diff --git a/.cargo/config.toml b/.cargo/config.toml
index a590c044d8..635229119f 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -3,3 +3,6 @@ rustflags = "-C link-arg=/STACK:8000000"
 
 [target.'cfg(all(target_os = "windows", not(target_env = "msvc")))']
 rustflags = "-C link-args=-Wl,--stack,8000000"
+
+[target.wasm32-unknown-unknown]
+rustflags = ["--cfg=getrandom_backend=\"wasm_js\""]
diff --git a/.claude/commands/upgrade-pylib.md b/.claude/commands/upgrade-pylib.md
new file mode 100644
index 0000000000..520d5deb7b
--- /dev/null
+++ b/.claude/commands/upgrade-pylib.md
@@ -0,0 +1,32 @@
+# Upgrade Python Library from CPython
+
+Upgrade a Python standard library module from CPython to RustPython.
+
+## Arguments
+- `$ARGUMENTS`: Library name to upgrade (e.g., `inspect`, `asyncio`, `json`)
+
+## Steps
+
+1. **Delete existing library in Lib/**
+   - If `Lib/$ARGUMENTS.py` exists, delete it
+   - If `Lib/$ARGUMENTS/` directory exists, delete it
+
+2. **Copy from cpython/Lib/**
+   - If `cpython/Lib/$ARGUMENTS.py` exists, copy it to `Lib/$ARGUMENTS.py`
+   - If `cpython/Lib/$ARGUMENTS/` directory exists, copy it to `Lib/$ARGUMENTS/`
+
+3. **Upgrade tests**
+   - Run: `python lib_updater.py --quick-upgrade cpython/Lib/test/test_$ARGUMENTS`
+   - This will update the test files with appropriate RustPython markers
+
+## Example Usage
+```
+/upgrade-pylib inspect
+/upgrade-pylib json
+/upgrade-pylib asyncio
+```
+
+## Notes
+- The cpython/ directory should contain the CPython source that we're syncing from
+- lib_updater.py handles adding `# TODO: RUSTPYTHON` markers and `@unittest.expectedFailure` decorators
+- After upgrading, you may need to run tests to verify: `cargo run --release -- -m test test_$ARGUMENTS`
diff --git a/.cspell.dict/cpython.txt b/.cspell.dict/cpython.txt
index 48059cf4e4..2ac19a4fca 100644
--- a/.cspell.dict/cpython.txt
+++ b/.cspell.dict/cpython.txt
@@ -1,18 +1,25 @@
 argtypes
 asdl
 asname
+attro
 augassign
+badcert
 badsyntax
 basetype
 boolop
 bxor
 cached_tsver
+cadata
+cafile
 cellarg
 cellvar
 cellvars
+CLASSDEREF
 cmpop
 denom
+DICTFLAG
 dictoffset
+distpoint
 elts
 excepthandler
 fileutils
@@ -24,28 +31,43 @@ fromlist
 heaptype
 HIGHRES
 IMMUTABLETYPE
+ismine
+Itertool
+keeped
 kwonlyarg
 kwonlyargs
 lasti
 linearise
+lsprof
 maxdepth
 mult
+multibytecodec
+newsemlockobject
 nkwargs
 noraise
 numer
 orelse
 pathconfig
 patma
+platstdlib
 posonlyarg
 posonlyargs
 prec
 preinitialized
+pydecimal
+pyrepl
+pythonw
 PYTHREAD_NAME
+releasebuffer
 SA_ONSTACK
+SOABI
 stackdepth
+stginfo
 stringlib
 structseq
 subparams
+swappedbytes
+ticketer
 tok_oldval
 tvars
 unaryop
@@ -53,9 +75,15 @@ unparse
 unparser
 VARKEYWORDS
 varkwarg
+venvlauncher
+venvlaunchert
+venvw
+venvwlauncher
+venvwlaunchert
 wbits
 weakreflist
+webpki
 withitem
 withs
 xstat
-XXPRIME
\ No newline at end of file
+XXPRIME
diff --git a/.cspell.dict/python-more.txt b/.cspell.dict/python-more.txt
index 8e1c012838..a13f345eec 100644
--- a/.cspell.dict/python-more.txt
+++ b/.cspell.dict/python-more.txt
@@ -4,6 +4,7 @@ aenter
 aexit
 aiter
 anext
+anextawaitable
 appendleft
 argcount
 arrayiterator
@@ -147,6 +148,7 @@ nbytes
 ncallbacks
 ndigits
 ndim
+needsfree
 nldecoder
 nlocals
 NOARGS
@@ -167,13 +169,17 @@ pycache
 pycodecs
 pycs
 pyexpat
+PYTHONAPI
 PYTHONBREAKPOINT
 PYTHONDEBUG
 PYTHONDONTWRITEBYTECODE
+PYTHONFAULTHANDLER
 PYTHONHASHSEED
 PYTHONHOME
 PYTHONINSPECT
 PYTHONINTMAXSTRDIGITS
+PYTHONIOENCODING
+PYTHONNODEBUGRANGES
 PYTHONNOUSERSITE
 PYTHONOPTIMIZE
 PYTHONPATH
@@ -195,6 +201,7 @@ readbuffer
 reconstructor
 refcnt
 releaselevel
+reraised
 reverseitemiterator
 reverseiterator
 reversekeyiterator
diff --git a/.cspell.dict/rust-more.txt b/.cspell.dict/rust-more.txt
index 6f89fdfafe..ff2013e81a 100644
--- a/.cspell.dict/rust-more.txt
+++ b/.cspell.dict/rust-more.txt
@@ -50,6 +50,7 @@ nanos
 nonoverlapping
 objclass
 peekable
+pemfile
 powc
 powf
 powi
@@ -61,6 +62,7 @@ rposition
 rsplitn
 rustc
 rustfmt
+rustls
 rustyline
 seedable
 seekfrom
@@ -80,6 +82,7 @@ unsync
 wasip1
 wasip2
 wasmbind
+wasmer
 wasmtime
 widestring
 winapi
diff --git a/.cspell.json b/.cspell.json
index 6112c35d59..89cde1ce77 100644
--- a/.cspell.json
+++ b/.cspell.json
@@ -60,6 +60,7 @@
     "dedentations",
     "dedents",
     "deduped",
+    "downcastable",
     "downcasted",
     "dumpable",
     "emscripten",
@@ -74,9 +75,9 @@
     "makeunicodedata",
     "miri",
     "notrace",
+    "oparg",
     "openat",
     "pyarg",
-    "pyarg",
     "pyargs",
     "pyast",
     "PyAttr",
@@ -106,6 +107,7 @@
     "pystruct",
     "pystructseq",
     "pytrace",
+    "pytype",
     "reducelib",
     "richcompare",
     "RustPython",
@@ -115,7 +117,6 @@
     "sysmodule",
     "tracebacks",
     "typealiases",
-    "unconstructible",
     "unhashable",
     "uninit",
     "unraisable",
@@ -123,6 +124,8 @@
     "wasi",
     "zelf",
     // unix
+    "posixshmem",
+    "shm",
     "CLOEXEC",
     "codeset",
     "endgrent",
@@ -130,6 +133,7 @@
     "getrusage",
     "nanosleep",
     "sigaction",
+    "sighandler",
     "WRLCK",
     // win32
     "birthtime",
diff --git a/.gitattributes b/.gitattributes
index f54bcd3b72..d1dd182a9b 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -5,3 +5,4 @@ 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
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index e175cd5184..4667f4ee17 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -44,7 +44,7 @@ cargo run -- script.py
 cargo run
 
 # With specific features
-cargo run --features ssl
+cargo run --features jit
 
 # Release mode (recommended for better performance)
 cargo run --release -- script.py
@@ -73,17 +73,28 @@ The `Lib/` directory contains Python standard library files copied from the CPyt
   - `unittest.skip("TODO: RustPython <reason>")`
   - `unittest.expectedFailure` with `# TODO: RUSTPYTHON <reason>` comment
 
+### Clean Build
+
+When you modify bytecode instructions, a full clean is required:
+
+```bash
+rm -r target/debug/build/rustpython-* && find . | grep -E "\.pyc$" | xargs rm -r
+```
+
 ### Testing
 
 ```bash
 # Run Rust unit tests
 cargo test --workspace --exclude rustpython_wasm
 
-# Run Python snippets tests
+# Run Python snippets tests (debug mode recommended for faster compilation)
+cargo run -- extra_tests/snippets/builtin_bytes.py
+
+# Run all Python snippets tests with pytest
 cd extra_tests
 pytest -v
 
-# Run the Python test module
+# Run the Python test module (release mode recommended for better performance)
 cargo run --release -- -m test ${TEST_MODULE}
 cargo run --release -- -m test test_unicode # to test test_unicode.py
 
@@ -91,6 +102,8 @@ cargo run --release -- -m test test_unicode # to test test_unicode.py
 cargo run --release -- -m test test_unicode -k test_unicode_escape
 ```
 
+**Note**: For `extra_tests/snippets` tests, use debug mode (`cargo run`) as compilation is faster. For `unittest` (`-m test`), use release mode (`cargo run --release`) for better runtime performance.
+
 ### Determining What to Implement
 
 Run `./whats_left.py` to get a list of unimplemented methods, which is helpful when looking for contribution opportunities.
@@ -176,12 +189,11 @@ cargo build --target wasm32-wasip1 --no-default-features --features freeze-stdli
 cargo run --features jit
 ```
 
-### SSL Support
+### Building venvlauncher (Windows)
 
-```bash
-# Enable SSL support
-cargo run --features ssl
-```
+See DEVELOPMENT.md "CPython Version Upgrade Checklist" section.
+
+**IMPORTANT**: All 4 venvlauncher binaries use the same source code. Do NOT add multiple `[[bin]]` entries to Cargo.toml. Build once and copy with different names.
 
 ## Test Code Modification Rules
 
@@ -206,7 +218,7 @@ cargo run --features ssl
 
 ## Documentation
 
-- Check the [architecture document](architecture/architecture.md) for a high-level overview
-- Read the [development guide](DEVELOPMENT.md) for detailed setup instructions
+- Check the [architecture document](/architecture/architecture.md) for a high-level overview
+- Read the [development guide](/DEVELOPMENT.md) for detailed setup instructions
 - Generate documentation with `cargo doc --no-deps --all`
-- Online documentation is available at [docs.rs/rustpython](https://docs.rs/rustpython/)
\ No newline at end of file
+- Online documentation is available at [docs.rs/rustpython](https://docs.rs/rustpython/)
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index be006de9a1..b3b7b446e4 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,13 +1,15 @@
-# Keep GitHub Actions up to date with GitHub's Dependabot...
-# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
-# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
 version: 2
 updates:
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly
+    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_*" 
   - package-ecosystem: github-actions
     directory: /
-    groups:
-      github-actions:
-        patterns:
-          - "*"  # Group all Actions updates into a single larger pull request
     schedule:
       interval: weekly
diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index fec9d4d838..b8263026d5 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -16,18 +16,20 @@ concurrency:
   cancel-in-progress: true
 
 env:
-  CARGO_ARGS: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,ssl
+  CARGO_ARGS: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite,ssl-rustls
+  CARGO_ARGS_NO_SSL: --no-default-features --features stdlib,importlib,stdio,encodings,sqlite
+  # Crates excluded from workspace builds:
+  # - rustpython_wasm: requires wasm target
+  # - rustpython-compiler-source: deprecated
+  # - rustpython-venvlauncher: Windows-only
+  WORKSPACE_EXCLUDES: --exclude rustpython_wasm --exclude rustpython-compiler-source --exclude rustpython-venvlauncher
   # Skip additional tests on Windows. They are checked on Linux and MacOS.
   # test_glob: many failing tests
-  # test_io: many failing tests
-  # test_os: many failing tests
-  # test_pathlib: support.rmtree() failing
+  # 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_glob
-    test_io
-    test_os
     test_rlcompleter
     test_pathlib
     test_posixpath
@@ -103,8 +105,19 @@ env:
     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.13.1"
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_INCLUDE_DIR: C:\Program Files\OpenSSL\include
 
 jobs:
   rust_tests:
@@ -112,55 +125,61 @@ jobs:
     env:
       RUST_BACKTRACE: full
     name: Run rust tests
-    runs-on:  ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 45
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
+        os: [macos-latest, ubuntu-latest, windows-2025]
       fail-fast: false
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
       - uses: Swatinem/rust-cache@v2
 
-      - name: Set up the Windows environment
-        shell: bash
-        run: |
-          git config --system core.longpaths true
-          cargo install --target-dir=target -v cargo-vcpkg
-          cargo vcpkg -v build
-        if: runner.os == 'Windows'
       - name: Set up the Mac environment
         run: brew install autoconf automake libtool
         if: runner.os == 'macOS'
 
       - name: run clippy
-        run: cargo clippy ${{ env.CARGO_ARGS }} --workspace --all-targets --exclude rustpython_wasm -- -Dwarnings
+        run: cargo clippy ${{ env.CARGO_ARGS }} --workspace --all-targets ${{ env.WORKSPACE_EXCLUDES }} -- -Dwarnings
 
       - name: run rust tests
-        run: cargo test --workspace --exclude rustpython_wasm --verbose --features threading ${{ env.CARGO_ARGS }}
+        run: cargo test --workspace ${{ env.WORKSPACE_EXCLUDES }} --verbose --features threading ${{ env.CARGO_ARGS }}
         if: runner.os != 'macOS'
       - name: run rust tests
-        run: cargo test --workspace --exclude rustpython_wasm --exclude rustpython-jit --verbose --features threading  ${{ env.CARGO_ARGS }}
+        run: cargo test --workspace ${{ env.WORKSPACE_EXCLUDES }} --exclude rustpython-jit --verbose --features threading ${{ env.CARGO_ARGS }}
         if: runner.os == 'macOS'
 
       - name: check compilation without threading
         run: cargo check ${{ env.CARGO_ARGS }}
 
+      - name: Test openssl build
+        run: cargo build --no-default-features --features ssl-openssl
+        if: runner.os == 'Linux'
+
+      # - name: Install tk-dev for tkinter build
+      #   run: sudo apt-get update && sudo apt-get install -y tk-dev
+      #   if: runner.os == 'Linux'
+
+      # - name: Test tkinter build
+      #   run: cargo build --features tkinter
+      #   if: runner.os == 'Linux'
+
       - name: Test example projects
-        run:
+        run: |
           cargo run --manifest-path example_projects/barebone/Cargo.toml
           cargo run --manifest-path example_projects/frozen_stdlib/Cargo.toml
         if: runner.os == 'Linux'
 
-      - name: prepare AppleSilicon build
+      - name: prepare Intel MacOS build
         uses: dtolnay/rust-toolchain@stable
         with:
-          target: aarch64-apple-darwin
+          target: x86_64-apple-darwin
         if: runner.os == 'macOS'
-      - name: Check compilation for Apple Silicon
-        run: cargo check --target aarch64-apple-darwin
+      - name: Check compilation for Intel MacOS
+        run: cargo check --target x86_64-apple-darwin
         if: runner.os == 'macOS'
       - name: prepare iOS build
         uses: dtolnay/rust-toolchain@stable
@@ -168,15 +187,16 @@ jobs:
           target: aarch64-apple-ios
         if: runner.os == 'macOS'
       - name: Check compilation for iOS
-        run: cargo check --target aarch64-apple-ios
+        run: cargo check --target aarch64-apple-ios ${{ env.CARGO_ARGS_NO_SSL }}
         if: runner.os == 'macOS'
 
   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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: i686-unknown-linux-gnu
@@ -184,14 +204,14 @@ jobs:
       - 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
+        run: cargo check --target i686-unknown-linux-gnu ${{ env.CARGO_ARGS_NO_SSL }}
 
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: aarch64-linux-android
 
       - name: Check compilation for android
-        run: cargo check --target aarch64-linux-android
+        run: cargo check --target aarch64-linux-android ${{ env.CARGO_ARGS_NO_SSL }}
 
       - uses: dtolnay/rust-toolchain@stable
         with:
@@ -200,28 +220,28 @@ jobs:
       - 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
+        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
+        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
+        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
+        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
@@ -236,25 +256,18 @@ jobs:
     env:
       RUST_BACKTRACE: full
     name: Run snippets and cpython tests
-    runs-on:  ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
+        os: [macos-latest, ubuntu-latest, windows-2025]
       fail-fast: false
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-      - name: Set up the Windows environment
-        shell: bash
-        run: |
-          git config --system core.longpaths true
-          cargo install cargo-vcpkg
-          cargo vcpkg build
-        if: runner.os == 'Windows'
       - name: Set up the Mac environment
         run: brew install autoconf automake libtool openssl@3
         if: runner.os == 'macOS'
@@ -264,34 +277,132 @@ jobs:
       - name: build rustpython
         run: cargo build --release --verbose --features=threading ${{ env.CARGO_ARGS }},jit
         if: runner.os != 'macOS'
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - 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
-        run:
-          target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed -v ${{ env.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)
-        run: target/release/rustpython -m test -j 1 -u all --slowest --fail-env-changed -v -x ${{ env.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 -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+        timeout-minutes: 45
+
       - if: runner.os == 'macOS'
         name: run cpython platform-dependent tests (MacOS)
-        run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }}
+        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)
-        run:
-          target/release/rustpython -m test -j 1 --slowest --fail-env-changed -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
+        env:
+          RUSTPYTHON_SKIP_ENV_POLLUTERS: true
+        run: target/release/rustpython -m test -j 1 --slowest --fail-env-changed --timeout 600 -v -x ${{ env.PLATFORM_INDEPENDENT_TESTS }} ${{ env.WINDOWS_SKIPS }}
+        timeout-minutes: 45
+
+      - if: runner.os == 'Linux'
+        name: run cpython tests to check if env polluters have stopped polluting (Common/Linux)
+        shell: bash
+        run: |
+          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_LINUX }}; do
+            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
+
+      - if: runner.os == 'macOS'
+        name: run cpython tests to check if env polluters have stopped polluting (Common/macOS)
+        shell: bash
+        run: |
+          for thing in ${{ env.ENV_POLLUTING_TESTS_COMMON }} ${{ env.ENV_POLLUTING_TESTS_MACOS }}; do
+            for i in $(seq 1 10); do
+              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_MACOS in '.github/workflows/ci.yaml'."
+              echo "Please also remove the skip decorators that include the word 'POLLUTERS' in ${thing}."
+              if [ ${exit_code} -ne 0 ]; then
+                echo "Test ${thing} failed with exit code ${exit_code}."
+                echo "Please investigate which test item in ${thing} is failing and either mark it as an expected failure or a skip."
+              fi
+              exit 1
+            fi
+          done
+        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
+                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: check that --install-pip succeeds
         run: |
           mkdir site-packages
           target/release/rustpython --install-pip ensurepip --user
           target/release/rustpython -m pip install six
-      - if: runner.os != 'Windows'
-        name: Check that ensurepip succeeds.
+      - name: Check that ensurepip succeeds.
         run: |
           target/release/rustpython -m ensurepip
           target/release/rustpython -c "import pip"
@@ -304,30 +415,40 @@ jobs:
         run: python -I whats_left.py
 
   lint:
-    name: Check Rust code with rustfmt and clippy
+    name: Check Rust code with clippy
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
-            components: rustfmt, clippy
-      - name: run rustfmt
-        run: cargo fmt --check
+          components: clippy
+
       - name: run clippy on wasm
-        run: cargo clippy --manifest-path=wasm/lib/Cargo.toml -- -Dwarnings
-      - uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: install ruff
-        run: python -m pip install ruff==0.11.8
+        run: cargo clippy --manifest-path=crates/wasm/Cargo.toml -- -Dwarnings
+
       - name: Ensure docs generate no warnings
         run: cargo doc
-      - name: run ruff check
-        run: ruff check --diff
-      - name: run ruff format
-        run: ruff format --check
+
+      - name: Ensure Lib/_opcode_metadata is updated
+        run: |
+          python scripts/generate_opcode_metadata.py
+          if [ -n "$(git status --porcelain)" ]; then
+            exit 1
+          fi
+
+      - name: Install ruff
+        uses: astral-sh/ruff-action@57714a7c8a2e59f32539362ba31877a1957dded1 # v3.5.1
+        with:
+          version: "0.14.11"
+          args: "--version"
+
+      - run: ruff check --diff
+
+      - run: ruff format --check
+
       - name: install prettier
         run: yarn global add prettier && echo "$(yarn global bin)" >>$GITHUB_PATH
+
       - 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
@@ -335,34 +456,42 @@ jobs:
       - 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@v7
+        uses: streetsidesoftware/cspell-action@v8
         with:
-          files: '**/*.rs'
+          files: "**/*.rs"
           incremental_files_only: true
 
   miri:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     name: Run tests under miri
     runs-on: ubuntu-latest
+    timeout-minutes: 30
+    env:
+      NIGHTLY_CHANNEL: nightly
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
+
       - uses: dtolnay/rust-toolchain@master
         with:
-            toolchain: nightly
-            components: miri
+          toolchain: ${{ env.NIGHTLY_CHANNEL }}
+          components: miri
 
       - uses: Swatinem/rust-cache@v2
+
       - name: Run tests under miri
-        # miri-ignore-leaks because the type-object circular reference means that there will always be
-        # a memory leak, at least until we have proper cyclic gc
-        run: MIRIFLAGS='-Zmiri-ignore-leaks' cargo +nightly miri test -p rustpython-vm -- miri_test
+        run: cargo +${{ env.NIGHTLY_CHANNEL }} miri test -p rustpython-vm -- miri_test
+        env:
+          # miri-ignore-leaks because the type-object circular reference means that there will always be
+          # a memory leak, at least until we have proper cyclic gc
+          MIRIFLAGS: "-Zmiri-ignore-leaks"
 
   wasm:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     name: Check the WASM package and demo
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
 
       - uses: Swatinem/rust-cache@v2
@@ -373,12 +502,12 @@ 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@v5
+      - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - run: python -m pip install -r requirements.txt
         working-directory: ./wasm/tests
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         with:
           cache: "npm"
           cache-dependency-path: "wasm/demo/package-lock.json"
@@ -394,11 +523,13 @@ jobs:
         with: { wabt-version: "1.0.36" }
       - name: check wasm32-unknown without js
         run: |
-          cd wasm/wasm-unknown-test
-          cargo build --release --verbose
-          if wasm-objdump -xj Import target/wasm32-unknown-unknown/release/wasm_unknown_test.wasm; then
-            echo "ERROR: wasm32-unknown module expects imports from the host environment" >2
+          cd example_projects/wasm32_without_js/rustpython-without-js
+          cargo build
+          cd ..
+          if wasm-objdump -xj Import rustpython-without-js/target/wasm32-unknown-unknown/debug/rustpython_without_js.wasm; then
+            echo "ERROR: wasm32-unknown module expects imports from the host environment" >&2
           fi
+          cargo run --release --manifest-path wasm-runtime/Cargo.toml rustpython-without-js/target/wasm32-unknown-unknown/debug/rustpython_without_js.wasm
       - name: build notebook demo
         if: github.ref == 'refs/heads/release'
         run: |
@@ -421,8 +552,9 @@ jobs:
     if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
     name: Run snippets and cpython tests on wasm-wasi
     runs-on: ubuntu-latest
+    timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
           target: wasm32-wasip1
diff --git a/.github/workflows/comment-commands.yml b/.github/workflows/comment-commands.yml
new file mode 100644
index 0000000000..d1a457c73e
--- /dev/null
+++ b/.github/workflows/comment-commands.yml
@@ -0,0 +1,21 @@
+name: Comment Commands
+
+on:
+  issue_comment:
+    types: created
+
+jobs:
+  issue_assign:
+    if: (!github.event.issue.pull_request) && github.event.comment.body == 'take'
+    runs-on: ubuntu-latest
+
+    concurrency:
+      group: ${{ github.actor }}-issue-assign
+
+    permissions:
+      issues: write
+
+    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
diff --git a/.github/workflows/cron-ci.yaml b/.github/workflows/cron-ci.yaml
index 6389fee1cb..d48c5e4cfe 100644
--- a/.github/workflows/cron-ci.yaml
+++ b/.github/workflows/cron-ci.yaml
@@ -1,15 +1,18 @@
 on:
   schedule:
-    - cron: '0 0 * * 6'
+    - cron: "0 0 * * 6"
   workflow_dispatch:
   push:
     paths:
       - .github/workflows/cron-ci.yaml
+  pull_request:
+    paths:
+      - .github/workflows/cron-ci.yaml
 
 name: Periodic checks/tasks
 
 env:
-  CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl,jit
+  CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
   PYTHON_VERSION: "3.13.1"
 
 jobs:
@@ -18,25 +21,28 @@ jobs:
   codecov:
     name: Collect code coverage data
     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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
       - uses: taiki-e/install-action@cargo-llvm-cov
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - run: sudo apt-get update && sudo apt-get -y install lcov
       - name: Run cargo-llvm-cov with Rust tests.
-        run: cargo llvm-cov --no-report --workspace --exclude rustpython_wasm --verbose --no-default-features --features stdlib,importlib,encodings,ssl,jit
+        run: cargo llvm-cov --no-report --workspace --exclude rustpython_wasm --exclude rustpython-compiler-source --exclude rustpython-venvlauncher --verbose --no-default-features --features stdlib,importlib,encodings,ssl-rustls,jit
       - name: Run cargo-llvm-cov with Python snippets.
         run: python scripts/cargo-llvm-cov.py
         continue-on-error: true
       - name: Run cargo-llvm-cov with Python test suite.
-        run: cargo llvm-cov --no-report run -- -m test -u all --slowest --fail-env-changed 
+        run: cargo llvm-cov --no-report run -- -m test -u all --slowest --fail-env-changed
         continue-on-error: true
       - name: Prepare code coverage data
         run: cargo llvm-cov report --lcov --output-path='codecov.lcov'
       - name: Upload to Codecov
+        if: ${{ github.event_name != 'pull_request' }}
         uses: codecov/codecov-action@v5
         with:
           file: ./codecov.lcov
@@ -44,8 +50,10 @@ jobs:
   testdata:
     name: Collect regression test data
     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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
       - name: build rustpython
         run: cargo build --release --verbose
@@ -54,6 +62,7 @@ jobs:
         env:
           RUSTPYTHONPATH: ${{ github.workspace }}/Lib
       - name: upload tests data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
           GITHUB_ACTOR: ${{ github.actor }}
@@ -73,10 +82,12 @@ jobs:
   whatsleft:
     name: Collect what is left data
     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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6.1.0
         with:
           python-version: ${{ env.PYTHON_VERSION }}
       - name: build rustpython
@@ -88,6 +99,7 @@ jobs:
         env:
           RUSTPYTHONPATH: ${{ github.workspace }}/Lib
       - name: Upload data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
           GITHUB_ACTOR: ${{ github.actor }}
@@ -103,6 +115,23 @@ jobs:
           rm ./_data/whats_left/modules.csv
           echo -e "module" > ./_data/whats_left/modules.csv
           cat ./_data/whats_left.temp | grep "(entire module)" | cut -d ' ' -f 1 | sort >> ./_data/whats_left/modules.csv
+          awk -f - ./_data/whats_left.temp > ./_data/whats_left/builtin_items.csv <<'EOF'
+          BEGIN {
+              OFS=","
+              print "builtin,name,is_inherited"
+          }
+          /^# builtin items/ { in_section=1; next }
+          /^$/ { if (in_section) exit }
+          in_section {
+              split($1, a, ".")
+              rest = ""
+              idx = index($0, " ")
+              if (idx > 0) {
+                  rest = substr($0, idx+1)
+              }
+              print a[1], $1, rest
+          }
+          EOF
           git add -A
           if git -c user.name="Github Actions" -c user.email="actions@github.com" commit -m "Update what is left results" --author="$GITHUB_ACTOR"; then
             git push
@@ -111,12 +140,14 @@ jobs:
   benchmark:
     name: Collect benchmark data
     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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6.1.0
         with:
-          python-version: 3.9
+          python-version: ${{ env.PYTHON_VERSION }}
       - run: cargo install cargo-criterion
       - name: build benchmarks
         run: cargo build --release --benches
@@ -137,6 +168,7 @@ jobs:
           mv reports/* .
           rmdir reports
       - name: upload benchmark data to the website
+        if: ${{ github.event_name != 'pull_request' }}
         env:
           SSHKEY: ${{ secrets.ACTIONS_TESTS_DATA_DEPLOY_KEY }}
         run: |
diff --git a/.github/workflows/pr-auto-commit.yaml b/.github/workflows/pr-auto-commit.yaml
new file mode 100644
index 0000000000..d4d97b19d1
--- /dev/null
+++ b/.github/workflows/pr-auto-commit.yaml
@@ -0,0 +1,121 @@
+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:
+    if: ${{ !contains(github.event.pull_request.labels.*.name, 'skip:ci') }}
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v6.0.1
+        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 f6a1ad3209..c11d11d980 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,10 +17,14 @@ permissions:
 
 env:
   CARGO_ARGS: --no-default-features --features stdlib,importlib,encodings,sqlite,ssl
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_LIB_DIR: C:\Program Files\OpenSSL\lib\VC\x64\MD
+  X86_64_PC_WINDOWS_MSVC_OPENSSL_INCLUDE_DIR: C:\Program Files\OpenSSL\include
 
 jobs:
   build:
     runs-on: ${{ matrix.platform.runner }}
+    # Disable this scheduled job when running on a fork.
+    if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     strategy:
       matrix:
         platform:
@@ -40,28 +44,21 @@ jobs:
             target: aarch64-apple-darwin
 #          - runner: macos-latest
 #            target: x86_64-apple-darwin
-          - runner: windows-latest
+          - runner: windows-2025
             target: x86_64-pc-windows-msvc
-#          - runner: windows-latest
+#          - runner: windows-2025
 #            target: i686-pc-windows-msvc
-#          - runner: windows-latest
+#          - runner: windows-2025
 #            target: aarch64-pc-windows-msvc
       fail-fast: false
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
       - uses: cargo-bins/cargo-binstall@main
 
       - name: Set up Environment
         shell: bash
         run: rustup target add ${{ matrix.platform.target }}
-      - name: Set up Windows Environment
-        shell: bash
-        run: |
-          git config --global core.longpaths true
-          cargo install --target-dir=target -v cargo-vcpkg
-          cargo vcpkg -v build
-        if: runner.os == 'Windows'
       - name: Set up MacOS Environment
         run: brew install autoconf automake libtool
         if: runner.os == 'macOS'
@@ -81,15 +78,17 @@ jobs:
         if: runner.os == 'Windows'
 
       - name: Upload Binary Artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6.0.0
         with:
           name: rustpython-release-${{ runner.os }}-${{ matrix.platform.target }}
           path: target/rustpython-release-${{ runner.os }}-${{ matrix.platform.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@v4
+      - uses: actions/checkout@v6.0.1
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: wasm32-wasip1
@@ -101,14 +100,14 @@ jobs:
         run: cp target/wasm32-wasip1/release/rustpython.wasm target/rustpython-release-wasm32-wasip1.wasm
 
       - name: Upload Binary Artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6.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@v4
+      - uses: actions/setup-node@v6
       - uses: mwilliamson/setup-wabt-action@v3
         with: { wabt-version: "1.0.30" }
       - name: build demo
@@ -136,15 +135,23 @@ jobs:
 
   release:
     runs-on: ubuntu-latest
+    # Disable this scheduled job when running on a fork.
+    if: ${{ github.repository == 'RustPython/RustPython' || github.event_name != 'schedule' }}
     needs: [build, build-wasm]
     steps:
+      - uses: actions/checkout@v6.0.1
+
       - name: Download Binary Artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7.0.0
         with:
           path: bin
           pattern: rustpython-*
           merge-multiple: true
 
+      - name: Create Lib Archive
+        run: |
+          zip -r bin/rustpython-lib.zip Lib/
+
       - name: List Binaries
         run: |
           ls -lah bin/
@@ -168,6 +175,7 @@ jobs:
               --repo="$GITHUB_REPOSITORY" \
               --title="RustPython $RELEASE_TYPE_NAME $today-$tag #$run" \
               --target="$tag" \
+              --notes "⚠️ **Important**: To run RustPython, you must download both the binary for your platform AND the \`rustpython-lib.zip\` archive. Extract the Lib directory from the archive to the same location as the binary, or set the \`RUSTPYTHONPATH\` environment variable to point to the Lib directory." \
               --generate-notes \
               $PRERELEASE_ARG \
               bin/rustpython-release-*
diff --git a/.github/workflows/update-doc-db.yml b/.github/workflows/update-doc-db.yml
new file mode 100644
index 0000000000..c580e7d0ea
--- /dev/null
+++ b/.github/workflows/update-doc-db.yml
@@ -0,0 +1,108 @@
+name: Update doc DB
+
+permissions:
+  contents: write
+
+on:
+  workflow_dispatch:
+    inputs:
+      python-version:
+        description: Target python version to generate doc db for
+        type: string
+        default: "3.13.9"
+      ref:
+        description: Branch to commit to (leave empty for current branch)
+        type: string
+        default: ""
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  generate:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+          sparse-checkout: |
+            crates/doc
+
+      - uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        with:
+          python-version: ${{ inputs.python-version }}
+
+      - name: Generate docs
+        run: python crates/doc/generate.py
+
+      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: doc-db-${{ inputs.python-version }}-${{ matrix.os }}
+          path: "crates/doc/generated/*.json"
+          if-no-files-found: error
+          retention-days: 7
+          overwrite: true
+
+  merge:
+    runs-on: ubuntu-latest
+    needs: generate
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+          token: ${{ secrets.AUTO_COMMIT_PAT }}
+
+      - name: Download generated doc DBs
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          pattern: "doc-db-${{ inputs.python-version }}-**"
+          path: crates/doc/generated/
+          merge-multiple: true
+
+      - name: Transform JSON
+        run: |
+          # Merge all artifacts
+          jq -s "add" --sort-keys crates/doc/generated/*.json > crates/doc/generated/merged.json
+
+          # Format merged json for the phf macro
+          jq -r 'to_entries[] | "    \(.key | @json) => \(.value | @json),"' crates/doc/generated/merged.json > crates/doc/generated/raw_entries.txt
+
+          OUTPUT_FILE='crates/doc/src/data.inc.rs'
+
+          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 '// spell-checker: disable' >> $OUTPUT_FILE
+
+          echo '' >> $OUTPUT_FILE
+
+          echo "pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {" >> $OUTPUT_FILE
+          cat crates/doc/generated/raw_entries.txt >> $OUTPUT_FILE
+          echo '};' >> $OUTPUT_FILE
+
+      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: doc-db-${{ inputs.python-version }}
+          path: "crates/doc/src/data.inc.rs"
+          if-no-files-found: error
+          retention-days: 7
+          overwrite: true
+
+      - name: Commit and push (non-main branches only)
+        if: github.ref != 'refs/heads/main' && inputs.ref != 'main'
+        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
+          fi
diff --git a/.gitignore b/.gitignore
index cb7165aaca..fea93ace80 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,3 +21,8 @@ flamescope.json
 
 extra_tests/snippets/resources
 extra_tests/not_impl.py
+
+Lib/site-packages/*
+!Lib/site-packages/README.txt
+Lib/test/data/*
+!Lib/test/data/README
diff --git a/.vscode/launch.json b/.vscode/launch.json
index fa6f96c5fd..6e00e14aff 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -16,18 +16,6 @@
             },
             "cwd": "${workspaceFolder}"
         },
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug executable 'rustpython' without SSL",
-            "preLaunchTask": "Build RustPython Debug without SSL",
-            "program": "target/debug/rustpython",
-            "args": [],
-            "env": {
-                "RUST_BACKTRACE": "1"
-            },
-            "cwd": "${workspaceFolder}"
-        },
         {
             "type": "lldb",
             "request": "launch",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 18a3d6010d..50a52aaf8b 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -1,28 +1,12 @@
 {
     "version": "2.0.0",
     "tasks": [
-        {
-            "label": "Build RustPython Debug without SSL",
-            "type": "shell",
-            "command": "cargo",
-            "args": [
-                "build",
-            ],
-            "problemMatcher": [
-                "$rustc",
-            ],
-            "group": {
-                "kind": "build",
-                "isDefault": true,
-            },
-        },
         {
             "label": "Build RustPython Debug",
             "type": "shell",
             "command": "cargo",
             "args": [
                 "build",
-                "--features=ssl"
             ],
             "problemMatcher": [
                 "$rustc",
diff --git a/Cargo.lock b/Cargo.lock
index c6dee806c7..1ce839a96d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 4
 
 [[package]]
 name = "adler2"
-version = "2.0.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "adler32"
@@ -14,6 +14,17 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
 
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
 [[package]]
 name = "ahash"
 version = "0.8.12"
@@ -21,7 +32,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
  "cfg-if",
- "getrandom 0.3.2",
+ "getrandom 0.3.4",
  "once_cell",
  "version_check",
  "zerocopy",
@@ -29,24 +40,27 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.3"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "allocator-api2"
-version = "0.2.21"
+name = "alloca"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+checksum = "e5a7d05ea6aea7e9e64d25b9156ba2fee3fdd659e34e41063cd2fc7cd020d7f4"
+dependencies = [
+ "cc",
+]
 
 [[package]]
-name = "android-tzdata"
-version = "0.1.1"
+name = "allocator-api2"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
 name = "android_system_properties"
@@ -65,9 +79,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
 
 [[package]]
 name = "anstream"
-version = "0.6.18"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -80,44 +94,44 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.10"
+version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.6"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.2"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.7"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
- "once_cell",
- "windows-sys 0.59.0",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
 [[package]]
 name = "approx"
@@ -130,9 +144,9 @@ dependencies = [
 
 [[package]]
 name = "arbitrary"
-version = "1.4.1"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dde20b3d026af13f561bdd0f15edf01fc734f0dafcedbaf42bba506a9517f223"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 
 [[package]]
 name = "ascii"
@@ -141,19 +155,126 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"
 
 [[package]]
-name = "atomic"
+name = "asn1-rs"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56624a96882bb8c26d61312ae18cb45868e5a9992ea73c58e45c3101e56a1e60"
+dependencies = [
+ "asn1-rs-derive",
+ "asn1-rs-impl",
+ "displaydoc",
+ "nom",
+ "num-traits",
+ "rusticata-macros",
+ "thiserror 2.0.17",
+ "time",
+]
+
+[[package]]
+name = "asn1-rs-derive"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d818003e740b63afc82337e3160717f4f63078720a810b7b903e70a5d1d2994"
+checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "asn1-rs-impl"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "atomic"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
 dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "attribute-derive"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05832cdddc8f2650cc2cc187cc2e952b8c133a48eb055f35211f61ee81502d77"
+dependencies = [
+ "attribute-derive-macro",
+ "derive-where",
+ "manyhow",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "attribute-derive-macro"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a7cdbbd4bd005c5d3e2e9c885e6fa575db4f4a3572335b974d8db853b6beb61"
+dependencies = [
+ "collection_literals",
+ "interpolator",
+ "manyhow",
+ "proc-macro-utils",
+ "proc-macro2",
+ "quote",
+ "quote-use",
+ "syn",
+]
+
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "aws-lc-fips-sys"
+version = "0.13.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "57900537c00a0565a35b63c4c281b372edfc9744b072fd4a3b414350a8f5ed48"
+dependencies = [
+ "bindgen 0.72.1",
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+ "regex",
+]
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a88aab2464f1f25453baa7a07c84c5b7684e274054ba06817f382357f77a288"
+dependencies = [
+ "aws-lc-fips-sys",
+ "aws-lc-sys",
+ "untrusted 0.7.1",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b45afffdee1e7c9126814751f88dddc747f41d91da16c9551a0f1e8a11e788a1"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
 
 [[package]]
 name = "base64"
@@ -161,13 +282,19 @@ version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
+[[package]]
+name = "base64ct"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e050f626429857a27ddccb31e0aca21356bfa709c04041aefddac081a8f068a"
+
 [[package]]
 name = "bindgen"
 version = "0.71.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -178,7 +305,27 @@ dependencies = [
  "regex",
  "rustc-hash",
  "shlex",
- "syn 2.0.101",
+ "syn",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.72.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
+dependencies = [
+ "bitflags 2.10.0",
+ "cexpr",
+ "clang-sys",
+ "itertools 0.13.0",
+ "log",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
 ]
 
 [[package]]
@@ -189,9 +336,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.0"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "blake2"
@@ -211,11 +358,20 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bstr"
-version = "1.12.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "234113d19d0d7d613b40e86fb654acf958910802bcceab913a4f9e7cda03b1a4"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -224,37 +380,32 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.17.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1628fb46dfa0b37568d12e5edd512553eccf6a22a78e8bde00bb4aed84d5bdbf"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 dependencies = [
  "allocator-api2",
 ]
 
 [[package]]
 name = "bytemuck"
-version = "1.23.0"
+version = "1.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9134a6ef01ce4b366b50689c94f82c14bc72bc5d0386829828a2e2752ef7958c"
+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
 
 [[package]]
-name = "bzip2"
-version = "0.5.2"
+name = "bytes"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47"
-dependencies = [
- "bzip2-sys",
- "libbz2-rs-sys",
-]
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
 
 [[package]]
-name = "bzip2-sys"
-version = "0.1.13+1.0.8"
+name = "bzip2"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
 dependencies = [
- "cc",
- "pkg-config",
+ "libbz2-rs-sys",
 ]
 
 [[package]]
@@ -274,22 +425,40 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "castaway"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0abae9be0aaf9ea96a3b1b8b1b55c602ca751eba1b1500220cea4ecbafe7c0d5"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
 dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher",
+]
+
 [[package]]
 name = "cc"
-version = "1.2.21"
+version = "1.2.51"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8691782945451c1c383942c4874dbe63814f61cb57ef773cda2972682b7bb3c0"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
 dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
  "shlex",
 ]
 
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
 [[package]]
 name = "cexpr"
 version = "0.6.0"
@@ -301,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.0"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
@@ -313,11 +482,10 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
-version = "0.4.41"
+version = "0.4.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c469d952047f47f91b68d1cba3f10d63c11d73e4636f24f08daf0278abf01c4d"
+checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
 dependencies = [
- "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
@@ -352,6 +520,16 @@ dependencies = [
  "half",
 ]
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.8.1"
@@ -360,23 +538,23 @@ checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
  "glob",
  "libc",
- "libloading",
+ "libloading 0.8.9",
 ]
 
 [[package]]
 name = "clap"
-version = "4.5.38"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
 dependencies = [
  "clap_builder",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.5.38"
+version = "4.5.53"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -384,30 +562,55 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
 
 [[package]]
 name = "clipboard-win"
-version = "5.4.0"
+version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15efe7a882b08f34e38556b14f2fb3daa98769d06c7f0c1b076dfd0d983bc892"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
 dependencies = [
  "error-code",
 ]
 
 [[package]]
-name = "colorchoice"
+name = "cmake"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "collection_literals"
 version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+checksum = "2550f75b8cfac212855f6b1885455df8eaee8fe8e246b647d69146142e016084"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "memchr",
+]
 
 [[package]]
 name = "compact_str"
-version = "0.8.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b79c4069c6cad78e2e0cdfcbd26275770669fb39fd308a752dc110e83b9af32"
+checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
 dependencies = [
  "castaway",
  "cfg-if",
@@ -439,6 +642,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
 [[package]]
 name = "constant_time_eq"
 version = "0.4.2"
@@ -455,6 +664,16 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -472,9 +691,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d07c374d4da962eca0833c1d14621d5b4e32e68c8ca185b046a3b6b924ad334"
+checksum = "9849e5e1589a1d7b9e8a27cbf55747bd5d262ed72ac06c97d824adfc97a93652"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
@@ -483,42 +702,42 @@ dependencies = [
 
 [[package]]
 name = "cranelift-assembler-x64"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "263cc79b8a23c29720eb596d251698f604546b48c34d0d84f8fd2761e5bf8888"
+checksum = "ff9edf1a79ff137b5c9bc74aff5d8467a8bea67722d9f4a2a0dc555504e8dc66"
 dependencies = [
  "cranelift-assembler-x64-meta",
 ]
 
 [[package]]
 name = "cranelift-assembler-x64-meta"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b4a113455f8c0e13e3b3222a9c38d6940b958ff22573108be083495c72820e1"
+checksum = "0ed408aad286cb6433f3e361268b588566ac138dc0d8cf1c22af822c004250ad"
 dependencies = [
  "cranelift-srcgen",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f96dca41c5acf5d4312c1d04b3391e21a312f8d64ce31a2723a3bb8edd5d4d"
+checksum = "efddb47bd7fc6fb0fe9387a82c4cf1987b7402fefa694f73be1f3ae2b26663ab"
 dependencies = [
  "cranelift-entity",
 ]
 
 [[package]]
 name = "cranelift-bitset"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d821ed698dd83d9c012447eb63a5406c1e9c23732a2f674fb5b5015afd42202"
+checksum = "2922de888b20fedaff065be5a4044f5c3c13cb1132db8f1f56f7a5c03a768c81"
 
 [[package]]
 name = "cranelift-codegen"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06c52fdec4322cb8d5545a648047819aaeaa04e630f88d3a609c0d3c1a00e9a0"
+checksum = "0d3172ca7ba0bf31cae6dd4dffbfc33e0afe5994eb3ec29608d0ab14bcb674cb"
 dependencies = [
  "bumpalo",
  "cranelift-assembler-x64",
@@ -530,55 +749,57 @@ dependencies = [
  "cranelift-entity",
  "cranelift-isle",
  "gimli",
- "hashbrown",
+ "hashbrown 0.15.5",
  "log",
  "regalloc2",
  "rustc-hash",
  "serde",
  "smallvec",
  "target-lexicon",
+ "wasmtime-internal-math",
 ]
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af2c215e0c9afa8069aafb71d22aa0e0dde1048d9a5c3c72a83cacf9b61fcf4a"
+checksum = "e2bad8d14320124ea673cb11b7db0176470279b7ec1d0f201f79a7c0213f52f6"
 dependencies = [
  "cranelift-assembler-x64-meta",
  "cranelift-codegen-shared",
  "cranelift-srcgen",
+ "heck",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97524b2446fc26a78142132d813679dda19f620048ebc9a9fbb0ac9f2d320dcb"
+checksum = "c414fe1c62e61d269a928594bd0f10fb6fa707e112b433fc19cc8d5aeaf08fda"
 
 [[package]]
 name = "cranelift-control"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e32e900aee81f9e3cc493405ef667a7812cb5c79b5fc6b669e0a2795bda4b22"
+checksum = "fac90ac0e9a0dd900a880ee6b56f36e37ca5017af9f7d1390805dcb6f35e4064"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d16a2e28e0fa6b9108d76879d60fe1cc95ba90e1bcf52bac96496371044484ee"
+checksum = "5c63209c9b060b3048b2cc6483bdba85e93118268d14b3ce1452615e7cb42010"
 dependencies = [
  "cranelift-bitset",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "328181a9083d99762d85954a16065d2560394a862b8dc10239f39668df528b95"
+checksum = "e42ad0eeaa7f2c365a06ec50580ff6820f1ef45de1c784e8080f5b24bbe3a634"
 dependencies = [
  "cranelift-codegen",
  "log",
@@ -588,15 +809,15 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e916f36f183e377e9a3ed71769f2721df88b72648831e95bb9fa6b0cd9b1c709"
+checksum = "316dd3048717d1ad577d23fb2773671bc4fe633b651bb0d41be79d1a2dd0121b"
 
 [[package]]
 name = "cranelift-jit"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bb584ac927f1076d552504b0075b833b9d61e2e9178ba55df6b2d966b4375d"
+checksum = "e0c1c762faecc6e30a4ebb8f36ad980a5211afc2e037daf0095983c287f8d0f9"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -608,15 +829,15 @@ dependencies = [
  "log",
  "region",
  "target-lexicon",
- "wasmtime-jit-icache-coherence",
- "windows-sys 0.59.0",
+ "wasmtime-internal-jit-icache-coherence",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "cranelift-module"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "40c18ccb8e4861cf49cec79998af73b772a2b47212d12d3d63bf57cc4293a1e3"
+checksum = "1d29cd90f94cdc63c56eb7f81813072a654bb9723d9aceb382fad752f9a8e7f8"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -625,9 +846,9 @@ dependencies = [
 
 [[package]]
 name = "cranelift-native"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc852cf04128877047dc2027aa1b85c64f681dc3a6a37ff45dcbfa26e4d52d2f"
+checksum = "5dc065eb9d570d70360d9eceb5be0faf1e5871aa53973389a4a9d37bf2c748b5"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -636,40 +857,39 @@ dependencies = [
 
 [[package]]
 name = "cranelift-srcgen"
-version = "0.119.0"
+version = "0.127.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e1a86340a16e74b4285cc86ac69458fa1c8e7aaff313da4a89d10efd3535ee"
+checksum = "4a628782eefce8d87340a08f635d19e55e2900a77706f56b75cf73f1efc880a3"
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "4d883447757bb0ee46f233e9dc22eb84d93a9508c9b868687b274fc431d886bf"
 dependencies = [
+ "alloca",
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "is-terminal",
- "itertools 0.10.5",
+ "itertools 0.13.0",
  "num-traits",
- "once_cell",
  "oorandom",
+ "page_size",
  "plotters",
  "rayon",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "walkdir",
@@ -677,12 +897,12 @@ dependencies = [
 
 [[package]]
 name = "criterion-plot"
-version = "0.5.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+checksum = "ed943f81ea2faa8dcecbbfa50164acf95d555afec96a27871663b300e387b2e4"
 dependencies = [
  "cast",
- "itertools 0.10.5",
+ "itertools 0.13.0",
 ]
 
 [[package]]
@@ -712,15 +932,15 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crunchy"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "crypto-common"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
 dependencies = [
  "generic-array",
  "typenum",
@@ -728,13 +948,77 @@ dependencies = [
 
 [[package]]
 name = "csv-core"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d02f3b0da4c6504f86e9cd789d8dbafab48c2321be74e9987593de5a894d93d"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
 dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid",
+ "der_derive",
+ "flagset",
+ "pem-rfc7468 0.7.0",
+ "zeroize",
+]
+
+[[package]]
+name = "der-parser"
+version = "10.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6"
+dependencies = [
+ "asn1-rs",
+ "displaydoc",
+ "nom",
+ "num-bigint",
+ "num-traits",
+ "rusticata-macros",
+]
+
+[[package]]
+name = "der_derive"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "derive-where"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef941ded77d15ca19b40374869ac6000af1c9f2a4c0f3d4c70926287e6364a8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -767,23 +1051,40 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "dns-lookup"
-version = "2.0.4"
+version = "3.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5766087c2235fec47fafa4cfecc81e494ee679d0fd4a59887ea0919bfb0e4fc"
+checksum = "6e39034cee21a2f5bbb66ba0e3689819c4bb5d00382a282006e802a7ffa6c41d"
 dependencies = [
  "cfg-if",
  "libc",
  "socket2",
- "windows-sys 0.48.0",
+ "windows-sys 0.60.2",
 ]
 
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
 [[package]]
 name = "dyn-clone"
-version = "1.0.19"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c7a8fb8a9fbf66c1f703fe16184d10ca0ee9d23be5b4436400408ba54a95005"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "either"
@@ -805,9 +1106,9 @@ checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
 
 [[package]]
 name = "env_filter"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
 dependencies = [
  "log",
  "regex",
@@ -840,12 +1141,12 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "errno"
-version = "0.3.11"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -866,6 +1167,12 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
 [[package]]
 name = "fd-lock"
 version = "4.0.4"
@@ -877,13 +1184,25 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "flagset"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
+
 [[package]]
 name = "flame"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fc2706461e1ee94f55cab2ed2e3d34ae9536cfa830358ef80acff1a3dacab30"
 dependencies = [
- "lazy_static",
+ "lazy_static 0.2.11",
  "serde",
  "serde_derive",
  "serde_json",
@@ -892,13 +1211,13 @@ dependencies = [
 
 [[package]]
 name = "flamer"
-version = "0.4.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36b732da54fd4ea34452f2431cf464ac7be94ca4b339c9cd3d3d12eb06fe7aab"
+checksum = "7693d9dd1ec1c54f52195dfe255b627f7cec7da33b679cd56de949e662b3db10"
 dependencies = [
  "flame",
  "quote",
- "syn 1.0.109",
+ "syn",
 ]
 
 [[package]]
@@ -915,26 +1234,20 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.1.1"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ced92e76e966ca2fd84c8f7aa01a4aea65b0eb6648d72f7c8f3e2764a67fece"
+checksum = "b375d6465b98090a5f25b1c7703f3859783755aa9a80433b36e0379a3ec2f369"
 dependencies = [
  "crc32fast",
- "libz-rs-sys",
  "miniz_oxide",
+ "zlib-rs",
 ]
 
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
 [[package]]
 name = "foldhash"
-version = "0.1.5"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
 
 [[package]]
 name = "foreign-types"
@@ -951,6 +1264,12 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -961,23 +1280,46 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "get-size-derive2"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab21d7bd2c625f2064f04ce54bcb88bc57c45724cde45cba326d784e22d3f71a"
+dependencies = [
+ "attribute-derive",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "get-size2"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879272b0de109e2b67b39fcfe3d25fdbba96ac07e44a254f5a0b4d7ff55340cb"
+dependencies = [
+ "compact_str",
+ "get-size-derive2",
+ "hashbrown 0.16.1",
+ "smallvec",
+]
+
 [[package]]
 name = "gethostname"
-version = "1.0.2"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc257fdb4038301ce4b9cd1b3b51704509692bb3ff716a410cbd07925d9dae55"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
 dependencies = [
  "rustix",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
 name = "getopts"
-version = "0.2.21"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
 dependencies = [
- "unicode-width 0.1.14",
+ "unicode-width",
 ]
 
 [[package]]
@@ -988,28 +1330,28 @@ checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
 dependencies = [
  "cfg-if",
  "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasi",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.2"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
  "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
+ "wasip2",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.31.1"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
 dependencies = [
  "fallible-iterator",
  "indexmap",
@@ -1018,25 +1360,32 @@ dependencies = [
 
 [[package]]
 name = "glob"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "half"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "zerocopy",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.15.3"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
 dependencies = [
  "foldhash",
 ]
@@ -1049,15 +1398,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
-
-[[package]]
-name = "hermit-abi"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f154ce46856750ed433c8649605bf7ed2de3bc35fd9d2a9f30cddd873c80cb08"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hex"
@@ -1071,20 +1414,29 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
 [[package]]
 name = "home"
-version = "0.5.11"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.63"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c919e5debc312ad217002b8048a17b7d83f80703865bbfcfebb0458b0b27d8"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
@@ -1092,7 +1444,7 @@ dependencies = [
  "js-sys",
  "log",
  "wasm-bindgen",
- "windows-core 0.61.0",
+ "windows-core",
 ]
 
 [[package]]
@@ -1106,31 +1458,51 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.16.1",
 ]
 
 [[package]]
 name = "indoc"
-version = "2.0.6"
+version = "2.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding",
+ "generic-array",
+]
 
 [[package]]
 name = "insta"
-version = "1.43.1"
+version = "1.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "154934ea70c58054b556dd430b99a98c2a7ff5309ac9891597e339b5c28f4371"
+checksum = "1b66886d14d18d420ab5052cbff544fc5d34d0b2cdd35eb5976aaa10a4a472e5"
 dependencies = [
  "console",
  "once_cell",
  "similar",
+ "tempfile",
 ]
 
+[[package]]
+name = "interpolator"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71dd52191aae121e8611f1e8dc3e324dd0dd1dee1e6dd91d10ee07a3cfb4d9d8"
+
 [[package]]
 name = "is-macro"
 version = "0.3.7"
@@ -1140,34 +1512,14 @@ dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.101",
-]
-
-[[package]]
-name = "is-terminal"
-version = "0.4.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
-dependencies = [
- "hermit-abi 0.5.1",
- "libc",
- "windows-sys 0.59.0",
+ "syn",
 ]
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.1"
+version = "1.70.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "itertools"
@@ -1189,39 +1541,71 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.15"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
 
 [[package]]
 name = "jiff"
-version = "0.2.13"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f02000660d30638906021176af16b17498bd0d12813dbfe7b276d8bc7f3c0806"
+checksum = "a87d9b8105c23642f50cbbae03d1f75d8422c5cb98ce7ee9271f7ff7505be6b8"
 dependencies = [
  "jiff-static",
  "log",
  "portable-atomic",
  "portable-atomic-util",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
 name = "jiff-static"
-version = "0.2.13"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c30758ddd7188629c6713fc45d1188af4f44c90582311d0c8d8c9907f60c48"
+checksum = "b787bebb543f8969132630c51fd0afab173a86c6abae56ff3b9e5e3e3f9f6e58"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -1229,12 +1613,12 @@ dependencies = [
 
 [[package]]
 name = "junction"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72bbdfd737a243da3dfc1f99ee8d6e166480f17ab4ac84d7c34aacd73fc7bd16"
+checksum = "c52f6e1bf39a7894f618c9d378904a11dbd7e10fe3ec20d1173600e79b1408d8"
 dependencies = [
  "scopeguard",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1252,35 +1636,36 @@ version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "lexical-parse-float"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de6f9cb01fb0b08060209a057c048fcbab8717b4c1ecd2eac66ebfe39a65b0f2"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
 dependencies = [
  "lexical-parse-integer",
  "lexical-util",
- "static_assertions",
 ]
 
 [[package]]
 name = "lexical-parse-integer"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72207aae22fc0a121ba7b6d479e42cbfea549af1479c3f3a4f12c70dd66df12e"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
 dependencies = [
  "lexical-util",
- "static_assertions",
 ]
 
 [[package]]
 name = "lexical-util"
-version = "1.0.6"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a82e24bf537fd24c177ffbbdc6ebcc8d54732c35b50a3f28cc3f4e4c949a0b3"
-dependencies = [
- "static_assertions",
-]
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
 
 [[package]]
 name = "lexopt"
@@ -1290,21 +1675,21 @@ checksum = "9fa0e2a1fcbe2f6be6c42e342259976206b383122fc152e872795338b5a3f3a7"
 
 [[package]]
 name = "libbz2-rs-sys"
-version = "0.1.3"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0864a00c8d019e36216b69c2c4ce50b83b7bd966add3cf5ba554ec44f8bebcf5"
+checksum = "2c4a545a15244c7d945065b5d392b2d2d7f21526fba56ce51467b06ed445e8f7"
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.180"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "bcc35a38544a891a5f7c865aca548a982ccb3b8650a5b06d0fd33a10283c56fc"
 
 [[package]]
 name = "libffi"
-version = "4.1.0"
+version = "5.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebfd30a67b482a08116e753d0656cb626548cf4242543e5cc005be7639d99838"
+checksum = "0498fe5655f857803e156523e644dcdcdc3b3c7edda42ea2afdae2e09b2db87b"
 dependencies = [
  "libc",
  "libffi-sys",
@@ -1312,21 +1697,31 @@ dependencies = [
 
 [[package]]
 name = "libffi-sys"
-version = "3.3.1"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f003aa318c9f0ee69eb0ada7c78f5c9d2fedd2ceb274173b5c7ff475eee584a3"
+checksum = "71d4f1d4ce15091955144350b75db16a96d4a63728500122706fb4d29a26afbb"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "libloading"
-version = "0.8.6"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.6",
+ "windows-link",
+]
+
+[[package]]
+name = "libloading"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60"
+dependencies = [
+ "cfg-if",
+ "windows-link",
 ]
 
 [[package]]
@@ -1337,19 +1732,19 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.3"
+version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "3d0b95e02c851351f877147b7deea7b1afb1df71b63aa5f8270716e0c5720616"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "libc",
 ]
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.28.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c10584274047cb335c23d3e61bcef8e323adae7c5c8c760540f73610177fc3f"
+checksum = "95b4103cffefa72eb8428cb6b47d6627161e51c2739fc5e3b734584157bc642a"
 dependencies = [
  "cc",
  "pkg-config",
@@ -1358,40 +1753,39 @@ dependencies = [
 
 [[package]]
 name = "libz-rs-sys"
-version = "0.5.0"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6489ca9bd760fe9642d7644e827b0c9add07df89857b0416ee15c1cc1a3b8c5a"
+checksum = "c10501e7805cee23da17c7790e59df2870c0d4043ec6d03f67d31e2b53e77415"
 dependencies = [
  "zlib-rs",
 ]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.4"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
 name = "lock_api"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lz4_flex"
-version = "0.11.3"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+checksum = "ab6473172471198271ff72e9379150e9dfd70d8e533e0752a27e515b48dd375e"
 dependencies = [
  "twox-hash",
 ]
@@ -1413,26 +1807,26 @@ version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303"
 dependencies = [
- "nix",
+ "nix 0.29.0",
  "winapi",
 ]
 
 [[package]]
 name = "mach2"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "malachite-base"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "554bcf7f816ff3c1eae8f2b95c4375156884c79988596a6d01b7b070710fa9e5"
+checksum = "5eb2a098b227df48779e28ed4125dd3161b792a9254961377cea6f5c19e5b417"
 dependencies = [
- "hashbrown",
+ "hashbrown 0.16.1",
  "itertools 0.14.0",
  "libm",
  "ryu",
@@ -1440,9 +1834,9 @@ dependencies = [
 
 [[package]]
 name = "malachite-bigint"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1acde414186498b2a6a1e271f8ce5d65eaa5c492e95271121f30718fe2f925"
+checksum = "6eaf19f1b8ba023528050372eafd72ca11f80f70c9dc2af9bb22f888bf079013"
 dependencies = [
  "malachite-base",
  "malachite-nz",
@@ -1453,26 +1847,50 @@ dependencies = [
 
 [[package]]
 name = "malachite-nz"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43d406336c42a59e07813b57efd651db00118af84c640a221d666964b2ec71f"
+checksum = "ab7c0ddc4e2681459d70591baf30ca5abd31c25969e76d3605838bec794c8077"
 dependencies = [
  "itertools 0.14.0",
  "libm",
  "malachite-base",
+ "wide",
 ]
 
 [[package]]
 name = "malachite-q"
-version = "0.6.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25911a58ea0426e0b7bb1dffc8324e82711c82abff868b8523ae69d8a47e8062"
+checksum = "e13d19f04fc672f251d477c8d58c13c6c5550553dfba6a665c9ad3604466ac9a"
 dependencies = [
  "itertools 0.14.0",
  "malachite-base",
  "malachite-nz",
 ]
 
+[[package]]
+name = "manyhow"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b33efb3ca6d3b07393750d4030418d594ab1139cee518f0dc88db70fec873587"
+dependencies = [
+ "manyhow-macros",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "manyhow-macros"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46fce34d199b78b6e6073abf984c9cf5fd3e9330145a93ee0738a7443e371495"
+dependencies = [
+ "proc-macro-utils",
+ "proc-macro2",
+ "quote",
+]
+
 [[package]]
 name = "maplit"
 version = "1.0.2"
@@ -1497,15 +1915,15 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.4"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "memmap2"
-version = "0.5.10"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
 dependencies = [
  "libc",
 ]
@@ -1527,11 +1945,12 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
  "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
@@ -1540,7 +1959,7 @@ version = "3.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df7151a832e54d2d6b2c827a20e5bcdd80359281cd2c354e725d4b82e7c471de"
 dependencies = [
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -1558,7 +1977,20 @@ version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+ "memoffset",
+]
+
+[[package]]
+name = "nix"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
+dependencies = [
+ "bitflags 2.10.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -1575,6 +2007,16 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.4.6"
@@ -1584,6 +2026,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-integer"
 version = "0.1.46"
@@ -1604,32 +2052,42 @@ dependencies = [
 
 [[package]]
 name = "num_cpus"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
 dependencies = [
- "hermit-abi 0.3.9",
+ "hermit-abi",
  "libc",
 ]
 
 [[package]]
 name = "num_enum"
-version = "0.7.3"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.3"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
+]
+
+[[package]]
+name = "oid-registry"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7"
+dependencies = [
+ "asn1-rs",
 ]
 
 [[package]]
@@ -1638,6 +2096,12 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
 [[package]]
 name = "oorandom"
 version = "11.1.5"
@@ -1646,11 +2110,11 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "openssl"
-version = "0.10.72"
+version = "0.10.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -1667,29 +2131,29 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "openssl-probe"
-version = "0.1.6"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+checksum = "9f50d9b3dabb09ecd771ad0aa242ca6894994c130308ca3d7684634df8037391"
 
 [[package]]
 name = "openssl-src"
-version = "300.5.0+3.5.0"
+version = "300.5.4+3.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8ce546f549326b0e6052b649198487d91320875da901e7bd11a06d1ee3f9c2f"
+checksum = "a507b3792995dae9b0df8a1c1e3771e8418b7c2d9f0baeba32e6fe8b06c7cb72"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.108"
+version = "0.9.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e145e1651e858e820e4860f7b9c5e169bc1d8ce1c86043be79fa7b7634821847"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
 dependencies = [
  "cc",
  "libc",
@@ -1716,32 +2180,60 @@ dependencies = [
 
 [[package]]
 name = "parking_lot"
-version = "0.12.3"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
 ]
 
 [[package]]
-name = "parking_lot_core"
-version = "0.9.10"
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.5.18",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
 dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall 0.5.12",
- "smallvec",
- "windows-targets 0.52.6",
+ "base64ct",
 ]
 
 [[package]]
-name = "paste"
-version = "1.0.15"
+name = "pem-rfc7468"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9"
+dependencies = [
+ "base64ct",
+]
 
 [[package]]
 name = "phf"
@@ -1749,7 +2241,18 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
- "phf_shared",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared 0.13.1",
+ "serde",
 ]
 
 [[package]]
@@ -1758,8 +2261,8 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
 dependencies = [
- "phf_generator",
- "phf_shared",
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
 ]
 
 [[package]]
@@ -1768,10 +2271,33 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
- "phf_shared",
+ "phf_shared 0.11.3",
  "rand 0.8.5",
 ]
 
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared 0.13.1",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator 0.13.1",
+ "phf_shared 0.13.1",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "phf_shared"
 version = "0.11.3"
@@ -1781,6 +2307,42 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
+dependencies = [
+ "aes",
+ "cbc",
+ "der",
+ "pbkdf2",
+ "scrypt",
+ "sha2",
+ "spki",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "pkcs5",
+ "rand_core 0.6.4",
+ "spki",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.32"
@@ -1823,14 +2385,14 @@ checksum = "52a40bc70c2c58040d2d8b167ba9a5ff59fc9dab7ad44771cfde3dcfde7a09c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "portable-atomic"
-version = "1.11.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950"
 
 [[package]]
 name = "portable-atomic-util"
@@ -1841,6 +2403,12 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1852,39 +2420,54 @@ dependencies = [
 
 [[package]]
 name = "prettyplease"
-version = "0.2.32"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "664ec5419c51e34154eec046ebcba56312d5a2fc3b09a06da188e1ad21afadf6"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
- "syn 2.0.101",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro-utils"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eeaf08a13de400bc215877b5bdc088f241b12eb42f0a548d3390dc1c56bb7071"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "smallvec",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "pymath"
-version = "0.0.2"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b66ab66a8610ce209d8b36cd0fecc3a15c494f715e0cb26f0586057f293abc9"
+checksum = "bbfb6723b732fc7f0b29a0ee7150c7f70f947bf467b8c3e82530b13589a78b4c"
 dependencies = [
  "libc",
+ "libm",
+ "malachite-bigint",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.24.2"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
 dependencies = [
- "cfg-if",
  "indoc",
  "libc",
  "memoffset",
@@ -1898,19 +2481,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.2"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.2"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -1918,48 +2500,71 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.2"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.2"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
 dependencies = [
  "heck",
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "quote-use"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9619db1197b497a36178cfc736dc96b271fe918875fbf1344c436a7e93d0321e"
+dependencies = [
+ "quote",
+ "quote-use-macros",
+]
+
+[[package]]
+name = "quote-use-macros"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "82ebfb7faafadc06a7ab141a6f67bcfb24cb8beb158c6fe933f2f035afa99f35"
 dependencies = [
+ "proc-macro-utils",
  "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "radium"
-version = "1.1.0"
-source = "git+https://github.com/youknowone/ferrilab?branch=fix-nightly#4a301c3a223e096626a2773d1a1eed1fc4e21140"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1775bc532a9bfde46e26eba441ca1171b91608d14a3bae71fea371f18a00cffe"
 dependencies = [
  "cfg-if",
 ]
@@ -1987,12 +2592,12 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2012,7 +2617,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
 dependencies = [
  "ppv-lite86",
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
 ]
 
 [[package]]
@@ -2026,18 +2631,18 @@ dependencies = [
 
 [[package]]
 name = "rand_core"
-version = "0.9.3"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
 dependencies = [
- "getrandom 0.3.2",
+ "getrandom 0.3.4",
 ]
 
 [[package]]
 name = "rayon"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
  "either",
  "rayon-core",
@@ -2045,9 +2650,9 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.12.1"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
  "crossbeam-deque",
  "crossbeam-utils",
@@ -2061,11 +2666,11 @@ checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.12"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -2081,13 +2686,13 @@ dependencies = [
 
 [[package]]
 name = "regalloc2"
-version = "0.11.2"
+version = "0.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a"
+checksum = "4e249c660440317032a71ddac302f25f1d5dff387667bcc3978d1f77aa31ac34"
 dependencies = [
  "allocator-api2",
  "bumpalo",
- "hashbrown",
+ "hashbrown 0.15.5",
  "log",
  "rustc-hash",
  "smallvec",
@@ -2095,9 +2700,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -2107,9 +2712,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.9"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -2118,9 +2723,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "region"
@@ -2136,33 +2741,48 @@ dependencies = [
 
 [[package]]
 name = "result-like"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abf7172fef6a7d056b5c26bf6c826570267562d51697f4982ff3ba4aec68a9df"
+checksum = "bffa194499266bd8a1ac7da6ac7355aa0f81ffa1a5db2baaf20dd13854fd6f4e"
 dependencies = [
  "result-like-derive",
 ]
 
 [[package]]
 name = "result-like-derive"
-version = "0.5.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d6574c02e894d66370cfc681e5d68fedbc9a548fb55b30a96b3f0ae22d0fe5"
+checksum = "01d3b03471c9700a3a6bd166550daaa6124cb4a146ea139fb028e4edaa8f4277"
 dependencies = [
  "pmutil",
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.16",
+ "libc",
+ "untrusted 0.9.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "ruff_python_ast"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?tag=0.11.0#2cd25ef6410fb5fca96af1578728a3d828d2d53a"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "aho-corasick",
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "compact_str",
+ "get-size2",
  "is-macro",
  "itertools 0.14.0",
  "memchr",
@@ -2170,16 +2790,18 @@ dependencies = [
  "ruff_source_file",
  "ruff_text_size",
  "rustc-hash",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
 name = "ruff_python_parser"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?tag=0.11.0#2cd25ef6410fb5fca96af1578728a3d828d2d53a"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "bstr",
  "compact_str",
+ "get-size2",
  "memchr",
  "ruff_python_ast",
  "ruff_python_trivia",
@@ -2188,13 +2810,13 @@ dependencies = [
  "static_assertions",
  "unicode-ident",
  "unicode-normalization",
- "unicode_names2",
+ "unicode_names2 1.3.0",
 ]
 
 [[package]]
 name = "ruff_python_trivia"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?tag=0.11.0#2cd25ef6410fb5fca96af1578728a3d828d2d53a"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "itertools 0.14.0",
  "ruff_source_file",
@@ -2205,7 +2827,7 @@ dependencies = [
 [[package]]
 name = "ruff_source_file"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?tag=0.11.0#2cd25ef6410fb5fca96af1578728a3d828d2d53a"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
 dependencies = [
  "memchr",
  "ruff_text_size",
@@ -2214,7 +2836,10 @@ dependencies = [
 [[package]]
 name = "ruff_text_size"
 version = "0.0.0"
-source = "git+https://github.com/astral-sh/ruff.git?tag=0.11.0#2cd25ef6410fb5fca96af1578728a3d828d2d53a"
+source = "git+https://github.com/astral-sh/ruff.git?rev=45bbb4cbffe73cf925d4579c2e3eb413e0539390#45bbb4cbffe73cf925d4579c2e3eb413e0539390"
+dependencies = [
+ "get-size2",
+]
 
 [[package]]
 name = "rustc-hash"
@@ -2222,17 +2847,109 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
+[[package]]
+name = "rusticata-macros"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632"
+dependencies = [
+ "nom",
+]
+
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c665f33d38cea657d9614f766881e4d510e0eda4239891eea56b4cadcf01801b"
+dependencies = [
+ "aws-lc-rs",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -2263,7 +2980,7 @@ name = "rustpython-codegen"
 version = "0.4.0"
 dependencies = [
  "ahash",
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "indexmap",
  "insta",
  "itertools 0.14.0",
@@ -2274,14 +2991,12 @@ dependencies = [
  "num-traits",
  "ruff_python_ast",
  "ruff_python_parser",
- "ruff_source_file",
  "ruff_text_size",
  "rustpython-compiler-core",
- "rustpython-compiler-source",
  "rustpython-literal",
  "rustpython-wtf8",
- "thiserror 2.0.12",
- "unicode_names2",
+ "thiserror 2.0.17",
+ "unicode_names2 2.0.0",
 ]
 
 [[package]]
@@ -2289,17 +3004,16 @@ name = "rustpython-common"
 version = "0.4.0"
 dependencies = [
  "ascii",
- "bitflags 2.9.0",
- "bstr",
+ "bitflags 2.10.0",
  "cfg-if",
- "getrandom 0.3.2",
+ "getrandom 0.3.4",
  "itertools 0.14.0",
  "libc",
  "lock_api",
  "malachite-base",
  "malachite-bigint",
  "malachite-q",
- "memchr",
+ "nix 0.30.1",
  "num-complex",
  "num-traits",
  "once_cell",
@@ -2308,43 +3022,40 @@ dependencies = [
  "rustpython-literal",
  "rustpython-wtf8",
  "siphasher",
- "unicode_names2",
+ "unicode_names2 2.0.0",
  "widestring",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustpython-compiler"
 version = "0.4.0"
 dependencies = [
- "rand 0.9.1",
  "ruff_python_ast",
  "ruff_python_parser",
  "ruff_source_file",
  "ruff_text_size",
  "rustpython-codegen",
  "rustpython-compiler-core",
- "rustpython-compiler-source",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
 name = "rustpython-compiler-core"
 version = "0.4.0"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "itertools 0.14.0",
  "lz4_flex",
  "malachite-bigint",
  "num-complex",
  "ruff_source_file",
  "rustpython-wtf8",
- "serde",
 ]
 
 [[package]]
 name = "rustpython-compiler-source"
-version = "0.4.0"
+version = "0.5.0+deprecated"
 dependencies = [
  "ruff_source_file",
  "ruff_text_size",
@@ -2354,10 +3065,9 @@ dependencies = [
 name = "rustpython-derive"
 version = "0.4.0"
 dependencies = [
- "proc-macro2",
  "rustpython-compiler",
  "rustpython-derive-impl",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
@@ -2370,17 +3080,16 @@ dependencies = [
  "quote",
  "rustpython-compiler-core",
  "rustpython-doc",
- "syn 2.0.101",
+ "syn",
  "syn-ext",
  "textwrap",
 ]
 
 [[package]]
 name = "rustpython-doc"
-version = "0.3.0"
-source = "git+https://github.com/RustPython/__doc__?tag=0.3.0#8b62ce5d796d68a091969c9fa5406276cb483f79"
+version = "0.4.0"
 dependencies = [
- "once_cell",
+ "phf 0.13.1",
 ]
 
 [[package]]
@@ -2395,7 +3104,7 @@ dependencies = [
  "num-traits",
  "rustpython-compiler-core",
  "rustpython-derive",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -2406,7 +3115,7 @@ dependencies = [
  "is-macro",
  "lexical-parse-float",
  "num-traits",
- "rand 0.9.1",
+ "rand 0.9.2",
  "rustpython-wtf8",
  "unic-ucd-category",
 ]
@@ -2424,7 +3133,7 @@ dependencies = [
 name = "rustpython-sre_engine"
 version = "0.4.0"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "criterion",
  "num_enum",
  "optional",
@@ -2438,23 +3147,26 @@ dependencies = [
  "adler32",
  "ahash",
  "ascii",
+ "aws-lc-rs",
  "base64",
  "blake2",
  "bzip2",
  "cfg-if",
+ "chrono",
  "crc32fast",
  "crossbeam-utils",
  "csv-core",
+ "der",
  "digest",
  "dns-lookup",
  "dyn-clone",
+ "flame",
  "flate2",
  "foreign-types-shared",
  "gethostname",
  "hex",
  "indexmap",
  "itertools 0.14.0",
- "junction",
  "libc",
  "libsqlite3-sys",
  "libz-rs-sys",
@@ -2465,20 +3177,28 @@ dependencies = [
  "memchr",
  "memmap2",
  "mt19937",
- "nix",
+ "nix 0.30.1",
  "num-complex",
  "num-integer",
  "num-traits",
  "num_enum",
+ "oid-registry",
  "openssl",
  "openssl-probe",
  "openssl-sys",
  "page_size",
  "parking_lot",
  "paste",
+ "pem-rfc7468 1.0.0",
+ "phf 0.13.1",
+ "pkcs8",
  "pymath",
- "rand_core 0.9.3",
+ "rand_core 0.9.5",
  "rustix",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pemfile",
+ "rustls-platform-verifier",
  "rustpython-common",
  "rustpython-derive",
  "rustpython-vm",
@@ -2500,21 +3220,31 @@ dependencies = [
  "unic-ucd-ident",
  "unicode-bidi-mirroring",
  "unicode-casing",
- "unicode_names2",
+ "unicode_names2 2.0.0",
  "uuid",
+ "webpki-roots",
  "widestring",
- "windows-sys 0.59.0",
- "xml-rs",
+ "windows-sys 0.61.2",
+ "x509-cert",
+ "x509-parser",
+ "xml",
  "xz2",
 ]
 
+[[package]]
+name = "rustpython-venvlauncher"
+version = "0.4.0"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustpython-vm"
 version = "0.4.0"
 dependencies = [
  "ahash",
  "ascii",
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "bstr",
  "caseless",
  "cfg-if",
@@ -2525,7 +3255,7 @@ dependencies = [
  "exitcode",
  "flame",
  "flamer",
- "getrandom 0.3.2",
+ "getrandom 0.3.4",
  "glob",
  "half",
  "hex",
@@ -2535,12 +3265,11 @@ dependencies = [
  "junction",
  "libc",
  "libffi",
- "libloading",
+ "libloading 0.9.0",
  "log",
  "malachite-bigint",
  "memchr",
- "memoffset",
- "nix",
+ "nix 0.30.1",
  "num-complex",
  "num-integer",
  "num-traits",
@@ -2553,25 +3282,24 @@ dependencies = [
  "result-like",
  "ruff_python_ast",
  "ruff_python_parser",
- "ruff_source_file",
  "ruff_text_size",
  "rustix",
  "rustpython-codegen",
  "rustpython-common",
  "rustpython-compiler",
  "rustpython-compiler-core",
- "rustpython-compiler-source",
  "rustpython-derive",
  "rustpython-jit",
  "rustpython-literal",
  "rustpython-sre_engine",
  "rustyline",
- "schannel",
+ "scoped-tls",
+ "scopeguard",
  "serde",
  "static_assertions",
  "strum",
  "strum_macros",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "thread_local",
  "timsort",
  "uname",
@@ -2579,13 +3307,10 @@ dependencies = [
  "unic-ucd-category",
  "unic-ucd-ident",
  "unicode-casing",
- "unicode_names2",
  "wasm-bindgen",
  "which",
  "widestring",
- "windows",
- "windows-sys 0.59.0",
- "winreg",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2618,17 +3343,17 @@ dependencies = [
 
 [[package]]
 name = "rustversion"
-version = "1.0.20"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eded382c5f5f786b989652c49544c4877d9f015cc22e145a5ea8ea66c2921cd2"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rustyline"
-version = "15.0.0"
+version = "17.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ee1e066dc922e513bda599c6ccb5f3bb2b0ea5870a579448f2622993f0a9a2f"
+checksum = "e902948a25149d50edc1a8e0141aad50f54e22ba83ff988cf8f7c9ef07f50564"
 dependencies = [
- "bitflags 2.9.0",
+ "bitflags 2.10.0",
  "cfg-if",
  "clipboard-win",
  "fd-lock",
@@ -2636,19 +3361,37 @@ dependencies = [
  "libc",
  "log",
  "memchr",
- "nix",
+ "nix 0.30.1",
  "radix_trie",
  "unicode-segmentation",
- "unicode-width 0.2.0",
+ "unicode-width",
  "utf8parse",
- "windows-sys 0.59.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.20"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
+
+[[package]]
+name = "safe_arch"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "629516c85c29fe757770fa03f2074cf1eac43d44c02a3de9fc2ef7b0e207dfdd"
+dependencies = [
+ "bytemuck",
+]
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
 
 [[package]]
 name = "same-file"
@@ -2661,70 +3404,120 @@ dependencies = [
 
 [[package]]
 name = "schannel"
-version = "0.1.27"
+version = "0.1.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f29ebaa345f945cec9fbbc532eb307f0fdad8161f281b6369539c8d84876b3d"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+dependencies = [
+ "bitflags 2.10.0",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
+ "serde_core",
  "serde_derive",
 ]
 
 [[package]]
 name = "serde-wasm-bindgen"
-version = "0.3.1"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "618365e8e586c22123d692b72a7d791d5ee697817b65a218cdf12a98870af0f7"
+checksum = "8302e169f0eddcc139c70f139d19d6467353af16f9fce27e8c30158036a1e16b"
 dependencies = [
- "fnv",
  "js-sys",
  "serde",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "3084b546a1dd6289475996f182a22aba973866ea8e8b02c51d9f46b1336a22da"
 dependencies = [
  "itoa",
  "memchr",
- "ryu",
  "serde",
+ "serde_core",
+ "zmij",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.8"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2738,6 +3531,17 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sha2"
 version = "0.10.9"
@@ -2764,14 +3568,29 @@ name = "shared-build"
 version = "0.2.0"
 source = "git+https://github.com/arihant2math/tkinter.git?tag=v0.2.0#198fc35b1f18f4eda401f97a641908f321b1403a"
 dependencies = [
- "bindgen",
+ "bindgen 0.71.1",
 ]
 
 [[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "similar"
@@ -2787,25 +3606,35 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "smallvec"
-version = "1.15.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "socket2"
-version = "0.5.9"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
 ]
 
 [[package]]
 name = "stable_deref_trait"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "static_assertions"
@@ -2815,21 +3644,20 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strum"
-version = "0.27.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 
 [[package]]
 name = "strum_macros"
-version = "0.27.1"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "rustversion",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
@@ -2840,9 +3668,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2850,35 +3678,35 @@ dependencies = [
 ]
 
 [[package]]
-name = "syn"
-version = "2.0.101"
+name = "syn-ext"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf"
+checksum = "b126de4ef6c2a628a68609dd00733766c3b015894698a438ebdf374933fc31d1"
 dependencies = [
  "proc-macro2",
  "quote",
- "unicode-ident",
+ "syn",
 ]
 
 [[package]]
-name = "syn-ext"
-version = "0.5.0"
+name = "synstructure"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b126de4ef6c2a628a68609dd00733766c3b015894698a438ebdf374933fc31d1"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "system-configuration"
-version = "0.6.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c879d448e9d986b661742763247d3693ed13609438cf3d006f51f5368a5ba6b"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "bitflags 2.9.0",
- "core-foundation",
+ "bitflags 2.10.0",
+ "core-foundation 0.9.4",
  "system-configuration-sys",
 ]
 
@@ -2894,9 +3722,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.13.2"
+version = "0.13.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
+checksum = "b1dd07eb858a2067e2f3c7155d54e929265c264e6f37efe3ee7a8d1b5a1dd0ba"
 
 [[package]]
 name = "tcl-sys"
@@ -2907,6 +3735,19 @@ dependencies = [
  "shared-build",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "termios"
 version = "0.3.3"
@@ -2933,11 +3774,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.12"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl 2.0.12",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
@@ -2948,18 +3789,18 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.12"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
@@ -2975,12 +3816,42 @@ dependencies = [
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
  "cfg-if",
- "once_cell",
+]
+
+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "time-macros"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+dependencies = [
+ "num-conv",
+ "time-core",
 ]
 
 [[package]]
@@ -3001,9 +3872,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -3024,61 +3895,76 @@ dependencies = [
 ]
 
 [[package]]
-name = "toml"
-version = "0.8.22"
+name = "tls_codec"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ae329d1f08c4d17a59bed7ff5b5a769d062e64a62d34a3261b219e62cd5aae"
+checksum = "0de2e01245e2bb89d6f05801c564fa27624dbd7b1846859876c7dad82e90bf6b"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
+ "tls_codec_derive",
+ "zeroize",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.9"
+name = "tls_codec_derive"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3"
+checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd"
 dependencies = [
- "serde",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.22.26"
+name = "toml"
+version = "0.9.10+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e"
+checksum = "0825052159284a1a8b4d6c0c86cbc801f2da5afd2b225fa548c72f2e74002f48"
 dependencies = [
  "indexmap",
- "serde",
+ "serde_core",
  "serde_spanned",
  "toml_datetime",
- "toml_write",
+ "toml_parser",
+ "toml_writer",
  "winnow",
 ]
 
 [[package]]
-name = "toml_write"
-version = "0.1.1"
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfb942dfe1d8e29a7ee7fcbde5bd2b9a25fb89aa70caea2eba3bee836ff41076"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
-name = "twox-hash"
-version = "1.6.3"
+name = "toml_parser"
+version = "1.0.6+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+checksum = "a3198b4b0a8e11f09dd03e133c0280504d0801269e9afa46362ffde1cbeebf44"
 dependencies = [
- "cfg-if",
- "static_assertions",
+ "winnow",
 ]
 
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
 [[package]]
 name = "typenum"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
 
 [[package]]
 name = "ucd"
@@ -3202,27 +4088,27 @@ dependencies = [
 
 [[package]]
 name = "unicode-bidi-mirroring"
-version = "0.2.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23cb788ffebc92c5948d0e997106233eeb1d8b9512f93f41651f52b6c5f5af86"
+checksum = "5dfa6e8c60bb66d49db113e0125ee8711b7647b5579dc7f5f19c42357ed039fe"
 
 [[package]]
 name = "unicode-casing"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "623f59e6af2a98bdafeb93fa277ac8e1e40440973001ca15cf4ae1541cd16d56"
+checksum = "061dbb8cc7f108532b6087a0065eff575e892a4bcb503dc57323a197457cc202"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.18"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.24"
+version = "0.1.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
 dependencies = [
  "tinyvec",
 ]
@@ -3235,24 +4121,28 @@ checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.14"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
 
 [[package]]
-name = "unicode-width"
-version = "0.2.0"
+name = "unicode_names2"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
+checksum = "d1673eca9782c84de5f81b82e4109dcfb3611c8ba0d52930ec4a9478f547b2dd"
+dependencies = [
+ "phf 0.11.3",
+ "unicode_names2_generator 1.3.0",
+]
 
 [[package]]
 name = "unicode_names2"
-version = "1.3.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1673eca9782c84de5f81b82e4109dcfb3611c8ba0d52930ec4a9478f547b2dd"
+checksum = "d189085656ca1203291e965444e7f6a2723fbdd1dd9f34f8482e79bafd8338a0"
 dependencies = [
- "phf",
- "unicode_names2_generator",
+ "phf 0.11.3",
+ "unicode_names2_generator 2.0.0",
 ]
 
 [[package]]
@@ -3267,12 +4157,34 @@ dependencies = [
  "rand 0.8.5",
 ]
 
+[[package]]
+name = "unicode_names2_generator"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1262662dc96937c71115228ce2e1d30f41db71a7a45d3459e98783ef94052214"
+dependencies = [
+ "phf_codegen",
+ "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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -3281,11 +4193,13 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.16.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
+checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
 dependencies = [
  "atomic",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -3312,50 +4226,37 @@ dependencies = [
 
 [[package]]
 name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
+version = "0.11.1+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
-name = "wasi"
-version = "0.14.2+wasi-0.2.4"
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
 dependencies = [
- "wit-bindgen-rt",
+ "wit-bindgen",
 ]
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
-dependencies = [
- "bumpalo",
- "log",
- "proc-macro2",
- "quote",
- "syn 2.0.101",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.50"
+version = "0.4.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -3366,9 +4267,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3376,65 +4277,101 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
 dependencies = [
+ "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.101",
- "wasm-bindgen-backend",
+ "syn",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
-name = "wasmtime-jit-icache-coherence"
-version = "32.0.0"
+name = "wasmtime-internal-jit-icache-coherence"
+version = "40.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb399eaabd7594f695e1159d236bf40ef55babcb3af97f97c027864ed2104db6"
+checksum = "3b4462e93068c8d73847a9d69c371b9dd8106cf020a736d43cdca519a20703b3"
 dependencies = [
  "anyhow",
  "cfg-if",
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "wasmtime-internal-math"
+version = "40.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50a77e2f3f9009c5af4abb0c2875f64ab5f7c04875b3bcb8a8a120e22cdffe70"
+dependencies = [
+ "libm",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee3e3b5f5e80bc89f30ce8d0343bf4e5f12341c51f3e26cbeecbc7c85443e85b"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "which"
-version = "7.0.3"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762"
+checksum = "d3fabb953106c3c8eea8306e4393700d7657561cb43122571b172bbfb7c7ba1d"
 dependencies = [
- "either",
  "env_home",
  "rustix",
  "winsafe",
 ]
 
+[[package]]
+name = "wide"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13ca908d26e4786149c48efcf6c0ea09ab0e06d1fe3c17dc1b4b0f1ca4a7e788"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
 [[package]]
 name = "widestring"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd7cf3379ca1aac9eea11fba24fd7e315d621f8dfe35c8d7d2be8b793726e07d"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
 
 [[package]]
 name = "winapi"
@@ -3454,11 +4391,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3467,30 +4404,11 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
-[[package]]
-name = "windows"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
-dependencies = [
- "windows-core 0.52.0",
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
-dependencies = [
- "windows-targets 0.52.6",
-]
-
 [[package]]
 name = "windows-core"
-version = "0.61.0"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4763c1de310c86d75a878046489e2e5ba02c649d185f21c67d4cf8a56d098980"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
  "windows-implement",
  "windows-interface",
@@ -3501,57 +4419,57 @@ dependencies = [
 
 [[package]]
 name = "windows-implement"
-version = "0.60.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "windows-interface"
-version = "0.59.1"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "windows-link"
-version = "0.1.1"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-result"
-version = "0.3.2"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fd11a4fd95df68efcfee5f44a294fe71b8bc6a91993e2791938abcc712252"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.4.0"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ba9642430ee452d5a7aa78d72907ebe8cfda358e8cb7918a2050581322f97"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.48.0"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "windows-targets 0.48.5",
+ "windows-targets 0.42.2",
 ]
 
 [[package]]
@@ -3572,19 +4490,37 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
 ]
 
 [[package]]
@@ -3596,18 +4532,35 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm",
+ "windows_i686_gnullvm 0.52.6",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
@@ -3615,11 +4568,17 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -3627,11 +4586,17 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -3639,17 +4604,29 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -3657,11 +4634,17 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -3669,11 +4652,17 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -3681,11 +4670,17 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.5"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -3694,29 +4689,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winnow"
-version = "0.7.10"
+name = "windows_x86_64_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec"
-dependencies = [
- "memchr",
-]
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
-name = "winreg"
-version = "0.55.0"
+name = "winnow"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
-dependencies = [
- "cfg-if",
- "windows-sys 0.59.0",
-]
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 
 [[package]]
 name = "winresource"
-version = "0.1.20"
+version = "0.1.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4a67c78ee5782c0c1cb41bebc7e12c6e79644daa1650ebbc1de5d5b08593f7"
+checksum = "17cdfa8da4b111045a5e47c7c839e6c5e11c942de1309bc624393ed5d87f89c6"
 dependencies = [
  "toml",
  "version_check",
@@ -3729,19 +4717,47 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"
 
 [[package]]
-name = "wit-bindgen-rt"
-version = "0.39.0"
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "x509-cert"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
 dependencies = [
- "bitflags 2.9.0",
+ "const-oid",
+ "der",
+ "sha1",
+ "signature",
+ "spki",
+ "tls_codec",
 ]
 
 [[package]]
-name = "xml-rs"
-version = "0.8.26"
+name = "x509-parser"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62ce76d9b56901b19a74f19431b0d8b3bc7ca4ad685a746dfd78ca8f4fc6bda"
+checksum = "eb3e137310115a65136898d2079f003ce33331a6c4b0d51f1531d1be082b6425"
+dependencies = [
+ "asn1-rs",
+ "data-encoding",
+ "der-parser",
+ "lazy_static 1.5.0",
+ "nom",
+ "oid-registry",
+ "rusticata-macros",
+ "thiserror 2.0.17",
+ "time",
+]
+
+[[package]]
+name = "xml"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8aa498d22c9bbaf482329839bc5620c46be275a19a812e9a22a2b07529a642a"
 
 [[package]]
 name = "xz2"
@@ -3754,26 +4770,52 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.25"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.25"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.101",
+ "syn",
 ]
 
 [[package]]
 name = "zlib-rs"
-version = "0.5.0"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40990edd51aae2c2b6907af74ffb635029d5788228222c4bb811e9351c0caad3"
+
+[[package]]
+name = "zmij"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "868b928d7949e09af2f6086dfc1e01936064cc7a819253bce650d4e2a2d63ba8"
+checksum = "e3280a1b827474fcd5dbef4b35a674deb52ba5c312363aef9135317df179d81b"
diff --git a/Cargo.toml b/Cargo.toml
index 1fdc77d261..083358cf74 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,18 +10,20 @@ repository.workspace = true
 license.workspace = true
 
 [features]
-default = ["threading", "stdlib", "stdio", "importlib"]
+default = ["threading", "stdlib", "stdio", "importlib", "ssl-rustls"]
 importlib = ["rustpython-vm/importlib"]
 encodings = ["rustpython-vm/encodings"]
 stdio = ["rustpython-vm/stdio"]
 stdlib = ["rustpython-stdlib", "rustpython-pylib", "encodings"]
-flame-it = ["rustpython-vm/flame-it", "flame", "flamescope"]
+flame-it = ["rustpython-vm/flame-it", "rustpython-stdlib/flame-it", "flame", "flamescope"]
 freeze-stdlib = ["stdlib", "rustpython-vm/freeze-stdlib", "rustpython-pylib?/freeze-stdlib"]
 jit = ["rustpython-vm/jit"]
 threading = ["rustpython-vm/threading", "rustpython-stdlib/threading"]
 sqlite = ["rustpython-stdlib/sqlite"]
-ssl = ["rustpython-stdlib/ssl"]
-ssl-vendor = ["ssl", "rustpython-stdlib/ssl-vendor"]
+ssl = []
+ssl-rustls = ["ssl", "rustpython-stdlib/ssl-rustls"]
+ssl-openssl = ["ssl", "rustpython-stdlib/ssl-openssl"]
+ssl-vendor = ["ssl-openssl", "rustpython-stdlib/ssl-vendor"]
 tkinter = ["rustpython-stdlib/tkinter"]
 
 [build-dependencies]
@@ -51,7 +53,7 @@ rustyline = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
-pyo3 = { version = "0.24", features = ["auto-initialize"] }
+pyo3 = { version = "0.27", features = ["auto-initialize"] }
 
 [[bench]]
 name = "execution"
@@ -73,6 +75,10 @@ opt-level = 3
 # https://github.com/rust-lang/rust/issues/92869
 # lto = "thin"
 
+# Doesn't change often
+[profile.release.package.rustpython-doc]
+codegen-units = 1
+
 [profile.bench]
 lto = "thin"
 codegen-units = 1
@@ -82,20 +88,9 @@ opt-level = 3
 lto = "thin"
 
 [patch.crates-io]
-radium = { version = "1.1.0", git = "https://github.com/youknowone/ferrilab", branch = "fix-nightly" }
 # REDOX START, Uncomment when you want to compile/check with redoxer
 # REDOX END
 
-# Used only on Windows to build the vcpkg dependencies
-[package.metadata.vcpkg]
-git = "https://github.com/microsoft/vcpkg"
-# The revision of the vcpkg repository to use
-# https://github.com/microsoft/vcpkg/tags
-rev = "2024.02.14"
-
-[package.metadata.vcpkg.target]
-x86_64-pc-windows-msvc = { triplet = "x64-windows-static-md", dev-dependencies = ["openssl" ] }
-
 [package.metadata.packager]
 product-name = "RustPython"
 identifier = "com.rustpython.rustpython"
@@ -118,66 +113,68 @@ template = "installer-config/installer.wxs"
 [workspace]
 resolver = "2"
 members = [
-    "compiler", "compiler/core", "compiler/codegen", "compiler/literal", "compiler/source",
-    ".", "common", "derive", "jit", "vm", "vm/sre_engine", "pylib", "stdlib", "derive-impl", "wtf8",
-    "wasm/lib",
+    ".",
+    "crates/*",
 ]
+exclude = ["pymath"]
 
 [workspace.package]
 version = "0.4.0"
 authors = ["RustPython Team"]
 edition = "2024"
-rust-version = "1.85.0"
+rust-version = "1.91.0"
 repository = "https://github.com/RustPython/RustPython"
 license = "MIT"
 
 [workspace.dependencies]
-rustpython-compiler-source = { path = "compiler/source" }
-rustpython-compiler-core = { path = "compiler/core", version = "0.4.0" }
-rustpython-compiler = { path = "compiler", version = "0.4.0" }
-rustpython-codegen = { path = "compiler/codegen", version = "0.4.0" }
-rustpython-common = { path = "common", version = "0.4.0" }
-rustpython-derive = { path = "derive", version = "0.4.0" }
-rustpython-derive-impl = { path = "derive-impl", version = "0.4.0" }
-rustpython-jit = { path = "jit", version = "0.4.0" }
-rustpython-literal = { path = "compiler/literal", version = "0.4.0" }
-rustpython-vm = { path = "vm", default-features = false, version = "0.4.0" }
-rustpython-pylib = { path = "pylib", version = "0.4.0" }
-rustpython-stdlib = { path = "stdlib", default-features = false, version = "0.4.0" }
-rustpython-sre_engine = { path = "vm/sre_engine", version = "0.4.0" }
-rustpython-wtf8 = { path = "wtf8", version = "0.4.0" }
-rustpython-doc = { git = "https://github.com/RustPython/__doc__", tag = "0.3.0", version = "0.3.0" }
-
-ruff_python_parser = { git = "https://github.com/astral-sh/ruff.git", tag = "0.11.0" }
-ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", tag = "0.11.0" }
-ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", tag = "0.11.0" }
-ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", tag = "0.11.0" }
-
-ahash = "0.8.11"
+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.10 is based on commit 45bbb4cbffe73cf925d4579c2e3eb413e0539390
+# at the time of this capture. We use the commit hash to ensure reproducible builds.
+ruff_python_parser = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_python_ast = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_text_size = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+ruff_source_file = { git = "https://github.com/astral-sh/ruff.git", rev = "45bbb4cbffe73cf925d4579c2e3eb413e0539390" }
+
+phf = { version = "0.13.1", default-features = false, features = ["macros"]}
+ahash = "0.8.12"
 ascii = "1.1"
-bitflags = "2.4.2"
+bitflags = "2.9.4"
 bstr = "1"
 cfg-if = "1.0"
-chrono = "0.4.39"
+chrono = { version = "0.4.42", default-features = false, features = ["clock", "oldtime", "std"] }
 constant_time_eq = "0.4"
-criterion = { version = "0.5", features = ["html_reports"] }
+criterion = { version = "0.8", features = ["html_reports"] }
 crossbeam-utils = "0.8.21"
 flame = "0.2.2"
 getrandom = { version = "0.3", features = ["std"] }
 glob = "0.3"
 hex = "0.4.3"
-indexmap = { version = "2.2.6", features = ["std"] }
-insta = "1.42"
+indexmap = { version = "2.13.0", features = ["std"] }
+insta = "1.46"
 itertools = "0.14.0"
 is-macro = "0.3.7"
-junction = "1.2.0"
-libc = "0.2.169"
-libffi = "4.1"
-log = "0.4.27"
-nix = { version = "0.29", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
-malachite-bigint = "0.6"
-malachite-q = "0.6"
-malachite-base = "0.6"
+junction = "1.3.0"
+libc = "0.2.180"
+libffi = "5"
+log = "0.4.29"
+nix = { version = "0.30", features = ["fs", "user", "process", "term", "time", "signal", "ioctl", "socket", "sched", "zerocopy", "dir", "hostname", "net", "poll"] }
+malachite-bigint = "0.9"
+malachite-q = "0.9"
+malachite-base = "0.9"
 memchr = "2.7.4"
 num-complex = "0.4.6"
 num-integer = "0.1.46"
@@ -187,34 +184,36 @@ optional = "0.5"
 once_cell = "1.20.3"
 parking_lot = "0.12.3"
 paste = "1.0.15"
-proc-macro2 = "1.0.93"
-pymath = "0.0.2"
-quote = "1.0.38"
-radium = "1.1"
+proc-macro2 = "1.0.105"
+pymath = { version = "0.1.5", features = ["mul_add", "malachite-bigint", "complex"] }
+quote = "1.0.43"
+radium = "1.1.1"
 rand = "0.9"
 rand_core = { version = "0.9", features = ["os_rng"] }
-rustix = { version = "1.0", features = ["event"] }
-rustyline = "15.0.0"
-serde = { version = "1.0.133", default-features = false }
-schannel = "0.1.27"
+rustix = { version = "1.1", features = ["event"] }
+rustyline = "17.0.1"
+serde = { version = "1.0.225", default-features = false }
+schannel = "0.1.28"
+scoped-tls = "1"
+scopeguard = "1"
 static_assertions = "1.1"
 strum = "0.27"
 strum_macros = "0.27"
 syn = "2"
 thiserror = "2.0"
-thread_local = "1.1.8"
-unicode-casing = "0.1.0"
+thread_local = "1.1.9"
+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 = "1.3.0"
-unicode-bidi-mirroring = "0.2"
-widestring = "1.1.0"
-windows-sys = "0.59.0"
-wasm-bindgen = "0.2.100"
+unicode_names2 = "2.0.0"
+unicode-bidi-mirroring = "0.4"
+widestring = "1.2.0"
+windows-sys = "0.61.2"
+wasm-bindgen = "0.2.106"
 
 # Lints
 
@@ -224,6 +223,9 @@ unsafe_op_in_unsafe_fn = "deny"
 elided_lifetimes_in_paths = "warn"
 
 [workspace.lints.clippy]
+# alloc_instead_of_core = "warn"
+# std_instead_of_alloc = "warn"
+# std_instead_of_core = "warn"
 perf = "warn"
 style = "warn"
 complexity = "warn"
diff --git a/DEVELOPMENT.md b/DEVELOPMENT.md
index aa7d99eef3..82364e9b81 100644
--- a/DEVELOPMENT.md
+++ b/DEVELOPMENT.md
@@ -19,7 +19,7 @@ The contents of the Development Guide include:
 
 RustPython requires the following:
 
-- Rust latest stable version (e.g 1.69.0 as of Apr 20 2023)
+- Rust latest stable version (e.g 1.92.0 as of Jan 7 2026)
     - To check Rust version: `rustc --version` 
     - If you have `rustup` on your system, enter to update to the latest
       stable version: `rustup update stable`
@@ -118,19 +118,19 @@ exists a raw html viewer which is currently broken, and we welcome a PR to fix i
 Understanding a new codebase takes time. Here's a brief view of the
 repository's structure:
 
-- `compiler/src`: python compilation to bytecode
-  - `core/src`: python bytecode representation in rust structures
-  - `parser/src`: python lexing, parsing and ast
-- `derive/src`: Rust language extensions and macros specific to rustpython
+- `crates/compiler/src`: python compilation to bytecode
+  - `crates/compiler-core/src`: python bytecode representation in rust structures
+- `crates/derive/src` and `crates/derive-impl/src`: Rust language extensions and macros specific to rustpython
 - `Lib`: Carefully selected / copied files from CPython sourcecode. This is
    the python side of the standard library.
   - `test`: CPython test suite
-- `vm/src`: python virtual machine
+- `crates/vm/src`: python virtual machine
   - `builtins`: Builtin functions and types
   - `stdlib`: Standard library parts implemented in rust.
 - `src`: using the other subcrates to bring rustpython to life.
-- `wasm`: Binary crate and resources for WebAssembly build
-- `extra_tests`: extra integration test snippets as a supplement to `Lib/test`
+- `crates/wasm`: Binary crate and resources for WebAssembly build
+- `extra_tests`: extra integration test snippets as a supplement to `Lib/test`.
+  Add new RustPython-only regression tests here; do not place new tests under `Lib/test`.
 
 ## Understanding Internals
 
@@ -140,9 +140,9 @@ implementation is found in the `src` directory (specifically, `src/lib.rs`).
 
 The top-level `rustpython` binary depends on several lower-level crates including:
 
-- `rustpython-parser` (implementation in `compiler/parser/src`)
-- `rustpython-compiler` (implementation in `compiler/src`)
-- `rustpython-vm` (implementation in `vm/src`)
+- `ruff_python_parser` and `ruff_python_ast` (external dependencies from the Ruff project)
+- `rustpython-compiler` (implementation in `crates/compiler/src`)
+- `rustpython-vm` (implementation in `crates/vm/src`)
 
 Together, these crates provide the functions of a programming language and
 enable a line of code to go through a series of steps:
@@ -153,31 +153,26 @@ enable a line of code to go through a series of steps:
 - compile the AST into bytecode
 - execute the bytecode in the virtual machine (VM).
 
-### rustpython-parser
+### Parser and AST
 
-This crate contains the lexer and parser to convert a line of code to
-an Abstract Syntax Tree (AST):
+RustPython uses the Ruff project's parser and AST implementation:
 
-- Lexer: `compiler/parser/src/lexer.rs` converts Python source code into tokens
-- Parser: `compiler/parser/src/parser.rs` takes the tokens generated by the lexer and parses
-  the tokens into an AST (Abstract Syntax Tree) where the nodes of the syntax
-  tree are Rust structs and enums.
-  - The Parser relies on `LALRPOP`, a Rust parser generator framework. The
-    LALRPOP definition of Python's grammar is in `compiler/parser/src/python.lalrpop`.
-  - More information on parsers and a tutorial can be found in the 
-    [LALRPOP book](https://lalrpop.github.io/lalrpop/).
-- AST: `compiler/ast/` implements in Rust the Python types and expressions
-  represented by the AST nodes.
+- Parser: `ruff_python_parser` is used to convert Python source code into tokens
+  and parse them into an Abstract Syntax Tree (AST)
+- AST: `ruff_python_ast` provides the Rust types and expressions represented by
+  the AST nodes
+- These are external dependencies maintained by the Ruff project
+- For more information, visit the [Ruff GitHub repository](https://github.com/astral-sh/ruff)
 
 ### rustpython-compiler
 
 The `rustpython-compiler` crate's purpose is to transform the AST (Abstract Syntax
 Tree) to bytecode. The implementation of the compiler is found in the
-`compiler/src` directory. The compiler implements Python's symbol table,
+`crates/compiler/src` directory. The compiler implements Python's symbol table,
 ast->bytecode compiler, and bytecode optimizer in Rust.
 
-Implementation of bytecode structure in Rust is found in the `compiler/core/src`
-directory. `compiler/core/src/bytecode.rs` contains the representation of
+Implementation of bytecode structure in Rust is found in the `crates/compiler-core/src`
+directory. `crates/compiler-core/src/bytecode.rs` contains the representation of
 instructions and operations in Rust. Further information about Python's
 bytecode instructions can be found in the
 [Python documentation](https://docs.python.org/3/library/dis.html#bytecodes).
@@ -185,14 +180,14 @@ bytecode instructions can be found in the
 ### rustpython-vm
 
 The `rustpython-vm` crate has the important job of running the virtual machine that
-executes Python's instructions. The `vm/src` directory contains code to
+executes Python's instructions. The `crates/vm/src` directory contains code to
 implement the read and evaluation loop that fetches and dispatches
 instructions. This directory also contains the implementation of the
-Python Standard Library modules in Rust (`vm/src/stdlib`). In Python
-everything can be represented as an object. The `vm/src/builtins` directory holds
+Python Standard Library modules in Rust (`crates/vm/src/stdlib`). In Python
+everything can be represented as an object. The `crates/vm/src/builtins` directory holds
 the Rust code used to represent different Python objects and their methods. The
 core implementation of what a Python object is can be found in
-`vm/src/object/core.rs`.
+`crates/vm/src/object/core.rs`.
 
 ### Code generation
 
diff --git a/Lib/_android_support.py b/Lib/_android_support.py
index ae506f6a4b..a439d03a14 100644
--- a/Lib/_android_support.py
+++ b/Lib/_android_support.py
@@ -29,15 +29,19 @@ def init_streams(android_log_write, stdout_prio, stderr_prio):
 
     global logcat
     logcat = Logcat(android_log_write)
-
-    sys.stdout = TextLogStream(
-        stdout_prio, "python.stdout", sys.stdout.fileno())
-    sys.stderr = TextLogStream(
-        stderr_prio, "python.stderr", sys.stderr.fileno())
+    sys.stdout = TextLogStream(stdout_prio, "python.stdout", sys.stdout)
+    sys.stderr = TextLogStream(stderr_prio, "python.stderr", sys.stderr)
 
 
 class TextLogStream(io.TextIOWrapper):
-    def __init__(self, prio, tag, fileno=None, **kwargs):
+    def __init__(self, prio, tag, original=None, **kwargs):
+        # Respect the -u option.
+        if original:
+            kwargs.setdefault("write_through", original.write_through)
+            fileno = original.fileno()
+        else:
+            fileno = None
+
         # The default is surrogateescape for stdout and backslashreplace for
         # stderr, but in the context of an Android log, readability is more
         # important than reversibility.
diff --git a/Lib/_collections_abc.py b/Lib/_collections_abc.py
index de624f2e54..e02fc22738 100644
--- a/Lib/_collections_abc.py
+++ b/Lib/_collections_abc.py
@@ -512,7 +512,7 @@ def __getitem__(self, item):
             new_args = (t_args, t_result)
         return _CallableGenericAlias(Callable, tuple(new_args))
 
-    # TODO: RUSTPYTHON patch for common call
+    # TODO: RUSTPYTHON; patch for common call
     def __or__(self, other):
         super().__or__(other)
 
@@ -1087,7 +1087,7 @@ def __new__(cls, name, bases, namespace, **kwargs):
 
             warnings._deprecated(
                 "collections.abc.ByteString",
-                remove=(3, 14),
+                remove=(3, 17),
             )
         return super().__new__(cls, name, bases, namespace, **kwargs)
 
@@ -1096,14 +1096,18 @@ def __instancecheck__(cls, instance):
 
         warnings._deprecated(
             "collections.abc.ByteString",
-            remove=(3, 14),
+            remove=(3, 17),
         )
         return super().__instancecheck__(instance)
 
 class ByteString(Sequence, metaclass=_DeprecateByteStringMeta):
-    """This unifies bytes and bytearray.
+    """Deprecated ABC serving as a common supertype of ``bytes`` and ``bytearray``.
 
-    XXX Should add all their methods.
+    This ABC is scheduled for removal in Python 3.17.
+    Use ``isinstance(obj, collections.abc.Buffer)`` to test if ``obj``
+    implements the buffer protocol at runtime. For use in type annotations,
+    either use ``Buffer`` or a union that explicitly specifies the types your
+    code supports (e.g., ``bytes | bytearray | memoryview``).
     """
 
     __slots__ = ()
diff --git a/Lib/_colorize.py b/Lib/_colorize.py
index 70acfd4ad0..9eb6f0933b 100644
--- a/Lib/_colorize.py
+++ b/Lib/_colorize.py
@@ -1,21 +1,64 @@
+from __future__ import annotations
 import io
 import os
 import sys
 
 COLORIZE = True
 
+# types
+if False:
+    from typing import IO
+
 
 class ANSIColors:
-    BOLD_GREEN = "\x1b[1;32m"
-    BOLD_MAGENTA = "\x1b[1;35m"
-    BOLD_RED = "\x1b[1;31m"
+    RESET = "\x1b[0m"
+
+    BLACK = "\x1b[30m"
+    BLUE = "\x1b[34m"
+    CYAN = "\x1b[36m"
     GREEN = "\x1b[32m"
-    GREY = "\x1b[90m"
     MAGENTA = "\x1b[35m"
     RED = "\x1b[31m"
-    RESET = "\x1b[0m"
+    WHITE = "\x1b[37m"  # more like LIGHT GRAY
     YELLOW = "\x1b[33m"
 
+    BOLD_BLACK = "\x1b[1;30m"  # DARK GRAY
+    BOLD_BLUE = "\x1b[1;34m"
+    BOLD_CYAN = "\x1b[1;36m"
+    BOLD_GREEN = "\x1b[1;32m"
+    BOLD_MAGENTA = "\x1b[1;35m"
+    BOLD_RED = "\x1b[1;31m"
+    BOLD_WHITE = "\x1b[1;37m"  # actual WHITE
+    BOLD_YELLOW = "\x1b[1;33m"
+
+    # intense = like bold but without being bold
+    INTENSE_BLACK = "\x1b[90m"
+    INTENSE_BLUE = "\x1b[94m"
+    INTENSE_CYAN = "\x1b[96m"
+    INTENSE_GREEN = "\x1b[92m"
+    INTENSE_MAGENTA = "\x1b[95m"
+    INTENSE_RED = "\x1b[91m"
+    INTENSE_WHITE = "\x1b[97m"
+    INTENSE_YELLOW = "\x1b[93m"
+
+    BACKGROUND_BLACK = "\x1b[40m"
+    BACKGROUND_BLUE = "\x1b[44m"
+    BACKGROUND_CYAN = "\x1b[46m"
+    BACKGROUND_GREEN = "\x1b[42m"
+    BACKGROUND_MAGENTA = "\x1b[45m"
+    BACKGROUND_RED = "\x1b[41m"
+    BACKGROUND_WHITE = "\x1b[47m"
+    BACKGROUND_YELLOW = "\x1b[43m"
+
+    INTENSE_BACKGROUND_BLACK = "\x1b[100m"
+    INTENSE_BACKGROUND_BLUE = "\x1b[104m"
+    INTENSE_BACKGROUND_CYAN = "\x1b[106m"
+    INTENSE_BACKGROUND_GREEN = "\x1b[102m"
+    INTENSE_BACKGROUND_MAGENTA = "\x1b[105m"
+    INTENSE_BACKGROUND_RED = "\x1b[101m"
+    INTENSE_BACKGROUND_WHITE = "\x1b[107m"
+    INTENSE_BACKGROUND_YELLOW = "\x1b[103m"
+
 
 NoColors = ANSIColors()
 
@@ -24,14 +67,16 @@ class ANSIColors:
         setattr(NoColors, attr, "")
 
 
-def get_colors(colorize: bool = False, *, file=None) -> ANSIColors:
+def get_colors(
+    colorize: bool = False, *, file: IO[str] | IO[bytes] | None = None
+) -> ANSIColors:
     if colorize or can_colorize(file=file):
         return ANSIColors()
     else:
         return NoColors
 
 
-def can_colorize(*, file=None) -> bool:
+def can_colorize(*, file: IO[str] | IO[bytes] | None = None) -> bool:
     if file is None:
         file = sys.stdout
 
@@ -64,4 +109,4 @@ def can_colorize(*, file=None) -> bool:
     try:
         return os.isatty(file.fileno())
     except io.UnsupportedOperation:
-        return file.isatty()
+        return hasattr(file, "isatty") and file.isatty()
diff --git a/Lib/_dummy_thread.py b/Lib/_dummy_thread.py
index 424b0b3be5..0630d4e59f 100644
--- a/Lib/_dummy_thread.py
+++ b/Lib/_dummy_thread.py
@@ -11,15 +11,35 @@
         import _dummy_thread as _thread
 
 """
+
 # Exports only things specified by thread documentation;
 # skipping obsolete synonyms allocate(), start_new(), exit_thread().
-__all__ = ['error', 'start_new_thread', 'exit', 'get_ident', 'allocate_lock',
-           'interrupt_main', 'LockType', 'RLock',
-           '_count']
+__all__ = [
+    "error",
+    "start_new_thread",
+    "exit",
+    "get_ident",
+    "allocate_lock",
+    "interrupt_main",
+    "LockType",
+    "RLock",
+    "_count",
+    "start_joinable_thread",
+    "daemon_threads_allowed",
+    "_shutdown",
+    "_make_thread_handle",
+    "_ThreadHandle",
+    "_get_main_thread_ident",
+    "_is_main_interpreter",
+    "_local",
+]
 
 # A dummy value
 TIMEOUT_MAX = 2**31
 
+# Main thread ident for dummy implementation
+_MAIN_THREAD_IDENT = -1
+
 # NOTE: this module can be imported early in the extension building process,
 # and so top level imports of other modules should be avoided.  Instead, all
 # imports are done when needed on a function-by-function basis.  Since threads
@@ -27,6 +47,7 @@
 
 error = RuntimeError
 
+
 def start_new_thread(function, args, kwargs={}):
     """Dummy implementation of _thread.start_new_thread().
 
@@ -52,6 +73,7 @@ def start_new_thread(function, args, kwargs={}):
         pass
     except:
         import traceback
+
         traceback.print_exc()
     _main = True
     global _interrupt
@@ -59,10 +81,58 @@ def start_new_thread(function, args, kwargs={}):
         _interrupt = False
         raise KeyboardInterrupt
 
+
+def start_joinable_thread(function, handle=None, daemon=True):
+    """Dummy implementation of _thread.start_joinable_thread().
+
+    In dummy thread, we just run the function synchronously.
+    """
+    if handle is None:
+        handle = _ThreadHandle()
+    try:
+        function()
+    except SystemExit:
+        pass
+    except:
+        import traceback
+
+        traceback.print_exc()
+    handle._set_done()
+    return handle
+
+
+def daemon_threads_allowed():
+    """Dummy implementation of _thread.daemon_threads_allowed()."""
+    return True
+
+
+def _shutdown():
+    """Dummy implementation of _thread._shutdown()."""
+    pass
+
+
+def _make_thread_handle(ident):
+    """Dummy implementation of _thread._make_thread_handle()."""
+    handle = _ThreadHandle()
+    handle._ident = ident
+    return handle
+
+
+def _get_main_thread_ident():
+    """Dummy implementation of _thread._get_main_thread_ident()."""
+    return _MAIN_THREAD_IDENT
+
+
+def _is_main_interpreter():
+    """Dummy implementation of _thread._is_main_interpreter()."""
+    return True
+
+
 def exit():
     """Dummy implementation of _thread.exit()."""
     raise SystemExit
 
+
 def get_ident():
     """Dummy implementation of _thread.get_ident().
 
@@ -70,26 +140,31 @@ def get_ident():
     available, it is safe to assume that the current process is the
     only thread.  Thus a constant can be safely returned.
     """
-    return -1
+    return _MAIN_THREAD_IDENT
+
 
 def allocate_lock():
     """Dummy implementation of _thread.allocate_lock()."""
     return LockType()
 
+
 def stack_size(size=None):
     """Dummy implementation of _thread.stack_size()."""
     if size is not None:
         raise error("setting thread stack size not supported")
     return 0
 
+
 def _set_sentinel():
     """Dummy implementation of _thread._set_sentinel()."""
     return LockType()
 
+
 def _count():
     """Dummy implementation of _thread._count()."""
     return 0
 
+
 class LockType(object):
     """Class implementing dummy implementation of _thread.LockType.
 
@@ -125,6 +200,7 @@ def acquire(self, waitflag=None, timeout=-1):
             else:
                 if timeout > 0:
                     import time
+
                     time.sleep(timeout)
                 return False
 
@@ -153,14 +229,41 @@ def __repr__(self):
             "locked" if self.locked_status else "unlocked",
             self.__class__.__module__,
             self.__class__.__qualname__,
-            hex(id(self))
+            hex(id(self)),
         )
 
+
+class _ThreadHandle:
+    """Dummy implementation of _thread._ThreadHandle."""
+
+    def __init__(self):
+        self._ident = _MAIN_THREAD_IDENT
+        self._done = False
+
+    @property
+    def ident(self):
+        return self._ident
+
+    def _set_done(self):
+        self._done = True
+
+    def is_done(self):
+        return self._done
+
+    def join(self, timeout=None):
+        # In dummy thread, thread is always done
+        return
+
+    def __repr__(self):
+        return f"<_ThreadHandle ident={self._ident}>"
+
+
 # Used to signal that interrupt_main was called in a "thread"
 _interrupt = False
 # True when not executing in a "thread"
 _main = True
 
+
 def interrupt_main():
     """Set _interrupt flag to True to have start_new_thread raise
     KeyboardInterrupt upon exiting."""
@@ -170,6 +273,7 @@ def interrupt_main():
         global _interrupt
         _interrupt = True
 
+
 class RLock:
     def __init__(self):
         self.locked_count = 0
@@ -190,7 +294,7 @@ def release(self):
         return True
 
     def locked(self):
-        return self.locked_status != 0
+        return self.locked_count != 0
 
     def __repr__(self):
         return "<%s %s.%s object owner=%s count=%s at %s>" % (
@@ -199,5 +303,36 @@ def __repr__(self):
             self.__class__.__qualname__,
             get_ident() if self.locked_count else 0,
             self.locked_count,
-            hex(id(self))
+            hex(id(self)),
         )
+
+
+class _local:
+    """Dummy implementation of _thread._local (thread-local storage)."""
+
+    def __init__(self):
+        object.__setattr__(self, "_local__impl", {})
+
+    def __getattribute__(self, name):
+        if name.startswith("_local__"):
+            return object.__getattribute__(self, name)
+        impl = object.__getattribute__(self, "_local__impl")
+        try:
+            return impl[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __setattr__(self, name, value):
+        if name.startswith("_local__"):
+            return object.__setattr__(self, name, value)
+        impl = object.__getattribute__(self, "_local__impl")
+        impl[name] = value
+
+    def __delattr__(self, name):
+        if name.startswith("_local__"):
+            return object.__delattr__(self, name)
+        impl = object.__getattribute__(self, "_local__impl")
+        try:
+            del impl[name]
+        except KeyError:
+            raise AttributeError(name)
diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py
new file mode 100644
index 0000000000..34e73bf31b
--- /dev/null
+++ b/Lib/_opcode_metadata.py
@@ -0,0 +1,253 @@
+# This file is generated by scripts/generate_opcode_metadata.py
+# for RustPython bytecode format (CPython 3.13 compatible opcode numbers).
+# Do not edit!
+
+_specializations = {}
+
+_specialized_opmap = {}
+
+opmap = {
+    'CACHE': 0,
+    'BEFORE_ASYNC_WITH': 1,
+    'BEFORE_WITH': 2,
+    'BINARY_OP_INPLACE_ADD_UNICODE': 3,
+    'BINARY_SLICE': 4,
+    'BINARY_SUBSCR': 5,
+    'CHECK_EG_MATCH': 6,
+    'CHECK_EXC_MATCH': 7,
+    'CLEANUP_THROW': 8,
+    'DELETE_SUBSCR': 9,
+    'END_ASYNC_FOR': 10,
+    'END_FOR': 11,
+    'END_SEND': 12,
+    'EXIT_INIT_CHECK': 13,
+    'FORMAT_SIMPLE': 14,
+    'FORMAT_WITH_SPEC': 15,
+    'GET_AITER': 16,
+    'RESERVED': 17,
+    'GET_ANEXT': 18,
+    'GET_ITER': 19,
+    'GET_LEN': 20,
+    'GET_YIELD_FROM_ITER': 21,
+    'INTERPRETER_EXIT': 22,
+    'LOAD_ASSERTION_ERROR': 23,
+    'LOAD_BUILD_CLASS': 24,
+    'LOAD_LOCALS': 25,
+    'MAKE_FUNCTION': 26,
+    'MATCH_KEYS': 27,
+    'MATCH_MAPPING': 28,
+    'MATCH_SEQUENCE': 29,
+    'NOP': 30,
+    'POP_EXCEPT': 31,
+    'POP_TOP': 32,
+    'PUSH_EXC_INFO': 33,
+    'PUSH_NULL': 34,
+    'RETURN_GENERATOR': 35,
+    'RETURN_VALUE': 36,
+    'SETUP_ANNOTATIONS': 37,
+    'STORE_SLICE': 38,
+    'STORE_SUBSCR': 39,
+    'TO_BOOL': 40,
+    'UNARY_INVERT': 41,
+    'UNARY_NEGATIVE': 42,
+    'UNARY_NOT': 43,
+    'WITH_EXCEPT_START': 44,
+    'BINARY_OP': 45,
+    'BUILD_CONST_KEY_MAP': 46,
+    'BUILD_LIST': 47,
+    'BUILD_MAP': 48,
+    'BUILD_SET': 49,
+    'BUILD_SLICE': 50,
+    'BUILD_STRING': 51,
+    'BUILD_TUPLE': 52,
+    'CALL': 53,
+    'CALL_FUNCTION_EX': 54,
+    'CALL_INTRINSIC_1': 55,
+    'CALL_INTRINSIC_2': 56,
+    'CALL_KW': 57,
+    'COMPARE_OP': 58,
+    'CONTAINS_OP': 59,
+    'CONVERT_VALUE': 60,
+    'COPY': 61,
+    'COPY_FREE_VARS': 62,
+    'DELETE_ATTR': 63,
+    'DELETE_DEREF': 64,
+    'DELETE_FAST': 65,
+    'DELETE_GLOBAL': 66,
+    'DELETE_NAME': 67,
+    'DICT_MERGE': 68,
+    'DICT_UPDATE': 69,
+    'ENTER_EXECUTOR': 70,
+    'EXTENDED_ARG': 71,
+    'FOR_ITER': 72,
+    'GET_AWAITABLE': 73,
+    'IMPORT_FROM': 74,
+    'IMPORT_NAME': 75,
+    'IS_OP': 76,
+    'JUMP_BACKWARD': 77,
+    'JUMP_BACKWARD_NO_INTERRUPT': 78,
+    'JUMP_FORWARD': 79,
+    'LIST_APPEND': 80,
+    'LIST_EXTEND': 81,
+    'LOAD_ATTR': 82,
+    'LOAD_CONST': 83,
+    'LOAD_DEREF': 84,
+    'LOAD_FAST': 85,
+    'LOAD_FAST_AND_CLEAR': 86,
+    'LOAD_FAST_CHECK': 87,
+    'LOAD_FAST_LOAD_FAST': 88,
+    'LOAD_FROM_DICT_OR_DEREF': 89,
+    'LOAD_FROM_DICT_OR_GLOBALS': 90,
+    'LOAD_GLOBAL': 91,
+    'LOAD_NAME': 92,
+    'LOAD_SUPER_ATTR': 93,
+    'MAKE_CELL': 94,
+    'MAP_ADD': 95,
+    'MATCH_CLASS': 96,
+    'POP_JUMP_IF_FALSE': 97,
+    'POP_JUMP_IF_NONE': 98,
+    'POP_JUMP_IF_NOT_NONE': 99,
+    'POP_JUMP_IF_TRUE': 100,
+    'RAISE_VARARGS': 101,
+    'RERAISE': 102,
+    'RETURN_CONST': 103,
+    'SEND': 104,
+    'SET_ADD': 105,
+    'SET_FUNCTION_ATTRIBUTE': 106,
+    'SET_UPDATE': 107,
+    'STORE_ATTR': 108,
+    'STORE_DEREF': 109,
+    'STORE_FAST': 110,
+    'STORE_FAST_LOAD_FAST': 111,
+    'STORE_FAST_STORE_FAST': 112,
+    'STORE_GLOBAL': 113,
+    'STORE_NAME': 114,
+    'SWAP': 115,
+    'UNPACK_EX': 116,
+    'UNPACK_SEQUENCE': 117,
+    'YIELD_VALUE': 118,
+    'BREAK': 119,
+    'BUILD_LIST_FROM_TUPLES': 120,
+    'BUILD_MAP_FOR_CALL': 121,
+    'BUILD_SET_FROM_TUPLES': 122,
+    'BUILD_TUPLE_FROM_ITER': 123,
+    'BUILD_TUPLE_FROM_TUPLES': 124,
+    'BUILD_TEMPLATE': 125,
+    'BUILD_INTERPOLATION': 126,
+    'CONTINUE': 128,
+    'JUMP_IF_FALSE_OR_POP': 129,
+    'JUMP_IF_TRUE_OR_POP': 130,
+    'JUMP_IF_NOT_EXC_MATCH': 131,
+    'SET_EXC_INFO': 132,
+    'SUBSCRIPT': 133,
+    'RESUME': 149,
+    'BINARY_OP_ADD_FLOAT': 150,
+    'BINARY_OP_ADD_INT': 151,
+    'BINARY_OP_ADD_UNICODE': 152,
+    'BINARY_OP_MULTIPLY_FLOAT': 153,
+    'BINARY_OP_MULTIPLY_INT': 154,
+    'BINARY_OP_SUBTRACT_FLOAT': 155,
+    'BINARY_OP_SUBTRACT_INT': 156,
+    'BINARY_SUBSCR_DICT': 157,
+    'BINARY_SUBSCR_GETITEM': 158,
+    'BINARY_SUBSCR_LIST_INT': 159,
+    'BINARY_SUBSCR_STR_INT': 160,
+    'BINARY_SUBSCR_TUPLE_INT': 161,
+    'CALL_ALLOC_AND_ENTER_INIT': 162,
+    'CALL_BOUND_METHOD_EXACT_ARGS': 163,
+    'CALL_BOUND_METHOD_GENERAL': 164,
+    'CALL_BUILTIN_CLASS': 165,
+    'CALL_BUILTIN_FAST': 166,
+    'CALL_BUILTIN_FAST_WITH_KEYWORDS': 167,
+    'CALL_BUILTIN_O': 168,
+    'CALL_ISINSTANCE': 169,
+    'CALL_LEN': 170,
+    'CALL_LIST_APPEND': 171,
+    'CALL_METHOD_DESCRIPTOR_FAST': 172,
+    'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS': 173,
+    'CALL_METHOD_DESCRIPTOR_NOARGS': 174,
+    'CALL_METHOD_DESCRIPTOR_O': 175,
+    'CALL_NON_PY_GENERAL': 176,
+    'CALL_PY_EXACT_ARGS': 177,
+    'CALL_PY_GENERAL': 178,
+    'CALL_STR_1': 179,
+    'CALL_TUPLE_1': 180,
+    'CALL_TYPE_1': 181,
+    'COMPARE_OP_FLOAT': 182,
+    'COMPARE_OP_INT': 183,
+    'COMPARE_OP_STR': 184,
+    'CONTAINS_OP_DICT': 185,
+    'CONTAINS_OP_SET': 186,
+    'FOR_ITER_GEN': 187,
+    'FOR_ITER_LIST': 188,
+    'FOR_ITER_RANGE': 189,
+    'FOR_ITER_TUPLE': 190,
+    'LOAD_ATTR_CLASS': 191,
+    'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN': 192,
+    'LOAD_ATTR_INSTANCE_VALUE': 193,
+    'LOAD_ATTR_METHOD_LAZY_DICT': 194,
+    'LOAD_ATTR_METHOD_NO_DICT': 195,
+    'LOAD_ATTR_METHOD_WITH_VALUES': 196,
+    'LOAD_ATTR_MODULE': 197,
+    'LOAD_ATTR_NONDESCRIPTOR_NO_DICT': 198,
+    'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES': 199,
+    'LOAD_ATTR_PROPERTY': 200,
+    'LOAD_ATTR_SLOT': 201,
+    'LOAD_ATTR_WITH_HINT': 202,
+    'LOAD_GLOBAL_BUILTIN': 203,
+    'LOAD_GLOBAL_MODULE': 204,
+    'LOAD_SUPER_ATTR_ATTR': 205,
+    'LOAD_SUPER_ATTR_METHOD': 206,
+    'RESUME_CHECK': 207,
+    'SEND_GEN': 208,
+    'STORE_ATTR_INSTANCE_VALUE': 209,
+    'STORE_ATTR_SLOT': 210,
+    'STORE_ATTR_WITH_HINT': 211,
+    'STORE_SUBSCR_DICT': 212,
+    'STORE_SUBSCR_LIST_INT': 213,
+    'TO_BOOL_ALWAYS_TRUE': 214,
+    'TO_BOOL_BOOL': 215,
+    'TO_BOOL_INT': 216,
+    'TO_BOOL_LIST': 217,
+    'TO_BOOL_NONE': 218,
+    'TO_BOOL_STR': 219,
+    'UNPACK_SEQUENCE_LIST': 220,
+    'UNPACK_SEQUENCE_TUPLE': 221,
+    'UNPACK_SEQUENCE_TWO_TUPLE': 222,
+    'INSTRUMENTED_RESUME': 236,
+    'INSTRUMENTED_END_FOR': 237,
+    'INSTRUMENTED_END_SEND': 238,
+    'INSTRUMENTED_RETURN_VALUE': 239,
+    'INSTRUMENTED_RETURN_CONST': 240,
+    'INSTRUMENTED_YIELD_VALUE': 241,
+    'INSTRUMENTED_LOAD_SUPER_ATTR': 242,
+    'INSTRUMENTED_FOR_ITER': 243,
+    'INSTRUMENTED_CALL': 244,
+    'INSTRUMENTED_CALL_KW': 245,
+    'INSTRUMENTED_CALL_FUNCTION_EX': 246,
+    'INSTRUMENTED_INSTRUCTION': 247,
+    'INSTRUMENTED_JUMP_FORWARD': 248,
+    'INSTRUMENTED_JUMP_BACKWARD': 249,
+    'INSTRUMENTED_POP_JUMP_IF_TRUE': 250,
+    'INSTRUMENTED_POP_JUMP_IF_FALSE': 251,
+    'INSTRUMENTED_POP_JUMP_IF_NONE': 252,
+    'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253,
+    'INSTRUMENTED_LINE': 254,
+    'LOAD_CLOSURE': 255,
+    'JUMP': 256,
+    'JUMP_NO_INTERRUPT': 257,
+    'RESERVED_258': 258,
+    'LOAD_ATTR_METHOD': 259,
+    'LOAD_SUPER_METHOD': 260,
+    'LOAD_ZERO_SUPER_ATTR': 261,
+    'LOAD_ZERO_SUPER_METHOD': 262,
+    'POP_BLOCK': 263,
+    'SETUP_CLEANUP': 264,
+    'SETUP_FINALLY': 265,
+    'SETUP_WITH': 266,
+    'STORE_FAST_MAYBE_NULL': 267,
+}
+
+# CPython 3.13 compatible: opcodes < 44 have no argument
+HAVE_ARGUMENT = 44
+MIN_INSTRUMENTED_OPCODE = 236
diff --git a/Lib/_pydatetime.py b/Lib/_pydatetime.py
index cd0ea900bf..38e1f764f0 100644
--- a/Lib/_pydatetime.py
+++ b/Lib/_pydatetime.py
@@ -402,6 +402,8 @@ def _parse_hh_mm_ss_ff(tstr):
             raise ValueError("Invalid microsecond component")
         else:
             pos += 1
+            if not all(map(_is_ascii_digit, tstr[pos:])):
+                raise ValueError("Non-digit values in fraction")
 
             len_remainder = len_str - pos
 
@@ -413,9 +415,6 @@ def _parse_hh_mm_ss_ff(tstr):
             time_comps[3] = int(tstr[pos:(pos+to_parse)])
             if to_parse < 6:
                 time_comps[3] *= _FRACTION_CORRECTION[to_parse-1]
-            if (len_remainder > to_parse
-                    and not all(map(_is_ascii_digit, tstr[(pos+to_parse):]))):
-                raise ValueError("Non-digit values in unparsed fraction")
 
     return time_comps
 
@@ -556,10 +555,6 @@ def _check_tzinfo_arg(tz):
     if tz is not None and not isinstance(tz, tzinfo):
         raise TypeError("tzinfo argument must be None or of a tzinfo subclass")
 
-def _cmperror(x, y):
-    raise TypeError("can't compare '%s' to '%s'" % (
-                    type(x).__name__, type(y).__name__))
-
 def _divide_and_round(a, b):
     """divide a by b and round result to the nearest integer
 
@@ -970,6 +965,8 @@ def __new__(cls, year, month=None, day=None):
     @classmethod
     def fromtimestamp(cls, t):
         "Construct a date from a POSIX timestamp (like time.time())."
+        if t is None:
+            raise TypeError("'NoneType' object cannot be interpreted as an integer")
         y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)
         return cls(y, m, d)
 
@@ -1059,8 +1056,8 @@ def isoformat(self):
         This is 'YYYY-MM-DD'.
 
         References:
-        - http://www.w3.org/TR/NOTE-datetime
-        - http://www.cl.cam.ac.uk/~mgk25/iso-time.html
+        - https://www.w3.org/TR/NOTE-datetime
+        - https://www.cl.cam.ac.uk/~mgk25/iso-time.html
         """
         return "%04d-%02d-%02d" % (self._year, self._month, self._day)
 
@@ -1108,35 +1105,38 @@ def replace(self, year=None, month=None, day=None):
             day = self._day
         return type(self)(year, month, day)
 
+    __replace__ = replace
+
     # Comparisons of date objects with other.
 
     def __eq__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) == 0
         return NotImplemented
 
     def __le__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) <= 0
         return NotImplemented
 
     def __lt__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) < 0
         return NotImplemented
 
     def __ge__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) >= 0
         return NotImplemented
 
     def __gt__(self, other):
-        if isinstance(other, date):
+        if isinstance(other, date) and not isinstance(other, datetime):
             return self._cmp(other) > 0
         return NotImplemented
 
     def _cmp(self, other):
         assert isinstance(other, date)
+        assert not isinstance(other, datetime)
         y, m, d = self._year, self._month, self._day
         y2, m2, d2 = other._year, other._month, other._day
         return _cmp((y, m, d), (y2, m2, d2))
@@ -1191,7 +1191,7 @@ def isocalendar(self):
         The first week is 1; Monday is 1 ... Sunday is 7.
 
         ISO calendar algorithm taken from
-        http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
+        https://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
         (used with permission)
         """
         year = self._year
@@ -1633,6 +1633,8 @@ def replace(self, hour=None, minute=None, second=None, microsecond=None,
             fold = self._fold
         return type(self)(hour, minute, second, microsecond, tzinfo, fold=fold)
 
+    __replace__ = replace
+
     # Pickle support.
 
     def _getstate(self, protocol=3):
@@ -1680,7 +1682,7 @@ class datetime(date):
     The year, month and day arguments are required. tzinfo may be None, or an
     instance of a tzinfo subclass. The remaining arguments may be ints.
     """
-    __slots__ = date.__slots__ + time.__slots__
+    __slots__ = time.__slots__
 
     def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
                 microsecond=0, tzinfo=None, *, fold=0):
@@ -1979,6 +1981,8 @@ def replace(self, year=None, month=None, day=None, hour=None,
         return type(self)(year, month, day, hour, minute, second,
                           microsecond, tzinfo, fold=fold)
 
+    __replace__ = replace
+
     def _local_timezone(self):
         if self.tzinfo is None:
             ts = self._mktime()
@@ -2040,7 +2044,7 @@ def isoformat(self, sep='T', timespec='auto'):
         By default, the fractional part is omitted if self.microsecond == 0.
 
         If self.tzinfo is not None, the UTC offset is also attached, giving
-        giving a full format of 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM'.
+        a full format of 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM'.
 
         Optional argument sep specifies the separator between date and
         time, default 'T'.
@@ -2131,42 +2135,32 @@ def dst(self):
     def __eq__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other, allow_mixed=True) == 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            return False
+            return NotImplemented
 
     def __le__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) <= 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __lt__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) < 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __ge__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) >= 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def __gt__(self, other):
         if isinstance(other, datetime):
             return self._cmp(other) > 0
-        elif not isinstance(other, date):
-            return NotImplemented
         else:
-            _cmperror(self, other)
+            return NotImplemented
 
     def _cmp(self, other, allow_mixed=False):
         assert isinstance(other, datetime)
@@ -2311,7 +2305,6 @@ def __reduce__(self):
 
 def _isoweek1monday(year):
     # Helper to calculate the day number of the Monday starting week 1
-    # XXX This could be done more efficiently
     THURSDAY = 3
     firstday = _ymd2ord(year, 1, 1)
     firstweekday = (firstday + 6) % 7  # See weekday() above
@@ -2341,6 +2334,9 @@ def __new__(cls, offset, name=_Omitted):
                              "timedelta(hours=24).")
         return cls._create(offset, name)
 
+    def __init_subclass__(cls):
+        raise TypeError("type 'datetime.timezone' is not an acceptable base type")
+
     @classmethod
     def _create(cls, offset, name=None):
         self = tzinfo.__new__(cls)
diff --git a/Lib/_pydecimal.py b/Lib/_pydecimal.py
index a0b608380a..ff80180a79 100644
--- a/Lib/_pydecimal.py
+++ b/Lib/_pydecimal.py
@@ -13,104 +13,7 @@
 # bug) and will be backported.  At this point the spec is stabilizing
 # and the updates are becoming fewer, smaller, and less significant.
 
-"""
-This is an implementation of decimal floating point arithmetic based on
-the General Decimal Arithmetic Specification:
-
-    http://speleotrove.com/decimal/decarith.html
-
-and IEEE standard 854-1987:
-
-    http://en.wikipedia.org/wiki/IEEE_854-1987
-
-Decimal floating point has finite precision with arbitrarily large bounds.
-
-The purpose of this module is to support arithmetic using familiar
-"schoolhouse" rules and to avoid some of the tricky representation
-issues associated with binary floating point.  The package is especially
-useful for financial applications or for contexts where users have
-expectations that are at odds with binary floating point (for instance,
-in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead
-of 0.0; Decimal('1.00') % Decimal('0.1') returns the expected
-Decimal('0.00')).
-
-Here are some examples of using the decimal module:
-
->>> from decimal import *
->>> setcontext(ExtendedContext)
->>> Decimal(0)
-Decimal('0')
->>> Decimal('1')
-Decimal('1')
->>> Decimal('-.0123')
-Decimal('-0.0123')
->>> Decimal(123456)
-Decimal('123456')
->>> Decimal('123.45e12345678')
-Decimal('1.2345E+12345680')
->>> Decimal('1.33') + Decimal('1.27')
-Decimal('2.60')
->>> Decimal('12.34') + Decimal('3.87') - Decimal('18.41')
-Decimal('-2.20')
->>> dig = Decimal(1)
->>> print(dig / Decimal(3))
-0.333333333
->>> getcontext().prec = 18
->>> print(dig / Decimal(3))
-0.333333333333333333
->>> print(dig.sqrt())
-1
->>> print(Decimal(3).sqrt())
-1.73205080756887729
->>> print(Decimal(3) ** 123)
-4.85192780976896427E+58
->>> inf = Decimal(1) / Decimal(0)
->>> print(inf)
-Infinity
->>> neginf = Decimal(-1) / Decimal(0)
->>> print(neginf)
--Infinity
->>> print(neginf + inf)
-NaN
->>> print(neginf * inf)
--Infinity
->>> print(dig / 0)
-Infinity
->>> getcontext().traps[DivisionByZero] = 1
->>> print(dig / 0)
-Traceback (most recent call last):
-  ...
-  ...
-  ...
-decimal.DivisionByZero: x / 0
->>> c = Context()
->>> c.traps[InvalidOperation] = 0
->>> print(c.flags[InvalidOperation])
-0
->>> c.divide(Decimal(0), Decimal(0))
-Decimal('NaN')
->>> c.traps[InvalidOperation] = 1
->>> print(c.flags[InvalidOperation])
-1
->>> c.flags[InvalidOperation] = 0
->>> print(c.flags[InvalidOperation])
-0
->>> print(c.divide(Decimal(0), Decimal(0)))
-Traceback (most recent call last):
-  ...
-  ...
-  ...
-decimal.InvalidOperation: 0 / 0
->>> print(c.flags[InvalidOperation])
-1
->>> c.flags[InvalidOperation] = 0
->>> c.traps[InvalidOperation] = 0
->>> print(c.divide(Decimal(0), Decimal(0)))
-NaN
->>> print(c.flags[InvalidOperation])
-1
->>>
-"""
+"""Python decimal arithmetic module"""
 
 __all__ = [
     # Two major classes
@@ -140,8 +43,11 @@
     # Limits for the C version for compatibility
     'MAX_PREC',  'MAX_EMAX', 'MIN_EMIN', 'MIN_ETINY',
 
-    # C version: compile time choice that enables the thread local context
-    'HAVE_THREADS'
+    # C version: compile time choice that enables the thread local context (deprecated, now always true)
+    'HAVE_THREADS',
+
+    # C version: compile time choice that enables the coroutine local context
+    'HAVE_CONTEXTVAR'
 ]
 
 __xname__ = __name__    # sys.modules lookup (--without-threads)
@@ -156,7 +62,7 @@
 
 try:
     from collections import namedtuple as _namedtuple
-    DecimalTuple = _namedtuple('DecimalTuple', 'sign digits exponent')
+    DecimalTuple = _namedtuple('DecimalTuple', 'sign digits exponent', module='decimal')
 except ImportError:
     DecimalTuple = lambda *args: args
 
@@ -172,6 +78,7 @@
 
 # Compatibility with the C version
 HAVE_THREADS = True
+HAVE_CONTEXTVAR = True
 if sys.maxsize == 2**63-1:
     MAX_PREC = 999999999999999999
     MAX_EMAX = 999999999999999999
@@ -190,7 +97,7 @@ class DecimalException(ArithmeticError):
 
     Used exceptions derive from this.
     If an exception derives from another exception besides this (such as
-    Underflow (Inexact, Rounded, Subnormal) that indicates that it is only
+    Underflow (Inexact, Rounded, Subnormal)) that indicates that it is only
     called if the others are present.  This isn't actually used for
     anything, though.
 
@@ -238,7 +145,7 @@ class InvalidOperation(DecimalException):
     x ** (+-)INF
     An operand is invalid
 
-    The result of the operation after these is a quiet positive NaN,
+    The result of the operation after this is a quiet positive NaN,
     except when the cause is a signaling NaN, in which case the result is
     also a quiet NaN, but with the original sign, and an optional
     diagnostic information.
@@ -431,82 +338,40 @@ class FloatOperation(DecimalException, TypeError):
 ##### Context Functions ##################################################
 
 # The getcontext() and setcontext() function manage access to a thread-local
-# current context.  Py2.4 offers direct support for thread locals.  If that
-# is not available, use threading.current_thread() which is slower but will
-# work for older Pythons.  If threads are not part of the build, create a
-# mock threading object with threading.local() returning the module namespace.
-
-try:
-    import threading
-except ImportError:
-    # Python was compiled without threads; create a mock object instead
-    class MockThreading(object):
-        def local(self, sys=sys):
-            return sys.modules[__xname__]
-    threading = MockThreading()
-    del MockThreading
-
-try:
-    threading.local
-
-except AttributeError:
-
-    # To fix reloading, force it to create a new context
-    # Old contexts have different exceptions in their dicts, making problems.
-    if hasattr(threading.current_thread(), '__decimal_context__'):
-        del threading.current_thread().__decimal_context__
+# current context.
 
-    def setcontext(context):
-        """Set this thread's context to context."""
-        if context in (DefaultContext, BasicContext, ExtendedContext):
-            context = context.copy()
-            context.clear_flags()
-        threading.current_thread().__decimal_context__ = context
+import contextvars
 
-    def getcontext():
-        """Returns this thread's context.
+_current_context_var = contextvars.ContextVar('decimal_context')
 
-        If this thread does not yet have a context, returns
-        a new context and sets this thread's context.
-        New contexts are copies of DefaultContext.
-        """
-        try:
-            return threading.current_thread().__decimal_context__
-        except AttributeError:
-            context = Context()
-            threading.current_thread().__decimal_context__ = context
-            return context
+_context_attributes = frozenset(
+    ['prec', 'Emin', 'Emax', 'capitals', 'clamp', 'rounding', 'flags', 'traps']
+)
 
-else:
+def getcontext():
+    """Returns this thread's context.
 
-    local = threading.local()
-    if hasattr(local, '__decimal_context__'):
-        del local.__decimal_context__
+    If this thread does not yet have a context, returns
+    a new context and sets this thread's context.
+    New contexts are copies of DefaultContext.
+    """
+    try:
+        return _current_context_var.get()
+    except LookupError:
+        context = Context()
+        _current_context_var.set(context)
+        return context
+
+def setcontext(context):
+    """Set this thread's context to context."""
+    if context in (DefaultContext, BasicContext, ExtendedContext):
+        context = context.copy()
+        context.clear_flags()
+    _current_context_var.set(context)
 
-    def getcontext(_local=local):
-        """Returns this thread's context.
+del contextvars        # Don't contaminate the namespace
 
-        If this thread does not yet have a context, returns
-        a new context and sets this thread's context.
-        New contexts are copies of DefaultContext.
-        """
-        try:
-            return _local.__decimal_context__
-        except AttributeError:
-            context = Context()
-            _local.__decimal_context__ = context
-            return context
-
-    def setcontext(context, _local=local):
-        """Set this thread's context to context."""
-        if context in (DefaultContext, BasicContext, ExtendedContext):
-            context = context.copy()
-            context.clear_flags()
-        _local.__decimal_context__ = context
-
-    del threading, local        # Don't contaminate the namespace
-
-def localcontext(ctx=None):
+def localcontext(ctx=None, **kwargs):
     """Return a context manager for a copy of the supplied context
 
     Uses a copy of the current context if no context is specified
@@ -542,8 +407,14 @@ def sin(x):
     >>> print(getcontext().prec)
     28
     """
-    if ctx is None: ctx = getcontext()
-    return _ContextManager(ctx)
+    if ctx is None:
+        ctx = getcontext()
+    ctx_manager = _ContextManager(ctx)
+    for key, value in kwargs.items():
+        if key not in _context_attributes:
+            raise TypeError(f"'{key}' is an invalid keyword argument for this function")
+        setattr(ctx_manager.new_context, key, value)
+    return ctx_manager
 
 
 ##### Decimal class #######################################################
@@ -553,7 +424,7 @@ def sin(x):
 # numbers.py for more detail.
 
 class Decimal(object):
-    """Floating point class for decimal arithmetic."""
+    """Floating-point class for decimal arithmetic."""
 
     __slots__ = ('_exp','_int','_sign', '_is_special')
     # Generally, the value of the Decimal instance is given by
@@ -993,7 +864,7 @@ def __hash__(self):
             if self.is_snan():
                 raise TypeError('Cannot hash a signaling NaN value.')
             elif self.is_nan():
-                return _PyHASH_NAN
+                return object.__hash__(self)
             else:
                 if self._sign:
                     return -_PyHASH_INF
@@ -1674,13 +1545,13 @@ def __int__(self):
 
     __trunc__ = __int__
 
+    @property
     def real(self):
         return self
-    real = property(real)
 
+    @property
     def imag(self):
         return Decimal(0)
-    imag = property(imag)
 
     def conjugate(self):
         return self
@@ -2260,10 +2131,16 @@ def _power_exact(self, other, p):
             else:
                 return None
 
-            if xc >= 10**p:
+            # An exact power of 10 is representable, but can convert to a
+            # string of any length. But an exact power of 10 shouldn't be
+            # possible at this point.
+            assert xc > 1, self
+            assert xc % 10 != 0, self
+            strxc = str(xc)
+            if len(strxc) > p:
                 return None
             xe = -e-xe
-            return _dec_from_triple(0, str(xc), xe)
+            return _dec_from_triple(0, strxc, xe)
 
         # now y is positive; find m and n such that y = m/n
         if ye >= 0:
@@ -2272,7 +2149,7 @@ def _power_exact(self, other, p):
             if xe != 0 and len(str(abs(yc*xe))) <= -ye:
                 return None
             xc_bits = _nbits(xc)
-            if xc != 1 and len(str(abs(yc)*xc_bits)) <= -ye:
+            if len(str(abs(yc)*xc_bits)) <= -ye:
                 return None
             m, n = yc, 10**(-ye)
             while m % 2 == n % 2 == 0:
@@ -2285,7 +2162,7 @@ def _power_exact(self, other, p):
         # compute nth root of xc*10**xe
         if n > 1:
             # if 1 < xc < 2**n then xc isn't an nth power
-            if xc != 1 and xc_bits <= n:
+            if xc_bits <= n:
                 return None
 
             xe, rem = divmod(xe, n)
@@ -2313,13 +2190,18 @@ def _power_exact(self, other, p):
             return None
         xc = xc**m
         xe *= m
-        if xc > 10**p:
+        # An exact power of 10 is representable, but can convert to a string
+        # of any length. But an exact power of 10 shouldn't be possible at
+        # this point.
+        assert xc > 1, self
+        assert xc % 10 != 0, self
+        str_xc = str(xc)
+        if len(str_xc) > p:
             return None
 
         # by this point the result *is* exactly representable
         # adjust the exponent to get as close as possible to the ideal
         # exponent, if necessary
-        str_xc = str(xc)
         if other._isinteger() and other._sign == 0:
             ideal_exponent = self._exp*int(other)
             zeros = min(xe-ideal_exponent, p-len(str_xc))
@@ -3837,6 +3719,10 @@ def __format__(self, specifier, context=None, _localeconv=None):
         # represented in fixed point; rescale them to 0e0.
         if not self and self._exp > 0 and spec['type'] in 'fF%':
             self = self._rescale(0, rounding)
+        if not self and spec['no_neg_0'] and self._sign:
+            adjusted_sign = 0
+        else:
+            adjusted_sign = self._sign
 
         # figure out placement of the decimal point
         leftdigits = self._exp + len(self._int)
@@ -3867,7 +3753,7 @@ def __format__(self, specifier, context=None, _localeconv=None):
 
         # done with the decimal-specific stuff;  hand over the rest
         # of the formatting to the _format_number function
-        return _format_number(self._sign, intpart, fracpart, exp, spec)
+        return _format_number(adjusted_sign, intpart, fracpart, exp, spec)
 
 def _dec_from_triple(sign, coefficient, exponent, special=False):
     """Create a decimal instance directly, without any validation,
@@ -5677,8 +5563,6 @@ def __init__(self, value=None):
     def __repr__(self):
         return "(%r, %r, %r)" % (self.sign, self.int, self.exp)
 
-    __str__ = __repr__
-
 
 
 def _normalize(op1, op2, prec = 0):
@@ -6187,7 +6071,7 @@ def _convert_for_comparison(self, other, equality_op=False):
 #
 # A format specifier for Decimal looks like:
 #
-#   [[fill]align][sign][#][0][minimumwidth][,][.precision][type]
+#   [[fill]align][sign][z][#][0][minimumwidth][,][.precision][type]
 
 _parse_format_specifier_regex = re.compile(r"""\A
 (?:
@@ -6195,6 +6079,7 @@ def _convert_for_comparison(self, other, equality_op=False):
    (?P<align>[<>=^])
 )?
 (?P<sign>[-+ ])?
+(?P<no_neg_0>z)?
 (?P<alt>\#)?
 (?P<zeropad>0)?
 (?P<minimumwidth>(?!0)\d+)?
diff --git a/Lib/_pyio.py b/Lib/_pyio.py
index 2629ed9e00..48c8f770f8 100644
--- a/Lib/_pyio.py
+++ b/Lib/_pyio.py
@@ -33,11 +33,8 @@
 # Rebind for compatibility
 BlockingIOError = BlockingIOError
 
-# Does io.IOBase finalizer log the exception if the close() method fails?
-# The exception is ignored silently by default in release build.
-_IOBASE_EMITS_UNRAISABLE = (hasattr(sys, "gettotalrefcount") or sys.flags.dev_mode)
 # Does open() check its 'errors' argument?
-_CHECK_ERRORS = _IOBASE_EMITS_UNRAISABLE
+_CHECK_ERRORS = (hasattr(sys, "gettotalrefcount") or sys.flags.dev_mode)
 
 
 def text_encoding(encoding, stacklevel=2):
@@ -416,18 +413,12 @@ def __del__(self):
         if closed:
             return
 
-        if _IOBASE_EMITS_UNRAISABLE:
-            self.close()
-        else:
-            # The try/except block is in case this is called at program
-            # exit time, when it's possible that globals have already been
-            # deleted, and then the close() call might fail.  Since
-            # there's nothing we can do about such failures and they annoy
-            # the end users, we suppress the traceback.
-            try:
-                self.close()
-            except:
-                pass
+        if dealloc_warn := getattr(self, "_dealloc_warn", None):
+            dealloc_warn(self)
+
+        # If close() fails, the caller logs the exception with
+        # sys.unraisablehook. close() must be called at the end at __del__().
+        self.close()
 
     ### Inquiries ###
 
@@ -632,16 +623,15 @@ def read(self, size=-1):
         n = self.readinto(b)
         if n is None:
             return None
+        if n < 0 or n > len(b):
+            raise ValueError(f"readinto returned {n} outside buffer size {len(b)}")
         del b[n:]
         return bytes(b)
 
     def readall(self):
         """Read until EOF, using multiple read() call."""
         res = bytearray()
-        while True:
-            data = self.read(DEFAULT_BUFFER_SIZE)
-            if not data:
-                break
+        while data := self.read(DEFAULT_BUFFER_SIZE):
             res += data
         if res:
             return bytes(res)
@@ -666,8 +656,6 @@ def write(self, b):
         self._unsupported("write")
 
 io.RawIOBase.register(RawIOBase)
-from _io import FileIO
-RawIOBase.register(FileIO)
 
 
 class BufferedIOBase(IOBase):
@@ -874,6 +862,10 @@ def __repr__(self):
         else:
             return "<{}.{} name={!r}>".format(modname, clsname, name)
 
+    def _dealloc_warn(self, source):
+        if dealloc_warn := getattr(self.raw, "_dealloc_warn", None):
+            dealloc_warn(source)
+
     ### Lower-level APIs ###
 
     def fileno(self):
@@ -1511,6 +1503,11 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
         if isinstance(file, float):
             raise TypeError('integer argument expected, got float')
         if isinstance(file, int):
+            if isinstance(file, bool):
+                import warnings
+                warnings.warn("bool is used as a file descriptor",
+                              RuntimeWarning, stacklevel=2)
+                file = int(file)
             fd = file
             if fd < 0:
                 raise ValueError('negative file descriptor')
@@ -1569,7 +1566,8 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
                     if not isinstance(fd, int):
                         raise TypeError('expected integer from opener')
                     if fd < 0:
-                        raise OSError('Negative file descriptor')
+                        # bpo-27066: Raise a ValueError for bad value.
+                        raise ValueError(f'opener returned {fd}')
                 owned_fd = fd
                 if not noinherit_flag:
                     os.set_inheritable(fd, False)
@@ -1608,12 +1606,11 @@ def __init__(self, file, mode='r', closefd=True, opener=None):
             raise
         self._fd = fd
 
-    def __del__(self):
+    def _dealloc_warn(self, source):
         if self._fd >= 0 and self._closefd and not self.closed:
             import warnings
-            warnings.warn('unclosed file %r' % (self,), ResourceWarning,
+            warnings.warn(f'unclosed file {source!r}', ResourceWarning,
                           stacklevel=2, source=self)
-            self.close()
 
     def __getstate__(self):
         raise TypeError(f"cannot pickle {self.__class__.__name__!r} object")
@@ -1757,7 +1754,7 @@ def close(self):
         """
         if not self.closed:
             try:
-                if self._closefd:
+                if self._closefd and self._fd >= 0:
                     os.close(self._fd)
             finally:
                 super().close()
@@ -2649,6 +2646,10 @@ def readline(self, size=None):
     def newlines(self):
         return self._decoder.newlines if self._decoder else None
 
+    def _dealloc_warn(self, source):
+        if dealloc_warn := getattr(self.buffer, "_dealloc_warn", None):
+            dealloc_warn(source)
+
 
 class StringIO(TextIOWrapper):
     """Text I/O implementation using an in-memory buffer.
diff --git a/Lib/_strptime.py b/Lib/_strptime.py
index 798cf9f9d3..a07eb5f923 100644
--- a/Lib/_strptime.py
+++ b/Lib/_strptime.py
@@ -10,10 +10,13 @@
     strptime -- Calculates the time struct represented by the passed-in string
 
 """
+import os
 import time
 import locale
 import calendar
+import re
 from re import compile as re_compile
+from re import sub as re_sub
 from re import IGNORECASE
 from re import escape as re_escape
 from datetime import (date as datetime_date,
@@ -27,6 +30,41 @@ def _getlang():
     # Figure out what the current language is set to.
     return locale.getlocale(locale.LC_TIME)
 
+def _findall(haystack, needle):
+    # Find all positions of needle in haystack.
+    if not needle:
+        return
+    i = 0
+    while True:
+        i = haystack.find(needle, i)
+        if i < 0:
+            break
+        yield i
+        i += len(needle)
+
+def _fixmonths(months):
+    yield from months
+    # The lower case of 'İ' ('\u0130') is 'i\u0307'.
+    # The re module only supports 1-to-1 character matching in
+    # case-insensitive mode.
+    for s in months:
+        if 'i\u0307' in s:
+            yield s.replace('i\u0307', '\u0130')
+
+lzh_TW_alt_digits = (
+    # 〇:一:二:三:四:五:六:七:八:九
+    '\u3007', '\u4e00', '\u4e8c', '\u4e09', '\u56db',
+    '\u4e94', '\u516d', '\u4e03', '\u516b', '\u4e5d',
+    # 十:十一:十二:十三:十四:十五:十六:十七:十八:十九
+    '\u5341', '\u5341\u4e00', '\u5341\u4e8c', '\u5341\u4e09', '\u5341\u56db',
+    '\u5341\u4e94', '\u5341\u516d', '\u5341\u4e03', '\u5341\u516b', '\u5341\u4e5d',
+    # 廿:廿一:廿二:廿三:廿四:廿五:廿六:廿七:廿八:廿九
+    '\u5eff', '\u5eff\u4e00', '\u5eff\u4e8c', '\u5eff\u4e09', '\u5eff\u56db',
+    '\u5eff\u4e94', '\u5eff\u516d', '\u5eff\u4e03', '\u5eff\u516b', '\u5eff\u4e5d',
+    # 卅:卅一
+    '\u5345', '\u5345\u4e00')
+
+
 class LocaleTime(object):
     """Stores and handles locale-specific information related to time.
 
@@ -70,6 +108,7 @@ def __init__(self):
         self.__calc_weekday()
         self.__calc_month()
         self.__calc_am_pm()
+        self.__calc_alt_digits()
         self.__calc_timezone()
         self.__calc_date_time()
         if _getlang() != self.lang:
@@ -101,53 +140,184 @@ def __calc_am_pm(self):
         am_pm = []
         for hour in (1, 22):
             time_tuple = time.struct_time((1999,3,17,hour,44,55,2,76,0))
-            am_pm.append(time.strftime("%p", time_tuple).lower())
+            # br_FR has AM/PM info (' ',' ').
+            am_pm.append(time.strftime("%p", time_tuple).lower().strip())
         self.am_pm = am_pm
 
+    def __calc_alt_digits(self):
+        # Set self.LC_alt_digits by using time.strftime().
+
+        # The magic data should contain all decimal digits.
+        time_tuple = time.struct_time((1998, 1, 27, 10, 43, 56, 1, 27, 0))
+        s = time.strftime("%x%X", time_tuple)
+        if s.isascii():
+            # Fast path -- all digits are ASCII.
+            self.LC_alt_digits = ()
+            return
+
+        digits = ''.join(sorted(set(re.findall(r'\d', s))))
+        if len(digits) == 10 and ord(digits[-1]) == ord(digits[0]) + 9:
+            # All 10 decimal digits from the same set.
+            if digits.isascii():
+                # All digits are ASCII.
+                self.LC_alt_digits = ()
+                return
+
+            self.LC_alt_digits = [a + b for a in digits for b in digits]
+            # Test whether the numbers contain leading zero.
+            time_tuple2 = time.struct_time((2000, 1, 1, 1, 1, 1, 5, 1, 0))
+            if self.LC_alt_digits[1] not in time.strftime("%x %X", time_tuple2):
+                self.LC_alt_digits[:10] = digits
+            return
+
+        # Either non-Gregorian calendar or non-decimal numbers.
+        if {'\u4e00', '\u4e03', '\u4e5d', '\u5341', '\u5eff'}.issubset(s):
+            # lzh_TW
+            self.LC_alt_digits = lzh_TW_alt_digits
+            return
+
+        self.LC_alt_digits = None
+
     def __calc_date_time(self):
-        # Set self.date_time, self.date, & self.time by using
-        # time.strftime().
+        # Set self.LC_date_time, self.LC_date, self.LC_time and
+        # self.LC_time_ampm by using time.strftime().
 
         # Use (1999,3,17,22,44,55,2,76,0) for magic date because the amount of
         # overloaded numbers is minimized.  The order in which searches for
         # values within the format string is very important; it eliminates
         # possible ambiguity for what something represents.
         time_tuple = time.struct_time((1999,3,17,22,44,55,2,76,0))
-        date_time = [None, None, None]
-        date_time[0] = time.strftime("%c", time_tuple).lower()
-        date_time[1] = time.strftime("%x", time_tuple).lower()
-        date_time[2] = time.strftime("%X", time_tuple).lower()
-        replacement_pairs = [('%', '%%'), (self.f_weekday[2], '%A'),
-                    (self.f_month[3], '%B'), (self.a_weekday[2], '%a'),
-                    (self.a_month[3], '%b'), (self.am_pm[1], '%p'),
-                    ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
-                    ('44', '%M'), ('55', '%S'), ('76', '%j'),
-                    ('17', '%d'), ('03', '%m'), ('3', '%m'),
-                    # '3' needed for when no leading zero.
-                    ('2', '%w'), ('10', '%I')]
-        replacement_pairs.extend([(tz, "%Z") for tz_values in self.timezone
-                                                for tz in tz_values])
-        for offset,directive in ((0,'%c'), (1,'%x'), (2,'%X')):
-            current_format = date_time[offset]
-            for old, new in replacement_pairs:
+        time_tuple2 = time.struct_time((1999,1,3,1,1,1,6,3,0))
+        replacement_pairs = []
+
+        # Non-ASCII digits
+        if self.LC_alt_digits or self.LC_alt_digits is None:
+            for n, d in [(19, '%OC'), (99, '%Oy'), (22, '%OH'),
+                         (44, '%OM'), (55, '%OS'), (17, '%Od'),
+                         (3, '%Om'), (2, '%Ow'), (10, '%OI')]:
+                if self.LC_alt_digits is None:
+                    s = chr(0x660 + n // 10) + chr(0x660 + n % 10)
+                    replacement_pairs.append((s, d))
+                    if n < 10:
+                        replacement_pairs.append((s[1], d))
+                elif len(self.LC_alt_digits) > n:
+                    replacement_pairs.append((self.LC_alt_digits[n], d))
+                else:
+                    replacement_pairs.append((time.strftime(d, time_tuple), d))
+        replacement_pairs += [
+            ('1999', '%Y'), ('99', '%y'), ('22', '%H'),
+            ('44', '%M'), ('55', '%S'), ('76', '%j'),
+            ('17', '%d'), ('03', '%m'), ('3', '%m'),
+            # '3' needed for when no leading zero.
+            ('2', '%w'), ('10', '%I'),
+        ]
+
+        date_time = []
+        for directive in ('%c', '%x', '%X', '%r'):
+            current_format = time.strftime(directive, time_tuple).lower()
+            current_format = current_format.replace('%', '%%')
+            # The month and the day of the week formats are treated specially
+            # because of a possible ambiguity in some locales where the full
+            # and abbreviated names are equal or names of different types
+            # are equal. See doc of __find_month_format for more details.
+            lst, fmt = self.__find_weekday_format(directive)
+            if lst:
+                current_format = current_format.replace(lst[2], fmt, 1)
+            lst, fmt = self.__find_month_format(directive)
+            if lst:
+                current_format = current_format.replace(lst[3], fmt, 1)
+            if self.am_pm[1]:
                 # Must deal with possible lack of locale info
                 # manifesting itself as the empty string (e.g., Swedish's
                 # lack of AM/PM info) or a platform returning a tuple of empty
                 # strings (e.g., MacOS 9 having timezone as ('','')).
-                if old:
-                    current_format = current_format.replace(old, new)
+                current_format = current_format.replace(self.am_pm[1], '%p')
+            for tz_values in self.timezone:
+                for tz in tz_values:
+                    if tz:
+                        current_format = current_format.replace(tz, "%Z")
+            # Transform all non-ASCII digits to digits in range U+0660 to U+0669.
+            if not current_format.isascii() and self.LC_alt_digits is None:
+                current_format = re_sub(r'\d(?<![0-9])',
+                                        lambda m: chr(0x0660 + int(m[0])),
+                                        current_format)
+            for old, new in replacement_pairs:
+                current_format = current_format.replace(old, new)
             # If %W is used, then Sunday, 2005-01-03 will fall on week 0 since
             # 2005-01-03 occurs before the first Monday of the year.  Otherwise
             # %U is used.
-            time_tuple = time.struct_time((1999,1,3,1,1,1,6,3,0))
-            if '00' in time.strftime(directive, time_tuple):
+            if '00' in time.strftime(directive, time_tuple2):
                 U_W = '%W'
             else:
                 U_W = '%U'
-            date_time[offset] = current_format.replace('11', U_W)
+            current_format = current_format.replace('11', U_W)
+            date_time.append(current_format)
         self.LC_date_time = date_time[0]
         self.LC_date = date_time[1]
         self.LC_time = date_time[2]
+        self.LC_time_ampm = date_time[3]
+
+    def __find_month_format(self, directive):
+        """Find the month format appropriate for the current locale.
+
+        In some locales (for example French and Hebrew), the default month
+        used in __calc_date_time has the same name in full and abbreviated
+        form.  Also, the month name can by accident match other part of the
+        representation: the day of the week name (for example in Morisyen)
+        or the month number (for example in Japanese).  Thus, cycle months
+        of the year and find all positions that match the month name for
+        each month,  If no common positions are found, the representation
+        does not use the month name.
+        """
+        full_indices = abbr_indices = None
+        for m in range(1, 13):
+            time_tuple = time.struct_time((1999, m, 17, 22, 44, 55, 2, 76, 0))
+            datetime = time.strftime(directive, time_tuple).lower()
+            indices = set(_findall(datetime, self.f_month[m]))
+            if full_indices is None:
+                full_indices = indices
+            else:
+                full_indices &= indices
+            indices = set(_findall(datetime, self.a_month[m]))
+            if abbr_indices is None:
+                abbr_indices = set(indices)
+            else:
+                abbr_indices &= indices
+            if not full_indices and not abbr_indices:
+                return None, None
+        if full_indices:
+            return self.f_month, '%B'
+        if abbr_indices:
+            return self.a_month, '%b'
+        return None, None
+
+    def __find_weekday_format(self, directive):
+        """Find the day of the week format appropriate for the current locale.
+
+        Similar to __find_month_format().
+        """
+        full_indices = abbr_indices = None
+        for wd in range(7):
+            time_tuple = time.struct_time((1999, 3, 17, 22, 44, 55, wd, 76, 0))
+            datetime = time.strftime(directive, time_tuple).lower()
+            indices = set(_findall(datetime, self.f_weekday[wd]))
+            if full_indices is None:
+                full_indices = indices
+            else:
+                full_indices &= indices
+            if self.f_weekday[wd] != self.a_weekday[wd]:
+                indices = set(_findall(datetime, self.a_weekday[wd]))
+            if abbr_indices is None:
+                abbr_indices = set(indices)
+            else:
+                abbr_indices &= indices
+            if not full_indices and not abbr_indices:
+                return None, None
+        if full_indices:
+            return self.f_weekday, '%A'
+        if abbr_indices:
+            return self.a_weekday, '%a'
+        return None, None
 
     def __calc_timezone(self):
         # Set self.timezone by using time.tzname.
@@ -181,12 +351,14 @@ def __init__(self, locale_time=None):
         else:
             self.locale_time = LocaleTime()
         base = super()
-        base.__init__({
+        mapping = {
             # The " [1-9]" part of the regex is to make %c from ANSI C work
             'd': r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
             'f': r"(?P<f>[0-9]{1,6})",
-            'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
-            'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])",
+            'H': r"(?P<H>2[0-3]|[0-1]\d|\d| \d)",
+            'k': r"(?P<H>2[0-3]|[0-1]\d|\d| \d)",
+            'I': r"(?P<I>1[0-2]|0[1-9]|[1-9]| [1-9])",
+            'l': r"(?P<I>1[0-2]|0[1-9]|[1-9]| [1-9])",
             'G': r"(?P<G>\d\d\d\d)",
             'j': r"(?P<j>36[0-6]|3[0-5]\d|[1-2]\d\d|0[1-9]\d|00[1-9]|[1-9]\d|0[1-9]|[1-9])",
             'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])",
@@ -198,25 +370,60 @@ def __init__(self, locale_time=None):
             'V': r"(?P<V>5[0-3]|0[1-9]|[1-4]\d|\d)",
             # W is set below by using 'U'
             'y': r"(?P<y>\d\d)",
-            #XXX: Does 'Y' need to worry about having less or more than
-            #     4 digits?
             'Y': r"(?P<Y>\d\d\d\d)",
             'z': r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|(?-i:Z))",
             'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
             'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
-            'B': self.__seqToRE(self.locale_time.f_month[1:], 'B'),
-            'b': self.__seqToRE(self.locale_time.a_month[1:], 'b'),
+            'B': self.__seqToRE(_fixmonths(self.locale_time.f_month[1:]), 'B'),
+            'b': self.__seqToRE(_fixmonths(self.locale_time.a_month[1:]), 'b'),
             'p': self.__seqToRE(self.locale_time.am_pm, 'p'),
             'Z': self.__seqToRE((tz for tz_names in self.locale_time.timezone
                                         for tz in tz_names),
                                 'Z'),
-            '%': '%'})
-        base.__setitem__('W', base.__getitem__('U').replace('U', 'W'))
-        base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
-        base.__setitem__('x', self.pattern(self.locale_time.LC_date))
+            '%': '%'}
+        if self.locale_time.LC_alt_digits is None:
+            for d in 'dmyCHIMS':
+                mapping['O' + d] = r'(?P<%s>\d\d|\d| \d)' % d
+            mapping['Ow'] = r'(?P<w>\d)'
+        else:
+            mapping.update({
+                'Od': self.__seqToRE(self.locale_time.LC_alt_digits[1:32], 'd',
+                                     '3[0-1]|[1-2][0-9]|0[1-9]|[1-9]'),
+                'Om': self.__seqToRE(self.locale_time.LC_alt_digits[1:13], 'm',
+                                     '1[0-2]|0[1-9]|[1-9]'),
+                'Ow': self.__seqToRE(self.locale_time.LC_alt_digits[:7], 'w',
+                                     '[0-6]'),
+                'Oy': self.__seqToRE(self.locale_time.LC_alt_digits, 'y',
+                                     '[0-9][0-9]'),
+                'OC': self.__seqToRE(self.locale_time.LC_alt_digits, 'C',
+                                     '[0-9][0-9]'),
+                'OH': self.__seqToRE(self.locale_time.LC_alt_digits[:24], 'H',
+                                     '2[0-3]|[0-1][0-9]|[0-9]'),
+                'OI': self.__seqToRE(self.locale_time.LC_alt_digits[1:13], 'I',
+                                     '1[0-2]|0[1-9]|[1-9]'),
+                'OM': self.__seqToRE(self.locale_time.LC_alt_digits[:60], 'M',
+                                     '[0-5][0-9]|[0-9]'),
+                'OS': self.__seqToRE(self.locale_time.LC_alt_digits[:62], 'S',
+                                     '6[0-1]|[0-5][0-9]|[0-9]'),
+            })
+        mapping.update({
+            'e': mapping['d'],
+            'Oe': mapping['Od'],
+            'P': mapping['p'],
+            'Op': mapping['p'],
+            'W': mapping['U'].replace('U', 'W'),
+        })
+        mapping['W'] = mapping['U'].replace('U', 'W')
+
+        base.__init__(mapping)
+        base.__setitem__('T', self.pattern('%H:%M:%S'))
+        base.__setitem__('R', self.pattern('%H:%M'))
+        base.__setitem__('r', self.pattern(self.locale_time.LC_time_ampm))
         base.__setitem__('X', self.pattern(self.locale_time.LC_time))
+        base.__setitem__('x', self.pattern(self.locale_time.LC_date))
+        base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
 
-    def __seqToRE(self, to_convert, directive):
+    def __seqToRE(self, to_convert, directive, altregex=None):
         """Convert a list to a regex string for matching a directive.
 
         Want possible matching values to be from longest to shortest.  This
@@ -232,8 +439,9 @@ def __seqToRE(self, to_convert, directive):
         else:
             return ''
         regex = '|'.join(re_escape(stuff) for stuff in to_convert)
-        regex = '(?P<%s>%s' % (directive, regex)
-        return '%s)' % regex
+        if altregex is not None:
+            regex += '|' + altregex
+        return '(?P<%s>%s)' % (directive, regex)
 
     def pattern(self, format):
         """Return regex pattern for the format string.
@@ -242,21 +450,36 @@ def pattern(self, format):
         regex syntax are escaped.
 
         """
-        processed_format = ''
         # The sub() call escapes all characters that might be misconstrued
         # as regex syntax.  Cannot use re.escape since we have to deal with
         # format directives (%m, etc.).
-        regex_chars = re_compile(r"([\\.^$*+?\(\){}\[\]|])")
-        format = regex_chars.sub(r"\\\1", format)
-        whitespace_replacement = re_compile(r'\s+')
-        format = whitespace_replacement.sub(r'\\s+', format)
-        while '%' in format:
-            directive_index = format.index('%')+1
-            processed_format = "%s%s%s" % (processed_format,
-                                           format[:directive_index-1],
-                                           self[format[directive_index]])
-            format = format[directive_index+1:]
-        return "%s%s" % (processed_format, format)
+        format = re_sub(r"([\\.^$*+?\(\){}\[\]|])", r"\\\1", format)
+        format = re_sub(r'\s+', r'\\s+', format)
+        format = re_sub(r"'", "['\u02bc]", format)  # needed for br_FR
+        year_in_format = False
+        day_of_month_in_format = False
+        def repl(m):
+            format_char = m[1]
+            match format_char:
+                case 'Y' | 'y' | 'G':
+                    nonlocal year_in_format
+                    year_in_format = True
+                case 'd':
+                    nonlocal day_of_month_in_format
+                    day_of_month_in_format = True
+            return self[format_char]
+        format = re_sub(r'%[-_0^#]*[0-9]*([OE]?\\?.?)', repl, format)
+        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
+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.
+See https://github.com/python/cpython/issues/70647.""",
+                          DeprecationWarning,
+                          skip_file_prefixes=(os.path.dirname(__file__),))
+        return format
 
     def compile(self, format):
         """Return a compiled re object for the format string."""
@@ -319,14 +542,13 @@ def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
             # \\, in which case it was a stray % but with a space after it
             except KeyError as err:
                 bad_directive = err.args[0]
-                if bad_directive == "\\":
-                    bad_directive = "%"
                 del err
+                bad_directive = bad_directive.replace('\\s', '')
+                if not bad_directive:
+                    raise ValueError("stray %% in format '%s'" % format) from None
+                bad_directive = bad_directive.replace('\\', '', 1)
                 raise ValueError("'%s' is a bad directive in format '%s'" %
                                     (bad_directive, format)) from None
-            # IndexError only occurs when the format string is "%"
-            except IndexError:
-                raise ValueError("stray %% in format '%s'" % format) from None
             _regex_cache[format] = format_regex
     found = format_regex.match(data_string)
     if not found:
@@ -348,6 +570,15 @@ def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
     # values
     weekday = julian = None
     found_dict = found.groupdict()
+    if locale_time.LC_alt_digits:
+        def parse_int(s):
+            try:
+                return locale_time.LC_alt_digits.index(s)
+            except ValueError:
+                return int(s)
+    else:
+        parse_int = int
+
     for group_key in found_dict.keys():
         # Directives not explicitly handled below:
         #   c, x, X
@@ -355,30 +586,34 @@ def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
         #   U, W
         #      worthless without day of the week
         if group_key == 'y':
-            year = int(found_dict['y'])
-            # Open Group specification for strptime() states that a %y
-            #value in the range of [00, 68] is in the century 2000, while
-            #[69,99] is in the century 1900
-            if year <= 68:
-                year += 2000
+            year = parse_int(found_dict['y'])
+            if 'C' in found_dict:
+                century = parse_int(found_dict['C'])
+                year += century * 100
             else:
-                year += 1900
+                # Open Group specification for strptime() states that a %y
+                #value in the range of [00, 68] is in the century 2000, while
+                #[69,99] is in the century 1900
+                if year <= 68:
+                    year += 2000
+                else:
+                    year += 1900
         elif group_key == 'Y':
             year = int(found_dict['Y'])
         elif group_key == 'G':
             iso_year = int(found_dict['G'])
         elif group_key == 'm':
-            month = int(found_dict['m'])
+            month = parse_int(found_dict['m'])
         elif group_key == 'B':
             month = locale_time.f_month.index(found_dict['B'].lower())
         elif group_key == 'b':
             month = locale_time.a_month.index(found_dict['b'].lower())
         elif group_key == 'd':
-            day = int(found_dict['d'])
+            day = parse_int(found_dict['d'])
         elif group_key == 'H':
-            hour = int(found_dict['H'])
+            hour = parse_int(found_dict['H'])
         elif group_key == 'I':
-            hour = int(found_dict['I'])
+            hour = parse_int(found_dict['I'])
             ampm = found_dict.get('p', '').lower()
             # If there was no AM/PM indicator, we'll treat this like AM
             if ampm in ('', locale_time.am_pm[0]):
@@ -394,9 +629,9 @@ def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
                 if hour != 12:
                     hour += 12
         elif group_key == 'M':
-            minute = int(found_dict['M'])
+            minute = parse_int(found_dict['M'])
         elif group_key == 'S':
-            second = int(found_dict['S'])
+            second = parse_int(found_dict['S'])
         elif group_key == 'f':
             s = found_dict['f']
             # Pad to always return microseconds.
diff --git a/Lib/_weakrefset.py b/Lib/_weakrefset.py
index 2a27684324..489eec714e 100644
--- a/Lib/_weakrefset.py
+++ b/Lib/_weakrefset.py
@@ -80,8 +80,7 @@ def __contains__(self, item):
         return wr in self.data
 
     def __reduce__(self):
-        return (self.__class__, (list(self),),
-                getattr(self, '__dict__', None))
+        return self.__class__, (list(self),), self.__getstate__()
 
     def add(self, item):
         if self._pending_removals:
diff --git a/Lib/ast.py b/Lib/ast.py
index 07044706dc..37b20206b8 100644
--- a/Lib/ast.py
+++ b/Lib/ast.py
@@ -1,28 +1,24 @@
 """
-    ast
-    ~~~
-
-    The `ast` module helps Python applications to process trees of the Python
-    abstract syntax grammar.  The abstract syntax itself might change with
-    each Python release; this module helps to find out programmatically what
-    the current grammar looks like and allows modifications of it.
-
-    An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as
-    a flag to the `compile()` builtin function or by using the `parse()`
-    function from this module.  The result will be a tree of objects whose
-    classes all inherit from `ast.AST`.
-
-    A modified abstract syntax tree can be compiled into a Python code object
-    using the built-in `compile()` function.
-
-    Additionally various helper functions are provided that make working with
-    the trees simpler.  The main intention of the helper functions and this
-    module in general is to provide an easy to use interface for libraries
-    that work tightly with the python syntax (template engines for example).
-
-
-    :copyright: Copyright 2008 by Armin Ronacher.
-    :license: Python License.
+The `ast` module helps Python applications to process trees of the Python
+abstract syntax grammar.  The abstract syntax itself might change with
+each Python release; this module helps to find out programmatically what
+the current grammar looks like and allows modifications of it.
+
+An abstract syntax tree can be generated by passing `ast.PyCF_ONLY_AST` as
+a flag to the `compile()` builtin function or by using the `parse()`
+function from this module.  The result will be a tree of objects whose
+classes all inherit from `ast.AST`.
+
+A modified abstract syntax tree can be compiled into a Python code object
+using the built-in `compile()` function.
+
+Additionally various helper functions are provided that make working with
+the trees simpler.  The main intention of the helper functions and this
+module in general is to provide an easy to use interface for libraries
+that work tightly with the python syntax (template engines for example).
+
+:copyright: Copyright 2008 by Armin Ronacher.
+:license: Python License.
 """
 import sys
 import re
@@ -32,13 +28,15 @@
 
 
 def parse(source, filename='<unknown>', mode='exec', *,
-          type_comments=False, feature_version=None):
+          type_comments=False, feature_version=None, optimize=-1):
     """
     Parse the source into an AST node.
     Equivalent to compile(source, filename, mode, PyCF_ONLY_AST).
     Pass type_comments=True to get back type comments where the syntax allows.
     """
     flags = PyCF_ONLY_AST
+    if optimize > 0:
+        flags |= PyCF_OPTIMIZED_AST
     if type_comments:
         flags |= PyCF_TYPE_COMMENTS
     if feature_version is None:
@@ -50,7 +48,7 @@ def parse(source, filename='<unknown>', mode='exec', *,
         feature_version = minor
     # Else it should be an int giving the minor version for 3.x.
     return compile(source, filename, mode, flags,
-                   _feature_version=feature_version)
+                   _feature_version=feature_version, optimize=optimize)
 
 
 def literal_eval(node_or_string):
@@ -112,7 +110,11 @@ def _convert(node):
     return _convert(node_or_string)
 
 
-def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
+def dump(
+    node, annotate_fields=True, include_attributes=False,
+    *,
+    indent=None, show_empty=False,
+):
     """
     Return a formatted dump of the tree in node.  This is mainly useful for
     debugging purposes.  If annotate_fields is true (by default),
@@ -123,6 +125,8 @@ def dump(node, annotate_fields=True, include_attributes=False, *, indent=None):
     include_attributes can be set to true.  If indent is a non-negative
     integer or string, then the tree will be pretty-printed with that indent
     level. None (the default) selects the single line representation.
+    If show_empty is False, then empty lists and fields that are None
+    will be omitted from the output for better readability.
     """
     def _format(node, level=0):
         if indent is not None:
@@ -135,6 +139,7 @@ def _format(node, level=0):
         if isinstance(node, AST):
             cls = type(node)
             args = []
+            args_buffer = []
             allsimple = True
             keywords = annotate_fields
             for name in node._fields:
@@ -146,6 +151,16 @@ def _format(node, level=0):
                 if value is None and getattr(cls, name, ...) is None:
                     keywords = True
                     continue
+                if not show_empty:
+                    if value == []:
+                        field_type = cls._field_types.get(name, object)
+                        if getattr(field_type, '__origin__', ...) is list:
+                            if not keywords:
+                                args_buffer.append(repr(value))
+                            continue
+                    if not keywords:
+                        args.extend(args_buffer)
+                        args_buffer = []
                 value, simple = _format(value, level)
                 allsimple = allsimple and simple
                 if keywords:
@@ -726,12 +741,11 @@ class _Unparser(NodeVisitor):
     output source code for the abstract syntax; original formatting
     is disregarded."""
 
-    def __init__(self, *, _avoid_backslashes=False):
+    def __init__(self):
         self._source = []
         self._precedences = {}
         self._type_ignores = {}
         self._indent = 0
-        self._avoid_backslashes = _avoid_backslashes
         self._in_try_star = False
 
     def interleave(self, inter, f, seq):
@@ -1104,12 +1118,21 @@ def visit_TypeVar(self, node):
         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 ")
@@ -1246,9 +1269,14 @@ def visit_JoinedStr(self, node):
                     fallback_to_repr = True
                     break
                 quote_types = new_quote_types
-            elif "\n" in value:
-                quote_types = [q for q in quote_types if q in _MULTI_QUOTES]
-                assert 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:
@@ -1268,13 +1296,19 @@ def visit_JoinedStr(self, node):
         quote_type = quote_types[0]
         self.write(f"{quote_type}{value}{quote_type}")
 
-    def _write_fstring_inner(self, node):
+    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)
+                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)
@@ -1297,7 +1331,7 @@ def unparse_inner(inner):
                 self.write(f"!{chr(node.conversion)}")
             if node.format_spec:
                 self.write(":")
-                self._write_fstring_inner(node.format_spec)
+                self._write_fstring_inner(node.format_spec, is_format_spec=True)
 
     def visit_Name(self, node):
         self.write(node.id)
@@ -1317,8 +1351,6 @@ def _write_constant(self, value):
                 .replace("inf", _INFSTR)
                 .replace("nan", f"({_INFSTR}-{_INFSTR})")
             )
-        elif self._avoid_backslashes and isinstance(value, str):
-            self._write_str_avoiding_backslashes(value)
         else:
             self.write(repr(value))
 
@@ -1805,8 +1837,7 @@ def main():
     import argparse
 
     parser = argparse.ArgumentParser(prog='python -m ast')
-    parser.add_argument('infile', type=argparse.FileType(mode='rb'), nargs='?',
-                        default='-',
+    parser.add_argument('infile', nargs='?', default='-',
                         help='the file to parse; defaults to stdin')
     parser.add_argument('-m', '--mode', default='exec',
                         choices=('exec', 'single', 'eval', 'func_type'),
@@ -1820,9 +1851,14 @@ def main():
                         help='indentation of nodes (number of spaces)')
     args = parser.parse_args()
 
-    with args.infile as infile:
-        source = infile.read()
-    tree = parse(source, args.infile.name, args.mode, type_comments=args.no_type_comments)
+    if args.infile == '-':
+        name = '<stdin>'
+        source = sys.stdin.buffer.read()
+    else:
+        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))
 
 if __name__ == '__main__':
diff --git a/Lib/asyncio/__main__.py b/Lib/asyncio/__main__.py
index 18bb87a5bc..8e9af83cc8 100644
--- a/Lib/asyncio/__main__.py
+++ b/Lib/asyncio/__main__.py
@@ -1,41 +1,51 @@
 import ast
 import asyncio
-import code
 import concurrent.futures
+import contextvars
 import inspect
+import os
+import site
 import sys
 import threading
 import types
 import warnings
 
+from _colorize import can_colorize, ANSIColors  # type: ignore[import-not-found]
+from _pyrepl.console import InteractiveColoredConsole
+
 from . import futures
 
 
-class AsyncIOInteractiveConsole(code.InteractiveConsole):
+class AsyncIOInteractiveConsole(InteractiveColoredConsole):
 
     def __init__(self, locals, loop):
-        super().__init__(locals)
+        super().__init__(locals, filename="<stdin>")
         self.compile.compiler.flags |= ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
 
         self.loop = loop
+        self.context = contextvars.copy_context()
 
     def runcode(self, code):
+        global return_code
         future = concurrent.futures.Future()
 
         def callback():
+            global return_code
             global repl_future
-            global repl_future_interrupted
+            global keyboard_interrupted
 
             repl_future = None
-            repl_future_interrupted = False
+            keyboard_interrupted = False
 
             func = types.FunctionType(code, self.locals)
             try:
                 coro = func()
-            except SystemExit:
-                raise
+            except SystemExit as se:
+                return_code = se.code
+                self.loop.stop()
+                return
             except KeyboardInterrupt as ex:
-                repl_future_interrupted = True
+                keyboard_interrupted = True
                 future.set_exception(ex)
                 return
             except BaseException as ex:
@@ -47,39 +57,71 @@ def callback():
                 return
 
             try:
-                repl_future = self.loop.create_task(coro)
+                repl_future = self.loop.create_task(coro, context=self.context)
                 futures._chain_future(repl_future, future)
             except BaseException as exc:
                 future.set_exception(exc)
 
-        loop.call_soon_threadsafe(callback)
+        self.loop.call_soon_threadsafe(callback, context=self.context)
 
         try:
             return future.result()
-        except SystemExit:
-            raise
+        except SystemExit as se:
+            return_code = se.code
+            self.loop.stop()
+            return
         except BaseException:
-            if repl_future_interrupted:
-                self.write("\nKeyboardInterrupt\n")
+            if keyboard_interrupted:
+                if not CAN_USE_PYREPL:
+                    self.write("\nKeyboardInterrupt\n")
             else:
                 self.showtraceback()
-
+            return self.STATEMENT_FAILED
 
 class REPLThread(threading.Thread):
 
     def run(self):
+        global return_code
+
         try:
             banner = (
                 f'asyncio REPL {sys.version} on {sys.platform}\n'
                 f'Use "await" directly instead of "asyncio.run()".\n'
                 f'Type "help", "copyright", "credits" or "license" '
                 f'for more information.\n'
-                f'{getattr(sys, "ps1", ">>> ")}import asyncio'
             )
 
-            console.interact(
-                banner=banner,
-                exitmsg='exiting asyncio REPL...')
+            console.write(banner)
+
+            if startup_path := os.getenv("PYTHONSTARTUP"):
+                sys.audit("cpython.run_startup", startup_path)
+
+                import tokenize
+                with tokenize.open(startup_path) as f:
+                    startup_code = compile(f.read(), startup_path, "exec")
+                    exec(startup_code, console.locals)
+
+            ps1 = getattr(sys, "ps1", ">>> ")
+            if can_colorize() and CAN_USE_PYREPL:
+                ps1 = f"{ANSIColors.BOLD_MAGENTA}{ps1}{ANSIColors.RESET}"
+            console.write(f"{ps1}import asyncio\n")
+
+            if CAN_USE_PYREPL:
+                from _pyrepl.simple_interact import (
+                    run_multiline_interactive_console,
+                )
+                try:
+                    run_multiline_interactive_console(console)
+                except SystemExit:
+                    # expected via the `exit` and `quit` commands
+                    pass
+                except BaseException:
+                    # unexpected issue
+                    console.showtraceback()
+                    console.write("Internal error, ")
+                    return_code = 1
+            else:
+                console.interact(banner="", exitmsg="")
         finally:
             warnings.filterwarnings(
                 'ignore',
@@ -88,8 +130,25 @@ def run(self):
 
             loop.call_soon_threadsafe(loop.stop)
 
+    def interrupt(self) -> None:
+        if not CAN_USE_PYREPL:
+            return
+
+        from _pyrepl.simple_interact import _get_reader
+        r = _get_reader()
+        if r.threading_hook is not None:
+            r.threading_hook.add("")  # type: ignore
+
 
 if __name__ == '__main__':
+    sys.audit("cpython.run_stdin")
+
+    if os.getenv('PYTHON_BASIC_REPL'):
+        CAN_USE_PYREPL = False
+    else:
+        from _pyrepl.main import CAN_USE_PYREPL
+
+    return_code = 0
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
 
@@ -102,14 +161,31 @@ def run(self):
     console = AsyncIOInteractiveConsole(repl_locals, loop)
 
     repl_future = None
-    repl_future_interrupted = False
+    keyboard_interrupted = False
 
     try:
         import readline  # NoQA
     except ImportError:
-        pass
+        readline = None
+
+    interactive_hook = getattr(sys, "__interactivehook__", None)
 
-    repl_thread = REPLThread()
+    if interactive_hook is not None:
+        sys.audit("cpython.run_interactivehook", interactive_hook)
+        interactive_hook()
+
+    if interactive_hook is site.register_readline:
+        # Fix the completer function to use the interactive console locals
+        try:
+            import rlcompleter
+        except:
+            pass
+        else:
+            if readline is not None:
+                completer = rlcompleter.Completer(console.locals)
+                readline.set_completer(completer.complete)
+
+    repl_thread = REPLThread(name="Interactive thread")
     repl_thread.daemon = True
     repl_thread.start()
 
@@ -117,9 +193,13 @@ def run(self):
         try:
             loop.run_forever()
         except KeyboardInterrupt:
+            keyboard_interrupted = True
             if repl_future and not repl_future.done():
                 repl_future.cancel()
-                repl_future_interrupted = True
+            repl_thread.interrupt()
             continue
         else:
             break
+
+    console.write('exiting asyncio REPL...\n')
+    sys.exit(return_code)
diff --git a/Lib/asyncio/base_events.py b/Lib/asyncio/base_events.py
index 29eff0499c..356fc3d791 100644
--- a/Lib/asyncio/base_events.py
+++ b/Lib/asyncio/base_events.py
@@ -17,7 +17,6 @@
 import collections.abc
 import concurrent.futures
 import errno
-import functools
 import heapq
 import itertools
 import os
@@ -279,7 +278,9 @@ def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
                  ssl_handshake_timeout, ssl_shutdown_timeout=None):
         self._loop = loop
         self._sockets = sockets
-        self._active_count = 0
+        # Weak references so we don't break Transport's ability to
+        # detect abandoned transports
+        self._clients = weakref.WeakSet()
         self._waiters = []
         self._protocol_factory = protocol_factory
         self._backlog = backlog
@@ -292,14 +293,13 @@ def __init__(self, loop, sockets, protocol_factory, ssl_context, backlog,
     def __repr__(self):
         return f'<{self.__class__.__name__} sockets={self.sockets!r}>'
 
-    def _attach(self):
+    def _attach(self, transport):
         assert self._sockets is not None
-        self._active_count += 1
+        self._clients.add(transport)
 
-    def _detach(self):
-        assert self._active_count > 0
-        self._active_count -= 1
-        if self._active_count == 0 and self._sockets is None:
+    def _detach(self, transport):
+        self._clients.discard(transport)
+        if len(self._clients) == 0 and self._sockets is None:
             self._wakeup()
 
     def _wakeup(self):
@@ -348,9 +348,17 @@ def close(self):
             self._serving_forever_fut.cancel()
             self._serving_forever_fut = None
 
-        if self._active_count == 0:
+        if len(self._clients) == 0:
             self._wakeup()
 
+    def close_clients(self):
+        for transport in self._clients.copy():
+            transport.close()
+
+    def abort_clients(self):
+        for transport in self._clients.copy():
+            transport.abort()
+
     async def start_serving(self):
         self._start_serving()
         # Skip one loop iteration so that all 'loop.add_reader'
@@ -422,6 +430,8 @@ def __init__(self):
         self._clock_resolution = time.get_clock_info('monotonic').resolution
         self._exception_handler = None
         self.set_debug(coroutines._is_debug_mode())
+        # The preserved state of async generator hooks.
+        self._old_agen_hooks = None
         # In debug mode, if the execution of a callback or a step of a task
         # exceed this duration in seconds, the slow callback/task is logged.
         self.slow_callback_duration = 0.1
@@ -448,26 +458,30 @@ def create_future(self):
         """Create a Future object attached to the loop."""
         return futures.Future(loop=self)
 
-    def create_task(self, coro, *, name=None, context=None):
+    def create_task(self, coro, *, name=None, context=None, **kwargs):
         """Schedule a coroutine object.
 
         Return a task object.
         """
         self._check_closed()
-        if self._task_factory is None:
-            task = tasks.Task(coro, loop=self, name=name, context=context)
+        if self._task_factory is not None:
+            if context is not None:
+                kwargs["context"] = context
+
+            task = self._task_factory(self, coro, **kwargs)
+            task.set_name(name)
+
+        else:
+            task = tasks.Task(coro, loop=self, name=name, context=context, **kwargs)
             if task._source_traceback:
                 del task._source_traceback[-1]
-        else:
-            if context is None:
-                # Use legacy API if context is not needed
-                task = self._task_factory(self, coro)
-            else:
-                task = self._task_factory(self, coro, context=context)
-
-            tasks._set_task_name(task, name)
 
-        return task
+        try:
+            return task
+        finally:
+            # gh-128552: prevent a refcycle of
+            # task.exception().__traceback__->BaseEventLoop.create_task->task
+            del task
 
     def set_task_factory(self, factory):
         """Set a task factory that will be used by loop.create_task().
@@ -475,9 +489,10 @@ def set_task_factory(self, factory):
         If factory is None the default task factory will be set.
 
         If factory is a callable, it should have a signature matching
-        '(loop, coro)', where 'loop' will be a reference to the active
-        event loop, 'coro' will be a coroutine object.  The callable
-        must return a Future.
+        '(loop, coro, **kwargs)', where 'loop' will be a reference to the active
+        event loop, 'coro' will be a coroutine object, and **kwargs will be
+        arbitrary keyword arguments that should be passed on to Task.
+        The callable must return a Task.
         """
         if factory is not None and not callable(factory):
             raise TypeError('task factory must be a callable or None')
@@ -624,29 +639,52 @@ def _check_running(self):
             raise RuntimeError(
                 'Cannot run the event loop while another loop is running')
 
-    def run_forever(self):
-        """Run until stop() is called."""
+    def _run_forever_setup(self):
+        """Prepare the run loop to process events.
+
+        This method exists so that custom event loop subclasses (e.g., event loops
+        that integrate a GUI event loop with Python's event loop) have access to all the
+        loop setup logic.
+        """
         self._check_closed()
         self._check_running()
         self._set_coroutine_origin_tracking(self._debug)
 
-        old_agen_hooks = sys.get_asyncgen_hooks()
-        try:
-            self._thread_id = threading.get_ident()
-            sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
-                                   finalizer=self._asyncgen_finalizer_hook)
+        self._old_agen_hooks = sys.get_asyncgen_hooks()
+        self._thread_id = threading.get_ident()
+        sys.set_asyncgen_hooks(
+            firstiter=self._asyncgen_firstiter_hook,
+            finalizer=self._asyncgen_finalizer_hook
+        )
+
+        events._set_running_loop(self)
+
+    def _run_forever_cleanup(self):
+        """Clean up after an event loop finishes the looping over events.
+
+        This method exists so that custom event loop subclasses (e.g., event loops
+        that integrate a GUI event loop with Python's event loop) have access to all the
+        loop cleanup logic.
+        """
+        self._stopping = False
+        self._thread_id = None
+        events._set_running_loop(None)
+        self._set_coroutine_origin_tracking(False)
+        # Restore any pre-existing async generator hooks.
+        if self._old_agen_hooks is not None:
+            sys.set_asyncgen_hooks(*self._old_agen_hooks)
+            self._old_agen_hooks = None
 
-            events._set_running_loop(self)
+    def run_forever(self):
+        """Run until stop() is called."""
+        self._run_forever_setup()
+        try:
             while True:
                 self._run_once()
                 if self._stopping:
                     break
         finally:
-            self._stopping = False
-            self._thread_id = None
-            events._set_running_loop(None)
-            self._set_coroutine_origin_tracking(False)
-            sys.set_asyncgen_hooks(*old_agen_hooks)
+            self._run_forever_cleanup()
 
     def run_until_complete(self, future):
         """Run until the Future is done.
@@ -981,39 +1019,43 @@ async def _connect_sock(self, exceptions, addr_info, local_addr_infos=None):
         family, type_, proto, _, address = addr_info
         sock = None
         try:
-            sock = socket.socket(family=family, type=type_, proto=proto)
-            sock.setblocking(False)
-            if local_addr_infos is not None:
-                for lfamily, _, _, _, laddr in local_addr_infos:
-                    # skip local addresses of different family
-                    if lfamily != family:
-                        continue
-                    try:
-                        sock.bind(laddr)
-                        break
-                    except OSError as exc:
-                        msg = (
-                            f'error while attempting to bind on '
-                            f'address {laddr!r}: '
-                            f'{exc.strerror.lower()}'
-                        )
-                        exc = OSError(exc.errno, msg)
-                        my_exceptions.append(exc)
-                else:  # all bind attempts failed
-                    if my_exceptions:
-                        raise my_exceptions.pop()
-                    else:
-                        raise OSError(f"no matching local address with {family=} found")
-            await self.sock_connect(sock, address)
-            return sock
-        except OSError as exc:
-            my_exceptions.append(exc)
-            if sock is not None:
-                sock.close()
-            raise
+            try:
+                sock = socket.socket(family=family, type=type_, proto=proto)
+                sock.setblocking(False)
+                if local_addr_infos is not None:
+                    for lfamily, _, _, _, laddr in local_addr_infos:
+                        # skip local addresses of different family
+                        if lfamily != family:
+                            continue
+                        try:
+                            sock.bind(laddr)
+                            break
+                        except OSError as exc:
+                            msg = (
+                                f'error while attempting to bind on '
+                                f'address {laddr!r}: {str(exc).lower()}'
+                            )
+                            exc = OSError(exc.errno, msg)
+                            my_exceptions.append(exc)
+                    else:  # all bind attempts failed
+                        if my_exceptions:
+                            raise my_exceptions.pop()
+                        else:
+                            raise OSError(f"no matching local address with {family=} found")
+                await self.sock_connect(sock, address)
+                return sock
+            except OSError as exc:
+                my_exceptions.append(exc)
+                raise
         except:
             if sock is not None:
-                sock.close()
+                try:
+                    sock.close()
+                except OSError:
+                    # An error when closing a newly created socket is
+                    # not important, but it can overwrite more important
+                    # non-OSError error. So ignore it.
+                    pass
             raise
         finally:
             exceptions = my_exceptions = None
@@ -1107,11 +1149,18 @@ async def create_connection(
                     except OSError:
                         continue
             else:  # using happy eyeballs
-                sock, _, _ = await staggered.staggered_race(
-                    (functools.partial(self._connect_sock,
-                                       exceptions, addrinfo, laddr_infos)
-                     for addrinfo in infos),
-                    happy_eyeballs_delay, loop=self)
+                sock = (await staggered.staggered_race(
+                    (
+                        # can't use functools.partial as it keeps a reference
+                        # to exceptions
+                        lambda addrinfo=addrinfo: self._connect_sock(
+                            exceptions, addrinfo, laddr_infos
+                        )
+                        for addrinfo in infos
+                    ),
+                    happy_eyeballs_delay,
+                    loop=self,
+                ))[0]  # can't use sock, _, _ as it keeks a reference to exceptions
 
             if sock is None:
                 exceptions = [exc for sub in exceptions for exc in sub]
@@ -1120,7 +1169,7 @@ async def create_connection(
                         raise ExceptionGroup("create_connection failed", exceptions)
                     if len(exceptions) == 1:
                         raise exceptions[0]
-                    else:
+                    elif exceptions:
                         # If they all have the same str(), raise one.
                         model = str(exceptions[0])
                         if all(str(exc) == model for exc in exceptions):
@@ -1129,6 +1178,9 @@ async def create_connection(
                         # the various error messages.
                         raise OSError('Multiple exceptions: {}'.format(
                             ', '.join(str(exc) for exc in exceptions)))
+                    else:
+                        # No exceptions were collected, raise a timeout error
+                        raise TimeoutError('create_connection failed')
                 finally:
                     exceptions = None
 
@@ -1254,8 +1306,8 @@ async def _sendfile_fallback(self, transp, file, offset, count):
                 read = await self.run_in_executor(None, file.readinto, view)
                 if not read:
                     return total_sent  # EOF
-                await proto.drain()
                 transp.write(view[:read])
+                await proto.drain()
                 total_sent += read
         finally:
             if total_sent > 0 and hasattr(file, 'seek'):
@@ -1474,6 +1526,7 @@ async def create_server(
             ssl=None,
             reuse_address=None,
             reuse_port=None,
+            keep_alive=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
             start_serving=True):
@@ -1545,8 +1598,13 @@ async def create_server(
                     if reuse_address:
                         sock.setsockopt(
                             socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
-                    if reuse_port:
+                    # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+                    # on other address families than AF_INET/AF_INET6.
+                    if reuse_port and af in (socket.AF_INET, socket.AF_INET6):
                         _set_reuseport(sock)
+                    if keep_alive:
+                        sock.setsockopt(
+                            socket.SOL_SOCKET, socket.SO_KEEPALIVE, True)
                     # Disable IPv4/IPv6 dual stack support (enabled by
                     # default on Linux) which makes a single socket
                     # listen on both address families.
@@ -1561,7 +1619,7 @@ async def create_server(
                     except OSError as err:
                         msg = ('error while attempting '
                                'to bind on address %r: %s'
-                               % (sa, err.strerror.lower()))
+                               % (sa, str(err).lower()))
                         if err.errno == errno.EADDRNOTAVAIL:
                             # Assume the family is not enabled (bpo-30945)
                             sockets.pop()
@@ -1833,6 +1891,8 @@ def call_exception_handler(self, context):
         - 'protocol' (optional): Protocol instance;
         - 'transport' (optional): Transport instance;
         - 'socket' (optional): Socket instance;
+        - 'source_traceback' (optional): Traceback of the source;
+        - 'handle_traceback' (optional): Traceback of the handle;
         - 'asyncgen' (optional): Asynchronous generator that caused
                                  the exception.
 
@@ -1943,8 +2003,11 @@ def _run_once(self):
             timeout = 0
         elif self._scheduled:
             # Compute the desired timeout.
-            when = self._scheduled[0]._when
-            timeout = min(max(0, when - self.time()), MAXIMUM_SELECT_TIMEOUT)
+            timeout = self._scheduled[0]._when - self.time()
+            if timeout > MAXIMUM_SELECT_TIMEOUT:
+                timeout = MAXIMUM_SELECT_TIMEOUT
+            elif timeout < 0:
+                timeout = 0
 
         event_list = self._selector.select(timeout)
         self._process_events(event_list)
diff --git a/Lib/asyncio/base_subprocess.py b/Lib/asyncio/base_subprocess.py
index 4c9b0dd565..321a4e5d5d 100644
--- a/Lib/asyncio/base_subprocess.py
+++ b/Lib/asyncio/base_subprocess.py
@@ -1,6 +1,9 @@
 import collections
 import subprocess
 import warnings
+import os
+import signal
+import sys
 
 from . import protocols
 from . import transports
@@ -23,6 +26,7 @@ def __init__(self, loop, protocol, args, shell,
         self._pending_calls = collections.deque()
         self._pipes = {}
         self._finished = False
+        self._pipes_connected = False
 
         if stdin == subprocess.PIPE:
             self._pipes[0] = None
@@ -101,7 +105,12 @@ def close(self):
         for proto in self._pipes.values():
             if proto is None:
                 continue
-            proto.pipe.close()
+            # See gh-114177
+            # skip closing the pipe if loop is already closed
+            # this can happen e.g. when loop is closed immediately after
+            # process is killed
+            if self._loop and not self._loop.is_closed():
+                proto.pipe.close()
 
         if (self._proc is not None and
                 # has the child process finished?
@@ -115,7 +124,8 @@ def close(self):
 
             try:
                 self._proc.kill()
-            except ProcessLookupError:
+            except (ProcessLookupError, PermissionError):
+                # the process may have already exited or may be running setuid
                 pass
 
             # Don't clear the _proc reference yet: _post_init() may still run
@@ -141,17 +151,31 @@ def _check_proc(self):
         if self._proc is None:
             raise ProcessLookupError()
 
-    def send_signal(self, signal):
-        self._check_proc()
-        self._proc.send_signal(signal)
+    if sys.platform == 'win32':
+        def send_signal(self, signal):
+            self._check_proc()
+            self._proc.send_signal(signal)
+
+        def terminate(self):
+            self._check_proc()
+            self._proc.terminate()
+
+        def kill(self):
+            self._check_proc()
+            self._proc.kill()
+    else:
+        def send_signal(self, signal):
+            self._check_proc()
+            try:
+                os.kill(self._proc.pid, signal)
+            except ProcessLookupError:
+                pass
 
-    def terminate(self):
-        self._check_proc()
-        self._proc.terminate()
+        def terminate(self):
+            self.send_signal(signal.SIGTERM)
 
-    def kill(self):
-        self._check_proc()
-        self._proc.kill()
+        def kill(self):
+            self.send_signal(signal.SIGKILL)
 
     async def _connect_pipes(self, waiter):
         try:
@@ -190,6 +214,7 @@ async def _connect_pipes(self, waiter):
         else:
             if waiter is not None and not waiter.cancelled():
                 waiter.set_result(None)
+            self._pipes_connected = True
 
     def _call(self, cb, *data):
         if self._pending_calls is not None:
@@ -233,6 +258,15 @@ def _try_finish(self):
         assert not self._finished
         if self._returncode is None:
             return
+        if not self._pipes_connected:
+            # self._pipes_connected can be False if not all pipes were connected
+            # because either the process failed to start or the self._connect_pipes task
+            # got cancelled. In this broken state we consider all pipes disconnected and
+            # to avoid hanging forever in self._wait as otherwise _exit_waiters
+            # would never be woken up, we wake them up here.
+            for waiter in self._exit_waiters:
+                if not waiter.cancelled():
+                    waiter.set_result(self._returncode)
         if all(p is not None and p.disconnected
                for p in self._pipes.values()):
             self._finished = True
diff --git a/Lib/asyncio/events.py b/Lib/asyncio/events.py
index 016852880c..3b740b9b90 100644
--- a/Lib/asyncio/events.py
+++ b/Lib/asyncio/events.py
@@ -54,7 +54,8 @@ def _repr_info(self):
             info.append('cancelled')
         if self._callback is not None:
             info.append(format_helpers._format_callback_source(
-                self._callback, self._args))
+                self._callback, self._args,
+                debug=self._loop.get_debug()))
         if self._source_traceback:
             frame = self._source_traceback[-1]
             info.append(f'created at {frame[0]}:{frame[1]}')
@@ -90,7 +91,8 @@ def _run(self):
             raise
         except BaseException as exc:
             cb = format_helpers._format_callback_source(
-                self._callback, self._args)
+                self._callback, self._args,
+                debug=self._loop.get_debug())
             msg = f'Exception in callback {cb}'
             context = {
                 'message': msg,
@@ -173,6 +175,14 @@ def close(self):
         """Stop serving.  This leaves existing connections open."""
         raise NotImplementedError
 
+    def close_clients(self):
+        """Close all active connections."""
+        raise NotImplementedError
+
+    def abort_clients(self):
+        """Close all active connections immediately."""
+        raise NotImplementedError
+
     def get_loop(self):
         """Get the event loop the Server object is attached to."""
         raise NotImplementedError
@@ -282,7 +292,7 @@ def create_future(self):
 
     # Method scheduling a coroutine object: create a task.
 
-    def create_task(self, coro, *, name=None, context=None):
+    def create_task(self, coro, **kwargs):
         raise NotImplementedError
 
     # Methods for interacting with threads.
@@ -320,6 +330,7 @@ async def create_server(
             *, family=socket.AF_UNSPEC,
             flags=socket.AI_PASSIVE, sock=None, backlog=100,
             ssl=None, reuse_address=None, reuse_port=None,
+            keep_alive=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
             start_serving=True):
@@ -358,6 +369,9 @@ async def create_server(
         they all set this flag when being created. This option is not
         supported on Windows.
 
+        keep_alive set to True keeps connections active by enabling the
+        periodic transmission of messages.
+
         ssl_handshake_timeout is the time in seconds that an SSL server
         will wait for completion of the SSL handshake before aborting the
         connection. Default is 60s.
diff --git a/Lib/asyncio/format_helpers.py b/Lib/asyncio/format_helpers.py
index 27d11fd4fa..93737b7708 100644
--- a/Lib/asyncio/format_helpers.py
+++ b/Lib/asyncio/format_helpers.py
@@ -19,19 +19,26 @@ def _get_function_source(func):
     return None
 
 
-def _format_callback_source(func, args):
-    func_repr = _format_callback(func, args, None)
+def _format_callback_source(func, args, *, debug=False):
+    func_repr = _format_callback(func, args, None, debug=debug)
     source = _get_function_source(func)
     if source:
         func_repr += f' at {source[0]}:{source[1]}'
     return func_repr
 
 
-def _format_args_and_kwargs(args, kwargs):
+def _format_args_and_kwargs(args, kwargs, *, debug=False):
     """Format function arguments and keyword arguments.
 
     Special case for a single parameter: ('hello',) is formatted as ('hello').
+
+    Note that this function only returns argument details when
+    debug=True is specified, as arguments may contain sensitive
+    information.
     """
+    if not debug:
+        return '()'
+
     # use reprlib to limit the length of the output
     items = []
     if args:
@@ -41,10 +48,11 @@ def _format_args_and_kwargs(args, kwargs):
     return '({})'.format(', '.join(items))
 
 
-def _format_callback(func, args, kwargs, suffix=''):
+def _format_callback(func, args, kwargs, *, debug=False, suffix=''):
     if isinstance(func, functools.partial):
-        suffix = _format_args_and_kwargs(args, kwargs) + suffix
-        return _format_callback(func.func, func.args, func.keywords, suffix)
+        suffix = _format_args_and_kwargs(args, kwargs, debug=debug) + suffix
+        return _format_callback(func.func, func.args, func.keywords,
+                                debug=debug, suffix=suffix)
 
     if hasattr(func, '__qualname__') and func.__qualname__:
         func_repr = func.__qualname__
@@ -53,7 +61,7 @@ def _format_callback(func, args, kwargs, suffix=''):
     else:
         func_repr = repr(func)
 
-    func_repr += _format_args_and_kwargs(args, kwargs)
+    func_repr += _format_args_and_kwargs(args, kwargs, debug=debug)
     if suffix:
         func_repr += suffix
     return func_repr
diff --git a/Lib/asyncio/futures.py b/Lib/asyncio/futures.py
index 97fc4e3fcb..5193263909 100644
--- a/Lib/asyncio/futures.py
+++ b/Lib/asyncio/futures.py
@@ -138,9 +138,6 @@ def _make_cancelled_error(self):
             exc = exceptions.CancelledError()
         else:
             exc = exceptions.CancelledError(self._cancel_message)
-        exc.__context__ = self._cancelled_exc
-        # Remove the reference since we don't need this anymore.
-        self._cancelled_exc = None
         return exc
 
     def cancel(self, msg=None):
@@ -194,8 +191,7 @@ def result(self):
         the future is done and has an exception set, this exception is raised.
         """
         if self._state == _CANCELLED:
-            exc = self._make_cancelled_error()
-            raise exc
+            raise self._make_cancelled_error()
         if self._state != _FINISHED:
             raise exceptions.InvalidStateError('Result is not ready.')
         self.__log_traceback = False
@@ -212,8 +208,7 @@ def exception(self):
         InvalidStateError.
         """
         if self._state == _CANCELLED:
-            exc = self._make_cancelled_error()
-            raise exc
+            raise self._make_cancelled_error()
         if self._state != _FINISHED:
             raise exceptions.InvalidStateError('Exception is not set.')
         self.__log_traceback = False
@@ -272,9 +267,13 @@ def set_exception(self, exception):
             raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
         if isinstance(exception, type):
             exception = exception()
-        if type(exception) is StopIteration:
-            raise TypeError("StopIteration interacts badly with generators "
-                            "and cannot be raised into a Future")
+        if isinstance(exception, StopIteration):
+            new_exc = RuntimeError("StopIteration interacts badly with "
+                                   "generators and cannot be raised into a "
+                                   "Future")
+            new_exc.__cause__ = exception
+            new_exc.__context__ = exception
+            exception = new_exc
         self._exception = exception
         self._exception_tb = exception.__traceback__
         self._state = _FINISHED
@@ -318,11 +317,9 @@ def _set_result_unless_cancelled(fut, result):
 def _convert_future_exc(exc):
     exc_class = type(exc)
     if exc_class is concurrent.futures.CancelledError:
-        return exceptions.CancelledError(*exc.args)
-    elif exc_class is concurrent.futures.TimeoutError:
-        return exceptions.TimeoutError(*exc.args)
+        return exceptions.CancelledError(*exc.args).with_traceback(exc.__traceback__)
     elif exc_class is concurrent.futures.InvalidStateError:
-        return exceptions.InvalidStateError(*exc.args)
+        return exceptions.InvalidStateError(*exc.args).with_traceback(exc.__traceback__)
     else:
         return exc
 
diff --git a/Lib/asyncio/locks.py b/Lib/asyncio/locks.py
index ce5d8d5bfb..3df4c693a9 100644
--- a/Lib/asyncio/locks.py
+++ b/Lib/asyncio/locks.py
@@ -24,25 +24,23 @@ class Lock(_ContextManagerMixin, mixins._LoopBoundMixin):
     """Primitive lock objects.
 
     A primitive lock is a synchronization primitive that is not owned
-    by a particular coroutine when locked.  A primitive lock is in one
+    by a particular task when locked.  A primitive lock is in one
     of two states, 'locked' or 'unlocked'.
 
     It is created in the unlocked state.  It has two basic methods,
     acquire() and release().  When the state is unlocked, acquire()
     changes the state to locked and returns immediately.  When the
     state is locked, acquire() blocks until a call to release() in
-    another coroutine changes it to unlocked, then the acquire() call
+    another task changes it to unlocked, then the acquire() call
     resets it to locked and returns.  The release() method should only
     be called in the locked state; it changes the state to unlocked
     and returns immediately.  If an attempt is made to release an
     unlocked lock, a RuntimeError will be raised.
 
-    When more than one coroutine is blocked in acquire() waiting for
-    the state to turn to unlocked, only one coroutine proceeds when a
-    release() call resets the state to unlocked; first coroutine which
-    is blocked in acquire() is being processed.
-
-    acquire() is a coroutine and should be called with 'await'.
+    When more than one task is blocked in acquire() waiting for
+    the state to turn to unlocked, only one task proceeds when a
+    release() call resets the state to unlocked; successive release()
+    calls will unblock tasks in FIFO order.
 
     Locks also support the asynchronous context management protocol.
     'async with lock' statement should be used.
@@ -95,6 +93,8 @@ async def acquire(self):
         This method blocks until the lock is unlocked, then sets it to
         locked and returns True.
         """
+        # Implement fair scheduling, where thread always waits
+        # its turn. Jumping the queue if all are cancelled is an optimization.
         if (not self._locked and (self._waiters is None or
                 all(w.cancelled() for w in self._waiters))):
             self._locked = True
@@ -105,19 +105,22 @@ async def acquire(self):
         fut = self._get_loop().create_future()
         self._waiters.append(fut)
 
-        # Finally block should be called before the CancelledError
-        # handling as we don't want CancelledError to call
-        # _wake_up_first() and attempt to wake up itself.
         try:
             try:
                 await fut
             finally:
                 self._waiters.remove(fut)
         except exceptions.CancelledError:
+            # Currently the only exception designed be able to occur here.
+
+            # Ensure the lock invariant: If lock is not claimed (or about
+            # to be claimed by us) and there is a Task in waiters,
+            # ensure that the Task at the head will run.
             if not self._locked:
                 self._wake_up_first()
             raise
 
+        # assert self._locked is False
         self._locked = True
         return True
 
@@ -125,7 +128,7 @@ def release(self):
         """Release a lock.
 
         When the lock is locked, reset it to unlocked, and return.
-        If any other coroutines are blocked waiting for the lock to become
+        If any other tasks are blocked waiting for the lock to become
         unlocked, allow exactly one of them to proceed.
 
         When invoked on an unlocked lock, a RuntimeError is raised.
@@ -139,7 +142,7 @@ def release(self):
             raise RuntimeError('Lock is not acquired.')
 
     def _wake_up_first(self):
-        """Wake up the first waiter if it isn't done."""
+        """Ensure that the first waiter will wake up."""
         if not self._waiters:
             return
         try:
@@ -147,9 +150,7 @@ def _wake_up_first(self):
         except StopIteration:
             return
 
-        # .done() necessarily means that a waiter will wake up later on and
-        # either take the lock, or, if it was cancelled and lock wasn't
-        # taken already, will hit this again and wake up a new waiter.
+        # .done() means that the waiter is already set to wake up.
         if not fut.done():
             fut.set_result(True)
 
@@ -179,8 +180,8 @@ def is_set(self):
         return self._value
 
     def set(self):
-        """Set the internal flag to true. All coroutines waiting for it to
-        become true are awakened. Coroutine that call wait() once the flag is
+        """Set the internal flag to true. All tasks waiting for it to
+        become true are awakened. Tasks that call wait() once the flag is
         true will not block at all.
         """
         if not self._value:
@@ -191,7 +192,7 @@ def set(self):
                     fut.set_result(True)
 
     def clear(self):
-        """Reset the internal flag to false. Subsequently, coroutines calling
+        """Reset the internal flag to false. Subsequently, tasks calling
         wait() will block until set() is called to set the internal flag
         to true again."""
         self._value = False
@@ -200,7 +201,7 @@ async def wait(self):
         """Block until the internal flag is true.
 
         If the internal flag is true on entry, return True
-        immediately.  Otherwise, block until another coroutine calls
+        immediately.  Otherwise, block until another task calls
         set() to set the flag to true, then return True.
         """
         if self._value:
@@ -219,8 +220,8 @@ class Condition(_ContextManagerMixin, mixins._LoopBoundMixin):
     """Asynchronous equivalent to threading.Condition.
 
     This class implements condition variable objects. A condition variable
-    allows one or more coroutines to wait until they are notified by another
-    coroutine.
+    allows one or more tasks to wait until they are notified by another
+    task.
 
     A new Lock object is created and used as the underlying lock.
     """
@@ -247,45 +248,64 @@ def __repr__(self):
     async def wait(self):
         """Wait until notified.
 
-        If the calling coroutine has not acquired the lock when this
+        If the calling task has not acquired the lock when this
         method is called, a RuntimeError is raised.
 
         This method releases the underlying lock, and then blocks
         until it is awakened by a notify() or notify_all() call for
-        the same condition variable in another coroutine.  Once
+        the same condition variable in another task.  Once
         awakened, it re-acquires the lock and returns True.
+
+        This method may return spuriously,
+        which is why the caller should always
+        re-check the state and be prepared to wait() again.
         """
         if not self.locked():
             raise RuntimeError('cannot wait on un-acquired lock')
 
+        fut = self._get_loop().create_future()
         self.release()
         try:
-            fut = self._get_loop().create_future()
-            self._waiters.append(fut)
             try:
-                await fut
-                return True
-            finally:
-                self._waiters.remove(fut)
-
-        finally:
-            # Must reacquire lock even if wait is cancelled
-            cancelled = False
-            while True:
+                self._waiters.append(fut)
                 try:
-                    await self.acquire()
-                    break
-                except exceptions.CancelledError:
-                    cancelled = True
+                    await fut
+                    return True
+                finally:
+                    self._waiters.remove(fut)
 
-            if cancelled:
-                raise exceptions.CancelledError
+            finally:
+                # Must re-acquire lock even if wait is cancelled.
+                # We only catch CancelledError here, since we don't want any
+                # other (fatal) errors with the future to cause us to spin.
+                err = None
+                while True:
+                    try:
+                        await self.acquire()
+                        break
+                    except exceptions.CancelledError as e:
+                        err = e
+
+                if err is not None:
+                    try:
+                        raise err  # Re-raise most recent exception instance.
+                    finally:
+                        err = None  # Break reference cycles.
+        except BaseException:
+            # Any error raised out of here _may_ have occurred after this Task
+            # believed to have been successfully notified.
+            # Make sure to notify another Task instead.  This may result
+            # in a "spurious wakeup", which is allowed as part of the
+            # Condition Variable protocol.
+            self._notify(1)
+            raise
 
     async def wait_for(self, predicate):
         """Wait until a predicate becomes true.
 
-        The predicate should be a callable which result will be
-        interpreted as a boolean value.  The final predicate value is
+        The predicate should be a callable whose result will be
+        interpreted as a boolean value.  The method will repeatedly
+        wait() until it evaluates to true.  The final predicate value is
         the return value.
         """
         result = predicate()
@@ -295,20 +315,22 @@ async def wait_for(self, predicate):
         return result
 
     def notify(self, n=1):
-        """By default, wake up one coroutine waiting on this condition, if any.
-        If the calling coroutine has not acquired the lock when this method
+        """By default, wake up one task waiting on this condition, if any.
+        If the calling task has not acquired the lock when this method
         is called, a RuntimeError is raised.
 
-        This method wakes up at most n of the coroutines waiting for the
-        condition variable; it is a no-op if no coroutines are waiting.
+        This method wakes up n of the tasks waiting for the condition
+         variable; if fewer than n are waiting, they are all awoken.
 
-        Note: an awakened coroutine does not actually return from its
+        Note: an awakened task does not actually return from its
         wait() call until it can reacquire the lock. Since notify() does
         not release the lock, its caller should.
         """
         if not self.locked():
             raise RuntimeError('cannot notify on un-acquired lock')
+        self._notify(n)
 
+    def _notify(self, n):
         idx = 0
         for fut in self._waiters:
             if idx >= n:
@@ -357,6 +379,7 @@ def __repr__(self):
 
     def locked(self):
         """Returns True if semaphore cannot be acquired immediately."""
+        # Due to state, or FIFO rules (must allow others to run first).
         return self._value == 0 or (
             any(not w.cancelled() for w in (self._waiters or ())))
 
@@ -365,11 +388,12 @@ async def acquire(self):
 
         If the internal counter is larger than zero on entry,
         decrement it by one and return True immediately.  If it is
-        zero on entry, block, waiting until some other coroutine has
+        zero on entry, block, waiting until some other task has
         called release() to make it larger than 0, and then return
         True.
         """
         if not self.locked():
+            # Maintain FIFO, wait for others to start even if _value > 0.
             self._value -= 1
             return True
 
@@ -378,29 +402,34 @@ async def acquire(self):
         fut = self._get_loop().create_future()
         self._waiters.append(fut)
 
-        # Finally block should be called before the CancelledError
-        # handling as we don't want CancelledError to call
-        # _wake_up_first() and attempt to wake up itself.
         try:
             try:
                 await fut
             finally:
                 self._waiters.remove(fut)
         except exceptions.CancelledError:
-            if not fut.cancelled():
+            # Currently the only exception designed be able to occur here.
+            if fut.done() and not fut.cancelled():
+                # Our Future was successfully set to True via _wake_up_next(),
+                # but we are not about to successfully acquire(). Therefore we
+                # must undo the bookkeeping already done and attempt to wake
+                # up someone else.
                 self._value += 1
-                self._wake_up_next()
             raise
 
-        if self._value > 0:
-            self._wake_up_next()
+        finally:
+            # New waiters may have arrived but had to wait due to FIFO.
+            # Wake up as many as are allowed.
+            while self._value > 0:
+                if not self._wake_up_next():
+                    break  # There was no-one to wake up.
         return True
 
     def release(self):
         """Release a semaphore, incrementing the internal counter by one.
 
-        When it was zero on entry and another coroutine is waiting for it to
-        become larger than zero again, wake up that coroutine.
+        When it was zero on entry and another task is waiting for it to
+        become larger than zero again, wake up that task.
         """
         self._value += 1
         self._wake_up_next()
@@ -408,13 +437,15 @@ def release(self):
     def _wake_up_next(self):
         """Wake up the first waiter that isn't done."""
         if not self._waiters:
-            return
+            return False
 
         for fut in self._waiters:
             if not fut.done():
                 self._value -= 1
                 fut.set_result(True)
-                return
+                # `fut` is now `done()` and not `cancelled()`.
+                return True
+        return False
 
 
 class BoundedSemaphore(Semaphore):
@@ -454,7 +485,7 @@ class Barrier(mixins._LoopBoundMixin):
     def __init__(self, parties):
         """Create a barrier, initialised to 'parties' tasks."""
         if parties < 1:
-            raise ValueError('parties must be > 0')
+            raise ValueError('parties must be >= 1')
 
         self._cond = Condition() # notify all tasks when state changes
 
diff --git a/Lib/asyncio/proactor_events.py b/Lib/asyncio/proactor_events.py
index 1e2a730cf3..f404273c3a 100644
--- a/Lib/asyncio/proactor_events.py
+++ b/Lib/asyncio/proactor_events.py
@@ -63,7 +63,7 @@ def __init__(self, loop, sock, protocol, waiter=None,
         self._called_connection_lost = False
         self._eof_written = False
         if self._server is not None:
-            self._server._attach()
+            self._server._attach(self)
         self._loop.call_soon(self._protocol.connection_made, self)
         if waiter is not None:
             # only wake up the waiter when connection_made() has been called
@@ -167,7 +167,7 @@ def _call_connection_lost(self, exc):
             self._sock = None
             server = self._server
             if server is not None:
-                server._detach()
+                server._detach(self)
                 self._server = None
             self._called_connection_lost = True
 
@@ -460,6 +460,8 @@ def _pipe_closed(self, fut):
 class _ProactorDatagramTransport(_ProactorBasePipeTransport,
                                  transports.DatagramTransport):
     max_size = 256 * 1024
+    _header_size = 8
+
     def __init__(self, loop, sock, protocol, address=None,
                  waiter=None, extra=None):
         self._address = address
@@ -487,9 +489,6 @@ def sendto(self, data, addr=None):
             raise TypeError('data argument must be bytes-like object (%r)',
                             type(data))
 
-        if not data:
-            return
-
         if self._address is not None and addr not in (None, self._address):
             raise ValueError(
                 f'Invalid address: must be None or {self._address}')
@@ -502,7 +501,7 @@ def sendto(self, data, addr=None):
 
         # Ensure that what we buffer is immutable.
         self._buffer.append((bytes(data), addr))
-        self._buffer_size += len(data)
+        self._buffer_size += len(data) + self._header_size
 
         if self._write_fut is None:
             # No current write operations are active, kick one off
@@ -529,7 +528,7 @@ def _loop_writing(self, fut=None):
                 return
 
             data, addr = self._buffer.popleft()
-            self._buffer_size -= len(data)
+            self._buffer_size -= len(data) + self._header_size
             if self._address is not None:
                 self._write_fut = self._loop._proactor.send(self._sock,
                                                             data)
@@ -724,6 +723,8 @@ async def sock_sendto(self, sock, data, address):
         return await self._proactor.sendto(sock, data, 0, address)
 
     async def sock_connect(self, sock, address):
+        if self._debug and sock.gettimeout() != 0:
+            raise ValueError("the socket must be non-blocking")
         return await self._proactor.connect(sock, address)
 
     async def sock_accept(self, sock):
diff --git a/Lib/asyncio/queues.py b/Lib/asyncio/queues.py
index a9656a6df5..084fccaaff 100644
--- a/Lib/asyncio/queues.py
+++ b/Lib/asyncio/queues.py
@@ -1,4 +1,11 @@
-__all__ = ('Queue', 'PriorityQueue', 'LifoQueue', 'QueueFull', 'QueueEmpty')
+__all__ = (
+    'Queue',
+    'PriorityQueue',
+    'LifoQueue',
+    'QueueFull',
+    'QueueEmpty',
+    'QueueShutDown',
+)
 
 import collections
 import heapq
@@ -18,6 +25,11 @@ class QueueFull(Exception):
     pass
 
 
+class QueueShutDown(Exception):
+    """Raised when putting on to or getting from a shut-down Queue."""
+    pass
+
+
 class Queue(mixins._LoopBoundMixin):
     """A queue, useful for coordinating producer and consumer coroutines.
 
@@ -41,6 +53,7 @@ def __init__(self, maxsize=0):
         self._finished = locks.Event()
         self._finished.set()
         self._init(maxsize)
+        self._is_shutdown = False
 
     # These three are overridable in subclasses.
 
@@ -81,6 +94,8 @@ def _format(self):
             result += f' _putters[{len(self._putters)}]'
         if self._unfinished_tasks:
             result += f' tasks={self._unfinished_tasks}'
+        if self._is_shutdown:
+            result += ' shutdown'
         return result
 
     def qsize(self):
@@ -112,8 +127,12 @@ async def put(self, item):
 
         Put an item into the queue. If the queue is full, wait until a free
         slot is available before adding item.
+
+        Raises QueueShutDown if the queue has been shut down.
         """
         while self.full():
+            if self._is_shutdown:
+                raise QueueShutDown
             putter = self._get_loop().create_future()
             self._putters.append(putter)
             try:
@@ -125,7 +144,7 @@ async def put(self, item):
                     self._putters.remove(putter)
                 except ValueError:
                     # The putter could be removed from self._putters by a
-                    # previous get_nowait call.
+                    # previous get_nowait call or a shutdown call.
                     pass
                 if not self.full() and not putter.cancelled():
                     # We were woken up by get_nowait(), but can't take
@@ -138,7 +157,11 @@ def put_nowait(self, item):
         """Put an item into the queue without blocking.
 
         If no free slot is immediately available, raise QueueFull.
+
+        Raises QueueShutDown if the queue has been shut down.
         """
+        if self._is_shutdown:
+            raise QueueShutDown
         if self.full():
             raise QueueFull
         self._put(item)
@@ -150,8 +173,13 @@ async def get(self):
         """Remove and return an item from the queue.
 
         If queue is empty, wait until an item is available.
+
+        Raises QueueShutDown if the queue has been shut down and is empty, or
+        if the queue has been shut down immediately.
         """
         while self.empty():
+            if self._is_shutdown and self.empty():
+                raise QueueShutDown
             getter = self._get_loop().create_future()
             self._getters.append(getter)
             try:
@@ -163,7 +191,7 @@ async def get(self):
                     self._getters.remove(getter)
                 except ValueError:
                     # The getter could be removed from self._getters by a
-                    # previous put_nowait call.
+                    # previous put_nowait call, or a shutdown call.
                     pass
                 if not self.empty() and not getter.cancelled():
                     # We were woken up by put_nowait(), but can't take
@@ -176,8 +204,13 @@ def get_nowait(self):
         """Remove and return an item from the queue.
 
         Return an item if one is immediately available, else raise QueueEmpty.
+
+        Raises QueueShutDown if the queue has been shut down and is empty, or
+        if the queue has been shut down immediately.
         """
         if self.empty():
+            if self._is_shutdown:
+                raise QueueShutDown
             raise QueueEmpty
         item = self._get()
         self._wakeup_next(self._putters)
@@ -214,6 +247,36 @@ async def join(self):
         if self._unfinished_tasks > 0:
             await self._finished.wait()
 
+    def shutdown(self, immediate=False):
+        """Shut-down the queue, making queue gets and puts raise QueueShutDown.
+
+        By default, gets will only raise once the queue is empty. Set
+        'immediate' to True to make gets raise immediately instead.
+
+        All blocked callers of put() and get() will be unblocked.
+
+        If 'immediate', the queue is drained and unfinished tasks
+        is reduced by the number of drained tasks.  If unfinished tasks
+        is reduced to zero, callers of Queue.join are unblocked.
+        """
+        self._is_shutdown = True
+        if immediate:
+            while not self.empty():
+                self._get()
+                if self._unfinished_tasks > 0:
+                    self._unfinished_tasks -= 1
+            if self._unfinished_tasks == 0:
+                self._finished.set()
+        # All getters need to re-check queue-empty to raise ShutDown
+        while self._getters:
+            getter = self._getters.popleft()
+            if not getter.done():
+                getter.set_result(None)
+        while self._putters:
+            putter = self._putters.popleft()
+            if not putter.done():
+                putter.set_result(None)
+
 
 class PriorityQueue(Queue):
     """A subclass of Queue; retrieves entries in priority order (lowest first).
diff --git a/Lib/asyncio/runners.py b/Lib/asyncio/runners.py
index 1b89236599..102ae78021 100644
--- a/Lib/asyncio/runners.py
+++ b/Lib/asyncio/runners.py
@@ -168,6 +168,7 @@ def run(main, *, debug=None, loop_factory=None):
     running in the same thread.
 
     If debug is True, the event loop will be run in debug mode.
+    If loop_factory is passed, it is used for new event loop creation.
 
     This function always creates a new event loop and closes it at the end.
     It should be used as a main entry point for asyncio programs, and should
diff --git a/Lib/asyncio/selector_events.py b/Lib/asyncio/selector_events.py
index 790711f834..8701467d41 100644
--- a/Lib/asyncio/selector_events.py
+++ b/Lib/asyncio/selector_events.py
@@ -265,22 +265,17 @@ def _ensure_fd_no_transport(self, fd):
             except (AttributeError, TypeError, ValueError):
                 # This code matches selectors._fileobj_to_fd function.
                 raise ValueError(f"Invalid file object: {fd!r}") from None
-        try:
-            transport = self._transports[fileno]
-        except KeyError:
-            pass
-        else:
-            if not transport.is_closing():
-                raise RuntimeError(
-                    f'File descriptor {fd!r} is used by transport '
-                    f'{transport!r}')
+        transport = self._transports.get(fileno)
+        if transport and not transport.is_closing():
+            raise RuntimeError(
+                f'File descriptor {fd!r} is used by transport '
+                f'{transport!r}')
 
     def _add_reader(self, fd, callback, *args):
         self._check_closed()
         handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             self._selector.register(fd, selectors.EVENT_READ,
                                     (handle, None))
         else:
@@ -294,30 +289,27 @@ def _add_reader(self, fd, callback, *args):
     def _remove_reader(self, fd):
         if self.is_closed():
             return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             return False
+        mask, (reader, writer) = key.events, key.data
+        mask &= ~selectors.EVENT_READ
+        if not mask:
+            self._selector.unregister(fd)
         else:
-            mask, (reader, writer) = key.events, key.data
-            mask &= ~selectors.EVENT_READ
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (None, writer))
+            self._selector.modify(fd, mask, (None, writer))
 
-            if reader is not None:
-                reader.cancel()
-                return True
-            else:
-                return False
+        if reader is not None:
+            reader.cancel()
+            return True
+        else:
+            return False
 
     def _add_writer(self, fd, callback, *args):
         self._check_closed()
         handle = events.Handle(callback, args, self, None)
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             self._selector.register(fd, selectors.EVENT_WRITE,
                                     (None, handle))
         else:
@@ -332,24 +324,22 @@ def _remove_writer(self, fd):
         """Remove a writer callback."""
         if self.is_closed():
             return False
-        try:
-            key = self._selector.get_key(fd)
-        except KeyError:
+        key = self._selector.get_map().get(fd)
+        if key is None:
             return False
+        mask, (reader, writer) = key.events, key.data
+        # Remove both writer and connector.
+        mask &= ~selectors.EVENT_WRITE
+        if not mask:
+            self._selector.unregister(fd)
         else:
-            mask, (reader, writer) = key.events, key.data
-            # Remove both writer and connector.
-            mask &= ~selectors.EVENT_WRITE
-            if not mask:
-                self._selector.unregister(fd)
-            else:
-                self._selector.modify(fd, mask, (reader, None))
+            self._selector.modify(fd, mask, (reader, None))
 
-            if writer is not None:
-                writer.cancel()
-                return True
-            else:
-                return False
+        if writer is not None:
+            writer.cancel()
+            return True
+        else:
+            return False
 
     def add_reader(self, fd, callback, *args):
         """Add a reader callback."""
@@ -801,7 +791,7 @@ def __init__(self, loop, sock, protocol, extra=None, server=None):
         self._paused = False  # Set when pause_reading() called
 
         if self._server is not None:
-            self._server._attach()
+            self._server._attach(self)
         loop._transports[self._sock_fd] = self
 
     def __repr__(self):
@@ -878,6 +868,8 @@ def __del__(self, _warn=warnings.warn):
         if self._sock is not None:
             _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
             self._sock.close()
+            if self._server is not None:
+                self._server._detach(self)
 
     def _fatal_error(self, exc, message='Fatal error on transport'):
         # Should be called from exception handler only.
@@ -916,7 +908,7 @@ def _call_connection_lost(self, exc):
             self._loop = None
             server = self._server
             if server is not None:
-                server._detach()
+                server._detach(self)
                 self._server = None
 
     def get_write_buffer_size(self):
@@ -1054,8 +1046,8 @@ def _read_ready__on_eof(self):
 
     def write(self, data):
         if not isinstance(data, (bytes, bytearray, memoryview)):
-            raise TypeError(f'data argument must be a bytes-like object, '
-                            f'not {type(data).__name__!r}')
+            raise TypeError(f'data argument must be a bytes, bytearray, or memoryview '
+                            f'object, not {type(data).__name__!r}')
         if self._eof:
             raise RuntimeError('Cannot call write() after write_eof()')
         if self._empty_waiter is not None:
@@ -1178,20 +1170,31 @@ def writelines(self, list_of_data):
             raise RuntimeError('unable to writelines; sendfile is in progress')
         if not list_of_data:
             return
+
+        if self._conn_lost:
+            if self._conn_lost >= constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES:
+                logger.warning('socket.send() raised exception.')
+            self._conn_lost += 1
+            return
+
         self._buffer.extend([memoryview(data) for data in list_of_data])
         self._write_ready()
         # If the entire buffer couldn't be written, register a write handler
         if self._buffer:
             self._loop._add_writer(self._sock_fd, self._write_ready)
+            self._maybe_pause_protocol()
 
     def can_write_eof(self):
         return True
 
     def _call_connection_lost(self, exc):
-        super()._call_connection_lost(exc)
-        if self._empty_waiter is not None:
-            self._empty_waiter.set_exception(
-                ConnectionError("Connection is closed by peer"))
+        try:
+            super()._call_connection_lost(exc)
+        finally:
+            self._write_ready = None
+            if self._empty_waiter is not None:
+                self._empty_waiter.set_exception(
+                    ConnectionError("Connection is closed by peer"))
 
     def _make_empty_waiter(self):
         if self._empty_waiter is not None:
@@ -1206,13 +1209,13 @@ def _reset_empty_waiter(self):
 
     def close(self):
         self._read_ready_cb = None
-        self._write_ready = None
         super().close()
 
 
 class _SelectorDatagramTransport(_SelectorTransport, transports.DatagramTransport):
 
     _buffer_factory = collections.deque
+    _header_size = 8
 
     def __init__(self, loop, sock, protocol, address=None,
                  waiter=None, extra=None):
@@ -1251,8 +1254,6 @@ def sendto(self, data, addr=None):
         if not isinstance(data, (bytes, bytearray, memoryview)):
             raise TypeError(f'data argument must be a bytes-like object, '
                             f'not {type(data).__name__!r}')
-        if not data:
-            return
 
         if self._address:
             if addr not in (None, self._address):
@@ -1288,13 +1289,13 @@ def sendto(self, data, addr=None):
 
         # Ensure that what we buffer is immutable.
         self._buffer.append((bytes(data), addr))
-        self._buffer_size += len(data)
+        self._buffer_size += len(data) + self._header_size
         self._maybe_pause_protocol()
 
     def _sendto_ready(self):
         while self._buffer:
             data, addr = self._buffer.popleft()
-            self._buffer_size -= len(data)
+            self._buffer_size -= len(data) + self._header_size
             try:
                 if self._extra['peername']:
                     self._sock.send(data)
@@ -1302,7 +1303,7 @@ def _sendto_ready(self):
                     self._sock.sendto(data, addr)
             except (BlockingIOError, InterruptedError):
                 self._buffer.appendleft((data, addr))  # Try again later.
-                self._buffer_size += len(data)
+                self._buffer_size += len(data) + self._header_size
                 break
             except OSError as exc:
                 self._protocol.error_received(exc)
diff --git a/Lib/asyncio/sslproto.py b/Lib/asyncio/sslproto.py
index e51669a2ab..74c5f0d5ca 100644
--- a/Lib/asyncio/sslproto.py
+++ b/Lib/asyncio/sslproto.py
@@ -101,7 +101,7 @@ def get_protocol(self):
         return self._ssl_protocol._app_protocol
 
     def is_closing(self):
-        return self._closed
+        return self._closed or self._ssl_protocol._is_transport_closing()
 
     def close(self):
         """Close the transport.
@@ -379,6 +379,9 @@ def _get_app_transport(self):
             self._app_transport_created = True
         return self._app_transport
 
+    def _is_transport_closing(self):
+        return self._transport is not None and self._transport.is_closing()
+
     def connection_made(self, transport):
         """Called when the low-level connection is made.
 
@@ -542,7 +545,7 @@ def _start_handshake(self):
         # start handshake timeout count down
         self._handshake_timeout_handle = \
             self._loop.call_later(self._ssl_handshake_timeout,
-                                  lambda: self._check_handshake_timeout())
+                                  self._check_handshake_timeout)
 
         self._do_handshake()
 
@@ -623,7 +626,7 @@ def _start_shutdown(self):
             self._set_state(SSLProtocolState.FLUSHING)
             self._shutdown_timeout_handle = self._loop.call_later(
                 self._ssl_shutdown_timeout,
-                lambda: self._check_shutdown_timeout()
+                self._check_shutdown_timeout
             )
             self._do_flush()
 
@@ -762,7 +765,7 @@ def _do_read__buffered(self):
                     else:
                         break
                 else:
-                    self._loop.call_soon(lambda: self._do_read())
+                    self._loop.call_soon(self._do_read)
         except SSLAgainErrors:
             pass
         if offset > 0:
diff --git a/Lib/asyncio/staggered.py b/Lib/asyncio/staggered.py
index 451a53a16f..0afed64fdf 100644
--- a/Lib/asyncio/staggered.py
+++ b/Lib/asyncio/staggered.py
@@ -3,7 +3,6 @@
 __all__ = 'staggered_race',
 
 import contextlib
-import typing
 
 from . import events
 from . import exceptions as exceptions_mod
@@ -11,16 +10,7 @@
 from . import tasks
 
 
-async def staggered_race(
-        coro_fns: typing.Iterable[typing.Callable[[], typing.Awaitable]],
-        delay: typing.Optional[float],
-        *,
-        loop: events.AbstractEventLoop = None,
-) -> typing.Tuple[
-    typing.Any,
-    typing.Optional[int],
-    typing.List[typing.Optional[Exception]]
-]:
+async def staggered_race(coro_fns, delay, *, loop=None):
     """Run coroutines with staggered start times and take the first to finish.
 
     This method takes an iterable of coroutine functions. The first one is
@@ -76,11 +66,33 @@ async def staggered_race(
     enum_coro_fns = enumerate(coro_fns)
     winner_result = None
     winner_index = None
+    unhandled_exceptions = []
     exceptions = []
-    running_tasks = []
+    running_tasks = set()
+    on_completed_fut = None
+
+    def task_done(task):
+        running_tasks.discard(task)
+        if (
+            on_completed_fut is not None
+            and not on_completed_fut.done()
+            and not running_tasks
+        ):
+            on_completed_fut.set_result(None)
+
+        if task.cancelled():
+            return
+
+        exc = task.exception()
+        if exc is None:
+            return
+        unhandled_exceptions.append(exc)
 
-    async def run_one_coro(
-            previous_failed: typing.Optional[locks.Event]) -> None:
+    async def run_one_coro(ok_to_start, previous_failed) -> None:
+        # in eager tasks this waits for the calling task to append this task
+        # to running_tasks, in regular tasks this wait is a no-op that does
+        # not yield a future. See gh-124309.
+        await ok_to_start.wait()
         # Wait for the previous task to finish, or for delay seconds
         if previous_failed is not None:
             with contextlib.suppress(exceptions_mod.TimeoutError):
@@ -96,9 +108,13 @@ async def run_one_coro(
             return
         # Start task that will run the next coroutine
         this_failed = locks.Event()
-        next_task = loop.create_task(run_one_coro(this_failed))
-        running_tasks.append(next_task)
-        assert len(running_tasks) == this_index + 2
+        next_ok_to_start = locks.Event()
+        next_task = loop.create_task(run_one_coro(next_ok_to_start, this_failed))
+        running_tasks.add(next_task)
+        next_task.add_done_callback(task_done)
+        # next_task has been appended to running_tasks so next_task is ok to
+        # start.
+        next_ok_to_start.set()
         # Prepare place to put this coroutine's exceptions if not won
         exceptions.append(None)
         assert len(exceptions) == this_index + 1
@@ -123,27 +139,36 @@ async def run_one_coro(
             # up as done() == True, cancelled() == False, exception() ==
             # asyncio.CancelledError. This behavior is specified in
             # https://bugs.python.org/issue30048
-            for i, t in enumerate(running_tasks):
-                if i != this_index:
+            current_task = tasks.current_task(loop)
+            for t in running_tasks:
+                if t is not current_task:
                     t.cancel()
 
-    first_task = loop.create_task(run_one_coro(None))
-    running_tasks.append(first_task)
+    propagate_cancellation_error = None
     try:
-        # Wait for a growing list of tasks to all finish: poor man's version of
-        # curio's TaskGroup or trio's nursery
-        done_count = 0
-        while done_count != len(running_tasks):
-            done, _ = await tasks.wait(running_tasks)
-            done_count = len(done)
+        ok_to_start = locks.Event()
+        first_task = loop.create_task(run_one_coro(ok_to_start, None))
+        running_tasks.add(first_task)
+        first_task.add_done_callback(task_done)
+        # first_task has been appended to running_tasks so first_task is ok to start.
+        ok_to_start.set()
+        propagate_cancellation_error = None
+        # Make sure no tasks are left running if we leave this function
+        while running_tasks:
+            on_completed_fut = loop.create_future()
+            try:
+                await on_completed_fut
+            except exceptions_mod.CancelledError as ex:
+                propagate_cancellation_error = ex
+                for task in running_tasks:
+                    task.cancel(*ex.args)
+            on_completed_fut = None
+        if __debug__ and unhandled_exceptions:
             # If run_one_coro raises an unhandled exception, it's probably a
             # programming error, and I want to see it.
-            if __debug__:
-                for d in done:
-                    if d.done() and not d.cancelled() and d.exception():
-                        raise d.exception()
+            raise ExceptionGroup("staggered race failed", unhandled_exceptions)
+        if propagate_cancellation_error is not None:
+            raise propagate_cancellation_error
         return winner_result, winner_index, exceptions
     finally:
-        # Make sure no tasks are left running if we leave this function
-        for t in running_tasks:
-            t.cancel()
+        del exceptions, propagate_cancellation_error, unhandled_exceptions
diff --git a/Lib/asyncio/streams.py b/Lib/asyncio/streams.py
index f310aa2f36..64aac4cc50 100644
--- a/Lib/asyncio/streams.py
+++ b/Lib/asyncio/streams.py
@@ -201,7 +201,6 @@ def __init__(self, stream_reader, client_connected_cb=None, loop=None):
             # is established.
             self._strong_reader = stream_reader
         self._reject_connection = False
-        self._stream_writer = None
         self._task = None
         self._transport = None
         self._client_connected_cb = client_connected_cb
@@ -214,10 +213,8 @@ def _stream_reader(self):
             return None
         return self._stream_reader_wr()
 
-    def _replace_writer(self, writer):
+    def _replace_transport(self, transport):
         loop = self._loop
-        transport = writer.transport
-        self._stream_writer = writer
         self._transport = transport
         self._over_ssl = transport.get_extra_info('sslcontext') is not None
 
@@ -239,11 +236,8 @@ def connection_made(self, transport):
             reader.set_transport(transport)
         self._over_ssl = transport.get_extra_info('sslcontext') is not None
         if self._client_connected_cb is not None:
-            self._stream_writer = StreamWriter(transport, self,
-                                               reader,
-                                               self._loop)
-            res = self._client_connected_cb(reader,
-                                            self._stream_writer)
+            writer = StreamWriter(transport, self, reader, self._loop)
+            res = self._client_connected_cb(reader, writer)
             if coroutines.iscoroutine(res):
                 def callback(task):
                     if task.cancelled():
@@ -405,9 +399,9 @@ async def start_tls(self, sslcontext, *,
             ssl_handshake_timeout=ssl_handshake_timeout,
             ssl_shutdown_timeout=ssl_shutdown_timeout)
         self._transport = new_transport
-        protocol._replace_writer(self)
+        protocol._replace_transport(new_transport)
 
-    def __del__(self):
+    def __del__(self, warnings=warnings):
         if not self._transport.is_closing():
             if self._loop.is_closed():
                 warnings.warn("loop is closed", ResourceWarning)
@@ -596,20 +590,34 @@ async def readuntil(self, separator=b'\n'):
         If the data cannot be read because of over limit, a
         LimitOverrunError exception  will be raised, and the data
         will be left in the internal buffer, so it can be read again.
+
+        The ``separator`` may also be a tuple of separators. In this
+        case the return value will be the shortest possible that has any
+        separator as the suffix. For the purposes of LimitOverrunError,
+        the shortest possible separator is considered to be the one that
+        matched.
         """
-        seplen = len(separator)
-        if seplen == 0:
+        if isinstance(separator, tuple):
+            # Makes sure shortest matches wins
+            separator = sorted(separator, key=len)
+        else:
+            separator = [separator]
+        if not separator:
+            raise ValueError('Separator should contain at least one element')
+        min_seplen = len(separator[0])
+        max_seplen = len(separator[-1])
+        if min_seplen == 0:
             raise ValueError('Separator should be at least one-byte string')
 
         if self._exception is not None:
             raise self._exception
 
         # Consume whole buffer except last bytes, which length is
-        # one less than seplen. Let's check corner cases with
-        # separator='SEPARATOR':
+        # one less than max_seplen. Let's check corner cases with
+        # separator[-1]='SEPARATOR':
         # * we have received almost complete separator (without last
         #   byte). i.e buffer='some textSEPARATO'. In this case we
-        #   can safely consume len(separator) - 1 bytes.
+        #   can safely consume max_seplen - 1 bytes.
         # * last byte of buffer is first byte of separator, i.e.
         #   buffer='abcdefghijklmnopqrS'. We may safely consume
         #   everything except that last byte, but this require to
@@ -622,26 +630,35 @@ async def readuntil(self, separator=b'\n'):
         #   messages :)
 
         # `offset` is the number of bytes from the beginning of the buffer
-        # where there is no occurrence of `separator`.
+        # where there is no occurrence of any `separator`.
         offset = 0
 
-        # Loop until we find `separator` in the buffer, exceed the buffer size,
+        # Loop until we find a `separator` in the buffer, exceed the buffer size,
         # or an EOF has happened.
         while True:
             buflen = len(self._buffer)
 
-            # Check if we now have enough data in the buffer for `separator` to
-            # fit.
-            if buflen - offset >= seplen:
-                isep = self._buffer.find(separator, offset)
-
-                if isep != -1:
-                    # `separator` is in the buffer. `isep` will be used later
-                    # to retrieve the data.
+            # Check if we now have enough data in the buffer for shortest
+            # separator to fit.
+            if buflen - offset >= min_seplen:
+                match_start = None
+                match_end = None
+                for sep in separator:
+                    isep = self._buffer.find(sep, offset)
+
+                    if isep != -1:
+                        # `separator` is in the buffer. `match_start` and
+                        # `match_end` will be used later to retrieve the
+                        # data.
+                        end = isep + len(sep)
+                        if match_end is None or end < match_end:
+                            match_end = end
+                            match_start = isep
+                if match_end is not None:
                     break
 
                 # see upper comment for explanation.
-                offset = buflen + 1 - seplen
+                offset = max(0, buflen + 1 - max_seplen)
                 if offset > self._limit:
                     raise exceptions.LimitOverrunError(
                         'Separator is not found, and chunk exceed the limit',
@@ -650,7 +667,7 @@ async def readuntil(self, separator=b'\n'):
             # Complete message (with full separator) may be present in buffer
             # even when EOF flag is set. This may happen when the last chunk
             # adds data which makes separator be found. That's why we check for
-            # EOF *ater* inspecting the buffer.
+            # EOF *after* inspecting the buffer.
             if self._eof:
                 chunk = bytes(self._buffer)
                 self._buffer.clear()
@@ -659,12 +676,12 @@ async def readuntil(self, separator=b'\n'):
             # _wait_for_data() will resume reading if stream was paused.
             await self._wait_for_data('readuntil')
 
-        if isep > self._limit:
+        if match_start > self._limit:
             raise exceptions.LimitOverrunError(
-                'Separator is found, but chunk is longer than limit', isep)
+                'Separator is found, but chunk is longer than limit', match_start)
 
-        chunk = self._buffer[:isep + seplen]
-        del self._buffer[:isep + seplen]
+        chunk = self._buffer[:match_end]
+        del self._buffer[:match_end]
         self._maybe_resume_transport()
         return bytes(chunk)
 
diff --git a/Lib/asyncio/taskgroups.py b/Lib/asyncio/taskgroups.py
index d264e51f1f..8fda6c8d55 100644
--- a/Lib/asyncio/taskgroups.py
+++ b/Lib/asyncio/taskgroups.py
@@ -66,6 +66,20 @@ async def __aenter__(self):
         return self
 
     async def __aexit__(self, et, exc, tb):
+        tb = None
+        try:
+            return await self._aexit(et, exc)
+        finally:
+            # Exceptions are heavy objects that can have object
+            # cycles (bad for GC); let's not keep a reference to
+            # a bunch of them. It would be nicer to use a try/finally
+            # in __aexit__ directly but that introduced some diff noise
+            self._parent_task = None
+            self._errors = None
+            self._base_error = None
+            exc = None
+
+    async def _aexit(self, et, exc):
         self._exiting = True
 
         if (exc is not None and
@@ -73,14 +87,10 @@ async def __aexit__(self, et, exc, tb):
                 self._base_error is None):
             self._base_error = exc
 
-        propagate_cancellation_error = \
-            exc if et is exceptions.CancelledError else None
-        if self._parent_cancel_requested:
-            # If this flag is set we *must* call uncancel().
-            if self._parent_task.uncancel() == 0:
-                # If there are no pending cancellations left,
-                # don't propagate CancelledError.
-                propagate_cancellation_error = None
+        if et is not None and issubclass(et, exceptions.CancelledError):
+            propagate_cancellation_error = exc
+        else:
+            propagate_cancellation_error = None
 
         if et is not None:
             if not self._aborting:
@@ -126,25 +136,47 @@ async def __aexit__(self, et, exc, tb):
         assert not self._tasks
 
         if self._base_error is not None:
-            raise self._base_error
+            try:
+                raise self._base_error
+            finally:
+                exc = None
+
+        if self._parent_cancel_requested:
+            # If this flag is set we *must* call uncancel().
+            if self._parent_task.uncancel() == 0:
+                # If there are no pending cancellations left,
+                # don't propagate CancelledError.
+                propagate_cancellation_error = None
 
         # Propagate CancelledError if there is one, except if there
         # are other errors -- those have priority.
-        if propagate_cancellation_error and not self._errors:
-            raise propagate_cancellation_error
-
-        if et is not None and et is not exceptions.CancelledError:
+        try:
+            if propagate_cancellation_error is not None and not self._errors:
+                try:
+                    raise propagate_cancellation_error
+                finally:
+                    exc = None
+        finally:
+            propagate_cancellation_error = None
+
+        if et is not None and not issubclass(et, exceptions.CancelledError):
             self._errors.append(exc)
 
         if self._errors:
-            # Exceptions are heavy objects that can have object
-            # cycles (bad for GC); let's not keep a reference to
-            # a bunch of them.
+            # If the parent task is being cancelled from the outside
+            # of the taskgroup, un-cancel and re-cancel the parent task,
+            # which will keep the cancel count stable.
+            if self._parent_task.cancelling():
+                self._parent_task.uncancel()
+                self._parent_task.cancel()
             try:
-                me = BaseExceptionGroup('unhandled errors in a TaskGroup', self._errors)
-                raise me from None
+                raise BaseExceptionGroup(
+                    'unhandled errors in a TaskGroup',
+                    self._errors,
+                ) from None
             finally:
-                self._errors = None
+                exc = None
+
 
     def create_task(self, coro, *, name=None, context=None):
         """Create a new task in this group and return it.
@@ -152,25 +184,31 @@ def create_task(self, coro, *, name=None, context=None):
         Similar to `asyncio.create_task`.
         """
         if not self._entered:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} has not been entered")
         if self._exiting and not self._tasks:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} is finished")
         if self._aborting:
+            coro.close()
             raise RuntimeError(f"TaskGroup {self!r} is shutting down")
         if context is None:
-            task = self._loop.create_task(coro)
+            task = self._loop.create_task(coro, name=name)
         else:
-            task = self._loop.create_task(coro, context=context)
-        tasks._set_task_name(task, name)
-        # optimization: Immediately call the done callback if the task is
+            task = self._loop.create_task(coro, name=name, context=context)
+
+        # Always schedule the done callback even if the task is
         # already done (e.g. if the coro was able to complete eagerly),
-        # and skip scheduling a done callback
-        if task.done():
-            self._on_task_done(task)
-        else:
-            self._tasks.add(task)
-            task.add_done_callback(self._on_task_done)
-        return task
+        # otherwise if the task completes with an exception then it will cancel
+        # the current task too early. gh-128550, gh-128588
+        self._tasks.add(task)
+        task.add_done_callback(self._on_task_done)
+        try:
+            return task
+        finally:
+            # gh-128552: prevent a refcycle of
+            # task.exception().__traceback__->TaskGroup.create_task->task
+            del task
 
     # Since Python 3.8 Tasks propagate all exceptions correctly,
     # except for KeyboardInterrupt and SystemExit which are
diff --git a/Lib/asyncio/tasks.py b/Lib/asyncio/tasks.py
index 0b22e28d8e..dadcb5b5f3 100644
--- a/Lib/asyncio/tasks.py
+++ b/Lib/asyncio/tasks.py
@@ -15,8 +15,8 @@
 import functools
 import inspect
 import itertools
+import math
 import types
-import warnings
 import weakref
 from types import GenericAlias
 
@@ -25,6 +25,7 @@
 from . import events
 from . import exceptions
 from . import futures
+from . import queues
 from . import timeouts
 
 # Helper to generate new task names
@@ -67,19 +68,6 @@ def all_tasks(loop=None):
             if futures._get_loop(t) is loop and not t.done()}
 
 
-def _set_task_name(task, name):
-    if name is not None:
-        try:
-            set_name = task.set_name
-        except AttributeError:
-            warnings.warn("Task.set_name() was added in Python 3.8, "
-                      "the method support will be mandatory for third-party "
-                      "task implementations since 3.13.",
-                      DeprecationWarning, stacklevel=3)
-        else:
-            set_name(name)
-
-
 class Task(futures._PyFuture):  # Inherit Python Task implementation
                                 # from a Python Future implementation.
 
@@ -267,6 +255,8 @@ def uncancel(self):
         """
         if self._num_cancels_requested > 0:
             self._num_cancels_requested -= 1
+            if self._num_cancels_requested == 0:
+                self._must_cancel = False
         return self._num_cancels_requested
 
     def __eager_start(self):
@@ -417,11 +407,10 @@ def create_task(coro, *, name=None, context=None):
     loop = events.get_running_loop()
     if context is None:
         # Use legacy API if context is not needed
-        task = loop.create_task(coro)
+        task = loop.create_task(coro, name=name)
     else:
-        task = loop.create_task(coro, context=context)
+        task = loop.create_task(coro, name=name, context=context)
 
-    _set_task_name(task, name)
     return task
 
 
@@ -437,8 +426,6 @@ async def wait(fs, *, timeout=None, return_when=ALL_COMPLETED):
 
     The fs iterable must not be empty.
 
-    Coroutines will be wrapped in Tasks.
-
     Returns two sets of Future: (done, pending).
 
     Usage:
@@ -580,62 +567,125 @@ async def _cancel_and_wait(fut):
         fut.remove_done_callback(cb)
 
 
-# This is *not* a @coroutine!  It is just an iterator (yielding Futures).
+class _AsCompletedIterator:
+    """Iterator of awaitables representing tasks of asyncio.as_completed.
+
+    As an asynchronous iterator, iteration yields futures as they finish. As a
+    plain iterator, new coroutines are yielded that will return or raise the
+    result of the next underlying future to complete.
+    """
+    def __init__(self, aws, timeout):
+        self._done = queues.Queue()
+        self._timeout_handle = None
+
+        loop = events.get_event_loop()
+        todo = {ensure_future(aw, loop=loop) for aw in set(aws)}
+        for f in todo:
+            f.add_done_callback(self._handle_completion)
+        if todo and timeout is not None:
+            self._timeout_handle = (
+                loop.call_later(timeout, self._handle_timeout)
+            )
+        self._todo = todo
+        self._todo_left = len(todo)
+
+    def __aiter__(self):
+        return self
+
+    def __iter__(self):
+        return self
+
+    async def __anext__(self):
+        if not self._todo_left:
+            raise StopAsyncIteration
+        assert self._todo_left > 0
+        self._todo_left -= 1
+        return await self._wait_for_one()
+
+    def __next__(self):
+        if not self._todo_left:
+            raise StopIteration
+        assert self._todo_left > 0
+        self._todo_left -= 1
+        return self._wait_for_one(resolve=True)
+
+    def _handle_timeout(self):
+        for f in self._todo:
+            f.remove_done_callback(self._handle_completion)
+            self._done.put_nowait(None)  # Sentinel for _wait_for_one().
+        self._todo.clear()  # Can't do todo.remove(f) in the loop.
+
+    def _handle_completion(self, f):
+        if not self._todo:
+            return  # _handle_timeout() was here first.
+        self._todo.remove(f)
+        self._done.put_nowait(f)
+        if not self._todo and self._timeout_handle is not None:
+            self._timeout_handle.cancel()
+
+    async def _wait_for_one(self, resolve=False):
+        # Wait for the next future to be done and return it unless resolve is
+        # set, in which case return either the result of the future or raise
+        # an exception.
+        f = await self._done.get()
+        if f is None:
+            # Dummy value from _handle_timeout().
+            raise exceptions.TimeoutError
+        return f.result() if resolve else f
+
+
 def as_completed(fs, *, timeout=None):
-    """Return an iterator whose values are coroutines.
+    """Create an iterator of awaitables or their results in completion order.
 
-    When waiting for the yielded coroutines you'll get the results (or
-    exceptions!) of the original Futures (or coroutines), in the order
-    in which and as soon as they complete.
+    Run the supplied awaitables concurrently. The returned object can be
+    iterated to obtain the results of the awaitables as they finish.
 
-    This differs from PEP 3148; the proper way to use this is:
+    The object returned can be iterated as an asynchronous iterator or a plain
+    iterator. When asynchronous iteration is used, the originally-supplied
+    awaitables are yielded if they are tasks or futures. This makes it easy to
+    correlate previously-scheduled tasks with their results:
 
-        for f in as_completed(fs):
-            result = await f  # The 'await' may raise.
-            # Use result.
+        ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+        ipv6_connect = create_task(open_connection("::1", 80))
+        tasks = [ipv4_connect, ipv6_connect]
 
-    If a timeout is specified, the 'await' will raise
-    TimeoutError when the timeout occurs before all Futures are done.
+        async for earliest_connect in as_completed(tasks):
+            # earliest_connect is done. The result can be obtained by
+            # awaiting it or calling earliest_connect.result()
+            reader, writer = await earliest_connect
 
-    Note: The futures 'f' are not necessarily members of fs.
-    """
-    if futures.isfuture(fs) or coroutines.iscoroutine(fs):
-        raise TypeError(f"expect an iterable of futures, not {type(fs).__name__}")
+            if earliest_connect is ipv6_connect:
+                print("IPv6 connection established.")
+            else:
+                print("IPv4 connection established.")
 
-    from .queues import Queue  # Import here to avoid circular import problem.
-    done = Queue()
+    During asynchronous iteration, implicitly-created tasks will be yielded for
+    supplied awaitables that aren't tasks or futures.
 
-    loop = events.get_event_loop()
-    todo = {ensure_future(f, loop=loop) for f in set(fs)}
-    timeout_handle = None
+    When used as a plain iterator, each iteration yields a new coroutine that
+    returns the result or raises the exception of the next completed awaitable.
+    This pattern is compatible with Python versions older than 3.13:
 
-    def _on_timeout():
-        for f in todo:
-            f.remove_done_callback(_on_completion)
-            done.put_nowait(None)  # Queue a dummy value for _wait_for_one().
-        todo.clear()  # Can't do todo.remove(f) in the loop.
+        ipv4_connect = create_task(open_connection("127.0.0.1", 80))
+        ipv6_connect = create_task(open_connection("::1", 80))
+        tasks = [ipv4_connect, ipv6_connect]
 
-    def _on_completion(f):
-        if not todo:
-            return  # _on_timeout() was here first.
-        todo.remove(f)
-        done.put_nowait(f)
-        if not todo and timeout_handle is not None:
-            timeout_handle.cancel()
+        for next_connect in as_completed(tasks):
+            # next_connect is not one of the original task objects. It must be
+            # awaited to obtain the result value or raise the exception of the
+            # awaitable that finishes next.
+            reader, writer = await next_connect
 
-    async def _wait_for_one():
-        f = await done.get()
-        if f is None:
-            # Dummy value from _on_timeout().
-            raise exceptions.TimeoutError
-        return f.result()  # May raise f.exception().
+    A TimeoutError is raised if the timeout occurs before all awaitables are
+    done. This is raised by the async for loop during asynchronous iteration or
+    by the coroutines yielded during plain iteration.
+    """
+    if inspect.isawaitable(fs):
+        raise TypeError(
+            f"expects an iterable of awaitables, not {type(fs).__name__}"
+        )
 
-    for f in todo:
-        f.add_done_callback(_on_completion)
-    if todo and timeout is not None:
-        timeout_handle = loop.call_later(timeout, _on_timeout)
-    for _ in range(len(todo)):
-        yield _wait_for_one()
+    return _AsCompletedIterator(fs, timeout)
 
 
 @types.coroutine
@@ -656,6 +706,9 @@ async def sleep(delay, result=None):
         await __sleep0()
         return result
 
+    if math.isnan(delay):
+        raise ValueError("Invalid delay: NaN (not a number)")
+
     loop = events.get_running_loop()
     future = loop.create_future()
     h = loop.call_later(delay,
diff --git a/Lib/asyncio/timeouts.py b/Lib/asyncio/timeouts.py
index 30042abb3a..e6f5100691 100644
--- a/Lib/asyncio/timeouts.py
+++ b/Lib/asyncio/timeouts.py
@@ -109,10 +109,16 @@ async def __aexit__(
         if self._state is _State.EXPIRING:
             self._state = _State.EXPIRED
 
-            if self._task.uncancel() <= self._cancelling and exc_type is exceptions.CancelledError:
+            if self._task.uncancel() <= self._cancelling and exc_type is not None:
                 # Since there are no new cancel requests, we're
                 # handling this.
-                raise TimeoutError from exc_val
+                if issubclass(exc_type, exceptions.CancelledError):
+                    raise TimeoutError from exc_val
+                elif exc_val is not None:
+                    self._insert_timeout_error(exc_val)
+                    if isinstance(exc_val, ExceptionGroup):
+                        for exc in exc_val.exceptions:
+                            self._insert_timeout_error(exc)
         elif self._state is _State.ENTERED:
             self._state = _State.EXITED
 
@@ -125,6 +131,16 @@ def _on_timeout(self) -> None:
         # drop the reference early
         self._timeout_handler = None
 
+    @staticmethod
+    def _insert_timeout_error(exc_val: BaseException) -> None:
+        while exc_val.__context__ is not None:
+            if isinstance(exc_val.__context__, exceptions.CancelledError):
+                te = TimeoutError()
+                te.__context__ = te.__cause__ = exc_val.__context__
+                exc_val.__context__ = te
+                break
+            exc_val = exc_val.__context__
+
 
 def timeout(delay: Optional[float]) -> Timeout:
     """Timeout async context manager.
diff --git a/Lib/asyncio/transports.py b/Lib/asyncio/transports.py
index 30fd41d49a..34c7ad44ff 100644
--- a/Lib/asyncio/transports.py
+++ b/Lib/asyncio/transports.py
@@ -181,6 +181,8 @@ def sendto(self, data, addr=None):
         to be sent out asynchronously.
         addr is target socket address.
         If addr is None use target address pointed on transport creation.
+        If data is an empty bytes object a zero-length datagram will be
+        sent.
         """
         raise NotImplementedError
 
diff --git a/Lib/asyncio/unix_events.py b/Lib/asyncio/unix_events.py
index f2e920ada4..41ccf1b78f 100644
--- a/Lib/asyncio/unix_events.py
+++ b/Lib/asyncio/unix_events.py
@@ -32,6 +32,7 @@
     'FastChildWatcher', 'PidfdChildWatcher',
     'MultiLoopChildWatcher', 'ThreadedChildWatcher',
     'DefaultEventLoopPolicy',
+    'EventLoop',
 )
 
 
@@ -63,6 +64,7 @@ class _UnixSelectorEventLoop(selector_events.BaseSelectorEventLoop):
     def __init__(self, selector=None):
         super().__init__(selector)
         self._signal_handlers = {}
+        self._unix_server_sockets = {}
 
     def close(self):
         super().close()
@@ -283,7 +285,7 @@ async def create_unix_server(
             sock=None, backlog=100, ssl=None,
             ssl_handshake_timeout=None,
             ssl_shutdown_timeout=None,
-            start_serving=True):
+            start_serving=True, cleanup_socket=True):
         if isinstance(ssl, bool):
             raise TypeError('ssl argument must be an SSLContext or None')
 
@@ -339,6 +341,15 @@ async def create_unix_server(
                 raise ValueError(
                     f'A UNIX Domain Stream Socket was expected, got {sock!r}')
 
+        if cleanup_socket:
+            path = sock.getsockname()
+            # Check for abstract socket. `str` and `bytes` paths are supported.
+            if path[0] not in (0, '\x00'):
+                try:
+                    self._unix_server_sockets[sock] = os.stat(path).st_ino
+                except FileNotFoundError:
+                    pass
+
         sock.setblocking(False)
         server = base_events.Server(self, [sock], protocol_factory,
                                     ssl, backlog, ssl_handshake_timeout,
@@ -393,6 +404,9 @@ def _sock_sendfile_native_impl(self, fut, registered_fd, sock, fileno,
                 fut.set_result(total_sent)
                 return
 
+        # On 32-bit architectures truncate to 1GiB to avoid OverflowError
+        blocksize = min(blocksize, sys.maxsize//2 + 1)
+
         try:
             sent = os.sendfile(fd, fileno, offset, blocksize)
         except (BlockingIOError, InterruptedError):
@@ -456,6 +470,27 @@ def cb(fut):
                     self.remove_writer(fd)
         fut.add_done_callback(cb)
 
+    def _stop_serving(self, sock):
+        # Is this a unix socket that needs cleanup?
+        if sock in self._unix_server_sockets:
+            path = sock.getsockname()
+        else:
+            path = None
+
+        super()._stop_serving(sock)
+
+        if path is not None:
+            prev_ino = self._unix_server_sockets[sock]
+            del self._unix_server_sockets[sock]
+            try:
+                if os.stat(path).st_ino == prev_ino:
+                    os.unlink(path)
+            except FileNotFoundError:
+                pass
+            except OSError as err:
+                logger.error('Unable to clean up listening UNIX socket '
+                             '%r: %r', path, err)
+
 
 class _UnixReadPipeTransport(transports.ReadTransport):
 
@@ -1498,3 +1533,4 @@ def set_child_watcher(self, watcher):
 
 SelectorEventLoop = _UnixSelectorEventLoop
 DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
+EventLoop = SelectorEventLoop
diff --git a/Lib/asyncio/windows_events.py b/Lib/asyncio/windows_events.py
index cb613451a5..bf99bc271c 100644
--- a/Lib/asyncio/windows_events.py
+++ b/Lib/asyncio/windows_events.py
@@ -30,7 +30,7 @@
 __all__ = (
     'SelectorEventLoop', 'ProactorEventLoop', 'IocpProactor',
     'DefaultEventLoopPolicy', 'WindowsSelectorEventLoopPolicy',
-    'WindowsProactorEventLoopPolicy',
+    'WindowsProactorEventLoopPolicy', 'EventLoop',
 )
 
 
@@ -315,24 +315,25 @@ def __init__(self, proactor=None):
             proactor = IocpProactor()
         super().__init__(proactor)
 
-    def run_forever(self):
-        try:
-            assert self._self_reading_future is None
-            self.call_soon(self._loop_self_reading)
-            super().run_forever()
-        finally:
-            if self._self_reading_future is not None:
-                ov = self._self_reading_future._ov
-                self._self_reading_future.cancel()
-                # self_reading_future always uses IOCP, so even though it's
-                # been cancelled, we need to make sure that the IOCP message
-                # is received so that the kernel is not holding on to the
-                # memory, possibly causing memory corruption later. Only
-                # unregister it if IO is complete in all respects. Otherwise
-                # we need another _poll() later to complete the IO.
-                if ov is not None and not ov.pending:
-                    self._proactor._unregister(ov)
-                self._self_reading_future = None
+    def _run_forever_setup(self):
+        assert self._self_reading_future is None
+        self.call_soon(self._loop_self_reading)
+        super()._run_forever_setup()
+
+    def _run_forever_cleanup(self):
+        super()._run_forever_cleanup()
+        if self._self_reading_future is not None:
+            ov = self._self_reading_future._ov
+            self._self_reading_future.cancel()
+            # self_reading_future always uses IOCP, so even though it's
+            # been cancelled, we need to make sure that the IOCP message
+            # is received so that the kernel is not holding on to the
+            # memory, possibly causing memory corruption later. Only
+            # unregister it if IO is complete in all respects. Otherwise
+            # we need another _poll() later to complete the IO.
+            if ov is not None and not ov.pending:
+                self._proactor._unregister(ov)
+            self._self_reading_future = None
 
     async def create_pipe_connection(self, protocol_factory, address):
         f = self._proactor.connect_pipe(address)
@@ -899,3 +900,4 @@ class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
 
 
 DefaultEventLoopPolicy = WindowsProactorEventLoopPolicy
+EventLoop = ProactorEventLoop
diff --git a/Lib/base64.py b/Lib/base64.py
old mode 100644
new mode 100755
diff --git a/Lib/bdb.py b/Lib/bdb.py
index 0f3eec653b..f256b56daa 100644
--- a/Lib/bdb.py
+++ b/Lib/bdb.py
@@ -3,6 +3,7 @@
 import fnmatch
 import sys
 import os
+from contextlib import contextmanager
 from inspect import CO_GENERATOR, CO_COROUTINE, CO_ASYNC_GENERATOR
 
 __all__ = ["BdbQuit", "Bdb", "Breakpoint"]
@@ -32,7 +33,12 @@ def __init__(self, skip=None):
         self.skip = set(skip) if skip else None
         self.breaks = {}
         self.fncache = {}
+        self.frame_trace_lines_opcodes = {}
         self.frame_returning = None
+        self.trace_opcodes = False
+        self.enterframe = None
+        self.cmdframe = None
+        self.cmdlineno = None
 
         self._load_breaks()
 
@@ -60,6 +66,12 @@ def reset(self):
         self.botframe = None
         self._set_stopinfo(None, None)
 
+    @contextmanager
+    def set_enterframe(self, frame):
+        self.enterframe = frame
+        yield
+        self.enterframe = None
+
     def trace_dispatch(self, frame, event, arg):
         """Dispatch a trace function for debugged frames based on the event.
 
@@ -84,24 +96,28 @@ def trace_dispatch(self, frame, event, arg):
 
         The arg parameter depends on the previous event.
         """
-        if self.quitting:
-            return # None
-        if event == 'line':
-            return self.dispatch_line(frame)
-        if event == 'call':
-            return self.dispatch_call(frame, arg)
-        if event == 'return':
-            return self.dispatch_return(frame, arg)
-        if event == 'exception':
-            return self.dispatch_exception(frame, arg)
-        if event == 'c_call':
-            return self.trace_dispatch
-        if event == 'c_exception':
-            return self.trace_dispatch
-        if event == 'c_return':
+
+        with self.set_enterframe(frame):
+            if self.quitting:
+                return # None
+            if event == 'line':
+                return self.dispatch_line(frame)
+            if event == 'call':
+                return self.dispatch_call(frame, arg)
+            if event == 'return':
+                return self.dispatch_return(frame, arg)
+            if event == 'exception':
+                return self.dispatch_exception(frame, arg)
+            if event == 'c_call':
+                return self.trace_dispatch
+            if event == 'c_exception':
+                return self.trace_dispatch
+            if event == 'c_return':
+                return self.trace_dispatch
+            if event == 'opcode':
+                return self.dispatch_opcode(frame, arg)
+            print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))
             return self.trace_dispatch
-        print('bdb.Bdb.dispatch: unknown debugging event:', repr(event))
-        return self.trace_dispatch
 
     def dispatch_line(self, frame):
         """Invoke user function and return trace function for line event.
@@ -110,7 +126,12 @@ def dispatch_line(self, frame):
         self.user_line(). Raise BdbQuit if self.quitting is set.
         Return self.trace_dispatch to continue tracing in this scope.
         """
-        if self.stop_here(frame) or self.break_here(frame):
+        # GH-136057
+        # For line events, we don't want to stop at the same line where
+        # the latest next/step command was issued.
+        if (self.stop_here(frame) or self.break_here(frame)) and not (
+            self.cmdframe == frame and self.cmdlineno == frame.f_lineno
+        ):
             self.user_line(frame)
             if self.quitting: raise BdbQuit
         return self.trace_dispatch
@@ -157,6 +178,11 @@ def dispatch_return(self, frame, arg):
             # The user issued a 'next' or 'until' command.
             if self.stopframe is frame and self.stoplineno != -1:
                 self._set_stopinfo(None, None)
+            # The previous frame might not have f_trace set, unless we are
+            # issuing a command that does not expect to stop, we should set
+            # f_trace
+            if self.stoplineno != -1:
+                self._set_caller_tracefunc(frame)
         return self.trace_dispatch
 
     def dispatch_exception(self, frame, arg):
@@ -186,6 +212,17 @@ def dispatch_exception(self, frame, arg):
 
         return self.trace_dispatch
 
+    def dispatch_opcode(self, frame, arg):
+        """Invoke user function and return trace function for opcode event.
+        If the debugger stops on the current opcode, invoke
+        self.user_opcode(). Raise BdbQuit if self.quitting is set.
+        Return self.trace_dispatch to continue tracing in this scope.
+        """
+        if self.stop_here(frame) or self.break_here(frame):
+            self.user_opcode(frame)
+            if self.quitting: raise BdbQuit
+        return self.trace_dispatch
+
     # Normally derived classes don't override the following
     # methods, but they may if they want to redefine the
     # definition of stopping and breakpoints.
@@ -272,7 +309,22 @@ def user_exception(self, frame, exc_info):
         """Called when we stop on an exception."""
         pass
 
-    def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
+    def user_opcode(self, frame):
+        """Called when we are about to execute an opcode."""
+        pass
+
+    def _set_trace_opcodes(self, trace_opcodes):
+        if trace_opcodes != self.trace_opcodes:
+            self.trace_opcodes = trace_opcodes
+            frame = self.enterframe
+            while frame is not None:
+                frame.f_trace_opcodes = trace_opcodes
+                if frame is self.botframe:
+                    break
+                frame = frame.f_back
+
+    def _set_stopinfo(self, stopframe, returnframe, stoplineno=0, opcode=False,
+                      cmdframe=None, cmdlineno=None):
         """Set the attributes for stopping.
 
         If stoplineno is greater than or equal to 0, then stop at line
@@ -285,6 +337,21 @@ def _set_stopinfo(self, stopframe, returnframe, stoplineno=0):
         # stoplineno >= 0 means: stop at line >= the stoplineno
         # stoplineno -1 means: don't stop at all
         self.stoplineno = stoplineno
+        # cmdframe/cmdlineno is the frame/line number when the user issued
+        # step/next commands.
+        self.cmdframe = cmdframe
+        self.cmdlineno = cmdlineno
+        self._set_trace_opcodes(opcode)
+
+    def _set_caller_tracefunc(self, current_frame):
+        # Issue #13183: pdb skips frames after hitting a breakpoint and running
+        # step commands.
+        # Restore the trace function in the caller (that may not have been set
+        # for performance reasons) when returning from the current frame, unless
+        # the caller is the botframe.
+        caller_frame = current_frame.f_back
+        if caller_frame and not caller_frame.f_trace and caller_frame is not self.botframe:
+            caller_frame.f_trace = self.trace_dispatch
 
     # Derived classes and clients can call the following methods
     # to affect the stepping state.
@@ -299,19 +366,17 @@ def set_until(self, frame, lineno=None):
 
     def set_step(self):
         """Stop after one line of code."""
-        # Issue #13183: pdb skips frames after hitting a breakpoint and running
-        # step commands.
-        # Restore the trace function in the caller (that may not have been set
-        # for performance reasons) when returning from the current frame.
-        if self.frame_returning:
-            caller_frame = self.frame_returning.f_back
-            if caller_frame and not caller_frame.f_trace:
-                caller_frame.f_trace = self.trace_dispatch
-        self._set_stopinfo(None, None)
+        # set_step() could be called from signal handler so enterframe might be None
+        self._set_stopinfo(None, None, cmdframe=self.enterframe,
+                           cmdlineno=getattr(self.enterframe, 'f_lineno', None))
+
+    def set_stepinstr(self):
+        """Stop before the next instruction."""
+        self._set_stopinfo(None, None, opcode=True)
 
     def set_next(self, frame):
         """Stop on the next line in or below the given frame."""
-        self._set_stopinfo(frame, None)
+        self._set_stopinfo(frame, None, cmdframe=frame, cmdlineno=frame.f_lineno)
 
     def set_return(self, frame):
         """Stop when returning from the given frame."""
@@ -328,11 +393,15 @@ def set_trace(self, frame=None):
         if frame is None:
             frame = sys._getframe().f_back
         self.reset()
-        while frame:
-            frame.f_trace = self.trace_dispatch
-            self.botframe = frame
-            frame = frame.f_back
-        self.set_step()
+        with self.set_enterframe(frame):
+            while frame:
+                frame.f_trace = self.trace_dispatch
+                self.botframe = frame
+                self.frame_trace_lines_opcodes[frame] = (frame.f_trace_lines, frame.f_trace_opcodes)
+                # We need f_trace_lines == True for the debugger to work
+                frame.f_trace_lines = True
+                frame = frame.f_back
+            self.set_stepinstr()
         sys.settrace(self.trace_dispatch)
 
     def set_continue(self):
@@ -349,6 +418,9 @@ def set_continue(self):
             while frame and frame is not self.botframe:
                 del frame.f_trace
                 frame = frame.f_back
+            for frame, (trace_lines, trace_opcodes) in self.frame_trace_lines_opcodes.items():
+                frame.f_trace_lines, frame.f_trace_opcodes = trace_lines, trace_opcodes
+            self.frame_trace_lines_opcodes = {}
 
     def set_quit(self):
         """Set quitting attribute to True.
@@ -387,6 +459,14 @@ def set_break(self, filename, lineno, temporary=False, cond=None,
             return 'Line %s:%d does not exist' % (filename, lineno)
         self._add_to_breaks(filename, lineno)
         bp = Breakpoint(filename, lineno, temporary, cond, funcname)
+        # After we set a new breakpoint, we need to search through all frames
+        # and set f_trace to trace_dispatch if there could be a breakpoint in
+        # that frame.
+        frame = self.enterframe
+        while frame:
+            if self.break_anywhere(frame):
+                frame.f_trace = self.trace_dispatch
+            frame = frame.f_back
         return None
 
     def _load_breaks(self):
diff --git a/Lib/bz2.py b/Lib/bz2.py
index fabe4f73c8..2420cd0190 100644
--- a/Lib/bz2.py
+++ b/Lib/bz2.py
@@ -17,7 +17,7 @@
 from _bz2 import BZ2Compressor, BZ2Decompressor
 
 
-_MODE_CLOSED   = 0
+# Value 0 no longer used
 _MODE_READ     = 1
 # Value 2 no longer used
 _MODE_WRITE    = 3
@@ -54,7 +54,7 @@ def __init__(self, filename, mode="r", *, compresslevel=9):
         """
         self._fp = None
         self._closefp = False
-        self._mode = _MODE_CLOSED
+        self._mode = None
 
         if not (1 <= compresslevel <= 9):
             raise ValueError("compresslevel must be between 1 and 9")
@@ -100,7 +100,7 @@ def close(self):
         May be called more than once without error. Once the file is
         closed, any other operation on it will raise a ValueError.
         """
-        if self._mode == _MODE_CLOSED:
+        if self.closed:
             return
         try:
             if self._mode == _MODE_READ:
@@ -115,13 +115,21 @@ def close(self):
             finally:
                 self._fp = None
                 self._closefp = False
-                self._mode = _MODE_CLOSED
                 self._buffer = None
 
     @property
     def closed(self):
         """True if this file is closed."""
-        return self._mode == _MODE_CLOSED
+        return self._fp is None
+
+    @property
+    def name(self):
+        self._check_not_closed()
+        return self._fp.name
+
+    @property
+    def mode(self):
+        return 'wb' if self._mode == _MODE_WRITE else 'rb'
 
     def fileno(self):
         """Return the file descriptor for the underlying file."""
diff --git a/Lib/code.py b/Lib/code.py
index 2bd5fa3e79..2777c31118 100644
--- a/Lib/code.py
+++ b/Lib/code.py
@@ -5,6 +5,7 @@
 # Inspired by similar code by Jeff Epler and Fredrik Lundh.
 
 
+import builtins
 import sys
 import traceback
 from codeop import CommandCompiler, compile_command
@@ -12,6 +13,7 @@
 __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
            "compile_command"]
 
+
 class InteractiveInterpreter:
     """Base class for InteractiveConsole.
 
@@ -24,10 +26,10 @@ class InteractiveInterpreter:
     def __init__(self, locals=None):
         """Constructor.
 
-        The optional 'locals' argument specifies the dictionary in
-        which code will be executed; it defaults to a newly created
-        dictionary with key "__name__" set to "__console__" and key
-        "__doc__" set to None.
+        The optional 'locals' argument specifies a mapping to use as the
+        namespace in which code will be executed; it defaults to a newly
+        created dictionary with key "__name__" set to "__console__" and
+        key "__doc__" set to None.
 
         """
         if locals is None:
@@ -63,7 +65,7 @@ def runsource(self, source, filename="<input>", symbol="single"):
             code = self.compile(source, filename, symbol)
         except (OverflowError, SyntaxError, ValueError):
             # Case 1
-            self.showsyntaxerror(filename)
+            self.showsyntaxerror(filename, source=source)
             return False
 
         if code is None:
@@ -93,7 +95,7 @@ def runcode(self, code):
         except:
             self.showtraceback()
 
-    def showsyntaxerror(self, filename=None):
+    def showsyntaxerror(self, filename=None, **kwargs):
         """Display the syntax error that just occurred.
 
         This doesn't display a stack trace because there isn't one.
@@ -105,29 +107,14 @@ def showsyntaxerror(self, filename=None):
         The output is written by self.write(), below.
 
         """
-        type, value, tb = sys.exc_info()
-        sys.last_exc = value
-        sys.last_type = type
-        sys.last_value = value
-        sys.last_traceback = tb
-        if filename and type is SyntaxError:
-            # Work hard to stuff the correct filename in the exception
-            try:
-                msg, (dummy_filename, lineno, offset, line) = value.args
-            except ValueError:
-                # Not the format we expect; leave it alone
-                pass
-            else:
-                # Stuff in the right filename
-                value = SyntaxError(msg, (filename, lineno, offset, line))
-                sys.last_exc = sys.last_value = value
-        if sys.excepthook is sys.__excepthook__:
-            lines = traceback.format_exception_only(type, value)
-            self.write(''.join(lines))
-        else:
-            # If someone has set sys.excepthook, we let that take precedence
-            # over self.write
-            sys.excepthook(type, value, tb)
+        try:
+            typ, value, tb = sys.exc_info()
+            if filename and issubclass(typ, SyntaxError):
+                value.filename = filename
+            source = kwargs.pop('source', "")
+            self._showtraceback(typ, value, None, source)
+        finally:
+            typ = value = tb = None
 
     def showtraceback(self):
         """Display the exception that just occurred.
@@ -137,19 +124,46 @@ def showtraceback(self):
         The output is written by self.write(), below.
 
         """
-        sys.last_type, sys.last_value, last_tb = ei = sys.exc_info()
-        sys.last_traceback = last_tb
-        sys.last_exc = ei[1]
         try:
-            lines = traceback.format_exception(ei[0], ei[1], last_tb.tb_next)
-            if sys.excepthook is sys.__excepthook__:
-                self.write(''.join(lines))
-            else:
-                # If someone has set sys.excepthook, we let that take precedence
-                # over self.write
-                sys.excepthook(ei[0], ei[1], last_tb)
+            typ, value, tb = sys.exc_info()
+            self._showtraceback(typ, value, tb.tb_next, '')
         finally:
-            last_tb = ei = None
+            typ = value = tb = None
+
+    def _showtraceback(self, typ, value, tb, source):
+        sys.last_type = typ
+        sys.last_traceback = tb
+        value = value.with_traceback(tb)
+        # Set the line of text that the exception refers to
+        lines = source.splitlines()
+        if (source and typ is SyntaxError
+                and not value.text and value.lineno is not None
+                and len(lines) >= value.lineno):
+            value.text = lines[value.lineno - 1]
+        sys.last_exc = sys.last_value = value = value.with_traceback(tb)
+        if sys.excepthook is sys.__excepthook__:
+            self._excepthook(typ, value, tb)
+        else:
+            # If someone has set sys.excepthook, we let that take precedence
+            # over self.write
+            try:
+                sys.excepthook(typ, value, tb)
+            except SystemExit:
+                raise
+            except BaseException as e:
+                e.__context__ = None
+                e = e.with_traceback(e.__traceback__.tb_next)
+                print('Error in sys.excepthook:', file=sys.stderr)
+                sys.__excepthook__(type(e), e, e.__traceback__)
+                print(file=sys.stderr)
+                print('Original exception was:', file=sys.stderr)
+                sys.__excepthook__(typ, value, tb)
+
+    def _excepthook(self, typ, value, tb):
+        # This method is being overwritten in
+        # _pyrepl.console.InteractiveColoredConsole
+        lines = traceback.format_exception(typ, value, tb)
+        self.write(''.join(lines))
 
     def write(self, data):
         """Write a string.
@@ -169,7 +183,7 @@ class InteractiveConsole(InteractiveInterpreter):
 
     """
 
-    def __init__(self, locals=None, filename="<console>"):
+    def __init__(self, locals=None, filename="<console>", *, local_exit=False):
         """Constructor.
 
         The optional locals argument will be passed to the
@@ -181,6 +195,7 @@ def __init__(self, locals=None, filename="<console>"):
         """
         InteractiveInterpreter.__init__(self, locals)
         self.filename = filename
+        self.local_exit = local_exit
         self.resetbuffer()
 
     def resetbuffer(self):
@@ -219,29 +234,66 @@ def interact(self, banner=None, exitmsg=None):
         elif banner:
             self.write("%s\n" % str(banner))
         more = 0
-        while 1:
-            try:
-                if more:
-                    prompt = sys.ps2
-                else:
-                    prompt = sys.ps1
+
+        # When the user uses exit() or quit() in their interactive shell
+        # they probably just want to exit the created shell, not the whole
+        # process. exit and quit in builtins closes sys.stdin which makes
+        # it super difficult to restore
+        #
+        # When self.local_exit is True, we overwrite the builtins so
+        # exit() and quit() only raises SystemExit and we can catch that
+        # to only exit the interactive shell
+
+        _exit = None
+        _quit = None
+
+        if self.local_exit:
+            if hasattr(builtins, "exit"):
+                _exit = builtins.exit
+                builtins.exit = Quitter("exit")
+
+            if hasattr(builtins, "quit"):
+                _quit = builtins.quit
+                builtins.quit = Quitter("quit")
+
+        try:
+            while True:
                 try:
-                    line = self.raw_input(prompt)
-                except EOFError:
-                    self.write("\n")
-                    break
-                else:
-                    more = self.push(line)
-            except KeyboardInterrupt:
-                self.write("\nKeyboardInterrupt\n")
-                self.resetbuffer()
-                more = 0
-        if exitmsg is None:
-            self.write('now exiting %s...\n' % self.__class__.__name__)
-        elif exitmsg != '':
-            self.write('%s\n' % exitmsg)
-
-    def push(self, line):
+                    if more:
+                        prompt = sys.ps2
+                    else:
+                        prompt = sys.ps1
+                    try:
+                        line = self.raw_input(prompt)
+                    except EOFError:
+                        self.write("\n")
+                        break
+                    else:
+                        more = self.push(line)
+                except KeyboardInterrupt:
+                    self.write("\nKeyboardInterrupt\n")
+                    self.resetbuffer()
+                    more = 0
+                except SystemExit as e:
+                    if self.local_exit:
+                        self.write("\n")
+                        break
+                    else:
+                        raise e
+        finally:
+            # restore exit and quit in builtins if they were modified
+            if _exit is not None:
+                builtins.exit = _exit
+
+            if _quit is not None:
+                builtins.quit = _quit
+
+            if exitmsg is None:
+                self.write('now exiting %s...\n' % self.__class__.__name__)
+            elif exitmsg != '':
+                self.write('%s\n' % exitmsg)
+
+    def push(self, line, filename=None, _symbol="single"):
         """Push a line to the interpreter.
 
         The line should not have a trailing newline; it may have
@@ -257,7 +309,9 @@ def push(self, line):
         """
         self.buffer.append(line)
         source = "\n".join(self.buffer)
-        more = self.runsource(source, self.filename)
+        if filename is None:
+            filename = self.filename
+        more = self.runsource(source, filename, symbol=_symbol)
         if not more:
             self.resetbuffer()
         return more
@@ -276,8 +330,22 @@ def raw_input(self, prompt=""):
         return input(prompt)
 
 
+class Quitter:
+    def __init__(self, name):
+        self.name = name
+        if sys.platform == "win32":
+            self.eof = 'Ctrl-Z plus Return'
+        else:
+            self.eof = 'Ctrl-D (i.e. EOF)'
+
+    def __repr__(self):
+        return f'Use {self.name} or {self.eof} to exit'
+
+    def __call__(self, code=None):
+        raise SystemExit(code)
+
 
-def interact(banner=None, readfunc=None, local=None, exitmsg=None):
+def interact(banner=None, readfunc=None, local=None, exitmsg=None, local_exit=False):
     """Closely emulate the interactive Python interpreter.
 
     This is a backwards compatible interface to the InteractiveConsole
@@ -290,9 +358,10 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None):
     readfunc -- if not None, replaces InteractiveConsole.raw_input()
     local -- passed to InteractiveInterpreter.__init__()
     exitmsg -- passed to InteractiveConsole.interact()
+    local_exit -- passed to InteractiveConsole.__init__()
 
     """
-    console = InteractiveConsole(local)
+    console = InteractiveConsole(local, local_exit=local_exit)
     if readfunc is not None:
         console.raw_input = readfunc
     else:
@@ -308,7 +377,7 @@ def interact(banner=None, readfunc=None, local=None, exitmsg=None):
 
     parser = argparse.ArgumentParser()
     parser.add_argument('-q', action='store_true',
-                       help="don't print version and copyright messages")
+                        help="don't print version and copyright messages")
     args = parser.parse_args()
     if args.q or sys.flags.quiet:
         banner = ''
diff --git a/Lib/codecs.py b/Lib/codecs.py
index 82f23983e7..e4f4e1b5c0 100644
--- a/Lib/codecs.py
+++ b/Lib/codecs.py
@@ -111,6 +111,9 @@ def __repr__(self):
                 (self.__class__.__module__, self.__class__.__qualname__,
                  self.name, id(self))
 
+    def __getnewargs__(self):
+        return tuple(self)
+
 class Codec:
 
     """ Defines the interface for stateless encoders/decoders.
@@ -615,7 +618,7 @@ def readlines(self, sizehint=None, keepends=True):
             method and are included in the list entries.
 
             sizehint, if given, is ignored since there is no efficient
-            way to finding the true end-of-line.
+            way of finding the true end-of-line.
 
         """
         data = self.read()
@@ -706,13 +709,13 @@ def read(self, size=-1):
 
         return self.reader.read(size)
 
-    def readline(self, size=None):
+    def readline(self, size=None, keepends=True):
 
-        return self.reader.readline(size)
+        return self.reader.readline(size, keepends)
 
-    def readlines(self, sizehint=None):
+    def readlines(self, sizehint=None, keepends=True):
 
-        return self.reader.readlines(sizehint)
+        return self.reader.readlines(sizehint, keepends)
 
     def __next__(self):
 
diff --git a/Lib/codeop.py b/Lib/codeop.py
index eea6cbc701..adf000ba29 100644
--- a/Lib/codeop.py
+++ b/Lib/codeop.py
@@ -44,6 +44,7 @@
 # Caveat emptor: These flags are undocumented on purpose and depending
 # on their effect outside the standard library is **unsupported**.
 PyCF_DONT_IMPLY_DEDENT = 0x200
+PyCF_ONLY_AST = 0x400
 PyCF_ALLOW_INCOMPLETE_INPUT = 0x4000
 
 def _maybe_compile(compiler, source, filename, symbol):
@@ -73,15 +74,6 @@ def _maybe_compile(compiler, source, filename, symbol):
 
     return compiler(source, filename, symbol, incomplete_input=False)
 
-def _is_syntax_error(err1, err2):
-    rep1 = repr(err1)
-    rep2 = repr(err2)
-    if "was never closed" in rep1 and "was never closed" in rep2:
-        return False
-    if rep1 == rep2:
-        return True
-    return False
-
 def _compile(source, filename, symbol, incomplete_input=True):
     flags = 0
     if incomplete_input:
@@ -89,7 +81,6 @@ def _compile(source, filename, symbol, incomplete_input=True):
         flags |= PyCF_DONT_IMPLY_DEDENT
     return compile(source, filename, symbol, flags)
 
-
 def compile_command(source, filename="<input>", symbol="single"):
     r"""Compile a command and determine whether it is incomplete.
 
@@ -119,12 +110,14 @@ class Compile:
     def __init__(self):
         self.flags = PyCF_DONT_IMPLY_DEDENT | PyCF_ALLOW_INCOMPLETE_INPUT
 
-    def __call__(self, source, filename, symbol, **kwargs):
-        flags = self.flags
+    def __call__(self, source, filename, symbol, flags=0, **kwargs):
+        flags |= self.flags
         if kwargs.get('incomplete_input', True) is False:
             flags &= ~PyCF_DONT_IMPLY_DEDENT
             flags &= ~PyCF_ALLOW_INCOMPLETE_INPUT
         codeob = compile(source, filename, symbol, flags, True)
+        if flags & PyCF_ONLY_AST:
+            return codeob  # this is an ast.Module in this case
         for feature in _features:
             if codeob.co_flags & feature.compiler_flag:
                 self.flags |= feature.compiler_flag
diff --git a/Lib/concurrent/futures/__init__.py b/Lib/concurrent/futures/__init__.py
index d746aeac50..72de617a5b 100644
--- a/Lib/concurrent/futures/__init__.py
+++ b/Lib/concurrent/futures/__init__.py
@@ -23,6 +23,7 @@
     'ALL_COMPLETED',
     'CancelledError',
     'TimeoutError',
+    'InvalidStateError',
     'BrokenExecutor',
     'Future',
     'Executor',
@@ -50,4 +51,4 @@ def __getattr__(name):
         ThreadPoolExecutor = te
         return te
 
-    raise AttributeError(f"module {__name__} has no attribute {name}")
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/Lib/concurrent/futures/_base.py b/Lib/concurrent/futures/_base.py
index cf119ac643..7d69a5baea 100644
--- a/Lib/concurrent/futures/_base.py
+++ b/Lib/concurrent/futures/_base.py
@@ -50,9 +50,7 @@ class CancelledError(Error):
     """The Future was cancelled."""
     pass
 
-class TimeoutError(Error):
-    """The operation exceeded the given deadline."""
-    pass
+TimeoutError = TimeoutError  # make local alias for the standard exception
 
 class InvalidStateError(Error):
     """The operation is not allowed in this state."""
@@ -284,7 +282,7 @@ def wait(fs, timeout=None, return_when=ALL_COMPLETED):
         A named 2-tuple of sets. The first set, named 'done', contains the
         futures that completed (is finished or cancelled) before the wait
         completed. The second set, named 'not_done', contains uncompleted
-        futures. Duplicate futures given to *fs* are removed and will be 
+        futures. Duplicate futures given to *fs* are removed and will be
         returned only once.
     """
     fs = set(fs)
@@ -312,6 +310,18 @@ def wait(fs, timeout=None, return_when=ALL_COMPLETED):
     done.update(waiter.finished_futures)
     return DoneAndNotDoneFutures(done, fs - done)
 
+
+def _result_or_cancel(fut, timeout=None):
+    try:
+        try:
+            return fut.result(timeout)
+        finally:
+            fut.cancel()
+    finally:
+        # Break a reference cycle with the exception in self._exception
+        del fut
+
+
 class Future(object):
     """Represents the result of an asynchronous computation."""
 
@@ -386,7 +396,7 @@ def done(self):
             return self._state in [CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED]
 
     def __get_result(self):
-        if self._exception:
+        if self._exception is not None:
             try:
                 raise self._exception
             finally:
@@ -606,9 +616,9 @@ def result_iterator():
                 while fs:
                     # Careful not to keep a reference to the popped future
                     if timeout is None:
-                        yield fs.pop().result()
+                        yield _result_or_cancel(fs.pop())
                     else:
-                        yield fs.pop().result(end_time - time.monotonic())
+                        yield _result_or_cancel(fs.pop(), end_time - time.monotonic())
             finally:
                 for future in fs:
                     future.cancel()
diff --git a/Lib/concurrent/futures/process.py b/Lib/concurrent/futures/process.py
index 57941e485d..0dee8303ba 100644
--- a/Lib/concurrent/futures/process.py
+++ b/Lib/concurrent/futures/process.py
@@ -49,6 +49,8 @@
 from concurrent.futures import _base
 import queue
 import multiprocessing as mp
+# This import is required to load the multiprocessing.connection submodule
+# so that it can be accessed later as `mp.connection`
 import multiprocessing.connection
 from multiprocessing.queues import Queue
 import threading
@@ -56,7 +58,7 @@
 from functools import partial
 import itertools
 import sys
-import traceback
+from traceback import format_exception
 
 
 _threads_wakeups = weakref.WeakKeyDictionary()
@@ -66,22 +68,31 @@
 class _ThreadWakeup:
     def __init__(self):
         self._closed = False
+        self._lock = threading.Lock()
         self._reader, self._writer = mp.Pipe(duplex=False)
 
     def close(self):
-        if not self._closed:
-            self._closed = True
-            self._writer.close()
-            self._reader.close()
+        # Please note that we do not take the self._lock when
+        # calling clear() (to avoid deadlocking) so this method can
+        # only be called safely from the same thread as all calls to
+        # clear() even if you hold the lock. Otherwise we
+        # might try to read from the closed pipe.
+        with self._lock:
+            if not self._closed:
+                self._closed = True
+                self._writer.close()
+                self._reader.close()
 
     def wakeup(self):
-        if not self._closed:
-            self._writer.send_bytes(b"")
+        with self._lock:
+            if not self._closed:
+                self._writer.send_bytes(b"")
 
     def clear(self):
-        if not self._closed:
-            while self._reader.poll():
-                self._reader.recv_bytes()
+        if self._closed:
+            raise RuntimeError('operation on closed _ThreadWakeup')
+        while self._reader.poll():
+            self._reader.recv_bytes()
 
 
 def _python_exit():
@@ -123,8 +134,7 @@ def __str__(self):
 
 class _ExceptionWithTraceback:
     def __init__(self, exc, tb):
-        tb = traceback.format_exception(type(exc), exc, tb)
-        tb = ''.join(tb)
+        tb = ''.join(format_exception(type(exc), exc, tb))
         self.exc = exc
         # Traceback object needs to be garbage-collected as its frames
         # contain references to all the objects in the exception scope
@@ -145,10 +155,11 @@ def __init__(self, future, fn, args, kwargs):
         self.kwargs = kwargs
 
 class _ResultItem(object):
-    def __init__(self, work_id, exception=None, result=None):
+    def __init__(self, work_id, exception=None, result=None, exit_pid=None):
         self.work_id = work_id
         self.exception = exception
         self.result = result
+        self.exit_pid = exit_pid
 
 class _CallItem(object):
     def __init__(self, work_id, fn, args, kwargs):
@@ -160,20 +171,17 @@ def __init__(self, work_id, fn, args, kwargs):
 
 class _SafeQueue(Queue):
     """Safe Queue set exception to the future object linked to a job"""
-    def __init__(self, max_size=0, *, ctx, pending_work_items, shutdown_lock,
-                 thread_wakeup):
+    def __init__(self, max_size=0, *, ctx, pending_work_items, thread_wakeup):
         self.pending_work_items = pending_work_items
-        self.shutdown_lock = shutdown_lock
         self.thread_wakeup = thread_wakeup
         super().__init__(max_size, ctx=ctx)
 
     def _on_queue_feeder_error(self, e, obj):
         if isinstance(obj, _CallItem):
-            tb = traceback.format_exception(type(e), e, e.__traceback__)
+            tb = format_exception(type(e), e, e.__traceback__)
             e.__cause__ = _RemoteTraceback('\n"""\n{}"""'.format(''.join(tb)))
             work_item = self.pending_work_items.pop(obj.work_id, None)
-            with self.shutdown_lock:
-                self.thread_wakeup.wakeup()
+            self.thread_wakeup.wakeup()
             # work_item can be None if another process terminated. In this
             # case, the executor_manager_thread fails all work_items
             # with BrokenProcessPool
@@ -183,16 +191,6 @@ def _on_queue_feeder_error(self, e, obj):
             super()._on_queue_feeder_error(e, obj)
 
 
-def _get_chunks(*iterables, chunksize):
-    """ Iterates over zip()ed iterables in chunks. """
-    it = zip(*iterables)
-    while True:
-        chunk = tuple(itertools.islice(it, chunksize))
-        if not chunk:
-            return
-        yield chunk
-
-
 def _process_chunk(fn, chunk):
     """ Processes a chunk of an iterable passed to map.
 
@@ -205,17 +203,19 @@ def _process_chunk(fn, chunk):
     return [fn(*args) for args in chunk]
 
 
-def _sendback_result(result_queue, work_id, result=None, exception=None):
+def _sendback_result(result_queue, work_id, result=None, exception=None,
+                     exit_pid=None):
     """Safely send back the given result or exception"""
     try:
         result_queue.put(_ResultItem(work_id, result=result,
-                                     exception=exception))
+                                     exception=exception, exit_pid=exit_pid))
     except BaseException as e:
         exc = _ExceptionWithTraceback(e, e.__traceback__)
-        result_queue.put(_ResultItem(work_id, exception=exc))
+        result_queue.put(_ResultItem(work_id, exception=exc,
+                                     exit_pid=exit_pid))
 
 
-def _process_worker(call_queue, result_queue, initializer, initargs):
+def _process_worker(call_queue, result_queue, initializer, initargs, max_tasks=None):
     """Evaluates calls from call_queue and places the results in result_queue.
 
     This worker is run in a separate process.
@@ -236,25 +236,38 @@ def _process_worker(call_queue, result_queue, initializer, initargs):
             # The parent will notice that the process stopped and
             # mark the pool broken
             return
+    num_tasks = 0
+    exit_pid = None
     while True:
         call_item = call_queue.get(block=True)
         if call_item is None:
             # Wake up queue management thread
             result_queue.put(os.getpid())
             return
+
+        if max_tasks is not None:
+            num_tasks += 1
+            if num_tasks >= max_tasks:
+                exit_pid = os.getpid()
+
         try:
             r = call_item.fn(*call_item.args, **call_item.kwargs)
         except BaseException as e:
             exc = _ExceptionWithTraceback(e, e.__traceback__)
-            _sendback_result(result_queue, call_item.work_id, exception=exc)
+            _sendback_result(result_queue, call_item.work_id, exception=exc,
+                             exit_pid=exit_pid)
         else:
-            _sendback_result(result_queue, call_item.work_id, result=r)
+            _sendback_result(result_queue, call_item.work_id, result=r,
+                             exit_pid=exit_pid)
             del r
 
         # Liberate the resource as soon as possible, to avoid holding onto
         # open files or shared memory that is not needed anymore
         del call_item
 
+        if exit_pid is not None:
+            return
+
 
 class _ExecutorManagerThread(threading.Thread):
     """Manages the communication between this process and the worker processes.
@@ -284,11 +297,10 @@ def __init__(self, executor):
         # if there is no pending work item.
         def weakref_cb(_,
                        thread_wakeup=self.thread_wakeup,
-                       shutdown_lock=self.shutdown_lock):
-            mp.util.debug('Executor collected: triggering callback for'
+                       mp_util_debug=mp.util.debug):
+            mp_util_debug('Executor collected: triggering callback for'
                           ' QueueManager wakeup')
-            with shutdown_lock:
-                thread_wakeup.wakeup()
+            thread_wakeup.wakeup()
 
         self.executor_reference = weakref.ref(executor, weakref_cb)
 
@@ -305,6 +317,10 @@ def weakref_cb(_,
         # A queue.Queue of work ids e.g. Queue([5, 6, ...]).
         self.work_ids_queue = executor._work_ids
 
+        # Maximum number of tasks a worker process can execute before
+        # exiting safely
+        self.max_tasks_per_child = executor._max_tasks_per_child
+
         # A dict mapping work ids to _WorkItems e.g.
         #     {5: <_WorkItem...>, 6: <_WorkItem...>, ...}
         self.pending_work_items = executor._pending_work_items
@@ -315,7 +331,14 @@ def run(self):
         # Main loop for the executor manager thread.
 
         while True:
-            self.add_call_item_to_queue()
+            # gh-109047: During Python finalization, self.call_queue.put()
+            # creation of a thread can fail with RuntimeError.
+            try:
+                self.add_call_item_to_queue()
+            except BaseException as exc:
+                cause = format_exception(exc)
+                self.terminate_broken(cause)
+                return
 
             result_item, is_broken, cause = self.wait_result_broken_or_wakeup()
 
@@ -324,19 +347,32 @@ def run(self):
                 return
             if result_item is not None:
                 self.process_result_item(result_item)
+
+                process_exited = result_item.exit_pid is not None
+                if process_exited:
+                    p = self.processes.pop(result_item.exit_pid)
+                    p.join()
+
                 # Delete reference to result_item to avoid keeping references
                 # while waiting on new results.
                 del result_item
 
-                # attempt to increment idle process count
-                executor = self.executor_reference()
-                if executor is not None:
-                    executor._idle_worker_semaphore.release()
-                del executor
+                if executor := self.executor_reference():
+                    if process_exited:
+                        with self.shutdown_lock:
+                            executor._adjust_process_count()
+                    else:
+                        executor._idle_worker_semaphore.release()
+                    del executor
 
             if self.is_shutting_down():
                 self.flag_executor_shutting_down()
 
+                # When only canceled futures remain in pending_work_items, our
+                # next call to wait_result_broken_or_wakeup would hang forever.
+                # This makes sure we have some running futures or none at all.
+                self.add_call_item_to_queue()
+
                 # Since no new work items can be added, it is safe to shutdown
                 # this thread if there are no pending work items.
                 if not self.pending_work_items:
@@ -386,14 +422,13 @@ def wait_result_broken_or_wakeup(self):
             try:
                 result_item = result_reader.recv()
                 is_broken = False
-            except BaseException as e:
-                cause = traceback.format_exception(type(e), e, e.__traceback__)
+            except BaseException as exc:
+                cause = format_exception(exc)
 
         elif wakeup_reader in ready:
             is_broken = False
 
-        with self.shutdown_lock:
-            self.thread_wakeup.clear()
+        self.thread_wakeup.clear()
 
         return result_item, is_broken, cause
 
@@ -401,24 +436,14 @@ def process_result_item(self, result_item):
         # Process the received a result_item. This can be either the PID of a
         # worker that exited gracefully or a _ResultItem
 
-        if isinstance(result_item, int):
-            # Clean shutdown of a worker using its PID
-            # (avoids marking the executor broken)
-            assert self.is_shutting_down()
-            p = self.processes.pop(result_item)
-            p.join()
-            if not self.processes:
-                self.join_executor_internals()
-                return
-        else:
-            # Received a _ResultItem so mark the future as completed.
-            work_item = self.pending_work_items.pop(result_item.work_id, None)
-            # work_item can be None if another process terminated (see above)
-            if work_item is not None:
-                if result_item.exception:
-                    work_item.future.set_exception(result_item.exception)
-                else:
-                    work_item.future.set_result(result_item.result)
+        # Received a _ResultItem so mark the future as completed.
+        work_item = self.pending_work_items.pop(result_item.work_id, None)
+        # work_item can be None if another process terminated (see above)
+        if work_item is not None:
+            if result_item.exception is not None:
+                work_item.future.set_exception(result_item.exception)
+            else:
+                work_item.future.set_result(result_item.result)
 
     def is_shutting_down(self):
         # Check whether we should start shutting down the executor.
@@ -430,7 +455,7 @@ def is_shutting_down(self):
         return (_global_shutdown or executor is None
                 or executor._shutdown_thread)
 
-    def terminate_broken(self, cause):
+    def _terminate_broken(self, cause):
         # Terminate the executor because it is in a broken state. The cause
         # argument can be used to display more information on the error that
         # lead the executor into becoming broken.
@@ -455,7 +480,14 @@ def terminate_broken(self, cause):
 
         # Mark pending tasks as failed.
         for work_id, work_item in self.pending_work_items.items():
-            work_item.future.set_exception(bpe)
+            try:
+                work_item.future.set_exception(bpe)
+            except _base.InvalidStateError:
+                # set_exception() fails if the future is cancelled: ignore it.
+                # Trying to check if the future is cancelled before calling
+                # set_exception() would leave a race condition if the future is
+                # cancelled between the check and set_exception().
+                pass
             # Delete references to object. See issue16284
             del work_item
         self.pending_work_items.clear()
@@ -465,8 +497,14 @@ def terminate_broken(self, cause):
         for p in self.processes.values():
             p.terminate()
 
+        self.call_queue._terminate_broken()
+
         # clean up resources
-        self.join_executor_internals()
+        self._join_executor_internals(broken=True)
+
+    def terminate_broken(self, cause):
+        with self.shutdown_lock:
+            self._terminate_broken(cause)
 
     def flag_executor_shutting_down(self):
         # Flag the executor as shutting down and cancel remaining tasks if
@@ -509,15 +547,24 @@ def shutdown_workers(self):
                     break
 
     def join_executor_internals(self):
-        self.shutdown_workers()
+        with self.shutdown_lock:
+            self._join_executor_internals()
+
+    def _join_executor_internals(self, broken=False):
+        # If broken, call_queue was closed and so can no longer be used.
+        if not broken:
+            self.shutdown_workers()
+
         # Release the queue's resources as soon as possible.
         self.call_queue.close()
         self.call_queue.join_thread()
-        with self.shutdown_lock:
-            self.thread_wakeup.close()
+        self.thread_wakeup.close()
+
         # If .join() is not called on the created processes then
         # some ctx.Queue methods may deadlock on Mac OS X.
         for p in self.processes.values():
+            if broken:
+                p.terminate()
             p.join()
 
     def get_n_children_alive(self):
@@ -582,22 +629,29 @@ class BrokenProcessPool(_base.BrokenExecutor):
 
 class ProcessPoolExecutor(_base.Executor):
     def __init__(self, max_workers=None, mp_context=None,
-                 initializer=None, initargs=()):
+                 initializer=None, initargs=(), *, max_tasks_per_child=None):
         """Initializes a new ProcessPoolExecutor instance.
 
         Args:
             max_workers: The maximum number of processes that can be used to
                 execute the given calls. If None or not given then as many
                 worker processes will be created as the machine has processors.
-            mp_context: A multiprocessing context to launch the workers. This
+            mp_context: A multiprocessing context to launch the workers created
+                using the multiprocessing.get_context('start method') API. This
                 object should provide SimpleQueue, Queue and Process.
             initializer: A callable used to initialize worker processes.
             initargs: A tuple of arguments to pass to the initializer.
+            max_tasks_per_child: The maximum number of tasks a worker process
+                can complete before it will exit and be replaced with a fresh
+                worker process. The default of None means worker process will
+                live as long as the executor. Requires a non-'fork' mp_context
+                start method. When given, we default to using 'spawn' if no
+                mp_context is supplied.
         """
         _check_system_limits()
 
         if max_workers is None:
-            self._max_workers = os.cpu_count() or 1
+            self._max_workers = os.process_cpu_count() or 1
             if sys.platform == 'win32':
                 self._max_workers = min(_MAX_WINDOWS_WORKERS,
                                         self._max_workers)
@@ -612,7 +666,10 @@ def __init__(self, max_workers=None, mp_context=None,
             self._max_workers = max_workers
 
         if mp_context is None:
-            mp_context = mp.get_context()
+            if max_tasks_per_child is not None:
+                mp_context = mp.get_context("spawn")
+            else:
+                mp_context = mp.get_context()
         self._mp_context = mp_context
 
         # https://github.com/python/cpython/issues/90622
@@ -624,6 +681,18 @@ def __init__(self, max_workers=None, mp_context=None,
         self._initializer = initializer
         self._initargs = initargs
 
+        if max_tasks_per_child is not None:
+            if not isinstance(max_tasks_per_child, int):
+                raise TypeError("max_tasks_per_child must be an integer")
+            elif max_tasks_per_child <= 0:
+                raise ValueError("max_tasks_per_child must be >= 1")
+            if self._mp_context.get_start_method(allow_none=False) == "fork":
+                # https://github.com/python/cpython/issues/90622
+                raise ValueError("max_tasks_per_child is incompatible with"
+                                 " the 'fork' multiprocessing start method;"
+                                 " supply a different mp_context.")
+        self._max_tasks_per_child = max_tasks_per_child
+
         # Management thread
         self._executor_manager_thread = None
 
@@ -646,7 +715,9 @@ def __init__(self, max_workers=None, mp_context=None,
         # as it could result in a deadlock if a worker process dies with the
         # _result_queue write lock still acquired.
         #
-        # _shutdown_lock must be locked to access _ThreadWakeup.
+        # Care must be taken to only call clear and close from the
+        # executor_manager_thread, since _ThreadWakeup.clear() is not protected
+        # by a lock.
         self._executor_manager_thread_wakeup = _ThreadWakeup()
 
         # Create communication channels for the executor
@@ -657,7 +728,6 @@ def __init__(self, max_workers=None, mp_context=None,
         self._call_queue = _SafeQueue(
             max_size=queue_size, ctx=self._mp_context,
             pending_work_items=self._pending_work_items,
-            shutdown_lock=self._shutdown_lock,
             thread_wakeup=self._executor_manager_thread_wakeup)
         # Killed worker processes can produce spurious "broken pipe"
         # tracebacks in the queue's own worker thread. But we detect killed
@@ -677,6 +747,11 @@ def _start_executor_manager_thread(self):
                 self._executor_manager_thread_wakeup
 
     def _adjust_process_count(self):
+        # gh-132969: avoid error when state is reset and executor is still running,
+        # which will happen when shutdown(wait=False) is called.
+        if self._processes is None:
+            return
+
         # if there's an idle process, we don't need to spawn a new one.
         if self._idle_worker_semaphore.acquire(blocking=False):
             return
@@ -705,7 +780,8 @@ def _spawn_process(self):
             args=(self._call_queue,
                   self._result_queue,
                   self._initializer,
-                  self._initargs))
+                  self._initargs,
+                  self._max_tasks_per_child))
         p.start()
         self._processes[p.pid] = p
 
@@ -759,7 +835,7 @@ def map(self, fn, *iterables, timeout=None, chunksize=1):
             raise ValueError("chunksize must be >= 1.")
 
         results = super().map(partial(_process_chunk, fn),
-                              _get_chunks(*iterables, chunksize=chunksize),
+                              itertools.batched(zip(*iterables), chunksize),
                               timeout=timeout)
         return _chain_from_iterable_of_lists(results)
 
diff --git a/Lib/concurrent/futures/thread.py b/Lib/concurrent/futures/thread.py
index 493861d314..9021dde48e 100644
--- a/Lib/concurrent/futures/thread.py
+++ b/Lib/concurrent/futures/thread.py
@@ -37,14 +37,14 @@ def _python_exit():
 threading._register_atexit(_python_exit)
 
 # At fork, reinitialize the `_global_shutdown_lock` lock in the child process
-# TODO RUSTPYTHON - _at_fork_reinit is not implemented yet
-if hasattr(os, 'register_at_fork') and hasattr(_global_shutdown_lock, '_at_fork_reinit'):
+if hasattr(os, 'register_at_fork'):
     os.register_at_fork(before=_global_shutdown_lock.acquire,
                         after_in_child=_global_shutdown_lock._at_fork_reinit,
                         after_in_parent=_global_shutdown_lock.release)
+    os.register_at_fork(after_in_child=_threads_queues.clear)
 
 
-class _WorkItem(object):
+class _WorkItem:
     def __init__(self, future, fn, args, kwargs):
         self.future = future
         self.fn = fn
@@ -79,17 +79,20 @@ def _worker(executor_reference, work_queue, initializer, initargs):
             return
     try:
         while True:
-            work_item = work_queue.get(block=True)
-            if work_item is not None:
-                work_item.run()
-                # Delete references to object. See issue16284
-                del work_item
-
-                # attempt to increment idle count
+            try:
+                work_item = work_queue.get_nowait()
+            except queue.Empty:
+                # attempt to increment idle count if queue is empty
                 executor = executor_reference()
                 if executor is not None:
                     executor._idle_semaphore.release()
                 del executor
+                work_item = work_queue.get(block=True)
+
+            if work_item is not None:
+                work_item.run()
+                # Delete references to object. See GH-60488
+                del work_item
                 continue
 
             executor = executor_reference()
@@ -137,10 +140,10 @@ def __init__(self, max_workers=None, thread_name_prefix='',
             # * CPU bound task which releases GIL
             # * I/O bound task (which releases GIL, of course)
             #
-            # We use cpu_count + 4 for both types of tasks.
+            # We use process_cpu_count + 4 for both types of tasks.
             # But we limit it to 32 to avoid consuming surprisingly large resource
             # on many core machine.
-            max_workers = min(32, (os.cpu_count() or 1) + 4)
+            max_workers = min(32, (os.process_cpu_count() or 1) + 4)
         if max_workers <= 0:
             raise ValueError("max_workers must be greater than 0")
 
diff --git a/Lib/configparser.py b/Lib/configparser.py
index e8aae21794..05b86acb91 100644
--- a/Lib/configparser.py
+++ b/Lib/configparser.py
@@ -18,8 +18,8 @@
              delimiters=('=', ':'), comment_prefixes=('#', ';'),
              inline_comment_prefixes=None, strict=True,
              empty_lines_in_values=True, default_section='DEFAULT',
-             interpolation=<unset>, converters=<unset>):
-
+             interpolation=<unset>, converters=<unset>,
+             allow_unnamed_section=False):
         Create the parser. When `defaults` is given, it is initialized into the
         dictionary or intrinsic defaults. The keys must be strings, the values
         must be appropriate for %()s string interpolation.
@@ -68,6 +68,10 @@
         converter gets its corresponding get*() method on the parser object and
         section proxies.
 
+        When `allow_unnamed_section` is True (default: False), options
+        without section are accepted: the section for these is
+        ``configparser.UNNAMED_SECTION``.
+
     sections()
         Return all the configuration section names, sans DEFAULT.
 
@@ -139,24 +143,28 @@
         between keys and values are surrounded by spaces.
 """
 
-from collections.abc import MutableMapping
+# Do not import dataclasses; overhead is unacceptable (gh-117703)
+
+from collections.abc import Iterable, MutableMapping
 from collections import ChainMap as _ChainMap
+import contextlib
 import functools
 import io
 import itertools
 import os
 import re
 import sys
-import warnings
+import types
 
 __all__ = ("NoSectionError", "DuplicateOptionError", "DuplicateSectionError",
            "NoOptionError", "InterpolationError", "InterpolationDepthError",
            "InterpolationMissingOptionError", "InterpolationSyntaxError",
            "ParsingError", "MissingSectionHeaderError",
+           "MultilineContinuationError",
            "ConfigParser", "RawConfigParser",
            "Interpolation", "BasicInterpolation",  "ExtendedInterpolation",
-           "LegacyInterpolation", "SectionProxy", "ConverterMapping",
-           "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH")
+           "SectionProxy", "ConverterMapping",
+           "DEFAULTSECT", "MAX_INTERPOLATION_DEPTH", "UNNAMED_SECTION")
 
 _default_dict = dict
 DEFAULTSECT = "DEFAULT"
@@ -298,15 +306,33 @@ def __init__(self, option, section, rawval):
 class ParsingError(Error):
     """Raised when a configuration file does not follow legal syntax."""
 
-    def __init__(self, source):
+    def __init__(self, source, *args):
         super().__init__(f'Source contains parsing errors: {source!r}')
         self.source = source
         self.errors = []
         self.args = (source, )
+        if args:
+            self.append(*args)
 
     def append(self, lineno, line):
         self.errors.append((lineno, line))
-        self.message += '\n\t[line %2d]: %s' % (lineno, line)
+        self.message += '\n\t[line %2d]: %s' % (lineno, repr(line))
+
+    def combine(self, others):
+        for other in others:
+            for error in other.errors:
+                self.append(*error)
+        return self
+
+    @staticmethod
+    def _raise_all(exceptions: Iterable['ParsingError']):
+        """
+        Combine any number of ParsingErrors into one and raise it.
+        """
+        exceptions = iter(exceptions)
+        with contextlib.suppress(StopIteration):
+            raise next(exceptions).combine(exceptions)
+
 
 
 class MissingSectionHeaderError(ParsingError):
@@ -323,6 +349,28 @@ def __init__(self, filename, lineno, line):
         self.args = (filename, lineno, line)
 
 
+class MultilineContinuationError(ParsingError):
+    """Raised when a key without value is followed by continuation line"""
+    def __init__(self, filename, lineno, line):
+        Error.__init__(
+            self,
+            "Key without value continued with an indented line.\n"
+            "file: %r, line: %d\n%r"
+            %(filename, lineno, line))
+        self.source = filename
+        self.lineno = lineno
+        self.line = line
+        self.args = (filename, lineno, line)
+
+class _UnnamedSection:
+
+    def __repr__(self):
+        return "<UNNAMED_SECTION>"
+
+
+UNNAMED_SECTION = _UnnamedSection()
+
+
 # Used in parser getters to indicate the default behaviour when a specific
 # option is not found it to raise an exception. Created to enable `None` as
 # a valid fallback value.
@@ -478,6 +526,8 @@ def _interpolate_some(self, parser, option, accum, rest, section, map,
                 except (KeyError, NoSectionError, NoOptionError):
                     raise InterpolationMissingOptionError(
                         option, section, rawval, ":".join(path)) from None
+                if v is None:
+                    continue
                 if "$" in v:
                     self._interpolate_some(parser, opt, accum, v, sect,
                                            dict(parser.items(sect, raw=True)),
@@ -491,51 +541,50 @@ def _interpolate_some(self, parser, option, accum, rest, section, map,
                     "found: %r" % (rest,))
 
 
-class LegacyInterpolation(Interpolation):
-    """Deprecated interpolation used in old versions of ConfigParser.
-    Use BasicInterpolation or ExtendedInterpolation instead."""
+class _ReadState:
+    elements_added : set[str]
+    cursect : dict[str, str] | None = None
+    sectname : str | None = None
+    optname : str | None = None
+    lineno : int = 0
+    indent_level : int = 0
+    errors : list[ParsingError]
 
-    _KEYCRE = re.compile(r"%\(([^)]*)\)s|.")
+    def __init__(self):
+        self.elements_added = set()
+        self.errors = list()
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        warnings.warn(
-            "LegacyInterpolation has been deprecated since Python 3.2 "
-            "and will be removed from the configparser module in Python 3.13. "
-            "Use BasicInterpolation or ExtendedInterpolation instead.",
-            DeprecationWarning, stacklevel=2
-        )
 
-    def before_get(self, parser, section, option, value, vars):
-        rawval = value
-        depth = MAX_INTERPOLATION_DEPTH
-        while depth:                    # Loop through this until it's done
-            depth -= 1
-            if value and "%(" in value:
-                replace = functools.partial(self._interpolation_replace,
-                                            parser=parser)
-                value = self._KEYCRE.sub(replace, value)
-                try:
-                    value = value % vars
-                except KeyError as e:
-                    raise InterpolationMissingOptionError(
-                        option, section, rawval, e.args[0]) from None
-            else:
-                break
-        if value and "%(" in value:
-            raise InterpolationDepthError(option, section, rawval)
-        return value
+class _Line(str):
 
-    def before_set(self, parser, section, option, value):
-        return value
+    def __new__(cls, val, *args, **kwargs):
+        return super().__new__(cls, val)
 
-    @staticmethod
-    def _interpolation_replace(match, parser):
-        s = match.group(1)
-        if s is None:
-            return match.group()
-        else:
-            return "%%(%s)s" % parser.optionxform(s)
+    def __init__(self, val, prefixes):
+        self.prefixes = prefixes
+
+    @functools.cached_property
+    def clean(self):
+        return self._strip_full() and self._strip_inline()
+
+    @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 '(?!)'
+        )
+        match = matcher.search(self)
+        return self[:match.start() if match else None].strip()
+
+    def _strip_full(self):
+        return '' if any(map(self.strip().startswith, self.prefixes.full)) else True
 
 
 class RawConfigParser(MutableMapping):
@@ -584,7 +633,8 @@ def __init__(self, defaults=None, dict_type=_default_dict,
                  comment_prefixes=('#', ';'), inline_comment_prefixes=None,
                  strict=True, empty_lines_in_values=True,
                  default_section=DEFAULTSECT,
-                 interpolation=_UNSET, converters=_UNSET):
+                 interpolation=_UNSET, converters=_UNSET,
+                 allow_unnamed_section=False,):
 
         self._dict = dict_type
         self._sections = self._dict()
@@ -603,8 +653,10 @@ def __init__(self, defaults=None, dict_type=_default_dict,
             else:
                 self._optcre = re.compile(self._OPT_TMPL.format(delim=d),
                                           re.VERBOSE)
-        self._comment_prefixes = tuple(comment_prefixes or ())
-        self._inline_comment_prefixes = tuple(inline_comment_prefixes or ())
+        self._prefixes = types.SimpleNamespace(
+            full=tuple(comment_prefixes or ()),
+            inline=tuple(inline_comment_prefixes or ()),
+        )
         self._strict = strict
         self._allow_no_value = allow_no_value
         self._empty_lines_in_values = empty_lines_in_values
@@ -623,6 +675,7 @@ def __init__(self, defaults=None, dict_type=_default_dict,
             self._converters.update(converters)
         if defaults:
             self._read_defaults(defaults)
+        self._allow_unnamed_section = allow_unnamed_section
 
     def defaults(self):
         return self._defaults
@@ -896,13 +949,19 @@ 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:
+            self._write_section(fp, UNNAMED_SECTION, self._sections[UNNAMED_SECTION].items(), d, unnamed=True)
+
         for section in self._sections:
+            if section is UNNAMED_SECTION:
+                continue
             self._write_section(fp, section,
                                 self._sections[section].items(), d)
 
-    def _write_section(self, fp, section_name, section_items, delimiter):
-        """Write a single section to the specified `fp`."""
-        fp.write("[{}]\n".format(section_name))
+    def _write_section(self, fp, section_name, section_items, delimiter, unnamed=False):
+        """Write a single section to the specified `fp'."""
+        if not unnamed:
+            fp.write("[{}]\n".format(section_name))
         for key, value in section_items:
             value = self._interpolation.before_write(self, section_name, key,
                                                      value)
@@ -988,110 +1047,113 @@ 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.
         """
-        elements_added = set()
-        cursect = None                        # None, or a dictionary
-        sectname = None
-        optname = None
-        lineno = 0
-        indent_level = 0
-        e = None                              # None, or an exception
-        for lineno, line in enumerate(fp, start=1):
-            comment_start = sys.maxsize
-            # strip inline comments
-            inline_prefixes = {p: -1 for p in self._inline_comment_prefixes}
-            while comment_start == sys.maxsize and inline_prefixes:
-                next_prefixes = {}
-                for prefix, index in inline_prefixes.items():
-                    index = line.find(prefix, index+1)
-                    if index == -1:
-                        continue
-                    next_prefixes[prefix] = index
-                    if index == 0 or (index > 0 and line[index-1].isspace()):
-                        comment_start = min(comment_start, index)
-                inline_prefixes = next_prefixes
-            # strip full line comments
-            for prefix in self._comment_prefixes:
-                if line.strip().startswith(prefix):
-                    comment_start = 0
-                    break
-            if comment_start == sys.maxsize:
-                comment_start = None
-            value = line[:comment_start].strip()
-            if not value:
+
+        try:
+            ParsingError._raise_all(self._read_inner(fp, fpname))
+        finally:
+            self._join_multiline_values()
+
+    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):
+            if not line.clean:
                 if self._empty_lines_in_values:
                     # add empty line to the value, but only if there was no
                     # comment on the line
-                    if (comment_start is None and
-                        cursect is not None and
-                        optname and
-                        cursect[optname] is not None):
-                        cursect[optname].append('') # newlines added at join
+                    if (not line.has_comments and
+                        st.cursect is not None and
+                        st.optname and
+                        st.cursect[st.optname] is not None):
+                        st.cursect[st.optname].append('') # newlines added at join
                 else:
                     # empty line marks end of value
-                    indent_level = sys.maxsize
+                    st.indent_level = sys.maxsize
                 continue
-            # continuation line?
+
             first_nonspace = self.NONSPACECRE.search(line)
-            cur_indent_level = first_nonspace.start() if first_nonspace else 0
-            if (cursect is not None and optname and
-                cur_indent_level > indent_level):
-                cursect[optname].append(value)
-            # a section header or option header?
-            else:
-                indent_level = cur_indent_level
-                # is it a section header?
-                mo = self.SECTCRE.match(value)
-                if mo:
-                    sectname = mo.group('header')
-                    if sectname in self._sections:
-                        if self._strict and sectname in elements_added:
-                            raise DuplicateSectionError(sectname, fpname,
-                                                        lineno)
-                        cursect = self._sections[sectname]
-                        elements_added.add(sectname)
-                    elif sectname == self.default_section:
-                        cursect = self._defaults
-                    else:
-                        cursect = self._dict()
-                        self._sections[sectname] = cursect
-                        self._proxies[sectname] = SectionProxy(self, sectname)
-                        elements_added.add(sectname)
-                    # So sections can't start with a continuation line
-                    optname = None
-                # no section header in the file?
-                elif cursect is None:
-                    raise MissingSectionHeaderError(fpname, lineno, line)
-                # an option line?
-                else:
-                    mo = self._optcre.match(value)
-                    if mo:
-                        optname, vi, optval = mo.group('option', 'vi', 'value')
-                        if not optname:
-                            e = self._handle_error(e, fpname, lineno, line)
-                        optname = self.optionxform(optname.rstrip())
-                        if (self._strict and
-                            (sectname, optname) in elements_added):
-                            raise DuplicateOptionError(sectname, optname,
-                                                       fpname, lineno)
-                        elements_added.add((sectname, optname))
-                        # This check is fine because the OPTCRE cannot
-                        # match if it would set optval to None
-                        if optval is not None:
-                            optval = optval.strip()
-                            cursect[optname] = [optval]
-                        else:
-                            # valueless option handling
-                            cursect[optname] = None
-                    else:
-                        # a non-fatal parsing error occurred. set up the
-                        # exception but keep going. the exception will be
-                        # raised at the end of the file and will contain a
-                        # list of all bogus lines
-                        e = self._handle_error(e, fpname, lineno, line)
-        self._join_multiline_values()
-        # if any parsing errors occurred, raise an exception
-        if e:
-            raise e
+            st.cur_indent_level = first_nonspace.start() if first_nonspace else 0
+
+            if self._handle_continuation_line(st, line, fpname):
+                continue
+
+            self._handle_rest(st, line, fpname)
+
+        return st.errors
+
+    def _handle_continuation_line(self, st, line, fpname):
+        # continuation line?
+        is_continue = (st.cursect is not None and st.optname and
+            st.cur_indent_level > st.indent_level)
+        if is_continue:
+            if st.cursect[st.optname] is None:
+                raise MultilineContinuationError(fpname, st.lineno, line)
+            st.cursect[st.optname].append(line.clean)
+        return is_continue
+
+    def _handle_rest(self, st, line, fpname):
+        # a section header or option header?
+        if self._allow_unnamed_section and st.cursect is None:
+            self._handle_header(st, UNNAMED_SECTION, fpname)
+
+        st.indent_level = st.cur_indent_level
+        # is it a section header?
+        mo = self.SECTCRE.match(line.clean)
+
+        if not mo and st.cursect is None:
+            raise MissingSectionHeaderError(fpname, st.lineno, line)
+
+        self._handle_header(st, mo.group('header'), fpname) if mo else self._handle_option(st, line, fpname)
+
+    def _handle_header(self, st, sectname, fpname):
+        st.sectname = sectname
+        if st.sectname in self._sections:
+            if self._strict and st.sectname in st.elements_added:
+                raise DuplicateSectionError(st.sectname, fpname,
+                                            st.lineno)
+            st.cursect = self._sections[st.sectname]
+            st.elements_added.add(st.sectname)
+        elif st.sectname == self.default_section:
+            st.cursect = self._defaults
+        else:
+            st.cursect = self._dict()
+            self._sections[st.sectname] = st.cursect
+            self._proxies[st.sectname] = SectionProxy(self, st.sectname)
+            st.elements_added.add(st.sectname)
+        # So sections can't start with a continuation line
+        st.optname = None
+
+    def _handle_option(self, st, line, fpname):
+        # an option line?
+        st.indent_level = st.cur_indent_level
+
+        mo = self._optcre.match(line.clean)
+        if not mo:
+            # a non-fatal parsing error occurred. set up the
+            # exception but keep going. the exception will be
+            # raised at the end of the file and will contain a
+            # list of all bogus lines
+            st.errors.append(ParsingError(fpname, st.lineno, line))
+            return
+
+        st.optname, vi, optval = mo.group('option', 'vi', 'value')
+        if not st.optname:
+            st.errors.append(ParsingError(fpname, st.lineno, line))
+        st.optname = self.optionxform(st.optname.rstrip())
+        if (self._strict and
+            (st.sectname, st.optname) in st.elements_added):
+            raise DuplicateOptionError(st.sectname, st.optname,
+                                    fpname, st.lineno)
+        st.elements_added.add((st.sectname, st.optname))
+        # This check is fine because the OPTCRE cannot
+        # match if it would set optval to None
+        if optval is not None:
+            optval = optval.strip()
+            st.cursect[st.optname] = [optval]
+        else:
+            # valueless option handling
+            st.cursect[st.optname] = None
 
     def _join_multiline_values(self):
         defaults = self.default_section, self._defaults
@@ -1111,12 +1173,6 @@ def _read_defaults(self, defaults):
         for key, value in defaults.items():
             self._defaults[self.optionxform(key)] = value
 
-    def _handle_error(self, exc, fpname, lineno, line):
-        if not exc:
-            exc = ParsingError(fpname)
-        exc.append(lineno, repr(line))
-        return exc
-
     def _unify_values(self, section, vars):
         """Create a sequence of lookups with 'vars' taking priority over
         the 'section' which takes priority over the DEFAULTSECT.
diff --git a/Lib/contextlib.py b/Lib/contextlib.py
index b831d8916c..5b646fabca 100644
--- a/Lib/contextlib.py
+++ b/Lib/contextlib.py
@@ -20,6 +20,8 @@ class AbstractContextManager(abc.ABC):
 
     __class_getitem__ = classmethod(GenericAlias)
 
+    __slots__ = ()
+
     def __enter__(self):
         """Return `self` upon entering the runtime context."""
         return self
@@ -42,6 +44,8 @@ class AbstractAsyncContextManager(abc.ABC):
 
     __class_getitem__ = classmethod(GenericAlias)
 
+    __slots__ = ()
+
     async def __aenter__(self):
         """Return `self` upon entering the runtime context."""
         return self
@@ -565,11 +569,12 @@ def __enter__(self):
         return self
 
     def __exit__(self, *exc_details):
-        received_exc = exc_details[0] is not None
+        exc = exc_details[1]
+        received_exc = exc is not None
 
         # We manipulate the exception state so it behaves as though
         # we were actually nesting multiple with statements
-        frame_exc = sys.exc_info()[1]
+        frame_exc = sys.exception()
         def _fix_exception_context(new_exc, old_exc):
             # Context may not be correct, so find the end of the chain
             while 1:
@@ -592,24 +597,28 @@ def _fix_exception_context(new_exc, old_exc):
             is_sync, cb = self._exit_callbacks.pop()
             assert is_sync
             try:
+                if exc is None:
+                    exc_details = None, None, None
+                else:
+                    exc_details = type(exc), exc, exc.__traceback__
                 if cb(*exc_details):
                     suppressed_exc = True
                     pending_raise = False
-                    exc_details = (None, None, None)
-            except:
-                new_exc_details = sys.exc_info()
+                    exc = None
+            except BaseException as new_exc:
                 # simulate the stack of exceptions by setting the context
-                _fix_exception_context(new_exc_details[1], exc_details[1])
+                _fix_exception_context(new_exc, exc)
                 pending_raise = True
-                exc_details = new_exc_details
+                exc = new_exc
+
         if pending_raise:
             try:
-                # bare "raise exc_details[1]" replaces our carefully
+                # bare "raise exc" replaces our carefully
                 # set-up context
-                fixed_ctx = exc_details[1].__context__
-                raise exc_details[1]
+                fixed_ctx = exc.__context__
+                raise exc
             except BaseException:
-                exc_details[1].__context__ = fixed_ctx
+                exc.__context__ = fixed_ctx
                 raise
         return received_exc and suppressed_exc
 
@@ -705,11 +714,12 @@ async def __aenter__(self):
         return self
 
     async def __aexit__(self, *exc_details):
-        received_exc = exc_details[0] is not None
+        exc = exc_details[1]
+        received_exc = exc is not None
 
         # We manipulate the exception state so it behaves as though
         # we were actually nesting multiple with statements
-        frame_exc = sys.exc_info()[1]
+        frame_exc = sys.exception()
         def _fix_exception_context(new_exc, old_exc):
             # Context may not be correct, so find the end of the chain
             while 1:
@@ -731,6 +741,10 @@ def _fix_exception_context(new_exc, old_exc):
         while self._exit_callbacks:
             is_sync, cb = self._exit_callbacks.pop()
             try:
+                if exc is None:
+                    exc_details = None, None, None
+                else:
+                    exc_details = type(exc), exc, exc.__traceback__
                 if is_sync:
                     cb_suppress = cb(*exc_details)
                 else:
@@ -739,21 +753,21 @@ def _fix_exception_context(new_exc, old_exc):
                 if cb_suppress:
                     suppressed_exc = True
                     pending_raise = False
-                    exc_details = (None, None, None)
-            except:
-                new_exc_details = sys.exc_info()
+                    exc = None
+            except BaseException as new_exc:
                 # simulate the stack of exceptions by setting the context
-                _fix_exception_context(new_exc_details[1], exc_details[1])
+                _fix_exception_context(new_exc, exc)
                 pending_raise = True
-                exc_details = new_exc_details
+                exc = new_exc
+
         if pending_raise:
             try:
-                # bare "raise exc_details[1]" replaces our carefully
+                # bare "raise exc" replaces our carefully
                 # set-up context
-                fixed_ctx = exc_details[1].__context__
-                raise exc_details[1]
+                fixed_ctx = exc.__context__
+                raise exc
             except BaseException:
-                exc_details[1].__context__ = fixed_ctx
+                exc.__context__ = fixed_ctx
                 raise
         return received_exc and suppressed_exc
 
diff --git a/Lib/csv.py b/Lib/csv.py
index 77f30c8d2b..cd20265987 100644
--- a/Lib/csv.py
+++ b/Lib/csv.py
@@ -1,28 +1,90 @@
 
-"""
-csv.py - read/write/investigate CSV files
+r"""
+CSV parsing and writing.
+
+This module provides classes that assist in the reading and writing
+of Comma Separated Value (CSV) files, and implements the interface
+described by PEP 305.  Although many CSV files are simple to parse,
+the format is not formally defined by a stable specification and
+is subtle enough that parsing lines of a CSV file with something
+like line.split(",") is bound to fail.  The module supports three
+basic APIs: reading, writing, and registration of dialects.
+
+
+DIALECT REGISTRATION:
+
+Readers and writers support a dialect argument, which is a convenient
+handle on a group of settings.  When the dialect argument is a string,
+it identifies one of the dialects previously registered with the module.
+If it is a class or instance, the attributes of the argument are used as
+the settings for the reader or writer:
+
+    class excel:
+        delimiter = ','
+        quotechar = '"'
+        escapechar = None
+        doublequote = True
+        skipinitialspace = False
+        lineterminator = '\r\n'
+        quoting = QUOTE_MINIMAL
+
+SETTINGS:
+
+    * quotechar - specifies a one-character string to use as the
+        quoting character.  It defaults to '"'.
+    * delimiter - specifies a one-character string to use as the
+        field separator.  It defaults to ','.
+    * skipinitialspace - specifies how to interpret spaces which
+        immediately follow a delimiter.  It defaults to False, which
+        means that spaces immediately following a delimiter is part
+        of the following field.
+    * lineterminator - specifies the character sequence which should
+        terminate rows.
+    * quoting - controls when quotes should be generated by the writer.
+        It can take on any of the following module constants:
+
+        csv.QUOTE_MINIMAL means only when required, for example, when a
+            field contains either the quotechar or the delimiter
+        csv.QUOTE_ALL means that quotes are always placed around fields.
+        csv.QUOTE_NONNUMERIC means that quotes are always placed around
+            fields which do not parse as integers or floating-point
+            numbers.
+        csv.QUOTE_STRINGS means that quotes are always placed around
+            fields which are strings.  Note that the Python value None
+            is not a string.
+        csv.QUOTE_NOTNULL means that quotes are only placed around fields
+            that are not the Python value None.
+        csv.QUOTE_NONE means that quotes are never placed around fields.
+    * escapechar - specifies a one-character string used to escape
+        the delimiter when quoting is set to QUOTE_NONE.
+    * doublequote - controls the handling of quotes inside fields.  When
+        True, two consecutive quotes are interpreted as one during read,
+        and when writing, each quote character embedded in the data is
+        written as two quotes
 """
 
 import re
 import types
-from _csv import Error, __version__, writer, reader, register_dialect, \
+from _csv import Error, writer, reader, register_dialect, \
                  unregister_dialect, get_dialect, list_dialects, \
                  field_size_limit, \
                  QUOTE_MINIMAL, QUOTE_ALL, QUOTE_NONNUMERIC, QUOTE_NONE, \
-                 QUOTE_STRINGS, QUOTE_NOTNULL, \
-                 __doc__
+                 QUOTE_STRINGS, QUOTE_NOTNULL
 from _csv import Dialect as _Dialect
 
 from io import StringIO
 
 __all__ = ["QUOTE_MINIMAL", "QUOTE_ALL", "QUOTE_NONNUMERIC", "QUOTE_NONE",
            "QUOTE_STRINGS", "QUOTE_NOTNULL",
-           "Error", "Dialect", "__doc__", "excel", "excel_tab",
+           "Error", "Dialect", "excel", "excel_tab",
            "field_size_limit", "reader", "writer",
            "register_dialect", "get_dialect", "list_dialects", "Sniffer",
-           "unregister_dialect", "__version__", "DictReader", "DictWriter",
+           "unregister_dialect", "DictReader", "DictWriter",
            "unix_dialect"]
 
+__version__ = "1.0"
+
+
 class Dialect:
     """Describe a CSV dialect.
 
@@ -51,8 +113,8 @@ def _validate(self):
         try:
             _Dialect(self)
         except TypeError as e:
-            # We do this for compatibility with py2.3
-            raise Error(str(e))
+            # Re-raise to get a traceback showing more user code.
+            raise Error(str(e)) from None
 
 class excel(Dialect):
     """Describe the usual properties of Excel-generated CSV files."""
diff --git a/Lib/ctypes/__init__.py b/Lib/ctypes/__init__.py
index b8b005061f..80651dc64c 100644
--- a/Lib/ctypes/__init__.py
+++ b/Lib/ctypes/__init__.py
@@ -1,6 +1,8 @@
 """create and manipulate C data types in Python"""
 
-import os as _os, sys as _sys
+import os as _os
+import sys as _sys
+import sysconfig as _sysconfig
 import types as _types
 
 __version__ = "1.1.0"
@@ -36,9 +38,6 @@
      FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO, \
      FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR
 
-# TODO: RUSTPYTHON remove this
-from _ctypes import _non_existing_function
-
 # WINOLEAPI -> HRESULT
 # WINOLEAPI_(type)
 #
@@ -110,7 +109,7 @@ class CFunctionType(_CFuncPtr):
     return CFunctionType
 
 if _os.name == "nt":
-    from _ctypes import LoadLibrary as _dlopen
+    from _ctypes import LoadLibrary as _LoadLibrary
     from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
 
     _win_functype_cache = {}
@@ -299,16 +298,15 @@ def create_unicode_buffer(init, size=None):
         return buf
     elif isinstance(init, int):
         _sys.audit("ctypes.create_unicode_buffer", None, init)
-        # XXX: RUSTPYTHON
-        # buftype = c_wchar * init
-        buftype = c_wchar.__mul__(init)
+        buftype = c_wchar * init
         buf = buftype()
         return buf
     raise TypeError(init)
 
 
-# XXX Deprecated
 def SetPointerType(pointer, cls):
+    import warnings
+    warnings._deprecated("ctypes.SetPointerType", remove=(3, 15))
     if _pointer_type_cache.get(cls, None) is not None:
         raise RuntimeError("This type already exists in the cache")
     if id(pointer) not in _pointer_type_cache:
@@ -317,7 +315,6 @@ def SetPointerType(pointer, cls):
     _pointer_type_cache[cls] = pointer
     del _pointer_type_cache[id(pointer)]
 
-# XXX Deprecated
 def ARRAY(typ, len):
     return typ * len
 
@@ -349,39 +346,59 @@ def __init__(self, name, mode=DEFAULT_MODE, handle=None,
                  use_errno=False,
                  use_last_error=False,
                  winmode=None):
-        self._name = name
-        flags = self._func_flags_
-        if use_errno:
-            flags |= _FUNCFLAG_USE_ERRNO
-        if use_last_error:
-            flags |= _FUNCFLAG_USE_LASTERROR
-        if _sys.platform.startswith("aix"):
-            """When the name contains ".a(" and ends with ")",
-               e.g., "libFOO.a(libFOO.so)" - this is taken to be an
-               archive(member) syntax for dlopen(), and the mode is adjusted.
-               Otherwise, name is presented to dlopen() as a file argument.
-            """
-            if name and name.endswith(")") and ".a(" in name:
-                mode |= ( _os.RTLD_MEMBER | _os.RTLD_NOW )
-        if _os.name == "nt":
-            if winmode is not None:
-                mode = winmode
-            else:
-                import nt
-                mode = nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
-                if '/' in name or '\\' in name:
-                    self._name = nt._getfullpathname(self._name)
-                    mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
-
         class _FuncPtr(_CFuncPtr):
-            _flags_ = flags
+            _flags_ = self._func_flags_
             _restype_ = self._func_restype_
+            if use_errno:
+                _flags_ |= _FUNCFLAG_USE_ERRNO
+            if use_last_error:
+                _flags_ |= _FUNCFLAG_USE_LASTERROR
+
         self._FuncPtr = _FuncPtr
+        if name:
+            name = _os.fspath(name)
 
-        if handle is None:
-            self._handle = _dlopen(self._name, mode)
-        else:
-            self._handle = handle
+        self._handle = self._load_library(name, mode, handle, winmode)
+
+    if _os.name == "nt":
+        def _load_library(self, name, mode, handle, winmode):
+            if winmode is None:
+                import nt as _nt
+                winmode = _nt._LOAD_LIBRARY_SEARCH_DEFAULT_DIRS
+                # WINAPI LoadLibrary searches for a DLL if the given name
+                # is not fully qualified with an explicit drive. For POSIX
+                # compatibility, and because the DLL search path no longer
+                # contains the working directory, begin by fully resolving
+                # any name that contains a path separator.
+                if name is not None and ('/' in name or '\\' in name):
+                    name = _nt._getfullpathname(name)
+                    winmode |= _nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
+            self._name = name
+            if handle is not None:
+                return handle
+            return _LoadLibrary(self._name, winmode)
+
+    else:
+        def _load_library(self, name, mode, handle, winmode):
+            # If the filename that has been provided is an iOS/tvOS/watchOS
+            # .fwork file, dereference the location to the true origin of the
+            # binary.
+            if name and name.endswith(".fwork"):
+                with open(name) as f:
+                    name = _os.path.join(
+                        _os.path.dirname(_sys.executable),
+                        f.read().strip()
+                    )
+            if _sys.platform.startswith("aix"):
+                """When the name contains ".a(" and ends with ")",
+                   e.g., "libFOO.a(libFOO.so)" - this is taken to be an
+                   archive(member) syntax for dlopen(), and the mode is adjusted.
+                   Otherwise, name is presented to dlopen() as a file argument.
+                """
+                if name and name.endswith(")") and ".a(" in name:
+                    mode |= _os.RTLD_MEMBER | _os.RTLD_NOW
+            self._name = name
+            return _dlopen(name, mode)
 
     def __repr__(self):
         return "<%s '%s', handle %x at %#x>" % \
@@ -469,8 +486,9 @@ def LoadLibrary(self, name):
 
 if _os.name == "nt":
     pythonapi = PyDLL("python dll", None, _sys.dllhandle)
-elif _sys.platform == "cygwin":
-    pythonapi = PyDLL("libpython%d.%d.dll" % _sys.version_info[:2])
+elif _sys.platform in ["android", "cygwin"]:
+    # These are Unix-like platforms which use a dynamically-linked libpython.
+    pythonapi = PyDLL(_sysconfig.get_config_var("LDLIBRARY"))
 else:
     pythonapi = PyDLL(None)
 
@@ -500,15 +518,14 @@ def WinError(code=None, descr=None):
     c_ssize_t = c_longlong
 
 # functions
+
 from _ctypes import _memmove_addr, _memset_addr, _string_at_addr, _cast_addr
 
 ## void *memmove(void *, const void *, size_t);
-# XXX: RUSTPYTHON
-# memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
+memmove = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_size_t)(_memmove_addr)
 
 ## void *memset(void *, int, size_t)
-# XXX: RUSTPYTHON
-# memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
+memset = CFUNCTYPE(c_void_p, c_void_p, c_int, c_size_t)(_memset_addr)
 
 def PYFUNCTYPE(restype, *argtypes):
     class CFunctionType(_CFuncPtr):
@@ -517,17 +534,15 @@ class CFunctionType(_CFuncPtr):
         _flags_ = _FUNCFLAG_CDECL | _FUNCFLAG_PYTHONAPI
     return CFunctionType
 
-# XXX: RUSTPYTHON
-# _cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
+_cast = PYFUNCTYPE(py_object, c_void_p, py_object, py_object)(_cast_addr)
 def cast(obj, typ):
     return _cast(obj, obj, typ)
 
-# XXX: RUSTPYTHON
-# _string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
+_string_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_string_at_addr)
 def string_at(ptr, size=-1):
-    """string_at(addr[, size]) -> string
+    """string_at(ptr[, size]) -> string
 
-    Return the string at addr."""
+    Return the byte string at void *ptr."""
     return _string_at(ptr, size)
 
 try:
@@ -535,12 +550,11 @@ def string_at(ptr, size=-1):
 except ImportError:
     pass
 else:
-    # XXX: RUSTPYTHON
-    # _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
+    _wstring_at = PYFUNCTYPE(py_object, c_void_p, c_int)(_wstring_at_addr)
     def wstring_at(ptr, size=-1):
-        """wstring_at(addr[, size]) -> string
+        """wstring_at(ptr[, size]) -> string
 
-        Return the string at addr."""
+        Return the wide-character string at void *ptr."""
         return _wstring_at(ptr, size)
 
 
diff --git a/Lib/ctypes/_endian.py b/Lib/ctypes/_endian.py
index 34dee64b1a..6382dd22b8 100644
--- a/Lib/ctypes/_endian.py
+++ b/Lib/ctypes/_endian.py
@@ -1,5 +1,5 @@
 import sys
-from ctypes import *
+from ctypes import Array, Structure, Union
 
 _array_type = type(Array)
 
@@ -15,8 +15,8 @@ def _other_endian(typ):
     # if typ is array
     if isinstance(typ, _array_type):
         return _other_endian(typ._type_) * typ._length_
-    # if typ is structure
-    if issubclass(typ, Structure):
+    # if typ is structure or union
+    if issubclass(typ, (Structure, Union)):
         return typ
     raise TypeError("This type does not support other endian: %s" % typ)
 
@@ -37,7 +37,7 @@ class _swapped_union_meta(_swapped_meta, type(Union)): pass
 ################################################################
 
 # Note: The Structure metaclass checks for the *presence* (not the
-# value!) of a _swapped_bytes_ attribute to determine the bit order in
+# value!) of a _swappedbytes_ attribute to determine the bit order in
 # structures containing bit fields.
 
 if sys.byteorder == "little":
diff --git a/Lib/ctypes/test/__init__.py b/Lib/ctypes/test/__init__.py
deleted file mode 100644
index 6e496fa5a5..0000000000
--- a/Lib/ctypes/test/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import os
-import unittest
-from test import support
-from test.support import import_helper
-
-
-# skip tests if _ctypes was not built
-ctypes = import_helper.import_module('ctypes')
-ctypes_symbols = dir(ctypes)
-
-def need_symbol(name):
-    return unittest.skipUnless(name in ctypes_symbols,
-                               '{!r} is required'.format(name))
-
-def load_tests(*args):
-    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/ctypes/test/__main__.py b/Lib/ctypes/test/__main__.py
deleted file mode 100644
index 362a9ec8cf..0000000000
--- a/Lib/ctypes/test/__main__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from ctypes.test import load_tests
-import unittest
-
-unittest.main()
diff --git a/Lib/ctypes/test/test_checkretval.py b/Lib/ctypes/test/test_checkretval.py
deleted file mode 100644
index e9567dc391..0000000000
--- a/Lib/ctypes/test/test_checkretval.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import unittest
-
-from ctypes import *
-from ctypes.test import need_symbol
-
-class CHECKED(c_int):
-    def _check_retval_(value):
-        # Receives a CHECKED instance.
-        return str(value.value)
-    _check_retval_ = staticmethod(_check_retval_)
-
-class Test(unittest.TestCase):
-
-    def test_checkretval(self):
-
-        import _ctypes_test
-        dll = CDLL(_ctypes_test.__file__)
-        self.assertEqual(42, dll._testfunc_p_p(42))
-
-        dll._testfunc_p_p.restype = CHECKED
-        self.assertEqual("42", dll._testfunc_p_p(42))
-
-        dll._testfunc_p_p.restype = None
-        self.assertEqual(None, dll._testfunc_p_p(42))
-
-        del dll._testfunc_p_p.restype
-        self.assertEqual(42, dll._testfunc_p_p(42))
-
-    @need_symbol('oledll')
-    def test_oledll(self):
-        self.assertRaises(OSError,
-                              oledll.oleaut32.CreateTypeLib2,
-                              0, None, None)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_delattr.py b/Lib/ctypes/test/test_delattr.py
deleted file mode 100644
index 0f4d58691b..0000000000
--- a/Lib/ctypes/test/test_delattr.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import unittest
-from ctypes import *
-
-class X(Structure):
-    _fields_ = [("foo", c_int)]
-
-class TestCase(unittest.TestCase):
-    def test_simple(self):
-        self.assertRaises(TypeError,
-                          delattr, c_int(42), "value")
-
-    def test_chararray(self):
-        self.assertRaises(TypeError,
-                          delattr, (c_char * 5)(), "value")
-
-    def test_struct(self):
-        self.assertRaises(TypeError,
-                          delattr, X(), "foo")
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_errno.py b/Lib/ctypes/test/test_errno.py
deleted file mode 100644
index 3685164dde..0000000000
--- a/Lib/ctypes/test/test_errno.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import unittest, os, errno
-import threading
-
-from ctypes import *
-from ctypes.util import find_library
-
-class Test(unittest.TestCase):
-    def test_open(self):
-        libc_name = find_library("c")
-        if libc_name is None:
-            raise unittest.SkipTest("Unable to find C library")
-        libc = CDLL(libc_name, use_errno=True)
-        if os.name == "nt":
-            libc_open = libc._open
-        else:
-            libc_open = libc.open
-
-        libc_open.argtypes = c_char_p, c_int
-
-        self.assertEqual(libc_open(b"", 0), -1)
-        self.assertEqual(get_errno(), errno.ENOENT)
-
-        self.assertEqual(set_errno(32), errno.ENOENT)
-        self.assertEqual(get_errno(), 32)
-
-        def _worker():
-            set_errno(0)
-
-            libc = CDLL(libc_name, use_errno=False)
-            if os.name == "nt":
-                libc_open = libc._open
-            else:
-                libc_open = libc.open
-            libc_open.argtypes = c_char_p, c_int
-            self.assertEqual(libc_open(b"", 0), -1)
-            self.assertEqual(get_errno(), 0)
-
-        t = threading.Thread(target=_worker)
-        t.start()
-        t.join()
-
-        self.assertEqual(get_errno(), 32)
-        set_errno(0)
-
-    @unittest.skipUnless(os.name == "nt", 'Test specific to Windows')
-    def test_GetLastError(self):
-        dll = WinDLL("kernel32", use_last_error=True)
-        GetModuleHandle = dll.GetModuleHandleA
-        GetModuleHandle.argtypes = [c_wchar_p]
-
-        self.assertEqual(0, GetModuleHandle("foo"))
-        self.assertEqual(get_last_error(), 126)
-
-        self.assertEqual(set_last_error(32), 126)
-        self.assertEqual(get_last_error(), 32)
-
-        def _worker():
-            set_last_error(0)
-
-            dll = WinDLL("kernel32", use_last_error=False)
-            GetModuleHandle = dll.GetModuleHandleW
-            GetModuleHandle.argtypes = [c_wchar_p]
-            GetModuleHandle("bar")
-
-            self.assertEqual(get_last_error(), 0)
-
-        t = threading.Thread(target=_worker)
-        t.start()
-        t.join()
-
-        self.assertEqual(get_last_error(), 32)
-
-        set_last_error(0)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_funcptr.py b/Lib/ctypes/test/test_funcptr.py
deleted file mode 100644
index e0b9b54e97..0000000000
--- a/Lib/ctypes/test/test_funcptr.py
+++ /dev/null
@@ -1,132 +0,0 @@
-import unittest
-from ctypes import *
-
-try:
-    WINFUNCTYPE
-except NameError:
-    # fake to enable this test on Linux
-    WINFUNCTYPE = CFUNCTYPE
-
-import _ctypes_test
-lib = CDLL(_ctypes_test.__file__)
-
-class CFuncPtrTestCase(unittest.TestCase):
-    def test_basic(self):
-        X = WINFUNCTYPE(c_int, c_int, c_int)
-
-        def func(*args):
-            return len(args)
-
-        x = X(func)
-        self.assertEqual(x.restype, c_int)
-        self.assertEqual(x.argtypes, (c_int, c_int))
-        self.assertEqual(sizeof(x), sizeof(c_voidp))
-        self.assertEqual(sizeof(X), sizeof(c_voidp))
-
-    def test_first(self):
-        StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
-        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
-
-        def func(a, b):
-            return a + b
-
-        s = StdCallback(func)
-        c = CdeclCallback(func)
-
-        self.assertEqual(s(1, 2), 3)
-        self.assertEqual(c(1, 2), 3)
-        # The following no longer raises a TypeError - it is now
-        # possible, as in C, to call cdecl functions with more parameters.
-        #self.assertRaises(TypeError, c, 1, 2, 3)
-        self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
-        if not WINFUNCTYPE is CFUNCTYPE:
-            self.assertRaises(TypeError, s, 1, 2, 3)
-
-    def test_structures(self):
-        WNDPROC = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
-
-        def wndproc(hwnd, msg, wParam, lParam):
-            return hwnd + msg + wParam + lParam
-
-        HINSTANCE = c_int
-        HICON = c_int
-        HCURSOR = c_int
-        LPCTSTR = c_char_p
-
-        class WNDCLASS(Structure):
-            _fields_ = [("style", c_uint),
-                        ("lpfnWndProc", WNDPROC),
-                        ("cbClsExtra", c_int),
-                        ("cbWndExtra", c_int),
-                        ("hInstance", HINSTANCE),
-                        ("hIcon", HICON),
-                        ("hCursor", HCURSOR),
-                        ("lpszMenuName", LPCTSTR),
-                        ("lpszClassName", LPCTSTR)]
-
-        wndclass = WNDCLASS()
-        wndclass.lpfnWndProc = WNDPROC(wndproc)
-
-        WNDPROC_2 = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
-
-        # This is no longer true, now that WINFUNCTYPE caches created types internally.
-        ## # CFuncPtr subclasses are compared by identity, so this raises a TypeError:
-        ## self.assertRaises(TypeError, setattr, wndclass,
-        ##                  "lpfnWndProc", WNDPROC_2(wndproc))
-        # instead:
-
-        self.assertIs(WNDPROC, WNDPROC_2)
-        # 'wndclass.lpfnWndProc' leaks 94 references.  Why?
-        self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
-
-
-        f = wndclass.lpfnWndProc
-
-        del wndclass
-        del wndproc
-
-        self.assertEqual(f(10, 11, 12, 13), 46)
-
-    def test_dllfunctions(self):
-
-        def NoNullHandle(value):
-            if not value:
-                raise WinError()
-            return value
-
-        strchr = lib.my_strchr
-        strchr.restype = c_char_p
-        strchr.argtypes = (c_char_p, c_char)
-        self.assertEqual(strchr(b"abcdefghi", b"b"), b"bcdefghi")
-        self.assertEqual(strchr(b"abcdefghi", b"x"), None)
-
-
-        strtok = lib.my_strtok
-        strtok.restype = c_char_p
-        # Neither of this does work: strtok changes the buffer it is passed
-##        strtok.argtypes = (c_char_p, c_char_p)
-##        strtok.argtypes = (c_string, c_char_p)
-
-        def c_string(init):
-            size = len(init) + 1
-            return (c_char*size)(*init)
-
-        s = b"a\nb\nc"
-        b = c_string(s)
-
-##        b = (c_char * (len(s)+1))()
-##        b.value = s
-
-##        b = c_string(s)
-        self.assertEqual(strtok(b, b"\n"), b"a")
-        self.assertEqual(strtok(None, b"\n"), b"b")
-        self.assertEqual(strtok(None, b"\n"), b"c")
-        self.assertEqual(strtok(None, b"\n"), None)
-
-    def test_abstract(self):
-        from ctypes import _CFuncPtr
-
-        self.assertRaises(TypeError, _CFuncPtr, 13, "name", 42, "iid")
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_incomplete.py b/Lib/ctypes/test/test_incomplete.py
deleted file mode 100644
index 00c430ef53..0000000000
--- a/Lib/ctypes/test/test_incomplete.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import unittest
-from ctypes import *
-
-################################################################
-#
-# The incomplete pointer example from the tutorial
-#
-
-class MyTestCase(unittest.TestCase):
-
-    def test_incomplete_example(self):
-        lpcell = POINTER("cell")
-        class cell(Structure):
-            _fields_ = [("name", c_char_p),
-                        ("next", lpcell)]
-
-        SetPointerType(lpcell, cell)
-
-        c1 = cell()
-        c1.name = b"foo"
-        c2 = cell()
-        c2.name = b"bar"
-
-        c1.next = pointer(c2)
-        c2.next = pointer(c1)
-
-        p = c1
-
-        result = []
-        for i in range(8):
-            result.append(p.name)
-            p = p.next[0]
-        self.assertEqual(result, [b"foo", b"bar"] * 4)
-
-        # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
-        del _pointer_type_cache[cell]
-
-################################################################
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_init.py b/Lib/ctypes/test/test_init.py
deleted file mode 100644
index 75fad112a0..0000000000
--- a/Lib/ctypes/test/test_init.py
+++ /dev/null
@@ -1,40 +0,0 @@
-from ctypes import *
-import unittest
-
-class X(Structure):
-    _fields_ = [("a", c_int),
-                ("b", c_int)]
-    new_was_called = False
-
-    def __new__(cls):
-        result = super().__new__(cls)
-        result.new_was_called = True
-        return result
-
-    def __init__(self):
-        self.a = 9
-        self.b = 12
-
-class Y(Structure):
-    _fields_ = [("x", X)]
-
-
-class InitTest(unittest.TestCase):
-    def test_get(self):
-        # make sure the only accessing a nested structure
-        # doesn't call the structure's __new__ and __init__
-        y = Y()
-        self.assertEqual((y.x.a, y.x.b), (0, 0))
-        self.assertEqual(y.x.new_was_called, False)
-
-        # But explicitly creating an X structure calls __new__ and __init__, of course.
-        x = X()
-        self.assertEqual((x.a, x.b), (9, 12))
-        self.assertEqual(x.new_was_called, True)
-
-        y.x = x
-        self.assertEqual((y.x.a, y.x.b), (9, 12))
-        self.assertEqual(y.x.new_was_called, False)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_loading.py b/Lib/ctypes/test/test_loading.py
deleted file mode 100644
index ea892277c4..0000000000
--- a/Lib/ctypes/test/test_loading.py
+++ /dev/null
@@ -1,182 +0,0 @@
-from ctypes import *
-import os
-import shutil
-import subprocess
-import sys
-import unittest
-import test.support
-from test.support import import_helper
-from test.support import os_helper
-from ctypes.util import find_library
-
-libc_name = None
-
-def setUpModule():
-    global libc_name
-    if os.name == "nt":
-        libc_name = find_library("c")
-    elif sys.platform == "cygwin":
-        libc_name = "cygwin1.dll"
-    else:
-        libc_name = find_library("c")
-
-    if test.support.verbose:
-        print("libc_name is", libc_name)
-
-class LoaderTest(unittest.TestCase):
-
-    unknowndll = "xxrandomnamexx"
-
-    def test_load(self):
-        if libc_name is None:
-            self.skipTest('could not find libc')
-        CDLL(libc_name)
-        CDLL(os.path.basename(libc_name))
-        self.assertRaises(OSError, CDLL, self.unknowndll)
-
-    def test_load_version(self):
-        if libc_name is None:
-            self.skipTest('could not find libc')
-        if os.path.basename(libc_name) != 'libc.so.6':
-            self.skipTest('wrong libc path for test')
-        cdll.LoadLibrary("libc.so.6")
-        # linux uses version, libc 9 should not exist
-        self.assertRaises(OSError, cdll.LoadLibrary, "libc.so.9")
-        self.assertRaises(OSError, cdll.LoadLibrary, self.unknowndll)
-
-    def test_find(self):
-        for name in ("c", "m"):
-            lib = find_library(name)
-            if lib:
-                cdll.LoadLibrary(lib)
-                CDLL(lib)
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_library(self):
-        # CRT is no longer directly loadable. See issue23606 for the
-        # discussion about alternative approaches.
-        #self.assertIsNotNone(libc_name)
-        if test.support.verbose:
-            print(find_library("kernel32"))
-            print(find_library("user32"))
-
-        if os.name == "nt":
-            windll.kernel32.GetModuleHandleW
-            windll["kernel32"].GetModuleHandleW
-            windll.LoadLibrary("kernel32").GetModuleHandleW
-            WinDLL("kernel32").GetModuleHandleW
-            # embedded null character
-            self.assertRaises(ValueError, windll.LoadLibrary, "kernel32\0")
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_ordinal_functions(self):
-        import _ctypes_test
-        dll = WinDLL(_ctypes_test.__file__)
-        # We load the same function both via ordinal and name
-        func_ord = dll[2]
-        func_name = dll.GetString
-        # addressof gets the address where the function pointer is stored
-        a_ord = addressof(func_ord)
-        a_name = addressof(func_name)
-        f_ord_addr = c_void_p.from_address(a_ord).value
-        f_name_addr = c_void_p.from_address(a_name).value
-        self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
-
-        self.assertRaises(AttributeError, dll.__getitem__, 1234)
-
-    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
-    def test_1703286_A(self):
-        from _ctypes import LoadLibrary, FreeLibrary
-        # On winXP 64-bit, advapi32 loads at an address that does
-        # NOT fit into a 32-bit integer.  FreeLibrary must be able
-        # to accept this address.
-
-        # These are tests for https://www.python.org/sf/1703286
-        handle = LoadLibrary("advapi32")
-        FreeLibrary(handle)
-
-    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
-    def test_1703286_B(self):
-        # Since on winXP 64-bit advapi32 loads like described
-        # above, the (arbitrarily selected) CloseEventLog function
-        # also has a high address.  'call_function' should accept
-        # addresses so large.
-        from _ctypes import call_function
-        advapi32 = windll.advapi32
-        # Calling CloseEventLog with a NULL argument should fail,
-        # but the call should not segfault or so.
-        self.assertEqual(0, advapi32.CloseEventLog(None))
-        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
-        windll.kernel32.GetProcAddress.restype = c_void_p
-        proc = windll.kernel32.GetProcAddress(advapi32._handle,
-                                              b"CloseEventLog")
-        self.assertTrue(proc)
-        # This is the real test: call the function via 'call_function'
-        self.assertEqual(0, call_function(proc, (None,)))
-
-    @unittest.skipUnless(os.name == "nt",
-                         'test specific to Windows')
-    def test_load_dll_with_flags(self):
-        _sqlite3 = import_helper.import_module("_sqlite3")
-        src = _sqlite3.__file__
-        if src.lower().endswith("_d.pyd"):
-            ext = "_d.dll"
-        else:
-            ext = ".dll"
-
-        with os_helper.temp_dir() as tmp:
-            # We copy two files and load _sqlite3.dll (formerly .pyd),
-            # which has a dependency on sqlite3.dll. Then we test
-            # loading it in subprocesses to avoid it starting in memory
-            # for each test.
-            target = os.path.join(tmp, "_sqlite3.dll")
-            shutil.copy(src, target)
-            shutil.copy(os.path.join(os.path.dirname(src), "sqlite3" + ext),
-                        os.path.join(tmp, "sqlite3" + ext))
-
-            def should_pass(command):
-                with self.subTest(command):
-                    subprocess.check_output(
-                        [sys.executable, "-c",
-                         "from ctypes import *; import nt;" + command],
-                        cwd=tmp
-                    )
-
-            def should_fail(command):
-                with self.subTest(command):
-                    with self.assertRaises(subprocess.CalledProcessError):
-                        subprocess.check_output(
-                            [sys.executable, "-c",
-                             "from ctypes import *; import nt;" + command],
-                            cwd=tmp, stderr=subprocess.STDOUT,
-                        )
-
-            # Default load should not find this in CWD
-            should_fail("WinDLL('_sqlite3.dll')")
-
-            # Relative path (but not just filename) should succeed
-            should_pass("WinDLL('./_sqlite3.dll')")
-
-            # Insecure load flags should succeed
-            # Clear the DLL directory to avoid safe search settings propagating
-            should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
-
-            # Full path load without DLL_LOAD_DIR shouldn't find dependency
-            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
-                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
-
-            # Full path load with DLL_LOAD_DIR should succeed
-            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
-                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
-                        "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
-
-            # User-specified directory should succeed
-            should_pass("import os; p = os.add_dll_directory(os.getcwd());" +
-                        "WinDLL('_sqlite3.dll'); p.close()")
-
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_parameters.py b/Lib/ctypes/test/test_parameters.py
deleted file mode 100644
index 38af7ac13d..0000000000
--- a/Lib/ctypes/test/test_parameters.py
+++ /dev/null
@@ -1,250 +0,0 @@
-import unittest
-from ctypes.test import need_symbol
-import test.support
-
-class SimpleTypesTestCase(unittest.TestCase):
-
-    def setUp(self):
-        import ctypes
-        try:
-            from _ctypes import set_conversion_mode
-        except ImportError:
-            pass
-        else:
-            self.prev_conv_mode = set_conversion_mode("ascii", "strict")
-
-    def tearDown(self):
-        try:
-            from _ctypes import set_conversion_mode
-        except ImportError:
-            pass
-        else:
-            set_conversion_mode(*self.prev_conv_mode)
-
-    def test_subclasses(self):
-        from ctypes import c_void_p, c_char_p
-        # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new
-        class CVOIDP(c_void_p):
-            def from_param(cls, value):
-                return value * 2
-            from_param = classmethod(from_param)
-
-        class CCHARP(c_char_p):
-            def from_param(cls, value):
-                return value * 4
-            from_param = classmethod(from_param)
-
-        self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
-        self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
-
-    @need_symbol('c_wchar_p')
-    def test_subclasses_c_wchar_p(self):
-        from ctypes import c_wchar_p
-
-        class CWCHARP(c_wchar_p):
-            def from_param(cls, value):
-                return value * 3
-            from_param = classmethod(from_param)
-
-        self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
-
-    # XXX Replace by c_char_p tests
-    def test_cstrings(self):
-        from ctypes import c_char_p
-
-        # c_char_p.from_param on a Python String packs the string
-        # into a cparam object
-        s = b"123"
-        self.assertIs(c_char_p.from_param(s)._obj, s)
-
-        # new in 0.9.1: convert (encode) unicode to ascii
-        self.assertEqual(c_char_p.from_param(b"123")._obj, b"123")
-        self.assertRaises(TypeError, c_char_p.from_param, "123\377")
-        self.assertRaises(TypeError, c_char_p.from_param, 42)
-
-        # calling c_char_p.from_param with a c_char_p instance
-        # returns the argument itself:
-        a = c_char_p(b"123")
-        self.assertIs(c_char_p.from_param(a), a)
-
-    @need_symbol('c_wchar_p')
-    def test_cw_strings(self):
-        from ctypes import c_wchar_p
-
-        c_wchar_p.from_param("123")
-
-        self.assertRaises(TypeError, c_wchar_p.from_param, 42)
-        self.assertRaises(TypeError, c_wchar_p.from_param, b"123\377")
-
-        pa = c_wchar_p.from_param(c_wchar_p("123"))
-        self.assertEqual(type(pa), c_wchar_p)
-
-    def test_int_pointers(self):
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER, pointer
-        LPINT = POINTER(c_int)
-
-##        p = pointer(c_int(42))
-##        x = LPINT.from_param(p)
-        x = LPINT.from_param(pointer(c_int(42)))
-        self.assertEqual(x.contents.value, 42)
-        self.assertEqual(LPINT(c_int(42)).contents.value, 42)
-
-        self.assertEqual(LPINT.from_param(None), None)
-
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
-        self.assertRaises(TypeError, LPINT.from_param, pointer(c_uint(42)))
-        self.assertRaises(TypeError, LPINT.from_param, pointer(c_short(42)))
-
-    def test_byref_pointer(self):
-        # The from_param class method of POINTER(typ) classes accepts what is
-        # returned by byref(obj), it type(obj) == typ
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER, byref
-        LPINT = POINTER(c_int)
-
-        LPINT.from_param(byref(c_int(42)))
-
-        self.assertRaises(TypeError, LPINT.from_param, byref(c_short(22)))
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPINT.from_param, byref(c_long(22)))
-        self.assertRaises(TypeError, LPINT.from_param, byref(c_uint(22)))
-
-    def test_byref_pointerpointer(self):
-        # See above
-        from ctypes import c_short, c_uint, c_int, c_long, pointer, POINTER, byref
-
-        LPLPINT = POINTER(POINTER(c_int))
-        LPLPINT.from_param(byref(pointer(c_int(42))))
-
-        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_short(22))))
-        if c_int != c_long:
-            self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_long(22))))
-        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_uint(22))))
-
-    def test_array_pointers(self):
-        from ctypes import c_short, c_uint, c_int, c_long, POINTER
-        INTARRAY = c_int * 3
-        ia = INTARRAY()
-        self.assertEqual(len(ia), 3)
-        self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
-
-        # Pointers are only compatible with arrays containing items of
-        # the same type!
-        LPINT = POINTER(c_int)
-        LPINT.from_param((c_int*3)())
-        self.assertRaises(TypeError, LPINT.from_param, c_short*3)
-        self.assertRaises(TypeError, LPINT.from_param, c_long*3)
-        self.assertRaises(TypeError, LPINT.from_param, c_uint*3)
-
-    def test_noctypes_argtype(self):
-        import _ctypes_test
-        from ctypes import CDLL, c_void_p, ArgumentError
-
-        func = CDLL(_ctypes_test.__file__)._testfunc_p_p
-        func.restype = c_void_p
-        # TypeError: has no from_param method
-        self.assertRaises(TypeError, setattr, func, "argtypes", (object,))
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                return None
-
-        func.argtypes = (Adapter(),)
-        self.assertEqual(func(None), None)
-        self.assertEqual(func(object()), None)
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                return obj
-
-        func.argtypes = (Adapter(),)
-        # don't know how to convert parameter 1
-        self.assertRaises(ArgumentError, func, object())
-        self.assertEqual(func(c_void_p(42)), 42)
-
-        class Adapter(object):
-            def from_param(cls, obj):
-                raise ValueError(obj)
-
-        func.argtypes = (Adapter(),)
-        # ArgumentError: argument 1: ValueError: 99
-        self.assertRaises(ArgumentError, func, 99)
-
-    def test_abstract(self):
-        from ctypes import (Array, Structure, Union, _Pointer,
-                            _SimpleCData, _CFuncPtr)
-
-        self.assertRaises(TypeError, Array.from_param, 42)
-        self.assertRaises(TypeError, Structure.from_param, 42)
-        self.assertRaises(TypeError, Union.from_param, 42)
-        self.assertRaises(TypeError, _CFuncPtr.from_param, 42)
-        self.assertRaises(TypeError, _Pointer.from_param, 42)
-        self.assertRaises(TypeError, _SimpleCData.from_param, 42)
-
-    @test.support.cpython_only
-    def test_issue31311(self):
-        # __setstate__ should neither raise a SystemError nor crash in case
-        # of a bad __dict__.
-        from ctypes import Structure
-
-        class BadStruct(Structure):
-            @property
-            def __dict__(self):
-                pass
-        with self.assertRaises(TypeError):
-            BadStruct().__setstate__({}, b'foo')
-
-        class WorseStruct(Structure):
-            @property
-            def __dict__(self):
-                1/0
-        with self.assertRaises(ZeroDivisionError):
-            WorseStruct().__setstate__({}, b'foo')
-
-    def test_parameter_repr(self):
-        from ctypes import (
-            c_bool,
-            c_char,
-            c_wchar,
-            c_byte,
-            c_ubyte,
-            c_short,
-            c_ushort,
-            c_int,
-            c_uint,
-            c_long,
-            c_ulong,
-            c_longlong,
-            c_ulonglong,
-            c_float,
-            c_double,
-            c_longdouble,
-            c_char_p,
-            c_wchar_p,
-            c_void_p,
-        )
-        self.assertRegex(repr(c_bool.from_param(True)), r"^<cparam '\?' at 0x[A-Fa-f0-9]+>$")
-        self.assertEqual(repr(c_char.from_param(97)), "<cparam 'c' ('a')>")
-        self.assertRegex(repr(c_wchar.from_param('a')), r"^<cparam 'u' at 0x[A-Fa-f0-9]+>$")
-        self.assertEqual(repr(c_byte.from_param(98)), "<cparam 'b' (98)>")
-        self.assertEqual(repr(c_ubyte.from_param(98)), "<cparam 'B' (98)>")
-        self.assertEqual(repr(c_short.from_param(511)), "<cparam 'h' (511)>")
-        self.assertEqual(repr(c_ushort.from_param(511)), "<cparam 'H' (511)>")
-        self.assertRegex(repr(c_int.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
-        self.assertRegex(repr(c_uint.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
-        self.assertRegex(repr(c_long.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
-        self.assertRegex(repr(c_ulong.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
-        self.assertRegex(repr(c_longlong.from_param(20000)), r"^<cparam '[liq]' \(20000\)>$")
-        self.assertRegex(repr(c_ulonglong.from_param(20000)), r"^<cparam '[LIQ]' \(20000\)>$")
-        self.assertEqual(repr(c_float.from_param(1.5)), "<cparam 'f' (1.5)>")
-        self.assertEqual(repr(c_double.from_param(1.5)), "<cparam 'd' (1.5)>")
-        self.assertEqual(repr(c_double.from_param(1e300)), "<cparam 'd' (1e+300)>")
-        self.assertRegex(repr(c_longdouble.from_param(1.5)), r"^<cparam ('d' \(1.5\)|'g' at 0x[A-Fa-f0-9]+)>$")
-        self.assertRegex(repr(c_char_p.from_param(b'hihi')), r"^<cparam 'z' \(0x[A-Fa-f0-9]+\)>$")
-        self.assertRegex(repr(c_wchar_p.from_param('hihi')), r"^<cparam 'Z' \(0x[A-Fa-f0-9]+\)>$")
-        self.assertRegex(repr(c_void_p.from_param(0x12)), r"^<cparam 'P' \(0x0*12\)>$")
-
-################################################################
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_pep3118.py b/Lib/ctypes/test/test_pep3118.py
deleted file mode 100644
index efffc80a66..0000000000
--- a/Lib/ctypes/test/test_pep3118.py
+++ /dev/null
@@ -1,235 +0,0 @@
-import unittest
-from ctypes import *
-import re, sys
-
-if sys.byteorder == "little":
-    THIS_ENDIAN = "<"
-    OTHER_ENDIAN = ">"
-else:
-    THIS_ENDIAN = ">"
-    OTHER_ENDIAN = "<"
-
-def normalize(format):
-    # Remove current endian specifier and white space from a format
-    # string
-    if format is None:
-        return ""
-    format = format.replace(OTHER_ENDIAN, THIS_ENDIAN)
-    return re.sub(r"\s", "", format)
-
-class Test(unittest.TestCase):
-
-    def test_native_types(self):
-        for tp, fmt, shape, itemtp in native_types:
-            ob = tp()
-            v = memoryview(ob)
-            try:
-                self.assertEqual(normalize(v.format), normalize(fmt))
-                if shape:
-                    self.assertEqual(len(v), shape[0])
-                else:
-                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
-                self.assertEqual(v.itemsize, sizeof(itemtp))
-                self.assertEqual(v.shape, shape)
-                # XXX Issue #12851: PyCData_NewGetBuffer() must provide strides
-                #     if requested. memoryview currently reconstructs missing
-                #     stride information, so this assert will fail.
-                # self.assertEqual(v.strides, ())
-
-                # they are always read/write
-                self.assertFalse(v.readonly)
-
-                if v.shape:
-                    n = 1
-                    for dim in v.shape:
-                        n = n * dim
-                    self.assertEqual(n * v.itemsize, len(v.tobytes()))
-            except:
-                # so that we can see the failing type
-                print(tp)
-                raise
-
-    def test_endian_types(self):
-        for tp, fmt, shape, itemtp in endian_types:
-            ob = tp()
-            v = memoryview(ob)
-            try:
-                self.assertEqual(v.format, fmt)
-                if shape:
-                    self.assertEqual(len(v), shape[0])
-                else:
-                    self.assertEqual(len(v) * sizeof(itemtp), sizeof(ob))
-                self.assertEqual(v.itemsize, sizeof(itemtp))
-                self.assertEqual(v.shape, shape)
-                # XXX Issue #12851
-                # self.assertEqual(v.strides, ())
-
-                # they are always read/write
-                self.assertFalse(v.readonly)
-
-                if v.shape:
-                    n = 1
-                    for dim in v.shape:
-                        n = n * dim
-                    self.assertEqual(n, len(v))
-            except:
-                # so that we can see the failing type
-                print(tp)
-                raise
-
-# define some structure classes
-
-class Point(Structure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class PackedPoint(Structure):
-    _pack_ = 2
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class Point2(Structure):
-    pass
-Point2._fields_ = [("x", c_long), ("y", c_long)]
-
-class EmptyStruct(Structure):
-    _fields_ = []
-
-class aUnion(Union):
-    _fields_ = [("a", c_int)]
-
-class StructWithArrays(Structure):
-    _fields_ = [("x", c_long * 3 * 2), ("y", Point * 4)]
-
-class Incomplete(Structure):
-    pass
-
-class Complete(Structure):
-    pass
-PComplete = POINTER(Complete)
-Complete._fields_ = [("a", c_long)]
-
-################################################################
-#
-# This table contains format strings as they look on little endian
-# machines.  The test replaces '<' with '>' on big endian machines.
-#
-
-# Platform-specific type codes
-s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
-s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
-s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
-s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
-s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
-s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
-s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
-s_longlong = "q"
-s_ulonglong = "Q"
-s_float = "f"
-s_double = "d"
-s_longdouble = "g"
-
-# Alias definitions in ctypes/__init__.py
-if c_int is c_long:
-    s_int = s_long
-if c_uint is c_ulong:
-    s_uint = s_ulong
-if c_longlong is c_long:
-    s_longlong = s_long
-if c_ulonglong is c_ulong:
-    s_ulonglong = s_ulong
-if c_longdouble is c_double:
-    s_longdouble = s_double
-
-
-native_types = [
-    # type                      format                  shape           calc itemsize
-
-    ## simple types
-
-    (c_char,                    "<c",                   (),           c_char),
-    (c_byte,                    "<b",                   (),           c_byte),
-    (c_ubyte,                   "<B",                   (),           c_ubyte),
-    (c_short,                   "<" + s_short,          (),           c_short),
-    (c_ushort,                  "<" + s_ushort,         (),           c_ushort),
-
-    (c_int,                     "<" + s_int,            (),           c_int),
-    (c_uint,                    "<" + s_uint,           (),           c_uint),
-
-    (c_long,                    "<" + s_long,           (),           c_long),
-    (c_ulong,                   "<" + s_ulong,          (),           c_ulong),
-
-    (c_longlong,                "<" + s_longlong,       (),           c_longlong),
-    (c_ulonglong,               "<" + s_ulonglong,      (),           c_ulonglong),
-
-    (c_float,                   "<f",                   (),           c_float),
-    (c_double,                  "<d",                   (),           c_double),
-
-    (c_longdouble,              "<" + s_longdouble,     (),           c_longdouble),
-
-    (c_bool,                    "<" + s_bool,           (),           c_bool),
-    (py_object,                 "<O",                   (),           py_object),
-
-    ## pointers
-
-    (POINTER(c_byte),           "&<b",                  (),           POINTER(c_byte)),
-    (POINTER(POINTER(c_long)),  "&&<" + s_long,         (),           POINTER(POINTER(c_long))),
-
-    ## arrays and pointers
-
-    (c_double * 4,              "<d",                   (4,),           c_double),
-    (c_double * 0,              "<d",                   (0,),           c_double),
-    (c_float * 4 * 3 * 2,       "<f",                   (2,3,4),        c_float),
-    (c_float * 4 * 0 * 2,       "<f",                   (2,0,4),        c_float),
-    (POINTER(c_short) * 2,      "&<" + s_short,         (2,),           POINTER(c_short)),
-    (POINTER(c_short) * 2 * 3,  "&<" + s_short,         (3,2,),         POINTER(c_short)),
-    (POINTER(c_short * 2),      "&(2)<" + s_short,      (),             POINTER(c_short)),
-
-    ## structures and unions
-
-    (Point,                     "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point),
-    # packed structures do not implement the pep
-    (PackedPoint,               "B",                                   (),  PackedPoint),
-    (Point2,                    "T{<l:x:<l:y:}".replace('l', s_long),  (),  Point2),
-    (EmptyStruct,               "T{}",                                 (),  EmptyStruct),
-    # the pep doesn't support unions
-    (aUnion,                    "B",                                   (),  aUnion),
-    # structure with sub-arrays
-    (StructWithArrays, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (), StructWithArrays),
-    (StructWithArrays * 3, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (3,), StructWithArrays),
-
-    ## pointer to incomplete structure
-    (Incomplete,                "B",                    (),           Incomplete),
-    (POINTER(Incomplete),       "&B",                   (),           POINTER(Incomplete)),
-
-    # 'Complete' is a structure that starts incomplete, but is completed after the
-    # pointer type to it has been created.
-    (Complete,                  "T{<l:a:}".replace('l', s_long), (), Complete),
-    # Unfortunately the pointer format string is not fixed...
-    (POINTER(Complete),         "&B",                   (),           POINTER(Complete)),
-
-    ## other
-
-    # function signatures are not implemented
-    (CFUNCTYPE(None),           "X{}",                  (),           CFUNCTYPE(None)),
-
-    ]
-
-class BEPoint(BigEndianStructure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-class LEPoint(LittleEndianStructure):
-    _fields_ = [("x", c_long), ("y", c_long)]
-
-################################################################
-#
-# This table contains format strings as they really look, on both big
-# and little endian machines.
-#
-endian_types = [
-    (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
-    (LEPoint, "T{<l:x:<l:y:}".replace('l', s_long), (), LEPoint),
-    (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
-    (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
-    ]
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_python_api.py b/Lib/ctypes/test/test_python_api.py
deleted file mode 100644
index 49571f97bb..0000000000
--- a/Lib/ctypes/test/test_python_api.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from ctypes import *
-import unittest
-from test import support
-
-################################################################
-# This section should be moved into ctypes\__init__.py, when it's ready.
-
-from _ctypes import PyObj_FromPtr
-
-################################################################
-
-from sys import getrefcount as grc
-
-class PythonAPITestCase(unittest.TestCase):
-
-    def test_PyBytes_FromStringAndSize(self):
-        PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
-
-        PyBytes_FromStringAndSize.restype = py_object
-        PyBytes_FromStringAndSize.argtypes = c_char_p, c_size_t
-
-        self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
-
-    @support.refcount_test
-    def test_PyString_FromString(self):
-        pythonapi.PyBytes_FromString.restype = py_object
-        pythonapi.PyBytes_FromString.argtypes = (c_char_p,)
-
-        s = b"abc"
-        refcnt = grc(s)
-        pyob = pythonapi.PyBytes_FromString(s)
-        self.assertEqual(grc(s), refcnt)
-        self.assertEqual(s, pyob)
-        del pyob
-        self.assertEqual(grc(s), refcnt)
-
-    @support.refcount_test
-    def test_PyLong_Long(self):
-        ref42 = grc(42)
-        pythonapi.PyLong_FromLong.restype = py_object
-        self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
-
-        self.assertEqual(grc(42), ref42)
-
-        pythonapi.PyLong_AsLong.argtypes = (py_object,)
-        pythonapi.PyLong_AsLong.restype = c_long
-
-        res = pythonapi.PyLong_AsLong(42)
-        self.assertEqual(grc(res), ref42 + 1)
-        del res
-        self.assertEqual(grc(42), ref42)
-
-    @support.refcount_test
-    def test_PyObj_FromPtr(self):
-        s = "abc def ghi jkl"
-        ref = grc(s)
-        # id(python-object) is the address
-        pyobj = PyObj_FromPtr(id(s))
-        self.assertIs(s, pyobj)
-
-        self.assertEqual(grc(s), ref + 1)
-        del pyobj
-        self.assertEqual(grc(s), ref)
-
-    def test_PyOS_snprintf(self):
-        PyOS_snprintf = pythonapi.PyOS_snprintf
-        PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
-
-        buf = c_buffer(256)
-        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s", b"ctypes")
-        self.assertEqual(buf.value, b"Hello from ctypes")
-
-        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
-        self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
-
-        # not enough arguments
-        self.assertRaises(TypeError, PyOS_snprintf, buf)
-
-    def test_pyobject_repr(self):
-        self.assertEqual(repr(py_object()), "py_object(<NULL>)")
-        self.assertEqual(repr(py_object(42)), "py_object(42)")
-        self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_random_things.py b/Lib/ctypes/test/test_random_things.py
deleted file mode 100644
index 2988e275cf..0000000000
--- a/Lib/ctypes/test/test_random_things.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from ctypes import *
-import contextlib
-from test import support
-import unittest
-import sys
-
-
-def callback_func(arg):
-    42 / arg
-    raise ValueError(arg)
-
-@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
-class call_function_TestCase(unittest.TestCase):
-    # _ctypes.call_function is deprecated and private, but used by
-    # Gary Bishp's readline module.  If we have it, we must test it as well.
-
-    def test(self):
-        from _ctypes import call_function
-        windll.kernel32.LoadLibraryA.restype = c_void_p
-        windll.kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
-        windll.kernel32.GetProcAddress.restype = c_void_p
-
-        hdll = windll.kernel32.LoadLibraryA(b"kernel32")
-        funcaddr = windll.kernel32.GetProcAddress(hdll, b"GetModuleHandleA")
-
-        self.assertEqual(call_function(funcaddr, (None,)),
-                             windll.kernel32.GetModuleHandleA(None))
-
-class CallbackTracbackTestCase(unittest.TestCase):
-    # When an exception is raised in a ctypes callback function, the C
-    # code prints a traceback.
-    #
-    # This test makes sure the exception types *and* the exception
-    # value is printed correctly.
-    #
-    # Changed in 0.9.3: No longer is '(in callback)' prepended to the
-    # error message - instead an additional frame for the C code is
-    # created, then a full traceback printed.  When SystemExit is
-    # raised in a callback function, the interpreter exits.
-
-    @contextlib.contextmanager
-    def expect_unraisable(self, exc_type, exc_msg=None):
-        with support.catch_unraisable_exception() as cm:
-            yield
-
-            self.assertIsInstance(cm.unraisable.exc_value, exc_type)
-            if exc_msg is not None:
-                self.assertEqual(str(cm.unraisable.exc_value), exc_msg)
-            self.assertEqual(cm.unraisable.err_msg,
-                             "Exception ignored on calling ctypes "
-                             "callback function")
-            self.assertIs(cm.unraisable.object, callback_func)
-
-    def test_ValueError(self):
-        cb = CFUNCTYPE(c_int, c_int)(callback_func)
-        with self.expect_unraisable(ValueError, '42'):
-            cb(42)
-
-    def test_IntegerDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_int)(callback_func)
-        with self.expect_unraisable(ZeroDivisionError):
-            cb(0)
-
-    def test_FloatDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_double)(callback_func)
-        with self.expect_unraisable(ZeroDivisionError):
-            cb(0.0)
-
-    def test_TypeErrorDivisionError(self):
-        cb = CFUNCTYPE(c_int, c_char_p)(callback_func)
-        err_msg = "unsupported operand type(s) for /: 'int' and 'bytes'"
-        with self.expect_unraisable(TypeError, err_msg):
-            cb(b"spam")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_refcounts.py b/Lib/ctypes/test/test_refcounts.py
deleted file mode 100644
index 48958cd2a6..0000000000
--- a/Lib/ctypes/test/test_refcounts.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import unittest
-from test import support
-import ctypes
-import gc
-
-MyCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
-OtherCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulonglong)
-
-import _ctypes_test
-dll = ctypes.CDLL(_ctypes_test.__file__)
-
-class RefcountTestCase(unittest.TestCase):
-
-    @support.refcount_test
-    def test_1(self):
-        from sys import getrefcount as grc
-
-        f = dll._testfunc_callback_i_if
-        f.restype = ctypes.c_int
-        f.argtypes = [ctypes.c_int, MyCallback]
-
-        def callback(value):
-            #print "called back with", value
-            return value
-
-        self.assertEqual(grc(callback), 2)
-        cb = MyCallback(callback)
-
-        self.assertGreater(grc(callback), 2)
-        result = f(-10, cb)
-        self.assertEqual(result, -18)
-        cb = None
-
-        gc.collect()
-
-        self.assertEqual(grc(callback), 2)
-
-
-    @support.refcount_test
-    def test_refcount(self):
-        from sys import getrefcount as grc
-        def func(*args):
-            pass
-        # this is the standard refcount for func
-        self.assertEqual(grc(func), 2)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        f = OtherCallback(func)
-        self.assertGreater(grc(func), 2)
-
-        # and may release it again
-        del f
-        self.assertGreaterEqual(grc(func), 2)
-
-        # but now it must be gone
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-        class X(ctypes.Structure):
-            _fields_ = [("a", OtherCallback)]
-        x = X()
-        x.a = OtherCallback(func)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(grc(func), 2)
-
-        # and may release it again
-        del x
-        self.assertGreaterEqual(grc(func), 2)
-
-        # and now it must be gone again
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-        f = OtherCallback(func)
-
-        # the CFuncPtr instance holds at least one refcount on func:
-        self.assertGreater(grc(func), 2)
-
-        # create a cycle
-        f.cycle = f
-
-        del f
-        gc.collect()
-        self.assertEqual(grc(func), 2)
-
-class AnotherLeak(unittest.TestCase):
-    def test_callback(self):
-        import sys
-
-        proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
-        def func(a, b):
-            return a * b * 2
-        f = proto(func)
-
-        a = sys.getrefcount(ctypes.c_int)
-        f(1, 2)
-        self.assertEqual(sys.getrefcount(ctypes.c_int), a)
-
-    @support.refcount_test
-    def test_callback_py_object_none_return(self):
-        # bpo-36880: test that returning None from a py_object callback
-        # does not decrement the refcount of None.
-
-        for FUNCTYPE in (ctypes.CFUNCTYPE, ctypes.PYFUNCTYPE):
-            with self.subTest(FUNCTYPE=FUNCTYPE):
-                @FUNCTYPE(ctypes.py_object)
-                def func():
-                    return None
-
-                # Check that calling func does not affect None's refcount.
-                for _ in range(10000):
-                    func()
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_simplesubclasses.py b/Lib/ctypes/test/test_simplesubclasses.py
deleted file mode 100644
index 3da2794a79..0000000000
--- a/Lib/ctypes/test/test_simplesubclasses.py
+++ /dev/null
@@ -1,55 +0,0 @@
-import unittest
-from ctypes import *
-
-class MyInt(c_int):
-    def __eq__(self, other):
-        if type(other) != MyInt:
-            return NotImplementedError
-        return self.value == other.value
-
-class Test(unittest.TestCase):
-
-    def test_compare(self):
-        self.assertEqual(MyInt(3), MyInt(3))
-        self.assertNotEqual(MyInt(42), MyInt(43))
-
-    def test_ignore_retval(self):
-        # Test if the return value of a callback is ignored
-        # if restype is None
-        proto = CFUNCTYPE(None)
-        def func():
-            return (1, "abc", None)
-
-        cb = proto(func)
-        self.assertEqual(None, cb())
-
-
-    def test_int_callback(self):
-        args = []
-        def func(arg):
-            args.append(arg)
-            return arg
-
-        cb = CFUNCTYPE(None, MyInt)(func)
-
-        self.assertEqual(None, cb(42))
-        self.assertEqual(type(args[-1]), MyInt)
-
-        cb = CFUNCTYPE(c_int, c_int)(func)
-
-        self.assertEqual(42, cb(42))
-        self.assertEqual(type(args[-1]), int)
-
-    def test_int_struct(self):
-        class X(Structure):
-            _fields_ = [("x", MyInt)]
-
-        self.assertEqual(X().x, MyInt())
-
-        s = X()
-        s.x = MyInt(42)
-
-        self.assertEqual(s.x, MyInt(42))
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_sizes.py b/Lib/ctypes/test/test_sizes.py
deleted file mode 100644
index 4ceacbc290..0000000000
--- a/Lib/ctypes/test/test_sizes.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# Test specifically-sized containers.
-
-from ctypes import *
-
-import unittest
-
-
-class SizesTestCase(unittest.TestCase):
-    def test_8(self):
-        self.assertEqual(1, sizeof(c_int8))
-        self.assertEqual(1, sizeof(c_uint8))
-
-    def test_16(self):
-        self.assertEqual(2, sizeof(c_int16))
-        self.assertEqual(2, sizeof(c_uint16))
-
-    def test_32(self):
-        self.assertEqual(4, sizeof(c_int32))
-        self.assertEqual(4, sizeof(c_uint32))
-
-    def test_64(self):
-        self.assertEqual(8, sizeof(c_int64))
-        self.assertEqual(8, sizeof(c_uint64))
-
-    def test_size_t(self):
-        self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
-
-    def test_ssize_t(self):
-        self.assertEqual(sizeof(c_void_p), sizeof(c_ssize_t))
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_stringptr.py b/Lib/ctypes/test/test_stringptr.py
deleted file mode 100644
index c20951f4ce..0000000000
--- a/Lib/ctypes/test/test_stringptr.py
+++ /dev/null
@@ -1,77 +0,0 @@
-import unittest
-from test import support
-from ctypes import *
-
-import _ctypes_test
-
-lib = CDLL(_ctypes_test.__file__)
-
-class StringPtrTestCase(unittest.TestCase):
-
-    @support.refcount_test
-    def test__POINTER_c_char(self):
-        class X(Structure):
-            _fields_ = [("str", POINTER(c_char))]
-        x = X()
-
-        # NULL pointer access
-        self.assertRaises(ValueError, getattr, x.str, "contents")
-        b = c_buffer(b"Hello, World")
-        from sys import getrefcount as grc
-        self.assertEqual(grc(b), 2)
-        x.str = b
-        self.assertEqual(grc(b), 3)
-
-        # POINTER(c_char) and Python string is NOT compatible
-        # POINTER(c_char) and c_buffer() is compatible
-        for i in range(len(b)):
-            self.assertEqual(b[i], x.str[i])
-
-        self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
-
-    def test__c_char_p(self):
-        class X(Structure):
-            _fields_ = [("str", c_char_p)]
-        x = X()
-
-        # c_char_p and Python string is compatible
-        # c_char_p and c_buffer is NOT compatible
-        self.assertEqual(x.str, None)
-        x.str = b"Hello, World"
-        self.assertEqual(x.str, b"Hello, World")
-        b = c_buffer(b"Hello, World")
-        self.assertRaises(TypeError, setattr, x, b"str", b)
-
-
-    def test_functions(self):
-        strchr = lib.my_strchr
-        strchr.restype = c_char_p
-
-        # c_char_p and Python string is compatible
-        # c_char_p and c_buffer are now compatible
-        strchr.argtypes = c_char_p, c_char
-        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
-        self.assertEqual(strchr(c_buffer(b"abcdef"), b"c"), b"cdef")
-
-        # POINTER(c_char) and Python string is NOT compatible
-        # POINTER(c_char) and c_buffer() is compatible
-        strchr.argtypes = POINTER(c_char), c_char
-        buf = c_buffer(b"abcdef")
-        self.assertEqual(strchr(buf, b"c"), b"cdef")
-        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
-
-        # XXX These calls are dangerous, because the first argument
-        # to strchr is no longer valid after the function returns!
-        # So we must keep a reference to buf separately
-
-        strchr.restype = POINTER(c_char)
-        buf = c_buffer(b"abcdef")
-        r = strchr(buf, b"c")
-        x = r[0], r[1], r[2], r[3], r[4]
-        self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
-        del buf
-        # Because r is a pointer to memory that is freed after deleting buf,
-        # the pointer is hanging and using it would reference freed memory.
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_strings.py b/Lib/ctypes/test/test_strings.py
deleted file mode 100644
index 12e208828a..0000000000
--- a/Lib/ctypes/test/test_strings.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-
-class StringArrayTestCase(unittest.TestCase):
-    def test(self):
-        BUF = c_char * 4
-
-        buf = BUF(b"a", b"b", b"c")
-        self.assertEqual(buf.value, b"abc")
-        self.assertEqual(buf.raw, b"abc\000")
-
-        buf.value = b"ABCD"
-        self.assertEqual(buf.value, b"ABCD")
-        self.assertEqual(buf.raw, b"ABCD")
-
-        buf.value = b"x"
-        self.assertEqual(buf.value, b"x")
-        self.assertEqual(buf.raw, b"x\000CD")
-
-        buf[1] = b"Z"
-        self.assertEqual(buf.value, b"xZCD")
-        self.assertEqual(buf.raw, b"xZCD")
-
-        self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa")
-        self.assertRaises(TypeError, setattr, buf, "value", 42)
-
-    def test_c_buffer_value(self):
-        buf = c_buffer(32)
-
-        buf.value = b"Hello, World"
-        self.assertEqual(buf.value, b"Hello, World")
-
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
-        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
-
-    def test_c_buffer_raw(self):
-        buf = c_buffer(32)
-
-        buf.raw = memoryview(b"Hello, World")
-        self.assertEqual(buf.value, b"Hello, World")
-        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
-        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
-
-    def test_param_1(self):
-        BUF = c_char * 4
-        buf = BUF()
-##        print c_char_p.from_param(buf)
-
-    def test_param_2(self):
-        BUF = c_char * 4
-        buf = BUF()
-##        print BUF.from_param(c_char_p("python"))
-##        print BUF.from_param(BUF(*"pyth"))
-
-    def test_del_segfault(self):
-        BUF = c_char * 4
-        buf = BUF()
-        with self.assertRaises(AttributeError):
-            del buf.raw
-
-
-@need_symbol('c_wchar')
-class WStringArrayTestCase(unittest.TestCase):
-    def test(self):
-        BUF = c_wchar * 4
-
-        buf = BUF("a", "b", "c")
-        self.assertEqual(buf.value, "abc")
-
-        buf.value = "ABCD"
-        self.assertEqual(buf.value, "ABCD")
-
-        buf.value = "x"
-        self.assertEqual(buf.value, "x")
-
-        buf[1] = "Z"
-        self.assertEqual(buf.value, "xZCD")
-
-    @unittest.skipIf(sizeof(c_wchar) < 4,
-                     "sizeof(wchar_t) is smaller than 4 bytes")
-    def test_nonbmp(self):
-        u = chr(0x10ffff)
-        w = c_wchar(u)
-        self.assertEqual(w.value, u)
-
-
-@need_symbol('c_wchar')
-class WStringTestCase(unittest.TestCase):
-    def test_wchar(self):
-        c_wchar("x")
-        repr(byref(c_wchar("x")))
-        c_wchar("x")
-
-
-    @unittest.skip('test disabled')
-    def test_basic_wstrings(self):
-        cs = c_wstring("abcdef")
-
-        # XXX This behaviour is about to change:
-        # len returns the size of the internal buffer in bytes.
-        # This includes the terminating NUL character.
-        self.assertEqual(sizeof(cs), 14)
-
-        # The value property is the string up to the first terminating NUL.
-        self.assertEqual(cs.value, "abcdef")
-        self.assertEqual(c_wstring("abc\000def").value, "abc")
-
-        self.assertEqual(c_wstring("abc\000def").value, "abc")
-
-        # The raw property is the total buffer contents:
-        self.assertEqual(cs.raw, "abcdef\000")
-        self.assertEqual(c_wstring("abc\000def").raw, "abc\000def\000")
-
-        # We can change the value:
-        cs.value = "ab"
-        self.assertEqual(cs.value, "ab")
-        self.assertEqual(cs.raw, "ab\000\000\000\000\000")
-
-        self.assertRaises(TypeError, c_wstring, "123")
-        self.assertRaises(ValueError, c_wstring, 0)
-
-    @unittest.skip('test disabled')
-    def test_toolong(self):
-        cs = c_wstring("abcdef")
-        # Much too long string:
-        self.assertRaises(ValueError, setattr, cs, "value", "123456789012345")
-
-        # One char too long values:
-        self.assertRaises(ValueError, setattr, cs, "value", "1234567")
-
-
-def run_test(rep, msg, func, arg):
-    items = range(rep)
-    from time import perf_counter as clock
-    start = clock()
-    for i in items:
-        func(arg); func(arg); func(arg); func(arg); func(arg)
-    stop = clock()
-    print("%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep)))
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_struct_fields.py b/Lib/ctypes/test/test_struct_fields.py
deleted file mode 100644
index e444f5e1f7..0000000000
--- a/Lib/ctypes/test/test_struct_fields.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import unittest
-from ctypes import *
-
-class StructFieldsTestCase(unittest.TestCase):
-    # Structure/Union classes must get 'finalized' sooner or
-    # later, when one of these things happen:
-    #
-    # 1. _fields_ is set.
-    # 2. An instance is created.
-    # 3. The type is used as field of another Structure/Union.
-    # 4. The type is subclassed
-    #
-    # When they are finalized, assigning _fields_ is no longer allowed.
-
-    def test_1_A(self):
-        class X(Structure):
-            pass
-        self.assertEqual(sizeof(X), 0) # not finalized
-        X._fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_1_B(self):
-        class X(Structure):
-            _fields_ = [] # finalized
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_2(self):
-        class X(Structure):
-            pass
-        X()
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_3(self):
-        class X(Structure):
-            pass
-        class Y(Structure):
-            _fields_ = [("x", X)] # finalizes X
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_4(self):
-        class X(Structure):
-            pass
-        class Y(X):
-            pass
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-        Y._fields_ = []
-        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
-
-    def test_5(self):
-        class X(Structure):
-            _fields_ = (("char", c_char * 5),)
-
-        x = X(b'#' * 5)
-        x.char = b'a\0b\0'
-        self.assertEqual(bytes(x), b'a\x00###')
-
-    def test_6(self):
-        class X(Structure):
-            _fields_ = [("x", c_int)]
-        CField = type(X.x)
-        self.assertRaises(TypeError, CField)
-
-    def test_gh99275(self):
-        class BrokenStructure(Structure):
-            def __init_subclass__(cls, **kwargs):
-                cls._fields_ = []  # This line will fail, `stgdict` is not ready
-
-        with self.assertRaisesRegex(TypeError,
-                                    'ctypes state is not initialized'):
-            class Subclass(BrokenStructure): ...
-
-    # __set__ and __get__ should raise a TypeError in case their self
-    # argument is not a ctype instance.
-    def test___set__(self):
-        class MyCStruct(Structure):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCStruct.field.__set__, 'wrong type self', 42)
-
-        class MyCUnion(Union):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCUnion.field.__set__, 'wrong type self', 42)
-
-    def test___get__(self):
-        class MyCStruct(Structure):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCStruct.field.__get__, 'wrong type self', 42)
-
-        class MyCUnion(Union):
-            _fields_ = (("field", c_int),)
-        self.assertRaises(TypeError,
-                          MyCUnion.field.__get__, 'wrong type self', 42)
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/test/test_unicode.py b/Lib/ctypes/test/test_unicode.py
deleted file mode 100644
index 60c75424b7..0000000000
--- a/Lib/ctypes/test/test_unicode.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import unittest
-import ctypes
-from ctypes.test import need_symbol
-
-import _ctypes_test
-
-@need_symbol('c_wchar')
-class UnicodeTestCase(unittest.TestCase):
-    def test_wcslen(self):
-        dll = ctypes.CDLL(_ctypes_test.__file__)
-        wcslen = dll.my_wcslen
-        wcslen.argtypes = [ctypes.c_wchar_p]
-
-        self.assertEqual(wcslen("abc"), 3)
-        self.assertEqual(wcslen("ab\u2070"), 3)
-        self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
-
-    def test_buffers(self):
-        buf = ctypes.create_unicode_buffer("abc")
-        self.assertEqual(len(buf), 3+1)
-
-        buf = ctypes.create_unicode_buffer("ab\xe4\xf6\xfc")
-        self.assertEqual(buf[:], "ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::], "ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::-1], '\x00\xfc\xf6\xe4ba')
-        self.assertEqual(buf[::2], 'a\xe4\xfc')
-        self.assertEqual(buf[6:5:-1], "")
-
-    def test_embedded_null(self):
-        class TestStruct(ctypes.Structure):
-            _fields_ = [("unicode", ctypes.c_wchar_p)]
-        t = TestStruct()
-        # This would raise a ValueError:
-        t.unicode = "foo\0bar\0\0"
-
-
-func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
-
-class StringTestCase(UnicodeTestCase):
-    def setUp(self):
-        func.argtypes = [ctypes.c_char_p]
-        func.restype = ctypes.c_char_p
-
-    def tearDown(self):
-        func.argtypes = None
-        func.restype = ctypes.c_int
-
-    def test_func(self):
-        self.assertEqual(func(b"abc\xe4"), b"abc\xe4")
-
-    def test_buffers(self):
-        buf = ctypes.create_string_buffer(b"abc")
-        self.assertEqual(len(buf), 3+1)
-
-        buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc")
-        self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\0")
-        self.assertEqual(buf[::-1], b'\x00\xfc\xf6\xe4ba')
-        self.assertEqual(buf[::2], b'a\xe4\xfc')
-        self.assertEqual(buf[6:5:-1], b"")
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/ctypes/test/test_wintypes.py b/Lib/ctypes/test/test_wintypes.py
deleted file mode 100644
index 243d5962ff..0000000000
--- a/Lib/ctypes/test/test_wintypes.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import unittest
-
-# also work on POSIX
-
-from ctypes import *
-from ctypes import wintypes
-
-
-class WinTypesTest(unittest.TestCase):
-    def test_variant_bool(self):
-        # reads 16-bits from memory, anything non-zero is True
-        for true_value in (1, 32767, 32768, 65535, 65537):
-            true = POINTER(c_int16)(c_int16(true_value))
-            value = cast(true, POINTER(wintypes.VARIANT_BOOL))
-            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(True)')
-
-            vb = wintypes.VARIANT_BOOL()
-            self.assertIs(vb.value, False)
-            vb.value = True
-            self.assertIs(vb.value, True)
-            vb.value = true_value
-            self.assertIs(vb.value, True)
-
-        for false_value in (0, 65536, 262144, 2**33):
-            false = POINTER(c_int16)(c_int16(false_value))
-            value = cast(false, POINTER(wintypes.VARIANT_BOOL))
-            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(False)')
-
-        # allow any bool conversion on assignment to value
-        for set_value in (65536, 262144, 2**33):
-            vb = wintypes.VARIANT_BOOL()
-            vb.value = set_value
-            self.assertIs(vb.value, True)
-
-        vb = wintypes.VARIANT_BOOL()
-        vb.value = [2, 3]
-        self.assertIs(vb.value, True)
-        vb.value = []
-        self.assertIs(vb.value, False)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/ctypes/util.py b/Lib/ctypes/util.py
index 0c2510e161..117bf06cb0 100644
--- a/Lib/ctypes/util.py
+++ b/Lib/ctypes/util.py
@@ -67,7 +67,7 @@ def find_library(name):
                 return fname
         return None
 
-elif os.name == "posix" and sys.platform == "darwin":
+elif os.name == "posix" and sys.platform in {"darwin", "ios", "tvos", "watchos"}:
     from ctypes.macholib.dyld import dyld_find as _dyld_find
     def find_library(name):
         possible = ['lib%s.dylib' % name,
@@ -89,6 +89,15 @@ def find_library(name):
 
     from ctypes._aix import find_library
 
+elif sys.platform == "android":
+    def find_library(name):
+        directory = "/system/lib"
+        if "64" in os.uname().machine:
+            directory += "64"
+
+        fname = f"{directory}/lib{name}.so"
+        return fname if os.path.isfile(fname) else None
+
 elif os.name == "posix":
     # Andreas Degert's find functions, using gcc, /sbin/ldconfig, objdump
     import re, tempfile
@@ -96,8 +105,11 @@ def find_library(name):
     def _is_elf(filename):
         "Return True if the given file is an ELF file"
         elf_header = b'\x7fELF'
-        with open(filename, 'br') as thefile:
-            return thefile.read(4) == elf_header
+        try:
+            with open(filename, 'br') as thefile:
+                return thefile.read(4) == elf_header
+        except FileNotFoundError:
+            return False
 
     def _findLib_gcc(name):
         # Run GCC's linker with the -t (aka --trace) option and examine the
diff --git a/Lib/ctypes/wintypes.py b/Lib/ctypes/wintypes.py
index c619d27596..9c4e721438 100644
--- a/Lib/ctypes/wintypes.py
+++ b/Lib/ctypes/wintypes.py
@@ -1,7 +1,7 @@
 # The most useful windows datatypes
 import ctypes
 
-BYTE = ctypes.c_byte
+BYTE = ctypes.c_ubyte
 WORD = ctypes.c_ushort
 DWORD = ctypes.c_ulong
 
diff --git a/Lib/dataclasses.py b/Lib/dataclasses.py
index e1687a117d..7883ce78e5 100644
--- a/Lib/dataclasses.py
+++ b/Lib/dataclasses.py
@@ -4,11 +4,9 @@
 import types
 import inspect
 import keyword
-import builtins
-import functools
+import itertools
 import abc
-import _thread
-from types import FunctionType, GenericAlias
+from reprlib import recursive_repr
 
 
 __all__ = ['dataclass',
@@ -222,6 +220,30 @@ def __repr__(self):
 # https://bugs.python.org/issue33453 for details.
 _MODULE_IDENTIFIER_RE = re.compile(r'^(?:\s*(\w+)\s*\.)?\s*(\w+)')
 
+# Atomic immutable types which don't require any recursive handling and for which deepcopy
+# returns the same object. We can provide a fast-path for these types in asdict and astuple.
+_ATOMIC_TYPES = frozenset({
+    # Common JSON Serializable types
+    types.NoneType,
+    bool,
+    int,
+    float,
+    str,
+    # Other common types
+    complex,
+    bytes,
+    # Other types that are also unaffected by deepcopy
+    types.EllipsisType,
+    types.NotImplementedType,
+    types.CodeType,
+    types.BuiltinFunctionType,
+    types.FunctionType,
+    type,
+    range,
+    property,
+})
+
+
 class InitVar:
     __slots__ = ('type', )
 
@@ -229,7 +251,7 @@ def __init__(self, type):
         self.type = type
 
     def __repr__(self):
-        if isinstance(self.type, type) and not isinstance(self.type, GenericAlias):
+        if isinstance(self.type, type):
             type_name = self.type.__name__
         else:
             # typing objects, e.g. List[int]
@@ -279,6 +301,7 @@ def __init__(self, default, default_factory, init, repr, hash, compare,
         self.kw_only = kw_only
         self._field_type = None
 
+    @recursive_repr()
     def __repr__(self):
         return ('Field('
                 f'name={self.name!r},'
@@ -297,7 +320,7 @@ def __repr__(self):
     # This is used to support the PEP 487 __set_name__ protocol in the
     # case where we're using a field that contains a descriptor as a
     # default value.  For details on __set_name__, see
-    # https://www.python.org/dev/peps/pep-0487/#implementation-details.
+    # https://peps.python.org/pep-0487/#implementation-details.
     #
     # Note that in _process_class, this Field object is overwritten
     # with the default value, so the end result is a descriptor that
@@ -309,7 +332,7 @@ def __set_name__(self, owner, name):
             # it.
             func(self.default, owner, name)
 
-    __class_getitem__ = classmethod(GenericAlias)
+    __class_getitem__ = classmethod(types.GenericAlias)
 
 
 class _DataclassParams:
@@ -319,15 +342,25 @@ class _DataclassParams:
                  'order',
                  'unsafe_hash',
                  'frozen',
+                 'match_args',
+                 'kw_only',
+                 'slots',
+                 'weakref_slot',
                  )
 
-    def __init__(self, init, repr, eq, order, unsafe_hash, frozen):
+    def __init__(self,
+                 init, repr, eq, order, unsafe_hash, frozen,
+                 match_args, kw_only, slots, weakref_slot):
         self.init = init
         self.repr = repr
         self.eq = eq
         self.order = order
         self.unsafe_hash = unsafe_hash
         self.frozen = frozen
+        self.match_args = match_args
+        self.kw_only = kw_only
+        self.slots = slots
+        self.weakref_slot = weakref_slot
 
     def __repr__(self):
         return ('_DataclassParams('
@@ -336,7 +369,11 @@ def __repr__(self):
                 f'eq={self.eq!r},'
                 f'order={self.order!r},'
                 f'unsafe_hash={self.unsafe_hash!r},'
-                f'frozen={self.frozen!r}'
+                f'frozen={self.frozen!r},'
+                f'match_args={self.match_args!r},'
+                f'kw_only={self.kw_only!r},'
+                f'slots={self.slots!r},'
+                f'weakref_slot={self.weakref_slot!r}'
                 ')')
 
 
@@ -388,49 +425,95 @@ def _tuple_str(obj_name, fields):
     return f'({",".join([f"{obj_name}.{f.name}" for f in fields])},)'
 
 
-# This function's logic is copied from "recursive_repr" function in
-# reprlib module to avoid dependency.
-def _recursive_repr(user_function):
-    # Decorator to make a repr function return "..." for a recursive
-    # call.
-    repr_running = set()
+class _FuncBuilder:
+    def __init__(self, globals):
+        self.names = []
+        self.src = []
+        self.globals = globals
+        self.locals = {}
+        self.overwrite_errors = {}
+        self.unconditional_adds = {}
+
+    def add_fn(self, name, args, body, *, locals=None, return_type=MISSING,
+               overwrite_error=False, unconditional_add=False, decorator=None):
+        if locals is not None:
+            self.locals.update(locals)
+
+        # Keep track if this method is allowed to be overwritten if it already
+        # exists in the class.  The error is method-specific, so keep it with
+        # the name.  We'll use this when we generate all of the functions in
+        # the add_fns_to_class call.  overwrite_error is either True, in which
+        # case we'll raise an error, or it's a string, in which case we'll
+        # raise an error and append this string.
+        if overwrite_error:
+            self.overwrite_errors[name] = overwrite_error
+
+        # Should this function always overwrite anything that's already in the
+        # class?  The default is to not overwrite a function that already
+        # exists.
+        if unconditional_add:
+            self.unconditional_adds[name] = True
+
+        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 = ''
+        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}')
 
-    @functools.wraps(user_function)
-    def wrapper(self):
-        key = id(self), _thread.get_ident()
-        if key in repr_running:
-            return '...'
-        repr_running.add(key)
-        try:
-            result = user_function(self)
-        finally:
-            repr_running.discard(key)
-        return result
-    return wrapper
-
-
-def _create_fn(name, args, body, *, globals=None, locals=None,
-               return_type=MISSING):
-    # Note that we may mutate locals. Callers beware!
-    # The only callers are internal to this module, so no
-    # worries about external callers.
-    if locals is None:
-        locals = {}
-    return_annotation = ''
-    if return_type is not MISSING:
-        locals['_return_type'] = return_type
-        return_annotation = '->_return_type'
-    args = ','.join(args)
-    body = '\n'.join(f'  {b}' for b in body)
-
-    # Compute the text of the entire function.
-    txt = f' def {name}({args}){return_annotation}:\n{body}'
-
-    local_vars = ', '.join(locals.keys())
-    txt = f"def __create_fn__({local_vars}):\n{txt}\n return {name}"
-    ns = {}
-    exec(txt, globals, ns)
-    return ns['__create_fn__'](**locals)
+    def add_fns_to_class(self, cls):
+        # The source to all of the functions we're generating.
+        fns_src = '\n'.join(self.src)
+
+        # The locals they use.
+        local_vars = ','.join(self.locals.keys())
+
+        # The names of all of the functions, used for the return value of the
+        # outer function.  Need to handle the 0-tuple specially.
+        if len(self.names) == 0:
+            return_names = '()'
+        else:
+            return_names  =f'({",".join(self.names)},)'
+
+        # txt is the entire function we're going to execute, including the
+        # bodies of the functions we're defining.  Here's a greatly simplified
+        # version:
+        # def __create_fn__():
+        #  def __init__(self, x, y):
+        #   self.x = x
+        #   self.y = y
+        #  @recursive_repr
+        #  def __repr__(self):
+        #   return f"cls(x={self.x!r},y={self.y!r})"
+        # return __init__,__repr__
+
+        txt = f"def __create_fn__({local_vars}):\n{fns_src}\n return {return_names}"
+        ns = {}
+        exec(txt, self.globals, ns)
+        fns = ns['__create_fn__'](**self.locals)
+
+        # 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__}"
+            if self.unconditional_adds.get(name, False):
+                setattr(cls, name, fn)
+            else:
+                already_exists = _set_new_attribute(cls, name, fn)
+
+                # See if it's an error to overwrite this particular function.
+                if already_exists and (msg_extra := self.overwrite_errors.get(name)):
+                    error_msg = (f'Cannot overwrite attribute {fn.__name__} '
+                                 f'in class {cls.__name__}')
+                    if not msg_extra is True:
+                        error_msg = f'{error_msg} {msg_extra}'
+
+                    raise TypeError(error_msg)
 
 
 def _field_assign(frozen, name, value, self_name):
@@ -441,22 +524,22 @@ def _field_assign(frozen, name, value, self_name):
     # self_name is what "self" is called in this function: don't
     # hard-code "self", since that might be a field name.
     if frozen:
-        return f'__dataclass_builtins_object__.__setattr__({self_name},{name!r},{value})'
-    return f'{self_name}.{name}={value}'
+        return f'  __dataclass_builtins_object__.__setattr__({self_name},{name!r},{value})'
+    return f'  {self_name}.{name}={value}'
 
 
 def _field_init(f, frozen, globals, self_name, slots):
     # Return the text of the line in the body of __init__ that will
     # initialize this field.
 
-    default_name = f'_dflt_{f.name}'
+    default_name = f'__dataclass_dflt_{f.name}__'
     if f.default_factory is not MISSING:
         if f.init:
             # This field has a default factory.  If a parameter is
             # given, use it.  If not, call the factory.
             globals[default_name] = f.default_factory
             value = (f'{default_name}() '
-                     f'if {f.name} is _HAS_DEFAULT_FACTORY '
+                     f'if {f.name} is __dataclass_HAS_DEFAULT_FACTORY__ '
                      f'else {f.name}')
         else:
             # This is a field that's not in the __init__ params, but
@@ -517,15 +600,15 @@ def _init_param(f):
     elif f.default is not MISSING:
         # There's a default, this will be the name that's used to look
         # it up.
-        default = f'=_dflt_{f.name}'
+        default = f'=__dataclass_dflt_{f.name}__'
     elif f.default_factory is not MISSING:
         # There's a factory function.  Set a marker.
-        default = '=_HAS_DEFAULT_FACTORY'
-    return f'{f.name}:_type_{f.name}{default}'
+        default = '=__dataclass_HAS_DEFAULT_FACTORY__'
+    return f'{f.name}:__dataclass_type_{f.name}__{default}'
 
 
 def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
-             self_name, globals, slots):
+             self_name, func_builder, slots):
     # fields contains both real fields and InitVar pseudo-fields.
 
     # Make sure we don't have fields without defaults following fields
@@ -534,22 +617,21 @@ def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
     # message, and future-proofs us in case we build up the function
     # using ast.
 
-    seen_default = False
+    seen_default = None
     for f in std_fields:
         # Only consider the non-kw-only fields in the __init__ call.
         if f.init:
             if not (f.default is MISSING and f.default_factory is MISSING):
-                seen_default = True
+                seen_default = f
             elif seen_default:
                 raise TypeError(f'non-default argument {f.name!r} '
-                                'follows default argument')
+                                f'follows default argument {seen_default.name!r}')
 
-    locals = {f'_type_{f.name}': f.type for f in fields}
-    locals.update({
-        'MISSING': MISSING,
-        '_HAS_DEFAULT_FACTORY': _HAS_DEFAULT_FACTORY,
-        '__dataclass_builtins_object__': object,
-    })
+    locals = {**{f'__dataclass_type_{f.name}__': f.type for f in fields},
+              **{'__dataclass_HAS_DEFAULT_FACTORY__': _HAS_DEFAULT_FACTORY,
+                 '__dataclass_builtins_object__': object,
+                 }
+              }
 
     body_lines = []
     for f in fields:
@@ -563,11 +645,11 @@ def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
     if has_post_init:
         params_str = ','.join(f.name for f in fields
                               if f._field_type is _FIELD_INITVAR)
-        body_lines.append(f'{self_name}.{_POST_INIT_NAME}({params_str})')
+        body_lines.append(f'  {self_name}.{_POST_INIT_NAME}({params_str})')
 
     # If no body lines, use 'pass'.
     if not body_lines:
-        body_lines = ['pass']
+        body_lines = ['  pass']
 
     _init_params = [_init_param(f) for f in std_fields]
     if kw_only_fields:
@@ -576,70 +658,34 @@ def _init_fn(fields, std_fields, kw_only_fields, frozen, has_post_init,
         # (instead of just concatenting the lists together).
         _init_params += ['*']
         _init_params += [_init_param(f) for f in kw_only_fields]
-    return _create_fn('__init__',
-                      [self_name] + _init_params,
-                      body_lines,
-                      locals=locals,
-                      globals=globals,
-                      return_type=None)
-
-
-def _repr_fn(fields, globals):
-    fn = _create_fn('__repr__',
-                    ('self',),
-                    ['return self.__class__.__qualname__ + f"(' +
-                     ', '.join([f"{f.name}={{self.{f.name}!r}}"
-                                for f in fields]) +
-                     ')"'],
-                     globals=globals)
-    return _recursive_repr(fn)
-
-
-def _frozen_get_del_attr(cls, fields, globals):
+    func_builder.add_fn('__init__',
+                        [self_name] + _init_params,
+                        body_lines,
+                        locals=locals,
+                        return_type=None)
+
+
+def _frozen_get_del_attr(cls, fields, func_builder):
     locals = {'cls': cls,
               'FrozenInstanceError': FrozenInstanceError}
+    condition = 'type(self) is cls'
     if fields:
-        fields_str = '(' + ','.join(repr(f.name) for f in fields) + ',)'
-    else:
-        # Special case for the zero-length tuple.
-        fields_str = '()'
-    return (_create_fn('__setattr__',
-                      ('self', 'name', 'value'),
-                      (f'if type(self) is cls or name in {fields_str}:',
-                        ' raise FrozenInstanceError(f"cannot assign to field {name!r}")',
-                       f'super(cls, self).__setattr__(name, value)'),
-                       locals=locals,
-                       globals=globals),
-            _create_fn('__delattr__',
-                      ('self', 'name'),
-                      (f'if type(self) is cls or name in {fields_str}:',
-                        ' raise FrozenInstanceError(f"cannot delete field {name!r}")',
-                       f'super(cls, self).__delattr__(name)'),
-                       locals=locals,
-                       globals=globals),
-            )
-
-
-def _cmp_fn(name, op, self_tuple, other_tuple, globals):
-    # Create a comparison function.  If the fields in the object are
-    # named 'x' and 'y', then self_tuple is the string
-    # '(self.x,self.y)' and other_tuple is the string
-    # '(other.x,other.y)'.
-
-    return _create_fn(name,
-                      ('self', 'other'),
-                      [ 'if other.__class__ is self.__class__:',
-                       f' return {self_tuple}{op}{other_tuple}',
-                        'return NotImplemented'],
-                      globals=globals)
-
-
-def _hash_fn(fields, globals):
-    self_tuple = _tuple_str('self', fields)
-    return _create_fn('__hash__',
-                      ('self',),
-                      [f'return hash({self_tuple})'],
-                      globals=globals)
+        condition += ' or name in {' + ', '.join(repr(f.name) for f in fields) + '}'
+
+    func_builder.add_fn('__setattr__',
+                        ('self', 'name', 'value'),
+                        (f'  if {condition}:',
+                          '   raise FrozenInstanceError(f"cannot assign to field {name!r}")',
+                         f'  super(cls, self).__setattr__(name, value)'),
+                        locals=locals,
+                        overwrite_error=True)
+    func_builder.add_fn('__delattr__',
+                        ('self', 'name'),
+                        (f'  if {condition}:',
+                          '   raise FrozenInstanceError(f"cannot delete field {name!r}")',
+                         f'  super(cls, self).__delattr__(name)'),
+                        locals=locals,
+                        overwrite_error=True)
 
 
 def _is_classvar(a_type, typing):
@@ -807,26 +853,20 @@ def _get_field(cls, a_name, a_type, default_kw_only):
             raise TypeError(f'field {f.name} is a ClassVar but specifies '
                             'kw_only')
 
-    # For real fields, disallow mutable defaults for known types.
-    if f._field_type is _FIELD and isinstance(f.default, (list, dict, set)):
+    # For real fields, disallow mutable defaults.  Use unhashable as a proxy
+    # indicator for mutability.  Read the __hash__ attribute from the class,
+    # not the instance.
+    if f._field_type is _FIELD and f.default.__class__.__hash__ is None:
         raise ValueError(f'mutable default {type(f.default)} for field '
                          f'{f.name} is not allowed: use default_factory')
 
     return f
 
-def _set_qualname(cls, value):
-    # Ensure that the functions returned from _create_fn uses the proper
-    # __qualname__ (the class they belong to).
-    if isinstance(value, FunctionType):
-        value.__qualname__ = f"{cls.__qualname__}.{value.__name__}"
-    return value
-
 def _set_new_attribute(cls, name, value):
     # Never overwrites an existing attribute.  Returns True if the
     # attribute already exists.
     if name in cls.__dict__:
         return True
-    _set_qualname(cls, value)
     setattr(cls, name, value)
     return False
 
@@ -836,14 +876,22 @@ def _set_new_attribute(cls, name, value):
 # take.  The common case is to do nothing, so instead of providing a
 # function that is a no-op, use None to signify that.
 
-def _hash_set_none(cls, fields, globals):
-    return None
+def _hash_set_none(cls, fields, func_builder):
+    # It's sort of a hack that I'm setting this here, instead of at
+    # func_builder.add_fns_to_class time, but since this is an exceptional case
+    # (it's not setting an attribute to a function, but to a scalar value),
+    # just do it directly here.  I might come to regret this.
+    cls.__hash__ = None
 
-def _hash_add(cls, fields, globals):
+def _hash_add(cls, fields, func_builder):
     flds = [f for f in fields if (f.compare if f.hash is None else f.hash)]
-    return _set_qualname(cls, _hash_fn(flds, globals))
+    self_tuple = _tuple_str('self', flds)
+    func_builder.add_fn('__hash__',
+                        ('self',),
+                        [f'  return hash({self_tuple})'],
+                        unconditional_add=True)
 
-def _hash_exception(cls, fields, globals):
+def _hash_exception(cls, fields, func_builder):
     # Raise an exception.
     raise TypeError(f'Cannot overwrite attribute __hash__ '
                     f'in class {cls.__name__}')
@@ -879,7 +927,7 @@ def _hash_exception(cls, fields, globals):
 
 
 def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
-                   match_args, kw_only, slots):
+                   match_args, kw_only, slots, weakref_slot):
     # Now that dicts retain insertion order, there's no reason to use
     # an ordered dict.  I am leveraging that ordering here, because
     # derived class fields overwrite base class fields, but the order
@@ -897,13 +945,18 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
         globals = {}
 
     setattr(cls, _PARAMS, _DataclassParams(init, repr, eq, order,
-                                           unsafe_hash, frozen))
+                                           unsafe_hash, frozen,
+                                           match_args, kw_only,
+                                           slots, weakref_slot))
 
     # Find our base classes in reverse MRO order, and exclude
     # ourselves.  In reversed order so that more derived classes
     # override earlier field definitions in base classes.  As long as
-    # we're iterating over them, see if any are frozen.
+    # we're iterating over them, see if all or any of them are frozen.
     any_frozen_base = False
+    # By default `all_frozen_bases` is `None` to represent a case,
+    # where some dataclasses does not have any bases with `_FIELDS`
+    all_frozen_bases = None
     has_dataclass_bases = False
     for b in cls.__mro__[-1:0:-1]:
         # Only process classes that have been processed by our
@@ -913,13 +966,13 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
             has_dataclass_bases = True
             for f in base_fields.values():
                 fields[f.name] = f
-            if getattr(b, _PARAMS).frozen:
-                any_frozen_base = True
+            if all_frozen_bases is None:
+                all_frozen_bases = True
+            current_frozen = getattr(b, _PARAMS).frozen
+            all_frozen_bases = all_frozen_bases and current_frozen
+            any_frozen_base = any_frozen_base or current_frozen
 
-    # Annotations that are defined in this class (not in base
-    # classes).  If __annotations__ isn't present, then this class
-    # adds no new annotations.  We use this to compute fields that are
-    # added by this class.
+    # Annotations defined specifically in this class (not in base classes).
     #
     # Fields are found from cls_annotations, which is guaranteed to be
     # ordered.  Default values are from class attributes, if a field
@@ -928,7 +981,7 @@ 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 = cls.__dict__.get('__annotations__', {})
+    cls_annotations = inspect.get_annotations(cls)
 
     # Now find fields in our class.  While doing so, validate some
     # things, and set the default values (as class attributes) where
@@ -986,7 +1039,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
                             'frozen one')
 
         # Raise an exception if we're frozen, but none of our bases are.
-        if not any_frozen_base and frozen:
+        if all_frozen_bases is False and frozen:
             raise TypeError('cannot inherit frozen dataclass from a '
                             'non-frozen one')
 
@@ -997,7 +1050,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
     # Was this class defined with an explicit __hash__?  Note that if
     # __eq__ is defined in this class, then python will automatically
     # set __hash__ to None.  This is a heuristic, as it's possible
-    # that such a __hash__ == None was not auto-generated, but it
+    # that such a __hash__ == None was not auto-generated, but it's
     # close enough.
     class_hash = cls.__dict__.get('__hash__', MISSING)
     has_explicit_hash = not (class_hash is MISSING or
@@ -1016,24 +1069,27 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
     (std_init_fields,
      kw_only_init_fields) = _fields_in_init_order(all_init_fields)
 
+    func_builder = _FuncBuilder(globals)
+
     if init:
         # Does this class have a post-init function?
         has_post_init = hasattr(cls, _POST_INIT_NAME)
 
-        _set_new_attribute(cls, '__init__',
-                           _init_fn(all_init_fields,
-                                    std_init_fields,
-                                    kw_only_init_fields,
-                                    frozen,
-                                    has_post_init,
-                                    # The name to use for the "self"
-                                    # param in __init__.  Use "self"
-                                    # if possible.
-                                    '__dataclass_self__' if 'self' in fields
-                                            else 'self',
-                                    globals,
-                                    slots,
-                          ))
+        _init_fn(all_init_fields,
+                 std_init_fields,
+                 kw_only_init_fields,
+                 frozen,
+                 has_post_init,
+                 # The name to use for the "self"
+                 # param in __init__.  Use "self"
+                 # if possible.
+                 '__dataclass_self__' if 'self' in fields
+                 else 'self',
+                 func_builder,
+                 slots,
+                 )
+
+    _set_new_attribute(cls, '__replace__', _replace)
 
     # Get the fields as a list, and include only real fields.  This is
     # used in all of the following methods.
@@ -1041,18 +1097,27 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
 
     if repr:
         flds = [f for f in field_list if f.repr]
-        _set_new_attribute(cls, '__repr__', _repr_fn(flds, globals))
+        func_builder.add_fn('__repr__',
+                            ('self',),
+                            ['  return f"{self.__class__.__qualname__}(' +
+                             ', '.join([f"{f.name}={{self.{f.name}!r}}"
+                                        for f in flds]) + ')"'],
+                            locals={'__dataclasses_recursive_repr': recursive_repr},
+                            decorator="@__dataclasses_recursive_repr()")
 
     if eq:
         # Create __eq__ method.  There's no need for a __ne__ method,
         # since python will call __eq__ and negate it.
-        flds = [f for f in field_list if f.compare]
-        self_tuple = _tuple_str('self', flds)
-        other_tuple = _tuple_str('other', flds)
-        _set_new_attribute(cls, '__eq__',
-                           _cmp_fn('__eq__', '==',
-                                   self_tuple, other_tuple,
-                                   globals=globals))
+        cmp_fields = (field for field in field_list if field.compare)
+        terms = [f'self.{field.name}==other.{field.name}' for field in cmp_fields]
+        field_comparisons = ' and '.join(terms) or 'True'
+        func_builder.add_fn('__eq__',
+                            ('self', 'other'),
+                            [ '  if self is other:',
+                              '   return True',
+                              '  if other.__class__ is self.__class__:',
+                             f'   return {field_comparisons}',
+                              '  return NotImplemented'])
 
     if order:
         # Create and set the ordering methods.
@@ -1064,18 +1129,19 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
                          ('__gt__', '>'),
                          ('__ge__', '>='),
                          ]:
-            if _set_new_attribute(cls, name,
-                                  _cmp_fn(name, op, self_tuple, other_tuple,
-                                          globals=globals)):
-                raise TypeError(f'Cannot overwrite attribute {name} '
-                                f'in class {cls.__name__}. Consider using '
-                                'functools.total_ordering')
+            # Create a comparison function.  If the fields in the object are
+            # named 'x' and 'y', then self_tuple is the string
+            # '(self.x,self.y)' and other_tuple is the string
+            # '(other.x,other.y)'.
+            func_builder.add_fn(name,
+                            ('self', 'other'),
+                            [ '  if other.__class__ is self.__class__:',
+                             f'   return {self_tuple}{op}{other_tuple}',
+                              '  return NotImplemented'],
+                            overwrite_error='Consider using functools.total_ordering')
 
     if frozen:
-        for fn in _frozen_get_del_attr(cls, field_list, globals):
-            if _set_new_attribute(cls, fn.__name__, fn):
-                raise TypeError(f'Cannot overwrite attribute {fn.__name__} '
-                                f'in class {cls.__name__}')
+        _frozen_get_del_attr(cls, field_list, func_builder)
 
     # Decide if/how we're going to create a hash function.
     hash_action = _hash_action[bool(unsafe_hash),
@@ -1083,22 +1149,33 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
                                bool(frozen),
                                has_explicit_hash]
     if hash_action:
-        # No need to call _set_new_attribute here, since by the time
-        # we're here the overwriting is unconditional.
-        cls.__hash__ = hash_action(cls, field_list, globals)
+        cls.__hash__ = hash_action(cls, field_list, func_builder)
+
+    # Generate the methods and add them to the class.  This needs to be done
+    # before the __doc__ logic below, since inspect will look at the __init__
+    # signature.
+    func_builder.add_fns_to_class(cls)
 
     if not getattr(cls, '__doc__'):
         # Create a class doc-string.
-        cls.__doc__ = (cls.__name__ +
-                       str(inspect.signature(cls)).replace(' -> None', ''))
+        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', '')
+        except (TypeError, ValueError):
+            text_sig = ''
+        cls.__doc__ = (cls.__name__ + text_sig)
 
     if match_args:
-        # I could probably compute this once
+        # I could probably compute this once.
         _set_new_attribute(cls, '__match_args__',
                            tuple(f.name for f in std_init_fields))
 
+    # It's an error to specify weakref_slot if slots is False.
+    if weakref_slot and not slots:
+        raise TypeError('weakref_slot is True but slots is False')
     if slots:
-        cls = _add_slots(cls, frozen)
+        cls = _add_slots(cls, frozen, weakref_slot)
 
     abc.update_abstractmethods(cls)
 
@@ -1106,7 +1183,7 @@ def _process_class(cls, init, repr, eq, order, unsafe_hash, frozen,
 
 
 # _dataclass_getstate and _dataclass_setstate are needed for pickling frozen
-# classes with slots.  These could be slighly more performant if we generated
+# classes with slots.  These could be slightly more performant if we generated
 # the code instead of iterating over fields.  But that can be a project for
 # another day, if performance becomes an issue.
 def _dataclass_getstate(self):
@@ -1119,7 +1196,30 @@ def _dataclass_setstate(self, state):
         object.__setattr__(self, field.name, value)
 
 
-def _add_slots(cls, is_frozen):
+def _get_slots(cls):
+    match cls.__dict__.get('__slots__'):
+        # `__dictoffset__` and `__weakrefoffset__` can tell us whether
+        # the base type has dict/weakref slots, in a way that works correctly
+        # for both Python classes and C extension types. Extension types
+        # don't use `__slots__` for slot creation
+        case None:
+            slots = []
+            if getattr(cls, '__weakrefoffset__', -1) != 0:
+                slots.append('__weakref__')
+            if getattr(cls, '__dictoffset__', -1) != 0:
+                slots.append('__dict__')
+            yield from slots
+        case str(slot):
+            yield slot
+        # Slots may be any iterable, but we cannot handle an iterator
+        # because it will already be (partially) consumed.
+        case iterable if not hasattr(iterable, '__next__'):
+            yield from iterable
+        case _:
+            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.
 
@@ -1130,7 +1230,23 @@ def _add_slots(cls, is_frozen):
     # Create a new dict for our new class.
     cls_dict = dict(cls.__dict__)
     field_names = tuple(f.name for f in fields(cls))
-    cls_dict['__slots__'] = field_names
+    # Make sure slots don't overlap with those in base classes.
+    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 ()
+            )
+        ),
+    )
+
     for field_name in field_names:
         # Remove our attributes, if present. They'll still be
         #  available in _MARKER.
@@ -1139,6 +1255,9 @@ def _add_slots(cls, is_frozen):
     # 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)
@@ -1147,33 +1266,35 @@ def _add_slots(cls, is_frozen):
 
     if is_frozen:
         # Need this for pickling frozen classes with slots.
-        cls.__getstate__ = _dataclass_getstate
-        cls.__setstate__ = _dataclass_setstate
+        if '__getstate__' not in cls_dict:
+            cls.__getstate__ = _dataclass_getstate
+        if '__setstate__' not in cls_dict:
+            cls.__setstate__ = _dataclass_setstate
 
     return cls
 
 
 def dataclass(cls=None, /, *, init=True, repr=True, eq=True, order=False,
               unsafe_hash=False, frozen=False, match_args=True,
-              kw_only=False, slots=False):
-    """Returns the same class as was passed in, with dunder methods
-    added based on the fields defined in the class.
+              kw_only=False, slots=False, weakref_slot=False):
+    """Add dunder methods based on the fields defined in the class.
 
     Examines PEP 526 __annotations__ to determine fields.
 
-    If init is true, an __init__() method is added to the class. If
-    repr is true, a __repr__() method is added. If order is true, rich
+    If init is true, an __init__() method is added to the class. If repr
+    is true, a __repr__() method is added. If order is true, rich
     comparison dunder methods are added. If unsafe_hash is true, a
-    __hash__() method function is added. If frozen is true, fields may
-    not be assigned to after instance creation. If match_args is true,
-    the __match_args__ tuple is added. If kw_only is true, then by
-    default all fields are keyword-only. If slots is true, an
-    __slots__ attribute is added.
+    __hash__() method is added. If frozen is true, fields may not be
+    assigned to after instance creation. If match_args is true, the
+    __match_args__ tuple is added. If kw_only is true, then by default
+    all fields are keyword-only. If slots is true, a new class with a
+    __slots__ attribute is returned.
     """
 
     def wrap(cls):
         return _process_class(cls, init, repr, eq, order, unsafe_hash,
-                              frozen, match_args, kw_only, slots)
+                              frozen, match_args, kw_only, slots,
+                              weakref_slot)
 
     # See if we're being called as @dataclass or @dataclass().
     if cls is None:
@@ -1195,7 +1316,7 @@ def fields(class_or_instance):
     try:
         fields = getattr(class_or_instance, _FIELDS)
     except AttributeError:
-        raise TypeError('must be called with a dataclass type or instance')
+        raise TypeError('must be called with a dataclass type or instance') from None
 
     # Exclude pseudo-fields.  Note that fields is sorted by insertion
     # order, so the order of the tuple is as the fields were defined.
@@ -1210,7 +1331,7 @@ def _is_dataclass_instance(obj):
 def is_dataclass(obj):
     """Returns True if obj is a dataclass or an instance of a
     dataclass."""
-    cls = obj if isinstance(obj, type) and not isinstance(obj, GenericAlias) else type(obj)
+    cls = obj if isinstance(obj, type) else type(obj)
     return hasattr(cls, _FIELDS)
 
 
@@ -1218,7 +1339,7 @@ def asdict(obj, *, dict_factory=dict):
     """Return the fields of a dataclass instance as a new dictionary mapping
     field names to field values.
 
-    Example usage:
+    Example usage::
 
       @dataclass
       class C:
@@ -1231,7 +1352,7 @@ class C:
     If given, 'dict_factory' will be used instead of built-in dict.
     The function applies recursively to field values that are
     dataclass instances. This will also look into built-in containers:
-    tuples, lists, and dicts.
+    tuples, lists, and dicts. Other objects are copied with 'copy.deepcopy()'.
     """
     if not _is_dataclass_instance(obj):
         raise TypeError("asdict() should be called on dataclass instances")
@@ -1239,42 +1360,69 @@ class C:
 
 
 def _asdict_inner(obj, dict_factory):
-    if _is_dataclass_instance(obj):
-        result = []
-        for f in fields(obj):
-            value = _asdict_inner(getattr(obj, f.name), dict_factory)
-            result.append((f.name, value))
-        return dict_factory(result)
-    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
-        # obj is a namedtuple.  Recurse into it, but the returned
-        # object is another namedtuple of the same type.  This is
-        # similar to how other list- or tuple-derived classes are
-        # treated (see below), but we just need to create them
-        # differently because a namedtuple's __init__ needs to be
-        # called differently (see bpo-34363).
-
-        # I'm not using namedtuple's _asdict()
-        # method, because:
-        # - it does not recurse in to the namedtuple fields and
-        #   convert them to dicts (using dict_factory).
-        # - I don't actually want to return a dict here.  The main
-        #   use case here is json.dumps, and it handles converting
-        #   namedtuples to lists.  Admittedly we're losing some
-        #   information here when we produce a json list instead of a
-        #   dict.  Note that if we returned dicts here instead of
-        #   namedtuples, we could no longer call asdict() on a data
-        #   structure where a namedtuple was used as a dict key.
-
-        return type(obj)(*[_asdict_inner(v, dict_factory) for v in obj])
-    elif isinstance(obj, (list, tuple)):
+    obj_type = type(obj)
+    if obj_type in _ATOMIC_TYPES:
+        return obj
+    elif hasattr(obj_type, _FIELDS):
+        # dataclass instance: fast path for the common case
+        if dict_factory is dict:
+            return {
+                f.name: _asdict_inner(getattr(obj, f.name), dict)
+                for f in fields(obj)
+            }
+        else:
+            return dict_factory([
+                (f.name, _asdict_inner(getattr(obj, f.name), dict_factory))
+                for f in fields(obj)
+            ])
+    # handle the builtin types first for speed; subclasses handled below
+    elif obj_type is list:
+        return [_asdict_inner(v, dict_factory) for v in obj]
+    elif obj_type is dict:
+        return {
+            _asdict_inner(k, dict_factory): _asdict_inner(v, dict_factory)
+            for k, v in obj.items()
+        }
+    elif obj_type is tuple:
+        return tuple([_asdict_inner(v, dict_factory) for v in obj])
+    elif issubclass(obj_type, tuple):
+        if hasattr(obj, '_fields'):
+            # obj is a namedtuple.  Recurse into it, but the returned
+            # object is another namedtuple of the same type.  This is
+            # similar to how other list- or tuple-derived classes are
+            # treated (see below), but we just need to create them
+            # differently because a namedtuple's __init__ needs to be
+            # called differently (see bpo-34363).
+
+            # I'm not using namedtuple's _asdict()
+            # method, because:
+            # - it does not recurse in to the namedtuple fields and
+            #   convert them to dicts (using dict_factory).
+            # - I don't actually want to return a dict here.  The main
+            #   use case here is json.dumps, and it handles converting
+            #   namedtuples to lists.  Admittedly we're losing some
+            #   information here when we produce a json list instead of a
+            #   dict.  Note that if we returned dicts here instead of
+            #   namedtuples, we could no longer call asdict() on a data
+            #   structure where a namedtuple was used as a dict key.
+            return obj_type(*[_asdict_inner(v, dict_factory) for v in obj])
+        else:
+            return obj_type(_asdict_inner(v, dict_factory) for v in obj)
+    elif issubclass(obj_type, dict):
+        if hasattr(obj_type, 'default_factory'):
+            # obj is a defaultdict, which has a different constructor from
+            # dict as it requires the default_factory as its first arg.
+            result = obj_type(obj.default_factory)
+            for k, v in obj.items():
+                result[_asdict_inner(k, dict_factory)] = _asdict_inner(v, dict_factory)
+            return result
+        return obj_type((_asdict_inner(k, dict_factory),
+                         _asdict_inner(v, dict_factory))
+                        for k, v in obj.items())
+    elif issubclass(obj_type, list):
         # Assume we can create an object of this type by passing in a
-        # generator (which is not true for namedtuples, handled
-        # above).
-        return type(obj)(_asdict_inner(v, dict_factory) for v in obj)
-    elif isinstance(obj, dict):
-        return type(obj)((_asdict_inner(k, dict_factory),
-                          _asdict_inner(v, dict_factory))
-                         for k, v in obj.items())
+        # generator
+        return obj_type(_asdict_inner(v, dict_factory) for v in obj)
     else:
         return copy.deepcopy(obj)
 
@@ -1289,13 +1437,13 @@ class C:
           x: int
           y: int
 
-    c = C(1, 2)
-    assert astuple(c) == (1, 2)
+      c = C(1, 2)
+      assert astuple(c) == (1, 2)
 
     If given, 'tuple_factory' will be used instead of built-in tuple.
     The function applies recursively to field values that are
     dataclass instances. This will also look into built-in containers:
-    tuples, lists, and dicts.
+    tuples, lists, and dicts. Other objects are copied with 'copy.deepcopy()'.
     """
 
     if not _is_dataclass_instance(obj):
@@ -1304,12 +1452,13 @@ class C:
 
 
 def _astuple_inner(obj, tuple_factory):
-    if _is_dataclass_instance(obj):
-        result = []
-        for f in fields(obj):
-            value = _astuple_inner(getattr(obj, f.name), tuple_factory)
-            result.append(value)
-        return tuple_factory(result)
+    if type(obj) in _ATOMIC_TYPES:
+        return obj
+    elif _is_dataclass_instance(obj):
+        return tuple_factory([
+            _astuple_inner(getattr(obj, f.name), tuple_factory)
+            for f in fields(obj)
+        ])
     elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
         # obj is a namedtuple.  Recurse into it, but the returned
         # object is another namedtuple of the same type.  This is
@@ -1324,7 +1473,15 @@ def _astuple_inner(obj, tuple_factory):
         # above).
         return type(obj)(_astuple_inner(v, tuple_factory) for v in obj)
     elif isinstance(obj, dict):
-        return type(obj)((_astuple_inner(k, tuple_factory), _astuple_inner(v, tuple_factory))
+        obj_type = type(obj)
+        if hasattr(obj_type, 'default_factory'):
+            # obj is a defaultdict, which has a different constructor from
+            # dict as it requires the default_factory as its first arg.
+            result = obj_type(getattr(obj, 'default_factory'))
+            for k, v in obj.items():
+                result[_astuple_inner(k, tuple_factory)] = _astuple_inner(v, tuple_factory)
+            return result
+        return obj_type((_astuple_inner(k, tuple_factory), _astuple_inner(v, tuple_factory))
                           for k, v in obj.items())
     else:
         return copy.deepcopy(obj)
@@ -1332,17 +1489,18 @@ 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):
+                   frozen=False, match_args=True, kw_only=False, slots=False,
+                   weakref_slot=False, module=None):
     """Return a new dynamically created dataclass.
 
     The dataclass name will be 'cls_name'.  'fields' is an iterable
     of either (name), (name, type) or (name, type, Field) objects. If type is
     omitted, use the string 'typing.Any'.  Field objects are created by
-    the equivalent of calling 'field(name, type [, Field-info])'.
+    the equivalent of calling 'field(name, type [, Field-info])'.::
 
       C = make_dataclass('C', ['x', ('y', int), ('z', int, field(init=False))], bases=(Base,))
 
-    is equivalent to:
+    is equivalent to::
 
       @dataclass
       class C(Base):
@@ -1352,8 +1510,11 @@ class C(Base):
 
     For the bases and namespace parameters, see the builtin type() function.
 
-    The parameters init, repr, eq, order, unsafe_hash, and frozen are passed to
-    dataclass().
+    The parameters init, repr, eq, order, unsafe_hash, frozen, match_args, kw_only,
+    slots, and weakref_slot are passed to dataclass().
+
+    If module parameter is defined, the '__module__' attribute of the dataclass is
+    set to that value.
     """
 
     if namespace is None:
@@ -1396,16 +1557,30 @@ def exec_body_callback(ns):
     # of generic dataclasses.
     cls = types.new_class(cls_name, bases, {}, exec_body_callback)
 
+    # For pickling to work, the __module__ variable needs to be set to the frame
+    # where the dataclass is created.
+    if module is None:
+        try:
+            module = sys._getframemodulename(1) or '__main__'
+        except AttributeError:
+            try:
+                module = sys._getframe(1).f_globals.get('__name__', '__main__')
+            except (AttributeError, ValueError):
+                pass
+    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)
+                     match_args=match_args, kw_only=kw_only, slots=slots,
+                     weakref_slot=weakref_slot)
 
 
 def replace(obj, /, **changes):
     """Return a new object replacing specified fields with new values.
 
-    This is especially useful for frozen classes.  Example usage:
+    This is especially useful for frozen classes.  Example usage::
 
       @dataclass(frozen=True)
       class C:
@@ -1415,18 +1590,20 @@ class C:
       c = C(1, 2)
       c1 = replace(c, x=3)
       assert c1.x == 3 and c1.y == 2
-      """
-
-    # We're going to mutate 'changes', but that's okay because it's a
-    # new dict, even if called with 'replace(obj, **my_changes)'.
-
+    """
     if not _is_dataclass_instance(obj):
         raise TypeError("replace() should be called on dataclass instances")
+    return _replace(obj, **changes)
+
+
+def _replace(self, /, **changes):
+    # We're going to mutate 'changes', but that's okay because it's a
+    # new dict, even if called with 'replace(self, **my_changes)'.
 
     # It's an error to have init=False fields in 'changes'.
-    # If a field is not in 'changes', read its value from the provided obj.
+    # If a field is not in 'changes', read its value from the provided 'self'.
 
-    for f in getattr(obj, _FIELDS).values():
+    for f in getattr(self, _FIELDS).values():
         # Only consider normal fields or InitVars.
         if f._field_type is _FIELD_CLASSVAR:
             continue
@@ -1434,20 +1611,20 @@ class C:
         if not f.init:
             # Error if this field is specified in changes.
             if f.name in changes:
-                raise ValueError(f'field {f.name} is declared with '
-                                 'init=False, it cannot be specified with '
-                                 'replace()')
+                raise TypeError(f'field {f.name} is declared with '
+                                f'init=False, it cannot be specified with '
+                                f'replace()')
             continue
 
         if f.name not in changes:
             if f._field_type is _FIELD_INITVAR and f.default is MISSING:
-                raise ValueError(f"InitVar {f.name!r} "
-                                 'must be specified with replace()')
-            changes[f.name] = getattr(obj, f.name)
+                raise TypeError(f"InitVar {f.name!r} "
+                                f'must be specified with replace()')
+            changes[f.name] = getattr(self, f.name)
 
     # Create the new object, which calls __init__() and
     # __post_init__() (if defined), using all of the init fields we've
     # added and/or left in 'changes'.  If there are values supplied in
     # changes that aren't fields, this will correctly raise a
     # TypeError.
-    return obj.__class__(**changes)
+    return self.__class__(**changes)
diff --git a/Lib/dbm/__init__.py b/Lib/dbm/__init__.py
index f65da521af..4fdbc54e74 100644
--- a/Lib/dbm/__init__.py
+++ b/Lib/dbm/__init__.py
@@ -5,7 +5,7 @@
         import dbm
         d = dbm.open(file, 'w', 0o666)
 
-The returned object is a dbm.gnu, dbm.ndbm or dbm.dumb object, dependent on the
+The returned object is a dbm.sqlite3, dbm.gnu, dbm.ndbm or dbm.dumb database object, dependent on the
 type of database being opened (determined by the whichdb function) in the case
 of an existing dbm. If the dbm does not exist and the create or new flag ('c'
 or 'n') was specified, the dbm type will be determined by the availability of
@@ -38,7 +38,7 @@
 class error(Exception):
     pass
 
-_names = ['dbm.gnu', 'dbm.ndbm', 'dbm.dumb']
+_names = ['dbm.sqlite3', 'dbm.gnu', 'dbm.ndbm', 'dbm.dumb']
 _defaultmod = None
 _modules = {}
 
@@ -109,17 +109,18 @@ def whichdb(filename):
     """
 
     # Check for ndbm first -- this has a .pag and a .dir file
+    filename = os.fsencode(filename)
     try:
-        f = io.open(filename + ".pag", "rb")
+        f = io.open(filename + b".pag", "rb")
         f.close()
-        f = io.open(filename + ".dir", "rb")
+        f = io.open(filename + b".dir", "rb")
         f.close()
         return "dbm.ndbm"
     except OSError:
         # some dbm emulations based on Berkeley DB generate a .db file
         # some do not, but they should be caught by the bsd checks
         try:
-            f = io.open(filename + ".db", "rb")
+            f = io.open(filename + b".db", "rb")
             f.close()
             # guarantee we can actually open the file using dbm
             # kind of overkill, but since we are dealing with emulations
@@ -134,12 +135,12 @@ def whichdb(filename):
     # Check for dumbdbm next -- this has a .dir and a .dat file
     try:
         # First check for presence of files
-        os.stat(filename + ".dat")
-        size = os.stat(filename + ".dir").st_size
+        os.stat(filename + b".dat")
+        size = os.stat(filename + b".dir").st_size
         # dumbdbm files with no keys are empty
         if size == 0:
             return "dbm.dumb"
-        f = io.open(filename + ".dir", "rb")
+        f = io.open(filename + b".dir", "rb")
         try:
             if f.read(1) in (b"'", b'"'):
                 return "dbm.dumb"
@@ -163,6 +164,10 @@ def whichdb(filename):
     if len(s) != 4:
         return ""
 
+    # Check for SQLite3 header string.
+    if s16 == b"SQLite format 3\0":
+        return "dbm.sqlite3"
+
     # Convert to 4-byte int in native byte order -- return "" if impossible
     try:
         (magic,) = struct.unpack("=l", s)
diff --git a/Lib/dbm/dumb.py b/Lib/dbm/dumb.py
index 864ad371ec..def120ffc3 100644
--- a/Lib/dbm/dumb.py
+++ b/Lib/dbm/dumb.py
@@ -46,6 +46,7 @@ class _Database(collections.abc.MutableMapping):
     _io = _io       # for _commit()
 
     def __init__(self, filebasename, mode, flag='c'):
+        filebasename = self._os.fsencode(filebasename)
         self._mode = mode
         self._readonly = (flag == 'r')
 
@@ -54,14 +55,14 @@ def __init__(self, filebasename, mode, flag='c'):
         # where key is the string key, pos is the offset into the dat
         # file of the associated value's first byte, and siz is the number
         # of bytes in the associated value.
-        self._dirfile = filebasename + '.dir'
+        self._dirfile = filebasename + b'.dir'
 
         # The data file is a binary file pointed into by the directory
         # file, and holds the values associated with keys.  Each value
         # begins at a _BLOCKSIZE-aligned byte offset, and is a raw
         # binary 8-bit string value.
-        self._datfile = filebasename + '.dat'
-        self._bakfile = filebasename + '.bak'
+        self._datfile = filebasename + b'.dat'
+        self._bakfile = filebasename + b'.bak'
 
         # The index is an in-memory dict, mirroring the directory file.
         self._index = None  # maps keys to (pos, siz) pairs
@@ -97,7 +98,8 @@ def _update(self, flag):
         except OSError:
             if flag not in ('c', 'n'):
                 raise
-            self._modified = True
+            with self._io.open(self._dirfile, 'w', encoding="Latin-1") as f:
+                self._chmod(self._dirfile)
         else:
             with f:
                 for line in f:
@@ -133,6 +135,7 @@ def _commit(self):
                 # position; UTF-8, though, does care sometimes.
                 entry = "%r, %r\n" % (key.decode('Latin-1'), pos_and_siz_pair)
                 f.write(entry)
+        self._modified = False
 
     sync = _commit
 
diff --git a/Lib/dbm/gnu.py b/Lib/dbm/gnu.py
new file mode 100644
index 0000000000..b07a1defff
--- /dev/null
+++ b/Lib/dbm/gnu.py
@@ -0,0 +1,3 @@
+"""Provide the _gdbm module as a dbm submodule."""
+
+from _gdbm import *
diff --git a/Lib/dbm/ndbm.py b/Lib/dbm/ndbm.py
new file mode 100644
index 0000000000..23056a29ef
--- /dev/null
+++ b/Lib/dbm/ndbm.py
@@ -0,0 +1,3 @@
+"""Provide the _dbm module as a dbm submodule."""
+
+from _dbm import *
diff --git a/Lib/dbm/sqlite3.py b/Lib/dbm/sqlite3.py
new file mode 100644
index 0000000000..d0eed54e0f
--- /dev/null
+++ b/Lib/dbm/sqlite3.py
@@ -0,0 +1,144 @@
+import os
+import sqlite3
+from pathlib import Path
+from contextlib import suppress, closing
+from collections.abc import MutableMapping
+
+BUILD_TABLE = """
+  CREATE TABLE IF NOT EXISTS Dict (
+    key BLOB UNIQUE NOT NULL,
+    value BLOB NOT NULL
+  )
+"""
+GET_SIZE = "SELECT COUNT (key) FROM Dict"
+LOOKUP_KEY = "SELECT value FROM Dict WHERE key = CAST(? AS BLOB)"
+STORE_KV = "REPLACE INTO Dict (key, value) VALUES (CAST(? AS BLOB), CAST(? AS BLOB))"
+DELETE_KEY = "DELETE FROM Dict WHERE key = CAST(? AS BLOB)"
+ITER_KEYS = "SELECT key FROM Dict"
+
+
+class error(OSError):
+    pass
+
+
+_ERR_CLOSED = "DBM object has already been closed"
+_ERR_REINIT = "DBM object does not support reinitialization"
+
+
+def _normalize_uri(path):
+    path = Path(path)
+    uri = path.absolute().as_uri()
+    while "//" in uri:
+        uri = uri.replace("//", "/")
+    return uri
+
+
+class _Database(MutableMapping):
+
+    def __init__(self, path, /, *, flag, mode):
+        if hasattr(self, "_cx"):
+            raise error(_ERR_REINIT)
+
+        path = os.fsdecode(path)
+        match flag:
+            case "r":
+                flag = "ro"
+            case "w":
+                flag = "rw"
+            case "c":
+                flag = "rwc"
+                Path(path).touch(mode=mode, exist_ok=True)
+            case "n":
+                flag = "rwc"
+                Path(path).unlink(missing_ok=True)
+                Path(path).touch(mode=mode)
+            case _:
+                raise ValueError("Flag must be one of 'r', 'w', 'c', or 'n', "
+                                 f"not {flag!r}")
+
+        # We use the URI format when opening the database.
+        uri = _normalize_uri(path)
+        uri = f"{uri}?mode={flag}"
+        if flag == "ro":
+            # Add immutable=1 to allow read-only SQLite access even if wal/shm missing
+            uri += "&immutable=1"
+
+        try:
+            self._cx = sqlite3.connect(uri, autocommit=True, uri=True)
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+        if flag != "ro":
+            # This is an optimization only; it's ok if it fails.
+            with suppress(sqlite3.OperationalError):
+                self._cx.execute("PRAGMA journal_mode = wal")
+
+            if flag == "rwc":
+                self._execute(BUILD_TABLE)
+
+    def _execute(self, *args, **kwargs):
+        if not self._cx:
+            raise error(_ERR_CLOSED)
+        try:
+            return closing(self._cx.execute(*args, **kwargs))
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+    def __len__(self):
+        with self._execute(GET_SIZE) as cu:
+            row = cu.fetchone()
+        return row[0]
+
+    def __getitem__(self, key):
+        with self._execute(LOOKUP_KEY, (key,)) as cu:
+            row = cu.fetchone()
+        if not row:
+            raise KeyError(key)
+        return row[0]
+
+    def __setitem__(self, key, value):
+        self._execute(STORE_KV, (key, value))
+
+    def __delitem__(self, key):
+        with self._execute(DELETE_KEY, (key,)) as cu:
+            if not cu.rowcount:
+                raise KeyError(key)
+
+    def __iter__(self):
+        try:
+            with self._execute(ITER_KEYS) as cu:
+                for row in cu:
+                    yield row[0]
+        except sqlite3.Error as exc:
+            raise error(str(exc))
+
+    def close(self):
+        if self._cx:
+            self._cx.close()
+            self._cx = None
+
+    def keys(self):
+        return list(super().keys())
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+def open(filename, /, flag="r", mode=0o666):
+    """Open a dbm.sqlite3 database and return the dbm object.
+
+    The 'filename' parameter is the name of the database file.
+
+    The optional 'flag' parameter can be one of ...:
+        'r' (default): open an existing database for read only access
+        'w': open an existing database for read/write access
+        'c': create a database if it does not exist; open for read/write access
+        'n': always create a new, empty database; open for read/write access
+
+    The optional 'mode' parameter is the Unix file access mode of the database;
+    only used when creating a new database. Default: 0o666.
+    """
+    return _Database(filename, flag=flag, mode=mode)
diff --git a/Lib/decimal.py b/Lib/decimal.py
index 7746ea2601..ee3147f5dd 100644
--- a/Lib/decimal.py
+++ b/Lib/decimal.py
@@ -1,11 +1,109 @@
+"""Decimal fixed-point and floating-point arithmetic.
+
+This is an implementation of decimal floating-point arithmetic based on
+the General Decimal Arithmetic Specification:
+
+    http://speleotrove.com/decimal/decarith.html
+
+and IEEE standard 854-1987:
+
+    http://en.wikipedia.org/wiki/IEEE_854-1987
+
+Decimal floating point has finite precision with arbitrarily large bounds.
+
+The purpose of this module is to support arithmetic using familiar
+"schoolhouse" rules and to avoid some of the tricky representation
+issues associated with binary floating point.  The package is especially
+useful for financial applications or for contexts where users have
+expectations that are at odds with binary floating point (for instance,
+in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead
+of 0.0; Decimal('1.00') % Decimal('0.1') returns the expected
+Decimal('0.00')).
+
+Here are some examples of using the decimal module:
+
+>>> from decimal import *
+>>> setcontext(ExtendedContext)
+>>> Decimal(0)
+Decimal('0')
+>>> Decimal('1')
+Decimal('1')
+>>> Decimal('-.0123')
+Decimal('-0.0123')
+>>> Decimal(123456)
+Decimal('123456')
+>>> Decimal('123.45e12345678')
+Decimal('1.2345E+12345680')
+>>> Decimal('1.33') + Decimal('1.27')
+Decimal('2.60')
+>>> Decimal('12.34') + Decimal('3.87') - Decimal('18.41')
+Decimal('-2.20')
+>>> dig = Decimal(1)
+>>> print(dig / Decimal(3))
+0.333333333
+>>> getcontext().prec = 18
+>>> print(dig / Decimal(3))
+0.333333333333333333
+>>> print(dig.sqrt())
+1
+>>> print(Decimal(3).sqrt())
+1.73205080756887729
+>>> print(Decimal(3) ** 123)
+4.85192780976896427E+58
+>>> inf = Decimal(1) / Decimal(0)
+>>> print(inf)
+Infinity
+>>> neginf = Decimal(-1) / Decimal(0)
+>>> print(neginf)
+-Infinity
+>>> print(neginf + inf)
+NaN
+>>> print(neginf * inf)
+-Infinity
+>>> print(dig / 0)
+Infinity
+>>> getcontext().traps[DivisionByZero] = 1
+>>> print(dig / 0)
+Traceback (most recent call last):
+  ...
+  ...
+  ...
+decimal.DivisionByZero: x / 0
+>>> c = Context()
+>>> c.traps[InvalidOperation] = 0
+>>> print(c.flags[InvalidOperation])
+0
+>>> c.divide(Decimal(0), Decimal(0))
+Decimal('NaN')
+>>> c.traps[InvalidOperation] = 1
+>>> print(c.flags[InvalidOperation])
+1
+>>> c.flags[InvalidOperation] = 0
+>>> print(c.flags[InvalidOperation])
+0
+>>> print(c.divide(Decimal(0), Decimal(0)))
+Traceback (most recent call last):
+  ...
+  ...
+  ...
+decimal.InvalidOperation: 0 / 0
+>>> print(c.flags[InvalidOperation])
+1
+>>> c.flags[InvalidOperation] = 0
+>>> c.traps[InvalidOperation] = 0
+>>> print(c.divide(Decimal(0), Decimal(0)))
+NaN
+>>> print(c.flags[InvalidOperation])
+1
+>>>
+"""
 
 try:
     from _decimal import *
-    from _decimal import __doc__
     from _decimal import __version__
     from _decimal import __libmpdec_version__
 except ImportError:
-    from _pydecimal import *
-    from _pydecimal import __doc__
-    from _pydecimal import __version__
-    from _pydecimal import __libmpdec_version__
+    import _pydecimal
+    import sys
+    _pydecimal.__doc__ = __doc__
+    sys.modules[__name__] = _pydecimal
diff --git a/Lib/difflib.py b/Lib/difflib.py
index 3425e438c9..33e7e6c165 100644
--- a/Lib/difflib.py
+++ b/Lib/difflib.py
@@ -1200,6 +1200,25 @@ def context_diff(a, b, fromfile='', tofile='',
     strings for 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'.
     The modification times are normally expressed in the ISO 8601 format.
     If not specified, the strings default to blanks.
+
+    Example:
+
+    >>> print(''.join(context_diff('one\ntwo\nthree\nfour\n'.splitlines(True),
+    ...       'zero\none\ntree\nfour\n'.splitlines(True), 'Original', 'Current')),
+    ...       end="")
+    *** Original
+    --- Current
+    ***************
+    *** 1,4 ****
+      one
+    ! two
+    ! three
+      four
+    --- 1,4 ----
+    + zero
+      one
+    ! tree
+      four
     """
 
     _check_types(a, b, fromfile, tofile, fromfiledate, tofiledate, lineterm)
@@ -1609,7 +1628,7 @@ def _line_pair_iterator():
 </html>"""
 
 _styles = """
-        table.diff {font-family:Courier; border:medium;}
+        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 --git a/Lib/dis.py b/Lib/dis.py
index 53c85555bc..797e0f8a08 100644
--- a/Lib/dis.py
+++ b/Lib/dis.py
@@ -1,18 +1,1075 @@
-from _dis import *
+"""Disassembler of Python byte code into mnemonics."""
 
+import sys
+import types
+import collections
+import io
 
-# Disassembling a file by following cpython Lib/dis.py
-def _test():
-    """Simple test program to disassemble a file."""
+from opcode import *
+from opcode import (
+    __all__ as _opcodes_all,
+    _cache_format,
+    _inline_cache_entries,
+    _nb_ops,
+    _intrinsic_1_descs,
+    _intrinsic_2_descs,
+    _specializations,
+    _specialized_opmap,
+)
+
+from _opcode import get_executor
+
+__all__ = ["code_info", "dis", "disassemble", "distb", "disco",
+           "findlinestarts", "findlabels", "show_code",
+           "get_instructions", "Instruction", "Bytecode"] + _opcodes_all
+del _opcodes_all
+
+_have_code = (types.MethodType, types.FunctionType, types.CodeType,
+              classmethod, staticmethod, type)
+
+CONVERT_VALUE = opmap['CONVERT_VALUE']
+
+SET_FUNCTION_ATTRIBUTE = opmap['SET_FUNCTION_ATTRIBUTE']
+FUNCTION_ATTR_FLAGS = ('defaults', 'kwdefaults', 'annotations', 'closure')
+
+ENTER_EXECUTOR = opmap['ENTER_EXECUTOR']
+LOAD_CONST = opmap['LOAD_CONST']
+RETURN_CONST = opmap['RETURN_CONST']
+LOAD_GLOBAL = opmap['LOAD_GLOBAL']
+BINARY_OP = opmap['BINARY_OP']
+JUMP_BACKWARD = opmap['JUMP_BACKWARD']
+FOR_ITER = opmap['FOR_ITER']
+SEND = opmap['SEND']
+LOAD_ATTR = opmap['LOAD_ATTR']
+LOAD_SUPER_ATTR = opmap['LOAD_SUPER_ATTR']
+CALL_INTRINSIC_1 = opmap['CALL_INTRINSIC_1']
+CALL_INTRINSIC_2 = opmap['CALL_INTRINSIC_2']
+LOAD_FAST_LOAD_FAST = opmap['LOAD_FAST_LOAD_FAST']
+STORE_FAST_LOAD_FAST = opmap['STORE_FAST_LOAD_FAST']
+STORE_FAST_STORE_FAST = opmap['STORE_FAST_STORE_FAST']
+
+CACHE = opmap["CACHE"]
+
+_all_opname = list(opname)
+_all_opmap = dict(opmap)
+for name, op in _specialized_opmap.items():
+    # fill opname and opmap
+    assert op < len(_all_opname)
+    _all_opname[op] = name
+    _all_opmap[name] = op
+
+deoptmap = {
+    specialized: base for base, family in _specializations.items() for specialized in family
+}
+
+def _try_compile(source, name):
+    """Attempts to compile the given source, first as an expression and
+       then as a statement if the first approach fails.
+
+       Utility function to accept strings in functions that otherwise
+       expect code objects
+    """
+    try:
+        return compile(source, name, 'eval')
+    except SyntaxError:
+        pass
+    return compile(source, name, 'exec')
+
+def dis(x=None, *, file=None, depth=None, show_caches=False, adaptive=False,
+        show_offsets=False):
+    """Disassemble classes, methods, functions, and other compiled objects.
+
+    With no argument, disassemble the last traceback.
+
+    Compiled objects currently include generator objects, async generator
+    objects, and coroutine objects, all of which store their code object
+    in a special attribute.
+    """
+    if x is None:
+        distb(file=file, show_caches=show_caches, adaptive=adaptive,
+              show_offsets=show_offsets)
+        return
+    # Extract functions from methods.
+    if hasattr(x, '__func__'):
+        x = x.__func__
+    # Extract compiled code objects from...
+    if hasattr(x, '__code__'):  # ...a function, or
+        x = x.__code__
+    elif hasattr(x, 'gi_code'):  #...a generator object, or
+        x = x.gi_code
+    elif hasattr(x, 'ag_code'):  #...an asynchronous generator object, or
+        x = x.ag_code
+    elif hasattr(x, 'cr_code'):  #...a coroutine.
+        x = x.cr_code
+    # Perform the disassembly.
+    if hasattr(x, '__dict__'):  # Class or module
+        items = sorted(x.__dict__.items())
+        for name, x1 in items:
+            if isinstance(x1, _have_code):
+                print("Disassembly of %s:" % name, file=file)
+                try:
+                    dis(x1, file=file, depth=depth, show_caches=show_caches, adaptive=adaptive, show_offsets=show_offsets)
+                except TypeError as msg:
+                    print("Sorry:", msg, file=file)
+                print(file=file)
+    elif hasattr(x, 'co_code'): # Code object
+        _disassemble_recursive(x, file=file, depth=depth, show_caches=show_caches, adaptive=adaptive, show_offsets=show_offsets)
+    elif isinstance(x, (bytes, bytearray)): # Raw bytecode
+        labels_map = _make_labels_map(x)
+        label_width = 4 + len(str(len(labels_map)))
+        formatter = Formatter(file=file,
+                              offset_width=len(str(max(len(x) - 2, 9999))) if show_offsets else 0,
+                              label_width=label_width,
+                              show_caches=show_caches)
+        arg_resolver = ArgResolver(labels_map=labels_map)
+        _disassemble_bytes(x, arg_resolver=arg_resolver, formatter=formatter)
+    elif isinstance(x, str):    # Source code
+        _disassemble_str(x, file=file, depth=depth, show_caches=show_caches, adaptive=adaptive, show_offsets=show_offsets)
+    else:
+        raise TypeError("don't know how to disassemble %s objects" %
+                        type(x).__name__)
+
+def distb(tb=None, *, file=None, show_caches=False, adaptive=False, show_offsets=False):
+    """Disassemble a traceback (default: last traceback)."""
+    if tb is None:
+        try:
+            if hasattr(sys, 'last_exc'):
+                tb = sys.last_exc.__traceback__
+            else:
+                tb = sys.last_traceback
+        except AttributeError:
+            raise RuntimeError("no last traceback to disassemble") from None
+        while tb.tb_next: tb = tb.tb_next
+    disassemble(tb.tb_frame.f_code, tb.tb_lasti, file=file, show_caches=show_caches, adaptive=adaptive, show_offsets=show_offsets)
+
+# The inspect module interrogates this dictionary to build its
+# list of CO_* constants. It is also used by pretty_flags to
+# turn the co_flags field into a human readable list.
+COMPILER_FLAG_NAMES = {
+     1: "OPTIMIZED",
+     2: "NEWLOCALS",
+     4: "VARARGS",
+     8: "VARKEYWORDS",
+    16: "NESTED",
+    32: "GENERATOR",
+    64: "NOFREE",
+   128: "COROUTINE",
+   256: "ITERABLE_COROUTINE",
+   512: "ASYNC_GENERATOR",
+}
+
+def pretty_flags(flags):
+    """Return pretty representation of code flags."""
+    names = []
+    for i in range(32):
+        flag = 1<<i
+        if flags & flag:
+            names.append(COMPILER_FLAG_NAMES.get(flag, hex(flag)))
+            flags ^= flag
+            if not flags:
+                break
+    else:
+        names.append(hex(flags))
+    return ", ".join(names)
+
+class _Unknown:
+    def __repr__(self):
+        return "<unknown>"
+
+# Sentinel to represent values that cannot be calculated
+UNKNOWN = _Unknown()
+
+def _get_code_object(x):
+    """Helper to handle methods, compiled or raw code objects, and strings."""
+    # Extract functions from methods.
+    if hasattr(x, '__func__'):
+        x = x.__func__
+    # Extract compiled code objects from...
+    if hasattr(x, '__code__'):  # ...a function, or
+        x = x.__code__
+    elif hasattr(x, 'gi_code'):  #...a generator object, or
+        x = x.gi_code
+    elif hasattr(x, 'ag_code'):  #...an asynchronous generator object, or
+        x = x.ag_code
+    elif hasattr(x, 'cr_code'):  #...a coroutine.
+        x = x.cr_code
+    # Handle source code.
+    if isinstance(x, str):
+        x = _try_compile(x, "<disassembly>")
+    # By now, if we don't have a code object, we can't disassemble x.
+    if hasattr(x, 'co_code'):
+        return x
+    raise TypeError("don't know how to disassemble %s objects" %
+                    type(x).__name__)
+
+def _deoptop(op):
+    name = _all_opname[op]
+    return _all_opmap[deoptmap[name]] if name in deoptmap else op
+
+def _get_code_array(co, adaptive):
+    if adaptive:
+        code = co._co_code_adaptive
+        res = []
+        found = False
+        for i in range(0, len(code), 2):
+            op, arg = code[i], code[i+1]
+            if op == ENTER_EXECUTOR:
+                try:
+                    ex = get_executor(co, i)
+                except (ValueError, RuntimeError):
+                    ex = None
+
+                if ex:
+                    op, arg = ex.get_opcode(), ex.get_oparg()
+                    found = True
+
+            res.append(op.to_bytes())
+            res.append(arg.to_bytes())
+        return code if not found else b''.join(res)
+    else:
+        return co.co_code
+
+def code_info(x):
+    """Formatted details of methods, functions, or code."""
+    return _format_code_info(_get_code_object(x))
+
+def _format_code_info(co):
+    lines = []
+    lines.append("Name:              %s" % co.co_name)
+    lines.append("Filename:          %s" % co.co_filename)
+    lines.append("Argument count:    %s" % co.co_argcount)
+    lines.append("Positional-only arguments: %s" % co.co_posonlyargcount)
+    lines.append("Kw-only arguments: %s" % co.co_kwonlyargcount)
+    lines.append("Number of locals:  %s" % co.co_nlocals)
+    lines.append("Stack size:        %s" % co.co_stacksize)
+    lines.append("Flags:             %s" % pretty_flags(co.co_flags))
+    if co.co_consts:
+        lines.append("Constants:")
+        for i_c in enumerate(co.co_consts):
+            lines.append("%4d: %r" % i_c)
+    if co.co_names:
+        lines.append("Names:")
+        for i_n in enumerate(co.co_names):
+            lines.append("%4d: %s" % i_n)
+    if co.co_varnames:
+        lines.append("Variable names:")
+        for i_n in enumerate(co.co_varnames):
+            lines.append("%4d: %s" % i_n)
+    if co.co_freevars:
+        lines.append("Free variables:")
+        for i_n in enumerate(co.co_freevars):
+            lines.append("%4d: %s" % i_n)
+    if co.co_cellvars:
+        lines.append("Cell variables:")
+        for i_n in enumerate(co.co_cellvars):
+            lines.append("%4d: %s" % i_n)
+    return "\n".join(lines)
+
+def show_code(co, *, file=None):
+    """Print details of methods, functions, or code to *file*.
+
+    If *file* is not provided, the output is printed on stdout.
+    """
+    print(code_info(co), file=file)
+
+Positions = collections.namedtuple(
+    'Positions',
+    [
+        'lineno',
+        'end_lineno',
+        'col_offset',
+        'end_col_offset',
+    ],
+    defaults=[None] * 4
+)
+
+_Instruction = collections.namedtuple(
+    "_Instruction",
+    [
+        'opname',
+        'opcode',
+        'arg',
+        'argval',
+        'argrepr',
+        'offset',
+        'start_offset',
+        'starts_line',
+        'line_number',
+        'label',
+        'positions',
+        'cache_info',
+    ],
+    defaults=[None, None, None]
+)
+
+_Instruction.opname.__doc__ = "Human readable name for operation"
+_Instruction.opcode.__doc__ = "Numeric code for operation"
+_Instruction.arg.__doc__ = "Numeric argument to operation (if any), otherwise None"
+_Instruction.argval.__doc__ = "Resolved arg value (if known), otherwise same as arg"
+_Instruction.argrepr.__doc__ = "Human readable description of operation argument"
+_Instruction.offset.__doc__ = "Start index of operation within bytecode sequence"
+_Instruction.start_offset.__doc__ = (
+    "Start index of operation within bytecode sequence, including extended args if present; "
+    "otherwise equal to Instruction.offset"
+)
+_Instruction.starts_line.__doc__ = "True if this opcode starts a source line, otherwise False"
+_Instruction.line_number.__doc__ = "source line number associated with this opcode (if any), otherwise None"
+_Instruction.label.__doc__ = "A label (int > 0) if this instruction is a jump target, otherwise None"
+_Instruction.positions.__doc__ = "dis.Positions object holding the span of source code covered by this instruction"
+_Instruction.cache_info.__doc__ = "list of (name, size, data), one for each cache entry of the instruction"
+
+_ExceptionTableEntryBase = collections.namedtuple("_ExceptionTableEntryBase",
+    "start end target depth lasti")
+
+class _ExceptionTableEntry(_ExceptionTableEntryBase):
+    pass
+
+_OPNAME_WIDTH = 20
+_OPARG_WIDTH = 5
+
+def _get_cache_size(opname):
+    return _inline_cache_entries.get(opname, 0)
+
+def _get_jump_target(op, arg, offset):
+    """Gets the bytecode offset of the jump target if this is a jump instruction.
+
+    Otherwise return None.
+    """
+    deop = _deoptop(op)
+    caches = _get_cache_size(_all_opname[deop])
+    if deop in hasjrel:
+        if _is_backward_jump(deop):
+            arg = -arg
+        target = offset + 2 + arg*2
+        target += 2 * caches
+    elif deop in hasjabs:
+        target = arg*2
+    else:
+        target = None
+    return target
+
+class Instruction(_Instruction):
+    """Details for a bytecode operation.
+
+       Defined fields:
+         opname - human readable name for operation
+         opcode - numeric code for operation
+         arg - numeric argument to operation (if any), otherwise None
+         argval - resolved arg value (if known), otherwise same as arg
+         argrepr - human readable description of operation argument
+         offset - start index of operation within bytecode sequence
+         start_offset - start index of operation within bytecode sequence including extended args if present;
+                        otherwise equal to Instruction.offset
+         starts_line - True if this opcode starts a source line, otherwise False
+         line_number - source line number associated with this opcode (if any), otherwise None
+         label - A label if this instruction is a jump target, otherwise None
+         positions - Optional dis.Positions object holding the span of source code
+                     covered by this instruction
+         cache_info - information about the format and content of the instruction's cache
+                        entries (if any)
+    """
+
+    @property
+    def oparg(self):
+        """Alias for Instruction.arg."""
+        return self.arg
+
+    @property
+    def baseopcode(self):
+        """Numeric code for the base operation if operation is specialized.
+
+        Otherwise equal to Instruction.opcode.
+        """
+        return _deoptop(self.opcode)
+
+    @property
+    def baseopname(self):
+        """Human readable name for the base operation if operation is specialized.
+
+        Otherwise equal to Instruction.opname.
+        """
+        return opname[self.baseopcode]
+
+    @property
+    def cache_offset(self):
+        """Start index of the cache entries following the operation."""
+        return self.offset + 2
+
+    @property
+    def end_offset(self):
+        """End index of the cache entries following the operation."""
+        return self.cache_offset + _get_cache_size(_all_opname[self.opcode])*2
+
+    @property
+    def jump_target(self):
+        """Bytecode index of the jump target if this is a jump operation.
+
+        Otherwise return None.
+        """
+        return _get_jump_target(self.opcode, self.arg, self.offset)
+
+    @property
+    def is_jump_target(self):
+        """True if other code jumps to here, otherwise False"""
+        return self.label is not None
+
+    def __str__(self):
+        output = io.StringIO()
+        formatter = Formatter(file=output)
+        formatter.print_instruction(self, False)
+        return output.getvalue()
+
+
+class Formatter:
+
+    def __init__(self, file=None, lineno_width=0, offset_width=0, label_width=0,
+                       line_offset=0, show_caches=False):
+        """Create a Formatter
+
+        *file* where to write the output
+        *lineno_width* sets the width of the line number field (0 omits it)
+        *offset_width* sets the width of the instruction offset field
+        *label_width* sets the width of the label field
+        *show_caches* is a boolean indicating whether to display cache lines
+
+        """
+        self.file = file
+        self.lineno_width = lineno_width
+        self.offset_width = offset_width
+        self.label_width = label_width
+        self.show_caches = show_caches
+
+    def print_instruction(self, instr, mark_as_current=False):
+        self.print_instruction_line(instr, mark_as_current)
+        if self.show_caches and instr.cache_info:
+            offset = instr.offset
+            for name, size, data in instr.cache_info:
+                for i in range(size):
+                    offset += 2
+                    # Only show the fancy argrepr for a CACHE instruction when it's
+                    # the first entry for a particular cache value:
+                    if i == 0:
+                        argrepr = f"{name}: {int.from_bytes(data, sys.byteorder)}"
+                    else:
+                        argrepr = ""
+                    self.print_instruction_line(
+                        Instruction("CACHE", CACHE, 0, None, argrepr, offset, offset,
+                                    False, None, None, instr.positions),
+                        False)
+
+    def print_instruction_line(self, instr, mark_as_current):
+        """Format instruction details for inclusion in disassembly output."""
+        lineno_width = self.lineno_width
+        offset_width = self.offset_width
+        label_width = self.label_width
+
+        new_source_line = (lineno_width > 0 and
+                           instr.starts_line and
+                           instr.offset > 0)
+        if new_source_line:
+            print(file=self.file)
+
+        fields = []
+        # Column: Source code line number
+        if lineno_width:
+            if instr.starts_line:
+                lineno_fmt = "%%%dd" if instr.line_number is not None else "%%%ds"
+                lineno_fmt = lineno_fmt % lineno_width
+                lineno = _NO_LINENO if instr.line_number is None else instr.line_number
+                fields.append(lineno_fmt % lineno)
+            else:
+                fields.append(' ' * lineno_width)
+        # Column: Label
+        if instr.label is not None:
+            lbl = f"L{instr.label}:"
+            fields.append(f"{lbl:>{label_width}}")
+        else:
+            fields.append(' ' * label_width)
+        # Column: Instruction offset from start of code sequence
+        if offset_width > 0:
+            fields.append(f"{repr(instr.offset):>{offset_width}}  ")
+        # Column: Current instruction indicator
+        if mark_as_current:
+            fields.append('-->')
+        else:
+            fields.append('   ')
+        # Column: Opcode name
+        fields.append(instr.opname.ljust(_OPNAME_WIDTH))
+        # Column: Opcode argument
+        if instr.arg is not None:
+            arg = repr(instr.arg)
+            # If opname is longer than _OPNAME_WIDTH, we allow it to overflow into
+            # the space reserved for oparg. This results in fewer misaligned opargs
+            # in the disassembly output.
+            opname_excess = max(0, len(instr.opname) - _OPNAME_WIDTH)
+            fields.append(repr(instr.arg).rjust(_OPARG_WIDTH - opname_excess))
+            # Column: Opcode argument details
+            if instr.argrepr:
+                fields.append('(' + instr.argrepr + ')')
+        print(' '.join(fields).rstrip(), file=self.file)
+
+    def print_exception_table(self, exception_entries):
+        file = self.file
+        if exception_entries:
+            print("ExceptionTable:", file=file)
+            for entry in exception_entries:
+                lasti = " lasti" if entry.lasti else ""
+                start = entry.start_label
+                end = entry.end_label
+                target = entry.target_label
+                print(f"  L{start} to L{end} -> L{target} [{entry.depth}]{lasti}", file=file)
+
+
+class ArgResolver:
+    def __init__(self, co_consts=None, names=None, varname_from_oparg=None, labels_map=None):
+        self.co_consts = co_consts
+        self.names = names
+        self.varname_from_oparg = varname_from_oparg
+        self.labels_map = labels_map or {}
+
+    def offset_from_jump_arg(self, op, arg, offset):
+        deop = _deoptop(op)
+        if deop in hasjabs:
+            return arg * 2
+        elif deop in hasjrel:
+            signed_arg = -arg if _is_backward_jump(deop) else arg
+            argval = offset + 2 + signed_arg*2
+            caches = _get_cache_size(_all_opname[deop])
+            argval += 2 * caches
+            return argval
+        return None
+
+    def get_label_for_offset(self, offset):
+        return self.labels_map.get(offset, None)
+
+    def get_argval_argrepr(self, op, arg, offset):
+        get_name = None if self.names is None else self.names.__getitem__
+        argval = None
+        argrepr = ''
+        deop = _deoptop(op)
+        if arg is not None:
+            #  Set argval to the dereferenced value of the argument when
+            #  available, and argrepr to the string representation of argval.
+            #    _disassemble_bytes needs the string repr of the
+            #    raw name index for LOAD_GLOBAL, LOAD_CONST, etc.
+            argval = arg
+            if deop in hasconst:
+                argval, argrepr = _get_const_info(deop, arg, self.co_consts)
+            elif deop in hasname:
+                if deop == LOAD_GLOBAL:
+                    argval, argrepr = _get_name_info(arg//2, get_name)
+                    if (arg & 1) and argrepr:
+                        argrepr = f"{argrepr} + NULL"
+                elif deop == LOAD_ATTR:
+                    argval, argrepr = _get_name_info(arg//2, get_name)
+                    if (arg & 1) and argrepr:
+                        argrepr = f"{argrepr} + NULL|self"
+                elif deop == LOAD_SUPER_ATTR:
+                    argval, argrepr = _get_name_info(arg//4, get_name)
+                    if (arg & 1) and argrepr:
+                        argrepr = f"{argrepr} + NULL|self"
+                else:
+                    argval, argrepr = _get_name_info(arg, get_name)
+            elif deop in hasjump or deop in hasexc:
+                argval = self.offset_from_jump_arg(op, arg, offset)
+                lbl = self.get_label_for_offset(argval)
+                assert lbl is not None
+                argrepr = f"to L{lbl}"
+            elif deop in (LOAD_FAST_LOAD_FAST, STORE_FAST_LOAD_FAST, STORE_FAST_STORE_FAST):
+                arg1 = arg >> 4
+                arg2 = arg & 15
+                val1, argrepr1 = _get_name_info(arg1, self.varname_from_oparg)
+                val2, argrepr2 = _get_name_info(arg2, self.varname_from_oparg)
+                argrepr = argrepr1 + ", " + argrepr2
+                argval = val1, val2
+            elif deop in haslocal or deop in hasfree:
+                argval, argrepr = _get_name_info(arg, self.varname_from_oparg)
+            elif deop in hascompare:
+                argval = cmp_op[arg >> 5]
+                argrepr = argval
+                if arg & 16:
+                    argrepr = f"bool({argrepr})"
+            elif deop == CONVERT_VALUE:
+                argval = (None, str, repr, ascii)[arg]
+                argrepr = ('', 'str', 'repr', 'ascii')[arg]
+            elif deop == SET_FUNCTION_ATTRIBUTE:
+                argrepr = ', '.join(s for i, s in enumerate(FUNCTION_ATTR_FLAGS)
+                                    if arg & (1<<i))
+            elif deop == BINARY_OP:
+                _, argrepr = _nb_ops[arg]
+            elif deop == CALL_INTRINSIC_1:
+                argrepr = _intrinsic_1_descs[arg]
+            elif deop == CALL_INTRINSIC_2:
+                argrepr = _intrinsic_2_descs[arg]
+        return argval, argrepr
+
+def get_instructions(x, *, first_line=None, show_caches=None, adaptive=False):
+    """Iterator for the opcodes in methods, functions or code
+
+    Generates a series of Instruction named tuples giving the details of
+    each operations in the supplied code.
+
+    If *first_line* is not None, it indicates the line number that should
+    be reported for the first source line in the disassembled code.
+    Otherwise, the source line information (if any) is taken directly from
+    the disassembled code object.
+    """
+    co = _get_code_object(x)
+    linestarts = dict(findlinestarts(co))
+    if first_line is not None:
+        line_offset = first_line - co.co_firstlineno
+    else:
+        line_offset = 0
+
+    original_code = co.co_code
+    arg_resolver = ArgResolver(co_consts=co.co_consts,
+                               names=co.co_names,
+                               varname_from_oparg=co._varname_from_oparg,
+                               labels_map=_make_labels_map(original_code))
+    return _get_instructions_bytes(_get_code_array(co, adaptive),
+                                   linestarts=linestarts,
+                                   line_offset=line_offset,
+                                   co_positions=co.co_positions(),
+                                   original_code=original_code,
+                                   arg_resolver=arg_resolver)
+
+def _get_const_value(op, arg, co_consts):
+    """Helper to get the value of the const in a hasconst op.
+
+       Returns the dereferenced constant if this is possible.
+       Otherwise (if it is a LOAD_CONST and co_consts is not
+       provided) returns the dis.UNKNOWN sentinel.
+    """
+    assert op in hasconst
+
+    argval = UNKNOWN
+    if co_consts is not None:
+        argval = co_consts[arg]
+    return argval
+
+def _get_const_info(op, arg, co_consts):
+    """Helper to get optional details about const references
+
+       Returns the dereferenced constant and its repr if the value
+       can be calculated.
+       Otherwise returns the sentinel value dis.UNKNOWN for the value
+       and an empty string for its repr.
+    """
+    argval = _get_const_value(op, arg, co_consts)
+    argrepr = repr(argval) if argval is not UNKNOWN else ''
+    return argval, argrepr
+
+def _get_name_info(name_index, get_name, **extrainfo):
+    """Helper to get optional details about named references
+
+       Returns the dereferenced name as both value and repr if the name
+       list is defined.
+       Otherwise returns the sentinel value dis.UNKNOWN for the value
+       and an empty string for its repr.
+    """
+    if get_name is not None:
+        argval = get_name(name_index, **extrainfo)
+        return argval, argval
+    else:
+        return UNKNOWN, ''
+
+def _parse_varint(iterator):
+    b = next(iterator)
+    val = b & 63
+    while b&64:
+        val <<= 6
+        b = next(iterator)
+        val |= b&63
+    return val
+
+def _parse_exception_table(code):
+    iterator = iter(code.co_exceptiontable)
+    entries = []
+    try:
+        while True:
+            start = _parse_varint(iterator)*2
+            length = _parse_varint(iterator)*2
+            end = start + length
+            target = _parse_varint(iterator)*2
+            dl = _parse_varint(iterator)
+            depth = dl >> 1
+            lasti = bool(dl&1)
+            entries.append(_ExceptionTableEntry(start, end, target, depth, lasti))
+    except StopIteration:
+        return entries
+
+def _is_backward_jump(op):
+    return opname[op] in ('JUMP_BACKWARD',
+                          'JUMP_BACKWARD_NO_INTERRUPT')
+
+def _get_instructions_bytes(code, linestarts=None, line_offset=0, co_positions=None,
+                            original_code=None, arg_resolver=None):
+    """Iterate over the instructions in a bytecode string.
+
+    Generates a sequence of Instruction namedtuples giving the details of each
+    opcode.
+
+    """
+    # Use the basic, unadaptive code for finding labels and actually walking the
+    # bytecode, since replacements like ENTER_EXECUTOR and INSTRUMENTED_* can
+    # mess that logic up pretty badly:
+    original_code = original_code or code
+    co_positions = co_positions or iter(())
+
+    starts_line = False
+    local_line_number = None
+    line_number = None
+    for offset, start_offset, op, arg in _unpack_opargs(original_code):
+        if linestarts is not None:
+            starts_line = offset in linestarts
+            if starts_line:
+                local_line_number = linestarts[offset]
+            if local_line_number is not None:
+                line_number = local_line_number + line_offset
+            else:
+                line_number = None
+        positions = Positions(*next(co_positions, ()))
+        deop = _deoptop(op)
+        op = code[offset]
+
+        if arg_resolver:
+            argval, argrepr = arg_resolver.get_argval_argrepr(op, arg, offset)
+        else:
+            argval, argrepr = arg, repr(arg)
+
+        caches = _get_cache_size(_all_opname[deop])
+        # Advance the co_positions iterator:
+        for _ in range(caches):
+            next(co_positions, ())
+
+        if caches:
+            cache_info = []
+            for name, size in _cache_format[opname[deop]].items():
+                data = code[offset + 2: offset + 2 + 2 * size]
+                cache_info.append((name, size, data))
+        else:
+            cache_info = None
+
+        label = arg_resolver.get_label_for_offset(offset) if arg_resolver else None
+        yield Instruction(_all_opname[op], op, arg, argval, argrepr,
+                          offset, start_offset, starts_line, line_number,
+                          label, positions, cache_info)
+
+
+def disassemble(co, lasti=-1, *, file=None, show_caches=False, adaptive=False,
+                show_offsets=False):
+    """Disassemble a code object."""
+    linestarts = dict(findlinestarts(co))
+    exception_entries = _parse_exception_table(co)
+    labels_map = _make_labels_map(co.co_code, exception_entries=exception_entries)
+    label_width = 4 + len(str(len(labels_map)))
+    formatter = Formatter(file=file,
+                          lineno_width=_get_lineno_width(linestarts),
+                          offset_width=len(str(max(len(co.co_code) - 2, 9999))) if show_offsets else 0,
+                          label_width=label_width,
+                          show_caches=show_caches)
+    arg_resolver = ArgResolver(co_consts=co.co_consts,
+                               names=co.co_names,
+                               varname_from_oparg=co._varname_from_oparg,
+                               labels_map=labels_map)
+    _disassemble_bytes(_get_code_array(co, adaptive), lasti, linestarts,
+                       exception_entries=exception_entries, co_positions=co.co_positions(),
+                       original_code=co.co_code, arg_resolver=arg_resolver, formatter=formatter)
+
+def _disassemble_recursive(co, *, file=None, depth=None, show_caches=False, adaptive=False, show_offsets=False):
+    disassemble(co, file=file, show_caches=show_caches, adaptive=adaptive, show_offsets=show_offsets)
+    if depth is None or depth > 0:
+        if depth is not None:
+            depth = depth - 1
+        for x in co.co_consts:
+            if hasattr(x, 'co_code'):
+                print(file=file)
+                print("Disassembly of %r:" % (x,), file=file)
+                _disassemble_recursive(
+                    x, file=file, depth=depth, show_caches=show_caches,
+                    adaptive=adaptive, show_offsets=show_offsets
+                )
+
+
+def _make_labels_map(original_code, exception_entries=()):
+    jump_targets = set(findlabels(original_code))
+    labels = set(jump_targets)
+    for start, end, target, _, _ in exception_entries:
+        labels.add(start)
+        labels.add(end)
+        labels.add(target)
+    labels = sorted(labels)
+    labels_map = {offset: i+1 for (i, offset) in enumerate(sorted(labels))}
+    for e in exception_entries:
+        e.start_label = labels_map[e.start]
+        e.end_label = labels_map[e.end]
+        e.target_label = labels_map[e.target]
+    return labels_map
+
+_NO_LINENO = '  --'
+
+def _get_lineno_width(linestarts):
+    if linestarts is None:
+        return 0
+    maxlineno = max(filter(None, linestarts.values()), default=-1)
+    if maxlineno == -1:
+        # Omit the line number column entirely if we have no line number info
+        return 0
+    lineno_width = max(3, len(str(maxlineno)))
+    if lineno_width < len(_NO_LINENO) and None in linestarts.values():
+        lineno_width = len(_NO_LINENO)
+    return lineno_width
+
+
+def _disassemble_bytes(code, lasti=-1, linestarts=None,
+                       *, line_offset=0, exception_entries=(),
+                       co_positions=None, original_code=None,
+                       arg_resolver=None, formatter=None):
+
+    assert formatter is not None
+    assert arg_resolver is not None
+
+    instrs = _get_instructions_bytes(code, linestarts=linestarts,
+                                           line_offset=line_offset,
+                                           co_positions=co_positions,
+                                           original_code=original_code,
+                                           arg_resolver=arg_resolver)
+
+    print_instructions(instrs, exception_entries, formatter, lasti=lasti)
+
+
+def print_instructions(instrs, exception_entries, formatter, lasti=-1):
+    for instr in instrs:
+        # Each CACHE takes 2 bytes
+        is_current_instr = instr.offset <= lasti \
+            <= instr.offset + 2 * _get_cache_size(_all_opname[_deoptop(instr.opcode)])
+        formatter.print_instruction(instr, is_current_instr)
+
+    formatter.print_exception_table(exception_entries)
+
+def _disassemble_str(source, **kwargs):
+    """Compile the source string, then disassemble the code object."""
+    _disassemble_recursive(_try_compile(source, '<dis>'), **kwargs)
+
+disco = disassemble                     # XXX For backwards compatibility
+
+
+# Rely on C `int` being 32 bits for oparg
+_INT_BITS = 32
+# Value for c int when it overflows
+_INT_OVERFLOW = 2 ** (_INT_BITS - 1)
+
+def _unpack_opargs(code):
+    extended_arg = 0
+    extended_args_offset = 0  # Number of EXTENDED_ARG instructions preceding the current instruction
+    caches = 0
+    for i in range(0, len(code), 2):
+        # Skip inline CACHE entries:
+        if caches:
+            caches -= 1
+            continue
+        op = code[i]
+        deop = _deoptop(op)
+        caches = _get_cache_size(_all_opname[deop])
+        if deop in hasarg:
+            arg = code[i+1] | extended_arg
+            extended_arg = (arg << 8) if deop == EXTENDED_ARG else 0
+            # The oparg is stored as a signed integer
+            # If the value exceeds its upper limit, it will overflow and wrap
+            # to a negative integer
+            if extended_arg >= _INT_OVERFLOW:
+                extended_arg -= 2 * _INT_OVERFLOW
+        else:
+            arg = None
+            extended_arg = 0
+        if deop == EXTENDED_ARG:
+            extended_args_offset += 1
+            yield (i, i, op, arg)
+        else:
+            start_offset = i - extended_args_offset*2
+            yield (i, start_offset, op, arg)
+            extended_args_offset = 0
+
+def findlabels(code):
+    """Detect all offsets in a byte code which are jump targets.
+
+    Return the list of offsets.
+
+    """
+    labels = []
+    for offset, _, op, arg in _unpack_opargs(code):
+        if arg is not None:
+            label = _get_jump_target(op, arg, offset)
+            if label is None:
+                continue
+            if label not in labels:
+                labels.append(label)
+    return labels
+
+def findlinestarts(code):
+    """Find the offsets in a byte code which are start of lines in the source.
+
+    Generate pairs (offset, lineno)
+    lineno will be an integer or None the offset does not have a source line.
+    """
+
+    lastline = False # None is a valid line number
+    for start, end, line in code.co_lines():
+        if line is not lastline:
+            lastline = line
+            yield start, line
+    return
+
+def _find_imports(co):
+    """Find import statements in the code
+
+    Generate triplets (name, level, fromlist) where
+    name is the imported module and level, fromlist are
+    the corresponding args to __import__.
+    """
+    IMPORT_NAME = opmap['IMPORT_NAME']
+
+    consts = co.co_consts
+    names = co.co_names
+    opargs = [(op, arg) for _, _, op, arg in _unpack_opargs(co.co_code)
+                  if op != EXTENDED_ARG]
+    for i, (op, oparg) in enumerate(opargs):
+        if op == IMPORT_NAME and i >= 2:
+            from_op = opargs[i-1]
+            level_op = opargs[i-2]
+            if (from_op[0] in hasconst and level_op[0] in hasconst):
+                level = _get_const_value(level_op[0], level_op[1], consts)
+                fromlist = _get_const_value(from_op[0], from_op[1], consts)
+                yield (names[oparg], level, fromlist)
+
+def _find_store_names(co):
+    """Find names of variables which are written in the code
+
+    Generate sequence of strings
+    """
+    STORE_OPS = {
+        opmap['STORE_NAME'],
+        opmap['STORE_GLOBAL']
+    }
+
+    names = co.co_names
+    for _, _, op, arg in _unpack_opargs(co.co_code):
+        if op in STORE_OPS:
+            yield names[arg]
+
+
+class Bytecode:
+    """The bytecode operations of a piece of code
+
+    Instantiate this with a function, method, other compiled object, string of
+    code, or a code object (as returned by compile()).
+
+    Iterating over this yields the bytecode operations as Instruction instances.
+    """
+    def __init__(self, x, *, first_line=None, current_offset=None, show_caches=False, adaptive=False, show_offsets=False):
+        self.codeobj = co = _get_code_object(x)
+        if first_line is None:
+            self.first_line = co.co_firstlineno
+            self._line_offset = 0
+        else:
+            self.first_line = first_line
+            self._line_offset = first_line - co.co_firstlineno
+        self._linestarts = dict(findlinestarts(co))
+        self._original_object = x
+        self.current_offset = current_offset
+        self.exception_entries = _parse_exception_table(co)
+        self.show_caches = show_caches
+        self.adaptive = adaptive
+        self.show_offsets = show_offsets
+
+    def __iter__(self):
+        co = self.codeobj
+        original_code = co.co_code
+        labels_map = _make_labels_map(original_code, self.exception_entries)
+        arg_resolver = ArgResolver(co_consts=co.co_consts,
+                                   names=co.co_names,
+                                   varname_from_oparg=co._varname_from_oparg,
+                                   labels_map=labels_map)
+        return _get_instructions_bytes(_get_code_array(co, self.adaptive),
+                                       linestarts=self._linestarts,
+                                       line_offset=self._line_offset,
+                                       co_positions=co.co_positions(),
+                                       original_code=original_code,
+                                       arg_resolver=arg_resolver)
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__,
+                                 self._original_object)
+
+    @classmethod
+    def from_traceback(cls, tb, *, show_caches=False, adaptive=False):
+        """ Construct a Bytecode from the given traceback """
+        while tb.tb_next:
+            tb = tb.tb_next
+        return cls(
+            tb.tb_frame.f_code, current_offset=tb.tb_lasti, show_caches=show_caches, adaptive=adaptive
+        )
+
+    def info(self):
+        """Return formatted information about the code object."""
+        return _format_code_info(self.codeobj)
+
+    def dis(self):
+        """Return a formatted view of the bytecode operations."""
+        co = self.codeobj
+        if self.current_offset is not None:
+            offset = self.current_offset
+        else:
+            offset = -1
+        with io.StringIO() as output:
+            code = _get_code_array(co, self.adaptive)
+            offset_width = len(str(max(len(code) - 2, 9999))) if self.show_offsets else 0
+
+
+            labels_map = _make_labels_map(co.co_code, self.exception_entries)
+            label_width = 4 + len(str(len(labels_map)))
+            formatter = Formatter(file=output,
+                                  lineno_width=_get_lineno_width(self._linestarts),
+                                  offset_width=offset_width,
+                                  label_width=label_width,
+                                  line_offset=self._line_offset,
+                                  show_caches=self.show_caches)
+
+            arg_resolver = ArgResolver(co_consts=co.co_consts,
+                                       names=co.co_names,
+                                       varname_from_oparg=co._varname_from_oparg,
+                                       labels_map=labels_map)
+            _disassemble_bytes(code,
+                               linestarts=self._linestarts,
+                               line_offset=self._line_offset,
+                               lasti=offset,
+                               exception_entries=self.exception_entries,
+                               co_positions=co.co_positions(),
+                               original_code=co.co_code,
+                               arg_resolver=arg_resolver,
+                               formatter=formatter)
+            return output.getvalue()
+
+
+def main(args=None):
     import argparse
 
     parser = argparse.ArgumentParser()
-    parser.add_argument('infile', type=argparse.FileType('rb'), nargs='?', default='-')
-    args = parser.parse_args()
-    with args.infile as infile:
-        source = infile.read()
-    code = compile(source, args.infile.name, "exec")
-    dis(code)
+    parser.add_argument('-C', '--show-caches', action='store_true',
+                        help='show inline caches')
+    parser.add_argument('-O', '--show-offsets', action='store_true',
+                        help='show instruction offsets')
+    parser.add_argument('infile', nargs='?', default='-')
+    args = parser.parse_args(args=args)
+    if args.infile == '-':
+        name = '<stdin>'
+        source = sys.stdin.buffer.read()
+    else:
+        name = args.infile
+        with open(args.infile, 'rb') as infile:
+            source = infile.read()
+    code = compile(source, name, "exec")
+    dis(code, show_caches=args.show_caches, show_offsets=args.show_offsets)
 
 if __name__ == "__main__":
-    _test()
+    main()
diff --git a/Lib/distutils/README b/Lib/distutils/README
deleted file mode 100644
index 408a203b85..0000000000
--- a/Lib/distutils/README
+++ /dev/null
@@ -1,13 +0,0 @@
-This directory contains the Distutils package.
-
-There's a full documentation available at:
-
-    http://docs.python.org/distutils/
-
-The Distutils-SIG web page is also a good starting point:
-
-    http://www.python.org/sigs/distutils-sig/
-
-WARNING : Distutils must remain compatible with 2.3
-
-$Id$
diff --git a/Lib/distutils/__init__.py b/Lib/distutils/__init__.py
deleted file mode 100644
index d823d040a1..0000000000
--- a/Lib/distutils/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""distutils
-
-The main package for the Python Module Distribution Utilities.  Normally
-used from a setup script as
-
-   from distutils.core import setup
-
-   setup (...)
-"""
-
-import sys
-
-__version__ = sys.version[:sys.version.index(' ')]
diff --git a/Lib/distutils/_msvccompiler.py b/Lib/distutils/_msvccompiler.py
deleted file mode 100644
index 30b3b47398..0000000000
--- a/Lib/distutils/_msvccompiler.py
+++ /dev/null
@@ -1,574 +0,0 @@
-"""distutils._msvccompiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for Microsoft Visual Studio 2015.
-
-The module is compatible with VS 2015 and later. You can find legacy support
-for older versions in distutils.msvc9compiler and distutils.msvccompiler.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-# ported to VS 2005 and VS 2008 by Christian Heimes
-# ported to VS 2015 by Steve Dower
-
-import os
-import shutil
-import stat
-import subprocess
-import winreg
-
-from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
-                             CompileError, LibError, LinkError
-from distutils.ccompiler import CCompiler, gen_lib_options
-from distutils import log
-from distutils.util import get_platform
-
-from itertools import count
-
-def _find_vc2015():
-    try:
-        key = winreg.OpenKeyEx(
-            winreg.HKEY_LOCAL_MACHINE,
-            r"Software\Microsoft\VisualStudio\SxS\VC7",
-            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY
-        )
-    except OSError:
-        log.debug("Visual C++ is not registered")
-        return None, None
-
-    best_version = 0
-    best_dir = None
-    with key:
-        for i in count():
-            try:
-                v, vc_dir, vt = winreg.EnumValue(key, i)
-            except OSError:
-                break
-            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
-                try:
-                    version = int(float(v))
-                except (ValueError, TypeError):
-                    continue
-                if version >= 14 and version > best_version:
-                    best_version, best_dir = version, vc_dir
-    return best_version, best_dir
-
-def _find_vc2017():
-    import _distutils_findvs
-    import threading
-
-    best_version = 0,   # tuple for full version comparisons
-    best_dir = None
-
-    # We need to call findall() on its own thread because it will
-    # initialize COM.
-    all_packages = []
-    def _getall():
-        all_packages.extend(_distutils_findvs.findall())
-    t = threading.Thread(target=_getall)
-    t.start()
-    t.join()
-
-    for name, version_str, path, packages in all_packages:
-        if 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64' in packages:
-            vc_dir = os.path.join(path, 'VC', 'Auxiliary', 'Build')
-            if not os.path.isdir(vc_dir):
-                continue
-            try:
-                version = tuple(int(i) for i in version_str.split('.'))
-            except (ValueError, TypeError):
-                continue
-            if version > best_version:
-                best_version, best_dir = version, vc_dir
-    try:
-        best_version = best_version[0]
-    except IndexError:
-        best_version = None
-    return best_version, best_dir
-
-def _find_vcvarsall(plat_spec):
-    best_version, best_dir = _find_vc2017()
-    vcruntime = None
-    vcruntime_plat = 'x64' if 'amd64' in plat_spec else 'x86'
-    if best_version:
-        vcredist = os.path.join(best_dir, "..", "..", "redist", "MSVC", "**",
-            "Microsoft.VC141.CRT", "vcruntime140.dll")
-        try:
-            import glob
-            vcruntime = glob.glob(vcredist, recursive=True)[-1]
-        except (ImportError, OSError, LookupError):
-            vcruntime = None
-
-    if not best_version:
-        best_version, best_dir = _find_vc2015()
-        if best_version:
-            vcruntime = os.path.join(best_dir, 'redist', vcruntime_plat,
-                "Microsoft.VC140.CRT", "vcruntime140.dll")
-
-    if not best_version:
-        log.debug("No suitable Visual C++ version found")
-        return None, None
-
-    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
-    if not os.path.isfile(vcvarsall):
-        log.debug("%s cannot be found", vcvarsall)
-        return None, None
-
-    if not vcruntime or not os.path.isfile(vcruntime):
-        log.debug("%s cannot be found", vcruntime)
-        vcruntime = None
-
-    return vcvarsall, vcruntime
-
-def _get_vc_env(plat_spec):
-    if os.getenv("DISTUTILS_USE_SDK"):
-        return {
-            key.lower(): value
-            for key, value in os.environ.items()
-        }
-
-    vcvarsall, vcruntime = _find_vcvarsall(plat_spec)
-    if not vcvarsall:
-        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
-
-    try:
-        out = subprocess.check_output(
-            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
-            stderr=subprocess.STDOUT,
-        ).decode('utf-16le', errors='replace')
-    except subprocess.CalledProcessError as exc:
-        log.error(exc.output)
-        raise DistutilsPlatformError("Error executing {}"
-                .format(exc.cmd))
-
-    env = {
-        key.lower(): value
-        for key, _, value in
-        (line.partition('=') for line in out.splitlines())
-        if key and value
-    }
-
-    if vcruntime:
-        env['py_vcruntime_redist'] = vcruntime
-    return env
-
-def _find_exe(exe, paths=None):
-    """Return path to an MSVC executable program.
-
-    Tries to find the program in several places: first, one of the
-    MSVC program search paths from the registry; next, the directories
-    in the PATH environment variable.  If any of those work, return an
-    absolute path that is known to exist.  If none of them work, just
-    return the original program name, 'exe'.
-    """
-    if not paths:
-        paths = os.getenv('path').split(os.pathsep)
-    for p in paths:
-        fn = os.path.join(os.path.abspath(p), exe)
-        if os.path.isfile(fn):
-            return fn
-    return exe
-
-# A map keyed by get_platform() return values to values accepted by
-# 'vcvarsall.bat'. Always cross-compile from x86 to work with the
-# lighter-weight MSVC installs that do not include native 64-bit tools.
-PLAT_TO_VCVARS = {
-    'win32' : 'x86',
-    'win-amd64' : 'x86_amd64',
-}
-
-# A set containing the DLLs that are guaranteed to be available for
-# all micro versions of this Python version. Known extension
-# dependencies that are not in this set will be copied to the output
-# path.
-_BUNDLED_DLLS = frozenset(['vcruntime140.dll'])
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        # target platform (.plat_name is consistent with 'bdist')
-        self.plat_name = None
-        self.initialized = False
-
-    def initialize(self, plat_name=None):
-        # multi-init means we would need to check platform same each time...
-        assert not self.initialized, "don't init multiple times"
-        if plat_name is None:
-            plat_name = get_platform()
-        # sanity check for platforms to prevent obscure errors later.
-        if plat_name not in PLAT_TO_VCVARS:
-            raise DistutilsPlatformError("--plat-name must be one of {}"
-                                         .format(tuple(PLAT_TO_VCVARS)))
-
-        # Get the vcvarsall.bat spec for the requested platform.
-        plat_spec = PLAT_TO_VCVARS[plat_name]
-
-        vc_env = _get_vc_env(plat_spec)
-        if not vc_env:
-            raise DistutilsPlatformError("Unable to find a compatible "
-                "Visual Studio installation.")
-
-        self._paths = vc_env.get('path', '')
-        paths = self._paths.split(os.pathsep)
-        self.cc = _find_exe("cl.exe", paths)
-        self.linker = _find_exe("link.exe", paths)
-        self.lib = _find_exe("lib.exe", paths)
-        self.rc = _find_exe("rc.exe", paths)   # resource compiler
-        self.mc = _find_exe("mc.exe", paths)   # message compiler
-        self.mt = _find_exe("mt.exe", paths)   # message compiler
-        self._vcruntime_redist = vc_env.get('py_vcruntime_redist', '')
-
-        for dir in vc_env.get('include', '').split(os.pathsep):
-            if dir:
-                self.add_include_dir(dir.rstrip(os.sep))
-
-        for dir in vc_env.get('lib', '').split(os.pathsep):
-            if dir:
-                self.add_library_dir(dir.rstrip(os.sep))
-
-        self.preprocess_options = None
-        # If vcruntime_redist is available, link against it dynamically. Otherwise,
-        # use /MT[d] to build statically, then switch from libucrt[d].lib to ucrt[d].lib
-        # later to dynamically link to ucrtbase but not vcruntime.
-        self.compile_options = [
-            '/nologo', '/Ox', '/W3', '/GL', '/DNDEBUG'
-        ]
-        self.compile_options.append('/MD' if self._vcruntime_redist else '/MT')
-
-        self.compile_options_debug = [
-            '/nologo', '/Od', '/MDd', '/Zi', '/W3', '/D_DEBUG'
-        ]
-
-        ldflags = [
-            '/nologo', '/INCREMENTAL:NO', '/LTCG'
-        ]
-        if not self._vcruntime_redist:
-            ldflags.extend(('/nodefaultlib:libucrt.lib', 'ucrt.lib'))
-
-        ldflags_debug = [
-            '/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL'
-        ]
-
-        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
-        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
-        self.ldflags_shared = [*ldflags, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
-        self.ldflags_shared_debug = [*ldflags_debug, '/DLL', '/MANIFEST:EMBED,ID=2', '/MANIFESTUAC:NO']
-        self.ldflags_static = [*ldflags]
-        self.ldflags_static_debug = [*ldflags_debug]
-
-        self._ldflags = {
-            (CCompiler.EXECUTABLE, None): self.ldflags_exe,
-            (CCompiler.EXECUTABLE, False): self.ldflags_exe,
-            (CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
-            (CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
-            (CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
-            (CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
-            (CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
-            (CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
-            (CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
-        }
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        ext_map = {
-            **{ext: self.obj_extension for ext in self.src_extensions},
-            **{ext: self.res_extension for ext in self._rc_extensions + self._mc_extensions},
-        }
-
-        output_dir = output_dir or ''
-
-        def make_out_path(p):
-            base, ext = os.path.splitext(p)
-            if strip_dir:
-                base = os.path.basename(base)
-            else:
-                _, base = os.path.splitdrive(base)
-                if base.startswith((os.path.sep, os.path.altsep)):
-                    base = base[1:]
-            try:
-                # XXX: This may produce absurdly long paths. We should check
-                # the length of the result and trim base until we fit within
-                # 260 characters.
-                return os.path.join(output_dir, base + ext_map[ext])
-            except LookupError:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError("Don't know how to compile {}".format(p))
-
-        return list(map(make_out_path, source_filenames))
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-
-        add_cpp_opts = False
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-                add_cpp_opts = True
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
-                    base, _ = os.path.splitext(os.path.basename (src))
-                    rc_file = os.path.join(rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc, "/fo" + obj, rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile {} to {}"
-                                   .format(src, obj))
-
-            args = [self.cc] + compile_opts + pp_opts
-            if add_cpp_opts:
-                args.append('/EHsc')
-            args.append(input_opt)
-            args.append("/Fo" + obj)
-            args.extend(extra_postargs)
-
-            try:
-                self.spawn(args)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        if runtime_library_dirs:
-            self.warn("I don't know what to do with 'runtime_library_dirs': "
-                       + str(runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ldflags = self._ldflags[target_desc, debug]
-
-            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            build_temp = os.path.dirname(objects[0])
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    build_temp,
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            output_dir = os.path.dirname(os.path.abspath(output_filename))
-            self.mkpath(output_dir)
-            try:
-                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
-                self.spawn([self.linker] + ld_args)
-                self._copy_vcruntime(output_dir)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def _copy_vcruntime(self, output_dir):
-        vcruntime = self._vcruntime_redist
-        if not vcruntime or not os.path.isfile(vcruntime):
-            return
-
-        if os.path.basename(vcruntime).lower() in _BUNDLED_DLLS:
-            return
-
-        log.debug('Copying "%s"', vcruntime)
-        vcruntime = shutil.copy(vcruntime, output_dir)
-        os.chmod(vcruntime, stat.S_IWRITE)
-
-    def spawn(self, cmd):
-        old_path = os.getenv('path')
-        try:
-            os.environ['path'] = self._paths
-            return super().spawn(cmd)
-        finally:
-            os.environ['path'] = old_path
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename(name))
-                if os.path.isfile(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
diff --git a/Lib/distutils/archive_util.py b/Lib/distutils/archive_util.py
deleted file mode 100644
index b002dc3b84..0000000000
--- a/Lib/distutils/archive_util.py
+++ /dev/null
@@ -1,256 +0,0 @@
-"""distutils.archive_util
-
-Utility functions for creating archive files (tarballs, zip files,
-that sort of thing)."""
-
-import os
-from warnings import warn
-import sys
-
-try:
-    import zipfile
-except ImportError:
-    zipfile = None
-
-
-from distutils.errors import DistutilsExecError
-from distutils.spawn import spawn
-from distutils.dir_util import mkpath
-from distutils import log
-
-try:
-    from pwd import getpwnam
-except ImportError:
-    getpwnam = None
-
-try:
-    from grp import getgrnam
-except ImportError:
-    getgrnam = None
-
-def _get_gid(name):
-    """Returns a gid, given a group name."""
-    if getgrnam is None or name is None:
-        return None
-    try:
-        result = getgrnam(name)
-    except KeyError:
-        result = None
-    if result is not None:
-        return result[2]
-    return None
-
-def _get_uid(name):
-    """Returns an uid, given a user name."""
-    if getpwnam is None or name is None:
-        return None
-    try:
-        result = getpwnam(name)
-    except KeyError:
-        result = None
-    if result is not None:
-        return result[2]
-    return None
-
-def make_tarball(base_name, base_dir, compress="gzip", verbose=0, dry_run=0,
-                 owner=None, group=None):
-    """Create a (possibly compressed) tar file from all the files under
-    'base_dir'.
-
-    'compress' must be "gzip" (the default), "bzip2", "xz", "compress", or
-    None.  ("compress" will be deprecated in Python 3.2)
-
-    'owner' and 'group' can be used to define an owner and a group for the
-    archive that is being built. If not provided, the current owner and group
-    will be used.
-
-    The output tar file will be named 'base_dir' +  ".tar", possibly plus
-    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").
-
-    Returns the output filename.
-    """
-    tar_compression = {'gzip': 'gz', 'bzip2': 'bz2', 'xz': 'xz', None: '',
-                       'compress': ''}
-    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz',
-                    'compress': '.Z'}
-
-    # flags for compression program, each element of list will be an argument
-    if compress is not None and compress not in compress_ext.keys():
-        raise ValueError(
-              "bad value for 'compress': must be None, 'gzip', 'bzip2', "
-              "'xz' or 'compress'")
-
-    archive_name = base_name + '.tar'
-    if compress != 'compress':
-        archive_name += compress_ext.get(compress, '')
-
-    mkpath(os.path.dirname(archive_name), dry_run=dry_run)
-
-    # creating the tarball
-    import tarfile  # late import so Python build itself doesn't break
-
-    log.info('Creating tar archive')
-
-    uid = _get_uid(owner)
-    gid = _get_gid(group)
-
-    def _set_uid_gid(tarinfo):
-        if gid is not None:
-            tarinfo.gid = gid
-            tarinfo.gname = group
-        if uid is not None:
-            tarinfo.uid = uid
-            tarinfo.uname = owner
-        return tarinfo
-
-    if not dry_run:
-        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
-        try:
-            tar.add(base_dir, filter=_set_uid_gid)
-        finally:
-            tar.close()
-
-    # compression using `compress`
-    if compress == 'compress':
-        warn("'compress' will be deprecated.", PendingDeprecationWarning)
-        # the option varies depending on the platform
-        compressed_name = archive_name + compress_ext[compress]
-        if sys.platform == 'win32':
-            cmd = [compress, archive_name, compressed_name]
-        else:
-            cmd = [compress, '-f', archive_name]
-        spawn(cmd, dry_run=dry_run)
-        return compressed_name
-
-    return archive_name
-
-def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):
-    """Create a zip file from all the files under 'base_dir'.
-
-    The output zip file will be named 'base_name' + ".zip".  Uses either the
-    "zipfile" Python module (if available) or the InfoZIP "zip" utility
-    (if installed and found on the default search path).  If neither tool is
-    available, raises DistutilsExecError.  Returns the name of the output zip
-    file.
-    """
-    zip_filename = base_name + ".zip"
-    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
-
-    # If zipfile module is not available, try spawning an external
-    # 'zip' command.
-    if zipfile is None:
-        if verbose:
-            zipoptions = "-r"
-        else:
-            zipoptions = "-rq"
-
-        try:
-            spawn(["zip", zipoptions, zip_filename, base_dir],
-                  dry_run=dry_run)
-        except DistutilsExecError:
-            # XXX really should distinguish between "couldn't find
-            # external 'zip' command" and "zip failed".
-            raise DistutilsExecError(("unable to create zip file '%s': "
-                   "could neither import the 'zipfile' module nor "
-                   "find a standalone zip utility") % zip_filename)
-
-    else:
-        log.info("creating '%s' and adding '%s' to it",
-                 zip_filename, base_dir)
-
-        if not dry_run:
-            try:
-                zip = zipfile.ZipFile(zip_filename, "w",
-                                      compression=zipfile.ZIP_DEFLATED)
-            except RuntimeError:
-                zip = zipfile.ZipFile(zip_filename, "w",
-                                      compression=zipfile.ZIP_STORED)
-
-            if base_dir != os.curdir:
-                path = os.path.normpath(os.path.join(base_dir, ''))
-                zip.write(path, path)
-                log.info("adding '%s'", path)
-            for dirpath, dirnames, filenames in os.walk(base_dir):
-                for name in dirnames:
-                    path = os.path.normpath(os.path.join(dirpath, name, ''))
-                    zip.write(path, path)
-                    log.info("adding '%s'", path)
-                for name in filenames:
-                    path = os.path.normpath(os.path.join(dirpath, name))
-                    if os.path.isfile(path):
-                        zip.write(path, path)
-                        log.info("adding '%s'", path)
-            zip.close()
-
-    return zip_filename
-
-ARCHIVE_FORMATS = {
-    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
-    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
-    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
-    'ztar':  (make_tarball, [('compress', 'compress')], "compressed tar file"),
-    'tar':   (make_tarball, [('compress', None)], "uncompressed tar file"),
-    'zip':   (make_zipfile, [],"ZIP file")
-    }
-
-def check_archive_formats(formats):
-    """Returns the first format from the 'format' list that is unknown.
-
-    If all formats are known, returns None
-    """
-    for format in formats:
-        if format not in ARCHIVE_FORMATS:
-            return format
-    return None
-
-def make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0,
-                 dry_run=0, owner=None, group=None):
-    """Create an archive file (eg. zip or tar).
-
-    'base_name' is the name of the file to create, minus any format-specific
-    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
-    "bztar", "xztar", or "ztar".
-
-    'root_dir' is a directory that will be the root directory of the
-    archive; ie. we typically chdir into 'root_dir' before creating the
-    archive.  'base_dir' is the directory where we start archiving from;
-    ie. 'base_dir' will be the common prefix of all files and
-    directories in the archive.  'root_dir' and 'base_dir' both default
-    to the current directory.  Returns the name of the archive file.
-
-    'owner' and 'group' are used when creating a tar archive. By default,
-    uses the current owner and group.
-    """
-    save_cwd = os.getcwd()
-    if root_dir is not None:
-        log.debug("changing into '%s'", root_dir)
-        base_name = os.path.abspath(base_name)
-        if not dry_run:
-            os.chdir(root_dir)
-
-    if base_dir is None:
-        base_dir = os.curdir
-
-    kwargs = {'dry_run': dry_run}
-
-    try:
-        format_info = ARCHIVE_FORMATS[format]
-    except KeyError:
-        raise ValueError("unknown archive format '%s'" % format)
-
-    func = format_info[0]
-    for arg, val in format_info[1]:
-        kwargs[arg] = val
-
-    if format != 'zip':
-        kwargs['owner'] = owner
-        kwargs['group'] = group
-
-    try:
-        filename = func(base_name, base_dir, **kwargs)
-    finally:
-        if root_dir is not None:
-            log.debug("changing back to '%s'", save_cwd)
-            os.chdir(save_cwd)
-
-    return filename
diff --git a/Lib/distutils/bcppcompiler.py b/Lib/distutils/bcppcompiler.py
deleted file mode 100644
index 9f4c432d90..0000000000
--- a/Lib/distutils/bcppcompiler.py
+++ /dev/null
@@ -1,393 +0,0 @@
-"""distutils.bcppcompiler
-
-Contains BorlandCCompiler, an implementation of the abstract CCompiler class
-for the Borland C++ compiler.
-"""
-
-# This implementation by Lyle Johnson, based on the original msvccompiler.py
-# module and using the directions originally published by Gordon Williams.
-
-# XXX looks like there's a LOT of overlap between these two classes:
-# someone should sit down and factor out the common code as
-# WindowsCCompiler!  --GPW
-
-
-import os
-from distutils.errors import \
-     DistutilsExecError, DistutilsPlatformError, \
-     CompileError, LibError, LinkError, UnknownFileError
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.file_util import write_file
-from distutils.dep_util import newer
-from distutils import log
-
-class BCPPCompiler(CCompiler) :
-    """Concrete class that implements an interface to the Borland C/C++
-    compiler, as defined by the CCompiler abstract class.
-    """
-
-    compiler_type = 'bcpp'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = _c_extensions + _cpp_extensions
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-
-    def __init__ (self,
-                  verbose=0,
-                  dry_run=0,
-                  force=0):
-
-        CCompiler.__init__ (self, verbose, dry_run, force)
-
-        # These executables are assumed to all be in the path.
-        # Borland doesn't seem to use any special registry settings to
-        # indicate their installation locations.
-
-        self.cc = "bcc32.exe"
-        self.linker = "ilink32.exe"
-        self.lib = "tlib.exe"
-
-        self.preprocess_options = None
-        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
-        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']
-
-        self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
-        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
-        self.ldflags_static = []
-        self.ldflags_exe = ['/Gn', '/q', '/x']
-        self.ldflags_exe_debug = ['/Gn', '/q', '/x','/r']
-
-
-    # -- Worker methods ------------------------------------------------
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        macros, objects, extra_postargs, pp_opts, build = \
-                self._setup_compile(output_dir, macros, include_dirs, sources,
-                                    depends, extra_postargs)
-        compile_opts = extra_preargs or []
-        compile_opts.append ('-c')
-        if debug:
-            compile_opts.extend (self.compile_options_debug)
-        else:
-            compile_opts.extend (self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            # XXX why do the normpath here?
-            src = os.path.normpath(src)
-            obj = os.path.normpath(obj)
-            # XXX _setup_compile() did a mkpath() too but before the normpath.
-            # Is it possible to skip the normpath?
-            self.mkpath(os.path.dirname(obj))
-
-            if ext == '.res':
-                # This is already a binary file -- skip it.
-                continue # the 'for' loop
-            if ext == '.rc':
-                # This needs to be compiled to a .res file -- do it now.
-                try:
-                    self.spawn (["brcc32", "-fo", obj, src])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue # the 'for' loop
-
-            # The next two are both for the real compiler.
-            if ext in self._c_extensions:
-                input_opt = ""
-            elif ext in self._cpp_extensions:
-                input_opt = "-P"
-            else:
-                # Unknown file type -- no extra options.  The compiler
-                # will probably fail, but let it just in case this is a
-                # file the compiler recognizes even if we don't.
-                input_opt = ""
-
-            output_opt = "-o" + obj
-
-            # Compiler command line syntax is: "bcc32 [options] file(s)".
-            # Note that the source file names must appear at the end of
-            # the command line.
-            try:
-                self.spawn ([self.cc] + compile_opts + pp_opts +
-                            [input_opt, output_opt] +
-                            extra_postargs + [src])
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-    # compile ()
-
-
-    def create_static_lib (self,
-                           objects,
-                           output_libname,
-                           output_dir=None,
-                           debug=0,
-                           target_lang=None):
-
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        output_filename = \
-            self.library_filename (output_libname, output_dir=output_dir)
-
-        if self._need_link (objects, output_filename):
-            lib_args = [output_filename, '/u'] + objects
-            if debug:
-                pass                    # XXX what goes here?
-            try:
-                self.spawn ([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # create_static_lib ()
-
-
-    def link (self,
-              target_desc,
-              objects,
-              output_filename,
-              output_dir=None,
-              libraries=None,
-              library_dirs=None,
-              runtime_library_dirs=None,
-              export_symbols=None,
-              debug=0,
-              extra_preargs=None,
-              extra_postargs=None,
-              build_temp=None,
-              target_lang=None):
-
-        # XXX this ignores 'build_temp'!  should follow the lead of
-        # msvccompiler.py
-
-        (objects, output_dir) = self._fix_object_args (objects, output_dir)
-        (libraries, library_dirs, runtime_library_dirs) = \
-            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)
-
-        if runtime_library_dirs:
-            log.warn("I don't know what to do with 'runtime_library_dirs': %s",
-                     str(runtime_library_dirs))
-
-        if output_dir is not None:
-            output_filename = os.path.join (output_dir, output_filename)
-
-        if self._need_link (objects, output_filename):
-
-            # Figure out linker args based on type of target.
-            if target_desc == CCompiler.EXECUTABLE:
-                startup_obj = 'c0w32'
-                if debug:
-                    ld_args = self.ldflags_exe_debug[:]
-                else:
-                    ld_args = self.ldflags_exe[:]
-            else:
-                startup_obj = 'c0d32'
-                if debug:
-                    ld_args = self.ldflags_shared_debug[:]
-                else:
-                    ld_args = self.ldflags_shared[:]
-
-
-            # Create a temporary exports file for use by the linker
-            if export_symbols is None:
-                def_file = ''
-            else:
-                head, tail = os.path.split (output_filename)
-                modname, ext = os.path.splitext (tail)
-                temp_dir = os.path.dirname(objects[0]) # preserve tree structure
-                def_file = os.path.join (temp_dir, '%s.def' % modname)
-                contents = ['EXPORTS']
-                for sym in (export_symbols or []):
-                    contents.append('  %s=_%s' % (sym, sym))
-                self.execute(write_file, (def_file, contents),
-                             "writing %s" % def_file)
-
-            # Borland C++ has problems with '/' in paths
-            objects2 = map(os.path.normpath, objects)
-            # split objects in .obj and .res files
-            # Borland C++ needs them at different positions in the command line
-            objects = [startup_obj]
-            resources = []
-            for file in objects2:
-                (base, ext) = os.path.splitext(os.path.normcase(file))
-                if ext == '.res':
-                    resources.append(file)
-                else:
-                    objects.append(file)
-
-
-            for l in library_dirs:
-                ld_args.append("/L%s" % os.path.normpath(l))
-            ld_args.append("/L.") # we sometimes use relative paths
-
-            # list of object files
-            ld_args.extend(objects)
-
-            # XXX the command-line syntax for Borland C++ is a bit wonky;
-            # certain filenames are jammed together in one big string, but
-            # comma-delimited.  This doesn't mesh too well with the
-            # Unix-centric attitude (with a DOS/Windows quoting hack) of
-            # 'spawn()', so constructing the argument list is a bit
-            # awkward.  Note that doing the obvious thing and jamming all
-            # the filenames and commas into one argument would be wrong,
-            # because 'spawn()' would quote any filenames with spaces in
-            # them.  Arghghh!.  Apparently it works fine as coded...
-
-            # name of dll/exe file
-            ld_args.extend([',',output_filename])
-            # no map file and start libraries
-            ld_args.append(',,')
-
-            for lib in libraries:
-                # see if we find it and if there is a bcpp specific lib
-                # (xxx_bcpp.lib)
-                libfile = self.find_library_file(library_dirs, lib, debug)
-                if libfile is None:
-                    ld_args.append(lib)
-                    # probably a BCPP internal library -- don't warn
-                else:
-                    # full name which prefers bcpp_xxx.lib over xxx.lib
-                    ld_args.append(libfile)
-
-            # some default libraries
-            ld_args.append ('import32')
-            ld_args.append ('cw32mt')
-
-            # def file for export symbols
-            ld_args.extend([',',def_file])
-            # add resource files
-            ld_args.append(',')
-            ld_args.extend(resources)
-
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath (os.path.dirname (output_filename))
-            try:
-                self.spawn ([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # link ()
-
-    # -- Miscellaneous methods -----------------------------------------
-
-
-    def find_library_file (self, dirs, lib, debug=0):
-        # List of effective library names to try, in order of preference:
-        # xxx_bcpp.lib is better than xxx.lib
-        # and xxx_d.lib is better than xxx.lib if debug is set
-        #
-        # The "_bcpp" suffix is to handle a Python installation for people
-        # with multiple compilers (primarily Distutils hackers, I suspect
-        # ;-).  The idea is they'd have one static library for each
-        # compiler they care about, since (almost?) every Windows compiler
-        # seems to have a different format for static libraries.
-        if debug:
-            dlib = (lib + "_d")
-            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
-        else:
-            try_names = (lib + "_bcpp", lib)
-
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename(name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # overwrite the one from CCompiler to support rc and res-files
-    def object_filenames (self,
-                          source_filenames,
-                          strip_dir=0,
-                          output_dir=''):
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
-            (base, ext) = os.path.splitext (os.path.normcase(src_name))
-            if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
-                      (ext, src_name))
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext == '.res':
-                # these can go unchanged
-                obj_names.append (os.path.join (output_dir, base + ext))
-            elif ext == '.rc':
-                # these need to be compiled to .res-files
-                obj_names.append (os.path.join (output_dir, base + '.res'))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                            base + self.obj_extension))
-        return obj_names
-
-    # object_filenames ()
-
-    def preprocess (self,
-                    source,
-                    output_file=None,
-                    macros=None,
-                    include_dirs=None,
-                    extra_preargs=None,
-                    extra_postargs=None):
-
-        (_, macros, include_dirs) = \
-            self._fix_compile_args(None, macros, include_dirs)
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = ['cpp32.exe'] + pp_opts
-        if output_file is not None:
-            pp_args.append('-o' + output_file)
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # We need to preprocess: either we're being forced to, or the
-        # source file is newer than the target (or the target doesn't
-        # exist).
-        if self.force or output_file is None or newer(source, output_file):
-            if output_file:
-                self.mkpath(os.path.dirname(output_file))
-            try:
-                self.spawn(pp_args)
-            except DistutilsExecError as msg:
-                print(msg)
-                raise CompileError(msg)
-
-    # preprocess()
diff --git a/Lib/distutils/ccompiler.py b/Lib/distutils/ccompiler.py
deleted file mode 100644
index b71d1d39bc..0000000000
--- a/Lib/distutils/ccompiler.py
+++ /dev/null
@@ -1,1115 +0,0 @@
-"""distutils.ccompiler
-
-Contains CCompiler, an abstract base class that defines the interface
-for the Distutils compiler abstraction model."""
-
-import sys, os, re
-from distutils.errors import *
-from distutils.spawn import spawn
-from distutils.file_util import move_file
-from distutils.dir_util import mkpath
-from distutils.dep_util import newer_pairwise, newer_group
-from distutils.util import split_quoted, execute
-from distutils import log
-
-class CCompiler:
-    """Abstract base class to define the interface that must be implemented
-    by real compiler classes.  Also has some utility methods used by
-    several compiler classes.
-
-    The basic idea behind a compiler abstraction class is that each
-    instance can be used for all the compile/link steps in building a
-    single project.  Thus, attributes common to all of those compile and
-    link steps -- include directories, macros to define, libraries to link
-    against, etc. -- are attributes of the compiler instance.  To allow for
-    variability in how individual files are treated, most of those
-    attributes may be varied on a per-compilation or per-link basis.
-    """
-
-    # 'compiler_type' is a class attribute that identifies this class.  It
-    # keeps code that wants to know what kind of compiler it's dealing with
-    # from having to import all possible compiler classes just to do an
-    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
-    # should really, really be one of the keys of the 'compiler_class'
-    # dictionary (see below -- used by the 'new_compiler()' factory
-    # function) -- authors of new compiler interface classes are
-    # responsible for updating 'compiler_class'!
-    compiler_type = None
-
-    # XXX things not handled by this compiler abstraction model:
-    #   * client can't provide additional options for a compiler,
-    #     e.g. warning, optimization, debugging flags.  Perhaps this
-    #     should be the domain of concrete compiler abstraction classes
-    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
-    #     class should have methods for the common ones.
-    #   * can't completely override the include or library searchg
-    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
-    #     I'm not sure how widely supported this is even by Unix
-    #     compilers, much less on other platforms.  And I'm even less
-    #     sure how useful it is; maybe for cross-compiling, but
-    #     support for that is a ways off.  (And anyways, cross
-    #     compilers probably have a dedicated binary with the
-    #     right paths compiled in.  I hope.)
-    #   * can't do really freaky things with the library list/library
-    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
-    #     different versions of libfoo.a in different locations.  I
-    #     think this is useless without the ability to null out the
-    #     library search path anyways.
-
-
-    # Subclasses that rely on the standard filename generation methods
-    # implemented below should override these; see the comment near
-    # those methods ('object_filenames()' et. al.) for details:
-    src_extensions = None               # list of strings
-    obj_extension = None                # string
-    static_lib_extension = None
-    shared_lib_extension = None         # string
-    static_lib_format = None            # format string
-    shared_lib_format = None            # prob. same as static_lib_format
-    exe_extension = None                # string
-
-    # Default language settings. language_map is used to detect a source
-    # file or Extension target language, checking source filenames.
-    # language_order is used to detect the language precedence, when deciding
-    # what language to use when mixing source types. For example, if some
-    # extension has two files with ".c" extension, and one with ".cpp", it
-    # is still linked as c++.
-    language_map = {".c"   : "c",
-                    ".cc"  : "c++",
-                    ".cpp" : "c++",
-                    ".cxx" : "c++",
-                    ".m"   : "objc",
-                   }
-    language_order = ["c++", "objc", "c"]
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        self.dry_run = dry_run
-        self.force = force
-        self.verbose = verbose
-
-        # 'output_dir': a common output directory for object, library,
-        # shared object, and shared library files
-        self.output_dir = None
-
-        # 'macros': a list of macro definitions (or undefinitions).  A
-        # macro definition is a 2-tuple (name, value), where the value is
-        # either a string or None (no explicit value).  A macro
-        # undefinition is a 1-tuple (name,).
-        self.macros = []
-
-        # 'include_dirs': a list of directories to search for include files
-        self.include_dirs = []
-
-        # 'libraries': a list of libraries to include in any link
-        # (library names, not filenames: eg. "foo" not "libfoo.a")
-        self.libraries = []
-
-        # 'library_dirs': a list of directories to search for libraries
-        self.library_dirs = []
-
-        # 'runtime_library_dirs': a list of directories to search for
-        # shared libraries/objects at runtime
-        self.runtime_library_dirs = []
-
-        # 'objects': a list of object files (or similar, such as explicitly
-        # named library files) to include on any link
-        self.objects = []
-
-        for key in self.executables.keys():
-            self.set_executable(key, self.executables[key])
-
-    def set_executables(self, **kwargs):
-        """Define the executables (and options for them) that will be run
-        to perform the various stages of compilation.  The exact set of
-        executables that may be specified here depends on the compiler
-        class (via the 'executables' class attribute), but most will have:
-          compiler      the C/C++ compiler
-          linker_so     linker used to create shared objects and libraries
-          linker_exe    linker used to create binary executables
-          archiver      static library creator
-
-        On platforms with a command-line (Unix, DOS/Windows), each of these
-        is a string that will be split into executable name and (optional)
-        list of arguments.  (Splitting the string is done similarly to how
-        Unix shells operate: words are delimited by spaces, but quotes and
-        backslashes can override this.  See
-        'distutils.util.split_quoted()'.)
-        """
-
-        # Note that some CCompiler implementation classes will define class
-        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
-        # this is appropriate when a compiler class is for exactly one
-        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
-        # classes (UnixCCompiler, in particular) are driven by information
-        # discovered at run-time, since there are many different ways to do
-        # basically the same things with Unix C compilers.
-
-        for key in kwargs:
-            if key not in self.executables:
-                raise ValueError("unknown executable '%s' for class %s" %
-                      (key, self.__class__.__name__))
-            self.set_executable(key, kwargs[key])
-
-    def set_executable(self, key, value):
-        if isinstance(value, str):
-            setattr(self, key, split_quoted(value))
-        else:
-            setattr(self, key, value)
-
-    def _find_macro(self, name):
-        i = 0
-        for defn in self.macros:
-            if defn[0] == name:
-                return i
-            i += 1
-        return None
-
-    def _check_macro_definitions(self, definitions):
-        """Ensures that every element of 'definitions' is a valid macro
-        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
-        nothing if all definitions are OK, raise TypeError otherwise.
-        """
-        for defn in definitions:
-            if not (isinstance(defn, tuple) and
-                    (len(defn) in (1, 2) and
-                      (isinstance (defn[1], str) or defn[1] is None)) and
-                    isinstance (defn[0], str)):
-                raise TypeError(("invalid macro definition '%s': " % defn) + \
-                      "must be tuple (string,), (string, string), or " + \
-                      "(string, None)")
-
-
-    # -- Bookkeeping methods -------------------------------------------
-
-    def define_macro(self, name, value=None):
-        """Define a preprocessor macro for all compilations driven by this
-        compiler object.  The optional parameter 'value' should be a
-        string; if it is not supplied, then the macro will be defined
-        without an explicit value and the exact outcome depends on the
-        compiler used (XXX true? does ANSI say anything about this?)
-        """
-        # Delete from the list of macro definitions/undefinitions if
-        # already there (so that this one will take precedence).
-        i = self._find_macro (name)
-        if i is not None:
-            del self.macros[i]
-
-        self.macros.append((name, value))
-
-    def undefine_macro(self, name):
-        """Undefine a preprocessor macro for all compilations driven by
-        this compiler object.  If the same macro is defined by
-        'define_macro()' and undefined by 'undefine_macro()' the last call
-        takes precedence (including multiple redefinitions or
-        undefinitions).  If the macro is redefined/undefined on a
-        per-compilation basis (ie. in the call to 'compile()'), then that
-        takes precedence.
-        """
-        # Delete from the list of macro definitions/undefinitions if
-        # already there (so that this one will take precedence).
-        i = self._find_macro (name)
-        if i is not None:
-            del self.macros[i]
-
-        undefn = (name,)
-        self.macros.append(undefn)
-
-    def add_include_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        header files.  The compiler is instructed to search directories in
-        the order in which they are supplied by successive calls to
-        'add_include_dir()'.
-        """
-        self.include_dirs.append(dir)
-
-    def set_include_dirs(self, dirs):
-        """Set the list of directories that will be searched to 'dirs' (a
-        list of strings).  Overrides any preceding calls to
-        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
-        to the list passed to 'set_include_dirs()'.  This does not affect
-        any list of standard include directories that the compiler may
-        search by default.
-        """
-        self.include_dirs = dirs[:]
-
-    def add_library(self, libname):
-        """Add 'libname' to the list of libraries that will be included in
-        all links driven by this compiler object.  Note that 'libname'
-        should *not* be the name of a file containing a library, but the
-        name of the library itself: the actual filename will be inferred by
-        the linker, the compiler, or the compiler class (depending on the
-        platform).
-
-        The linker will be instructed to link against libraries in the
-        order they were supplied to 'add_library()' and/or
-        'set_libraries()'.  It is perfectly valid to duplicate library
-        names; the linker will be instructed to link against libraries as
-        many times as they are mentioned.
-        """
-        self.libraries.append(libname)
-
-    def set_libraries(self, libnames):
-        """Set the list of libraries to be included in all links driven by
-        this compiler object to 'libnames' (a list of strings).  This does
-        not affect any standard system libraries that the linker may
-        include by default.
-        """
-        self.libraries = libnames[:]
-
-    def add_library_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        libraries specified to 'add_library()' and 'set_libraries()'.  The
-        linker will be instructed to search for libraries in the order they
-        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
-        """
-        self.library_dirs.append(dir)
-
-    def set_library_dirs(self, dirs):
-        """Set the list of library search directories to 'dirs' (a list of
-        strings).  This does not affect any standard library search path
-        that the linker may search by default.
-        """
-        self.library_dirs = dirs[:]
-
-    def add_runtime_library_dir(self, dir):
-        """Add 'dir' to the list of directories that will be searched for
-        shared libraries at runtime.
-        """
-        self.runtime_library_dirs.append(dir)
-
-    def set_runtime_library_dirs(self, dirs):
-        """Set the list of directories to search for shared libraries at
-        runtime to 'dirs' (a list of strings).  This does not affect any
-        standard search path that the runtime linker may search by
-        default.
-        """
-        self.runtime_library_dirs = dirs[:]
-
-    def add_link_object(self, object):
-        """Add 'object' to the list of object files (or analogues, such as
-        explicitly named library files or the output of "resource
-        compilers") to be included in every link driven by this compiler
-        object.
-        """
-        self.objects.append(object)
-
-    def set_link_objects(self, objects):
-        """Set the list of object files (or analogues) to be included in
-        every link to 'objects'.  This does not affect any standard object
-        files that the linker may include by default (such as system
-        libraries).
-        """
-        self.objects = objects[:]
-
-
-    # -- Private utility methods --------------------------------------
-    # (here for the convenience of subclasses)
-
-    # Helper method to prep compiler in subclass compile() methods
-
-    def _setup_compile(self, outdir, macros, incdirs, sources, depends,
-                       extra):
-        """Process arguments and decide which source files to compile."""
-        if outdir is None:
-            outdir = self.output_dir
-        elif not isinstance(outdir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        if macros is None:
-            macros = self.macros
-        elif isinstance(macros, list):
-            macros = macros + (self.macros or [])
-        else:
-            raise TypeError("'macros' (if supplied) must be a list of tuples")
-
-        if incdirs is None:
-            incdirs = self.include_dirs
-        elif isinstance(incdirs, (list, tuple)):
-            incdirs = list(incdirs) + (self.include_dirs or [])
-        else:
-            raise TypeError(
-                  "'include_dirs' (if supplied) must be a list of strings")
-
-        if extra is None:
-            extra = []
-
-        # Get the list of expected output (object) files
-        objects = self.object_filenames(sources, strip_dir=0,
-                                        output_dir=outdir)
-        assert len(objects) == len(sources)
-
-        pp_opts = gen_preprocess_options(macros, incdirs)
-
-        build = {}
-        for i in range(len(sources)):
-            src = sources[i]
-            obj = objects[i]
-            ext = os.path.splitext(src)[1]
-            self.mkpath(os.path.dirname(obj))
-            build[obj] = (src, ext)
-
-        return macros, objects, extra, pp_opts, build
-
-    def _get_cc_args(self, pp_opts, debug, before):
-        # works for unixccompiler, cygwinccompiler
-        cc_args = pp_opts + ['-c']
-        if debug:
-            cc_args[:0] = ['-g']
-        if before:
-            cc_args[:0] = before
-        return cc_args
-
-    def _fix_compile_args(self, output_dir, macros, include_dirs):
-        """Typecheck and fix-up some of the arguments to the 'compile()'
-        method, and return fixed-up values.  Specifically: if 'output_dir'
-        is None, replaces it with 'self.output_dir'; ensures that 'macros'
-        is a list, and augments it with 'self.macros'; ensures that
-        'include_dirs' is a list, and augments it with 'self.include_dirs'.
-        Guarantees that the returned values are of the correct type,
-        i.e. for 'output_dir' either string or None, and for 'macros' and
-        'include_dirs' either list or None.
-        """
-        if output_dir is None:
-            output_dir = self.output_dir
-        elif not isinstance(output_dir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        if macros is None:
-            macros = self.macros
-        elif isinstance(macros, list):
-            macros = macros + (self.macros or [])
-        else:
-            raise TypeError("'macros' (if supplied) must be a list of tuples")
-
-        if include_dirs is None:
-            include_dirs = self.include_dirs
-        elif isinstance(include_dirs, (list, tuple)):
-            include_dirs = list(include_dirs) + (self.include_dirs or [])
-        else:
-            raise TypeError(
-                  "'include_dirs' (if supplied) must be a list of strings")
-
-        return output_dir, macros, include_dirs
-
-    def _prep_compile(self, sources, output_dir, depends=None):
-        """Decide which souce files must be recompiled.
-
-        Determine the list of object files corresponding to 'sources',
-        and figure out which ones really need to be recompiled.
-        Return a list of all object files and a dictionary telling
-        which source files can be skipped.
-        """
-        # Get the list of expected output (object) files
-        objects = self.object_filenames(sources, output_dir=output_dir)
-        assert len(objects) == len(sources)
-
-        # Return an empty dict for the "which source files can be skipped"
-        # return value to preserve API compatibility.
-        return objects, {}
-
-    def _fix_object_args(self, objects, output_dir):
-        """Typecheck and fix up some arguments supplied to various methods.
-        Specifically: ensure that 'objects' is a list; if output_dir is
-        None, replace with self.output_dir.  Return fixed versions of
-        'objects' and 'output_dir'.
-        """
-        if not isinstance(objects, (list, tuple)):
-            raise TypeError("'objects' must be a list or tuple of strings")
-        objects = list(objects)
-
-        if output_dir is None:
-            output_dir = self.output_dir
-        elif not isinstance(output_dir, str):
-            raise TypeError("'output_dir' must be a string or None")
-
-        return (objects, output_dir)
-
-    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
-        """Typecheck and fix up some of the arguments supplied to the
-        'link_*' methods.  Specifically: ensure that all arguments are
-        lists, and augment them with their permanent versions
-        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
-        fixed versions of all arguments.
-        """
-        if libraries is None:
-            libraries = self.libraries
-        elif isinstance(libraries, (list, tuple)):
-            libraries = list (libraries) + (self.libraries or [])
-        else:
-            raise TypeError(
-                  "'libraries' (if supplied) must be a list of strings")
-
-        if library_dirs is None:
-            library_dirs = self.library_dirs
-        elif isinstance(library_dirs, (list, tuple)):
-            library_dirs = list (library_dirs) + (self.library_dirs or [])
-        else:
-            raise TypeError(
-                  "'library_dirs' (if supplied) must be a list of strings")
-
-        if runtime_library_dirs is None:
-            runtime_library_dirs = self.runtime_library_dirs
-        elif isinstance(runtime_library_dirs, (list, tuple)):
-            runtime_library_dirs = (list(runtime_library_dirs) +
-                                    (self.runtime_library_dirs or []))
-        else:
-            raise TypeError("'runtime_library_dirs' (if supplied) "
-                            "must be a list of strings")
-
-        return (libraries, library_dirs, runtime_library_dirs)
-
-    def _need_link(self, objects, output_file):
-        """Return true if we need to relink the files listed in 'objects'
-        to recreate 'output_file'.
-        """
-        if self.force:
-            return True
-        else:
-            if self.dry_run:
-                newer = newer_group (objects, output_file, missing='newer')
-            else:
-                newer = newer_group (objects, output_file)
-            return newer
-
-    def detect_language(self, sources):
-        """Detect the language of a given file, or list of files. Uses
-        language_map, and language_order to do the job.
-        """
-        if not isinstance(sources, list):
-            sources = [sources]
-        lang = None
-        index = len(self.language_order)
-        for source in sources:
-            base, ext = os.path.splitext(source)
-            extlang = self.language_map.get(ext)
-            try:
-                extindex = self.language_order.index(extlang)
-                if extindex < index:
-                    lang = extlang
-                    index = extindex
-            except ValueError:
-                pass
-        return lang
-
-
-    # -- Worker methods ------------------------------------------------
-    # (must be implemented by subclasses)
-
-    def preprocess(self, source, output_file=None, macros=None,
-                   include_dirs=None, extra_preargs=None, extra_postargs=None):
-        """Preprocess a single C/C++ source file, named in 'source'.
-        Output will be written to file named 'output_file', or stdout if
-        'output_file' not supplied.  'macros' is a list of macro
-        definitions as for 'compile()', which will augment the macros set
-        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
-        list of directory names that will be added to the default list.
-
-        Raises PreprocessError on failure.
-        """
-        pass
-
-    def compile(self, sources, output_dir=None, macros=None,
-                include_dirs=None, debug=0, extra_preargs=None,
-                extra_postargs=None, depends=None):
-        """Compile one or more source files.
-
-        'sources' must be a list of filenames, most likely C/C++
-        files, but in reality anything that can be handled by a
-        particular compiler and compiler class (eg. MSVCCompiler can
-        handle resource files in 'sources').  Return a list of object
-        filenames, one per source filename in 'sources'.  Depending on
-        the implementation, not all source files will necessarily be
-        compiled, but all corresponding object filenames will be
-        returned.
-
-        If 'output_dir' is given, object files will be put under it, while
-        retaining their original path component.  That is, "foo/bar.c"
-        normally compiles to "foo/bar.o" (for a Unix implementation); if
-        'output_dir' is "build", then it would compile to
-        "build/foo/bar.o".
-
-        'macros', if given, must be a list of macro definitions.  A macro
-        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
-        The former defines a macro; if the value is None, the macro is
-        defined without an explicit value.  The 1-tuple case undefines a
-        macro.  Later definitions/redefinitions/ undefinitions take
-        precedence.
-
-        'include_dirs', if given, must be a list of strings, the
-        directories to add to the default include file search path for this
-        compilation only.
-
-        'debug' is a boolean; if true, the compiler will be instructed to
-        output debug symbols in (or alongside) the object file(s).
-
-        'extra_preargs' and 'extra_postargs' are implementation- dependent.
-        On platforms that have the notion of a command-line (e.g. Unix,
-        DOS/Windows), they are most likely lists of strings: extra
-        command-line arguments to prepand/append to the compiler command
-        line.  On other platforms, consult the implementation class
-        documentation.  In any event, they are intended as an escape hatch
-        for those occasions when the abstract compiler framework doesn't
-        cut the mustard.
-
-        'depends', if given, is a list of filenames that all targets
-        depend on.  If a source file is older than any file in
-        depends, then the source file will be recompiled.  This
-        supports dependency tracking, but only at a coarse
-        granularity.
-
-        Raises CompileError on failure.
-        """
-        # A concrete compiler class can either override this method
-        # entirely or implement _compile().
-        macros, objects, extra_postargs, pp_opts, build = \
-                self._setup_compile(output_dir, macros, include_dirs, sources,
-                                    depends, extra_postargs)
-        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)
-
-        # Return *all* object filenames, not just the ones we just built.
-        return objects
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        """Compile 'src' to product 'obj'."""
-        # A concrete compiler class that does not override compile()
-        # should implement _compile().
-        pass
-
-    def create_static_lib(self, objects, output_libname, output_dir=None,
-                          debug=0, target_lang=None):
-        """Link a bunch of stuff together to create a static library file.
-        The "bunch of stuff" consists of the list of object files supplied
-        as 'objects', the extra object files supplied to
-        'add_link_object()' and/or 'set_link_objects()', the libraries
-        supplied to 'add_library()' and/or 'set_libraries()', and the
-        libraries supplied as 'libraries' (if any).
-
-        'output_libname' should be a library name, not a filename; the
-        filename will be inferred from the library name.  'output_dir' is
-        the directory where the library file will be put.
-
-        'debug' is a boolean; if true, debugging information will be
-        included in the library (note that on most platforms, it is the
-        compile step where this matters: the 'debug' flag is included here
-        just for consistency).
-
-        'target_lang' is the target language for which the given objects
-        are being compiled. This allows specific linkage time treatment of
-        certain languages.
-
-        Raises LibError on failure.
-        """
-        pass
-
-
-    # values for target_desc parameter in link()
-    SHARED_OBJECT = "shared_object"
-    SHARED_LIBRARY = "shared_library"
-    EXECUTABLE = "executable"
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-        """Link a bunch of stuff together to create an executable or
-        shared library file.
-
-        The "bunch of stuff" consists of the list of object files supplied
-        as 'objects'.  'output_filename' should be a filename.  If
-        'output_dir' is supplied, 'output_filename' is relative to it
-        (i.e. 'output_filename' can provide directory components if
-        needed).
-
-        'libraries' is a list of libraries to link against.  These are
-        library names, not filenames, since they're translated into
-        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
-        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
-        directory component, which means the linker will look in that
-        specific directory rather than searching all the normal locations.
-
-        'library_dirs', if supplied, should be a list of directories to
-        search for libraries that were specified as bare library names
-        (ie. no directory component).  These are on top of the system
-        default and those supplied to 'add_library_dir()' and/or
-        'set_library_dirs()'.  'runtime_library_dirs' is a list of
-        directories that will be embedded into the shared library and used
-        to search for other shared libraries that *it* depends on at
-        run-time.  (This may only be relevant on Unix.)
-
-        'export_symbols' is a list of symbols that the shared library will
-        export.  (This appears to be relevant only on Windows.)
-
-        'debug' is as for 'compile()' and 'create_static_lib()', with the
-        slight distinction that it actually matters on most platforms (as
-        opposed to 'create_static_lib()', which includes a 'debug' flag
-        mostly for form's sake).
-
-        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
-        of course that they supply command-line arguments for the
-        particular linker being used).
-
-        'target_lang' is the target language for which the given objects
-        are being compiled. This allows specific linkage time treatment of
-        certain languages.
-
-        Raises LinkError on failure.
-        """
-        raise NotImplementedError
-
-
-    # Old 'link_*()' methods, rewritten to use the new 'link()' method.
-
-    def link_shared_lib(self,
-                        objects,
-                        output_libname,
-                        output_dir=None,
-                        libraries=None,
-                        library_dirs=None,
-                        runtime_library_dirs=None,
-                        export_symbols=None,
-                        debug=0,
-                        extra_preargs=None,
-                        extra_postargs=None,
-                        build_temp=None,
-                        target_lang=None):
-        self.link(CCompiler.SHARED_LIBRARY, objects,
-                  self.library_filename(output_libname, lib_type='shared'),
-                  output_dir,
-                  libraries, library_dirs, runtime_library_dirs,
-                  export_symbols, debug,
-                  extra_preargs, extra_postargs, build_temp, target_lang)
-
-
-    def link_shared_object(self,
-                           objects,
-                           output_filename,
-                           output_dir=None,
-                           libraries=None,
-                           library_dirs=None,
-                           runtime_library_dirs=None,
-                           export_symbols=None,
-                           debug=0,
-                           extra_preargs=None,
-                           extra_postargs=None,
-                           build_temp=None,
-                           target_lang=None):
-        self.link(CCompiler.SHARED_OBJECT, objects,
-                  output_filename, output_dir,
-                  libraries, library_dirs, runtime_library_dirs,
-                  export_symbols, debug,
-                  extra_preargs, extra_postargs, build_temp, target_lang)
-
-
-    def link_executable(self,
-                        objects,
-                        output_progname,
-                        output_dir=None,
-                        libraries=None,
-                        library_dirs=None,
-                        runtime_library_dirs=None,
-                        debug=0,
-                        extra_preargs=None,
-                        extra_postargs=None,
-                        target_lang=None):
-        self.link(CCompiler.EXECUTABLE, objects,
-                  self.executable_filename(output_progname), output_dir,
-                  libraries, library_dirs, runtime_library_dirs, None,
-                  debug, extra_preargs, extra_postargs, None, target_lang)
-
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function; there is
-    # no appropriate default implementation so subclasses should
-    # implement all of these.
-
-    def library_dir_option(self, dir):
-        """Return the compiler option to add 'dir' to the list of
-        directories searched for libraries.
-        """
-        raise NotImplementedError
-
-    def runtime_library_dir_option(self, dir):
-        """Return the compiler option to add 'dir' to the list of
-        directories searched for runtime libraries.
-        """
-        raise NotImplementedError
-
-    def library_option(self, lib):
-        """Return the compiler option to add 'lib' to the list of libraries
-        linked into the shared library or executable.
-        """
-        raise NotImplementedError
-
-    def has_function(self, funcname, includes=None, include_dirs=None,
-                     libraries=None, library_dirs=None):
-        """Return a boolean indicating whether funcname is supported on
-        the current platform.  The optional arguments can be used to
-        augment the compilation environment.
-        """
-        # this can't be included at module scope because it tries to
-        # import math which might not be available at that point - maybe
-        # the necessary logic should just be inlined?
-        import tempfile
-        if includes is None:
-            includes = []
-        if include_dirs is None:
-            include_dirs = []
-        if libraries is None:
-            libraries = []
-        if library_dirs is None:
-            library_dirs = []
-        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
-        f = os.fdopen(fd, "w")
-        try:
-            for incl in includes:
-                f.write("""#include "%s"\n""" % incl)
-            f.write("""\
-main (int argc, char **argv) {
-    %s();
-}
-""" % funcname)
-        finally:
-            f.close()
-        try:
-            objects = self.compile([fname], include_dirs=include_dirs)
-        except CompileError:
-            return False
-
-        try:
-            self.link_executable(objects, "a.out",
-                                 libraries=libraries,
-                                 library_dirs=library_dirs)
-        except (LinkError, TypeError):
-            return False
-        return True
-
-    def find_library_file (self, dirs, lib, debug=0):
-        """Search the specified list of directories for a static or shared
-        library file 'lib' and return the full path to that file.  If
-        'debug' true, look for a debugging version (if that makes sense on
-        the current platform).  Return None if 'lib' wasn't found in any of
-        the specified directories.
-        """
-        raise NotImplementedError
-
-    # -- Filename generation methods -----------------------------------
-
-    # The default implementation of the filename generating methods are
-    # prejudiced towards the Unix/DOS/Windows view of the world:
-    #   * object files are named by replacing the source file extension
-    #     (eg. .c/.cpp -> .o/.obj)
-    #   * library files (shared or static) are named by plugging the
-    #     library name and extension into a format string, eg.
-    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
-    #   * executables are named by appending an extension (possibly
-    #     empty) to the program name: eg. progname + ".exe" for
-    #     Windows
-    #
-    # To reduce redundant code, these methods expect to find
-    # several attributes in the current object (presumably defined
-    # as class attributes):
-    #   * src_extensions -
-    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
-    #   * obj_extension -
-    #     object file extension, eg. '.o' or '.obj'
-    #   * static_lib_extension -
-    #     extension for static library files, eg. '.a' or '.lib'
-    #   * shared_lib_extension -
-    #     extension for shared library/object files, eg. '.so', '.dll'
-    #   * static_lib_format -
-    #     format string for generating static library filenames,
-    #     eg. 'lib%s.%s' or '%s.%s'
-    #   * shared_lib_format
-    #     format string for generating shared library filenames
-    #     (probably same as static_lib_format, since the extension
-    #     is one of the intended parameters to the format string)
-    #   * exe_extension -
-    #     extension for executable files, eg. '' or '.exe'
-
-    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
-        if output_dir is None:
-            output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            base, ext = os.path.splitext(src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                raise UnknownFileError(
-                      "unknown file type '%s' (from '%s')" % (ext, src_name))
-            if strip_dir:
-                base = os.path.basename(base)
-            obj_names.append(os.path.join(output_dir,
-                                          base + self.obj_extension))
-        return obj_names
-
-    def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if strip_dir:
-            basename = os.path.basename(basename)
-        return os.path.join(output_dir, basename + self.shared_lib_extension)
-
-    def executable_filename(self, basename, strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if strip_dir:
-            basename = os.path.basename(basename)
-        return os.path.join(output_dir, basename + (self.exe_extension or ''))
-
-    def library_filename(self, libname, lib_type='static',     # or 'shared'
-                         strip_dir=0, output_dir=''):
-        assert output_dir is not None
-        if lib_type not in ("static", "shared", "dylib", "xcode_stub"):
-            raise ValueError(
-                  "'lib_type' must be \"static\", \"shared\", \"dylib\", or \"xcode_stub\"")
-        fmt = getattr(self, lib_type + "_lib_format")
-        ext = getattr(self, lib_type + "_lib_extension")
-
-        dir, base = os.path.split(libname)
-        filename = fmt % (base, ext)
-        if strip_dir:
-            dir = ''
-
-        return os.path.join(output_dir, dir, filename)
-
-
-    # -- Utility methods -----------------------------------------------
-
-    def announce(self, msg, level=1):
-        log.debug(msg)
-
-    def debug_print(self, msg):
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-
-    def warn(self, msg):
-        sys.stderr.write("warning: %s\n" % msg)
-
-    def execute(self, func, args, msg=None, level=1):
-        execute(func, args, msg, self.dry_run)
-
-    def spawn(self, cmd):
-        spawn(cmd, dry_run=self.dry_run)
-
-    def move_file(self, src, dst):
-        return move_file(src, dst, dry_run=self.dry_run)
-
-    def mkpath (self, name, mode=0o777):
-        mkpath(name, mode, dry_run=self.dry_run)
-
-
-# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
-# type for that platform. Keys are interpreted as re match
-# patterns. Order is important; platform mappings are preferred over
-# OS names.
-_default_compilers = (
-
-    # Platform string mappings
-
-    # on a cygwin built python we can use gcc like an ordinary UNIXish
-    # compiler
-    ('cygwin.*', 'unix'),
-
-    # OS name mappings
-    ('posix', 'unix'),
-    ('nt', 'msvc'),
-
-    )
-
-def get_default_compiler(osname=None, platform=None):
-    """Determine the default compiler to use for the given platform.
-
-       osname should be one of the standard Python OS names (i.e. the
-       ones returned by os.name) and platform the common value
-       returned by sys.platform for the platform in question.
-
-       The default values are os.name and sys.platform in case the
-       parameters are not given.
-    """
-    if osname is None:
-        osname = os.name
-    if platform is None:
-        platform = sys.platform
-    for pattern, compiler in _default_compilers:
-        if re.match(pattern, platform) is not None or \
-           re.match(pattern, osname) is not None:
-            return compiler
-    # Default to Unix compiler
-    return 'unix'
-
-# Map compiler types to (module_name, class_name) pairs -- ie. where to
-# find the code that implements an interface to this compiler.  (The module
-# is assumed to be in the 'distutils' package.)
-compiler_class = { 'unix':    ('unixccompiler', 'UnixCCompiler',
-                               "standard UNIX-style compiler"),
-                   'msvc':    ('_msvccompiler', 'MSVCCompiler',
-                               "Microsoft Visual C++"),
-                   'cygwin':  ('cygwinccompiler', 'CygwinCCompiler',
-                               "Cygwin port of GNU C Compiler for Win32"),
-                   'mingw32': ('cygwinccompiler', 'Mingw32CCompiler',
-                               "Mingw32 port of GNU C Compiler for Win32"),
-                   'bcpp':    ('bcppcompiler', 'BCPPCompiler',
-                               "Borland C++ Compiler"),
-                 }
-
-def show_compilers():
-    """Print list of available compilers (used by the "--help-compiler"
-    options to "build", "build_ext", "build_clib").
-    """
-    # XXX this "knows" that the compiler option it's describing is
-    # "--compiler", which just happens to be the case for the three
-    # commands that use it.
-    from distutils.fancy_getopt import FancyGetopt
-    compilers = []
-    for compiler in compiler_class.keys():
-        compilers.append(("compiler="+compiler, None,
-                          compiler_class[compiler][2]))
-    compilers.sort()
-    pretty_printer = FancyGetopt(compilers)
-    pretty_printer.print_help("List of available compilers:")
-
-
-def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
-    """Generate an instance of some CCompiler subclass for the supplied
-    platform/compiler combination.  'plat' defaults to 'os.name'
-    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
-    for that platform.  Currently only 'posix' and 'nt' are supported, and
-    the default compilers are "traditional Unix interface" (UnixCCompiler
-    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
-    possible to ask for a Unix compiler object under Windows, and a
-    Microsoft compiler object under Unix -- if you supply a value for
-    'compiler', 'plat' is ignored.
-    """
-    if plat is None:
-        plat = os.name
-
-    try:
-        if compiler is None:
-            compiler = get_default_compiler(plat)
-
-        (module_name, class_name, long_description) = compiler_class[compiler]
-    except KeyError:
-        msg = "don't know how to compile C/C++ code on platform '%s'" % plat
-        if compiler is not None:
-            msg = msg + " with '%s' compiler" % compiler
-        raise DistutilsPlatformError(msg)
-
-    try:
-        module_name = "distutils." + module_name
-        __import__ (module_name)
-        module = sys.modules[module_name]
-        klass = vars(module)[class_name]
-    except ImportError:
-        raise DistutilsModuleError(
-              "can't compile C/C++ code: unable to load module '%s'" % \
-              module_name)
-    except KeyError:
-        raise DistutilsModuleError(
-               "can't compile C/C++ code: unable to find class '%s' "
-               "in module '%s'" % (class_name, module_name))
-
-    # XXX The None is necessary to preserve backwards compatibility
-    # with classes that expect verbose to be the first positional
-    # argument.
-    return klass(None, dry_run, force)
-
-
-def gen_preprocess_options(macros, include_dirs):
-    """Generate C pre-processor options (-D, -U, -I) as used by at least
-    two types of compilers: the typical Unix compiler and Visual C++.
-    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
-    means undefine (-U) macro 'name', and (name,value) means define (-D)
-    macro 'name' to 'value'.  'include_dirs' is just a list of directory
-    names to be added to the header file search path (-I).  Returns a list
-    of command-line options suitable for either Unix compilers or Visual
-    C++.
-    """
-    # XXX it would be nice (mainly aesthetic, and so we don't generate
-    # stupid-looking command lines) to go over 'macros' and eliminate
-    # redundant definitions/undefinitions (ie. ensure that only the
-    # latest mention of a particular macro winds up on the command
-    # line).  I don't think it's essential, though, since most (all?)
-    # Unix C compilers only pay attention to the latest -D or -U
-    # mention of a macro on their command line.  Similar situation for
-    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
-    # redundancies like this should probably be the province of
-    # CCompiler, since the data structures used are inherited from it
-    # and therefore common to all CCompiler classes.
-    pp_opts = []
-    for macro in macros:
-        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
-            raise TypeError(
-                  "bad macro definition '%s': "
-                  "each element of 'macros' list must be a 1- or 2-tuple"
-                  % macro)
-
-        if len(macro) == 1:        # undefine this macro
-            pp_opts.append("-U%s" % macro[0])
-        elif len(macro) == 2:
-            if macro[1] is None:    # define with no explicit value
-                pp_opts.append("-D%s" % macro[0])
-            else:
-                # XXX *don't* need to be clever about quoting the
-                # macro value here, because we're going to avoid the
-                # shell at all costs when we spawn the command!
-                pp_opts.append("-D%s=%s" % macro)
-
-    for dir in include_dirs:
-        pp_opts.append("-I%s" % dir)
-    return pp_opts
-
-
-def gen_lib_options (compiler, library_dirs, runtime_library_dirs, libraries):
-    """Generate linker options for searching library directories and
-    linking with specific libraries.  'libraries' and 'library_dirs' are,
-    respectively, lists of library names (not filenames!) and search
-    directories.  Returns a list of command-line options suitable for use
-    with some compiler (depending on the two format strings passed in).
-    """
-    lib_opts = []
-
-    for dir in library_dirs:
-        lib_opts.append(compiler.library_dir_option(dir))
-
-    for dir in runtime_library_dirs:
-        opt = compiler.runtime_library_dir_option(dir)
-        if isinstance(opt, list):
-            lib_opts = lib_opts + opt
-        else:
-            lib_opts.append(opt)
-
-    # XXX it's important that we *not* remove redundant library mentions!
-    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
-    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
-    # -lbar" to get things to work -- that's certainly a possibility, but a
-    # pretty nasty way to arrange your C code.
-
-    for lib in libraries:
-        (lib_dir, lib_name) = os.path.split(lib)
-        if lib_dir:
-            lib_file = compiler.find_library_file([lib_dir], lib_name)
-            if lib_file:
-                lib_opts.append(lib_file)
-            else:
-                compiler.warn("no library file corresponding to "
-                              "'%s' found (skipping)" % lib)
-        else:
-            lib_opts.append(compiler.library_option (lib))
-    return lib_opts
diff --git a/Lib/distutils/cmd.py b/Lib/distutils/cmd.py
deleted file mode 100644
index 939f795945..0000000000
--- a/Lib/distutils/cmd.py
+++ /dev/null
@@ -1,434 +0,0 @@
-"""distutils.cmd
-
-Provides the Command class, the base class for the command classes
-in the distutils.command package.
-"""
-
-import sys, os, re
-from distutils.errors import DistutilsOptionError
-from distutils import util, dir_util, file_util, archive_util, dep_util
-from distutils import log
-
-class Command:
-    """Abstract base class for defining command classes, the "worker bees"
-    of the Distutils.  A useful analogy for command classes is to think of
-    them as subroutines with local variables called "options".  The options
-    are "declared" in 'initialize_options()' and "defined" (given their
-    final values, aka "finalized") in 'finalize_options()', both of which
-    must be defined by every command class.  The distinction between the
-    two is necessary because option values might come from the outside
-    world (command line, config file, ...), and any options dependent on
-    other options must be computed *after* these outside influences have
-    been processed -- hence 'finalize_options()'.  The "body" of the
-    subroutine, where it does all its work based on the values of its
-    options, is the 'run()' method, which must also be implemented by every
-    command class.
-    """
-
-    # 'sub_commands' formalizes the notion of a "family" of commands,
-    # eg. "install" as the parent with sub-commands "install_lib",
-    # "install_headers", etc.  The parent of a family of commands
-    # defines 'sub_commands' as a class attribute; it's a list of
-    #    (command_name : string, predicate : unbound_method | string | None)
-    # tuples, where 'predicate' is a method of the parent command that
-    # determines whether the corresponding command is applicable in the
-    # current situation.  (Eg. we "install_headers" is only applicable if
-    # we have any C header files to install.)  If 'predicate' is None,
-    # that command is always applicable.
-    #
-    # 'sub_commands' is usually defined at the *end* of a class, because
-    # predicates can be unbound methods, so they must already have been
-    # defined.  The canonical example is the "install" command.
-    sub_commands = []
-
-
-    # -- Creation/initialization methods -------------------------------
-
-    def __init__(self, dist):
-        """Create and initialize a new Command object.  Most importantly,
-        invokes the 'initialize_options()' method, which is the real
-        initializer and depends on the actual command being
-        instantiated.
-        """
-        # late import because of mutual dependence between these classes
-        from distutils.dist import Distribution
-
-        if not isinstance(dist, Distribution):
-            raise TypeError("dist must be a Distribution instance")
-        if self.__class__ is Command:
-            raise RuntimeError("Command is an abstract class")
-
-        self.distribution = dist
-        self.initialize_options()
-
-        # Per-command versions of the global flags, so that the user can
-        # customize Distutils' behaviour command-by-command and let some
-        # commands fall back on the Distribution's behaviour.  None means
-        # "not defined, check self.distribution's copy", while 0 or 1 mean
-        # false and true (duh).  Note that this means figuring out the real
-        # value of each flag is a touch complicated -- hence "self._dry_run"
-        # will be handled by __getattr__, below.
-        # XXX This needs to be fixed.
-        self._dry_run = None
-
-        # verbose is largely ignored, but needs to be set for
-        # backwards compatibility (I think)?
-        self.verbose = dist.verbose
-
-        # Some commands define a 'self.force' option to ignore file
-        # timestamps, but methods defined *here* assume that
-        # 'self.force' exists for all commands.  So define it here
-        # just to be safe.
-        self.force = None
-
-        # The 'help' flag is just used for command-line parsing, so
-        # none of that complicated bureaucracy is needed.
-        self.help = 0
-
-        # 'finalized' records whether or not 'finalize_options()' has been
-        # called.  'finalize_options()' itself should not pay attention to
-        # this flag: it is the business of 'ensure_finalized()', which
-        # always calls 'finalize_options()', to respect/update it.
-        self.finalized = 0
-
-    # XXX A more explicit way to customize dry_run would be better.
-    def __getattr__(self, attr):
-        if attr == 'dry_run':
-            myval = getattr(self, "_" + attr)
-            if myval is None:
-                return getattr(self.distribution, attr)
-            else:
-                return myval
-        else:
-            raise AttributeError(attr)
-
-    def ensure_finalized(self):
-        if not self.finalized:
-            self.finalize_options()
-        self.finalized = 1
-
-    # Subclasses must define:
-    #   initialize_options()
-    #     provide default values for all options; may be customized by
-    #     setup script, by options from config file(s), or by command-line
-    #     options
-    #   finalize_options()
-    #     decide on the final values for all options; this is called
-    #     after all possible intervention from the outside world
-    #     (command-line, option file, etc.) has been processed
-    #   run()
-    #     run the command: do whatever it is we're here to do,
-    #     controlled by the command's various option values
-
-    def initialize_options(self):
-        """Set default values for all the options that this command
-        supports.  Note that these defaults may be overridden by other
-        commands, by the setup script, by config files, or by the
-        command-line.  Thus, this is not the place to code dependencies
-        between options; generally, 'initialize_options()' implementations
-        are just a bunch of "self.foo = None" assignments.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-    def finalize_options(self):
-        """Set final values for all the options that this command supports.
-        This is always called as late as possible, ie.  after any option
-        assignments from the command-line or from other commands have been
-        done.  Thus, this is the place to code option dependencies: if
-        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
-        long as 'foo' still has the same value it was assigned in
-        'initialize_options()'.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-
-    def dump_options(self, header=None, indent=""):
-        from distutils.fancy_getopt import longopt_xlate
-        if header is None:
-            header = "command options for '%s':" % self.get_command_name()
-        self.announce(indent + header, level=log.INFO)
-        indent = indent + "  "
-        for (option, _, _) in self.user_options:
-            option = option.translate(longopt_xlate)
-            if option[-1] == "=":
-                option = option[:-1]
-            value = getattr(self, option)
-            self.announce(indent + "%s = %s" % (option, value),
-                          level=log.INFO)
-
-    def run(self):
-        """A command's raison d'etre: carry out the action it exists to
-        perform, controlled by the options initialized in
-        'initialize_options()', customized by other commands, the setup
-        script, the command-line, and config files, and finalized in
-        'finalize_options()'.  All terminal output and filesystem
-        interaction should be done by 'run()'.
-
-        This method must be implemented by all command classes.
-        """
-        raise RuntimeError("abstract method -- subclass %s must override"
-                           % self.__class__)
-
-    def announce(self, msg, level=1):
-        """If the current verbosity level is of greater than or equal to
-        'level' print 'msg' to stdout.
-        """
-        log.log(level, msg)
-
-    def debug_print(self, msg):
-        """Print 'msg' to stdout if the global DEBUG (taken from the
-        DISTUTILS_DEBUG environment variable) flag is true.
-        """
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-            sys.stdout.flush()
-
-
-    # -- Option validation methods -------------------------------------
-    # (these are very handy in writing the 'finalize_options()' method)
-    #
-    # NB. the general philosophy here is to ensure that a particular option
-    # value meets certain type and value constraints.  If not, we try to
-    # force it into conformance (eg. if we expect a list but have a string,
-    # split the string on comma and/or whitespace).  If we can't force the
-    # option into conformance, raise DistutilsOptionError.  Thus, command
-    # classes need do nothing more than (eg.)
-    #   self.ensure_string_list('foo')
-    # and they can be guaranteed that thereafter, self.foo will be
-    # a list of strings.
-
-    def _ensure_stringlike(self, option, what, default=None):
-        val = getattr(self, option)
-        if val is None:
-            setattr(self, option, default)
-            return default
-        elif not isinstance(val, str):
-            raise DistutilsOptionError("'%s' must be a %s (got `%s`)"
-                                       % (option, what, val))
-        return val
-
-    def ensure_string(self, option, default=None):
-        """Ensure that 'option' is a string; if not defined, set it to
-        'default'.
-        """
-        self._ensure_stringlike(option, "string", default)
-
-    def ensure_string_list(self, option):
-        r"""Ensure that 'option' is a list of strings.  If 'option' is
-        currently a string, we split it either on /,\s*/ or /\s+/, so
-        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
-        ["foo", "bar", "baz"].
-        """
-        val = getattr(self, option)
-        if val is None:
-            return
-        elif isinstance(val, str):
-            setattr(self, option, re.split(r',\s*|\s+', val))
-        else:
-            if isinstance(val, list):
-                ok = all(isinstance(v, str) for v in val)
-            else:
-                ok = False
-            if not ok:
-                raise DistutilsOptionError(
-                      "'%s' must be a list of strings (got %r)"
-                      % (option, val))
-
-    def _ensure_tested_string(self, option, tester, what, error_fmt,
-                              default=None):
-        val = self._ensure_stringlike(option, what, default)
-        if val is not None and not tester(val):
-            raise DistutilsOptionError(("error in '%s' option: " + error_fmt)
-                                       % (option, val))
-
-    def ensure_filename(self, option):
-        """Ensure that 'option' is the name of an existing file."""
-        self._ensure_tested_string(option, os.path.isfile,
-                                   "filename",
-                                   "'%s' does not exist or is not a file")
-
-    def ensure_dirname(self, option):
-        self._ensure_tested_string(option, os.path.isdir,
-                                   "directory name",
-                                   "'%s' does not exist or is not a directory")
-
-
-    # -- Convenience methods for commands ------------------------------
-
-    def get_command_name(self):
-        if hasattr(self, 'command_name'):
-            return self.command_name
-        else:
-            return self.__class__.__name__
-
-    def set_undefined_options(self, src_cmd, *option_pairs):
-        """Set the values of any "undefined" options from corresponding
-        option values in some other command object.  "Undefined" here means
-        "is None", which is the convention used to indicate that an option
-        has not been changed between 'initialize_options()' and
-        'finalize_options()'.  Usually called from 'finalize_options()' for
-        options that depend on some other command rather than another
-        option of the same command.  'src_cmd' is the other command from
-        which option values will be taken (a command object will be created
-        for it if necessary); the remaining arguments are
-        '(src_option,dst_option)' tuples which mean "take the value of
-        'src_option' in the 'src_cmd' command object, and copy it to
-        'dst_option' in the current command object".
-        """
-        # Option_pairs: list of (src_option, dst_option) tuples
-        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
-        src_cmd_obj.ensure_finalized()
-        for (src_option, dst_option) in option_pairs:
-            if getattr(self, dst_option) is None:
-                setattr(self, dst_option, getattr(src_cmd_obj, src_option))
-
-    def get_finalized_command(self, command, create=1):
-        """Wrapper around Distribution's 'get_command_obj()' method: find
-        (create if necessary and 'create' is true) the command object for
-        'command', call its 'ensure_finalized()' method, and return the
-        finalized command object.
-        """
-        cmd_obj = self.distribution.get_command_obj(command, create)
-        cmd_obj.ensure_finalized()
-        return cmd_obj
-
-    # XXX rename to 'get_reinitialized_command()'? (should do the
-    # same in dist.py, if so)
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        return self.distribution.reinitialize_command(command,
-                                                      reinit_subcommands)
-
-    def run_command(self, command):
-        """Run some other command: uses the 'run_command()' method of
-        Distribution, which creates and finalizes the command object if
-        necessary and then invokes its 'run()' method.
-        """
-        self.distribution.run_command(command)
-
-    def get_sub_commands(self):
-        """Determine the sub-commands that are relevant in the current
-        distribution (ie., that need to be run).  This is based on the
-        'sub_commands' class attribute: each tuple in that list may include
-        a method that we call to determine if the subcommand needs to be
-        run for the current distribution.  Return a list of command names.
-        """
-        commands = []
-        for (cmd_name, method) in self.sub_commands:
-            if method is None or method(self):
-                commands.append(cmd_name)
-        return commands
-
-
-    # -- External world manipulation -----------------------------------
-
-    def warn(self, msg):
-        log.warn("warning: %s: %s\n", self.get_command_name(), msg)
-
-    def execute(self, func, args, msg=None, level=1):
-        util.execute(func, args, msg, dry_run=self.dry_run)
-
-    def mkpath(self, name, mode=0o777):
-        dir_util.mkpath(name, mode, dry_run=self.dry_run)
-
-    def copy_file(self, infile, outfile, preserve_mode=1, preserve_times=1,
-                  link=None, level=1):
-        """Copy a file respecting verbose, dry-run and force flags.  (The
-        former two default to whatever is in the Distribution object, and
-        the latter defaults to false for commands that don't define it.)"""
-        return file_util.copy_file(infile, outfile, preserve_mode,
-                                   preserve_times, not self.force, link,
-                                   dry_run=self.dry_run)
-
-    def copy_tree(self, infile, outfile, preserve_mode=1, preserve_times=1,
-                   preserve_symlinks=0, level=1):
-        """Copy an entire directory tree respecting verbose, dry-run,
-        and force flags.
-        """
-        return dir_util.copy_tree(infile, outfile, preserve_mode,
-                                  preserve_times, preserve_symlinks,
-                                  not self.force, dry_run=self.dry_run)
-
-    def move_file (self, src, dst, level=1):
-        """Move a file respecting dry-run flag."""
-        return file_util.move_file(src, dst, dry_run=self.dry_run)
-
-    def spawn(self, cmd, search_path=1, level=1):
-        """Spawn an external command respecting dry-run flag."""
-        from distutils.spawn import spawn
-        spawn(cmd, search_path, dry_run=self.dry_run)
-
-    def make_archive(self, base_name, format, root_dir=None, base_dir=None,
-                     owner=None, group=None):
-        return archive_util.make_archive(base_name, format, root_dir, base_dir,
-                                         dry_run=self.dry_run,
-                                         owner=owner, group=group)
-
-    def make_file(self, infiles, outfile, func, args,
-                  exec_msg=None, skip_msg=None, level=1):
-        """Special case of 'execute()' for operations that process one or
-        more input files and generate one output file.  Works just like
-        'execute()', except the operation is skipped and a different
-        message printed if 'outfile' already exists and is newer than all
-        files listed in 'infiles'.  If the command defined 'self.force',
-        and it is true, then the command is unconditionally run -- does no
-        timestamp checks.
-        """
-        if skip_msg is None:
-            skip_msg = "skipping %s (inputs unchanged)" % outfile
-
-        # Allow 'infiles' to be a single string
-        if isinstance(infiles, str):
-            infiles = (infiles,)
-        elif not isinstance(infiles, (list, tuple)):
-            raise TypeError(
-                  "'infiles' must be a string, or a list or tuple of strings")
-
-        if exec_msg is None:
-            exec_msg = "generating %s from %s" % (outfile, ', '.join(infiles))
-
-        # If 'outfile' must be regenerated (either because it doesn't
-        # exist, is out-of-date, or the 'force' flag is true) then
-        # perform the action that presumably regenerates it
-        if self.force or dep_util.newer_group(infiles, outfile):
-            self.execute(func, args, exec_msg, level)
-        # Otherwise, print the "skip" message
-        else:
-            log.debug(skip_msg)
-
-# XXX 'install_misc' class not currently used -- it was the base class for
-# both 'install_scripts' and 'install_data', but they outgrew it.  It might
-# still be useful for 'install_headers', though, so I'm keeping it around
-# for the time being.
-
-class install_misc(Command):
-    """Common base class for installing some files in a subdirectory.
-    Currently used by install_data and install_scripts.
-    """
-
-    user_options = [('install-dir=', 'd', "directory to install the files to")]
-
-    def initialize_options (self):
-        self.install_dir = None
-        self.outfiles = []
-
-    def _install_dir_from(self, dirname):
-        self.set_undefined_options('install', (dirname, 'install_dir'))
-
-    def _copy_files(self, filelist):
-        self.outfiles = []
-        if not filelist:
-            return
-        self.mkpath(self.install_dir)
-        for f in filelist:
-            self.copy_file(f, self.install_dir)
-            self.outfiles.append(os.path.join(self.install_dir, f))
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/__init__.py b/Lib/distutils/command/__init__.py
deleted file mode 100644
index 481eea9fd4..0000000000
--- a/Lib/distutils/command/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-"""distutils.command
-
-Package containing implementation of all the standard Distutils
-commands."""
-
-__all__ = ['build',
-           'build_py',
-           'build_ext',
-           'build_clib',
-           'build_scripts',
-           'clean',
-           'install',
-           'install_lib',
-           'install_headers',
-           'install_scripts',
-           'install_data',
-           'sdist',
-           'register',
-           'bdist',
-           'bdist_dumb',
-           'bdist_rpm',
-           'bdist_wininst',
-           'check',
-           'upload',
-           # These two are reserved for future use:
-           #'bdist_sdux',
-           #'bdist_pkgtool',
-           # Note:
-           # bdist_packager is not included because it only provides
-           # an abstract base class
-          ]
diff --git a/Lib/distutils/command/bdist.py b/Lib/distutils/command/bdist.py
deleted file mode 100644
index 014871d280..0000000000
--- a/Lib/distutils/command/bdist.py
+++ /dev/null
@@ -1,143 +0,0 @@
-"""distutils.command.bdist
-
-Implements the Distutils 'bdist' command (create a built [binary]
-distribution)."""
-
-import os
-from distutils.core import Command
-from distutils.errors import *
-from distutils.util import get_platform
-
-
-def show_formats():
-    """Print list of available formats (arguments to "--format" option).
-    """
-    from distutils.fancy_getopt import FancyGetopt
-    formats = []
-    for format in bdist.format_commands:
-        formats.append(("formats=" + format, None,
-                        bdist.format_command[format][1]))
-    pretty_printer = FancyGetopt(formats)
-    pretty_printer.print_help("List of available distribution formats:")
-
-
-class bdist(Command):
-
-    description = "create a built (binary) distribution"
-
-    user_options = [('bdist-base=', 'b',
-                     "temporary directory for creating built distributions"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('formats=', None,
-                     "formats for distribution (comma-separated list)"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in "
-                     "[default: dist]"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('owner=', 'u',
-                     "Owner name used when creating a tar file"
-                     " [default: current user]"),
-                    ('group=', 'g',
-                     "Group name used when creating a tar file"
-                     " [default: current group]"),
-                   ]
-
-    boolean_options = ['skip-build']
-
-    help_options = [
-        ('help-formats', None,
-         "lists available distribution formats", show_formats),
-        ]
-
-    # The following commands do not take a format option from bdist
-    no_format_option = ('bdist_rpm',)
-
-    # This won't do in reality: will need to distinguish RPM-ish Linux,
-    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
-    default_format = {'posix': 'gztar',
-                      'nt': 'zip'}
-
-    # Establish the preferred order (for the --help-formats option).
-    format_commands = ['rpm', 'gztar', 'bztar', 'xztar', 'ztar', 'tar',
-                       'wininst', 'zip', 'msi']
-
-    # And the real information.
-    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
-                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
-                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
-                      'xztar': ('bdist_dumb', "xz'ed tar file"),
-                      'ztar':  ('bdist_dumb', "compressed tar file"),
-                      'tar':   ('bdist_dumb', "tar file"),
-                      'wininst': ('bdist_wininst',
-                                  "Windows executable installer"),
-                      'zip':   ('bdist_dumb', "ZIP file"),
-                      'msi':   ('bdist_msi',  "Microsoft Installer")
-                      }
-
-
-    def initialize_options(self):
-        self.bdist_base = None
-        self.plat_name = None
-        self.formats = None
-        self.dist_dir = None
-        self.skip_build = 0
-        self.group = None
-        self.owner = None
-
-    def finalize_options(self):
-        # have to finalize 'plat_name' before 'bdist_base'
-        if self.plat_name is None:
-            if self.skip_build:
-                self.plat_name = get_platform()
-            else:
-                self.plat_name = self.get_finalized_command('build').plat_name
-
-        # 'bdist_base' -- parent of per-built-distribution-format
-        # temporary directories (eg. we'll probably have
-        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
-        if self.bdist_base is None:
-            build_base = self.get_finalized_command('build').build_base
-            self.bdist_base = os.path.join(build_base,
-                                           'bdist.' + self.plat_name)
-
-        self.ensure_string_list('formats')
-        if self.formats is None:
-            try:
-                self.formats = [self.default_format[os.name]]
-            except KeyError:
-                raise DistutilsPlatformError(
-                      "don't know how to create built distributions "
-                      "on platform %s" % os.name)
-
-        if self.dist_dir is None:
-            self.dist_dir = "dist"
-
-    def run(self):
-        # Figure out which sub-commands we need to run.
-        commands = []
-        for format in self.formats:
-            try:
-                commands.append(self.format_command[format][0])
-            except KeyError:
-                raise DistutilsOptionError("invalid format '%s'" % format)
-
-        # Reinitialize and run each command.
-        for i in range(len(self.formats)):
-            cmd_name = commands[i]
-            sub_cmd = self.reinitialize_command(cmd_name)
-            if cmd_name not in self.no_format_option:
-                sub_cmd.format = self.formats[i]
-
-            # passing the owner and group names for tar archiving
-            if cmd_name == 'bdist_dumb':
-                sub_cmd.owner = self.owner
-                sub_cmd.group = self.group
-
-            # If we're going to need to run this command again, tell it to
-            # keep its temporary files around so subsequent runs go faster.
-            if cmd_name in commands[i+1:]:
-                sub_cmd.keep_temp = 1
-            self.run_command(cmd_name)
diff --git a/Lib/distutils/command/bdist_dumb.py b/Lib/distutils/command/bdist_dumb.py
deleted file mode 100644
index f0d6b5b8cd..0000000000
--- a/Lib/distutils/command/bdist_dumb.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""distutils.command.bdist_dumb
-
-Implements the Distutils 'bdist_dumb' command (create a "dumb" built
-distribution -- i.e., just an archive to be unpacked under $prefix or
-$exec_prefix)."""
-
-import os
-from distutils.core import Command
-from distutils.util import get_platform
-from distutils.dir_util import remove_tree, ensure_relative
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_dumb(Command):
-
-    description = "create a \"dumb\" built distribution"
-
-    user_options = [('bdist-dir=', 'd',
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('format=', 'f',
-                     "archive format to create (tar, gztar, bztar, xztar, "
-                     "ztar, zip)"),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('relative', None,
-                     "build the archive using relative paths "
-                     "(default: false)"),
-                    ('owner=', 'u',
-                     "Owner name used when creating a tar file"
-                     " [default: current user]"),
-                    ('group=', 'g',
-                     "Group name used when creating a tar file"
-                     " [default: current group]"),
-                   ]
-
-    boolean_options = ['keep-temp', 'skip-build', 'relative']
-
-    default_format = { 'posix': 'gztar',
-                       'nt': 'zip' }
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.format = None
-        self.keep_temp = 0
-        self.dist_dir = None
-        self.skip_build = None
-        self.relative = 0
-        self.owner = None
-        self.group = None
-
-    def finalize_options(self):
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'dumb')
-
-        if self.format is None:
-            try:
-                self.format = self.default_format[os.name]
-            except KeyError:
-                raise DistutilsPlatformError(
-                       "don't know how to create dumb built distributions "
-                       "on platform %s" % os.name)
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                   ('skip_build', 'skip_build'))
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.root = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-
-        log.info("installing to %s", self.bdist_dir)
-        self.run_command('install')
-
-        # And make an archive relative to the root of the
-        # pseudo-installation tree.
-        archive_basename = "%s.%s" % (self.distribution.get_fullname(),
-                                      self.plat_name)
-
-        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
-        if not self.relative:
-            archive_root = self.bdist_dir
-        else:
-            if (self.distribution.has_ext_modules() and
-                (install.install_base != install.install_platbase)):
-                raise DistutilsPlatformError(
-                       "can't make a dumb built distribution where "
-                       "base and platbase are different (%s, %s)"
-                       % (repr(install.install_base),
-                          repr(install.install_platbase)))
-            else:
-                archive_root = os.path.join(self.bdist_dir,
-                                   ensure_relative(install.install_base))
-
-        # Make the archive
-        filename = self.make_archive(pseudoinstall_root,
-                                     self.format, root_dir=archive_root,
-                                     owner=self.owner, group=self.group)
-        if self.distribution.has_ext_modules():
-            pyversion = get_python_version()
-        else:
-            pyversion = 'any'
-        self.distribution.dist_files.append(('bdist_dumb', pyversion,
-                                             filename))
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
diff --git a/Lib/distutils/command/bdist_msi.py b/Lib/distutils/command/bdist_msi.py
deleted file mode 100644
index 80104c372d..0000000000
--- a/Lib/distutils/command/bdist_msi.py
+++ /dev/null
@@ -1,741 +0,0 @@
-# Copyright (C) 2005, 2006 Martin von Löwis
-# Licensed to PSF under a Contributor Agreement.
-# The bdist_wininst command proper
-# based on bdist_wininst
-"""
-Implements the bdist_msi command.
-"""
-
-import sys, os
-from distutils.core import Command
-from distutils.dir_util import remove_tree
-from distutils.sysconfig import get_python_version
-from distutils.version import StrictVersion
-from distutils.errors import DistutilsOptionError
-from distutils.util import get_platform
-from distutils import log
-import msilib
-from msilib import schema, sequence, text
-from msilib import Directory, Feature, Dialog, add_data
-
-class PyDialog(Dialog):
-    """Dialog class with a fixed layout: controls at the top, then a ruler,
-    then a list of buttons: back, next, cancel. Optionally a bitmap at the
-    left."""
-    def __init__(self, *args, **kw):
-        """Dialog(database, name, x, y, w, h, attributes, title, first,
-        default, cancel, bitmap=true)"""
-        Dialog.__init__(self, *args)
-        ruler = self.h - 36
-        bmwidth = 152*ruler/328
-        #if kw.get("bitmap", True):
-        #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
-        self.line("BottomLine", 0, ruler, self.w, 0)
-
-    def title(self, title):
-        "Set the title text of the dialog at the top."
-        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
-        # text, in VerdanaBold10
-        self.text("Title", 15, 10, 320, 60, 0x30003,
-                  r"{\VerdanaBold10}%s" % title)
-
-    def back(self, title, next, name = "Back", active = 1):
-        """Add a back button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)
-
-    def cancel(self, title, next, name = "Cancel", active = 1):
-        """Add a cancel button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)
-
-    def next(self, title, next, name = "Next", active = 1):
-        """Add a Next button with a given title, the tab-next button,
-        its name in the Control table, possibly initially disabled.
-
-        Return the button, so that events can be associated"""
-        if active:
-            flags = 3 # Visible|Enabled
-        else:
-            flags = 1 # Visible
-        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)
-
-    def xbutton(self, name, title, next, xpos):
-        """Add a button with a given title, the tab-next button,
-        its name in the Control table, giving its x position; the
-        y-position is aligned with the other buttons.
-
-        Return the button, so that events can be associated"""
-        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)
-
-class bdist_msi(Command):
-
-    description = "create a Microsoft Installer (.msi) binary distribution"
-
-    user_options = [('bdist-dir=', None,
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('target-version=', None,
-                     "require a specific python version" +
-                     " on the target system"),
-                    ('no-target-compile', 'c',
-                     "do not compile .py to .pyc on the target system"),
-                    ('no-target-optimize', 'o',
-                     "do not compile .py to .pyo (optimized) "
-                     "on the target system"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('install-script=', None,
-                     "basename of installation script to be run after "
-                     "installation or before deinstallation"),
-                    ('pre-install-script=', None,
-                     "Fully qualified filename of a script to be run before "
-                     "any files are installed.  This script need not be in the "
-                     "distribution"),
-                   ]
-
-    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
-                       'skip-build']
-
-    all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
-                    '2.5', '2.6', '2.7', '2.8', '2.9',
-                    '3.0', '3.1', '3.2', '3.3', '3.4',
-                    '3.5', '3.6', '3.7', '3.8', '3.9']
-    other_version = 'X'
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.no_target_compile = 0
-        self.no_target_optimize = 0
-        self.target_version = None
-        self.dist_dir = None
-        self.skip_build = None
-        self.install_script = None
-        self.pre_install_script = None
-        self.versions = None
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
-
-        if self.bdist_dir is None:
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'msi')
-
-        short_version = get_python_version()
-        if (not self.target_version) and self.distribution.has_ext_modules():
-            self.target_version = short_version
-
-        if self.target_version:
-            self.versions = [self.target_version]
-            if not self.skip_build and self.distribution.has_ext_modules()\
-               and self.target_version != short_version:
-                raise DistutilsOptionError(
-                      "target version can only be %s, or the '--skip-build'"
-                      " option must be specified" % (short_version,))
-        else:
-            self.versions = list(self.all_versions)
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                   )
-
-        if self.pre_install_script:
-            raise DistutilsOptionError(
-                  "the pre-install-script feature is not yet implemented")
-
-        if self.install_script:
-            for script in self.distribution.scripts:
-                if self.install_script == os.path.basename(script):
-                    break
-            else:
-                raise DistutilsOptionError(
-                      "install_script '%s' not found in scripts"
-                      % self.install_script)
-        self.install_script_key = None
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.prefix = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-
-        install_lib = self.reinitialize_command('install_lib')
-        # we do not want to include pyc or pyo files
-        install_lib.compile = 0
-        install_lib.optimize = 0
-
-        if self.distribution.has_ext_modules():
-            # If we are building an installer for a Python version other
-            # than the one we are currently running, then we need to ensure
-            # our build_lib reflects the other Python version rather than ours.
-            # Note that for target_version!=sys.version, we must have skipped the
-            # build step, so there is no issue with enforcing the build of this
-            # version.
-            target_version = self.target_version
-            if not target_version:
-                assert self.skip_build, "Should have already checked this"
-                target_version = '%d.%d' % sys.version_info[:2]
-            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
-            build = self.get_finalized_command('build')
-            build.build_lib = os.path.join(build.build_base,
-                                           'lib' + plat_specifier)
-
-        log.info("installing to %s", self.bdist_dir)
-        install.ensure_finalized()
-
-        # avoid warning of 'install_lib' about installing
-        # into a directory not in sys.path
-        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
-
-        install.run()
-
-        del sys.path[0]
-
-        self.mkpath(self.dist_dir)
-        fullname = self.distribution.get_fullname()
-        installer_name = self.get_installer_filename(fullname)
-        installer_name = os.path.abspath(installer_name)
-        if os.path.exists(installer_name): os.unlink(installer_name)
-
-        metadata = self.distribution.metadata
-        author = metadata.author
-        if not author:
-            author = metadata.maintainer
-        if not author:
-            author = "UNKNOWN"
-        version = metadata.get_version()
-        # ProductVersion must be strictly numeric
-        # XXX need to deal with prerelease versions
-        sversion = "%d.%d.%d" % StrictVersion(version).version
-        # Prefix ProductName with Python x.y, so that
-        # it sorts together with the other Python packages
-        # in Add-Remove-Programs (APR)
-        fullname = self.distribution.get_fullname()
-        if self.target_version:
-            product_name = "Python %s %s" % (self.target_version, fullname)
-        else:
-            product_name = "Python %s" % (fullname)
-        self.db = msilib.init_database(installer_name, schema,
-                product_name, msilib.gen_uuid(),
-                sversion, author)
-        msilib.add_tables(self.db, sequence)
-        props = [('DistVersion', version)]
-        email = metadata.author_email or metadata.maintainer_email
-        if email:
-            props.append(("ARPCONTACT", email))
-        if metadata.url:
-            props.append(("ARPURLINFOABOUT", metadata.url))
-        if props:
-            add_data(self.db, 'Property', props)
-
-        self.add_find_python()
-        self.add_files()
-        self.add_scripts()
-        self.add_ui()
-        self.db.Commit()
-
-        if hasattr(self.distribution, 'dist_files'):
-            tup = 'bdist_msi', self.target_version or 'any', fullname
-            self.distribution.dist_files.append(tup)
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-    def add_files(self):
-        db = self.db
-        cab = msilib.CAB("distfiles")
-        rootdir = os.path.abspath(self.bdist_dir)
-
-        root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
-        f = Feature(db, "Python", "Python", "Everything",
-                    0, 1, directory="TARGETDIR")
-
-        items = [(f, root, '')]
-        for version in self.versions + [self.other_version]:
-            target = "TARGETDIR" + version
-            name = default = "Python" + version
-            desc = "Everything"
-            if version is self.other_version:
-                title = "Python from another location"
-                level = 2
-            else:
-                title = "Python %s from registry" % version
-                level = 1
-            f = Feature(db, name, title, desc, 1, level, directory=target)
-            dir = Directory(db, cab, root, rootdir, target, default)
-            items.append((f, dir, version))
-        db.Commit()
-
-        seen = {}
-        for feature, dir, version in items:
-            todo = [dir]
-            while todo:
-                dir = todo.pop()
-                for file in os.listdir(dir.absolute):
-                    afile = os.path.join(dir.absolute, file)
-                    if os.path.isdir(afile):
-                        short = "%s|%s" % (dir.make_short(file), file)
-                        default = file + version
-                        newdir = Directory(db, cab, dir, file, default, short)
-                        todo.append(newdir)
-                    else:
-                        if not dir.component:
-                            dir.start_component(dir.logical, feature, 0)
-                        if afile not in seen:
-                            key = seen[afile] = dir.add_file(file)
-                            if file==self.install_script:
-                                if self.install_script_key:
-                                    raise DistutilsOptionError(
-                                          "Multiple files with name %s" % file)
-                                self.install_script_key = '[#%s]' % key
-                        else:
-                            key = seen[afile]
-                            add_data(self.db, "DuplicateFile",
-                                [(key + version, dir.component, key, None, dir.logical)])
-            db.Commit()
-        cab.commit(db)
-
-    def add_find_python(self):
-        """Adds code to the installer to compute the location of Python.
-
-        Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
-        registry for each version of Python.
-
-        Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
-        else from PYTHON.MACHINE.X.Y.
-
-        Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""
-
-        start = 402
-        for ver in self.versions:
-            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
-            machine_reg = "python.machine." + ver
-            user_reg = "python.user." + ver
-            machine_prop = "PYTHON.MACHINE." + ver
-            user_prop = "PYTHON.USER." + ver
-            machine_action = "PythonFromMachine" + ver
-            user_action = "PythonFromUser" + ver
-            exe_action = "PythonExe" + ver
-            target_dir_prop = "TARGETDIR" + ver
-            exe_prop = "PYTHON" + ver
-            if msilib.Win64:
-                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
-                Type = 2+16
-            else:
-                Type = 2
-            add_data(self.db, "RegLocator",
-                    [(machine_reg, 2, install_path, None, Type),
-                     (user_reg, 1, install_path, None, Type)])
-            add_data(self.db, "AppSearch",
-                    [(machine_prop, machine_reg),
-                     (user_prop, user_reg)])
-            add_data(self.db, "CustomAction",
-                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
-                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
-                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
-                    ])
-            add_data(self.db, "InstallExecuteSequence",
-                    [(machine_action, machine_prop, start),
-                     (user_action, user_prop, start + 1),
-                     (exe_action, None, start + 2),
-                    ])
-            add_data(self.db, "InstallUISequence",
-                    [(machine_action, machine_prop, start),
-                     (user_action, user_prop, start + 1),
-                     (exe_action, None, start + 2),
-                    ])
-            add_data(self.db, "Condition",
-                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
-            start += 4
-            assert start < 500
-
-    def add_scripts(self):
-        if self.install_script:
-            start = 6800
-            for ver in self.versions + [self.other_version]:
-                install_action = "install_script." + ver
-                exe_prop = "PYTHON" + ver
-                add_data(self.db, "CustomAction",
-                        [(install_action, 50, exe_prop, self.install_script_key)])
-                add_data(self.db, "InstallExecuteSequence",
-                        [(install_action, "&Python%s=3" % ver, start)])
-                start += 1
-        # XXX pre-install scripts are currently refused in finalize_options()
-        #     but if this feature is completed, it will also need to add
-        #     entries for each version as the above code does
-        if self.pre_install_script:
-            scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
-            f = open(scriptfn, "w")
-            # The batch file will be executed with [PYTHON], so that %1
-            # is the path to the Python interpreter; %0 will be the path
-            # of the batch file.
-            # rem ="""
-            # %1 %0
-            # exit
-            # """
-            # <actual script>
-            f.write('rem ="""\n%1 %0\nexit\n"""\n')
-            f.write(open(self.pre_install_script).read())
-            f.close()
-            add_data(self.db, "Binary",
-                [("PreInstall", msilib.Binary(scriptfn))
-                ])
-            add_data(self.db, "CustomAction",
-                [("PreInstall", 2, "PreInstall", None)
-                ])
-            add_data(self.db, "InstallExecuteSequence",
-                    [("PreInstall", "NOT Installed", 450)])
-
-
-    def add_ui(self):
-        db = self.db
-        x = y = 50
-        w = 370
-        h = 300
-        title = "[ProductName] Setup"
-
-        # see "Dialog Style Bits"
-        modal = 3      # visible | modal
-        modeless = 1   # visible
-        track_disk_space = 32
-
-        # UI customization properties
-        add_data(db, "Property",
-                 # See "DefaultUIFont Property"
-                 [("DefaultUIFont", "DlgFont8"),
-                  # See "ErrorDialog Style Bit"
-                  ("ErrorDialog", "ErrorDlg"),
-                  ("Progress1", "Install"),   # modified in maintenance type dlg
-                  ("Progress2", "installs"),
-                  ("MaintenanceForm_Action", "Repair"),
-                  # possible values: ALL, JUSTME
-                  ("WhichUsers", "ALL")
-                 ])
-
-        # Fonts, see "TextStyle Table"
-        add_data(db, "TextStyle",
-                 [("DlgFont8", "Tahoma", 9, None, 0),
-                  ("DlgFontBold8", "Tahoma", 8, None, 1), #bold
-                  ("VerdanaBold10", "Verdana", 10, None, 1),
-                  ("VerdanaRed9", "Verdana", 9, 255, 0),
-                 ])
-
-        # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
-        # Numbers indicate sequence; see sequence.py for how these action integrate
-        add_data(db, "InstallUISequence",
-                 [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
-                  ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
-                  # In the user interface, assume all-users installation if privileged.
-                  ("SelectFeaturesDlg", "Not Installed", 1230),
-                  # XXX no support for resume installations yet
-                  #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
-                  ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
-                  ("ProgressDlg", None, 1280)])
-
-        add_data(db, 'ActionText', text.ActionText)
-        add_data(db, 'UIText', text.UIText)
-        #####################################################################
-        # Standard dialogs: FatalError, UserExit, ExitDialog
-        fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
-                     "Finish", "Finish", "Finish")
-        fatal.title("[ProductName] Installer ended prematurely")
-        fatal.back("< Back", "Finish", active = 0)
-        fatal.cancel("Cancel", "Back", active = 0)
-        fatal.text("Description1", 15, 70, 320, 80, 0x30003,
-                   "[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.")
-        fatal.text("Description2", 15, 155, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c=fatal.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Exit")
-
-        user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
-                     "Finish", "Finish", "Finish")
-        user_exit.title("[ProductName] Installer was interrupted")
-        user_exit.back("< Back", "Finish", active = 0)
-        user_exit.cancel("Cancel", "Back", active = 0)
-        user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
-                   "[ProductName] setup was interrupted.  Your system has not been modified.  "
-                   "To install this program at a later time, please run the installation again.")
-        user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c = user_exit.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Exit")
-
-        exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
-                             "Finish", "Finish", "Finish")
-        exit_dialog.title("Completing the [ProductName] Installer")
-        exit_dialog.back("< Back", "Finish", active = 0)
-        exit_dialog.cancel("Cancel", "Back", active = 0)
-        exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
-                   "Click the Finish button to exit the Installer.")
-        c = exit_dialog.next("Finish", "Cancel", name="Finish")
-        c.event("EndDialog", "Return")
-
-        #####################################################################
-        # Required dialog: FilesInUse, ErrorDlg
-        inuse = PyDialog(db, "FilesInUse",
-                         x, y, w, h,
-                         19,                # KeepModeless|Modal|Visible
-                         title,
-                         "Retry", "Retry", "Retry", bitmap=False)
-        inuse.text("Title", 15, 6, 200, 15, 0x30003,
-                   r"{\DlgFontBold8}Files in Use")
-        inuse.text("Description", 20, 23, 280, 20, 0x30003,
-               "Some files that need to be updated are currently in use.")
-        inuse.text("Text", 20, 55, 330, 50, 3,
-                   "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
-        inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
-                      None, None, None)
-        c=inuse.back("Exit", "Ignore", name="Exit")
-        c.event("EndDialog", "Exit")
-        c=inuse.next("Ignore", "Retry", name="Ignore")
-        c.event("EndDialog", "Ignore")
-        c=inuse.cancel("Retry", "Exit", name="Retry")
-        c.event("EndDialog","Retry")
-
-        # See "Error Dialog". See "ICE20" for the required names of the controls.
-        error = Dialog(db, "ErrorDlg",
-                       50, 10, 330, 101,
-                       65543,       # Error|Minimize|Modal|Visible
-                       title,
-                       "ErrorText", None, None)
-        error.text("ErrorText", 50,9,280,48,3, "")
-        #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
-        error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
-        error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
-        error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
-        error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
-        error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
-        error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
-        error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")
-
-        #####################################################################
-        # Global "Query Cancel" dialog
-        cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
-                        "No", "No", "No")
-        cancel.text("Text", 48, 15, 194, 30, 3,
-                    "Are you sure you want to cancel [ProductName] installation?")
-        #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
-        #               "py.ico", None, None)
-        c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
-        c.event("EndDialog", "Exit")
-
-        c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
-        c.event("EndDialog", "Return")
-
-        #####################################################################
-        # Global "Wait for costing" dialog
-        costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
-                         "Return", "Return", "Return")
-        costing.text("Text", 48, 15, 194, 30, 3,
-                     "Please wait while the installer finishes determining your disk space requirements.")
-        c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
-        c.event("EndDialog", "Exit")
-
-        #####################################################################
-        # Preparation dialog: no user input except cancellation
-        prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
-                        "Cancel", "Cancel", "Cancel")
-        prep.text("Description", 15, 70, 320, 40, 0x30003,
-                  "Please wait while the Installer prepares to guide you through the installation.")
-        prep.title("Welcome to the [ProductName] Installer")
-        c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
-        c.mapping("ActionText", "Text")
-        c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
-        c.mapping("ActionData", "Text")
-        prep.back("Back", None, active=0)
-        prep.next("Next", None, active=0)
-        c=prep.cancel("Cancel", None)
-        c.event("SpawnDialog", "CancelDlg")
-
-        #####################################################################
-        # Feature (Python directory) selection
-        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
-                        "Next", "Next", "Cancel")
-        seldlg.title("Select Python Installations")
-
-        seldlg.text("Hint", 15, 30, 300, 20, 3,
-                    "Select the Python locations where %s should be installed."
-                    % self.distribution.get_fullname())
-
-        seldlg.back("< Back", None, active=0)
-        c = seldlg.next("Next >", "Cancel")
-        order = 1
-        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
-        for version in self.versions + [self.other_version]:
-            order += 1
-            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
-                    "FEATURE_SELECTED AND &Python%s=3" % version,
-                    ordering=order)
-        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
-        c.event("EndDialog", "Return", ordering=order + 2)
-        c = seldlg.cancel("Cancel", "Features")
-        c.event("SpawnDialog", "CancelDlg")
-
-        c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
-                           "FEATURE", None, "PathEdit", None)
-        c.event("[FEATURE_SELECTED]", "1")
-        ver = self.other_version
-        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
-        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver
-
-        c = seldlg.text("Other", 15, 200, 300, 15, 3,
-                        "Provide an alternate Python location")
-        c.condition("Enable", install_other_cond)
-        c.condition("Show", install_other_cond)
-        c.condition("Disable", dont_install_other_cond)
-        c.condition("Hide", dont_install_other_cond)
-
-        c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
-                           "TARGETDIR" + ver, None, "Next", None)
-        c.condition("Enable", install_other_cond)
-        c.condition("Show", install_other_cond)
-        c.condition("Disable", dont_install_other_cond)
-        c.condition("Hide", dont_install_other_cond)
-
-        #####################################################################
-        # Disk cost
-        cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
-                        "OK", "OK", "OK", bitmap=False)
-        cost.text("Title", 15, 6, 200, 15, 0x30003,
-                 r"{\DlgFontBold8}Disk Space Requirements")
-        cost.text("Description", 20, 20, 280, 20, 0x30003,
-                  "The disk space required for the installation of the selected features.")
-        cost.text("Text", 20, 53, 330, 60, 3,
-                  "The highlighted volumes (if any) do not have enough disk space "
-              "available for the currently selected features.  You can either "
-              "remove some files from the highlighted volumes, or choose to "
-              "install less features onto local drive(s), or select different "
-              "destination drive(s).")
-        cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
-                     None, "{120}{70}{70}{70}{70}", None, None)
-        cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")
-
-        #####################################################################
-        # WhichUsers Dialog. Only available on NT, and for privileged users.
-        # This must be run before FindRelatedProducts, because that will
-        # take into account whether the previous installation was per-user
-        # or per-machine. We currently don't support going back to this
-        # dialog after "Next" was selected; to support this, we would need to
-        # find how to reset the ALLUSERS property, and how to re-run
-        # FindRelatedProducts.
-        # On Windows9x, the ALLUSERS property is ignored on the command line
-        # and in the Property table, but installer fails according to the documentation
-        # if a dialog attempts to set ALLUSERS.
-        whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
-                            "AdminInstall", "Next", "Cancel")
-        whichusers.title("Select whether to install [ProductName] for all users of this computer.")
-        # A radio group with two options: allusers, justme
-        g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
-                                  "WhichUsers", "", "Next")
-        g.add("ALL", 0, 5, 150, 20, "Install for all users")
-        g.add("JUSTME", 0, 25, 150, 20, "Install just for me")
-
-        whichusers.back("Back", None, active=0)
-
-        c = whichusers.next("Next >", "Cancel")
-        c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
-        c.event("EndDialog", "Return", ordering = 2)
-
-        c = whichusers.cancel("Cancel", "AdminInstall")
-        c.event("SpawnDialog", "CancelDlg")
-
-        #####################################################################
-        # Installation Progress dialog (modeless)
-        progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
-                            "Cancel", "Cancel", "Cancel", bitmap=False)
-        progress.text("Title", 20, 15, 200, 15, 0x30003,
-                     r"{\DlgFontBold8}[Progress1] [ProductName]")
-        progress.text("Text", 35, 65, 300, 30, 3,
-                      "Please wait while the Installer [Progress2] [ProductName]. "
-                      "This may take several minutes.")
-        progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")
-
-        c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
-        c.mapping("ActionText", "Text")
-
-        #c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
-        #c.mapping("ActionData", "Text")
-
-        c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
-                           None, "Progress done", None, None)
-        c.mapping("SetProgress", "Progress")
-
-        progress.back("< Back", "Next", active=False)
-        progress.next("Next >", "Cancel", active=False)
-        progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")
-
-        ###################################################################
-        # Maintenance type: repair/uninstall
-        maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
-                         "Next", "Next", "Cancel")
-        maint.title("Welcome to the [ProductName] Setup Wizard")
-        maint.text("BodyText", 15, 63, 330, 42, 3,
-                   "Select whether you want to repair or remove [ProductName].")
-        g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
-                            "MaintenanceForm_Action", "", "Next")
-        #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
-        g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
-        g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")
-
-        maint.back("< Back", None, active=False)
-        c=maint.next("Finish", "Cancel")
-        # Change installation: Change progress dialog to "Change", then ask
-        # for feature selection
-        #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
-        #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)
-
-        # Reinstall: Change progress dialog to "Repair", then invoke reinstall
-        # Also set list of reinstalled features to "ALL"
-        c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
-        c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
-        c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
-        c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)
-
-        # Uninstall: Change progress to "Remove", then invoke uninstall
-        # Also set list of removed features to "ALL"
-        c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
-        c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
-        c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
-        c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)
-
-        # Close dialog when maintenance action scheduled
-        c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
-        #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)
-
-        maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")
-
-    def get_installer_filename(self, fullname):
-        # Factored out to allow overriding in subclasses
-        if self.target_version:
-            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
-                                            self.target_version)
-        else:
-            base_name = "%s.%s.msi" % (fullname, self.plat_name)
-        installer_name = os.path.join(self.dist_dir, base_name)
-        return installer_name
diff --git a/Lib/distutils/command/bdist_rpm.py b/Lib/distutils/command/bdist_rpm.py
deleted file mode 100644
index 02f10dd89d..0000000000
--- a/Lib/distutils/command/bdist_rpm.py
+++ /dev/null
@@ -1,582 +0,0 @@
-"""distutils.command.bdist_rpm
-
-Implements the Distutils 'bdist_rpm' command (create RPM source and binary
-distributions)."""
-
-import subprocess, sys, os
-from distutils.core import Command
-from distutils.debug import DEBUG
-from distutils.util import get_platform
-from distutils.file_util import write_file
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_rpm(Command):
-
-    description = "create an RPM distribution"
-
-    user_options = [
-        ('bdist-base=', None,
-         "base directory for creating built distributions"),
-        ('rpm-base=', None,
-         "base directory for creating RPMs (defaults to \"rpm\" under "
-         "--bdist-base; must be specified for RPM 2)"),
-        ('dist-dir=', 'd',
-         "directory to put final RPM files in "
-         "(and .spec files if --spec-only)"),
-        ('python=', None,
-         "path to Python interpreter to hard-code in the .spec file "
-         "(default: \"python\")"),
-        ('fix-python', None,
-         "hard-code the exact path to the current Python interpreter in "
-         "the .spec file"),
-        ('spec-only', None,
-         "only regenerate spec file"),
-        ('source-only', None,
-         "only generate source RPM"),
-        ('binary-only', None,
-         "only generate binary RPM"),
-        ('use-bzip2', None,
-         "use bzip2 instead of gzip to create source distribution"),
-
-        # More meta-data: too RPM-specific to put in the setup script,
-        # but needs to go in the .spec file -- so we make these options
-        # to "bdist_rpm".  The idea is that packagers would put this
-        # info in setup.cfg, although they are of course free to
-        # supply it on the command line.
-        ('distribution-name=', None,
-         "name of the (Linux) distribution to which this "
-         "RPM applies (*not* the name of the module distribution!)"),
-        ('group=', None,
-         "package classification [default: \"Development/Libraries\"]"),
-        ('release=', None,
-         "RPM release number"),
-        ('serial=', None,
-         "RPM serial number"),
-        ('vendor=', None,
-         "RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
-         "[default: maintainer or author from setup script]"),
-        ('packager=', None,
-         "RPM packager (eg. \"Jane Doe <jane@example.net>\") "
-         "[default: vendor]"),
-        ('doc-files=', None,
-         "list of documentation files (space or comma-separated)"),
-        ('changelog=', None,
-         "RPM changelog"),
-        ('icon=', None,
-         "name of icon file"),
-        ('provides=', None,
-         "capabilities provided by this package"),
-        ('requires=', None,
-         "capabilities required by this package"),
-        ('conflicts=', None,
-         "capabilities which conflict with this package"),
-        ('build-requires=', None,
-         "capabilities required to build this package"),
-        ('obsoletes=', None,
-         "capabilities made obsolete by this package"),
-        ('no-autoreq', None,
-         "do not automatically calculate dependencies"),
-
-        # Actions to take when building RPM
-        ('keep-temp', 'k',
-         "don't clean up RPM build directory"),
-        ('no-keep-temp', None,
-         "clean up RPM build directory [default]"),
-        ('use-rpm-opt-flags', None,
-         "compile with RPM_OPT_FLAGS when building from source RPM"),
-        ('no-rpm-opt-flags', None,
-         "do not pass any RPM CFLAGS to compiler"),
-        ('rpm3-mode', None,
-         "RPM 3 compatibility mode (default)"),
-        ('rpm2-mode', None,
-         "RPM 2 compatibility mode"),
-
-        # Add the hooks necessary for specifying custom scripts
-        ('prep-script=', None,
-         "Specify a script for the PREP phase of RPM building"),
-        ('build-script=', None,
-         "Specify a script for the BUILD phase of RPM building"),
-
-        ('pre-install=', None,
-         "Specify a script for the pre-INSTALL phase of RPM building"),
-        ('install-script=', None,
-         "Specify a script for the INSTALL phase of RPM building"),
-        ('post-install=', None,
-         "Specify a script for the post-INSTALL phase of RPM building"),
-
-        ('pre-uninstall=', None,
-         "Specify a script for the pre-UNINSTALL phase of RPM building"),
-        ('post-uninstall=', None,
-         "Specify a script for the post-UNINSTALL phase of RPM building"),
-
-        ('clean-script=', None,
-         "Specify a script for the CLEAN phase of RPM building"),
-
-        ('verify-script=', None,
-         "Specify a script for the VERIFY phase of the RPM build"),
-
-        # Allow a packager to explicitly force an architecture
-        ('force-arch=', None,
-         "Force an architecture onto the RPM build process"),
-
-        ('quiet', 'q',
-         "Run the INSTALL phase of RPM building in quiet mode"),
-        ]
-
-    boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
-                       'no-autoreq', 'quiet']
-
-    negative_opt = {'no-keep-temp': 'keep-temp',
-                    'no-rpm-opt-flags': 'use-rpm-opt-flags',
-                    'rpm2-mode': 'rpm3-mode'}
-
-
-    def initialize_options(self):
-        self.bdist_base = None
-        self.rpm_base = None
-        self.dist_dir = None
-        self.python = None
-        self.fix_python = None
-        self.spec_only = None
-        self.binary_only = None
-        self.source_only = None
-        self.use_bzip2 = None
-
-        self.distribution_name = None
-        self.group = None
-        self.release = None
-        self.serial = None
-        self.vendor = None
-        self.packager = None
-        self.doc_files = None
-        self.changelog = None
-        self.icon = None
-
-        self.prep_script = None
-        self.build_script = None
-        self.install_script = None
-        self.clean_script = None
-        self.verify_script = None
-        self.pre_install = None
-        self.post_install = None
-        self.pre_uninstall = None
-        self.post_uninstall = None
-        self.prep = None
-        self.provides = None
-        self.requires = None
-        self.conflicts = None
-        self.build_requires = None
-        self.obsoletes = None
-
-        self.keep_temp = 0
-        self.use_rpm_opt_flags = 1
-        self.rpm3_mode = 1
-        self.no_autoreq = 0
-
-        self.force_arch = None
-        self.quiet = 0
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
-        if self.rpm_base is None:
-            if not self.rpm3_mode:
-                raise DistutilsOptionError(
-                      "you must specify --rpm-base in RPM 2 mode")
-            self.rpm_base = os.path.join(self.bdist_base, "rpm")
-
-        if self.python is None:
-            if self.fix_python:
-                self.python = sys.executable
-            else:
-                self.python = "python3"
-        elif self.fix_python:
-            raise DistutilsOptionError(
-                  "--python and --fix-python are mutually exclusive options")
-
-        if os.name != 'posix':
-            raise DistutilsPlatformError("don't know how to create RPM "
-                   "distributions on platform %s" % os.name)
-        if self.binary_only and self.source_only:
-            raise DistutilsOptionError(
-                  "cannot supply both '--source-only' and '--binary-only'")
-
-        # don't pass CFLAGS to pure python distributions
-        if not self.distribution.has_ext_modules():
-            self.use_rpm_opt_flags = 0
-
-        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
-        self.finalize_package_data()
-
-    def finalize_package_data(self):
-        self.ensure_string('group', "Development/Libraries")
-        self.ensure_string('vendor',
-                           "%s <%s>" % (self.distribution.get_contact(),
-                                        self.distribution.get_contact_email()))
-        self.ensure_string('packager')
-        self.ensure_string_list('doc_files')
-        if isinstance(self.doc_files, list):
-            for readme in ('README', 'README.txt'):
-                if os.path.exists(readme) and readme not in self.doc_files:
-                    self.doc_files.append(readme)
-
-        self.ensure_string('release', "1")
-        self.ensure_string('serial')   # should it be an int?
-
-        self.ensure_string('distribution_name')
-
-        self.ensure_string('changelog')
-          # Format changelog correctly
-        self.changelog = self._format_changelog(self.changelog)
-
-        self.ensure_filename('icon')
-
-        self.ensure_filename('prep_script')
-        self.ensure_filename('build_script')
-        self.ensure_filename('install_script')
-        self.ensure_filename('clean_script')
-        self.ensure_filename('verify_script')
-        self.ensure_filename('pre_install')
-        self.ensure_filename('post_install')
-        self.ensure_filename('pre_uninstall')
-        self.ensure_filename('post_uninstall')
-
-        # XXX don't forget we punted on summaries and descriptions -- they
-        # should be handled here eventually!
-
-        # Now *this* is some meta-data that belongs in the setup script...
-        self.ensure_string_list('provides')
-        self.ensure_string_list('requires')
-        self.ensure_string_list('conflicts')
-        self.ensure_string_list('build_requires')
-        self.ensure_string_list('obsoletes')
-
-        self.ensure_string('force_arch')
-
-    def run(self):
-        if DEBUG:
-            print("before _get_package_data():")
-            print("vendor =", self.vendor)
-            print("packager =", self.packager)
-            print("doc_files =", self.doc_files)
-            print("changelog =", self.changelog)
-
-        # make directories
-        if self.spec_only:
-            spec_dir = self.dist_dir
-            self.mkpath(spec_dir)
-        else:
-            rpm_dir = {}
-            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
-                rpm_dir[d] = os.path.join(self.rpm_base, d)
-                self.mkpath(rpm_dir[d])
-            spec_dir = rpm_dir['SPECS']
-
-        # Spec file goes into 'dist_dir' if '--spec-only specified',
-        # build/rpm.<plat> otherwise.
-        spec_path = os.path.join(spec_dir,
-                                 "%s.spec" % self.distribution.get_name())
-        self.execute(write_file,
-                     (spec_path,
-                      self._make_spec_file()),
-                     "writing '%s'" % spec_path)
-
-        if self.spec_only: # stop if requested
-            return
-
-        # Make a source distribution and copy to SOURCES directory with
-        # optional icon.
-        saved_dist_files = self.distribution.dist_files[:]
-        sdist = self.reinitialize_command('sdist')
-        if self.use_bzip2:
-            sdist.formats = ['bztar']
-        else:
-            sdist.formats = ['gztar']
-        self.run_command('sdist')
-        self.distribution.dist_files = saved_dist_files
-
-        source = sdist.get_archive_files()[0]
-        source_dir = rpm_dir['SOURCES']
-        self.copy_file(source, source_dir)
-
-        if self.icon:
-            if os.path.exists(self.icon):
-                self.copy_file(self.icon, source_dir)
-            else:
-                raise DistutilsFileError(
-                      "icon file '%s' does not exist" % self.icon)
-
-        # build package
-        log.info("building RPMs")
-        rpm_cmd = ['rpm']
-        if os.path.exists('/usr/bin/rpmbuild') or \
-           os.path.exists('/bin/rpmbuild'):
-            rpm_cmd = ['rpmbuild']
-
-        if self.source_only: # what kind of RPMs?
-            rpm_cmd.append('-bs')
-        elif self.binary_only:
-            rpm_cmd.append('-bb')
-        else:
-            rpm_cmd.append('-ba')
-        rpm_cmd.extend(['--define', '__python %s' % self.python])
-        if self.rpm3_mode:
-            rpm_cmd.extend(['--define',
-                             '_topdir %s' % os.path.abspath(self.rpm_base)])
-        if not self.keep_temp:
-            rpm_cmd.append('--clean')
-
-        if self.quiet:
-            rpm_cmd.append('--quiet')
-
-        rpm_cmd.append(spec_path)
-        # Determine the binary rpm names that should be built out of this spec
-        # file
-        # Note that some of these may not be really built (if the file
-        # list is empty)
-        nvr_string = "%{name}-%{version}-%{release}"
-        src_rpm = nvr_string + ".src.rpm"
-        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
-        q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
-            src_rpm, non_src_rpm, spec_path)
-
-        out = os.popen(q_cmd)
-        try:
-            binary_rpms = []
-            source_rpm = None
-            while True:
-                line = out.readline()
-                if not line:
-                    break
-                l = line.strip().split()
-                assert(len(l) == 2)
-                binary_rpms.append(l[1])
-                # The source rpm is named after the first entry in the spec file
-                if source_rpm is None:
-                    source_rpm = l[0]
-
-            status = out.close()
-            if status:
-                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))
-
-        finally:
-            out.close()
-
-        self.spawn(rpm_cmd)
-
-        if not self.dry_run:
-            if self.distribution.has_ext_modules():
-                pyversion = get_python_version()
-            else:
-                pyversion = 'any'
-
-            if not self.binary_only:
-                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
-                assert(os.path.exists(srpm))
-                self.move_file(srpm, self.dist_dir)
-                filename = os.path.join(self.dist_dir, source_rpm)
-                self.distribution.dist_files.append(
-                    ('bdist_rpm', pyversion, filename))
-
-            if not self.source_only:
-                for rpm in binary_rpms:
-                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
-                    if os.path.exists(rpm):
-                        self.move_file(rpm, self.dist_dir)
-                        filename = os.path.join(self.dist_dir,
-                                                os.path.basename(rpm))
-                        self.distribution.dist_files.append(
-                            ('bdist_rpm', pyversion, filename))
-
-    def _dist_path(self, path):
-        return os.path.join(self.dist_dir, os.path.basename(path))
-
-    def _make_spec_file(self):
-        """Generate the text of an RPM spec file and return it as a
-        list of strings (one per line).
-        """
-        # definitions and headers
-        spec_file = [
-            '%define name ' + self.distribution.get_name(),
-            '%define version ' + self.distribution.get_version().replace('-','_'),
-            '%define unmangled_version ' + self.distribution.get_version(),
-            '%define release ' + self.release.replace('-','_'),
-            '',
-            'Summary: ' + self.distribution.get_description(),
-            ]
-
-        # Workaround for #14443 which affects some RPM based systems such as
-        # RHEL6 (and probably derivatives)
-        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
-        # Generate a potential replacement value for __os_install_post (whilst
-        # normalizing the whitespace to simplify the test for whether the
-        # invocation of brp-python-bytecompile passes in __python):
-        vendor_hook = '\n'.join(['  %s \\' % line.strip()
-                                 for line in vendor_hook.splitlines()])
-        problem = "brp-python-bytecompile \\\n"
-        fixed = "brp-python-bytecompile %{__python} \\\n"
-        fixed_hook = vendor_hook.replace(problem, fixed)
-        if fixed_hook != vendor_hook:
-            spec_file.append('# Workaround for http://bugs.python.org/issue14443')
-            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')
-
-        # put locale summaries into spec file
-        # XXX not supported for now (hard to put a dictionary
-        # in a config file -- arg!)
-        #for locale in self.summaries.keys():
-        #    spec_file.append('Summary(%s): %s' % (locale,
-        #                                          self.summaries[locale]))
-
-        spec_file.extend([
-            'Name: %{name}',
-            'Version: %{version}',
-            'Release: %{release}',])
-
-        # XXX yuck! this filename is available from the "sdist" command,
-        # but only after it has run: and we create the spec file before
-        # running "sdist", in case of --spec-only.
-        if self.use_bzip2:
-            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
-        else:
-            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')
-
-        spec_file.extend([
-            'License: ' + self.distribution.get_license(),
-            'Group: ' + self.group,
-            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
-            'Prefix: %{_prefix}', ])
-
-        if not self.force_arch:
-            # noarch if no extension modules
-            if not self.distribution.has_ext_modules():
-                spec_file.append('BuildArch: noarch')
-        else:
-            spec_file.append( 'BuildArch: %s' % self.force_arch )
-
-        for field in ('Vendor',
-                      'Packager',
-                      'Provides',
-                      'Requires',
-                      'Conflicts',
-                      'Obsoletes',
-                      ):
-            val = getattr(self, field.lower())
-            if isinstance(val, list):
-                spec_file.append('%s: %s' % (field, ' '.join(val)))
-            elif val is not None:
-                spec_file.append('%s: %s' % (field, val))
-
-
-        if self.distribution.get_url() != 'UNKNOWN':
-            spec_file.append('Url: ' + self.distribution.get_url())
-
-        if self.distribution_name:
-            spec_file.append('Distribution: ' + self.distribution_name)
-
-        if self.build_requires:
-            spec_file.append('BuildRequires: ' +
-                             ' '.join(self.build_requires))
-
-        if self.icon:
-            spec_file.append('Icon: ' + os.path.basename(self.icon))
-
-        if self.no_autoreq:
-            spec_file.append('AutoReq: 0')
-
-        spec_file.extend([
-            '',
-            '%description',
-            self.distribution.get_long_description()
-            ])
-
-        # put locale descriptions into spec file
-        # XXX again, suppressed because config file syntax doesn't
-        # easily support this ;-(
-        #for locale in self.descriptions.keys():
-        #    spec_file.extend([
-        #        '',
-        #        '%description -l ' + locale,
-        #        self.descriptions[locale],
-        #        ])
-
-        # rpm scripts
-        # figure out default build script
-        def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
-        def_build = "%s build" % def_setup_call
-        if self.use_rpm_opt_flags:
-            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build
-
-        # insert contents of files
-
-        # XXX this is kind of misleading: user-supplied options are files
-        # that we open and interpolate into the spec file, but the defaults
-        # are just text that we drop in as-is.  Hmmm.
-
-        install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
-                       '--record=INSTALLED_FILES') % def_setup_call
-
-        script_options = [
-            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
-            ('build', 'build_script', def_build),
-            ('install', 'install_script', install_cmd),
-            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
-            ('verifyscript', 'verify_script', None),
-            ('pre', 'pre_install', None),
-            ('post', 'post_install', None),
-            ('preun', 'pre_uninstall', None),
-            ('postun', 'post_uninstall', None),
-        ]
-
-        for (rpm_opt, attr, default) in script_options:
-            # Insert contents of file referred to, if no file is referred to
-            # use 'default' as contents of script
-            val = getattr(self, attr)
-            if val or default:
-                spec_file.extend([
-                    '',
-                    '%' + rpm_opt,])
-                if val:
-                    spec_file.extend(open(val, 'r').read().split('\n'))
-                else:
-                    spec_file.append(default)
-
-
-        # files section
-        spec_file.extend([
-            '',
-            '%files -f INSTALLED_FILES',
-            '%defattr(-,root,root)',
-            ])
-
-        if self.doc_files:
-            spec_file.append('%doc ' + ' '.join(self.doc_files))
-
-        if self.changelog:
-            spec_file.extend([
-                '',
-                '%changelog',])
-            spec_file.extend(self.changelog)
-
-        return spec_file
-
-    def _format_changelog(self, changelog):
-        """Format the changelog correctly and convert it to a list of strings
-        """
-        if not changelog:
-            return changelog
-        new_changelog = []
-        for line in changelog.strip().split('\n'):
-            line = line.strip()
-            if line[0] == '*':
-                new_changelog.extend(['', line])
-            elif line[0] == '-':
-                new_changelog.append(line)
-            else:
-                new_changelog.append('  ' + line)
-
-        # strip trailing newline inserted by first changelog entry
-        if not new_changelog[0]:
-            del new_changelog[0]
-
-        return new_changelog
diff --git a/Lib/distutils/command/bdist_wininst.py b/Lib/distutils/command/bdist_wininst.py
deleted file mode 100644
index 1db47f9b98..0000000000
--- a/Lib/distutils/command/bdist_wininst.py
+++ /dev/null
@@ -1,367 +0,0 @@
-"""distutils.command.bdist_wininst
-
-Implements the Distutils 'bdist_wininst' command: create a windows installer
-exe-program."""
-
-import sys, os
-from distutils.core import Command
-from distutils.util import get_platform
-from distutils.dir_util import create_tree, remove_tree
-from distutils.errors import *
-from distutils.sysconfig import get_python_version
-from distutils import log
-
-class bdist_wininst(Command):
-
-    description = "create an executable installer for MS Windows"
-
-    user_options = [('bdist-dir=', None,
-                     "temporary directory for creating the distribution"),
-                    ('plat-name=', 'p',
-                     "platform name to embed in generated filenames "
-                     "(default: %s)" % get_platform()),
-                    ('keep-temp', 'k',
-                     "keep the pseudo-installation tree around after " +
-                     "creating the distribution archive"),
-                    ('target-version=', None,
-                     "require a specific python version" +
-                     " on the target system"),
-                    ('no-target-compile', 'c',
-                     "do not compile .py to .pyc on the target system"),
-                    ('no-target-optimize', 'o',
-                     "do not compile .py to .pyo (optimized) "
-                     "on the target system"),
-                    ('dist-dir=', 'd',
-                     "directory to put final built distributions in"),
-                    ('bitmap=', 'b',
-                     "bitmap to use for the installer instead of python-powered logo"),
-                    ('title=', 't',
-                     "title to display on the installer background instead of default"),
-                    ('skip-build', None,
-                     "skip rebuilding everything (for testing/debugging)"),
-                    ('install-script=', None,
-                     "basename of installation script to be run after "
-                     "installation or before deinstallation"),
-                    ('pre-install-script=', None,
-                     "Fully qualified filename of a script to be run before "
-                     "any files are installed.  This script need not be in the "
-                     "distribution"),
-                    ('user-access-control=', None,
-                     "specify Vista's UAC handling - 'none'/default=no "
-                     "handling, 'auto'=use UAC if target Python installed for "
-                     "all users, 'force'=always use UAC"),
-                   ]
-
-    boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
-                       'skip-build']
-
-    def initialize_options(self):
-        self.bdist_dir = None
-        self.plat_name = None
-        self.keep_temp = 0
-        self.no_target_compile = 0
-        self.no_target_optimize = 0
-        self.target_version = None
-        self.dist_dir = None
-        self.bitmap = None
-        self.title = None
-        self.skip_build = None
-        self.install_script = None
-        self.pre_install_script = None
-        self.user_access_control = None
-
-
-    def finalize_options(self):
-        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))
-
-        if self.bdist_dir is None:
-            if self.skip_build and self.plat_name:
-                # If build is skipped and plat_name is overridden, bdist will
-                # not see the correct 'plat_name' - so set that up manually.
-                bdist = self.distribution.get_command_obj('bdist')
-                bdist.plat_name = self.plat_name
-                # next the command will be initialized using that name
-            bdist_base = self.get_finalized_command('bdist').bdist_base
-            self.bdist_dir = os.path.join(bdist_base, 'wininst')
-
-        if not self.target_version:
-            self.target_version = ""
-
-        if not self.skip_build and self.distribution.has_ext_modules():
-            short_version = get_python_version()
-            if self.target_version and self.target_version != short_version:
-                raise DistutilsOptionError(
-                      "target version can only be %s, or the '--skip-build'" \
-                      " option must be specified" % (short_version,))
-            self.target_version = short_version
-
-        self.set_undefined_options('bdist',
-                                   ('dist_dir', 'dist_dir'),
-                                   ('plat_name', 'plat_name'),
-                                  )
-
-        if self.install_script:
-            for script in self.distribution.scripts:
-                if self.install_script == os.path.basename(script):
-                    break
-            else:
-                raise DistutilsOptionError(
-                      "install_script '%s' not found in scripts"
-                      % self.install_script)
-
-    def run(self):
-        if (sys.platform != "win32" and
-            (self.distribution.has_ext_modules() or
-             self.distribution.has_c_libraries())):
-            raise DistutilsPlatformError \
-                  ("distribution contains extensions and/or C libraries; "
-                   "must be compiled on a Windows 32 platform")
-
-        if not self.skip_build:
-            self.run_command('build')
-
-        install = self.reinitialize_command('install', reinit_subcommands=1)
-        install.root = self.bdist_dir
-        install.skip_build = self.skip_build
-        install.warn_dir = 0
-        install.plat_name = self.plat_name
-
-        install_lib = self.reinitialize_command('install_lib')
-        # we do not want to include pyc or pyo files
-        install_lib.compile = 0
-        install_lib.optimize = 0
-
-        if self.distribution.has_ext_modules():
-            # If we are building an installer for a Python version other
-            # than the one we are currently running, then we need to ensure
-            # our build_lib reflects the other Python version rather than ours.
-            # Note that for target_version!=sys.version, we must have skipped the
-            # build step, so there is no issue with enforcing the build of this
-            # version.
-            target_version = self.target_version
-            if not target_version:
-                assert self.skip_build, "Should have already checked this"
-                target_version = '%d.%d' % sys.version_info[:2]
-            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
-            build = self.get_finalized_command('build')
-            build.build_lib = os.path.join(build.build_base,
-                                           'lib' + plat_specifier)
-
-        # Use a custom scheme for the zip-file, because we have to decide
-        # at installation time which scheme to use.
-        for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
-            value = key.upper()
-            if key == 'headers':
-                value = value + '/Include/$dist_name'
-            setattr(install,
-                    'install_' + key,
-                    value)
-
-        log.info("installing to %s", self.bdist_dir)
-        install.ensure_finalized()
-
-        # avoid warning of 'install_lib' about installing
-        # into a directory not in sys.path
-        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
-
-        install.run()
-
-        del sys.path[0]
-
-        # And make an archive relative to the root of the
-        # pseudo-installation tree.
-        from tempfile import mktemp
-        archive_basename = mktemp()
-        fullname = self.distribution.get_fullname()
-        arcname = self.make_archive(archive_basename, "zip",
-                                    root_dir=self.bdist_dir)
-        # create an exe containing the zip-file
-        self.create_exe(arcname, fullname, self.bitmap)
-        if self.distribution.has_ext_modules():
-            pyversion = get_python_version()
-        else:
-            pyversion = 'any'
-        self.distribution.dist_files.append(('bdist_wininst', pyversion,
-                                             self.get_installer_filename(fullname)))
-        # remove the zip-file again
-        log.debug("removing temporary file '%s'", arcname)
-        os.remove(arcname)
-
-        if not self.keep_temp:
-            remove_tree(self.bdist_dir, dry_run=self.dry_run)
-
-    def get_inidata(self):
-        # Return data describing the installation.
-        lines = []
-        metadata = self.distribution.metadata
-
-        # Write the [metadata] section.
-        lines.append("[metadata]")
-
-        # 'info' will be displayed in the installer's dialog box,
-        # describing the items to be installed.
-        info = (metadata.long_description or '') + '\n'
-
-        # Escape newline characters
-        def escape(s):
-            return s.replace("\n", "\\n")
-
-        for name in ["author", "author_email", "description", "maintainer",
-                     "maintainer_email", "name", "url", "version"]:
-            data = getattr(metadata, name, "")
-            if data:
-                info = info + ("\n    %s: %s" % \
-                               (name.capitalize(), escape(data)))
-                lines.append("%s=%s" % (name, escape(data)))
-
-        # The [setup] section contains entries controlling
-        # the installer runtime.
-        lines.append("\n[Setup]")
-        if self.install_script:
-            lines.append("install_script=%s" % self.install_script)
-        lines.append("info=%s" % escape(info))
-        lines.append("target_compile=%d" % (not self.no_target_compile))
-        lines.append("target_optimize=%d" % (not self.no_target_optimize))
-        if self.target_version:
-            lines.append("target_version=%s" % self.target_version)
-        if self.user_access_control:
-            lines.append("user_access_control=%s" % self.user_access_control)
-
-        title = self.title or self.distribution.get_fullname()
-        lines.append("title=%s" % escape(title))
-        import time
-        import distutils
-        build_info = "Built %s with distutils-%s" % \
-                     (time.ctime(time.time()), distutils.__version__)
-        lines.append("build_info=%s" % build_info)
-        return "\n".join(lines)
-
-    def create_exe(self, arcname, fullname, bitmap=None):
-        import struct
-
-        self.mkpath(self.dist_dir)
-
-        cfgdata = self.get_inidata()
-
-        installer_name = self.get_installer_filename(fullname)
-        self.announce("creating %s" % installer_name)
-
-        if bitmap:
-            bitmapdata = open(bitmap, "rb").read()
-            bitmaplen = len(bitmapdata)
-        else:
-            bitmaplen = 0
-
-        file = open(installer_name, "wb")
-        file.write(self.get_exe_bytes())
-        if bitmap:
-            file.write(bitmapdata)
-
-        # Convert cfgdata from unicode to ascii, mbcs encoded
-        if isinstance(cfgdata, str):
-            cfgdata = cfgdata.encode("mbcs")
-
-        # Append the pre-install script
-        cfgdata = cfgdata + b"\0"
-        if self.pre_install_script:
-            # We need to normalize newlines, so we open in text mode and
-            # convert back to bytes. "latin-1" simply avoids any possible
-            # failures.
-            with open(self.pre_install_script, "r",
-                encoding="latin-1") as script:
-                script_data = script.read().encode("latin-1")
-            cfgdata = cfgdata + script_data + b"\n\0"
-        else:
-            # empty pre-install script
-            cfgdata = cfgdata + b"\0"
-        file.write(cfgdata)
-
-        # The 'magic number' 0x1234567B is used to make sure that the
-        # binary layout of 'cfgdata' is what the wininst.exe binary
-        # expects.  If the layout changes, increment that number, make
-        # the corresponding changes to the wininst.exe sources, and
-        # recompile them.
-        header = struct.pack("<iii",
-                             0x1234567B,       # tag
-                             len(cfgdata),     # length
-                             bitmaplen,        # number of bytes in bitmap
-                             )
-        file.write(header)
-        file.write(open(arcname, "rb").read())
-
-    def get_installer_filename(self, fullname):
-        # Factored out to allow overriding in subclasses
-        if self.target_version:
-            # if we create an installer for a specific python version,
-            # it's better to include this in the name
-            installer_name = os.path.join(self.dist_dir,
-                                          "%s.%s-py%s.exe" %
-                                           (fullname, self.plat_name, self.target_version))
-        else:
-            installer_name = os.path.join(self.dist_dir,
-                                          "%s.%s.exe" % (fullname, self.plat_name))
-        return installer_name
-
-    def get_exe_bytes(self):
-        # If a target-version other than the current version has been
-        # specified, then using the MSVC version from *this* build is no good.
-        # Without actually finding and executing the target version and parsing
-        # its sys.version, we just hard-code our knowledge of old versions.
-        # NOTE: Possible alternative is to allow "--target-version" to
-        # specify a Python executable rather than a simple version string.
-        # We can then execute this program to obtain any info we need, such
-        # as the real sys.version string for the build.
-        cur_version = get_python_version()
-
-        # If the target version is *later* than us, then we assume they
-        # use what we use
-        # string compares seem wrong, but are what sysconfig.py itself uses
-        if self.target_version and self.target_version < cur_version:
-            if self.target_version < "2.4":
-                bv = '6.0'
-            elif self.target_version == "2.4":
-                bv = '7.1'
-            elif self.target_version == "2.5":
-                bv = '8.0'
-            elif self.target_version <= "3.2":
-                bv = '9.0'
-            elif self.target_version <= "3.4":
-                bv = '10.0'
-            else:
-                bv = '14.0'
-        else:
-            # for current version - use authoritative check.
-            try:
-                from msvcrt import CRT_ASSEMBLY_VERSION
-            except ImportError:
-                # cross-building, so assume the latest version
-                bv = '14.0'
-            else:
-                # as far as we know, CRT is binary compatible based on
-                # the first field, so assume 'x.0' until proven otherwise
-                major = CRT_ASSEMBLY_VERSION.partition('.')[0]
-                bv = major + '.0'
-
-
-        # wininst-x.y.exe is in the same directory as this file
-        directory = os.path.dirname(__file__)
-        # we must use a wininst-x.y.exe built with the same C compiler
-        # used for python.  XXX What about mingw, borland, and so on?
-
-        # if plat_name starts with "win" but is not "win32"
-        # we want to strip "win" and leave the rest (e.g. -amd64)
-        # for all other cases, we don't want any suffix
-        if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
-            sfix = self.plat_name[3:]
-        else:
-            sfix = ''
-
-        filename = os.path.join(directory, "wininst-%s%s.exe" % (bv, sfix))
-        try:
-            f = open(filename, "rb")
-        except IOError as e:
-            raise DistutilsFileError(str(e) + ', %s not included in the Debian packages.' % filename)
-        try:
-            return f.read()
-        finally:
-            f.close()
diff --git a/Lib/distutils/command/build.py b/Lib/distutils/command/build.py
deleted file mode 100644
index c6f52e61e1..0000000000
--- a/Lib/distutils/command/build.py
+++ /dev/null
@@ -1,157 +0,0 @@
-"""distutils.command.build
-
-Implements the Distutils 'build' command."""
-
-import sys, os
-from distutils.core import Command
-from distutils.errors import DistutilsOptionError
-from distutils.util import get_platform
-
-
-def show_compilers():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build(Command):
-
-    description = "build everything needed to install"
-
-    user_options = [
-        ('build-base=', 'b',
-         "base directory for build library"),
-        ('build-purelib=', None,
-         "build directory for platform-neutral distributions"),
-        ('build-platlib=', None,
-         "build directory for platform-specific distributions"),
-        ('build-lib=', None,
-         "build directory for all distribution (defaults to either " +
-         "build-purelib or build-platlib"),
-        ('build-scripts=', None,
-         "build directory for scripts"),
-        ('build-temp=', 't',
-         "temporary build directory"),
-        ('plat-name=', 'p',
-         "platform name to build for, if supported "
-         "(default: %s)" % get_platform()),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ('parallel=', 'j',
-         "number of parallel build jobs"),
-        ('debug', 'g',
-         "compile extensions and libraries with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('executable=', 'e',
-         "specify final destination interpreter path (build.py)"),
-        ]
-
-    boolean_options = ['debug', 'force']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.build_base = 'build'
-        # these are decided only after 'build_base' has its final value
-        # (unless overridden by the user or client)
-        self.build_purelib = None
-        self.build_platlib = None
-        self.build_lib = None
-        self.build_temp = None
-        self.build_scripts = None
-        self.compiler = None
-        self.plat_name = None
-        self.debug = None
-        self.force = 0
-        self.executable = None
-        self.parallel = None
-
-    def finalize_options(self):
-        if self.plat_name is None:
-            self.plat_name = get_platform()
-        else:
-            # plat-name only supported for windows (other platforms are
-            # supported via ./configure flags, if at all).  Avoid misleading
-            # other platforms.
-            if os.name != 'nt':
-                raise DistutilsOptionError(
-                            "--plat-name only supported on Windows (try "
-                            "using './configure --help' on your platform)")
-
-        plat_specifier = ".%s-%d.%d" % (self.plat_name, *sys.version_info[:2])
-
-        # Make it so Python 2.x and Python 2.x with --with-pydebug don't
-        # share the same build directories. Doing so confuses the build
-        # process for C modules
-        if hasattr(sys, 'gettotalrefcount'):
-            plat_specifier += '-pydebug'
-
-        # 'build_purelib' and 'build_platlib' just default to 'lib' and
-        # 'lib.<plat>' under the base build directory.  We only use one of
-        # them for a given distribution, though --
-        if self.build_purelib is None:
-            self.build_purelib = os.path.join(self.build_base, 'lib')
-        if self.build_platlib is None:
-            self.build_platlib = os.path.join(self.build_base,
-                                              'lib' + plat_specifier)
-
-        # 'build_lib' is the actual directory that we will use for this
-        # particular module distribution -- if user didn't supply it, pick
-        # one of 'build_purelib' or 'build_platlib'.
-        if self.build_lib is None:
-            if self.distribution.ext_modules:
-                self.build_lib = self.build_platlib
-            else:
-                self.build_lib = self.build_purelib
-
-        # 'build_temp' -- temporary directory for compiler turds,
-        # "build/temp.<plat>"
-        if self.build_temp is None:
-            self.build_temp = os.path.join(self.build_base,
-                                           'temp' + plat_specifier)
-        if self.build_scripts is None:
-            self.build_scripts = os.path.join(self.build_base,
-                                              'scripts-%d.%d' % sys.version_info[:2])
-
-        if self.executable is None:
-            self.executable = os.path.normpath(sys.executable)
-
-        if isinstance(self.parallel, str):
-            try:
-                self.parallel = int(self.parallel)
-            except ValueError:
-                raise DistutilsOptionError("parallel should be an integer")
-
-    def run(self):
-        # Run all relevant sub-commands.  This will be some subset of:
-        #  - build_py      - pure Python modules
-        #  - build_clib    - standalone C libraries
-        #  - build_ext     - Python extensions
-        #  - build_scripts - (Python) scripts
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-
-    # -- Predicates for the sub-command list ---------------------------
-
-    def has_pure_modules(self):
-        return self.distribution.has_pure_modules()
-
-    def has_c_libraries(self):
-        return self.distribution.has_c_libraries()
-
-    def has_ext_modules(self):
-        return self.distribution.has_ext_modules()
-
-    def has_scripts(self):
-        return self.distribution.has_scripts()
-
-
-    sub_commands = [('build_py',      has_pure_modules),
-                    ('build_clib',    has_c_libraries),
-                    ('build_ext',     has_ext_modules),
-                    ('build_scripts', has_scripts),
-                   ]
diff --git a/Lib/distutils/command/build_clib.py b/Lib/distutils/command/build_clib.py
deleted file mode 100644
index 3e20ef23cd..0000000000
--- a/Lib/distutils/command/build_clib.py
+++ /dev/null
@@ -1,209 +0,0 @@
-"""distutils.command.build_clib
-
-Implements the Distutils 'build_clib' command, to build a C/C++ library
-that is included in the module distribution and needed by an extension
-module."""
-
-
-# XXX this module has *lots* of code ripped-off quite transparently from
-# build_ext.py -- not surprisingly really, as the work required to build
-# a static library from a collection of C source files is not really all
-# that different from what's required to build a shared object file from
-# a collection of C source files.  Nevertheless, I haven't done the
-# necessary refactoring to account for the overlap in code between the
-# two modules, mainly because a number of subtle details changed in the
-# cut 'n paste.  Sigh.
-
-import os
-from distutils.core import Command
-from distutils.errors import *
-from distutils.sysconfig import customize_compiler
-from distutils import log
-
-def show_compilers():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build_clib(Command):
-
-    description = "build C/C++ libraries used by Python extensions"
-
-    user_options = [
-        ('build-clib=', 'b',
-         "directory to build C/C++ libraries to"),
-        ('build-temp=', 't',
-         "directory to put temporary build by-products"),
-        ('debug', 'g',
-         "compile with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ]
-
-    boolean_options = ['debug', 'force']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.build_clib = None
-        self.build_temp = None
-
-        # List of libraries to build
-        self.libraries = None
-
-        # Compilation options for all libraries
-        self.include_dirs = None
-        self.define = None
-        self.undef = None
-        self.debug = None
-        self.force = 0
-        self.compiler = None
-
-
-    def finalize_options(self):
-        # This might be confusing: both build-clib and build-temp default
-        # to build-temp as defined by the "build" command.  This is because
-        # I think that C libraries are really just temporary build
-        # by-products, at least from the point of view of building Python
-        # extensions -- but I want to keep my options open.
-        self.set_undefined_options('build',
-                                   ('build_temp', 'build_clib'),
-                                   ('build_temp', 'build_temp'),
-                                   ('compiler', 'compiler'),
-                                   ('debug', 'debug'),
-                                   ('force', 'force'))
-
-        self.libraries = self.distribution.libraries
-        if self.libraries:
-            self.check_library_list(self.libraries)
-
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        if isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        # XXX same as for build_ext -- what about 'self.define' and
-        # 'self.undef' ?
-
-
-    def run(self):
-        if not self.libraries:
-            return
-
-        # Yech -- this is cut 'n pasted from build_ext.py!
-        from distutils.ccompiler import new_compiler
-        self.compiler = new_compiler(compiler=self.compiler,
-                                     dry_run=self.dry_run,
-                                     force=self.force)
-        customize_compiler(self.compiler)
-
-        if self.include_dirs is not None:
-            self.compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name,value) in self.define:
-                self.compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                self.compiler.undefine_macro(macro)
-
-        self.build_libraries(self.libraries)
-
-
-    def check_library_list(self, libraries):
-        """Ensure that the list of libraries is valid.
-
-        `library` is presumably provided as a command option 'libraries'.
-        This method checks that it is a list of 2-tuples, where the tuples
-        are (library_name, build_info_dict).
-
-        Raise DistutilsSetupError if the structure is invalid anywhere;
-        just returns otherwise.
-        """
-        if not isinstance(libraries, list):
-            raise DistutilsSetupError(
-                  "'libraries' option must be a list of tuples")
-
-        for lib in libraries:
-            if not isinstance(lib, tuple) and len(lib) != 2:
-                raise DistutilsSetupError(
-                      "each element of 'libraries' must a 2-tuple")
-
-            name, build_info = lib
-
-            if not isinstance(name, str):
-                raise DistutilsSetupError(
-                      "first element of each tuple in 'libraries' "
-                      "must be a string (the library name)")
-
-            if '/' in name or (os.sep != '/' and os.sep in name):
-                raise DistutilsSetupError("bad library name '%s': "
-                       "may not contain directory separators" % lib[0])
-
-            if not isinstance(build_info, dict):
-                raise DistutilsSetupError(
-                      "second element of each tuple in 'libraries' "
-                      "must be a dictionary (build info)")
-
-
-    def get_library_names(self):
-        # Assume the library list is valid -- 'check_library_list()' is
-        # called from 'finalize_options()', so it should be!
-        if not self.libraries:
-            return None
-
-        lib_names = []
-        for (lib_name, build_info) in self.libraries:
-            lib_names.append(lib_name)
-        return lib_names
-
-
-    def get_source_files(self):
-        self.check_library_list(self.libraries)
-        filenames = []
-        for (lib_name, build_info) in self.libraries:
-            sources = build_info.get('sources')
-            if sources is None or not isinstance(sources, (list, tuple)):
-                raise DistutilsSetupError(
-                       "in 'libraries' option (library '%s'), "
-                       "'sources' must be present and must be "
-                       "a list of source filenames" % lib_name)
-
-            filenames.extend(sources)
-        return filenames
-
-
-    def build_libraries(self, libraries):
-        for (lib_name, build_info) in libraries:
-            sources = build_info.get('sources')
-            if sources is None or not isinstance(sources, (list, tuple)):
-                raise DistutilsSetupError(
-                       "in 'libraries' option (library '%s'), "
-                       "'sources' must be present and must be "
-                       "a list of source filenames" % lib_name)
-            sources = list(sources)
-
-            log.info("building '%s' library", lib_name)
-
-            # First, compile the source code to object files in the library
-            # directory.  (This should probably change to putting object
-            # files in a temporary build directory.)
-            macros = build_info.get('macros')
-            include_dirs = build_info.get('include_dirs')
-            objects = self.compiler.compile(sources,
-                                            output_dir=self.build_temp,
-                                            macros=macros,
-                                            include_dirs=include_dirs,
-                                            debug=self.debug)
-
-            # Now "link" the object files together into a static library.
-            # (On Unix at least, this isn't really linking -- it just
-            # builds an archive.  Whatever.)
-            self.compiler.create_static_lib(objects, lib_name,
-                                            output_dir=self.build_clib,
-                                            debug=self.debug)
diff --git a/Lib/distutils/command/build_ext.py b/Lib/distutils/command/build_ext.py
deleted file mode 100644
index acf2fc5484..0000000000
--- a/Lib/distutils/command/build_ext.py
+++ /dev/null
@@ -1,755 +0,0 @@
-"""distutils.command.build_ext
-
-Implements the Distutils 'build_ext' command, for building extension
-modules (currently limited to C extensions, should accommodate C++
-extensions ASAP)."""
-
-import contextlib
-import os
-import re
-import sys
-from distutils.core import Command
-from distutils.errors import *
-from distutils.sysconfig import customize_compiler, get_python_version
-from distutils.sysconfig import get_config_h_filename
-from distutils.dep_util import newer_group
-from distutils.extension import Extension
-from distutils.util import get_platform
-from distutils import log
-
-from site import USER_BASE
-
-# An extension name is just a dot-separated list of Python NAMEs (ie.
-# the same as a fully-qualified module name).
-extension_name_re = re.compile \
-    (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')
-
-
-def show_compilers ():
-    from distutils.ccompiler import show_compilers
-    show_compilers()
-
-
-class build_ext(Command):
-
-    description = "build C/C++ extensions (compile/link to build directory)"
-
-    # XXX thoughts on how to deal with complex command-line options like
-    # these, i.e. how to make it so fancy_getopt can suck them off the
-    # command line and make it look like setup.py defined the appropriate
-    # lists of tuples of what-have-you.
-    #   - each command needs a callback to process its command-line options
-    #   - Command.__init__() needs access to its share of the whole
-    #     command line (must ultimately come from
-    #     Distribution.parse_command_line())
-    #   - it then calls the current command class' option-parsing
-    #     callback to deal with weird options like -D, which have to
-    #     parse the option text and churn out some custom data
-    #     structure
-    #   - that data structure (in this case, a list of 2-tuples)
-    #     will then be present in the command object by the time
-    #     we get to finalize_options() (i.e. the constructor
-    #     takes care of both command-line and client options
-    #     in between initialize_options() and finalize_options())
-
-    sep_by = " (separated by '%s')" % os.pathsep
-    user_options = [
-        ('build-lib=', 'b',
-         "directory for compiled extension modules"),
-        ('build-temp=', 't',
-         "directory for temporary files (build by-products)"),
-        ('plat-name=', 'p',
-         "platform name to cross-compile for, if supported "
-         "(default: %s)" % get_platform()),
-        ('inplace', 'i',
-         "ignore build-lib and put compiled extensions into the source " +
-         "directory alongside your pure Python modules"),
-        ('include-dirs=', 'I',
-         "list of directories to search for header files" + sep_by),
-        ('define=', 'D',
-         "C preprocessor macros to define"),
-        ('undef=', 'U',
-         "C preprocessor macros to undefine"),
-        ('libraries=', 'l',
-         "external C libraries to link with"),
-        ('library-dirs=', 'L',
-         "directories to search for external C libraries" + sep_by),
-        ('rpath=', 'R',
-         "directories to search for shared C libraries at runtime"),
-        ('link-objects=', 'O',
-         "extra explicit link objects to include in the link"),
-        ('debug', 'g',
-         "compile/link with debugging information"),
-        ('force', 'f',
-         "forcibly build everything (ignore file timestamps)"),
-        ('compiler=', 'c',
-         "specify the compiler type"),
-        ('parallel=', 'j',
-         "number of parallel build jobs"),
-        ('swig-cpp', None,
-         "make SWIG create C++ files (default is C)"),
-        ('swig-opts=', None,
-         "list of SWIG command line options"),
-        ('swig=', None,
-         "path to the SWIG executable"),
-        ('user', None,
-         "add user include, library and rpath")
-        ]
-
-    boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']
-
-    help_options = [
-        ('help-compiler', None,
-         "list available compilers", show_compilers),
-        ]
-
-    def initialize_options(self):
-        self.extensions = None
-        self.build_lib = None
-        self.plat_name = None
-        self.build_temp = None
-        self.inplace = 0
-        self.package = None
-
-        self.include_dirs = None
-        self.define = None
-        self.undef = None
-        self.libraries = None
-        self.library_dirs = None
-        self.rpath = None
-        self.link_objects = None
-        self.debug = None
-        self.force = None
-        self.compiler = None
-        self.swig = None
-        self.swig_cpp = None
-        self.swig_opts = None
-        self.user = None
-        self.parallel = None
-
-    def finalize_options(self):
-        from distutils import sysconfig
-
-        self.set_undefined_options('build',
-                                   ('build_lib', 'build_lib'),
-                                   ('build_temp', 'build_temp'),
-                                   ('compiler', 'compiler'),
-                                   ('debug', 'debug'),
-                                   ('force', 'force'),
-                                   ('parallel', 'parallel'),
-                                   ('plat_name', 'plat_name'),
-                                   )
-
-        if self.package is None:
-            self.package = self.distribution.ext_package
-
-        self.extensions = self.distribution.ext_modules
-
-        # Make sure Python's include directories (for Python.h, pyconfig.h,
-        # etc.) are in the include search path.
-        py_include = sysconfig.get_python_inc()
-        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        if isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        # If in a virtualenv, add its include directory
-        # Issue 16116
-        if sys.exec_prefix != sys.base_exec_prefix:
-            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))
-
-        # Put the Python "system" include dir at the end, so that
-        # any local include dirs take precedence.
-        self.include_dirs.append(py_include)
-        if plat_py_include != py_include:
-            self.include_dirs.append(plat_py_include)
-
-        self.ensure_string_list('libraries')
-        self.ensure_string_list('link_objects')
-
-        # Life is easier if we're not forever checking for None, so
-        # simplify these options to empty lists if unset
-        if self.libraries is None:
-            self.libraries = []
-        if self.library_dirs is None:
-            self.library_dirs = []
-        elif isinstance(self.library_dirs, str):
-            self.library_dirs = self.library_dirs.split(os.pathsep)
-
-        if self.rpath is None:
-            self.rpath = []
-        elif isinstance(self.rpath, str):
-            self.rpath = self.rpath.split(os.pathsep)
-
-        # for extensions under windows use different directories
-        # for Release and Debug builds.
-        # also Python's library directory must be appended to library_dirs
-        if os.name == 'nt':
-            # the 'libs' directory is for binary installs - we assume that
-            # must be the *native* platform.  But we don't really support
-            # cross-compiling via a binary install anyway, so we let it go.
-            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
-            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
-                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
-            if self.debug:
-                self.build_temp = os.path.join(self.build_temp, "Debug")
-            else:
-                self.build_temp = os.path.join(self.build_temp, "Release")
-
-            # Append the source distribution include and library directories,
-            # this allows distutils on windows to work in the source tree
-            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
-            _sys_home = getattr(sys, '_home', None)
-            if _sys_home:
-                self.library_dirs.append(_sys_home)
-
-            # Use the .lib files for the correct architecture
-            if self.plat_name == 'win32':
-                suffix = 'win32'
-            else:
-                # win-amd64 or win-ia64
-                suffix = self.plat_name[4:]
-            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
-            if suffix:
-                new_lib = os.path.join(new_lib, suffix)
-            self.library_dirs.append(new_lib)
-
-        # for extensions under Cygwin and AtheOS Python's library directory must be
-        # appended to library_dirs
-        if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
-            if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
-                # building third party extensions
-                self.library_dirs.append(os.path.join(sys.prefix, "lib",
-                                                      "python" + get_python_version(),
-                                                      "config"))
-            else:
-                # building python standard extensions
-                self.library_dirs.append('.')
-
-        # For building extensions with a shared Python library,
-        # Python's library directory must be appended to library_dirs
-        # See Issues: #1600860, #4366
-        if False and (sysconfig.get_config_var('Py_ENABLE_SHARED')):
-            if not sysconfig.python_build:
-                # building third party extensions
-                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
-            else:
-                # building python standard extensions
-                self.library_dirs.append('.')
-
-        # The argument parsing will result in self.define being a string, but
-        # it has to be a list of 2-tuples.  All the preprocessor symbols
-        # specified by the 'define' option will be set to '1'.  Multiple
-        # symbols can be separated with commas.
-
-        if self.define:
-            defines = self.define.split(',')
-            self.define = [(symbol, '1') for symbol in defines]
-
-        # The option for macros to undefine is also a string from the
-        # option parsing, but has to be a list.  Multiple symbols can also
-        # be separated with commas here.
-        if self.undef:
-            self.undef = self.undef.split(',')
-
-        if self.swig_opts is None:
-            self.swig_opts = []
-        else:
-            self.swig_opts = self.swig_opts.split(' ')
-
-        # Finally add the user include and library directories if requested
-        if self.user:
-            user_include = os.path.join(USER_BASE, "include")
-            user_lib = os.path.join(USER_BASE, "lib")
-            if os.path.isdir(user_include):
-                self.include_dirs.append(user_include)
-            if os.path.isdir(user_lib):
-                self.library_dirs.append(user_lib)
-                self.rpath.append(user_lib)
-
-        if isinstance(self.parallel, str):
-            try:
-                self.parallel = int(self.parallel)
-            except ValueError:
-                raise DistutilsOptionError("parallel should be an integer")
-
-    def run(self):
-        from distutils.ccompiler import new_compiler
-
-        # 'self.extensions', as supplied by setup.py, is a list of
-        # Extension instances.  See the documentation for Extension (in
-        # distutils.extension) for details.
-        #
-        # For backwards compatibility with Distutils 0.8.2 and earlier, we
-        # also allow the 'extensions' list to be a list of tuples:
-        #    (ext_name, build_info)
-        # where build_info is a dictionary containing everything that
-        # Extension instances do except the name, with a few things being
-        # differently named.  We convert these 2-tuples to Extension
-        # instances as needed.
-
-        if not self.extensions:
-            return
-
-        # If we were asked to build any C/C++ libraries, make sure that the
-        # directory where we put them is in the library search path for
-        # linking extensions.
-        if self.distribution.has_c_libraries():
-            build_clib = self.get_finalized_command('build_clib')
-            self.libraries.extend(build_clib.get_library_names() or [])
-            self.library_dirs.append(build_clib.build_clib)
-
-        # Setup the CCompiler object that we'll use to do all the
-        # compiling and linking
-        self.compiler = new_compiler(compiler=self.compiler,
-                                     verbose=self.verbose,
-                                     dry_run=self.dry_run,
-                                     force=self.force)
-        customize_compiler(self.compiler)
-        # If we are cross-compiling, init the compiler now (if we are not
-        # cross-compiling, init would not hurt, but people may rely on
-        # late initialization of compiler even if they shouldn't...)
-        if os.name == 'nt' and self.plat_name != get_platform():
-            self.compiler.initialize(self.plat_name)
-
-        # And make sure that any compile/link-related options (which might
-        # come from the command-line or from the setup script) are set in
-        # that CCompiler object -- that way, they automatically apply to
-        # all compiling and linking done here.
-        if self.include_dirs is not None:
-            self.compiler.set_include_dirs(self.include_dirs)
-        if self.define is not None:
-            # 'define' option is a list of (name,value) tuples
-            for (name, value) in self.define:
-                self.compiler.define_macro(name, value)
-        if self.undef is not None:
-            for macro in self.undef:
-                self.compiler.undefine_macro(macro)
-        if self.libraries is not None:
-            self.compiler.set_libraries(self.libraries)
-        if self.library_dirs is not None:
-            self.compiler.set_library_dirs(self.library_dirs)
-        if self.rpath is not None:
-            self.compiler.set_runtime_library_dirs(self.rpath)
-        if self.link_objects is not None:
-            self.compiler.set_link_objects(self.link_objects)
-
-        # Now actually compile and link everything.
-        self.build_extensions()
-
-    def check_extensions_list(self, extensions):
-        """Ensure that the list of extensions (presumably provided as a
-        command option 'extensions') is valid, i.e. it is a list of
-        Extension objects.  We also support the old-style list of 2-tuples,
-        where the tuples are (ext_name, build_info), which are converted to
-        Extension instances here.
-
-        Raise DistutilsSetupError if the structure is invalid anywhere;
-        just returns otherwise.
-        """
-        if not isinstance(extensions, list):
-            raise DistutilsSetupError(
-                  "'ext_modules' option must be a list of Extension instances")
-
-        for i, ext in enumerate(extensions):
-            if isinstance(ext, Extension):
-                continue                # OK! (assume type-checking done
-                                        # by Extension constructor)
-
-            if not isinstance(ext, tuple) or len(ext) != 2:
-                raise DistutilsSetupError(
-                       "each element of 'ext_modules' option must be an "
-                       "Extension instance or 2-tuple")
-
-            ext_name, build_info = ext
-
-            log.warn("old-style (ext_name, build_info) tuple found in "
-                     "ext_modules for extension '%s' "
-                     "-- please convert to Extension instance", ext_name)
-
-            if not (isinstance(ext_name, str) and
-                    extension_name_re.match(ext_name)):
-                raise DistutilsSetupError(
-                       "first element of each tuple in 'ext_modules' "
-                       "must be the extension name (a string)")
-
-            if not isinstance(build_info, dict):
-                raise DistutilsSetupError(
-                       "second element of each tuple in 'ext_modules' "
-                       "must be a dictionary (build info)")
-
-            # OK, the (ext_name, build_info) dict is type-safe: convert it
-            # to an Extension instance.
-            ext = Extension(ext_name, build_info['sources'])
-
-            # Easy stuff: one-to-one mapping from dict elements to
-            # instance attributes.
-            for key in ('include_dirs', 'library_dirs', 'libraries',
-                        'extra_objects', 'extra_compile_args',
-                        'extra_link_args'):
-                val = build_info.get(key)
-                if val is not None:
-                    setattr(ext, key, val)
-
-            # Medium-easy stuff: same syntax/semantics, different names.
-            ext.runtime_library_dirs = build_info.get('rpath')
-            if 'def_file' in build_info:
-                log.warn("'def_file' element of build info dict "
-                         "no longer supported")
-
-            # Non-trivial stuff: 'macros' split into 'define_macros'
-            # and 'undef_macros'.
-            macros = build_info.get('macros')
-            if macros:
-                ext.define_macros = []
-                ext.undef_macros = []
-                for macro in macros:
-                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
-                        raise DistutilsSetupError(
-                              "'macros' element of build info dict "
-                              "must be 1- or 2-tuple")
-                    if len(macro) == 1:
-                        ext.undef_macros.append(macro[0])
-                    elif len(macro) == 2:
-                        ext.define_macros.append(macro)
-
-            extensions[i] = ext
-
-    def get_source_files(self):
-        self.check_extensions_list(self.extensions)
-        filenames = []
-
-        # Wouldn't it be neat if we knew the names of header files too...
-        for ext in self.extensions:
-            filenames.extend(ext.sources)
-        return filenames
-
-    def get_outputs(self):
-        # Sanity check the 'extensions' list -- can't assume this is being
-        # done in the same run as a 'build_extensions()' call (in fact, we
-        # can probably assume that it *isn't*!).
-        self.check_extensions_list(self.extensions)
-
-        # And build the list of output (built) filenames.  Note that this
-        # ignores the 'inplace' flag, and assumes everything goes in the
-        # "build" tree.
-        outputs = []
-        for ext in self.extensions:
-            outputs.append(self.get_ext_fullpath(ext.name))
-        return outputs
-
-    def build_extensions(self):
-        # First, sanity-check the 'extensions' list
-        self.check_extensions_list(self.extensions)
-        if self.parallel:
-            self._build_extensions_parallel()
-        else:
-            self._build_extensions_serial()
-
-    def _build_extensions_parallel(self):
-        workers = self.parallel
-        if self.parallel is True:
-            workers = os.cpu_count()  # may return None
-        try:
-            from concurrent.futures import ThreadPoolExecutor
-        except ImportError:
-            workers = None
-
-        if workers is None:
-            self._build_extensions_serial()
-            return
-
-        with ThreadPoolExecutor(max_workers=workers) as executor:
-            futures = [executor.submit(self.build_extension, ext)
-                       for ext in self.extensions]
-            for ext, fut in zip(self.extensions, futures):
-                with self._filter_build_errors(ext):
-                    fut.result()
-
-    def _build_extensions_serial(self):
-        for ext in self.extensions:
-            with self._filter_build_errors(ext):
-                self.build_extension(ext)
-
-    @contextlib.contextmanager
-    def _filter_build_errors(self, ext):
-        try:
-            yield
-        except (CCompilerError, DistutilsError, CompileError) as e:
-            if not ext.optional:
-                raise
-            self.warn('building extension "%s" failed: %s' %
-                      (ext.name, e))
-
-    def build_extension(self, ext):
-        sources = ext.sources
-        if sources is None or not isinstance(sources, (list, tuple)):
-            raise DistutilsSetupError(
-                  "in 'ext_modules' option (extension '%s'), "
-                  "'sources' must be present and must be "
-                  "a list of source filenames" % ext.name)
-        sources = list(sources)
-
-        ext_path = self.get_ext_fullpath(ext.name)
-        depends = sources + ext.depends
-        if not (self.force or newer_group(depends, ext_path, 'newer')):
-            log.debug("skipping '%s' extension (up-to-date)", ext.name)
-            return
-        else:
-            log.info("building '%s' extension", ext.name)
-
-        # First, scan the sources for SWIG definition files (.i), run
-        # SWIG on 'em to create .c files, and modify the sources list
-        # accordingly.
-        sources = self.swig_sources(sources, ext)
-
-        # Next, compile the source code to object files.
-
-        # XXX not honouring 'define_macros' or 'undef_macros' -- the
-        # CCompiler API needs to change to accommodate this, and I
-        # want to do one thing at a time!
-
-        # Two possible sources for extra compiler arguments:
-        #   - 'extra_compile_args' in Extension object
-        #   - CFLAGS environment variable (not particularly
-        #     elegant, but people seem to expect it and I
-        #     guess it's useful)
-        # The environment variable should take precedence, and
-        # any sensible compiler will give precedence to later
-        # command line args.  Hence we combine them in order:
-        extra_args = ext.extra_compile_args or []
-
-        macros = ext.define_macros[:]
-        for undef in ext.undef_macros:
-            macros.append((undef,))
-
-        objects = self.compiler.compile(sources,
-                                         output_dir=self.build_temp,
-                                         macros=macros,
-                                         include_dirs=ext.include_dirs,
-                                         debug=self.debug,
-                                         extra_postargs=extra_args,
-                                         depends=ext.depends)
-
-        # XXX outdated variable, kept here in case third-part code
-        # needs it.
-        self._built_objects = objects[:]
-
-        # Now link the object files together into a "shared object" --
-        # of course, first we have to figure out all the other things
-        # that go into the mix.
-        if ext.extra_objects:
-            objects.extend(ext.extra_objects)
-        extra_args = ext.extra_link_args or []
-
-        # Detect target language, if not provided
-        language = ext.language or self.compiler.detect_language(sources)
-
-        self.compiler.link_shared_object(
-            objects, ext_path,
-            libraries=self.get_libraries(ext),
-            library_dirs=ext.library_dirs,
-            runtime_library_dirs=ext.runtime_library_dirs,
-            extra_postargs=extra_args,
-            export_symbols=self.get_export_symbols(ext),
-            debug=self.debug,
-            build_temp=self.build_temp,
-            target_lang=language)
-
-    def swig_sources(self, sources, extension):
-        """Walk the list of source files in 'sources', looking for SWIG
-        interface (.i) files.  Run SWIG on all that are found, and
-        return a modified 'sources' list with SWIG source files replaced
-        by the generated C (or C++) files.
-        """
-        new_sources = []
-        swig_sources = []
-        swig_targets = {}
-
-        # XXX this drops generated C/C++ files into the source tree, which
-        # is fine for developers who want to distribute the generated
-        # source -- but there should be an option to put SWIG output in
-        # the temp dir.
-
-        if self.swig_cpp:
-            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")
-
-        if self.swig_cpp or ('-c++' in self.swig_opts) or \
-           ('-c++' in extension.swig_opts):
-            target_ext = '.cpp'
-        else:
-            target_ext = '.c'
-
-        for source in sources:
-            (base, ext) = os.path.splitext(source)
-            if ext == ".i":             # SWIG interface file
-                new_sources.append(base + '_wrap' + target_ext)
-                swig_sources.append(source)
-                swig_targets[source] = new_sources[-1]
-            else:
-                new_sources.append(source)
-
-        if not swig_sources:
-            return new_sources
-
-        swig = self.swig or self.find_swig()
-        swig_cmd = [swig, "-python"]
-        swig_cmd.extend(self.swig_opts)
-        if self.swig_cpp:
-            swig_cmd.append("-c++")
-
-        # Do not override commandline arguments
-        if not self.swig_opts:
-            for o in extension.swig_opts:
-                swig_cmd.append(o)
-
-        for source in swig_sources:
-            target = swig_targets[source]
-            log.info("swigging %s to %s", source, target)
-            self.spawn(swig_cmd + ["-o", target, source])
-
-        return new_sources
-
-    def find_swig(self):
-        """Return the name of the SWIG executable.  On Unix, this is
-        just "swig" -- it should be in the PATH.  Tries a bit harder on
-        Windows.
-        """
-        if os.name == "posix":
-            return "swig"
-        elif os.name == "nt":
-            # Look for SWIG in its standard installation directory on
-            # Windows (or so I presume!).  If we find it there, great;
-            # if not, act like Unix and assume it's in the PATH.
-            for vers in ("1.3", "1.2", "1.1"):
-                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
-                if os.path.isfile(fn):
-                    return fn
-            else:
-                return "swig.exe"
-        else:
-            raise DistutilsPlatformError(
-                  "I don't know how to find (much less run) SWIG "
-                  "on platform '%s'" % os.name)
-
-    # -- Name generators -----------------------------------------------
-    # (extension names, filenames, whatever)
-    def get_ext_fullpath(self, ext_name):
-        """Returns the path of the filename for a given extension.
-
-        The file is located in `build_lib` or directly in the package
-        (inplace option).
-        """
-        fullname = self.get_ext_fullname(ext_name)
-        modpath = fullname.split('.')
-        filename = self.get_ext_filename(modpath[-1])
-
-        if not self.inplace:
-            # no further work needed
-            # returning :
-            #   build_dir/package/path/filename
-            filename = os.path.join(*modpath[:-1]+[filename])
-            return os.path.join(self.build_lib, filename)
-
-        # the inplace option requires to find the package directory
-        # using the build_py command for that
-        package = '.'.join(modpath[0:-1])
-        build_py = self.get_finalized_command('build_py')
-        package_dir = os.path.abspath(build_py.get_package_dir(package))
-
-        # returning
-        #   package_dir/filename
-        return os.path.join(package_dir, filename)
-
-    def get_ext_fullname(self, ext_name):
-        """Returns the fullname of a given extension name.
-
-        Adds the `package.` prefix"""
-        if self.package is None:
-            return ext_name
-        else:
-            return self.package + '.' + ext_name
-
-    def get_ext_filename(self, ext_name):
-        r"""Convert the name of an extension (eg. "foo.bar") into the name
-        of the file from which it will be loaded (eg. "foo/bar.so", or
-        "foo\bar.pyd").
-        """
-        from distutils.sysconfig import get_config_var
-        ext_path = ext_name.split('.')
-        ext_suffix = get_config_var('EXT_SUFFIX')
-        return os.path.join(*ext_path) + ext_suffix
-
-    def get_export_symbols(self, ext):
-        """Return the list of symbols that a shared extension has to
-        export.  This either uses 'ext.export_symbols' or, if it's not
-        provided, "PyInit_" + module_name.  Only relevant on Windows, where
-        the .pyd file (DLL) must export the module "PyInit_" function.
-        """
-        initfunc_name = "PyInit_" + ext.name.split('.')[-1]
-        if initfunc_name not in ext.export_symbols:
-            ext.export_symbols.append(initfunc_name)
-        return ext.export_symbols
-
-    def get_libraries(self, ext):
-        """Return the list of libraries to link against when building a
-        shared extension.  On most platforms, this is just 'ext.libraries';
-        on Windows, we add the Python library (eg. python20.dll).
-        """
-        # The python library is always needed on Windows.  For MSVC, this
-        # is redundant, since the library is mentioned in a pragma in
-        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
-        # to need it mentioned explicitly, though, so that's what we do.
-        # Append '_d' to the python import library on debug builds.
-        if sys.platform == "win32":
-            from distutils._msvccompiler import MSVCCompiler
-            if not isinstance(self.compiler, MSVCCompiler):
-                template = "python%d%d"
-                if self.debug:
-                    template = template + '_d'
-                pythonlib = (template %
-                       (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-                # don't extend ext.libraries, it may be shared with other
-                # extensions, it is a reference to the original list
-                return ext.libraries + [pythonlib]
-            else:
-                return ext.libraries
-        elif sys.platform[:6] == "cygwin":
-            template = "python%d.%d"
-            pythonlib = (template %
-                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-            # don't extend ext.libraries, it may be shared with other
-            # extensions, it is a reference to the original list
-            return ext.libraries + [pythonlib]
-        elif sys.platform[:6] == "atheos":
-            from distutils import sysconfig
-
-            template = "python%d.%d"
-            pythonlib = (template %
-                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-            # Get SHLIBS from Makefile
-            extra = []
-            for lib in sysconfig.get_config_var('SHLIBS').split():
-                if lib.startswith('-l'):
-                    extra.append(lib[2:])
-                else:
-                    extra.append(lib)
-            # don't extend ext.libraries, it may be shared with other
-            # extensions, it is a reference to the original list
-            return ext.libraries + [pythonlib, "m"] + extra
-        elif sys.platform == 'darwin':
-            # Don't use the default code below
-            return ext.libraries
-        elif sys.platform[:3] == 'aix':
-            # Don't use the default code below
-            return ext.libraries
-        else:
-            from distutils import sysconfig
-            if False and sysconfig.get_config_var('Py_ENABLE_SHARED'):
-                pythonlib = 'python{}.{}{}'.format(
-                    sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff,
-                    sysconfig.get_config_var('ABIFLAGS'))
-                return ext.libraries + [pythonlib]
-            else:
-                return ext.libraries
diff --git a/Lib/distutils/command/build_py.py b/Lib/distutils/command/build_py.py
deleted file mode 100644
index cf0ca57c32..0000000000
--- a/Lib/distutils/command/build_py.py
+++ /dev/null
@@ -1,416 +0,0 @@
-"""distutils.command.build_py
-
-Implements the Distutils 'build_py' command."""
-
-import os
-import importlib.util
-import sys
-from glob import glob
-
-from distutils.core import Command
-from distutils.errors import *
-from distutils.util import convert_path, Mixin2to3
-from distutils import log
-
-class build_py (Command):
-
-    description = "\"build\" pure Python modules (copy to build directory)"
-
-    user_options = [
-        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
-        ('compile', 'c', "compile .py to .pyc"),
-        ('no-compile', None, "don't compile .py files [default]"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
-        ]
-
-    boolean_options = ['compile', 'force']
-    negative_opt = {'no-compile' : 'compile'}
-
-    def initialize_options(self):
-        self.build_lib = None
-        self.py_modules = None
-        self.package = None
-        self.package_data = None
-        self.package_dir = None
-        self.compile = 0
-        self.optimize = 0
-        self.force = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_lib', 'build_lib'),
-                                   ('force', 'force'))
-
-        # Get the distribution options that are aliases for build_py
-        # options -- list of packages and list of modules.
-        self.packages = self.distribution.packages
-        self.py_modules = self.distribution.py_modules
-        self.package_data = self.distribution.package_data
-        self.package_dir = {}
-        if self.distribution.package_dir:
-            for name, path in self.distribution.package_dir.items():
-                self.package_dir[name] = convert_path(path)
-        self.data_files = self.get_data_files()
-
-        # Ick, copied straight from install_lib.py (fancy_getopt needs a
-        # type system!  Hell, *everything* needs a type system!!!)
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                assert 0 <= self.optimize <= 2
-            except (ValueError, AssertionError):
-                raise DistutilsOptionError("optimize must be 0, 1, or 2")
-
-    def run(self):
-        # XXX copy_file by default preserves atime and mtime.  IMHO this is
-        # the right thing to do, but perhaps it should be an option -- in
-        # particular, a site administrator might want installed files to
-        # reflect the time of installation rather than the last
-        # modification time before the installed release.
-
-        # XXX copy_file by default preserves mode, which appears to be the
-        # wrong thing to do: if a file is read-only in the working
-        # directory, we want it to be installed read/write so that the next
-        # installation of the same module distribution can overwrite it
-        # without problems.  (This might be a Unix-specific issue.)  Thus
-        # we turn off 'preserve_mode' when copying to the build directory,
-        # since the build directory is supposed to be exactly what the
-        # installation will look like (ie. we preserve mode when
-        # installing).
-
-        # Two options control which modules will be installed: 'packages'
-        # and 'py_modules'.  The former lets us work with whole packages, not
-        # specifying individual modules at all; the latter is for
-        # specifying modules one-at-a-time.
-
-        if self.py_modules:
-            self.build_modules()
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        self.byte_compile(self.get_outputs(include_bytecode=0))
-
-    def get_data_files(self):
-        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
-        data = []
-        if not self.packages:
-            return data
-        for package in self.packages:
-            # Locate package source directory
-            src_dir = self.get_package_dir(package)
-
-            # Compute package build directory
-            build_dir = os.path.join(*([self.build_lib] + package.split('.')))
-
-            # Length of path to strip from found files
-            plen = 0
-            if src_dir:
-                plen = len(src_dir)+1
-
-            # Strip directory from globbed filenames
-            filenames = [
-                file[plen:] for file in self.find_data_files(package, src_dir)
-                ]
-            data.append((package, src_dir, build_dir, filenames))
-        return data
-
-    def find_data_files(self, package, src_dir):
-        """Return filenames for package's data files in 'src_dir'"""
-        globs = (self.package_data.get('', [])
-                 + self.package_data.get(package, []))
-        files = []
-        for pattern in globs:
-            # Each pattern has to be converted to a platform-specific path
-            filelist = glob(os.path.join(src_dir, convert_path(pattern)))
-            # Files that match more than one pattern are only added once
-            files.extend([fn for fn in filelist if fn not in files
-                and os.path.isfile(fn)])
-        return files
-
-    def build_package_data(self):
-        """Copy data files into build directory"""
-        lastdir = None
-        for package, src_dir, build_dir, filenames in self.data_files:
-            for filename in filenames:
-                target = os.path.join(build_dir, filename)
-                self.mkpath(os.path.dirname(target))
-                self.copy_file(os.path.join(src_dir, filename), target,
-                               preserve_mode=False)
-
-    def get_package_dir(self, package):
-        """Return the directory, relative to the top of the source
-           distribution, where package 'package' should be found
-           (at least according to the 'package_dir' option, if any)."""
-        path = package.split('.')
-
-        if not self.package_dir:
-            if path:
-                return os.path.join(*path)
-            else:
-                return ''
-        else:
-            tail = []
-            while path:
-                try:
-                    pdir = self.package_dir['.'.join(path)]
-                except KeyError:
-                    tail.insert(0, path[-1])
-                    del path[-1]
-                else:
-                    tail.insert(0, pdir)
-                    return os.path.join(*tail)
-            else:
-                # Oops, got all the way through 'path' without finding a
-                # match in package_dir.  If package_dir defines a directory
-                # for the root (nameless) package, then fallback on it;
-                # otherwise, we might as well have not consulted
-                # package_dir at all, as we just use the directory implied
-                # by 'tail' (which should be the same as the original value
-                # of 'path' at this point).
-                pdir = self.package_dir.get('')
-                if pdir is not None:
-                    tail.insert(0, pdir)
-
-                if tail:
-                    return os.path.join(*tail)
-                else:
-                    return ''
-
-    def check_package(self, package, package_dir):
-        # Empty dir name means current directory, which we can probably
-        # assume exists.  Also, os.path.exists and isdir don't know about
-        # my "empty string means current dir" convention, so we have to
-        # circumvent them.
-        if package_dir != "":
-            if not os.path.exists(package_dir):
-                raise DistutilsFileError(
-                      "package directory '%s' does not exist" % package_dir)
-            if not os.path.isdir(package_dir):
-                raise DistutilsFileError(
-                       "supposed package directory '%s' exists, "
-                       "but is not a directory" % package_dir)
-
-        # Require __init__.py for all but the "root package"
-        if package:
-            init_py = os.path.join(package_dir, "__init__.py")
-            if os.path.isfile(init_py):
-                return init_py
-            else:
-                log.warn(("package init file '%s' not found " +
-                          "(or not a regular file)"), init_py)
-
-        # Either not in a package at all (__init__.py not expected), or
-        # __init__.py doesn't exist -- so don't return the filename.
-        return None
-
-    def check_module(self, module, module_file):
-        if not os.path.isfile(module_file):
-            log.warn("file %s (for module %s) not found", module_file, module)
-            return False
-        else:
-            return True
-
-    def find_package_modules(self, package, package_dir):
-        self.check_package(package, package_dir)
-        module_files = glob(os.path.join(package_dir, "*.py"))
-        modules = []
-        setup_script = os.path.abspath(self.distribution.script_name)
-
-        for f in module_files:
-            abs_f = os.path.abspath(f)
-            if abs_f != setup_script:
-                module = os.path.splitext(os.path.basename(f))[0]
-                modules.append((package, module, f))
-            else:
-                self.debug_print("excluding %s" % setup_script)
-        return modules
-
-    def find_modules(self):
-        """Finds individually-specified Python modules, ie. those listed by
-        module name in 'self.py_modules'.  Returns a list of tuples (package,
-        module_base, filename): 'package' is a tuple of the path through
-        package-space to the module; 'module_base' is the bare (no
-        packages, no dots) module name, and 'filename' is the path to the
-        ".py" file (relative to the distribution root) that implements the
-        module.
-        """
-        # Map package names to tuples of useful info about the package:
-        #    (package_dir, checked)
-        # package_dir - the directory where we'll find source files for
-        #   this package
-        # checked - true if we have checked that the package directory
-        #   is valid (exists, contains __init__.py, ... ?)
-        packages = {}
-
-        # List of (package, module, filename) tuples to return
-        modules = []
-
-        # We treat modules-in-packages almost the same as toplevel modules,
-        # just the "package" for a toplevel is empty (either an empty
-        # string or empty list, depending on context).  Differences:
-        #   - don't check for __init__.py in directory for empty package
-        for module in self.py_modules:
-            path = module.split('.')
-            package = '.'.join(path[0:-1])
-            module_base = path[-1]
-
-            try:
-                (package_dir, checked) = packages[package]
-            except KeyError:
-                package_dir = self.get_package_dir(package)
-                checked = 0
-
-            if not checked:
-                init_py = self.check_package(package, package_dir)
-                packages[package] = (package_dir, 1)
-                if init_py:
-                    modules.append((package, "__init__", init_py))
-
-            # XXX perhaps we should also check for just .pyc files
-            # (so greedy closed-source bastards can distribute Python
-            # modules too)
-            module_file = os.path.join(package_dir, module_base + ".py")
-            if not self.check_module(module, module_file):
-                continue
-
-            modules.append((package, module_base, module_file))
-
-        return modules
-
-    def find_all_modules(self):
-        """Compute the list of all modules that will be built, whether
-        they are specified one-module-at-a-time ('self.py_modules') or
-        by whole packages ('self.packages').  Return a list of tuples
-        (package, module, module_file), just like 'find_modules()' and
-        'find_package_modules()' do."""
-        modules = []
-        if self.py_modules:
-            modules.extend(self.find_modules())
-        if self.packages:
-            for package in self.packages:
-                package_dir = self.get_package_dir(package)
-                m = self.find_package_modules(package, package_dir)
-                modules.extend(m)
-        return modules
-
-    def get_source_files(self):
-        return [module[-1] for module in self.find_all_modules()]
-
-    def get_module_outfile(self, build_dir, package, module):
-        outfile_path = [build_dir] + list(package) + [module + ".py"]
-        return os.path.join(*outfile_path)
-
-    def get_outputs(self, include_bytecode=1):
-        modules = self.find_all_modules()
-        outputs = []
-        for (package, module, module_file) in modules:
-            package = package.split('.')
-            filename = self.get_module_outfile(self.build_lib, package, module)
-            outputs.append(filename)
-            if include_bytecode:
-                if self.compile:
-                    outputs.append(importlib.util.cache_from_source(
-                        filename, optimization=''))
-                if self.optimize > 0:
-                    outputs.append(importlib.util.cache_from_source(
-                        filename, optimization=self.optimize))
-
-        outputs += [
-            os.path.join(build_dir, filename)
-            for package, src_dir, build_dir, filenames in self.data_files
-            for filename in filenames
-            ]
-
-        return outputs
-
-    def build_module(self, module, module_file, package):
-        if isinstance(package, str):
-            package = package.split('.')
-        elif not isinstance(package, (list, tuple)):
-            raise TypeError(
-                  "'package' must be a string (dot-separated), list, or tuple")
-
-        # Now put the module source file into the "build" area -- this is
-        # easy, we just copy it somewhere under self.build_lib (the build
-        # directory for Python source).
-        outfile = self.get_module_outfile(self.build_lib, package, module)
-        dir = os.path.dirname(outfile)
-        self.mkpath(dir)
-        return self.copy_file(module_file, outfile, preserve_mode=0)
-
-    def build_modules(self):
-        modules = self.find_modules()
-        for (package, module, module_file) in modules:
-            # Now "build" the module -- ie. copy the source file to
-            # self.build_lib (the build directory for Python source).
-            # (Actually, it gets copied to the directory for this package
-            # under self.build_lib.)
-            self.build_module(module, module_file, package)
-
-    def build_packages(self):
-        for package in self.packages:
-            # Get list of (package, module, module_file) tuples based on
-            # scanning the package directory.  'package' is only included
-            # in the tuple so that 'find_modules()' and
-            # 'find_package_tuples()' have a consistent interface; it's
-            # ignored here (apart from a sanity check).  Also, 'module' is
-            # the *unqualified* module name (ie. no dots, no package -- we
-            # already know its package!), and 'module_file' is the path to
-            # the .py file, relative to the current directory
-            # (ie. including 'package_dir').
-            package_dir = self.get_package_dir(package)
-            modules = self.find_package_modules(package, package_dir)
-
-            # Now loop over the modules we found, "building" each one (just
-            # copy it to self.build_lib).
-            for (package_, module, module_file) in modules:
-                assert package == package_
-                self.build_module(module, module_file, package)
-
-    def byte_compile(self, files):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-        prefix = self.build_lib
-        if prefix[-1] != os.sep:
-            prefix = prefix + os.sep
-
-        # XXX this code is essentially the same as the 'byte_compile()
-        # method of the "install_lib" command, except for the determination
-        # of the 'prefix' string.  Hmmm.
-        if self.compile:
-            byte_compile(files, optimize=0,
-                         force=self.force, prefix=prefix, dry_run=self.dry_run)
-        if self.optimize > 0:
-            byte_compile(files, optimize=self.optimize,
-                         force=self.force, prefix=prefix, dry_run=self.dry_run)
-
-class build_py_2to3(build_py, Mixin2to3):
-    def run(self):
-        self.updated_files = []
-
-        # Base class code
-        if self.py_modules:
-            self.build_modules()
-        if self.packages:
-            self.build_packages()
-            self.build_package_data()
-
-        # 2to3
-        self.run_2to3(self.updated_files)
-
-        # Remaining base class code
-        self.byte_compile(self.get_outputs(include_bytecode=0))
-
-    def build_module(self, module, module_file, package):
-        res = build_py.build_module(self, module, module_file, package)
-        if res[1]:
-            # file was copied
-            self.updated_files.append(res[0])
-        return res
diff --git a/Lib/distutils/command/build_scripts.py b/Lib/distutils/command/build_scripts.py
deleted file mode 100644
index ccc70e6465..0000000000
--- a/Lib/distutils/command/build_scripts.py
+++ /dev/null
@@ -1,160 +0,0 @@
-"""distutils.command.build_scripts
-
-Implements the Distutils 'build_scripts' command."""
-
-import os, re
-from stat import ST_MODE
-from distutils import sysconfig
-from distutils.core import Command
-from distutils.dep_util import newer
-from distutils.util import convert_path, Mixin2to3
-from distutils import log
-import tokenize
-
-# check if Python is called on the first line with this expression
-first_line_re = re.compile(b'^#!.*python[0-9.]*([ \t].*)?$')
-
-class build_scripts(Command):
-
-    description = "\"build\" scripts (copy and fixup #! line)"
-
-    user_options = [
-        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
-        ('force', 'f', "forcibly build everything (ignore file timestamps"),
-        ('executable=', 'e', "specify final destination interpreter path"),
-        ]
-
-    boolean_options = ['force']
-
-
-    def initialize_options(self):
-        self.build_dir = None
-        self.scripts = None
-        self.force = None
-        self.executable = None
-        self.outfiles = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_scripts', 'build_dir'),
-                                   ('force', 'force'),
-                                   ('executable', 'executable'))
-        self.scripts = self.distribution.scripts
-
-    def get_source_files(self):
-        return self.scripts
-
-    def run(self):
-        if not self.scripts:
-            return
-        self.copy_scripts()
-
-
-    def copy_scripts(self):
-        r"""Copy each script listed in 'self.scripts'; if it's marked as a
-        Python script in the Unix way (first line matches 'first_line_re',
-        ie. starts with "\#!" and contains "python"), then adjust the first
-        line to refer to the current Python interpreter as we copy.
-        """
-        self.mkpath(self.build_dir)
-        outfiles = []
-        updated_files = []
-        for script in self.scripts:
-            adjust = False
-            script = convert_path(script)
-            outfile = os.path.join(self.build_dir, os.path.basename(script))
-            outfiles.append(outfile)
-
-            if not self.force and not newer(script, outfile):
-                log.debug("not copying %s (up-to-date)", script)
-                continue
-
-            # Always open the file, but ignore failures in dry-run mode --
-            # that way, we'll get accurate feedback if we can read the
-            # script.
-            try:
-                f = open(script, "rb")
-            except OSError:
-                if not self.dry_run:
-                    raise
-                f = None
-            else:
-                encoding, lines = tokenize.detect_encoding(f.readline)
-                f.seek(0)
-                first_line = f.readline()
-                if not first_line:
-                    self.warn("%s is an empty file (skipping)" % script)
-                    continue
-
-                match = first_line_re.match(first_line)
-                if match:
-                    adjust = True
-                    post_interp = match.group(1) or b''
-
-            if adjust:
-                log.info("copying and adjusting %s -> %s", script,
-                         self.build_dir)
-                updated_files.append(outfile)
-                if not self.dry_run:
-                    if not sysconfig.python_build:
-                        executable = self.executable
-                    else:
-                        executable = os.path.join(
-                            sysconfig.get_config_var("BINDIR"),
-                           "python%s%s" % (sysconfig.get_config_var("VERSION"),
-                                           sysconfig.get_config_var("EXE")))
-                    executable = os.fsencode(executable)
-                    shebang = b"#!" + executable + post_interp + b"\n"
-                    # Python parser starts to read a script using UTF-8 until
-                    # it gets a #coding:xxx cookie. The shebang has to be the
-                    # first line of a file, the #coding:xxx cookie cannot be
-                    # written before. So the shebang has to be decodable from
-                    # UTF-8.
-                    try:
-                        shebang.decode('utf-8')
-                    except UnicodeDecodeError:
-                        raise ValueError(
-                            "The shebang ({!r}) is not decodable "
-                            "from utf-8".format(shebang))
-                    # If the script is encoded to a custom encoding (use a
-                    # #coding:xxx cookie), the shebang has to be decodable from
-                    # the script encoding too.
-                    try:
-                        shebang.decode(encoding)
-                    except UnicodeDecodeError:
-                        raise ValueError(
-                            "The shebang ({!r}) is not decodable "
-                            "from the script encoding ({})"
-                            .format(shebang, encoding))
-                    with open(outfile, "wb") as outf:
-                        outf.write(shebang)
-                        outf.writelines(f.readlines())
-                if f:
-                    f.close()
-            else:
-                if f:
-                    f.close()
-                updated_files.append(outfile)
-                self.copy_file(script, outfile)
-
-        if os.name == 'posix':
-            for file in outfiles:
-                if self.dry_run:
-                    log.info("changing mode of %s", file)
-                else:
-                    oldmode = os.stat(file)[ST_MODE] & 0o7777
-                    newmode = (oldmode | 0o555) & 0o7777
-                    if newmode != oldmode:
-                        log.info("changing mode of %s from %o to %o",
-                                 file, oldmode, newmode)
-                        os.chmod(file, newmode)
-        # XXX should we modify self.outfiles?
-        return outfiles, updated_files
-
-class build_scripts_2to3(build_scripts, Mixin2to3):
-
-    def copy_scripts(self):
-        outfiles, updated_files = build_scripts.copy_scripts(self)
-        if not self.dry_run:
-            self.run_2to3(updated_files)
-        return outfiles, updated_files
diff --git a/Lib/distutils/command/check.py b/Lib/distutils/command/check.py
deleted file mode 100644
index 7ebe707cff..0000000000
--- a/Lib/distutils/command/check.py
+++ /dev/null
@@ -1,145 +0,0 @@
-"""distutils.command.check
-
-Implements the Distutils 'check' command.
-"""
-from distutils.core import Command
-from distutils.errors import DistutilsSetupError
-
-try:
-    # docutils is installed
-    from docutils.utils import Reporter
-    from docutils.parsers.rst import Parser
-    from docutils import frontend
-    from docutils import nodes
-    from io import StringIO
-
-    class SilentReporter(Reporter):
-
-        def __init__(self, source, report_level, halt_level, stream=None,
-                     debug=0, encoding='ascii', error_handler='replace'):
-            self.messages = []
-            Reporter.__init__(self, source, report_level, halt_level, stream,
-                              debug, encoding, error_handler)
-
-        def system_message(self, level, message, *children, **kwargs):
-            self.messages.append((level, message, children, kwargs))
-            return nodes.system_message(message, level=level,
-                                        type=self.levels[level],
-                                        *children, **kwargs)
-
-    HAS_DOCUTILS = True
-except Exception:
-    # Catch all exceptions because exceptions besides ImportError probably
-    # indicate that docutils is not ported to Py3k.
-    HAS_DOCUTILS = False
-
-class check(Command):
-    """This command checks the meta-data of the package.
-    """
-    description = ("perform some checks on the package")
-    user_options = [('metadata', 'm', 'Verify meta-data'),
-                    ('restructuredtext', 'r',
-                     ('Checks if long string meta-data syntax '
-                      'are reStructuredText-compliant')),
-                    ('strict', 's',
-                     'Will exit with an error if a check fails')]
-
-    boolean_options = ['metadata', 'restructuredtext', 'strict']
-
-    def initialize_options(self):
-        """Sets default values for options."""
-        self.restructuredtext = 0
-        self.metadata = 1
-        self.strict = 0
-        self._warnings = 0
-
-    def finalize_options(self):
-        pass
-
-    def warn(self, msg):
-        """Counts the number of warnings that occurs."""
-        self._warnings += 1
-        return Command.warn(self, msg)
-
-    def run(self):
-        """Runs the command."""
-        # perform the various tests
-        if self.metadata:
-            self.check_metadata()
-        if self.restructuredtext:
-            if HAS_DOCUTILS:
-                self.check_restructuredtext()
-            elif self.strict:
-                raise DistutilsSetupError('The docutils package is needed.')
-
-        # let's raise an error in strict mode, if we have at least
-        # one warning
-        if self.strict and self._warnings > 0:
-            raise DistutilsSetupError('Please correct your package.')
-
-    def check_metadata(self):
-        """Ensures that all required elements of meta-data are supplied.
-
-        name, version, URL, (author and author_email) or
-        (maintainer and maintainer_email)).
-
-        Warns if any are missing.
-        """
-        metadata = self.distribution.metadata
-
-        missing = []
-        for attr in ('name', 'version', 'url'):
-            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
-                missing.append(attr)
-
-        if missing:
-            self.warn("missing required meta-data: %s"  % ', '.join(missing))
-        if metadata.author:
-            if not metadata.author_email:
-                self.warn("missing meta-data: if 'author' supplied, " +
-                          "'author_email' must be supplied too")
-        elif metadata.maintainer:
-            if not metadata.maintainer_email:
-                self.warn("missing meta-data: if 'maintainer' supplied, " +
-                          "'maintainer_email' must be supplied too")
-        else:
-            self.warn("missing meta-data: either (author and author_email) " +
-                      "or (maintainer and maintainer_email) " +
-                      "must be supplied")
-
-    def check_restructuredtext(self):
-        """Checks if the long string fields are reST-compliant."""
-        data = self.distribution.get_long_description()
-        for warning in self._check_rst_data(data):
-            line = warning[-1].get('line')
-            if line is None:
-                warning = warning[1]
-            else:
-                warning = '%s (line %s)' % (warning[1], line)
-            self.warn(warning)
-
-    def _check_rst_data(self, data):
-        """Returns warnings when the provided data doesn't compile."""
-        source_path = StringIO()
-        parser = Parser()
-        settings = frontend.OptionParser(components=(Parser,)).get_default_values()
-        settings.tab_width = 4
-        settings.pep_references = None
-        settings.rfc_references = None
-        reporter = SilentReporter(source_path,
-                          settings.report_level,
-                          settings.halt_level,
-                          stream=settings.warning_stream,
-                          debug=settings.debug,
-                          encoding=settings.error_encoding,
-                          error_handler=settings.error_encoding_error_handler)
-
-        document = nodes.document(settings, reporter, source=source_path)
-        document.note_source(source_path, -1)
-        try:
-            parser.parse(data, document)
-        except AttributeError as e:
-            reporter.messages.append(
-                (-1, 'Could not finish the parsing: %s.' % e, '', {}))
-
-        return reporter.messages
diff --git a/Lib/distutils/command/clean.py b/Lib/distutils/command/clean.py
deleted file mode 100644
index 0cb2701662..0000000000
--- a/Lib/distutils/command/clean.py
+++ /dev/null
@@ -1,76 +0,0 @@
-"""distutils.command.clean
-
-Implements the Distutils 'clean' command."""
-
-# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18
-
-import os
-from distutils.core import Command
-from distutils.dir_util import remove_tree
-from distutils import log
-
-class clean(Command):
-
-    description = "clean up temporary files from 'build' command"
-    user_options = [
-        ('build-base=', 'b',
-         "base build directory (default: 'build.build-base')"),
-        ('build-lib=', None,
-         "build directory for all modules (default: 'build.build-lib')"),
-        ('build-temp=', 't',
-         "temporary build directory (default: 'build.build-temp')"),
-        ('build-scripts=', None,
-         "build directory for scripts (default: 'build.build-scripts')"),
-        ('bdist-base=', None,
-         "temporary directory for built distributions"),
-        ('all', 'a',
-         "remove all build output, not just temporary by-products")
-    ]
-
-    boolean_options = ['all']
-
-    def initialize_options(self):
-        self.build_base = None
-        self.build_lib = None
-        self.build_temp = None
-        self.build_scripts = None
-        self.bdist_base = None
-        self.all = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build',
-                                   ('build_base', 'build_base'),
-                                   ('build_lib', 'build_lib'),
-                                   ('build_scripts', 'build_scripts'),
-                                   ('build_temp', 'build_temp'))
-        self.set_undefined_options('bdist',
-                                   ('bdist_base', 'bdist_base'))
-
-    def run(self):
-        # remove the build/temp.<plat> directory (unless it's already
-        # gone)
-        if os.path.exists(self.build_temp):
-            remove_tree(self.build_temp, dry_run=self.dry_run)
-        else:
-            log.debug("'%s' does not exist -- can't clean it",
-                      self.build_temp)
-
-        if self.all:
-            # remove build directories
-            for directory in (self.build_lib,
-                              self.bdist_base,
-                              self.build_scripts):
-                if os.path.exists(directory):
-                    remove_tree(directory, dry_run=self.dry_run)
-                else:
-                    log.warn("'%s' does not exist -- can't clean it",
-                             directory)
-
-        # just for the heck of it, try to remove the base build directory:
-        # we might have emptied it right now, but if not we don't care
-        if not self.dry_run:
-            try:
-                os.rmdir(self.build_base)
-                log.info("removing '%s'", self.build_base)
-            except OSError:
-                pass
diff --git a/Lib/distutils/command/command_template b/Lib/distutils/command/command_template
deleted file mode 100644
index 6106819db8..0000000000
--- a/Lib/distutils/command/command_template
+++ /dev/null
@@ -1,33 +0,0 @@
-"""distutils.command.x
-
-Implements the Distutils 'x' command.
-"""
-
-# created 2000/mm/dd, John Doe
-
-__revision__ = "$Id$"
-
-from distutils.core import Command
-
-
-class x(Command):
-
-    # Brief (40-50 characters) description of the command
-    description = ""
-
-    # List of option tuples: long name, short name (None if no short
-    # name), and help string.
-    user_options = [('', '',
-                     ""),
-                   ]
-
-    def initialize_options(self):
-        self. = None
-        self. = None
-        self. = None
-
-    def finalize_options(self):
-        if self.x is None:
-            self.x = 
-
-    def run(self):
diff --git a/Lib/distutils/command/config.py b/Lib/distutils/command/config.py
deleted file mode 100644
index 4ae153d194..0000000000
--- a/Lib/distutils/command/config.py
+++ /dev/null
@@ -1,347 +0,0 @@
-"""distutils.command.config
-
-Implements the Distutils 'config' command, a (mostly) empty command class
-that exists mainly to be sub-classed by specific module distributions and
-applications.  The idea is that while every "config" command is different,
-at least they're all named the same, and users always see "config" in the
-list of standard commands.  Also, this is a good place to put common
-configure-like tasks: "try to compile this C code", or "figure out where
-this header file lives".
-"""
-
-import os, re
-
-from distutils.core import Command
-from distutils.errors import DistutilsExecError
-from distutils.sysconfig import customize_compiler
-from distutils import log
-
-LANG_EXT = {"c": ".c", "c++": ".cxx"}
-
-class config(Command):
-
-    description = "prepare to build"
-
-    user_options = [
-        ('compiler=', None,
-         "specify the compiler type"),
-        ('cc=', None,
-         "specify the compiler executable"),
-        ('include-dirs=', 'I',
-         "list of directories to search for header files"),
-        ('define=', 'D',
-         "C preprocessor macros to define"),
-        ('undef=', 'U',
-         "C preprocessor macros to undefine"),
-        ('libraries=', 'l',
-         "external C libraries to link with"),
-        ('library-dirs=', 'L',
-         "directories to search for external C libraries"),
-
-        ('noisy', None,
-         "show every action (compile, link, run, ...) taken"),
-        ('dump-source', None,
-         "dump generated source files before attempting to compile them"),
-        ]
-
-
-    # The three standard command methods: since the "config" command
-    # does nothing by default, these are empty.
-
-    def initialize_options(self):
-        self.compiler = None
-        self.cc = None
-        self.include_dirs = None
-        self.libraries = None
-        self.library_dirs = None
-
-        # maximal output for now
-        self.noisy = 1
-        self.dump_source = 1
-
-        # list of temporary files generated along-the-way that we have
-        # to clean at some point
-        self.temp_files = []
-
-    def finalize_options(self):
-        if self.include_dirs is None:
-            self.include_dirs = self.distribution.include_dirs or []
-        elif isinstance(self.include_dirs, str):
-            self.include_dirs = self.include_dirs.split(os.pathsep)
-
-        if self.libraries is None:
-            self.libraries = []
-        elif isinstance(self.libraries, str):
-            self.libraries = [self.libraries]
-
-        if self.library_dirs is None:
-            self.library_dirs = []
-        elif isinstance(self.library_dirs, str):
-            self.library_dirs = self.library_dirs.split(os.pathsep)
-
-    def run(self):
-        pass
-
-    # Utility methods for actual "config" commands.  The interfaces are
-    # loosely based on Autoconf macros of similar names.  Sub-classes
-    # may use these freely.
-
-    def _check_compiler(self):
-        """Check that 'self.compiler' really is a CCompiler object;
-        if not, make it one.
-        """
-        # We do this late, and only on-demand, because this is an expensive
-        # import.
-        from distutils.ccompiler import CCompiler, new_compiler
-        if not isinstance(self.compiler, CCompiler):
-            self.compiler = new_compiler(compiler=self.compiler,
-                                         dry_run=self.dry_run, force=1)
-            customize_compiler(self.compiler)
-            if self.include_dirs:
-                self.compiler.set_include_dirs(self.include_dirs)
-            if self.libraries:
-                self.compiler.set_libraries(self.libraries)
-            if self.library_dirs:
-                self.compiler.set_library_dirs(self.library_dirs)
-
-    def _gen_temp_sourcefile(self, body, headers, lang):
-        filename = "_configtest" + LANG_EXT[lang]
-        file = open(filename, "w")
-        if headers:
-            for header in headers:
-                file.write("#include <%s>\n" % header)
-            file.write("\n")
-        file.write(body)
-        if body[-1] != "\n":
-            file.write("\n")
-        file.close()
-        return filename
-
-    def _preprocess(self, body, headers, include_dirs, lang):
-        src = self._gen_temp_sourcefile(body, headers, lang)
-        out = "_configtest.i"
-        self.temp_files.extend([src, out])
-        self.compiler.preprocess(src, out, include_dirs=include_dirs)
-        return (src, out)
-
-    def _compile(self, body, headers, include_dirs, lang):
-        src = self._gen_temp_sourcefile(body, headers, lang)
-        if self.dump_source:
-            dump_file(src, "compiling '%s':" % src)
-        (obj,) = self.compiler.object_filenames([src])
-        self.temp_files.extend([src, obj])
-        self.compiler.compile([src], include_dirs=include_dirs)
-        return (src, obj)
-
-    def _link(self, body, headers, include_dirs, libraries, library_dirs,
-              lang):
-        (src, obj) = self._compile(body, headers, include_dirs, lang)
-        prog = os.path.splitext(os.path.basename(src))[0]
-        self.compiler.link_executable([obj], prog,
-                                      libraries=libraries,
-                                      library_dirs=library_dirs,
-                                      target_lang=lang)
-
-        if self.compiler.exe_extension is not None:
-            prog = prog + self.compiler.exe_extension
-        self.temp_files.append(prog)
-
-        return (src, obj, prog)
-
-    def _clean(self, *filenames):
-        if not filenames:
-            filenames = self.temp_files
-            self.temp_files = []
-        log.info("removing: %s", ' '.join(filenames))
-        for filename in filenames:
-            try:
-                os.remove(filename)
-            except OSError:
-                pass
-
-
-    # XXX these ignore the dry-run flag: what to do, what to do? even if
-    # you want a dry-run build, you still need some sort of configuration
-    # info.  My inclination is to make it up to the real config command to
-    # consult 'dry_run', and assume a default (minimal) configuration if
-    # true.  The problem with trying to do it here is that you'd have to
-    # return either true or false from all the 'try' methods, neither of
-    # which is correct.
-
-    # XXX need access to the header search path and maybe default macros.
-
-    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
-        """Construct a source file from 'body' (a string containing lines
-        of C/C++ code) and 'headers' (a list of header files to include)
-        and run it through the preprocessor.  Return true if the
-        preprocessor succeeded, false if there were any errors.
-        ('body' probably isn't of much use, but what the heck.)
-        """
-        from distutils.ccompiler import CompileError
-        self._check_compiler()
-        ok = True
-        try:
-            self._preprocess(body, headers, include_dirs, lang)
-        except CompileError:
-            ok = False
-
-        self._clean()
-        return ok
-
-    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
-                   lang="c"):
-        """Construct a source file (just like 'try_cpp()'), run it through
-        the preprocessor, and return true if any line of the output matches
-        'pattern'.  'pattern' should either be a compiled regex object or a
-        string containing a regex.  If both 'body' and 'headers' are None,
-        preprocesses an empty file -- which can be useful to determine the
-        symbols the preprocessor and compiler set by default.
-        """
-        self._check_compiler()
-        src, out = self._preprocess(body, headers, include_dirs, lang)
-
-        if isinstance(pattern, str):
-            pattern = re.compile(pattern)
-
-        file = open(out)
-        match = False
-        while True:
-            line = file.readline()
-            if line == '':
-                break
-            if pattern.search(line):
-                match = True
-                break
-
-        file.close()
-        self._clean()
-        return match
-
-    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
-        """Try to compile a source file built from 'body' and 'headers'.
-        Return true on success, false otherwise.
-        """
-        from distutils.ccompiler import CompileError
-        self._check_compiler()
-        try:
-            self._compile(body, headers, include_dirs, lang)
-            ok = True
-        except CompileError:
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-    def try_link(self, body, headers=None, include_dirs=None, libraries=None,
-                 library_dirs=None, lang="c"):
-        """Try to compile and link a source file, built from 'body' and
-        'headers', to executable form.  Return true on success, false
-        otherwise.
-        """
-        from distutils.ccompiler import CompileError, LinkError
-        self._check_compiler()
-        try:
-            self._link(body, headers, include_dirs,
-                       libraries, library_dirs, lang)
-            ok = True
-        except (CompileError, LinkError):
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-    def try_run(self, body, headers=None, include_dirs=None, libraries=None,
-                library_dirs=None, lang="c"):
-        """Try to compile, link to an executable, and run a program
-        built from 'body' and 'headers'.  Return true on success, false
-        otherwise.
-        """
-        from distutils.ccompiler import CompileError, LinkError
-        self._check_compiler()
-        try:
-            src, obj, exe = self._link(body, headers, include_dirs,
-                                       libraries, library_dirs, lang)
-            self.spawn([exe])
-            ok = True
-        except (CompileError, LinkError, DistutilsExecError):
-            ok = False
-
-        log.info(ok and "success!" or "failure.")
-        self._clean()
-        return ok
-
-
-    # -- High-level methods --------------------------------------------
-    # (these are the ones that are actually likely to be useful
-    # when implementing a real-world config command!)
-
-    def check_func(self, func, headers=None, include_dirs=None,
-                   libraries=None, library_dirs=None, decl=0, call=0):
-        """Determine if function 'func' is available by constructing a
-        source file that refers to 'func', and compiles and links it.
-        If everything succeeds, returns true; otherwise returns false.
-
-        The constructed source file starts out by including the header
-        files listed in 'headers'.  If 'decl' is true, it then declares
-        'func' (as "int func()"); you probably shouldn't supply 'headers'
-        and set 'decl' true in the same call, or you might get errors about
-        a conflicting declarations for 'func'.  Finally, the constructed
-        'main()' function either references 'func' or (if 'call' is true)
-        calls it.  'libraries' and 'library_dirs' are used when
-        linking.
-        """
-        self._check_compiler()
-        body = []
-        if decl:
-            body.append("int %s ();" % func)
-        body.append("int main () {")
-        if call:
-            body.append("  %s();" % func)
-        else:
-            body.append("  %s;" % func)
-        body.append("}")
-        body = "\n".join(body) + "\n"
-
-        return self.try_link(body, headers, include_dirs,
-                             libraries, library_dirs)
-
-    def check_lib(self, library, library_dirs=None, headers=None,
-                  include_dirs=None, other_libraries=[]):
-        """Determine if 'library' is available to be linked against,
-        without actually checking that any particular symbols are provided
-        by it.  'headers' will be used in constructing the source file to
-        be compiled, but the only effect of this is to check if all the
-        header files listed are available.  Any libraries listed in
-        'other_libraries' will be included in the link, in case 'library'
-        has symbols that depend on other libraries.
-        """
-        self._check_compiler()
-        return self.try_link("int main (void) { }", headers, include_dirs,
-                             [library] + other_libraries, library_dirs)
-
-    def check_header(self, header, include_dirs=None, library_dirs=None,
-                     lang="c"):
-        """Determine if the system header file named by 'header_file'
-        exists and can be found by the preprocessor; return true if so,
-        false otherwise.
-        """
-        return self.try_cpp(body="/* No body */", headers=[header],
-                            include_dirs=include_dirs)
-
-
-def dump_file(filename, head=None):
-    """Dumps a file content into log.info.
-
-    If head is not None, will be dumped before the file content.
-    """
-    if head is None:
-        log.info('%s', filename)
-    else:
-        log.info(head)
-    file = open(filename)
-    try:
-        log.info(file.read())
-    finally:
-        file.close()
diff --git a/Lib/distutils/command/install.py b/Lib/distutils/command/install.py
deleted file mode 100644
index fd3357ea78..0000000000
--- a/Lib/distutils/command/install.py
+++ /dev/null
@@ -1,705 +0,0 @@
-"""distutils.command.install
-
-Implements the Distutils 'install' command."""
-
-import sys
-import os
-
-from distutils import log
-from distutils.core import Command
-from distutils.debug import DEBUG
-from distutils.sysconfig import get_config_vars
-from distutils.errors import DistutilsPlatformError
-from distutils.file_util import write_file
-from distutils.util import convert_path, subst_vars, change_root
-from distutils.util import get_platform
-from distutils.errors import DistutilsOptionError
-
-from site import USER_BASE
-from site import USER_SITE
-HAS_USER_SITE = True
-
-WINDOWS_SCHEME = {
-    'purelib': '$base/Lib/site-packages',
-    'platlib': '$base/Lib/site-packages',
-    'headers': '$base/Include/$dist_name',
-    'scripts': '$base/Scripts',
-    'data'   : '$base',
-}
-
-INSTALL_SCHEMES = {
-    'unix_prefix': {
-        'purelib': '$base/lib/python$py_version_short/site-packages',
-        'platlib': '$platbase/lib/python$py_version_short/site-packages',
-        'headers': '$base/include/python$py_version_short$abiflags/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'unix_local': {
-        'purelib': '$base/local/lib/python$py_version_short/dist-packages',
-        'platlib': '$platbase/local/lib/python$py_version_short/dist-packages',
-        'headers': '$base/local/include/python$py_version_short/$dist_name',
-        'scripts': '$base/local/bin',
-        'data'   : '$base/local',
-        },
-    'deb_system': {
-        'purelib': '$base/lib/python3/dist-packages',
-        'platlib': '$platbase/lib/python3/dist-packages',
-        'headers': '$base/include/python$py_version_short/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'unix_home': {
-        'purelib': '$base/lib/python',
-        'platlib': '$base/lib/python',
-        'headers': '$base/include/python/$dist_name',
-        'scripts': '$base/bin',
-        'data'   : '$base',
-        },
-    'nt': WINDOWS_SCHEME,
-    }
-
-# user site schemes
-if HAS_USER_SITE:
-    INSTALL_SCHEMES['nt_user'] = {
-        'purelib': '$usersite',
-        'platlib': '$usersite',
-        'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
-        'scripts': '$userbase/Python$py_version_nodot/Scripts',
-        'data'   : '$userbase',
-        }
-
-    INSTALL_SCHEMES['unix_user'] = {
-        'purelib': '$usersite',
-        'platlib': '$usersite',
-        'headers':
-            '$userbase/include/python$py_version_short$abiflags/$dist_name',
-        'scripts': '$userbase/bin',
-        'data'   : '$userbase',
-        }
-
-# XXX RUSTPYTHON: replace python with rustpython in all these paths
-for group in INSTALL_SCHEMES.values():
-    for key in group.keys():
-        group[key] = group[key].replace("Python", "RustPython").replace("python", "rustpython")
-
-# The keys to an installation scheme; if any new types of files are to be
-# installed, be sure to add an entry to every installation scheme above,
-# and to SCHEME_KEYS here.
-SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')
-
-
-class install(Command):
-
-    description = "install everything from build directory"
-
-    user_options = [
-        # Select installation scheme and set base director(y|ies)
-        ('prefix=', None,
-         "installation prefix"),
-        ('exec-prefix=', None,
-         "(Unix only) prefix for platform-specific files"),
-        ('home=', None,
-         "(Unix only) home directory to install under"),
-
-        # Or, just set the base director(y|ies)
-        ('install-base=', None,
-         "base installation directory (instead of --prefix or --home)"),
-        ('install-platbase=', None,
-         "base installation directory for platform-specific files " +
-         "(instead of --exec-prefix or --home)"),
-        ('root=', None,
-         "install everything relative to this alternate root directory"),
-
-        # Or, explicitly set the installation scheme
-        ('install-purelib=', None,
-         "installation directory for pure Python module distributions"),
-        ('install-platlib=', None,
-         "installation directory for non-pure module distributions"),
-        ('install-lib=', None,
-         "installation directory for all module distributions " +
-         "(overrides --install-purelib and --install-platlib)"),
-
-        ('install-headers=', None,
-         "installation directory for C/C++ headers"),
-        ('install-scripts=', None,
-         "installation directory for Python scripts"),
-        ('install-data=', None,
-         "installation directory for data files"),
-
-        # Byte-compilation options -- see install_lib.py for details, as
-        # these are duplicated from there (but only install_lib does
-        # anything with them).
-        ('compile', 'c', "compile .py to .pyc [default]"),
-        ('no-compile', None, "don't compile .py files"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-
-        # Miscellaneous control options
-        ('force', 'f',
-         "force installation (overwrite any existing files)"),
-        ('skip-build', None,
-         "skip rebuilding everything (for testing/debugging)"),
-
-        # Where to install documentation (eventually!)
-        #('doc-format=', None, "format of documentation to generate"),
-        #('install-man=', None, "directory for Unix man pages"),
-        #('install-html=', None, "directory for HTML documentation"),
-        #('install-info=', None, "directory for GNU info files"),
-
-        ('record=', None,
-         "filename in which to record list of installed files"),
-
-        ('install-layout=', None,
-         "installation layout to choose (known values: deb, unix)"),
-        ]
-
-    boolean_options = ['compile', 'force', 'skip-build']
-
-    if HAS_USER_SITE:
-        user_options.append(('user', None,
-                             "install in user site-package '%s'" % USER_SITE))
-        boolean_options.append('user')
-
-    negative_opt = {'no-compile' : 'compile'}
-
-
-    def initialize_options(self):
-        """Initializes options."""
-        # High-level options: these select both an installation base
-        # and scheme.
-        self.prefix = None
-        self.exec_prefix = None
-        self.home = None
-        self.user = 0
-        self.prefix_option = None
-
-        # These select only the installation base; it's up to the user to
-        # specify the installation scheme (currently, that means supplying
-        # the --install-{platlib,purelib,scripts,data} options).
-        self.install_base = None
-        self.install_platbase = None
-        self.root = None
-
-        # These options are the actual installation directories; if not
-        # supplied by the user, they are filled in using the installation
-        # scheme implied by prefix/exec-prefix/home and the contents of
-        # that installation scheme.
-        self.install_purelib = None     # for pure module distributions
-        self.install_platlib = None     # non-pure (dists w/ extensions)
-        self.install_headers = None     # for C/C++ headers
-        self.install_lib = None         # set to either purelib or platlib
-        self.install_scripts = None
-        self.install_data = None
-        self.install_userbase = USER_BASE
-        self.install_usersite = USER_SITE
-
-        # enable custom installation, known values: deb
-        self.install_layout = None
-        self.multiarch = None
-        
-        self.compile = None
-        self.optimize = None
-
-        # Deprecated
-        # These two are for putting non-packagized distributions into their
-        # own directory and creating a .pth file if it makes sense.
-        # 'extra_path' comes from the setup file; 'install_path_file' can
-        # be turned off if it makes no sense to install a .pth file.  (But
-        # better to install it uselessly than to guess wrong and not
-        # install it when it's necessary and would be used!)  Currently,
-        # 'install_path_file' is always true unless some outsider meddles
-        # with it.
-        self.extra_path = None
-        self.install_path_file = 1
-
-        # 'force' forces installation, even if target files are not
-        # out-of-date.  'skip_build' skips running the "build" command,
-        # handy if you know it's not necessary.  'warn_dir' (which is *not*
-        # a user option, it's just there so the bdist_* commands can turn
-        # it off) determines whether we warn about installing to a
-        # directory not in sys.path.
-        self.force = 0
-        self.skip_build = 0
-        self.warn_dir = 1
-
-        # These are only here as a conduit from the 'build' command to the
-        # 'install_*' commands that do the real work.  ('build_base' isn't
-        # actually used anywhere, but it might be useful in future.)  They
-        # are not user options, because if the user told the install
-        # command where the build directory is, that wouldn't affect the
-        # build command.
-        self.build_base = None
-        self.build_lib = None
-
-        # Not defined yet because we don't know anything about
-        # documentation yet.
-        #self.install_man = None
-        #self.install_html = None
-        #self.install_info = None
-
-        self.record = None
-
-
-    # -- Option finalizing methods -------------------------------------
-    # (This is rather more involved than for most commands,
-    # because this is where the policy for installing third-
-    # party Python modules on various platforms given a wide
-    # array of user input is decided.  Yes, it's quite complex!)
-
-    def finalize_options(self):
-        """Finalizes options."""
-        # This method (and its pliant slaves, like 'finalize_unix()',
-        # 'finalize_other()', and 'select_scheme()') is where the default
-        # installation directories for modules, extension modules, and
-        # anything else we care to install from a Python module
-        # distribution.  Thus, this code makes a pretty important policy
-        # statement about how third-party stuff is added to a Python
-        # installation!  Note that the actual work of installation is done
-        # by the relatively simple 'install_*' commands; they just take
-        # their orders from the installation directory options determined
-        # here.
-
-        # Check for errors/inconsistencies in the options; first, stuff
-        # that's wrong on any platform.
-
-        if ((self.prefix or self.exec_prefix or self.home) and
-            (self.install_base or self.install_platbase)):
-            raise DistutilsOptionError(
-                   "must supply either prefix/exec-prefix/home or " +
-                   "install-base/install-platbase -- not both")
-
-        if self.home and (self.prefix or self.exec_prefix):
-            raise DistutilsOptionError(
-                  "must supply either home or prefix/exec-prefix -- not both")
-
-        if self.user and (self.prefix or self.exec_prefix or self.home or
-                self.install_base or self.install_platbase):
-            raise DistutilsOptionError("can't combine user with prefix, "
-                                       "exec_prefix/home, or install_(plat)base")
-
-        # Next, stuff that's wrong (or dubious) only on certain platforms.
-        if os.name != "posix":
-            if self.exec_prefix:
-                self.warn("exec-prefix option ignored on this platform")
-                self.exec_prefix = None
-
-        # Now the interesting logic -- so interesting that we farm it out
-        # to other methods.  The goal of these methods is to set the final
-        # values for the install_{lib,scripts,data,...}  options, using as
-        # input a heady brew of prefix, exec_prefix, home, install_base,
-        # install_platbase, user-supplied versions of
-        # install_{purelib,platlib,lib,scripts,data,...}, and the
-        # INSTALL_SCHEME dictionary above.  Phew!
-
-        self.dump_dirs("pre-finalize_{unix,other}")
-
-        if os.name == 'posix':
-            self.finalize_unix()
-        else:
-            self.finalize_other()
-
-        self.dump_dirs("post-finalize_{unix,other}()")
-
-        # Expand configuration variables, tilde, etc. in self.install_base
-        # and self.install_platbase -- that way, we can use $base or
-        # $platbase in the other installation directories and not worry
-        # about needing recursive variable expansion (shudder).
-
-        py_version = sys.version.split()[0]
-        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
-        try:
-            abiflags = sys.abiflags
-        except AttributeError:
-            # sys.abiflags may not be defined on all platforms.
-            abiflags = ''
-        self.config_vars = {'dist_name': self.distribution.get_name(),
-                            'dist_version': self.distribution.get_version(),
-                            'dist_fullname': self.distribution.get_fullname(),
-                            'py_version': py_version,
-                            'py_version_short': '%d.%d' % sys.version_info[:2],
-                            'py_version_nodot': '%d%d' % sys.version_info[:2],
-                            'sys_prefix': prefix,
-                            'prefix': prefix,
-                            'sys_exec_prefix': exec_prefix,
-                            'exec_prefix': exec_prefix,
-                            'abiflags': abiflags,
-                           }
-
-        if HAS_USER_SITE:
-            self.config_vars['userbase'] = self.install_userbase
-            self.config_vars['usersite'] = self.install_usersite
-
-        self.expand_basedirs()
-
-        self.dump_dirs("post-expand_basedirs()")
-
-        # Now define config vars for the base directories so we can expand
-        # everything else.
-        self.config_vars['base'] = self.install_base
-        self.config_vars['platbase'] = self.install_platbase
-
-        if DEBUG:
-            from pprint import pprint
-            print("config vars:")
-            pprint(self.config_vars)
-
-        # Expand "~" and configuration variables in the installation
-        # directories.
-        self.expand_dirs()
-
-        self.dump_dirs("post-expand_dirs()")
-
-        # Create directories in the home dir:
-        if self.user:
-            self.create_home_path()
-
-        # Pick the actual directory to install all modules to: either
-        # install_purelib or install_platlib, depending on whether this
-        # module distribution is pure or not.  Of course, if the user
-        # already specified install_lib, use their selection.
-        if self.install_lib is None:
-            if self.distribution.ext_modules: # has extensions: non-pure
-                self.install_lib = self.install_platlib
-            else:
-                self.install_lib = self.install_purelib
-
-
-        # Convert directories from Unix /-separated syntax to the local
-        # convention.
-        self.convert_paths('lib', 'purelib', 'platlib',
-                           'scripts', 'data', 'headers',
-                           'userbase', 'usersite')
-
-        # Deprecated
-        # Well, we're not actually fully completely finalized yet: we still
-        # have to deal with 'extra_path', which is the hack for allowing
-        # non-packagized module distributions (hello, Numerical Python!) to
-        # get their own directories.
-        self.handle_extra_path()
-        self.install_libbase = self.install_lib # needed for .pth file
-        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)
-
-        # If a new root directory was supplied, make all the installation
-        # dirs relative to it.
-        if self.root is not None:
-            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
-                              'scripts', 'data', 'headers')
-
-        self.dump_dirs("after prepending root")
-
-        # Find out the build directories, ie. where to install from.
-        self.set_undefined_options('build',
-                                   ('build_base', 'build_base'),
-                                   ('build_lib', 'build_lib'))
-
-        # Punt on doc directories for now -- after all, we're punting on
-        # documentation completely!
-
-    def dump_dirs(self, msg):
-        """Dumps the list of user options."""
-        if not DEBUG:
-            return
-        from distutils.fancy_getopt import longopt_xlate
-        log.debug(msg + ":")
-        for opt in self.user_options:
-            opt_name = opt[0]
-            if opt_name[-1] == "=":
-                opt_name = opt_name[0:-1]
-            if opt_name in self.negative_opt:
-                opt_name = self.negative_opt[opt_name]
-                opt_name = opt_name.translate(longopt_xlate)
-                val = not getattr(self, opt_name)
-            else:
-                opt_name = opt_name.translate(longopt_xlate)
-                val = getattr(self, opt_name)
-            log.debug("  %s: %s", opt_name, val)
-
-    def finalize_unix(self):
-        """Finalizes options for posix platforms."""
-        if self.install_base is not None or self.install_platbase is not None:
-            if ((self.install_lib is None and
-                 self.install_purelib is None and
-                 self.install_platlib is None) or
-                self.install_headers is None or
-                self.install_scripts is None or
-                self.install_data is None):
-                raise DistutilsOptionError(
-                      "install-base or install-platbase supplied, but "
-                      "installation scheme is incomplete")
-            return
-
-        if self.user:
-            if self.install_userbase is None:
-                raise DistutilsPlatformError(
-                    "User base directory is not specified")
-            self.install_base = self.install_platbase = self.install_userbase
-            self.select_scheme("unix_user")
-        elif self.home is not None:
-            self.install_base = self.install_platbase = self.home
-            self.select_scheme("unix_home")
-        else:
-            self.prefix_option = self.prefix
-            if self.prefix is None:
-                if self.exec_prefix is not None:
-                    raise DistutilsOptionError(
-                          "must not supply exec-prefix without prefix")
-
-                self.prefix = os.path.normpath(sys.prefix)
-                self.exec_prefix = os.path.normpath(sys.exec_prefix)
-
-            else:
-                if self.exec_prefix is None:
-                    self.exec_prefix = self.prefix
-
-            self.install_base = self.prefix
-            self.install_platbase = self.exec_prefix
-            if self.install_layout:
-                if self.install_layout.lower() in ['deb']:
-                    import sysconfig
-                    self.multiarch = sysconfig.get_config_var('MULTIARCH')
-                    self.select_scheme("deb_system")
-                elif self.install_layout.lower() in ['unix']:
-                    self.select_scheme("unix_prefix")
-                else:
-                    raise DistutilsOptionError(
-                        "unknown value for --install-layout")
-            elif ((self.prefix_option and
-                   os.path.normpath(self.prefix) != '/usr/local')
-                  or sys.base_prefix != sys.prefix
-                  or 'PYTHONUSERBASE' in os.environ
-                  or 'VIRTUAL_ENV' in os.environ
-                  or 'real_prefix' in sys.__dict__):
-                self.select_scheme("unix_prefix")
-            else:
-                if os.path.normpath(self.prefix) == '/usr/local':
-                    self.prefix = self.exec_prefix = '/usr'
-                    self.install_base = self.install_platbase = '/usr'
-                self.select_scheme("unix_local")
-
-    def finalize_other(self):
-        """Finalizes options for non-posix platforms"""
-        if self.user:
-            if self.install_userbase is None:
-                raise DistutilsPlatformError(
-                    "User base directory is not specified")
-            self.install_base = self.install_platbase = self.install_userbase
-            self.select_scheme(os.name + "_user")
-        elif self.home is not None:
-            self.install_base = self.install_platbase = self.home
-            self.select_scheme("unix_home")
-        else:
-            if self.prefix is None:
-                self.prefix = os.path.normpath(sys.prefix)
-
-            self.install_base = self.install_platbase = self.prefix
-            try:
-                self.select_scheme(os.name)
-            except KeyError:
-                raise DistutilsPlatformError(
-                      "I don't know how to install stuff on '%s'" % os.name)
-
-    def select_scheme(self, name):
-        """Sets the install directories by applying the install schemes."""
-        # it's the caller's problem if they supply a bad name!
-        scheme = INSTALL_SCHEMES[name]
-        for key in SCHEME_KEYS:
-            attrname = 'install_' + key
-            if getattr(self, attrname) is None:
-                setattr(self, attrname, scheme[key])
-
-    def _expand_attrs(self, attrs):
-        for attr in attrs:
-            val = getattr(self, attr)
-            if val is not None:
-                if os.name == 'posix' or os.name == 'nt':
-                    val = os.path.expanduser(val)
-                val = subst_vars(val, self.config_vars)
-                setattr(self, attr, val)
-
-    def expand_basedirs(self):
-        """Calls `os.path.expanduser` on install_base, install_platbase and
-        root."""
-        self._expand_attrs(['install_base', 'install_platbase', 'root'])
-
-    def expand_dirs(self):
-        """Calls `os.path.expanduser` on install dirs."""
-        self._expand_attrs(['install_purelib', 'install_platlib',
-                            'install_lib', 'install_headers',
-                            'install_scripts', 'install_data',])
-
-    def convert_paths(self, *names):
-        """Call `convert_path` over `names`."""
-        for name in names:
-            attr = "install_" + name
-            setattr(self, attr, convert_path(getattr(self, attr)))
-
-    def handle_extra_path(self):
-        """Set `path_file` and `extra_dirs` using `extra_path`."""
-        if self.extra_path is None:
-            self.extra_path = self.distribution.extra_path
-
-        if self.extra_path is not None:
-            log.warn(
-                "Distribution option extra_path is deprecated. "
-                "See issue27919 for details."
-            )
-            if isinstance(self.extra_path, str):
-                self.extra_path = self.extra_path.split(',')
-
-            if len(self.extra_path) == 1:
-                path_file = extra_dirs = self.extra_path[0]
-            elif len(self.extra_path) == 2:
-                path_file, extra_dirs = self.extra_path
-            else:
-                raise DistutilsOptionError(
-                      "'extra_path' option must be a list, tuple, or "
-                      "comma-separated string with 1 or 2 elements")
-
-            # convert to local form in case Unix notation used (as it
-            # should be in setup scripts)
-            extra_dirs = convert_path(extra_dirs)
-        else:
-            path_file = None
-            extra_dirs = ''
-
-        # XXX should we warn if path_file and not extra_dirs? (in which
-        # case the path file would be harmless but pointless)
-        self.path_file = path_file
-        self.extra_dirs = extra_dirs
-
-    def change_roots(self, *names):
-        """Change the install directories pointed by name using root."""
-        for name in names:
-            attr = "install_" + name
-            setattr(self, attr, change_root(self.root, getattr(self, attr)))
-
-    def create_home_path(self):
-        """Create directories under ~."""
-        if not self.user:
-            return
-        home = convert_path(os.path.expanduser("~"))
-        for name, path in self.config_vars.items():
-            if path.startswith(home) and not os.path.isdir(path):
-                self.debug_print("os.makedirs('%s', 0o700)" % path)
-                os.makedirs(path, 0o700)
-
-    # -- Command execution methods -------------------------------------
-
-    def run(self):
-        """Runs the command."""
-        # Obviously have to build before we can install
-        if not self.skip_build:
-            self.run_command('build')
-            # If we built for any other platform, we can't install.
-            build_plat = self.distribution.get_command_obj('build').plat_name
-            # check warn_dir - it is a clue that the 'install' is happening
-            # internally, and not to sys.path, so we don't check the platform
-            # matches what we are running.
-            if self.warn_dir and build_plat != get_platform():
-                raise DistutilsPlatformError("Can't install when "
-                                             "cross-compiling")
-
-        # Run all sub-commands (at least those that need to be run)
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        if self.path_file:
-            self.create_path_file()
-
-        # write list of installed files, if requested.
-        if self.record:
-            outputs = self.get_outputs()
-            if self.root:               # strip any package prefix
-                root_len = len(self.root)
-                for counter in range(len(outputs)):
-                    outputs[counter] = outputs[counter][root_len:]
-            self.execute(write_file,
-                         (self.record, outputs),
-                         "writing list of installed files to '%s'" %
-                         self.record)
-
-        sys_path = map(os.path.normpath, sys.path)
-        sys_path = map(os.path.normcase, sys_path)
-        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
-        if (self.warn_dir and
-            not (self.path_file and self.install_path_file) and
-            install_lib not in sys_path):
-            log.debug(("modules installed to '%s', which is not in "
-                       "Python's module search path (sys.path) -- "
-                       "you'll have to change the search path yourself"),
-                       self.install_lib)
-
-    def create_path_file(self):
-        """Creates the .pth file"""
-        filename = os.path.join(self.install_libbase,
-                                self.path_file + ".pth")
-        if self.install_path_file:
-            self.execute(write_file,
-                         (filename, [self.extra_dirs]),
-                         "creating %s" % filename)
-        else:
-            self.warn("path file '%s' not created" % filename)
-
-
-    # -- Reporting methods ---------------------------------------------
-
-    def get_outputs(self):
-        """Assembles the outputs of all the sub-commands."""
-        outputs = []
-        for cmd_name in self.get_sub_commands():
-            cmd = self.get_finalized_command(cmd_name)
-            # Add the contents of cmd.get_outputs(), ensuring
-            # that outputs doesn't contain duplicate entries
-            for filename in cmd.get_outputs():
-                if filename not in outputs:
-                    outputs.append(filename)
-
-        if self.path_file and self.install_path_file:
-            outputs.append(os.path.join(self.install_libbase,
-                                        self.path_file + ".pth"))
-
-        return outputs
-
-    def get_inputs(self):
-        """Returns the inputs of all the sub-commands"""
-        # XXX gee, this looks familiar ;-(
-        inputs = []
-        for cmd_name in self.get_sub_commands():
-            cmd = self.get_finalized_command(cmd_name)
-            inputs.extend(cmd.get_inputs())
-
-        return inputs
-
-    # -- Predicates for sub-command list -------------------------------
-
-    def has_lib(self):
-        """Returns true if the current distribution has any Python
-        modules to install."""
-        return (self.distribution.has_pure_modules() or
-                self.distribution.has_ext_modules())
-
-    def has_headers(self):
-        """Returns true if the current distribution has any headers to
-        install."""
-        return self.distribution.has_headers()
-
-    def has_scripts(self):
-        """Returns true if the current distribution has any scripts to.
-        install."""
-        return self.distribution.has_scripts()
-
-    def has_data(self):
-        """Returns true if the current distribution has any data to.
-        install."""
-        return self.distribution.has_data_files()
-
-    # 'sub_commands': a list of commands this command might have to run to
-    # get its work done.  See cmd.py for more info.
-    sub_commands = [('install_lib',     has_lib),
-                    ('install_headers', has_headers),
-                    ('install_scripts', has_scripts),
-                    ('install_data',    has_data),
-                    ('install_egg_info', lambda self:True),
-                   ]
diff --git a/Lib/distutils/command/install_data.py b/Lib/distutils/command/install_data.py
deleted file mode 100644
index 947cd76a99..0000000000
--- a/Lib/distutils/command/install_data.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""distutils.command.install_data
-
-Implements the Distutils 'install_data' command, for installing
-platform-independent data files."""
-
-# contributed by Bastian Kleineidam
-
-import os
-from distutils.core import Command
-from distutils.util import change_root, convert_path
-
-class install_data(Command):
-
-    description = "install data files"
-
-    user_options = [
-        ('install-dir=', 'd',
-         "base directory for installing data files "
-         "(default: installation base dir)"),
-        ('root=', None,
-         "install everything relative to this alternate root directory"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ]
-
-    boolean_options = ['force']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.outfiles = []
-        self.root = None
-        self.force = 0
-        self.data_files = self.distribution.data_files
-        self.warn_dir = 1
-
-    def finalize_options(self):
-        self.set_undefined_options('install',
-                                   ('install_data', 'install_dir'),
-                                   ('root', 'root'),
-                                   ('force', 'force'),
-                                  )
-
-    def run(self):
-        self.mkpath(self.install_dir)
-        for f in self.data_files:
-            if isinstance(f, str):
-                # it's a simple file, so copy it
-                f = convert_path(f)
-                if self.warn_dir:
-                    self.warn("setup script did not provide a directory for "
-                              "'%s' -- installing right in '%s'" %
-                              (f, self.install_dir))
-                (out, _) = self.copy_file(f, self.install_dir)
-                self.outfiles.append(out)
-            else:
-                # it's a tuple with path to install to and a list of files
-                dir = convert_path(f[0])
-                if not os.path.isabs(dir):
-                    dir = os.path.join(self.install_dir, dir)
-                elif self.root:
-                    dir = change_root(self.root, dir)
-                self.mkpath(dir)
-
-                if f[1] == []:
-                    # If there are no files listed, the user must be
-                    # trying to create an empty directory, so add the
-                    # directory to the list of output files.
-                    self.outfiles.append(dir)
-                else:
-                    # Copy files, adding them to the list of output files.
-                    for data in f[1]:
-                        data = convert_path(data)
-                        (out, _) = self.copy_file(data, dir)
-                        self.outfiles.append(out)
-
-    def get_inputs(self):
-        return self.data_files or []
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/install_egg_info.py b/Lib/distutils/command/install_egg_info.py
deleted file mode 100644
index 0a71b61000..0000000000
--- a/Lib/distutils/command/install_egg_info.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""distutils.command.install_egg_info
-
-Implements the Distutils 'install_egg_info' command, for installing
-a package's PKG-INFO metadata."""
-
-
-from distutils.cmd import Command
-from distutils import log, dir_util
-import os, sys, re
-
-class install_egg_info(Command):
-    """Install an .egg-info file for the package"""
-
-    description = "Install package's PKG-INFO metadata as an .egg-info file"
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-        ('install-layout', None, "custom installation layout"),
-    ]
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.install_layout = None
-        self.prefix_option = None
-
-    def finalize_options(self):
-        self.set_undefined_options('install_lib',('install_dir','install_dir'))
-        self.set_undefined_options('install',('install_layout','install_layout'))
-        self.set_undefined_options('install',('prefix_option','prefix_option'))
-        if self.install_layout:
-            if not self.install_layout.lower() in ['deb', 'unix']:
-                raise DistutilsOptionError(
-                    "unknown value for --install-layout")
-            no_pyver = (self.install_layout.lower() == 'deb')
-        elif self.prefix_option:
-            no_pyver = False
-        else:
-            no_pyver = True
-        if no_pyver:
-            basename = "%s-%s.egg-info" % (
-                to_filename(safe_name(self.distribution.get_name())),
-                to_filename(safe_version(self.distribution.get_version()))
-                )
-        else:
-            basename = "%s-%s-py%d.%d.egg-info" % (
-                to_filename(safe_name(self.distribution.get_name())),
-                to_filename(safe_version(self.distribution.get_version())),
-                *sys.version_info[:2]
-            )
-        self.target = os.path.join(self.install_dir, basename)
-        self.outputs = [self.target]
-
-    def run(self):
-        target = self.target
-        if os.path.isdir(target) and not os.path.islink(target):
-            dir_util.remove_tree(target, dry_run=self.dry_run)
-        elif os.path.exists(target):
-            self.execute(os.unlink,(self.target,),"Removing "+target)
-        elif not os.path.isdir(self.install_dir):
-            self.execute(os.makedirs, (self.install_dir,),
-                         "Creating "+self.install_dir)
-        log.info("Writing %s", target)
-        if not self.dry_run:
-            with open(target, 'w', encoding='UTF-8') as f:
-                self.distribution.metadata.write_pkg_file(f)
-
-    def get_outputs(self):
-        return self.outputs
-
-
-# The following routines are taken from setuptools' pkg_resources module and
-# can be replaced by importing them from pkg_resources once it is included
-# in the stdlib.
-
-def safe_name(name):
-    """Convert an arbitrary string to a standard distribution name
-
-    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
-    """
-    return re.sub('[^A-Za-z0-9.]+', '-', name)
-
-
-def safe_version(version):
-    """Convert an arbitrary string to a standard version string
-
-    Spaces become dots, and all other non-alphanumeric characters become
-    dashes, with runs of multiple dashes condensed to a single dash.
-    """
-    version = version.replace(' ','.')
-    return re.sub('[^A-Za-z0-9.]+', '-', version)
-
-
-def to_filename(name):
-    """Convert a project or version name to its filename-escaped form
-
-    Any '-' characters are currently replaced with '_'.
-    """
-    return name.replace('-','_')
diff --git a/Lib/distutils/command/install_headers.py b/Lib/distutils/command/install_headers.py
deleted file mode 100644
index 9bb0b18dc0..0000000000
--- a/Lib/distutils/command/install_headers.py
+++ /dev/null
@@ -1,47 +0,0 @@
-"""distutils.command.install_headers
-
-Implements the Distutils 'install_headers' command, to install C/C++ header
-files to the Python include directory."""
-
-from distutils.core import Command
-
-
-# XXX force is never used
-class install_headers(Command):
-
-    description = "install C/C++ header files"
-
-    user_options = [('install-dir=', 'd',
-                     "directory to install header files to"),
-                    ('force', 'f',
-                     "force installation (overwrite existing files)"),
-                   ]
-
-    boolean_options = ['force']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.force = 0
-        self.outfiles = []
-
-    def finalize_options(self):
-        self.set_undefined_options('install',
-                                   ('install_headers', 'install_dir'),
-                                   ('force', 'force'))
-
-
-    def run(self):
-        headers = self.distribution.headers
-        if not headers:
-            return
-
-        self.mkpath(self.install_dir)
-        for header in headers:
-            (out, _) = self.copy_file(header, self.install_dir)
-            self.outfiles.append(out)
-
-    def get_inputs(self):
-        return self.distribution.headers or []
-
-    def get_outputs(self):
-        return self.outfiles
diff --git a/Lib/distutils/command/install_lib.py b/Lib/distutils/command/install_lib.py
deleted file mode 100644
index eef63626ff..0000000000
--- a/Lib/distutils/command/install_lib.py
+++ /dev/null
@@ -1,221 +0,0 @@
-"""distutils.command.install_lib
-
-Implements the Distutils 'install_lib' command
-(install all Python modules)."""
-
-import os
-import importlib.util
-import sys
-
-from distutils.core import Command
-from distutils.errors import DistutilsOptionError
-
-
-# Extension for Python source files.
-PYTHON_SOURCE_EXTENSION = ".py"
-
-class install_lib(Command):
-
-    description = "install all Python modules (extensions and pure Python)"
-
-    # The byte-compilation options are a tad confusing.  Here are the
-    # possible scenarios:
-    #   1) no compilation at all (--no-compile --no-optimize)
-    #   2) compile .pyc only (--compile --no-optimize; default)
-    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
-    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
-    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
-    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
-    #
-    # The UI for this is two options, 'compile' and 'optimize'.
-    # 'compile' is strictly boolean, and only decides whether to
-    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
-    # decides both whether to generate .pyc files and what level of
-    # optimization to use.
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install to"),
-        ('build-dir=','b', "build directory (where to install from)"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ('compile', 'c', "compile .py to .pyc [default]"),
-        ('no-compile', None, "don't compile .py files"),
-        ('optimize=', 'O',
-         "also compile with optimization: -O1 for \"python -O\", "
-         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
-        ('skip-build', None, "skip the build steps"),
-        ]
-
-    boolean_options = ['force', 'compile', 'skip-build']
-    negative_opt = {'no-compile' : 'compile'}
-
-    def initialize_options(self):
-        # let the 'install' command dictate our installation directory
-        self.install_dir = None
-        self.build_dir = None
-        self.force = 0
-        self.compile = None
-        self.optimize = None
-        self.skip_build = None
-        self.multiarch = None # if we should rename the extensions
-
-    def finalize_options(self):
-        # Get all the information we need to install pure Python modules
-        # from the umbrella 'install' command -- build (source) directory,
-        # install (target) directory, and whether to compile .py files.
-        self.set_undefined_options('install',
-                                   ('build_lib', 'build_dir'),
-                                   ('install_lib', 'install_dir'),
-                                   ('force', 'force'),
-                                   ('compile', 'compile'),
-                                   ('optimize', 'optimize'),
-                                   ('skip_build', 'skip_build'),
-                                   ('multiarch', 'multiarch'),
-                                  )
-
-        if self.compile is None:
-            self.compile = True
-        if self.optimize is None:
-            self.optimize = False
-
-        if not isinstance(self.optimize, int):
-            try:
-                self.optimize = int(self.optimize)
-                if self.optimize not in (0, 1, 2):
-                    raise AssertionError
-            except (ValueError, AssertionError):
-                raise DistutilsOptionError("optimize must be 0, 1, or 2")
-
-    def run(self):
-        # Make sure we have built everything we need first
-        self.build()
-
-        # Install everything: simply dump the entire contents of the build
-        # directory to the installation directory (that's the beauty of
-        # having a build directory!)
-        outfiles = self.install()
-
-        # (Optionally) compile .py to .pyc
-        if outfiles is not None and self.distribution.has_pure_modules():
-            self.byte_compile(outfiles)
-
-    # -- Top-level worker functions ------------------------------------
-    # (called from 'run()')
-
-    def build(self):
-        if not self.skip_build:
-            if self.distribution.has_pure_modules():
-                self.run_command('build_py')
-            if self.distribution.has_ext_modules():
-                self.run_command('build_ext')
-
-    def install(self):
-        if os.path.isdir(self.build_dir):
-            import distutils.dir_util
-            distutils.dir_util._multiarch = self.multiarch
-            outfiles = self.copy_tree(self.build_dir, self.install_dir)
-        else:
-            self.warn("'%s' does not exist -- no Python modules to install" %
-                      self.build_dir)
-            return
-        return outfiles
-
-    def byte_compile(self, files):
-        if sys.dont_write_bytecode:
-            self.warn('byte-compiling is disabled, skipping.')
-            return
-
-        from distutils.util import byte_compile
-
-        # Get the "--root" directory supplied to the "install" command,
-        # and use it as a prefix to strip off the purported filename
-        # encoded in bytecode files.  This is far from complete, but it
-        # should at least generate usable bytecode in RPM distributions.
-        install_root = self.get_finalized_command('install').root
-
-        if self.compile:
-            byte_compile(files, optimize=0,
-                         force=self.force, prefix=install_root,
-                         dry_run=self.dry_run)
-        if self.optimize > 0:
-            byte_compile(files, optimize=self.optimize,
-                         force=self.force, prefix=install_root,
-                         verbose=self.verbose, dry_run=self.dry_run)
-
-
-    # -- Utility methods -----------------------------------------------
-
-    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
-        if not has_any:
-            return []
-
-        build_cmd = self.get_finalized_command(build_cmd)
-        build_files = build_cmd.get_outputs()
-        build_dir = getattr(build_cmd, cmd_option)
-
-        prefix_len = len(build_dir) + len(os.sep)
-        outputs = []
-        for file in build_files:
-            outputs.append(os.path.join(output_dir, file[prefix_len:]))
-
-        return outputs
-
-    def _bytecode_filenames(self, py_filenames):
-        bytecode_files = []
-        for py_file in py_filenames:
-            # Since build_py handles package data installation, the
-            # list of outputs can contain more than just .py files.
-            # Make sure we only report bytecode for the .py files.
-            ext = os.path.splitext(os.path.normcase(py_file))[1]
-            if ext != PYTHON_SOURCE_EXTENSION:
-                continue
-            if self.compile:
-                bytecode_files.append(importlib.util.cache_from_source(
-                    py_file, optimization=''))
-            if self.optimize > 0:
-                bytecode_files.append(importlib.util.cache_from_source(
-                    py_file, optimization=self.optimize))
-
-        return bytecode_files
-
-
-    # -- External interface --------------------------------------------
-    # (called by outsiders)
-
-    def get_outputs(self):
-        """Return the list of files that would be installed if this command
-        were actually run.  Not affected by the "dry-run" flag or whether
-        modules have actually been built yet.
-        """
-        pure_outputs = \
-            self._mutate_outputs(self.distribution.has_pure_modules(),
-                                 'build_py', 'build_lib',
-                                 self.install_dir)
-        if self.compile:
-            bytecode_outputs = self._bytecode_filenames(pure_outputs)
-        else:
-            bytecode_outputs = []
-
-        ext_outputs = \
-            self._mutate_outputs(self.distribution.has_ext_modules(),
-                                 'build_ext', 'build_lib',
-                                 self.install_dir)
-
-        return pure_outputs + bytecode_outputs + ext_outputs
-
-    def get_inputs(self):
-        """Get the list of files that are input to this command, ie. the
-        files that get installed as they are named in the build tree.
-        The files in this list correspond one-to-one to the output
-        filenames returned by 'get_outputs()'.
-        """
-        inputs = []
-
-        if self.distribution.has_pure_modules():
-            build_py = self.get_finalized_command('build_py')
-            inputs.extend(build_py.get_outputs())
-
-        if self.distribution.has_ext_modules():
-            build_ext = self.get_finalized_command('build_ext')
-            inputs.extend(build_ext.get_outputs())
-
-        return inputs
diff --git a/Lib/distutils/command/install_scripts.py b/Lib/distutils/command/install_scripts.py
deleted file mode 100644
index 31a1130ee5..0000000000
--- a/Lib/distutils/command/install_scripts.py
+++ /dev/null
@@ -1,60 +0,0 @@
-"""distutils.command.install_scripts
-
-Implements the Distutils 'install_scripts' command, for installing
-Python scripts."""
-
-# contributed by Bastian Kleineidam
-
-import os
-from distutils.core import Command
-from distutils import log
-from stat import ST_MODE
-
-
-class install_scripts(Command):
-
-    description = "install scripts (Python or otherwise)"
-
-    user_options = [
-        ('install-dir=', 'd', "directory to install scripts to"),
-        ('build-dir=','b', "build directory (where to install from)"),
-        ('force', 'f', "force installation (overwrite existing files)"),
-        ('skip-build', None, "skip the build steps"),
-    ]
-
-    boolean_options = ['force', 'skip-build']
-
-    def initialize_options(self):
-        self.install_dir = None
-        self.force = 0
-        self.build_dir = None
-        self.skip_build = None
-
-    def finalize_options(self):
-        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
-        self.set_undefined_options('install',
-                                   ('install_scripts', 'install_dir'),
-                                   ('force', 'force'),
-                                   ('skip_build', 'skip_build'),
-                                  )
-
-    def run(self):
-        if not self.skip_build:
-            self.run_command('build_scripts')
-        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
-        if os.name == 'posix':
-            # Set the executable bits (owner, group, and world) on
-            # all the scripts we just installed.
-            for file in self.get_outputs():
-                if self.dry_run:
-                    log.info("changing mode of %s", file)
-                else:
-                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
-                    log.info("changing mode of %s to %o", file, mode)
-                    os.chmod(file, mode)
-
-    def get_inputs(self):
-        return self.distribution.scripts or []
-
-    def get_outputs(self):
-        return self.outfiles or []
diff --git a/Lib/distutils/command/register.py b/Lib/distutils/command/register.py
deleted file mode 100644
index 0fac94e9e5..0000000000
--- a/Lib/distutils/command/register.py
+++ /dev/null
@@ -1,304 +0,0 @@
-"""distutils.command.register
-
-Implements the Distutils 'register' command (register with the repository).
-"""
-
-# created 2002/10/21, Richard Jones
-
-import getpass
-import io
-import urllib.parse, urllib.request
-from warnings import warn
-
-from distutils.core import PyPIRCCommand
-from distutils.errors import *
-from distutils import log
-
-class register(PyPIRCCommand):
-
-    description = ("register the distribution with the Python package index")
-    user_options = PyPIRCCommand.user_options + [
-        ('list-classifiers', None,
-         'list the valid Trove classifiers'),
-        ('strict', None ,
-         'Will stop the registering if the meta-data are not fully compliant')
-        ]
-    boolean_options = PyPIRCCommand.boolean_options + [
-        'verify', 'list-classifiers', 'strict']
-
-    sub_commands = [('check', lambda self: True)]
-
-    def initialize_options(self):
-        PyPIRCCommand.initialize_options(self)
-        self.list_classifiers = 0
-        self.strict = 0
-
-    def finalize_options(self):
-        PyPIRCCommand.finalize_options(self)
-        # setting options for the `check` subcommand
-        check_options = {'strict': ('register', self.strict),
-                         'restructuredtext': ('register', 1)}
-        self.distribution.command_options['check'] = check_options
-
-    def run(self):
-        self.finalize_options()
-        self._set_config()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        if self.dry_run:
-            self.verify_metadata()
-        elif self.list_classifiers:
-            self.classifiers()
-        else:
-            self.send_metadata()
-
-    def check_metadata(self):
-        """Deprecated API."""
-        warn("distutils.command.register.check_metadata is deprecated, \
-              use the check command instead", PendingDeprecationWarning)
-        check = self.distribution.get_command_obj('check')
-        check.ensure_finalized()
-        check.strict = self.strict
-        check.restructuredtext = 1
-        check.run()
-
-    def _set_config(self):
-        ''' Reads the configuration file and set attributes.
-        '''
-        config = self._read_pypirc()
-        if config != {}:
-            self.username = config['username']
-            self.password = config['password']
-            self.repository = config['repository']
-            self.realm = config['realm']
-            self.has_config = True
-        else:
-            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
-                raise ValueError('%s not found in .pypirc' % self.repository)
-            if self.repository == 'pypi':
-                self.repository = self.DEFAULT_REPOSITORY
-            self.has_config = False
-
-    def classifiers(self):
-        ''' Fetch the list of classifiers from the server.
-        '''
-        url = self.repository+'?:action=list_classifiers'
-        response = urllib.request.urlopen(url)
-        log.info(self._read_pypi_response(response))
-
-    def verify_metadata(self):
-        ''' Send the metadata to the package index server to be checked.
-        '''
-        # send the info to the server and report the result
-        (code, result) = self.post_to_server(self.build_post_data('verify'))
-        log.info('Server response (%s): %s', code, result)
-
-    def send_metadata(self):
-        ''' Send the metadata to the package index server.
-
-            Well, do the following:
-            1. figure who the user is, and then
-            2. send the data as a Basic auth'ed POST.
-
-            First we try to read the username/password from $HOME/.pypirc,
-            which is a ConfigParser-formatted file with a section
-            [distutils] containing username and password entries (both
-            in clear text). Eg:
-
-                [distutils]
-                index-servers =
-                    pypi
-
-                [pypi]
-                username: fred
-                password: sekrit
-
-            Otherwise, to figure who the user is, we offer the user three
-            choices:
-
-             1. use existing login,
-             2. register as a new user, or
-             3. set the password to a random string and email the user.
-
-        '''
-        # see if we can short-cut and get the username/password from the
-        # config
-        if self.has_config:
-            choice = '1'
-            username = self.username
-            password = self.password
-        else:
-            choice = 'x'
-            username = password = ''
-
-        # get the user's login info
-        choices = '1 2 3 4'.split()
-        while choice not in choices:
-            self.announce('''\
-We need to know who you are, so please choose either:
- 1. use your existing login,
- 2. register as a new user,
- 3. have the server generate a new password for you (and email it to you), or
- 4. quit
-Your selection [default 1]: ''', log.INFO)
-            choice = input()
-            if not choice:
-                choice = '1'
-            elif choice not in choices:
-                print('Please choose one of the four options!')
-
-        if choice == '1':
-            # get the username and password
-            while not username:
-                username = input('Username: ')
-            while not password:
-                password = getpass.getpass('Password: ')
-
-            # set up the authentication
-            auth = urllib.request.HTTPPasswordMgr()
-            host = urllib.parse.urlparse(self.repository)[1]
-            auth.add_password(self.realm, host, username, password)
-            # send the info to the server and report the result
-            code, result = self.post_to_server(self.build_post_data('submit'),
-                auth)
-            self.announce('Server response (%s): %s' % (code, result),
-                          log.INFO)
-
-            # possibly save the login
-            if code == 200:
-                if self.has_config:
-                    # sharing the password in the distribution instance
-                    # so the upload command can reuse it
-                    self.distribution.password = password
-                else:
-                    self.announce(('I can store your PyPI login so future '
-                                   'submissions will be faster.'), log.INFO)
-                    self.announce('(the login will be stored in %s)' % \
-                                  self._get_rc_file(), log.INFO)
-                    choice = 'X'
-                    while choice.lower() not in 'yn':
-                        choice = input('Save your login (y/N)?')
-                        if not choice:
-                            choice = 'n'
-                    if choice.lower() == 'y':
-                        self._store_pypirc(username, password)
-
-        elif choice == '2':
-            data = {':action': 'user'}
-            data['name'] = data['password'] = data['email'] = ''
-            data['confirm'] = None
-            while not data['name']:
-                data['name'] = input('Username: ')
-            while data['password'] != data['confirm']:
-                while not data['password']:
-                    data['password'] = getpass.getpass('Password: ')
-                while not data['confirm']:
-                    data['confirm'] = getpass.getpass(' Confirm: ')
-                if data['password'] != data['confirm']:
-                    data['password'] = ''
-                    data['confirm'] = None
-                    print("Password and confirm don't match!")
-            while not data['email']:
-                data['email'] = input('   EMail: ')
-            code, result = self.post_to_server(data)
-            if code != 200:
-                log.info('Server response (%s): %s', code, result)
-            else:
-                log.info('You will receive an email shortly.')
-                log.info(('Follow the instructions in it to '
-                          'complete registration.'))
-        elif choice == '3':
-            data = {':action': 'password_reset'}
-            data['email'] = ''
-            while not data['email']:
-                data['email'] = input('Your email address: ')
-            code, result = self.post_to_server(data)
-            log.info('Server response (%s): %s', code, result)
-
-    def build_post_data(self, action):
-        # figure the data to send - the metadata plus some additional
-        # information used by the package server
-        meta = self.distribution.metadata
-        data = {
-            ':action': action,
-            'metadata_version' : '1.0',
-            'name': meta.get_name(),
-            'version': meta.get_version(),
-            'summary': meta.get_description(),
-            'home_page': meta.get_url(),
-            'author': meta.get_contact(),
-            'author_email': meta.get_contact_email(),
-            'license': meta.get_licence(),
-            'description': meta.get_long_description(),
-            'keywords': meta.get_keywords(),
-            'platform': meta.get_platforms(),
-            'classifiers': meta.get_classifiers(),
-            'download_url': meta.get_download_url(),
-            # PEP 314
-            'provides': meta.get_provides(),
-            'requires': meta.get_requires(),
-            'obsoletes': meta.get_obsoletes(),
-        }
-        if data['provides'] or data['requires'] or data['obsoletes']:
-            data['metadata_version'] = '1.1'
-        return data
-
-    def post_to_server(self, data, auth=None):
-        ''' Post a query to the server, and return a string response.
-        '''
-        if 'name' in data:
-            self.announce('Registering %s to %s' % (data['name'],
-                                                    self.repository),
-                                                    log.INFO)
-        # Build up the MIME payload for the urllib2 POST data
-        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = '\n--' + boundary
-        end_boundary = sep_boundary + '--'
-        body = io.StringIO()
-        for key, value in data.items():
-            # handle multiple entries for the same name
-            if type(value) not in (type([]), type( () )):
-                value = [value]
-            for value in value:
-                value = str(value)
-                body.write(sep_boundary)
-                body.write('\nContent-Disposition: form-data; name="%s"'%key)
-                body.write("\n\n")
-                body.write(value)
-                if value and value[-1] == '\r':
-                    body.write('\n')  # write an extra newline (lurve Macs)
-        body.write(end_boundary)
-        body.write("\n")
-        body = body.getvalue().encode("utf-8")
-
-        # build the Request
-        headers = {
-            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
-            'Content-length': str(len(body))
-        }
-        req = urllib.request.Request(self.repository, body, headers)
-
-        # handle HTTP and include the Basic Auth handler
-        opener = urllib.request.build_opener(
-            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
-        )
-        data = ''
-        try:
-            result = opener.open(req)
-        except urllib.error.HTTPError as e:
-            if self.show_response:
-                data = e.fp.read()
-            result = e.code, e.msg
-        except urllib.error.URLError as e:
-            result = 500, str(e)
-        else:
-            if self.show_response:
-                data = self._read_pypi_response(result)
-            result = 200, 'OK'
-        if self.show_response:
-            msg = '\n'.join(('-' * 75, data, '-' * 75))
-            self.announce(msg, log.INFO)
-        return result
diff --git a/Lib/distutils/command/sdist.py b/Lib/distutils/command/sdist.py
deleted file mode 100644
index 4fd1d4715d..0000000000
--- a/Lib/distutils/command/sdist.py
+++ /dev/null
@@ -1,456 +0,0 @@
-"""distutils.command.sdist
-
-Implements the Distutils 'sdist' command (create a source distribution)."""
-
-import os
-import sys
-from types import *
-from glob import glob
-from warnings import warn
-
-from distutils.core import Command
-from distutils import dir_util, dep_util, file_util, archive_util
-from distutils.text_file import TextFile
-from distutils.errors import *
-from distutils.filelist import FileList
-from distutils import log
-from distutils.util import convert_path
-
-def show_formats():
-    """Print all possible values for the 'formats' option (used by
-    the "--help-formats" command-line option).
-    """
-    from distutils.fancy_getopt import FancyGetopt
-    from distutils.archive_util import ARCHIVE_FORMATS
-    formats = []
-    for format in ARCHIVE_FORMATS.keys():
-        formats.append(("formats=" + format, None,
-                        ARCHIVE_FORMATS[format][2]))
-    formats.sort()
-    FancyGetopt(formats).print_help(
-        "List of available source distribution formats:")
-
-class sdist(Command):
-
-    description = "create a source distribution (tarball, zip file, etc.)"
-
-    def checking_metadata(self):
-        """Callable used for the check sub-command.
-
-        Placed here so user_options can view it"""
-        return self.metadata_check
-
-    user_options = [
-        ('template=', 't',
-         "name of manifest template file [default: MANIFEST.in]"),
-        ('manifest=', 'm',
-         "name of manifest file [default: MANIFEST]"),
-        ('use-defaults', None,
-         "include the default file set in the manifest "
-         "[default; disable with --no-defaults]"),
-        ('no-defaults', None,
-         "don't include the default file set"),
-        ('prune', None,
-         "specifically exclude files/directories that should not be "
-         "distributed (build tree, RCS/CVS dirs, etc.) "
-         "[default; disable with --no-prune]"),
-        ('no-prune', None,
-         "don't automatically exclude anything"),
-        ('manifest-only', 'o',
-         "just regenerate the manifest and then stop "
-         "(implies --force-manifest)"),
-        ('force-manifest', 'f',
-         "forcibly regenerate the manifest and carry on as usual. "
-         "Deprecated: now the manifest is always regenerated."),
-        ('formats=', None,
-         "formats for source distribution (comma-separated list)"),
-        ('keep-temp', 'k',
-         "keep the distribution tree around after creating " +
-         "archive file(s)"),
-        ('dist-dir=', 'd',
-         "directory to put the source distribution archive(s) in "
-         "[default: dist]"),
-        ('metadata-check', None,
-         "Ensure that all required elements of meta-data "
-         "are supplied. Warn if any missing. [default]"),
-        ('owner=', 'u',
-         "Owner name used when creating a tar file [default: current user]"),
-        ('group=', 'g',
-         "Group name used when creating a tar file [default: current group]"),
-        ]
-
-    boolean_options = ['use-defaults', 'prune',
-                       'manifest-only', 'force-manifest',
-                       'keep-temp', 'metadata-check']
-
-    help_options = [
-        ('help-formats', None,
-         "list available distribution formats", show_formats),
-        ]
-
-    negative_opt = {'no-defaults': 'use-defaults',
-                    'no-prune': 'prune' }
-
-    sub_commands = [('check', checking_metadata)]
-
-    def initialize_options(self):
-        # 'template' and 'manifest' are, respectively, the names of
-        # the manifest template and manifest file.
-        self.template = None
-        self.manifest = None
-
-        # 'use_defaults': if true, we will include the default file set
-        # in the manifest
-        self.use_defaults = 1
-        self.prune = 1
-
-        self.manifest_only = 0
-        self.force_manifest = 0
-
-        self.formats = ['gztar']
-        self.keep_temp = 0
-        self.dist_dir = None
-
-        self.archive_files = None
-        self.metadata_check = 1
-        self.owner = None
-        self.group = None
-
-    def finalize_options(self):
-        if self.manifest is None:
-            self.manifest = "MANIFEST"
-        if self.template is None:
-            self.template = "MANIFEST.in"
-
-        self.ensure_string_list('formats')
-
-        bad_format = archive_util.check_archive_formats(self.formats)
-        if bad_format:
-            raise DistutilsOptionError(
-                  "unknown archive format '%s'" % bad_format)
-
-        if self.dist_dir is None:
-            self.dist_dir = "dist"
-
-    def run(self):
-        # 'filelist' contains the list of files that will make up the
-        # manifest
-        self.filelist = FileList()
-
-        # Run sub commands
-        for cmd_name in self.get_sub_commands():
-            self.run_command(cmd_name)
-
-        # Do whatever it takes to get the list of files to process
-        # (process the manifest template, read an existing manifest,
-        # whatever).  File list is accumulated in 'self.filelist'.
-        self.get_file_list()
-
-        # If user just wanted us to regenerate the manifest, stop now.
-        if self.manifest_only:
-            return
-
-        # Otherwise, go ahead and create the source distribution tarball,
-        # or zipfile, or whatever.
-        self.make_distribution()
-
-    def check_metadata(self):
-        """Deprecated API."""
-        warn("distutils.command.sdist.check_metadata is deprecated, \
-              use the check command instead", PendingDeprecationWarning)
-        check = self.distribution.get_command_obj('check')
-        check.ensure_finalized()
-        check.run()
-
-    def get_file_list(self):
-        """Figure out the list of files to include in the source
-        distribution, and put it in 'self.filelist'.  This might involve
-        reading the manifest template (and writing the manifest), or just
-        reading the manifest, or just using the default file set -- it all
-        depends on the user's options.
-        """
-        # new behavior when using a template:
-        # the file list is recalculated every time because
-        # even if MANIFEST.in or setup.py are not changed
-        # the user might have added some files in the tree that
-        # need to be included.
-        #
-        #  This makes --force the default and only behavior with templates.
-        template_exists = os.path.isfile(self.template)
-        if not template_exists and self._manifest_is_not_generated():
-            self.read_manifest()
-            self.filelist.sort()
-            self.filelist.remove_duplicates()
-            return
-
-        if not template_exists:
-            self.warn(("manifest template '%s' does not exist " +
-                        "(using default file list)") %
-                        self.template)
-        self.filelist.findall()
-
-        if self.use_defaults:
-            self.add_defaults()
-
-        if template_exists:
-            self.read_template()
-
-        if self.prune:
-            self.prune_file_list()
-
-        self.filelist.sort()
-        self.filelist.remove_duplicates()
-        self.write_manifest()
-
-    def add_defaults(self):
-        """Add all the default files to self.filelist:
-          - README or README.txt
-          - setup.py
-          - test/test*.py
-          - all pure Python modules mentioned in setup script
-          - all files pointed by package_data (build_py)
-          - all files defined in data_files.
-          - all files defined as scripts.
-          - all C sources listed as part of extensions or C libraries
-            in the setup script (doesn't catch C headers!)
-        Warns if (README or README.txt) or setup.py are missing; everything
-        else is optional.
-        """
-        standards = [('README', 'README.txt'), self.distribution.script_name]
-        for fn in standards:
-            if isinstance(fn, tuple):
-                alts = fn
-                got_it = False
-                for fn in alts:
-                    if os.path.exists(fn):
-                        got_it = True
-                        self.filelist.append(fn)
-                        break
-
-                if not got_it:
-                    self.warn("standard file not found: should have one of " +
-                              ', '.join(alts))
-            else:
-                if os.path.exists(fn):
-                    self.filelist.append(fn)
-                else:
-                    self.warn("standard file '%s' not found" % fn)
-
-        optional = ['test/test*.py', 'setup.cfg']
-        for pattern in optional:
-            files = filter(os.path.isfile, glob(pattern))
-            self.filelist.extend(files)
-
-        # build_py is used to get:
-        #  - python modules
-        #  - files defined in package_data
-        build_py = self.get_finalized_command('build_py')
-
-        # getting python files
-        if self.distribution.has_pure_modules():
-            self.filelist.extend(build_py.get_source_files())
-
-        # getting package_data files
-        # (computed in build_py.data_files by build_py.finalize_options)
-        for pkg, src_dir, build_dir, filenames in build_py.data_files:
-            for filename in filenames:
-                self.filelist.append(os.path.join(src_dir, filename))
-
-        # getting distribution.data_files
-        if self.distribution.has_data_files():
-            for item in self.distribution.data_files:
-                if isinstance(item, str): # plain file
-                    item = convert_path(item)
-                    if os.path.isfile(item):
-                        self.filelist.append(item)
-                else:    # a (dirname, filenames) tuple
-                    dirname, filenames = item
-                    for f in filenames:
-                        f = convert_path(f)
-                        if os.path.isfile(f):
-                            self.filelist.append(f)
-
-        if self.distribution.has_ext_modules():
-            build_ext = self.get_finalized_command('build_ext')
-            self.filelist.extend(build_ext.get_source_files())
-
-        if self.distribution.has_c_libraries():
-            build_clib = self.get_finalized_command('build_clib')
-            self.filelist.extend(build_clib.get_source_files())
-
-        if self.distribution.has_scripts():
-            build_scripts = self.get_finalized_command('build_scripts')
-            self.filelist.extend(build_scripts.get_source_files())
-
-    def read_template(self):
-        """Read and parse manifest template file named by self.template.
-
-        (usually "MANIFEST.in") The parsing and processing is done by
-        'self.filelist', which updates itself accordingly.
-        """
-        log.info("reading manifest template '%s'", self.template)
-        template = TextFile(self.template, strip_comments=1, skip_blanks=1,
-                            join_lines=1, lstrip_ws=1, rstrip_ws=1,
-                            collapse_join=1)
-
-        try:
-            while True:
-                line = template.readline()
-                if line is None:            # end of file
-                    break
-
-                try:
-                    self.filelist.process_template_line(line)
-                # the call above can raise a DistutilsTemplateError for
-                # malformed lines, or a ValueError from the lower-level
-                # convert_path function
-                except (DistutilsTemplateError, ValueError) as msg:
-                    self.warn("%s, line %d: %s" % (template.filename,
-                                                   template.current_line,
-                                                   msg))
-        finally:
-            template.close()
-
-    def prune_file_list(self):
-        """Prune off branches that might slip into the file list as created
-        by 'read_template()', but really don't belong there:
-          * the build tree (typically "build")
-          * the release tree itself (only an issue if we ran "sdist"
-            previously with --keep-temp, or it aborted)
-          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
-        """
-        build = self.get_finalized_command('build')
-        base_dir = self.distribution.get_fullname()
-
-        self.filelist.exclude_pattern(None, prefix=build.build_base)
-        self.filelist.exclude_pattern(None, prefix=base_dir)
-
-        if sys.platform == 'win32':
-            seps = r'/|\\'
-        else:
-            seps = '/'
-
-        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
-                    '_darcs']
-        vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
-        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)
-
-    def write_manifest(self):
-        """Write the file list in 'self.filelist' (presumably as filled in
-        by 'add_defaults()' and 'read_template()') to the manifest file
-        named by 'self.manifest'.
-        """
-        if self._manifest_is_not_generated():
-            log.info("not writing to manually maintained "
-                     "manifest file '%s'" % self.manifest)
-            return
-
-        content = self.filelist.files[:]
-        content.insert(0, '# file GENERATED by distutils, do NOT edit')
-        self.execute(file_util.write_file, (self.manifest, content),
-                     "writing manifest file '%s'" % self.manifest)
-
-    def _manifest_is_not_generated(self):
-        # check for special comment used in 3.1.3 and higher
-        if not os.path.isfile(self.manifest):
-            return False
-
-        fp = open(self.manifest)
-        try:
-            first_line = fp.readline()
-        finally:
-            fp.close()
-        return first_line != '# file GENERATED by distutils, do NOT edit\n'
-
-    def read_manifest(self):
-        """Read the manifest file (named by 'self.manifest') and use it to
-        fill in 'self.filelist', the list of files to include in the source
-        distribution.
-        """
-        log.info("reading manifest file '%s'", self.manifest)
-        manifest = open(self.manifest)
-        for line in manifest:
-            # ignore comments and blank lines
-            line = line.strip()
-            if line.startswith('#') or not line:
-                continue
-            self.filelist.append(line)
-        manifest.close()
-
-    def make_release_tree(self, base_dir, files):
-        """Create the directory tree that will become the source
-        distribution archive.  All directories implied by the filenames in
-        'files' are created under 'base_dir', and then we hard link or copy
-        (if hard linking is unavailable) those files into place.
-        Essentially, this duplicates the developer's source tree, but in a
-        directory named after the distribution, containing only the files
-        to be distributed.
-        """
-        # Create all the directories under 'base_dir' necessary to
-        # put 'files' there; the 'mkpath()' is just so we don't die
-        # if the manifest happens to be empty.
-        self.mkpath(base_dir)
-        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)
-
-        # And walk over the list of files, either making a hard link (if
-        # os.link exists) to each one that doesn't already exist in its
-        # corresponding location under 'base_dir', or copying each file
-        # that's out-of-date in 'base_dir'.  (Usually, all files will be
-        # out-of-date, because by default we blow away 'base_dir' when
-        # we're done making the distribution archives.)
-
-        if hasattr(os, 'link'):        # can make hard links on this system
-            link = 'hard'
-            msg = "making hard links in %s..." % base_dir
-        else:                           # nope, have to copy
-            link = None
-            msg = "copying files to %s..." % base_dir
-
-        if not files:
-            log.warn("no files to distribute -- empty manifest?")
-        else:
-            log.info(msg)
-        for file in files:
-            if not os.path.isfile(file):
-                log.warn("'%s' not a regular file -- skipping", file)
-            else:
-                dest = os.path.join(base_dir, file)
-                self.copy_file(file, dest, link=link)
-
-        self.distribution.metadata.write_pkg_info(base_dir)
-
-    def make_distribution(self):
-        """Create the source distribution(s).  First, we create the release
-        tree with 'make_release_tree()'; then, we create all required
-        archive files (according to 'self.formats') from the release tree.
-        Finally, we clean up by blowing away the release tree (unless
-        'self.keep_temp' is true).  The list of archive files created is
-        stored so it can be retrieved later by 'get_archive_files()'.
-        """
-        # Don't warn about missing meta-data here -- should be (and is!)
-        # done elsewhere.
-        base_dir = self.distribution.get_fullname()
-        base_name = os.path.join(self.dist_dir, base_dir)
-
-        self.make_release_tree(base_dir, self.filelist.files)
-        archive_files = []              # remember names of files we create
-        # tar archive must be created last to avoid overwrite and remove
-        if 'tar' in self.formats:
-            self.formats.append(self.formats.pop(self.formats.index('tar')))
-
-        for fmt in self.formats:
-            file = self.make_archive(base_name, fmt, base_dir=base_dir,
-                                     owner=self.owner, group=self.group)
-            archive_files.append(file)
-            self.distribution.dist_files.append(('sdist', '', file))
-
-        self.archive_files = archive_files
-
-        if not self.keep_temp:
-            dir_util.remove_tree(base_dir, dry_run=self.dry_run)
-
-    def get_archive_files(self):
-        """Return the list of archive files created when the command
-        was run, or None if the command hasn't run yet.
-        """
-        return self.archive_files
diff --git a/Lib/distutils/command/upload.py b/Lib/distutils/command/upload.py
deleted file mode 100644
index 32dda359ba..0000000000
--- a/Lib/distutils/command/upload.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""
-distutils.command.upload
-
-Implements the Distutils 'upload' subcommand (upload package to a package
-index).
-"""
-
-import os
-import io
-import platform
-import hashlib
-from base64 import standard_b64encode
-from urllib.request import urlopen, Request, HTTPError
-from urllib.parse import urlparse
-from distutils.errors import DistutilsError, DistutilsOptionError
-from distutils.core import PyPIRCCommand
-from distutils.spawn import spawn
-from distutils import log
-
-class upload(PyPIRCCommand):
-
-    description = "upload binary package to PyPI"
-
-    user_options = PyPIRCCommand.user_options + [
-        ('sign', 's',
-         'sign files to upload using gpg'),
-        ('identity=', 'i', 'GPG identity used to sign files'),
-        ]
-
-    boolean_options = PyPIRCCommand.boolean_options + ['sign']
-
-    def initialize_options(self):
-        PyPIRCCommand.initialize_options(self)
-        self.username = ''
-        self.password = ''
-        self.show_response = 0
-        self.sign = False
-        self.identity = None
-
-    def finalize_options(self):
-        PyPIRCCommand.finalize_options(self)
-        if self.identity and not self.sign:
-            raise DistutilsOptionError(
-                "Must use --sign for --identity to have meaning"
-            )
-        config = self._read_pypirc()
-        if config != {}:
-            self.username = config['username']
-            self.password = config['password']
-            self.repository = config['repository']
-            self.realm = config['realm']
-
-        # getting the password from the distribution
-        # if previously set by the register command
-        if not self.password and self.distribution.password:
-            self.password = self.distribution.password
-
-    def run(self):
-        if not self.distribution.dist_files:
-            msg = ("Must create and upload files in one command "
-                   "(e.g. setup.py sdist upload)")
-            raise DistutilsOptionError(msg)
-        for command, pyversion, filename in self.distribution.dist_files:
-            self.upload_file(command, pyversion, filename)
-
-    def upload_file(self, command, pyversion, filename):
-        # Makes sure the repository URL is compliant
-        schema, netloc, url, params, query, fragments = \
-            urlparse(self.repository)
-        if params or query or fragments:
-            raise AssertionError("Incompatible url %s" % self.repository)
-
-        if schema not in ('http', 'https'):
-            raise AssertionError("unsupported schema " + schema)
-
-        # Sign if requested
-        if self.sign:
-            gpg_args = ["gpg", "--detach-sign", "-a", filename]
-            if self.identity:
-                gpg_args[2:2] = ["--local-user", self.identity]
-            spawn(gpg_args,
-                  dry_run=self.dry_run)
-
-        # Fill in the data - send all the meta-data in case we need to
-        # register a new release
-        f = open(filename,'rb')
-        try:
-            content = f.read()
-        finally:
-            f.close()
-        meta = self.distribution.metadata
-        data = {
-            # action
-            ':action': 'file_upload',
-            'protocol_version': '1',
-
-            # identify release
-            'name': meta.get_name(),
-            'version': meta.get_version(),
-
-            # file content
-            'content': (os.path.basename(filename),content),
-            'filetype': command,
-            'pyversion': pyversion,
-            'md5_digest': hashlib.md5(content).hexdigest(),
-
-            # additional meta-data
-            'metadata_version': '1.0',
-            'summary': meta.get_description(),
-            'home_page': meta.get_url(),
-            'author': meta.get_contact(),
-            'author_email': meta.get_contact_email(),
-            'license': meta.get_licence(),
-            'description': meta.get_long_description(),
-            'keywords': meta.get_keywords(),
-            'platform': meta.get_platforms(),
-            'classifiers': meta.get_classifiers(),
-            'download_url': meta.get_download_url(),
-            # PEP 314
-            'provides': meta.get_provides(),
-            'requires': meta.get_requires(),
-            'obsoletes': meta.get_obsoletes(),
-            }
-        comment = ''
-        if command == 'bdist_rpm':
-            dist, version, id = platform.dist()
-            if dist:
-                comment = 'built for %s %s' % (dist, version)
-        elif command == 'bdist_dumb':
-            comment = 'built for %s' % platform.platform(terse=1)
-        data['comment'] = comment
-
-        if self.sign:
-            data['gpg_signature'] = (os.path.basename(filename) + ".asc",
-                                     open(filename+".asc", "rb").read())
-
-        # set up the authentication
-        user_pass = (self.username + ":" + self.password).encode('ascii')
-        # The exact encoding of the authentication string is debated.
-        # Anyway PyPI only accepts ascii for both username or password.
-        auth = "Basic " + standard_b64encode(user_pass).decode('ascii')
-
-        # Build up the MIME payload for the POST data
-        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
-        sep_boundary = b'\r\n--' + boundary.encode('ascii')
-        end_boundary = sep_boundary + b'--\r\n'
-        body = io.BytesIO()
-        for key, value in data.items():
-            title = '\r\nContent-Disposition: form-data; name="%s"' % key
-            # handle multiple entries for the same name
-            if not isinstance(value, list):
-                value = [value]
-            for value in value:
-                if type(value) is tuple:
-                    title += '; filename="%s"' % value[0]
-                    value = value[1]
-                else:
-                    value = str(value).encode('utf-8')
-                body.write(sep_boundary)
-                body.write(title.encode('utf-8'))
-                body.write(b"\r\n\r\n")
-                body.write(value)
-        body.write(end_boundary)
-        body = body.getvalue()
-
-        msg = "Submitting %s to %s" % (filename, self.repository)
-        self.announce(msg, log.INFO)
-
-        # build the Request
-        headers = {
-            'Content-type': 'multipart/form-data; boundary=%s' % boundary,
-            'Content-length': str(len(body)),
-            'Authorization': auth,
-        }
-
-        request = Request(self.repository, data=body,
-                          headers=headers)
-        # send the data
-        try:
-            result = urlopen(request)
-            status = result.getcode()
-            reason = result.msg
-        except HTTPError as e:
-            status = e.code
-            reason = e.msg
-        except OSError as e:
-            self.announce(str(e), log.ERROR)
-            raise
-
-        if status == 200:
-            self.announce('Server response (%s): %s' % (status, reason),
-                          log.INFO)
-            if self.show_response:
-                text = self._read_pypi_response(result)
-                msg = '\n'.join(('-' * 75, text, '-' * 75))
-                self.announce(msg, log.INFO)
-        else:
-            msg = 'Upload failed (%s): %s' % (status, reason)
-            self.announce(msg, log.ERROR)
-            raise DistutilsError(msg)
diff --git a/Lib/distutils/config.py b/Lib/distutils/config.py
deleted file mode 100644
index bf8d8dd2f5..0000000000
--- a/Lib/distutils/config.py
+++ /dev/null
@@ -1,131 +0,0 @@
-"""distutils.pypirc
-
-Provides the PyPIRCCommand class, the base class for the command classes
-that uses .pypirc in the distutils.command package.
-"""
-import os
-from configparser import RawConfigParser
-
-from distutils.cmd import Command
-
-DEFAULT_PYPIRC = """\
-[distutils]
-index-servers =
-    pypi
-
-[pypi]
-username:%s
-password:%s
-"""
-
-class PyPIRCCommand(Command):
-    """Base command that knows how to handle the .pypirc file
-    """
-    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
-    DEFAULT_REALM = 'pypi'
-    repository = None
-    realm = None
-
-    user_options = [
-        ('repository=', 'r',
-         "url of repository [default: %s]" % \
-            DEFAULT_REPOSITORY),
-        ('show-response', None,
-         'display full response text from server')]
-
-    boolean_options = ['show-response']
-
-    def _get_rc_file(self):
-        """Returns rc file path."""
-        return os.path.join(os.path.expanduser('~'), '.pypirc')
-
-    def _store_pypirc(self, username, password):
-        """Creates a default .pypirc file."""
-        rc = self._get_rc_file()
-        with os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0o600), 'w') as f:
-            f.write(DEFAULT_PYPIRC % (username, password))
-
-    def _read_pypirc(self):
-        """Reads the .pypirc file."""
-        rc = self._get_rc_file()
-        if os.path.exists(rc):
-            self.announce('Using PyPI login from %s' % rc)
-            repository = self.repository or self.DEFAULT_REPOSITORY
-            realm = self.realm or self.DEFAULT_REALM
-
-            config = RawConfigParser()
-            config.read(rc)
-            sections = config.sections()
-            if 'distutils' in sections:
-                # let's get the list of servers
-                index_servers = config.get('distutils', 'index-servers')
-                _servers = [server.strip() for server in
-                            index_servers.split('\n')
-                            if server.strip() != '']
-                if _servers == []:
-                    # nothing set, let's try to get the default pypi
-                    if 'pypi' in sections:
-                        _servers = ['pypi']
-                    else:
-                        # the file is not properly defined, returning
-                        # an empty dict
-                        return {}
-                for server in _servers:
-                    current = {'server': server}
-                    current['username'] = config.get(server, 'username')
-
-                    # optional params
-                    for key, default in (('repository',
-                                          self.DEFAULT_REPOSITORY),
-                                         ('realm', self.DEFAULT_REALM),
-                                         ('password', None)):
-                        if config.has_option(server, key):
-                            current[key] = config.get(server, key)
-                        else:
-                            current[key] = default
-
-                    # work around people having "repository" for the "pypi"
-                    # section of their config set to the HTTP (rather than
-                    # HTTPS) URL
-                    if (server == 'pypi' and
-                        repository in (self.DEFAULT_REPOSITORY, 'pypi')):
-                        current['repository'] = self.DEFAULT_REPOSITORY
-                        return current
-
-                    if (current['server'] == repository or
-                        current['repository'] == repository):
-                        return current
-            elif 'server-login' in sections:
-                # old format
-                server = 'server-login'
-                if config.has_option(server, 'repository'):
-                    repository = config.get(server, 'repository')
-                else:
-                    repository = self.DEFAULT_REPOSITORY
-                return {'username': config.get(server, 'username'),
-                        'password': config.get(server, 'password'),
-                        'repository': repository,
-                        'server': server,
-                        'realm': self.DEFAULT_REALM}
-
-        return {}
-
-    def _read_pypi_response(self, response):
-        """Read and decode a PyPI HTTP response."""
-        import cgi
-        content_type = response.getheader('content-type', 'text/plain')
-        encoding = cgi.parse_header(content_type)[1].get('charset', 'ascii')
-        return response.read().decode(encoding)
-
-    def initialize_options(self):
-        """Initialize options."""
-        self.repository = None
-        self.realm = None
-        self.show_response = 0
-
-    def finalize_options(self):
-        """Finalizes options."""
-        if self.repository is None:
-            self.repository = self.DEFAULT_REPOSITORY
-        if self.realm is None:
-            self.realm = self.DEFAULT_REALM
diff --git a/Lib/distutils/core.py b/Lib/distutils/core.py
deleted file mode 100644
index d603d4a45a..0000000000
--- a/Lib/distutils/core.py
+++ /dev/null
@@ -1,234 +0,0 @@
-"""distutils.core
-
-The only module that needs to be imported to use the Distutils; provides
-the 'setup' function (which is to be called from the setup script).  Also
-indirectly provides the Distribution and Command classes, although they are
-really defined in distutils.dist and distutils.cmd.
-"""
-
-import os
-import sys
-
-from distutils.debug import DEBUG
-from distutils.errors import *
-
-# Mainly import these so setup scripts can "from distutils.core import" them.
-from distutils.dist import Distribution
-from distutils.cmd import Command
-from distutils.config import PyPIRCCommand
-from distutils.extension import Extension
-
-# This is a barebones help message generated displayed when the user
-# runs the setup script with no arguments at all.  More useful help
-# is generated with various --help options: global help, list commands,
-# and per-command help.
-USAGE = """\
-usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
-   or: %(script)s --help [cmd1 cmd2 ...]
-   or: %(script)s --help-commands
-   or: %(script)s cmd --help
-"""
-
-def gen_usage (script_name):
-    script = os.path.basename(script_name)
-    return USAGE % vars()
-
-
-# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
-_setup_stop_after = None
-_setup_distribution = None
-
-# Legal keyword arguments for the setup() function
-setup_keywords = ('distclass', 'script_name', 'script_args', 'options',
-                  'name', 'version', 'author', 'author_email',
-                  'maintainer', 'maintainer_email', 'url', 'license',
-                  'description', 'long_description', 'keywords',
-                  'platforms', 'classifiers', 'download_url',
-                  'requires', 'provides', 'obsoletes',
-                  )
-
-# Legal keyword arguments for the Extension constructor
-extension_keywords = ('name', 'sources', 'include_dirs',
-                      'define_macros', 'undef_macros',
-                      'library_dirs', 'libraries', 'runtime_library_dirs',
-                      'extra_objects', 'extra_compile_args', 'extra_link_args',
-                      'swig_opts', 'export_symbols', 'depends', 'language')
-
-def setup (**attrs):
-    """The gateway to the Distutils: do everything your setup script needs
-    to do, in a highly flexible and user-driven way.  Briefly: create a
-    Distribution instance; find and parse config files; parse the command
-    line; run each Distutils command found there, customized by the options
-    supplied to 'setup()' (as keyword arguments), in config files, and on
-    the command line.
-
-    The Distribution instance might be an instance of a class supplied via
-    the 'distclass' keyword argument to 'setup'; if no such class is
-    supplied, then the Distribution class (in dist.py) is instantiated.
-    All other arguments to 'setup' (except for 'cmdclass') are used to set
-    attributes of the Distribution instance.
-
-    The 'cmdclass' argument, if supplied, is a dictionary mapping command
-    names to command classes.  Each command encountered on the command line
-    will be turned into a command class, which is in turn instantiated; any
-    class found in 'cmdclass' is used in place of the default, which is
-    (for command 'foo_bar') class 'foo_bar' in module
-    'distutils.command.foo_bar'.  The command class must provide a
-    'user_options' attribute which is a list of option specifiers for
-    'distutils.fancy_getopt'.  Any command-line options between the current
-    and the next command are used to set attributes of the current command
-    object.
-
-    When the entire command-line has been successfully parsed, calls the
-    'run()' method on each command object in turn.  This method will be
-    driven entirely by the Distribution object (which each command object
-    has a reference to, thanks to its constructor), and the
-    command-specific options that became attributes of each command
-    object.
-    """
-
-    global _setup_stop_after, _setup_distribution
-
-    # Determine the distribution class -- either caller-supplied or
-    # our Distribution (see below).
-    klass = attrs.get('distclass')
-    if klass:
-        del attrs['distclass']
-    else:
-        klass = Distribution
-
-    if 'script_name' not in attrs:
-        attrs['script_name'] = os.path.basename(sys.argv[0])
-    if 'script_args'  not in attrs:
-        attrs['script_args'] = sys.argv[1:]
-
-    # Create the Distribution instance, using the remaining arguments
-    # (ie. everything except distclass) to initialize it
-    try:
-        _setup_distribution = dist = klass(attrs)
-    except DistutilsSetupError as msg:
-        if 'name' not in attrs:
-            raise SystemExit("error in setup command: %s" % msg)
-        else:
-            raise SystemExit("error in %s setup command: %s" % \
-                  (attrs['name'], msg))
-
-    if _setup_stop_after == "init":
-        return dist
-
-    # Find and parse the config file(s): they will override options from
-    # the setup script, but be overridden by the command line.
-    dist.parse_config_files()
-
-    if DEBUG:
-        print("options (after parsing config files):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "config":
-        return dist
-
-    # Parse the command line and override config files; any
-    # command-line errors are the end user's fault, so turn them into
-    # SystemExit to suppress tracebacks.
-    try:
-        ok = dist.parse_command_line()
-    except DistutilsArgError as msg:
-        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)
-
-    if DEBUG:
-        print("options (after parsing command line):")
-        dist.dump_option_dicts()
-
-    if _setup_stop_after == "commandline":
-        return dist
-
-    # And finally, run all the commands found on the command line.
-    if ok:
-        try:
-            dist.run_commands()
-        except KeyboardInterrupt:
-            raise SystemExit("interrupted")
-        except OSError as exc:
-            if DEBUG:
-                sys.stderr.write("error: %s\n" % (exc,))
-                raise
-            else:
-                raise SystemExit("error: %s" % (exc,))
-
-        except (DistutilsError,
-                CCompilerError) as msg:
-            if DEBUG:
-                raise
-            else:
-                raise SystemExit("error: " + str(msg))
-
-    return dist
-
-# setup ()
-
-
-def run_setup (script_name, script_args=None, stop_after="run"):
-    """Run a setup script in a somewhat controlled environment, and
-    return the Distribution instance that drives things.  This is useful
-    if you need to find out the distribution meta-data (passed as
-    keyword args from 'script' to 'setup()', or the contents of the
-    config files or command-line.
-
-    'script_name' is a file that will be read and run with 'exec()';
-    'sys.argv[0]' will be replaced with 'script' for the duration of the
-    call.  'script_args' is a list of strings; if supplied,
-    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
-    the call.
-
-    'stop_after' tells 'setup()' when to stop processing; possible
-    values:
-      init
-        stop after the Distribution instance has been created and
-        populated with the keyword arguments to 'setup()'
-      config
-        stop after config files have been parsed (and their data
-        stored in the Distribution instance)
-      commandline
-        stop after the command-line ('sys.argv[1:]' or 'script_args')
-        have been parsed (and the data stored in the Distribution)
-      run [default]
-        stop after all commands have been run (the same as if 'setup()'
-        had been called in the usual way
-
-    Returns the Distribution instance, which provides all information
-    used to drive the Distutils.
-    """
-    if stop_after not in ('init', 'config', 'commandline', 'run'):
-        raise ValueError("invalid value for 'stop_after': %r" % (stop_after,))
-
-    global _setup_stop_after, _setup_distribution
-    _setup_stop_after = stop_after
-
-    save_argv = sys.argv.copy()
-    g = {'__file__': script_name}
-    try:
-        try:
-            sys.argv[0] = script_name
-            if script_args is not None:
-                sys.argv[1:] = script_args
-            with open(script_name, 'rb') as f:
-                exec(f.read(), g)
-        finally:
-            sys.argv = save_argv
-            _setup_stop_after = None
-    except SystemExit:
-        # Hmm, should we do something if exiting with a non-zero code
-        # (ie. error)?
-        pass
-
-    if _setup_distribution is None:
-        raise RuntimeError(("'distutils.core.setup()' was never called -- "
-               "perhaps '%s' is not a Distutils setup script?") % \
-              script_name)
-
-    # I wonder if the setup script's namespace -- g and l -- would be of
-    # any interest to callers?
-    #print "_setup_distribution:", _setup_distribution
-    return _setup_distribution
-
-# run_setup ()
diff --git a/Lib/distutils/cygwinccompiler.py b/Lib/distutils/cygwinccompiler.py
deleted file mode 100644
index 1c36990347..0000000000
--- a/Lib/distutils/cygwinccompiler.py
+++ /dev/null
@@ -1,405 +0,0 @@
-"""distutils.cygwinccompiler
-
-Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
-handles the Cygwin port of the GNU C compiler to Windows.  It also contains
-the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
-cygwin in no-cygwin mode).
-"""
-
-# problems:
-#
-# * if you use a msvc compiled python version (1.5.2)
-#   1. you have to insert a __GNUC__ section in its config.h
-#   2. you have to generate an import library for its dll
-#      - create a def-file for python??.dll
-#      - create an import library using
-#             dlltool --dllname python15.dll --def python15.def \
-#                       --output-lib libpython15.a
-#
-#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
-#
-# * We put export_symbols in a def-file, and don't use
-#   --export-all-symbols because it doesn't worked reliable in some
-#   tested configurations. And because other windows compilers also
-#   need their symbols specified this no serious problem.
-#
-# tested configurations:
-#
-# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
-#   (after patching python's config.h and for C++ some other include files)
-#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
-# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
-#   (ld doesn't support -shared, so we use dllwrap)
-# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
-#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
-#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
-#   - using gcc -mdll instead dllwrap doesn't work without -static because
-#     it tries to link against dlls instead their import libraries. (If
-#     it finds the dll first.)
-#     By specifying -static we force ld to link against the import libraries,
-#     this is windows standard and there are normally not the necessary symbols
-#     in the dlls.
-#   *** only the version of June 2000 shows these problems
-# * cygwin gcc 3.2/ld 2.13.90 works
-#   (ld supports -shared)
-# * mingw gcc 3.2/ld 2.13 works
-#   (ld supports -shared)
-
-import os
-import sys
-import copy
-from subprocess import Popen, PIPE, check_output
-import re
-
-from distutils.ccompiler import gen_preprocess_options, gen_lib_options
-from distutils.unixccompiler import UnixCCompiler
-from distutils.file_util import write_file
-from distutils.errors import (DistutilsExecError, CCompilerError,
-        CompileError, UnknownFileError)
-from distutils import log
-from distutils.version import LooseVersion
-from distutils.spawn import find_executable
-
-def get_msvcr():
-    """Include the appropriate MSVC runtime library if Python was built
-    with MSVC 7.0 or later.
-    """
-    msc_pos = sys.version.find('MSC v.')
-    if msc_pos != -1:
-        msc_ver = sys.version[msc_pos+6:msc_pos+10]
-        if msc_ver == '1300':
-            # MSVC 7.0
-            return ['msvcr70']
-        elif msc_ver == '1310':
-            # MSVC 7.1
-            return ['msvcr71']
-        elif msc_ver == '1400':
-            # VS2005 / MSVC 8.0
-            return ['msvcr80']
-        elif msc_ver == '1500':
-            # VS2008 / MSVC 9.0
-            return ['msvcr90']
-        elif msc_ver == '1600':
-            # VS2010 / MSVC 10.0
-            return ['msvcr100']
-        else:
-            raise ValueError("Unknown MS Compiler version %s " % msc_ver)
-
-
-class CygwinCCompiler(UnixCCompiler):
-    """ Handles the Cygwin port of the GNU C compiler to Windows.
-    """
-    compiler_type = 'cygwin'
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".dll"
-    static_lib_format = "lib%s%s"
-    shared_lib_format = "%s%s"
-    exe_extension = ".exe"
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        UnixCCompiler.__init__(self, verbose, dry_run, force)
-
-        status, details = check_config_h()
-        self.debug_print("Python's GCC status: %s (details: %s)" %
-                         (status, details))
-        if status is not CONFIG_H_OK:
-            self.warn(
-                "Python's pyconfig.h doesn't seem to support your compiler. "
-                "Reason: %s. "
-                "Compiling may fail because of undefined preprocessor macros."
-                % details)
-
-        self.gcc_version, self.ld_version, self.dllwrap_version = \
-            get_versions()
-        self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
-                         (self.gcc_version,
-                          self.ld_version,
-                          self.dllwrap_version) )
-
-        # ld_version >= "2.10.90" and < "2.13" should also be able to use
-        # gcc -mdll instead of dllwrap
-        # Older dllwraps had own version numbers, newer ones use the
-        # same as the rest of binutils ( also ld )
-        # dllwrap 2.10.90 is buggy
-        if self.ld_version >= "2.10.90":
-            self.linker_dll = "gcc"
-        else:
-            self.linker_dll = "dllwrap"
-
-        # ld_version >= "2.13" support -shared so use it instead of
-        # -mdll -static
-        if self.ld_version >= "2.13":
-            shared_option = "-shared"
-        else:
-            shared_option = "-mdll -static"
-
-        # Hard-code GCC because that's what this is all about.
-        # XXX optimization, warnings etc. should be customizable.
-        self.set_executables(compiler='gcc -mcygwin -O -Wall',
-                             compiler_so='gcc -mcygwin -mdll -O -Wall',
-                             compiler_cxx='g++ -mcygwin -O -Wall',
-                             linker_exe='gcc -mcygwin',
-                             linker_so=('%s -mcygwin %s' %
-                                        (self.linker_dll, shared_option)))
-
-        # cygwin and mingw32 need different sets of libraries
-        if self.gcc_version == "2.91.57":
-            # cygwin shouldn't need msvcrt, but without the dlls will crash
-            # (gcc version 2.91.57) -- perhaps something about initialization
-            self.dll_libraries=["msvcrt"]
-            self.warn(
-                "Consider upgrading to a newer version of gcc")
-        else:
-            # Include the appropriate MSVC runtime library if Python was built
-            # with MSVC 7.0 or later.
-            self.dll_libraries = get_msvcr()
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        """Compiles the source by spawning GCC and windres if needed."""
-        if ext == '.rc' or ext == '.res':
-            # gcc needs '.res' and '.rc' compiled to object files !!!
-            try:
-                self.spawn(["windres", "-i", src, "-o", obj])
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-        else: # for other files use the C-compiler
-            try:
-                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-    def link(self, target_desc, objects, output_filename, output_dir=None,
-             libraries=None, library_dirs=None, runtime_library_dirs=None,
-             export_symbols=None, debug=0, extra_preargs=None,
-             extra_postargs=None, build_temp=None, target_lang=None):
-        """Link the objects."""
-        # use separate copies, so we can modify the lists
-        extra_preargs = copy.copy(extra_preargs or [])
-        libraries = copy.copy(libraries or [])
-        objects = copy.copy(objects or [])
-
-        # Additional libraries
-        libraries.extend(self.dll_libraries)
-
-        # handle export symbols by creating a def-file
-        # with executables this only works with gcc/ld as linker
-        if ((export_symbols is not None) and
-            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
-            # (The linker doesn't do anything if output is up-to-date.
-            # So it would probably better to check if we really need this,
-            # but for this we had to insert some unchanged parts of
-            # UnixCCompiler, and this is not what we want.)
-
-            # we want to put some files in the same directory as the
-            # object files are, build_temp doesn't help much
-            # where are the object files
-            temp_dir = os.path.dirname(objects[0])
-            # name of dll to give the helper files the same base name
-            (dll_name, dll_extension) = os.path.splitext(
-                os.path.basename(output_filename))
-
-            # generate the filenames for these files
-            def_file = os.path.join(temp_dir, dll_name + ".def")
-            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")
-
-            # Generate .def file
-            contents = [
-                "LIBRARY %s" % os.path.basename(output_filename),
-                "EXPORTS"]
-            for sym in export_symbols:
-                contents.append(sym)
-            self.execute(write_file, (def_file, contents),
-                         "writing %s" % def_file)
-
-            # next add options for def-file and to creating import libraries
-
-            # dllwrap uses different options than gcc/ld
-            if self.linker_dll == "dllwrap":
-                extra_preargs.extend(["--output-lib", lib_file])
-                # for dllwrap we have to use a special option
-                extra_preargs.extend(["--def", def_file])
-            # we use gcc/ld here and can be sure ld is >= 2.9.10
-            else:
-                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
-                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
-                # for gcc/ld the def-file is specified as any object files
-                objects.append(def_file)
-
-        #end: if ((export_symbols is not None) and
-        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
-
-        # who wants symbols and a many times larger output file
-        # should explicitly switch the debug mode on
-        # otherwise we let dllwrap/ld strip the output file
-        # (On my machine: 10KB < stripped_file < ??100KB
-        #   unstripped_file = stripped_file + XXX KB
-        #  ( XXX=254 for a typical python extension))
-        if not debug:
-            extra_preargs.append("-s")
-
-        UnixCCompiler.link(self, target_desc, objects, output_filename,
-                           output_dir, libraries, library_dirs,
-                           runtime_library_dirs,
-                           None, # export_symbols, we do this in our def-file
-                           debug, extra_preargs, extra_postargs, build_temp,
-                           target_lang)
-
-    # -- Miscellaneous methods -----------------------------------------
-
-    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
-        """Adds supports for rc and res files."""
-        if output_dir is None:
-            output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
-            base, ext = os.path.splitext(os.path.normcase(src_name))
-            if ext not in (self.src_extensions + ['.rc','.res']):
-                raise UnknownFileError("unknown file type '%s' (from '%s')" % \
-                      (ext, src_name))
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in ('.res', '.rc'):
-                # these need to be compiled to object files
-                obj_names.append (os.path.join(output_dir,
-                                              base + ext + self.obj_extension))
-            else:
-                obj_names.append (os.path.join(output_dir,
-                                               base + self.obj_extension))
-        return obj_names
-
-# the same as cygwin plus some additional parameters
-class Mingw32CCompiler(CygwinCCompiler):
-    """ Handles the Mingw32 port of the GNU C compiler to Windows.
-    """
-    compiler_type = 'mingw32'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-
-        CygwinCCompiler.__init__ (self, verbose, dry_run, force)
-
-        # ld_version >= "2.13" support -shared so use it instead of
-        # -mdll -static
-        if self.ld_version >= "2.13":
-            shared_option = "-shared"
-        else:
-            shared_option = "-mdll -static"
-
-        # A real mingw32 doesn't need to specify a different entry point,
-        # but cygwin 2.91.57 in no-cygwin-mode needs it.
-        if self.gcc_version <= "2.91.57":
-            entry_point = '--entry _DllMain@12'
-        else:
-            entry_point = ''
-
-        if is_cygwingcc():
-            raise CCompilerError(
-                'Cygwin gcc cannot be used with --compiler=mingw32')
-
-        self.set_executables(compiler='gcc -O -Wall',
-                             compiler_so='gcc -mdll -O -Wall',
-                             compiler_cxx='g++ -O -Wall',
-                             linker_exe='gcc',
-                             linker_so='%s %s %s'
-                                        % (self.linker_dll, shared_option,
-                                           entry_point))
-        # Maybe we should also append -mthreads, but then the finished
-        # dlls need another dll (mingwm10.dll see Mingw32 docs)
-        # (-mthreads: Support thread-safe exception handling on `Mingw32')
-
-        # no additional libraries needed
-        self.dll_libraries=[]
-
-        # Include the appropriate MSVC runtime library if Python was built
-        # with MSVC 7.0 or later.
-        self.dll_libraries = get_msvcr()
-
-# Because these compilers aren't configured in Python's pyconfig.h file by
-# default, we should at least warn the user if he is using an unmodified
-# version.
-
-CONFIG_H_OK = "ok"
-CONFIG_H_NOTOK = "not ok"
-CONFIG_H_UNCERTAIN = "uncertain"
-
-def check_config_h():
-    """Check if the current Python installation appears amenable to building
-    extensions with GCC.
-
-    Returns a tuple (status, details), where 'status' is one of the following
-    constants:
-
-    - CONFIG_H_OK: all is well, go ahead and compile
-    - CONFIG_H_NOTOK: doesn't look good
-    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h
-
-    'details' is a human-readable string explaining the situation.
-
-    Note there are two ways to conclude "OK": either 'sys.version' contains
-    the string "GCC" (implying that this Python was built with GCC), or the
-    installed "pyconfig.h" contains the string "__GNUC__".
-    """
-
-    # XXX since this function also checks sys.version, it's not strictly a
-    # "pyconfig.h" check -- should probably be renamed...
-
-    from distutils import sysconfig
-
-    # if sys.version contains GCC then python was compiled with GCC, and the
-    # pyconfig.h file should be OK
-    if "GCC" in sys.version:
-        return CONFIG_H_OK, "sys.version mentions 'GCC'"
-
-    # let's see if __GNUC__ is mentioned in python.h
-    fn = sysconfig.get_config_h_filename()
-    try:
-        config_h = open(fn)
-        try:
-            if "__GNUC__" in config_h.read():
-                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
-            else:
-                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
-        finally:
-            config_h.close()
-    except OSError as exc:
-        return (CONFIG_H_UNCERTAIN,
-                "couldn't read '%s': %s" % (fn, exc.strerror))
-
-RE_VERSION = re.compile(br'(\d+\.\d+(\.\d+)*)')
-
-def _find_exe_version(cmd):
-    """Find the version of an executable by running `cmd` in the shell.
-
-    If the command is not found, or the output does not match
-    `RE_VERSION`, returns None.
-    """
-    executable = cmd.split()[0]
-    if find_executable(executable) is None:
-        return None
-    out = Popen(cmd, shell=True, stdout=PIPE).stdout
-    try:
-        out_string = out.read()
-    finally:
-        out.close()
-    result = RE_VERSION.search(out_string)
-    if result is None:
-        return None
-    # LooseVersion works with strings
-    # so we need to decode our bytes
-    return LooseVersion(result.group(1).decode())
-
-def get_versions():
-    """ Try to find out the versions of gcc, ld and dllwrap.
-
-    If not possible it returns None for it.
-    """
-    commands = ['gcc -dumpversion', 'ld -v', 'dllwrap --version']
-    return tuple([_find_exe_version(cmd) for cmd in commands])
-
-def is_cygwingcc():
-    '''Try to determine if the gcc that would be used is from cygwin.'''
-    out_string = check_output(['gcc', '-dumpmachine'])
-    return out_string.strip().endswith(b'cygwin')
diff --git a/Lib/distutils/debug.py b/Lib/distutils/debug.py
deleted file mode 100644
index daf1660f0d..0000000000
--- a/Lib/distutils/debug.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import os
-
-# If DISTUTILS_DEBUG is anything other than the empty string, we run in
-# debug mode.
-DEBUG = os.environ.get('DISTUTILS_DEBUG')
diff --git a/Lib/distutils/dep_util.py b/Lib/distutils/dep_util.py
deleted file mode 100644
index d74f5e4e92..0000000000
--- a/Lib/distutils/dep_util.py
+++ /dev/null
@@ -1,92 +0,0 @@
-"""distutils.dep_util
-
-Utility functions for simple, timestamp-based dependency of files
-and groups of files; also, function based entirely on such
-timestamp dependency analysis."""
-
-import os
-from distutils.errors import DistutilsFileError
-
-
-def newer (source, target):
-    """Return true if 'source' exists and is more recently modified than
-    'target', or if 'source' exists and 'target' doesn't.  Return false if
-    both exist and 'target' is the same age or younger than 'source'.
-    Raise DistutilsFileError if 'source' does not exist.
-    """
-    if not os.path.exists(source):
-        raise DistutilsFileError("file '%s' does not exist" %
-                                 os.path.abspath(source))
-    if not os.path.exists(target):
-        return 1
-
-    from stat import ST_MTIME
-    mtime1 = os.stat(source)[ST_MTIME]
-    mtime2 = os.stat(target)[ST_MTIME]
-
-    return mtime1 > mtime2
-
-# newer ()
-
-
-def newer_pairwise (sources, targets):
-    """Walk two filename lists in parallel, testing if each source is newer
-    than its corresponding target.  Return a pair of lists (sources,
-    targets) where source is newer than target, according to the semantics
-    of 'newer()'.
-    """
-    if len(sources) != len(targets):
-        raise ValueError("'sources' and 'targets' must be same length")
-
-    # build a pair of lists (sources, targets) where  source is newer
-    n_sources = []
-    n_targets = []
-    for i in range(len(sources)):
-        if newer(sources[i], targets[i]):
-            n_sources.append(sources[i])
-            n_targets.append(targets[i])
-
-    return (n_sources, n_targets)
-
-# newer_pairwise ()
-
-
-def newer_group (sources, target, missing='error'):
-    """Return true if 'target' is out-of-date with respect to any file
-    listed in 'sources'.  In other words, if 'target' exists and is newer
-    than every file in 'sources', return false; otherwise return true.
-    'missing' controls what we do when a source file is missing; the
-    default ("error") is to blow up with an OSError from inside 'stat()';
-    if it is "ignore", we silently drop any missing source files; if it is
-    "newer", any missing source files make us assume that 'target' is
-    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
-    carry out commands that wouldn't work because inputs are missing, but
-    that doesn't matter because you're not actually going to run the
-    commands).
-    """
-    # If the target doesn't even exist, then it's definitely out-of-date.
-    if not os.path.exists(target):
-        return 1
-
-    # Otherwise we have to find out the hard way: if *any* source file
-    # is more recent than 'target', then 'target' is out-of-date and
-    # we can immediately return true.  If we fall through to the end
-    # of the loop, then 'target' is up-to-date and we return false.
-    from stat import ST_MTIME
-    target_mtime = os.stat(target)[ST_MTIME]
-    for source in sources:
-        if not os.path.exists(source):
-            if missing == 'error':      # blow up when we stat() the file
-                pass
-            elif missing == 'ignore':   # missing source dropped from
-                continue                #  target's dependency list
-            elif missing == 'newer':    # missing source means target is
-                return 1                #  out-of-date
-
-        source_mtime = os.stat(source)[ST_MTIME]
-        if source_mtime > target_mtime:
-            return 1
-    else:
-        return 0
-
-# newer_group ()
diff --git a/Lib/distutils/dir_util.py b/Lib/distutils/dir_util.py
deleted file mode 100644
index df4d751c94..0000000000
--- a/Lib/distutils/dir_util.py
+++ /dev/null
@@ -1,223 +0,0 @@
-"""distutils.dir_util
-
-Utility functions for manipulating directories and directory trees."""
-
-import os
-import errno
-from distutils.errors import DistutilsFileError, DistutilsInternalError
-from distutils import log
-
-# cache for by mkpath() -- in addition to cheapening redundant calls,
-# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
-_path_created = {}
-
-# I don't use os.makedirs because a) it's new to Python 1.5.2, and
-# b) it blows up if the directory already exists (I want to silently
-# succeed in that case).
-def mkpath(name, mode=0o777, verbose=1, dry_run=0):
-    """Create a directory and any missing ancestor directories.
-
-    If the directory already exists (or if 'name' is the empty string, which
-    means the current directory, which of course exists), then do nothing.
-    Raise DistutilsFileError if unable to create some directory along the way
-    (eg. some sub-path exists, but is a file rather than a directory).
-    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
-    Return the list of directories actually created.
-    """
-
-    global _path_created
-
-    # Detect a common bug -- name is None
-    if not isinstance(name, str):
-        raise DistutilsInternalError(
-              "mkpath: 'name' must be a string (got %r)" % (name,))
-
-    # XXX what's the better way to handle verbosity? print as we create
-    # each directory in the path (the current behaviour), or only announce
-    # the creation of the whole path? (quite easy to do the latter since
-    # we're not using a recursive algorithm)
-
-    name = os.path.normpath(name)
-    created_dirs = []
-    if os.path.isdir(name) or name == '':
-        return created_dirs
-    if _path_created.get(os.path.abspath(name)):
-        return created_dirs
-
-    (head, tail) = os.path.split(name)
-    tails = [tail]                      # stack of lone dirs to create
-
-    while head and tail and not os.path.isdir(head):
-        (head, tail) = os.path.split(head)
-        tails.insert(0, tail)          # push next higher dir onto stack
-
-    # now 'head' contains the deepest directory that already exists
-    # (that is, the child of 'head' in 'name' is the highest directory
-    # that does *not* exist)
-    for d in tails:
-        #print "head = %s, d = %s: " % (head, d),
-        head = os.path.join(head, d)
-        abs_head = os.path.abspath(head)
-
-        if _path_created.get(abs_head):
-            continue
-
-        if verbose >= 1:
-            log.info("creating %s", head)
-
-        if not dry_run:
-            try:
-                os.mkdir(head, mode)
-            except OSError as exc:
-                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
-                    raise DistutilsFileError(
-                          "could not create '%s': %s" % (head, exc.args[-1]))
-            created_dirs.append(head)
-
-        _path_created[abs_head] = 1
-    return created_dirs
-
-def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
-    """Create all the empty directories under 'base_dir' needed to put 'files'
-    there.
-
-    'base_dir' is just the name of a directory which doesn't necessarily
-    exist yet; 'files' is a list of filenames to be interpreted relative to
-    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
-    will be created if it doesn't already exist.  'mode', 'verbose' and
-    'dry_run' flags are as for 'mkpath()'.
-    """
-    # First get the list of directories to create
-    need_dir = set()
-    for file in files:
-        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))
-
-    # Now create them
-    for dir in sorted(need_dir):
-        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)
-
-import sysconfig
-_multiarch = None
-
-def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
-              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
-    """Copy an entire directory tree 'src' to a new location 'dst'.
-
-    Both 'src' and 'dst' must be directory names.  If 'src' is not a
-    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
-    created with 'mkpath()'.  The end result of the copy is that every
-    file in 'src' is copied to 'dst', and directories under 'src' are
-    recursively copied to 'dst'.  Return the list of files that were
-    copied or might have been copied, using their output name.  The
-    return value is unaffected by 'update' or 'dry_run': it is simply
-    the list of all files under 'src', with the names changed to be
-    under 'dst'.
-
-    'preserve_mode' and 'preserve_times' are the same as for
-    'copy_file'; note that they only apply to regular files, not to
-    directories.  If 'preserve_symlinks' is true, symlinks will be
-    copied as symlinks (on platforms that support them!); otherwise
-    (the default), the destination of the symlink will be copied.
-    'update' and 'verbose' are the same as for 'copy_file'.
-    """
-    from distutils.file_util import copy_file
-
-    if not dry_run and not os.path.isdir(src):
-        raise DistutilsFileError(
-              "cannot copy tree '%s': not a directory" % src)
-    try:
-        names = os.listdir(src)
-    except OSError as e:
-        if dry_run:
-            names = []
-        else:
-            raise DistutilsFileError(
-                  "error listing files in '%s': %s" % (src, e.strerror))
-
-    ext_suffix = sysconfig.get_config_var ('EXT_SUFFIX')
-    _multiarch = sysconfig.get_config_var ('MULTIARCH')
-    if ext_suffix.endswith(_multiarch + ext_suffix[-3:]):
-        new_suffix = None
-    else:
-        new_suffix = "%s-%s%s" % (ext_suffix[:-3], _multiarch, ext_suffix[-3:])
-
-    if not dry_run:
-        mkpath(dst, verbose=verbose)
-
-    outputs = []
-
-    for n in names:
-        src_name = os.path.join(src, n)
-        dst_name = os.path.join(dst, n)
-        if new_suffix and _multiarch and n.endswith(ext_suffix) and not n.endswith(new_suffix):
-            dst_name = os.path.join(dst, n.replace(ext_suffix, new_suffix))
-            log.info("renaming extension %s -> %s", n, n.replace(ext_suffix, new_suffix))
-
-        if n.startswith('.nfs'):
-            # skip NFS rename files
-            continue
-
-        if preserve_symlinks and os.path.islink(src_name):
-            link_dest = os.readlink(src_name)
-            if verbose >= 1:
-                log.info("linking %s -> %s", dst_name, link_dest)
-            if not dry_run:
-                os.symlink(link_dest, dst_name)
-            outputs.append(dst_name)
-
-        elif os.path.isdir(src_name):
-            outputs.extend(
-                copy_tree(src_name, dst_name, preserve_mode,
-                          preserve_times, preserve_symlinks, update,
-                          verbose=verbose, dry_run=dry_run))
-        else:
-            copy_file(src_name, dst_name, preserve_mode,
-                      preserve_times, update, verbose=verbose,
-                      dry_run=dry_run)
-            outputs.append(dst_name)
-
-    return outputs
-
-def _build_cmdtuple(path, cmdtuples):
-    """Helper for remove_tree()."""
-    for f in os.listdir(path):
-        real_f = os.path.join(path,f)
-        if os.path.isdir(real_f) and not os.path.islink(real_f):
-            _build_cmdtuple(real_f, cmdtuples)
-        else:
-            cmdtuples.append((os.remove, real_f))
-    cmdtuples.append((os.rmdir, path))
-
-def remove_tree(directory, verbose=1, dry_run=0):
-    """Recursively remove an entire directory tree.
-
-    Any errors are ignored (apart from being reported to stdout if 'verbose'
-    is true).
-    """
-    global _path_created
-
-    if verbose >= 1:
-        log.info("removing '%s' (and everything under it)", directory)
-    if dry_run:
-        return
-    cmdtuples = []
-    _build_cmdtuple(directory, cmdtuples)
-    for cmd in cmdtuples:
-        try:
-            cmd[0](cmd[1])
-            # remove dir from cache if it's already there
-            abspath = os.path.abspath(cmd[1])
-            if abspath in _path_created:
-                del _path_created[abspath]
-        except OSError as exc:
-            log.warn("error removing %s: %s", directory, exc)
-
-def ensure_relative(path):
-    """Take the full path 'path', and make it a relative path.
-
-    This is useful to make 'path' the second argument to os.path.join().
-    """
-    drive, path = os.path.splitdrive(path)
-    if path[0:1] == os.sep:
-        path = drive + path[1:]
-    return path
diff --git a/Lib/distutils/dist.py b/Lib/distutils/dist.py
deleted file mode 100644
index 62a24516cf..0000000000
--- a/Lib/distutils/dist.py
+++ /dev/null
@@ -1,1236 +0,0 @@
-"""distutils.dist
-
-Provides the Distribution class, which represents the module distribution
-being built/installed/distributed.
-"""
-
-import sys
-import os
-import re
-from email import message_from_file
-
-try:
-    import warnings
-except ImportError:
-    warnings = None
-
-from distutils.errors import *
-from distutils.fancy_getopt import FancyGetopt, translate_longopt
-from distutils.util import check_environ, strtobool, rfc822_escape
-from distutils import log
-from distutils.debug import DEBUG
-
-# Regex to define acceptable Distutils command names.  This is not *quite*
-# the same as a Python NAME -- I don't allow leading underscores.  The fact
-# that they're very similar is no coincidence; the default naming scheme is
-# to look for a Python module named after the command.
-command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')
-
-
-class Distribution:
-    """The core of the Distutils.  Most of the work hiding behind 'setup'
-    is really done within a Distribution instance, which farms the work out
-    to the Distutils commands specified on the command line.
-
-    Setup scripts will almost never instantiate Distribution directly,
-    unless the 'setup()' function is totally inadequate to their needs.
-    However, it is conceivable that a setup script might wish to subclass
-    Distribution for some specialized purpose, and then pass the subclass
-    to 'setup()' as the 'distclass' keyword argument.  If so, it is
-    necessary to respect the expectations that 'setup' has of Distribution.
-    See the code for 'setup()', in core.py, for details.
-    """
-
-    # 'global_options' describes the command-line options that may be
-    # supplied to the setup script prior to any actual commands.
-    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
-    # these global options.  This list should be kept to a bare minimum,
-    # since every global option is also valid as a command option -- and we
-    # don't want to pollute the commands with too many options that they
-    # have minimal control over.
-    # The fourth entry for verbose means that it can be repeated.
-    global_options = [
-        ('verbose', 'v', "run verbosely (default)", 1),
-        ('quiet', 'q', "run quietly (turns verbosity off)"),
-        ('dry-run', 'n', "don't actually do anything"),
-        ('help', 'h', "show detailed help message"),
-        ('no-user-cfg', None,
-            'ignore pydistutils.cfg in your home directory'),
-    ]
-
-    # 'common_usage' is a short (2-3 line) string describing the common
-    # usage of the setup script.
-    common_usage = """\
-Common commands: (see '--help-commands' for more)
-
-  setup.py build      will build the package underneath 'build/'
-  setup.py install    will install the package
-"""
-
-    # options that are not propagated to the commands
-    display_options = [
-        ('help-commands', None,
-         "list all available commands"),
-        ('name', None,
-         "print package name"),
-        ('version', 'V',
-         "print package version"),
-        ('fullname', None,
-         "print <package name>-<version>"),
-        ('author', None,
-         "print the author's name"),
-        ('author-email', None,
-         "print the author's email address"),
-        ('maintainer', None,
-         "print the maintainer's name"),
-        ('maintainer-email', None,
-         "print the maintainer's email address"),
-        ('contact', None,
-         "print the maintainer's name if known, else the author's"),
-        ('contact-email', None,
-         "print the maintainer's email address if known, else the author's"),
-        ('url', None,
-         "print the URL for this package"),
-        ('license', None,
-         "print the license of the package"),
-        ('licence', None,
-         "alias for --license"),
-        ('description', None,
-         "print the package description"),
-        ('long-description', None,
-         "print the long package description"),
-        ('platforms', None,
-         "print the list of platforms"),
-        ('classifiers', None,
-         "print the list of classifiers"),
-        ('keywords', None,
-         "print the list of keywords"),
-        ('provides', None,
-         "print the list of packages/modules provided"),
-        ('requires', None,
-         "print the list of packages/modules required"),
-        ('obsoletes', None,
-         "print the list of packages/modules made obsolete")
-        ]
-    display_option_names = [translate_longopt(x[0]) for x in display_options]
-
-    # negative options are options that exclude other options
-    negative_opt = {'quiet': 'verbose'}
-
-    # -- Creation/initialization methods -------------------------------
-
-    def __init__(self, attrs=None):
-        """Construct a new Distribution instance: initialize all the
-        attributes of a Distribution, and then use 'attrs' (a dictionary
-        mapping attribute names to values) to assign some of those
-        attributes their "real" values.  (Any attributes not mentioned in
-        'attrs' will be assigned to some null value: 0, None, an empty list
-        or dictionary, etc.)  Most importantly, initialize the
-        'command_obj' attribute to the empty dictionary; this will be
-        filled in with real command objects by 'parse_command_line()'.
-        """
-
-        # Default values for our command-line options
-        self.verbose = 1
-        self.dry_run = 0
-        self.help = 0
-        for attr in self.display_option_names:
-            setattr(self, attr, 0)
-
-        # Store the distribution meta-data (name, version, author, and so
-        # forth) in a separate object -- we're getting to have enough
-        # information here (and enough command-line options) that it's
-        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
-        # object in a sneaky and underhanded (but efficient!) way.
-        self.metadata = DistributionMetadata()
-        for basename in self.metadata._METHOD_BASENAMES:
-            method_name = "get_" + basename
-            setattr(self, method_name, getattr(self.metadata, method_name))
-
-        # 'cmdclass' maps command names to class objects, so we
-        # can 1) quickly figure out which class to instantiate when
-        # we need to create a new command object, and 2) have a way
-        # for the setup script to override command classes
-        self.cmdclass = {}
-
-        # 'command_packages' is a list of packages in which commands
-        # are searched for.  The factory for command 'foo' is expected
-        # to be named 'foo' in the module 'foo' in one of the packages
-        # named here.  This list is searched from the left; an error
-        # is raised if no named package provides the command being
-        # searched for.  (Always access using get_command_packages().)
-        self.command_packages = None
-
-        # 'script_name' and 'script_args' are usually set to sys.argv[0]
-        # and sys.argv[1:], but they can be overridden when the caller is
-        # not necessarily a setup script run from the command-line.
-        self.script_name = None
-        self.script_args = None
-
-        # 'command_options' is where we store command options between
-        # parsing them (from config files, the command-line, etc.) and when
-        # they are actually needed -- ie. when the command in question is
-        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
-        #   command_options = { command_name : { option : (source, value) } }
-        self.command_options = {}
-
-        # 'dist_files' is the list of (command, pyversion, file) that
-        # have been created by any dist commands run so far. This is
-        # filled regardless of whether the run is dry or not. pyversion
-        # gives sysconfig.get_python_version() if the dist file is
-        # specific to a Python version, 'any' if it is good for all
-        # Python versions on the target platform, and '' for a source
-        # file. pyversion should not be used to specify minimum or
-        # maximum required Python versions; use the metainfo for that
-        # instead.
-        self.dist_files = []
-
-        # These options are really the business of various commands, rather
-        # than of the Distribution itself.  We provide aliases for them in
-        # Distribution as a convenience to the developer.
-        self.packages = None
-        self.package_data = {}
-        self.package_dir = None
-        self.py_modules = None
-        self.libraries = None
-        self.headers = None
-        self.ext_modules = None
-        self.ext_package = None
-        self.include_dirs = None
-        self.extra_path = None
-        self.scripts = None
-        self.data_files = None
-        self.password = ''
-
-        # And now initialize bookkeeping stuff that can't be supplied by
-        # the caller at all.  'command_obj' maps command names to
-        # Command instances -- that's how we enforce that every command
-        # class is a singleton.
-        self.command_obj = {}
-
-        # 'have_run' maps command names to boolean values; it keeps track
-        # of whether we have actually run a particular command, to make it
-        # cheap to "run" a command whenever we think we might need to -- if
-        # it's already been done, no need for expensive filesystem
-        # operations, we just check the 'have_run' dictionary and carry on.
-        # It's only safe to query 'have_run' for a command class that has
-        # been instantiated -- a false value will be inserted when the
-        # command object is created, and replaced with a true value when
-        # the command is successfully run.  Thus it's probably best to use
-        # '.get()' rather than a straight lookup.
-        self.have_run = {}
-
-        # Now we'll use the attrs dictionary (ultimately, keyword args from
-        # the setup script) to possibly override any or all of these
-        # distribution options.
-
-        if attrs:
-            # Pull out the set of command options and work on them
-            # specifically.  Note that this order guarantees that aliased
-            # command options will override any supplied redundantly
-            # through the general options dictionary.
-            options = attrs.get('options')
-            if options is not None:
-                del attrs['options']
-                for (command, cmd_options) in options.items():
-                    opt_dict = self.get_option_dict(command)
-                    for (opt, val) in cmd_options.items():
-                        opt_dict[opt] = ("setup script", val)
-
-            if 'licence' in attrs:
-                attrs['license'] = attrs['licence']
-                del attrs['licence']
-                msg = "'licence' distribution option is deprecated; use 'license'"
-                if warnings is not None:
-                    warnings.warn(msg)
-                else:
-                    sys.stderr.write(msg + "\n")
-
-            # Now work on the rest of the attributes.  Any attribute that's
-            # not already defined is invalid!
-            for (key, val) in attrs.items():
-                if hasattr(self.metadata, "set_" + key):
-                    getattr(self.metadata, "set_" + key)(val)
-                elif hasattr(self.metadata, key):
-                    setattr(self.metadata, key, val)
-                elif hasattr(self, key):
-                    setattr(self, key, val)
-                else:
-                    msg = "Unknown distribution option: %s" % repr(key)
-                    if warnings is not None:
-                        warnings.warn(msg)
-                    else:
-                        sys.stderr.write(msg + "\n")
-
-        # no-user-cfg is handled before other command line args
-        # because other args override the config files, and this
-        # one is needed before we can load the config files.
-        # If attrs['script_args'] wasn't passed, assume false.
-        #
-        # This also make sure we just look at the global options
-        self.want_user_cfg = True
-
-        if self.script_args is not None:
-            for arg in self.script_args:
-                if not arg.startswith('-'):
-                    break
-                if arg == '--no-user-cfg':
-                    self.want_user_cfg = False
-                    break
-
-        self.finalize_options()
-
-    def get_option_dict(self, command):
-        """Get the option dictionary for a given command.  If that
-        command's option dictionary hasn't been created yet, then create it
-        and return the new dictionary; otherwise, return the existing
-        option dictionary.
-        """
-        dict = self.command_options.get(command)
-        if dict is None:
-            dict = self.command_options[command] = {}
-        return dict
-
-    def dump_option_dicts(self, header=None, commands=None, indent=""):
-        from pprint import pformat
-
-        if commands is None:             # dump all command option dicts
-            commands = sorted(self.command_options.keys())
-
-        if header is not None:
-            self.announce(indent + header)
-            indent = indent + "  "
-
-        if not commands:
-            self.announce(indent + "no commands known yet")
-            return
-
-        for cmd_name in commands:
-            opt_dict = self.command_options.get(cmd_name)
-            if opt_dict is None:
-                self.announce(indent +
-                              "no option dict for '%s' command" % cmd_name)
-            else:
-                self.announce(indent +
-                              "option dict for '%s' command:" % cmd_name)
-                out = pformat(opt_dict)
-                for line in out.split('\n'):
-                    self.announce(indent + "  " + line)
-
-    # -- Config file finding/parsing methods ---------------------------
-
-    def find_config_files(self):
-        """Find as many configuration files as should be processed for this
-        platform, and return a list of filenames in the order in which they
-        should be parsed.  The filenames returned are guaranteed to exist
-        (modulo nasty race conditions).
-
-        There are three possible config files: distutils.cfg in the
-        Distutils installation directory (ie. where the top-level
-        Distutils __inst__.py file lives), a file in the user's home
-        directory named .pydistutils.cfg on Unix and pydistutils.cfg
-        on Windows/Mac; and setup.cfg in the current directory.
-
-        The file in the user's home directory can be disabled with the
-        --no-user-cfg option.
-        """
-        files = []
-        check_environ()
-
-        # Where to look for the system-wide Distutils config file
-        sys_dir = os.path.dirname(sys.modules['distutils'].__file__)
-
-        # Look for the system config file
-        sys_file = os.path.join(sys_dir, "distutils.cfg")
-        if os.path.isfile(sys_file):
-            files.append(sys_file)
-
-        # What to call the per-user config file
-        if os.name == 'posix':
-            user_filename = ".pydistutils.cfg"
-        else:
-            user_filename = "pydistutils.cfg"
-
-        # And look for the user config file
-        if self.want_user_cfg:
-            user_file = os.path.join(os.path.expanduser('~'), user_filename)
-            if os.path.isfile(user_file):
-                files.append(user_file)
-
-        # All platforms support local setup.cfg
-        local_file = "setup.cfg"
-        if os.path.isfile(local_file):
-            files.append(local_file)
-
-        if DEBUG:
-            self.announce("using config files: %s" % ', '.join(files))
-
-        return files
-
-    def parse_config_files(self, filenames=None):
-        from configparser import ConfigParser
-
-        # Ignore install directory options if we have a venv
-        if sys.prefix != sys.base_prefix:
-            ignore_options = [
-                'install-base', 'install-platbase', 'install-lib',
-                'install-platlib', 'install-purelib', 'install-headers',
-                'install-scripts', 'install-data', 'prefix', 'exec-prefix',
-                'home', 'user', 'root']
-        else:
-            ignore_options = []
-
-        ignore_options = frozenset(ignore_options)
-
-        if filenames is None:
-            filenames = self.find_config_files()
-
-        if DEBUG:
-            self.announce("Distribution.parse_config_files():")
-
-        parser = ConfigParser()
-        for filename in filenames:
-            if DEBUG:
-                self.announce("  reading %s" % filename)
-            parser.read(filename)
-            for section in parser.sections():
-                options = parser.options(section)
-                opt_dict = self.get_option_dict(section)
-
-                for opt in options:
-                    if opt != '__name__' and opt not in ignore_options:
-                        val = parser.get(section,opt)
-                        opt = opt.replace('-', '_')
-                        opt_dict[opt] = (filename, val)
-
-            # Make the ConfigParser forget everything (so we retain
-            # the original filenames that options come from)
-            parser.__init__()
-
-        # If there was a "global" section in the config file, use it
-        # to set Distribution options.
-
-        if 'global' in self.command_options:
-            for (opt, (src, val)) in self.command_options['global'].items():
-                alias = self.negative_opt.get(opt)
-                try:
-                    if alias:
-                        setattr(self, alias, not strtobool(val))
-                    elif opt in ('verbose', 'dry_run'): # ugh!
-                        setattr(self, opt, strtobool(val))
-                    else:
-                        setattr(self, opt, val)
-                except ValueError as msg:
-                    raise DistutilsOptionError(msg)
-
-    # -- Command-line parsing methods ----------------------------------
-
-    def parse_command_line(self):
-        """Parse the setup script's command line, taken from the
-        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
-        -- see 'setup()' in core.py).  This list is first processed for
-        "global options" -- options that set attributes of the Distribution
-        instance.  Then, it is alternately scanned for Distutils commands
-        and options for that command.  Each new command terminates the
-        options for the previous command.  The allowed options for a
-        command are determined by the 'user_options' attribute of the
-        command class -- thus, we have to be able to load command classes
-        in order to parse the command line.  Any error in that 'options'
-        attribute raises DistutilsGetoptError; any error on the
-        command-line raises DistutilsArgError.  If no Distutils commands
-        were found on the command line, raises DistutilsArgError.  Return
-        true if command-line was successfully parsed and we should carry
-        on with executing commands; false if no errors but we shouldn't
-        execute commands (currently, this only happens if user asks for
-        help).
-        """
-        #
-        # We now have enough information to show the Macintosh dialog
-        # that allows the user to interactively specify the "command line".
-        #
-        toplevel_options = self._get_toplevel_options()
-
-        # We have to parse the command line a bit at a time -- global
-        # options, then the first command, then its options, and so on --
-        # because each command will be handled by a different class, and
-        # the options that are valid for a particular class aren't known
-        # until we have loaded the command class, which doesn't happen
-        # until we know what the command is.
-
-        self.commands = []
-        parser = FancyGetopt(toplevel_options + self.display_options)
-        parser.set_negative_aliases(self.negative_opt)
-        parser.set_aliases({'licence': 'license'})
-        args = parser.getopt(args=self.script_args, object=self)
-        option_order = parser.get_option_order()
-        log.set_verbosity(self.verbose)
-
-        # for display options we return immediately
-        if self.handle_display_options(option_order):
-            return
-        while args:
-            args = self._parse_command_opts(parser, args)
-            if args is None:            # user asked for help (and got it)
-                return
-
-        # Handle the cases of --help as a "global" option, ie.
-        # "setup.py --help" and "setup.py --help command ...".  For the
-        # former, we show global options (--verbose, --dry-run, etc.)
-        # and display-only options (--name, --version, etc.); for the
-        # latter, we omit the display-only options and show help for
-        # each command listed on the command line.
-        if self.help:
-            self._show_help(parser,
-                            display_options=len(self.commands) == 0,
-                            commands=self.commands)
-            return
-
-        # Oops, no commands found -- an end-user error
-        if not self.commands:
-            raise DistutilsArgError("no commands supplied")
-
-        # All is well: return true
-        return True
-
-    def _get_toplevel_options(self):
-        """Return the non-display options recognized at the top level.
-
-        This includes options that are recognized *only* at the top
-        level as well as options recognized for commands.
-        """
-        return self.global_options + [
-            ("command-packages=", None,
-             "list of packages that provide distutils commands"),
-            ]
-
-    def _parse_command_opts(self, parser, args):
-        """Parse the command-line options for a single command.
-        'parser' must be a FancyGetopt instance; 'args' must be the list
-        of arguments, starting with the current command (whose options
-        we are about to parse).  Returns a new version of 'args' with
-        the next command at the front of the list; will be the empty
-        list if there are no more commands on the command line.  Returns
-        None if the user asked for help on this command.
-        """
-        # late import because of mutual dependence between these modules
-        from distutils.cmd import Command
-
-        # Pull the current command from the head of the command line
-        command = args[0]
-        if not command_re.match(command):
-            raise SystemExit("invalid command name '%s'" % command)
-        self.commands.append(command)
-
-        # Dig up the command class that implements this command, so we
-        # 1) know that it's a valid command, and 2) know which options
-        # it takes.
-        try:
-            cmd_class = self.get_command_class(command)
-        except DistutilsModuleError as msg:
-            raise DistutilsArgError(msg)
-
-        # Require that the command class be derived from Command -- want
-        # to be sure that the basic "command" interface is implemented.
-        if not issubclass(cmd_class, Command):
-            raise DistutilsClassError(
-                "command class %s must subclass Command" % cmd_class)
-
-        # Also make sure that the command object provides a list of its
-        # known options.
-        if not (hasattr(cmd_class, 'user_options') and
-                isinstance(cmd_class.user_options, list)):
-            msg = ("command class %s must provide "
-                "'user_options' attribute (a list of tuples)")
-            raise DistutilsClassError(msg % cmd_class)
-
-        # If the command class has a list of negative alias options,
-        # merge it in with the global negative aliases.
-        negative_opt = self.negative_opt
-        if hasattr(cmd_class, 'negative_opt'):
-            negative_opt = negative_opt.copy()
-            negative_opt.update(cmd_class.negative_opt)
-
-        # Check for help_options in command class.  They have a different
-        # format (tuple of four) so we need to preprocess them here.
-        if (hasattr(cmd_class, 'help_options') and
-                isinstance(cmd_class.help_options, list)):
-            help_options = fix_help_options(cmd_class.help_options)
-        else:
-            help_options = []
-
-        # All commands support the global options too, just by adding
-        # in 'global_options'.
-        parser.set_option_table(self.global_options +
-                                cmd_class.user_options +
-                                help_options)
-        parser.set_negative_aliases(negative_opt)
-        (args, opts) = parser.getopt(args[1:])
-        if hasattr(opts, 'help') and opts.help:
-            self._show_help(parser, display_options=0, commands=[cmd_class])
-            return
-
-        if (hasattr(cmd_class, 'help_options') and
-                isinstance(cmd_class.help_options, list)):
-            help_option_found=0
-            for (help_option, short, desc, func) in cmd_class.help_options:
-                if hasattr(opts, parser.get_attr_name(help_option)):
-                    help_option_found=1
-                    if callable(func):
-                        func()
-                    else:
-                        raise DistutilsClassError(
-                            "invalid help function %r for help option '%s': "
-                            "must be a callable object (function, etc.)"
-                            % (func, help_option))
-
-            if help_option_found:
-                return
-
-        # Put the options from the command-line into their official
-        # holding pen, the 'command_options' dictionary.
-        opt_dict = self.get_option_dict(command)
-        for (name, value) in vars(opts).items():
-            opt_dict[name] = ("command line", value)
-
-        return args
-
-    def finalize_options(self):
-        """Set final values for all the options on the Distribution
-        instance, analogous to the .finalize_options() method of Command
-        objects.
-        """
-        for attr in ('keywords', 'platforms'):
-            value = getattr(self.metadata, attr)
-            if value is None:
-                continue
-            if isinstance(value, str):
-                value = [elm.strip() for elm in value.split(',')]
-                setattr(self.metadata, attr, value)
-
-    def _show_help(self, parser, global_options=1, display_options=1,
-                   commands=[]):
-        """Show help for the setup script command-line in the form of
-        several lists of command-line options.  'parser' should be a
-        FancyGetopt instance; do not expect it to be returned in the
-        same state, as its option table will be reset to make it
-        generate the correct help text.
-
-        If 'global_options' is true, lists the global options:
-        --verbose, --dry-run, etc.  If 'display_options' is true, lists
-        the "display-only" options: --name, --version, etc.  Finally,
-        lists per-command help for every command name or command class
-        in 'commands'.
-        """
-        # late import because of mutual dependence between these modules
-        from distutils.core import gen_usage
-        from distutils.cmd import Command
-
-        if global_options:
-            if display_options:
-                options = self._get_toplevel_options()
-            else:
-                options = self.global_options
-            parser.set_option_table(options)
-            parser.print_help(self.common_usage + "\nGlobal options:")
-            print('')
-
-        if display_options:
-            parser.set_option_table(self.display_options)
-            parser.print_help(
-                "Information display options (just display " +
-                "information, ignore any commands)")
-            print('')
-
-        for command in self.commands:
-            if isinstance(command, type) and issubclass(command, Command):
-                klass = command
-            else:
-                klass = self.get_command_class(command)
-            if (hasattr(klass, 'help_options') and
-                    isinstance(klass.help_options, list)):
-                parser.set_option_table(klass.user_options +
-                                        fix_help_options(klass.help_options))
-            else:
-                parser.set_option_table(klass.user_options)
-            parser.print_help("Options for '%s' command:" % klass.__name__)
-            print('')
-
-        print(gen_usage(self.script_name))
-
-    def handle_display_options(self, option_order):
-        """If there were any non-global "display-only" options
-        (--help-commands or the metadata display options) on the command
-        line, display the requested info and return true; else return
-        false.
-        """
-        from distutils.core import gen_usage
-
-        # User just wants a list of commands -- we'll print it out and stop
-        # processing now (ie. if they ran "setup --help-commands foo bar",
-        # we ignore "foo bar").
-        if self.help_commands:
-            self.print_commands()
-            print('')
-            print(gen_usage(self.script_name))
-            return 1
-
-        # If user supplied any of the "display metadata" options, then
-        # display that metadata in the order in which the user supplied the
-        # metadata options.
-        any_display_options = 0
-        is_display_option = {}
-        for option in self.display_options:
-            is_display_option[option[0]] = 1
-
-        for (opt, val) in option_order:
-            if val and is_display_option.get(opt):
-                opt = translate_longopt(opt)
-                value = getattr(self.metadata, "get_"+opt)()
-                if opt in ['keywords', 'platforms']:
-                    print(','.join(value))
-                elif opt in ('classifiers', 'provides', 'requires',
-                             'obsoletes'):
-                    print('\n'.join(value))
-                else:
-                    print(value)
-                any_display_options = 1
-
-        return any_display_options
-
-    def print_command_list(self, commands, header, max_length):
-        """Print a subset of the list of all commands -- used by
-        'print_commands()'.
-        """
-        print(header + ":")
-
-        for cmd in commands:
-            klass = self.cmdclass.get(cmd)
-            if not klass:
-                klass = self.get_command_class(cmd)
-            try:
-                description = klass.description
-            except AttributeError:
-                description = "(no description available)"
-
-            print("  %-*s  %s" % (max_length, cmd, description))
-
-    def print_commands(self):
-        """Print out a help message listing all available commands with a
-        description of each.  The list is divided into "standard commands"
-        (listed in distutils.command.__all__) and "extra commands"
-        (mentioned in self.cmdclass, but not a standard command).  The
-        descriptions come from the command class attribute
-        'description'.
-        """
-        import distutils.command
-        std_commands = distutils.command.__all__
-        is_std = {}
-        for cmd in std_commands:
-            is_std[cmd] = 1
-
-        extra_commands = []
-        for cmd in self.cmdclass.keys():
-            if not is_std.get(cmd):
-                extra_commands.append(cmd)
-
-        max_length = 0
-        for cmd in (std_commands + extra_commands):
-            if len(cmd) > max_length:
-                max_length = len(cmd)
-
-        self.print_command_list(std_commands,
-                                "Standard commands",
-                                max_length)
-        if extra_commands:
-            print()
-            self.print_command_list(extra_commands,
-                                    "Extra commands",
-                                    max_length)
-
-    def get_command_list(self):
-        """Get a list of (command, description) tuples.
-        The list is divided into "standard commands" (listed in
-        distutils.command.__all__) and "extra commands" (mentioned in
-        self.cmdclass, but not a standard command).  The descriptions come
-        from the command class attribute 'description'.
-        """
-        # Currently this is only used on Mac OS, for the Mac-only GUI
-        # Distutils interface (by Jack Jansen)
-        import distutils.command
-        std_commands = distutils.command.__all__
-        is_std = {}
-        for cmd in std_commands:
-            is_std[cmd] = 1
-
-        extra_commands = []
-        for cmd in self.cmdclass.keys():
-            if not is_std.get(cmd):
-                extra_commands.append(cmd)
-
-        rv = []
-        for cmd in (std_commands + extra_commands):
-            klass = self.cmdclass.get(cmd)
-            if not klass:
-                klass = self.get_command_class(cmd)
-            try:
-                description = klass.description
-            except AttributeError:
-                description = "(no description available)"
-            rv.append((cmd, description))
-        return rv
-
-    # -- Command class/object methods ----------------------------------
-
-    def get_command_packages(self):
-        """Return a list of packages from which commands are loaded."""
-        pkgs = self.command_packages
-        if not isinstance(pkgs, list):
-            if pkgs is None:
-                pkgs = ''
-            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
-            if "distutils.command" not in pkgs:
-                pkgs.insert(0, "distutils.command")
-            self.command_packages = pkgs
-        return pkgs
-
-    def get_command_class(self, command):
-        """Return the class that implements the Distutils command named by
-        'command'.  First we check the 'cmdclass' dictionary; if the
-        command is mentioned there, we fetch the class object from the
-        dictionary and return it.  Otherwise we load the command module
-        ("distutils.command." + command) and fetch the command class from
-        the module.  The loaded class is also stored in 'cmdclass'
-        to speed future calls to 'get_command_class()'.
-
-        Raises DistutilsModuleError if the expected module could not be
-        found, or if that module does not define the expected class.
-        """
-        klass = self.cmdclass.get(command)
-        if klass:
-            return klass
-
-        for pkgname in self.get_command_packages():
-            module_name = "%s.%s" % (pkgname, command)
-            klass_name = command
-
-            try:
-                __import__(module_name)
-                module = sys.modules[module_name]
-            except ImportError:
-                continue
-
-            try:
-                klass = getattr(module, klass_name)
-            except AttributeError:
-                raise DistutilsModuleError(
-                    "invalid command '%s' (no class '%s' in module '%s')"
-                    % (command, klass_name, module_name))
-
-            self.cmdclass[command] = klass
-            return klass
-
-        raise DistutilsModuleError("invalid command '%s'" % command)
-
-    def get_command_obj(self, command, create=1):
-        """Return the command object for 'command'.  Normally this object
-        is cached on a previous call to 'get_command_obj()'; if no command
-        object for 'command' is in the cache, then we either create and
-        return it (if 'create' is true) or return None.
-        """
-        cmd_obj = self.command_obj.get(command)
-        if not cmd_obj and create:
-            if DEBUG:
-                self.announce("Distribution.get_command_obj(): "
-                              "creating '%s' command object" % command)
-
-            klass = self.get_command_class(command)
-            cmd_obj = self.command_obj[command] = klass(self)
-            self.have_run[command] = 0
-
-            # Set any options that were supplied in config files
-            # or on the command line.  (NB. support for error
-            # reporting is lame here: any errors aren't reported
-            # until 'finalize_options()' is called, which means
-            # we won't report the source of the error.)
-            options = self.command_options.get(command)
-            if options:
-                self._set_command_options(cmd_obj, options)
-
-        return cmd_obj
-
-    def _set_command_options(self, command_obj, option_dict=None):
-        """Set the options for 'command_obj' from 'option_dict'.  Basically
-        this means copying elements of a dictionary ('option_dict') to
-        attributes of an instance ('command').
-
-        'command_obj' must be a Command instance.  If 'option_dict' is not
-        supplied, uses the standard option dictionary for this command
-        (from 'self.command_options').
-        """
-        command_name = command_obj.get_command_name()
-        if option_dict is None:
-            option_dict = self.get_option_dict(command_name)
-
-        if DEBUG:
-            self.announce("  setting options for '%s' command:" % command_name)
-        for (option, (source, value)) in option_dict.items():
-            if DEBUG:
-                self.announce("    %s = %s (from %s)" % (option, value,
-                                                         source))
-            try:
-                bool_opts = [translate_longopt(o)
-                             for o in command_obj.boolean_options]
-            except AttributeError:
-                bool_opts = []
-            try:
-                neg_opt = command_obj.negative_opt
-            except AttributeError:
-                neg_opt = {}
-
-            try:
-                is_string = isinstance(value, str)
-                if option in neg_opt and is_string:
-                    setattr(command_obj, neg_opt[option], not strtobool(value))
-                elif option in bool_opts and is_string:
-                    setattr(command_obj, option, strtobool(value))
-                elif hasattr(command_obj, option):
-                    setattr(command_obj, option, value)
-                else:
-                    raise DistutilsOptionError(
-                        "error in %s: command '%s' has no such option '%s'"
-                        % (source, command_name, option))
-            except ValueError as msg:
-                raise DistutilsOptionError(msg)
-
-    def reinitialize_command(self, command, reinit_subcommands=0):
-        """Reinitializes a command to the state it was in when first
-        returned by 'get_command_obj()': ie., initialized but not yet
-        finalized.  This provides the opportunity to sneak option
-        values in programmatically, overriding or supplementing
-        user-supplied values from the config files and command line.
-        You'll have to re-finalize the command object (by calling
-        'finalize_options()' or 'ensure_finalized()') before using it for
-        real.
-
-        'command' should be a command name (string) or command object.  If
-        'reinit_subcommands' is true, also reinitializes the command's
-        sub-commands, as declared by the 'sub_commands' class attribute (if
-        it has one).  See the "install" command for an example.  Only
-        reinitializes the sub-commands that actually matter, ie. those
-        whose test predicates return true.
-
-        Returns the reinitialized command object.
-        """
-        from distutils.cmd import Command
-        if not isinstance(command, Command):
-            command_name = command
-            command = self.get_command_obj(command_name)
-        else:
-            command_name = command.get_command_name()
-
-        if not command.finalized:
-            return command
-        command.initialize_options()
-        command.finalized = 0
-        self.have_run[command_name] = 0
-        self._set_command_options(command)
-
-        if reinit_subcommands:
-            for sub in command.get_sub_commands():
-                self.reinitialize_command(sub, reinit_subcommands)
-
-        return command
-
-    # -- Methods that operate on the Distribution ----------------------
-
-    def announce(self, msg, level=log.INFO):
-        log.log(level, msg)
-
-    def run_commands(self):
-        """Run each command that was seen on the setup script command line.
-        Uses the list of commands found and cache of command objects
-        created by 'get_command_obj()'.
-        """
-        for cmd in self.commands:
-            self.run_command(cmd)
-
-    # -- Methods that operate on its Commands --------------------------
-
-    def run_command(self, command):
-        """Do whatever it takes to run a command (including nothing at all,
-        if the command has already been run).  Specifically: if we have
-        already created and run the command named by 'command', return
-        silently without doing anything.  If the command named by 'command'
-        doesn't even have a command object yet, create one.  Then invoke
-        'run()' on that command object (or an existing one).
-        """
-        # Already been here, done that? then return silently.
-        if self.have_run.get(command):
-            return
-
-        log.info("running %s", command)
-        cmd_obj = self.get_command_obj(command)
-        cmd_obj.ensure_finalized()
-        cmd_obj.run()
-        self.have_run[command] = 1
-
-    # -- Distribution query methods ------------------------------------
-
-    def has_pure_modules(self):
-        return len(self.packages or self.py_modules or []) > 0
-
-    def has_ext_modules(self):
-        return self.ext_modules and len(self.ext_modules) > 0
-
-    def has_c_libraries(self):
-        return self.libraries and len(self.libraries) > 0
-
-    def has_modules(self):
-        return self.has_pure_modules() or self.has_ext_modules()
-
-    def has_headers(self):
-        return self.headers and len(self.headers) > 0
-
-    def has_scripts(self):
-        return self.scripts and len(self.scripts) > 0
-
-    def has_data_files(self):
-        return self.data_files and len(self.data_files) > 0
-
-    def is_pure(self):
-        return (self.has_pure_modules() and
-                not self.has_ext_modules() and
-                not self.has_c_libraries())
-
-    # -- Metadata query methods ----------------------------------------
-
-    # If you're looking for 'get_name()', 'get_version()', and so forth,
-    # they are defined in a sneaky way: the constructor binds self.get_XXX
-    # to self.metadata.get_XXX.  The actual code is in the
-    # DistributionMetadata class, below.
-
-class DistributionMetadata:
-    """Dummy class to hold the distribution meta-data: name, version,
-    author, and so forth.
-    """
-
-    _METHOD_BASENAMES = ("name", "version", "author", "author_email",
-                         "maintainer", "maintainer_email", "url",
-                         "license", "description", "long_description",
-                         "keywords", "platforms", "fullname", "contact",
-                         "contact_email", "classifiers", "download_url",
-                         # PEP 314
-                         "provides", "requires", "obsoletes",
-                         )
-
-    def __init__(self, path=None):
-        if path is not None:
-            self.read_pkg_file(open(path))
-        else:
-            self.name = None
-            self.version = None
-            self.author = None
-            self.author_email = None
-            self.maintainer = None
-            self.maintainer_email = None
-            self.url = None
-            self.license = None
-            self.description = None
-            self.long_description = None
-            self.keywords = None
-            self.platforms = None
-            self.classifiers = None
-            self.download_url = None
-            # PEP 314
-            self.provides = None
-            self.requires = None
-            self.obsoletes = None
-
-    def read_pkg_file(self, file):
-        """Reads the metadata values from a file object."""
-        msg = message_from_file(file)
-
-        def _read_field(name):
-            value = msg[name]
-            if value == 'UNKNOWN':
-                return None
-            return value
-
-        def _read_list(name):
-            values = msg.get_all(name, None)
-            if values == []:
-                return None
-            return values
-
-        metadata_version = msg['metadata-version']
-        self.name = _read_field('name')
-        self.version = _read_field('version')
-        self.description = _read_field('summary')
-        # we are filling author only.
-        self.author = _read_field('author')
-        self.maintainer = None
-        self.author_email = _read_field('author-email')
-        self.maintainer_email = None
-        self.url = _read_field('home-page')
-        self.license = _read_field('license')
-
-        if 'download-url' in msg:
-            self.download_url = _read_field('download-url')
-        else:
-            self.download_url = None
-
-        self.long_description = _read_field('description')
-        self.description = _read_field('summary')
-
-        if 'keywords' in msg:
-            self.keywords = _read_field('keywords').split(',')
-
-        self.platforms = _read_list('platform')
-        self.classifiers = _read_list('classifier')
-
-        # PEP 314 - these fields only exist in 1.1
-        if metadata_version == '1.1':
-            self.requires = _read_list('requires')
-            self.provides = _read_list('provides')
-            self.obsoletes = _read_list('obsoletes')
-        else:
-            self.requires = None
-            self.provides = None
-            self.obsoletes = None
-
-    def write_pkg_info(self, base_dir):
-        """Write the PKG-INFO file into the release tree.
-        """
-        with open(os.path.join(base_dir, 'PKG-INFO'), 'w',
-                  encoding='UTF-8') as pkg_info:
-            self.write_pkg_file(pkg_info)
-
-    def write_pkg_file(self, file):
-        """Write the PKG-INFO format data to a file object.
-        """
-        version = '1.0'
-        if (self.provides or self.requires or self.obsoletes or
-                self.classifiers or self.download_url):
-            version = '1.1'
-
-        file.write('Metadata-Version: %s\n' % version)
-        file.write('Name: %s\n' % self.get_name())
-        file.write('Version: %s\n' % self.get_version())
-        file.write('Summary: %s\n' % self.get_description())
-        file.write('Home-page: %s\n' % self.get_url())
-        file.write('Author: %s\n' % self.get_contact())
-        file.write('Author-email: %s\n' % self.get_contact_email())
-        file.write('License: %s\n' % self.get_license())
-        if self.download_url:
-            file.write('Download-URL: %s\n' % self.download_url)
-
-        long_desc = rfc822_escape(self.get_long_description())
-        file.write('Description: %s\n' % long_desc)
-
-        keywords = ','.join(self.get_keywords())
-        if keywords:
-            file.write('Keywords: %s\n' % keywords)
-
-        self._write_list(file, 'Platform', self.get_platforms())
-        self._write_list(file, 'Classifier', self.get_classifiers())
-
-        # PEP 314
-        self._write_list(file, 'Requires', self.get_requires())
-        self._write_list(file, 'Provides', self.get_provides())
-        self._write_list(file, 'Obsoletes', self.get_obsoletes())
-
-    def _write_list(self, file, name, values):
-        for value in values:
-            file.write('%s: %s\n' % (name, value))
-
-    # -- Metadata query methods ----------------------------------------
-
-    def get_name(self):
-        return self.name or "UNKNOWN"
-
-    def get_version(self):
-        return self.version or "0.0.0"
-
-    def get_fullname(self):
-        return "%s-%s" % (self.get_name(), self.get_version())
-
-    def get_author(self):
-        return self.author or "UNKNOWN"
-
-    def get_author_email(self):
-        return self.author_email or "UNKNOWN"
-
-    def get_maintainer(self):
-        return self.maintainer or "UNKNOWN"
-
-    def get_maintainer_email(self):
-        return self.maintainer_email or "UNKNOWN"
-
-    def get_contact(self):
-        return self.maintainer or self.author or "UNKNOWN"
-
-    def get_contact_email(self):
-        return self.maintainer_email or self.author_email or "UNKNOWN"
-
-    def get_url(self):
-        return self.url or "UNKNOWN"
-
-    def get_license(self):
-        return self.license or "UNKNOWN"
-    get_licence = get_license
-
-    def get_description(self):
-        return self.description or "UNKNOWN"
-
-    def get_long_description(self):
-        return self.long_description or "UNKNOWN"
-
-    def get_keywords(self):
-        return self.keywords or []
-
-    def get_platforms(self):
-        return self.platforms or ["UNKNOWN"]
-
-    def get_classifiers(self):
-        return self.classifiers or []
-
-    def get_download_url(self):
-        return self.download_url or "UNKNOWN"
-
-    # PEP 314
-    def get_requires(self):
-        return self.requires or []
-
-    def set_requires(self, value):
-        import distutils.versionpredicate
-        for v in value:
-            distutils.versionpredicate.VersionPredicate(v)
-        self.requires = value
-
-    def get_provides(self):
-        return self.provides or []
-
-    def set_provides(self, value):
-        value = [v.strip() for v in value]
-        for v in value:
-            import distutils.versionpredicate
-            distutils.versionpredicate.split_provision(v)
-        self.provides = value
-
-    def get_obsoletes(self):
-        return self.obsoletes or []
-
-    def set_obsoletes(self, value):
-        import distutils.versionpredicate
-        for v in value:
-            distutils.versionpredicate.VersionPredicate(v)
-        self.obsoletes = value
-
-def fix_help_options(options):
-    """Convert a 4-tuple 'help_options' list as found in various command
-    classes to the 3-tuple form required by FancyGetopt.
-    """
-    new_options = []
-    for help_tuple in options:
-        new_options.append(help_tuple[0:3])
-    return new_options
diff --git a/Lib/distutils/errors.py b/Lib/distutils/errors.py
deleted file mode 100644
index 8b93059e19..0000000000
--- a/Lib/distutils/errors.py
+++ /dev/null
@@ -1,97 +0,0 @@
-"""distutils.errors
-
-Provides exceptions used by the Distutils modules.  Note that Distutils
-modules may raise standard exceptions; in particular, SystemExit is
-usually raised for errors that are obviously the end-user's fault
-(eg. bad command-line arguments).
-
-This module is safe to use in "from ... import *" mode; it only exports
-symbols whose names start with "Distutils" and end with "Error"."""
-
-class DistutilsError (Exception):
-    """The root of all Distutils evil."""
-    pass
-
-class DistutilsModuleError (DistutilsError):
-    """Unable to load an expected module, or to find an expected class
-    within some module (in particular, command modules and classes)."""
-    pass
-
-class DistutilsClassError (DistutilsError):
-    """Some command class (or possibly distribution class, if anyone
-    feels a need to subclass Distribution) is found not to be holding
-    up its end of the bargain, ie. implementing some part of the
-    "command "interface."""
-    pass
-
-class DistutilsGetoptError (DistutilsError):
-    """The option table provided to 'fancy_getopt()' is bogus."""
-    pass
-
-class DistutilsArgError (DistutilsError):
-    """Raised by fancy_getopt in response to getopt.error -- ie. an
-    error in the command line usage."""
-    pass
-
-class DistutilsFileError (DistutilsError):
-    """Any problems in the filesystem: expected file not found, etc.
-    Typically this is for problems that we detect before OSError
-    could be raised."""
-    pass
-
-class DistutilsOptionError (DistutilsError):
-    """Syntactic/semantic errors in command options, such as use of
-    mutually conflicting options, or inconsistent options,
-    badly-spelled values, etc.  No distinction is made between option
-    values originating in the setup script, the command line, config
-    files, or what-have-you -- but if we *know* something originated in
-    the setup script, we'll raise DistutilsSetupError instead."""
-    pass
-
-class DistutilsSetupError (DistutilsError):
-    """For errors that can be definitely blamed on the setup script,
-    such as invalid keyword arguments to 'setup()'."""
-    pass
-
-class DistutilsPlatformError (DistutilsError):
-    """We don't know how to do something on the current platform (but
-    we do know how to do it on some platform) -- eg. trying to compile
-    C files on a platform not supported by a CCompiler subclass."""
-    pass
-
-class DistutilsExecError (DistutilsError):
-    """Any problems executing an external program (such as the C
-    compiler, when compiling C files)."""
-    pass
-
-class DistutilsInternalError (DistutilsError):
-    """Internal inconsistencies or impossibilities (obviously, this
-    should never be seen if the code is working!)."""
-    pass
-
-class DistutilsTemplateError (DistutilsError):
-    """Syntax error in a file list template."""
-
-class DistutilsByteCompileError(DistutilsError):
-    """Byte compile error."""
-
-# Exception classes used by the CCompiler implementation classes
-class CCompilerError (Exception):
-    """Some compile/link operation failed."""
-
-class PreprocessError (CCompilerError):
-    """Failure to preprocess one or more C/C++ files."""
-
-class CompileError (CCompilerError):
-    """Failure to compile one or more C/C++ source files."""
-
-class LibError (CCompilerError):
-    """Failure to create a static library from one or more C/C++ object
-    files."""
-
-class LinkError (CCompilerError):
-    """Failure to link one or more C/C++ object files into an executable
-    or shared library file."""
-
-class UnknownFileError (CCompilerError):
-    """Attempt to process an unknown file type."""
diff --git a/Lib/distutils/extension.py b/Lib/distutils/extension.py
deleted file mode 100644
index c507da360a..0000000000
--- a/Lib/distutils/extension.py
+++ /dev/null
@@ -1,240 +0,0 @@
-"""distutils.extension
-
-Provides the Extension class, used to describe C/C++ extension
-modules in setup scripts."""
-
-import os
-import warnings
-
-# This class is really only used by the "build_ext" command, so it might
-# make sense to put it in distutils.command.build_ext.  However, that
-# module is already big enough, and I want to make this class a bit more
-# complex to simplify some common cases ("foo" module in "foo.c") and do
-# better error-checking ("foo.c" actually exists).
-#
-# Also, putting this in build_ext.py means every setup script would have to
-# import that large-ish module (indirectly, through distutils.core) in
-# order to do anything.
-
-class Extension:
-    """Just a collection of attributes that describes an extension
-    module and everything needed to build it (hopefully in a portable
-    way, but there are hooks that let you be as unportable as you need).
-
-    Instance attributes:
-      name : string
-        the full name of the extension, including any packages -- ie.
-        *not* a filename or pathname, but Python dotted name
-      sources : [string]
-        list of source filenames, relative to the distribution root
-        (where the setup script lives), in Unix form (slash-separated)
-        for portability.  Source files may be C, C++, SWIG (.i),
-        platform-specific resource files, or whatever else is recognized
-        by the "build_ext" command as source for a Python extension.
-      include_dirs : [string]
-        list of directories to search for C/C++ header files (in Unix
-        form for portability)
-      define_macros : [(name : string, value : string|None)]
-        list of macros to define; each macro is defined using a 2-tuple,
-        where 'value' is either the string to define it to or None to
-        define it without a particular value (equivalent of "#define
-        FOO" in source or -DFOO on Unix C compiler command line)
-      undef_macros : [string]
-        list of macros to undefine explicitly
-      library_dirs : [string]
-        list of directories to search for C/C++ libraries at link time
-      libraries : [string]
-        list of library names (not filenames or paths) to link against
-      runtime_library_dirs : [string]
-        list of directories to search for C/C++ libraries at run time
-        (for shared extensions, this is when the extension is loaded)
-      extra_objects : [string]
-        list of extra files to link with (eg. object files not implied
-        by 'sources', static library that must be explicitly specified,
-        binary resource files, etc.)
-      extra_compile_args : [string]
-        any extra platform- and compiler-specific information to use
-        when compiling the source files in 'sources'.  For platforms and
-        compilers where "command line" makes sense, this is typically a
-        list of command-line arguments, but for other platforms it could
-        be anything.
-      extra_link_args : [string]
-        any extra platform- and compiler-specific information to use
-        when linking object files together to create the extension (or
-        to create a new static Python interpreter).  Similar
-        interpretation as for 'extra_compile_args'.
-      export_symbols : [string]
-        list of symbols to be exported from a shared extension.  Not
-        used on all platforms, and not generally necessary for Python
-        extensions, which typically export exactly one symbol: "init" +
-        extension_name.
-      swig_opts : [string]
-        any extra options to pass to SWIG if a source file has the .i
-        extension.
-      depends : [string]
-        list of files that the extension depends on
-      language : string
-        extension language (i.e. "c", "c++", "objc"). Will be detected
-        from the source extensions if not provided.
-      optional : boolean
-        specifies that a build failure in the extension should not abort the
-        build process, but simply not install the failing extension.
-    """
-
-    # When adding arguments to this constructor, be sure to update
-    # setup_keywords in core.py.
-    def __init__(self, name, sources,
-                  include_dirs=None,
-                  define_macros=None,
-                  undef_macros=None,
-                  library_dirs=None,
-                  libraries=None,
-                  runtime_library_dirs=None,
-                  extra_objects=None,
-                  extra_compile_args=None,
-                  extra_link_args=None,
-                  export_symbols=None,
-                  swig_opts = None,
-                  depends=None,
-                  language=None,
-                  optional=None,
-                  **kw                      # To catch unknown keywords
-                 ):
-        if not isinstance(name, str):
-            raise AssertionError("'name' must be a string")
-        if not (isinstance(sources, list) and
-                all(isinstance(v, str) for v in sources)):
-            raise AssertionError("'sources' must be a list of strings")
-
-        self.name = name
-        self.sources = sources
-        self.include_dirs = include_dirs or []
-        self.define_macros = define_macros or []
-        self.undef_macros = undef_macros or []
-        self.library_dirs = library_dirs or []
-        self.libraries = libraries or []
-        self.runtime_library_dirs = runtime_library_dirs or []
-        self.extra_objects = extra_objects or []
-        self.extra_compile_args = extra_compile_args or []
-        self.extra_link_args = extra_link_args or []
-        self.export_symbols = export_symbols or []
-        self.swig_opts = swig_opts or []
-        self.depends = depends or []
-        self.language = language
-        self.optional = optional
-
-        # If there are unknown keyword options, warn about them
-        if len(kw) > 0:
-            options = [repr(option) for option in kw]
-            options = ', '.join(sorted(options))
-            msg = "Unknown Extension options: %s" % options
-            warnings.warn(msg)
-
-    def __repr__(self):
-        return '<%s.%s(%r) at %#x>' % (
-            self.__class__.__module__,
-            self.__class__.__qualname__,
-            self.name,
-            id(self))
-
-
-def read_setup_file(filename):
-    """Reads a Setup file and returns Extension instances."""
-    from distutils.sysconfig import (parse_makefile, expand_makefile_vars,
-                                     _variable_rx)
-
-    from distutils.text_file import TextFile
-    from distutils.util import split_quoted
-
-    # First pass over the file to gather "VAR = VALUE" assignments.
-    vars = parse_makefile(filename)
-
-    # Second pass to gobble up the real content: lines of the form
-    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
-    file = TextFile(filename,
-                    strip_comments=1, skip_blanks=1, join_lines=1,
-                    lstrip_ws=1, rstrip_ws=1)
-    try:
-        extensions = []
-
-        while True:
-            line = file.readline()
-            if line is None:                # eof
-                break
-            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
-                continue
-
-            if line[0] == line[-1] == "*":
-                file.warn("'%s' lines not handled yet" % line)
-                continue
-
-            line = expand_makefile_vars(line, vars)
-            words = split_quoted(line)
-
-            # NB. this parses a slightly different syntax than the old
-            # makesetup script: here, there must be exactly one extension per
-            # line, and it must be the first word of the line.  I have no idea
-            # why the old syntax supported multiple extensions per line, as
-            # they all wind up being the same.
-
-            module = words[0]
-            ext = Extension(module, [])
-            append_next_word = None
-
-            for word in words[1:]:
-                if append_next_word is not None:
-                    append_next_word.append(word)
-                    append_next_word = None
-                    continue
-
-                suffix = os.path.splitext(word)[1]
-                switch = word[0:2] ; value = word[2:]
-
-                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
-                    # hmm, should we do something about C vs. C++ sources?
-                    # or leave it up to the CCompiler implementation to
-                    # worry about?
-                    ext.sources.append(word)
-                elif switch == "-I":
-                    ext.include_dirs.append(value)
-                elif switch == "-D":
-                    equals = value.find("=")
-                    if equals == -1:        # bare "-DFOO" -- no value
-                        ext.define_macros.append((value, None))
-                    else:                   # "-DFOO=blah"
-                        ext.define_macros.append((value[0:equals],
-                                                  value[equals+2:]))
-                elif switch == "-U":
-                    ext.undef_macros.append(value)
-                elif switch == "-C":        # only here 'cause makesetup has it!
-                    ext.extra_compile_args.append(word)
-                elif switch == "-l":
-                    ext.libraries.append(value)
-                elif switch == "-L":
-                    ext.library_dirs.append(value)
-                elif switch == "-R":
-                    ext.runtime_library_dirs.append(value)
-                elif word == "-rpath":
-                    append_next_word = ext.runtime_library_dirs
-                elif word == "-Xlinker":
-                    append_next_word = ext.extra_link_args
-                elif word == "-Xcompiler":
-                    append_next_word = ext.extra_compile_args
-                elif switch == "-u":
-                    ext.extra_link_args.append(word)
-                    if not value:
-                        append_next_word = ext.extra_link_args
-                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
-                    # NB. a really faithful emulation of makesetup would
-                    # append a .o file to extra_objects only if it
-                    # had a slash in it; otherwise, it would s/.o/.c/
-                    # and append it to sources.  Hmmmm.
-                    ext.extra_objects.append(word)
-                else:
-                    file.warn("unrecognized argument '%s'" % word)
-
-            extensions.append(ext)
-    finally:
-        file.close()
-
-    return extensions
diff --git a/Lib/distutils/fancy_getopt.py b/Lib/distutils/fancy_getopt.py
deleted file mode 100644
index 7d170dd277..0000000000
--- a/Lib/distutils/fancy_getopt.py
+++ /dev/null
@@ -1,457 +0,0 @@
-"""distutils.fancy_getopt
-
-Wrapper around the standard getopt module that provides the following
-additional features:
-  * short and long options are tied together
-  * options have help strings, so fancy_getopt could potentially
-    create a complete usage summary
-  * options set attributes of a passed-in object
-"""
-
-import sys, string, re
-import getopt
-from distutils.errors import *
-
-# Much like command_re in distutils.core, this is close to but not quite
-# the same as a Python NAME -- except, in the spirit of most GNU
-# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
-# The similarities to NAME are again not a coincidence...
-longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
-longopt_re = re.compile(r'^%s$' % longopt_pat)
-
-# For recognizing "negative alias" options, eg. "quiet=!verbose"
-neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))
-
-# This is used to translate long options to legitimate Python identifiers
-# (for use as attributes of some object).
-longopt_xlate = str.maketrans('-', '_')
-
-class FancyGetopt:
-    """Wrapper around the standard 'getopt()' module that provides some
-    handy extra functionality:
-      * short and long options are tied together
-      * options have help strings, and help text can be assembled
-        from them
-      * options set attributes of a passed-in object
-      * boolean options can have "negative aliases" -- eg. if
-        --quiet is the "negative alias" of --verbose, then "--quiet"
-        on the command line sets 'verbose' to false
-    """
-
-    def __init__(self, option_table=None):
-        # The option table is (currently) a list of tuples.  The
-        # tuples may have 3 or four values:
-        #   (long_option, short_option, help_string [, repeatable])
-        # if an option takes an argument, its long_option should have '='
-        # appended; short_option should just be a single character, no ':'
-        # in any case.  If a long_option doesn't have a corresponding
-        # short_option, short_option should be None.  All option tuples
-        # must have long options.
-        self.option_table = option_table
-
-        # 'option_index' maps long option names to entries in the option
-        # table (ie. those 3-tuples).
-        self.option_index = {}
-        if self.option_table:
-            self._build_index()
-
-        # 'alias' records (duh) alias options; {'foo': 'bar'} means
-        # --foo is an alias for --bar
-        self.alias = {}
-
-        # 'negative_alias' keeps track of options that are the boolean
-        # opposite of some other option
-        self.negative_alias = {}
-
-        # These keep track of the information in the option table.  We
-        # don't actually populate these structures until we're ready to
-        # parse the command-line, since the 'option_table' passed in here
-        # isn't necessarily the final word.
-        self.short_opts = []
-        self.long_opts = []
-        self.short2long = {}
-        self.attr_name = {}
-        self.takes_arg = {}
-
-        # And 'option_order' is filled up in 'getopt()'; it records the
-        # original order of options (and their values) on the command-line,
-        # but expands short options, converts aliases, etc.
-        self.option_order = []
-
-    def _build_index(self):
-        self.option_index.clear()
-        for option in self.option_table:
-            self.option_index[option[0]] = option
-
-    def set_option_table(self, option_table):
-        self.option_table = option_table
-        self._build_index()
-
-    def add_option(self, long_option, short_option=None, help_string=None):
-        if long_option in self.option_index:
-            raise DistutilsGetoptError(
-                  "option conflict: already an option '%s'" % long_option)
-        else:
-            option = (long_option, short_option, help_string)
-            self.option_table.append(option)
-            self.option_index[long_option] = option
-
-    def has_option(self, long_option):
-        """Return true if the option table for this parser has an
-        option with long name 'long_option'."""
-        return long_option in self.option_index
-
-    def get_attr_name(self, long_option):
-        """Translate long option name 'long_option' to the form it
-        has as an attribute of some object: ie., translate hyphens
-        to underscores."""
-        return long_option.translate(longopt_xlate)
-
-    def _check_alias_dict(self, aliases, what):
-        assert isinstance(aliases, dict)
-        for (alias, opt) in aliases.items():
-            if alias not in self.option_index:
-                raise DistutilsGetoptError(("invalid %s '%s': "
-                       "option '%s' not defined") % (what, alias, alias))
-            if opt not in self.option_index:
-                raise DistutilsGetoptError(("invalid %s '%s': "
-                       "aliased option '%s' not defined") % (what, alias, opt))
-
-    def set_aliases(self, alias):
-        """Set the aliases for this option parser."""
-        self._check_alias_dict(alias, "alias")
-        self.alias = alias
-
-    def set_negative_aliases(self, negative_alias):
-        """Set the negative aliases for this option parser.
-        'negative_alias' should be a dictionary mapping option names to
-        option names, both the key and value must already be defined
-        in the option table."""
-        self._check_alias_dict(negative_alias, "negative alias")
-        self.negative_alias = negative_alias
-
-    def _grok_option_table(self):
-        """Populate the various data structures that keep tabs on the
-        option table.  Called by 'getopt()' before it can do anything
-        worthwhile.
-        """
-        self.long_opts = []
-        self.short_opts = []
-        self.short2long.clear()
-        self.repeat = {}
-
-        for option in self.option_table:
-            if len(option) == 3:
-                long, short, help = option
-                repeat = 0
-            elif len(option) == 4:
-                long, short, help, repeat = option
-            else:
-                # the option table is part of the code, so simply
-                # assert that it is correct
-                raise ValueError("invalid option tuple: %r" % (option,))
-
-            # Type- and value-check the option names
-            if not isinstance(long, str) or len(long) < 2:
-                raise DistutilsGetoptError(("invalid long option '%s': "
-                       "must be a string of length >= 2") % long)
-
-            if (not ((short is None) or
-                     (isinstance(short, str) and len(short) == 1))):
-                raise DistutilsGetoptError("invalid short option '%s': "
-                       "must a single character or None" % short)
-
-            self.repeat[long] = repeat
-            self.long_opts.append(long)
-
-            if long[-1] == '=':             # option takes an argument?
-                if short: short = short + ':'
-                long = long[0:-1]
-                self.takes_arg[long] = 1
-            else:
-                # Is option is a "negative alias" for some other option (eg.
-                # "quiet" == "!verbose")?
-                alias_to = self.negative_alias.get(long)
-                if alias_to is not None:
-                    if self.takes_arg[alias_to]:
-                        raise DistutilsGetoptError(
-                              "invalid negative alias '%s': "
-                              "aliased option '%s' takes a value"
-                              % (long, alias_to))
-
-                    self.long_opts[-1] = long # XXX redundant?!
-                self.takes_arg[long] = 0
-
-            # If this is an alias option, make sure its "takes arg" flag is
-            # the same as the option it's aliased to.
-            alias_to = self.alias.get(long)
-            if alias_to is not None:
-                if self.takes_arg[long] != self.takes_arg[alias_to]:
-                    raise DistutilsGetoptError(
-                          "invalid alias '%s': inconsistent with "
-                          "aliased option '%s' (one of them takes a value, "
-                          "the other doesn't"
-                          % (long, alias_to))
-
-            # Now enforce some bondage on the long option name, so we can
-            # later translate it to an attribute name on some object.  Have
-            # to do this a bit late to make sure we've removed any trailing
-            # '='.
-            if not longopt_re.match(long):
-                raise DistutilsGetoptError(
-                       "invalid long option name '%s' "
-                       "(must be letters, numbers, hyphens only" % long)
-
-            self.attr_name[long] = self.get_attr_name(long)
-            if short:
-                self.short_opts.append(short)
-                self.short2long[short[0]] = long
-
-    def getopt(self, args=None, object=None):
-        """Parse command-line options in args. Store as attributes on object.
-
-        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
-        'object' is None or not supplied, creates a new OptionDummy
-        object, stores option values there, and returns a tuple (args,
-        object).  If 'object' is supplied, it is modified in place and
-        'getopt()' just returns 'args'; in both cases, the returned
-        'args' is a modified copy of the passed-in 'args' list, which
-        is left untouched.
-        """
-        if args is None:
-            args = sys.argv[1:]
-        if object is None:
-            object = OptionDummy()
-            created_object = True
-        else:
-            created_object = False
-
-        self._grok_option_table()
-
-        short_opts = ' '.join(self.short_opts)
-        try:
-            opts, args = getopt.getopt(args, short_opts, self.long_opts)
-        except getopt.error as msg:
-            raise DistutilsArgError(msg)
-
-        for opt, val in opts:
-            if len(opt) == 2 and opt[0] == '-': # it's a short option
-                opt = self.short2long[opt[1]]
-            else:
-                assert len(opt) > 2 and opt[:2] == '--'
-                opt = opt[2:]
-
-            alias = self.alias.get(opt)
-            if alias:
-                opt = alias
-
-            if not self.takes_arg[opt]:     # boolean option?
-                assert val == '', "boolean option can't have value"
-                alias = self.negative_alias.get(opt)
-                if alias:
-                    opt = alias
-                    val = 0
-                else:
-                    val = 1
-
-            attr = self.attr_name[opt]
-            # The only repeating option at the moment is 'verbose'.
-            # It has a negative option -q quiet, which should set verbose = 0.
-            if val and self.repeat.get(attr) is not None:
-                val = getattr(object, attr, 0) + 1
-            setattr(object, attr, val)
-            self.option_order.append((opt, val))
-
-        # for opts
-        if created_object:
-            return args, object
-        else:
-            return args
-
-    def get_option_order(self):
-        """Returns the list of (option, value) tuples processed by the
-        previous run of 'getopt()'.  Raises RuntimeError if
-        'getopt()' hasn't been called yet.
-        """
-        if self.option_order is None:
-            raise RuntimeError("'getopt()' hasn't been called yet")
-        else:
-            return self.option_order
-
-    def generate_help(self, header=None):
-        """Generate help text (a list of strings, one per suggested line of
-        output) from the option table for this FancyGetopt object.
-        """
-        # Blithely assume the option table is good: probably wouldn't call
-        # 'generate_help()' unless you've already called 'getopt()'.
-
-        # First pass: determine maximum length of long option names
-        max_opt = 0
-        for option in self.option_table:
-            long = option[0]
-            short = option[1]
-            l = len(long)
-            if long[-1] == '=':
-                l = l - 1
-            if short is not None:
-                l = l + 5                   # " (-x)" where short == 'x'
-            if l > max_opt:
-                max_opt = l
-
-        opt_width = max_opt + 2 + 2 + 2     # room for indent + dashes + gutter
-
-        # Typical help block looks like this:
-        #   --foo       controls foonabulation
-        # Help block for longest option looks like this:
-        #   --flimflam  set the flim-flam level
-        # and with wrapped text:
-        #   --flimflam  set the flim-flam level (must be between
-        #               0 and 100, except on Tuesdays)
-        # Options with short names will have the short name shown (but
-        # it doesn't contribute to max_opt):
-        #   --foo (-f)  controls foonabulation
-        # If adding the short option would make the left column too wide,
-        # we push the explanation off to the next line
-        #   --flimflam (-l)
-        #               set the flim-flam level
-        # Important parameters:
-        #   - 2 spaces before option block start lines
-        #   - 2 dashes for each long option name
-        #   - min. 2 spaces between option and explanation (gutter)
-        #   - 5 characters (incl. space) for short option name
-
-        # Now generate lines of help text.  (If 80 columns were good enough
-        # for Jesus, then 78 columns are good enough for me!)
-        line_width = 78
-        text_width = line_width - opt_width
-        big_indent = ' ' * opt_width
-        if header:
-            lines = [header]
-        else:
-            lines = ['Option summary:']
-
-        for option in self.option_table:
-            long, short, help = option[:3]
-            text = wrap_text(help, text_width)
-            if long[-1] == '=':
-                long = long[0:-1]
-
-            # Case 1: no short option at all (makes life easy)
-            if short is None:
-                if text:
-                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
-                else:
-                    lines.append("  --%-*s  " % (max_opt, long))
-
-            # Case 2: we have a short option, so we have to include it
-            # just after the long option
-            else:
-                opt_names = "%s (-%s)" % (long, short)
-                if text:
-                    lines.append("  --%-*s  %s" %
-                                 (max_opt, opt_names, text[0]))
-                else:
-                    lines.append("  --%-*s" % opt_names)
-
-            for l in text[1:]:
-                lines.append(big_indent + l)
-        return lines
-
-    def print_help(self, header=None, file=None):
-        if file is None:
-            file = sys.stdout
-        for line in self.generate_help(header):
-            file.write(line + "\n")
-
-
-def fancy_getopt(options, negative_opt, object, args):
-    parser = FancyGetopt(options)
-    parser.set_negative_aliases(negative_opt)
-    return parser.getopt(args, object)
-
-
-WS_TRANS = {ord(_wschar) : ' ' for _wschar in string.whitespace}
-
-def wrap_text(text, width):
-    """wrap_text(text : string, width : int) -> [string]
-
-    Split 'text' into multiple lines of no more than 'width' characters
-    each, and return the list of strings that results.
-    """
-    if text is None:
-        return []
-    if len(text) <= width:
-        return [text]
-
-    text = text.expandtabs()
-    text = text.translate(WS_TRANS)
-    chunks = re.split(r'( +|-+)', text)
-    chunks = [ch for ch in chunks if ch] # ' - ' results in empty strings
-    lines = []
-
-    while chunks:
-        cur_line = []                   # list of chunks (to-be-joined)
-        cur_len = 0                     # length of current line
-
-        while chunks:
-            l = len(chunks[0])
-            if cur_len + l <= width:    # can squeeze (at least) this chunk in
-                cur_line.append(chunks[0])
-                del chunks[0]
-                cur_len = cur_len + l
-            else:                       # this line is full
-                # drop last chunk if all space
-                if cur_line and cur_line[-1][0] == ' ':
-                    del cur_line[-1]
-                break
-
-        if chunks:                      # any chunks left to process?
-            # if the current line is still empty, then we had a single
-            # chunk that's too big too fit on a line -- so we break
-            # down and break it up at the line width
-            if cur_len == 0:
-                cur_line.append(chunks[0][0:width])
-                chunks[0] = chunks[0][width:]
-
-            # all-whitespace chunks at the end of a line can be discarded
-            # (and we know from the re.split above that if a chunk has
-            # *any* whitespace, it is *all* whitespace)
-            if chunks[0][0] == ' ':
-                del chunks[0]
-
-        # and store this line in the list-of-all-lines -- as a single
-        # string, of course!
-        lines.append(''.join(cur_line))
-
-    return lines
-
-
-def translate_longopt(opt):
-    """Convert a long option name to a valid Python identifier by
-    changing "-" to "_".
-    """
-    return opt.translate(longopt_xlate)
-
-
-class OptionDummy:
-    """Dummy class just used as a place to hold command-line option
-    values as instance attributes."""
-
-    def __init__(self, options=[]):
-        """Create a new OptionDummy instance.  The attributes listed in
-        'options' will be initialized to None."""
-        for opt in options:
-            setattr(self, opt, None)
-
-
-if __name__ == "__main__":
-    text = """\
-Tra-la-la, supercalifragilisticexpialidocious.
-How *do* you spell that odd word, anyways?
-(Someone ask Mary -- she'll know [or she'll
-say, "How should I know?"].)"""
-
-    for w in (10, 20, 30, 40):
-        print("width: %d" % w)
-        print("\n".join(wrap_text(text, w)))
-        print()
diff --git a/Lib/distutils/file_util.py b/Lib/distutils/file_util.py
deleted file mode 100644
index b3fee35a6c..0000000000
--- a/Lib/distutils/file_util.py
+++ /dev/null
@@ -1,238 +0,0 @@
-"""distutils.file_util
-
-Utility functions for operating on single files.
-"""
-
-import os
-from distutils.errors import DistutilsFileError
-from distutils import log
-
-# for generating verbose output in 'copy_file()'
-_copy_action = { None:   'copying',
-                 'hard': 'hard linking',
-                 'sym':  'symbolically linking' }
-
-
-def _copy_file_contents(src, dst, buffer_size=16*1024):
-    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
-    opening either file, reading from 'src', or writing to 'dst', raises
-    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
-    bytes (default 16k).  No attempt is made to handle anything apart from
-    regular files.
-    """
-    # Stolen from shutil module in the standard library, but with
-    # custom error-handling added.
-    fsrc = None
-    fdst = None
-    try:
-        try:
-            fsrc = open(src, 'rb')
-        except OSError as e:
-            raise DistutilsFileError("could not open '%s': %s" % (src, e.strerror))
-
-        if os.path.exists(dst):
-            try:
-                os.unlink(dst)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not delete '%s': %s" % (dst, e.strerror))
-
-        try:
-            fdst = open(dst, 'wb')
-        except OSError as e:
-            raise DistutilsFileError(
-                  "could not create '%s': %s" % (dst, e.strerror))
-
-        while True:
-            try:
-                buf = fsrc.read(buffer_size)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not read from '%s': %s" % (src, e.strerror))
-
-            if not buf:
-                break
-
-            try:
-                fdst.write(buf)
-            except OSError as e:
-                raise DistutilsFileError(
-                      "could not write to '%s': %s" % (dst, e.strerror))
-    finally:
-        if fdst:
-            fdst.close()
-        if fsrc:
-            fsrc.close()
-
-def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
-              link=None, verbose=1, dry_run=0):
-    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
-    copied there with the same name; otherwise, it must be a filename.  (If
-    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
-    is true (the default), the file's mode (type and permission bits, or
-    whatever is analogous on the current platform) is copied.  If
-    'preserve_times' is true (the default), the last-modified and
-    last-access times are copied as well.  If 'update' is true, 'src' will
-    only be copied if 'dst' does not exist, or if 'dst' does exist but is
-    older than 'src'.
-
-    'link' allows you to make hard links (os.link) or symbolic links
-    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
-    None (the default), files are copied.  Don't set 'link' on systems that
-    don't support it: 'copy_file()' doesn't check if hard or symbolic
-    linking is available. If hardlink fails, falls back to
-    _copy_file_contents().
-
-    Under Mac OS, uses the native file copy function in macostools; on
-    other systems, uses '_copy_file_contents()' to copy file contents.
-
-    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
-    the output file, and 'copied' is true if the file was copied (or would
-    have been copied, if 'dry_run' true).
-    """
-    # XXX if the destination file already exists, we clobber it if
-    # copying, but blow up if linking.  Hmmm.  And I don't know what
-    # macostools.copyfile() does.  Should definitely be consistent, and
-    # should probably blow up if destination exists and we would be
-    # changing it (ie. it's not already a hard/soft link to src OR
-    # (not update) and (src newer than dst).
-
-    from distutils.dep_util import newer
-    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE
-
-    if not os.path.isfile(src):
-        raise DistutilsFileError(
-              "can't copy '%s': doesn't exist or not a regular file" % src)
-
-    if os.path.isdir(dst):
-        dir = dst
-        dst = os.path.join(dst, os.path.basename(src))
-    else:
-        dir = os.path.dirname(dst)
-
-    if update and not newer(src, dst):
-        if verbose >= 1:
-            log.debug("not copying %s (output up-to-date)", src)
-        return (dst, 0)
-
-    try:
-        action = _copy_action[link]
-    except KeyError:
-        raise ValueError("invalid value '%s' for 'link' argument" % link)
-
-    if verbose >= 1:
-        if os.path.basename(dst) == os.path.basename(src):
-            log.info("%s %s -> %s", action, src, dir)
-        else:
-            log.info("%s %s -> %s", action, src, dst)
-
-    if dry_run:
-        return (dst, 1)
-
-    # If linking (hard or symbolic), use the appropriate system call
-    # (Unix only, of course, but that's the caller's responsibility)
-    elif link == 'hard':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            try:
-                os.link(src, dst)
-                return (dst, 1)
-            except OSError:
-                # If hard linking fails, fall back on copying file
-                # (some special filesystems don't support hard linking
-                #  even under Unix, see issue #8876).
-                pass
-    elif link == 'sym':
-        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
-            os.symlink(src, dst)
-            return (dst, 1)
-
-    # Otherwise (non-Mac, not linking), copy the file contents and
-    # (optionally) copy the times and mode.
-    _copy_file_contents(src, dst)
-    if preserve_mode or preserve_times:
-        st = os.stat(src)
-
-        # According to David Ascher <da@ski.org>, utime() should be done
-        # before chmod() (at least under NT).
-        if preserve_times:
-            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
-        if preserve_mode:
-            os.chmod(dst, S_IMODE(st[ST_MODE]))
-
-    return (dst, 1)
-
-
-# XXX I suspect this is Unix-specific -- need porting help!
-def move_file (src, dst,
-               verbose=1,
-               dry_run=0):
-
-    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
-    be moved into it with the same name; otherwise, 'src' is just renamed
-    to 'dst'.  Return the new full name of the file.
-
-    Handles cross-device moves on Unix using 'copy_file()'.  What about
-    other systems???
-    """
-    from os.path import exists, isfile, isdir, basename, dirname
-    import errno
-
-    if verbose >= 1:
-        log.info("moving %s -> %s", src, dst)
-
-    if dry_run:
-        return dst
-
-    if not isfile(src):
-        raise DistutilsFileError("can't move '%s': not a regular file" % src)
-
-    if isdir(dst):
-        dst = os.path.join(dst, basename(src))
-    elif exists(dst):
-        raise DistutilsFileError(
-              "can't move '%s': destination '%s' already exists" %
-              (src, dst))
-
-    if not isdir(dirname(dst)):
-        raise DistutilsFileError(
-              "can't move '%s': destination '%s' not a valid path" %
-              (src, dst))
-
-    copy_it = False
-    try:
-        os.rename(src, dst)
-    except OSError as e:
-        (num, msg) = e.args
-        if num == errno.EXDEV:
-            copy_it = True
-        else:
-            raise DistutilsFileError(
-                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))
-
-    if copy_it:
-        copy_file(src, dst, verbose=verbose)
-        try:
-            os.unlink(src)
-        except OSError as e:
-            (num, msg) = e.args
-            try:
-                os.unlink(dst)
-            except OSError:
-                pass
-            raise DistutilsFileError(
-                  "couldn't move '%s' to '%s' by copy/delete: "
-                  "delete '%s' failed: %s"
-                  % (src, dst, src, msg))
-    return dst
-
-
-def write_file (filename, contents):
-    """Create a file with the specified name and write 'contents' (a
-    sequence of strings without line terminators) to it.
-    """
-    f = open(filename, "w")
-    try:
-        for line in contents:
-            f.write(line + "\n")
-    finally:
-        f.close()
diff --git a/Lib/distutils/filelist.py b/Lib/distutils/filelist.py
deleted file mode 100644
index c92d5fdba3..0000000000
--- a/Lib/distutils/filelist.py
+++ /dev/null
@@ -1,327 +0,0 @@
-"""distutils.filelist
-
-Provides the FileList class, used for poking about the filesystem
-and building lists of files.
-"""
-
-import os, re
-import fnmatch
-import functools
-from distutils.util import convert_path
-from distutils.errors import DistutilsTemplateError, DistutilsInternalError
-from distutils import log
-
-class FileList:
-    """A list of files built by on exploring the filesystem and filtered by
-    applying various patterns to what we find there.
-
-    Instance attributes:
-      dir
-        directory from which files will be taken -- only used if
-        'allfiles' not supplied to constructor
-      files
-        list of filenames currently being built/filtered/manipulated
-      allfiles
-        complete list of files under consideration (ie. without any
-        filtering applied)
-    """
-
-    def __init__(self, warn=None, debug_print=None):
-        # ignore argument to FileList, but keep them for backwards
-        # compatibility
-        self.allfiles = None
-        self.files = []
-
-    def set_allfiles(self, allfiles):
-        self.allfiles = allfiles
-
-    def findall(self, dir=os.curdir):
-        self.allfiles = findall(dir)
-
-    def debug_print(self, msg):
-        """Print 'msg' to stdout if the global DEBUG (taken from the
-        DISTUTILS_DEBUG environment variable) flag is true.
-        """
-        from distutils.debug import DEBUG
-        if DEBUG:
-            print(msg)
-
-    # -- List-like methods ---------------------------------------------
-
-    def append(self, item):
-        self.files.append(item)
-
-    def extend(self, items):
-        self.files.extend(items)
-
-    def sort(self):
-        # Not a strict lexical sort!
-        sortable_files = sorted(map(os.path.split, self.files))
-        self.files = []
-        for sort_tuple in sortable_files:
-            self.files.append(os.path.join(*sort_tuple))
-
-
-    # -- Other miscellaneous utility methods ---------------------------
-
-    def remove_duplicates(self):
-        # Assumes list has been sorted!
-        for i in range(len(self.files) - 1, 0, -1):
-            if self.files[i] == self.files[i - 1]:
-                del self.files[i]
-
-
-    # -- "File template" methods ---------------------------------------
-
-    def _parse_template_line(self, line):
-        words = line.split()
-        action = words[0]
-
-        patterns = dir = dir_pattern = None
-
-        if action in ('include', 'exclude',
-                      'global-include', 'global-exclude'):
-            if len(words) < 2:
-                raise DistutilsTemplateError(
-                      "'%s' expects <pattern1> <pattern2> ..." % action)
-            patterns = [convert_path(w) for w in words[1:]]
-        elif action in ('recursive-include', 'recursive-exclude'):
-            if len(words) < 3:
-                raise DistutilsTemplateError(
-                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action)
-            dir = convert_path(words[1])
-            patterns = [convert_path(w) for w in words[2:]]
-        elif action in ('graft', 'prune'):
-            if len(words) != 2:
-                raise DistutilsTemplateError(
-                      "'%s' expects a single <dir_pattern>" % action)
-            dir_pattern = convert_path(words[1])
-        else:
-            raise DistutilsTemplateError("unknown action '%s'" % action)
-
-        return (action, patterns, dir, dir_pattern)
-
-    def process_template_line(self, line):
-        # Parse the line: split it up, make sure the right number of words
-        # is there, and return the relevant words.  'action' is always
-        # defined: it's the first word of the line.  Which of the other
-        # three are defined depends on the action; it'll be either
-        # patterns, (dir and patterns), or (dir_pattern).
-        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)
-
-        # OK, now we know that the action is valid and we have the
-        # right number of words on the line for that action -- so we
-        # can proceed with minimal error-checking.
-        if action == 'include':
-            self.debug_print("include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=1):
-                    log.warn("warning: no files found matching '%s'",
-                             pattern)
-
-        elif action == 'exclude':
-            self.debug_print("exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=1):
-                    log.warn(("warning: no previously-included files "
-                              "found matching '%s'"), pattern)
-
-        elif action == 'global-include':
-            self.debug_print("global-include " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, anchor=0):
-                    log.warn(("warning: no files found matching '%s' "
-                              "anywhere in distribution"), pattern)
-
-        elif action == 'global-exclude':
-            self.debug_print("global-exclude " + ' '.join(patterns))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, anchor=0):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found anywhere in distribution"),
-                             pattern)
-
-        elif action == 'recursive-include':
-            self.debug_print("recursive-include %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.include_pattern(pattern, prefix=dir):
-                    log.warn(("warning: no files found matching '%s' "
-                                "under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'recursive-exclude':
-            self.debug_print("recursive-exclude %s %s" %
-                             (dir, ' '.join(patterns)))
-            for pattern in patterns:
-                if not self.exclude_pattern(pattern, prefix=dir):
-                    log.warn(("warning: no previously-included files matching "
-                              "'%s' found under directory '%s'"),
-                             pattern, dir)
-
-        elif action == 'graft':
-            self.debug_print("graft " + dir_pattern)
-            if not self.include_pattern(None, prefix=dir_pattern):
-                log.warn("warning: no directories found matching '%s'",
-                         dir_pattern)
-
-        elif action == 'prune':
-            self.debug_print("prune " + dir_pattern)
-            if not self.exclude_pattern(None, prefix=dir_pattern):
-                log.warn(("no previously-included directories found "
-                          "matching '%s'"), dir_pattern)
-        else:
-            raise DistutilsInternalError(
-                  "this cannot happen: invalid action '%s'" % action)
-
-
-    # -- Filtering/selection methods -----------------------------------
-
-    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
-        """Select strings (presumably filenames) from 'self.files' that
-        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
-        are not quite the same as implemented by the 'fnmatch' module: '*'
-        and '?'  match non-special characters, where "special" is platform-
-        dependent: slash on Unix; colon, slash, and backslash on
-        DOS/Windows; and colon on Mac OS.
-
-        If 'anchor' is true (the default), then the pattern match is more
-        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
-        'anchor' is false, both of these will match.
-
-        If 'prefix' is supplied, then only filenames starting with 'prefix'
-        (itself a pattern) and ending with 'pattern', with anything in between
-        them, will match.  'anchor' is ignored in this case.
-
-        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
-        'pattern' is assumed to be either a string containing a regex or a
-        regex object -- no translation is done, the regex is just compiled
-        and used as-is.
-
-        Selected strings will be added to self.files.
-
-        Return True if files are found, False otherwise.
-        """
-        # XXX docstring lying about what the special chars are?
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("include_pattern: applying regex r'%s'" %
-                         pattern_re.pattern)
-
-        # delayed loading of allfiles list
-        if self.allfiles is None:
-            self.findall()
-
-        for name in self.allfiles:
-            if pattern_re.search(name):
-                self.debug_print(" adding " + name)
-                self.files.append(name)
-                files_found = True
-        return files_found
-
-
-    def exclude_pattern (self, pattern,
-                         anchor=1, prefix=None, is_regex=0):
-        """Remove strings (presumably filenames) from 'files' that match
-        'pattern'.  Other parameters are the same as for
-        'include_pattern()', above.
-        The list 'self.files' is modified in place.
-        Return True if files are found, False otherwise.
-        """
-        files_found = False
-        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
-        self.debug_print("exclude_pattern: applying regex r'%s'" %
-                         pattern_re.pattern)
-        for i in range(len(self.files)-1, -1, -1):
-            if pattern_re.search(self.files[i]):
-                self.debug_print(" removing " + self.files[i])
-                del self.files[i]
-                files_found = True
-        return files_found
-
-
-# ----------------------------------------------------------------------
-# Utility functions
-
-def _find_all_simple(path):
-    """
-    Find all files under 'path'
-    """
-    results = (
-        os.path.join(base, file)
-        for base, dirs, files in os.walk(path, followlinks=True)
-        for file in files
-    )
-    return filter(os.path.isfile, results)
-
-
-def findall(dir=os.curdir):
-    """
-    Find all files under 'dir' and return the list of full filenames.
-    Unless dir is '.', return full filenames with dir prepended.
-    """
-    files = _find_all_simple(dir)
-    if dir == os.curdir:
-        make_rel = functools.partial(os.path.relpath, start=dir)
-        files = map(make_rel, files)
-    return list(files)
-
-
-def glob_to_re(pattern):
-    """Translate a shell-like glob pattern to a regular expression; return
-    a string containing the regex.  Differs from 'fnmatch.translate()' in
-    that '*' does not match "special characters" (which are
-    platform-specific).
-    """
-    pattern_re = fnmatch.translate(pattern)
-
-    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
-    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
-    # and by extension they shouldn't match such "special characters" under
-    # any OS.  So change all non-escaped dots in the RE to match any
-    # character except the special characters (currently: just os.sep).
-    sep = os.sep
-    if os.sep == '\\':
-        # we're using a regex to manipulate a regex, so we need
-        # to escape the backslash twice
-        sep = r'\\\\'
-    escaped = r'\1[^%s]' % sep
-    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
-    return pattern_re
-
-
-def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
-    """Translate a shell-like wildcard pattern to a compiled regular
-    expression.  Return the compiled regex.  If 'is_regex' true,
-    then 'pattern' is directly compiled to a regex (if it's a string)
-    or just returned as-is (assumes it's a regex object).
-    """
-    if is_regex:
-        if isinstance(pattern, str):
-            return re.compile(pattern)
-        else:
-            return pattern
-
-    # ditch start and end characters
-    start, _, end = glob_to_re('_').partition('_')
-
-    if pattern:
-        pattern_re = glob_to_re(pattern)
-        assert pattern_re.startswith(start) and pattern_re.endswith(end)
-    else:
-        pattern_re = ''
-
-    if prefix is not None:
-        prefix_re = glob_to_re(prefix)
-        assert prefix_re.startswith(start) and prefix_re.endswith(end)
-        prefix_re = prefix_re[len(start): len(prefix_re) - len(end)]
-        sep = os.sep
-        if os.sep == '\\':
-            sep = r'\\'
-        pattern_re = pattern_re[len(start): len(pattern_re) - len(end)]
-        pattern_re = r'%s\A%s%s.*%s%s' % (start, prefix_re, sep, pattern_re, end)
-    else:                               # no prefix -- respect anchor flag
-        if anchor:
-            pattern_re = r'%s\A%s' % (start, pattern_re[len(start):])
-
-    return re.compile(pattern_re)
diff --git a/Lib/distutils/log.py b/Lib/distutils/log.py
deleted file mode 100644
index 8ef6b28ea2..0000000000
--- a/Lib/distutils/log.py
+++ /dev/null
@@ -1,77 +0,0 @@
-"""A simple log mechanism styled after PEP 282."""
-
-# The class here is styled after PEP 282 so that it could later be
-# replaced with a standard Python logging implementation.
-
-DEBUG = 1
-INFO = 2
-WARN = 3
-ERROR = 4
-FATAL = 5
-
-import sys
-
-class Log:
-
-    def __init__(self, threshold=WARN):
-        self.threshold = threshold
-
-    def _log(self, level, msg, args):
-        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
-            raise ValueError('%s wrong log level' % str(level))
-
-        if level >= self.threshold:
-            if args:
-                msg = msg % args
-            if level in (WARN, ERROR, FATAL):
-                stream = sys.stderr
-            else:
-                stream = sys.stdout
-            try:
-                stream.write('%s\n' % msg)
-            except UnicodeEncodeError:
-                # emulate backslashreplace error handler
-                encoding = stream.encoding
-                msg = msg.encode(encoding, "backslashreplace").decode(encoding)
-                stream.write('%s\n' % msg)
-            stream.flush()
-
-    def log(self, level, msg, *args):
-        self._log(level, msg, args)
-
-    def debug(self, msg, *args):
-        self._log(DEBUG, msg, args)
-
-    def info(self, msg, *args):
-        self._log(INFO, msg, args)
-
-    def warn(self, msg, *args):
-        self._log(WARN, msg, args)
-
-    def error(self, msg, *args):
-        self._log(ERROR, msg, args)
-
-    def fatal(self, msg, *args):
-        self._log(FATAL, msg, args)
-
-_global_log = Log()
-log = _global_log.log
-debug = _global_log.debug
-info = _global_log.info
-warn = _global_log.warn
-error = _global_log.error
-fatal = _global_log.fatal
-
-def set_threshold(level):
-    # return the old threshold for use from tests
-    old = _global_log.threshold
-    _global_log.threshold = level
-    return old
-
-def set_verbosity(v):
-    if v <= 0:
-        set_threshold(WARN)
-    elif v == 1:
-        set_threshold(INFO)
-    elif v >= 2:
-        set_threshold(DEBUG)
diff --git a/Lib/distutils/msvc9compiler.py b/Lib/distutils/msvc9compiler.py
deleted file mode 100644
index 2119127622..0000000000
--- a/Lib/distutils/msvc9compiler.py
+++ /dev/null
@@ -1,791 +0,0 @@
-"""distutils.msvc9compiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for the Microsoft Visual Studio 2008.
-
-The module is compatible with VS 2005 and VS 2008. You can find legacy support
-for older versions of VS in distutils.msvccompiler.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-# ported to VS2005 and VS 2008 by Christian Heimes
-
-import os
-import subprocess
-import sys
-import re
-
-from distutils.errors import DistutilsExecError, DistutilsPlatformError, \
-                             CompileError, LibError, LinkError
-from distutils.ccompiler import CCompiler, gen_preprocess_options, \
-                                gen_lib_options
-from distutils import log
-from distutils.util import get_platform
-
-import winreg
-
-RegOpenKeyEx = winreg.OpenKeyEx
-RegEnumKey = winreg.EnumKey
-RegEnumValue = winreg.EnumValue
-RegError = winreg.error
-
-HKEYS = (winreg.HKEY_USERS,
-         winreg.HKEY_CURRENT_USER,
-         winreg.HKEY_LOCAL_MACHINE,
-         winreg.HKEY_CLASSES_ROOT)
-
-NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
-if NATIVE_WIN64:
-    # Visual C++ is a 32-bit application, so we need to look in
-    # the corresponding registry branch, if we're running a
-    # 64-bit Python on Win64
-    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
-else:
-    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
-    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
-    NET_BASE = r"Software\Microsoft\.NETFramework"
-
-# A map keyed by get_platform() return values to values accepted by
-# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
-# the param to cross-compile on x86 targeting amd64.)
-PLAT_TO_VCVARS = {
-    'win32' : 'x86',
-    'win-amd64' : 'amd64',
-    'win-ia64' : 'ia64',
-}
-
-class Reg:
-    """Helper class to read values from the registry
-    """
-
-    def get_value(cls, path, key):
-        for base in HKEYS:
-            d = cls.read_values(base, path)
-            if d and key in d:
-                return d[key]
-        raise KeyError(key)
-    get_value = classmethod(get_value)
-
-    def read_keys(cls, base, key):
-        """Return list of registry keys."""
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        L = []
-        i = 0
-        while True:
-            try:
-                k = RegEnumKey(handle, i)
-            except RegError:
-                break
-            L.append(k)
-            i += 1
-        return L
-    read_keys = classmethod(read_keys)
-
-    def read_values(cls, base, key):
-        """Return dict of registry keys and values.
-
-        All names are converted to lowercase.
-        """
-        try:
-            handle = RegOpenKeyEx(base, key)
-        except RegError:
-            return None
-        d = {}
-        i = 0
-        while True:
-            try:
-                name, value, type = RegEnumValue(handle, i)
-            except RegError:
-                break
-            name = name.lower()
-            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
-            i += 1
-        return d
-    read_values = classmethod(read_values)
-
-    def convert_mbcs(s):
-        dec = getattr(s, "decode", None)
-        if dec is not None:
-            try:
-                s = dec("mbcs")
-            except UnicodeError:
-                pass
-        return s
-    convert_mbcs = staticmethod(convert_mbcs)
-
-class MacroExpander:
-
-    def __init__(self, version):
-        self.macros = {}
-        self.vsbase = VS_BASE % version
-        self.load_macros(version)
-
-    def set_macro(self, macro, path, key):
-        self.macros["$(%s)" % macro] = Reg.get_value(path, key)
-
-    def load_macros(self, version):
-        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
-        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
-        self.set_macro("FrameworkDir", NET_BASE, "installroot")
-        try:
-            if version >= 8.0:
-                self.set_macro("FrameworkSDKDir", NET_BASE,
-                               "sdkinstallrootv2.0")
-            else:
-                raise KeyError("sdkinstallrootv2.0")
-        except KeyError:
-            raise DistutilsPlatformError(
-            """Python was built with Visual Studio 2008;
-extensions must be built with a compiler than can generate compatible binaries.
-Visual Studio 2008 was not found on this system. If you have Cygwin installed,
-you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
-
-        if version >= 9.0:
-            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
-            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
-        else:
-            p = r"Software\Microsoft\NET Framework Setup\Product"
-            for base in HKEYS:
-                try:
-                    h = RegOpenKeyEx(base, p)
-                except RegError:
-                    continue
-                key = RegEnumKey(h, 0)
-                d = Reg.get_value(base, r"%s\%s" % (p, key))
-                self.macros["$(FrameworkVersion)"] = d["version"]
-
-    def sub(self, s):
-        for k, v in self.macros.items():
-            s = s.replace(k, v)
-        return s
-
-def get_build_version():
-    """Return the version of MSVC that was used to build Python.
-
-    For Python 2.3 and up, the version number is included in
-    sys.version.  For earlier versions, assume the compiler is MSVC 6.
-    """
-    prefix = "MSC v."
-    i = sys.version.find(prefix)
-    if i == -1:
-        return 6
-    i = i + len(prefix)
-    s, rest = sys.version[i:].split(" ", 1)
-    majorVersion = int(s[:-2]) - 6
-    if majorVersion >= 13:
-        # v13 was skipped and should be v14
-        majorVersion += 1
-    minorVersion = int(s[2:3]) / 10.0
-    # I don't think paths are affected by minor version in version 6
-    if majorVersion == 6:
-        minorVersion = 0
-    if majorVersion >= 6:
-        return majorVersion + minorVersion
-    # else we don't know what version of the compiler this is
-    return None
-
-def normalize_and_reduce_paths(paths):
-    """Return a list of normalized paths with duplicates removed.
-
-    The current order of paths is maintained.
-    """
-    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
-    reduced_paths = []
-    for p in paths:
-        np = os.path.normpath(p)
-        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
-        if np not in reduced_paths:
-            reduced_paths.append(np)
-    return reduced_paths
-
-def removeDuplicates(variable):
-    """Remove duplicate values of an environment variable.
-    """
-    oldList = variable.split(os.pathsep)
-    newList = []
-    for i in oldList:
-        if i not in newList:
-            newList.append(i)
-    newVariable = os.pathsep.join(newList)
-    return newVariable
-
-def find_vcvarsall(version):
-    """Find the vcvarsall.bat file
-
-    At first it tries to find the productdir of VS 2008 in the registry. If
-    that fails it falls back to the VS90COMNTOOLS env var.
-    """
-    vsbase = VS_BASE % version
-    try:
-        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
-                                   "productdir")
-    except KeyError:
-        log.debug("Unable to find productdir in registry")
-        productdir = None
-
-    if not productdir or not os.path.isdir(productdir):
-        toolskey = "VS%0.f0COMNTOOLS" % version
-        toolsdir = os.environ.get(toolskey, None)
-
-        if toolsdir and os.path.isdir(toolsdir):
-            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
-            productdir = os.path.abspath(productdir)
-            if not os.path.isdir(productdir):
-                log.debug("%s is not a valid directory" % productdir)
-                return None
-        else:
-            log.debug("Env var %s is not set or invalid" % toolskey)
-    if not productdir:
-        log.debug("No productdir found")
-        return None
-    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
-    if os.path.isfile(vcvarsall):
-        return vcvarsall
-    log.debug("Unable to find vcvarsall.bat")
-    return None
-
-def query_vcvarsall(version, arch="x86"):
-    """Launch vcvarsall.bat and read the settings from its environment
-    """
-    vcvarsall = find_vcvarsall(version)
-    interesting = set(("include", "lib", "libpath", "path"))
-    result = {}
-
-    if vcvarsall is None:
-        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
-    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
-    popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
-                             stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-    try:
-        stdout, stderr = popen.communicate()
-        if popen.wait() != 0:
-            raise DistutilsPlatformError(stderr.decode("mbcs"))
-
-        stdout = stdout.decode("mbcs")
-        for line in stdout.split("\n"):
-            line = Reg.convert_mbcs(line)
-            if '=' not in line:
-                continue
-            line = line.strip()
-            key, value = line.split('=', 1)
-            key = key.lower()
-            if key in interesting:
-                if value.endswith(os.pathsep):
-                    value = value[:-1]
-                result[key] = removeDuplicates(value)
-
-    finally:
-        popen.stdout.close()
-        popen.stderr.close()
-
-    if len(result) != len(interesting):
-        raise ValueError(str(list(result.keys())))
-
-    return result
-
-# More globals
-VERSION = get_build_version()
-if VERSION < 8.0:
-    raise DistutilsPlatformError("VC %0.1f is not supported by this module" % VERSION)
-# MACROS = MacroExpander(VERSION)
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        self.__version = VERSION
-        self.__root = r"Software\Microsoft\VisualStudio"
-        # self.__macros = MACROS
-        self.__paths = []
-        # target platform (.plat_name is consistent with 'bdist')
-        self.plat_name = None
-        self.__arch = None # deprecated name
-        self.initialized = False
-
-    def initialize(self, plat_name=None):
-        # multi-init means we would need to check platform same each time...
-        assert not self.initialized, "don't init multiple times"
-        if plat_name is None:
-            plat_name = get_platform()
-        # sanity check for platforms to prevent obscure errors later.
-        ok_plats = 'win32', 'win-amd64', 'win-ia64'
-        if plat_name not in ok_plats:
-            raise DistutilsPlatformError("--plat-name must be one of %s" %
-                                         (ok_plats,))
-
-        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
-            # Assume that the SDK set up everything alright; don't try to be
-            # smarter
-            self.cc = "cl.exe"
-            self.linker = "link.exe"
-            self.lib = "lib.exe"
-            self.rc = "rc.exe"
-            self.mc = "mc.exe"
-        else:
-            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
-            # to cross compile, you use 'x86_amd64'.
-            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
-            # compile use 'x86' (ie, it runs the x86 compiler directly)
-            # No idea how itanium handles this, if at all.
-            if plat_name == get_platform() or plat_name == 'win32':
-                # native build or cross-compile to win32
-                plat_spec = PLAT_TO_VCVARS[plat_name]
-            else:
-                # cross compile from win32 -> some 64bit
-                plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
-                            PLAT_TO_VCVARS[plat_name]
-
-            vc_env = query_vcvarsall(VERSION, plat_spec)
-
-            self.__paths = vc_env['path'].split(os.pathsep)
-            os.environ['lib'] = vc_env['lib']
-            os.environ['include'] = vc_env['include']
-
-            if len(self.__paths) == 0:
-                raise DistutilsPlatformError("Python was built with %s, "
-                       "and extensions need to be built with the same "
-                       "version of the compiler, but it isn't installed."
-                       % self.__product)
-
-            self.cc = self.find_exe("cl.exe")
-            self.linker = self.find_exe("link.exe")
-            self.lib = self.find_exe("lib.exe")
-            self.rc = self.find_exe("rc.exe")   # resource compiler
-            self.mc = self.find_exe("mc.exe")   # message compiler
-            #self.set_path_env_var('lib')
-            #self.set_path_env_var('include')
-
-        # extend the MSVC path with the current path
-        try:
-            for p in os.environ['path'].split(';'):
-                self.__paths.append(p)
-        except KeyError:
-            pass
-        self.__paths = normalize_and_reduce_paths(self.__paths)
-        os.environ['path'] = ";".join(self.__paths)
-
-        self.preprocess_options = None
-        if self.__arch == "x86":
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3',
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
-                                          '/Z7', '/D_DEBUG']
-        else:
-            # Win64
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
-                                          '/Z7', '/D_DEBUG']
-
-        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
-        if self.__version >= 7:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
-                ]
-        self.ldflags_static = [ '/nologo']
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        # Copied from ccompiler.py, extended to return .res as 'object'-file
-        # for .rc input file
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            (base, ext) = os.path.splitext (src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError ("Don't know how to compile %s" % src_name)
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in self._rc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            elif ext in self._mc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.obj_extension))
-        return obj_names
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append ('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts +
-                               [output_opt] + [input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc] +
-                               ['-h', h_dir, '-r', rc_dir] + [src])
-                    base, _ = os.path.splitext (os.path.basename (src))
-                    rc_file = os.path.join (rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc] +
-                               ["/fo" + obj] + [rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile %s to %s"
-                                   % (src, obj))
-
-            output_opt = "/Fo" + obj
-            try:
-                self.spawn([self.cc] + compile_opts + pp_opts +
-                           [input_opt, output_opt] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        (libraries, library_dirs, runtime_library_dirs) = fixed_args
-
-        if runtime_library_dirs:
-            self.warn ("I don't know what to do with 'runtime_library_dirs': "
-                       + str (runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            if target_desc == CCompiler.EXECUTABLE:
-                if debug:
-                    ldflags = self.ldflags_shared_debug[1:]
-                else:
-                    ldflags = self.ldflags_shared[1:]
-            else:
-                if debug:
-                    ldflags = self.ldflags_shared_debug
-                else:
-                    ldflags = self.ldflags_shared
-
-            export_opts = []
-            for sym in (export_symbols or []):
-                export_opts.append("/EXPORT:" + sym)
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            build_temp = os.path.dirname(objects[0])
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    build_temp,
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                self.spawn([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-            # embed the manifest
-            # XXX - this is somewhat fragile - if mt.exe fails, distutils
-            # will still consider the DLL up-to-date, but it will not have a
-            # manifest.  Maybe we should link to a temp file?  OTOH, that
-            # implies a build environment error that shouldn't go undetected.
-            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
-            if mfinfo is not None:
-                mffilename, mfid = mfinfo
-                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
-                try:
-                    self.spawn(['mt.exe', '-nologo', '-manifest',
-                                mffilename, out_arg])
-                except DistutilsExecError as msg:
-                    raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
-        # If we need a manifest at all, an embedded manifest is recommended.
-        # See MSDN article titled
-        # "How to: Embed a Manifest Inside a C/C++ Application"
-        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
-        # Ask the linker to generate the manifest in the temp dir, so
-        # we can check it, and possibly embed it, later.
-        temp_manifest = os.path.join(
-                build_temp,
-                os.path.basename(output_filename) + ".manifest")
-        ld_args.append('/MANIFESTFILE:' + temp_manifest)
-
-    def manifest_get_embed_info(self, target_desc, ld_args):
-        # If a manifest should be embedded, return a tuple of
-        # (manifest_filename, resource_id).  Returns None if no manifest
-        # should be embedded.  See http://bugs.python.org/issue7833 for why
-        # we want to avoid any manifest for extension modules if we can)
-        for arg in ld_args:
-            if arg.startswith("/MANIFESTFILE:"):
-                temp_manifest = arg.split(":", 1)[1]
-                break
-        else:
-            # no /MANIFESTFILE so nothing to do.
-            return None
-        if target_desc == CCompiler.EXECUTABLE:
-            # by default, executables always get the manifest with the
-            # CRT referenced.
-            mfid = 1
-        else:
-            # Extension modules try and avoid any manifest if possible.
-            mfid = 2
-            temp_manifest = self._remove_visual_c_ref(temp_manifest)
-        if temp_manifest is None:
-            return None
-        return temp_manifest, mfid
-
-    def _remove_visual_c_ref(self, manifest_file):
-        try:
-            # Remove references to the Visual C runtime, so they will
-            # fall through to the Visual C dependency of Python.exe.
-            # This way, when installed for a restricted user (e.g.
-            # runtimes are not in WinSxS folder, but in Python's own
-            # folder), the runtimes do not need to be in every folder
-            # with .pyd's.
-            # Returns either the filename of the modified manifest or
-            # None if no manifest should be embedded.
-            manifest_f = open(manifest_file)
-            try:
-                manifest_buf = manifest_f.read()
-            finally:
-                manifest_f.close()
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
-                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
-                re.DOTALL)
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            pattern = r"<dependentAssembly>\s*</dependentAssembly>"
-            manifest_buf = re.sub(pattern, "", manifest_buf)
-            # Now see if any other assemblies are referenced - if not, we
-            # don't want a manifest embedded.
-            pattern = re.compile(
-                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
-                r""".*?(?:/>|</assemblyIdentity>)""", re.DOTALL)
-            if re.search(pattern, manifest_buf) is None:
-                return None
-
-            manifest_f = open(manifest_file, 'w')
-            try:
-                manifest_f.write(manifest_buf)
-                return manifest_file
-            finally:
-                manifest_f.close()
-        except OSError:
-            pass
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC++")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename (name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # Helper methods for using the MSVC registry settings
-
-    def find_exe(self, exe):
-        """Return path to an MSVC executable program.
-
-        Tries to find the program in several places: first, one of the
-        MSVC program search paths from the registry; next, the directories
-        in the PATH environment variable.  If any of those work, return an
-        absolute path that is known to exist.  If none of them work, just
-        return the original program name, 'exe'.
-        """
-        for p in self.__paths:
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-
-        # didn't find it; try existing path
-        for p in os.environ['Path'].split(';'):
-            fn = os.path.join(os.path.abspath(p),exe)
-            if os.path.isfile(fn):
-                return fn
-
-        return exe
diff --git a/Lib/distutils/msvccompiler.py b/Lib/distutils/msvccompiler.py
deleted file mode 100644
index 1048cd4159..0000000000
--- a/Lib/distutils/msvccompiler.py
+++ /dev/null
@@ -1,643 +0,0 @@
-"""distutils.msvccompiler
-
-Contains MSVCCompiler, an implementation of the abstract CCompiler class
-for the Microsoft Visual Studio.
-"""
-
-# Written by Perry Stoll
-# hacked by Robin Becker and Thomas Heller to do a better job of
-#   finding DevStudio (through the registry)
-
-import sys, os
-from distutils.errors import \
-     DistutilsExecError, DistutilsPlatformError, \
-     CompileError, LibError, LinkError
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils import log
-
-_can_read_reg = False
-try:
-    import winreg
-
-    _can_read_reg = True
-    hkey_mod = winreg
-
-    RegOpenKeyEx = winreg.OpenKeyEx
-    RegEnumKey = winreg.EnumKey
-    RegEnumValue = winreg.EnumValue
-    RegError = winreg.error
-
-except ImportError:
-    try:
-        import win32api
-        import win32con
-        _can_read_reg = True
-        hkey_mod = win32con
-
-        RegOpenKeyEx = win32api.RegOpenKeyEx
-        RegEnumKey = win32api.RegEnumKey
-        RegEnumValue = win32api.RegEnumValue
-        RegError = win32api.error
-    except ImportError:
-        log.info("Warning: Can't read registry to find the "
-                 "necessary compiler setting\n"
-                 "Make sure that Python modules winreg, "
-                 "win32api or win32con are installed.")
-        pass
-
-if _can_read_reg:
-    HKEYS = (hkey_mod.HKEY_USERS,
-             hkey_mod.HKEY_CURRENT_USER,
-             hkey_mod.HKEY_LOCAL_MACHINE,
-             hkey_mod.HKEY_CLASSES_ROOT)
-
-def read_keys(base, key):
-    """Return list of registry keys."""
-    try:
-        handle = RegOpenKeyEx(base, key)
-    except RegError:
-        return None
-    L = []
-    i = 0
-    while True:
-        try:
-            k = RegEnumKey(handle, i)
-        except RegError:
-            break
-        L.append(k)
-        i += 1
-    return L
-
-def read_values(base, key):
-    """Return dict of registry keys and values.
-
-    All names are converted to lowercase.
-    """
-    try:
-        handle = RegOpenKeyEx(base, key)
-    except RegError:
-        return None
-    d = {}
-    i = 0
-    while True:
-        try:
-            name, value, type = RegEnumValue(handle, i)
-        except RegError:
-            break
-        name = name.lower()
-        d[convert_mbcs(name)] = convert_mbcs(value)
-        i += 1
-    return d
-
-def convert_mbcs(s):
-    dec = getattr(s, "decode", None)
-    if dec is not None:
-        try:
-            s = dec("mbcs")
-        except UnicodeError:
-            pass
-    return s
-
-class MacroExpander:
-    def __init__(self, version):
-        self.macros = {}
-        self.load_macros(version)
-
-    def set_macro(self, macro, path, key):
-        for base in HKEYS:
-            d = read_values(base, path)
-            if d:
-                self.macros["$(%s)" % macro] = d[key]
-                break
-
-    def load_macros(self, version):
-        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
-        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
-        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
-        net = r"Software\Microsoft\.NETFramework"
-        self.set_macro("FrameworkDir", net, "installroot")
-        try:
-            if version > 7.0:
-                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
-            else:
-                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
-        except KeyError as exc: #
-            raise DistutilsPlatformError(
-            """Python was built with Visual Studio 2003;
-extensions must be built with a compiler than can generate compatible binaries.
-Visual Studio 2003 was not found on this system. If you have Cygwin installed,
-you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")
-
-        p = r"Software\Microsoft\NET Framework Setup\Product"
-        for base in HKEYS:
-            try:
-                h = RegOpenKeyEx(base, p)
-            except RegError:
-                continue
-            key = RegEnumKey(h, 0)
-            d = read_values(base, r"%s\%s" % (p, key))
-            self.macros["$(FrameworkVersion)"] = d["version"]
-
-    def sub(self, s):
-        for k, v in self.macros.items():
-            s = s.replace(k, v)
-        return s
-
-def get_build_version():
-    """Return the version of MSVC that was used to build Python.
-
-    For Python 2.3 and up, the version number is included in
-    sys.version.  For earlier versions, assume the compiler is MSVC 6.
-    """
-    prefix = "MSC v."
-    i = sys.version.find(prefix)
-    if i == -1:
-        return 6
-    i = i + len(prefix)
-    s, rest = sys.version[i:].split(" ", 1)
-    majorVersion = int(s[:-2]) - 6
-    if majorVersion >= 13:
-        # v13 was skipped and should be v14
-        majorVersion += 1
-    minorVersion = int(s[2:3]) / 10.0
-    # I don't think paths are affected by minor version in version 6
-    if majorVersion == 6:
-        minorVersion = 0
-    if majorVersion >= 6:
-        return majorVersion + minorVersion
-    # else we don't know what version of the compiler this is
-    return None
-
-def get_build_architecture():
-    """Return the processor architecture.
-
-    Possible results are "Intel", "Itanium", or "AMD64".
-    """
-
-    prefix = " bit ("
-    i = sys.version.find(prefix)
-    if i == -1:
-        return "Intel"
-    j = sys.version.find(")", i)
-    return sys.version[i+len(prefix):j]
-
-def normalize_and_reduce_paths(paths):
-    """Return a list of normalized paths with duplicates removed.
-
-    The current order of paths is maintained.
-    """
-    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
-    reduced_paths = []
-    for p in paths:
-        np = os.path.normpath(p)
-        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
-        if np not in reduced_paths:
-            reduced_paths.append(np)
-    return reduced_paths
-
-
-class MSVCCompiler(CCompiler) :
-    """Concrete class that implements an interface to Microsoft Visual C++,
-       as defined by the CCompiler abstract class."""
-
-    compiler_type = 'msvc'
-
-    # Just set this so CCompiler's constructor doesn't barf.  We currently
-    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
-    # as it really isn't necessary for this sort of single-compiler class.
-    # Would be nice to have a consistent interface with UnixCCompiler,
-    # though, so it's worth thinking about.
-    executables = {}
-
-    # Private class data (need to distinguish C from C++ source for compiler)
-    _c_extensions = ['.c']
-    _cpp_extensions = ['.cc', '.cpp', '.cxx']
-    _rc_extensions = ['.rc']
-    _mc_extensions = ['.mc']
-
-    # Needed for the filename generation methods provided by the
-    # base class, CCompiler.
-    src_extensions = (_c_extensions + _cpp_extensions +
-                      _rc_extensions + _mc_extensions)
-    res_extension = '.res'
-    obj_extension = '.obj'
-    static_lib_extension = '.lib'
-    shared_lib_extension = '.dll'
-    static_lib_format = shared_lib_format = '%s%s'
-    exe_extension = '.exe'
-
-    def __init__(self, verbose=0, dry_run=0, force=0):
-        CCompiler.__init__ (self, verbose, dry_run, force)
-        self.__version = get_build_version()
-        self.__arch = get_build_architecture()
-        if self.__arch == "Intel":
-            # x86
-            if self.__version >= 7:
-                self.__root = r"Software\Microsoft\VisualStudio"
-                self.__macros = MacroExpander(self.__version)
-            else:
-                self.__root = r"Software\Microsoft\Devstudio"
-            self.__product = "Visual Studio version %s" % self.__version
-        else:
-            # Win64. Assume this was built with the platform SDK
-            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)
-
-        self.initialized = False
-
-    def initialize(self):
-        self.__paths = []
-        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
-            # Assume that the SDK set up everything alright; don't try to be
-            # smarter
-            self.cc = "cl.exe"
-            self.linker = "link.exe"
-            self.lib = "lib.exe"
-            self.rc = "rc.exe"
-            self.mc = "mc.exe"
-        else:
-            self.__paths = self.get_msvc_paths("path")
-
-            if len(self.__paths) == 0:
-                raise DistutilsPlatformError("Python was built with %s, "
-                       "and extensions need to be built with the same "
-                       "version of the compiler, but it isn't installed."
-                       % self.__product)
-
-            self.cc = self.find_exe("cl.exe")
-            self.linker = self.find_exe("link.exe")
-            self.lib = self.find_exe("lib.exe")
-            self.rc = self.find_exe("rc.exe")   # resource compiler
-            self.mc = self.find_exe("mc.exe")   # message compiler
-            self.set_path_env_var('lib')
-            self.set_path_env_var('include')
-
-        # extend the MSVC path with the current path
-        try:
-            for p in os.environ['path'].split(';'):
-                self.__paths.append(p)
-        except KeyError:
-            pass
-        self.__paths = normalize_and_reduce_paths(self.__paths)
-        os.environ['path'] = ";".join(self.__paths)
-
-        self.preprocess_options = None
-        if self.__arch == "Intel":
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GX' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX',
-                                          '/Z7', '/D_DEBUG']
-        else:
-            # Win64
-            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
-                                     '/DNDEBUG']
-            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
-                                          '/Z7', '/D_DEBUG']
-
-        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
-        if self.__version >= 7:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
-                ]
-        else:
-            self.ldflags_shared_debug = [
-                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
-                ]
-        self.ldflags_static = [ '/nologo']
-
-        self.initialized = True
-
-    # -- Worker methods ------------------------------------------------
-
-    def object_filenames(self,
-                         source_filenames,
-                         strip_dir=0,
-                         output_dir=''):
-        # Copied from ccompiler.py, extended to return .res as 'object'-file
-        # for .rc input file
-        if output_dir is None: output_dir = ''
-        obj_names = []
-        for src_name in source_filenames:
-            (base, ext) = os.path.splitext (src_name)
-            base = os.path.splitdrive(base)[1] # Chop off the drive
-            base = base[os.path.isabs(base):]  # If abs, chop off leading /
-            if ext not in self.src_extensions:
-                # Better to raise an exception instead of silently continuing
-                # and later complain about sources and targets having
-                # different lengths
-                raise CompileError ("Don't know how to compile %s" % src_name)
-            if strip_dir:
-                base = os.path.basename (base)
-            if ext in self._rc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            elif ext in self._mc_extensions:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.res_extension))
-            else:
-                obj_names.append (os.path.join (output_dir,
-                                                base + self.obj_extension))
-        return obj_names
-
-
-    def compile(self, sources,
-                output_dir=None, macros=None, include_dirs=None, debug=0,
-                extra_preargs=None, extra_postargs=None, depends=None):
-
-        if not self.initialized:
-            self.initialize()
-        compile_info = self._setup_compile(output_dir, macros, include_dirs,
-                                           sources, depends, extra_postargs)
-        macros, objects, extra_postargs, pp_opts, build = compile_info
-
-        compile_opts = extra_preargs or []
-        compile_opts.append ('/c')
-        if debug:
-            compile_opts.extend(self.compile_options_debug)
-        else:
-            compile_opts.extend(self.compile_options)
-
-        for obj in objects:
-            try:
-                src, ext = build[obj]
-            except KeyError:
-                continue
-            if debug:
-                # pass the full pathname to MSVC in debug mode,
-                # this allows the debugger to find the source file
-                # without asking the user to browse for it
-                src = os.path.abspath(src)
-
-            if ext in self._c_extensions:
-                input_opt = "/Tc" + src
-            elif ext in self._cpp_extensions:
-                input_opt = "/Tp" + src
-            elif ext in self._rc_extensions:
-                # compile .RC to .RES file
-                input_opt = src
-                output_opt = "/fo" + obj
-                try:
-                    self.spawn([self.rc] + pp_opts +
-                               [output_opt] + [input_opt])
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            elif ext in self._mc_extensions:
-                # Compile .MC to .RC file to .RES file.
-                #   * '-h dir' specifies the directory for the
-                #     generated include file
-                #   * '-r dir' specifies the target directory of the
-                #     generated RC file and the binary message resource
-                #     it includes
-                #
-                # For now (since there are no options to change this),
-                # we use the source-directory for the include file and
-                # the build directory for the RC file and message
-                # resources. This works at least for win32all.
-                h_dir = os.path.dirname(src)
-                rc_dir = os.path.dirname(obj)
-                try:
-                    # first compile .MC to .RC and .H file
-                    self.spawn([self.mc] +
-                               ['-h', h_dir, '-r', rc_dir] + [src])
-                    base, _ = os.path.splitext (os.path.basename (src))
-                    rc_file = os.path.join (rc_dir, base + '.rc')
-                    # then compile .RC to .RES file
-                    self.spawn([self.rc] +
-                               ["/fo" + obj] + [rc_file])
-
-                except DistutilsExecError as msg:
-                    raise CompileError(msg)
-                continue
-            else:
-                # how to handle this file?
-                raise CompileError("Don't know how to compile %s to %s"
-                                   % (src, obj))
-
-            output_opt = "/Fo" + obj
-            try:
-                self.spawn([self.cc] + compile_opts + pp_opts +
-                           [input_opt, output_opt] +
-                           extra_postargs)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-        return objects
-
-
-    def create_static_lib(self,
-                          objects,
-                          output_libname,
-                          output_dir=None,
-                          debug=0,
-                          target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        output_filename = self.library_filename(output_libname,
-                                                output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            lib_args = objects + ['/OUT:' + output_filename]
-            if debug:
-                pass # XXX what goes here?
-            try:
-                self.spawn([self.lib] + lib_args)
-            except DistutilsExecError as msg:
-                raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    def link(self,
-             target_desc,
-             objects,
-             output_filename,
-             output_dir=None,
-             libraries=None,
-             library_dirs=None,
-             runtime_library_dirs=None,
-             export_symbols=None,
-             debug=0,
-             extra_preargs=None,
-             extra_postargs=None,
-             build_temp=None,
-             target_lang=None):
-
-        if not self.initialized:
-            self.initialize()
-        (objects, output_dir) = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        (libraries, library_dirs, runtime_library_dirs) = fixed_args
-
-        if runtime_library_dirs:
-            self.warn ("I don't know what to do with 'runtime_library_dirs': "
-                       + str (runtime_library_dirs))
-
-        lib_opts = gen_lib_options(self,
-                                   library_dirs, runtime_library_dirs,
-                                   libraries)
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            if target_desc == CCompiler.EXECUTABLE:
-                if debug:
-                    ldflags = self.ldflags_shared_debug[1:]
-                else:
-                    ldflags = self.ldflags_shared[1:]
-            else:
-                if debug:
-                    ldflags = self.ldflags_shared_debug
-                else:
-                    ldflags = self.ldflags_shared
-
-            export_opts = []
-            for sym in (export_symbols or []):
-                export_opts.append("/EXPORT:" + sym)
-
-            ld_args = (ldflags + lib_opts + export_opts +
-                       objects + ['/OUT:' + output_filename])
-
-            # The MSVC linker generates .lib and .exp files, which cannot be
-            # suppressed by any linker switches. The .lib files may even be
-            # needed! Make sure they are generated in the temporary build
-            # directory. Since they have different names for debug and release
-            # builds, they can go into the same directory.
-            if export_symbols is not None:
-                (dll_name, dll_ext) = os.path.splitext(
-                    os.path.basename(output_filename))
-                implib_file = os.path.join(
-                    os.path.dirname(objects[0]),
-                    self.library_filename(dll_name))
-                ld_args.append ('/IMPLIB:' + implib_file)
-
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                self.spawn([self.linker] + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "/LIBPATH:" + dir
-
-    def runtime_library_dir_option(self, dir):
-        raise DistutilsPlatformError(
-              "don't know how to set runtime library search path for MSVC++")
-
-    def library_option(self, lib):
-        return self.library_filename(lib)
-
-
-    def find_library_file(self, dirs, lib, debug=0):
-        # Prefer a debugging library if found (and requested), but deal
-        # with it if we don't have one.
-        if debug:
-            try_names = [lib + "_d", lib]
-        else:
-            try_names = [lib]
-        for dir in dirs:
-            for name in try_names:
-                libfile = os.path.join(dir, self.library_filename (name))
-                if os.path.exists(libfile):
-                    return libfile
-        else:
-            # Oops, didn't find it in *any* of 'dirs'
-            return None
-
-    # Helper methods for using the MSVC registry settings
-
-    def find_exe(self, exe):
-        """Return path to an MSVC executable program.
-
-        Tries to find the program in several places: first, one of the
-        MSVC program search paths from the registry; next, the directories
-        in the PATH environment variable.  If any of those work, return an
-        absolute path that is known to exist.  If none of them work, just
-        return the original program name, 'exe'.
-        """
-        for p in self.__paths:
-            fn = os.path.join(os.path.abspath(p), exe)
-            if os.path.isfile(fn):
-                return fn
-
-        # didn't find it; try existing path
-        for p in os.environ['Path'].split(';'):
-            fn = os.path.join(os.path.abspath(p),exe)
-            if os.path.isfile(fn):
-                return fn
-
-        return exe
-
-    def get_msvc_paths(self, path, platform='x86'):
-        """Get a list of devstudio directories (include, lib or path).
-
-        Return a list of strings.  The list will be empty if unable to
-        access the registry or appropriate registry keys not found.
-        """
-        if not _can_read_reg:
-            return []
-
-        path = path + " dirs"
-        if self.__version >= 7:
-            key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories"
-                   % (self.__root, self.__version))
-        else:
-            key = (r"%s\6.0\Build System\Components\Platforms"
-                   r"\Win32 (%s)\Directories" % (self.__root, platform))
-
-        for base in HKEYS:
-            d = read_values(base, key)
-            if d:
-                if self.__version >= 7:
-                    return self.__macros.sub(d[path]).split(";")
-                else:
-                    return d[path].split(";")
-        # MSVC 6 seems to create the registry entries we need only when
-        # the GUI is run.
-        if self.__version == 6:
-            for base in HKEYS:
-                if read_values(base, r"%s\6.0" % self.__root) is not None:
-                    self.warn("It seems you have Visual Studio 6 installed, "
-                        "but the expected registry settings are not present.\n"
-                        "You must at least run the Visual Studio GUI once "
-                        "so that these entries are created.")
-                    break
-        return []
-
-    def set_path_env_var(self, name):
-        """Set environment variable 'name' to an MSVC path type value.
-
-        This is equivalent to a SET command prior to execution of spawned
-        commands.
-        """
-
-        if name == "lib":
-            p = self.get_msvc_paths("library")
-        else:
-            p = self.get_msvc_paths(name)
-        if p:
-            os.environ[name] = ';'.join(p)
-
-
-if get_build_version() >= 8.0:
-    log.debug("Importing new compiler from distutils.msvc9compiler")
-    OldMSVCCompiler = MSVCCompiler
-    from distutils.msvc9compiler import MSVCCompiler
-    # get_build_architecture not really relevant now we support cross-compile
-    from distutils.msvc9compiler import MacroExpander
diff --git a/Lib/distutils/spawn.py b/Lib/distutils/spawn.py
deleted file mode 100644
index 5387688093..0000000000
--- a/Lib/distutils/spawn.py
+++ /dev/null
@@ -1,192 +0,0 @@
-"""distutils.spawn
-
-Provides the 'spawn()' function, a front-end to various platform-
-specific functions for launching another program in a sub-process.
-Also provides the 'find_executable()' to search the path for a given
-executable name.
-"""
-
-import sys
-import os
-
-from distutils.errors import DistutilsPlatformError, DistutilsExecError
-from distutils.debug import DEBUG
-from distutils import log
-
-def spawn(cmd, search_path=1, verbose=0, dry_run=0):
-    """Run another program, specified as a command list 'cmd', in a new process.
-
-    'cmd' is just the argument list for the new process, ie.
-    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
-    There is no way to run a program with a name different from that of its
-    executable.
-
-    If 'search_path' is true (the default), the system's executable
-    search path will be used to find the program; otherwise, cmd[0]
-    must be the exact path to the executable.  If 'dry_run' is true,
-    the command will not actually be run.
-
-    Raise DistutilsExecError if running the program fails in any way; just
-    return on success.
-    """
-    # cmd is documented as a list, but just in case some code passes a tuple
-    # in, protect our %-formatting code against horrible death
-    cmd = list(cmd)
-    if os.name == 'posix':
-        _spawn_posix(cmd, search_path, dry_run=dry_run)
-    elif os.name == 'nt':
-        _spawn_nt(cmd, search_path, dry_run=dry_run)
-    else:
-        raise DistutilsPlatformError(
-              "don't know how to spawn programs on platform '%s'" % os.name)
-
-def _nt_quote_args(args):
-    """Quote command-line arguments for DOS/Windows conventions.
-
-    Just wraps every argument which contains blanks in double quotes, and
-    returns a new argument list.
-    """
-    # XXX this doesn't seem very robust to me -- but if the Windows guys
-    # say it'll work, I guess I'll have to accept it.  (What if an arg
-    # contains quotes?  What other magic characters, other than spaces,
-    # have to be escaped?  Is there an escaping mechanism other than
-    # quoting?)
-    for i, arg in enumerate(args):
-        if ' ' in arg:
-            args[i] = '"%s"' % arg
-    return args
-
-def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
-    executable = cmd[0]
-    cmd = _nt_quote_args(cmd)
-    if search_path:
-        # either we find one or it stays the same
-        executable = find_executable(executable) or executable
-    log.info(' '.join([executable] + cmd[1:]))
-    if not dry_run:
-        # spawn for NT requires a full path to the .exe
-        try:
-            rc = os.spawnv(os.P_WAIT, executable, cmd)
-        except OSError as exc:
-            # this seems to happen when the command isn't found
-            if not DEBUG:
-                cmd = executable
-            raise DistutilsExecError(
-                  "command %r failed: %s" % (cmd, exc.args[-1]))
-        if rc != 0:
-            # and this reflects the command running but failing
-            if not DEBUG:
-                cmd = executable
-            raise DistutilsExecError(
-                  "command %r failed with exit status %d" % (cmd, rc))
-
-if sys.platform == 'darwin':
-    from distutils import sysconfig
-    _cfg_target = None
-    _cfg_target_split = None
-
-def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
-    log.info(' '.join(cmd))
-    if dry_run:
-        return
-    executable = cmd[0]
-    exec_fn = search_path and os.execvp or os.execv
-    env = None
-    if sys.platform == 'darwin':
-        global _cfg_target, _cfg_target_split
-        if _cfg_target is None:
-            _cfg_target = sysconfig.get_config_var(
-                                  'MACOSX_DEPLOYMENT_TARGET') or ''
-            if _cfg_target:
-                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
-        if _cfg_target:
-            # ensure that the deployment target of build process is not less
-            # than that used when the interpreter was built. This ensures
-            # extension modules are built with correct compatibility values
-            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
-            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
-                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
-                          'now "%s" but "%s" during configure'
-                                % (cur_target, _cfg_target))
-                raise DistutilsPlatformError(my_msg)
-            env = dict(os.environ,
-                       MACOSX_DEPLOYMENT_TARGET=cur_target)
-            exec_fn = search_path and os.execvpe or os.execve
-    pid = os.fork()
-    if pid == 0: # in the child
-        try:
-            if env is None:
-                exec_fn(executable, cmd)
-            else:
-                exec_fn(executable, cmd, env)
-        except OSError as e:
-            if not DEBUG:
-                cmd = executable
-            sys.stderr.write("unable to execute %r: %s\n"
-                             % (cmd, e.strerror))
-            os._exit(1)
-
-        if not DEBUG:
-            cmd = executable
-        sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
-        os._exit(1)
-    else: # in the parent
-        # Loop until the child either exits or is terminated by a signal
-        # (ie. keep waiting if it's merely stopped)
-        while True:
-            try:
-                pid, status = os.waitpid(pid, 0)
-            except OSError as exc:
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "command %r failed: %s" % (cmd, exc.args[-1]))
-            if os.WIFSIGNALED(status):
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "command %r terminated by signal %d"
-                      % (cmd, os.WTERMSIG(status)))
-            elif os.WIFEXITED(status):
-                exit_status = os.WEXITSTATUS(status)
-                if exit_status == 0:
-                    return   # hey, it succeeded!
-                else:
-                    if not DEBUG:
-                        cmd = executable
-                    raise DistutilsExecError(
-                          "command %r failed with exit status %d"
-                          % (cmd, exit_status))
-            elif os.WIFSTOPPED(status):
-                continue
-            else:
-                if not DEBUG:
-                    cmd = executable
-                raise DistutilsExecError(
-                      "unknown error executing %r: termination status %d"
-                      % (cmd, status))
-
-def find_executable(executable, path=None):
-    """Tries to find 'executable' in the directories listed in 'path'.
-
-    A string listing directories separated by 'os.pathsep'; defaults to
-    os.environ['PATH'].  Returns the complete filename or None if not found.
-    """
-    if path is None:
-        path = os.environ.get('PATH', os.defpath)
-
-    paths = path.split(os.pathsep)
-    base, ext = os.path.splitext(executable)
-
-    if (sys.platform == 'win32') and (ext != '.exe'):
-        executable = executable + '.exe'
-
-    if not os.path.isfile(executable):
-        for p in paths:
-            f = os.path.join(p, executable)
-            if os.path.isfile(f):
-                # the file exists, we have a shot at spawn working
-                return f
-        return None
-    else:
-        return executable
diff --git a/Lib/distutils/sysconfig.py b/Lib/distutils/sysconfig.py
deleted file mode 100644
index 3a5984f5c0..0000000000
--- a/Lib/distutils/sysconfig.py
+++ /dev/null
@@ -1,556 +0,0 @@
-"""Provide access to Python's configuration information.  The specific
-configuration variables available depend heavily on the platform and
-configuration.  The values may be retrieved using
-get_config_var(name), and the list of variables is available via
-get_config_vars().keys().  Additional convenience functions are also
-available.
-
-Written by:   Fred L. Drake, Jr.
-Email:        <fdrake@acm.org>
-"""
-
-import _imp
-import os
-import re
-import sys
-
-from .errors import DistutilsPlatformError
-
-# These are needed in a couple of spots, so just compute them once.
-PREFIX = os.path.normpath(sys.prefix)
-EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
-BASE_PREFIX = os.path.normpath(sys.base_prefix)
-BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
-
-# Path to the base directory of the project. On Windows the binary may
-# live in project/PCbuild/win32 or project/PCbuild/amd64.
-# set for cross builds
-if "_PYTHON_PROJECT_BASE" in os.environ:
-    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
-else:
-    if sys.executable:
-        project_base = os.path.dirname(os.path.abspath(sys.executable))
-    else:
-        # sys.executable can be empty if argv[0] has been changed and Python is
-        # unable to retrieve the real program name
-        project_base = os.getcwd()
-
-
-# python_build: (Boolean) if true, we're either building Python or
-# building an extension with an un-installed Python, so we use
-# different (hard-wired) directories.
-def _is_python_source_dir(d):
-    for fn in ("Setup", "Setup.local"):
-        if os.path.isfile(os.path.join(d, "Modules", fn)):
-            return True
-    return False
-
-_sys_home = getattr(sys, '_home', None)
-
-if os.name == 'nt':
-    def _fix_pcbuild(d):
-        if d and os.path.normcase(d).startswith(
-                os.path.normcase(os.path.join(PREFIX, "PCbuild"))):
-            return PREFIX
-        return d
-    project_base = _fix_pcbuild(project_base)
-    _sys_home = _fix_pcbuild(_sys_home)
-
-def _python_build():
-    if _sys_home:
-        return _is_python_source_dir(_sys_home)
-    return _is_python_source_dir(project_base)
-
-python_build = _python_build()
-
-
-# Calculate the build qualifier flags if they are defined.  Adding the flags
-# to the include and lib directories only makes sense for an installation, not
-# an in-source build.
-build_flags = ''
-try:
-    if not python_build:
-        build_flags = sys.abiflags
-except AttributeError:
-    # It's not a configure-based build, so the sys module doesn't have
-    # this attribute, which is fine.
-    pass
-
-def get_python_version():
-    """Return a string containing the major and minor Python version,
-    leaving off the patchlevel.  Sample return values could be '1.5'
-    or '2.2'.
-    """
-    return '%d.%d' % sys.version_info[:2]
-
-
-def get_python_inc(plat_specific=0, prefix=None):
-    """Return the directory containing installed Python header files.
-
-    If 'plat_specific' is false (the default), this is the path to the
-    non-platform-specific header files, i.e. Python.h and so on;
-    otherwise, this is the path to platform-specific header files
-    (namely pyconfig.h).
-
-    If 'prefix' is supplied, use it instead of sys.base_prefix or
-    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
-    """
-    if prefix is None:
-        prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
-    if os.name == "posix":
-        if python_build:
-            # Assume the executable is in the build directory.  The
-            # pyconfig.h file should be in the same directory.  Since
-            # the build directory may not be the source directory, we
-            # must use "srcdir" from the makefile to find the "Include"
-            # directory.
-            if plat_specific:
-                return _sys_home or project_base
-            else:
-                incdir = os.path.join(get_config_var('srcdir'), 'Include')
-                return os.path.normpath(incdir)
-        python_dir = 'python' + get_python_version() + build_flags
-        return os.path.join(prefix, "include", python_dir)
-    elif os.name == "nt":
-        if python_build:
-            # Include both the include and PC dir to ensure we can find
-            # pyconfig.h
-            return (os.path.join(prefix, "include") + os.path.pathsep +
-                    os.path.join(prefix, "PC"))
-        return os.path.join(prefix, "include")
-    else:
-        raise DistutilsPlatformError(
-            "I don't know where Python installs its C header files "
-            "on platform '%s'" % os.name)
-
-
-def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
-    """Return the directory containing the Python library (standard or
-    site additions).
-
-    If 'plat_specific' is true, return the directory containing
-    platform-specific modules, i.e. any module from a non-pure-Python
-    module distribution; otherwise, return the platform-shared library
-    directory.  If 'standard_lib' is true, return the directory
-    containing standard Python library modules; otherwise, return the
-    directory for site-specific modules.
-
-    If 'prefix' is supplied, use it instead of sys.base_prefix or
-    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
-    """
-    if prefix is None:
-        if standard_lib:
-            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
-        else:
-            prefix = plat_specific and EXEC_PREFIX or PREFIX
-
-    if os.name == "posix":
-        if plat_specific or standard_lib:
-            # Platform-specific modules (any module from a non-pure-Python
-            # module distribution) or standard Python library modules.
-            libdir = sys.platlibdir
-        else:
-            # Pure Python
-            libdir = "lib"
-        libpython = os.path.join(prefix, libdir,
-                                 # XXX RUSTPYTHON: changed from python->rustpython
-                                 "rustpython" + get_python_version())
-        if standard_lib:
-            return libpython
-        else:
-            return os.path.join(libpython, "site-packages")
-    elif os.name == "nt":
-        if standard_lib:
-            return os.path.join(prefix, "Lib")
-        else:
-            return os.path.join(prefix, "Lib", "site-packages")
-    else:
-        raise DistutilsPlatformError(
-            "I don't know where Python installs its library "
-            "on platform '%s'" % os.name)
-
-
-
-def customize_compiler(compiler):
-    """Do any platform-specific customization of a CCompiler instance.
-
-    Mainly needed on Unix, so we can plug in the information that
-    varies across Unices and is stored in Python's Makefile.
-    """
-    if compiler.compiler_type == "unix":
-        if sys.platform == "darwin":
-            # Perform first-time customization of compiler-related
-            # config vars on OS X now that we know we need a compiler.
-            # This is primarily to support Pythons from binary
-            # installers.  The kind and paths to build tools on
-            # the user system may vary significantly from the system
-            # that Python itself was built on.  Also the user OS
-            # version and build tools may not support the same set
-            # of CPU architectures for universal builds.
-            global _config_vars
-            # Use get_config_var() to ensure _config_vars is initialized.
-            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
-                import _osx_support
-                _osx_support.customize_compiler(_config_vars)
-                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'
-
-        (cc, cxx, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \
-            get_config_vars('CC', 'CXX', 'CFLAGS',
-                            'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')
-
-        if 'CC' in os.environ:
-            newcc = os.environ['CC']
-            if (sys.platform == 'darwin'
-                    and 'LDSHARED' not in os.environ
-                    and ldshared.startswith(cc)):
-                # On OS X, if CC is overridden, use that as the default
-                #       command for LDSHARED as well
-                ldshared = newcc + ldshared[len(cc):]
-            cc = newcc
-        if 'CXX' in os.environ:
-            cxx = os.environ['CXX']
-        if 'LDSHARED' in os.environ:
-            ldshared = os.environ['LDSHARED']
-        if 'CPP' in os.environ:
-            cpp = os.environ['CPP']
-        else:
-            cpp = cc + " -E"           # not always
-        if 'LDFLAGS' in os.environ:
-            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
-        if 'CFLAGS' in os.environ:
-            cflags = cflags + ' ' + os.environ['CFLAGS']
-            ldshared = ldshared + ' ' + os.environ['CFLAGS']
-        if 'CPPFLAGS' in os.environ:
-            cpp = cpp + ' ' + os.environ['CPPFLAGS']
-            cflags = cflags + ' ' + os.environ['CPPFLAGS']
-            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
-        if 'AR' in os.environ:
-            ar = os.environ['AR']
-        if 'ARFLAGS' in os.environ:
-            archiver = ar + ' ' + os.environ['ARFLAGS']
-        else:
-            archiver = ar + ' ' + ar_flags
-
-        cc_cmd = cc + ' ' + cflags
-        compiler.set_executables(
-            preprocessor=cpp,
-            compiler=cc_cmd,
-            compiler_so=cc_cmd + ' ' + ccshared,
-            compiler_cxx=cxx,
-            linker_so=ldshared,
-            linker_exe=cc,
-            archiver=archiver)
-
-        compiler.shared_lib_extension = shlib_suffix
-
-
-def get_config_h_filename():
-    """Return full pathname of installed pyconfig.h file."""
-    if python_build:
-        if os.name == "nt":
-            inc_dir = os.path.join(_sys_home or project_base, "PC")
-        else:
-            inc_dir = _sys_home or project_base
-    else:
-        inc_dir = get_python_inc(plat_specific=1)
-
-    return os.path.join(inc_dir, 'pyconfig.h')
-
-
-def get_makefile_filename():
-    """Return full pathname of installed Makefile from the Python build."""
-    if python_build:
-        return os.path.join(_sys_home or project_base, "Makefile")
-    lib_dir = get_python_lib(plat_specific=0, standard_lib=1)
-    config_file = 'config-{}{}'.format(get_python_version(), build_flags)
-    if hasattr(sys.implementation, '_multiarch'):
-        config_file += '-%s' % sys.implementation._multiarch
-    return os.path.join(lib_dir, config_file, 'Makefile')
-
-
-def parse_config_h(fp, g=None):
-    """Parse a config.h-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    if g is None:
-        g = {}
-    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
-    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
-    #
-    while True:
-        line = fp.readline()
-        if not line:
-            break
-        m = define_rx.match(line)
-        if m:
-            n, v = m.group(1, 2)
-            try: v = int(v)
-            except ValueError: pass
-            g[n] = v
-        else:
-            m = undef_rx.match(line)
-            if m:
-                g[m.group(1)] = 0
-    return g
-
-
-# Regexes needed for parsing Makefile (and similar syntaxes,
-# like old-style Setup files).
-_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
-_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
-_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")
-
-def parse_makefile(fn, g=None):
-    """Parse a Makefile-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    from distutils.text_file import TextFile
-    fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape")
-
-    if g is None:
-        g = {}
-    done = {}
-    notdone = {}
-
-    while True:
-        line = fp.readline()
-        if line is None: # eof
-            break
-        m = _variable_rx.match(line)
-        if m:
-            n, v = m.group(1, 2)
-            v = v.strip()
-            # `$$' is a literal `$' in make
-            tmpv = v.replace('$$', '')
-
-            if "$" in tmpv:
-                notdone[n] = v
-            else:
-                try:
-                    v = int(v)
-                except ValueError:
-                    # insert literal `$'
-                    done[n] = v.replace('$$', '$')
-                else:
-                    done[n] = v
-
-    # Variables with a 'PY_' prefix in the makefile. These need to
-    # be made available without that prefix through sysconfig.
-    # Special care is needed to ensure that variable expansion works, even
-    # if the expansion uses the name without a prefix.
-    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
-
-    # do variable interpolation here
-    while notdone:
-        for name in list(notdone):
-            value = notdone[name]
-            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
-            if m:
-                n = m.group(1)
-                found = True
-                if n in done:
-                    item = str(done[n])
-                elif n in notdone:
-                    # get it on a subsequent round
-                    found = False
-                elif n in os.environ:
-                    # do it like make: fall back to environment
-                    item = os.environ[n]
-
-                elif n in renamed_variables:
-                    if name.startswith('PY_') and name[3:] in renamed_variables:
-                        item = ""
-
-                    elif 'PY_' + n in notdone:
-                        found = False
-
-                    else:
-                        item = str(done['PY_' + n])
-                else:
-                    done[n] = item = ""
-                if found:
-                    after = value[m.end():]
-                    value = value[:m.start()] + item + after
-                    if "$" in after:
-                        notdone[name] = value
-                    else:
-                        try: value = int(value)
-                        except ValueError:
-                            done[name] = value.strip()
-                        else:
-                            done[name] = value
-                        del notdone[name]
-
-                        if name.startswith('PY_') \
-                            and name[3:] in renamed_variables:
-
-                            name = name[3:]
-                            if name not in done:
-                                done[name] = value
-            else:
-                # bogus variable reference; just drop it since we can't deal
-                del notdone[name]
-
-    fp.close()
-
-    # strip spurious spaces
-    for k, v in done.items():
-        if isinstance(v, str):
-            done[k] = v.strip()
-
-    # save the results in the global dictionary
-    g.update(done)
-    return g
-
-
-def expand_makefile_vars(s, vars):
-    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
-    'string' according to 'vars' (a dictionary mapping variable names to
-    values).  Variables not present in 'vars' are silently expanded to the
-    empty string.  The variable values in 'vars' should not contain further
-    variable expansions; if 'vars' is the output of 'parse_makefile()',
-    you're fine.  Returns a variable-expanded version of 's'.
-    """
-
-    # This algorithm does multiple expansion, so if vars['foo'] contains
-    # "${bar}", it will expand ${foo} to ${bar}, and then expand
-    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
-    # 'parse_makefile()', which takes care of such expansions eagerly,
-    # according to make's variable expansion semantics.
-
-    while True:
-        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
-        if m:
-            (beg, end) = m.span()
-            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
-        else:
-            break
-    return s
-
-
-_config_vars = None
-
-def _init_posix():
-    """Initialize the module as appropriate for POSIX systems."""
-    # _sysconfigdata is generated at build time, see the sysconfig module
-    name = os.environ.get('_PYTHON_SYSCONFIGDATA_NAME',
-        '_sysconfigdata_{abi}_{platform}_{multiarch}'.format(
-        abi=sys.abiflags,
-        platform=sys.platform,
-        multiarch=getattr(sys.implementation, '_multiarch', ''),
-    ))
-    _temp = __import__(name, globals(), locals(), ['build_time_vars'], 0)
-    build_time_vars = _temp.build_time_vars
-    global _config_vars
-    _config_vars = {}
-    _config_vars.update(build_time_vars)
-
-
-def _init_nt():
-    """Initialize the module as appropriate for NT"""
-    g = {}
-    # set basic install directories
-    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
-    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)
-
-    # XXX hmmm.. a normal install puts include files here
-    g['INCLUDEPY'] = get_python_inc(plat_specific=0)
-
-    g['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
-    g['EXE'] = ".exe"
-    g['VERSION'] = get_python_version().replace(".", "")
-    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))
-
-    global _config_vars
-    _config_vars = g
-
-
-def get_config_vars(*args):
-    """With no arguments, return a dictionary of all configuration
-    variables relevant for the current platform.  Generally this includes
-    everything needed to build extensions and install both pure modules and
-    extensions.  On Unix, this means every variable defined in Python's
-    installed Makefile; on Windows it's a much smaller set.
-
-    With arguments, return a list of values that result from looking up
-    each argument in the configuration variable dictionary.
-    """
-    global _config_vars
-    if _config_vars is None:
-        func = globals().get("_init_" + os.name)
-        if func:
-            func()
-        else:
-            _config_vars = {}
-
-        # Normalized versions of prefix and exec_prefix are handy to have;
-        # in fact, these are the standard versions used most places in the
-        # Distutils.
-        _config_vars['prefix'] = PREFIX
-        _config_vars['exec_prefix'] = EXEC_PREFIX
-
-        # For backward compatibility, see issue19555
-        SO = _config_vars.get('EXT_SUFFIX')
-        if SO is not None:
-            _config_vars['SO'] = SO
-
-        # Always convert srcdir to an absolute path
-        srcdir = _config_vars.get('srcdir', project_base)
-        if os.name == 'posix':
-            if python_build:
-                # If srcdir is a relative path (typically '.' or '..')
-                # then it should be interpreted relative to the directory
-                # containing Makefile.
-                base = os.path.dirname(get_makefile_filename())
-                srcdir = os.path.join(base, srcdir)
-            else:
-                # srcdir is not meaningful since the installation is
-                # spread about the filesystem.  We choose the
-                # directory containing the Makefile since we know it
-                # exists.
-                srcdir = os.path.dirname(get_makefile_filename())
-        _config_vars['srcdir'] = os.path.abspath(os.path.normpath(srcdir))
-
-        # Convert srcdir into an absolute path if it appears necessary.
-        # Normally it is relative to the build directory.  However, during
-        # testing, for example, we might be running a non-installed python
-        # from a different directory.
-        if python_build and os.name == "posix":
-            base = project_base
-            if (not os.path.isabs(_config_vars['srcdir']) and
-                base != os.getcwd()):
-                # srcdir is relative and we are not in the same directory
-                # as the executable. Assume executable is in the build
-                # directory and make srcdir absolute.
-                srcdir = os.path.join(base, _config_vars['srcdir'])
-                _config_vars['srcdir'] = os.path.normpath(srcdir)
-
-        # OS X platforms require special customization to handle
-        # multi-architecture, multi-os-version installers
-        if sys.platform == 'darwin':
-            import _osx_support
-            _osx_support.customize_config_vars(_config_vars)
-
-    if args:
-        vals = []
-        for name in args:
-            vals.append(_config_vars.get(name))
-        return vals
-    else:
-        return _config_vars
-
-def get_config_var(name):
-    """Return the value of a single variable using the dictionary
-    returned by 'get_config_vars()'.  Equivalent to
-    get_config_vars().get(name)
-    """
-    if name == 'SO':
-        import warnings
-        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
-    return get_config_vars().get(name)
diff --git a/Lib/distutils/text_file.py b/Lib/distutils/text_file.py
deleted file mode 100644
index 93abad38f4..0000000000
--- a/Lib/distutils/text_file.py
+++ /dev/null
@@ -1,286 +0,0 @@
-"""text_file
-
-provides the TextFile class, which gives an interface to text files
-that (optionally) takes care of stripping comments, ignoring blank
-lines, and joining lines with backslashes."""
-
-import sys, io
-
-
-class TextFile:
-    """Provides a file-like object that takes care of all the things you
-       commonly want to do when processing a text file that has some
-       line-by-line syntax: strip comments (as long as "#" is your
-       comment character), skip blank lines, join adjacent lines by
-       escaping the newline (ie. backslash at end of line), strip
-       leading and/or trailing whitespace.  All of these are optional
-       and independently controllable.
-
-       Provides a 'warn()' method so you can generate warning messages that
-       report physical line number, even if the logical line in question
-       spans multiple physical lines.  Also provides 'unreadline()' for
-       implementing line-at-a-time lookahead.
-
-       Constructor is called as:
-
-           TextFile (filename=None, file=None, **options)
-
-       It bombs (RuntimeError) if both 'filename' and 'file' are None;
-       'filename' should be a string, and 'file' a file object (or
-       something that provides 'readline()' and 'close()' methods).  It is
-       recommended that you supply at least 'filename', so that TextFile
-       can include it in warning messages.  If 'file' is not supplied,
-       TextFile creates its own using 'io.open()'.
-
-       The options are all boolean, and affect the value returned by
-       'readline()':
-         strip_comments [default: true]
-           strip from "#" to end-of-line, as well as any whitespace
-           leading up to the "#" -- unless it is escaped by a backslash
-         lstrip_ws [default: false]
-           strip leading whitespace from each line before returning it
-         rstrip_ws [default: true]
-           strip trailing whitespace (including line terminator!) from
-           each line before returning it
-         skip_blanks [default: true}
-           skip lines that are empty *after* stripping comments and
-           whitespace.  (If both lstrip_ws and rstrip_ws are false,
-           then some lines may consist of solely whitespace: these will
-           *not* be skipped, even if 'skip_blanks' is true.)
-         join_lines [default: false]
-           if a backslash is the last non-newline character on a line
-           after stripping comments and whitespace, join the following line
-           to it to form one "logical line"; if N consecutive lines end
-           with a backslash, then N+1 physical lines will be joined to
-           form one logical line.
-         collapse_join [default: false]
-           strip leading whitespace from lines that are joined to their
-           predecessor; only matters if (join_lines and not lstrip_ws)
-         errors [default: 'strict']
-           error handler used to decode the file content
-
-       Note that since 'rstrip_ws' can strip the trailing newline, the
-       semantics of 'readline()' must differ from those of the builtin file
-       object's 'readline()' method!  In particular, 'readline()' returns
-       None for end-of-file: an empty string might just be a blank line (or
-       an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
-       not."""
-
-    default_options = { 'strip_comments': 1,
-                        'skip_blanks':    1,
-                        'lstrip_ws':      0,
-                        'rstrip_ws':      1,
-                        'join_lines':     0,
-                        'collapse_join':  0,
-                        'errors':         'strict',
-                      }
-
-    def __init__(self, filename=None, file=None, **options):
-        """Construct a new TextFile object.  At least one of 'filename'
-           (a string) and 'file' (a file-like object) must be supplied.
-           They keyword argument options are described above and affect
-           the values returned by 'readline()'."""
-        if filename is None and file is None:
-            raise RuntimeError("you must supply either or both of 'filename' and 'file'")
-
-        # set values for all options -- either from client option hash
-        # or fallback to default_options
-        for opt in self.default_options.keys():
-            if opt in options:
-                setattr(self, opt, options[opt])
-            else:
-                setattr(self, opt, self.default_options[opt])
-
-        # sanity check client option hash
-        for opt in options.keys():
-            if opt not in self.default_options:
-                raise KeyError("invalid TextFile option '%s'" % opt)
-
-        if file is None:
-            self.open(filename)
-        else:
-            self.filename = filename
-            self.file = file
-            self.current_line = 0       # assuming that file is at BOF!
-
-        # 'linebuf' is a stack of lines that will be emptied before we
-        # actually read from the file; it's only populated by an
-        # 'unreadline()' operation
-        self.linebuf = []
-
-    def open(self, filename):
-        """Open a new file named 'filename'.  This overrides both the
-           'filename' and 'file' arguments to the constructor."""
-        self.filename = filename
-        self.file = io.open(self.filename, 'r', errors=self.errors)
-        self.current_line = 0
-
-    def close(self):
-        """Close the current file and forget everything we know about it
-           (filename, current line number)."""
-        file = self.file
-        self.file = None
-        self.filename = None
-        self.current_line = None
-        file.close()
-
-    def gen_error(self, msg, line=None):
-        outmsg = []
-        if line is None:
-            line = self.current_line
-        outmsg.append(self.filename + ", ")
-        if isinstance(line, (list, tuple)):
-            outmsg.append("lines %d-%d: " % tuple(line))
-        else:
-            outmsg.append("line %d: " % line)
-        outmsg.append(str(msg))
-        return "".join(outmsg)
-
-    def error(self, msg, line=None):
-        raise ValueError("error: " + self.gen_error(msg, line))
-
-    def warn(self, msg, line=None):
-        """Print (to stderr) a warning message tied to the current logical
-           line in the current file.  If the current logical line in the
-           file spans multiple physical lines, the warning refers to the
-           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
-           the current line number; it may be a list or tuple to indicate a
-           range of physical lines, or an integer for a single physical
-           line."""
-        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")
-
-    def readline(self):
-        """Read and return a single logical line from the current file (or
-           from an internal buffer if lines have previously been "unread"
-           with 'unreadline()').  If the 'join_lines' option is true, this
-           may involve reading multiple physical lines concatenated into a
-           single string.  Updates the current line number, so calling
-           'warn()' after 'readline()' emits a warning about the physical
-           line(s) just read.  Returns None on end-of-file, since the empty
-           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
-           not."""
-        # If any "unread" lines waiting in 'linebuf', return the top
-        # one.  (We don't actually buffer read-ahead data -- lines only
-        # get put in 'linebuf' if the client explicitly does an
-        # 'unreadline()'.
-        if self.linebuf:
-            line = self.linebuf[-1]
-            del self.linebuf[-1]
-            return line
-
-        buildup_line = ''
-
-        while True:
-            # read the line, make it None if EOF
-            line = self.file.readline()
-            if line == '':
-                line = None
-
-            if self.strip_comments and line:
-
-                # Look for the first "#" in the line.  If none, never
-                # mind.  If we find one and it's the first character, or
-                # is not preceded by "\", then it starts a comment --
-                # strip the comment, strip whitespace before it, and
-                # carry on.  Otherwise, it's just an escaped "#", so
-                # unescape it (and any other escaped "#"'s that might be
-                # lurking in there) and otherwise leave the line alone.
-
-                pos = line.find("#")
-                if pos == -1: # no "#" -- no comments
-                    pass
-
-                # It's definitely a comment -- either "#" is the first
-                # character, or it's elsewhere and unescaped.
-                elif pos == 0 or line[pos-1] != "\\":
-                    # Have to preserve the trailing newline, because it's
-                    # the job of a later step (rstrip_ws) to remove it --
-                    # and if rstrip_ws is false, we'd better preserve it!
-                    # (NB. this means that if the final line is all comment
-                    # and has no trailing newline, we will think that it's
-                    # EOF; I think that's OK.)
-                    eol = (line[-1] == '\n') and '\n' or ''
-                    line = line[0:pos] + eol
-
-                    # If all that's left is whitespace, then skip line
-                    # *now*, before we try to join it to 'buildup_line' --
-                    # that way constructs like
-                    #   hello \\
-                    #   # comment that should be ignored
-                    #   there
-                    # result in "hello there".
-                    if line.strip() == "":
-                        continue
-                else: # it's an escaped "#"
-                    line = line.replace("\\#", "#")
-
-            # did previous line end with a backslash? then accumulate
-            if self.join_lines and buildup_line:
-                # oops: end of file
-                if line is None:
-                    self.warn("continuation line immediately precedes "
-                              "end-of-file")
-                    return buildup_line
-
-                if self.collapse_join:
-                    line = line.lstrip()
-                line = buildup_line + line
-
-                # careful: pay attention to line number when incrementing it
-                if isinstance(self.current_line, list):
-                    self.current_line[1] = self.current_line[1] + 1
-                else:
-                    self.current_line = [self.current_line,
-                                         self.current_line + 1]
-            # just an ordinary line, read it as usual
-            else:
-                if line is None: # eof
-                    return None
-
-                # still have to be careful about incrementing the line number!
-                if isinstance(self.current_line, list):
-                    self.current_line = self.current_line[1] + 1
-                else:
-                    self.current_line = self.current_line + 1
-
-            # strip whitespace however the client wants (leading and
-            # trailing, or one or the other, or neither)
-            if self.lstrip_ws and self.rstrip_ws:
-                line = line.strip()
-            elif self.lstrip_ws:
-                line = line.lstrip()
-            elif self.rstrip_ws:
-                line = line.rstrip()
-
-            # blank line (whether we rstrip'ed or not)? skip to next line
-            # if appropriate
-            if (line == '' or line == '\n') and self.skip_blanks:
-                continue
-
-            if self.join_lines:
-                if line[-1] == '\\':
-                    buildup_line = line[:-1]
-                    continue
-
-                if line[-2:] == '\\\n':
-                    buildup_line = line[0:-2] + '\n'
-                    continue
-
-            # well, I guess there's some actual content there: return it
-            return line
-
-    def readlines(self):
-        """Read and return the list of all logical lines remaining in the
-           current file."""
-        lines = []
-        while True:
-            line = self.readline()
-            if line is None:
-                return lines
-            lines.append(line)
-
-    def unreadline(self, line):
-        """Push 'line' (a string) onto an internal buffer that will be
-           checked by future 'readline()' calls.  Handy for implementing
-           a parser with line-at-a-time lookahead."""
-        self.linebuf.append(line)
diff --git a/Lib/distutils/unixccompiler.py b/Lib/distutils/unixccompiler.py
deleted file mode 100644
index 4524417e66..0000000000
--- a/Lib/distutils/unixccompiler.py
+++ /dev/null
@@ -1,333 +0,0 @@
-"""distutils.unixccompiler
-
-Contains the UnixCCompiler class, a subclass of CCompiler that handles
-the "typical" Unix-style command-line C compiler:
-  * macros defined with -Dname[=value]
-  * macros undefined with -Uname
-  * include search directories specified with -Idir
-  * libraries specified with -lllib
-  * library search directories specified with -Ldir
-  * compile handled by 'cc' (or similar) executable with -c option:
-    compiles .c to .o
-  * link static library handled by 'ar' command (possibly with 'ranlib')
-  * link shared library handled by 'cc -shared'
-"""
-
-import os, sys, re
-
-from distutils import sysconfig
-from distutils.dep_util import newer
-from distutils.ccompiler import \
-     CCompiler, gen_preprocess_options, gen_lib_options
-from distutils.errors import \
-     DistutilsExecError, CompileError, LibError, LinkError
-from distutils import log
-
-if sys.platform == 'darwin':
-    import _osx_support
-
-# XXX Things not currently handled:
-#   * optimization/debug/warning flags; we just use whatever's in Python's
-#     Makefile and live with it.  Is this adequate?  If not, we might
-#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
-#     SunCCompiler, and I suspect down that road lies madness.
-#   * even if we don't know a warning flag from an optimization flag,
-#     we need some way for outsiders to feed preprocessor/compiler/linker
-#     flags in to us -- eg. a sysadmin might want to mandate certain flags
-#     via a site config file, or a user might want to set something for
-#     compiling this module distribution only via the setup.py command
-#     line, whatever.  As long as these options come from something on the
-#     current system, they can be as system-dependent as they like, and we
-#     should just happily stuff them into the preprocessor/compiler/linker
-#     options and carry on.
-
-
-class UnixCCompiler(CCompiler):
-
-    compiler_type = 'unix'
-
-    # These are used by CCompiler in two places: the constructor sets
-    # instance attributes 'preprocessor', 'compiler', etc. from them, and
-    # 'set_executable()' allows any of these to be set.  The defaults here
-    # are pretty generic; they will probably have to be set by an outsider
-    # (eg. using information discovered by the sysconfig about building
-    # Python extensions).
-    executables = {'preprocessor' : None,
-                   'compiler'     : ["cc"],
-                   'compiler_so'  : ["cc"],
-                   'compiler_cxx' : ["cc"],
-                   'linker_so'    : ["cc", "-shared"],
-                   'linker_exe'   : ["cc"],
-                   'archiver'     : ["ar", "-cr"],
-                   'ranlib'       : None,
-                  }
-
-    if sys.platform[:6] == "darwin":
-        executables['ranlib'] = ["ranlib"]
-
-    # Needed for the filename generation methods provided by the base
-    # class, CCompiler.  NB. whoever instantiates/uses a particular
-    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
-    # reasonable common default here, but it's not necessarily used on all
-    # Unices!
-
-    src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
-    obj_extension = ".o"
-    static_lib_extension = ".a"
-    shared_lib_extension = ".so"
-    dylib_lib_extension = ".dylib"
-    xcode_stub_lib_extension = ".tbd"
-    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
-    xcode_stub_lib_format = dylib_lib_format
-    if sys.platform == "cygwin":
-        exe_extension = ".exe"
-
-    def preprocess(self, source, output_file=None, macros=None,
-                   include_dirs=None, extra_preargs=None, extra_postargs=None):
-        fixed_args = self._fix_compile_args(None, macros, include_dirs)
-        ignore, macros, include_dirs = fixed_args
-        pp_opts = gen_preprocess_options(macros, include_dirs)
-        pp_args = self.preprocessor + pp_opts
-        if output_file:
-            pp_args.extend(['-o', output_file])
-        if extra_preargs:
-            pp_args[:0] = extra_preargs
-        if extra_postargs:
-            pp_args.extend(extra_postargs)
-        pp_args.append(source)
-
-        # We need to preprocess: either we're being forced to, or we're
-        # generating output to stdout, or there's a target output file and
-        # the source file is newer than the target (or the target doesn't
-        # exist).
-        if self.force or output_file is None or newer(source, output_file):
-            if output_file:
-                self.mkpath(os.path.dirname(output_file))
-            try:
-                self.spawn(pp_args)
-            except DistutilsExecError as msg:
-                raise CompileError(msg)
-
-    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
-        compiler_so = self.compiler_so
-        if sys.platform == 'darwin':
-            compiler_so = _osx_support.compiler_fixup(compiler_so,
-                                                    cc_args + extra_postargs)
-        try:
-            self.spawn(compiler_so + cc_args + [src, '-o', obj] +
-                       extra_postargs)
-        except DistutilsExecError as msg:
-            raise CompileError(msg)
-
-    def create_static_lib(self, objects, output_libname,
-                          output_dir=None, debug=0, target_lang=None):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-
-        output_filename = \
-            self.library_filename(output_libname, output_dir=output_dir)
-
-        if self._need_link(objects, output_filename):
-            self.mkpath(os.path.dirname(output_filename))
-            self.spawn(self.archiver +
-                       [output_filename] +
-                       objects + self.objects)
-
-            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
-            # think the only major Unix that does.  Maybe we need some
-            # platform intelligence here to skip ranlib if it's not
-            # needed -- or maybe Python's configure script took care of
-            # it for us, hence the check for leading colon.
-            if self.ranlib:
-                try:
-                    self.spawn(self.ranlib + [output_filename])
-                except DistutilsExecError as msg:
-                    raise LibError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    def link(self, target_desc, objects,
-             output_filename, output_dir=None, libraries=None,
-             library_dirs=None, runtime_library_dirs=None,
-             export_symbols=None, debug=0, extra_preargs=None,
-             extra_postargs=None, build_temp=None, target_lang=None):
-        objects, output_dir = self._fix_object_args(objects, output_dir)
-        fixed_args = self._fix_lib_args(libraries, library_dirs,
-                                        runtime_library_dirs)
-        libraries, library_dirs, runtime_library_dirs = fixed_args
-
-        # filter out standard library paths, which are not explicitely needed
-        # for linking
-        system_libdirs = ['/lib', '/lib64', '/usr/lib', '/usr/lib64']
-        multiarch = sysconfig.get_config_var("MULTIARCH")
-        if multiarch:
-            system_libdirs.extend(['/lib/%s' % multiarch, '/usr/lib/%s' % multiarch])
-        library_dirs = [dir for dir in library_dirs
-                        if not dir in system_libdirs]
-        runtime_library_dirs = [dir for dir in runtime_library_dirs
-                                if not dir in system_libdirs]
-
-        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
-                                   libraries)
-        if not isinstance(output_dir, (str, type(None))):
-            raise TypeError("'output_dir' must be a string or None")
-        if output_dir is not None:
-            output_filename = os.path.join(output_dir, output_filename)
-
-        if self._need_link(objects, output_filename):
-            ld_args = (objects + self.objects +
-                       lib_opts + ['-o', output_filename])
-            if debug:
-                ld_args[:0] = ['-g']
-            if extra_preargs:
-                ld_args[:0] = extra_preargs
-            if extra_postargs:
-                ld_args.extend(extra_postargs)
-            self.mkpath(os.path.dirname(output_filename))
-            try:
-                if target_desc == CCompiler.EXECUTABLE:
-                    linker = self.linker_exe[:]
-                else:
-                    linker = self.linker_so[:]
-                if target_lang == "c++" and self.compiler_cxx:
-                    # skip over environment variable settings if /usr/bin/env
-                    # is used to set up the linker's environment.
-                    # This is needed on OSX. Note: this assumes that the
-                    # normal and C++ compiler have the same environment
-                    # settings.
-                    i = 0
-                    if os.path.basename(linker[0]) == "env":
-                        i = 1
-                        while '=' in linker[i]:
-                            i += 1
-                    linker[i] = self.compiler_cxx[i]
-
-                if sys.platform == 'darwin':
-                    linker = _osx_support.compiler_fixup(linker, ld_args)
-
-                self.spawn(linker + ld_args)
-            except DistutilsExecError as msg:
-                raise LinkError(msg)
-        else:
-            log.debug("skipping %s (up-to-date)", output_filename)
-
-    # -- Miscellaneous methods -----------------------------------------
-    # These are all used by the 'gen_lib_options() function, in
-    # ccompiler.py.
-
-    def library_dir_option(self, dir):
-        return "-L" + dir
-
-    def _is_gcc(self, compiler_name):
-        return "gcc" in compiler_name or "g++" in compiler_name
-
-    def runtime_library_dir_option(self, dir):
-        # XXX Hackish, at the very least.  See Python bug #445902:
-        # http://sourceforge.net/tracker/index.php
-        #   ?func=detail&aid=445902&group_id=5470&atid=105470
-        # Linkers on different platforms need different options to
-        # specify that directories need to be added to the list of
-        # directories searched for dependencies when a dynamic library
-        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
-        # be told to pass the -R option through to the linker, whereas
-        # other compilers and gcc on other systems just know this.
-        # Other compilers may need something slightly different.  At
-        # this time, there's no way to determine this information from
-        # the configuration data stored in the Python installation, so
-        # we use this hack.
-        compiler = os.path.basename(sysconfig.get_config_var("CC"))
-        if sys.platform[:6] == "darwin":
-            # MacOSX's linker doesn't understand the -R flag at all
-            return "-L" + dir
-        elif sys.platform[:7] == "freebsd":
-            return "-Wl,-rpath=" + dir
-        elif sys.platform[:5] == "hp-ux":
-            if self._is_gcc(compiler):
-                return ["-Wl,+s", "-L" + dir]
-            return ["+s", "-L" + dir]
-        elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5":
-            return ["-rpath", dir]
-        else:
-            if self._is_gcc(compiler):
-                # gcc on non-GNU systems does not need -Wl, but can
-                # use it anyway.  Since distutils has always passed in
-                # -Wl whenever gcc was used in the past it is probably
-                # safest to keep doing so.
-                if sysconfig.get_config_var("GNULD") == "yes":
-                    # GNU ld needs an extra option to get a RUNPATH
-                    # instead of just an RPATH.
-                    return "-Wl,--enable-new-dtags,-R" + dir
-                else:
-                    return "-Wl,-R" + dir
-            else:
-                # No idea how --enable-new-dtags would be passed on to
-                # ld if this system was using GNU ld.  Don't know if a
-                # system like this even exists.
-                return "-R" + dir
-
-    def library_option(self, lib):
-        return "-l" + lib
-
-    def find_library_file(self, dirs, lib, debug=0):
-        shared_f = self.library_filename(lib, lib_type='shared')
-        dylib_f = self.library_filename(lib, lib_type='dylib')
-        xcode_stub_f = self.library_filename(lib, lib_type='xcode_stub')
-        static_f = self.library_filename(lib, lib_type='static')
-
-        if sys.platform == 'darwin':
-            # On OSX users can specify an alternate SDK using
-            # '-isysroot', calculate the SDK root if it is specified
-            # (and use it further on)
-            #
-            # Note that, as of Xcode 7, Apple SDKs may contain textual stub
-            # libraries with .tbd extensions rather than the normal .dylib
-            # shared libraries installed in /.  The Apple compiler tool
-            # chain handles this transparently but it can cause problems
-            # for programs that are being built with an SDK and searching
-            # for specific libraries.  Callers of find_library_file need to
-            # keep in mind that the base filename of the returned SDK library
-            # file might have a different extension from that of the library
-            # file installed on the running system, for example:
-            #   /Applications/Xcode.app/Contents/Developer/Platforms/
-            #       MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
-            #       usr/lib/libedit.tbd
-            # vs
-            #   /usr/lib/libedit.dylib
-            cflags = sysconfig.get_config_var('CFLAGS')
-            m = re.search(r'-isysroot\s+(\S+)', cflags)
-            if m is None:
-                sysroot = '/'
-            else:
-                sysroot = m.group(1)
-
-
-
-        for dir in dirs:
-            shared = os.path.join(dir, shared_f)
-            dylib = os.path.join(dir, dylib_f)
-            static = os.path.join(dir, static_f)
-            xcode_stub = os.path.join(dir, xcode_stub_f)
-
-            if sys.platform == 'darwin' and (
-                dir.startswith('/System/') or (
-                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):
-
-                shared = os.path.join(sysroot, dir[1:], shared_f)
-                dylib = os.path.join(sysroot, dir[1:], dylib_f)
-                static = os.path.join(sysroot, dir[1:], static_f)
-                xcode_stub = os.path.join(sysroot, dir[1:], xcode_stub_f)
-
-            # We're second-guessing the linker here, with not much hard
-            # data to go on: GCC seems to prefer the shared library, so I'm
-            # assuming that *all* Unix C compilers do.  And of course I'm
-            # ignoring even GCC's "-static" option.  So sue me.
-            if os.path.exists(dylib):
-                return dylib
-            elif os.path.exists(xcode_stub):
-                return xcode_stub
-            elif os.path.exists(shared):
-                return shared
-            elif os.path.exists(static):
-                return static
-
-        # Oops, didn't find it in *any* of 'dirs'
-        return None
diff --git a/Lib/distutils/util.py b/Lib/distutils/util.py
deleted file mode 100644
index fdcf6fabae..0000000000
--- a/Lib/distutils/util.py
+++ /dev/null
@@ -1,557 +0,0 @@
-"""distutils.util
-
-Miscellaneous utility functions -- anything that doesn't fit into
-one of the other *util.py modules.
-"""
-
-import os
-import re
-import importlib.util
-import string
-import sys
-from distutils.errors import DistutilsPlatformError
-from distutils.dep_util import newer
-from distutils.spawn import spawn
-from distutils import log
-from distutils.errors import DistutilsByteCompileError
-
-def get_platform ():
-    """Return a string that identifies the current platform.  This is used
-    mainly to distinguish platform-specific build directories and
-    platform-specific built distributions.  Typically includes the OS name
-    and version and the architecture (as supplied by 'os.uname()'),
-    although the exact information included depends on the OS; eg. for IRIX
-    the architecture isn't particularly important (IRIX only runs on SGI
-    hardware), but for Linux the kernel version isn't particularly
-    important.
-
-    Examples of returned values:
-       linux-i586
-       linux-alpha (?)
-       solaris-2.6-sun4u
-       irix-5.3
-       irix64-6.2
-
-    Windows will return one of:
-       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
-       win-ia64 (64bit Windows on Itanium)
-       win32 (all others - specifically, sys.platform is returned)
-
-    For other non-POSIX platforms, currently just returns 'sys.platform'.
-    """
-    if os.name == 'nt':
-        # sniff sys.version for architecture.
-        prefix = " bit ("
-        i = sys.version.find(prefix)
-        if i == -1:
-            return sys.platform
-        j = sys.version.find(")", i)
-        look = sys.version[i+len(prefix):j].lower()
-        if look == 'amd64':
-            return 'win-amd64'
-        if look == 'itanium':
-            return 'win-ia64'
-        return sys.platform
-
-    # Set for cross builds explicitly
-    if "_PYTHON_HOST_PLATFORM" in os.environ:
-        return os.environ["_PYTHON_HOST_PLATFORM"]
-
-    if os.name != "posix" or not hasattr(os, 'uname'):
-        # XXX what about the architecture? NT is Intel or Alpha,
-        # Mac OS is M68k or PPC, etc.
-        return sys.platform
-
-    # Try to distinguish various flavours of Unix
-
-    (osname, host, release, version, machine) = os.uname()
-
-    # Convert the OS name to lowercase, remove '/' characters
-    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
-    osname = osname.lower().replace('/', '')
-    machine = machine.replace(' ', '_')
-    machine = machine.replace('/', '-')
-
-    if osname[:5] == "linux":
-        # At least on Linux/Intel, 'machine' is the processor --
-        # i386, etc.
-        # XXX what about Alpha, SPARC, etc?
-        return  "%s-%s" % (osname, machine)
-    elif osname[:5] == "sunos":
-        if release[0] >= "5":           # SunOS 5 == Solaris 2
-            osname = "solaris"
-            release = "%d.%s" % (int(release[0]) - 3, release[2:])
-            # We can't use "platform.architecture()[0]" because a
-            # bootstrap problem. We use a dict to get an error
-            # if some suspicious happens.
-            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
-            machine += ".%s" % bitness[sys.maxsize]
-        # fall through to standard osname-release-machine representation
-    elif osname[:4] == "irix":              # could be "irix64"!
-        return "%s-%s" % (osname, release)
-    elif osname[:3] == "aix":
-        return "%s-%s.%s" % (osname, version, release)
-    elif osname[:6] == "cygwin":
-        osname = "cygwin"
-        rel_re = re.compile (r'[\d.]+', re.ASCII)
-        m = rel_re.match(release)
-        if m:
-            release = m.group()
-    elif osname[:6] == "darwin":
-        import _osx_support, distutils.sysconfig
-        osname, release, machine = _osx_support.get_platform_osx(
-                                        distutils.sysconfig.get_config_vars(),
-                                        osname, release, machine)
-
-    return "%s-%s-%s" % (osname, release, machine)
-
-# get_platform ()
-
-
-def convert_path (pathname):
-    """Return 'pathname' as a name that will work on the native filesystem,
-    i.e. split it on '/' and put it back together again using the current
-    directory separator.  Needed because filenames in the setup script are
-    always supplied in Unix style, and have to be converted to the local
-    convention before we can actually use them in the filesystem.  Raises
-    ValueError on non-Unix-ish systems if 'pathname' either starts or
-    ends with a slash.
-    """
-    if os.sep == '/':
-        return pathname
-    if not pathname:
-        return pathname
-    if pathname[0] == '/':
-        raise ValueError("path '%s' cannot be absolute" % pathname)
-    if pathname[-1] == '/':
-        raise ValueError("path '%s' cannot end with '/'" % pathname)
-
-    paths = pathname.split('/')
-    while '.' in paths:
-        paths.remove('.')
-    if not paths:
-        return os.curdir
-    return os.path.join(*paths)
-
-# convert_path ()
-
-
-def change_root (new_root, pathname):
-    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
-    relative, this is equivalent to "os.path.join(new_root,pathname)".
-    Otherwise, it requires making 'pathname' relative and then joining the
-    two, which is tricky on DOS/Windows and Mac OS.
-    """
-    if os.name == 'posix':
-        if not os.path.isabs(pathname):
-            return os.path.join(new_root, pathname)
-        else:
-            return os.path.join(new_root, pathname[1:])
-
-    elif os.name == 'nt':
-        (drive, path) = os.path.splitdrive(pathname)
-        if path[0] == '\\':
-            path = path[1:]
-        return os.path.join(new_root, path)
-
-    else:
-        raise DistutilsPlatformError("nothing known about platform '%s'" % os.name)
-
-
-_environ_checked = 0
-def check_environ ():
-    """Ensure that 'os.environ' has all the environment variables we
-    guarantee that users can use in config files, command-line options,
-    etc.  Currently this includes:
-      HOME - user's home directory (Unix only)
-      PLAT - description of the current platform, including hardware
-             and OS (see 'get_platform()')
-    """
-    global _environ_checked
-    if _environ_checked:
-        return
-
-    if os.name == 'posix' and 'HOME' not in os.environ:
-        import pwd
-        os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
-
-    if 'PLAT' not in os.environ:
-        os.environ['PLAT'] = get_platform()
-
-    _environ_checked = 1
-
-
-def subst_vars (s, local_vars):
-    """Perform shell/Perl-style variable substitution on 'string'.  Every
-    occurrence of '$' followed by a name is considered a variable, and
-    variable is substituted by the value found in the 'local_vars'
-    dictionary, or in 'os.environ' if it's not in 'local_vars'.
-    'os.environ' is first checked/augmented to guarantee that it contains
-    certain values: see 'check_environ()'.  Raise ValueError for any
-    variables not found in either 'local_vars' or 'os.environ'.
-    """
-    check_environ()
-    def _subst (match, local_vars=local_vars):
-        var_name = match.group(1)
-        if var_name in local_vars:
-            return str(local_vars[var_name])
-        else:
-            return os.environ[var_name]
-
-    try:
-        return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
-    except KeyError as var:
-        raise ValueError("invalid variable '$%s'" % var)
-
-# subst_vars ()
-
-
-def grok_environment_error (exc, prefix="error: "):
-    # Function kept for backward compatibility.
-    # Used to try clever things with EnvironmentErrors,
-    # but nowadays str(exception) produces good messages.
-    return prefix + str(exc)
-
-
-# Needed by 'split_quoted()'
-_wordchars_re = _squote_re = _dquote_re = None
-def _init_regex():
-    global _wordchars_re, _squote_re, _dquote_re
-    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
-    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
-    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')
-
-def split_quoted (s):
-    """Split a string up according to Unix shell-like rules for quotes and
-    backslashes.  In short: words are delimited by spaces, as long as those
-    spaces are not escaped by a backslash, or inside a quoted string.
-    Single and double quotes are equivalent, and the quote characters can
-    be backslash-escaped.  The backslash is stripped from any two-character
-    escape sequence, leaving only the escaped character.  The quote
-    characters are stripped from any quoted string.  Returns a list of
-    words.
-    """
-
-    # This is a nice algorithm for splitting up a single string, since it
-    # doesn't require character-by-character examination.  It was a little
-    # bit of a brain-bender to get it working right, though...
-    if _wordchars_re is None: _init_regex()
-
-    s = s.strip()
-    words = []
-    pos = 0
-
-    while s:
-        m = _wordchars_re.match(s, pos)
-        end = m.end()
-        if end == len(s):
-            words.append(s[:end])
-            break
-
-        if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
-            words.append(s[:end])       # we definitely have a word delimiter
-            s = s[end:].lstrip()
-            pos = 0
-
-        elif s[end] == '\\':            # preserve whatever is being escaped;
-                                        # will become part of the current word
-            s = s[:end] + s[end+1:]
-            pos = end+1
-
-        else:
-            if s[end] == "'":           # slurp singly-quoted string
-                m = _squote_re.match(s, end)
-            elif s[end] == '"':         # slurp doubly-quoted string
-                m = _dquote_re.match(s, end)
-            else:
-                raise RuntimeError("this can't happen (bad char '%c')" % s[end])
-
-            if m is None:
-                raise ValueError("bad string (mismatched %s quotes?)" % s[end])
-
-            (beg, end) = m.span()
-            s = s[:beg] + s[beg+1:end-1] + s[end:]
-            pos = m.end() - 2
-
-        if pos >= len(s):
-            words.append(s)
-            break
-
-    return words
-
-# split_quoted ()
-
-
-def execute (func, args, msg=None, verbose=0, dry_run=0):
-    """Perform some action that affects the outside world (eg.  by
-    writing to the filesystem).  Such actions are special because they
-    are disabled by the 'dry_run' flag.  This method takes care of all
-    that bureaucracy for you; all you have to do is supply the
-    function to call and an argument tuple for it (to embody the
-    "external action" being performed), and an optional message to
-    print.
-    """
-    if msg is None:
-        msg = "%s%r" % (func.__name__, args)
-        if msg[-2:] == ',)':        # correct for singleton tuple
-            msg = msg[0:-2] + ')'
-
-    log.info(msg)
-    if not dry_run:
-        func(*args)
-
-
-def strtobool (val):
-    """Convert a string representation of truth to true (1) or false (0).
-
-    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
-    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
-    'val' is anything else.
-    """
-    val = val.lower()
-    if val in ('y', 'yes', 't', 'true', 'on', '1'):
-        return 1
-    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
-        return 0
-    else:
-        raise ValueError("invalid truth value %r" % (val,))
-
-
-def byte_compile (py_files,
-                  optimize=0, force=0,
-                  prefix=None, base_dir=None,
-                  verbose=1, dry_run=0,
-                  direct=None):
-    """Byte-compile a collection of Python source files to .pyc
-    files in a __pycache__ subdirectory.  'py_files' is a list
-    of files to compile; any files that don't end in ".py" are silently
-    skipped.  'optimize' must be one of the following:
-      0 - don't optimize
-      1 - normal optimization (like "python -O")
-      2 - extra optimization (like "python -OO")
-    If 'force' is true, all files are recompiled regardless of
-    timestamps.
-
-    The source filename encoded in each bytecode file defaults to the
-    filenames listed in 'py_files'; you can modify these with 'prefix' and
-    'basedir'.  'prefix' is a string that will be stripped off of each
-    source filename, and 'base_dir' is a directory name that will be
-    prepended (after 'prefix' is stripped).  You can supply either or both
-    (or neither) of 'prefix' and 'base_dir', as you wish.
-
-    If 'dry_run' is true, doesn't actually do anything that would
-    affect the filesystem.
-
-    Byte-compilation is either done directly in this interpreter process
-    with the standard py_compile module, or indirectly by writing a
-    temporary script and executing it.  Normally, you should let
-    'byte_compile()' figure out to use direct compilation or not (see
-    the source for details).  The 'direct' flag is used by the script
-    generated in indirect mode; unless you know what you're doing, leave
-    it set to None.
-    """
-
-    # Late import to fix a bootstrap issue: _posixsubprocess is built by
-    # setup.py, but setup.py uses distutils.
-    import subprocess
-
-    # nothing is done if sys.dont_write_bytecode is True
-    if sys.dont_write_bytecode:
-        raise DistutilsByteCompileError('byte-compiling is disabled.')
-
-    # First, if the caller didn't force us into direct or indirect mode,
-    # figure out which mode we should be in.  We take a conservative
-    # approach: choose direct mode *only* if the current interpreter is
-    # in debug mode and optimize is 0.  If we're not in debug mode (-O
-    # or -OO), we don't know which level of optimization this
-    # interpreter is running with, so we can't do direct
-    # byte-compilation and be certain that it's the right thing.  Thus,
-    # always compile indirectly if the current interpreter is in either
-    # optimize mode, or if either optimization level was requested by
-    # the caller.
-    if direct is None:
-        direct = (__debug__ and optimize == 0)
-
-    # "Indirect" byte-compilation: write a temporary script and then
-    # run it with the appropriate flags.
-    if not direct:
-        try:
-            from tempfile import mkstemp
-            (script_fd, script_name) = mkstemp(".py")
-        except ImportError:
-            from tempfile import mktemp
-            (script_fd, script_name) = None, mktemp(".py")
-        log.info("writing byte-compilation script '%s'", script_name)
-        if not dry_run:
-            if script_fd is not None:
-                script = os.fdopen(script_fd, "w")
-            else:
-                script = open(script_name, "w")
-
-            script.write("""\
-from distutils.util import byte_compile
-files = [
-""")
-
-            # XXX would be nice to write absolute filenames, just for
-            # safety's sake (script should be more robust in the face of
-            # chdir'ing before running it).  But this requires abspath'ing
-            # 'prefix' as well, and that breaks the hack in build_lib's
-            # 'byte_compile()' method that carefully tacks on a trailing
-            # slash (os.sep really) to make sure the prefix here is "just
-            # right".  This whole prefix business is rather delicate -- the
-            # problem is that it's really a directory, but I'm treating it
-            # as a dumb string, so trailing slashes and so forth matter.
-
-            #py_files = map(os.path.abspath, py_files)
-            #if prefix:
-            #    prefix = os.path.abspath(prefix)
-
-            script.write(",\n".join(map(repr, py_files)) + "]\n")
-            script.write("""
-byte_compile(files, optimize=%r, force=%r,
-             prefix=%r, base_dir=%r,
-             verbose=%r, dry_run=0,
-             direct=1)
-""" % (optimize, force, prefix, base_dir, verbose))
-
-            script.close()
-
-        cmd = [sys.executable]
-        cmd.extend(subprocess._optim_args_from_interpreter_flags())
-        cmd.append(script_name)
-        spawn(cmd, dry_run=dry_run)
-        execute(os.remove, (script_name,), "removing %s" % script_name,
-                dry_run=dry_run)
-
-    # "Direct" byte-compilation: use the py_compile module to compile
-    # right here, right now.  Note that the script generated in indirect
-    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
-    # cross-process recursion.  Hey, it works!
-    else:
-        from py_compile import compile
-
-        for file in py_files:
-            if file[-3:] != ".py":
-                # This lets us be lazy and not filter filenames in
-                # the "install_lib" command.
-                continue
-
-            # Terminology from the py_compile module:
-            #   cfile - byte-compiled file
-            #   dfile - purported source filename (same as 'file' by default)
-            if optimize >= 0:
-                opt = '' if optimize == 0 else optimize
-                cfile = importlib.util.cache_from_source(
-                    file, optimization=opt)
-            else:
-                cfile = importlib.util.cache_from_source(file)
-            dfile = file
-            if prefix:
-                if file[:len(prefix)] != prefix:
-                    raise ValueError("invalid prefix: filename %r doesn't start with %r"
-                           % (file, prefix))
-                dfile = dfile[len(prefix):]
-            if base_dir:
-                dfile = os.path.join(base_dir, dfile)
-
-            cfile_base = os.path.basename(cfile)
-            if direct:
-                if force or newer(file, cfile):
-                    log.info("byte-compiling %s to %s", file, cfile_base)
-                    if not dry_run:
-                        compile(file, cfile, dfile)
-                else:
-                    log.debug("skipping byte-compilation of %s to %s",
-                              file, cfile_base)
-
-# byte_compile ()
-
-def rfc822_escape (header):
-    """Return a version of the string escaped for inclusion in an
-    RFC-822 header, by ensuring there are 8 spaces space after each newline.
-    """
-    lines = header.split('\n')
-    sep = '\n' + 8 * ' '
-    return sep.join(lines)
-
-# 2to3 support
-
-def run_2to3(files, fixer_names=None, options=None, explicit=None):
-    """Invoke 2to3 on a list of Python files.
-    The files should all come from the build area, as the
-    modification is done in-place. To reduce the build time,
-    only files modified since the last invocation of this
-    function should be passed in the files argument."""
-
-    if not files:
-        return
-
-    # Make this class local, to delay import of 2to3
-    from lib2to3.refactor import RefactoringTool, get_fixers_from_package
-    class DistutilsRefactoringTool(RefactoringTool):
-        def log_error(self, msg, *args, **kw):
-            log.error(msg, *args)
-
-        def log_message(self, msg, *args):
-            log.info(msg, *args)
-
-        def log_debug(self, msg, *args):
-            log.debug(msg, *args)
-
-    if fixer_names is None:
-        fixer_names = get_fixers_from_package('lib2to3.fixes')
-    r = DistutilsRefactoringTool(fixer_names, options=options)
-    r.refactor(files, write=True)
-
-def copydir_run_2to3(src, dest, template=None, fixer_names=None,
-                     options=None, explicit=None):
-    """Recursively copy a directory, only copying new and changed files,
-    running run_2to3 over all newly copied Python modules afterward.
-
-    If you give a template string, it's parsed like a MANIFEST.in.
-    """
-    from distutils.dir_util import mkpath
-    from distutils.file_util import copy_file
-    from distutils.filelist import FileList
-    filelist = FileList()
-    curdir = os.getcwd()
-    os.chdir(src)
-    try:
-        filelist.findall()
-    finally:
-        os.chdir(curdir)
-    filelist.files[:] = filelist.allfiles
-    if template:
-        for line in template.splitlines():
-            line = line.strip()
-            if not line: continue
-            filelist.process_template_line(line)
-    copied = []
-    for filename in filelist.files:
-        outname = os.path.join(dest, filename)
-        mkpath(os.path.dirname(outname))
-        res = copy_file(os.path.join(src, filename), outname, update=1)
-        if res[1]: copied.append(outname)
-    run_2to3([fn for fn in copied if fn.lower().endswith('.py')],
-             fixer_names=fixer_names, options=options, explicit=explicit)
-    return copied
-
-class Mixin2to3:
-    '''Mixin class for commands that run 2to3.
-    To configure 2to3, setup scripts may either change
-    the class variables, or inherit from individual commands
-    to override how 2to3 is invoked.'''
-
-    # provide list of fixers to run;
-    # defaults to all from lib2to3.fixers
-    fixer_names = None
-
-    # options dictionary
-    options = None
-
-    # list of fixers to invoke even though they are marked as explicit
-    explicit = None
-
-    def run_2to3(self, files):
-        return run_2to3(files, self.fixer_names, self.options, self.explicit)
diff --git a/Lib/distutils/version.py b/Lib/distutils/version.py
deleted file mode 100644
index af14cc1348..0000000000
--- a/Lib/distutils/version.py
+++ /dev/null
@@ -1,343 +0,0 @@
-#
-# distutils/version.py
-#
-# Implements multiple version numbering conventions for the
-# Python Module Distribution Utilities.
-#
-# $Id$
-#
-
-"""Provides classes to represent module version numbers (one class for
-each style of version numbering).  There are currently two such classes
-implemented: StrictVersion and LooseVersion.
-
-Every version number class implements the following interface:
-  * the 'parse' method takes a string and parses it to some internal
-    representation; if the string is an invalid version number,
-    'parse' raises a ValueError exception
-  * the class constructor takes an optional string argument which,
-    if supplied, is passed to 'parse'
-  * __str__ reconstructs the string that was passed to 'parse' (or
-    an equivalent string -- ie. one that will generate an equivalent
-    version number instance)
-  * __repr__ generates Python code to recreate the version number instance
-  * _cmp compares the current instance with either another instance
-    of the same class or a string (which will be parsed to an instance
-    of the same class, thus must follow the same rules)
-"""
-
-import re
-
-class Version:
-    """Abstract base class for version numbering classes.  Just provides
-    constructor (__init__) and reproducer (__repr__), because those
-    seem to be the same for all version numbering classes; and route
-    rich comparisons to _cmp.
-    """
-
-    def __init__ (self, vstring=None):
-        if vstring:
-            self.parse(vstring)
-
-    def __repr__ (self):
-        return "%s ('%s')" % (self.__class__.__name__, str(self))
-
-    def __eq__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c == 0
-
-    def __lt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c < 0
-
-    def __le__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c <= 0
-
-    def __gt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c > 0
-
-    def __ge__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c >= 0
-
-
-# Interface for version-number classes -- must be implemented
-# by the following classes (the concrete ones -- Version should
-# be treated as an abstract class).
-#    __init__ (string) - create and take same action as 'parse'
-#                        (string parameter is optional)
-#    parse (string)    - convert a string representation to whatever
-#                        internal representation is appropriate for
-#                        this style of version numbering
-#    __str__ (self)    - convert back to a string; should be very similar
-#                        (if not identical to) the string supplied to parse
-#    __repr__ (self)   - generate Python code to recreate
-#                        the instance
-#    _cmp (self, other) - compare two version numbers ('other' may
-#                        be an unparsed version string, or another
-#                        instance of your version class)
-
-
-class StrictVersion (Version):
-
-    """Version numbering for anal retentives and software idealists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of two or three
-    dot-separated numeric components, with an optional "pre-release" tag
-    on the end.  The pre-release tag consists of the letter 'a' or 'b'
-    followed by a number.  If the numeric components of two version
-    numbers are equal, then one with a pre-release tag will always
-    be deemed earlier (lesser) than one without.
-
-    The following are valid version numbers (shown in the order that
-    would be obtained by sorting according to the supplied cmp function):
-
-        0.4       0.4.0  (these two are equivalent)
-        0.4.1
-        0.5a1
-        0.5b3
-        0.5
-        0.9.6
-        1.0
-        1.0.4a3
-        1.0.4b1
-        1.0.4
-
-    The following are examples of invalid version numbers:
-
-        1
-        2.7.2.2
-        1.3.a4
-        1.3pl1
-        1.3c4
-
-    The rationale for this version numbering system will be explained
-    in the distutils documentation.
-    """
-
-    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
-                            re.VERBOSE | re.ASCII)
-
-
-    def parse (self, vstring):
-        match = self.version_re.match(vstring)
-        if not match:
-            raise ValueError("invalid version number '%s'" % vstring)
-
-        (major, minor, patch, prerelease, prerelease_num) = \
-            match.group(1, 2, 4, 5, 6)
-
-        if patch:
-            self.version = tuple(map(int, [major, minor, patch]))
-        else:
-            self.version = tuple(map(int, [major, minor])) + (0,)
-
-        if prerelease:
-            self.prerelease = (prerelease[0], int(prerelease_num))
-        else:
-            self.prerelease = None
-
-
-    def __str__ (self):
-
-        if self.version[2] == 0:
-            vstring = '.'.join(map(str, self.version[0:2]))
-        else:
-            vstring = '.'.join(map(str, self.version))
-
-        if self.prerelease:
-            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
-
-        return vstring
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            other = StrictVersion(other)
-
-        if self.version != other.version:
-            # numeric versions don't match
-            # prerelease stuff doesn't matter
-            if self.version < other.version:
-                return -1
-            else:
-                return 1
-
-        # have to compare prerelease
-        # case 1: neither has prerelease; they're equal
-        # case 2: self has prerelease, other doesn't; other is greater
-        # case 3: self doesn't have prerelease, other does: self is greater
-        # case 4: both have prerelease: must compare them!
-
-        if (not self.prerelease and not other.prerelease):
-            return 0
-        elif (self.prerelease and not other.prerelease):
-            return -1
-        elif (not self.prerelease and other.prerelease):
-            return 1
-        elif (self.prerelease and other.prerelease):
-            if self.prerelease == other.prerelease:
-                return 0
-            elif self.prerelease < other.prerelease:
-                return -1
-            else:
-                return 1
-        else:
-            assert False, "never get here"
-
-# end class StrictVersion
-
-
-# The rules according to Greg Stein:
-# 1) a version number has 1 or more numbers separated by a period or by
-#    sequences of letters. If only periods, then these are compared
-#    left-to-right to determine an ordering.
-# 2) sequences of letters are part of the tuple for comparison and are
-#    compared lexicographically
-# 3) recognize the numeric components may have leading zeroes
-#
-# The LooseVersion class below implements these rules: a version number
-# string is split up into a tuple of integer and string components, and
-# comparison is a simple tuple comparison.  This means that version
-# numbers behave in a predictable and obvious way, but a way that might
-# not necessarily be how people *want* version numbers to behave.  There
-# wouldn't be a problem if people could stick to purely numeric version
-# numbers: just split on period and compare the numbers as tuples.
-# However, people insist on putting letters into their version numbers;
-# the most common purpose seems to be:
-#   - indicating a "pre-release" version
-#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
-#   - indicating a post-release patch ('p', 'pl', 'patch')
-# but of course this can't cover all version number schemes, and there's
-# no way to know what a programmer means without asking him.
-#
-# The problem is what to do with letters (and other non-numeric
-# characters) in a version number.  The current implementation does the
-# obvious and predictable thing: keep them as strings and compare
-# lexically within a tuple comparison.  This has the desired effect if
-# an appended letter sequence implies something "post-release":
-# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
-#
-# However, if letters in a version number imply a pre-release version,
-# the "obvious" thing isn't correct.  Eg. you would expect that
-# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
-# implemented here, this just isn't so.
-#
-# Two possible solutions come to mind.  The first is to tie the
-# comparison algorithm to a particular set of semantic rules, as has
-# been done in the StrictVersion class above.  This works great as long
-# as everyone can go along with bondage and discipline.  Hopefully a
-# (large) subset of Python module programmers will agree that the
-# particular flavour of bondage and discipline provided by StrictVersion
-# provides enough benefit to be worth using, and will submit their
-# version numbering scheme to its domination.  The free-thinking
-# anarchists in the lot will never give in, though, and something needs
-# to be done to accommodate them.
-#
-# Perhaps a "moderately strict" version class could be implemented that
-# lets almost anything slide (syntactically), and makes some heuristic
-# assumptions about non-digits in version number strings.  This could
-# sink into special-case-hell, though; if I was as talented and
-# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
-# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
-# just as happy dealing with things like "2g6" and "1.13++".  I don't
-# think I'm smart enough to do it right though.
-#
-# In any case, I've coded the test suite for this module (see
-# ../test/test_version.py) specifically to fail on things like comparing
-# "1.2a2" and "1.2".  That's not because the *code* is doing anything
-# wrong, it's because the simple, obvious design doesn't match my
-# complicated, hairy expectations for real-world version numbers.  It
-# would be a snap to fix the test suite to say, "Yep, LooseVersion does
-# the Right Thing" (ie. the code matches the conception).  But I'd rather
-# have a conception that matches common notions about version numbers.
-
-class LooseVersion (Version):
-
-    """Version numbering for anarchists and software realists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of a series of numbers,
-    separated by either periods or strings of letters.  When comparing
-    version numbers, the numeric components will be compared
-    numerically, and the alphabetic components lexically.  The following
-    are all valid version numbers, in no particular order:
-
-        1.5.1
-        1.5.2b2
-        161
-        3.10a
-        8.02
-        3.4j
-        1996.07.12
-        3.2.pl0
-        3.1.1.6
-        2g6
-        11g
-        0.960923
-        2.2beta29
-        1.13++
-        5.5.kw
-        2.0b1pl0
-
-    In fact, there is no such thing as an invalid version number under
-    this scheme; the rules for comparison are simple and predictable,
-    but may not always give the results you want (for some definition
-    of "want").
-    """
-
-    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
-
-    def __init__ (self, vstring=None):
-        if vstring:
-            self.parse(vstring)
-
-
-    def parse (self, vstring):
-        # I've given up on thinking I can reconstruct the version string
-        # from the parsed tuple -- so I just store the string here for
-        # use by __str__
-        self.vstring = vstring
-        components = [x for x in self.component_re.split(vstring)
-                              if x and x != '.']
-        for i, obj in enumerate(components):
-            try:
-                components[i] = int(obj)
-            except ValueError:
-                pass
-
-        self.version = components
-
-
-    def __str__ (self):
-        return self.vstring
-
-
-    def __repr__ (self):
-        return "LooseVersion ('%s')" % str(self)
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            other = LooseVersion(other)
-
-        if self.version == other.version:
-            return 0
-        if self.version < other.version:
-            return -1
-        if self.version > other.version:
-            return 1
-
-
-# end class LooseVersion
diff --git a/Lib/distutils/versionpredicate.py b/Lib/distutils/versionpredicate.py
deleted file mode 100644
index 062c98f248..0000000000
--- a/Lib/distutils/versionpredicate.py
+++ /dev/null
@@ -1,166 +0,0 @@
-"""Module for parsing and testing package version predicate strings.
-"""
-import re
-import distutils.version
-import operator
-
-
-re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
-    re.ASCII)
-# (package) (rest)
-
-re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
-re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
-# (comp) (version)
-
-
-def splitUp(pred):
-    """Parse a single version comparison.
-
-    Return (comparison string, StrictVersion)
-    """
-    res = re_splitComparison.match(pred)
-    if not res:
-        raise ValueError("bad package restriction syntax: %r" % pred)
-    comp, verStr = res.groups()
-    return (comp, distutils.version.StrictVersion(verStr))
-
-compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
-           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
-
-class VersionPredicate:
-    """Parse and test package version predicates.
-
-    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
-
-    The `name` attribute provides the full dotted name that is given::
-
-    >>> v.name
-    'pyepat.abc'
-
-    The str() of a `VersionPredicate` provides a normalized
-    human-readable version of the expression::
-
-    >>> print(v)
-    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
-
-    The `satisfied_by()` method can be used to determine with a given
-    version number is included in the set described by the version
-    restrictions::
-
-    >>> v.satisfied_by('1.1')
-    True
-    >>> v.satisfied_by('1.4')
-    True
-    >>> v.satisfied_by('1.0')
-    False
-    >>> v.satisfied_by('4444.4')
-    False
-    >>> v.satisfied_by('1555.1b3')
-    False
-
-    `VersionPredicate` is flexible in accepting extra whitespace::
-
-    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
-    >>> v.name
-    'pat'
-    >>> v.satisfied_by('0.1')
-    True
-    >>> v.satisfied_by('0.2')
-    False
-
-    If any version numbers passed in do not conform to the
-    restrictions of `StrictVersion`, a `ValueError` is raised::
-
-    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
-    Traceback (most recent call last):
-      ...
-    ValueError: invalid version number '1.2zb3'
-
-    It the module or package name given does not conform to what's
-    allowed as a legal module or package name, `ValueError` is
-    raised::
-
-    >>> v = VersionPredicate('foo-bar')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: '-bar'
-
-    >>> v = VersionPredicate('foo bar (12.21)')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: 'bar (12.21)'
-
-    """
-
-    def __init__(self, versionPredicateStr):
-        """Parse a version predicate string.
-        """
-        # Fields:
-        #    name:  package name
-        #    pred:  list of (comparison string, StrictVersion)
-
-        versionPredicateStr = versionPredicateStr.strip()
-        if not versionPredicateStr:
-            raise ValueError("empty package restriction")
-        match = re_validPackage.match(versionPredicateStr)
-        if not match:
-            raise ValueError("bad package name in %r" % versionPredicateStr)
-        self.name, paren = match.groups()
-        paren = paren.strip()
-        if paren:
-            match = re_paren.match(paren)
-            if not match:
-                raise ValueError("expected parenthesized list: %r" % paren)
-            str = match.groups()[0]
-            self.pred = [splitUp(aPred) for aPred in str.split(",")]
-            if not self.pred:
-                raise ValueError("empty parenthesized list in %r"
-                                 % versionPredicateStr)
-        else:
-            self.pred = []
-
-    def __str__(self):
-        if self.pred:
-            seq = [cond + " " + str(ver) for cond, ver in self.pred]
-            return self.name + " (" + ", ".join(seq) + ")"
-        else:
-            return self.name
-
-    def satisfied_by(self, version):
-        """True if version is compatible with all the predicates in self.
-        The parameter version must be acceptable to the StrictVersion
-        constructor.  It may be either a string or StrictVersion.
-        """
-        for cond, ver in self.pred:
-            if not compmap[cond](version, ver):
-                return False
-        return True
-
-
-_provision_rx = None
-
-def split_provision(value):
-    """Return the name and optional version number of a provision.
-
-    The version number, if given, will be returned as a `StrictVersion`
-    instance, otherwise it will be `None`.
-
-    >>> split_provision('mypkg')
-    ('mypkg', None)
-    >>> split_provision(' mypkg( 1.2 ) ')
-    ('mypkg', StrictVersion ('1.2'))
-    """
-    global _provision_rx
-    if _provision_rx is None:
-        _provision_rx = re.compile(
-            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
-            re.ASCII)
-    value = value.strip()
-    m = _provision_rx.match(value)
-    if not m:
-        raise ValueError("illegal provides specification: %r" % value)
-    ver = m.group(2) or None
-    if ver:
-        ver = distutils.version.StrictVersion(ver)
-    return m.group(1), ver
diff --git a/Lib/doctest.py b/Lib/doctest.py
index 387f71b184..ecac54ad5a 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -94,6 +94,7 @@ def _test():
 
 import __future__
 import difflib
+import functools
 import inspect
 import linecache
 import os
@@ -104,8 +105,26 @@ def _test():
 import unittest
 from io import StringIO, IncrementalNewlineDecoder
 from collections import namedtuple
+import _colorize  # Used in doctests
+from _colorize import ANSIColors, can_colorize
+
+
+class TestResults(namedtuple('TestResults', 'failed attempted')):
+    def __new__(cls, failed, attempted, *, skipped=0):
+        results = super().__new__(cls, failed, attempted)
+        results.skipped = skipped
+        return results
+
+    def __repr__(self):
+        if self.skipped:
+            return (f'TestResults(failed={self.failed}, '
+                    f'attempted={self.attempted}, '
+                    f'skipped={self.skipped})')
+        else:
+            # Leave the repr() unchanged for backward compatibility
+            # if skipped is zero
+            return super().__repr__()
 
-TestResults = namedtuple('TestResults', 'failed attempted')
 
 # There are 4 basic classes:
 #  - Example: a <source, want> pair, plus an intra-docstring line number.
@@ -207,7 +226,13 @@ def _normalize_module(module, depth=2):
     elif isinstance(module, str):
         return __import__(module, globals(), locals(), ["*"])
     elif module is None:
-        return sys.modules[sys._getframe(depth).f_globals['__name__']]
+        try:
+            try:
+                return sys.modules[sys._getframemodulename(depth)]
+            except AttributeError:
+                return sys.modules[sys._getframe(depth).f_globals['__name__']]
+        except KeyError:
+            pass
     else:
         raise TypeError("Expected a module, string, or None")
 
@@ -229,7 +254,6 @@ def _load_testfile(filename, package, module_relative, encoding):
             file_contents = file_contents.decode(encoding)
             # get_data() opens files as 'rb', so one must do the equivalent
             # conversion as universal newlines would do.
-
             return _newline_convert(file_contents), filename
     with open(filename, encoding=encoding) as f:
         return f.read(), filename
@@ -570,9 +594,11 @@ def __hash__(self):
     def __lt__(self, other):
         if not isinstance(other, DocTest):
             return NotImplemented
-        return ((self.name, self.filename, self.lineno, id(self))
+        self_lno = self.lineno if self.lineno is not None else -1
+        other_lno = other.lineno if other.lineno is not None else -1
+        return ((self.name, self.filename, self_lno, id(self))
                 <
-                (other.name, other.filename, other.lineno, id(other)))
+                (other.name, other.filename, other_lno, id(other)))
 
 ######################################################################
 ## 3. DocTestParser
@@ -957,7 +983,8 @@ def _from_module(self, module, object):
             return module is inspect.getmodule(object)
         elif inspect.isfunction(object):
             return module.__dict__ is object.__globals__
-        elif inspect.ismethoddescriptor(object):
+        elif (inspect.ismethoddescriptor(object) or
+              inspect.ismethodwrapper(object)):
             if hasattr(object, '__objclass__'):
                 obj_mod = object.__objclass__.__module__
             elif hasattr(object, '__module__'):
@@ -1104,7 +1131,7 @@ def _find_lineno(self, obj, source_lines):
             if source_lines is None:
                 return None
             pat = re.compile(r'^\s*class\s*%s\b' %
-                             getattr(obj, '__name__', '-'))
+                             re.escape(getattr(obj, '__name__', '-')))
             for i, line in enumerate(source_lines):
                 if pat.match(line):
                     lineno = i
@@ -1112,13 +1139,24 @@ def _find_lineno(self, obj, source_lines):
 
         # Find the line number for functions & methods.
         if inspect.ismethod(obj): obj = obj.__func__
-        if inspect.isfunction(obj) and getattr(obj, '__doc__', None):
+        if isinstance(obj, property):
+            obj = obj.fget
+        if isinstance(obj, functools.cached_property):
+            obj = obj.func
+        if inspect.isroutine(obj) and getattr(obj, '__doc__', None):
             # We don't use `docstring` var here, because `obj` can be changed.
-            obj = obj.__code__
+            obj = inspect.unwrap(obj)
+            try:
+                obj = obj.__code__
+            except AttributeError:
+                # Functions implemented in C don't necessarily
+                # have a __code__ attribute.
+                # If there's no code, there's no lineno
+                return None
         if inspect.istraceback(obj): obj = obj.tb_frame
         if inspect.isframe(obj): obj = obj.f_code
         if inspect.iscode(obj):
-            lineno = getattr(obj, 'co_firstlineno', None)-1
+            lineno = obj.co_firstlineno - 1
 
         # Find the line number where the docstring starts.  Assume
         # that it's the first line that begins with a quote mark.
@@ -1144,8 +1182,10 @@ class DocTestRunner:
     """
     A class used to run DocTest test cases, and accumulate statistics.
     The `run` method is used to process a single DocTest case.  It
-    returns a tuple `(f, t)`, where `t` is the number of test cases
-    tried, and `f` is the number of test cases that failed.
+    returns a TestResults instance.
+
+        >>> save_colorize = _colorize.COLORIZE
+        >>> _colorize.COLORIZE = False
 
         >>> tests = DocTestFinder().find(_TestClass)
         >>> runner = DocTestRunner(verbose=False)
@@ -1158,27 +1198,29 @@ class DocTestRunner:
         _TestClass.square -> TestResults(failed=0, attempted=1)
 
     The `summarize` method prints a summary of all the test cases that
-    have been run by the runner, and returns an aggregated `(f, t)`
-    tuple:
+    have been run by the runner, and returns an aggregated TestResults
+    instance:
 
         >>> runner.summarize(verbose=1)
         4 items passed all tests:
            2 tests in _TestClass
            2 tests in _TestClass.__init__
            2 tests in _TestClass.get
-           1 tests in _TestClass.square
+           1 test in _TestClass.square
         7 tests in 4 items.
-        7 passed and 0 failed.
+        7 passed.
         Test passed.
         TestResults(failed=0, attempted=7)
 
-    The aggregated number of tried examples and failed examples is
-    also available via the `tries` and `failures` attributes:
+    The aggregated number of tried examples and failed examples is also
+    available via the `tries`, `failures` and `skips` attributes:
 
         >>> runner.tries
         7
         >>> runner.failures
         0
+        >>> runner.skips
+        0
 
     The comparison between expected outputs and actual outputs is done
     by an `OutputChecker`.  This comparison may be customized with a
@@ -1195,6 +1237,8 @@ class DocTestRunner:
     can be also customized by subclassing DocTestRunner, and
     overriding the methods `report_start`, `report_success`,
     `report_unexpected_exception`, and `report_failure`.
+
+        >>> _colorize.COLORIZE = save_colorize
     """
     # This divider string is used to separate failure messages, and to
     # separate sections of the summary.
@@ -1227,7 +1271,8 @@ def __init__(self, checker=None, verbose=None, optionflags=0):
         # Keep track of the examples we've run.
         self.tries = 0
         self.failures = 0
-        self._name2ft = {}
+        self.skips = 0
+        self._stats = {}
 
         # Create a fake output target for capturing doctest output.
         self._fakeout = _SpoofOut()
@@ -1272,7 +1317,10 @@ def report_unexpected_exception(self, out, test, example, exc_info):
             'Exception raised:\n' + _indent(_exception_traceback(exc_info)))
 
     def _failure_header(self, test, example):
-        out = [self.DIVIDER]
+        red, reset = (
+            (ANSIColors.RED, ANSIColors.RESET) if can_colorize() else ("", "")
+        )
+        out = [f"{red}{self.DIVIDER}{reset}"]
         if test.filename:
             if test.lineno is not None and example.lineno is not None:
                 lineno = test.lineno + example.lineno + 1
@@ -1296,13 +1344,11 @@ def __run(self, test, compileflags, out):
         Run the examples in `test`.  Write the outcome of each example
         with one of the `DocTestRunner.report_*` methods, using the
         writer function `out`.  `compileflags` is the set of compiler
-        flags that should be used to execute examples.  Return a tuple
-        `(f, t)`, where `t` is the number of examples tried, and `f`
-        is the number of examples that failed.  The examples are run
-        in the namespace `test.globs`.
+        flags that should be used to execute examples.  Return a TestResults
+        instance.  The examples are run in the namespace `test.globs`.
         """
-        # Keep track of the number of failures and tries.
-        failures = tries = 0
+        # Keep track of the number of failed, attempted, skipped examples.
+        failures = attempted = skips = 0
 
         # Save the option flags (since option directives can be used
         # to modify them).
@@ -1314,6 +1360,7 @@ def __run(self, test, compileflags, out):
 
         # Process each example.
         for examplenum, example in enumerate(test.examples):
+            attempted += 1
 
             # If REPORT_ONLY_FIRST_FAILURE is set, then suppress
             # reporting after the first failure.
@@ -1331,10 +1378,10 @@ def __run(self, test, compileflags, out):
 
             # If 'SKIP' is set, then skip this example.
             if self.optionflags & SKIP:
+                skips += 1
                 continue
 
             # Record that we started this example.
-            tries += 1
             if not quiet:
                 self.report_start(out, test, example)
 
@@ -1370,7 +1417,24 @@ def __run(self, test, compileflags, out):
 
             # The example raised an exception:  check if it was expected.
             else:
-                exc_msg = traceback.format_exception_only(*exception[:2])[-1]
+                formatted_ex = traceback.format_exception_only(*exception[:2])
+                if issubclass(exception[0], SyntaxError):
+                    # SyntaxError / IndentationError is special:
+                    # we don't care about the carets / suggestions / etc
+                    # We only care about the error message and notes.
+                    # They start with `SyntaxError:` (or any other class name)
+                    exception_line_prefixes = (
+                        f"{exception[0].__qualname__}:",
+                        f"{exception[0].__module__}.{exception[0].__qualname__}:",
+                    )
+                    exc_msg_index = next(
+                        index
+                        for index, line in enumerate(formatted_ex)
+                        if line.startswith(exception_line_prefixes)
+                    )
+                    formatted_ex = formatted_ex[exc_msg_index:]
+
+                exc_msg = "".join(formatted_ex)
                 if not quiet:
                     got += _exception_traceback(exception)
 
@@ -1412,19 +1476,22 @@ def __run(self, test, compileflags, out):
         # Restore the option flags (in case they were modified)
         self.optionflags = original_optionflags
 
-        # Record and return the number of failures and tries.
-        self.__record_outcome(test, failures, tries)
-        return TestResults(failures, tries)
+        # Record and return the number of failures and attempted.
+        self.__record_outcome(test, failures, attempted, skips)
+        return TestResults(failures, attempted, skipped=skips)
 
-    def __record_outcome(self, test, f, t):
+    def __record_outcome(self, test, failures, tries, skips):
         """
-        Record the fact that the given DocTest (`test`) generated `f`
-        failures out of `t` tried examples.
+        Record the fact that the given DocTest (`test`) generated `failures`
+        failures out of `tries` tried examples.
         """
-        f2, t2 = self._name2ft.get(test.name, (0,0))
-        self._name2ft[test.name] = (f+f2, t+t2)
-        self.failures += f
-        self.tries += t
+        failures2, tries2, skips2 = self._stats.get(test.name, (0, 0, 0))
+        self._stats[test.name] = (failures + failures2,
+                                  tries + tries2,
+                                  skips + skips2)
+        self.failures += failures
+        self.tries += tries
+        self.skips += skips
 
     __LINECACHE_FILENAME_RE = re.compile(r'<doctest '
                                          r'(?P<name>.+)'
@@ -1493,7 +1560,11 @@ def out(s):
         # Make sure sys.displayhook just prints the value to stdout
         save_displayhook = sys.displayhook
         sys.displayhook = sys.__displayhook__
-
+        saved_can_colorize = _colorize.can_colorize
+        _colorize.can_colorize = lambda *args, **kwargs: False
+        color_variables = {"PYTHON_COLORS": None, "FORCE_COLOR": None}
+        for key in color_variables:
+            color_variables[key] = os.environ.pop(key, None)
         try:
             return self.__run(test, compileflags, out)
         finally:
@@ -1502,6 +1573,10 @@ def out(s):
             sys.settrace(save_trace)
             linecache.getlines = self.save_linecache_getlines
             sys.displayhook = save_displayhook
+            _colorize.can_colorize = saved_can_colorize
+            for key, value in color_variables.items():
+                if value is not None:
+                    os.environ[key] = value
             if clear_globs:
                 test.globs.clear()
                 import builtins
@@ -1513,9 +1588,7 @@ def out(s):
     def summarize(self, verbose=None):
         """
         Print a summary of all the test cases that have been run by
-        this DocTestRunner, and return a tuple `(f, t)`, where `f` is
-        the total number of failed examples, and `t` is the total
-        number of tried examples.
+        this DocTestRunner, and return a TestResults instance.
 
         The optional `verbose` argument controls how detailed the
         summary is.  If the verbosity is not specified, then the
@@ -1523,66 +1596,98 @@ def summarize(self, verbose=None):
         """
         if verbose is None:
             verbose = self._verbose
-        notests = []
-        passed = []
-        failed = []
-        totalt = totalf = 0
-        for x in self._name2ft.items():
-            name, (f, t) = x
-            assert f <= t
-            totalt += t
-            totalf += f
-            if t == 0:
+
+        notests, passed, failed = [], [], []
+        total_tries = total_failures = total_skips = 0
+
+        for name, (failures, tries, skips) in self._stats.items():
+            assert failures <= tries
+            total_tries += tries
+            total_failures += failures
+            total_skips += skips
+
+            if tries == 0:
                 notests.append(name)
-            elif f == 0:
-                passed.append( (name, t) )
+            elif failures == 0:
+                passed.append((name, tries))
             else:
-                failed.append(x)
+                failed.append((name, (failures, tries, skips)))
+
+        ansi = _colorize.get_colors()
+        bold_green = ansi.BOLD_GREEN
+        bold_red = ansi.BOLD_RED
+        green = ansi.GREEN
+        red = ansi.RED
+        reset = ansi.RESET
+        yellow = ansi.YELLOW
+
         if verbose:
             if notests:
-                print(len(notests), "items had no tests:")
+                print(f"{_n_items(notests)} had no tests:")
                 notests.sort()
-                for thing in notests:
-                    print("   ", thing)
+                for name in notests:
+                    print(f"    {name}")
+
             if passed:
-                print(len(passed), "items passed all tests:")
-                passed.sort()
-                for thing, count in passed:
-                    print(" %3d tests in %s" % (count, thing))
+                print(f"{green}{_n_items(passed)} passed all tests:{reset}")
+                for name, count in sorted(passed):
+                    s = "" if count == 1 else "s"
+                    print(f" {green}{count:3d} test{s} in {name}{reset}")
+
         if failed:
-            print(self.DIVIDER)
-            print(len(failed), "items had failures:")
-            failed.sort()
-            for thing, (f, t) in failed:
-                print(" %3d of %3d in %s" % (f, t, thing))
+            print(f"{red}{self.DIVIDER}{reset}")
+            print(f"{_n_items(failed)} had failures:")
+            for name, (failures, tries, skips) in sorted(failed):
+                print(f" {failures:3d} of {tries:3d} in {name}")
+
         if verbose:
-            print(totalt, "tests in", len(self._name2ft), "items.")
-            print(totalt - totalf, "passed and", totalf, "failed.")
-        if totalf:
-            print("***Test Failed***", totalf, "failures.")
+            s = "" if total_tries == 1 else "s"
+            print(f"{total_tries} test{s} in {_n_items(self._stats)}.")
+
+            and_f = (
+                f" and {red}{total_failures} failed{reset}"
+                if total_failures else ""
+            )
+            print(f"{green}{total_tries - total_failures} passed{reset}{and_f}.")
+
+        if total_failures:
+            s = "" if total_failures == 1 else "s"
+            msg = f"{bold_red}***Test Failed*** {total_failures} failure{s}{reset}"
+            if total_skips:
+                s = "" if total_skips == 1 else "s"
+                msg = f"{msg} and {yellow}{total_skips} skipped test{s}{reset}"
+            print(f"{msg}.")
         elif verbose:
-            print("Test passed.")
-        return TestResults(totalf, totalt)
+            print(f"{bold_green}Test passed.{reset}")
+
+        return TestResults(total_failures, total_tries, skipped=total_skips)
 
     #/////////////////////////////////////////////////////////////////
     # Backward compatibility cruft to maintain doctest.master.
     #/////////////////////////////////////////////////////////////////
     def merge(self, other):
-        d = self._name2ft
-        for name, (f, t) in other._name2ft.items():
+        d = self._stats
+        for name, (failures, tries, skips) in other._stats.items():
             if name in d:
-                # Don't print here by default, since doing
-                #     so breaks some of the buildbots
-                #print("*** DocTestRunner.merge: '" + name + "' in both" \
-                #    " testers; summing outcomes.")
-                f2, t2 = d[name]
-                f = f + f2
-                t = t + t2
-            d[name] = f, t
+                failures2, tries2, skips2 = d[name]
+                failures = failures + failures2
+                tries = tries + tries2
+                skips = skips + skips2
+            d[name] = (failures, tries, skips)
+
+
+def _n_items(items: list | dict) -> str:
+    """
+    Helper to pluralise the number of items in a list.
+    """
+    n = len(items)
+    s = "" if n == 1 else "s"
+    return f"{n} item{s}"
+
 
 class OutputChecker:
     """
-    A class used to check the whether the actual output from a doctest
+    A class used to check whether the actual output from a doctest
     example matches the expected output.  `OutputChecker` defines two
     methods: `check_output`, which compares a given pair of outputs,
     and returns true if they match; and `output_difference`, which
@@ -1887,8 +1992,8 @@ def testmod(m=None, name=None, globs=None, verbose=None,
     from module m (or the current module if m is not supplied), starting
     with m.__doc__.
 
-    Also test examples reachable from dict m.__test__ if it exists and is
-    not None.  m.__test__ maps names to functions, classes and strings;
+    Also test examples reachable from dict m.__test__ if it exists.
+    m.__test__ maps names to functions, classes and strings;
     function and class docstrings are tested even if the name is private;
     strings are tested directly, as if they were docstrings.
 
@@ -1978,7 +2083,8 @@ class doctest.Tester, then merges the results into (or creates)
     else:
         master.merge(runner)
 
-    return TestResults(runner.failures, runner.tries)
+    return TestResults(runner.failures, runner.tries, skipped=runner.skips)
+
 
 def testfile(filename, module_relative=True, name=None, package=None,
              globs=None, verbose=None, report=True, optionflags=0,
@@ -2101,7 +2207,8 @@ class doctest.Tester, then merges the results into (or creates)
     else:
         master.merge(runner)
 
-    return TestResults(runner.failures, runner.tries)
+    return TestResults(runner.failures, runner.tries, skipped=runner.skips)
+
 
 def run_docstring_examples(f, globs, verbose=False, name="NoName",
                            compileflags=None, optionflags=0):
@@ -2176,13 +2283,13 @@ def __init__(self, test, optionflags=0, setUp=None, tearDown=None,
         unittest.TestCase.__init__(self)
         self._dt_optionflags = optionflags
         self._dt_checker = checker
-        self._dt_globs = test.globs.copy()
         self._dt_test = test
         self._dt_setUp = setUp
         self._dt_tearDown = tearDown
 
     def setUp(self):
         test = self._dt_test
+        self._dt_globs = test.globs.copy()
 
         if self._dt_setUp is not None:
             self._dt_setUp(test)
@@ -2213,12 +2320,13 @@ def runTest(self):
 
         try:
             runner.DIVIDER = "-"*70
-            failures, tries = runner.run(
-                test, out=new.write, clear_globs=False)
+            results = runner.run(test, out=new.write, clear_globs=False)
+            if results.skipped == results.attempted:
+                raise unittest.SkipTest("all examples were skipped")
         finally:
             sys.stdout = old
 
-        if failures:
+        if results.failed:
             raise self.failureException(self.format_failure(new.getvalue()))
 
     def format_failure(self, err):
diff --git a/Lib/dummy_threading.py b/Lib/dummy_threading.py
index 1bb7eee338..662f3b89a9 100644
--- a/Lib/dummy_threading.py
+++ b/Lib/dummy_threading.py
@@ -6,6 +6,7 @@
 regardless of whether ``_thread`` was available which is not desired.
 
 """
+
 from sys import modules as sys_modules
 
 import _dummy_thread
@@ -19,35 +20,38 @@
     # Could have checked if ``_thread`` was not in sys.modules and gone
     # a different route, but decided to mirror technique used with
     # ``threading`` below.
-    if '_thread' in sys_modules:
-        held_thread = sys_modules['_thread']
+    if "_thread" in sys_modules:
+        held_thread = sys_modules["_thread"]
         holding_thread = True
     # Must have some module named ``_thread`` that implements its API
     # in order to initially import ``threading``.
-    sys_modules['_thread'] = sys_modules['_dummy_thread']
+    sys_modules["_thread"] = sys_modules["_dummy_thread"]
 
-    if 'threading' in sys_modules:
+    if "threading" in sys_modules:
         # If ``threading`` is already imported, might as well prevent
         # trying to import it more than needed by saving it if it is
         # already imported before deleting it.
-        held_threading = sys_modules['threading']
+        held_threading = sys_modules["threading"]
         holding_threading = True
-        del sys_modules['threading']
+        del sys_modules["threading"]
 
-    if '_threading_local' in sys_modules:
+    if "_threading_local" in sys_modules:
         # If ``_threading_local`` is already imported, might as well prevent
         # trying to import it more than needed by saving it if it is
         # already imported before deleting it.
-        held__threading_local = sys_modules['_threading_local']
+        held__threading_local = sys_modules["_threading_local"]
         holding__threading_local = True
-        del sys_modules['_threading_local']
+        del sys_modules["_threading_local"]
 
     import threading
+
     # Need a copy of the code kept somewhere...
-    sys_modules['_dummy_threading'] = sys_modules['threading']
-    del sys_modules['threading']
-    sys_modules['_dummy__threading_local'] = sys_modules['_threading_local']
-    del sys_modules['_threading_local']
+    sys_modules["_dummy_threading"] = sys_modules["threading"]
+    del sys_modules["threading"]
+    # _threading_local may not be imported if _thread._local is available
+    if "_threading_local" in sys_modules:
+        sys_modules["_dummy__threading_local"] = sys_modules["_threading_local"]
+        del sys_modules["_threading_local"]
     from _dummy_threading import *
     from _dummy_threading import __all__
 
@@ -55,23 +59,23 @@
     # Put back ``threading`` if we overwrote earlier
 
     if holding_threading:
-        sys_modules['threading'] = held_threading
+        sys_modules["threading"] = held_threading
         del held_threading
     del holding_threading
 
     # Put back ``_threading_local`` if we overwrote earlier
 
     if holding__threading_local:
-        sys_modules['_threading_local'] = held__threading_local
+        sys_modules["_threading_local"] = held__threading_local
         del held__threading_local
     del holding__threading_local
 
     # Put back ``thread`` if we overwrote, else del the entry we made
     if holding_thread:
-        sys_modules['_thread'] = held_thread
+        sys_modules["_thread"] = held_thread
         del held_thread
     else:
-        del sys_modules['_thread']
+        del sys_modules["_thread"]
     del holding_thread
 
     del _dummy_thread
diff --git a/Lib/email/_header_value_parser.py b/Lib/email/_header_value_parser.py
index ec2215a5e5..91243378dc 100644
--- a/Lib/email/_header_value_parser.py
+++ b/Lib/email/_header_value_parser.py
@@ -95,8 +95,16 @@
 NLSET = {'\n', '\r'}
 SPECIALSNL = SPECIALS | NLSET
 
+
+def make_quoted_pairs(value):
+    """Escape dquote and backslash for use within a quoted-string."""
+    return str(value).replace('\\', '\\\\').replace('"', '\\"')
+
+
 def quote_string(value):
-    return '"'+str(value).replace('\\', '\\\\').replace('"', r'\"')+'"'
+    escaped = make_quoted_pairs(value)
+    return f'"{escaped}"'
+
 
 # Match a RFC 2047 word, looks like =?utf-8?q?someword?=
 rfc2047_matcher = re.compile(r'''
@@ -1012,6 +1020,8 @@ def _get_ptext_to_endchars(value, endchars):
     a flag that is True iff there were any quoted printables decoded.
 
     """
+    if not value:
+        return '', '', False
     fragment, *remainder = _wsp_splitter(value, 1)
     vchars = []
     escape = False
@@ -1045,7 +1055,7 @@ def get_fws(value):
     fws = WhiteSpaceTerminal(value[:len(value)-len(newvalue)], 'fws')
     return fws, newvalue
 
-def get_encoded_word(value):
+def get_encoded_word(value, terminal_type='vtext'):
     """ encoded-word = "=?" charset "?" encoding "?" encoded-text "?="
 
     """
@@ -1084,7 +1094,7 @@ def get_encoded_word(value):
             ew.append(token)
             continue
         chars, *remainder = _wsp_splitter(text, 1)
-        vtext = ValueTerminal(chars, 'vtext')
+        vtext = ValueTerminal(chars, terminal_type)
         _validate_xtext(vtext)
         ew.append(vtext)
         text = ''.join(remainder)
@@ -1126,7 +1136,7 @@ def get_unstructured(value):
         valid_ew = True
         if value.startswith('=?'):
             try:
-                token, value = get_encoded_word(value)
+                token, value = get_encoded_word(value, 'utext')
             except _InvalidEwError:
                 valid_ew = False
             except errors.HeaderParseError:
@@ -1155,7 +1165,7 @@ def get_unstructured(value):
         # the parser to go in an infinite loop.
         if valid_ew and rfc2047_matcher.search(tok):
             tok, *remainder = value.partition('=?')
-        vtext = ValueTerminal(tok, 'vtext')
+        vtext = ValueTerminal(tok, 'utext')
         _validate_xtext(vtext)
         unstructured.append(vtext)
         value = ''.join(remainder)
@@ -1565,7 +1575,7 @@ def get_dtext(value):
 def _check_for_early_dl_end(value, domain_literal):
     if value:
         return False
-    domain_literal.append(errors.InvalidHeaderDefect(
+    domain_literal.defects.append(errors.InvalidHeaderDefect(
         "end of input inside domain-literal"))
     domain_literal.append(ValueTerminal(']', 'domain-literal-end'))
     return True
@@ -1584,9 +1594,9 @@ def get_domain_literal(value):
         raise errors.HeaderParseError("expected '[' at start of domain-literal "
                 "but found '{}'".format(value))
     value = value[1:]
+    domain_literal.append(ValueTerminal('[', 'domain-literal-start'))
     if _check_for_early_dl_end(value, domain_literal):
         return domain_literal, value
-    domain_literal.append(ValueTerminal('[', 'domain-literal-start'))
     if value[0] in WSP:
         token, value = get_fws(value)
         domain_literal.append(token)
@@ -2805,7 +2815,7 @@ def _refold_parse_tree(parse_tree, *, policy):
             continue
         tstr = str(part)
         if not want_encoding:
-            if part.token_type == 'ptext':
+            if part.token_type in ('ptext', 'vtext'):
                 # Encode if tstr contains special characters.
                 want_encoding = not SPECIALSNL.isdisjoint(tstr)
             else:
@@ -2905,6 +2915,15 @@ def _refold_parse_tree(parse_tree, *, policy):
         if not hasattr(part, 'encode'):
             # It's not a terminal, try folding the subparts.
             newparts = list(part)
+            if part.token_type == 'bare-quoted-string':
+                # To fold a quoted string we need to create a list of terminal
+                # tokens that will render the leading and trailing quotes
+                # and use quoted pairs in the value as appropriate.
+                newparts = (
+                    [ValueTerminal('"', 'ptext')] +
+                    [ValueTerminal(make_quoted_pairs(p), 'ptext')
+                     for p in newparts] +
+                    [ValueTerminal('"', 'ptext')])
             if not part.as_ew_allowed:
                 wrap_as_ew_blocked += 1
                 newparts.append(end_ew_not_allowed)
diff --git a/Lib/email/_parseaddr.py b/Lib/email/_parseaddr.py
index 0f1bf8e425..565af0cf36 100644
--- a/Lib/email/_parseaddr.py
+++ b/Lib/email/_parseaddr.py
@@ -146,8 +146,9 @@ def _parsedate_tz(data):
         return None
     # Check for a yy specified in two-digit format, then convert it to the
     # appropriate four-digit format, according to the POSIX standard. RFC 822
-    # calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822)
-    # mandates a 4-digit yy. For more information, see the documentation for
+    # calls for a two-digit yy, but RFC 2822 (which obsoletes RFC 822) already
+    # mandated a 4-digit yy, and RFC 5322 (which obsoletes RFC 2822) continues
+    # this requirement. For more information, see the documentation for
     # the time module.
     if yy < 100:
         # The year is between 1969 and 1999 (inclusive).
@@ -233,9 +234,11 @@ def __init__(self, field):
         self.CR = '\r\n'
         self.FWS = self.LWS + self.CR
         self.atomends = self.specials + self.LWS + self.CR
-        # Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it
-        # is obsolete syntax.  RFC 2822 requires that we recognize obsolete
-        # syntax, so allow dots in phrases.
+        # Note that RFC 2822 section 4.1 introduced '.' as obs-phrase to handle
+        # existing practice (periods in display names), even though it was not
+        # allowed in RFC 822. RFC 5322 section 4.1 (which obsoletes RFC 2822)
+        # continues this requirement. We must recognize obsolete syntax, so
+        # allow dots in phrases.
         self.phraseends = self.atomends.replace('.', '')
         self.field = field
         self.commentlist = []
diff --git a/Lib/email/_policybase.py b/Lib/email/_policybase.py
index c9f0d74309..0d486c90a9 100644
--- a/Lib/email/_policybase.py
+++ b/Lib/email/_policybase.py
@@ -370,7 +370,7 @@ def _fold(self, name, value, sanitize):
             h = value
         if h is not None:
             # The Header class interprets a value of None for maxlinelen as the
-            # default value of 78, as recommended by RFC 2822.
+            # default value of 78, as recommended by RFC 5322 section 2.1.1.
             maxlinelen = 0
             if self.max_line_length is not None:
                 maxlinelen = self.max_line_length
diff --git a/Lib/email/contentmanager.py b/Lib/email/contentmanager.py
index b4f5830bea..11d1536db2 100644
--- a/Lib/email/contentmanager.py
+++ b/Lib/email/contentmanager.py
@@ -2,6 +2,7 @@
 import email.charset
 import email.message
 import email.errors
+import sys
 from email import quoprimime
 
 class ContentManager:
@@ -142,13 +143,15 @@ def _encode_base64(data, max_line_length):
 
 
 def _encode_text(string, charset, cte, policy):
+    # If max_line_length is 0 or None, there is no limit.
+    maxlen = policy.max_line_length or sys.maxsize
     lines = string.encode(charset).splitlines()
     linesep = policy.linesep.encode('ascii')
     def embedded_body(lines): return linesep.join(lines) + linesep
     def normal_body(lines): return b'\n'.join(lines) + b'\n'
     if cte is None:
         # Use heuristics to decide on the "best" encoding.
-        if max((len(x) for x in lines), default=0) <= policy.max_line_length:
+        if max(map(len, lines), default=0) <= maxlen:
             try:
                 return '7bit', normal_body(lines).decode('ascii')
             except UnicodeDecodeError:
@@ -156,8 +159,7 @@ def normal_body(lines): return b'\n'.join(lines) + b'\n'
             if policy.cte_type == '8bit':
                 return '8bit', normal_body(lines).decode('ascii', 'surrogateescape')
         sniff = embedded_body(lines[:10])
-        sniff_qp = quoprimime.body_encode(sniff.decode('latin-1'),
-                                          policy.max_line_length)
+        sniff_qp = quoprimime.body_encode(sniff.decode('latin-1'), maxlen)
         sniff_base64 = binascii.b2a_base64(sniff)
         # This is a little unfair to qp; it includes lineseps, base64 doesn't.
         if len(sniff_qp) > len(sniff_base64):
@@ -172,9 +174,9 @@ def normal_body(lines): return b'\n'.join(lines) + b'\n'
         data = normal_body(lines).decode('ascii', 'surrogateescape')
     elif cte == 'quoted-printable':
         data = quoprimime.body_encode(normal_body(lines).decode('latin-1'),
-                                      policy.max_line_length)
+                                      maxlen)
     elif cte == 'base64':
-        data = _encode_base64(embedded_body(lines), policy.max_line_length)
+        data = _encode_base64(embedded_body(lines), maxlen)
     else:
         raise ValueError("Unknown content transfer encoding {}".format(cte))
     return cte, data
diff --git a/Lib/email/feedparser.py b/Lib/email/feedparser.py
index 06d6b4a3af..bc773f3803 100644
--- a/Lib/email/feedparser.py
+++ b/Lib/email/feedparser.py
@@ -32,7 +32,7 @@
 NLCRE_bol = re.compile(r'(\r\n|\r|\n)')
 NLCRE_eol = re.compile(r'(\r\n|\r|\n)\Z')
 NLCRE_crack = re.compile(r'(\r\n|\r|\n)')
-# RFC 2822 $3.6.8 Optional fields.  ftext is %d33-57 / %d59-126, Any character
+# RFC 5322 section 3.6.8 Optional fields.  ftext is %d33-57 / %d59-126, Any character
 # except controls, SP, and ":".
 headerRE = re.compile(r'^(From |[\041-\071\073-\176]*:|[\t ])')
 EMPTYSTRING = ''
@@ -294,7 +294,7 @@ def _parsegen(self):
             return
         if self._cur.get_content_maintype() == 'message':
             # The message claims to be a message/* type, then what follows is
-            # another RFC 2822 message.
+            # another RFC 5322 message.
             for retval in self._parsegen():
                 if retval is NeedMoreData:
                     yield NeedMoreData
diff --git a/Lib/email/generator.py b/Lib/email/generator.py
index 47b9df8f4e..ce94f5c56f 100644
--- a/Lib/email/generator.py
+++ b/Lib/email/generator.py
@@ -50,7 +50,7 @@ def __init__(self, outfp, mangle_from_=None, maxheaderlen=None, *,
         expanded to 8 spaces) than maxheaderlen, the header will split as
         defined in the Header class.  Set maxheaderlen to zero to disable
         header wrapping.  The default is 78, as recommended (but not required)
-        by RFC 2822.
+        by RFC 5322 section 2.1.1.
 
         The policy keyword specifies a policy object that controls a number of
         aspects of the generator's operation.  If no policy is specified,
diff --git a/Lib/email/header.py b/Lib/email/header.py
index 984851a7d9..a0aadb97ca 100644
--- a/Lib/email/header.py
+++ b/Lib/email/header.py
@@ -59,16 +59,22 @@
 def decode_header(header):
     """Decode a message header value without converting charset.
 
-    Returns a list of (string, charset) pairs containing each of the decoded
-    parts of the header.  Charset is None for non-encoded parts of the header,
-    otherwise a lower-case string containing the name of the character set
-    specified in the encoded string.
+    For historical reasons, this function may return either:
+
+    1. A list of length 1 containing a pair (str, None).
+    2. A list of (bytes, charset) pairs containing each of the decoded
+       parts of the header.  Charset is None for non-encoded parts of the header,
+       otherwise a lower-case string containing the name of the character set
+       specified in the encoded string.
 
     header may be a string that may or may not contain RFC2047 encoded words,
     or it may be a Header object.
 
     An email.errors.HeaderParseError may be raised when certain decoding error
     occurs (e.g. a base64 decoding exception).
+
+    This function exists for backwards compatibility only. For new code, we
+    recommend using email.headerregistry.HeaderRegistry instead.
     """
     # If it is a Header object, we can just return the encoded chunks.
     if hasattr(header, '_chunks'):
@@ -161,6 +167,9 @@ def make_header(decoded_seq, maxlinelen=None, header_name=None,
     This function takes one of those sequence of pairs and returns a Header
     instance.  Optional maxlinelen, header_name, and continuation_ws are as in
     the Header constructor.
+
+    This function exists for backwards compatibility only, and is not
+    recommended for use in new code.
     """
     h = Header(maxlinelen=maxlinelen, header_name=header_name,
                continuation_ws=continuation_ws)
diff --git a/Lib/email/message.py b/Lib/email/message.py
index 46bb8c2194..80f01d66a3 100644
--- a/Lib/email/message.py
+++ b/Lib/email/message.py
@@ -74,19 +74,25 @@ def _parseparam(s):
     # RDM This might be a Header, so for now stringify it.
     s = ';' + str(s)
     plist = []
-    while s[:1] == ';':
-        s = s[1:]
-        end = s.find(';')
-        while end > 0 and (s.count('"', 0, end) - s.count('\\"', 0, end)) % 2:
-            end = s.find(';', end + 1)
+    start = 0
+    while s.find(';', start) == start:
+        start += 1
+        end = s.find(';', start)
+        ind, diff = start, 0
+        while end > 0:
+            diff += s.count('"', ind, end) - s.count('\\"', ind, end)
+            if diff % 2 == 0:
+                break
+            end, ind = ind, s.find(';', end + 1)
         if end < 0:
             end = len(s)
-        f = s[:end]
-        if '=' in f:
-            i = f.index('=')
-            f = f[:i].strip().lower() + '=' + f[i+1:].strip()
+        i = s.find('=', start, end)
+        if i == -1:
+            f = s[start:end]
+        else:
+            f = s[start:i].rstrip().lower() + '=' + s[i+1:end].lstrip()
         plist.append(f.strip())
-        s = s[end:]
+        start = end
     return plist
 
 
@@ -135,7 +141,7 @@ def _decode_uu(encoded):
 class Message:
     """Basic message object.
 
-    A message object is defined as something that has a bunch of RFC 2822
+    A message object is defined as something that has a bunch of RFC 5322
     headers and a payload.  It may optionally have an envelope header
     (a.k.a. Unix-From or From_ header).  If the message is a container (i.e. a
     multipart or a message/rfc822), then the payload is a list of Message
@@ -286,8 +292,12 @@ def get_payload(self, i=None, decode=False):
         if i is not None and not isinstance(self._payload, list):
             raise TypeError('Expected list, got %s' % type(self._payload))
         payload = self._payload
-        # cte might be a Header, so for now stringify it.
-        cte = str(self.get('content-transfer-encoding', '')).lower()
+        cte = self.get('content-transfer-encoding', '')
+        if hasattr(cte, 'cte'):
+            cte = cte.cte
+        else:
+            # cte might be a Header, so for now stringify it.
+            cte = str(cte).strip().lower()
         # payload may be bytes here.
         if not decode:
             if isinstance(payload, str) and utils._has_surrogates(payload):
@@ -309,6 +319,8 @@ def get_payload(self, i=None, decode=False):
                 # If it does happen, turn the string into bytes in a way
                 # guaranteed not to fail.
                 bpayload = payload.encode('raw-unicode-escape')
+        else:
+            bpayload = payload
         if cte == 'quoted-printable':
             return quopri.decodestring(bpayload)
         elif cte == 'base64':
@@ -560,7 +572,7 @@ def add_header(self, _name, _value, **_params):
 
         msg.add_header('content-disposition', 'attachment', filename='bud.gif')
         msg.add_header('content-disposition', 'attachment',
-                       filename=('utf-8', '', Fußballer.ppt'))
+                       filename=('utf-8', '', 'Fußballer.ppt'))
         msg.add_header('content-disposition', 'attachment',
                        filename='Fußballer.ppt'))
         """
diff --git a/Lib/email/parser.py b/Lib/email/parser.py
index 06d99b17f2..e3003118ce 100644
--- a/Lib/email/parser.py
+++ b/Lib/email/parser.py
@@ -2,7 +2,7 @@
 # Author: Barry Warsaw, Thomas Wouters, Anthony Baxter
 # Contact: email-sig@python.org
 
-"""A parser of RFC 2822 and MIME email messages."""
+"""A parser of RFC 5322 and MIME email messages."""
 
 __all__ = ['Parser', 'HeaderParser', 'BytesParser', 'BytesHeaderParser',
            'FeedParser', 'BytesFeedParser']
@@ -15,14 +15,14 @@
 
 class Parser:
     def __init__(self, _class=None, *, policy=compat32):
-        """Parser of RFC 2822 and MIME email messages.
+        """Parser of RFC 5322 and MIME email messages.
 
         Creates an in-memory object tree representing the email message, which
         can then be manipulated and turned over to a Generator to return the
         textual representation of the message.
 
-        The string must be formatted as a block of RFC 2822 headers and header
-        continuation lines, optionally preceded by a `Unix-from' header.  The
+        The string must be formatted as a block of RFC 5322 headers and header
+        continuation lines, optionally preceded by a 'Unix-from' header.  The
         header block is terminated either by the end of the string or by a
         blank line.
 
@@ -75,14 +75,14 @@ def parsestr(self, text, headersonly=True):
 class BytesParser:
 
     def __init__(self, *args, **kw):
-        """Parser of binary RFC 2822 and MIME email messages.
+        """Parser of binary RFC 5322 and MIME email messages.
 
         Creates an in-memory object tree representing the email message, which
         can then be manipulated and turned over to a Generator to return the
         textual representation of the message.
 
-        The input must be formatted as a block of RFC 2822 headers and header
-        continuation lines, optionally preceded by a `Unix-from' header.  The
+        The input must be formatted as a block of RFC 5322 headers and header
+        continuation lines, optionally preceded by a 'Unix-from' header.  The
         header block is terminated either by the end of the input or by a
         blank line.
 
diff --git a/Lib/email/utils.py b/Lib/email/utils.py
index e42674fa4f..e4d35f06ab 100644
--- a/Lib/email/utils.py
+++ b/Lib/email/utils.py
@@ -417,8 +417,14 @@ def decode_params(params):
         for name, continuations in rfc2231_params.items():
             value = []
             extended = False
-            # Sort by number
-            continuations.sort()
+            # Sort by number, treating None as 0 if there is no 0,
+            # and ignore it if there is already a 0.
+            has_zero = any(x[0] == 0 for x in continuations)
+            if has_zero:
+                continuations = [x for x in continuations if x[0] is not None]
+            else:
+                continuations = [(x[0] or 0, x[1], x[2]) for x in continuations]
+            continuations.sort(key=lambda x: x[0])
             # And now append all values in numerical order, converting
             # %-encodings for the encoded segments.  If any of the
             # continuation names ends in a *, then the entire string, after
diff --git a/Lib/encodings/aliases.py b/Lib/encodings/aliases.py
index d85afd6d5c..6a5ca046b5 100644
--- a/Lib/encodings/aliases.py
+++ b/Lib/encodings/aliases.py
@@ -209,6 +209,7 @@
     'ms932'              : 'cp932',
     'mskanji'            : 'cp932',
     'ms_kanji'           : 'cp932',
+    'windows_31j'        : 'cp932',
 
     # cp949 codec
     '949'                : 'cp949',
diff --git a/Lib/encodings/idna.py b/Lib/encodings/idna.py
index 5396047a7f..0c90b4c9fe 100644
--- a/Lib/encodings/idna.py
+++ b/Lib/encodings/idna.py
@@ -11,7 +11,7 @@
 sace_prefix = "xn--"
 
 # This assumes query strings, so AllowUnassigned is true
-def nameprep(label):
+def nameprep(label):  # type: (str) -> str
     # Map
     newlabel = []
     for c in label:
@@ -25,7 +25,7 @@ def nameprep(label):
     label = unicodedata.normalize("NFKC", label)
 
     # Prohibit
-    for c in label:
+    for i, c in enumerate(label):
         if stringprep.in_table_c12(c) or \
            stringprep.in_table_c22(c) or \
            stringprep.in_table_c3(c) or \
@@ -35,7 +35,7 @@ def nameprep(label):
            stringprep.in_table_c7(c) or \
            stringprep.in_table_c8(c) or \
            stringprep.in_table_c9(c):
-            raise UnicodeError("Invalid character %r" % c)
+            raise UnicodeEncodeError("idna", label, i, i+1, f"Invalid character {c!r}")
 
     # Check bidi
     RandAL = [stringprep.in_table_d1(x) for x in label]
@@ -46,29 +46,38 @@ def nameprep(label):
         # This is table C.8, which was already checked
         # 2) If a string contains any RandALCat character, the string
         # MUST NOT contain any LCat character.
-        if any(stringprep.in_table_d2(x) for x in label):
-            raise UnicodeError("Violation of BIDI requirement 2")
+        for i, x in enumerate(label):
+            if stringprep.in_table_d2(x):
+                raise UnicodeEncodeError("idna", label, i, i+1,
+                                         "Violation of BIDI requirement 2")
         # 3) If a string contains any RandALCat character, a
         # RandALCat character MUST be the first character of the
         # string, and a RandALCat character MUST be the last
         # character of the string.
-        if not RandAL[0] or not RandAL[-1]:
-            raise UnicodeError("Violation of BIDI requirement 3")
+        if not RandAL[0]:
+            raise UnicodeEncodeError("idna", label, 0, 1,
+                                     "Violation of BIDI requirement 3")
+        if not RandAL[-1]:
+            raise UnicodeEncodeError("idna", label, len(label)-1, len(label),
+                                     "Violation of BIDI requirement 3")
 
     return label
 
-def ToASCII(label):
+def ToASCII(label):  # type: (str) -> bytes
     try:
         # Step 1: try ASCII
-        label = label.encode("ascii")
-    except UnicodeError:
+        label_ascii = label.encode("ascii")
+    except UnicodeEncodeError:
         pass
     else:
         # Skip to step 3: UseSTD3ASCIIRules is false, so
         # Skip to step 8.
-        if 0 < len(label) < 64:
-            return label
-        raise UnicodeError("label empty or too long")
+        if 0 < len(label_ascii) < 64:
+            return label_ascii
+        if len(label) == 0:
+            raise UnicodeEncodeError("idna", label, 0, 1, "label empty")
+        else:
+            raise UnicodeEncodeError("idna", label, 0, len(label), "label too long")
 
     # Step 2: nameprep
     label = nameprep(label)
@@ -76,29 +85,34 @@ def ToASCII(label):
     # Step 3: UseSTD3ASCIIRules is false
     # Step 4: try ASCII
     try:
-        label = label.encode("ascii")
-    except UnicodeError:
+        label_ascii = label.encode("ascii")
+    except UnicodeEncodeError:
         pass
     else:
         # Skip to step 8.
         if 0 < len(label) < 64:
-            return label
-        raise UnicodeError("label empty or too long")
+            return label_ascii
+        if len(label) == 0:
+            raise UnicodeEncodeError("idna", label, 0, 1, "label empty")
+        else:
+            raise UnicodeEncodeError("idna", label, 0, len(label), "label too long")
 
     # Step 5: Check ACE prefix
-    if label.startswith(sace_prefix):
-        raise UnicodeError("Label starts with ACE prefix")
+    if label.lower().startswith(sace_prefix):
+        raise UnicodeEncodeError(
+            "idna", label, 0, len(sace_prefix), "Label starts with ACE prefix")
 
     # Step 6: Encode with PUNYCODE
-    label = label.encode("punycode")
+    label_ascii = label.encode("punycode")
 
     # Step 7: Prepend ACE prefix
-    label = ace_prefix + label
+    label_ascii = ace_prefix + label_ascii
 
     # Step 8: Check size
-    if 0 < len(label) < 64:
-        return label
-    raise UnicodeError("label empty or too long")
+    # do not check for empty as we prepend ace_prefix.
+    if len(label_ascii) < 64:
+        return label_ascii
+    raise UnicodeEncodeError("idna", label, 0, len(label), "label too long")
 
 def ToUnicode(label):
     if len(label) > 1024:
@@ -110,7 +124,9 @@ def ToUnicode(label):
         # per https://www.rfc-editor.org/rfc/rfc3454#section-3.1 while still
         # preventing us from wasting time decoding a big thing that'll just
         # hit the actual <= 63 length limit in Step 6.
-        raise UnicodeError("label way too long")
+        if isinstance(label, str):
+            label = label.encode("utf-8", errors="backslashreplace")
+        raise UnicodeDecodeError("idna", label, 0, len(label), "label way too long")
     # Step 1: Check for ASCII
     if isinstance(label, bytes):
         pure_ascii = True
@@ -118,25 +134,32 @@ def ToUnicode(label):
         try:
             label = label.encode("ascii")
             pure_ascii = True
-        except UnicodeError:
+        except UnicodeEncodeError:
             pure_ascii = False
     if not pure_ascii:
+        assert isinstance(label, str)
         # Step 2: Perform nameprep
         label = nameprep(label)
         # It doesn't say this, but apparently, it should be ASCII now
         try:
             label = label.encode("ascii")
-        except UnicodeError:
-            raise UnicodeError("Invalid character in IDN label")
+        except UnicodeEncodeError as exc:
+            raise UnicodeEncodeError("idna", label, exc.start, exc.end,
+                                     "Invalid character in IDN label")
     # Step 3: Check for ACE prefix
-    if not label.startswith(ace_prefix):
+    assert isinstance(label, bytes)
+    if not label.lower().startswith(ace_prefix):
         return str(label, "ascii")
 
     # Step 4: Remove ACE prefix
     label1 = label[len(ace_prefix):]
 
     # Step 5: Decode using PUNYCODE
-    result = label1.decode("punycode")
+    try:
+        result = label1.decode("punycode")
+    except UnicodeDecodeError as exc:
+        offset = len(ace_prefix)
+        raise UnicodeDecodeError("idna", label, offset+exc.start, offset+exc.end, exc.reason)
 
     # Step 6: Apply ToASCII
     label2 = ToASCII(result)
@@ -144,7 +167,8 @@ def ToUnicode(label):
     # Step 7: Compare the result of step 6 with the one of step 3
     # label2 will already be in lower case.
     if str(label, "ascii").lower() != str(label2, "ascii"):
-        raise UnicodeError("IDNA does not round-trip", label, label2)
+        raise UnicodeDecodeError("idna", label, 0, len(label),
+                                 f"IDNA does not round-trip, '{label!r}' != '{label2!r}'")
 
     # Step 8: return the result of step 5
     return result
@@ -156,7 +180,7 @@ def encode(self, input, errors='strict'):
 
         if errors != 'strict':
             # IDNA is quite clear that implementations must be strict
-            raise UnicodeError("unsupported error handling "+errors)
+            raise UnicodeError(f"Unsupported error handling: {errors}")
 
         if not input:
             return b'', 0
@@ -168,11 +192,16 @@ def encode(self, input, errors='strict'):
         else:
             # ASCII name: fast path
             labels = result.split(b'.')
-            for label in labels[:-1]:
-                if not (0 < len(label) < 64):
-                    raise UnicodeError("label empty or too long")
-            if len(labels[-1]) >= 64:
-                raise UnicodeError("label too long")
+            for i, label in enumerate(labels[:-1]):
+                if len(label) == 0:
+                    offset = sum(len(l) for l in labels[:i]) + i
+                    raise UnicodeEncodeError("idna", input, offset, offset+1,
+                                             "label empty")
+            for i, label in enumerate(labels):
+                if len(label) >= 64:
+                    offset = sum(len(l) for l in labels[:i]) + i
+                    raise UnicodeEncodeError("idna", input, offset, offset+len(label),
+                                             "label too long")
             return result, len(input)
 
         result = bytearray()
@@ -182,17 +211,27 @@ def encode(self, input, errors='strict'):
             del labels[-1]
         else:
             trailing_dot = b''
-        for label in labels:
+        for i, label in enumerate(labels):
             if result:
                 # Join with U+002E
                 result.extend(b'.')
-            result.extend(ToASCII(label))
+            try:
+                result.extend(ToASCII(label))
+            except (UnicodeEncodeError, UnicodeDecodeError) as exc:
+                offset = sum(len(l) for l in labels[:i]) + i
+                raise UnicodeEncodeError(
+                    "idna",
+                    input,
+                    offset + exc.start,
+                    offset + exc.end,
+                    exc.reason,
+                )
         return bytes(result+trailing_dot), len(input)
 
     def decode(self, input, errors='strict'):
 
         if errors != 'strict':
-            raise UnicodeError("Unsupported error handling "+errors)
+            raise UnicodeError(f"Unsupported error handling: {errors}")
 
         if not input:
             return "", 0
@@ -202,7 +241,7 @@ def decode(self, input, errors='strict'):
             # XXX obviously wrong, see #3232
             input = bytes(input)
 
-        if ace_prefix not in input:
+        if ace_prefix not in input.lower():
             # Fast path
             try:
                 return input.decode('ascii'), len(input)
@@ -218,8 +257,15 @@ def decode(self, input, errors='strict'):
             trailing_dot = ''
 
         result = []
-        for label in labels:
-            result.append(ToUnicode(label))
+        for i, label in enumerate(labels):
+            try:
+                u_label = ToUnicode(label)
+            except (UnicodeEncodeError, UnicodeDecodeError) as exc:
+                offset = sum(len(x) for x in labels[:i]) + len(labels[:i])
+                raise UnicodeDecodeError(
+                    "idna", input, offset+exc.start, offset+exc.end, exc.reason)
+            else:
+                result.append(u_label)
 
         return ".".join(result)+trailing_dot, len(input)
 
@@ -227,7 +273,7 @@ class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
     def _buffer_encode(self, input, errors, final):
         if errors != 'strict':
             # IDNA is quite clear that implementations must be strict
-            raise UnicodeError("unsupported error handling "+errors)
+            raise UnicodeError(f"Unsupported error handling: {errors}")
 
         if not input:
             return (b'', 0)
@@ -251,7 +297,16 @@ def _buffer_encode(self, input, errors, final):
                 # Join with U+002E
                 result.extend(b'.')
                 size += 1
-            result.extend(ToASCII(label))
+            try:
+                result.extend(ToASCII(label))
+            except (UnicodeEncodeError, UnicodeDecodeError) as exc:
+                raise UnicodeEncodeError(
+                    "idna",
+                    input,
+                    size + exc.start,
+                    size + exc.end,
+                    exc.reason,
+                )
             size += len(label)
 
         result += trailing_dot
@@ -261,7 +316,7 @@ def _buffer_encode(self, input, errors, final):
 class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
     def _buffer_decode(self, input, errors, final):
         if errors != 'strict':
-            raise UnicodeError("Unsupported error handling "+errors)
+            raise UnicodeError(f"Unsupported error handling: {errors}")
 
         if not input:
             return ("", 0)
@@ -271,7 +326,11 @@ def _buffer_decode(self, input, errors, final):
             labels = dots.split(input)
         else:
             # Must be ASCII string
-            input = str(input, "ascii")
+            try:
+                input = str(input, "ascii")
+            except (UnicodeEncodeError, UnicodeDecodeError) as exc:
+                raise UnicodeDecodeError("idna", input,
+                                         exc.start, exc.end, exc.reason)
             labels = input.split(".")
 
         trailing_dot = ''
@@ -288,7 +347,18 @@ def _buffer_decode(self, input, errors, final):
         result = []
         size = 0
         for label in labels:
-            result.append(ToUnicode(label))
+            try:
+                u_label = ToUnicode(label)
+            except (UnicodeEncodeError, UnicodeDecodeError) as exc:
+                raise UnicodeDecodeError(
+                    "idna",
+                    input.encode("ascii", errors="backslashreplace"),
+                    size + exc.start,
+                    size + exc.end,
+                    exc.reason,
+                )
+            else:
+                result.append(u_label)
             if size:
                 size += 1
             size += len(label)
diff --git a/Lib/encodings/palmos.py b/Lib/encodings/palmos.py
index c506d65452..df164ca5b9 100644
--- a/Lib/encodings/palmos.py
+++ b/Lib/encodings/palmos.py
@@ -201,7 +201,7 @@ def getregentry():
     '\u02dc'   #  0x98 -> SMALL TILDE
     '\u2122'   #  0x99 -> TRADE MARK SIGN
     '\u0161'   #  0x9A -> LATIN SMALL LETTER S WITH CARON
-    '\x9b'     #  0x9B -> <control>
+    '\u203a'   #  0x9B -> SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
     '\u0153'   #  0x9C -> LATIN SMALL LIGATURE OE
     '\x9d'     #  0x9D -> <control>
     '\x9e'     #  0x9E -> <control>
diff --git a/Lib/encodings/punycode.py b/Lib/encodings/punycode.py
index 1c57264470..4622fc8c92 100644
--- a/Lib/encodings/punycode.py
+++ b/Lib/encodings/punycode.py
@@ -1,4 +1,4 @@
-""" Codec for the Punicode encoding, as specified in RFC 3492
+""" Codec for the Punycode encoding, as specified in RFC 3492
 
 Written by Martin v. Löwis.
 """
@@ -131,10 +131,11 @@ def decode_generalized_number(extended, extpos, bias, errors):
     j = 0
     while 1:
         try:
-            char = ord(extended[extpos])
+            char = extended[extpos]
         except IndexError:
             if errors == "strict":
-                raise UnicodeError("incomplete punicode string")
+                raise UnicodeDecodeError("punycode", extended, extpos, extpos+1,
+                                         "incomplete punycode string")
             return extpos + 1, None
         extpos += 1
         if 0x41 <= char <= 0x5A: # A-Z
@@ -142,8 +143,8 @@ def decode_generalized_number(extended, extpos, bias, errors):
         elif 0x30 <= char <= 0x39:
             digit = char - 22 # 0x30-26
         elif errors == "strict":
-            raise UnicodeError("Invalid extended code point '%s'"
-                               % extended[extpos-1])
+            raise UnicodeDecodeError("punycode", extended, extpos-1, extpos,
+                                     f"Invalid extended code point '{extended[extpos-1]}'")
         else:
             return extpos, None
         t = T(j, bias)
@@ -155,11 +156,14 @@ def decode_generalized_number(extended, extpos, bias, errors):
 
 
 def insertion_sort(base, extended, errors):
-    """3.2 Insertion unsort coding"""
+    """3.2 Insertion sort coding"""
+    # This function raises UnicodeDecodeError with position in the extended.
+    # Caller should add the offset.
     char = 0x80
     pos = -1
     bias = 72
     extpos = 0
+
     while extpos < len(extended):
         newpos, delta = decode_generalized_number(extended, extpos,
                                                   bias, errors)
@@ -171,7 +175,9 @@ def insertion_sort(base, extended, errors):
         char += pos // (len(base) + 1)
         if char > 0x10FFFF:
             if errors == "strict":
-                raise UnicodeError("Invalid character U+%x" % char)
+                raise UnicodeDecodeError(
+                    "punycode", extended, pos-1, pos,
+                    f"Invalid character U+{char:x}")
             char = ord('?')
         pos = pos % (len(base) + 1)
         base = base[:pos] + chr(char) + base[pos:]
@@ -187,11 +193,21 @@ def punycode_decode(text, errors):
     pos = text.rfind(b"-")
     if pos == -1:
         base = ""
-        extended = str(text, "ascii").upper()
+        extended = text.upper()
     else:
-        base = str(text[:pos], "ascii", errors)
-        extended = str(text[pos+1:], "ascii").upper()
-    return insertion_sort(base, extended, errors)
+        try:
+            base = str(text[:pos], "ascii", errors)
+        except UnicodeDecodeError as exc:
+            raise UnicodeDecodeError("ascii", text, exc.start, exc.end,
+                                     exc.reason) from None
+        extended = text[pos+1:].upper()
+    try:
+        return insertion_sort(base, extended, errors)
+    except UnicodeDecodeError as exc:
+        offset = pos + 1
+        raise UnicodeDecodeError("punycode", text,
+                                 offset+exc.start, offset+exc.end,
+                                 exc.reason) from None
 
 ### Codec APIs
 
@@ -203,7 +219,7 @@ def encode(self, input, errors='strict'):
 
     def decode(self, input, errors='strict'):
         if errors not in ('strict', 'replace', 'ignore'):
-            raise UnicodeError("Unsupported error handling "+errors)
+            raise UnicodeError(f"Unsupported error handling: {errors}")
         res = punycode_decode(input, errors)
         return res, len(input)
 
@@ -214,7 +230,7 @@ def encode(self, input, final=False):
 class IncrementalDecoder(codecs.IncrementalDecoder):
     def decode(self, input, final=False):
         if self.errors not in ('strict', 'replace', 'ignore'):
-            raise UnicodeError("Unsupported error handling "+self.errors)
+            raise UnicodeError(f"Unsupported error handling: {self.errors}")
         return punycode_decode(input, self.errors)
 
 class StreamWriter(Codec,codecs.StreamWriter):
diff --git a/Lib/encodings/undefined.py b/Lib/encodings/undefined.py
index 4690288355..082771e1c8 100644
--- a/Lib/encodings/undefined.py
+++ b/Lib/encodings/undefined.py
@@ -1,6 +1,6 @@
 """ Python 'undefined' Codec
 
-    This codec will always raise a ValueError exception when being
+    This codec will always raise a UnicodeError exception when being
     used. It is intended for use by the site.py file to switch off
     automatic string to Unicode coercion.
 
diff --git a/Lib/encodings/utf_16.py b/Lib/encodings/utf_16.py
index c61248242b..d3b9980026 100644
--- a/Lib/encodings/utf_16.py
+++ b/Lib/encodings/utf_16.py
@@ -64,7 +64,7 @@ def _buffer_decode(self, input, errors, final):
             elif byteorder == 1:
                 self.decoder = codecs.utf_16_be_decode
             elif consumed >= 2:
-                raise UnicodeError("UTF-16 stream does not start with BOM")
+                raise UnicodeDecodeError("utf-16", input, 0, 2, "Stream does not start with BOM")
             return (output, consumed)
         return self.decoder(input, self.errors, final)
 
@@ -138,7 +138,7 @@ def decode(self, input, errors='strict'):
         elif byteorder == 1:
             self.decode = codecs.utf_16_be_decode
         elif consumed>=2:
-            raise UnicodeError("UTF-16 stream does not start with BOM")
+            raise UnicodeDecodeError("utf-16", input, 0, 2, "Stream does not start with BOM")
         return (object, consumed)
 
 ### encodings module API
diff --git a/Lib/encodings/utf_32.py b/Lib/encodings/utf_32.py
index cdf84d1412..1924bedbb7 100644
--- a/Lib/encodings/utf_32.py
+++ b/Lib/encodings/utf_32.py
@@ -59,7 +59,7 @@ def _buffer_decode(self, input, errors, final):
             elif byteorder == 1:
                 self.decoder = codecs.utf_32_be_decode
             elif consumed >= 4:
-                raise UnicodeError("UTF-32 stream does not start with BOM")
+                raise UnicodeDecodeError("utf-32", input, 0, 4, "Stream does not start with BOM")
             return (output, consumed)
         return self.decoder(input, self.errors, final)
 
@@ -132,8 +132,8 @@ def decode(self, input, errors='strict'):
             self.decode = codecs.utf_32_le_decode
         elif byteorder == 1:
             self.decode = codecs.utf_32_be_decode
-        elif consumed>=4:
-            raise UnicodeError("UTF-32 stream does not start with BOM")
+        elif consumed >= 4:
+            raise UnicodeDecodeError("utf-32", input, 0, 4, "Stream does not start with BOM")
         return (object, consumed)
 
 ### encodings module API
diff --git a/Lib/ensurepip/__init__.py b/Lib/ensurepip/__init__.py
index 1fb1d505cf..ab6d32478e 100644
--- a/Lib/ensurepip/__init__.py
+++ b/Lib/ensurepip/__init__.py
@@ -1,78 +1,64 @@
-import collections
 import os
-import os.path
 import subprocess
 import sys
 import sysconfig
 import tempfile
+from contextlib import nullcontext
 from importlib import resources
+from pathlib import Path
+from shutil import copy2
 
 
 __all__ = ["version", "bootstrap"]
-_PACKAGE_NAMES = ('pip',)
-_PIP_VERSION = "23.2.1"
-_PROJECTS = [
-    ("pip", _PIP_VERSION, "py3"),
-]
-
-# Packages bundled in ensurepip._bundled have wheel_name set.
-# Packages from WHEEL_PKG_DIR have wheel_path set.
-_Package = collections.namedtuple('Package',
-                                  ('version', 'wheel_name', 'wheel_path'))
+_PIP_VERSION = "25.2"
 
 # Directory of system wheel packages. Some Linux distribution packaging
 # policies recommend against bundling dependencies. For example, Fedora
 # installs wheel packages in the /usr/share/python-wheels/ directory and don't
 # install the ensurepip._bundled package.
-_WHEEL_PKG_DIR = sysconfig.get_config_var('WHEEL_PKG_DIR')
+if (_pkg_dir := sysconfig.get_config_var('WHEEL_PKG_DIR')) is not None:
+    _WHEEL_PKG_DIR = Path(_pkg_dir).resolve()
+else:
+    _WHEEL_PKG_DIR = None
+
 
+def _find_wheel_pkg_dir_pip():
+    if _WHEEL_PKG_DIR is None:
+        # NOTE: The compile-time `WHEEL_PKG_DIR` is unset so there is no place
+        # NOTE: for looking up the wheels.
+        return None
 
-def _find_packages(path):
-    packages = {}
+    dist_matching_wheels = _WHEEL_PKG_DIR.glob('pip-*.whl')
     try:
-        filenames = os.listdir(path)
-    except OSError:
-        # Ignore: path doesn't exist or permission error
-        filenames = ()
-    # Make the code deterministic if a directory contains multiple wheel files
-    # of the same package, but don't attempt to implement correct version
-    # comparison since this case should not happen.
-    filenames = sorted(filenames)
-    for filename in filenames:
-        # filename is like 'pip-21.2.4-py3-none-any.whl'
-        if not filename.endswith(".whl"):
-            continue
-        for name in _PACKAGE_NAMES:
-            prefix = name + '-'
-            if filename.startswith(prefix):
-                break
-        else:
-            continue
-
-        # Extract '21.2.4' from 'pip-21.2.4-py3-none-any.whl'
-        version = filename.removeprefix(prefix).partition('-')[0]
-        wheel_path = os.path.join(path, filename)
-        packages[name] = _Package(version, None, wheel_path)
-    return packages
-
-
-def _get_packages():
-    global _PACKAGES, _WHEEL_PKG_DIR
-    if _PACKAGES is not None:
-        return _PACKAGES
-
-    packages = {}
-    for name, version, py_tag in _PROJECTS:
-        wheel_name = f"{name}-{version}-{py_tag}-none-any.whl"
-        packages[name] = _Package(version, wheel_name, None)
-    if _WHEEL_PKG_DIR:
-        dir_packages = _find_packages(_WHEEL_PKG_DIR)
-        # only used the wheel package directory if all packages are found there
-        if all(name in dir_packages for name in _PACKAGE_NAMES):
-            packages = dir_packages
-    _PACKAGES = packages
-    return packages
-_PACKAGES = None
+        last_matching_dist_wheel = sorted(dist_matching_wheels)[-1]
+    except IndexError:
+        # NOTE: `WHEEL_PKG_DIR` does not contain any wheel files for `pip`.
+        return None
+
+    return nullcontext(last_matching_dist_wheel)
+
+
+def _get_pip_whl_path_ctx():
+    # Prefer pip from the wheel package directory, if present.
+    if (alternative_pip_wheel_path := _find_wheel_pkg_dir_pip()) is not None:
+        return alternative_pip_wheel_path
+
+    return resources.as_file(
+        resources.files('ensurepip')
+        / '_bundled'
+        / f'pip-{_PIP_VERSION}-py3-none-any.whl'
+    )
+
+
+def _get_pip_version():
+    with _get_pip_whl_path_ctx() as bundled_wheel_path:
+        wheel_name = bundled_wheel_path.name
+        return (
+            # Extract '21.2.4' from 'pip-21.2.4-py3-none-any.whl'
+            wheel_name.
+            removeprefix('pip-').
+            partition('-')[0]
+        )
 
 
 def _run_pip(args, additional_paths=None):
@@ -105,7 +91,7 @@ def version():
     """
     Returns a string specifying the bundled version of pip.
     """
-    return _get_packages()['pip'].version
+    return _get_pip_version()
 
 
 def _disable_pip_configuration_settings():
@@ -167,24 +153,10 @@ def _bootstrap(*, root=None, upgrade=False, user=False,
     with tempfile.TemporaryDirectory() as tmpdir:
         # Put our bundled wheels into a temporary directory and construct the
         # additional paths that need added to sys.path
-        additional_paths = []
-        for name, package in _get_packages().items():
-            if package.wheel_name:
-                # Use bundled wheel package
-                wheel_name = package.wheel_name
-                wheel_path = resources.files("ensurepip") / "_bundled" / wheel_name
-                whl = wheel_path.read_bytes()
-            else:
-                # Use the wheel package directory
-                with open(package.wheel_path, "rb") as fp:
-                    whl = fp.read()
-                wheel_name = os.path.basename(package.wheel_path)
-
-            filename = os.path.join(tmpdir, wheel_name)
-            with open(filename, "wb") as fp:
-                fp.write(whl)
-
-            additional_paths.append(filename)
+        tmpdir_path = Path(tmpdir)
+        with _get_pip_whl_path_ctx() as bundled_wheel_path:
+            tmp_wheel_path = tmpdir_path / bundled_wheel_path.name
+            copy2(bundled_wheel_path, tmp_wheel_path)
 
         # Construct the arguments to be passed to the pip command
         args = ["install", "--no-cache-dir", "--no-index", "--find-links", tmpdir]
@@ -197,7 +169,8 @@ def _bootstrap(*, root=None, upgrade=False, user=False,
         if verbosity:
             args += ["-" + "v" * verbosity]
 
-        return _run_pip([*args, *_PACKAGE_NAMES], additional_paths)
+        return _run_pip([*args, "pip"], [os.fsdecode(tmp_wheel_path)])
+
 
 def _uninstall_helper(*, verbosity=0):
     """Helper to support a clean default uninstall process on Windows
@@ -227,7 +200,7 @@ def _uninstall_helper(*, verbosity=0):
     if verbosity:
         args += ["-" + "v" * verbosity]
 
-    return _run_pip([*args, *reversed(_PACKAGE_NAMES)])
+    return _run_pip([*args, "pip"])
 
 
 def _main(argv=None):
diff --git a/Lib/ensurepip/_bundled/pip-23.2.1-py3-none-any.whl b/Lib/ensurepip/_bundled/pip-23.2.1-py3-none-any.whl
deleted file mode 100644
index ba28ef02e2..0000000000
Binary files a/Lib/ensurepip/_bundled/pip-23.2.1-py3-none-any.whl and /dev/null differ
diff --git a/Lib/ensurepip/_bundled/pip-25.2-py3-none-any.whl b/Lib/ensurepip/_bundled/pip-25.2-py3-none-any.whl
new file mode 100644
index 0000000000..4db7e72071
Binary files /dev/null and b/Lib/ensurepip/_bundled/pip-25.2-py3-none-any.whl differ
diff --git a/Lib/enum.py b/Lib/enum.py
index 7cffb71863..3adb208c7e 100644
--- a/Lib/enum.py
+++ b/Lib/enum.py
@@ -1,12 +1,11 @@
 import sys
 import builtins as bltns
+from functools import partial
 from types import MappingProxyType, DynamicClassAttribute
-from operator import or_ as _or_
-from functools import reduce
 
 
 __all__ = [
-        'EnumType', 'EnumMeta',
+        'EnumType', 'EnumMeta', 'EnumDict',
         'Enum', 'IntEnum', 'StrEnum', 'Flag', 'IntFlag', 'ReprEnum',
         'auto', 'unique', 'property', 'verify', 'member', 'nonmember',
         'FlagBoundary', 'STRICT', 'CONFORM', 'EJECT', 'KEEP',
@@ -39,7 +38,7 @@ def _is_descriptor(obj):
     """
     Returns True if obj is a descriptor, False otherwise.
     """
-    return (
+    return not isinstance(obj, partial) and (
             hasattr(obj, '__get__') or
             hasattr(obj, '__set__') or
             hasattr(obj, '__delete__')
@@ -63,8 +62,8 @@ def _is_sunder(name):
     return (
             len(name) > 2 and
             name[0] == name[-1] == '_' and
-            name[1:2] != '_' and
-            name[-2:-1] != '_'
+            name[1] != '_' and
+            name[-2] != '_'
             )
 
 def _is_internal_class(cls_name, obj):
@@ -83,7 +82,6 @@ def _is_private(cls_name, name):
     if (
             len(name) > pat_len
             and name.startswith(pattern)
-            and name[pat_len:pat_len+1] != ['_']
             and (name[-1] != '_' or name[-2] != '_')
         ):
         return True
@@ -158,7 +156,6 @@ def _dedent(text):
     Like textwrap.dedent.  Rewritten because we cannot import textwrap.
     """
     lines = text.split('\n')
-    blanks = 0
     for i, ch in enumerate(lines[0]):
         if ch != ' ':
             break
@@ -166,6 +163,11 @@ def _dedent(text):
         lines[j] = l[i:]
     return '\n'.join(lines)
 
+class _not_given:
+    def __repr__(self):
+        return('<not given>')
+_not_given = _not_given()
+
 class _auto_null:
     def __repr__(self):
         return '_auto_null'
@@ -283,9 +285,10 @@ def __set_name__(self, enum_class, member_name):
         enum_member._sort_order_ = len(enum_class._member_names_)
 
         if Flag is not None and issubclass(enum_class, Flag):
-            enum_class._flag_mask_ |= value
-            if _is_single_bit(value):
-                enum_class._singles_mask_ |= value
+            if isinstance(value, int):
+                enum_class._flag_mask_ |= value
+                if _is_single_bit(value):
+                    enum_class._singles_mask_ |= value
             enum_class._all_bits_ = 2 ** ((enum_class._flag_mask_).bit_length()) - 1
 
         # If another member with the same value was already defined, the
@@ -313,72 +316,40 @@ def __set_name__(self, enum_class, member_name):
             elif (
                     Flag is not None
                     and issubclass(enum_class, Flag)
+                    and isinstance(value, int)
                     and _is_single_bit(value)
                 ):
                 # no other instances found, record this member in _member_names_
                 enum_class._member_names_.append(member_name)
-        # if necessary, get redirect in place and then add it to _member_map_
-        found_descriptor = None
-        descriptor_type = None
-        class_type = None
-        for base in enum_class.__mro__[1:]:
-            attr = base.__dict__.get(member_name)
-            if attr is not None:
-                if isinstance(attr, (property, DynamicClassAttribute)):
-                    found_descriptor = attr
-                    class_type = base
-                    descriptor_type = 'enum'
-                    break
-                elif _is_descriptor(attr):
-                    found_descriptor = attr
-                    descriptor_type = descriptor_type or 'desc'
-                    class_type = class_type or base
-                    continue
-                else:
-                    descriptor_type = 'attr'
-                    class_type = base
-        if found_descriptor:
-            redirect = property()
-            redirect.member = enum_member
-            redirect.__set_name__(enum_class, member_name)
-            if descriptor_type in ('enum','desc'):
-                # earlier descriptor found; copy fget, fset, fdel to this one.
-                redirect.fget = getattr(found_descriptor, 'fget', None)
-                redirect._get = getattr(found_descriptor, '__get__', None)
-                redirect.fset = getattr(found_descriptor, 'fset', None)
-                redirect._set = getattr(found_descriptor, '__set__', None)
-                redirect.fdel = getattr(found_descriptor, 'fdel', None)
-                redirect._del = getattr(found_descriptor, '__delete__', None)
-            redirect._attr_type = descriptor_type
-            redirect._cls_type = class_type
-            setattr(enum_class, member_name, redirect)
-        else:
-            setattr(enum_class, member_name, enum_member)
-        # now add to _member_map_ (even aliases)
-        enum_class._member_map_[member_name] = enum_member
+
+        enum_class._add_member_(member_name, enum_member)
         try:
             # This may fail if value is not hashable. We can't add the value
             # to the map, and by-value lookups for this value will be
             # linear.
             enum_class._value2member_map_.setdefault(value, enum_member)
+            if value not in enum_class._hashable_values_:
+                enum_class._hashable_values_.append(value)
         except TypeError:
             # keep track of the value in a list so containment checks are quick
             enum_class._unhashable_values_.append(value)
+            enum_class._unhashable_values_map_.setdefault(member_name, []).append(value)
 
 
-class _EnumDict(dict):
+class EnumDict(dict):
     """
     Track enum member order and ensure member names are not reused.
 
     EnumType will use the names found in self._member_names as the
     enumeration member names.
     """
-    def __init__(self):
+    def __init__(self, cls_name=None):
         super().__init__()
-        self._member_names = {} # use a dict to keep insertion order
+        self._member_names = {} # use a dict -- faster look-up than a list, and keeps insertion order since 3.7
         self._last_values = []
         self._ignore = []
         self._auto_called = False
+        self._cls_name = cls_name
 
     def __setitem__(self, key, value):
         """
@@ -389,23 +360,19 @@ def __setitem__(self, key, value):
 
         Single underscore (sunder) names are reserved.
         """
-        if _is_internal_class(self._cls_name, value):
-            import warnings
-            warnings.warn(
-                    "In 3.13 classes created inside an enum will not become a member.  "
-                    "Use the `member` decorator to keep the current behavior.",
-                    DeprecationWarning,
-                    stacklevel=2,
-                    )
-        if _is_private(self._cls_name, key):
-            # also do nothing, name will be a normal attribute
+        if self._cls_name is not None and _is_private(self._cls_name, key):
+            # do nothing, name will be a normal attribute
             pass
         elif _is_sunder(key):
             if key not in (
                     '_order_',
                     '_generate_next_value_', '_numeric_repr_', '_missing_', '_ignore_',
                     '_iter_member_', '_iter_member_by_value_', '_iter_member_by_def_',
-                    ):
+                    '_add_alias_', '_add_value_alias_',
+                    # While not in use internally, those are common for pretty
+                    # printing and thus excluded from Enum's reservation of
+                    # _sunder_ names
+                    ) and not key.startswith('_repr_'):
                 raise ValueError(
                         '_sunder_ names, such as %r, are reserved for future Enum use'
                         % (key, )
@@ -439,12 +406,17 @@ def __setitem__(self, key, value):
         elif isinstance(value, nonmember):
             # unwrap value here; it won't be processed by the below `else`
             value = value.value
+        elif isinstance(value, partial):
+            import warnings
+            warnings.warn('functools.partial will be a method descriptor '
+                          'in future Python versions; wrap it in '
+                          'enum.member() if you want to preserve the '
+                          'old behavior', FutureWarning, stacklevel=2)
         elif _is_descriptor(value):
             pass
-        # TODO: uncomment next three lines in 3.13
-        # elif _is_internal_class(self._cls_name, value):
-        #     # do nothing, name will be a normal attribute
-        #     pass
+        elif self._cls_name is not None and _is_internal_class(self._cls_name, value):
+            # do nothing, name will be a normal attribute
+            pass
         else:
             if key in self:
                 # enum overwriting a descriptor?
@@ -457,10 +429,11 @@ def __setitem__(self, key, value):
             if isinstance(value, auto):
                 single = True
                 value = (value, )
-            if type(value) is tuple and any(isinstance(v, auto) for v in value):
+            if isinstance(value, tuple) and any(isinstance(v, auto) for v in value):
                 # insist on an actual tuple, no subclasses, in keeping with only supporting
                 # top-level auto() usage (not contained in any other data structure)
                 auto_valued = []
+                t = type(value)
                 for v in value:
                     if isinstance(v, auto):
                         non_auto_store = False
@@ -475,12 +448,21 @@ def __setitem__(self, key, value):
                 if single:
                     value = auto_valued[0]
                 else:
-                    value = tuple(auto_valued)
+                    try:
+                        # accepts iterable as multiple arguments?
+                        value = t(auto_valued)
+                    except TypeError:
+                        # then pass them in singly
+                        value = t(*auto_valued)
             self._member_names[key] = None
             if non_auto_store:
                 self._last_values.append(value)
         super().__setitem__(key, value)
 
+    @property
+    def member_names(self):
+        return list(self._member_names)
+
     def update(self, members, **more_members):
         try:
             for name in members.keys():
@@ -491,6 +473,8 @@ def update(self, members, **more_members):
         for name, value in more_members.items():
             self[name] = value
 
+_EnumDict = EnumDict        # keep private name for backwards compatibility
+
 
 class EnumType(type):
     """
@@ -502,8 +486,7 @@ def __prepare__(metacls, cls, bases, **kwds):
         # check that previous enum members do not exist
         metacls._check_for_existing_members_(cls, bases)
         # create the namespace dict
-        enum_dict = _EnumDict()
-        enum_dict._cls_name = cls
+        enum_dict = EnumDict(cls)
         # inherit previous flags and _generate_next_value_ function
         member_type, first_enum = metacls._get_mixins_(cls, bases)
         if first_enum is not None:
@@ -564,7 +547,9 @@ def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **k
         classdict['_member_names_'] = []
         classdict['_member_map_'] = {}
         classdict['_value2member_map_'] = {}
-        classdict['_unhashable_values_'] = []
+        classdict['_hashable_values_'] = []          # for comparing with non-hashable types
+        classdict['_unhashable_values_'] = []       # e.g. frozenset() with set()
+        classdict['_unhashable_values_map_'] = {}
         classdict['_member_type_'] = member_type
         # now set the __repr__ for the value
         classdict['_value_repr_'] = metacls._find_data_repr_(cls, bases)
@@ -579,15 +564,16 @@ def __new__(metacls, cls, bases, classdict, *, boundary=None, _simple=False, **k
         classdict['_all_bits_'] = 0
         classdict['_inverted_'] = None
         try:
-            exc = None
+            classdict['_%s__in_progress' % cls] = True
             enum_class = super().__new__(metacls, cls, bases, classdict, **kwds)
-        except RuntimeError as e:
-            # any exceptions raised by member.__new__ will get converted to a
-            # RuntimeError, so get that original exception back and raise it instead
-            exc = e.__cause__ or e
-        if exc is not None:
-            raise exc
-        #
+            classdict['_%s__in_progress' % cls] = False
+            delattr(enum_class, '_%s__in_progress' % cls)
+        except Exception as e:
+            # since 3.12 the note "Error calling __set_name__ on '_proto_member' instance ..."
+            # is tacked on to the error instead of raising a RuntimeError, so discard it
+            if hasattr(e, '__notes__'):
+                del e.__notes__
+            raise
         # update classdict with any changes made by __init_subclass__
         classdict.update(enum_class.__dict__)
         #
@@ -706,7 +692,7 @@ def __bool__(cls):
         """
         return True
 
-    def __call__(cls, value, names=None, *values, module=None, qualname=None, type=None, start=1, boundary=None):
+    def __call__(cls, value, names=_not_given, *values, module=None, qualname=None, type=None, start=1, boundary=None):
         """
         Either returns an existing member, or creates a new enum class.
 
@@ -735,18 +721,18 @@ def __call__(cls, value, names=None, *values, module=None, qualname=None, type=N
         """
         if cls._member_map_:
             # simple value lookup if members exist
-            if names:
+            if names is not _not_given:
                 value = (value, names) + values
             return cls.__new__(cls, value)
         # otherwise, functional API: we're creating a new Enum type
-        if names is None and type is None:
+        if names is _not_given and type is None:
             # no body? no data-type? possibly wrong usage
             raise TypeError(
                     f"{cls} has no members; specify `names=()` if you meant to create a new, empty, enum"
                     )
         return cls._create_(
                 class_name=value,
-                names=names,
+                names=None if names is _not_given else names,
                 module=module,
                 qualname=qualname,
                 type=type,
@@ -760,10 +746,20 @@ def __contains__(cls, value):
         `value` is in `cls` if:
         1) `value` is a member of `cls`, or
         2) `value` is the value of one of the `cls`'s members.
+        3) `value` is a pseudo-member (flags)
         """
         if isinstance(value, cls):
             return True
-        return value in cls._value2member_map_ or value in cls._unhashable_values_
+        if issubclass(cls, Flag):
+            try:
+                result = cls._missing_(value)
+                return isinstance(result, cls)
+            except ValueError:
+                pass
+        return (
+                value in cls._unhashable_values_    # both structures are lists
+                or value in cls._hashable_values_
+                )
 
     def __delattr__(cls, attr):
         # nicer error message when someone tries to delete an attribute
@@ -1059,7 +1055,55 @@ def _find_new_(mcls, classdict, member_type, first_enum):
         else:
             use_args = True
         return __new__, save_new, use_args
-EnumMeta = EnumType
+
+    def _add_member_(cls, name, member):
+        # _value_ structures are not updated
+        if name in cls._member_map_:
+            if cls._member_map_[name] is not member:
+                raise NameError('%r is already bound: %r' % (name, cls._member_map_[name]))
+            return
+        #
+        # if necessary, get redirect in place and then add it to _member_map_
+        found_descriptor = None
+        descriptor_type = None
+        class_type = None
+        for base in cls.__mro__[1:]:
+            attr = base.__dict__.get(name)
+            if attr is not None:
+                if isinstance(attr, (property, DynamicClassAttribute)):
+                    found_descriptor = attr
+                    class_type = base
+                    descriptor_type = 'enum'
+                    break
+                elif _is_descriptor(attr):
+                    found_descriptor = attr
+                    descriptor_type = descriptor_type or 'desc'
+                    class_type = class_type or base
+                    continue
+                else:
+                    descriptor_type = 'attr'
+                    class_type = base
+        if found_descriptor:
+            redirect = property()
+            redirect.member = member
+            redirect.__set_name__(cls, name)
+            if descriptor_type in ('enum', 'desc'):
+                # earlier descriptor found; copy fget, fset, fdel to this one.
+                redirect.fget = getattr(found_descriptor, 'fget', None)
+                redirect._get = getattr(found_descriptor, '__get__', None)
+                redirect.fset = getattr(found_descriptor, 'fset', None)
+                redirect._set = getattr(found_descriptor, '__set__', None)
+                redirect.fdel = getattr(found_descriptor, 'fdel', None)
+                redirect._del = getattr(found_descriptor, '__delete__', None)
+            redirect._attr_type = descriptor_type
+            redirect._cls_type = class_type
+            setattr(cls, name, redirect)
+        else:
+            setattr(cls, name, member)
+        # now add to _member_map_ (even aliases)
+        cls._member_map_[name] = member
+
+EnumMeta = EnumType         # keep EnumMeta name for backwards compatibility
 
 
 class Enum(metaclass=EnumType):
@@ -1125,12 +1169,17 @@ def __new__(cls, value):
             pass
         except TypeError:
             # not there, now do long search -- O(n) behavior
-            for member in cls._member_map_.values():
-                if member._value_ == value:
-                    return member
+            for name, unhashable_values in cls._unhashable_values_map_.items():
+                if value in unhashable_values:
+                    return cls[name]
+            for name, member in cls._member_map_.items():
+                if value == member._value_:
+                    return cls[name]
         # still not found -- verify that members exist, in-case somebody got here mistakenly
         # (such as via super when trying to override __new__)
         if not cls._member_map_:
+            if getattr(cls, '_%s__in_progress' % cls.__name__, False):
+                raise TypeError('do not use `super().__new__; call the appropriate __new__ directly') from None
             raise TypeError("%r has no members defined" % cls)
         #
         # still not found -- try _missing_ hook
@@ -1168,6 +1217,34 @@ def __new__(cls, value):
     def __init__(self, *args, **kwds):
         pass
 
+    def _add_alias_(self, name):
+        self.__class__._add_member_(name, self)
+
+    def _add_value_alias_(self, value):
+        cls = self.__class__
+        try:
+            if value in cls._value2member_map_:
+                if cls._value2member_map_[value] is not self:
+                    raise ValueError('%r is already bound: %r' % (value, cls._value2member_map_[value]))
+                return
+        except TypeError:
+            # unhashable value, do long search
+            for m in cls._member_map_.values():
+                if m._value_ == value:
+                    if m is not self:
+                        raise ValueError('%r is already bound: %r' % (value, cls._value2member_map_[value]))
+                    return
+        try:
+            # This may fail if value is not hashable. We can't add the value
+            # to the map, and by-value lookups for this value will be
+            # linear.
+            cls._value2member_map_.setdefault(value, self)
+            cls._hashable_values_.append(value)
+        except TypeError:
+            # keep track of the value in a list so containment checks are quick
+            cls._unhashable_values_.append(value)
+            cls._unhashable_values_map_.setdefault(self.name, []).append(value)
+
     @staticmethod
     def _generate_next_value_(name, start, count, last_values):
         """
@@ -1181,28 +1258,13 @@ def _generate_next_value_(name, start, count, last_values):
         if not last_values:
             return start
         try:
-            last = last_values[-1]
-            last_values.sort()
-            if last == last_values[-1]:
-                # no difference between old and new methods
-                return last + 1
-            else:
-                # trigger old method (with warning)
-                raise TypeError
+            last_value = sorted(last_values).pop()
         except TypeError:
-            import warnings
-            warnings.warn(
-                    "In 3.13 the default `auto()`/`_generate_next_value_` will require all values to be sortable and support adding +1\n"
-                    "and the value returned will be the largest value in the enum incremented by 1",
-                    DeprecationWarning,
-                    stacklevel=3,
-                    )
-            for v in reversed(last_values):
-                try:
-                    return v + 1
-                except TypeError:
-                    pass
-            return start
+            raise TypeError('unable to sort non-numeric values') from None
+        try:
+            return last_value + 1
+        except TypeError:
+            raise TypeError('unable to increment %r' % (last_value, )) from None
 
     @classmethod
     def _missing_(cls, value):
@@ -1217,14 +1279,13 @@ def __str__(self):
 
     def __dir__(self):
         """
-        Returns all members and all public methods
+        Returns public methods and other interesting attributes.
         """
-        if self.__class__._member_type_ is object:
-            interesting = set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value'])
-        else:
+        interesting = set()
+        if self.__class__._member_type_ is not object:
             interesting = set(object.__dir__(self))
         for name in getattr(self, '__dict__', []):
-            if name[0] != '_':
+            if name[0] != '_' and name not in self._member_map_:
                 interesting.add(name)
         for cls in self.__class__.mro():
             for name, obj in cls.__dict__.items():
@@ -1237,7 +1298,7 @@ def __dir__(self):
                     else:
                         # in case it was added by `dir(self)`
                         interesting.discard(name)
-                else:
+                elif name not in self._member_map_:
                     interesting.add(name)
         names = sorted(
                 set(['__class__', '__doc__', '__eq__', '__hash__', '__module__'])
@@ -1525,37 +1586,50 @@ def __str__(self):
     def __bool__(self):
         return bool(self._value_)
 
+    def _get_value(self, flag):
+        if isinstance(flag, self.__class__):
+            return flag._value_
+        elif self._member_type_ is not object and isinstance(flag, self._member_type_):
+            return flag
+        return NotImplemented
+
     def __or__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with |")
         value = self._value_
-        return self.__class__(value | other)
+        return self.__class__(value | other_value)
 
     def __and__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with &")
         value = self._value_
-        return self.__class__(value & other)
+        return self.__class__(value & other_value)
 
     def __xor__(self, other):
-        if isinstance(other, self.__class__):
-            other = other._value_
-        elif self._member_type_ is not object and isinstance(other, self._member_type_):
-            other = other
-        else:
+        other_value = self._get_value(other)
+        if other_value is NotImplemented:
             return NotImplemented
+
+        for flag in self, other:
+            if self._get_value(flag) is None:
+                raise TypeError(f"'{flag}' cannot be combined with other flags with ^")
         value = self._value_
-        return self.__class__(value ^ other)
+        return self.__class__(value ^ other_value)
 
     def __invert__(self):
+        if self._get_value(self) is None:
+            raise TypeError(f"'{self}' cannot be inverted")
+
         if self._inverted_ is None:
             if self._boundary_ in (EJECT, KEEP):
                 self._inverted_ = self.__class__(~self._value_)
@@ -1622,7 +1696,7 @@ def global_flag_repr(self):
     cls_name = self.__class__.__name__
     if self._name_ is None:
         return "%s.%s(%r)" % (module, cls_name, self._value_)
-    if _is_single_bit(self):
+    if _is_single_bit(self._value_):
         return '%s.%s' % (module, self._name_)
     if self._boundary_ is not FlagBoundary.KEEP:
         return '|'.join(['%s.%s' % (module, name) for name in self.name.split('|')])
@@ -1665,7 +1739,7 @@ def _simple_enum(etype=Enum, *, boundary=None, use_args=None):
     Class decorator that converts a normal class into an :class:`Enum`.  No
     safety checks are done, and some advanced behavior (such as
     :func:`__init_subclass__`) is not available.  Enum creation can be faster
-    using :func:`simple_enum`.
+    using :func:`_simple_enum`.
 
         >>> from enum import Enum, _simple_enum
         >>> @_simple_enum(Enum)
@@ -1696,7 +1770,9 @@ def convert_class(cls):
         body['_member_names_'] = member_names = []
         body['_member_map_'] = member_map = {}
         body['_value2member_map_'] = value2member_map = {}
-        body['_unhashable_values_'] = []
+        body['_hashable_values_'] = hashable_values = []
+        body['_unhashable_values_'] = unhashable_values = []
+        body['_unhashable_values_map_'] = {}
         body['_member_type_'] = member_type = etype._member_type_
         body['_value_repr_'] = etype._value_repr_
         if issubclass(etype, Flag):
@@ -1743,35 +1819,42 @@ def convert_class(cls):
             for name, value in attrs.items():
                 if isinstance(value, auto) and auto.value is _auto_null:
                     value = gnv(name, 1, len(member_names), gnv_last_values)
-                if value in value2member_map:
+                # create basic member (possibly isolate value for alias check)
+                if use_args:
+                    if not isinstance(value, tuple):
+                        value = (value, )
+                    member = new_member(enum_class, *value)
+                    value = value[0]
+                else:
+                    member = new_member(enum_class)
+                if __new__ is None:
+                    member._value_ = value
+                # now check if alias
+                try:
+                    contained = value2member_map.get(member._value_)
+                except TypeError:
+                    contained = None
+                    if member._value_ in unhashable_values or member.value in hashable_values:
+                        for m in enum_class:
+                            if m._value_ == member._value_:
+                                contained = m
+                                break
+                if contained is not None:
                     # an alias to an existing member
-                    member = value2member_map[value]
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
+                    contained._add_alias_(name)
                 else:
-                    # create the member
-                    if use_args:
-                        if not isinstance(value, tuple):
-                            value = (value, )
-                        member = new_member(enum_class, *value)
-                        value = value[0]
-                    else:
-                        member = new_member(enum_class)
-                    if __new__ is None:
-                        member._value_ = value
+                    # finish creating member
                     member._name_ = name
                     member.__objclass__ = enum_class
                     member.__init__(value)
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
                     member._sort_order_ = len(member_names)
+                    if name not in ('name', 'value'):
+                        setattr(enum_class, name, member)
+                        member_map[name] = member
+                    else:
+                        enum_class._add_member_(name, member)
                     value2member_map[value] = member
+                    hashable_values.append(value)
                     if _is_single_bit(value):
                         # not a multi-bit alias, record in _member_names_ and _flag_mask_
                         member_names.append(name)
@@ -1793,37 +1876,53 @@ def convert_class(cls):
                     if value.value is _auto_null:
                         value.value = gnv(name, 1, len(member_names), gnv_last_values)
                     value = value.value
-                if value in value2member_map:
+                # create basic member (possibly isolate value for alias check)
+                if use_args:
+                    if not isinstance(value, tuple):
+                        value = (value, )
+                    member = new_member(enum_class, *value)
+                    value = value[0]
+                else:
+                    member = new_member(enum_class)
+                if __new__ is None:
+                    member._value_ = value
+                # now check if alias
+                try:
+                    contained = value2member_map.get(member._value_)
+                except TypeError:
+                    contained = None
+                    if member._value_ in unhashable_values or member._value_ in hashable_values:
+                        for m in enum_class:
+                            if m._value_ == member._value_:
+                                contained = m
+                                break
+                if contained is not None:
                     # an alias to an existing member
-                    member = value2member_map[value]
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
+                    contained._add_alias_(name)
                 else:
-                    # create the member
-                    if use_args:
-                        if not isinstance(value, tuple):
-                            value = (value, )
-                        member = new_member(enum_class, *value)
-                        value = value[0]
-                    else:
-                        member = new_member(enum_class)
-                    if __new__ is None:
-                        member._value_ = value
+                    # finish creating member
                     member._name_ = name
                     member.__objclass__ = enum_class
                     member.__init__(value)
                     member._sort_order_ = len(member_names)
-                    redirect = property()
-                    redirect.member = member
-                    redirect.__set_name__(enum_class, name)
-                    setattr(enum_class, name, redirect)
-                    member_map[name] = member
-                    value2member_map[value] = member
+                    if name not in ('name', 'value'):
+                        setattr(enum_class, name, member)
+                        member_map[name] = member
+                    else:
+                        enum_class._add_member_(name, member)
                     member_names.append(name)
                     gnv_last_values.append(value)
+                    try:
+                        # This may fail if value is not hashable. We can't add the value
+                        # to the map, and by-value lookups for this value will be
+                        # linear.
+                        enum_class._value2member_map_.setdefault(value, member)
+                        if value not in hashable_values:
+                            hashable_values.append(value)
+                    except TypeError:
+                        # keep track of the value in a list so containment checks are quick
+                        enum_class._unhashable_values_.append(value)
+                        enum_class._unhashable_values_map_.setdefault(name, []).append(value)
         if '__new__' in body:
             enum_class.__new_member__ = enum_class.__new__
         enum_class.__new__ = Enum.__new__
@@ -1880,7 +1979,7 @@ def __call__(self, enumeration):
                         if 2**i not in values:
                             missing.append(2**i)
                 elif enum_type == 'enum':
-                    # check for powers of one
+                    # check for missing consecutive integers
                     for i in range(low+1, high):
                         if i not in values:
                             missing.append(i)
@@ -1908,7 +2007,8 @@ def __call__(self, enumeration):
                     missed = [v for v in values if v not in member_values]
                     if missed:
                         missing_names.append(name)
-                        missing_value |= reduce(_or_, missed)
+                        for val in missed:
+                            missing_value |= val
                 if missing_names:
                     if len(missing_names) == 1:
                         alias = 'alias %s is missing' % missing_names[0]
@@ -1957,7 +2057,8 @@ def _test_simple_enum(checked_enum, simple_enum):
                 + list(simple_enum._member_map_.keys())
                 )
         for key in set(checked_keys + simple_keys):
-            if key in ('__module__', '_member_map_', '_value2member_map_', '__doc__'):
+            if key in ('__module__', '_member_map_', '_value2member_map_', '__doc__',
+                       '__static_attributes__', '__firstlineno__'):
                 # keys known to be different, or very long
                 continue
             elif key in member_names:
diff --git a/Lib/filecmp.py b/Lib/filecmp.py
index 30bd900fa8..c5b8d854d7 100644
--- a/Lib/filecmp.py
+++ b/Lib/filecmp.py
@@ -88,12 +88,15 @@ def _do_cmp(f1, f2):
 class dircmp:
     """A class that manages the comparison of 2 directories.
 
-    dircmp(a, b, ignore=None, hide=None)
+    dircmp(a, b, ignore=None, hide=None, *, shallow=True)
       A and B are directories.
       IGNORE is a list of names to ignore,
         defaults to DEFAULT_IGNORES.
       HIDE is a list of names to hide,
         defaults to [os.curdir, os.pardir].
+      SHALLOW specifies whether to just check the stat signature (do not read
+        the files).
+        defaults to True.
 
     High level usage:
       x = dircmp(dir1, dir2)
@@ -121,7 +124,7 @@ class dircmp:
        in common_dirs.
      """
 
-    def __init__(self, a, b, ignore=None, hide=None): # Initialize
+    def __init__(self, a, b, ignore=None, hide=None, *, shallow=True): # Initialize
         self.left = a
         self.right = b
         if hide is None:
@@ -132,6 +135,7 @@ def __init__(self, a, b, ignore=None, hide=None): # Initialize
             self.ignore = DEFAULT_IGNORES
         else:
             self.ignore = ignore
+        self.shallow = shallow
 
     def phase0(self): # Compare everything except common subdirectories
         self.left_list = _filter(os.listdir(self.left),
@@ -160,12 +164,14 @@ def phase2(self): # Distinguish files, directories, funnies
             ok = True
             try:
                 a_stat = os.stat(a_path)
-            except OSError:
+            except (OSError, ValueError):
+                # See https://github.com/python/cpython/issues/122400
+                # for the rationale for protecting against ValueError.
                 # print('Can\'t stat', a_path, ':', why.args[1])
                 ok = False
             try:
                 b_stat = os.stat(b_path)
-            except OSError:
+            except (OSError, ValueError):
                 # print('Can\'t stat', b_path, ':', why.args[1])
                 ok = False
 
@@ -184,7 +190,7 @@ def phase2(self): # Distinguish files, directories, funnies
                 self.common_funny.append(x)
 
     def phase3(self): # Find out differences between common files
-        xx = cmpfiles(self.left, self.right, self.common_files)
+        xx = cmpfiles(self.left, self.right, self.common_files, self.shallow)
         self.same_files, self.diff_files, self.funny_files = xx
 
     def phase4(self): # Find out differences between common subdirectories
@@ -196,7 +202,8 @@ def phase4(self): # Find out differences between common subdirectories
         for x in self.common_dirs:
             a_x = os.path.join(self.left, x)
             b_x = os.path.join(self.right, x)
-            self.subdirs[x]  = self.__class__(a_x, b_x, self.ignore, self.hide)
+            self.subdirs[x]  = self.__class__(a_x, b_x, self.ignore, self.hide,
+                                              shallow=self.shallow)
 
     def phase4_closure(self): # Recursively call phase4() on subdirectories
         self.phase4()
@@ -280,12 +287,12 @@ def cmpfiles(a, b, common, shallow=True):
 # Return:
 #       0 for equal
 #       1 for different
-#       2 for funny cases (can't stat, etc.)
+#       2 for funny cases (can't stat, NUL bytes, etc.)
 #
 def _cmp(a, b, sh, abs=abs, cmp=cmp):
     try:
         return not abs(cmp(a, b, sh))
-    except OSError:
+    except (OSError, ValueError):
         return 2
 
 
diff --git a/Lib/fnmatch.py b/Lib/fnmatch.py
index fee59bf73f..73acb1fe8d 100644
--- a/Lib/fnmatch.py
+++ b/Lib/fnmatch.py
@@ -16,12 +16,6 @@
 
 __all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
 
-# Build a thread-safe incrementing counter to help create unique regexp group
-# names across calls.
-from itertools import count
-_nextgroupnum = count().__next__
-del count
-
 def fnmatch(name, pat):
     """Test whether FILENAME matches PATTERN.
 
@@ -41,7 +35,7 @@ def fnmatch(name, pat):
     pat = os.path.normcase(pat)
     return fnmatchcase(name, pat)
 
-@functools.lru_cache(maxsize=256, typed=True)
+@functools.lru_cache(maxsize=32768, typed=True)
 def _compile_pattern(pat):
     if isinstance(pat, bytes):
         pat_str = str(pat, 'ISO-8859-1')
@@ -84,6 +78,11 @@ def translate(pat):
     """
 
     STAR = object()
+    parts = _translate(pat, STAR, '.')
+    return _join_translated_parts(parts, STAR)
+
+
+def _translate(pat, STAR, QUESTION_MARK):
     res = []
     add = res.append
     i, n = 0, len(pat)
@@ -95,7 +94,7 @@ def translate(pat):
             if (not res) or res[-1] is not STAR:
                 add(STAR)
         elif c == '?':
-            add('.')
+            add(QUESTION_MARK)
         elif c == '[':
             j = i
             if j < n and pat[j] == '!':
@@ -152,9 +151,11 @@ def translate(pat):
         else:
             add(re.escape(c))
     assert i == n
+    return res
+
 
+def _join_translated_parts(inp, STAR):
     # Deal with STARs.
-    inp = res
     res = []
     add = res.append
     i, n = 0, len(inp)
@@ -165,17 +166,10 @@ def translate(pat):
     # 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.
-    # We can't spell that directly, but can trick it into working by matching
-    #    .*?fixed
-    # in a lookahead assertion, save the matched part in a group, then
-    # consume that group via a backreference. If the overall match fails,
-    # the lookahead assertion won't try alternatives. So the translation is:
-    #     (?=(?P<name>.*?fixed))(?P=name)
-    # Group names are created as needed: g0, g1, g2, ...
-    # The numbers are obtained from _nextgroupnum() to ensure they're unique
-    # across calls and across threads. This is because people rely on the
-    # undocumented ability to join multiple translate() results together via
-    # "|" to build large regexps matching "one of many" shell patterns.
+    # 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
@@ -192,8 +186,7 @@ def translate(pat):
             add(".*")
             add(fixed)
         else:
-            groupnum = _nextgroupnum()
-            add(f"(?=(?P<g{groupnum}>.*?{fixed}))(?P=g{groupnum})")
+            add(f"(?>.*?{fixed})")
     assert i == n
     res = "".join(res)
     return fr'(?s:{res})\Z'
diff --git a/Lib/fractions.py b/Lib/fractions.py
index 88b418fe38..9d42e80987 100644
--- a/Lib/fractions.py
+++ b/Lib/fractions.py
@@ -139,6 +139,23 @@ def _round_to_figures(n, d, figures):
     return sign, significand, exponent
 
 
+# Pattern for matching non-float-style format specifications.
+_GENERAL_FORMAT_SPECIFICATION_MATCHER = re.compile(r"""
+    (?:
+        (?P<fill>.)?
+        (?P<align>[<>=^])
+    )?
+    (?P<sign>[-+ ]?)
+    # Alt flag forces a slash and denominator in the output, even for
+    # integer-valued Fraction objects.
+    (?P<alt>\#)?
+    # We don't implement the zeropad flag since there's no single obvious way
+    # to interpret it.
+    (?P<minimumwidth>0|[1-9][0-9]*)?
+    (?P<thousands_sep>[,_])?
+""", re.DOTALL | re.VERBOSE).fullmatch
+
+
 # Pattern for matching float-style format specifications;
 # supports 'e', 'E', 'f', 'F', 'g', 'G' and '%' presentation types.
 _FLOAT_FORMAT_SPECIFICATION_MATCHER = re.compile(r"""
@@ -414,27 +431,42 @@ def __str__(self):
         else:
             return '%s/%s' % (self._numerator, self._denominator)
 
-    def __format__(self, format_spec, /):
-        """Format this fraction according to the given format specification."""
-
-        # Backwards compatiblility with existing formatting.
-        if not format_spec:
-            return str(self)
+    def _format_general(self, match):
+        """Helper method for __format__.
 
+        Handles fill, alignment, signs, and thousands separators in the
+        case of no presentation type.
+        """
         # Validate and parse the format specifier.
-        match = _FLOAT_FORMAT_SPECIFICATION_MATCHER(format_spec)
-        if match is None:
-            raise ValueError(
-                f"Invalid format specifier {format_spec!r} "
-                f"for object of type {type(self).__name__!r}"
-            )
-        elif match["align"] is not None and match["zeropad"] is not None:
-            # Avoid the temptation to guess.
-            raise ValueError(
-                f"Invalid format specifier {format_spec!r} "
-                f"for object of type {type(self).__name__!r}; "
-                "can't use explicit alignment when zero-padding"
-            )
+        fill = match["fill"] or " "
+        align = match["align"] or ">"
+        pos_sign = "" if match["sign"] == "-" else match["sign"]
+        alternate_form = bool(match["alt"])
+        minimumwidth = int(match["minimumwidth"] or "0")
+        thousands_sep = match["thousands_sep"] or ''
+
+        # Determine the body and sign representation.
+        n, d = self._numerator, self._denominator
+        if d > 1 or alternate_form:
+            body = f"{abs(n):{thousands_sep}}/{d:{thousands_sep}}"
+        else:
+            body = f"{abs(n):{thousands_sep}}"
+        sign = '-' if n < 0 else pos_sign
+
+        # Pad with fill character if necessary and return.
+        padding = fill * (minimumwidth - len(sign) - len(body))
+        if align == ">":
+            return padding + sign + body
+        elif align == "<":
+            return sign + body + padding
+        elif align == "^":
+            half = len(padding) // 2
+            return padding[:half] + sign + body + padding[half:]
+        else:  # align == "="
+            return sign + padding + body
+
+    def _format_float_style(self, match):
+        """Helper method for __format__; handles float presentation types."""
         fill = match["fill"] or " "
         align = match["align"] or ">"
         pos_sign = "" if match["sign"] == "-" else match["sign"]
@@ -449,6 +481,9 @@ def __format__(self, format_spec, /):
         trim_point = not alternate_form
         exponent_indicator = "E" if presentation_type in "EFG" else "e"
 
+        if align == '=' and fill == '0':
+            zeropad = True
+
         # Round to get the digits we need, figure out where to place the point,
         # and decide whether to use scientific notation. 'point_pos' is the
         # relative to the _end_ of the digit string: that is, it's the number
@@ -530,7 +565,25 @@ def __format__(self, format_spec, /):
         else:  # align == "="
             return sign + padding + body
 
-    def _operator_fallbacks(monomorphic_operator, fallback_operator):
+    def __format__(self, format_spec, /):
+        """Format this fraction according to the given format specification."""
+
+        if match := _GENERAL_FORMAT_SPECIFICATION_MATCHER(format_spec):
+            return self._format_general(match)
+
+        if match := _FLOAT_FORMAT_SPECIFICATION_MATCHER(format_spec):
+            # Refuse the temptation to guess if both alignment _and_
+            # zero padding are specified.
+            if match["align"] is None or match["zeropad"] is None:
+                return self._format_float_style(match)
+
+        raise ValueError(
+            f"Invalid format specifier {format_spec!r} "
+            f"for object of type {type(self).__name__!r}"
+        )
+
+    def _operator_fallbacks(monomorphic_operator, fallback_operator,
+                            handle_complex=True):
         """Generates forward and reverse operators given a purely-rational
         operator and a function from the operator module.
 
@@ -617,7 +670,7 @@ def forward(a, b):
                 return monomorphic_operator(a, Fraction(b))
             elif isinstance(b, float):
                 return fallback_operator(float(a), b)
-            elif isinstance(b, complex):
+            elif handle_complex and isinstance(b, complex):
                 return fallback_operator(complex(a), b)
             else:
                 return NotImplemented
@@ -630,7 +683,7 @@ def reverse(b, a):
                 return monomorphic_operator(Fraction(a), b)
             elif isinstance(a, numbers.Real):
                 return fallback_operator(float(a), float(b))
-            elif isinstance(a, numbers.Complex):
+            elif handle_complex and isinstance(a, numbers.Complex):
                 return fallback_operator(complex(a), complex(b))
             else:
                 return NotImplemented
@@ -781,7 +834,7 @@ def _floordiv(a, b):
         """a // b"""
         return (a.numerator * b.denominator) // (a.denominator * b.numerator)
 
-    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv)
+    __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv, False)
 
     def _divmod(a, b):
         """(a // b, a % b)"""
@@ -789,14 +842,14 @@ def _divmod(a, b):
         div, n_mod = divmod(a.numerator * db, da * b.numerator)
         return div, Fraction(n_mod, da * db)
 
-    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod)
+    __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod, False)
 
     def _mod(a, b):
         """a % b"""
         da, db = a.denominator, b.denominator
         return Fraction((a.numerator * db) % (b.numerator * da), da * db)
 
-    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod)
+    __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod, False)
 
     def __pow__(a, b):
         """a ** b
@@ -825,8 +878,10 @@ def __pow__(a, b):
                 # A fractional power will generally produce an
                 # irrational number.
                 return float(a) ** float(b)
-        else:
+        elif isinstance(b, (float, complex)):
             return float(a) ** b
+        else:
+            return NotImplemented
 
     def __rpow__(b, a):
         """a ** b"""
diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index a56e0c3085..10c5d1ea08 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -900,11 +900,17 @@ def ftpcp(source, sourcename, target, targetname = '', type = 'I'):
 
 def test():
     '''Test program.
-    Usage: ftp [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
+    Usage: ftplib [-d] [-r[file]] host [-l[dir]] [-d[dir]] [-p] [file] ...
 
-    -d dir
-    -l list
-    -p password
+    Options:
+      -d        increase debugging level
+      -r[file]  set alternate ~/.netrc file
+
+    Commands:
+      -l[dir]   list directory
+      -d[dir]   change the current directory
+      -p        toggle passive and active mode
+      file      retrieve the file and write it to stdout
     '''
 
     if len(sys.argv) < 2:
@@ -930,15 +936,14 @@ def test():
         netrcobj = netrc.netrc(rcfile)
     except OSError:
         if rcfile is not None:
-            sys.stderr.write("Could not open account file"
-                             " -- using anonymous login.")
+            print("Could not open account file -- using anonymous login.",
+                  file=sys.stderr)
     else:
         try:
             userid, acct, passwd = netrcobj.authenticators(host)
-        except KeyError:
+        except (KeyError, TypeError):
             # no account for host
-            sys.stderr.write(
-                    "No account -- using anonymous login.")
+            print("No account -- using anonymous login.", file=sys.stderr)
     ftp.login(userid, passwd, acct)
     for file in sys.argv[2:]:
         if file[:2] == '-l':
@@ -951,7 +956,9 @@ def test():
             ftp.set_pasv(not ftp.passiveserver)
         else:
             ftp.retrbinary('RETR ' + file, \
-                           sys.stdout.write, 1024)
+                           sys.stdout.buffer.write, 1024)
+            sys.stdout.buffer.flush()
+        sys.stdout.flush()
     ftp.quit()
 
 
diff --git a/Lib/functools.py b/Lib/functools.py
index 2ae4290f98..4c1175b815 100644
--- a/Lib/functools.py
+++ b/Lib/functools.py
@@ -19,8 +19,9 @@
 # import types, weakref  # Deferred to single_dispatch()
 from reprlib import recursive_repr
 from _thread import RLock
-from types import GenericAlias
 
+# Avoid importing types, so we can speedup import time
+GenericAlias = type(list[int])
 
 ################################################################################
 ### update_wrapper() and wraps() decorator
@@ -236,14 +237,16 @@ def __ge__(self, other):
 
 def reduce(function, sequence, initial=_initial_missing):
     """
-    reduce(function, iterable[, initial]) -> value
-
-    Apply a function of two arguments cumulatively to the items of a sequence
-    or iterable, from left to right, so as to reduce the iterable to a single
-    value.  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
-    ((((1+2)+3)+4)+5).  If initial is present, it is placed before the items
-    of the iterable in the calculation, and serves as a default when the
-    iterable is empty.
+    reduce(function, iterable[, initial], /) -> value
+
+    Apply a function of two arguments cumulatively to the items of an iterable, from left to right.
+
+    This effectively reduces the iterable to a single value.  If initial is present,
+    it is placed before the items of the iterable in the calculation, and serves as
+    a default when the iterable is empty.
+
+    For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
+    calculates ((((1 + 2) + 3) + 4) + 5).
     """
 
     it = iter(sequence)
@@ -284,7 +287,7 @@ def __new__(cls, func, /, *args, **keywords):
         if not callable(func):
             raise TypeError("the first argument must be callable")
 
-        if hasattr(func, "func"):
+        if isinstance(func, partial):
             args = func.args + args
             keywords = {**func.keywords, **keywords}
             func = func.func
@@ -302,13 +305,23 @@ def __call__(self, /, *args, **keywords):
 
     @recursive_repr()
     def __repr__(self):
-        qualname = type(self).__qualname__
+        cls = type(self)
+        qualname = cls.__qualname__
+        module = cls.__module__
         args = [repr(self.func)]
         args.extend(repr(x) for x in self.args)
         args.extend(f"{k}={v!r}" for (k, v) in self.keywords.items())
-        if type(self).__module__ == "functools":
-            return f"functools.{qualname}({', '.join(args)})"
-        return f"{qualname}({', '.join(args)})"
+        return f"{module}.{qualname}({', '.join(args)})"
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        import warnings
+        warnings.warn('functools.partial will be a method descriptor in '
+                      'future Python versions; wrap it in staticmethod() '
+                      'if you want to preserve the old behavior',
+                      FutureWarning, 2)
+        return self
 
     def __reduce__(self):
         return type(self), (self.func,), (self.func, self.args,
@@ -338,6 +351,9 @@ def __setstate__(self, state):
         self.args = args
         self.keywords = kwds
 
+    __class_getitem__ = classmethod(GenericAlias)
+
+
 try:
     from _functools import partial
 except ImportError:
@@ -372,28 +388,26 @@ def __init__(self, func, /, *args, **keywords):
             self.keywords = keywords
 
     def __repr__(self):
-        args = ", ".join(map(repr, self.args))
-        keywords = ", ".join("{}={!r}".format(k, v)
-                                 for k, v in self.keywords.items())
-        format_string = "{module}.{cls}({func}, {args}, {keywords})"
-        return format_string.format(module=self.__class__.__module__,
-                                    cls=self.__class__.__qualname__,
-                                    func=self.func,
-                                    args=args,
-                                    keywords=keywords)
+        cls = type(self)
+        module = cls.__module__
+        qualname = cls.__qualname__
+        args = [repr(self.func)]
+        args.extend(map(repr, self.args))
+        args.extend(f"{k}={v!r}" for k, v in self.keywords.items())
+        return f"{module}.{qualname}({', '.join(args)})"
 
     def _make_unbound_method(self):
         def _method(cls_or_self, /, *args, **keywords):
             keywords = {**self.keywords, **keywords}
             return self.func(cls_or_self, *self.args, *args, **keywords)
         _method.__isabstractmethod__ = self.__isabstractmethod__
-        _method._partialmethod = self
+        _method.__partialmethod__ = self
         return _method
 
     def __get__(self, obj, cls=None):
         get = getattr(self.func, "__get__", None)
         result = None
-        if get is not None:
+        if get is not None and not isinstance(self.func, partial):
             new_func = get(obj, cls)
             if new_func is not self.func:
                 # Assume __get__ returning something new indicates the
@@ -423,6 +437,17 @@ def _unwrap_partial(func):
         func = func.func
     return func
 
+def _unwrap_partialmethod(func):
+    prev = None
+    while func is not prev:
+        prev = func
+        while isinstance(getattr(func, "__partialmethod__", None), partialmethod):
+            func = func.__partialmethod__
+        while isinstance(func, partialmethod):
+            func = getattr(func, 'func')
+        func = _unwrap_partial(func)
+    return func
+
 ################################################################################
 ### LRU Cache function decorator
 ################################################################################
@@ -483,8 +508,9 @@ def lru_cache(maxsize=128, typed=False):
     can grow without bound.
 
     If *typed* is True, arguments of different types will be cached separately.
-    For example, f(3.0) and f(3) will be treated as distinct calls with
-    distinct results.
+    For example, f(decimal.Decimal("3.0")) and f(3.0) will be treated as
+    distinct calls with distinct results. Some types such as str and int may
+    be cached separately even when typed is false.
 
     Arguments to the cached function must be hashable.
 
@@ -660,7 +686,7 @@ def cache(user_function, /):
 def _c3_merge(sequences):
     """Merges MROs in *sequences* to a single MRO using the C3 algorithm.
 
-    Adapted from https://www.python.org/download/releases/2.3/mro/.
+    Adapted from https://docs.python.org/3/howto/mro.html.
 
     """
     result = []
@@ -905,7 +931,6 @@ def wrapper(*args, **kw):
         if not args:
             raise TypeError(f'{funcname} requires at least '
                             '1 positional argument')
-
         return dispatch(args[0].__class__)(*args, **kw)
 
     funcname = getattr(func, '__name__', 'singledispatch function')
@@ -941,13 +966,18 @@ def register(self, cls, method=None):
         return self.dispatcher.register(cls, func=method)
 
     def __get__(self, obj, cls=None):
+        dispatch = self.dispatcher.dispatch
+        funcname = getattr(self.func, '__name__', 'singledispatchmethod method')
         def _method(*args, **kwargs):
-            method = self.dispatcher.dispatch(args[0].__class__)
-            return method.__get__(obj, cls)(*args, **kwargs)
+            if not args:
+                raise TypeError(f'{funcname} requires at least '
+                                '1 positional argument')
+            return dispatch(args[0].__class__).__get__(obj, cls)(*args, **kwargs)
 
         _method.__isabstractmethod__ = self.__isabstractmethod__
         _method.register = self.register
         update_wrapper(_method, self.func)
+
         return _method
 
     @property
@@ -966,6 +996,7 @@ def __init__(self, func):
         self.func = func
         self.attrname = None
         self.__doc__ = func.__doc__
+        self.__module__ = func.__module__
 
     def __set_name__(self, owner, name):
         if self.attrname is None:
diff --git a/Lib/genericpath.py b/Lib/genericpath.py
index 1bd5b3897c..9363f564aa 100644
--- a/Lib/genericpath.py
+++ b/Lib/genericpath.py
@@ -7,8 +7,8 @@
 import stat
 
 __all__ = ['commonprefix', 'exists', 'getatime', 'getctime', 'getmtime',
-           'getsize', 'isdir', 'isfile', 'islink', 'samefile', 'sameopenfile',
-           'samestat']
+           'getsize', 'isdevdrive', 'isdir', 'isfile', 'isjunction', 'islink',
+           'lexists', 'samefile', 'sameopenfile', 'samestat', 'ALLOW_MISSING']
 
 
 # Does a path exist?
@@ -22,6 +22,15 @@ def exists(path):
     return True
 
 
+# Being true for dangling symbolic links is also useful.
+def lexists(path):
+    """Test whether a path exists.  Returns True for broken symbolic links"""
+    try:
+        os.lstat(path)
+    except (OSError, ValueError):
+        return False
+    return True
+
 # This follows symbolic links, so both islink() and isdir() can be true
 # for the same path on systems that support symlinks
 def isfile(path):
@@ -57,6 +66,21 @@ def islink(path):
     return stat.S_ISLNK(st.st_mode)
 
 
+# Is a path a junction?
+def isjunction(path):
+    """Test whether a path is a junction
+    Junctions are not supported on the current platform"""
+    os.fspath(path)
+    return False
+
+
+def isdevdrive(path):
+    """Determines whether the specified path is on a Windows Dev Drive.
+    Dev Drives are not supported on the current platform"""
+    os.fspath(path)
+    return False
+
+
 def getsize(filename):
     """Return the size of a file, reported by os.stat()."""
     return os.stat(filename).st_size
@@ -165,3 +189,12 @@ def _check_arg_types(funcname, *args):
                             f'os.PathLike object, not {s.__class__.__name__!r}') from None
     if hasstr and hasbytes:
         raise TypeError("Can't mix strings and bytes in path components") from None
+
+# A singleton with a true boolean value.
+@object.__new__
+class ALLOW_MISSING:
+    """Special value for use in realpath()."""
+    def __repr__(self):
+        return 'os.path.ALLOW_MISSING'
+    def __reduce__(self):
+        return self.__class__.__name__
diff --git a/Lib/gettext.py b/Lib/gettext.py
index b72b15f82d..62cff81b7b 100644
--- a/Lib/gettext.py
+++ b/Lib/gettext.py
@@ -46,6 +46,7 @@
 #   find this format documented anywhere.
 
 
+import operator
 import os
 import re
 import sys
@@ -166,14 +167,28 @@ def _parse(tokens, priority=-1):
 
 def _as_int(n):
     try:
-        i = round(n)
+        round(n)
     except TypeError:
         raise TypeError('Plural value must be an integer, got %s' %
                         (n.__class__.__name__,)) from None
+    return _as_int2(n)
+
+def _as_int2(n):
+    try:
+        return operator.index(n)
+    except TypeError:
+        pass
+
     import warnings
+    frame = sys._getframe(1)
+    stacklevel = 2
+    while frame.f_back is not None and frame.f_globals.get('__name__') == __name__:
+        stacklevel += 1
+        frame = frame.f_back
     warnings.warn('Plural value must be an integer, got %s' %
                   (n.__class__.__name__,),
-                  DeprecationWarning, 4)
+                  DeprecationWarning,
+                  stacklevel)
     return n
 
 
@@ -200,7 +215,7 @@ def c2py(plural):
             elif c == ')':
                 depth -= 1
 
-        ns = {'_as_int': _as_int}
+        ns = {'_as_int': _as_int, '__name__': __name__}
         exec('''if True:
             def func(n):
                 if not isinstance(n, int):
@@ -280,6 +295,7 @@ def gettext(self, message):
     def ngettext(self, msgid1, msgid2, n):
         if self._fallback:
             return self._fallback.ngettext(msgid1, msgid2, n)
+        n = _as_int2(n)
         if n == 1:
             return msgid1
         else:
@@ -293,6 +309,7 @@ def pgettext(self, context, message):
     def npgettext(self, context, msgid1, msgid2, n):
         if self._fallback:
             return self._fallback.npgettext(context, msgid1, msgid2, n)
+        n = _as_int2(n)
         if n == 1:
             return msgid1
         else:
@@ -579,6 +596,7 @@ def dngettext(domain, msgid1, msgid2, n):
     try:
         t = translation(domain, _localedirs.get(domain, None))
     except OSError:
+        n = _as_int2(n)
         if n == 1:
             return msgid1
         else:
@@ -598,6 +616,7 @@ def dnpgettext(domain, context, msgid1, msgid2, n):
     try:
         t = translation(domain, _localedirs.get(domain, None))
     except OSError:
+        n = _as_int2(n)
         if n == 1:
             return msgid1
         else:
diff --git a/Lib/glob.py b/Lib/glob.py
index 50beef37f4..c506e0e215 100644
--- a/Lib/glob.py
+++ b/Lib/glob.py
@@ -4,11 +4,14 @@
 import os
 import re
 import fnmatch
+import functools
 import itertools
+import operator
 import stat
 import sys
 
-__all__ = ["glob", "iglob", "escape"]
+
+__all__ = ["glob", "iglob", "escape", "translate"]
 
 def glob(pathname, *, root_dir=None, dir_fd=None, recursive=False,
         include_hidden=False):
@@ -104,8 +107,8 @@ def _iglob(pathname, root_dir, dir_fd, recursive, dironly,
 
 def _glob1(dirname, pattern, dir_fd, dironly, include_hidden=False):
     names = _listdir(dirname, dir_fd, dironly)
-    if include_hidden or not _ishidden(pattern):
-        names = (x for x in names if include_hidden or not _ishidden(x))
+    if not (include_hidden or _ishidden(pattern)):
+        names = (x for x in names if not _ishidden(x))
     return fnmatch.filter(names, pattern)
 
 def _glob0(dirname, basename, dir_fd, dironly, include_hidden=False):
@@ -119,12 +122,19 @@ def _glob0(dirname, basename, dir_fd, dironly, include_hidden=False):
             return [basename]
     return []
 
-# Following functions are not public but can be used by third-party code.
+_deprecated_function_message = (
+    "{name} is deprecated and will be removed in Python {remove}. Use "
+    "glob.glob and pass a directory to its root_dir argument instead."
+)
 
 def glob0(dirname, pattern):
+    import warnings
+    warnings._deprecated("glob.glob0", _deprecated_function_message, remove=(3, 15))
     return _glob0(dirname, pattern, None, False)
 
 def glob1(dirname, pattern):
+    import warnings
+    warnings._deprecated("glob.glob1", _deprecated_function_message, remove=(3, 15))
     return _glob1(dirname, pattern, None, False)
 
 # This helper function recursively yields relative pathnames inside a literal
@@ -249,4 +259,287 @@ def escape(pathname):
     return drive + pathname
 
 
+_special_parts = ('', '.', '..')
 _dir_open_flags = os.O_RDONLY | getattr(os, 'O_DIRECTORY', 0)
+_no_recurse_symlinks = object()
+
+
+def translate(pat, *, recursive=False, include_hidden=False, seps=None):
+    """Translate a pathname with shell wildcards to a regular expression.
+
+    If `recursive` is true, the pattern segment '**' will match any number of
+    path segments.
+
+    If `include_hidden` is true, wildcards can match path segments beginning
+    with a dot ('.').
+
+    If a sequence of separator characters is given to `seps`, they will be
+    used to split the pattern into segments and match path separators. If not
+    given, os.path.sep and os.path.altsep (where available) are used.
+    """
+    if not seps:
+        if os.path.altsep:
+            seps = (os.path.sep, os.path.altsep)
+        else:
+            seps = os.path.sep
+    escaped_seps = ''.join(map(re.escape, seps))
+    any_sep = f'[{escaped_seps}]' if len(seps) > 1 else escaped_seps
+    not_sep = f'[^{escaped_seps}]'
+    if include_hidden:
+        one_last_segment = f'{not_sep}+'
+        one_segment = f'{one_last_segment}{any_sep}'
+        any_segments = f'(?:.+{any_sep})?'
+        any_last_segments = '.*'
+    else:
+        one_last_segment = f'[^{escaped_seps}.]{not_sep}*'
+        one_segment = f'{one_last_segment}{any_sep}'
+        any_segments = f'(?:{one_segment})*'
+        any_last_segments = f'{any_segments}(?:{one_last_segment})?'
+
+    results = []
+    parts = re.split(any_sep, pat)
+    last_part_idx = len(parts) - 1
+    for idx, part in enumerate(parts):
+        if part == '*':
+            results.append(one_segment if idx < last_part_idx else one_last_segment)
+        elif recursive and part == '**':
+            if idx < last_part_idx:
+                if parts[idx + 1] != '**':
+                    results.append(any_segments)
+            else:
+                results.append(any_last_segments)
+        else:
+            if part:
+                if not include_hidden and part[0] in '*?':
+                    results.append(r'(?!\.)')
+                results.extend(fnmatch._translate(part, f'{not_sep}*', not_sep))
+            if idx < last_part_idx:
+                results.append(any_sep)
+    res = ''.join(results)
+    return fr'(?s:{res})\Z'
+
+
+@functools.lru_cache(maxsize=512)
+def _compile_pattern(pat, sep, 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)
+    return re.compile(regex, flags=flags).match
+
+
+class _Globber:
+    """Class providing shell-style pattern matching and globbing.
+    """
+
+    def __init__(self, sep, case_sensitive, case_pedantic=False, recursive=False):
+        self.sep = sep
+        self.case_sensitive = case_sensitive
+        self.case_pedantic = case_pedantic
+        self.recursive = recursive
+
+    # Low-level methods
+
+    lstat = operator.methodcaller('lstat')
+    add_slash = operator.methodcaller('joinpath', '')
+
+    @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().
+        """
+        return contextlib.nullcontext(path.iterdir())
+
+    @staticmethod
+    def concat_path(path, text):
+        """Appends text to the given path.
+        """
+        return path.with_segments(path._raw_path + text)
+
+    @staticmethod
+    def parse_entry(entry):
+        """Returns the path of an entry yielded from scandir().
+        """
+        return entry
+
+    # High-level methods
+
+    def compile(self, pat):
+        return _compile_pattern(pat, self.sep, self.case_sensitive, self.recursive)
+
+    def selector(self, parts):
+        """Returns a function that selects from a given path, walking and
+        filtering according to the glob-style pattern parts in *parts*.
+        """
+        if not parts:
+            return self.select_exists
+        part = parts.pop()
+        if self.recursive and part == '**':
+            selector = self.recursive_selector
+        elif part in _special_parts:
+            selector = self.special_selector
+        elif not self.case_pedantic and magic_check.search(part) is None:
+            selector = self.literal_selector
+        else:
+            selector = self.wildcard_selector
+        return selector(part, parts)
+
+    def special_selector(self, part, parts):
+        """Returns a function that selects special children of the given path.
+        """
+        select_next = self.selector(parts)
+
+        def select_special(path, exists=False):
+            path = self.concat_path(self.add_slash(path), part)
+            return select_next(path, exists)
+        return select_special
+
+    def literal_selector(self, part, parts):
+        """Returns a function that selects a literal descendant of a path.
+        """
+
+        # 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().
+        while parts and magic_check.search(parts[-1]) is None:
+            part += self.sep + parts.pop()
+
+        select_next = self.selector(parts)
+
+        def select_literal(path, exists=False):
+            path = self.concat_path(self.add_slash(path), part)
+            return select_next(path, exists=False)
+        return select_literal
+
+    def wildcard_selector(self, part, parts):
+        """Returns a function that selects direct children of a given path,
+        filtering by pattern.
+        """
+
+        match = None if part == '*' else self.compile(part)
+        dir_only = bool(parts)
+        if dir_only:
+            select_next = self.selector(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)
+            except OSError:
+                pass
+            else:
+                for entry 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:
+                            yield from select_next(entry_path, exists=True)
+                        else:
+                            yield entry_path
+        return select_wildcard
+
+    def recursive_selector(self, part, parts):
+        """Returns a function that selects a given path and all its children,
+        recursively, filtering by pattern.
+        """
+        # Optimization: consume following '**' parts, which have no effect.
+        while parts and parts[-1] == '**':
+            parts.pop()
+
+        # Optimization: consume and join any following non-special parts here,
+        # rather than leaving them for the next selector. They're used to
+        # build a regular expression, which we use to filter the results of
+        # the recursive walk. As a result, non-special pattern segments
+        # following a '**' wildcard don't require additional filesystem access
+        # to expand.
+        follow_symlinks = self.recursive is not _no_recurse_symlinks
+        if follow_symlinks:
+            while parts and parts[-1] not in _special_parts:
+                part += self.sep + parts.pop()
+
+        match = None if part == '**' else self.compile(part)
+        dir_only = bool(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)
+            stack = [path]
+            while stack:
+                yield from select_recursive_step(stack, match_pos)
+
+        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)
+            except OSError:
+                pass
+            else:
+                for entry in entries:
+                    is_dir = False
+                    try:
+                        if entry.is_dir(follow_symlinks=follow_symlinks):
+                            is_dir = True
+                    except OSError:
+                        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):
+                            if dir_only:
+                                yield from select_next(entry_path, exists=True)
+                            else:
+                                # Optimization: directly yield the path if this is
+                                # last pattern part.
+                                yield entry_path
+                        if is_dir:
+                            stack.append(entry_path)
+
+        return select_recursive
+
+    def select_exists(self, path, exists=False):
+        """Yields the given path, if it exists.
+        """
+        if exists:
+            # 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
+
+
+class _StringGlobber(_Globber):
+    lstat = staticmethod(os.lstat)
+    scandir = staticmethod(os.scandir)
+    parse_entry = operator.attrgetter('path')
+    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}/'
diff --git a/Lib/hmac.py b/Lib/hmac.py
index 8b4f920db9..8b4eb2fe74 100644
--- a/Lib/hmac.py
+++ b/Lib/hmac.py
@@ -53,7 +53,7 @@ def __init__(self, key, msg=None, digestmod=''):
             raise TypeError("key: expected bytes or bytearray, but got %r" % type(key).__name__)
 
         if not digestmod:
-            raise TypeError("Missing required parameter 'digestmod'.")
+            raise TypeError("Missing required argument 'digestmod'.")
 
         if _hashopenssl and isinstance(digestmod, (str, _functype)):
             try:
diff --git a/Lib/html/__init__.py b/Lib/html/__init__.py
index da0a0a3ce7..1543460ca3 100644
--- a/Lib/html/__init__.py
+++ b/Lib/html/__init__.py
@@ -25,7 +25,7 @@ def escape(s, quote=True):
     return s
 
 
-# see http://www.w3.org/TR/html5/syntax.html#tokenizing-character-references
+# see https://html.spec.whatwg.org/multipage/parsing.html#numeric-character-reference-end-state
 
 _invalid_charrefs = {
     0x00: '\ufffd',  # REPLACEMENT CHARACTER
diff --git a/Lib/html/entities.py b/Lib/html/entities.py
index dc508631ac..eb6dc12190 100644
--- a/Lib/html/entities.py
+++ b/Lib/html/entities.py
@@ -3,8 +3,7 @@
 __all__ = ['html5', 'name2codepoint', 'codepoint2name', 'entitydefs']
 
 
-# maps the HTML entity name to the Unicode code point
-# from https://html.spec.whatwg.org/multipage/named-characters.html
+# maps HTML4 entity name to the Unicode code point
 name2codepoint = {
     'AElig':    0x00c6, # latin capital letter AE = latin capital ligature AE, U+00C6 ISOlat1
     'Aacute':   0x00c1, # latin capital letter A with acute, U+00C1 ISOlat1
@@ -261,7 +260,11 @@
 }
 
 
-# maps the HTML5 named character references to the equivalent Unicode character(s)
+# HTML5 named character references
+# Generated by Tools/build/parse_html5_entities.py
+# from https://html.spec.whatwg.org/entities.json and
+# https://html.spec.whatwg.org/multipage/named-characters.html.
+# Map HTML5 named character references to the equivalent Unicode character(s).
 html5 = {
     'Aacute': '\xc1',
     'aacute': '\xe1',
diff --git a/Lib/html/parser.py b/Lib/html/parser.py
index bef0f4fe4b..5d7050dad2 100644
--- a/Lib/html/parser.py
+++ b/Lib/html/parser.py
@@ -12,6 +12,7 @@
 import _markupbase
 
 from html import unescape
+from html.entities import html5 as html5_entities
 
 
 __all__ = ['HTMLParser']
@@ -23,20 +24,51 @@
 
 entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]')
 charref = re.compile('&#(?:[0-9]+|[xX][0-9a-fA-F]+)[^0-9a-fA-F]')
+attr_charref = re.compile(r'&(#[0-9]+|#[xX][0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*)[;=]?')
 
 starttagopen = re.compile('<[a-zA-Z]')
+endtagopen = re.compile('</[a-zA-Z]')
 piclose = re.compile('>')
-commentclose = re.compile(r'--\s*>')
+commentclose = re.compile(r'--!?>')
+commentabruptclose = re.compile(r'-?>')
 # Note:
-#  1) if you change tagfind/attrfind remember to update locatestarttagend too;
-#  2) if you change tagfind/attrfind and/or locatestarttagend the parser will
+#  1) if you change tagfind/attrfind remember to update locatetagend too;
+#  2) if you change tagfind/attrfind and/or locatetagend the parser will
 #     explode, so don't do it.
-# see http://www.w3.org/TR/html5/tokenization.html#tag-open-state
-# and http://www.w3.org/TR/html5/tokenization.html#tag-name-state
-tagfind_tolerant = re.compile(r'([a-zA-Z][^\t\n\r\f />\x00]*)(?:\s|/(?!>))*')
-attrfind_tolerant = re.compile(
-    r'((?<=[\'"\s/])[^\s/>][^\s/=>]*)(\s*=+\s*'
-    r'(\'[^\']*\'|"[^"]*"|(?![\'"])[^>\s]*))?(?:\s|/(?!>))*')
+# see the HTML5 specs section "13.2.5.6 Tag open state",
+# "13.2.5.8 Tag name state" and "13.2.5.33 Attribute name state".
+# https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state
+# https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
+# https://html.spec.whatwg.org/multipage/parsing.html#attribute-name-state
+tagfind_tolerant = re.compile(r'([a-zA-Z][^\t\n\r\f />]*)(?:[\t\n\r\f ]|/(?!>))*')
+attrfind_tolerant = re.compile(r"""
+  (
+    (?<=['"\t\n\r\f /])[^\t\n\r\f />][^\t\n\r\f /=>]*  # attribute name
+   )
+  ([\t\n\r\f ]*=[\t\n\r\f ]*        # value indicator
+    ('[^']*'                        # LITA-enclosed value
+    |"[^"]*"                        # LIT-enclosed value
+    |(?!['"])[^>\t\n\r\f ]*         # bare value
+    )
+   )?
+  (?:[\t\n\r\f ]|/(?!>))*           # possibly followed by a space
+""", re.VERBOSE)
+locatetagend = re.compile(r"""
+  [a-zA-Z][^\t\n\r\f />]*           # tag name
+  [\t\n\r\f /]*                     # optional whitespace before attribute name
+  (?:(?<=['"\t\n\r\f /])[^\t\n\r\f />][^\t\n\r\f /=>]*  # attribute name
+    (?:[\t\n\r\f ]*=[\t\n\r\f ]*    # value indicator
+      (?:'[^']*'                    # LITA-enclosed value
+        |"[^"]*"                    # LIT-enclosed value
+        |(?!['"])[^>\t\n\r\f ]*     # bare value
+       )
+     )?
+    [\t\n\r\f /]*                   # possibly followed by a space
+   )*
+   >?
+""", re.VERBOSE)
+# The following variables are not used, but are temporarily left for
+# backward compatibility.
 locatestarttagend_tolerant = re.compile(r"""
   <[a-zA-Z][^\t\n\r\f />\x00]*       # tag name
   (?:[\s/]*                          # optional whitespace before attribute name
@@ -53,10 +85,24 @@
   \s*                                # trailing whitespace
 """, re.VERBOSE)
 endendtag = re.compile('>')
-# the HTML 5 spec, section 8.1.2.2, doesn't allow spaces between
-# </ and the tag name, so maybe this should be fixed
 endtagfind = re.compile(r'</\s*([a-zA-Z][-.a-zA-Z0-9:_]*)\s*>')
 
+# Character reference processing logic specific to attribute values
+# See: https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+def _replace_attr_charref(match):
+    ref = match.group(0)
+    # Numeric / hex char refs must always be unescaped
+    if ref.startswith('&#'):
+        return unescape(ref)
+    # Named character / entity references must only be unescaped
+    # if they are an exact match, and they are not followed by an equals sign
+    if not ref.endswith('=') and ref[1:] in html5_entities:
+        return unescape(ref)
+    # Otherwise do not unescape
+    return ref
+
+def _unescape_attrvalue(s):
+    return attr_charref.sub(_replace_attr_charref, s)
 
 
 class HTMLParser(_markupbase.ParserBase):
@@ -82,6 +128,7 @@ class HTMLParser(_markupbase.ParserBase):
     """
 
     CDATA_CONTENT_ELEMENTS = ("script", "style")
+    RCDATA_CONTENT_ELEMENTS = ("textarea", "title")
 
     def __init__(self, *, convert_charrefs=True):
         """Initialize and reset this instance.
@@ -89,6 +136,7 @@ def __init__(self, *, convert_charrefs=True):
         If convert_charrefs is True (the default), all character references
         are automatically converted to the corresponding Unicode characters.
         """
+        super().__init__()
         self.convert_charrefs = convert_charrefs
         self.reset()
 
@@ -98,7 +146,9 @@ def reset(self):
         self.lasttag = '???'
         self.interesting = interesting_normal
         self.cdata_elem = None
-        _markupbase.ParserBase.reset(self)
+        self._support_cdata = True
+        self._escapable = True
+        super().reset()
 
     def feed(self, data):
         r"""Feed data to the parser.
@@ -119,13 +169,33 @@ def get_starttag_text(self):
         """Return full source of start tag: '<...>'."""
         return self.__starttag_text
 
-    def set_cdata_mode(self, elem):
+    def set_cdata_mode(self, elem, *, escapable=False):
         self.cdata_elem = elem.lower()
-        self.interesting = re.compile(r'</\s*%s\s*>' % self.cdata_elem, re.I)
+        self._escapable = escapable
+        if escapable and not self.convert_charrefs:
+            self.interesting = re.compile(r'&|</%s(?=[\t\n\r\f />])' % self.cdata_elem,
+                                          re.IGNORECASE|re.ASCII)
+        else:
+            self.interesting = re.compile(r'</%s(?=[\t\n\r\f />])' % self.cdata_elem,
+                                          re.IGNORECASE|re.ASCII)
 
     def clear_cdata_mode(self):
         self.interesting = interesting_normal
         self.cdata_elem = None
+        self._escapable = True
+
+    def _set_support_cdata(self, flag=True):
+        """Enable or disable support of the CDATA sections.
+        If enabled, "<[CDATA[" starts a CDATA section which ends with "]]>".
+        If disabled, "<[CDATA[" starts a bogus comments which ends with ">".
+
+        This method is not called by default. Its purpose is to be called
+        in custom handle_starttag() and handle_endtag() methods, with
+        value that depends on the adjusted current node.
+        See https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
+        for details.
+        """
+        self._support_cdata = flag
 
     # Internal -- handle data as far as reasonable.  May leave state
     # and data to be processed by a subsequent call.  If 'end' is
@@ -146,7 +216,7 @@ def goahead(self, end):
                     # & near the end and see if it's followed by a space or ;.
                     amppos = rawdata.rfind('&', max(i, n-34))
                     if (amppos >= 0 and
-                        not re.compile(r'[\s;]').search(rawdata, amppos)):
+                        not re.compile(r'[\t\n\r\f ;]').search(rawdata, amppos)):
                         break  # wait till we get all the text
                     j = n
             else:
@@ -158,7 +228,7 @@ def goahead(self, end):
                         break
                     j = n
             if i < j:
-                if self.convert_charrefs and not self.cdata_elem:
+                if self.convert_charrefs and self._escapable:
                     self.handle_data(unescape(rawdata[i:j]))
                 else:
                     self.handle_data(rawdata[i:j])
@@ -176,7 +246,7 @@ def goahead(self, end):
                     k = self.parse_pi(i)
                 elif startswith("<!", i):
                     k = self.parse_html_declaration(i)
-                elif (i + 1) < n:
+                elif (i + 1) < n or end:
                     self.handle_data("<")
                     k = i + 1
                 else:
@@ -184,17 +254,35 @@ def goahead(self, end):
                 if k < 0:
                     if not end:
                         break
-                    k = rawdata.find('>', i + 1)
-                    if k < 0:
-                        k = rawdata.find('<', i + 1)
-                        if k < 0:
-                            k = i + 1
-                    else:
-                        k += 1
-                    if self.convert_charrefs and not self.cdata_elem:
-                        self.handle_data(unescape(rawdata[i:k]))
+                    if starttagopen.match(rawdata, i):  # < + letter
+                        pass
+                    elif startswith("</", i):
+                        if i + 2 == n:
+                            self.handle_data("</")
+                        elif endtagopen.match(rawdata, i):  # </ + letter
+                            pass
+                        else:
+                            # bogus comment
+                            self.handle_comment(rawdata[i+2:])
+                    elif startswith("<!--", i):
+                        j = n
+                        for suffix in ("--!", "--", "-"):
+                            if rawdata.endswith(suffix, i+4):
+                                j -= len(suffix)
+                                break
+                        self.handle_comment(rawdata[i+4:j])
+                    elif startswith("<![CDATA[", i) and self._support_cdata:
+                        self.unknown_decl(rawdata[i+3:])
+                    elif rawdata[i:i+9].lower() == '<!doctype':
+                        self.handle_decl(rawdata[i+2:])
+                    elif startswith("<!", i):
+                        # bogus comment
+                        self.handle_comment(rawdata[i+2:])
+                    elif startswith("<?", i):
+                        self.handle_pi(rawdata[i+2:])
                     else:
-                        self.handle_data(rawdata[i:k])
+                        raise AssertionError("we should not get here!")
+                    k = n
                 i = self.updatepos(i, k)
             elif startswith("&#", i):
                 match = charref.match(rawdata, i)
@@ -241,8 +329,8 @@ def goahead(self, end):
             else:
                 assert 0, "interesting.search() lied"
         # end while
-        if end and i < n and not self.cdata_elem:
-            if self.convert_charrefs and not self.cdata_elem:
+        if end and i < n:
+            if self.convert_charrefs and self._escapable:
                 self.handle_data(unescape(rawdata[i:n]))
             else:
                 self.handle_data(rawdata[i:n])
@@ -259,8 +347,12 @@ def parse_html_declaration(self, i):
         if rawdata[i:i+4] == '<!--':
             # this case is actually already handled in goahead()
             return self.parse_comment(i)
-        elif rawdata[i:i+3] == '<![':
-            return self.parse_marked_section(i)
+        elif rawdata[i:i+9] == '<![CDATA[' and self._support_cdata:
+            j = rawdata.find(']]>', i+9)
+            if j < 0:
+                return -1
+            self.unknown_decl(rawdata[i+3: j])
+            return j + 3
         elif rawdata[i:i+9].lower() == '<!doctype':
             # find the closing >
             gtpos = rawdata.find('>', i+9)
@@ -271,12 +363,27 @@ def parse_html_declaration(self, i):
         else:
             return self.parse_bogus_comment(i)
 
+    # Internal -- parse comment, return length or -1 if not terminated
+    # see https://html.spec.whatwg.org/multipage/parsing.html#comment-start-state
+    def parse_comment(self, i, report=True):
+        rawdata = self.rawdata
+        assert rawdata.startswith('<!--', i), 'unexpected call to parse_comment()'
+        match = commentclose.search(rawdata, i+4)
+        if not match:
+            match = commentabruptclose.match(rawdata, i+4)
+            if not match:
+                return -1
+        if report:
+            j = match.start()
+            self.handle_comment(rawdata[i+4: j])
+        return match.end()
+
     # Internal -- parse bogus comment, return length or -1 if not terminated
-    # see http://www.w3.org/TR/html5/tokenization.html#bogus-comment-state
+    # see https://html.spec.whatwg.org/multipage/parsing.html#bogus-comment-state
     def parse_bogus_comment(self, i, report=1):
         rawdata = self.rawdata
         assert rawdata[i:i+2] in ('<!', '</'), ('unexpected call to '
-                                                'parse_comment()')
+                                                'parse_bogus_comment()')
         pos = rawdata.find('>', i+2)
         if pos == -1:
             return -1
@@ -298,6 +405,8 @@ def parse_pi(self, i):
 
     # Internal -- handle starttag, return end or -1 if not terminated
     def parse_starttag(self, i):
+        # See the HTML5 specs section "13.2.5.8 Tag name state"
+        # https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
         self.__starttag_text = None
         endpos = self.check_for_whole_start_tag(i)
         if endpos < 0:
@@ -322,7 +431,7 @@ def parse_starttag(self, i):
                  attrvalue[:1] == '"' == attrvalue[-1:]:
                 attrvalue = attrvalue[1:-1]
             if attrvalue:
-                attrvalue = unescape(attrvalue)
+                attrvalue = _unescape_attrvalue(attrvalue)
             attrs.append((attrname.lower(), attrvalue))
             k = m.end()
 
@@ -337,82 +446,50 @@ def parse_starttag(self, i):
             self.handle_starttag(tag, attrs)
             if tag in self.CDATA_CONTENT_ELEMENTS:
                 self.set_cdata_mode(tag)
+            elif tag in self.RCDATA_CONTENT_ELEMENTS:
+                self.set_cdata_mode(tag, escapable=True)
         return endpos
 
     # Internal -- check to see if we have a complete starttag; return end
     # or -1 if incomplete.
     def check_for_whole_start_tag(self, i):
         rawdata = self.rawdata
-        m = locatestarttagend_tolerant.match(rawdata, i)
-        if m:
-            j = m.end()
-            next = rawdata[j:j+1]
-            if next == ">":
-                return j + 1
-            if next == "/":
-                if rawdata.startswith("/>", j):
-                    return j + 2
-                if rawdata.startswith("/", j):
-                    # buffer boundary
-                    return -1
-                # else bogus input
-                if j > i:
-                    return j
-                else:
-                    return i + 1
-            if next == "":
-                # end of input
-                return -1
-            if next in ("abcdefghijklmnopqrstuvwxyz=/"
-                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
-                # end of input in or before attribute value, or we have the
-                # '/' from a '/>' ending
-                return -1
-            if j > i:
-                return j
-            else:
-                return i + 1
-        raise AssertionError("we should not get here!")
+        match = locatetagend.match(rawdata, i+1)
+        assert match
+        j = match.end()
+        if rawdata[j-1] != ">":
+            return -1
+        return j
 
     # Internal -- parse endtag, return end or -1 if incomplete
     def parse_endtag(self, i):
+        # See the HTML5 specs section "13.2.5.7 End tag open state"
+        # https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state
         rawdata = self.rawdata
         assert rawdata[i:i+2] == "</", "unexpected call to parse_endtag"
-        match = endendtag.search(rawdata, i+1) # >
-        if not match:
+        if rawdata.find('>', i+2) < 0:  # fast check
             return -1
-        gtpos = match.end()
-        match = endtagfind.match(rawdata, i) # </ + tag + >
-        if not match:
-            if self.cdata_elem is not None:
-                self.handle_data(rawdata[i:gtpos])
-                return gtpos
-            # find the name: w3.org/TR/html5/tokenization.html#tag-name-state
-            namematch = tagfind_tolerant.match(rawdata, i+2)
-            if not namematch:
-                # w3.org/TR/html5/tokenization.html#end-tag-open-state
-                if rawdata[i:i+3] == '</>':
-                    return i+3
-                else:
-                    return self.parse_bogus_comment(i)
-            tagname = namematch.group(1).lower()
-            # consume and ignore other stuff between the name and the >
-            # Note: this is not 100% correct, since we might have things like
-            # </tag attr=">">, but looking for > after the name should cover
-            # most of the cases and is much simpler
-            gtpos = rawdata.find('>', namematch.end())
-            self.handle_endtag(tagname)
-            return gtpos+1
+        if not endtagopen.match(rawdata, i):  # </ + letter
+            if rawdata[i+2:i+3] == '>':  # </> is ignored
+                # "missing-end-tag-name" parser error
+                return i+3
+            else:
+                return self.parse_bogus_comment(i)
 
-        elem = match.group(1).lower() # script or style
-        if self.cdata_elem is not None:
-            if elem != self.cdata_elem:
-                self.handle_data(rawdata[i:gtpos])
-                return gtpos
+        match = locatetagend.match(rawdata, i+2)
+        assert match
+        j = match.end()
+        if rawdata[j-1] != ">":
+            return -1
 
-        self.handle_endtag(elem)
+        # find the name: "13.2.5.8 Tag name state"
+        # https://html.spec.whatwg.org/multipage/parsing.html#tag-name-state
+        match = tagfind_tolerant.match(rawdata, i+2)
+        assert match
+        tag = match.group(1).lower()
+        self.handle_endtag(tag)
         self.clear_cdata_mode()
-        return gtpos
+        return j
 
     # Overridable -- finish processing of start+end tag: <tag.../>
     def handle_startendtag(self, tag, attrs):
diff --git a/Lib/http/__init__.py b/Lib/http/__init__.py
index bf8d7d6886..17a47b180e 100644
--- a/Lib/http/__init__.py
+++ b/Lib/http/__init__.py
@@ -1,14 +1,15 @@
-from enum import IntEnum
+from enum import StrEnum, IntEnum, _simple_enum
 
-__all__ = ['HTTPStatus']
+__all__ = ['HTTPStatus', 'HTTPMethod']
 
 
-class HTTPStatus(IntEnum):
+@_simple_enum(IntEnum)
+class HTTPStatus:
     """HTTP status codes and reason phrases
 
     Status codes from the following RFCs are all observed:
 
-        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+        * RFC 9110: HTTP Semantics, obsoletes 7231, which obsoleted 2616
         * RFC 6585: Additional HTTP Status Codes
         * RFC 3229: Delta encoding in HTTP
         * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
@@ -25,11 +26,30 @@ class HTTPStatus(IntEnum):
     def __new__(cls, value, phrase, description=''):
         obj = int.__new__(cls, value)
         obj._value_ = value
-
         obj.phrase = phrase
         obj.description = description
         return obj
 
+    @property
+    def is_informational(self):
+        return 100 <= self <= 199
+
+    @property
+    def is_success(self):
+        return 200 <= self <= 299
+
+    @property
+    def is_redirection(self):
+        return 300 <= self <= 399
+
+    @property
+    def is_client_error(self):
+        return 400 <= self <= 499
+
+    @property
+    def is_server_error(self):
+        return 500 <= self <= 599
+
     # informational
     CONTINUE = 100, 'Continue', 'Request received, please continue'
     SWITCHING_PROTOCOLS = (101, 'Switching Protocols',
@@ -94,22 +114,25 @@ def __new__(cls, value, phrase, description=''):
         'Client must specify Content-Length')
     PRECONDITION_FAILED = (412, 'Precondition Failed',
         'Precondition in headers is false')
-    REQUEST_ENTITY_TOO_LARGE = (413, 'Request Entity Too Large',
-        'Entity is too large')
-    REQUEST_URI_TOO_LONG = (414, 'Request-URI Too Long',
+    CONTENT_TOO_LARGE = (413, 'Content Too Large',
+        'Content is too large')
+    REQUEST_ENTITY_TOO_LARGE = CONTENT_TOO_LARGE
+    URI_TOO_LONG = (414, 'URI Too Long',
         'URI is too long')
+    REQUEST_URI_TOO_LONG = URI_TOO_LONG
     UNSUPPORTED_MEDIA_TYPE = (415, 'Unsupported Media Type',
         'Entity body in unsupported format')
-    REQUESTED_RANGE_NOT_SATISFIABLE = (416,
-        'Requested Range Not Satisfiable',
+    RANGE_NOT_SATISFIABLE = (416, 'Range Not Satisfiable',
         'Cannot satisfy request range')
+    REQUESTED_RANGE_NOT_SATISFIABLE = RANGE_NOT_SATISFIABLE
     EXPECTATION_FAILED = (417, 'Expectation Failed',
         'Expect condition could not be satisfied')
     IM_A_TEAPOT = (418, 'I\'m a Teapot',
         'Server refuses to brew coffee because it is a teapot.')
     MISDIRECTED_REQUEST = (421, 'Misdirected Request',
         'Server is not able to produce a response')
-    UNPROCESSABLE_ENTITY = 422, 'Unprocessable Entity'
+    UNPROCESSABLE_CONTENT = 422, 'Unprocessable Content'
+    UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
     LOCKED = 423, 'Locked'
     FAILED_DEPENDENCY = 424, 'Failed Dependency'
     TOO_EARLY = 425, 'Too Early'
@@ -148,3 +171,32 @@ def __new__(cls, value, phrase, description=''):
     NETWORK_AUTHENTICATION_REQUIRED = (511,
         'Network Authentication Required',
         'The client needs to authenticate to gain network access')
+
+
+@_simple_enum(StrEnum)
+class HTTPMethod:
+    """HTTP methods and descriptions
+
+    Methods from the following RFCs are all observed:
+
+        * RFC 9110: HTTP Semantics, obsoletes 7231, which obsoleted 2616
+        * RFC 5789: PATCH Method for HTTP
+    """
+    def __new__(cls, value, description):
+        obj = str.__new__(cls, value)
+        obj._value_ = value
+        obj.description = description
+        return obj
+
+    def __repr__(self):
+        return "<%s.%s>" % (self.__class__.__name__, self._name_)
+
+    CONNECT = 'CONNECT', 'Establish a connection to the server.'
+    DELETE = 'DELETE', 'Remove the target.'
+    GET = 'GET', 'Retrieve the target.'
+    HEAD = 'HEAD', 'Same as GET, but only retrieve the status line and header section.'
+    OPTIONS = 'OPTIONS', 'Describe the communication options for the target.'
+    PATCH = 'PATCH', 'Apply partial modifications to a target.'
+    POST = 'POST', 'Perform target-specific processing with the request payload.'
+    PUT = 'PUT', 'Replace the target with the request payload.'
+    TRACE = 'TRACE', 'Perform a message loop-back test along the path to the target.'
diff --git a/Lib/http/client.py b/Lib/http/client.py
index a6ab135b2c..dd5f4136e9 100644
--- a/Lib/http/client.py
+++ b/Lib/http/client.py
@@ -111,6 +111,11 @@
 _MAXLINE = 65536
 _MAXHEADERS = 100
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
+
+
 # Header name/value ABNF (http://tools.ietf.org/html/rfc7230#section-3.2)
 #
 # VCHAR          = %x21-7E
@@ -172,6 +177,13 @@ def _encode(data, name='data'):
             "if you want to send it encoded in UTF-8." %
             (name.title(), data[err.start:err.end], name)) from None
 
+def _strip_ipv6_iface(enc_name: bytes) -> bytes:
+    """Remove interface scope from IPv6 address."""
+    enc_name, percent, _ = enc_name.partition(b"%")
+    if percent:
+        assert enc_name.startswith(b'['), enc_name
+        enc_name += b']'
+    return enc_name
 
 class HTTPMessage(email.message.Message):
     # XXX The only usage of this method is in
@@ -221,8 +233,9 @@ def _read_headers(fp):
             break
     return headers
 
-def parse_headers(fp, _class=HTTPMessage):
-    """Parses only RFC2822 headers from a file pointer.
+def _parse_header_lines(header_lines, _class=HTTPMessage):
+    """
+    Parses only RFC 5322 headers from header lines.
 
     email Parser wants to see strings rather than bytes.
     But a TextIOWrapper around self.rfile would buffer too many bytes
@@ -231,10 +244,15 @@ def parse_headers(fp, _class=HTTPMessage):
     to parse.
 
     """
-    headers = _read_headers(fp)
-    hstring = b''.join(headers).decode('iso-8859-1')
+    hstring = b''.join(header_lines).decode('iso-8859-1')
     return email.parser.Parser(_class=_class).parsestr(hstring)
 
+def parse_headers(fp, _class=HTTPMessage):
+    """Parses only RFC 5322 headers from a file pointer."""
+
+    headers = _read_headers(fp)
+    return _parse_header_lines(headers, _class)
+
 
 class HTTPResponse(io.BufferedIOBase):
 
@@ -448,6 +466,7 @@ def isclosed(self):
         return self.fp is None
 
     def read(self, amt=None):
+        """Read and return the response body, or up to the next amt bytes."""
         if self.fp is None:
             return b""
 
@@ -458,7 +477,7 @@ def read(self, amt=None):
         if self.chunked:
             return self._read_chunked(amt)
 
-        if amt is not None:
+        if amt is not None and amt >= 0:
             if self.length is not None and amt > self.length:
                 # clip the read to the "end of response"
                 amt = self.length
@@ -576,13 +595,11 @@ def _get_chunk_left(self):
 
     def _read_chunked(self, amt=None):
         assert self.chunked != _UNKNOWN
+        if amt is not None and amt < 0:
+            amt = None
         value = []
         try:
-            while True:
-                chunk_left = self._get_chunk_left()
-                if chunk_left is None:
-                    break
-
+            while (chunk_left := self._get_chunk_left()) is not None:
                 if amt is not None and amt <= chunk_left:
                     value.append(self._safe_read(amt))
                     self.chunk_left = chunk_left - amt
@@ -593,8 +610,8 @@ def _read_chunked(self, amt=None):
                     amt -= chunk_left
                 self.chunk_left = 0
             return b''.join(value)
-        except IncompleteRead:
-            raise IncompleteRead(b''.join(value))
+        except IncompleteRead as exc:
+            raise IncompleteRead(b''.join(value)) from exc
 
     def _readinto_chunked(self, b):
         assert self.chunked != _UNKNOWN
@@ -627,10 +644,25 @@ def _safe_read(self, amt):
         reading. If the bytes are truly not available (due to EOF), then the
         IncompleteRead exception can be used to detect the problem.
         """
-        data = self.fp.read(amt)
-        if len(data) < amt:
-            raise IncompleteRead(data, amt-len(data))
-        return data
+        cursize = min(amt, _MIN_READ_BUF_SIZE)
+        data = self.fp.read(cursize)
+        if len(data) >= amt:
+            return data
+        if len(data) < cursize:
+            raise IncompleteRead(data, amt - len(data))
+
+        data = io.BytesIO(data)
+        data.seek(0, 2)
+        while True:
+            # This is a geometric increase in read size (never more than
+            # doubling out the current length of data per loop iteration).
+            delta = min(cursize, amt - cursize)
+            data.write(self.fp.read(delta))
+            if data.tell() >= amt:
+                return data.getvalue()
+            cursize += delta
+            if data.tell() < cursize:
+                raise IncompleteRead(data.getvalue(), amt - data.tell())
 
     def _safe_readinto(self, b):
         """Same as _safe_read, but for reading into a buffer."""
@@ -655,6 +687,8 @@ def read1(self, n=-1):
             self._close_conn()
         elif self.length is not None:
             self.length -= len(result)
+            if not self.length:
+                self._close_conn()
         return result
 
     def peek(self, n=-1):
@@ -679,6 +713,8 @@ def readline(self, limit=-1):
             self._close_conn()
         elif self.length is not None:
             self.length -= len(result)
+            if not self.length:
+                self._close_conn()
         return result
 
     def _read1_chunked(self, n):
@@ -786,6 +822,20 @@ def getcode(self):
         '''
         return self.status
 
+
+def _create_https_context(http_version):
+    # Function also used by urllib.request to be able to set the check_hostname
+    # attribute on a context object.
+    context = ssl._create_default_https_context()
+    # send ALPN extension to indicate HTTP/1.1 protocol
+    if http_version == 11:
+        context.set_alpn_protocols(['http/1.1'])
+    # enable PHA for TLS 1.3 connections if available
+    if context.post_handshake_auth is not None:
+        context.post_handshake_auth = True
+    return context
+
+
 class HTTPConnection:
 
     _http_vsn = 11
@@ -847,6 +897,7 @@ def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
         self._tunnel_host = None
         self._tunnel_port = None
         self._tunnel_headers = {}
+        self._raw_proxy_headers = None
 
         (self.host, self.port) = self._get_hostport(host, port)
 
@@ -859,9 +910,9 @@ def __init__(self, host, port=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
     def set_tunnel(self, host, port=None, headers=None):
         """Set up host and port for HTTP CONNECT tunnelling.
 
-        In a connection that uses HTTP CONNECT tunneling, the host passed to the
-        constructor is used as a proxy server that relays all communication to
-        the endpoint passed to `set_tunnel`. This done by sending an HTTP
+        In a connection that uses HTTP CONNECT tunnelling, the host passed to
+        the constructor is used as a proxy server that relays all communication
+        to the endpoint passed to `set_tunnel`. This done by sending an HTTP
         CONNECT request to the proxy server when the connection is established.
 
         This method must be called before the HTTP connection has been
@@ -869,6 +920,13 @@ def set_tunnel(self, host, port=None, headers=None):
 
         The headers argument should be a mapping of extra HTTP headers to send
         with the CONNECT request.
+
+        As HTTP/1.1 is used for HTTP CONNECT tunnelling request, as per the RFC
+        (https://tools.ietf.org/html/rfc7231#section-4.3.6), a HTTP Host:
+        header must be provided, matching the authority-form of the request
+        target provided as the destination for the CONNECT request. If a
+        HTTP Host: header is not provided via the headers argument, one
+        is generated and transmitted automatically.
         """
 
         if self.sock:
@@ -876,10 +934,15 @@ def set_tunnel(self, host, port=None, headers=None):
 
         self._tunnel_host, self._tunnel_port = self._get_hostport(host, port)
         if headers:
-            self._tunnel_headers = headers
+            self._tunnel_headers = headers.copy()
         else:
             self._tunnel_headers.clear()
 
+        if not any(header.lower() == "host" for header in self._tunnel_headers):
+            encoded_host = self._tunnel_host.encode("idna").decode("ascii")
+            self._tunnel_headers["Host"] = "%s:%d" % (
+                encoded_host, self._tunnel_port)
+
     def _get_hostport(self, host, port):
         if port is None:
             i = host.rfind(':')
@@ -895,17 +958,24 @@ def _get_hostport(self, host, port):
                 host = host[:i]
             else:
                 port = self.default_port
-            if host and host[0] == '[' and host[-1] == ']':
-                host = host[1:-1]
+        if host and host[0] == '[' and host[-1] == ']':
+            host = host[1:-1]
 
         return (host, port)
 
     def set_debuglevel(self, level):
         self.debuglevel = level
 
+    def _wrap_ipv6(self, ip):
+        if b':' in ip and ip[0] != b'['[0]:
+            return b"[" + ip + b"]"
+        return ip
+
     def _tunnel(self):
-        connect = b"CONNECT %s:%d HTTP/1.0\r\n" % (
-            self._tunnel_host.encode("ascii"), self._tunnel_port)
+        connect = b"CONNECT %s:%d %s\r\n" % (
+            self._wrap_ipv6(self._tunnel_host.encode("idna")),
+            self._tunnel_port,
+            self._http_vsn_str.encode("ascii"))
         headers = [connect]
         for header, value in self._tunnel_headers.items():
             headers.append(f"{header}: {value}\r\n".encode("latin-1"))
@@ -917,23 +987,35 @@ def _tunnel(self):
         del headers
 
         response = self.response_class(self.sock, method=self._method)
-        (version, code, message) = response._read_status()
+        try:
+            (version, code, message) = response._read_status()
 
-        if code != http.HTTPStatus.OK:
-            self.close()
-            raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
-        while True:
-            line = response.fp.readline(_MAXLINE + 1)
-            if len(line) > _MAXLINE:
-                raise LineTooLong("header line")
-            if not line:
-                # for sites which EOF without sending a trailer
-                break
-            if line in (b'\r\n', b'\n', b''):
-                break
+            self._raw_proxy_headers = _read_headers(response.fp)
 
             if self.debuglevel > 0:
-                print('header:', line.decode())
+                for header in self._raw_proxy_headers:
+                    print('header:', header.decode())
+
+            if code != http.HTTPStatus.OK:
+                self.close()
+                raise OSError(f"Tunnel connection failed: {code} {message.strip()}")
+
+        finally:
+            response.close()
+
+    def get_proxy_response_headers(self):
+        """
+        Returns a dictionary with the headers of the response
+        received from the proxy server to the CONNECT request
+        sent to set the tunnel.
+
+        If the CONNECT request was not sent, the method returns None.
+        """
+        return (
+            _parse_header_lines(self._raw_proxy_headers)
+            if self._raw_proxy_headers is not None
+            else None
+        )
 
     def connect(self):
         """Connect to the host and port specified in __init__."""
@@ -942,7 +1024,7 @@ def connect(self):
             (self.host,self.port), self.timeout, self.source_address)
         # Might fail in OSs that don't implement TCP_NODELAY
         try:
-             self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
         except OSError as e:
             if e.errno != errno.ENOPROTOOPT:
                 raise
@@ -980,14 +1062,11 @@ def send(self, data):
             print("send:", repr(data))
         if hasattr(data, "read") :
             if self.debuglevel > 0:
-                print("sendIng a read()able")
+                print("sending a readable")
             encode = self._is_textIO(data)
             if encode and self.debuglevel > 0:
                 print("encoding file using iso-8859-1")
-            while 1:
-                datablock = data.read(self.blocksize)
-                if not datablock:
-                    break
+            while datablock := data.read(self.blocksize):
                 if encode:
                     datablock = datablock.encode("iso-8859-1")
                 sys.audit("http.client.send", self, datablock)
@@ -1013,14 +1092,11 @@ def _output(self, s):
 
     def _read_readable(self, readable):
         if self.debuglevel > 0:
-            print("sendIng a read()able")
+            print("reading a readable")
         encode = self._is_textIO(readable)
         if encode and self.debuglevel > 0:
             print("encoding file using iso-8859-1")
-        while True:
-            datablock = readable.read(self.blocksize)
-            if not datablock:
-                break
+        while datablock := readable.read(self.blocksize):
             if encode:
                 datablock = datablock.encode("iso-8859-1")
             yield datablock
@@ -1157,7 +1233,7 @@ def putrequest(self, method, url, skip_host=False,
                         netloc_enc = netloc.encode("ascii")
                     except UnicodeEncodeError:
                         netloc_enc = netloc.encode("idna")
-                    self.putheader('Host', netloc_enc)
+                    self.putheader('Host', _strip_ipv6_iface(netloc_enc))
                 else:
                     if self._tunnel_host:
                         host = self._tunnel_host
@@ -1173,9 +1249,9 @@ def putrequest(self, method, url, skip_host=False,
 
                     # As per RFC 273, IPv6 address should be wrapped with []
                     # when used as Host header
-
-                    if host.find(':') >= 0:
-                        host_enc = b'[' + host_enc + b']'
+                    host_enc = self._wrap_ipv6(host_enc)
+                    if ":" in host:
+                        host_enc = _strip_ipv6_iface(host_enc)
 
                     if port == self.default_port:
                         self.putheader('Host', host_enc)
@@ -1400,46 +1476,15 @@ class HTTPSConnection(HTTPConnection):
 
         default_port = HTTPS_PORT
 
-        # XXX Should key_file and cert_file be deprecated in favour of context?
-
-        def __init__(self, host, port=None, key_file=None, cert_file=None,
-                     timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
-                     source_address=None, *, context=None,
-                     check_hostname=None, blocksize=8192):
+        def __init__(self, host, port=None,
+                     *, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
+                     source_address=None, context=None, blocksize=8192):
             super(HTTPSConnection, self).__init__(host, port, timeout,
                                                   source_address,
                                                   blocksize=blocksize)
-            if (key_file is not None or cert_file is not None or
-                        check_hostname is not None):
-                import warnings
-                warnings.warn("key_file, cert_file and check_hostname are "
-                              "deprecated, use a custom context instead.",
-                              DeprecationWarning, 2)
-            self.key_file = key_file
-            self.cert_file = cert_file
             if context is None:
-                context = ssl._create_default_https_context()
-                # send ALPN extension to indicate HTTP/1.1 protocol
-                if self._http_vsn == 11:
-                    context.set_alpn_protocols(['http/1.1'])
-                # enable PHA for TLS 1.3 connections if available
-                if context.post_handshake_auth is not None:
-                    context.post_handshake_auth = True
-            will_verify = context.verify_mode != ssl.CERT_NONE
-            if check_hostname is None:
-                check_hostname = context.check_hostname
-            if check_hostname and not will_verify:
-                raise ValueError("check_hostname needs a SSL context with "
-                                 "either CERT_OPTIONAL or CERT_REQUIRED")
-            if key_file or cert_file:
-                context.load_cert_chain(cert_file, key_file)
-                # cert and key file means the user wants to authenticate.
-                # enable TLS 1.3 PHA implicitly even for custom contexts.
-                if context.post_handshake_auth is not None:
-                    context.post_handshake_auth = True
+                context = _create_https_context(self._http_vsn)
             self._context = context
-            if check_hostname is not None:
-                self._context.check_hostname = check_hostname
 
         def connect(self):
             "Connect to a host on a given (SSL) port."
diff --git a/Lib/http/cookiejar.py b/Lib/http/cookiejar.py
index 685f6a0b97..9a2f0fb851 100644
--- a/Lib/http/cookiejar.py
+++ b/Lib/http/cookiejar.py
@@ -34,10 +34,7 @@
 import re
 import time
 import urllib.parse, urllib.request
-try:
-    import threading as _threading
-except ImportError:
-    import dummy_threading as _threading
+import threading as _threading
 import http.client  # only for the default HTTP port
 from calendar import timegm
 
@@ -92,8 +89,7 @@ def _timegm(tt):
 DAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
 MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-MONTHS_LOWER = []
-for month in MONTHS: MONTHS_LOWER.append(month.lower())
+MONTHS_LOWER = [month.lower() for month in MONTHS]
 
 def time2isoz(t=None):
     """Return a string representing time in seconds since epoch, t.
@@ -108,9 +104,9 @@ def time2isoz(t=None):
 
     """
     if t is None:
-        dt = datetime.datetime.utcnow()
+        dt = datetime.datetime.now(tz=datetime.UTC)
     else:
-        dt = datetime.datetime.utcfromtimestamp(t)
+        dt = datetime.datetime.fromtimestamp(t, tz=datetime.UTC)
     return "%04d-%02d-%02d %02d:%02d:%02dZ" % (
         dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
 
@@ -126,9 +122,9 @@ def time2netscape(t=None):
 
     """
     if t is None:
-        dt = datetime.datetime.utcnow()
+        dt = datetime.datetime.now(tz=datetime.UTC)
     else:
-        dt = datetime.datetime.utcfromtimestamp(t)
+        dt = datetime.datetime.fromtimestamp(t, tz=datetime.UTC)
     return "%s, %02d-%s-%04d %02d:%02d:%02d GMT" % (
         DAYS[dt.weekday()], dt.day, MONTHS[dt.month-1],
         dt.year, dt.hour, dt.minute, dt.second)
@@ -434,6 +430,7 @@ def split_header_words(header_values):
         if pairs: result.append(pairs)
     return result
 
+HEADER_JOIN_TOKEN_RE = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
 HEADER_JOIN_ESCAPE_RE = re.compile(r"([\"\\])")
 def join_header_words(lists):
     """Do the inverse (almost) of the conversion done by split_header_words.
@@ -441,10 +438,10 @@ def join_header_words(lists):
     Takes a list of lists of (key, value) pairs and produces a single header
     value.  Attribute values are quoted if needed.
 
-    >>> join_header_words([[("text/plain", None), ("charset", "iso-8859-1")]])
-    'text/plain; charset="iso-8859-1"'
-    >>> join_header_words([[("text/plain", None)], [("charset", "iso-8859-1")]])
-    'text/plain, charset="iso-8859-1"'
+    >>> join_header_words([[("text/plain", None), ("charset", "iso-8859/1")]])
+    'text/plain; charset="iso-8859/1"'
+    >>> join_header_words([[("text/plain", None)], [("charset", "iso-8859/1")]])
+    'text/plain, charset="iso-8859/1"'
 
     """
     headers = []
@@ -452,7 +449,7 @@ def join_header_words(lists):
         attr = []
         for k, v in pairs:
             if v is not None:
-                if not re.search(r"^\w+$", v):
+                if not HEADER_JOIN_TOKEN_RE.fullmatch(v):
                     v = HEADER_JOIN_ESCAPE_RE.sub(r"\\\1", v)  # escape " and \
                     v = '"%s"' % v
                 k = "%s=%s" % (k, v)
@@ -644,7 +641,7 @@ def eff_request_host(request):
 
     """
     erhn = req_host = request_host(request)
-    if req_host.find(".") == -1 and not IPV4_RE.search(req_host):
+    if "." not in req_host:
         erhn = req_host + ".local"
     return req_host, erhn
 
@@ -1047,12 +1044,13 @@ def set_ok_domain(self, cookie, request):
             else:
                 undotted_domain = domain
             embedded_dots = (undotted_domain.find(".") >= 0)
-            if not embedded_dots and domain != ".local":
+            if not embedded_dots and not erhn.endswith(".local"):
                 _debug("   non-local domain %s contains no embedded dot",
                        domain)
                 return False
             if cookie.version == 0:
-                if (not erhn.endswith(domain) and
+                if (not (erhn.endswith(domain) or
+                         erhn.endswith(f"{undotted_domain}.local")) and
                     (not erhn.startswith(".") and
                      not ("."+erhn).endswith(domain))):
                     _debug("   effective request-host %s (even with added "
@@ -1227,14 +1225,9 @@ def path_return_ok(self, path, request):
         _debug("  %s does not path-match %s", req_path, path)
         return False
 
-def vals_sorted_by_key(adict):
-    keys = sorted(adict.keys())
-    return map(adict.get, keys)
-
 def deepvalues(mapping):
-    """Iterates over nested mapping, depth-first, in sorted order by key."""
-    values = vals_sorted_by_key(mapping)
-    for obj in values:
+    """Iterates over nested mapping, depth-first"""
+    for obj in list(mapping.values()):
         mapping = False
         try:
             obj.items
@@ -1898,7 +1891,10 @@ def save(self, filename=None, ignore_discard=False, ignore_expires=False):
             if self.filename is not None: filename = self.filename
             else: raise ValueError(MISSING_FILENAME_TEXT)
 
-        with open(filename, "w") as f:
+        with os.fdopen(
+            os.open(filename, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600),
+            'w',
+        ) as f:
             # There really isn't an LWP Cookies 2.0 format, but this indicates
             # that there is extra information in here (domain_dot and
             # port_spec) while still being compatible with libwww-perl, I hope.
@@ -1923,9 +1919,7 @@ def _really_load(self, f, filename, ignore_discard, ignore_expires):
                        "comment", "commenturl")
 
         try:
-            while 1:
-                line = f.readline()
-                if line == "": break
+            while (line := f.readline()) != "":
                 if not line.startswith(header):
                     continue
                 line = line[len(header):].strip()
@@ -1993,7 +1987,7 @@ class MozillaCookieJar(FileCookieJar):
 
     This class differs from CookieJar only in the format it uses to save and
     load cookies to and from a file.  This class uses the Mozilla/Netscape
-    `cookies.txt' format.  lynx uses this file format, too.
+    `cookies.txt' format.  curl and lynx use this file format, too.
 
     Don't expect cookies saved while the browser is running to be noticed by
     the browser (in fact, Mozilla on unix will overwrite your saved cookies if
@@ -2025,12 +2019,9 @@ def _really_load(self, f, filename, ignore_discard, ignore_expires):
                 filename)
 
         try:
-            while 1:
-                line = f.readline()
+            while (line := f.readline()) != "":
                 rest = {}
 
-                if line == "": break
-
                 # httponly is a cookie flag as defined in rfc6265
                 # when encoded in a netscape cookie file,
                 # the line is prepended with "#HttpOnly_"
@@ -2094,7 +2085,10 @@ def save(self, filename=None, ignore_discard=False, ignore_expires=False):
             if self.filename is not None: filename = self.filename
             else: raise ValueError(MISSING_FILENAME_TEXT)
 
-        with open(filename, "w") as f:
+        with os.fdopen(
+            os.open(filename, os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600),
+            'w',
+        ) as f:
             f.write(NETSCAPE_HEADER_TEXT)
             now = time.time()
             for cookie in self:
diff --git a/Lib/http/cookies.py b/Lib/http/cookies.py
index 35ac2dc6ae..57791c6ab0 100644
--- a/Lib/http/cookies.py
+++ b/Lib/http/cookies.py
@@ -184,8 +184,13 @@ def _quote(str):
         return '"' + str.translate(_Translator) + '"'
 
 
-_OctalPatt = re.compile(r"\\[0-3][0-7][0-7]")
-_QuotePatt = re.compile(r"[\\].")
+_unquote_sub = re.compile(r'\\(?:([0-3][0-7][0-7])|(.))').sub
+
+def _unquote_replace(m):
+    if m[1]:
+        return chr(int(m[1], 8))
+    else:
+        return m[2]
 
 def _unquote(str):
     # If there aren't any doublequotes,
@@ -205,36 +210,13 @@ def _unquote(str):
     #    \012 --> \n
     #    \"   --> "
     #
-    i = 0
-    n = len(str)
-    res = []
-    while 0 <= i < n:
-        o_match = _OctalPatt.search(str, i)
-        q_match = _QuotePatt.search(str, i)
-        if not o_match and not q_match:              # Neither matched
-            res.append(str[i:])
-            break
-        # else:
-        j = k = -1
-        if o_match:
-            j = o_match.start(0)
-        if q_match:
-            k = q_match.start(0)
-        if q_match and (not o_match or k < j):     # QuotePatt matched
-            res.append(str[i:k])
-            res.append(str[k+1])
-            i = k + 2
-        else:                                      # OctalPatt matched
-            res.append(str[i:j])
-            res.append(chr(int(str[j+1:j+4], 8)))
-            i = j + 4
-    return _nulljoin(res)
+    return _unquote_sub(_unquote_replace, str)
 
 # The _getdate() routine is used to set the expiration time in the cookie's HTTP
 # header.  By default, _getdate() returns the current time in the appropriate
 # "expires" format for a Set-Cookie header.  The one optional argument is an
 # offset from now, in seconds.  For example, an offset of -3600 means "one hour
-# ago".  The offset may be a floating point number.
+# ago".  The offset may be a floating-point number.
 #
 
 _weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
@@ -442,9 +424,11 @@ def OutputString(self, attrs=None):
     (                              # Optional group: there may not be a value.
     \s*=\s*                          # Equal Sign
     (?P<val>                         # Start of group 'val'
-    "(?:[^\\"]|\\.)*"                  # Any doublequoted string
+    "(?:[^\\"]|\\.)*"                  # Any double-quoted string
     |                                  # or
-    \w{3},\s[\w\d\s-]{9,11}\s[\d:]{8}\sGMT  # Special case for "expires" attr
+    # Special case for "expires" attr
+    (\w{3,6}day|\w{3}),\s              # Day of the week or abbreviated day
+    [\w\d\s-]{9,11}\s[\d:]{8}\sGMT     # Date and time in specific format
     |                                  # or
     [""" + _LegalValueChars + r"""]*      # Any word or empty string
     )                                # End of group 'val'
diff --git a/Lib/http/server.py b/Lib/http/server.py
index 58abadf737..0ec479003a 100644
--- a/Lib/http/server.py
+++ b/Lib/http/server.py
@@ -2,18 +2,18 @@
 
 Note: BaseHTTPRequestHandler doesn't implement any HTTP request; see
 SimpleHTTPRequestHandler for simple implementations of GET, HEAD and POST,
-and CGIHTTPRequestHandler for CGI scripts.
+and (deprecated) CGIHTTPRequestHandler for CGI scripts.
 
-It does, however, optionally implement HTTP/1.1 persistent connections,
-as of version 0.3.
+It does, however, optionally implement HTTP/1.1 persistent connections.
 
 Notes on CGIHTTPRequestHandler
 ------------------------------
 
-This class implements GET and POST requests to cgi-bin scripts.
+This class is deprecated. It implements GET and POST requests to cgi-bin scripts.
 
-If the os.fork() function is not present (e.g. on Windows),
-subprocess.Popen() is used as a fallback, with slightly altered semantics.
+If the os.fork() function is not present (Windows), subprocess.Popen() is used,
+with slightly altered but never documented semantics.  Use from a threaded
+process is likely to trigger a warning at os.fork() time.
 
 In all cases, the implementation is intentionally naive -- all
 requests are executed synchronously.
@@ -93,6 +93,7 @@
 import html
 import http.client
 import io
+import itertools
 import mimetypes
 import os
 import posixpath
@@ -109,11 +110,10 @@
 
 # Default error message template
 DEFAULT_ERROR_MESSAGE = """\
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
-        "http://www.w3.org/TR/html4/strict.dtd">
-<html>
+<!DOCTYPE HTML>
+<html lang="en">
     <head>
-        <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
+        <meta charset="utf-8">
         <title>Error response</title>
     </head>
     <body>
@@ -127,6 +127,10 @@
 
 DEFAULT_ERROR_CONTENT_TYPE = "text/html;charset=utf-8"
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
+
 class HTTPServer(socketserver.TCPServer):
 
     allow_reuse_address = 1    # Seems to make sense in testing environment
@@ -275,6 +279,7 @@ def parse_request(self):
         error response has already been sent back.
 
         """
+        is_http_0_9 = False
         self.command = None  # set in case of error on the first line
         self.request_version = version = self.default_request_version
         self.close_connection = True
@@ -300,6 +305,10 @@ def parse_request(self):
                 #   - Leading zeros MUST be ignored by recipients.
                 if len(version_number) != 2:
                     raise ValueError
+                if any(not component.isdigit() for component in version_number):
+                    raise ValueError("non digit in http version")
+                if any(len(component) > 10 for component in version_number):
+                    raise ValueError("unreasonable length http version")
                 version_number = int(version_number[0]), int(version_number[1])
             except (ValueError, IndexError):
                 self.send_error(
@@ -328,8 +337,21 @@ def parse_request(self):
                     HTTPStatus.BAD_REQUEST,
                     "Bad HTTP/0.9 request type (%r)" % command)
                 return False
+            is_http_0_9 = True
         self.command, self.path = command, path
 
+        # gh-87389: The purpose of replacing '//' with '/' is to protect
+        # against open redirect attacks possibly triggered if the path starts
+        # with '//' because http clients treat //path as an absolute URI
+        # without scheme (similar to http://path) rather than a path.
+        if self.path.startswith('//'):
+            self.path = '/' + self.path.lstrip('/')  # Reduce to a single /
+
+        # For HTTP/0.9, headers are not expected at all.
+        if is_http_0_9:
+            self.headers = {}
+            return True
+
         # Examine the headers and look for a Connection directive.
         try:
             self.headers = http.client.parse_headers(self.rfile,
@@ -556,6 +578,11 @@ def log_error(self, format, *args):
 
         self.log_message(format, *args)
 
+    # https://en.wikipedia.org/wiki/List_of_Unicode_characters#Control_codes
+    _control_char_table = str.maketrans(
+            {c: fr'\x{c:02x}' for c in itertools.chain(range(0x20), range(0x7f,0xa0))})
+    _control_char_table[ord('\\')] = r'\\'
+
     def log_message(self, format, *args):
         """Log an arbitrary message.
 
@@ -571,12 +598,16 @@ def log_message(self, format, *args):
         The client ip and current date/time are prefixed to
         every message.
 
+        Unicode control characters are replaced with escaped hex
+        before writing the output to stderr.
+
         """
 
+        message = format % args
         sys.stderr.write("%s - - [%s] %s\n" %
                          (self.address_string(),
                           self.log_date_time_string(),
-                          format%args))
+                          message.translate(self._control_char_table)))
 
     def version_string(self):
         """Return the server software version string."""
@@ -637,6 +668,7 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
     """
 
     server_version = "SimpleHTTP/" + __version__
+    index_pages = ("index.html", "index.htm")
     extensions_map = _encodings_map_default = {
         '.gz': 'application/gzip',
         '.Z': 'application/octet-stream',
@@ -680,7 +712,7 @@ def send_head(self):
         f = None
         if os.path.isdir(path):
             parts = urllib.parse.urlsplit(self.path)
-            if not parts.path.endswith('/'):
+            if not parts.path.endswith(('/', '%2f', '%2F')):
                 # redirect browser - doing basically what apache does
                 self.send_response(HTTPStatus.MOVED_PERMANENTLY)
                 new_parts = (parts[0], parts[1], parts[2] + '/',
@@ -690,9 +722,9 @@ def send_head(self):
                 self.send_header("Content-Length", "0")
                 self.end_headers()
                 return None
-            for index in "index.html", "index.htm":
+            for index in self.index_pages:
                 index = os.path.join(path, index)
-                if os.path.exists(index):
+                if os.path.isfile(index):
                     path = index
                     break
             else:
@@ -702,7 +734,7 @@ def send_head(self):
         # The test for this was added in test_httpserver.py
         # However, some OS platforms accept a trailingSlash as a filename
         # See discussion on python-dev and Issue34711 regarding
-        # parseing and rejection of filenames with a trailing slash
+        # parsing and rejection of filenames with a trailing slash
         if path.endswith("/"):
             self.send_error(HTTPStatus.NOT_FOUND, "File not found")
             return None
@@ -770,21 +802,23 @@ def list_directory(self, path):
             return None
         list.sort(key=lambda a: a.lower())
         r = []
+        displaypath = self.path
+        displaypath = displaypath.split('#', 1)[0]
+        displaypath = displaypath.split('?', 1)[0]
         try:
-            displaypath = urllib.parse.unquote(self.path,
+            displaypath = urllib.parse.unquote(displaypath,
                                                errors='surrogatepass')
         except UnicodeDecodeError:
-            displaypath = urllib.parse.unquote(path)
+            displaypath = urllib.parse.unquote(displaypath)
         displaypath = html.escape(displaypath, quote=False)
         enc = sys.getfilesystemencoding()
-        title = 'Directory listing for %s' % displaypath
-        r.append('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" '
-                 '"http://www.w3.org/TR/html4/strict.dtd">')
-        r.append('<html>\n<head>')
-        r.append('<meta http-equiv="Content-Type" '
-                 'content="text/html; charset=%s">' % enc)
-        r.append('<title>%s</title>\n</head>' % title)
-        r.append('<body>\n<h1>%s</h1>' % title)
+        title = f'Directory listing for {displaypath}'
+        r.append('<!DOCTYPE HTML>')
+        r.append('<html lang="en">')
+        r.append('<head>')
+        r.append(f'<meta charset="{enc}">')
+        r.append(f'<title>{title}</title>\n</head>')
+        r.append(f'<body>\n<h1>{title}</h1>')
         r.append('<hr>\n<ul>')
         for name in list:
             fullname = os.path.join(path, name)
@@ -820,14 +854,14 @@ def translate_path(self, path):
 
         """
         # abandon query parameters
-        path = path.split('?',1)[0]
-        path = path.split('#',1)[0]
+        path = path.split('#', 1)[0]
+        path = path.split('?', 1)[0]
         # Don't forget explicit trailing slash when normalizing. Issue17324
-        trailing_slash = path.rstrip().endswith('/')
         try:
             path = urllib.parse.unquote(path, errors='surrogatepass')
         except UnicodeDecodeError:
             path = urllib.parse.unquote(path)
+        trailing_slash = path.endswith('/')
         path = posixpath.normpath(path)
         words = path.split('/')
         words = filter(None, words)
@@ -877,7 +911,7 @@ def guess_type(self, path):
         ext = ext.lower()
         if ext in self.extensions_map:
             return self.extensions_map[ext]
-        guess, _ = mimetypes.guess_type(path)
+        guess, _ = mimetypes.guess_file_type(path)
         if guess:
             return guess
         return 'application/octet-stream'
@@ -966,6 +1000,12 @@ class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
 
     """
 
+    def __init__(self, *args, **kwargs):
+        import warnings
+        warnings._deprecated("http.server.CGIHTTPRequestHandler",
+                             remove=(3, 15))
+        super().__init__(*args, **kwargs)
+
     # Determine platform specifics
     have_fork = hasattr(os, 'fork')
 
@@ -1078,7 +1118,7 @@ def run_cgi(self):
                     "CGI script is not executable (%r)" % scriptname)
                 return
 
-        # Reference: http://hoohoo.ncsa.uiuc.edu/cgi/env.html
+        # Reference: https://www6.uniovi.es/~antonio/ncsa_httpd/cgi/env.html
         # XXX Much of the following could be prepared ahead of time!
         env = copy.deepcopy(os.environ)
         env['SERVER_SOFTWARE'] = self.version_string()
@@ -1198,7 +1238,18 @@ def run_cgi(self):
                                  env = env
                                  )
             if self.command.lower() == "post" and nbytes > 0:
-                data = self.rfile.read(nbytes)
+                cursize = 0
+                data = self.rfile.read(min(nbytes, _MIN_READ_BUF_SIZE))
+                while len(data) < nbytes and len(data) != cursize:
+                    cursize = len(data)
+                    # This is a geometric increase in read size (never more
+                    # than doubling out the current length of data per loop
+                    # iteration).
+                    delta = min(cursize, nbytes - cursize)
+                    try:
+                        data += self.rfile.read(delta)
+                    except TimeoutError:
+                        break
             else:
                 data = None
             # throw away additional data [see bug #427345]
@@ -1258,15 +1309,19 @@ def test(HandlerClass=BaseHTTPRequestHandler,
     parser = argparse.ArgumentParser()
     parser.add_argument('--cgi', action='store_true',
                         help='run as CGI server')
-    parser.add_argument('--bind', '-b', metavar='ADDRESS',
-                        help='specify alternate bind address '
+    parser.add_argument('-b', '--bind', metavar='ADDRESS',
+                        help='bind to this address '
                              '(default: all interfaces)')
-    parser.add_argument('--directory', '-d', default=os.getcwd(),
-                        help='specify alternate directory '
+    parser.add_argument('-d', '--directory', default=os.getcwd(),
+                        help='serve this directory '
                              '(default: current directory)')
-    parser.add_argument('port', action='store', default=8000, type=int,
-                        nargs='?',
-                        help='specify alternate port (default: 8000)')
+    parser.add_argument('-p', '--protocol', metavar='VERSION',
+                        default='HTTP/1.0',
+                        help='conform to this HTTP version '
+                             '(default: %(default)s)')
+    parser.add_argument('port', default=8000, type=int, nargs='?',
+                        help='bind to this port '
+                             '(default: %(default)s)')
     args = parser.parse_args()
     if args.cgi:
         handler_class = CGIHTTPRequestHandler
@@ -1292,4 +1347,5 @@ def finish_request(self, request, client_address):
         ServerClass=DualStackServer,
         port=args.port,
         bind=args.bind,
+        protocol=args.protocol,
     )
diff --git a/Lib/importlib/__init__.py b/Lib/importlib/__init__.py
index 707c081cb2..a7d57561ea 100644
--- a/Lib/importlib/__init__.py
+++ b/Lib/importlib/__init__.py
@@ -54,8 +54,6 @@
 # Fully bootstrapped at this point, import whatever you like, circular
 # dependencies and startup overhead minimisation permitting :)
 
-import warnings
-
 
 # Public API #########################################################
 
@@ -105,7 +103,7 @@ def reload(module):
         try:
             name = module.__name__
         except AttributeError:
-            raise TypeError("reload() argument must be a module")
+            raise TypeError("reload() argument must be a module") from None
 
     if sys.modules.get(name) is not module:
         raise ImportError(f"module {name} not in sys.modules", name=name)
diff --git a/Lib/importlib/_bootstrap.py b/Lib/importlib/_bootstrap.py
index 093a0b8245..68d993caca 100644
--- a/Lib/importlib/_bootstrap.py
+++ b/Lib/importlib/_bootstrap.py
@@ -53,7 +53,7 @@ def _new_module(name):
 
 # For a list that can have a weakref to it.
 class _List(list):
-    pass
+    __slots__ = ("__weakref__",)
 
 
 # Copied from weakref.py with some simplifications and modifications unique to
@@ -527,7 +527,7 @@ def _load_module_shim(self, fullname):
 
     """
     msg = ("the load_module() method is deprecated and slated for removal in "
-          "Python 3.12; use exec_module() instead")
+           "Python 3.15; use exec_module() instead")
     _warnings.warn(msg, DeprecationWarning)
     spec = spec_from_loader(fullname, self)
     if fullname in sys.modules:
@@ -825,10 +825,16 @@ def _module_repr_from_spec(spec):
     """Return the repr to use for the module."""
     name = '?' if spec.name is None else spec.name
     if spec.origin is None:
-        if spec.loader is None:
+        loader = spec.loader
+        if loader is None:
             return f'<module {name!r}>'
+        elif (
+            _bootstrap_external is not None
+            and isinstance(loader, _bootstrap_external.NamespaceLoader)
+        ):
+            return f'<module {name!r} (namespace) from {list(loader._path)}>'
         else:
-            return f'<module {name!r} (namespace) from {list(spec.loader._path)}>'
+            return f'<module {name!r} ({loader!r})>'
     else:
         if spec.has_location:
             return f'<module {name!r} from {spec.origin!r}>'
@@ -1129,7 +1135,7 @@ def find_spec(cls, fullname, path=None, target=None):
         # part of the importer), instead of here (the finder part).
         # The loader is the usual place to get the data that will
         # be loaded into the module.  (For example, see _LoaderBasics
-        # in _bootstra_external.py.)  Most importantly, this importer
+        # in _bootstrap_external.py.)  Most importantly, this importer
         # is simpler if we wait to get the data.
         # However, getting as much data in the finder as possible
         # to later load the module is okay, and sometimes important.
diff --git a/Lib/importlib/_bootstrap_external.py b/Lib/importlib/_bootstrap_external.py
index 73ac4405cb..ca73eb2fcf 100644
--- a/Lib/importlib/_bootstrap_external.py
+++ b/Lib/importlib/_bootstrap_external.py
@@ -52,7 +52,7 @@
 
 # Bootstrap-related code ######################################################
 _CASE_INSENSITIVE_PLATFORMS_STR_KEY = 'win',
-_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY = 'cygwin', 'darwin'
+_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY = 'cygwin', 'darwin', 'ios', 'tvos', 'watchos'
 _CASE_INSENSITIVE_PLATFORMS =  (_CASE_INSENSITIVE_PLATFORMS_BYTES_KEY
                                 + _CASE_INSENSITIVE_PLATFORMS_STR_KEY)
 
@@ -81,6 +81,11 @@ def _pack_uint32(x):
     return (int(x) & 0xFFFFFFFF).to_bytes(4, 'little')
 
 
+def _unpack_uint64(data):
+    """Convert 8 bytes in little-endian to an integer."""
+    assert len(data) == 8
+    return int.from_bytes(data, 'little')
+
 def _unpack_uint32(data):
     """Convert 4 bytes in little-endian to an integer."""
     assert len(data) == 4
@@ -203,7 +208,7 @@ def _write_atomic(path, data, mode=0o666):
     try:
         # We first write data to a temporary file, and then use os.replace() to
         # perform an atomic rename.
-        with _io.FileIO(fd, 'wb') as file:
+        with _io.open(fd, 'wb') as file:
             file.write(data)
         _os.replace(path_tmp, path)
     except OSError:
@@ -413,6 +418,7 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.11a7 3492 (make POP_JUMP_IF_NONE/NOT_NONE/TRUE/FALSE relative)
 #     Python 3.11a7 3493 (Make JUMP_IF_TRUE_OR_POP/JUMP_IF_FALSE_OR_POP relative)
 #     Python 3.11a7 3494 (New location info table)
+#     Python 3.11b4 3495 (Set line number of module's RESUME instr to 0 per PEP 626)
 #     Python 3.12a1 3500 (Remove PRECALL opcode)
 #     Python 3.12a1 3501 (YIELD_VALUE oparg == stack_depth)
 #     Python 3.12a1 3502 (LOAD_FAST_CHECK, no NULL-check in LOAD_FAST)
@@ -445,8 +451,30 @@ def _write_atomic(path, data, mode=0o666):
 #     Python 3.12b1 3529 (Inline list/dict/set comprehensions)
 #     Python 3.12b1 3530 (Shrink the LOAD_SUPER_ATTR caches)
 #     Python 3.12b1 3531 (Add PEP 695 changes)
-
-#     Python 3.13 will start with 3550
+#     Python 3.13a1 3550 (Plugin optimizer support)
+#     Python 3.13a1 3551 (Compact superinstructions)
+#     Python 3.13a1 3552 (Remove LOAD_FAST__LOAD_CONST and LOAD_CONST__LOAD_FAST)
+#     Python 3.13a1 3553 (Add SET_FUNCTION_ATTRIBUTE)
+#     Python 3.13a1 3554 (more efficient bytecodes for f-strings)
+#     Python 3.13a1 3555 (generate specialized opcodes metadata from bytecodes.c)
+#     Python 3.13a1 3556 (Convert LOAD_CLOSURE to a pseudo-op)
+#     Python 3.13a1 3557 (Make the conversion to boolean in jumps explicit)
+#     Python 3.13a1 3558 (Reorder the stack items for CALL)
+#     Python 3.13a1 3559 (Generate opcode IDs from bytecodes.c)
+#     Python 3.13a1 3560 (Add RESUME_CHECK instruction)
+#     Python 3.13a1 3561 (Add cache entry to branch instructions)
+#     Python 3.13a1 3562 (Assign opcode IDs for internal ops in separate range)
+#     Python 3.13a1 3563 (Add CALL_KW and remove KW_NAMES)
+#     Python 3.13a1 3564 (Removed oparg from YIELD_VALUE, changed oparg values of RESUME)
+#     Python 3.13a1 3565 (Oparg of YIELD_VALUE indicates whether it is in a yield-from)
+#     Python 3.13a1 3566 (Emit JUMP_NO_INTERRUPT instead of JUMP for non-loop no-lineno cases)
+#     Python 3.13a1 3567 (Reimplement line number propagation by the compiler)
+#     Python 3.13a1 3568 (Change semantics of END_FOR)
+#     Python 3.13a5 3569 (Specialize CONTAINS_OP)
+#     Python 3.13a6 3570 (Add __firstlineno__ class attribute)
+#     Python 3.13b1 3571 (Fix miscompilation of private names in generic classes)
+
+#     Python 3.14 will start with 3600
 
 #     Please don't copy-paste the same pre-release tag for new entries above!!!
 #     You should always use the *upcoming* tag. For example, if 3.12a6 came out
@@ -461,7 +489,7 @@ def _write_atomic(path, data, mode=0o666):
 # Whenever MAGIC_NUMBER is changed, the ranges in the magic_values array
 # in PC/launcher.c must also be updated.
 
-MAGIC_NUMBER = (3531).to_bytes(2, 'little') + b'\r\n'
+MAGIC_NUMBER = (2997).to_bytes(2, 'little') + b'\r\n'
 
 _RAW_MAGIC_NUMBER = int.from_bytes(MAGIC_NUMBER, 'little')  # For import.c
 
@@ -535,7 +563,8 @@ def cache_from_source(path, debug_override=None, *, optimization=None):
         # Strip initial drive from a Windows path. We know we have an absolute
         # path here, so the second part of the check rules out a POSIX path that
         # happens to contain a colon at the second character.
-        if head[1] == ':' and head[0] not in path_separators:
+        # Slicing avoids issues with an empty (or short) `head`.
+        if head[1:2] == ':' and head[0:1] not in path_separators:
             head = head[2:]
 
         # Strip initial path separator from `head` to complete the conversion
@@ -1437,7 +1466,7 @@ class PathFinder:
     @staticmethod
     def invalidate_caches():
         """Call the invalidate_caches() method on all path entry finders
-        stored in sys.path_importer_caches (where implemented)."""
+        stored in sys.path_importer_cache (where implemented)."""
         for name, finder in list(sys.path_importer_cache.items()):
             # Drop entry if finder name is a relative path. The current
             # working directory may have changed.
@@ -1449,6 +1478,9 @@ def invalidate_caches():
         # https://bugs.python.org/issue45703
         _NamespacePath._epoch += 1
 
+        from importlib.metadata import MetadataPathFinder
+        MetadataPathFinder.invalidate_caches()
+
     @staticmethod
     def _path_hooks(path):
         """Search sys.path_hooks for a finder for 'path'."""
@@ -1690,6 +1722,52 @@ def __repr__(self):
         return f'FileFinder({self.path!r})'
 
 
+class AppleFrameworkLoader(ExtensionFileLoader):
+    """A loader for modules that have been packaged as frameworks for
+    compatibility with Apple's iOS App Store policies.
+    """
+    def create_module(self, spec):
+        # If the ModuleSpec has been created by the FileFinder, it will have
+        # been created with an origin pointing to the .fwork file. We need to
+        # redirect this to the location in the Frameworks folder, using the
+        # content of the .fwork file.
+        if spec.origin.endswith(".fwork"):
+            with _io.FileIO(spec.origin, 'r') as file:
+                framework_binary = file.read().decode().strip()
+            bundle_path = _path_split(sys.executable)[0]
+            spec.origin = _path_join(bundle_path, framework_binary)
+
+        # If the loader is created based on the spec for a loaded module, the
+        # path will be pointing at the Framework location. If this occurs,
+        # get the original .fwork location to use as the module's __file__.
+        if self.path.endswith(".fwork"):
+            path = self.path
+        else:
+            with _io.FileIO(self.path + ".origin", 'r') as file:
+                origin = file.read().decode().strip()
+                bundle_path = _path_split(sys.executable)[0]
+                path = _path_join(bundle_path, origin)
+
+        module = _bootstrap._call_with_frames_removed(_imp.create_dynamic, spec)
+
+        _bootstrap._verbose_message(
+            "Apple framework extension module {!r} loaded from {!r} (path {!r})",
+            spec.name,
+            spec.origin,
+            path,
+        )
+
+        # Ensure that the __file__ points at the .fwork location
+        try:
+            module.__file__ = path
+        except AttributeError:
+            # Not important enough to report.
+            # (The error is also ignored in _bootstrap._init_module_attrs or
+            # import_run_extension in import.c)
+            pass
+
+        return module
+
 # Import setup ###############################################################
 
 def _fix_up_module(ns, name, pathname, cpathname=None):
@@ -1722,10 +1800,17 @@ def _get_supported_file_loaders():
 
     Each item is a tuple (loader, suffixes).
     """
-    extensions = ExtensionFileLoader, _imp.extension_suffixes()
+    extension_loaders = []
+    if hasattr(_imp, 'create_dynamic'):
+        if sys.platform in {"ios", "tvos", "watchos"}:
+            extension_loaders = [(AppleFrameworkLoader, [
+                suffix.replace(".so", ".fwork")
+                for suffix in _imp.extension_suffixes()
+            ])]
+        extension_loaders.append((ExtensionFileLoader, _imp.extension_suffixes()))
     source = SourceFileLoader, SOURCE_SUFFIXES
     bytecode = SourcelessFileLoader, BYTECODE_SUFFIXES
-    return [extensions, source, bytecode]
+    return extension_loaders + [source, bytecode]
 
 
 def _set_bootstrap_module(_bootstrap_module):
diff --git a/Lib/importlib/abc.py b/Lib/importlib/abc.py
index b56fa94eb9..37fef357fe 100644
--- a/Lib/importlib/abc.py
+++ b/Lib/importlib/abc.py
@@ -180,7 +180,11 @@ def get_code(self, fullname):
         else:
             return self.source_to_code(source, path)
 
-_register(ExecutionLoader, machinery.ExtensionFileLoader)
+_register(
+    ExecutionLoader,
+    machinery.ExtensionFileLoader,
+    machinery.AppleFrameworkLoader,
+)
 
 
 class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader):
diff --git a/Lib/importlib/machinery.py b/Lib/importlib/machinery.py
index d9a19a13f7..fbd30b159f 100644
--- a/Lib/importlib/machinery.py
+++ b/Lib/importlib/machinery.py
@@ -12,6 +12,7 @@
 from ._bootstrap_external import SourceFileLoader
 from ._bootstrap_external import SourcelessFileLoader
 from ._bootstrap_external import ExtensionFileLoader
+from ._bootstrap_external import AppleFrameworkLoader
 from ._bootstrap_external import NamespaceLoader
 
 
diff --git a/Lib/importlib/metadata/__init__.py b/Lib/importlib/metadata/__init__.py
index 56ee403832..8ce62dd864 100644
--- a/Lib/importlib/metadata/__init__.py
+++ b/Lib/importlib/metadata/__init__.py
@@ -1,9 +1,13 @@
+from __future__ import annotations
+
 import os
 import re
 import abc
-import csv
 import sys
+import json
 import email
+import types
+import inspect
 import pathlib
 import zipfile
 import operator
@@ -12,11 +16,9 @@
 import functools
 import itertools
 import posixpath
-import contextlib
 import collections
-import inspect
 
-from . import _adapters, _meta
+from . import _meta
 from ._collections import FreezableDefaultDict, Pair
 from ._functools import method_cache, pass_none
 from ._itertools import always_iterable, unique_everseen
@@ -26,8 +28,7 @@
 from importlib import import_module
 from importlib.abc import MetaPathFinder
 from itertools import starmap
-from typing import List, Mapping, Optional, cast
-
+from typing import Any, Iterable, List, Mapping, Match, Optional, Set, cast
 
 __all__ = [
     'Distribution',
@@ -48,20 +49,14 @@
 class PackageNotFoundError(ModuleNotFoundError):
     """The package was not found."""
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"No package metadata was found for {self.name}"
 
     @property
-    def name(self):
+    def name(self) -> str:  # type: ignore[override]
         (name,) = self.args
         return name
 
-    # TODO: RUSTPYTHON; the entire setter is added to avoid errors
-    @name.setter
-    def name(self, value):
-        import sys
-        sys.stderr.write("set value to PackageNotFoundError ignored\n")
-
 
 class Sectioned:
     """
@@ -124,38 +119,11 @@ def read(text, filter_=None):
             yield Pair(name, value)
 
     @staticmethod
-    def valid(line):
+    def valid(line: str):
         return line and not line.startswith('#')
 
 
-class DeprecatedTuple:
-    """
-    Provide subscript item access for backward compatibility.
-
-    >>> recwarn = getfixture('recwarn')
-    >>> ep = EntryPoint(name='name', value='value', group='group')
-    >>> ep[:]
-    ('name', 'value', 'group')
-    >>> ep[0]
-    'name'
-    >>> len(recwarn)
-    1
-    """
-
-    # Do not remove prior to 2023-05-01 or Python 3.13
-    _warn = functools.partial(
-        warnings.warn,
-        "EntryPoint tuple interface is deprecated. Access members by name.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-
-    def __getitem__(self, item):
-        self._warn()
-        return self._key()[item]
-
-
-class EntryPoint(DeprecatedTuple):
+class EntryPoint:
     """An entry point as defined by Python packaging conventions.
 
     See `the packaging docs on entry points
@@ -197,34 +165,37 @@ class EntryPoint(DeprecatedTuple):
     value: str
     group: str
 
-    dist: Optional['Distribution'] = None
+    dist: Optional[Distribution] = None
 
-    def __init__(self, name, value, group):
+    def __init__(self, name: str, value: str, group: str) -> None:
         vars(self).update(name=name, value=value, group=group)
 
-    def load(self):
+    def load(self) -> Any:
         """Load the entry point from its definition. If only a module
         is indicated by the value, return that module. Otherwise,
         return the named object.
         """
-        match = self.pattern.match(self.value)
+        match = cast(Match, self.pattern.match(self.value))
         module = import_module(match.group('module'))
         attrs = filter(None, (match.group('attr') or '').split('.'))
         return functools.reduce(getattr, attrs, module)
 
     @property
-    def module(self):
+    def module(self) -> str:
         match = self.pattern.match(self.value)
+        assert match is not None
         return match.group('module')
 
     @property
-    def attr(self):
+    def attr(self) -> str:
         match = self.pattern.match(self.value)
+        assert match is not None
         return match.group('attr')
 
     @property
-    def extras(self):
+    def extras(self) -> List[str]:
         match = self.pattern.match(self.value)
+        assert match is not None
         return re.findall(r'\w+', match.group('extras') or '')
 
     def _for(self, dist):
@@ -272,7 +243,7 @@ def __repr__(self):
             f'group={self.group!r})'
         )
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self._key())
 
 
@@ -283,7 +254,7 @@ class EntryPoints(tuple):
 
     __slots__ = ()
 
-    def __getitem__(self, name):  # -> EntryPoint:
+    def __getitem__(self, name: str) -> EntryPoint:  # type: ignore[override]
         """
         Get the EntryPoint in self matching name.
         """
@@ -292,7 +263,14 @@ def __getitem__(self, name):  # -> EntryPoint:
         except StopIteration:
             raise KeyError(name)
 
-    def select(self, **params):
+    def __repr__(self):
+        """
+        Repr with classname and tuple constructor to
+        signal that we deviate from regular tuple behavior.
+        """
+        return '%s(%r)' % (self.__class__.__name__, tuple(self))
+
+    def select(self, **params) -> EntryPoints:
         """
         Select entry points from self that match the
         given parameters (typically group and/or name).
@@ -300,14 +278,14 @@ def select(self, **params):
         return EntryPoints(ep for ep in self if ep.matches(**params))
 
     @property
-    def names(self):
+    def names(self) -> Set[str]:
         """
         Return the set of all names of all entry points.
         """
         return {ep.name for ep in self}
 
     @property
-    def groups(self):
+    def groups(self) -> Set[str]:
         """
         Return the set of all groups of all entry points.
         """
@@ -328,28 +306,31 @@ def _from_text(text):
 class PackagePath(pathlib.PurePosixPath):
     """A reference to a path in a package"""
 
-    def read_text(self, encoding='utf-8'):
-        with self.locate().open(encoding=encoding) as stream:
-            return stream.read()
+    hash: Optional[FileHash]
+    size: int
+    dist: Distribution
+
+    def read_text(self, encoding: str = 'utf-8') -> str:  # type: ignore[override]
+        return self.locate().read_text(encoding=encoding)
 
-    def read_binary(self):
-        with self.locate().open('rb') as stream:
-            return stream.read()
+    def read_binary(self) -> bytes:
+        return self.locate().read_bytes()
 
-    def locate(self):
+    def locate(self) -> SimplePath:
         """Return a path-like object for this path"""
         return self.dist.locate_file(self)
 
 
 class FileHash:
-    def __init__(self, spec):
+    def __init__(self, spec: str) -> None:
         self.mode, _, self.value = spec.partition('=')
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<FileHash mode: {self.mode} value: {self.value}>'
 
 
 class DeprecatedNonAbstract:
+    # Required until Python 3.14
     def __new__(cls, *args, **kwargs):
         all_names = {
             name for subclass in inspect.getmro(cls) for name in vars(subclass)
@@ -369,25 +350,48 @@ def __new__(cls, *args, **kwargs):
 
 
 class Distribution(DeprecatedNonAbstract):
-    """A Python distribution package."""
+    """
+    An abstract Python distribution package.
+
+    Custom providers may derive from this class and define
+    the abstract methods to provide a concrete implementation
+    for their environment. Some providers may opt to override
+    the default implementation of some properties to bypass
+    the file-reading mechanism.
+    """
 
     @abc.abstractmethod
     def read_text(self, filename) -> Optional[str]:
         """Attempt to load metadata file given by the name.
 
+        Python distribution metadata is organized by blobs of text
+        typically represented as "files" in the metadata directory
+        (e.g. package-1.0.dist-info). These files include things
+        like:
+
+        - METADATA: The distribution metadata including fields
+          like Name and Version and Description.
+        - entry_points.txt: A series of entry points as defined in
+          `the entry points spec <https://packaging.python.org/en/latest/specifications/entry-points/#file-format>`_.
+        - RECORD: A record of files according to
+          `this recording spec <https://packaging.python.org/en/latest/specifications/recording-installed-packages/#the-record-file>`_.
+
+        A package may provide any set of files, including those
+        not listed here or none at all.
+
         :param filename: The name of the file in the distribution info.
         :return: The text if found, otherwise None.
         """
 
     @abc.abstractmethod
-    def locate_file(self, path):
+    def locate_file(self, path: str | os.PathLike[str]) -> SimplePath:
         """
-        Given a path to a file in this distribution, return a path
+        Given a path to a file in this distribution, return a SimplePath
         to it.
         """
 
     @classmethod
-    def from_name(cls, name: str):
+    def from_name(cls, name: str) -> Distribution:
         """Return the Distribution for the given package name.
 
         :param name: The name of the distribution package to search for.
@@ -400,21 +404,23 @@ def from_name(cls, name: str):
         if not name:
             raise ValueError("A distribution name is required.")
         try:
-            return next(cls.discover(name=name))
+            return next(iter(cls.discover(name=name)))
         except StopIteration:
             raise PackageNotFoundError(name)
 
     @classmethod
-    def discover(cls, **kwargs):
+    def discover(
+        cls, *, context: Optional[DistributionFinder.Context] = None, **kwargs
+    ) -> Iterable[Distribution]:
         """Return an iterable of Distribution objects for all packages.
 
         Pass a ``context`` or pass keyword arguments for constructing
         a context.
 
         :context: A ``DistributionFinder.Context`` object.
-        :return: Iterable of Distribution objects for all packages.
+        :return: Iterable of Distribution objects for packages matching
+          the context.
         """
-        context = kwargs.pop('context', None)
         if context and kwargs:
             raise ValueError("cannot accept context and kwargs")
         context = context or DistributionFinder.Context(**kwargs)
@@ -423,8 +429,8 @@ def discover(cls, **kwargs):
         )
 
     @staticmethod
-    def at(path):
-        """Return a Distribution for the indicated metadata path
+    def at(path: str | os.PathLike[str]) -> Distribution:
+        """Return a Distribution for the indicated metadata path.
 
         :param path: a string or path-like object
         :return: a concrete Distribution instance for the path
@@ -433,7 +439,7 @@ def at(path):
 
     @staticmethod
     def _discover_resolvers():
-        """Search the meta_path for resolvers."""
+        """Search the meta_path for resolvers (MetadataPathFinders)."""
         declared = (
             getattr(finder, 'find_distributions', None) for finder in sys.meta_path
         )
@@ -444,8 +450,15 @@ def metadata(self) -> _meta.PackageMetadata:
         """Return the parsed metadata for this Distribution.
 
         The returned object will have keys that name the various bits of
-        metadata.  See PEP 566 for details.
+        metadata per the
+        `Core metadata specifications <https://packaging.python.org/en/latest/specifications/core-metadata/#core-metadata>`_.
+
+        Custom providers may provide the METADATA file or override this
+        property.
         """
+        # deferred for performance (python/cpython#109829)
+        from . import _adapters
+
         opt_text = (
             self.read_text('METADATA')
             or self.read_text('PKG-INFO')
@@ -458,7 +471,7 @@ def metadata(self) -> _meta.PackageMetadata:
         return _adapters.Message(email.message_from_string(text))
 
     @property
-    def name(self):
+    def name(self) -> str:
         """Return the 'Name' metadata for the distribution package."""
         return self.metadata['Name']
 
@@ -468,16 +481,22 @@ def _normalized_name(self):
         return Prepared.normalize(self.name)
 
     @property
-    def version(self):
+    def version(self) -> str:
         """Return the 'Version' metadata for the distribution package."""
         return self.metadata['Version']
 
     @property
-    def entry_points(self):
+    def entry_points(self) -> EntryPoints:
+        """
+        Return EntryPoints for this distribution.
+
+        Custom providers may provide the ``entry_points.txt`` file
+        or override this property.
+        """
         return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self)
 
     @property
-    def files(self):
+    def files(self) -> Optional[List[PackagePath]]:
         """Files in this distribution.
 
         :return: List of PackagePath for this distribution or None
@@ -486,6 +505,10 @@ def files(self):
         (i.e. RECORD for dist-info, or installed-files.txt or
         SOURCES.txt for egg-info) is missing.
         Result may be empty if the metadata exists but is empty.
+
+        Custom providers are recommended to provide a "RECORD" file (in
+        ``read_text``) or override this property to allow for callers to be
+        able to resolve filenames provided by the package.
         """
 
         def make_file(name, hash=None, size_str=None):
@@ -497,6 +520,10 @@ def make_file(name, hash=None, size_str=None):
 
         @pass_none
         def make_files(lines):
+            # Delay csv import, since Distribution.files is not as widely used
+            # as other parts of importlib.metadata
+            import csv
+
             return starmap(make_file, csv.reader(lines))
 
         @pass_none
@@ -513,7 +540,7 @@ def skip_missing_files(package_paths):
 
     def _read_files_distinfo(self):
         """
-        Read the lines of RECORD
+        Read the lines of RECORD.
         """
         text = self.read_text('RECORD')
         return text and text.splitlines()
@@ -540,7 +567,7 @@ def _read_files_egginfo_installed(self):
         paths = (
             (subdir / name)
             .resolve()
-            .relative_to(self.locate_file('').resolve())
+            .relative_to(self.locate_file('').resolve(), walk_up=True)
             .as_posix()
             for name in text.splitlines()
         )
@@ -562,7 +589,7 @@ def _read_files_egginfo_sources(self):
         return text and map('"{}"'.format, text.splitlines())
 
     @property
-    def requires(self):
+    def requires(self) -> Optional[List[str]]:
         """Generated requirements specified for this Distribution"""
         reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
         return reqs and list(reqs)
@@ -613,10 +640,23 @@ def url_req_space(req):
             space = url_req_space(section.value)
             yield section.value + space + quoted_marker(section.name)
 
+    @property
+    def origin(self):
+        return self._load_json('direct_url.json')
+
+    def _load_json(self, filename):
+        return pass_none(json.loads)(
+            self.read_text(filename),
+            object_hook=lambda data: types.SimpleNamespace(**data),
+        )
+
 
 class DistributionFinder(MetaPathFinder):
     """
     A MetaPathFinder capable of discovering installed distributions.
+
+    Custom providers should implement this interface in order to
+    supply metadata.
     """
 
     class Context:
@@ -629,6 +669,17 @@ class Context:
         Each DistributionFinder may expect any parameters
         and should attempt to honor the canonical
         parameters defined below when appropriate.
+
+        This mechanism gives a custom provider a means to
+        solicit additional details from the caller beyond
+        "name" and "path" when searching distributions.
+        For example, imagine a provider that exposes suites
+        of packages in either a "public" or "private" ``realm``.
+        A caller may wish to query only for distributions in
+        a particular realm and could call
+        ``distributions(realm="private")`` to signal to the
+        custom provider to only include distributions from that
+        realm.
         """
 
         name = None
@@ -641,7 +692,7 @@ def __init__(self, **kwargs):
             vars(self).update(kwargs)
 
         @property
-        def path(self):
+        def path(self) -> List[str]:
             """
             The sequence of directory path that a distribution finder
             should search.
@@ -652,7 +703,7 @@ def path(self):
             return vars(self).get('path', sys.path)
 
     @abc.abstractmethod
-    def find_distributions(self, context=Context()):
+    def find_distributions(self, context=Context()) -> Iterable[Distribution]:
         """
         Find distributions.
 
@@ -664,11 +715,18 @@ def find_distributions(self, context=Context()):
 
 class FastPath:
     """
-    Micro-optimized class for searching a path for
-    children.
+    Micro-optimized class for searching a root for children.
+
+    Root is a path on the file system that may contain metadata
+    directories either as natural directories or within a zip file.
 
     >>> FastPath('').children()
     ['...']
+
+    FastPath objects are cached and recycled for any given root.
+
+    >>> FastPath('foobar') is FastPath('foobar')
+    True
     """
 
     @functools.lru_cache()  # type: ignore
@@ -710,7 +768,19 @@ def lookup(self, mtime):
 
 
 class Lookup:
+    """
+    A micro-optimized class for searching a (fast) path for metadata.
+    """
+
     def __init__(self, path: FastPath):
+        """
+        Calculate all of the children representing metadata.
+
+        From the children in the path, calculate early all of the
+        children that appear to represent metadata (infos) or legacy
+        metadata (eggs).
+        """
+
         base = os.path.basename(path.root).lower()
         base_is_egg = base.endswith(".egg")
         self.infos = FreezableDefaultDict(list)
@@ -731,7 +801,10 @@ def __init__(self, path: FastPath):
         self.infos.freeze()
         self.eggs.freeze()
 
-    def search(self, prepared):
+    def search(self, prepared: Prepared):
+        """
+        Yield all infos and eggs matching the Prepared query.
+        """
         infos = (
             self.infos[prepared.normalized]
             if prepared
@@ -747,13 +820,28 @@ def search(self, prepared):
 
 class Prepared:
     """
-    A prepared search for metadata on a possibly-named package.
+    A prepared search query for metadata on a possibly-named package.
+
+    Pre-calculates the normalization to prevent repeated operations.
+
+    >>> none = Prepared(None)
+    >>> none.normalized
+    >>> none.legacy_normalized
+    >>> bool(none)
+    False
+    >>> sample = Prepared('Sample__Pkg-name.foo')
+    >>> sample.normalized
+    'sample_pkg_name_foo'
+    >>> sample.legacy_normalized
+    'sample__pkg_name.foo'
+    >>> bool(sample)
+    True
     """
 
     normalized = None
     legacy_normalized = None
 
-    def __init__(self, name):
+    def __init__(self, name: Optional[str]):
         self.name = name
         if name is None:
             return
@@ -781,7 +869,9 @@ def __bool__(self):
 
 class MetadataPathFinder(DistributionFinder):
     @classmethod
-    def find_distributions(cls, context=DistributionFinder.Context()):
+    def find_distributions(
+        cls, context=DistributionFinder.Context()
+    ) -> Iterable[PathDistribution]:
         """
         Find distributions.
 
@@ -801,19 +891,20 @@ def _search_paths(cls, name, paths):
             path.search(prepared) for path in map(FastPath, paths)
         )
 
-    def invalidate_caches(cls):
+    @classmethod
+    def invalidate_caches(cls) -> None:
         FastPath.__new__.cache_clear()
 
 
 class PathDistribution(Distribution):
-    def __init__(self, path: SimplePath):
+    def __init__(self, path: SimplePath) -> None:
         """Construct a distribution.
 
         :param path: SimplePath indicating the metadata directory.
         """
         self._path = path
 
-    def read_text(self, filename):
+    def read_text(self, filename: str | os.PathLike[str]) -> Optional[str]:
         with suppress(
             FileNotFoundError,
             IsADirectoryError,
@@ -823,9 +914,11 @@ def read_text(self, filename):
         ):
             return self._path.joinpath(filename).read_text(encoding='utf-8')
 
+        return None
+
     read_text.__doc__ = Distribution.read_text.__doc__
 
-    def locate_file(self, path):
+    def locate_file(self, path: str | os.PathLike[str]) -> SimplePath:
         return self._path.parent / path
 
     @property
@@ -858,7 +951,7 @@ def _name_from_stem(stem):
         return name
 
 
-def distribution(distribution_name):
+def distribution(distribution_name: str) -> Distribution:
     """Get the ``Distribution`` instance for the named package.
 
     :param distribution_name: The name of the distribution package as a string.
@@ -867,7 +960,7 @@ def distribution(distribution_name):
     return Distribution.from_name(distribution_name)
 
 
-def distributions(**kwargs):
+def distributions(**kwargs) -> Iterable[Distribution]:
     """Get all ``Distribution`` instances in the current environment.
 
     :return: An iterable of ``Distribution`` instances.
@@ -875,7 +968,7 @@ def distributions(**kwargs):
     return Distribution.discover(**kwargs)
 
 
-def metadata(distribution_name) -> _meta.PackageMetadata:
+def metadata(distribution_name: str) -> _meta.PackageMetadata:
     """Get the metadata for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -884,7 +977,7 @@ def metadata(distribution_name) -> _meta.PackageMetadata:
     return Distribution.from_name(distribution_name).metadata
 
 
-def version(distribution_name):
+def version(distribution_name: str) -> str:
     """Get the version string for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -918,7 +1011,7 @@ def entry_points(**params) -> EntryPoints:
     return EntryPoints(eps).select(**params)
 
 
-def files(distribution_name):
+def files(distribution_name: str) -> Optional[List[PackagePath]]:
     """Return a list of files for the named package.
 
     :param distribution_name: The name of the distribution package to query.
@@ -927,11 +1020,11 @@ def files(distribution_name):
     return distribution(distribution_name).files
 
 
-def requires(distribution_name):
+def requires(distribution_name: str) -> Optional[List[str]]:
     """
     Return a list of requirements for the named package.
 
-    :return: An iterator of requirements, suitable for
+    :return: An iterable of requirements, suitable for
         packaging.requirement.Requirement.
     """
     return distribution(distribution_name).requires
@@ -958,13 +1051,42 @@ def _top_level_declared(dist):
     return (dist.read_text('top_level.txt') or '').split()
 
 
+def _topmost(name: PackagePath) -> Optional[str]:
+    """
+    Return the top-most parent as long as there is a parent.
+    """
+    top, *rest = name.parts
+    return top if rest else None
+
+
+def _get_toplevel_name(name: PackagePath) -> str:
+    """
+    Infer a possibly importable module name from a name presumed on
+    sys.path.
+
+    >>> _get_toplevel_name(PackagePath('foo.py'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo.pyc'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo/__init__.py'))
+    'foo'
+    >>> _get_toplevel_name(PackagePath('foo.pth'))
+    'foo.pth'
+    >>> _get_toplevel_name(PackagePath('foo.dist-info'))
+    'foo.dist-info'
+    """
+    return _topmost(name) or (
+        # python/typeshed#10328
+        inspect.getmodulename(name)  # type: ignore
+        or str(name)
+    )
+
+
 def _top_level_inferred(dist):
-    opt_names = {
-        f.parts[0] if len(f.parts) > 1 else inspect.getmodulename(f)
-        for f in always_iterable(dist.files)
-    }
+    opt_names = set(map(_get_toplevel_name, always_iterable(dist.files)))
 
-    @pass_none
     def importable_name(name):
         return '.' not in name
 
diff --git a/Lib/importlib/metadata/_adapters.py b/Lib/importlib/metadata/_adapters.py
index 6aed69a308..5911688089 100644
--- a/Lib/importlib/metadata/_adapters.py
+++ b/Lib/importlib/metadata/_adapters.py
@@ -53,7 +53,7 @@ def __iter__(self):
     def __getitem__(self, item):
         """
         Warn users that a ``KeyError`` can be expected when a
-        mising key is supplied. Ref python/importlib_metadata#371.
+        missing key is supplied. Ref python/importlib_metadata#371.
         """
         res = super().__getitem__(item)
         if res is None:
diff --git a/Lib/importlib/metadata/_meta.py b/Lib/importlib/metadata/_meta.py
index c9a7ef906a..1927d0f624 100644
--- a/Lib/importlib/metadata/_meta.py
+++ b/Lib/importlib/metadata/_meta.py
@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import os
 from typing import Protocol
 from typing import Any, Dict, Iterator, List, Optional, TypeVar, Union, overload
 
@@ -6,30 +9,27 @@
 
 
 class PackageMetadata(Protocol):
-    def __len__(self) -> int:
-        ...  # pragma: no cover
+    def __len__(self) -> int: ...  # pragma: no cover
 
-    def __contains__(self, item: str) -> bool:
-        ...  # pragma: no cover
+    def __contains__(self, item: str) -> bool: ...  # pragma: no cover
 
-    def __getitem__(self, key: str) -> str:
-        ...  # pragma: no cover
+    def __getitem__(self, key: str) -> str: ...  # pragma: no cover
 
-    def __iter__(self) -> Iterator[str]:
-        ...  # pragma: no cover
+    def __iter__(self) -> Iterator[str]: ...  # pragma: no cover
 
     @overload
-    def get(self, name: str, failobj: None = None) -> Optional[str]:
-        ...  # pragma: no cover
+    def get(
+        self, name: str, failobj: None = None
+    ) -> Optional[str]: ...  # pragma: no cover
 
     @overload
-    def get(self, name: str, failobj: _T) -> Union[str, _T]:
-        ...  # pragma: no cover
+    def get(self, name: str, failobj: _T) -> Union[str, _T]: ...  # pragma: no cover
 
     # overload per python/importlib_metadata#435
     @overload
-    def get_all(self, name: str, failobj: None = None) -> Optional[List[Any]]:
-        ...  # pragma: no cover
+    def get_all(
+        self, name: str, failobj: None = None
+    ) -> Optional[List[Any]]: ...  # pragma: no cover
 
     @overload
     def get_all(self, name: str, failobj: _T) -> Union[List[Any], _T]:
@@ -44,20 +44,24 @@ def json(self) -> Dict[str, Union[str, List[str]]]:
         """
 
 
-class SimplePath(Protocol[_T]):
+class SimplePath(Protocol):
     """
-    A minimal subset of pathlib.Path required by PathDistribution.
+    A minimal subset of pathlib.Path required by Distribution.
     """
 
-    def joinpath(self) -> _T:
-        ...  # pragma: no cover
+    def joinpath(
+        self, other: Union[str, os.PathLike[str]]
+    ) -> SimplePath: ...  # pragma: no cover
 
-    def __truediv__(self, other: Union[str, _T]) -> _T:
-        ...  # pragma: no cover
+    def __truediv__(
+        self, other: Union[str, os.PathLike[str]]
+    ) -> SimplePath: ...  # pragma: no cover
 
     @property
-    def parent(self) -> _T:
-        ...  # pragma: no cover
+    def parent(self) -> SimplePath: ...  # pragma: no cover
+
+    def read_text(self, encoding=None) -> str: ...  # pragma: no cover
+
+    def read_bytes(self) -> bytes: ...  # pragma: no cover
 
-    def read_text(self) -> str:
-        ...  # pragma: no cover
+    def exists(self) -> bool: ...  # pragma: no cover
diff --git a/Lib/importlib/metadata/diagnose.py b/Lib/importlib/metadata/diagnose.py
new file mode 100644
index 0000000000..e405471ac4
--- /dev/null
+++ b/Lib/importlib/metadata/diagnose.py
@@ -0,0 +1,21 @@
+import sys
+
+from . import Distribution
+
+
+def inspect(path):
+    print("Inspecting", path)
+    dists = list(Distribution.discover(path=[path]))
+    if not dists:
+        return
+    print("Found", len(dists), "packages:", end=' ')
+    print(', '.join(dist.name for dist in dists))
+
+
+def run():
+    for path in sys.path:
+        inspect(path)
+
+
+if __name__ == '__main__':
+    run()
diff --git a/Lib/importlib/resources/__init__.py b/Lib/importlib/resources/__init__.py
index 34e3a9950c..723c9f9eb3 100644
--- a/Lib/importlib/resources/__init__.py
+++ b/Lib/importlib/resources/__init__.py
@@ -1,20 +1,27 @@
-"""Read resources contained within a package."""
+"""
+Read resources contained within a package.
+
+This codebase is shared between importlib.resources in the stdlib
+and importlib_resources in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
 
 from ._common import (
     as_file,
     files,
     Package,
+    Anchor,
 )
 
-from ._legacy import (
+from ._functional import (
     contents,
+    is_resource,
     open_binary,
-    read_binary,
     open_text,
-    read_text,
-    is_resource,
     path,
-    Resource,
+    read_binary,
+    read_text,
 )
 
 from .abc import ResourceReader
@@ -22,11 +29,11 @@
 
 __all__ = [
     'Package',
-    'Resource',
+    'Anchor',
     'ResourceReader',
     'as_file',
-    'contents',
     'files',
+    'contents',
     'is_resource',
     'open_binary',
     'open_text',
diff --git a/Lib/importlib/resources/_common.py b/Lib/importlib/resources/_common.py
index b402e05116..d9128266a2 100644
--- a/Lib/importlib/resources/_common.py
+++ b/Lib/importlib/resources/_common.py
@@ -12,8 +12,6 @@
 from typing import Union, Optional, cast
 from .abc import ResourceReader, Traversable
 
-from ._adapters import wrap_spec
-
 Package = Union[types.ModuleType, str]
 Anchor = Package
 
@@ -27,6 +25,8 @@ def package_to_anchor(func):
     >>> files('a', 'b')
     Traceback (most recent call last):
     TypeError: files() takes from 0 to 1 positional arguments but 2 were given
+
+    Remove this compatibility in Python 3.14.
     """
     undefined = object()
 
@@ -66,10 +66,10 @@ def get_resource_reader(package: types.ModuleType) -> Optional[ResourceReader]:
     # zipimport.zipimporter does not support weak references, resulting in a
     # TypeError.  That seems terrible.
     spec = package.__spec__
-    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore
+    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore[union-attr]
     if reader is None:
         return None
-    return reader(spec.name)  # type: ignore
+    return reader(spec.name)  # type: ignore[union-attr]
 
 
 @functools.singledispatch
@@ -93,12 +93,13 @@ def _infer_caller():
     """
 
     def is_this_file(frame_info):
-        return frame_info.filename == __file__
+        return frame_info.filename == stack[0].filename
 
     def is_wrapper(frame_info):
         return frame_info.function == 'wrapper'
 
-    not_this_file = itertools.filterfalse(is_this_file, inspect.stack())
+    stack = inspect.stack()
+    not_this_file = itertools.filterfalse(is_this_file, stack)
     # also exclude 'wrapper' due to singledispatch in the call stack
     callers = itertools.filterfalse(is_wrapper, not_this_file)
     return next(callers).frame
@@ -109,6 +110,9 @@ def from_package(package: types.ModuleType):
     Return a Traversable object for the given package.
 
     """
+    # deferred for performance (python/cpython#109829)
+    from ._adapters import wrap_spec
+
     spec = wrap_spec(package)
     reader = spec.loader.get_resource_reader(spec.name)
     return reader.files()
diff --git a/Lib/importlib/resources/_functional.py b/Lib/importlib/resources/_functional.py
new file mode 100644
index 0000000000..f59416f2dd
--- /dev/null
+++ b/Lib/importlib/resources/_functional.py
@@ -0,0 +1,81 @@
+"""Simplified function-based API for importlib.resources"""
+
+import warnings
+
+from ._common import files, as_file
+
+
+_MISSING = object()
+
+
+def open_binary(anchor, *path_names):
+    """Open for binary reading the *resource* within *package*."""
+    return _get_resource(anchor, path_names).open('rb')
+
+
+def open_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Open for text reading the *resource* within *package*."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.open('r', encoding=encoding, errors=errors)
+
+
+def read_binary(anchor, *path_names):
+    """Read and return contents of *resource* within *package* as bytes."""
+    return _get_resource(anchor, path_names).read_bytes()
+
+
+def read_text(anchor, *path_names, encoding=_MISSING, errors='strict'):
+    """Read and return contents of *resource* within *package* as str."""
+    encoding = _get_encoding_arg(path_names, encoding)
+    resource = _get_resource(anchor, path_names)
+    return resource.read_text(encoding=encoding, errors=errors)
+
+
+def path(anchor, *path_names):
+    """Return the path to the *resource* as an actual file system path."""
+    return as_file(_get_resource(anchor, path_names))
+
+
+def is_resource(anchor, *path_names):
+    """Return ``True`` if there is a resource named *name* in the package,
+
+    Otherwise returns ``False``.
+    """
+    return _get_resource(anchor, path_names).is_file()
+
+
+def contents(anchor, *path_names):
+    """Return an iterable over the named resources within the package.
+
+    The iterable returns :class:`str` resources (e.g. files).
+    The iterable does not recurse into subdirectories.
+    """
+    warnings.warn(
+        "importlib.resources.contents is deprecated. "
+        "Use files(anchor).iterdir() instead.",
+        DeprecationWarning,
+        stacklevel=1,
+    )
+    return (resource.name for resource in _get_resource(anchor, path_names).iterdir())
+
+
+def _get_encoding_arg(path_names, encoding):
+    # For compatibility with versions where *encoding* was a positional
+    # argument, it needs to be given explicitly when there are multiple
+    # *path_names*.
+    # This limitation can be removed in Python 3.15.
+    if encoding is _MISSING:
+        if len(path_names) > 1:
+            raise TypeError(
+                "'encoding' argument required with multiple path names",
+            )
+        else:
+            return 'utf-8'
+    return encoding
+
+
+def _get_resource(anchor, path_names):
+    if anchor is None:
+        raise TypeError("anchor must be module or string, got None")
+    return files(anchor).joinpath(*path_names)
diff --git a/Lib/importlib/resources/readers.py b/Lib/importlib/resources/readers.py
index c3cdf769cb..70fc7e2b9c 100644
--- a/Lib/importlib/resources/readers.py
+++ b/Lib/importlib/resources/readers.py
@@ -1,8 +1,14 @@
+from __future__ import annotations
+
 import collections
+import contextlib
 import itertools
 import pathlib
 import operator
+import re
+import warnings
 import zipfile
+from collections.abc import Iterator
 
 from . import abc
 
@@ -31,8 +37,10 @@ def files(self):
 
 class ZipReader(abc.TraversableResources):
     def __init__(self, loader, module):
-        _, _, name = module.rpartition('.')
-        self.prefix = loader.prefix.replace('\\', '/') + name + '/'
+        self.prefix = loader.prefix.replace('\\', '/')
+        if loader.is_package(module):
+            _, _, name = module.rpartition('.')
+            self.prefix += name + '/'
         self.archive = loader.archive
 
     def open_resource(self, resource):
@@ -62,7 +70,7 @@ class MultiplexedPath(abc.Traversable):
     """
 
     def __init__(self, *paths):
-        self._paths = list(map(pathlib.Path, remove_duplicates(paths)))
+        self._paths = list(map(_ensure_traversable, remove_duplicates(paths)))
         if not self._paths:
             message = 'MultiplexedPath must contain at least one path'
             raise FileNotFoundError(message)
@@ -130,7 +138,40 @@ class NamespaceReader(abc.TraversableResources):
     def __init__(self, namespace_path):
         if 'NamespacePath' not in str(namespace_path):
             raise ValueError('Invalid path')
-        self.path = MultiplexedPath(*list(namespace_path))
+        self.path = MultiplexedPath(*filter(bool, map(self._resolve, namespace_path)))
+
+    @classmethod
+    def _resolve(cls, path_str) -> abc.Traversable | None:
+        r"""
+        Given an item from a namespace path, resolve it to a Traversable.
+
+        path_str might be a directory on the filesystem or a path to a
+        zipfile plus the path within the zipfile, e.g. ``/foo/bar`` or
+        ``/foo/baz.zip/inner_dir`` or ``foo\baz.zip\inner_dir\sub``.
+
+        path_str might also be a sentinel used by editable packages to
+        trigger other behaviors (see python/importlib_resources#311).
+        In that case, return None.
+        """
+        dirs = (cand for cand in cls._candidate_paths(path_str) if cand.is_dir())
+        return next(dirs, None)
+
+    @classmethod
+    def _candidate_paths(cls, path_str: str) -> Iterator[abc.Traversable]:
+        yield pathlib.Path(path_str)
+        yield from cls._resolve_zip_path(path_str)
+
+    @staticmethod
+    def _resolve_zip_path(path_str: str):
+        for match in reversed(list(re.finditer(r'[\\/]', path_str))):
+            with contextlib.suppress(
+                FileNotFoundError,
+                IsADirectoryError,
+                NotADirectoryError,
+                PermissionError,
+            ):
+                inner = path_str[match.end() :].replace('\\', '/') + '/'
+                yield zipfile.Path(path_str[: match.start()], inner.lstrip('/'))
 
     def resource_path(self, resource):
         """
@@ -142,3 +183,21 @@ def resource_path(self, resource):
 
     def files(self):
         return self.path
+
+
+def _ensure_traversable(path):
+    """
+    Convert deprecated string arguments to traversables (pathlib.Path).
+
+    Remove with Python 3.15.
+    """
+    if not isinstance(path, str):
+        return path
+
+    warnings.warn(
+        "String arguments are deprecated. Pass a Traversable instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+    return pathlib.Path(path)
diff --git a/Lib/importlib/resources/simple.py b/Lib/importlib/resources/simple.py
index 7770c922c8..2e75299b13 100644
--- a/Lib/importlib/resources/simple.py
+++ b/Lib/importlib/resources/simple.py
@@ -77,7 +77,7 @@ class ResourceHandle(Traversable):
 
     def __init__(self, parent: ResourceContainer, name: str):
         self.parent = parent
-        self.name = name  # type: ignore
+        self.name = name  # type: ignore[misc]
 
     def is_file(self):
         return True
@@ -88,7 +88,7 @@ def is_dir(self):
     def open(self, mode='r', *args, **kwargs):
         stream = self.parent.reader.open_binary(self.name)
         if 'b' not in mode:
-            stream = io.TextIOWrapper(*args, **kwargs)
+            stream = io.TextIOWrapper(stream, *args, **kwargs)
         return stream
 
     def joinpath(self, name):
diff --git a/Lib/importlib/util.py b/Lib/importlib/util.py
index f4d6e82331..284206b62f 100644
--- a/Lib/importlib/util.py
+++ b/Lib/importlib/util.py
@@ -135,7 +135,7 @@ class _incompatible_extension_module_restrictions:
     may not be imported in a subinterpreter.  That implies modules
     that do not implement multi-phase init or that explicitly of out.
 
-    Likewise for modules import in a subinterpeter with its own GIL
+    Likewise for modules import in a subinterpreter with its own GIL
     when the extension does not support a per-interpreter GIL.  This
     implies the module does not have a Py_mod_multiple_interpreters slot
     set to Py_MOD_PER_INTERPRETER_GIL_SUPPORTED.
@@ -145,7 +145,7 @@ class _incompatible_extension_module_restrictions:
 
     You can get the same effect as this function by implementing the
     basic interface of multi-phase init (PEP 489) and lying about
-    support for mulitple interpreters (or per-interpreter GIL).
+    support for multiple interpreters (or per-interpreter GIL).
     """
 
     def __init__(self, *, disable_check):
@@ -171,36 +171,57 @@ class _LazyModule(types.ModuleType):
 
     def __getattribute__(self, attr):
         """Trigger the load of the module and return the attribute."""
-        # All module metadata must be garnered from __spec__ in order to avoid
-        # using mutated values.
-        # Stop triggering this method.
-        self.__class__ = types.ModuleType
-        # Get the original name to make sure no object substitution occurred
-        # in sys.modules.
-        original_name = self.__spec__.name
-        # Figure out exactly what attributes were mutated between the creation
-        # of the module and now.
-        attrs_then = self.__spec__.loader_state['__dict__']
-        attrs_now = self.__dict__
-        attrs_updated = {}
-        for key, value in attrs_now.items():
-            # Code that set the attribute may have kept a reference to the
-            # assigned object, making identity more important than equality.
-            if key not in attrs_then:
-                attrs_updated[key] = value
-            elif id(attrs_now[key]) != id(attrs_then[key]):
-                attrs_updated[key] = value
-        self.__spec__.loader.exec_module(self)
-        # If exec_module() was used directly there is no guarantee the module
-        # object was put into sys.modules.
-        if original_name in sys.modules:
-            if id(self) != id(sys.modules[original_name]):
-                raise ValueError(f"module object for {original_name!r} "
-                                  "substituted in sys.modules during a lazy "
-                                  "load")
-        # Update after loading since that's what would happen in an eager
-        # loading situation.
-        self.__dict__.update(attrs_updated)
+        __spec__ = object.__getattribute__(self, '__spec__')
+        loader_state = __spec__.loader_state
+        with loader_state['lock']:
+            # Only the first thread to get the lock should trigger the load
+            # and reset the module's class. The rest can now getattr().
+            if object.__getattribute__(self, '__class__') is _LazyModule:
+                __class__ = loader_state['__class__']
+
+                # Reentrant calls from the same thread must be allowed to proceed without
+                # triggering the load again.
+                # exec_module() and self-referential imports are the primary ways this can
+                # happen, but in any case we must return something to avoid deadlock.
+                if loader_state['is_loading']:
+                    return __class__.__getattribute__(self, attr)
+                loader_state['is_loading'] = True
+
+                __dict__ = __class__.__getattribute__(self, '__dict__')
+
+                # All module metadata must be gathered from __spec__ in order to avoid
+                # using mutated values.
+                # Get the original name to make sure no object substitution occurred
+                # in sys.modules.
+                original_name = __spec__.name
+                # Figure out exactly what attributes were mutated between the creation
+                # of the module and now.
+                attrs_then = loader_state['__dict__']
+                attrs_now = __dict__
+                attrs_updated = {}
+                for key, value in attrs_now.items():
+                    # Code that set an attribute may have kept a reference to the
+                    # assigned object, making identity more important than equality.
+                    if key not in attrs_then:
+                        attrs_updated[key] = value
+                    elif id(attrs_now[key]) != id(attrs_then[key]):
+                        attrs_updated[key] = value
+                __spec__.loader.exec_module(self)
+                # If exec_module() was used directly there is no guarantee the module
+                # object was put into sys.modules.
+                if original_name in sys.modules:
+                    if id(self) != id(sys.modules[original_name]):
+                        raise ValueError(f"module object for {original_name!r} "
+                                          "substituted in sys.modules during a lazy "
+                                          "load")
+                # Update after loading since that's what would happen in an eager
+                # loading situation.
+                __dict__.update(attrs_updated)
+                # Finally, stop triggering this method, if the module did not
+                # already update its own __class__.
+                if isinstance(self, _LazyModule):
+                    object.__setattr__(self, '__class__', __class__)
+
         return getattr(self, attr)
 
     def __delattr__(self, attr):
@@ -235,6 +256,9 @@ def create_module(self, spec):
 
     def exec_module(self, module):
         """Make the module load lazily."""
+        # Threading is only needed for lazy loading, and importlib.util can
+        # be pulled in at interpreter startup, so defer until needed.
+        import threading
         module.__spec__.loader = self.loader
         module.__loader__ = self.loader
         # Don't need to worry about deep-copying as trying to set an attribute
@@ -244,5 +268,7 @@ def exec_module(self, module):
         loader_state = {}
         loader_state['__dict__'] = module.__dict__.copy()
         loader_state['__class__'] = module.__class__
+        loader_state['lock'] = threading.RLock()
+        loader_state['is_loading'] = False
         module.__spec__.loader_state = loader_state
         module.__class__ = _LazyModule
diff --git a/Lib/inspect.py b/Lib/inspect.py
index a84f3346b3..5a814f97b5 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -24,6 +24,8 @@
     stack(), trace() - get info about frames on the stack or in a traceback
 
     signature() - get a Signature object for the callable
+
+    get_annotations() - safely compute an object's annotations
 """
 
 # This module is in the public domain.  No warranties.
@@ -31,7 +33,116 @@
 __author__ = ('Ka-Ping Yee <ping@lfw.org>',
               'Yury Selivanov <yselivanov@sprymix.com>')
 
+__all__ = [
+    "AGEN_CLOSED",
+    "AGEN_CREATED",
+    "AGEN_RUNNING",
+    "AGEN_SUSPENDED",
+    "ArgInfo",
+    "Arguments",
+    "Attribute",
+    "BlockFinder",
+    "BoundArguments",
+    "BufferFlags",
+    "CORO_CLOSED",
+    "CORO_CREATED",
+    "CORO_RUNNING",
+    "CORO_SUSPENDED",
+    "CO_ASYNC_GENERATOR",
+    "CO_COROUTINE",
+    "CO_GENERATOR",
+    "CO_ITERABLE_COROUTINE",
+    "CO_NESTED",
+    "CO_NEWLOCALS",
+    "CO_NOFREE",
+    "CO_OPTIMIZED",
+    "CO_VARARGS",
+    "CO_VARKEYWORDS",
+    "ClassFoundException",
+    "ClosureVars",
+    "EndOfBlock",
+    "FrameInfo",
+    "FullArgSpec",
+    "GEN_CLOSED",
+    "GEN_CREATED",
+    "GEN_RUNNING",
+    "GEN_SUSPENDED",
+    "Parameter",
+    "Signature",
+    "TPFLAGS_IS_ABSTRACT",
+    "Traceback",
+    "classify_class_attrs",
+    "cleandoc",
+    "currentframe",
+    "findsource",
+    "formatannotation",
+    "formatannotationrelativeto",
+    "formatargvalues",
+    "get_annotations",
+    "getabsfile",
+    "getargs",
+    "getargvalues",
+    "getasyncgenlocals",
+    "getasyncgenstate",
+    "getattr_static",
+    "getblock",
+    "getcallargs",
+    "getclasstree",
+    "getclosurevars",
+    "getcomments",
+    "getcoroutinelocals",
+    "getcoroutinestate",
+    "getdoc",
+    "getfile",
+    "getframeinfo",
+    "getfullargspec",
+    "getgeneratorlocals",
+    "getgeneratorstate",
+    "getinnerframes",
+    "getlineno",
+    "getmembers",
+    "getmembers_static",
+    "getmodule",
+    "getmodulename",
+    "getmro",
+    "getouterframes",
+    "getsource",
+    "getsourcefile",
+    "getsourcelines",
+    "indentsize",
+    "isabstract",
+    "isasyncgen",
+    "isasyncgenfunction",
+    "isawaitable",
+    "isbuiltin",
+    "isclass",
+    "iscode",
+    "iscoroutine",
+    "iscoroutinefunction",
+    "isdatadescriptor",
+    "isframe",
+    "isfunction",
+    "isgenerator",
+    "isgeneratorfunction",
+    "isgetsetdescriptor",
+    "ismemberdescriptor",
+    "ismethod",
+    "ismethoddescriptor",
+    "ismethodwrapper",
+    "ismodule",
+    "isroutine",
+    "istraceback",
+    "markcoroutinefunction",
+    "signature",
+    "stack",
+    "trace",
+    "unwrap",
+    "walktree",
+]
+
+
 import abc
+import ast
 import dis
 import collections.abc
 import enum
@@ -44,47 +155,156 @@
 import tokenize
 import token
 import types
-import warnings
 import functools
 import builtins
+from keyword import iskeyword
 from operator import attrgetter
 from collections import namedtuple, OrderedDict
+from weakref import ref as make_weakref
 
 # Create constants for the compiler flags in Include/code.h
 # We try to get them from dis to avoid duplication
 mod_dict = globals()
 for k, v in dis.COMPILER_FLAG_NAMES.items():
     mod_dict["CO_" + v] = k
+del k, v, mod_dict
 
 # See Include/object.h
 TPFLAGS_IS_ABSTRACT = 1 << 20
 
+
+def get_annotations(obj, *, globals=None, locals=None, eval_str=False):
+    """Compute the annotations dict for an object.
+
+    obj may be a callable, class, or module.
+    Passing in an object of any other type raises TypeError.
+
+    Returns a dict.  get_annotations() returns a new dict every time
+    it's called; calling it twice on the same object will return two
+    different but equivalent dicts.
+
+    This function handles several details for you:
+
+      * If eval_str is true, values of type str will
+        be un-stringized using eval().  This is intended
+        for use with stringized annotations
+        ("from __future__ import annotations").
+      * If obj doesn't have an annotations dict, returns an
+        empty dict.  (Functions and methods always have an
+        annotations dict; classes, modules, and other types of
+        callables may not.)
+      * Ignores inherited annotations on classes.  If a class
+        doesn't have its own annotations dict, returns an empty dict.
+      * All accesses to object members and dict values are done
+        using getattr() and dict.get() for safety.
+      * Always, always, always returns a freshly-created dict.
+
+    eval_str controls whether or not values of type str are replaced
+    with the result of calling eval() on those values:
+
+      * If eval_str is true, eval() is called on values of type str.
+      * If eval_str is false (the default), values of type str are unchanged.
+
+    globals and locals are passed in to eval(); see the documentation
+    for eval() for more information.  If either globals or locals is
+    None, this function may replace that value with a context-specific
+    default, contingent on type(obj):
+
+      * If obj is a module, globals defaults to obj.__dict__.
+      * If obj is a class, globals defaults to
+        sys.modules[obj.__module__].__dict__ and locals
+        defaults to the obj class namespace.
+      * If obj is a callable, globals defaults to obj.__globals__,
+        although if obj is a wrapped function (using
+        functools.update_wrapper()) it is first unwrapped.
+    """
+    if isinstance(obj, type):
+        # class
+        obj_dict = getattr(obj, '__dict__', None)
+        if obj_dict and hasattr(obj_dict, 'get'):
+            ann = obj_dict.get('__annotations__', None)
+            if isinstance(ann, types.GetSetDescriptorType):
+                ann = None
+        else:
+            ann = None
+
+        obj_globals = None
+        module_name = getattr(obj, '__module__', None)
+        if module_name:
+            module = sys.modules.get(module_name, None)
+            if module:
+                obj_globals = getattr(module, '__dict__', None)
+        obj_locals = dict(vars(obj))
+        unwrap = obj
+    elif isinstance(obj, types.ModuleType):
+        # module
+        ann = getattr(obj, '__annotations__', None)
+        obj_globals = getattr(obj, '__dict__')
+        obj_locals = None
+        unwrap = None
+    elif callable(obj):
+        # this includes types.Function, types.BuiltinFunctionType,
+        # types.BuiltinMethodType, functools.partial, functools.singledispatch,
+        # "class funclike" from Lib/test/test_inspect... on and on it goes.
+        ann = getattr(obj, '__annotations__', None)
+        obj_globals = getattr(obj, '__globals__', None)
+        obj_locals = None
+        unwrap = obj
+    else:
+        raise TypeError(f"{obj!r} is not a module, class, or callable.")
+
+    if ann is None:
+        return {}
+
+    if not isinstance(ann, dict):
+        raise ValueError(f"{obj!r}.__annotations__ is neither a dict nor None")
+
+    if not ann:
+        return {}
+
+    if not eval_str:
+        return dict(ann)
+
+    if unwrap is not None:
+        while True:
+            if hasattr(unwrap, '__wrapped__'):
+                unwrap = unwrap.__wrapped__
+                continue
+            if isinstance(unwrap, functools.partial):
+                unwrap = unwrap.func
+                continue
+            break
+        if hasattr(unwrap, "__globals__"):
+            obj_globals = unwrap.__globals__
+
+    if globals is None:
+        globals = obj_globals
+    if locals is None:
+        locals = obj_locals or {}
+
+    # "Inject" type parameters into the local namespace
+    # (unless they are shadowed by assignments *in* the local namespace),
+    # as a way of emulating annotation scopes when calling `eval()`
+    if type_params := getattr(obj, "__type_params__", ()):
+        locals = {param.__name__: param for param in type_params} | locals
+
+    return_value = {key:
+        value if not isinstance(value, str) else eval(value, globals, locals)
+        for key, value in ann.items() }
+    return return_value
+
+
 # ----------------------------------------------------------- type-checking
 def ismodule(object):
-    """Return true if the object is a module.
-
-    Module objects provide these attributes:
-        __cached__      pathname to byte compiled file
-        __doc__         documentation string
-        __file__        filename (missing for built-in modules)"""
+    """Return true if the object is a module."""
     return isinstance(object, types.ModuleType)
 
 def isclass(object):
-    """Return true if the object is a class.
-
-    Class objects provide these attributes:
-        __doc__         documentation string
-        __module__      name of module in which this class was defined"""
+    """Return true if the object is a class."""
     return isinstance(object, type)
 
 def ismethod(object):
-    """Return true if the object is an instance method.
-
-    Instance method objects provide these attributes:
-        __doc__         documentation string
-        __name__        name with which this method was defined
-        __func__        function object containing implementation of method
-        __self__        instance to which this method is bound"""
+    """Return true if the object is an instance method."""
     return isinstance(object, types.MethodType)
 
 def ismethoddescriptor(object):
@@ -93,9 +313,10 @@ def ismethoddescriptor(object):
     But not if ismethod() or isclass() or isfunction() are true.
 
     This is new in Python 2.2, and, for example, is true of int.__add__.
-    An object passing this test has a __get__ attribute but not a __set__
-    attribute, but beyond that the set of attributes varies.  __name__ is
-    usually sensible, and __doc__ often is.
+    An object passing this test has a __get__ attribute, but not a
+    __set__ attribute or a __delete__ attribute. Beyond that, the set
+    of attributes varies; __name__ is usually sensible, and __doc__
+    often is.
 
     Methods implemented via descriptors that also pass one of the other
     tests return false from the ismethoddescriptor() test, simply because
@@ -104,8 +325,15 @@ def ismethoddescriptor(object):
     if isclass(object) or ismethod(object) or isfunction(object):
         # mutual exclusion
         return False
+    if isinstance(object, functools.partial):
+        # Lie for children.  The addition of partial.__get__
+        # doesn't currently change the partial objects behaviour,
+        # not counting a warning about future changes.
+        return False
     tp = type(object)
-    return hasattr(tp, "__get__") and not hasattr(tp, "__set__")
+    return (hasattr(tp, "__get__")
+            and not hasattr(tp, "__set__")
+            and not hasattr(tp, "__delete__"))
 
 def isdatadescriptor(object):
     """Return true if the object is a data descriptor.
@@ -170,12 +398,14 @@ def isfunction(object):
 
 def _has_code_flag(f, flag):
     """Return true if ``f`` is a function (or a method or functools.partial
-    wrapper wrapping a function) whose code object has the given ``flag``
+    wrapper wrapping a function or a functools.partialmethod wrapping a
+    function) whose code object has the given ``flag``
     set in its flags."""
+    f = functools._unwrap_partialmethod(f)
     while ismethod(f):
         f = f.__func__
     f = functools._unwrap_partial(f)
-    if not isfunction(f):
+    if not (isfunction(f) or _signature_is_functionlike(f)):
         return False
     return bool(f.__code__.co_flags & flag)
 
@@ -186,12 +416,31 @@ def isgeneratorfunction(obj):
     See help(isfunction) for a list of attributes."""
     return _has_code_flag(obj, CO_GENERATOR)
 
+# A marker for markcoroutinefunction and iscoroutinefunction.
+_is_coroutine_mark = object()
+
+def _has_coroutine_mark(f):
+    while ismethod(f):
+        f = f.__func__
+    f = functools._unwrap_partial(f)
+    return getattr(f, "_is_coroutine_marker", None) is _is_coroutine_mark
+
+def markcoroutinefunction(func):
+    """
+    Decorator to ensure callable is recognised as a coroutine function.
+    """
+    if hasattr(func, '__func__'):
+        func = func.__func__
+    func._is_coroutine_marker = _is_coroutine_mark
+    return func
+
 def iscoroutinefunction(obj):
     """Return true if the object is a coroutine function.
 
-    Coroutine functions are defined with "async def" syntax.
+    Coroutine functions are normally defined with "async def" syntax, but may
+    be marked via markcoroutinefunction.
     """
-    return _has_code_flag(obj, CO_COROUTINE)
+    return _has_code_flag(obj, CO_COROUTINE) or _has_coroutine_mark(obj)
 
 def isasyncgenfunction(obj):
     """Return true if the object is an asynchronous generator function.
@@ -276,7 +525,7 @@ def iscode(object):
         co_kwonlyargcount   number of keyword only arguments (not including ** arg)
         co_lnotab           encoded mapping of line numbers to bytecode indices
         co_name             name with which this code object was defined
-        co_names            tuple of names of local variables
+        co_names            tuple of names other than arguments and function locals
         co_nlocals          number of local variables
         co_stacksize        virtual machine stack space required
         co_varnames         tuple of names of arguments and local variables"""
@@ -291,28 +540,30 @@ def isbuiltin(object):
         __self__        instance to which a method is bound, or None"""
     return isinstance(object, types.BuiltinFunctionType)
 
+def ismethodwrapper(object):
+    """Return true if the object is a method wrapper."""
+    return isinstance(object, types.MethodWrapperType)
+
 def isroutine(object):
     """Return true if the object is any kind of function or method."""
     return (isbuiltin(object)
             or isfunction(object)
             or ismethod(object)
-            or ismethoddescriptor(object))
+            or ismethoddescriptor(object)
+            or ismethodwrapper(object))
 
 def isabstract(object):
     """Return true if the object is an abstract base class (ABC)."""
     if not isinstance(object, type):
         return False
-    # TODO: RUSTPYTHON
-    # TPFLAGS_IS_ABSTRACT is not being set for abstract classes, so this implementation differs from CPython.
-    # if object.__flags__ & TPFLAGS_IS_ABSTRACT:
-    #     return True
+    if object.__flags__ & TPFLAGS_IS_ABSTRACT:
+        return True
     if not issubclass(type(object), abc.ABCMeta):
         return False
     if hasattr(object, '__abstractmethods__'):
         # It looks like ABCMeta.__new__ has finished running;
         # TPFLAGS_IS_ABSTRACT should have been accurate.
-        # return False
-        return bool(getattr(object, '__abstractmethods__'))
+        return False
     # It looks like ABCMeta.__new__ has not finished running yet; we're
     # probably in __init_subclass__. We'll look for abstractmethods manually.
     for name, value in object.__dict__.items():
@@ -325,32 +576,30 @@ def isabstract(object):
                 return True
     return False
 
-def getmembers(object, predicate=None):
-    """Return all members of an object as (name, value) pairs sorted by name.
-    Optionally, only return members that satisfy a given predicate."""
-    if isclass(object):
-        mro = (object,) + getmro(object)
-    else:
-        mro = ()
+def _getmembers(object, predicate, getter):
     results = []
     processed = set()
     names = dir(object)
-    # :dd any DynamicClassAttributes to the list of names if object is a class;
-    # this may result in duplicate entries if, for example, a virtual
-    # attribute with the same name as a DynamicClassAttribute exists
-    try:
-        for base in object.__bases__:
-            for k, v in base.__dict__.items():
-                if isinstance(v, types.DynamicClassAttribute):
-                    names.append(k)
-    except AttributeError:
-        pass
+    if isclass(object):
+        mro = getmro(object)
+        # add any DynamicClassAttributes to the list of names if object is a class;
+        # this may result in duplicate entries if, for example, a virtual
+        # attribute with the same name as a DynamicClassAttribute exists
+        try:
+            for base in object.__bases__:
+                for k, v in base.__dict__.items():
+                    if isinstance(v, types.DynamicClassAttribute):
+                        names.append(k)
+        except AttributeError:
+            pass
+    else:
+        mro = ()
     for key in names:
         # First try to get the value via getattr.  Some descriptors don't
         # like calling their __get__ (see bug #1785), so fall back to
         # looking in the __dict__.
         try:
-            value = getattr(object, key)
+            value = getter(object, key)
             # handle the duplicate key
             if key in processed:
                 raise AttributeError
@@ -369,6 +618,25 @@ def getmembers(object, predicate=None):
     results.sort(key=lambda pair: pair[0])
     return results
 
+def getmembers(object, predicate=None):
+    """Return all members of an object as (name, value) pairs sorted by name.
+    Optionally, only return members that satisfy a given predicate."""
+    return _getmembers(object, predicate, getattr)
+
+def getmembers_static(object, predicate=None):
+    """Return all members of an object as (name, value) pairs sorted by name
+    without triggering dynamic lookup via the descriptor protocol,
+    __getattr__ or __getattribute__. Optionally, only return members that
+    satisfy a given predicate.
+
+    Note: this function may not be able to retrieve all members
+       that getmembers can fetch (like dynamically created attributes)
+       and may find members that getmembers can't (like descriptors
+       that raise AttributeError). It can also return descriptor objects
+       instead of instance members in some cases.
+    """
+    return _getmembers(object, predicate, getattr_static)
+
 Attribute = namedtuple('Attribute', 'name kind defining_class object')
 
 def classify_class_attrs(cls):
@@ -409,7 +677,7 @@ def classify_class_attrs(cls):
     # attribute with the same name as a DynamicClassAttribute exists.
     for base in mro:
         for k, v in base.__dict__.items():
-            if isinstance(v, types.DynamicClassAttribute):
+            if isinstance(v, types.DynamicClassAttribute) and v.fget is not None:
                 names.append(k)
     result = []
     processed = set()
@@ -432,7 +700,7 @@ def classify_class_attrs(cls):
                 if name == '__dict__':
                     raise Exception("__dict__ is special, don't want the proxy")
                 get_obj = getattr(cls, name)
-            except Exception as exc:
+            except Exception:
                 pass
             else:
                 homecls = getattr(get_obj, "__objclass__", homecls)
@@ -509,18 +777,14 @@ def unwrap(func, *, stop=None):
    :exc:`ValueError` is raised if a cycle is encountered.
 
     """
-    if stop is None:
-        def _is_wrapper(f):
-            return hasattr(f, '__wrapped__')
-    else:
-        def _is_wrapper(f):
-            return hasattr(f, '__wrapped__') and not stop(f)
     f = func  # remember the original func for error reporting
     # Memoise by id to tolerate non-hashable objects, but store objects to
     # ensure they aren't destroyed, which would allow their IDs to be reused.
     memo = {id(f): f}
     recursion_limit = sys.getrecursionlimit()
-    while _is_wrapper(func):
+    while not isinstance(func, type) and hasattr(func, '__wrapped__'):
+        if stop is not None and stop(func):
+            break
         func = func.__wrapped__
         id_func = id(func)
         if (id_func in memo) or (len(memo) >= recursion_limit):
@@ -581,9 +845,8 @@ def _finddoc(obj):
             cls = self.__class__
     # Should be tested before isdatadescriptor().
     elif isinstance(obj, property):
-        func = obj.fget
-        name = func.__name__
-        cls = _findclass(func)
+        name = obj.__name__
+        cls = _findclass(obj.fget)
         if cls is None or getattr(cls, name) is not obj:
             return None
     elif ismethoddescriptor(obj) or isdatadescriptor(obj):
@@ -630,29 +893,28 @@ def cleandoc(doc):
 
     Any whitespace that can be uniformly removed from the second line
     onwards is removed."""
-    try:
-        lines = doc.expandtabs().split('\n')
-    except UnicodeError:
-        return None
-    else:
-        # Find minimum indentation of any non-blank lines after first line.
-        margin = sys.maxsize
-        for line in lines[1:]:
-            content = len(line.lstrip())
-            if content:
-                indent = len(line) - content
-                margin = min(margin, indent)
-        # Remove indentation.
-        if lines:
-            lines[0] = lines[0].lstrip()
-        if margin < sys.maxsize:
-            for i in range(1, len(lines)): lines[i] = lines[i][margin:]
-        # Remove any trailing or leading blank lines.
-        while lines and not lines[-1]:
-            lines.pop()
-        while lines and not lines[0]:
-            lines.pop(0)
-        return '\n'.join(lines)
+    lines = doc.expandtabs().split('\n')
+
+    # Find minimum indentation of any non-blank lines after first line.
+    margin = sys.maxsize
+    for line in lines[1:]:
+        content = len(line.lstrip(' '))
+        if content:
+            indent = len(line) - content
+            margin = min(margin, indent)
+    # Remove indentation.
+    if lines:
+        lines[0] = lines[0].lstrip(' ')
+    if margin < sys.maxsize:
+        for i in range(1, len(lines)):
+            lines[i] = lines[i][margin:]
+    # Remove any trailing or leading blank lines.
+    while lines and not lines[-1]:
+        lines.pop()
+    while lines and not lines[0]:
+        lines.pop(0)
+    return '\n'.join(lines)
+
 
 def getfile(object):
     """Work out which source or compiled file an object was defined in."""
@@ -665,6 +927,8 @@ def getfile(object):
             module = sys.modules.get(object.__module__)
             if getattr(module, '__file__', None):
                 return module.__file__
+            if object.__module__ == '__main__':
+                raise OSError('source code not available')
         raise TypeError('{!r} is a built-in class'.format(object))
     if ismethod(object):
         object = object.__func__
@@ -705,13 +969,20 @@ def getsourcefile(object):
     elif any(filename.endswith(s) for s in
                  importlib.machinery.EXTENSION_SUFFIXES):
         return None
+    elif filename.endswith(".fwork"):
+        # Apple mobile framework markers are another type of non-source file
+        return None
+
+    # return a filename found in the linecache even if it doesn't exist on disk
+    if filename in linecache.cache:
+        return filename
     if os.path.exists(filename):
         return filename
     # only return a non-existent filename if the module has a PEP 302 loader
-    if getattr(getmodule(object, filename), '__loader__', None) is not None:
+    module = getmodule(object, filename)
+    if getattr(module, '__loader__', None) is not None:
         return filename
-    # or it is in the linecache
-    if filename in linecache.cache:
+    elif getattr(getattr(module, "__spec__", None), "loader", None) is not None:
         return filename
 
 def getabsfile(object, _filename=None):
@@ -732,19 +1003,20 @@ def getmodule(object, _filename=None):
         return object
     if hasattr(object, '__module__'):
         return sys.modules.get(object.__module__)
+
     # Try the filename to modulename cache
     if _filename is not None and _filename in modulesbyfile:
         return sys.modules.get(modulesbyfile[_filename])
     # Try the cache again with the absolute file name
     try:
         file = getabsfile(object, _filename)
-    except TypeError:
+    except (TypeError, FileNotFoundError):
         return None
     if file in modulesbyfile:
         return sys.modules.get(modulesbyfile[file])
     # Update the filename to module name cache and check yet again
     # Copy sys.modules in order to cope with changes while iterating
-    for modname, module in list(sys.modules.items()):
+    for modname, module in sys.modules.copy().items():
         if ismodule(module) and hasattr(module, '__file__'):
             f = module.__file__
             if f == _filesbymodname.get(modname, None):
@@ -772,6 +1044,11 @@ def getmodule(object, _filename=None):
         if builtinobject is object:
             return builtin
 
+
+class ClassFoundException(Exception):
+    pass
+
+
 def findsource(object):
     """Return the entire source file and starting line number for an object.
 
@@ -789,12 +1066,14 @@ def findsource(object):
         # Allow filenames in form of "<something>" to pass through.
         # `doctest` monkeypatches `linecache` module to enable
         # inspection, so let `linecache.getlines` to be called.
-        if not (file.startswith('<') and file.endswith('>')):
+        if (not (file.startswith('<') and file.endswith('>'))) or file.endswith('.fwork'):
             raise OSError('source code not available')
 
     module = getmodule(object, file)
     if module:
         lines = linecache.getlines(file, module.__dict__)
+        if not lines and file.startswith('<') and hasattr(object, "__code__"):
+            lines = linecache._getlines_from_code(object.__code__)
     else:
         lines = linecache.getlines(file)
     if not lines:
@@ -804,27 +1083,13 @@ def findsource(object):
         return lines, 0
 
     if isclass(object):
-        name = object.__name__
-        pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
-        # make some effort to find the best matching class definition:
-        # use the one with the least indentation, which is the one
-        # that's most probably not inside a function definition.
-        candidates = []
-        for i in range(len(lines)):
-            match = pat.match(lines[i])
-            if match:
-                # if it's at toplevel, it's already the best one
-                if lines[i][0] == 'c':
-                    return lines, i
-                # else add whitespace to candidate list
-                candidates.append((match.group(1), i))
-        if candidates:
-            # this will sort by whitespace, and by line number,
-            # less whitespace first
-            candidates.sort()
-            return lines, candidates[0][1]
-        else:
-            raise OSError('could not find class definition')
+        try:
+            lnum = vars(object)['__firstlineno__'] - 1
+        except (TypeError, KeyError):
+            raise OSError('source code not available')
+        if lnum >= len(lines):
+            raise OSError('lineno is out of bounds')
+        return lines, lnum
 
     if ismethod(object):
         object = object.__func__
@@ -838,10 +1103,8 @@ def findsource(object):
         if not hasattr(object, 'co_firstlineno'):
             raise OSError('could not find function definition')
         lnum = object.co_firstlineno - 1
-        pat = re.compile(r'^(\s*def\s)|(\s*async\s+def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
-        while lnum > 0:
-            if pat.match(lines[lnum]): break
-            lnum = lnum - 1
+        if lnum >= len(lines):
+            raise OSError('lineno is out of bounds')
         return lines, lnum
     raise OSError('could not find code object')
 
@@ -896,43 +1159,43 @@ class BlockFinder:
     """Provide a tokeneater() method to detect the end of a code block."""
     def __init__(self):
         self.indent = 0
-        self.islambda = False
+        self.singleline = False
         self.started = False
         self.passline = False
         self.indecorator = False
-        self.decoratorhasargs = False
         self.last = 1
+        self.body_col0 = None
 
     def tokeneater(self, type, token, srowcol, erowcol, line):
         if not self.started and not self.indecorator:
+            if type in (tokenize.INDENT, tokenize.COMMENT, tokenize.NL):
+                pass
+            elif token == "async":
+                pass
             # skip any decorators
-            if token == "@":
+            elif token == "@":
                 self.indecorator = True
-            # look for the first "def", "class" or "lambda"
-            elif token in ("def", "class", "lambda"):
-                if token == "lambda":
-                    self.islambda = True
+            else:
+                # For "def" and "class" scan to the end of the block.
+                # For "lambda" and generator expression scan to
+                # the end of the logical line.
+                self.singleline = token not in ("def", "class")
                 self.started = True
             self.passline = True    # skip to the end of the line
-        elif token == "(":
-            if self.indecorator:
-                self.decoratorhasargs = True
-        elif token == ")":
-            if self.indecorator:
-                self.indecorator = False
-                self.decoratorhasargs = False
         elif type == tokenize.NEWLINE:
             self.passline = False   # stop skipping when a NEWLINE is seen
             self.last = srowcol[0]
-            if self.islambda:       # lambdas always end at the first NEWLINE
+            if self.singleline:
                 raise EndOfBlock
             # hitting a NEWLINE when in a decorator without args
             # ends the decorator
-            if self.indecorator and not self.decoratorhasargs:
+            if self.indecorator:
                 self.indecorator = False
         elif self.passline:
             pass
         elif type == tokenize.INDENT:
+            if self.body_col0 is None and self.started:
+                self.body_col0 = erowcol[1]
             self.indent = self.indent + 1
             self.passline = True
         elif type == tokenize.DEDENT:
@@ -942,6 +1205,10 @@ def tokeneater(self, type, token, srowcol, erowcol, line):
             #  not e.g. for "if: else:" or "try: finally:" blocks)
             if self.indent <= 0:
                 raise EndOfBlock
+        elif type == tokenize.COMMENT:
+            if self.body_col0 is not None and srowcol[1] >= self.body_col0:
+                # Include comments if indented at least as much as the block
+                self.last = srowcol[0]
         elif self.indent == 0 and type not in (tokenize.COMMENT, tokenize.NL):
             # any other token on the same indentation level end the previous
             # block as well, except the pseudo-tokens COMMENT and NL.
@@ -956,6 +1223,14 @@ def getblock(lines):
             blockfinder.tokeneater(*_token)
     except (EndOfBlock, IndentationError):
         pass
+    except SyntaxError as e:
+        if "unmatched" not in e.msg:
+            raise e from None
+        _, *_token_info = _token
+        try:
+            blockfinder.tokeneater(tokenize.NEWLINE, *_token_info)
+        except (EndOfBlock, IndentationError):
+            pass
     return lines[:blockfinder.last]
 
 def getsourcelines(object):
@@ -1043,7 +1318,6 @@ def getargs(co):
     nkwargs = co.co_kwonlyargcount
     args = list(names[:nargs])
     kwonlyargs = list(names[nargs:nargs+nkwargs])
-    step = 0
 
     nargs += nkwargs
     varargs = None
@@ -1055,37 +1329,6 @@ def getargs(co):
         varkw = co.co_varnames[nargs]
     return Arguments(args + kwonlyargs, varargs, varkw)
 
-ArgSpec = namedtuple('ArgSpec', 'args varargs keywords defaults')
-
-def getargspec(func):
-    """Get the names and default values of a function's parameters.
-
-    A tuple of four things is returned: (args, varargs, keywords, defaults).
-    'args' is a list of the argument names, including keyword-only argument names.
-    'varargs' and 'keywords' are the names of the * and ** parameters or None.
-    'defaults' is an n-tuple of the default values of the last n parameters.
-
-    This function is deprecated, as it does not support annotations or
-    keyword-only parameters and will raise ValueError if either is present
-    on the supplied callable.
-
-    For a more structured introspection API, use inspect.signature() instead.
-
-    Alternatively, use getfullargspec() for an API with a similar namedtuple
-    based interface, but full support for annotations and keyword-only
-    parameters.
-
-    Deprecated since Python 3.5, use `inspect.getfullargspec()`.
-    """
-    warnings.warn("inspect.getargspec() is deprecated since Python 3.0, "
-                  "use inspect.signature() or inspect.getfullargspec()",
-                  DeprecationWarning, stacklevel=2)
-    args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \
-        getfullargspec(func)
-    if kwonlyargs or ann:
-        raise ValueError("Function has keyword-only parameters or annotations"
-                         ", use inspect.signature() API which can support them")
-    return ArgSpec(args, varargs, varkw, defaults)
 
 FullArgSpec = namedtuple('FullArgSpec',
     'args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations')
@@ -1126,7 +1369,8 @@ def getfullargspec(func):
         sig = _signature_from_callable(func,
                                        follow_wrapper_chains=False,
                                        skip_bound_arg=False,
-                                       sigcls=Signature)
+                                       sigcls=Signature,
+                                       eval_str=False)
     except Exception as ex:
         # Most of the times 'signature' will raise ValueError.
         # But, it can also raise AttributeError, and, maybe something
@@ -1139,7 +1383,6 @@ def getfullargspec(func):
     varkw = None
     posonlyargs = []
     kwonlyargs = []
-    defaults = ()
     annotations = {}
     defaults = ()
     kwdefaults = {}
@@ -1197,7 +1440,12 @@ def getargvalues(frame):
 
 def formatannotation(annotation, base_module=None):
     if getattr(annotation, '__module__', None) == 'typing':
-        return repr(annotation).replace('typing.', '')
+        def repl(match):
+            text = match.group()
+            return text.removeprefix('typing.')
+        return re.sub(r'[\w\.]+', repl, repr(annotation))
+    if isinstance(annotation, types.GenericAlias):
+        return str(annotation)
     if isinstance(annotation, type):
         if annotation.__module__ in ('builtins', base_module):
             return annotation.__qualname__
@@ -1210,63 +1458,6 @@ def _formatannotation(annotation):
         return formatannotation(annotation, module)
     return _formatannotation
 
-def formatargspec(args, varargs=None, varkw=None, defaults=None,
-                  kwonlyargs=(), kwonlydefaults={}, annotations={},
-                  formatarg=str,
-                  formatvarargs=lambda name: '*' + name,
-                  formatvarkw=lambda name: '**' + name,
-                  formatvalue=lambda value: '=' + repr(value),
-                  formatreturns=lambda text: ' -> ' + text,
-                  formatannotation=formatannotation):
-    """Format an argument spec from the values returned by getfullargspec.
-
-    The first seven arguments are (args, varargs, varkw, defaults,
-    kwonlyargs, kwonlydefaults, annotations).  The other five arguments
-    are the corresponding optional formatting functions that are called to
-    turn names and values into strings.  The last argument is an optional
-    function to format the sequence of arguments.
-
-    Deprecated since Python 3.5: use the `signature` function and `Signature`
-    objects.
-    """
-
-    from warnings import warn
-
-    warn("`formatargspec` is deprecated since Python 3.5. Use `signature` and "
-         "the `Signature` object directly",
-         DeprecationWarning,
-         stacklevel=2)
-
-    def formatargandannotation(arg):
-        result = formatarg(arg)
-        if arg in annotations:
-            result += ': ' + formatannotation(annotations[arg])
-        return result
-    specs = []
-    if defaults:
-        firstdefault = len(args) - len(defaults)
-    for i, arg in enumerate(args):
-        spec = formatargandannotation(arg)
-        if defaults and i >= firstdefault:
-            spec = spec + formatvalue(defaults[i - firstdefault])
-        specs.append(spec)
-    if varargs is not None:
-        specs.append(formatvarargs(formatargandannotation(varargs)))
-    else:
-        if kwonlyargs:
-            specs.append('*')
-    if kwonlyargs:
-        for kwonlyarg in kwonlyargs:
-            spec = formatargandannotation(kwonlyarg)
-            if kwonlydefaults and kwonlyarg in kwonlydefaults:
-                spec += formatvalue(kwonlydefaults[kwonlyarg])
-            specs.append(spec)
-    if varkw is not None:
-        specs.append(formatvarkw(formatargandannotation(varkw)))
-    result = '(' + ', '.join(specs) + ')'
-    if 'return' in annotations:
-        result += formatreturns(formatannotation(annotations['return']))
-    return result
 
 def formatargvalues(args, varargs, varkw, locals,
                     formatarg=str,
@@ -1425,11 +1616,15 @@ def getclosurevars(func):
     global_vars = {}
     builtin_vars = {}
     unbound_names = set()
-    for name in code.co_names:
-        if name in ("None", "True", "False"):
-            # Because these used to be builtins instead of keywords, they
-            # may still show up as name references. We ignore them.
-            continue
+    global_names = set()
+    for instruction in dis.get_instructions(code):
+        opname = instruction.opname
+        name = instruction.argval
+        if opname == "LOAD_ATTR":
+            unbound_names.add(name)
+        elif opname == "LOAD_GLOBAL":
+            global_names.add(name)
+    for name in global_names:
         try:
             global_vars[name] = global_ns[name]
         except KeyError:
@@ -1443,7 +1638,30 @@ def getclosurevars(func):
 
 # -------------------------------------------------- stack frame extraction
 
-Traceback = namedtuple('Traceback', 'filename lineno function code_context index')
+_Traceback = namedtuple('_Traceback', 'filename lineno function code_context index')
+
+class Traceback(_Traceback):
+    def __new__(cls, filename, lineno, function, code_context, index, *, positions=None):
+        instance = super().__new__(cls, filename, lineno, function, code_context, index)
+        instance.positions = positions
+        return instance
+
+    def __repr__(self):
+        return ('Traceback(filename={!r}, lineno={!r}, function={!r}, '
+               'code_context={!r}, index={!r}, positions={!r})'.format(
+                self.filename, self.lineno, self.function, self.code_context,
+                self.index, self.positions))
+
+def _get_code_position_from_tb(tb):
+    code, instruction_index = tb.tb_frame.f_code, tb.tb_lasti
+    return _get_code_position(code, instruction_index)
+
+def _get_code_position(code, instruction_index):
+    if instruction_index < 0:
+        return (None, None, None, None)
+    positions_gen = code.co_positions()
+    # The nth entry in code.co_positions() corresponds to instruction (2*n)th since Python 3.10+
+    return next(itertools.islice(positions_gen, instruction_index // 2, None))
 
 def getframeinfo(frame, context=1):
     """Get information about a frame or traceback object.
@@ -1454,10 +1672,20 @@ def getframeinfo(frame, context=1):
     The optional second argument specifies the number of lines of context
     to return, which are centered around the current line."""
     if istraceback(frame):
+        positions = _get_code_position_from_tb(frame)
         lineno = frame.tb_lineno
         frame = frame.tb_frame
     else:
         lineno = frame.f_lineno
+        positions = _get_code_position(frame.f_code, frame.f_lasti)
+
+    if positions[0] is None:
+        frame, *positions = (frame, lineno, *positions[1:])
+    else:
+        frame, *positions = (frame, *positions)
+
+    lineno = positions[0]
+
     if not isframe(frame):
         raise TypeError('{!r} is not a frame or traceback object'.format(frame))
 
@@ -1475,14 +1703,26 @@ def getframeinfo(frame, context=1):
     else:
         lines = index = None
 
-    return Traceback(filename, lineno, frame.f_code.co_name, lines, index)
+    return Traceback(filename, lineno, frame.f_code.co_name, lines,
+                     index, positions=dis.Positions(*positions))
 
 def getlineno(frame):
     """Get the line number from a frame object, allowing for optimization."""
     # FrameType.f_lineno is now a descriptor that grovels co_lnotab
     return frame.f_lineno
 
-FrameInfo = namedtuple('FrameInfo', ('frame',) + Traceback._fields)
+_FrameInfo = namedtuple('_FrameInfo', ('frame',) + Traceback._fields)
+class FrameInfo(_FrameInfo):
+    def __new__(cls, frame, filename, lineno, function, code_context, index, *, positions=None):
+        instance = super().__new__(cls, frame, filename, lineno, function, code_context, index)
+        instance.positions = positions
+        return instance
+
+    def __repr__(self):
+        return ('FrameInfo(frame={!r}, filename={!r}, lineno={!r}, function={!r}, '
+               'code_context={!r}, index={!r}, positions={!r})'.format(
+                self.frame, self.filename, self.lineno, self.function,
+                self.code_context, self.index, self.positions))
 
 def getouterframes(frame, context=1):
     """Get a list of records for a frame and all higher (calling) frames.
@@ -1491,8 +1731,9 @@ def getouterframes(frame, context=1):
     name, a list of lines of context, and index within the context."""
     framelist = []
     while frame:
-        frameinfo = (frame,) + getframeinfo(frame, context)
-        framelist.append(FrameInfo(*frameinfo))
+        traceback_info = getframeinfo(frame, context)
+        frameinfo = (frame,) + traceback_info
+        framelist.append(FrameInfo(*frameinfo, positions=traceback_info.positions))
         frame = frame.f_back
     return framelist
 
@@ -1503,8 +1744,9 @@ def getinnerframes(tb, context=1):
     name, a list of lines of context, and index within the context."""
     framelist = []
     while tb:
-        frameinfo = (tb.tb_frame,) + getframeinfo(tb, context)
-        framelist.append(FrameInfo(*frameinfo))
+        traceback_info = getframeinfo(tb, context)
+        frameinfo = (tb.tb_frame,) + traceback_info
+        framelist.append(FrameInfo(*frameinfo, positions=traceback_info.positions))
         tb = tb.tb_next
     return framelist
 
@@ -1518,15 +1760,17 @@ def stack(context=1):
 
 def trace(context=1):
     """Return a list of records for the stack below the current exception."""
-    return getinnerframes(sys.exc_info()[2], context)
+    exc = sys.exception()
+    tb = None if exc is None else exc.__traceback__
+    return getinnerframes(tb, context)
 
 
 # ------------------------------------------------ static version of getattr
 
 _sentinel = object()
+_static_getmro = type.__dict__['__mro__'].__get__
+_get_dunder_dict_of_class = type.__dict__["__dict__"].__get__
 
-def _static_getmro(klass):
-    return type.__dict__['__mro__'].__get__(klass)
 
 def _check_instance(obj, attr):
     instance_dict = {}
@@ -1539,34 +1783,43 @@ def _check_instance(obj, attr):
 
 def _check_class(klass, attr):
     for entry in _static_getmro(klass):
-        if _shadowed_dict(type(entry)) is _sentinel:
-            try:
-                return entry.__dict__[attr]
-            except KeyError:
-                pass
+        if _shadowed_dict(type(entry)) is _sentinel and attr in entry.__dict__:
+            return entry.__dict__[attr]
     return _sentinel
 
-def _is_type(obj):
-    try:
-        _static_getmro(obj)
-    except TypeError:
-        return False
-    return True
 
-def _shadowed_dict(klass):
-    dict_attr = type.__dict__["__dict__"]
-    for entry in _static_getmro(klass):
-        try:
-            class_dict = dict_attr.__get__(entry)["__dict__"]
-        except KeyError:
-            pass
-        else:
+@functools.lru_cache()
+def _shadowed_dict_from_weakref_mro_tuple(*weakref_mro):
+    for weakref_entry in weakref_mro:
+        # Normally we'd have to check whether the result of weakref_entry()
+        # is None here, in case the object the weakref is pointing to has died.
+        # In this specific case, however, we know that the only caller of this
+        # function is `_shadowed_dict()`, and that therefore this weakref is
+        # guaranteed to point to an object that is still alive.
+        entry = weakref_entry()
+        dunder_dict = _get_dunder_dict_of_class(entry)
+        if '__dict__' in dunder_dict:
+            class_dict = dunder_dict['__dict__']
             if not (type(class_dict) is types.GetSetDescriptorType and
                     class_dict.__name__ == "__dict__" and
                     class_dict.__objclass__ is entry):
                 return class_dict
     return _sentinel
 
+
+def _shadowed_dict(klass):
+    # gh-118013: the inner function here is decorated with lru_cache for
+    # performance reasons, *but* make sure not to pass strong references
+    # to the items in the mro. Doing so can lead to unexpected memory
+    # consumption in cases where classes are dynamically created and
+    # destroyed, and the dynamically created classes happen to be the only
+    # objects that hold strong references to other objects that take up a
+    # significant amount of memory.
+    return _shadowed_dict_from_weakref_mro_tuple(
+        *[make_weakref(entry) for entry in _static_getmro(klass)]
+    )
+
+
 def getattr_static(obj, attr, default=_sentinel):
     """Retrieve attributes without triggering dynamic lookup via the
        descriptor protocol,  __getattr__ or __getattribute__.
@@ -1579,8 +1832,10 @@ def getattr_static(obj, attr, default=_sentinel):
        documentation for details.
     """
     instance_result = _sentinel
-    if not _is_type(obj):
-        klass = type(obj)
+
+    objtype = type(obj)
+    if type not in _static_getmro(objtype):
+        klass = objtype
         dict_attr = _shadowed_dict(klass)
         if (dict_attr is _sentinel or
             type(dict_attr) is types.MemberDescriptorType):
@@ -1591,8 +1846,10 @@ def getattr_static(obj, attr, default=_sentinel):
     klass_result = _check_class(klass, attr)
 
     if instance_result is not _sentinel and klass_result is not _sentinel:
-        if (_check_class(type(klass_result), '__get__') is not _sentinel and
-            _check_class(type(klass_result), '__set__') is not _sentinel):
+        if _check_class(type(klass_result), "__get__") is not _sentinel and (
+            _check_class(type(klass_result), "__set__") is not _sentinel
+            or _check_class(type(klass_result), "__delete__") is not _sentinel
+        ):
             return klass_result
 
     if instance_result is not _sentinel:
@@ -1603,11 +1860,11 @@ def getattr_static(obj, attr, default=_sentinel):
     if obj is klass:
         # for types we check the metaclass too
         for entry in _static_getmro(type(klass)):
-            if _shadowed_dict(type(entry)) is _sentinel:
-                try:
-                    return entry.__dict__[attr]
-                except KeyError:
-                    pass
+            if (
+                _shadowed_dict(type(entry)) is _sentinel
+                and attr in entry.__dict__
+            ):
+                return entry.__dict__[attr]
     if default is not _sentinel:
         return default
     raise AttributeError(attr)
@@ -1631,11 +1888,11 @@ def getgeneratorstate(generator):
     """
     if generator.gi_running:
         return GEN_RUNNING
+    if generator.gi_suspended:
+        return GEN_SUSPENDED
     if generator.gi_frame is None:
         return GEN_CLOSED
-    if generator.gi_frame.f_lasti == -1:
-        return GEN_CREATED
-    return GEN_SUSPENDED
+    return GEN_CREATED
 
 
 def getgeneratorlocals(generator):
@@ -1673,11 +1930,11 @@ def getcoroutinestate(coroutine):
     """
     if coroutine.cr_running:
         return CORO_RUNNING
+    if coroutine.cr_suspended:
+        return CORO_SUSPENDED
     if coroutine.cr_frame is None:
         return CORO_CLOSED
-    if coroutine.cr_frame.f_lasti == -1:
-        return CORO_CREATED
-    return CORO_SUSPENDED
+    return CORO_CREATED
 
 
 def getcoroutinelocals(coroutine):
@@ -1693,35 +1950,89 @@ def getcoroutinelocals(coroutine):
         return {}
 
 
+# ----------------------------------- asynchronous generator introspection
+
+AGEN_CREATED = 'AGEN_CREATED'
+AGEN_RUNNING = 'AGEN_RUNNING'
+AGEN_SUSPENDED = 'AGEN_SUSPENDED'
+AGEN_CLOSED = 'AGEN_CLOSED'
+
+
+def getasyncgenstate(agen):
+    """Get current state of an asynchronous generator object.
+
+    Possible states are:
+      AGEN_CREATED: Waiting to start execution.
+      AGEN_RUNNING: Currently being executed by the interpreter.
+      AGEN_SUSPENDED: Currently suspended at a yield expression.
+      AGEN_CLOSED: Execution has completed.
+    """
+    if agen.ag_running:
+        return AGEN_RUNNING
+    if agen.ag_suspended:
+        return AGEN_SUSPENDED
+    if agen.ag_frame is None:
+        return AGEN_CLOSED
+    return AGEN_CREATED
+
+
+def getasyncgenlocals(agen):
+    """
+    Get the mapping of asynchronous generator local variables to their current
+    values.
+
+    A dict is returned, with the keys the local variable names and values the
+    bound values."""
+
+    if not isasyncgen(agen):
+        raise TypeError(f"{agen!r} is not a Python async generator")
+
+    frame = getattr(agen, "ag_frame", None)
+    if frame is not None:
+        return agen.ag_frame.f_locals
+    else:
+        return {}
+
+
 ###############################################################################
 ### Function Signature Object (PEP 362)
 ###############################################################################
 
 
-_WrapperDescriptor = type(type.__call__)
-_MethodWrapper = type(all.__call__)
-_ClassMethodWrapper = type(int.__dict__['from_bytes'])
-
-_NonUserDefinedCallables = (_WrapperDescriptor,
-                            _MethodWrapper,
-                            _ClassMethodWrapper,
+_NonUserDefinedCallables = (types.WrapperDescriptorType,
+                            types.MethodWrapperType,
+                            types.ClassMethodDescriptorType,
                             types.BuiltinFunctionType)
 
 
-def _signature_get_user_defined_method(cls, method_name):
+def _signature_get_user_defined_method(cls, method_name, *, follow_wrapper_chains=True):
     """Private helper. Checks if ``cls`` has an attribute
     named ``method_name`` and returns it only if it is a
     pure python function.
     """
-    try:
-        meth = getattr(cls, method_name)
-    except AttributeError:
-        return
+    if method_name == '__new__':
+        meth = getattr(cls, method_name, None)
     else:
-        if not isinstance(meth, _NonUserDefinedCallables):
-            # Once '__signature__' will be added to 'C'-level
-            # callables, this check won't be necessary
-            return meth
+        meth = getattr_static(cls, method_name, None)
+    if meth is None:
+        return None
+
+    # NOTE: The meth may wraps a non-user-defined callable.
+    # In this case, we treat the meth as non-user-defined callable too.
+    # (e.g. cls.__new__ generated by @warnings.deprecated)
+    unwrapped_meth = None
+    if follow_wrapper_chains:
+        unwrapped_meth = unwrap(meth, stop=(lambda m: hasattr(m, "__signature__")
+                                  or _signature_is_builtin(m)))
+
+    if (isinstance(meth, _NonUserDefinedCallables)
+          or isinstance(unwrapped_meth, _NonUserDefinedCallables)):
+        # Once '__signature__' will be added to 'C'-level
+        # callables, this check won't be necessary
+        return None
+    if method_name != '__new__':
+        meth = _descriptor_get(meth, cls)
+    return meth
 
 
 def _signature_get_partial(wrapped_sig, partial, extra_args=()):
@@ -1834,8 +2145,10 @@ def _signature_is_builtin(obj):
             ismethoddescriptor(obj) or
             isinstance(obj, _NonUserDefinedCallables) or
             # Can't test 'isinstance(type)' here, as it would
-            # also be True for regular python classes
-            obj in (type, object))
+            # also be True for regular python classes.
+            # Can't use the `in` operator here, as it would
+            # invoke the custom __eq__ method.
+            obj is type or obj is object)
 
 
 def _signature_is_functionlike(obj):
@@ -1860,30 +2173,7 @@ def _signature_is_functionlike(obj):
             isinstance(name, str) and
             (defaults is None or isinstance(defaults, tuple)) and
             (kwdefaults is None or isinstance(kwdefaults, dict)) and
-            isinstance(annotations, dict))
-
-
-def _signature_get_bound_param(spec):
-    """ Private helper to get first parameter name from a
-    __text_signature__ of a builtin method, which should
-    be in the following format: '($param1, ...)'.
-    Assumptions are that the first argument won't have
-    a default value or an annotation.
-    """
-
-    assert spec.startswith('($')
-
-    pos = spec.find(',')
-    if pos == -1:
-        pos = spec.find(')')
-
-    cpos = spec.find(':')
-    assert cpos == -1 or cpos > pos
-
-    cpos = spec.find('=')
-    assert cpos == -1 or cpos > pos
-
-    return spec[2:pos]
+            (isinstance(annotations, (dict)) or annotations is None) )
 
 
 def _signature_strip_non_python_syntax(signature):
@@ -1891,26 +2181,21 @@ def _signature_strip_non_python_syntax(signature):
     Private helper function. Takes a signature in Argument Clinic's
     extended signature format.
 
-    Returns a tuple of three things:
-      * that signature re-rendered in standard Python syntax,
+    Returns a tuple of two things:
+      * that signature re-rendered in standard Python syntax, and
       * the index of the "self" parameter (generally 0), or None if
-        the function does not have a "self" parameter, and
-      * the index of the last "positional only" parameter,
-        or None if the signature has no positional-only parameters.
+        the function does not have a "self" parameter.
     """
 
     if not signature:
-        return signature, None, None
+        return signature, None
 
     self_parameter = None
-    last_positional_only = None
 
-    lines = [l.encode('ascii') for l in signature.split('\n')]
+    lines = [l.encode('ascii') for l in signature.split('\n') if l]
     generator = iter(lines).__next__
     token_stream = tokenize.tokenize(generator)
 
-    delayed_comma = False
-    skip_next_comma = False
     text = []
     add = text.append
 
@@ -1927,49 +2212,27 @@ def _signature_strip_non_python_syntax(signature):
 
         if type == OP:
             if string == ',':
-                if skip_next_comma:
-                    skip_next_comma = False
-                else:
-                    assert not delayed_comma
-                    delayed_comma = True
-                    current_parameter += 1
-                continue
+                current_parameter += 1
 
-            if string == '/':
-                assert not skip_next_comma
-                assert last_positional_only is None
-                skip_next_comma = True
-                last_positional_only = current_parameter - 1
-                continue
-
-        if (type == ERRORTOKEN) and (string == '$'):
+        if (type == OP) and (string == '$'):
             assert self_parameter is None
             self_parameter = current_parameter
             continue
 
-        if delayed_comma:
-            delayed_comma = False
-            if not ((type == OP) and (string == ')')):
-                add(', ')
         add(string)
         if (string == ','):
             add(' ')
-    clean_signature = ''.join(text)
-    return clean_signature, self_parameter, last_positional_only
+    clean_signature = ''.join(text).strip().replace("\n", "")
+    return clean_signature, self_parameter
 
 
 def _signature_fromstr(cls, obj, s, skip_bound_arg=True):
     """Private helper to parse content of '__text_signature__'
     and return a Signature based on it.
     """
-    # Lazy import ast because it's relatively heavy and
-    # it's not used for other than this function.
-    import ast
-
     Parameter = cls._parameter_cls
 
-    clean_signature, self_parameter, last_positional_only = \
-        _signature_strip_non_python_syntax(s)
+    clean_signature, self_parameter = _signature_strip_non_python_syntax(s)
 
     program = "def foo" + clean_signature + ": pass"
 
@@ -1985,11 +2248,15 @@ def _signature_fromstr(cls, obj, s, skip_bound_arg=True):
 
     parameters = []
     empty = Parameter.empty
-    invalid = object()
 
     module = None
     module_dict = {}
+
     module_name = getattr(obj, '__module__', None)
+    if not module_name:
+        objclass = getattr(obj, '__objclass__', None)
+        module_name = getattr(objclass, '__module__', None)
+
     if module_name:
         module = sys.modules.get(module_name, None)
         if module:
@@ -2009,11 +2276,11 @@ def wrap_value(s):
             try:
                 value = eval(s, sys_module_dict)
             except NameError:
-                raise RuntimeError()
+                raise ValueError
 
         if isinstance(value, (str, int, float, bytes, bool, type(None))):
             return ast.Constant(value)
-        raise RuntimeError()
+        raise ValueError
 
     class RewriteSymbolics(ast.NodeTransformer):
         def visit_Attribute(self, node):
@@ -2023,7 +2290,7 @@ def visit_Attribute(self, node):
                 a.append(n.attr)
                 n = n.value
             if not isinstance(n, ast.Name):
-                raise RuntimeError()
+                raise ValueError
             a.append(n.id)
             value = ".".join(reversed(a))
             return wrap_value(value)
@@ -2033,33 +2300,43 @@ def visit_Name(self, node):
                 raise ValueError()
             return wrap_value(node.id)
 
+        def visit_BinOp(self, node):
+            # Support constant folding of a couple simple binary operations
+            # commonly used to define default values in text signatures
+            left = self.visit(node.left)
+            right = self.visit(node.right)
+            if not isinstance(left, ast.Constant) or not isinstance(right, ast.Constant):
+                raise ValueError
+            if isinstance(node.op, ast.Add):
+                return ast.Constant(left.value + right.value)
+            elif isinstance(node.op, ast.Sub):
+                return ast.Constant(left.value - right.value)
+            elif isinstance(node.op, ast.BitOr):
+                return ast.Constant(left.value | right.value)
+            raise ValueError
+
     def p(name_node, default_node, default=empty):
         name = parse_name(name_node)
-        if name is invalid:
-            return None
         if default_node and default_node is not _empty:
             try:
                 default_node = RewriteSymbolics().visit(default_node)
-                o = ast.literal_eval(default_node)
+                default = ast.literal_eval(default_node)
             except ValueError:
-                o = invalid
-            if o is invalid:
-                return None
-            default = o if o is not invalid else default
+                raise ValueError("{!r} builtin has invalid signature".format(obj)) from None
         parameters.append(Parameter(name, kind, default=default, annotation=empty))
 
     # non-keyword-only parameters
-    args = reversed(f.args.args)
-    defaults = reversed(f.args.defaults)
-    iter = itertools.zip_longest(args, defaults, fillvalue=None)
-    if last_positional_only is not None:
-        kind = Parameter.POSITIONAL_ONLY
-    else:
-        kind = Parameter.POSITIONAL_OR_KEYWORD
-    for i, (name, default) in enumerate(reversed(list(iter))):
+    total_non_kw_args = len(f.args.posonlyargs) + len(f.args.args)
+    required_non_kw_args = total_non_kw_args - len(f.args.defaults)
+    defaults = itertools.chain(itertools.repeat(None, required_non_kw_args), f.args.defaults)
+
+    kind = Parameter.POSITIONAL_ONLY
+    for (name, default) in zip(f.args.posonlyargs, defaults):
+        p(name, default)
+
+    kind = Parameter.POSITIONAL_OR_KEYWORD
+    for (name, default) in zip(f.args.args, defaults):
         p(name, default)
-        if i == last_positional_only:
-            kind = Parameter.POSITIONAL_OR_KEYWORD
 
     # *args
     if f.args.vararg:
@@ -2112,7 +2389,8 @@ def _signature_from_builtin(cls, func, skip_bound_arg=True):
     return _signature_fromstr(cls, func, s, skip_bound_arg)
 
 
-def _signature_from_function(cls, func, skip_bound_arg=True):
+def _signature_from_function(cls, func, skip_bound_arg=True,
+                             globals=None, locals=None, eval_str=False):
     """Private helper: constructs Signature for the given python function."""
 
     is_duck_function = False
@@ -2138,7 +2416,7 @@ def _signature_from_function(cls, func, skip_bound_arg=True):
     positional = arg_names[:pos_count]
     keyword_only_count = func_code.co_kwonlyargcount
     keyword_only = arg_names[pos_count:pos_count + keyword_only_count]
-    annotations = func.__annotations__
+    annotations = get_annotations(func, globals=globals, locals=locals, eval_str=eval_str)
     defaults = func.__defaults__
     kwdefaults = func.__kwdefaults__
 
@@ -2206,26 +2484,42 @@ def _signature_from_function(cls, func, skip_bound_arg=True):
                __validate_parameters__=is_duck_function)
 
 
+def _descriptor_get(descriptor, obj):
+    if isclass(descriptor):
+        return descriptor
+    get = getattr(type(descriptor), '__get__', _sentinel)
+    if get is _sentinel:
+        return descriptor
+    return get(descriptor, obj, type(obj))
+
+
 def _signature_from_callable(obj, *,
                              follow_wrapper_chains=True,
                              skip_bound_arg=True,
+                             globals=None,
+                             locals=None,
+                             eval_str=False,
                              sigcls):
 
     """Private helper function to get signature for arbitrary
     callable objects.
     """
 
+    _get_signature_of = functools.partial(_signature_from_callable,
+                                follow_wrapper_chains=follow_wrapper_chains,
+                                skip_bound_arg=skip_bound_arg,
+                                globals=globals,
+                                locals=locals,
+                                sigcls=sigcls,
+                                eval_str=eval_str)
+
     if not callable(obj):
         raise TypeError('{!r} is not a callable object'.format(obj))
 
     if isinstance(obj, types.MethodType):
         # In this case we skip the first parameter of the underlying
         # function (usually `self` or `cls`).
-        sig = _signature_from_callable(
-            obj.__func__,
-            follow_wrapper_chains=follow_wrapper_chains,
-            skip_bound_arg=skip_bound_arg,
-            sigcls=sigcls)
+        sig = _get_signature_of(obj.__func__)
 
         if skip_bound_arg:
             return _signature_bound_method(sig)
@@ -2234,16 +2528,15 @@ def _signature_from_callable(obj, *,
 
     # Was this function wrapped by a decorator?
     if follow_wrapper_chains:
-        obj = unwrap(obj, stop=(lambda f: hasattr(f, "__signature__")))
+        # Unwrap until we find an explicit signature or a MethodType (which will be
+        # handled explicitly below).
+        obj = unwrap(obj, stop=(lambda f: hasattr(f, "__signature__")
+                                or isinstance(f, types.MethodType)))
         if isinstance(obj, types.MethodType):
             # If the unwrapped object is a *method*, we might want to
             # skip its first parameter (self).
             # See test_signature_wrapped_bound_method for details.
-            return _signature_from_callable(
-                obj,
-                follow_wrapper_chains=follow_wrapper_chains,
-                skip_bound_arg=skip_bound_arg,
-                sigcls=sigcls)
+            return _get_signature_of(obj)
 
     try:
         sig = obj.__signature__
@@ -2251,14 +2544,22 @@ def _signature_from_callable(obj, *,
         pass
     else:
         if sig is not None:
+            # since __text_signature__ is not writable on classes, __signature__
+            # may contain text (or be a callable that returns text);
+            # if so, convert it
+            o_sig = sig
+            if not isinstance(sig, (Signature, str)) and callable(sig):
+                sig = sig()
+            if isinstance(sig, str):
+                sig = _signature_fromstr(sigcls, obj, sig)
             if not isinstance(sig, Signature):
                 raise TypeError(
                     'unexpected object {!r} in __signature__ '
-                    'attribute'.format(sig))
+                    'attribute'.format(o_sig))
             return sig
 
     try:
-        partialmethod = obj._partialmethod
+        partialmethod = obj.__partialmethod__
     except AttributeError:
         pass
     else:
@@ -2270,11 +2571,7 @@ def _signature_from_callable(obj, *,
             # (usually `self`, or `cls`) will not be passed
             # automatically (as for boundmethods)
 
-            wrapped_sig = _signature_from_callable(
-                partialmethod.func,
-                follow_wrapper_chains=follow_wrapper_chains,
-                skip_bound_arg=skip_bound_arg,
-                sigcls=sigcls)
+            wrapped_sig = _get_signature_of(partialmethod.func)
 
             sig = _signature_get_partial(wrapped_sig, partialmethod, (None,))
             first_wrapped_param = tuple(wrapped_sig.parameters.values())[0]
@@ -2289,121 +2586,112 @@ def _signature_from_callable(obj, *,
                 new_params = (first_wrapped_param,) + sig_params
                 return sig.replace(parameters=new_params)
 
+    if isinstance(obj, functools.partial):
+        wrapped_sig = _get_signature_of(obj.func)
+        return _signature_get_partial(wrapped_sig, obj)
+
     if isfunction(obj) or _signature_is_functionlike(obj):
         # If it's a pure Python function, or an object that is duck type
         # of a Python function (Cython functions, for instance), then:
         return _signature_from_function(sigcls, obj,
-                                        skip_bound_arg=skip_bound_arg)
+                                        skip_bound_arg=skip_bound_arg,
+                                        globals=globals, locals=locals, eval_str=eval_str)
 
     if _signature_is_builtin(obj):
         return _signature_from_builtin(sigcls, obj,
                                        skip_bound_arg=skip_bound_arg)
 
-    if isinstance(obj, functools.partial):
-        wrapped_sig = _signature_from_callable(
-            obj.func,
-            follow_wrapper_chains=follow_wrapper_chains,
-            skip_bound_arg=skip_bound_arg,
-            sigcls=sigcls)
-        return _signature_get_partial(wrapped_sig, obj)
-
-    sig = None
     if isinstance(obj, type):
         # obj is a class or a metaclass
 
         # First, let's see if it has an overloaded __call__ defined
         # in its metaclass
-        call = _signature_get_user_defined_method(type(obj), '__call__')
+        call = _signature_get_user_defined_method(
+            type(obj),
+            '__call__',
+            follow_wrapper_chains=follow_wrapper_chains,
+        )
         if call is not None:
-            sig = _signature_from_callable(
-                call,
-                follow_wrapper_chains=follow_wrapper_chains,
-                skip_bound_arg=skip_bound_arg,
-                sigcls=sigcls)
-        else:
-            # Now we check if the 'obj' class has a '__new__' method
-            new = _signature_get_user_defined_method(obj, '__new__')
-            if new is not None:
-                sig = _signature_from_callable(
-                    new,
-                    follow_wrapper_chains=follow_wrapper_chains,
-                    skip_bound_arg=skip_bound_arg,
-                    sigcls=sigcls)
+            return _get_signature_of(call)
+
+        # NOTE: The user-defined method can be a function with a thin wrapper
+        # around object.__new__ (e.g., generated by `@warnings.deprecated`)
+        new = _signature_get_user_defined_method(
+            obj,
+            '__new__',
+            follow_wrapper_chains=follow_wrapper_chains,
+        )
+        init = _signature_get_user_defined_method(
+            obj,
+            '__init__',
+            follow_wrapper_chains=follow_wrapper_chains,
+        )
+
+        # Go through the MRO and see if any class has user-defined
+        # pure Python __new__ or __init__ method
+        for base in obj.__mro__:
+            # Now we check if the 'obj' class has an own '__new__' method
+            if new is not None and '__new__' in base.__dict__:
+                sig = _get_signature_of(new)
+                if skip_bound_arg:
+                    sig = _signature_bound_method(sig)
+                return sig
+            # or an own '__init__' method
+            elif init is not None and '__init__' in base.__dict__:
+                return _get_signature_of(init)
+
+        # At this point we know, that `obj` is a class, with no user-
+        # defined '__init__', '__new__', or class-level '__call__'
+
+        for base in obj.__mro__[:-1]:
+            # Since '__text_signature__' is implemented as a
+            # descriptor that extracts text signature from the
+            # class docstring, if 'obj' is derived from a builtin
+            # class, its own '__text_signature__' may be 'None'.
+            # Therefore, we go through the MRO (except the last
+            # class in there, which is 'object') to find the first
+            # class with non-empty text signature.
+            try:
+                text_sig = base.__text_signature__
+            except AttributeError:
+                pass
             else:
-                # Finally, we should have at least __init__ implemented
-                init = _signature_get_user_defined_method(obj, '__init__')
-                if init is not None:
-                    sig = _signature_from_callable(
-                        init,
-                        follow_wrapper_chains=follow_wrapper_chains,
-                        skip_bound_arg=skip_bound_arg,
-                        sigcls=sigcls)
-
-        if sig is None:
-            # At this point we know, that `obj` is a class, with no user-
-            # defined '__init__', '__new__', or class-level '__call__'
-
-            for base in obj.__mro__[:-1]:
-                # Since '__text_signature__' is implemented as a
-                # descriptor that extracts text signature from the
-                # class docstring, if 'obj' is derived from a builtin
-                # class, its own '__text_signature__' may be 'None'.
-                # Therefore, we go through the MRO (except the last
-                # class in there, which is 'object') to find the first
-                # class with non-empty text signature.
-                try:
-                    text_sig = base.__text_signature__
-                except AttributeError:
-                    pass
-                else:
-                    if text_sig:
-                        # If 'obj' class has a __text_signature__ attribute:
-                        # return a signature based on it
-                        return _signature_fromstr(sigcls, obj, text_sig)
-
-            # No '__text_signature__' was found for the 'obj' class.
-            # Last option is to check if its '__init__' is
-            # object.__init__ or type.__init__.
-            if type not in obj.__mro__:
-                # We have a class (not metaclass), but no user-defined
-                # __init__ or __new__ for it
-                if (obj.__init__ is object.__init__ and
-                    obj.__new__ is object.__new__):
-                    # Return a signature of 'object' builtin.
-                    return sigcls.from_callable(object)
-                else:
-                    raise ValueError(
-                        'no signature found for builtin type {!r}'.format(obj))
+                if text_sig:
+                    # If 'base' class has a __text_signature__ attribute:
+                    # return a signature based on it
+                    return _signature_fromstr(sigcls, base, text_sig)
+
+        # No '__text_signature__' was found for the 'obj' class.
+        # Last option is to check if its '__init__' is
+        # object.__init__ or type.__init__.
+        if type not in obj.__mro__:
+            obj_init = obj.__init__
+            obj_new = obj.__new__
+            if follow_wrapper_chains:
+                obj_init = unwrap(obj_init)
+                obj_new = unwrap(obj_new)
+            # We have a class (not metaclass), but no user-defined
+            # __init__ or __new__ for it
+            if obj_init is object.__init__ and obj_new is object.__new__:
+                # Return a signature of 'object' builtin.
+                return sigcls.from_callable(object)
+            else:
+                raise ValueError(
+                    'no signature found for builtin type {!r}'.format(obj))
 
-    elif not isinstance(obj, _NonUserDefinedCallables):
+    else:
         # An object with __call__
-        # We also check that the 'obj' is not an instance of
-        # _WrapperDescriptor or _MethodWrapper to avoid
-        # infinite recursion (and even potential segfault)
-        call = _signature_get_user_defined_method(type(obj), '__call__')
+        call = getattr_static(type(obj), '__call__', None)
         if call is not None:
             try:
-                sig = _signature_from_callable(
-                    call,
-                    follow_wrapper_chains=follow_wrapper_chains,
-                    skip_bound_arg=skip_bound_arg,
-                    sigcls=sigcls)
-            except ValueError as ex:
-                msg = 'no signature found for {!r}'.format(obj)
-                raise ValueError(msg) from ex
-
-    if sig is not None:
-        # For classes and objects we skip the first parameter of their
-        # __call__, __new__, or __init__ methods
-        if skip_bound_arg:
-            return _signature_bound_method(sig)
-        else:
-            return sig
-
-    if isinstance(obj, types.BuiltinFunctionType):
-        # Raise a nicer error message for builtins
-        msg = 'no signature found for builtin function {!r}'.format(obj)
-        raise ValueError(msg)
+                text_sig = obj.__text_signature__
+            except AttributeError:
+                pass
+            else:
+                if text_sig:
+                    return _signature_fromstr(sigcls, obj, text_sig)
+            call = _descriptor_get(call, obj)
+            return _get_signature_of(call)
 
     raise ValueError('callable {!r} is not supported by signature'.format(obj))
 
@@ -2417,18 +2705,21 @@ class _empty:
 
 
 class _ParameterKind(enum.IntEnum):
-    POSITIONAL_ONLY = 0
-    POSITIONAL_OR_KEYWORD = 1
-    VAR_POSITIONAL = 2
-    KEYWORD_ONLY = 3
-    VAR_KEYWORD = 4
+    POSITIONAL_ONLY = 'positional-only'
+    POSITIONAL_OR_KEYWORD = 'positional or keyword'
+    VAR_POSITIONAL = 'variadic positional'
+    KEYWORD_ONLY = 'keyword-only'
+    VAR_KEYWORD = 'variadic keyword'
+
+    def __new__(cls, description):
+        value = len(cls.__members__)
+        member = int.__new__(cls, value)
+        member._value_ = value
+        member.description = description
+        return member
 
     def __str__(self):
-        return self._name_
-
-    @property
-    def description(self):
-        return _PARAM_NAME_MAPPING[self]
+        return self.name
 
 _POSITIONAL_ONLY         = _ParameterKind.POSITIONAL_ONLY
 _POSITIONAL_OR_KEYWORD   = _ParameterKind.POSITIONAL_OR_KEYWORD
@@ -2436,14 +2727,6 @@ def description(self):
 _KEYWORD_ONLY            = _ParameterKind.KEYWORD_ONLY
 _VAR_KEYWORD             = _ParameterKind.VAR_KEYWORD
 
-_PARAM_NAME_MAPPING = {
-    _POSITIONAL_ONLY: 'positional-only',
-    _POSITIONAL_OR_KEYWORD: 'positional or keyword',
-    _VAR_POSITIONAL: 'variadic positional',
-    _KEYWORD_ONLY: 'keyword-only',
-    _VAR_KEYWORD: 'variadic keyword'
-}
-
 
 class Parameter:
     """Represents a parameter in a function signature.
@@ -2512,7 +2795,10 @@ def __init__(self, name, kind, *, default=_empty, annotation=_empty):
             self._kind = _POSITIONAL_ONLY
             name = 'implicit{}'.format(name[1:])
 
-        if not name.isidentifier():
+        # It's possible for C functions to have a positional-only parameter
+        # where the name is a keyword, so for compatibility we'll allow it.
+        is_keyword = iskeyword(name) and self._kind is not _POSITIONAL_ONLY
+        if is_keyword or not name.isidentifier():
             raise ValueError('{!r} is not a valid parameter name'.format(name))
 
         self._name = name
@@ -2583,11 +2869,13 @@ def __str__(self):
 
         return formatted
 
+    __replace__ = replace
+
     def __repr__(self):
         return '<{} "{}">'.format(self.__class__.__name__, self)
 
     def __hash__(self):
-        return hash((self.name, self.kind, self.annotation, self.default))
+        return hash((self._name, self._kind, self._annotation, self._default))
 
     def __eq__(self, other):
         if self is other:
@@ -2606,7 +2894,7 @@ class BoundArguments:
 
     Has the following public attributes:
 
-    * arguments : OrderedDict
+    * arguments : dict
         An ordered mutable mapping of parameters' names to arguments' values.
         Does not contain arguments' default values.
     * signature : Signature
@@ -2706,7 +2994,7 @@ def apply_defaults(self):
                     # Signature.bind_partial().
                     continue
                 new_arguments.append((name, val))
-        self.arguments = OrderedDict(new_arguments)
+        self.arguments = dict(new_arguments)
 
     def __eq__(self, other):
         if self is other:
@@ -2772,9 +3060,9 @@ def __init__(self, parameters=None, *, return_annotation=_empty,
             if __validate_parameters__:
                 params = OrderedDict()
                 top_kind = _POSITIONAL_ONLY
-                kind_defaults = False
+                seen_default = False
 
-                for idx, param in enumerate(parameters):
+                for param in parameters:
                     kind = param.kind
                     name = param.name
 
@@ -2787,21 +3075,19 @@ def __init__(self, parameters=None, *, return_annotation=_empty,
                                          kind.description)
                         raise ValueError(msg)
                     elif kind > top_kind:
-                        kind_defaults = False
                         top_kind = kind
 
                     if kind in (_POSITIONAL_ONLY, _POSITIONAL_OR_KEYWORD):
                         if param.default is _empty:
-                            if kind_defaults:
+                            if seen_default:
                                 # No default for this parameter, but the
-                                # previous parameter of the same kind had
-                                # a default
+                                # previous parameter of had a default
                                 msg = 'non-default argument follows default ' \
                                       'argument'
                                 raise ValueError(msg)
                         else:
                             # There is a default for this parameter.
-                            kind_defaults = True
+                            seen_default = True
 
                     if name in params:
                         msg = 'duplicate parameter name: {!r}'.format(name)
@@ -2809,41 +3095,18 @@ def __init__(self, parameters=None, *, return_annotation=_empty,
 
                     params[name] = param
             else:
-                params = OrderedDict(((param.name, param)
-                                                for param in parameters))
+                params = OrderedDict((param.name, param) for param in parameters)
 
         self._parameters = types.MappingProxyType(params)
         self._return_annotation = return_annotation
 
     @classmethod
-    def from_function(cls, func):
-        """Constructs Signature for the given python function.
-
-        Deprecated since Python 3.5, use `Signature.from_callable()`.
-        """
-
-        warnings.warn("inspect.Signature.from_function() is deprecated since "
-                      "Python 3.5, use Signature.from_callable()",
-                      DeprecationWarning, stacklevel=2)
-        return _signature_from_function(cls, func)
-
-    @classmethod
-    def from_builtin(cls, func):
-        """Constructs Signature for the given builtin function.
-
-        Deprecated since Python 3.5, use `Signature.from_callable()`.
-        """
-
-        warnings.warn("inspect.Signature.from_builtin() is deprecated since "
-                      "Python 3.5, use Signature.from_callable()",
-                      DeprecationWarning, stacklevel=2)
-        return _signature_from_builtin(cls, func)
-
-    @classmethod
-    def from_callable(cls, obj, *, follow_wrapped=True):
+    def from_callable(cls, obj, *,
+                      follow_wrapped=True, globals=None, locals=None, eval_str=False):
         """Constructs Signature for the given callable object."""
         return _signature_from_callable(obj, sigcls=cls,
-                                        follow_wrapper_chains=follow_wrapped)
+                                        follow_wrapper_chains=follow_wrapped,
+                                        globals=globals, locals=locals, eval_str=eval_str)
 
     @property
     def parameters(self):
@@ -2868,6 +3131,8 @@ def replace(self, *, parameters=_void, return_annotation=_void):
         return type(self)(parameters,
                           return_annotation=return_annotation)
 
+    __replace__ = replace
+
     def _hash_basis(self):
         params = tuple(param for param in self.parameters.values()
                              if param.kind != _KEYWORD_ONLY)
@@ -2892,12 +3157,14 @@ def __eq__(self, other):
     def _bind(self, args, kwargs, *, partial=False):
         """Private method. Don't use directly."""
 
-        arguments = OrderedDict()
+        arguments = {}
 
         parameters = iter(self.parameters.values())
         parameters_ex = ()
         arg_vals = iter(args)
 
+        pos_only_param_in_kwargs = []
+
         while True:
             # Let's iterate through the positional arguments and corresponding
             # parameters
@@ -2918,10 +3185,13 @@ def _bind(self, args, kwargs, *, partial=False):
                         break
                     elif param.name in kwargs:
                         if param.kind == _POSITIONAL_ONLY:
-                            msg = '{arg!r} parameter is positional only, ' \
-                                  'but was passed as a keyword'
-                            msg = msg.format(arg=param.name)
-                            raise TypeError(msg) from None
+                            if param.default is _empty:
+                                msg = f'missing a required positional-only argument: {param.name!r}'
+                                raise TypeError(msg)
+                            # Raise a TypeError once we are sure there is no
+                            # **kwargs param later.
+                            pos_only_param_in_kwargs.append(param)
+                            continue
                         parameters_ex = (param,)
                         break
                     elif (param.kind == _VAR_KEYWORD or
@@ -2938,8 +3208,12 @@ def _bind(self, args, kwargs, *, partial=False):
                             parameters_ex = (param,)
                             break
                         else:
-                            msg = 'missing a required argument: {arg!r}'
-                            msg = msg.format(arg=param.name)
+                            if param.kind == _KEYWORD_ONLY:
+                                argtype = ' keyword-only'
+                            else:
+                                argtype = ''
+                            msg = 'missing a required{argtype} argument: {arg!r}'
+                            msg = msg.format(arg=param.name, argtype=argtype)
                             raise TypeError(msg) from None
             else:
                 # We have a positional argument to process
@@ -2999,20 +3273,22 @@ def _bind(self, args, kwargs, *, partial=False):
                                     format(arg=param_name)) from None
 
             else:
-                if param.kind == _POSITIONAL_ONLY:
-                    # This should never happen in case of a properly built
-                    # Signature object (but let's have this check here
-                    # to ensure correct behaviour just in case)
-                    raise TypeError('{arg!r} parameter is positional only, '
-                                    'but was passed as a keyword'. \
-                                    format(arg=param.name))
-
                 arguments[param_name] = arg_val
 
         if kwargs:
             if kwargs_param is not None:
                 # Process our '**kwargs'-like parameter
                 arguments[kwargs_param.name] = kwargs
+            elif pos_only_param_in_kwargs:
+                raise TypeError(
+                    'got some positional-only arguments passed as '
+                    'keyword arguments: {arg!r}'.format(
+                        arg=', '.join(
+                            param.name
+                            for param in pos_only_param_in_kwargs
+                        ),
+                    ),
+                )
             else:
                 raise TypeError(
                     'got an unexpected keyword argument {arg!r}'.format(
@@ -3046,6 +3322,16 @@ def __repr__(self):
         return '<{} {}>'.format(self.__class__.__name__, self)
 
     def __str__(self):
+        return self.format()
+
+    def format(self, *, max_width=None):
+        """Create a string representation of the Signature object.
+
+        If *max_width* integer is passed,
+        signature will try to fit into the *max_width*.
+        If signature is longer than *max_width*,
+        all parameters will be on separate lines.
+        """
         result = []
         render_pos_only_separator = False
         render_kw_only_separator = True
@@ -3083,6 +3369,8 @@ def __str__(self):
             result.append('/')
 
         rendered = '({})'.format(', '.join(result))
+        if max_width is not None and len(rendered) > max_width:
+            rendered = '(\n    {}\n)'.format(',\n    '.join(result))
 
         if self.return_annotation is not _empty:
             anno = formatannotation(self.return_annotation)
@@ -3091,9 +3379,32 @@ def __str__(self):
         return rendered
 
 
-def signature(obj, *, follow_wrapped=True):
+def signature(obj, *, follow_wrapped=True, globals=None, locals=None, eval_str=False):
     """Get a signature object for the passed callable."""
-    return Signature.from_callable(obj, follow_wrapped=follow_wrapped)
+    return Signature.from_callable(obj, follow_wrapped=follow_wrapped,
+                                   globals=globals, locals=locals, eval_str=eval_str)
+
+
+class BufferFlags(enum.IntFlag):
+    SIMPLE = 0x0
+    WRITABLE = 0x1
+    FORMAT = 0x4
+    ND = 0x8
+    STRIDES = 0x10 | ND
+    C_CONTIGUOUS = 0x20 | STRIDES
+    F_CONTIGUOUS = 0x40 | STRIDES
+    ANY_CONTIGUOUS = 0x80 | STRIDES
+    INDIRECT = 0x100 | STRIDES
+    CONTIG = ND | WRITABLE
+    CONTIG_RO = ND
+    STRIDED = STRIDES | WRITABLE
+    STRIDED_RO = STRIDES
+    RECORDS = STRIDES | WRITABLE | FORMAT
+    RECORDS_RO = STRIDES | FORMAT
+    FULL = INDIRECT | WRITABLE | FORMAT
+    FULL_RO = INDIRECT | FORMAT
+    READ = 0x100
+    WRITE = 0x200
 
 
 def _main():
diff --git a/Lib/io.py b/Lib/io.py
index c2812876d3..f0e2fa15d5 100644
--- a/Lib/io.py
+++ b/Lib/io.py
@@ -46,23 +46,17 @@
            "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"]
 
 
 import _io
 import abc
 
 from _io import (DEFAULT_BUFFER_SIZE, BlockingIOError, UnsupportedOperation,
-                 open, open_code, BytesIO, StringIO, BufferedReader,
+                 open, open_code, FileIO, BytesIO, StringIO, BufferedReader,
                  BufferedWriter, BufferedRWPair, BufferedRandom,
                  IncrementalNewlineDecoder, text_encoding, TextIOWrapper)
 
-try:
-    from _io import FileIO
-except ImportError:
-    pass
 
 # Pretend this exception was created here.
 UnsupportedOperation.__module__ = "io"
@@ -87,10 +81,7 @@ class BufferedIOBase(_io._BufferedIOBase, IOBase):
 class TextIOBase(_io._TextIOBase, IOBase):
     __doc__ = _io._TextIOBase.__doc__
 
-try:
-    RawIOBase.register(FileIO)
-except NameError:
-    pass
+RawIOBase.register(FileIO)
 
 for klass in (BytesIO, BufferedReader, BufferedWriter, BufferedRandom,
               BufferedRWPair):
diff --git a/Lib/json/__init__.py b/Lib/json/__init__.py
index e4c21daaf3..c7a6dcdf77 100644
--- a/Lib/json/__init__.py
+++ b/Lib/json/__init__.py
@@ -1,4 +1,4 @@
-r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of
+r"""JSON (JavaScript Object Notation) <https://json.org> is a subset of
 JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
 interchange format.
 
@@ -128,8 +128,9 @@ def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     instead of raising a ``TypeError``.
 
     If ``ensure_ascii`` is false, then the strings written to ``fp`` can
-    contain non-ASCII characters if they appear in strings contained in
-    ``obj``. Otherwise, all such characters are escaped in JSON strings.
+    contain non-ASCII and non-printable characters if they appear in strings
+    contained in ``obj``. Otherwise, all such characters are escaped in JSON
+    strings.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will
@@ -145,10 +146,11 @@ def dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     level of 0 will only insert newlines. ``None`` is the most compact
     representation.
 
-    If specified, ``separators`` should be an ``(item_separator, key_separator)``
-    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
-    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
-    you should specify ``(',', ':')`` to eliminate whitespace.
+    If specified, ``separators`` should be an ``(item_separator,
+    key_separator)`` tuple.  The default is ``(', ', ': ')`` if *indent* is
+    ``None`` and ``(',', ': ')`` otherwise.  To get the most compact JSON
+    representation, you should specify ``(',', ':')`` to eliminate
+    whitespace.
 
     ``default(obj)`` is a function that should return a serializable version
     of obj or raise TypeError. The default simply raises TypeError.
@@ -189,9 +191,10 @@ def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
     instead of raising a ``TypeError``.
 
-    If ``ensure_ascii`` is false, then the return value can contain non-ASCII
-    characters if they appear in strings contained in ``obj``. Otherwise, all
-    such characters are escaped in JSON strings.
+    If ``ensure_ascii`` is false, then the return value can contain
+    non-ASCII and non-printable characters if they appear in strings
+    contained in ``obj``.  Otherwise, all such characters are escaped in
+    JSON strings.
 
     If ``check_circular`` is false, then the circular reference check
     for container types will be skipped and a circular reference will
@@ -207,10 +210,11 @@ def dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True,
     level of 0 will only insert newlines. ``None`` is the most compact
     representation.
 
-    If specified, ``separators`` should be an ``(item_separator, key_separator)``
-    tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
-    ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
-    you should specify ``(',', ':')`` to eliminate whitespace.
+    If specified, ``separators`` should be an ``(item_separator,
+    key_separator)`` tuple.  The default is ``(', ', ': ')`` if *indent* is
+    ``None`` and ``(',', ': ')`` otherwise.  To get the most compact JSON
+    representation, you should specify ``(',', ':')`` to eliminate
+    whitespace.
 
     ``default(obj)`` is a function that should return a serializable version
     of obj or raise TypeError. The default simply raises TypeError.
@@ -281,11 +285,12 @@ def load(fp, *, cls=None, object_hook=None, parse_float=None,
     ``object_hook`` will be used instead of the ``dict``. This feature
     can be used to implement custom decoders (e.g. JSON-RPC class hinting).
 
-    ``object_pairs_hook`` is an optional function that will be called with the
-    result of any object literal decoded with an ordered list of pairs.  The
-    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
-    This feature can be used to implement custom decoders.  If ``object_hook``
-    is also defined, the ``object_pairs_hook`` takes priority.
+    ``object_pairs_hook`` is an optional function that will be called with
+    the result of any object literal decoded with an ordered list of pairs.
+    The return value of ``object_pairs_hook`` will be used instead of the
+    ``dict``.  This feature can be used to implement custom decoders.  If
+    ``object_hook`` is also defined, the ``object_pairs_hook`` takes
+    priority.
 
     To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
     kwarg; otherwise ``JSONDecoder`` is used.
@@ -306,11 +311,12 @@ def loads(s, *, cls=None, object_hook=None, parse_float=None,
     ``object_hook`` will be used instead of the ``dict``. This feature
     can be used to implement custom decoders (e.g. JSON-RPC class hinting).
 
-    ``object_pairs_hook`` is an optional function that will be called with the
-    result of any object literal decoded with an ordered list of pairs.  The
-    return value of ``object_pairs_hook`` will be used instead of the ``dict``.
-    This feature can be used to implement custom decoders.  If ``object_hook``
-    is also defined, the ``object_pairs_hook`` takes priority.
+    ``object_pairs_hook`` is an optional function that will be called with
+    the result of any object literal decoded with an ordered list of pairs.
+    The return value of ``object_pairs_hook`` will be used instead of the
+    ``dict``.  This feature can be used to implement custom decoders.  If
+    ``object_hook`` is also defined, the ``object_pairs_hook`` takes
+    priority.
 
     ``parse_float``, if specified, will be called with the string
     of every JSON float to be decoded. By default this is equivalent to
diff --git a/Lib/json/decoder.py b/Lib/json/decoder.py
index 239bacdb0f..db87724a89 100644
--- a/Lib/json/decoder.py
+++ b/Lib/json/decoder.py
@@ -41,7 +41,6 @@ def _from_serde(cls, msg, doc, line, col):
         pos += col
         return cls(msg, doc, pos)
 
-
     # Note that this exception is used from _json
     def __init__(self, msg, doc, pos):
         lineno = doc.count('\n', 0, pos) + 1
@@ -65,17 +64,18 @@ def __reduce__(self):
 }
 
 
+HEXDIGITS = re.compile(r'[0-9A-Fa-f]{4}', FLAGS)
 STRINGCHUNK = re.compile(r'(.*?)(["\\\x00-\x1f])', FLAGS)
 BACKSLASH = {
     '"': '"', '\\': '\\', '/': '/',
     'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t',
 }
 
-def _decode_uXXXX(s, pos):
-    esc = s[pos + 1:pos + 5]
-    if len(esc) == 4 and esc[1] not in 'xX':
+def _decode_uXXXX(s, pos, _m=HEXDIGITS.match):
+    esc = _m(s, pos + 1)
+    if esc is not None:
         try:
-            return int(esc, 16)
+            return int(esc.group(), 16)
         except ValueError:
             pass
     msg = "Invalid \\uXXXX escape"
@@ -215,10 +215,13 @@ def JSONObject(s_and_end, strict, scan_once, object_hook, object_pairs_hook,
             break
         elif nextchar != ',':
             raise JSONDecodeError("Expecting ',' delimiter", s, end - 1)
+        comma_idx = end - 1
         end = _w(s, end).end()
         nextchar = s[end:end + 1]
         end += 1
         if nextchar != '"':
+            if nextchar == '}':
+                raise JSONDecodeError("Illegal trailing comma before end of object", s, comma_idx)
             raise JSONDecodeError(
                 "Expecting property name enclosed in double quotes", s, end - 1)
     if object_pairs_hook is not None:
@@ -255,19 +258,23 @@ def JSONArray(s_and_end, scan_once, _w=WHITESPACE.match, _ws=WHITESPACE_STR):
             break
         elif nextchar != ',':
             raise JSONDecodeError("Expecting ',' delimiter", s, end - 1)
+        comma_idx = end - 1
         try:
             if s[end] in _ws:
                 end += 1
                 if s[end] in _ws:
                     end = _w(s, end + 1).end()
+            nextchar = s[end:end + 1]
         except IndexError:
             pass
+        if nextchar == ']':
+            raise JSONDecodeError("Illegal trailing comma before end of array", s, comma_idx)
 
     return values, end
 
 
 class JSONDecoder(object):
-    """Simple JSON <http://json.org> decoder
+    """Simple JSON <https://json.org> decoder
 
     Performs the following translations in decoding by default:
 
@@ -304,10 +311,10 @@ def __init__(self, *, object_hook=None, parse_float=None,
         place of the given ``dict``.  This can be used to provide custom
         deserializations (e.g. to support JSON-RPC class hinting).
 
-        ``object_pairs_hook``, if specified will be called with the result of
-        every JSON object decoded with an ordered list of pairs.  The return
-        value of ``object_pairs_hook`` will be used instead of the ``dict``.
-        This feature can be used to implement custom decoders.
+        ``object_pairs_hook``, if specified will be called with the result
+        of every JSON object decoded with an ordered list of pairs.  The
+        return value of ``object_pairs_hook`` will be used instead of the
+        ``dict``.  This feature can be used to implement custom decoders.
         If ``object_hook`` is also defined, the ``object_pairs_hook`` takes
         priority.
 
diff --git a/Lib/json/encoder.py b/Lib/json/encoder.py
index 21bff2c1a1..0671500d10 100644
--- a/Lib/json/encoder.py
+++ b/Lib/json/encoder.py
@@ -30,6 +30,7 @@
 for i in range(0x20):
     ESCAPE_DCT.setdefault(chr(i), '\\u{0:04x}'.format(i))
     #ESCAPE_DCT.setdefault(chr(i), '\\u%04x' % (i,))
+del i
 
 INFINITY = float('inf')
 
@@ -71,7 +72,7 @@ def replace(match):
     c_encode_basestring_ascii or py_encode_basestring_ascii)
 
 class JSONEncoder(object):
-    """Extensible JSON <http://json.org> encoder for Python data structures.
+    """Extensible JSON <https://json.org> encoder for Python data structures.
 
     Supports the following objects and types by default:
 
@@ -107,12 +108,13 @@ def __init__(self, *, skipkeys=False, ensure_ascii=True,
         """Constructor for JSONEncoder, with sensible defaults.
 
         If skipkeys is false, then it is a TypeError to attempt
-        encoding of keys that are not str, int, float or None.  If
-        skipkeys is True, such items are simply skipped.
+        encoding of keys that are not str, int, float, bool or None.
+        If skipkeys is True, such items are simply skipped.
 
-        If ensure_ascii is true, the output is guaranteed to be str
-        objects with all incoming non-ASCII characters escaped.  If
-        ensure_ascii is false, the output can contain non-ASCII characters.
+        If ensure_ascii is true, the output is guaranteed to be str objects
+        with all incoming non-ASCII and non-printable characters escaped.
+        If ensure_ascii is false, the output can contain non-ASCII and
+        non-printable characters.
 
         If check_circular is true, then lists, dicts, and custom encoded
         objects will be checked for circular references during encoding to
@@ -133,14 +135,15 @@ def __init__(self, *, skipkeys=False, ensure_ascii=True,
         indent level.  An indent level of 0 will only insert newlines.
         None is the most compact representation.
 
-        If specified, separators should be an (item_separator, key_separator)
-        tuple.  The default is (', ', ': ') if *indent* is ``None`` and
-        (',', ': ') otherwise.  To get the most compact JSON representation,
-        you should specify (',', ':') to eliminate whitespace.
+        If specified, separators should be an (item_separator,
+        key_separator) tuple.  The default is (', ', ': ') if *indent* is
+        ``None`` and (',', ': ') otherwise.  To get the most compact JSON
+        representation, you should specify (',', ':') to eliminate
+        whitespace.
 
         If specified, default is a function that gets called for objects
-        that can't otherwise be serialized.  It should return a JSON encodable
-        version of the object or raise a ``TypeError``.
+        that can't otherwise be serialized.  It should return a JSON
+        encodable version of the object or raise a ``TypeError``.
 
         """
 
@@ -173,7 +176,7 @@ def default(self, o):
                 else:
                     return list(iterable)
                 # Let the base class default method raise the TypeError
-                return JSONEncoder.default(self, o)
+                return super().default(o)
 
         """
         raise TypeError(f'Object of type {o.__class__.__name__} '
@@ -243,15 +246,18 @@ def floatstr(o, allow_nan=self.allow_nan,
             return text
 
 
-        if (_one_shot and c_make_encoder is not None
-                and self.indent is None):
+        if self.indent is None or isinstance(self.indent, str):
+            indent = self.indent
+        else:
+            indent = ' ' * self.indent
+        if _one_shot and c_make_encoder is not None:
             _iterencode = c_make_encoder(
-                markers, self.default, _encoder, self.indent,
+                markers, self.default, _encoder, indent,
                 self.key_separator, self.item_separator, self.sort_keys,
                 self.skipkeys, self.allow_nan)
         else:
             _iterencode = _make_iterencode(
-                markers, self.default, _encoder, self.indent, floatstr,
+                markers, self.default, _encoder, indent, floatstr,
                 self.key_separator, self.item_separator, self.sort_keys,
                 self.skipkeys, _one_shot)
         return _iterencode(o, 0)
@@ -271,9 +277,6 @@ def _make_iterencode(markers, _default, _encoder, _indent, _floatstr,
         _intstr=int.__repr__,
     ):
 
-    if _indent is not None and not isinstance(_indent, str):
-        _indent = ' ' * _indent
-
     def _iterencode_list(lst, _current_indent_level):
         if not lst:
             yield '[]'
@@ -344,7 +347,6 @@ def _iterencode_dict(dct, _current_indent_level):
             _current_indent_level += 1
             newline_indent = '\n' + _indent * _current_indent_level
             item_separator = _item_separator + newline_indent
-            yield newline_indent
         else:
             newline_indent = None
             item_separator = _item_separator
@@ -377,6 +379,8 @@ def _iterencode_dict(dct, _current_indent_level):
                                 f'not {key.__class__.__name__}')
             if first:
                 first = False
+                if newline_indent is not None:
+                    yield newline_indent
             else:
                 yield item_separator
             yield _encoder(key)
@@ -403,7 +407,7 @@ def _iterencode_dict(dct, _current_indent_level):
                 else:
                     chunks = _iterencode(value, _current_indent_level)
                 yield from chunks
-        if newline_indent is not None:
+        if not first and newline_indent is not None:
             _current_indent_level -= 1
             yield '\n' + _indent * _current_indent_level
         yield '}'
diff --git a/Lib/json/scanner.py b/Lib/json/scanner.py
index 7a61cfc2d2..090897515f 100644
--- a/Lib/json/scanner.py
+++ b/Lib/json/scanner.py
@@ -9,7 +9,7 @@
 __all__ = ['make_scanner']
 
 NUMBER_RE = re.compile(
-    r'(-?(?:0|[1-9]\d*))(\.\d+)?([eE][-+]?\d+)?',
+    r'(-?(?:0|[1-9][0-9]*))(\.[0-9]+)?([eE][-+]?[0-9]+)?',
     (re.VERBOSE | re.MULTILINE | re.DOTALL))
 
 def py_make_scanner(context):
diff --git a/Lib/json/tool.py b/Lib/json/tool.py
index 0490b8c0be..fdfc3372bc 100644
--- a/Lib/json/tool.py
+++ b/Lib/json/tool.py
@@ -13,7 +13,6 @@
 import argparse
 import json
 import sys
-from pathlib import Path
 
 
 def main():
@@ -22,11 +21,9 @@ def main():
                    'to validate and pretty-print JSON objects.')
     parser = argparse.ArgumentParser(prog=prog, description=description)
     parser.add_argument('infile', nargs='?',
-                        type=argparse.FileType(encoding="utf-8"),
                         help='a JSON file to be validated or pretty-printed',
-                        default=sys.stdin)
+                        default='-')
     parser.add_argument('outfile', nargs='?',
-                        type=Path,
                         help='write the output of infile to outfile',
                         default=None)
     parser.add_argument('--sort-keys', action='store_true', default=False,
@@ -59,23 +56,30 @@ def main():
         dump_args['indent'] = None
         dump_args['separators'] = ',', ':'
 
-    with options.infile as infile:
+    try:
+        if options.infile == '-':
+            infile = sys.stdin
+        else:
+            infile = open(options.infile, encoding='utf-8')
         try:
             if options.json_lines:
                 objs = (json.loads(line) for line in infile)
             else:
                 objs = (json.load(infile),)
+        finally:
+            if infile is not sys.stdin:
+                infile.close()
 
-            if options.outfile is None:
-                out = sys.stdout
-            else:
-                out = options.outfile.open('w', encoding='utf-8')
-            with out as outfile:
-                for obj in objs:
-                    json.dump(obj, outfile, **dump_args)
-                    outfile.write('\n')
-        except ValueError as e:
-            raise SystemExit(e)
+        if options.outfile is None:
+            outfile = sys.stdout
+        else:
+            outfile = open(options.outfile, 'w', encoding='utf-8')
+        with outfile:
+            for obj in objs:
+                json.dump(obj, outfile, **dump_args)
+                outfile.write('\n')
+    except ValueError as e:
+        raise SystemExit(e)
 
 
 if __name__ == '__main__':
diff --git a/Lib/locale.py b/Lib/locale.py
index 7a7694e1bf..db6d0abb26 100644
--- a/Lib/locale.py
+++ b/Lib/locale.py
@@ -25,8 +25,8 @@
 # Yuck:  LC_MESSAGES is non-standard:  can't tell whether it exists before
 # trying the import.  So __all__ is also fiddled at the end of the file.
 __all__ = ["getlocale", "getdefaultlocale", "getpreferredencoding", "Error",
-           "setlocale", "resetlocale", "localeconv", "strcoll", "strxfrm",
-           "str", "atof", "atoi", "format", "format_string", "currency",
+           "setlocale", "localeconv", "strcoll", "strxfrm",
+           "str", "atof", "atoi", "format_string", "currency",
            "normalize", "LC_CTYPE", "LC_COLLATE", "LC_TIME", "LC_MONETARY",
            "LC_NUMERIC", "LC_ALL", "CHAR_MAX", "getencoding"]
 
@@ -247,21 +247,6 @@ def format_string(f, val, grouping=False, monetary=False):
 
     return new_f % val
 
-def format(percent, value, grouping=False, monetary=False, *additional):
-    """Deprecated, use format_string instead."""
-    import warnings
-    warnings.warn(
-        "This method will be removed in a future version of Python. "
-        "Use 'locale.format_string()' instead.",
-        DeprecationWarning, stacklevel=2
-    )
-
-    match = _percent_re.match(percent)
-    if not match or len(match.group())!= len(percent):
-        raise ValueError(("format() must be given exactly one %%char "
-                         "format specifier, %s not valid") % repr(percent))
-    return _format(percent, value, grouping, monetary, *additional)
-
 def currency(val, symbol=True, grouping=False, international=False):
     """Formats val according to the currency settings
     in the current locale."""
@@ -556,11 +541,15 @@ def getdefaultlocale(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE')):
     """
 
     import warnings
-    warnings.warn(
-        "Use setlocale(), getencoding() and getlocale() instead",
-        DeprecationWarning, stacklevel=2
-    )
+    warnings._deprecated(
+        "locale.getdefaultlocale",
+        "{name!r} is deprecated and slated for removal in Python {remove}. "
+        "Use setlocale(), getencoding() and getlocale() instead.",
+        remove=(3, 15))
+    return _getdefaultlocale(envvars)
+
 
+def _getdefaultlocale(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE')):
     try:
         # check if it's supported by the _locale module
         import _locale
@@ -625,40 +614,15 @@ def setlocale(category, locale=None):
         locale = normalize(_build_localename(locale))
     return _setlocale(category, locale)
 
-def resetlocale(category=LC_ALL):
-
-    """ Sets the locale for category to the default setting.
-
-        The default setting is determined by calling
-        getdefaultlocale(). category defaults to LC_ALL.
-
-    """
-    import warnings
-    warnings.warn(
-        'Use locale.setlocale(locale.LC_ALL, "") instead',
-        DeprecationWarning, stacklevel=2
-    )
-
-    with warnings.catch_warnings():
-        warnings.simplefilter('ignore', category=DeprecationWarning)
-        loc = getdefaultlocale()
-
-    _setlocale(category, _build_localename(loc))
-
 
 try:
     from _locale import getencoding
 except ImportError:
+    # When _locale.getencoding() is missing, locale.getencoding() uses the
+    # Python filesystem encoding.
     def getencoding():
-        if hasattr(sys, 'getandroidapilevel'):
-            # On Android langinfo.h and CODESET are missing, and UTF-8 is
-            # always used in mbstowcs() and wcstombs().
-            return 'utf-8'
-        encoding = getdefaultlocale()[1]
-        if encoding is None:
-            # LANG not set, default to UTF-8
-            encoding = 'utf-8'
-        return encoding
+        return sys.getfilesystemencoding()
+
 
 try:
     CODESET
@@ -896,6 +860,28 @@ def getpreferredencoding(do_setlocale=True):
 #    updated 'ca_es@valencia' -> 'ca_ES.ISO8859-15@valencia' to 'ca_ES.UTF-8@valencia'
 #    updated 'kk_kz' -> 'kk_KZ.RK1048' to 'kk_KZ.ptcp154'
 #    updated 'russian' -> 'ru_RU.ISO8859-5' to 'ru_RU.KOI8-R'
+#
+# SS 2025-02-04:
+# Updated alias mapping with glibc 2.41 supported locales and the latest
+# X lib alias mapping.
+#
+# These are the differences compared to the old mapping (Python 3.13.1
+# and older):
+#
+#    updated 'c.utf8' -> 'C.UTF-8' to 'en_US.UTF-8'
+#    updated 'de_it' -> 'de_IT.ISO8859-1' to 'de_IT.UTF-8'
+#    removed 'de_li.utf8'
+#    updated 'en_il' -> 'en_IL.UTF-8' to 'en_IL.ISO8859-1'
+#    removed 'english.iso88591'
+#    updated 'es_cu' -> 'es_CU.UTF-8' to 'es_CU.ISO8859-1'
+#    updated 'russian' -> 'ru_RU.KOI8-R' to 'ru_RU.ISO8859-5'
+#    updated 'sr@latn' -> 'sr_CS.UTF-8@latin' to 'sr_RS.UTF-8@latin'
+#    removed 'univ'
+#    removed 'universal'
+#
+# SS 2025-06-10:
+# Remove 'c.utf8' -> 'en_US.UTF-8' because 'en_US.UTF-8' does not exist
+# on all platforms.
 
 locale_alias = {
     'a3':                                   'az_AZ.KOI8-C',
@@ -975,7 +961,6 @@ def getpreferredencoding(do_setlocale=True):
     'c.ascii':                              'C',
     'c.en':                                 'C',
     'c.iso88591':                           'en_US.ISO8859-1',
-    'c.utf8':                               'en_US.UTF-8',
     'c_c':                                  'C',
     'c_c.c':                                'C',
     'ca':                                   'ca_ES.ISO8859-1',
@@ -992,6 +977,7 @@ def getpreferredencoding(do_setlocale=True):
     'chr_us':                               'chr_US.UTF-8',
     'ckb_iq':                               'ckb_IQ.UTF-8',
     'cmn_tw':                               'cmn_TW.UTF-8',
+    'crh_ru':                               'crh_RU.UTF-8',
     'crh_ua':                               'crh_UA.UTF-8',
     'croatian':                             'hr_HR.ISO8859-2',
     'cs':                                   'cs_CZ.ISO8859-2',
@@ -1013,11 +999,12 @@ def getpreferredencoding(do_setlocale=True):
     'de_be':                                'de_BE.ISO8859-1',
     'de_ch':                                'de_CH.ISO8859-1',
     'de_de':                                'de_DE.ISO8859-1',
-    'de_it':                                'de_IT.ISO8859-1',
-    'de_li.utf8':                           'de_LI.UTF-8',
+    'de_it':                                'de_IT.UTF-8',
+    'de_li':                                'de_LI.ISO8859-1',
     'de_lu':                                'de_LU.ISO8859-1',
     'deutsch':                              'de_DE.ISO8859-1',
     'doi_in':                               'doi_IN.UTF-8',
+    'dsb_de':                               'dsb_DE.UTF-8',
     'dutch':                                'nl_NL.ISO8859-1',
     'dutch.iso88591':                       'nl_BE.ISO8859-1',
     'dv_mv':                                'dv_MV.UTF-8',
@@ -1040,7 +1027,7 @@ def getpreferredencoding(do_setlocale=True):
     'en_gb':                                'en_GB.ISO8859-1',
     'en_hk':                                'en_HK.ISO8859-1',
     'en_ie':                                'en_IE.ISO8859-1',
-    'en_il':                                'en_IL.UTF-8',
+    'en_il':                                'en_IL.ISO8859-1',
     'en_in':                                'en_IN.ISO8859-1',
     'en_ng':                                'en_NG.UTF-8',
     'en_nz':                                'en_NZ.ISO8859-1',
@@ -1056,7 +1043,6 @@ def getpreferredencoding(do_setlocale=True):
     'en_zw.utf8':                           'en_ZS.UTF-8',
     'eng_gb':                               'en_GB.ISO8859-1',
     'english':                              'en_EN.ISO8859-1',
-    'english.iso88591':                     'en_US.ISO8859-1',
     'english_uk':                           'en_GB.ISO8859-1',
     'english_united-states':                'en_US.ISO8859-1',
     'english_united-states.437':            'C',
@@ -1072,7 +1058,7 @@ def getpreferredencoding(do_setlocale=True):
     'es_cl':                                'es_CL.ISO8859-1',
     'es_co':                                'es_CO.ISO8859-1',
     'es_cr':                                'es_CR.ISO8859-1',
-    'es_cu':                                'es_CU.UTF-8',
+    'es_cu':                                'es_CU.ISO8859-1',
     'es_do':                                'es_DO.ISO8859-1',
     'es_ec':                                'es_EC.ISO8859-1',
     'es_es':                                'es_ES.ISO8859-1',
@@ -1122,6 +1108,7 @@ def getpreferredencoding(do_setlocale=True):
     'ga_ie':                                'ga_IE.ISO8859-1',
     'galego':                               'gl_ES.ISO8859-1',
     'galician':                             'gl_ES.ISO8859-1',
+    'gbm_in':                               'gbm_IN.UTF-8',
     'gd':                                   'gd_GB.ISO8859-1',
     'gd_gb':                                'gd_GB.ISO8859-1',
     'ger_de':                               'de_DE.ISO8859-1',
@@ -1162,6 +1149,7 @@ def getpreferredencoding(do_setlocale=True):
     'icelandic':                            'is_IS.ISO8859-1',
     'id':                                   'id_ID.ISO8859-1',
     'id_id':                                'id_ID.ISO8859-1',
+    'ie':                                   'ie.UTF-8',
     'ig_ng':                                'ig_NG.UTF-8',
     'ik_ca':                                'ik_CA.UTF-8',
     'in':                                   'id_ID.ISO8859-1',
@@ -1216,6 +1204,7 @@ def getpreferredencoding(do_setlocale=True):
     'ks_in':                                'ks_IN.UTF-8',
     'ks_in@devanagari.utf8':                'ks_IN.UTF-8@devanagari',
     'ku_tr':                                'ku_TR.ISO8859-9',
+    'kv_ru':                                'kv_RU.UTF-8',
     'kw':                                   'kw_GB.ISO8859-1',
     'kw_gb':                                'kw_GB.ISO8859-1',
     'ky':                                   'ky_KG.UTF-8',
@@ -1234,6 +1223,7 @@ def getpreferredencoding(do_setlocale=True):
     'lo_la.mulelao1':                       'lo_LA.MULELAO-1',
     'lt':                                   'lt_LT.ISO8859-13',
     'lt_lt':                                'lt_LT.ISO8859-13',
+    'ltg_lv.utf8':                          'ltg_LV.UTF-8',
     'lv':                                   'lv_LV.ISO8859-13',
     'lv_lv':                                'lv_LV.ISO8859-13',
     'lzh_tw':                               'lzh_TW.UTF-8',
@@ -1241,6 +1231,7 @@ def getpreferredencoding(do_setlocale=True):
     'mai':                                  'mai_IN.UTF-8',
     'mai_in':                               'mai_IN.UTF-8',
     'mai_np':                               'mai_NP.UTF-8',
+    'mdf_ru':                               'mdf_RU.UTF-8',
     'mfe_mu':                               'mfe_MU.UTF-8',
     'mg_mg':                                'mg_MG.ISO8859-15',
     'mhr_ru':                               'mhr_RU.UTF-8',
@@ -1254,6 +1245,7 @@ def getpreferredencoding(do_setlocale=True):
     'ml_in':                                'ml_IN.UTF-8',
     'mn_mn':                                'mn_MN.UTF-8',
     'mni_in':                               'mni_IN.UTF-8',
+    'mnw_mm':                               'mnw_MM.UTF-8',
     'mr':                                   'mr_IN.UTF-8',
     'mr_in':                                'mr_IN.UTF-8',
     'ms':                                   'ms_MY.ISO8859-1',
@@ -1322,6 +1314,7 @@ def getpreferredencoding(do_setlocale=True):
     'pt_pt':                                'pt_PT.ISO8859-1',
     'quz_pe':                               'quz_PE.UTF-8',
     'raj_in':                               'raj_IN.UTF-8',
+    'rif_ma':                               'rif_MA.UTF-8',
     'ro':                                   'ro_RO.ISO8859-2',
     'ro_ro':                                'ro_RO.ISO8859-2',
     'romanian':                             'ro_RO.ISO8859-2',
@@ -1329,12 +1322,14 @@ def getpreferredencoding(do_setlocale=True):
     'ru_ru':                                'ru_RU.UTF-8',
     'ru_ua':                                'ru_UA.KOI8-U',
     'rumanian':                             'ro_RO.ISO8859-2',
-    'russian':                              'ru_RU.KOI8-R',
+    'russian':                              'ru_RU.ISO8859-5',
     'rw':                                   'rw_RW.ISO8859-1',
     'rw_rw':                                'rw_RW.ISO8859-1',
     'sa_in':                                'sa_IN.UTF-8',
+    'sah_ru':                               'sah_RU.UTF-8',
     'sat_in':                               'sat_IN.UTF-8',
     'sc_it':                                'sc_IT.UTF-8',
+    'scn_it':                               'scn_IT.UTF-8',
     'sd':                                   'sd_IN.UTF-8',
     'sd_in':                                'sd_IN.UTF-8',
     'sd_in@devanagari.utf8':                'sd_IN.UTF-8@devanagari',
@@ -1376,7 +1371,7 @@ def getpreferredencoding(do_setlocale=True):
     'sq_mk':                                'sq_MK.UTF-8',
     'sr':                                   'sr_RS.UTF-8',
     'sr@cyrillic':                          'sr_RS.UTF-8',
-    'sr@latn':                              'sr_CS.UTF-8@latin',
+    'sr@latn':                              'sr_RS.UTF-8@latin',
     'sr_cs':                                'sr_CS.UTF-8',
     'sr_cs.iso88592@latn':                  'sr_CS.ISO8859-2',
     'sr_cs@latn':                           'sr_CS.UTF-8@latin',
@@ -1395,14 +1390,17 @@ def getpreferredencoding(do_setlocale=True):
     'sr_yu@cyrillic':                       'sr_RS.UTF-8',
     'ss':                                   'ss_ZA.ISO8859-1',
     'ss_za':                                'ss_ZA.ISO8859-1',
+    'ssy_er':                               'ssy_ER.UTF-8',
     'st':                                   'st_ZA.ISO8859-1',
     'st_za':                                'st_ZA.ISO8859-1',
+    'su_id':                                'su_ID.UTF-8',
     'sv':                                   'sv_SE.ISO8859-1',
     'sv_fi':                                'sv_FI.ISO8859-1',
     'sv_se':                                'sv_SE.ISO8859-1',
     'sw_ke':                                'sw_KE.UTF-8',
     'sw_tz':                                'sw_TZ.UTF-8',
     'swedish':                              'sv_SE.ISO8859-1',
+    'syr':                                  'syr.UTF-8',
     'szl_pl':                               'szl_PL.UTF-8',
     'ta':                                   'ta_IN.TSCII-0',
     'ta_in':                                'ta_IN.TSCII-0',
@@ -1429,6 +1427,7 @@ def getpreferredencoding(do_setlocale=True):
     'tn':                                   'tn_ZA.ISO8859-15',
     'tn_za':                                'tn_ZA.ISO8859-15',
     'to_to':                                'to_TO.UTF-8',
+    'tok':                                  'tok.UTF-8',
     'tpi_pg':                               'tpi_PG.UTF-8',
     'tr':                                   'tr_TR.ISO8859-9',
     'tr_cy':                                'tr_CY.ISO8859-9',
@@ -1443,8 +1442,7 @@ def getpreferredencoding(do_setlocale=True):
     'ug_cn':                                'ug_CN.UTF-8',
     'uk':                                   'uk_UA.KOI8-U',
     'uk_ua':                                'uk_UA.KOI8-U',
-    'univ':                                 'en_US.utf',
-    'universal':                            'en_US.utf',
+    'univ.utf8':                            'en_US.UTF-8',
     'universal.utf8@ucs4':                  'en_US.UTF-8',
     'unm_us':                               'unm_US.UTF-8',
     'ur':                                   'ur_PK.CP1256',
@@ -1473,6 +1471,7 @@ def getpreferredencoding(do_setlocale=True):
     'yo_ng':                                'yo_NG.UTF-8',
     'yue_hk':                               'yue_HK.UTF-8',
     'yuw_pg':                               'yuw_PG.UTF-8',
+    'zgh_ma':                               'zgh_MA.UTF-8',
     'zh':                                   'zh_CN.eucCN',
     'zh_cn':                                'zh_CN.gb2312',
     'zh_cn.big5':                           'zh_TW.big5',
@@ -1496,7 +1495,8 @@ def getpreferredencoding(do_setlocale=True):
 # to include every locale up to Windows Vista.
 #
 # NOTE: this mapping is incomplete.  If your language is missing, please
-# submit a bug report to the Python bug tracker at http://bugs.python.org/
+# submit a bug report as detailed in the Python devguide at:
+#    https://devguide.python.org/triage/issue-tracker/
 # Make sure you include the missing language identifier and the suggested
 # locale code.
 #
@@ -1742,17 +1742,6 @@ def _init_categories(categories=categories):
         print('   Encoding: ', enc or '(undefined)')
         print()
 
-    print()
-    print('Locale settings after calling resetlocale():')
-    print('-'*72)
-    resetlocale()
-    for name,category in categories.items():
-        print(name, '...')
-        lang, enc = getlocale(category)
-        print('   Language: ', lang or '(undefined)')
-        print('   Encoding: ', enc or '(undefined)')
-        print()
-
     try:
         setlocale(LC_ALL, "")
     except:
diff --git a/Lib/logging/__init__.py b/Lib/logging/__init__.py
index 28df075dcd..357d127c09 100644
--- a/Lib/logging/__init__.py
+++ b/Lib/logging/__init__.py
@@ -56,7 +56,7 @@
 #
 #_startTime is used as the base when calculating the relative time of events
 #
-_startTime = time.time()
+_startTime = time.time_ns()
 
 #
 #raiseExceptions is used to see if exceptions during handling should be
@@ -159,12 +159,9 @@ def addLevelName(level, levelName):
 
     This is used when converting levels to text during message formatting.
     """
-    _acquireLock()
-    try:    #unlikely to cause an exception, but you never know...
+    with _lock:
         _levelToName[level] = levelName
         _nameToLevel[levelName] = level
-    finally:
-        _releaseLock()
 
 if hasattr(sys, "_getframe"):
     currentframe = lambda: sys._getframe(1)
@@ -201,7 +198,7 @@ def _is_internal_frame(frame):
     """Signal whether the frame is a CPython or logging module internal."""
     filename = os.path.normcase(frame.f_code.co_filename)
     return filename == _srcfile or (
-            "importlib" in filename and "_bootstrap" in filename
+        "importlib" in filename and "_bootstrap" in filename
     )
 
 
@@ -231,21 +228,27 @@ def _checkLevel(level):
 #
 _lock = threading.RLock()
 
-def _acquireLock():
+def _prepareFork():
     """
-    Acquire the module-level lock for serializing access to shared data.
+    Prepare to fork a new child process by acquiring the module-level lock.
 
-    This should be released with _releaseLock().
+    This should be used in conjunction with _afterFork().
     """
-    if _lock:
+    # Wrap the lock acquisition in a try-except to prevent the lock from being
+    # abandoned in the event of an asynchronous exception. See gh-106238.
+    try:
         _lock.acquire()
+    except BaseException:
+        _lock.release()
+        raise
 
-def _releaseLock():
+def _afterFork():
     """
-    Release the module-level lock acquired by calling _acquireLock().
+    After a new child process has been forked, release the module-level lock.
+
+    This should be used in conjunction with _prepareFork().
     """
-    if _lock:
-        _lock.release()
+    _lock.release()
 
 
 # Prevent a held logging lock from blocking a child from logging.
@@ -260,23 +263,20 @@ def _register_at_fork_reinit_lock(instance):
     _at_fork_reinit_lock_weakset = weakref.WeakSet()
 
     def _register_at_fork_reinit_lock(instance):
-        _acquireLock()
-        try:
+        with _lock:
             _at_fork_reinit_lock_weakset.add(instance)
-        finally:
-            _releaseLock()
 
     def _after_at_fork_child_reinit_locks():
         for handler in _at_fork_reinit_lock_weakset:
             handler._at_fork_reinit()
 
-        # _acquireLock() was called in the parent before forking.
+        # _prepareFork() was called in the parent before forking.
         # The lock is reinitialized to unlocked state.
         _lock._at_fork_reinit()
 
-    os.register_at_fork(before=_acquireLock,
+    os.register_at_fork(before=_prepareFork,
                         after_in_child=_after_at_fork_child_reinit_locks,
-                        after_in_parent=_releaseLock)
+                        after_in_parent=_afterFork)
 
 
 #---------------------------------------------------------------------------
@@ -300,7 +300,7 @@ def __init__(self, name, level, pathname, lineno,
         """
         Initialize a logging record with interesting information.
         """
-        ct = time.time()
+        ct = time.time_ns()
         self.name = name
         self.msg = msg
         #
@@ -322,7 +322,7 @@ def __init__(self, name, level, pathname, lineno,
         # Thus, while not removing the isinstance check, it does now look
         # for collections.abc.Mapping rather than, as before, dict.
         if (args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping)
-                and args[0]):
+            and args[0]):
             args = args[0]
         self.args = args
         self.levelname = getLevelName(level)
@@ -339,9 +339,17 @@ def __init__(self, name, level, pathname, lineno,
         self.stack_info = sinfo
         self.lineno = lineno
         self.funcName = func
-        self.created = ct
-        self.msecs = int((ct - int(ct)) * 1000) + 0.0  # see gh-89047
-        self.relativeCreated = (self.created - _startTime) * 1000
+        self.created = ct / 1e9  # ns to float seconds
+        # Get the number of whole milliseconds (0-999) in the fractional part of seconds.
+        # Eg: 1_677_903_920_999_998_503 ns --> 999_998_503 ns--> 999 ms
+        # Convert to float by adding 0.0 for historical reasons. See gh-89047
+        self.msecs = (ct % 1_000_000_000) // 1_000_000 + 0.0
+        if self.msecs == 999.0 and int(self.created) != ct // 1_000_000_000:
+            # ns -> sec conversion can round up, e.g:
+            # 1_677_903_920_999_999_900 ns --> 1_677_903_921.0 sec
+            self.msecs = 0.0
+
+        self.relativeCreated = (ct - _startTime) / 1e6
         if logThreads:
             self.thread = threading.get_ident()
             self.threadName = threading.current_thread().name
@@ -378,7 +386,7 @@ def __init__(self, name, level, pathname, lineno,
 
     def __repr__(self):
         return '<LogRecord: %s, %s, %s, %s, "%s">'%(self.name, self.levelno,
-                                                    self.pathname, self.lineno, self.msg)
+            self.pathname, self.lineno, self.msg)
 
     def getMessage(self):
         """
@@ -572,7 +580,7 @@ class Formatter(object):
     %(lineno)d          Source line number where the logging call was issued
                         (if available)
     %(funcName)s        Function name
-    %(created)f         Time when the LogRecord was created (time.time()
+    %(created)f         Time when the LogRecord was created (time.time_ns() / 1e9
                         return value)
     %(asctime)s         Textual time when the LogRecord was created
     %(msecs)d           Millisecond portion of the creation time
@@ -583,6 +591,7 @@ class Formatter(object):
     %(threadName)s      Thread name (if available)
     %(taskName)s        Task name (if available)
     %(process)d         Process ID (if available)
+    %(processName)s     Process name (if available)
     %(message)s         The result of record.getMessage(), computed just as
                         the record is emitted
     """
@@ -608,7 +617,7 @@ def __init__(self, fmt=None, datefmt=None, style='%', validate=True, *,
         """
         if style not in _STYLES:
             raise ValueError('Style must be one of: %s' % ','.join(
-                _STYLES.keys()))
+                             _STYLES.keys()))
         self._style = _STYLES[style][0](fmt, defaults=defaults)
         if validate:
             self._style.validate()
@@ -658,7 +667,7 @@ def formatException(self, ei):
         # See issues #9427, #1553375. Commented out for now.
         #if getattr(self, 'fullstack', False):
         #    traceback.print_stack(tb.tb_frame.f_back, file=sio)
-        traceback.print_exception(ei[0], ei[1], tb, None, sio)
+        traceback.print_exception(ei[0], ei[1], tb, limit=None, file=sio)
         s = sio.getvalue()
         sio.close()
         if s[-1:] == "\n":
@@ -879,25 +888,20 @@ def _removeHandlerRef(wr):
     # set to None. It can also be called from another thread. So we need to
     # pre-emptively grab the necessary globals and check if they're None,
     # to prevent race conditions and failures during interpreter shutdown.
-    acquire, release, handlers = _acquireLock, _releaseLock, _handlerList
-    if acquire and release and handlers:
-        acquire()
-        try:
-            handlers.remove(wr)
-        except ValueError:
-            pass
-        finally:
-            release()
+    handlers, lock = _handlerList, _lock
+    if lock and handlers:
+        with lock:
+            try:
+                handlers.remove(wr)
+            except ValueError:
+                pass
 
 def _addHandlerRef(handler):
     """
     Add a handler to the internal cleanup list using a weak reference.
     """
-    _acquireLock()
-    try:
+    with _lock:
         _handlerList.append(weakref.ref(handler, _removeHandlerRef))
-    finally:
-        _releaseLock()
 
 
 def getHandlerByName(name):
@@ -912,8 +916,7 @@ def getHandlerNames():
     """
     Return all known handler names as an immutable set.
     """
-    result = set(_handlers.keys())
-    return frozenset(result)
+    return frozenset(_handlers)
 
 
 class Handler(Filterer):
@@ -943,15 +946,12 @@ def get_name(self):
         return self._name
 
     def set_name(self, name):
-        _acquireLock()
-        try:
+        with _lock:
             if self._name in _handlers:
                 del _handlers[self._name]
             self._name = name
             if name:
                 _handlers[name] = self
-        finally:
-            _releaseLock()
 
     name = property(get_name, set_name)
 
@@ -1023,11 +1023,8 @@ def handle(self, record):
         if isinstance(rv, LogRecord):
             record = rv
         if rv:
-            self.acquire()
-            try:
+            with self.lock:
                 self.emit(record)
-            finally:
-                self.release()
         return rv
 
     def setFormatter(self, fmt):
@@ -1055,13 +1052,10 @@ def close(self):
         methods.
         """
         #get the module data lock, as we're updating a shared structure.
-        _acquireLock()
-        try:    #unlikely to raise an exception, but you never know...
+        with _lock:
             self._closed = True
             if self._name and self._name in _handlers:
                 del _handlers[self._name]
-        finally:
-            _releaseLock()
 
     def handleError(self, record):
         """
@@ -1076,14 +1070,14 @@ def handleError(self, record):
         The record which was being processed is passed in to this method.
         """
         if raiseExceptions and sys.stderr:  # see issue 13807
-            t, v, tb = sys.exc_info()
+            exc = sys.exception()
             try:
                 sys.stderr.write('--- Logging error ---\n')
-                traceback.print_exception(t, v, tb, None, sys.stderr)
+                traceback.print_exception(exc, limit=None, file=sys.stderr)
                 sys.stderr.write('Call stack:\n')
                 # Walk the stack frame up until we're out of logging,
                 # so as to print the calling context.
-                frame = tb.tb_frame
+                frame = exc.__traceback__.tb_frame
                 while (frame and os.path.dirname(frame.f_code.co_filename) ==
                        __path__[0]):
                     frame = frame.f_back
@@ -1092,7 +1086,7 @@ def handleError(self, record):
                 else:
                     # couldn't find the right stack frame, for some reason
                     sys.stderr.write('Logged from file %s, line %s\n' % (
-                        record.filename, record.lineno))
+                                     record.filename, record.lineno))
                 # Issue 18671: output logging message and arguments
                 try:
                     sys.stderr.write('Message: %r\n'
@@ -1104,11 +1098,11 @@ def handleError(self, record):
                     sys.stderr.write('Unable to print the message and arguments'
                                      ' - possible formatting error.\nUse the'
                                      ' traceback above to help find the error.\n'
-                                     )
+                                    )
             except OSError: #pragma: no cover
                 pass    # see issue 5971
             finally:
-                del t, v, tb
+                del exc
 
     def __repr__(self):
         level = getLevelName(self.level)
@@ -1138,12 +1132,9 @@ def flush(self):
         """
         Flushes the stream.
         """
-        self.acquire()
-        try:
+        with self.lock:
             if self.stream and hasattr(self.stream, "flush"):
                 self.stream.flush()
-        finally:
-            self.release()
 
     def emit(self, record):
         """
@@ -1179,12 +1170,9 @@ def setStream(self, stream):
             result = None
         else:
             result = self.stream
-            self.acquire()
-            try:
+            with self.lock:
                 self.flush()
                 self.stream = stream
-            finally:
-                self.release()
         return result
 
     def __repr__(self):
@@ -1234,8 +1222,7 @@ def close(self):
         """
         Closes the stream.
         """
-        self.acquire()
-        try:
+        with self.lock:
             try:
                 if self.stream:
                     try:
@@ -1251,8 +1238,6 @@ def close(self):
                 # Also see Issue #42378: we also rely on
                 # self._closed being set to True there
                 StreamHandler.close(self)
-        finally:
-            self.release()
 
     def _open(self):
         """
@@ -1388,8 +1373,7 @@ def getLogger(self, name):
         rv = None
         if not isinstance(name, str):
             raise TypeError('A logger name must be a string')
-        _acquireLock()
-        try:
+        with _lock:
             if name in self.loggerDict:
                 rv = self.loggerDict[name]
                 if isinstance(rv, PlaceHolder):
@@ -1404,8 +1388,6 @@ def getLogger(self, name):
                 rv.manager = self
                 self.loggerDict[name] = rv
                 self._fixupParents(rv)
-        finally:
-            _releaseLock()
         return rv
 
     def setLoggerClass(self, klass):
@@ -1468,12 +1450,11 @@ def _clear_cache(self):
         Called when level changes are made
         """
 
-        _acquireLock()
-        for logger in self.loggerDict.values():
-            if isinstance(logger, Logger):
-                logger._cache.clear()
-        self.root._cache.clear()
-        _releaseLock()
+        with _lock:
+            for logger in self.loggerDict.values():
+                if isinstance(logger, Logger):
+                    logger._cache.clear()
+            self.root._cache.clear()
 
 #---------------------------------------------------------------------------
 #   Logger classes and functions
@@ -1494,6 +1475,8 @@ class Logger(Filterer):
     level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
     There is no arbitrary limit to the depth of nesting.
     """
+    _tls = threading.local()
+
     def __init__(self, name, level=NOTSET):
         """
         Initialize the logger with a name and an optional level.
@@ -1552,7 +1535,7 @@ def warning(self, msg, *args, **kwargs):
 
     def warn(self, msg, *args, **kwargs):
         warnings.warn("The 'warn' method is deprecated, "
-                      "use 'warning' instead", DeprecationWarning, 2)
+            "use 'warning' instead", DeprecationWarning, 2)
         self.warning(msg, *args, **kwargs)
 
     def error(self, msg, *args, **kwargs):
@@ -1649,7 +1632,7 @@ def makeRecord(self, name, level, fn, lno, msg, args, exc_info,
         specialized LogRecords.
         """
         rv = _logRecordFactory(name, level, fn, lno, msg, args, exc_info, func,
-                               sinfo)
+                             sinfo)
         if extra is not None:
             for key in extra:
                 if (key in ["message", "asctime"]) or (key in rv.__dict__):
@@ -1690,36 +1673,35 @@ def handle(self, record):
         This method is used for unpickled records received from a socket, as
         well as those created locally. Logger-level filtering is applied.
         """
-        if self.disabled:
-            return
-        maybe_record = self.filter(record)
-        if not maybe_record:
+        if self._is_disabled():
             return
-        if isinstance(maybe_record, LogRecord):
-            record = maybe_record
-        self.callHandlers(record)
+
+        self._tls.in_progress = True
+        try:
+            maybe_record = self.filter(record)
+            if not maybe_record:
+                return
+            if isinstance(maybe_record, LogRecord):
+                record = maybe_record
+            self.callHandlers(record)
+        finally:
+            self._tls.in_progress = False
 
     def addHandler(self, hdlr):
         """
         Add the specified handler to this logger.
         """
-        _acquireLock()
-        try:
+        with _lock:
             if not (hdlr in self.handlers):
                 self.handlers.append(hdlr)
-        finally:
-            _releaseLock()
 
     def removeHandler(self, hdlr):
         """
         Remove the specified handler from this logger.
         """
-        _acquireLock()
-        try:
+        with _lock:
             if hdlr in self.handlers:
                 self.handlers.remove(hdlr)
-        finally:
-            _releaseLock()
 
     def hasHandlers(self):
         """
@@ -1791,22 +1773,19 @@ def isEnabledFor(self, level):
         """
         Is this logger enabled for level 'level'?
         """
-        if self.disabled:
+        if self._is_disabled():
             return False
 
         try:
             return self._cache[level]
         except KeyError:
-            _acquireLock()
-            try:
+            with _lock:
                 if self.manager.disable >= level:
                     is_enabled = self._cache[level] = False
                 else:
                     is_enabled = self._cache[level] = (
-                            level >= self.getEffectiveLevel()
+                        level >= self.getEffectiveLevel()
                     )
-            finally:
-                _releaseLock()
             return is_enabled
 
     def getChild(self, suffix):
@@ -1836,16 +1815,18 @@ def _hierlevel(logger):
             return 1 + logger.name.count('.')
 
         d = self.manager.loggerDict
-        _acquireLock()
-        try:
+        with _lock:
             # exclude PlaceHolders - the last check is to ensure that lower-level
             # descendants aren't returned - if there are placeholders, a logger's
             # parent field might point to a grandparent or ancestor thereof.
             return set(item for item in d.values()
                        if isinstance(item, Logger) and item.parent is self and
                        _hierlevel(item) == 1 + _hierlevel(item.parent))
-        finally:
-            _releaseLock()
+
+    def _is_disabled(self):
+        # We need to use getattr as it will only be set the first time a log
+        # message is recorded on any given thread
+        return self.disabled or getattr(self._tls, 'in_progress', False)
 
     def __repr__(self):
         level = getLevelName(self.getEffectiveLevel())
@@ -1881,7 +1862,7 @@ class LoggerAdapter(object):
     information in logging output.
     """
 
-    def __init__(self, logger, extra=None):
+    def __init__(self, logger, extra=None, merge_extra=False):
         """
         Initialize the adapter with a logger and a dict-like object which
         provides contextual information. This constructor signature allows
@@ -1891,9 +1872,20 @@ def __init__(self, logger, extra=None):
         following example:
 
         adapter = LoggerAdapter(someLogger, dict(p1=v1, p2="v2"))
+
+        By default, LoggerAdapter objects will drop the "extra" argument
+        passed on the individual log calls to use its own instead.
+
+        Initializing it with merge_extra=True will instead merge both
+        maps when logging, the individual call extra taking precedence
+        over the LoggerAdapter instance extra
+
+        .. versionchanged:: 3.13
+           The *merge_extra* argument was added.
         """
         self.logger = logger
         self.extra = extra
+        self.merge_extra = merge_extra
 
     def process(self, msg, kwargs):
         """
@@ -1905,7 +1897,10 @@ def process(self, msg, kwargs):
         Normally, you'll only need to override this one method in a
         LoggerAdapter subclass for your specific needs.
         """
-        kwargs["extra"] = self.extra
+        if self.merge_extra and "extra" in kwargs:
+            kwargs["extra"] = {**self.extra, **kwargs["extra"]}
+        else:
+            kwargs["extra"] = self.extra
         return msg, kwargs
 
     #
@@ -1931,7 +1926,7 @@ def warning(self, msg, *args, **kwargs):
 
     def warn(self, msg, *args, **kwargs):
         warnings.warn("The 'warn' method is deprecated, "
-                      "use 'warning' instead", DeprecationWarning, 2)
+            "use 'warning' instead", DeprecationWarning, 2)
         self.warning(msg, *args, **kwargs)
 
     def error(self, msg, *args, **kwargs):
@@ -2088,8 +2083,7 @@ def basicConfig(**kwargs):
     """
     # Add thread safety in case someone mistakenly calls
     # basicConfig() from multiple threads
-    _acquireLock()
-    try:
+    with _lock:
         force = kwargs.pop('force', False)
         encoding = kwargs.pop('encoding', None)
         errors = kwargs.pop('errors', 'backslashreplace')
@@ -2125,7 +2119,7 @@ def basicConfig(**kwargs):
             style = kwargs.pop("style", '%')
             if style not in _STYLES:
                 raise ValueError('Style must be one of: %s' % ','.join(
-                    _STYLES.keys()))
+                                 _STYLES.keys()))
             fs = kwargs.pop("format", _STYLES[style][1])
             fmt = Formatter(fs, dfs, style)
             for h in handlers:
@@ -2138,8 +2132,6 @@ def basicConfig(**kwargs):
             if kwargs:
                 keys = ', '.join(kwargs.keys())
                 raise ValueError('Unrecognised argument(s): %s' % keys)
-    finally:
-        _releaseLock()
 
 #---------------------------------------------------------------------------
 # Utility functions at module level.
@@ -2202,7 +2194,7 @@ def warning(msg, *args, **kwargs):
 
 def warn(msg, *args, **kwargs):
     warnings.warn("The 'warn' function is deprecated, "
-                  "use 'warning' instead", DeprecationWarning, 2)
+        "use 'warning' instead", DeprecationWarning, 2)
     warning(msg, *args, **kwargs)
 
 def info(msg, *args, **kwargs):
diff --git a/Lib/logging/config.py b/Lib/logging/config.py
index ef04a35168..190b4f9225 100644
--- a/Lib/logging/config.py
+++ b/Lib/logging/config.py
@@ -83,15 +83,12 @@ def fileConfig(fname, defaults=None, disable_existing_loggers=True, encoding=Non
     formatters = _create_formatters(cp)
 
     # critical section
-    logging._acquireLock()
-    try:
+    with logging._lock:
         _clearExistingHandlers()
 
         # Handlers add themselves to logging._handlers
         handlers = _install_handlers(cp, formatters)
         _install_loggers(cp, handlers, disable_existing_loggers)
-    finally:
-        logging._releaseLock()
 
 
 def _resolve(name):
@@ -314,7 +311,7 @@ def convert_with_key(self, key, value, replace=True):
             if replace:
                 self[key] = result
             if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
+                               ConvertingTuple):
                 result.parent = self
                 result.key = key
         return result
@@ -323,7 +320,7 @@ def convert(self, value):
         result = self.configurator.convert(value)
         if value is not result:
             if type(result) in (ConvertingDict, ConvertingList,
-                                ConvertingTuple):
+                               ConvertingTuple):
                 result.parent = self
         return result
 
@@ -378,7 +375,7 @@ class BaseConfigurator(object):
 
     WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
     DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
-    INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
+    INDEX_PATTERN = re.compile(r'^\[([^\[\]]*)\]\s*')
     DIGIT_PATTERN = re.compile(r'^\d+$')
 
     value_converters = {
@@ -464,8 +461,8 @@ def convert(self, value):
         elif not isinstance(value, ConvertingList) and isinstance(value, list):
             value = ConvertingList(value)
             value.configurator = self
-        elif not isinstance(value, ConvertingTuple) and \
-                isinstance(value, tuple) and not hasattr(value, '_fields'):
+        elif not isinstance(value, ConvertingTuple) and\
+                 isinstance(value, tuple) and not hasattr(value, '_fields'):
             value = ConvertingTuple(value)
             value.configurator = self
         elif isinstance(value, str): # str for py3k
@@ -543,8 +540,7 @@ def configure(self):
             raise ValueError("Unsupported version: %s" % config['version'])
         incremental = config.pop('incremental', False)
         EMPTY_DICT = {}
-        logging._acquireLock()
-        try:
+        with logging._lock:
             if incremental:
                 handlers = config.get('handlers', EMPTY_DICT)
                 for name in handlers:
@@ -585,7 +581,7 @@ def configure(self):
                 for name in formatters:
                     try:
                         formatters[name] = self.configure_formatter(
-                            formatters[name])
+                                                            formatters[name])
                     except Exception as e:
                         raise ValueError('Unable to configure '
                                          'formatter %r' % name) from e
@@ -688,8 +684,6 @@ def configure(self):
                     except Exception as e:
                         raise ValueError('Unable to configure root '
                                          'logger') from e
-        finally:
-            logging._releaseLock()
 
     def configure_formatter(self, config):
         """Configure a formatter from a dictionary."""
@@ -700,10 +694,9 @@ def configure_formatter(self, config):
             except TypeError as te:
                 if "'format'" not in str(te):
                     raise
-                #Name of parameter changed from fmt to format.
-                #Retry with old name.
-                #This is so that code can be used with older Python versions
-                #(e.g. by Django)
+                # logging.Formatter and its subclasses expect the `fmt`
+                # parameter instead of `format`. Retry passing configuration
+                # with `fmt`.
                 config['fmt'] = config.pop('format')
                 config['()'] = factory
                 result = self.configure_custom(config)
@@ -812,7 +805,7 @@ def configure_handler(self, config):
             elif issubclass(klass, logging.handlers.QueueHandler):
                 # Another special case for handler which refers to other handlers
                 # if 'handlers' not in config:
-                # raise ValueError('No handlers specified for a QueueHandler')
+                    # raise ValueError('No handlers specified for a QueueHandler')
                 if 'queue' in config:
                     qspec = config['queue']
 
@@ -836,8 +829,8 @@ def configure_handler(self, config):
                     else:
                         if isinstance(lspec, str):
                             listener = self.resolve(lspec)
-                            if isinstance(listener, type) and \
-                                    not issubclass(listener, logging.handlers.QueueListener):
+                            if isinstance(listener, type) and\
+                                not issubclass(listener, logging.handlers.QueueListener):
                                 raise TypeError('Invalid listener specifier %r' % lspec)
                         elif isinstance(lspec, dict):
                             if '()' not in lspec:
@@ -861,11 +854,11 @@ def configure_handler(self, config):
                     except Exception as e:
                         raise ValueError('Unable to set required handler %r' % hn) from e
                     config['handlers'] = hlist
-            elif issubclass(klass, logging.handlers.SMTPHandler) and \
-                    'mailhost' in config:
+            elif issubclass(klass, logging.handlers.SMTPHandler) and\
+                'mailhost' in config:
                 config['mailhost'] = self.as_tuple(config['mailhost'])
-            elif issubclass(klass, logging.handlers.SysLogHandler) and \
-                    'address' in config:
+            elif issubclass(klass, logging.handlers.SysLogHandler) and\
+                'address' in config:
                 config['address'] = self.as_tuple(config['address'])
             if issubclass(klass, logging.handlers.QueueHandler):
                 factory = functools.partial(self._configure_queue_handler, klass)
@@ -1018,9 +1011,8 @@ class ConfigSocketReceiver(ThreadingTCPServer):
         def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,
                      handler=None, ready=None, verify=None):
             ThreadingTCPServer.__init__(self, (host, port), handler)
-            logging._acquireLock()
-            self.abort = 0
-            logging._releaseLock()
+            with logging._lock:
+                self.abort = 0
             self.timeout = 1
             self.ready = ready
             self.verify = verify
@@ -1034,9 +1026,8 @@ def serve_until_stopped(self):
                                            self.timeout)
                 if rd:
                     self.handle_request()
-                logging._acquireLock()
-                abort = self.abort
-                logging._releaseLock()
+                with logging._lock:
+                    abort = self.abort
             self.server_close()
 
     class Server(threading.Thread):
@@ -1057,9 +1048,8 @@ def run(self):
                 self.port = server.server_address[1]
             self.ready.set()
             global _listener
-            logging._acquireLock()
-            _listener = server
-            logging._releaseLock()
+            with logging._lock:
+                _listener = server
             server.serve_until_stopped()
 
     return Server(ConfigSocketReceiver, ConfigStreamHandler, port, verify)
@@ -1069,10 +1059,7 @@ def stopListening():
     Stop the listening server which was created with a call to listen().
     """
     global _listener
-    logging._acquireLock()
-    try:
+    with logging._lock:
         if _listener:
             _listener.abort = 1
             _listener = None
-    finally:
-        logging._releaseLock()
diff --git a/Lib/logging/handlers.py b/Lib/logging/handlers.py
index bf42ea1103..d3ea06c731 100644
--- a/Lib/logging/handlers.py
+++ b/Lib/logging/handlers.py
@@ -23,11 +23,17 @@
 To use, simply 'import logging.handlers' and log away!
 """
 
-import io, logging, socket, os, pickle, struct, time, re
-from stat import ST_DEV, ST_INO, ST_MTIME
+import copy
+import io
+import logging
+import os
+import pickle
 import queue
+import re
+import socket
+import struct
 import threading
-import copy
+import time
 
 #
 # Some constants...
@@ -272,7 +278,7 @@ def __init__(self, filename, when='h', interval=1, backupCount=0,
         # path object (see Issue #27493), but self.baseFilename will be a string
         filename = self.baseFilename
         if os.path.exists(filename):
-            t = os.stat(filename)[ST_MTIME]
+            t = int(os.stat(filename).st_mtime)
         else:
             t = int(time.time())
         self.rolloverAt = self.computeRollover(t)
@@ -304,10 +310,10 @@ def computeRollover(self, currentTime):
                 rotate_ts = _MIDNIGHT
             else:
                 rotate_ts = ((self.atTime.hour * 60 + self.atTime.minute)*60 +
-                             self.atTime.second)
+                    self.atTime.second)
 
             r = rotate_ts - ((currentHour * 60 + currentMinute) * 60 +
-                             currentSecond)
+                currentSecond)
             if r <= 0:
                 # Rotate time is before the current time (for example when
                 # self.rotateAt is 13:45 and it now 14:15), rotation is
@@ -465,8 +471,7 @@ class WatchedFileHandler(logging.FileHandler):
     This handler is not appropriate for use under Windows, because
     under Windows open files cannot be moved or renamed - logging
     opens the files with exclusive locks - and so there is no need
-    for such a handler. Furthermore, ST_INO is not supported under
-    Windows; stat always returns zero for this value.
+    for such a handler.
 
     This handler is based on a suggestion and patch by Chad J.
     Schroeder.
@@ -482,9 +487,11 @@ def __init__(self, filename, mode='a', encoding=None, delay=False,
         self._statstream()
 
     def _statstream(self):
-        if self.stream:
-            sres = os.fstat(self.stream.fileno())
-            self.dev, self.ino = sres[ST_DEV], sres[ST_INO]
+        if self.stream is None:
+            return
+        sres = os.fstat(self.stream.fileno())
+        self.dev = sres.st_dev
+        self.ino = sres.st_ino
 
     def reopenIfNeeded(self):
         """
@@ -494,6 +501,9 @@ def reopenIfNeeded(self):
         has, close the old stream and reopen the file to get the
         current stream.
         """
+        if self.stream is None:
+            return
+
         # Reduce the chance of race conditions by stat'ing by path only
         # once and then fstat'ing our new fd if we opened a new log stream.
         # See issue #14632: Thanks to John Mulligan for the problem report
@@ -501,18 +511,23 @@ def reopenIfNeeded(self):
         try:
             # stat the file by path, checking for existence
             sres = os.stat(self.baseFilename)
+
+            # compare file system stat with that of our stream file handle
+            reopen = (sres.st_dev != self.dev or sres.st_ino != self.ino)
         except FileNotFoundError:
-            sres = None
-        # compare file system stat with that of our stream file handle
-        if not sres or sres[ST_DEV] != self.dev or sres[ST_INO] != self.ino:
-            if self.stream is not None:
-                # we have an open file handle, clean it up
-                self.stream.flush()
-                self.stream.close()
-                self.stream = None  # See Issue #21742: _open () might fail.
-                # open a new file handle and get new stat info from that fd
-                self.stream = self._open()
-                self._statstream()
+            reopen = True
+
+        if not reopen:
+            return
+
+        # we have an open file handle, clean it up
+        self.stream.flush()
+        self.stream.close()
+        self.stream = None  # See Issue #21742: _open () might fail.
+
+        # open a new file handle and get new stat info from that fd
+        self.stream = self._open()
+        self._statstream()
 
     def emit(self, record):
         """
@@ -682,15 +697,12 @@ def close(self):
         """
         Closes the socket.
         """
-        self.acquire()
-        try:
+        with self.lock:
             sock = self.sock
             if sock:
                 self.sock = None
                 sock.close()
             logging.Handler.close(self)
-        finally:
-            self.release()
 
 class DatagramHandler(SocketHandler):
     """
@@ -803,7 +815,7 @@ class SysLogHandler(logging.Handler):
         "panic":    LOG_EMERG,      #  DEPRECATED
         "warn":     LOG_WARNING,    #  DEPRECATED
         "warning":  LOG_WARNING,
-    }
+        }
 
     facility_names = {
         "auth":         LOG_AUTH,
@@ -830,7 +842,7 @@ class SysLogHandler(logging.Handler):
         "local5":       LOG_LOCAL5,
         "local6":       LOG_LOCAL6,
         "local7":       LOG_LOCAL7,
-    }
+        }
 
     # Originally added to work around GH-43683. Unnecessary since GH-50043 but kept
     # for backwards compatibility.
@@ -950,15 +962,12 @@ def close(self):
         """
         Closes the socket.
         """
-        self.acquire()
-        try:
+        with self.lock:
             sock = self.socket
             if sock:
                 self.socket = None
                 sock.close()
             logging.Handler.close(self)
-        finally:
-            self.release()
 
     def mapPriority(self, levelName):
         """
@@ -1031,7 +1040,8 @@ def __init__(self, mailhost, fromaddr, toaddrs, subject,
         only be used when authentication credentials are supplied. The tuple
         will be either an empty tuple, or a single-value tuple with the name
         of a keyfile, or a 2-value tuple with the names of the keyfile and
-        certificate file. (This tuple is passed to the `starttls` method).
+        certificate file. (This tuple is passed to the
+        `ssl.SSLContext.load_cert_chain` method).
         A timeout in seconds can be specified for the SMTP connection (the
         default is one second).
         """
@@ -1084,8 +1094,23 @@ def emit(self, record):
             msg.set_content(self.format(record))
             if self.username:
                 if self.secure is not None:
+                    import ssl
+
+                    try:
+                        keyfile = self.secure[0]
+                    except IndexError:
+                        keyfile = None
+
+                    try:
+                        certfile = self.secure[1]
+                    except IndexError:
+                        certfile = None
+
+                    context = ssl._create_stdlib_context(
+                        certfile=certfile, keyfile=keyfile
+                    )
                     smtp.ehlo()
-                    smtp.starttls(*self.secure)
+                    smtp.starttls(context=context)
                     smtp.ehlo()
                 smtp.login(self.username, self.password)
             smtp.send_message(msg)
@@ -1132,10 +1157,10 @@ def __init__(self, appname, dllname=None, logtype="Application"):
                 logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE,
                 logging.ERROR   : win32evtlog.EVENTLOG_ERROR_TYPE,
                 logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
-            }
+         }
         except ImportError:
-            print("The Python Win32 extensions for NT (service, event " \
-                  "logging) appear not to be available.")
+            print("The Python Win32 extensions for NT (service, event "\
+                        "logging) appear not to be available.")
             self._welu = None
 
     def getMessageID(self, record):
@@ -1330,11 +1355,8 @@ def flush(self):
 
         This version just zaps the buffer to empty.
         """
-        self.acquire()
-        try:
+        with self.lock:
             self.buffer.clear()
-        finally:
-            self.release()
 
     def close(self):
         """
@@ -1378,17 +1400,14 @@ def shouldFlush(self, record):
         Check for buffer full or a record at the flushLevel or higher.
         """
         return (len(self.buffer) >= self.capacity) or \
-            (record.levelno >= self.flushLevel)
+                (record.levelno >= self.flushLevel)
 
     def setTarget(self, target):
         """
         Set the target handler for this handler.
         """
-        self.acquire()
-        try:
+        with self.lock:
             self.target = target
-        finally:
-            self.release()
 
     def flush(self):
         """
@@ -1398,14 +1417,11 @@ def flush(self):
 
         The record buffer is only cleared if a target has been set.
         """
-        self.acquire()
-        try:
+        with self.lock:
             if self.target:
                 for record in self.buffer:
                     self.target.handle(record)
                 self.buffer.clear()
-        finally:
-            self.release()
 
     def close(self):
         """
@@ -1416,12 +1432,9 @@ def close(self):
             if self.flushOnClose:
                 self.flush()
         finally:
-            self.acquire()
-            try:
+            with self.lock:
                 self.target = None
                 BufferingHandler.close(self)
-            finally:
-                self.release()
 
 
 class QueueHandler(logging.Handler):
@@ -1532,6 +1545,9 @@ def start(self):
         This starts up a background thread to monitor the queue for
         LogRecords to process.
         """
+        if self._thread is not None:
+            raise RuntimeError("Listener already started")
+
         self._thread = t = threading.Thread(target=self._monitor)
         t.daemon = True
         t.start()
@@ -1603,6 +1619,7 @@ def stop(self):
         Note that if you don't call this before your application exits, there
         may be some records still left on the queue, which won't be processed.
         """
-        self.enqueue_sentinel()
-        self._thread.join()
-        self._thread = None
+        if self._thread:  # see gh-114706 - allow calling this more than once
+            self.enqueue_sentinel()
+            self._thread.join()
+            self._thread = None
diff --git a/Lib/lzma.py b/Lib/lzma.py
index 6668921f00..c1e3d33deb 100644
--- a/Lib/lzma.py
+++ b/Lib/lzma.py
@@ -128,7 +128,7 @@ def __init__(self, filename=None, mode="r", *,
 
         if self._mode == _MODE_READ:
             raw = _compression.DecompressReader(self._fp, LZMADecompressor,
-                                                trailing_error=LZMAError, format=format, filters=filters)
+                trailing_error=LZMAError, format=format, filters=filters)
             self._buffer = io.BufferedReader(raw)
 
     def close(self):
diff --git a/Lib/mailbox.py b/Lib/mailbox.py
index 70da07ed2e..b00d9e8634 100644
--- a/Lib/mailbox.py
+++ b/Lib/mailbox.py
@@ -395,6 +395,56 @@ def get_file(self, key):
         f = open(os.path.join(self._path, self._lookup(key)), 'rb')
         return _ProxyFile(f)
 
+    def get_info(self, key):
+        """Get the keyed message's "info" as a string."""
+        subpath = self._lookup(key)
+        if self.colon in subpath:
+            return subpath.split(self.colon)[-1]
+        return ''
+
+    def set_info(self, key, info: str):
+        """Set the keyed message's "info" string."""
+        if not isinstance(info, str):
+            raise TypeError(f'info must be a string: {type(info)}')
+        old_subpath = self._lookup(key)
+        new_subpath = old_subpath.split(self.colon)[0]
+        if info:
+            new_subpath += self.colon + info
+        if new_subpath == old_subpath:
+            return
+        old_path = os.path.join(self._path, old_subpath)
+        new_path = os.path.join(self._path, new_subpath)
+        os.rename(old_path, new_path)
+        self._toc[key] = new_subpath
+
+    def get_flags(self, key):
+        """Return as a string the standard flags that are set on the keyed message."""
+        info = self.get_info(key)
+        if info.startswith('2,'):
+            return info[2:]
+        return ''
+
+    def set_flags(self, key, flags: str):
+        """Set the given flags and unset all others on the keyed message."""
+        if not isinstance(flags, str):
+            raise TypeError(f'flags must be a string: {type(flags)}')
+        # TODO: check if flags are valid standard flag characters?
+        self.set_info(key, '2,' + ''.join(sorted(set(flags))))
+
+    def add_flag(self, key, flag: str):
+        """Set the given flag(s) without changing others on the keyed message."""
+        if not isinstance(flag, str):
+            raise TypeError(f'flag must be a string: {type(flag)}')
+        # TODO: check that flag is a valid standard flag character?
+        self.set_flags(key, ''.join(set(self.get_flags(key)) | set(flag)))
+
+    def remove_flag(self, key, flag: str):
+        """Unset the given string flag(s) without changing others on the keyed message."""
+        if not isinstance(flag, str):
+            raise TypeError(f'flag must be a string: {type(flag)}')
+        if self.get_flags(key):
+            self.set_flags(key, ''.join(set(self.get_flags(key)) - set(flag)))
+
     def iterkeys(self):
         """Return an iterator over keys."""
         self._refresh()
@@ -540,6 +590,8 @@ def _refresh(self):
         for subdir in self._toc_mtimes:
             path = self._paths[subdir]
             for entry in os.listdir(path):
+                if entry.startswith('.'):
+                    continue
                 p = os.path.join(path, entry)
                 if os.path.isdir(p):
                     continue
@@ -698,9 +750,13 @@ def flush(self):
         _sync_close(new_file)
         # self._file is about to get replaced, so no need to sync.
         self._file.close()
-        # Make sure the new file's mode is the same as the old file's
-        mode = os.stat(self._path).st_mode
-        os.chmod(new_file.name, mode)
+        # Make sure the new file's mode and owner are the same as the old file's
+        info = os.stat(self._path)
+        os.chmod(new_file.name, info.st_mode)
+        try:
+            os.chown(new_file.name, info.st_uid, info.st_gid)
+        except (AttributeError, OSError):
+            pass
         try:
             os.rename(new_file.name, self._path)
         except FileExistsError:
@@ -778,10 +834,11 @@ def get_message(self, key):
         """Return a Message representation or raise a KeyError."""
         start, stop = self._lookup(key)
         self._file.seek(start)
-        from_line = self._file.readline().replace(linesep, b'')
+        from_line = self._file.readline().replace(linesep, b'').decode('ascii')
         string = self._file.read(stop - self._file.tell())
         msg = self._message_factory(string.replace(linesep, b'\n'))
-        msg.set_from(from_line[5:].decode('ascii'))
+        msg.set_unixfrom(from_line)
+        msg.set_from(from_line[5:])
         return msg
 
     def get_string(self, key, from_=False):
@@ -1089,10 +1146,24 @@ def __len__(self):
         """Return a count of messages in the mailbox."""
         return len(list(self.iterkeys()))
 
+    def _open_mh_sequences_file(self, text):
+        mode = '' if text else 'b'
+        kwargs = {'encoding': 'ASCII'} if text else {}
+        path = os.path.join(self._path, '.mh_sequences')
+        while True:
+            try:
+                return open(path, 'r+' + mode, **kwargs)
+            except FileNotFoundError:
+                pass
+            try:
+                return open(path, 'x+' + mode, **kwargs)
+            except FileExistsError:
+                pass
+
     def lock(self):
         """Lock the mailbox."""
         if not self._locked:
-            self._file = open(os.path.join(self._path, '.mh_sequences'), 'rb+')
+            self._file = self._open_mh_sequences_file(text=False)
             _lock_file(self._file)
             self._locked = True
 
@@ -1146,7 +1217,11 @@ def remove_folder(self, folder):
     def get_sequences(self):
         """Return a name-to-key-list dictionary to define each sequence."""
         results = {}
-        with open(os.path.join(self._path, '.mh_sequences'), 'r', encoding='ASCII') as f:
+        try:
+            f = open(os.path.join(self._path, '.mh_sequences'), 'r', encoding='ASCII')
+        except FileNotFoundError:
+            return results
+        with f:
             all_keys = set(self.keys())
             for line in f:
                 try:
@@ -1169,7 +1244,7 @@ def get_sequences(self):
 
     def set_sequences(self, sequences):
         """Set sequences using the given name-to-key-list dictionary."""
-        f = open(os.path.join(self._path, '.mh_sequences'), 'r+', encoding='ASCII')
+        f = self._open_mh_sequences_file(text=True)
         try:
             os.close(os.open(f.name, os.O_WRONLY | os.O_TRUNC))
             for name, keys in sequences.items():
@@ -1956,10 +2031,7 @@ def readlines(self, sizehint=None):
 
     def __iter__(self):
         """Iterate over lines."""
-        while True:
-            line = self.readline()
-            if not line:
-                return
+        while line := self.readline():
             yield line
 
     def tell(self):
diff --git a/Lib/multiprocessing/connection.py b/Lib/multiprocessing/connection.py
index d0582e3cd5..abd88adf76 100644
--- a/Lib/multiprocessing/connection.py
+++ b/Lib/multiprocessing/connection.py
@@ -19,7 +19,6 @@
 import tempfile
 import itertools
 
-import _multiprocessing
 
 from . import util
 
@@ -28,6 +27,7 @@
 _ForkingPickler = reduction.ForkingPickler
 
 try:
+    import _multiprocessing
     import _winapi
     from _winapi import WAIT_OBJECT_0, WAIT_ABANDONED_0, WAIT_TIMEOUT, INFINITE
 except ImportError:
@@ -74,7 +74,7 @@ def arbitrary_address(family):
     if family == 'AF_INET':
         return ('localhost', 0)
     elif family == 'AF_UNIX':
-        return tempfile.mktemp(prefix='listener-', dir=util.get_temp_dir())
+        return tempfile.mktemp(prefix='sock-', dir=util.get_temp_dir())
     elif family == 'AF_PIPE':
         return tempfile.mktemp(prefix=r'\\.\pipe\pyc-%d-%d-' %
                                (os.getpid(), next(_mmap_counter)), dir="")
@@ -846,7 +846,7 @@ def PipeClient(address):
 _LEGACY_LENGTHS = (_MD5ONLY_MESSAGE_LENGTH, _MD5_DIGEST_LEN)
 
 
-def _get_digest_name_and_payload(message: bytes) -> (str, bytes):
+def _get_digest_name_and_payload(message):  # type: (bytes) -> tuple[str, bytes]
     """Returns a digest name and the payload for a response hash.
 
     If a legacy protocol is detected based on the message length
@@ -956,7 +956,7 @@ def answer_challenge(connection, authkey: bytes):
                 f'Protocol error, expected challenge: {message=}')
     message = message[len(_CHALLENGE):]
     if len(message) < _MD5ONLY_MESSAGE_LENGTH:
-        raise AuthenticationError('challenge too short: {len(message)} bytes')
+        raise AuthenticationError(f'challenge too short: {len(message)} bytes')
     digest = _create_response(authkey, message)
     connection.send_bytes(digest)
     response = connection.recv_bytes(256)        # reject large message
@@ -1012,8 +1012,20 @@ def _exhaustive_wait(handles, timeout):
         # returning the first signalled might create starvation issues.)
         L = list(handles)
         ready = []
+        # Windows limits WaitForMultipleObjects at 64 handles, and we use a
+        # few for synchronisation, so we switch to batched waits at 60.
+        if len(L) > 60:
+            try:
+                res = _winapi.BatchedWaitForMultipleObjects(L, False, timeout)
+            except TimeoutError:
+                return []
+            ready.extend(L[i] for i in res)
+            if res:
+                L = [h for i, h in enumerate(L) if i > res[0] & i not in res]
+            timeout = 0
         while L:
-            res = _winapi.WaitForMultipleObjects(L, False, timeout)
+            short_L = L[:60] if len(L) > 60 else L
+            res = _winapi.WaitForMultipleObjects(short_L, False, timeout)
             if res == WAIT_TIMEOUT:
                 break
             elif WAIT_OBJECT_0 <= res < WAIT_OBJECT_0 + len(L):
diff --git a/Lib/multiprocessing/context.py b/Lib/multiprocessing/context.py
index de8a264829..f395e8b04d 100644
--- a/Lib/multiprocessing/context.py
+++ b/Lib/multiprocessing/context.py
@@ -145,7 +145,7 @@ def freeze_support(self):
         '''Check whether this is a fake forked process in a frozen executable.
         If so then run code specified by commandline and exit.
         '''
-        if sys.platform == 'win32' and getattr(sys, 'frozen', False):
+        if self.get_start_method() == 'spawn' and getattr(sys, 'frozen', False):
             from .spawn import freeze_support
             freeze_support()
 
diff --git a/Lib/multiprocessing/forkserver.py b/Lib/multiprocessing/forkserver.py
index 4642707dae..e243442e7a 100644
--- a/Lib/multiprocessing/forkserver.py
+++ b/Lib/multiprocessing/forkserver.py
@@ -1,3 +1,4 @@
+import atexit
 import errno
 import os
 import selectors
@@ -126,12 +127,13 @@ def ensure_running(self):
             cmd = ('from multiprocessing.forkserver import main; ' +
                    'main(%d, %d, %r, **%r)')
 
+            main_kws = {}
             if self._preload_modules:
-                desired_keys = {'main_path', 'sys_path'}
                 data = spawn.get_preparation_data('ignore')
-                data = {x: y for x, y in data.items() if x in desired_keys}
-            else:
-                data = {}
+                if 'sys_path' in data:
+                    main_kws['sys_path'] = data['sys_path']
+                if 'init_main_from_path' in data:
+                    main_kws['main_path'] = data['init_main_from_path']
 
             with socket.socket(socket.AF_UNIX) as listener:
                 address = connection.arbitrary_address('AF_UNIX')
@@ -146,7 +148,7 @@ def ensure_running(self):
                 try:
                     fds_to_pass = [listener.fileno(), alive_r]
                     cmd %= (listener.fileno(), alive_r, self._preload_modules,
-                            data)
+                            main_kws)
                     exe = spawn.get_executable()
                     args = [exe] + util._args_from_interpreter_flags()
                     args += ['-c', cmd]
@@ -167,6 +169,8 @@ def ensure_running(self):
 def main(listener_fd, alive_r, preload, main_path=None, sys_path=None):
     '''Run forkserver.'''
     if preload:
+        if sys_path is not None:
+            sys.path[:] = sys_path
         if '__main__' in preload and main_path is not None:
             process.current_process()._inheriting = True
             try:
@@ -179,6 +183,10 @@ def main(listener_fd, alive_r, preload, main_path=None, sys_path=None):
             except ImportError:
                 pass
 
+        # gh-135335: flush stdout/stderr in case any of the preloaded modules
+        # wrote to them, otherwise children might inherit buffered data
+        util._flush_std_streams()
+
     util._close_stdin()
 
     sig_r, sig_w = os.pipe()
@@ -271,6 +279,8 @@ def sigchld_handler(*_unused):
                                 selector.close()
                                 unused_fds = [alive_r, child_w, sig_r, sig_w]
                                 unused_fds.extend(pid_to_fd.values())
+                                atexit._clear()
+                                atexit.register(util._exit_function)
                                 code = _serve_one(child_r, fds,
                                                   unused_fds,
                                                   old_handlers)
@@ -278,6 +288,7 @@ def sigchld_handler(*_unused):
                                 sys.excepthook(*sys.exc_info())
                                 sys.stderr.flush()
                             finally:
+                                atexit._run_exitfuncs()
                                 os._exit(code)
                         else:
                             # Send pid to client process
diff --git a/Lib/multiprocessing/managers.py b/Lib/multiprocessing/managers.py
index 75d9c18c20..ef791c2751 100644
--- a/Lib/multiprocessing/managers.py
+++ b/Lib/multiprocessing/managers.py
@@ -90,7 +90,10 @@ def dispatch(c, id, methodname, args=(), kwds={}):
     kind, result = c.recv()
     if kind == '#RETURN':
         return result
-    raise convert_to_error(kind, result)
+    try:
+        raise convert_to_error(kind, result)
+    finally:
+        del result  # break reference cycle
 
 def convert_to_error(kind, result):
     if kind == '#ERROR':
@@ -755,22 +758,29 @@ class BaseProxy(object):
     _address_to_local = {}
     _mutex = util.ForkAwareThreadLock()
 
+    # Each instance gets a `_serial` number. Unlike `id(...)`, this number
+    # is never reused.
+    _next_serial = 1
+
     def __init__(self, token, serializer, manager=None,
                  authkey=None, exposed=None, incref=True, manager_owned=False):
         with BaseProxy._mutex:
-            tls_idset = BaseProxy._address_to_local.get(token.address, None)
-            if tls_idset is None:
-                tls_idset = util.ForkAwareLocal(), ProcessLocalSet()
-                BaseProxy._address_to_local[token.address] = tls_idset
+            tls_serials = BaseProxy._address_to_local.get(token.address, None)
+            if tls_serials is None:
+                tls_serials = util.ForkAwareLocal(), ProcessLocalSet()
+                BaseProxy._address_to_local[token.address] = tls_serials
+
+            self._serial = BaseProxy._next_serial
+            BaseProxy._next_serial += 1
 
         # self._tls is used to record the connection used by this
         # thread to communicate with the manager at token.address
-        self._tls = tls_idset[0]
+        self._tls = tls_serials[0]
 
-        # self._idset is used to record the identities of all shared
-        # objects for which the current process owns references and
+        # self._all_serials is a set used to record the identities of all
+        # shared objects for which the current process owns references and
         # which are in the manager at token.address
-        self._idset = tls_idset[1]
+        self._all_serials = tls_serials[1]
 
         self._token = token
         self._id = self._token.id
@@ -833,7 +843,10 @@ def _callmethod(self, methodname, args=(), kwds={}):
             conn = self._Client(token.address, authkey=self._authkey)
             dispatch(conn, None, 'decref', (token.id,))
             return proxy
-        raise convert_to_error(kind, result)
+        try:
+            raise convert_to_error(kind, result)
+        finally:
+            del result   # break reference cycle
 
     def _getvalue(self):
         '''
@@ -850,20 +863,20 @@ def _incref(self):
         dispatch(conn, None, 'incref', (self._id,))
         util.debug('INCREF %r', self._token.id)
 
-        self._idset.add(self._id)
+        self._all_serials.add(self._serial)
 
         state = self._manager and self._manager._state
 
         self._close = util.Finalize(
             self, BaseProxy._decref,
-            args=(self._token, self._authkey, state,
-                  self._tls, self._idset, self._Client),
+            args=(self._token, self._serial, self._authkey, state,
+                  self._tls, self._all_serials, self._Client),
             exitpriority=10
             )
 
     @staticmethod
-    def _decref(token, authkey, state, tls, idset, _Client):
-        idset.discard(token.id)
+    def _decref(token, serial, authkey, state, tls, idset, _Client):
+        idset.discard(serial)
 
         # check whether manager is still alive
         if state is None or state.value == State.STARTED:
@@ -1159,15 +1172,19 @@ def __imul__(self, value):
         self._callmethod('__imul__', (value,))
         return self
 
+    __class_getitem__ = classmethod(types.GenericAlias)
 
-DictProxy = MakeProxyType('DictProxy', (
+
+_BaseDictProxy = MakeProxyType('DictProxy', (
     '__contains__', '__delitem__', '__getitem__', '__iter__', '__len__',
     '__setitem__', 'clear', 'copy', 'get', 'items',
     'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
     ))
-DictProxy._method_to_typeid_ = {
+_BaseDictProxy._method_to_typeid_ = {
     '__iter__': 'Iterator',
     }
+class DictProxy(_BaseDictProxy):
+    __class_getitem__ = classmethod(types.GenericAlias)
 
 
 ArrayProxy = MakeProxyType('ArrayProxy', (
diff --git a/Lib/multiprocessing/pool.py b/Lib/multiprocessing/pool.py
index 4f5d88cb97..f979890170 100644
--- a/Lib/multiprocessing/pool.py
+++ b/Lib/multiprocessing/pool.py
@@ -200,7 +200,7 @@ def __init__(self, processes=None, initializer=None, initargs=(),
         self._initargs = initargs
 
         if processes is None:
-            processes = os.cpu_count() or 1
+            processes = os.process_cpu_count() or 1
         if processes < 1:
             raise ValueError("Number of processes must be at least 1")
         if maxtasksperchild is not None:
diff --git a/Lib/multiprocessing/popen_fork.py b/Lib/multiprocessing/popen_fork.py
index 625981cf47..a57ef6bdad 100644
--- a/Lib/multiprocessing/popen_fork.py
+++ b/Lib/multiprocessing/popen_fork.py
@@ -1,3 +1,4 @@
+import atexit
 import os
 import signal
 
@@ -66,10 +67,13 @@ def _launch(self, process_obj):
         self.pid = os.fork()
         if self.pid == 0:
             try:
+                atexit._clear()
+                atexit.register(util._exit_function)
                 os.close(parent_r)
                 os.close(parent_w)
                 code = process_obj._bootstrap(parent_sentinel=child_r)
             finally:
+                atexit._run_exitfuncs()
                 os._exit(code)
         else:
             os.close(child_w)
diff --git a/Lib/multiprocessing/popen_spawn_posix.py b/Lib/multiprocessing/popen_spawn_posix.py
index 24b8634523..cccd659ae7 100644
--- a/Lib/multiprocessing/popen_spawn_posix.py
+++ b/Lib/multiprocessing/popen_spawn_posix.py
@@ -57,6 +57,10 @@ def _launch(self, process_obj):
             self._fds.extend([child_r, child_w])
             self.pid = util.spawnv_passfds(spawn.get_executable(),
                                            cmd, self._fds)
+            os.close(child_r)
+            child_r = None
+            os.close(child_w)
+            child_w = None
             self.sentinel = parent_r
             with open(parent_w, 'wb', closefd=False) as f:
                 f.write(fp.getbuffer())
diff --git a/Lib/multiprocessing/popen_spawn_win32.py b/Lib/multiprocessing/popen_spawn_win32.py
index 49d4c7eea2..62fb0ddbf9 100644
--- a/Lib/multiprocessing/popen_spawn_win32.py
+++ b/Lib/multiprocessing/popen_spawn_win32.py
@@ -3,6 +3,7 @@
 import signal
 import sys
 import _winapi
+from subprocess import STARTUPINFO, STARTF_FORCEOFFFEEDBACK
 
 from .context import reduction, get_spawning_popen, set_spawning_popen
 from . import spawn
@@ -74,7 +75,8 @@ def __init__(self, process_obj):
             try:
                 hp, ht, pid, tid = _winapi.CreateProcess(
                     python_exe, cmd,
-                    None, None, False, 0, env, None, None)
+                    None, None, False, 0, env, None,
+                    STARTUPINFO(dwFlags=STARTF_FORCEOFFFEEDBACK))
                 _winapi.CloseHandle(ht)
             except:
                 _winapi.CloseHandle(rhandle)
diff --git a/Lib/multiprocessing/process.py b/Lib/multiprocessing/process.py
index 271ba3fd32..b45f7df476 100644
--- a/Lib/multiprocessing/process.py
+++ b/Lib/multiprocessing/process.py
@@ -310,11 +310,8 @@ def _bootstrap(self, parent_sentinel=None):
                 # _run_after_forkers() is executed
                 del old_process
             util.info('child process calling self.run()')
-            try:
-                self.run()
-                exitcode = 0
-            finally:
-                util._exit_function()
+            self.run()
+            exitcode = 0
         except SystemExit as e:
             if e.code is None:
                 exitcode = 0
diff --git a/Lib/multiprocessing/queues.py b/Lib/multiprocessing/queues.py
index 852ae87b27..925f043900 100644
--- a/Lib/multiprocessing/queues.py
+++ b/Lib/multiprocessing/queues.py
@@ -20,8 +20,6 @@
 
 from queue import Empty, Full
 
-import _multiprocessing
-
 from . import connection
 from . import context
 _ForkingPickler = context.reduction.ForkingPickler
diff --git a/Lib/multiprocessing/resource_tracker.py b/Lib/multiprocessing/resource_tracker.py
index 79e96ecf32..22e3bbcf21 100644
--- a/Lib/multiprocessing/resource_tracker.py
+++ b/Lib/multiprocessing/resource_tracker.py
@@ -15,11 +15,15 @@
 # this resource tracker process, "killall python" would probably leave unlinked
 # resources.
 
+import base64
 import os
 import signal
 import sys
 import threading
 import warnings
+from collections import deque
+
+import json
 
 from . import spawn
 from . import util
@@ -29,8 +33,12 @@
 _HAVE_SIGMASK = hasattr(signal, 'pthread_sigmask')
 _IGNORED_SIGNALS = (signal.SIGINT, signal.SIGTERM)
 
+def cleanup_noop(name):
+    raise RuntimeError('noop should never be registered or cleaned up')
+
 _CLEANUP_FUNCS = {
-    'noop': lambda: None,
+    'noop': cleanup_noop,
+    'dummy': lambda name: None,  # Dummy resource used in tests
 }
 
 if os.name == 'posix':
@@ -61,6 +69,15 @@ def __init__(self):
         self._lock = threading.RLock()
         self._fd = None
         self._pid = None
+        self._exitcode = None
+        self._reentrant_messages = deque()
+
+        # True to use colon-separated lines, rather than JSON lines,
+        # for internal communication. (Mainly for testing).
+        # Filenames not supported by the simple format will always be sent
+        # using JSON.
+        # The reader should understand all formats.
+        self._use_simple_format = True
 
     def _reentrant_call_error(self):
         # gh-109629: this happens if an explicit call to the ResourceTracker
@@ -70,22 +87,58 @@ def _reentrant_call_error(self):
         raise ReentrantCallError(
             "Reentrant call into the multiprocessing resource tracker")
 
-    def _stop(self):
-        with self._lock:
-            # This should not happen (_stop() isn't called by a finalizer)
-            # but we check for it anyway.
-            if self._lock._recursion_count() > 1:
-                return self._reentrant_call_error()
-            if self._fd is None:
-                # not running
-                return
+    def __del__(self):
+        # making sure child processess are cleaned before ResourceTracker
+        # gets destructed.
+        # see https://github.com/python/cpython/issues/88887
+        self._stop(use_blocking_lock=False)
 
-            # closing the "alive" file descriptor stops main()
-            os.close(self._fd)
-            self._fd = None
+    def _stop(self, use_blocking_lock=True):
+        if use_blocking_lock:
+            with self._lock:
+                self._stop_locked()
+        else:
+            acquired = self._lock.acquire(blocking=False)
+            try:
+                self._stop_locked()
+            finally:
+                if acquired:
+                    self._lock.release()
+
+    def _stop_locked(
+        self,
+        close=os.close,
+        waitpid=os.waitpid,
+        waitstatus_to_exitcode=os.waitstatus_to_exitcode,
+    ):
+        # This shouldn't happen (it might when called by a finalizer)
+        # so we check for it anyway.
+        if self._lock._recursion_count() > 1:
+            raise self._reentrant_call_error()
+        if self._fd is None:
+            # not running
+            return
+        if self._pid is None:
+            return
+
+        # closing the "alive" file descriptor stops main()
+        close(self._fd)
+        self._fd = None
 
-            os.waitpid(self._pid, 0)
+        try:
+            _, status = waitpid(self._pid, 0)
+        except ChildProcessError:
             self._pid = None
+            self._exitcode = None
+            return
+
+        self._pid = None
+
+        try:
+            self._exitcode = waitstatus_to_exitcode(status)
+        except ValueError:
+            # os.waitstatus_to_exitcode may raise an exception for invalid values
+            self._exitcode = None
 
     def getfd(self):
         self.ensure_running()
@@ -96,74 +149,119 @@ def ensure_running(self):
 
         This can be run from any process.  Usually a child process will use
         the resource created by its parent.'''
+        return self._ensure_running_and_write()
+
+    def _teardown_dead_process(self):
+        os.close(self._fd)
+
+        # Clean-up to avoid dangling processes.
+        try:
+            # _pid can be None if this process is a child from another
+            # python process, which has started the resource_tracker.
+            if self._pid is not None:
+                os.waitpid(self._pid, 0)
+        except ChildProcessError:
+            # The resource_tracker has already been terminated.
+            pass
+        self._fd = None
+        self._pid = None
+        self._exitcode = None
+
+        warnings.warn('resource_tracker: process died unexpectedly, '
+                      'relaunching.  Some resources might leak.')
+
+    def _launch(self):
+        fds_to_pass = []
+        try:
+            fds_to_pass.append(sys.stderr.fileno())
+        except Exception:
+            pass
+        r, w = os.pipe()
+        try:
+            fds_to_pass.append(r)
+            # process will out live us, so no need to wait on pid
+            exe = spawn.get_executable()
+            args = [
+                exe,
+                *util._args_from_interpreter_flags(),
+                '-c',
+                f'from multiprocessing.resource_tracker import main;main({r})',
+            ]
+            # bpo-33613: Register a signal mask that will block the signals.
+            # This signal mask will be inherited by the child that is going
+            # to be spawned and will protect the child from a race condition
+            # that can make the child die before it registers signal handlers
+            # for SIGINT and SIGTERM. The mask is unregistered after spawning
+            # the child.
+            prev_sigmask = None
+            try:
+                if _HAVE_SIGMASK:
+                    prev_sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, _IGNORED_SIGNALS)
+                pid = util.spawnv_passfds(exe, args, fds_to_pass)
+            finally:
+                if prev_sigmask is not None:
+                    signal.pthread_sigmask(signal.SIG_SETMASK, prev_sigmask)
+        except:
+            os.close(w)
+            raise
+        else:
+            self._fd = w
+            self._pid = pid
+        finally:
+            os.close(r)
+
+    def _make_probe_message(self):
+        """Return a probe message."""
+        if self._use_simple_format:
+            return b'PROBE:0:noop\n'
+        return (
+            json.dumps(
+                {"cmd": "PROBE", "rtype": "noop"},
+                ensure_ascii=True,
+                separators=(",", ":"),
+            )
+            + "\n"
+        ).encode("ascii")
+
+    def _ensure_running_and_write(self, msg=None):
         with self._lock:
             if self._lock._recursion_count() > 1:
                 # The code below is certainly not reentrant-safe, so bail out
-                return self._reentrant_call_error()
+                if msg is None:
+                    raise self._reentrant_call_error()
+                return self._reentrant_messages.append(msg)
+
             if self._fd is not None:
                 # resource tracker was launched before, is it still running?
-                if self._check_alive():
-                    # => still alive
-                    return
-                # => dead, launch it again
-                os.close(self._fd)
-
-                # Clean-up to avoid dangling processes.
+                if msg is None:
+                    to_send = self._make_probe_message()
+                else:
+                    to_send = msg
                 try:
-                    # _pid can be None if this process is a child from another
-                    # python process, which has started the resource_tracker.
-                    if self._pid is not None:
-                        os.waitpid(self._pid, 0)
-                except ChildProcessError:
-                    # The resource_tracker has already been terminated.
-                    pass
-                self._fd = None
-                self._pid = None
+                    self._write(to_send)
+                except OSError:
+                    self._teardown_dead_process()
+                    self._launch()
 
-                warnings.warn('resource_tracker: process died unexpectedly, '
-                              'relaunching.  Some resources might leak.')
+                msg = None  # message was sent in probe
+            else:
+                self._launch()
 
-            fds_to_pass = []
+        while True:
             try:
-                fds_to_pass.append(sys.stderr.fileno())
-            except Exception:
-                pass
-            cmd = 'from multiprocessing.resource_tracker import main;main(%d)'
-            r, w = os.pipe()
-            try:
-                fds_to_pass.append(r)
-                # process will out live us, so no need to wait on pid
-                exe = spawn.get_executable()
-                args = [exe] + util._args_from_interpreter_flags()
-                args += ['-c', cmd % r]
-                # bpo-33613: Register a signal mask that will block the signals.
-                # This signal mask will be inherited by the child that is going
-                # to be spawned and will protect the child from a race condition
-                # that can make the child die before it registers signal handlers
-                # for SIGINT and SIGTERM. The mask is unregistered after spawning
-                # the child.
-                try:
-                    if _HAVE_SIGMASK:
-                        signal.pthread_sigmask(signal.SIG_BLOCK, _IGNORED_SIGNALS)
-                    pid = util.spawnv_passfds(exe, args, fds_to_pass)
-                finally:
-                    if _HAVE_SIGMASK:
-                        signal.pthread_sigmask(signal.SIG_UNBLOCK, _IGNORED_SIGNALS)
-            except:
-                os.close(w)
-                raise
-            else:
-                self._fd = w
-                self._pid = pid
-            finally:
-                os.close(r)
+                reentrant_msg = self._reentrant_messages.popleft()
+            except IndexError:
+                break
+            self._write(reentrant_msg)
+        if msg is not None:
+            self._write(msg)
 
     def _check_alive(self):
         '''Check that the pipe has not been closed by sending a probe.'''
         try:
             # We cannot use send here as it calls ensure_running, creating
             # a cycle.
-            os.write(self._fd, b'PROBE:0:noop\n')
+            os.write(self._fd, self._make_probe_message())
         except OSError:
             return False
         else:
@@ -177,27 +275,42 @@ def unregister(self, name, rtype):
         '''Unregister name of resource with resource tracker.'''
         self._send('UNREGISTER', name, rtype)
 
-    def _send(self, cmd, name, rtype):
-        try:
-            self.ensure_running()
-        except ReentrantCallError:
-            # The code below might or might not work, depending on whether
-            # the resource tracker was already running and still alive.
-            # Better warn the user.
-            # (XXX is warnings.warn itself reentrant-safe? :-)
-            warnings.warn(
-                f"ResourceTracker called reentrantly for resource cleanup, "
-                f"which is unsupported. "
-                f"The {rtype} object {name!r} might leak.")
-        msg = '{0}:{1}:{2}\n'.format(cmd, name, rtype).encode('ascii')
-        if len(msg) > 512:
-            # posix guarantees that writes to a pipe of less than PIPE_BUF
-            # bytes are atomic, and that PIPE_BUF >= 512
-            raise ValueError('msg too long')
+    def _write(self, msg):
         nbytes = os.write(self._fd, msg)
-        assert nbytes == len(msg), "nbytes {0:n} but len(msg) {1:n}".format(
-            nbytes, len(msg))
+        assert nbytes == len(msg), f"{nbytes=} != {len(msg)=}"
 
+    def _send(self, cmd, name, rtype):
+        if self._use_simple_format and '\n' not in name:
+            msg = f"{cmd}:{name}:{rtype}\n".encode("ascii")
+            if len(msg) > 512:
+                # posix guarantees that writes to a pipe of less than PIPE_BUF
+                # bytes are atomic, and that PIPE_BUF >= 512
+                raise ValueError('msg too long')
+            self._ensure_running_and_write(msg)
+            return
+
+        # POSIX guarantees that writes to a pipe of less than PIPE_BUF (512 on Linux)
+        # bytes are atomic. Therefore, we want the message to be shorter than 512 bytes.
+        # POSIX shm_open() and sem_open() require the name, including its leading slash,
+        # to be at most NAME_MAX bytes (255 on Linux)
+        # With json.dump(..., ensure_ascii=True) every non-ASCII byte becomes a 6-char
+        # escape like \uDC80.
+        # As we want the overall message to be kept atomic and therefore smaller than 512,
+        # we encode encode the raw name bytes with URL-safe Base64 - so a 255 long name
+        # will not exceed 340 bytes.
+        b = name.encode('utf-8', 'surrogateescape')
+        if len(b) > 255:
+            raise ValueError('shared memory name too long (max 255 bytes)')
+        b64 = base64.urlsafe_b64encode(b).decode('ascii')
+
+        payload = {"cmd": cmd, "rtype": rtype, "base64_name": b64}
+        msg = (json.dumps(payload, ensure_ascii=True, separators=(",", ":")) + "\n").encode("ascii")
+
+        # The entire JSON message is guaranteed < PIPE_BUF (512 bytes) by construction.
+        assert len(msg) <= 512, f"internal error: message too long ({len(msg)} bytes)"
+        assert msg.startswith(b'{')
+
+        self._ensure_running_and_write(msg)
 
 _resource_tracker = ResourceTracker()
 ensure_running = _resource_tracker.ensure_running
@@ -206,6 +319,30 @@ def _send(self, cmd, name, rtype):
 getfd = _resource_tracker.getfd
 
 
+def _decode_message(line):
+    if line.startswith(b'{'):
+        try:
+            obj = json.loads(line.decode('ascii'))
+        except Exception as e:
+            raise ValueError("malformed resource_tracker message: %r" % (line,)) from e
+
+        cmd = obj["cmd"]
+        rtype = obj["rtype"]
+        b64  = obj.get("base64_name", "")
+
+        if not isinstance(cmd, str) or not isinstance(rtype, str) or not isinstance(b64, str):
+            raise ValueError("malformed resource_tracker fields: %r" % (obj,))
+
+        try:
+            name = base64.urlsafe_b64decode(b64).decode('utf-8', 'surrogateescape')
+        except ValueError as e:
+            raise ValueError("malformed resource_tracker base64_name: %r" % (b64,)) from e
+    else:
+        cmd, rest = line.strip().decode('ascii').split(':', maxsplit=1)
+        name, rtype = rest.rsplit(':', maxsplit=1)
+    return cmd, rtype, name
+
+
 def main(fd):
     '''Run resource tracker.'''
     # protect the process from ^C and "killall python" etc
@@ -221,12 +358,14 @@ def main(fd):
             pass
 
     cache = {rtype: set() for rtype in _CLEANUP_FUNCS.keys()}
+    exit_code = 0
+
     try:
         # keep track of registered/unregistered resources
         with open(fd, 'rb') as f:
             for line in f:
                 try:
-                    cmd, name, rtype = line.strip().decode('ascii').split(':')
+                    cmd, rtype, name = _decode_message(line)
                     cleanup_func = _CLEANUP_FUNCS.get(rtype, None)
                     if cleanup_func is None:
                         raise ValueError(
@@ -242,6 +381,7 @@ def main(fd):
                     else:
                         raise RuntimeError('unrecognized command %r' % cmd)
                 except Exception:
+                    exit_code = 3
                     try:
                         sys.excepthook(*sys.exc_info())
                     except:
@@ -251,9 +391,17 @@ def main(fd):
         for rtype, rtype_cache in cache.items():
             if rtype_cache:
                 try:
-                    warnings.warn('resource_tracker: There appear to be %d '
-                                  'leaked %s objects to clean up at shutdown' %
-                                  (len(rtype_cache), rtype))
+                    exit_code = 1
+                    if rtype == 'dummy':
+                        # The test 'dummy' resource is expected to leak.
+                        # We skip the warning (and *only* the warning) for it.
+                        pass
+                    else:
+                        warnings.warn(
+                            f'resource_tracker: There appear to be '
+                            f'{len(rtype_cache)} leaked {rtype} objects to '
+                            f'clean up at shutdown: {rtype_cache}'
+                        )
                 except Exception:
                     pass
             for name in rtype_cache:
@@ -264,6 +412,9 @@ def main(fd):
                     try:
                         _CLEANUP_FUNCS[rtype](name)
                     except Exception as e:
+                        exit_code = 2
                         warnings.warn('resource_tracker: %r: %s' % (name, e))
                 finally:
                     pass
+
+        sys.exit(exit_code)
diff --git a/Lib/multiprocessing/shared_memory.py b/Lib/multiprocessing/shared_memory.py
index 9a1e5aa17b..67e70fdc27 100644
--- a/Lib/multiprocessing/shared_memory.py
+++ b/Lib/multiprocessing/shared_memory.py
@@ -71,8 +71,9 @@ class SharedMemory:
     _flags = os.O_RDWR
     _mode = 0o600
     _prepend_leading_slash = True if _USE_POSIX else False
+    _track = True
 
-    def __init__(self, name=None, create=False, size=0):
+    def __init__(self, name=None, create=False, size=0, *, track=True):
         if not size >= 0:
             raise ValueError("'size' must be a positive integer")
         if create:
@@ -82,6 +83,7 @@ def __init__(self, name=None, create=False, size=0):
         if name is None and not self._flags & os.O_EXCL:
             raise ValueError("'name' can only be None if create=True")
 
+        self._track = track
         if _USE_POSIX:
 
             # POSIX Shared Memory
@@ -116,8 +118,8 @@ def __init__(self, name=None, create=False, size=0):
             except OSError:
                 self.unlink()
                 raise
-
-            resource_tracker.register(self._name, "shared_memory")
+            if self._track:
+                resource_tracker.register(self._name, "shared_memory")
 
         else:
 
@@ -236,12 +238,20 @@ def close(self):
     def unlink(self):
         """Requests that the underlying shared memory block be destroyed.
 
-        In order to ensure proper cleanup of resources, unlink should be
-        called once (and only once) across all processes which have access
-        to the shared memory block."""
+        Unlink should be called once (and only once) across all handles
+        which have access to the shared memory block, even if these
+        handles belong to different processes. Closing and unlinking may
+        happen in any order, but trying to access data inside a shared
+        memory block after unlinking may result in memory errors,
+        depending on platform.
+
+        This method has no effect on Windows, where the only way to
+        delete a shared memory block is to close all handles."""
+
         if _USE_POSIX and self._name:
             _posixshmem.shm_unlink(self._name)
-            resource_tracker.unregister(self._name, "shared_memory")
+            if self._track:
+                resource_tracker.unregister(self._name, "shared_memory")
 
 
 _encoding = "utf8"
diff --git a/Lib/multiprocessing/synchronize.py b/Lib/multiprocessing/synchronize.py
index 3ccbfe311c..870c91349b 100644
--- a/Lib/multiprocessing/synchronize.py
+++ b/Lib/multiprocessing/synchronize.py
@@ -174,7 +174,7 @@ def __repr__(self):
                 name = process.current_process().name
                 if threading.current_thread().name != 'MainThread':
                     name += '|' + threading.current_thread().name
-            elif self._semlock._get_value() == 1:
+            elif not self._semlock._is_zero():
                 name = 'None'
             elif self._semlock._count() > 0:
                 name = 'SomeOtherThread'
@@ -200,7 +200,7 @@ def __repr__(self):
                 if threading.current_thread().name != 'MainThread':
                     name += '|' + threading.current_thread().name
                 count = self._semlock._count()
-            elif self._semlock._get_value() == 1:
+            elif not self._semlock._is_zero():
                 name, count = 'None', 0
             elif self._semlock._count() > 0:
                 name, count = 'SomeOtherThread', 'nonzero'
@@ -360,7 +360,7 @@ def wait(self, timeout=None):
                 return True
             return False
 
-    def __repr__(self) -> str:
+    def __repr__(self):
         set_status = 'set' if self.is_set() else 'unset'
         return f"<{type(self).__qualname__} at {id(self):#x} {set_status}>"
 #
diff --git a/Lib/multiprocessing/util.py b/Lib/multiprocessing/util.py
index 79559823fb..b8bfea045d 100644
--- a/Lib/multiprocessing/util.py
+++ b/Lib/multiprocessing/util.py
@@ -34,6 +34,7 @@
 DEBUG = 10
 INFO = 20
 SUBWARNING = 25
+WARNING = 30
 
 LOGGER_NAME = 'multiprocessing'
 DEFAULT_LOGGING_FORMAT = '[%(levelname)s/%(processName)s] %(message)s'
@@ -53,6 +54,10 @@ def info(msg, *args):
     if _logger:
         _logger.log(INFO, msg, *args, stacklevel=2)
 
+def _warn(msg, *args):
+    if _logger:
+        _logger.log(WARNING, msg, *args, stacklevel=2)
+
 def sub_warning(msg, *args):
     if _logger:
         _logger.log(SUBWARNING, msg, *args, stacklevel=2)
@@ -64,8 +69,7 @@ def get_logger():
     global _logger
     import logging
 
-    logging._acquireLock()
-    try:
+    with logging._lock:
         if not _logger:
 
             _logger = logging.getLogger(LOGGER_NAME)
@@ -79,9 +83,6 @@ def get_logger():
                 atexit._exithandlers.remove((_exit_function, (), {}))
                 atexit._exithandlers.append((_exit_function, (), {}))
 
-    finally:
-        logging._releaseLock()
-
     return _logger
 
 def log_to_stderr(level=None):
@@ -106,11 +107,7 @@ def log_to_stderr(level=None):
 # Abstract socket support
 
 def _platform_supports_abstract_sockets():
-    if sys.platform == "linux":
-        return True
-    if hasattr(sys, 'getandroidapilevel'):
-        return True
-    return False
+    return sys.platform in ("linux", "android")
 
 
 def is_abstract_socket_namespace(address):
@@ -129,11 +126,25 @@ def is_abstract_socket_namespace(address):
 # Function returning a temp directory which will be removed on exit
 #
 
+# Maximum length of a NULL-terminated [1] socket file path is usually
+# between 92 and 108 [2], but Linux is known to use a size of 108 [3].
+# BSD-based systems usually use a size of 104 or 108 and Windows does
+# not create AF_UNIX sockets.
+#
+# [1]: https://github.com/python/cpython/issues/140734
+# [2]: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/sys_un.h.html
+# [3]: https://man7.org/linux/man-pages/man7/unix.7.html
+
+if sys.platform == 'linux':
+    _SUN_PATH_MAX = 108
+elif sys.platform.startswith(('openbsd', 'freebsd')):
+    _SUN_PATH_MAX = 104
+else:
+    # On Windows platforms, we do not create AF_UNIX sockets.
+    _SUN_PATH_MAX = None if os.name == 'nt' else 92
+
 def _remove_temp_dir(rmtree, tempdir):
-    def onerror(func, path, err_info):
-        if not issubclass(err_info[0], FileNotFoundError):
-            raise
-    rmtree(tempdir, onerror=onerror)
+    rmtree(tempdir)
 
     current_process = process.current_process()
     # current_process() can be None if the finalizer is called
@@ -141,12 +152,69 @@ def onerror(func, path, err_info):
     if current_process is not None:
         current_process._config['tempdir'] = None
 
+def _get_base_temp_dir(tempfile):
+    """Get a temporary directory where socket files will be created.
+
+    To prevent additional imports, pass a pre-imported 'tempfile' module.
+    """
+    if os.name == 'nt':
+        return None
+    # Most of the time, the default temporary directory is /tmp. Thus,
+    # listener sockets files "$TMPDIR/pymp-XXXXXXXX/sock-XXXXXXXX" do
+    # not have a path length exceeding SUN_PATH_MAX.
+    #
+    # If users specify their own temporary directory, we may be unable
+    # to create those files. Therefore, we fall back to the system-wide
+    # temporary directory /tmp, assumed to exist on POSIX systems.
+    #
+    # See https://github.com/python/cpython/issues/132124.
+    base_tempdir = tempfile.gettempdir()
+    # Files created in a temporary directory are suffixed by a string
+    # generated by tempfile._RandomNameSequence, which, by design,
+    # is 8 characters long.
+    #
+    # Thus, the socket file path length (without NULL terminator) will be:
+    #
+    #   len(base_tempdir + '/pymp-XXXXXXXX' + '/sock-XXXXXXXX')
+    sun_path_len = len(base_tempdir) + 14 + 14
+    # Strict inequality to account for the NULL terminator.
+    # See https://github.com/python/cpython/issues/140734.
+    if sun_path_len < _SUN_PATH_MAX:
+        return base_tempdir
+    # Fallback to the default system-wide temporary directory.
+    # This ignores user-defined environment variables.
+    #
+    # On POSIX systems, /tmp MUST be writable by any application [1].
+    # We however emit a warning if this is not the case to prevent
+    # obscure errors later in the execution.
+    #
+    # On some legacy systems, /var/tmp and /usr/tmp can be present
+    # and will be used instead.
+    #
+    # [1]: https://refspecs.linuxfoundation.org/FHS_3.0/fhs/ch03s18.html
+    dirlist = ['/tmp', '/var/tmp', '/usr/tmp']
+    try:
+        base_system_tempdir = tempfile._get_default_tempdir(dirlist)
+    except FileNotFoundError:
+        _warn("Process-wide temporary directory %s will not be usable for "
+              "creating socket files and no usable system-wide temporary "
+              "directory was found in %s", base_tempdir, dirlist)
+        # At this point, the system-wide temporary directory is not usable
+        # but we may assume that the user-defined one is, even if we will
+        # not be able to write socket files out there.
+        return base_tempdir
+    _warn("Ignoring user-defined temporary directory: %s", base_tempdir)
+    # at most max(map(len, dirlist)) + 14 + 14 = 36 characters
+    assert len(base_system_tempdir) + 14 + 14 < _SUN_PATH_MAX
+    return base_system_tempdir
+
 def get_temp_dir():
     # get name of a temp directory which will be automatically cleaned up
     tempdir = process.current_process()._config.get('tempdir')
     if tempdir is None:
         import shutil, tempfile
-        tempdir = tempfile.mkdtemp(prefix='pymp-')
+        base_tempdir = _get_base_temp_dir(tempfile)
+        tempdir = tempfile.mkdtemp(prefix='pymp-', dir=base_tempdir)
         info('created temp directory %s', tempdir)
         # keep a strong reference to shutil.rmtree(), since the finalizer
         # can be called late during Python shutdown
diff --git a/Lib/netrc.py b/Lib/netrc.py
index c1358aac6a..bd003e80a4 100644
--- a/Lib/netrc.py
+++ b/Lib/netrc.py
@@ -2,11 +2,24 @@
 
 # Module and documentation by Eric S. Raymond, 21 Dec 1998
 
-import os, shlex, stat
+import os, stat
 
 __all__ = ["netrc", "NetrcParseError"]
 
 
+def _can_security_check():
+    # On WASI, getuid() is indicated as a stub but it may also be missing.
+    return os.name == 'posix' and hasattr(os, 'getuid')
+
+
+def _getpwuid(uid):
+    try:
+        import pwd
+        return pwd.getpwuid(uid)[0]
+    except (ImportError, LookupError):
+        return f'uid {uid}'
+
+
 class NetrcParseError(Exception):
     """Exception raised on syntax errors in the .netrc file."""
     def __init__(self, msg, filename=None, lineno=None):
@@ -142,18 +155,12 @@ def _parse(self, file, fp, default_netrc):
             self._security_check(fp, default_netrc, self.hosts[entryname][0])
 
     def _security_check(self, fp, default_netrc, login):
-        if os.name == 'posix' and default_netrc and login != "anonymous":
+        if _can_security_check() and default_netrc and login != "anonymous":
             prop = os.fstat(fp.fileno())
-            if prop.st_uid != os.getuid():
-                import pwd
-                try:
-                    fowner = pwd.getpwuid(prop.st_uid)[0]
-                except KeyError:
-                    fowner = 'uid %s' % prop.st_uid
-                try:
-                    user = pwd.getpwuid(os.getuid())[0]
-                except KeyError:
-                    user = 'uid %s' % os.getuid()
+            current_user_id = os.getuid()
+            if prop.st_uid != current_user_id:
+                fowner = _getpwuid(prop.st_uid)
+                user = _getpwuid(current_user_id)
                 raise NetrcParseError(
                     (f"~/.netrc file owner ({fowner}, {user}) does not match"
                      " current user"))
diff --git a/Lib/ntpath.py b/Lib/ntpath.py
index df3402d46c..9cdc16480f 100644
--- a/Lib/ntpath.py
+++ b/Lib/ntpath.py
@@ -19,18 +19,17 @@
 
 import os
 import sys
-import stat
 import genericpath
 from genericpath import *
 
-
 __all__ = ["normcase","isabs","join","splitdrive","splitroot","split","splitext",
            "basename","dirname","commonprefix","getsize","getmtime",
            "getatime","getctime", "islink","exists","lexists","isdir","isfile",
-           "ismount", "expanduser","expandvars","normpath","abspath",
-           "curdir","pardir","sep","pathsep","defpath","altsep",
+           "ismount","isreserved","expanduser","expandvars","normpath",
+           "abspath","curdir","pardir","sep","pathsep","defpath","altsep",
            "extsep","devnull","realpath","supports_unicode_filenames","relpath",
-           "samefile", "sameopenfile", "samestat", "commonpath", "isjunction"]
+           "samefile", "sameopenfile", "samestat", "commonpath", "isjunction",
+           "isdevdrive", "ALLOW_MISSING"]
 
 def _get_bothseps(path):
     if isinstance(path, bytes):
@@ -78,12 +77,6 @@ def normcase(s):
         return s.replace('/', '\\').lower()
 
 
-# Return whether a path is absolute.
-# Trivial in Posix, harder on Windows.
-# For Windows it is absolute if it starts with a slash or backslash (current
-# volume), or if a pathname after the volume-letter-and-colon or UNC-resource
-# starts with a slash or backslash.
-
 def isabs(s):
     """Test whether a path is absolute"""
     s = os.fspath(s)
@@ -91,16 +84,15 @@ def isabs(s):
         sep = b'\\'
         altsep = b'/'
         colon_sep = b':\\'
+        double_sep = b'\\\\'
     else:
         sep = '\\'
         altsep = '/'
         colon_sep = ':\\'
+        double_sep = '\\\\'
     s = s[:3].replace(altsep, sep)
     # Absolute: UNC, device, and paths with a drive and root.
-    # LEGACY BUG: isabs("/x") should be false since the path has no drive.
-    if s.startswith(sep) or s.startswith(colon_sep, 1):
-        return True
-    return False
+    return s.startswith(colon_sep, 1) or s.startswith(double_sep)
 
 
 # Join two (or more) paths.
@@ -109,16 +101,14 @@ def join(path, *paths):
     if isinstance(path, bytes):
         sep = b'\\'
         seps = b'\\/'
-        colon = b':'
+        colon_seps = b':\\/'
     else:
         sep = '\\'
         seps = '\\/'
-        colon = ':'
+        colon_seps = ':\\/'
     try:
-        if not paths:
-            path[:0] + sep  #23780: Ensure compatible data type even if p is null.
         result_drive, result_root, result_path = splitroot(path)
-        for p in map(os.fspath, paths):
+        for p in paths:
             p_drive, p_root, p_path = splitroot(p)
             if p_root:
                 # Second path is absolute
@@ -142,7 +132,7 @@ def join(path, *paths):
             result_path = result_path + p_path
         ## add separator between UNC and non-absolute path
         if (result_path and not result_root and
-            result_drive and result_drive[-1:] not in colon + seps):
+            result_drive and result_drive[-1] not in colon_seps):
             return result_drive + sep + result_path
         return result_drive + result_root + result_path
     except (TypeError, AttributeError, BytesWarning):
@@ -176,56 +166,52 @@ def splitdrive(p):
     return drive, root + tail
 
 
-def splitroot(p):
-    """Split a pathname into drive, root and tail. The drive is defined
-    exactly as in splitdrive(). On Windows, the root may be a single path
-    separator or an empty string. The tail contains anything after the root.
-    For example:
+try:
+    from nt import _path_splitroot_ex as splitroot
+except ImportError:
+    def splitroot(p):
+        """Split a pathname into drive, root and tail.
 
-        splitroot('//server/share/') == ('//server/share', '/', '')
-        splitroot('C:/Users/Barney') == ('C:', '/', 'Users/Barney')
-        splitroot('C:///spam///ham') == ('C:', '/', '//spam///ham')
-        splitroot('Windows/notepad') == ('', '', 'Windows/notepad')
-    """
-    p = os.fspath(p)
-    if isinstance(p, bytes):
-        sep = b'\\'
-        altsep = b'/'
-        colon = b':'
-        unc_prefix = b'\\\\?\\UNC\\'
-        empty = b''
-    else:
-        sep = '\\'
-        altsep = '/'
-        colon = ':'
-        unc_prefix = '\\\\?\\UNC\\'
-        empty = ''
-    normp = p.replace(altsep, sep)
-    if normp[:1] == sep:
-        if normp[1:2] == sep:
-            # UNC drives, e.g. \\server\share or \\?\UNC\server\share
-            # Device drives, e.g. \\.\device or \\?\device
-            start = 8 if normp[:8].upper() == unc_prefix else 2
-            index = normp.find(sep, start)
-            if index == -1:
-                return p, empty, empty
-            index2 = normp.find(sep, index + 1)
-            if index2 == -1:
-                return p, empty, empty
-            return p[:index2], p[index2:index2 + 1], p[index2 + 1:]
+        The tail contains anything after the root."""
+        p = os.fspath(p)
+        if isinstance(p, bytes):
+            sep = b'\\'
+            altsep = b'/'
+            colon = b':'
+            unc_prefix = b'\\\\?\\UNC\\'
+            empty = b''
         else:
-            # Relative path with root, e.g. \Windows
-            return empty, p[:1], p[1:]
-    elif normp[1:2] == colon:
-        if normp[2:3] == sep:
-            # Absolute drive-letter path, e.g. X:\Windows
-            return p[:2], p[2:3], p[3:]
+            sep = '\\'
+            altsep = '/'
+            colon = ':'
+            unc_prefix = '\\\\?\\UNC\\'
+            empty = ''
+        normp = p.replace(altsep, sep)
+        if normp[:1] == sep:
+            if normp[1:2] == sep:
+                # UNC drives, e.g. \\server\share or \\?\UNC\server\share
+                # Device drives, e.g. \\.\device or \\?\device
+                start = 8 if normp[:8].upper() == unc_prefix else 2
+                index = normp.find(sep, start)
+                if index == -1:
+                    return p, empty, empty
+                index2 = normp.find(sep, index + 1)
+                if index2 == -1:
+                    return p, empty, empty
+                return p[:index2], p[index2:index2 + 1], p[index2 + 1:]
+            else:
+                # Relative path with root, e.g. \Windows
+                return empty, p[:1], p[1:]
+        elif normp[1:2] == colon:
+            if normp[2:3] == sep:
+                # Absolute drive-letter path, e.g. X:\Windows
+                return p[:2], p[2:3], p[3:]
+            else:
+                # Relative path with drive, e.g. X:Windows
+                return p[:2], empty, p[2:]
         else:
-            # Relative path with drive, e.g. X:Windows
-            return p[:2], empty, p[2:]
-    else:
-        # Relative path, e.g. Windows
-        return empty, empty, p
+            # Relative path, e.g. Windows
+            return empty, empty, p
 
 
 # Split a path in head (everything up to the last '/') and tail (the
@@ -277,33 +263,6 @@ def dirname(p):
     return split(p)[0]
 
 
-# Is a path a junction?
-
-if hasattr(os.stat_result, 'st_reparse_tag'):
-    def isjunction(path):
-        """Test whether a path is a junction"""
-        try:
-            st = os.lstat(path)
-        except (OSError, ValueError, AttributeError):
-            return False
-        return bool(st.st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT)
-else:
-    def isjunction(path):
-        """Test whether a path is a junction"""
-        os.fspath(path)
-        return False
-
-
-# Being true for dangling symbolic links is also useful.
-
-def lexists(path):
-    """Test whether a path exists.  Returns True for broken symbolic links"""
-    try:
-        st = os.lstat(path)
-    except (OSError, ValueError):
-        return False
-    return True
-
 # Is a path a mount point?
 # Any drive letter root (eg c:\)
 # Any share UNC (eg \\server\share)
@@ -338,6 +297,40 @@ def ismount(path):
         return False
 
 
+_reserved_chars = frozenset(
+    {chr(i) for i in range(32)} |
+    {'"', '*', ':', '<', '>', '?', '|', '/', '\\'}
+)
+
+_reserved_names = frozenset(
+    {'CON', 'PRN', 'AUX', 'NUL', 'CONIN$', 'CONOUT$'} |
+    {f'COM{c}' for c in '123456789\xb9\xb2\xb3'} |
+    {f'LPT{c}' for c in '123456789\xb9\xb2\xb3'}
+)
+
+def isreserved(path):
+    """Return true if the pathname is reserved by the system."""
+    # Refer to "Naming Files, Paths, and Namespaces":
+    # https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file
+    path = os.fsdecode(splitroot(path)[2]).replace(altsep, sep)
+    return any(_isreservedname(name) for name in reversed(path.split(sep)))
+
+def _isreservedname(name):
+    """Return true if the filename is reserved by the system."""
+    # Trailing dots and spaces are reserved.
+    if name[-1:] in ('.', ' '):
+        return name not in ('.', '..')
+    # Wildcards, separators, colon, and pipe (*?"<>/\:|) are reserved.
+    # ASCII control characters (0-31) are reserved.
+    # Colon is reserved for file streams (e.g. "name:stream[:type]").
+    if _reserved_chars.intersection(name):
+        return True
+    # DOS device names are reserved (e.g. "nul" or "nul .txt"). The rules
+    # are complex and vary across Windows versions. On the side of
+    # caution, return True for names that may not be reserved.
+    return name.partition('.')[0].rstrip(' ').upper() in _reserved_names
+
+
 # Expand paths beginning with '~' or '~user'.
 # '~' means $HOME; '~user' means that user's home directory.
 # If the path doesn't begin with '~', or if the user or $HOME is unknown,
@@ -353,24 +346,23 @@ def expanduser(path):
     If user or $HOME is unknown, do nothing."""
     path = os.fspath(path)
     if isinstance(path, bytes):
+        seps = b'\\/'
         tilde = b'~'
     else:
+        seps = '\\/'
         tilde = '~'
     if not path.startswith(tilde):
         return path
     i, n = 1, len(path)
-    while i < n and path[i] not in _get_bothseps(path):
+    while i < n and path[i] not in seps:
         i += 1
 
     if 'USERPROFILE' in os.environ:
         userhome = os.environ['USERPROFILE']
-    elif not 'HOMEPATH' in os.environ:
+    elif 'HOMEPATH' not in os.environ:
         return path
     else:
-        try:
-            drive = os.environ['HOMEDRIVE']
-        except KeyError:
-            drive = ''
+        drive = os.environ.get('HOMEDRIVE', '')
         userhome = join(drive, os.environ['HOMEPATH'])
 
     if i != 1: #~user
@@ -521,7 +513,7 @@ def expandvars(path):
 # Previously, this function also truncated pathnames to 8+3 format,
 # but as this module is called "ntpath", that's obviously wrong!
 try:
-    from nt import _path_normpath
+    from nt import _path_normpath as normpath
 
 except ImportError:
     def normpath(path):
@@ -560,37 +552,22 @@ def normpath(path):
             comps.append(curdir)
         return prefix + sep.join(comps)
 
-else:
-    def normpath(path):
-        """Normalize path, eliminating double slashes, etc."""
-        path = os.fspath(path)
-        if isinstance(path, bytes):
-            return os.fsencode(_path_normpath(os.fsdecode(path))) or b"."
-        return _path_normpath(path) or "."
-
-
-def _abspath_fallback(path):
-    """Return the absolute version of a path as a fallback function in case
-    `nt._getfullpathname` is not available or raises OSError. See bpo-31047 for
-    more.
-
-    """
-
-    path = os.fspath(path)
-    if not isabs(path):
-        if isinstance(path, bytes):
-            cwd = os.getcwdb()
-        else:
-            cwd = os.getcwd()
-        path = join(cwd, path)
-    return normpath(path)
 
 # Return an absolute path.
 try:
     from nt import _getfullpathname
 
 except ImportError: # not running on Windows - mock up something sensible
-    abspath = _abspath_fallback
+    def abspath(path):
+        """Return the absolute version of a path."""
+        path = os.fspath(path)
+        if not isabs(path):
+            if isinstance(path, bytes):
+                cwd = os.getcwdb()
+            else:
+                cwd = os.getcwd()
+            path = join(cwd, path)
+        return normpath(path)
 
 else:  # use native Windows method on Windows
     def abspath(path):
@@ -598,15 +575,36 @@ def abspath(path):
         try:
             return _getfullpathname(normpath(path))
         except (OSError, ValueError):
-            return _abspath_fallback(path)
+            # See gh-75230, handle outside for cleaner traceback
+            pass
+        path = os.fspath(path)
+        if not isabs(path):
+            if isinstance(path, bytes):
+                sep = b'\\'
+                getcwd = os.getcwdb
+            else:
+                sep = '\\'
+                getcwd = os.getcwd
+            drive, root, path = splitroot(path)
+            # Either drive or root can be nonempty, but not both.
+            if drive or root:
+                try:
+                    path = join(_getfullpathname(drive + root), path)
+                except (OSError, ValueError):
+                    # Drive "\0:" cannot exist; use the root directory.
+                    path = drive + sep + path
+            else:
+                path = join(getcwd(), path)
+        return normpath(path)
 
 try:
-    from nt import _getfinalpathname, readlink as _nt_readlink
+    from nt import _findfirstfile, _getfinalpathname, readlink as _nt_readlink
 except ImportError:
     # realpath is a no-op on systems without _getfinalpathname support.
-    realpath = abspath
+    def realpath(path, *, strict=False):
+        return abspath(path)
 else:
-    def _readlink_deep(path):
+    def _readlink_deep(path, ignored_error=OSError):
         # These error codes indicate that we should stop reading links and
         # return the path we currently have.
         # 1: ERROR_INVALID_FUNCTION
@@ -639,7 +637,7 @@ def _readlink_deep(path):
                         path = old_path
                         break
                     path = normpath(join(dirname(old_path), path))
-            except OSError as ex:
+            except ignored_error as ex:
                 if ex.winerror in allowed_winerror:
                     break
                 raise
@@ -648,7 +646,7 @@ def _readlink_deep(path):
                 break
         return path
 
-    def _getfinalpathname_nonstrict(path):
+    def _getfinalpathname_nonstrict(path, ignored_error=OSError):
         # These error codes indicate that we should stop resolving the path
         # and return the value we currently have.
         # 1: ERROR_INVALID_FUNCTION
@@ -664,9 +662,10 @@ def _getfinalpathname_nonstrict(path):
         # 87: ERROR_INVALID_PARAMETER
         # 123: ERROR_INVALID_NAME
         # 161: ERROR_BAD_PATHNAME
+        # 1005: ERROR_UNRECOGNIZED_VOLUME
         # 1920: ERROR_CANT_ACCESS_FILE
         # 1921: ERROR_CANT_RESOLVE_FILENAME (implies unfollowable symlink)
-        allowed_winerror = 1, 2, 3, 5, 21, 32, 50, 53, 65, 67, 87, 123, 161, 1920, 1921
+        allowed_winerror = 1, 2, 3, 5, 21, 32, 50, 53, 65, 67, 87, 123, 161, 1005, 1920, 1921
 
         # Non-strict algorithm is to find as much of the target directory
         # as we can and join the rest.
@@ -675,23 +674,29 @@ def _getfinalpathname_nonstrict(path):
             try:
                 path = _getfinalpathname(path)
                 return join(path, tail) if tail else path
-            except OSError as ex:
+            except ignored_error as ex:
                 if ex.winerror not in allowed_winerror:
                     raise
                 try:
                     # The OS could not resolve this path fully, so we attempt
                     # to follow the link ourselves. If we succeed, join the tail
                     # and return.
-                    new_path = _readlink_deep(path)
+                    new_path = _readlink_deep(path,
+                                              ignored_error=ignored_error)
                     if new_path != path:
                         return join(new_path, tail) if tail else new_path
-                except OSError:
+                except ignored_error:
                     # If we fail to readlink(), let's keep traversing
                     pass
-                path, name = split(path)
-                # TODO (bpo-38186): Request the real file name from the directory
-                # entry using FindFirstFileW. For now, we will return the path
-                # as best we have it
+                # If we get these errors, try to get the real name of the file without accessing it.
+                if ex.winerror in (1, 5, 32, 50, 87, 1920, 1921):
+                    try:
+                        name = _findfirstfile(path)
+                        path, _ = split(path)
+                    except ignored_error:
+                        path, name = split(path)
+                else:
+                    path, name = split(path)
                 if path and not name:
                     return path + tail
                 tail = join(name, tail) if tail else name
@@ -705,7 +710,8 @@ def realpath(path, *, strict=False):
             new_unc_prefix = b'\\\\'
             cwd = os.getcwdb()
             # bpo-38081: Special case for realpath(b'nul')
-            if normcase(path) == normcase(os.fsencode(devnull)):
+            devnull = b'nul'
+            if normcase(path) == devnull:
                 return b'\\\\.\\NUL'
         else:
             prefix = '\\\\?\\'
@@ -713,9 +719,19 @@ def realpath(path, *, strict=False):
             new_unc_prefix = '\\\\'
             cwd = os.getcwd()
             # bpo-38081: Special case for realpath('nul')
-            if normcase(path) == normcase(devnull):
+            devnull = 'nul'
+            if normcase(path) == devnull:
                 return '\\\\.\\NUL'
         had_prefix = path.startswith(prefix)
+
+        if strict is ALLOW_MISSING:
+            ignored_error = FileNotFoundError
+            strict = True
+        elif strict:
+            ignored_error = ()
+        else:
+            ignored_error = OSError
+
         if not had_prefix and not isabs(path):
             path = join(cwd, path)
         try:
@@ -723,17 +739,16 @@ def realpath(path, *, strict=False):
             initial_winerror = 0
         except ValueError as ex:
             # gh-106242: Raised for embedded null characters
-            # In strict mode, we convert into an OSError.
+            # In strict modes, we convert into an OSError.
             # Non-strict mode returns the path as-is, since we've already
             # made it absolute.
             if strict:
                 raise OSError(str(ex)) from None
             path = normpath(path)
-        except OSError as ex:
-            if strict:
-                raise
+        except ignored_error as ex:
             initial_winerror = ex.winerror
-            path = _getfinalpathname_nonstrict(path)
+            path = _getfinalpathname_nonstrict(path,
+                                               ignored_error=ignored_error)
         # The path returned by _getfinalpathname will always start with \\?\ -
         # strip off that prefix unless it was already provided on the original
         # path.
@@ -766,6 +781,9 @@ def realpath(path, *, strict=False):
 def relpath(path, start=None):
     """Return a relative version of a path"""
     path = os.fspath(path)
+    if not path:
+        raise ValueError("no path specified")
+
     if isinstance(path, bytes):
         sep = b'\\'
         curdir = b'.'
@@ -777,22 +795,20 @@ def relpath(path, start=None):
 
     if start is None:
         start = curdir
+    else:
+        start = os.fspath(start)
 
-    if not path:
-        raise ValueError("no path specified")
-
-    start = os.fspath(start)
     try:
-        start_abs = abspath(normpath(start))
-        path_abs = abspath(normpath(path))
+        start_abs = abspath(start)
+        path_abs = abspath(path)
         start_drive, _, start_rest = splitroot(start_abs)
         path_drive, _, path_rest = splitroot(path_abs)
         if normcase(start_drive) != normcase(path_drive):
             raise ValueError("path is on mount %r, start on mount %r" % (
                 path_drive, start_drive))
 
-        start_list = [x for x in start_rest.split(sep) if x]
-        path_list = [x for x in path_rest.split(sep) if x]
+        start_list = start_rest.split(sep) if start_rest else []
+        path_list = path_rest.split(sep) if path_rest else []
         # Work out how much of the filepath is shared by start and path.
         i = 0
         for e1, e2 in zip(start_list, path_list):
@@ -803,29 +819,28 @@ def relpath(path, start=None):
         rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
         if not rel_list:
             return curdir
-        return join(*rel_list)
+        return sep.join(rel_list)
     except (TypeError, ValueError, AttributeError, BytesWarning, DeprecationWarning):
         genericpath._check_arg_types('relpath', path, start)
         raise
 
 
-# Return the longest common sub-path of the sequence of paths given as input.
+# Return the longest common sub-path of the iterable of paths given as input.
 # The function is case-insensitive and 'separator-insensitive', i.e. if the
 # only difference between two paths is the use of '\' versus '/' as separator,
 # they are deemed to be equal.
 #
 # However, the returned path will have the standard '\' separator (even if the
 # given paths had the alternative '/' separator) and will have the case of the
-# first path given in the sequence. Additionally, any trailing separator is
+# first path given in the iterable. Additionally, any trailing separator is
 # stripped from the returned path.
 
 def commonpath(paths):
-    """Given a sequence of path names, returns the longest common sub-path."""
-
+    """Given an iterable of path names, returns the longest common sub-path."""
+    paths = tuple(map(os.fspath, paths))
     if not paths:
-        raise ValueError('commonpath() arg is an empty sequence')
+        raise ValueError('commonpath() arg is an empty iterable')
 
-    paths = tuple(map(os.fspath, paths))
     if isinstance(paths[0], bytes):
         sep = b'\\'
         altsep = b'/'
@@ -839,9 +854,6 @@ def commonpath(paths):
         drivesplits = [splitroot(p.replace(altsep, sep).lower()) for p in paths]
         split_paths = [p.split(sep) for d, r, p in drivesplits]
 
-        if len({r for d, r, p in drivesplits}) != 1:
-            raise ValueError("Can't mix absolute and relative paths")
-
         # Check that all drive letters or UNC paths match. The check is made only
         # now otherwise type errors for mixing strings and bytes would not be
         # caught.
@@ -849,6 +861,12 @@ def commonpath(paths):
             raise ValueError("Paths don't have the same drive")
 
         drive, root, path = splitroot(paths[0].replace(altsep, sep))
+        if len({r for d, r, p in drivesplits}) != 1:
+            if drive:
+                raise ValueError("Can't mix absolute and relative paths")
+            else:
+                raise ValueError("Can't mix rooted and not-rooted paths")
+
         common = path.split(sep)
         common = [c for c in common if c and c != curdir]
 
@@ -869,13 +887,15 @@ def commonpath(paths):
 
 
 try:
-    # The isdir(), isfile(), islink() and exists() implementations in
-    # genericpath use os.stat(). This is overkill on Windows. Use simpler
+    # The isdir(), isfile(), islink(), exists() and lexists() implementations
+    # in genericpath use os.stat(). This is overkill on Windows. Use simpler
     # builtin functions if they are available.
     from nt import _path_isdir as isdir
     from nt import _path_isfile as isfile
     from nt import _path_islink as islink
+    from nt import _path_isjunction as isjunction
     from nt import _path_exists as exists
+    from nt import _path_lexists as lexists
 except ImportError:
     # Use genericpath.* as imported above
     pass
@@ -883,15 +903,12 @@ def commonpath(paths):
 
 try:
     from nt import _path_isdevdrive
-except ImportError:
-    def isdevdrive(path):
-        """Determines whether the specified path is on a Windows Dev Drive."""
-        # Never a Dev Drive
-        return False
-else:
     def isdevdrive(path):
         """Determines whether the specified path is on a Windows Dev Drive."""
         try:
             return _path_isdevdrive(abspath(path))
         except OSError:
             return False
+except ImportError:
+    # Use genericpath.isdevdrive as imported above
+    pass
diff --git a/Lib/nturl2path.py b/Lib/nturl2path.py
index 61852aff58..757fd01bec 100644
--- a/Lib/nturl2path.py
+++ b/Lib/nturl2path.py
@@ -15,32 +15,29 @@ def url2pathname(url):
     # become
     #   C:\foo\bar\spam.foo
     import string, urllib.parse
+    if url[:3] == '///':
+        # URL has an empty authority section, so the path begins on the third
+        # character.
+        url = url[2:]
+    elif url[:12] == '//localhost/':
+        # Skip past 'localhost' authority.
+        url = url[11:]
+    if url[:3] == '///':
+        # Skip past extra slash before UNC drive in URL path.
+        url = url[1:]
     # Windows itself uses ":" even in URLs.
     url = url.replace(':', '|')
     if not '|' in url:
         # No drive specifier, just convert slashes
-        if url[:4] == '////':
-            # path is something like ////host/path/on/remote/host
-            # convert this to \\host\path\on\remote\host
-            # (notice halving of slashes at the start of the path)
-            url = url[2:]
-        components = url.split('/')
         # make sure not to convert quoted slashes :-)
-        return urllib.parse.unquote('\\'.join(components))
+        return urllib.parse.unquote(url.replace('/', '\\'))
     comp = url.split('|')
     if len(comp) != 2 or comp[0][-1] not in string.ascii_letters:
         error = 'Bad URL: ' + url
         raise OSError(error)
     drive = comp[0][-1].upper()
-    components = comp[1].split('/')
-    path = drive + ':'
-    for comp in components:
-        if comp:
-            path = path + '\\' + urllib.parse.unquote(comp)
-    # Issue #11474 - handing url such as |c/|
-    if path.endswith(':') and url.endswith('/'):
-        path += '\\'
-    return path
+    tail = urllib.parse.unquote(comp[1].replace('/', '\\'))
+    return drive + ':' + tail
 
 def pathname2url(p):
     """OS-specific conversion from a file system path to a relative URL
@@ -52,30 +49,21 @@ def pathname2url(p):
     import urllib.parse
     # First, clean up some special forms. We are going to sacrifice
     # the additional information anyway
-    if p[:4] == '\\\\?\\':
+    p = p.replace('\\', '/')
+    if p[:4] == '//?/':
         p = p[4:]
-        if p[:4].upper() == 'UNC\\':
-            p = '\\' + p[4:]
+        if p[:4].upper() == 'UNC/':
+            p = '//' + p[4:]
         elif p[1:2] != ':':
             raise OSError('Bad path: ' + p)
     if not ':' in p:
-        # No drive specifier, just convert slashes and quote the name
-        if p[:2] == '\\\\':
-        # path is something like \\host\path\on\remote\host
-        # convert this to ////host/path/on/remote/host
-        # (notice doubling of slashes at the start of the path)
-            p = '\\\\' + p
-        components = p.split('\\')
-        return urllib.parse.quote('/'.join(components))
+        # No DOS drive specified, just quote the pathname
+        return urllib.parse.quote(p)
     comp = p.split(':', maxsplit=2)
     if len(comp) != 2 or len(comp[0]) > 1:
         error = 'Bad path: ' + p
         raise OSError(error)
 
     drive = urllib.parse.quote(comp[0].upper())
-    components = comp[1].split('\\')
-    path = '///' + drive + ':'
-    for comp in components:
-        if comp:
-            path = path + '/' + urllib.parse.quote(comp)
-    return path
+    tail = urllib.parse.quote(comp[1])
+    return '///' + drive + ':' + tail
diff --git a/Lib/numbers.py b/Lib/numbers.py
index a2913e32cf..37fddb8917 100644
--- a/Lib/numbers.py
+++ b/Lib/numbers.py
@@ -290,18 +290,27 @@ def conjugate(self):
 
 
 class Rational(Real):
-    """.numerator and .denominator should be in lowest terms."""
+    """To Real, Rational adds numerator and denominator properties.
+
+    The numerator and denominator values should be in lowest terms,
+    with a positive denominator.
+    """
 
     __slots__ = ()
 
     @property
     @abstractmethod
     def numerator(self):
+        """The numerator of a rational number in lowest terms."""
         raise NotImplementedError
 
     @property
     @abstractmethod
     def denominator(self):
+        """The denominator of a rational number in lowest terms.
+
+        This denominator should be positive.
+        """
         raise NotImplementedError
 
     # Concrete implementation of Real's conversion to float.
diff --git a/Lib/opcode.py b/Lib/opcode.py
index ab6b765b4b..5735686fa7 100644
--- a/Lib/opcode.py
+++ b/Lib/opcode.py
@@ -4,404 +4,47 @@
 operate on bytecodes (e.g. peephole optimizers).
 """
 
-__all__ = ["cmp_op", "hasarg", "hasconst", "hasname", "hasjrel", "hasjabs",
-           "haslocal", "hascompare", "hasfree", "hasexc", "opname", "opmap",
-           "HAVE_ARGUMENT", "EXTENDED_ARG"]
 
-# It's a chicken-and-egg I'm afraid:
-# We're imported before _opcode's made.
-# With exception unheeded
-# (stack_effect is not needed)
-# Both our chickens and eggs are allayed.
-#     --Larry Hastings, 2013/11/23
+__all__ = ["cmp_op", "stack_effect", "hascompare", "opname", "opmap",
+           "HAVE_ARGUMENT", "EXTENDED_ARG", "hasarg", "hasconst", "hasname",
+           "hasjump", "hasjrel", "hasjabs", "hasfree", "haslocal", "hasexc"]
 
-try:
-    from _opcode import stack_effect
-    __all__.append('stack_effect')
-except ImportError:
-    pass
+import _opcode
+from _opcode import stack_effect
 
-cmp_op = ('<', '<=', '==', '!=', '>', '>=')
-
-hasarg = []
-hasconst = []
-hasname = []
-hasjrel = []
-hasjabs = []
-haslocal = []
-hascompare = []
-hasfree = []
-hasexc = []
-
-def is_pseudo(op):
-    return op >= MIN_PSEUDO_OPCODE and op <= MAX_PSEUDO_OPCODE
-
-oplists = [hasarg, hasconst, hasname, hasjrel, hasjabs,
-           haslocal, hascompare, hasfree, hasexc]
-
-opmap = {}
-
-## pseudo opcodes (used in the compiler) mapped to the values
-## they can become in the actual code.
-_pseudo_ops = {}
-
-def def_op(name, op):
-    opmap[name] = op
-
-def name_op(name, op):
-    def_op(name, op)
-    hasname.append(op)
-
-def jrel_op(name, op):
-    def_op(name, op)
-    hasjrel.append(op)
-
-def jabs_op(name, op):
-    def_op(name, op)
-    hasjabs.append(op)
-
-def pseudo_op(name, op, real_ops):
-    def_op(name, op)
-    _pseudo_ops[name] = real_ops
-    # add the pseudo opcode to the lists its targets are in
-    for oplist in oplists:
-        res = [opmap[rop] in oplist for rop in real_ops]
-        if any(res):
-            assert all(res)
-            oplist.append(op)
-
-
-# Instruction opcodes for compiled code
-# Blank lines correspond to available opcodes
-
-def_op('CACHE', 0)
-def_op('POP_TOP', 1)
-def_op('PUSH_NULL', 2)
-
-def_op('NOP', 9)
-def_op('UNARY_POSITIVE', 10)
-def_op('UNARY_NEGATIVE', 11)
-def_op('UNARY_NOT', 12)
-
-def_op('UNARY_INVERT', 15)
-
-def_op('BINARY_SUBSCR', 25)
-def_op('BINARY_SLICE', 26)
-def_op('STORE_SLICE', 27)
-
-def_op('GET_LEN', 30)
-def_op('MATCH_MAPPING', 31)
-def_op('MATCH_SEQUENCE', 32)
-def_op('MATCH_KEYS', 33)
-
-def_op('PUSH_EXC_INFO', 35)
-def_op('CHECK_EXC_MATCH', 36)
-def_op('CHECK_EG_MATCH', 37)
-
-def_op('WITH_EXCEPT_START', 49)
-def_op('GET_AITER', 50)
-def_op('GET_ANEXT', 51)
-def_op('BEFORE_ASYNC_WITH', 52)
-def_op('BEFORE_WITH', 53)
-def_op('END_ASYNC_FOR', 54)
-def_op('CLEANUP_THROW', 55)
-
-def_op('STORE_SUBSCR', 60)
-def_op('DELETE_SUBSCR', 61)
-
-# TODO: RUSTPYTHON
-# Delete below def_op after updating coroutines.py
-def_op('YIELD_FROM', 72)
-
-def_op('GET_ITER', 68)
-def_op('GET_YIELD_FROM_ITER', 69)
-def_op('PRINT_EXPR', 70)
-def_op('LOAD_BUILD_CLASS', 71)
-
-def_op('LOAD_ASSERTION_ERROR', 74)
-def_op('RETURN_GENERATOR', 75)
-
-def_op('LIST_TO_TUPLE', 82)
-def_op('RETURN_VALUE', 83)
-def_op('IMPORT_STAR', 84)
-def_op('SETUP_ANNOTATIONS', 85)
-
-def_op('ASYNC_GEN_WRAP', 87)
-def_op('PREP_RERAISE_STAR', 88)
-def_op('POP_EXCEPT', 89)
-
-HAVE_ARGUMENT = 90             # real opcodes from here have an argument:
-
-name_op('STORE_NAME', 90)       # Index in name list
-name_op('DELETE_NAME', 91)      # ""
-def_op('UNPACK_SEQUENCE', 92)   # Number of tuple items
-jrel_op('FOR_ITER', 93)
-def_op('UNPACK_EX', 94)
-name_op('STORE_ATTR', 95)       # Index in name list
-name_op('DELETE_ATTR', 96)      # ""
-name_op('STORE_GLOBAL', 97)     # ""
-name_op('DELETE_GLOBAL', 98)    # ""
-def_op('SWAP', 99)
-def_op('LOAD_CONST', 100)       # Index in const list
-hasconst.append(100)
-name_op('LOAD_NAME', 101)       # Index in name list
-def_op('BUILD_TUPLE', 102)      # Number of tuple items
-def_op('BUILD_LIST', 103)       # Number of list items
-def_op('BUILD_SET', 104)        # Number of set items
-def_op('BUILD_MAP', 105)        # Number of dict entries
-name_op('LOAD_ATTR', 106)       # Index in name list
-def_op('COMPARE_OP', 107)       # Comparison operator
-hascompare.append(107)
-name_op('IMPORT_NAME', 108)     # Index in name list
-name_op('IMPORT_FROM', 109)     # Index in name list
-jrel_op('JUMP_FORWARD', 110)    # Number of words to skip
-jrel_op('JUMP_IF_FALSE_OR_POP', 111) # Number of words to skip
-jrel_op('JUMP_IF_TRUE_OR_POP', 112)  # ""
-jrel_op('POP_JUMP_IF_FALSE', 114)
-jrel_op('POP_JUMP_IF_TRUE', 115)
-name_op('LOAD_GLOBAL', 116)     # Index in name list
-def_op('IS_OP', 117)
-def_op('CONTAINS_OP', 118)
-def_op('RERAISE', 119)
-def_op('COPY', 120)
-def_op('BINARY_OP', 122)
-jrel_op('SEND', 123) # Number of bytes to skip
-def_op('LOAD_FAST', 124)        # Local variable number, no null check
-haslocal.append(124)
-def_op('STORE_FAST', 125)       # Local variable number
-haslocal.append(125)
-def_op('DELETE_FAST', 126)      # Local variable number
-haslocal.append(126)
-def_op('LOAD_FAST_CHECK', 127)  # Local variable number
-haslocal.append(127)
-jrel_op('POP_JUMP_IF_NOT_NONE', 128)
-jrel_op('POP_JUMP_IF_NONE', 129)
-def_op('RAISE_VARARGS', 130)    # Number of raise arguments (1, 2, or 3)
-def_op('GET_AWAITABLE', 131)
-def_op('MAKE_FUNCTION', 132)    # Flags
-def_op('BUILD_SLICE', 133)      # Number of items
-jrel_op('JUMP_BACKWARD_NO_INTERRUPT', 134) # Number of words to skip (backwards)
-def_op('MAKE_CELL', 135)
-hasfree.append(135)
-def_op('LOAD_CLOSURE', 136)
-hasfree.append(136)
-def_op('LOAD_DEREF', 137)
-hasfree.append(137)
-def_op('STORE_DEREF', 138)
-hasfree.append(138)
-def_op('DELETE_DEREF', 139)
-hasfree.append(139)
-jrel_op('JUMP_BACKWARD', 140)    # Number of words to skip (backwards)
-
-def_op('CALL_FUNCTION_EX', 142)  # Flags
-
-def_op('EXTENDED_ARG', 144)
-EXTENDED_ARG = 144
-def_op('LIST_APPEND', 145)
-def_op('SET_ADD', 146)
-def_op('MAP_ADD', 147)
-def_op('LOAD_CLASSDEREF', 148)
-hasfree.append(148)
-def_op('COPY_FREE_VARS', 149)
-def_op('YIELD_VALUE', 150)
-def_op('RESUME', 151)   # This must be kept in sync with deepfreeze.py
-def_op('MATCH_CLASS', 152)
-
-def_op('FORMAT_VALUE', 155)
-def_op('BUILD_CONST_KEY_MAP', 156)
-def_op('BUILD_STRING', 157)
-
-def_op('LIST_EXTEND', 162)
-def_op('SET_UPDATE', 163)
-def_op('DICT_MERGE', 164)
-def_op('DICT_UPDATE', 165)
-
-def_op('CALL', 171)
-def_op('KW_NAMES', 172)
-hasconst.append(172)
+from _opcode_metadata import (_specializations, _specialized_opmap, opmap,
+                              HAVE_ARGUMENT, MIN_INSTRUMENTED_OPCODE)
+EXTENDED_ARG = opmap['EXTENDED_ARG']
 
-
-hasarg.extend([op for op in opmap.values() if op >= HAVE_ARGUMENT])
-
-MIN_PSEUDO_OPCODE = 256
-
-pseudo_op('SETUP_FINALLY', 256, ['NOP'])
-hasexc.append(256)
-pseudo_op('SETUP_CLEANUP', 257, ['NOP'])
-hasexc.append(257)
-pseudo_op('SETUP_WITH', 258, ['NOP'])
-hasexc.append(258)
-pseudo_op('POP_BLOCK', 259, ['NOP'])
-
-pseudo_op('JUMP', 260, ['JUMP_FORWARD', 'JUMP_BACKWARD'])
-pseudo_op('JUMP_NO_INTERRUPT', 261, ['JUMP_FORWARD', 'JUMP_BACKWARD_NO_INTERRUPT'])
-
-pseudo_op('LOAD_METHOD', 262, ['LOAD_ATTR'])
-
-MAX_PSEUDO_OPCODE = MIN_PSEUDO_OPCODE + len(_pseudo_ops) - 1
-
-del def_op, name_op, jrel_op, jabs_op, pseudo_op
-
-opname = ['<%r>' % (op,) for op in range(MAX_PSEUDO_OPCODE + 1)]
+opname = ['<%r>' % (op,) for op in range(max(opmap.values()) + 1)]
 for op, i in opmap.items():
     opname[i] = op
 
+cmp_op = ('<', '<=', '==', '!=', '>', '>=')
 
-_nb_ops = [
-    ("NB_ADD", "+"),
-    ("NB_AND", "&"),
-    ("NB_FLOOR_DIVIDE", "//"),
-    ("NB_LSHIFT", "<<"),
-    ("NB_MATRIX_MULTIPLY", "@"),
-    ("NB_MULTIPLY", "*"),
-    ("NB_REMAINDER", "%"),
-    ("NB_OR", "|"),
-    ("NB_POWER", "**"),
-    ("NB_RSHIFT", ">>"),
-    ("NB_SUBTRACT", "-"),
-    ("NB_TRUE_DIVIDE", "/"),
-    ("NB_XOR", "^"),
-    ("NB_INPLACE_ADD", "+="),
-    ("NB_INPLACE_AND", "&="),
-    ("NB_INPLACE_FLOOR_DIVIDE", "//="),
-    ("NB_INPLACE_LSHIFT", "<<="),
-    ("NB_INPLACE_MATRIX_MULTIPLY", "@="),
-    ("NB_INPLACE_MULTIPLY", "*="),
-    ("NB_INPLACE_REMAINDER", "%="),
-    ("NB_INPLACE_OR", "|="),
-    ("NB_INPLACE_POWER", "**="),
-    ("NB_INPLACE_RSHIFT", ">>="),
-    ("NB_INPLACE_SUBTRACT", "-="),
-    ("NB_INPLACE_TRUE_DIVIDE", "/="),
-    ("NB_INPLACE_XOR", "^="),
-]
+# These lists are documented as part of the dis module's API
+hasarg = [op for op in opmap.values() if _opcode.has_arg(op)]
+hasconst = [op for op in opmap.values() if _opcode.has_const(op)]
+hasname = [op for op in opmap.values() if _opcode.has_name(op)]
+hasjump = [op for op in opmap.values() if _opcode.has_jump(op)]
+hasjrel = hasjump  # for backward compatibility
+hasjabs = []
+hasfree = [op for op in opmap.values() if _opcode.has_free(op)]
+haslocal = [op for op in opmap.values() if _opcode.has_local(op)]
+hasexc = [op for op in opmap.values() if _opcode.has_exc(op)]
 
-_specializations = {
-    "BINARY_OP": [
-        "BINARY_OP_ADAPTIVE",
-        "BINARY_OP_ADD_FLOAT",
-        "BINARY_OP_ADD_INT",
-        "BINARY_OP_ADD_UNICODE",
-        "BINARY_OP_INPLACE_ADD_UNICODE",
-        "BINARY_OP_MULTIPLY_FLOAT",
-        "BINARY_OP_MULTIPLY_INT",
-        "BINARY_OP_SUBTRACT_FLOAT",
-        "BINARY_OP_SUBTRACT_INT",
-    ],
-    "BINARY_SUBSCR": [
-        "BINARY_SUBSCR_ADAPTIVE",
-        "BINARY_SUBSCR_DICT",
-        "BINARY_SUBSCR_GETITEM",
-        "BINARY_SUBSCR_LIST_INT",
-        "BINARY_SUBSCR_TUPLE_INT",
-    ],
-    "CALL": [
-        "CALL_ADAPTIVE",
-        "CALL_PY_EXACT_ARGS",
-        "CALL_PY_WITH_DEFAULTS",
-        "CALL_BOUND_METHOD_EXACT_ARGS",
-        "CALL_BUILTIN_CLASS",
-        "CALL_BUILTIN_FAST_WITH_KEYWORDS",
-        "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS",
-        "CALL_NO_KW_BUILTIN_FAST",
-        "CALL_NO_KW_BUILTIN_O",
-        "CALL_NO_KW_ISINSTANCE",
-        "CALL_NO_KW_LEN",
-        "CALL_NO_KW_LIST_APPEND",
-        "CALL_NO_KW_METHOD_DESCRIPTOR_FAST",
-        "CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS",
-        "CALL_NO_KW_METHOD_DESCRIPTOR_O",
-        "CALL_NO_KW_STR_1",
-        "CALL_NO_KW_TUPLE_1",
-        "CALL_NO_KW_TYPE_1",
-    ],
-    "COMPARE_OP": [
-        "COMPARE_OP_ADAPTIVE",
-        "COMPARE_OP_FLOAT_JUMP",
-        "COMPARE_OP_INT_JUMP",
-        "COMPARE_OP_STR_JUMP",
-    ],
-    "EXTENDED_ARG": [
-        "EXTENDED_ARG_QUICK",
-    ],
-    "FOR_ITER": [
-        "FOR_ITER_ADAPTIVE",
-        "FOR_ITER_LIST",
-        "FOR_ITER_RANGE",
-    ],
-    "JUMP_BACKWARD": [
-        "JUMP_BACKWARD_QUICK",
-    ],
-    "LOAD_ATTR": [
-        "LOAD_ATTR_ADAPTIVE",
-        # These potentially push [NULL, bound method] onto the stack.
-        "LOAD_ATTR_CLASS",
-        "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN",
-        "LOAD_ATTR_INSTANCE_VALUE",
-        "LOAD_ATTR_MODULE",
-        "LOAD_ATTR_PROPERTY",
-        "LOAD_ATTR_SLOT",
-        "LOAD_ATTR_WITH_HINT",
-        # These will always push [unbound method, self] onto the stack.
-        "LOAD_ATTR_METHOD_LAZY_DICT",
-        "LOAD_ATTR_METHOD_NO_DICT",
-        "LOAD_ATTR_METHOD_WITH_DICT",
-        "LOAD_ATTR_METHOD_WITH_VALUES",
-    ],
-    "LOAD_CONST": [
-        "LOAD_CONST__LOAD_FAST",
-    ],
-    "LOAD_FAST": [
-        "LOAD_FAST__LOAD_CONST",
-        "LOAD_FAST__LOAD_FAST",
-    ],
-    "LOAD_GLOBAL": [
-        "LOAD_GLOBAL_ADAPTIVE",
-        "LOAD_GLOBAL_BUILTIN",
-        "LOAD_GLOBAL_MODULE",
-    ],
-    "RESUME": [
-        "RESUME_QUICK",
-    ],
-    "STORE_ATTR": [
-        "STORE_ATTR_ADAPTIVE",
-        "STORE_ATTR_INSTANCE_VALUE",
-        "STORE_ATTR_SLOT",
-        "STORE_ATTR_WITH_HINT",
-    ],
-    "STORE_FAST": [
-        "STORE_FAST__LOAD_FAST",
-        "STORE_FAST__STORE_FAST",
-    ],
-    "STORE_SUBSCR": [
-        "STORE_SUBSCR_ADAPTIVE",
-        "STORE_SUBSCR_DICT",
-        "STORE_SUBSCR_LIST_INT",
-    ],
-    "UNPACK_SEQUENCE": [
-        "UNPACK_SEQUENCE_ADAPTIVE",
-        "UNPACK_SEQUENCE_LIST",
-        "UNPACK_SEQUENCE_TUPLE",
-        "UNPACK_SEQUENCE_TWO_TUPLE",
-    ],
-}
-_specialized_instructions = [
-    opcode for family in _specializations.values() for opcode in family
-]
-_specialization_stats = [
-    "success",
-    "failure",
-    "hit",
-    "deferred",
-    "miss",
-    "deopt",
-]
+
+_intrinsic_1_descs = _opcode.get_intrinsic1_descs()
+_intrinsic_2_descs = _opcode.get_intrinsic2_descs()
+_nb_ops = _opcode.get_nb_ops()
+
+hascompare = [opmap["COMPARE_OP"]]
 
 _cache_format = {
     "LOAD_GLOBAL": {
         "counter": 1,
         "index": 1,
-        "module_keys_version": 2,
+        "module_keys_version": 1,
         "builtin_keys_version": 1,
     },
     "BINARY_OP": {
@@ -412,16 +55,19 @@ def pseudo_op(name, op, real_ops):
     },
     "COMPARE_OP": {
         "counter": 1,
-        "mask": 1,
+    },
+    "CONTAINS_OP": {
+        "counter": 1,
     },
     "BINARY_SUBSCR": {
         "counter": 1,
-        "type_version": 2,
-        "func_version": 1,
     },
     "FOR_ITER": {
         "counter": 1,
     },
+    "LOAD_SUPER_ATTR": {
+        "counter": 1,
+    },
     "LOAD_ATTR": {
         "counter": 1,
         "version": 2,
@@ -436,13 +82,34 @@ def pseudo_op(name, op, real_ops):
     "CALL": {
         "counter": 1,
         "func_version": 2,
-        "min_args": 1,
     },
     "STORE_SUBSCR": {
         "counter": 1,
     },
+    "SEND": {
+        "counter": 1,
+    },
+    "JUMP_BACKWARD": {
+        "counter": 1,
+    },
+    "TO_BOOL": {
+        "counter": 1,
+        "version": 2,
+    },
+    "POP_JUMP_IF_TRUE": {
+        "counter": 1,
+    },
+    "POP_JUMP_IF_FALSE": {
+        "counter": 1,
+    },
+    "POP_JUMP_IF_NONE": {
+        "counter": 1,
+    },
+    "POP_JUMP_IF_NOT_NONE": {
+        "counter": 1,
+    },
 }
 
-_inline_cache_entries = [
-    sum(_cache_format.get(opname[opcode], {}).values()) for opcode in range(256)
-]
+_inline_cache_entries = {
+    name : sum(value.values()) for (name, value) in _cache_format.items()
+}
diff --git a/Lib/operator.py b/Lib/operator.py
index 30116c1189..02ccdaa13d 100644
--- a/Lib/operator.py
+++ b/Lib/operator.py
@@ -239,7 +239,7 @@ class attrgetter:
     """
     __slots__ = ('_attrs', '_call')
 
-    def __init__(self, attr, *attrs):
+    def __init__(self, attr, /, *attrs):
         if not attrs:
             if not isinstance(attr, str):
                 raise TypeError('attribute name must be a string')
@@ -257,7 +257,7 @@ def func(obj):
                 return tuple(getter(obj) for getter in getters)
             self._call = func
 
-    def __call__(self, obj):
+    def __call__(self, obj, /):
         return self._call(obj)
 
     def __repr__(self):
@@ -276,7 +276,7 @@ class itemgetter:
     """
     __slots__ = ('_items', '_call')
 
-    def __init__(self, item, *items):
+    def __init__(self, item, /, *items):
         if not items:
             self._items = (item,)
             def func(obj):
@@ -288,7 +288,7 @@ def func(obj):
                 return tuple(obj[i] for i in items)
             self._call = func
 
-    def __call__(self, obj):
+    def __call__(self, obj, /):
         return self._call(obj)
 
     def __repr__(self):
@@ -315,7 +315,7 @@ def __init__(self, name, /, *args, **kwargs):
         self._args = args
         self._kwargs = kwargs
 
-    def __call__(self, obj):
+    def __call__(self, obj, /):
         return getattr(obj, self._name)(*self._args, **self._kwargs)
 
     def __repr__(self):
diff --git a/Lib/os.py b/Lib/os.py
index 7ee7d695d9..b4c9f84c36 100644
--- a/Lib/os.py
+++ b/Lib/os.py
@@ -110,6 +110,7 @@ def _add(str, fn):
     _add("HAVE_FCHMODAT",   "chmod")
     _add("HAVE_FCHOWNAT",   "chown")
     _add("HAVE_FSTATAT",    "stat")
+    _add("HAVE_LSTAT",      "lstat")
     _add("HAVE_FUTIMESAT",  "utime")
     _add("HAVE_LINKAT",     "link")
     _add("HAVE_MKDIRAT",    "mkdir")
@@ -131,6 +132,7 @@ def _add(str, fn):
     _set = set()
     _add("HAVE_FCHDIR",     "chdir")
     _add("HAVE_FCHMOD",     "chmod")
+    _add("MS_WINDOWS",      "chmod")
     _add("HAVE_FCHOWN",     "chown")
     _add("HAVE_FDOPENDIR",  "listdir")
     _add("HAVE_FDOPENDIR",  "scandir")
@@ -171,6 +173,7 @@ def _add(str, fn):
     _add("HAVE_FSTATAT",    "stat")
     _add("HAVE_LCHFLAGS",   "chflags")
     _add("HAVE_LCHMOD",     "chmod")
+    _add("MS_WINDOWS",      "chmod")
     if _exists("lchown"): # mac os x10.3
         _add("HAVE_LCHOWN", "chown")
     _add("HAVE_LINKAT",     "link")
@@ -279,6 +282,10 @@ def renames(old, new):
 
 __all__.extend(["makedirs", "removedirs", "renames"])
 
+# Private sentinel that makes walk() classify all symlinks and junctions as
+# regular files.
+_walk_symlinks_as_files = object()
+
 def walk(top, topdown=True, onerror=None, followlinks=False):
     """Directory tree generator.
 
@@ -331,12 +338,12 @@ def walk(top, topdown=True, onerror=None, followlinks=False):
 
     import os
     from os.path import join, getsize
-    for root, dirs, files in os.walk('python/Lib/email'):
+    for root, dirs, files in os.walk('python/Lib/xml'):
         print(root, "consumes ")
         print(sum(getsize(join(root, name)) for name in files), end=" ")
         print("bytes in", len(files), "non-directory files")
-        if 'CVS' in dirs:
-            dirs.remove('CVS')  # don't visit CVS directories
+        if '__pycache__' in dirs:
+            dirs.remove('__pycache__')  # don't visit __pycache__ directories
 
     """
     sys.audit("os.walk", top, topdown, onerror, followlinks)
@@ -380,7 +387,10 @@ def walk(top, topdown=True, onerror=None, followlinks=False):
                     break
 
                 try:
-                    is_dir = entry.is_dir()
+                    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().
@@ -459,34 +469,69 @@ def fwalk(top=".", topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=
         Example:
 
         import os
-        for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):
+        for root, dirs, files, rootfd in os.fwalk('python/Lib/xml'):
             print(root, "consumes", end="")
             print(sum(os.stat(name, dir_fd=rootfd).st_size for name in files),
                   end="")
             print("bytes in", len(files), "non-directory files")
-            if 'CVS' in dirs:
-                dirs.remove('CVS')  # don't visit CVS directories
+            if '__pycache__' in dirs:
+                dirs.remove('__pycache__')  # don't visit __pycache__ directories
         """
         sys.audit("os.fwalk", top, topdown, onerror, follow_symlinks, dir_fd)
         top = fspath(top)
-        # Note: To guard against symlink races, we use the standard
-        # lstat()/open()/fstat() trick.
-        if not follow_symlinks:
-            orig_st = stat(top, follow_symlinks=False, dir_fd=dir_fd)
-        topfd = open(top, O_RDONLY | O_NONBLOCK, dir_fd=dir_fd)
+        stack = [(_fwalk_walk, (True, dir_fd, top, top, None))]
+        isbytes = isinstance(top, bytes)
         try:
-            if (follow_symlinks or (st.S_ISDIR(orig_st.st_mode) and
-                                    path.samestat(orig_st, stat(topfd)))):
-                yield from _fwalk(topfd, top, isinstance(top, bytes),
-                                  topdown, onerror, follow_symlinks)
+            while stack:
+                yield from _fwalk(stack, isbytes, topdown, onerror, follow_symlinks)
         finally:
-            close(topfd)
-
-    def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks):
+            # Close any file descriptors still on the stack.
+            while stack:
+                action, value = stack.pop()
+                if action == _fwalk_close:
+                    close(value)
+
+    # Each item in the _fwalk() stack is a pair (action, args).
+    _fwalk_walk = 0  # args: (isroot, dirfd, toppath, topname, entry)
+    _fwalk_yield = 1  # args: (toppath, dirnames, filenames, topfd)
+    _fwalk_close = 2  # args: dirfd
+
+    def _fwalk(stack, isbytes, topdown, onerror, follow_symlinks):
         # Note: This uses O(depth of the directory tree) file descriptors: if
         # necessary, it can be adapted to only require O(1) FDs, see issue
         # #13734.
 
+        action, value = stack.pop()
+        if action == _fwalk_close:
+            close(value)
+            return
+        elif action == _fwalk_yield:
+            yield value
+            return
+        assert action == _fwalk_walk
+        isroot, dirfd, toppath, topname, entry = value
+        try:
+            if not follow_symlinks:
+                # Note: To guard against symlink races, we use the standard
+                # lstat()/open()/fstat() trick.
+                if entry is None:
+                    orig_st = stat(topname, follow_symlinks=False, dir_fd=dirfd)
+                else:
+                    orig_st = entry.stat(follow_symlinks=False)
+            topfd = open(topname, O_RDONLY | O_NONBLOCK, dir_fd=dirfd)
+        except OSError as err:
+            if isroot:
+                raise
+            if onerror is not None:
+                onerror(err)
+            return
+        stack.append((_fwalk_close, topfd))
+        if not follow_symlinks:
+            if isroot and not st.S_ISDIR(orig_st.st_mode):
+                return
+            if not path.samestat(orig_st, stat(topfd)):
+                return
+
         scandir_it = scandir(topfd)
         dirs = []
         nondirs = []
@@ -512,31 +557,18 @@ def _fwalk(topfd, toppath, isbytes, topdown, onerror, follow_symlinks):
 
         if topdown:
             yield toppath, dirs, nondirs, topfd
+        else:
+            stack.append((_fwalk_yield, (toppath, dirs, nondirs, topfd)))
 
-        for name in dirs if entries is None else zip(dirs, entries):
-            try:
-                if not follow_symlinks:
-                    if topdown:
-                        orig_st = stat(name, dir_fd=topfd, follow_symlinks=False)
-                    else:
-                        assert entries is not None
-                        name, entry = name
-                        orig_st = entry.stat(follow_symlinks=False)
-                dirfd = open(name, O_RDONLY | O_NONBLOCK, dir_fd=topfd)
-            except OSError as err:
-                if onerror is not None:
-                    onerror(err)
-                continue
-            try:
-                if follow_symlinks or path.samestat(orig_st, stat(dirfd)):
-                    dirpath = path.join(toppath, name)
-                    yield from _fwalk(dirfd, dirpath, isbytes,
-                                      topdown, onerror, follow_symlinks)
-            finally:
-                close(dirfd)
-
-        if not topdown:
-            yield toppath, dirs, nondirs, topfd
+        toppath = path.join(toppath, toppath[:0])  # Add trailing slash.
+        if entries is None:
+            stack.extend(
+                (_fwalk_walk, (False, topfd, toppath + name, name, None))
+                for name in dirs[::-1])
+        else:
+            stack.extend(
+                (_fwalk_walk, (False, topfd, toppath + name, name, entry))
+                for name, entry in zip(dirs[::-1], entries[::-1]))
 
     __all__.append("fwalk")
 
@@ -1061,6 +1093,12 @@ def _fspath(path):
         else:
             raise TypeError("expected str, bytes or os.PathLike object, "
                             "not " + path_type.__name__)
+    except TypeError:
+        if path_type.__fspath__ is None:
+            raise TypeError("expected str, bytes or os.PathLike object, "
+                            "not " + path_type.__name__) from None
+        else:
+            raise
     if isinstance(path_repr, (str, bytes)):
         return path_repr
     else:
@@ -1079,6 +1117,8 @@ class PathLike(abc.ABC):
 
     """Abstract base class for implementing the file system path protocol."""
 
+    __slots__ = ()
+
     @abc.abstractmethod
     def __fspath__(self):
         """Return the file system path representation of the object."""
@@ -1128,3 +1168,17 @@ def add_dll_directory(path):
             cookie,
             nt._remove_dll_directory
         )
+
+
+if _exists('sched_getaffinity') and sys._get_cpu_count_config() < 0:
+    def process_cpu_count():
+        """
+        Get the number of CPUs of the current process.
+
+        Return the number of logical CPUs usable by the calling thread of the
+        current process. Return None if indeterminable.
+        """
+        return len(sched_getaffinity(0))
+else:
+    # Just an alias to cpu_count() (same docstring)
+    process_cpu_count = cpu_count
diff --git a/Lib/pathlib.py b/Lib/pathlib.py
deleted file mode 100644
index bd5a096f9e..0000000000
--- a/Lib/pathlib.py
+++ /dev/null
@@ -1,1435 +0,0 @@
-"""Object-oriented filesystem paths.
-
-This module provides classes to represent abstract paths and concrete
-paths with operations that have semantics appropriate for different
-operating systems.
-"""
-
-import fnmatch
-import functools
-import io
-import ntpath
-import os
-import posixpath
-import re
-import sys
-import warnings
-from _collections_abc import Sequence
-from errno import ENOENT, ENOTDIR, EBADF, ELOOP
-from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
-from urllib.parse import quote_from_bytes as urlquote_from_bytes
-
-
-__all__ = [
-    "PurePath", "PurePosixPath", "PureWindowsPath",
-    "Path", "PosixPath", "WindowsPath",
-    ]
-
-#
-# Internals
-#
-
-# Reference for Windows paths can be found at
-# https://learn.microsoft.com/en-gb/windows/win32/fileio/naming-a-file .
-_WIN_RESERVED_NAMES = frozenset(
-    {'CON', 'PRN', 'AUX', 'NUL', 'CONIN$', 'CONOUT$'} |
-    {f'COM{c}' for c in '123456789\xb9\xb2\xb3'} |
-    {f'LPT{c}' for c in '123456789\xb9\xb2\xb3'}
-)
-
-_WINERROR_NOT_READY = 21  # drive exists but is not accessible
-_WINERROR_INVALID_NAME = 123  # fix for bpo-35306
-_WINERROR_CANT_RESOLVE_FILENAME = 1921  # broken symlink pointing to itself
-
-# EBADF - guard against macOS `stat` throwing EBADF
-_IGNORED_ERRNOS = (ENOENT, ENOTDIR, EBADF, ELOOP)
-
-_IGNORED_WINERRORS = (
-    _WINERROR_NOT_READY,
-    _WINERROR_INVALID_NAME,
-    _WINERROR_CANT_RESOLVE_FILENAME)
-
-def _ignore_error(exception):
-    return (getattr(exception, 'errno', None) in _IGNORED_ERRNOS or
-            getattr(exception, 'winerror', None) in _IGNORED_WINERRORS)
-
-
-@functools.cache
-def _is_case_sensitive(flavour):
-    return flavour.normcase('Aa') == 'Aa'
-
-#
-# Globbing helpers
-#
-
-
-# fnmatch.translate() returns a regular expression that includes a prefix and
-# a suffix, which enable matching newlines and ensure the end of the string is
-# matched, respectively. These features are undesirable for our implementation
-# of PurePatch.match(), which represents path separators as newlines and joins
-# pattern segments together. As a workaround, we define a slice object that
-# can remove the prefix and suffix from any translate() result. See the
-# _compile_pattern_lines() function for more details.
-_FNMATCH_PREFIX, _FNMATCH_SUFFIX = fnmatch.translate('_').split('_')
-_FNMATCH_SLICE = slice(len(_FNMATCH_PREFIX), -len(_FNMATCH_SUFFIX))
-_SWAP_SEP_AND_NEWLINE = {
-    '/': str.maketrans({'/': '\n', '\n': '/'}),
-    '\\': str.maketrans({'\\': '\n', '\n': '\\'}),
-}
-
-
-@functools.lru_cache()
-def _make_selector(pattern_parts, flavour, case_sensitive):
-    pat = pattern_parts[0]
-    if not pat:
-        return _TerminatingSelector()
-    if pat == '**':
-        child_parts_idx = 1
-        while child_parts_idx < len(pattern_parts) and pattern_parts[child_parts_idx] == '**':
-            child_parts_idx += 1
-        child_parts = pattern_parts[child_parts_idx:]
-        if '**' in child_parts:
-            cls = _DoubleRecursiveWildcardSelector
-        else:
-            cls = _RecursiveWildcardSelector
-    else:
-        child_parts = pattern_parts[1:]
-        if pat == '..':
-            cls = _ParentSelector
-        elif '**' in pat:
-            raise ValueError("Invalid pattern: '**' can only be an entire path component")
-        else:
-            cls = _WildcardSelector
-    return cls(pat, child_parts, flavour, case_sensitive)
-
-
-@functools.lru_cache(maxsize=256)
-def _compile_pattern(pat, case_sensitive):
-    flags = re.NOFLAG if case_sensitive else re.IGNORECASE
-    return re.compile(fnmatch.translate(pat), flags).match
-
-
-@functools.lru_cache()
-def _compile_pattern_lines(pattern_lines, case_sensitive):
-    """Compile the given pattern lines to an `re.Pattern` object.
-
-    The *pattern_lines* argument is a glob-style pattern (e.g. '*/*.py') with
-    its path separators and newlines swapped (e.g. '*\n*.py`). By using
-    newlines to separate path components, and not setting `re.DOTALL`, we
-    ensure that the `*` wildcard cannot match path separators.
-
-    The returned `re.Pattern` object may have its `match()` method called to
-    match a complete pattern, or `search()` to match from the right. The
-    argument supplied to these methods must also have its path separators and
-    newlines swapped.
-    """
-
-    # Match the start of the path, or just after a path separator
-    parts = ['^']
-    for part in pattern_lines.splitlines(keepends=True):
-        if part == '*\n':
-            part = r'.+\n'
-        elif part == '*':
-            part = r'.+'
-        else:
-            # Any other component: pass to fnmatch.translate(). We slice off
-            # the common prefix and suffix added by translate() to ensure that
-            # re.DOTALL is not set, and the end of the string not matched,
-            # respectively. With DOTALL not set, '*' wildcards will not match
-            # path separators, because the '.' characters in the pattern will
-            # not match newlines.
-            part = fnmatch.translate(part)[_FNMATCH_SLICE]
-        parts.append(part)
-    # Match the end of the path, always.
-    parts.append(r'\Z')
-    flags = re.MULTILINE
-    if not case_sensitive:
-        flags |= re.IGNORECASE
-    return re.compile(''.join(parts), flags=flags)
-
-
-class _Selector:
-    """A selector matches a specific glob pattern part against the children
-    of a given path."""
-
-    def __init__(self, child_parts, flavour, case_sensitive):
-        self.child_parts = child_parts
-        if child_parts:
-            self.successor = _make_selector(child_parts, flavour, case_sensitive)
-            self.dironly = True
-        else:
-            self.successor = _TerminatingSelector()
-            self.dironly = False
-
-    def select_from(self, parent_path):
-        """Iterate over all child paths of `parent_path` matched by this
-        selector.  This can contain parent_path itself."""
-        path_cls = type(parent_path)
-        scandir = path_cls._scandir
-        if not parent_path.is_dir():
-            return iter([])
-        return self._select_from(parent_path, scandir)
-
-
-class _TerminatingSelector:
-
-    def _select_from(self, parent_path, scandir):
-        yield parent_path
-
-
-class _ParentSelector(_Selector):
-
-    def __init__(self, name, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-
-    def _select_from(self,  parent_path, scandir):
-        path = parent_path._make_child_relpath('..')
-        for p in self.successor._select_from(path, scandir):
-            yield p
-
-
-class _WildcardSelector(_Selector):
-
-    def __init__(self, pat, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-        if case_sensitive is None:
-            # TODO: evaluate case-sensitivity of each directory in _select_from()
-            case_sensitive = _is_case_sensitive(flavour)
-        self.match = _compile_pattern(pat, case_sensitive)
-
-    def _select_from(self, parent_path, scandir):
-        try:
-            # We must close the scandir() object before proceeding to
-            # avoid exhausting file descriptors when globbing deep trees.
-            with scandir(parent_path) as scandir_it:
-                entries = list(scandir_it)
-        except OSError:
-            pass
-        else:
-            for entry in entries:
-                if self.dironly:
-                    try:
-                        if not entry.is_dir():
-                            continue
-                    except OSError:
-                        continue
-                name = entry.name
-                if self.match(name):
-                    path = parent_path._make_child_relpath(name)
-                    for p in self.successor._select_from(path, scandir):
-                        yield p
-
-
-class _RecursiveWildcardSelector(_Selector):
-
-    def __init__(self, pat, child_parts, flavour, case_sensitive):
-        _Selector.__init__(self, child_parts, flavour, case_sensitive)
-
-    def _iterate_directories(self, parent_path):
-        yield parent_path
-        for dirpath, dirnames, _ in parent_path.walk():
-            for dirname in dirnames:
-                yield dirpath._make_child_relpath(dirname)
-
-    def _select_from(self, parent_path, scandir):
-        successor_select = self.successor._select_from
-        for starting_point in self._iterate_directories(parent_path):
-            for p in successor_select(starting_point, scandir):
-                yield p
-
-
-class _DoubleRecursiveWildcardSelector(_RecursiveWildcardSelector):
-    """
-    Like _RecursiveWildcardSelector, but also de-duplicates results from
-    successive selectors. This is necessary if the pattern contains
-    multiple non-adjacent '**' segments.
-    """
-
-    def _select_from(self, parent_path, scandir):
-        yielded = set()
-        try:
-            for p in super()._select_from(parent_path, scandir):
-                if p not in yielded:
-                    yield p
-                    yielded.add(p)
-        finally:
-            yielded.clear()
-
-
-#
-# Public API
-#
-
-class _PathParents(Sequence):
-    """This object provides sequence-like access to the logical ancestors
-    of a path.  Don't try to construct it yourself."""
-    __slots__ = ('_path', '_drv', '_root', '_tail')
-
-    def __init__(self, path):
-        self._path = path
-        self._drv = path.drive
-        self._root = path.root
-        self._tail = path._tail
-
-    def __len__(self):
-        return len(self._tail)
-
-    def __getitem__(self, idx):
-        if isinstance(idx, slice):
-            return tuple(self[i] for i in range(*idx.indices(len(self))))
-
-        if idx >= len(self) or idx < -len(self):
-            raise IndexError(idx)
-        if idx < 0:
-            idx += len(self)
-        return self._path._from_parsed_parts(self._drv, self._root,
-                                             self._tail[:-idx - 1])
-
-    def __repr__(self):
-        return "<{}.parents>".format(type(self._path).__name__)
-
-
-class PurePath(object):
-    """Base class for manipulating paths without I/O.
-
-    PurePath represents a filesystem path and offers operations which
-    don't imply any actual filesystem I/O.  Depending on your system,
-    instantiating a PurePath will return either a PurePosixPath or a
-    PureWindowsPath object.  You can also instantiate either of these classes
-    directly, regardless of your system.
-    """
-
-    __slots__ = (
-        # The `_raw_paths` slot stores unnormalized string paths. This is set
-        # in the `__init__()` method.
-        '_raw_paths',
-
-        # The `_drv`, `_root` and `_tail_cached` slots store parsed and
-        # normalized parts of the path. They are set when any of the `drive`,
-        # `root` or `_tail` properties are accessed for the first time. The
-        # three-part division corresponds to the result of
-        # `os.path.splitroot()`, except that the tail is further split on path
-        # separators (i.e. it is a list of strings), and that the root and
-        # tail are normalized.
-        '_drv', '_root', '_tail_cached',
-
-        # The `_str` slot stores the string representation of the path,
-        # computed from the drive, root and tail when `__str__()` is called
-        # for the first time. It's used to implement `_str_normcase`
-        '_str',
-
-        # The `_str_normcase_cached` slot stores the string path with
-        # normalized case. It is set when the `_str_normcase` property is
-        # accessed for the first time. It's used to implement `__eq__()`
-        # `__hash__()`, and `_parts_normcase`
-        '_str_normcase_cached',
-
-        # The `_parts_normcase_cached` slot stores the case-normalized
-        # string path after splitting on path separators. It's set when the
-        # `_parts_normcase` property is accessed for the first time. It's used
-        # to implement comparison methods like `__lt__()`.
-        '_parts_normcase_cached',
-
-        # The `_lines_cached` slot stores the string path with path separators
-        # and newlines swapped. This is used to implement `match()`.
-        '_lines_cached',
-
-        # The `_hash` slot stores the hash of the case-normalized string
-        # path. It's set when `__hash__()` is called for the first time.
-        '_hash',
-    )
-    _flavour = os.path
-
-    def __new__(cls, *args, **kwargs):
-        """Construct a PurePath from one or several strings and or existing
-        PurePath objects.  The strings and path objects are combined so as
-        to yield a canonicalized path, which is incorporated into the
-        new PurePath object.
-        """
-        if cls is PurePath:
-            cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
-        return object.__new__(cls)
-
-    def __reduce__(self):
-        # Using the parts tuple helps share interned path parts
-        # when pickling related paths.
-        return (self.__class__, self.parts)
-
-    def __init__(self, *args):
-        paths = []
-        for arg in args:
-            if isinstance(arg, PurePath):
-                if arg._flavour is ntpath and self._flavour is posixpath:
-                    # GH-103631: Convert separators for backwards compatibility.
-                    paths.extend(path.replace('\\', '/') for path in arg._raw_paths)
-                else:
-                    paths.extend(arg._raw_paths)
-            else:
-                try:
-                    path = os.fspath(arg)
-                except TypeError:
-                    path = arg
-                if not isinstance(path, str):
-                    raise TypeError(
-                        "argument should be a str or an os.PathLike "
-                        "object where __fspath__ returns a str, "
-                        f"not {type(path).__name__!r}")
-                paths.append(path)
-        self._raw_paths = paths
-
-    def with_segments(self, *pathsegments):
-        """Construct a new path object from any number of path-like objects.
-        Subclasses may override this method to customize how new path objects
-        are created from methods like `iterdir()`.
-        """
-        return type(self)(*pathsegments)
-
-    @classmethod
-    def _parse_path(cls, path):
-        if not path:
-            return '', '', []
-        sep = cls._flavour.sep
-        altsep = cls._flavour.altsep
-        if altsep:
-            path = path.replace(altsep, sep)
-        drv, root, rel = cls._flavour.splitroot(path)
-        if not root and drv.startswith(sep) and not drv.endswith(sep):
-            drv_parts = drv.split(sep)
-            if len(drv_parts) == 4 and drv_parts[2] not in '?.':
-                # e.g. //server/share
-                root = sep
-            elif len(drv_parts) == 6:
-                # e.g. //?/unc/server/share
-                root = sep
-        parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
-        return drv, root, parsed
-
-    def _load_parts(self):
-        paths = self._raw_paths
-        if len(paths) == 0:
-            path = ''
-        elif len(paths) == 1:
-            path = paths[0]
-        else:
-            path = self._flavour.join(*paths)
-        drv, root, tail = self._parse_path(path)
-        self._drv = drv
-        self._root = root
-        self._tail_cached = tail
-
-    def _from_parsed_parts(self, drv, root, tail):
-        path_str = self._format_parsed_parts(drv, root, tail)
-        path = self.with_segments(path_str)
-        path._str = path_str or '.'
-        path._drv = drv
-        path._root = root
-        path._tail_cached = tail
-        return path
-
-    @classmethod
-    def _format_parsed_parts(cls, drv, root, tail):
-        if drv or root:
-            return drv + root + cls._flavour.sep.join(tail)
-        elif tail and cls._flavour.splitdrive(tail[0])[0]:
-            tail = ['.'] + tail
-        return cls._flavour.sep.join(tail)
-
-    def __str__(self):
-        """Return the string representation of the path, suitable for
-        passing to system calls."""
-        try:
-            return self._str
-        except AttributeError:
-            self._str = self._format_parsed_parts(self.drive, self.root,
-                                                  self._tail) or '.'
-            return self._str
-
-    def __fspath__(self):
-        return str(self)
-
-    def as_posix(self):
-        """Return the string representation of the path with forward (/)
-        slashes."""
-        f = self._flavour
-        return str(self).replace(f.sep, '/')
-
-    def __bytes__(self):
-        """Return the bytes representation of the path.  This is only
-        recommended to use under Unix."""
-        return os.fsencode(self)
-
-    def __repr__(self):
-        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
-
-    def as_uri(self):
-        """Return the path as a 'file' URI."""
-        if not self.is_absolute():
-            raise ValueError("relative path can't be expressed as a file URI")
-
-        drive = self.drive
-        if len(drive) == 2 and drive[1] == ':':
-            # It's a path on a local drive => 'file:///c:/a/b'
-            prefix = 'file:///' + drive
-            path = self.as_posix()[2:]
-        elif drive:
-            # It's a path on a network drive => 'file://host/share/a/b'
-            prefix = 'file:'
-            path = self.as_posix()
-        else:
-            # It's a posix path => 'file:///etc/hosts'
-            prefix = 'file://'
-            path = str(self)
-        return prefix + urlquote_from_bytes(os.fsencode(path))
-
-    @property
-    def _str_normcase(self):
-        # String with normalized case, for hashing and equality checks
-        try:
-            return self._str_normcase_cached
-        except AttributeError:
-            if _is_case_sensitive(self._flavour):
-                self._str_normcase_cached = str(self)
-            else:
-                self._str_normcase_cached = str(self).lower()
-            return self._str_normcase_cached
-
-    @property
-    def _parts_normcase(self):
-        # Cached parts with normalized case, for comparisons.
-        try:
-            return self._parts_normcase_cached
-        except AttributeError:
-            self._parts_normcase_cached = self._str_normcase.split(self._flavour.sep)
-            return self._parts_normcase_cached
-
-    @property
-    def _lines(self):
-        # Path with separators and newlines swapped, for pattern matching.
-        try:
-            return self._lines_cached
-        except AttributeError:
-            path_str = str(self)
-            if path_str == '.':
-                self._lines_cached = ''
-            else:
-                trans = _SWAP_SEP_AND_NEWLINE[self._flavour.sep]
-                self._lines_cached = path_str.translate(trans)
-            return self._lines_cached
-
-    def __eq__(self, other):
-        if not isinstance(other, PurePath):
-            return NotImplemented
-        return self._str_normcase == other._str_normcase and self._flavour is other._flavour
-
-    def __hash__(self):
-        try:
-            return self._hash
-        except AttributeError:
-            self._hash = hash(self._str_normcase)
-            return self._hash
-
-    def __lt__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase < other._parts_normcase
-
-    def __le__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase <= other._parts_normcase
-
-    def __gt__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase > other._parts_normcase
-
-    def __ge__(self, other):
-        if not isinstance(other, PurePath) or self._flavour is not other._flavour:
-            return NotImplemented
-        return self._parts_normcase >= other._parts_normcase
-
-    @property
-    def drive(self):
-        """The drive prefix (letter or UNC path), if any."""
-        try:
-            return self._drv
-        except AttributeError:
-            self._load_parts()
-            return self._drv
-
-    @property
-    def root(self):
-        """The root of the path, if any."""
-        try:
-            return self._root
-        except AttributeError:
-            self._load_parts()
-            return self._root
-
-    @property
-    def _tail(self):
-        try:
-            return self._tail_cached
-        except AttributeError:
-            self._load_parts()
-            return self._tail_cached
-
-    @property
-    def anchor(self):
-        """The concatenation of the drive and root, or ''."""
-        anchor = self.drive + self.root
-        return anchor
-
-    @property
-    def name(self):
-        """The final path component, if any."""
-        tail = self._tail
-        if not tail:
-            return ''
-        return tail[-1]
-
-    @property
-    def suffix(self):
-        """
-        The final component's last suffix, if any.
-
-        This includes the leading period. For example: '.txt'
-        """
-        name = self.name
-        i = name.rfind('.')
-        if 0 < i < len(name) - 1:
-            return name[i:]
-        else:
-            return ''
-
-    @property
-    def suffixes(self):
-        """
-        A list of the final component's suffixes, if any.
-
-        These include the leading periods. For example: ['.tar', '.gz']
-        """
-        name = self.name
-        if name.endswith('.'):
-            return []
-        name = name.lstrip('.')
-        return ['.' + suffix for suffix in name.split('.')[1:]]
-
-    @property
-    def stem(self):
-        """The final path component, minus its last suffix."""
-        name = self.name
-        i = name.rfind('.')
-        if 0 < i < len(name) - 1:
-            return name[:i]
-        else:
-            return name
-
-    def with_name(self, name):
-        """Return a new path with the file name changed."""
-        if not self.name:
-            raise ValueError("%r has an empty name" % (self,))
-        f = self._flavour
-        if not name or f.sep in name or (f.altsep and f.altsep in name) or name == '.':
-            raise ValueError("Invalid name %r" % (name))
-        return self._from_parsed_parts(self.drive, self.root,
-                                       self._tail[:-1] + [name])
-
-    def with_stem(self, stem):
-        """Return a new path with the stem changed."""
-        return self.with_name(stem + self.suffix)
-
-    def with_suffix(self, suffix):
-        """Return a new path with the file suffix changed.  If the path
-        has no suffix, add given suffix.  If the given suffix is an empty
-        string, remove the suffix from the path.
-        """
-        f = self._flavour
-        if f.sep in suffix or f.altsep and f.altsep in suffix:
-            raise ValueError("Invalid suffix %r" % (suffix,))
-        if suffix and not suffix.startswith('.') or suffix == '.':
-            raise ValueError("Invalid suffix %r" % (suffix))
-        name = self.name
-        if not name:
-            raise ValueError("%r has an empty name" % (self,))
-        old_suffix = self.suffix
-        if not old_suffix:
-            name = name + suffix
-        else:
-            name = name[:-len(old_suffix)] + suffix
-        return self._from_parsed_parts(self.drive, self.root,
-                                       self._tail[:-1] + [name])
-
-    def relative_to(self, other, /, *_deprecated, walk_up=False):
-        """Return the relative path to another path identified by the passed
-        arguments.  If the operation is not possible (because this is not
-        related to the other path), raise ValueError.
-
-        The *walk_up* parameter controls whether `..` may be used to resolve
-        the path.
-        """
-        if _deprecated:
-            msg = ("support for supplying more than one positional argument "
-                   "to pathlib.PurePath.relative_to() is deprecated and "
-                   "scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath.relative_to(*args)", msg,
-                                 remove=(3, 14))
-        other = self.with_segments(other, *_deprecated)
-        for step, path in enumerate([other] + list(other.parents)):
-            if self.is_relative_to(path):
-                break
-            elif not walk_up:
-                raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
-            elif path.name == '..':
-                raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
-        else:
-            raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
-        parts = ['..'] * step + self._tail[len(path._tail):]
-        return self.with_segments(*parts)
-
-    def is_relative_to(self, other, /, *_deprecated):
-        """Return True if the path is relative to another path or False.
-        """
-        if _deprecated:
-            msg = ("support for supplying more than one argument to "
-                   "pathlib.PurePath.is_relative_to() is deprecated and "
-                   "scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath.is_relative_to(*args)",
-                                 msg, remove=(3, 14))
-        other = self.with_segments(other, *_deprecated)
-        return other == self or other in self.parents
-
-    @property
-    def parts(self):
-        """An object providing sequence-like access to the
-        components in the filesystem path."""
-        if self.drive or self.root:
-            return (self.drive + self.root,) + tuple(self._tail)
-        else:
-            return tuple(self._tail)
-
-    def joinpath(self, *pathsegments):
-        """Combine this path with one or several arguments, and return a
-        new path representing either a subpath (if all arguments are relative
-        paths) or a totally different path (if one of the arguments is
-        anchored).
-        """
-        return self.with_segments(self, *pathsegments)
-
-    def __truediv__(self, key):
-        try:
-            return self.joinpath(key)
-        except TypeError:
-            return NotImplemented
-
-    def __rtruediv__(self, key):
-        try:
-            return self.with_segments(key, self)
-        except TypeError:
-            return NotImplemented
-
-    @property
-    def parent(self):
-        """The logical parent of the path."""
-        drv = self.drive
-        root = self.root
-        tail = self._tail
-        if not tail:
-            return self
-        return self._from_parsed_parts(drv, root, tail[:-1])
-
-    @property
-    def parents(self):
-        """A sequence of this path's logical parents."""
-        # The value of this property should not be cached on the path object,
-        # as doing so would introduce a reference cycle.
-        return _PathParents(self)
-
-    def is_absolute(self):
-        """True if the path is absolute (has both a root and, if applicable,
-        a drive)."""
-        if self._flavour is ntpath:
-            # ntpath.isabs() is defective - see GH-44626.
-            return bool(self.drive and self.root)
-        elif self._flavour is posixpath:
-            # Optimization: work with raw paths on POSIX.
-            for path in self._raw_paths:
-                if path.startswith('/'):
-                    return True
-            return False
-        else:
-            return self._flavour.isabs(str(self))
-
-    def is_reserved(self):
-        """Return True if the path contains one of the special names reserved
-        by the system, if any."""
-        if self._flavour is posixpath or not self._tail:
-            return False
-
-        # NOTE: the rules for reserved names seem somewhat complicated
-        # (e.g. r"..\NUL" is reserved but not r"foo\NUL" if "foo" does not
-        # exist). We err on the side of caution and return True for paths
-        # which are not considered reserved by Windows.
-        if self.drive.startswith('\\\\'):
-            # UNC paths are never reserved.
-            return False
-        name = self._tail[-1].partition('.')[0].partition(':')[0].rstrip(' ')
-        return name.upper() in _WIN_RESERVED_NAMES
-
-    def match(self, path_pattern, *, case_sensitive=None):
-        """
-        Return True if this path matches the given pattern.
-        """
-        if not isinstance(path_pattern, PurePath):
-            path_pattern = self.with_segments(path_pattern)
-        if case_sensitive is None:
-            case_sensitive = _is_case_sensitive(self._flavour)
-        pattern = _compile_pattern_lines(path_pattern._lines, case_sensitive)
-        if path_pattern.drive or path_pattern.root:
-            return pattern.match(self._lines) is not None
-        elif path_pattern._tail:
-            return pattern.search(self._lines) is not None
-        else:
-            raise ValueError("empty pattern")
-
-
-# Can't subclass os.PathLike from PurePath and keep the constructor
-# optimizations in PurePath.__slots__.
-os.PathLike.register(PurePath)
-
-
-class PurePosixPath(PurePath):
-    """PurePath subclass for non-Windows systems.
-
-    On a POSIX system, instantiating a PurePath should return this object.
-    However, you can also instantiate it directly on any system.
-    """
-    _flavour = posixpath
-    __slots__ = ()
-
-
-class PureWindowsPath(PurePath):
-    """PurePath subclass for Windows systems.
-
-    On a Windows system, instantiating a PurePath should return this object.
-    However, you can also instantiate it directly on any system.
-    """
-    _flavour = ntpath
-    __slots__ = ()
-
-
-# Filesystem-accessing classes
-
-
-class Path(PurePath):
-    """PurePath subclass that can make system calls.
-
-    Path represents a filesystem path but unlike PurePath, also offers
-    methods to do system calls on path objects. Depending on your system,
-    instantiating a Path will return either a PosixPath or a WindowsPath
-    object. You can also instantiate a PosixPath or WindowsPath directly,
-    but cannot instantiate a WindowsPath on a POSIX system or vice versa.
-    """
-    __slots__ = ()
-
-    def stat(self, *, follow_symlinks=True):
-        """
-        Return the result of the stat() system call on this path, like
-        os.stat() does.
-        """
-        return os.stat(self, follow_symlinks=follow_symlinks)
-
-    def lstat(self):
-        """
-        Like stat(), except if the path points to a symlink, the symlink's
-        status information is returned, rather than its target's.
-        """
-        return self.stat(follow_symlinks=False)
-
-
-    # Convenience functions for querying the stat results
-
-    def exists(self, *, follow_symlinks=True):
-        """
-        Whether this path exists.
-
-        This method normally follows symlinks; to check whether a symlink exists,
-        add the argument follow_symlinks=False.
-        """
-        try:
-            self.stat(follow_symlinks=follow_symlinks)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-        return True
-
-    def is_dir(self):
-        """
-        Whether this path is a directory.
-        """
-        try:
-            return S_ISDIR(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_file(self):
-        """
-        Whether this path is a regular file (also True for symlinks pointing
-        to regular files).
-        """
-        try:
-            return S_ISREG(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_mount(self):
-        """
-        Check if this path is a mount point
-        """
-        return self._flavour.ismount(self)
-
-    def is_symlink(self):
-        """
-        Whether this path is a symbolic link.
-        """
-        try:
-            return S_ISLNK(self.lstat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_junction(self):
-        """
-        Whether this path is a junction.
-        """
-        return self._flavour.isjunction(self)
-
-    def is_block_device(self):
-        """
-        Whether this path is a block device.
-        """
-        try:
-            return S_ISBLK(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_char_device(self):
-        """
-        Whether this path is a character device.
-        """
-        try:
-            return S_ISCHR(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_fifo(self):
-        """
-        Whether this path is a FIFO.
-        """
-        try:
-            return S_ISFIFO(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def is_socket(self):
-        """
-        Whether this path is a socket.
-        """
-        try:
-            return S_ISSOCK(self.stat().st_mode)
-        except OSError as e:
-            if not _ignore_error(e):
-                raise
-            # Path doesn't exist or is a broken symlink
-            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
-            return False
-        except ValueError:
-            # Non-encodable path
-            return False
-
-    def samefile(self, other_path):
-        """Return whether other_path is the same or not as this file
-        (as returned by os.path.samefile()).
-        """
-        st = self.stat()
-        try:
-            other_st = other_path.stat()
-        except AttributeError:
-            other_st = self.with_segments(other_path).stat()
-        return self._flavour.samestat(st, other_st)
-
-    def open(self, mode='r', buffering=-1, encoding=None,
-             errors=None, newline=None):
-        """
-        Open the file pointed by this path and return a file object, as
-        the built-in open() function does.
-        """
-        if "b" not in mode:
-            encoding = io.text_encoding(encoding)
-        return io.open(self, mode, buffering, encoding, errors, newline)
-
-    def read_bytes(self):
-        """
-        Open the file in bytes mode, read it, and close the file.
-        """
-        with self.open(mode='rb') as f:
-            return f.read()
-
-    def read_text(self, encoding=None, errors=None):
-        """
-        Open the file in text mode, read it, and close the file.
-        """
-        encoding = io.text_encoding(encoding)
-        with self.open(mode='r', encoding=encoding, errors=errors) as f:
-            return f.read()
-
-    def write_bytes(self, data):
-        """
-        Open the file in bytes mode, write to it, and close the file.
-        """
-        # type-check for the buffer interface before truncating the file
-        view = memoryview(data)
-        with self.open(mode='wb') as f:
-            return f.write(view)
-
-    def write_text(self, data, encoding=None, errors=None, newline=None):
-        """
-        Open the file in text mode, write to it, and close the file.
-        """
-        if not isinstance(data, str):
-            raise TypeError('data must be str, not %s' %
-                            data.__class__.__name__)
-        encoding = io.text_encoding(encoding)
-        with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
-            return f.write(data)
-
-    def iterdir(self):
-        """Yield path objects of the directory contents.
-
-        The children are yielded in arbitrary order, and the
-        special entries '.' and '..' are not included.
-        """
-        for name in os.listdir(self):
-            yield self._make_child_relpath(name)
-
-    def _scandir(self):
-        # bpo-24132: a future version of pathlib will support subclassing of
-        # pathlib.Path to customize how the filesystem is accessed. This
-        # includes scandir(), which is used to implement glob().
-        return os.scandir(self)
-
-    def _make_child_relpath(self, name):
-        path_str = str(self)
-        tail = self._tail
-        if tail:
-            path_str = f'{path_str}{self._flavour.sep}{name}'
-        elif path_str != '.':
-            path_str = f'{path_str}{name}'
-        else:
-            path_str = name
-        path = self.with_segments(path_str)
-        path._str = path_str
-        path._drv = self.drive
-        path._root = self.root
-        path._tail_cached = tail + [name]
-        return path
-
-    def glob(self, pattern, *, case_sensitive=None):
-        """Iterate over this subtree and yield all existing files (of any
-        kind, including directories) matching the given relative pattern.
-        """
-        sys.audit("pathlib.Path.glob", self, pattern)
-        if not pattern:
-            raise ValueError("Unacceptable pattern: {!r}".format(pattern))
-        drv, root, pattern_parts = self._parse_path(pattern)
-        if drv or root:
-            raise NotImplementedError("Non-relative patterns are unsupported")
-        if pattern[-1] in (self._flavour.sep, self._flavour.altsep):
-            pattern_parts.append('')
-        selector = _make_selector(tuple(pattern_parts), self._flavour, case_sensitive)
-        for p in selector.select_from(self):
-            yield p
-
-    def rglob(self, pattern, *, case_sensitive=None):
-        """Recursively yield all existing files (of any kind, including
-        directories) matching the given relative pattern, anywhere in
-        this subtree.
-        """
-        sys.audit("pathlib.Path.rglob", self, pattern)
-        drv, root, pattern_parts = self._parse_path(pattern)
-        if drv or root:
-            raise NotImplementedError("Non-relative patterns are unsupported")
-        if pattern and pattern[-1] in (self._flavour.sep, self._flavour.altsep):
-            pattern_parts.append('')
-        selector = _make_selector(("**",) + tuple(pattern_parts), self._flavour, case_sensitive)
-        for p in selector.select_from(self):
-            yield p
-
-    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
-        """Walk the directory tree from this directory, similar to os.walk()."""
-        sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
-        paths = [self]
-
-        while paths:
-            path = paths.pop()
-            if isinstance(path, tuple):
-                yield path
-                continue
-
-            # We may not have read permission for self, in which case we can't
-            # get a list of the files the directory contains. os.walk()
-            # always suppressed the exception in that instance, rather than
-            # blow up for a minor reason when (say) a thousand readable
-            # directories are still left to visit. That logic is copied here.
-            try:
-                scandir_it = path._scandir()
-            except OSError as error:
-                if on_error is not None:
-                    on_error(error)
-                continue
-
-            with scandir_it:
-                dirnames = []
-                filenames = []
-                for entry in scandir_it:
-                    try:
-                        is_dir = entry.is_dir(follow_symlinks=follow_symlinks)
-                    except OSError:
-                        # Carried over from os.path.isdir().
-                        is_dir = False
-
-                    if is_dir:
-                        dirnames.append(entry.name)
-                    else:
-                        filenames.append(entry.name)
-
-            if top_down:
-                yield path, dirnames, filenames
-            else:
-                paths.append((path, dirnames, filenames))
-
-            paths += [path._make_child_relpath(d) for d in reversed(dirnames)]
-
-    def __init__(self, *args, **kwargs):
-        if kwargs:
-            msg = ("support for supplying keyword arguments to pathlib.PurePath "
-                   "is deprecated and scheduled for removal in Python {remove}")
-            warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
-        super().__init__(*args)
-
-    def __new__(cls, *args, **kwargs):
-        if cls is Path:
-            cls = WindowsPath if os.name == 'nt' else PosixPath
-        return object.__new__(cls)
-
-    def __enter__(self):
-        # In previous versions of pathlib, __exit__() marked this path as
-        # closed; subsequent attempts to perform I/O would raise an IOError.
-        # This functionality was never documented, and had the effect of
-        # making Path objects mutable, contrary to PEP 428.
-        # In Python 3.9 __exit__() was made a no-op.
-        # In Python 3.11 __enter__() began emitting DeprecationWarning.
-        # In Python 3.13 __enter__() and __exit__() should be removed.
-        warnings.warn("pathlib.Path.__enter__() is deprecated and scheduled "
-                      "for removal in Python 3.13; Path objects as a context "
-                      "manager is a no-op",
-                      DeprecationWarning, stacklevel=2)
-        return self
-
-    def __exit__(self, t, v, tb):
-        pass
-
-    # Public API
-
-    @classmethod
-    def cwd(cls):
-        """Return a new path pointing to the current working directory."""
-        # We call 'absolute()' rather than using 'os.getcwd()' directly to
-        # enable users to replace the implementation of 'absolute()' in a
-        # subclass and benefit from the new behaviour here. This works because
-        # os.path.abspath('.') == os.getcwd().
-        return cls().absolute()
-
-    @classmethod
-    def home(cls):
-        """Return a new path pointing to the user's home directory (as
-        returned by os.path.expanduser('~')).
-        """
-        return cls("~").expanduser()
-
-    def absolute(self):
-        """Return an absolute version of this path by prepending the current
-        working directory. No normalization or symlink resolution is performed.
-
-        Use resolve() to get the canonical path to a file.
-        """
-        if self.is_absolute():
-            return self
-        elif self.drive:
-            # There is a CWD on each drive-letter drive.
-            cwd = self._flavour.abspath(self.drive)
-        else:
-            cwd = os.getcwd()
-            # Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
-            # We pass only one argument to with_segments() to avoid the cost
-            # of joining, and we exploit the fact that getcwd() returns a
-            # fully-normalized string by storing it in _str. This is used to
-            # implement Path.cwd().
-            if not self.root and not self._tail:
-                result = self.with_segments(cwd)
-                result._str = cwd
-                return result
-        return self.with_segments(cwd, self)
-
-    def resolve(self, strict=False):
-        """
-        Make the path absolute, resolving all symlinks on the way and also
-        normalizing it.
-        """
-
-        def check_eloop(e):
-            winerror = getattr(e, 'winerror', 0)
-            if e.errno == ELOOP or winerror == _WINERROR_CANT_RESOLVE_FILENAME:
-                raise RuntimeError("Symlink loop from %r" % e.filename)
-
-        try:
-            s = self._flavour.realpath(self, strict=strict)
-        except OSError as e:
-            check_eloop(e)
-            raise
-        p = self.with_segments(s)
-
-        # In non-strict mode, realpath() doesn't raise on symlink loops.
-        # Ensure we get an exception by calling stat()
-        if not strict:
-            try:
-                p.stat()
-            except OSError as e:
-                check_eloop(e)
-        return p
-
-    def owner(self):
-        """
-        Return the login name of the file owner.
-        """
-        try:
-            import pwd
-            return pwd.getpwuid(self.stat().st_uid).pw_name
-        except ImportError:
-            raise NotImplementedError("Path.owner() is unsupported on this system")
-
-    def group(self):
-        """
-        Return the group name of the file gid.
-        """
-
-        try:
-            import grp
-            return grp.getgrgid(self.stat().st_gid).gr_name
-        except ImportError:
-            raise NotImplementedError("Path.group() is unsupported on this system")
-
-    def readlink(self):
-        """
-        Return the path to which the symbolic link points.
-        """
-        if not hasattr(os, "readlink"):
-            raise NotImplementedError("os.readlink() not available on this system")
-        return self.with_segments(os.readlink(self))
-
-    def touch(self, mode=0o666, exist_ok=True):
-        """
-        Create this file with the given access mode, if it doesn't exist.
-        """
-
-        if exist_ok:
-            # First try to bump modification time
-            # Implementation note: GNU touch uses the UTIME_NOW option of
-            # the utimensat() / futimens() functions.
-            try:
-                os.utime(self, None)
-            except OSError:
-                # Avoid exception chaining
-                pass
-            else:
-                return
-        flags = os.O_CREAT | os.O_WRONLY
-        if not exist_ok:
-            flags |= os.O_EXCL
-        fd = os.open(self, flags, mode)
-        os.close(fd)
-
-    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
-        """
-        Create a new directory at this given path.
-        """
-        try:
-            os.mkdir(self, mode)
-        except FileNotFoundError:
-            if not parents or self.parent == self:
-                raise
-            self.parent.mkdir(parents=True, exist_ok=True)
-            self.mkdir(mode, parents=False, exist_ok=exist_ok)
-        except OSError:
-            # Cannot rely on checking for EEXIST, since the operating system
-            # could give priority to other errors like EACCES or EROFS
-            if not exist_ok or not self.is_dir():
-                raise
-
-    def chmod(self, mode, *, follow_symlinks=True):
-        """
-        Change the permissions of the path, like os.chmod().
-        """
-        os.chmod(self, mode, follow_symlinks=follow_symlinks)
-
-    def lchmod(self, mode):
-        """
-        Like chmod(), except if the path points to a symlink, the symlink's
-        permissions are changed, rather than its target's.
-        """
-        self.chmod(mode, follow_symlinks=False)
-
-    def unlink(self, missing_ok=False):
-        """
-        Remove this file or link.
-        If the path is a directory, use rmdir() instead.
-        """
-        try:
-            os.unlink(self)
-        except FileNotFoundError:
-            if not missing_ok:
-                raise
-
-    def rmdir(self):
-        """
-        Remove this directory.  The directory must be empty.
-        """
-        os.rmdir(self)
-
-    def rename(self, target):
-        """
-        Rename this path to the target path.
-
-        The target path may be absolute or relative. Relative paths are
-        interpreted relative to the current working directory, *not* the
-        directory of the Path object.
-
-        Returns the new Path instance pointing to the target path.
-        """
-        os.rename(self, target)
-        return self.with_segments(target)
-
-    def replace(self, target):
-        """
-        Rename this path to the target path, overwriting if that path exists.
-
-        The target path may be absolute or relative. Relative paths are
-        interpreted relative to the current working directory, *not* the
-        directory of the Path object.
-
-        Returns the new Path instance pointing to the target path.
-        """
-        os.replace(self, target)
-        return self.with_segments(target)
-
-    def symlink_to(self, target, target_is_directory=False):
-        """
-        Make this path a symlink pointing to the target path.
-        Note the order of arguments (link, target) is the reverse of os.symlink.
-        """
-        if not hasattr(os, "symlink"):
-            raise NotImplementedError("os.symlink() not available on this system")
-        os.symlink(target, self, target_is_directory)
-
-    def hardlink_to(self, target):
-        """
-        Make this path a hard link pointing to the same file as *target*.
-
-        Note the order of arguments (self, target) is the reverse of os.link's.
-        """
-        if not hasattr(os, "link"):
-            raise NotImplementedError("os.link() not available on this system")
-        os.link(target, self)
-
-    def expanduser(self):
-        """ Return a new path with expanded ~ and ~user constructs
-        (as returned by os.path.expanduser)
-        """
-        if (not (self.drive or self.root) and
-            self._tail and self._tail[0][:1] == '~'):
-            homedir = self._flavour.expanduser(self._tail[0])
-            if homedir[:1] == "~":
-                raise RuntimeError("Could not determine home directory.")
-            drv, root, tail = self._parse_path(homedir)
-            return self._from_parsed_parts(drv, root, tail + self._tail[1:])
-
-        return self
-
-
-class PosixPath(Path, PurePosixPath):
-    """Path subclass for non-Windows systems.
-
-    On a POSIX system, instantiating a Path should return this object.
-    """
-    __slots__ = ()
-
-    if os.name == 'nt':
-        def __new__(cls, *args, **kwargs):
-            raise NotImplementedError(
-                f"cannot instantiate {cls.__name__!r} on your system")
-
-class WindowsPath(Path, PureWindowsPath):
-    """Path subclass for Windows systems.
-
-    On a Windows system, instantiating a Path should return this object.
-    """
-    __slots__ = ()
-
-    if os.name != 'nt':
-        def __new__(cls, *args, **kwargs):
-            raise NotImplementedError(
-                f"cannot instantiate {cls.__name__!r} on your system")
diff --git a/Lib/pathlib/__init__.py b/Lib/pathlib/__init__.py
new file mode 100644
index 0000000000..4b3edf535a
--- /dev/null
+++ b/Lib/pathlib/__init__.py
@@ -0,0 +1,12 @@
+"""Object-oriented filesystem paths.
+
+This module provides classes to represent abstract paths and concrete
+paths with operations that have semantics appropriate for different
+operating systems.
+"""
+
+from ._abc import *
+from ._local import *
+
+__all__ = (_abc.__all__ +
+           _local.__all__)
diff --git a/Lib/pathlib/_abc.py b/Lib/pathlib/_abc.py
new file mode 100644
index 0000000000..4d24146aa5
--- /dev/null
+++ b/Lib/pathlib/_abc.py
@@ -0,0 +1,930 @@
+"""
+Abstract base classes for rich path objects.
+
+This module is published as a PyPI package called "pathlib-abc".
+
+This module is also a *PRIVATE* part of the Python standard library, where
+it's developed alongside pathlib. If it finds success and maturity as a PyPI
+package, it could become a public part of the standard library.
+
+Two base classes are defined here -- PurePathBase and PathBase -- that
+resemble pathlib's PurePath and Path respectively.
+"""
+
+import functools
+from glob import _Globber, _no_recurse_symlinks
+from errno import ENOENT, ENOTDIR, EBADF, ELOOP, EINVAL
+from stat import S_ISDIR, S_ISLNK, S_ISREG, S_ISSOCK, S_ISBLK, S_ISCHR, S_ISFIFO
+
+
+__all__ = ["UnsupportedOperation"]
+
+#
+# Internals
+#
+
+_WINERROR_NOT_READY = 21  # drive exists but is not accessible
+_WINERROR_INVALID_NAME = 123  # fix for bpo-35306
+_WINERROR_CANT_RESOLVE_FILENAME = 1921  # broken symlink pointing to itself
+
+# EBADF - guard against macOS `stat` throwing EBADF
+_IGNORED_ERRNOS = (ENOENT, ENOTDIR, EBADF, ELOOP)
+
+_IGNORED_WINERRORS = (
+    _WINERROR_NOT_READY,
+    _WINERROR_INVALID_NAME,
+    _WINERROR_CANT_RESOLVE_FILENAME)
+
+def _ignore_error(exception):
+    return (getattr(exception, 'errno', None) in _IGNORED_ERRNOS or
+            getattr(exception, 'winerror', None) in _IGNORED_WINERRORS)
+
+
+@functools.cache
+def _is_case_sensitive(parser):
+    return parser.normcase('Aa') == 'Aa'
+
+
+class UnsupportedOperation(NotImplementedError):
+    """An exception that is raised when an unsupported operation is called on
+    a path object.
+    """
+    pass
+
+
+class ParserBase:
+    """Base class for path parsers, which do low-level path manipulation.
+
+    Path parsers provide a subset of the os.path API, specifically those
+    functions needed to provide PurePathBase functionality. Each PurePathBase
+    subclass references its path parser via a 'parser' class attribute.
+
+    Every method in this base class raises an UnsupportedOperation exception.
+    """
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported"
+
+    @property
+    def sep(self):
+        """The character used to separate path components."""
+        raise UnsupportedOperation(self._unsupported_msg('sep'))
+
+    def join(self, path, *paths):
+        """Join path segments."""
+        raise UnsupportedOperation(self._unsupported_msg('join()'))
+
+    def split(self, path):
+        """Split the path into a pair (head, tail), where *head* is everything
+        before the final path separator, and *tail* is everything after.
+        Either part may be empty.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('split()'))
+
+    def splitdrive(self, path):
+        """Split the path into a 2-item tuple (drive, tail), where *drive* is
+        a device name or mount point, and *tail* is everything after the
+        drive. Either part may be empty."""
+        raise UnsupportedOperation(self._unsupported_msg('splitdrive()'))
+
+    def normcase(self, path):
+        """Normalize the case of the path."""
+        raise UnsupportedOperation(self._unsupported_msg('normcase()'))
+
+    def isabs(self, path):
+        """Returns whether the path is absolute, i.e. unaffected by the
+        current directory or drive."""
+        raise UnsupportedOperation(self._unsupported_msg('isabs()'))
+
+
+class PurePathBase:
+    """Base class for pure path objects.
+
+    This class *does not* provide several magic methods that are defined in
+    its subclass PurePath. They are: __fspath__, __bytes__, __reduce__,
+    __hash__, __eq__, __lt__, __le__, __gt__, __ge__. Its initializer and path
+    joining methods accept only strings, not os.PathLike objects more broadly.
+    """
+
+    __slots__ = (
+        # The `_raw_path` slot store a joined string path. This is set in the
+        # `__init__()` method.
+        '_raw_path',
+
+        # The '_resolving' slot stores a boolean indicating whether the path
+        # is being processed by `PathBase.resolve()`. This prevents duplicate
+        # work from occurring when `resolve()` calls `stat()` or `readlink()`.
+        '_resolving',
+    )
+    parser = ParserBase()
+    _globber = _Globber
+
+    def __init__(self, path, *paths):
+        self._raw_path = self.parser.join(path, *paths) if paths else path
+        if not isinstance(self._raw_path, str):
+            raise TypeError(
+                f"path should be a str, not {type(self._raw_path).__name__!r}")
+        self._resolving = False
+
+    def with_segments(self, *pathsegments):
+        """Construct a new path object from any number of path-like objects.
+        Subclasses may override this method to customize how new path objects
+        are created from methods like `iterdir()`.
+        """
+        return type(self)(*pathsegments)
+
+    def __str__(self):
+        """Return the string representation of the path, suitable for
+        passing to system calls."""
+        return self._raw_path
+
+    def as_posix(self):
+        """Return the string representation of the path with forward (/)
+        slashes."""
+        return str(self).replace(self.parser.sep, '/')
+
+    @property
+    def drive(self):
+        """The drive prefix (letter or UNC path), if any."""
+        return self.parser.splitdrive(self.anchor)[0]
+
+    @property
+    def root(self):
+        """The root of the path, if any."""
+        return self.parser.splitdrive(self.anchor)[1]
+
+    @property
+    def anchor(self):
+        """The concatenation of the drive and root, or ''."""
+        return self._stack[0]
+
+    @property
+    def name(self):
+        """The final path component, if any."""
+        return self.parser.split(self._raw_path)[1]
+
+    @property
+    def suffix(self):
+        """
+        The final component's last suffix, if any.
+
+        This includes the leading period. For example: '.txt'
+        """
+        name = self.name
+        i = name.rfind('.')
+        if 0 < i < len(name) - 1:
+            return name[i:]
+        else:
+            return ''
+
+    @property
+    def suffixes(self):
+        """
+        A list of the final component's suffixes, if any.
+
+        These include the leading periods. For example: ['.tar', '.gz']
+        """
+        name = self.name
+        if name.endswith('.'):
+            return []
+        name = name.lstrip('.')
+        return ['.' + suffix for suffix in name.split('.')[1:]]
+
+    @property
+    def stem(self):
+        """The final path component, minus its last suffix."""
+        name = self.name
+        i = name.rfind('.')
+        if 0 < i < len(name) - 1:
+            return name[:i]
+        else:
+            return name
+
+    def with_name(self, name):
+        """Return a new path with the file name changed."""
+        split = self.parser.split
+        if split(name)[0]:
+            raise ValueError(f"Invalid name {name!r}")
+        return self.with_segments(split(self._raw_path)[0], name)
+
+    def with_stem(self, stem):
+        """Return a new path with the stem changed."""
+        suffix = self.suffix
+        if not suffix:
+            return self.with_name(stem)
+        elif not stem:
+            # If the suffix is non-empty, we can't make the stem empty.
+            raise ValueError(f"{self!r} has a non-empty suffix")
+        else:
+            return self.with_name(stem + suffix)
+
+    def with_suffix(self, suffix):
+        """Return a new path with the file suffix changed.  If the path
+        has no suffix, add given suffix.  If the given suffix is an empty
+        string, remove the suffix from the path.
+        """
+        stem = self.stem
+        if not stem:
+            # If the stem is empty, we can't make the suffix non-empty.
+            raise ValueError(f"{self!r} has an empty name")
+        elif suffix and not (suffix.startswith('.') and len(suffix) > 1):
+            raise ValueError(f"Invalid suffix {suffix!r}")
+        else:
+            return self.with_name(stem + suffix)
+
+    def relative_to(self, other, *, walk_up=False):
+        """Return the relative path to another path identified by the passed
+        arguments.  If the operation is not possible (because this is not
+        related to the other path), raise ValueError.
+
+        The *walk_up* parameter controls whether `..` may be used to resolve
+        the path.
+        """
+        if not isinstance(other, PurePathBase):
+            other = self.with_segments(other)
+        anchor0, parts0 = self._stack
+        anchor1, parts1 = other._stack
+        if anchor0 != anchor1:
+            raise ValueError(f"{self._raw_path!r} and {other._raw_path!r} have different anchors")
+        while parts0 and parts1 and parts0[-1] == parts1[-1]:
+            parts0.pop()
+            parts1.pop()
+        for part in parts1:
+            if not part or part == '.':
+                pass
+            elif not walk_up:
+                raise ValueError(f"{self._raw_path!r} is not in the subpath of {other._raw_path!r}")
+            elif part == '..':
+                raise ValueError(f"'..' segment in {other._raw_path!r} cannot be walked")
+            else:
+                parts0.append('..')
+        return self.with_segments('', *reversed(parts0))
+
+    def is_relative_to(self, other):
+        """Return True if the path is relative to another path or False.
+        """
+        if not isinstance(other, PurePathBase):
+            other = self.with_segments(other)
+        anchor0, parts0 = self._stack
+        anchor1, parts1 = other._stack
+        if anchor0 != anchor1:
+            return False
+        while parts0 and parts1 and parts0[-1] == parts1[-1]:
+            parts0.pop()
+            parts1.pop()
+        for part in parts1:
+            if part and part != '.':
+                return False
+        return True
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        anchor, parts = self._stack
+        if anchor:
+            parts.append(anchor)
+        return tuple(reversed(parts))
+
+    def joinpath(self, *pathsegments):
+        """Combine this path with one or several arguments, and return a
+        new path representing either a subpath (if all arguments are relative
+        paths) or a totally different path (if one of the arguments is
+        anchored).
+        """
+        return self.with_segments(self._raw_path, *pathsegments)
+
+    def __truediv__(self, key):
+        try:
+            return self.with_segments(self._raw_path, key)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, key):
+        try:
+            return self.with_segments(key, self._raw_path)
+        except TypeError:
+            return NotImplemented
+
+    @property
+    def _stack(self):
+        """
+        Split the path into a 2-tuple (anchor, parts), where *anchor* is the
+        uppermost parent of the path (equivalent to path.parents[-1]), and
+        *parts* is a reversed list of parts following the anchor.
+        """
+        split = self.parser.split
+        path = self._raw_path
+        parent, name = split(path)
+        names = []
+        while path != parent:
+            names.append(name)
+            path = parent
+            parent, name = split(path)
+        return path, names
+
+    @property
+    def parent(self):
+        """The logical parent of the path."""
+        path = self._raw_path
+        parent = self.parser.split(path)[0]
+        if path != parent:
+            parent = self.with_segments(parent)
+            parent._resolving = self._resolving
+            return parent
+        return self
+
+    @property
+    def parents(self):
+        """A sequence of this path's logical parents."""
+        split = self.parser.split
+        path = self._raw_path
+        parent = split(path)[0]
+        parents = []
+        while path != parent:
+            parents.append(self.with_segments(parent))
+            path = parent
+            parent = split(path)[0]
+        return tuple(parents)
+
+    def is_absolute(self):
+        """True if the path is absolute (has both a root and, if applicable,
+        a drive)."""
+        return self.parser.isabs(self._raw_path)
+
+    @property
+    def _pattern_str(self):
+        """The path expressed as a string, for use in pattern-matching."""
+        return str(self)
+
+    def match(self, path_pattern, *, case_sensitive=None):
+        """
+        Return True if this path matches the given pattern. If the pattern is
+        relative, matching is done from the right; otherwise, the entire path
+        is matched. The recursive wildcard '**' is *not* supported by this
+        method.
+        """
+        if not isinstance(path_pattern, PurePathBase):
+            path_pattern = self.with_segments(path_pattern)
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+        sep = path_pattern.parser.sep
+        path_parts = self.parts[::-1]
+        pattern_parts = path_pattern.parts[::-1]
+        if not pattern_parts:
+            raise ValueError("empty pattern")
+        if len(path_parts) < len(pattern_parts):
+            return False
+        if len(path_parts) > len(pattern_parts) and path_pattern.anchor:
+            return False
+        globber = self._globber(sep, case_sensitive)
+        for path_part, pattern_part in zip(path_parts, pattern_parts):
+            match = globber.compile(pattern_part)
+            if match(path_part) is None:
+                return False
+        return True
+
+    def full_match(self, pattern, *, case_sensitive=None):
+        """
+        Return True if this path matches the given glob-style pattern. The
+        pattern is matched against the entire path.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+        globber = self._globber(pattern.parser.sep, case_sensitive, recursive=True)
+        match = globber.compile(pattern._pattern_str)
+        return match(self._pattern_str) is not None
+
+
+
+class PathBase(PurePathBase):
+    """Base class for concrete path objects.
+
+    This class provides dummy implementations for many methods that derived
+    classes can override selectively; the default implementations raise
+    UnsupportedOperation. The most basic methods, such as stat() and open(),
+    directly raise UnsupportedOperation; these basic methods are called by
+    other methods such as is_dir() and read_text().
+
+    The Path class derives this class to implement local filesystem paths.
+    Users may derive their own classes to implement virtual filesystem paths,
+    such as paths in archive files or on remote storage systems.
+    """
+    __slots__ = ()
+
+    # Maximum number of symlinks to follow in resolve()
+    _max_symlinks = 40
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported"
+
+    def stat(self, *, follow_symlinks=True):
+        """
+        Return the result of the stat() system call on this path, like
+        os.stat() does.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('stat()'))
+
+    def lstat(self):
+        """
+        Like stat(), except if the path points to a symlink, the symlink's
+        status information is returned, rather than its target's.
+        """
+        return self.stat(follow_symlinks=False)
+
+
+    # Convenience functions for querying the stat results
+
+    def exists(self, *, follow_symlinks=True):
+        """
+        Whether this path exists.
+
+        This method normally follows symlinks; to check whether a symlink exists,
+        add the argument follow_symlinks=False.
+        """
+        try:
+            self.stat(follow_symlinks=follow_symlinks)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+        return True
+
+    def is_dir(self, *, follow_symlinks=True):
+        """
+        Whether this path is a directory.
+        """
+        try:
+            return S_ISDIR(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_file(self, *, follow_symlinks=True):
+        """
+        Whether this path is a regular file (also True for symlinks pointing
+        to regular files).
+        """
+        try:
+            return S_ISREG(self.stat(follow_symlinks=follow_symlinks).st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_mount(self):
+        """
+        Check if this path is a mount point
+        """
+        # Need to exist and be a dir
+        if not self.exists() or not self.is_dir():
+            return False
+
+        try:
+            parent_dev = self.parent.stat().st_dev
+        except OSError:
+            return False
+
+        dev = self.stat().st_dev
+        if dev != parent_dev:
+            return True
+        ino = self.stat().st_ino
+        parent_ino = self.parent.stat().st_ino
+        return ino == parent_ino
+
+    def is_symlink(self):
+        """
+        Whether this path is a symbolic link.
+        """
+        try:
+            return S_ISLNK(self.lstat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_junction(self):
+        """
+        Whether this path is a junction.
+        """
+        # Junctions are a Windows-only feature, not present in POSIX nor the
+        # majority of virtual filesystems. There is no cross-platform idiom
+        # to check for junctions (using stat().st_mode).
+        return False
+
+    def is_block_device(self):
+        """
+        Whether this path is a block device.
+        """
+        try:
+            return S_ISBLK(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_char_device(self):
+        """
+        Whether this path is a character device.
+        """
+        try:
+            return S_ISCHR(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_fifo(self):
+        """
+        Whether this path is a FIFO.
+        """
+        try:
+            return S_ISFIFO(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def is_socket(self):
+        """
+        Whether this path is a socket.
+        """
+        try:
+            return S_ISSOCK(self.stat().st_mode)
+        except OSError as e:
+            if not _ignore_error(e):
+                raise
+            # Path doesn't exist or is a broken symlink
+            # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ )
+            return False
+        except ValueError:
+            # Non-encodable path
+            return False
+
+    def samefile(self, other_path):
+        """Return whether other_path is the same or not as this file
+        (as returned by os.path.samefile()).
+        """
+        st = self.stat()
+        try:
+            other_st = other_path.stat()
+        except AttributeError:
+            other_st = self.with_segments(other_path).stat()
+        return (st.st_ino == other_st.st_ino and
+                st.st_dev == other_st.st_dev)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        """
+        Open the file pointed to by this path and return a file object, as
+        the built-in open() function does.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('open()'))
+
+    def read_bytes(self):
+        """
+        Open the file in bytes mode, read it, and close the file.
+        """
+        with self.open(mode='rb') as f:
+            return f.read()
+
+    def read_text(self, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, read it, and close the file.
+        """
+        with self.open(mode='r', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.read()
+
+    def write_bytes(self, data):
+        """
+        Open the file in bytes mode, write to it, and close the file.
+        """
+        # type-check for the buffer interface before truncating the file
+        view = memoryview(data)
+        with self.open(mode='wb') as f:
+            return f.write(view)
+
+    def write_text(self, data, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, write to it, and close the file.
+        """
+        if not isinstance(data, str):
+            raise TypeError('data must be str, not %s' %
+                            data.__class__.__name__)
+        with self.open(mode='w', encoding=encoding, errors=errors, newline=newline) as f:
+            return f.write(data)
+
+    def iterdir(self):
+        """Yield path objects of the directory contents.
+
+        The children are yielded in arbitrary order, and the
+        special entries '.' and '..' are not included.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('iterdir()'))
+
+    def _glob_selector(self, parts, case_sensitive, recurse_symlinks):
+        if case_sensitive is None:
+            case_sensitive = _is_case_sensitive(self.parser)
+            case_pedantic = False
+        else:
+            # The user has expressed a case sensitivity choice, but we don't
+            # know the case sensitivity of the underlying filesystem, so we
+            # must use scandir() for everything, including non-wildcard parts.
+            case_pedantic = True
+        recursive = True if recurse_symlinks else _no_recurse_symlinks
+        globber = self._globber(self.parser.sep, case_sensitive, case_pedantic, recursive)
+        return globber.selector(parts)
+
+    def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
+        """Iterate over this subtree and yield all existing files (of any
+        kind, including directories) matching the given relative pattern.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        anchor, parts = pattern._stack
+        if anchor:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        select = self._glob_selector(parts, case_sensitive, recurse_symlinks)
+        return select(self)
+
+    def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=True):
+        """Recursively yield all existing files (of any kind, including
+        directories) matching the given relative pattern, anywhere in
+        this subtree.
+        """
+        if not isinstance(pattern, PurePathBase):
+            pattern = self.with_segments(pattern)
+        pattern = '**' / pattern
+        return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
+
+    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+        """Walk the directory tree from this directory, similar to os.walk()."""
+        paths = [self]
+        while paths:
+            path = paths.pop()
+            if isinstance(path, tuple):
+                yield path
+                continue
+            dirnames = []
+            filenames = []
+            if not top_down:
+                paths.append((path, dirnames, filenames))
+            try:
+                for child in path.iterdir():
+                    try:
+                        if child.is_dir(follow_symlinks=follow_symlinks):
+                            if not top_down:
+                                paths.append(child)
+                            dirnames.append(child.name)
+                        else:
+                            filenames.append(child.name)
+                    except OSError:
+                        filenames.append(child.name)
+            except OSError as error:
+                if on_error is not None:
+                    on_error(error)
+                if not top_down:
+                    while not isinstance(paths.pop(), tuple):
+                        pass
+                continue
+            if top_down:
+                yield path, dirnames, filenames
+                paths += [path.joinpath(d) for d in reversed(dirnames)]
+
+    def absolute(self):
+        """Return an absolute version of this path
+        No normalization or symlink resolution is performed.
+
+        Use resolve() to resolve symlinks and remove '..' segments.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('absolute()'))
+
+    @classmethod
+    def cwd(cls):
+        """Return a new path pointing to the current working directory."""
+        # We call 'absolute()' rather than using 'os.getcwd()' directly to
+        # enable users to replace the implementation of 'absolute()' in a
+        # subclass and benefit from the new behaviour here. This works because
+        # os.path.abspath('.') == os.getcwd().
+        return cls('').absolute()
+
+    def expanduser(self):
+        """ Return a new path with expanded ~ and ~user constructs
+        (as returned by os.path.expanduser)
+        """
+        raise UnsupportedOperation(self._unsupported_msg('expanduser()'))
+
+    @classmethod
+    def home(cls):
+        """Return a new path pointing to expanduser('~').
+        """
+        return cls("~").expanduser()
+
+    def readlink(self):
+        """
+        Return the path to which the symbolic link points.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('readlink()'))
+    readlink._supported = False
+
+    def resolve(self, strict=False):
+        """
+        Make the path absolute, resolving all symlinks on the way and also
+        normalizing it.
+        """
+        if self._resolving:
+            return self
+        path_root, parts = self._stack
+        path = self.with_segments(path_root)
+        try:
+            path = path.absolute()
+        except UnsupportedOperation:
+            path_tail = []
+        else:
+            path_root, path_tail = path._stack
+            path_tail.reverse()
+
+        # If the user has *not* overridden the `readlink()` method, then symlinks are unsupported
+        # and (in non-strict mode) we can improve performance by not calling `stat()`.
+        querying = strict or getattr(self.readlink, '_supported', True)
+        link_count = 0
+        while parts:
+            part = parts.pop()
+            if not part or part == '.':
+                continue
+            if part == '..':
+                if not path_tail:
+                    if path_root:
+                        # Delete '..' segment immediately following root
+                        continue
+                elif path_tail[-1] != '..':
+                    # Delete '..' segment and its predecessor
+                    path_tail.pop()
+                    continue
+            path_tail.append(part)
+            if querying and part != '..':
+                path = self.with_segments(path_root + self.parser.sep.join(path_tail))
+                path._resolving = True
+                try:
+                    st = path.stat(follow_symlinks=False)
+                    if S_ISLNK(st.st_mode):
+                        # Like Linux and macOS, raise OSError(errno.ELOOP) if too many symlinks are
+                        # encountered during resolution.
+                        link_count += 1
+                        if link_count >= self._max_symlinks:
+                            raise OSError(ELOOP, "Too many symbolic links in path", self._raw_path)
+                        target_root, target_parts = path.readlink()._stack
+                        # If the symlink target is absolute (like '/etc/hosts'), set the current
+                        # path to its uppermost parent (like '/').
+                        if target_root:
+                            path_root = target_root
+                            path_tail.clear()
+                        else:
+                            path_tail.pop()
+                        # Add the symlink target's reversed tail parts (like ['hosts', 'etc']) to
+                        # the stack of unresolved path parts.
+                        parts.extend(target_parts)
+                        continue
+                    elif parts and not S_ISDIR(st.st_mode):
+                        raise NotADirectoryError(ENOTDIR, "Not a directory", self._raw_path)
+                except OSError:
+                    if strict:
+                        raise
+                    else:
+                        querying = False
+        return self.with_segments(path_root + self.parser.sep.join(path_tail))
+
+    def symlink_to(self, target, target_is_directory=False):
+        """
+        Make this path a symlink pointing to the target path.
+        Note the order of arguments (link, target) is the reverse of os.symlink.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('symlink_to()'))
+
+    def hardlink_to(self, target):
+        """
+        Make this path a hard link pointing to the same file as *target*.
+
+        Note the order of arguments (self, target) is the reverse of os.link's.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('hardlink_to()'))
+
+    def touch(self, mode=0o666, exist_ok=True):
+        """
+        Create this file with the given access mode, if it doesn't exist.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('touch()'))
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        """
+        Create a new directory at this given path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('mkdir()'))
+
+    def rename(self, target):
+        """
+        Rename this path to the target path.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('rename()'))
+
+    def replace(self, target):
+        """
+        Rename this path to the target path, overwriting if that path exists.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('replace()'))
+
+    def chmod(self, mode, *, follow_symlinks=True):
+        """
+        Change the permissions of the path, like os.chmod().
+        """
+        raise UnsupportedOperation(self._unsupported_msg('chmod()'))
+
+    def lchmod(self, mode):
+        """
+        Like chmod(), except if the path points to a symlink, the symlink's
+        permissions are changed, rather than its target's.
+        """
+        self.chmod(mode, follow_symlinks=False)
+
+    def unlink(self, missing_ok=False):
+        """
+        Remove this file or link.
+        If the path is a directory, use rmdir() instead.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('unlink()'))
+
+    def rmdir(self):
+        """
+        Remove this directory.  The directory must be empty.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('rmdir()'))
+
+    def owner(self, *, follow_symlinks=True):
+        """
+        Return the login name of the file owner.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('owner()'))
+
+    def group(self, *, follow_symlinks=True):
+        """
+        Return the group name of the file gid.
+        """
+        raise UnsupportedOperation(self._unsupported_msg('group()'))
+
+    @classmethod
+    def from_uri(cls, uri):
+        """Return a new path from the given 'file' URI."""
+        raise UnsupportedOperation(cls._unsupported_msg('from_uri()'))
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        raise UnsupportedOperation(self._unsupported_msg('as_uri()'))
diff --git a/Lib/pathlib/_local.py b/Lib/pathlib/_local.py
new file mode 100644
index 0000000000..0188e7c772
--- /dev/null
+++ b/Lib/pathlib/_local.py
@@ -0,0 +1,861 @@
+import io
+import ntpath
+import operator
+import os
+import posixpath
+import sys
+import warnings
+from glob import _StringGlobber
+from itertools import chain
+from _collections_abc import Sequence
+
+try:
+    import pwd
+except ImportError:
+    pwd = None
+try:
+    import grp
+except ImportError:
+    grp = None
+
+from ._abc import UnsupportedOperation, PurePathBase, PathBase
+
+
+__all__ = [
+    "PurePath", "PurePosixPath", "PureWindowsPath",
+    "Path", "PosixPath", "WindowsPath",
+    ]
+
+
+class _PathParents(Sequence):
+    """This object provides sequence-like access to the logical ancestors
+    of a path.  Don't try to construct it yourself."""
+    __slots__ = ('_path', '_drv', '_root', '_tail')
+
+    def __init__(self, path):
+        self._path = path
+        self._drv = path.drive
+        self._root = path.root
+        self._tail = path._tail
+
+    def __len__(self):
+        return len(self._tail)
+
+    def __getitem__(self, idx):
+        if isinstance(idx, slice):
+            return tuple(self[i] for i in range(*idx.indices(len(self))))
+
+        if idx >= len(self) or idx < -len(self):
+            raise IndexError(idx)
+        if idx < 0:
+            idx += len(self)
+        return self._path._from_parsed_parts(self._drv, self._root,
+                                             self._tail[:-idx - 1])
+
+    def __repr__(self):
+        return "<{}.parents>".format(type(self._path).__name__)
+
+
+class PurePath(PurePathBase):
+    """Base class for manipulating paths without I/O.
+
+    PurePath represents a filesystem path and offers operations which
+    don't imply any actual filesystem I/O.  Depending on your system,
+    instantiating a PurePath will return either a PurePosixPath or a
+    PureWindowsPath object.  You can also instantiate either of these classes
+    directly, regardless of your system.
+    """
+
+    __slots__ = (
+        # The `_raw_paths` slot stores unnormalized string paths. This is set
+        # in the `__init__()` method.
+        '_raw_paths',
+
+        # The `_drv`, `_root` and `_tail_cached` slots store parsed and
+        # normalized parts of the path. They are set when any of the `drive`,
+        # `root` or `_tail` properties are accessed for the first time. The
+        # three-part division corresponds to the result of
+        # `os.path.splitroot()`, except that the tail is further split on path
+        # separators (i.e. it is a list of strings), and that the root and
+        # tail are normalized.
+        '_drv', '_root', '_tail_cached',
+
+        # The `_str` slot stores the string representation of the path,
+        # computed from the drive, root and tail when `__str__()` is called
+        # for the first time. It's used to implement `_str_normcase`
+        '_str',
+
+        # The `_str_normcase_cached` slot stores the string path with
+        # normalized case. It is set when the `_str_normcase` property is
+        # accessed for the first time. It's used to implement `__eq__()`
+        # `__hash__()`, and `_parts_normcase`
+        '_str_normcase_cached',
+
+        # The `_parts_normcase_cached` slot stores the case-normalized
+        # string path after splitting on path separators. It's set when the
+        # `_parts_normcase` property is accessed for the first time. It's used
+        # to implement comparison methods like `__lt__()`.
+        '_parts_normcase_cached',
+
+        # The `_hash` slot stores the hash of the case-normalized string
+        # path. It's set when `__hash__()` is called for the first time.
+        '_hash',
+    )
+    parser = os.path
+    _globber = _StringGlobber
+
+    def __new__(cls, *args, **kwargs):
+        """Construct a PurePath from one or several strings and or existing
+        PurePath objects.  The strings and path objects are combined so as
+        to yield a canonicalized path, which is incorporated into the
+        new PurePath object.
+        """
+        if cls is PurePath:
+            cls = PureWindowsPath if os.name == 'nt' else PurePosixPath
+        return object.__new__(cls)
+
+    def __init__(self, *args):
+        paths = []
+        for arg in args:
+            if isinstance(arg, PurePath):
+                if arg.parser is not self.parser:
+                    # GH-103631: Convert separators for backwards compatibility.
+                    paths.append(arg.as_posix())
+                else:
+                    paths.extend(arg._raw_paths)
+            else:
+                try:
+                    path = os.fspath(arg)
+                except TypeError:
+                    path = arg
+                if not isinstance(path, str):
+                    raise TypeError(
+                        "argument should be a str or an os.PathLike "
+                        "object where __fspath__ returns a str, "
+                        f"not {type(path).__name__!r}")
+                paths.append(path)
+        # Avoid calling super().__init__, as an optimisation
+        self._raw_paths = paths
+
+    def joinpath(self, *pathsegments):
+        """Combine this path with one or several arguments, and return a
+        new path representing either a subpath (if all arguments are relative
+        paths) or a totally different path (if one of the arguments is
+        anchored).
+        """
+        return self.with_segments(self, *pathsegments)
+
+    def __truediv__(self, key):
+        try:
+            return self.with_segments(self, key)
+        except TypeError:
+            return NotImplemented
+
+    def __rtruediv__(self, key):
+        try:
+            return self.with_segments(key, self)
+        except TypeError:
+            return NotImplemented
+
+    def __reduce__(self):
+        return self.__class__, tuple(self._raw_paths)
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+    def __fspath__(self):
+        return str(self)
+
+    def __bytes__(self):
+        """Return the bytes representation of the path.  This is only
+        recommended to use under Unix."""
+        return os.fsencode(self)
+
+    @property
+    def _str_normcase(self):
+        # String with normalized case, for hashing and equality checks
+        try:
+            return self._str_normcase_cached
+        except AttributeError:
+            if self.parser is posixpath:
+                self._str_normcase_cached = str(self)
+            else:
+                self._str_normcase_cached = str(self).lower()
+            return self._str_normcase_cached
+
+    def __hash__(self):
+        try:
+            return self._hash
+        except AttributeError:
+            self._hash = hash(self._str_normcase)
+            return self._hash
+
+    def __eq__(self, other):
+        if not isinstance(other, PurePath):
+            return NotImplemented
+        return self._str_normcase == other._str_normcase and self.parser is other.parser
+
+    @property
+    def _parts_normcase(self):
+        # Cached parts with normalized case, for comparisons.
+        try:
+            return self._parts_normcase_cached
+        except AttributeError:
+            self._parts_normcase_cached = self._str_normcase.split(self.parser.sep)
+            return self._parts_normcase_cached
+
+    def __lt__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase < other._parts_normcase
+
+    def __le__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase <= other._parts_normcase
+
+    def __gt__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase > other._parts_normcase
+
+    def __ge__(self, other):
+        if not isinstance(other, PurePath) or self.parser is not other.parser:
+            return NotImplemented
+        return self._parts_normcase >= other._parts_normcase
+
+    def __str__(self):
+        """Return the string representation of the path, suitable for
+        passing to system calls."""
+        try:
+            return self._str
+        except AttributeError:
+            self._str = self._format_parsed_parts(self.drive, self.root,
+                                                  self._tail) or '.'
+            return self._str
+
+    @classmethod
+    def _format_parsed_parts(cls, drv, root, tail):
+        if drv or root:
+            return drv + root + cls.parser.sep.join(tail)
+        elif tail and cls.parser.splitdrive(tail[0])[0]:
+            tail = ['.'] + tail
+        return cls.parser.sep.join(tail)
+
+    def _from_parsed_parts(self, drv, root, tail):
+        path = self._from_parsed_string(self._format_parsed_parts(drv, root, tail))
+        path._drv = drv
+        path._root = root
+        path._tail_cached = tail
+        return path
+
+    def _from_parsed_string(self, path_str):
+        path = self.with_segments(path_str)
+        path._str = path_str or '.'
+        return path
+
+    @classmethod
+    def _parse_path(cls, path):
+        if not path:
+            return '', '', []
+        sep = cls.parser.sep
+        altsep = cls.parser.altsep
+        if altsep:
+            path = path.replace(altsep, sep)
+        drv, root, rel = cls.parser.splitroot(path)
+        if not root and drv.startswith(sep) and not drv.endswith(sep):
+            drv_parts = drv.split(sep)
+            if len(drv_parts) == 4 and drv_parts[2] not in '?.':
+                # e.g. //server/share
+                root = sep
+            elif len(drv_parts) == 6:
+                # e.g. //?/unc/server/share
+                root = sep
+        parsed = [sys.intern(str(x)) for x in rel.split(sep) if x and x != '.']
+        return drv, root, parsed
+
+    @property
+    def _raw_path(self):
+        """The joined but unnormalized path."""
+        paths = self._raw_paths
+        if len(paths) == 0:
+            path = ''
+        elif len(paths) == 1:
+            path = paths[0]
+        else:
+            path = self.parser.join(*paths)
+        return path
+
+    @property
+    def drive(self):
+        """The drive prefix (letter or UNC path), if any."""
+        try:
+            return self._drv
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._drv
+
+    @property
+    def root(self):
+        """The root of the path, if any."""
+        try:
+            return self._root
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._root
+
+    @property
+    def _tail(self):
+        try:
+            return self._tail_cached
+        except AttributeError:
+            self._drv, self._root, self._tail_cached = self._parse_path(self._raw_path)
+            return self._tail_cached
+
+    @property
+    def anchor(self):
+        """The concatenation of the drive and root, or ''."""
+        return self.drive + self.root
+
+    @property
+    def parts(self):
+        """An object providing sequence-like access to the
+        components in the filesystem path."""
+        if self.drive or self.root:
+            return (self.drive + self.root,) + tuple(self._tail)
+        else:
+            return tuple(self._tail)
+
+    @property
+    def parent(self):
+        """The logical parent of the path."""
+        drv = self.drive
+        root = self.root
+        tail = self._tail
+        if not tail:
+            return self
+        return self._from_parsed_parts(drv, root, tail[:-1])
+
+    @property
+    def parents(self):
+        """A sequence of this path's logical parents."""
+        # The value of this property should not be cached on the path object,
+        # as doing so would introduce a reference cycle.
+        return _PathParents(self)
+
+    @property
+    def name(self):
+        """The final path component, if any."""
+        tail = self._tail
+        if not tail:
+            return ''
+        return tail[-1]
+
+    def with_name(self, name):
+        """Return a new path with the file name changed."""
+        p = self.parser
+        if not name or p.sep in name or (p.altsep and p.altsep in name) or name == '.':
+            raise ValueError(f"Invalid name {name!r}")
+        tail = self._tail.copy()
+        if not tail:
+            raise ValueError(f"{self!r} has an empty name")
+        tail[-1] = name
+        return self._from_parsed_parts(self.drive, self.root, tail)
+
+    def relative_to(self, other, /, *_deprecated, walk_up=False):
+        """Return the relative path to another path identified by the passed
+        arguments.  If the operation is not possible (because this is not
+        related to the other path), raise ValueError.
+
+        The *walk_up* parameter controls whether `..` may be used to resolve
+        the path.
+        """
+        if _deprecated:
+            msg = ("support for supplying more than one positional argument "
+                   "to pathlib.PurePath.relative_to() is deprecated and "
+                   "scheduled for removal in Python 3.14")
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            other = self.with_segments(other, *_deprecated)
+        elif not isinstance(other, PurePath):
+            other = self.with_segments(other)
+        for step, path in enumerate(chain([other], other.parents)):
+            if path == self or path in self.parents:
+                break
+            elif not walk_up:
+                raise ValueError(f"{str(self)!r} is not in the subpath of {str(other)!r}")
+            elif path.name == '..':
+                raise ValueError(f"'..' segment in {str(other)!r} cannot be walked")
+        else:
+            raise ValueError(f"{str(self)!r} and {str(other)!r} have different anchors")
+        parts = ['..'] * step + self._tail[len(path._tail):]
+        return self._from_parsed_parts('', '', parts)
+
+    def is_relative_to(self, other, /, *_deprecated):
+        """Return True if the path is relative to another path or False.
+        """
+        if _deprecated:
+            msg = ("support for supplying more than one argument to "
+                   "pathlib.PurePath.is_relative_to() is deprecated and "
+                   "scheduled for removal in Python 3.14")
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            other = self.with_segments(other, *_deprecated)
+        elif not isinstance(other, PurePath):
+            other = self.with_segments(other)
+        return other == self or other in self.parents
+
+    def is_absolute(self):
+        """True if the path is absolute (has both a root and, if applicable,
+        a drive)."""
+        if self.parser is posixpath:
+            # Optimization: work with raw paths on POSIX.
+            for path in self._raw_paths:
+                if path.startswith('/'):
+                    return True
+            return False
+        return self.parser.isabs(self)
+
+    def is_reserved(self):
+        """Return True if the path contains one of the special names reserved
+        by the system, if any."""
+        msg = ("pathlib.PurePath.is_reserved() is deprecated and scheduled "
+               "for removal in Python 3.15. Use os.path.isreserved() to "
+               "detect reserved paths on Windows.")
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        if self.parser is ntpath:
+            return self.parser.isreserved(self)
+        return False
+
+    def as_uri(self):
+        """Return the path as a URI."""
+        if not self.is_absolute():
+            raise ValueError("relative path can't be expressed as a file URI")
+
+        drive = self.drive
+        if len(drive) == 2 and drive[1] == ':':
+            # It's a path on a local drive => 'file:///c:/a/b'
+            prefix = 'file:///' + drive
+            path = self.as_posix()[2:]
+        elif drive:
+            # It's a path on a network drive => 'file://host/share/a/b'
+            prefix = 'file:'
+            path = self.as_posix()
+        else:
+            # It's a posix path => 'file:///etc/hosts'
+            prefix = 'file://'
+            path = str(self)
+        from urllib.parse import quote_from_bytes
+        return prefix + quote_from_bytes(os.fsencode(path))
+
+    @property
+    def _pattern_str(self):
+        """The path expressed as a string, for use in pattern-matching."""
+        # The string representation of an empty path is a single dot ('.'). Empty
+        # paths shouldn't match wildcards, so we change it to the empty string.
+        path_str = str(self)
+        return '' if path_str == '.' else path_str
+
+# Subclassing os.PathLike makes isinstance() checks slower,
+# which in turn makes Path construction slower. Register instead!
+os.PathLike.register(PurePath)
+
+
+class PurePosixPath(PurePath):
+    """PurePath subclass for non-Windows systems.
+
+    On a POSIX system, instantiating a PurePath should return this object.
+    However, you can also instantiate it directly on any system.
+    """
+    parser = posixpath
+    __slots__ = ()
+
+
+class PureWindowsPath(PurePath):
+    """PurePath subclass for Windows systems.
+
+    On a Windows system, instantiating a PurePath should return this object.
+    However, you can also instantiate it directly on any system.
+    """
+    parser = ntpath
+    __slots__ = ()
+
+
+class Path(PathBase, PurePath):
+    """PurePath subclass that can make system calls.
+
+    Path represents a filesystem path but unlike PurePath, also offers
+    methods to do system calls on path objects. Depending on your system,
+    instantiating a Path will return either a PosixPath or a WindowsPath
+    object. You can also instantiate a PosixPath or WindowsPath directly,
+    but cannot instantiate a WindowsPath on a POSIX system or vice versa.
+    """
+    __slots__ = ()
+    as_uri = PurePath.as_uri
+
+    @classmethod
+    def _unsupported_msg(cls, attribute):
+        return f"{cls.__name__}.{attribute} is unsupported on this system"
+
+    def __init__(self, *args, **kwargs):
+        if kwargs:
+            msg = ("support for supplying keyword arguments to pathlib.PurePath "
+                   "is deprecated and scheduled for removal in Python {remove}")
+            warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
+        super().__init__(*args)
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Path:
+            cls = WindowsPath if os.name == 'nt' else PosixPath
+        return object.__new__(cls)
+
+    def stat(self, *, follow_symlinks=True):
+        """
+        Return the result of the stat() system call on this path, like
+        os.stat() does.
+        """
+        return os.stat(self, follow_symlinks=follow_symlinks)
+
+    def is_mount(self):
+        """
+        Check if this path is a mount point
+        """
+        return os.path.ismount(self)
+
+    def is_junction(self):
+        """
+        Whether this path is a junction.
+        """
+        return os.path.isjunction(self)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        """
+        Open the file pointed to by this path and return a file object, as
+        the built-in open() function does.
+        """
+        if "b" not in mode:
+            encoding = io.text_encoding(encoding)
+        return io.open(self, mode, buffering, encoding, errors, newline)
+
+    def read_text(self, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, read it, and close the file.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        return PathBase.read_text(self, encoding, errors, newline)
+
+    def write_text(self, data, encoding=None, errors=None, newline=None):
+        """
+        Open the file in text mode, write to it, and close the file.
+        """
+        # Call io.text_encoding() here to ensure any warning is raised at an
+        # appropriate stack level.
+        encoding = io.text_encoding(encoding)
+        return PathBase.write_text(self, data, encoding, errors, newline)
+
+    _remove_leading_dot = operator.itemgetter(slice(2, None))
+    _remove_trailing_slash = operator.itemgetter(slice(-1))
+
+    def _filter_trailing_slash(self, paths):
+        sep = self.parser.sep
+        anchor_len = len(self.anchor)
+        for path_str in paths:
+            if len(path_str) > anchor_len and path_str[-1] == sep:
+                path_str = path_str[:-1]
+            yield path_str
+
+    def iterdir(self):
+        """Yield path objects of the directory contents.
+
+        The children are yielded in arbitrary order, and the
+        special entries '.' and '..' are not included.
+        """
+        root_dir = str(self)
+        with os.scandir(root_dir) as scandir_it:
+            paths = [entry.path for entry in scandir_it]
+        if root_dir == '.':
+            paths = map(self._remove_leading_dot, paths)
+        return map(self._from_parsed_string, paths)
+
+    def glob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
+        """Iterate over this subtree and yield all existing files (of any
+        kind, including directories) matching the given relative pattern.
+        """
+        sys.audit("pathlib.Path.glob", self, pattern)
+        if not isinstance(pattern, PurePath):
+            pattern = self.with_segments(pattern)
+        if pattern.anchor:
+            raise NotImplementedError("Non-relative patterns are unsupported")
+        parts = pattern._tail.copy()
+        if not parts:
+            raise ValueError("Unacceptable pattern: {!r}".format(pattern))
+        raw = pattern._raw_path
+        if raw[-1] in (self.parser.sep, self.parser.altsep):
+            # GH-65238: pathlib doesn't preserve trailing slash. Add it back.
+            parts.append('')
+        select = self._glob_selector(parts[::-1], case_sensitive, recurse_symlinks)
+        root = str(self)
+        paths = select(root)
+
+        # Normalize results
+        if root == '.':
+            paths = map(self._remove_leading_dot, paths)
+        if parts[-1] == '':
+            paths = map(self._remove_trailing_slash, paths)
+        elif parts[-1] == '**':
+            paths = self._filter_trailing_slash(paths)
+        paths = map(self._from_parsed_string, paths)
+        return paths
+
+    def rglob(self, pattern, *, case_sensitive=None, recurse_symlinks=False):
+        """Recursively yield all existing files (of any kind, including
+        directories) matching the given relative pattern, anywhere in
+        this subtree.
+        """
+        sys.audit("pathlib.Path.rglob", self, pattern)
+        if not isinstance(pattern, PurePath):
+            pattern = self.with_segments(pattern)
+        pattern = '**' / pattern
+        return self.glob(pattern, case_sensitive=case_sensitive, recurse_symlinks=recurse_symlinks)
+
+    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+        """Walk the directory tree from this directory, similar to os.walk()."""
+        sys.audit("pathlib.Path.walk", self, on_error, follow_symlinks)
+        root_dir = str(self)
+        if not follow_symlinks:
+            follow_symlinks = os._walk_symlinks_as_files
+        results = os.walk(root_dir, top_down, on_error, follow_symlinks)
+        for path_str, dirnames, filenames in results:
+            if root_dir == '.':
+                path_str = path_str[2:]
+            yield self._from_parsed_string(path_str), dirnames, filenames
+
+    def absolute(self):
+        """Return an absolute version of this path
+        No normalization or symlink resolution is performed.
+
+        Use resolve() to resolve symlinks and remove '..' segments.
+        """
+        if self.is_absolute():
+            return self
+        if self.root:
+            drive = os.path.splitroot(os.getcwd())[0]
+            return self._from_parsed_parts(drive, self.root, self._tail)
+        if self.drive:
+            # There is a CWD on each drive-letter drive.
+            cwd = os.path.abspath(self.drive)
+        else:
+            cwd = os.getcwd()
+        if not self._tail:
+            # Fast path for "empty" paths, e.g. Path("."), Path("") or Path().
+            # We pass only one argument to with_segments() to avoid the cost
+            # of joining, and we exploit the fact that getcwd() returns a
+            # fully-normalized string by storing it in _str. This is used to
+            # implement Path.cwd().
+            return self._from_parsed_string(cwd)
+        drive, root, rel = os.path.splitroot(cwd)
+        if not rel:
+            return self._from_parsed_parts(drive, root, self._tail)
+        tail = rel.split(self.parser.sep)
+        tail.extend(self._tail)
+        return self._from_parsed_parts(drive, root, tail)
+
+    def resolve(self, strict=False):
+        """
+        Make the path absolute, resolving all symlinks on the way and also
+        normalizing it.
+        """
+
+        return self.with_segments(os.path.realpath(self, strict=strict))
+
+    if pwd:
+        def owner(self, *, follow_symlinks=True):
+            """
+            Return the login name of the file owner.
+            """
+            uid = self.stat(follow_symlinks=follow_symlinks).st_uid
+            return pwd.getpwuid(uid).pw_name
+
+    if grp:
+        def group(self, *, follow_symlinks=True):
+            """
+            Return the group name of the file gid.
+            """
+            gid = self.stat(follow_symlinks=follow_symlinks).st_gid
+            return grp.getgrgid(gid).gr_name
+
+    if hasattr(os, "readlink"):
+        def readlink(self):
+            """
+            Return the path to which the symbolic link points.
+            """
+            return self.with_segments(os.readlink(self))
+
+    def touch(self, mode=0o666, exist_ok=True):
+        """
+        Create this file with the given access mode, if it doesn't exist.
+        """
+
+        if exist_ok:
+            # First try to bump modification time
+            # Implementation note: GNU touch uses the UTIME_NOW option of
+            # the utimensat() / futimens() functions.
+            try:
+                os.utime(self, None)
+            except OSError:
+                # Avoid exception chaining
+                pass
+            else:
+                return
+        flags = os.O_CREAT | os.O_WRONLY
+        if not exist_ok:
+            flags |= os.O_EXCL
+        fd = os.open(self, flags, mode)
+        os.close(fd)
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        """
+        Create a new directory at this given path.
+        """
+        try:
+            os.mkdir(self, mode)
+        except FileNotFoundError:
+            if not parents or self.parent == self:
+                raise
+            self.parent.mkdir(parents=True, exist_ok=True)
+            self.mkdir(mode, parents=False, exist_ok=exist_ok)
+        except OSError:
+            # Cannot rely on checking for EEXIST, since the operating system
+            # could give priority to other errors like EACCES or EROFS
+            if not exist_ok or not self.is_dir():
+                raise
+
+    def chmod(self, mode, *, follow_symlinks=True):
+        """
+        Change the permissions of the path, like os.chmod().
+        """
+        os.chmod(self, mode, follow_symlinks=follow_symlinks)
+
+    def unlink(self, missing_ok=False):
+        """
+        Remove this file or link.
+        If the path is a directory, use rmdir() instead.
+        """
+        try:
+            os.unlink(self)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    def rmdir(self):
+        """
+        Remove this directory.  The directory must be empty.
+        """
+        os.rmdir(self)
+
+    def rename(self, target):
+        """
+        Rename this path to the target path.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        os.rename(self, target)
+        return self.with_segments(target)
+
+    def replace(self, target):
+        """
+        Rename this path to the target path, overwriting if that path exists.
+
+        The target path may be absolute or relative. Relative paths are
+        interpreted relative to the current working directory, *not* the
+        directory of the Path object.
+
+        Returns the new Path instance pointing to the target path.
+        """
+        os.replace(self, target)
+        return self.with_segments(target)
+
+    if hasattr(os, "symlink"):
+        def symlink_to(self, target, target_is_directory=False):
+            """
+            Make this path a symlink pointing to the target path.
+            Note the order of arguments (link, target) is the reverse of os.symlink.
+            """
+            os.symlink(target, self, target_is_directory)
+
+    if hasattr(os, "link"):
+        def hardlink_to(self, target):
+            """
+            Make this path a hard link pointing to the same file as *target*.
+
+            Note the order of arguments (self, target) is the reverse of os.link's.
+            """
+            os.link(target, self)
+
+    def expanduser(self):
+        """ Return a new path with expanded ~ and ~user constructs
+        (as returned by os.path.expanduser)
+        """
+        if (not (self.drive or self.root) and
+            self._tail and self._tail[0][:1] == '~'):
+            homedir = os.path.expanduser(self._tail[0])
+            if homedir[:1] == "~":
+                raise RuntimeError("Could not determine home directory.")
+            drv, root, tail = self._parse_path(homedir)
+            return self._from_parsed_parts(drv, root, tail + self._tail[1:])
+
+        return self
+
+    @classmethod
+    def from_uri(cls, uri):
+        """Return a new path from the given 'file' URI."""
+        if not uri.startswith('file:'):
+            raise ValueError(f"URI does not start with 'file:': {uri!r}")
+        path = uri[5:]
+        if path[:3] == '///':
+            # Remove empty authority
+            path = path[2:]
+        elif path[:12] == '//localhost/':
+            # Remove 'localhost' authority
+            path = path[11:]
+        if path[:3] == '///' or (path[:1] == '/' and path[2:3] in ':|'):
+            # Remove slash before DOS device/UNC path
+            path = path[1:]
+        if path[1:2] == '|':
+            # Replace bar with colon in DOS drive
+            path = path[:1] + ':' + path[2:]
+        from urllib.parse import unquote_to_bytes
+        path = cls(os.fsdecode(unquote_to_bytes(path)))
+        if not path.is_absolute():
+            raise ValueError(f"URI is not absolute: {uri!r}")
+        return path
+
+
+class PosixPath(Path, PurePosixPath):
+    """Path subclass for non-Windows systems.
+
+    On a POSIX system, instantiating a Path should return this object.
+    """
+    __slots__ = ()
+
+    if os.name == 'nt':
+        def __new__(cls, *args, **kwargs):
+            raise UnsupportedOperation(
+                f"cannot instantiate {cls.__name__!r} on your system")
+
+class WindowsPath(Path, PureWindowsPath):
+    """Path subclass for Windows systems.
+
+    On a Windows system, instantiating a Path should return this object.
+    """
+    __slots__ = ()
+
+    if os.name != 'nt':
+        def __new__(cls, *args, **kwargs):
+            raise UnsupportedOperation(
+                f"cannot instantiate {cls.__name__!r} on your system")
diff --git a/Lib/pickle.py b/Lib/pickle.py
index 6e3c61fd0b..550f8675f2 100644
--- a/Lib/pickle.py
+++ b/Lib/pickle.py
@@ -314,16 +314,17 @@ 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, obj))
+                                 .format(name, top))
         try:
             parent = obj
             obj = getattr(obj, subpath)
         except AttributeError:
             raise AttributeError("Can't get attribute {!r} on {!r}"
-                                 .format(name, obj)) from None
+                                 .format(name, top)) from None
     return obj, parent
 
 def whichmodule(obj, name):
@@ -396,6 +397,8 @@ def decode_long(data):
     return int.from_bytes(data, byteorder='little', signed=True)
 
 
+_NoValue = object()
+
 # Pickling machinery
 
 class _Pickler:
@@ -530,10 +533,11 @@ def save(self, obj, save_persistent_id=True):
         self.framer.commit_frame()
 
         # Check for persistent id (defined by a subclass)
-        pid = self.persistent_id(obj)
-        if pid is not None and save_persistent_id:
-            self.save_pers(pid)
-            return
+        if save_persistent_id:
+            pid = self.persistent_id(obj)
+            if pid is not None:
+                self.save_pers(pid)
+                return
 
         # Check the memo
         x = self.memo.get(id(obj))
@@ -542,8 +546,8 @@ def save(self, obj, save_persistent_id=True):
             return
 
         rv = NotImplemented
-        reduce = getattr(self, "reducer_override", None)
-        if reduce is not None:
+        reduce = getattr(self, "reducer_override", _NoValue)
+        if reduce is not _NoValue:
             rv = reduce(obj)
 
         if rv is NotImplemented:
@@ -556,8 +560,8 @@ def save(self, obj, save_persistent_id=True):
 
             # Check private dispatch table if any, or else
             # copyreg.dispatch_table
-            reduce = getattr(self, 'dispatch_table', dispatch_table).get(t)
-            if reduce is not None:
+            reduce = getattr(self, 'dispatch_table', dispatch_table).get(t, _NoValue)
+            if reduce is not _NoValue:
                 rv = reduce(obj)
             else:
                 # Check for a class with a custom metaclass; treat as regular
@@ -567,12 +571,12 @@ def save(self, obj, save_persistent_id=True):
                     return
 
                 # Check for a __reduce_ex__ method, fall back to __reduce__
-                reduce = getattr(obj, "__reduce_ex__", None)
-                if reduce is not None:
+                reduce = getattr(obj, "__reduce_ex__", _NoValue)
+                if reduce is not _NoValue:
                     rv = reduce(self.proto)
                 else:
-                    reduce = getattr(obj, "__reduce__", None)
-                    if reduce is not None:
+                    reduce = getattr(obj, "__reduce__", _NoValue)
+                    if reduce is not _NoValue:
                         rv = reduce()
                     else:
                         raise PicklingError("Can't pickle %r object: %r" %
@@ -780,14 +784,10 @@ def save_float(self, obj):
             self.write(FLOAT + repr(obj).encode("ascii") + b'\n')
     dispatch[float] = save_float
 
-    def save_bytes(self, obj):
-        if self.proto < 3:
-            if not obj: # bytes object is empty
-                self.save_reduce(bytes, (), obj=obj)
-            else:
-                self.save_reduce(codecs.encode,
-                                 (str(obj, 'latin1'), 'latin1'), obj=obj)
-            return
+    def _save_bytes_no_memo(self, obj):
+        # helper for writing bytes objects for protocol >= 3
+        # without memoizing them
+        assert self.proto >= 3
         n = len(obj)
         if n <= 0xff:
             self.write(SHORT_BINBYTES + pack("<B", n) + obj)
@@ -797,9 +797,29 @@ def save_bytes(self, obj):
             self._write_large_bytes(BINBYTES + pack("<I", n), obj)
         else:
             self.write(BINBYTES + pack("<I", n) + obj)
+
+    def save_bytes(self, obj):
+        if self.proto < 3:
+            if not obj: # bytes object is empty
+                self.save_reduce(bytes, (), obj=obj)
+            else:
+                self.save_reduce(codecs.encode,
+                                 (str(obj, 'latin1'), 'latin1'), obj=obj)
+            return
+        self._save_bytes_no_memo(obj)
         self.memoize(obj)
     dispatch[bytes] = save_bytes
 
+    def _save_bytearray_no_memo(self, obj):
+        # helper for writing bytearray objects for protocol >= 5
+        # without memoizing them
+        assert self.proto >= 5
+        n = len(obj)
+        if n >= self.framer._FRAME_SIZE_TARGET:
+            self._write_large_bytes(BYTEARRAY8 + pack("<Q", n), obj)
+        else:
+            self.write(BYTEARRAY8 + pack("<Q", n) + obj)
+
     def save_bytearray(self, obj):
         if self.proto < 5:
             if not obj:  # bytearray is empty
@@ -807,18 +827,14 @@ def save_bytearray(self, obj):
             else:
                 self.save_reduce(bytearray, (bytes(obj),), obj=obj)
             return
-        n = len(obj)
-        if n >= self.framer._FRAME_SIZE_TARGET:
-            self._write_large_bytes(BYTEARRAY8 + pack("<Q", n), obj)
-        else:
-            self.write(BYTEARRAY8 + pack("<Q", n) + obj)
+        self._save_bytearray_no_memo(obj)
         self.memoize(obj)
     dispatch[bytearray] = save_bytearray
 
     if _HAVE_PICKLE_BUFFER:
         def save_picklebuffer(self, obj):
             if self.proto < 5:
-                raise PicklingError("PickleBuffer can only pickled with "
+                raise PicklingError("PickleBuffer can only be pickled with "
                                     "protocol >= 5")
             with obj.raw() as m:
                 if not m.contiguous:
@@ -830,10 +846,18 @@ def save_picklebuffer(self, obj):
                 if in_band:
                     # Write data in-band
                     # XXX The C implementation avoids a copy here
+                    buf = m.tobytes()
+                    in_memo = id(buf) in self.memo
                     if m.readonly:
-                        self.save_bytes(m.tobytes())
+                        if in_memo:
+                            self._save_bytes_no_memo(buf)
+                        else:
+                            self.save_bytes(buf)
                     else:
-                        self.save_bytearray(m.tobytes())
+                        if in_memo:
+                            self._save_bytearray_no_memo(buf)
+                        else:
+                            self.save_bytearray(buf)
                 else:
                     # Write data out-of-band
                     self.write(NEXT_BUFFER)
@@ -1070,11 +1094,16 @@ def save_global(self, obj, name=None):
                     (obj, module_name, name))
 
         if self.proto >= 2:
-            code = _extension_registry.get((module_name, name))
-            if code:
-                assert code > 0
+            code = _extension_registry.get((module_name, name), _NoValue)
+            if code is not _NoValue:
                 if code <= 0xff:
-                    write(EXT1 + pack("<B", code))
+                    data = pack("<B", code)
+                    if data == b'\0':
+                        # Should never happen in normal circumstances,
+                        # since the type and the value of the code are
+                        # checked in copyreg.add_extension().
+                        raise RuntimeError("extension code 0 is out of range")
+                    write(EXT1 + data)
                 elif code <= 0xffff:
                     write(EXT2 + pack("<H", code))
                 else:
@@ -1088,11 +1117,35 @@ def save_global(self, obj, name=None):
             self.save(module_name)
             self.save(name)
             write(STACK_GLOBAL)
-        elif parent is not module:
-            self.save_reduce(getattr, (parent, lastname))
-        elif self.proto >= 3:
-            write(GLOBAL + bytes(module_name, "utf-8") + b'\n' +
-                  bytes(name, "utf-8") + b'\n')
+        elif '.' in name:
+            # In protocol < 4, objects with multi-part __qualname__
+            # are represented as
+            # getattr(getattr(..., attrname1), attrname2).
+            dotted_path = name.split('.')
+            name = dotted_path.pop(0)
+            save = self.save
+            for attrname in dotted_path:
+                save(getattr)
+                if self.proto < 2:
+                    write(MARK)
+            self._save_toplevel_by_name(module_name, name)
+            for attrname in dotted_path:
+                save(attrname)
+                if self.proto < 2:
+                    write(TUPLE)
+                else:
+                    write(TUPLE2)
+                write(REDUCE)
+        else:
+            self._save_toplevel_by_name(module_name, name)
+
+        self.memoize(obj)
+
+    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')
         else:
             if self.fix_imports:
                 r_name_mapping = _compat_pickle.REVERSE_NAME_MAPPING
@@ -1102,14 +1155,12 @@ def save_global(self, obj, name=None):
                 elif module_name in r_import_mapping:
                     module_name = r_import_mapping[module_name]
             try:
-                write(GLOBAL + bytes(module_name, "ascii") + b'\n' +
-                      bytes(name, "ascii") + b'\n')
+                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, self.proto)) from None
-
-        self.memoize(obj)
+                    "pickle protocol %i" % (module_name, name, self.proto)) from None
 
     def save_type(self, obj):
         if obj is type(None):
@@ -1546,9 +1597,8 @@ def load_ext4(self):
     dispatch[EXT4[0]] = load_ext4
 
     def get_extension(self, code):
-        nil = []
-        obj = _extension_cache.get(code, nil)
-        if obj is not nil:
+        obj = _extension_cache.get(code, _NoValue)
+        if obj is not _NoValue:
             self.append(obj)
             return
         key = _inverted_registry.get(code)
@@ -1705,8 +1755,8 @@ def load_build(self):
         stack = self.stack
         state = stack.pop()
         inst = stack[-1]
-        setstate = getattr(inst, "__setstate__", None)
-        if setstate is not None:
+        setstate = getattr(inst, "__setstate__", _NoValue)
+        if setstate is not _NoValue:
             setstate(state)
             return
         slotstate = None
diff --git a/Lib/pickletools.py b/Lib/pickletools.py
index 51ee4a7a26..33a51492ea 100644
--- a/Lib/pickletools.py
+++ b/Lib/pickletools.py
@@ -312,7 +312,7 @@ def read_uint8(f):
             doc="Eight-byte unsigned integer, little-endian.")
 
 
-def read_stringnl(f, decode=True, stripquotes=True):
+def read_stringnl(f, decode=True, stripquotes=True, *, encoding='latin-1'):
     r"""
     >>> import io
     >>> read_stringnl(io.BytesIO(b"'abcd'\nefg\n"))
@@ -356,7 +356,7 @@ def read_stringnl(f, decode=True, stripquotes=True):
             raise ValueError("no string quotes around %r" % data)
 
     if decode:
-        data = codecs.escape_decode(data)[0].decode("ascii")
+        data = codecs.escape_decode(data)[0].decode(encoding)
     return data
 
 stringnl = ArgumentDescriptor(
@@ -370,7 +370,7 @@ def read_stringnl(f, decode=True, stripquotes=True):
                    """)
 
 def read_stringnl_noescape(f):
-    return read_stringnl(f, stripquotes=False)
+    return read_stringnl(f, stripquotes=False, encoding='utf-8')
 
 stringnl_noescape = ArgumentDescriptor(
                         name='stringnl_noescape',
@@ -2513,7 +2513,10 @@ def dis(pickle, out=None, memo=None, indentlevel=4, annotate=0):
             # make a mild effort to align arguments
             line += ' ' * (10 - len(opcode.name))
             if arg is not None:
-                line += ' ' + repr(arg)
+                if opcode.name in ("STRING", "BINSTRING", "SHORT_BINSTRING"):
+                    line += ' ' + ascii(arg)
+                else:
+                    line += ' ' + repr(arg)
             if markmsg:
                 line += ' ' + markmsg
         if annotate:
diff --git a/Lib/pkgutil.py b/Lib/pkgutil.py
index a4c474006b..dccbec52aa 100644
--- a/Lib/pkgutil.py
+++ b/Lib/pkgutil.py
@@ -14,7 +14,7 @@
 __all__ = [
     'get_importer', 'iter_importers', 'get_loader', 'find_loader',
     'walk_packages', 'iter_modules', 'get_data',
-    'ImpImporter', 'ImpLoader', 'read_code', 'extend_path',
+    'read_code', 'extend_path',
     'ModuleInfo',
 ]
 
@@ -23,20 +23,6 @@
 ModuleInfo.__doc__ = 'A namedtuple with minimal info about a module.'
 
 
-def _get_spec(finder, name):
-    """Return the finder-specific module spec."""
-    # Works with legacy finders.
-    try:
-        find_spec = finder.find_spec
-    except AttributeError:
-        loader = finder.find_module(name)
-        if loader is None:
-            return None
-        return importlib.util.spec_from_loader(name, loader)
-    else:
-        return find_spec(name)
-
-
 def read_code(stream):
     # This helper is needed in order for the PEP 302 emulation to
     # correctly handle compiled files
@@ -184,6 +170,7 @@ def _iter_file_finder_modules(importer, prefix=''):
 iter_importer_modules.register(
     importlib.machinery.FileFinder, _iter_file_finder_modules)
 
+
 try:
     import zipimport
     from zipimport import zipimporter
@@ -231,6 +218,7 @@ def get_importer(path_item):
     The cache (or part of it) can be cleared manually if a
     rescan of sys.path_hooks is necessary.
     """
+    path_item = os.fsdecode(path_item)
     try:
         importer = sys.path_importer_cache[path_item]
     except KeyError:
@@ -282,6 +270,10 @@ def get_loader(module_or_name):
     If the named module is not already imported, its containing package
     (if any) is imported, in order to establish the package __path__.
     """
+    warnings._deprecated("pkgutil.get_loader",
+                         f"{warnings._DEPRECATED_MSG}; "
+                         "use importlib.util.find_spec() instead",
+                         remove=(3, 14))
     if module_or_name in sys.modules:
         module_or_name = sys.modules[module_or_name]
         if module_or_name is None:
@@ -306,6 +298,10 @@ def find_loader(fullname):
     importlib.util.find_spec that converts most failures to ImportError
     and only returns the loader rather than the full spec
     """
+    warnings._deprecated("pkgutil.find_loader",
+                         f"{warnings._DEPRECATED_MSG}; "
+                         "use importlib.util.find_spec() instead",
+                         remove=(3, 14))
     if fullname.startswith('.'):
         msg = "Relative module name {!r} not supported".format(fullname)
         raise ImportError(msg)
@@ -328,10 +324,10 @@ def extend_path(path, name):
         from pkgutil import extend_path
         __path__ = extend_path(__path__, __name__)
 
-    This will add to the package's __path__ all subdirectories of
-    directories on sys.path named after the package.  This is useful
-    if one wants to distribute different parts of a single logical
-    package as multiple directories.
+    For each directory on sys.path that has a subdirectory that
+    matches the package name, add the subdirectory to the package's
+    __path__.  This is useful if one wants to distribute different
+    parts of a single logical package as multiple directories.
 
     It also looks for *.pkg files beginning where * matches the name
     argument.  This feature is similar to *.pth files (see site.py),
diff --git a/Lib/platform.py b/Lib/platform.py
index 58b66078e1..1a533688a9 100755
--- a/Lib/platform.py
+++ b/Lib/platform.py
@@ -10,7 +10,8 @@
 """
 #    This module is maintained by Marc-Andre Lemburg <mal@egenix.com>.
 #    If you find problems, please submit bug reports/patches via the
-#    Python bug tracker (http://bugs.python.org) and assign them to "lemburg".
+#    Python issue tracker (https://github.com/python/cpython/issues) and
+#    mention "@malemburg".
 #
 #    Still needed:
 #    * support for MS-DOS (PythonDX ?)
@@ -118,6 +119,10 @@
 import sys
 import functools
 import itertools
+try:
+    import _wmi
+except ImportError:
+    _wmi = None
 
 ### Globals & Constants
 
@@ -136,11 +141,11 @@
     'pl': 200, 'p': 200,
 }
 
-_component_re = re.compile(r'([0-9]+|[._+-])')
 
 def _comparable_version(version):
+    component_re = re.compile(r'([0-9]+|[._+-])')
     result = []
-    for v in _component_re.split(version):
+    for v in component_re.split(version):
         if v not in '._+-':
             try:
                 v = int(v, 10)
@@ -152,11 +157,6 @@ def _comparable_version(version):
 
 ### Platform specific APIs
 
-_libc_search = re.compile(b'(__libc_init)'
-                          b'|'
-                          b'(GLIBC_([0-9.]+))'
-                          b'|'
-                          br'(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)', re.ASCII)
 
 def libc_ver(executable=None, lib='', version='', chunksize=16384):
 
@@ -190,6 +190,12 @@ def libc_ver(executable=None, lib='', version='', chunksize=16384):
             # sys.executable is not set.
             return lib, version
 
+    libc_search = re.compile(b'(__libc_init)'
+                          b'|'
+                          b'(GLIBC_([0-9.]+))'
+                          b'|'
+                          br'(libc(_\w+)?\.so(?:\.(\d[0-9.]*))?)', re.ASCII)
+
     V = _comparable_version
     # We use os.path.realpath()
     # here to work around problems with Cygwin not being
@@ -200,7 +206,7 @@ def libc_ver(executable=None, lib='', version='', chunksize=16384):
         pos = 0
         while pos < len(binary):
             if b'libc' in binary or b'GLIBC' in binary:
-                m = _libc_search.search(binary, pos)
+                m = libc_search.search(binary, pos)
             else:
                 m = None
             if not m or m.end() == len(binary):
@@ -247,9 +253,6 @@ def _norm_version(version, build=''):
     version = '.'.join(strings[:3])
     return version
 
-_ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
-                         r'.*'
-                         r'\[.* ([\d.]+)\])')
 
 # Examples of VER command output:
 #
@@ -295,9 +298,13 @@ def _syscmd_ver(system='', release='', version='',
     else:
         return system, release, version
 
+    ver_output = re.compile(r'(?:([\w ]+) ([\w.]+) '
+                         r'.*'
+                         r'\[.* ([\d.]+)\])')
+
     # Parse the output
     info = info.strip()
-    m = _ver_output.match(info)
+    m = ver_output.match(info)
     if m is not None:
         system, release, version = m.groups()
         # Strip trailing dots from version and release
@@ -310,44 +317,62 @@ def _syscmd_ver(system='', release='', version='',
         version = _norm_version(version)
     return system, release, version
 
-_WIN32_CLIENT_RELEASES = {
-    (5, 0): "2000",
-    (5, 1): "XP",
-    # Strictly, 5.2 client is XP 64-bit, but platform.py historically
-    # has always called it 2003 Server
-    (5, 2): "2003Server",
-    (5, None): "post2003",
-
-    (6, 0): "Vista",
-    (6, 1): "7",
-    (6, 2): "8",
-    (6, 3): "8.1",
-    (6, None): "post8.1",
-
-    (10, 0): "10",
-    (10, None): "post10",
-}
-
-# Server release name lookup will default to client names if necessary
-_WIN32_SERVER_RELEASES = {
-    (5, 2): "2003Server",
 
-    (6, 0): "2008Server",
-    (6, 1): "2008ServerR2",
-    (6, 2): "2012Server",
-    (6, 3): "2012ServerR2",
-    (6, None): "post2012ServerR2",
-}
+def _wmi_query(table, *keys):
+    global _wmi
+    if not _wmi:
+        raise OSError("not supported")
+    table = {
+        "OS": "Win32_OperatingSystem",
+        "CPU": "Win32_Processor",
+    }[table]
+    try:
+        data = _wmi.exec_query("SELECT {} FROM {}".format(
+            ",".join(keys),
+            table,
+        )).split("\0")
+    except OSError:
+        _wmi = None
+        raise OSError("not supported")
+    split_data = (i.partition("=") for i in data)
+    dict_data = {i[0]: i[2] for i in split_data}
+    return (dict_data[k] for k in keys)
+
+
+_WIN32_CLIENT_RELEASES = [
+    ((10, 1, 0), "post11"),
+    ((10, 0, 22000), "11"),
+    ((6, 4, 0), "10"),
+    ((6, 3, 0), "8.1"),
+    ((6, 2, 0), "8"),
+    ((6, 1, 0), "7"),
+    ((6, 0, 0), "Vista"),
+    ((5, 2, 3790), "XP64"),
+    ((5, 2, 0), "XPMedia"),
+    ((5, 1, 0), "XP"),
+    ((5, 0, 0), "2000"),
+]
+
+_WIN32_SERVER_RELEASES = [
+    ((10, 1, 0), "post2025Server"),
+    ((10, 0, 26100), "2025Server"),
+    ((10, 0, 20348), "2022Server"),
+    ((10, 0, 17763), "2019Server"),
+    ((6, 4, 0), "2016Server"),
+    ((6, 3, 0), "2012ServerR2"),
+    ((6, 2, 0), "2012Server"),
+    ((6, 1, 0), "2008ServerR2"),
+    ((6, 0, 0), "2008Server"),
+    ((5, 2, 0), "2003Server"),
+    ((5, 0, 0), "2000Server"),
+]
 
 def win32_is_iot():
     return win32_edition() in ('IoTUAP', 'NanoServer', 'WindowsCoreHeadless', 'IoTEdgeOS')
 
 def win32_edition():
     try:
-        try:
-            import winreg
-        except ImportError:
-            import _winreg as winreg
+        import winreg
     except ImportError:
         pass
     else:
@@ -360,22 +385,40 @@ def win32_edition():
 
     return None
 
-def win32_ver(release='', version='', csd='', ptype=''):
+def _win32_ver(version, csd, ptype):
+    # Try using WMI first, as this is the canonical source of data
+    try:
+        (version, product_type, ptype, spmajor, spminor)  = _wmi_query(
+            'OS',
+            'Version',
+            'ProductType',
+            'BuildType',
+            'ServicePackMajorVersion',
+            'ServicePackMinorVersion',
+        )
+        is_client = (int(product_type) == 1)
+        if spminor and spminor != '0':
+            csd = f'SP{spmajor}.{spminor}'
+        else:
+            csd = f'SP{spmajor}'
+        return version, csd, ptype, is_client
+    except OSError:
+        pass
+
+    # Fall back to a combination of sys.getwindowsversion and "ver"
     try:
         from sys import getwindowsversion
     except ImportError:
-        return release, version, csd, ptype
+        return version, csd, ptype, True
 
     winver = getwindowsversion()
+    is_client = (getattr(winver, 'product_type', 1) == 1)
     try:
-        major, minor, build = map(int, _syscmd_ver()[2].split('.'))
+        version = _syscmd_ver()[2]
+        major, minor, build = map(int, version.split('.'))
     except ValueError:
         major, minor, build = winver.platform_version or winver[:3]
-    version = '{0}.{1}.{2}'.format(major, minor, build)
-
-    release = (_WIN32_CLIENT_RELEASES.get((major, minor)) or
-               _WIN32_CLIENT_RELEASES.get((major, None)) or
-               release)
+        version = '{0}.{1}.{2}'.format(major, minor, build)
 
     # getwindowsversion() reflect the compatibility mode Python is
     # running under, and so the service pack value is only going to be
@@ -387,17 +430,8 @@ def win32_ver(release='', version='', csd='', ptype=''):
             if csd[:13] == 'Service Pack ':
                 csd = 'SP' + csd[13:]
 
-    # VER_NT_SERVER = 3
-    if getattr(winver, 'product_type', None) == 3:
-        release = (_WIN32_SERVER_RELEASES.get((major, minor)) or
-                   _WIN32_SERVER_RELEASES.get((major, None)) or
-                   release)
-
     try:
-        try:
-            import winreg
-        except ImportError:
-            import _winreg as winreg
+        import winreg
     except ImportError:
         pass
     else:
@@ -408,6 +442,18 @@ def win32_ver(release='', version='', csd='', ptype=''):
         except OSError:
             pass
 
+    return version, csd, ptype, is_client
+
+def win32_ver(release='', version='', csd='', ptype=''):
+    is_client = False
+
+    version, csd, ptype, is_client = _win32_ver(version, csd, ptype)
+
+    if version:
+        intversion = tuple(map(int, version.split('.')))
+        releases = _WIN32_CLIENT_RELEASES if is_client else _WIN32_SERVER_RELEASES
+        release = next((r for v, r in releases if v <= intversion), release)
+
     return release, version, csd, ptype
 
 
@@ -452,8 +498,32 @@ def mac_ver(release='', versioninfo=('', '', ''), machine=''):
     # If that also doesn't work return the default values
     return release, versioninfo, machine
 
-def _java_getprop(name, default):
 
+# A namedtuple for iOS version information.
+IOSVersionInfo = collections.namedtuple(
+    "IOSVersionInfo",
+    ["system", "release", "model", "is_simulator"]
+)
+
+
+def ios_ver(system="", release="", model="", is_simulator=False):
+    """Get iOS version information, and return it as a namedtuple:
+        (system, release, model, is_simulator).
+
+    If values can't be determined, they are set to values provided as
+    parameters.
+    """
+    if sys.platform == "ios":
+        import _ios_support
+        result = _ios_support.get_platform_ios()
+        if result is not None:
+            return IOSVersionInfo(*result)
+
+    return IOSVersionInfo(system, release, model, is_simulator)
+
+
+def _java_getprop(name, default):
+    """This private helper is deprecated in 3.13 and will be removed in 3.15"""
     from java.lang import System
     try:
         value = System.getProperty(name)
@@ -475,6 +545,8 @@ def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')):
         given as parameters (which all default to '').
 
     """
+    import warnings
+    warnings._deprecated('java_ver', remove=(3, 15))
     # Import the needed APIs
     try:
         import java.lang
@@ -496,6 +568,47 @@ def java_ver(release='', vendor='', vminfo=('', '', ''), osinfo=('', '', '')):
 
     return release, vendor, vminfo, osinfo
 
+
+AndroidVer = collections.namedtuple(
+    "AndroidVer", "release api_level manufacturer model device is_emulator")
+
+def android_ver(release="", api_level=0, manufacturer="", model="", device="",
+                is_emulator=False):
+    if sys.platform == "android":
+        try:
+            from ctypes import CDLL, c_char_p, create_string_buffer
+        except ImportError:
+            pass
+        else:
+            # An NDK developer confirmed that this is an officially-supported
+            # API (https://stackoverflow.com/a/28416743). Use `getattr` to avoid
+            # private name mangling.
+            system_property_get = getattr(CDLL("libc.so"), "__system_property_get")
+            system_property_get.argtypes = (c_char_p, c_char_p)
+
+            def getprop(name, default):
+                # https://android.googlesource.com/platform/bionic/+/refs/tags/android-5.0.0_r1/libc/include/sys/system_properties.h#39
+                PROP_VALUE_MAX = 92
+                buffer = create_string_buffer(PROP_VALUE_MAX)
+                length = system_property_get(name.encode("UTF-8"), buffer)
+                if length == 0:
+                    # This API doesn’t distinguish between an empty property and
+                    # a missing one.
+                    return default
+                else:
+                    return buffer.value.decode("UTF-8", "backslashreplace")
+
+            release = getprop("ro.build.version.release", release)
+            api_level = int(getprop("ro.build.version.sdk", api_level))
+            manufacturer = getprop("ro.product.manufacturer", manufacturer)
+            model = getprop("ro.product.model", model)
+            device = getprop("ro.product.device", device)
+            is_emulator = getprop("ro.kernel.qemu", "0") == "1"
+
+    return AndroidVer(
+        release, api_level, manufacturer, model, device, is_emulator)
+
+
 ### System name aliasing
 
 def system_alias(system, release, version):
@@ -562,12 +675,12 @@ def _platform(*args):
     platform = platform.replace('unknown', '')
 
     # Fold '--'s and remove trailing '-'
-    while 1:
+    while True:
         cleaned = platform.replace('--', '-')
         if cleaned == platform:
             break
         platform = cleaned
-    while platform[-1] == '-':
+    while platform and platform[-1] == '-':
         platform = platform[:-1]
 
     return platform
@@ -608,7 +721,7 @@ def _syscmd_file(target, default=''):
         default in case the command should fail.
 
     """
-    if sys.platform in ('dos', 'win32', 'win16'):
+    if sys.platform in {'dos', 'win32', 'win16', 'ios', 'tvos', 'watchos'}:
         # XXX Others too ?
         return default
 
@@ -702,6 +815,8 @@ def architecture(executable=sys.executable, bits='', linkage=''):
     # Linkage
     if 'ELF' in fileout:
         linkage = 'ELF'
+    elif 'Mach-O' in fileout:
+        linkage = "Mach-O"
     elif 'PE' in fileout:
         # E.g. Windows uses this format
         if 'Windows' in fileout:
@@ -726,6 +841,21 @@ def _get_machine_win32():
     # http://www.geocities.com/rick_lively/MANUALS/ENV/MSWIN/PROCESSI.HTM
 
     # WOW64 processes mask the native architecture
+    try:
+        [arch, *_] = _wmi_query('CPU', 'Architecture')
+    except OSError:
+        pass
+    else:
+        try:
+            arch = ['x86', 'MIPS', 'Alpha', 'PowerPC', None,
+                    'ARM', 'ia64', None, None,
+                    'AMD64', None, None, 'ARM64',
+            ][int(arch)]
+        except (ValueError, IndexError):
+            pass
+        else:
+            if arch:
+                return arch
     return (
         os.environ.get('PROCESSOR_ARCHITEW6432', '') or
         os.environ.get('PROCESSOR_ARCHITECTURE', '')
@@ -739,7 +869,12 @@ def get(cls):
         return func() or ''
 
     def get_win32():
-        return os.environ.get('PROCESSOR_IDENTIFIER', _get_machine_win32())
+        try:
+            manufacturer, caption = _wmi_query('CPU', 'Manufacturer', 'Caption')
+        except OSError:
+            return os.environ.get('PROCESSOR_IDENTIFIER', _get_machine_win32())
+        else:
+            return f'{caption}, {manufacturer}'
 
     def get_OpenVMS():
         try:
@@ -750,6 +885,14 @@ def get_OpenVMS():
             csid, cpu_number = vms_lib.getsyi('SYI$_CPU', 0)
             return 'Alpha' if cpu_number >= 128 else 'VAX'
 
+    # On the iOS simulator, os.uname returns the architecture as uname.machine.
+    # On device it returns the model name for some reason; but there's only one
+    # CPU architecture for iOS devices, so we know the right answer.
+    def get_ios():
+        if sys.implementation._multiarch.endswith("simulator"):
+            return os.uname().machine
+        return 'arm64'
+
     def from_subprocess():
         """
         Fall back to `uname -p`
@@ -904,6 +1047,15 @@ def uname():
         system = 'Windows'
         release = 'Vista'
 
+    # On Android, return the name and version of the OS rather than the kernel.
+    if sys.platform == 'android':
+        system = 'Android'
+        release = android_ver().release
+
+    # Normalize responses on iOS
+    if sys.platform == 'ios':
+        system, release, _, _ = ios_ver()
+
     vals = system, node, release, version, machine
     # Replace 'unknown' values with the more portable ''
     _uname_cache = uname_result(*map(_unknown_as_blank, vals))
@@ -971,32 +1123,6 @@ def processor():
 
 ### Various APIs for extracting information from sys.version
 
-_sys_version_parser = re.compile(
-    r'([\w.+]+)\s*'  # "version<space>"
-    r'\(#?([^,]+)'  # "(#buildno"
-    r'(?:,\s*([\w ]*)'  # ", builddate"
-    r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
-    r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
-
-_ironpython_sys_version_parser = re.compile(
-    r'IronPython\s*'
-    r'([\d\.]+)'
-    r'(?: \(([\d\.]+)\))?'
-    r' on (.NET [\d\.]+)', re.ASCII)
-
-# IronPython covering 2.6 and 2.7
-_ironpython26_sys_version_parser = re.compile(
-    r'([\d.]+)\s*'
-    r'\(IronPython\s*'
-    r'[\d.]+\s*'
-    r'\(([\d.]+)\) on ([\w.]+ [\d.]+(?: \(\d+-bit\))?)\)'
-)
-
-_pypy_sys_version_parser = re.compile(
-    r'([\w.+]+)\s*'
-    r'\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
-    r'\[PyPy [^\]]+\]?')
-
 _sys_version_cache = {}
 
 def _sys_version(sys_version=None):
@@ -1028,28 +1154,16 @@ def _sys_version(sys_version=None):
     if result is not None:
         return result
 
-    # Parse it
-    if 'IronPython' in sys_version:
-        # IronPython
-        name = 'IronPython'
-        if sys_version.startswith('IronPython'):
-            match = _ironpython_sys_version_parser.match(sys_version)
-        else:
-            match = _ironpython26_sys_version_parser.match(sys_version)
-
-        if match is None:
-            raise ValueError(
-                'failed to parse IronPython sys.version: %s' %
-                repr(sys_version))
-
-        version, alt_version, compiler = match.groups()
-        buildno = ''
-        builddate = ''
-
-    elif sys.platform.startswith('java'):
+    if sys.platform.startswith('java'):
         # Jython
+        jython_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'  # "version<space>"
+            r'\(#?([^,]+)'  # "(#buildno"
+            r'(?:,\s*([\w ]*)'  # ", builddate"
+            r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
+            r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
         name = 'Jython'
-        match = _sys_version_parser.match(sys_version)
+        match = jython_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError(
                 'failed to parse Jython sys.version: %s' %
@@ -1061,8 +1175,13 @@ def _sys_version(sys_version=None):
 
     elif "PyPy" in sys_version:
         # PyPy
+        pypy_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'
+            r'\(#?([^,]+),\s*([\w ]+),\s*([\w :]+)\)\s*'
+            r'\[PyPy [^\]]+\]?')
+
         name = "PyPy"
-        match = _pypy_sys_version_parser.match(sys_version)
+        match = pypy_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError("failed to parse PyPy sys.version: %s" %
                              repr(sys_version))
@@ -1071,7 +1190,14 @@ def _sys_version(sys_version=None):
 
     else:
         # CPython
-        match = _sys_version_parser.match(sys_version)
+        cpython_sys_version_parser = re.compile(
+            r'([\w.+]+)\s*'  # "version<space>"
+            r'(?:experimental free-threading build\s+)?' # "free-threading-build<space>"
+            r'\(#?([^,]+)'  # "(#buildno"
+            r'(?:,\s*([\w ]*)'  # ", builddate"
+            r'(?:,\s*([\w :]*))?)?\)\s*'  # ", buildtime)<space>"
+            r'\[([^\]]+)\]?', re.ASCII)  # "[compiler]"
+        match = cpython_sys_version_parser.match(sys_version)
         if match is None:
             raise ValueError(
                 'failed to parse CPython sys.version: %s' %
@@ -1080,11 +1206,10 @@ def _sys_version(sys_version=None):
               match.groups()
 
         # XXX: RUSTPYTHON support
-        if "rustc" in sys_version:
+        if "RustPython" in sys_version:
             name = "RustPython"
         else:
             name = 'CPython'
-
         if builddate is None:
             builddate = ''
         elif buildtime:
@@ -1115,7 +1240,6 @@ def python_implementation():
 
         Currently, the following implementations are identified:
           'CPython' (C implementation of Python),
-          'IronPython' (.NET implementation of Python),
           'Jython' (Java implementation of Python),
           'PyPy' (Python implementation of Python).
 
@@ -1190,7 +1314,7 @@ def python_compiler():
 
 _platform_cache = {}
 
-def platform(aliased=0, terse=0):
+def platform(aliased=False, terse=False):
 
     """ Returns a single string identifying the underlying platform
         with as much useful information as possible (but no more :).
@@ -1222,11 +1346,14 @@ def platform(aliased=0, terse=0):
         system, release, version = system_alias(system, release, version)
 
     if system == 'Darwin':
-        # macOS (darwin kernel)
-        macos_release = mac_ver()[0]
-        if macos_release:
-            system = 'macOS'
-            release = macos_release
+        # macOS and iOS both report as a "Darwin" kernel
+        if sys.platform == "ios":
+            system, release, _, _ = ios_ver()
+        else:
+            macos_release = mac_ver()[0]
+            if macos_release:
+                system = 'macOS'
+                release = macos_release
 
     if system == 'Windows':
         # MS platforms
@@ -1236,7 +1363,7 @@ def platform(aliased=0, terse=0):
         else:
             platform = _platform(system, release, version, csd)
 
-    elif system in ('Linux',):
+    elif system == 'Linux':
         # check for libc vs. glibc
         libcname, libcversion = libc_ver()
         platform = _platform(system, release, machine, processor,
@@ -1267,13 +1394,6 @@ def platform(aliased=0, terse=0):
 ### freedesktop.org os-release standard
 # https://www.freedesktop.org/software/systemd/man/os-release.html
 
-# NAME=value with optional quotes (' or "). The regular expression is less
-# strict than shell lexer, but that's ok.
-_os_release_line = re.compile(
-    "^(?P<name>[a-zA-Z0-9_]+)=(?P<quote>[\"\']?)(?P<value>.*)(?P=quote)$"
-)
-# unescape five special characters mentioned in the standard
-_os_release_unescape = re.compile(r"\\([\\\$\"\'`])")
 # /etc takes precedence over /usr/lib
 _os_release_candidates = ("/etc/os-release", "/usr/lib/os-release")
 _os_release_cache = None
@@ -1288,10 +1408,18 @@ def _parse_os_release(lines):
         "PRETTY_NAME": "Linux",
     }
 
+    # NAME=value with optional quotes (' or "). The regular expression is less
+    # strict than shell lexer, but that's ok.
+    os_release_line = re.compile(
+        "^(?P<name>[a-zA-Z0-9_]+)=(?P<quote>[\"\']?)(?P<value>.*)(?P=quote)$"
+    )
+    # unescape five special characters mentioned in the standard
+    os_release_unescape = re.compile(r"\\([\\\$\"\'`])")
+
     for line in lines:
-        mo = _os_release_line.match(line)
+        mo = os_release_line.match(line)
         if mo is not None:
-            info[mo.group('name')] = _os_release_unescape.sub(
+            info[mo.group('name')] = os_release_unescape.sub(
                 r"\1", mo.group('value')
             )
 
diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 2eeebe4c9a..655c51eea3 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -21,6 +21,9 @@
 
 Generate Plist example:
 
+    import datetime
+    import plistlib
+
     pl = dict(
         aString = "Doodah",
         aList = ["A", "B", 12, 32.1, [1, 2, 3]],
@@ -28,22 +31,28 @@
         anInt = 728,
         aDict = dict(
             anotherString = "<hello & hi there!>",
-            aUnicodeValue = "M\xe4ssig, Ma\xdf",
+            aThirdString = "M\xe4ssig, Ma\xdf",
             aTrueValue = True,
             aFalseValue = False,
         ),
         someData = b"<binary gunk>",
         someMoreData = b"<lots of binary gunk>" * 10,
-        aDate = datetime.datetime.fromtimestamp(time.mktime(time.gmtime())),
+        aDate = datetime.datetime.now()
     )
-    with open(fileName, 'wb') as fp:
-        dump(pl, fp)
+    print(plistlib.dumps(pl).decode())
 
 Parse Plist example:
 
-    with open(fileName, 'rb') as fp:
-        pl = load(fp)
-    print(pl["aKey"])
+    import plistlib
+
+    plist = b'''<plist version="1.0">
+    <dict>
+        <key>foo</key>
+        <string>bar</string>
+    </dict>
+    </plist>'''
+    pl = plistlib.loads(plist)
+    print(pl["foo"])
 """
 __all__ = [
     "InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"
@@ -64,6 +73,9 @@
 PlistFormat = enum.Enum('PlistFormat', 'FMT_XML FMT_BINARY', module=__name__)
 globals().update(PlistFormat.__members__)
 
+# Data larger than this will be read in chunks, to prevent extreme
+# overallocation.
+_MIN_READ_BUF_SIZE = 1 << 20
 
 class UID:
     def __init__(self, data):
@@ -131,7 +143,7 @@ def _decode_base64(s):
 _dateParser = re.compile(r"(?P<year>\d\d\d\d)(?:-(?P<month>\d\d)(?:-(?P<day>\d\d)(?:T(?P<hour>\d\d)(?::(?P<minute>\d\d)(?::(?P<second>\d\d))?)?)?)?)?Z", re.ASCII)
 
 
-def _date_from_string(s):
+def _date_from_string(s, aware_datetime):
     order = ('year', 'month', 'day', 'hour', 'minute', 'second')
     gd = _dateParser.match(s).groupdict()
     lst = []
@@ -140,10 +152,14 @@ def _date_from_string(s):
         if val is None:
             break
         lst.append(int(val))
+    if aware_datetime:
+        return datetime.datetime(*lst, tzinfo=datetime.UTC)
     return datetime.datetime(*lst)
 
 
-def _date_to_string(d):
+def _date_to_string(d, aware_datetime):
+    if aware_datetime:
+        d = d.astimezone(datetime.UTC)
     return '%04d-%02d-%02dT%02d:%02d:%02dZ' % (
         d.year, d.month, d.day,
         d.hour, d.minute, d.second
@@ -152,7 +168,7 @@ def _date_to_string(d):
 def _escape(text):
     m = _controlCharPat.search(text)
     if m is not None:
-        raise ValueError("strings can't contains control characters; "
+        raise ValueError("strings can't contain control characters; "
                          "use bytes instead")
     text = text.replace("\r\n", "\n")       # convert DOS line endings
     text = text.replace("\r", "\n")         # convert Mac line endings
@@ -162,11 +178,12 @@ def _escape(text):
     return text
 
 class _PlistParser:
-    def __init__(self, dict_type):
+    def __init__(self, dict_type, aware_datetime=False):
         self.stack = []
         self.current_key = None
         self.root = None
         self._dict_type = dict_type
+        self._aware_datetime = aware_datetime
 
     def parse(self, fileobj):
         self.parser = ParserCreate()
@@ -178,8 +195,8 @@ def parse(self, fileobj):
         return self.root
 
     def handle_entity_decl(self, entity_name, is_parameter_entity, value, base, system_id, public_id, notation_name):
-        # Reject plist files with entity declarations to avoid XML vulnerabilies in expat.
-        # Regular plist files don't contain those declerations, and Apple's plutil tool does not
+        # Reject plist files with entity declarations to avoid XML vulnerabilities in expat.
+        # Regular plist files don't contain those declarations, and Apple's plutil tool does not
         # accept them either.
         raise InvalidFileException("XML entity declarations are not supported in plist files")
 
@@ -199,7 +216,7 @@ def handle_data(self, data):
 
     def add_object(self, value):
         if self.current_key is not None:
-            if not isinstance(self.stack[-1], type({})):
+            if not isinstance(self.stack[-1], dict):
                 raise ValueError("unexpected element at line %d" %
                                  self.parser.CurrentLineNumber)
             self.stack[-1][self.current_key] = value
@@ -208,7 +225,7 @@ def add_object(self, value):
             # this is the root object
             self.root = value
         else:
-            if not isinstance(self.stack[-1], type([])):
+            if not isinstance(self.stack[-1], list):
                 raise ValueError("unexpected element at line %d" %
                                  self.parser.CurrentLineNumber)
             self.stack[-1].append(value)
@@ -232,7 +249,7 @@ def end_dict(self):
         self.stack.pop()
 
     def end_key(self):
-        if self.current_key or not isinstance(self.stack[-1], type({})):
+        if self.current_key or not isinstance(self.stack[-1], dict):
             raise ValueError("unexpected key at line %d" %
                              self.parser.CurrentLineNumber)
         self.current_key = self.get_data()
@@ -268,7 +285,8 @@ def end_data(self):
         self.add_object(_decode_base64(self.get_data()))
 
     def end_date(self):
-        self.add_object(_date_from_string(self.get_data()))
+        self.add_object(_date_from_string(self.get_data(),
+                                          aware_datetime=self._aware_datetime))
 
 
 class _DumbXMLWriter:
@@ -312,13 +330,14 @@ def writeln(self, line):
 class _PlistWriter(_DumbXMLWriter):
     def __init__(
             self, file, indent_level=0, indent=b"\t", writeHeader=1,
-            sort_keys=True, skipkeys=False):
+            sort_keys=True, skipkeys=False, aware_datetime=False):
 
         if writeHeader:
             file.write(PLISTHEADER)
         _DumbXMLWriter.__init__(self, file, indent_level, indent)
         self._sort_keys = sort_keys
         self._skipkeys = skipkeys
+        self._aware_datetime = aware_datetime
 
     def write(self, value):
         self.writeln("<plist version=\"1.0\">")
@@ -351,7 +370,8 @@ def write_value(self, value):
             self.write_bytes(value)
 
         elif isinstance(value, datetime.datetime):
-            self.simple_element("date", _date_to_string(value))
+            self.simple_element("date",
+                                _date_to_string(value, self._aware_datetime))
 
         elif isinstance(value, (tuple, list)):
             self.write_array(value)
@@ -452,8 +472,9 @@ class _BinaryPlistParser:
 
     see also: http://opensource.apple.com/source/CF/CF-744.18/CFBinaryPList.c
     """
-    def __init__(self, dict_type):
+    def __init__(self, dict_type, aware_datetime=False):
         self._dict_type = dict_type
+        self._aware_datime = aware_datetime
 
     def parse(self, fp):
         try:
@@ -490,12 +511,24 @@ def _get_size(self, tokenL):
 
         return tokenL
 
+    def _read(self, size):
+        cursize = min(size, _MIN_READ_BUF_SIZE)
+        data = self._fp.read(cursize)
+        while True:
+            if len(data) != cursize:
+                raise InvalidFileException
+            if cursize == size:
+                return data
+            delta = min(cursize, size - cursize)
+            data += self._fp.read(delta)
+            cursize += delta
+
     def _read_ints(self, n, size):
-        data = self._fp.read(size * n)
+        data = self._read(size * n)
         if size in _BINARY_FORMAT:
             return struct.unpack(f'>{n}{_BINARY_FORMAT[size]}', data)
         else:
-            if not size or len(data) != size * n:
+            if not size:
                 raise InvalidFileException()
             return tuple(int.from_bytes(data[i: i + size], 'big')
                          for i in range(0, size * n, size))
@@ -547,27 +580,24 @@ def _read_object(self, ref):
             f = struct.unpack('>d', self._fp.read(8))[0]
             # timestamp 0 of binary plists corresponds to 1/1/2001
             # (year of Mac OS X 10.0), instead of 1/1/1970.
-            result = (datetime.datetime(2001, 1, 1) +
-                      datetime.timedelta(seconds=f))
+            if self._aware_datime:
+                epoch = datetime.datetime(2001, 1, 1, tzinfo=datetime.UTC)
+            else:
+                epoch = datetime.datetime(2001, 1, 1)
+            result = epoch + datetime.timedelta(seconds=f)
 
         elif tokenH == 0x40:  # data
             s = self._get_size(tokenL)
-            result = self._fp.read(s)
-            if len(result) != s:
-                raise InvalidFileException()
+            result = self._read(s)
 
         elif tokenH == 0x50:  # ascii string
             s = self._get_size(tokenL)
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('ascii')
 
         elif tokenH == 0x60:  # unicode string
             s = self._get_size(tokenL) * 2
-            data = self._fp.read(s)
-            if len(data) != s:
-                raise InvalidFileException()
+            data = self._read(s)
             result = data.decode('utf-16be')
 
         elif tokenH == 0x80:  # UID
@@ -579,7 +609,8 @@ def _read_object(self, ref):
             obj_refs = self._read_refs(s)
             result = []
             self._objects[ref] = result
-            result.extend(self._read_object(x) for x in obj_refs)
+            for x in obj_refs:
+                result.append(self._read_object(x))
 
         # tokenH == 0xB0 is documented as 'ordset', but is not actually
         # implemented in the Apple reference code.
@@ -620,10 +651,11 @@ def _count_to_size(count):
 _scalars = (str, int, float, datetime.datetime, bytes)
 
 class _BinaryPlistWriter (object):
-    def __init__(self, fp, sort_keys, skipkeys):
+    def __init__(self, fp, sort_keys, skipkeys, aware_datetime=False):
         self._fp = fp
         self._sort_keys = sort_keys
         self._skipkeys = skipkeys
+        self._aware_datetime = aware_datetime
 
     def write(self, value):
 
@@ -769,7 +801,12 @@ def _write_object(self, value):
             self._fp.write(struct.pack('>Bd', 0x23, value))
 
         elif isinstance(value, datetime.datetime):
-            f = (value - datetime.datetime(2001, 1, 1)).total_seconds()
+            if self._aware_datetime:
+                dt = value.astimezone(datetime.UTC)
+                offset = dt - datetime.datetime(2001, 1, 1, tzinfo=datetime.UTC)
+                f = offset.total_seconds()
+            else:
+                f = (value - datetime.datetime(2001, 1, 1)).total_seconds()
             self._fp.write(struct.pack('>Bd', 0x33, f))
 
         elif isinstance(value, (bytes, bytearray)):
@@ -853,7 +890,7 @@ def _is_fmt_binary(header):
 }
 
 
-def load(fp, *, fmt=None, dict_type=dict):
+def load(fp, *, fmt=None, dict_type=dict, aware_datetime=False):
     """Read a .plist file. 'fp' should be a readable and binary file object.
     Return the unpacked root object (which usually is a dictionary).
     """
@@ -871,32 +908,41 @@ def load(fp, *, fmt=None, dict_type=dict):
     else:
         P = _FORMATS[fmt]['parser']
 
-    p = P(dict_type=dict_type)
+    p = P(dict_type=dict_type, aware_datetime=aware_datetime)
     return p.parse(fp)
 
 
-def loads(value, *, fmt=None, dict_type=dict):
+def loads(value, *, fmt=None, dict_type=dict, aware_datetime=False):
     """Read a .plist file from a bytes object.
     Return the unpacked root object (which usually is a dictionary).
     """
+    if isinstance(value, str):
+        if fmt == FMT_BINARY:
+            raise TypeError("value must be bytes-like object when fmt is "
+                            "FMT_BINARY")
+        value = value.encode()
     fp = BytesIO(value)
-    return load(fp, fmt=fmt, dict_type=dict_type)
+    return load(fp, fmt=fmt, dict_type=dict_type, aware_datetime=aware_datetime)
 
 
-def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False):
+def dump(value, fp, *, fmt=FMT_XML, sort_keys=True, skipkeys=False,
+         aware_datetime=False):
     """Write 'value' to a .plist file. 'fp' should be a writable,
     binary file object.
     """
     if fmt not in _FORMATS:
         raise ValueError("Unsupported format: %r"%(fmt,))
 
-    writer = _FORMATS[fmt]["writer"](fp, sort_keys=sort_keys, skipkeys=skipkeys)
+    writer = _FORMATS[fmt]["writer"](fp, sort_keys=sort_keys, skipkeys=skipkeys,
+                                     aware_datetime=aware_datetime)
     writer.write(value)
 
 
-def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True):
+def dumps(value, *, fmt=FMT_XML, skipkeys=False, sort_keys=True,
+          aware_datetime=False):
     """Return a bytes object with the contents for a .plist file.
     """
     fp = BytesIO()
-    dump(value, fp, fmt=fmt, skipkeys=skipkeys, sort_keys=sort_keys)
+    dump(value, fp, fmt=fmt, skipkeys=skipkeys, sort_keys=sort_keys,
+         aware_datetime=aware_datetime)
     return fp.getvalue()
diff --git a/Lib/posixpath.py b/Lib/posixpath.py
index e4f155e41a..80561ae7e5 100644
--- a/Lib/posixpath.py
+++ b/Lib/posixpath.py
@@ -22,6 +22,7 @@
 altsep = None
 devnull = '/dev/null'
 
+import errno
 import os
 import sys
 import stat
@@ -35,7 +36,7 @@
            "samefile","sameopenfile","samestat",
            "curdir","pardir","sep","pathsep","defpath","altsep","extsep",
            "devnull","realpath","supports_unicode_filenames","relpath",
-           "commonpath", "isjunction"]
+           "commonpath", "isjunction","isdevdrive","ALLOW_MISSING"]
 
 
 def _get_sep(path):
@@ -77,12 +78,11 @@ def join(a, *p):
     sep = _get_sep(a)
     path = a
     try:
-        if not p:
-            path[:0] + sep  #23780: Ensure compatible data type even if p is null.
-        for b in map(os.fspath, p):
-            if b.startswith(sep):
+        for b in p:
+            b = os.fspath(b)
+            if b.startswith(sep) or not path:
                 path = b
-            elif not path or path.endswith(sep):
+            elif path.endswith(sep):
                 path += b
             else:
                 path += sep + b
@@ -135,33 +135,30 @@ def splitdrive(p):
     return p[:0], p
 
 
-def splitroot(p):
-    """Split a pathname into drive, root and tail. On Posix, drive is always
-    empty; the root may be empty, a single slash, or two slashes. The tail
-    contains anything after the root. For example:
+try:
+    from posix import _path_splitroot_ex as splitroot
+except ImportError:
+    def splitroot(p):
+        """Split a pathname into drive, root and tail.
 
-        splitroot('foo/bar') == ('', '', 'foo/bar')
-        splitroot('/foo/bar') == ('', '/', 'foo/bar')
-        splitroot('//foo/bar') == ('', '//', 'foo/bar')
-        splitroot('///foo/bar') == ('', '/', '//foo/bar')
-    """
-    p = os.fspath(p)
-    if isinstance(p, bytes):
-        sep = b'/'
-        empty = b''
-    else:
-        sep = '/'
-        empty = ''
-    if p[:1] != sep:
-        # Relative path, e.g.: 'foo'
-        return empty, empty, p
-    elif p[1:2] != sep or p[2:3] == sep:
-        # Absolute path, e.g.: '/foo', '///foo', '////foo', etc.
-        return empty, sep, p[1:]
-    else:
-        # Precisely two leading slashes, e.g.: '//foo'. Implementation defined per POSIX, see
-        # https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13
-        return empty, p[:2], p[2:]
+        The tail contains anything after the root."""
+        p = os.fspath(p)
+        if isinstance(p, bytes):
+            sep = b'/'
+            empty = b''
+        else:
+            sep = '/'
+            empty = ''
+        if p[:1] != sep:
+            # Relative path, e.g.: 'foo'
+            return empty, empty, p
+        elif p[1:2] != sep or p[2:3] == sep:
+            # Absolute path, e.g.: '/foo', '///foo', '////foo', etc.
+            return empty, sep, p[1:]
+        else:
+            # Precisely two leading slashes, e.g.: '//foo'. Implementation defined per POSIX, see
+            # https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13
+            return empty, p[:2], p[2:]
 
 
 # Return the tail (basename) part of a path, same as split(path)[1].
@@ -187,26 +184,6 @@ def dirname(p):
     return head
 
 
-# Is a path a junction?
-
-def isjunction(path):
-    """Test whether a path is a junction
-    Junctions are not a part of posix semantics"""
-    os.fspath(path)
-    return False
-
-
-# Being true for dangling symbolic links is also useful.
-
-def lexists(path):
-    """Test whether a path exists.  Returns True for broken symbolic links"""
-    try:
-        os.lstat(path)
-    except (OSError, ValueError):
-        return False
-    return True
-
-
 # Is a path a mount point?
 # (Does this work for all UNIXes?  Is it even guaranteed to work by Posix?)
 
@@ -227,21 +204,17 @@ def ismount(path):
         parent = join(path, b'..')
     else:
         parent = join(path, '..')
-    parent = realpath(parent)
     try:
         s2 = os.lstat(parent)
-    except (OSError, ValueError):
-        return False
+    except OSError:
+        parent = realpath(parent)
+        try:
+            s2 = os.lstat(parent)
+        except OSError:
+            return False
 
-    dev1 = s1.st_dev
-    dev2 = s2.st_dev
-    if dev1 != dev2:
-        return True     # path/.. on a different device as path
-    ino1 = s1.st_ino
-    ino2 = s2.st_ino
-    if ino1 == ino2:
-        return True     # path/.. is the same i-node as path
-    return False
+    # path/.. on a different device as path or the same i-node as path
+    return s1.st_dev != s2.st_dev or s1.st_ino == s2.st_ino
 
 
 # Expand paths beginning with '~' or '~user'.
@@ -290,7 +263,7 @@ def expanduser(path):
             return path
         name = path[1:i]
         if isinstance(name, bytes):
-            name = str(name, 'ASCII')
+            name = os.fsdecode(name)
         try:
             pwent = pwd.getpwnam(name)
         except KeyError:
@@ -303,11 +276,8 @@ def expanduser(path):
         return path
     if isinstance(path, bytes):
         userhome = os.fsencode(userhome)
-        root = b'/'
-    else:
-        root = '/'
-    userhome = userhome.rstrip(root)
-    return (userhome + path[i:]) or root
+    userhome = userhome.rstrip(sep)
+    return (userhome + path[i:]) or sep
 
 
 # Expand paths containing shell variable substitutions.
@@ -371,7 +341,7 @@ def expandvars(path):
 # if it contains symbolic links!
 
 try:
-    from posix import _path_normpath
+    from posix import _path_normpath as normpath
 
 except ImportError:
     def normpath(path):
@@ -379,21 +349,19 @@ def normpath(path):
         path = os.fspath(path)
         if isinstance(path, bytes):
             sep = b'/'
-            empty = b''
             dot = b'.'
             dotdot = b'..'
         else:
             sep = '/'
-            empty = ''
             dot = '.'
             dotdot = '..'
-        if path == empty:
+        if not path:
             return dot
         _, initial_slashes, path = splitroot(path)
         comps = path.split(sep)
         new_comps = []
         for comp in comps:
-            if comp in (empty, dot):
+            if not comp or comp == dot:
                 continue
             if (comp != dotdot or (not initial_slashes and not new_comps) or
                  (new_comps and new_comps[-1] == dotdot)):
@@ -404,24 +372,16 @@ def normpath(path):
         path = initial_slashes + sep.join(comps)
         return path or dot
 
-else:
-    def normpath(path):
-        """Normalize path, eliminating double slashes, etc."""
-        path = os.fspath(path)
-        if isinstance(path, bytes):
-            return os.fsencode(_path_normpath(os.fsdecode(path))) or b"."
-        return _path_normpath(path) or "."
-
 
 def abspath(path):
     """Return an absolute path."""
     path = os.fspath(path)
-    if not isabs(path):
-        if isinstance(path, bytes):
-            cwd = os.getcwdb()
-        else:
-            cwd = os.getcwd()
-        path = join(cwd, path)
+    if isinstance(path, bytes):
+        if not path.startswith(b'/'):
+            path = join(os.getcwdb(), path)
+    else:
+        if not path.startswith('/'):
+            path = join(os.getcwd(), path)
     return normpath(path)
 
 
@@ -432,72 +392,109 @@ def realpath(filename, *, strict=False):
     """Return the canonical path of the specified filename, eliminating any
 symbolic links encountered in the path."""
     filename = os.fspath(filename)
-    path, ok = _joinrealpath(filename[:0], filename, strict, {})
-    return abspath(path)
-
-# Join two paths, normalizing and eliminating any symbolic links
-# encountered in the second path.
-def _joinrealpath(path, rest, strict, seen):
-    if isinstance(path, bytes):
+    if isinstance(filename, bytes):
         sep = b'/'
         curdir = b'.'
         pardir = b'..'
+        getcwd = os.getcwdb
     else:
         sep = '/'
         curdir = '.'
         pardir = '..'
-
-    if isabs(rest):
-        rest = rest[1:]
-        path = sep
-
-    while rest:
-        name, _, rest = rest.partition(sep)
+        getcwd = os.getcwd
+    if strict is ALLOW_MISSING:
+        ignored_error = FileNotFoundError
+        strict = True
+    elif strict:
+        ignored_error = ()
+    else:
+        ignored_error = OSError
+
+    maxlinks = None
+
+    # The stack of unresolved path parts. When popped, a special value of None
+    # indicates that a symlink target has been resolved, and that the original
+    # symlink path can be retrieved by popping again. The [::-1] slice is a
+    # very fast way of spelling list(reversed(...)).
+    rest = filename.split(sep)[::-1]
+
+    # Number of unprocessed parts in 'rest'. This can differ from len(rest)
+    # later, because 'rest' might contain markers for unresolved symlinks.
+    part_count = len(rest)
+
+    # The resolved path, which is absolute throughout this function.
+    # Note: getcwd() returns a normalized and symlink-free path.
+    path = sep if filename.startswith(sep) else getcwd()
+
+    # Mapping from symlink paths to *fully resolved* symlink targets. If a
+    # symlink is encountered but not yet resolved, the value is None. This is
+    # used both to detect symlink loops and to speed up repeated traversals of
+    # the same links.
+    seen = {}
+
+    while part_count:
+        name = rest.pop()
+        if name is None:
+            # resolved symlink target
+            seen[rest.pop()] = path
+            continue
+        part_count -= 1
         if not name or name == curdir:
             # current dir
             continue
         if name == pardir:
             # parent dir
-            if path:
-                path, name = split(path)
-                if name == pardir:
-                    path = join(path, pardir, pardir)
-            else:
-                path = pardir
+            path = path[:path.rindex(sep)] or sep
             continue
-        newpath = join(path, name)
+        if path == sep:
+            newpath = path + name
+        else:
+            newpath = path + sep + name
         try:
-            st = os.lstat(newpath)
-        except OSError:
-            if strict:
-                raise
-            is_link = False
+            st_mode = os.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:
+                # Already seen this path
+                path = seen[newpath]
+                if path is not None:
+                    # use cached value
+                    continue
+                # The symlink is not resolved, so we must have a symlink loop.
+                if strict:
+                    # Raise OSError(errno.ELOOP)
+                    os.stat(newpath)
+                path = newpath
+                continue
+            target = os.readlink(newpath)
+        except ignored_error:
+            pass
         else:
-            is_link = stat.S_ISLNK(st.st_mode)
-        if not is_link:
-            path = newpath
+            # Resolve the symbolic link
+            if target.startswith(sep):
+                # Symlink target is absolute; reset resolved path.
+                path = sep
+            if maxlinks is None:
+                # Mark this symlink as seen but not fully resolved.
+                seen[newpath] = None
+                # Push the symlink path onto the stack, and signal its specialness
+                # by also pushing None. When these entries are popped, we'll
+                # record the fully-resolved symlink target in the 'seen' mapping.
+                rest.append(newpath)
+                rest.append(None)
+            # Push the unresolved symlink target parts onto the stack.
+            target_parts = target.split(sep)[::-1]
+            rest.extend(target_parts)
+            part_count += len(target_parts)
             continue
-        # Resolve the symbolic link
-        if newpath in seen:
-            # Already seen this path
-            path = seen[newpath]
-            if path is not None:
-                # use cached value
-                continue
-            # The symlink is not resolved, so we must have a symlink loop.
-            if strict:
-                # Raise OSError(errno.ELOOP)
-                os.stat(newpath)
-            else:
-                # Return already resolved part + rest of the path unchanged.
-                return join(newpath, rest), False
-        seen[newpath] = None # not resolved symlink
-        path, ok = _joinrealpath(path, os.readlink(newpath), strict, seen)
-        if not ok:
-            return join(path, rest), False
-        seen[newpath] = path # resolved symlink
+        # An error occurred and was ignored.
+        path = newpath
 
-    return path, True
+    return path
 
 
 supports_unicode_filenames = (sys.platform == 'darwin')
@@ -505,10 +502,10 @@ def _joinrealpath(path, rest, strict, seen):
 def relpath(path, start=None):
     """Return a relative version of a path"""
 
+    path = os.fspath(path)
     if not path:
         raise ValueError("no path specified")
 
-    path = os.fspath(path)
     if isinstance(path, bytes):
         curdir = b'.'
         sep = b'/'
@@ -524,15 +521,17 @@ def relpath(path, start=None):
         start = os.fspath(start)
 
     try:
-        start_list = [x for x in abspath(start).split(sep) if x]
-        path_list = [x for x in abspath(path).split(sep) if x]
+        start_tail = abspath(start).lstrip(sep)
+        path_tail = abspath(path).lstrip(sep)
+        start_list = start_tail.split(sep) if start_tail else []
+        path_list = path_tail.split(sep) if path_tail else []
         # Work out how much of the filepath is shared by start and path.
         i = len(commonprefix([start_list, path_list]))
 
         rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
         if not rel_list:
             return curdir
-        return join(*rel_list)
+        return sep.join(rel_list)
     except (TypeError, AttributeError, BytesWarning, DeprecationWarning):
         genericpath._check_arg_types('relpath', path, start)
         raise
@@ -546,10 +545,11 @@ def relpath(path, start=None):
 def commonpath(paths):
     """Given a sequence of path names, returns the longest common sub-path."""
 
+    paths = tuple(map(os.fspath, paths))
+
     if not paths:
         raise ValueError('commonpath() arg is an empty sequence')
 
-    paths = tuple(map(os.fspath, paths))
     if isinstance(paths[0], bytes):
         sep = b'/'
         curdir = b'.'
@@ -561,7 +561,7 @@ def commonpath(paths):
         split_paths = [path.split(sep) for path in paths]
 
         try:
-            isabs, = set(p[:1] == sep for p in paths)
+            isabs, = {p.startswith(sep) for p in paths}
         except ValueError:
             raise ValueError("Can't mix absolute and relative paths") from None
 
diff --git a/Lib/pty.py b/Lib/pty.py
index 8d8ce40df5..1d97994abe 100644
--- a/Lib/pty.py
+++ b/Lib/pty.py
@@ -40,6 +40,9 @@ def master_open():
     Open a pty master and return the fd, and the filename of the slave end.
     Deprecated, use openpty() instead."""
 
+    import warnings
+    warnings.warn("Use pty.openpty() instead.", DeprecationWarning, stacklevel=2)  # Remove API in 3.14
+
     try:
         master_fd, slave_fd = os.openpty()
     except (AttributeError, OSError):
@@ -69,6 +72,9 @@ def slave_open(tty_name):
     opened filedescriptor.
     Deprecated, use openpty() instead."""
 
+    import warnings
+    warnings.warn("Use pty.openpty() instead.", DeprecationWarning, stacklevel=2)  # Remove API in 3.14
+
     result = os.open(tty_name, os.O_RDWR)
     try:
         from fcntl import ioctl, I_PUSH
@@ -101,32 +107,14 @@ def fork():
     master_fd, slave_fd = openpty()
     pid = os.fork()
     if pid == CHILD:
-        # Establish a new session.
-        os.setsid()
         os.close(master_fd)
-
-        # Slave becomes stdin/stdout/stderr of child.
-        os.dup2(slave_fd, STDIN_FILENO)
-        os.dup2(slave_fd, STDOUT_FILENO)
-        os.dup2(slave_fd, STDERR_FILENO)
-        if slave_fd > STDERR_FILENO:
-            os.close(slave_fd)
-
-        # Explicitly open the tty to make it become a controlling tty.
-        tmp_fd = os.open(os.ttyname(STDOUT_FILENO), os.O_RDWR)
-        os.close(tmp_fd)
+        os.login_tty(slave_fd)
     else:
         os.close(slave_fd)
 
     # Parent and child process.
     return pid, master_fd
 
-def _writen(fd, data):
-    """Write all the data to a descriptor."""
-    while data:
-        n = os.write(fd, data)
-        data = data[n:]
-
 def _read(fd):
     """Default read function."""
     return os.read(fd, 1024)
@@ -136,9 +124,42 @@ def _copy(master_fd, master_read=_read, stdin_read=_read):
     Copies
             pty master -> standard output   (master_read)
             standard input -> pty master    (stdin_read)"""
-    fds = [master_fd, STDIN_FILENO]
-    while fds:
-        rfds, _wfds, _xfds = select(fds, [], [])
+    if os.get_blocking(master_fd):
+        # If we write more than tty/ndisc is willing to buffer, we may block
+        # indefinitely. So we set master_fd to non-blocking temporarily during
+        # the copy operation.
+        os.set_blocking(master_fd, False)
+        try:
+            _copy(master_fd, master_read=master_read, stdin_read=stdin_read)
+        finally:
+            # restore blocking mode for backwards compatibility
+            os.set_blocking(master_fd, True)
+        return
+    high_waterlevel = 4096
+    stdin_avail = master_fd != STDIN_FILENO
+    stdout_avail = master_fd != STDOUT_FILENO
+    i_buf = b''
+    o_buf = b''
+    while 1:
+        rfds = []
+        wfds = []
+        if stdin_avail and len(i_buf) < high_waterlevel:
+            rfds.append(STDIN_FILENO)
+        if stdout_avail and len(o_buf) < high_waterlevel:
+            rfds.append(master_fd)
+        if stdout_avail and len(o_buf) > 0:
+            wfds.append(STDOUT_FILENO)
+        if len(i_buf) > 0:
+            wfds.append(master_fd)
+
+        rfds, wfds, _xfds = select(rfds, wfds, [])
+
+        if STDOUT_FILENO in wfds:
+            try:
+                n = os.write(STDOUT_FILENO, o_buf)
+                o_buf = o_buf[n:]
+            except OSError:
+                stdout_avail = False
 
         if master_fd in rfds:
             # Some OSes signal EOF by returning an empty byte string,
@@ -150,19 +171,22 @@ def _copy(master_fd, master_read=_read, stdin_read=_read):
             if not data:  # Reached EOF.
                 return    # Assume the child process has exited and is
                           # unreachable, so we clean up.
-            else:
-                os.write(STDOUT_FILENO, data)
+            o_buf += data
+
+        if master_fd in wfds:
+            n = os.write(master_fd, i_buf)
+            i_buf = i_buf[n:]
 
-        if STDIN_FILENO in rfds:
+        if stdin_avail and STDIN_FILENO in rfds:
             data = stdin_read(STDIN_FILENO)
             if not data:
-                fds.remove(STDIN_FILENO)
+                stdin_avail = False
             else:
-                _writen(master_fd, data)
+                i_buf += data
 
 def spawn(argv, master_read=_read, stdin_read=_read):
     """Create a spawned process."""
-    if type(argv) == type(''):
+    if isinstance(argv, str):
         argv = (argv,)
     sys.audit('pty.spawn', argv)
 
diff --git a/Lib/pyclbr.py b/Lib/pyclbr.py
new file mode 100644
index 0000000000..37f86995d6
--- /dev/null
+++ b/Lib/pyclbr.py
@@ -0,0 +1,314 @@
+"""Parse a Python module and describe its classes and functions.
+
+Parse enough of a Python file to recognize imports and class and
+function definitions, and to find out the superclasses of a class.
+
+The interface consists of a single function:
+    readmodule_ex(module, path=None)
+where module is the name of a Python module, and path is an optional
+list of directories where the module is to be searched.  If present,
+path is prepended to the system search path sys.path.  The return value
+is a dictionary.  The keys of the dictionary are the names of the
+classes and functions defined in the module (including classes that are
+defined via the from XXX import YYY construct).  The values are
+instances of classes Class and Function.  One special key/value pair is
+present for packages: the key '__path__' has a list as its value which
+contains the package search path.
+
+Classes and Functions have a common superclass: _Object.  Every instance
+has the following attributes:
+    module  -- name of the module;
+    name    -- name of the object;
+    file    -- file in which the object is defined;
+    lineno  -- line in the file where the object's definition starts;
+    end_lineno -- line in the file where the object's definition ends;
+    parent  -- parent of this object, if any;
+    children -- nested objects contained in this object.
+The 'children' attribute is a dictionary mapping names to objects.
+
+Instances of Function describe functions with the attributes from _Object,
+plus the following:
+    is_async -- if a function is defined with an 'async' prefix
+
+Instances of Class describe classes with the attributes from _Object,
+plus the following:
+    super   -- list of super classes (Class instances if possible);
+    methods -- mapping of method names to beginning line numbers.
+If the name of a super class is not recognized, the corresponding
+entry in the list of super classes is not a class instance but a
+string giving the name of the super class.  Since import statements
+are recognized and imported modules are scanned as well, this
+shouldn't happen often.
+"""
+
+import ast
+import sys
+import importlib.util
+
+__all__ = ["readmodule", "readmodule_ex", "Class", "Function"]
+
+_modules = {}  # Initialize cache of modules we've seen.
+
+
+class _Object:
+    "Information about Python class or function."
+    def __init__(self, module, name, file, lineno, end_lineno, parent):
+        self.module = module
+        self.name = name
+        self.file = file
+        self.lineno = lineno
+        self.end_lineno = end_lineno
+        self.parent = parent
+        self.children = {}
+        if parent is not None:
+            parent.children[name] = self
+
+
+# Odd Function and Class signatures are for back-compatibility.
+class Function(_Object):
+    "Information about a Python function, including methods."
+    def __init__(self, module, name, file, lineno,
+                 parent=None, is_async=False, *, end_lineno=None):
+        super().__init__(module, name, file, lineno, end_lineno, parent)
+        self.is_async = is_async
+        if isinstance(parent, Class):
+            parent.methods[name] = lineno
+
+
+class Class(_Object):
+    "Information about a Python class."
+    def __init__(self, module, name, super_, file, lineno,
+                 parent=None, *, end_lineno=None):
+        super().__init__(module, name, file, lineno, end_lineno, parent)
+        self.super = super_ or []
+        self.methods = {}
+
+
+# These 2 functions are used in these tests
+# Lib/test/test_pyclbr, Lib/idlelib/idle_test/test_browser.py
+def _nest_function(ob, func_name, lineno, end_lineno, is_async=False):
+    "Return a Function after nesting within ob."
+    return Function(ob.module, func_name, ob.file, lineno,
+                    parent=ob, is_async=is_async, end_lineno=end_lineno)
+
+def _nest_class(ob, class_name, lineno, end_lineno, super=None):
+    "Return a Class after nesting within ob."
+    return Class(ob.module, class_name, super, ob.file, lineno,
+                 parent=ob, end_lineno=end_lineno)
+
+
+def readmodule(module, path=None):
+    """Return Class objects for the top-level classes in module.
+
+    This is the original interface, before Functions were added.
+    """
+
+    res = {}
+    for key, value in _readmodule(module, path or []).items():
+        if isinstance(value, Class):
+            res[key] = value
+    return res
+
+def readmodule_ex(module, path=None):
+    """Return a dictionary with all functions and classes in module.
+
+    Search for module in PATH + sys.path.
+    If possible, include imported superclasses.
+    Do this by reading source, without importing (and executing) it.
+    """
+    return _readmodule(module, path or [])
+
+
+def _readmodule(module, path, inpackage=None):
+    """Do the hard work for readmodule[_ex].
+
+    If inpackage is given, it must be the dotted name of the package in
+    which we are searching for a submodule, and then PATH must be the
+    package search path; otherwise, we are searching for a top-level
+    module, and path is combined with sys.path.
+    """
+    # Compute the full module name (prepending inpackage if set).
+    if inpackage is not None:
+        fullmodule = "%s.%s" % (inpackage, module)
+    else:
+        fullmodule = module
+
+    # Check in the cache.
+    if fullmodule in _modules:
+        return _modules[fullmodule]
+
+    # Initialize the dict for this module's contents.
+    tree = {}
+
+    # Check if it is a built-in module; we don't do much for these.
+    if module in sys.builtin_module_names and inpackage is None:
+        _modules[module] = tree
+        return tree
+
+    # Check for a dotted module name.
+    i = module.rfind('.')
+    if i >= 0:
+        package = module[:i]
+        submodule = module[i+1:]
+        parent = _readmodule(package, path, inpackage)
+        if inpackage is not None:
+            package = "%s.%s" % (inpackage, package)
+        if not '__path__' in parent:
+            raise ImportError('No package named {}'.format(package))
+        return _readmodule(submodule, parent['__path__'], package)
+
+    # Search the path for the module.
+    f = None
+    if inpackage is not None:
+        search_path = path
+    else:
+        search_path = path + sys.path
+    spec = importlib.util._find_spec_from_path(fullmodule, search_path)
+    if spec is None:
+        raise ModuleNotFoundError(f"no module named {fullmodule!r}", name=fullmodule)
+    _modules[fullmodule] = tree
+    # Is module a package?
+    if spec.submodule_search_locations is not None:
+        tree['__path__'] = spec.submodule_search_locations
+    try:
+        source = spec.loader.get_source(fullmodule)
+    except (AttributeError, ImportError):
+        # If module is not Python source, we cannot do anything.
+        return tree
+    else:
+        if source is None:
+            return tree
+
+    fname = spec.loader.get_filename(fullmodule)
+    return _create_tree(fullmodule, path, fname, source, tree, inpackage)
+
+
+class _ModuleBrowser(ast.NodeVisitor):
+    def __init__(self, module, path, file, tree, inpackage):
+        self.path = path
+        self.tree = tree
+        self.file = file
+        self.module = module
+        self.inpackage = inpackage
+        self.stack = []
+
+    def visit_ClassDef(self, node):
+        bases = []
+        for base in node.bases:
+            name = ast.unparse(base)
+            if name in self.tree:
+                # We know this super class.
+                bases.append(self.tree[name])
+            elif len(names := name.split(".")) > 1:
+                # Super class form is module.class:
+                # look in module for class.
+                *_, module, class_ = names
+                if module in _modules:
+                    bases.append(_modules[module].get(class_, name))
+            else:
+                bases.append(name)
+
+        parent = self.stack[-1] if self.stack else None
+        class_ = Class(self.module, node.name, bases, self.file, node.lineno,
+                       parent=parent, end_lineno=node.end_lineno)
+        if parent is None:
+            self.tree[node.name] = class_
+        self.stack.append(class_)
+        self.generic_visit(node)
+        self.stack.pop()
+
+    def visit_FunctionDef(self, node, *, is_async=False):
+        parent = self.stack[-1] if self.stack else None
+        function = Function(self.module, node.name, self.file, node.lineno,
+                            parent, is_async, end_lineno=node.end_lineno)
+        if parent is None:
+            self.tree[node.name] = function
+        self.stack.append(function)
+        self.generic_visit(node)
+        self.stack.pop()
+
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node, is_async=True)
+
+    def visit_Import(self, node):
+        if node.col_offset != 0:
+            return
+
+        for module in node.names:
+            try:
+                try:
+                    _readmodule(module.name, self.path, self.inpackage)
+                except ImportError:
+                    _readmodule(module.name, [])
+            except (ImportError, SyntaxError):
+                # If we can't find or parse the imported module,
+                # too bad -- don't die here.
+                continue
+
+    def visit_ImportFrom(self, node):
+        if node.col_offset != 0:
+            return
+        try:
+            module = "." * node.level
+            if node.module:
+                module += node.module
+            module = _readmodule(module, self.path, self.inpackage)
+        except (ImportError, SyntaxError):
+            return
+
+        for name in node.names:
+            if name.name in module:
+                self.tree[name.asname or name.name] = module[name.name]
+            elif name.name == "*":
+                for import_name, import_value in module.items():
+                    if import_name.startswith("_"):
+                        continue
+                    self.tree[import_name] = import_value
+
+
+def _create_tree(fullmodule, path, fname, source, tree, inpackage):
+    mbrowser = _ModuleBrowser(fullmodule, path, fname, tree, inpackage)
+    mbrowser.visit(ast.parse(source))
+    return mbrowser.tree
+
+
+def _main():
+    "Print module output (default this file) for quick visual check."
+    import os
+    try:
+        mod = sys.argv[1]
+    except:
+        mod = __file__
+    if os.path.exists(mod):
+        path = [os.path.dirname(mod)]
+        mod = os.path.basename(mod)
+        if mod.lower().endswith(".py"):
+            mod = mod[:-3]
+    else:
+        path = []
+    tree = readmodule_ex(mod, path)
+    lineno_key = lambda a: getattr(a, 'lineno', 0)
+    objs = sorted(tree.values(), key=lineno_key, reverse=True)
+    indent_level = 2
+    while objs:
+        obj = objs.pop()
+        if isinstance(obj, list):
+            # Value is a __path__ key.
+            continue
+        if not hasattr(obj, 'indent'):
+            obj.indent = 0
+
+        if isinstance(obj, _Object):
+            new_objs = sorted(obj.children.values(),
+                              key=lineno_key, reverse=True)
+            for ob in new_objs:
+                ob.indent = obj.indent + indent_level
+            objs.extend(new_objs)
+        if isinstance(obj, Class):
+            print("{}class {} {} {}"
+                  .format(' ' * obj.indent, obj.name, obj.super, obj.lineno))
+        elif isinstance(obj, Function):
+            print("{}def {} {}".format(' ' * obj.indent, obj.name, obj.lineno))
+
+if __name__ == "__main__":
+    _main()
diff --git a/Lib/quopri.py b/Lib/quopri.py
index 08899c5cb7..f36cf7b395 100755
--- a/Lib/quopri.py
+++ b/Lib/quopri.py
@@ -67,10 +67,7 @@ def write(s, output=output, lineEnd=b'\n'):
             output.write(s + lineEnd)
 
     prevline = None
-    while 1:
-        line = input.readline()
-        if not line:
-            break
+    while line := input.readline():
         outline = []
         # Strip off any readline induced trailing newline
         stripped = b''
@@ -126,9 +123,7 @@ def decode(input, output, header=False):
         return
 
     new = b''
-    while 1:
-        line = input.readline()
-        if not line: break
+    while line := input.readline():
         i, n = 0, len(line)
         if n > 0 and line[n-1:n] == b'\n':
             partial = 0; n = n-1
diff --git a/Lib/re/__init__.py b/Lib/re/__init__.py
index 428d1b0d5f..7e8abbf6ff 100644
--- a/Lib/re/__init__.py
+++ b/Lib/re/__init__.py
@@ -117,7 +117,8 @@
     U  UNICODE     For compatibility only. Ignored for string patterns (it
                    is the default), and forbidden for bytes patterns.
 
-This module also defines an exception 'error'.
+This module also defines exception 'PatternError', aliased to 'error' for
+backward compatibility.
 
 """
 
@@ -133,7 +134,7 @@
     "findall", "finditer", "compile", "purge", "escape",
     "error", "Pattern", "Match", "A", "I", "L", "M", "S", "X", "U",
     "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
-    "UNICODE", "NOFLAG", "RegexFlag",
+    "UNICODE", "NOFLAG", "RegexFlag", "PatternError"
 ]
 
 __version__ = "2.2.1"
@@ -155,7 +156,7 @@ class RegexFlag:
     _numeric_repr_ = hex
 
 # sre exception
-error = _compiler.error
+PatternError = error = _compiler.PatternError
 
 # --------------------------------------------------------------------
 # public interface
diff --git a/Lib/re/_casefix.py b/Lib/re/_casefix.py
index 06507d08be..fed2d84fc0 100644
--- a/Lib/re/_casefix.py
+++ b/Lib/re/_casefix.py
@@ -1,4 +1,4 @@
-# Auto-generated by Tools/scripts/generate_re_casefix.py.
+# Auto-generated by Tools/build/generate_re_casefix.py.
 
 # Maps the code of lowercased character to codes of different lowercased
 # characters which have the same uppercase.
diff --git a/Lib/re/_compiler.py b/Lib/re/_compiler.py
index 861bbdb130..1b1aaa7714 100644
--- a/Lib/re/_compiler.py
+++ b/Lib/re/_compiler.py
@@ -101,8 +101,6 @@ def _compile(code, pattern, flags):
             else:
                 emit(ANY)
         elif op in REPEATING_CODES:
-            if flags & SRE_FLAG_TEMPLATE:
-                raise error("internal: unsupported template operator %r" % (op,))
             if _simple(av[2]):
                 emit(REPEATING_CODES[op][2])
                 skip = _len(code); emit(0)
@@ -152,7 +150,7 @@ def _compile(code, pattern, flags):
                 if lo > MAXCODE:
                     raise error("looks too much behind")
                 if lo != hi:
-                    raise error("look-behind requires fixed-width pattern")
+                    raise PatternError("look-behind requires fixed-width pattern")
                 emit(lo) # look behind
             _compile(code, av[1], flags)
             emit(SUCCESS)
@@ -211,7 +209,7 @@ def _compile(code, pattern, flags):
             else:
                 code[skipyes] = _len(code) - skipyes + 1
         else:
-            raise error("internal: unsupported operand type %r" % (op,))
+            raise PatternError(f"internal: unsupported operand type {op!r}")
 
 def _compile_charset(charset, flags, code):
     # compile charset subprogram
@@ -237,7 +235,7 @@ def _compile_charset(charset, flags, code):
             else:
                 emit(av)
         else:
-            raise error("internal: unsupported set operator %r" % (op,))
+            raise PatternError(f"internal: unsupported set operator {op!r}")
     emit(FAILURE)
 
 def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
@@ -250,11 +248,11 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
         while True:
             try:
                 if op is LITERAL:
-                    if fixup:
-                        lo = fixup(av)
-                        charmap[lo] = 1
-                        if fixes and lo in fixes:
-                            for k in fixes[lo]:
+                    if fixup: # IGNORECASE and not LOCALE
+                        av = fixup(av)
+                        charmap[av] = 1
+                        if fixes and av in fixes:
+                            for k in fixes[av]:
                                 charmap[k] = 1
                         if not hascased and iscased(av):
                             hascased = True
@@ -262,7 +260,7 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                         charmap[av] = 1
                 elif op is RANGE:
                     r = range(av[0], av[1]+1)
-                    if fixup:
+                    if fixup: # IGNORECASE and not LOCALE
                         if fixes:
                             for i in map(fixup, r):
                                 charmap[i] = 1
@@ -289,8 +287,7 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                 # Character set contains non-BMP character codes.
                 # For range, all BMP characters in the range are already
                 # proceeded.
-                if fixup:
-                    hascased = True
+                if fixup: # IGNORECASE and not LOCALE
                     # For now, IN_UNI_IGNORE+LITERAL and
                     # IN_UNI_IGNORE+RANGE_UNI_IGNORE work for all non-BMP
                     # characters, because two characters (at least one of
@@ -301,7 +298,13 @@ def _optimize_charset(charset, iscased=None, fixup=None, fixes=None):
                     # Also, both c.lower() and c.lower().upper() are single
                     # characters for every non-BMP character.
                     if op is RANGE:
-                        op = RANGE_UNI_IGNORE
+                        if fixes: # not ASCII
+                            op = RANGE_UNI_IGNORE
+                        hascased = True
+                    else:
+                        assert op is LITERAL
+                        if not hascased and iscased(av):
+                            hascased = True
                 tail.append((op, av))
             break
 
@@ -763,4 +766,3 @@ def compile(p, flags=0):
         p.state.groups-1,
         groupindex, tuple(indexgroup)
         )
-
diff --git a/Lib/re/_constants.py b/Lib/re/_constants.py
index 92494e385c..9c3c294ba4 100644
--- a/Lib/re/_constants.py
+++ b/Lib/re/_constants.py
@@ -13,14 +13,14 @@
 
 # update when constants are added or removed
 
-MAGIC = 20221023
+MAGIC = 20230612
 
 from _sre import MAXREPEAT, MAXGROUPS
 
 # SRE standard exception (access as sre.error)
 # should this really be here?
 
-class error(Exception):
+class PatternError(Exception):
     """Exception raised for invalid regular expressions.
 
     Attributes:
@@ -53,6 +53,9 @@ def __init__(self, msg, pattern=None, pos=None):
         super().__init__(msg)
 
 
+# Backward compatibility after renaming in 3.13
+error = PatternError
+
 class _NamedIntConstant(int):
     def __new__(cls, value, name):
         self = super(_NamedIntConstant, cls).__new__(cls, value)
@@ -204,7 +207,6 @@ def _makecodes(*names):
 }
 
 # flags
-SRE_FLAG_TEMPLATE = 1 # template mode (unknown purpose, deprecated)
 SRE_FLAG_IGNORECASE = 2 # case insensitive
 SRE_FLAG_LOCALE = 4 # honour system locale
 SRE_FLAG_MULTILINE = 8 # treat target as multiline string
@@ -218,4 +220,3 @@ def _makecodes(*names):
 SRE_INFO_PREFIX = 1 # has prefix
 SRE_INFO_LITERAL = 2 # entire pattern is literal (given by prefix)
 SRE_INFO_CHARSET = 4 # pattern starts with character from given set
-RE_INFO_CHARSET = 4 # pattern starts with character from given set
diff --git a/Lib/re/_parser.py b/Lib/re/_parser.py
index 4a492b79e8..f3c779340f 100644
--- a/Lib/re/_parser.py
+++ b/Lib/re/_parser.py
@@ -61,12 +61,11 @@
     "x": SRE_FLAG_VERBOSE,
     # extensions
     "a": SRE_FLAG_ASCII,
-    "t": SRE_FLAG_TEMPLATE,
     "u": SRE_FLAG_UNICODE,
 }
 
 TYPE_FLAGS = SRE_FLAG_ASCII | SRE_FLAG_LOCALE | SRE_FLAG_UNICODE
-GLOBAL_FLAGS = SRE_FLAG_DEBUG | SRE_FLAG_TEMPLATE
+GLOBAL_FLAGS = SRE_FLAG_DEBUG
 
 # Maximal value returned by SubPattern.getwidth().
 # Must be larger than MAXREPEAT, MAXCODE and sys.maxsize.
@@ -781,8 +780,10 @@ def _parse(source, state, verbose, nested, first=False):
                                            source.tell() - start)
                     if char == "=":
                         subpatternappend((ASSERT, (dir, p)))
-                    else:
+                    elif p:
                         subpatternappend((ASSERT_NOT, (dir, p)))
+                    else:
+                        subpatternappend((FAILURE, ()))
                     continue
 
                 elif char == "(":
diff --git a/Lib/rlcompleter.py b/Lib/rlcompleter.py
index bca4a7bc52..23eb0020f4 100644
--- a/Lib/rlcompleter.py
+++ b/Lib/rlcompleter.py
@@ -31,7 +31,11 @@
 
 import atexit
 import builtins
+import inspect
+import keyword
+import re
 import __main__
+import warnings
 
 __all__ = ["Completer"]
 
@@ -85,10 +89,11 @@ def complete(self, text, state):
                 return None
 
         if state == 0:
-            if "." in text:
-                self.matches = self.attr_matches(text)
-            else:
-                self.matches = self.global_matches(text)
+            with warnings.catch_warnings(action="ignore"):
+                if "." in text:
+                    self.matches = self.attr_matches(text)
+                else:
+                    self.matches = self.global_matches(text)
         try:
             return self.matches[state]
         except IndexError:
@@ -96,7 +101,13 @@ def complete(self, text, state):
 
     def _callable_postfix(self, val, word):
         if callable(val):
-            word = word + "("
+            word += "("
+            try:
+                if not inspect.signature(val).parameters:
+                    word += ")"
+            except ValueError:
+                pass
+
         return word
 
     def global_matches(self, text):
@@ -106,18 +117,17 @@ def global_matches(self, text):
         defined in self.namespace that match.
 
         """
-        import keyword
         matches = []
         seen = {"__builtins__"}
         n = len(text)
-        for word in keyword.kwlist:
+        for word in keyword.kwlist + keyword.softkwlist:
             if word[:n] == text:
                 seen.add(word)
                 if word in {'finally', 'try'}:
                     word = word + ':'
                 elif word not in {'False', 'None', 'True',
                                   'break', 'continue', 'pass',
-                                  'else'}:
+                                  'else', '_'}:
                     word = word + ' '
                 matches.append(word)
         for nspace in [self.namespace, builtins.__dict__]:
@@ -139,7 +149,6 @@ def attr_matches(self, text):
         with a __getattr__ hook is evaluated.
 
         """
-        import re
         m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
         if not m:
             return []
@@ -169,13 +178,20 @@ def attr_matches(self, text):
                 if (word[:n] == attr and
                     not (noprefix and word[:n+1] == noprefix)):
                     match = "%s.%s" % (expr, word)
-                    try:
-                        val = getattr(thisobject, word)
-                    except Exception:
-                        pass  # Include even if attribute not set
+                    if isinstance(getattr(type(thisobject), word, None),
+                                  property):
+                        # bpo-44752: thisobject.word is a method decorated by
+                        # `@property`. What follows applies a postfix if
+                        # thisobject.word is callable, but know we know that
+                        # this is not callable (because it is a property).
+                        # Also, getattr(thisobject, word) will evaluate the
+                        # property method, which is not desirable.
+                        matches.append(match)
+                        continue
+                    if (value := getattr(thisobject, word, None)) is not None:
+                        matches.append(self._callable_postfix(value, match))
                     else:
-                        match = self._callable_postfix(val, match)
-                    matches.append(match)
+                        matches.append(match)
             if matches or not noprefix:
                 break
             if noprefix == '_':
diff --git a/Lib/runpy.py b/Lib/runpy.py
index c7d3d8caad..ef54d3282e 100644
--- a/Lib/runpy.py
+++ b/Lib/runpy.py
@@ -14,18 +14,20 @@
 import importlib.machinery # importlib first so we can test #15386 via -m
 import importlib.util
 import io
-import types
 import os
 
 __all__ = [
     "run_module", "run_path",
 ]
 
+# avoid 'import types' just for ModuleType
+ModuleType = type(sys)
+
 class _TempModule(object):
     """Temporarily replace a module in sys.modules with an empty namespace"""
     def __init__(self, mod_name):
         self.mod_name = mod_name
-        self.module = types.ModuleType(mod_name)
+        self.module = ModuleType(mod_name)
         self._saved_module = []
 
     def __enter__(self):
@@ -245,17 +247,17 @@ def _get_main_module_details(error=ImportError):
         sys.modules[main_name] = saved_main
 
 
-def _get_code_from_file(run_name, fname):
+def _get_code_from_file(fname):
     # Check for a compiled file first
     from pkgutil import read_code
-    decoded_path = os.path.abspath(os.fsdecode(fname))
-    with io.open_code(decoded_path) as f:
+    code_path = os.path.abspath(fname)
+    with io.open_code(code_path) as f:
         code = read_code(f)
     if code is None:
         # That didn't work, so try it as normal source code
-        with io.open_code(decoded_path) as f:
+        with io.open_code(code_path) as f:
             code = compile(f.read(), fname, 'exec')
-    return code, fname
+    return code
 
 def run_path(path_name, init_globals=None, run_name=None):
     """Execute code located at the specified filesystem location.
@@ -277,17 +279,13 @@ def run_path(path_name, init_globals=None, run_name=None):
     pkg_name = run_name.rpartition(".")[0]
     from pkgutil import get_importer
     importer = get_importer(path_name)
-    # Trying to avoid importing imp so as to not consume the deprecation warning.
-    is_NullImporter = False
-    if type(importer).__module__ == 'imp':
-        if type(importer).__name__ == 'NullImporter':
-            is_NullImporter = True
-    if isinstance(importer, type(None)) or is_NullImporter:
+    path_name = os.fsdecode(path_name)
+    if isinstance(importer, type(None)):
         # Not a valid sys.path entry, so run the code directly
         # execfile() doesn't help as we want to allow compiled files
-        code, fname = _get_code_from_file(run_name, path_name)
+        code = _get_code_from_file(path_name)
         return _run_module_code(code, init_globals, run_name,
-                                pkg_name=pkg_name, script_name=fname)
+                                pkg_name=pkg_name, script_name=path_name)
     else:
         # Finder is defined for path, so add it to
         # the start of sys.path
diff --git a/Lib/secrets.py b/Lib/secrets.py
index a546efbdd4..566a09b731 100644
--- a/Lib/secrets.py
+++ b/Lib/secrets.py
@@ -2,7 +2,7 @@
 managing secrets such as account authentication, tokens, and similar.
 
 See PEP 506 for more information.
-https://www.python.org/dev/peps/pep-0506/
+https://peps.python.org/pep-0506/
 
 """
 
@@ -13,7 +13,6 @@
 
 
 import base64
-import binascii
 
 from hmac import compare_digest
 from random import SystemRandom
@@ -56,7 +55,7 @@ def token_hex(nbytes=None):
     'f9bf78b9a18ce6d46a0cd2b0b86df9da'
 
     """
-    return binascii.hexlify(token_bytes(nbytes)).decode('ascii')
+    return token_bytes(nbytes).hex()
 
 def token_urlsafe(nbytes=None):
     """Return a random URL-safe text string, in Base64 encoding.
diff --git a/Lib/selectors.py b/Lib/selectors.py
index c3b065b522..b8e5f6a4f7 100644
--- a/Lib/selectors.py
+++ b/Lib/selectors.py
@@ -66,12 +66,16 @@ def __init__(self, selector):
     def __len__(self):
         return len(self._selector._fd_to_key)
 
+    def get(self, fileobj, default=None):
+        fd = self._selector._fileobj_lookup(fileobj)
+        return self._selector._fd_to_key.get(fd, default)
+
     def __getitem__(self, fileobj):
-        try:
-            fd = self._selector._fileobj_lookup(fileobj)
-            return self._selector._fd_to_key[fd]
-        except KeyError:
-            raise KeyError("{!r} is not registered".format(fileobj)) from None
+        fd = self._selector._fileobj_lookup(fileobj)
+        key = self._selector._fd_to_key.get(fd)
+        if key is None:
+            raise KeyError("{!r} is not registered".format(fileobj))
+        return key
 
     def __iter__(self):
         return iter(self._selector._fd_to_key)
@@ -272,19 +276,6 @@ def close(self):
     def get_map(self):
         return self._map
 
-    def _key_from_fd(self, fd):
-        """Return the key associated to a given file descriptor.
-
-        Parameters:
-        fd -- file descriptor
-
-        Returns:
-        corresponding key, or None if not found
-        """
-        try:
-            return self._fd_to_key[fd]
-        except KeyError:
-            return None
 
 
 class SelectSelector(_BaseSelectorImpl):
@@ -323,17 +314,15 @@ def select(self, timeout=None):
             r, w, _ = self._select(self._readers, self._writers, [], timeout)
         except InterruptedError:
             return ready
-        r = set(r)
-        w = set(w)
-        for fd in r | w:
-            events = 0
-            if fd in r:
-                events |= EVENT_READ
-            if fd in w:
-                events |= EVENT_WRITE
-
-            key = self._key_from_fd(fd)
+        r = frozenset(r)
+        w = frozenset(w)
+        rw = r | w
+        fd_to_key_get = self._fd_to_key.get
+        for fd in rw:
+            key = fd_to_key_get(fd)
             if key:
+                events = ((fd in r and EVENT_READ)
+                          | (fd in w and EVENT_WRITE))
                 ready.append((key, events & key.events))
         return ready
 
@@ -350,11 +339,8 @@ def __init__(self):
 
     def register(self, fileobj, events, data=None):
         key = super().register(fileobj, events, data)
-        poller_events = 0
-        if events & EVENT_READ:
-            poller_events |= self._EVENT_READ
-        if events & EVENT_WRITE:
-            poller_events |= self._EVENT_WRITE
+        poller_events = ((events & EVENT_READ and self._EVENT_READ)
+                         | (events & EVENT_WRITE and self._EVENT_WRITE) )
         try:
             self._selector.register(key.fd, poller_events)
         except:
@@ -380,11 +366,8 @@ def modify(self, fileobj, events, data=None):
 
         changed = False
         if events != key.events:
-            selector_events = 0
-            if events & EVENT_READ:
-                selector_events |= self._EVENT_READ
-            if events & EVENT_WRITE:
-                selector_events |= self._EVENT_WRITE
+            selector_events = ((events & EVENT_READ and self._EVENT_READ)
+                               | (events & EVENT_WRITE and self._EVENT_WRITE))
             try:
                 self._selector.modify(key.fd, selector_events)
             except:
@@ -415,15 +398,13 @@ def select(self, timeout=None):
             fd_event_list = self._selector.poll(timeout)
         except InterruptedError:
             return ready
-        for fd, event in fd_event_list:
-            events = 0
-            if event & ~self._EVENT_READ:
-                events |= EVENT_WRITE
-            if event & ~self._EVENT_WRITE:
-                events |= EVENT_READ
 
-            key = self._key_from_fd(fd)
+        fd_to_key_get = self._fd_to_key.get
+        for fd, event in fd_event_list:
+            key = fd_to_key_get(fd)
             if key:
+                events = ((event & ~self._EVENT_READ and EVENT_WRITE)
+                           | (event & ~self._EVENT_WRITE and EVENT_READ))
                 ready.append((key, events & key.events))
         return ready
 
@@ -439,6 +420,9 @@ class PollSelector(_PollLikeSelector):
 
 if hasattr(select, 'epoll'):
 
+    _NOT_EPOLLIN = ~select.EPOLLIN
+    _NOT_EPOLLOUT = ~select.EPOLLOUT
+
     class EpollSelector(_PollLikeSelector):
         """Epoll-based selector."""
         _selector_cls = select.epoll
@@ -461,22 +445,20 @@ def select(self, timeout=None):
             # epoll_wait() expects `maxevents` to be greater than zero;
             # we want to make sure that `select()` can be called when no
             # FD is registered.
-            max_ev = max(len(self._fd_to_key), 1)
+            max_ev = len(self._fd_to_key) or 1
 
             ready = []
             try:
                 fd_event_list = self._selector.poll(timeout, max_ev)
             except InterruptedError:
                 return ready
-            for fd, event in fd_event_list:
-                events = 0
-                if event & ~select.EPOLLIN:
-                    events |= EVENT_WRITE
-                if event & ~select.EPOLLOUT:
-                    events |= EVENT_READ
 
-                key = self._key_from_fd(fd)
+            fd_to_key = self._fd_to_key
+            for fd, event in fd_event_list:
+                key = fd_to_key.get(fd)
                 if key:
+                    events = ((event & _NOT_EPOLLIN and EVENT_WRITE)
+                              | (event & _NOT_EPOLLOUT and EVENT_READ))
                     ready.append((key, events & key.events))
             return ready
 
@@ -566,17 +548,15 @@ def select(self, timeout=None):
                 kev_list = self._selector.control(None, max_ev, timeout)
             except InterruptedError:
                 return ready
+
+            fd_to_key_get = self._fd_to_key.get
             for kev in kev_list:
                 fd = kev.ident
                 flag = kev.filter
-                events = 0
-                if flag == select.KQ_FILTER_READ:
-                    events |= EVENT_READ
-                if flag == select.KQ_FILTER_WRITE:
-                    events |= EVENT_WRITE
-
-                key = self._key_from_fd(fd)
+                key = fd_to_key_get(fd)
                 if key:
+                    events = ((flag == select.KQ_FILTER_READ and EVENT_READ)
+                              | (flag == select.KQ_FILTER_WRITE and EVENT_WRITE))
                     ready.append((key, events & key.events))
             return ready
 
diff --git a/Lib/shelve.py b/Lib/shelve.py
index 5d443a0fa8..50584716e9 100644
--- a/Lib/shelve.py
+++ b/Lib/shelve.py
@@ -56,7 +56,7 @@
 the persistent dictionary on disk, if feasible).
 """
 
-from pickle import Pickler, Unpickler
+from pickle import DEFAULT_PROTOCOL, Pickler, Unpickler
 from io import BytesIO
 
 import collections.abc
@@ -85,7 +85,7 @@ def __init__(self, dict, protocol=None, writeback=False,
                  keyencoding="utf-8"):
         self.dict = dict
         if protocol is None:
-            protocol = 3
+            protocol = DEFAULT_PROTOCOL
         self._protocol = protocol
         self.writeback = writeback
         self.cache = {}
@@ -226,6 +226,13 @@ def __init__(self, filename, flag='c', protocol=None, writeback=False):
         import dbm
         Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback)
 
+    def clear(self):
+        """Remove all items from the shelf."""
+        # Call through to the clear method on dbm-backed shelves.
+        # see https://github.com/python/cpython/issues/107089
+        self.cache.clear()
+        self.dict.clear()
+
 
 def open(filename, flag='c', protocol=None, writeback=False):
     """Open a persistent dictionary for reading and writing.
diff --git a/Lib/shlex.py b/Lib/shlex.py
index 4801a6c1d4..f4821616b6 100644
--- a/Lib/shlex.py
+++ b/Lib/shlex.py
@@ -305,9 +305,7 @@ def __next__(self):
 def split(s, comments=False, posix=True):
     """Split the string *s* using shell-like syntax."""
     if s is None:
-        import warnings
-        warnings.warn("Passing None for 's' to shlex.split() is deprecated.",
-                      DeprecationWarning, stacklevel=2)
+        raise ValueError("s argument must not be None")
     lex = shlex(s, posix=posix)
     lex.whitespace_split = True
     if not comments:
@@ -335,10 +333,7 @@ def quote(s):
 
 
 def _print_tokens(lexer):
-    while 1:
-        tt = lexer.get_token()
-        if not tt:
-            break
+    while tt := lexer.get_token():
         print("Token: " + repr(tt))
 
 if __name__ == '__main__':
diff --git a/Lib/shutil.py b/Lib/shutil.py
index 6803ee3ce6..7df972012c 100644
--- a/Lib/shutil.py
+++ b/Lib/shutil.py
@@ -10,7 +10,6 @@
 import fnmatch
 import collections
 import errno
-import warnings
 
 try:
     import zlib
@@ -48,7 +47,8 @@
 COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
 # This should never be removed, see rationale in:
 # https://bugs.python.org/issue43743#msg393429
-_USE_CP_SENDFILE = hasattr(os, "sendfile") and sys.platform.startswith("linux")
+_USE_CP_SENDFILE = (hasattr(os, "sendfile")
+                    and sys.platform.startswith(("linux", "android")))
 _HAS_FCOPYFILE = posix and hasattr(posix, "_fcopyfile")  # macOS
 
 # CMD defaults in Windows 10
@@ -153,16 +153,14 @@ def _fastcopy_sendfile(fsrc, fdst):
             err.filename = fsrc.name
             err.filename2 = fdst.name
 
-            # XXX RUSTPYTHON TODO: consistent OSError.errno
-            if hasattr(err, "errno") and err.errno == errno.ENOTSOCK:
+            if err.errno == errno.ENOTSOCK:
                 # sendfile() on this platform (probably Linux < 2.6.33)
                 # does not support copies between regular files (only
                 # sockets).
                 _USE_CP_SENDFILE = False
                 raise _GiveupOnFastCopy(err)
 
-            # XXX RUSTPYTHON TODO: consistent OSError.errno
-            if hasattr(err, "errno") and err.errno == errno.ENOSPC:  # filesystem is full
+            if err.errno == errno.ENOSPC:  # filesystem is full
                 raise err from None
 
             # Give up on first call and if no data was copied.
@@ -304,16 +302,17 @@ def copymode(src, dst, *, follow_symlinks=True):
     sys.audit("shutil.copymode", src, dst)
 
     if not follow_symlinks and _islink(src) and os.path.islink(dst):
-        if os.name == 'nt':
-            stat_func, chmod_func = os.lstat, os.chmod
-        elif hasattr(os, 'lchmod'):
+        if hasattr(os, 'lchmod'):
             stat_func, chmod_func = os.lstat, os.lchmod
         else:
             return
     else:
+        stat_func = _stat
         if os.name == 'nt' and os.path.islink(dst):
-            dst = os.path.realpath(dst, strict=True)
-        stat_func, chmod_func = _stat, os.chmod
+            def chmod_func(*args):
+                os.chmod(*args, follow_symlinks=True)
+        else:
+            chmod_func = os.chmod
 
     st = stat_func(src)
     chmod_func(dst, stat.S_IMODE(st.st_mode))
@@ -388,16 +387,8 @@ def lookup(name):
     # We must copy extended attributes before the file is (potentially)
     # chmod()'ed read-only, otherwise setxattr() will error with -EACCES.
     _copyxattr(src, dst, follow_symlinks=follow)
-    _chmod = lookup("chmod")
-    if os.name == 'nt':
-        if follow:
-            if os.path.islink(dst):
-                dst = os.path.realpath(dst, strict=True)
-        else:
-            def _chmod(*args, **kwargs):
-                os.chmod(*args)
     try:
-        _chmod(dst, mode, follow_symlinks=follow)
+        lookup("chmod")(dst, mode, follow_symlinks=follow)
     except NotImplementedError:
         # if we got a NotImplementedError, it's because
         #   * follow_symlinks=False,
@@ -565,7 +556,7 @@ def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
     If the optional symlinks flag is true, symbolic links in the
     source tree result in symbolic links in the destination tree; if
     it is false, the contents of the files pointed to by symbolic
-    links are copied. If the file pointed by the symlink doesn't
+    links are copied. If the file pointed to by the symlink doesn't
     exist, an exception will be added in the list of errors raised in
     an Error exception at the end of the copy process.
 
@@ -605,118 +596,115 @@ def copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2,
                      dirs_exist_ok=dirs_exist_ok)
 
 if hasattr(os.stat_result, 'st_file_attributes'):
-    def _rmtree_islink(path):
-        try:
-            st = os.lstat(path)
-            return (stat.S_ISLNK(st.st_mode) or
-                (st.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
-                 and st.st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT))
-        except OSError:
-            return False
+    def _rmtree_islink(st):
+        return (stat.S_ISLNK(st.st_mode) or
+            (st.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT
+                and st.st_reparse_tag == stat.IO_REPARSE_TAG_MOUNT_POINT))
 else:
-    def _rmtree_islink(path):
-        return os.path.islink(path)
+    def _rmtree_islink(st):
+        return stat.S_ISLNK(st.st_mode)
 
 # version vulnerable to race conditions
 def _rmtree_unsafe(path, onexc):
-    try:
-        with os.scandir(path) as scandir_it:
-            entries = list(scandir_it)
-    except OSError as err:
-        onexc(os.scandir, path, err)
-        entries = []
-    for entry in entries:
-        fullname = entry.path
-        try:
-            is_dir = entry.is_dir(follow_symlinks=False)
-        except OSError:
-            is_dir = False
-
-        if is_dir and not entry.is_junction():
+    def onerror(err):
+        if not isinstance(err, FileNotFoundError):
+            onexc(os.scandir, err.filename, err)
+    results = os.walk(path, topdown=False, onerror=onerror, followlinks=os._walk_symlinks_as_files)
+    for dirpath, dirnames, filenames in results:
+        for name in dirnames:
+            fullname = os.path.join(dirpath, name)
             try:
-                if entry.is_symlink():
-                    # This can only happen if someone replaces
-                    # a directory with a symlink after the call to
-                    # os.scandir or entry.is_dir above.
-                    raise OSError("Cannot call rmtree on a symbolic link")
-            except OSError as err:
-                onexc(os.path.islink, fullname, err)
+                os.rmdir(fullname)
+            except FileNotFoundError:
                 continue
-            _rmtree_unsafe(fullname, onexc)
-        else:
+            except OSError as err:
+                onexc(os.rmdir, fullname, err)
+        for name in filenames:
+            fullname = os.path.join(dirpath, name)
             try:
                 os.unlink(fullname)
+            except FileNotFoundError:
+                continue
             except OSError as err:
                 onexc(os.unlink, fullname, err)
     try:
         os.rmdir(path)
+    except FileNotFoundError:
+        pass
     except OSError as err:
         onexc(os.rmdir, path, err)
 
 # Version using fd-based APIs to protect against races
-def _rmtree_safe_fd(topfd, path, onexc):
+def _rmtree_safe_fd(stack, onexc):
+    # Each stack item has four elements:
+    # * func: The first operation to perform: os.lstat, os.close or os.rmdir.
+    #   Walking a directory starts with an os.lstat() to detect symlinks; in
+    #   this case, func is updated before subsequent operations and passed to
+    #   onexc() if an error occurs.
+    # * dirfd: Open file descriptor, or None if we're processing the top-level
+    #   directory given to rmtree() and the user didn't supply dir_fd.
+    # * path: Path of file to operate upon. This is passed to onexc() if an
+    #   error occurs.
+    # * orig_entry: os.DirEntry, or None if we're processing the top-level
+    #   directory given to rmtree(). We used the cached stat() of the entry to
+    #   save a call to os.lstat() when walking subdirectories.
+    func, dirfd, path, orig_entry = stack.pop()
+    name = path if orig_entry is None else orig_entry.name
     try:
+        if func is os.close:
+            os.close(dirfd)
+            return
+        if func is os.rmdir:
+            os.rmdir(name, dir_fd=dirfd)
+            return
+
+        # Note: To guard against symlink races, we use the standard
+        # lstat()/open()/fstat() trick.
+        assert func is os.lstat
+        if orig_entry is None:
+            orig_st = os.lstat(name, dir_fd=dirfd)
+        else:
+            orig_st = orig_entry.stat(follow_symlinks=False)
+
+        func = os.open  # For error reporting.
+        topfd = os.open(name, os.O_RDONLY | os.O_NONBLOCK, dir_fd=dirfd)
+
+        func = os.path.islink  # For error reporting.
+        try:
+            if not os.path.samestat(orig_st, os.fstat(topfd)):
+                # Symlinks to directories are forbidden, see GH-46010.
+                raise OSError("Cannot call rmtree on a symbolic link")
+            stack.append((os.rmdir, dirfd, path, orig_entry))
+        finally:
+            stack.append((os.close, topfd, path, orig_entry))
+
+        func = os.scandir  # For error reporting.
         with os.scandir(topfd) as scandir_it:
             entries = list(scandir_it)
-    except OSError as err:
-        err.filename = path
-        onexc(os.scandir, path, err)
-        return
-    for entry in entries:
-        fullname = os.path.join(path, entry.name)
-        try:
-            is_dir = entry.is_dir(follow_symlinks=False)
-        except OSError:
-            is_dir = False
-        else:
-            if is_dir:
-                try:
-                    orig_st = entry.stat(follow_symlinks=False)
-                    is_dir = stat.S_ISDIR(orig_st.st_mode)
-                except OSError as err:
-                    onexc(os.lstat, fullname, err)
-                    continue
-        if is_dir:
+        for entry in entries:
+            fullname = os.path.join(path, entry.name)
             try:
-                dirfd = os.open(entry.name, os.O_RDONLY | os.O_NONBLOCK, dir_fd=topfd)
-                dirfd_closed = False
-            except OSError as err:
-                onexc(os.open, fullname, err)
-            else:
-                try:
-                    if os.path.samestat(orig_st, os.fstat(dirfd)):
-                        _rmtree_safe_fd(dirfd, fullname, onexc)
-                        try:
-                            os.close(dirfd)
-                        except OSError as err:
-                            # close() should not be retried after an error.
-                            dirfd_closed = True
-                            onexc(os.close, fullname, err)
-                        dirfd_closed = True
-                        try:
-                            os.rmdir(entry.name, dir_fd=topfd)
-                        except OSError as err:
-                            onexc(os.rmdir, fullname, err)
-                    else:
-                        try:
-                            # This can only happen if someone replaces
-                            # a directory with a symlink after the call to
-                            # os.scandir or stat.S_ISDIR above.
-                            raise OSError("Cannot call rmtree on a symbolic "
-                                          "link")
-                        except OSError as err:
-                            onexc(os.path.islink, fullname, err)
-                finally:
-                    if not dirfd_closed:
-                        try:
-                            os.close(dirfd)
-                        except OSError as err:
-                            onexc(os.close, fullname, err)
-        else:
+                if entry.is_dir(follow_symlinks=False):
+                    # Traverse into sub-directory.
+                    stack.append((os.lstat, topfd, fullname, entry))
+                    continue
+            except FileNotFoundError:
+                continue
+            except OSError:
+                pass
             try:
                 os.unlink(entry.name, dir_fd=topfd)
+            except FileNotFoundError:
+                continue
             except OSError as err:
                 onexc(os.unlink, fullname, err)
+    except FileNotFoundError as err:
+        if orig_entry is None or func is os.close:
+            err.filename = path
+            onexc(func, path, err)
+    except OSError as err:
+        err.filename = path
+        onexc(func, path, err)
 
 _use_fd_functions = ({os.open, os.stat, os.unlink, os.rmdir} <=
                      os.supports_dir_fd and
@@ -769,41 +757,16 @@ def onexc(*args):
         # While the unsafe rmtree works fine on bytes, the fd based does not.
         if isinstance(path, bytes):
             path = os.fsdecode(path)
-        # Note: To guard against symlink races, we use the standard
-        # lstat()/open()/fstat() trick.
-        try:
-            orig_st = os.lstat(path, dir_fd=dir_fd)
-        except Exception as err:
-            onexc(os.lstat, path, err)
-            return
+        stack = [(os.lstat, dir_fd, path, None)]
         try:
-            fd = os.open(path, os.O_RDONLY | os.O_NONBLOCK, dir_fd=dir_fd)
-            fd_closed = False
-        except Exception as err:
-            onexc(os.open, path, err)
-            return
-        try:
-            if os.path.samestat(orig_st, os.fstat(fd)):
-                _rmtree_safe_fd(fd, path, onexc)
-                try:
-                    os.close(fd)
-                except OSError as err:
-                    # close() should not be retried after an error.
-                    fd_closed = True
-                    onexc(os.close, path, err)
-                fd_closed = True
-                try:
-                    os.rmdir(path, dir_fd=dir_fd)
-                except OSError as err:
-                    onexc(os.rmdir, path, err)
-            else:
-                try:
-                    # symlinks to directories are forbidden, see bug #1669
-                    raise OSError("Cannot call rmtree on a symbolic link")
-                except OSError as err:
-                    onexc(os.path.islink, path, err)
+            while stack:
+                _rmtree_safe_fd(stack, onexc)
         finally:
-            if not fd_closed:
+            # Close any file descriptors still on the stack.
+            while stack:
+                func, fd, path, entry = stack.pop()
+                if func is not os.close:
+                    continue
                 try:
                     os.close(fd)
                 except OSError as err:
@@ -812,7 +775,12 @@ def onexc(*args):
         if dir_fd is not None:
             raise NotImplementedError("dir_fd unavailable on this platform")
         try:
-            if _rmtree_islink(path):
+            st = os.lstat(path)
+        except OSError as err:
+            onexc(os.lstat, path, err)
+            return
+        try:
+            if _rmtree_islink(st):
                 # symlinks to directories are forbidden, see bug #1669
                 raise OSError("Cannot call rmtree on a symbolic link")
         except OSError as err:
@@ -1428,11 +1396,18 @@ def disk_usage(path):
         return _ntuple_diskusage(total, used, free)
 
 
-def chown(path, user=None, group=None):
+def chown(path, user=None, group=None, *, dir_fd=None, follow_symlinks=True):
     """Change owner user and group of the given path.
 
     user and group can be the uid/gid or the user/group names, and in that case,
     they are converted to their respective uid/gid.
+
+    If dir_fd is set, it should be an open file descriptor to the directory to
+    be used as the root of *path* if it is relative.
+
+    If follow_symlinks is set to False and the last element of the path is a
+    symbolic link, chown will modify the link itself and not the file being
+    referenced by the link.
     """
     sys.audit('shutil.chown', path, user, group)
 
@@ -1458,7 +1433,8 @@ def chown(path, user=None, group=None):
         if _group is None:
             raise LookupError("no such group: {!r}".format(group))
 
-    os.chown(path, _user, _group)
+    os.chown(path, _user, _group, dir_fd=dir_fd,
+             follow_symlinks=follow_symlinks)
 
 def get_terminal_size(fallback=(80, 24)):
     """Get the size of the terminal window.
@@ -1575,21 +1551,21 @@ def which(cmd, mode=os.F_OK | os.X_OK, path=None):
     if sys.platform == "win32":
         # PATHEXT is necessary to check on Windows.
         pathext_source = os.getenv("PATHEXT") or _WIN_DEFAULT_PATHEXT
-        pathext = [ext for ext in pathext_source.split(os.pathsep) if ext]
+        pathext = pathext_source.split(os.pathsep)
+        pathext = [ext.rstrip('.') for ext in pathext if ext]
 
         if use_bytes:
             pathext = [os.fsencode(ext) for ext in pathext]
 
-        files = ([cmd] + [cmd + ext for ext in pathext])
+        files = [cmd + ext for ext in pathext]
 
-        # gh-109590. If we are looking for an executable, we need to look
-        # for a PATHEXT match. The first cmd is the direct match
-        # (e.g. python.exe instead of python)
-        # Check that direct match first if and only if the extension is in PATHEXT
-        # Otherwise check it last
-        suffix = os.path.splitext(files[0])[1].upper()
-        if mode & os.X_OK and not any(suffix == ext.upper() for ext in pathext):
-            files.append(files.pop(0))
+        # If X_OK in mode, simulate the cmd.exe behavior: look at direct
+        # match if and only if the extension is in PATHEXT.
+        # If X_OK not in mode, simulate the first result of where.exe:
+        # always look at direct match before a PATHEXT match.
+        normcmd = cmd.upper()
+        if not (mode & os.X_OK) or any(normcmd.endswith(ext.upper()) for ext in pathext):
+            files.insert(0, cmd)
     else:
         # On other platforms you don't have things like PATHEXT to tell you
         # what file suffixes are executable, so just pass on cmd as-is.
@@ -1598,7 +1574,7 @@ def which(cmd, mode=os.F_OK | os.X_OK, path=None):
     seen = set()
     for dir in path:
         normdir = os.path.normcase(dir)
-        if not normdir in seen:
+        if normdir not in seen:
             seen.add(normdir)
             for thefile in files:
                 name = os.path.join(dir, thefile)
diff --git a/Lib/site.py b/Lib/site.py
index acc8481b13..2983ca7154 100644
--- a/Lib/site.py
+++ b/Lib/site.py
@@ -75,6 +75,7 @@
 import _sitebuiltins
 import io
 import stat
+import errno
 
 # Prefixes for site-packages; add additional prefixes like /usr/local here
 PREFIXES = [sys.prefix, sys.exec_prefix]
@@ -179,35 +180,46 @@ def addpackage(sitedir, name, known_paths):
         return
     _trace(f"Processing .pth file: {fullname!r}")
     try:
-        # locale encoding is not ideal especially on Windows. But we have used
-        # it for a long time. setuptools uses the locale encoding too.
-        f = io.TextIOWrapper(io.open_code(fullname), encoding="locale")
+        with io.open_code(fullname) as f:
+            pth_content = f.read()
     except OSError:
         return
-    with f:
-        for n, line in enumerate(f):
-            if line.startswith("#"):
-                continue
-            if line.strip() == "":
+
+    try:
+        # Accept BOM markers in .pth files as we do in source files
+        # (Windows PowerShell 5.1 makes it hard to emit UTF-8 files without a BOM)
+        pth_content = pth_content.decode("utf-8-sig")
+    except UnicodeDecodeError:
+        # Fallback to locale encoding for backward compatibility.
+        # We will deprecate this fallback in the future.
+        import locale
+        pth_content = pth_content.decode(locale.getencoding())
+        _trace(f"Cannot read {fullname!r} as UTF-8. "
+               f"Using fallback encoding {locale.getencoding()!r}")
+
+    for n, line in enumerate(pth_content.splitlines(), 1):
+        if line.startswith("#"):
+            continue
+        if line.strip() == "":
+            continue
+        try:
+            if line.startswith(("import ", "import\t")):
+                exec(line)
                 continue
-            try:
-                if line.startswith(("import ", "import\t")):
-                    exec(line)
-                    continue
-                line = line.rstrip()
-                dir, dircase = makepath(sitedir, line)
-                if not dircase in known_paths and os.path.exists(dir):
-                    sys.path.append(dir)
-                    known_paths.add(dircase)
-            except Exception as exc:
-                print("Error processing line {:d} of {}:\n".format(n+1, fullname),
-                      file=sys.stderr)
-                import traceback
-                for record in traceback.format_exception(exc):
-                    for line in record.splitlines():
-                        print('  '+line, file=sys.stderr)
-                print("\nRemainder of file ignored", file=sys.stderr)
-                break
+            line = line.rstrip()
+            dir, dircase = makepath(sitedir, line)
+            if dircase not in known_paths and os.path.exists(dir):
+                sys.path.append(dir)
+                known_paths.add(dircase)
+        except Exception as exc:
+            print(f"Error processing line {n:d} of {fullname}:\n",
+                  file=sys.stderr)
+            import traceback
+            for record in traceback.format_exception(exc):
+                for line in record.splitlines():
+                    print('  '+line, file=sys.stderr)
+            print("\nRemainder of file ignored", file=sys.stderr)
+            break
     if reset:
         known_paths = None
     return known_paths
@@ -270,14 +282,18 @@ def check_enableusersite():
 #
 # See https://bugs.python.org/issue29585
 
+# Copy of sysconfig._get_implementation()
+def _get_implementation():
+    return 'RustPython' # XXX: RustPython; for site-packages
+
 # Copy of sysconfig._getuserbase()
 def _getuserbase():
     env_base = os.environ.get("PYTHONUSERBASE", None)
     if env_base:
         return env_base
 
-    # Emscripten, VxWorks, and WASI have no home directories
-    if sys.platform in {"emscripten", "vxworks", "wasi"}:
+    # Emscripten, iOS, tvOS, VxWorks, WASI, and watchOS have no home directories
+    if sys.platform in {"emscripten", "ios", "tvos", "vxworks", "wasi", "watchos"}:
         return None
 
     def joinuser(*args):
@@ -285,8 +301,7 @@ def joinuser(*args):
 
     if os.name == "nt":
         base = os.environ.get("APPDATA") or "~"
-        # XXX: RUSTPYTHON; please keep this change for site-packages
-        return joinuser(base, "RustPython")
+        return joinuser(base, _get_implementation())
 
     if sys.platform == "darwin" and sys._framework:
         return joinuser("~", "Library", sys._framework,
@@ -298,15 +313,22 @@ def joinuser(*args):
 # Same to sysconfig.get_path('purelib', os.name+'_user')
 def _get_path(userbase):
     version = sys.version_info
+    if hasattr(sys, 'abiflags') and 't' in sys.abiflags:
+        abi_thread = 't'
+    else:
+        abi_thread = ''
 
+    implementation = _get_implementation()
+    implementation_lower = implementation.lower()
     if os.name == 'nt':
         ver_nodot = sys.winver.replace('.', '')
-        return f'{userbase}\\RustPython{ver_nodot}\\site-packages'
+        return f'{userbase}\\{implementation}{ver_nodot}\\site-packages'
 
     if sys.platform == 'darwin' and sys._framework:
-        return f'{userbase}/lib/rustpython/site-packages'
+        return f'{userbase}/lib/{implementation_lower}/site-packages'
 
-    return f'{userbase}/lib/rustpython{version[0]}.{version[1]}/site-packages'
+    # XXX: RUSTPYTHON
+    return f'{userbase}/lib/rustpython{version[0]}.{version[1]}{abi_thread}/site-packages'
 
 
 def getuserbase():
@@ -372,6 +394,12 @@ def getsitepackages(prefixes=None):
             continue
         seen.add(prefix)
 
+        implementation = _get_implementation().lower()
+        ver = sys.version_info
+        if hasattr(sys, 'abiflags') and 't' in sys.abiflags:
+            abi_thread = 't'
+        else:
+            abi_thread = ''
         if os.sep == '/':
             libdirs = [sys.platlibdir]
             if sys.platlibdir != "lib":
@@ -379,8 +407,7 @@ def getsitepackages(prefixes=None):
 
             for libdir in libdirs:
                 path = os.path.join(prefix, libdir,
-                                    # XXX: RUSTPYTHON; please keep this change for site-packages
-                                    "rustpython%d.%d" % sys.version_info[:2],
+                                    f"{implementation}{ver[0]}.{ver[1]}{abi_thread}",
                                     "site-packages")
                 sitepackages.append(path)
         else:
@@ -417,8 +444,9 @@ def setcopyright():
     """Set 'copyright' and 'credits' in builtins"""
     builtins.copyright = _sitebuiltins._Printer("copyright", sys.copyright)
     builtins.credits = _sitebuiltins._Printer("credits", """\
-    Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
-    for supporting Python development.  See www.python.org for more information.""")
+    Thanks to CWI, CNRI, BeOpen, Zope Corporation, the Python Software
+    Foundation, and a cast of thousands for supporting Python
+    development.  See www.python.org for more information.""")
     files, dirs = [], []
     # Not all modules are required to have a __file__ attribute.  See
     # PEP 420 for more details.
@@ -437,27 +465,76 @@ def setcopyright():
 def sethelper():
     builtins.help = _sitebuiltins._Helper()
 
+
+def gethistoryfile():
+    """Check if the PYTHON_HISTORY environment variable is set and define
+    it as the .python_history file.  If PYTHON_HISTORY is not set, use the
+    default .python_history file.
+    """
+    if not sys.flags.ignore_environment:
+        history = os.environ.get("PYTHON_HISTORY")
+        if history:
+            return history
+    return os.path.join(os.path.expanduser('~'),
+        '.python_history')
+
+
 def enablerlcompleter():
     """Enable default readline configuration on interactive prompts, by
     registering a sys.__interactivehook__.
+    """
+    sys.__interactivehook__ = register_readline
+
+
+def register_readline():
+    """Configure readline completion on interactive prompts.
 
     If the readline module can be imported, the hook will set the Tab key
     as completion key and register ~/.python_history as history file.
     This can be overridden in the sitecustomize or usercustomize module,
     or in a PYTHONSTARTUP file.
     """
-    def register_readline():
-        import atexit
+    if not sys.flags.ignore_environment:
+        PYTHON_BASIC_REPL = os.getenv("PYTHON_BASIC_REPL")
+    else:
+        PYTHON_BASIC_REPL = False
+
+    import atexit
+
+    try:
         try:
             import readline
-            import rlcompleter
         except ImportError:
-            return
+            readline = None
+        else:
+            import rlcompleter  # noqa: F401
+    except ImportError:
+        return
 
+    try:
+        if PYTHON_BASIC_REPL:
+            CAN_USE_PYREPL = False
+        else:
+            original_path = sys.path
+            sys.path = [p for p in original_path if p != '']
+            try:
+                import _pyrepl.readline
+                if os.name == "nt":
+                    import _pyrepl.windows_console
+                    console_errors = (_pyrepl.windows_console._error,)
+                else:
+                    import _pyrepl.unix_console
+                    console_errors = _pyrepl.unix_console._error
+                from _pyrepl.main import CAN_USE_PYREPL
+            finally:
+                sys.path = original_path
+    except ImportError:
+        return
+
+    if readline is not None:
         # Reading the initialization (config) file may not be enough to set a
         # completion key, so we set one first and then read the file.
-        readline_doc = getattr(readline, '__doc__', '')
-        if readline_doc is not None and 'libedit' in readline_doc:
+        if readline.backend == 'editline':
             readline.parse_and_bind('bind ^I rl_complete')
         else:
             readline.parse_and_bind('tab: complete')
@@ -471,30 +548,44 @@ def register_readline():
             # want to ignore the exception.
             pass
 
-        if readline.get_current_history_length() == 0:
-            # If no history was loaded, default to .python_history.
-            # The guard is necessary to avoid doubling history size at
-            # each interpreter exit when readline was already configured
-            # through a PYTHONSTARTUP hook, see:
-            # http://bugs.python.org/issue5845#msg198636
-            history = os.path.join(os.path.expanduser('~'),
-                                   '.python_history')
+    if readline is None or readline.get_current_history_length() == 0:
+        # If no history was loaded, default to .python_history,
+        # or PYTHON_HISTORY.
+        # The guard is necessary to avoid doubling history size at
+        # each interpreter exit when readline was already configured
+        # through a PYTHONSTARTUP hook, see:
+        # http://bugs.python.org/issue5845#msg198636
+        history = gethistoryfile()
+
+        if CAN_USE_PYREPL:
+            readline_module = _pyrepl.readline
+            exceptions = (OSError, *console_errors)
+        else:
+            if readline is None:
+                return
+            readline_module = readline
+            exceptions = OSError
+
+        try:
+            readline_module.read_history_file(history)
+        except exceptions:
+            pass
+
+        def write_history():
             try:
-                readline.read_history_file(history)
-            except OSError:
+                readline_module.write_history_file(history)
+            except (FileNotFoundError, PermissionError):
+                # home directory does not exist or is not writable
+                # https://bugs.python.org/issue19891
                 pass
+            except OSError:
+                if errno.EROFS:
+                    pass  # gh-128066: read-only file system
+                else:
+                    raise
 
-            def write_history():
-                try:
-                    readline.write_history_file(history)
-                except OSError:
-                    # bpo-19891, bpo-41193: Home directory does not exist
-                    # or is not writable, or the filesystem is read-only.
-                    pass
-
-            atexit.register(write_history)
+        atexit.register(write_history)
 
-    sys.__interactivehook__ = register_readline
 
 def venv(known_paths):
     global PREFIXES, ENABLE_USER_SITE
@@ -679,17 +770,5 @@ def exists(path):
         print(textwrap.dedent(help % (sys.argv[0], os.pathsep)))
         sys.exit(10)
 
-def gethistoryfile():
-    """Check if the PYTHON_HISTORY environment variable is set and define
-    it as the .python_history file.  If PYTHON_HISTORY is not set, use the
-    default .python_history file.
-    """
-    if not sys.flags.ignore_environment:
-        history = os.environ.get("PYTHON_HISTORY")
-        if history:
-            return history
-    return os.path.join(os.path.expanduser('~'),
-        '.python_history')
-
 if __name__ == '__main__':
     _script()
diff --git a/Lib/smtplib.py b/Lib/smtplib.py
old mode 100644
new mode 100755
index 912233d817..9b81bcfbc4
--- a/Lib/smtplib.py
+++ b/Lib/smtplib.py
@@ -171,7 +171,7 @@ def quotedata(data):
     internet CRLF end-of-line.
     """
     return re.sub(r'(?m)^\.', '..',
-                  re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
+        re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data))
 
 def _quote_periods(bindata):
     return re.sub(br'(?m)^\.', b'..', bindata)
@@ -179,6 +179,16 @@ def _quote_periods(bindata):
 def _fix_eols(data):
     return  re.sub(r'(?:\r\n|\n|\r(?!\n))', CRLF, data)
 
+
+try:
+    hmac.digest(b'', b'', 'md5')
+# except ValueError:
+except (ValueError, AttributeError): # TODO: RUSTPYTHON
+    _have_cram_md5_support = False
+else:
+    _have_cram_md5_support = True
+
+
 try:
     import ssl
 except ImportError:
@@ -475,7 +485,7 @@ def ehlo(self, name=''):
             if auth_match:
                 # This doesn't remove duplicates, but that's no problem
                 self.esmtp_features["auth"] = self.esmtp_features.get("auth", "") \
-                                              + " " + auth_match.groups(0)[0]
+                        + " " + auth_match.groups(0)[0]
                 continue
 
             # RFC 1869 requires a space between ehlo keyword and parameters.
@@ -488,7 +498,7 @@ def ehlo(self, name=''):
                 params = m.string[m.end("feature"):].strip()
                 if feature == "auth":
                     self.esmtp_features[feature] = self.esmtp_features.get(feature, "") \
-                                                   + " " + params
+                            + " " + params
                 else:
                     self.esmtp_features[feature] = params
         return (code, msg)
@@ -542,7 +552,7 @@ def mail(self, sender, options=()):
                     raise SMTPNotSupportedError(
                         'SMTPUTF8 not supported by server')
             optionlist = ' ' + ' '.join(options)
-        self.putcmd("mail", "FROM:%s%s" % (quoteaddr(sender), optionlist))
+        self.putcmd("mail", "from:%s%s" % (quoteaddr(sender), optionlist))
         return self.getreply()
 
     def rcpt(self, recip, options=()):
@@ -550,7 +560,7 @@ def rcpt(self, recip, options=()):
         optionlist = ''
         if options and self.does_esmtp:
             optionlist = ' ' + ' '.join(options)
-        self.putcmd("rcpt", "TO:%s%s" % (quoteaddr(recip), optionlist))
+        self.putcmd("rcpt", "to:%s%s" % (quoteaddr(recip), optionlist))
         return self.getreply()
 
     def data(self, msg):
@@ -667,8 +677,11 @@ def auth_cram_md5(self, challenge=None):
         # CRAM-MD5 does not support initial-response.
         if challenge is None:
             return None
-        return self.user + " " + hmac.HMAC(
-            self.password.encode('ascii'), challenge, 'md5').hexdigest()
+        if not _have_cram_md5_support:
+            raise SMTPException("CRAM-MD5 is not supported")
+        password = self.password.encode('ascii')
+        authcode = hmac.HMAC(password, challenge, 'md5')
+        return f"{self.user} {authcode.hexdigest()}"
 
     def auth_plain(self, challenge=None):
         """ Authobject to use with PLAIN authentication. Requires self.user and
@@ -720,8 +733,10 @@ def login(self, user, password, *, initial_response_ok=True):
         advertised_authlist = self.esmtp_features["auth"].split()
 
         # Authentication methods we can handle in our preferred order:
-        preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
-
+        if _have_cram_md5_support:
+            preferred_auths = ['CRAM-MD5', 'PLAIN', 'LOGIN']
+        else:
+            preferred_auths = ['PLAIN', 'LOGIN']
         # We try the supported authentications in our preferred order, if
         # the server supports them.
         authlist = [auth for auth in preferred_auths
@@ -905,7 +920,7 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         The arguments are as for sendmail, except that msg is an
         email.message.Message object.  If from_addr is None or to_addrs is
         None, these arguments are taken from the headers of the Message as
-        described in RFC 2822 (a ValueError is raised if there is more than
+        described in RFC 5322 (a ValueError is raised if there is more than
         one set of 'Resent-' headers).  Regardless of the values of from_addr and
         to_addr, any Bcc field (or Resent-Bcc field, when the Message is a
         resent) of the Message object won't be transmitted.  The Message
@@ -919,7 +934,7 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         policy.
 
         """
-        # 'Resent-Date' is a mandatory field if the Message is resent (RFC 2822
+        # 'Resent-Date' is a mandatory field if the Message is resent (RFC 5322
         # Section 3.6.6). In such a case, we use the 'Resent-*' fields.  However,
         # if there is more than one 'Resent-' block there's no way to
         # unambiguously determine which one is the most recent in all cases,
@@ -938,10 +953,10 @@ def send_message(self, msg, from_addr=None, to_addrs=None,
         else:
             raise ValueError("message has more than one 'Resent-' header block")
         if from_addr is None:
-            # Prefer the sender field per RFC 2822:3.6.2.
+            # Prefer the sender field per RFC 5322 section 3.6.2.
             from_addr = (msg[header_prefix + 'Sender']
-                         if (header_prefix + 'Sender') in msg
-                         else msg[header_prefix + 'From'])
+                           if (header_prefix + 'Sender') in msg
+                           else msg[header_prefix + 'From'])
             from_addr = email.utils.getaddresses([from_addr])[0][1]
         if to_addrs is None:
             addr_fields = [f for f in (msg[header_prefix + 'To'],
diff --git a/Lib/socket.py b/Lib/socket.py
index 42ee130773..35d87eff34 100644
--- a/Lib/socket.py
+++ b/Lib/socket.py
@@ -306,7 +306,8 @@ def makefile(self, mode="r", buffering=None, *,
         """makefile(...) -> an I/O stream connected to the socket
 
         The arguments are as for io.open() after the filename, except the only
-        supported mode values are 'r' (default), 'w' and 'b'.
+        supported mode values are 'r' (default), 'w', 'b', or a combination of
+        those.
         """
         # XXX refactor to share code?
         if not set(mode) <= {"r", "w", "b"}:
@@ -591,16 +592,65 @@ def fromshare(info):
         return socket(0, 0, 0, info)
     __all__.append("fromshare")
 
-if hasattr(_socket, "socketpair"):
+# Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
+# This is used if _socket doesn't natively provide socketpair. It's
+# always defined so that it can be patched in for testing purposes.
+def _fallback_socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
+    if family == AF_INET:
+        host = _LOCALHOST
+    elif family == AF_INET6:
+        host = _LOCALHOST_V6
+    else:
+        raise ValueError("Only AF_INET and AF_INET6 socket address families "
+                         "are supported")
+    if type != SOCK_STREAM:
+        raise ValueError("Only SOCK_STREAM socket type is supported")
+    if proto != 0:
+        raise ValueError("Only protocol zero is supported")
+
+    # We create a connected TCP socket. Note the trick with
+    # setblocking(False) that prevents us from having to create a thread.
+    lsock = socket(family, type, proto)
+    try:
+        lsock.bind((host, 0))
+        lsock.listen()
+        # On IPv6, ignore flow_info and scope_id
+        addr, port = lsock.getsockname()[:2]
+        csock = socket(family, type, proto)
+        try:
+            csock.setblocking(False)
+            try:
+                csock.connect((addr, port))
+            except (BlockingIOError, InterruptedError):
+                pass
+            csock.setblocking(True)
+            ssock, _ = lsock.accept()
+        except:
+            csock.close()
+            raise
+    finally:
+        lsock.close()
 
-    def socketpair(family=None, type=SOCK_STREAM, proto=0):
-        """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
+    # Authenticating avoids using a connection from something else
+    # able to connect to {host}:{port} instead of us.
+    # We expect only AF_INET and AF_INET6 families.
+    try:
+        if (
+            ssock.getsockname() != csock.getpeername()
+            or csock.getsockname() != ssock.getpeername()
+        ):
+            raise ConnectionError("Unexpected peer connection")
+    except:
+        # getsockname() and getpeername() can fail
+        # if either socket isn't connected.
+        ssock.close()
+        csock.close()
+        raise
 
-        Create a pair of socket objects from the sockets returned by the platform
-        socketpair() function.
-        The arguments are the same as for socket() except the default family is
-        AF_UNIX if defined on the platform; otherwise, the default is AF_INET.
-        """
+    return (ssock, csock)
+
+if hasattr(_socket, "socketpair"):
+    def socketpair(family=None, type=SOCK_STREAM, proto=0):
         if family is None:
             try:
                 family = AF_UNIX
@@ -612,44 +662,7 @@ def socketpair(family=None, type=SOCK_STREAM, proto=0):
         return a, b
 
 else:
-
-    # Origin: https://gist.github.com/4325783, by Geert Jansen.  Public domain.
-    def socketpair(family=AF_INET, type=SOCK_STREAM, proto=0):
-        if family == AF_INET:
-            host = _LOCALHOST
-        elif family == AF_INET6:
-            host = _LOCALHOST_V6
-        else:
-            raise ValueError("Only AF_INET and AF_INET6 socket address families "
-                             "are supported")
-        if type != SOCK_STREAM:
-            raise ValueError("Only SOCK_STREAM socket type is supported")
-        if proto != 0:
-            raise ValueError("Only protocol zero is supported")
-
-        # We create a connected TCP socket. Note the trick with
-        # setblocking(False) that prevents us from having to create a thread.
-        lsock = socket(family, type, proto)
-        try:
-            lsock.bind((host, 0))
-            lsock.listen()
-            # On IPv6, ignore flow_info and scope_id
-            addr, port = lsock.getsockname()[:2]
-            csock = socket(family, type, proto)
-            try:
-                csock.setblocking(False)
-                try:
-                    csock.connect((addr, port))
-                except (BlockingIOError, InterruptedError):
-                    pass
-                csock.setblocking(True)
-                ssock, _ = lsock.accept()
-            except:
-                csock.close()
-                raise
-        finally:
-            lsock.close()
-        return (ssock, csock)
+    socketpair = _fallback_socketpair
     __all__.append("socketpair")
 
 socketpair.__doc__ = """socketpair([family[, type[, proto]]]) -> (socket object, socket object)
@@ -702,16 +715,15 @@ def readinto(self, b):
         self._checkReadable()
         if self._timeout_occurred:
             raise OSError("cannot read from timed out object")
-        while True:
-            try:
-                return self._sock.recv_into(b)
-            except timeout:
-                self._timeout_occurred = True
-                raise
-            except error as e:
-                if e.errno in _blocking_errnos:
-                    return None
-                raise
+        try:
+            return self._sock.recv_into(b)
+        except timeout:
+            self._timeout_occurred = True
+            raise
+        except error as e:
+            if e.errno in _blocking_errnos:
+                return None
+            raise
 
     def write(self, b):
         """Write the given bytes or bytearray object *b* to the socket
@@ -919,7 +931,9 @@ def create_server(address, *, family=AF_INET, backlog=None, reuse_port=False,
                 # Fail later on bind(), for platforms which may not
                 # support this option.
                 pass
-        if reuse_port:
+        # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+        # on other address families than AF_INET/AF_INET6.
+        if reuse_port and family in (AF_INET, AF_INET6):
             sock.setsockopt(SOL_SOCKET, SO_REUSEPORT, 1)
         if has_ipv6 and family == AF_INET6:
             if dualstack_ipv6:
diff --git a/Lib/socketserver.py b/Lib/socketserver.py
index 2905e3eac3..35b2723de3 100644
--- a/Lib/socketserver.py
+++ b/Lib/socketserver.py
@@ -127,10 +127,7 @@ class will essentially render the service "deaf" while one request is
 import selectors
 import os
 import sys
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
+import threading
 from io import BufferedIOBase
 from time import monotonic as time
 
@@ -144,6 +141,8 @@ class will essentially render the service "deaf" while one request is
     __all__.extend(["UnixStreamServer","UnixDatagramServer",
                     "ThreadingUnixStreamServer",
                     "ThreadingUnixDatagramServer"])
+    if hasattr(os, "fork"):
+        __all__.extend(["ForkingUnixStreamServer", "ForkingUnixDatagramServer"])
 
 # poll/select have the advantage of not requiring any extra file descriptor,
 # contrarily to epoll/kqueue (also, they require a single syscall).
@@ -190,6 +189,7 @@ class BaseServer:
     - address_family
     - socket_type
     - allow_reuse_address
+    - allow_reuse_port
 
     Instance variables:
 
@@ -294,8 +294,7 @@ def handle_request(self):
             selector.register(self, selectors.EVENT_READ)
 
             while True:
-                ready = selector.select(timeout)
-                if ready:
+                if selector.select(timeout):
                     return self._handle_request_noblock()
                 else:
                     if timeout is not None:
@@ -428,6 +427,7 @@ class TCPServer(BaseServer):
     - socket_type
     - request_queue_size (only for stream sockets)
     - allow_reuse_address
+    - allow_reuse_port
 
     Instance variables:
 
@@ -445,6 +445,8 @@ class TCPServer(BaseServer):
 
     allow_reuse_address = False
 
+    allow_reuse_port = False
+
     def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
         """Constructor.  May be extended, do not override."""
         BaseServer.__init__(self, server_address, RequestHandlerClass)
@@ -464,8 +466,15 @@ def server_bind(self):
         May be overridden.
 
         """
-        if self.allow_reuse_address:
+        if self.allow_reuse_address and hasattr(socket, "SO_REUSEADDR"):
             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # Since Linux 6.12.9, SO_REUSEPORT is not allowed
+        # on other address families than AF_INET/AF_INET6.
+        if (
+            self.allow_reuse_port and hasattr(socket, "SO_REUSEPORT")
+            and self.address_family in (socket.AF_INET, socket.AF_INET6)
+        ):
+            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
         self.socket.bind(self.server_address)
         self.server_address = self.socket.getsockname()
 
@@ -522,6 +531,8 @@ class UDPServer(TCPServer):
 
     allow_reuse_address = False
 
+    allow_reuse_port = False
+
     socket_type = socket.SOCK_DGRAM
 
     max_packet_size = 8192
@@ -723,6 +734,11 @@ class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): pass
 
     class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): pass
 
+    if hasattr(os, "fork"):
+        class ForkingUnixStreamServer(ForkingMixIn, UnixStreamServer): pass
+
+        class ForkingUnixDatagramServer(ForkingMixIn, UnixDatagramServer): pass
+
 class BaseRequestHandler:
 
     """Base class for request handler classes.
diff --git a/Lib/sre_constants.py b/Lib/sre_constants.py
index 8543e2bc8c..fa09d04429 100644
--- a/Lib/sre_constants.py
+++ b/Lib/sre_constants.py
@@ -5,81 +5,3 @@
 
 from re import _constants as _
 globals().update({k: v for k, v in vars(_).items() if k[:2] != '__'})
-
-if __name__ == "__main__":
-    def dump(f, d, typ, int_t, prefix):
-        items = sorted(d)
-        f.write(f"""\
-#[derive(num_enum::TryFromPrimitive, Debug)]
-#[repr({int_t})]
-#[allow(non_camel_case_types, clippy::upper_case_acronyms)]
-pub enum {typ} {{
-""")
-        for item in items:
-            name = str(item).removeprefix(prefix)
-            val = int(item)
-            f.write(f"    {name} = {val},\n")
-        f.write("""\
-}
-""")
-    import sys
-    if len(sys.argv) > 1:
-        constants_file = sys.argv[1]
-    else:
-        import os
-        constants_file = os.path.join(os.path.dirname(__file__), "../../sre-engine/src/constants.rs")
-    with open(constants_file, "w") as f:
-        f.write("""\
-/*
- * Secret Labs' Regular Expression Engine
- *
- * regular expression matching engine
- *
- * NOTE: This file is generated by sre_constants.py.  If you need
- * to change anything in here, edit sre_constants.py and run it.
- *
- * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
- *
- * See the _sre.c file for information on usage and redistribution.
- */
-
-""")
-
-        f.write("use bitflags::bitflags;\n\n");
-
-        f.write("pub const SRE_MAGIC: usize = %d;\n" % MAGIC)
-
-        dump(f, OPCODES, "SreOpcode", "u32", "")
-        dump(f, ATCODES, "SreAtCode", "u32", "AT_")
-        dump(f, CHCODES, "SreCatCode", "u32", "CATEGORY_")
-
-        def bitflags(typ, int_t, prefix, flags):
-            f.write(f"""\
-bitflags! {{
-    pub struct {typ}: {int_t} {{
-""")
-            for name in flags:
-                val = globals()[prefix + name]
-                f.write(f"        const {name} = {val};\n")
-            f.write("""\
-    }
-}
-""")
-
-        bitflags("SreFlag", "u16", "SRE_FLAG_", [
-            "TEMPLATE",
-            "IGNORECASE",
-            "LOCALE",
-            "MULTILINE",
-            "DOTALL",
-            "UNICODE",
-            "VERBOSE",
-            "DEBUG",
-            "ASCII",
-        ])
-
-        bitflags("SreInfo", "u32", "SRE_INFO_", [
-            "PREFIX", "LITERAL", "CHARSET",
-        ])
-
-    print("done")
diff --git a/Lib/ssl.py b/Lib/ssl.py
index 1200d7d993..c8703b046c 100644
--- a/Lib/ssl.py
+++ b/Lib/ssl.py
@@ -18,9 +18,10 @@
                           seconds past the Epoch (the time values
                           returned from time.time())
 
-  fetch_server_certificate (HOST, PORT) -- fetch the certificate provided
-                          by the server running on HOST at port PORT.  No
-                          validation of the certificate is performed.
+  get_server_certificate (addr, ssl_version, ca_certs, timeout) -- Retrieve the
+                          certificate from the server at the specified
+                          address and return it as a PEM-encoded string
+
 
 Integer constants:
 
@@ -94,31 +95,31 @@
 import os
 from collections import namedtuple
 from enum import Enum as _Enum, IntEnum as _IntEnum, IntFlag as _IntFlag
+from enum import _simple_enum
 
 import _ssl             # if we can't import it, let the error propagate
 
 from _ssl import OPENSSL_VERSION_NUMBER, OPENSSL_VERSION_INFO, OPENSSL_VERSION
-from _ssl import _SSLContext#, MemoryBIO, SSLSession
+from _ssl import _SSLContext, MemoryBIO, SSLSession
 from _ssl import (
     SSLError, SSLZeroReturnError, SSLWantReadError, SSLWantWriteError,
     SSLSyscallError, SSLEOFError, SSLCertVerificationError
     )
 from _ssl import txt2obj as _txt2obj, nid2obj as _nid2obj
-from _ssl import RAND_status, RAND_add, RAND_bytes, RAND_pseudo_bytes
+from _ssl import RAND_status, RAND_add, RAND_bytes
 try:
     from _ssl import RAND_egd
 except ImportError:
-    # LibreSSL does not provide RAND_egd
+    # RAND_egd is not supported on some platforms
     pass
 
 
 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_TLSv1_1, HAS_TLSv1_2, HAS_TLSv1_3, HAS_PSK
 )
 from _ssl import _DEFAULT_CIPHERS, _OPENSSL_API_VERSION
 
-
 _IntEnum._convert_(
     '_SSLMethod', __name__,
     lambda name: name.startswith('PROTOCOL_') and name != 'PROTOCOL_SSLv23',
@@ -155,7 +156,8 @@
 _SSLv2_IF_EXISTS = getattr(_SSLMethod, 'PROTOCOL_SSLv2', None)
 
 
-class TLSVersion(_IntEnum):
+@_simple_enum(_IntEnum)
+class TLSVersion:
     MINIMUM_SUPPORTED = _ssl.PROTO_MINIMUM_SUPPORTED
     SSLv3 = _ssl.PROTO_SSLv3
     TLSv1 = _ssl.PROTO_TLSv1
@@ -165,7 +167,8 @@ class TLSVersion(_IntEnum):
     MAXIMUM_SUPPORTED = _ssl.PROTO_MAXIMUM_SUPPORTED
 
 
-class _TLSContentType(_IntEnum):
+@_simple_enum(_IntEnum)
+class _TLSContentType:
     """Content types (record layer)
 
     See RFC 8446, section B.1
@@ -179,7 +182,8 @@ class _TLSContentType(_IntEnum):
     INNER_CONTENT_TYPE = 0x101
 
 
-class _TLSAlertType(_IntEnum):
+@_simple_enum(_IntEnum)
+class _TLSAlertType:
     """Alert types for TLSContentType.ALERT messages
 
     See RFC 8466, section B.2
@@ -220,7 +224,8 @@ class _TLSAlertType(_IntEnum):
     NO_APPLICATION_PROTOCOL = 120
 
 
-class _TLSMessageType(_IntEnum):
+@_simple_enum(_IntEnum)
+class _TLSMessageType:
     """Message types (handshake protocol)
 
     See RFC 8446, section B.3
@@ -250,10 +255,10 @@ class _TLSMessageType(_IntEnum):
 
 
 if sys.platform == "win32":
-    from _ssl import enum_certificates #, enum_crls
+    from _ssl import enum_certificates, enum_crls
 
-from socket import socket, AF_INET, SOCK_STREAM, create_connection
-from socket import SOL_SOCKET, SO_TYPE
+from socket import socket, SOCK_STREAM, create_connection
+from socket import SOL_SOCKET, SO_TYPE, _GLOBAL_DEFAULT_TIMEOUT
 import socket as _socket
 import base64        # for DER-to-PEM translation
 import errno
@@ -275,7 +280,7 @@ class _TLSMessageType(_IntEnum):
 def _dnsname_match(dn, hostname):
     """Matching according to RFC 6125, section 6.4.3
 
-    - Hostnames are compared lower case.
+    - Hostnames are compared lower-case.
     - For IDNA, both dn and hostname must be encoded as IDN A-label (ACE).
     - Partial wildcards like 'www*.example.org', multiple wildcards, sole
       wildcard or wildcards in labels other then the left-most label are not
@@ -363,68 +368,11 @@ def _ipaddress_match(cert_ipaddress, host_ip):
     (section 1.7.2 - "Out of Scope").
     """
     # OpenSSL may add a trailing newline to a subjectAltName's IP address,
-    # commonly woth IPv6 addresses. Strip off trailing \n.
+    # commonly with IPv6 addresses. Strip off trailing \n.
     ip = _inet_paton(cert_ipaddress.rstrip())
     return ip == host_ip
 
 
-def match_hostname(cert, hostname):
-    """Verify that *cert* (in decoded format as returned by
-    SSLSocket.getpeercert()) matches the *hostname*.  RFC 2818 and RFC 6125
-    rules are followed.
-
-    The function matches IP addresses rather than dNSNames if hostname is a
-    valid ipaddress string. IPv4 addresses are supported on all platforms.
-    IPv6 addresses are supported on platforms with IPv6 support (AF_INET6
-    and inet_pton).
-
-    CertificateError is raised on failure. On success, the function
-    returns nothing.
-    """
-    if not cert:
-        raise ValueError("empty or no certificate, match_hostname needs a "
-                         "SSL socket or SSL context with either "
-                         "CERT_OPTIONAL or CERT_REQUIRED")
-    try:
-        host_ip = _inet_paton(hostname)
-    except ValueError:
-        # Not an IP address (common case)
-        host_ip = None
-    dnsnames = []
-    san = cert.get('subjectAltName', ())
-    for key, value in san:
-        if key == 'DNS':
-            if host_ip is None and _dnsname_match(value, hostname):
-                return
-            dnsnames.append(value)
-        elif key == 'IP Address':
-            if host_ip is not None and _ipaddress_match(value, host_ip):
-                return
-            dnsnames.append(value)
-    if not dnsnames:
-        # The subject is only checked when there is no dNSName entry
-        # in subjectAltName
-        for sub in cert.get('subject', ()):
-            for key, value in sub:
-                # XXX according to RFC 2818, the most specific Common Name
-                # must be used.
-                if key == 'commonName':
-                    if _dnsname_match(value, hostname):
-                        return
-                    dnsnames.append(value)
-    if len(dnsnames) > 1:
-        raise CertificateError("hostname %r "
-            "doesn't match either of %s"
-            % (hostname, ', '.join(map(repr, dnsnames))))
-    elif len(dnsnames) == 1:
-        raise CertificateError("hostname %r "
-            "doesn't match %r"
-            % (hostname, dnsnames[0]))
-    else:
-        raise CertificateError("no appropriate commonName or "
-            "subjectAltName fields were found")
-
-
 DefaultVerifyPaths = namedtuple("DefaultVerifyPaths",
     "cafile capath openssl_cafile_env openssl_cafile openssl_capath_env "
     "openssl_capath")
@@ -479,7 +427,14 @@ class SSLContext(_SSLContext):
     sslsocket_class = None  # SSLSocket is assigned later.
     sslobject_class = None  # SSLObject is assigned later.
 
-    def __new__(cls, protocol=PROTOCOL_TLS, *args, **kwargs):
+    def __new__(cls, protocol=None, *args, **kwargs):
+        if protocol is None:
+            warnings.warn(
+                "ssl.SSLContext() without protocol argument is deprecated.",
+                category=DeprecationWarning,
+                stacklevel=2
+            )
+            protocol = PROTOCOL_TLS
         self = _SSLContext.__new__(cls, protocol)
         return self
 
@@ -518,6 +473,11 @@ def wrap_bio(self, incoming, outgoing, server_side=False,
         )
 
     def set_npn_protocols(self, npn_protocols):
+        warnings.warn(
+            "ssl NPN is deprecated, use ALPN instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
         protos = bytearray()
         for protocol in npn_protocols:
             b = bytes(protocol, 'ascii')
@@ -553,18 +513,17 @@ def set_alpn_protocols(self, alpn_protocols):
         self._set_alpn_protocols(protos)
 
     def _load_windows_store_certs(self, storename, purpose):
-        certs = bytearray()
         try:
             for cert, encoding, trust in enum_certificates(storename):
                 # CA certs are never PKCS#7 encoded
                 if encoding == "x509_asn":
                     if trust is True or purpose.oid in trust:
-                        certs.extend(cert)
+                        try:
+                            self.load_verify_locations(cadata=cert)
+                        except SSLError as exc:
+                            warnings.warn(f"Bad certificate in Windows certificate store: {exc!s}")
         except PermissionError:
             warnings.warn("unable to enumerate Windows certificate store")
-        if certs:
-            self.load_verify_locations(cadata=certs)
-        return certs
 
     def load_default_certs(self, purpose=Purpose.SERVER_AUTH):
         if not isinstance(purpose, _ASN1Object):
@@ -734,12 +693,25 @@ def create_default_context(purpose=Purpose.SERVER_AUTH, *, cafile=None,
     # SSLContext sets OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION,
     # OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE and OP_SINGLE_ECDH_USE
     # by default.
-    context = SSLContext(PROTOCOL_TLS)
-
     if purpose == Purpose.SERVER_AUTH:
         # verify certs and host name in client mode
+        context = SSLContext(PROTOCOL_TLS_CLIENT)
         context.verify_mode = CERT_REQUIRED
         context.check_hostname = True
+    elif purpose == Purpose.CLIENT_AUTH:
+        context = SSLContext(PROTOCOL_TLS_SERVER)
+    else:
+        raise ValueError(purpose)
+
+    # `VERIFY_X509_PARTIAL_CHAIN` makes OpenSSL's chain building behave more
+    # like RFC 3280 and 5280, which specify that chain building stops with the
+    # first trust anchor, even if that anchor is not self-signed.
+    #
+    # `VERIFY_X509_STRICT` makes OpenSSL more conservative about the
+    # certificates it accepts, including "disabling workarounds for
+    # some broken certificates."
+    context.verify_flags |= (_ssl.VERIFY_X509_PARTIAL_CHAIN |
+                             _ssl.VERIFY_X509_STRICT)
 
     if cafile or capath or cadata:
         context.load_verify_locations(cafile, capath, cadata)
@@ -755,7 +727,7 @@ def create_default_context(purpose=Purpose.SERVER_AUTH, *, cafile=None,
             context.keylog_filename = keylogfile
     return context
 
-def _create_unverified_context(protocol=PROTOCOL_TLS, *, cert_reqs=CERT_NONE,
+def _create_unverified_context(protocol=None, *, cert_reqs=CERT_NONE,
                            check_hostname=False, purpose=Purpose.SERVER_AUTH,
                            certfile=None, keyfile=None,
                            cafile=None, capath=None, cadata=None):
@@ -772,10 +744,18 @@ def _create_unverified_context(protocol=PROTOCOL_TLS, *, cert_reqs=CERT_NONE,
     # SSLContext sets OP_NO_SSLv2, OP_NO_SSLv3, OP_NO_COMPRESSION,
     # OP_CIPHER_SERVER_PREFERENCE, OP_SINGLE_DH_USE and OP_SINGLE_ECDH_USE
     # by default.
-    context = SSLContext(protocol)
+    if purpose == Purpose.SERVER_AUTH:
+        # verify certs and host name in client mode
+        if protocol is None:
+            protocol = PROTOCOL_TLS_CLIENT
+    elif purpose == Purpose.CLIENT_AUTH:
+        if protocol is None:
+            protocol = PROTOCOL_TLS_SERVER
+    else:
+        raise ValueError(purpose)
 
-    if not check_hostname:
-        context.check_hostname = False
+    context = SSLContext(protocol)
+    context.check_hostname = check_hostname
     if cert_reqs is not None:
         context.verify_mode = cert_reqs
     if check_hostname:
@@ -905,19 +885,46 @@ def getpeercert(self, binary_form=False):
         """
         return self._sslobj.getpeercert(binary_form)
 
+    def get_verified_chain(self):
+        """Returns verified certificate chain provided by the other
+        end of the SSL channel as a list of DER-encoded bytes.
+
+        If certificate verification was disabled method acts the same as
+        ``SSLSocket.get_unverified_chain``.
+        """
+        chain = self._sslobj.get_verified_chain()
+
+        if chain is None:
+            return []
+
+        return [cert.public_bytes(_ssl.ENCODING_DER) for cert in chain]
+
+    def get_unverified_chain(self):
+        """Returns raw certificate chain provided by the other
+        end of the SSL channel as a list of DER-encoded bytes.
+        """
+        chain = self._sslobj.get_unverified_chain()
+
+        if chain is None:
+            return []
+
+        return [cert.public_bytes(_ssl.ENCODING_DER) for cert in chain]
+
     def selected_npn_protocol(self):
         """Return the currently selected NPN protocol as a string, or ``None``
         if a next protocol was not negotiated or if NPN is not supported by one
         of the peers."""
-        if _ssl.HAS_NPN:
-            return self._sslobj.selected_npn_protocol()
+        warnings.warn(
+            "ssl NPN is deprecated, use ALPN instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
 
     def selected_alpn_protocol(self):
         """Return the currently selected ALPN protocol as a string, or ``None``
         if a next protocol was not negotiated or if ALPN is not supported by one
         of the peers."""
-        if _ssl.HAS_ALPN:
-            return self._sslobj.selected_alpn_protocol()
+        return self._sslobj.selected_alpn_protocol()
 
     def cipher(self):
         """Return the currently selected cipher as a 3-tuple ``(name,
@@ -996,38 +1003,67 @@ def _create(cls, sock, server_side=False, do_handshake_on_connect=True,
         if context.check_hostname and not server_hostname:
             raise ValueError("check_hostname requires server_hostname")
 
+        sock_timeout = sock.gettimeout()
         kwargs = dict(
             family=sock.family, type=sock.type, proto=sock.proto,
             fileno=sock.fileno()
         )
         self = cls.__new__(cls, **kwargs)
         super(SSLSocket, self).__init__(**kwargs)
-        self.settimeout(sock.gettimeout())
         sock.detach()
-
-        self._context = context
-        self._session = session
-        self._closed = False
-        self._sslobj = None
-        self.server_side = server_side
-        self.server_hostname = context._encode_hostname(server_hostname)
-        self.do_handshake_on_connect = do_handshake_on_connect
-        self.suppress_ragged_eofs = suppress_ragged_eofs
-
-        # See if we are connected
+        # Now SSLSocket is responsible for closing the file descriptor.
         try:
-            self.getpeername()
-        except OSError as e:
-            if e.errno != errno.ENOTCONN:
-                raise
-            connected = False
-        else:
-            connected = True
+            self._context = context
+            self._session = session
+            self._closed = False
+            self._sslobj = None
+            self.server_side = server_side
+            self.server_hostname = context._encode_hostname(server_hostname)
+            self.do_handshake_on_connect = do_handshake_on_connect
+            self.suppress_ragged_eofs = suppress_ragged_eofs
 
-        self._connected = connected
-        if connected:
-            # create the SSL object
+            # See if we are connected
             try:
+                self.getpeername()
+            except OSError as e:
+                if e.errno != errno.ENOTCONN:
+                    raise
+                connected = False
+                blocking = self.getblocking()
+                self.setblocking(False)
+                try:
+                    # We are not connected so this is not supposed to block, but
+                    # testing revealed otherwise on macOS and Windows so we do
+                    # the non-blocking dance regardless. Our raise when any data
+                    # is found means consuming the data is harmless.
+                    notconn_pre_handshake_data = self.recv(1)
+                except OSError as e:
+                    # EINVAL occurs for recv(1) on non-connected on unix sockets.
+                    if e.errno not in (errno.ENOTCONN, errno.EINVAL):
+                        raise
+                    notconn_pre_handshake_data = b''
+                self.setblocking(blocking)
+                if notconn_pre_handshake_data:
+                    # This prevents pending data sent to the socket before it was
+                    # closed from escaping to the caller who could otherwise
+                    # presume it came through a successful TLS connection.
+                    reason = "Closed before TLS handshake with data in recv buffer."
+                    notconn_pre_handshake_data_error = SSLError(e.errno, reason)
+                    # Add the SSLError attributes that _ssl.c always adds.
+                    notconn_pre_handshake_data_error.reason = reason
+                    notconn_pre_handshake_data_error.library = None
+                    try:
+                        raise notconn_pre_handshake_data_error
+                    finally:
+                        # Explicitly break the reference cycle.
+                        notconn_pre_handshake_data_error = None
+            else:
+                connected = True
+
+            self.settimeout(sock_timeout)  # Must come after setblocking() calls.
+            self._connected = connected
+            if connected:
+                # create the SSL object
                 self._sslobj = self._context._wrap_socket(
                     self, server_side, self.server_hostname,
                     owner=self, session=self._session,
@@ -1038,9 +1074,12 @@ def _create(cls, sock, server_side=False, do_handshake_on_connect=True,
                         # non-blocking
                         raise ValueError("do_handshake_on_connect should not be specified for non-blocking sockets")
                     self.do_handshake()
-            except (OSError, ValueError):
+        except:
+            try:
                 self.close()
-                raise
+            except OSError:
+                pass
+            raise
         return self
 
     @property
@@ -1123,13 +1162,33 @@ def getpeercert(self, binary_form=False):
         self._check_connected()
         return self._sslobj.getpeercert(binary_form)
 
+    @_sslcopydoc
+    def get_verified_chain(self):
+        chain = self._sslobj.get_verified_chain()
+
+        if chain is None:
+            return []
+
+        return [cert.public_bytes(_ssl.ENCODING_DER) for cert in chain]
+
+    @_sslcopydoc
+    def get_unverified_chain(self):
+        chain = self._sslobj.get_unverified_chain()
+
+        if chain is None:
+            return []
+
+        return [cert.public_bytes(_ssl.ENCODING_DER) for cert in chain]
+
     @_sslcopydoc
     def selected_npn_protocol(self):
         self._checkClosed()
-        if self._sslobj is None or not _ssl.HAS_NPN:
-            return None
-        else:
-            return self._sslobj.selected_npn_protocol()
+        warnings.warn(
+            "ssl NPN is deprecated, use ALPN instead",
+            DeprecationWarning,
+            stacklevel=2
+        )
+        return None
 
     @_sslcopydoc
     def selected_alpn_protocol(self):
@@ -1229,10 +1288,14 @@ def recv(self, buflen=1024, flags=0):
 
     def recv_into(self, buffer, nbytes=None, flags=0):
         self._checkClosed()
-        if buffer and (nbytes is None):
-            nbytes = len(buffer)
-        elif nbytes is None:
-            nbytes = 1024
+        if nbytes is None:
+            if buffer is not None:
+                with memoryview(buffer) as view:
+                    nbytes = view.nbytes
+                if not nbytes:
+                    nbytes = 1024
+            else:
+                nbytes = 1024
         if self._sslobj is not None:
             if flags != 0:
                 raise ValueError(
@@ -1382,32 +1445,6 @@ def version(self):
 SSLContext.sslobject_class = SSLObject
 
 
-def wrap_socket(sock, keyfile=None, certfile=None,
-                server_side=False, cert_reqs=CERT_NONE,
-                ssl_version=PROTOCOL_TLS, ca_certs=None,
-                do_handshake_on_connect=True,
-                suppress_ragged_eofs=True,
-                ciphers=None):
-
-    if server_side and not certfile:
-        raise ValueError("certfile must be specified for server-side "
-                         "operations")
-    if keyfile and not certfile:
-        raise ValueError("certfile must be specified")
-    context = SSLContext(ssl_version)
-    context.verify_mode = cert_reqs
-    if ca_certs:
-        context.load_verify_locations(ca_certs)
-    if certfile:
-        context.load_cert_chain(certfile, keyfile)
-    if ciphers:
-        context.set_ciphers(ciphers)
-    return context.wrap_socket(
-        sock=sock, server_side=server_side,
-        do_handshake_on_connect=do_handshake_on_connect,
-        suppress_ragged_eofs=suppress_ragged_eofs
-    )
-
 # some utility functions
 
 def cert_time_to_seconds(cert_time):
@@ -1466,11 +1503,14 @@ def PEM_cert_to_DER_cert(pem_cert_string):
     d = pem_cert_string.strip()[len(PEM_HEADER):-len(PEM_FOOTER)]
     return base64.decodebytes(d.encode('ASCII', 'strict'))
 
-def get_server_certificate(addr, ssl_version=PROTOCOL_TLS, ca_certs=None):
+def get_server_certificate(addr, ssl_version=PROTOCOL_TLS_CLIENT,
+                           ca_certs=None, timeout=_GLOBAL_DEFAULT_TIMEOUT):
     """Retrieve the certificate from the server at the specified address,
     and return it as a PEM-encoded string.
     If 'ca_certs' is specified, validate the server cert against it.
-    If 'ssl_version' is specified, use it in the connection attempt."""
+    If 'ssl_version' is specified, use it in the connection attempt.
+    If 'timeout' is specified, use it in the connection attempt.
+    """
 
     host, port = addr
     if ca_certs is not None:
@@ -1480,8 +1520,8 @@ def get_server_certificate(addr, ssl_version=PROTOCOL_TLS, ca_certs=None):
     context = _create_stdlib_context(ssl_version,
                                      cert_reqs=cert_reqs,
                                      cafile=ca_certs)
-    with  create_connection(addr) as sock:
-        with context.wrap_socket(sock) as sslsock:
+    with create_connection(addr, timeout=timeout) as sock:
+        with context.wrap_socket(sock, server_hostname=host) as sslsock:
             dercert = sslsock.getpeercert(True)
     return DER_cert_to_PEM_cert(dercert)
 
diff --git a/Lib/stat.py b/Lib/stat.py
index fc024db3f4..1b4ed1ebc9 100644
--- a/Lib/stat.py
+++ b/Lib/stat.py
@@ -110,22 +110,30 @@ def S_ISWHT(mode):
 S_IXOTH = 0o0001  # execute by others
 
 # Names for file flags
-
+UF_SETTABLE  = 0x0000ffff  # owner settable flags
 UF_NODUMP    = 0x00000001  # do not dump file
 UF_IMMUTABLE = 0x00000002  # file may not be changed
 UF_APPEND    = 0x00000004  # file may only be appended to
 UF_OPAQUE    = 0x00000008  # directory is opaque when viewed through a union stack
 UF_NOUNLINK  = 0x00000010  # file may not be renamed or deleted
-UF_COMPRESSED = 0x00000020 # OS X: file is hfs-compressed
-UF_HIDDEN    = 0x00008000  # OS X: file should not be displayed
+UF_COMPRESSED = 0x00000020 # macOS: file is compressed
+UF_TRACKED   = 0x00000040  # macOS: used for handling document IDs
+UF_DATAVAULT = 0x00000080  # macOS: entitlement needed for I/O
+UF_HIDDEN    = 0x00008000  # macOS: file should not be displayed
+SF_SETTABLE  = 0xffff0000  # superuser settable flags
 SF_ARCHIVED  = 0x00010000  # file may be archived
 SF_IMMUTABLE = 0x00020000  # file may not be changed
 SF_APPEND    = 0x00040000  # file may only be appended to
+SF_RESTRICTED = 0x00080000 # macOS: entitlement needed for writing
 SF_NOUNLINK  = 0x00100000  # file may not be renamed or deleted
 SF_SNAPSHOT  = 0x00200000  # file is a snapshot file
+SF_FIRMLINK  = 0x00800000  # macOS: file is a firmlink
+SF_DATALESS  = 0x40000000  # macOS: file is a dataless object
 
 
 _filemode_table = (
+    # File type chars according to:
+    # http://en.wikibooks.org/wiki/C_Programming/POSIX_Reference/sys/stat.h
     ((S_IFLNK,         "l"),
      (S_IFSOCK,        "s"),  # Must appear before IFREG and IFDIR as IFSOCK == IFREG | IFDIR
      (S_IFREG,         "-"),
@@ -156,13 +164,17 @@ def S_ISWHT(mode):
 def filemode(mode):
     """Convert a file's mode to a string of the form '-rwxrwxrwx'."""
     perm = []
-    for table in _filemode_table:
+    for index, table in enumerate(_filemode_table):
         for bit, char in table:
             if mode & bit == bit:
                 perm.append(char)
                 break
         else:
-            perm.append("-")
+            if index == 0:
+                # Unknown filetype
+                perm.append("?")
+            else:
+                perm.append("-")
     return "".join(perm)
 
 
diff --git a/Lib/statistics.py b/Lib/statistics.py
index f66245380a..ad4a94219c 100644
--- a/Lib/statistics.py
+++ b/Lib/statistics.py
@@ -11,7 +11,7 @@
 Function            Description
 ==================  ==================================================
 mean                Arithmetic mean (average) of data.
-fmean               Fast, floating point arithmetic mean.
+fmean               Fast, floating-point arithmetic mean.
 geometric_mean      Geometric mean of data.
 harmonic_mean       Harmonic mean of data.
 median              Median (middle value) of data.
@@ -112,6 +112,8 @@
     'fmean',
     'geometric_mean',
     'harmonic_mean',
+    'kde',
+    'kde_random',
     'linear_regression',
     'mean',
     'median',
@@ -130,14 +132,20 @@
 import math
 import numbers
 import random
+import sys
 
 from fractions import Fraction
 from decimal import Decimal
-from itertools import groupby, repeat
+from itertools import count, groupby, repeat
 from bisect import bisect_left, bisect_right
-from math import hypot, sqrt, fabs, exp, erf, tau, log, fsum
+from math import hypot, sqrt, fabs, exp, erf, 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
-from collections import Counter, namedtuple
+from collections import Counter, namedtuple, defaultdict
+
+_SQRT2 = sqrt(2.0)
+_random = random
 
 # === Exceptions ===
 
@@ -180,11 +188,12 @@ def _sum(data):
     allowed.
     """
     count = 0
+    types = set()
+    types_add = types.add
     partials = {}
     partials_get = partials.get
-    T = int
     for typ, values in groupby(data, type):
-        T = _coerce(T, typ)  # or raise TypeError
+        types_add(typ)
         for n, d in map(_exact_ratio, values):
             count += 1
             partials[d] = partials_get(d, 0) + n
@@ -196,9 +205,51 @@ def _sum(data):
     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.
@@ -245,6 +296,28 @@ def _exact_ratio(x):
 
     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.
+
+    # 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.
+
+    # 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.
+
+    # This doesn't seem to have been problem in practice, but it is a
+    # potential pitfall.
+
     try:
         return x.as_integer_ratio()
     except AttributeError:
@@ -279,22 +352,6 @@ def _convert(value, T):
             raise
 
 
-def _find_lteq(a, x):
-    'Locate the leftmost value exactly equal to x'
-    i = bisect_left(a, x)
-    if i != len(a) and a[i] == x:
-        return i
-    raise ValueError
-
-
-def _find_rteq(a, l, x):
-    'Locate the rightmost value exactly equal to x'
-    i = bisect_right(a, x, lo=l)
-    if i != (len(a) + 1) and a[i - 1] == x:
-        return i - 1
-    raise ValueError
-
-
 def _fail_neg(values, errmsg='negative value'):
     """Iterate over values, failing if any are less than zero."""
     for x in values:
@@ -303,6 +360,113 @@ def _fail_neg(values, errmsg='negative value'):
         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
+
+
 # === Measures of central tendency (averages) ===
 
 def mean(data):
@@ -321,17 +485,13 @@ def mean(data):
 
     If ``data`` is empty, StatisticsError will be raised.
     """
-    if iter(data) is data:
-        data = list(data)
-    n = len(data)
+    T, total, n = _sum(data)
     if n < 1:
         raise StatisticsError('mean requires at least one data point')
-    T, total, count = _sum(data)
-    assert count == n
     return _convert(total / n, T)
 
 
-def fmean(data):
+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.
@@ -340,29 +500,40 @@ def fmean(data):
     >>> fmean([3.5, 4.0, 5.25])
     4.25
     """
-    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
-        total = fsum(count(data))
-    else:
+    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)
-    try:
+        if not n:
+            raise StatisticsError('fmean requires at least one data point')
         return total / n
-    except ZeroDivisionError:
-        raise StatisticsError('fmean requires at least one data point') from None
+    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,
-    if it contains a zero, or if it contains a negative value.
+    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.)
@@ -370,11 +541,25 @@ def geometric_mean(data):
     >>> round(geometric_mean([54, 24, 36]), 9)
     36.0
     """
-    try:
-        return exp(fmean(map(log, data)))
-    except ValueError:
-        raise StatisticsError('geometric mean requires a non-empty dataset '
-                              'containing positive numbers') from None
+    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):
@@ -498,58 +683,75 @@ def median_high(data):
     return data[n // 2]
 
 
-def median_grouped(data, interval=1):
-    """Return the 50th percentile (median) of grouped continuous data.
+def median_grouped(data, interval=1.0):
+    """Estimates the median for numeric data binned around the midpoints
+    of consecutive, fixed-width intervals.
 
-    >>> median_grouped([1, 2, 2, 3, 4, 4, 4, 4, 4, 5])
-    3.7
-    >>> median_grouped([52, 52, 53, 54])
-    52.5
+    The *data* can be any iterable of numeric data with each value being
+    exactly the midpoint of a bin.  At least one value must be present.
 
-    This calculates the median as the 50th percentile, and should be
-    used when your data is continuous and grouped. In the above example,
-    the values 1, 2, 3, etc. actually represent the midpoint of classes
-    0.5-1.5, 1.5-2.5, 2.5-3.5, etc. The middle value falls somewhere in
-    class 3.5-4.5, and interpolation is used to estimate it.
+    The *interval* is width of each bin.
 
-    Optional argument ``interval`` represents the class interval, and
-    defaults to 1. Changing the class interval naturally will change the
-    interpolated 50th percentile value:
+    For example, demographic information may have been summarized into
+    consecutive ten-year age groups with each group being represented
+    by the 5-year midpoints of the intervals:
 
-    >>> median_grouped([1, 3, 3, 5, 7], interval=1)
-    3.25
-    >>> median_grouped([1, 3, 3, 5, 7], interval=2)
-    3.5
+        >>> demographics = Counter({
+        ...    25: 172,   # 20 to 30 years old
+        ...    35: 484,   # 30 to 40 years old
+        ...    45: 387,   # 40 to 50 years old
+        ...    55:  22,   # 50 to 60 years old
+        ...    65:   6,   # 60 to 70 years old
+        ... })
+
+    The 50th percentile (median) is the 536th person out of the 1071
+    member cohort.  That person is in the 30 to 40 year old age group.
+
+    The regular median() function would assume that everyone in the
+    tricenarian age group was exactly 35 years old.  A more tenable
+    assumption is that the 484 members of that age group are evenly
+    distributed between 30 and 40.  For that, we use median_grouped().
+
+        >>> data = list(demographics.elements())
+        >>> median(data)
+        35
+        >>> round(median_grouped(data, interval=10), 1)
+        37.5
+
+    The caller is responsible for making sure the data points are separated
+    by exact multiples of *interval*.  This is essential for getting a
+    correct result.  The function does not check this precondition.
+
+    Inputs may be any numeric type that can be coerced to a float during
+    the interpolation step.
 
-    This function does not check whether the data points are at least
-    ``interval`` apart.
     """
     data = sorted(data)
     n = len(data)
-    if n == 0:
+    if not n:
         raise StatisticsError("no median for empty data")
-    elif n == 1:
-        return data[0]
+
     # Find the value at the midpoint. Remember this corresponds to the
-    # centre of the class interval.
+    # midpoint of the class interval.
     x = data[n // 2]
-    for obj in (x, interval):
-        if isinstance(obj, (str, bytes)):
-            raise TypeError('expected number but got %r' % obj)
+
+    # Using O(log n) bisection, find where all the x values occur in the data.
+    # All x will lie within data[i:j].
+    i = bisect_left(data, x)
+    j = bisect_right(data, x, lo=i)
+
+    # Coerce to floats, raising a TypeError if not possible
     try:
-        L = x - interval / 2  # The lower limit of the median interval.
-    except TypeError:
-        # Mixed type. For now we just coerce to float.
-        L = float(x) - float(interval) / 2
-
-    # Uses bisection search to search for x in data with log(n) time complexity
-    # Find the position of leftmost occurrence of x in data
-    l1 = _find_lteq(data, x)
-    # Find the position of rightmost occurrence of x in data[l1...len(data)]
-    # Assuming always l1 <= l2
-    l2 = _find_rteq(data, l1, x)
-    cf = l1
-    f = l2 - l1 + 1
+        interval = float(interval)
+        x = float(x)
+    except ValueError:
+        raise TypeError(f'Value cannot be converted to a float')
+
+    # Interpolate the median using the formula found at:
+    # https://www.cuemath.com/data/median-of-grouped-data/
+    L = x - interval / 2.0    # Lower limit of the median interval
+    cf = i                    # Cumulative frequency of the preceding interval
+    f = j - i                 # Number of elements in the median internal
     return L + interval * (n / 2 - cf) / f
 
 
@@ -596,9 +798,223 @@ def multimode(data):
     >>> multimode('')
     []
     """
-    counts = Counter(iter(data)).most_common()
-    maxcount, mode_items = next(groupby(counts, key=itemgetter(1)), (0, []))
-    return list(map(itemgetter(0), mode_items))
+    counts = Counter(iter(data))
+    if not counts:
+        return []
+    maxcount = max(counts.values())
+    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.
+
+    The basic idea is to smooth the data using a kernel function
+    to help draw inferences about a population from a sample.
+
+    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.
+
+    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.
+
+    Kernels that give some weight to every sample point:
+
+       normal (gauss)
+       logistic
+       sigmoid
+
+    Kernels that only give weight to sample points within
+    the bandwidth:
+
+       rectangular (uniform)
+       triangular
+       parabolic (epanechnikov)
+       quartic (biweight)
+       triweight
+       cosine
+
+    If *cumulative* is true, will return a cumulative distribution function.
+
+    A StatisticsError will be raised if the data sequence is empty.
+
+    Example
+    -------
+
+    Given a sample of six data points, construct a continuous
+    function that estimates the underlying probability density:
+
+        >>> 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
@@ -659,7 +1075,10 @@ def quantiles(data, *, n=4, method='exclusive'):
     data = sorted(data)
     ld = len(data)
     if ld < 2:
-        raise StatisticsError('must have at least two data points')
+        if ld == 1:
+            return data * (n - 1)
+        raise StatisticsError('must have at least one data point')
+
     if method == 'inclusive':
         m = ld - 1
         result = []
@@ -668,6 +1087,7 @@ def quantiles(data, *, n=4, method='exclusive'):
             interpolated = (data[j] * (n - delta) + data[j + 1] * delta) / n
             result.append(interpolated)
         return result
+
     if method == 'exclusive':
         m = ld + 1
         result = []
@@ -678,6 +1098,7 @@ def quantiles(data, *, n=4, method='exclusive'):
             interpolated = (data[j - 1] * (n - delta) + data[j] * delta) / n
             result.append(interpolated)
         return result
+
     raise ValueError(f'Unknown method: {method!r}')
 
 
@@ -685,41 +1106,6 @@ def quantiles(data, *, n=4, method='exclusive'):
 
 # See http://mathworld.wolfram.com/Variance.html
 #     http://mathworld.wolfram.com/SampleVariance.html
-#     http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
-#
-# Under no circumstances use the so-called "computational formula for
-# variance", as that is only suitable for hand calculations with a small
-# amount of low-precision data. It has terrible numeric properties.
-#
-# See a comparison of three computational methods here:
-# http://www.johndcook.com/blog/2008/09/26/comparing-three-methods-of-computing-standard-deviation/
-
-def _ss(data, c=None):
-    """Return sum of square deviations of sequence data.
-
-    If ``c`` is None, the mean is calculated in one pass, and the deviations
-    from the mean are calculated in a second pass. Otherwise, deviations are
-    calculated from ``c`` as given. Use the second case with care, as it can
-    lead to garbage results.
-    """
-    if c is not None:
-        T, total, count = _sum((x-c)**2 for x in data)
-        return (T, total)
-    T, total, count = _sum(data)
-    mean_n, mean_d = (total / count).as_integer_ratio()
-    partials = Counter()
-    for n, d in map(_exact_ratio, data):
-        diff_n = n * mean_d - d * mean_n
-        diff_d = d * mean_d
-        partials[diff_d * diff_d] += diff_n * diff_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:
-        total = sum(Fraction(n, d) for d, n in partials.items())
-    return (T, total)
 
 
 def variance(data, xbar=None):
@@ -760,12 +1146,9 @@ def variance(data, xbar=None):
     Fraction(67, 108)
 
     """
-    if iter(data) is data:
-        data = list(data)
-    n = len(data)
+    T, ss, c, n = _ss(data, xbar)
     if n < 2:
         raise StatisticsError('variance requires at least two data points')
-    T, ss = _ss(data, xbar)
     return _convert(ss / (n - 1), T)
 
 
@@ -804,12 +1187,9 @@ def pvariance(data, mu=None):
     Fraction(13, 72)
 
     """
-    if iter(data) is data:
-        data = list(data)
-    n = len(data)
+    T, ss, c, n = _ss(data, mu)
     if n < 1:
         raise StatisticsError('pvariance requires at least one data point')
-    T, ss = _ss(data, mu)
     return _convert(ss / n, T)
 
 
@@ -822,14 +1202,13 @@ def stdev(data, xbar=None):
     1.0810874155219827
 
     """
-    # Fixme: Despite the exact sum of squared deviations, some inaccuracy
-    # remain because there are two rounding steps.  The first occurs in
-    # the _convert() step for variance(), the second occurs in math.sqrt().
-    var = variance(data, xbar)
-    try:
-        return var.sqrt()
-    except AttributeError:
-        return math.sqrt(var)
+    T, ss, c, n = _ss(data, xbar)
+    if n < 2:
+        raise StatisticsError('stdev requires at least two data points')
+    mss = ss / (n - 1)
+    if issubclass(T, Decimal):
+        return _decimal_sqrt_of_frac(mss.numerator, mss.denominator)
+    return _float_sqrt_of_frac(mss.numerator, mss.denominator)
 
 
 def pstdev(data, mu=None):
@@ -841,14 +1220,47 @@ def pstdev(data, mu=None):
     0.986893273527251
 
     """
-    # Fixme: Despite the exact sum of squared deviations, some inaccuracy
-    # remain because there are two rounding steps.  The first occurs in
-    # the _convert() step for pvariance(), the second occurs in math.sqrt().
-    var = pvariance(data, mu)
+    T, ss, c, n = _ss(data, mu)
+    if n < 1:
+        raise StatisticsError('pstdev requires at least one data point')
+    mss = ss / n
+    if issubclass(T, Decimal):
+        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 var.sqrt()
+        return float(xbar), _float_sqrt_of_frac(mss.numerator, mss.denominator)
     except AttributeError:
-        return math.sqrt(var)
+        # 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 ===
@@ -882,18 +1294,16 @@ def covariance(x, y, /):
         raise StatisticsError('covariance requires at least two data points')
     xbar = fsum(x) / n
     ybar = fsum(y) / n
-    sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y))
+    sxy = sumprod((xi - xbar for xi in x), (yi - ybar for yi in y))
     return sxy / (n - 1)
 
 
-def correlation(x, y, /):
+def correlation(x, y, /, *, method='linear'):
     """Pearson's correlation coefficient
 
     Return the Pearson's correlation coefficient for two inputs. Pearson's
-    correlation coefficient *r* takes values between -1 and +1. It measures the
-    strength and direction of the linear relationship, where +1 means very
-    strong, positive linear relationship, -1 very strong, negative linear
-    relationship, and 0 no linear relationship.
+    correlation coefficient *r* takes values between -1 and +1. It measures
+    the strength and direction of a linear relationship.
 
     >>> x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
     >>> y = [9, 8, 7, 6, 5, 4, 3, 2, 1]
@@ -902,19 +1312,36 @@ def correlation(x, y, /):
     >>> correlation(x, y)
     -1.0
 
+    If *method* is "ranked", computes Spearman's rank correlation coefficient
+    for two inputs.  The data is replaced by ranks.  Ties are averaged
+    so that equal values receive the same rank.  The resulting coefficient
+    measures the strength of a monotonic relationship.
+
+    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.
     """
     n = len(x)
     if len(y) != n:
         raise StatisticsError('correlation requires that both inputs have same number of data points')
     if n < 2:
         raise StatisticsError('correlation requires at least two data points')
-    xbar = fsum(x) / n
-    ybar = fsum(y) / n
-    sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y))
-    sxx = fsum((xi - xbar) ** 2.0 for xi in x)
-    syy = fsum((yi - ybar) ** 2.0 for yi in y)
+    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 / sqrt(sxx * syy)
+        return sxy / _sqrtprod(sxx, syy)
     except ZeroDivisionError:
         raise StatisticsError('at least one of the inputs is constant')
 
@@ -922,13 +1349,13 @@ def correlation(x, y, /):
 LinearRegression = namedtuple('LinearRegression', ('slope', 'intercept'))
 
 
-def linear_regression(x, y, /):
+def linear_regression(x, y, /, *, proportional=False):
     """Slope and intercept for simple linear regression.
 
     Return the slope and intercept of simple linear regression
     parameters estimated using ordinary least squares. Simple linear
     regression describes relationship between an independent variable
-    *x* and a dependent variable *y* in terms of linear function:
+    *x* and a dependent variable *y* in terms of a linear function:
 
         y = slope * x + intercept + noise
 
@@ -944,7 +1371,20 @@ def linear_regression(x, y, /):
     >>> noise = NormalDist().samples(5, seed=42)
     >>> y = [3 * x[i] + 2 + noise[i] for i in range(5)]
     >>> linear_regression(x, y)  #doctest: +ELLIPSIS
-    LinearRegression(slope=3.09078914170..., intercept=1.75684970486...)
+    LinearRegression(slope=3.17495..., intercept=1.00925...)
+
+    If *proportional* is true, the independent variable *x* and the
+    dependent variable *y* are assumed to be directly proportional.
+    The data is fit to a line passing through the origin.
+
+    Since the *intercept* will always be 0.0, the underlying linear
+    function simplifies to:
+
+        y = slope * x + noise
+
+    >>> y = [3 * x[i] + noise[i] for i in range(5)]
+    >>> linear_regression(x, y, proportional=True)  #doctest: +ELLIPSIS
+    LinearRegression(slope=2.90475..., intercept=0.0)
 
     """
     n = len(x)
@@ -952,15 +1392,18 @@ def linear_regression(x, y, /):
         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')
-    xbar = fsum(x) / n
-    ybar = fsum(y) / n
-    sxy = fsum((xi - xbar) * (yi - ybar) for xi, yi in zip(x, y))
-    sxx = fsum((xi - xbar) ** 2.0 for xi in x)
+    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 = ybar - slope * xbar
+    intercept = 0.0 if proportional else ybar - slope * xbar
     return LinearRegression(slope=slope, intercept=intercept)
 
 
@@ -1068,29 +1511,29 @@ def __init__(self, mu=0.0, sigma=1.0):
     @classmethod
     def from_samples(cls, data):
         "Make a normal distribution instance from sample data."
-        if not isinstance(data, (list, tuple)):
-            data = list(data)
-        xbar = fmean(data)
-        return cls(xbar, stdev(data, xbar))
+        return cls(*_mean_stdev(data))
 
     def samples(self, n, *, seed=None):
         "Generate *n* samples for a given mean and standard deviation."
-        gauss = random.gauss if seed is None else random.Random(seed).gauss
-        mu, sigma = self._mu, self._sigma
-        return [gauss(mu, sigma) for i in range(n)]
+        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 ** 2.0
+        variance = self._sigma * self._sigma
         if not variance:
             raise StatisticsError('pdf() not defined when sigma is zero')
-        return exp((x - self._mu)**2.0 / (-2.0*variance)) / sqrt(tau*variance)
+        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 * (1.0 + erf((x - self._mu) / (self._sigma * sqrt(2.0))))
+        return 0.5 * (1.0 + erf((x - self._mu) / (self._sigma * _SQRT2)))
 
     def inv_cdf(self, p):
         """Inverse cumulative distribution function.  x : P(X <= x) = p
@@ -1104,8 +1547,6 @@ def inv_cdf(self, p):
         """
         if p <= 0.0 or p >= 1.0:
             raise StatisticsError('p must be in the range 0.0 < p < 1.0')
-        if self._sigma <= 0.0:
-            raise StatisticsError('cdf() not defined when sigma at or below zero')
         return _normal_dist_inv_cdf(p, self._mu, self._sigma)
 
     def quantiles(self, n=4):
@@ -1146,9 +1587,9 @@ def overlap(self, other):
         dv = Y_var - X_var
         dm = fabs(Y._mu - X._mu)
         if not dv:
-            return 1.0 - erf(dm / (2.0 * X._sigma * sqrt(2.0)))
+            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**2.0 + dv * log(Y_var / 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)))
@@ -1191,7 +1632,7 @@ def stdev(self):
     @property
     def variance(self):
         "Square of the standard deviation."
-        return self._sigma ** 2.0
+        return self._sigma * self._sigma
 
     def __add__(x1, x2):
         """Add a constant or another NormalDist instance.
@@ -1265,3 +1706,102 @@ def __hash__(self):
 
     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
+
+
+## kde_random() ##############################################################
+
+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):
+    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
+
+_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)
+
+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
+
+_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
+    probability density function created by kde(data, h, kernel).
+
+    Providing a *seed* allows reproducible selections within a single
+    thread.  The seed may be an integer, float, str, or bytes.
+
+    A StatisticsError will be raised if the *data* sequence is empty.
+
+    Example:
+
+    >>> data = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2]
+    >>> rand = kde_random(data, h=1.5, seed=8675309)
+    >>> new_selections = [rand() for i in range(10)]
+    >>> [round(x, 1) for x in new_selections]
+    [0.7, 6.2, 1.2, 6.9, 7.0, 1.8, 2.5, -0.5, -1.8, 5.6]
+
+    """
+    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}')
+
+    kernel_invcdf = _kernel_invcdfs.get(kernel)
+    if kernel_invcdf is None:
+        raise StatisticsError(f'Unknown kernel name: {kernel!r}')
+
+    prng = _random.Random(seed)
+    random = prng.random
+    choice = prng.choice
+
+    def rand():
+        return choice(data) + h * kernel_invcdf(random())
+
+    rand.__doc__ = f'Random KDE selection with {h=!r} and {kernel=!r}'
+
+    return rand
diff --git a/Lib/subprocess.py b/Lib/subprocess.py
index 1d17ae3608..885f0092b5 100644
--- a/Lib/subprocess.py
+++ b/Lib/subprocess.py
@@ -74,8 +74,8 @@
 else:
     _mswindows = True
 
-# wasm32-emscripten and wasm32-wasi do not support processes
-_can_fork_exec = sys.platform not in {"emscripten", "wasi"}
+# some platforms do not support subprocesses
+_can_fork_exec = sys.platform not in {"emscripten", "wasi", "ios", "tvos", "watchos"}
 
 if _mswindows:
     import _winapi
@@ -83,6 +83,7 @@
                          STD_INPUT_HANDLE, STD_OUTPUT_HANDLE,
                          STD_ERROR_HANDLE, SW_HIDE,
                          STARTF_USESTDHANDLES, STARTF_USESHOWWINDOW,
+                         STARTF_FORCEONFEEDBACK, STARTF_FORCEOFFFEEDBACK,
                          ABOVE_NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS,
                          HIGH_PRIORITY_CLASS, IDLE_PRIORITY_CLASS,
                          NORMAL_PRIORITY_CLASS, REALTIME_PRIORITY_CLASS,
@@ -93,6 +94,7 @@
                     "STD_INPUT_HANDLE", "STD_OUTPUT_HANDLE",
                     "STD_ERROR_HANDLE", "SW_HIDE",
                     "STARTF_USESTDHANDLES", "STARTF_USESHOWWINDOW",
+                    "STARTF_FORCEONFEEDBACK", "STARTF_FORCEOFFFEEDBACK",
                     "STARTUPINFO",
                     "ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS",
                     "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS",
@@ -103,18 +105,22 @@
     if _can_fork_exec:
         from _posixsubprocess import fork_exec as _fork_exec
         # used in methods that are called by __del__
-        _waitpid = os.waitpid
-        _waitstatus_to_exitcode = os.waitstatus_to_exitcode
-        _WIFSTOPPED = os.WIFSTOPPED
-        _WSTOPSIG = os.WSTOPSIG
-        _WNOHANG = os.WNOHANG
+        class _del_safe:
+            waitpid = os.waitpid
+            waitstatus_to_exitcode = os.waitstatus_to_exitcode
+            WIFSTOPPED = os.WIFSTOPPED
+            WSTOPSIG = os.WSTOPSIG
+            WNOHANG = os.WNOHANG
+            ECHILD = errno.ECHILD
     else:
-        _fork_exec = None
-        _waitpid = None
-        _waitstatus_to_exitcode = None
-        _WIFSTOPPED = None
-        _WSTOPSIG = None
-        _WNOHANG = None
+        class _del_safe:
+            waitpid = None
+            waitstatus_to_exitcode = None
+            WIFSTOPPED = None
+            WSTOPSIG = None
+            WNOHANG = None
+            ECHILD = errno.ECHILD
+
     import select
     import selectors
 
@@ -346,7 +352,7 @@ def _args_from_interpreter_flags():
     if dev_mode:
         args.extend(('-X', 'dev'))
     for opt in ('faulthandler', 'tracemalloc', 'importtime',
-                'frozen_modules', 'showrefcount', 'utf8'):
+                'frozen_modules', 'showrefcount', 'utf8', 'gil'):
         if opt in xoptions:
             value = xoptions[opt]
             if value is True:
@@ -380,7 +386,7 @@ def _text_encoding():
 
 def call(*popenargs, timeout=None, **kwargs):
     """Run command with arguments.  Wait for command to complete or
-    timeout, then return the returncode attribute.
+    for timeout seconds, then return the returncode attribute.
 
     The arguments are the same as for the Popen constructor.  Example:
 
@@ -517,8 +523,8 @@ def run(*popenargs,
     in the returncode attribute, and output & stderr attributes if those streams
     were captured.
 
-    If timeout is given, and the process takes too long, a TimeoutExpired
-    exception will be raised.
+    If timeout (seconds) is given and the process takes too long,
+     a TimeoutExpired exception will be raised.
 
     There is an optional argument "input", allowing you to
     pass bytes or a string to the subprocess's stdin.  If you use this argument
@@ -709,6 +715,9 @@ def _use_posix_spawn():
         # os.posix_spawn() is not available
         return False
 
+    if ((_env := os.environ.get('_PYTHON_SUBPROCESS_USE_POSIX_SPAWN')) in ('0', '1')):
+        return bool(int(_env))
+
     if sys.platform in ('darwin', 'sunos5'):
         # posix_spawn() is a syscall on both macOS and Solaris,
         # and properly reports errors
@@ -744,6 +753,7 @@ def _use_posix_spawn():
 # guarantee the given libc/syscall API will be used.
 _USE_POSIX_SPAWN = _use_posix_spawn()
 _USE_VFORK = True
+_HAVE_POSIX_SPAWN_CLOSEFROM = hasattr(os, 'POSIX_SPAWN_CLOSEFROM')
 
 
 class Popen:
@@ -834,6 +844,9 @@ def __init__(self, args, bufsize=-1, executable=None,
         if not isinstance(bufsize, int):
             raise TypeError("bufsize must be an integer")
 
+        if stdout is STDOUT:
+            raise ValueError("STDOUT can only be used for stderr")
+
         if pipesize is None:
             pipesize = -1  # Restore default
         if not isinstance(pipesize, int):
@@ -1224,8 +1237,11 @@ def communicate(self, input=None, timeout=None):
 
             finally:
                 self._communication_started = True
-
-            sts = self.wait(timeout=self._remaining_time(endtime))
+            try:
+                sts = self.wait(timeout=self._remaining_time(endtime))
+            except TimeoutExpired as exc:
+                exc.timeout = timeout
+                raise
 
         return (stdout, stderr)
 
@@ -1600,6 +1616,10 @@ def _readerthread(self, fh, buffer):
             fh.close()
 
 
+        def _writerthread(self, input):
+            self._stdin_write(input)
+
+
         def _communicate(self, input, endtime, orig_timeout):
             # Start reader threads feeding into a list hanging off of this
             # object, unless they've already been started.
@@ -1618,8 +1638,23 @@ def _communicate(self, input, endtime, orig_timeout):
                 self.stderr_thread.daemon = True
                 self.stderr_thread.start()
 
-            if self.stdin:
-                self._stdin_write(input)
+            # Start writer thread to send input to stdin, unless already
+            # started.  The thread writes input and closes stdin when done,
+            # or continues in the background on timeout.
+            if self.stdin and not hasattr(self, "_stdin_thread"):
+                self._stdin_thread = \
+                        threading.Thread(target=self._writerthread,
+                                         args=(input,))
+                self._stdin_thread.daemon = True
+                self._stdin_thread.start()
+
+            # Wait for the writer thread, or time out.  If we time out, the
+            # thread remains writing and the fd left open in case the user
+            # calls communicate again.
+            if hasattr(self, "_stdin_thread"):
+                self._stdin_thread.join(self._remaining_time(endtime))
+                if self._stdin_thread.is_alive():
+                    raise TimeoutExpired(self.args, orig_timeout)
 
             # Wait for the reader threads, or time out.  If we time out, the
             # threads remain reading and the fds left open in case the user
@@ -1749,14 +1784,11 @@ def _get_handles(self, stdin, stdout, stderr):
                     errread, errwrite)
 
 
-        def _posix_spawn(self, args, executable, env, restore_signals,
+        def _posix_spawn(self, args, executable, env, restore_signals, close_fds,
                          p2cread, p2cwrite,
                          c2pread, c2pwrite,
                          errread, errwrite):
             """Execute program using os.posix_spawn()."""
-            if env is None:
-                env = os.environ
-
             kwargs = {}
             if restore_signals:
                 # See _Py_RestoreSignals() in Python/pylifecycle.c
@@ -1778,6 +1810,10 @@ def _posix_spawn(self, args, executable, env, restore_signals,
             ):
                 if fd != -1:
                     file_actions.append((os.POSIX_SPAWN_DUP2, fd, fd2))
+
+            if close_fds:
+                file_actions.append((os.POSIX_SPAWN_CLOSEFROM, 3))
+
             if file_actions:
                 kwargs['file_actions'] = file_actions
 
@@ -1825,7 +1861,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
             if (_USE_POSIX_SPAWN
                     and os.path.dirname(executable)
                     and preexec_fn is None
-                    and not close_fds
+                    and (not close_fds or _HAVE_POSIX_SPAWN_CLOSEFROM)
                     and not pass_fds
                     and cwd is None
                     and (p2cread == -1 or p2cread > 2)
@@ -1837,7 +1873,7 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                     and gids is None
                     and uid is None
                     and umask < 0):
-                self._posix_spawn(args, executable, env, restore_signals,
+                self._posix_spawn(args, executable, env, restore_signals, close_fds,
                                   p2cread, p2cwrite,
                                   c2pread, c2pwrite,
                                   errread, errwrite)
@@ -1958,20 +1994,16 @@ def _execute_child(self, args, executable, preexec_fn, close_fds,
                 raise child_exception_type(err_msg)
 
 
-        def _handle_exitstatus(self, sts,
-                               _waitstatus_to_exitcode=_waitstatus_to_exitcode,
-                               _WIFSTOPPED=_WIFSTOPPED,
-                               _WSTOPSIG=_WSTOPSIG):
+        def _handle_exitstatus(self, sts, _del_safe=_del_safe):
             """All callers to this function MUST hold self._waitpid_lock."""
             # This method is called (indirectly) by __del__, so it cannot
             # refer to anything outside of its local scope.
-            if _WIFSTOPPED(sts):
-                self.returncode = -_WSTOPSIG(sts)
+            if _del_safe.WIFSTOPPED(sts):
+                self.returncode = -_del_safe.WSTOPSIG(sts)
             else:
-                self.returncode = _waitstatus_to_exitcode(sts)
+                self.returncode = _del_safe.waitstatus_to_exitcode(sts)
 
-        def _internal_poll(self, _deadstate=None, _waitpid=_waitpid,
-                _WNOHANG=_WNOHANG, _ECHILD=errno.ECHILD):
+        def _internal_poll(self, _deadstate=None, _del_safe=_del_safe):
             """Check if child process has terminated.  Returns returncode
             attribute.
 
@@ -1987,13 +2019,13 @@ def _internal_poll(self, _deadstate=None, _waitpid=_waitpid,
                 try:
                     if self.returncode is not None:
                         return self.returncode  # Another thread waited.
-                    pid, sts = _waitpid(self.pid, _WNOHANG)
+                    pid, sts = _del_safe.waitpid(self.pid, _del_safe.WNOHANG)
                     if pid == self.pid:
                         self._handle_exitstatus(sts)
                 except OSError as e:
                     if _deadstate is not None:
                         self.returncode = _deadstate
-                    elif e.errno == _ECHILD:
+                    elif e.errno == _del_safe.ECHILD:
                         # This happens if SIGCLD is set to be ignored or
                         # waiting for child processes has otherwise been
                         # disabled for our process.  This child is dead, we
@@ -2067,6 +2099,10 @@ def _communicate(self, input, endtime, orig_timeout):
                     self.stdin.flush()
                 except BrokenPipeError:
                     pass  # communicate() must ignore BrokenPipeError.
+                except ValueError:
+                    # ignore ValueError: I/O operation on closed file.
+                    if not self.stdin.closed:
+                        raise
                 if not input:
                     try:
                         self.stdin.close()
@@ -2092,10 +2128,13 @@ def _communicate(self, input, endtime, orig_timeout):
             self._save_input(input)
 
             if self._input:
-                input_view = memoryview(self._input)
+                if not isinstance(self._input, memoryview):
+                    input_view = memoryview(self._input)
+                else:
+                    input_view = self._input.cast("b")  # byte input required
 
             with _PopenSelector() as selector:
-                if self.stdin and input:
+                if self.stdin and not self.stdin.closed and self._input:
                     selector.register(self.stdin, selectors.EVENT_WRITE)
                 if self.stdout and not self.stdout.closed:
                     selector.register(self.stdout, selectors.EVENT_READ)
@@ -2128,7 +2167,7 @@ def _communicate(self, input, endtime, orig_timeout):
                                 selector.unregister(key.fileobj)
                                 key.fileobj.close()
                             else:
-                                if self._input_offset >= len(self._input):
+                                if self._input_offset >= len(input_view):
                                     selector.unregister(key.fileobj)
                                     key.fileobj.close()
                         elif key.fileobj in (self.stdout, self.stderr):
@@ -2137,8 +2176,11 @@ def _communicate(self, input, endtime, orig_timeout):
                                 selector.unregister(key.fileobj)
                                 key.fileobj.close()
                             self._fileobj2output[key.fileobj].append(data)
-
-            self.wait(timeout=self._remaining_time(endtime))
+            try:
+                self.wait(timeout=self._remaining_time(endtime))
+            except TimeoutExpired as exc:
+                exc.timeout = orig_timeout
+                raise
 
             # All data exchanged.  Translate lists into strings.
             if stdout is not None:
diff --git a/Lib/symtable.py b/Lib/symtable.py
new file mode 100644
index 0000000000..672ec0ce1f
--- /dev/null
+++ b/Lib/symtable.py
@@ -0,0 +1,414 @@
+"""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)
+
+import weakref
+from enum import StrEnum
+
+__all__ = ["symtable", "SymbolTableType", "SymbolTable", "Class", "Function", "Symbol"]
+
+def symtable(code, filename, compile_type):
+    """ Return the toplevel *SymbolTable* for the source code.
+
+    *filename* is the name of the file with the code
+    and *compile_type* is the *compile()* mode argument.
+    """
+    top = _symtable.symtable(code, filename, compile_type)
+    return _newSymbolTable(top, filename)
+
+class SymbolTableFactory:
+    def __init__(self):
+        self.__memo = weakref.WeakValueDictionary()
+
+    def new(self, table, filename):
+        if table.type == _symtable.TYPE_FUNCTION:
+            return Function(table, filename)
+        if table.type == _symtable.TYPE_CLASS:
+            return Class(table, filename)
+        return SymbolTable(table, filename)
+
+    def __call__(self, table, filename):
+        key = table, filename
+        obj = self.__memo.get(key, None)
+        if obj is None:
+            obj = self.__memo[key] = self.new(table, filename)
+        return obj
+
+_newSymbolTable = SymbolTableFactory()
+
+
+class SymbolTableType(StrEnum):
+    MODULE = "module"
+    FUNCTION = "function"
+    CLASS = "class"
+    ANNOTATION = "annotation"
+    TYPE_ALIAS = "type alias"
+    TYPE_PARAMETERS = "type parameters"
+    TYPE_VARIABLE = "type variable"
+
+
+class SymbolTable:
+
+    def __init__(self, raw_table, filename):
+        self._table = raw_table
+        self._filename = filename
+        self._symbols = {}
+
+    def __repr__(self):
+        if self.__class__ == SymbolTable:
+            kind = ""
+        else:
+            kind = "%s " % self.__class__.__name__
+
+        if self._table.name == "top":
+            return "<{0}SymbolTable for module {1}>".format(kind, self._filename)
+        else:
+            return "<{0}SymbolTable for {1} in {2}>".format(kind,
+                                                            self._table.name,
+                                                            self._filename)
+
+    def get_type(self):
+        """Return the type of the symbol table.
+
+        The value returned is one of the values in
+        the ``SymbolTableType`` enumeration.
+        """
+        if self._table.type == _symtable.TYPE_MODULE:
+            return SymbolTableType.MODULE
+        if self._table.type == _symtable.TYPE_FUNCTION:
+            return SymbolTableType.FUNCTION
+        if self._table.type == _symtable.TYPE_CLASS:
+            return SymbolTableType.CLASS
+        if self._table.type == _symtable.TYPE_ANNOTATION:
+            return SymbolTableType.ANNOTATION
+        if self._table.type == _symtable.TYPE_TYPE_ALIAS:
+            return SymbolTableType.TYPE_ALIAS
+        if self._table.type == _symtable.TYPE_TYPE_PARAMETERS:
+            return SymbolTableType.TYPE_PARAMETERS
+        if self._table.type == _symtable.TYPE_TYPE_VARIABLE:
+            return SymbolTableType.TYPE_VARIABLE
+        assert False, f"unexpected type: {self._table.type}"
+
+    def get_id(self):
+        """Return an identifier for the table.
+        """
+        return self._table.id
+
+    def get_name(self):
+        """Return the table's name.
+
+        This corresponds to the name of the class, function
+        or 'top' if the table is for a class, function or
+        global respectively.
+        """
+        return self._table.name
+
+    def get_lineno(self):
+        """Return the number of the first line in the
+        block for the table.
+        """
+        return self._table.lineno
+
+    def is_optimized(self):
+        """Return *True* if the locals in the table
+        are optimizable.
+        """
+        return bool(self._table.type == _symtable.TYPE_FUNCTION)
+
+    def is_nested(self):
+        """Return *True* if the block is a nested class
+        or function."""
+        return bool(self._table.nested)
+
+    def has_children(self):
+        """Return *True* if the block has nested namespaces.
+        """
+        return bool(self._table.children)
+
+    def get_identifiers(self):
+        """Return a view object containing the names of symbols in the table.
+        """
+        return self._table.symbols.keys()
+
+    def lookup(self, name):
+        """Lookup a *name* in the table.
+
+        Returns a *Symbol* instance.
+        """
+        sym = self._symbols.get(name)
+        if sym is None:
+            flags = self._table.symbols[name]
+            namespaces = self.__check_children(name)
+            module_scope = (self._table.name == "top")
+            sym = self._symbols[name] = Symbol(name, flags, namespaces,
+                                               module_scope=module_scope)
+        return sym
+
+    def get_symbols(self):
+        """Return a list of *Symbol* instances for
+        names in the table.
+        """
+        return [self.lookup(ident) for ident in self.get_identifiers()]
+
+    def __check_children(self, name):
+        return [_newSymbolTable(st, self._filename)
+                for st in self._table.children
+                if st.name == name]
+
+    def get_children(self):
+        """Return a list of the nested symbol tables.
+        """
+        return [_newSymbolTable(st, self._filename)
+                for st in self._table.children]
+
+
+class Function(SymbolTable):
+
+    # Default values for instance variables
+    __params = None
+    __locals = None
+    __frees = None
+    __globals = None
+    __nonlocals = None
+
+    def __idents_matching(self, test_func):
+        return tuple(ident for ident in self.get_identifiers()
+                     if test_func(self._table.symbols[ident]))
+
+    def get_parameters(self):
+        """Return a tuple of parameters to the function.
+        """
+        if self.__params is None:
+            self.__params = self.__idents_matching(lambda x:x & DEF_PARAM)
+        return self.__params
+
+    def get_locals(self):
+        """Return a tuple of locals in the function.
+        """
+        if self.__locals is None:
+            locs = (LOCAL, CELL)
+            test = lambda x: ((x >> SCOPE_OFF) & SCOPE_MASK) in locs
+            self.__locals = self.__idents_matching(test)
+        return self.__locals
+
+    def get_globals(self):
+        """Return a tuple of globals in the function.
+        """
+        if self.__globals is None:
+            glob = (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
+            test = lambda x:((x >> SCOPE_OFF) & SCOPE_MASK) in glob
+            self.__globals = self.__idents_matching(test)
+        return self.__globals
+
+    def get_nonlocals(self):
+        """Return a tuple of nonlocals in the function.
+        """
+        if self.__nonlocals is None:
+            self.__nonlocals = self.__idents_matching(lambda x:x & DEF_NONLOCAL)
+        return self.__nonlocals
+
+    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
+            self.__frees = self.__idents_matching(is_free)
+        return self.__frees
+
+
+class Class(SymbolTable):
+
+    __methods = None
+
+    def get_methods(self):
+        """Return a tuple of methods declared in the class.
+        """
+        if self.__methods is None:
+            d = {}
+
+            def is_local_symbol(ident):
+                flags = self._table.symbols.get(ident, 0)
+                return ((flags >> SCOPE_OFF) & SCOPE_MASK) == LOCAL
+
+            for st in self._table.children:
+                # pick the function-like symbols that are local identifiers
+                if is_local_symbol(st.name):
+                    match st.type:
+                        case _symtable.TYPE_FUNCTION:
+                            # generators are of type TYPE_FUNCTION with a ".0"
+                            # parameter as a first parameter (which makes them
+                            # distinguishable from a function named 'genexpr')
+                            if st.name == 'genexpr' and '.0' in st.varnames:
+                                continue
+                            d[st.name] = 1
+                        case _symtable.TYPE_TYPE_PARAMETERS:
+                            # Get the function-def block in the annotation
+                            # scope 'st' with the same identifier, if any.
+                            scope_name = st.name
+                            for c in st.children:
+                                if c.name == scope_name and c.type == _symtable.TYPE_FUNCTION:
+                                    # A generic generator of type TYPE_FUNCTION
+                                    # cannot be a direct child of 'st' (but it
+                                    # can be a descendant), e.g.:
+                                    #
+                                    # class A:
+                                    #   type genexpr[genexpr] = (x for x in [])
+                                    assert scope_name != 'genexpr' or '.0' not in c.varnames
+                                    d[scope_name] = 1
+                                    break
+            self.__methods = tuple(d)
+        return self.__methods
+
+
+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.__namespaces = namespaces or ()
+        self.__module_scope = module_scope
+
+    def __repr__(self):
+        flags_str = '|'.join(self._flags_str())
+        return f'<symbol {self.__name!r}: {self._scope_str()}, {flags_str}>'
+
+    def _scope_str(self):
+        return _scopes_value_to_name.get(self.__scope) or str(self.__scope)
+
+    def _flags_str(self):
+        for flagname, flagvalue in _flags:
+            if self.__flags & flagvalue == flagvalue:
+                yield flagname
+
+    def get_name(self):
+        """Return a name of a symbol.
+        """
+        return self.__name
+
+    def is_referenced(self):
+        """Return *True* if the symbol is used in
+        its block.
+        """
+        return bool(self.__flags & _symtable.USE)
+
+    def is_parameter(self):
+        """Return *True* if the symbol is a parameter.
+        """
+        return bool(self.__flags & DEF_PARAM)
+
+    def is_global(self):
+        """Return *True* if the symbol is global.
+        """
+        return bool(self.__scope in (GLOBAL_IMPLICIT, GLOBAL_EXPLICIT)
+                    or (self.__module_scope and self.__flags & DEF_BOUND))
+
+    def is_nonlocal(self):
+        """Return *True* if the symbol is nonlocal."""
+        return bool(self.__flags & DEF_NONLOCAL)
+
+    def is_declared_global(self):
+        """Return *True* if the symbol is declared global
+        with a global statement."""
+        return bool(self.__scope == GLOBAL_EXPLICIT)
+
+    def is_local(self):
+        """Return *True* if the symbol is local.
+        """
+        return bool(self.__scope in (LOCAL, CELL)
+                    or (self.__module_scope and self.__flags & DEF_BOUND))
+
+    def is_annotated(self):
+        """Return *True* if the symbol is annotated.
+        """
+        return bool(self.__flags & DEF_ANNOT)
+
+    def is_free(self):
+        """Return *True* if a referenced symbol is
+        not assigned to.
+        """
+        return bool(self.__scope == FREE)
+
+    def is_imported(self):
+        """Return *True* if the symbol is created from
+        an import statement.
+        """
+        return bool(self.__flags & DEF_IMPORT)
+
+    def is_assigned(self):
+        """Return *True* if a symbol is assigned to."""
+        return bool(self.__flags & DEF_LOCAL)
+
+    def is_namespace(self):
+        """Returns *True* if name binding introduces new namespace.
+
+        If the name is used as the target of a function or class
+        statement, this will be true.
+
+        Note that a single name can be bound to multiple objects.  If
+        is_namespace() is true, the name may also be bound to other
+        objects, like an int or list, that does not introduce a new
+        namespace.
+        """
+        return bool(self.__namespaces)
+
+    def get_namespaces(self):
+        """Return a list of namespaces bound to this name"""
+        return self.__namespaces
+
+    def get_namespace(self):
+        """Return the single namespace bound to this name.
+
+        Raises ValueError if the name is bound to multiple namespaces
+        or no namespace.
+        """
+        if len(self.__namespaces) == 0:
+            raise ValueError("name is not bound to any namespaces")
+        elif len(self.__namespaces) > 1:
+            raise ValueError("name is bound to multiple namespaces")
+        else:
+            return self.__namespaces[0]
+
+
+_flags = [('USE', USE)]
+_flags.extend(kv for kv in globals().items() if kv[0].startswith('DEF_'))
+_scopes_names = ('FREE', 'LOCAL', 'GLOBAL_IMPLICIT', 'GLOBAL_EXPLICIT', 'CELL')
+_scopes_value_to_name = {globals()[n]: n for n in _scopes_names}
+
+
+def main(args):
+    import sys
+    def print_symbols(table, level=0):
+        indent = '    ' * level
+        nested = "nested " if table.is_nested() else ""
+        if table.get_type() == 'module':
+            what = f'from file {table._filename!r}'
+        else:
+            what = f'{table.get_name()!r}'
+        print(f'{indent}symbol table for {nested}{table.get_type()} {what}:')
+        for ident in table.get_identifiers():
+            symbol = table.lookup(ident)
+            flags = ', '.join(symbol._flags_str()).lower()
+            print(f'    {indent}{symbol._scope_str().lower()} symbol {symbol.get_name()!r}: {flags}')
+        print()
+
+        for table2 in table.get_children():
+            print_symbols(table2, level + 1)
+
+    for filename in args or ['-']:
+        if filename == '-':
+            src = sys.stdin.read()
+            filename = '<stdin>'
+        else:
+            with open(filename, 'rb') as f:
+                src = f.read()
+        mod = symtable(src, filename, 'exec')
+        print_symbols(mod)
+
+
+if __name__ == "__main__":
+    import sys
+    main(sys.argv[1:])
diff --git a/Lib/sysconfig.py b/Lib/sysconfig.py
deleted file mode 100644
index 9999d6bbd5..0000000000
--- a/Lib/sysconfig.py
+++ /dev/null
@@ -1,858 +0,0 @@
-# XXX: RUSTPYTHON; Trick to make sysconfig work as RustPython
-exec(r'''
-"""Access to Python's configuration information."""
-
-import os
-import sys
-from os.path import pardir, realpath
-
-__all__ = [
-    'get_config_h_filename',
-    'get_config_var',
-    'get_config_vars',
-    'get_makefile_filename',
-    'get_path',
-    'get_path_names',
-    'get_paths',
-    'get_platform',
-    'get_python_version',
-    'get_scheme_names',
-    'parse_config_h',
-]
-
-# Keys for get_config_var() that are never converted to Python integers.
-_ALWAYS_STR = {
-    'MACOSX_DEPLOYMENT_TARGET',
-}
-
-_INSTALL_SCHEMES = {
-    'posix_prefix': {
-        'stdlib': '{installed_base}/{platlibdir}/python{py_version_short}',
-        'platstdlib': '{platbase}/{platlibdir}/python{py_version_short}',
-        'purelib': '{base}/lib/python{py_version_short}/site-packages',
-        'platlib': '{platbase}/{platlibdir}/python{py_version_short}/site-packages',
-        'include':
-            '{installed_base}/include/python{py_version_short}{abiflags}',
-        'platinclude':
-            '{installed_platbase}/include/python{py_version_short}{abiflags}',
-        'scripts': '{base}/bin',
-        'data': '{base}',
-        },
-    'posix_home': {
-        'stdlib': '{installed_base}/lib/python',
-        'platstdlib': '{base}/lib/python',
-        'purelib': '{base}/lib/python',
-        'platlib': '{base}/lib/python',
-        'include': '{installed_base}/include/python',
-        'platinclude': '{installed_base}/include/python',
-        'scripts': '{base}/bin',
-        'data': '{base}',
-        },
-    'nt': {
-        'stdlib': '{installed_base}/Lib',
-        'platstdlib': '{base}/Lib',
-        'purelib': '{base}/Lib/site-packages',
-        'platlib': '{base}/Lib/site-packages',
-        'include': '{installed_base}/Include',
-        'platinclude': '{installed_base}/Include',
-        'scripts': '{base}/Scripts',
-        'data': '{base}',
-        },
-    # Downstream distributors can overwrite the default install scheme.
-    # This is done to support downstream modifications where distributors change
-    # the installation layout (eg. different site-packages directory).
-    # So, distributors will change the default scheme to one that correctly
-    # represents their layout.
-    # This presents an issue for projects/people that need to bootstrap virtual
-    # environments, like virtualenv. As distributors might now be customizing
-    # the default install scheme, there is no guarantee that the information
-    # returned by sysconfig.get_default_scheme/get_paths is correct for
-    # a virtual environment, the only guarantee we have is that it is correct
-    # for the *current* environment. When bootstrapping a virtual environment,
-    # we need to know its layout, so that we can place the files in the
-    # correct locations.
-    # The "*_venv" install scheme is a scheme to bootstrap virtual environments,
-    # essentially identical to the default posix_prefix/nt schemes.
-    # Downstream distributors who patch posix_prefix/nt scheme are encouraged to
-    # leave the following schemes unchanged
-    'posix_venv': {
-        'stdlib': '{installed_base}/{platlibdir}/python{py_version_short}',
-        'platstdlib': '{platbase}/{platlibdir}/python{py_version_short}',
-        'purelib': '{base}/lib/python{py_version_short}/site-packages',
-        'platlib': '{platbase}/{platlibdir}/python{py_version_short}/site-packages',
-        'include':
-            '{installed_base}/include/python{py_version_short}{abiflags}',
-        'platinclude':
-            '{installed_platbase}/include/python{py_version_short}{abiflags}',
-        'scripts': '{base}/bin',
-        'data': '{base}',
-        },
-    'nt_venv': {
-        'stdlib': '{installed_base}/Lib',
-        'platstdlib': '{base}/Lib',
-        'purelib': '{base}/Lib/site-packages',
-        'platlib': '{base}/Lib/site-packages',
-        'include': '{installed_base}/Include',
-        'platinclude': '{installed_base}/Include',
-        'scripts': '{base}/Scripts',
-        'data': '{base}',
-        },
-    }
-
-# For the OS-native venv scheme, we essentially provide an alias:
-if os.name == 'nt':
-    _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['nt_venv']
-else:
-    _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['posix_venv']
-
-
-# NOTE: site.py has copy of this function.
-# Sync it when modify this function.
-def _getuserbase():
-    env_base = os.environ.get("PYTHONUSERBASE", None)
-    if env_base:
-        return env_base
-
-    # Emscripten, VxWorks, and WASI have no home directories
-    if sys.platform in {"emscripten", "vxworks", "wasi"}:
-        return None
-
-    def joinuser(*args):
-        return os.path.expanduser(os.path.join(*args))
-
-    if os.name == "nt":
-        base = os.environ.get("APPDATA") or "~"
-        return joinuser(base, "Python")
-
-    if sys.platform == "darwin" and sys._framework:
-        return joinuser("~", "Library", sys._framework,
-                        f"{sys.version_info[0]}.{sys.version_info[1]}")
-
-    return joinuser("~", ".local")
-
-_HAS_USER_BASE = (_getuserbase() is not None)
-
-if _HAS_USER_BASE:
-    _INSTALL_SCHEMES |= {
-        # NOTE: When modifying "purelib" scheme, update site._get_path() too.
-        'nt_user': {
-            'stdlib': '{userbase}/Python{py_version_nodot_plat}',
-            'platstdlib': '{userbase}/Python{py_version_nodot_plat}',
-            'purelib': '{userbase}/Python{py_version_nodot_plat}/site-packages',
-            'platlib': '{userbase}/Python{py_version_nodot_plat}/site-packages',
-            'include': '{userbase}/Python{py_version_nodot_plat}/Include',
-            'scripts': '{userbase}/Python{py_version_nodot_plat}/Scripts',
-            'data': '{userbase}',
-            },
-        'posix_user': {
-            'stdlib': '{userbase}/{platlibdir}/python{py_version_short}',
-            'platstdlib': '{userbase}/{platlibdir}/python{py_version_short}',
-            'purelib': '{userbase}/lib/python{py_version_short}/site-packages',
-            'platlib': '{userbase}/lib/python{py_version_short}/site-packages',
-            'include': '{userbase}/include/python{py_version_short}',
-            'scripts': '{userbase}/bin',
-            'data': '{userbase}',
-            },
-        'osx_framework_user': {
-            'stdlib': '{userbase}/lib/python',
-            'platstdlib': '{userbase}/lib/python',
-            'purelib': '{userbase}/lib/python/site-packages',
-            'platlib': '{userbase}/lib/python/site-packages',
-            'include': '{userbase}/include/python{py_version_short}',
-            'scripts': '{userbase}/bin',
-            'data': '{userbase}',
-            },
-    }
-
-_SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include',
-                'scripts', 'data')
-
-_PY_VERSION = sys.version.split()[0]
-_PY_VERSION_SHORT = f'{sys.version_info[0]}.{sys.version_info[1]}'
-_PY_VERSION_SHORT_NO_DOT = f'{sys.version_info[0]}{sys.version_info[1]}'
-_PREFIX = os.path.normpath(sys.prefix)
-_BASE_PREFIX = os.path.normpath(sys.base_prefix)
-_EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
-_BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
-_CONFIG_VARS = None
-_USER_BASE = None
-
-# Regexes needed for parsing Makefile (and similar syntaxes,
-# like old-style Setup files).
-_variable_rx = r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)"
-_findvar1_rx = r"\$\(([A-Za-z][A-Za-z0-9_]*)\)"
-_findvar2_rx = r"\${([A-Za-z][A-Za-z0-9_]*)}"
-
-
-def _safe_realpath(path):
-    try:
-        return realpath(path)
-    except OSError:
-        return path
-
-if sys.executable:
-    _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
-else:
-    # sys.executable can be empty if argv[0] has been changed and Python is
-    # unable to retrieve the real program name
-    _PROJECT_BASE = _safe_realpath(os.getcwd())
-
-# In a virtual environment, `sys._home` gives us the target directory
-# `_PROJECT_BASE` for the executable that created it when the virtual
-# python is an actual executable ('venv --copies' or Windows).
-_sys_home = getattr(sys, '_home', None)
-if _sys_home:
-    _PROJECT_BASE = _sys_home
-
-if os.name == 'nt':
-    # In a source build, the executable is in a subdirectory of the root
-    # that we want (<root>\PCbuild\<platname>).
-    # `_BASE_PREFIX` is used as the base installation is where the source
-    # will be.  The realpath is needed to prevent mount point confusion
-    # that can occur with just string comparisons.
-    if _safe_realpath(_PROJECT_BASE).startswith(
-            _safe_realpath(f'{_BASE_PREFIX}\\PCbuild')):
-        _PROJECT_BASE = _BASE_PREFIX
-
-# set for cross builds
-if "_PYTHON_PROJECT_BASE" in os.environ:
-    _PROJECT_BASE = _safe_realpath(os.environ["_PYTHON_PROJECT_BASE"])
-
-def is_python_build(check_home=None):
-    if check_home is not None:
-        import warnings
-        warnings.warn("check_home argument is deprecated and ignored.",
-                      DeprecationWarning, stacklevel=2)
-    for fn in ("Setup", "Setup.local"):
-        if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
-            return True
-    return False
-
-_PYTHON_BUILD = is_python_build()
-
-if _PYTHON_BUILD:
-    for scheme in ('posix_prefix', 'posix_home'):
-        # On POSIX-y platforms, Python will:
-        # - Build from .h files in 'headers' (which is only added to the
-        #   scheme when building CPython)
-        # - Install .h files to 'include'
-        scheme = _INSTALL_SCHEMES[scheme]
-        scheme['headers'] = scheme['include']
-        scheme['include'] = '{srcdir}/Include'
-        scheme['platinclude'] = '{projectbase}/.'
-    del scheme
-
-
-def _subst_vars(s, local_vars):
-    try:
-        return s.format(**local_vars)
-    except KeyError as var:
-        try:
-            return s.format(**os.environ)
-        except KeyError:
-            raise AttributeError(f'{var}') from None
-
-def _extend_dict(target_dict, other_dict):
-    target_keys = target_dict.keys()
-    for key, value in other_dict.items():
-        if key in target_keys:
-            continue
-        target_dict[key] = value
-
-
-def _expand_vars(scheme, vars):
-    res = {}
-    if vars is None:
-        vars = {}
-    _extend_dict(vars, get_config_vars())
-    if os.name == 'nt':
-        # On Windows we want to substitute 'lib' for schemes rather
-        # than the native value (without modifying vars, in case it
-        # was passed in)
-        vars = vars | {'platlibdir': 'lib'}
-
-    for key, value in _INSTALL_SCHEMES[scheme].items():
-        if os.name in ('posix', 'nt'):
-            value = os.path.expanduser(value)
-        res[key] = os.path.normpath(_subst_vars(value, vars))
-    return res
-
-
-def _get_preferred_schemes():
-    if os.name == 'nt':
-        return {
-            'prefix': 'nt',
-            'home': 'posix_home',
-            'user': 'nt_user',
-        }
-    if sys.platform == 'darwin' and sys._framework:
-        return {
-            'prefix': 'posix_prefix',
-            'home': 'posix_home',
-            'user': 'osx_framework_user',
-        }
-    return {
-        'prefix': 'posix_prefix',
-        'home': 'posix_home',
-        'user': 'posix_user',
-    }
-
-
-def get_preferred_scheme(key):
-    if key == 'prefix' and sys.prefix != sys.base_prefix:
-        return 'venv'
-    scheme = _get_preferred_schemes()[key]
-    if scheme not in _INSTALL_SCHEMES:
-        raise ValueError(
-            f"{key!r} returned {scheme!r}, which is not a valid scheme "
-            f"on this platform"
-        )
-    return scheme
-
-
-def get_default_scheme():
-    return get_preferred_scheme('prefix')
-
-
-def _parse_makefile(filename, vars=None, keep_unresolved=True):
-    """Parse a Makefile-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    import re
-
-    if vars is None:
-        vars = {}
-    done = {}
-    notdone = {}
-
-    with open(filename, encoding=sys.getfilesystemencoding(),
-              errors="surrogateescape") as f:
-        lines = f.readlines()
-
-    for line in lines:
-        if line.startswith('#') or line.strip() == '':
-            continue
-        m = re.match(_variable_rx, line)
-        if m:
-            n, v = m.group(1, 2)
-            v = v.strip()
-            # `$$' is a literal `$' in make
-            tmpv = v.replace('$$', '')
-
-            if "$" in tmpv:
-                notdone[n] = v
-            else:
-                try:
-                    if n in _ALWAYS_STR:
-                        raise ValueError
-
-                    v = int(v)
-                except ValueError:
-                    # insert literal `$'
-                    done[n] = v.replace('$$', '$')
-                else:
-                    done[n] = v
-
-    # do variable interpolation here
-    variables = list(notdone.keys())
-
-    # Variables with a 'PY_' prefix in the makefile. These need to
-    # be made available without that prefix through sysconfig.
-    # Special care is needed to ensure that variable expansion works, even
-    # if the expansion uses the name without a prefix.
-    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
-
-    while len(variables) > 0:
-        for name in tuple(variables):
-            value = notdone[name]
-            m1 = re.search(_findvar1_rx, value)
-            m2 = re.search(_findvar2_rx, value)
-            if m1 and m2:
-                m = m1 if m1.start() < m2.start() else m2
-            else:
-                m = m1 if m1 else m2
-            if m is not None:
-                n = m.group(1)
-                found = True
-                if n in done:
-                    item = str(done[n])
-                elif n in notdone:
-                    # get it on a subsequent round
-                    found = False
-                elif n in os.environ:
-                    # do it like make: fall back to environment
-                    item = os.environ[n]
-
-                elif n in renamed_variables:
-                    if (name.startswith('PY_') and
-                        name[3:] in renamed_variables):
-                        item = ""
-
-                    elif 'PY_' + n in notdone:
-                        found = False
-
-                    else:
-                        item = str(done['PY_' + n])
-
-                else:
-                    done[n] = item = ""
-
-                if found:
-                    after = value[m.end():]
-                    value = value[:m.start()] + item + after
-                    if "$" in after:
-                        notdone[name] = value
-                    else:
-                        try:
-                            if name in _ALWAYS_STR:
-                                raise ValueError
-                            value = int(value)
-                        except ValueError:
-                            done[name] = value.strip()
-                        else:
-                            done[name] = value
-                        variables.remove(name)
-
-                        if name.startswith('PY_') \
-                        and name[3:] in renamed_variables:
-
-                            name = name[3:]
-                            if name not in done:
-                                done[name] = value
-
-            else:
-                # Adds unresolved variables to the done dict.
-                # This is disabled when called from distutils.sysconfig
-                if keep_unresolved:
-                    done[name] = value
-                # bogus variable reference (e.g. "prefix=$/opt/python");
-                # just drop it since we can't deal
-                variables.remove(name)
-
-    # strip spurious spaces
-    for k, v in done.items():
-        if isinstance(v, str):
-            done[k] = v.strip()
-
-    # save the results in the global dictionary
-    vars.update(done)
-    return vars
-
-
-def get_makefile_filename():
-    """Return the path of the 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 _get_sysconfigdata_name():
-    multiarch = getattr(sys.implementation, '_multiarch', '')
-    return os.environ.get(
-        '_PYTHON_SYSCONFIGDATA_NAME',
-        f'_sysconfigdata_{sys.abiflags}_{sys.platform}_{multiarch}',
-    )
-
-
-def _generate_posix_vars():
-    """Generate the Python module containing build-time variables."""
-    import pprint
-    vars = {}
-    # load the installed Makefile:
-    makefile = get_makefile_filename()
-    try:
-        _parse_makefile(makefile, vars)
-    except OSError as e:
-        msg = f"invalid Python installation: unable to open {makefile}"
-        if hasattr(e, "strerror"):
-            msg = f"{msg} ({e.strerror})"
-        raise OSError(msg)
-    # load the installed pyconfig.h:
-    config_h = get_config_h_filename()
-    try:
-        with open(config_h, encoding="utf-8") as f:
-            parse_config_h(f, vars)
-    except OSError as e:
-        msg = f"invalid Python installation: unable to open {config_h}"
-        if hasattr(e, "strerror"):
-            msg = f"{msg} ({e.strerror})"
-        raise OSError(msg)
-    # On AIX, there are wrong paths to the linker scripts in the Makefile
-    # -- these paths are relative to the Python source, but when installed
-    # the scripts are in another directory.
-    if _PYTHON_BUILD:
-        vars['BLDSHARED'] = vars['LDSHARED']
-
-    # 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
-    # `make pybuilddir.txt` target -- which is a precursor to the
-    # _sysconfigdata.py module being constructed.  Unfortunately,
-    # get_config_vars() eventually calls _init_posix(), which attempts
-    # to import _sysconfigdata, which we won't have built yet.  In order
-    # for _init_posix() to work, if we're on Darwin, just mock up the
-    # _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
-
-    pybuilddir = f'build/lib.{get_platform()}-{_PY_VERSION_SHORT}'
-    if hasattr(sys, "gettotalrefcount"):
-        pybuilddir += '-pydebug'
-    os.makedirs(pybuilddir, exist_ok=True)
-    destfile = os.path.join(pybuilddir, name + '.py')
-
-    with open(destfile, 'w', encoding='utf8') as f:
-        f.write('# system configuration generated and used by'
-                ' the sysconfig module\n')
-        f.write('build_time_vars = ')
-        pprint.pprint(vars, stream=f)
-
-    # Create file used for sys.path fixup -- see Modules/getpath.c
-    with open('pybuilddir.txt', 'w', encoding='utf8') as f:
-        f.write(pybuilddir)
-
-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()
-    _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"""
-    # set basic install directories
-    import _imp
-    vars['LIBDEST'] = get_path('stdlib')
-    vars['BINLIBDEST'] = get_path('platstdlib')
-    vars['INCLUDEPY'] = get_path('include')
-    try:
-        # GH-99201: _imp.extension_suffixes may be empty when
-        # HAVE_DYNAMIC_LOADING is not set. In this case, don't set EXT_SUFFIX.
-        vars['EXT_SUFFIX'] = _imp.extension_suffixes()[0]
-    except IndexError:
-        pass
-    vars['EXE'] = '.exe'
-    vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
-    vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
-    vars['TZPATH'] = ''
-
-#
-# public APIs
-#
-
-
-def parse_config_h(fp, vars=None):
-    """Parse a config.h-style file.
-
-    A dictionary containing name/value pairs is returned.  If an
-    optional dictionary is passed in as the second argument, it is
-    used instead of a new dictionary.
-    """
-    if vars is None:
-        vars = {}
-    import re
-    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
-    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
-
-    while True:
-        line = fp.readline()
-        if not line:
-            break
-        m = define_rx.match(line)
-        if m:
-            n, v = m.group(1, 2)
-            try:
-                if n in _ALWAYS_STR:
-                    raise ValueError
-                v = int(v)
-            except ValueError:
-                pass
-            vars[n] = v
-        else:
-            m = undef_rx.match(line)
-            if m:
-                vars[m.group(1)] = 0
-    return vars
-
-
-def get_config_h_filename():
-    """Return the path of pyconfig.h."""
-    if _PYTHON_BUILD:
-        if os.name == "nt":
-            inc_dir = os.path.join(_PROJECT_BASE, "PC")
-        else:
-            inc_dir = _PROJECT_BASE
-    else:
-        inc_dir = get_path('platinclude')
-    return os.path.join(inc_dir, 'pyconfig.h')
-
-
-def get_scheme_names():
-    """Return a tuple containing the schemes names."""
-    return tuple(sorted(_INSTALL_SCHEMES))
-
-
-def get_path_names():
-    """Return a tuple containing the paths names."""
-    return _SCHEME_KEYS
-
-
-def get_paths(scheme=get_default_scheme(), vars=None, expand=True):
-    """Return a mapping containing an install scheme.
-
-    ``scheme`` is the install scheme name. If not provided, it will
-    return the default scheme for the current platform.
-    """
-    if expand:
-        return _expand_vars(scheme, vars)
-    else:
-        return _INSTALL_SCHEMES[scheme]
-
-
-def get_path(name, scheme=get_default_scheme(), vars=None, expand=True):
-    """Return a path corresponding to the scheme.
-
-    ``scheme`` is the install scheme name.
-    """
-    return get_paths(scheme, vars, expand)[name]
-
-
-def get_config_vars(*args):
-    """With no arguments, return a dictionary of all configuration
-    variables relevant for the current platform.
-
-    On Unix, this means every variable defined in Python's installed Makefile;
-    On Windows it's a much smaller set.
-
-    With arguments, return a list of values that result from looking up
-    each argument in the configuration variable dictionary.
-    """
-    global _CONFIG_VARS
-    if _CONFIG_VARS is None:
-        _CONFIG_VARS = {}
-        # Normalized versions of prefix and exec_prefix are handy to have;
-        # in fact, these are the standard versions used most places in the
-        # Distutils.
-        _CONFIG_VARS['prefix'] = _PREFIX
-        _CONFIG_VARS['exec_prefix'] = _EXEC_PREFIX
-        _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['projectbase'] = _PROJECT_BASE
-        _CONFIG_VARS['platlibdir'] = sys.platlibdir
-        try:
-            _CONFIG_VARS['abiflags'] = sys.abiflags
-        except AttributeError:
-            # sys.abiflags may not be defined on all platforms.
-            _CONFIG_VARS['abiflags'] = ''
-        try:
-            _CONFIG_VARS['py_version_nodot_plat'] = sys.winver.replace('.', '')
-        except AttributeError:
-            _CONFIG_VARS['py_version_nodot_plat'] = ''
-
-        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
-            # the init-function.
-            _CONFIG_VARS['userbase'] = _getuserbase()
-
-        # Always convert srcdir to an absolute path
-        srcdir = _CONFIG_VARS.get('srcdir', _PROJECT_BASE)
-        if os.name == 'posix':
-            if _PYTHON_BUILD:
-                # If srcdir is a relative path (typically '.' or '..')
-                # then it should be interpreted relative to the directory
-                # containing Makefile.
-                base = os.path.dirname(get_makefile_filename())
-                srcdir = os.path.join(base, srcdir)
-            else:
-                # srcdir is not meaningful since the installation is
-                # spread about the filesystem.  We choose the
-                # directory containing the Makefile since we know it
-                # exists.
-                srcdir = os.path.dirname(get_makefile_filename())
-        _CONFIG_VARS['srcdir'] = _safe_realpath(srcdir)
-
-        # OS X platforms require special customization to handle
-        # multi-architecture, multi-os-version installers
-        if sys.platform == 'darwin':
-            import _osx_support
-            _osx_support.customize_config_vars(_CONFIG_VARS)
-
-    if args:
-        vals = []
-        for name in args:
-            vals.append(_CONFIG_VARS.get(name))
-        return vals
-    else:
-        return _CONFIG_VARS
-
-
-def get_config_var(name):
-    """Return the value of a single variable using the dictionary returned by
-    'get_config_vars()'.
-
-    Equivalent to get_config_vars().get(name)
-    """
-    return get_config_vars().get(name)
-
-
-def get_platform():
-    """Return a string that identifies the current platform.
-
-    This is used mainly to distinguish platform-specific build directories and
-    platform-specific built distributions.  Typically includes the OS name and
-    version and the architecture (as supplied by 'os.uname()'), although the
-    exact information included depends on the OS; on Linux, the kernel version
-    isn't particularly important.
-
-    Examples of returned values:
-       linux-i586
-       linux-alpha (?)
-       solaris-2.6-sun4u
-
-    Windows will return one of:
-       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
-       win32 (all others - specifically, sys.platform is returned)
-
-    For other non-POSIX platforms, currently just returns 'sys.platform'.
-
-    """
-    if os.name == 'nt':
-        if 'amd64' in sys.version.lower():
-            return 'win-amd64'
-        if '(arm)' in sys.version.lower():
-            return 'win-arm32'
-        if '(arm64)' in sys.version.lower():
-            return 'win-arm64'
-        return sys.platform
-
-    if os.name != "posix" or not hasattr(os, 'uname'):
-        # XXX what about the architecture? NT is Intel or Alpha
-        return sys.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":
-        # 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"
-            release = f"{int(release[0]) - 3}.{release[2:]}"
-            # We can't use "platform.architecture()[0]" because a
-            # bootstrap problem. We use a dict to get an error
-            # if some suspicious happens.
-            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
-            machine += f".{bitness[sys.maxsize]}"
-        # fall through to standard osname-release-machine representation
-    elif osname[:3] == "aix":
-        from _aix_support import aix_platform
-        return aix_platform()
-    elif osname[:6] == "cygwin":
-        osname = "cygwin"
-        import re
-        rel_re = re.compile(r'[\d.]+')
-        m = rel_re.match(release)
-        if m:
-            release = m.group()
-    elif osname[:6] == "darwin":
-        import _osx_support
-        osname, release, machine = _osx_support.get_platform_osx(
-                                            get_config_vars(),
-                                            osname, release, machine)
-
-    return f"{osname}-{release}-{machine}"
-
-
-def get_python_version():
-    return _PY_VERSION_SHORT
-
-
-def expand_makefile_vars(s, vars):
-    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
-    'string' according to 'vars' (a dictionary mapping variable names to
-    values).  Variables not present in 'vars' are silently expanded to the
-    empty string.  The variable values in 'vars' should not contain further
-    variable expansions; if 'vars' is the output of 'parse_makefile()',
-    you're fine.  Returns a variable-expanded version of 's'.
-    """
-    import re
-
-    # This algorithm does multiple expansion, so if vars['foo'] contains
-    # "${bar}", it will expand ${foo} to ${bar}, and then expand
-    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
-    # 'parse_makefile()', which takes care of such expansions eagerly,
-    # according to make's variable expansion semantics.
-
-    while True:
-        m = re.search(_findvar1_rx, s) or re.search(_findvar2_rx, s)
-        if m:
-            (beg, end) = m.span()
-            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
-        else:
-            break
-    return s
-
-
-def _print_dict(title, data):
-    for index, (key, value) in enumerate(sorted(data.items())):
-        if index == 0:
-            print(f'{title}: ')
-        print(f'\t{key} = "{value}"')
-
-
-def _main():
-    """Display all information sysconfig detains."""
-    if '--generate-posix-vars' in sys.argv:
-        _generate_posix_vars()
-        return
-    print(f'Platform: "{get_platform()}"')
-    print(f'Python version: "{get_python_version()}"')
-    print(f'Current installation scheme: "{get_default_scheme()}"')
-    print()
-    _print_dict('Paths', get_paths())
-    print()
-    _print_dict('Variables', get_config_vars())
-
-if __name__ == '__main__':
-    _main()
-'''.replace("Python", "RustPython").replace("/python", "/rustpython"))
diff --git a/Lib/sysconfig/__init__.py b/Lib/sysconfig/__init__.py
new file mode 100644
index 0000000000..8365236f61
--- /dev/null
+++ b/Lib/sysconfig/__init__.py
@@ -0,0 +1,726 @@
+"""Access to Python's configuration information."""
+
+import os
+import sys
+import threading
+from os.path import realpath
+
+__all__ = [
+    'get_config_h_filename',
+    'get_config_var',
+    'get_config_vars',
+    'get_makefile_filename',
+    'get_path',
+    'get_path_names',
+    'get_paths',
+    'get_platform',
+    'get_python_version',
+    'get_scheme_names',
+    'parse_config_h',
+]
+
+# Keys for get_config_var() that are never converted to Python integers.
+_ALWAYS_STR = {
+    'IPHONEOS_DEPLOYMENT_TARGET',
+    'MACOSX_DEPLOYMENT_TARGET',
+}
+
+_INSTALL_SCHEMES = {
+    'posix_prefix': {
+        'stdlib': '{installed_base}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+        'platstdlib': '{platbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+        'purelib': '{base}/lib/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+        'platlib': '{platbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+        'include':
+            '{installed_base}/include/{implementation_lower}{py_version_short}{abiflags}',
+        'platinclude':
+            '{installed_platbase}/include/{implementation_lower}{py_version_short}{abiflags}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+        },
+    'posix_home': {
+        'stdlib': '{installed_base}/lib/{implementation_lower}',
+        'platstdlib': '{base}/lib/{implementation_lower}',
+        'purelib': '{base}/lib/{implementation_lower}',
+        'platlib': '{base}/lib/{implementation_lower}',
+        'include': '{installed_base}/include/{implementation_lower}',
+        'platinclude': '{installed_base}/include/{implementation_lower}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+        },
+    'nt': {
+        'stdlib': '{installed_base}/Lib',
+        'platstdlib': '{base}/Lib',
+        'purelib': '{base}/Lib/site-packages',
+        'platlib': '{base}/Lib/site-packages',
+        'include': '{installed_base}/Include',
+        'platinclude': '{installed_base}/Include',
+        'scripts': '{base}/Scripts',
+        'data': '{base}',
+        },
+
+    # Downstream distributors can overwrite the default install scheme.
+    # This is done to support downstream modifications where distributors change
+    # the installation layout (eg. different site-packages directory).
+    # So, distributors will change the default scheme to one that correctly
+    # represents their layout.
+    # This presents an issue for projects/people that need to bootstrap virtual
+    # environments, like virtualenv. As distributors might now be customizing
+    # the default install scheme, there is no guarantee that the information
+    # returned by sysconfig.get_default_scheme/get_paths is correct for
+    # a virtual environment, the only guarantee we have is that it is correct
+    # for the *current* environment. When bootstrapping a virtual environment,
+    # we need to know its layout, so that we can place the files in the
+    # correct locations.
+    # The "*_venv" install scheme is a scheme to bootstrap virtual environments,
+    # essentially identical to the default posix_prefix/nt schemes.
+    # Downstream distributors who patch posix_prefix/nt scheme are encouraged to
+    # leave the following schemes unchanged
+    'posix_venv': {
+        'stdlib': '{installed_base}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+        'platstdlib': '{platbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+        'purelib': '{base}/lib/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+        'platlib': '{platbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+        'include':
+            '{installed_base}/include/{implementation_lower}{py_version_short}{abiflags}',
+        'platinclude':
+            '{installed_platbase}/include/{implementation_lower}{py_version_short}{abiflags}',
+        'scripts': '{base}/bin',
+        'data': '{base}',
+        },
+    'nt_venv': {
+        'stdlib': '{installed_base}/Lib',
+        'platstdlib': '{base}/Lib',
+        'purelib': '{base}/Lib/site-packages',
+        'platlib': '{base}/Lib/site-packages',
+        'include': '{installed_base}/Include',
+        'platinclude': '{installed_base}/Include',
+        'scripts': '{base}/Scripts',
+        'data': '{base}',
+        },
+    }
+
+# For the OS-native venv scheme, we essentially provide an alias:
+if os.name == 'nt':
+    _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['nt_venv']
+else:
+    _INSTALL_SCHEMES['venv'] = _INSTALL_SCHEMES['posix_venv']
+
+def _get_implementation():
+    return 'RustPython' # XXX: For site-packages
+
+# NOTE: site.py has copy of this function.
+# Sync it when modify this function.
+def _getuserbase():
+    env_base = os.environ.get("PYTHONUSERBASE", None)
+    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"}:
+        return None
+
+    def joinuser(*args):
+        return os.path.expanduser(os.path.join(*args))
+
+    if os.name == "nt":
+        base = os.environ.get("APPDATA") or "~"
+        return joinuser(base,  _get_implementation())
+
+    if sys.platform == "darwin" and sys._framework:
+        return joinuser("~", "Library", sys._framework,
+                        f"{sys.version_info[0]}.{sys.version_info[1]}")
+
+    return joinuser("~", ".local")
+
+_HAS_USER_BASE = (_getuserbase() is not None)
+
+if _HAS_USER_BASE:
+    _INSTALL_SCHEMES |= {
+        # NOTE: When modifying "purelib" scheme, update site._get_path() too.
+        'nt_user': {
+            'stdlib': '{userbase}/{implementation}{py_version_nodot_plat}',
+            'platstdlib': '{userbase}/{implementation}{py_version_nodot_plat}',
+            'purelib': '{userbase}/{implementation}{py_version_nodot_plat}/site-packages',
+            'platlib': '{userbase}/{implementation}{py_version_nodot_plat}/site-packages',
+            'include': '{userbase}/{implementation}{py_version_nodot_plat}/Include',
+            'scripts': '{userbase}/{implementation}{py_version_nodot_plat}/Scripts',
+            'data': '{userbase}',
+            },
+        'posix_user': {
+            'stdlib': '{userbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+            'platstdlib': '{userbase}/{platlibdir}/{implementation_lower}{py_version_short}{abi_thread}',
+            'purelib': '{userbase}/lib/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+            'platlib': '{userbase}/lib/{implementation_lower}{py_version_short}{abi_thread}/site-packages',
+            'include': '{userbase}/include/{implementation_lower}{py_version_short}{abi_thread}',
+            'scripts': '{userbase}/bin',
+            'data': '{userbase}',
+            },
+        'osx_framework_user': {
+            'stdlib': '{userbase}/lib/{implementation_lower}',
+            'platstdlib': '{userbase}/lib/{implementation_lower}',
+            'purelib': '{userbase}/lib/{implementation_lower}/site-packages',
+            'platlib': '{userbase}/lib/{implementation_lower}/site-packages',
+            'include': '{userbase}/include/{implementation_lower}{py_version_short}',
+            'scripts': '{userbase}/bin',
+            'data': '{userbase}',
+            },
+    }
+
+_SCHEME_KEYS = ('stdlib', 'platstdlib', 'purelib', 'platlib', 'include',
+                'scripts', 'data')
+
+_PY_VERSION = sys.version.split()[0]
+_PY_VERSION_SHORT = f'{sys.version_info[0]}.{sys.version_info[1]}'
+_PY_VERSION_SHORT_NO_DOT = f'{sys.version_info[0]}{sys.version_info[1]}'
+_BASE_PREFIX = os.path.normpath(sys.base_prefix)
+_BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)
+# Mutex guarding initialization of _CONFIG_VARS.
+_CONFIG_VARS_LOCK = threading.RLock()
+_CONFIG_VARS = None
+# True iff _CONFIG_VARS has been fully initialized.
+_CONFIG_VARS_INITIALIZED = False
+_USER_BASE = None
+
+
+def _safe_realpath(path):
+    try:
+        return realpath(path)
+    except OSError:
+        return path
+
+if sys.executable:
+    _PROJECT_BASE = os.path.dirname(_safe_realpath(sys.executable))
+else:
+    # sys.executable can be empty if argv[0] has been changed and Python is
+    # unable to retrieve the real program name
+    _PROJECT_BASE = _safe_realpath(os.getcwd())
+
+# In a virtual environment, `sys._home` gives us the target directory
+# `_PROJECT_BASE` for the executable that created it when the virtual
+# python is an actual executable ('venv --copies' or Windows).
+_sys_home = getattr(sys, '_home', None)
+if _sys_home:
+    _PROJECT_BASE = _sys_home
+
+if os.name == 'nt':
+    # In a source build, the executable is in a subdirectory of the root
+    # that we want (<root>\PCbuild\<platname>).
+    # `_BASE_PREFIX` is used as the base installation is where the source
+    # will be.  The realpath is needed to prevent mount point confusion
+    # that can occur with just string comparisons.
+    if _safe_realpath(_PROJECT_BASE).startswith(
+            _safe_realpath(f'{_BASE_PREFIX}\\PCbuild')):
+        _PROJECT_BASE = _BASE_PREFIX
+
+# set for cross builds
+if "_PYTHON_PROJECT_BASE" in os.environ:
+    _PROJECT_BASE = _safe_realpath(os.environ["_PYTHON_PROJECT_BASE"])
+
+def is_python_build(check_home=None):
+    if check_home is not None:
+        import warnings
+        warnings.warn(
+            (
+                'The check_home argument of sysconfig.is_python_build is '
+                'deprecated and its value is ignored. '
+                'It will be removed in Python 3.15.'
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    for fn in ("Setup", "Setup.local"):
+        if os.path.isfile(os.path.join(_PROJECT_BASE, "Modules", fn)):
+            return True
+    return False
+
+_PYTHON_BUILD = is_python_build()
+
+if _PYTHON_BUILD:
+    for scheme in ('posix_prefix', 'posix_home'):
+        # On POSIX-y platforms, Python will:
+        # - Build from .h files in 'headers' (which is only added to the
+        #   scheme when building CPython)
+        # - Install .h files to 'include'
+        scheme = _INSTALL_SCHEMES[scheme]
+        scheme['headers'] = scheme['include']
+        scheme['include'] = '{srcdir}/Include'
+        scheme['platinclude'] = '{projectbase}/.'
+    del scheme
+
+
+def _subst_vars(s, local_vars):
+    try:
+        return s.format(**local_vars)
+    except KeyError as var:
+        try:
+            return s.format(**os.environ)
+        except KeyError:
+            raise AttributeError(f'{var}') from None
+
+def _extend_dict(target_dict, other_dict):
+    target_keys = target_dict.keys()
+    for key, value in other_dict.items():
+        if key in target_keys:
+            continue
+        target_dict[key] = value
+
+
+def _expand_vars(scheme, vars):
+    res = {}
+    if vars is None:
+        vars = {}
+    _extend_dict(vars, get_config_vars())
+    if os.name == 'nt':
+        # On Windows we want to substitute 'lib' for schemes rather
+        # than the native value (without modifying vars, in case it
+        # was passed in)
+        vars = vars | {'platlibdir': 'lib'}
+
+    for key, value in _INSTALL_SCHEMES[scheme].items():
+        if os.name in ('posix', 'nt'):
+            value = os.path.expanduser(value)
+        res[key] = os.path.normpath(_subst_vars(value, vars))
+    return res
+
+
+def _get_preferred_schemes():
+    if os.name == 'nt':
+        return {
+            'prefix': 'nt',
+            'home': 'posix_home',
+            'user': 'nt_user',
+        }
+    if sys.platform == 'darwin' and sys._framework:
+        return {
+            'prefix': 'posix_prefix',
+            'home': 'posix_home',
+            'user': 'osx_framework_user',
+        }
+
+    return {
+        'prefix': 'posix_prefix',
+        'home': 'posix_home',
+        'user': 'posix_user',
+    }
+
+
+def get_preferred_scheme(key):
+    if key == 'prefix' and sys.prefix != sys.base_prefix:
+        return 'venv'
+    scheme = _get_preferred_schemes()[key]
+    if scheme not in _INSTALL_SCHEMES:
+        raise ValueError(
+            f"{key!r} returned {scheme!r}, which is not a valid scheme "
+            f"on this platform"
+        )
+    return scheme
+
+
+def get_default_scheme():
+    return get_preferred_scheme('prefix')
+
+
+def get_makefile_filename():
+    """Return the path of the 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 _get_sysconfigdata_name():
+    multiarch = getattr(sys.implementation, '_multiarch', '')
+    return os.environ.get(
+        '_PYTHON_SYSCONFIGDATA_NAME',
+        f'_sysconfigdata_{sys.abiflags}_{sys.platform}_{multiarch}',
+    )
+
+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()
+
+    # 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"""
+    # set basic install directories
+    import _winapi
+    import _sysconfig
+    vars['LIBDEST'] = get_path('stdlib')
+    vars['BINLIBDEST'] = get_path('platstdlib')
+    vars['INCLUDEPY'] = get_path('include')
+
+    # Add EXT_SUFFIX, SOABI, and Py_GIL_DISABLED
+    vars.update(_sysconfig.config_vars())
+
+    vars['LIBDIR'] = _safe_realpath(os.path.join(get_config_var('installed_base'), 'libs'))
+    if hasattr(sys, 'dllhandle'):
+        dllhandle = _winapi.GetModuleFileName(sys.dllhandle)
+        vars['LIBRARY'] = os.path.basename(_safe_realpath(dllhandle))
+        vars['LDLIBRARY'] = vars['LIBRARY']
+    vars['EXE'] = '.exe'
+    vars['VERSION'] = _PY_VERSION_SHORT_NO_DOT
+    vars['BINDIR'] = os.path.dirname(_safe_realpath(sys.executable))
+    vars['TZPATH'] = ''
+
+#
+# public APIs
+#
+
+
+def parse_config_h(fp, vars=None):
+    """Parse a config.h-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    if vars is None:
+        vars = {}
+    import re
+    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
+    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
+
+    while True:
+        line = fp.readline()
+        if not line:
+            break
+        m = define_rx.match(line)
+        if m:
+            n, v = m.group(1, 2)
+            try:
+                if n in _ALWAYS_STR:
+                    raise ValueError
+                v = int(v)
+            except ValueError:
+                pass
+            vars[n] = v
+        else:
+            m = undef_rx.match(line)
+            if m:
+                vars[m.group(1)] = 0
+    return vars
+
+
+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)
+        else:
+            inc_dir = _PROJECT_BASE
+    else:
+        inc_dir = get_path('platinclude')
+    return os.path.join(inc_dir, 'pyconfig.h')
+
+
+def get_scheme_names():
+    """Return a tuple containing the schemes names."""
+    return tuple(sorted(_INSTALL_SCHEMES))
+
+
+def get_path_names():
+    """Return a tuple containing the paths names."""
+    return _SCHEME_KEYS
+
+
+def get_paths(scheme=get_default_scheme(), vars=None, expand=True):
+    """Return a mapping containing an install scheme.
+
+    ``scheme`` is the install scheme name. If not provided, it will
+    return the default scheme for the current platform.
+    """
+    if expand:
+        return _expand_vars(scheme, vars)
+    else:
+        return _INSTALL_SCHEMES[scheme]
+
+
+def get_path(name, scheme=get_default_scheme(), vars=None, expand=True):
+    """Return a path corresponding to the scheme.
+
+    ``scheme`` is the install scheme name.
+    """
+    return get_paths(scheme, vars, expand)[name]
+
+
+def _init_config_vars():
+    global _CONFIG_VARS
+    _CONFIG_VARS = {}
+    # Normalized versions of prefix and exec_prefix are handy to have;
+    # in fact, these are the standard versions used most places in the
+    # Distutils.
+    _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['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['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'] = ''
+    try:
+        _CONFIG_VARS['py_version_nodot_plat'] = sys.winver.replace('.', '')
+    except AttributeError:
+        _CONFIG_VARS['py_version_nodot_plat'] = ''
+
+    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
+        # the init-function.
+        _CONFIG_VARS['userbase'] = _getuserbase()
+
+    # e.g., 't' for free-threaded or '' for default build
+    _CONFIG_VARS['abi_thread'] = 't' if _CONFIG_VARS.get('Py_GIL_DISABLED') else ''
+
+    # Always convert srcdir to an absolute path
+    srcdir = _CONFIG_VARS.get('srcdir', _PROJECT_BASE)
+    if os.name == 'posix':
+        if _PYTHON_BUILD:
+            # If srcdir is a relative path (typically '.' or '..')
+            # then it should be interpreted relative to the directory
+            # containing Makefile.
+            base = os.path.dirname(get_makefile_filename())
+            srcdir = os.path.join(base, srcdir)
+        else:
+            # srcdir is not meaningful since the installation is
+            # spread about the filesystem.  We choose the
+            # directory containing the Makefile since we know it
+            # exists.
+            srcdir = os.path.dirname(get_makefile_filename())
+    _CONFIG_VARS['srcdir'] = _safe_realpath(srcdir)
+
+    # OS X platforms require special customization to handle
+    # multi-architecture, multi-os-version installers
+    if sys.platform == 'darwin':
+        import _osx_support
+        _osx_support.customize_config_vars(_CONFIG_VARS)
+
+    global _CONFIG_VARS_INITIALIZED
+    _CONFIG_VARS_INITIALIZED = True
+
+
+def get_config_vars(*args):
+    """With no arguments, return a dictionary of all configuration
+    variables relevant for the current platform.
+
+    On Unix, this means every variable defined in Python's installed Makefile;
+    On Windows it's a much smaller set.
+
+    With arguments, return a list of values that result from looking up
+    each argument in the configuration variable dictionary.
+    """
+    global _CONFIG_VARS_INITIALIZED
+
+    # Avoid claiming the lock once initialization is complete.
+    if not _CONFIG_VARS_INITIALIZED:
+        with _CONFIG_VARS_LOCK:
+            # Test again with the lock held to avoid races. Note that
+            # we test _CONFIG_VARS here, not _CONFIG_VARS_INITIALIZED,
+            # to ensure that recursive calls to get_config_vars()
+            # 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 = []
+        for name in args:
+            vals.append(_CONFIG_VARS.get(name))
+        return vals
+    else:
+        return _CONFIG_VARS
+
+
+def get_config_var(name):
+    """Return the value of a single variable using the dictionary returned by
+    'get_config_vars()'.
+
+    Equivalent to get_config_vars().get(name)
+    """
+    return get_config_vars().get(name)
+
+
+def get_platform():
+    """Return a string that identifies the current platform.
+
+    This is used mainly to distinguish platform-specific build directories and
+    platform-specific built distributions.  Typically includes the OS name and
+    version and the architecture (as supplied by 'os.uname()'), although the
+    exact information included depends on the OS; on Linux, the kernel version
+    isn't particularly important.
+
+    Examples of returned values:
+
+
+    Windows:
+
+    - win-amd64 (64-bit Windows on AMD64, aka x86_64, Intel64, and EM64T)
+    - win-arm64 (64-bit Windows on ARM64, aka AArch64)
+    - win32 (all others - specifically, sys.platform is returned)
+
+    POSIX based OS:
+
+    - linux-x86_64
+    - macosx-15.5-arm64
+    - macosx-26.0-universal2 (macOS on Apple Silicon or Intel)
+    - android-24-arm64_v8a
+
+    For other non-POSIX platforms, currently just returns :data:`sys.platform`."""
+    if os.name == 'nt':
+        if 'amd64' in sys.version.lower():
+            return 'win-amd64'
+        if '(arm)' in sys.version.lower():
+            return 'win-arm32'
+        if '(arm64)' in sys.version.lower():
+            return 'win-arm64'
+        return sys.platform
+
+    if os.name != "posix" or not hasattr(os, 'uname'):
+        # XXX what about the architecture? NT is Intel or Alpha
+        return sys.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}"
+    elif osname[:5] == "sunos":
+        if release[0] >= "5":           # SunOS 5 == Solaris 2
+            osname = "solaris"
+            release = f"{int(release[0]) - 3}.{release[2:]}"
+            # We can't use "platform.architecture()[0]" because a
+            # bootstrap problem. We use a dict to get an error
+            # if some suspicious happens.
+            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
+            machine += f".{bitness[sys.maxsize]}"
+        # fall through to standard osname-release-machine representation
+    elif osname[:3] == "aix":
+        from _aix_support import aix_platform
+        return aix_platform()
+    elif osname[:6] == "cygwin":
+        osname = "cygwin"
+        import re
+        rel_re = re.compile(r'[\d.]+')
+        m = rel_re.match(release)
+        if m:
+            release = m.group()
+    elif osname[:6] == "darwin":
+        if sys.platform == "ios":
+            release = get_config_vars().get("IPHONEOS_DEPLOYMENT_TARGET", "13.0")
+            osname = sys.platform
+            machine = sys.implementation._multiarch
+        else:
+            import _osx_support
+            osname, release, machine = _osx_support.get_platform_osx(
+                                                get_config_vars(),
+                                                osname, release, machine)
+
+    return f"{osname}-{release}-{machine}"
+
+
+def get_python_version():
+    return _PY_VERSION_SHORT
+
+
+def _get_python_version_abi():
+    return _PY_VERSION_SHORT + get_config_var("abi_thread")
+
+
+def expand_makefile_vars(s, vars):
+    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
+    'string' according to 'vars' (a dictionary mapping variable names to
+    values).  Variables not present in 'vars' are silently expanded to the
+    empty string.  The variable values in 'vars' should not contain further
+    variable expansions; if 'vars' is the output of 'parse_makefile()',
+    you're fine.  Returns a variable-expanded version of 's'.
+    """
+    import re
+
+    _findvar1_rx = r"\$\(([A-Za-z][A-Za-z0-9_]*)\)"
+    _findvar2_rx = r"\${([A-Za-z][A-Za-z0-9_]*)}"
+
+    # This algorithm does multiple expansion, so if vars['foo'] contains
+    # "${bar}", it will expand ${foo} to ${bar}, and then expand
+    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
+    # 'parse_makefile()', which takes care of such expansions eagerly,
+    # according to make's variable expansion semantics.
+
+    while True:
+        m = re.search(_findvar1_rx, s) or re.search(_findvar2_rx, s)
+        if m:
+            (beg, end) = m.span()
+            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
+        else:
+            break
+    return s
diff --git a/Lib/sysconfig/__main__.py b/Lib/sysconfig/__main__.py
new file mode 100644
index 0000000000..d7257b9d2d
--- /dev/null
+++ b/Lib/sysconfig/__main__.py
@@ -0,0 +1,248 @@
+import os
+import sys
+from sysconfig import (
+    _ALWAYS_STR,
+    _PYTHON_BUILD,
+    _get_sysconfigdata_name,
+    get_config_h_filename,
+    get_config_vars,
+    get_default_scheme,
+    get_makefile_filename,
+    get_paths,
+    get_platform,
+    get_python_version,
+    parse_config_h,
+)
+
+
+# Regexes needed for parsing Makefile (and similar syntaxes,
+# like old-style Setup files).
+_variable_rx = r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)"
+_findvar1_rx = r"\$\(([A-Za-z][A-Za-z0-9_]*)\)"
+_findvar2_rx = r"\${([A-Za-z][A-Za-z0-9_]*)}"
+
+
+def _parse_makefile(filename, vars=None, keep_unresolved=True):
+    """Parse a Makefile-style file.
+
+    A dictionary containing name/value pairs is returned.  If an
+    optional dictionary is passed in as the second argument, it is
+    used instead of a new dictionary.
+    """
+    import re
+
+    if vars is None:
+        vars = {}
+    done = {}
+    notdone = {}
+
+    with open(filename, encoding=sys.getfilesystemencoding(),
+              errors="surrogateescape") as f:
+        lines = f.readlines()
+
+    for line in lines:
+        if line.startswith('#') or line.strip() == '':
+            continue
+        m = re.match(_variable_rx, line)
+        if m:
+            n, v = m.group(1, 2)
+            v = v.strip()
+            # `$$' is a literal `$' in make
+            tmpv = v.replace('$$', '')
+
+            if "$" in tmpv:
+                notdone[n] = v
+            else:
+                try:
+                    if n in _ALWAYS_STR:
+                        raise ValueError
+
+                    v = int(v)
+                except ValueError:
+                    # insert literal `$'
+                    done[n] = v.replace('$$', '$')
+                else:
+                    done[n] = v
+
+    # do variable interpolation here
+    variables = list(notdone.keys())
+
+    # Variables with a 'PY_' prefix in the makefile. These need to
+    # be made available without that prefix through sysconfig.
+    # Special care is needed to ensure that variable expansion works, even
+    # if the expansion uses the name without a prefix.
+    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')
+
+    while len(variables) > 0:
+        for name in tuple(variables):
+            value = notdone[name]
+            m1 = re.search(_findvar1_rx, value)
+            m2 = re.search(_findvar2_rx, value)
+            if m1 and m2:
+                m = m1 if m1.start() < m2.start() else m2
+            else:
+                m = m1 if m1 else m2
+            if m is not None:
+                n = m.group(1)
+                found = True
+                if n in done:
+                    item = str(done[n])
+                elif n in notdone:
+                    # get it on a subsequent round
+                    found = False
+                elif n in os.environ:
+                    # do it like make: fall back to environment
+                    item = os.environ[n]
+
+                elif n in renamed_variables:
+                    if (name.startswith('PY_') and
+                        name[3:] in renamed_variables):
+                        item = ""
+
+                    elif 'PY_' + n in notdone:
+                        found = False
+
+                    else:
+                        item = str(done['PY_' + n])
+
+                else:
+                    done[n] = item = ""
+
+                if found:
+                    after = value[m.end():]
+                    value = value[:m.start()] + item + after
+                    if "$" in after:
+                        notdone[name] = value
+                    else:
+                        try:
+                            if name in _ALWAYS_STR:
+                                raise ValueError
+                            value = int(value)
+                        except ValueError:
+                            done[name] = value.strip()
+                        else:
+                            done[name] = value
+                        variables.remove(name)
+
+                        if name.startswith('PY_') \
+                        and name[3:] in renamed_variables:
+
+                            name = name[3:]
+                            if name not in done:
+                                done[name] = value
+
+            else:
+                # Adds unresolved variables to the done dict.
+                # This is disabled when called from distutils.sysconfig
+                if keep_unresolved:
+                    done[name] = value
+                # bogus variable reference (e.g. "prefix=$/opt/python");
+                # just drop it since we can't deal
+                variables.remove(name)
+
+    # strip spurious spaces
+    for k, v in done.items():
+        if isinstance(v, str):
+            done[k] = v.strip()
+
+    # save the results in the global dictionary
+    vars.update(done)
+    return vars
+
+
+def _print_config_dict(d, stream):
+    print ("{", file=stream)
+    for k, v in sorted(d.items()):
+        print(f"    {k!r}: {v!r},", file=stream)
+    print ("}", file=stream)
+
+
+def _generate_posix_vars():
+    """Generate the Python module containing build-time variables."""
+    vars = {}
+    # load the installed Makefile:
+    makefile = get_makefile_filename()
+    try:
+        _parse_makefile(makefile, vars)
+    except OSError as e:
+        msg = f"invalid Python installation: unable to open {makefile}"
+        if hasattr(e, "strerror"):
+            msg = f"{msg} ({e.strerror})"
+        raise OSError(msg)
+    # load the installed pyconfig.h:
+    config_h = get_config_h_filename()
+    try:
+        with open(config_h, encoding="utf-8") as f:
+            parse_config_h(f, vars)
+    except OSError as e:
+        msg = f"invalid Python installation: unable to open {config_h}"
+        if hasattr(e, "strerror"):
+            msg = f"{msg} ({e.strerror})"
+        raise OSError(msg)
+    # On AIX, there are wrong paths to the linker scripts in the Makefile
+    # -- these paths are relative to the Python source, but when installed
+    # the scripts are in another directory.
+    if _PYTHON_BUILD:
+        vars['BLDSHARED'] = vars['LDSHARED']
+
+    # 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
+    # `make pybuilddir.txt` target -- which is a precursor to the
+    # _sysconfigdata.py module being constructed.  Unfortunately,
+    # get_config_vars() eventually calls _init_posix(), which attempts
+    # to import _sysconfigdata, which we won't have built yet.  In order
+    # for _init_posix() to work, if we're on Darwin, just mock up the
+    # _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
+
+    pybuilddir = f'build/lib.{get_platform()}-{get_python_version()}'
+    if hasattr(sys, "gettotalrefcount"):
+        pybuilddir += '-pydebug'
+    os.makedirs(pybuilddir, exist_ok=True)
+    destfile = os.path.join(pybuilddir, name + '.py')
+
+    with open(destfile, 'w', encoding='utf8') as f:
+        f.write('# system configuration generated and used by'
+                ' the sysconfig module\n')
+        f.write('build_time_vars = ')
+        _print_config_dict(vars, stream=f)
+
+    # Create file used for sys.path fixup -- see Modules/getpath.c
+    with open('pybuilddir.txt', 'w', encoding='utf8') as f:
+        f.write(pybuilddir)
+
+
+def _print_dict(title, data):
+    for index, (key, value) in enumerate(sorted(data.items())):
+        if index == 0:
+            print(f'{title}: ')
+        print(f'\t{key} = "{value}"')
+
+
+def _main():
+    """Display all information sysconfig detains."""
+    if '--generate-posix-vars' in sys.argv:
+        _generate_posix_vars()
+        return
+    print(f'Platform: "{get_platform()}"')
+    print(f'Python version: "{get_python_version()}"')
+    print(f'Current installation scheme: "{get_default_scheme()}"')
+    print()
+    _print_dict('Paths', get_paths())
+    print()
+    _print_dict('Variables', get_config_vars())
+
+
+if __name__ == '__main__':
+    try:
+        _main()
+    except BrokenPipeError:
+        pass
diff --git a/Lib/tabnanny.py b/Lib/tabnanny.py
index 7973f26f98..d06c4c221e 100755
--- a/Lib/tabnanny.py
+++ b/Lib/tabnanny.py
@@ -23,8 +23,6 @@
 import os
 import sys
 import tokenize
-if not hasattr(tokenize, 'NL'):
-    raise ValueError("tokenize.NL doesn't exist -- tokenize module too old")
 
 __all__ = ["check", "NannyNag", "process_tokens"]
 
@@ -37,6 +35,7 @@ def errprint(*args):
         sys.stderr.write(sep + str(arg))
         sep = " "
     sys.stderr.write("\n")
+    sys.exit(1)
 
 def main():
     import getopt
@@ -46,7 +45,6 @@ def main():
         opts, args = getopt.getopt(sys.argv[1:], "qv")
     except getopt.error as msg:
         errprint(msg)
-        return
     for o, a in opts:
         if o == '-q':
             filename_only = filename_only + 1
@@ -54,7 +52,6 @@ def main():
             verbose = verbose + 1
     if not args:
         errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...")
-        return
     for arg in args:
         check(arg)
 
@@ -114,6 +111,10 @@ def check(file):
         errprint("%r: Indentation Error: %s" % (file, msg))
         return
 
+    except SyntaxError as msg:
+        errprint("%r: Syntax Error: %s" % (file, msg))
+        return
+
     except NannyNag as nag:
         badline = nag.get_lineno()
         line = nag.get_line()
@@ -275,6 +276,12 @@ def format_witnesses(w):
     return prefix + " " + ', '.join(firsts)
 
 def process_tokens(tokens):
+    try:
+        _process_tokens(tokens)
+    except TabError as e:
+        raise NannyNag(e.lineno, e.msg, e.text)
+
+def _process_tokens(tokens):
     INDENT = tokenize.INDENT
     DEDENT = tokenize.DEDENT
     NEWLINE = tokenize.NEWLINE
diff --git a/Lib/tempfile.py b/Lib/tempfile.py
index 3aceb3f70f..8036e93cd6 100644
--- a/Lib/tempfile.py
+++ b/Lib/tempfile.py
@@ -46,7 +46,6 @@
 import sys as _sys
 import types as _types
 import weakref as _weakref
-
 import _thread
 _allocate_lock = _thread.allocate_lock
 
@@ -181,7 +180,7 @@ def _candidate_tempdir_list():
 
     return dirlist
 
-def _get_default_tempdir():
+def _get_default_tempdir(dirlist=None):
     """Calculate the default directory to use for temporary files.
     This routine should be called exactly once.
 
@@ -191,7 +190,8 @@ def _get_default_tempdir():
     service, the name of the test file must be randomized."""
 
     namer = _RandomNameSequence()
-    dirlist = _candidate_tempdir_list()
+    if dirlist is None:
+        dirlist = _candidate_tempdir_list()
 
     for dir in dirlist:
         if dir != _os.curdir:
@@ -204,8 +204,7 @@ def _get_default_tempdir():
                 fd = _os.open(filename, _bin_openflags, 0o600)
                 try:
                     try:
-                        with _io.open(fd, 'wb', closefd=False) as fp:
-                            fp.write(b'blat')
+                        _os.write(fd, b'blat')
                     finally:
                         _os.close(fd)
                 finally:
@@ -245,6 +244,7 @@ def _get_candidate_names():
 def _mkstemp_inner(dir, pre, suf, flags, output_type):
     """Code common to mkstemp, TemporaryFile, and NamedTemporaryFile."""
 
+    dir = _os.path.abspath(dir)
     names = _get_candidate_names()
     if output_type is bytes:
         names = map(_os.fsencode, names)
@@ -265,11 +265,27 @@ def _mkstemp_inner(dir, pre, suf, flags, output_type):
                 continue
             else:
                 raise
-        return (fd, _os.path.abspath(file))
+        return fd, file
 
     raise FileExistsError(_errno.EEXIST,
                           "No usable temporary file name found")
 
+def _dont_follow_symlinks(func, path, *args):
+    # Pass follow_symlinks=False, unless not supported on this platform.
+    if func in _os.supports_follow_symlinks:
+        func(path, *args, follow_symlinks=False)
+    elif not _os.path.islink(path):
+        func(path, *args)
+
+def _resetperms(path):
+    try:
+        chflags = _os.chflags
+    except AttributeError:
+        pass
+    else:
+        _dont_follow_symlinks(chflags, path, 0)
+    _dont_follow_symlinks(_os.chmod, path, 0o700)
+
 
 # User visible interfaces.
 
@@ -377,7 +393,7 @@ def mkdtemp(suffix=None, prefix=None, dir=None):
                 continue
             else:
                 raise
-        return file
+        return _os.path.abspath(file)
 
     raise FileExistsError(_errno.EEXIST,
                           "No usable temporary directory name found")
@@ -419,42 +435,42 @@ class _TemporaryFileCloser:
     underlying file object, without adding a __del__ method to the
     temporary file."""
 
-    file = None  # Set here since __del__ checks it
+    cleanup_called = False
     close_called = False
 
-    def __init__(self, file, name, delete=True):
+    def __init__(self, file, name, delete=True, delete_on_close=True):
         self.file = file
         self.name = name
         self.delete = delete
+        self.delete_on_close = delete_on_close
 
-    # NT provides delete-on-close as a primitive, so we don't need
-    # the wrapper to do anything special.  We still use it so that
-    # file.name is useful (i.e. not "(fdopen)") with NamedTemporaryFile.
-    if _os.name != 'nt':
-        # Cache the unlinker so we don't get spurious errors at
-        # shutdown when the module-level "os" is None'd out.  Note
-        # that this must be referenced as self.unlink, because the
-        # name TemporaryFileWrapper may also get None'd out before
-        # __del__ is called.
-
-        def close(self, unlink=_os.unlink):
-            if not self.close_called and self.file is not None:
-                self.close_called = True
-                try:
+    def cleanup(self, windows=(_os.name == 'nt'), unlink=_os.unlink):
+        if not self.cleanup_called:
+            self.cleanup_called = True
+            try:
+                if not self.close_called:
+                    self.close_called = True
                     self.file.close()
-                finally:
-                    if self.delete:
+            finally:
+                # Windows provides delete-on-close as a primitive, in which
+                # case the file was deleted by self.file.close().
+                if self.delete and not (windows and self.delete_on_close):
+                    try:
                         unlink(self.name)
+                    except FileNotFoundError:
+                        pass
 
-        # Need to ensure the file is deleted on __del__
-        def __del__(self):
-            self.close()
-
-    else:
-        def close(self):
-            if not self.close_called:
-                self.close_called = True
+    def close(self):
+        if not self.close_called:
+            self.close_called = True
+            try:
                 self.file.close()
+            finally:
+                if self.delete and self.delete_on_close:
+                    self.cleanup()
+
+    def __del__(self):
+        self.cleanup()
 
 
 class _TemporaryFileWrapper:
@@ -465,11 +481,11 @@ class _TemporaryFileWrapper:
     remove the file when it is no longer needed.
     """
 
-    def __init__(self, file, name, delete=True):
+    def __init__(self, file, name, delete=True, delete_on_close=True):
         self.file = file
         self.name = name
-        self.delete = delete
-        self._closer = _TemporaryFileCloser(file, name, delete)
+        self._closer = _TemporaryFileCloser(file, name, delete,
+                                            delete_on_close)
 
     def __getattr__(self, name):
         # Attribute lookups are delegated to the underlying file
@@ -500,7 +516,7 @@ def __enter__(self):
     # deleted when used in a with statement
     def __exit__(self, exc, value, tb):
         result = self.file.__exit__(exc, value, tb)
-        self.close()
+        self._closer.cleanup()
         return result
 
     def close(self):
@@ -519,10 +535,10 @@ def __iter__(self):
         for line in self.file:
             yield line
 
-
 def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
                        newline=None, suffix=None, prefix=None,
-                       dir=None, delete=True, *, errors=None):
+                       dir=None, delete=True, *, errors=None,
+                       delete_on_close=True):
     """Create and return a temporary file.
     Arguments:
     'prefix', 'suffix', 'dir' -- as for mkstemp.
@@ -530,13 +546,20 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
     'buffering' -- the buffer size argument to io.open (default -1).
     'encoding' -- the encoding argument to io.open (default None)
     'newline' -- the newline argument to io.open (default None)
-    'delete' -- whether the file is deleted on close (default True).
+    'delete' -- whether the file is automatically deleted (default True).
+    'delete_on_close' -- if 'delete', whether the file is deleted on close
+       (default True) or otherwise either on context manager exit
+       (if context manager was used) or on object finalization. .
     'errors' -- the errors argument to io.open (default None)
     The file is created as mkstemp() would do it.
 
     Returns an object with a file-like interface; the name of the file
     is accessible as its 'name' attribute.  The file will be automatically
     deleted when it is closed unless the 'delete' argument is set to False.
+
+    On POSIX, NamedTemporaryFiles cannot be automatically deleted if
+    the creating process is terminated abruptly with a SIGKILL signal.
+    Windows can delete the file even in this case.
     """
 
     prefix, suffix, dir, output_type = _sanitize_params(prefix, suffix, dir)
@@ -545,21 +568,33 @@ def NamedTemporaryFile(mode='w+b', buffering=-1, encoding=None,
 
     # Setting O_TEMPORARY in the flags causes the OS to delete
     # the file when it is closed.  This is only supported by Windows.
-    if _os.name == 'nt' and delete:
+    if _os.name == 'nt' and delete and delete_on_close:
         flags |= _os.O_TEMPORARY
 
     if "b" not in mode:
         encoding = _io.text_encoding(encoding)
 
-    (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+    name = None
+    def opener(*args):
+        nonlocal name
+        fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+        return fd
     try:
-        file = _io.open(fd, mode, buffering=buffering,
-                        newline=newline, encoding=encoding, errors=errors)
-
-        return _TemporaryFileWrapper(file, name, delete)
-    except BaseException:
-        _os.unlink(name)
-        _os.close(fd)
+        file = _io.open(dir, mode, buffering=buffering,
+                        newline=newline, encoding=encoding, errors=errors,
+                        opener=opener)
+        try:
+            raw = getattr(file, 'buffer', file)
+            raw = getattr(raw, 'raw', raw)
+            raw.name = name
+            return _TemporaryFileWrapper(file, name, delete, delete_on_close)
+        except:
+            file.close()
+            raise
+    except:
+        if name is not None and not (
+            _os.name == 'nt' and delete and delete_on_close):
+            _os.unlink(name)
         raise
 
 if _os.name != 'posix' or _sys.platform == 'cygwin':
@@ -598,9 +633,20 @@ def TemporaryFile(mode='w+b', buffering=-1, encoding=None,
 
         flags = _bin_openflags
         if _O_TMPFILE_WORKS:
-            try:
+            fd = None
+            def opener(*args):
+                nonlocal fd
                 flags2 = (flags | _os.O_TMPFILE) & ~_os.O_CREAT
                 fd = _os.open(dir, flags2, 0o600)
+                return fd
+            try:
+                file = _io.open(dir, mode, buffering=buffering,
+                                newline=newline, encoding=encoding,
+                                errors=errors, opener=opener)
+                raw = getattr(file, 'buffer', file)
+                raw = getattr(raw, 'raw', raw)
+                raw.name = fd
+                return file
             except IsADirectoryError:
                 # Linux kernel older than 3.11 ignores the O_TMPFILE flag:
                 # O_TMPFILE is read as O_DIRECTORY. Trying to open a directory
@@ -617,26 +663,27 @@ def TemporaryFile(mode='w+b', buffering=-1, encoding=None,
                 # fails with NotADirectoryError, because O_TMPFILE is read as
                 # O_DIRECTORY.
                 pass
-            else:
-                try:
-                    return _io.open(fd, mode, buffering=buffering,
-                                    newline=newline, encoding=encoding,
-                                    errors=errors)
-                except:
-                    _os.close(fd)
-                    raise
             # Fallback to _mkstemp_inner().
 
-        (fd, name) = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
-        try:
-            _os.unlink(name)
-            return _io.open(fd, mode, buffering=buffering,
-                            newline=newline, encoding=encoding, errors=errors)
-        except:
-            _os.close(fd)
-            raise
+        fd = None
+        def opener(*args):
+            nonlocal fd
+            fd, name = _mkstemp_inner(dir, prefix, suffix, flags, output_type)
+            try:
+                _os.unlink(name)
+            except BaseException as e:
+                _os.close(fd)
+                raise
+            return fd
+        file = _io.open(dir, mode, buffering=buffering,
+                        newline=newline, encoding=encoding, errors=errors,
+                        opener=opener)
+        raw = getattr(file, 'buffer', file)
+        raw = getattr(raw, 'raw', raw)
+        raw.name = fd
+        return file
 
-class SpooledTemporaryFile:
+class SpooledTemporaryFile(_io.IOBase):
     """Temporary file wrapper, specialized to switch from BytesIO
     or StringIO to a real file when it exceeds a certain size or
     when a fileno is needed.
@@ -701,6 +748,16 @@ def __exit__(self, exc, value, tb):
     def __iter__(self):
         return self._file.__iter__()
 
+    def __del__(self):
+        if not self.closed:
+            _warnings.warn(
+                "Unclosed file {!r}".format(self),
+                ResourceWarning,
+                stacklevel=2,
+                source=self
+            )
+            self.close()
+
     def close(self):
         self._file.close()
 
@@ -744,15 +801,30 @@ def name(self):
     def newlines(self):
         return self._file.newlines
 
+    def readable(self):
+        return self._file.readable()
+
     def read(self, *args):
         return self._file.read(*args)
 
+    def read1(self, *args):
+        return self._file.read1(*args)
+
+    def readinto(self, b):
+        return self._file.readinto(b)
+
+    def readinto1(self, b):
+        return self._file.readinto1(b)
+
     def readline(self, *args):
         return self._file.readline(*args)
 
     def readlines(self, *args):
         return self._file.readlines(*args)
 
+    def seekable(self):
+        return self._file.seekable()
+
     def seek(self, *args):
         return self._file.seek(*args)
 
@@ -761,11 +833,14 @@ def tell(self):
 
     def truncate(self, size=None):
         if size is None:
-            self._file.truncate()
+            return self._file.truncate()
         else:
             if size > self._max_size:
                 self.rollover()
-            self._file.truncate(size)
+            return self._file.truncate(size)
+
+    def writable(self):
+        return self._file.writable()
 
     def write(self, s):
         file = self._file
@@ -774,10 +849,17 @@ def write(self, s):
         return rv
 
     def writelines(self, iterable):
-        file = self._file
-        rv = file.writelines(iterable)
-        self._check(file)
-        return rv
+        if self._max_size == 0 or self._rolled:
+            return self._file.writelines(iterable)
+
+        it = iter(iterable)
+        for line in it:
+            self.write(line)
+            if self._rolled:
+                return self._file.writelines(it)
+
+    def detach(self):
+        return self._file.detach()
 
 
 class TemporaryDirectory:
@@ -789,53 +871,74 @@ class TemporaryDirectory:
             ...
 
     Upon exiting the context, the directory and everything contained
-    in it are removed.
+    in it are removed (unless delete=False is passed or an exception
+    is raised during cleanup and ignore_cleanup_errors is not True).
+
+    Optional Arguments:
+        suffix - A str suffix for the directory name.  (see mkdtemp)
+        prefix - A str prefix for the directory name.  (see mkdtemp)
+        dir - A directory to create this temp dir in.  (see mkdtemp)
+        ignore_cleanup_errors - False; ignore exceptions during cleanup?
+        delete - True; whether the directory is automatically deleted.
     """
 
     def __init__(self, suffix=None, prefix=None, dir=None,
-                 ignore_cleanup_errors=False):
+                 ignore_cleanup_errors=False, *, delete=True):
         self.name = mkdtemp(suffix, prefix, dir)
         self._ignore_cleanup_errors = ignore_cleanup_errors
+        self._delete = delete
         self._finalizer = _weakref.finalize(
             self, self._cleanup, self.name,
             warn_message="Implicitly cleaning up {!r}".format(self),
-            ignore_errors=self._ignore_cleanup_errors)
+            ignore_errors=self._ignore_cleanup_errors, delete=self._delete)
 
     @classmethod
-    def _rmtree(cls, name, ignore_errors=False):
-        def onerror(func, path, exc_info):
-            if issubclass(exc_info[0], PermissionError):
-                def resetperms(path):
-                    try:
-                        _os.chflags(path, 0)
-                    except AttributeError:
-                        pass
-                    _os.chmod(path, 0o700)
+    def _rmtree(cls, name, ignore_errors=False, repeated=False):
+        def onexc(func, path, exc):
+            if isinstance(exc, PermissionError):
+                if repeated and path == name:
+                    if ignore_errors:
+                        return
+                    raise
 
                 try:
                     if path != name:
-                        resetperms(_os.path.dirname(path))
-                    resetperms(path)
+                        _resetperms(_os.path.dirname(path))
+                    _resetperms(path)
 
                     try:
                         _os.unlink(path)
-                    # PermissionError is raised on FreeBSD for directories
-                    except (IsADirectoryError, PermissionError):
+                    except IsADirectoryError:
                         cls._rmtree(path, ignore_errors=ignore_errors)
+                    except PermissionError:
+                        # The PermissionError handler was originally added for
+                        # FreeBSD in directories, but it seems that it is raised
+                        # on Windows too.
+                        # bpo-43153: Calling _rmtree again may
+                        # raise NotADirectoryError and mask the PermissionError.
+                        # So we must re-raise the current PermissionError if
+                        # path is not a directory.
+                        if not _os.path.isdir(path) or _os.path.isjunction(path):
+                            if ignore_errors:
+                                return
+                            raise
+                        cls._rmtree(path, ignore_errors=ignore_errors,
+                                    repeated=(path == name))
                 except FileNotFoundError:
                     pass
-            elif issubclass(exc_info[0], FileNotFoundError):
+            elif isinstance(exc, FileNotFoundError):
                 pass
             else:
                 if not ignore_errors:
                     raise
 
-        _shutil.rmtree(name, onerror=onerror)
+        _shutil.rmtree(name, onexc=onexc)
 
     @classmethod
-    def _cleanup(cls, name, warn_message, ignore_errors=False):
-        cls._rmtree(name, ignore_errors=ignore_errors)
-        _warnings.warn(warn_message, ResourceWarning)
+    def _cleanup(cls, name, warn_message, ignore_errors=False, delete=True):
+        if delete:
+            cls._rmtree(name, ignore_errors=ignore_errors)
+            _warnings.warn(warn_message, ResourceWarning)
 
     def __repr__(self):
         return "<{} {!r}>".format(self.__class__.__name__, self.name)
@@ -844,7 +947,8 @@ def __enter__(self):
         return self.name
 
     def __exit__(self, exc, value, tb):
-        self.cleanup()
+        if self._delete:
+            self.cleanup()
 
     def cleanup(self):
         if self._finalizer.detach() or _os.path.exists(self.name):
diff --git a/Lib/test/__main__.py b/Lib/test/__main__.py
index 19a6b2b890..82b50ad2c6 100644
--- a/Lib/test/__main__.py
+++ b/Lib/test/__main__.py
@@ -1,2 +1,2 @@
-from test.libregrtest import main
-main()
+from test.libregrtest.main import main
+main(_add_python_opts=True)
diff --git a/Lib/test/_test_eintr.py b/Lib/test/_test_eintr.py
new file mode 100644
index 0000000000..c8f04e9625
--- /dev/null
+++ b/Lib/test/_test_eintr.py
@@ -0,0 +1,550 @@
+"""
+This test suite exercises some system calls subject to interruption with EINTR,
+to check that it is actually handled transparently.
+It is intended to be run by the main test suite within a child process, to
+ensure there is no background thread running (so that signals are delivered to
+the correct thread).
+Signals are generated in-process using setitimer(ITIMER_REAL), which allows
+sub-second periodicity (contrarily to signal()).
+"""
+
+import contextlib
+import faulthandler
+import fcntl
+import os
+import platform
+import select
+import signal
+import socket
+import subprocess
+import sys
+import textwrap
+import time
+import unittest
+
+from test import support
+from test.support import os_helper
+from test.support import socket_helper
+
+
+# gh-109592: Tolerate a difference of 20 ms when comparing timings
+# (clock resolution)
+CLOCK_RES = 0.020
+
+
+@contextlib.contextmanager
+def kill_on_error(proc):
+    """Context manager killing the subprocess if a Python exception is raised."""
+    with proc:
+        try:
+            yield proc
+        except:
+            proc.kill()
+            raise
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class EINTRBaseTest(unittest.TestCase):
+    """ Base class for EINTR tests. """
+
+    # delay for initial signal delivery
+    signal_delay = 0.1
+    # signal delivery periodicity
+    signal_period = 0.1
+    # default sleep time for tests - should obviously have:
+    # sleep_time > signal_period
+    sleep_time = 0.2
+
+    def sighandler(self, signum, frame):
+        self.signals += 1
+
+    def setUp(self):
+        self.signals = 0
+        self.orig_handler = signal.signal(signal.SIGALRM, self.sighandler)
+        signal.setitimer(signal.ITIMER_REAL, self.signal_delay,
+                         self.signal_period)
+
+        # Use faulthandler as watchdog to debug when a test hangs
+        # (timeout of 10 minutes)
+        faulthandler.dump_traceback_later(10 * 60, exit=True,
+                                          file=sys.__stderr__)
+
+    @staticmethod
+    def stop_alarm():
+        signal.setitimer(signal.ITIMER_REAL, 0, 0)
+
+    def tearDown(self):
+        self.stop_alarm()
+        signal.signal(signal.SIGALRM, self.orig_handler)
+        faulthandler.cancel_dump_traceback_later()
+
+    def subprocess(self, *args, **kw):
+        cmd_args = (sys.executable, '-c') + args
+        return subprocess.Popen(cmd_args, **kw)
+
+    def check_elapsed_time(self, elapsed):
+        self.assertGreaterEqual(elapsed, self.sleep_time - CLOCK_RES)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class OSEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the os module. """
+
+    def new_sleep_process(self):
+        code = 'import time; time.sleep(%r)' % self.sleep_time
+        return self.subprocess(code)
+
+    def _test_wait_multiple(self, wait_func):
+        num = 3
+        processes = [self.new_sleep_process() for _ in range(num)]
+        for _ in range(num):
+            wait_func()
+        # Call the Popen method to avoid a ResourceWarning
+        for proc in processes:
+            proc.wait()
+
+    def test_wait(self):
+        self._test_wait_multiple(os.wait)
+
+    @unittest.skipUnless(hasattr(os, 'wait3'), 'requires wait3()')
+    def test_wait3(self):
+        self._test_wait_multiple(lambda: os.wait3(0))
+
+    def _test_wait_single(self, wait_func):
+        proc = self.new_sleep_process()
+        wait_func(proc.pid)
+        # Call the Popen method to avoid a ResourceWarning
+        proc.wait()
+
+    def test_waitpid(self):
+        self._test_wait_single(lambda pid: os.waitpid(pid, 0))
+
+    @unittest.skipUnless(hasattr(os, 'wait4'), 'requires wait4()')
+    def test_wait4(self):
+        self._test_wait_single(lambda pid: os.wait4(pid, 0))
+
+    def test_read(self):
+        rd, wr = os.pipe()
+        self.addCleanup(os.close, rd)
+        # wr closed explicitly by parent
+
+        # the payload below are smaller than PIPE_BUF, hence the writes will be
+        # atomic
+        datas = [b"hello", b"world", b"spam"]
+
+        code = '\n'.join((
+            'import os, sys, time',
+            '',
+            'wr = int(sys.argv[1])',
+            'datas = %r' % datas,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            'for data in datas:',
+            '    # let the parent block on read()',
+            '    time.sleep(sleep_time)',
+            '    os.write(wr, data)',
+        ))
+
+        proc = self.subprocess(code, str(wr), pass_fds=[wr])
+        with kill_on_error(proc):
+            os.close(wr)
+            for data in datas:
+                self.assertEqual(data, os.read(rd, len(data)))
+            self.assertEqual(proc.wait(), 0)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
+    def test_write(self):
+        rd, wr = os.pipe()
+        self.addCleanup(os.close, wr)
+        # rd closed explicitly by parent
+
+        # we must write enough data for the write() to block
+        data = b"x" * support.PIPE_MAX_SIZE
+
+        code = '\n'.join((
+            'import io, os, sys, time',
+            '',
+            'rd = int(sys.argv[1])',
+            'sleep_time = %r' % self.sleep_time,
+            'data = b"x" * %s' % support.PIPE_MAX_SIZE,
+            'data_len = len(data)',
+            '',
+            '# let the parent block on write()',
+            'time.sleep(sleep_time)',
+            '',
+            'read_data = io.BytesIO()',
+            'while len(read_data.getvalue()) < data_len:',
+            '    chunk = os.read(rd, 2 * data_len)',
+            '    read_data.write(chunk)',
+            '',
+            'value = read_data.getvalue()',
+            'if value != data:',
+            '    raise Exception("read error: %s vs %s bytes"',
+            '                    % (len(value), data_len))',
+        ))
+
+        proc = self.subprocess(code, str(rd), pass_fds=[rd])
+        with kill_on_error(proc):
+            os.close(rd)
+            written = 0
+            while written < len(data):
+                written += os.write(wr, memoryview(data)[written:])
+            self.assertEqual(proc.wait(), 0)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class SocketEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the socket module. """
+
+    @unittest.skipUnless(hasattr(socket, 'socketpair'), 'needs socketpair()')
+    def _test_recv(self, recv_func):
+        rd, wr = socket.socketpair()
+        self.addCleanup(rd.close)
+        # wr closed explicitly by parent
+
+        # single-byte payload guard us against partial recv
+        datas = [b"x", b"y", b"z"]
+
+        code = '\n'.join((
+            'import os, socket, sys, time',
+            '',
+            'fd = int(sys.argv[1])',
+            'family = %s' % int(wr.family),
+            'sock_type = %s' % int(wr.type),
+            'datas = %r' % datas,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            'wr = socket.fromfd(fd, family, sock_type)',
+            'os.close(fd)',
+            '',
+            'with wr:',
+            '    for data in datas:',
+            '        # let the parent block on recv()',
+            '        time.sleep(sleep_time)',
+            '        wr.sendall(data)',
+        ))
+
+        fd = wr.fileno()
+        proc = self.subprocess(code, str(fd), pass_fds=[fd])
+        with kill_on_error(proc):
+            wr.close()
+            for data in datas:
+                self.assertEqual(data, recv_func(rd, len(data)))
+            self.assertEqual(proc.wait(), 0)
+
+    def test_recv(self):
+        self._test_recv(socket.socket.recv)
+
+    @unittest.skipUnless(hasattr(socket.socket, 'recvmsg'), 'needs recvmsg()')
+    def test_recvmsg(self):
+        self._test_recv(lambda sock, data: sock.recvmsg(data)[0])
+
+    def _test_send(self, send_func):
+        rd, wr = socket.socketpair()
+        self.addCleanup(wr.close)
+        # rd closed explicitly by parent
+
+        # we must send enough data for the send() to block
+        data = b"xyz" * (support.SOCK_MAX_SIZE // 3)
+
+        code = '\n'.join((
+            'import os, socket, sys, time',
+            '',
+            'fd = int(sys.argv[1])',
+            'family = %s' % int(rd.family),
+            'sock_type = %s' % int(rd.type),
+            'sleep_time = %r' % self.sleep_time,
+            'data = b"xyz" * %s' % (support.SOCK_MAX_SIZE // 3),
+            'data_len = len(data)',
+            '',
+            'rd = socket.fromfd(fd, family, sock_type)',
+            'os.close(fd)',
+            '',
+            'with rd:',
+            '    # let the parent block on send()',
+            '    time.sleep(sleep_time)',
+            '',
+            '    received_data = bytearray(data_len)',
+            '    n = 0',
+            '    while n < data_len:',
+            '        n += rd.recv_into(memoryview(received_data)[n:])',
+            '',
+            'if received_data != data:',
+            '    raise Exception("recv error: %s vs %s bytes"',
+            '                    % (len(received_data), data_len))',
+        ))
+
+        fd = rd.fileno()
+        proc = self.subprocess(code, str(fd), pass_fds=[fd])
+        with kill_on_error(proc):
+            rd.close()
+            written = 0
+            while written < len(data):
+                sent = send_func(wr, memoryview(data)[written:])
+                # sendall() returns None
+                written += len(data) if sent is None else sent
+            self.assertEqual(proc.wait(), 0)
+
+    def test_send(self):
+        self._test_send(socket.socket.send)
+
+    def test_sendall(self):
+        self._test_send(socket.socket.sendall)
+
+    @unittest.skipUnless(hasattr(socket.socket, 'sendmsg'), 'needs sendmsg()')
+    def test_sendmsg(self):
+        self._test_send(lambda sock, data: sock.sendmsg([data]))
+
+    def test_accept(self):
+        sock = socket.create_server((socket_helper.HOST, 0))
+        self.addCleanup(sock.close)
+        port = sock.getsockname()[1]
+
+        code = '\n'.join((
+            'import socket, time',
+            '',
+            'host = %r' % socket_helper.HOST,
+            'port = %s' % port,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            '# let parent block on accept()',
+            'time.sleep(sleep_time)',
+            'with socket.create_connection((host, port)):',
+            '    time.sleep(sleep_time)',
+        ))
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            client_sock, _ = sock.accept()
+            client_sock.close()
+            self.assertEqual(proc.wait(), 0)
+
+    # Issue #25122: There is a race condition in the FreeBSD kernel on
+    # handling signals in the FIFO device. Skip the test until the bug is
+    # fixed in the kernel.
+    # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=203162
+    @support.requires_freebsd_version(10, 3)
+    @unittest.skipUnless(hasattr(os, 'mkfifo'), 'needs mkfifo()')
+    def _test_open(self, do_open_close_reader, do_open_close_writer):
+        filename = os_helper.TESTFN
+
+        # Use a fifo: until the child opens it for reading, the parent will
+        # block when trying to open it for writing.
+        os_helper.unlink(filename)
+        try:
+            os.mkfifo(filename)
+        except PermissionError as e:
+            self.skipTest('os.mkfifo(): %s' % e)
+        self.addCleanup(os_helper.unlink, filename)
+
+        code = '\n'.join((
+            'import os, time',
+            '',
+            'path = %a' % filename,
+            'sleep_time = %r' % self.sleep_time,
+            '',
+            '# let the parent block',
+            'time.sleep(sleep_time)',
+            '',
+            do_open_close_reader,
+        ))
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            do_open_close_writer(filename)
+            self.assertEqual(proc.wait(), 0)
+
+    def python_open(self, path):
+        fp = open(path, 'w')
+        fp.close()
+
+    @unittest.skipIf(sys.platform == "darwin",
+                     "hangs under macOS; see bpo-25234, bpo-35363")
+    def test_open(self):
+        self._test_open("fp = open(path, 'r')\nfp.close()",
+                        self.python_open)
+
+    def os_open(self, path):
+        fd = os.open(path, os.O_WRONLY)
+        os.close(fd)
+
+    @unittest.skipIf(sys.platform == "darwin",
+                     "hangs under macOS; see bpo-25234, bpo-35363")
+    @unittest.skipIf(sys.platform.startswith('netbsd'),
+                     "hangs on NetBSD; see gh-137397")
+    def test_os_open(self):
+        self._test_open("fd = os.open(path, os.O_RDONLY)\nos.close(fd)",
+                        self.os_open)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class TimeEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the time module. """
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_sleep(self):
+        t0 = time.monotonic()
+        time.sleep(self.sleep_time)
+        self.stop_alarm()
+        dt = time.monotonic() - t0
+        self.check_elapsed_time(dt)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+# bpo-30320: Need pthread_sigmask() to block the signal, otherwise the test
+# is vulnerable to a race condition between the child and the parent processes.
+@unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
+                     'need signal.pthread_sigmask()')
+class SignalEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the signal module. """
+
+    def check_sigwait(self, wait_func):
+        signum = signal.SIGUSR1
+        pid = os.getpid()
+
+        old_handler = signal.signal(signum, lambda *args: None)
+        self.addCleanup(signal.signal, signum, old_handler)
+
+        code = '\n'.join((
+            'import os, time',
+            'pid = %s' % os.getpid(),
+            'signum = %s' % int(signum),
+            'sleep_time = %r' % self.sleep_time,
+            'time.sleep(sleep_time)',
+            'os.kill(pid, signum)',
+        ))
+
+        old_mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
+        self.addCleanup(signal.pthread_sigmask, signal.SIG_UNBLOCK, [signum])
+
+        proc = self.subprocess(code)
+        with kill_on_error(proc):
+            wait_func(signum)
+
+        self.assertEqual(proc.wait(), 0)
+
+    @unittest.skipUnless(hasattr(signal, 'sigwaitinfo'),
+                         'need signal.sigwaitinfo()')
+    def test_sigwaitinfo(self):
+        def wait_func(signum):
+            signal.sigwaitinfo([signum])
+
+        self.check_sigwait(wait_func)
+
+    @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
+                         'need signal.sigwaitinfo()')
+    def test_sigtimedwait(self):
+        def wait_func(signum):
+            signal.sigtimedwait([signum], 120.0)
+
+        self.check_sigwait(wait_func)
+
+
+@unittest.skipUnless(hasattr(signal, "setitimer"), "requires setitimer()")
+class SelectEINTRTest(EINTRBaseTest):
+    """ EINTR tests for the select module. """
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_select(self):
+        t0 = time.monotonic()
+        select.select([], [], [], self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.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')
+    def test_poll(self):
+        poller = select.poll()
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time * 1e3)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'epoll'), 'need select.epoll')
+    def test_epoll(self):
+        poller = select.epoll()
+        self.addCleanup(poller.close)
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'kqueue'), 'need select.kqueue')
+    def test_kqueue(self):
+        kqueue = select.kqueue()
+        self.addCleanup(kqueue.close)
+
+        t0 = time.monotonic()
+        kqueue.control(None, 1, self.sleep_time)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+    @unittest.skipUnless(hasattr(select, 'devpoll'), 'need select.devpoll')
+    def test_devpoll(self):
+        poller = select.devpoll()
+        self.addCleanup(poller.close)
+
+        t0 = time.monotonic()
+        poller.poll(self.sleep_time * 1e3)
+        dt = time.monotonic() - t0
+        self.stop_alarm()
+        self.check_elapsed_time(dt)
+
+
+class FCNTLEINTRTest(EINTRBaseTest):
+    def _lock(self, lock_func, lock_name):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        rd1, wr1 = os.pipe()
+        rd2, wr2 = os.pipe()
+        for fd in (rd1, wr1, rd2, wr2):
+            self.addCleanup(os.close, fd)
+        code = textwrap.dedent(f"""
+            import fcntl, os, time
+            with open('{os_helper.TESTFN}', 'wb') as f:
+                fcntl.{lock_name}(f, fcntl.LOCK_EX)
+                os.write({wr1}, b"ok")
+                _ = os.read({rd2}, 2)  # wait for parent process
+                time.sleep({self.sleep_time})
+        """)
+        proc = self.subprocess(code, pass_fds=[wr1, rd2])
+        with kill_on_error(proc):
+            with open(os_helper.TESTFN, 'wb') as f:
+                # synchronize the subprocess
+                ok = os.read(rd1, 2)
+                self.assertEqual(ok, b"ok")
+
+                # notify the child that the parent is ready
+                start_time = time.monotonic()
+                os.write(wr2, b"go")
+
+                # the child locked the file just a moment ago for 'sleep_time' seconds
+                # that means that the lock below will block for 'sleep_time' minus some
+                # potential context switch delay
+                lock_func(f, fcntl.LOCK_EX)
+                dt = time.monotonic() - start_time
+                self.stop_alarm()
+                self.check_elapsed_time(dt)
+            proc.wait()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
+    # Issue 35633: See https://bugs.python.org/issue35633#msg333662
+    # skip test rather than accept PermissionError from all platforms
+    @unittest.skipIf(platform.system() == "AIX", "AIX returns PermissionError")
+    def test_lockf(self):
+        self._lock(fcntl.lockf, "lockf")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON InterruptedError: [Errno 4] Interrupted system call
+    def test_flock(self):
+        self._lock(fcntl.flock, "flock")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/_test_multiprocessing.py b/Lib/test/_test_multiprocessing.py
index 9e688efb1e..80b663d32f 100644
--- a/Lib/test/_test_multiprocessing.py
+++ b/Lib/test/_test_multiprocessing.py
@@ -12,6 +12,7 @@
 import sys
 import os
 import gc
+import importlib
 import errno
 import functools
 import signal
@@ -19,10 +20,11 @@
 import socket
 import random
 import logging
+import shutil
 import subprocess
 import struct
+import tempfile
 import operator
-import pathlib
 import pickle
 import weakref
 import warnings
@@ -36,7 +38,7 @@
 from test.support import socket_helper
 from test.support import threading_helper
 from test.support import warnings_helper
-
+from test.support import subTests
 
 # Skip tests if _multiprocessing wasn't built.
 _multiprocessing = import_helper.import_module('_multiprocessing')
@@ -50,7 +52,7 @@
 import multiprocessing.managers
 import multiprocessing.pool
 import multiprocessing.queues
-from multiprocessing.connection import wait, AuthenticationError
+from multiprocessing.connection import wait
 
 from multiprocessing import util
 
@@ -255,6 +257,9 @@ def __call__(self, *args, **kwds):
 class BaseTestCase(object):
 
     ALLOWED_TYPES = ('processes', 'manager', 'threads')
+    # If not empty, limit which start method suites run this class.
+    START_METHODS: set[str] = set()
+    start_method = None  # set by install_tests_in_module_dict()
 
     def assertTimingAlmostEqual(self, a, b):
         if CHECK_TIMINGS:
@@ -324,8 +329,9 @@ def test_set_executable(self):
             self.skipTest(f'test not appropriate for {self.TYPE}')
         paths = [
             sys.executable,               # str
-            sys.executable.encode(),      # bytes
-            pathlib.Path(sys.executable)  # os.PathLike
+            os.fsencode(sys.executable),  # bytes
+            os_helper.FakePath(sys.executable),  # os.PathLike
+            os_helper.FakePath(os.fsencode(sys.executable)),  # os.PathLike bytes
         ]
         for path in paths:
             self.set_executable(path)
@@ -505,6 +511,11 @@ def _test_process_mainthread_native_id(cls, q):
     def _sleep_some(cls):
         time.sleep(100)
 
+    @classmethod
+    def _sleep_some_event(cls, event):
+        event.set()
+        time.sleep(100)
+
     @classmethod
     def _test_sleep(cls, delay):
         time.sleep(delay)
@@ -513,7 +524,8 @@ def _kill_process(self, meth):
         if self.TYPE == 'threads':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
 
-        p = self.Process(target=self._sleep_some)
+        event = self.Event()
+        p = self.Process(target=self._sleep_some_event, args=(event,))
         p.daemon = True
         p.start()
 
@@ -531,8 +543,11 @@ def _kill_process(self, meth):
         self.assertTimingAlmostEqual(join.elapsed, 0.0)
         self.assertEqual(p.is_alive(), True)
 
-        # XXX maybe terminating too soon causes the problems on Gentoo...
-        time.sleep(1)
+        timeout = support.SHORT_TIMEOUT
+        if not event.wait(timeout):
+            p.terminate()
+            p.join()
+            self.fail(f"event not signaled in {timeout} seconds")
 
         meth(p)
 
@@ -582,12 +597,16 @@ def test_cpu_count(self):
     def test_active_children(self):
         self.assertEqual(type(self.active_children()), list)
 
-        p = self.Process(target=time.sleep, args=(DELTA,))
+        event = self.Event()
+        p = self.Process(target=event.wait, args=())
         self.assertNotIn(p, self.active_children())
 
-        p.daemon = True
-        p.start()
-        self.assertIn(p, self.active_children())
+        try:
+            p.daemon = True
+            p.start()
+            self.assertIn(p, self.active_children())
+        finally:
+            event.set()
 
         p.join()
         self.assertNotIn(p, self.active_children())
@@ -1090,7 +1109,7 @@ def test_put(self):
     @classmethod
     def _test_get(cls, queue, child_can_start, parent_can_continue):
         child_can_start.wait()
-        #queue.put(1)
+        queue.put(1)
         queue.put(2)
         queue.put(3)
         queue.put(4)
@@ -1114,15 +1133,16 @@ def test_get(self):
         child_can_start.set()
         parent_can_continue.wait()
 
-        time.sleep(DELTA)
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if not queue_empty(queue):
+                break
         self.assertEqual(queue_empty(queue), False)
 
-        # Hangs unexpectedly, remove for now
-        #self.assertEqual(queue.get(), 1)
+        self.assertEqual(queue.get_nowait(), 1)
         self.assertEqual(queue.get(True, None), 2)
         self.assertEqual(queue.get(True), 3)
         self.assertEqual(queue.get(timeout=1), 4)
-        self.assertEqual(queue.get_nowait(), 5)
+        self.assertEqual(queue.get(), 5)
 
         self.assertEqual(queue_empty(queue), True)
 
@@ -1332,6 +1352,23 @@ def _on_queue_feeder_error(e, obj):
         self.assertTrue(not_serializable_obj.reduce_was_called)
         self.assertTrue(not_serializable_obj.on_queue_feeder_error_was_called)
 
+    def test_closed_queue_empty_exceptions(self):
+        # Assert that checking the emptiness of an unused closed queue
+        # does not raise an OSError. The rationale is that q.close() is
+        # a no-op upon construction and becomes effective once the queue
+        # has been used (e.g., by calling q.put()).
+        for q in multiprocessing.Queue(), multiprocessing.JoinableQueue():
+            q.close()  # this is a no-op since the feeder thread is None
+            q.join_thread()  # this is also a no-op
+            self.assertTrue(q.empty())
+
+        for q in multiprocessing.Queue(), multiprocessing.JoinableQueue():
+            q.put('foo')  # make sure that the queue is 'used'
+            q.close()  # close the feeder thread
+            q.join_thread()  # make sure to join the feeder thread
+            with self.assertRaisesRegex(OSError, 'is closed'):
+                q.empty()
+
     def test_closed_queue_put_get_exceptions(self):
         for q in multiprocessing.Queue(), multiprocessing.JoinableQueue():
             q.close()
@@ -1345,6 +1382,66 @@ def test_closed_queue_put_get_exceptions(self):
 
 class _TestLock(BaseTestCase):
 
+    @staticmethod
+    def _acquire(lock, l=None):
+        lock.acquire()
+        if l is not None:
+            l.append(repr(lock))
+
+    @staticmethod
+    def _acquire_event(lock, event):
+        lock.acquire()
+        event.set()
+        time.sleep(1.0)
+
+    def test_repr_lock(self):
+        if self.TYPE != 'processes':
+            self.skipTest('test not appropriate for {}'.format(self.TYPE))
+
+        lock = self.Lock()
+        self.assertEqual(f'<Lock(owner=None)>', repr(lock))
+
+        lock.acquire()
+        self.assertEqual(f'<Lock(owner=MainProcess)>', repr(lock))
+        lock.release()
+
+        tname = 'T1'
+        l = []
+        t = threading.Thread(target=self._acquire,
+                             args=(lock, l),
+                             name=tname)
+        t.start()
+        time.sleep(0.1)
+        self.assertEqual(f'<Lock(owner=MainProcess|{tname})>', l[0])
+        lock.release()
+
+        t = threading.Thread(target=self._acquire,
+                             args=(lock,),
+                             name=tname)
+        t.start()
+        time.sleep(0.1)
+        self.assertEqual('<Lock(owner=SomeOtherThread)>', repr(lock))
+        lock.release()
+
+        pname = 'P1'
+        l = multiprocessing.Manager().list()
+        p = self.Process(target=self._acquire,
+                         args=(lock, l),
+                         name=pname)
+        p.start()
+        p.join()
+        self.assertEqual(f'<Lock(owner={pname})>', l[0])
+
+        lock = self.Lock()
+        event = self.Event()
+        p = self.Process(target=self._acquire_event,
+                         args=(lock, event),
+                         name='P2')
+        p.start()
+        event.wait()
+        self.assertEqual(f'<Lock(owner=SomeOtherProcess)>', repr(lock))
+        p.terminate()
+
     def test_lock(self):
         lock = self.Lock()
         self.assertEqual(lock.acquire(), True)
@@ -1352,6 +1449,69 @@ def test_lock(self):
         self.assertEqual(lock.release(), None)
         self.assertRaises((ValueError, threading.ThreadError), lock.release)
 
+    @staticmethod
+    def _acquire_release(lock, timeout, l=None, n=1):
+        for _ in range(n):
+            lock.acquire()
+        if l is not None:
+            l.append(repr(lock))
+        time.sleep(timeout)
+        for _ in range(n):
+            lock.release()
+
+    @unittest.skipIf(sys.platform == 'darwin', "TODO: RUSTPYTHON; flaky on darwin")
+    def test_repr_rlock(self):
+        if self.TYPE != 'processes':
+            self.skipTest('test not appropriate for {}'.format(self.TYPE))
+
+        lock = self.RLock()
+        self.assertEqual('<RLock(None, 0)>', repr(lock))
+
+        n = 3
+        for _ in range(n):
+            lock.acquire()
+        self.assertEqual(f'<RLock(MainProcess, {n})>', repr(lock))
+        for _ in range(n):
+            lock.release()
+
+        t, l = [], []
+        for i in range(n):
+            t.append(threading.Thread(target=self._acquire_release,
+                                      args=(lock, 0.1, l, i+1),
+                                      name=f'T{i+1}'))
+            t[-1].start()
+        for t_ in t:
+            t_.join()
+        for i in range(n):
+            self.assertIn(f'<RLock(MainProcess|T{i+1}, {i+1})>', l)
+
+
+        t = threading.Thread(target=self._acquire_release,
+                                 args=(lock, 0.2),
+                                 name=f'T1')
+        t.start()
+        time.sleep(0.1)
+        self.assertEqual('<RLock(SomeOtherThread, nonzero)>', repr(lock))
+        time.sleep(0.2)
+
+        pname = 'P1'
+        l = multiprocessing.Manager().list()
+        p = self.Process(target=self._acquire_release,
+                         args=(lock, 0.1, l),
+                         name=pname)
+        p.start()
+        p.join()
+        self.assertEqual(f'<RLock({pname}, 1)>', l[0])
+
+        event = self.Event()
+        lock = self.RLock()
+        p = self.Process(target=self._acquire_event,
+                         args=(lock, event))
+        p.start()
+        event.wait()
+        self.assertEqual('<RLock(SomeOtherProcess, nonzero)>', repr(lock))
+        p.join()
+
     def test_rlock(self):
         lock = self.RLock()
         self.assertEqual(lock.acquire(), True)
@@ -1432,14 +1592,13 @@ def f(cls, cond, sleeping, woken, timeout=None):
         cond.release()
 
     def assertReachesEventually(self, func, value):
-        for i in range(10):
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
             try:
                 if func() == value:
                     break
             except NotImplementedError:
                 break
-            time.sleep(DELTA)
-        time.sleep(DELTA)
+
         self.assertReturnsIfImplemented(value, func)
 
     def check_invariant(self, cond):
@@ -1461,20 +1620,17 @@ def test_notify(self):
         p = self.Process(target=self.f, args=(cond, sleeping, woken))
         p.daemon = True
         p.start()
-        self.addCleanup(p.join)
 
-        p = threading.Thread(target=self.f, args=(cond, sleeping, woken))
-        p.daemon = True
-        p.start()
-        self.addCleanup(p.join)
+        t = threading.Thread(target=self.f, args=(cond, sleeping, woken))
+        t.daemon = True
+        t.start()
 
         # wait for both children to start sleeping
         sleeping.acquire()
         sleeping.acquire()
 
         # check no process/thread has woken up
-        time.sleep(DELTA)
-        self.assertReturnsIfImplemented(0, get_value, woken)
+        self.assertReachesEventually(lambda: get_value(woken), 0)
 
         # wake up one process/thread
         cond.acquire()
@@ -1482,8 +1638,7 @@ def test_notify(self):
         cond.release()
 
         # check one process/thread has woken up
-        time.sleep(DELTA)
-        self.assertReturnsIfImplemented(1, get_value, woken)
+        self.assertReachesEventually(lambda: get_value(woken), 1)
 
         # wake up another
         cond.acquire()
@@ -1491,12 +1646,13 @@ def test_notify(self):
         cond.release()
 
         # check other has woken up
-        time.sleep(DELTA)
-        self.assertReturnsIfImplemented(2, get_value, woken)
+        self.assertReachesEventually(lambda: get_value(woken), 2)
 
         # check state is not mucked up
         self.check_invariant(cond)
-        p.join()
+
+        threading_helper.join_thread(t)
+        join_process(p)
 
     def test_notify_all(self):
         cond = self.Condition()
@@ -1504,18 +1660,19 @@ def test_notify_all(self):
         woken = self.Semaphore(0)
 
         # start some threads/processes which will timeout
+        workers = []
         for i in range(3):
             p = self.Process(target=self.f,
                              args=(cond, sleeping, woken, TIMEOUT1))
             p.daemon = True
             p.start()
-            self.addCleanup(p.join)
+            workers.append(p)
 
             t = threading.Thread(target=self.f,
                                  args=(cond, sleeping, woken, TIMEOUT1))
             t.daemon = True
             t.start()
-            self.addCleanup(t.join)
+            workers.append(t)
 
         # wait for them all to sleep
         for i in range(6):
@@ -1534,12 +1691,12 @@ def test_notify_all(self):
             p = self.Process(target=self.f, args=(cond, sleeping, woken))
             p.daemon = True
             p.start()
-            self.addCleanup(p.join)
+            workers.append(p)
 
             t = threading.Thread(target=self.f, args=(cond, sleeping, woken))
             t.daemon = True
             t.start()
-            self.addCleanup(t.join)
+            workers.append(t)
 
         # wait for them to all sleep
         for i in range(6):
@@ -1555,27 +1712,34 @@ def test_notify_all(self):
         cond.release()
 
         # check they have all woken
-        self.assertReachesEventually(lambda: get_value(woken), 6)
+        for i in range(6):
+            woken.acquire()
+        self.assertReturnsIfImplemented(0, get_value, woken)
 
         # check state is not mucked up
         self.check_invariant(cond)
 
+        for w in workers:
+            # NOTE: join_process and join_thread are the same
+            threading_helper.join_thread(w)
+
     def test_notify_n(self):
         cond = self.Condition()
         sleeping = self.Semaphore(0)
         woken = self.Semaphore(0)
 
         # start some threads/processes
+        workers = []
         for i in range(3):
             p = self.Process(target=self.f, args=(cond, sleeping, woken))
             p.daemon = True
             p.start()
-            self.addCleanup(p.join)
+            workers.append(p)
 
             t = threading.Thread(target=self.f, args=(cond, sleeping, woken))
             t.daemon = True
             t.start()
-            self.addCleanup(t.join)
+            workers.append(t)
 
         # wait for them to all sleep
         for i in range(6):
@@ -1610,6 +1774,10 @@ def test_notify_n(self):
         # check state is not mucked up
         self.check_invariant(cond)
 
+        for w in workers:
+            # NOTE: join_process and join_thread are the same
+            threading_helper.join_thread(w)
+
     def test_timeout(self):
         cond = self.Condition()
         wait = TimingWrapper(cond.wait)
@@ -2804,6 +2972,8 @@ def test_map_no_failfast(self):
         # check that we indeed waited for all jobs
         self.assertGreater(time.monotonic() - t_start, 0.9)
 
+    # TODO: RUSTPYTHON - reference counting differences
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_release_task_refs(self):
         # Issue #29861: task arguments and results should not be kept
         # alive after we are done with them.
@@ -2812,8 +2982,8 @@ def test_release_task_refs(self):
         self.pool.map(identity, objs)
 
         del objs
-        gc.collect()  # For PyPy or other GCs.
         time.sleep(DELTA)  # let threaded cleanup code run
+        support.gc_collect()  # For PyPy or other GCs.
         self.assertEqual(set(wr() for wr in refs), {None})
         # With a process pool, copies of the objects are returned, check
         # they were released too.
@@ -3174,6 +3344,44 @@ def test_rapid_restart(self):
             if hasattr(manager, "shutdown"):
                 self.addCleanup(manager.shutdown)
 
+
+class FakeConnection:
+    def send(self, payload):
+        pass
+
+    def recv(self):
+        return '#ERROR', pyqueue.Empty()
+
+class TestManagerExceptions(unittest.TestCase):
+    # Issue 106558: Manager exceptions avoids creating cyclic references.
+    def setUp(self):
+        self.mgr = multiprocessing.Manager()
+
+    def tearDown(self):
+        self.mgr.shutdown()
+        self.mgr.join()
+
+    def test_queue_get(self):
+        queue = self.mgr.Queue()
+        if gc.isenabled():
+            gc.disable()
+            self.addCleanup(gc.enable)
+        try:
+            queue.get_nowait()
+        except pyqueue.Empty as e:
+            wr = weakref.ref(e)
+        self.assertEqual(wr(), None)
+
+    def test_dispatch(self):
+        if gc.isenabled():
+            gc.disable()
+            self.addCleanup(gc.enable)
+        try:
+            multiprocessing.managers.dispatch(FakeConnection(), None, None)
+        except pyqueue.Empty as e:
+            wr = weakref.ref(e)
+        self.assertEqual(wr(), None)
+
 #
 #
 #
@@ -3678,6 +3886,8 @@ def _remote(cls, conn):
 
         conn.close()
 
+    # TODO: RUSTPYTHON - hangs
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_pickling(self):
         families = self.connection.families
 
@@ -3847,6 +4057,8 @@ def test_heap(self):
         self.assertEqual(len(heap._allocated_blocks), 0, heap._allocated_blocks)
         self.assertEqual(len(heap._len_to_seq), 0)
 
+    # TODO: RUSTPYTHON - gc.enable() not implemented
+    @unittest.expectedFailure
     def test_free_from_gc(self):
         # Check that freeing of blocks by the garbage collector doesn't deadlock
         # (issue #12352).
@@ -3899,6 +4111,8 @@ def _double(cls, x, y, z, foo, arr, string):
         for i in range(len(arr)):
             arr[i] *= 2
 
+    # TODO: RUSTPYTHON - ctypes Structure shared memory not working
+    @unittest.expectedFailure
     def test_sharedctypes(self, lock=False):
         x = Value('i', 7, lock=lock)
         y = Value(c_double, 1.0/3.0, lock=lock)
@@ -3922,6 +4136,8 @@ def test_sharedctypes(self, lock=False):
             self.assertAlmostEqual(arr[i], i*2)
         self.assertEqual(string.value, latin('hellohello'))
 
+    # TODO: RUSTPYTHON - calls test_sharedctypes which fails
+    @unittest.expectedFailure
     def test_synchronize(self):
         self.test_sharedctypes(lock=True)
 
@@ -3936,6 +4152,19 @@ def test_copy(self):
         self.assertEqual(bar.z, 2 ** 33)
 
 
+def resource_tracker_format_subtests(func):
+    """Run given test using both resource tracker communication formats"""
+    def _inner(self, *args, **kwargs):
+        tracker = resource_tracker._resource_tracker
+        for use_simple_format in False, True:
+            with (
+                self.subTest(use_simple_format=use_simple_format),
+                unittest.mock.patch.object(
+                    tracker, '_use_simple_format', use_simple_format)
+            ):
+                func(self, *args, **kwargs)
+    return _inner
+
 @unittest.skipUnless(HAS_SHMEM, "requires multiprocessing.shared_memory")
 @hashlib_helper.requires_hashdigest('sha256')
 class _TestSharedMemory(BaseTestCase):
@@ -4213,6 +4442,7 @@ def test_shared_memory_SharedMemoryServer_ignores_sigint(self):
         smm.shutdown()
 
     @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
     def test_shared_memory_SharedMemoryManager_reuses_resource_tracker(self):
         # bpo-36867: test that a SharedMemoryManager uses the
         # same resource_tracker process as its parent.
@@ -4462,6 +4692,61 @@ def test_shared_memory_cleaned_after_process_termination(self):
                     "resource_tracker: There appear to be 1 leaked "
                     "shared_memory objects to clean up at shutdown", err)
 
+    @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
+    def test_shared_memory_untracking(self):
+        # gh-82300: When a separate Python process accesses shared memory
+        # with track=False, it must not cause the memory to be deleted
+        # when terminating.
+        cmd = '''if 1:
+            import sys
+            from multiprocessing.shared_memory import SharedMemory
+            mem = SharedMemory(create=False, name=sys.argv[1], track=False)
+            mem.close()
+        '''
+        mem = shared_memory.SharedMemory(create=True, size=10)
+        # The resource tracker shares pipes with the subprocess, and so
+        # err existing means that the tracker process has terminated now.
+        try:
+            rc, out, err = script_helper.assert_python_ok("-c", cmd, mem.name)
+            self.assertNotIn(b"resource_tracker", err)
+            self.assertEqual(rc, 0)
+            mem2 = shared_memory.SharedMemory(create=False, name=mem.name)
+            mem2.close()
+        finally:
+            try:
+                mem.unlink()
+            except OSError:
+                pass
+            mem.close()
+
+    @unittest.skipIf(os.name != "posix", "resource_tracker is posix only")
+    @resource_tracker_format_subtests
+    def test_shared_memory_tracking(self):
+        # gh-82300: When a separate Python process accesses shared memory
+        # with track=True, it must cause the memory to be deleted when
+        # terminating.
+        cmd = '''if 1:
+            import sys
+            from multiprocessing.shared_memory import SharedMemory
+            mem = SharedMemory(create=False, name=sys.argv[1], track=True)
+            mem.close()
+        '''
+        mem = shared_memory.SharedMemory(create=True, size=10)
+        try:
+            rc, out, err = script_helper.assert_python_ok("-c", cmd, mem.name)
+            self.assertEqual(rc, 0)
+            self.assertIn(
+                b"resource_tracker: There appear to be 1 leaked "
+                b"shared_memory objects to clean up at shutdown", err)
+        finally:
+            try:
+                mem.unlink()
+            except OSError:
+                pass
+            resource_tracker.unregister(mem._name, "shared_memory")
+            mem.close()
+
 #
 # Test to verify that `Finalize` works.
 #
@@ -4530,6 +4815,8 @@ def test_finalize(self):
         result = [obj for obj in iter(conn.recv, 'STOP')]
         self.assertEqual(result, ['a', 'b', 'd10', 'd03', 'd02', 'd01', 'e'])
 
+    # TODO: RUSTPYTHON - gc.get_threshold() and gc.set_threshold() not implemented
+    @unittest.expectedFailure
     @support.requires_resource('cpu')
     def test_thread_safety(self):
         # bpo-24484: _run_finalizers() should be thread-safe
@@ -4571,7 +4858,7 @@ def make_finalizers():
         old_interval = sys.getswitchinterval()
         old_threshold = gc.get_threshold()
         try:
-            sys.setswitchinterval(1e-6)
+            support.setswitchinterval(1e-6)
             gc.set_threshold(5, 5, 5)
             threads = [threading.Thread(target=run_finalizers),
                        threading.Thread(target=make_finalizers)]
@@ -5157,6 +5444,8 @@ def run_in_child(cls, start_method):
         flags = (tuple(sys.flags), grandchild_flags)
         print(json.dumps(flags))
 
+    # TODO: RUSTPYTHON - SyntaxError in subprocess after fork
+    @unittest.expectedFailure
     def test_flags(self):
         import json
         # start child process using unusual flags
@@ -5557,8 +5846,9 @@ def create_and_register_resource(rtype):
         '''
         for rtype in resource_tracker._CLEANUP_FUNCS:
             with self.subTest(rtype=rtype):
-                if rtype == "noop":
+                if rtype in ("noop", "dummy"):
                     # Artefact resource type used by the resource_tracker
+                    # or tests
                     continue
                 r, w = os.pipe()
                 p = subprocess.Popen([sys.executable,
@@ -5638,6 +5928,8 @@ def test_resource_tracker_sigterm(self):
         # Catchable signal (ignored by semaphore tracker)
         self.check_resource_tracker_death(signal.SIGTERM, False)
 
+    @unittest.skipIf(sys.platform.startswith("netbsd"),
+                     "gh-125620: Skip on NetBSD due to long wait for SIGKILL process termination.")
     def test_resource_tracker_sigkill(self):
         # Uncatchable signal.
         self.check_resource_tracker_death(signal.SIGKILL, True)
@@ -5678,6 +5970,59 @@ def test_too_long_name_resource(self):
         with self.assertRaises(ValueError):
             resource_tracker.register(too_long_name_resource, rtype)
 
+    def _test_resource_tracker_leak_resources(self, cleanup):
+        # We use a separate instance for testing, since the main global
+        # _resource_tracker may be used to watch test infrastructure.
+        from multiprocessing.resource_tracker import ResourceTracker
+        tracker = ResourceTracker()
+        tracker.ensure_running()
+        self.assertTrue(tracker._check_alive())
+
+        self.assertIsNone(tracker._exitcode)
+        tracker.register('somename', 'dummy')
+        if cleanup:
+            tracker.unregister('somename', 'dummy')
+            expected_exit_code = 0
+        else:
+            expected_exit_code = 1
+
+        self.assertTrue(tracker._check_alive())
+        self.assertIsNone(tracker._exitcode)
+        tracker._stop()
+        self.assertEqual(tracker._exitcode, expected_exit_code)
+
+    def test_resource_tracker_exit_code(self):
+        """
+        Test the exit code of the resource tracker.
+
+        If no leaked resources were found, exit code should be 0, otherwise 1
+        """
+        for cleanup in [True, False]:
+            with self.subTest(cleanup=cleanup):
+                self._test_resource_tracker_leak_resources(
+                    cleanup=cleanup,
+                )
+
+    @unittest.skipUnless(hasattr(signal, "pthread_sigmask"), "pthread_sigmask is not available")
+    def test_resource_tracker_blocked_signals(self):
+        #
+        # gh-127586: Check that resource_tracker does not override blocked signals of caller.
+        #
+        from multiprocessing.resource_tracker import ResourceTracker
+        orig_sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, set())
+        signals = {signal.SIGTERM, signal.SIGINT, signal.SIGUSR1}
+
+        try:
+            for sig in signals:
+                signal.pthread_sigmask(signal.SIG_SETMASK, {sig})
+                self.assertEqual(signal.pthread_sigmask(signal.SIG_BLOCK, set()), {sig})
+                tracker = ResourceTracker()
+                tracker.ensure_running()
+                self.assertEqual(signal.pthread_sigmask(signal.SIG_BLOCK, set()), {sig})
+                tracker._stop()
+        finally:
+            # restore sigmask to what it was before executing test
+            signal.pthread_sigmask(signal.SIG_SETMASK, orig_sigmask)
 
 class TestSimpleQueue(unittest.TestCase):
 
@@ -5691,6 +6036,15 @@ def _test_empty(cls, queue, child_can_start, parent_can_continue):
         finally:
             parent_can_continue.set()
 
+    def test_empty_exceptions(self):
+        # Assert that checking emptiness of a closed queue raises
+        # an OSError, independently of whether the queue was used
+        # or not. This differs from Queue and JoinableQueue.
+        q = multiprocessing.SimpleQueue()
+        q.close()  # close the pipe
+        with self.assertRaisesRegex(OSError, 'is closed'):
+            q.empty()
+
     def test_empty(self):
         queue = multiprocessing.SimpleQueue()
         child_can_start = multiprocessing.Event()
@@ -6037,6 +6391,113 @@ def submain(): pass
         self.assertFalse(err, msg=err.decode('utf-8'))
 
 
+class _TestAtExit(BaseTestCase):
+
+    ALLOWED_TYPES = ('processes',)
+
+    @classmethod
+    def _write_file_at_exit(self, output_path):
+        import atexit
+        def exit_handler():
+            with open(output_path, 'w') as f:
+                f.write("deadbeef")
+        atexit.register(exit_handler)
+
+    def test_atexit(self):
+        # gh-83856
+        with os_helper.temp_dir() as temp_dir:
+            output_path = os.path.join(temp_dir, 'output.txt')
+            p = self.Process(target=self._write_file_at_exit, args=(output_path,))
+            p.start()
+            p.join()
+            with open(output_path) as f:
+                self.assertEqual(f.read(), 'deadbeef')
+
+
+class _TestSpawnedSysPath(BaseTestCase):
+    """Test that sys.path is setup in forkserver and spawn processes."""
+
+    ALLOWED_TYPES = {'processes'}
+    # Not applicable to fork which inherits everything from the process as is.
+    START_METHODS = {"forkserver", "spawn"}
+
+    def setUp(self):
+        self._orig_sys_path = list(sys.path)
+        self._temp_dir = tempfile.mkdtemp(prefix="test_sys_path-")
+        self._mod_name = "unique_test_mod"
+        module_path = os.path.join(self._temp_dir, f"{self._mod_name}.py")
+        with open(module_path, "w", encoding="utf-8") as mod:
+            mod.write("# A simple test module\n")
+        sys.path[:] = [p for p in sys.path if p]  # remove any existing ""s
+        sys.path.insert(0, self._temp_dir)
+        sys.path.insert(0, "")  # Replaced with an abspath in child.
+        self.assertIn(self.start_method, self.START_METHODS)
+        self._ctx = multiprocessing.get_context(self.start_method)
+
+    def tearDown(self):
+        sys.path[:] = self._orig_sys_path
+        shutil.rmtree(self._temp_dir, ignore_errors=True)
+
+    @staticmethod
+    def enq_imported_module_names(queue):
+        queue.put(tuple(sys.modules))
+
+    def test_forkserver_preload_imports_sys_path(self):
+        if self._ctx.get_start_method() != "forkserver":
+            self.skipTest("forkserver specific test.")
+        self.assertNotIn(self._mod_name, sys.modules)
+        multiprocessing.forkserver._forkserver._stop()  # Must be fresh.
+        self._ctx.set_forkserver_preload(
+            ["test.test_multiprocessing_forkserver", self._mod_name])
+        q = self._ctx.Queue()
+        proc = self._ctx.Process(
+                target=self.enq_imported_module_names, args=(q,))
+        proc.start()
+        proc.join()
+        child_imported_modules = q.get()
+        q.close()
+        self.assertIn(self._mod_name, child_imported_modules)
+
+    @staticmethod
+    def enq_sys_path_and_import(queue, mod_name):
+        queue.put(sys.path)
+        try:
+            importlib.import_module(mod_name)
+        except ImportError as exc:
+            queue.put(exc)
+        else:
+            queue.put(None)
+
+    def test_child_sys_path(self):
+        q = self._ctx.Queue()
+        proc = self._ctx.Process(
+                target=self.enq_sys_path_and_import, args=(q, self._mod_name))
+        proc.start()
+        proc.join()
+        child_sys_path = q.get()
+        import_error = q.get()
+        q.close()
+        self.assertNotIn("", child_sys_path)  # replaced by an abspath
+        self.assertIn(self._temp_dir, child_sys_path)  # our addition
+        # ignore the first element, it is the absolute "" replacement
+        self.assertEqual(child_sys_path[1:], sys.path[1:])
+        self.assertIsNone(import_error, msg=f"child could not import {self._mod_name}")
+
+    def test_std_streams_flushed_after_preload(self):
+        # gh-135335: Check fork server flushes standard streams after
+        # preloading modules
+        if multiprocessing.get_start_method() != "forkserver":
+            self.skipTest("forkserver specific test")
+
+        name = os.path.join(os.path.dirname(__file__), 'mp_preload_flush.py')
+        _, out, err = test.support.script_helper.assert_python_ok(name)
+
+        # Check stderr first, as it is more likely to be useful to see in the
+        # event of a failure.
+        self.assertEqual(err.decode().rstrip(), '__main____mp_main__')
+        self.assertEqual(out.decode().rstrip(), '__main____mp_main__')
+
+
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         # Just make sure names in not_exported are excluded
@@ -6061,6 +6522,58 @@ def test_spawn_sys_executable_none_allows_import(self):
         self.assertEqual(rc, 0)
         self.assertFalse(err, msg=err.decode('utf-8'))
 
+    def test_large_pool(self):
+        #
+        # gh-89240: Check that large pools are always okay
+        #
+        testfn = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, testfn)
+        with open(testfn, 'w', encoding='utf-8') as f:
+            f.write(textwrap.dedent('''\
+                import multiprocessing
+                def f(x): return x*x
+                if __name__ == '__main__':
+                    with multiprocessing.Pool(200) as p:
+                        print(sum(p.map(f, range(1000))))
+            '''))
+        rc, out, err = script_helper.assert_python_ok(testfn)
+        self.assertEqual("332833500", out.decode('utf-8').strip())
+        self.assertFalse(err, msg=err.decode('utf-8'))
+
+    def test_forked_thread_not_started(self):
+        # gh-134381: Ensure that a thread that has not been started yet in
+        # the parent process can be started within a forked child process.
+
+        if multiprocessing.get_start_method() != "fork":
+            self.skipTest("fork specific test")
+
+        q = multiprocessing.Queue()
+        t = threading.Thread(target=lambda: q.put("done"), daemon=True)
+
+        def child():
+            t.start()
+            t.join()
+
+        p = multiprocessing.Process(target=child)
+        p.start()
+        p.join(support.SHORT_TIMEOUT)
+
+        self.assertEqual(p.exitcode, 0)
+        self.assertEqual(q.get_nowait(), "done")
+        close_queue(q)
+
+    def test_preload_main(self):
+        # gh-126631: Check that __main__ can be pre-loaded
+        if multiprocessing.get_start_method() != "forkserver":
+            self.skipTest("forkserver specific test")
+
+        name = os.path.join(os.path.dirname(__file__), 'mp_preload_main.py')
+        _, out, err = test.support.script_helper.assert_python_ok(name)
+        self.assertEqual(err, b'')
+
+        # The trailing empty string comes from split() on output ending with \n
+        out = out.decode().split("\n")
+        self.assertEqual(out, ['__main__', '__mp_main__', 'f', 'f', ''])
 
 #
 # Mixins
@@ -6084,7 +6597,8 @@ def tearDownClass(cls):
             support.print_warning(f'Dangling processes: {processes}')
         processes = None
 
-        threads = set(threading._dangling) - set(cls.dangling[1])
+        # TODO: RUSTPYTHON: Filter out stopped threads since gc.collect() is a no-op
+        threads = {t for t in threading._dangling if t.is_alive()} - {t for t in cls.dangling[1] if t.is_alive()}
         if threads:
             test.support.environment_altered = True
             support.print_warning(f'Dangling threads: {threads}')
@@ -6213,6 +6727,8 @@ def install_tests_in_module_dict(remote_globs, start_method,
             if base is BaseTestCase:
                 continue
             assert set(base.ALLOWED_TYPES) <= ALL_TYPES, base.ALLOWED_TYPES
+            if base.START_METHODS and start_method not in base.START_METHODS:
+                continue  # class not intended for this start method.
             for type_ in base.ALLOWED_TYPES:
                 if only_type and type_ != only_type:
                     continue
@@ -6226,6 +6742,7 @@ class Temp(base, Mixin, unittest.TestCase):
                     Temp = hashlib_helper.requires_hashdigest('sha256')(Temp)
                 Temp.__name__ = Temp.__qualname__ = newname
                 Temp.__module__ = __module__
+                Temp.start_method = start_method
                 remote_globs[newname] = Temp
         elif issubclass(base, unittest.TestCase):
             if only_type:
@@ -6278,7 +6795,8 @@ def tearDownModule():
             support.print_warning(f'Dangling processes: {processes}')
         processes = None
 
-        threads = set(threading._dangling) - set(dangling[1])
+        # TODO: RUSTPYTHON: Filter out stopped threads since gc.collect() is a no-op
+        threads = {t for t in threading._dangling if t.is_alive()} - {t for t in dangling[1] if t.is_alive()}
         if threads:
             need_sleep = True
             test.support.environment_altered = True
@@ -6305,3 +6823,52 @@ class SemLock(_multiprocessing.SemLock):
         name = f'test_semlock_subclass-{os.getpid()}'
         s = SemLock(1, 0, 10, name, False)
         _multiprocessing.sem_unlink(name)
+
+
+@unittest.skipUnless(HAS_SHMEM, "requires multiprocessing.shared_memory")
+class TestSharedMemoryNames(unittest.TestCase):
+    @subTests('use_simple_format', (True, False))
+    def test_that_shared_memory_name_with_colons_has_no_resource_tracker_errors(
+            self, use_simple_format):
+        # Test script that creates and cleans up shared memory with colon in name
+        test_script = textwrap.dedent("""
+            import sys
+            from multiprocessing import shared_memory
+            from multiprocessing import resource_tracker
+            import time
+
+            resource_tracker._resource_tracker._use_simple_format = %s
+
+            # Test various patterns of colons in names
+            test_names = [
+                "a:b",
+                "a:b:c",
+                "test:name:with:many:colons",
+                ":starts:with:colon",
+                "ends:with:colon:",
+                "::double::colons::",
+                "name\\nwithnewline",
+                "name-with-trailing-newline\\n",
+                "\\nname-starts-with-newline",
+                "colons:and\\nnewlines:mix",
+                "multi\\nline\\nname",
+            ]
+
+            for name in test_names:
+                try:
+                    shm = shared_memory.SharedMemory(create=True, size=100, name=name)
+                    shm.buf[:5] = b'hello'  # Write something to the shared memory
+                    shm.close()
+                    shm.unlink()
+
+                except Exception as e:
+                    print(f"Error with name '{name}': {e}", file=sys.stderr)
+                    sys.exit(1)
+
+            print("SUCCESS")
+        """ % use_simple_format)
+
+        rc, out, err = script_helper.assert_python_ok("-c", test_script)
+        self.assertIn(b"SUCCESS", out)
+        self.assertNotIn(b"traceback", err.lower(), err)
+        self.assertNotIn(b"resource_tracker.py", err, err)
diff --git a/Lib/test/_test_venv_multiprocessing.py b/Lib/test/_test_venv_multiprocessing.py
new file mode 100644
index 0000000000..ad985dd8d5
--- /dev/null
+++ b/Lib/test/_test_venv_multiprocessing.py
@@ -0,0 +1,40 @@
+import multiprocessing
+import random
+import sys
+
+def fill_queue(queue, code):
+    queue.put(code)
+
+
+def drain_queue(queue, code):
+    if code != queue.get():
+        sys.exit(1)
+
+
+def test_func():
+    code = random.randrange(0, 1000)
+    queue = multiprocessing.Queue()
+    fill_pool = multiprocessing.Process(
+        target=fill_queue,
+        args=(queue, code)
+    )
+    drain_pool = multiprocessing.Process(
+        target=drain_queue,
+        args=(queue, code)
+    )
+    drain_pool.start()
+    fill_pool.start()
+    fill_pool.join()
+    drain_pool.join()
+
+
+def main():
+    multiprocessing.set_start_method('spawn')
+    test_pool = multiprocessing.Process(target=test_func)
+    test_pool.start()
+    test_pool.join()
+    sys.exit(test_pool.exitcode)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/test/archiver_tests.py b/Lib/test/archiver_tests.py
new file mode 100644
index 0000000000..24745941b0
--- /dev/null
+++ b/Lib/test/archiver_tests.py
@@ -0,0 +1,177 @@
+"""Tests common to tarfile and zipfile."""
+
+import os
+import sys
+
+from test.support import swap_attr
+from test.support import os_helper
+
+class OverwriteTests:
+
+    def setUp(self):
+        os.makedirs(self.testdir)
+        self.addCleanup(os_helper.rmtree, self.testdir)
+
+    def create_file(self, path, content=b''):
+        with open(path, 'wb') as f:
+            f.write(content)
+
+    def open(self, path):
+        raise NotImplementedError
+
+    def extractall(self, ar):
+        raise NotImplementedError
+
+
+    def test_overwrite_file_as_file(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    def test_overwrite_dir_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_overwrite_dir_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+        self.assertTrue(os.path.isfile(os.path.join(target, 'file')))
+        with open(os.path.join(target, 'file'), 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    def test_overwrite_dir_as_file(self):
+        target = os.path.join(self.testdir, 'test')
+        os.mkdir(target)
+        with self.open(self.ar_with_file) as ar:
+            with self.assertRaises(PermissionError if sys.platform == 'win32'
+                                   else IsADirectoryError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_overwrite_file_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'content')
+
+    def test_overwrite_file_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        self.create_file(target, b'content')
+        with self.open(self.ar_with_implicit_dir) as ar:
+            with self.assertRaises(FileNotFoundError if sys.platform == 'win32'
+                                   else NotADirectoryError):
+                self.extractall(ar)
+        self.assertTrue(os.path.isfile(target))
+        with open(target, 'rb') as f:
+            self.assertEqual(f.read(), b'content')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_file_symlink_as_file(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        self.create_file(target2, b'content')
+        os.symlink('test2', target)
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isfile(target2))
+        with open(target2, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_file_symlink_as_file(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target)
+        with self.open(self.ar_with_file) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isfile(target2))
+        with open(target2, 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_dir_symlink_as_dir(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.mkdir(target2)
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isdir(target2))
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_dir_symlink_as_implicit_dir(self):
+        # XXX: It is potential security vulnerability.
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.mkdir(target2)
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertTrue(os.path.isdir(target2))
+        self.assertTrue(os.path.isfile(os.path.join(target2, 'file')))
+        with open(os.path.join(target2, 'file'), 'rb') as f:
+            self.assertEqual(f.read(), b'newcontent')
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_dir_symlink_as_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertFalse(os.path.exists(target2))
+
+    @os_helper.skip_unless_symlink
+    def test_overwrite_broken_dir_symlink_as_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        target2 = os.path.join(self.testdir, 'test2')
+        os.symlink('test2', target, target_is_directory=True)
+        with self.open(self.ar_with_implicit_dir) as ar:
+            with self.assertRaises(FileExistsError):
+                self.extractall(ar)
+        self.assertTrue(os.path.islink(target))
+        self.assertFalse(os.path.exists(target2))
+
+    def test_concurrent_extract_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        def concurrent_mkdir(*args, **kwargs):
+            orig_mkdir(*args, **kwargs)
+            orig_mkdir(*args, **kwargs)
+        with swap_attr(os, 'mkdir', concurrent_mkdir) as orig_mkdir:
+            with self.open(self.ar_with_dir) as ar:
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+
+    def test_concurrent_extract_implicit_dir(self):
+        target = os.path.join(self.testdir, 'test')
+        def concurrent_mkdir(*args, **kwargs):
+            orig_mkdir(*args, **kwargs)
+            orig_mkdir(*args, **kwargs)
+        with swap_attr(os, 'mkdir', concurrent_mkdir) as orig_mkdir:
+            with self.open(self.ar_with_implicit_dir) as ar:
+                self.extractall(ar)
+        self.assertTrue(os.path.isdir(target))
+        self.assertTrue(os.path.isfile(os.path.join(target, 'file')))
diff --git a/Lib/test/archivetestdata/README.md b/Lib/test/archivetestdata/README.md
new file mode 100644
index 0000000000..7b555fa327
--- /dev/null
+++ b/Lib/test/archivetestdata/README.md
@@ -0,0 +1,36 @@
+# Test data for `test_zipfile`, `test_tarfile` (and even some others)
+
+## `test_zipfile`
+
+The test executables in this directory are created manually from `header.sh` and
+the `testdata_module_inside_zip.py` file.  You must have Info-ZIP's zip utility
+installed (`apt install zip` on Debian).
+
+### Purpose of `exe_with_zip` and `exe_with_z64`
+
+These are used to test executable files with an appended zipfile, in a scenario
+where the executable is _not_ a Python interpreter itself so our automatic
+zipimport machinery (that'd look for `__main__.py`) is not being used.
+
+### Updating the test executables
+
+If you update header.sh or the testdata_module_inside_zip.py file, rerun the
+commands below.  These are expected to be rarely changed, if ever.
+
+#### Standard old format (2.0) zip file
+
+```
+zip -0 zip2.zip testdata_module_inside_zip.py
+cat header.sh zip2.zip >exe_with_zip
+rm zip2.zip
+```
+
+#### Modern format (4.5) zip64 file
+
+Redirecting from stdin forces Info-ZIP's zip tool to create a zip64.
+
+```
+zip -0 <testdata_module_inside_zip.py >zip64.zip
+cat header.sh zip64.zip >exe_with_z64
+rm zip64.zip
+```
diff --git a/Lib/test/archivetestdata/exe_with_z64 b/Lib/test/archivetestdata/exe_with_z64
new file mode 100755
index 0000000000..82b03cf39d
Binary files /dev/null and b/Lib/test/archivetestdata/exe_with_z64 differ
diff --git a/Lib/test/archivetestdata/exe_with_zip b/Lib/test/archivetestdata/exe_with_zip
new file mode 100755
index 0000000000..c833cdf9f9
Binary files /dev/null and b/Lib/test/archivetestdata/exe_with_zip differ
diff --git a/Lib/test/archivetestdata/header.sh b/Lib/test/archivetestdata/header.sh
new file mode 100755
index 0000000000..52dc91acf7
--- /dev/null
+++ b/Lib/test/archivetestdata/header.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+INTERPRETER_UNDER_TEST="$1"
+if [[ ! -x "${INTERPRETER_UNDER_TEST}" ]]; then
+    echo "Interpreter must be the command line argument."
+    exit 4
+fi
+EXECUTABLE="$0" exec "${INTERPRETER_UNDER_TEST}" -E - <<END_OF_PYTHON
+import os
+import zipfile
+
+namespace = {}
+
+filename = os.environ['EXECUTABLE']
+print(f'Opening {filename} as a zipfile.')
+with zipfile.ZipFile(filename, mode='r') as exe_zip:
+  for file_info in exe_zip.infolist():
+    data = exe_zip.read(file_info)
+    exec(data, namespace, namespace)
+    break  # Only use the first file in the archive.
+
+print('Favorite number in executable:', namespace["FAVORITE_NUMBER"])
+
+### Archive contents will be appended after this file. ###
+END_OF_PYTHON
diff --git a/Lib/test/archivetestdata/recursion.tar b/Lib/test/archivetestdata/recursion.tar
new file mode 100644
index 0000000000..b823725196
Binary files /dev/null and b/Lib/test/archivetestdata/recursion.tar differ
diff --git a/Lib/test/archivetestdata/testdata_module_inside_zip.py b/Lib/test/archivetestdata/testdata_module_inside_zip.py
new file mode 100644
index 0000000000..6f8dcd6c0e
--- /dev/null
+++ b/Lib/test/archivetestdata/testdata_module_inside_zip.py
@@ -0,0 +1,2 @@
+# Test data file to be stored within a zip file.
+FAVORITE_NUMBER = 5
diff --git a/Lib/test/archivetestdata/testtar.tar b/Lib/test/archivetestdata/testtar.tar
new file mode 100644
index 0000000000..bb9345373e
Binary files /dev/null and b/Lib/test/archivetestdata/testtar.tar differ
diff --git a/Lib/test/archivetestdata/testtar.tar.xz b/Lib/test/archivetestdata/testtar.tar.xz
new file mode 100644
index 0000000000..512fa149e6
Binary files /dev/null and b/Lib/test/archivetestdata/testtar.tar.xz differ
diff --git a/Lib/test/archivetestdata/zip_cp437_header.zip b/Lib/test/archivetestdata/zip_cp437_header.zip
new file mode 100644
index 0000000000..f7c6cf1704
Binary files /dev/null and b/Lib/test/archivetestdata/zip_cp437_header.zip differ
diff --git a/Lib/test/archivetestdata/zipdir.zip b/Lib/test/archivetestdata/zipdir.zip
new file mode 100644
index 0000000000..ac21d7a1ed
Binary files /dev/null and b/Lib/test/archivetestdata/zipdir.zip differ
diff --git a/Lib/test/archivetestdata/zipdir_backslash.zip b/Lib/test/archivetestdata/zipdir_backslash.zip
new file mode 100644
index 0000000000..979126ef5e
Binary files /dev/null and b/Lib/test/archivetestdata/zipdir_backslash.zip differ
diff --git a/Lib/test/autotest.py b/Lib/test/autotest.py
new file mode 100644
index 0000000000..b5a1fab404
--- /dev/null
+++ b/Lib/test/autotest.py
@@ -0,0 +1,5 @@
+# This should be equivalent to running regrtest.py from the cmdline.
+# It can be especially handy if you're in an interactive shell, e.g.,
+# from test import autotest.
+from test.libregrtest.main import main
+main()
diff --git a/Lib/test/certdata/allsans.pem b/Lib/test/certdata/allsans.pem
new file mode 100644
index 0000000000..02f2c2e634
--- /dev/null
+++ b/Lib/test/certdata/allsans.pem
@@ -0,0 +1,167 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:5f
+        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
+        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
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:allsans, othername: 1.2.3.4::some other identifier, othername: 1.3.6.1.5.2.2::<unsupported>, email:user@example.org, DNS:www.example.org, DirName:/C=XY/L=Castle Anthrax/O=Python Software Foundation/CN=dirname example, URI:https://www.python.org/, IP Address:127.0.0.1, IP Address:0:0:0:0:0:0:0:1, Registered ID:1.2.3.4.5
+            X509v3 Key Usage: critical
+                Digital Signature, Key Encipherment
+            X509v3 Extended Key Usage: 
+                TLS Web Server Authentication, TLS Web Client Authentication
+            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
+            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
+                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
+                serial:CB:2D:80:99:5A:69:52:5B
+            Authority Information Access: 
+                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
+                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
+            X509v3 CRL Distribution Points: 
+                Full Name:
+                  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
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/badcert.pem b/Lib/test/certdata/badcert.pem
new file mode 100644
index 0000000000..c4191460f9
--- /dev/null
+++ b/Lib/test/certdata/badcert.pem
@@ -0,0 +1,36 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXwIBAAKBgQC8ddrhm+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9L
+opdJhTvbGfEj0DQs1IE8M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVH
+fhi/VwovESJlaBOp+WMnfhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQAB
+AoGBAK0FZpaKj6WnJZN0RqhhK+ggtBWwBnc0U/ozgKz2j1s3fsShYeiGtW6CK5nU
+D1dZ5wzhbGThI7LiOXDvRucc9n7vUgi0alqPQ/PFodPxAN/eEYkmXQ7W2k7zwsDA
+IUK0KUhktQbLu8qF/m8qM86ba9y9/9YkXuQbZ3COl5ahTZrhAkEA301P08RKv3KM
+oXnGU2UHTuJ1MAD2hOrPxjD4/wxA/39EWG9bZczbJyggB4RHu0I3NOSFjAm3HQm0
+ANOu5QK9owJBANgOeLfNNcF4pp+UikRFqxk5hULqRAWzVxVrWe85FlPm0VVmHbb/
+loif7mqjU8o1jTd/LM7RD9f2usZyE2psaw8CQQCNLhkpX3KO5kKJmS9N7JMZSc4j
+oog58yeYO8BBqKKzpug0LXuQultYv2K4veaIO04iL9VLe5z9S/Q1jaCHBBuXAkEA
+z8gjGoi1AOp6PBBLZNsncCvcV/0aC+1se4HxTNo2+duKSDnbq+ljqOM+E7odU+Nq
+ewvIWOG//e8fssd0mq3HywJBAJ8l/c8GVmrpFTx8r/nZ2Pyyjt3dH1widooDXYSV
+q6Gbf41Llo5sYAtmxdndTLASuHKecacTgZVhy0FryZpLKrU=
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+Just bad cert data
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+MIICXwIBAAKBgQC8ddrhm+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9L
+opdJhTvbGfEj0DQs1IE8M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVH
+fhi/VwovESJlaBOp+WMnfhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQAB
+AoGBAK0FZpaKj6WnJZN0RqhhK+ggtBWwBnc0U/ozgKz2j1s3fsShYeiGtW6CK5nU
+D1dZ5wzhbGThI7LiOXDvRucc9n7vUgi0alqPQ/PFodPxAN/eEYkmXQ7W2k7zwsDA
+IUK0KUhktQbLu8qF/m8qM86ba9y9/9YkXuQbZ3COl5ahTZrhAkEA301P08RKv3KM
+oXnGU2UHTuJ1MAD2hOrPxjD4/wxA/39EWG9bZczbJyggB4RHu0I3NOSFjAm3HQm0
+ANOu5QK9owJBANgOeLfNNcF4pp+UikRFqxk5hULqRAWzVxVrWe85FlPm0VVmHbb/
+loif7mqjU8o1jTd/LM7RD9f2usZyE2psaw8CQQCNLhkpX3KO5kKJmS9N7JMZSc4j
+oog58yeYO8BBqKKzpug0LXuQultYv2K4veaIO04iL9VLe5z9S/Q1jaCHBBuXAkEA
+z8gjGoi1AOp6PBBLZNsncCvcV/0aC+1se4HxTNo2+duKSDnbq+ljqOM+E7odU+Nq
+ewvIWOG//e8fssd0mq3HywJBAJ8l/c8GVmrpFTx8r/nZ2Pyyjt3dH1widooDXYSV
+q6Gbf41Llo5sYAtmxdndTLASuHKecacTgZVhy0FryZpLKrU=
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+Just bad cert data
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/badkey.pem b/Lib/test/certdata/badkey.pem
new file mode 100644
index 0000000000..1c8a955719
--- /dev/null
+++ b/Lib/test/certdata/badkey.pem
@@ -0,0 +1,40 @@
+-----BEGIN RSA PRIVATE KEY-----
+Bad Key, though the cert should be OK
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICpzCCAhCgAwIBAgIJAP+qStv1cIGNMA0GCSqGSIb3DQEBBQUAMIGJMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMIRGVsYXdhcmUxEzARBgNVBAcTCldpbG1pbmd0b24x
+IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMQwwCgYDVQQLEwNT
+U0wxHzAdBgNVBAMTFnNvbWVtYWNoaW5lLnB5dGhvbi5vcmcwHhcNMDcwODI3MTY1
+NDUwWhcNMTMwMjE2MTY1NDUwWjCBiTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERl
+bGF3YXJlMRMwEQYDVQQHEwpXaWxtaW5ndG9uMSMwIQYDVQQKExpQeXRob24gU29m
+dHdhcmUgRm91bmRhdGlvbjEMMAoGA1UECxMDU1NMMR8wHQYDVQQDExZzb21lbWFj
+aGluZS5weXRob24ub3JnMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8ddrh
+m+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9LopdJhTvbGfEj0DQs1IE8
+M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVHfhi/VwovESJlaBOp+WMn
+fhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQABoxUwEzARBglghkgBhvhC
+AQEEBAMCBkAwDQYJKoZIhvcNAQEFBQADgYEAF4Q5BVqmCOLv1n8je/Jw9K669VXb
+08hyGzQhkemEBYQd6fzQ9A/1ZzHkJKb1P6yreOLSEh4KcxYPyrLRC1ll8nr5OlCx
+CMhKkTnR6qBsdNV0XtdU2+N25hqW+Ma4ZeqsN/iiJVCGNOZGnvQuvCAGWF8+J/f/
+iHkC6gGdBJhogs4=
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+Bad Key, though the cert should be OK
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICpzCCAhCgAwIBAgIJAP+qStv1cIGNMA0GCSqGSIb3DQEBBQUAMIGJMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMIRGVsYXdhcmUxEzARBgNVBAcTCldpbG1pbmd0b24x
+IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMQwwCgYDVQQLEwNT
+U0wxHzAdBgNVBAMTFnNvbWVtYWNoaW5lLnB5dGhvbi5vcmcwHhcNMDcwODI3MTY1
+NDUwWhcNMTMwMjE2MTY1NDUwWjCBiTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERl
+bGF3YXJlMRMwEQYDVQQHEwpXaWxtaW5ndG9uMSMwIQYDVQQKExpQeXRob24gU29m
+dHdhcmUgRm91bmRhdGlvbjEMMAoGA1UECxMDU1NMMR8wHQYDVQQDExZzb21lbWFj
+aGluZS5weXRob24ub3JnMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8ddrh
+m+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9LopdJhTvbGfEj0DQs1IE8
+M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVHfhi/VwovESJlaBOp+WMn
+fhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQABoxUwEzARBglghkgBhvhC
+AQEEBAMCBkAwDQYJKoZIhvcNAQEFBQADgYEAF4Q5BVqmCOLv1n8je/Jw9K669VXb
+08hyGzQhkemEBYQd6fzQ9A/1ZzHkJKb1P6yreOLSEh4KcxYPyrLRC1ll8nr5OlCx
+CMhKkTnR6qBsdNV0XtdU2+N25hqW+Ma4ZeqsN/iiJVCGNOZGnvQuvCAGWF8+J/f/
+iHkC6gGdBJhogs4=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/4e1295a3.0 b/Lib/test/certdata/capath/4e1295a3.0
new file mode 100644
index 0000000000..9d7ac238d8
--- /dev/null
+++ b/Lib/test/certdata/capath/4e1295a3.0
@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICLDCCAdYCAQAwDQYJKoZIhvcNAQEEBQAwgaAxCzAJBgNVBAYTAlBUMRMwEQYD
+VQQIEwpRdWVlbnNsYW5kMQ8wDQYDVQQHEwZMaXNib2ExFzAVBgNVBAoTDk5ldXJv
+bmlvLCBMZGEuMRgwFgYDVQQLEw9EZXNlbnZvbHZpbWVudG8xGzAZBgNVBAMTEmJy
+dXR1cy5uZXVyb25pby5wdDEbMBkGCSqGSIb3DQEJARYMc2FtcG9AaWtpLmZpMB4X
+DTk2MDkwNTAzNDI0M1oXDTk2MTAwNTAzNDI0M1owgaAxCzAJBgNVBAYTAlBUMRMw
+EQYDVQQIEwpRdWVlbnNsYW5kMQ8wDQYDVQQHEwZMaXNib2ExFzAVBgNVBAoTDk5l
+dXJvbmlvLCBMZGEuMRgwFgYDVQQLEw9EZXNlbnZvbHZpbWVudG8xGzAZBgNVBAMT
+EmJydXR1cy5uZXVyb25pby5wdDEbMBkGCSqGSIb3DQEJARYMc2FtcG9AaWtpLmZp
+MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAL7+aty3S1iBA/+yxjxv4q1MUTd1kjNw
+L4lYKbpzzlmC5beaQXeQ2RmGMTXU+mDvuqItjVHOK3DvPK7lTcSGftUCAwEAATAN
+BgkqhkiG9w0BAQQFAANBAFqPEKFjk6T6CKTHvaQeEAsX0/8YHPHqH/9AnhSjrwuX
+9EBc0n6bVGhN7XaXd6sJ7dym9sbsWxb+pJdurnkxjx4=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/5ed36f99.0 b/Lib/test/certdata/capath/5ed36f99.0
new file mode 100644
index 0000000000..e7dfc82947
--- /dev/null
+++ b/Lib/test/certdata/capath/5ed36f99.0
@@ -0,0 +1,41 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/6e88d7b8.0 b/Lib/test/certdata/capath/6e88d7b8.0
new file mode 100644
index 0000000000..9d7ac238d8
--- /dev/null
+++ b/Lib/test/certdata/capath/6e88d7b8.0
@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICLDCCAdYCAQAwDQYJKoZIhvcNAQEEBQAwgaAxCzAJBgNVBAYTAlBUMRMwEQYD
+VQQIEwpRdWVlbnNsYW5kMQ8wDQYDVQQHEwZMaXNib2ExFzAVBgNVBAoTDk5ldXJv
+bmlvLCBMZGEuMRgwFgYDVQQLEw9EZXNlbnZvbHZpbWVudG8xGzAZBgNVBAMTEmJy
+dXR1cy5uZXVyb25pby5wdDEbMBkGCSqGSIb3DQEJARYMc2FtcG9AaWtpLmZpMB4X
+DTk2MDkwNTAzNDI0M1oXDTk2MTAwNTAzNDI0M1owgaAxCzAJBgNVBAYTAlBUMRMw
+EQYDVQQIEwpRdWVlbnNsYW5kMQ8wDQYDVQQHEwZMaXNib2ExFzAVBgNVBAoTDk5l
+dXJvbmlvLCBMZGEuMRgwFgYDVQQLEw9EZXNlbnZvbHZpbWVudG8xGzAZBgNVBAMT
+EmJydXR1cy5uZXVyb25pby5wdDEbMBkGCSqGSIb3DQEJARYMc2FtcG9AaWtpLmZp
+MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAL7+aty3S1iBA/+yxjxv4q1MUTd1kjNw
+L4lYKbpzzlmC5beaQXeQ2RmGMTXU+mDvuqItjVHOK3DvPK7lTcSGftUCAwEAATAN
+BgkqhkiG9w0BAQQFAANBAFqPEKFjk6T6CKTHvaQeEAsX0/8YHPHqH/9AnhSjrwuX
+9EBc0n6bVGhN7XaXd6sJ7dym9sbsWxb+pJdurnkxjx4=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/99d0fa06.0 b/Lib/test/certdata/capath/99d0fa06.0
new file mode 100644
index 0000000000..e7dfc82947
--- /dev/null
+++ b/Lib/test/certdata/capath/99d0fa06.0
@@ -0,0 +1,41 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/b1930218.0 b/Lib/test/certdata/capath/b1930218.0
new file mode 100644
index 0000000000..aa9dbbe294
--- /dev/null
+++ b/Lib/test/certdata/capath/b1930218.0
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/capath/ceff1710.0 b/Lib/test/certdata/capath/ceff1710.0
new file mode 100644
index 0000000000..aa9dbbe294
--- /dev/null
+++ b/Lib/test/certdata/capath/ceff1710.0
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/cert3.pem b/Lib/test/certdata/cert3.pem
new file mode 100644
index 0000000000..4ab0f5ff13
--- /dev/null
+++ b/Lib/test/certdata/cert3.pem
@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/ffdh3072.pem b/Lib/test/certdata/ffdh3072.pem
new file mode 100644
index 0000000000..ad69bac8d0
--- /dev/null
+++ b/Lib/test/certdata/ffdh3072.pem
@@ -0,0 +1,41 @@
+    DH Parameters: (3072 bit)
+        prime:
+            00:ff:ff:ff:ff:ff:ff:ff:ff:ad:f8:54:58:a2:bb:
+            4a:9a:af:dc:56:20:27:3d:3c:f1:d8:b9:c5:83:ce:
+            2d:36:95:a9:e1:36:41:14:64:33:fb:cc:93:9d:ce:
+            24:9b:3e:f9:7d:2f:e3:63:63:0c:75:d8:f6:81:b2:
+            02:ae:c4:61:7a:d3:df:1e:d5:d5:fd:65:61:24:33:
+            f5:1f:5f:06:6e:d0:85:63:65:55:3d:ed:1a:f3:b5:
+            57:13:5e:7f:57:c9:35:98:4f:0c:70:e0:e6:8b:77:
+            e2:a6:89:da:f3:ef:e8:72:1d:f1:58:a1:36:ad:e7:
+            35:30:ac:ca:4f:48:3a:79:7a:bc:0a:b1:82:b3:24:
+            fb:61:d1:08:a9:4b:b2:c8:e3:fb:b9:6a:da:b7:60:
+            d7:f4:68:1d:4f:42:a3:de:39:4d:f4:ae:56:ed:e7:
+            63:72:bb:19:0b:07:a7:c8:ee:0a:6d:70:9e:02:fc:
+            e1:cd:f7:e2:ec:c0:34:04:cd:28:34:2f:61:91:72:
+            fe:9c:e9:85:83:ff:8e:4f:12:32:ee:f2:81:83:c3:
+            fe:3b:1b:4c:6f:ad:73:3b:b5:fc:bc:2e:c2:20:05:
+            c5:8e:f1:83:7d:16:83:b2:c6:f3:4a:26:c1:b2:ef:
+            fa:88:6b:42:38:61:1f:cf:dc:de:35:5b:3b:65:19:
+            03:5b:bc:34:f4:de:f9:9c:02:38:61:b4:6f:c9:d6:
+            e6:c9:07:7a:d9:1d:26:91:f7:f7:ee:59:8c:b0:fa:
+            c1:86:d9:1c:ae:fe:13:09:85:13:92:70:b4:13:0c:
+            93:bc:43:79:44:f4:fd:44:52:e2:d7:4d:d3:64:f2:
+            e2:1e:71:f5:4b:ff:5c:ae:82:ab:9c:9d:f6:9e:e8:
+            6d:2b:c5:22:36:3a:0d:ab:c5:21:97:9b:0d:ea:da:
+            1d:bf:9a:42:d5:c4:48:4e:0a:bc:d0:6b:fa:53:dd:
+            ef:3c:1b:20:ee:3f:d5:9d:7c:25:e4:1d:2b:66:c6:
+            2e:37:ff:ff:ff:ff:ff:ff:ff:ff
+        generator: 2 (0x2)
+        recommended-private-length: 276 bits
+-----BEGIN DH PARAMETERS-----
+MIIBjAKCAYEA//////////+t+FRYortKmq/cViAnPTzx2LnFg84tNpWp4TZBFGQz
++8yTnc4kmz75fS/jY2MMddj2gbICrsRhetPfHtXV/WVhJDP1H18GbtCFY2VVPe0a
+87VXE15/V8k1mE8McODmi3fipona8+/och3xWKE2rec1MKzKT0g6eXq8CrGCsyT7
+YdEIqUuyyOP7uWrat2DX9GgdT0Kj3jlN9K5W7edjcrsZCwenyO4KbXCeAvzhzffi
+7MA0BM0oNC9hkXL+nOmFg/+OTxIy7vKBg8P+OxtMb61zO7X8vC7CIAXFjvGDfRaD
+ssbzSibBsu/6iGtCOGEfz9zeNVs7ZRkDW7w09N75nAI4YbRvydbmyQd62R0mkff3
+7lmMsPrBhtkcrv4TCYUTknC0EwyTvEN5RPT9RFLi103TZPLiHnH1S/9croKrnJ32
+nuhtK8UiNjoNq8Uhl5sN6todv5pC1cRITgq80Gv6U93vPBsg7j/VnXwl5B0rZsYu
+N///////////AgECAgIBFA==
+-----END DH PARAMETERS-----
diff --git a/Lib/test/certdata/idnsans.pem b/Lib/test/certdata/idnsans.pem
new file mode 100644
index 0000000000..07a42422af
--- /dev/null
+++ b/Lib/test/certdata/idnsans.pem
@@ -0,0 +1,166 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:60
+        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
+        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
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:idnsans, DNS:xn--knig-5qa.idn.pythontest.net, DNS:xn--knigsgsschen-lcb0w.idna2003.pythontest.net, DNS:xn--knigsgchen-b4a3dun.idna2008.pythontest.net, DNS:xn--nxasmq6b.idna2003.pythontest.net, DNS:xn--nxasmm1c.idna2008.pythontest.net
+            X509v3 Key Usage: critical
+                Digital Signature, Key Encipherment
+            X509v3 Extended Key Usage: 
+                TLS Web Server Authentication, TLS Web Client Authentication
+            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
+            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
+                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
+                serial:CB:2D:80:99:5A:69:52:5B
+            Authority Information Access: 
+                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
+                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
+            X509v3 CRL Distribution Points: 
+                Full Name:
+                  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
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert.passwd.pem b/Lib/test/certdata/keycert.passwd.pem
new file mode 100644
index 0000000000..187021b8ee
--- /dev/null
+++ b/Lib/test/certdata/keycert.passwd.pem
@@ -0,0 +1,69 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----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+-----END ENCRYPTED PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert.pem b/Lib/test/certdata/keycert.pem
new file mode 100644
index 0000000000..a30d15ca4d
--- /dev/null
+++ b/Lib/test/certdata/keycert.pem
@@ -0,0 +1,67 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert2.pem b/Lib/test/certdata/keycert2.pem
new file mode 100644
index 0000000000..c7c4aa7458
--- /dev/null
+++ b/Lib/test/certdata/keycert2.pem
@@ -0,0 +1,67 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIEjDCCAvSgAwIBAgIUQ2S3jJ5nve5k5956sgsrWY3vw9MwDQYJKoZIhvcNAQEL
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert3.pem b/Lib/test/certdata/keycert3.pem
new file mode 100644
index 0000000000..20d9bd14e9
--- /dev/null
+++ b/Lib/test/certdata/keycert3.pem
@@ -0,0 +1,161 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:5c
+        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
+        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
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:localhost
+            X509v3 Key Usage: critical
+                Digital Signature, Key Encipherment
+            X509v3 Extended Key Usage: 
+                TLS Web Server Authentication, TLS Web Client Authentication
+            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
+            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
+                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
+                serial:CB:2D:80:99:5A:69:52:5B
+            Authority Information Access: 
+                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
+                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
+            X509v3 CRL Distribution Points: 
+                Full Name:
+                  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
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycert4.pem b/Lib/test/certdata/keycert4.pem
new file mode 100644
index 0000000000..ff4dceac79
--- /dev/null
+++ b/Lib/test/certdata/keycert4.pem
@@ -0,0 +1,161 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:5d
+        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
+        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
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:fakehostname
+            X509v3 Key Usage: critical
+                Digital Signature, Key Encipherment
+            X509v3 Extended Key Usage: 
+                TLS Web Server Authentication, TLS Web Client Authentication
+            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
+            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
+                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
+                serial:CB:2D:80:99:5A:69:52:5B
+            Authority Information Access: 
+                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
+                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
+            X509v3 CRL Distribution Points: 
+                Full Name:
+                  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
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/keycertecc.pem b/Lib/test/certdata/keycertecc.pem
new file mode 100644
index 0000000000..bd10992189
--- /dev/null
+++ b/Lib/test/certdata/keycertecc.pem
@@ -0,0 +1,103 @@
+-----BEGIN PRIVATE KEY-----
+MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDDRUbCeT3hMph4Y/ahL
+1sy9Qfy4DYotuAP06UetzG6syv+EoQ02kX3xvazqwiJDrEyhZANiAAQef97STEPn
+4Nk6C153VEx24MNkJUcmLe771u6lr3Q8Em3J/YPaA1i9Ys7KZA3WvoKBPoWaaikn
+4yLQbd/6YE6AAjMuaThlR1/cqH5QnmS3DXHUjmxnLjWy/dZl0CJG1qo=
+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:5e
+        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
+        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
+                ASN1 OID: secp384r1
+                NIST CURVE: P-384
+        X509v3 extensions:
+            X509v3 Subject Alternative Name: 
+                DNS:localhost-ecc
+            X509v3 Key Usage: critical
+                Digital Signature, Key Encipherment
+            X509v3 Extended Key Usage: 
+                TLS Web Server Authentication, TLS Web Client Authentication
+            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
+            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
+                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
+                serial:CB:2D:80:99:5A:69:52:5B
+            Authority Information Access: 
+                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
+                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
+            X509v3 CRL Distribution Points: 
+                Full Name:
+                  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
+-----BEGIN CERTIFICATE-----
+MIIEyzCCAzOgAwIBAgIJAMstgJlaaVJeMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/leaf-missing-aki.ca.pem b/Lib/test/certdata/leaf-missing-aki.ca.pem
new file mode 100644
index 0000000000..36b202ae02
--- /dev/null
+++ b/Lib/test/certdata/leaf-missing-aki.ca.pem
@@ -0,0 +1,13 @@
+# Taken from x509-limbo's `rfc5280::aki::leaf-missing-aki` testcase.
+# See: https://x509-limbo.com/testcases/rfc5280/#rfc5280akileaf-missing-aki
+-----BEGIN CERTIFICATE-----
+MIIBkDCCATWgAwIBAgIUGjIb/aYm9u9fBh2o4GAYRJwk5XIwCgYIKoZIzj0EAwIw
+GjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5
+NjkwNTAzMDAwMDAxWjAaMRgwFgYDVQQDDA94NTA5LWxpbWJvLXJvb3QwWTATBgcq
+hkjOPQIBBggqhkjOPQMBBwNCAARUzBhjMOkO911U65Fvs4YmL1YPNj63P9Fa+g9U
+KrUqiIy8WjaDXdIe8g8Zj0TalpbU1gYCs3atteMxgIp6qxwHo1cwVTAPBgNVHRMB
+Af8EBTADAQH/MAsGA1UdDwQEAwICBDAWBgNVHREEDzANggtleGFtcGxlLmNvbTAd
+BgNVHQ4EFgQUcv1fyqgezMGzmo+lhmUkdUuAbIowCgYIKoZIzj0EAwIDSQAwRgIh
+AIOErPSRlWpnyMub9UgtPF/lSzdvnD4Q8KjLQppHx6oPAiEA373p4L/HvUbs0xg8
+6/pLyn0RT02toKKJcMV3ChohLtM=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/leaf-missing-aki.keycert.pem b/Lib/test/certdata/leaf-missing-aki.keycert.pem
new file mode 100644
index 0000000000..0fd2ab39bf
--- /dev/null
+++ b/Lib/test/certdata/leaf-missing-aki.keycert.pem
@@ -0,0 +1,18 @@
+# Taken from x509-limbo's `rfc5280::aki::leaf-missing-aki` testcase.
+# See: https://x509-limbo.com/testcases/rfc5280/#rfc5280akileaf-missing-aki
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEIF5Re+/FP3rg+7c1odKEQPXhb9V65kXnlZIWHDG9gKrLoAoGCCqGSM49
+AwEHoUQDQgAE1WAQMdC7ims7T9lpK9uzaCuKqHb/oNMbGjh1f10pOHv3Z+oAvsqF
+Sv3hGzreu69YLy01afA6sUCf1AA/95dKkg==
+-----END EC PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIBjjCCATWgAwIBAgIUVlBgclml+OXlrWzZfcgYCiNm96UwCgYIKoZIzj0EAwIw
+GjEYMBYGA1UEAwwPeDUwOS1saW1iby1yb290MCAXDTcwMDEwMTAwMDAwMVoYDzI5
+NjkwNTAzMDAwMDAxWjAWMRQwEgYDVQQDDAtleGFtcGxlLmNvbTBZMBMGByqGSM49
+AgEGCCqGSM49AwEHA0IABNVgEDHQu4prO0/ZaSvbs2griqh2/6DTGxo4dX9dKTh7
+92fqAL7KhUr94Rs63ruvWC8tNWnwOrFAn9QAP/eXSpKjWzBZMB0GA1UdDgQWBBS3
+yYRQQwo3syjGVQ8Yw7/XRZHbpzALBgNVHQ8EBAMCB4AwEwYDVR0lBAwwCgYIKwYB
+BQUHAwEwFgYDVR0RBA8wDYILZXhhbXBsZS5jb20wCgYIKoZIzj0EAwIDRwAwRAIg
+BVq7lw4Y5MPEyisPhowMWd4KnERupdM5qeImDO+dD7ICIE/ksd6Wz1b8rMAfllNV
+yiYst9lfwTd2SkFgdDNUDFud
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/make_ssl_certs.py b/Lib/test/certdata/make_ssl_certs.py
new file mode 100644
index 0000000000..ed2037c1fd
--- /dev/null
+++ b/Lib/test/certdata/make_ssl_certs.py
@@ -0,0 +1,315 @@
+"""Make the custom certificate and private key files used by test_ssl
+and friends."""
+
+import os
+import pprint
+import shutil
+import tempfile
+from subprocess import *
+
+startdate = "20180829142316Z"
+enddate = "20371028142316Z"
+
+req_template = """
+    [ default ]
+    base_url               = http://testca.pythontest.net/testca
+
+    [req]
+    distinguished_name     = req_distinguished_name
+    prompt                 = no
+
+    [req_distinguished_name]
+    C                      = XY
+    L                      = Castle Anthrax
+    O                      = Python Software Foundation
+    CN                     = {hostname}
+
+    [req_x509_extensions_nosan]
+
+    [req_x509_extensions_simple]
+    subjectAltName         = @san
+
+    [req_x509_extensions_full]
+    subjectAltName         = @san
+    keyUsage               = critical,keyEncipherment,digitalSignature
+    extendedKeyUsage       = serverAuth,clientAuth
+    basicConstraints       = critical,CA:false
+    subjectKeyIdentifier   = hash
+    authorityKeyIdentifier = keyid:always,issuer:always
+    authorityInfoAccess    = @issuer_ocsp_info
+    crlDistributionPoints  = @crl_info
+
+    [ issuer_ocsp_info ]
+    caIssuers;URI.0        = $base_url/pycacert.cer
+    OCSP;URI.0             = $base_url/ocsp/
+
+    [ crl_info ]
+    URI.0                  = $base_url/revocation.crl
+
+    [san]
+    DNS.1 = {hostname}
+    {extra_san}
+
+    [dir_sect]
+    C                      = XY
+    L                      = Castle Anthrax
+    O                      = Python Software Foundation
+    CN                     = dirname example
+
+    [princ_name]
+    realm = EXP:0, GeneralString:KERBEROS.REALM
+    principal_name = EXP:1, SEQUENCE:principal_seq
+
+    [principal_seq]
+    name_type = EXP:0, INTEGER:1
+    name_string = EXP:1, SEQUENCE:principals
+
+    [principals]
+    princ1 = GeneralString:username
+
+    [ ca ]
+    default_ca      = CA_default
+
+    [ CA_default ]
+    dir = cadir
+    database  = $dir/index.txt
+    crlnumber = $dir/crl.txt
+    default_md = sha256
+    startdate = {startdate}
+    default_startdate = {startdate}
+    enddate = {enddate}
+    default_enddate = {enddate}
+    default_days = 7000
+    default_crl_days = 7000
+    certificate = pycacert.pem
+    private_key = pycakey.pem
+    serial    = $dir/serial
+    RANDFILE  = $dir/.rand
+    policy          = policy_match
+
+    [ policy_match ]
+    countryName             = match
+    stateOrProvinceName     = optional
+    organizationName        = match
+    organizationalUnitName  = optional
+    commonName              = supplied
+    emailAddress            = optional
+
+    [ policy_anything ]
+    countryName   = optional
+    stateOrProvinceName = optional
+    localityName    = optional
+    organizationName  = optional
+    organizationalUnitName  = optional
+    commonName    = supplied
+    emailAddress    = optional
+
+
+    [ v3_ca ]
+
+    subjectKeyIdentifier=hash
+    authorityKeyIdentifier=keyid:always,issuer
+    basicConstraints = critical, CA:true
+    keyUsage = critical, digitalSignature, keyCertSign, cRLSign
+
+    """
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+def make_cert_key(hostname, sign=False, extra_san='',
+                  ext='req_x509_extensions_full', key='rsa:3072'):
+    print("creating cert for " + hostname)
+    tempnames = []
+    for i in range(3):
+        with tempfile.NamedTemporaryFile(delete=False) as f:
+            tempnames.append(f.name)
+    req_file, cert_file, key_file = tempnames
+    try:
+        req = req_template.format(
+            hostname=hostname,
+            extra_san=extra_san,
+            startdate=startdate,
+            enddate=enddate
+        )
+        with open(req_file, 'w') as f:
+            f.write(req)
+        args = ['req', '-new', '-nodes', '-days', '7000',
+                '-newkey', key, '-keyout', key_file,
+                '-extensions', ext,
+                '-config', req_file]
+        if sign:
+            with tempfile.NamedTemporaryFile(delete=False) as f:
+                tempnames.append(f.name)
+                reqfile = f.name
+            args += ['-out', reqfile ]
+
+        else:
+            args += ['-x509', '-out', cert_file ]
+        check_call(['openssl'] + args)
+
+        if sign:
+            args = [
+                'ca',
+                '-config', req_file,
+                '-extensions', ext,
+                '-out', cert_file,
+                '-outdir', 'cadir',
+                '-policy', 'policy_anything',
+                '-batch', '-infiles', reqfile
+            ]
+            check_call(['openssl'] + args)
+
+
+        with open(cert_file, 'r') as f:
+            cert = f.read()
+        with open(key_file, 'r') as f:
+            key = f.read()
+        return cert, key
+    finally:
+        for name in tempnames:
+            os.remove(name)
+
+TMP_CADIR = 'cadir'
+
+def unmake_ca():
+    shutil.rmtree(TMP_CADIR)
+
+def make_ca():
+    os.mkdir(TMP_CADIR)
+    with open(os.path.join('cadir','index.txt'),'a+') as f:
+        pass # empty file
+    with open(os.path.join('cadir','crl.txt'),'a+') as f:
+        f.write("00")
+    with open(os.path.join('cadir','index.txt.attr'),'w+') as f:
+        f.write('unique_subject = no')
+    # random start value for serial numbers
+    with open(os.path.join('cadir','serial'), 'w') as f:
+        f.write('CB2D80995A69525B\n')
+
+    with tempfile.NamedTemporaryFile("w") as t:
+        req = req_template.format(
+            hostname='our-ca-server',
+            extra_san='',
+            startdate=startdate,
+            enddate=enddate
+        )
+        t.write(req)
+        t.flush()
+        with tempfile.NamedTemporaryFile() as f:
+            args = ['req', '-config', t.name, '-new',
+                    '-nodes',
+                    '-newkey', 'rsa:3072',
+                    '-keyout', 'pycakey.pem',
+                    '-out', f.name,
+                    '-subj', '/C=XY/L=Castle Anthrax/O=Python Software Foundation CA/CN=our-ca-server']
+            check_call(['openssl'] + args)
+            args = ['ca', '-config', t.name,
+                    '-out', 'pycacert.pem', '-batch', '-outdir', TMP_CADIR,
+                    '-keyfile', 'pycakey.pem',
+                    '-selfsign', '-extensions', 'v3_ca', '-infiles', f.name ]
+            check_call(['openssl'] + args)
+            args = ['ca', '-config', t.name, '-gencrl', '-out', 'revocation.crl']
+            check_call(['openssl'] + args)
+
+    # capath hashes depend on subject!
+    check_call([
+        'openssl', 'x509', '-in', 'pycacert.pem', '-out', 'capath/ceff1710.0'
+    ])
+    shutil.copy('capath/ceff1710.0', 'capath/b1930218.0')
+
+
+def print_cert(path):
+    import _ssl
+    pprint.pprint(_ssl._test_decode_cert(path))
+
+
+if __name__ == '__main__':
+    os.chdir(here)
+    cert, key = make_cert_key('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:
+        f.write(key)
+    print("password protecting ssl_key.pem in ssl_key.passwd.pem")
+    check_call(['openssl','pkey','-in','ssl_key.pem','-out','ssl_key.passwd.pem','-aes256','-passout','pass:somepass'])
+    check_call(['openssl','pkey','-in','ssl_key.pem','-out','keycert.passwd.pem','-aes256','-passout','pass:somepass'])
+
+    with open('keycert.pem', 'w') as f:
+        f.write(key)
+        f.write(cert)
+
+    with open('keycert.passwd.pem', 'a+') as f:
+        f.write(cert)
+
+    # For certificate matching tests
+    make_ca()
+    cert, key = make_cert_key('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)
+    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)
+    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'
+    )
+    with open('keycertecc.pem', 'w') as f:
+        f.write(key)
+        f.write(cert)
+
+    extra_san = [
+        'otherName.1 = 1.2.3.4;UTF8:some other identifier',
+        'otherName.2 = 1.3.6.1.5.2.2;SEQUENCE:princ_name',
+        'email.1 = user@example.org',
+        'DNS.2 = www.example.org',
+        # GEN_X400
+        'dirName.1 = dir_sect',
+        # GEN_EDIPARTY
+        'URI.1 = https://www.python.org/',
+        'IP.1 = 127.0.0.1',
+        'IP.2 = ::1',
+        'RID.1 = 1.2.3.4.5',
+    ]
+
+    cert, key = make_cert_key('allsans', sign=True, extra_san='\n'.join(extra_san))
+    with open('allsans.pem', 'w') as f:
+        f.write(key)
+        f.write(cert)
+
+    extra_san = [
+        # könig (king)
+        'DNS.2 = xn--knig-5qa.idn.pythontest.net',
+        # königsgäßchen (king's alleyway)
+        'DNS.3 = xn--knigsgsschen-lcb0w.idna2003.pythontest.net',
+        'DNS.4 = xn--knigsgchen-b4a3dun.idna2008.pythontest.net',
+        # βόλοσ (marble)
+        'DNS.5 = xn--nxasmq6b.idna2003.pythontest.net',
+        'DNS.6 = xn--nxasmm1c.idna2008.pythontest.net',
+    ]
+
+    # IDN SANS, signed
+    cert, key = make_cert_key('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')
+    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')
diff --git a/Lib/test/certdata/nokia.pem b/Lib/test/certdata/nokia.pem
new file mode 100644
index 0000000000..0d044df436
--- /dev/null
+++ b/Lib/test/certdata/nokia.pem
@@ -0,0 +1,31 @@
+# Certificate for projects.developer.nokia.com:443 (see issue 13034)
+-----BEGIN CERTIFICATE-----
+MIIFLDCCBBSgAwIBAgIQLubqdkCgdc7lAF9NfHlUmjANBgkqhkiG9w0BAQUFADCB
+vDELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL
+ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYDVQQLEzJUZXJtcyBvZiB1c2Ug
+YXQgaHR0cHM6Ly93d3cudmVyaXNpZ24uY29tL3JwYSAoYykxMDE2MDQGA1UEAxMt
+VmVyaVNpZ24gQ2xhc3MgMyBJbnRlcm5hdGlvbmFsIFNlcnZlciBDQSAtIEczMB4X
+DTExMDkyMTAwMDAwMFoXDTEyMDkyMDIzNTk1OVowcTELMAkGA1UEBhMCRkkxDjAM
+BgNVBAgTBUVzcG9vMQ4wDAYDVQQHFAVFc3BvbzEOMAwGA1UEChQFTm9raWExCzAJ
+BgNVBAsUAkJJMSUwIwYDVQQDFBxwcm9qZWN0cy5kZXZlbG9wZXIubm9raWEuY29t
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCr92w1bpHYSYxUEx8N/8Iddda2
+lYi+aXNtQfV/l2Fw9Ykv3Ipw4nLeGTj18FFlAZgMdPRlgrzF/NNXGw/9l3/qKdow
+CypkQf8lLaxb9Ze1E/KKmkRJa48QTOqvo6GqKuTI6HCeGlG1RxDb8YSKcQWLiytn
+yj3Wp4MgRQO266xmMQIDAQABo4IB9jCCAfIwQQYDVR0RBDowOIIccHJvamVjdHMu
+ZGV2ZWxvcGVyLm5va2lhLmNvbYIYcHJvamVjdHMuZm9ydW0ubm9raWEuY29tMAkG
+A1UdEwQCMAAwCwYDVR0PBAQDAgWgMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9T
+VlJJbnRsLUczLWNybC52ZXJpc2lnbi5jb20vU1ZSSW50bEczLmNybDBEBgNVHSAE
+PTA7MDkGC2CGSAGG+EUBBxcDMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZl
+cmlzaWduLmNvbS9ycGEwKAYDVR0lBCEwHwYJYIZIAYb4QgQBBggrBgEFBQcDAQYI
+KwYBBQUHAwIwcgYIKwYBBQUHAQEEZjBkMCQGCCsGAQUFBzABhhhodHRwOi8vb2Nz
+cC52ZXJpc2lnbi5jb20wPAYIKwYBBQUHMAKGMGh0dHA6Ly9TVlJJbnRsLUczLWFp
+YS52ZXJpc2lnbi5jb20vU1ZSSW50bEczLmNlcjBuBggrBgEFBQcBDARiMGChXqBc
+MFowWDBWFglpbWFnZS9naWYwITAfMAcGBSsOAwIaBBRLa7kolgYMu9BSOJsprEsH
+iyEFGDAmFiRodHRwOi8vbG9nby52ZXJpc2lnbi5jb20vdnNsb2dvMS5naWYwDQYJ
+KoZIhvcNAQEFBQADggEBACQuPyIJqXwUyFRWw9x5yDXgMW4zYFopQYOw/ItRY522
+O5BsySTh56BWS6mQB07XVfxmYUGAvRQDA5QHpmY8jIlNwSmN3s8RKo+fAtiNRlcL
+x/mWSfuMs3D/S6ev3D6+dpEMZtjrhOdctsarMKp8n/hPbwhAbg5hVjpkW5n8vz2y
+0KxvvkA1AxpLwpVv7OlK17ttzIHw8bp9HTlHBU5s8bKz4a565V/a5HI0CSEv/+0y
+ko4/ghTnZc1CkmUngKKeFMSah/mT/xAh8XnE2l1AazFa8UKuYki1e+ArHaGZc4ix
+UYOtiRphwfuYQhRZ7qX9q2MMkCMI65XNK/SaFrAbbG0=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/nosan.pem b/Lib/test/certdata/nosan.pem
new file mode 100644
index 0000000000..c6ff8ea31b
--- /dev/null
+++ b/Lib/test/certdata/nosan.pem
@@ -0,0 +1,131 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
+Certificate:
+    Data:
+        Version: 1 (0x0)
+        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
+        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
+                Exponent: 65537 (0x10001)
+    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
+-----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=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/nullbytecert.pem b/Lib/test/certdata/nullbytecert.pem
new file mode 100644
index 0000000000..447186c950
--- /dev/null
+++ b/Lib/test/certdata/nullbytecert.pem
@@ -0,0 +1,90 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 0 (0x0)
+    Signature Algorithm: sha1WithRSAEncryption
+        Issuer: C=US, ST=Oregon, L=Beaverton, O=Python Software Foundation, OU=Python Core Development, CN=null.python.org\x00example.org/emailAddress=python-dev@python.org
+        Validity
+            Not Before: Aug  7 13:11:52 2013 GMT
+            Not After : Aug  7 13:12:52 2013 GMT
+        Subject: C=US, ST=Oregon, L=Beaverton, O=Python Software Foundation, OU=Python Core Development, CN=null.python.org\x00example.org/emailAddress=python-dev@python.org
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+                Public-Key: (2048 bit)
+                Modulus:
+                    00:b5:ea:ed:c9:fb:46:7d:6f:3b:76:80:dd:3a:f3:
+                    03:94:0b:a7:a6:db:ec:1d:df:ff:23:74:08:9d:97:
+                    16:3f:a3:a4:7b:3e:1b:0e:96:59:25:03:a7:26:e2:
+                    88:a9:cf:79:cd:f7:04:56:b0:ab:79:32:6e:59:c1:
+                    32:30:54:eb:58:a8:cb:91:f0:42:a5:64:27:cb:d4:
+                    56:31:88:52:ad:cf:bd:7f:f0:06:64:1f:cc:27:b8:
+                    a3:8b:8c:f3:d8:29:1f:25:0b:f5:46:06:1b:ca:02:
+                    45:ad:7b:76:0a:9c:bf:bb:b9:ae:0d:16:ab:60:75:
+                    ae:06:3e:9c:7c:31:dc:92:2f:29:1a:e0:4b:0c:91:
+                    90:6c:e9:37:c5:90:d7:2a:d7:97:15:a3:80:8f:5d:
+                    7b:49:8f:54:30:d4:97:2c:1c:5b:37:b5:ab:69:30:
+                    68:43:d3:33:78:4b:02:60:f5:3c:44:80:a1:8f:e7:
+                    f0:0f:d1:5e:87:9e:46:cf:62:fc:f9:bf:0c:65:12:
+                    f1:93:c8:35:79:3f:c8:ec:ec:47:f5:ef:be:44:d5:
+                    ae:82:1e:2d:9a:9f:98:5a:67:65:e1:74:70:7c:cb:
+                    d3:c2:ce:0e:45:49:27:dc:e3:2d:d4:fb:48:0e:2f:
+                    9e:77:b8:14:46:c0:c4:36:ca:02:ae:6a:91:8c:da:
+                    2f:85
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Basic Constraints: critical
+                CA:FALSE
+            X509v3 Subject Key Identifier:
+                88:5A:55:C0:52:FF:61:CD:52:A3:35:0F:EA:5A:9C:24:38:22:F7:5C
+            X509v3 Key Usage:
+                Digital Signature, Non Repudiation, Key Encipherment
+            X509v3 Subject Alternative Name:
+                *************************************************************
+                WARNING: The values for DNS, email and URI are WRONG. OpenSSL
+                         doesn't print the text after a NULL byte.
+                *************************************************************
+                DNS:altnull.python.org, email:null@python.org, URI:http://null.python.org, IP Address:192.0.2.1, IP Address:2001:DB8:0:0:0:0:0:1
+    Signature Algorithm: sha1WithRSAEncryption
+         ac:4f:45:ef:7d:49:a8:21:70:8e:88:59:3e:d4:36:42:70:f5:
+         a3:bd:8b:d7:a8:d0:58:f6:31:4a:b1:a4:a6:dd:6f:d9:e8:44:
+         3c:b6:0a:71:d6:7f:b1:08:61:9d:60:ce:75:cf:77:0c:d2:37:
+         86:02:8d:5e:5d:f9:0f:71:b4:16:a8:c1:3d:23:1c:f1:11:b3:
+         56:6e:ca:d0:8d:34:94:e6:87:2a:99:f2:ae:ae:cc:c2:e8:86:
+         de:08:a8:7f:c5:05:fa:6f:81:a7:82:e6:d0:53:9d:34:f4:ac:
+         3e:40:fe:89:57:7a:29:a4:91:7e:0b:c6:51:31:e5:10:2f:a4:
+         60:76:cd:95:51:1a:be:8b:a1:b0:fd:ad:52:bd:d7:1b:87:60:
+         d2:31:c7:17:c4:18:4f:2d:08:25:a3:a7:4f:b7:92:ca:e2:f5:
+         25:f1:54:75:81:9d:b3:3d:61:a2:f7:da:ed:e1:c6:6f:2c:60:
+         1f:d8:6f:c5:92:05:ab:c9:09:62:49:a9:14:ad:55:11:cc:d6:
+         4a:19:94:99:97:37:1d:81:5f:8b:cf:a3:a8:96:44:51:08:3d:
+         0b:05:65:12:eb:b6:70:80:88:48:72:4f:c6:c2:da:cf:cd:8e:
+         5b:ba:97:2f:60:b4:96:56:49:5e:3a:43:76:63:04:be:2a:f6:
+         c1:ca:a9:94
+-----BEGIN CERTIFICATE-----
+MIIE2DCCA8CgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBxTELMAkGA1UEBhMCVVMx
+DzANBgNVBAgMBk9yZWdvbjESMBAGA1UEBwwJQmVhdmVydG9uMSMwIQYDVQQKDBpQ
+eXRob24gU29mdHdhcmUgRm91bmRhdGlvbjEgMB4GA1UECwwXUHl0aG9uIENvcmUg
+RGV2ZWxvcG1lbnQxJDAiBgNVBAMMG251bGwucHl0aG9uLm9yZwBleGFtcGxlLm9y
+ZzEkMCIGCSqGSIb3DQEJARYVcHl0aG9uLWRldkBweXRob24ub3JnMB4XDTEzMDgw
+NzEzMTE1MloXDTEzMDgwNzEzMTI1MlowgcUxCzAJBgNVBAYTAlVTMQ8wDQYDVQQI
+DAZPcmVnb24xEjAQBgNVBAcMCUJlYXZlcnRvbjEjMCEGA1UECgwaUHl0aG9uIFNv
+ZnR3YXJlIEZvdW5kYXRpb24xIDAeBgNVBAsMF1B5dGhvbiBDb3JlIERldmVsb3Bt
+ZW50MSQwIgYDVQQDDBtudWxsLnB5dGhvbi5vcmcAZXhhbXBsZS5vcmcxJDAiBgkq
+hkiG9w0BCQEWFXB5dGhvbi1kZXZAcHl0aG9uLm9yZzCCASIwDQYJKoZIhvcNAQEB
+BQADggEPADCCAQoCggEBALXq7cn7Rn1vO3aA3TrzA5QLp6bb7B3f/yN0CJ2XFj+j
+pHs+Gw6WWSUDpybiiKnPec33BFawq3kyblnBMjBU61ioy5HwQqVkJ8vUVjGIUq3P
+vX/wBmQfzCe4o4uM89gpHyUL9UYGG8oCRa17dgqcv7u5rg0Wq2B1rgY+nHwx3JIv
+KRrgSwyRkGzpN8WQ1yrXlxWjgI9de0mPVDDUlywcWze1q2kwaEPTM3hLAmD1PESA
+oY/n8A/RXoeeRs9i/Pm/DGUS8ZPINXk/yOzsR/XvvkTVroIeLZqfmFpnZeF0cHzL
+08LODkVJJ9zjLdT7SA4vnne4FEbAxDbKAq5qkYzaL4UCAwEAAaOB0DCBzTAMBgNV
+HRMBAf8EAjAAMB0GA1UdDgQWBBSIWlXAUv9hzVKjNQ/qWpwkOCL3XDALBgNVHQ8E
+BAMCBeAwgZAGA1UdEQSBiDCBhYIeYWx0bnVsbC5weXRob24ub3JnAGV4YW1wbGUu
+Y29tgSBudWxsQHB5dGhvbi5vcmcAdXNlckBleGFtcGxlLm9yZ4YpaHR0cDovL251
+bGwucHl0aG9uLm9yZwBodHRwOi8vZXhhbXBsZS5vcmeHBMAAAgGHECABDbgAAAAA
+AAAAAAAAAAEwDQYJKoZIhvcNAQEFBQADggEBAKxPRe99SaghcI6IWT7UNkJw9aO9
+i9eo0Fj2MUqxpKbdb9noRDy2CnHWf7EIYZ1gznXPdwzSN4YCjV5d+Q9xtBaowT0j
+HPERs1ZuytCNNJTmhyqZ8q6uzMLoht4IqH/FBfpvgaeC5tBTnTT0rD5A/olXeimk
+kX4LxlEx5RAvpGB2zZVRGr6LobD9rVK91xuHYNIxxxfEGE8tCCWjp0+3ksri9SXx
+VHWBnbM9YaL32u3hxm8sYB/Yb8WSBavJCWJJqRStVRHM1koZlJmXNx2BX4vPo6iW
+RFEIPQsFZRLrtnCAiEhyT8bC2s/Njlu6ly9gtJZWSV46Q3ZjBL4q9sHKqZQ=
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/nullcert.pem b/Lib/test/certdata/nullcert.pem
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Lib/test/certdata/pycacert.pem b/Lib/test/certdata/pycacert.pem
new file mode 100644
index 0000000000..0a48bf7d23
--- /dev/null
+++ b/Lib/test/certdata/pycacert.pem
@@ -0,0 +1,102 @@
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number:
+            cb:2d:80:99:5a:69:52:5b
+        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
+        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
+                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
+            X509v3 Authority Key Identifier: 
+                F3:EC:94:8E:F2:8E:30:C4:8E:68:C2:BF:8E:6A:19:C0:C1:9F:76:65
+            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
+-----BEGIN CERTIFICATE-----
+MIIEgDCCAuigAwIBAgIJAMstgJlaaVJbMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNV
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/pycakey.pem b/Lib/test/certdata/pycakey.pem
new file mode 100644
index 0000000000..a6bf7356f4
--- /dev/null
+++ b/Lib/test/certdata/pycakey.pem
@@ -0,0 +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
+-----END PRIVATE KEY-----
diff --git a/Lib/test/certdata/revocation.crl b/Lib/test/certdata/revocation.crl
new file mode 100644
index 0000000000..431a831c4f
--- /dev/null
+++ b/Lib/test/certdata/revocation.crl
@@ -0,0 +1,14 @@
+-----BEGIN X509 CRL-----
+MIICJjCBjwIBATANBgkqhkiG9w0BAQsFADBNMQswCQYDVQQGEwJYWTEmMCQGA1UE
+CgwdUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24gQ0ExFjAUBgNVBAMMDW91ci1j
+YS1zZXJ2ZXIXDTIzMTEyNTA0MjEzNloXDTQzMDEyNDA0MjEzNlqgDjAMMAoGA1Ud
+FAQDAgEAMA0GCSqGSIb3DQEBCwUAA4IBgQDMZ4XLQlzUrqBbszEq9I/nXK3jN8/p
+VZ2aScU2le0ySJqIthe0yXEYuoFu+I4ZULyNkCA79baStIl8/Lt48DOHfBVv8SVx
+ZqF7/fdUZBCLJV1kuhuSSknbtNmja5NI4/lcRRXrodRWDMcOmqlKbAC6RMQz/gMG
+vpewGPX1oj5AQnqqd9spKtHbeqeDiyyWYr9ZZFO/433lP7GdsoriTPggYJJMWJvs
+819buE0iGwWf+rTLB51VyGluhcz2pqimej6Ra2cdnYh5IztZlDFR99HywzWhVz/A
+2fwUA91GR7zATerweXVKNd59mcgF4PZWiXmQMwcE0qQOMqMmAqYPLim1mretZsAs
+t1X+nDM0Ak3sKumIjteQF7I6VpSsG4NCtq23G8KpNHnBZVOt0U065lQEvx0ZmB94
+1z7SzjfSZMVXYxBjSXljwuoc1keGpNT5xCmHyrOIxaHsmizzwNESW4dGVLu7/JfK
+w40uGbwH09w4Cfbwuo7w6sRWDWPnlW2mkoc=
+-----END X509 CRL-----
diff --git a/Lib/test/certdata/secp384r1.pem b/Lib/test/certdata/secp384r1.pem
new file mode 100644
index 0000000000..eef7117af7
--- /dev/null
+++ b/Lib/test/certdata/secp384r1.pem
@@ -0,0 +1,7 @@
+$ openssl genpkey -genparam -algorithm EC -pkeyopt ec_paramgen_curve:secp384r1 -pkeyopt ec_param_enc:named_curve -text
+-----BEGIN EC PARAMETERS-----
+BgUrgQQAIg==
+-----END EC PARAMETERS-----
+ECDSA-Parameters: (384 bit)
+ASN1 OID: secp384r1
+NIST CURVE: P-384
diff --git a/Lib/test/certdata/selfsigned_pythontestdotnet.pem b/Lib/test/certdata/selfsigned_pythontestdotnet.pem
new file mode 100644
index 0000000000..2b1760747b
--- /dev/null
+++ b/Lib/test/certdata/selfsigned_pythontestdotnet.pem
@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----
+MIIF9zCCA9+gAwIBAgIUH98b4Fw/DyugC9cV7VK7ZODzHsIwDQYJKoZIhvcNAQEL
+BQAwgYoxCzAJBgNVBAYTAlhZMRcwFQYDVQQIDA5DYXN0bGUgQW50aHJheDEYMBYG
+A1UEBwwPQXJndW1lbnQgQ2xpbmljMSMwIQYDVQQKDBpQeXRob24gU29mdHdhcmUg
+Rm91bmRhdGlvbjEjMCEGA1UEAwwac2VsZi1zaWduZWQucHl0aG9udGVzdC5uZXQw
+HhcNMTkwNTA4MDEwMjQzWhcNMjcwNzI0MDEwMjQzWjCBijELMAkGA1UEBhMCWFkx
+FzAVBgNVBAgMDkNhc3RsZSBBbnRocmF4MRgwFgYDVQQHDA9Bcmd1bWVudCBDbGlu
+aWMxIzAhBgNVBAoMGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMSMwIQYDVQQD
+DBpzZWxmLXNpZ25lZC5weXRob250ZXN0Lm5ldDCCAiIwDQYJKoZIhvcNAQEBBQAD
+ggIPADCCAgoCggIBAMKdJlyCThkahwoBb7pl5q64Pe9Fn5jrIvzsveHTc97TpjV2
+RLfICnXKrltPk/ohkVl6K5SUZQZwMVzFubkyxE0nZPHYHlpiKWQxbsYVkYv01rix
+IFdLvaxxbGYke2jwQao31s4o61AdlsfK1SdpHQUynBBMssqI3SB4XPmcA7e+wEEx
+jxjVish4ixA1vuIZOx8yibu+CFCf/geEjoBMF3QPdzULzlrCSw8k/45iZCSoNbvK
+DoL4TVV07PHOxpheDh8ZQmepGvU6pVqhb9m4lgmV0OGWHgozd5Ur9CbTVDmxIEz3
+TSoRtNJK7qtyZdGNqwjksQxgZTjM/d/Lm/BJG99AiOmYOjsl9gbQMZgvQmMAtUsI
+aMJnQuZ6R+KEpW/TR5qSKLWZSG45z/op+tzI2m+cE6HwTRVAWbcuJxcAA55MZjqU
+OOOu3BBYMjS5nf2sQ9uoXsVBFH7i0mQqoW1SLzr9opI8KsWwFxQmO2vBxWYaN+lH
+OmwBZBwyODIsmI1YGXmTp09NxRYz3Qe5GCgFzYowpMrcxUC24iduIdMwwhRM7rKg
+7GtIWMSrFfuI1XCLRmSlhDbhNN6fVg2f8Bo9PdH9ihiIyxSrc+FOUasUYCCJvlSZ
+8hFUlLvcmrZlWuazohm0lsXuMK1JflmQr/DA/uXxP9xzFfRy+RU3jDyxJbRHAgMB
+AAGjUzBRMB0GA1UdDgQWBBSQJyxiPMRK01i+0BsV9zUwDiBaHzAfBgNVHSMEGDAW
+gBSQJyxiPMRK01i+0BsV9zUwDiBaHzAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3
+DQEBCwUAA4ICAQCR+7a7N/m+WLkxPPIA/CB4MOr2Uf8ixTv435Nyv6rXOun0+lTP
+ExSZ0uYQ+L0WylItI3cQHULldDueD+s8TGzxf5woaLKf6tqyr0NYhKs+UeNEzDnN
+9PHQIhX0SZw3XyXGUgPNBfRCg2ZDdtMMdOU4XlQN/IN/9hbYTrueyY7eXq9hmtI9
+1srftAMqr9SR1JP7aHI6DVgrEsZVMTDnfT8WmLSGLlY1HmGfdEn1Ip5sbo9uSkiH
+AEPgPfjYIvR5LqTOMn4KsrlZyBbFIDh9Sl99M1kZzgH6zUGVLCDg1y6Cms69fx/e
+W1HoIeVkY4b4TY7Bk7JsqyNhIuqu7ARaxkdaZWhYaA2YyknwANdFfNpfH+elCLIk
+BUt5S3f4i7DaUePTvKukCZiCq4Oyln7RcOn5If73wCeLB/ZM9Ei1HforyLWP1CN8
+XLfpHaoeoPSWIveI0XHUl65LsPN2UbMbul/F23hwl+h8+BLmyAS680Yhn4zEN6Ku
+B7Po90HoFa1Du3bmx4jsN73UkT/dwMTi6K072FbipnC1904oGlWmLwvAHvrtxxmL
+Pl3pvEaZIu8wa/PNF6Y7J7VIewikIJq6Ta6FrWeFfzMWOj2qA1ZZi6fUaDSNYvuV
+J5quYKCc/O+I/yDDf8wyBbZ/gvUXzUHTMYGG+bFrn1p7XDbYYeEJ6R/xEg==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/ssl_cert.pem b/Lib/test/certdata/ssl_cert.pem
new file mode 100644
index 0000000000..427948252b
--- /dev/null
+++ b/Lib/test/certdata/ssl_cert.pem
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEgzCCAuugAwIBAgIUU+FIM/dUbCklbdDwNPd2xemDAEwwDQYJKoZIhvcNAQEL
+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==
+-----END CERTIFICATE-----
diff --git a/Lib/test/certdata/ssl_key.passwd.pem b/Lib/test/certdata/ssl_key.passwd.pem
new file mode 100644
index 0000000000..6ab7d57d00
--- /dev/null
+++ b/Lib/test/certdata/ssl_key.passwd.pem
@@ -0,0 +1,42 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----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+-----END ENCRYPTED PRIVATE KEY-----
diff --git a/Lib/test/certdata/ssl_key.pem b/Lib/test/certdata/ssl_key.pem
new file mode 100644
index 0000000000..ee92721051
--- /dev/null
+++ b/Lib/test/certdata/ssl_key.pem
@@ -0,0 +1,40 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
diff --git a/Lib/test/certdata/talos-2019-0758.pem b/Lib/test/certdata/talos-2019-0758.pem
new file mode 100644
index 0000000000..13b95a77fd
--- /dev/null
+++ b/Lib/test/certdata/talos-2019-0758.pem
@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDqDCCApKgAwIBAgIBAjALBgkqhkiG9w0BAQswHzELMAkGA1UEBhMCVUsxEDAO
+BgNVBAMTB2NvZHktY2EwHhcNMTgwNjE4MTgwMDU4WhcNMjgwNjE0MTgwMDU4WjA7
+MQswCQYDVQQGEwJVSzEsMCoGA1UEAxMjY29kZW5vbWljb24tdm0tMi50ZXN0Lmxh
+bC5jaXNjby5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC63fGB
+J80A9Av1GB0bptslKRIUtJm8EeEu34HkDWbL6AJY0P8WfDtlXjlPaLqFa6sqH6ES
+V48prSm1ZUbDSVL8R6BYVYpOlK8/48xk4pGTgRzv69gf5SGtQLwHy8UPBKgjSZoD
+5a5k5wJXGswhKFFNqyyxqCvWmMnJWxXTt2XDCiWc4g4YAWi4O4+6SeeHVAV9rV7C
+1wxqjzKovVe2uZOHjKEzJbbIU6JBPb6TRfMdRdYOw98n1VXDcKVgdX2DuuqjCzHP
+WhU4Tw050M9NaK3eXp4Mh69VuiKoBGOLSOcS8reqHIU46Reg0hqeL8LIL6OhFHIF
+j7HR6V1X6F+BfRS/AgMBAAGjgdYwgdMwCQYDVR0TBAIwADAdBgNVHQ4EFgQUOktp
+HQjxDXXUg8prleY9jeLKeQ4wTwYDVR0jBEgwRoAUx6zgPygZ0ZErF9sPC4+5e2Io
+UU+hI6QhMB8xCzAJBgNVBAYTAlVLMRAwDgYDVQQDEwdjb2R5LWNhggkA1QEAuwb7
+2s0wCQYDVR0SBAIwADAuBgNVHREEJzAlgiNjb2Rlbm9taWNvbi12bS0yLnRlc3Qu
+bGFsLmNpc2NvLmNvbTAOBgNVHQ8BAf8EBAMCBaAwCwYDVR0fBAQwAjAAMAsGCSqG
+SIb3DQEBCwOCAQEAvqantx2yBlM11RoFiCfi+AfSblXPdrIrHvccepV4pYc/yO6p
+t1f2dxHQb8rWH3i6cWag/EgIZx+HJQvo0rgPY1BFJsX1WnYf1/znZpkUBGbVmlJr
+t/dW1gSkNS6sPsM0Q+7HPgEv8CPDNK5eo7vU2seE0iWOkxSyVUuiCEY9ZVGaLVit
+p0C78nZ35Pdv4I+1cosmHl28+es1WI22rrnmdBpH8J1eY6WvUw2xuZHLeNVN0TzV
+Q3qq53AaCWuLOD1AjESWuUCxMZTK9DPS4JKXTK8RLyDeqOvJGjsSWp3kL0y3GaQ+
+10T1rfkKJub2+m9A9duin1fn6tHc2wSvB7m3DA==
+-----END CERTIFICATE-----
diff --git a/Lib/test/cfgparser.1 b/Lib/test/configdata/cfgparser.1
similarity index 100%
rename from Lib/test/cfgparser.1
rename to Lib/test/configdata/cfgparser.1
diff --git a/Lib/test/cfgparser.2 b/Lib/test/configdata/cfgparser.2
similarity index 100%
rename from Lib/test/cfgparser.2
rename to Lib/test/configdata/cfgparser.2
diff --git a/Lib/test/cfgparser.3 b/Lib/test/configdata/cfgparser.3
similarity index 100%
rename from Lib/test/cfgparser.3
rename to Lib/test/configdata/cfgparser.3
diff --git a/Lib/test/data/README b/Lib/test/data/README
new file mode 100644
index 0000000000..bd05984e43
--- /dev/null
+++ b/Lib/test/data/README
@@ -0,0 +1,2 @@
+This empty directory serves as destination for temporary files
+created by some tests, in particular, the test_codecmaps_* tests.
diff --git a/Lib/test/datetimetester.py b/Lib/test/datetimetester.py
index 7c6c8d7dd2..1bb74c6d96 100644
--- a/Lib/test/datetimetester.py
+++ b/Lib/test/datetimetester.py
@@ -1,3 +1,6 @@
+# TODO: RustPython
+# Skipping some tests because time module has no attribute tzset
+# implementation detail specific to cpython
 """Test date/time type.
 
 See https://www.zope.dev/Members/fdrake/DateTimeWiki/TestCases
@@ -13,6 +16,7 @@
 import re
 import struct
 import sys
+import textwrap
 import unittest
 import warnings
 
@@ -22,6 +26,7 @@
 
 from test import support
 from test.support import is_resource_enabled, ALWAYS_EQ, LARGEST, SMALLEST
+from test.support import script_helper, warnings_helper
 
 import datetime as datetime_module
 from datetime import MINYEAR, MAXYEAR
@@ -37,6 +42,10 @@
     import _testcapi
 except ImportError:
     _testcapi = None
+try:
+    import _interpreters
+except ModuleNotFoundError:
+    _interpreters = None
 
 # Needed by test_datetime
 import _strptime
@@ -301,6 +310,10 @@ def test_inheritance(self):
         self.assertIsInstance(timezone.utc, tzinfo)
         self.assertIsInstance(self.EST, tzinfo)
 
+    def test_cannot_subclass(self):
+        with self.assertRaises(TypeError):
+            class MyTimezone(timezone): pass
+
     def test_utcoffset(self):
         dummy = self.DT
         for h in [0, 1.5, 12]:
@@ -752,6 +765,9 @@ def test_str(self):
                    microseconds=999999)),
            "999999999 days, 23:59:59.999999")
 
+        # test the Doc/library/datetime.rst recipe
+        eq(f'-({-td(hours=-1)!s})', "-(1:00:00)")
+
     def test_repr(self):
         name = 'datetime.' + self.theclass.__name__
         self.assertEqual(repr(self.theclass(1)),
@@ -1331,6 +1347,11 @@ def test_insane_fromtimestamp(self):
             self.assertRaises(OverflowError, self.theclass.fromtimestamp,
                               insane)
 
+    def test_fromtimestamp_with_none_arg(self):
+        # See gh-120268 for more details
+        with self.assertRaises(TypeError):
+            self.theclass.fromtimestamp(None)
+
     def test_today(self):
         import time
 
@@ -1498,8 +1519,7 @@ def test_strftime(self):
         # bpo-41260: The parameter was named "fmt" in the pure python impl.
         t.strftime(format="%f")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_strftime_trailing_percent(self):
         # bpo-35066: Make sure trailing '%' doesn't cause datetime's strftime to
         # complain. Different libcs have different handling of trailing
@@ -1600,8 +1620,7 @@ def test_pickling(self):
             self.assertEqual(orig, derived)
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ndate\n(S'\\x07\\xdf\\x0b\\x1b'\ntR.",
@@ -1703,29 +1722,44 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
 
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4)):
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     def test_subclass_replace(self):
         class DateSubclass(self.theclass):
-            pass
+            def __new__(cls, *args, **kwargs):
+                result = self.theclass.__new__(cls, *args, **kwargs)
+                result.extra = 7
+                return result
 
         dt = DateSubclass(2012, 1, 1)
-        self.assertIs(type(dt.replace(year=2013)), DateSubclass)
+
+        test_cases = [
+            ('self.replace', dt.replace(year=2013)),
+            ('copy.replace', copy.replace(dt, year=2013)),
+        ]
+
+        for name, res in test_cases:
+            with self.subTest(name):
+                self.assertIs(type(res), DateSubclass)
+                self.assertEqual(res.year, 2013)
+                self.assertEqual(res.month, 1)
+                self.assertEqual(res.extra, 7)
 
     def test_subclass_date(self):
 
@@ -1912,6 +1946,10 @@ def test_fromisoformat_fails(self):
             '2009-02-29',       # Invalid leap day
             '2019-W53-1',       # No week 53 in 2019
             '2020-W54-1',       # No week 54
+            '0000-W25-1',       # Invalid year
+            '10000-W25-1',      # Invalid year
+            '2020-W25-0',       # Invalid day-of-week
+            '2020-W25-8',       # Invalid day-of-week
             '2009\ud80002\ud80028',     # Separators are surrogate codepoints
         ]
 
@@ -2369,8 +2407,7 @@ def test_pickling_subclass_datetime(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassDatetime))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n('
@@ -2780,6 +2817,20 @@ def test_strptime_single_digit(self):
                 newdate = strptime(string, format)
                 self.assertEqual(newdate, target, msg=reason)
 
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)
+    def test_strptime_leap_year(self):
+        # GH-70647: warns if parsing a format with a day and no year.
+        with self.assertRaises(ValueError):
+            # The existing behavior that GH-70647 seeks to change.
+            self.theclass.strptime('02-29', '%m-%d')
+        with self.assertWarnsRegex(DeprecationWarning,
+                                   r'.*day of month without a year.*'):
+            self.theclass.strptime('03-14.159265', '%m-%d.%f')
+        with self._assertNotWarns(DeprecationWarning):
+            self.theclass.strptime('20-03-14.159265', '%y-%m-%d.%f')
+        with self._assertNotWarns(DeprecationWarning):
+            self.theclass.strptime('02-29,2024', '%m-%d,%Y')
+
     def test_more_timetuple(self):
         # This tests fields beyond those tested by the TestDate.test_timetuple.
         t = self.theclass(2004, 12, 31, 6, 22, 33)
@@ -2813,11 +2864,34 @@ def test_more_strftime(self):
             self.assertEqual(t.strftime("%z"), "-0200" + z)
             self.assertEqual(t.strftime("%:z"), "-02:00:" + z)
 
-        # bpo-34482: Check that surrogates don't cause a crash.
-        try:
-            t.strftime('%y\ud800%m %H\ud800%M')
-        except UnicodeEncodeError:
-            pass
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
+    def test_strftime_special(self):
+        t = self.theclass(2004, 12, 31, 6, 22, 33, 47)
+        s1 = t.strftime('%c')
+        s2 = t.strftime('%B')
+        # gh-52551, gh-78662: Unicode strings should pass through strftime,
+        # independently from locale.
+        self.assertEqual(t.strftime('\U0001f40d'), '\U0001f40d')
+        self.assertEqual(t.strftime('\U0001f4bb%c\U0001f40d%B'), f'\U0001f4bb{s1}\U0001f40d{s2}')
+        self.assertEqual(t.strftime('%c\U0001f4bb%B\U0001f40d'), f'{s1}\U0001f4bb{s2}\U0001f40d')
+        # Lone surrogates should pass through.
+        self.assertEqual(t.strftime('\ud83d'), '\ud83d')
+        self.assertEqual(t.strftime('\udc0d'), '\udc0d')
+        self.assertEqual(t.strftime('\ud83d%c\udc0d%B'), f'\ud83d{s1}\udc0d{s2}')
+        self.assertEqual(t.strftime('%c\ud83d%B\udc0d'), f'{s1}\ud83d{s2}\udc0d')
+        self.assertEqual(t.strftime('%c\udc0d%B\ud83d'), f'{s1}\udc0d{s2}\ud83d')
+        # Surrogate pairs should not recombine.
+        self.assertEqual(t.strftime('\ud83d\udc0d'), '\ud83d\udc0d')
+        self.assertEqual(t.strftime('%c\ud83d\udc0d%B'), f'{s1}\ud83d\udc0d{s2}')
+        # Surrogate-escaped bytes should not recombine.
+        self.assertEqual(t.strftime('\udcf0\udc9f\udc90\udc8d'), '\udcf0\udc9f\udc90\udc8d')
+        self.assertEqual(t.strftime('%c\udcf0\udc9f\udc90\udc8d%B'), f'{s1}\udcf0\udc9f\udc90\udc8d{s2}')
+        # gh-124531: The null character should not terminate the format string.
+        self.assertEqual(t.strftime('\0'), '\0')
+        self.assertEqual(t.strftime('\0'*1000), '\0'*1000)
+        self.assertEqual(t.strftime('\0%c\0%B'), f'\0{s1}\0{s2}')
+        self.assertEqual(t.strftime('%c\0%B\0'), f'{s1}\0{s2}\0')
 
     def test_extract(self):
         dt = self.theclass(2002, 3, 4, 18, 45, 3, 1234)
@@ -2862,26 +2936,27 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3, 4, 5, 6, 7]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4),
-                             ("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4),
+                   ("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     @support.run_with_tz('EDT4')
     def test_astimezone(self):
@@ -2943,8 +3018,6 @@ def newmeth(self, start):
         self.assertEqual(dt2.newmeth(-7), dt1.year + dt1.month +
                                           dt1.second - 7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclass_alternate_constructors_datetime(self):
         # Test that alternate constructors call the constructor
         class DateTimeSubclass(self.theclass):
@@ -3026,6 +3099,26 @@ def __new__(cls, *args, **kwargs):
                 self.assertIsInstance(dt, DateTimeSubclass)
                 self.assertEqual(dt.extra, 7)
 
+    def test_subclass_replace_fold(self):
+        class DateTimeSubclass(self.theclass):
+            pass
+
+        dt = DateTimeSubclass(2012, 1, 1)
+        dt2 = DateTimeSubclass(2012, 1, 1, fold=1)
+
+        test_cases = [
+            ('self.replace', dt.replace(year=2013), 0),
+            ('self.replace', dt2.replace(year=2013), 1),
+            ('copy.replace', copy.replace(dt, year=2013), 0),
+            ('copy.replace', copy.replace(dt2, year=2013), 1),
+        ]
+
+        for name, res, fold in test_cases:
+            with self.subTest(name, fold=fold):
+                self.assertIs(type(res), DateTimeSubclass)
+                self.assertEqual(res.year, 2013)
+                self.assertEqual(res.fold, fold)
+
     def test_fromisoformat_datetime(self):
         # Test that isoformat() is reversible
         base_dates = [
@@ -3303,6 +3396,9 @@ def test_fromisoformat_fails_datetime(self):
             '2009-04-19T12:30:45.123456-05:00a',    # Extra text
             '2009-04-19T12:30:45.123-05:00a',       # Extra text
             '2009-04-19T12:30:45-05:00a',           # Extra text
+            '2009-04-19T12:30:45.400 +02:30',  # Space between ms and timezone (gh-130959)
+            '2009-04-19T12:30:45.400 ',        # Trailing space (gh-130959)
+            '2009-04-19T12:30:45. 400',        # Space before fraction (gh-130959)
         ]
 
         for bad_str in bad_strs:
@@ -3572,6 +3668,35 @@ def test_strftime(self):
         # gh-85432: The parameter was named "fmt" in the pure-Python impl.
         t.strftime(format="%f")
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud83d' in position 0: surrogates not allowed
+    def test_strftime_special(self):
+        t = self.theclass(1, 2, 3, 4)
+        s1 = t.strftime('%I%p%Z')
+        s2 = t.strftime('%X')
+        # gh-52551, gh-78662: Unicode strings should pass through strftime,
+        # independently from locale.
+        self.assertEqual(t.strftime('\U0001f40d'), '\U0001f40d')
+        self.assertEqual(t.strftime('\U0001f4bb%I%p%Z\U0001f40d%X'), f'\U0001f4bb{s1}\U0001f40d{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\U0001f4bb%X\U0001f40d'), f'{s1}\U0001f4bb{s2}\U0001f40d')
+        # Lone surrogates should pass through.
+        self.assertEqual(t.strftime('\ud83d'), '\ud83d')
+        self.assertEqual(t.strftime('\udc0d'), '\udc0d')
+        self.assertEqual(t.strftime('\ud83d%I%p%Z\udc0d%X'), f'\ud83d{s1}\udc0d{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\ud83d%X\udc0d'), f'{s1}\ud83d{s2}\udc0d')
+        self.assertEqual(t.strftime('%I%p%Z\udc0d%X\ud83d'), f'{s1}\udc0d{s2}\ud83d')
+        # Surrogate pairs should not recombine.
+        self.assertEqual(t.strftime('\ud83d\udc0d'), '\ud83d\udc0d')
+        self.assertEqual(t.strftime('%I%p%Z\ud83d\udc0d%X'), f'{s1}\ud83d\udc0d{s2}')
+        # Surrogate-escaped bytes should not recombine.
+        self.assertEqual(t.strftime('\udcf0\udc9f\udc90\udc8d'), '\udcf0\udc9f\udc90\udc8d')
+        self.assertEqual(t.strftime('%I%p%Z\udcf0\udc9f\udc90\udc8d%X'), f'{s1}\udcf0\udc9f\udc90\udc8d{s2}')
+        # gh-124531: The null character should not terminate the format string.
+        self.assertEqual(t.strftime('\0'), '\0')
+        self.assertEqual(t.strftime('\0'*1000), '\0'*1000)
+        self.assertEqual(t.strftime('\0%I%p%Z\0%X'), f'\0{s1}\0{s2}')
+        self.assertEqual(t.strftime('%I%p%Z\0%X\0'), f'{s1}\0{s2}\0')
+
     def test_format(self):
         t = self.theclass(1, 2, 3, 4)
         self.assertEqual(t.__format__(''), str(t))
@@ -3643,8 +3768,7 @@ def test_pickling_subclass_time(self):
             self.assertEqual(orig, derived)
             self.assertTrue(isinstance(derived, SubclassTime))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             (b"cdatetime\ntime\n(S'\\x14;\\x10\\x00\\x10\\x00'\ntR.",
@@ -3681,19 +3805,19 @@ def test_replace(self):
         cls = self.theclass
         args = [1, 2, 3, 4]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Out of bounds.
         base = cls(1)
@@ -3701,13 +3825,35 @@ def test_replace(self):
         self.assertRaises(ValueError, base.replace, minute=-1)
         self.assertRaises(ValueError, base.replace, second=100)
         self.assertRaises(ValueError, base.replace, microsecond=1000000)
+        self.assertRaises(ValueError, copy.replace, base, hour=24)
+        self.assertRaises(ValueError, copy.replace, base, minute=-1)
+        self.assertRaises(ValueError, copy.replace, base, second=100)
+        self.assertRaises(ValueError, copy.replace, base, microsecond=1000000)
 
     def test_subclass_replace(self):
         class TimeSubclass(self.theclass):
-            pass
+            def __new__(cls, *args, **kwargs):
+                result = self.theclass.__new__(cls, *args, **kwargs)
+                result.extra = 7
+                return result
 
         ctime = TimeSubclass(12, 30)
-        self.assertIs(type(ctime.replace(hour=10)), TimeSubclass)
+        ctime2 = TimeSubclass(12, 30, fold=1)
+
+        test_cases = [
+            ('self.replace', ctime.replace(hour=10), 0),
+            ('self.replace', ctime2.replace(hour=10), 1),
+            ('copy.replace', copy.replace(ctime, hour=10), 0),
+            ('copy.replace', copy.replace(ctime2, hour=10), 1),
+        ]
+
+        for name, res, fold in test_cases:
+            with self.subTest(name, fold=fold):
+                self.assertIs(type(res), TimeSubclass)
+                self.assertEqual(res.hour, 10)
+                self.assertEqual(res.minute, 30)
+                self.assertEqual(res.extra, 7)
+                self.assertEqual(res.fold, fold)
 
     def test_subclass_time(self):
 
@@ -3920,6 +4066,8 @@ def test_empty(self):
         self.assertEqual(t.microsecond, 0)
         self.assertIsNone(t.tzinfo)
 
+    @unittest.skip('TODO: RUSTPYTHON')
+    # UnicodeEncodeError: 'utf-8' codec can't encode character '\ud800' in position 0: surrogates not allowed
     def test_zones(self):
         est = FixedOffset(-300, "EST", 1)
         utc = FixedOffset(0, "UTC", -2)
@@ -4003,9 +4151,8 @@ def tzname(self, dt): return self.tz
         self.assertRaises(TypeError, t.strftime, "%Z")
 
         # Issue #6697:
-        if '_Fast' in self.__class__.__name__:
-            Badtzname.tz = '\ud800'
-            self.assertRaises(ValueError, t.strftime, "%Z")
+        Badtzname.tz = '\ud800'
+        self.assertEqual(t.strftime("%Z"), '\ud800')
 
     def test_hash_edge_cases(self):
         # Offsets that overflow a basic time.
@@ -4039,8 +4186,7 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b"cdatetime\ntime\n(S'\\x05\\x06\\x07\\x01\\xe2@'\n"
@@ -4097,31 +4243,37 @@ def test_replace(self):
         zm200 = FixedOffset(timedelta(minutes=-200), "-200")
         args = [1, 2, 3, 4, z100]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8),
-                             ("tzinfo", zm200)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8),
+                   ("tzinfo", zm200))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Ensure we can get rid of a tzinfo.
         self.assertEqual(base.tzname(), "+100")
         base2 = base.replace(tzinfo=None)
         self.assertIsNone(base2.tzinfo)
         self.assertIsNone(base2.tzname())
+        base22 = copy.replace(base, tzinfo=None)
+        self.assertIsNone(base22.tzinfo)
+        self.assertIsNone(base22.tzname())
 
         # Ensure we can add one.
         base3 = base2.replace(tzinfo=z100)
         self.assertEqual(base, base3)
         self.assertIs(base.tzinfo, base3.tzinfo)
+        base32 = copy.replace(base22, tzinfo=z100)
+        self.assertEqual(base, base32)
+        self.assertIs(base.tzinfo, base32.tzinfo)
 
         # Out of bounds.
         base = cls(1)
@@ -4129,6 +4281,10 @@ def test_replace(self):
         self.assertRaises(ValueError, base.replace, minute=-1)
         self.assertRaises(ValueError, base.replace, second=100)
         self.assertRaises(ValueError, base.replace, microsecond=1000000)
+        self.assertRaises(ValueError, copy.replace, base, hour=24)
+        self.assertRaises(ValueError, copy.replace, base, minute=-1)
+        self.assertRaises(ValueError, copy.replace, base, second=100)
+        self.assertRaises(ValueError, copy.replace, base, microsecond=1000000)
 
     def test_mixed_compare(self):
         t1 = self.theclass(1, 2, 3)
@@ -4333,6 +4489,9 @@ def test_fromisoformat_fails(self):
             '12:30:45.123456-',         # Extra at end of microsecond time
             '12:30:45.123456+',         # Extra at end of microsecond time
             '12:30:45.123456+12:00:30a',    # Extra at end of full time
+            '12:30:45.400 +02:30',      # Space between ms and timezone (gh-130959)
+            '12:30:45.400 ',            # Trailing space (gh-130959)
+            '12:30:45. 400',            # Space before fraction (gh-130959)
         ]
 
         for bad_str in bad_strs:
@@ -4493,8 +4652,7 @@ def test_pickling(self):
             self.assertEqual(derived.tzname(), 'cookie')
         self.assertEqual(orig.__reduce__(), orig.__reduce_ex__(2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compat_unpickle(self):
         tests = [
             b'cdatetime\ndatetime\n'
@@ -4899,38 +5057,45 @@ def test_replace(self):
         zm200 = FixedOffset(timedelta(minutes=-200), "-200")
         args = [1, 2, 3, 4, 5, 6, 7, z100]
         base = cls(*args)
-        self.assertEqual(base, base.replace())
-
-        i = 0
-        for name, newval in (("year", 2),
-                             ("month", 3),
-                             ("day", 4),
-                             ("hour", 5),
-                             ("minute", 6),
-                             ("second", 7),
-                             ("microsecond", 8),
-                             ("tzinfo", zm200)):
+        self.assertEqual(base.replace(), base)
+        self.assertEqual(copy.replace(base), base)
+
+        changes = (("year", 2),
+                   ("month", 3),
+                   ("day", 4),
+                   ("hour", 5),
+                   ("minute", 6),
+                   ("second", 7),
+                   ("microsecond", 8),
+                   ("tzinfo", zm200))
+        for i, (name, newval) in enumerate(changes):
             newargs = args[:]
             newargs[i] = newval
             expected = cls(*newargs)
-            got = base.replace(**{name: newval})
-            self.assertEqual(expected, got)
-            i += 1
+            self.assertEqual(base.replace(**{name: newval}), expected)
+            self.assertEqual(copy.replace(base, **{name: newval}), expected)
 
         # Ensure we can get rid of a tzinfo.
         self.assertEqual(base.tzname(), "+100")
         base2 = base.replace(tzinfo=None)
         self.assertIsNone(base2.tzinfo)
         self.assertIsNone(base2.tzname())
+        base22 = copy.replace(base, tzinfo=None)
+        self.assertIsNone(base22.tzinfo)
+        self.assertIsNone(base22.tzname())
 
         # Ensure we can add one.
         base3 = base2.replace(tzinfo=z100)
         self.assertEqual(base, base3)
         self.assertIs(base.tzinfo, base3.tzinfo)
+        base32 = copy.replace(base22, tzinfo=z100)
+        self.assertEqual(base, base32)
+        self.assertIs(base.tzinfo, base32.tzinfo)
 
         # Out of bounds.
         base = cls(2000, 2, 29)
         self.assertRaises(ValueError, base.replace, year=2001)
+        self.assertRaises(ValueError, copy.replace, base, year=2001)
 
     def test_more_astimezone(self):
         # The inherited test_astimezone covered some trivial and error cases.
@@ -5420,45 +5585,51 @@ def fromutc(self, dt):
 
 class Oddballs(unittest.TestCase):
 
-    def test_bug_1028306(self):
+    def test_date_datetime_comparison(self):
+        # bpo-1028306, bpo-5516 (gh-49766)
         # Trying to compare a date to a datetime should act like a mixed-
         # type comparison, despite that datetime is a subclass of date.
         as_date = date.today()
         as_datetime = datetime.combine(as_date, time())
-        self.assertTrue(as_date != as_datetime)
-        self.assertTrue(as_datetime != as_date)
-        self.assertFalse(as_date == as_datetime)
-        self.assertFalse(as_datetime == as_date)
-        self.assertRaises(TypeError, lambda: as_date < as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime < as_date)
-        self.assertRaises(TypeError, lambda: as_date <= as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime <= as_date)
-        self.assertRaises(TypeError, lambda: as_date > as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime > as_date)
-        self.assertRaises(TypeError, lambda: as_date >= as_datetime)
-        self.assertRaises(TypeError, lambda: as_datetime >= as_date)
-
-        # Nevertheless, comparison should work with the base-class (date)
-        # projection if use of a date method is forced.
-        self.assertEqual(as_date.__eq__(as_datetime), True)
-        different_day = (as_date.day + 1) % 20 + 1
-        as_different = as_datetime.replace(day= different_day)
-        self.assertEqual(as_date.__eq__(as_different), False)
+        date_sc = SubclassDate(as_date.year, as_date.month, as_date.day)
+        datetime_sc = SubclassDatetime(as_date.year, as_date.month,
+                                       as_date.day, 0, 0, 0)
+        for d in (as_date, date_sc):
+            for dt in (as_datetime, datetime_sc):
+                for x, y in (d, dt), (dt, d):
+                    self.assertTrue(x != y)
+                    self.assertFalse(x == y)
+                    self.assertRaises(TypeError, lambda: x < y)
+                    self.assertRaises(TypeError, lambda: x <= y)
+                    self.assertRaises(TypeError, lambda: x > y)
+                    self.assertRaises(TypeError, lambda: x >= y)
 
         # And date should compare with other subclasses of date.  If a
         # subclass wants to stop this, it's up to the subclass to do so.
-        date_sc = SubclassDate(as_date.year, as_date.month, as_date.day)
-        self.assertEqual(as_date, date_sc)
-        self.assertEqual(date_sc, as_date)
-
         # Ditto for datetimes.
-        datetime_sc = SubclassDatetime(as_datetime.year, as_datetime.month,
-                                       as_date.day, 0, 0, 0)
-        self.assertEqual(as_datetime, datetime_sc)
-        self.assertEqual(datetime_sc, as_datetime)
+        for x, y in ((as_date, date_sc),
+                     (date_sc, as_date),
+                     (as_datetime, datetime_sc),
+                     (datetime_sc, as_datetime)):
+            self.assertTrue(x == y)
+            self.assertFalse(x != y)
+            self.assertFalse(x < y)
+            self.assertFalse(x > y)
+            self.assertTrue(x <= y)
+            self.assertTrue(x >= y)
+
+        # Nevertheless, comparison should work if other object is an instance
+        # of date or datetime class with overridden comparison operators.
+        # So special methods should return NotImplemented, as if
+        # date and datetime were independent classes.
+        for x, y in (as_date, as_datetime), (as_datetime, as_date):
+            self.assertEqual(x.__eq__(y), NotImplemented)
+            self.assertEqual(x.__ne__(y), NotImplemented)
+            self.assertEqual(x.__lt__(y), NotImplemented)
+            self.assertEqual(x.__gt__(y), NotImplemented)
+            self.assertEqual(x.__gt__(y), NotImplemented)
+            self.assertEqual(x.__ge__(y), NotImplemented)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_extra_attributes(self):
         with self.assertWarns(DeprecationWarning):
             utcnow = datetime.utcnow()
@@ -6683,6 +6854,126 @@ def test_datetime_from_timestamp(self):
 
                     self.assertEqual(dt_orig, dt_rt)
 
+    def test_type_check_in_subinterp(self):
+        # iOS requires the use of the custom framework loader,
+        # not the ExtensionFileLoader.
+        if sys.platform == "ios":
+            extension_loader = "AppleFrameworkLoader"
+        else:
+            extension_loader = "ExtensionFileLoader"
+
+        script = textwrap.dedent(f"""
+            if {_interpreters is None}:
+                import _testcapi as module
+                module.test_datetime_capi()
+            else:
+                import importlib.machinery
+                import importlib.util
+                fullname = '_testcapi_datetime'
+                origin = importlib.util.find_spec('_testcapi').origin
+                loader = importlib.machinery.{extension_loader}(fullname, origin)
+                spec = importlib.util.spec_from_loader(fullname, loader)
+                module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(module)
+
+            def run(type_checker, obj):
+                if not type_checker(obj, True):
+                    raise TypeError(f'{{type(obj)}} is not C API type')
+
+            import _datetime
+            run(module.datetime_check_date,     _datetime.date.today())
+            run(module.datetime_check_datetime, _datetime.datetime.now())
+            run(module.datetime_check_time,     _datetime.time(12, 30))
+            run(module.datetime_check_delta,    _datetime.timedelta(1))
+            run(module.datetime_check_tzinfo,   _datetime.tzinfo())
+        """)
+        if _interpreters is None:
+            ret = support.run_in_subinterp(script)
+            self.assertEqual(ret, 0)
+        else:
+            for name in ('isolated', 'legacy'):
+                with self.subTest(name):
+                    config = _interpreters.new_config(name).__dict__
+                    ret = support.run_in_subinterp_with_config(script, **config)
+                    self.assertEqual(ret, 0)
+
+
+class ExtensionModuleTests(unittest.TestCase):
+
+    def setUp(self):
+        if self.__class__.__name__.endswith('Pure'):
+            self.skipTest('Not relevant in pure Python')
+
+    @support.cpython_only
+    def test_gh_120161(self):
+        with self.subTest('simple'):
+            script = textwrap.dedent("""
+                import datetime
+                from _ast import Tuple
+                f = lambda: None
+                Tuple.dims = property(f, f)
+
+                class tzutc(datetime.tzinfo):
+                    pass
+                """)
+            script_helper.assert_python_ok('-c', script)
+
+        with self.subTest('complex'):
+            script = textwrap.dedent("""
+                import asyncio
+                import datetime
+                from typing import Type
+
+                class tzutc(datetime.tzinfo):
+                    pass
+                _EPOCHTZ = datetime.datetime(1970, 1, 1, tzinfo=tzutc())
+
+                class FakeDateMeta(type):
+                    def __instancecheck__(self, obj):
+                        return True
+                class FakeDate(datetime.date, metaclass=FakeDateMeta):
+                    pass
+                def pickle_fake_date(datetime_) -> Type[FakeDate]:
+                    # A pickle function for FakeDate
+                    return FakeDate
+                """)
+            script_helper.assert_python_ok('-c', script)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: Process return code is 1
+    @unittest.expectedFailure
+    def test_update_type_cache(self):
+        # gh-120782
+        script = textwrap.dedent("""
+            import sys
+            for i in range(5):
+                import _datetime
+                assert _datetime.date.max > _datetime.date.min
+                assert _datetime.time.max > _datetime.time.min
+                assert _datetime.datetime.max > _datetime.datetime.min
+                assert _datetime.timedelta.max > _datetime.timedelta.min
+                assert _datetime.date.__dict__["min"] is _datetime.date.min
+                assert _datetime.date.__dict__["max"] is _datetime.date.max
+                assert _datetime.date.__dict__["resolution"] is _datetime.date.resolution
+                assert _datetime.time.__dict__["min"] is _datetime.time.min
+                assert _datetime.time.__dict__["max"] is _datetime.time.max
+                assert _datetime.time.__dict__["resolution"] is _datetime.time.resolution
+                assert _datetime.datetime.__dict__["min"] is _datetime.datetime.min
+                assert _datetime.datetime.__dict__["max"] is _datetime.datetime.max
+                assert _datetime.datetime.__dict__["resolution"] is _datetime.datetime.resolution
+                assert _datetime.timedelta.__dict__["min"] is _datetime.timedelta.min
+                assert _datetime.timedelta.__dict__["max"] is _datetime.timedelta.max
+                assert _datetime.timedelta.__dict__["resolution"] is _datetime.timedelta.resolution
+                assert _datetime.timezone.__dict__["min"] is _datetime.timezone.min
+                assert _datetime.timezone.__dict__["max"] is _datetime.timezone.max
+                assert _datetime.timezone.__dict__["utc"] is _datetime.timezone.utc
+                assert isinstance(_datetime.timezone.min, _datetime.tzinfo)
+                assert isinstance(_datetime.timezone.max, _datetime.tzinfo)
+                assert isinstance(_datetime.timezone.utc, _datetime.tzinfo)
+                del sys.modules['_datetime']
+            """)
+        script_helper.assert_python_ok('-c', script)
+
 
 def load_tests(loader, standard_tests, pattern):
     standard_tests.addTest(ZoneInfoCompleteTest())
diff --git a/Lib/test/decimaltestdata/abs.decTest b/Lib/test/decimaltestdata/abs.decTest
index 01f73d7766..569b8fcd84 100644
--- a/Lib/test/decimaltestdata/abs.decTest
+++ b/Lib/test/decimaltestdata/abs.decTest
@@ -20,7 +20,7 @@
 version: 2.59
 
 -- This set of tests primarily tests the existence of the operator.
--- Additon, subtraction, rounding, and more overflows are tested
+-- Addition, subtraction, rounding, and more overflows are tested
 -- elsewhere.
 
 precision:   9
diff --git a/Lib/test/decimaltestdata/ddFMA.decTest b/Lib/test/decimaltestdata/ddFMA.decTest
index 9094fc015b..7f2e523037 100644
--- a/Lib/test/decimaltestdata/ddFMA.decTest
+++ b/Lib/test/decimaltestdata/ddFMA.decTest
@@ -1663,7 +1663,7 @@ ddfma375087 fma  1  12345678 1E-33                   -> 12345678.00000001 Inexac
 ddfma375088 fma  1  12345678 1E-34                   -> 12345678.00000001 Inexact Rounded
 ddfma375089 fma  1  12345678 1E-35                   -> 12345678.00000001 Inexact Rounded
 
--- desctructive subtraction (from remainder tests)
+-- destructive subtraction (from remainder tests)
 
 -- +++ some of these will be off-by-one remainder vs remainderNear
 
diff --git a/Lib/test/decimaltestdata/ddQuantize.decTest b/Lib/test/decimaltestdata/ddQuantize.decTest
index 9177620169..e1c5674d9a 100644
--- a/Lib/test/decimaltestdata/ddQuantize.decTest
+++ b/Lib/test/decimaltestdata/ddQuantize.decTest
@@ -462,7 +462,7 @@ ddqua520 quantize   1.234    1e359 -> 0E+359 Inexact Rounded
 ddqua521 quantize 123.456    1e359 -> 0E+359 Inexact Rounded
 ddqua522 quantize   1.234    1e359 -> 0E+359 Inexact Rounded
 ddqua523 quantize 123.456    1e359 -> 0E+359 Inexact Rounded
--- next four are "won't fit" overfl
+-- next four are "won't fit" overflow
 ddqua526 quantize   1.234   1e-299 -> NaN Invalid_operation
 ddqua527 quantize 123.456   1e-299 -> NaN Invalid_operation
 ddqua528 quantize   1.234   1e-299 -> NaN Invalid_operation
diff --git a/Lib/test/decimaltestdata/ddRemainder.decTest b/Lib/test/decimaltestdata/ddRemainder.decTest
index 5bd1e32d01..b1866d39a2 100644
--- a/Lib/test/decimaltestdata/ddRemainder.decTest
+++ b/Lib/test/decimaltestdata/ddRemainder.decTest
@@ -422,7 +422,7 @@ ddrem757 remainder  1    sNaN   ->  NaN  Invalid_operation
 ddrem758 remainder  1000 sNaN   ->  NaN  Invalid_operation
 ddrem759 remainder  Inf -sNaN   -> -NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 ddrem760 remainder  NaN1   NaN7   ->  NaN1
 ddrem761 remainder sNaN2   NaN8   ->  NaN2 Invalid_operation
 ddrem762 remainder  NaN3  sNaN9   ->  NaN9 Invalid_operation
diff --git a/Lib/test/decimaltestdata/ddRemainderNear.decTest b/Lib/test/decimaltestdata/ddRemainderNear.decTest
index 6ba64ebafe..bbe82ea374 100644
--- a/Lib/test/decimaltestdata/ddRemainderNear.decTest
+++ b/Lib/test/decimaltestdata/ddRemainderNear.decTest
@@ -450,7 +450,7 @@ ddrmn757 remaindernear  1    sNaN   ->  NaN  Invalid_operation
 ddrmn758 remaindernear  1000 sNaN   ->  NaN  Invalid_operation
 ddrmn759 remaindernear  Inf -sNaN   -> -NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 ddrmn760 remaindernear  NaN1   NaN7   ->  NaN1
 ddrmn761 remaindernear sNaN2   NaN8   ->  NaN2 Invalid_operation
 ddrmn762 remaindernear  NaN3  sNaN9   ->  NaN9 Invalid_operation
diff --git a/Lib/test/decimaltestdata/dqRemainder.decTest b/Lib/test/decimaltestdata/dqRemainder.decTest
index bae8eae526..e0aaca3747 100644
--- a/Lib/test/decimaltestdata/dqRemainder.decTest
+++ b/Lib/test/decimaltestdata/dqRemainder.decTest
@@ -418,7 +418,7 @@ dqrem757 remainder  1    sNaN   ->  NaN  Invalid_operation
 dqrem758 remainder  1000 sNaN   ->  NaN  Invalid_operation
 dqrem759 remainder  Inf -sNaN   -> -NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 dqrem760 remainder  NaN1   NaN7   ->  NaN1
 dqrem761 remainder sNaN2   NaN8   ->  NaN2 Invalid_operation
 dqrem762 remainder  NaN3  sNaN9   ->  NaN9 Invalid_operation
diff --git a/Lib/test/decimaltestdata/dqRemainderNear.decTest b/Lib/test/decimaltestdata/dqRemainderNear.decTest
index b850626fe4..2c5c3f5074 100644
--- a/Lib/test/decimaltestdata/dqRemainderNear.decTest
+++ b/Lib/test/decimaltestdata/dqRemainderNear.decTest
@@ -450,7 +450,7 @@ dqrmn757 remaindernear  1    sNaN   ->  NaN  Invalid_operation
 dqrmn758 remaindernear  1000 sNaN   ->  NaN  Invalid_operation
 dqrmn759 remaindernear  Inf -sNaN   -> -NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 dqrmn760 remaindernear  NaN1   NaN7   ->  NaN1
 dqrmn761 remaindernear sNaN2   NaN8   ->  NaN2 Invalid_operation
 dqrmn762 remaindernear  NaN3  sNaN9   ->  NaN9 Invalid_operation
diff --git a/Lib/test/decimaltestdata/exp.decTest b/Lib/test/decimaltestdata/exp.decTest
index 6a7af23b62..e01d7a8f92 100644
--- a/Lib/test/decimaltestdata/exp.decTest
+++ b/Lib/test/decimaltestdata/exp.decTest
@@ -28,7 +28,7 @@ rounding:    half_even
 maxExponent: 384
 minexponent: -383
 
--- basics (examples in specificiation, etc.)
+-- basics (examples in specification, etc.)
 expx001 exp  -Infinity     -> 0
 expx002 exp  -10           -> 0.0000453999298 Inexact Rounded
 expx003 exp  -1            -> 0.367879441 Inexact Rounded
diff --git a/Lib/test/decimaltestdata/extra.decTest b/Lib/test/decimaltestdata/extra.decTest
index b630d8e3f9..31291202a3 100644
--- a/Lib/test/decimaltestdata/extra.decTest
+++ b/Lib/test/decimaltestdata/extra.decTest
@@ -156,7 +156,7 @@ extr1302 fma -Inf 0E-456 sNaN148 -> NaN Invalid_operation
 
 -- max/min/max_mag/min_mag bug in 2.5.2/2.6/3.0: max(NaN, finite) gave
 -- incorrect answers when the finite number required rounding; similarly
--- for the other thre functions
+-- for the other three functions
 maxexponent: 999
 minexponent: -999
 precision: 6
diff --git a/Lib/test/decimaltestdata/remainder.decTest b/Lib/test/decimaltestdata/remainder.decTest
index 7a1061b1e6..4f59b33287 100644
--- a/Lib/test/decimaltestdata/remainder.decTest
+++ b/Lib/test/decimaltestdata/remainder.decTest
@@ -435,7 +435,7 @@ remx757 remainder  1    sNaN   ->  NaN  Invalid_operation
 remx758 remainder  1000 sNaN   ->  NaN  Invalid_operation
 remx759 remainder  Inf -sNaN   -> -NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 remx760 remainder  NaN1   NaN7   ->  NaN1
 remx761 remainder sNaN2   NaN8   ->  NaN2 Invalid_operation
 remx762 remainder  NaN3  sNaN9   ->  NaN9 Invalid_operation
diff --git a/Lib/test/decimaltestdata/remainderNear.decTest b/Lib/test/decimaltestdata/remainderNear.decTest
index b768b9e0cf..000b1424d8 100644
--- a/Lib/test/decimaltestdata/remainderNear.decTest
+++ b/Lib/test/decimaltestdata/remainderNear.decTest
@@ -498,7 +498,7 @@ rmnx758 remaindernear  1000 sNaN   ->  NaN  Invalid_operation
 rmnx759 remaindernear  Inf  sNaN   ->  NaN  Invalid_operation
 rmnx760 remaindernear  NaN  sNaN   ->  NaN  Invalid_operation
 
--- propaging NaNs
+-- propagating NaNs
 rmnx761 remaindernear  NaN1   NaN7   ->  NaN1
 rmnx762 remaindernear sNaN2   NaN8   ->  NaN2 Invalid_operation
 rmnx763 remaindernear  NaN3 -sNaN9   -> -NaN9 Invalid_operation
diff --git a/Lib/test/dtracedata/assert_usable.d b/Lib/test/dtracedata/assert_usable.d
new file mode 100644
index 0000000000..0b2d4da66e
--- /dev/null
+++ b/Lib/test/dtracedata/assert_usable.d
@@ -0,0 +1,5 @@
+BEGIN
+{
+    printf("probe: success\n");
+    exit(0);
+}
diff --git a/Lib/test/dtracedata/assert_usable.stp b/Lib/test/dtracedata/assert_usable.stp
new file mode 100644
index 0000000000..88e7e68e2c
--- /dev/null
+++ b/Lib/test/dtracedata/assert_usable.stp
@@ -0,0 +1,5 @@
+probe begin
+{
+  println("probe: success")
+  exit ()
+}
diff --git a/Lib/test/dtracedata/call_stack.d b/Lib/test/dtracedata/call_stack.d
new file mode 100644
index 0000000000..761d30fd55
--- /dev/null
+++ b/Lib/test/dtracedata/call_stack.d
@@ -0,0 +1,31 @@
+self int indent;
+
+python$target:::function-entry
+/copyinstr(arg1) == "start"/
+{
+    self->trace = 1;
+}
+
+python$target:::function-entry
+/self->trace/
+{
+    printf("%d\t%*s:", timestamp, 15, probename);
+    printf("%*s", self->indent, "");
+    printf("%s:%s:%d\n", basename(copyinstr(arg0)), copyinstr(arg1), arg2);
+    self->indent++;
+}
+
+python$target:::function-return
+/self->trace/
+{
+    self->indent--;
+    printf("%d\t%*s:", timestamp, 15, probename);
+    printf("%*s", self->indent, "");
+    printf("%s:%s:%d\n", basename(copyinstr(arg0)), copyinstr(arg1), arg2);
+}
+
+python$target:::function-return
+/copyinstr(arg1) == "start"/
+{
+    self->trace = 0;
+}
diff --git a/Lib/test/dtracedata/call_stack.d.expected b/Lib/test/dtracedata/call_stack.d.expected
new file mode 100644
index 0000000000..27849d1549
--- /dev/null
+++ b/Lib/test/dtracedata/call_stack.d.expected
@@ -0,0 +1,18 @@
+ function-entry:call_stack.py:start:23
+ function-entry: call_stack.py:function_1:1
+ function-entry:  call_stack.py:function_3:9
+function-return:  call_stack.py:function_3:10
+function-return: call_stack.py:function_1:2
+ function-entry: call_stack.py:function_2:5
+ function-entry:  call_stack.py:function_1:1
+ function-entry:   call_stack.py:function_3:9
+function-return:   call_stack.py:function_3:10
+function-return:  call_stack.py:function_1:2
+function-return: call_stack.py:function_2:6
+ function-entry: call_stack.py:function_3:9
+function-return: call_stack.py:function_3:10
+ function-entry: call_stack.py:function_4:13
+function-return: call_stack.py:function_4:14
+ function-entry: call_stack.py:function_5:18
+function-return: call_stack.py:function_5:21
+function-return:call_stack.py:start:28
diff --git a/Lib/test/dtracedata/call_stack.py b/Lib/test/dtracedata/call_stack.py
new file mode 100644
index 0000000000..ee9f3ae8d6
--- /dev/null
+++ b/Lib/test/dtracedata/call_stack.py
@@ -0,0 +1,30 @@
+def function_1():
+    function_3(1, 2)
+
+# Check stacktrace
+def function_2():
+    function_1()
+
+# CALL_FUNCTION_VAR
+def function_3(dummy, dummy2):
+    pass
+
+# CALL_FUNCTION_KW
+def function_4(**dummy):
+    return 1
+    return 2  # unreachable
+
+# CALL_FUNCTION_VAR_KW
+def function_5(dummy, dummy2, **dummy3):
+    if False:
+        return 7
+    return 8
+
+def start():
+    function_1()
+    function_2()
+    function_3(1, 2)
+    function_4(test=42)
+    function_5(*(1, 2), **{"test": 42})
+
+start()
diff --git a/Lib/test/dtracedata/call_stack.stp b/Lib/test/dtracedata/call_stack.stp
new file mode 100644
index 0000000000..54082c202f
--- /dev/null
+++ b/Lib/test/dtracedata/call_stack.stp
@@ -0,0 +1,41 @@
+global tracing
+
+function basename:string(path:string)
+{
+    last_token = token = tokenize(path, "/");
+    while (token != "") {
+        last_token = token;
+        token = tokenize("", "/");
+    }
+    return last_token;
+}
+
+probe process.mark("function__entry")
+{
+    funcname = user_string($arg2);
+
+    if (funcname == "start") {
+        tracing = 1;
+    }
+}
+
+probe process.mark("function__entry"), process.mark("function__return")
+{
+    filename = user_string($arg1);
+    funcname = user_string($arg2);
+    lineno = $arg3;
+
+    if (tracing) {
+        printf("%d\t%s:%s:%s:%d\n", gettimeofday_us(), $$name,
+               basename(filename), funcname, lineno);
+    }
+}
+
+probe process.mark("function__return")
+{
+    funcname = user_string($arg2);
+
+    if (funcname == "start") {
+        tracing = 0;
+    }
+}
diff --git a/Lib/test/dtracedata/call_stack.stp.expected b/Lib/test/dtracedata/call_stack.stp.expected
new file mode 100644
index 0000000000..32cf396f82
--- /dev/null
+++ b/Lib/test/dtracedata/call_stack.stp.expected
@@ -0,0 +1,14 @@
+function__entry:call_stack.py:start:23
+function__entry:call_stack.py:function_1:1
+function__return:call_stack.py:function_1:2
+function__entry:call_stack.py:function_2:5
+function__entry:call_stack.py:function_1:1
+function__return:call_stack.py:function_1:2
+function__return:call_stack.py:function_2:6
+function__entry:call_stack.py:function_3:9
+function__return:call_stack.py:function_3:10
+function__entry:call_stack.py:function_4:13
+function__return:call_stack.py:function_4:14
+function__entry:call_stack.py:function_5:18
+function__return:call_stack.py:function_5:21
+function__return:call_stack.py:start:28
diff --git a/Lib/test/dtracedata/gc.d b/Lib/test/dtracedata/gc.d
new file mode 100644
index 0000000000..4d91487b7e
--- /dev/null
+++ b/Lib/test/dtracedata/gc.d
@@ -0,0 +1,18 @@
+python$target:::function-entry
+/copyinstr(arg1) == "start"/
+{
+    self->trace = 1;
+}
+
+python$target:::gc-start,
+python$target:::gc-done
+/self->trace/
+{
+    printf("%d\t%s:%ld\n", timestamp, probename, arg0);
+}
+
+python$target:::function-return
+/copyinstr(arg1) == "start"/
+{
+    self->trace = 0;
+}
diff --git a/Lib/test/dtracedata/gc.d.expected b/Lib/test/dtracedata/gc.d.expected
new file mode 100644
index 0000000000..8e5ac2a6d5
--- /dev/null
+++ b/Lib/test/dtracedata/gc.d.expected
@@ -0,0 +1,8 @@
+gc-start:0
+gc-done:0
+gc-start:1
+gc-done:0
+gc-start:2
+gc-done:0
+gc-start:2
+gc-done:1
diff --git a/Lib/test/dtracedata/gc.py b/Lib/test/dtracedata/gc.py
new file mode 100644
index 0000000000..144a783b7b
--- /dev/null
+++ b/Lib/test/dtracedata/gc.py
@@ -0,0 +1,13 @@
+import gc
+
+def start():
+    gc.collect(0)
+    gc.collect(1)
+    gc.collect(2)
+    l = []
+    l.append(l)
+    del l
+    gc.collect(2)
+
+gc.collect()
+start()
diff --git a/Lib/test/dtracedata/gc.stp b/Lib/test/dtracedata/gc.stp
new file mode 100644
index 0000000000..162c6d3a22
--- /dev/null
+++ b/Lib/test/dtracedata/gc.stp
@@ -0,0 +1,26 @@
+global tracing
+
+probe process.mark("function__entry")
+{
+    funcname = user_string($arg2);
+
+    if (funcname == "start") {
+        tracing = 1;
+    }
+}
+
+probe process.mark("gc__start"), process.mark("gc__done")
+{
+    if (tracing) {
+        printf("%d\t%s:%ld\n", gettimeofday_us(), $$name, $arg1);
+    }
+}
+
+probe process.mark("function__return")
+{
+    funcname = user_string($arg2);
+
+    if (funcname == "start") {
+        tracing = 0;
+    }
+}
diff --git a/Lib/test/dtracedata/gc.stp.expected b/Lib/test/dtracedata/gc.stp.expected
new file mode 100644
index 0000000000..7e6e6227fb
--- /dev/null
+++ b/Lib/test/dtracedata/gc.stp.expected
@@ -0,0 +1,8 @@
+gc__start:0
+gc__done:0
+gc__start:1
+gc__done:0
+gc__start:2
+gc__done:0
+gc__start:2
+gc__done:1
diff --git a/Lib/test/dtracedata/instance.py b/Lib/test/dtracedata/instance.py
new file mode 100644
index 0000000000..f1421378b0
--- /dev/null
+++ b/Lib/test/dtracedata/instance.py
@@ -0,0 +1,24 @@
+import gc
+
+class old_style_class():
+    pass
+class new_style_class(object):
+    pass
+
+a = old_style_class()
+del a
+gc.collect()
+b = new_style_class()
+del b
+gc.collect()
+
+a = old_style_class()
+del old_style_class
+gc.collect()
+b = new_style_class()
+del new_style_class
+gc.collect()
+del a
+gc.collect()
+del b
+gc.collect()
diff --git a/Lib/test/dtracedata/line.d b/Lib/test/dtracedata/line.d
new file mode 100644
index 0000000000..03f22db6fc
--- /dev/null
+++ b/Lib/test/dtracedata/line.d
@@ -0,0 +1,7 @@
+python$target:::line
+/(copyinstr(arg1)=="test_line")/
+{
+    printf("%d\t%s:%s:%s:%d\n", timestamp,
+        probename, basename(copyinstr(arg0)),
+        copyinstr(arg1), arg2);
+}
diff --git a/Lib/test/dtracedata/line.d.expected b/Lib/test/dtracedata/line.d.expected
new file mode 100644
index 0000000000..9b16ce76ee
--- /dev/null
+++ b/Lib/test/dtracedata/line.d.expected
@@ -0,0 +1,20 @@
+line:line.py:test_line:2
+line:line.py:test_line:3
+line:line.py:test_line:4
+line:line.py:test_line:5
+line:line.py:test_line:6
+line:line.py:test_line:7
+line:line.py:test_line:8
+line:line.py:test_line:9
+line:line.py:test_line:10
+line:line.py:test_line:11
+line:line.py:test_line:4
+line:line.py:test_line:5
+line:line.py:test_line:6
+line:line.py:test_line:7
+line:line.py:test_line:8
+line:line.py:test_line:10
+line:line.py:test_line:11
+line:line.py:test_line:4
+line:line.py:test_line:12
+line:line.py:test_line:13
diff --git a/Lib/test/dtracedata/line.py b/Lib/test/dtracedata/line.py
new file mode 100644
index 0000000000..0930ff391f
--- /dev/null
+++ b/Lib/test/dtracedata/line.py
@@ -0,0 +1,17 @@
+def test_line():
+    a = 1
+    print('# Preamble', a)
+    for i in range(2):
+        a = i
+        b = i+2
+        c = i+3
+        if c < 4:
+            a = c
+        d = a + b +c
+        print('#', a, b, c, d)
+    a = 1
+    print('# Epilogue', a)
+
+
+if __name__ == '__main__':
+    test_line()
diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py
new file mode 100644
index 0000000000..8c32895f5e
--- /dev/null
+++ b/Lib/test/fork_wait.py
@@ -0,0 +1,80 @@
+"""This test case provides support for checking forking and wait behavior.
+
+To test different wait behavior, override the wait_impl method.
+
+We want fork1() semantics -- only the forking thread survives in the
+child after a fork().
+
+On some systems (e.g. Solaris without posix threads) we find that all
+active threads survive in the child after a fork(); this is an error.
+"""
+
+import os, time, unittest
+import threading
+from test import support
+from test.support import threading_helper
+import warnings
+
+
+LONGSLEEP = 2
+SHORTSLEEP = 0.5
+NUM_THREADS = 4
+
+class ForkWait(unittest.TestCase):
+
+    def setUp(self):
+        self._threading_key = threading_helper.threading_setup()
+        self.alive = {}
+        self.stop = 0
+        self.threads = []
+
+    def tearDown(self):
+        # Stop threads
+        self.stop = 1
+        for thread in self.threads:
+            thread.join()
+        thread = None
+        self.threads.clear()
+        threading_helper.threading_cleanup(*self._threading_key)
+
+    def f(self, id):
+        while not self.stop:
+            self.alive[id] = os.getpid()
+            try:
+                time.sleep(SHORTSLEEP)
+            except OSError:
+                pass
+
+    def wait_impl(self, cpid, *, exitcode):
+        support.wait_process(cpid, exitcode=exitcode)
+
+    def test_wait(self):
+        for i in range(NUM_THREADS):
+            thread = threading.Thread(target=self.f, args=(i,))
+            thread.start()
+            self.threads.append(thread)
+
+        # busy-loop to wait for threads
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(self.alive) >= NUM_THREADS:
+                break
+
+        a = sorted(self.alive.keys())
+        self.assertEqual(a, list(range(NUM_THREADS)))
+
+        prefork_lives = self.alive.copy()
+
+        # Ignore the warning about fork with threads.
+        with warnings.catch_warnings(category=DeprecationWarning,
+                                     action="ignore"):
+            if (cpid := os.fork()) == 0:
+                # Child
+                time.sleep(LONGSLEEP)
+                n = 0
+                for key in self.alive:
+                    if self.alive[key] != prefork_lives[key]:
+                        n += 1
+                os._exit(n)
+            else:
+                # Parent
+                self.wait_impl(cpid, exitcode=0)
diff --git a/Lib/test/keycert.passwd.pem b/Lib/test/keycert.passwd.pem
deleted file mode 100644
index 0ad6960551..0000000000
--- a/Lib/test/keycert.passwd.pem
+++ /dev/null
@@ -1,50 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: DES-EDE3-CBC,E74528136B90D2DD
-
-WRHVD2PJXPqjFSHg92HURIsUzvsTE4a9oi0SC5yMBFKNWA5Z933gK3XTifp6jul5
-zpNYi8jBXZ2EqJJBxCuVcefmXSxL0q7CMej25TdIC4BVAFJVveeprHPUFkNB0IM1
-go5Lg4YofYqTCg3OE3k7WvfR3Zg1cRYxksDKO+WNZgWyKBex5X4vjOiyUqDl3GKt
-kQXnkg1VgPV2Vrx93S9XNdELNRTguwf+XG0fkhtYhp/zCto8uKTgy5elK2P/ulGp
-7fe6uj7h/uN9L7EOC6CjRkitywfeBUER739mOcGT4imSFJ9G27TCqPzj2ea3uuaf
-/v1xhkQ4M6lNY/gcRfgVpCXhW43aAQV8XXQRMJTqLmz5Y5hYTKn+Ugq5vJ/ngyRM
-lu1gUJnYYaemBTb4hbm6aBvnYK9mORa891Pmf+vxU9rYuQIdVAhvvXh4KBreSEBI
-1AFy6dFKXl8ZKs6Wrq5wPefmFFkRmZ8OBiiq0fp2ApCRGZw6LsjCgwrRM38JiY7d
-3OdsJpKvRYufgUyuuzUE0xA+E4yMvD48M9pPq2fC8O5giuGL1uEekQWXJuq+6ZRI
-XYKIeSkuQALbX3RAzCPXTUEMtCYXKm/gxrrwJ+Bet4ob2amf3MX0uvWwOuAq++Fk
-J0HFSBxrwvIWOhyQXOPuJdAN8PXA7dWOXfOgOMF0hQYqZCl3T4TiVZJbwVQtg1sN
-dO7oAD5ZPHiKzvveZuB6k1FlBG8j0TyAC+44ChxkPDD3jF4dd6zGe62sDf85p4/d
-W80gxJeD3xnDxG0ePPns+GuKUpUaWS7WvHtDpeFW1JEhvOqf8p1Li9a7RzWVo8ML
-mGTdQgBIYIf6/fk69pFKl0nKtBU75KaunZz4nAmd9bNED4naDurMBg44u5TvODbJ
-vgYIYXIYjNvONbskJatVrrTS8zch2NwVIjCi8L/hecwBXbIXzo1pECpc6BU7sQT8
-+i9sDKBeJcRipzfKZNHvnO19mUZaPCY8+a/f9c21DgKXz+bgLcJbohpSaeGM8Gfc
-aZd3Vp9n3OJ3g2zQR1++HO9v1vR/wLELu6MeydkvMduHLmOPCn54gZ9z51ZNPAwa
-qfFIsH+mLh9ks0H74ssF59uIlstkgB9zmZHv/Q0dK9ZfG/VEH6rSgdETWhZxhoMQ
-Z92jXBEFT0zhI3rrIPNY+XS7eJCQIc1wc84Ea3cRk7SP+S1og3JtAxX56ykUwtkM
-LQ/Dwwa6h1aqD0l2d5x1/BSdavtTuSegISRWQ4iOmSvEdlFP7H4g6RZk/okbLzMD
-Evq5gNc7vlXhVawoQU8JCanJ5ZbbWnIRZfiXxBQS4lpYPKvJt4ML9z/x+82XxcXv
-Z93N2Wep7wWW5OwS2LcQcOgZRDSIPompwo/0pMFGOS+5oort0ZDRHdmmGLjvBcCb
-1KQmKQ4+8brI/3rjRzts6uDLjTGNxSCieNsnqhwHUv9Mg9WDSWupcGa+x27L89x3
-rObf6+3umcFLSjIzU8wuv1hx/e/y98Kv7BDBNYpAr6kVMrLnzYjAfJbBmqlxkzkQ
-IgQzgrk2QZoTdgwR+S374NAMO0AE5IlO+/qa6qp2SORGTDX64I3UNw==
------END RSA PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIDWTCCAkGgAwIBAgIJAPm6B21bar2bMA0GCSqGSIb3DQEBCwUAMF8xCzAJBgNV
-BAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9u
-IFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0xODAx
-MTkxOTA5MDZaFw0yODAxMTcxOTA5MDZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQH
-DA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5k
-YXRpb24xEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP
-ADCCAQoCggEBAKvvsX2gEti4shve3iYMc+jE4Se7WHs1Bol2f21H8qNboDOFdeb1
-RKHjmq3exHpajywOUEgne9nKHJY/3f2phR4Y5klqG6liLgiSpVyRlcBGbeT2qEAj
-9oLiLFUXLGfGDds2mTwivQDLJBWi51j7ff5k2Pr58fN5ugYMn24T9FNyn0moT+qj
-SFoBNm58l9jrdkJSlgWfqPlbiMa+mqDn/SFtrwLF2Trbfzu42Sd9UdIzMaSSrzbN
-sGm53pNhCh8KndWUQ8GPP2IsLPoUU4qAtmZuTxCx2S1cXrN9EkmT69tlOH84YfSn
-96Ih9bWRc7M5y5bfVdEVM+fKQl3hBRf05qMCAwEAAaMYMBYwFAYDVR0RBA0wC4IJ
-bG9jYWxob3N0MA0GCSqGSIb3DQEBCwUAA4IBAQAtQ8f37cCEk7/rAcbYR53ce3iK
-Vpihb0U2ni1QjG9Tg9UIExkIGkwTiCm7kwQL+GEStBu9AG/QVrOjeTriRiddhWkk
-ze8kRaI3AC/63t6Vh9Q1x6PESgeE4OtAO9JpJCf4GILglA789Y/b/GF8zJZQxR13
-qpB4ZwWw7gCBhdEW59u6CFeBmfDa58hM8lWvuVoRrTi7bjUeC6PAn5HVMzZSykhu
-4HaUfBp6bKFjuym2+h/VvM1n8C3chjVSmutsLb6ELdD8IK0vPV/yf5+LN256zSsS
-dyUZYd8XwQaioEMKdbhLvnehyzHiWfQIUR3BdhONxoIJhHv/EAo8eCkHHYIF
------END CERTIFICATE-----
diff --git a/Lib/test/keycert.pem b/Lib/test/keycert.pem
deleted file mode 100644
index 9545dcf4b9..0000000000
--- a/Lib/test/keycert.pem
+++ /dev/null
@@ -1,48 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCr77F9oBLYuLIb
-3t4mDHPoxOEnu1h7NQaJdn9tR/KjW6AzhXXm9USh45qt3sR6Wo8sDlBIJ3vZyhyW
-P939qYUeGOZJahupYi4IkqVckZXARm3k9qhAI/aC4ixVFyxnxg3bNpk8Ir0AyyQV
-oudY+33+ZNj6+fHzeboGDJ9uE/RTcp9JqE/qo0haATZufJfY63ZCUpYFn6j5W4jG
-vpqg5/0hba8Cxdk62387uNknfVHSMzGkkq82zbBpud6TYQofCp3VlEPBjz9iLCz6
-FFOKgLZmbk8QsdktXF6zfRJJk+vbZTh/OGH0p/eiIfW1kXOzOcuW31XRFTPnykJd
-4QUX9OajAgMBAAECggEAHppmXDbuw9Z0FVPg9KLIysioTtsgz6VLiZIm8juZK4x2
-glUh/D7xvWL2uDXrgN+3lh7iGUW13LkFx5SMncbbo9TIwI57Z/XKvcnkVwquve+L
-RfLFVc1Q5lD9lROv2rS86KTaN4LzYz3FKXi6dvMkpPAsUtfEQhMLkmISypQQq/1z
-EJaqo7r85OjN7e0wKazlKZpOzJEa5FQLMVRjTRFhLFNbHXX/tAet2jw+umATKbw8
-hYgiuZ44TwSEd9JeIV/oSYWfI/3HetuYW0ru3caiztRF2NySNu8lcsWgNC7fIku9
-mcHjtSNzs91QN1Qlu7GQvvhpt6OWDirNDCW+49WGaQKBgQDg9SDhfF0jRYslgYbH
-cqO4ggaFdHjrAAYpwnAgvanhFZL/zEqm5G1E7l/e2fCkJ9VOSFO0A208chvwMcr+
-dCjHE2tVdE81aQ2v/Eo83VdS1RcOV4Y75yPH48rMhxPaHvxWD/FFDbf0/P2mtPB7
-SZ3kIeZMkE1wxdaO3AKUbQoozwKBgQDDqYgg7kVtygyICE1mB8Hwp6nUxFTczG7y
-4XcsDqMIrKmw+PbQluvkoHoStxeVrsTloDhkTjIrpmYLyAiazg+PUJdkd6xrfLSj
-VV6X93W0S/1egEb1F1CGFxtk8v/PWH4K76EPL2vxXdxjywz3GWlrL9yDYaB2szzS
-DqgwVMqx7QKBgDCD7UF0Bsoyl13RX3XoPXLvZ+SkR+e2q52Z94C4JskKVBeiwX7Y
-yNAS8M4pBoMArDoj0xmBm69rlKbqtjLGbnzwrTdSzDpim7cWnBQgUFLm7gAD1Elb
-AhZ8BCK0Bw4FnLoa2hfga4oEfdfUMgEE0W5/+SEOBgWKRUmuHUhRc911AoGAY2EN
-YmSDYSM5wDIvVb5k9B3EtevOiqNPSw/XnsoEZtiEC/44JnQxdltIBY93bDBrk5IQ
-cmoBM4h91kgQjshQwOMXMhFSwvmBKmCm/hrTbvMVytTutXfVD3ZXFKwT4DW7N0TF
-ElhsxBh/YzRz7mG62JVjtFt2zDN3ld2Z8YpvtXUCgYEA4EJ4ObS5YyvcXAKHJFo6
-Fxmavyrf8LSm3MFA65uSnFvWukMVqqRMReQc5jvpxHKCis+XvnHzyOfL0gW9ZTi7
-tWGGbBi0TRJCa8BkvgngUZxOxUlMfg/7cVxOIB0TPoUSgxFd/+qVz4GZMvr0dPu7
-eAF7J/8ECVvb0wSPTUI1N3c=
------END PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIDWTCCAkGgAwIBAgIJAPm6B21bar2bMA0GCSqGSIb3DQEBCwUAMF8xCzAJBgNV
-BAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9u
-IFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0xODAx
-MTkxOTA5MDZaFw0yODAxMTcxOTA5MDZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQH
-DA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5k
-YXRpb24xEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEP
-ADCCAQoCggEBAKvvsX2gEti4shve3iYMc+jE4Se7WHs1Bol2f21H8qNboDOFdeb1
-RKHjmq3exHpajywOUEgne9nKHJY/3f2phR4Y5klqG6liLgiSpVyRlcBGbeT2qEAj
-9oLiLFUXLGfGDds2mTwivQDLJBWi51j7ff5k2Pr58fN5ugYMn24T9FNyn0moT+qj
-SFoBNm58l9jrdkJSlgWfqPlbiMa+mqDn/SFtrwLF2Trbfzu42Sd9UdIzMaSSrzbN
-sGm53pNhCh8KndWUQ8GPP2IsLPoUU4qAtmZuTxCx2S1cXrN9EkmT69tlOH84YfSn
-96Ih9bWRc7M5y5bfVdEVM+fKQl3hBRf05qMCAwEAAaMYMBYwFAYDVR0RBA0wC4IJ
-bG9jYWxob3N0MA0GCSqGSIb3DQEBCwUAA4IBAQAtQ8f37cCEk7/rAcbYR53ce3iK
-Vpihb0U2ni1QjG9Tg9UIExkIGkwTiCm7kwQL+GEStBu9AG/QVrOjeTriRiddhWkk
-ze8kRaI3AC/63t6Vh9Q1x6PESgeE4OtAO9JpJCf4GILglA789Y/b/GF8zJZQxR13
-qpB4ZwWw7gCBhdEW59u6CFeBmfDa58hM8lWvuVoRrTi7bjUeC6PAn5HVMzZSykhu
-4HaUfBp6bKFjuym2+h/VvM1n8C3chjVSmutsLb6ELdD8IK0vPV/yf5+LN256zSsS
-dyUZYd8XwQaioEMKdbhLvnehyzHiWfQIUR3BdhONxoIJhHv/EAo8eCkHHYIF
------END CERTIFICATE-----
diff --git a/Lib/test/keycert2.pem b/Lib/test/keycert2.pem
deleted file mode 100644
index bb5fa65a8a..0000000000
--- a/Lib/test/keycert2.pem
+++ /dev/null
@@ -1,49 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC3ulRNfhbOAey/
-B+wIVYx+d5az7EV4riR6yi/qE6G+bxbTvay2pqySHtDweuaYSh2cVmcasBKKIFJm
-rCD1zR8UmLb5i2XFIina1t3eePCuBZMrvZZwkzlQUSM1AZtjGOO/W0I3FwO6y645
-9xA5PduKI7SMYkH/VL3zE5W1JwMovv6bvNiT+GU5l6mB9ylCTgLpmUqoQhRqz/35
-zCzVyoh+ppDvVcpWYfvXywsXsgQwbAF0QJm8SSFi0TZm5ykv4WE16afQp08yuZS0
-3U4K3MJCa4rxO58edcxBopWYfQ29K3iINM8enRfr5q+u5mAAbALAEEvyFjgLWl/u
-7arxn7bJAgMBAAECggEBAJfMt8KfHzBunrDnVrk8FayYGkfmOzAOkc1yKEx6k/TH
-zFB+Mqlm5MaF95P5t3S0J+r36JBAUdEWC38RUNpF9BwMYYGlDxzlsTdCuGYL/q+J
-o6NMLXQt7/jQUQqGnWAvPFzqhbcGqOo5R2ZVH25sEWv9PDuRI35XAepIkDTwWsfa
-P6UcJJoP+4v9B++fb3sSL4zNwp1BqS4wxR8YTR0t1zQqOxJ5BGPw1J8aBMs1sq5t
-qyosAQAT63kLrdqWotHaM26QxjqEQUMlh12XMWb5GdBXUxbvyGtEabsqskGa/f8B
-RdHE437J8D8l+jxb2mZLzrlaH3dq2tbFGCe1rT8qLRECgYEA5CWIvoD/YnQydLGA
-OlEhCSocqURuqcotg9Ev0nt/C60jkr/NHFLGppz9lhqjIDjixt3sIMGZMFzxRtwM
-pSYal3XiR7rZuHau9iM35yDhpuytEiGbYy1ADakJRzY5jq/Qa8RfPP9Atua5xAeP
-q6DiSnq9vhHv9G+O4MxzHBmrw9sCgYEAziiJWFthcwvuXn3Jv9xFYKEb/06puZAx
-EgQCz/3rPzv5fmGD/sKVo1U/K4z/eA82DNeKG8QRTFJCxT8TCNRxOmGV7HdCYo/B
-4BTNNvbKcdi3l0j75kKoADg+nt5CD5lz6gLG0GrUEnVO1y5HVfCTb3BEAfa36C85
-9i0sfQGiwysCgYEAuus9k8cgdct5oz3iLuVVSark/JGCkT2B+OOkaLChsDFUWeEm
-7TOsaclpwldkmvvAYOplkZjMJ2GelE2pVo1XcAw3LkmaI5WpVyQXoxe/iQGT8qzy
-IFlsh0Scw2lb0tmcyw6CcPk4TiHOxRrkzNrtS9QwLM+JZx0XVHptPPKTVc0CgYAu
-j/VFYY5G/8Dc0qhIjyWUR48dQNUQtkJ/ASzpcT46z/7vznKTjbtiYpSb74KbyUO5
-7sygrM4DYOj3x+Eys1jHiNbly6HQxQtS4x/edCsRP5NntfI+9XsgYZOzKhvdjhki
-F3J0DEzNxnUCIM+311hVaRPTJbgv1srOkTFlIoNydQKBgQC6/OHGaC/OewQqRlRK
-Mg5KZm01/pk4iKrpA5nG7OTAeoa70NzXNtG8J3WnaJ4mWanNwNUOyRMAMrsUAy9q
-EeGqHM5mMFpY4TeVuNLL21lu/x3KYw6mKL3Ctinn+JLAoYoqEy8deZnEA5/tjYlz
-YhFBchnUicjoUN1chdpM6SpV2Q==
------END PRIVATE KEY-----
------BEGIN CERTIFICATE-----
-MIIDYjCCAkqgAwIBAgIJALJXRr8qF6oIMA0GCSqGSIb3DQEBCwUAMGIxCzAJBgNV
-BAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9u
-IFNvZnR3YXJlIEZvdW5kYXRpb24xFTATBgNVBAMMDGZha2Vob3N0bmFtZTAeFw0x
-ODAxMTkxOTA5MDZaFw0yODAxMTcxOTA5MDZaMGIxCzAJBgNVBAYTAlhZMRcwFQYD
-VQQHDA5DYXN0bGUgQW50aHJheDEjMCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZv
-dW5kYXRpb24xFTATBgNVBAMMDGZha2Vob3N0bmFtZTCCASIwDQYJKoZIhvcNAQEB
-BQADggEPADCCAQoCggEBALe6VE1+Fs4B7L8H7AhVjH53lrPsRXiuJHrKL+oTob5v
-FtO9rLamrJIe0PB65phKHZxWZxqwEoogUmasIPXNHxSYtvmLZcUiKdrW3d548K4F
-kyu9lnCTOVBRIzUBm2MY479bQjcXA7rLrjn3EDk924ojtIxiQf9UvfMTlbUnAyi+
-/pu82JP4ZTmXqYH3KUJOAumZSqhCFGrP/fnMLNXKiH6mkO9VylZh+9fLCxeyBDBs
-AXRAmbxJIWLRNmbnKS/hYTXpp9CnTzK5lLTdTgrcwkJrivE7nx51zEGilZh9Db0r
-eIg0zx6dF+vmr67mYABsAsAQS/IWOAtaX+7tqvGftskCAwEAAaMbMBkwFwYDVR0R
-BBAwDoIMZmFrZWhvc3RuYW1lMA0GCSqGSIb3DQEBCwUAA4IBAQCZhHhGItpkqhEq
-ntMRd6Hv0GoOJixNvgeMwK4NJSRT/no3OirtUTzccn46h+SWibSa2eVssAV+pAVJ
-HbzkN/DH27A1mMx1zJL1ekcOKA1AF6MXhUnrUGXMqW36YNtzHfXJLrwvpLJ13OQg
-/Kxo4Nw68bGzM+PyRtKU/mpgYyfcvwR+ZSeIDh1fvUZK/IEVCf8ub42GPVs5wPfv
-M+k5aHxWTxeif3K1byTRzxHupYNG2yWO4XEdnBGOuOwzzN4/iQyNcsuQKeuKHGrt
-YvIlG/ri04CQ7xISZCj74yjTZ+/A2bXre2mQXAHqKPumHL7cl34+erzbUaxYxbTE
-u5FcOmLQ
------END CERTIFICATE-----
diff --git a/Lib/test/keycert3.pem b/Lib/test/keycert3.pem
deleted file mode 100644
index 621eb08bb0..0000000000
--- a/Lib/test/keycert3.pem
+++ /dev/null
@@ -1,132 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDgV4G+Zzf2DT5n
-oAisIGFhn/bz7Vn5WiXUqbDsxROJOh/7BtOlduZka0pPhFylGbnxS8l1kEWHRI2T
-6hOoWzumB6ItKiN+T5J30lAvSyo7iwdFoAQ/S5nPXQfhNARQe/NEOhRtpcuNdyx4
-BWdPdPuJQA1ASNJCLwcLOoRxaLbKLvb2V5T5FCAkeNPtRvPuT4gKQItMmiHfAhoV
-C8MZWF/GC0RukHINys5MwqeFexam8CznmQPMYrLdhmKTj3DTivCPoh97EDIFGlgZ
-SCaaYDVQA+aqlo/q2pi52PFwC1KzhNEA7EeOqSwC1NQjwjHuhcnf9WbxrgTq2zh3
-rv5YEW2ZAgMBAAECggEAPfSMtTumPcJskIumuXp7yk02EyliZrWZqwBuBwVqHsS5
-nkbFXnXWrLbgn9MrDsFrE5NdgKUmPnQVMVs8sIr5jyGejSCNCs4I4iRn1pfIgwcj
-K/xEEALd6GGF0pDd/CgvB5GOoLVf4KKf2kmLvWrOKJpSzoUN5A8+v8AaYYOMr4sC
-czbvfGomzEIewEG+Rw9zOVUDlmwyEKPQZ47E7PQ+EEA7oeFdR+1Zj6eT9ndegf8B
-54frySYCLRUCk/sHCpWhaJBtBrcpht7Y8CfY7hiH/7x866fvuLnYPz4YALtUb0wN
-7zUCNS9ol3n4LbjFFKfZtiRjKaCBRzMjK0rz6ydFcQKBgQDyLI3oGbnW73vqcDe/
-6eR0w++fiCAVhfMs3AO/gOaJi2la2JHlJ5u+cIHQIOFwEhn6Zq0AtdmnFx1TS5IQ
-C0MdXI0XoQQw7rEF8EJcvfe85Z0QxENVhzydtdb8QpJfnQGfBfLyQlaaRYzRRHB6
-VdYUHF3EIPVIhbjbghal+Qep/QKBgQDtJlRPHkWwTMevu0J0fYbWN1ywtVTFUR//
-k7VyORSf8yuuSnaQRop4cbcqONxmDKH6Or1fl3NYBsAxtXkkOK1E2OZNo2sfQdRa
-wpA7o7mPHRhztQFpT5vflp+8P6+PEFat8D04eBOhNwrwwfhiPjD4gv5KvN4XutRW
-VWv/2pnmzQKBgHPvHGg2mJ7quvm6ixXW1MWJX1eSBToIjCe3lBvDi5nhIaiZ8Q4w
-7gA3QA3xD7tlDwauzLeAVxgEmsdbcCs6GQEfY3QiYy1Bt4FOSZa4YrcNfSmfq1Rw
-j3Y4rRjKjeQz96i3YlzToT3tecJc7zPBj+DEy6au2H3Fdn+vQURneWHJAoGBANG7
-XES8mRVaUh/wlM1BVsaNH8SIGfiHzqzRjV7/bGYpQTBbWpAuUrhCmaMVtpXqBjav
-TFwGLVRkZAWSYRjPpy2ERenT5SE3rv61o6mbGrifGsj6A82HQmtzYsGx8SmtYXtj
-REF0sKebbmmOooUAS379GrguYJzL9o6D7YfRZNrhAoGAVfb/tiFU4S67DSpYpQey
-ULhgfsFpDByICY6Potsg67gVFf9jIaB83NPTx3u/r6sHFgxFw7lQsuZcgSuWMu7t
-glzOXVIP11Y5sl5CJ5OsfeK1/0umMZF5MWPyAQCx/qrPlZL86vXjt24Y/VaOxsAi
-CZYdyJsjgOrJrWoMbo5ta54=
------END PRIVATE KEY-----
-Certificate:
-    Data:
-        Version: 3 (0x2)
-        Serial Number:
-            82:ed:bf:41:c8:80:91:9c
-    Signature Algorithm: sha1WithRSAEncryption
-        Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
-        Validity
-            Not Before: Jan 19 19:09:06 2018 GMT
-            Not After : Nov 28 19:09:06 2027 GMT
-        Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=localhost
-        Subject Public Key Info:
-            Public Key Algorithm: rsaEncryption
-                Public-Key: (2048 bit)
-                Modulus:
-                    00:e0:57:81:be:67:37:f6:0d:3e:67:a0:08:ac:20:
-                    61:61:9f:f6:f3:ed:59:f9:5a:25:d4:a9:b0:ec:c5:
-                    13:89:3a:1f:fb:06:d3:a5:76:e6:64:6b:4a:4f:84:
-                    5c:a5:19:b9:f1:4b:c9:75:90:45:87:44:8d:93:ea:
-                    13:a8:5b:3b:a6:07:a2:2d:2a:23:7e:4f:92:77:d2:
-                    50:2f:4b:2a:3b:8b:07:45:a0:04:3f:4b:99:cf:5d:
-                    07:e1:34:04:50:7b:f3:44:3a:14:6d:a5:cb:8d:77:
-                    2c:78:05:67:4f:74:fb:89:40:0d:40:48:d2:42:2f:
-                    07:0b:3a:84:71:68:b6:ca:2e:f6:f6:57:94:f9:14:
-                    20:24:78:d3:ed:46:f3:ee:4f:88:0a:40:8b:4c:9a:
-                    21:df:02:1a:15:0b:c3:19:58:5f:c6:0b:44:6e:90:
-                    72:0d:ca:ce:4c:c2:a7:85:7b:16:a6:f0:2c:e7:99:
-                    03:cc:62:b2:dd:86:62:93:8f:70:d3:8a:f0:8f:a2:
-                    1f:7b:10:32:05:1a:58:19:48:26:9a:60:35:50:03:
-                    e6:aa:96:8f:ea:da:98:b9:d8:f1:70:0b:52:b3:84:
-                    d1:00:ec:47:8e:a9:2c:02:d4:d4:23:c2:31:ee:85:
-                    c9:df:f5:66:f1:ae:04:ea:db:38:77:ae:fe:58:11:
-                    6d:99
-                Exponent: 65537 (0x10001)
-        X509v3 extensions:
-            X509v3 Subject Alternative Name: 
-                DNS:localhost
-            X509v3 Key Usage: critical
-                Digital Signature, Key Encipherment
-            X509v3 Extended Key Usage: 
-                TLS Web Server Authentication, TLS Web Client Authentication
-            X509v3 Basic Constraints: critical
-                CA:FALSE
-            X509v3 Subject Key Identifier: 
-                85:11:BE:16:47:04:D1:30:EE:86:8A:18:70:BE:A8:28:6F:82:3D:CE
-            X509v3 Authority Key Identifier: 
-                keyid:9A:CF:CF:6E:EB:71:3D:DB:3C:F1:AE:88:6B:56:72:03:CB:08:A7:48
-                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
-                serial:82:ED:BF:41:C8:80:91:9B
-
-            Authority Information Access: 
-                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
-                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
-
-            X509v3 CRL Distribution Points: 
-
-                Full Name:
-                  URI:http://testca.pythontest.net/testca/revocation.crl
-
-    Signature Algorithm: sha1WithRSAEncryption
-         7f:a1:7e:3e:68:01:b0:32:b8:57:b8:03:68:13:13:b3:e3:f4:
-         70:2f:15:e5:0f:87:b9:fd:e0:12:e3:16:f2:91:53:c7:4e:25:
-         af:ca:cb:a7:d9:9d:57:4d:bf:a2:80:d4:78:aa:04:31:fd:6d:
-         cc:6d:82:43:e9:62:16:0d:0e:26:8b:e7:f1:3d:57:5c:68:02:
-         9c:2b:b6:c9:fd:62:2f:10:85:88:cc:44:a5:e7:a2:3e:89:f2:
-         1f:02:6a:3f:d0:3c:6c:24:2d:bc:51:62:7a:ec:25:c5:86:87:
-         77:35:8f:f9:7e:d0:17:3d:77:56:bf:1a:0c:be:09:78:ee:ea:
-         73:97:65:60:94:91:35:b3:5c:46:8a:5e:6d:94:52:de:48:b7:
-         1f:6c:28:79:7f:ff:08:8d:e4:7d:d0:b9:0b:7c:ae:c4:1d:2a:
-         a1:b3:50:11:82:03:5e:6c:e7:26:fa:05:32:39:07:83:49:b9:
-         a2:fa:04:da:0d:e5:ff:4c:db:97:d0:c3:a7:43:37:4c:16:de:
-         3c:b5:e9:7e:82:d4:b3:10:df:d1:c1:66:72:9c:15:67:19:3b:
-         7b:91:0a:82:07:67:c5:06:03:5f:80:54:08:81:8a:b1:5c:7c:
-         4c:d2:07:38:92:eb:12:f5:71:ae:de:05:15:c8:e1:33:f0:e4:
-         96:0f:0f:1e
------BEGIN CERTIFICATE-----
-MIIE8TCCA9mgAwIBAgIJAILtv0HIgJGcMA0GCSqGSIb3DQEBBQUAME0xCzAJBgNV
-BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODAxMTkxOTA5MDZaFw0yNzExMjgx
-OTA5MDZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMMCWxv
-Y2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOBXgb5nN/YN
-PmegCKwgYWGf9vPtWflaJdSpsOzFE4k6H/sG06V25mRrSk+EXKUZufFLyXWQRYdE
-jZPqE6hbO6YHoi0qI35PknfSUC9LKjuLB0WgBD9Lmc9dB+E0BFB780Q6FG2ly413
-LHgFZ090+4lADUBI0kIvBws6hHFotsou9vZXlPkUICR40+1G8+5PiApAi0yaId8C
-GhULwxlYX8YLRG6Qcg3KzkzCp4V7FqbwLOeZA8xist2GYpOPcNOK8I+iH3sQMgUa
-WBlIJppgNVAD5qqWj+ramLnY8XALUrOE0QDsR46pLALU1CPCMe6Fyd/1ZvGuBOrb
-OHeu/lgRbZkCAwEAAaOCAcAwggG8MBQGA1UdEQQNMAuCCWxvY2FsaG9zdDAOBgNV
-HQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAwGA1Ud
-EwEB/wQCMAAwHQYDVR0OBBYEFIURvhZHBNEw7oaKGHC+qChvgj3OMH0GA1UdIwR2
-MHSAFJrPz27rcT3bPPGuiGtWcgPLCKdIoVGkTzBNMQswCQYDVQQGEwJYWTEmMCQG
-A1UECgwdUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24gQ0ExFjAUBgNVBAMMDW91
-ci1jYS1zZXJ2ZXKCCQCC7b9ByICRmzCBgwYIKwYBBQUHAQEEdzB1MDwGCCsGAQUF
-BzAChjBodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9weWNhY2Vy
-dC5jZXIwNQYIKwYBBQUHMAGGKWh0dHA6Ly90ZXN0Y2EucHl0aG9udGVzdC5uZXQv
-dGVzdGNhL29jc3AvMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHA6Ly90ZXN0Y2EucHl0
-aG9udGVzdC5uZXQvdGVzdGNhL3Jldm9jYXRpb24uY3JsMA0GCSqGSIb3DQEBBQUA
-A4IBAQB/oX4+aAGwMrhXuANoExOz4/RwLxXlD4e5/eAS4xbykVPHTiWvysun2Z1X
-Tb+igNR4qgQx/W3MbYJD6WIWDQ4mi+fxPVdcaAKcK7bJ/WIvEIWIzESl56I+ifIf
-Amo/0DxsJC28UWJ67CXFhod3NY/5ftAXPXdWvxoMvgl47upzl2VglJE1s1xGil5t
-lFLeSLcfbCh5f/8IjeR90LkLfK7EHSqhs1ARggNebOcm+gUyOQeDSbmi+gTaDeX/
-TNuX0MOnQzdMFt48tel+gtSzEN/RwWZynBVnGTt7kQqCB2fFBgNfgFQIgYqxXHxM
-0gc4kusS9XGu3gUVyOEz8OSWDw8e
------END CERTIFICATE-----
diff --git a/Lib/test/keycert4.pem b/Lib/test/keycert4.pem
deleted file mode 100644
index b7df7f3f2c..0000000000
--- a/Lib/test/keycert4.pem
+++ /dev/null
@@ -1,132 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDH/76hZAZH4cSV
-CmVZa5HEqKCjCKrcPwBECs9BS+3ibwN4x9NnFNP+tCeFGgJXl7WGFoeXgg3oK+1p
-FsOWpsRHuF3BdqkCnShSydmT8bLaGHwKeL0cPxJP5T/uW7ezPKW2VWXGMwmwRaRJ
-9dj2VCUu20vDZWSGFr9zjnjoJczBtH3RsVUgpK7euEHuQ5pIM9QSOaCo+5FPR7s7
-1nU7YqbFWtd+NhC8Og1G497B31DQlHciF6BRm6/cNGAmHaAErKUGBFdkGtFPHBn4
-vktoEg9fwxJAZLvGpoTZWrB4HRsRwVTmFdGvK+JXK225xF23AXRXp/snhSuSFeLj
-E5cpyJJ7AgMBAAECggEAQOv527X2e/sDr0XSpHZQuT/r9UBpBlnFIlFH+fBF5k0X
-GWv0ae/O6U1dzs0kmX57xG0n0ry6+vTXeleTYiH8cTOd66EzN9AAOO+hG29IGZf9
-HAEZkkO/FARc/mjzdtFnEYsjIHWM3ZWdwQx3Q28JKu6w51rQiN51g3NqOCGdF/uF
-rE5XPKsKndn+nLHvsNuApFgUYZEwdrozgUueEgRaPTUCNhzotcA9eWoBdA24XNhk
-x8Cm/bZWabXm7gBO75zl3Cu2F21ay+EuwyOZTsx6lZi6YX9/zo1mkO81Zi3tQk50
-NMEI0feLNwsdxTbmOcVJadjOgd+QVghlFyr5HGBWMQKBgQD3AH3rhnAo6tOyNkGN
-+IzIU1MhUS452O7IavykUYO9sM24BVChpRtlI9Dpev4yE/q3BAO3+oWT3cJrN7/3
-iyo1dzAkpGvI65XWfElXFM4nLjEiZzx4W9fiPN91Oucpr0ED6+BZXTtz4gVm0TP/
-TUc2xvTB6EKvIyWmKOYEi0snxQKBgQDPSOjbz9jWOrC9XY7PmtLB6QJDDz7XSGVK
-wzD+gDAPpAwhk58BEokdOhBx2Lwl8zMJi0CRHgH2vNvkRyhvUQ4UFzisrqann/Tw
-klp5sw3iWC6ERC8z9zL7GfHs7sK3mOVeAdK6ffowPM3JrZ2vPusVBdr0MN3oZwki
-CtNXqbY1PwKBgGheQNbAW6wubX0kB9chavtKmhm937Z5v4vYCSC1gOEqUAKt3EAx
-L74wwBmn6rjmUE382EVpCgBM99WuHONQXmlxD1qsTw763LlgkuzE0cckcYaD8L06
-saHa7uDuHrcyYlpx1L5t8q0ol/e19i6uTKUMtGcq6OJwC3yGU4sgAIWxAoGBAMVq
-qiQXm2vFL+jafxYoXUvDMJ1PmskMsTP4HOR2j8+FrOwZnVk3HxGP6HOVOPRn4JbZ
-YiAT1Uj6a+7I+rCyINdvmlGUcTK6fFzW9oZryvBkjcD483/pkktmVWwTpa2YV/Ml
-h16IdsyUTGYlDUYHhXtbPUJOfDpIT4F1j/0wrFGfAoGAO82BcUsehEUQE0xvQLIn
-7QaFtUI5z19WW730jVuEobiYlh9Ka4DPbKMvka8MwyOxEwhk39gZQavmfG6+wZm+
-kjERU23LhHziJGWS2Um4yIhC7myKbWaLzjHEq72dszLpQku4BzE5fT60fxI7cURD
-WGm/Z3Q2weS3ZGIoMj1RNPI=
------END PRIVATE KEY-----
-Certificate:
-    Data:
-        Version: 3 (0x2)
-        Serial Number:
-            82:ed:bf:41:c8:80:91:9d
-    Signature Algorithm: sha1WithRSAEncryption
-        Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
-        Validity
-            Not Before: Jan 19 19:09:06 2018 GMT
-            Not After : Nov 28 19:09:06 2027 GMT
-        Subject: C=XY, L=Castle Anthrax, O=Python Software Foundation, CN=fakehostname
-        Subject Public Key Info:
-            Public Key Algorithm: rsaEncryption
-                Public-Key: (2048 bit)
-                Modulus:
-                    00:c7:ff:be:a1:64:06:47:e1:c4:95:0a:65:59:6b:
-                    91:c4:a8:a0:a3:08:aa:dc:3f:00:44:0a:cf:41:4b:
-                    ed:e2:6f:03:78:c7:d3:67:14:d3:fe:b4:27:85:1a:
-                    02:57:97:b5:86:16:87:97:82:0d:e8:2b:ed:69:16:
-                    c3:96:a6:c4:47:b8:5d:c1:76:a9:02:9d:28:52:c9:
-                    d9:93:f1:b2:da:18:7c:0a:78:bd:1c:3f:12:4f:e5:
-                    3f:ee:5b:b7:b3:3c:a5:b6:55:65:c6:33:09:b0:45:
-                    a4:49:f5:d8:f6:54:25:2e:db:4b:c3:65:64:86:16:
-                    bf:73:8e:78:e8:25:cc:c1:b4:7d:d1:b1:55:20:a4:
-                    ae:de:b8:41:ee:43:9a:48:33:d4:12:39:a0:a8:fb:
-                    91:4f:47:bb:3b:d6:75:3b:62:a6:c5:5a:d7:7e:36:
-                    10:bc:3a:0d:46:e3:de:c1:df:50:d0:94:77:22:17:
-                    a0:51:9b:af:dc:34:60:26:1d:a0:04:ac:a5:06:04:
-                    57:64:1a:d1:4f:1c:19:f8:be:4b:68:12:0f:5f:c3:
-                    12:40:64:bb:c6:a6:84:d9:5a:b0:78:1d:1b:11:c1:
-                    54:e6:15:d1:af:2b:e2:57:2b:6d:b9:c4:5d:b7:01:
-                    74:57:a7:fb:27:85:2b:92:15:e2:e3:13:97:29:c8:
-                    92:7b
-                Exponent: 65537 (0x10001)
-        X509v3 extensions:
-            X509v3 Subject Alternative Name: 
-                DNS:fakehostname
-            X509v3 Key Usage: critical
-                Digital Signature, Key Encipherment
-            X509v3 Extended Key Usage: 
-                TLS Web Server Authentication, TLS Web Client Authentication
-            X509v3 Basic Constraints: critical
-                CA:FALSE
-            X509v3 Subject Key Identifier: 
-                F8:76:79:CB:11:85:F0:46:E5:95:E6:7E:69:CB:12:5E:4E:AA:EC:4D
-            X509v3 Authority Key Identifier: 
-                keyid:9A:CF:CF:6E:EB:71:3D:DB:3C:F1:AE:88:6B:56:72:03:CB:08:A7:48
-                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
-                serial:82:ED:BF:41:C8:80:91:9B
-
-            Authority Information Access: 
-                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
-                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
-
-            X509v3 CRL Distribution Points: 
-
-                Full Name:
-                  URI:http://testca.pythontest.net/testca/revocation.crl
-
-    Signature Algorithm: sha1WithRSAEncryption
-         6d:50:8d:fb:ee:4e:93:8b:eb:47:56:ba:38:cc:80:e1:9d:c7:
-         e1:9e:1f:9c:22:0c:d2:08:9b:ed:bf:31:d9:00:ee:af:8c:56:
-         78:92:d1:7c:ba:4e:81:7f:82:1f:f4:68:99:86:91:c6:cb:57:
-         d3:b9:41:12:fa:75:53:fd:22:32:21:50:af:6b:4c:b1:34:36:
-         d1:a8:25:0a:d0:f0:f8:81:7d:69:58:6e:af:e3:d2:c4:32:87:
-         79:d7:cd:ad:0c:56:f3:15:27:10:0c:f9:57:59:53:00:ed:af:
-         5d:4d:07:86:7a:e5:f3:97:88:bc:86:b4:f1:17:46:33:55:28:
-         66:7b:70:d3:a5:12:b9:4f:c7:ed:e6:13:20:2d:f0:9e:ec:17:
-         64:cf:fd:13:14:1b:76:ba:64:ac:c5:51:b6:cd:13:0a:93:b1:
-         fd:43:09:a0:0b:44:6c:77:45:43:0b:e5:ed:70:b2:76:dc:08:
-         4a:5b:73:5f:c1:fc:7f:63:70:f8:b9:ca:3c:98:06:5f:fd:98:
-         d1:e4:e6:61:5f:09:8f:6c:18:86:98:9c:cb:3f:73:7b:3f:38:
-         f5:a7:09:20:ee:a5:63:1c:ff:8b:a6:d1:8c:e8:f4:84:3d:99:
-         38:0f:cc:e0:52:03:f9:18:05:23:76:39:de:52:ce:8e:fb:a6:
-         6e:f5:4f:c3
------BEGIN CERTIFICATE-----
-MIIE9zCCA9+gAwIBAgIJAILtv0HIgJGdMA0GCSqGSIb3DQEBBQUAME0xCzAJBgNV
-BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODAxMTkxOTA5MDZaFw0yNzExMjgx
-OTA5MDZaMGIxCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xFTATBgNVBAMMDGZh
-a2Vob3N0bmFtZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMf/vqFk
-BkfhxJUKZVlrkcSooKMIqtw/AEQKz0FL7eJvA3jH02cU0/60J4UaAleXtYYWh5eC
-Degr7WkWw5amxEe4XcF2qQKdKFLJ2ZPxstoYfAp4vRw/Ek/lP+5bt7M8pbZVZcYz
-CbBFpEn12PZUJS7bS8NlZIYWv3OOeOglzMG0fdGxVSCkrt64Qe5Dmkgz1BI5oKj7
-kU9HuzvWdTtipsVa1342ELw6DUbj3sHfUNCUdyIXoFGbr9w0YCYdoASspQYEV2Qa
-0U8cGfi+S2gSD1/DEkBku8amhNlasHgdGxHBVOYV0a8r4lcrbbnEXbcBdFen+yeF
-K5IV4uMTlynIknsCAwEAAaOCAcMwggG/MBcGA1UdEQQQMA6CDGZha2Vob3N0bmFt
-ZTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMC
-MAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFPh2ecsRhfBG5ZXmfmnLEl5OquxNMH0G
-A1UdIwR2MHSAFJrPz27rcT3bPPGuiGtWcgPLCKdIoVGkTzBNMQswCQYDVQQGEwJY
-WTEmMCQGA1UECgwdUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24gQ0ExFjAUBgNV
-BAMMDW91ci1jYS1zZXJ2ZXKCCQCC7b9ByICRmzCBgwYIKwYBBQUHAQEEdzB1MDwG
-CCsGAQUFBzAChjBodHRwOi8vdGVzdGNhLnB5dGhvbnRlc3QubmV0L3Rlc3RjYS9w
-eWNhY2VydC5jZXIwNQYIKwYBBQUHMAGGKWh0dHA6Ly90ZXN0Y2EucHl0aG9udGVz
-dC5uZXQvdGVzdGNhL29jc3AvMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHA6Ly90ZXN0
-Y2EucHl0aG9udGVzdC5uZXQvdGVzdGNhL3Jldm9jYXRpb24uY3JsMA0GCSqGSIb3
-DQEBBQUAA4IBAQBtUI377k6Ti+tHVro4zIDhncfhnh+cIgzSCJvtvzHZAO6vjFZ4
-ktF8uk6Bf4If9GiZhpHGy1fTuUES+nVT/SIyIVCva0yxNDbRqCUK0PD4gX1pWG6v
-49LEMod5182tDFbzFScQDPlXWVMA7a9dTQeGeuXzl4i8hrTxF0YzVShme3DTpRK5
-T8ft5hMgLfCe7Bdkz/0TFBt2umSsxVG2zRMKk7H9QwmgC0Rsd0VDC+XtcLJ23AhK
-W3Nfwfx/Y3D4uco8mAZf/ZjR5OZhXwmPbBiGmJzLP3N7Pzj1pwkg7qVjHP+LptGM
-6PSEPZk4D8zgUgP5GAUjdjneUs6O+6Zu9U/D
------END CERTIFICATE-----
diff --git a/Lib/test/keycertecc.pem b/Lib/test/keycertecc.pem
deleted file mode 100644
index deb484f992..0000000000
--- a/Lib/test/keycertecc.pem
+++ /dev/null
@@ -1,96 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIG2AgEAMBAGByqGSM49AgEGBSuBBAAiBIGeMIGbAgEBBDDe3QWmhZX07HZbntz4
-CFqAOaoYMdYwD7Z3WPNIc2zR7p4D6BMOa7NAWjLV5A7CUw6hZANiAAQ5IVKzLLz4
-LCfcpy6fMOp+jk5KwywsU3upPtjA6E3UetxPcfnnv+gghRyDAYLN2OVqZgLMEmUo
-F1j1SM1QrbhHIuNcVxI9gPPMdumcNFSz/hqxrBRtA/8Z2gywczdNLjc=
------END PRIVATE KEY-----
-Certificate:
-    Data:
-        Version: 3 (0x2)
-        Serial Number:
-            82:ed:bf:41:c8:80:91:9e
-    Signature Algorithm: sha1WithRSAEncryption
-        Issuer: C=XY, O=Python Software Foundation CA, CN=our-ca-server
-        Validity
-            Not Before: Jan 19 19:09:06 2018 GMT
-            Not After : Nov 28 19:09:06 2027 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:39:21:52:b3:2c:bc:f8:2c:27:dc:a7:2e:9f:30:
-                    ea:7e:8e:4e:4a:c3:2c:2c:53:7b:a9:3e:d8:c0:e8:
-                    4d:d4:7a:dc:4f:71:f9:e7:bf:e8:20:85:1c:83:01:
-                    82:cd:d8:e5:6a:66:02:cc:12:65:28:17:58:f5:48:
-                    cd:50:ad:b8:47:22:e3:5c:57:12:3d:80:f3:cc:76:
-                    e9:9c:34:54:b3:fe:1a:b1:ac:14:6d:03:ff:19:da:
-                    0c:b0:73:37:4d:2e:37
-                ASN1 OID: secp384r1
-                NIST CURVE: P-384
-        X509v3 extensions:
-            X509v3 Subject Alternative Name: 
-                DNS:localhost-ecc
-            X509v3 Key Usage: critical
-                Digital Signature, Key Encipherment
-            X509v3 Extended Key Usage: 
-                TLS Web Server Authentication, TLS Web Client Authentication
-            X509v3 Basic Constraints: critical
-                CA:FALSE
-            X509v3 Subject Key Identifier: 
-                33:23:0E:15:04:83:2E:3D:BF:DA:81:6D:10:38:80:C3:C2:B0:A4:74
-            X509v3 Authority Key Identifier: 
-                keyid:9A:CF:CF:6E:EB:71:3D:DB:3C:F1:AE:88:6B:56:72:03:CB:08:A7:48
-                DirName:/C=XY/O=Python Software Foundation CA/CN=our-ca-server
-                serial:82:ED:BF:41:C8:80:91:9B
-
-            Authority Information Access: 
-                CA Issuers - URI:http://testca.pythontest.net/testca/pycacert.cer
-                OCSP - URI:http://testca.pythontest.net/testca/ocsp/
-
-            X509v3 CRL Distribution Points: 
-
-                Full Name:
-                  URI:http://testca.pythontest.net/testca/revocation.crl
-
-    Signature Algorithm: sha1WithRSAEncryption
-         3b:6f:97:af:7e:5f:e0:14:34:ed:57:7e:de:ce:c4:85:1e:aa:
-         84:52:94:7c:e5:ce:e9:9c:88:8b:ad:b5:4d:16:ac:af:81:ea:
-         b8:a2:e2:50:2e:cb:e9:11:bd:1b:a6:3f:0c:a2:d7:7b:67:72:
-         b3:43:16:ad:c6:87:ac:6e:ac:47:78:ef:2f:8c:86:e8:9b:d1:
-         43:8c:c1:7a:91:30:e9:14:d6:9f:41:8b:9b:0b:24:9b:78:86:
-         11:8a:fc:2b:cd:c9:13:ee:90:4f:14:33:51:a3:c4:9e:d6:06:
-         48:f5:41:12:af:f0:f2:71:40:78:f5:96:c2:5d:cf:e1:38:ff:
-         bf:10:eb:74:2f:c2:23:21:3e:27:f5:f1:f2:af:2c:62:82:31:
-         00:c8:96:1b:c3:7e:8d:71:89:e7:40:b5:67:1a:33:fb:c0:8b:
-         96:0c:36:78:25:27:82:d8:27:27:52:0f:f7:69:cd:ff:2b:92:
-         10:d3:d2:0a:db:65:ed:af:90:eb:db:76:f3:8a:7a:13:9e:c6:
-         33:57:15:42:06:13:d6:54:49:fa:84:a7:0e:1d:14:72:ca:19:
-         8e:2b:aa:a4:02:54:3c:f6:1c:23:81:7a:59:54:b0:92:65:72:
-         c8:e5:ba:9f:03:4e:30:f2:4d:45:85:e3:35:a8:b1:68:58:b9:
-         3b:20:a3:eb
------BEGIN CERTIFICATE-----
-MIIESzCCAzOgAwIBAgIJAILtv0HIgJGeMA0GCSqGSIb3DQEBBQUAME0xCzAJBgNV
-BAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUgRm91bmRhdGlvbiBDQTEW
-MBQGA1UEAwwNb3VyLWNhLXNlcnZlcjAeFw0xODAxMTkxOTA5MDZaFw0yNzExMjgx
-OTA5MDZaMGMxCzAJBgNVBAYTAlhZMRcwFQYDVQQHDA5DYXN0bGUgQW50aHJheDEj
-MCEGA1UECgwaUHl0aG9uIFNvZnR3YXJlIEZvdW5kYXRpb24xFjAUBgNVBAMMDWxv
-Y2FsaG9zdC1lY2MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQ5IVKzLLz4LCfcpy6f
-MOp+jk5KwywsU3upPtjA6E3UetxPcfnnv+gghRyDAYLN2OVqZgLMEmUoF1j1SM1Q
-rbhHIuNcVxI9gPPMdumcNFSz/hqxrBRtA/8Z2gywczdNLjejggHEMIIBwDAYBgNV
-HREEETAPgg1sb2NhbGhvc3QtZWNjMA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAU
-BggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUMyMO
-FQSDLj2/2oFtEDiAw8KwpHQwfQYDVR0jBHYwdIAUms/PbutxPds88a6Ia1ZyA8sI
-p0ihUaRPME0xCzAJBgNVBAYTAlhZMSYwJAYDVQQKDB1QeXRob24gU29mdHdhcmUg
-Rm91bmRhdGlvbiBDQTEWMBQGA1UEAwwNb3VyLWNhLXNlcnZlcoIJAILtv0HIgJGb
-MIGDBggrBgEFBQcBAQR3MHUwPAYIKwYBBQUHMAKGMGh0dHA6Ly90ZXN0Y2EucHl0
-aG9udGVzdC5uZXQvdGVzdGNhL3B5Y2FjZXJ0LmNlcjA1BggrBgEFBQcwAYYpaHR0
-cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2Evb2NzcC8wQwYDVR0fBDww
-OjA4oDagNIYyaHR0cDovL3Rlc3RjYS5weXRob250ZXN0Lm5ldC90ZXN0Y2EvcmV2
-b2NhdGlvbi5jcmwwDQYJKoZIhvcNAQEFBQADggEBADtvl69+X+AUNO1Xft7OxIUe
-qoRSlHzlzumciIuttU0WrK+B6rii4lAuy+kRvRumPwyi13tncrNDFq3Gh6xurEd4
-7y+Mhuib0UOMwXqRMOkU1p9Bi5sLJJt4hhGK/CvNyRPukE8UM1GjxJ7WBkj1QRKv
-8PJxQHj1lsJdz+E4/78Q63QvwiMhPif18fKvLGKCMQDIlhvDfo1xiedAtWcaM/vA
-i5YMNnglJ4LYJydSD/dpzf8rkhDT0grbZe2vkOvbdvOKehOexjNXFUIGE9ZUSfqE
-pw4dFHLKGY4rqqQCVDz2HCOBellUsJJlcsjlup8DTjDyTUWF4zWosWhYuTsgo+s=
------END CERTIFICATE-----
diff --git a/Lib/test/libregrtest/__init__.py b/Lib/test/libregrtest/__init__.py
index 3427b51b60..e69de29bb2 100644
--- a/Lib/test/libregrtest/__init__.py
+++ b/Lib/test/libregrtest/__init__.py
@@ -1,5 +0,0 @@
-# We import importlib *ASAP* in order to test #15386
-import importlib
-
-from test.libregrtest.cmdline import _parse_args, RESOURCE_NAMES, ALL_RESOURCES
-from test.libregrtest.main import main
diff --git a/Lib/test/libregrtest/cmdline.py b/Lib/test/libregrtest/cmdline.py
index 0a97c8c19b..62bc36ed42 100644
--- a/Lib/test/libregrtest/cmdline.py
+++ b/Lib/test/libregrtest/cmdline.py
@@ -1,8 +1,9 @@
 import argparse
-import os
+import os.path
+import shlex
 import sys
-from test import support
-from test.support import os_helper
+from test.support import os_helper, Py_DEBUG
+from .utils import ALL_RESOURCES, RESOURCE_NAMES, TestFilter
 
 
 USAGE = """\
@@ -27,8 +28,10 @@
 Additional option details:
 
 -r randomizes test execution order. You can use --randseed=int to provide an
-int seed value for the randomizer; this is useful for reproducing troublesome
-test orders.
+int seed value for the randomizer. The randseed value will be used
+to set seeds for all random usages in tests
+(including randomizing the tests order if -r is set).
+By default we always set random seed, but do not randomize test order.
 
 -s On the first invocation of regrtest using -s, the first test file found
 or the first test file given on the command line is run, and the name of
@@ -107,6 +110,8 @@
 
     cpu -       Used for certain CPU-heavy tests.
 
+    walltime -  Long running but not CPU-bound tests.
+
     subprocess  Run all tests for the subprocess module.
 
     urlfetch -  It is okay to download files required on testing.
@@ -128,17 +133,51 @@
 """
 
 
-ALL_RESOURCES = ('audio', 'curses', 'largefile', 'network',
-                 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui')
+class Namespace(argparse.Namespace):
+    def __init__(self, **kwargs) -> None:
+        self.ci = False
+        self.testdir = None
+        self.verbose = 0
+        self.quiet = False
+        self.exclude = False
+        self.cleanup = False
+        self.wait = False
+        self.list_cases = False
+        self.list_tests = False
+        self.single = False
+        self.randomize = False
+        self.fromfile = None
+        self.fail_env_changed = False
+        self.use_resources: list[str] = []
+        self.trace = False
+        self.coverdir = 'coverage'
+        self.runleaks = False
+        self.huntrleaks: tuple[int, int, str] | None = None
+        self.rerun = False
+        self.verbose3 = False
+        self.print_slow = False
+        self.random_seed = None
+        self.use_mp = None
+        self.forever = False
+        self.header = False
+        self.failfast = False
+        self.match_tests: TestFilter = []
+        self.pgo = False
+        self.pgo_extended = False
+        self.tsan = False
+        self.worker_json = None
+        self.start = None
+        self.timeout = None
+        self.memlimit = None
+        self.threshold = None
+        self.fail_rerun = False
+        self.tempdir = None
+        self._add_python_opts = True
+        self.xmlpath = None
+        self.single_process = False
+
+        super().__init__(**kwargs)
 
-# Other resources excluded from --use=all:
-#
-# - extralagefile (ex: test_zipfile64): really too slow to be enabled
-#   "by default"
-# - tzdata: while needed to validate fully test_datetime, it makes
-#   test_datetime too slow (15-20 min on some buildbots) and so is disabled by
-#   default (see bpo-30822).
-RESOURCE_NAMES = ALL_RESOURCES + ('extralargefile', 'tzdata')
 
 class _ArgParser(argparse.ArgumentParser):
 
@@ -146,6 +185,20 @@ def error(self, message):
         super().error(message + "\nPass -h or --help for complete help.")
 
 
+class FilterAction(argparse.Action):
+    def __call__(self, parser, namespace, value, option_string=None):
+        items = getattr(namespace, self.dest)
+        items.append((value, self.const))
+
+
+class FromFileFilterAction(argparse.Action):
+    def __call__(self, parser, namespace, value, option_string=None):
+        items = getattr(namespace, self.dest)
+        with open(value, encoding='utf-8') as fp:
+            for line in fp:
+                items.append((line.strip(), self.const))
+
+
 def _create_parser():
     # Set prog to prevent the uninformative "__main__.py" from displaying in
     # error messages when using "python -m test ...".
@@ -155,6 +208,7 @@ def _create_parser():
                         epilog=EPILOG,
                         add_help=False,
                         formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.set_defaults(match_tests=[])
 
     # Arguments with this clause added to its help are described further in
     # the epilog's "Additional option details" section.
@@ -164,23 +218,35 @@ def _create_parser():
     # We add help explicitly to control what argument group it renders under.
     group.add_argument('-h', '--help', action='help',
                        help='show this help message and exit')
-    group.add_argument('--timeout', metavar='TIMEOUT', type=float,
+    group.add_argument('--fast-ci', action='store_true',
+                       help='Fast Continuous Integration (CI) mode used by '
+                            'GitHub Actions')
+    group.add_argument('--slow-ci', action='store_true',
+                       help='Slow Continuous Integration (CI) mode used by '
+                            'buildbot workers')
+    group.add_argument('--timeout', metavar='TIMEOUT',
                         help='dump the traceback and exit if a test takes '
                              'more than TIMEOUT seconds; disabled if TIMEOUT '
                              'is negative or equals to zero')
     group.add_argument('--wait', action='store_true',
                        help='wait for user input, e.g., allow a debugger '
                             'to be attached')
-    group.add_argument('--worker-args', metavar='ARGS')
     group.add_argument('-S', '--start', metavar='START',
                        help='the name of the test at which to start.' +
                             more_details)
+    group.add_argument('-p', '--python', metavar='PYTHON',
+                       help='Command to run Python test subprocesses with.')
+    group.add_argument('--randseed', metavar='SEED',
+                       dest='random_seed', type=int,
+                       help='pass a global random seed')
 
     group = parser.add_argument_group('Verbosity')
     group.add_argument('-v', '--verbose', action='count',
                        help='run tests in verbose mode with output to stdout')
-    group.add_argument('-w', '--verbose2', action='store_true',
+    group.add_argument('-w', '--rerun', action='store_true',
                        help='re-run failed tests in verbose mode')
+    group.add_argument('--verbose2', action='store_true', dest='rerun',
+                       help='deprecated alias to --rerun')
     group.add_argument('-W', '--verbose3', action='store_true',
                        help='display test output on failure')
     group.add_argument('-q', '--quiet', action='store_true',
@@ -193,10 +259,9 @@ def _create_parser():
     group = parser.add_argument_group('Selecting tests')
     group.add_argument('-r', '--randomize', action='store_true',
                        help='randomize test execution order.' + more_details)
-    group.add_argument('--randseed', metavar='SEED',
-                       dest='random_seed', type=int,
-                       help='pass a random seed to reproduce a previous '
-                            'random run')
+    group.add_argument('--no-randomize', dest='no_randomize', action='store_true',
+                       help='do not randomize test execution order, even if '
+                       'it would be implied by another option')
     group.add_argument('-f', '--fromfile', metavar='FILE',
                        help='read names of tests to run from a file.' +
                             more_details)
@@ -206,12 +271,21 @@ def _create_parser():
                        help='single step through a set of tests.' +
                             more_details)
     group.add_argument('-m', '--match', metavar='PAT',
-                       dest='match_tests', action='append',
+                       dest='match_tests', action=FilterAction, const=True,
                        help='match test cases and methods with glob pattern PAT')
+    group.add_argument('-i', '--ignore', metavar='PAT',
+                       dest='match_tests', action=FilterAction, const=False,
+                       help='ignore test cases and methods with glob pattern PAT')
     group.add_argument('--matchfile', metavar='FILENAME',
-                       dest='match_filename',
+                       dest='match_tests',
+                       action=FromFileFilterAction, const=True,
                        help='similar to --match but get patterns from a '
                             'text file, one pattern per line')
+    group.add_argument('--ignorefile', metavar='FILENAME',
+                       dest='match_tests',
+                       action=FromFileFilterAction, const=False,
+                       help='similar to --matchfile but it receives patterns '
+                            'from text file to ignore')
     group.add_argument('-G', '--failfast', action='store_true',
                        help='fail as soon as a test fails (only with -v or -W)')
     group.add_argument('-u', '--use', metavar='RES1,RES2,...',
@@ -227,9 +301,6 @@ def _create_parser():
                             '(instead of the Python stdlib test suite)')
 
     group = parser.add_argument_group('Special runs')
-    group.add_argument('-l', '--findleaks', action='store_const', const=2,
-                       default=1,
-                       help='deprecated alias to --fail-env-changed')
     group.add_argument('-L', '--runleaks', action='store_true',
                        help='run the leaks(1) command just before exit.' +
                             more_details)
@@ -240,6 +311,12 @@ def _create_parser():
     group.add_argument('-j', '--multiprocess', metavar='PROCESSES',
                        dest='use_mp', type=int,
                        help='run PROCESSES processes at once')
+    group.add_argument('--single-process', action='store_true',
+                       dest='single_process',
+                       help='always run all tests sequentially in '
+                            'a single process, ignore -jN option, '
+                            'and failed tests are also rerun sequentially '
+                            'in the same process')
     group.add_argument('-T', '--coverage', action='store_true',
                        dest='trace',
                        help='turn on code coverage tracing using the trace '
@@ -257,7 +334,7 @@ def _create_parser():
                        help='suppress error message boxes on Windows')
     group.add_argument('-F', '--forever', action='store_true',
                        help='run the specified tests in a loop, until an '
-                            'error happens')
+                            'error happens; imply --failfast')
     group.add_argument('--list-tests', action='store_true',
                        help="only write the name of tests that will be run, "
                             "don't execute them")
@@ -265,16 +342,30 @@ def _create_parser():
                        help='only write the name of test cases that will be run'
                             ' , don\'t execute them')
     group.add_argument('-P', '--pgo', dest='pgo', action='store_true',
-                       help='enable Profile Guided Optimization training')
+                       help='enable Profile Guided Optimization (PGO) training')
+    group.add_argument('--pgo-extended', action='store_true',
+                       help='enable extended PGO training (slower training)')
+    group.add_argument('--tsan', dest='tsan', action='store_true',
+                       help='run a subset of test cases that are proper for the TSAN test')
     group.add_argument('--fail-env-changed', action='store_true',
                        help='if a test file alters the environment, mark '
                             'the test as failed')
+    group.add_argument('--fail-rerun', action='store_true',
+                       help='if a test failed and then passed when re-run, '
+                            'mark the tests as failed')
 
     group.add_argument('--junit-xml', dest='xmlpath', metavar='FILENAME',
                        help='writes JUnit-style XML results to the specified '
                             'file')
-    group.add_argument('--tempdir', dest='tempdir', metavar='PATH',
+    group.add_argument('--tempdir', metavar='PATH',
                        help='override the working directory for the test run')
+    group.add_argument('--cleanup', action='store_true',
+                       help='remove old test_python_* directories')
+    group.add_argument('--bisect', action='store_true',
+                       help='if some tests fail, run test.bisect_cmd on them')
+    group.add_argument('--dont-add-python-opts', dest='_add_python_opts',
+                       action='store_false',
+                       help="internal option, don't use it")
     return parser
 
 
@@ -309,19 +400,12 @@ def resources_list(string):
 
 def _parse_args(args, **kwargs):
     # Defaults
-    ns = argparse.Namespace(testdir=None, verbose=0, quiet=False,
-         exclude=False, single=False, randomize=False, fromfile=None,
-         findleaks=1, use_resources=None, trace=False, coverdir='coverage',
-         runleaks=False, huntrleaks=False, verbose2=False, print_slow=False,
-         random_seed=None, use_mp=None, verbose3=False, forever=False,
-         header=False, failfast=False, match_tests=None, pgo=False)
+    ns = Namespace()
     for k, v in kwargs.items():
         if not hasattr(ns, k):
             raise TypeError('%r is an invalid keyword argument '
                             'for this function' % k)
         setattr(ns, k, v)
-    if ns.use_resources is None:
-        ns.use_resources = []
 
     parser = _create_parser()
     # Issue #14191: argparse doesn't support "intermixed" positional and
@@ -330,19 +414,81 @@ def _parse_args(args, **kwargs):
     for arg in ns.args:
         if arg.startswith('-'):
             parser.error("unrecognized arguments: %s" % arg)
-            sys.exit(1)
 
-    if ns.findleaks > 1:
-        # --findleaks implies --fail-env-changed
+    if ns.timeout is not None:
+        # Support "--timeout=" (no value) so Makefile.pre.pre TESTTIMEOUT
+        # can be used by "make buildbottest" and "make test".
+        if ns.timeout != "":
+            try:
+                ns.timeout = float(ns.timeout)
+            except ValueError:
+                parser.error(f"invalid timeout value: {ns.timeout!r}")
+        else:
+            ns.timeout = None
+
+    # Continuous Integration (CI): common options for fast/slow CI modes
+    if ns.slow_ci or ns.fast_ci:
+        # Similar to options:
+        #   -j0 --randomize --fail-env-changed --rerun --slowest --verbose3
+        if ns.use_mp is None:
+            ns.use_mp = 0
+        ns.randomize = True
         ns.fail_env_changed = True
+        if ns.python is None:
+            ns.rerun = True
+        ns.print_slow = True
+        if not ns.verbose:
+            ns.verbose3 = True
+        else:
+            # --verbose has the priority over --verbose3
+            pass
+    else:
+        ns._add_python_opts = False
+
+    # --singleprocess overrides -jN option
+    if ns.single_process:
+        ns.use_mp = None
+
+    # When both --slow-ci and --fast-ci options are present,
+    # --slow-ci has the priority
+    if ns.slow_ci:
+        # Similar to: -u "all" --timeout=1200
+        if ns.use is None:
+            ns.use = []
+        ns.use.insert(0, ['all'])
+        if ns.timeout is None:
+            ns.timeout = 1200  # 20 minutes
+    elif ns.fast_ci:
+        # Similar to: -u "all,-cpu" --timeout=600
+        if ns.use is None:
+            ns.use = []
+        ns.use.insert(0, ['all', '-cpu'])
+        if ns.timeout is None:
+            ns.timeout = 600  # 10 minutes
+
     if ns.single and ns.fromfile:
         parser.error("-s and -f don't go together!")
-    if ns.use_mp is not None and ns.trace:
-        parser.error("-T and -j don't go together!")
+    if ns.trace:
+        if ns.use_mp is not None:
+            if not Py_DEBUG:
+                parser.error("need --with-pydebug to use -T and -j together")
+        else:
+            print(
+                "Warning: collecting coverage without -j is imprecise. Configure"
+                " --with-pydebug and run -m test -T -j for best results.",
+                file=sys.stderr
+            )
+    if ns.python is not None:
+        if ns.use_mp is None:
+            parser.error("-p requires -j!")
+        # The "executable" may be two or more parts, e.g. "node python.js"
+        ns.python = shlex.split(ns.python)
     if ns.failfast and not (ns.verbose or ns.verbose3):
         parser.error("-G/--failfast needs either -v or -W")
-    if ns.pgo and (ns.verbose or ns.verbose2 or ns.verbose3):
+    if ns.pgo and (ns.verbose or ns.rerun or ns.verbose3):
         parser.error("--pgo/-v don't go together!")
+    if ns.pgo_extended:
+        ns.pgo = True  # pgo_extended implies pgo
 
     if ns.nowindows:
         print("Warning: the --nowindows (-n) option is deprecated. "
@@ -353,10 +499,6 @@ def _parse_args(args, **kwargs):
     if ns.timeout is not None:
         if ns.timeout <= 0:
             ns.timeout = None
-    if ns.use_mp is not None:
-        if ns.use_mp <= 0:
-            # Use all cores + extras for tests that like to sleep
-            ns.use_mp = 2 + (os.cpu_count() or 1)
     if ns.use:
         for a in ns.use:
             for r in a:
@@ -377,18 +519,34 @@ def _parse_args(args, **kwargs):
                     ns.use_resources.append(r)
     if ns.random_seed is not None:
         ns.randomize = True
+    if ns.no_randomize:
+        ns.randomize = False
     if ns.verbose:
         ns.header = True
-    if ns.huntrleaks and ns.verbose3:
+
+    # When -jN option is used, a worker process does not use --verbose3
+    # and so -R 3:3 -jN --verbose3 just works as expected: there is no false
+    # alarm about memory leak.
+    if ns.huntrleaks and ns.verbose3 and ns.use_mp is None:
+        # run_single_test() replaces sys.stdout with io.StringIO if verbose3
+        # is true. In this case, huntrleaks sees an write into StringIO as
+        # a memory leak, whereas it is not (gh-71290).
         ns.verbose3 = False
         print("WARNING: Disable --verbose3 because it's incompatible with "
-              "--huntrleaks: see http://bugs.python.org/issue27103",
+              "--huntrleaks without -jN option",
               file=sys.stderr)
-    if ns.match_filename:
-        if ns.match_tests is None:
-            ns.match_tests = []
-        with open(ns.match_filename) as fp:
-            for line in fp:
-                ns.match_tests.append(line.strip())
+
+    if ns.forever:
+        # --forever implies --failfast
+        ns.failfast = True
+
+    if ns.huntrleaks:
+        warmup, repetitions, _ = ns.huntrleaks
+        if warmup < 1 or repetitions < 1:
+            msg = ("Invalid values for the --huntrleaks/-R parameters. The "
+                   "number of warmups and repetitions must be at least 1 "
+                   "each (1:1).")
+            print(msg, file=sys.stderr, flush=True)
+            sys.exit(2)
 
     return ns
diff --git a/Lib/test/libregrtest/filter.py b/Lib/test/libregrtest/filter.py
new file mode 100644
index 0000000000..41372e427f
--- /dev/null
+++ b/Lib/test/libregrtest/filter.py
@@ -0,0 +1,77 @@
+import itertools
+import operator
+import re
+
+
+# By default, don't filter tests
+_test_matchers = ()
+_test_patterns = ()
+
+
+def match_test(test):
+    # Function used by support.run_unittest() and regrtest --list-cases
+    result = False
+    for matcher, result in reversed(_test_matchers):
+        if matcher(test.id()):
+            return result
+    return not result
+
+
+def _is_full_match_test(pattern):
+    # If a pattern contains at least one dot, it's considered
+    # as a full test identifier.
+    # Example: 'test.test_os.FileTests.test_access'.
+    #
+    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
+    # or '[!...]'. For example, ignore 'test_access*'.
+    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
+
+
+def get_match_tests():
+    global _test_patterns
+    return _test_patterns
+
+
+def set_match_tests(patterns):
+    global _test_matchers, _test_patterns
+
+    if not patterns:
+        _test_matchers = ()
+        _test_patterns = ()
+    else:
+        itemgetter = operator.itemgetter
+        patterns = tuple(patterns)
+        if patterns != _test_patterns:
+            _test_matchers = [
+                (_compile_match_function(map(itemgetter(0), it)), result)
+                for result, it in itertools.groupby(patterns, itemgetter(1))
+            ]
+            _test_patterns = patterns
+
+
+def _compile_match_function(patterns):
+    patterns = list(patterns)
+
+    if all(map(_is_full_match_test, patterns)):
+        # Simple case: all patterns are full test identifier.
+        # The test.bisect_cmd utility only uses such full test identifiers.
+        return set(patterns).__contains__
+    else:
+        import fnmatch
+        regex = '|'.join(map(fnmatch.translate, patterns))
+        # The search *is* case sensitive on purpose:
+        # don't use flags=re.IGNORECASE
+        regex_match = re.compile(regex).match
+
+        def match_test_regex(test_id, regex_match=regex_match):
+            if regex_match(test_id):
+                # The regex matches the whole identifier, for example
+                # 'test.test_os.FileTests.test_access'.
+                return True
+            else:
+                # Try to match parts of the test identifier.
+                # For example, split 'test.test_os.FileTests.test_access'
+                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
+                return any(map(regex_match, test_id.split(".")))
+
+        return match_test_regex
diff --git a/Lib/test/libregrtest/findtests.py b/Lib/test/libregrtest/findtests.py
new file mode 100644
index 0000000000..f01c124077
--- /dev/null
+++ b/Lib/test/libregrtest/findtests.py
@@ -0,0 +1,110 @@
+import os
+import sys
+import unittest
+from collections.abc import Container
+
+from test import support
+
+from .filter import match_test, set_match_tests
+from .utils import (
+    StrPath, TestName, TestTuple, TestList, TestFilter,
+    abs_module_name, count, printlist)
+
+
+# If these test directories are encountered recurse into them and treat each
+# "test_*.py" file or each sub-directory as a separate test module. This can
+# increase parallelism.
+#
+# Beware this can't generally be done for any directory with sub-tests as the
+# __init__.py may do things which alter what tests are to be run.
+SPLITTESTDIRS: set[TestName] = {
+    "test_asyncio",
+    "test_concurrent_futures",
+    "test_doctests",
+    "test_future_stmt",
+    "test_gdb",
+    "test_inspect",
+    "test_pydoc",
+    "test_multiprocessing_fork",
+    "test_multiprocessing_forkserver",
+    "test_multiprocessing_spawn",
+}
+
+
+def findtestdir(path: StrPath | None = None) -> StrPath:
+    return path or os.path.dirname(os.path.dirname(__file__)) or os.curdir
+
+
+def findtests(*, testdir: StrPath | None = None, exclude: Container[str] = (),
+              split_test_dirs: set[TestName] = SPLITTESTDIRS,
+              base_mod: str = "") -> TestList:
+    """Return a list of all applicable test modules."""
+    testdir = findtestdir(testdir)
+    tests = []
+    for name in os.listdir(testdir):
+        mod, ext = os.path.splitext(name)
+        if (not mod.startswith("test_")) or (mod in exclude):
+            continue
+        if base_mod:
+            fullname = f"{base_mod}.{mod}"
+        else:
+            fullname = mod
+        if fullname in split_test_dirs:
+            subdir = os.path.join(testdir, mod)
+            if not base_mod:
+                fullname = f"test.{mod}"
+            tests.extend(findtests(testdir=subdir, exclude=exclude,
+                                   split_test_dirs=split_test_dirs,
+                                   base_mod=fullname))
+        elif ext in (".py", ""):
+            tests.append(fullname)
+    return sorted(tests)
+
+
+def split_test_packages(tests, *, testdir: StrPath | None = None,
+                        exclude: Container[str] = (),
+                        split_test_dirs=SPLITTESTDIRS) -> list[TestName]:
+    testdir = findtestdir(testdir)
+    splitted = []
+    for name in tests:
+        if name in split_test_dirs:
+            subdir = os.path.join(testdir, name)
+            splitted.extend(findtests(testdir=subdir, exclude=exclude,
+                                      split_test_dirs=split_test_dirs,
+                                      base_mod=name))
+        else:
+            splitted.append(name)
+    return splitted
+
+
+def _list_cases(suite: unittest.TestSuite) -> None:
+    for test in suite:
+        if isinstance(test, unittest.loader._FailedTest):  # type: ignore[attr-defined]
+            continue
+        if isinstance(test, unittest.TestSuite):
+            _list_cases(test)
+        elif isinstance(test, unittest.TestCase):
+            if match_test(test):
+                print(test.id())
+
+def list_cases(tests: TestTuple, *,
+               match_tests: TestFilter | None = None,
+               test_dir: StrPath | None = None) -> None:
+    support.verbose = False
+    set_match_tests(match_tests)
+
+    skipped = []
+    for test_name in tests:
+        module_name = abs_module_name(test_name, test_dir)
+        try:
+            suite = unittest.defaultTestLoader.loadTestsFromName(module_name)
+            _list_cases(suite)
+        except unittest.SkipTest:
+            skipped.append(test_name)
+
+    if skipped:
+        sys.stdout.flush()
+        stderr = sys.stderr
+        print(file=stderr)
+        print(count(len(skipped), "test"), "skipped:", file=stderr)
+        printlist(skipped, file=stderr)
diff --git a/Lib/test/libregrtest/logger.py b/Lib/test/libregrtest/logger.py
new file mode 100644
index 0000000000..fa1d4d575c
--- /dev/null
+++ b/Lib/test/libregrtest/logger.py
@@ -0,0 +1,89 @@
+import os
+import time
+
+from test.support import MS_WINDOWS
+from .results import TestResults
+from .runtests import RunTests
+from .utils import print_warning
+
+if MS_WINDOWS:
+    from .win_utils import WindowsLoadTracker
+
+
+class Logger:
+    def __init__(self, results: TestResults, quiet: bool, pgo: bool):
+        self.start_time = time.perf_counter()
+        self.test_count_text = ''
+        self.test_count_width = 3
+        self.win_load_tracker: WindowsLoadTracker | None = None
+        self._results: TestResults = results
+        self._quiet: bool = quiet
+        self._pgo: bool = pgo
+
+    def log(self, line: str = '') -> None:
+        empty = not line
+
+        # add the system load prefix: "load avg: 1.80 "
+        load_avg = self.get_load_avg()
+        if load_avg is not None:
+            line = f"load avg: {load_avg:.2f} {line}"
+
+        # add the timestamp prefix:  "0:01:05 "
+        log_time = time.perf_counter() - self.start_time
+
+        mins, secs = divmod(int(log_time), 60)
+        hours, mins = divmod(mins, 60)
+        formatted_log_time = "%d:%02d:%02d" % (hours, mins, secs)
+
+        line = f"{formatted_log_time} {line}"
+        if empty:
+            line = line[:-1]
+
+        print(line, flush=True)
+
+    def get_load_avg(self) -> float | None:
+        if hasattr(os, 'getloadavg'):
+            try:
+                return os.getloadavg()[0]
+            except OSError:
+                pass
+        if self.win_load_tracker is not None:
+            return self.win_load_tracker.getloadavg()
+        return None
+
+    def display_progress(self, test_index: int, text: str) -> None:
+        if self._quiet:
+            return
+        results = self._results
+
+        # "[ 51/405/1] test_tcl passed"
+        line = f"{test_index:{self.test_count_width}}{self.test_count_text}"
+        fails = len(results.bad) + len(results.env_changed)
+        if fails and not self._pgo:
+            line = f"{line}/{fails}"
+        self.log(f"[{line}] {text}")
+
+    def set_tests(self, runtests: RunTests) -> None:
+        if runtests.forever:
+            self.test_count_text = ''
+            self.test_count_width = 3
+        else:
+            self.test_count_text = '/{}'.format(len(runtests.tests))
+            self.test_count_width = len(self.test_count_text) - 1
+
+    def start_load_tracker(self) -> None:
+        if not MS_WINDOWS:
+            return
+
+        try:
+            self.win_load_tracker = WindowsLoadTracker()
+        except PermissionError as error:
+            # Standard accounts may not have access to the performance
+            # counters.
+            print_warning(f'Failed to create WindowsLoadTracker: {error}')
+
+    def stop_load_tracker(self) -> None:
+        if self.win_load_tracker is None:
+            return
+        self.win_load_tracker.close()
+        self.win_load_tracker = None
diff --git a/Lib/test/libregrtest/main.py b/Lib/test/libregrtest/main.py
index e1d19e1e4a..3a9c06da47 100644
--- a/Lib/test/libregrtest/main.py
+++ b/Lib/test/libregrtest/main.py
@@ -1,42 +1,34 @@
-import datetime
-import faulthandler
-import json
-import locale
 import os
-import platform
 import random
 import re
+import shlex
 import sys
 import sysconfig
-import tempfile
 import time
-import unittest
-from test.libregrtest.cmdline import _parse_args
-from test.libregrtest.runtest import (
-    findtests, runtest, get_abs_module,
-    STDTESTS, NOTTESTS, PASSED, FAILED, ENV_CHANGED, SKIPPED, RESOURCE_DENIED,
-    INTERRUPTED, CHILD_ERROR, TEST_DID_NOT_RUN,
-    PROGRESS_MIN_TIME, format_test_result)
-from test.libregrtest.setup import setup_tests
-from test.libregrtest.utils import removepy, count, format_duration, printlist
-from test import support
-from test.support import os_helper, import_helper
-
-
-# When tests are run from the Python build directory, it is best practice
-# to keep the test files in a subfolder.  This eases the cleanup of leftover
-# files using the "make distclean" command.
-if sysconfig.is_python_build():
-    TEMPDIR = sysconfig.get_config_var('abs_builddir')
-    if TEMPDIR is None:
-        # bpo-30284: On Windows, only srcdir is available. Using abs_builddir
-        # mostly matters on UNIX when building Python out of the source tree,
-        # especially when the source tree is read only.
-        TEMPDIR = sysconfig.get_config_var('srcdir')
-    TEMPDIR = os.path.join(TEMPDIR, 'build')
-else:
-    TEMPDIR = tempfile.gettempdir()
-TEMPDIR = os.path.abspath(TEMPDIR)
+import trace
+from typing import NoReturn
+
+from test.support import (os_helper, MS_WINDOWS, flush_std_streams,
+                          can_use_suppress_immortalization,
+                          suppress_immortalization)
+
+from .cmdline import _parse_args, Namespace
+from .findtests import findtests, split_test_packages, list_cases
+from .logger import Logger
+from .pgo import setup_pgo_tests
+from .result import State, TestResult
+from .results import TestResults, EXITCODE_INTERRUPTED
+from .runtests import RunTests, HuntRefleak
+from .setup import setup_process, setup_test_dir
+from .single import run_single_test, PROGRESS_MIN_TIME
+from .tsan import setup_tsan_tests
+from .utils import (
+    StrPath, StrJSON, TestName, TestList, TestTuple, TestFilter,
+    strip_py_suffix, count, format_duration,
+    printlist, get_temp_dir, get_work_dir, exit_timeout,
+    display_header, cleanup_temp_dir, print_warning,
+    is_cross_compiled, get_host_runner,
+    EXIT_TIMEOUT)
 
 
 class Regrtest:
@@ -57,357 +49,356 @@ class Regrtest:
     files beginning with test_ will be used.
 
     The other default arguments (verbose, quiet, exclude,
-    single, randomize, findleaks, use_resources, trace, coverdir,
+    single, randomize, use_resources, trace, coverdir,
     print_slow, and random_seed) allow programmers calling main()
     directly to set the values that would normally be set by flags
     on the command line.
     """
-    def __init__(self):
-        # Namespace of command line options
-        self.ns = None
+    def __init__(self, ns: Namespace, _add_python_opts: bool = False):
+        # Log verbosity
+        self.verbose: int = int(ns.verbose)
+        self.quiet: bool = ns.quiet
+        self.pgo: bool = ns.pgo
+        self.pgo_extended: bool = ns.pgo_extended
+        self.tsan: bool = ns.tsan
+
+        # Test results
+        self.results: TestResults = TestResults()
+        self.first_state: str | None = None
+
+        # Logger
+        self.logger = Logger(self.results, self.quiet, self.pgo)
+
+        # Actions
+        self.want_header: bool = ns.header
+        self.want_list_tests: bool = ns.list_tests
+        self.want_list_cases: bool = ns.list_cases
+        self.want_wait: bool = ns.wait
+        self.want_cleanup: bool = ns.cleanup
+        self.want_rerun: bool = ns.rerun
+        self.want_run_leaks: bool = ns.runleaks
+        self.want_bisect: bool = ns.bisect
+
+        self.ci_mode: bool = (ns.fast_ci or ns.slow_ci)
+        self.want_add_python_opts: bool = (_add_python_opts
+                                           and ns._add_python_opts)
+
+        # Select tests
+        self.match_tests: TestFilter = ns.match_tests
+        self.exclude: bool = ns.exclude
+        self.fromfile: StrPath | None = ns.fromfile
+        self.starting_test: TestName | None = ns.start
+        self.cmdline_args: TestList = ns.args
+
+        # Workers
+        self.single_process: bool = ns.single_process
+        if self.single_process or ns.use_mp is None:
+            num_workers = 0   # run sequentially in a single process
+        elif ns.use_mp <= 0:
+            num_workers = -1  # run in parallel, use the number of CPUs
+        else:
+            num_workers = ns.use_mp  # run in parallel
+        self.num_workers: int = num_workers
+        self.worker_json: StrJSON | None = ns.worker_json
+
+        # Options to run tests
+        self.fail_fast: bool = ns.failfast
+        self.fail_env_changed: bool = ns.fail_env_changed
+        self.fail_rerun: bool = ns.fail_rerun
+        self.forever: bool = ns.forever
+        self.output_on_failure: bool = ns.verbose3
+        self.timeout: float | None = ns.timeout
+        if ns.huntrleaks:
+            warmups, runs, filename = ns.huntrleaks
+            filename = os.path.abspath(filename)
+            self.hunt_refleak: HuntRefleak | None = HuntRefleak(warmups, runs, filename)
+        else:
+            self.hunt_refleak = None
+        self.test_dir: StrPath | None = ns.testdir
+        self.junit_filename: StrPath | None = ns.xmlpath
+        self.memory_limit: str | None = ns.memlimit
+        self.gc_threshold: int | None = ns.threshold
+        self.use_resources: tuple[str, ...] = tuple(ns.use_resources)
+        if ns.python:
+            self.python_cmd: tuple[str, ...] | None = tuple(ns.python)
+        else:
+            self.python_cmd = None
+        self.coverage: bool = ns.trace
+        self.coverage_dir: StrPath | None = ns.coverdir
+        self._tmp_dir: StrPath | None = ns.tempdir
+
+        # Randomize
+        self.randomize: bool = ns.randomize
+        if ('SOURCE_DATE_EPOCH' in os.environ
+            # don't use the variable if empty
+            and os.environ['SOURCE_DATE_EPOCH']
+        ):
+            self.randomize = False
+            # SOURCE_DATE_EPOCH should be an integer, but use a string to not
+            # fail if it's not integer. random.seed() accepts a string.
+            # https://reproducible-builds.org/docs/source-date-epoch/
+            self.random_seed: int | str = os.environ['SOURCE_DATE_EPOCH']
+        elif ns.random_seed is None:
+            self.random_seed = random.getrandbits(32)
+        else:
+            self.random_seed = ns.random_seed
 
         # tests
-        self.tests = []
-        self.selected = []
-
-        # test results
-        self.good = []
-        self.bad = []
-        self.skipped = []
-        self.resource_denieds = []
-        self.environment_changed = []
-        self.run_no_tests = []
-        self.rerun = []
-        self.first_result = None
-        self.interrupted = False
-
-        # used by --slow
-        self.test_times = []
-
-        # used by --coverage, trace.Trace instance
-        self.tracer = None
+        self.first_runtests: RunTests | None = None
+
+        # used by --slowest
+        self.print_slowest: bool = ns.print_slow
 
         # used to display the progress bar "[ 3/100]"
-        self.start_time = time.monotonic()
-        self.test_count = ''
-        self.test_count_width = 1
+        self.start_time = time.perf_counter()
 
         # used by --single
-        self.next_single_test = None
-        self.next_single_filename = None
-
-        # used by --junit-xml
-        self.testsuite_xml = None
-
-        self.win_load_tracker = None
-
-    def get_executed(self):
-        return (set(self.good) | set(self.bad) | set(self.skipped)
-                | set(self.resource_denieds) | set(self.environment_changed)
-                | set(self.run_no_tests))
-
-    def accumulate_result(self, result, rerun=False):
-        test_name = result.test_name
-        ok = result.result
-
-        if ok not in (CHILD_ERROR, INTERRUPTED) and not rerun:
-            self.test_times.append((result.test_time, test_name))
-
-        if ok == PASSED:
-            self.good.append(test_name)
-        elif ok in (FAILED, CHILD_ERROR):
-            if not rerun:
-                self.bad.append(test_name)
-        elif ok == ENV_CHANGED:
-            self.environment_changed.append(test_name)
-        elif ok == SKIPPED:
-            self.skipped.append(test_name)
-        elif ok == RESOURCE_DENIED:
-            self.skipped.append(test_name)
-            self.resource_denieds.append(test_name)
-        elif ok == TEST_DID_NOT_RUN:
-            self.run_no_tests.append(test_name)
-        elif ok == INTERRUPTED:
-            self.interrupted = True
-        else:
-            raise ValueError("invalid test result: %r" % ok)
-
-        if rerun and ok not in {FAILED, CHILD_ERROR, INTERRUPTED}:
-            self.bad.remove(test_name)
-
-        xml_data = result.xml_data
-        if xml_data:
-            import xml.etree.ElementTree as ET
-            for e in xml_data:
-                try:
-                    self.testsuite_xml.append(ET.fromstring(e))
-                except ET.ParseError:
-                    print(xml_data, file=sys.__stderr__)
-                    raise
-
-    def display_progress(self, test_index, text):
-        if self.ns.quiet:
-            return
-
-        # "[ 51/405/1] test_tcl passed"
-        line = f"{test_index:{self.test_count_width}}{self.test_count}"
-        fails = len(self.bad) + len(self.environment_changed)
-        if fails and not self.ns.pgo:
-            line = f"{line}/{fails}"
-        line = f"[{line}] {text}"
-
-        # add the system load prefix: "load avg: 1.80 "
-        load_avg = self.getloadavg()
-        if load_avg is not None:
-            line = f"load avg: {load_avg:.2f} {line}"
-
-        # add the timestamp prefix:  "0:01:05 "
-        test_time = time.monotonic() - self.start_time
-        test_time = datetime.timedelta(seconds=int(test_time))
-        line = f"{test_time} {line}"
-        print(line, flush=True)
-
-    def parse_args(self, kwargs):
-        ns = _parse_args(sys.argv[1:], **kwargs)
-
-        if ns.timeout and not hasattr(faulthandler, 'dump_traceback_later'):
-            print("Warning: The timeout option requires "
-                  "faulthandler.dump_traceback_later", file=sys.stderr)
-            ns.timeout = None
-
-        if ns.xmlpath:
-            support.junit_xml_list = self.testsuite_xml = []
-
-        # Strip .py extensions.
-        removepy(ns.args)
-
-        return ns
-
-    def find_tests(self, tests):
-        self.tests = tests
-
-        if self.ns.single:
-            self.next_single_filename = os.path.join(TEMPDIR, 'pynexttest')
+        self.single_test_run: bool = ns.single
+        self.next_single_test: TestName | None = None
+        self.next_single_filename: StrPath | None = None
+
+    def log(self, line: str = '') -> None:
+        self.logger.log(line)
+
+    def find_tests(self, tests: TestList | None = None) -> tuple[TestTuple, TestList | None]:
+        if tests is None:
+            tests = []
+        if self.single_test_run:
+            self.next_single_filename = os.path.join(self.tmp_dir, 'pynexttest')
             try:
                 with open(self.next_single_filename, 'r') as fp:
                     next_test = fp.read().strip()
-                    self.tests = [next_test]
+                    tests = [next_test]
             except OSError:
                 pass
 
-        if self.ns.fromfile:
-            self.tests = []
+        if self.fromfile:
+            tests = []
             # regex to match 'test_builtin' in line:
             # '0:00:00 [  4/400] test_builtin -- test_dict took 1 sec'
             regex = re.compile(r'\btest_[a-zA-Z0-9_]+\b')
-            with open(os.path.join(os_helper.SAVEDCWD, self.ns.fromfile)) as fp:
+            with open(os.path.join(os_helper.SAVEDCWD, self.fromfile)) as fp:
                 for line in fp:
                     line = line.split('#', 1)[0]
                     line = line.strip()
                     match = regex.search(line)
                     if match is not None:
-                        self.tests.append(match.group())
-
-        removepy(self.tests)
-
-        stdtests = STDTESTS[:]
-        nottests = NOTTESTS.copy()
-        if self.ns.exclude:
-            for arg in self.ns.args:
-                if arg in stdtests:
-                    stdtests.remove(arg)
-                nottests.add(arg)
-            self.ns.args = []
-
-        # if testdir is set, then we are not running the python tests suite, so
-        # don't add default tests to be executed or skipped (pass empty values)
-        if self.ns.testdir:
-            alltests = findtests(self.ns.testdir, list(), set())
+                        tests.append(match.group())
+
+        strip_py_suffix(tests)
+
+        exclude_tests = set()
+        if self.exclude:
+            for arg in self.cmdline_args:
+                exclude_tests.add(arg)
+            self.cmdline_args = []
+
+        if self.pgo:
+            # add default PGO tests if no tests are specified
+            setup_pgo_tests(self.cmdline_args, self.pgo_extended)
+
+        if self.tsan:
+            setup_tsan_tests(self.cmdline_args)
+
+        alltests = findtests(testdir=self.test_dir,
+                             exclude=exclude_tests)
+
+        if not self.fromfile:
+            selected = tests or self.cmdline_args
+            if exclude_tests:
+                # Support "--pgo/--tsan -x test_xxx" command
+                selected = [name for name in selected
+                            if name not in exclude_tests]
+            if selected:
+                selected = split_test_packages(selected)
+            else:
+                selected = alltests
         else:
-            alltests = findtests(self.ns.testdir, stdtests, nottests)
+            selected = tests
 
-        if not self.ns.fromfile:
-            self.selected = self.tests or self.ns.args or alltests
-        else:
-            self.selected = self.tests
-        if self.ns.single:
-            self.selected = self.selected[:1]
+        if self.single_test_run:
+            selected = selected[:1]
             try:
-                pos = alltests.index(self.selected[0])
+                pos = alltests.index(selected[0])
                 self.next_single_test = alltests[pos + 1]
             except IndexError:
                 pass
 
         # Remove all the selected tests that precede start if it's set.
-        if self.ns.start:
+        if self.starting_test:
             try:
-                del self.selected[:self.selected.index(self.ns.start)]
+                del selected[:selected.index(self.starting_test)]
             except ValueError:
-                print("Couldn't find starting test (%s), using all tests"
-                      % self.ns.start, file=sys.stderr)
+                print(f"Cannot find starting test: {self.starting_test}")
+                sys.exit(1)
 
-        if self.ns.randomize:
-            if self.ns.random_seed is None:
-                self.ns.random_seed = random.randrange(10000000)
-            random.seed(self.ns.random_seed)
-            random.shuffle(self.selected)
-
-    def list_tests(self):
-        for name in self.selected:
-            print(name)
+        random.seed(self.random_seed)
+        if self.randomize:
+            random.shuffle(selected)
 
-    def _list_cases(self, suite):
-        for test in suite:
-            if isinstance(test, unittest.loader._FailedTest):
-                continue
-            if isinstance(test, unittest.TestSuite):
-                self._list_cases(test)
-            elif isinstance(test, unittest.TestCase):
-                if support.match_test(test):
-                    print(test.id())
-
-    def list_cases(self):
-        support.verbose = False
-        support.set_match_tests(self.ns.match_tests)
-
-        for test_name in self.selected:
-            abstest = get_abs_module(self.ns, test_name)
-            try:
-                suite = unittest.defaultTestLoader.loadTestsFromName(abstest)
-                self._list_cases(suite)
-            except unittest.SkipTest:
-                self.skipped.append(test_name)
+        return (tuple(selected), tests)
 
-        if self.skipped:
-            print(file=sys.stderr)
-            print(count(len(self.skipped), "test"), "skipped:", file=sys.stderr)
-            printlist(self.skipped, file=sys.stderr)
+    @staticmethod
+    def list_tests(tests: TestTuple) -> None:
+        for name in tests:
+            print(name)
 
-    def rerun_failed_tests(self):
-        self.ns.verbose = True
-        self.ns.failfast = False
-        self.ns.verbose3 = False
+    def _rerun_failed_tests(self, runtests: RunTests) -> RunTests:
+        # Configure the runner to re-run tests
+        if self.num_workers == 0 and not self.single_process:
+            # Always run tests in fresh processes to have more deterministic
+            # initial state. Don't re-run tests in parallel but limit to a
+            # single worker process to have side effects (on the system load
+            # and timings) between tests.
+            self.num_workers = 1
+
+        tests, match_tests_dict = self.results.prepare_rerun()
+
+        # Re-run failed tests
+        runtests = runtests.copy(
+            tests=tests,
+            rerun=True,
+            verbose=True,
+            forever=False,
+            fail_fast=False,
+            match_tests_dict=match_tests_dict,
+            output_on_failure=False)
+        self.logger.set_tests(runtests)
+
+        msg = f"Re-running {len(tests)} failed tests in verbose mode"
+        if not self.single_process:
+            msg = f"{msg} in subprocesses"
+            self.log(msg)
+            self._run_tests_mp(runtests, self.num_workers)
+        else:
+            self.log(msg)
+            self.run_tests_sequentially(runtests)
+        return runtests
+
+    def rerun_failed_tests(self, runtests: RunTests) -> None:
+        if self.python_cmd:
+            # Temp patch for https://github.com/python/cpython/issues/94052
+            self.log(
+                "Re-running failed tests is not supported with --python "
+                "host runner option."
+            )
+            return
 
-        self.first_result = self.get_tests_result()
+        self.first_state = self.get_state()
 
         print()
-        print("Re-running failed tests in verbose mode")
-        self.rerun = self.bad[:]
-        for test_name in self.rerun:
-            print(f"Re-running {test_name} in verbose mode", flush=True)
-            self.ns.verbose = True
-            result = runtest(self.ns, test_name)
+        rerun_runtests = self._rerun_failed_tests(runtests)
 
-            self.accumulate_result(result, rerun=True)
+        if self.results.bad:
+            print(count(len(self.results.bad), 'test'), "failed again:")
+            printlist(self.results.bad)
 
-            if result.result == INTERRUPTED:
-                break
+        self.display_result(rerun_runtests)
 
-        if self.bad:
-            print(count(len(self.bad), 'test'), "failed again:")
-            printlist(self.bad)
+    def _run_bisect(self, runtests: RunTests, test: str, progress: str) -> bool:
+        print()
+        title = f"Bisect {test}"
+        if progress:
+            title = f"{title} ({progress})"
+        print(title)
+        print("#" * len(title))
+        print()
 
-        self.display_result()
+        cmd = runtests.create_python_cmd()
+        cmd.extend([
+            "-u", "-m", "test.bisect_cmd",
+            # Limit to 25 iterations (instead of 100) to not abuse CI resources
+            "--max-iter", "25",
+            "-v",
+            # runtests.match_tests is not used (yet) for bisect_cmd -i arg
+        ])
+        cmd.extend(runtests.bisect_cmd_args())
+        cmd.append(test)
+        print("+", shlex.join(cmd), flush=True)
+
+        flush_std_streams()
+
+        import subprocess
+        proc = subprocess.run(cmd, timeout=runtests.timeout)
+        exitcode = proc.returncode
+
+        title = f"{title}: exit code {exitcode}"
+        print(title)
+        print("#" * len(title))
+        print(flush=True)
+
+        if exitcode:
+            print(f"Bisect failed with exit code {exitcode}")
+            return False
+
+        return True
+
+    def run_bisect(self, runtests: RunTests) -> None:
+        tests, _ = self.results.prepare_rerun(clear=False)
+
+        for index, name in enumerate(tests, 1):
+            if len(tests) > 1:
+                progress = f"{index}/{len(tests)}"
+            else:
+                progress = ""
+            if not self._run_bisect(runtests, name, progress):
+                return
 
-    def display_result(self):
+    def display_result(self, runtests: RunTests) -> None:
         # If running the test suite for PGO then no one cares about results.
-        if self.ns.pgo:
+        if runtests.pgo:
             return
 
+        state = self.get_state()
         print()
-        print("== Tests result: %s ==" % self.get_tests_result())
-
-        if self.interrupted:
-            print("Test suite interrupted by signal SIGINT.")
-
-        omitted = set(self.selected) - self.get_executed()
-        if omitted:
-            print()
-            print(count(len(omitted), "test"), "omitted:")
-            printlist(omitted)
-
-        if self.good and not self.ns.quiet:
-            print()
-            if (not self.bad
-                and not self.skipped
-                and not self.interrupted
-                and len(self.good) > 1):
-                print("All", end=' ')
-            print(count(len(self.good), "test"), "OK.")
-
-        if self.ns.print_slow:
-            self.test_times.sort(reverse=True)
-            print()
-            print("10 slowest tests:")
-            for test_time, test in self.test_times[:10]:
-                print("- %s: %s" % (test, format_duration(test_time)))
-
-        if self.bad:
-            print()
-            print(count(len(self.bad), "test"), "failed:")
-            printlist(self.bad)
-
-        if self.environment_changed:
-            print()
-            print("{} altered the execution environment:".format(
-                     count(len(self.environment_changed), "test")))
-            printlist(self.environment_changed)
-
-        if self.skipped and not self.ns.quiet:
-            print()
-            print(count(len(self.skipped), "test"), "skipped:")
-            printlist(self.skipped)
-
-        if self.rerun:
-            print()
-            print("%s:" % count(len(self.rerun), "re-run test"))
-            printlist(self.rerun)
-
-        if self.run_no_tests:
-            print()
-            print(count(len(self.run_no_tests), "test"), "run no tests:")
-            printlist(self.run_no_tests)
-
-    def run_tests_sequential(self):
-        if self.ns.trace:
-            import trace
-            self.tracer = trace.Trace(trace=False, count=True)
+        print(f"== Tests result: {state} ==")
+
+        self.results.display_result(runtests.tests,
+                                    self.quiet, self.print_slowest)
+
+    def run_test(
+        self, test_name: TestName, runtests: RunTests, tracer: trace.Trace | None
+    ) -> TestResult:
+        if tracer is not None:
+            # If we're tracing code coverage, then we don't exit with status
+            # if on a false return value from main.
+            cmd = ('result = run_single_test(test_name, runtests)')
+            namespace = dict(locals())
+            tracer.runctx(cmd, globals=globals(), locals=namespace)
+            result = namespace['result']
+            result.covered_lines = list(tracer.counts)
+        else:
+            result = run_single_test(test_name, runtests)
+
+        self.results.accumulate_result(result, runtests)
+
+        return result
+
+    def run_tests_sequentially(self, runtests: RunTests) -> None:
+        if self.coverage:
+            tracer = trace.Trace(trace=False, count=True)
+        else:
+            tracer = None
 
         save_modules = set(sys.modules)
 
-        print("Run tests sequentially")
-
-        previous_test = None
-        for test_index, test_name in enumerate(self.tests, 1):
-            start_time = time.monotonic()
-
-            text = test_name
-            if previous_test:
-                text = '%s -- %s' % (text, previous_test)
-            self.display_progress(test_index, text)
-
-            if self.tracer:
-                # If we're tracing code coverage, then we don't exit with status
-                # if on a false return value from main.
-                cmd = ('result = runtest(self.ns, test_name); '
-                       'self.accumulate_result(result)')
-                ns = dict(locals())
-                self.tracer.runctx(cmd, globals=globals(), locals=ns)
-                result = ns['result']
-            else:
-                result = runtest(self.ns, test_name)
-                self.accumulate_result(result)
+        jobs = runtests.get_jobs()
+        if jobs is not None:
+            tests = count(jobs, 'test')
+        else:
+            tests = 'tests'
+        msg = f"Run {tests} sequentially in a single process"
+        if runtests.timeout:
+            msg += " (timeout: %s)" % format_duration(runtests.timeout)
+        self.log(msg)
 
-            if result.result == INTERRUPTED:
-                break
+        tests_iter = runtests.iter_tests()
+        for test_index, test_name in enumerate(tests_iter, 1):
+            start_time = time.perf_counter()
 
-            previous_test = format_test_result(result)
-            test_time = time.monotonic() - start_time
-            if test_time >= PROGRESS_MIN_TIME:
-                previous_test = "%s in %s" % (previous_test, format_duration(test_time))
-            elif result[0] == PASSED:
-                # be quiet: say nothing if the test passed shortly
-                previous_test = None
+            self.logger.display_progress(test_index, test_name)
+
+            result = self.run_test(test_name, runtests, tracer)
 
             # Unload the newly imported test modules (best effort finalization)
             new_modules = [module for module in sys.modules
@@ -422,95 +413,26 @@ def run_tests_sequential(self):
                 except (KeyError, AttributeError):
                     pass
 
-        if previous_test:
-            print(previous_test)
-
-    def _test_forever(self, tests):
-        while True:
-            for test_name in tests:
-                yield test_name
-                if self.bad:
-                    return
-                if self.ns.fail_env_changed and self.environment_changed:
-                    return
-
-    def display_header(self):
-        # Print basic platform information
-        print("==", platform.python_implementation(), *sys.version.split())
-        try:
-            print("==", platform.platform(aliased=True),
-                          "%s-endian" % sys.byteorder)
-        except:
-            print("== RustPython: Need to fix platform.platform")
-        print("== cwd:", os.getcwd())
-        cpu_count = os.cpu_count()
-        if cpu_count:
-            print("== CPU count:", cpu_count)
-        try:
-            print("== encodings: locale=%s, FS=%s"
-              % (locale.getpreferredencoding(False),
-                 sys.getfilesystemencoding()))
-        except:
-            print("== RustPython: Need to fix encoding stuff")
-
-    def get_tests_result(self):
-        result = []
-        if self.bad:
-            result.append("FAILURE")
-        elif self.ns.fail_env_changed and self.environment_changed:
-            result.append("ENV CHANGED")
-        elif not any((self.good, self.bad, self.skipped, self.interrupted,
-            self.environment_changed)):
-            result.append("NO TEST RUN")
-
-        if self.interrupted:
-            result.append("INTERRUPTED")
-
-        if not result:
-            result.append("SUCCESS")
-
-        result = ', '.join(result)
-        if self.first_result:
-            result = '%s then %s' % (self.first_result, result)
-        return result
+            text = str(result)
+            test_time = time.perf_counter() - start_time
+            if test_time >= PROGRESS_MIN_TIME:
+                text = f"{text} in {format_duration(test_time)}"
+            self.logger.display_progress(test_index, text)
 
-    def run_tests(self):
-        # For a partial run, we do not need to clutter the output.
-        if (self.ns.header
-            or not(self.ns.pgo or self.ns.quiet or self.ns.single
-                   or self.tests or self.ns.args)):
-            self.display_header()
-
-        if self.ns.huntrleaks:
-            warmup, repetitions, _ = self.ns.huntrleaks
-            if warmup < 3:
-                msg = ("WARNING: Running tests with --huntrleaks/-R and less than "
-                        "3 warmup repetitions can give false positives!")
-                print(msg, file=sys.stdout, flush=True)
-
-        if self.ns.randomize:
-            print("Using random seed", self.ns.random_seed)
-
-        if self.ns.forever:
-            self.tests = self._test_forever(list(self.selected))
-            self.test_count = ''
-            self.test_count_width = 3
-        else:
-            self.tests = iter(self.selected)
-            self.test_count = '/{}'.format(len(self.selected))
-            self.test_count_width = len(self.test_count) - 1
+            if result.must_stop(self.fail_fast, self.fail_env_changed):
+                break
 
-        if self.ns.use_mp:
-            from test.libregrtest.runtest_mp import run_tests_multiprocess
-            run_tests_multiprocess(self)
-        else:
-            self.run_tests_sequential()
+    def get_state(self) -> str:
+        state = self.results.get_state(self.fail_env_changed)
+        if self.first_state:
+            state = f'{self.first_state} then {state}'
+        return state
 
-    def finalize(self):
-        if self.win_load_tracker is not None:
-            self.win_load_tracker.close()
-            self.win_load_tracker = None
+    def _run_tests_mp(self, runtests: RunTests, num_workers: int) -> None:
+        from .run_workers import RunWorkers
+        RunWorkers(num_workers, runtests, self.logger, self.results).run()
 
+    def finalize_tests(self, coverage: trace.CoverageResults | None) -> None:
         if self.next_single_filename:
             if self.next_single_test:
                 with open(self.next_single_filename, 'w') as fp:
@@ -518,141 +440,337 @@ def finalize(self):
             else:
                 os.unlink(self.next_single_filename)
 
-        if self.tracer:
-            r = self.tracer.results()
-            r.write_results(show_missing=True, summary=True,
-                            coverdir=self.ns.coverdir)
+        if coverage is not None:
+            # uses a new-in-Python 3.13 keyword argument that mypy doesn't know about yet:
+            coverage.write_results(show_missing=True, summary=True,  # type: ignore[call-arg]
+                                   coverdir=self.coverage_dir,
+                                   ignore_missing_files=True)
+
+        if self.want_run_leaks:
+            os.system("leaks %d" % os.getpid())
 
+        if self.junit_filename:
+            self.results.write_junit(self.junit_filename)
+
+    def display_summary(self) -> None:
+        if self.first_runtests is None:
+            raise ValueError(
+                "Should never call `display_summary()` before calling `_run_test()`"
+            )
+
+        duration = time.perf_counter() - self.logger.start_time
+        filtered = bool(self.match_tests)
+
+        # Total duration
         print()
-        duration = time.monotonic() - self.start_time
         print("Total duration: %s" % format_duration(duration))
-        print("Tests result: %s" % self.get_tests_result())
 
-        if self.ns.runleaks:
-            os.system("leaks %d" % os.getpid())
+        self.results.display_summary(self.first_runtests, filtered)
+
+        # Result
+        state = self.get_state()
+        print(f"Result: {state}")
+
+    def create_run_tests(self, tests: TestTuple) -> RunTests:
+        return RunTests(
+            tests,
+            fail_fast=self.fail_fast,
+            fail_env_changed=self.fail_env_changed,
+            match_tests=self.match_tests,
+            match_tests_dict=None,
+            rerun=False,
+            forever=self.forever,
+            pgo=self.pgo,
+            pgo_extended=self.pgo_extended,
+            output_on_failure=self.output_on_failure,
+            timeout=self.timeout,
+            verbose=self.verbose,
+            quiet=self.quiet,
+            hunt_refleak=self.hunt_refleak,
+            test_dir=self.test_dir,
+            use_junit=(self.junit_filename is not None),
+            coverage=self.coverage,
+            memory_limit=self.memory_limit,
+            gc_threshold=self.gc_threshold,
+            use_resources=self.use_resources,
+            python_cmd=self.python_cmd,
+            randomize=self.randomize,
+            random_seed=self.random_seed,
+        )
+
+    def _run_tests(self, selected: TestTuple, tests: TestList | None) -> int:
+        if self.hunt_refleak and self.hunt_refleak.warmups < 3:
+            msg = ("WARNING: Running tests with --huntrleaks/-R and "
+                   "less than 3 warmup repetitions can give false positives!")
+            print(msg, file=sys.stdout, flush=True)
+
+        if self.num_workers < 0:
+            # Use all CPUs + 2 extra worker processes for tests
+            # that like to sleep
+            #
+            # os.process.cpu_count() is new in Python 3.13;
+            # mypy doesn't know about it yet
+            self.num_workers = (os.process_cpu_count() or 1) + 2  # type: ignore[attr-defined]
 
-    def save_xml_result(self):
-        if not self.ns.xmlpath and not self.testsuite_xml:
-            return
+        # For a partial run, we do not need to clutter the output.
+        if (self.want_header
+            or not(self.pgo or self.quiet or self.single_test_run
+                   or tests or self.cmdline_args)):
+            display_header(self.use_resources, self.python_cmd)
 
-        import xml.etree.ElementTree as ET
-        root = ET.Element("testsuites")
+        print("Using random seed:", self.random_seed)
 
-        # Manually count the totals for the overall summary
-        totals = {'tests': 0, 'errors': 0, 'failures': 0}
-        for suite in self.testsuite_xml:
-            root.append(suite)
-            for k in totals:
-                try:
-                    totals[k] += int(suite.get(k, 0))
-                except ValueError:
-                    pass
+        runtests = self.create_run_tests(selected)
+        self.first_runtests = runtests
+        self.logger.set_tests(runtests)
 
-        for k, v in totals.items():
-            root.set(k, str(v))
-
-        xmlpath = os.path.join(os_helper.SAVEDCWD, self.ns.xmlpath)
-        with open(xmlpath, 'wb') as f:
-            for s in ET.tostringlist(root):
-                f.write(s)
-
-    def main(self, tests=None, **kwargs):
-        global TEMPDIR
-        self.ns = self.parse_args(kwargs)
-
-        if self.ns.tempdir:
-            TEMPDIR = self.ns.tempdir
-        elif self.ns.worker_args:
-            ns_dict, _ = json.loads(self.ns.worker_args)
-            TEMPDIR = ns_dict.get("tempdir") or TEMPDIR
-
-        os.makedirs(TEMPDIR, exist_ok=True)
-
-        # Define a writable temp dir that will be used as cwd while running
-        # the tests. The name of the dir includes the pid to allow parallel
-        # testing (see the -j option).
-        test_cwd = 'test_python_{}'.format(os.getpid())
-        test_cwd = os.path.join(TEMPDIR, test_cwd)
-
-        # Run the tests in a context manager that temporarily changes the CWD to a
-        # temporary and writable directory.  If it's not possible to create or
-        # change the CWD, the original CWD will be used.  The original CWD is
-        # available from os_helper.SAVEDCWD.
-        with os_helper.temp_cwd(test_cwd, quiet=True):
-            self._main(tests, kwargs)
-
-    def getloadavg(self):
-        if self.win_load_tracker is not None:
-            return self.win_load_tracker.getloadavg()
-
-        if hasattr(os, 'getloadavg'):
-            return os.getloadavg()[0]
-
-        return None
-
-    def _main(self, tests, kwargs):
-        if self.ns.huntrleaks:
-            warmup, repetitions, _ = self.ns.huntrleaks
-            if warmup < 1 or repetitions < 1:
-                msg = ("Invalid values for the --huntrleaks/-R parameters. The "
-                       "number of warmups and repetitions must be at least 1 "
-                       "each (1:1).")
-                print(msg, file=sys.stderr, flush=True)
-                sys.exit(2)
-
-        if self.ns.worker_args is not None:
-            from test.libregrtest.runtest_mp import run_tests_worker
-            run_tests_worker(self.ns.worker_args)
-
-        if self.ns.wait:
-            input("Press any key to continue...")
+        if (runtests.hunt_refleak is not None) and (not self.num_workers):
+            # gh-109739: WindowsLoadTracker thread interferes with refleak check
+            use_load_tracker = False
+        else:
+            # WindowsLoadTracker is only needed on Windows
+            # use_load_tracker = MS_WINDOWS  # TODO: RUSTPYTHON, investigate why this was disabled in the first place
+            use_load_tracker = False
 
-        support.PGO = self.ns.pgo
+        if use_load_tracker:
+            self.logger.start_load_tracker()
+        try:
+            if self.num_workers:
+                self._run_tests_mp(runtests, self.num_workers)
+            else:
+                # gh-135734: suppress_immortalization() raises SkipTest
+                # if _testinternalcapi is missing and the -R option is set.
+                if not can_use_suppress_immortalization(runtests.hunt_refleak):
+                    print("Module '_testinternalcapi' is missing. "
+                          "Did you disable it with --disable-test-modules?",
+                          file=sys.stderr)
+                    raise SystemExit(1)
+
+                # gh-117783: don't immortalize deferred objects when tracking
+                # refleaks. Only relevant for the free-threaded build.
+                with suppress_immortalization(runtests.hunt_refleak):
+                    self.run_tests_sequentially(runtests)
+
+            coverage = self.results.get_coverage_results()
+            self.display_result(runtests)
+
+            if self.want_rerun and self.results.need_rerun():
+                self.rerun_failed_tests(runtests)
+
+            if self.want_bisect and self.results.need_rerun():
+                self.run_bisect(runtests)
+        finally:
+            if use_load_tracker:
+                self.logger.stop_load_tracker()
+
+        self.display_summary()
+        self.finalize_tests(coverage)
+
+        return self.results.get_exitcode(self.fail_env_changed,
+                                         self.fail_rerun)
+
+    def run_tests(self, selected: TestTuple, tests: TestList | None) -> int:
+        os.makedirs(self.tmp_dir, exist_ok=True)
+        work_dir = get_work_dir(self.tmp_dir)
+
+        # Put a timeout on Python exit
+        with exit_timeout():
+            # Run the tests in a context manager that temporarily changes the
+            # CWD to a temporary and writable directory. If it's not possible
+            # to create or change the CWD, the original CWD will be used.
+            # The original CWD is available from os_helper.SAVEDCWD.
+            with os_helper.temp_cwd(work_dir, quiet=True):
+                # When using multiprocessing, worker processes will use
+                # work_dir as their parent temporary directory. So when the
+                # main process exit, it removes also subdirectories of worker
+                # processes.
+                return self._run_tests(selected, tests)
+
+    def _add_cross_compile_opts(self, regrtest_opts):
+        # WASM/WASI buildbot builders pass multiple PYTHON environment
+        # variables such as PYTHONPATH and _PYTHON_HOSTRUNNER.
+        keep_environ = bool(self.python_cmd)
+        environ = None
+
+        # Are we using cross-compilation?
+        cross_compile = is_cross_compiled()
+
+        # Get HOSTRUNNER
+        hostrunner = get_host_runner()
+
+        if cross_compile:
+            # emulate -E, but keep PYTHONPATH + cross compile env vars,
+            # so test executable can load correct sysconfigdata file.
+            keep = {
+                '_PYTHON_PROJECT_BASE',
+                '_PYTHON_HOST_PLATFORM',
+                '_PYTHON_SYSCONFIGDATA_NAME',
+                "_PYTHON_SYSCONFIGDATA_PATH",
+                'PYTHONPATH'
+            }
+            old_environ = os.environ
+            new_environ = {
+                name: value for name, value in os.environ.items()
+                if not name.startswith(('PYTHON', '_PYTHON')) or name in keep
+            }
+            # Only set environ if at least one variable was removed
+            if new_environ != old_environ:
+                environ = new_environ
+            keep_environ = True
+
+        if cross_compile and hostrunner:
+            if self.num_workers == 0 and not self.single_process:
+                # For now use only two cores for cross-compiled builds;
+                # hostrunner can be expensive.
+                regrtest_opts.extend(['-j', '2'])
+
+            # If HOSTRUNNER is set and -p/--python option is not given, then
+            # use hostrunner to execute python binary for tests.
+            if not self.python_cmd:
+                buildpython = sysconfig.get_config_var("BUILDPYTHON")
+                python_cmd = f"{hostrunner} {buildpython}"
+                regrtest_opts.extend(["--python", python_cmd])
+                keep_environ = True
+
+        return (environ, keep_environ)
+
+    def _add_ci_python_opts(self, python_opts, keep_environ):
+        # --fast-ci and --slow-ci add options to Python.
+        #
+        # Some platforms run tests in embedded mode and cannot change options
+        # after startup, so if this function changes, consider also updating:
+        #  * gradle_task in Android/android.py
+
+        # Unbuffered stdout and stderr. This isn't helpful on Android, because
+        # it would cause lines to be split into multiple log messages.
+        if not sys.stdout.write_through and sys.platform != "android":
+            python_opts.append('-u')
+
+        # Add warnings filter 'error', unless the user specified a different
+        # filter. Ignore BytesWarning since it's controlled by '-b' below.
+        if not [
+            opt for opt in sys.warnoptions
+            if not opt.endswith("::BytesWarning")
+        ]:
+            python_opts.extend(('-W', 'error'))
+
+        # Error on bytes/str comparison
+        if sys.flags.bytes_warning < 2:
+            python_opts.append('-bb')
+
+        if not keep_environ:
+            # Ignore PYTHON* environment variables
+            if not sys.flags.ignore_environment:
+                python_opts.append('-E')
+
+    def _execute_python(self, cmd, environ):
+        # Make sure that messages before execv() are logged
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+        cmd_text = shlex.join(cmd)
+        try:
+            # Android and iOS run tests in embedded mode. To update their
+            # Python options, see the comment in _add_ci_python_opts.
+            if not cmd[0]:
+                raise ValueError("No Python executable is present")
+
+            print(f"+ {cmd_text}", flush=True)
+            if hasattr(os, 'execv') and not MS_WINDOWS:
+                os.execv(cmd[0], cmd)
+                # On success, execv() do no return.
+                # On error, it raises an OSError.
+            else:
+                import subprocess
+                with subprocess.Popen(cmd, env=environ) as proc:
+                    try:
+                        proc.wait()
+                    except KeyboardInterrupt:
+                        # There is no need to call proc.terminate(): on CTRL+C,
+                        # SIGTERM is also sent to the child process.
+                        try:
+                            proc.wait(timeout=EXIT_TIMEOUT)
+                        except subprocess.TimeoutExpired:
+                            proc.kill()
+                            proc.wait()
+                            sys.exit(EXITCODE_INTERRUPTED)
+
+                sys.exit(proc.returncode)
+        except Exception as exc:
+            print_warning(f"Failed to change Python options: {exc!r}\n"
+                          f"Command: {cmd_text}")
+            # continue executing main()
+
+    def _add_python_opts(self) -> None:
+        python_opts: list[str] = []
+        regrtest_opts: list[str] = []
+
+        environ, keep_environ = self._add_cross_compile_opts(regrtest_opts)
+        if self.ci_mode:
+            self._add_ci_python_opts(python_opts, keep_environ)
+
+        if (not python_opts) and (not regrtest_opts) and (environ is None):
+            # Nothing changed: nothing to do
+            return
 
-        setup_tests(self.ns)
+        # Create new command line
+        cmd = list(sys.orig_argv)
+        if python_opts:
+            cmd[1:1] = python_opts
+        if regrtest_opts:
+            cmd.extend(regrtest_opts)
+        cmd.append("--dont-add-python-opts")
 
-        self.find_tests(tests)
+        self._execute_python(cmd, environ)
 
-        if self.ns.list_tests:
-            self.list_tests()
-            sys.exit(0)
+    def _init(self):
+        setup_process()
 
-        if self.ns.list_cases:
-            self.list_cases()
-            sys.exit(0)
+        if self.junit_filename and not os.path.isabs(self.junit_filename):
+            self.junit_filename = os.path.abspath(self.junit_filename)
 
-        # If we're on windows and this is the parent runner (not a worker),
-        # track the load average.
-        # TODO: RUSTPYTHON
-        # if sys.platform == 'win32' and (self.ns.worker_args is None):
-        #     from test.libregrtest.win_utils import WindowsLoadTracker
+        strip_py_suffix(self.cmdline_args)
 
-        #     try:
-        #         self.win_load_tracker = WindowsLoadTracker()
-        #     except FileNotFoundError as error:
-        #         # Windows IoT Core and Windows Nano Server do not provide
-        #         # typeperf.exe for x64, x86 or ARM
-        #         print(f'Failed to create WindowsLoadTracker: {error}')
+        self._tmp_dir = get_temp_dir(self._tmp_dir)
 
-        self.run_tests()
-        self.display_result()
+    @property
+    def tmp_dir(self) -> StrPath:
+        if self._tmp_dir is None:
+            raise ValueError(
+                "Should never use `.tmp_dir` before calling `.main()`"
+            )
+        return self._tmp_dir
 
-        if self.ns.verbose2 and self.bad:
-            self.rerun_failed_tests()
+    def main(self, tests: TestList | None = None) -> NoReturn:
+        if self.want_add_python_opts:
+            self._add_python_opts()
 
-        self.finalize()
+        self._init()
+
+        if self.want_cleanup:
+            cleanup_temp_dir(self.tmp_dir)
+            sys.exit(0)
 
-        self.save_xml_result()
+        if self.want_wait:
+            input("Press any key to continue...")
+
+        setup_test_dir(self.test_dir)
+        selected, tests = self.find_tests(tests)
+
+        exitcode = 0
+        if self.want_list_tests:
+            self.list_tests(selected)
+        elif self.want_list_cases:
+            list_cases(selected,
+                       match_tests=self.match_tests,
+                       test_dir=self.test_dir)
+        else:
+            exitcode = self.run_tests(selected, tests)
 
-        if self.bad:
-            sys.exit(2)
-        if self.interrupted:
-            sys.exit(130)
-        if self.ns.fail_env_changed and self.environment_changed:
-            sys.exit(3)
-        sys.exit(0)
+        sys.exit(exitcode)
 
 
-def main(tests=None, **kwargs):
+def main(tests=None, _add_python_opts=False, **kwargs) -> NoReturn:
     """Run the Python suite."""
-    Regrtest().main(tests=tests, **kwargs)
+    ns = _parse_args(sys.argv[1:], **kwargs)
+    Regrtest(ns, _add_python_opts=_add_python_opts).main(tests=tests)
diff --git a/Lib/test/libregrtest/mypy.ini b/Lib/test/libregrtest/mypy.ini
new file mode 100644
index 0000000000..3fa9afcb7a
--- /dev/null
+++ b/Lib/test/libregrtest/mypy.ini
@@ -0,0 +1,26 @@
+# Config file for running mypy on libregrtest.
+# Run mypy by invoking `mypy --config-file Lib/test/libregrtest/mypy.ini`
+# on the command-line from the repo root
+
+[mypy]
+files = Lib/test/libregrtest
+explicit_package_bases = True
+python_version = 3.12
+platform = linux
+pretty = True
+
+# Enable most stricter settings
+enable_error_code = ignore-without-code
+strict = True
+
+# Various stricter settings that we can't yet enable
+# Try to enable these in the following order:
+disallow_incomplete_defs = False
+disallow_untyped_calls = False
+disallow_untyped_defs = False
+check_untyped_defs = False
+warn_return_any = False
+
+# Various internal modules that typeshed deliberately doesn't have stubs for:
+[mypy-_abc.*,_opcode.*,_overlapped.*,_testcapi.*,_testinternalcapi.*,test.*]
+ignore_missing_imports = True
diff --git a/Lib/test/libregrtest/pgo.py b/Lib/test/libregrtest/pgo.py
new file mode 100644
index 0000000000..04803ddf64
--- /dev/null
+++ b/Lib/test/libregrtest/pgo.py
@@ -0,0 +1,55 @@
+# Set of tests run by default if --pgo is specified.  The tests below were
+# chosen based on the following criteria: either they exercise a commonly used
+# C extension module or type, or they run some relatively typical Python code.
+# Long running tests should be avoided because the PGO instrumented executable
+# runs slowly.
+PGO_TESTS = [
+    'test_array',
+    'test_base64',
+    'test_binascii',
+    'test_binop',
+    'test_bisect',
+    'test_bytes',
+    'test_bz2',
+    'test_cmath',
+    'test_codecs',
+    'test_collections',
+    'test_complex',
+    'test_dataclasses',
+    'test_datetime',
+    'test_decimal',
+    'test_difflib',
+    'test_float',
+    'test_fstring',
+    'test_functools',
+    'test_generators',
+    'test_hashlib',
+    'test_heapq',
+    'test_int',
+    'test_itertools',
+    'test_json',
+    'test_long',
+    'test_lzma',
+    'test_math',
+    'test_memoryview',
+    'test_operator',
+    'test_ordered_dict',
+    'test_patma',
+    'test_pickle',
+    'test_pprint',
+    'test_re',
+    'test_set',
+    'test_sqlite3',
+    'test_statistics',
+    'test_str',
+    'test_struct',
+    'test_tabnanny',
+    'test_time',
+    'test_xml_etree',
+    'test_xml_etree_c',
+]
+
+def setup_pgo_tests(cmdline_args, pgo_extended: bool) -> None:
+    if not cmdline_args and not pgo_extended:
+        # run default set of tests for PGO training
+        cmdline_args[:] = PGO_TESTS[:]
diff --git a/Lib/test/libregrtest/refleak.py b/Lib/test/libregrtest/refleak.py
index 03747f7f75..75fcd118d7 100644
--- a/Lib/test/libregrtest/refleak.py
+++ b/Lib/test/libregrtest/refleak.py
@@ -1,9 +1,17 @@
 import os
-import re
 import sys
 import warnings
 from inspect import isabstract
+from typing import Any
+import linecache
+
 from test import support
+from test.support import os_helper
+from test.support import refleak_helper
+
+from .runtests import HuntRefleak
+from .utils import clear_caches
+
 try:
     from _abc import _get_dump
 except ImportError:
@@ -17,7 +25,33 @@ def _get_dump(cls):
                 cls._abc_negative_cache, cls._abc_negative_cache_version)
 
 
-def dash_R(ns, test_name, test_func):
+def save_support_xml(filename):
+    if support.junit_xml_list is None:
+        return
+
+    import pickle
+    with open(filename, 'xb') as fp:
+        pickle.dump(support.junit_xml_list, fp)
+    support.junit_xml_list = None
+
+
+def restore_support_xml(filename):
+    try:
+        fp = open(filename, 'rb')
+    except FileNotFoundError:
+        return
+
+    import pickle
+    with fp:
+        xml_list = pickle.load(fp)
+    os.unlink(filename)
+
+    support.junit_xml_list = xml_list
+
+
+def runtest_refleak(test_name, test_func,
+                    hunt_refleak: HuntRefleak,
+                    quiet: bool):
     """Run a test multiple times, looking for reference leaks.
 
     Returns:
@@ -39,12 +73,19 @@ def dash_R(ns, test_name, test_func):
     fs = warnings.filters[:]
     ps = copyreg.dispatch_table.copy()
     pic = sys.path_importer_cache.copy()
+    zdc: dict[str, Any] | None
+    # Linecache holds a cache with the source of interactive code snippets
+    # (e.g. code typed in the REPL). This cache is not cleared by
+    # linecache.clearcache(). We need to save and restore it to avoid false
+    # positives.
+    linecache_data = linecache.cache.copy(), linecache._interactive_cache.copy() # type: ignore[attr-defined]
     try:
         import zipimport
     except ImportError:
         zdc = None # Run unmodified on platforms without zipimport support
     else:
-        zdc = zipimport._zip_directory_cache.copy()
+        # private attribute that mypy doesn't know about:
+        zdc = zipimport._zip_directory_cache.copy()  # type: ignore[attr-defined]
     abcs = {}
     for abc in [getattr(collections.abc, a) for a in collections.abc.__all__]:
         if not isabstract(abc):
@@ -60,9 +101,10 @@ def dash_R(ns, test_name, test_func):
     def get_pooled_int(value):
         return int_pool.setdefault(value, value)
 
-    nwarmup, ntracked, fname = ns.huntrleaks
-    fname = os.path.join(os_helper.SAVEDCWD, fname)
-    repcount = nwarmup + ntracked
+    warmups = hunt_refleak.warmups
+    runs = hunt_refleak.runs
+    filename = hunt_refleak.filename
+    repcount = warmups + runs
 
     # Pre-allocate to ensure that the loop doesn't allocate anything new
     rep_range = list(range(repcount))
@@ -71,45 +113,81 @@ def get_pooled_int(value):
     fd_deltas = [0] * repcount
     getallocatedblocks = sys.getallocatedblocks
     gettotalrefcount = sys.gettotalrefcount
-    fd_count = support.fd_count
-
+    getunicodeinternedsize = sys.getunicodeinternedsize
+    fd_count = os_helper.fd_count
     # initialize variables to make pyflakes quiet
-    rc_before = alloc_before = fd_before = 0
-
-    if not ns.quiet:
-        print("beginning", repcount, "repetitions", file=sys.stderr)
-        print(("1234567890"*(repcount//10 + 1))[:repcount], file=sys.stderr,
-              flush=True)
-
-    dash_R_cleanup(fs, ps, pic, zdc, abcs)
+    rc_before = alloc_before = fd_before = interned_immortal_before = 0
+
+    if not quiet:
+        print("beginning", repcount, "repetitions. Showing number of leaks "
+                "(. for 0 or less, X for 10 or more)",
+              file=sys.stderr)
+        numbers = ("1234567890"*(repcount//10 + 1))[:repcount]
+        numbers = numbers[:warmups] + ':' + numbers[warmups:]
+        print(numbers, file=sys.stderr, flush=True)
+
+    xml_filename = 'refleak-xml.tmp'
+    result = None
+    dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data)
+    support.gc_collect()
 
     for i in rep_range:
-        test_func()
-        dash_R_cleanup(fs, ps, pic, zdc, abcs)
-
-        # dash_R_cleanup() ends with collecting cyclic trash:
-        # read memory statistics immediately after.
-        alloc_after = getallocatedblocks()
+        current = refleak_helper._hunting_for_refleaks
+        refleak_helper._hunting_for_refleaks = True
+        try:
+            result = test_func()
+        finally:
+            refleak_helper._hunting_for_refleaks = current
+
+        save_support_xml(xml_filename)
+        dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data)
+        support.gc_collect()
+
+        # Read memory statistics immediately after the garbage collection.
+        # Also, readjust the reference counts and alloc blocks by ignoring
+        # any strings that might have been interned during test_func. These
+        # strings will be deallocated at runtime shutdown
+        interned_immortal_after = getunicodeinternedsize(
+            # Use an internal-only keyword argument that mypy doesn't know yet
+            _only_immortal=True)  # type: ignore[call-arg]
+        alloc_after = getallocatedblocks() - interned_immortal_after
         rc_after = gettotalrefcount()
         fd_after = fd_count()
 
-        if not ns.quiet:
-            print('.', end='', file=sys.stderr, flush=True)
-
         rc_deltas[i] = get_pooled_int(rc_after - rc_before)
         alloc_deltas[i] = get_pooled_int(alloc_after - alloc_before)
         fd_deltas[i] = get_pooled_int(fd_after - fd_before)
 
+        if not quiet:
+            # use max, not sum, so total_leaks is one of the pooled ints
+            total_leaks = max(rc_deltas[i], alloc_deltas[i], fd_deltas[i])
+            if total_leaks <= 0:
+                symbol = '.'
+            elif total_leaks < 10:
+                symbol = (
+                    '.', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+                    )[total_leaks]
+            else:
+                symbol = 'X'
+            if i == warmups:
+                print(' ', end='', file=sys.stderr, flush=True)
+            print(symbol, end='', file=sys.stderr, flush=True)
+            del total_leaks
+            del symbol
+
         alloc_before = alloc_after
         rc_before = rc_after
         fd_before = fd_after
+        interned_immortal_before = interned_immortal_after
+
+        restore_support_xml(xml_filename)
 
-    if not ns.quiet:
+    if not quiet:
         print(file=sys.stderr)
 
     # These checkers return False on success, True on failure
     def check_rc_deltas(deltas):
-        # Checker for reference counters and memomry blocks.
+        # Checker for reference counters and memory blocks.
         #
         # bpo-30776: Try to ignore false positives:
         #
@@ -133,19 +211,25 @@ def check_fd_deltas(deltas):
         (fd_deltas, 'file descriptors', check_fd_deltas)
     ]:
         # ignore warmup runs
-        deltas = deltas[nwarmup:]
-        if checker(deltas):
+        deltas = deltas[warmups:]
+        failing = checker(deltas)
+        suspicious = any(deltas)
+        if failing or suspicious:
             msg = '%s leaked %s %s, sum=%s' % (
                 test_name, deltas, item_name, sum(deltas))
-            print(msg, file=sys.stderr, flush=True)
-            with open(fname, "a") as refrep:
-                print(msg, file=refrep)
-                refrep.flush()
-            failed = True
-    return failed
-
-
-def dash_R_cleanup(fs, ps, pic, zdc, abcs):
+            print(msg, end='', file=sys.stderr)
+            if failing:
+                print(file=sys.stderr, flush=True)
+                with open(filename, "a", encoding="utf-8") as refrep:
+                    print(msg, file=refrep)
+                    refrep.flush()
+                failed = True
+            else:
+                print(' (this is fine)', file=sys.stderr, flush=True)
+    return (failed, result)
+
+
+def dash_R_cleanup(fs, ps, pic, zdc, abcs, linecache_data):
     import copyreg
     import collections.abc
 
@@ -155,6 +239,11 @@ def dash_R_cleanup(fs, ps, pic, zdc, abcs):
     copyreg.dispatch_table.update(ps)
     sys.path_importer_cache.clear()
     sys.path_importer_cache.update(pic)
+    lcache, linteractive = linecache_data
+    linecache._interactive_cache.clear()
+    linecache._interactive_cache.update(linteractive)
+    linecache.cache.clear()
+    linecache.cache.update(lcache)
     try:
         import zipimport
     except ImportError:
@@ -163,121 +252,29 @@ def dash_R_cleanup(fs, ps, pic, zdc, abcs):
         zipimport._zip_directory_cache.clear()
         zipimport._zip_directory_cache.update(zdc)
 
-    # clear type cache
-    sys._clear_type_cache()
-
     # Clear ABC registries, restoring previously saved ABC registries.
+    # ignore deprecation warning for collections.abc.ByteString
     abs_classes = [getattr(collections.abc, a) for a in collections.abc.__all__]
     abs_classes = filter(isabstract, abs_classes)
     for abc in abs_classes:
         for obj in abc.__subclasses__() + [abc]:
-            for ref in abcs.get(obj, set()):
-                if ref() is not None:
-                    obj.register(ref())
+            refs = abcs.get(obj, None)
+            if refs is not None:
+                obj._abc_registry_clear()
+                for ref in refs:
+                    subclass = ref()
+                    if subclass is not None:
+                        obj.register(subclass)
             obj._abc_caches_clear()
 
+    # Clear caches
     clear_caches()
 
-
-def clear_caches():
-    # Clear the warnings registry, so they can be displayed again
-    for mod in sys.modules.values():
-        if hasattr(mod, '__warningregistry__'):
-            del mod.__warningregistry__
-
-    # Flush standard output, so that buffered data is sent to the OS and
-    # associated Python objects are reclaimed.
-    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
-        if stream is not None:
-            stream.flush()
-
-    # Clear assorted module caches.
-    # Don't worry about resetting the cache if the module is not loaded
-    try:
-        distutils_dir_util = sys.modules['distutils.dir_util']
-    except KeyError:
-        pass
-    else:
-        distutils_dir_util._path_created.clear()
-    re.purge()
-
-    try:
-        _strptime = sys.modules['_strptime']
-    except KeyError:
-        pass
-    else:
-        _strptime._regex_cache.clear()
-
-    try:
-        urllib_parse = sys.modules['urllib.parse']
-    except KeyError:
-        pass
-    else:
-        urllib_parse.clear_cache()
-
-    try:
-        urllib_request = sys.modules['urllib.request']
-    except KeyError:
-        pass
-    else:
-        urllib_request.urlcleanup()
-
-    try:
-        linecache = sys.modules['linecache']
-    except KeyError:
-        pass
-    else:
-        linecache.clearcache()
-
-    try:
-        mimetypes = sys.modules['mimetypes']
-    except KeyError:
-        pass
-    else:
-        mimetypes._default_mime_types()
-
-    try:
-        filecmp = sys.modules['filecmp']
-    except KeyError:
-        pass
-    else:
-        filecmp._cache.clear()
-
-    try:
-        struct = sys.modules['struct']
-    except KeyError:
-        pass
-    else:
-        # TODO: fix
-        # struct._clearcache()
-        pass
-
-    try:
-        doctest = sys.modules['doctest']
-    except KeyError:
-        pass
-    else:
-        doctest.master = None
-
-    try:
-        ctypes = sys.modules['ctypes']
-    except KeyError:
-        pass
-    else:
-        ctypes._reset_cache()
-
-    try:
-        typing = sys.modules['typing']
-    except KeyError:
-        pass
-    else:
-        for f in typing._cleanups:
-            f()
-
-    support.gc_collect()
+    # Clear other caches last (previous function calls can re-populate them):
+    sys._clear_internal_caches()
 
 
-def warm_caches():
+def warm_caches() -> None:
     # char cache
     s = bytes(range(256))
     for i in range(256):
diff --git a/Lib/test/libregrtest/result.py b/Lib/test/libregrtest/result.py
new file mode 100644
index 0000000000..7553efe5e8
--- /dev/null
+++ b/Lib/test/libregrtest/result.py
@@ -0,0 +1,225 @@
+import dataclasses
+import json
+from typing import Any
+
+from .utils import (
+    StrJSON, TestName, FilterTuple,
+    format_duration, normalize_test_name, print_warning)
+
+
+@dataclasses.dataclass(slots=True)
+class TestStats:
+    tests_run: int = 0
+    failures: int = 0
+    skipped: int = 0
+
+    @staticmethod
+    def from_unittest(result):
+        return TestStats(result.testsRun,
+                         len(result.failures),
+                         len(result.skipped))
+
+    @staticmethod
+    def from_doctest(results):
+        return TestStats(results.attempted,
+                         results.failed,
+                         results.skipped)
+
+    def accumulate(self, stats):
+        self.tests_run += stats.tests_run
+        self.failures += stats.failures
+        self.skipped += stats.skipped
+
+
+# Avoid enum.Enum to reduce the number of imports when tests are run
+class State:
+    PASSED = "PASSED"
+    FAILED = "FAILED"
+    SKIPPED = "SKIPPED"
+    UNCAUGHT_EXC = "UNCAUGHT_EXC"
+    REFLEAK = "REFLEAK"
+    ENV_CHANGED = "ENV_CHANGED"
+    RESOURCE_DENIED = "RESOURCE_DENIED"
+    INTERRUPTED = "INTERRUPTED"
+    WORKER_FAILED = "WORKER_FAILED"   # non-zero worker process exit code
+    WORKER_BUG = "WORKER_BUG"         # exception when running a worker
+    DID_NOT_RUN = "DID_NOT_RUN"
+    TIMEOUT = "TIMEOUT"
+
+    @staticmethod
+    def is_failed(state):
+        return state in {
+            State.FAILED,
+            State.UNCAUGHT_EXC,
+            State.REFLEAK,
+            State.WORKER_FAILED,
+            State.WORKER_BUG,
+            State.TIMEOUT}
+
+    @staticmethod
+    def has_meaningful_duration(state):
+        # Consider that the duration is meaningless for these cases.
+        # For example, if a whole test file is skipped, its duration
+        # is unlikely to be the duration of executing its tests,
+        # but just the duration to execute code which skips the test.
+        return state not in {
+            State.SKIPPED,
+            State.RESOURCE_DENIED,
+            State.INTERRUPTED,
+            State.WORKER_FAILED,
+            State.WORKER_BUG,
+            State.DID_NOT_RUN}
+
+    @staticmethod
+    def must_stop(state):
+        return state in {
+            State.INTERRUPTED,
+            State.WORKER_BUG,
+        }
+
+
+FileName = str
+LineNo = int
+Location = tuple[FileName, LineNo]
+
+
+@dataclasses.dataclass(slots=True)
+class TestResult:
+    test_name: TestName
+    state: str | None = None
+    # Test duration in seconds
+    duration: float | None = None
+    xml_data: list[str] | None = None
+    stats: TestStats | None = None
+
+    # errors and failures copied from support.TestFailedWithDetails
+    errors: list[tuple[str, str]] | None = None
+    failures: list[tuple[str, str]] | None = None
+
+    # partial coverage in a worker run; not used by sequential in-process runs
+    covered_lines: list[Location] | None = None
+
+    def is_failed(self, fail_env_changed: bool) -> bool:
+        if self.state == State.ENV_CHANGED:
+            return fail_env_changed
+        return State.is_failed(self.state)
+
+    def _format_failed(self):
+        if self.errors and self.failures:
+            le = len(self.errors)
+            lf = len(self.failures)
+            error_s = "error" + ("s" if le > 1 else "")
+            failure_s = "failure" + ("s" if lf > 1 else "")
+            return f"{self.test_name} failed ({le} {error_s}, {lf} {failure_s})"
+
+        if self.errors:
+            le = len(self.errors)
+            error_s = "error" + ("s" if le > 1 else "")
+            return f"{self.test_name} failed ({le} {error_s})"
+
+        if self.failures:
+            lf = len(self.failures)
+            failure_s = "failure" + ("s" if lf > 1 else "")
+            return f"{self.test_name} failed ({lf} {failure_s})"
+
+        return f"{self.test_name} failed"
+
+    def __str__(self) -> str:
+        match self.state:
+            case State.PASSED:
+                return f"{self.test_name} passed"
+            case State.FAILED:
+                return self._format_failed()
+            case State.SKIPPED:
+                return f"{self.test_name} skipped"
+            case State.UNCAUGHT_EXC:
+                return f"{self.test_name} failed (uncaught exception)"
+            case State.REFLEAK:
+                return f"{self.test_name} failed (reference leak)"
+            case State.ENV_CHANGED:
+                return f"{self.test_name} failed (env changed)"
+            case State.RESOURCE_DENIED:
+                return f"{self.test_name} skipped (resource denied)"
+            case State.INTERRUPTED:
+                return f"{self.test_name} interrupted"
+            case State.WORKER_FAILED:
+                return f"{self.test_name} worker non-zero exit code"
+            case State.WORKER_BUG:
+                return f"{self.test_name} worker bug"
+            case State.DID_NOT_RUN:
+                return f"{self.test_name} ran no tests"
+            case State.TIMEOUT:
+                assert self.duration is not None, "self.duration is None"
+                return f"{self.test_name} timed out ({format_duration(self.duration)})"
+            case _:
+                raise ValueError("unknown result state: {state!r}")
+
+    def has_meaningful_duration(self):
+        return State.has_meaningful_duration(self.state)
+
+    def set_env_changed(self):
+        if self.state is None or self.state == State.PASSED:
+            self.state = State.ENV_CHANGED
+
+    def must_stop(self, fail_fast: bool, fail_env_changed: bool) -> bool:
+        if State.must_stop(self.state):
+            return True
+        if fail_fast and self.is_failed(fail_env_changed):
+            return True
+        return False
+
+    def get_rerun_match_tests(self) -> FilterTuple | None:
+        match_tests = []
+
+        errors = self.errors or []
+        failures = self.failures or []
+        for error_list, is_error in (
+            (errors, True),
+            (failures, False),
+        ):
+            for full_name, *_ in error_list:
+                match_name = normalize_test_name(full_name, is_error=is_error)
+                if match_name is None:
+                    # 'setUpModule (test.test_sys)': don't filter tests
+                    return None
+                if not match_name:
+                    error_type = "ERROR" if is_error else "FAIL"
+                    print_warning(f"rerun failed to parse {error_type} test name: "
+                                  f"{full_name!r}: don't filter tests")
+                    return None
+                match_tests.append(match_name)
+
+        if not match_tests:
+            return None
+        return tuple(match_tests)
+
+    def write_json_into(self, file) -> None:
+        json.dump(self, file, cls=_EncodeTestResult)
+
+    @staticmethod
+    def from_json(worker_json: StrJSON) -> 'TestResult':
+        return json.loads(worker_json, object_hook=_decode_test_result)
+
+
+class _EncodeTestResult(json.JSONEncoder):
+    def default(self, o: Any) -> dict[str, Any]:
+        if isinstance(o, TestResult):
+            result = dataclasses.asdict(o)
+            result["__test_result__"] = o.__class__.__name__
+            return result
+        else:
+            return super().default(o)
+
+
+def _decode_test_result(data: dict[str, Any]) -> TestResult | dict[str, Any]:
+    if "__test_result__" in data:
+        data.pop('__test_result__')
+        if data['stats'] is not None:
+            data['stats'] = TestStats(**data['stats'])
+        if data['covered_lines'] is not None:
+            data['covered_lines'] = [
+                tuple(loc) for loc in data['covered_lines']
+            ]
+        return TestResult(**data)
+    else:
+        return data
diff --git a/Lib/test/libregrtest/results.py b/Lib/test/libregrtest/results.py
new file mode 100644
index 0000000000..9eda926966
--- /dev/null
+++ b/Lib/test/libregrtest/results.py
@@ -0,0 +1,276 @@
+import sys
+import trace
+from typing import TYPE_CHECKING
+
+from .runtests import RunTests
+from .result import State, TestResult, TestStats, Location
+from .utils import (
+    StrPath, TestName, TestTuple, TestList, FilterDict,
+    printlist, count, format_duration)
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+# Python uses exit code 1 when an exception is not caught
+# argparse.ArgumentParser.error() uses exit code 2
+EXITCODE_BAD_TEST = 2
+EXITCODE_ENV_CHANGED = 3
+EXITCODE_NO_TESTS_RAN = 4
+EXITCODE_RERUN_FAIL = 5
+EXITCODE_INTERRUPTED = 130   # 128 + signal.SIGINT=2
+
+
+class TestResults:
+    def __init__(self) -> None:
+        self.bad: TestList = []
+        self.good: TestList = []
+        self.rerun_bad: TestList = []
+        self.skipped: TestList = []
+        self.resource_denied: TestList = []
+        self.env_changed: TestList = []
+        self.run_no_tests: TestList = []
+        self.rerun: TestList = []
+        self.rerun_results: list[TestResult] = []
+
+        self.interrupted: bool = False
+        self.worker_bug: bool = False
+        self.test_times: list[tuple[float, TestName]] = []
+        self.stats = TestStats()
+        # used by --junit-xml
+        self.testsuite_xml: list['Element'] = []
+        # used by -T with -j
+        self.covered_lines: set[Location] = set()
+
+    def is_all_good(self) -> bool:
+        return (not self.bad
+                and not self.skipped
+                and not self.interrupted
+                and not self.worker_bug)
+
+    def get_executed(self) -> set[TestName]:
+        return (set(self.good) | set(self.bad) | set(self.skipped)
+                | set(self.resource_denied) | set(self.env_changed)
+                | set(self.run_no_tests))
+
+    def no_tests_run(self) -> bool:
+        return not any((self.good, self.bad, self.skipped, self.interrupted,
+                        self.env_changed))
+
+    def get_state(self, fail_env_changed: bool) -> str:
+        state = []
+        if self.bad:
+            state.append("FAILURE")
+        elif fail_env_changed and self.env_changed:
+            state.append("ENV CHANGED")
+        elif self.no_tests_run():
+            state.append("NO TESTS RAN")
+
+        if self.interrupted:
+            state.append("INTERRUPTED")
+        if self.worker_bug:
+            state.append("WORKER BUG")
+        if not state:
+            state.append("SUCCESS")
+
+        return ', '.join(state)
+
+    def get_exitcode(self, fail_env_changed: bool, fail_rerun: bool) -> int:
+        exitcode = 0
+        if self.bad:
+            exitcode = EXITCODE_BAD_TEST
+        elif self.interrupted:
+            exitcode = EXITCODE_INTERRUPTED
+        elif fail_env_changed and self.env_changed:
+            exitcode = EXITCODE_ENV_CHANGED
+        elif self.no_tests_run():
+            exitcode = EXITCODE_NO_TESTS_RAN
+        elif fail_rerun and self.rerun:
+            exitcode = EXITCODE_RERUN_FAIL
+        elif self.worker_bug:
+            exitcode = EXITCODE_BAD_TEST
+        return exitcode
+
+    def accumulate_result(self, result: TestResult, runtests: RunTests) -> None:
+        test_name = result.test_name
+        rerun = runtests.rerun
+        fail_env_changed = runtests.fail_env_changed
+
+        match result.state:
+            case State.PASSED:
+                self.good.append(test_name)
+            case State.ENV_CHANGED:
+                self.env_changed.append(test_name)
+                self.rerun_results.append(result)
+            case State.SKIPPED:
+                self.skipped.append(test_name)
+            case State.RESOURCE_DENIED:
+                self.resource_denied.append(test_name)
+            case State.INTERRUPTED:
+                self.interrupted = True
+            case State.DID_NOT_RUN:
+                self.run_no_tests.append(test_name)
+            case _:
+                if result.is_failed(fail_env_changed):
+                    self.bad.append(test_name)
+                    self.rerun_results.append(result)
+                else:
+                    raise ValueError(f"invalid test state: {result.state!r}")
+
+        if result.state == State.WORKER_BUG:
+            self.worker_bug = True
+
+        if result.has_meaningful_duration() and not rerun:
+            if result.duration is None:
+                raise ValueError("result.duration is None")
+            self.test_times.append((result.duration, test_name))
+        if result.stats is not None:
+            self.stats.accumulate(result.stats)
+        if rerun:
+            self.rerun.append(test_name)
+        if result.covered_lines:
+            # we don't care about trace counts so we don't have to sum them up
+            self.covered_lines.update(result.covered_lines)
+        xml_data = result.xml_data
+        if xml_data:
+            self.add_junit(xml_data)
+
+    def get_coverage_results(self) -> trace.CoverageResults:
+        counts = {loc: 1 for loc in self.covered_lines}
+        return trace.CoverageResults(counts=counts)
+
+    def need_rerun(self) -> bool:
+        return bool(self.rerun_results)
+
+    def prepare_rerun(self, *, clear: bool = True) -> tuple[TestTuple, FilterDict]:
+        tests: TestList = []
+        match_tests_dict = {}
+        for result in self.rerun_results:
+            tests.append(result.test_name)
+
+            match_tests = result.get_rerun_match_tests()
+            # ignore empty match list
+            if match_tests:
+                match_tests_dict[result.test_name] = match_tests
+
+        if clear:
+            # Clear previously failed tests
+            self.rerun_bad.extend(self.bad)
+            self.bad.clear()
+            self.env_changed.clear()
+            self.rerun_results.clear()
+
+        return (tuple(tests), match_tests_dict)
+
+    def add_junit(self, xml_data: list[str]) -> None:
+        import xml.etree.ElementTree as ET
+        for e in xml_data:
+            try:
+                self.testsuite_xml.append(ET.fromstring(e))
+            except ET.ParseError:
+                print(xml_data, file=sys.__stderr__)
+                raise
+
+    def write_junit(self, filename: StrPath) -> None:
+        if not self.testsuite_xml:
+            # Don't create empty XML file
+            return
+
+        import xml.etree.ElementTree as ET
+        root = ET.Element("testsuites")
+
+        # Manually count the totals for the overall summary
+        totals = {'tests': 0, 'errors': 0, 'failures': 0}
+        for suite in self.testsuite_xml:
+            root.append(suite)
+            for k in totals:
+                try:
+                    totals[k] += int(suite.get(k, 0))
+                except ValueError:
+                    pass
+
+        for k, v in totals.items():
+            root.set(k, str(v))
+
+        with open(filename, 'wb') as f:
+            for s in ET.tostringlist(root):
+                f.write(s)
+
+    def display_result(self, tests: TestTuple, quiet: bool, print_slowest: bool) -> None:
+        if print_slowest:
+            self.test_times.sort(reverse=True)
+            print()
+            print("10 slowest tests:")
+            for test_time, test in self.test_times[:10]:
+                print("- %s: %s" % (test, format_duration(test_time)))
+
+        all_tests = []
+        omitted = set(tests) - self.get_executed()
+
+        # less important
+        all_tests.append((sorted(omitted), "test", "{} omitted:"))
+        if not quiet:
+            all_tests.append((self.skipped, "test", "{} skipped:"))
+            all_tests.append((self.resource_denied, "test", "{} skipped (resource denied):"))
+        all_tests.append((self.run_no_tests, "test", "{} run no tests:"))
+
+        # more important
+        all_tests.append((self.env_changed, "test", "{} altered the execution environment (env changed):"))
+        all_tests.append((self.rerun, "re-run test", "{}:"))
+        all_tests.append((self.bad, "test", "{} failed:"))
+
+        for tests_list, count_text, title_format in all_tests:
+            if tests_list:
+                print()
+                count_text = count(len(tests_list), count_text)
+                print(title_format.format(count_text))
+                printlist(tests_list)
+
+        if self.good and not quiet:
+            print()
+            text = count(len(self.good), "test")
+            text = f"{text} OK."
+            if (self.is_all_good() and len(self.good) > 1):
+                text = f"All {text}"
+            print(text)
+
+        if self.interrupted:
+            print()
+            print("Test suite interrupted by signal SIGINT.")
+
+    def display_summary(self, first_runtests: RunTests, filtered: bool) -> None:
+        # Total tests
+        stats = self.stats
+        text = f'run={stats.tests_run:,}'
+        if filtered:
+            text = f"{text} (filtered)"
+        report = [text]
+        if stats.failures:
+            report.append(f'failures={stats.failures:,}')
+        if stats.skipped:
+            report.append(f'skipped={stats.skipped:,}')
+        print(f"Total tests: {' '.join(report)}")
+
+        # Total test files
+        all_tests = [self.good, self.bad, self.rerun,
+                     self.skipped,
+                     self.env_changed, self.run_no_tests]
+        run = sum(map(len, all_tests))
+        text = f'run={run}'
+        if not first_runtests.forever:
+            ntest = len(first_runtests.tests)
+            text = f"{text}/{ntest}"
+        if filtered:
+            text = f"{text} (filtered)"
+        report = [text]
+        for name, tests in (
+            ('failed', self.bad),
+            ('env_changed', self.env_changed),
+            ('skipped', self.skipped),
+            ('resource_denied', self.resource_denied),
+            ('rerun', self.rerun),
+            ('run_no_tests', self.run_no_tests),
+        ):
+            if tests:
+                report.append(f'{name}={len(tests)}')
+        print(f"Total test files: {' '.join(report)}")
diff --git a/Lib/test/libregrtest/run_workers.py b/Lib/test/libregrtest/run_workers.py
new file mode 100644
index 0000000000..3c6d13215f
--- /dev/null
+++ b/Lib/test/libregrtest/run_workers.py
@@ -0,0 +1,621 @@
+import contextlib
+import dataclasses
+import faulthandler
+import os.path
+import queue
+import signal
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+import traceback
+from typing import Any, Literal, TextIO
+
+from test import support
+from test.support import os_helper, MS_WINDOWS
+
+from .logger import Logger
+from .result import TestResult, State
+from .results import TestResults
+from .runtests import RunTests, WorkerRunTests, JsonFile, JsonFileType
+from .single import PROGRESS_MIN_TIME
+from .utils import (
+    StrPath, TestName,
+    format_duration, print_warning, count, plural, get_signal_name)
+from .worker import create_worker_process, USE_PROCESS_GROUP
+
+if MS_WINDOWS:
+    import locale
+    import msvcrt
+
+
+
+# Display the running tests if nothing happened last N seconds
+PROGRESS_UPDATE = 30.0   # seconds
+assert PROGRESS_UPDATE >= PROGRESS_MIN_TIME
+
+# Kill the main process after 5 minutes. It is supposed to write an update
+# every PROGRESS_UPDATE seconds. Tolerate 5 minutes for Python slowest
+# buildbot workers.
+MAIN_PROCESS_TIMEOUT = 5 * 60.0
+assert MAIN_PROCESS_TIMEOUT >= PROGRESS_UPDATE
+
+# Time to wait until a worker completes: should be immediate
+WAIT_COMPLETED_TIMEOUT = 30.0   # seconds
+
+# Time to wait a killed process (in seconds)
+WAIT_KILLED_TIMEOUT = 60.0
+
+
+# We do not use a generator so multiple threads can call next().
+class MultiprocessIterator:
+
+    """A thread-safe iterator over tests for multiprocess mode."""
+
+    def __init__(self, tests_iter):
+        self.lock = threading.Lock()
+        self.tests_iter = tests_iter
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        with self.lock:
+            if self.tests_iter is None:
+                raise StopIteration
+            return next(self.tests_iter)
+
+    def stop(self):
+        with self.lock:
+            self.tests_iter = None
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class MultiprocessResult:
+    result: TestResult
+    # bpo-45410: stderr is written into stdout to keep messages order
+    worker_stdout: str | None = None
+    err_msg: str | None = None
+
+
+class WorkerThreadExited:
+    """Indicates that a worker thread has exited"""
+
+ExcStr = str
+QueueOutput = tuple[Literal[False], MultiprocessResult] | tuple[Literal[True], ExcStr]
+QueueContent = QueueOutput | WorkerThreadExited
+
+
+class ExitThread(Exception):
+    pass
+
+
+class WorkerError(Exception):
+    def __init__(self,
+                 test_name: TestName,
+                 err_msg: str | None,
+                 stdout: str | None,
+                 state: str):
+        result = TestResult(test_name, state=state)
+        self.mp_result = MultiprocessResult(result, stdout, err_msg)
+        super().__init__()
+
+
+_NOT_RUNNING = "<not running>"
+
+
+class WorkerThread(threading.Thread):
+    def __init__(self, worker_id: int, runner: "RunWorkers") -> None:
+        super().__init__()
+        self.worker_id = worker_id
+        self.runtests = runner.runtests
+        self.pending = runner.pending
+        self.output = runner.output
+        self.timeout = runner.worker_timeout
+        self.log = runner.log
+        self.test_name = _NOT_RUNNING
+        self.start_time = time.monotonic()
+        self._popen: subprocess.Popen[str] | None = None
+        self._killed = False
+        self._stopped = False
+
+    def __repr__(self) -> str:
+        info = [f'WorkerThread #{self.worker_id}']
+        if self.is_alive():
+            info.append("running")
+        else:
+            info.append('stopped')
+        test = self.test_name
+        if test:
+            info.append(f'test={test}')
+        popen = self._popen
+        if popen is not None:
+            dt = time.monotonic() - self.start_time
+            info.extend((f'pid={popen.pid}',
+                         f'time={format_duration(dt)}'))
+        return '<%s>' % ' '.join(info)
+
+    def _kill(self) -> None:
+        popen = self._popen
+        if popen is None:
+            return
+
+        if self._killed:
+            return
+        self._killed = True
+
+        if USE_PROCESS_GROUP:
+            what = f"{self} process group"
+        else:
+            what = f"{self} process"
+
+        print(f"Kill {what}", file=sys.stderr, flush=True)
+        try:
+            if USE_PROCESS_GROUP:
+                os.killpg(popen.pid, signal.SIGKILL)
+            else:
+                popen.kill()
+        except ProcessLookupError:
+            # popen.kill(): the process completed, the WorkerThread thread
+            # read its exit status, but Popen.send_signal() read the returncode
+            # just before Popen.wait() set returncode.
+            pass
+        except OSError as exc:
+            print_warning(f"Failed to kill {what}: {exc!r}")
+
+    def stop(self) -> None:
+        # Method called from a different thread to stop this thread
+        self._stopped = True
+        self._kill()
+
+    def _run_process(self, runtests: WorkerRunTests, output_fd: int,
+                     tmp_dir: StrPath | None = None) -> int | None:
+        popen = create_worker_process(runtests, output_fd, tmp_dir)
+        self._popen = popen
+        self._killed = False
+
+        try:
+            if self._stopped:
+                # If kill() has been called before self._popen is set,
+                # self._popen is still running. Call again kill()
+                # to ensure that the process is killed.
+                self._kill()
+                raise ExitThread
+
+            try:
+                # gh-94026: stdout+stderr are written to tempfile
+                retcode = popen.wait(timeout=self.timeout)
+                assert retcode is not None
+                return retcode
+            except subprocess.TimeoutExpired:
+                if self._stopped:
+                    # kill() has been called: communicate() fails on reading
+                    # closed stdout
+                    raise ExitThread
+
+                # On timeout, kill the process
+                self._kill()
+
+                # None means TIMEOUT for the caller
+                retcode = None
+                # bpo-38207: Don't attempt to call communicate() again: on it
+                # can hang until all child processes using stdout
+                # pipes completes.
+            except OSError:
+                if self._stopped:
+                    # kill() has been called: communicate() fails
+                    # on reading closed stdout
+                    raise ExitThread
+                raise
+            return None
+        except:
+            self._kill()
+            raise
+        finally:
+            self._wait_completed()
+            self._popen = None
+
+    def create_stdout(self, stack: contextlib.ExitStack) -> TextIO:
+        """Create stdout temporary file (file descriptor)."""
+
+        if MS_WINDOWS:
+            # gh-95027: When stdout is not a TTY, Python uses the ANSI code
+            # page for the sys.stdout encoding. If the main process runs in a
+            # terminal, sys.stdout uses WindowsConsoleIO with UTF-8 encoding.
+            encoding = locale.getencoding()
+        else:
+            encoding = sys.stdout.encoding
+
+        # gh-94026: Write stdout+stderr to a tempfile as workaround for
+        # non-blocking pipes on Emscripten with NodeJS.
+        # gh-109425: Use "backslashreplace" error handler: log corrupted
+        # stdout+stderr, instead of failing with a UnicodeDecodeError and not
+        # logging stdout+stderr at all.
+        stdout_file = tempfile.TemporaryFile('w+',
+                                             encoding=encoding,
+                                             errors='backslashreplace')
+        stack.enter_context(stdout_file)
+        return stdout_file
+
+    def create_json_file(self, stack: contextlib.ExitStack) -> tuple[JsonFile, TextIO | None]:
+        """Create JSON file."""
+
+        json_file_use_stdout = self.runtests.json_file_use_stdout()
+        if json_file_use_stdout:
+            json_file = JsonFile(None, JsonFileType.STDOUT)
+            json_tmpfile = None
+        else:
+            json_tmpfile = tempfile.TemporaryFile('w+', encoding='utf8')
+            stack.enter_context(json_tmpfile)
+
+            json_fd = json_tmpfile.fileno()
+            if MS_WINDOWS:
+                # The msvcrt module is only available on Windows;
+                # we run mypy with `--platform=linux` in CI
+                json_handle: int = msvcrt.get_osfhandle(json_fd)  # type: ignore[attr-defined]
+                json_file = JsonFile(json_handle,
+                                     JsonFileType.WINDOWS_HANDLE)
+            else:
+                json_file = JsonFile(json_fd, JsonFileType.UNIX_FD)
+        return (json_file, json_tmpfile)
+
+    def create_worker_runtests(self, test_name: TestName, json_file: JsonFile) -> WorkerRunTests:
+        tests = (test_name,)
+        if self.runtests.rerun:
+            match_tests = self.runtests.get_match_tests(test_name)
+        else:
+            match_tests = None
+
+        kwargs: dict[str, Any] = {}
+        if match_tests:
+            kwargs['match_tests'] = [(test, True) for test in match_tests]
+        if self.runtests.output_on_failure:
+            kwargs['verbose'] = True
+            kwargs['output_on_failure'] = False
+        return self.runtests.create_worker_runtests(
+            tests=tests,
+            json_file=json_file,
+            **kwargs)
+
+    def run_tmp_files(self, worker_runtests: WorkerRunTests,
+                      stdout_fd: int) -> tuple[int | None, list[StrPath]]:
+        # gh-93353: Check for leaked temporary files in the parent process,
+        # since the deletion of temporary files can happen late during
+        # Python finalization: too late for libregrtest.
+        if not support.is_wasi:
+            # Don't check for leaked temporary files and directories if Python is
+            # run on WASI. WASI doesn't pass environment variables like TMPDIR to
+            # worker processes.
+            tmp_dir = tempfile.mkdtemp(prefix="test_python_")
+            tmp_dir = os.path.abspath(tmp_dir)
+            try:
+                retcode = self._run_process(worker_runtests,
+                                            stdout_fd, tmp_dir)
+            finally:
+                tmp_files = os.listdir(tmp_dir)
+                os_helper.rmtree(tmp_dir)
+        else:
+            retcode = self._run_process(worker_runtests, stdout_fd)
+            tmp_files = []
+
+        return (retcode, tmp_files)
+
+    def read_stdout(self, stdout_file: TextIO) -> str:
+        stdout_file.seek(0)
+        try:
+            return stdout_file.read().strip()
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            raise WorkerError(self.test_name,
+                              f"Cannot read process stdout: {exc}",
+                              stdout=None,
+                              state=State.WORKER_BUG)
+
+    def read_json(self, json_file: JsonFile, json_tmpfile: TextIO | None,
+                  stdout: str) -> tuple[TestResult, str]:
+        try:
+            if json_tmpfile is not None:
+                json_tmpfile.seek(0)
+                worker_json = json_tmpfile.read()
+            elif json_file.file_type == JsonFileType.STDOUT:
+                stdout, _, worker_json = stdout.rpartition("\n")
+                stdout = stdout.rstrip()
+            else:
+                with json_file.open(encoding='utf8') as json_fp:
+                    worker_json = json_fp.read()
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            err_msg = f"Failed to read worker process JSON: {exc}"
+            raise WorkerError(self.test_name, err_msg, stdout,
+                              state=State.WORKER_BUG)
+
+        if not worker_json:
+            raise WorkerError(self.test_name, "empty JSON", stdout,
+                              state=State.WORKER_BUG)
+
+        try:
+            result = TestResult.from_json(worker_json)
+        except Exception as exc:
+            # gh-101634: Catch UnicodeDecodeError if stdout cannot be
+            # decoded from encoding
+            err_msg = f"Failed to parse worker process JSON: {exc}"
+            raise WorkerError(self.test_name, err_msg, stdout,
+                              state=State.WORKER_BUG)
+
+        return (result, stdout)
+
+    def _runtest(self, test_name: TestName) -> MultiprocessResult:
+        with contextlib.ExitStack() as stack:
+            stdout_file = self.create_stdout(stack)
+            json_file, json_tmpfile = self.create_json_file(stack)
+            worker_runtests = self.create_worker_runtests(test_name, json_file)
+
+            retcode: str | int | None
+            retcode, tmp_files = self.run_tmp_files(worker_runtests,
+                                                    stdout_file.fileno())
+
+            stdout = self.read_stdout(stdout_file)
+
+            if retcode is None:
+                raise WorkerError(self.test_name, stdout=stdout,
+                                  err_msg=None,
+                                  state=State.TIMEOUT)
+            if retcode != 0:
+                name = get_signal_name(retcode)
+                if name:
+                    retcode = f"{retcode} ({name})"
+                raise WorkerError(self.test_name, f"Exit code {retcode}", stdout,
+                                  state=State.WORKER_FAILED)
+
+            result, stdout = self.read_json(json_file, json_tmpfile, stdout)
+
+        if tmp_files:
+            msg = (f'\n\n'
+                   f'Warning -- {test_name} leaked temporary files '
+                   f'({len(tmp_files)}): {", ".join(sorted(tmp_files))}')
+            stdout += msg
+            result.set_env_changed()
+
+        return MultiprocessResult(result, stdout)
+
+    def run(self) -> None:
+        fail_fast = self.runtests.fail_fast
+        fail_env_changed = self.runtests.fail_env_changed
+        try:
+            while not self._stopped:
+                try:
+                    test_name = next(self.pending)
+                except StopIteration:
+                    break
+
+                self.start_time = time.monotonic()
+                self.test_name = test_name
+                try:
+                    mp_result = self._runtest(test_name)
+                except WorkerError as exc:
+                    mp_result = exc.mp_result
+                finally:
+                    self.test_name = _NOT_RUNNING
+                mp_result.result.duration = time.monotonic() - self.start_time
+                self.output.put((False, mp_result))
+
+                if mp_result.result.must_stop(fail_fast, fail_env_changed):
+                    break
+        except ExitThread:
+            pass
+        except BaseException:
+            self.output.put((True, traceback.format_exc()))
+        finally:
+            self.output.put(WorkerThreadExited())
+
+    def _wait_completed(self) -> None:
+        popen = self._popen
+        # only needed for mypy:
+        if popen is None:
+            raise ValueError("Should never access `._popen` before calling `.run()`")
+
+        try:
+            popen.wait(WAIT_COMPLETED_TIMEOUT)
+        except (subprocess.TimeoutExpired, OSError) as exc:
+            print_warning(f"Failed to wait for {self} completion "
+                          f"(timeout={format_duration(WAIT_COMPLETED_TIMEOUT)}): "
+                          f"{exc!r}")
+
+    def wait_stopped(self, start_time: float) -> None:
+        # bpo-38207: RunWorkers.stop_workers() called self.stop()
+        # which killed the process. Sometimes, killing the process from the
+        # main thread does not interrupt popen.communicate() in
+        # WorkerThread thread. This loop with a timeout is a workaround
+        # for that.
+        #
+        # Moreover, if this method fails to join the thread, it is likely
+        # that Python will hang at exit while calling threading._shutdown()
+        # which tries again to join the blocked thread. Regrtest.main()
+        # uses EXIT_TIMEOUT to workaround this second bug.
+        while True:
+            # Write a message every second
+            self.join(1.0)
+            if not self.is_alive():
+                break
+            dt = time.monotonic() - start_time
+            self.log(f"Waiting for {self} thread for {format_duration(dt)}")
+            if dt > WAIT_KILLED_TIMEOUT:
+                print_warning(f"Failed to join {self} in {format_duration(dt)}")
+                break
+
+
+def get_running(workers: list[WorkerThread]) -> str | None:
+    running: list[str] = []
+    for worker in workers:
+        test_name = worker.test_name
+        if test_name == _NOT_RUNNING:
+            continue
+        dt = time.monotonic() - worker.start_time
+        if dt >= PROGRESS_MIN_TIME:
+            text = f'{test_name} ({format_duration(dt)})'
+            running.append(text)
+    if not running:
+        return None
+    return f"running ({len(running)}): {', '.join(running)}"
+
+
+class RunWorkers:
+    def __init__(self, num_workers: int, runtests: RunTests,
+                 logger: Logger, results: TestResults) -> None:
+        self.num_workers = num_workers
+        self.runtests = runtests
+        self.log = logger.log
+        self.display_progress = logger.display_progress
+        self.results: TestResults = results
+        self.live_worker_count = 0
+
+        self.output: queue.Queue[QueueContent] = queue.Queue()
+        tests_iter = runtests.iter_tests()
+        self.pending = MultiprocessIterator(tests_iter)
+        self.timeout = runtests.timeout
+        if self.timeout is not None:
+            # Rely on faulthandler to kill a worker process. This timouet is
+            # when faulthandler fails to kill a worker process. Give a maximum
+            # of 5 minutes to faulthandler to kill the worker.
+            self.worker_timeout: float | None = min(self.timeout * 1.5, self.timeout + 5 * 60)
+        else:
+            self.worker_timeout = None
+        self.workers: list[WorkerThread] = []
+
+        jobs = self.runtests.get_jobs()
+        if jobs is not None:
+            # Don't spawn more threads than the number of jobs:
+            # these worker threads would never get anything to do.
+            self.num_workers = min(self.num_workers, jobs)
+
+    def start_workers(self) -> None:
+        self.workers = [WorkerThread(index, self)
+                        for index in range(1, self.num_workers + 1)]
+        jobs = self.runtests.get_jobs()
+        if jobs is not None:
+            tests = count(jobs, 'test')
+        else:
+            tests = 'tests'
+        nworkers = len(self.workers)
+        processes = plural(nworkers, "process", "processes")
+        msg = (f"Run {tests} in parallel using "
+               f"{nworkers} worker {processes}")
+        if self.timeout and self.worker_timeout is not None:
+            msg += (" (timeout: %s, worker timeout: %s)"
+                    % (format_duration(self.timeout),
+                       format_duration(self.worker_timeout)))
+        self.log(msg)
+        for worker in self.workers:
+            worker.start()
+            self.live_worker_count += 1
+
+    def stop_workers(self) -> None:
+        start_time = time.monotonic()
+        for worker in self.workers:
+            worker.stop()
+        for worker in self.workers:
+            worker.wait_stopped(start_time)
+
+    def _get_result(self) -> QueueOutput | None:
+        pgo = self.runtests.pgo
+        use_faulthandler = (self.timeout is not None)
+
+        # bpo-46205: check the status of workers every iteration to avoid
+        # waiting forever on an empty queue.
+        while self.live_worker_count > 0:
+            if use_faulthandler:
+                faulthandler.dump_traceback_later(MAIN_PROCESS_TIMEOUT,
+                                                  exit=True)
+
+            # wait for a thread
+            try:
+                result = self.output.get(timeout=PROGRESS_UPDATE)
+                if isinstance(result, WorkerThreadExited):
+                    self.live_worker_count -= 1
+                    continue
+                return result
+            except queue.Empty:
+                pass
+
+            if not pgo:
+                # display progress
+                running = get_running(self.workers)
+                if running:
+                    self.log(running)
+        return None
+
+    def display_result(self, mp_result: MultiprocessResult) -> None:
+        result = mp_result.result
+        pgo = self.runtests.pgo
+
+        text = str(result)
+        if mp_result.err_msg:
+            # WORKER_BUG
+            text += ' (%s)' % mp_result.err_msg
+        elif (result.duration and result.duration >= PROGRESS_MIN_TIME and not pgo):
+            text += ' (%s)' % format_duration(result.duration)
+        if not pgo:
+            running = get_running(self.workers)
+            if running:
+                text += f' -- {running}'
+        self.display_progress(self.test_index, text)
+
+    def _process_result(self, item: QueueOutput) -> TestResult:
+        """Returns True if test runner must stop."""
+        if item[0]:
+            # Thread got an exception
+            format_exc = item[1]
+            print_warning(f"regrtest worker thread failed: {format_exc}")
+            result = TestResult("<regrtest worker>", state=State.WORKER_BUG)
+            self.results.accumulate_result(result, self.runtests)
+            return result
+
+        self.test_index += 1
+        mp_result = item[1]
+        result = mp_result.result
+        self.results.accumulate_result(result, self.runtests)
+        self.display_result(mp_result)
+
+        # Display worker stdout
+        if not self.runtests.output_on_failure:
+            show_stdout = True
+        else:
+            # --verbose3 ignores stdout on success
+            show_stdout = (result.state != State.PASSED)
+        if show_stdout:
+            stdout = mp_result.worker_stdout
+            if stdout:
+                print(stdout, flush=True)
+
+        return result
+
+    def run(self) -> None:
+        fail_fast = self.runtests.fail_fast
+        fail_env_changed = self.runtests.fail_env_changed
+
+        self.start_workers()
+
+        self.test_index = 0
+        try:
+            while True:
+                item = self._get_result()
+                if item is None:
+                    break
+
+                result = self._process_result(item)
+                if result.must_stop(fail_fast, fail_env_changed):
+                    break
+        except KeyboardInterrupt:
+            print()
+            self.results.interrupted = True
+        finally:
+            if self.timeout is not None:
+                faulthandler.cancel_dump_traceback_later()
+
+            # Always ensure that all worker processes are no longer
+            # worker when we exit this function
+            self.pending.stop()
+            self.stop_workers()
diff --git a/Lib/test/libregrtest/runtest.py b/Lib/test/libregrtest/runtest.py
deleted file mode 100644
index e2af18f349..0000000000
--- a/Lib/test/libregrtest/runtest.py
+++ /dev/null
@@ -1,328 +0,0 @@
-import collections
-import faulthandler
-import functools
-# import gc
-import importlib
-import io
-import os
-import sys
-import time
-import traceback
-import unittest
-
-from test import support
-from test.support import os_helper, import_helper
-from test.libregrtest.refleak import dash_R, clear_caches
-from test.libregrtest.save_env import saved_test_environment
-from test.libregrtest.utils import print_warning
-
-
-# Test result constants.
-PASSED = 1
-FAILED = 0
-ENV_CHANGED = -1
-SKIPPED = -2
-RESOURCE_DENIED = -3
-INTERRUPTED = -4
-CHILD_ERROR = -5   # error in a child process
-TEST_DID_NOT_RUN = -6   # error in a child process
-
-_FORMAT_TEST_RESULT = {
-    PASSED: '%s passed',
-    FAILED: '%s failed',
-    ENV_CHANGED: '%s failed (env changed)',
-    SKIPPED: '%s skipped',
-    RESOURCE_DENIED: '%s skipped (resource denied)',
-    INTERRUPTED: '%s interrupted',
-    CHILD_ERROR: '%s crashed',
-    TEST_DID_NOT_RUN: '%s run no tests',
-}
-
-# Minimum duration of a test to display its duration or to mention that
-# the test is running in background
-PROGRESS_MIN_TIME = 30.0   # seconds
-
-# small set of tests to determine if we have a basically functioning interpreter
-# (i.e. if any of these fail, then anything else is likely to follow)
-STDTESTS = [
-    # 'test_grammar',
-    # 'test_opcodes',
-    # 'test_dict',
-    # 'test_builtin',
-    # 'test_exceptions',
-    # 'test_types',
-    # 'test_unittest',
-    # 'test_doctest',
-    # 'test_doctest2',
-    # 'test_support'
-]
-
-# set of tests that we don't want to be executed when using regrtest
-NOTTESTS = set()
-
-
-# used by --findleaks, store for gc.garbage
-FOUND_GARBAGE = []
-
-
-def format_test_result(result):
-    fmt = _FORMAT_TEST_RESULT.get(result.result, "%s")
-    return fmt % result.test_name
-
-
-def findtestdir(path=None):
-    return path or os.path.dirname(os.path.dirname(__file__)) or os.curdir
-
-
-def findtests(testdir=None, stdtests=STDTESTS, nottests=NOTTESTS):
-    """Return a list of all applicable test modules."""
-    testdir = findtestdir(testdir)
-    names = os.listdir(testdir)
-    tests = []
-    others = set(stdtests) | nottests
-    for name in names:
-        mod, ext = os.path.splitext(name)
-        if mod[:5] == "test_" and ext in (".py", "") and mod not in others:
-            tests.append(mod)
-    return stdtests + sorted(tests)
-
-
-def get_abs_module(ns, test_name):
-    if test_name.startswith('test.') or ns.testdir:
-        return test_name
-    else:
-        # Import it from the test package
-        return 'test.' + test_name
-
-
-TestResult = collections.namedtuple('TestResult',
-    'test_name result test_time xml_data')
-
-def _runtest(ns, test_name):
-    # Handle faulthandler timeout, capture stdout+stderr, XML serialization
-    # and measure time.
-
-    output_on_failure = ns.verbose3
-
-    use_timeout = (ns.timeout is not None)
-    if use_timeout:
-        faulthandler.dump_traceback_later(ns.timeout, exit=True)
-
-    start_time = time.perf_counter()
-    try:
-        support.set_match_tests(ns.match_tests)
-        support.junit_xml_list = xml_list = [] if ns.xmlpath else None
-        if ns.failfast:
-            support.failfast = True
-
-        if output_on_failure:
-            support.verbose = True
-
-            stream = io.StringIO()
-            orig_stdout = sys.stdout
-            orig_stderr = sys.stderr
-            try:
-                sys.stdout = stream
-                sys.stderr = stream
-                result = _runtest_inner(ns, test_name,
-                                        display_failure=False)
-                if result != PASSED:
-                    output = stream.getvalue()
-                    orig_stderr.write(output)
-                    orig_stderr.flush()
-            finally:
-                sys.stdout = orig_stdout
-                sys.stderr = orig_stderr
-        else:
-            # Tell tests to be moderately quiet
-            support.verbose = ns.verbose
-
-            result = _runtest_inner(ns, test_name,
-                                    display_failure=not ns.verbose)
-
-        if xml_list:
-            import xml.etree.ElementTree as ET
-            xml_data = [ET.tostring(x).decode('us-ascii') for x in xml_list]
-        else:
-            xml_data = None
-
-        test_time = time.perf_counter() - start_time
-
-        return TestResult(test_name, result, test_time, xml_data)
-    finally:
-        if use_timeout:
-            faulthandler.cancel_dump_traceback_later()
-        support.junit_xml_list = None
-
-
-def runtest(ns, test_name):
-    """Run a single test.
-
-    ns -- regrtest namespace of options
-    test_name -- the name of the test
-
-    Returns the tuple (result, test_time, xml_data), where result is one
-    of the constants:
-
-        INTERRUPTED      KeyboardInterrupt
-        RESOURCE_DENIED  test skipped because resource denied
-        SKIPPED          test skipped for some other reason
-        ENV_CHANGED      test failed because it changed the execution environment
-        FAILED           test failed
-        PASSED           test passed
-        EMPTY_TEST_SUITE test ran no subtests.
-
-    If ns.xmlpath is not None, xml_data is a list containing each
-    generated testsuite element.
-    """
-    try:
-        return _runtest(ns, test_name)
-    except:
-        if not ns.pgo:
-            msg = traceback.format_exc()
-            print(f"test {test_name} crashed -- {msg}",
-                  file=sys.stderr, flush=True)
-        return TestResult(test_name, FAILED, 0.0, None)
-
-
-def _test_module(the_module):
-    loader = unittest.TestLoader()
-    tests = loader.loadTestsFromModule(the_module)
-    for error in loader.errors:
-        print(error, file=sys.stderr)
-    if loader.errors:
-        raise Exception("errors while loading tests")
-    support.run_unittest(tests)
-
-
-def _runtest_inner2(ns, test_name):
-    # Load the test function, run the test function, handle huntrleaks
-    # and findleaks to detect leaks
-
-    abstest = get_abs_module(ns, test_name)
-
-    # remove the module from sys.module to reload it if it was already imported
-    import_helper.unload(abstest)
-
-    the_module = importlib.import_module(abstest)
-
-    # If the test has a test_main, that will run the appropriate
-    # tests.  If not, use normal unittest test loading.
-    test_runner = getattr(the_module, "test_main", None)
-    if test_runner is None:
-        test_runner = functools.partial(_test_module, the_module)
-
-    try:
-        if ns.huntrleaks:
-            # Return True if the test leaked references
-            refleak = dash_R(ns, test_name, test_runner)
-        else:
-            test_runner()
-            refleak = False
-    finally:
-        cleanup_test_droppings(test_name, ns.verbose)
-
-    support.gc_collect()
-
-    # if gc.garbage:
-    #     support.environment_altered = True
-    #     print_warning(f"{test_name} created {len(gc.garbage)} "
-    #                   f"uncollectable object(s).")
-
-    #     # move the uncollectable objects somewhere,
-    #     # so we don't see them again
-    #     FOUND_GARBAGE.extend(gc.garbage)
-    #     gc.garbage.clear()
-
-    support.reap_children()
-
-    return refleak
-
-
-def _runtest_inner(ns, test_name, display_failure=True):
-    # Detect environment changes, handle exceptions.
-
-    # Reset the environment_altered flag to detect if a test altered
-    # the environment
-    support.environment_altered = False
-
-    if ns.pgo:
-        display_failure = False
-
-    try:
-        clear_caches()
-
-        # with saved_test_environment(test_name, ns.verbose, ns.quiet, pgo=ns.pgo) as environment:
-        refleak = _runtest_inner2(ns, test_name)
-    except support.ResourceDenied as msg:
-        if not ns.quiet and not ns.pgo:
-            print(f"{test_name} skipped -- {msg}", flush=True)
-        return RESOURCE_DENIED
-    except unittest.SkipTest as msg:
-        if not ns.quiet and not ns.pgo:
-            print(f"{test_name} skipped -- {msg}", flush=True)
-        return SKIPPED
-    except support.TestFailed as exc:
-        msg = f"test {test_name} failed"
-        if display_failure:
-            msg = f"{msg} -- {exc}"
-        print(msg, file=sys.stderr, flush=True)
-        return FAILED
-    except support.TestDidNotRun:
-        return TEST_DID_NOT_RUN
-    except KeyboardInterrupt:
-        print()
-        return INTERRUPTED
-    except:
-        if not ns.pgo:
-            msg = traceback.format_exc()
-            print(f"test {test_name} crashed -- {msg}",
-                  file=sys.stderr, flush=True)
-        return FAILED
-
-    if refleak:
-        return FAILED
-    # if environment.changed:
-    #     return ENV_CHANGED
-    return PASSED
-
-
-def cleanup_test_droppings(test_name, verbose):
-    # First kill any dangling references to open files etc.
-    # This can also issue some ResourceWarnings which would otherwise get
-    # triggered during the following test run, and possibly produce failures.
-    support.gc_collect()
-
-    # Try to clean up junk commonly left behind.  While tests shouldn't leave
-    # any files or directories behind, when a test fails that can be tedious
-    # for it to arrange.  The consequences can be especially nasty on Windows,
-    # since if a test leaves a file open, it cannot be deleted by name (while
-    # there's nothing we can do about that here either, we can display the
-    # name of the offending test, which is a real help).
-    for name in (os_helper.TESTFN,
-                 "db_home",
-                ):
-        if not os.path.exists(name):
-            continue
-
-        if os.path.isdir(name):
-            import shutil
-            kind, nuker = "directory", shutil.rmtree
-        elif os.path.isfile(name):
-            kind, nuker = "file", os.unlink
-        else:
-            raise RuntimeError(f"os.path says {name!r} exists but is neither "
-                               f"directory nor file")
-
-        if verbose:
-            print_warning("%r left behind %s %r" % (test_name, kind, name))
-            support.environment_altered = True
-
-        try:
-            import stat
-            # fix possible permissions problems that might prevent cleanup
-            os.chmod(name, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
-            nuker(name)
-        except Exception as exc:
-            print_warning(f"{test_name} left behind {kind} {name!r} "
-                          f"and it couldn't be removed: {exc}")
diff --git a/Lib/test/libregrtest/runtest_mp.py b/Lib/test/libregrtest/runtest_mp.py
deleted file mode 100644
index c2177d9995..0000000000
--- a/Lib/test/libregrtest/runtest_mp.py
+++ /dev/null
@@ -1,288 +0,0 @@
-import collections
-import faulthandler
-import json
-import os
-import queue
-import subprocess
-import sys
-import threading
-import time
-import traceback
-import types
-from test import support
-
-from test.libregrtest.runtest import (
-    runtest, INTERRUPTED, CHILD_ERROR, PROGRESS_MIN_TIME,
-    format_test_result, TestResult)
-from test.libregrtest.setup import setup_tests
-from test.libregrtest.utils import format_duration
-from test.support import os_helper
-
-
-# Display the running tests if nothing happened last N seconds
-PROGRESS_UPDATE = 30.0   # seconds
-
-
-def must_stop(result):
-    return result.result in (INTERRUPTED, CHILD_ERROR)
-
-
-def run_test_in_subprocess(testname, ns):
-    ns_dict = vars(ns)
-    worker_args = (ns_dict, testname)
-    worker_args = json.dumps(worker_args)
-
-    cmd = [sys.executable, *support.args_from_interpreter_flags(),
-           '-u',    # Unbuffered stdout and stderr
-           '-m', 'test.regrtest',
-           '--worker-args', worker_args]
-    if ns.pgo:
-        cmd += ['--pgo']
-
-    # Running the child from the same working directory as regrtest's original
-    # invocation ensures that TEMPDIR for the child is the same when
-    # sysconfig.is_python_build() is true. See issue 15300.
-    return subprocess.Popen(cmd,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                            universal_newlines=True,
-                            close_fds=(os.name != 'nt'),
-                            cwd=os_helper.SAVEDCWD)
-
-
-def run_tests_worker(worker_args):
-    ns_dict, testname = json.loads(worker_args)
-    ns = types.SimpleNamespace(**ns_dict)
-
-    setup_tests(ns)
-
-    result = runtest(ns, testname)
-    print()   # Force a newline (just in case)
-    print(json.dumps(result), flush=True)
-    sys.exit(0)
-
-
-# We do not use a generator so multiple threads can call next().
-class MultiprocessIterator:
-
-    """A thread-safe iterator over tests for multiprocess mode."""
-
-    def __init__(self, tests):
-        self.lock = threading.Lock()
-        self.tests = tests
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        with self.lock:
-            return next(self.tests)
-
-
-MultiprocessResult = collections.namedtuple('MultiprocessResult',
-    'result stdout stderr error_msg')
-
-class MultiprocessThread(threading.Thread):
-    def __init__(self, pending, output, ns):
-        super().__init__()
-        self.pending = pending
-        self.output = output
-        self.ns = ns
-        self.current_test_name = None
-        self.start_time = None
-        self._popen = None
-
-    def kill(self):
-        if not self.is_alive():
-            return
-        if self._popen is not None:
-            self._popen.kill()
-
-    def _runtest(self, test_name):
-        try:
-            self.start_time = time.monotonic()
-            self.current_test_name = test_name
-
-            popen = run_test_in_subprocess(test_name, self.ns)
-            self._popen = popen
-            with popen:
-                try:
-                    stdout, stderr = popen.communicate()
-                except:
-                    popen.kill()
-                    popen.wait()
-                    raise
-
-            retcode = popen.wait()
-        finally:
-            self.current_test_name = None
-            self._popen = None
-
-        stdout = stdout.strip()
-        stderr = stderr.rstrip()
-
-        err_msg = None
-        if retcode != 0:
-            err_msg = "Exit code %s" % retcode
-        else:
-            stdout, _, result = stdout.rpartition("\n")
-            stdout = stdout.rstrip()
-            if not result:
-                err_msg = "Failed to parse worker stdout"
-            else:
-                try:
-                    # deserialize run_tests_worker() output
-                    result = json.loads(result)
-                    result = TestResult(*result)
-                except Exception as exc:
-                    err_msg = "Failed to parse worker JSON: %s" % exc
-
-        if err_msg is not None:
-            test_time = time.monotonic() - self.start_time
-            result = TestResult(test_name, CHILD_ERROR, test_time, None)
-
-        return MultiprocessResult(result, stdout, stderr, err_msg)
-
-    def run(self):
-        while True:
-            try:
-                try:
-                    test_name = next(self.pending)
-                except StopIteration:
-                    break
-
-                mp_result = self._runtest(test_name)
-                self.output.put((False, mp_result))
-
-                if must_stop(mp_result.result):
-                    break
-            except BaseException:
-                self.output.put((True, traceback.format_exc()))
-                break
-
-
-def get_running(workers):
-    running = []
-    for worker in workers:
-        current_test_name = worker.current_test_name
-        if not current_test_name:
-            continue
-        dt = time.monotonic() - worker.start_time
-        if dt >= PROGRESS_MIN_TIME:
-            text = '%s (%s)' % (current_test_name, format_duration(dt))
-            running.append(text)
-    return running
-
-
-class MultiprocessRunner:
-    def __init__(self, regrtest):
-        self.regrtest = regrtest
-        self.ns = regrtest.ns
-        self.output = queue.Queue()
-        self.pending = MultiprocessIterator(self.regrtest.tests)
-        if self.ns.timeout is not None:
-            self.test_timeout = self.ns.timeout * 1.5
-        else:
-            self.test_timeout = None
-        self.workers = None
-
-    def start_workers(self):
-        self.workers = [MultiprocessThread(self.pending, self.output, self.ns)
-                        for _ in range(self.ns.use_mp)]
-        print("Run tests in parallel using %s child processes"
-              % len(self.workers))
-        for worker in self.workers:
-            worker.start()
-
-    def wait_workers(self):
-        for worker in self.workers:
-            worker.kill()
-        for worker in self.workers:
-            worker.join()
-
-    def _get_result(self):
-        if not any(worker.is_alive() for worker in self.workers):
-            # all worker threads are done: consume pending results
-            try:
-                return self.output.get(timeout=0)
-            except queue.Empty:
-                return None
-
-        while True:
-            if self.test_timeout is not None:
-                faulthandler.dump_traceback_later(self.test_timeout, exit=True)
-
-            # wait for a thread
-            timeout = max(PROGRESS_UPDATE, PROGRESS_MIN_TIME)
-            try:
-                return self.output.get(timeout=timeout)
-            except queue.Empty:
-                pass
-
-            # display progress
-            running = get_running(self.workers)
-            if running and not self.ns.pgo:
-                print('running: %s' % ', '.join(running), flush=True)
-
-    def display_result(self, mp_result):
-        result = mp_result.result
-
-        text = format_test_result(result)
-        if mp_result.error_msg is not None:
-            # CHILD_ERROR
-            text += ' (%s)' % mp_result.error_msg
-        elif (result.test_time >= PROGRESS_MIN_TIME and not self.ns.pgo):
-            text += ' (%s)' % format_duration(result.test_time)
-        running = get_running(self.workers)
-        if running and not self.ns.pgo:
-            text += ' -- running: %s' % ', '.join(running)
-        self.regrtest.display_progress(self.test_index, text)
-
-    def _process_result(self, item):
-        if item[0]:
-            # Thread got an exception
-            format_exc = item[1]
-            print(f"regrtest worker thread failed: {format_exc}",
-                  file=sys.stderr, flush=True)
-            return True
-
-        self.test_index += 1
-        mp_result = item[1]
-        self.regrtest.accumulate_result(mp_result.result)
-        self.display_result(mp_result)
-
-        if mp_result.stdout:
-            print(mp_result.stdout, flush=True)
-        if mp_result.stderr and not self.ns.pgo:
-            print(mp_result.stderr, file=sys.stderr, flush=True)
-
-        if must_stop(mp_result.result):
-            return True
-
-        return False
-
-    def run_tests(self):
-        self.start_workers()
-
-        self.test_index = 0
-        try:
-            while True:
-                item = self._get_result()
-                if item is None:
-                    break
-
-                stop = self._process_result(item)
-                if stop:
-                    break
-        except KeyboardInterrupt:
-            print()
-            self.regrtest.interrupted = True
-        finally:
-            if self.test_timeout is not None:
-                faulthandler.cancel_dump_traceback_later()
-
-        self.wait_workers()
-
-
-def run_tests_multiprocess(regrtest):
-    MultiprocessRunner(regrtest).run_tests()
diff --git a/Lib/test/libregrtest/runtests.py b/Lib/test/libregrtest/runtests.py
new file mode 100644
index 0000000000..7b607d4a55
--- /dev/null
+++ b/Lib/test/libregrtest/runtests.py
@@ -0,0 +1,222 @@
+import contextlib
+import dataclasses
+import json
+import os
+import shlex
+import subprocess
+import sys
+from typing import Any, Iterator
+
+from test import support
+
+from .utils import (
+    StrPath, StrJSON, TestTuple, TestName, TestFilter, FilterTuple, FilterDict)
+
+
+class JsonFileType:
+    UNIX_FD = "UNIX_FD"
+    WINDOWS_HANDLE = "WINDOWS_HANDLE"
+    STDOUT = "STDOUT"
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class JsonFile:
+    # file type depends on file_type:
+    # - UNIX_FD: file descriptor (int)
+    # - WINDOWS_HANDLE: handle (int)
+    # - STDOUT: use process stdout (None)
+    file: int | None
+    file_type: str
+
+    def configure_subprocess(self, popen_kwargs: dict[str, Any]) -> None:
+        match self.file_type:
+            case JsonFileType.UNIX_FD:
+                # Unix file descriptor
+                popen_kwargs['pass_fds'] = [self.file]
+            case JsonFileType.WINDOWS_HANDLE:
+                # Windows handle
+                # We run mypy with `--platform=linux` so it complains about this:
+                startupinfo = subprocess.STARTUPINFO()  # type: ignore[attr-defined]
+                startupinfo.lpAttributeList = {"handle_list": [self.file]}
+                popen_kwargs['startupinfo'] = startupinfo
+
+    @contextlib.contextmanager
+    def inherit_subprocess(self) -> Iterator[None]:
+        if sys.platform == 'win32' and self.file_type == JsonFileType.WINDOWS_HANDLE:
+            os.set_handle_inheritable(self.file, True)
+            try:
+                yield
+            finally:
+                os.set_handle_inheritable(self.file, False)
+        else:
+            yield
+
+    def open(self, mode='r', *, encoding):
+        if self.file_type == JsonFileType.STDOUT:
+            raise ValueError("for STDOUT file type, just use sys.stdout")
+
+        file = self.file
+        if self.file_type == JsonFileType.WINDOWS_HANDLE:
+            import msvcrt
+            # Create a file descriptor from the handle
+            file = msvcrt.open_osfhandle(file, os.O_WRONLY)
+        return open(file, mode, encoding=encoding)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class HuntRefleak:
+    warmups: int
+    runs: int
+    filename: StrPath
+
+    def bisect_cmd_args(self) -> list[str]:
+        # Ignore filename since it can contain colon (":"),
+        # and usually it's not used. Use the default filename.
+        return ["-R", f"{self.warmups}:{self.runs}:"]
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class RunTests:
+    tests: TestTuple
+    fail_fast: bool
+    fail_env_changed: bool
+    match_tests: TestFilter
+    match_tests_dict: FilterDict | None
+    rerun: bool
+    forever: bool
+    pgo: bool
+    pgo_extended: bool
+    output_on_failure: bool
+    timeout: float | None
+    verbose: int
+    quiet: bool
+    hunt_refleak: HuntRefleak | None
+    test_dir: StrPath | None
+    use_junit: bool
+    coverage: bool
+    memory_limit: str | None
+    gc_threshold: int | None
+    use_resources: tuple[str, ...]
+    python_cmd: tuple[str, ...] | None
+    randomize: bool
+    random_seed: int | str
+
+    def copy(self, **override) -> 'RunTests':
+        state = dataclasses.asdict(self)
+        state.update(override)
+        return RunTests(**state)
+
+    def create_worker_runtests(self, **override) -> 'WorkerRunTests':
+        state = dataclasses.asdict(self)
+        state.update(override)
+        return WorkerRunTests(**state)
+
+    def get_match_tests(self, test_name: TestName) -> FilterTuple | None:
+        if self.match_tests_dict is not None:
+            return self.match_tests_dict.get(test_name, None)
+        else:
+            return None
+
+    def get_jobs(self) -> int | None:
+        # Number of run_single_test() calls needed to run all tests.
+        # None means that there is not bound limit (--forever option).
+        if self.forever:
+            return None
+        return len(self.tests)
+
+    def iter_tests(self) -> Iterator[TestName]:
+        if self.forever:
+            while True:
+                yield from self.tests
+        else:
+            yield from self.tests
+
+    def json_file_use_stdout(self) -> bool:
+        # Use STDOUT in two cases:
+        #
+        # - If --python command line option is used;
+        # - On Emscripten and WASI.
+        #
+        # On other platforms, UNIX_FD or WINDOWS_HANDLE can be used.
+        return (
+            bool(self.python_cmd)
+            or support.is_emscripten
+            or support.is_wasi
+        )
+
+    def create_python_cmd(self) -> list[str]:
+        python_opts = support.args_from_interpreter_flags()
+        if self.python_cmd is not None:
+            executable = self.python_cmd
+            # Remove -E option, since --python=COMMAND can set PYTHON
+            # environment variables, such as PYTHONPATH, in the worker
+            # process.
+            python_opts = [opt for opt in python_opts if opt != "-E"]
+        else:
+            executable = (sys.executable,)
+        cmd = [*executable, *python_opts]
+        if '-u' not in python_opts:
+            cmd.append('-u')  # Unbuffered stdout and stderr
+        if self.coverage:
+            cmd.append("-Xpresite=test.cov")
+        return cmd
+
+    def bisect_cmd_args(self) -> list[str]:
+        args = []
+        if self.fail_fast:
+            args.append("--failfast")
+        if self.fail_env_changed:
+            args.append("--fail-env-changed")
+        if self.timeout:
+            args.append(f"--timeout={self.timeout}")
+        if self.hunt_refleak is not None:
+            args.extend(self.hunt_refleak.bisect_cmd_args())
+        if self.test_dir:
+            args.extend(("--testdir", self.test_dir))
+        if self.memory_limit:
+            args.extend(("--memlimit", self.memory_limit))
+        if self.gc_threshold:
+            args.append(f"--threshold={self.gc_threshold}")
+        if self.use_resources:
+            args.extend(("-u", ','.join(self.use_resources)))
+        if self.python_cmd:
+            cmd = shlex.join(self.python_cmd)
+            args.extend(("--python", cmd))
+        if self.randomize:
+            args.append(f"--randomize")
+        args.append(f"--randseed={self.random_seed}")
+        return args
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class WorkerRunTests(RunTests):
+    json_file: JsonFile
+
+    def as_json(self) -> StrJSON:
+        return json.dumps(self, cls=_EncodeRunTests)
+
+    @staticmethod
+    def from_json(worker_json: StrJSON) -> 'WorkerRunTests':
+        return json.loads(worker_json, object_hook=_decode_runtests)
+
+
+class _EncodeRunTests(json.JSONEncoder):
+    def default(self, o: Any) -> dict[str, Any]:
+        if isinstance(o, WorkerRunTests):
+            result = dataclasses.asdict(o)
+            result["__runtests__"] = True
+            return result
+        else:
+            return super().default(o)
+
+
+def _decode_runtests(data: dict[str, Any]) -> RunTests | dict[str, Any]:
+    if "__runtests__" in data:
+        data.pop('__runtests__')
+        if data['hunt_refleak']:
+            data['hunt_refleak'] = HuntRefleak(**data['hunt_refleak'])
+        if data['json_file']:
+            data['json_file'] = JsonFile(**data['json_file'])
+        return WorkerRunTests(**data)
+    else:
+        return data
diff --git a/Lib/test/libregrtest/save_env.py b/Lib/test/libregrtest/save_env.py
index b9a1c0b392..f9bd6d87c4 100644
--- a/Lib/test/libregrtest/save_env.py
+++ b/Lib/test/libregrtest/save_env.py
@@ -1,20 +1,24 @@
-import asyncio
 import builtins
 import locale
-import logging
 import os
-import shutil
 import sys
-import sysconfig
 import threading
-import warnings
+
 from test import support
 from test.support import os_helper
-from test.libregrtest.utils import print_warning
+
+from .utils import print_warning
+
+# Import termios to save and restore terminal echo.  This is only available on
+# Unix, and it's fine if the module can't be found.
 try:
-    import _multiprocessing, multiprocessing.process
-except ImportError:
-    multiprocessing = None
+    import termios                                # noqa: F401
+except ModuleNotFoundError:
+    pass
+
+
+class SkipTestEnvironment(Exception):
+    pass
 
 
 # Unit tests are supposed to leave the execution environment unchanged
@@ -28,21 +32,19 @@
 class saved_test_environment:
     """Save bits of the test environment and restore them at block exit.
 
-        with saved_test_environment(testname, verbose, quiet):
+        with saved_test_environment(test_name, verbose, quiet):
             #stuff
 
     Unless quiet is True, a warning is printed to stderr if any of
-    the saved items was changed by the test.  The attribute 'changed'
-    is initially False, but is set to True if a change is detected.
+    the saved items was changed by the test. The support.environment_altered
+    attribute is set to True if a change is detected.
 
     If verbose is more than 1, the before and after state of changed
     items is also printed.
     """
 
-    changed = False
-
-    def __init__(self, testname, verbose=0, quiet=False, *, pgo=False):
-        self.testname = testname
+    def __init__(self, test_name, verbose, quiet, *, pgo):
+        self.test_name = test_name
         self.verbose = verbose
         self.quiet = quiet
         self.pgo = pgo
@@ -69,11 +71,40 @@ def __init__(self, testname, verbose=0, quiet=False, *, pgo=False):
                  'files', 'locale', 'warnings.showwarning',
                  'shutil_archive_formats', 'shutil_unpack_formats',
                  'asyncio.events._event_loop_policy',
+                 'urllib.requests._url_tempfiles', 'urllib.requests._opener',
+                 'stty_echo',
                 )
 
+    def get_module(self, name):
+        # function for restore() methods
+        return sys.modules[name]
+
+    def try_get_module(self, name):
+        # function for get() methods
+        try:
+            return self.get_module(name)
+        except KeyError:
+            raise SkipTestEnvironment
+
+    def get_urllib_requests__url_tempfiles(self):
+        urllib_request = self.try_get_module('urllib.request')
+        return list(urllib_request._url_tempfiles)
+    def restore_urllib_requests__url_tempfiles(self, tempfiles):
+        for filename in tempfiles:
+            os_helper.unlink(filename)
+
+    def get_urllib_requests__opener(self):
+        urllib_request = self.try_get_module('urllib.request')
+        return urllib_request._opener
+    def restore_urllib_requests__opener(self, opener):
+        urllib_request = self.get_module('urllib.request')
+        urllib_request._opener = opener
+
     def get_asyncio_events__event_loop_policy(self):
+        self.try_get_module('asyncio')
         return support.maybe_get_event_loop_policy()
     def restore_asyncio_events__event_loop_policy(self, policy):
+        asyncio = self.get_module('asyncio')
         asyncio.set_event_loop_policy(policy)
 
     def get_sys_argv(self):
@@ -132,39 +163,46 @@ def restore___import__(self, import_):
         builtins.__import__ = import_
 
     def get_warnings_filters(self):
+        warnings = self.try_get_module('warnings')
         return id(warnings.filters), warnings.filters, warnings.filters[:]
     def restore_warnings_filters(self, saved_filters):
+        warnings = self.get_module('warnings')
         warnings.filters = saved_filters[1]
         warnings.filters[:] = saved_filters[2]
 
     def get_asyncore_socket_map(self):
-        asyncore = sys.modules.get('asyncore')
+        asyncore = sys.modules.get('test.support.asyncore')
         # XXX Making a copy keeps objects alive until __exit__ gets called.
         return asyncore and asyncore.socket_map.copy() or {}
     def restore_asyncore_socket_map(self, saved_map):
-        asyncore = sys.modules.get('asyncore')
+        asyncore = sys.modules.get('test.support.asyncore')
         if asyncore is not None:
             asyncore.close_all(ignore_all=True)
             asyncore.socket_map.update(saved_map)
 
     def get_shutil_archive_formats(self):
+        shutil = self.try_get_module('shutil')
         # we could call get_archives_formats() but that only returns the
         # registry keys; we want to check the values too (the functions that
         # are registered)
         return shutil._ARCHIVE_FORMATS, shutil._ARCHIVE_FORMATS.copy()
     def restore_shutil_archive_formats(self, saved):
+        shutil = self.get_module('shutil')
         shutil._ARCHIVE_FORMATS = saved[0]
         shutil._ARCHIVE_FORMATS.clear()
         shutil._ARCHIVE_FORMATS.update(saved[1])
 
     def get_shutil_unpack_formats(self):
+        shutil = self.try_get_module('shutil')
         return shutil._UNPACK_FORMATS, shutil._UNPACK_FORMATS.copy()
     def restore_shutil_unpack_formats(self, saved):
+        shutil = self.get_module('shutil')
         shutil._UNPACK_FORMATS = saved[0]
         shutil._UNPACK_FORMATS.clear()
         shutil._UNPACK_FORMATS.update(saved[1])
 
     def get_logging__handlers(self):
+        logging = self.try_get_module('logging')
         # _handlers is a WeakValueDictionary
         return id(logging._handlers), logging._handlers, logging._handlers.copy()
     def restore_logging__handlers(self, saved_handlers):
@@ -172,6 +210,7 @@ def restore_logging__handlers(self, saved_handlers):
         pass
 
     def get_logging__handlerList(self):
+        logging = self.try_get_module('logging')
         # _handlerList is a list of weakrefs to handlers
         return id(logging._handlerList), logging._handlerList, logging._handlerList[:]
     def restore_logging__handlerList(self, saved_handlerList):
@@ -188,46 +227,52 @@ def restore_sys_warnoptions(self, saved_options):
     # to track reference leaks.
     def get_threading__dangling(self):
         # This copies the weakrefs without making any strong reference
-        return threading._dangling.copy()
+        # XXX: RUSTPYTHON - filter out dead threads since gc doesn't clean WeakSet. Revert this line when we have a GC
+        # return threading._dangling.copy()
+        return {t for t in threading._dangling if t.is_alive()}
     def restore_threading__dangling(self, saved):
         threading._dangling.clear()
         threading._dangling.update(saved)
 
     # Same for Process objects
     def get_multiprocessing_process__dangling(self):
-        if not multiprocessing:
-            return None
+        multiprocessing_process = self.try_get_module('multiprocessing.process')
         # Unjoined process objects can survive after process exits
-        multiprocessing.process._cleanup()
+        multiprocessing_process._cleanup()
         # This copies the weakrefs without making any strong reference
-        return multiprocessing.process._dangling.copy()
+        return multiprocessing_process._dangling.copy()
     def restore_multiprocessing_process__dangling(self, saved):
-        if not multiprocessing:
-            return
-        multiprocessing.process._dangling.clear()
-        multiprocessing.process._dangling.update(saved)
+        multiprocessing_process = self.get_module('multiprocessing.process')
+        multiprocessing_process._dangling.clear()
+        multiprocessing_process._dangling.update(saved)
 
     def get_sysconfig__CONFIG_VARS(self):
         # make sure the dict is initialized
+        sysconfig = self.try_get_module('sysconfig')
         sysconfig.get_config_var('prefix')
         return (id(sysconfig._CONFIG_VARS), sysconfig._CONFIG_VARS,
                 dict(sysconfig._CONFIG_VARS))
     def restore_sysconfig__CONFIG_VARS(self, saved):
+        sysconfig = self.get_module('sysconfig')
         sysconfig._CONFIG_VARS = saved[1]
         sysconfig._CONFIG_VARS.clear()
         sysconfig._CONFIG_VARS.update(saved[2])
 
     def get_sysconfig__INSTALL_SCHEMES(self):
+        sysconfig = self.try_get_module('sysconfig')
         return (id(sysconfig._INSTALL_SCHEMES), sysconfig._INSTALL_SCHEMES,
                 sysconfig._INSTALL_SCHEMES.copy())
     def restore_sysconfig__INSTALL_SCHEMES(self, saved):
+        sysconfig = self.get_module('sysconfig')
         sysconfig._INSTALL_SCHEMES = saved[1]
         sysconfig._INSTALL_SCHEMES.clear()
         sysconfig._INSTALL_SCHEMES.update(saved[2])
 
     def get_files(self):
+        # XXX: Maybe add an allow-list here?
         return sorted(fn + ('/' if os.path.isdir(fn) else '')
-                      for fn in os.listdir())
+                      for fn in os.listdir()
+                      if not fn.startswith(".hypothesis"))
     def restore_files(self, saved_value):
         fn = os_helper.TESTFN
         if fn not in saved_value and (fn + '/') not in saved_value:
@@ -251,10 +296,30 @@ def restore_locale(self, saved):
             locale.setlocale(lc, setting)
 
     def get_warnings_showwarning(self):
+        warnings = self.try_get_module('warnings')
         return warnings.showwarning
     def restore_warnings_showwarning(self, fxn):
+        warnings = self.get_module('warnings')
         warnings.showwarning = fxn
 
+    def get_stty_echo(self):
+        termios = self.try_get_module('termios')
+        if not os.isatty(fd := sys.__stdin__.fileno()):
+            return None
+        attrs = termios.tcgetattr(fd)
+        lflags = attrs[3]
+        return bool(lflags & termios.ECHO)
+    def restore_stty_echo(self, echo):
+        termios = self.get_module('termios')
+        attrs = termios.tcgetattr(fd := sys.__stdin__.fileno())
+        if echo:
+            # Turn echo on.
+            attrs[3] |= termios.ECHO
+        else:
+            # Turn echo off.
+            attrs[3] &= ~termios.ECHO
+        termios.tcsetattr(fd, termios.TCSADRAIN, attrs)
+
     def resource_info(self):
         for name in self.resources:
             method_suffix = name.replace('.', '_')
@@ -263,29 +328,32 @@ def resource_info(self):
             yield name, getattr(self, get_name), getattr(self, restore_name)
 
     def __enter__(self):
-        self.saved_values = dict((name, get()) for name, get, restore
-                                                   in self.resource_info())
+        self.saved_values = []
+        for name, get, restore in self.resource_info():
+            try:
+                original = get()
+            except SkipTestEnvironment:
+                continue
+
+            self.saved_values.append((name, get, restore, original))
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         saved_values = self.saved_values
-        del self.saved_values
+        self.saved_values = None
 
         # Some resources use weak references
         support.gc_collect()
 
-        # Read support.environment_altered, set by support helper functions
-        self.changed |= support.environment_altered
-
-        for name, get, restore in self.resource_info():
+        for name, get, restore, original in saved_values:
             current = get()
-            original = saved_values.pop(name)
             # Check for changes to the resource's value
             if current != original:
-                self.changed = True
+                support.environment_altered = True
                 restore(original)
                 if not self.quiet and not self.pgo:
-                    print_warning(f"{name} was modified by {self.testname}")
-                    print(f"  Before: {original}\n  After:  {current} ",
-                          file=sys.stderr, flush=True)
+                    print_warning(
+                        f"{name} was modified by {self.test_name}\n"
+                        f"  Before: {original}\n"
+                        f"  After:  {current} ")
         return False
diff --git a/Lib/test/libregrtest/setup.py b/Lib/test/libregrtest/setup.py
index b1a5ded525..704a4ccc68 100644
--- a/Lib/test/libregrtest/setup.py
+++ b/Lib/test/libregrtest/setup.py
@@ -1,17 +1,36 @@
-import atexit
 import faulthandler
+import gc
+import io
 import os
+import random
 import signal
 import sys
 import unittest
 from test import support
-try:
-    import gc
-except ImportError:
-    gc = None
+from test.support.os_helper import TESTFN_UNDECODABLE, FS_NONASCII
+from _colorize import can_colorize  # type: ignore[import-not-found]
 
+from .filter import set_match_tests
+from .runtests import RunTests
+from .utils import (
+    setup_unraisable_hook, setup_threading_excepthook, fix_umask,
+    adjust_rlimit_nofile)
 
-def setup_tests(ns):
+
+UNICODE_GUARD_ENV = "PYTHONREGRTEST_UNICODE_GUARD"
+
+
+def setup_test_dir(testdir: str | None) -> None:
+    if testdir:
+        # Prepend test directory to sys.path, so runtest() will be able
+        # to locate tests
+        sys.path.insert(0, os.path.abspath(testdir))
+
+
+def setup_process() -> None:
+    fix_umask()
+
+    assert sys.__stderr__ is not None, "sys.__stderr__ is None"
     try:
         stderr_fd = sys.__stderr__.fileno()
     except (ValueError, AttributeError):
@@ -19,13 +38,13 @@ def setup_tests(ns):
         # and ValueError on a closed stream.
         #
         # Catch AttributeError for stderr being None.
-        stderr_fd = None
+        pass
     else:
         # Display the Python traceback on fatal errors (e.g. segfault)
         faulthandler.enable(all_threads=True, file=stderr_fd)
 
         # Display the Python traceback on SIGALRM or SIGUSR1 signal
-        signals = []
+        signals: list[signal.Signals] = []
         if hasattr(signal, 'SIGALRM'):
             signals.append(signal.SIGALRM)
         if hasattr(signal, 'SIGUSR1'):
@@ -33,13 +52,17 @@ def setup_tests(ns):
         for signum in signals:
             faulthandler.register(signum, chain=True, file=stderr_fd)
 
-    # replace_stdout()
-    # support.record_original_stdout(sys.stdout)
+    adjust_rlimit_nofile()
 
-    if ns.testdir:
-        # Prepend test directory to sys.path, so runtest() will be able
-        # to locate tests
-        sys.path.insert(0, os.path.abspath(ns.testdir))
+    support.record_original_stdout(sys.stdout)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+
+    # Set sys.stdout encoder error handler to backslashreplace,
+    # similar to sys.stderr error handler, to avoid UnicodeEncodeError
+    # when printing a traceback or any other non-encodable character.
+    #
+    # Use an assertion to fix mypy error.
+    assert isinstance(sys.stdout, io.TextIOWrapper)
+    sys.stdout.reconfigure(errors="backslashreplace")
 
     # Some times __path__ and __file__ are not absolute (e.g. while running from
     # Lib/) and, if we change the CWD to run the tests in a temporary dir, some
@@ -56,79 +79,73 @@ def setup_tests(ns):
             for index, path in enumerate(module.__path__):
                 module.__path__[index] = os.path.abspath(path)
         if getattr(module, '__file__', None):
-            module.__file__ = os.path.abspath(module.__file__)
-
-    # MacOSX (a.k.a. Darwin) has a default stack size that is too small
-    # for deeply recursive regular expressions.  We see this as crashes in
-    # the Python test suite when running test_re.py and test_sre.py.  The
-    # fix is to set the stack limit to 2048.
-    # This approach may also be useful for other Unixy platforms that
-    # suffer from small default stack limits.
-    if sys.platform == 'darwin':
-        try:
-            import resource
-        except ImportError:
+            module.__file__ = os.path.abspath(module.__file__)  # type: ignore[type-var]
+
+    if hasattr(sys, 'addaudithook'):
+        # Add an auditing hook for all tests to ensure PySys_Audit is tested
+        def _test_audit_hook(name, args):
             pass
-        else:
-            soft, hard = resource.getrlimit(resource.RLIMIT_STACK)
-            newsoft = min(hard, max(soft, 1024*2048))
-            resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard))
+        sys.addaudithook(_test_audit_hook)
 
-    if ns.huntrleaks:
-        unittest.BaseTestSuite._cleanup = False
+    setup_unraisable_hook()
+    setup_threading_excepthook()
 
-    if ns.memlimit is not None:
-        support.set_memlimit(ns.memlimit)
+    # Ensure there's a non-ASCII character in env vars at all times to force
+    # tests consider this case. See BPO-44647 for details.
+    if TESTFN_UNDECODABLE and os.supports_bytes_environ:
+        os.environb.setdefault(UNICODE_GUARD_ENV.encode(), TESTFN_UNDECODABLE)
+    elif FS_NONASCII:
+        os.environ.setdefault(UNICODE_GUARD_ENV, FS_NONASCII)
 
-    if ns.threshold is not None:
-        gc.set_threshold(ns.threshold)
 
-    try:
-        import msvcrt
-    except ImportError:
-        pass
+def setup_tests(runtests: RunTests) -> None:
+    support.verbose = runtests.verbose
+    support.failfast = runtests.fail_fast
+    support.PGO = runtests.pgo
+    support.PGO_EXTENDED = runtests.pgo_extended
+
+    set_match_tests(runtests.match_tests)
+
+    if runtests.use_junit:
+        support.junit_xml_list = []
+        from .testresult import RegressionTestResult
+        RegressionTestResult.USE_XML = True
     else:
-        msvcrt.SetErrorMode(msvcrt.SEM_FAILCRITICALERRORS|
-                            msvcrt.SEM_NOALIGNMENTFAULTEXCEPT|
-                            msvcrt.SEM_NOGPFAULTERRORBOX|
-                            msvcrt.SEM_NOOPENFILEERRORBOX)
-        try:
-            msvcrt.CrtSetReportMode
-        except AttributeError:
-            # release build
-            pass
-        else:
-            for m in [msvcrt.CRT_WARN, msvcrt.CRT_ERROR, msvcrt.CRT_ASSERT]:
-                if ns.verbose and ns.verbose >= 2:
-                    msvcrt.CrtSetReportMode(m, msvcrt.CRTDBG_MODE_FILE)
-                    msvcrt.CrtSetReportFile(m, msvcrt.CRTDBG_FILE_STDERR)
-                else:
-                    msvcrt.CrtSetReportMode(m, 0)
+        support.junit_xml_list = None
 
-    support.use_resources = ns.use_resources
+    if runtests.memory_limit is not None:
+        support.set_memlimit(runtests.memory_limit)
 
+    support.suppress_msvcrt_asserts(runtests.verbose >= 2)
 
-def replace_stdout():
-    """Set stdout encoder error handler to backslashreplace (as stderr error
-    handler) to avoid UnicodeEncodeError when printing a traceback"""
-    stdout = sys.stdout
-    try:
-        fd = stdout.fileno()
-    except ValueError:
-        # On IDLE, sys.stdout has no file descriptor and is not a TextIOWrapper
-        # object. Leaving sys.stdout unchanged.
-        #
-        # Catch ValueError to catch io.UnsupportedOperation on TextIOBase
-        # and ValueError on a closed stream.
-        return
-
-    sys.stdout = open(fd, 'w',
-        encoding=stdout.encoding,
-        errors="backslashreplace",
-        closefd=False,
-        newline='\n')
-
-    def restore_stdout():
-        sys.stdout.close()
-        sys.stdout = stdout
-    atexit.register(restore_stdout)
+    support.use_resources = runtests.use_resources
+
+    timeout = runtests.timeout
+    if timeout is not None:
+        # For a slow buildbot worker, increase SHORT_TIMEOUT and LONG_TIMEOUT
+        support.LOOPBACK_TIMEOUT = max(support.LOOPBACK_TIMEOUT, timeout / 120)
+        # don't increase INTERNET_TIMEOUT
+        support.SHORT_TIMEOUT = max(support.SHORT_TIMEOUT, timeout / 40)
+        support.LONG_TIMEOUT = max(support.LONG_TIMEOUT, timeout / 4)
+
+        # If --timeout is short: reduce timeouts
+        support.LOOPBACK_TIMEOUT = min(support.LOOPBACK_TIMEOUT, timeout)
+        support.INTERNET_TIMEOUT = min(support.INTERNET_TIMEOUT, timeout)
+        support.SHORT_TIMEOUT = min(support.SHORT_TIMEOUT, timeout)
+        support.LONG_TIMEOUT = min(support.LONG_TIMEOUT, timeout)
+
+    if runtests.hunt_refleak:
+        # private attribute that mypy doesn't know about:
+        unittest.BaseTestSuite._cleanup = False  # type: ignore[attr-defined]
+
+    if runtests.gc_threshold is not None:
+        gc.set_threshold(runtests.gc_threshold)
+
+    random.seed(runtests.random_seed)
+
+    # sys.stdout is redirected to a StringIO in single process mode on which
+    # color auto-detect fails as StringIO is not a TTY. If the original
+    # sys.stdout supports color pass that through with FORCE_COLOR so that when
+    # results are printed, such as with -W, they get color.
+    if can_colorize(file=sys.stdout):
+        os.environ['FORCE_COLOR'] = "1"
diff --git a/Lib/test/libregrtest/single.py b/Lib/test/libregrtest/single.py
new file mode 100644
index 0000000000..456eb53543
--- /dev/null
+++ b/Lib/test/libregrtest/single.py
@@ -0,0 +1,322 @@
+import faulthandler
+# import gc  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+import importlib
+import io
+import sys
+import time
+import traceback
+import unittest
+
+from test import support
+from test.support import threading_helper
+
+from .filter import match_test
+from .result import State, TestResult, TestStats
+from .runtests import RunTests
+from .save_env import saved_test_environment
+from .setup import setup_tests
+from .testresult import get_test_runner
+from .utils import (
+    TestName,
+    clear_caches, remove_testfn, abs_module_name, print_warning)
+
+
+# Minimum duration of a test to display its duration or to mention that
+# the test is running in background
+PROGRESS_MIN_TIME = 30.0   # seconds
+
+
+def run_unittest(test_mod):
+    loader = unittest.TestLoader()
+    tests = loader.loadTestsFromModule(test_mod)
+    for error in loader.errors:
+        print(error, file=sys.stderr)
+    if loader.errors:
+        raise Exception("errors while loading tests")
+    _filter_suite(tests, match_test)
+    return _run_suite(tests)
+
+def _filter_suite(suite, pred):
+    """Recursively filter test cases in a suite based on a predicate."""
+    newtests = []
+    for test in suite._tests:
+        if isinstance(test, unittest.TestSuite):
+            _filter_suite(test, pred)
+            newtests.append(test)
+        else:
+            if pred(test):
+                newtests.append(test)
+    suite._tests = newtests
+
+def _run_suite(suite):
+    """Run tests from a unittest.TestSuite-derived class."""
+    runner = get_test_runner(sys.stdout,
+                             verbosity=support.verbose,
+                             capture_output=(support.junit_xml_list is not None))
+
+    result = runner.run(suite)
+
+    if support.junit_xml_list is not None:
+        import xml.etree.ElementTree as ET
+        xml_elem = result.get_xml_element()
+        xml_str = ET.tostring(xml_elem).decode('ascii')
+        support.junit_xml_list.append(xml_str)
+
+    if not result.testsRun and not result.skipped and not result.errors:
+        raise support.TestDidNotRun
+    if not result.wasSuccessful():
+        stats = TestStats.from_unittest(result)
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            err = "multiple errors occurred"
+            if not support.verbose: err += "; run in verbose mode for details"
+        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
+        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
+        raise support.TestFailedWithDetails(err, errors, failures, stats=stats)
+    return result
+
+
+def regrtest_runner(result: TestResult, test_func, runtests: RunTests) -> None:
+    # Run test_func(), collect statistics, and detect reference and memory
+    # leaks.
+    if runtests.hunt_refleak:
+        from .refleak import runtest_refleak
+        refleak, test_result = runtest_refleak(result.test_name, test_func,
+                                               runtests.hunt_refleak,
+                                               runtests.quiet)
+    else:
+        test_result = test_func()
+        refleak = False
+
+    if refleak:
+        result.state = State.REFLEAK
+
+    stats: TestStats | None
+
+    match test_result:
+        case TestStats():
+            stats = test_result
+        case unittest.TestResult():
+            stats = TestStats.from_unittest(test_result)
+        case None:
+            print_warning(f"{result.test_name} test runner returned None: {test_func}")
+            stats = None
+        case _:
+            # Don't import doctest at top level since only few tests return
+            # a doctest.TestResult instance.
+            import doctest
+            if isinstance(test_result, doctest.TestResults):
+                stats = TestStats.from_doctest(test_result)
+            else:
+                print_warning(f"Unknown test result type: {type(test_result)}")
+                stats = None
+
+    result.stats = stats
+
+
+# Storage of uncollectable GC objects (gc.garbage)
+GC_GARBAGE = []
+
+
+def _load_run_test(result: TestResult, runtests: RunTests) -> None:
+    # Load the test module and run the tests.
+    test_name = result.test_name
+    module_name = abs_module_name(test_name, runtests.test_dir)
+    test_mod = importlib.import_module(module_name)
+
+    if hasattr(test_mod, "test_main"):
+        # https://github.com/python/cpython/issues/89392
+        raise Exception(f"Module {test_name} defines test_main() which "
+                        f"is no longer supported by regrtest")
+    def test_func():
+        return run_unittest(test_mod)
+
+    try:
+        regrtest_runner(result, test_func, runtests)
+    finally:
+        # First kill any dangling references to open files etc.
+        # This can also issue some ResourceWarnings which would otherwise get
+        # triggered during the following test run, and possibly produce
+        # failures.
+        support.gc_collect()
+
+        remove_testfn(test_name, runtests.verbose)
+
+    # if gc.garbage:  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     support.environment_altered = True  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     print_warning(f"{test_name} created {len(gc.garbage)} "  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #                   f"uncollectable object(s)")  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+
+    #     # move the uncollectable objects somewhere,  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     # so we don't see them again  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     GC_GARBAGE.extend(gc.garbage)  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+    #     gc.garbage.clear()  # TODO: RUSTPYTHON, build a functional garbage collector into the interpreter
+
+    support.reap_children()
+
+
+def _runtest_env_changed_exc(result: TestResult, runtests: RunTests,
+                             display_failure: bool = True) -> None:
+    # Handle exceptions, detect environment changes.
+
+    # Reset the environment_altered flag to detect if a test altered
+    # the environment
+    support.environment_altered = False
+
+    pgo = runtests.pgo
+    if pgo:
+        display_failure = False
+    quiet = runtests.quiet
+
+    test_name = result.test_name
+    try:
+        clear_caches()
+        support.gc_collect()
+
+        with saved_test_environment(test_name,  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+                                    runtests.verbose, quiet, pgo=pgo):  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+            _load_run_test(result, runtests)  # TODO: RUSTPYTHON, figure out why this was disabled in the first place
+    except support.ResourceDenied as exc:
+        if not quiet and not pgo:
+            print(f"{test_name} skipped -- {exc}", flush=True)
+        result.state = State.RESOURCE_DENIED
+        return
+    except unittest.SkipTest as exc:
+        if not quiet and not pgo:
+            print(f"{test_name} skipped -- {exc}", flush=True)
+        result.state = State.SKIPPED
+        return
+    except support.TestFailedWithDetails as exc:
+        msg = f"test {test_name} failed"
+        if display_failure:
+            msg = f"{msg} -- {exc}"
+        print(msg, file=sys.stderr, flush=True)
+        result.state = State.FAILED
+        result.errors = exc.errors
+        result.failures = exc.failures
+        result.stats = exc.stats
+        return
+    except support.TestFailed as exc:
+        msg = f"test {test_name} failed"
+        if display_failure:
+            msg = f"{msg} -- {exc}"
+        print(msg, file=sys.stderr, flush=True)
+        result.state = State.FAILED
+        result.stats = exc.stats
+        return
+    except support.TestDidNotRun:
+        result.state = State.DID_NOT_RUN
+        return
+    except KeyboardInterrupt:
+        print()
+        result.state = State.INTERRUPTED
+        return
+    except:
+        if not pgo:
+            msg = traceback.format_exc()
+            print(f"test {test_name} crashed -- {msg}",
+                  file=sys.stderr, flush=True)
+        result.state = State.UNCAUGHT_EXC
+        return
+
+    if support.environment_altered:
+        result.set_env_changed()
+    # Don't override the state if it was already set (REFLEAK or ENV_CHANGED)
+    if result.state is None:
+        result.state = State.PASSED
+
+
+def _runtest(result: TestResult, runtests: RunTests) -> None:
+    # Capture stdout and stderr, set faulthandler timeout,
+    # and create JUnit XML report.
+    verbose = runtests.verbose
+    output_on_failure = runtests.output_on_failure
+    timeout = runtests.timeout
+
+    if timeout is not None and threading_helper.can_start_thread:
+        use_timeout = True
+        faulthandler.dump_traceback_later(timeout, exit=True)
+    else:
+        use_timeout = False
+
+    try:
+        setup_tests(runtests)
+
+        if output_on_failure or runtests.pgo:
+            support.verbose = True
+
+            stream = io.StringIO()
+            orig_stdout = sys.stdout
+            orig_stderr = sys.stderr
+            print_warning = support.print_warning
+            orig_print_warnings_stderr = print_warning.orig_stderr
+
+            output = None
+            try:
+                sys.stdout = stream
+                sys.stderr = stream
+                # print_warning() writes into the temporary stream to preserve
+                # messages order. If support.environment_altered becomes true,
+                # warnings will be written to sys.stderr below.
+                print_warning.orig_stderr = stream
+
+                _runtest_env_changed_exc(result, runtests, display_failure=False)
+                # Ignore output if the test passed successfully
+                if result.state != State.PASSED:
+                    output = stream.getvalue()
+            finally:
+                sys.stdout = orig_stdout
+                sys.stderr = orig_stderr
+                print_warning.orig_stderr = orig_print_warnings_stderr
+
+            if output is not None:
+                sys.stderr.write(output)
+                sys.stderr.flush()
+        else:
+            # Tell tests to be moderately quiet
+            support.verbose = verbose
+            _runtest_env_changed_exc(result, runtests,
+                                     display_failure=not verbose)
+
+        xml_list = support.junit_xml_list
+        if xml_list:
+            result.xml_data = xml_list
+    finally:
+        if use_timeout:
+            faulthandler.cancel_dump_traceback_later()
+        support.junit_xml_list = None
+
+
+def run_single_test(test_name: TestName, runtests: RunTests) -> TestResult:
+    """Run a single test.
+
+    test_name -- the name of the test
+
+    Returns a TestResult.
+
+    If runtests.use_junit, xml_data is a list containing each generated
+    testsuite element.
+    """
+    start_time = time.perf_counter()
+    result = TestResult(test_name)
+    pgo = runtests.pgo
+    try:
+        # gh-117783: don't immortalize deferred objects when tracking
+        # refleaks. Only releveant for the free-threaded build.
+        with support.suppress_immortalization(runtests.hunt_refleak):
+            _runtest(result, runtests)
+    except:
+        if not pgo:
+            msg = traceback.format_exc()
+            print(f"test {test_name} crashed -- {msg}",
+                  file=sys.stderr, flush=True)
+        result.state = State.UNCAUGHT_EXC
+
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    result.duration = time.perf_counter() - start_time
+    return result
diff --git a/Lib/test/libregrtest/testresult.py b/Lib/test/libregrtest/testresult.py
new file mode 100644
index 0000000000..1820f35457
--- /dev/null
+++ b/Lib/test/libregrtest/testresult.py
@@ -0,0 +1,193 @@
+'''Test runner and result class for the regression test suite.
+
+'''
+
+import functools
+import io
+import sys
+import time
+import traceback
+import unittest
+from test import support
+from test.libregrtest.utils import sanitize_xml
+
+class RegressionTestResult(unittest.TextTestResult):
+    USE_XML = False
+
+    def __init__(self, stream, descriptions, verbosity):
+        super().__init__(stream=stream, descriptions=descriptions,
+                         verbosity=2 if verbosity else 0)
+        self.buffer = True
+        if self.USE_XML:
+            from xml.etree import ElementTree as ET
+            from datetime import datetime, UTC
+            self.__ET = ET
+            self.__suite = ET.Element('testsuite')
+            self.__suite.set('start',
+                             datetime.now(UTC)
+                                     .replace(tzinfo=None)
+                                     .isoformat(' '))
+            self.__e = None
+        self.__start_time = None
+
+    @classmethod
+    def __getId(cls, test):
+        try:
+            test_id = test.id
+        except AttributeError:
+            return str(test)
+        try:
+            return test_id()
+        except TypeError:
+            return str(test_id)
+        return repr(test)
+
+    def startTest(self, test):
+        super().startTest(test)
+        if self.USE_XML:
+            self.__e = e = self.__ET.SubElement(self.__suite, 'testcase')
+        self.__start_time = time.perf_counter()
+
+    def _add_result(self, test, capture=False, **args):
+        if not self.USE_XML:
+            return
+        e = self.__e
+        self.__e = None
+        if e is None:
+            return
+        ET = self.__ET
+
+        e.set('name', args.pop('name', self.__getId(test)))
+        e.set('status', args.pop('status', 'run'))
+        e.set('result', args.pop('result', 'completed'))
+        if self.__start_time:
+            e.set('time', f'{time.perf_counter() - self.__start_time:0.6f}')
+
+        if capture:
+            if self._stdout_buffer is not None:
+                stdout = self._stdout_buffer.getvalue().rstrip()
+                ET.SubElement(e, 'system-out').text = sanitize_xml(stdout)
+            if self._stderr_buffer is not None:
+                stderr = self._stderr_buffer.getvalue().rstrip()
+                ET.SubElement(e, 'system-err').text = sanitize_xml(stderr)
+
+        for k, v in args.items():
+            if not k or not v:
+                continue
+
+            e2 = ET.SubElement(e, k)
+            if hasattr(v, 'items'):
+                for k2, v2 in v.items():
+                    if k2:
+                        e2.set(k2, sanitize_xml(str(v2)))
+                    else:
+                        e2.text = sanitize_xml(str(v2))
+            else:
+                e2.text = sanitize_xml(str(v))
+
+    @classmethod
+    def __makeErrorDict(cls, err_type, err_value, err_tb):
+        if isinstance(err_type, type):
+            if err_type.__module__ == 'builtins':
+                typename = err_type.__name__
+            else:
+                typename = f'{err_type.__module__}.{err_type.__name__}'
+        else:
+            typename = repr(err_type)
+
+        msg = traceback.format_exception(err_type, err_value, None)
+        tb = traceback.format_exception(err_type, err_value, err_tb)
+
+        return {
+            'type': typename,
+            'message': ''.join(msg),
+            '': ''.join(tb),
+        }
+
+    def addError(self, test, err):
+        self._add_result(test, True, error=self.__makeErrorDict(*err))
+        super().addError(test, err)
+
+    def addExpectedFailure(self, test, err):
+        self._add_result(test, True, output=self.__makeErrorDict(*err))
+        super().addExpectedFailure(test, err)
+
+    def addFailure(self, test, err):
+        self._add_result(test, True, failure=self.__makeErrorDict(*err))
+        super().addFailure(test, err)
+        if support.failfast:
+            self.stop()
+
+    def addSkip(self, test, reason):
+        self._add_result(test, skipped=reason)
+        super().addSkip(test, reason)
+
+    def addSuccess(self, test):
+        self._add_result(test)
+        super().addSuccess(test)
+
+    def addUnexpectedSuccess(self, test):
+        self._add_result(test, outcome='UNEXPECTED_SUCCESS')
+        super().addUnexpectedSuccess(test)
+
+    def get_xml_element(self):
+        if not self.USE_XML:
+            raise ValueError("USE_XML is false")
+        e = self.__suite
+        e.set('tests', str(self.testsRun))
+        e.set('errors', str(len(self.errors)))
+        e.set('failures', str(len(self.failures)))
+        return e
+
+class QuietRegressionTestRunner:
+    def __init__(self, stream, buffer=False):
+        self.result = RegressionTestResult(stream, None, 0)
+        self.result.buffer = buffer
+
+    def run(self, test):
+        test(self.result)
+        return self.result
+
+def get_test_runner_class(verbosity, buffer=False):
+    if verbosity:
+        return functools.partial(unittest.TextTestRunner,
+                                 resultclass=RegressionTestResult,
+                                 buffer=buffer,
+                                 verbosity=verbosity)
+    return functools.partial(QuietRegressionTestRunner, buffer=buffer)
+
+def get_test_runner(stream, verbosity, capture_output=False):
+    return get_test_runner_class(verbosity, capture_output)(stream)
+
+if __name__ == '__main__':
+    import xml.etree.ElementTree as ET
+    RegressionTestResult.USE_XML = True
+
+    class TestTests(unittest.TestCase):
+        def test_pass(self):
+            pass
+
+        def test_pass_slow(self):
+            time.sleep(1.0)
+
+        def test_fail(self):
+            print('stdout', file=sys.stdout)
+            print('stderr', file=sys.stderr)
+            self.fail('failure message')
+
+        def test_error(self):
+            print('stdout', file=sys.stdout)
+            print('stderr', file=sys.stderr)
+            raise RuntimeError('error message')
+
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.TestLoader().loadTestsFromTestCase(TestTests))
+    stream = io.StringIO()
+    runner_cls = get_test_runner_class(sum(a == '-v' for a in sys.argv))
+    runner = runner_cls(sys.stdout)
+    result = runner.run(suite)
+    print('Output:', stream.getvalue())
+    print('XML: ', end='')
+    for s in ET.tostringlist(result.get_xml_element()):
+        print(s.decode(), end='')
+    print()
diff --git a/Lib/test/libregrtest/tsan.py b/Lib/test/libregrtest/tsan.py
new file mode 100644
index 0000000000..0c0ab20fa0
--- /dev/null
+++ b/Lib/test/libregrtest/tsan.py
@@ -0,0 +1,34 @@
+# Set of tests run by default if --tsan is specified.  The tests below were
+# chosen because they use threads and run in a reasonable amount of time.
+
+TSAN_TESTS = [
+    # TODO: enable more of test_capi once bugs are fixed (GH-116908, GH-116909).
+    'test_capi.test_mem',
+    'test_capi.test_pyatomic',
+    'test_code',
+    'test_enum',
+    'test_functools',
+    'test_httpservers',
+    'test_imaplib',
+    'test_importlib',
+    'test_io',
+    'test_logging',
+    'test_opcache',
+    'test_queue',
+    'test_signal',
+    'test_socket',
+    'test_sqlite3',
+    'test_ssl',
+    'test_syslog',
+    'test_thread',
+    'test_threadedtempfile',
+    'test_threading',
+    'test_threading_local',
+    'test_threadsignals',
+    'test_weakref',
+]
+
+
+def setup_tsan_tests(cmdline_args) -> None:
+    if not cmdline_args:
+        cmdline_args[:] = TSAN_TESTS[:]
diff --git a/Lib/test/libregrtest/utils.py b/Lib/test/libregrtest/utils.py
index fb9971a64f..6500fd10ce 100644
--- a/Lib/test/libregrtest/utils.py
+++ b/Lib/test/libregrtest/utils.py
@@ -1,10 +1,64 @@
+import contextlib
+import faulthandler
+import locale
 import math
 import os.path
+import platform
+import random
+import re
+import shlex
+import signal
+import subprocess
 import sys
+import sysconfig
+import tempfile
 import textwrap
+from collections.abc import Callable, Iterable
 
+from test import support
+from test.support import os_helper
+from test.support import threading_helper
 
-def format_duration(seconds):
+
+# All temporary files and temporary directories created by libregrtest should
+# use TMP_PREFIX so cleanup_temp_dir() can remove them all.
+TMP_PREFIX = 'test_python_'
+WORK_DIR_PREFIX = TMP_PREFIX
+WORKER_WORK_DIR_PREFIX = WORK_DIR_PREFIX + 'worker_'
+
+# bpo-38203: Maximum delay in seconds to exit Python (call Py_Finalize()).
+# Used to protect against threading._shutdown() hang.
+# Must be smaller than buildbot "1200 seconds without output" limit.
+EXIT_TIMEOUT = 120.0
+
+
+ALL_RESOURCES = ('audio', 'console', 'curses', 'largefile', 'network',
+                 'decimal', 'cpu', 'subprocess', 'urlfetch', 'gui', 'walltime')
+
+# Other resources excluded from --use=all:
+#
+# - extralagefile (ex: test_zipfile64): really too slow to be enabled
+#   "by default"
+# - tzdata: while needed to validate fully test_datetime, it makes
+#   test_datetime too slow (15-20 min on some buildbots) and so is disabled by
+#   default (see bpo-30822).
+RESOURCE_NAMES = ALL_RESOURCES + ('extralargefile', 'tzdata')
+
+
+# Types for types hints
+StrPath = str
+TestName = str
+StrJSON = str
+TestTuple = tuple[TestName, ...]
+TestList = list[TestName]
+# --match and --ignore options: list of patterns
+# ('*' joker character can be used)
+TestFilter = list[tuple[TestName, bool]]
+FilterTuple = tuple[TestName, ...]
+FilterDict = dict[TestName, FilterTuple]
+
+
+def format_duration(seconds: float) -> str:
     ms = math.ceil(seconds * 1e3)
     seconds, ms = divmod(ms, 1000)
     minutes, seconds = divmod(seconds, 60)
@@ -16,17 +70,20 @@ def format_duration(seconds):
     if minutes:
         parts.append('%s min' % minutes)
     if seconds:
-        parts.append('%s sec' % seconds)
-    if ms:
-        parts.append('%s ms' % ms)
+        if parts:
+            # 2 min 1 sec
+            parts.append('%s sec' % seconds)
+        else:
+            # 1.0 sec
+            parts.append('%.1f sec' % (seconds + ms / 1000))
     if not parts:
-        return '0 ms'
+        return '%s ms' % ms
 
     parts = parts[:2]
     return ' '.join(parts)
 
 
-def removepy(names):
+def strip_py_suffix(names: list[str] | None) -> None:
     if not names:
         return
     for idx, name in enumerate(names):
@@ -35,11 +92,20 @@ def removepy(names):
             names[idx] = basename
 
 
-def count(n, word):
+def plural(n: int, singular: str, plural: str | None = None) -> str:
     if n == 1:
-        return "%d %s" % (n, word)
+        return singular
+    elif plural is not None:
+        return plural
     else:
-        return "%d %ss" % (n, word)
+        return singular + 's'
+
+
+def count(n: int, word: str) -> str:
+    if n == 1:
+        return f"{n} {word}"
+    else:
+        return f"{n} {word}s"
 
 
 def printlist(x, width=70, indent=4, file=None):
@@ -57,5 +123,686 @@ def printlist(x, width=70, indent=4, file=None):
           file=file)
 
 
-def print_warning(msg):
-    print(f"Warning -- {msg}", file=sys.stderr, flush=True)
+def print_warning(msg: str) -> None:
+    support.print_warning(msg)
+
+
+orig_unraisablehook: Callable[..., None] | None = None
+
+
+def regrtest_unraisable_hook(unraisable) -> None:
+    global orig_unraisablehook
+    support.environment_altered = True
+    support.print_warning("Unraisable exception")
+    old_stderr = sys.stderr
+    try:
+        support.flush_std_streams()
+        sys.stderr = support.print_warning.orig_stderr
+        assert orig_unraisablehook is not None, "orig_unraisablehook not set"
+        orig_unraisablehook(unraisable)
+        sys.stderr.flush()
+    finally:
+        sys.stderr = old_stderr
+
+
+def setup_unraisable_hook() -> None:
+    global orig_unraisablehook
+    orig_unraisablehook = sys.unraisablehook
+    sys.unraisablehook = regrtest_unraisable_hook
+
+
+orig_threading_excepthook: Callable[..., None] | None = None
+
+
+def regrtest_threading_excepthook(args) -> None:
+    global orig_threading_excepthook
+    support.environment_altered = True
+    support.print_warning(f"Uncaught thread exception: {args.exc_type.__name__}")
+    old_stderr = sys.stderr
+    try:
+        support.flush_std_streams()
+        sys.stderr = support.print_warning.orig_stderr
+        assert orig_threading_excepthook is not None, "orig_threading_excepthook not set"
+        orig_threading_excepthook(args)
+        sys.stderr.flush()
+    finally:
+        sys.stderr = old_stderr
+
+
+def setup_threading_excepthook() -> None:
+    global orig_threading_excepthook
+    import threading
+    orig_threading_excepthook = threading.excepthook
+    threading.excepthook = regrtest_threading_excepthook
+
+
+def clear_caches():
+    # Clear the warnings registry, so they can be displayed again
+    for mod in sys.modules.values():
+        if hasattr(mod, '__warningregistry__'):
+            del mod.__warningregistry__
+
+    # Flush standard output, so that buffered data is sent to the OS and
+    # associated Python objects are reclaimed.
+    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
+        if stream is not None:
+            stream.flush()
+
+    try:
+        re = sys.modules['re']
+    except KeyError:
+        pass
+    else:
+        re.purge()
+
+    try:
+        _strptime = sys.modules['_strptime']
+    except KeyError:
+        pass
+    else:
+        _strptime._regex_cache.clear()
+
+    try:
+        urllib_parse = sys.modules['urllib.parse']
+    except KeyError:
+        pass
+    else:
+        urllib_parse.clear_cache()
+
+    try:
+        urllib_request = sys.modules['urllib.request']
+    except KeyError:
+        pass
+    else:
+        urllib_request.urlcleanup()
+
+    try:
+        linecache = sys.modules['linecache']
+    except KeyError:
+        pass
+    else:
+        linecache.clearcache()
+
+    try:
+        mimetypes = sys.modules['mimetypes']
+    except KeyError:
+        pass
+    else:
+        mimetypes._default_mime_types()
+
+    try:
+        filecmp = sys.modules['filecmp']
+    except KeyError:
+        pass
+    else:
+        filecmp._cache.clear()
+
+    try:
+        struct = sys.modules['struct']
+    except KeyError:
+        pass
+    else:
+        # struct._clearcache()  # TODO: RUSTPYTHON, investigate why this was disabled in the first place
+        pass
+
+    try:
+        doctest = sys.modules['doctest']
+    except KeyError:
+        pass
+    else:
+        doctest.master = None
+
+    try:
+        ctypes = sys.modules['ctypes']
+    except KeyError:
+        pass
+    else:
+        ctypes._reset_cache()
+
+    try:
+        typing = sys.modules['typing']
+    except KeyError:
+        pass
+    else:
+        for f in typing._cleanups:
+            f()
+
+        import inspect
+        abs_classes = filter(inspect.isabstract, typing.__dict__.values())
+        for abc in abs_classes:
+            for obj in abc.__subclasses__() + [abc]:
+                obj._abc_caches_clear()
+
+    try:
+        fractions = sys.modules['fractions']
+    except KeyError:
+        pass
+    else:
+        fractions._hash_algorithm.cache_clear()
+
+    try:
+        inspect = sys.modules['inspect']
+    except KeyError:
+        pass
+    else:
+        inspect._shadowed_dict_from_weakref_mro_tuple.cache_clear()
+        inspect._filesbymodname.clear()
+        inspect.modulesbyfile.clear()
+
+    try:
+        importlib_metadata = sys.modules['importlib.metadata']
+    except KeyError:
+        pass
+    else:
+        importlib_metadata.FastPath.__new__.cache_clear()
+
+
+def get_build_info():
+    # Get most important configure and build options as a list of strings.
+    # Example: ['debug', 'ASAN+MSAN'] or ['release', 'LTO+PGO'].
+
+    config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''
+    cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
+    cflags += ' ' + (sysconfig.get_config_var('PY_CFLAGS_NODIST') or '')
+    ldflags_nodist = sysconfig.get_config_var('PY_LDFLAGS_NODIST') or ''
+
+    build = []
+
+    # --disable-gil
+    if sysconfig.get_config_var('Py_GIL_DISABLED'):
+        if not sys.flags.ignore_environment:
+            PYTHON_GIL = os.environ.get('PYTHON_GIL', None)
+            if PYTHON_GIL:
+                PYTHON_GIL = (PYTHON_GIL == '1')
+        else:
+            PYTHON_GIL = None
+
+        free_threading = "free_threading"
+        if PYTHON_GIL is not None:
+            free_threading = f"{free_threading} GIL={int(PYTHON_GIL)}"
+        build.append(free_threading)
+
+    if hasattr(sys, 'gettotalrefcount'):
+        # --with-pydebug
+        build.append('debug')
+
+        if '-DNDEBUG' in cflags:
+            build.append('without_assert')
+    else:
+        build.append('release')
+
+        if '--with-assertions' in config_args:
+            build.append('with_assert')
+        elif '-DNDEBUG' not in cflags:
+            build.append('with_assert')
+
+    # --enable-experimental-jit
+    tier2 = re.search('-D_Py_TIER2=([0-9]+)', cflags)
+    if tier2:
+        tier2 = int(tier2.group(1))
+
+    if not sys.flags.ignore_environment:
+        PYTHON_JIT = os.environ.get('PYTHON_JIT', None)
+        if PYTHON_JIT:
+            PYTHON_JIT = (PYTHON_JIT != '0')
+    else:
+        PYTHON_JIT = None
+
+    if tier2 == 1:  # =yes
+        if PYTHON_JIT == False:
+            jit = 'JIT=off'
+        else:
+            jit = 'JIT'
+    elif tier2 == 3:  # =yes-off
+        if PYTHON_JIT:
+            jit = 'JIT'
+        else:
+            jit = 'JIT=off'
+    elif tier2 == 4:  # =interpreter
+        if PYTHON_JIT == False:
+            jit = 'JIT-interpreter=off'
+        else:
+            jit = 'JIT-interpreter'
+    elif tier2 == 6:  # =interpreter-off (Secret option!)
+        if PYTHON_JIT:
+            jit = 'JIT-interpreter'
+        else:
+            jit = 'JIT-interpreter=off'
+    elif '-D_Py_JIT' in cflags:
+        jit = 'JIT'
+    else:
+        jit = None
+    if jit:
+        build.append(jit)
+
+    # --enable-framework=name
+    framework = sysconfig.get_config_var('PYTHONFRAMEWORK')
+    if framework:
+        build.append(f'framework={framework}')
+
+    # --enable-shared
+    shared = int(sysconfig.get_config_var('PY_ENABLE_SHARED') or '0')
+    if shared:
+        build.append('shared')
+
+    # --with-lto
+    optimizations = []
+    if '-flto=thin' in ldflags_nodist:
+        optimizations.append('ThinLTO')
+    elif '-flto' in ldflags_nodist:
+        optimizations.append('LTO')
+
+    if support.check_cflags_pgo():
+        # PGO (--enable-optimizations)
+        optimizations.append('PGO')
+
+    if support.check_bolt_optimized():
+        # BOLT (--enable-bolt)
+        optimizations.append('BOLT')
+
+    if optimizations:
+        build.append('+'.join(optimizations))
+
+    # --with-address-sanitizer
+    sanitizers = []
+    if support.check_sanitizer(address=True):
+        sanitizers.append("ASAN")
+    # --with-memory-sanitizer
+    if support.check_sanitizer(memory=True):
+        sanitizers.append("MSAN")
+    # --with-undefined-behavior-sanitizer
+    if support.check_sanitizer(ub=True):
+        sanitizers.append("UBSAN")
+    # --with-thread-sanitizer
+    if support.check_sanitizer(thread=True):
+        sanitizers.append("TSAN")
+    if sanitizers:
+        build.append('+'.join(sanitizers))
+
+    # --with-trace-refs
+    if hasattr(sys, 'getobjects'):
+        build.append("TraceRefs")
+    # --enable-pystats
+    if hasattr(sys, '_stats_on'):
+        build.append("pystats")
+    # --with-valgrind
+    if sysconfig.get_config_var('WITH_VALGRIND'):
+        build.append("valgrind")
+    # --with-dtrace
+    if sysconfig.get_config_var('WITH_DTRACE'):
+        build.append("dtrace")
+
+    return build
+
+
+def get_temp_dir(tmp_dir: StrPath | None = None) -> StrPath:
+    if tmp_dir:
+        tmp_dir = os.path.expanduser(tmp_dir)
+    else:
+        # When tests are run from the Python build directory, it is best practice
+        # to keep the test files in a subfolder.  This eases the cleanup of leftover
+        # files using the "make distclean" command.
+        if sysconfig.is_python_build():
+            if not support.is_wasi:
+                tmp_dir = sysconfig.get_config_var('abs_builddir')
+                if tmp_dir is None:
+                    tmp_dir = sysconfig.get_config_var('abs_srcdir')
+                    if not tmp_dir:
+                        # gh-74470: On Windows, only srcdir is available. Using
+                        # abs_builddir mostly matters on UNIX when building
+                        # Python out of the source tree, especially when the
+                        # source tree is read only.
+                        tmp_dir = sysconfig.get_config_var('srcdir')
+                        if not tmp_dir:
+                            raise RuntimeError(
+                                "Could not determine the correct value for tmp_dir"
+                            )
+                tmp_dir = os.path.join(tmp_dir, 'build')
+            else:
+                # WASI platform
+                tmp_dir = sysconfig.get_config_var('projectbase')
+                if not tmp_dir:
+                    raise RuntimeError(
+                        "sysconfig.get_config_var('projectbase') "
+                        f"unexpectedly returned {tmp_dir!r} on WASI"
+                    )
+                tmp_dir = os.path.join(tmp_dir, 'build')
+
+                # When get_temp_dir() is called in a worker process,
+                # get_temp_dir() path is different than in the parent process
+                # which is not a WASI process. So the parent does not create
+                # the same "tmp_dir" than the test worker process.
+                os.makedirs(tmp_dir, exist_ok=True)
+        else:
+            tmp_dir = tempfile.gettempdir()
+
+    return os.path.abspath(tmp_dir)
+
+
+def fix_umask() -> None:
+    if support.is_emscripten:
+        # Emscripten has default umask 0o777, which breaks some tests.
+        # see https://github.com/emscripten-core/emscripten/issues/17269
+        old_mask = os.umask(0)
+        if old_mask == 0o777:
+            os.umask(0o027)
+        else:
+            os.umask(old_mask)
+
+
+def get_work_dir(parent_dir: StrPath, worker: bool = False) -> StrPath:
+    # Define a writable temp dir that will be used as cwd while running
+    # the tests. The name of the dir includes the pid to allow parallel
+    # testing (see the -j option).
+    # Emscripten and WASI have stubbed getpid(), Emscripten has only
+    # millisecond clock resolution. Use randint() instead.
+    if support.is_emscripten or support.is_wasi:
+        nounce = random.randint(0, 1_000_000)
+    else:
+        nounce = os.getpid()
+
+    if worker:
+        work_dir = WORK_DIR_PREFIX + str(nounce)
+    else:
+        work_dir = WORKER_WORK_DIR_PREFIX + str(nounce)
+    work_dir += os_helper.FS_NONASCII
+    work_dir = os.path.join(parent_dir, work_dir)
+    return work_dir
+
+
+@contextlib.contextmanager
+def exit_timeout():
+    try:
+        yield
+    except SystemExit as exc:
+        # bpo-38203: Python can hang at exit in Py_Finalize(), especially
+        # on threading._shutdown() call: put a timeout
+        if threading_helper.can_start_thread:
+            faulthandler.dump_traceback_later(EXIT_TIMEOUT, exit=True)
+        sys.exit(exc.code)
+
+
+def remove_testfn(test_name: TestName, verbose: int) -> None:
+    # Try to clean up os_helper.TESTFN if left behind.
+    #
+    # While tests shouldn't leave any files or directories behind, when a test
+    # fails that can be tedious for it to arrange.  The consequences can be
+    # especially nasty on Windows, since if a test leaves a file open, it
+    # cannot be deleted by name (while there's nothing we can do about that
+    # here either, we can display the name of the offending test, which is a
+    # real help).
+    name = os_helper.TESTFN
+    if not os.path.exists(name):
+        return
+
+    nuker: Callable[[str], None]
+    if os.path.isdir(name):
+        import shutil
+        kind, nuker = "directory", shutil.rmtree
+    elif os.path.isfile(name):
+        kind, nuker = "file", os.unlink
+    else:
+        raise RuntimeError(f"os.path says {name!r} exists but is neither "
+                           f"directory nor file")
+
+    if verbose:
+        print_warning(f"{test_name} left behind {kind} {name!r}")
+        support.environment_altered = True
+
+    try:
+        import stat
+        # fix possible permissions problems that might prevent cleanup
+        os.chmod(name, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
+        nuker(name)
+    except Exception as exc:
+        print_warning(f"{test_name} left behind {kind} {name!r} "
+                      f"and it couldn't be removed: {exc}")
+
+
+def abs_module_name(test_name: TestName, test_dir: StrPath | None) -> TestName:
+    if test_name.startswith('test.') or test_dir:
+        return test_name
+    else:
+        # Import it from the test package
+        return 'test.' + test_name
+
+
+# gh-90681: When rerunning tests, we might need to rerun the whole
+# class or module suite if some its life-cycle hooks fail.
+# Test level hooks are not affected.
+_TEST_LIFECYCLE_HOOKS = frozenset((
+    'setUpClass', 'tearDownClass',
+    'setUpModule', 'tearDownModule',
+))
+
+def normalize_test_name(test_full_name: str, *,
+                        is_error: bool = False) -> str | None:
+    short_name = test_full_name.split(" ")[0]
+    if is_error and short_name in _TEST_LIFECYCLE_HOOKS:
+        if test_full_name.startswith(('setUpModule (', 'tearDownModule (')):
+            # if setUpModule() or tearDownModule() failed, don't filter
+            # tests with the test file name, don't use filters.
+            return None
+
+        # This means that we have a failure in a life-cycle hook,
+        # we need to rerun the whole module or class suite.
+        # Basically the error looks like this:
+        #    ERROR: setUpClass (test.test_reg_ex.RegTest)
+        # or
+        #    ERROR: setUpModule (test.test_reg_ex)
+        # So, we need to parse the class / module name.
+        lpar = test_full_name.index('(')
+        rpar = test_full_name.index(')')
+        return test_full_name[lpar + 1: rpar].split('.')[-1]
+    return short_name
+
+
+def adjust_rlimit_nofile() -> None:
+    """
+    On macOS the default fd limit (RLIMIT_NOFILE) is sometimes too low (256)
+    for our test suite to succeed. Raise it to something more reasonable. 1024
+    is a common Linux default.
+    """
+    try:
+        import resource
+    except ImportError:
+        return
+
+    fd_limit, max_fds = resource.getrlimit(resource.RLIMIT_NOFILE)
+
+    desired_fds = 1024
+
+    if fd_limit < desired_fds and fd_limit < max_fds:
+        new_fd_limit = min(desired_fds, max_fds)
+        try:
+            resource.setrlimit(resource.RLIMIT_NOFILE,
+                               (new_fd_limit, max_fds))
+            print(f"Raised RLIMIT_NOFILE: {fd_limit} -> {new_fd_limit}")
+        except (ValueError, OSError) as err:
+            print_warning(f"Unable to raise RLIMIT_NOFILE from {fd_limit} to "
+                          f"{new_fd_limit}: {err}.")
+
+
+def get_host_runner() -> str:
+    if (hostrunner := os.environ.get("_PYTHON_HOSTRUNNER")) is None:
+        hostrunner = sysconfig.get_config_var("HOSTRUNNER")
+    return hostrunner
+
+
+def is_cross_compiled() -> bool:
+    return ('_PYTHON_HOST_PLATFORM' in os.environ)
+
+
+def format_resources(use_resources: Iterable[str]) -> str:
+    use_resources = set(use_resources)
+    all_resources = set(ALL_RESOURCES)
+
+    # Express resources relative to "all"
+    relative_all = ['all']
+    for name in sorted(all_resources - use_resources):
+        relative_all.append(f'-{name}')
+    for name in sorted(use_resources - all_resources):
+        relative_all.append(f'{name}')
+    all_text = ','.join(relative_all)
+    all_text = f"resources: {all_text}"
+
+    # List of enabled resources
+    text = ','.join(sorted(use_resources))
+    text = f"resources ({len(use_resources)}): {text}"
+
+    # Pick the shortest string (prefer relative to all if lengths are equal)
+    if len(all_text) <= len(text):
+        return all_text
+    else:
+        return text
+
+
+def display_header(use_resources: tuple[str, ...],
+                   python_cmd: tuple[str, ...] | None) -> None:
+    # Print basic platform information
+    print("==", platform.python_implementation(), *sys.version.split())
+    try:
+        print("==", platform.platform(aliased=True),
+                    "%s-endian" % sys.byteorder)
+    except Exception as e:
+        print("==", f"Error: {e}")
+        print("==", "TODO: RUSTPYTHON, Need to fix platform.platform")
+    print("== Python build:", ' '.join(get_build_info()))
+    print("== cwd:", os.getcwd())
+
+    cpu_count: object = os.cpu_count()
+    if cpu_count:
+        # The function is new in Python 3.13; mypy doesn't know about it yet:
+        process_cpu_count = os.process_cpu_count()  # type: ignore[attr-defined]
+        if process_cpu_count and process_cpu_count != cpu_count:
+            cpu_count = f"{process_cpu_count} (process) / {cpu_count} (system)"
+        print("== CPU count:", cpu_count)
+    try:
+        print("== encodings: locale=%s FS=%s"
+              % (locale.getencoding(), sys.getfilesystemencoding()))
+    except Exception as e:
+        print("==", f"Error: {e}")
+        print("==", "TODO: RUSTPYTHON, Need to fix encoding stuff")
+
+    if use_resources:
+        text = format_resources(use_resources)
+        print(f"== {text}")
+    else:
+        print("== resources: all test resources are disabled, "
+              "use -u option to unskip tests")
+
+    cross_compile = is_cross_compiled()
+    if cross_compile:
+        print("== cross compiled: Yes")
+    if python_cmd:
+        cmd = shlex.join(python_cmd)
+        print(f"== host python: {cmd}")
+
+        get_cmd = [*python_cmd, '-m', 'platform']
+        proc = subprocess.run(
+            get_cmd,
+            stdout=subprocess.PIPE,
+            text=True,
+            cwd=os_helper.SAVEDCWD)
+        stdout = proc.stdout.replace('\n', ' ').strip()
+        if stdout:
+            print(f"== host platform: {stdout}")
+        elif proc.returncode:
+            print(f"== host platform: <command failed with exit code {proc.returncode}>")
+    else:
+        hostrunner = get_host_runner()
+        if hostrunner:
+            print(f"== host runner: {hostrunner}")
+
+    # This makes it easier to remember what to set in your local
+    # environment when trying to reproduce a sanitizer failure.
+    asan = support.check_sanitizer(address=True)
+    msan = support.check_sanitizer(memory=True)
+    ubsan = support.check_sanitizer(ub=True)
+    tsan = support.check_sanitizer(thread=True)
+    sanitizers = []
+    if asan:
+        sanitizers.append("address")
+    if msan:
+        sanitizers.append("memory")
+    if ubsan:
+        sanitizers.append("undefined behavior")
+    if tsan:
+        sanitizers.append("thread")
+    if sanitizers:
+        print(f"== sanitizers: {', '.join(sanitizers)}")
+        for sanitizer, env_var in (
+            (asan, "ASAN_OPTIONS"),
+            (msan, "MSAN_OPTIONS"),
+            (ubsan, "UBSAN_OPTIONS"),
+            (tsan, "TSAN_OPTIONS"),
+        ):
+            options= os.environ.get(env_var)
+            if sanitizer and options is not None:
+                print(f"== {env_var}={options!r}")
+
+    print(flush=True)
+
+
+def cleanup_temp_dir(tmp_dir: StrPath) -> None:
+    import glob
+
+    path = os.path.join(glob.escape(tmp_dir), TMP_PREFIX + '*')
+    print("Cleanup %s directory" % tmp_dir)
+    for name in glob.glob(path):
+        if os.path.isdir(name):
+            print("Remove directory: %s" % name)
+            os_helper.rmtree(name)
+        else:
+            print("Remove file: %s" % name)
+            os_helper.unlink(name)
+
+WINDOWS_STATUS = {
+    0xC0000005: "STATUS_ACCESS_VIOLATION",
+    0xC00000FD: "STATUS_STACK_OVERFLOW",
+    0xC000013A: "STATUS_CONTROL_C_EXIT",
+}
+
+def get_signal_name(exitcode):
+    if exitcode < 0:
+        signum = -exitcode
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    # Shell exit code (ex: WASI build)
+    if 128 < exitcode < 256:
+        signum = exitcode - 128
+        try:
+            return signal.Signals(signum).name
+        except ValueError:
+            pass
+
+    try:
+        return WINDOWS_STATUS[exitcode]
+    except KeyError:
+        pass
+
+    return None
+
+
+ILLEGAL_XML_CHARS_RE = re.compile(
+    '['
+    # Control characters; newline (\x0A and \x0D) and TAB (\x09) are legal
+    '\x00-\x08\x0B\x0C\x0E-\x1F'
+    # Surrogate characters
+    '\uD800-\uDFFF'
+    # Special Unicode characters
+    '\uFFFE'
+    '\uFFFF'
+    # Match multiple sequential invalid characters for better efficiency
+    ']+')
+
+def _sanitize_xml_replace(regs):
+    text = regs[0]
+    return ''.join(f'\\x{ord(ch):02x}' if ch <= '\xff' else ascii(ch)[1:-1]
+                   for ch in text)
+
+def sanitize_xml(text: str) -> str:
+    return ILLEGAL_XML_CHARS_RE.sub(_sanitize_xml_replace, text)
diff --git a/Lib/test/libregrtest/win_utils.py b/Lib/test/libregrtest/win_utils.py
index 95db3def36..b51fde0af5 100644
--- a/Lib/test/libregrtest/win_utils.py
+++ b/Lib/test/libregrtest/win_utils.py
@@ -1,105 +1,128 @@
+import _overlapped
+import _thread
 import _winapi
-import msvcrt
-import os
-import subprocess
-import uuid
-from test import support
+import math
+import struct
+import winreg
 
 
-# Max size of asynchronous reads
-BUFSIZE = 8192
-# Exponential damping factor (see below)
-LOAD_FACTOR_1 = 0.9200444146293232478931553241
 # Seconds per measurement
-SAMPLING_INTERVAL = 5
-COUNTER_NAME = r'\System\Processor Queue Length'
+SAMPLING_INTERVAL = 1
+# Exponential damping factor to compute exponentially weighted moving average
+# on 1 minute (60 seconds)
+LOAD_FACTOR_1 = 1 / math.exp(SAMPLING_INTERVAL / 60)
+# Initialize the load using the arithmetic mean of the first NVALUE values
+# of the Processor Queue Length
+NVALUE = 5
 
 
 class WindowsLoadTracker():
     """
-    This class asynchronously interacts with the `typeperf` command to read
-    the system load on Windows. Mulitprocessing and threads can't be used
-    here because they interfere with the test suite's cases for those
-    modules.
+    This class asynchronously reads the performance counters to calculate
+    the system load on Windows.  A "raw" thread is used here to prevent
+    interference with the test suite's cases for the threading module.
     """
 
     def __init__(self):
-        self.load = 0.0
-        self.start()
-
-    def start(self):
-        # Create a named pipe which allows for asynchronous IO in Windows
-        pipe_name =  r'\\.\pipe\typeperf_output_' + str(uuid.uuid4())
-
-        open_mode =  _winapi.PIPE_ACCESS_INBOUND
-        open_mode |= _winapi.FILE_FLAG_FIRST_PIPE_INSTANCE
-        open_mode |= _winapi.FILE_FLAG_OVERLAPPED
-
-        # This is the read end of the pipe, where we will be grabbing output
-        self.pipe = _winapi.CreateNamedPipe(
-            pipe_name, open_mode, _winapi.PIPE_WAIT,
-            1, BUFSIZE, BUFSIZE, _winapi.NMPWAIT_WAIT_FOREVER, _winapi.NULL
-        )
-        # The write end of the pipe which is passed to the created process
-        pipe_write_end = _winapi.CreateFile(
-            pipe_name, _winapi.GENERIC_WRITE, 0, _winapi.NULL,
-            _winapi.OPEN_EXISTING, 0, _winapi.NULL
-        )
-        # Open up the handle as a python file object so we can pass it to
-        # subprocess
-        command_stdout = msvcrt.open_osfhandle(pipe_write_end, 0)
-
-        # Connect to the read end of the pipe in overlap/async mode
-        overlap = _winapi.ConnectNamedPipe(self.pipe, overlapped=True)
-        overlap.GetOverlappedResult(True)
-
-        # Spawn off the load monitor
-        command = ['typeperf', COUNTER_NAME, '-si', str(SAMPLING_INTERVAL)]
-        self.p = subprocess.Popen(command, stdout=command_stdout, cwd=os_helper.SAVEDCWD)
-
-        # Close our copy of the write end of the pipe
-        os.close(command_stdout)
-
-    def close(self):
-        if self.p is None:
+        # make __del__ not fail if pre-flight test fails
+        self._running = None
+        self._stopped = None
+
+        # Pre-flight test for access to the performance data;
+        # `PermissionError` will be raised if not allowed
+        winreg.QueryInfoKey(winreg.HKEY_PERFORMANCE_DATA)
+
+        self._values = []
+        self._load = None
+        self._running = _overlapped.CreateEvent(None, True, False, None)
+        self._stopped = _overlapped.CreateEvent(None, True, False, None)
+
+        _thread.start_new_thread(self._update_load, (), {})
+
+    def _update_load(self,
+                    # localize module access to prevent shutdown errors
+                     _wait=_winapi.WaitForSingleObject,
+                     _signal=_overlapped.SetEvent):
+        # run until signaled to stop
+        while _wait(self._running, 1000):
+            self._calculate_load()
+        # notify stopped
+        _signal(self._stopped)
+
+    def _calculate_load(self,
+                        # localize module access to prevent shutdown errors
+                        _query=winreg.QueryValueEx,
+                        _hkey=winreg.HKEY_PERFORMANCE_DATA,
+                        _unpack=struct.unpack_from):
+        # get the 'System' object
+        data, _ = _query(_hkey, '2')
+        # PERF_DATA_BLOCK {
+        #   WCHAR Signature[4]      8 +
+        #   DWOWD LittleEndian      4 +
+        #   DWORD Version           4 +
+        #   DWORD Revision          4 +
+        #   DWORD TotalByteLength   4 +
+        #   DWORD HeaderLength      = 24 byte offset
+        #   ...
+        # }
+        obj_start, = _unpack('L', data, 24)
+        # PERF_OBJECT_TYPE {
+        #   DWORD TotalByteLength
+        #   DWORD DefinitionLength
+        #   DWORD HeaderLength
+        #   ...
+        # }
+        data_start, defn_start = _unpack('4xLL', data, obj_start)
+        data_base = obj_start + data_start
+        defn_base = obj_start + defn_start
+        # find the 'Processor Queue Length' counter (index=44)
+        while defn_base < data_base:
+            # PERF_COUNTER_DEFINITION {
+            #   DWORD ByteLength
+            #   DWORD CounterNameTitleIndex
+            #   ... [7 DWORDs/28 bytes]
+            #   DWORD CounterOffset
+            # }
+            size, idx, offset = _unpack('LL28xL', data, defn_base)
+            defn_base += size
+            if idx == 44:
+                counter_offset = data_base + offset
+                # the counter is known to be PERF_COUNTER_RAWCOUNT (DWORD)
+                processor_queue_length, = _unpack('L', data, counter_offset)
+                break
+        else:
             return
-        self.p.kill()
-        self.p.wait()
-        self.p = None
 
-    def __del__(self):
-        self.close()
-
-    def read_output(self):
-        import _winapi
-
-        overlapped, _ = _winapi.ReadFile(self.pipe, BUFSIZE, True)
-        bytes_read, res = overlapped.GetOverlappedResult(False)
-        if res != 0:
-            return
-
-        return overlapped.getbuffer().decode()
+        # We use an exponentially weighted moving average, imitating the
+        # load calculation on Unix systems.
+        # https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
+        # https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
+        if self._load is not None:
+            self._load = (self._load * LOAD_FACTOR_1
+                            + processor_queue_length  * (1.0 - LOAD_FACTOR_1))
+        elif len(self._values) < NVALUE:
+            self._values.append(processor_queue_length)
+        else:
+            self._load = sum(self._values) / len(self._values)
+
+    def close(self, kill=True):
+        self.__del__()
+        return
+
+    def __del__(self,
+                # localize module access to prevent shutdown errors
+                _wait=_winapi.WaitForSingleObject,
+                _close=_winapi.CloseHandle,
+                _signal=_overlapped.SetEvent):
+        if self._running is not None:
+            # tell the update thread to quit
+            _signal(self._running)
+            # wait for the update thread to signal done
+            _wait(self._stopped, -1)
+            # cleanup events
+            _close(self._running)
+            _close(self._stopped)
+            self._running = self._stopped = None
 
     def getloadavg(self):
-        typeperf_output = self.read_output()
-        # Nothing to update, just return the current load
-        if not typeperf_output:
-            return self.load
-
-        # Process the backlog of load values
-        for line in typeperf_output.splitlines():
-            # typeperf outputs in a CSV format like this:
-            # "07/19/2018 01:32:26.605","3.000000"
-            toks = line.split(',')
-            # Ignore blank lines and the initial header
-            if line.strip() == '' or (COUNTER_NAME in line) or len(toks) != 2:
-                continue
-
-            load = float(toks[1].replace('"', ''))
-            # We use an exponentially weighted moving average, imitating the
-            # load calculation on Unix systems.
-            # https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
-            new_load = self.load * LOAD_FACTOR_1 + load * (1.0 - LOAD_FACTOR_1)
-            self.load = new_load
-
-        return self.load
+        return self._load
diff --git a/Lib/test/libregrtest/worker.py b/Lib/test/libregrtest/worker.py
new file mode 100644
index 0000000000..e0627c4adc
--- /dev/null
+++ b/Lib/test/libregrtest/worker.py
@@ -0,0 +1,123 @@
+import subprocess
+import sys
+import os
+from _colorize import can_colorize  # type: ignore[import-not-found]
+from typing import Any, NoReturn
+
+from test.support import os_helper, Py_DEBUG
+
+from .setup import setup_process, setup_test_dir
+from .runtests import WorkerRunTests, JsonFile, JsonFileType
+from .single import run_single_test
+from .utils import (
+    StrPath, StrJSON, TestFilter,
+    get_temp_dir, get_work_dir, exit_timeout)
+
+
+USE_PROCESS_GROUP = (hasattr(os, "setsid") and hasattr(os, "killpg"))
+
+
+def create_worker_process(runtests: WorkerRunTests, output_fd: int,
+                          tmp_dir: StrPath | None = None) -> subprocess.Popen[str]:
+    worker_json = runtests.as_json()
+
+    cmd = runtests.create_python_cmd()
+    cmd.extend(['-m', 'test.libregrtest.worker', worker_json])
+
+    env = dict(os.environ)
+    if tmp_dir is not None:
+        env['TMPDIR'] = tmp_dir
+        env['TEMP'] = tmp_dir
+        env['TMP'] = tmp_dir
+
+    # The subcommand is run with a temporary output which means it is not a TTY
+    # and won't auto-color. The test results are printed to stdout so if we can
+    # color that have the subprocess use color.
+    if can_colorize(file=sys.stdout):
+        env['FORCE_COLOR'] = '1'
+
+    # Running the child from the same working directory as regrtest's original
+    # invocation ensures that TEMPDIR for the child is the same when
+    # sysconfig.is_python_build() is true. See issue 15300.
+    #
+    # Emscripten and WASI Python must start in the Python source code directory
+    # to get 'python.js' or 'python.wasm' file. Then worker_process() changes
+    # to a temporary directory created to run tests.
+    work_dir = os_helper.SAVEDCWD
+
+    kwargs: dict[str, Any] = dict(
+        env=env,
+        stdout=output_fd,
+        # bpo-45410: Write stderr into stdout to keep messages order
+        stderr=output_fd,
+        text=True,
+        close_fds=True,
+        cwd=work_dir,
+    )
+    if USE_PROCESS_GROUP:
+        kwargs['start_new_session'] = True
+
+    # Pass json_file to the worker process
+    json_file = runtests.json_file
+    json_file.configure_subprocess(kwargs)
+
+    with json_file.inherit_subprocess():
+        return subprocess.Popen(cmd, **kwargs)
+
+
+def worker_process(worker_json: StrJSON) -> NoReturn:
+    runtests = WorkerRunTests.from_json(worker_json)
+    test_name = runtests.tests[0]
+    match_tests: TestFilter = runtests.match_tests
+    json_file: JsonFile = runtests.json_file
+
+    setup_test_dir(runtests.test_dir)
+    setup_process()
+
+    if runtests.rerun:
+        if match_tests:
+            matching = "matching: " + ", ".join(pattern for pattern, result in match_tests if result)
+            print(f"Re-running {test_name} in verbose mode ({matching})", flush=True)
+        else:
+            print(f"Re-running {test_name} in verbose mode", flush=True)
+
+    result = run_single_test(test_name, runtests)
+    if runtests.coverage:
+        if "test.cov" in sys.modules:  # imported by -Xpresite=
+            result.covered_lines = list(sys.modules["test.cov"].coverage)
+        elif not Py_DEBUG:
+            print(
+                "Gathering coverage in worker processes requires --with-pydebug",
+                flush=True,
+            )
+        else:
+            raise LookupError(
+                "`test.cov` not found in sys.modules but coverage wanted"
+            )
+
+    if json_file.file_type == JsonFileType.STDOUT:
+        print()
+        result.write_json_into(sys.stdout)
+    else:
+        with json_file.open('w', encoding='utf-8') as json_fp:
+            result.write_json_into(json_fp)
+
+    sys.exit(0)
+
+
+def main() -> NoReturn:
+    if len(sys.argv) != 2:
+        print("usage: python -m test.libregrtest.worker JSON")
+        sys.exit(1)
+    worker_json = sys.argv[1]
+
+    tmp_dir = get_temp_dir()
+    work_dir = get_work_dir(tmp_dir, worker=True)
+
+    with exit_timeout():
+        with os_helper.temp_cwd(work_dir, quiet=True):
+            worker_process(worker_json)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index 0e11af6f36..65dfa41b26 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -2,13 +2,11 @@
 Tests common to list and UserList.UserList
 """
 
-import unittest
 import sys
-import os
 from functools import cmp_to_key
 
-from test import support, seq_tests
-from test.support import ALWAYS_EQ, NEVER_EQ
+from test import seq_tests
+from test.support import ALWAYS_EQ, NEVER_EQ, get_c_recursion_limit
 
 
 class CommonTest(seq_tests.CommonTest):
@@ -33,13 +31,13 @@ def test_init(self):
         self.assertEqual(a, b)
 
     def test_getitem_error(self):
-        a = []
+        a = self.type2test([])
         msg = "list indices must be integers or slices"
         with self.assertRaisesRegex(TypeError, msg):
             a['a']
 
     def test_setitem_error(self):
-        a = []
+        a = self.type2test([])
         msg = "list indices must be integers or slices"
         with self.assertRaisesRegex(TypeError, msg):
             a['a'] = "python"
@@ -63,7 +61,7 @@ def test_repr(self):
 
     def test_repr_deep(self):
         a = self.type2test([])
-        for i in range(sys.getrecursionlimit() + 100):
+        for i in range(get_c_recursion_limit() + 1):
             a = self.type2test([a])
         self.assertRaises(RecursionError, repr, a)
 
@@ -193,6 +191,14 @@ def test_setslice(self):
 
         self.assertRaises(TypeError, a.__setitem__)
 
+    def test_slice_assign_iterator(self):
+        x = self.type2test(range(5))
+        x[0:3] = reversed(range(3))
+        self.assertEqual(x, self.type2test([2, 1, 0, 3, 4]))
+
+        x[:] = reversed(range(3))
+        self.assertEqual(x, self.type2test([2, 1, 0]))
+
     def test_delslice(self):
         a = self.type2test([0, 1])
         del a[1:2]
@@ -552,7 +558,7 @@ def test_constructor_exception_handling(self):
         class F(object):
             def __iter__(self):
                 raise KeyboardInterrupt
-        self.assertRaises(KeyboardInterrupt, list, F())
+        self.assertRaises(KeyboardInterrupt, self.type2test, F())
 
     def test_exhausted_iterator(self):
         a = self.type2test([1, 2, 3])
@@ -564,3 +570,8 @@ def test_exhausted_iterator(self):
         self.assertEqual(list(exhit), [])
         self.assertEqual(list(empit), [9])
         self.assertEqual(a, self.type2test([1, 2, 3, 9]))
+
+        # gh-115733: Crash when iterating over exhausted iterator
+        exhit = iter(self.type2test([1, 2, 3]))
+        for _ in exhit:
+            next(exhit, 1)
diff --git a/Lib/test/lock_tests.py b/Lib/test/lock_tests.py
index 09b9114780..4031bfaeb6 100644
--- a/Lib/test/lock_tests.py
+++ b/Lib/test/lock_tests.py
@@ -2,6 +2,7 @@
 Various tests for synchronization primitives.
 """
 
+import gc
 import sys
 import time
 from _thread import start_new_thread, TIMEOUT_MAX
@@ -13,54 +14,79 @@
 from test.support import threading_helper
 
 
-def _wait():
-    # A crude wait/yield function not relying on synchronization primitives.
-    time.sleep(0.01)
+requires_fork = unittest.skipUnless(support.has_fork_support,
+                                    "platform doesn't support fork "
+                                     "(no _at_fork_reinit method)")
+
+
+def wait_threads_blocked(nthread):
+    # Arbitrary sleep to wait until N threads are blocked,
+    # like waiting for a lock.
+    time.sleep(0.010 * nthread)
+
 
 class Bunch(object):
     """
     A bunch of threads.
     """
-    def __init__(self, f, n, wait_before_exit=False):
+    def __init__(self, func, nthread, wait_before_exit=False):
         """
-        Construct a bunch of `n` threads running the same function `f`.
+        Construct a bunch of `nthread` threads running the same function `func`.
         If `wait_before_exit` is True, the threads won't terminate until
         do_finish() is called.
         """
-        self.f = f
-        self.n = n
+        self.func = func
+        self.nthread = nthread
         self.started = []
         self.finished = []
+        self.exceptions = []
         self._can_exit = not wait_before_exit
-        self.wait_thread = threading_helper.wait_threads_exit()
-        self.wait_thread.__enter__()
+        self._wait_thread = None
 
-        def task():
-            tid = threading.get_ident()
-            self.started.append(tid)
-            try:
-                f()
-            finally:
-                self.finished.append(tid)
-                while not self._can_exit:
-                    _wait()
+    def task(self):
+        tid = threading.get_ident()
+        self.started.append(tid)
+        try:
+            self.func()
+        except BaseException as exc:
+            self.exceptions.append(exc)
+        finally:
+            self.finished.append(tid)
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if self._can_exit:
+                    break
+
+    def __enter__(self):
+        self._wait_thread = threading_helper.wait_threads_exit(support.SHORT_TIMEOUT)
+        self._wait_thread.__enter__()
 
         try:
-            for i in range(n):
-                start_new_thread(task, ())
+            for _ in range(self.nthread):
+                start_new_thread(self.task, ())
         except:
             self._can_exit = True
             raise
 
-    def wait_for_started(self):
-        while len(self.started) < self.n:
-            _wait()
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(self.started) >= self.nthread:
+                break
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(self.finished) >= self.nthread:
+                break
+
+        # Wait until threads completely exit according to _thread._count()
+        self._wait_thread.__exit__(None, None, None)
 
-    def wait_for_finished(self):
-        while len(self.finished) < self.n:
-            _wait()
-        # Wait for threads exit
-        self.wait_thread.__exit__(None, None, None)
+        # Break reference cycle
+        exceptions = self.exceptions
+        self.exceptions = None
+        if exceptions:
+            raise ExceptionGroup(f"{self.func} threads raised exceptions",
+                                 exceptions)
 
     def do_finish(self):
         self._can_exit = True
@@ -88,6 +114,12 @@ class BaseLockTests(BaseTestCase):
     Tests for both recursive and non-recursive locks.
     """
 
+    def wait_phase(self, phase, expected):
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            if len(phase) >= expected:
+                break
+        self.assertEqual(len(phase), expected)
+
     def test_constructor(self):
         lock = self.locktype()
         del lock
@@ -125,44 +157,60 @@ def test_try_acquire_contended(self):
         result = []
         def f():
             result.append(lock.acquire(False))
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(result[0])
         lock.release()
 
-    @unittest.skip("TODO: RUSTPYTHON, sometimes hangs")
+    @unittest.skip('TODO: RUSTPYTHON; sometimes hangs')
     def test_acquire_contended(self):
         lock = self.locktype()
         lock.acquire()
-        N = 5
         def f():
             lock.acquire()
             lock.release()
 
-        b = Bunch(f, N)
-        b.wait_for_started()
-        _wait()
-        self.assertEqual(len(b.finished), 0)
-        lock.release()
-        b.wait_for_finished()
-        self.assertEqual(len(b.finished), N)
+        N = 5
+        with Bunch(f, N) as bunch:
+            # Threads block on lock.acquire()
+            wait_threads_blocked(N)
+            self.assertEqual(len(bunch.finished), 0)
+
+            # Threads unblocked
+            lock.release()
+
+        self.assertEqual(len(bunch.finished), N)
 
     def test_with(self):
         lock = self.locktype()
         def f():
             lock.acquire()
             lock.release()
-        def _with(err=None):
+
+        def with_lock(err=None):
             with lock:
                 if err is not None:
                     raise err
-        _with()
-        # Check the lock is unacquired
-        Bunch(f, 1).wait_for_finished()
-        self.assertRaises(TypeError, _with, TypeError)
-        # Check the lock is unacquired
-        Bunch(f, 1).wait_for_finished()
 
-    @unittest.skip("TODO: RUSTPYTHON, sometimes hangs")
+        # Acquire the lock, do nothing, with releases the lock
+        with lock:
+            pass
+
+        # Check that the lock is unacquired
+        with Bunch(f, 1):
+            pass
+
+        # Acquire the lock, raise an exception, with releases the lock
+        with self.assertRaises(TypeError):
+            with lock:
+                raise TypeError
+
+        # Check that the lock is unacquired even if after an exception
+        # was raised in the previous "with lock:" block
+        with Bunch(f, 1):
+            pass
+
+    @unittest.skip('TODO: RUSTPYTHON; sometimes hangs')
     def test_thread_leak(self):
         # The lock shouldn't leak a Thread instance when used from a foreign
         # (non-threading) thread.
@@ -170,22 +218,16 @@ def test_thread_leak(self):
         def f():
             lock.acquire()
             lock.release()
-        n = len(threading.enumerate())
+
         # We run many threads in the hope that existing threads ids won't
         # be recycled.
-        Bunch(f, 15).wait_for_finished()
-        if len(threading.enumerate()) != n:
-            # There is a small window during which a Thread instance's
-            # target function has finished running, but the Thread is still
-            # alive and registered.  Avoid spurious failures by waiting a
-            # bit more (seen on a buildbot).
-            time.sleep(0.4)
-            self.assertEqual(n, len(threading.enumerate()))
+        with Bunch(f, 15):
+            pass
 
     def test_timeout(self):
         lock = self.locktype()
         # Can't set timeout if not blocking
-        self.assertRaises(ValueError, lock.acquire, 0, 1)
+        self.assertRaises(ValueError, lock.acquire, False, 1)
         # Invalid timeout values
         self.assertRaises(ValueError, lock.acquire, timeout=-100)
         self.assertRaises(OverflowError, lock.acquire, timeout=1e100)
@@ -204,7 +246,8 @@ def f():
             results.append(lock.acquire(timeout=0.5))
             t2 = time.monotonic()
             results.append(t2 - t1)
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(results[0])
         self.assertTimeout(results[1], 0.5)
 
@@ -217,6 +260,7 @@ def test_weakref_deleted(self):
         lock = self.locktype()
         ref = weakref.ref(lock)
         del lock
+        gc.collect()  # For PyPy or other GCs.
         self.assertIsNone(ref())
 
 
@@ -237,15 +281,13 @@ def f():
             phase.append(None)
 
         with threading_helper.wait_threads_exit():
+            # Thread blocked on lock.acquire()
             start_new_thread(f, ())
-            while len(phase) == 0:
-                _wait()
-            _wait()
-            self.assertEqual(len(phase), 1)
+            self.wait_phase(phase, 1)
+
+            # Thread unblocked
             lock.release()
-            while len(phase) == 1:
-                _wait()
-            self.assertEqual(len(phase), 2)
+            self.wait_phase(phase, 2)
 
     def test_different_thread(self):
         # Lock can be released from a different thread.
@@ -253,8 +295,8 @@ def test_different_thread(self):
         lock.acquire()
         def f():
             lock.release()
-        b = Bunch(f, 1)
-        b.wait_for_finished()
+        with Bunch(f, 1):
+            pass
         lock.acquire()
         lock.release()
 
@@ -268,6 +310,25 @@ def test_state_after_timeout(self):
         self.assertFalse(lock.locked())
         self.assertTrue(lock.acquire(blocking=False))
 
+    @requires_fork
+    def test_at_fork_reinit(self):
+        def use_lock(lock):
+            # make sure that the lock still works normally
+            # after _at_fork_reinit()
+            lock.acquire()
+            lock.release()
+
+        # unlocked
+        lock = self.locktype()
+        lock._at_fork_reinit()
+        use_lock(lock)
+
+        # locked: _at_fork_reinit() resets the lock to the unlocked state
+        lock2 = self.locktype()
+        lock2.acquire()
+        lock2._at_fork_reinit()
+        use_lock(lock2)
+
 
 class RLockTests(BaseLockTests):
     """
@@ -306,17 +367,52 @@ def test_release_save_unacquired(self):
         lock.release()
         self.assertRaises(RuntimeError, lock._release_save)
 
+    def test_recursion_count(self):
+        lock = self.locktype()
+        self.assertEqual(0, lock._recursion_count())
+        lock.acquire()
+        self.assertEqual(1, lock._recursion_count())
+        lock.acquire()
+        lock.acquire()
+        self.assertEqual(3, lock._recursion_count())
+        lock.release()
+        self.assertEqual(2, lock._recursion_count())
+        lock.release()
+        lock.release()
+        self.assertEqual(0, lock._recursion_count())
+
+        phase = []
+
+        def f():
+            lock.acquire()
+            phase.append(None)
+
+            self.wait_phase(phase, 2)
+            lock.release()
+            phase.append(None)
+
+        with threading_helper.wait_threads_exit():
+            # Thread blocked on lock.acquire()
+            start_new_thread(f, ())
+            self.wait_phase(phase, 1)
+            self.assertEqual(0, lock._recursion_count())
+
+            # Thread unblocked
+            phase.append(None)
+            self.wait_phase(phase, 3)
+            self.assertEqual(0, lock._recursion_count())
+
     def test_different_thread(self):
         # Cannot release from a different thread
         lock = self.locktype()
         def f():
             lock.acquire()
-        b = Bunch(f, 1, True)
-        try:
-            self.assertRaises(RuntimeError, lock.release)
-        finally:
-            b.do_finish()
-        b.wait_for_finished()
+
+        with Bunch(f, 1, True) as bunch:
+            try:
+                self.assertRaises(RuntimeError, lock.release)
+            finally:
+                bunch.do_finish()
 
     def test__is_owned(self):
         lock = self.locktype()
@@ -328,7 +424,8 @@ def test__is_owned(self):
         result = []
         def f():
             result.append(lock._is_owned())
-        Bunch(f, 1).wait_for_finished()
+        with Bunch(f, 1):
+            pass
         self.assertFalse(result[0])
         lock.release()
         self.assertTrue(lock._is_owned())
@@ -361,12 +458,15 @@ def _check_notify(self, evt):
         def f():
             results1.append(evt.wait())
             results2.append(evt.wait())
-        b = Bunch(f, N)
-        b.wait_for_started()
-        _wait()
-        self.assertEqual(len(results1), 0)
-        evt.set()
-        b.wait_for_finished()
+
+        with Bunch(f, N):
+            # Threads blocked on first evt.wait()
+            wait_threads_blocked(N)
+            self.assertEqual(len(results1), 0)
+
+            # Threads unblocked
+            evt.set()
+
         self.assertEqual(results1, [True] * N)
         self.assertEqual(results2, [True] * N)
 
@@ -389,46 +489,61 @@ def f():
             r = evt.wait(0.5)
             t2 = time.monotonic()
             results2.append((r, t2 - t1))
-        Bunch(f, N).wait_for_finished()
+
+        with Bunch(f, N):
+            pass
+
         self.assertEqual(results1, [False] * N)
         for r, dt in results2:
             self.assertFalse(r)
             self.assertTimeout(dt, 0.5)
+
         # The event is set
         results1 = []
         results2 = []
         evt.set()
-        Bunch(f, N).wait_for_finished()
+        with Bunch(f, N):
+            pass
+
         self.assertEqual(results1, [True] * N)
         for r, dt in results2:
             self.assertTrue(r)
 
     def test_set_and_clear(self):
-        # Issue #13502: check that wait() returns true even when the event is
+        # gh-57711: check that wait() returns true even when the event is
         # cleared before the waiting thread is woken up.
-        evt = self.eventtype()
+        event = self.eventtype()
         results = []
-        timeout = 0.250
-        N = 5
         def f():
-            results.append(evt.wait(timeout * 4))
-        b = Bunch(f, N)
-        b.wait_for_started()
-        time.sleep(timeout)
-        evt.set()
-        evt.clear()
-        b.wait_for_finished()
+            results.append(event.wait(support.LONG_TIMEOUT))
+
+        N = 5
+        with Bunch(f, N):
+            # Threads blocked on event.wait()
+            wait_threads_blocked(N)
+
+            # Threads unblocked
+            event.set()
+            event.clear()
+
         self.assertEqual(results, [True] * N)
 
-    def test_reset_internal_locks(self):
+    @requires_fork
+    def test_at_fork_reinit(self):
         # ensure that condition is still using a Lock after reset
         evt = self.eventtype()
         with evt._cond:
             self.assertFalse(evt._cond.acquire(False))
-        evt._reset_internal_locks()
+        evt._at_fork_reinit()
         with evt._cond:
             self.assertFalse(evt._cond.acquire(False))
 
+    def test_repr(self):
+        evt = self.eventtype()
+        self.assertRegex(repr(evt), r"<\w+\.Event at .*: unset>")
+        evt.set()
+        self.assertRegex(repr(evt), r"<\w+\.Event at .*: set>")
+
 
 class ConditionTests(BaseTestCase):
     """
@@ -466,15 +581,14 @@ def _check_notify(self, cond):
         # Note that this test is sensitive to timing.  If the worker threads
         # don't execute in a timely fashion, the main thread may think they
         # are further along then they are.  The main thread therefore issues
-        # _wait() statements to try to make sure that it doesn't race ahead
-        # of the workers.
+        # wait_threads_blocked() statements to try to make sure that it doesn't
+        # race ahead of the workers.
         # Secondly, this test assumes that condition variables are not subject
         # to spurious wakeups.  The absence of spurious wakeups is an implementation
         # detail of Condition Variables in current CPython, but in general, not
         # a guaranteed property of condition variables as a programming
         # construct.  In particular, it is possible that this can no longer
         # be conveniently guaranteed should their implementation ever change.
-        N = 5
         ready = []
         results1 = []
         results2 = []
@@ -483,58 +597,83 @@ def f():
             cond.acquire()
             ready.append(phase_num)
             result = cond.wait()
+
             cond.release()
             results1.append((result, phase_num))
+
             cond.acquire()
             ready.append(phase_num)
+
             result = cond.wait()
             cond.release()
             results2.append((result, phase_num))
-        b = Bunch(f, N)
-        b.wait_for_started()
-        # first wait, to ensure all workers settle into cond.wait() before
-        # we continue. See issues #8799 and #30727.
-        while len(ready) < 5:
-            _wait()
-        ready.clear()
-        self.assertEqual(results1, [])
-        # Notify 3 threads at first
-        cond.acquire()
-        cond.notify(3)
-        _wait()
-        phase_num = 1
-        cond.release()
-        while len(results1) < 3:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3)
-        self.assertEqual(results2, [])
-        # make sure all awaken workers settle into cond.wait()
-        while len(ready) < 3:
-            _wait()
-        # Notify 5 threads: they might be in their first or second wait
-        cond.acquire()
-        cond.notify(5)
-        _wait()
-        phase_num = 2
-        cond.release()
-        while len(results1) + len(results2) < 8:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3 + [(True, 2)] * 2)
-        self.assertEqual(results2, [(True, 2)] * 3)
-        # make sure all workers settle into cond.wait()
-        while len(ready) < 5:
-            _wait()
-        # Notify all threads: they are all in their second wait
-        cond.acquire()
-        cond.notify_all()
-        _wait()
-        phase_num = 3
-        cond.release()
-        while len(results2) < 5:
-            _wait()
-        self.assertEqual(results1, [(True, 1)] * 3 + [(True,2)] * 2)
-        self.assertEqual(results2, [(True, 2)] * 3 + [(True, 3)] * 2)
-        b.wait_for_finished()
+
+        N = 5
+        with Bunch(f, N):
+            # first wait, to ensure all workers settle into cond.wait() before
+            # we continue. See issues #8799 and #30727.
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= N:
+                    break
+
+            ready.clear()
+            self.assertEqual(results1, [])
+
+            # Notify 3 threads at first
+            count1 = 3
+            cond.acquire()
+            cond.notify(count1)
+            wait_threads_blocked(count1)
+
+            # Phase 1
+            phase_num = 1
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) >= count1:
+                    break
+
+            self.assertEqual(results1, [(True, 1)] * count1)
+            self.assertEqual(results2, [])
+
+            # Wait until awaken workers are blocked on cond.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= count1 :
+                    break
+
+            # Notify 5 threads: they might be in their first or second wait
+            cond.acquire()
+            cond.notify(5)
+            wait_threads_blocked(N)
+
+            # Phase 2
+            phase_num = 2
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= (N + count1):
+                    break
+
+            count2 = N - count1
+            self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
+            self.assertEqual(results2, [(True, 2)] * count1)
+
+            # Make sure all workers settle into cond.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(ready) >= N:
+                    break
+
+            # Notify all threads: they are all in their second wait
+            cond.acquire()
+            cond.notify_all()
+            wait_threads_blocked(N)
+
+            # Phase 3
+            phase_num = 3
+            cond.release()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results2) >= N:
+                    break
+            self.assertEqual(results1, [(True, 1)] * count1 + [(True, 2)] * count2)
+            self.assertEqual(results2, [(True, 2)] * count1 + [(True, 3)] * count2)
 
     def test_notify(self):
         cond = self.condtype()
@@ -544,19 +683,23 @@ def test_notify(self):
 
     def test_timeout(self):
         cond = self.condtype()
+        timeout = 0.5
         results = []
-        N = 5
         def f():
             cond.acquire()
             t1 = time.monotonic()
-            result = cond.wait(0.5)
+            result = cond.wait(timeout)
             t2 = time.monotonic()
             cond.release()
             results.append((t2 - t1, result))
-        Bunch(f, N).wait_for_finished()
+
+        N = 5
+        with Bunch(f, N):
+            pass
         self.assertEqual(len(results), N)
+
         for dt, result in results:
-            self.assertTimeout(dt, 0.5)
+            self.assertTimeout(dt, timeout)
             # Note that conceptually (that"s the condition variable protocol)
             # a wait() may succeed even if no one notifies us and before any
             # timeout occurs.  Spurious wakeups can occur.
@@ -569,17 +712,16 @@ def test_waitfor(self):
         state = 0
         def f():
             with cond:
-                result = cond.wait_for(lambda : state==4)
+                result = cond.wait_for(lambda: state == 4)
                 self.assertTrue(result)
                 self.assertEqual(state, 4)
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        for i in range(4):
-            time.sleep(0.01)
-            with cond:
-                state += 1
-                cond.notify()
-        b.wait_for_finished()
+
+        with Bunch(f, 1):
+            for i in range(4):
+                time.sleep(0.010)
+                with cond:
+                    state += 1
+                    cond.notify()
 
     def test_waitfor_timeout(self):
         cond = self.condtype()
@@ -593,15 +735,15 @@ def f():
                 self.assertFalse(result)
                 self.assertTimeout(dt, 0.1)
                 success.append(None)
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        # Only increment 3 times, so state == 4 is never reached.
-        for i in range(3):
-            time.sleep(0.01)
-            with cond:
-                state += 1
-                cond.notify()
-        b.wait_for_finished()
+
+        with Bunch(f, 1):
+            # Only increment 3 times, so state == 4 is never reached.
+            for i in range(3):
+                time.sleep(0.010)
+                with cond:
+                    state += 1
+                    cond.notify()
+
         self.assertEqual(len(success), 1)
 
 
@@ -630,41 +772,107 @@ def test_acquire_destroy(self):
         del sem
 
     def test_acquire_contended(self):
-        sem = self.semtype(7)
+        sem_value = 7
+        sem = self.semtype(sem_value)
         sem.acquire()
-        N = 10
+
         sem_results = []
         results1 = []
         results2 = []
         phase_num = 0
-        def f():
+
+        def func():
             sem_results.append(sem.acquire())
             results1.append(phase_num)
+
             sem_results.append(sem.acquire())
             results2.append(phase_num)
-        b = Bunch(f, 10)
-        b.wait_for_started()
-        while len(results1) + len(results2) < 6:
-            _wait()
-        self.assertEqual(results1 + results2, [0] * 6)
-        phase_num = 1
-        for i in range(7):
+
+        def wait_count(count):
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= count:
+                    break
+
+        N = 10
+        with Bunch(func, N):
+            # Phase 0
+            count1 = sem_value - 1
+            wait_count(count1)
+            self.assertEqual(results1 + results2, [0] * count1)
+
+            # Phase 1
+            phase_num = 1
+            for i in range(sem_value):
+                sem.release()
+            count2 = sem_value
+            wait_count(count1 + count2)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2)
+
+            # Phase 2
+            phase_num = 2
+            count3 = (sem_value - 1)
+            for i in range(count3):
+                sem.release()
+            wait_count(count1 + count2 + count3)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2 + [2] * count3)
+            # The semaphore is still locked
+            self.assertFalse(sem.acquire(False))
+
+            # Final release, to let the last thread finish
+            count4 = 1
             sem.release()
-        while len(results1) + len(results2) < 13:
-            _wait()
-        self.assertEqual(sorted(results1 + results2), [0] * 6 + [1] * 7)
-        phase_num = 2
-        for i in range(6):
+
+        self.assertEqual(sem_results,
+                         [True] * (count1 + count2 + count3 + count4))
+
+    def test_multirelease(self):
+        sem_value = 7
+        sem = self.semtype(sem_value)
+        sem.acquire()
+
+        results1 = []
+        results2 = []
+        phase_num = 0
+        def func():
+            sem.acquire()
+            results1.append(phase_num)
+
+            sem.acquire()
+            results2.append(phase_num)
+
+        def wait_count(count):
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if len(results1) + len(results2) >= count:
+                    break
+
+        with Bunch(func, 10):
+            # Phase 0
+            count1 = sem_value - 1
+            wait_count(count1)
+            self.assertEqual(results1 + results2, [0] * count1)
+
+            # Phase 1
+            phase_num = 1
+            count2 = sem_value
+            sem.release(count2)
+            wait_count(count1 + count2)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2)
+
+            # Phase 2
+            phase_num = 2
+            count3 = sem_value - 1
+            sem.release(count3)
+            wait_count(count1 + count2 + count3)
+            self.assertEqual(sorted(results1 + results2),
+                             [0] * count1 + [1] * count2 + [2] * count3)
+            # The semaphore is still locked
+            self.assertFalse(sem.acquire(False))
+
+            # Final release, to let the last thread finish
             sem.release()
-        while len(results1) + len(results2) < 19:
-            _wait()
-        self.assertEqual(sorted(results1 + results2), [0] * 6 + [1] * 7 + [2] * 6)
-        # The semaphore is still locked
-        self.assertFalse(sem.acquire(False))
-        # Final release, to let the last thread finish
-        sem.release()
-        b.wait_for_finished()
-        self.assertEqual(sem_results, [True] * (6 + 7 + 6 + 1))
 
     def test_try_acquire(self):
         sem = self.semtype(2)
@@ -681,7 +889,8 @@ def test_try_acquire_contended(self):
         def f():
             results.append(sem.acquire(False))
             results.append(sem.acquire(False))
-        Bunch(f, 5).wait_for_finished()
+        with Bunch(f, 5):
+            pass
         # There can be a thread switch between acquiring the semaphore and
         # appending the result, therefore results will not necessarily be
         # ordered.
@@ -707,12 +916,14 @@ def test_default_value(self):
         def f():
             sem.acquire()
             sem.release()
-        b = Bunch(f, 1)
-        b.wait_for_started()
-        _wait()
-        self.assertFalse(b.finished)
-        sem.release()
-        b.wait_for_finished()
+
+        with Bunch(f, 1) as bunch:
+            # Thread blocked on sem.acquire()
+            wait_threads_blocked(1)
+            self.assertFalse(bunch.finished)
+
+            # Thread unblocked
+            sem.release()
 
     def test_with(self):
         sem = self.semtype(2)
@@ -744,6 +955,15 @@ def test_release_unacquired(self):
         sem.acquire()
         sem.release()
 
+    def test_repr(self):
+        sem = self.semtype(3)
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=3>")
+        sem.acquire()
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=2>")
+        sem.release()
+        sem.release()
+        self.assertRegex(repr(sem), r"<\w+\.Semaphore at .*: value=4>")
+
 
 class BoundedSemaphoreTests(BaseSemaphoreTests):
     """
@@ -758,6 +978,12 @@ def test_release_unacquired(self):
         sem.release()
         self.assertRaises(ValueError, sem.release)
 
+    def test_repr(self):
+        sem = self.semtype(3)
+        self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=3/3>")
+        sem.acquire()
+        self.assertRegex(repr(sem), r"<\w+\.BoundedSemaphore at .*: value=2/3>")
+
 
 class BarrierTests(BaseTestCase):
     """
@@ -768,13 +994,13 @@ class BarrierTests(BaseTestCase):
 
     def setUp(self):
         self.barrier = self.barriertype(self.N, timeout=self.defaultTimeout)
+
     def tearDown(self):
         self.barrier.abort()
 
     def run_threads(self, f):
-        b = Bunch(f, self.N-1)
-        f()
-        b.wait_for_finished()
+        with Bunch(f, self.N):
+            pass
 
     def multipass(self, results, n):
         m = self.barrier.parties
@@ -789,6 +1015,10 @@ def multipass(self, results, n):
         self.assertEqual(self.barrier.n_waiting, 0)
         self.assertFalse(self.barrier.broken)
 
+    def test_constructor(self):
+        self.assertRaises(ValueError, self.barriertype, parties=0)
+        self.assertRaises(ValueError, self.barriertype, parties=-1)
+
     def test_barrier(self, passes=1):
         """
         Test that a barrier is passed in lockstep
@@ -865,8 +1095,9 @@ def f():
             i = self.barrier.wait()
             if i == self.N//2:
                 # Wait until the other threads are all in the barrier.
-                while self.barrier.n_waiting < self.N-1:
-                    time.sleep(0.001)
+                for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                    if self.barrier.n_waiting >= (self.N - 1):
+                        break
                 self.barrier.reset()
             else:
                 try:
@@ -926,27 +1157,56 @@ def f():
             i = self.barrier.wait()
             if i == self.N // 2:
                 # One thread is late!
-                time.sleep(1.0)
+                time.sleep(self.defaultTimeout / 2)
             # Default timeout is 2.0, so this is shorter.
             self.assertRaises(threading.BrokenBarrierError,
-                              self.barrier.wait, 0.5)
+                              self.barrier.wait, self.defaultTimeout / 4)
         self.run_threads(f)
 
     def test_default_timeout(self):
         """
         Test the barrier's default timeout
         """
-        # create a barrier with a low default timeout
-        barrier = self.barriertype(self.N, timeout=0.3)
+        timeout = 0.100
+        barrier = self.barriertype(2, timeout=timeout)
         def f():
-            i = barrier.wait()
-            if i == self.N // 2:
-                # One thread is later than the default timeout of 0.3s.
-                time.sleep(1.0)
-            self.assertRaises(threading.BrokenBarrierError, barrier.wait)
-        self.run_threads(f)
+            self.assertRaises(threading.BrokenBarrierError,
+                              barrier.wait)
+
+        start_time = time.monotonic()
+        with Bunch(f, 1):
+            pass
+        dt = time.monotonic() - start_time
+        self.assertGreaterEqual(dt, timeout)
 
     def test_single_thread(self):
         b = self.barriertype(1)
         b.wait()
         b.wait()
+
+    def test_repr(self):
+        barrier = self.barriertype(3)
+        timeout = support.LONG_TIMEOUT
+        self.assertRegex(repr(barrier), r"<\w+\.Barrier at .*: waiters=0/3>")
+        def f():
+            barrier.wait(timeout)
+
+        N = 2
+        with Bunch(f, N):
+            # Threads blocked on barrier.wait()
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if barrier.n_waiting >= N:
+                    break
+            self.assertRegex(repr(barrier),
+                             r"<\w+\.Barrier at .*: waiters=2/3>")
+
+            # Threads unblocked
+            barrier.wait(timeout)
+
+        self.assertRegex(repr(barrier),
+                         r"<\w+\.Barrier at .*: waiters=0/3>")
+
+        # Abort the barrier
+        barrier.abort()
+        self.assertRegex(repr(barrier),
+                         r"<\w+\.Barrier at .*: broken>")
diff --git a/Lib/test/mathdata/cmath_testcases.txt b/Lib/test/mathdata/cmath_testcases.txt
index 0165e17634..7b98b5a299 100644
--- a/Lib/test/mathdata/cmath_testcases.txt
+++ b/Lib/test/mathdata/cmath_testcases.txt
@@ -371,9 +371,9 @@ acosh1002 acosh 0.0 inf -> inf 1.5707963267948966
 acosh1003 acosh 2.3 inf -> inf 1.5707963267948966
 acosh1004 acosh -0.0 inf -> inf 1.5707963267948966
 acosh1005 acosh -2.3 inf -> inf 1.5707963267948966
-acosh1006 acosh 0.0 nan -> nan nan
+acosh1006 acosh 0.0 nan -> nan 1.5707963267948966         ignore-imag-sign
 acosh1007 acosh 2.3 nan -> nan nan
-acosh1008 acosh -0.0 nan -> nan nan
+acosh1008 acosh -0.0 nan -> nan 1.5707963267948966        ignore-imag-sign
 acosh1009 acosh -2.3 nan -> nan nan
 acosh1010 acosh -inf 0.0 -> inf 3.1415926535897931
 acosh1011 acosh -inf 2.3 -> inf 3.1415926535897931
@@ -1992,9 +1992,9 @@ tanh0065 tanh 1.797e+308 0.0 -> 1.0 0.0
 
 --special values
 tanh1000 tanh 0.0 0.0 -> 0.0 0.0
-tanh1001 tanh 0.0 inf -> nan nan        invalid
+tanh1001 tanh 0.0 inf -> 0.0 nan        invalid
 tanh1002 tanh 2.3 inf -> nan nan        invalid
-tanh1003 tanh 0.0 nan -> nan nan
+tanh1003 tanh 0.0 nan -> 0.0 nan
 tanh1004 tanh 2.3 nan -> nan nan
 tanh1005 tanh inf 0.0 -> 1.0 0.0
 tanh1006 tanh inf 0.7 -> 1.0 0.0
@@ -2009,7 +2009,7 @@ tanh1014 tanh nan 2.3 -> nan nan
 tanh1015 tanh nan inf -> nan nan
 tanh1016 tanh nan nan -> nan nan
 tanh1017 tanh 0.0 -0.0 -> 0.0 -0.0
-tanh1018 tanh 0.0 -inf -> nan nan       invalid
+tanh1018 tanh 0.0 -inf -> 0.0 nan       invalid
 tanh1019 tanh 2.3 -inf -> nan nan       invalid
 tanh1020 tanh inf -0.0 -> 1.0 -0.0
 tanh1021 tanh inf -0.7 -> 1.0 -0.0
@@ -2022,9 +2022,9 @@ tanh1027 tanh nan -0.0 -> nan -0.0
 tanh1028 tanh nan -2.3 -> nan nan
 tanh1029 tanh nan -inf -> nan nan
 tanh1030 tanh -0.0 -0.0 -> -0.0 -0.0
-tanh1031 tanh -0.0 -inf -> nan nan      invalid
+tanh1031 tanh -0.0 -inf -> -0.0 nan      invalid
 tanh1032 tanh -2.3 -inf -> nan nan      invalid
-tanh1033 tanh -0.0 nan -> nan nan
+tanh1033 tanh -0.0 nan -> -0.0 nan
 tanh1034 tanh -2.3 nan -> nan nan
 tanh1035 tanh -inf -0.0 -> -1.0 -0.0
 tanh1036 tanh -inf -0.7 -> -1.0 -0.0
@@ -2035,7 +2035,7 @@ tanh1040 tanh -inf -3.5 -> -1.0 -0.0
 tanh1041 tanh -inf -inf -> -1.0 0.0     ignore-imag-sign
 tanh1042 tanh -inf nan -> -1.0 0.0      ignore-imag-sign
 tanh1043 tanh -0.0 0.0 -> -0.0 0.0
-tanh1044 tanh -0.0 inf -> nan nan       invalid
+tanh1044 tanh -0.0 inf -> -0.0 nan       invalid
 tanh1045 tanh -2.3 inf -> nan nan       invalid
 tanh1046 tanh -inf 0.0 -> -1.0 0.0
 tanh1047 tanh -inf 0.7 -> -1.0 0.0
@@ -2307,9 +2307,9 @@ tan0066 tan -8.79645943005142 0.0 -> 0.7265425280053614098 0.0
 
 -- special values
 tan1000 tan -0.0 0.0 -> -0.0 0.0
-tan1001 tan -inf 0.0 -> nan nan invalid
+tan1001 tan -inf 0.0 -> nan 0.0 invalid
 tan1002 tan -inf 2.2999999999999998 -> nan nan invalid
-tan1003 tan nan 0.0 -> nan nan
+tan1003 tan nan 0.0 -> nan 0.0
 tan1004 tan nan 2.2999999999999998 -> nan nan
 tan1005 tan -0.0 inf -> -0.0 1.0
 tan1006 tan -0.69999999999999996 inf -> -0.0 1.0
@@ -2324,7 +2324,7 @@ tan1014 tan -2.2999999999999998 nan -> nan nan
 tan1015 tan -inf nan -> nan nan
 tan1016 tan nan nan -> nan nan
 tan1017 tan 0.0 0.0 -> 0.0 0.0
-tan1018 tan inf 0.0 -> nan nan invalid
+tan1018 tan inf 0.0 -> nan 0.0 invalid
 tan1019 tan inf 2.2999999999999998 -> nan nan invalid
 tan1020 tan 0.0 inf -> 0.0 1.0
 tan1021 tan 0.69999999999999996 inf -> 0.0 1.0
@@ -2337,9 +2337,9 @@ tan1027 tan 0.0 nan -> 0.0 nan
 tan1028 tan 2.2999999999999998 nan -> nan nan
 tan1029 tan inf nan -> nan nan
 tan1030 tan 0.0 -0.0 -> 0.0 -0.0
-tan1031 tan inf -0.0 -> nan nan invalid
+tan1031 tan inf -0.0 -> nan -0.0 invalid
 tan1032 tan inf -2.2999999999999998 -> nan nan invalid
-tan1033 tan nan -0.0 -> nan nan
+tan1033 tan nan -0.0 -> nan -0.0
 tan1034 tan nan -2.2999999999999998 -> nan nan
 tan1035 tan 0.0 -inf -> 0.0 -1.0
 tan1036 tan 0.69999999999999996 -inf -> 0.0 -1.0
@@ -2350,7 +2350,7 @@ tan1040 tan 3.5 -inf -> 0.0 -1.0
 tan1041 tan inf -inf -> -0.0 -1.0 ignore-real-sign
 tan1042 tan nan -inf -> -0.0 -1.0 ignore-real-sign
 tan1043 tan -0.0 -0.0 -> -0.0 -0.0
-tan1044 tan -inf -0.0 -> nan nan invalid
+tan1044 tan -inf -0.0 -> nan -0.0 invalid
 tan1045 tan -inf -2.2999999999999998 -> nan nan invalid
 tan1046 tan -0.0 -inf -> -0.0 -1.0
 tan1047 tan -0.69999999999999996 -inf -> -0.0 -1.0
diff --git a/Lib/test/mathdata/floating_points.txt b/Lib/test/mathdata/floating_points.txt
new file mode 100644
index 0000000000..539073d19d
--- /dev/null
+++ b/Lib/test/mathdata/floating_points.txt
@@ -0,0 +1,1028 @@
+# These numbers are used to test floating point binary-to-decimal conversion.
+# They are based on the TCL test suite (tests/expr.test), which is based on
+# test data from:
+# Brigitte Verdonk, Annie Cuyt, Dennis Verschaeren, A precision and range
+# independent tool for testing floating-point arithmetic II: Conversions,
+# ACM Transactions on Mathematical Software 27:2 (March 2001), pp. 119-140.
+
+0E0
+-0E0
+1E0
+15E-1
+125E-2
+1125E-3
+10625E-4
+103125E-5
+1015625E-6
+10078125E-7
+100390625E-8
+1001953125E-9
+10009765625E-10
+100048828125E-11
+1000244140625E-12
+10001220703125E-13
+100006103515625E-14
+1000030517578125E-15
+10000152587890625E-16
++8E153
+-1E153
++9E306
+-2E153
++7E-304
+-3E-49
++7E-303
+-6E-49
++9E43
+-9E44
++8E303
+-1E303
++7E-287
+-2E-204
++2E-205
+-9E-47
++34E195
+-68E195
++85E194
+-67E97
++93E-234
+-19E-87
++38E-87
+-38E-88
+-69E220
++18E43
+-36E43
++61E-99
+-43E-92
++86E-92
+-51E-74
++283E85
+-566E85
++589E187
+-839E143
+-744E-234
++930E-235
+-186E-234
++604E175
+-302E175
++755E174
+-151E175
++662E-213
+-408E-74
++510E-75
++6782E55
+-2309E92
++7963E34
+-3391E55
++7903E-96
+-7611E-226
++4907E-196
+-5547E-311
++5311E241
+-5311E243
++5311E242
++9269E-45
+-8559E-289
++8699E-276
+-8085E-64
++74819E201
+-82081E41
++51881E37
+-55061E157
++77402E-215
+-33891E-92
++38701E-215
+-82139E-76
++75859E25
++89509E140
+-57533E287
++46073E-32
+-92146E-32
++83771E-74
+-34796E-276
++584169E229
++164162E41
+-328324E41
++209901E-11
+-419802E-11
++940189E-112
+-892771E-213
++757803E120
+-252601E120
++252601E121
+-505202E120
++970811E-264
+-654839E-60
++289767E-178
+-579534E-178
+-8823691E130
++9346704E229
+-1168338E229
+-6063369E-136
++3865421E-225
+-5783893E-127
++2572231E223
+-5144462E223
++1817623E109
++6431543E-97
+-5444097E-21
++8076999E-121
+-9997649E-270
++50609263E157
++70589528E130
+-88236910E129
++87575437E-310
+-23135572E-127
++85900881E177
+-84863171E113
++68761586E232
+-50464069E286
++27869147E-248
+-55738294E-248
++70176353E-53
+-80555086E-32
+-491080654E121
++526250918E287
+-245540327E121
+-175150874E-310
++350301748E-310
+-437877185E-311
++458117166E52
+-916234332E52
++229058583E52
+-525789935E98
++282926897E-227
+-565853794E-227
++667284113E-240
+-971212611E-126
++9981396317E-182
+-5035231965E-156
++8336960483E-153
+-8056371144E-155
++6418488827E79
+-3981006983E252
++7962013966E252
+-4713898551E261
++8715380633E-58
+-9078555839E-109
++9712126110E-127
++42333842451E201
+-84667684902E201
++23792120709E-315
+-78564021519E-227
++71812054883E-188
+-30311163631E-116
++71803914657E292
++36314223356E-109
++18157111678E-109
+-45392779195E-110
++778380362293E218
+-685763015669E280
++952918668151E70
+-548357443505E32
++384865004907E-285
+-769730009814E-285
++697015418417E-93
+-915654049301E-28
++178548656339E169
+-742522891517E259
++742522891517E258
+-357097312678E169
+-3113521449172E218
++3891901811465E217
+-1556760724586E218
++9997878507563E-195
+-7247563029154E-319
++3623781514577E-319
+-3092446298323E-200
++6363857920591E145
+-8233559360849E94
++2689845954547E49
+-5379691909094E49
++5560322501926E-301
+-7812878489261E-179
++8439398533053E-256
+-2780161250963E-301
+-87605699161665E155
+-17521139832333E156
+-88218101363513E-170
++38639244311627E-115
++35593959807306E261
+-53390939710959E260
++71187919614612E261
+-88984899518265E260
++77003665618895E-73
+-15400733123779E-72
++61602932495116E-72
+-30801466247558E-72
++834735494917063E-300
+-589795149206434E-151
++475603213226859E-42
+-294897574603217E-151
++850813008001913E93
+-203449172043339E185
++406898344086678E185
+-813796688173356E185
++6045338514609393E244
+-5145963778954906E142
++2572981889477453E142
+-6965949469487146E74
++6182410494241627E-119
+-8510309498186985E-277
++6647704637273331E-212
+-2215901545757777E-212
++3771476185376383E276
+-3729901848043846E212
++3771476185376383E277
+-9977830465649166E119
++8439928496349319E-142
+-8204230082070882E-59
++8853686434843997E-244
+-5553274272288559E-104
++36149023611096162E144
+-36149023611096162E147
++18074511805548081E146
+-18074511805548081E147
++97338774138954421E-290
+-88133809804950961E-308
++94080055902682397E-243
+-24691002732654881E-115
++52306490527514614E49
+-26153245263757307E49
++55188692254193604E165
+-68985865317742005E164
++27176258005319167E-261
+-73169230107256116E-248
++91461537634070145E-249
+-54352516010638334E-261
++586144289638535878E280
+-601117006785295431E245
++293072144819267939E280
+-953184713238516652E272
++902042358290366539E-281
+-557035730189854663E-294
++902042358290366539E-280
+-354944100507554393E-238
++272104041512242479E199
+-816312124536727437E199
++544208083024484958E199
+-792644927852378159E78
+-679406450132979175E-263
++543525160106383340E-262
++7400253695682920196E215
+-1850063423920730049E215
++3700126847841460098E215
+-9250317119603650245E214
++8396094300569779681E-252
+-3507665085003296281E-75
++7015330170006592562E-75
+-7015330170006592562E-74
++7185620434951919351E205
+-1360520207561212395E198
++2178999185345151731E-184
+-8691089486201567102E-218
++4345544743100783551E-218
+-4357998370690303462E-184
++59825267349106892461E177
+-62259110684423957791E47
++58380168477038565599E265
+-62259110684423957791E48
+-33584377202279118724E-252
+-57484963479615354808E205
++71856204349519193510E204
+-14371240869903838702E205
++36992084760177624177E-318
+-73984169520355248354E-318
++99257763227713890244E-115
+-87336362425182547697E-280
++7E289
+-3E153
++6E153
+-5E243
++7E-161
+-7E-172
++8E-63
+-7E-113
++8E126
+-4E126
++5E125
+-1E126
++8E-163
+-1E-163
++2E-163
+-4E-163
++51E195
+-37E46
++74E46
+-56E289
++69E-145
+-70E-162
++56E-161
+-21E-303
++34E-276
+-68E-276
++85E-277
+-87E-274
++829E102
+-623E100
++723E-162
+-457E-102
++914E-102
+-323E-135
++151E176
+-302E176
++921E90
+-604E176
++823E-206
+-463E-114
++348E-274
++9968E100
+-6230E99
++1246E100
++6676E-296
+-8345E-297
++1669E-296
+-3338E-296
++3257E58
+-6514E58
++2416E176
++8085E-63
+-3234E-62
++1617E-62
+-6468E-62
++53418E111
+-60513E160
++26709E111
+-99447E166
++12549E48
+-25098E48
++50196E48
+-62745E47
++83771E-73
+-97451E-167
++86637E-203
+-75569E-254
++473806E83
+-947612E83
++292369E76
+-584738E76
++933587E-140
+-720919E-14
++535001E-149
+-890521E-235
++548057E81
+-706181E88
++820997E106
+-320681E63
++928609E-261
+-302276E-254
++151138E-254
++4691773E45
+-9383546E45
++3059949E-243
+-6119898E-243
++5356626E-213
+-4877378E-199
++7716693E223
+-5452869E109
++4590831E156
+-9181662E156
+-3714436E-261
++4643045E-262
+-7428872E-261
++52942146E130
+-27966061E145
++26471073E130
+-55932122E145
++95412548E-99
+-47706274E-99
++23853137E-99
+-78493654E-301
++65346417E29
+-51083099E167
++89396333E264
+-84863171E114
++59540836E-251
+-74426045E-252
++14885209E-251
+-29770418E-251
++982161308E122
+-245540327E122
++491080654E122
++525452622E-310
+-771837113E-134
++820858081E-150
+-262726311E-310
++923091487E209
+-653777767E273
++842116236E-53
+-741111169E-202
++839507247E-284
+-951487269E-264
+-9821613080E121
++6677856011E-31
+-3573796826E-266
++7147593652E-266
+-9981396317E-181
++3268888835E272
+-2615111068E273
++1307555534E273
++2990671154E-190
+-1495335577E-190
++5981342308E-190
+-7476677885E-191
++82259684194E-202
+-93227267727E-49
++41129842097E-202
+-47584241418E-314
+-79360293406E92
++57332259349E225
+-57202326162E111
++86860597053E-206
+-53827010643E-200
++53587107423E-61
++635007636765E200
++508006109412E201
+-254003054706E201
++561029718715E-72
+-897647549944E-71
++112205943743E-71
+-873947086081E-236
++809184709177E116
+-573112917422E81
++286556458711E81
++952805821491E-259
+-132189992873E-44
+-173696038493E-144
++1831132757599E-107
+-9155663787995E-108
++7324531030396E-107
+-9277338894969E-200
++8188292423973E287
+-5672557437938E59
++2836278718969E59
+-9995153153494E54
++9224786422069E-291
+-3142213164987E-294
++6284426329974E-294
+-8340483752889E-301
++67039371486466E89
+-62150786615239E197
++33519685743233E89
+-52563419496999E156
++32599460466991E-65
+-41010988798007E-133
++65198920933982E-65
+-82021977596014E-133
++80527976643809E61
+-74712611505209E158
++53390939710959E261
+-69277302659155E225
++46202199371337E-72
+-23438635467783E-179
++41921560615349E-67
+-92404398742674E-72
++738545606647197E124
+-972708181182949E117
+-837992143580825E87
++609610927149051E-255
+-475603213226859E-41
++563002800671023E-177
+-951206426453718E-41
++805416432656519E202
+-530658674694337E159
++946574173863918E208
+-318329953318553E113
+-462021993713370E-73
++369617594970696E-72
++3666156212014994E233
+-1833078106007497E233
++8301790508624232E174
+-1037723813578029E174
++7297662880581139E-286
+-5106185698912191E-276
++7487252720986826E-165
+-3743626360493413E-165
++3773057430100257E230
+-7546114860200514E230
++4321222892463822E58
+-7793560217139653E51
++26525993941010681E112
+-53051987882021362E112
++72844871414247907E77
+-88839359596763261E105
++18718131802467065E-166
+-14974505441973652E-165
++73429396004640239E106
+-58483921078398283E57
++41391519190645203E165
+-82783038381290406E165
++58767043776702677E-163
+-90506231831231999E-129
++64409240769861689E-159
+-77305427432277771E-190
++476592356619258326E273
+-953184713238516652E273
++899810892172646163E283
+-929167076892018333E187
++647761278967534239E-312
+-644290479820542942E-180
++926145344610700019E-225
+-958507931896511964E-246
++272104041512242479E200
+-792644927852378159E79
++544208083024484958E200
+-929963218616126365E290
++305574339166810102E-219
+-152787169583405051E-219
++611148678333620204E-219
+-763935847917025255E-220
++7439550220920798612E158
+-3719775110460399306E158
++9299437776150998265E157
+-7120190517612959703E120
++3507665085003296281E-73
+-7015330170006592562E-73
+-6684428762278255956E-294
+-1088416166048969916E200
+-8707329328391759328E200
++4439021781608558002E-65
+-8878043563217116004E-65
++2219510890804279001E-65
++33051223951904955802E55
+-56961524140903677624E120
++71201905176129597030E119
++14030660340013185124E-73
+-17538325425016481405E-74
++67536228609141569109E-133
+-35620497849450218807E-306
++66550376797582521751E-126
+-71240995698900437614E-306
++3E24
+-6E24
++6E26
+-7E25
++1E-14
+-2E-14
++4E-14
+-8E-14
++5E26
+-8E27
++1E27
+-4E27
++9E-13
+-7E-20
++56E25
+-70E24
++51E26
++71E-17
+-31E-5
++62E-5
+-94E-8
++67E27
+-81E24
++54E23
+-54E25
++63E-22
+-63E-23
++43E-4
+-86E-4
++942E26
+-471E25
++803E24
+-471E26
+-409E-21
++818E-21
+-867E-8
++538E27
+-857E24
++269E27
+-403E26
++959E-7
+-959E-6
++373E-27
+-746E-27
++4069E24
+-4069E23
+-8138E24
++8294E-15
+-4147E-14
++4147E-15
+-8294E-14
++538E27
+-2690E26
++269E27
+-2152E27
++1721E-17
+-7979E-27
++6884E-17
+-8605E-18
++82854E27
+-55684E24
++27842E24
+-48959E25
++81921E-17
+-76207E-8
++4147E-15
+-41470E-16
++89309E24
++75859E26
+-75859E25
++14257E-23
+-28514E-23
++57028E-23
+-71285E-24
++344863E27
+-951735E27
++200677E23
+-401354E24
++839604E-11
+-209901E-11
++419802E-11
+-537734E-24
++910308E26
+-227577E26
++455154E26
+-531013E25
++963019E-21
+-519827E-13
++623402E-27
+-311701E-27
++9613651E26
+-9191316E23
++4595658E23
+-2297829E23
+-1679208E-11
++3379223E27
+-6758446E27
++5444097E-21
+-8399969E-27
++8366487E-16
+-8366487E-15
++65060671E25
++65212389E23
++55544957E-13
+-51040905E-20
++99585767E-22
+-99585767E-23
++40978393E26
+-67488159E24
++69005339E23
+-81956786E26
+-87105552E-21
++10888194E-21
+-21776388E-21
++635806667E27
+-670026614E25
++335013307E26
+-335013307E25
++371790617E-24
+-371790617E-25
++743581234E-24
+-743581234E-25
++202464477E24
+-404928954E24
++997853758E27
+-997853758E26
++405498418E-17
+-582579084E-14
++608247627E-18
+-291289542E-14
+-9537100005E26
++6358066670E27
+-1271613334E27
++5229646999E-16
++5229646999E-17
++4429943614E24
+-8859887228E24
++2214971807E24
+-4176887093E26
++4003495257E-20
+-4361901637E-23
++8723803274E-23
+-8006990514E-20
++72835110098E27
+-36417555049E27
++84279630104E25
+-84279630104E24
++21206176437E-27
+-66461566917E-22
++64808355539E-16
+-84932679673E-19
++65205430094E26
+-68384463429E25
++32602715047E26
+-62662203426E27
++58784444678E-18
+-50980203373E-21
++29392222339E-18
+-75529940323E-27
+-937495906299E26
++842642485799E-20
+-387824150699E-23
++924948814726E-27
+-775648301398E-23
++547075707432E25
++683844634290E24
+-136768926858E25
++509802033730E-22
++101960406746E-21
+-815683253968E-21
++7344124123524E24
+-9180155154405E23
++6479463327323E27
+-1836031030881E24
++4337269293039E-19
+-4599163554373E-23
++9198327108746E-23
++4812803938347E27
+-8412030890011E23
++9625607876694E27
+-4739968828249E24
++9697183891673E-23
+-7368108517543E-20
++51461358161422E25
+-77192037242133E26
++77192037242133E25
+-51461358161422E27
++43999661561541E-21
+-87999323123082E-21
++48374886826137E-26
+-57684246567111E-23
++87192805957686E23
+-75108713005913E24
++64233110587487E27
+-77577471133384E-23
++48485919458365E-24
+-56908598265713E-26
++589722294620133E23
++652835804449289E-22
+-656415363936202E-23
++579336749585745E-25
+-381292764980839E-26
++965265859649698E23
+-848925235434882E27
++536177612222491E23
+-424462617717441E27
++276009279888989E-27
+-608927158043691E-26
++552018559777978E-27
+-425678377667758E-22
++8013702726927119E26
++8862627962362001E27
+-5068007907757162E26
+-7379714799828406E-23
++4114538064016107E-27
+-3689857399914203E-23
++5575954851815478E23
++3395700941739528E27
++4115535777581961E-23
+-8231071555163922E-23
++6550246696190871E-26
+-68083046403986701E27
++43566388595783643E27
+-87132777191567286E27
++59644881059342141E25
+-83852770718576667E23
++99482967418206961E-25
+-99482967418206961E-26
++87446669969994614E-27
+-43723334984997307E-27
++5E24
+-8E25
++1E25
+-4E25
++2E-5
+-5E-6
++4E-5
+-3E-20
++3E27
+-9E26
++7E25
+-6E27
++2E-21
+-5E-22
+-4E-21
++87E25
+-97E24
++82E-24
+-41E-24
++76E-23
++83E25
+-50E27
++25E27
+-99E27
++97E-10
+-57E-20
++997E23
++776E24
+-388E24
++521E-10
+-506E-26
++739E-10
+-867E-7
+-415E24
++332E25
+-664E25
++291E-13
+-982E-8
++582E-13
+-491E-8
++4574E26
+-8609E26
++2287E26
+-4818E24
++6529E-8
+-8151E-21
++1557E-12
+-2573E-18
++4929E-16
+-3053E-22
++9858E-16
+-7767E-11
++54339E26
+-62409E25
++32819E27
+-89849E27
++63876E-20
+-15969E-20
++31938E-20
+-79845E-21
++89306E27
+-25487E24
++79889E24
+-97379E26
++81002E-8
+-43149E-25
++40501E-8
+-60318E-10
+-648299E27
++780649E24
++720919E-14
+-629703E-11
++557913E24
+-847899E23
++565445E27
+-736531E24
++680013E-19
+-529981E-10
++382923E-23
+-633614E-18
++2165479E27
+-8661916E27
++4330958E27
+-9391993E22
+-5767352E-14
++7209190E-15
+-1441838E-14
++8478990E22
++1473062E24
++8366487E-14
+-8399969E-25
++9366737E-12
+-9406141E-13
++65970979E24
+-65060671E26
++54923002E27
+-63846927E25
++99585767E-21
++67488159E25
+-69005339E24
++81956786E27
+-40978393E27
++77505754E-12
+-38752877E-12
++82772981E-15
+-95593517E-25
++200036989E25
+-772686455E27
++859139907E23
+-400073978E25
++569014327E-14
+-794263862E-15
++397131931E-15
+-380398957E-16
++567366773E27
+-337440795E24
++134976318E25
+-269952636E25
++932080597E-20
+-331091924E-15
+-413864905E-16
++8539246247E26
+-5859139791E26
++6105010149E24
+-3090745820E27
++3470877773E-20
+-6136309089E-27
++8917758713E-19
+-6941755546E-20
++9194900535E25
+-1838980107E26
++7355920428E26
+-3677960214E26
++8473634343E-17
+-8870766274E-16
++4435383137E-16
+-9598990129E-15
++71563496764E26
+-89454370955E25
++17890874191E26
+-35781748382E26
++57973447842E-19
+-28986723921E-19
++76822711313E-19
+-97699466874E-20
++67748656762E27
+-19394840991E24
++38789681982E24
+-33874328381E27
++54323763886E-27
+-58987193887E-20
++27161881943E-27
+-93042648033E-19
++520831059055E27
+-768124264394E25
++384062132197E25
++765337749889E-25
++794368912771E25
+-994162090146E23
++781652779431E26
++910077190046E-26
+-455038595023E-26
++471897551096E-20
+-906698409911E-21
++8854128003935E25
+-8146122716299E27
++7083302403148E26
+-3541651201574E26
++8394920649291E-25
+-7657975756753E-22
++5473834002228E-20
+-6842292502785E-21
+-2109568884597E25
++8438275538388E25
+-4219137769194E25
++3200141789841E-25
+-8655689322607E-22
++6400283579682E-25
+-8837719634493E-21
++19428217075297E24
+-38856434150594E24
++77712868301188E24
+-77192037242133E27
++76579757567530E-23
++15315951513506E-22
+-38289878783765E-23
++49378033925202E25
+-50940527102367E24
++98756067850404E25
+-99589397544892E26
+-56908598265713E-25
++97470695699657E-22
+-35851901247343E-25
++154384074484266E27
+-308768148968532E27
++910990389005985E23
++271742424169201E-27
+-543484848338402E-27
++162192083357563E-26
+-869254552770081E-23
++664831007626046E24
+-332415503813023E24
++943701829041427E24
+-101881054204734E24
++828027839666967E-27
+-280276135608777E-27
++212839188833879E-21
+-113817196531426E-25
++9711553197796883E27
+-2739849386524269E26
++5479698773048538E26
++6124568318523113E-25
+-1139777988171071E-24
++6322612303128019E-27
+-2955864564844617E-25
+-9994029144998961E25
+-2971238324022087E27
+-1656055679333934E-27
+-1445488709150234E-26
++55824717499885172E27
+-69780896874856465E26
++84161538867545199E25
+-27912358749942586E27
++24711112462926331E-25
+-12645224606256038E-27
+-12249136637046226E-25
++74874448287465757E27
+-35642836832753303E24
+-71285673665506606E24
++43723334984997307E-26
++10182419849537963E-24
+-93501703572661982E-26
+
+# A value that caused a crash in debug builds for Python >= 2.7, 3.1
+# See http://bugs.python.org/issue7632
+2183167012312112312312.23538020374420446192e-370
+
+# Another value designed to test a corner case of Python's strtod code.
+0.99999999999999999999999999999999999999999e+23
diff --git a/Lib/test/mathdata/formatfloat_testcases.txt b/Lib/test/mathdata/formatfloat_testcases.txt
new file mode 100644
index 0000000000..25c07ba293
--- /dev/null
+++ b/Lib/test/mathdata/formatfloat_testcases.txt
@@ -0,0 +1,355 @@
+-- 'f' code formatting, with explicit precision (>= 0).  Output always
+-- has the given number of places after the point;  zeros are added if
+-- necessary to make this true.
+
+-- zeros
+%.0f 0 -> 0
+%.1f 0 -> 0.0
+%.2f 0 -> 0.00
+%.3f 0 -> 0.000
+%.50f 0 -> 0.00000000000000000000000000000000000000000000000000
+
+-- precision 0;  result should never include a .
+%.0f 1.5 -> 2
+%.0f 2.5 -> 2
+%.0f 3.5 -> 4
+%.0f 0.0 -> 0
+%.0f 0.1 -> 0
+%.0f 0.001 -> 0
+%.0f 10.0 -> 10
+%.0f 10.1 -> 10
+%.0f 10.01 -> 10
+%.0f 123.456 -> 123
+%.0f 1234.56 -> 1235
+%.0f 1e49 -> 9999999999999999464902769475481793196872414789632
+%.0f 9.9999999999999987e+49 -> 99999999999999986860582406952576489172979654066176
+%.0f 1e50 -> 100000000000000007629769841091887003294964970946560
+
+-- precision 1
+%.1f 0.0001 -> 0.0
+%.1f 0.001 -> 0.0
+%.1f 0.01 -> 0.0
+%.1f 0.04 -> 0.0
+%.1f 0.06 -> 0.1
+%.1f 0.25 -> 0.2
+%.1f 0.75 -> 0.8
+%.1f 1.4 -> 1.4
+%.1f 1.5 -> 1.5
+%.1f 10.0 -> 10.0
+%.1f 1000.03 -> 1000.0
+%.1f 1234.5678 -> 1234.6
+%.1f 1234.7499 -> 1234.7
+%.1f 1234.75 -> 1234.8
+
+-- precision 2
+%.2f 0.0001 -> 0.00
+%.2f 0.001 -> 0.00
+%.2f 0.004999 -> 0.00
+%.2f 0.005001 -> 0.01
+%.2f 0.01 -> 0.01
+%.2f 0.125 -> 0.12
+%.2f 0.375 -> 0.38
+%.2f 1234500 -> 1234500.00
+%.2f 1234560 -> 1234560.00
+%.2f 1234567 -> 1234567.00
+%.2f 1234567.8 -> 1234567.80
+%.2f 1234567.89 -> 1234567.89
+%.2f 1234567.891 -> 1234567.89
+%.2f 1234567.8912 -> 1234567.89
+
+-- alternate form always includes a decimal point.  This only
+-- makes a difference when the precision is 0.
+%#.0f 0 -> 0.
+%#.1f 0 -> 0.0
+%#.0f 1.5 -> 2.
+%#.0f 2.5 -> 2.
+%#.0f 10.1 -> 10.
+%#.0f 1234.56 -> 1235.
+%#.1f 1.4 -> 1.4
+%#.2f 0.375 -> 0.38
+
+-- if precision is omitted it defaults to 6
+%f 0 -> 0.000000
+%f 1230000 -> 1230000.000000
+%f 1234567 -> 1234567.000000
+%f 123.4567 -> 123.456700
+%f 1.23456789 -> 1.234568
+%f 0.00012 -> 0.000120
+%f 0.000123 -> 0.000123
+%f 0.00012345 -> 0.000123
+%f 0.000001 -> 0.000001
+%f 0.0000005001 -> 0.000001
+%f 0.0000004999 -> 0.000000
+
+-- 'e' code formatting with explicit precision (>= 0). Output should
+-- always have exactly the number of places after the point that were
+-- requested.
+
+-- zeros
+%.0e 0 -> 0e+00
+%.1e 0 -> 0.0e+00
+%.2e 0 -> 0.00e+00
+%.10e 0 -> 0.0000000000e+00
+%.50e 0 -> 0.00000000000000000000000000000000000000000000000000e+00
+
+-- precision 0.  no decimal point in the output
+%.0e 0.01 -> 1e-02
+%.0e 0.1 -> 1e-01
+%.0e 1 -> 1e+00
+%.0e 10 -> 1e+01
+%.0e 100 -> 1e+02
+%.0e 0.012 -> 1e-02
+%.0e 0.12 -> 1e-01
+%.0e 1.2 -> 1e+00
+%.0e 12 -> 1e+01
+%.0e 120 -> 1e+02
+%.0e 123.456 -> 1e+02
+%.0e 0.000123456 -> 1e-04
+%.0e 123456000 -> 1e+08
+%.0e 0.5 -> 5e-01
+%.0e 1.4 -> 1e+00
+%.0e 1.5 -> 2e+00
+%.0e 1.6 -> 2e+00
+%.0e 2.4999999 -> 2e+00
+%.0e 2.5 -> 2e+00
+%.0e 2.5000001 -> 3e+00
+%.0e 3.499999999999 -> 3e+00
+%.0e 3.5 -> 4e+00
+%.0e 4.5 -> 4e+00
+%.0e 5.5 -> 6e+00
+%.0e 6.5 -> 6e+00
+%.0e 7.5 -> 8e+00
+%.0e 8.5 -> 8e+00
+%.0e 9.4999 -> 9e+00
+%.0e 9.5 -> 1e+01
+%.0e 10.5 -> 1e+01
+%.0e 14.999 -> 1e+01
+%.0e 15 -> 2e+01
+
+-- precision 1
+%.1e 0.0001 -> 1.0e-04
+%.1e 0.001 -> 1.0e-03
+%.1e 0.01 -> 1.0e-02
+%.1e 0.1 -> 1.0e-01
+%.1e 1 -> 1.0e+00
+%.1e 10 -> 1.0e+01
+%.1e 100 -> 1.0e+02
+%.1e 120 -> 1.2e+02
+%.1e 123 -> 1.2e+02
+%.1e 123.4 -> 1.2e+02
+
+-- precision 2
+%.2e 0.00013 -> 1.30e-04
+%.2e 0.000135 -> 1.35e-04
+%.2e 0.0001357 -> 1.36e-04
+%.2e 0.0001 -> 1.00e-04
+%.2e 0.001 -> 1.00e-03
+%.2e 0.01 -> 1.00e-02
+%.2e 0.1 -> 1.00e-01
+%.2e 1 -> 1.00e+00
+%.2e 10 -> 1.00e+01
+%.2e 100 -> 1.00e+02
+%.2e 1000 -> 1.00e+03
+%.2e 1500 -> 1.50e+03
+%.2e 1590 -> 1.59e+03
+%.2e 1598 -> 1.60e+03
+%.2e 1598.7 -> 1.60e+03
+%.2e 1598.76 -> 1.60e+03
+%.2e 9999 -> 1.00e+04
+
+-- omitted precision defaults to 6
+%e 0 -> 0.000000e+00
+%e 165 -> 1.650000e+02
+%e 1234567 -> 1.234567e+06
+%e 12345678 -> 1.234568e+07
+%e 1.1 -> 1.100000e+00
+
+-- alternate form always contains a decimal point.  This only makes
+-- a difference when precision is 0.
+
+%#.0e 0.01 -> 1.e-02
+%#.0e 0.1 -> 1.e-01
+%#.0e 1 -> 1.e+00
+%#.0e 10 -> 1.e+01
+%#.0e 100 -> 1.e+02
+%#.0e 0.012 -> 1.e-02
+%#.0e 0.12 -> 1.e-01
+%#.0e 1.2 -> 1.e+00
+%#.0e 12 -> 1.e+01
+%#.0e 120 -> 1.e+02
+%#.0e 123.456 -> 1.e+02
+%#.0e 0.000123456 -> 1.e-04
+%#.0e 123456000 -> 1.e+08
+%#.0e 0.5 -> 5.e-01
+%#.0e 1.4 -> 1.e+00
+%#.0e 1.5 -> 2.e+00
+%#.0e 1.6 -> 2.e+00
+%#.0e 2.4999999 -> 2.e+00
+%#.0e 2.5 -> 2.e+00
+%#.0e 2.5000001 -> 3.e+00
+%#.0e 3.499999999999 -> 3.e+00
+%#.0e 3.5 -> 4.e+00
+%#.0e 4.5 -> 4.e+00
+%#.0e 5.5 -> 6.e+00
+%#.0e 6.5 -> 6.e+00
+%#.0e 7.5 -> 8.e+00
+%#.0e 8.5 -> 8.e+00
+%#.0e 9.4999 -> 9.e+00
+%#.0e 9.5 -> 1.e+01
+%#.0e 10.5 -> 1.e+01
+%#.0e 14.999 -> 1.e+01
+%#.0e 15 -> 2.e+01
+%#.1e 123.4 -> 1.2e+02
+%#.2e 0.0001357 -> 1.36e-04
+
+-- 'g' code formatting.
+
+-- zeros
+%.0g 0 -> 0
+%.1g 0 -> 0
+%.2g 0 -> 0
+%.3g 0 -> 0
+%.4g 0 -> 0
+%.10g 0 -> 0
+%.50g 0 -> 0
+%.100g 0 -> 0
+
+-- precision 0 doesn't make a lot of sense for the 'g' code (what does
+-- it mean to have no significant digits?); in practice, it's interpreted
+-- as identical to precision 1
+%.0g 1000 -> 1e+03
+%.0g 100 -> 1e+02
+%.0g 10 -> 1e+01
+%.0g 1 -> 1
+%.0g 0.1 -> 0.1
+%.0g 0.01 -> 0.01
+%.0g 1e-3 -> 0.001
+%.0g 1e-4 -> 0.0001
+%.0g 1e-5 -> 1e-05
+%.0g 1e-6 -> 1e-06
+%.0g 12 -> 1e+01
+%.0g 120 -> 1e+02
+%.0g 1.2 -> 1
+%.0g 0.12 -> 0.1
+%.0g 0.012 -> 0.01
+%.0g 0.0012 -> 0.001
+%.0g 0.00012 -> 0.0001
+%.0g 0.000012 -> 1e-05
+%.0g 0.0000012 -> 1e-06
+
+-- precision 1 identical to precision 0
+%.1g 1000 -> 1e+03
+%.1g 100 -> 1e+02
+%.1g 10 -> 1e+01
+%.1g 1 -> 1
+%.1g 0.1 -> 0.1
+%.1g 0.01 -> 0.01
+%.1g 1e-3 -> 0.001
+%.1g 1e-4 -> 0.0001
+%.1g 1e-5 -> 1e-05
+%.1g 1e-6 -> 1e-06
+%.1g 12 -> 1e+01
+%.1g 120 -> 1e+02
+%.1g 1.2 -> 1
+%.1g 0.12 -> 0.1
+%.1g 0.012 -> 0.01
+%.1g 0.0012 -> 0.001
+%.1g 0.00012 -> 0.0001
+%.1g 0.000012 -> 1e-05
+%.1g 0.0000012 -> 1e-06
+
+-- precision 2
+%.2g 1000 -> 1e+03
+%.2g 100 -> 1e+02
+%.2g 10 -> 10
+%.2g 1 -> 1
+%.2g 0.1 -> 0.1
+%.2g 0.01 -> 0.01
+%.2g 0.001 -> 0.001
+%.2g 1e-4 -> 0.0001
+%.2g 1e-5 -> 1e-05
+%.2g 1e-6 -> 1e-06
+%.2g 1234 -> 1.2e+03
+%.2g 123 -> 1.2e+02
+%.2g 12.3 -> 12
+%.2g 1.23 -> 1.2
+%.2g 0.123 -> 0.12
+%.2g 0.0123 -> 0.012
+%.2g 0.00123 -> 0.0012
+%.2g 0.000123 -> 0.00012
+%.2g 0.0000123 -> 1.2e-05
+
+-- bad cases from http://bugs.python.org/issue9980
+%.12g 38210.0 -> 38210
+%.12g 37210.0 -> 37210
+%.12g 36210.0 -> 36210
+
+-- alternate g formatting:  always include decimal point and
+-- exactly <precision> significant digits.
+%#.0g 0 -> 0.
+%#.1g 0 -> 0.
+%#.2g 0 -> 0.0
+%#.3g 0 -> 0.00
+%#.4g 0 -> 0.000
+
+%#.0g 0.2 -> 0.2
+%#.1g 0.2 -> 0.2
+%#.2g 0.2 -> 0.20
+%#.3g 0.2 -> 0.200
+%#.4g 0.2 -> 0.2000
+%#.10g 0.2 -> 0.2000000000
+
+%#.0g 2 -> 2.
+%#.1g 2 -> 2.
+%#.2g 2 -> 2.0
+%#.3g 2 -> 2.00
+%#.4g 2 -> 2.000
+
+%#.0g 20 -> 2.e+01
+%#.1g 20 -> 2.e+01
+%#.2g 20 -> 20.
+%#.3g 20 -> 20.0
+%#.4g 20 -> 20.00
+
+%#.0g 234.56 -> 2.e+02
+%#.1g 234.56 -> 2.e+02
+%#.2g 234.56 -> 2.3e+02
+%#.3g 234.56 -> 235.
+%#.4g 234.56 -> 234.6
+%#.5g 234.56 -> 234.56
+%#.6g 234.56 -> 234.560
+
+-- repr formatting.  Result always includes decimal point and at
+-- least one digit after the point, or an exponent.
+%r 0 -> 0.0
+%r 1 -> 1.0
+
+%r 0.01 -> 0.01
+%r 0.02 -> 0.02
+%r 0.03 -> 0.03
+%r 0.04 -> 0.04
+%r 0.05 -> 0.05
+
+-- values >= 1e16 get an exponent
+%r 10 -> 10.0
+%r 100 -> 100.0
+%r 1e15 -> 1000000000000000.0
+%r 9.999e15 -> 9999000000000000.0
+%r 9999999999999998 -> 9999999999999998.0
+%r 9999999999999999 -> 1e+16
+%r 1e16 -> 1e+16
+%r 1e17 -> 1e+17
+
+-- as do values < 1e-4
+%r 1e-3 -> 0.001
+%r 1.001e-4 -> 0.0001001
+%r 1.0000000000000001e-4 -> 0.0001
+%r 1.000000000000001e-4 -> 0.0001000000000000001
+%r 1.00000000001e-4 -> 0.000100000000001
+%r 1.0000000001e-4 -> 0.00010000000001
+%r 1e-4 -> 0.0001
+%r 0.99999999999999999e-4 -> 0.0001
+%r 0.9999999999999999e-4 -> 9.999999999999999e-05
+%r 0.999999999999e-4 -> 9.99999999999e-05
+%r 0.999e-4 -> 9.99e-05
+%r 1e-5 -> 1e-05
diff --git a/Lib/test/mathdata/ieee754.txt b/Lib/test/mathdata/ieee754.txt
index 3e986cdb10..9be667826a 100644
--- a/Lib/test/mathdata/ieee754.txt
+++ b/Lib/test/mathdata/ieee754.txt
@@ -116,7 +116,7 @@ inf
 >>> 0 ** -1
 Traceback (most recent call last):
 ...
-ZeroDivisionError: 0.0 cannot be raised to a negative power
+ZeroDivisionError: zero to a negative power
 >>> pow(0, NAN)
 nan
 
@@ -127,31 +127,31 @@ Trigonometric Functions
 >>> sin(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> sin(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> sin(NAN)
 nan
 >>> cos(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> cos(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> cos(NAN)
 nan
 >>> tan(INF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got inf
 >>> tan(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a finite input, got -inf
 >>> tan(NAN)
 nan
 
@@ -169,11 +169,11 @@ True
 >>> asin(INF), asin(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a number in range from -1 up to 1, got inf
 >>> acos(INF), acos(NINF)
 Traceback (most recent call last):
 ...
-ValueError: math domain error
+ValueError: expected a number in range from -1 up to 1, got inf
 >>> equal(atan(INF), PI/2), equal(atan(NINF), -PI/2)
 (True, True)
 
diff --git a/Lib/test/mp_fork_bomb.py b/Lib/test/mp_fork_bomb.py
new file mode 100644
index 0000000000..017e010ba0
--- /dev/null
+++ b/Lib/test/mp_fork_bomb.py
@@ -0,0 +1,18 @@
+import multiprocessing, sys
+
+def foo():
+    print("123")
+
+# Because "if __name__ == '__main__'" is missing this will not work
+# correctly on Windows.  However, we should get a RuntimeError rather
+# than the Windows equivalent of a fork bomb.
+
+if len(sys.argv) > 1:
+    multiprocessing.set_start_method(sys.argv[1])
+else:
+    multiprocessing.set_start_method('spawn')
+
+p = multiprocessing.Process(target=foo)
+p.start()
+p.join()
+sys.exit(p.exitcode)
diff --git a/Lib/test/mp_preload.py b/Lib/test/mp_preload.py
new file mode 100644
index 0000000000..5314e8f0b2
--- /dev/null
+++ b/Lib/test/mp_preload.py
@@ -0,0 +1,18 @@
+import multiprocessing
+
+multiprocessing.Lock()
+
+
+def f():
+    print("ok")
+
+
+if __name__ == "__main__":
+    ctx = multiprocessing.get_context("forkserver")
+    modname = "test.mp_preload"
+    # Make sure it's importable
+    __import__(modname)
+    ctx.set_forkserver_preload([modname])
+    proc = ctx.Process(target=f)
+    proc.start()
+    proc.join()
diff --git a/Lib/test/mp_preload_flush.py b/Lib/test/mp_preload_flush.py
new file mode 100644
index 0000000000..c195a9ef6b
--- /dev/null
+++ b/Lib/test/mp_preload_flush.py
@@ -0,0 +1,11 @@
+import multiprocessing
+import sys
+
+print(__name__, end='', file=sys.stderr)
+print(__name__, end='', file=sys.stdout)
+if __name__ == '__main__':
+    multiprocessing.set_start_method('forkserver')
+    for _ in range(2):
+        p = multiprocessing.Process()
+        p.start()
+        p.join()
diff --git a/Lib/test/mp_preload_main.py b/Lib/test/mp_preload_main.py
new file mode 100644
index 0000000000..acb342822e
--- /dev/null
+++ b/Lib/test/mp_preload_main.py
@@ -0,0 +1,14 @@
+import multiprocessing
+
+print(f"{__name__}")
+
+def f():
+    print("f")
+
+if __name__ == "__main__":
+    ctx = multiprocessing.get_context("forkserver")
+    ctx.set_forkserver_preload(['__main__'])
+    for _ in range(2):
+        p = ctx.Process(target=f)
+        p.start()
+        p.join()
diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py
index 177e2ed2ca..c0d4c8f43b 100644
--- a/Lib/test/pickletester.py
+++ b/Lib/test/pickletester.py
@@ -26,7 +26,7 @@
 from test import support
 from test.support import os_helper
 from test.support import (
-    TestFailed, run_with_locale, no_tracing,
+    TestFailed, run_with_locales, no_tracing,
     _2G, _4G, bigmemtest
     )
 from test.support.import_helper import forget
@@ -144,6 +144,14 @@ class E(C):
     def __getinitargs__(self):
         return ()
 
+import __main__
+__main__.C = C
+C.__module__ = "__main__"
+__main__.D = D
+D.__module__ = "__main__"
+__main__.E = E
+E.__module__ = "__main__"
+
 # Simple mutable object.
 class Object:
     pass
@@ -157,14 +165,6 @@ def __reduce__(self):
         # Shouldn't support the recursion itself
         return K, (self.value,)
 
-import __main__
-__main__.C = C
-C.__module__ = "__main__"
-__main__.D = D
-D.__module__ = "__main__"
-__main__.E = E
-E.__module__ = "__main__"
-
 class myint(int):
     def __init__(self, x):
         self.str = str(x)
@@ -1080,6 +1080,11 @@ def test_large_32b_binunicode8(self):
         self.check_unpickling_error((pickle.UnpicklingError, OverflowError),
                                     dumped)
 
+    def test_large_binstring(self):
+        errmsg = 'BINSTRING pickle has negative byte count'
+        with self.assertRaisesRegex(pickle.UnpicklingError, errmsg):
+            self.loads(b'T\0\0\0\x80')
+
     def test_get(self):
         pickled = b'((lp100000\ng100000\nt.'
         unpickled = self.loads(pickled)
@@ -1179,6 +1184,153 @@ def test_compat_unpickle(self):
             self.assertIs(type(unpickled), collections.UserDict)
             self.assertEqual(unpickled, collections.UserDict({1: 2}))
 
+    def test_load_global(self):
+        self.assertIs(self.loads(b'cbuiltins\nstr\n.'), str)
+        self.assertIs(self.loads(b'cmath\nlog\n.'), math.log)
+        self.assertIs(self.loads(b'cos.path\njoin\n.'), os.path.join)
+        self.assertIs(self.loads(b'\x80\x04cbuiltins\nstr.upper\n.'), str.upper)
+        with support.swap_item(sys.modules, 'mödule', types.SimpleNamespace(glöbal=42)):
+            self.assertEqual(self.loads(b'\x80\x04cm\xc3\xb6dule\ngl\xc3\xb6bal\n.'), 42)
+
+        self.assertRaises(UnicodeDecodeError, self.loads, b'c\xff\nlog\n.')
+        self.assertRaises(UnicodeDecodeError, self.loads, b'cmath\n\xff\n.')
+        self.assertRaises(self.truncated_errors, self.loads, b'c\nlog\n.')
+        self.assertRaises(self.truncated_errors, self.loads, b'cmath\n\n.')
+        self.assertRaises(self.truncated_errors, self.loads, b'\x80\x04cmath\n\n.')
+
+    def test_load_stack_global(self):
+        self.assertIs(self.loads(b'\x8c\x08builtins\x8c\x03str\x93.'), str)
+        self.assertIs(self.loads(b'\x8c\x04math\x8c\x03log\x93.'), math.log)
+        self.assertIs(self.loads(b'\x8c\x07os.path\x8c\x04join\x93.'),
+                      os.path.join)
+        self.assertIs(self.loads(b'\x80\x04\x8c\x08builtins\x8c\x09str.upper\x93.'),
+                      str.upper)
+        with support.swap_item(sys.modules, 'mödule', types.SimpleNamespace(glöbal=42)):
+            self.assertEqual(self.loads(b'\x80\x04\x8c\x07m\xc3\xb6dule\x8c\x07gl\xc3\xb6bal\x93.'), 42)
+
+        self.assertRaises(UnicodeDecodeError, self.loads, b'\x8c\x01\xff\x8c\x03log\x93.')
+        self.assertRaises(UnicodeDecodeError, self.loads, b'\x8c\x04math\x8c\x01\xff\x93.')
+        self.assertRaises(ValueError, self.loads, b'\x8c\x00\x8c\x03log\x93.')
+        self.assertRaises(AttributeError, self.loads, b'\x8c\x04math\x8c\x00\x93.')
+        self.assertRaises(AttributeError, self.loads, b'\x80\x04\x8c\x04math\x8c\x00\x93.')
+
+        self.assertRaises(pickle.UnpicklingError, self.loads, b'N\x8c\x03log\x93.')
+        self.assertRaises(pickle.UnpicklingError, self.loads, b'\x8c\x04mathN\x93.')
+        self.assertRaises(pickle.UnpicklingError, self.loads, b'\x80\x04\x8c\x04mathN\x93.')
+
+    def test_find_class(self):
+        unpickler = self.unpickler(io.BytesIO())
+        unpickler_nofix = self.unpickler(io.BytesIO(), fix_imports=False)
+        unpickler4 = self.unpickler(io.BytesIO(b'\x80\x04N.'))
+        unpickler4.load()
+
+        self.assertIs(unpickler.find_class('__builtin__', 'str'), str)
+        self.assertRaises(ModuleNotFoundError,
+                          unpickler_nofix.find_class, '__builtin__', 'str')
+        self.assertIs(unpickler.find_class('builtins', 'str'), str)
+        self.assertIs(unpickler_nofix.find_class('builtins', 'str'), str)
+        self.assertIs(unpickler.find_class('math', 'log'), math.log)
+        self.assertIs(unpickler.find_class('os.path', 'join'), os.path.join)
+        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):
+            unpickler.find_class('builtins', 'str.upper')
+
+        with self.assertRaises(AttributeError):
+            unpickler.find_class('math', 'spam')
+        with self.assertRaises(AttributeError):
+            unpickler4.find_class('math', 'spam')
+        with self.assertRaises(AttributeError):
+            unpickler.find_class('math', 'log.spam')
+        with self.assertRaises(AttributeError):
+            unpickler4.find_class('math', 'log.spam')
+        with self.assertRaises(AttributeError):
+            unpickler.find_class('math', 'log.<locals>.spam')
+        with self.assertRaises(AttributeError):
+            unpickler4.find_class('math', 'log.<locals>.spam')
+        with self.assertRaises(AttributeError):
+            unpickler.find_class('math', '')
+        with self.assertRaises(AttributeError):
+            unpickler4.find_class('math', '')
+        self.assertRaises(ModuleNotFoundError, unpickler.find_class, 'spam', 'log')
+        self.assertRaises(ValueError, unpickler.find_class, '', 'log')
+
+        self.assertRaises(TypeError, unpickler.find_class, None, 'log')
+        self.assertRaises(TypeError, unpickler.find_class, 'math', None)
+        self.assertRaises((TypeError, AttributeError), unpickler4.find_class, 'math', None)
+
+    def test_custom_find_class(self):
+        def loads(data):
+            class Unpickler(self.unpickler):
+                def find_class(self, module_name, global_name):
+                    return (module_name, global_name)
+            return Unpickler(io.BytesIO(data)).load()
+
+        self.assertEqual(loads(b'cmath\nlog\n.'), ('math', 'log'))
+        self.assertEqual(loads(b'\x8c\x04math\x8c\x03log\x93.'), ('math', 'log'))
+
+        def loads(data):
+            class Unpickler(self.unpickler):
+                @staticmethod
+                def find_class(module_name, global_name):
+                    return (module_name, global_name)
+            return Unpickler(io.BytesIO(data)).load()
+
+        self.assertEqual(loads(b'cmath\nlog\n.'), ('math', 'log'))
+        self.assertEqual(loads(b'\x8c\x04math\x8c\x03log\x93.'), ('math', 'log'))
+
+        def loads(data):
+            class Unpickler(self.unpickler):
+                @classmethod
+                def find_class(cls, module_name, global_name):
+                    return (module_name, global_name)
+            return Unpickler(io.BytesIO(data)).load()
+
+        self.assertEqual(loads(b'cmath\nlog\n.'), ('math', 'log'))
+        self.assertEqual(loads(b'\x8c\x04math\x8c\x03log\x93.'), ('math', 'log'))
+
+        def loads(data):
+            class Unpickler(self.unpickler):
+                pass
+            def find_class(module_name, global_name):
+                return (module_name, global_name)
+            unpickler = Unpickler(io.BytesIO(data))
+            unpickler.find_class = find_class
+            return unpickler.load()
+
+        self.assertEqual(loads(b'cmath\nlog\n.'), ('math', 'log'))
+        self.assertEqual(loads(b'\x8c\x04math\x8c\x03log\x93.'), ('math', 'log'))
+
+    def test_bad_ext_code(self):
+        # unregistered extension code
+        self.check_unpickling_error(ValueError, b'\x82\x01.')
+        self.check_unpickling_error(ValueError, b'\x82\xff.')
+        self.check_unpickling_error(ValueError, b'\x83\x01\x00.')
+        self.check_unpickling_error(ValueError, b'\x83\xff\xff.')
+        self.check_unpickling_error(ValueError, b'\x84\x01\x00\x00\x00.')
+        self.check_unpickling_error(ValueError, b'\x84\xff\xff\xff\x7f.')
+        # EXT specifies code <= 0
+        self.check_unpickling_error(pickle.UnpicklingError, b'\x82\x00.')
+        self.check_unpickling_error(pickle.UnpicklingError, b'\x83\x00\x00.')
+        self.check_unpickling_error(pickle.UnpicklingError, b'\x84\x00\x00\x00\x00.')
+        self.check_unpickling_error(pickle.UnpicklingError, b'\x84\x00\x00\x00\x80.')
+        self.check_unpickling_error(pickle.UnpicklingError, b'\x84\xff\xff\xff\xff.')
+
+    @support.cpython_only
+    def test_bad_ext_inverted_registry(self):
+        code = 1
+        def check(key, exc):
+            with support.swap_item(copyreg._inverted_registry, code, key):
+                with self.assertRaises(exc):
+                    self.loads(b'\x82\x01.')
+        check(None, ValueError)
+        check((), ValueError)
+        check((__name__,), (TypeError, ValueError))
+        check((__name__, "MyList", "x"), (TypeError, ValueError))
+        check((__name__, None), (TypeError, ValueError))
+        check((None, "MyList"), (TypeError, ValueError))
+
     def test_bad_reduce(self):
         self.assertEqual(self.loads(b'cbuiltins\nint\n)R.'), 0)
         self.check_unpickling_error(TypeError, b'N)R.')
@@ -1197,6 +1349,41 @@ def test_bad_newobj_ex(self):
         self.check_unpickling_error(error, b'cbuiltins\nint\nN}\x92.')
         self.check_unpickling_error(error, b'cbuiltins\nint\n)N\x92.')
 
+    def test_bad_state(self):
+        c = C()
+        c.x = None
+        base = b'c__main__\nC\n)\x81'
+        self.assertEqual(self.loads(base + b'}X\x01\x00\x00\x00xNsb.'), c)
+        self.assertEqual(self.loads(base + b'N}X\x01\x00\x00\x00xNs\x86b.'), c)
+        # non-hashable dict key
+        self.check_unpickling_error(TypeError, base + b'}]Nsb.')
+        # state = list
+        error = (pickle.UnpicklingError, AttributeError)
+        self.check_unpickling_error(error, base + b'](}}eb.')
+        # state = 1-tuple
+        self.check_unpickling_error(error, base + b'}\x85b.')
+        # state = 3-tuple
+        self.check_unpickling_error(error, base + b'}}}\x87b.')
+        # non-hashable slot name
+        self.check_unpickling_error(TypeError, base + b'}}]Ns\x86b.')
+        # non-string slot name
+        self.check_unpickling_error(TypeError, base + b'}}NNs\x86b.')
+        # dict = True
+        self.check_unpickling_error(error, base + b'\x88}\x86b.')
+        # slots dict = True
+        self.check_unpickling_error(error, base + b'}\x88\x86b.')
+
+        class BadKey1:
+            count = 1
+            def __hash__(self):
+                if not self.count:
+                    raise CustomError
+                self.count -= 1
+                return 42
+        __main__.BadKey1 = BadKey1
+        # bad hashable dict key
+        self.check_unpickling_error(CustomError, base + b'}c__main__\nBadKey1\n)\x81Nsb.')
+
     def test_bad_stack(self):
         badpickles = [
             b'.',                       # STOP
@@ -1443,6 +1630,502 @@ def t():
             [ToBeUnpickled] * 2)
 
 
+class AbstractPicklingErrorTests:
+    # Subclass must define self.dumps, self.pickler.
+
+    def test_bad_reduce_result(self):
+        obj = REX([print, ()])
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj = REX((print,))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj = REX((print, (), None, None, None, None, None))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    def test_bad_reconstructor(self):
+        obj = REX((42, ()))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    def test_unpickleable_reconstructor(self):
+        obj = REX((UnpickleableCallable(), ()))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+
+    def test_bad_reconstructor_args(self):
+        obj = REX((print, []))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_bad_newobj_args(self):
+        obj = REX((copyreg.__newobj__, ()))
+        for proto in protocols[2:]:
+            with self.subTest(proto=proto):
+                with self.assertRaises((IndexError, pickle.PicklingError)) as cm:
+                    self.dumps(obj, proto)
+
+        obj = REX((copyreg.__newobj__, [REX]))
+        for proto in protocols[2:]:
+            with self.subTest(proto=proto):
+                with self.assertRaises((IndexError, pickle.PicklingError)):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    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)):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    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)):
+                    self.dumps(obj, proto)
+
+        obj = REX((copyreg.__newobj_ex__, 42))
+        for proto in protocols[2:]:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        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)
+
+        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)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_wrong_newobj_ex_class(self):
+        if self.pickler is not pickle._Pickler:
+            self.skipTest('only verified in the Python implementation')
+        obj = REX((copyreg.__newobj_ex__, (str, (), {})))
+        for proto in protocols[2:]:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    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)):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_unpickleable_state(self):
+        obj = REX_state(UNPICKLEABLE)
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+
+    def test_bad_state_setter(self):
+        if self.pickler is pickle._Pickler:
+            self.skipTest('only verified in the C implementation')
+        obj = REX((print, (), 'state', None, None, 42))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_bad_object_list_items(self):
+        # Issue4176: crash when 4th and 5th items of __reduce__()
+        # are not iterators
+        obj = REX((list, (), None, 42))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises((TypeError, pickle.PicklingError)):
+                    self.dumps(obj, proto)
+
+        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)):
+                        self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_bad_object_dict_items(self):
+        # Issue4176: crash when 4th and 5th items of __reduce__()
+        # are not iterators
+        obj = REX((dict, (), None, None, 42))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises((TypeError, pickle.PicklingError)):
+                    self.dumps(obj, proto)
+
+        for proto in protocols:
+            obj = REX((dict, (), None, None, iter([('a',)])))
+            with self.subTest(proto=proto):
+                with self.assertRaises((ValueError, TypeError)):
+                    self.dumps(obj, proto)
+
+        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)):
+                        self.dumps(obj, proto)
+
+    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):
+                    self.dumps(obj, proto)
+
+    def test_unpickleable_list_items(self):
+        obj = [1, [2, 3, UNPICKLEABLE]]
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+        for n in [0, 1, 1000, 1005]:
+            obj = [*range(n), UNPICKLEABLE]
+            for proto in protocols:
+                with self.subTest(proto=proto):
+                    with self.assertRaises(CustomError):
+                        self.dumps(obj, proto)
+
+    def test_unpickleable_tuple_items(self):
+        obj = (1, (2, 3, UNPICKLEABLE))
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+        obj = (*range(10), UNPICKLEABLE)
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+
+    def test_unpickleable_dict_items(self):
+        obj = {'a': {'b': UNPICKLEABLE}}
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+        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):
+                        self.dumps(obj, proto)
+
+    def test_unpickleable_set_items(self):
+        obj = {UNPICKLEABLE}
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+
+    def test_unpickleable_frozenset_items(self):
+        obj = frozenset({frozenset({UNPICKLEABLE})})
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(CustomError):
+                    self.dumps(obj, proto)
+
+    def test_global_lookup_error(self):
+        # Global name does not exist
+        obj = REX('spam')
+        obj.__module__ = __name__
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj.__module__ = 'nonexisting'
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj.__module__ = ''
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises((ValueError, pickle.PicklingError)):
+                    self.dumps(obj, proto)
+
+        obj.__module__ = None
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    def test_nonencodable_global_name_error(self):
+        for proto in protocols[:4]:
+            with self.subTest(proto=proto):
+                name = 'nonascii\xff' if proto < 3 else 'nonencodable\udbff'
+                obj = REX(name)
+                obj.__module__ = __name__
+                with support.swap_item(globals(), name, obj):
+                    with self.assertRaises((UnicodeEncodeError, pickle.PicklingError)):
+                        self.dumps(obj, proto)
+
+    def test_nonencodable_module_name_error(self):
+        for proto in protocols[:4]:
+            with self.subTest(proto=proto):
+                name = 'nonascii\xff' if proto < 3 else 'nonencodable\udbff'
+                obj = REX('test')
+                obj.__module__ = name
+                mod = types.SimpleNamespace(test=obj)
+                with support.swap_item(sys.modules, name, mod):
+                    with self.assertRaises((UnicodeEncodeError, pickle.PicklingError)):
+                        self.dumps(obj, proto)
+
+    def test_nested_lookup_error(self):
+        # Nested name does not exist
+        global TestGlobal
+        class TestGlobal:
+            class A:
+                pass
+        obj = REX('TestGlobal.A.B.C')
+        obj.__module__ = __name__
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj.__module__ = None
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    def test_wrong_object_lookup_error(self):
+        # Name is bound to different object
+        global TestGlobal
+        class TestGlobal:
+            pass
+        obj = REX('TestGlobal')
+        obj.__module__ = __name__
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+        obj.__module__ = None
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PicklingError):
+                    self.dumps(obj, proto)
+
+    def test_local_lookup_error(self):
+        # Test that whichmodule() errors out cleanly when looking up
+        # an assumed globally-reachable object fails.
+        def f():
+            pass
+        # Since the function is local, lookup will fail
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises((AttributeError, pickle.PicklingError)):
+                    self.dumps(f, proto)
+        # 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)):
+                    self.dumps(f, proto)
+        # Yet a different path.
+        f.__name__ = f.__qualname__
+        for proto in protocols:
+            with self.subTest(proto=proto):
+                with self.assertRaises((AttributeError, pickle.PicklingError)):
+                    self.dumps(f, proto)
+
+    def test_reduce_ex_None(self):
+        c = REX_None()
+        with self.assertRaises(TypeError):
+            self.dumps(c)
+
+    def test_reduce_None(self):
+        c = R_None()
+        with self.assertRaises(TypeError):
+            self.dumps(c)
+
+    @no_tracing
+    def test_bad_getattr(self):
+        # Issue #3514: crash when there is an infinite loop in __getattr__
+        x = BadGetattr()
+        for proto in range(2):
+            with support.infinite_recursion(25):
+                self.assertRaises(RuntimeError, self.dumps, x, proto)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            s = self.dumps(x, proto)
+
+    def test_picklebuffer_error(self):
+        # PickleBuffer forbidden with protocol < 5
+        pb = pickle.PickleBuffer(b"foobar")
+        for proto in range(0, 5):
+            with self.subTest(proto=proto):
+                with self.assertRaises(pickle.PickleError) as cm:
+                    self.dumps(pb, proto)
+                self.assertEqual(str(cm.exception),
+                    'PickleBuffer can only be pickled with protocol >= 5')
+
+    def test_non_continuous_buffer(self):
+        for proto in protocols[5:]:
+            with self.subTest(proto=proto):
+                pb = pickle.PickleBuffer(memoryview(b"foobar")[::2])
+                with self.assertRaises((pickle.PicklingError, BufferError)):
+                    self.dumps(pb, proto)
+
+    def test_buffer_callback_error(self):
+        def buffer_callback(buffers):
+            raise CustomError
+        pb = pickle.PickleBuffer(b"foobar")
+        with self.assertRaises(CustomError):
+            self.dumps(pb, 5, buffer_callback=buffer_callback)
+
+    def test_evil_pickler_mutating_collection(self):
+        # https://github.com/python/cpython/issues/92930
+        global Clearer
+        class Clearer:
+            pass
+
+        def check(collection):
+            class EvilPickler(self.pickler):
+                def persistent_id(self, obj):
+                    if isinstance(obj, Clearer):
+                        collection.clear()
+                    return None
+            pickler = EvilPickler(io.BytesIO(), proto)
+            try:
+                pickler.dump(collection)
+            except RuntimeError as e:
+                expected = "changed size during iteration"
+                self.assertIn(expected, str(e))
+
+        for proto in protocols:
+            check([Clearer()])
+            check([Clearer(), Clearer()])
+            check({Clearer()})
+            check({Clearer(), Clearer()})
+            check({Clearer(): 1})
+            check({Clearer(): 1, Clearer(): 2})
+            check({1: Clearer(), 2: Clearer()})
+
+    @support.cpython_only
+    def test_bad_ext_code(self):
+        # This should never happen in normal circumstances, because the type
+        # and the value of the extension code is checked in copyreg.add_extension().
+        key = (__name__, 'MyList')
+        def check(code, exc):
+            assert key not in copyreg._extension_registry
+            assert code not in copyreg._inverted_registry
+            with (support.swap_item(copyreg._extension_registry, key, code),
+                  support.swap_item(copyreg._inverted_registry, code, key)):
+                for proto in protocols[2:]:
+                    with self.assertRaises(exc):
+                        self.dumps(MyList, proto)
+
+        check(object(), TypeError)
+        check(None, TypeError)
+        check(-1, (RuntimeError, struct.error))
+        check(0, RuntimeError)
+        check(2**31, (RuntimeError, OverflowError, struct.error))
+        check(2**1000, (OverflowError, struct.error))
+        check(-2**1000, (OverflowError, struct.error))
+
 
 class AbstractPickleTests:
     # Subclass must define self.dumps, self.loads.
@@ -1845,6 +2528,25 @@ def test_bytes(self):
                 p = self.dumps(s, proto)
                 self.assert_is_copy(s, self.loads(p))
 
+    def test_bytes_memoization(self):
+        for proto in protocols:
+            for array_type in [bytes, ZeroCopyBytes]:
+                for s in b'', b'xyz', b'xyz'*100:
+                    with self.subTest(proto=proto, array_type=array_type, s=s, independent=False):
+                        b = array_type(s)
+                        p = self.dumps((b, b), proto)
+                        x, y = self.loads(p)
+                        self.assertIs(x, y)
+                        self.assert_is_copy((b, b), (x, y))
+
+                    with self.subTest(proto=proto, array_type=array_type, s=s, independent=True):
+                        b1, b2 = array_type(s), array_type(s)
+                        p = self.dumps((b1, b2), proto)
+                        # Note that (b1, b2) = self.loads(p) might have identical
+                        # components, i.e., b1 is b2, but this is not always the
+                        # case if the content is large (equality still holds).
+                        self.assert_is_copy((b1, b2), self.loads(p))
+
     def test_bytearray(self):
         for proto in protocols:
             for s in b'', b'xyz', b'xyz'*100:
@@ -1864,13 +2566,31 @@ def test_bytearray(self):
                     self.assertNotIn(b'bytearray', p)
                     self.assertTrue(opcode_in_pickle(pickle.BYTEARRAY8, p))
 
-    def test_bytearray_memoization_bug(self):
+    def test_bytearray_memoization(self):
         for proto in protocols:
-            for s in b'', b'xyz', b'xyz'*100:
-                b = bytearray(s)
-                p = self.dumps((b, b), proto)
-                b1, b2 = self.loads(p)
-                self.assertIs(b1, b2)
+            for array_type in [bytearray, ZeroCopyBytearray]:
+                for s in b'', b'xyz', b'xyz'*100:
+                    with self.subTest(proto=proto, array_type=array_type, s=s, independent=False):
+                        b = array_type(s)
+                        p = self.dumps((b, b), proto)
+                        b1, b2 = self.loads(p)
+                        self.assertIs(b1, b2)
+
+                    with self.subTest(proto=proto, array_type=array_type, s=s, independent=True):
+                        b1a, b2a = array_type(s), array_type(s)
+                        # Unlike bytes, equal but independent bytearray objects are
+                        # never identical.
+                        self.assertIsNot(b1a, b2a)
+
+                        p = self.dumps((b1a, b2a), proto)
+                        b1b, b2b = self.loads(p)
+                        self.assertIsNot(b1b, b2b)
+
+                        self.assertIsNot(b1a, b1b)
+                        self.assert_is_copy(b1a, b1b)
+
+                        self.assertIsNot(b2a, b2b)
+                        self.assert_is_copy(b2a, b2b)
 
     def test_ints(self):
         for proto in protocols:
@@ -1915,7 +2635,7 @@ def test_float(self):
                 got = self.loads(pickle)
                 self.assert_is_copy(value, got)
 
-    @run_with_locale('LC_ALL', 'de_DE', 'fr_FR')
+    @run_with_locales('LC_ALL', 'de_DE', 'fr_FR', '')
     def test_float_format(self):
         # make sure that floats are formatted locale independent with proto 0
         self.assertEqual(self.dumps(1.2, 0)[0:3], b'F1.')
@@ -2010,8 +2730,6 @@ def test_builtin_exceptions(self):
                     else:
                         self.assertIs(u, t)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_builtin_functions(self):
         for t in builtins.__dict__.values():
             if isinstance(t, types.BuiltinFunctionType):
@@ -2418,40 +3136,11 @@ def test_reduce_calls_base(self):
             y = self.loads(s)
             self.assertEqual(y._reduce_called, 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @no_tracing
-    def test_bad_getattr(self):
-        # Issue #3514: crash when there is an infinite loop in __getattr__
-        x = BadGetattr()
-        for proto in range(2):
-            with support.infinite_recursion():
-                self.assertRaises(RuntimeError, self.dumps, x, proto)
-        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
-            s = self.dumps(x, proto)
-
-    def test_reduce_bad_iterator(self):
-        # Issue4176: crash when 4th and 5th items of __reduce__()
-        # are not iterators
-        class C(object):
-            def __reduce__(self):
-                # 4th item is not an iterator
-                return list, (), None, [], None
-        class D(object):
-            def __reduce__(self):
-                # 5th item is not an iterator
-                return dict, (), None, None, []
-
-        # Python implementation is less strict and also accepts iterables.
-        for proto in protocols:
-            try:
-                self.dumps(C(), proto)
-            except pickle.PicklingError:
-                pass
-            try:
-                self.dumps(D(), proto)
-            except pickle.PicklingError:
-                pass
+    def test_pickle_setstate_None(self):
+        c = C_None_setstate()
+        p = self.dumps(c)
+        with self.assertRaises(TypeError):
+            self.loads(p)
 
     def test_many_puts_and_gets(self):
         # Test that internal data structures correctly deal with lots of
@@ -2769,6 +3458,18 @@ class Recursive:
                 self.assertIs(unpickled, Recursive)
         del Recursive.mod # break reference loop
 
+    def test_recursive_nested_names2(self):
+        global Recursive
+        class Recursive:
+            pass
+        Recursive.ref = Recursive
+        Recursive.__qualname__ = 'Recursive.ref'
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                unpickled = self.loads(self.dumps(Recursive, proto))
+                self.assertIs(unpickled, Recursive)
+        del Recursive.ref # break reference loop
+
     def test_py_methods(self):
         global PyMethodsTest
         class PyMethodsTest:
@@ -2818,6 +3519,15 @@ def pie(self):
                     unpickled = self.loads(self.dumps(method, proto))
                     self.assertEqual(method(obj), unpickled(obj))
 
+        descriptors = (
+            PyMethodsTest.__dict__['cheese'],  # static method descriptor
+            PyMethodsTest.__dict__['wine'],  # class method descriptor
+        )
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            for descr in descriptors:
+                with self.subTest(proto=proto, descr=descr):
+                    self.assertRaises(TypeError, self.dumps, descr, proto)
+
     def test_c_methods(self):
         global Subclass
         class Subclass(tuple):
@@ -2853,6 +3563,15 @@ class Nested(str):
                     unpickled = self.loads(self.dumps(method, proto))
                     self.assertEqual(method(*args), unpickled(*args))
 
+        descriptors = (
+            bytearray.__dict__['maketrans'],  # built-in static method descriptor
+            dict.__dict__['fromkeys'],  # built-in class method descriptor
+        )
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            for descr in descriptors:
+                with self.subTest(proto=proto, descr=descr):
+                    self.assertRaises(TypeError, self.dumps, descr, proto)
+
     def test_compat_pickle(self):
         tests = [
             (range(1, 7), '__builtin__', 'xrange'),
@@ -2871,27 +3590,6 @@ def test_compat_pickle(self):
                     self.assertIn(('c%s\n%s' % (mod, name)).encode(), pickled)
                     self.assertIs(type(self.loads(pickled)), type(val))
 
-    def test_local_lookup_error(self):
-        # Test that whichmodule() errors out cleanly when looking up
-        # an assumed globally-reachable object fails.
-        def f():
-            pass
-        # Since the function is local, lookup will fail
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            with self.assertRaises((AttributeError, pickle.PicklingError)):
-                pickletools.dis(self.dumps(f, proto))
-        # Same without a __module__ attribute (exercises a different path
-        # in _pickle.c).
-        del f.__module__
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            with self.assertRaises((AttributeError, pickle.PicklingError)):
-                pickletools.dis(self.dumps(f, proto))
-        # Yet a different path.
-        f.__name__ = f.__qualname__
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            with self.assertRaises((AttributeError, pickle.PicklingError)):
-                pickletools.dis(self.dumps(f, proto))
-
     #
     # PEP 574 tests below
     #
@@ -3002,20 +3700,6 @@ def test_oob_buffers_writable_to_readonly(self):
             self.assertIs(type(new), type(obj))
             self.assertEqual(new, obj)
 
-    def test_picklebuffer_error(self):
-        # PickleBuffer forbidden with protocol < 5
-        pb = pickle.PickleBuffer(b"foobar")
-        for proto in range(0, 5):
-            with self.assertRaises(pickle.PickleError):
-                self.dumps(pb, proto)
-
-    def test_buffer_callback_error(self):
-        def buffer_callback(buffers):
-            1/0
-        pb = pickle.PickleBuffer(b"foobar")
-        with self.assertRaises(ZeroDivisionError):
-            self.dumps(pb, 5, buffer_callback=buffer_callback)
-
     def test_buffers_error(self):
         pb = pickle.PickleBuffer(b"foobar")
         for proto in range(5, pickle.HIGHEST_PROTOCOL + 1):
@@ -3107,37 +3791,6 @@ def __reduce__(self):
                     expected = "changed size during iteration"
                     self.assertIn(expected, str(e))
 
-    def test_evil_pickler_mutating_collection(self):
-        # https://github.com/python/cpython/issues/92930
-        if not hasattr(self, "pickler"):
-            raise self.skipTest(f"{type(self)} has no associated pickler type")
-
-        global Clearer
-        class Clearer:
-            pass
-
-        def check(collection):
-            class EvilPickler(self.pickler):
-                def persistent_id(self, obj):
-                    if isinstance(obj, Clearer):
-                        collection.clear()
-                    return None
-            pickler = EvilPickler(io.BytesIO(), proto)
-            try:
-                pickler.dump(collection)
-            except RuntimeError as e:
-                expected = "changed size during iteration"
-                self.assertIn(expected, str(e))
-
-        for proto in protocols:
-            check([Clearer()])
-            check([Clearer(), Clearer()])
-            check({Clearer()})
-            check({Clearer(), Clearer()})
-            check({Clearer(): 1})
-            check({Clearer(): 1, Clearer(): 2})
-            check({1: Clearer(), 2: Clearer()})
-
 
 class BigmemPickleTests:
 
@@ -3268,6 +3921,18 @@ def test_huge_str_64b(self, size):
 
 # Test classes for reduce_ex
 
+class R:
+    def __init__(self, reduce=None):
+        self.reduce = reduce
+    def __reduce__(self, proto):
+        return self.reduce
+
+class REX:
+    def __init__(self, reduce_ex=None):
+        self.reduce_ex = reduce_ex
+    def __reduce_ex__(self, proto):
+        return self.reduce_ex
+
 class REX_one(object):
     """No __reduce_ex__ here, but inheriting it from object"""
     _reduce_called = 0
@@ -3343,6 +4008,34 @@ def __setstate__(self, state):
     def __reduce__(self):
         return type(self), (), self.state
 
+class REX_None:
+    """ Setting __reduce_ex__ to None should fail """
+    __reduce_ex__ = None
+
+class R_None:
+    """ Setting __reduce__ to None should fail """
+    __reduce__ = None
+
+class C_None_setstate:
+    """  Setting __setstate__ to None should fail """
+    def __getstate__(self):
+        return 1
+
+    __setstate__ = None
+
+class CustomError(Exception):
+    pass
+
+class Unpickleable:
+    def __reduce__(self):
+        raise CustomError
+
+UNPICKLEABLE = Unpickleable()
+
+class UnpickleableCallable(Unpickleable):
+    def __call__(self, *args, **kwargs):
+        pass
+
 
 # Test classes for newobj
 
@@ -3392,7 +4085,9 @@ class MyIntWithNew2(MyIntWithNew):
 class SlotList(MyList):
     __slots__ = ["foo"]
 
-class SimpleNewObj(int):
+# Ruff "redefined while unused" false positive here due to `global` variables
+# being assigned (and then restored) from within test methods earlier in the file
+class SimpleNewObj(int):  # noqa: F811
     def __init__(self, *args, **kwargs):
         # raise an error, to make sure this isn't called
         raise TypeError("SimpleNewObj.__init__() didn't expect to get called")
@@ -3411,6 +4106,12 @@ class BadGetattr:
     def __getattr__(self, key):
         self.foo
 
+class NoNew:
+    def __getattribute__(self, name):
+        if name == '__new__':
+            raise AttributeError
+        return super().__getattribute__(name)
+
 
 class AbstractPickleModuleTests:
 
@@ -3483,7 +4184,7 @@ def raises_oserror(self, *args, **kwargs):
             raise OSError
         @property
         def bad_property(self):
-            1/0
+            raise CustomError
 
         # File without read and readline
         class F:
@@ -3504,23 +4205,23 @@ class F:
         class F:
             read = bad_property
             readline = raises_oserror
-        self.assertRaises(ZeroDivisionError, self.Unpickler, F())
+        self.assertRaises(CustomError, self.Unpickler, F())
 
         # File with bad readline
         class F:
             readline = bad_property
             read = raises_oserror
-        self.assertRaises(ZeroDivisionError, self.Unpickler, F())
+        self.assertRaises(CustomError, self.Unpickler, F())
 
         # File with bad readline, no read
         class F:
             readline = bad_property
-        self.assertRaises(ZeroDivisionError, self.Unpickler, F())
+        self.assertRaises(CustomError, self.Unpickler, F())
 
         # File with bad read, no readline
         class F:
             read = bad_property
-        self.assertRaises((AttributeError, ZeroDivisionError), self.Unpickler, F())
+        self.assertRaises((AttributeError, CustomError), self.Unpickler, F())
 
         # File with bad peek
         class F:
@@ -3529,7 +4230,7 @@ class F:
             readline = raises_oserror
         try:
             self.Unpickler(F())
-        except ZeroDivisionError:
+        except CustomError:
             pass
 
         # File with bad readinto
@@ -3539,7 +4240,7 @@ class F:
             readline = raises_oserror
         try:
             self.Unpickler(F())
-        except ZeroDivisionError:
+        except CustomError:
             pass
 
     def test_pickler_bad_file(self):
@@ -3552,8 +4253,8 @@ class F:
         class F:
             @property
             def write(self):
-                1/0
-        self.assertRaises(ZeroDivisionError, self.Pickler, F())
+                raise CustomError
+        self.assertRaises(CustomError, self.Pickler, F())
 
     def check_dumps_loads_oob_buffers(self, dumps, loads):
         # No need to do the full gamut of tests here, just enough to
@@ -3661,9 +4362,15 @@ def test_return_correct_type(self):
 
     def test_protocol0_is_ascii_only(self):
         non_ascii_str = "\N{EMPTY SET}"
-        self.assertRaises(pickle.PicklingError, self.dumps, non_ascii_str, 0)
+        with self.assertRaises(pickle.PicklingError) as cm:
+            self.dumps(non_ascii_str, 0)
+        self.assertEqual(str(cm.exception),
+                         'persistent IDs in protocol 0 must be ASCII strings')
         pickled = pickle.PERSID + non_ascii_str.encode('utf-8') + b'\n.'
-        self.assertRaises(pickle.UnpicklingError, self.loads, pickled)
+        with self.assertRaises(pickle.UnpicklingError) as cm:
+            self.loads(pickled)
+        self.assertEqual(str(cm.exception),
+                         'persistent IDs in protocol 0 must be ASCII strings')
 
 
 class AbstractPicklerUnpicklerObjectTests:
@@ -3824,6 +4531,25 @@ def test_unpickling_buffering_readline(self):
                 unpickler = self.unpickler_class(f)
                 self.assertEqual(unpickler.load(), data)
 
+    def test_pickle_invalid_reducer_override(self):
+        # gh-103035
+        obj = object()
+
+        f = io.BytesIO()
+        class MyPickler(self.pickler_class):
+            pass
+        pickler = MyPickler(f)
+        pickler.dump(obj)
+
+        pickler.clear_memo()
+        pickler.reducer_override = None
+        with self.assertRaises(TypeError):
+            pickler.dump(obj)
+
+        pickler.clear_memo()
+        pickler.reducer_override = 10
+        with self.assertRaises(TypeError):
+            pickler.dump(obj)
 
 # Tests for dispatch_table attribute
 
@@ -3986,6 +4712,15 @@ def dumps(obj, protocol=None):
 
         self._test_dispatch_table(dumps, dt)
 
+    def test_dispatch_table_None_item(self):
+        # gh-93627
+        obj = object()
+        f = io.BytesIO()
+        pickler = self.pickler_class(f)
+        pickler.dispatch_table = {type(obj): None}
+        with self.assertRaises(TypeError):
+            pickler.dump(obj)
+
     def _test_dispatch_table(self, dumps, dispatch_table):
         def custom_load_dump(obj):
             return pickle.loads(dumps(obj, 0))
diff --git a/Lib/test/pyclbr_input.py b/Lib/test/pyclbr_input.py
new file mode 100644
index 0000000000..5535edbfa7
--- /dev/null
+++ b/Lib/test/pyclbr_input.py
@@ -0,0 +1,85 @@
+"""Test cases for test_pyclbr.py"""
+
+def f(): pass
+
+class Other(object):
+    @classmethod
+    def foo(c): pass
+
+    def om(self): pass
+
+class B (object):
+    def bm(self): pass
+
+class C (B):
+    d = 10
+
+    # This one is correctly considered by both test_pyclbr.py and pyclbr.py
+    # as a non-method of C.
+    foo = Other().foo
+
+    # This causes test_pyclbr.py to fail, but only because the
+    # introspection-based is_method() code in the test can't
+    # distinguish between this and a genuine method function like m().
+    #
+    # The pyclbr.py module gets this right as it parses the text.
+    om = Other.om
+    f = f
+
+    def m(self): pass
+
+    @staticmethod
+    def sm(self): pass
+
+    @classmethod
+    def cm(self): pass
+
+# Check that mangling is correctly handled
+
+class a:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
+
+class _:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
+
+class __:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
+
+class ___:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
+
+class _a:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
+
+class __a:
+    def a(self): pass
+    def _(self): pass
+    def _a(self): pass
+    def __(self): pass
+    def ___(self): pass
+    def __a(self): pass
diff --git a/Lib/test/pythoninfo.py b/Lib/test/pythoninfo.py
new file mode 100644
index 0000000000..19b336ba96
--- /dev/null
+++ b/Lib/test/pythoninfo.py
@@ -0,0 +1,1100 @@
+"""
+Collect various information about Python to help debugging test failures.
+"""
+import errno
+import re
+import sys
+import traceback
+import warnings
+
+
+def normalize_text(text):
+    if text is None:
+        return None
+    text = str(text)
+    text = re.sub(r'\s+', ' ', text)
+    return text.strip()
+
+
+class PythonInfo:
+    def __init__(self):
+        self.info = {}
+
+    def add(self, key, value):
+        if key in self.info:
+            raise ValueError("duplicate key: %r" % key)
+
+        if value is None:
+            return
+
+        if not isinstance(value, int):
+            if not isinstance(value, str):
+                # convert other objects like sys.flags to string
+                value = str(value)
+
+            value = value.strip()
+            if not value:
+                return
+
+        self.info[key] = value
+
+    def get_infos(self):
+        """
+        Get information as a key:value dictionary where values are strings.
+        """
+        return {key: str(value) for key, value in self.info.items()}
+
+
+def copy_attributes(info_add, obj, name_fmt, attributes, *, formatter=None):
+    for attr in attributes:
+        value = getattr(obj, attr, None)
+        if value is None:
+            continue
+        name = name_fmt % attr
+        if formatter is not None:
+            value = formatter(attr, value)
+        info_add(name, value)
+
+
+def copy_attr(info_add, name, mod, attr_name):
+    try:
+        value = getattr(mod, attr_name)
+    except AttributeError:
+        return
+    info_add(name, value)
+
+
+def call_func(info_add, name, mod, func_name, *, formatter=None):
+    try:
+        func = getattr(mod, func_name)
+    except AttributeError:
+        return
+    value = func()
+    if formatter is not None:
+        value = formatter(value)
+    info_add(name, value)
+
+
+def collect_sys(info_add):
+    attributes = (
+        '_emscripten_info',
+        '_framework',
+        'abiflags',
+        'api_version',
+        'builtin_module_names',
+        'byteorder',
+        'dont_write_bytecode',
+        'executable',
+        'flags',
+        'float_info',
+        'float_repr_style',
+        'hash_info',
+        'hexversion',
+        'implementation',
+        'int_info',
+        'maxsize',
+        'maxunicode',
+        'path',
+        'platform',
+        'platlibdir',
+        'prefix',
+        'thread_info',
+        'version',
+        'version_info',
+        'winver',
+    )
+    copy_attributes(info_add, sys, 'sys.%s', attributes)
+
+    for func in (
+        '_is_gil_enabled',
+        'getandroidapilevel',
+        'getrecursionlimit',
+        'getwindowsversion',
+    ):
+        call_func(info_add, f'sys.{func}', sys, func)
+
+    encoding = sys.getfilesystemencoding()
+    if hasattr(sys, 'getfilesystemencodeerrors'):
+        encoding = '%s/%s' % (encoding, sys.getfilesystemencodeerrors())
+    info_add('sys.filesystem_encoding', encoding)
+
+    for name in ('stdin', 'stdout', 'stderr'):
+        stream = getattr(sys, name)
+        if stream is None:
+            continue
+        encoding = getattr(stream, 'encoding', None)
+        if not encoding:
+            continue
+        errors = getattr(stream, 'errors', None)
+        if errors:
+            encoding = '%s/%s' % (encoding, errors)
+        info_add('sys.%s.encoding' % name, encoding)
+
+    # Were we compiled --with-pydebug?
+    Py_DEBUG = hasattr(sys, 'gettotalrefcount')
+    if Py_DEBUG:
+        text = 'Yes (sys.gettotalrefcount() present)'
+    else:
+        text = 'No (sys.gettotalrefcount() missing)'
+    info_add('build.Py_DEBUG', text)
+
+    # Were we compiled --with-trace-refs?
+    Py_TRACE_REFS = hasattr(sys, 'getobjects')
+    if Py_TRACE_REFS:
+        text = 'Yes (sys.getobjects() present)'
+    else:
+        text = 'No (sys.getobjects() missing)'
+    info_add('build.Py_TRACE_REFS', text)
+
+
+def collect_platform(info_add):
+    import platform
+
+    arch = platform.architecture()
+    arch = ' '.join(filter(bool, arch))
+    info_add('platform.architecture', arch)
+
+    info_add('platform.python_implementation',
+             platform.python_implementation())
+    info_add('platform.platform',
+             platform.platform(aliased=True))
+
+    libc_ver = ('%s %s' % platform.libc_ver()).strip()
+    if libc_ver:
+        info_add('platform.libc_ver', libc_ver)
+
+    try:
+        os_release = platform.freedesktop_os_release()
+    except OSError:
+        pass
+    else:
+        for key in (
+            'ID',
+            'NAME',
+            'PRETTY_NAME'
+            'VARIANT',
+            'VARIANT_ID',
+            'VERSION',
+            'VERSION_CODENAME',
+            'VERSION_ID',
+        ):
+            if key not in os_release:
+                continue
+            info_add(f'platform.freedesktop_os_release[{key}]',
+                     os_release[key])
+
+    if sys.platform == 'android':
+        call_func(info_add, 'platform.android_ver', platform, 'android_ver')
+
+
+def collect_locale(info_add):
+    import locale
+
+    info_add('locale.getencoding', locale.getencoding())
+
+
+def collect_builtins(info_add):
+    info_add('builtins.float.float_format', float.__getformat__("float"))
+    info_add('builtins.float.double_format', float.__getformat__("double"))
+
+
+def collect_urandom(info_add):
+    import os
+
+    if hasattr(os, 'getrandom'):
+        # PEP 524: Check if system urandom is initialized
+        try:
+            try:
+                os.getrandom(1, os.GRND_NONBLOCK)
+                state = 'ready (initialized)'
+            except BlockingIOError as exc:
+                state = 'not seeded yet (%s)' % exc
+            info_add('os.getrandom', state)
+        except OSError as exc:
+            # Python was compiled on a more recent Linux version
+            # than the current Linux kernel: ignore OSError(ENOSYS)
+            if exc.errno != errno.ENOSYS:
+                raise
+
+
+def collect_os(info_add):
+    import os
+
+    def format_attr(attr, value):
+        if attr in ('supports_follow_symlinks', 'supports_fd',
+                    'supports_effective_ids'):
+            return str(sorted(func.__name__ for func in value))
+        else:
+            return value
+
+    attributes = (
+        'name',
+        'supports_bytes_environ',
+        'supports_effective_ids',
+        'supports_fd',
+        'supports_follow_symlinks',
+    )
+    copy_attributes(info_add, os, 'os.%s', attributes, formatter=format_attr)
+
+    for func in (
+        'cpu_count',
+        'getcwd',
+        'getegid',
+        'geteuid',
+        'getgid',
+        'getloadavg',
+        'getresgid',
+        'getresuid',
+        'getuid',
+        'process_cpu_count',
+        'uname',
+    ):
+        call_func(info_add, 'os.%s' % func, os, func)
+
+    def format_groups(groups):
+        return ', '.join(map(str, groups))
+
+    call_func(info_add, 'os.getgroups', os, 'getgroups', formatter=format_groups)
+
+    if hasattr(os, 'getlogin'):
+        try:
+            login = os.getlogin()
+        except OSError:
+            # getlogin() fails with "OSError: [Errno 25] Inappropriate ioctl
+            # for device" on Travis CI
+            pass
+        else:
+            info_add("os.login", login)
+
+    # Environment variables used by the stdlib and tests. Don't log the full
+    # environment: filter to list to not leak sensitive information.
+    #
+    # HTTP_PROXY is not logged because it can contain a password.
+    ENV_VARS = frozenset((
+        "APPDATA",
+        "AR",
+        "ARCHFLAGS",
+        "ARFLAGS",
+        "AUDIODEV",
+        "BUILDPYTHON",
+        "CC",
+        "CFLAGS",
+        "COLUMNS",
+        "COMPUTERNAME",
+        "COMSPEC",
+        "CPP",
+        "CPPFLAGS",
+        "DISPLAY",
+        "DISTUTILS_DEBUG",
+        "DISTUTILS_USE_SDK",
+        "DYLD_LIBRARY_PATH",
+        "ENSUREPIP_OPTIONS",
+        "HISTORY_FILE",
+        "HOME",
+        "HOMEDRIVE",
+        "HOMEPATH",
+        "IDLESTARTUP",
+        "IPHONEOS_DEPLOYMENT_TARGET",
+        "LANG",
+        "LDFLAGS",
+        "LDSHARED",
+        "LD_LIBRARY_PATH",
+        "LINES",
+        "MACOSX_DEPLOYMENT_TARGET",
+        "MAILCAPS",
+        "MAKEFLAGS",
+        "MIXERDEV",
+        "MSSDK",
+        "PATH",
+        "PATHEXT",
+        "PIP_CONFIG_FILE",
+        "PLAT",
+        "POSIXLY_CORRECT",
+        "PY_SAX_PARSER",
+        "ProgramFiles",
+        "ProgramFiles(x86)",
+        "RUNNING_ON_VALGRIND",
+        "SDK_TOOLS_BIN",
+        "SERVER_SOFTWARE",
+        "SHELL",
+        "SOURCE_DATE_EPOCH",
+        "SYSTEMROOT",
+        "TEMP",
+        "TERM",
+        "TILE_LIBRARY",
+        "TMP",
+        "TMPDIR",
+        "TRAVIS",
+        "TZ",
+        "USERPROFILE",
+        "VIRTUAL_ENV",
+        "WAYLAND_DISPLAY",
+        "WINDIR",
+        "_PYTHON_HOSTRUNNER",
+        "_PYTHON_HOST_PLATFORM",
+        "_PYTHON_PROJECT_BASE",
+        "_PYTHON_SYSCONFIGDATA_NAME",
+        "_PYTHON_SYSCONFIGDATA_PATH",
+        "__PYVENV_LAUNCHER__",
+
+        # Sanitizer options
+        "ASAN_OPTIONS",
+        "LSAN_OPTIONS",
+        "MSAN_OPTIONS",
+        "TSAN_OPTIONS",
+        "UBSAN_OPTIONS",
+    ))
+    for name, value in os.environ.items():
+        uname = name.upper()
+        if (uname in ENV_VARS
+           # Copy PYTHON* variables like PYTHONPATH
+           # Copy LC_* variables like LC_ALL
+           or uname.startswith(("PYTHON", "LC_"))
+           # Visual Studio: VS140COMNTOOLS
+           or (uname.startswith("VS") and uname.endswith("COMNTOOLS"))):
+            info_add('os.environ[%s]' % name, value)
+
+    if hasattr(os, 'umask'):
+        mask = os.umask(0)
+        os.umask(mask)
+        info_add("os.umask", '0o%03o' % mask)
+
+
+def collect_pwd(info_add):
+    try:
+        import pwd
+    except ImportError:
+        return
+    import os
+
+    uid = os.getuid()
+    try:
+        entry = pwd.getpwuid(uid)
+    except KeyError:
+        entry = None
+
+    info_add('pwd.getpwuid(%s)'% uid,
+             entry if entry is not None else '<KeyError>')
+
+    if entry is None:
+        # there is nothing interesting to read if the current user identifier
+        # is not the password database
+        return
+
+    if hasattr(os, 'getgrouplist'):
+        groups = os.getgrouplist(entry.pw_name, entry.pw_gid)
+        groups = ', '.join(map(str, groups))
+        info_add('os.getgrouplist', groups)
+
+
+def collect_readline(info_add):
+    try:
+        import readline
+    except ImportError:
+        return
+
+    def format_attr(attr, value):
+        if isinstance(value, int):
+            return "%#x" % value
+        else:
+            return value
+
+    attributes = (
+        "_READLINE_VERSION",
+        "_READLINE_RUNTIME_VERSION",
+        "_READLINE_LIBRARY_VERSION",
+    )
+    copy_attributes(info_add, readline, 'readline.%s', attributes,
+                    formatter=format_attr)
+
+    if not hasattr(readline, "_READLINE_LIBRARY_VERSION"):
+        # _READLINE_LIBRARY_VERSION has been added to CPython 3.7
+        doc = getattr(readline, '__doc__', '')
+        if 'libedit readline' in doc:
+            info_add('readline.library', 'libedit readline')
+        elif 'GNU readline' in doc:
+            info_add('readline.library', 'GNU readline')
+
+
+def collect_gdb(info_add):
+    import subprocess
+
+    try:
+        proc = subprocess.Popen(["gdb", "-nx", "--version"],
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE,
+                                universal_newlines=True)
+        version = proc.communicate()[0]
+        if proc.returncode:
+            # ignore gdb failure: test_gdb will log the error
+            return
+    except OSError:
+        return
+
+    # Only keep the first line
+    version = version.splitlines()[0]
+    info_add('gdb_version', version)
+
+
+def collect_tkinter(info_add):
+    try:
+        import _tkinter
+    except ImportError:
+        pass
+    else:
+        attributes = ('TK_VERSION', 'TCL_VERSION')
+        copy_attributes(info_add, _tkinter, 'tkinter.%s', attributes)
+
+    try:
+        import tkinter
+    except ImportError:
+        pass
+    else:
+        tcl = tkinter.Tcl()
+        patchlevel = tcl.call('info', 'patchlevel')
+        info_add('tkinter.info_patchlevel', patchlevel)
+
+
+def collect_time(info_add):
+    import time
+
+    info_add('time.time', time.time())
+
+    attributes = (
+        'altzone',
+        'daylight',
+        'timezone',
+        'tzname',
+    )
+    copy_attributes(info_add, time, 'time.%s', attributes)
+
+    if hasattr(time, 'get_clock_info'):
+        for clock in ('clock', 'monotonic', 'perf_counter',
+                      'process_time', 'thread_time', 'time'):
+            try:
+                # prevent DeprecatingWarning on get_clock_info('clock')
+                with warnings.catch_warnings(record=True):
+                    clock_info = time.get_clock_info(clock)
+            except ValueError:
+                # missing clock like time.thread_time()
+                pass
+            else:
+                info_add('time.get_clock_info(%s)' % clock, clock_info)
+
+
+def collect_curses(info_add):
+    try:
+        import curses
+    except ImportError:
+        return
+
+    copy_attr(info_add, 'curses.ncurses_version', curses, 'ncurses_version')
+
+
+def collect_datetime(info_add):
+    try:
+        import datetime
+    except ImportError:
+        return
+
+    info_add('datetime.datetime.now', datetime.datetime.now())
+
+
+def collect_sysconfig(info_add):
+    import sysconfig
+
+    info_add('sysconfig.is_python_build', sysconfig.is_python_build())
+
+    for name in (
+        'ABIFLAGS',
+        'ANDROID_API_LEVEL',
+        'CC',
+        'CCSHARED',
+        'CFLAGS',
+        'CFLAGSFORSHARED',
+        'CONFIG_ARGS',
+        'HOSTRUNNER',
+        'HOST_GNU_TYPE',
+        'MACHDEP',
+        'MULTIARCH',
+        'OPT',
+        'PGO_PROF_USE_FLAG',
+        'PY_CFLAGS',
+        'PY_CFLAGS_NODIST',
+        'PY_CORE_LDFLAGS',
+        'PY_LDFLAGS',
+        'PY_LDFLAGS_NODIST',
+        'PY_STDMODULE_CFLAGS',
+        'Py_DEBUG',
+        'Py_ENABLE_SHARED',
+        'Py_GIL_DISABLED',
+        'SHELL',
+        'SOABI',
+        'TEST_MODULES',
+        'abs_builddir',
+        'abs_srcdir',
+        'prefix',
+        'srcdir',
+    ):
+        value = sysconfig.get_config_var(name)
+        if name == 'ANDROID_API_LEVEL' and not value:
+            # skip ANDROID_API_LEVEL=0
+            continue
+        value = normalize_text(value)
+        info_add('sysconfig[%s]' % name, value)
+
+    PY_CFLAGS = sysconfig.get_config_var('PY_CFLAGS')
+    NDEBUG = (PY_CFLAGS and '-DNDEBUG' in PY_CFLAGS)
+    if NDEBUG:
+        text = 'ignore assertions (macro defined)'
+    else:
+        text= 'build assertions (macro not defined)'
+    info_add('build.NDEBUG',text)
+
+    for name in (
+        'WITH_DOC_STRINGS',
+        'WITH_DTRACE',
+        'WITH_FREELISTS',
+        'WITH_MIMALLOC',
+        'WITH_PYMALLOC',
+        'WITH_VALGRIND',
+    ):
+        value = sysconfig.get_config_var(name)
+        if value:
+            text = 'Yes'
+        else:
+            text = 'No'
+        info_add(f'build.{name}', text)
+
+
+def collect_ssl(info_add):
+    import os
+    try:
+        import ssl
+    except ImportError:
+        return
+    try:
+        import _ssl
+    except ImportError:
+        _ssl = None
+
+    def format_attr(attr, value):
+        if attr.startswith('OP_'):
+            return '%#8x' % value
+        else:
+            return value
+
+    attributes = (
+        'OPENSSL_VERSION',
+        'OPENSSL_VERSION_INFO',
+        'HAS_SNI',
+        'OP_ALL',
+        'OP_NO_TLSv1_1',
+    )
+    copy_attributes(info_add, ssl, 'ssl.%s', attributes, formatter=format_attr)
+
+    for name, ctx in (
+        ('SSLContext', ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)),
+        ('default_https_context', ssl._create_default_https_context()),
+        ('stdlib_context', ssl._create_stdlib_context()),
+    ):
+        attributes = (
+            'minimum_version',
+            'maximum_version',
+            'protocol',
+            'options',
+            'verify_mode',
+        )
+        copy_attributes(info_add, ctx, f'ssl.{name}.%s', attributes)
+
+    env_names = ["OPENSSL_CONF", "SSLKEYLOGFILE"]
+    if _ssl is not None and hasattr(_ssl, 'get_default_verify_paths'):
+        parts = _ssl.get_default_verify_paths()
+        env_names.extend((parts[0], parts[2]))
+
+    for name in env_names:
+        try:
+            value = os.environ[name]
+        except KeyError:
+            continue
+        info_add('ssl.environ[%s]' % name, value)
+
+
+def collect_socket(info_add):
+    try:
+        import socket
+    except ImportError:
+        return
+
+    try:
+        hostname = socket.gethostname()
+    except (OSError, AttributeError):
+        # WASI SDK 16.0 does not have gethostname(2).
+        if sys.platform != "wasi":
+            raise
+    else:
+        info_add('socket.hostname', hostname)
+
+
+def collect_sqlite(info_add):
+    try:
+        import sqlite3
+    except ImportError:
+        return
+
+    attributes = ('sqlite_version',)
+    copy_attributes(info_add, sqlite3, 'sqlite3.%s', attributes)
+
+
+def collect_zlib(info_add):
+    try:
+        import zlib
+    except ImportError:
+        return
+
+    attributes = ('ZLIB_VERSION', 'ZLIB_RUNTIME_VERSION')
+    copy_attributes(info_add, zlib, 'zlib.%s', attributes)
+
+
+def collect_expat(info_add):
+    try:
+        from xml.parsers import expat
+    except ImportError:
+        return
+
+    attributes = ('EXPAT_VERSION',)
+    copy_attributes(info_add, expat, 'expat.%s', attributes)
+
+
+def collect_decimal(info_add):
+    try:
+        import _decimal
+    except ImportError:
+        return
+
+    attributes = ('__libmpdec_version__',)
+    copy_attributes(info_add, _decimal, '_decimal.%s', attributes)
+
+
+def collect_testcapi(info_add):
+    try:
+        import _testcapi
+    except ImportError:
+        return
+
+    for name in (
+        'LONG_MAX',         # always 32-bit on Windows, 64-bit on 64-bit Unix
+        'PY_SSIZE_T_MAX',
+        'Py_C_RECURSION_LIMIT',
+        'SIZEOF_TIME_T',    # 32-bit or 64-bit depending on the platform
+        'SIZEOF_WCHAR_T',   # 16-bit or 32-bit depending on the platform
+    ):
+        copy_attr(info_add, f'_testcapi.{name}', _testcapi, name)
+
+
+def collect_testinternalcapi(info_add):
+    try:
+        import _testinternalcapi
+    except ImportError:
+        return
+
+    call_func(info_add, 'pymem.allocator', _testinternalcapi, 'pymem_getallocatorsname')
+
+    for name in (
+        'SIZEOF_PYGC_HEAD',
+        'SIZEOF_PYOBJECT',
+    ):
+        copy_attr(info_add, f'_testinternalcapi.{name}', _testinternalcapi, name)
+
+
+def collect_resource(info_add):
+    try:
+        import resource
+    except ImportError:
+        return
+
+    limits = [attr for attr in dir(resource) if attr.startswith('RLIMIT_')]
+    for name in limits:
+        key = getattr(resource, name)
+        value = resource.getrlimit(key)
+        info_add('resource.%s' % name, value)
+
+    call_func(info_add, 'resource.pagesize', resource, 'getpagesize')
+
+
+def collect_test_socket(info_add):
+    import unittest
+    try:
+        from test import test_socket
+    except (ImportError, unittest.SkipTest):
+        return
+
+    # all check attributes like HAVE_SOCKET_CAN
+    attributes = [name for name in dir(test_socket)
+                  if name.startswith('HAVE_')]
+    copy_attributes(info_add, test_socket, 'test_socket.%s', attributes)
+
+
+def collect_support(info_add):
+    try:
+        from test import support
+    except ImportError:
+        return
+
+    attributes = (
+        'MS_WINDOWS',
+        'has_fork_support',
+        'has_socket_support',
+        'has_strftime_extensions',
+        'has_subprocess_support',
+        'is_android',
+        'is_emscripten',
+        'is_jython',
+        'is_wasi',
+    )
+    copy_attributes(info_add, support, 'support.%s', attributes)
+
+    call_func(info_add, 'support._is_gui_available', support, '_is_gui_available')
+    call_func(info_add, 'support.python_is_optimized', support, 'python_is_optimized')
+
+    info_add('support.check_sanitizer(address=True)',
+             support.check_sanitizer(address=True))
+    info_add('support.check_sanitizer(memory=True)',
+             support.check_sanitizer(memory=True))
+    info_add('support.check_sanitizer(ub=True)',
+             support.check_sanitizer(ub=True))
+
+
+def collect_support_os_helper(info_add):
+    try:
+        from test.support import os_helper
+    except ImportError:
+        return
+
+    for name in (
+        'can_symlink',
+        'can_xattr',
+        'can_chmod',
+        'can_dac_override',
+    ):
+        func = getattr(os_helper, name)
+        info_add(f'support_os_helper.{name}', func())
+
+
+def collect_support_socket_helper(info_add):
+    try:
+        from test.support import socket_helper
+    except ImportError:
+        return
+
+    attributes = (
+        'IPV6_ENABLED',
+        'has_gethostname',
+    )
+    copy_attributes(info_add, socket_helper, 'support_socket_helper.%s', attributes)
+
+    for name in (
+        'tcp_blackhole',
+    ):
+        func = getattr(socket_helper, name)
+        info_add(f'support_socket_helper.{name}', func())
+
+
+def collect_support_threading_helper(info_add):
+    try:
+        from test.support import threading_helper
+    except ImportError:
+        return
+
+    attributes = (
+        'can_start_thread',
+    )
+    copy_attributes(info_add, threading_helper, 'support_threading_helper.%s', attributes)
+
+
+def collect_cc(info_add):
+    import subprocess
+    import sysconfig
+
+    CC = sysconfig.get_config_var('CC')
+    if not CC:
+        return
+
+    try:
+        import shlex
+        args = shlex.split(CC)
+    except ImportError:
+        args = CC.split()
+    args.append('--version')
+    try:
+        proc = subprocess.Popen(args,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.STDOUT,
+                                universal_newlines=True)
+    except OSError:
+        # Cannot run the compiler, for example when Python has been
+        # cross-compiled and installed on the target platform where the
+        # compiler is missing.
+        return
+
+    stdout = proc.communicate()[0]
+    if proc.returncode:
+        # CC --version failed: ignore error
+        return
+
+    text = stdout.splitlines()[0]
+    text = normalize_text(text)
+    info_add('CC.version', text)
+
+
+def collect_gdbm(info_add):
+    try:
+        from _gdbm import _GDBM_VERSION
+    except ImportError:
+        return
+
+    info_add('gdbm.GDBM_VERSION', '.'.join(map(str, _GDBM_VERSION)))
+
+
+def collect_get_config(info_add):
+    # Get global configuration variables, _PyPreConfig and _PyCoreConfig
+    try:
+        from _testinternalcapi import get_configs
+    except ImportError:
+        return
+
+    all_configs = get_configs()
+    for config_type in sorted(all_configs):
+        config = all_configs[config_type]
+        for key in sorted(config):
+            info_add('%s[%s]' % (config_type, key), repr(config[key]))
+
+
+def collect_subprocess(info_add):
+    import subprocess
+    copy_attributes(info_add, subprocess, 'subprocess.%s', ('_USE_POSIX_SPAWN',))
+
+
+def collect_windows(info_add):
+    if sys.platform != "win32":
+        # Code specific to Windows
+        return
+
+    # windows.RtlAreLongPathsEnabled: RtlAreLongPathsEnabled()
+    # windows.is_admin: IsUserAnAdmin()
+    try:
+        import ctypes
+        if not hasattr(ctypes, 'WinDLL'):
+            raise ImportError
+    except ImportError:
+        pass
+    else:
+        ntdll = ctypes.WinDLL('ntdll')
+        BOOLEAN = ctypes.c_ubyte
+        try:
+            RtlAreLongPathsEnabled = ntdll.RtlAreLongPathsEnabled
+        except AttributeError:
+            res = '<function not available>'
+        else:
+            RtlAreLongPathsEnabled.restype = BOOLEAN
+            RtlAreLongPathsEnabled.argtypes = ()
+            res = bool(RtlAreLongPathsEnabled())
+        info_add('windows.RtlAreLongPathsEnabled', res)
+
+        shell32 = ctypes.windll.shell32
+        IsUserAnAdmin = shell32.IsUserAnAdmin
+        IsUserAnAdmin.restype = BOOLEAN
+        IsUserAnAdmin.argtypes = ()
+        info_add('windows.is_admin', IsUserAnAdmin())
+
+    try:
+        import _winapi
+        dll_path = _winapi.GetModuleFileName(sys.dllhandle)
+        info_add('windows.dll_path', dll_path)
+    except (ImportError, AttributeError):
+        pass
+
+    # windows.version_caption: "wmic os get Caption,Version /value" command
+    import subprocess
+    try:
+        # When wmic.exe output is redirected to a pipe,
+        # it uses the OEM code page
+        proc = subprocess.Popen(["wmic", "os", "get", "Caption,Version", "/value"],
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE,
+                                encoding="oem",
+                                text=True)
+        output, stderr = proc.communicate()
+        if proc.returncode:
+            output = ""
+    except OSError:
+        pass
+    else:
+        for line in output.splitlines():
+            line = line.strip()
+            if line.startswith('Caption='):
+                line = line.removeprefix('Caption=').strip()
+                if line:
+                    info_add('windows.version_caption', line)
+            elif line.startswith('Version='):
+                line = line.removeprefix('Version=').strip()
+                if line:
+                    info_add('windows.version', line)
+
+    # windows.ver: "ver" command
+    try:
+        proc = subprocess.Popen(["ver"], shell=True,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE,
+                                text=True)
+        output = proc.communicate()[0]
+        if proc.returncode == 0xc0000142:
+            return
+        if proc.returncode:
+            output = ""
+    except OSError:
+        return
+    else:
+        output = output.strip()
+        line = output.splitlines()[0]
+        if line:
+            info_add('windows.ver', line)
+
+    # windows.developer_mode: get AllowDevelopmentWithoutDevLicense registry
+    import winreg
+    try:
+        key = winreg.OpenKey(
+            winreg.HKEY_LOCAL_MACHINE,
+            r"SOFTWARE\Microsoft\Windows\CurrentVersion\AppModelUnlock")
+        subkey = "AllowDevelopmentWithoutDevLicense"
+        try:
+            value, value_type = winreg.QueryValueEx(key, subkey)
+        finally:
+            winreg.CloseKey(key)
+    except OSError:
+        pass
+    else:
+        info_add('windows.developer_mode', "enabled" if value else "disabled")
+
+
+def collect_fips(info_add):
+    try:
+        import _hashlib
+    except ImportError:
+        _hashlib = None
+
+    if _hashlib is not None:
+        call_func(info_add, 'fips.openssl_fips_mode', _hashlib, 'get_fips_mode')
+
+    try:
+        with open("/proc/sys/crypto/fips_enabled", encoding="utf-8") as fp:
+            line = fp.readline().rstrip()
+
+        if line:
+            info_add('fips.linux_crypto_fips_enabled', line)
+    except OSError:
+        pass
+
+
+def collect_tempfile(info_add):
+    import tempfile
+
+    info_add('tempfile.gettempdir', tempfile.gettempdir())
+
+
+def collect_libregrtest_utils(info_add):
+    try:
+        from test.libregrtest import utils
+    except ImportError:
+        return
+
+    info_add('libregrtests.build_info', ' '.join(utils.get_build_info()))
+
+
+def collect_info(info):
+    error = False
+    info_add = info.add
+
+    for collect_func in (
+        # collect_urandom() must be the first, to check the getrandom() status.
+        # Other functions may block on os.urandom() indirectly and so change
+        # its state.
+        collect_urandom,
+
+        collect_builtins,
+        collect_cc,
+        collect_curses,
+        collect_datetime,
+        collect_decimal,
+        collect_expat,
+        collect_fips,
+        collect_gdb,
+        collect_gdbm,
+        collect_get_config,
+        collect_locale,
+        collect_os,
+        collect_platform,
+        collect_pwd,
+        collect_readline,
+        collect_resource,
+        collect_socket,
+        collect_sqlite,
+        collect_ssl,
+        collect_subprocess,
+        collect_sys,
+        collect_sysconfig,
+        collect_testcapi,
+        collect_testinternalcapi,
+        collect_tempfile,
+        collect_time,
+        collect_tkinter,
+        collect_windows,
+        collect_zlib,
+        collect_libregrtest_utils,
+
+        # Collecting from tests should be last as they have side effects.
+        collect_test_socket,
+        collect_support,
+        collect_support_os_helper,
+        collect_support_socket_helper,
+        collect_support_threading_helper,
+    ):
+        try:
+            collect_func(info_add)
+        except Exception:
+            error = True
+            print("ERROR: %s() failed" % (collect_func.__name__),
+                  file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+            print(file=sys.stderr)
+            sys.stderr.flush()
+
+    return error
+
+
+def dump_info(info, file=None):
+    title = "Python debug information"
+    print(title)
+    print("=" * len(title))
+    print()
+
+    infos = info.get_infos()
+    infos = sorted(infos.items())
+    for key, value in infos:
+        value = value.replace("\n", " ")
+        print("%s: %s" % (key, value))
+
+
+def main():
+    info = PythonInfo()
+    error = collect_info(info)
+    dump_info(info)
+
+    if error:
+        print()
+        print("Collection failed: exit with error", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 59db2664a0..54eb5e65ac 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -145,6 +145,9 @@ def __getitem__(self, i):
         self.assertEqual(self.type2test(LyingTuple((2,))), self.type2test((1,)))
         self.assertEqual(self.type2test(LyingList([2])), self.type2test([1]))
 
+        with self.assertRaises(TypeError):
+            self.type2test(unsupported_arg=[])
+
     def test_truth(self):
         self.assertFalse(self.type2test())
         self.assertTrue(self.type2test([42]))
@@ -423,8 +426,8 @@ def test_pickle(self):
             self.assertEqual(lst2, lst)
             self.assertNotEqual(id(lst2), id(lst))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @support.suppress_immortalization()
     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/site-packages/README.txt b/Lib/test/site-packages/README.txt
new file mode 100644
index 0000000000..273f6251a7
--- /dev/null
+++ b/Lib/test/site-packages/README.txt
@@ -0,0 +1,2 @@
+This directory exists so that 3rd party packages can be installed
+here.  Read the source for site.py for more details.
diff --git a/Lib/test/ssl_servers.py b/Lib/test/ssl_servers.py
index a4bd7455d4..c45411f49d 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, '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/string_tests.py b/Lib/test/string_tests.py
index 6f402513fd..c5831c47fc 100644
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -8,18 +8,12 @@
 from collections import UserList
 import random
 
+
 class Sequence:
     def __init__(self, seq='wxyz'): self.seq = seq
     def __len__(self): return len(self.seq)
     def __getitem__(self, i): return self.seq[i]
 
-class BadSeq1(Sequence):
-    def __init__(self): self.seq = [7, 'hello', 123]
-    def __str__(self): return '{0} {1} {2}'.format(*self.seq)
-
-class BadSeq2(Sequence):
-    def __init__(self): self.seq = ['a', 'b', 'c']
-    def __len__(self): return 8
 
 class BaseTest:
     # These tests are for buffers of values (bytes) and not
@@ -27,7 +21,7 @@ class BaseTest:
     # and various string implementations
 
     # The type to be tested
-    # Change in subclasses to change the behaviour of fixtesttype()
+    # Change in subclasses to change the behaviour of fixtype()
     type2test = None
 
     # Whether the "contained items" of the container are integers in
@@ -36,7 +30,7 @@ class BaseTest:
     contains_bytes = False
 
     # All tests pass their arguments to the testing methods
-    # as str objects. fixtesttype() can be used to propagate
+    # as str objects. fixtype() can be used to propagate
     # these arguments to the appropriate type
     def fixtype(self, obj):
         if isinstance(obj, str):
@@ -160,6 +154,12 @@ def test_count(self):
                     self.assertEqual(rem, 0, '%s != 0 for %s' % (rem, i))
                     self.assertEqual(r1, r2, '%s != %s for %s' % (r1, r2, i))
 
+    def test_count_keyword(self):
+        self.assertEqual('aa'.replace('a', 'b', 0), 'aa'.replace('a', 'b', count=0))
+        self.assertEqual('aa'.replace('a', 'b', 1), 'aa'.replace('a', 'b', count=1))
+        self.assertEqual('aa'.replace('a', 'b', 2), 'aa'.replace('a', 'b', count=2))
+        self.assertEqual('aa'.replace('a', 'b', 3), 'aa'.replace('a', 'b', count=3))
+
     def test_find(self):
         self.checkequal(0, 'abcdefghiabc', 'find', 'abc')
         self.checkequal(9, 'abcdefghiabc', 'find', 'abc', 1)
@@ -327,11 +327,12 @@ def reference_find(p, s):
             for i in range(len(s)):
                 if s.startswith(p, i):
                     return i
+            if p == '' and s == '':
+                return 0
             return -1
 
-        rr = random.randrange
-        choices = random.choices
-        for _ in range(1000):
+        def check_pattern(rr):
+            choices = random.choices
             p0 = ''.join(choices('abcde', k=rr(10))) * rr(10, 20)
             p = p0[:len(p0) - rr(10)] # pop off some characters
             left = ''.join(choices('abcdef', k=rr(2000)))
@@ -341,6 +342,49 @@ def reference_find(p, s):
                 self.checkequal(reference_find(p, text),
                                 text, 'find', p)
 
+        rr = random.randrange
+        for _ in range(1000):
+            check_pattern(rr)
+
+        # Test that empty string always work:
+        check_pattern(lambda *args: 0)
+
+    def test_find_many_lengths(self):
+        haystack_repeats = [a * 10**e for e in range(6) for a in (1,2,5)]
+        haystacks = [(n, self.fixtype("abcab"*n + "da")) for n in haystack_repeats]
+
+        needle_repeats = [a * 10**e for e in range(6) for a in (1, 3)]
+        needles = [(m, self.fixtype("abcab"*m + "da")) for m in needle_repeats]
+
+        for n, haystack1 in haystacks:
+            haystack2 = haystack1[:-1]
+            for m, needle in needles:
+                answer1 = 5 * (n - m) if m <= n else -1
+                self.assertEqual(haystack1.find(needle), answer1, msg=(n,m))
+                self.assertEqual(haystack2.find(needle), -1, msg=(n,m))
+
+    def test_adaptive_find(self):
+        # This would be very slow for the naive algorithm,
+        # but str.find() should be O(n + m).
+        for N in 1000, 10_000, 100_000, 1_000_000:
+            A, B = 'a' * N, 'b' * N
+            haystack = A + A + B + A + A
+            needle = A + B + B + A
+            self.checkequal(-1, haystack, 'find', needle)
+            self.checkequal(0, haystack, 'count', needle)
+            self.checkequal(len(haystack), haystack + needle, 'find', needle)
+            self.checkequal(1, haystack + needle, 'count', needle)
+
+    def test_find_with_memory(self):
+        # Test the "Skip with memory" path in the two-way algorithm.
+        for N in 1000, 3000, 10_000, 30_000:
+            needle = 'ab' * N
+            haystack = ('ab'*(N-1) + 'b') * 2
+            self.checkequal(-1, haystack, 'find', needle)
+            self.checkequal(0, haystack, 'count', needle)
+            self.checkequal(len(haystack), haystack + needle, 'find', needle)
+            self.checkequal(1, haystack + needle, 'count', needle)
+
     def test_find_shift_table_overflow(self):
         """When the table of 8-bit shifts overflows."""
         N = 2**8 + 100
@@ -724,6 +768,18 @@ def test_replace(self):
         self.checkraises(TypeError, 'hello', 'replace', 42, 'h')
         self.checkraises(TypeError, 'hello', 'replace', 'h', 42)
 
+    def test_replace_uses_two_way_maxcount(self):
+        # Test that maxcount works in _two_way_count in fastsearch.h
+        A, B = "A"*1000, "B"*1000
+        AABAA = A + A + B + A + A
+        ABBA = A + B + B + A
+        self.checkequal(AABAA + ABBA,
+                        AABAA + ABBA, 'replace', ABBA, "ccc", 0)
+        self.checkequal(AABAA + "ccc",
+                        AABAA + ABBA, 'replace', ABBA, "ccc", 1)
+        self.checkequal(AABAA + "ccc",
+                        AABAA + ABBA, 'replace', ABBA, "ccc", 2)
+
     @unittest.skip("TODO: RUSTPYTHON, may only apply to 32-bit platforms")
     @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
                      'only applies to 32-bit platforms')
@@ -734,8 +790,6 @@ def test_replace_overflow(self):
         self.checkraises(OverflowError, A2_16, "replace", "A", A2_16)
         self.checkraises(OverflowError, A2_16, "replace", "AA", A2_16+A2_16)
 
-
-    # Python 3.9
     def test_removeprefix(self):
         self.checkequal('am', 'spam', 'removeprefix', 'sp')
         self.checkequal('spamspam', 'spamspamspam', 'removeprefix', 'spam')
@@ -754,7 +808,6 @@ def test_removeprefix(self):
         self.checkraises(TypeError, 'hello', 'removeprefix', 'h', 42)
         self.checkraises(TypeError, 'hello', 'removeprefix', ("he", "l"))
 
-    # Python 3.9
     def test_removesuffix(self):
         self.checkequal('sp', 'spam', 'removesuffix', 'am')
         self.checkequal('spamspam', 'spamspamspam', 'removesuffix', 'spam')
@@ -1053,7 +1106,7 @@ def test_splitlines(self):
         self.checkraises(TypeError, 'abc', 'splitlines', 42, 42)
 
 
-class CommonTest(BaseTest):
+class StringLikeTest(BaseTest):
     # This testcase contains tests that can be used in all
     # stringlike classes. Currently this is str and UserString.
 
@@ -1084,11 +1137,6 @@ def test_capitalize_nonascii(self):
         self.checkequal('\u019b\u1d00\u1d86\u0221\u1fb7',
                         '\u019b\u1d00\u1d86\u0221\u1fb7', 'capitalize')
 
-
-class MixinStrUnicodeUserStringTest:
-    # additional tests that only work for
-    # stringlike objects, i.e. str, UserString
-
     def test_startswith(self):
         self.checkequal(True, 'hello', 'startswith', 'he')
         self.checkequal(True, 'hello', 'startswith', 'hello')
@@ -1273,8 +1321,11 @@ def test_join(self):
             self.checkequal(((('a' * i) + '-') * i)[:-1], '-', 'join',
                  ('a' * i,) * i)
 
-        #self.checkequal(str(BadSeq1()), ' ', 'join', BadSeq1())
-        self.checkequal('a b c', ' ', 'join', BadSeq2())
+        class LiesAboutLengthSeq(Sequence):
+            def __init__(self): self.seq = ['a', 'b', 'c']
+            def __len__(self): return 8
+
+        self.checkequal('a b c', ' ', 'join', LiesAboutLengthSeq())
 
         self.checkraises(TypeError, ' ', 'join')
         self.checkraises(TypeError, ' ', 'join', None)
@@ -1459,19 +1510,19 @@ def test_find_etc_raise_correct_error_messages(self):
         # issue 11828
         s = 'hello'
         x = 'x'
-        self.assertRaisesRegex(TypeError, r'^find\(', s.find,
+        self.assertRaisesRegex(TypeError, r'^find\b', s.find,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^rfind\(', s.rfind,
+        self.assertRaisesRegex(TypeError, r'^rfind\b', s.rfind,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^index\(', s.index,
+        self.assertRaisesRegex(TypeError, r'^index\b', s.index,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^rindex\(', s.rindex,
+        self.assertRaisesRegex(TypeError, r'^rindex\b', s.rindex,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^count\(', s.count,
+        self.assertRaisesRegex(TypeError, r'^count\b', s.count,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^startswith\(', s.startswith,
+        self.assertRaisesRegex(TypeError, r'^startswith\b', s.startswith,
                                 x, None, None, None)
-        self.assertRaisesRegex(TypeError, r'^endswith\(', s.endswith,
+        self.assertRaisesRegex(TypeError, r'^endswith\b', s.endswith,
                                 x, None, None, None)
 
         # issue #15534
diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index 948bad1ca8..444ca2219c 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -6,8 +6,8 @@
 import contextlib
 import dataclasses
 import functools
-import getpass
-import opcode
+import logging
+import _opcode
 import os
 import re
 import stat
@@ -19,8 +19,6 @@
 import unittest
 import warnings
 
-from .testresult import get_test_runner
-
 
 __all__ = [
     # globals
@@ -29,12 +27,11 @@
     "Error", "TestFailed", "TestDidNotRun", "ResourceDenied",
     # io
     "record_original_stdout", "get_original_stdout", "captured_stdout",
-    "captured_stdin", "captured_stderr",
+    "captured_stdin", "captured_stderr", "captured_output",
     # unittest
     "is_resource_enabled", "requires", "requires_freebsd_version",
-    "requires_linux_version", "requires_mac_ver",
+    "requires_gil_enabled", "requires_linux_version", "requires_mac_ver",
     "check_syntax_error",
-    "run_unittest", "run_doctest",
     "requires_gzip", "requires_bz2", "requires_lzma",
     "bigmemtest", "bigaddrspacetest", "cpython_only", "get_attribute",
     "requires_IEEE_754", "requires_zlib",
@@ -46,8 +43,8 @@
     "check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer",
     "requires_limited_api", "requires_specialization",
     # sys
-    "is_jython", "is_android", "is_emscripten", "is_wasi",
-    "check_impl_detail", "unix_shell", "setswitchinterval",
+    "MS_WINDOWS", "is_jython", "is_android", "is_emscripten", "is_wasi",
+    "is_apple_mobile", "check_impl_detail", "unix_shell", "setswitchinterval",
     # os
     "get_pagesize",
     # network
@@ -60,8 +57,13 @@
     "run_with_tz", "PGO", "missing_compiler_executable",
     "ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",
     "LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",
-    "Py_DEBUG", "EXCEEDS_RECURSION_LIMIT", "C_RECURSION_LIMIT",
+    "Py_DEBUG", "exceeds_recursion_limit", "get_c_recursion_limit",
     "skip_on_s390x",
+    "without_optimizer",
+    "force_not_colorized",
+    "force_not_colorized_test_class",
+    "make_clean_env",
+    "BrokenIter",
     ]
 
 
@@ -107,6 +109,7 @@
 STDLIB_DIR = os.path.dirname(TEST_HOME_DIR)
 REPO_ROOT = os.path.dirname(STDLIB_DIR)
 
+
 class Error(Exception):
     """Base class for regression test exceptions."""
 
@@ -302,6 +305,16 @@ def requires(resource, msg=None):
     if resource == 'gui' and not _is_gui_available():
         raise ResourceDenied(_is_gui_available.reason)
 
+def _get_kernel_version(sysname="Linux"):
+    import platform
+    if platform.system() != sysname:
+        return None
+    version_txt = platform.release().split('-', 1)[0]
+    try:
+        return tuple(map(int, version_txt.split('.')))
+    except ValueError:
+        return None
+
 def _requires_unix_version(sysname, min_version):
     """Decorator raising SkipTest if the OS is `sysname` and the version is less
     than `min_version`.
@@ -384,7 +397,7 @@ def skip_if_buildbot(reason=None):
     try:
         isbuildbot = getpass.getuser().lower() == 'buildbot'
     except (KeyError, OSError) as err:
-        warnings.warn(f'getpass.getuser() failed {err}.', RuntimeWarning)
+        logging.getLogger(__name__).warning('getpass.getuser() failed %s.', err, exc_info=err)
         isbuildbot = False
     return unittest.skipIf(isbuildbot, reason)
 
@@ -498,8 +511,7 @@ def requires_lzma(reason='requires lzma'):
         import lzma
     except ImportError:
         lzma = None
-    # XXX: RUSTPYTHON; xz is not supported yet
-    lzma = None
+    lzma = None # XXX: RUSTPYTHON; xz is not supported yet
     return unittest.skipUnless(lzma, reason)
 
 def has_no_debug_ranges():
@@ -511,27 +523,50 @@ def has_no_debug_ranges():
     return not bool(config['code_debug_ranges'])
 
 def requires_debug_ranges(reason='requires co_positions / debug_ranges'):
-    return unittest.skipIf(has_no_debug_ranges(), reason)
+    try:
+        skip = has_no_debug_ranges()
+    except unittest.SkipTest as e:
+        skip = True
+        reason = e.args[0] if e.args else reason
+    return unittest.skipIf(skip, reason)
 
-@contextlib.contextmanager
-def suppress_immortalization(suppress=True):
-    """Suppress immortalization of deferred objects."""
+
+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:
-        yield
-        return
+        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
+        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
@@ -807,28 +842,47 @@ def gc_collect():
     longer than expected.  This function tries its best to force all garbage
     objects to disappear.
     """
-    # TODO: RUSTPYTHON (comment out before)
-    # import gc
-    # gc.collect()
-    # if is_jython:
-    #     time.sleep(0.1)
-    # gc.collect()
-    # gc.collect()
-    pass
+    return # TODO: RUSTPYTHON
+
+    import gc
+    gc.collect()
+    gc.collect()
+    gc.collect()
 
 @contextlib.contextmanager
 def disable_gc():
-    # TODO: RUSTPYTHON (comment out before)
-    # import gc
-    # have_gc = gc.isenabled()
-    # gc.disable()
-    # try:
-    #     yield
-    # finally:
-    #     if have_gc:
-    #         gc.enable()
-    yield
+    # TODO: RUSTPYTHON; GC is not supported yet
+    try:
+        yield
+    finally:
+        pass
+    return
+
+    import gc
+    have_gc = gc.isenabled()
+    gc.disable()
+    try:
+        yield
+    finally:
+        if have_gc:
+            gc.enable()
 
+@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)
+    try:
+        yield
+    finally:
+        gc.set_threshold(*old_threshold)
 
 def python_is_optimized():
     """Find if Python was built with optimizations."""
@@ -837,14 +891,57 @@ def python_is_optimized():
     for opt in cflags.split():
         if opt.startswith('-O'):
             final_opt = opt
-    return final_opt not in ('', '-O0', '-Og')
+    if sysconfig.get_config_var("CC") == "gcc":
+        non_opts = ('', '-O0', '-Og')
+    else:
+        non_opts = ('', '-O0')
+    return final_opt not in non_opts
+
+
+def check_cflags_pgo():
+    # Check if Python was built with ./configure --enable-optimizations:
+    # with Profile Guided Optimization (PGO).
+    cflags_nodist = sysconfig.get_config_var('PY_CFLAGS_NODIST') or ''
+    pgo_options = [
+        # GCC
+        '-fprofile-use',
+        # clang: -fprofile-instr-use=code.profclangd
+        '-fprofile-instr-use',
+        # ICC
+        "-prof-use",
+    ]
+    PGO_PROF_USE_FLAG = sysconfig.get_config_var('PGO_PROF_USE_FLAG')
+    if PGO_PROF_USE_FLAG:
+        pgo_options.append(PGO_PROF_USE_FLAG)
+    return any(option in cflags_nodist for option in pgo_options)
+
+
+def check_bolt_optimized():
+    # Always return false, if the platform is WASI,
+    # because BOLT optimization does not support WASM binary.
+    if is_wasi:
+        return False
+    config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''
+    return '--enable-bolt' in config_args
+
 
+Py_GIL_DISABLED = bool(sysconfig.get_config_var('Py_GIL_DISABLED'))
 
-_header = 'nP'
+def requires_gil_enabled(msg="needs the GIL enabled"):
+    """Decorator for skipping tests on the free-threaded build."""
+    return unittest.skipIf(Py_GIL_DISABLED, msg)
+
+def expected_failure_if_gil_disabled():
+    """Expect test failure if the GIL is disabled."""
+    if Py_GIL_DISABLED:
+        return unittest.expectedFailure
+    return lambda test_case: test_case
+
+if Py_GIL_DISABLED:
+    _header = 'PHBBInP'
+else:
+    _header = 'nP'
 _align = '0n'
-if hasattr(sys, "getobjects"):
-    _header = '2P' + _header
-    _align = '0P'
 _vheader = _header + 'n'
 
 def calcobjsize(fmt):
@@ -873,9 +970,34 @@ def check_sizeof(test, o, size):
             % (type(o), result, size)
     test.assertEqual(result, size, msg)
 
+def subTests(arg_names, arg_values, /, *, _do_cleanups=False):
+    """Run multiple subtests with different parameters.
+    """
+    single_param = False
+    if isinstance(arg_names, str):
+        arg_names = arg_names.replace(',',' ').split()
+        if len(arg_names) == 1:
+            single_param = True
+    arg_values = tuple(arg_values)
+    def decorator(func):
+        if isinstance(func, type):
+            raise TypeError('subTests() can only decorate methods, not classes')
+        @functools.wraps(func)
+        def wrapper(self, /, *args, **kwargs):
+            for values in arg_values:
+                if single_param:
+                    values = (values,)
+                subtest_kwargs = dict(zip(arg_names, values))
+                with self.subTest(**subtest_kwargs):
+                    func(self, *args, **kwargs, **subtest_kwargs)
+                if _do_cleanups:
+                    self.doCleanups()
+        return wrapper
+    return decorator
+
 #=======================================================================
-# Decorator for running a function in a different locale, correctly resetting
-# it afterwards.
+# Decorator/context manager for running a code in a different locale,
+# correctly resetting it afterwards.
 
 @contextlib.contextmanager
 def run_with_locale(catstr, *locales):
@@ -886,16 +1008,21 @@ def run_with_locale(catstr, *locales):
     except AttributeError:
         # if the test author gives us an invalid category string
         raise
-    except:
+    except Exception:
         # cannot retrieve original locale, so do nothing
         locale = orig_locale = None
+        if '' not in locales:
+            raise unittest.SkipTest('no locales')
     else:
         for loc in locales:
             try:
                 locale.setlocale(category, loc)
                 break
-            except:
+            except locale.Error:
                 pass
+        else:
+            if '' not in locales:
+                raise unittest.SkipTest(f'no locales {locales}')
 
     try:
         yield
@@ -903,6 +1030,46 @@ def run_with_locale(catstr, *locales):
         if locale and orig_locale:
             locale.setlocale(category, orig_locale)
 
+#=======================================================================
+# Decorator for running a function in multiple locales (if they are
+# availasble) and resetting the original locale afterwards.
+
+def run_with_locales(catstr, *locales):
+    def deco(func):
+        @functools.wraps(func)
+        def wrapper(self, /, *args, **kwargs):
+            dry_run = '' in locales
+            try:
+                import locale
+                category = getattr(locale, catstr)
+                orig_locale = locale.setlocale(category)
+            except AttributeError:
+                # if the test author gives us an invalid category string
+                raise
+            except Exception:
+                # cannot retrieve original locale, so do nothing
+                pass
+            else:
+                try:
+                    for loc in locales:
+                        with self.subTest(locale=loc):
+                            try:
+                                locale.setlocale(category, loc)
+                            except locale.Error:
+                                self.skipTest(f'no locale {loc!r}')
+                            else:
+                                dry_run = False
+                                func(self, *args, **kwargs)
+                finally:
+                    locale.setlocale(category, orig_locale)
+            if dry_run:
+                # no locales available, so just run the test
+                # with the current locale
+                with self.subTest(locale=None):
+                    func(self, *args, **kwargs)
+        return wrapper
+    return deco
+
 #=======================================================================
 # Decorator for running a function in a specific timezone, correctly
 # resetting it afterwards.
@@ -949,27 +1116,31 @@ def inner(*args, **kwds):
 
 MAX_Py_ssize_t = sys.maxsize
 
-def set_memlimit(limit):
-    global max_memuse
-    global real_max_memuse
+def _parse_memlimit(limit: str) -> int:
     sizes = {
         'k': 1024,
         'm': _1M,
         'g': _1G,
         't': 1024*_1G,
     }
-    m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
+    m = re.match(r'(\d+(?:\.\d+)?) (K|M|G|T)b?$', limit,
                  re.IGNORECASE | re.VERBOSE)
     if m is None:
-        raise ValueError('Invalid memory limit %r' % (limit,))
-    memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
-    real_max_memuse = memlimit
-    if memlimit > MAX_Py_ssize_t:
-        memlimit = MAX_Py_ssize_t
+        raise ValueError(f'Invalid memory limit: {limit!r}')
+    return int(float(m.group(1)) * sizes[m.group(2).lower()])
+
+def set_memlimit(limit: str) -> None:
+    global max_memuse
+    global real_max_memuse
+    memlimit = _parse_memlimit(limit)
     if memlimit < _2G - 1:
-        raise ValueError('Memory limit %r too low to be useful' % (limit,))
+        raise ValueError(f'Memory limit {limit!r} too low to be useful')
+
+    real_max_memuse = memlimit
+    memlimit = min(memlimit, MAX_Py_ssize_t)
     max_memuse = memlimit
 
+
 class _MemoryWatchdog:
     """An object which periodically watches the process' memory consumption
     and prints it out.
@@ -984,8 +1155,7 @@ def start(self):
         try:
             f = open(self.procfile, 'r')
         except OSError as e:
-            warnings.warn('/proc not available for stats: {}'.format(e),
-                          RuntimeWarning)
+            logging.getLogger(__name__).warning('/proc not available for stats: %s', e, exc_info=e)
             sys.stderr.flush()
             return
 
@@ -1122,18 +1292,30 @@ def check_impl_detail(**guards):
 
 def no_tracing(func):
     """Decorator to temporarily turn off tracing for the duration of a test."""
-    if not hasattr(sys, 'gettrace'):
-        return func
-    else:
+    trace_wrapper = func
+    if hasattr(sys, 'gettrace'):
         @functools.wraps(func)
-        def wrapper(*args, **kwargs):
+        def trace_wrapper(*args, **kwargs):
             original_trace = sys.gettrace()
             try:
                 sys.settrace(None)
                 return func(*args, **kwargs)
             finally:
                 sys.settrace(original_trace)
-        return wrapper
+
+    coverage_wrapper = trace_wrapper
+    if 'test.cov' in sys.modules:  # -Xpresite=test.cov used
+        cov = sys.monitoring.COVERAGE_ID
+        @functools.wraps(func)
+        def coverage_wrapper(*args, **kwargs):
+            original_events = sys.monitoring.get_events(cov)
+            try:
+                sys.monitoring.set_events(cov, 0)
+                return trace_wrapper(*args, **kwargs)
+            finally:
+                sys.monitoring.set_events(cov, original_events)
+
+    return coverage_wrapper
 
 
 def refcount_test(test):
@@ -1150,305 +1332,109 @@ def refcount_test(test):
 def requires_limited_api(test):
     try:
         import _testcapi
+        import _testlimitedcapi
     except ImportError:
-        return unittest.skip('needs _testcapi module')(test)
-    return unittest.skipUnless(
-        _testcapi.LIMITED_API_AVAILABLE, 'needs Limited API support')(test)
+        return unittest.skip('needs _testcapi and _testlimitedcapi modules')(test)
+    return test
+
+
+# Windows build doesn't support --disable-test-modules feature, so there's no
+# 'TEST_MODULES' var in config
+TEST_MODULES_ENABLED = (sysconfig.get_config_var('TEST_MODULES') or 'yes') == 'yes'
 
 def requires_specialization(test):
     return unittest.skipUnless(
-        opcode.ENABLE_SPECIALIZATION, "requires specialization")(test)
-
-def _filter_suite(suite, pred):
-    """Recursively filter test cases in a suite based on a predicate."""
-    newtests = []
-    for test in suite._tests:
-        if isinstance(test, unittest.TestSuite):
-            _filter_suite(test, pred)
-            newtests.append(test)
-        else:
-            if pred(test):
-                newtests.append(test)
-    suite._tests = newtests
+        _opcode.ENABLE_SPECIALIZATION, "requires specialization")(test)
 
-@dataclasses.dataclass(slots=True)
-class TestStats:
-    tests_run: int = 0
-    failures: int = 0
-    skipped: int = 0
 
-    @staticmethod
-    def from_unittest(result):
-        return TestStats(result.testsRun,
-                         len(result.failures),
-                         len(result.skipped))
+#=======================================================================
+# Check for the presence of docstrings.
 
-    @staticmethod
-    def from_doctest(results):
-        return TestStats(results.attempted,
-                         results.failed)
+# Rather than trying to enumerate all the cases where docstrings may be
+# disabled, we just check for that directly
 
-    def accumulate(self, stats):
-        self.tests_run += stats.tests_run
-        self.failures += stats.failures
-        self.skipped += stats.skipped
+def _check_docstrings():
+    """Just used to check if docstrings are enabled"""
 
+MISSING_C_DOCSTRINGS = (check_impl_detail() and
+                        sys.platform != 'win32' and
+                        not sysconfig.get_config_var('WITH_DOC_STRINGS'))
 
-def _run_suite(suite):
-    """Run tests from a unittest.TestSuite-derived class."""
-    runner = get_test_runner(sys.stdout,
-                             verbosity=verbose,
-                             capture_output=(junit_xml_list is not None))
+HAVE_PY_DOCSTRINGS = _check_docstrings.__doc__ is not None
+HAVE_DOCSTRINGS = (HAVE_PY_DOCSTRINGS and not MISSING_C_DOCSTRINGS)
 
-    result = runner.run(suite)
+requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
+                                          "test requires docstrings")
 
-    if junit_xml_list is not None:
-        junit_xml_list.append(result.get_xml_element())
 
-    if not result.testsRun and not result.skipped and not result.errors:
-        raise TestDidNotRun
-    if not result.wasSuccessful():
-        stats = TestStats.from_unittest(result)
-        if len(result.errors) == 1 and not result.failures:
-            err = result.errors[0][1]
-        elif len(result.failures) == 1 and not result.errors:
-            err = result.failures[0][1]
-        else:
-            err = "multiple errors occurred"
-            if not verbose: err += "; run in verbose mode for details"
-        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
-        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
-        raise TestFailedWithDetails(err, errors, failures, stats=stats)
-    return result
+#=======================================================================
+# Support for saving and restoring the imported modules.
 
+def flush_std_streams():
+    if sys.stdout is not None:
+        sys.stdout.flush()
+    if sys.stderr is not None:
+        sys.stderr.flush()
 
-# By default, don't filter tests
-_match_test_func = None
 
-_accept_test_patterns = None
-_ignore_test_patterns = None
+def print_warning(msg):
+    # bpo-45410: Explicitly flush stdout to keep logs in order
+    flush_std_streams()
+    stream = print_warning.orig_stderr
+    for line in msg.splitlines():
+        print(f"Warning -- {line}", file=stream)
+    stream.flush()
 
+# bpo-39983: Store the original sys.stderr at Python startup to be able to
+# log warnings even if sys.stderr is captured temporarily by a test.
+print_warning.orig_stderr = sys.stderr
 
-def match_test(test):
-    # Function used by support.run_unittest() and regrtest --list-cases
-    if _match_test_func is None:
-        return True
-    else:
-        return _match_test_func(test.id())
 
+# Flag used by saved_test_environment of test.libregrtest.save_env,
+# to check if a test modified the environment. The flag should be set to False
+# before running a new test.
+#
+# For example, threading_helper.threading_cleanup() sets the flag is the function fails
+# to cleanup threads.
+environment_altered = False
 
-def _is_full_match_test(pattern):
-    # If a pattern contains at least one dot, it's considered
-    # as a full test identifier.
-    # Example: 'test.test_os.FileTests.test_access'.
-    #
-    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
-    # or '[!...]'. For example, ignore 'test_access*'.
-    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
+def reap_children():
+    """Use this function at the end of test_main() whenever sub-processes
+    are started.  This will help ensure that no extra children (zombies)
+    stick around to hog resources and create problems when looking
+    for refleaks.
+    """
+    global environment_altered
 
+    # Need os.waitpid(-1, os.WNOHANG): Windows is not supported
+    if not (hasattr(os, 'waitpid') and hasattr(os, 'WNOHANG')):
+        return
+    elif not has_subprocess_support:
+        return
 
-def set_match_tests(accept_patterns=None, ignore_patterns=None):
-    global _match_test_func, _accept_test_patterns, _ignore_test_patterns
+    # Reap all our dead child processes so we don't leave zombies around.
+    # These hog resources and might be causing some of the buildbots to die.
+    while True:
+        try:
+            # Read the exit status of any child process which already completed
+            pid, status = os.waitpid(-1, os.WNOHANG)
+        except OSError:
+            break
 
-    if accept_patterns is None:
-        accept_patterns = ()
-    if ignore_patterns is None:
-        ignore_patterns = ()
+        if pid == 0:
+            break
 
-    accept_func = ignore_func = None
+        print_warning(f"reap_children() reaped child process {pid}")
+        environment_altered = True
 
-    if accept_patterns != _accept_test_patterns:
-        accept_patterns, accept_func = _compile_match_function(accept_patterns)
-    if ignore_patterns != _ignore_test_patterns:
-        ignore_patterns, ignore_func = _compile_match_function(ignore_patterns)
 
-    # Create a copy since patterns can be mutable and so modified later
-    _accept_test_patterns = tuple(accept_patterns)
-    _ignore_test_patterns = tuple(ignore_patterns)
+@contextlib.contextmanager
+def swap_attr(obj, attr, new_val):
+    """Temporary swap out an attribute with a new object.
 
-    if accept_func is not None or ignore_func is not None:
-        def match_function(test_id):
-            accept = True
-            ignore = False
-            if accept_func:
-                accept = accept_func(test_id)
-            if ignore_func:
-                ignore = ignore_func(test_id)
-            return accept and not ignore
-
-        _match_test_func = match_function
-
-
-def _compile_match_function(patterns):
-    if not patterns:
-        func = None
-        # set_match_tests(None) behaves as set_match_tests(())
-        patterns = ()
-    elif all(map(_is_full_match_test, patterns)):
-        # Simple case: all patterns are full test identifier.
-        # The test.bisect_cmd utility only uses such full test identifiers.
-        func = set(patterns).__contains__
-    else:
-        import fnmatch
-        regex = '|'.join(map(fnmatch.translate, patterns))
-        # The search *is* case sensitive on purpose:
-        # don't use flags=re.IGNORECASE
-        regex_match = re.compile(regex).match
-
-        def match_test_regex(test_id):
-            if regex_match(test_id):
-                # The regex matches the whole identifier, for example
-                # 'test.test_os.FileTests.test_access'.
-                return True
-            else:
-                # Try to match parts of the test identifier.
-                # For example, split 'test.test_os.FileTests.test_access'
-                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
-                return any(map(regex_match, test_id.split(".")))
-
-        func = match_test_regex
-
-    return patterns, func
-
-
-def run_unittest(*classes):
-    """Run tests from unittest.TestCase-derived classes."""
-    valid_types = (unittest.TestSuite, unittest.TestCase)
-    loader = unittest.TestLoader()
-    suite = unittest.TestSuite()
-    for cls in classes:
-        if isinstance(cls, str):
-            if cls in sys.modules:
-                suite.addTest(loader.loadTestsFromModule(sys.modules[cls]))
-            else:
-                raise ValueError("str arguments must be keys in sys.modules")
-        elif isinstance(cls, valid_types):
-            suite.addTest(cls)
-        else:
-            suite.addTest(loader.loadTestsFromTestCase(cls))
-    _filter_suite(suite, match_test)
-    return _run_suite(suite)
-
-#=======================================================================
-# Check for the presence of docstrings.
-
-# Rather than trying to enumerate all the cases where docstrings may be
-# disabled, we just check for that directly
-
-def _check_docstrings():
-    """Just used to check if docstrings are enabled"""
-
-MISSING_C_DOCSTRINGS = (check_impl_detail() and
-                        sys.platform != 'win32' and
-                        not sysconfig.get_config_var('WITH_DOC_STRINGS'))
-
-HAVE_DOCSTRINGS = (_check_docstrings.__doc__ is not None and
-                   not MISSING_C_DOCSTRINGS)
-
-requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
-                                          "test requires docstrings")
-
-
-#=======================================================================
-# doctest driver.
-
-def run_doctest(module, verbosity=None, optionflags=0):
-    """Run doctest on the given module.  Return (#failures, #tests).
-
-    If optional argument verbosity is not specified (or is None), pass
-    support's belief about verbosity on to doctest.  Else doctest's
-    usual behavior is used (it searches sys.argv for -v).
-    """
-
-    import doctest
-
-    if verbosity is None:
-        verbosity = verbose
-    else:
-        verbosity = None
-
-    results = doctest.testmod(module,
-                             verbose=verbosity,
-                             optionflags=optionflags)
-    if results.failed:
-        stats = TestStats.from_doctest(results)
-        raise TestFailed(f"{results.failed} of {results.attempted} "
-                         f"doctests failed",
-                         stats=stats)
-    if verbose:
-        print('doctest (%s) ... %d tests with zero failures' %
-              (module.__name__, results.attempted))
-    return results
-
-
-#=======================================================================
-# Support for saving and restoring the imported modules.
-
-def flush_std_streams():
-    if sys.stdout is not None:
-        sys.stdout.flush()
-    if sys.stderr is not None:
-        sys.stderr.flush()
-
-
-def print_warning(msg):
-    # bpo-45410: Explicitly flush stdout to keep logs in order
-    flush_std_streams()
-    stream = print_warning.orig_stderr
-    for line in msg.splitlines():
-        print(f"Warning -- {line}", file=stream)
-    stream.flush()
-
-# bpo-39983: Store the original sys.stderr at Python startup to be able to
-# log warnings even if sys.stderr is captured temporarily by a test.
-print_warning.orig_stderr = sys.stderr
-
-
-# Flag used by saved_test_environment of test.libregrtest.save_env,
-# to check if a test modified the environment. The flag should be set to False
-# before running a new test.
-#
-# For example, threading_helper.threading_cleanup() sets the flag is the function fails
-# to cleanup threads.
-environment_altered = False
-
-def reap_children():
-    """Use this function at the end of test_main() whenever sub-processes
-    are started.  This will help ensure that no extra children (zombies)
-    stick around to hog resources and create problems when looking
-    for refleaks.
-    """
-    global environment_altered
-
-    # Need os.waitpid(-1, os.WNOHANG): Windows is not supported
-    if not (hasattr(os, 'waitpid') and hasattr(os, 'WNOHANG')):
-        return
-    elif not has_subprocess_support:
-        return
-
-    # Reap all our dead child processes so we don't leave zombies around.
-    # These hog resources and might be causing some of the buildbots to die.
-    while True:
-        try:
-            # Read the exit status of any child process which already completed
-            pid, status = os.waitpid(-1, os.WNOHANG)
-        except OSError:
-            break
-
-        if pid == 0:
-            break
-
-        print_warning(f"reap_children() reaped child process {pid}")
-        environment_altered = True
-
-
-@contextlib.contextmanager
-def swap_attr(obj, attr, new_val):
-    """Temporary swap out an attribute with a new object.
-
-    Usage:
-        with swap_attr(obj, "attr", 5):
-            ...
+    Usage:
+        with swap_attr(obj, "attr", 5):
+            ...
 
         This will set obj.attr to 5 for the duration of the with: block,
         restoring the old value at the end of the block. If `attr` doesn't
@@ -1686,7 +1672,7 @@ def check__all__(test_case, module, name_of_module=None, extra=(),
     'module'.
 
     The 'name_of_module' argument can specify (as a string or tuple thereof)
-    what module(s) an API could be defined in in order to be detected as a
+    what module(s) an API could be defined in order to be detected as a
     public API. One case for this is when 'module' imports part of its public
     API from other modules, possibly a C backend (like 'csv' and its '_csv').
 
@@ -1903,7 +1889,10 @@ def run_in_subinterp(code):
     module is enabled.
     """
     _check_tracemalloc()
-    import _testcapi
+    try:
+        import _testcapi
+    except ImportError:
+        raise unittest.SkipTest("requires _testcapi")
     return _testcapi.run_in_subinterp(code)
 
 
@@ -1913,11 +1902,25 @@ def run_in_subinterp_with_config(code, *, own_gil=None, **config):
     module is enabled.
     """
     _check_tracemalloc()
-    import _testcapi
+    try:
+        import _testinternalcapi
+    except ImportError:
+        raise unittest.SkipTest("requires _testinternalcapi")
     if own_gil is not None:
         assert 'gil' not in config, (own_gil, config)
-        config['gil'] = 2 if own_gil else 1
-    return _testcapi.run_in_subinterp_with_config(code, **config)
+        config['gil'] = 'own' if own_gil else 'shared'
+    else:
+        gil = config['gil']
+        if gil == 0:
+            config['gil'] = 'default'
+        elif gil == 1:
+            config['gil'] = 'shared'
+        elif gil == 2:
+            config['gil'] = 'own'
+        elif not isinstance(gil, str):
+            raise NotImplementedError(gil)
+    config = types.SimpleNamespace(**config)
+    return _testinternalcapi.run_in_subinterp_with_config(code, config)
 
 
 def _check_tracemalloc():
@@ -1933,24 +1936,31 @@ def _check_tracemalloc():
                                      "if tracemalloc module is tracing "
                                      "memory allocations")
 
-# TODO: RUSTPYTHON; GC is not supported yet
-# def check_free_after_iterating(test, iter, cls, args=()):
-#     class A(cls):
-#         def __del__(self):
-#             nonlocal done
-#             done = True
-#             try:
-#                 next(it)
-#             except StopIteration:
-#                 pass
-
-#     done = False
-#     it = iter(A(*args))
-#     # Issue 26494: Shouldn't crash
-#     test.assertRaises(StopIteration, next, it)
-#     # The sequence should be deallocated just after the end of iterating
-#     gc_collect()
-#     test.assertTrue(done)
+
+def check_free_after_iterating(test, iter, cls, args=()):
+    # TODO: RUSTPYTHON; GC is not supported yet
+    test.assertTrue(False)
+    return
+
+    done = False
+    def wrapper():
+        class A(cls):
+            def __del__(self):
+                nonlocal done
+                done = True
+                try:
+                    next(it)
+                except StopIteration:
+                    pass
+
+        it = iter(A(*args))
+        # Issue 26494: Shouldn't crash
+        test.assertRaises(StopIteration, next, it)
+
+    wrapper()
+    # The sequence should be deallocated just after the end of iterating
+    gc_collect()
+    test.assertTrue(done)
 
 
 def missing_compiler_executable(cmd_names=[]):
@@ -1962,8 +1972,9 @@ def missing_compiler_executable(cmd_names=[]):
     missing.
 
     """
-    from setuptools._distutils import ccompiler, sysconfig, spawn
+    from setuptools._distutils import ccompiler, sysconfig
     from setuptools import errors
+    import shutil
 
     compiler = ccompiler.new_compiler()
     sysconfig.customize_compiler(compiler)
@@ -1982,22 +1993,22 @@ def missing_compiler_executable(cmd_names=[]):
                     "the '%s' executable is not configured" % name
         elif not cmd:
             continue
-        if spawn.find_executable(cmd[0]) is None:
+        if shutil.which(cmd[0]) is None:
             return cmd[0]
 
 
-_is_android_emulator = None
+_old_android_emulator = None
 def setswitchinterval(interval):
     # Setting a very low gil interval on the Android emulator causes python
     # to hang (issue #26939).
-    minimum_interval = 1e-5
+    minimum_interval = 1e-4   # 100 us
     if is_android and interval < minimum_interval:
-        global _is_android_emulator
-        if _is_android_emulator is None:
-            import subprocess
-            _is_android_emulator = (subprocess.check_output(
-                               ['getprop', 'ro.kernel.qemu']).strip() == b'1')
-        if _is_android_emulator:
+        global _old_android_emulator
+        if _old_android_emulator is None:
+            import platform
+            av = platform.android_ver()
+            _old_android_emulator = av.is_emulator and av.api_level < 24
+        if _old_android_emulator:
             interval = minimum_interval
     return sys.setswitchinterval(interval)
 
@@ -2072,8 +2083,19 @@ def restore(self):
 
 
 def with_pymalloc():
-    import _testcapi
-    return _testcapi.WITH_PYMALLOC
+    try:
+        import _testcapi
+    except ImportError:
+        raise unittest.SkipTest("requires _testcapi")
+    return _testcapi.WITH_PYMALLOC and not Py_GIL_DISABLED
+
+
+def with_mimalloc():
+    try:
+        import _testcapi
+    except ImportError:
+        raise unittest.SkipTest("requires _testcapi")
+    return _testcapi.WITH_MIMALLOC
 
 
 class _ALWAYS_EQ:
@@ -2301,6 +2323,7 @@ def check_disallow_instantiation(testcase, tp, *args, **kwds):
         qualname = f"{name}"
     msg = f"cannot create '{re.escape(qualname)}' instances"
     testcase.assertRaisesRegex(TypeError, msg, tp, *args, **kwds)
+    testcase.assertRaisesRegex(TypeError, msg, tp.__new__, tp, *args, **kwds)
 
 def get_recursion_depth():
     """Get the recursion depth of the caller function.
@@ -2345,14 +2368,14 @@ def set_recursion_limit(limit):
     finally:
         sys.setrecursionlimit(original_limit)
 
-def infinite_recursion(max_depth=100):
-    """Set a lower limit for tests that interact with infinite recursions
-    (e.g test_ast.ASTHelpers_Test.test_recursion_direct) since on some
-    debug windows builds, due to not enough functions being inlined the
-    stack size might not handle the default recursion limit (1000). See
-    bpo-11105 for details."""
-    if max_depth < 3:
-        raise ValueError("max_depth must be at least 3, got {max_depth}")
+def infinite_recursion(max_depth=None):
+    if max_depth is None:
+        # Pick a number large enough to cause problems
+        # but not take too long for code that can handle
+        # very deep recursion.
+        max_depth = 20_000
+    elif max_depth < 3:
+        raise ValueError(f"max_depth must be at least 3, got {max_depth}")
     depth = get_recursion_depth()
     depth = max(depth - 1, 1)  # Ignore infinite_recursion() frame.
     limit = depth + max_depth
@@ -2412,11 +2435,13 @@ def _findwheel(pkgname):
     If set, the wheels are searched for in WHEEL_PKG_DIR (see ensurepip).
     Otherwise, they are searched for in the test directory.
     """
-    wheel_dir = sysconfig.get_config_var('WHEEL_PKG_DIR') or TEST_HOME_DIR
+    wheel_dir = sysconfig.get_config_var('WHEEL_PKG_DIR') or os.path.join(
+        TEST_HOME_DIR, 'wheeldata',
+    )
     filenames = os.listdir(wheel_dir)
     filenames = sorted(filenames, reverse=True)  # approximate "newest" first
     for filename in filenames:
-        # filename is like 'setuptools-67.6.1-py3-none-any.whl'
+        # filename is like 'setuptools-{version}-py3-none-any.whl'
         if not filename.endswith(".whl"):
             continue
         prefix = pkgname + '-'
@@ -2425,20 +2450,29 @@ def _findwheel(pkgname):
     raise FileNotFoundError(f"No wheel for {pkgname} found in {wheel_dir}")
 
 
-# Context manager that creates a virtual environment, install setuptools and wheel in it
-# and returns the path to the venv directory and the path to the python executable
+# Context manager that creates a virtual environment, install setuptools in it,
+# and returns the paths to the venv directory and the python executable
 @contextlib.contextmanager
-def setup_venv_with_pip_setuptools_wheel(venv_dir):
+def setup_venv_with_pip_setuptools(venv_dir):
     import subprocess
     from .os_helper import temp_cwd
 
+    def run_command(cmd):
+        if verbose:
+            import shlex
+            print()
+            print('Run:', ' '.join(map(shlex.quote, cmd)))
+            subprocess.run(cmd, check=True)
+        else:
+            subprocess.run(cmd,
+                           stdout=subprocess.PIPE,
+                           stderr=subprocess.STDOUT,
+                           check=True)
+
     with temp_cwd() as temp_dir:
         # Create virtual environment to get setuptools
         cmd = [sys.executable, '-X', 'dev', '-m', 'venv', venv_dir]
-        if verbose:
-            print()
-            print('Run:', ' '.join(cmd))
-        subprocess.run(cmd, check=True)
+        run_command(cmd)
 
         venv = os.path.join(temp_dir, venv_dir)
 
@@ -2449,14 +2483,11 @@ def setup_venv_with_pip_setuptools_wheel(venv_dir):
         else:
             python = os.path.join(venv, 'bin', python_exe)
 
-        cmd = [python, '-X', 'dev',
+        cmd = (python, '-X', 'dev',
                '-m', 'pip', 'install',
                _findwheel('setuptools'),
-               _findwheel('wheel')]
-        if verbose:
-            print()
-            print('Run:', ' '.join(cmd))
-        subprocess.run(cmd, check=True)
+               )
+        run_command(cmd)
 
         yield python
 
@@ -2579,6 +2610,46 @@ def sleeping_retry(timeout, err_msg=None, /,
         delay = min(delay * 2, max_delay)
 
 
+class CPUStopwatch:
+    """Context manager to roughly time a CPU-bound operation.
+
+    Disables GC. Uses CPU time if it can (i.e. excludes sleeps & time of
+    other processes).
+
+    N.B.:
+    - This *includes* time spent in other threads.
+    - Some systems only have a coarse resolution; check
+      stopwatch.clock_info.rseolution if.
+
+    Usage:
+
+    with ProcessStopwatch() as stopwatch:
+        ...
+    elapsed = stopwatch.seconds
+    resolution = stopwatch.clock_info.resolution
+    """
+    def __enter__(self):
+        get_time = time.process_time
+        clock_info = time.get_clock_info('process_time')
+        if get_time() <= 0:  # some platforms like WASM lack process_time()
+            get_time = time.monotonic
+            clock_info = time.get_clock_info('monotonic')
+        self.context = disable_gc()
+        self.context.__enter__()
+        self.get_time = get_time
+        self.clock_info = clock_info
+        self.start_time = get_time()
+        return self
+
+    def __exit__(self, *exc):
+        try:
+            end_time = self.get_time()
+        finally:
+            result = self.context.__exit__(*exc)
+        self.seconds = end_time - self.start_time
+        return result
+
+
 @contextlib.contextmanager
 def adjust_int_max_str_digits(max_digits):
     """Temporarily change the integer string conversion length limit."""
@@ -2589,33 +2660,139 @@ def adjust_int_max_str_digits(max_digits):
     finally:
         sys.set_int_max_str_digits(current)
 
-#For recursion tests, easily exceeds default recursion limit
-EXCEEDS_RECURSION_LIMIT = 5000
 
-# The default C recursion limit (from Include/cpython/pystate.h).
-C_RECURSION_LIMIT = 1500
+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 get_c_recursion_limit() * 3
+
 
 # Windows doesn't have os.uname() but it doesn't support s390x.
 is_s390x = hasattr(os, 'uname') and os.uname().machine == 's390x'
-skip_on_s390x = unittest.skipIf(hasattr(os, 'uname') and os.uname().machine == 's390x',
-                                'skipped on s390x')
-HAVE_ASAN_FORK_BUG = check_sanitizer(address=True)
+skip_on_s390x = unittest.skipIf(is_s390x, 'skipped on s390x')
+
+Py_TRACE_REFS = hasattr(sys, 'getobjects')
+
+# Decorator to disable optimizer while a function run
+def without_optimizer(func):
+    try:
+        from _testinternalcapi import get_optimizer, set_optimizer
+    except ImportError:
+        return func
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        save_opt = get_optimizer()
+        try:
+            set_optimizer(None)
+            return func(*args, **kwargs)
+        finally:
+            set_optimizer(save_opt)
+    return wrapper
+
+
+_BASE_COPY_SRC_DIR_IGNORED_NAMES = frozenset({
+    # SRC_DIR/.git
+    '.git',
+    # ignore all __pycache__/ sub-directories
+    '__pycache__',
+})
+
+# Ignore function for shutil.copytree() to copy the Python source code.
+def copy_python_src_ignore(path, names):
+    ignored = _BASE_COPY_SRC_DIR_IGNORED_NAMES
+    if os.path.basename(path) == 'Doc':
+        ignored |= {
+            # SRC_DIR/Doc/build/
+            'build',
+            # SRC_DIR/Doc/venv/
+            'venv',
+        }
+
+    # check if we are at the root of the source code
+    elif 'Modules' in names:
+        ignored |= {
+            # SRC_DIR/build/
+            'build',
+        }
+    return ignored
+
+
+def iter_builtin_types():
+    for obj in __builtins__.values():
+        if not isinstance(obj, type):
+            continue
+        cls = obj
+        if cls.__module__ != 'builtins':
+            continue
+        yield cls
+
+
+def iter_slot_wrappers(cls):
+    assert cls.__module__ == 'builtins', cls
+
+    def is_slot_wrapper(name, value):
+        if not isinstance(value, types.WrapperDescriptorType):
+            assert not repr(value).startswith('<slot wrapper '), (cls, name, value)
+            return False
+        assert repr(value).startswith('<slot wrapper '), (cls, name, value)
+        assert callable(value), (cls, name, value)
+        assert name.startswith('__') and name.endswith('__'), (cls, name, value)
+        return True
+
+    ns = vars(cls)
+    unused = set(ns)
+    for name in dir(cls):
+        if name in ns:
+            unused.remove(name)
+
+        try:
+            value = getattr(cls, name)
+        except AttributeError:
+            # It's as though it weren't in __dir__.
+            assert name in ('__annotate__', '__annotations__', '__abstractmethods__'), (cls, name)
+            if name in ns and is_slot_wrapper(name, ns[name]):
+                unused.add(name)
+            continue
+
+        if not name.startswith('__') or not name.endswith('__'):
+            assert not is_slot_wrapper(name, value), (cls, name, value)
+        if not is_slot_wrapper(name, value):
+            if name in ns:
+                assert not is_slot_wrapper(name, ns[name]), (cls, name, value, ns[name])
+        else:
+            if name in ns:
+                assert ns[name] is value, (cls, name, value, ns[name])
+                yield name, True
+            else:
+                yield name, False
+
+    for name in unused:
+        value = ns[name]
+        if is_slot_wrapper(cls, name, value):
+            yield name, True
+
 
-# From Cpython 3.13.5
 @contextlib.contextmanager
 def no_color():
     import _colorize
     from .os_helper import EnvironmentVarGuard
 
     with (
-        swap_attr(_colorize, "can_colorize", lambda file=None: False),
+        swap_attr(_colorize, "can_colorize", lambda *, file=None: False),
         EnvironmentVarGuard() as env,
     ):
         env.unset("FORCE_COLOR", "NO_COLOR", "PYTHON_COLORS")
         env.set("NO_COLOR", "1")
         yield
 
-# From Cpython 3.13.5
+
 def force_not_colorized(func):
     """Force the terminal not to be colorized."""
     @functools.wraps(func)
@@ -2625,7 +2802,36 @@ def wrapper(*args, **kwargs):
     return wrapper
 
 
-# From python 3.12.8
+def force_not_colorized_test_class(cls):
+    """Force the terminal not to be colorized for the entire test class."""
+    original_setUpClass = cls.setUpClass
+
+    @classmethod
+    @functools.wraps(cls.setUpClass)
+    def new_setUpClass(cls):
+        cls.enterClassContext(no_color())
+        original_setUpClass()
+
+    cls.setUpClass = new_setUpClass
+    return cls
+
+
+def make_clean_env() -> dict[str, str]:
+    clean_env = os.environ.copy()
+    for k in clean_env.copy():
+        if k.startswith("PYTHON"):
+            clean_env.pop(k)
+    clean_env.pop("FORCE_COLOR", None)
+    clean_env.pop("NO_COLOR", None)
+    return clean_env
+
+
+def initialized_with_pyrepl():
+    """Detect whether PyREPL was used during Python initialization."""
+    # If the main module has a __file__ attribute it's a Python module, which means PyREPL.
+    return hasattr(sys.modules["__main__"], "__file__")
+
+
 class BrokenIter:
     def __init__(self, init_raises=False, next_raises=False, iter_raises=False):
         if init_raises:
@@ -2641,3 +2847,224 @@ def __iter__(self):
         if self.iter_raises:
             1/0
         return self
+
+
+def linked_to_musl():
+    """
+    Test if the Python executable is linked to the musl C library.
+    """
+    if sys.platform != 'linux':
+        return False
+
+    import subprocess
+    exe = getattr(sys, '_base_executable', sys.executable)
+    cmd = ['ldd', exe]
+    try:
+        stdout = subprocess.check_output(cmd,
+                                         text=True,
+                                         stderr=subprocess.STDOUT)
+    except (OSError, subprocess.CalledProcessError):
+        return False
+    return ('musl' in stdout)
+
+
+# TODO: RUSTPYTHON
+# Every line of code below allowed us to update `Lib/test/support/__init__.py` without
+# needing to update `libregtest` and its dependencies.
+# Ideally we want to remove all code below and update `libregtest`.
+#
+# Code below was copied from: https://github.com/RustPython/RustPython/blob/9499d39f55b73535e2405bf208d5380241f79ada/Lib/test/support/__init__.py
+
+from .testresult import get_test_runner
+
+def _filter_suite(suite, pred):
+    """Recursively filter test cases in a suite based on a predicate."""
+    newtests = []
+    for test in suite._tests:
+        if isinstance(test, unittest.TestSuite):
+            _filter_suite(test, pred)
+            newtests.append(test)
+        else:
+            if pred(test):
+                newtests.append(test)
+    suite._tests = newtests
+
+# By default, don't filter tests
+_match_test_func = None
+
+_accept_test_patterns = None
+_ignore_test_patterns = None
+
+def match_test(test):
+    # Function used by support.run_unittest() and regrtest --list-cases
+    if _match_test_func is None:
+        return True
+    else:
+        return _match_test_func(test.id())
+
+def _is_full_match_test(pattern):
+    # If a pattern contains at least one dot, it's considered
+    # as a full test identifier.
+    # Example: 'test.test_os.FileTests.test_access'.
+    #
+    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
+    # or '[!...]'. For example, ignore 'test_access*'.
+    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
+
+def set_match_tests(accept_patterns=None, ignore_patterns=None):
+    global _match_test_func, _accept_test_patterns, _ignore_test_patterns
+
+    if accept_patterns is None:
+        accept_patterns = ()
+    if ignore_patterns is None:
+        ignore_patterns = ()
+
+    accept_func = ignore_func = None
+
+    if accept_patterns != _accept_test_patterns:
+        accept_patterns, accept_func = _compile_match_function(accept_patterns)
+    if ignore_patterns != _ignore_test_patterns:
+        ignore_patterns, ignore_func = _compile_match_function(ignore_patterns)
+
+    # Create a copy since patterns can be mutable and so modified later
+    _accept_test_patterns = tuple(accept_patterns)
+    _ignore_test_patterns = tuple(ignore_patterns)
+
+    if accept_func is not None or ignore_func is not None:
+        def match_function(test_id):
+            accept = True
+            ignore = False
+            if accept_func:
+                accept = accept_func(test_id)
+            if ignore_func:
+                ignore = ignore_func(test_id)
+            return accept and not ignore
+
+        _match_test_func = match_function
+
+def _compile_match_function(patterns):
+    if not patterns:
+        func = None
+        # set_match_tests(None) behaves as set_match_tests(())
+        patterns = ()
+    elif all(map(_is_full_match_test, patterns)):
+        # Simple case: all patterns are full test identifier.
+        # The test.bisect_cmd utility only uses such full test identifiers.
+        func = set(patterns).__contains__
+    else:
+        import fnmatch
+        regex = '|'.join(map(fnmatch.translate, patterns))
+        # The search *is* case sensitive on purpose:
+        # don't use flags=re.IGNORECASE
+        regex_match = re.compile(regex).match
+
+        def match_test_regex(test_id):
+            if regex_match(test_id):
+                # The regex matches the whole identifier, for example
+                # 'test.test_os.FileTests.test_access'.
+                return True
+            else:
+                # Try to match parts of the test identifier.
+                # For example, split 'test.test_os.FileTests.test_access'
+                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
+                return any(map(regex_match, test_id.split(".")))
+
+        func = match_test_regex
+
+    return patterns, func
+
+def run_unittest(*classes):
+    """Run tests from unittest.TestCase-derived classes."""
+    valid_types = (unittest.TestSuite, unittest.TestCase)
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    for cls in classes:
+        if isinstance(cls, str):
+            if cls in sys.modules:
+                suite.addTest(loader.loadTestsFromModule(sys.modules[cls]))
+            else:
+                raise ValueError("str arguments must be keys in sys.modules")
+        elif isinstance(cls, valid_types):
+            suite.addTest(cls)
+        else:
+            suite.addTest(loader.loadTestsFromTestCase(cls))
+    _filter_suite(suite, match_test)
+    return _run_suite(suite)
+
+def _run_suite(suite):
+    """Run tests from a unittest.TestSuite-derived class."""
+    runner = get_test_runner(sys.stdout,
+                             verbosity=verbose,
+                             capture_output=(junit_xml_list is not None))
+
+    result = runner.run(suite)
+
+    if junit_xml_list is not None:
+        junit_xml_list.append(result.get_xml_element())
+
+    if not result.testsRun and not result.skipped and not result.errors:
+        raise TestDidNotRun
+    if not result.wasSuccessful():
+        stats = TestStats.from_unittest(result)
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            err = "multiple errors occurred"
+            if not verbose: err += "; run in verbose mode for details"
+        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
+        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
+        raise TestFailedWithDetails(err, errors, failures, stats=stats)
+    return result
+
+@dataclasses.dataclass(slots=True)
+class TestStats:
+    tests_run: int = 0
+    failures: int = 0
+    skipped: int = 0
+
+    @staticmethod
+    def from_unittest(result):
+        return TestStats(result.testsRun,
+                         len(result.failures),
+                         len(result.skipped))
+
+    @staticmethod
+    def from_doctest(results):
+        return TestStats(results.attempted,
+                         results.failed)
+
+    def accumulate(self, stats):
+        self.tests_run += stats.tests_run
+        self.failures += stats.failures
+        self.skipped += stats.skipped
+
+
+def run_doctest(module, verbosity=None, optionflags=0):
+    """Run doctest on the given module.  Return (#failures, #tests).
+
+    If optional argument verbosity is not specified (or is None), pass
+    support's belief about verbosity on to doctest.  Else doctest's
+    usual behavior is used (it searches sys.argv for -v).
+    """
+
+    import doctest
+
+    if verbosity is None:
+        verbosity = verbose
+    else:
+        verbosity = None
+
+    results = doctest.testmod(module,
+                             verbose=verbosity,
+                             optionflags=optionflags)
+    if results.failed:
+        stats = TestStats.from_doctest(results)
+        raise TestFailed(f"{results.failed} of {results.attempted} "
+                         f"doctests failed",
+                         stats=stats)
+    if verbose:
+        print('doctest (%s) ... %d tests with zero failures' %
+              (module.__name__, results.attempted))
+    return results
diff --git a/Lib/test/support/bytecode_helper.py b/Lib/test/support/bytecode_helper.py
index 388d126677..85bcd1f0f1 100644
--- a/Lib/test/support/bytecode_helper.py
+++ b/Lib/test/support/bytecode_helper.py
@@ -3,10 +3,26 @@
 import unittest
 import dis
 import io
-from _testinternalcapi import compiler_codegen, optimize_cfg, assemble_code_object
+import opcode
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
 
 _UNSPECIFIED = object()
 
+def instructions_with_positions(instrs, co_positions):
+    # Return (instr, positions) pairs from the instrs list and co_positions
+    # iterator. The latter contains items for cache lines and the former
+    # doesn't, so those need to be skipped.
+
+    co_positions = co_positions or iter(())
+    for instr in instrs:
+        yield instr, next(co_positions, ())
+        for _, size, _ in (instr.cache_info or ()):
+            for i in range(size):
+                next(co_positions, ())
+
 class BytecodeTestCase(unittest.TestCase):
     """Custom assertion methods for inspecting bytecode."""
 
@@ -53,16 +69,14 @@ class CompilationStepTestCase(unittest.TestCase):
     class Label:
         pass
 
-    def assertInstructionsMatch(self, actual_, expected_):
-        # get two lists where each entry is a label or
-        # an instruction tuple. Normalize the labels to the
-        # instruction count of the target, and compare the lists.
-
-        self.assertIsInstance(actual_, list)
-        self.assertIsInstance(expected_, list)
+    def assertInstructionsMatch(self, actual_seq, expected):
+        # get an InstructionSequence and an expected list, where each
+        # entry is a label or an instruction tuple. Construct an expcted
+        # instruction sequence and compare with the one given.
 
-        actual = self.normalize_insts(actual_)
-        expected = self.normalize_insts(expected_)
+        self.assertIsInstance(expected, list)
+        actual = actual_seq.get_instructions()
+        expected = self.seq_from_insts(expected).get_instructions()
         self.assertEqual(len(actual), len(expected))
 
         # compare instructions
@@ -72,10 +86,8 @@ def assertInstructionsMatch(self, actual_, expected_):
                 continue
             self.assertIsInstance(exp, tuple)
             self.assertIsInstance(act, tuple)
-            # crop comparison to the provided expected values
-            if len(act) > len(exp):
-                act = act[:len(exp)]
-            self.assertEqual(exp, act)
+            idx = max([p[0] for p in enumerate(exp) if p[1] != -1])
+            self.assertEqual(exp[:idx], act[:idx])
 
     def resolveAndRemoveLabels(self, insts):
         idx = 0
@@ -90,54 +102,57 @@ def resolveAndRemoveLabels(self, insts):
 
         return res
 
-    def normalize_insts(self, insts):
-        """ Map labels to instruction index.
-            Map opcodes to opnames.
-        """
-        insts = self.resolveAndRemoveLabels(insts)
-        res = []
-        for item in insts:
-            assert isinstance(item, tuple)
-            opcode, oparg, *loc = item
-            opcode = dis.opmap.get(opcode, opcode)
-            if isinstance(oparg, self.Label):
-                arg = oparg.value
-            else:
-                arg = oparg if opcode in self.HAS_ARG else None
-            opcode = dis.opname[opcode]
-            res.append((opcode, arg, *loc))
-        return res
+    def seq_from_insts(self, insts):
+        labels = {item for item in insts if isinstance(item, self.Label)}
+        for i, lbl in enumerate(labels):
+            lbl.value = i
 
-    def complete_insts_info(self, insts):
-        # fill in omitted fields in location, and oparg 0 for ops with no arg.
-        res = []
+        seq = _testinternalcapi.new_instruction_sequence()
         for item in insts:
-            assert isinstance(item, tuple)
-            inst = list(item)
-            opcode = dis.opmap[inst[0]]
-            oparg = inst[1]
-            loc = inst[2:] + [-1] * (6 - len(inst))
-            res.append((opcode, oparg, *loc))
-        return res
+            if isinstance(item, self.Label):
+                seq.use_label(item.value)
+            else:
+                op = item[0]
+                if isinstance(op, str):
+                    op = opcode.opmap[op]
+                arg, *loc = item[1:]
+                if isinstance(arg, self.Label):
+                    arg = arg.value
+                loc = loc + [-1] * (4 - len(loc))
+                seq.addop(op, arg or 0, *loc)
+        return seq
+
+    def check_instructions(self, insts):
+        for inst in insts:
+            if isinstance(inst, self.Label):
+                continue
+            op, arg, *loc = inst
+            if isinstance(op, str):
+                op = opcode.opmap[op]
+            self.assertEqual(op in opcode.hasarg,
+                             arg is not None,
+                             f"{opcode.opname[op]=} {arg=}")
+            self.assertTrue(all(isinstance(l, int) for l in loc))
 
 
+@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
 class CodegenTestCase(CompilationStepTestCase):
 
     def generate_code(self, ast):
-        insts, _ = compiler_codegen(ast, "my_file.py", 0)
+        insts, _ = _testinternalcapi.compiler_codegen(ast, "my_file.py", 0)
         return insts
 
 
+@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
 class CfgOptimizationTestCase(CompilationStepTestCase):
 
-    def get_optimized(self, insts, consts, nlocals=0):
-        insts = self.normalize_insts(insts)
-        insts = self.complete_insts_info(insts)
-        insts = optimize_cfg(insts, consts, nlocals)
+    def get_optimized(self, seq, consts, nlocals=0):
+        insts = _testinternalcapi.optimize_cfg(seq, consts, nlocals)
         return insts, consts
 
+@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
 class AssemblerTestCase(CompilationStepTestCase):
 
     def get_code_object(self, filename, insts, metadata):
-        co = assemble_code_object(filename, insts, metadata)
+        co = _testinternalcapi.assemble_code_object(filename, insts, metadata)
         return co
diff --git a/Lib/test/support/hypothesis_helper.py b/Lib/test/support/hypothesis_helper.py
index 40f58a2f59..a99a4963ff 100644
--- a/Lib/test/support/hypothesis_helper.py
+++ b/Lib/test/support/hypothesis_helper.py
@@ -7,7 +7,8 @@
 else:
     # Regrtest changes to use a tempdir as the working directory, so we have
     # to tell Hypothesis to use the original in order to persist the database.
-    from .os_helper import SAVEDCWD
+    from test.support import has_socket_support
+    from test.support.os_helper import SAVEDCWD
     from hypothesis.configuration import set_hypothesis_home_dir
 
     set_hypothesis_home_dir(os.path.join(SAVEDCWD, ".hypothesis"))
@@ -28,7 +29,14 @@
     # of failing examples, and also use a pull-through cache to automatically
     # replay any failing examples discovered in CI.  For details on how this
     # works, see https://hypothesis.readthedocs.io/en/latest/database.html
-    if "CI" not in os.environ:
+    # We only do that if a GITHUB_TOKEN env var is provided, see:
+    # https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens
+    # And Python is built with socket support:
+    if (
+        has_socket_support
+        and "CI" not in os.environ
+        and "GITHUB_TOKEN" in os.environ
+    ):
         from hypothesis.database import (
             GitHubArtifactDatabase,
             MultiplexedDatabase,
diff --git a/Lib/test/support/import_helper.py b/Lib/test/support/import_helper.py
index 67f18e530e..a4ea5bc6af 100644
--- a/Lib/test/support/import_helper.py
+++ b/Lib/test/support/import_helper.py
@@ -8,7 +8,7 @@
 import unittest
 import warnings
 
-from .os_helper import unlink
+from .os_helper import unlink, temp_dir
 
 
 @contextlib.contextmanager
@@ -58,8 +58,8 @@ def make_legacy_pyc(source):
     :return: The file system path to the legacy pyc file.
     """
     pyc_file = importlib.util.cache_from_source(source)
-    up_one = os.path.dirname(os.path.abspath(source))
-    legacy_pyc = os.path.join(up_one, source + 'c')
+    assert source.endswith('.py')
+    legacy_pyc = source + 'c'
     shutil.move(pyc_file, legacy_pyc)
     return legacy_pyc
 
@@ -114,7 +114,7 @@ def multi_interp_extensions_check(enabled=True):
     This only applies to modules that haven't been imported yet.
     It overrides the PyInterpreterConfig.check_multi_interp_extensions
     setting (see support.run_in_subinterp_with_config() and
-    _xxsubinterpreters.create()).
+    _interpreters.create()).
 
     Also see importlib.utils.allowing_all_extensions().
     """
@@ -268,9 +268,44 @@ def modules_cleanup(oldmodules):
     sys.modules.update(oldmodules)
 
 
+@contextlib.contextmanager
+def isolated_modules():
+    """
+    Save modules on entry and cleanup on exit.
+    """
+    (saved,) = modules_setup()
+    try:
+        yield
+    finally:
+        modules_cleanup(saved)
+
+
 def mock_register_at_fork(func):
     # bpo-30599: Mock os.register_at_fork() when importing the random module,
     # since this function doesn't allow to unregister callbacks and would leak
     # memory.
     from unittest import mock
     return mock.patch('os.register_at_fork', create=True)(func)
+
+
+@contextlib.contextmanager
+def ready_to_import(name=None, source=""):
+    from test.support import script_helper
+
+    # 1. Sets up a temporary directory and removes it afterwards
+    # 2. Creates the module file
+    # 3. Temporarily clears the module from sys.modules (if any)
+    # 4. Reverts or removes the module when cleaning up
+    name = name or "spam"
+    with temp_dir() as tempdir:
+        path = script_helper.make_script(tempdir, name, source)
+        old_module = sys.modules.pop(name, None)
+        try:
+            sys.path.insert(0, tempdir)
+            yield name, path
+        finally:
+            sys.path.remove(tempdir)
+            if old_module is not None:
+                sys.modules[name] = old_module
+            else:
+                sys.modules.pop(name, None)
diff --git a/Lib/test/support/interpreters.py b/Lib/test/support/interpreters.py
deleted file mode 100644
index 5c484d1170..0000000000
--- a/Lib/test/support/interpreters.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Subinterpreters High Level Module."""
-
-import time
-import _xxsubinterpreters as _interpreters
-import _xxinterpchannels as _channels
-
-# aliases:
-from _xxsubinterpreters import is_shareable, RunFailedError
-from _xxinterpchannels import (
-    ChannelError, ChannelNotFoundError, ChannelEmptyError,
-)
-
-
-__all__ = [
-    'Interpreter', 'get_current', 'get_main', 'create', 'list_all',
-    'SendChannel', 'RecvChannel',
-    'create_channel', 'list_all_channels', 'is_shareable',
-    'ChannelError', 'ChannelNotFoundError',
-    'ChannelEmptyError',
-    ]
-
-
-def create(*, isolated=True):
-    """Return a new (idle) Python interpreter."""
-    id = _interpreters.create(isolated=isolated)
-    return Interpreter(id, isolated=isolated)
-
-
-def list_all():
-    """Return all existing interpreters."""
-    return [Interpreter(id) for id in _interpreters.list_all()]
-
-
-def get_current():
-    """Return the currently running interpreter."""
-    id = _interpreters.get_current()
-    return Interpreter(id)
-
-
-def get_main():
-    """Return the main interpreter."""
-    id = _interpreters.get_main()
-    return Interpreter(id)
-
-
-class Interpreter:
-    """A single Python interpreter."""
-
-    def __init__(self, id, *, isolated=None):
-        if not isinstance(id, (int, _interpreters.InterpreterID)):
-            raise TypeError(f'id must be an int, got {id!r}')
-        self._id = id
-        self._isolated = isolated
-
-    def __repr__(self):
-        data = dict(id=int(self._id), isolated=self._isolated)
-        kwargs = (f'{k}={v!r}' for k, v in data.items())
-        return f'{type(self).__name__}({", ".join(kwargs)})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __eq__(self, other):
-        if not isinstance(other, Interpreter):
-            return NotImplemented
-        else:
-            return other._id == self._id
-
-    @property
-    def id(self):
-        return self._id
-
-    @property
-    def isolated(self):
-        if self._isolated is None:
-            # XXX The low-level function has not been added yet.
-            # See bpo-....
-            self._isolated = _interpreters.is_isolated(self._id)
-        return self._isolated
-
-    def is_running(self):
-        """Return whether or not the identified interpreter is running."""
-        return _interpreters.is_running(self._id)
-
-    def close(self):
-        """Finalize and destroy the interpreter.
-
-        Attempting to destroy the current interpreter results
-        in a RuntimeError.
-        """
-        return _interpreters.destroy(self._id)
-
-    def run(self, src_str, /, *, channels=None):
-        """Run the given source code in the interpreter.
-
-        This blocks the current Python thread until done.
-        """
-        _interpreters.run_string(self._id, src_str, channels)
-
-
-def create_channel():
-    """Return (recv, send) for a new cross-interpreter channel.
-
-    The channel may be used to pass data safely between interpreters.
-    """
-    cid = _channels.create()
-    recv, send = RecvChannel(cid), SendChannel(cid)
-    return recv, send
-
-
-def list_all_channels():
-    """Return a list of (recv, send) for all open channels."""
-    return [(RecvChannel(cid), SendChannel(cid))
-            for cid in _channels.list_all()]
-
-
-class _ChannelEnd:
-    """The base class for RecvChannel and SendChannel."""
-
-    def __init__(self, id):
-        if not isinstance(id, (int, _channels.ChannelID)):
-            raise TypeError(f'id must be an int, got {id!r}')
-        self._id = id
-
-    def __repr__(self):
-        return f'{type(self).__name__}(id={int(self._id)})'
-
-    def __hash__(self):
-        return hash(self._id)
-
-    def __eq__(self, other):
-        if isinstance(self, RecvChannel):
-            if not isinstance(other, RecvChannel):
-                return NotImplemented
-        elif not isinstance(other, SendChannel):
-            return NotImplemented
-        return other._id == self._id
-
-    @property
-    def id(self):
-        return self._id
-
-
-_NOT_SET = object()
-
-
-class RecvChannel(_ChannelEnd):
-    """The receiving end of a cross-interpreter channel."""
-
-    def recv(self, *, _sentinel=object(), _delay=10 / 1000):  # 10 milliseconds
-        """Return the next object from the channel.
-
-        This blocks until an object has been sent, if none have been
-        sent already.
-        """
-        obj = _channels.recv(self._id, _sentinel)
-        while obj is _sentinel:
-            time.sleep(_delay)
-            obj = _channels.recv(self._id, _sentinel)
-        return obj
-
-    def recv_nowait(self, default=_NOT_SET):
-        """Return the next object from the channel.
-
-        If none have been sent then return the default if one
-        is provided or fail with ChannelEmptyError.  Otherwise this
-        is the same as recv().
-        """
-        if default is _NOT_SET:
-            return _channels.recv(self._id)
-        else:
-            return _channels.recv(self._id, default)
-
-
-class SendChannel(_ChannelEnd):
-    """The sending end of a cross-interpreter channel."""
-
-    def send(self, obj):
-        """Send the object (i.e. its data) to the channel's receiving end.
-
-        This blocks until the object is received.
-        """
-        _channels.send(self._id, obj)
-        # XXX We are missing a low-level channel_send_wait().
-        # See bpo-32604 and gh-19829.
-        # Until that shows up we fake it:
-        time.sleep(2)
-
-    def send_nowait(self, obj):
-        """Send the object to the channel's receiving end.
-
-        If the object is immediately received then return True
-        (else False).  Otherwise this is the same as send().
-        """
-        # XXX Note that at the moment channel_send() only ever returns
-        # None.  This should be fixed when channel_send_wait() is added.
-        # See bpo-32604 and gh-19829.
-        return _channels.send(self._id, obj)
diff --git a/Lib/test/support/interpreters/__init__.py b/Lib/test/support/interpreters/__init__.py
new file mode 100644
index 0000000000..e067f25936
--- /dev/null
+++ b/Lib/test/support/interpreters/__init__.py
@@ -0,0 +1,258 @@
+"""Subinterpreters High Level Module."""
+
+import threading
+import weakref
+import _interpreters
+
+# aliases:
+from _interpreters import (
+    InterpreterError, InterpreterNotFoundError, NotShareableError,
+    is_shareable,
+)
+
+
+__all__ = [
+    'get_current', 'get_main', 'create', 'list_all', 'is_shareable',
+    'Interpreter',
+    'InterpreterError', 'InterpreterNotFoundError', 'ExecutionFailed',
+    'NotShareableError',
+    'create_queue', 'Queue', 'QueueEmpty', 'QueueFull',
+]
+
+
+_queuemod = None
+
+def __getattr__(name):
+    if name in ('Queue', 'QueueEmpty', 'QueueFull', 'create_queue'):
+        global create_queue, Queue, QueueEmpty, QueueFull
+        ns = globals()
+        from .queues import (
+            create as create_queue,
+            Queue, QueueEmpty, QueueFull,
+        )
+        return ns[name]
+    else:
+        raise AttributeError(name)
+
+
+_EXEC_FAILURE_STR = """
+{superstr}
+
+Uncaught in the interpreter:
+
+{formatted}
+""".strip()
+
+class ExecutionFailed(InterpreterError):
+    """An unhandled exception happened during execution.
+
+    This is raised from Interpreter.exec() and Interpreter.call().
+    """
+
+    def __init__(self, excinfo):
+        msg = excinfo.formatted
+        if not msg:
+            if excinfo.type and excinfo.msg:
+                msg = f'{excinfo.type.__name__}: {excinfo.msg}'
+            else:
+                msg = excinfo.type.__name__ or excinfo.msg
+        super().__init__(msg)
+        self.excinfo = excinfo
+
+    def __str__(self):
+        try:
+            formatted = self.excinfo.errdisplay
+        except Exception:
+            return super().__str__()
+        else:
+            return _EXEC_FAILURE_STR.format(
+                superstr=super().__str__(),
+                formatted=formatted,
+            )
+
+
+def create():
+    """Return a new (idle) Python interpreter."""
+    id = _interpreters.create(reqrefs=True)
+    return Interpreter(id, _ownsref=True)
+
+
+def list_all():
+    """Return all existing interpreters."""
+    return [Interpreter(id, _whence=whence)
+            for id, whence in _interpreters.list_all(require_ready=True)]
+
+
+def get_current():
+    """Return the currently running interpreter."""
+    id, whence = _interpreters.get_current()
+    return Interpreter(id, _whence=whence)
+
+
+def get_main():
+    """Return the main interpreter."""
+    id, whence = _interpreters.get_main()
+    assert whence == _interpreters.WHENCE_RUNTIME, repr(whence)
+    return Interpreter(id, _whence=whence)
+
+
+_known = weakref.WeakValueDictionary()
+
+class Interpreter:
+    """A single Python interpreter.
+
+    Attributes:
+
+    "id" - the unique process-global ID number for the interpreter
+    "whence" - indicates where the interpreter was created
+
+    If the interpreter wasn't created by this module
+    then any method that modifies the interpreter will fail,
+    i.e. .close(), .prepare_main(), .exec(), and .call()
+    """
+
+    _WHENCE_TO_STR = {
+       _interpreters.WHENCE_UNKNOWN: 'unknown',
+       _interpreters.WHENCE_RUNTIME: 'runtime init',
+       _interpreters.WHENCE_LEGACY_CAPI: 'legacy C-API',
+       _interpreters.WHENCE_CAPI: 'C-API',
+       _interpreters.WHENCE_XI: 'cross-interpreter C-API',
+       _interpreters.WHENCE_STDLIB: '_interpreters module',
+    }
+
+    def __new__(cls, id, /, _whence=None, _ownsref=None):
+        # There is only one instance for any given ID.
+        if not isinstance(id, int):
+            raise TypeError(f'id must be an int, got {id!r}')
+        id = int(id)
+        if _whence is None:
+            if _ownsref:
+                _whence = _interpreters.WHENCE_STDLIB
+            else:
+                _whence = _interpreters.whence(id)
+        assert _whence in cls._WHENCE_TO_STR, repr(_whence)
+        if _ownsref is None:
+            _ownsref = (_whence == _interpreters.WHENCE_STDLIB)
+        try:
+            self = _known[id]
+            assert hasattr(self, '_ownsref')
+        except KeyError:
+            self = super().__new__(cls)
+            _known[id] = self
+            self._id = id
+            self._whence = _whence
+            self._ownsref = _ownsref
+            if _ownsref:
+                # This may raise InterpreterNotFoundError:
+                _interpreters.incref(id)
+        return self
+
+    def __repr__(self):
+        return f'{type(self).__name__}({self.id})'
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __del__(self):
+        self._decref()
+
+    # for pickling:
+    def __getnewargs__(self):
+        return (self._id,)
+
+    # for pickling:
+    def __getstate__(self):
+        return None
+
+    def _decref(self):
+        if not self._ownsref:
+            return
+        self._ownsref = False
+        try:
+            _interpreters.decref(self._id)
+        except InterpreterNotFoundError:
+            pass
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def whence(self):
+        return self._WHENCE_TO_STR[self._whence]
+
+    def is_running(self):
+        """Return whether or not the identified interpreter is running."""
+        return _interpreters.is_running(self._id)
+
+    # Everything past here is available only to interpreters created by
+    # interpreters.create().
+
+    def close(self):
+        """Finalize and destroy the interpreter.
+
+        Attempting to destroy the current interpreter results
+        in an InterpreterError.
+        """
+        return _interpreters.destroy(self._id, restrict=True)
+
+    def prepare_main(self, ns=None, /, **kwargs):
+        """Bind the given values into the interpreter's __main__.
+
+        The values must be shareable.
+        """
+        ns = dict(ns, **kwargs) if ns is not None else kwargs
+        _interpreters.set___main___attrs(self._id, ns, restrict=True)
+
+    def exec(self, code, /):
+        """Run the given source code in the interpreter.
+
+        This is essentially the same as calling the builtin "exec"
+        with this interpreter, using the __dict__ of its __main__
+        module as both globals and locals.
+
+        There is no return value.
+
+        If the code raises an unhandled exception then an ExecutionFailed
+        exception is raised, which summarizes the unhandled exception.
+        The actual exception is discarded because objects cannot be
+        shared between interpreters.
+
+        This blocks the current Python thread until done.  During
+        that time, the previous interpreter is allowed to run
+        in other threads.
+        """
+        excinfo = _interpreters.exec(self._id, code, restrict=True)
+        if excinfo is not None:
+            raise ExecutionFailed(excinfo)
+
+    def call(self, callable, /):
+        """Call the object in the interpreter with given args/kwargs.
+
+        Only functions that take no arguments and have no closure
+        are supported.
+
+        The return value is discarded.
+
+        If the callable raises an exception then the error display
+        (including full traceback) is send back between the interpreters
+        and an ExecutionFailed exception is raised, much like what
+        happens with Interpreter.exec().
+        """
+        # XXX Support args and kwargs.
+        # XXX Support arbitrary callables.
+        # XXX Support returning the return value (e.g. via pickle).
+        excinfo = _interpreters.call(self._id, callable, restrict=True)
+        if excinfo is not None:
+            raise ExecutionFailed(excinfo)
+
+    def call_in_thread(self, callable, /):
+        """Return a new thread that calls the object in the interpreter.
+
+        The return value and any raised exception are discarded.
+        """
+        def task():
+            self.call(callable)
+        t = threading.Thread(target=task)
+        t.start()
+        return t
diff --git a/Lib/test/support/interpreters/_crossinterp.py b/Lib/test/support/interpreters/_crossinterp.py
new file mode 100644
index 0000000000..544e197ba4
--- /dev/null
+++ b/Lib/test/support/interpreters/_crossinterp.py
@@ -0,0 +1,102 @@
+"""Common code between queues and channels."""
+
+
+class ItemInterpreterDestroyed(Exception):
+    """Raised when trying to get an item whose interpreter was destroyed."""
+
+
+class classonly:
+    """A non-data descriptor that makes a value only visible on the class.
+
+    This is like the "classmethod" builtin, but does not show up on
+    instances of the class.  It may be used as a decorator.
+    """
+
+    def __init__(self, value):
+        self.value = value
+        self.getter = classmethod(value).__get__
+        self.name = None
+
+    def __set_name__(self, cls, name):
+        if self.name is not None:
+            raise TypeError('already used')
+        self.name = name
+
+    def __get__(self, obj, cls):
+        if obj is not None:
+            raise AttributeError(self.name)
+        # called on the class
+        return self.getter(None, cls)
+
+
+class UnboundItem:
+    """Represents a cross-interpreter item no longer bound to an interpreter.
+
+    An item is unbound when the interpreter that added it to the
+    cross-interpreter container is destroyed.
+    """
+
+    __slots__ = ()
+
+    @classonly
+    def singleton(cls, kind, module, name='UNBOUND'):
+        doc = cls.__doc__.replace('cross-interpreter container', kind)
+        doc = doc.replace('cross-interpreter', kind)
+        subclass = type(
+            f'Unbound{kind.capitalize()}Item',
+            (cls,),
+            dict(
+                _MODULE=module,
+                _NAME=name,
+                __doc__=doc,
+            ),
+        )
+        return object.__new__(subclass)
+
+    _MODULE = __name__
+    _NAME = 'UNBOUND'
+
+    def __new__(cls):
+        raise Exception(f'use {cls._MODULE}.{cls._NAME}')
+
+    def __repr__(self):
+        return f'{self._MODULE}.{self._NAME}'
+#        return f'interpreters.queues.UNBOUND'
+
+
+UNBOUND = object.__new__(UnboundItem)
+UNBOUND_ERROR = object()
+UNBOUND_REMOVE = object()
+
+_UNBOUND_CONSTANT_TO_FLAG = {
+    UNBOUND_REMOVE: 1,
+    UNBOUND_ERROR: 2,
+    UNBOUND: 3,
+}
+_UNBOUND_FLAG_TO_CONSTANT = {v: k
+                             for k, v in _UNBOUND_CONSTANT_TO_FLAG.items()}
+
+
+def serialize_unbound(unbound):
+    op = unbound
+    try:
+        flag = _UNBOUND_CONSTANT_TO_FLAG[op]
+    except KeyError:
+        raise NotImplementedError(f'unsupported unbound replacement op {op!r}')
+    return flag,
+
+
+def resolve_unbound(flag, exctype_destroyed):
+    try:
+        op = _UNBOUND_FLAG_TO_CONSTANT[flag]
+    except KeyError:
+        raise NotImplementedError(f'unsupported unbound replacement op {flag!r}')
+    if op is UNBOUND_REMOVE:
+        # "remove" not possible here
+        raise NotImplementedError
+    elif op is UNBOUND_ERROR:
+        raise exctype_destroyed("item's original interpreter destroyed")
+    elif op is UNBOUND:
+        return UNBOUND
+    else:
+        raise NotImplementedError(repr(op))
diff --git a/Lib/test/support/interpreters/channels.py b/Lib/test/support/interpreters/channels.py
new file mode 100644
index 0000000000..d2bd93d77f
--- /dev/null
+++ b/Lib/test/support/interpreters/channels.py
@@ -0,0 +1,257 @@
+"""Cross-interpreter Channels High Level Module."""
+
+import time
+import _interpchannels as _channels
+from . import _crossinterp
+
+# aliases:
+from _interpchannels import (
+    ChannelError, ChannelNotFoundError, ChannelClosedError,
+    ChannelEmptyError, ChannelNotEmptyError,
+)
+from ._crossinterp import (
+    UNBOUND_ERROR, UNBOUND_REMOVE,
+)
+
+
+__all__ = [
+    'UNBOUND', 'UNBOUND_ERROR', 'UNBOUND_REMOVE',
+    'create', 'list_all',
+    'SendChannel', 'RecvChannel',
+    'ChannelError', 'ChannelNotFoundError', 'ChannelEmptyError',
+    'ItemInterpreterDestroyed',
+]
+
+
+class ItemInterpreterDestroyed(ChannelError,
+                               _crossinterp.ItemInterpreterDestroyed):
+    """Raised from get() and get_nowait()."""
+
+
+UNBOUND = _crossinterp.UnboundItem.singleton('queue', __name__)
+
+
+def _serialize_unbound(unbound):
+    if unbound is UNBOUND:
+        unbound = _crossinterp.UNBOUND
+    return _crossinterp.serialize_unbound(unbound)
+
+
+def _resolve_unbound(flag):
+    resolved = _crossinterp.resolve_unbound(flag, ItemInterpreterDestroyed)
+    if resolved is _crossinterp.UNBOUND:
+        resolved = UNBOUND
+    return resolved
+
+
+def create(*, unbounditems=UNBOUND):
+    """Return (recv, send) for a new cross-interpreter channel.
+
+    The channel may be used to pass data safely between interpreters.
+
+    "unbounditems" sets the default for the send end of the channel.
+    See SendChannel.send() for supported values.  The default value
+    is UNBOUND, which replaces the unbound item when received.
+    """
+    unbound = _serialize_unbound(unbounditems)
+    unboundop, = unbound
+    cid = _channels.create(unboundop)
+    recv, send = RecvChannel(cid), SendChannel(cid, _unbound=unbound)
+    return recv, send
+
+
+def list_all():
+    """Return a list of (recv, send) for all open channels."""
+    return [(RecvChannel(cid), SendChannel(cid, _unbound=unbound))
+            for cid, unbound in _channels.list_all()]
+
+
+class _ChannelEnd:
+    """The base class for RecvChannel and SendChannel."""
+
+    _end = None
+
+    def __new__(cls, cid):
+        self = super().__new__(cls)
+        if self._end == 'send':
+            cid = _channels._channel_id(cid, send=True, force=True)
+        elif self._end == 'recv':
+            cid = _channels._channel_id(cid, recv=True, force=True)
+        else:
+            raise NotImplementedError(self._end)
+        self._id = cid
+        return self
+
+    def __repr__(self):
+        return f'{type(self).__name__}(id={int(self._id)})'
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __eq__(self, other):
+        if isinstance(self, RecvChannel):
+            if not isinstance(other, RecvChannel):
+                return NotImplemented
+        elif not isinstance(other, SendChannel):
+            return NotImplemented
+        return other._id == self._id
+
+    # for pickling:
+    def __getnewargs__(self):
+        return (int(self._id),)
+
+    # for pickling:
+    def __getstate__(self):
+        return None
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def _info(self):
+        return _channels.get_info(self._id)
+
+    @property
+    def is_closed(self):
+        return self._info.closed
+
+
+_NOT_SET = object()
+
+
+class RecvChannel(_ChannelEnd):
+    """The receiving end of a cross-interpreter channel."""
+
+    _end = 'recv'
+
+    def recv(self, timeout=None, *,
+             _sentinel=object(),
+             _delay=10 / 1000,  # 10 milliseconds
+             ):
+        """Return the next object from the channel.
+
+        This blocks until an object has been sent, if none have been
+        sent already.
+        """
+        if timeout is not None:
+            timeout = int(timeout)
+            if timeout < 0:
+                raise ValueError(f'timeout value must be non-negative')
+            end = time.time() + timeout
+        obj, unboundop = _channels.recv(self._id, _sentinel)
+        while obj is _sentinel:
+            time.sleep(_delay)
+            if timeout is not None and time.time() >= end:
+                raise TimeoutError
+            obj, unboundop = _channels.recv(self._id, _sentinel)
+        if unboundop is not None:
+            assert obj is None, repr(obj)
+            return _resolve_unbound(unboundop)
+        return obj
+
+    def recv_nowait(self, default=_NOT_SET):
+        """Return the next object from the channel.
+
+        If none have been sent then return the default if one
+        is provided or fail with ChannelEmptyError.  Otherwise this
+        is the same as recv().
+        """
+        if default is _NOT_SET:
+            obj, unboundop = _channels.recv(self._id)
+        else:
+            obj, unboundop = _channels.recv(self._id, default)
+        if unboundop is not None:
+            assert obj is None, repr(obj)
+            return _resolve_unbound(unboundop)
+        return obj
+
+    def close(self):
+        _channels.close(self._id, recv=True)
+
+
+class SendChannel(_ChannelEnd):
+    """The sending end of a cross-interpreter channel."""
+
+    _end = 'send'
+
+    def __new__(cls, cid, *, _unbound=None):
+        if _unbound is None:
+            try:
+                op = _channels.get_channel_defaults(cid)
+                _unbound = (op,)
+            except ChannelNotFoundError:
+                _unbound = _serialize_unbound(UNBOUND)
+        self = super().__new__(cls, cid)
+        self._unbound = _unbound
+        return self
+
+    @property
+    def is_closed(self):
+        info = self._info
+        return info.closed or info.closing
+
+    def send(self, obj, timeout=None, *,
+             unbound=None,
+             ):
+        """Send the object (i.e. its data) to the channel's receiving end.
+
+        This blocks until the object is received.
+        """
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        _channels.send(self._id, obj, unboundop, timeout=timeout, blocking=True)
+
+    def send_nowait(self, obj, *,
+                    unbound=None,
+                    ):
+        """Send the object to the channel's receiving end.
+
+        If the object is immediately received then return True
+        (else False).  Otherwise this is the same as send().
+        """
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        # XXX Note that at the moment channel_send() only ever returns
+        # None.  This should be fixed when channel_send_wait() is added.
+        # See bpo-32604 and gh-19829.
+        return _channels.send(self._id, obj, unboundop, blocking=False)
+
+    def send_buffer(self, obj, timeout=None, *,
+                    unbound=None,
+                    ):
+        """Send the object's buffer to the channel's receiving end.
+
+        This blocks until the object is received.
+        """
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        _channels.send_buffer(self._id, obj, unboundop,
+                              timeout=timeout, blocking=True)
+
+    def send_buffer_nowait(self, obj, *,
+                           unbound=None,
+                           ):
+        """Send the object's buffer to the channel's receiving end.
+
+        If the object is immediately received then return True
+        (else False).  Otherwise this is the same as send().
+        """
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        return _channels.send_buffer(self._id, obj, unboundop, blocking=False)
+
+    def close(self):
+        _channels.close(self._id, send=True)
+
+
+# XXX This is causing leaks (gh-110318):
+_channels._register_end_types(SendChannel, RecvChannel)
diff --git a/Lib/test/support/interpreters/queues.py b/Lib/test/support/interpreters/queues.py
new file mode 100644
index 0000000000..deb8e8613a
--- /dev/null
+++ b/Lib/test/support/interpreters/queues.py
@@ -0,0 +1,313 @@
+"""Cross-interpreter Queues High Level Module."""
+
+import pickle
+import queue
+import time
+import weakref
+import _interpqueues as _queues
+from . import _crossinterp
+
+# aliases:
+from _interpqueues import (
+    QueueError, QueueNotFoundError,
+)
+from ._crossinterp import (
+    UNBOUND_ERROR, UNBOUND_REMOVE,
+)
+
+__all__ = [
+    'UNBOUND', 'UNBOUND_ERROR', 'UNBOUND_REMOVE',
+    'create', 'list_all',
+    'Queue',
+    'QueueError', 'QueueNotFoundError', 'QueueEmpty', 'QueueFull',
+    'ItemInterpreterDestroyed',
+]
+
+
+class QueueEmpty(QueueError, queue.Empty):
+    """Raised from get_nowait() when the queue is empty.
+
+    It is also raised from get() if it times out.
+    """
+
+
+class QueueFull(QueueError, queue.Full):
+    """Raised from put_nowait() when the queue is full.
+
+    It is also raised from put() if it times out.
+    """
+
+
+class ItemInterpreterDestroyed(QueueError,
+                               _crossinterp.ItemInterpreterDestroyed):
+    """Raised from get() and get_nowait()."""
+
+
+_SHARED_ONLY = 0
+_PICKLED = 1
+
+
+UNBOUND = _crossinterp.UnboundItem.singleton('queue', __name__)
+
+
+def _serialize_unbound(unbound):
+    if unbound is UNBOUND:
+        unbound = _crossinterp.UNBOUND
+    return _crossinterp.serialize_unbound(unbound)
+
+
+def _resolve_unbound(flag):
+    resolved = _crossinterp.resolve_unbound(flag, ItemInterpreterDestroyed)
+    if resolved is _crossinterp.UNBOUND:
+        resolved = UNBOUND
+    return resolved
+
+
+def create(maxsize=0, *, syncobj=False, unbounditems=UNBOUND):
+    """Return a new cross-interpreter queue.
+
+    The queue may be used to pass data safely between interpreters.
+
+    "syncobj" sets the default for Queue.put()
+    and Queue.put_nowait().
+
+    "unbounditems" likewise sets the default.  See Queue.put() for
+    supported values.  The default value is UNBOUND, which replaces
+    the unbound item.
+    """
+    fmt = _SHARED_ONLY if syncobj else _PICKLED
+    unbound = _serialize_unbound(unbounditems)
+    unboundop, = unbound
+    qid = _queues.create(maxsize, fmt, unboundop)
+    return Queue(qid, _fmt=fmt, _unbound=unbound)
+
+
+def list_all():
+    """Return a list of all open queues."""
+    return [Queue(qid, _fmt=fmt, _unbound=(unboundop,))
+            for qid, fmt, unboundop in _queues.list_all()]
+
+
+_known_queues = weakref.WeakValueDictionary()
+
+class Queue:
+    """A cross-interpreter queue."""
+
+    def __new__(cls, id, /, *, _fmt=None, _unbound=None):
+        # There is only one instance for any given ID.
+        if isinstance(id, int):
+            id = int(id)
+        else:
+            raise TypeError(f'id must be an int, got {id!r}')
+        if _fmt is None:
+            if _unbound is None:
+                _fmt, op = _queues.get_queue_defaults(id)
+                _unbound = (op,)
+            else:
+                _fmt, _ = _queues.get_queue_defaults(id)
+        elif _unbound is None:
+            _, op = _queues.get_queue_defaults(id)
+            _unbound = (op,)
+        try:
+            self = _known_queues[id]
+        except KeyError:
+            self = super().__new__(cls)
+            self._id = id
+            self._fmt = _fmt
+            self._unbound = _unbound
+            _known_queues[id] = self
+            _queues.bind(id)
+        return self
+
+    def __del__(self):
+        try:
+            _queues.release(self._id)
+        except QueueNotFoundError:
+            pass
+        try:
+            del _known_queues[self._id]
+        except KeyError:
+            pass
+
+    def __repr__(self):
+        return f'{type(self).__name__}({self.id})'
+
+    def __hash__(self):
+        return hash(self._id)
+
+    # for pickling:
+    def __getnewargs__(self):
+        return (self._id,)
+
+    # for pickling:
+    def __getstate__(self):
+        return None
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def maxsize(self):
+        try:
+            return self._maxsize
+        except AttributeError:
+            self._maxsize = _queues.get_maxsize(self._id)
+            return self._maxsize
+
+    def empty(self):
+        return self.qsize() == 0
+
+    def full(self):
+        return _queues.is_full(self._id)
+
+    def qsize(self):
+        return _queues.get_count(self._id)
+
+    def put(self, obj, timeout=None, *,
+            syncobj=None,
+            unbound=None,
+            _delay=10 / 1000,  # 10 milliseconds
+            ):
+        """Add the object to the queue.
+
+        This blocks while the queue is full.
+
+        If "syncobj" is None (the default) then it uses the
+        queue's default, set with create_queue().
+
+        If "syncobj" is false then all objects are supported,
+        at the expense of worse performance.
+
+        If "syncobj" is true then the object must be "shareable".
+        Examples of "shareable" objects include the builtin singletons,
+        str, and memoryview.  One benefit is that such objects are
+        passed through the queue efficiently.
+
+        The key difference, though, is conceptual: the corresponding
+        object returned from Queue.get() will be strictly equivalent
+        to the given obj.  In other words, the two objects will be
+        effectively indistinguishable from each other, even if the
+        object is mutable.  The received object may actually be the
+        same object, or a copy (immutable values only), or a proxy.
+        Regardless, the received object should be treated as though
+        the original has been shared directly, whether or not it
+        actually is.  That's a slightly different and stronger promise
+        than just (initial) equality, which is all "syncobj=False"
+        can promise.
+
+        "unbound" controls the behavior of Queue.get() for the given
+        object if the current interpreter (calling put()) is later
+        destroyed.
+
+        If "unbound" is None (the default) then it uses the
+        queue's default, set with create_queue(),
+        which is usually UNBOUND.
+
+        If "unbound" is UNBOUND_ERROR then get() will raise an
+        ItemInterpreterDestroyed exception if the original interpreter
+        has been destroyed.  This does not otherwise affect the queue;
+        the next call to put() will work like normal, returning the next
+        item in the queue.
+
+        If "unbound" is UNBOUND_REMOVE then the item will be removed
+        from the queue as soon as the original interpreter is destroyed.
+        Be aware that this will introduce an imbalance between put()
+        and get() calls.
+
+        If "unbound" is UNBOUND then it is returned by get() in place
+        of the unbound item.
+        """
+        if syncobj is None:
+            fmt = self._fmt
+        else:
+            fmt = _SHARED_ONLY if syncobj else _PICKLED
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        if timeout is not None:
+            timeout = int(timeout)
+            if timeout < 0:
+                raise ValueError(f'timeout value must be non-negative')
+            end = time.time() + timeout
+        if fmt is _PICKLED:
+            obj = pickle.dumps(obj)
+        while True:
+            try:
+                _queues.put(self._id, obj, fmt, unboundop)
+            except QueueFull as exc:
+                if timeout is not None and time.time() >= end:
+                    raise  # re-raise
+                time.sleep(_delay)
+            else:
+                break
+
+    def put_nowait(self, obj, *, syncobj=None, unbound=None):
+        if syncobj is None:
+            fmt = self._fmt
+        else:
+            fmt = _SHARED_ONLY if syncobj else _PICKLED
+        if unbound is None:
+            unboundop, = self._unbound
+        else:
+            unboundop, = _serialize_unbound(unbound)
+        if fmt is _PICKLED:
+            obj = pickle.dumps(obj)
+        _queues.put(self._id, obj, fmt, unboundop)
+
+    def get(self, timeout=None, *,
+            _delay=10 / 1000,  # 10 milliseconds
+            ):
+        """Return the next object from the queue.
+
+        This blocks while the queue is empty.
+
+        If the next item's original interpreter has been destroyed
+        then the "next object" is determined by the value of the
+        "unbound" argument to put().
+        """
+        if timeout is not None:
+            timeout = int(timeout)
+            if timeout < 0:
+                raise ValueError(f'timeout value must be non-negative')
+            end = time.time() + timeout
+        while True:
+            try:
+                obj, fmt, unboundop = _queues.get(self._id)
+            except QueueEmpty as exc:
+                if timeout is not None and time.time() >= end:
+                    raise  # re-raise
+                time.sleep(_delay)
+            else:
+                break
+        if unboundop is not None:
+            assert obj is None, repr(obj)
+            return _resolve_unbound(unboundop)
+        if fmt == _PICKLED:
+            obj = pickle.loads(obj)
+        else:
+            assert fmt == _SHARED_ONLY
+        return obj
+
+    def get_nowait(self):
+        """Return the next object from the channel.
+
+        If the queue is empty then raise QueueEmpty.  Otherwise this
+        is the same as get().
+        """
+        try:
+            obj, fmt, unboundop = _queues.get(self._id)
+        except QueueEmpty as exc:
+            raise  # re-raise
+        if unboundop is not None:
+            assert obj is None, repr(obj)
+            return _resolve_unbound(unboundop)
+        if fmt == _PICKLED:
+            obj = pickle.loads(obj)
+        else:
+            assert fmt == _SHARED_ONLY
+        return obj
+
+
+_queues._register_heap_types(Queue, QueueEmpty, QueueFull)
diff --git a/Lib/test/support/numbers.py b/Lib/test/support/numbers.py
new file mode 100644
index 0000000000..d5dbb41ace
--- /dev/null
+++ b/Lib/test/support/numbers.py
@@ -0,0 +1,80 @@
+# These are shared with test_tokenize and other test modules.
+#
+# Note: since several test cases filter out floats by looking for "e" and ".",
+# don't add hexadecimal literals that contain "e" or "E".
+VALID_UNDERSCORE_LITERALS = [
+    '0_0_0',
+    '4_2',
+    '1_0000_0000',
+    '0b1001_0100',
+    '0xffff_ffff',
+    '0o5_7_7',
+    '1_00_00.5',
+    '1_00_00.5e5',
+    '1_00_00e5_1',
+    '1e1_0',
+    '.1_4',
+    '.1_4e1',
+    '0b_0',
+    '0x_f',
+    '0o_5',
+    '1_00_00j',
+    '1_00_00.5j',
+    '1_00_00e5_1j',
+    '.1_4j',
+    '(1_2.5+3_3j)',
+    '(.5_6j)',
+]
+INVALID_UNDERSCORE_LITERALS = [
+    # Trailing underscores:
+    '0_',
+    '42_',
+    '1.4j_',
+    '0x_',
+    '0b1_',
+    '0xf_',
+    '0o5_',
+    '0 if 1_Else 1',
+    # Underscores in the base selector:
+    '0_b0',
+    '0_xf',
+    '0_o5',
+    # Old-style octal, still disallowed:
+    '0_7',
+    '09_99',
+    # Multiple consecutive underscores:
+    '4_______2',
+    '0.1__4',
+    '0.1__4j',
+    '0b1001__0100',
+    '0xffff__ffff',
+    '0x___',
+    '0o5__77',
+    '1e1__0',
+    '1e1__0j',
+    # Underscore right before a dot:
+    '1_.4',
+    '1_.4j',
+    # Underscore right after a dot:
+    '1._4',
+    '1._4j',
+    '._5',
+    '._5j',
+    # Underscore right after a sign:
+    '1.0e+_1',
+    '1.0e+_1j',
+    # Underscore right before j:
+    '1.4_j',
+    '1.4e5_j',
+    # Underscore right before e:
+    '1_e1',
+    '1.4_e1',
+    '1.4_e1j',
+    # Underscore right after e:
+    '1e_1',
+    '1.4e_1',
+    '1.4e_1j',
+    # Complex cases with parens:
+    '(1+1.5_j_)',
+    '(1+1.5_j)',
+]
diff --git a/Lib/test/support/os_helper.py b/Lib/test/support/os_helper.py
index 70161e9013..26c467a7ad 100644
--- a/Lib/test/support/os_helper.py
+++ b/Lib/test/support/os_helper.py
@@ -1,6 +1,7 @@
 import collections.abc
 import contextlib
 import errno
+import logging
 import os
 import re
 import stat
@@ -10,7 +11,6 @@
 import unittest
 import warnings
 
-# From CPython 3.13.5
 from test import support
 
 
@@ -23,8 +23,8 @@
 
 # TESTFN_UNICODE is a non-ascii filename
 TESTFN_UNICODE = TESTFN_ASCII + "-\xe0\xf2\u0258\u0141\u011f"
-if sys.platform == 'darwin':
-    # In Mac OS X's VFS API file names are, by definition, canonically
+if support.is_apple:
+    # On Apple's VFS API file names are, by definition, canonically
     # decomposed Unicode, encoded using UTF-8. See QA1173:
     # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
     import unicodedata
@@ -49,8 +49,8 @@
                   'encoding (%s). Unicode filename tests may not be effective'
                   % (TESTFN_UNENCODABLE, sys.getfilesystemencoding()))
             TESTFN_UNENCODABLE = None
-# macOS and Emscripten deny unencodable filenames (invalid utf-8)
-elif sys.platform not in {'darwin', 'emscripten', 'wasi'}:
+# Apple and Emscripten deny unencodable filenames (invalid utf-8)
+elif not support.is_apple and sys.platform not in {"emscripten", "wasi"}:
     try:
         # ascii and utf-8 cannot encode the byte 0xff
         b'\xff'.decode(sys.getfilesystemencoding())
@@ -199,10 +199,8 @@ def skip_unless_symlink(test):
     return test if ok else unittest.skip(msg)(test)
 
 
-# From CPython 3.13.5
 _can_hardlink = None
 
-# From CPython 3.13.5
 def can_hardlink():
     global _can_hardlink
     if _can_hardlink is None:
@@ -212,7 +210,6 @@ def can_hardlink():
     return _can_hardlink
 
 
-# From CPython 3.13.5
 def skip_unless_hardlink(test):
     ok = can_hardlink()
     msg = "requires hardlink support"
@@ -268,15 +265,15 @@ def can_chmod():
     global _can_chmod
     if _can_chmod is not None:
         return _can_chmod
-    if not hasattr(os, "chown"):
+    if not hasattr(os, "chmod"):
         _can_chmod = False
         return _can_chmod
     try:
         with open(TESTFN, "wb") as f:
             try:
-                os.chmod(TESTFN, 0o777)
+                os.chmod(TESTFN, 0o555)
                 mode1 = os.stat(TESTFN).st_mode
-                os.chmod(TESTFN, 0o666)
+                os.chmod(TESTFN, 0o777)
                 mode2 = os.stat(TESTFN).st_mode
             except OSError as e:
                 can = False
@@ -323,6 +320,10 @@ def can_dac_override():
             else:
                 _can_dac_override = True
     finally:
+        try:
+            os.chmod(TESTFN, 0o700)
+        except OSError:
+            pass
         unlink(TESTFN)
 
     return _can_dac_override
@@ -378,8 +379,12 @@ def _waitfor(func, pathname, waitall=False):
             # Increase the timeout and try again
             time.sleep(timeout)
             timeout *= 2
-        warnings.warn('tests may fail, delete still pending for ' + pathname,
-                      RuntimeWarning, stacklevel=4)
+        logging.getLogger(__name__).warning(
+            'tests may fail, delete still pending for %s',
+            pathname,
+            stack_info=True,
+            stacklevel=4,
+        )
 
     def _unlink(filename):
         _waitfor(os.unlink, filename)
@@ -494,9 +499,14 @@ def temp_dir(path=None, quiet=False):
         except OSError as exc:
             if not quiet:
                 raise
-            warnings.warn(f'tests may fail, unable to create '
-                          f'temporary directory {path!r}: {exc}',
-                          RuntimeWarning, stacklevel=3)
+            logging.getLogger(__name__).warning(
+                "tests may fail, unable to create temporary directory %r: %s",
+                path,
+                exc,
+                exc_info=exc,
+                stack_info=True,
+                stacklevel=3,
+            )
     if dir_created:
         pid = os.getpid()
     try:
@@ -527,9 +537,15 @@ def change_cwd(path, quiet=False):
     except OSError as exc:
         if not quiet:
             raise
-        warnings.warn(f'tests may fail, unable to change the current working '
-                      f'directory to {path!r}: {exc}',
-                      RuntimeWarning, stacklevel=3)
+        logging.getLogger(__name__).warning(
+            'tests may fail, unable to change the current working directory '
+            'to %r: %s',
+            path,
+            exc,
+            exc_info=exc,
+            stack_info=True,
+            stacklevel=3,
+        )
     try:
         yield os.getcwd()
     finally:
@@ -612,11 +628,18 @@ def __fspath__(self):
 def fd_count():
     """Count the number of open file descriptors.
     """
-    if sys.platform.startswith(('linux', 'freebsd', 'emscripten')):
+    if sys.platform.startswith(('linux', 'android', 'freebsd', 'emscripten')):
+        fd_path = "/proc/self/fd"
+    elif support.is_apple:
+        fd_path = "/dev/fd"
+    else:
+        fd_path = None
+
+    if fd_path is not None:
         try:
-            names = os.listdir("/proc/self/fd")
+            names = os.listdir(fd_path)
             # Subtract one because listdir() internally opens a file
-            # descriptor to list the content of the /proc/self/fd/ directory.
+            # descriptor to list the content of the directory.
             return len(names) - 1
         except FileNotFoundError:
             pass
@@ -686,9 +709,10 @@ def temp_umask(umask):
 
 
 class EnvironmentVarGuard(collections.abc.MutableMapping):
+    """Class to help protect the environment variable properly.
 
-    """Class to help protect the environment variable properly.  Can be used as
-    a context manager."""
+    Can be used as a context manager.
+    """
 
     def __init__(self):
         self._environ = os.environ
@@ -722,7 +746,6 @@ def __len__(self):
     def set(self, envvar, value):
         self[envvar] = value
 
-    # From CPython 3.13.5
     def unset(self, envvar, /, *envvars):
         """Unset one or more environment variables."""
         for ev in (envvar, *envvars):
@@ -746,13 +769,16 @@ def __exit__(self, *ignore_exc):
 
 
 try:
-    import ctypes
-    kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
-
-    ERROR_FILE_NOT_FOUND = 2
-    DDD_REMOVE_DEFINITION = 2
-    DDD_EXACT_MATCH_ON_REMOVE = 4
-    DDD_NO_BROADCAST_SYSTEM = 8
+    if support.MS_WINDOWS:
+        import ctypes
+        kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+
+        ERROR_FILE_NOT_FOUND = 2
+        DDD_REMOVE_DEFINITION = 2
+        DDD_EXACT_MATCH_ON_REMOVE = 4
+        DDD_NO_BROADCAST_SYSTEM = 8
+    else:
+        raise AttributeError
 except (ImportError, AttributeError):
     def subst_drive(path):
         raise unittest.SkipTest('ctypes or kernel32 is not available')
diff --git a/Lib/test/support/refleak_helper.py b/Lib/test/support/refleak_helper.py
new file mode 100644
index 0000000000..2f86c93a1e
--- /dev/null
+++ b/Lib/test/support/refleak_helper.py
@@ -0,0 +1,8 @@
+"""
+Utilities for changing test behaviour while hunting
+for refleaks
+"""
+
+_hunting_for_refleaks = False
+def hunting_for_refleaks():
+    return _hunting_for_refleaks
diff --git a/Lib/test/support/script_helper.py b/Lib/test/support/script_helper.py
index c2b43f4060..04458077d5 100644
--- a/Lib/test/support/script_helper.py
+++ b/Lib/test/support/script_helper.py
@@ -8,7 +8,6 @@
 import os.path
 import subprocess
 import py_compile
-import zipfile
 
 from importlib.util import source_from_cache
 from test import support
@@ -64,8 +63,8 @@ class _PythonRunResult(collections.namedtuple("_PythonRunResult",
     """Helper for reporting Python subprocess run results"""
     def fail(self, cmd_line):
         """Provide helpful details about failed subcommand runs"""
-        # Limit to 80 lines to ASCII characters
-        maxlen = 80 * 100
+        # Limit to 300 lines of ASCII characters
+        maxlen = 300 * 100
         out, err = self.out, self.err
         if len(out) > maxlen:
             out = b'(... truncated stdout ...)' + out[-maxlen:]
@@ -93,13 +92,28 @@ def fail(self, cmd_line):
 # Executing the interpreter in a subprocess
 @support.requires_subprocess()
 def run_python_until_end(*args, **env_vars):
+    """Used to implement assert_python_*.
+
+    *args are the command line flags to pass to the python interpreter.
+    **env_vars keyword arguments are environment variables to set on the process.
+
+    If __run_using_command= is supplied, it must be a list of
+    command line arguments to prepend to the command line used.
+    Useful when you want to run another command that should launch the
+    python interpreter via its own arguments. ["/bin/echo", "--"] for
+    example could print the unquoted python command line instead of
+    run it.
+    """
     env_required = interpreter_requires_environment()
+    run_using_command = env_vars.pop('__run_using_command', None)
     cwd = env_vars.pop('__cwd', None)
     if '__isolated' in env_vars:
         isolated = env_vars.pop('__isolated')
     else:
         isolated = not env_vars and not env_required
     cmd_line = [sys.executable, '-X', 'faulthandler']
+    if run_using_command:
+        cmd_line = run_using_command + cmd_line
     if isolated:
         # isolated mode: ignore Python environment variables, ignore user
         # site-packages, and don't add the current directory to sys.path
@@ -218,14 +232,19 @@ def make_script(script_dir, script_basename, source, omit_suffix=False):
     if not omit_suffix:
         script_filename += os.extsep + 'py'
     script_name = os.path.join(script_dir, script_filename)
-    # The script should be encoded to UTF-8, the default string encoding
-    with open(script_name, 'w', encoding='utf-8') as script_file:
-        script_file.write(source)
+    if isinstance(source, str):
+        # The script should be encoded to UTF-8, the default string encoding
+        with open(script_name, 'w', encoding='utf-8') as script_file:
+            script_file.write(source)
+    else:
+        with open(script_name, 'wb') as script_file:
+            script_file.write(source)
     importlib.invalidate_caches()
     return script_name
 
 
 def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None):
+    import zipfile
     zip_filename = zip_basename+os.extsep+'zip'
     zip_name = os.path.join(zip_dir, zip_filename)
     with zipfile.ZipFile(zip_name, 'w') as zip_file:
@@ -252,6 +271,7 @@ def make_pkg(pkg_dir, init_source=''):
 
 def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
                  source, depth=1, compiled=False):
+    import zipfile
     unlink = []
     init_name = make_script(zip_dir, '__init__', '')
     unlink.append(init_name)
diff --git a/Lib/test/support/smtpd.py b/Lib/test/support/smtpd.py
index ec4e7d2f4c..6052232ec2 100644
--- a/Lib/test/support/smtpd.py
+++ b/Lib/test/support/smtpd.py
@@ -180,122 +180,122 @@ def _set_rset_state(self):
     @property
     def __server(self):
         warn("Access to __server attribute on SMTPChannel is deprecated, "
-             "use 'smtp_server' instead", DeprecationWarning, 2)
+            "use 'smtp_server' instead", DeprecationWarning, 2)
         return self.smtp_server
     @__server.setter
     def __server(self, value):
         warn("Setting __server attribute on SMTPChannel is deprecated, "
-             "set 'smtp_server' instead", DeprecationWarning, 2)
+            "set 'smtp_server' instead", DeprecationWarning, 2)
         self.smtp_server = value
 
     @property
     def __line(self):
         warn("Access to __line attribute on SMTPChannel is deprecated, "
-             "use 'received_lines' instead", DeprecationWarning, 2)
+            "use 'received_lines' instead", DeprecationWarning, 2)
         return self.received_lines
     @__line.setter
     def __line(self, value):
         warn("Setting __line attribute on SMTPChannel is deprecated, "
-             "set 'received_lines' instead", DeprecationWarning, 2)
+            "set 'received_lines' instead", DeprecationWarning, 2)
         self.received_lines = value
 
     @property
     def __state(self):
         warn("Access to __state attribute on SMTPChannel is deprecated, "
-             "use 'smtp_state' instead", DeprecationWarning, 2)
+            "use 'smtp_state' instead", DeprecationWarning, 2)
         return self.smtp_state
     @__state.setter
     def __state(self, value):
         warn("Setting __state attribute on SMTPChannel is deprecated, "
-             "set 'smtp_state' instead", DeprecationWarning, 2)
+            "set 'smtp_state' instead", DeprecationWarning, 2)
         self.smtp_state = value
 
     @property
     def __greeting(self):
         warn("Access to __greeting attribute on SMTPChannel is deprecated, "
-             "use 'seen_greeting' instead", DeprecationWarning, 2)
+            "use 'seen_greeting' instead", DeprecationWarning, 2)
         return self.seen_greeting
     @__greeting.setter
     def __greeting(self, value):
         warn("Setting __greeting attribute on SMTPChannel is deprecated, "
-             "set 'seen_greeting' instead", DeprecationWarning, 2)
+            "set 'seen_greeting' instead", DeprecationWarning, 2)
         self.seen_greeting = value
 
     @property
     def __mailfrom(self):
         warn("Access to __mailfrom attribute on SMTPChannel is deprecated, "
-             "use 'mailfrom' instead", DeprecationWarning, 2)
+            "use 'mailfrom' instead", DeprecationWarning, 2)
         return self.mailfrom
     @__mailfrom.setter
     def __mailfrom(self, value):
         warn("Setting __mailfrom attribute on SMTPChannel is deprecated, "
-             "set 'mailfrom' instead", DeprecationWarning, 2)
+            "set 'mailfrom' instead", DeprecationWarning, 2)
         self.mailfrom = value
 
     @property
     def __rcpttos(self):
         warn("Access to __rcpttos attribute on SMTPChannel is deprecated, "
-             "use 'rcpttos' instead", DeprecationWarning, 2)
+            "use 'rcpttos' instead", DeprecationWarning, 2)
         return self.rcpttos
     @__rcpttos.setter
     def __rcpttos(self, value):
         warn("Setting __rcpttos attribute on SMTPChannel is deprecated, "
-             "set 'rcpttos' instead", DeprecationWarning, 2)
+            "set 'rcpttos' instead", DeprecationWarning, 2)
         self.rcpttos = value
 
     @property
     def __data(self):
         warn("Access to __data attribute on SMTPChannel is deprecated, "
-             "use 'received_data' instead", DeprecationWarning, 2)
+            "use 'received_data' instead", DeprecationWarning, 2)
         return self.received_data
     @__data.setter
     def __data(self, value):
         warn("Setting __data attribute on SMTPChannel is deprecated, "
-             "set 'received_data' instead", DeprecationWarning, 2)
+            "set 'received_data' instead", DeprecationWarning, 2)
         self.received_data = value
 
     @property
     def __fqdn(self):
         warn("Access to __fqdn attribute on SMTPChannel is deprecated, "
-             "use 'fqdn' instead", DeprecationWarning, 2)
+            "use 'fqdn' instead", DeprecationWarning, 2)
         return self.fqdn
     @__fqdn.setter
     def __fqdn(self, value):
         warn("Setting __fqdn attribute on SMTPChannel is deprecated, "
-             "set 'fqdn' instead", DeprecationWarning, 2)
+            "set 'fqdn' instead", DeprecationWarning, 2)
         self.fqdn = value
 
     @property
     def __peer(self):
         warn("Access to __peer attribute on SMTPChannel is deprecated, "
-             "use 'peer' instead", DeprecationWarning, 2)
+            "use 'peer' instead", DeprecationWarning, 2)
         return self.peer
     @__peer.setter
     def __peer(self, value):
         warn("Setting __peer attribute on SMTPChannel is deprecated, "
-             "set 'peer' instead", DeprecationWarning, 2)
+            "set 'peer' instead", DeprecationWarning, 2)
         self.peer = value
 
     @property
     def __conn(self):
         warn("Access to __conn attribute on SMTPChannel is deprecated, "
-             "use 'conn' instead", DeprecationWarning, 2)
+            "use 'conn' instead", DeprecationWarning, 2)
         return self.conn
     @__conn.setter
     def __conn(self, value):
         warn("Setting __conn attribute on SMTPChannel is deprecated, "
-             "set 'conn' instead", DeprecationWarning, 2)
+            "set 'conn' instead", DeprecationWarning, 2)
         self.conn = value
 
     @property
     def __addr(self):
         warn("Access to __addr attribute on SMTPChannel is deprecated, "
-             "use 'addr' instead", DeprecationWarning, 2)
+            "use 'addr' instead", DeprecationWarning, 2)
         return self.addr
     @__addr.setter
     def __addr(self, value):
         warn("Setting __addr attribute on SMTPChannel is deprecated, "
-             "set 'addr' instead", DeprecationWarning, 2)
+            "set 'addr' instead", DeprecationWarning, 2)
         self.addr = value
 
     # Overrides base class for convenience.
@@ -339,7 +339,7 @@ def found_terminator(self):
                 command = line[:i].upper()
                 arg = line[i+1:].strip()
             max_sz = (self.command_size_limits[command]
-                      if self.extended_smtp else self.command_size_limit)
+                        if self.extended_smtp else self.command_size_limit)
             if sz > max_sz:
                 self.push('500 Error: line too long')
                 return
diff --git a/Lib/test/support/socket_helper.py b/Lib/test/support/socket_helper.py
index 87941ee179..a41e487f3e 100644
--- a/Lib/test/support/socket_helper.py
+++ b/Lib/test/support/socket_helper.py
@@ -259,6 +259,10 @@ def filter_error(err):
             #        raise OSError('socket error', msg) from msg
             elif len(a) >= 2 and isinstance(a[1], OSError):
                 err = a[1]
+            # The error can also be wrapped as __cause__:
+            #    raise URLError(f"ftp error: {exp}") from exp
+            elif isinstance(err, urllib.error.URLError) and err.__cause__:
+                err = err.__cause__
             else:
                 break
         filter_error(err)
diff --git a/Lib/test/support/threading_helper.py b/Lib/test/support/threading_helper.py
index 7f16050f32..afa25a76f6 100644
--- a/Lib/test/support/threading_helper.py
+++ b/Lib/test/support/threading_helper.py
@@ -22,34 +22,37 @@
 
 
 def threading_setup():
-    return _thread._count(), threading._dangling.copy()
+    return _thread._count(), len(threading._dangling)
 
 
 def threading_cleanup(*original_values):
-    _MAX_COUNT = 100
-
-    for count in range(_MAX_COUNT):
-        values = _thread._count(), threading._dangling
-        if values == original_values:
-            break
-
-        if not count:
-            # Display a warning at the first iteration
-            support.environment_altered = True
-            dangling_threads = values[1]
-            support.print_warning(f"threading_cleanup() failed to cleanup "
-                                  f"{values[0] - original_values[0]} threads "
-                                  f"(count: {values[0]}, "
-                                  f"dangling: {len(dangling_threads)})")
-            for thread in dangling_threads:
-                support.print_warning(f"Dangling thread: {thread!r}")
-
-            # Don't hold references to threads
-            dangling_threads = None
-        values = None
-
-        time.sleep(0.01)
-        support.gc_collect()
+    orig_count, orig_ndangling = original_values
+
+    timeout = 1.0
+    for _ in support.sleeping_retry(timeout, error=False):
+        # Copy the thread list to get a consistent output. threading._dangling
+        # is a WeakSet, its value changes when it's read.
+        dangling_threads = list(threading._dangling)
+        count = _thread._count()
+
+        if count <= orig_count:
+            return
+
+    # Timeout!
+    support.environment_altered = True
+    support.print_warning(
+        f"threading_cleanup() failed to clean up threads "
+        f"in {timeout:.1f} seconds\n"
+        f"  before: thread count={orig_count}, dangling={orig_ndangling}\n"
+        f"  after: thread count={count}, dangling={len(dangling_threads)}")
+    for thread in dangling_threads:
+        support.print_warning(f"Dangling thread: {thread!r}")
+
+    # The warning happens when a test spawns threads and some of these threads
+    # are still running after the test completes. To fix this warning, join
+    # threads explicitly to wait until they complete.
+    #
+    # To make the warning more likely, reduce the timeout.
 
 
 def reap_threads(func):
diff --git a/Lib/test/support/venv.py b/Lib/test/support/venv.py
new file mode 100644
index 0000000000..78e6a51ec1
--- /dev/null
+++ b/Lib/test/support/venv.py
@@ -0,0 +1,70 @@
+import contextlib
+import logging
+import os
+import subprocess
+import shlex
+import sys
+import sysconfig
+import tempfile
+import venv
+
+
+class VirtualEnvironment:
+    def __init__(self, prefix, **venv_create_args):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        venv.create(prefix, **venv_create_args)
+        self._prefix = prefix
+        self._paths = sysconfig.get_paths(
+            scheme='venv',
+            vars={'base': self.prefix},
+            expand=True,
+        )
+
+    @classmethod
+    @contextlib.contextmanager
+    def from_tmpdir(cls, *, prefix=None, dir=None, **venv_create_args):
+        delete = not bool(os.environ.get('PYTHON_TESTS_KEEP_VENV'))
+        with tempfile.TemporaryDirectory(prefix=prefix, dir=dir, delete=delete) as tmpdir:
+            yield cls(tmpdir, **venv_create_args)
+
+    @property
+    def prefix(self):
+        return self._prefix
+
+    @property
+    def paths(self):
+        return self._paths
+
+    @property
+    def interpreter(self):
+        return os.path.join(self.paths['scripts'], os.path.basename(sys.executable))
+
+    def _format_output(self, name, data, indent='\t'):
+        if not data:
+            return indent + f'{name}: (none)'
+        if len(data.splitlines()) == 1:
+            return indent + f'{name}: {data}'
+        else:
+            prefixed_lines = '\n'.join(indent + '> ' + line for line in data.splitlines())
+            return indent + f'{name}:\n' + prefixed_lines
+
+    def run(self, *args, **subprocess_args):
+        if subprocess_args.get('shell'):
+            raise ValueError('Running the subprocess in shell mode is not supported.')
+        default_args = {
+            'capture_output': True,
+            'check': True,
+        }
+        try:
+            result = subprocess.run([self.interpreter, *args], **default_args | subprocess_args)
+        except subprocess.CalledProcessError as e:
+            if e.returncode != 0:
+                self._logger.error(
+                    f'Interpreter returned non-zero exit status {e.returncode}.\n'
+                    + self._format_output('COMMAND', shlex.join(e.cmd)) + '\n'
+                    + self._format_output('STDOUT', e.stdout.decode()) + '\n'
+                    + self._format_output('STDERR', e.stderr.decode()) + '\n'
+                )
+            raise
+        else:
+            return result
diff --git a/Lib/test/test__colorize.py b/Lib/test/test__colorize.py
index 056a5306ce..b2f0bb1386 100644
--- a/Lib/test/test__colorize.py
+++ b/Lib/test/test__colorize.py
@@ -10,8 +10,7 @@
 @contextlib.contextmanager
 def clear_env():
     with EnvironmentVarGuard() as mock_env:
-        for var in "FORCE_COLOR", "NO_COLOR", "PYTHON_COLORS":
-            mock_env.unset(var)
+        mock_env.unset("FORCE_COLOR", "NO_COLOR", "PYTHON_COLORS", "TERM")
         yield mock_env
 
 
diff --git a/Lib/test/test__opcode.py b/Lib/test/test__opcode.py
new file mode 100644
index 0000000000..045e010db4
--- /dev/null
+++ b/Lib/test/test__opcode.py
@@ -0,0 +1,142 @@
+import dis
+from test.support.import_helper import import_module
+import unittest
+import opcode
+
+_opcode = import_module("_opcode")
+from _opcode import stack_effect
+
+
+class OpListTests(unittest.TestCase):
+    def check_bool_function_result(self, func, ops, expected):
+        for op in ops:
+            if isinstance(op, str):
+                op = dis.opmap[op]
+            with self.subTest(opcode=op, func=func):
+                self.assertIsInstance(func(op), bool)
+                self.assertEqual(func(op), expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Move LoadClosure to psudoes
+    def test_invalid_opcodes(self):
+        invalid = [-100, -1, 255, 512, 513, 1000]
+        self.check_bool_function_result(_opcode.is_valid, invalid, False)
+        self.check_bool_function_result(_opcode.has_arg, invalid, False)
+        self.check_bool_function_result(_opcode.has_const, invalid, False)
+        self.check_bool_function_result(_opcode.has_name, invalid, False)
+        self.check_bool_function_result(_opcode.has_jump, invalid, False)
+        self.check_bool_function_result(_opcode.has_free, invalid, False)
+        self.check_bool_function_result(_opcode.has_local, invalid, False)
+        self.check_bool_function_result(_opcode.has_exc, invalid, False)
+
+    def test_is_valid(self):
+        names = [
+            'CACHE',
+            'POP_TOP',
+            'IMPORT_NAME',
+            'JUMP',
+            'INSTRUMENTED_RETURN_VALUE',
+        ]
+        opcodes = [dis.opmap[opname] for opname in names]
+        self.check_bool_function_result(_opcode.is_valid, opcodes, True)
+
+    def test_oplists(self):
+        def check_function(self, func, expected):
+            for op in [-10, 520]:
+                with self.subTest(opcode=op, func=func):
+                    res = func(op)
+                    self.assertIsInstance(res, bool)
+                    self.assertEqual(res, op in expected)
+
+        check_function(self, _opcode.has_arg, dis.hasarg)
+        check_function(self, _opcode.has_const, dis.hasconst)
+        check_function(self, _opcode.has_name, dis.hasname)
+        check_function(self, _opcode.has_jump, dis.hasjump)
+        check_function(self, _opcode.has_free, dis.hasfree)
+        check_function(self, _opcode.has_local, dis.haslocal)
+        check_function(self, _opcode.has_exc, dis.hasexc)
+
+
+class StackEffectTests(unittest.TestCase):
+    def test_stack_effect(self):
+        self.assertEqual(stack_effect(dis.opmap['POP_TOP']), -1)
+        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 0), -1)
+        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 1), -1)
+        self.assertEqual(stack_effect(dis.opmap['BUILD_SLICE'], 3), -2)
+        self.assertRaises(ValueError, stack_effect, 30000)
+        # All defined opcodes
+        has_arg = dis.hasarg
+        for name, code in filter(lambda item: item[0] not in dis.deoptmap, dis.opmap.items()):
+            if code >= opcode.MIN_INSTRUMENTED_OPCODE:
+                continue
+            with self.subTest(opname=name):
+                stack_effect(code)
+                stack_effect(code, 0)
+        # All not defined opcodes
+        for code in set(range(256)) - set(dis.opmap.values()):
+            with self.subTest(opcode=code):
+                self.assertRaises(ValueError, stack_effect, code)
+                self.assertRaises(ValueError, stack_effect, code, 0)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_stack_effect_jump(self):
+        FOR_ITER = dis.opmap['FOR_ITER']
+        self.assertEqual(stack_effect(FOR_ITER, 0), 1)
+        self.assertEqual(stack_effect(FOR_ITER, 0, jump=True), 1)
+        self.assertEqual(stack_effect(FOR_ITER, 0, jump=False), 1)
+        JUMP_FORWARD = dis.opmap['JUMP_FORWARD']
+        self.assertEqual(stack_effect(JUMP_FORWARD, 0), 0)
+        self.assertEqual(stack_effect(JUMP_FORWARD, 0, jump=True), 0)
+        self.assertEqual(stack_effect(JUMP_FORWARD, 0, jump=False), 0)
+        # All defined opcodes
+        has_arg = dis.hasarg
+        has_exc = dis.hasexc
+        has_jump = dis.hasjabs + dis.hasjrel
+        for name, code in filter(lambda item: item[0] not in dis.deoptmap, dis.opmap.items()):
+            if code >= opcode.MIN_INSTRUMENTED_OPCODE:
+                continue
+            with self.subTest(opname=name):
+                if code not in has_arg:
+                    common = stack_effect(code)
+                    jump = stack_effect(code, jump=True)
+                    nojump = stack_effect(code, jump=False)
+                else:
+                    common = stack_effect(code, 0)
+                    jump = stack_effect(code, 0, jump=True)
+                    nojump = stack_effect(code, 0, jump=False)
+                if code in has_jump or code in has_exc:
+                    self.assertEqual(common, max(jump, nojump))
+                else:
+                    self.assertEqual(jump, common)
+                    self.assertEqual(nojump, common)
+
+
+class SpecializationStatsTests(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON - no specialization stats
+    def test_specialization_stats(self):
+        stat_names = ["success", "failure", "hit", "deferred", "miss", "deopt"]
+        specialized_opcodes = [
+            op.lower()
+            for op in opcode._specializations
+            if opcode._inline_cache_entries.get(op, 0)
+        ]
+        self.assertIn('load_attr', specialized_opcodes)
+        self.assertIn('binary_subscr', specialized_opcodes)
+
+        stats = _opcode.get_specialization_stats()
+        if stats is not None:
+            self.assertIsInstance(stats, dict)
+            self.assertCountEqual(stats.keys(), specialized_opcodes)
+            self.assertCountEqual(
+                stats['load_attr'].keys(),
+                stat_names + ['failure_kinds'])
+            for sn in stat_names:
+                self.assertIsInstance(stats['load_attr'][sn], int)
+            self.assertIsInstance(
+                stats['load_attr']['failure_kinds'],
+                tuple)
+            for v in stats['load_attr']['failure_kinds']:
+                self.assertIsInstance(v, int)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index ac46ea67bb..92bd955855 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -168,6 +168,8 @@ 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
         def test_abstractmethod_integration(self):
             for abstractthing in [abc.abstractmethod, abc.abstractproperty,
                                   abc.abstractclassmethod,
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index dc2df795a7..b7e995334f 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -6747,8 +6747,6 @@ def test_ambiguous_option(self):
                 "ambiguous option: --foob=1 could match --foobaz, --fooble$",
             self.parser.parse_args, ['--foob=1', '--foogle', '2'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_os_error(self):
         self.parser.add_argument('file')
         self.assertRaisesRegex(argparse.ArgumentError,
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index be89bec522..0c20e27cfd 100644
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -1285,8 +1285,6 @@ def check_overflow(self, lower, upper):
         self.assertRaises(OverflowError, array.array, self.typecode, [upper+1])
         self.assertRaises(OverflowError, a.__setitem__, 0, upper+1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclassing(self):
         typecode = self.typecode
         class ExaggeratingArray(array.array):
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
deleted file mode 100644
index 1cac438250..0000000000
--- a/Lib/test/test_ast.py
+++ /dev/null
@@ -1,3236 +0,0 @@
-import ast
-import builtins
-import dis
-import enum
-import os
-import re
-import sys
-import textwrap
-import types
-import unittest
-import warnings
-import weakref
-from functools import partial
-from textwrap import dedent
-
-from test import support
-from test.support.import_helper import import_fresh_module
-from test.support import os_helper, script_helper
-from test.support.ast_helper import ASTTestMixin
-
-def to_tuple(t):
-    if t is None or isinstance(t, (str, int, complex)) or t is Ellipsis:
-        return t
-    elif isinstance(t, list):
-        return [to_tuple(e) for e in t]
-    result = [t.__class__.__name__]
-    if hasattr(t, 'lineno') and hasattr(t, 'col_offset'):
-        result.append((t.lineno, t.col_offset))
-        if hasattr(t, 'end_lineno') and hasattr(t, 'end_col_offset'):
-            result[-1] += (t.end_lineno, t.end_col_offset)
-    if t._fields is None:
-        return tuple(result)
-    for f in t._fields:
-        result.append(to_tuple(getattr(t, f)))
-    return tuple(result)
-
-
-# These tests are compiled through "exec"
-# There should be at least one test per statement
-exec_tests = [
-    # None
-    "None",
-    # Module docstring
-    "'module docstring'",
-    # FunctionDef
-    "def f(): pass",
-    # FunctionDef with docstring
-    "def f(): 'function docstring'",
-    # FunctionDef with arg
-    "def f(a): pass",
-    # FunctionDef with arg and default value
-    "def f(a=0): pass",
-    # FunctionDef with varargs
-    "def f(*args): pass",
-    # FunctionDef with varargs as TypeVarTuple
-    "def f(*args: *Ts): pass",
-    # FunctionDef with varargs as unpacked Tuple
-    "def f(*args: *tuple[int, ...]): pass",
-    # FunctionDef with varargs as unpacked Tuple *and* TypeVarTuple
-    "def f(*args: *tuple[int, *Ts]): pass",
-    # FunctionDef with kwargs
-    "def f(**kwargs): pass",
-    # FunctionDef with all kind of args and docstring
-    "def f(a, b=1, c=None, d=[], e={}, *args, f=42, **kwargs): 'doc for f()'",
-    # FunctionDef with type annotation on return involving unpacking
-    "def f() -> tuple[*Ts]: pass",
-    "def f() -> tuple[int, *Ts]: pass",
-    "def f() -> tuple[int, *tuple[int, ...]]: pass",
-    # ClassDef
-    "class C:pass",
-    # ClassDef with docstring
-    "class C: 'docstring for class C'",
-    # ClassDef, new style class
-    "class C(object): pass",
-    # Return
-    "def f():return 1",
-    # Delete
-    "del v",
-    # Assign
-    "v = 1",
-    "a,b = c",
-    "(a,b) = c",
-    "[a,b] = c",
-    # AnnAssign with unpacked types
-    "x: tuple[*Ts]",
-    "x: tuple[int, *Ts]",
-    "x: tuple[int, *tuple[str, ...]]",
-    # AugAssign
-    "v += 1",
-    # For
-    "for v in v:pass",
-    # While
-    "while v:pass",
-    # If
-    "if v:pass",
-    # If-Elif
-    "if a:\n  pass\nelif b:\n  pass",
-    # If-Elif-Else
-    "if a:\n  pass\nelif b:\n  pass\nelse:\n  pass",
-    # With
-    "with x as y: pass",
-    "with x as y, z as q: pass",
-    # Raise
-    "raise Exception('string')",
-    # TryExcept
-    "try:\n  pass\nexcept Exception:\n  pass",
-    # TryFinally
-    "try:\n  pass\nfinally:\n  pass",
-    # TryStarExcept
-    "try:\n  pass\nexcept* Exception:\n  pass",
-    # Assert
-    "assert v",
-    # Import
-    "import sys",
-    # ImportFrom
-    "from sys import v",
-    # Global
-    "global v",
-    # Expr
-    "1",
-    # Pass,
-    "pass",
-    # Break
-    "for v in v:break",
-    # Continue
-    "for v in v:continue",
-    # for statements with naked tuples (see http://bugs.python.org/issue6704)
-    "for a,b in c: pass",
-    "for (a,b) in c: pass",
-    "for [a,b] in c: pass",
-    # Multiline generator expression (test for .lineno & .col_offset)
-    """(
-    (
-    Aa
-    ,
-       Bb
-    )
-    for
-    Aa
-    ,
-    Bb in Cc
-    )""",
-    # dictcomp
-    "{a : b for w in x for m in p if g}",
-    # dictcomp with naked tuple
-    "{a : b for v,w in x}",
-    # setcomp
-    "{r for l in x if g}",
-    # setcomp with naked tuple
-    "{r for l,m in x}",
-    # AsyncFunctionDef
-    "async def f():\n 'async function'\n await something()",
-    # AsyncFor
-    "async def f():\n async for e in i: 1\n else: 2",
-    # AsyncWith
-    "async def f():\n async with a as b: 1",
-    # PEP 448: Additional Unpacking Generalizations
-    "{**{1:2}, 2:3}",
-    "{*{1, 2}, 3}",
-    # Asynchronous comprehensions
-    "async def f():\n [i async for b in c]",
-    # Decorated FunctionDef
-    "@deco1\n@deco2()\n@deco3(1)\ndef f(): pass",
-    # Decorated AsyncFunctionDef
-    "@deco1\n@deco2()\n@deco3(1)\nasync def f(): pass",
-    # Decorated ClassDef
-    "@deco1\n@deco2()\n@deco3(1)\nclass C: pass",
-    # Decorator with generator argument
-    "@deco(a for a in b)\ndef f(): pass",
-    # Decorator with attribute
-    "@a.b.c\ndef f(): pass",
-    # Simple assignment expression
-    "(a := 1)",
-    # Positional-only arguments
-    "def f(a, /,): pass",
-    "def f(a, /, c, d, e): pass",
-    "def f(a, /, c, *, d, e): pass",
-    "def f(a, /, c, *, d, e, **kwargs): pass",
-    # Positional-only arguments with defaults
-    "def f(a=1, /,): pass",
-    "def f(a=1, /, b=2, c=4): pass",
-    "def f(a=1, /, b=2, *, c=4): pass",
-    "def f(a=1, /, b=2, *, c): pass",
-    "def f(a=1, /, b=2, *, c=4, **kwargs): pass",
-    "def f(a=1, /, b=2, *, c, **kwargs): pass",
-    # Type aliases
-    "type X = int",
-    "type X[T] = int",
-    "type X[T, *Ts, **P] = (T, Ts, P)",
-    "type X[T: int, *Ts, **P] = (T, Ts, P)",
-    "type X[T: (int, str), *Ts, **P] = (T, Ts, P)",
-    # Generic classes
-    "class X[T]: pass",
-    "class X[T, *Ts, **P]: pass",
-    "class X[T: int, *Ts, **P]: pass",
-    "class X[T: (int, str), *Ts, **P]: pass",
-    # Generic functions
-    "def f[T](): pass",
-    "def f[T, *Ts, **P](): pass",
-    "def f[T: int, *Ts, **P](): pass",
-    "def f[T: (int, str), *Ts, **P](): pass",
-]
-
-# These are compiled through "single"
-# because of overlap with "eval", it just tests what
-# can't be tested with "eval"
-single_tests = [
-    "1+2"
-]
-
-# These are compiled through "eval"
-# It should test all expressions
-eval_tests = [
-  # None
-  "None",
-  # BoolOp
-  "a and b",
-  # BinOp
-  "a + b",
-  # UnaryOp
-  "not v",
-  # Lambda
-  "lambda:None",
-  # Dict
-  "{ 1:2 }",
-  # Empty dict
-  "{}",
-  # Set
-  "{None,}",
-  # Multiline dict (test for .lineno & .col_offset)
-  """{
-      1
-        :
-          2
-     }""",
-  # ListComp
-  "[a for b in c if d]",
-  # GeneratorExp
-  "(a for b in c if d)",
-  # Comprehensions with multiple for targets
-  "[(a,b) for a,b in c]",
-  "[(a,b) for (a,b) in c]",
-  "[(a,b) for [a,b] in c]",
-  "{(a,b) for a,b in c}",
-  "{(a,b) for (a,b) in c}",
-  "{(a,b) for [a,b] in c}",
-  "((a,b) for a,b in c)",
-  "((a,b) for (a,b) in c)",
-  "((a,b) for [a,b] in c)",
-  # Yield - yield expressions can't work outside a function
-  #
-  # Compare
-  "1 < 2 < 3",
-  # Call
-  "f(1,2,c=3,*d,**e)",
-  # Call with multi-character starred
-  "f(*[0, 1])",
-  # Call with a generator argument
-  "f(a for a in b)",
-  # Num
-  "10",
-  # Str
-  "'string'",
-  # Attribute
-  "a.b",
-  # Subscript
-  "a[b:c]",
-  # Name
-  "v",
-  # List
-  "[1,2,3]",
-  # Empty list
-  "[]",
-  # Tuple
-  "1,2,3",
-  # Tuple
-  "(1,2,3)",
-  # Empty tuple
-  "()",
-  # Combination
-  "a.b.c.d(a.b[1:2])",
-]
-
-# TODO: expr_context, slice, boolop, operator, unaryop, cmpop, comprehension
-# excepthandler, arguments, keywords, alias
-
-class AST_Tests(unittest.TestCase):
-    maxDiff = None
-
-    def _is_ast_node(self, name, node):
-        if not isinstance(node, type):
-            return False
-        if "ast" not in node.__module__:
-            return False
-        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:
-            return
-        if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
-            node_pos = (ast_node.lineno, ast_node.col_offset)
-            self.assertGreaterEqual(node_pos, parent_pos)
-            parent_pos = (ast_node.lineno, ast_node.col_offset)
-        for name in ast_node._fields:
-            value = getattr(ast_node, name)
-            if isinstance(value, list):
-                first_pos = parent_pos
-                if value and name == 'decorator_list':
-                    first_pos = (value[0].lineno, value[0].col_offset)
-                for child in value:
-                    self._assertTrueorder(child, first_pos)
-            elif value is not None:
-                self._assertTrueorder(value, parent_pos)
-        self.assertEqual(ast_node._fields, ast_node.__match_args__)
-
-    def test_AST_objects(self):
-        x = ast.AST()
-        self.assertEqual(x._fields, ())
-        x.foobar = 42
-        self.assertEqual(x.foobar, 42)
-        self.assertEqual(x.__dict__["foobar"], 42)
-
-        with self.assertRaises(AttributeError):
-            x.vararg
-
-        with self.assertRaises(TypeError):
-            # "ast.AST constructor takes 0 positional arguments"
-            ast.AST(2)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_AST_garbage_collection(self):
-        class X:
-            pass
-        a = ast.AST()
-        a.x = X()
-        a.x.a = a
-        ref = weakref.ref(a.x)
-        del a
-        support.gc_collect()
-        self.assertIsNone(ref())
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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 i, o in zip(input, output):
-                with self.subTest(action="parsing", input=i):
-                    ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
-                    self.assertEqual(to_tuple(ast_tree), o)
-                    self._assertTrueorder(ast_tree, (0, 0))
-                with self.subTest(action="compiling", input=i, kind=kind):
-                    compile(ast_tree, "?", kind)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_invalid_position_information(self):
-        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}"):
-                snippet = "a = 1"
-                tree = ast.parse(snippet)
-                tree.body[0].lineno = lineno
-                tree.body[0].end_lineno = end_lineno
-                with self.assertRaises(ValueError):
-                    compile(tree, '<string>', 'exec')
-
-        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}"):
-                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')
-
-    # XXX RUSTPYTHON: we always require that end ranges be present
-    @unittest.expectedFailure
-    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=[])
-
-        # Check that compilation doesn't crash. Note: this may crash explicitly only on debug mode.
-        compile(tree, "<string>", "exec")
-
-    def test_slice(self):
-        slc = ast.parse("x[::]").body[0].value.slice
-        self.assertIsNone(slc.upper)
-        self.assertIsNone(slc.lower)
-        self.assertIsNone(slc.step)
-
-    def test_from_import(self):
-        im = ast.parse("from . import y").body[0]
-        self.assertIsNone(im.module)
-
-    def test_non_interned_future_from_ast(self):
-        mod = ast.parse("from __future__ import division")
-        self.assertIsInstance(mod.body[0], ast.ImportFrom)
-        mod.body[0].module = " __future__ ".strip()
-        compile(mod, "<test>", "exec")
-
-    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.assertIsNone(alias.asname)
-        self.assertEqual(alias.lineno, 1)
-        self.assertEqual(alias.end_lineno, 1)
-        self.assertEqual(alias.col_offset, 16)
-        self.assertEqual(alias.end_col_offset, 17)
-
-        im = ast.parse("from bar import *").body[0]
-        alias = im.names[0]
-        self.assertEqual(alias.name, '*')
-        self.assertIsNone(alias.asname)
-        self.assertEqual(alias.lineno, 1)
-        self.assertEqual(alias.end_lineno, 1)
-        self.assertEqual(alias.col_offset, 16)
-        self.assertEqual(alias.end_col_offset, 17)
-
-        im = ast.parse("from bar import y as z").body[0]
-        alias = im.names[0]
-        self.assertEqual(alias.name, "y")
-        self.assertEqual(alias.asname, "z")
-        self.assertEqual(alias.lineno, 1)
-        self.assertEqual(alias.end_lineno, 1)
-        self.assertEqual(alias.col_offset, 16)
-        self.assertEqual(alias.end_col_offset, 22)
-
-        im = ast.parse("import bar as foo").body[0]
-        alias = im.names[0]
-        self.assertEqual(alias.name, "bar")
-        self.assertEqual(alias.asname, "foo")
-        self.assertEqual(alias.lineno, 1)
-        self.assertEqual(alias.end_lineno, 1)
-        self.assertEqual(alias.col_offset, 7)
-        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
-
-        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)
-
-    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':
-                continue
-            if self._is_ast_node(name, item):
-                x = item()
-                if isinstance(x, ast.AST):
-                    self.assertIs(type(x._fields), tuple)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_arguments(self):
-        x = ast.arguments()
-        self.assertEqual(x._fields, ('posonlyargs', 'args', 'vararg', 'kwonlyargs',
-                                     'kw_defaults', 'kwarg', 'defaults'))
-
-        with self.assertRaises(AttributeError):
-            x.args
-        self.assertIsNone(x.vararg)
-
-        x = ast.arguments(*range(1, 8))
-        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()
-        # We can assign to _fields
-        x._fields = 666
-        self.assertEqual(x._fields, 666)
-
-    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',
-            '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',
-            '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',
-            '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',
-        ])
-
-    def test_classattrs(self):
-        x = ast.Constant()
-        self.assertEqual(x._fields, ('value', 'kind'))
-
-        with self.assertRaises(AttributeError):
-            x.value
-
-        x = ast.Constant(42)
-        self.assertEqual(x.value, 42)
-
-        with self.assertRaises(AttributeError):
-            x.lineno
-
-        with self.assertRaises(AttributeError):
-            x.foobar
-
-        x = ast.Constant(lineno=2)
-        self.assertEqual(x.lineno, 2)
-
-        x = ast.Constant(42, lineno=0)
-        self.assertEqual(x.lineno, 0)
-        self.assertEqual(x._fields, ('value', 'kind'))
-        self.assertEqual(x.value, 42)
-
-        self.assertRaises(TypeError, ast.Constant, 1, None, 2)
-        self.assertRaises(TypeError, ast.Constant, 1, None, 2, lineno=0)
-
-        # Arbitrary keyword arguments are supported
-        self.assertEqual(ast.Constant(1, foo='bar').foo, 'bar')
-
-        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.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(), Num)
-        assertStrDeprecated(self.assertNotIsInstance, Constant(), Str)
-        assertBytesDeprecated(self.assertNotIsInstance, Constant(), Bytes)
-        assertNameConstantDeprecated(self.assertNotIsInstance, Constant(), NameConstant)
-        assertEllipsisDeprecated(self.assertNotIsInstance, Constant(), Ellipsis)
-
-        class S(str): pass
-        with assertStrDeprecated():
-            self.assertIsInstance(Constant(S('42')), Str)
-        with assertNumDeprecated():
-            self.assertNotIsInstance(Constant(S('42')), Num)
-
-    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'
-        class N2(ast.Constant):
-            pass
-
-        n = N(42)
-        self.assertEqual(n.value, 42)
-        self.assertEqual(n.z, 'spam')
-        self.assertEqual(type(n), N)
-        self.assertTrue(isinstance(n, N))
-        self.assertTrue(isinstance(n, ast.Constant))
-        self.assertFalse(isinstance(n, N2))
-        self.assertFalse(isinstance(ast.Constant(42), N))
-        n = N(value=42)
-        self.assertEqual(n.value, 42)
-        self.assertEqual(type(n), N)
-
-    def test_module(self):
-        body = [ast.Constant(42)]
-        x = ast.Module(body, [])
-        self.assertEqual(x.body, body)
-
-    def test_nodeclasses(self):
-        # Zero arguments constructor explicitly allowed
-        x = ast.BinOp()
-        self.assertEqual(x._fields, ('left', 'op', 'right'))
-
-        # Random attribute allowed too
-        x.foobarbaz = 5
-        self.assertEqual(x.foobarbaz, 5)
-
-        n1 = ast.Constant(1)
-        n3 = ast.Constant(3)
-        addop = ast.Add()
-        x = ast.BinOp(n1, addop, n3)
-        self.assertEqual(x.left, n1)
-        self.assertEqual(x.op, addop)
-        self.assertEqual(x.right, n3)
-
-        x = ast.BinOp(1, 2, 3)
-        self.assertEqual(x.left, 1)
-        self.assertEqual(x.op, 2)
-        self.assertEqual(x.right, 3)
-
-        x = ast.BinOp(1, 2, 3, lineno=0)
-        self.assertEqual(x.left, 1)
-        self.assertEqual(x.op, 2)
-        self.assertEqual(x.right, 3)
-        self.assertEqual(x.lineno, 0)
-
-        # node raises exception when given too many arguments
-        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4)
-        # node raises exception when given too many arguments
-        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0)
-
-        # can set attributes through kwargs too
-        x = ast.BinOp(left=1, op=2, right=3, lineno=0)
-        self.assertEqual(x.left, 1)
-        self.assertEqual(x.op, 2)
-        self.assertEqual(x.right, 3)
-        self.assertEqual(x.lineno, 0)
-
-        # Random kwargs also allowed
-        x = ast.BinOp(1, 2, 3, foobarbaz=42)
-        self.assertEqual(x.foobarbaz, 42)
-
-    def test_no_fields(self):
-        # this used to fail because Sub._fields was None
-        x = ast.Sub()
-        self.assertEqual(x._fields, ())
-
-    # TODO: RUSTPYTHON _ast classes should be HEAPTYPES (except for _ast.AST)
-    @unittest.expectedFailure
-    def test_pickling(self):
-        import pickle
-
-        for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
-            for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests):
-                ast2 = pickle.loads(pickle.dumps(ast, protocol))
-                self.assertEqual(to_tuple(ast2), to_tuple(ast))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_invalid_identifier(self):
-        m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], [])
-        ast.fix_missing_locations(m)
-        with self.assertRaises(TypeError) as cm:
-            compile(m, "<test>", "exec")
-        self.assertIn("identifier must be of type str", str(cm.exception))
-
-    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"
-            ):
-                compile(e, "<test>", "eval")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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()")
-        empty_yield_from.body[0].body[0].value.value = None
-        with self.assertRaises(ValueError) as cm:
-            compile(empty_yield_from, "<test>", "exec")
-        self.assertIn("field 'value' is required", str(cm.exception))
-
-    @support.cpython_only
-    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')
-
-    def test_issue18374_binop_col_offset(self):
-        tree = ast.parse('4+5+6+7')
-        parent_binop = tree.body[0].value
-        child_binop = parent_binop.left
-        grandchild_binop = child_binop.left
-        self.assertEqual(parent_binop.col_offset, 0)
-        self.assertEqual(parent_binop.end_col_offset, 7)
-        self.assertEqual(child_binop.col_offset, 0)
-        self.assertEqual(child_binop.end_col_offset, 5)
-        self.assertEqual(grandchild_binop.col_offset, 0)
-        self.assertEqual(grandchild_binop.end_col_offset, 3)
-
-        tree = ast.parse('4+5-\\\n 6-7')
-        parent_binop = tree.body[0].value
-        child_binop = parent_binop.left
-        grandchild_binop = child_binop.left
-        self.assertEqual(parent_binop.col_offset, 0)
-        self.assertEqual(parent_binop.lineno, 1)
-        self.assertEqual(parent_binop.end_col_offset, 4)
-        self.assertEqual(parent_binop.end_lineno, 2)
-
-        self.assertEqual(child_binop.col_offset, 0)
-        self.assertEqual(child_binop.lineno, 1)
-        self.assertEqual(child_binop.end_col_offset, 2)
-        self.assertEqual(child_binop.end_lineno, 2)
-
-        self.assertEqual(grandchild_binop.col_offset, 0)
-        self.assertEqual(grandchild_binop.lineno, 1)
-        self.assertEqual(grandchild_binop.end_col_offset, 3)
-        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')
-        attr_b = tree.body[0].decorator_list[0].value
-        self.assertEqual(attr_b.end_col_offset, 4)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_ast_asdl_signature(self):
-        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")
-        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)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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))
-        with self.assertRaises(SyntaxError):
-            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('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))
-        with self.assertRaises(SyntaxError):
-            ast.parse('lambda x=1, /: ...', feature_version=(3, 7))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_parenthesized_with_feature_version(self):
-        ast.parse('with (CtxManager() as example): ...', feature_version=(3, 10))
-        # While advertised as a feature in Python 3.10, this was allowed starting 3.9
-        ast.parse('with (CtxManager() as example): ...', feature_version=(3, 9))
-        with self.assertRaises(SyntaxError):
-            ast.parse('with (CtxManager() as example): ...', feature_version=(3, 8))
-        ast.parse('with CtxManager() as example: ...', feature_version=(3, 8))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_assignment_expression_feature_version(self):
-        ast.parse('(x := 0)', feature_version=(3, 8))
-        with self.assertRaises(SyntaxError):
-            ast.parse('(x := 0)', feature_version=(3, 7))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_exception_groups_feature_version(self):
-        code = dedent('''
-        try: ...
-        except* Exception: ...
-        ''')
-        ast.parse(code)
-        with self.assertRaises(SyntaxError):
-            ast.parse(code, feature_version=(3, 10))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_type_params_feature_version(self):
-        samples = [
-            "type X = int",
-            "class X[T]: pass",
-            "def f[T](): pass",
-        ]
-        for sample in samples:
-            with self.subTest(sample):
-                ast.parse(sample)
-                with self.assertRaises(SyntaxError):
-                    ast.parse(sample, feature_version=(3, 11))
-
-    def test_invalid_major_feature_version(self):
-        with self.assertRaises(ValueError):
-            ast.parse('pass', feature_version=(2, 7))
-        with self.assertRaises(ValueError):
-            ast.parse('pass', feature_version=(4, 0))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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"):
-                compile(expr, "<test>", "eval")
-
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: enum mismatch")
-    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'
-            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'
-            ATOM = enum.auto()
-            def next(self):
-                try:
-                    return self.__class__(self + 1)
-                except ValueError:
-                    return self
-        enum._test_simple_enum(_Precedence, ast._Precedence)
-
-    @unittest.skipIf(support.is_wasi, "exhausts limited stack on WASI")
-    @support.cpython_only
-    def test_ast_recursion_limit(self):
-        fail_depth = support.EXCEEDS_RECURSION_LIMIT
-        crash_depth = 100_000
-        success_depth = 1200
-
-        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)
-
-        check_limit("a", "()")
-        check_limit("a", ".b")
-        check_limit("a", "[0]")
-        check_limit("a", "*a")
-
-    def test_null_bytes(self):
-        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:
-        with self.subTest(f"{node.__name__}.{attr}"):
-            tree = ast.parse(source)
-            found = 0
-            for child in ast.walk(tree):
-                if isinstance(child, node):
-                    setattr(child, attr, None)
-                    found += 1
-            self.assertEqual(found, 1)
-            e = re.escape(f"field '{attr}' is required for {node.__name__}")
-            with self.assertRaisesRegex(ValueError, f"^{e}$"):
-                compile(tree, "<test>", "exec")
-
-    @unittest.skip("TODO: RUSTPYTHON, TypeError: Expected type 'str' but 'NoneType' found")
-    def test_none_checks(self) -> None:
-        tests = [
-            (ast.alias, "name", "import spam as SPAM"),
-            (ast.arg, "arg", "def spam(SPAM): spam"),
-            (ast.comprehension, "target", "[spam for SPAM in spam]"),
-            (ast.comprehension, "iter", "[spam for spam in SPAM]"),
-            (ast.keyword, "value", "spam(**SPAM)"),
-            (ast.match_case, "pattern", "match spam:\n case SPAM: spam"),
-            (ast.withitem, "context_expr", "with SPAM: spam"),
-        ]
-        for node, attr, source in tests:
-            self.assert_none_check(node, attr, source)
-
-class ASTHelpers_Test(unittest.TestCase):
-    maxDiff = None
-
-    def test_parse(self):
-        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
-        except Exception:
-            with self.assertRaises(SyntaxError) as e:
-                ast.literal_eval(r"'\U'")
-            self.assertIsNotNone(e.exception.__context__)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_dump(self):
-        node = ast.parse('spam(eggs, "and cheese")')
-        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')], "
-            "keywords=[]))], type_ignores=[])"
-        )
-        self.assertEqual(ast.dump(node, annotate_fields=False),
-            "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), "
-            "Constant('and cheese')], []))], [])"
-        )
-        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)], keywords=[], "
-            "lineno=1, col_offset=0, end_lineno=1, end_col_offset=24), "
-            "lineno=1, col_offset=0, end_lineno=1, end_col_offset=24)], type_ignores=[])"
-        )
-
-    # TODO: RUSTPYTHON; redundant kind for Contant node
-    @unittest.expectedFailure
-    def test_dump_indent(self):
-        node = ast.parse('spam(eggs, "and cheese")')
-        self.assertEqual(ast.dump(node, indent=3), """\
-Module(
-   body=[
-      Expr(
-         value=Call(
-            func=Name(id='spam', ctx=Load()),
-            args=[
-               Name(id='eggs', ctx=Load()),
-               Constant(value='and cheese')],
-            keywords=[]))],
-   type_ignores=[])""")
-        self.assertEqual(ast.dump(node, annotate_fields=False, indent='\t'), """\
-Module(
-\t[
-\t\tExpr(
-\t\t\tCall(
-\t\t\t\tName('spam', Load()),
-\t\t\t\t[
-\t\t\t\t\tName('eggs', Load()),
-\t\t\t\t\tConstant('and cheese')],
-\t\t\t\t[]))],
-\t[])""")
-        self.assertEqual(ast.dump(node, include_attributes=True, indent=3), """\
-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)],
-            keywords=[],
-            lineno=1,
-            col_offset=0,
-            end_lineno=1,
-            end_col_offset=24),
-         lineno=1,
-         col_offset=0,
-         end_lineno=1,
-         end_col_offset=24)],
-   type_ignores=[])""")
-
-    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)"
-        )
-        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, 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)"
-        )
-        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()))"
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_copy_location(self):
-        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))'
-        )
-        src = ast.Call(col_offset=1, lineno=1, end_lineno=1, end_col_offset=1)
-        new = ast.copy_location(src, ast.Call(col_offset=None, lineno=None))
-        self.assertIsNone(new.end_lineno)
-        self.assertIsNone(new.end_col_offset)
-        self.assertEqual(new.lineno, 1)
-        self.assertEqual(new.col_offset, 1)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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')], [])))
-        self.assertEqual(src, ast.fix_missing_locations(src))
-        self.maxDiff = None
-        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, "
-            "end_col_offset=12)], keywords=[], lineno=1, col_offset=0, end_lineno=1, "
-            "end_col_offset=13), lineno=1, col_offset=0, end_lineno=1, "
-            "end_col_offset=13), Expr(value=Call(func=Name(id='spam', ctx=Load(), "
-            "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)], keywords=[], lineno=1, col_offset=0, end_lineno=1, "
-            "end_col_offset=0), lineno=1, col_offset=0, end_lineno=1, end_col_offset=0)], "
-            "type_ignores=[])"
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_increment_lineno(self):
-        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))'
-        )
-        # issue10869: do not increment lineno of root twice
-        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))'
-        )
-        src = ast.Call(
-            func=ast.Name("test", ast.Load()), args=[], keywords=[], lineno=1
-        )
-        self.assertEqual(ast.increment_lineno(src).lineno, 2)
-        self.assertIsNone(ast.increment_lineno(src).end_lineno)
-
-    @unittest.skip("TODO: RUSTPYTHON, NameError: name 'PyCF_TYPE_COMMENTS' is not defined")
-    def test_increment_lineno_on_module(self):
-        src = ast.parse(dedent("""\
-        a = 1
-        b = 2 # type: ignore
-        c = 3
-        d = 4 # type: ignore@tag
-        """), 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')
-
-    def test_iter_fields(self):
-        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': []})
-
-    # TODO: RUSTPYTHON; redundant kind for Constant node
-    @unittest.expectedFailure
-    def test_iter_child_nodes(self):
-        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).value, 23)
-        self.assertEqual(next(iterator).value, 42)
-        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')
-
-        node = ast.parse('class foo:\n  """line one\n  line 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')
-
-        node = ast.parse('async def foo():\n  """spam\n  ham"""')
-        self.assertEqual(ast.get_docstring(node.body[0]), 'spam\nham')
-
-    def test_get_docstring_none(self):
-        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')
-        self.assertIsNone(ast.get_docstring(node))
-
-        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')
-        self.assertIsNone(ast.get_docstring(node.body[0]))
-
-        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')
-        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]))
-
-    def test_multi_line_docstring_col_offset_and_lineno_issue16806(self):
-        node = ast.parse(
-            '"""line one\nline two"""\n\n'
-            'def foo():\n  """line one\n  line two"""\n\n'
-            '  def bar():\n    """line one\n    line two"""\n'
-            '  """line one\n  line two"""\n'
-            '"""line one\nline two"""\n\n'
-        )
-        self.assertEqual(node.body[0].col_offset, 0)
-        self.assertEqual(node.body[0].lineno, 1)
-        self.assertEqual(node.body[1].body[0].col_offset, 2)
-        self.assertEqual(node.body[1].body[0].lineno, 5)
-        self.assertEqual(node.body[1].body[1].body[0].col_offset, 4)
-        self.assertEqual(node.body[1].body[1].body[0].lineno, 9)
-        self.assertEqual(node.body[1].body[2].col_offset, 2)
-        self.assertEqual(node.body[1].body[2].lineno, 11)
-        self.assertEqual(node.body[2].col_offset, 0)
-        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')
-        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')
-        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])')
-        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('{"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('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')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_literal_eval_str_int_limit(self):
-        with support.adjust_int_max_str_digits(4000):
-            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))
-
-    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)')
-
-    def test_literal_eval_malformed_dict_nodes(self):
-        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)])
-        self.assertRaises(ValueError, ast.literal_eval, malformed)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_literal_eval_trailing_ws(self):
-        self.assertEqual(ast.literal_eval("    -1"), -1)
-        self.assertEqual(ast.literal_eval("\t\t-1"), -1)
-        self.assertEqual(ast.literal_eval(" \t -1"), -1)
-        self.assertRaises(IndentationError, ast.literal_eval, "\n -1")
-
-    def test_literal_eval_malformed_lineno(self):
-        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:'
-        with self.assertRaisesRegex(ValueError, msg):
-            ast.literal_eval(node)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_literal_eval_syntax_errors(self):
-        with self.assertRaisesRegex(SyntaxError, "unexpected indent"):
-            ast.literal_eval(r'''
-                \
-                (\
-            \ ''')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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)]
-        mod = ast.Module(body, [])
-        with self.assertRaises(ValueError) as cm:
-            compile(mod, 'test', 'exec')
-        self.assertIn("invalid integer value: None", str(cm.exception))
-
-    # XXX RUSTPYTHON: we always require that end ranges be present
-    @unittest.expectedFailure
-    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)]
-        mod = ast.Module(body, [])
-        code = compile(mod, 'test', 'exec')
-        ns = {}
-        exec(code, ns)
-        self.assertIn('sleep', ns)
-
-    @unittest.skip("TODO: RUSTPYTHON; crash")
-    def test_recursion_direct(self):
-        e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
-        e.operand = e
-        with self.assertRaises(RecursionError):
-            with support.infinite_recursion():
-                compile(ast.Expression(e), "<test>", "eval")
-
-    @unittest.skip("TODO: RUSTPYTHON; crash")
-    def test_recursion_indirect(self):
-        e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
-        f = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
-        e.operand = f
-        f.operand = e
-        with self.assertRaises(RecursionError):
-            with support.infinite_recursion():
-                compile(ast.Expression(e), "<test>", "eval")
-
-
-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)
-        if msg is None:
-            compile(mod, "<test>", mode)
-        else:
-            with self.assertRaises(exc) as cm:
-                compile(mod, "<test>", mode)
-            self.assertIn(msg, str(cm.exception))
-
-    def expr(self, node, msg=None, *, exc=ValueError):
-        mod = ast.Module([ast.Expr(node)], [])
-        self.mod(mod, msg, exc=exc)
-
-    def stmt(self, stmt, msg=None):
-        mod = ast.Module([stmt], [])
-        self.mod(mod, msg)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_module(self):
-        m = ast.Interactive([ast.Expr(ast.Name("x", ast.Store()))])
-        self.mod(m, "must have Load context", "single")
-        m = ast.Expression(ast.Name("x", ast.Store()))
-        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):
-            if args is None:
-                args = []
-            if posonlyargs is None:
-                posonlyargs = []
-            if kwonlyargs is None:
-                kwonlyargs = []
-            if defaults is None:
-                defaults = []
-            if kw_defaults is None:
-                kw_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")
-        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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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, [])
-        self.stmt(f, "must have Load context")
-        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)
-
-    # TODO: RUSTPYTHON, match expression is not implemented yet
-    # 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())):
-    #                 return True
-    #             case _:
-    #                 return False
-
-    #     code = """
-    #         @capybara
-    #         def foo(bar) -> pacarana:
-    #             pass
-    #     """
-    #     source = ast.parse(textwrap.dedent(code))
-    #     funcdef = source.body[0]
-    #     self.assertIsInstance(funcdef, ast.FunctionDef)
-    #     self.assertTrue(matcher(funcdef))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_classdef(self):
-        def cls(bases=None, keywords=None, body=None, decorator_list=None, type_params=None):
-            if bases is None:
-                bases = []
-            if keywords is None:
-                keywords = []
-            if body is None:
-                body = [ast.Pass()]
-            if decorator_list is None:
-                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")
-        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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_augassign(self):
-        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()))
-        self.stmt(aug, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-        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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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()))])
-        self.stmt(i, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_with(self):
-        p = ast.Pass()
-        self.stmt(ast.With([], [p]), "empty items on With")
-        i = ast.withitem(ast.Constant(3), None)
-        self.stmt(ast.With([i], []), "empty body on With")
-        i = ast.withitem(ast.Name("x", ast.Store()), None)
-        self.stmt(ast.With([i], [p]), "must have Load context")
-        i = ast.withitem(ast.Constant(3), ast.Name("x", ast.Load()))
-        self.stmt(ast.With([i], [p]), "must have Store context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_raise(self):
-        r = ast.Raise(None, ast.Constant(3))
-        self.stmt(r, "Raise with cause but no exception")
-        r = ast.Raise(ast.Name("x", ast.Store()), None)
-        self.stmt(r, "must have Load context")
-        r = ast.Raise(ast.Constant(4), ast.Name("x", ast.Store()))
-        self.stmt(r, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_try(self):
-        p = ast.Pass()
-        t = ast.Try([], [], [], [p])
-        self.stmt(t, "empty body on Try")
-        t = ast.Try([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
-        self.stmt(t, "must have Load context")
-        t = ast.Try([p], [], [], [])
-        self.stmt(t, "Try has neither except handlers nor finalbody")
-        t = ast.Try([p], [], [p], [p])
-        self.stmt(t, "Try has orelse but no except handlers")
-        t = ast.Try([p], [ast.ExceptHandler(None, "x", [])], [], [])
-        self.stmt(t, "empty body on ExceptHandler")
-        e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
-        self.stmt(ast.Try([p], e, [], []), "must have Load context")
-        e = [ast.ExceptHandler(None, "x", [p])]
-        t = ast.Try([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
-        self.stmt(t, "must have Load context")
-        t = ast.Try([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
-        self.stmt(t, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON, SyntaxError: RustPython does not implement this feature yet")
-    def test_try_star(self):
-        p = ast.Pass()
-        t = ast.TryStar([], [], [], [p])
-        self.stmt(t, "empty body on TryStar")
-        t = ast.TryStar([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
-        self.stmt(t, "must have Load context")
-        t = ast.TryStar([p], [], [], [])
-        self.stmt(t, "TryStar has neither except handlers nor finalbody")
-        t = ast.TryStar([p], [], [p], [p])
-        self.stmt(t, "TryStar has orelse but no except handlers")
-        t = ast.TryStar([p], [ast.ExceptHandler(None, "x", [])], [], [])
-        self.stmt(t, "empty body on ExceptHandler")
-        e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
-        self.stmt(ast.TryStar([p], e, [], []), "must have Load context")
-        e = [ast.ExceptHandler(None, "x", [p])]
-        t = ast.TryStar([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
-        self.stmt(t, "must have Load context")
-        t = ast.TryStar([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
-        self.stmt(t, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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(assrt, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_import(self):
-        self.stmt(ast.Import([]), "empty names on Import")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_global(self):
-        self.stmt(ast.Global([]), "empty names on Global")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_nonlocal(self):
-        self.stmt(ast.Nonlocal([]), "empty names on Nonlocal")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_expr(self):
-        e = ast.Expr(ast.Name("x", ast.Store()))
-        self.stmt(e, "must have Load context")
-
-    @unittest.skip("TODO: RUSTPYTHON, thread 'main' panicked at 'called `Option::unwrap()` on a `None` value'")
-    def test_boolop(self):
-        b = ast.BoolOp(ast.And(), [])
-        self.expr(b, "less than 2 values")
-        b = ast.BoolOp(ast.And(), [ast.Constant(3)])
-        self.expr(b, "less than 2 values")
-        b = ast.BoolOp(ast.And(), [ast.Constant(4), None])
-        self.expr(b, "None disallowed")
-        b = ast.BoolOp(ast.And(), [ast.Constant(4), ast.Name("x", ast.Store())])
-        self.expr(b, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_unaryop(self):
-        u = ast.UnaryOp(ast.Not(), ast.Name("x", ast.Store()))
-        self.expr(u, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_lambda(self):
-        a = ast.arguments([], [], None, [], [], None, [])
-        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)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_set(self):
-        self.expr(ast.Set([None]), "None disallowed")
-        s = ast.Set([ast.Name("x", ast.Store())])
-        self.expr(s, "must have Load context")
-
-    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)
-        self.expr(fac([g]), "must have Store context")
-        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())
-        g = ast.comprehension(x, y, [None], 0)
-        self.expr(fac([g]), "None disallowed")
-        g = ast.comprehension(x, y, [ast.Name("x", ast.Store())], 0)
-        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")
-        def wrap(gens):
-            return fac(ast.Name("x", ast.Store()), gens)
-        self._check_comprehension(wrap)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_listcomp(self):
-        self._simple_comp(ast.ListComp)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_setcomp(self):
-        self._simple_comp(ast.SetComp)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_generatorexp(self):
-        self._simple_comp(ast.GeneratorExp)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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])
-        self.expr(c, "must have Load context")
-        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)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    @unittest.skip("TODO: RUSTPYTHON, thread 'main' panicked at 'assertion failed: `(left == right)` left: `0`, right: `1`'")
-    def test_compare(self):
-        left = ast.Name("x", ast.Load())
-        comp = ast.Compare(left, [ast.In()], [])
-        self.expr(comp, "no comparators")
-        comp = ast.Compare(left, [ast.In()], [ast.Constant(4), ast.Constant(5)])
-        self.expr(comp, "different number of comparators and operands")
-        comp = ast.Compare(ast.Constant("blah"), [ast.In()], [left])
-        self.expr(comp)
-        comp = ast.Compare(left, [ast.In()], [ast.Constant("blah")])
-        self.expr(comp)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_call(self):
-        func = ast.Name("x", ast.Load())
-        args = [ast.Name("y", ast.Load())]
-        keywords = [ast.keyword("w", ast.Name("z", ast.Load()))]
-        call = ast.Call(ast.Name("x", ast.Store()), args, keywords)
-        self.expr(call, "must have Load context")
-        call = ast.Call(func, [None], keywords)
-        self.expr(call, "None disallowed")
-        bad_keywords = [ast.keyword("w", ast.Name("z", ast.Store()))]
-        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',
-        ])
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_attribute(self):
-        attr = ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load())
-        self.expr(attr, "must have Load context")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_subscript(self):
-        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())
-        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")
-        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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_starred(self):
-        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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_list(self):
-        self._sequence(ast.List)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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',
-        ])
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @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:
-            with self.subTest(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")
-
-    constant_1 = ast.Constant(1)
-    pattern_1 = ast.MatchValue(constant_1)
-
-    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())
-
-    _MATCH_PATTERNS = [
-        ast.MatchValue(
-            ast.Attribute(
-                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.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.MatchMapping(
-            [constant_true, constant_1],
-            [pattern_x, pattern_1],
-            rest='True'
-        ),
-        ast.MatchMapping(
-            [constant_true, ast.Starred(ast.Name('lol', ast.Load()), ast.Load())],
-            [pattern_x, pattern_1],
-            rest='legit'
-        ),
-        ast.MatchClass(
-            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]
-        ),
-        ast.MatchClass(
-            name_carter,
-            patterns=[],
-            kwd_attrs=[],
-            kwd_patterns=[pattern_1]
-        ),
-        ast.MatchClass(
-            name_carter,
-            patterns=[ast.MatchSingleton('string')],
-            kwd_attrs=[],
-            kwd_patterns=[]
-        ),
-        ast.MatchClass(
-            name_carter,
-            patterns=[ast.MatchStar()],
-            kwd_attrs=[],
-            kwd_patterns=[]
-        ),
-        ast.MatchClass(
-            name_carter,
-            patterns=[],
-            kwd_attrs=[],
-            kwd_patterns=[ast.MatchStar()]
-        ),
-        ast.MatchClass(
-            constant_true,  # invalid name
-            patterns=[],
-            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.MatchAs(name="_"),
-        ast.MatchStar(name="x"),
-        ast.MatchSequence([ast.MatchStar("_")]),
-        ast.MatchMapping([], [], rest="_"),
-    ]
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_match_validation_pattern(self):
-        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()]
-                        )
-                    ]
-                )
-                node = ast.fix_missing_locations(node)
-                module = ast.Module([node], [])
-                with self.assertRaises(ValueError):
-                    compile(module, "<test>", "exec")
-
-
-class ConstantTests(unittest.TestCase):
-    """Tests on the ast.Constant node type."""
-
-    def compile_constant(self, value):
-        tree = ast.parse("x = 123")
-
-        node = tree.body[0].value
-        new_node = ast.Constant(value=value)
-        ast.copy_location(new_node, node)
-        tree.body[0].value = new_node
-
-        code = compile(tree, "<string>", "exec")
-
-        ns = {}
-        exec(code, ns)
-        return ns['x']
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_singletons(self):
-        for const in (None, False, True, Ellipsis, b'', frozenset()):
-            with self.subTest(const=const):
-                value = self.compile_constant(const)
-                self.assertIs(value, const)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    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)
-        for value in values:
-            with self.subTest(value=value):
-                result = self.compile_constant(value)
-                self.assertEqual(result, value)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_assign_to_constant(self):
-        tree = ast.parse("x = 1")
-
-        target = tree.body[0].targets[0]
-        new_target = ast.Constant(value=1)
-        ast.copy_location(new_target, target)
-        tree.body[0].targets[0] = new_target
-
-        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")
-
-    def test_get_docstring(self):
-        tree = ast.parse("'docstring'\nx = 1")
-        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')
-        consts = []
-        for instr in dis.get_instructions(co):
-            if instr.opname == 'LOAD_CONST' or instr.opname == 'RETURN_CONST':
-                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.extend((Ellipsis, None))
-
-        tree = ast.parse(code)
-        self.assertEqual(self.get_load_const(tree),
-                         consts)
-
-        # Replace expression nodes with constants
-        for assign, const in zip(tree.body, consts):
-            assert isinstance(assign, ast.Assign), ast.dump(assign)
-            new_node = ast.Constant(value=const)
-            ast.copy_location(new_node, assign.value)
-            assign.value = new_node
-
-        self.assertEqual(self.get_load_const(tree),
-                         consts)
-
-    def test_literal_eval(self):
-        tree = ast.parse("1 + 2")
-        binop = tree.body[0].value
-
-        new_left = ast.Constant(value=10)
-        ast.copy_location(new_left, binop.left)
-        binop.left = new_left
-
-        new_right = ast.Constant(value=20j)
-        ast.copy_location(new_right, binop.right)
-        binop.right = new_right
-
-        self.assertEqual(ast.literal_eval(binop), 10+20j)
-
-    def test_string_kind(self):
-        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
-        self.assertEqual(c.value, "x")
-        self.assertEqual(c.kind, "u")
-
-        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
-        self.assertEqual(c.value, b"x")
-        self.assertEqual(c.kind, None)
-
-
-class EndPositionTests(unittest.TestCase):
-    """Tests for end position of AST nodes.
-
-    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)
-
-    def _check_content(self, source, ast_node, content):
-        self.assertEqual(ast.get_source_segment(source, ast_node), content)
-
-    def _parse_value(self, s):
-        # Use duck-typing to support both single expression
-        # and a right hand side of an assignment statement.
-        return ast.parse(s).body[0].value
-
-    def test_lambda(self):
-        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')
-
-    def test_func_def(self):
-        s = dedent('''
-            def func(x: int,
-                     *args: str,
-                     z: float = 0,
-                     **kwargs: Any) -> bool:
-                return True
-            ''').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')
-
-    def test_call(self):
-        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')
-
-    def test_call_noargs(self):
-        s = 'x[0]()'
-        call = self._parse_value(s)
-        self._check_content(s, call.func, 'x[0]')
-        self._check_end_pos(call, 1, 6)
-
-    def test_class_def(self):
-        s = dedent('''
-            class C(A, B):
-                x: int = 0
-        ''').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')
-
-    def test_class_kw(self):
-        s = 'class S(metaclass=abc.ABCMeta): pass'
-        cdef = ast.parse(s).body[0]
-        self._check_content(s, cdef.keywords[0].value, 'abc.ABCMeta')
-
-    def test_multi_line_str(self):
-        s = dedent('''
-            x = """Some multi-line text.
-
-            It goes on starting from same indent."""
-        ''').strip()
-        assign = ast.parse(s).body[0]
-        self._check_end_pos(assign, 3, 40)
-        self._check_end_pos(assign.value, 3, 40)
-
-    def test_continued_str(self):
-        s = dedent('''
-            x = "first part" \\
-            "second part"
-        ''').strip()
-        assign = ast.parse(s).body[0]
-        self._check_end_pos(assign, 2, 13)
-        self._check_end_pos(assign.value, 2, 13)
-
-    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('''
-            while True:
-                pass
-
-            if one():
-                x = None
-            elif other():
-                y = None
-            else:
-                z = None
-
-            for x, y in stuff:
-                assert True
-
-            try:
-                raise RuntimeError
-            except TypeError as e:
-                pass
-
-            pass
-        ''').strip()
-        mod = ast.parse(s)
-        while_loop = mod.body[0]
-        if_stmt = mod.body[1]
-        for_loop = mod.body[2]
-        try_stmt = mod.body[3]
-        pass_stmt = mod.body[4]
-
-        self._check_end_pos(while_loop, 2, 8)
-        self._check_end_pos(if_stmt, 9, 12)
-        self._check_end_pos(for_loop, 12, 15)
-        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')
-
-    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')
-
-    def test_fstring_multi_line(self):
-        s = dedent('''
-            f"""Some multi-line text.
-            {
-            arg_one
-            +
-            arg_two
-            }
-            It goes on..."""
-        ''').strip()
-        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')
-
-    def test_import_from_multi_line(self):
-        s = dedent('''
-            from x.y.z import (
-                a, b, c as c
-            )
-        ''').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('''
-            x[ a.b: f () ,
-               g () : c.d
-              ]
-        ''').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_end_pos(im, 3, 3)
-
-    def test_binop(self):
-        s = dedent('''
-            (1 * 2 + (3 ) +
-                 4
-            )
-        ''').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')
-
-    def test_boolop(self):
-        s = dedent('''
-            if (one_condition and
-                    (other_condition or yet_another_one)):
-                pass
-        ''').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')
-
-    def test_tuples(self):
-        s1 = 'x = () ;'
-        s2 = 'x = 1 , ;'
-        s3 = 'x = (1 , 2 ) ;'
-        sm = dedent('''
-            x = (
-                a, b,
-            )
-        ''').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_end_pos(tm, 3, 1)
-
-    def test_attribute_spaces(self):
-        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')
-
-    def test_redundant_parenthesis(self):
-        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
-        v = ast.parse(s2).body[0].value.value
-        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'),
-        )
-        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
-                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 () ,}'
-        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 ()')
-
-    def test_comprehensions(self):
-        s = dedent('''
-            x = [{x for x, y in stuff
-                  if cond.x} for stuff in things]
-        ''').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')
-
-    def test_yield_await(self):
-        s = dedent('''
-            async def f():
-                yield x
-                await y
-        ''').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')
-
-    def test_source_segment_multi(self):
-        s_orig = dedent('''
-            x = (
-                a, b,
-            ) + ()
-        ''').strip()
-        s_tuple = dedent('''
-            (
-                a, b,
-            )
-        ''').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('''
-            class C:
-                def fun(self) -> None:
-                    "ЖЖЖЖЖ"
-        ''').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)
-
-    def test_source_segment_endings(self):
-        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')
-
-    def test_source_segment_tabs(self):
-        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'
-
-        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'
-        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')
-
-        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'
-        v, w, x, y = ast.parse(s).body
-        del v.lineno
-        del w.end_lineno
-        del x.col_offset
-        del y.end_col_offset
-        self.assertIsNone(ast.get_source_segment(s, v))
-        self.assertIsNone(ast.get_source_segment(s, w))
-        self.assertIsNone(ast.get_source_segment(s, x))
-        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):
-        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))
-
-        self.assertASTEqual(result_ast, expected_ast)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_node_remove_single(self):
-        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':
-                    return None
-                return node
-
-        self.assertASTTransformation(SomeTypeRemover, code, expected)
-
-    def test_node_remove_from_list(self):
-        code = """
-        def func(arg):
-            print(arg)
-            yield arg
-        """
-        expected = """
-        def func(arg):
-            print(arg)
-        """
-
-        # Since `FunctionDef.body` is defined as a list, we test
-        # the `if isinstance(old_value, list):` branch here.
-        class YieldRemover(ast.NodeTransformer):
-            def visit_Expr(self, node: ast.Expr):
-                self.generic_visit(node)
-                if isinstance(node.value, ast.Yield):
-                    return None  # Remove `yield` from a function
-                return node
-
-        self.assertASTTransformation(YieldRemover, code, expected)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_node_return_list(self):
-        code = """
-        class DSL(Base, kw1=True): ...
-        """
-        expected = """
-        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':
-                    return [
-                        node,
-                        ast.keyword('kw2', ast.Constant(True)),
-                        ast.keyword('kw3', ast.Constant(False)),
-                    ]
-                return node
-
-        self.assertASTTransformation(ExtendKeywords, code, expected)
-
-    def test_node_mutate(self):
-        code = """
-        def func(arg):
-            print(arg)
-        """
-        expected = """
-        def func(arg):
-            log(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'
-                return node
-
-        self.assertASTTransformation(PrintToLog, code, expected)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_node_replace(self):
-        code = """
-        def func(arg):
-            print(arg)
-        """
-        expected = """
-        def func(arg):
-            logger.log(arg, debug=True)
-        """
-
-        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':
-                    return ast.Call(
-                        func=ast.Attribute(
-                            ast.Name('logger', ctx=ast.Load()),
-                            attr='log',
-                            ctx=ast.Load(),
-                        ),
-                        args=node.args,
-                        keywords=[ast.keyword('debug', ast.Constant(True))],
-                    )
-                return node
-
-        self.assertASTTransformation(PrintToLog, code, expected)
-
-
-@support.cpython_only
-class ModuleStateTests(unittest.TestCase):
-    # bpo-41194, bpo-41261, bpo-41631: The _ast module uses a global state.
-
-    def check_ast_module(self):
-        # Check that the _ast module still works as expected
-        code = 'x + 1'
-        filename = '<string>'
-        mode = 'eval'
-
-        # Create _ast.AST subclasses instances
-        ast_tree = compile(code, filename, mode, flags=ast.PyCF_ONLY_AST)
-
-        # Call PyAST_Check()
-        code = compile(ast_tree, filename, mode)
-        self.assertIsInstance(code, types.CodeType)
-
-    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']
-            import _ast as ast1
-
-            del sys.modules['_ast']
-            import _ast as ast2
-
-            self.check_ast_module()
-
-        # Unloading the two _ast module instances must not crash.
-        del ast1
-        del ast2
-        support.gc_collect()
-
-        self.check_ast_module()
-
-    def test_sys_modules(self):
-        # bpo-41631: Test reproducing a Mercurial crash when PyAST_Check()
-        # imported the _ast module internally.
-        lazy_mod = object()
-
-        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_attr(builtins, '__import__', my_import):
-                # Test that compile() does not import the _ast module
-                self.check_ast_module()
-                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('''
-            import _ast
-            import ast
-            import gc
-            import sys
-            import types
-
-            # Create _ast.AST subclasses instances and call PyAST_Check()
-            ast_tree = compile('x+1', '<string>', 'eval',
-                               flags=ast.PyCF_ONLY_AST)
-            code = compile(ast_tree, 'string', 'eval')
-            if not isinstance(code, types.CodeType):
-                raise AssertionError
-
-            # Unloading the _ast module must not crash.
-            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.
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_cli_file_input(self):
-        code = "print(1, 2, 3)"
-        expected = ast.dump(ast.parse(code), indent=3)
-
-        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)
-
-        self.assertEqual(res.err, b"")
-        self.assertEqual(expected.splitlines(),
-                         res.out.decode("utf8").splitlines())
-        self.assertEqual(res.rc, 0)
-
-
-def main():
-    if __name__ != '__main__':
-        return
-    if sys.argv[1:] == ['-g']:
-        for statements, kind in ((exec_tests, "exec"), (single_tests, "single"),
-                                 (eval_tests, "eval")):
-            print(kind+"_results = [")
-            for statement in statements:
-                tree = ast.parse(statement, "?", kind)
-                print("%r," % (to_tuple(tree),))
-            print("]")
-        print("main()")
-        raise SystemExit
-    unittest.main()
-
-#### EVERYTHING BELOW IS GENERATED BY python Lib/test/test_ast.py -g  #####
-exec_results = [
-('Module', [('Expr', (1, 0, 1, 4), ('Constant', (1, 0, 1, 4), None, None))], []),
-('Module', [('Expr', (1, 0, 1, 18), ('Constant', (1, 0, 1, 18), 'module docstring', None))], []),
-('Module', [('FunctionDef', (1, 0, 1, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 9, 1, 13))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 29), ('Constant', (1, 9, 1, 29), 'function docstring', None))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 14), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, []), [('Pass', (1, 10, 1, 14))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 0, None)]), [('Pass', (1, 12, 1, 16))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 11), 'args', None, None), [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 23), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 16), 'args', ('Starred', (1, 13, 1, 16), ('Name', (1, 14, 1, 16), 'Ts', ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 19, 1, 23))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Constant', (1, 25, 1, 28), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Starred', (1, 25, 1, 28), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 21), 'f', ('arguments', [], [], None, [], [], ('arg', (1, 8, 1, 14), 'kwargs', None, None), []), [('Pass', (1, 17, 1, 21))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 71), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None), ('arg', (1, 9, 1, 10), 'b', None, None), ('arg', (1, 14, 1, 15), 'c', None, None), ('arg', (1, 22, 1, 23), 'd', None, None), ('arg', (1, 28, 1, 29), 'e', None, None)], ('arg', (1, 35, 1, 39), 'args', None, None), [('arg', (1, 41, 1, 42), 'f', None, None)], [('Constant', (1, 43, 1, 45), 42, None)], ('arg', (1, 49, 1, 55), 'kwargs', None, None), [('Constant', (1, 11, 1, 12), 1, None), ('Constant', (1, 16, 1, 20), None, None), ('List', (1, 24, 1, 26), [], ('Load',)), ('Dict', (1, 30, 1, 32), [], [])]), [('Expr', (1, 58, 1, 71), ('Constant', (1, 58, 1, 71), 'doc for f()', None))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 27), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 23, 1, 27))], [], ('Subscript', (1, 11, 1, 21), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 20), [('Starred', (1, 17, 1, 20), ('Name', (1, 18, 1, 20), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 28, 1, 32))], [], ('Subscript', (1, 11, 1, 26), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 25), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 25), ('Name', (1, 23, 1, 25), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 45), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 41, 1, 45))], [], ('Subscript', (1, 11, 1, 39), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 38), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 38), ('Subscript', (1, 23, 1, 38), ('Name', (1, 23, 1, 28), 'tuple', ('Load',)), ('Tuple', (1, 29, 1, 37), [('Name', (1, 29, 1, 32), 'int', ('Load',)), ('Constant', (1, 34, 1, 37), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
-('Module', [('ClassDef', (1, 0, 1, 12), 'C', [], [], [('Pass', (1, 8, 1, 12))], [], [])], []),
-('Module', [('ClassDef', (1, 0, 1, 32), 'C', [], [], [('Expr', (1, 9, 1, 32), ('Constant', (1, 9, 1, 32), 'docstring for class C', None))], [], [])], []),
-('Module', [('ClassDef', (1, 0, 1, 21), 'C', [('Name', (1, 8, 1, 14), 'object', ('Load',))], [], [('Pass', (1, 17, 1, 21))], [], [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Return', (1, 8, 1, 16), ('Constant', (1, 15, 1, 16), 1, None))], [], None, None, [])], []),
-('Module', [('Delete', (1, 0, 1, 5), [('Name', (1, 4, 1, 5), 'v', ('Del',))])], []),
-('Module', [('Assign', (1, 0, 1, 5), [('Name', (1, 0, 1, 1), 'v', ('Store',))], ('Constant', (1, 4, 1, 5), 1, None), None)], []),
-('Module', [('Assign', (1, 0, 1, 7), [('Tuple', (1, 0, 1, 3), [('Name', (1, 0, 1, 1), 'a', ('Store',)), ('Name', (1, 2, 1, 3), 'b', ('Store',))], ('Store',))], ('Name', (1, 6, 1, 7), 'c', ('Load',)), None)], []),
-('Module', [('Assign', (1, 0, 1, 9), [('Tuple', (1, 0, 1, 5), [('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Name', (1, 3, 1, 4), 'b', ('Store',))], ('Store',))], ('Name', (1, 8, 1, 9), 'c', ('Load',)), None)], []),
-('Module', [('Assign', (1, 0, 1, 9), [('List', (1, 0, 1, 5), [('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Name', (1, 3, 1, 4), 'b', ('Store',))], ('Store',))], ('Name', (1, 8, 1, 9), 'c', ('Load',)), None)], []),
-('Module', [('AnnAssign', (1, 0, 1, 13), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 13), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 12), [('Starred', (1, 9, 1, 12), ('Name', (1, 10, 1, 12), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
-('Module', [('AnnAssign', (1, 0, 1, 18), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 18), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 17), [('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Starred', (1, 14, 1, 17), ('Name', (1, 15, 1, 17), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
-('Module', [('AnnAssign', (1, 0, 1, 31), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 31), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 30), [('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Starred', (1, 14, 1, 30), ('Subscript', (1, 15, 1, 30), ('Name', (1, 15, 1, 20), 'tuple', ('Load',)), ('Tuple', (1, 21, 1, 29), [('Name', (1, 21, 1, 24), 'str', ('Load',)), ('Constant', (1, 26, 1, 29), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
-('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Add',), ('Constant', (1, 5, 1, 6), 1, None))], []),
-('Module', [('For', (1, 0, 1, 15), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Pass', (1, 11, 1, 15))], [], None)], []),
-('Module', [('While', (1, 0, 1, 12), ('Name', (1, 6, 1, 7), 'v', ('Load',)), [('Pass', (1, 8, 1, 12))], [])], []),
-('Module', [('If', (1, 0, 1, 9), ('Name', (1, 3, 1, 4), 'v', ('Load',)), [('Pass', (1, 5, 1, 9))], [])], []),
-('Module', [('If', (1, 0, 4, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('If', (3, 0, 4, 6), ('Name', (3, 5, 3, 6), 'b', ('Load',)), [('Pass', (4, 2, 4, 6))], [])])], []),
-('Module', [('If', (1, 0, 6, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('If', (3, 0, 6, 6), ('Name', (3, 5, 3, 6), 'b', ('Load',)), [('Pass', (4, 2, 4, 6))], [('Pass', (6, 2, 6, 6))])])], []),
-('Module', [('With', (1, 0, 1, 17), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), ('Name', (1, 10, 1, 11), 'y', ('Store',)))], [('Pass', (1, 13, 1, 17))], None)], []),
-('Module', [('With', (1, 0, 1, 25), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), ('Name', (1, 10, 1, 11), 'y', ('Store',))), ('withitem', ('Name', (1, 13, 1, 14), 'z', ('Load',)), ('Name', (1, 18, 1, 19), 'q', ('Store',)))], [('Pass', (1, 21, 1, 25))], None)], []),
-('Module', [('Raise', (1, 0, 1, 25), ('Call', (1, 6, 1, 25), ('Name', (1, 6, 1, 15), 'Exception', ('Load',)), [('Constant', (1, 16, 1, 24), 'string', None)], []), None)], []),
-('Module', [('Try', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 7, 3, 16), 'Exception', ('Load',)), None, [('Pass', (4, 2, 4, 6))])], [], [])], []),
-('Module', [('Try', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [], [], [('Pass', (4, 2, 4, 6))])], []),
-('Module', [('TryStar', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 8, 3, 17), 'Exception', ('Load',)), None, [('Pass', (4, 2, 4, 6))])], [], [])], []),
-('Module', [('Assert', (1, 0, 1, 8), ('Name', (1, 7, 1, 8), 'v', ('Load',)), None)], []),
-('Module', [('Import', (1, 0, 1, 10), [('alias', (1, 7, 1, 10), 'sys', None)])], []),
-('Module', [('ImportFrom', (1, 0, 1, 17), 'sys', [('alias', (1, 16, 1, 17), 'v', None)], 0)], []),
-('Module', [('Global', (1, 0, 1, 8), ['v'])], []),
-('Module', [('Expr', (1, 0, 1, 1), ('Constant', (1, 0, 1, 1), 1, None))], []),
-('Module', [('Pass', (1, 0, 1, 4))], []),
-('Module', [('For', (1, 0, 1, 16), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Break', (1, 11, 1, 16))], [], None)], []),
-('Module', [('For', (1, 0, 1, 19), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Continue', (1, 11, 1, 19))], [], None)], []),
-('Module', [('For', (1, 0, 1, 18), ('Tuple', (1, 4, 1, 7), [('Name', (1, 4, 1, 5), 'a', ('Store',)), ('Name', (1, 6, 1, 7), 'b', ('Store',))], ('Store',)), ('Name', (1, 11, 1, 12), 'c', ('Load',)), [('Pass', (1, 14, 1, 18))], [], None)], []),
-('Module', [('For', (1, 0, 1, 20), ('Tuple', (1, 4, 1, 9), [('Name', (1, 5, 1, 6), 'a', ('Store',)), ('Name', (1, 7, 1, 8), 'b', ('Store',))], ('Store',)), ('Name', (1, 13, 1, 14), 'c', ('Load',)), [('Pass', (1, 16, 1, 20))], [], None)], []),
-('Module', [('For', (1, 0, 1, 20), ('List', (1, 4, 1, 9), [('Name', (1, 5, 1, 6), 'a', ('Store',)), ('Name', (1, 7, 1, 8), 'b', ('Store',))], ('Store',)), ('Name', (1, 13, 1, 14), 'c', ('Load',)), [('Pass', (1, 16, 1, 20))], [], None)], []),
-('Module', [('Expr', (1, 0, 11, 5), ('GeneratorExp', (1, 0, 11, 5), ('Tuple', (2, 4, 6, 5), [('Name', (3, 4, 3, 6), 'Aa', ('Load',)), ('Name', (5, 7, 5, 9), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4, 10, 6), [('Name', (8, 4, 8, 6), 'Aa', ('Store',)), ('Name', (10, 4, 10, 6), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10, 10, 12), 'Cc', ('Load',)), [], 0)]))], []),
-('Module', [('Expr', (1, 0, 1, 34), ('DictComp', (1, 0, 1, 34), ('Name', (1, 1, 1, 2), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',)), [('comprehension', ('Name', (1, 11, 1, 12), 'w', ('Store',)), ('Name', (1, 16, 1, 17), 'x', ('Load',)), [], 0), ('comprehension', ('Name', (1, 22, 1, 23), 'm', ('Store',)), ('Name', (1, 27, 1, 28), 'p', ('Load',)), [('Name', (1, 32, 1, 33), 'g', ('Load',))], 0)]))], []),
-('Module', [('Expr', (1, 0, 1, 20), ('DictComp', (1, 0, 1, 20), ('Name', (1, 1, 1, 2), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'v', ('Store',)), ('Name', (1, 13, 1, 14), 'w', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'x', ('Load',)), [], 0)]))], []),
-('Module', [('Expr', (1, 0, 1, 19), ('SetComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 12, 1, 13), 'x', ('Load',)), [('Name', (1, 17, 1, 18), 'g', ('Load',))], 0)]))], []),
-('Module', [('Expr', (1, 0, 1, 16), ('SetComp', (1, 0, 1, 16), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Tuple', (1, 7, 1, 10), [('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 9, 1, 10), 'm', ('Store',))], ('Store',)), ('Name', (1, 14, 1, 15), 'x', ('Load',)), [], 0)]))], []),
-('Module', [('AsyncFunctionDef', (1, 0, 3, 18), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 17), ('Constant', (2, 1, 2, 17), 'async function', None)), ('Expr', (3, 1, 3, 18), ('Await', (3, 1, 3, 18), ('Call', (3, 7, 3, 18), ('Name', (3, 7, 3, 16), 'something', ('Load',)), [], [])))], [], None, None, [])], []),
-('Module', [('AsyncFunctionDef', (1, 0, 3, 8), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncFor', (2, 1, 3, 8), ('Name', (2, 11, 2, 12), 'e', ('Store',)), ('Name', (2, 16, 2, 17), 'i', ('Load',)), [('Expr', (2, 19, 2, 20), ('Constant', (2, 19, 2, 20), 1, None))], [('Expr', (3, 7, 3, 8), ('Constant', (3, 7, 3, 8), 2, None))], None)], [], None, None, [])], []),
-('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncWith', (2, 1, 2, 21), [('withitem', ('Name', (2, 12, 2, 13), 'a', ('Load',)), ('Name', (2, 17, 2, 18), 'b', ('Store',)))], [('Expr', (2, 20, 2, 21), ('Constant', (2, 20, 2, 21), 1, None))], None)], [], None, None, [])], []),
-('Module', [('Expr', (1, 0, 1, 14), ('Dict', (1, 0, 1, 14), [None, ('Constant', (1, 10, 1, 11), 2, None)], [('Dict', (1, 3, 1, 8), [('Constant', (1, 4, 1, 5), 1, None)], [('Constant', (1, 6, 1, 7), 2, None)]), ('Constant', (1, 12, 1, 13), 3, None)]))], []),
-('Module', [('Expr', (1, 0, 1, 12), ('Set', (1, 0, 1, 12), [('Starred', (1, 1, 1, 8), ('Set', (1, 2, 1, 8), [('Constant', (1, 3, 1, 4), 1, None), ('Constant', (1, 6, 1, 7), 2, None)]), ('Load',)), ('Constant', (1, 10, 1, 11), 3, None)]))], []),
-('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 21), ('ListComp', (2, 1, 2, 21), ('Name', (2, 2, 2, 3), 'i', ('Load',)), [('comprehension', ('Name', (2, 14, 2, 15), 'b', ('Store',)), ('Name', (2, 19, 2, 20), 'c', ('Load',)), [], 1)]))], [], None, None, [])], []),
-('Module', [('FunctionDef', (4, 0, 4, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None, [])], []),
-('Module', [('AsyncFunctionDef', (4, 0, 4, 19), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 15, 4, 19))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None, [])], []),
-('Module', [('ClassDef', (4, 0, 4, 13), 'C', [], [], [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], [])], []),
-('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Call', (1, 1, 1, 19), ('Name', (1, 1, 1, 5), 'deco', ('Load',)), [('GeneratorExp', (1, 5, 1, 19), ('Name', (1, 6, 1, 7), 'a', ('Load',)), [('comprehension', ('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 17, 1, 18), 'b', ('Load',)), [], 0)])], [])], None, None, [])], []),
-('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Attribute', (1, 1, 1, 6), ('Attribute', (1, 1, 1, 4), ('Name', (1, 1, 1, 2), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',))], None, None, [])], []),
-('Module', [('Expr', (1, 0, 1, 8), ('NamedExpr', (1, 1, 1, 7), ('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Constant', (1, 6, 1, 7), 1, None)))], []),
-('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None), ('arg', (1, 15, 1, 16), 'd', None, None), ('arg', (1, 18, 1, 19), 'e', None, None)], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], None, []), [('Pass', (1, 25, 1, 29))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 39), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], ('arg', (1, 26, 1, 32), 'kwargs', None, None), []), [('Pass', (1, 35, 1, 39))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 20), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None)]), [('Pass', (1, 16, 1, 20))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None), ('arg', (1, 19, 1, 20), 'c', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None), ('Constant', (1, 21, 1, 22), 4, None)]), [('Pass', (1, 25, 1, 29))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 28, 1, 32))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 30), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 26, 1, 30))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 42), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], ('arg', (1, 29, 1, 35), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 38, 1, 42))], [], None, None, [])], []),
-('Module', [('FunctionDef', (1, 0, 1, 40), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], ('arg', (1, 27, 1, 33), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 36, 1, 40))], [], None, None, [])], []),
-('Module', [('TypeAlias', (1, 0, 1, 12), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [], ('Name', (1, 9, 1, 12), 'int', ('Load',)))], []),
-('Module', [('TypeAlias', (1, 0, 1, 15), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None)], ('Name', (1, 12, 1, 15), 'int', ('Load',)))], []),
-('Module', [('TypeAlias', (1, 0, 1, 32), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None), ('TypeVarTuple', (1, 10, 1, 13), 'Ts'), ('ParamSpec', (1, 15, 1, 18), 'P')], ('Tuple', (1, 22, 1, 32), [('Name', (1, 23, 1, 24), 'T', ('Load',)), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Name', (1, 30, 1, 31), 'P', ('Load',))], ('Load',)))], []),
-('Module', [('TypeAlias', (1, 0, 1, 37), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 13), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',))), ('TypeVarTuple', (1, 15, 1, 18), 'Ts'), ('ParamSpec', (1, 20, 1, 23), 'P')], ('Tuple', (1, 27, 1, 37), [('Name', (1, 28, 1, 29), 'T', ('Load',)), ('Name', (1, 31, 1, 33), 'Ts', ('Load',)), ('Name', (1, 35, 1, 36), 'P', ('Load',))], ('Load',)))], []),
-('Module', [('TypeAlias', (1, 0, 1, 44), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 20), 'T', ('Tuple', (1, 10, 1, 20), [('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Name', (1, 16, 1, 19), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 22, 1, 25), 'Ts'), ('ParamSpec', (1, 27, 1, 30), 'P')], ('Tuple', (1, 34, 1, 44), [('Name', (1, 35, 1, 36), 'T', ('Load',)), ('Name', (1, 38, 1, 40), 'Ts', ('Load',)), ('Name', (1, 42, 1, 43), 'P', ('Load',))], ('Load',)))], []),
-('Module', [('ClassDef', (1, 0, 1, 16), 'X', [], [], [('Pass', (1, 12, 1, 16))], [], [('TypeVar', (1, 8, 1, 9), 'T', None)])], []),
-('Module', [('ClassDef', (1, 0, 1, 26), 'X', [], [], [('Pass', (1, 22, 1, 26))], [], [('TypeVar', (1, 8, 1, 9), 'T', None), ('TypeVarTuple', (1, 11, 1, 14), 'Ts'), ('ParamSpec', (1, 16, 1, 19), 'P')])], []),
-('Module', [('ClassDef', (1, 0, 1, 31), 'X', [], [], [('Pass', (1, 27, 1, 31))], [], [('TypeVar', (1, 8, 1, 14), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',))), ('TypeVarTuple', (1, 16, 1, 19), 'Ts'), ('ParamSpec', (1, 21, 1, 24), 'P')])], []),
-('Module', [('ClassDef', (1, 0, 1, 38), 'X', [], [], [('Pass', (1, 34, 1, 38))], [], [('TypeVar', (1, 8, 1, 21), 'T', ('Tuple', (1, 11, 1, 21), [('Name', (1, 12, 1, 15), 'int', ('Load',)), ('Name', (1, 17, 1, 20), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 23, 1, 26), 'Ts'), ('ParamSpec', (1, 28, 1, 31), 'P')])], []),
-('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 12, 1, 16))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None)])], []),
-('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None), ('TypeVarTuple', (1, 9, 1, 12), 'Ts'), ('ParamSpec', (1, 14, 1, 17), 'P')])], []),
-('Module', [('FunctionDef', (1, 0, 1, 31), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 27, 1, 31))], [], None, None, [('TypeVar', (1, 6, 1, 12), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',))), ('TypeVarTuple', (1, 14, 1, 17), 'Ts'), ('ParamSpec', (1, 19, 1, 22), 'P')])], []),
-('Module', [('FunctionDef', (1, 0, 1, 38), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 34, 1, 38))], [], None, None, [('TypeVar', (1, 6, 1, 19), 'T', ('Tuple', (1, 9, 1, 19), [('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Name', (1, 15, 1, 18), 'str', ('Load',))], ('Load',))), ('TypeVarTuple', (1, 21, 1, 24), 'Ts'), ('ParamSpec', (1, 26, 1, 29), 'P')])], []),
-]
-single_results = [
-('Interactive', [('Expr', (1, 0, 1, 3), ('BinOp', (1, 0, 1, 3), ('Constant', (1, 0, 1, 1), 1, None), ('Add',), ('Constant', (1, 2, 1, 3), 2, None)))]),
-]
-eval_results = [
-('Expression', ('Constant', (1, 0, 1, 4), None, None)),
-('Expression', ('BoolOp', (1, 0, 1, 7), ('And',), [('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Name', (1, 6, 1, 7), 'b', ('Load',))])),
-('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Add',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
-('Expression', ('UnaryOp', (1, 0, 1, 5), ('Not',), ('Name', (1, 4, 1, 5), 'v', ('Load',)))),
-('Expression', ('Lambda', (1, 0, 1, 11), ('arguments', [], [], None, [], [], None, []), ('Constant', (1, 7, 1, 11), None, None))),
-('Expression', ('Dict', (1, 0, 1, 7), [('Constant', (1, 2, 1, 3), 1, None)], [('Constant', (1, 4, 1, 5), 2, None)])),
-('Expression', ('Dict', (1, 0, 1, 2), [], [])),
-('Expression', ('Set', (1, 0, 1, 7), [('Constant', (1, 1, 1, 5), None, None)])),
-('Expression', ('Dict', (1, 0, 5, 6), [('Constant', (2, 6, 2, 7), 1, None)], [('Constant', (4, 10, 4, 11), 2, None)])),
-('Expression', ('ListComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'b', ('Store',)), ('Name', (1, 12, 1, 13), 'c', ('Load',)), [('Name', (1, 17, 1, 18), 'd', ('Load',))], 0)])),
-('Expression', ('GeneratorExp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'b', ('Store',)), ('Name', (1, 12, 1, 13), 'c', ('Load',)), [('Name', (1, 17, 1, 18), 'd', ('Load',))], 0)])),
-('Expression', ('ListComp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
-('Expression', ('ListComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('ListComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('SetComp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
-('Expression', ('SetComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('SetComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('GeneratorExp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
-('Expression', ('GeneratorExp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('GeneratorExp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
-('Expression', ('Compare', (1, 0, 1, 9), ('Constant', (1, 0, 1, 1), 1, None), [('Lt',), ('Lt',)], [('Constant', (1, 4, 1, 5), 2, None), ('Constant', (1, 8, 1, 9), 3, None)])),
-('Expression', ('Call', (1, 0, 1, 17), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('Constant', (1, 2, 1, 3), 1, None), ('Constant', (1, 4, 1, 5), 2, None), ('Starred', (1, 10, 1, 12), ('Name', (1, 11, 1, 12), 'd', ('Load',)), ('Load',))], [('keyword', (1, 6, 1, 9), 'c', ('Constant', (1, 8, 1, 9), 3, None)), ('keyword', (1, 13, 1, 16), None, ('Name', (1, 15, 1, 16), 'e', ('Load',)))])),
-('Expression', ('Call', (1, 0, 1, 10), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('Starred', (1, 2, 1, 9), ('List', (1, 3, 1, 9), [('Constant', (1, 4, 1, 5), 0, None), ('Constant', (1, 7, 1, 8), 1, None)], ('Load',)), ('Load',))], [])),
-('Expression', ('Call', (1, 0, 1, 15), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('GeneratorExp', (1, 1, 1, 15), ('Name', (1, 2, 1, 3), 'a', ('Load',)), [('comprehension', ('Name', (1, 8, 1, 9), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Load',)), [], 0)])], [])),
-('Expression', ('Constant', (1, 0, 1, 2), 10, None)),
-('Expression', ('Constant', (1, 0, 1, 8), 'string', None)),
-('Expression', ('Attribute', (1, 0, 1, 3), ('Name', (1, 0, 1, 1), 'a', ('Load',)), 'b', ('Load',))),
-('Expression', ('Subscript', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Slice', (1, 2, 1, 5), ('Name', (1, 2, 1, 3), 'b', ('Load',)), ('Name', (1, 4, 1, 5), 'c', ('Load',)), None), ('Load',))),
-('Expression', ('Name', (1, 0, 1, 1), 'v', ('Load',))),
-('Expression', ('List', (1, 0, 1, 7), [('Constant', (1, 1, 1, 2), 1, None), ('Constant', (1, 3, 1, 4), 2, None), ('Constant', (1, 5, 1, 6), 3, None)], ('Load',))),
-('Expression', ('List', (1, 0, 1, 2), [], ('Load',))),
-('Expression', ('Tuple', (1, 0, 1, 5), [('Constant', (1, 0, 1, 1), 1, None), ('Constant', (1, 2, 1, 3), 2, None), ('Constant', (1, 4, 1, 5), 3, None)], ('Load',))),
-('Expression', ('Tuple', (1, 0, 1, 7), [('Constant', (1, 1, 1, 2), 1, None), ('Constant', (1, 3, 1, 4), 2, None), ('Constant', (1, 5, 1, 6), 3, None)], ('Load',))),
-('Expression', ('Tuple', (1, 0, 1, 2), [], ('Load',))),
-('Expression', ('Call', (1, 0, 1, 17), ('Attribute', (1, 0, 1, 7), ('Attribute', (1, 0, 1, 5), ('Attribute', (1, 0, 1, 3), ('Name', (1, 0, 1, 1), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8, 1, 16), ('Attribute', (1, 8, 1, 11), ('Name', (1, 8, 1, 9), 'a', ('Load',)), 'b', ('Load',)), ('Slice', (1, 12, 1, 15), ('Constant', (1, 12, 1, 13), 1, None), ('Constant', (1, 14, 1, 15), 2, None), None), ('Load',))], [])),
-]
-main()
diff --git a/Lib/test/test_ast/__init__.py b/Lib/test/test_ast/__init__.py
new file mode 100644
index 0000000000..9a89d27ba9
--- /dev/null
+++ b/Lib/test/test_ast/__init__.py
@@ -0,0 +1,7 @@
+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_ast/snippets.py b/Lib/test/test_ast/snippets.py
new file mode 100644
index 0000000000..28d32b2941
--- /dev/null
+++ b/Lib/test/test_ast/snippets.py
@@ -0,0 +1,601 @@
+import ast
+import sys
+
+from test.test_ast.utils import to_tuple
+
+
+# These tests are compiled through "exec"
+# There should be at least one test per statement
+exec_tests = [
+    # Module docstring
+    "'module docstring'",
+    # FunctionDef
+    "def f(): pass",
+    # FunctionDef with docstring
+    "def f(): 'function docstring'",
+    # FunctionDef with arg
+    "def f(a): pass",
+    # FunctionDef with arg and default value
+    "def f(a=0): pass",
+    # FunctionDef with varargs
+    "def f(*args): pass",
+    # FunctionDef with varargs as TypeVarTuple
+    "def f(*args: *Ts): pass",
+    # FunctionDef with varargs as unpacked Tuple
+    "def f(*args: *tuple[int, ...]): pass",
+    # FunctionDef with varargs as unpacked Tuple *and* TypeVarTuple
+    "def f(*args: *tuple[int, *Ts]): pass",
+    # FunctionDef with kwargs
+    "def f(**kwargs): pass",
+    # FunctionDef with all kind of args and docstring
+    "def f(a, b=1, c=None, d=[], e={}, *args, f=42, **kwargs): 'doc for f()'",
+    # FunctionDef with type annotation on return involving unpacking
+    "def f() -> tuple[*Ts]: pass",
+    "def f() -> tuple[int, *Ts]: pass",
+    "def f() -> tuple[int, *tuple[int, ...]]: pass",
+    # ClassDef
+    "class C:pass",
+    # ClassDef with docstring
+    "class C: 'docstring for class C'",
+    # ClassDef, new style class
+    "class C(object): pass",
+    # Classdef with multiple bases
+    "class C(A, B): pass",
+    # Return
+    "def f():return 1",
+    "def f():return",
+    # Delete
+    "del v",
+    # Assign
+    "v = 1",
+    "a,b = c",
+    "(a,b) = c",
+    "[a,b] = c",
+    "a[b] = c",
+    # AnnAssign with unpacked types
+    "x: tuple[*Ts]",
+    "x: tuple[int, *Ts]",
+    "x: tuple[int, *tuple[str, ...]]",
+    # AugAssign
+    "v += 1",
+    "v -= 1",
+    "v *= 1",
+    "v @= 1",
+    "v /= 1",
+    "v %= 1",
+    "v **= 1",
+    "v <<= 1",
+    "v >>= 1",
+    "v |= 1",
+    "v ^= 1",
+    "v &= 1",
+    "v //= 1",
+    # For
+    "for v in v:pass",
+    # For-Else
+    "for v in v:\n  pass\nelse:\n  pass",
+    # While
+    "while v:pass",
+    # While-Else
+    "while v:\n  pass\nelse:\n  pass",
+    # If-Elif-Else
+    "if v:pass",
+    "if a:\n  pass\nelif b:\n  pass",
+    "if a:\n  pass\nelse:\n  pass",
+    "if a:\n  pass\nelif b:\n  pass\nelse:\n  pass",
+    "if a:\n  pass\nelif b:\n  pass\nelif b:\n  pass\nelif b:\n  pass\nelse:\n  pass",
+    # With
+    "with x: pass",
+    "with x, y: pass",
+    "with x as y: pass",
+    "with x as y, z as q: pass",
+    "with (x as y): pass",
+    "with (x, y): pass",
+    # Raise
+    "raise",
+    "raise Exception('string')",
+    "raise Exception",
+    "raise Exception('string') from None",
+    # TryExcept
+    "try:\n  pass\nexcept Exception:\n  pass",
+    "try:\n  pass\nexcept Exception as exc:\n  pass",
+    # TryFinally
+    "try:\n  pass\nfinally:\n  pass",
+    # TryStarExcept
+    "try:\n  pass\nexcept* Exception:\n  pass",
+    "try:\n  pass\nexcept* Exception as exc:\n  pass",
+    # TryExceptFinallyElse
+    "try:\n  pass\nexcept Exception:\n  pass\nelse:  pass\nfinally:\n  pass",
+    "try:\n  pass\nexcept Exception as exc:\n  pass\nelse:  pass\nfinally:\n  pass",
+    "try:\n  pass\nexcept* Exception as exc:\n  pass\nelse:  pass\nfinally:\n  pass",
+    # Assert
+    "assert v",
+    # Assert with message
+    "assert v, 'message'",
+    # Import
+    "import sys",
+    "import foo as bar",
+    # ImportFrom
+    "from sys import x as y",
+    "from sys import v",
+    # Global
+    "global v",
+    # Expr
+    "1",
+    # Pass,
+    "pass",
+    # Break
+    "for v in v:break",
+    # Continue
+    "for v in v:continue",
+    # for statements with naked tuples (see http://bugs.python.org/issue6704)
+    "for a,b in c: pass",
+    "for (a,b) in c: pass",
+    "for [a,b] in c: pass",
+    # Multiline generator expression (test for .lineno & .col_offset)
+    """(
+    (
+    Aa
+    ,
+       Bb
+    )
+    for
+    Aa
+    ,
+    Bb in Cc
+    )""",
+    # dictcomp
+    "{a : b for w in x for m in p if g}",
+    # dictcomp with naked tuple
+    "{a : b for v,w in x}",
+    # setcomp
+    "{r for l in x if g}",
+    # setcomp with naked tuple
+    "{r for l,m in x}",
+    # AsyncFunctionDef
+    "async def f():\n 'async function'\n await something()",
+    # AsyncFor
+    "async def f():\n async for e in i: 1\n else: 2",
+    # AsyncWith
+    "async def f():\n async with a as b: 1",
+    # PEP 448: Additional Unpacking Generalizations
+    "{**{1:2}, 2:3}",
+    "{*{1, 2}, 3}",
+    # Function with yield (from)
+    "def f(): yield 1",
+    "def f(): yield from []",
+    # Asynchronous comprehensions
+    "async def f():\n [i async for b in c]",
+    # Decorated FunctionDef
+    "@deco1\n@deco2()\n@deco3(1)\ndef f(): pass",
+    # Decorated AsyncFunctionDef
+    "@deco1\n@deco2()\n@deco3(1)\nasync def f(): pass",
+    # Decorated ClassDef
+    "@deco1\n@deco2()\n@deco3(1)\nclass C: pass",
+    # Decorator with generator argument
+    "@deco(a for a in b)\ndef f(): pass",
+    # Decorator with attribute
+    "@a.b.c\ndef f(): pass",
+    # Simple assignment expression
+    "(a := 1)",
+    # Assignment expression in if statement
+    "if a := foo(): pass",
+    # Assignment expression in while
+    "while a := foo(): pass",
+    # Positional-only arguments
+    "def f(a, /,): pass",
+    "def f(a, /, c, d, e): pass",
+    "def f(a, /, c, *, d, e): pass",
+    "def f(a, /, c, *, d, e, **kwargs): pass",
+    # Positional-only arguments with defaults
+    "def f(a=1, /,): pass",
+    "def f(a=1, /, b=2, c=4): pass",
+    "def f(a=1, /, b=2, *, c=4): pass",
+    "def f(a=1, /, b=2, *, c): pass",
+    "def f(a=1, /, b=2, *, c=4, **kwargs): pass",
+    "def f(a=1, /, b=2, *, c, **kwargs): pass",
+    # Type aliases
+    "type X = int",
+    "type X[T] = int",
+    "type X[T, *Ts, **P] = (T, Ts, P)",
+    "type X[T: int, *Ts, **P] = (T, Ts, P)",
+    "type X[T: (int, str), *Ts, **P] = (T, Ts, P)",
+    "type X[T: int = 1, *Ts = 2, **P =3] = (T, Ts, P)",
+    # Generic classes
+    "class X[T]: pass",
+    "class X[T, *Ts, **P]: pass",
+    "class X[T: int, *Ts, **P]: pass",
+    "class X[T: (int, str), *Ts, **P]: pass",
+    "class X[T: int = 1, *Ts = 2, **P = 3]: pass",
+    # Generic functions
+    "def f[T](): pass",
+    "def f[T, *Ts, **P](): pass",
+    "def f[T: int, *Ts, **P](): pass",
+    "def f[T: (int, str), *Ts, **P](): pass",
+    "def f[T: int = 1, *Ts = 2, **P = 3](): pass",
+    # Match
+    "match x:\n\tcase 1:\n\t\tpass",
+    # Match with _
+    "match x:\n\tcase 1:\n\t\tpass\n\tcase _:\n\t\tpass",
+]
+
+# These are compiled through "single"
+# because of overlap with "eval", it just tests what
+# can't be tested with "eval"
+single_tests = [
+    "1+2"
+]
+
+# These are compiled through "eval"
+# It should test all expressions
+eval_tests = [
+  # Constant(value=None)
+  "None",
+  # True
+  "True",
+  # False
+  "False",
+  # BoolOp
+  "a and b",
+  "a or b",
+  # BinOp
+  "a + b",
+  "a - b",
+  "a * b",
+  "a / b",
+  "a @ b",
+  "a // b",
+  "a ** b",
+  "a % b",
+  "a >> b",
+  "a << b",
+  "a ^ b",
+  "a | b",
+  "a & b",
+  # UnaryOp
+  "not v",
+  "+v",
+  "-v",
+  "~v",
+  # Lambda
+  "lambda:None",
+  # Dict
+  "{ 1:2 }",
+  # Empty dict
+  "{}",
+  # Set
+  "{None,}",
+  # Multiline dict (test for .lineno & .col_offset)
+  """{
+      1
+        :
+          2
+     }""",
+  # Multiline list
+  """[
+      1
+       ,
+        1
+     ]""",
+  # Multiline tuple
+  """(
+      1
+       ,
+     )""",
+  # Multiline set
+  """{
+      1
+       ,
+        1
+     }""",
+  # ListComp
+  "[a for b in c if d]",
+  # GeneratorExp
+  "(a for b in c if d)",
+  # SetComp
+  "{a for b in c if d}",
+  # DictComp
+  "{k: v for k, v in c if d}",
+  # Comprehensions with multiple for targets
+  "[(a,b) for a,b in c]",
+  "[(a,b) for (a,b) in c]",
+  "[(a,b) for [a,b] in c]",
+  "{(a,b) for a,b in c}",
+  "{(a,b) for (a,b) in c}",
+  "{(a,b) for [a,b] in c}",
+  "((a,b) for a,b in c)",
+  "((a,b) for (a,b) in c)",
+  "((a,b) for [a,b] in c)",
+  # Async comprehensions - async comprehensions can't work outside an asynchronous function
+  #
+  # Yield - yield expressions can't work outside a function
+  #
+  # Compare
+  "1 < 2 < 3",
+  "a == b",
+  "a <= b",
+  "a >= b",
+  "a != b",
+  "a is b",
+  "a is not b",
+  "a in b",
+  "a not in b",
+  # Call without argument
+  "f()",
+  # Call
+  "f(1,2,c=3,*d,**e)",
+  # Call with multi-character starred
+  "f(*[0, 1])",
+  # Call with a generator argument
+  "f(a for a in b)",
+  # Constant(value=int())
+  "10",
+  # Complex num
+  "1j",
+  # Constant(value=str())
+  "'string'",
+  # Attribute
+  "a.b",
+  # Subscript
+  "a[b:c]",
+  # Name
+  "v",
+  # List
+  "[1,2,3]",
+  # Empty list
+  "[]",
+  # Tuple
+  "1,2,3",
+  # Tuple
+  "(1,2,3)",
+  # Empty tuple
+  "()",
+  # Combination
+  "a.b.c.d(a.b[1:2])",
+  # Slice
+  "[5][1:]",
+  "[5][:1]",
+  "[5][::1]",
+  "[5][1:1:1]",
+  # IfExp
+  "foo() if x else bar()",
+  # JoinedStr and FormattedValue
+  "f'{a}'",
+  "f'{a:.2f}'",
+  "f'{a!r}'",
+  "f'foo({a})'",
+]
+
+
+def main():
+    if __name__ != '__main__':
+        return
+    if sys.argv[1:] == ['-g']:
+        for statements, kind in ((exec_tests, "exec"), (single_tests, "single"),
+                                 (eval_tests, "eval")):
+            print(kind+"_results = [")
+            for statement in statements:
+                tree = ast.parse(statement, "?", kind)
+                print("%r," % (to_tuple(tree),))
+            print("]")
+        print("main()")
+        raise SystemExit
+
+#### EVERYTHING BELOW IS GENERATED BY python Lib/test/test_ast/snippets.py -g  #####
+exec_results = [
+('Module', [('Expr', (1, 0, 1, 18), ('Constant', (1, 0, 1, 18), 'module docstring', None))], []),
+('Module', [('FunctionDef', (1, 0, 1, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 9, 1, 13))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 29), ('Constant', (1, 9, 1, 29), 'function docstring', None))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 14), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, []), [('Pass', (1, 10, 1, 14))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 0, None)]), [('Pass', (1, 12, 1, 16))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 11), 'args', None, None), [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 23), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 16), 'args', ('Starred', (1, 13, 1, 16), ('Name', (1, 14, 1, 16), 'Ts', ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 19, 1, 23))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Constant', (1, 25, 1, 28), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 36), 'f', ('arguments', [], [], ('arg', (1, 7, 1, 29), 'args', ('Starred', (1, 13, 1, 29), ('Subscript', (1, 14, 1, 29), ('Name', (1, 14, 1, 19), 'tuple', ('Load',)), ('Tuple', (1, 20, 1, 28), [('Name', (1, 20, 1, 23), 'int', ('Load',)), ('Starred', (1, 25, 1, 28), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), ('Load',)), None), [], [], None, []), [('Pass', (1, 32, 1, 36))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 21), 'f', ('arguments', [], [], None, [], [], ('arg', (1, 8, 1, 14), 'kwargs', None, None), []), [('Pass', (1, 17, 1, 21))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 71), 'f', ('arguments', [], [('arg', (1, 6, 1, 7), 'a', None, None), ('arg', (1, 9, 1, 10), 'b', None, None), ('arg', (1, 14, 1, 15), 'c', None, None), ('arg', (1, 22, 1, 23), 'd', None, None), ('arg', (1, 28, 1, 29), 'e', None, None)], ('arg', (1, 35, 1, 39), 'args', None, None), [('arg', (1, 41, 1, 42), 'f', None, None)], [('Constant', (1, 43, 1, 45), 42, None)], ('arg', (1, 49, 1, 55), 'kwargs', None, None), [('Constant', (1, 11, 1, 12), 1, None), ('Constant', (1, 16, 1, 20), None, None), ('List', (1, 24, 1, 26), [], ('Load',)), ('Dict', (1, 30, 1, 32), [], [])]), [('Expr', (1, 58, 1, 71), ('Constant', (1, 58, 1, 71), 'doc for f()', None))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 27), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 23, 1, 27))], [], ('Subscript', (1, 11, 1, 21), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 20), [('Starred', (1, 17, 1, 20), ('Name', (1, 18, 1, 20), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 28, 1, 32))], [], ('Subscript', (1, 11, 1, 26), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 25), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 25), ('Name', (1, 23, 1, 25), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 45), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 41, 1, 45))], [], ('Subscript', (1, 11, 1, 39), ('Name', (1, 11, 1, 16), 'tuple', ('Load',)), ('Tuple', (1, 17, 1, 38), [('Name', (1, 17, 1, 20), 'int', ('Load',)), ('Starred', (1, 22, 1, 38), ('Subscript', (1, 23, 1, 38), ('Name', (1, 23, 1, 28), 'tuple', ('Load',)), ('Tuple', (1, 29, 1, 37), [('Name', (1, 29, 1, 32), 'int', ('Load',)), ('Constant', (1, 34, 1, 37), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, [])], []),
+('Module', [('ClassDef', (1, 0, 1, 12), 'C', [], [], [('Pass', (1, 8, 1, 12))], [], [])], []),
+('Module', [('ClassDef', (1, 0, 1, 32), 'C', [], [], [('Expr', (1, 9, 1, 32), ('Constant', (1, 9, 1, 32), 'docstring for class C', None))], [], [])], []),
+('Module', [('ClassDef', (1, 0, 1, 21), 'C', [('Name', (1, 8, 1, 14), 'object', ('Load',))], [], [('Pass', (1, 17, 1, 21))], [], [])], []),
+('Module', [('ClassDef', (1, 0, 1, 19), 'C', [('Name', (1, 8, 1, 9), 'A', ('Load',)), ('Name', (1, 11, 1, 12), 'B', ('Load',))], [], [('Pass', (1, 15, 1, 19))], [], [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Return', (1, 8, 1, 16), ('Constant', (1, 15, 1, 16), 1, None))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 14), 'f', ('arguments', [], [], None, [], [], None, []), [('Return', (1, 8, 1, 14), None)], [], None, None, [])], []),
+('Module', [('Delete', (1, 0, 1, 5), [('Name', (1, 4, 1, 5), 'v', ('Del',))])], []),
+('Module', [('Assign', (1, 0, 1, 5), [('Name', (1, 0, 1, 1), 'v', ('Store',))], ('Constant', (1, 4, 1, 5), 1, None), None)], []),
+('Module', [('Assign', (1, 0, 1, 7), [('Tuple', (1, 0, 1, 3), [('Name', (1, 0, 1, 1), 'a', ('Store',)), ('Name', (1, 2, 1, 3), 'b', ('Store',))], ('Store',))], ('Name', (1, 6, 1, 7), 'c', ('Load',)), None)], []),
+('Module', [('Assign', (1, 0, 1, 9), [('Tuple', (1, 0, 1, 5), [('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Name', (1, 3, 1, 4), 'b', ('Store',))], ('Store',))], ('Name', (1, 8, 1, 9), 'c', ('Load',)), None)], []),
+('Module', [('Assign', (1, 0, 1, 9), [('List', (1, 0, 1, 5), [('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Name', (1, 3, 1, 4), 'b', ('Store',))], ('Store',))], ('Name', (1, 8, 1, 9), 'c', ('Load',)), None)], []),
+('Module', [('Assign', (1, 0, 1, 8), [('Subscript', (1, 0, 1, 4), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Name', (1, 2, 1, 3), 'b', ('Load',)), ('Store',))], ('Name', (1, 7, 1, 8), 'c', ('Load',)), None)], []),
+('Module', [('AnnAssign', (1, 0, 1, 13), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 13), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 12), [('Starred', (1, 9, 1, 12), ('Name', (1, 10, 1, 12), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
+('Module', [('AnnAssign', (1, 0, 1, 18), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 18), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 17), [('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Starred', (1, 14, 1, 17), ('Name', (1, 15, 1, 17), 'Ts', ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
+('Module', [('AnnAssign', (1, 0, 1, 31), ('Name', (1, 0, 1, 1), 'x', ('Store',)), ('Subscript', (1, 3, 1, 31), ('Name', (1, 3, 1, 8), 'tuple', ('Load',)), ('Tuple', (1, 9, 1, 30), [('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Starred', (1, 14, 1, 30), ('Subscript', (1, 15, 1, 30), ('Name', (1, 15, 1, 20), 'tuple', ('Load',)), ('Tuple', (1, 21, 1, 29), [('Name', (1, 21, 1, 24), 'str', ('Load',)), ('Constant', (1, 26, 1, 29), Ellipsis, None)], ('Load',)), ('Load',)), ('Load',))], ('Load',)), ('Load',)), None, 1)], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Add',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Sub',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Mult',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('MatMult',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Div',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Mod',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 7), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('Pow',), ('Constant', (1, 6, 1, 7), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 7), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('LShift',), ('Constant', (1, 6, 1, 7), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 7), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('RShift',), ('Constant', (1, 6, 1, 7), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('BitOr',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('BitXor',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('BitAnd',), ('Constant', (1, 5, 1, 6), 1, None))], []),
+('Module', [('AugAssign', (1, 0, 1, 7), ('Name', (1, 0, 1, 1), 'v', ('Store',)), ('FloorDiv',), ('Constant', (1, 6, 1, 7), 1, None))], []),
+('Module', [('For', (1, 0, 1, 15), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Pass', (1, 11, 1, 15))], [], None)], []),
+('Module', [('For', (1, 0, 4, 6), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Pass', (2, 2, 2, 6))], [('Pass', (4, 2, 4, 6))], None)], []),
+('Module', [('While', (1, 0, 1, 12), ('Name', (1, 6, 1, 7), 'v', ('Load',)), [('Pass', (1, 8, 1, 12))], [])], []),
+('Module', [('While', (1, 0, 4, 6), ('Name', (1, 6, 1, 7), 'v', ('Load',)), [('Pass', (2, 2, 2, 6))], [('Pass', (4, 2, 4, 6))])], []),
+('Module', [('If', (1, 0, 1, 9), ('Name', (1, 3, 1, 4), 'v', ('Load',)), [('Pass', (1, 5, 1, 9))], [])], []),
+('Module', [('If', (1, 0, 4, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('If', (3, 0, 4, 6), ('Name', (3, 5, 3, 6), 'b', ('Load',)), [('Pass', (4, 2, 4, 6))], [])])], []),
+('Module', [('If', (1, 0, 4, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('Pass', (4, 2, 4, 6))])], []),
+('Module', [('If', (1, 0, 6, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('If', (3, 0, 6, 6), ('Name', (3, 5, 3, 6), 'b', ('Load',)), [('Pass', (4, 2, 4, 6))], [('Pass', (6, 2, 6, 6))])])], []),
+('Module', [('If', (1, 0, 10, 6), ('Name', (1, 3, 1, 4), 'a', ('Load',)), [('Pass', (2, 2, 2, 6))], [('If', (3, 0, 10, 6), ('Name', (3, 5, 3, 6), 'b', ('Load',)), [('Pass', (4, 2, 4, 6))], [('If', (5, 0, 10, 6), ('Name', (5, 5, 5, 6), 'b', ('Load',)), [('Pass', (6, 2, 6, 6))], [('If', (7, 0, 10, 6), ('Name', (7, 5, 7, 6), 'b', ('Load',)), [('Pass', (8, 2, 8, 6))], [('Pass', (10, 2, 10, 6))])])])])], []),
+('Module', [('With', (1, 0, 1, 12), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), None)], [('Pass', (1, 8, 1, 12))], None)], []),
+('Module', [('With', (1, 0, 1, 15), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), None), ('withitem', ('Name', (1, 8, 1, 9), 'y', ('Load',)), None)], [('Pass', (1, 11, 1, 15))], None)], []),
+('Module', [('With', (1, 0, 1, 17), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), ('Name', (1, 10, 1, 11), 'y', ('Store',)))], [('Pass', (1, 13, 1, 17))], None)], []),
+('Module', [('With', (1, 0, 1, 25), [('withitem', ('Name', (1, 5, 1, 6), 'x', ('Load',)), ('Name', (1, 10, 1, 11), 'y', ('Store',))), ('withitem', ('Name', (1, 13, 1, 14), 'z', ('Load',)), ('Name', (1, 18, 1, 19), 'q', ('Store',)))], [('Pass', (1, 21, 1, 25))], None)], []),
+('Module', [('With', (1, 0, 1, 19), [('withitem', ('Name', (1, 6, 1, 7), 'x', ('Load',)), ('Name', (1, 11, 1, 12), 'y', ('Store',)))], [('Pass', (1, 15, 1, 19))], None)], []),
+('Module', [('With', (1, 0, 1, 17), [('withitem', ('Name', (1, 6, 1, 7), 'x', ('Load',)), None), ('withitem', ('Name', (1, 9, 1, 10), 'y', ('Load',)), None)], [('Pass', (1, 13, 1, 17))], None)], []),
+('Module', [('Raise', (1, 0, 1, 5), None, None)], []),
+('Module', [('Raise', (1, 0, 1, 25), ('Call', (1, 6, 1, 25), ('Name', (1, 6, 1, 15), 'Exception', ('Load',)), [('Constant', (1, 16, 1, 24), 'string', None)], []), None)], []),
+('Module', [('Raise', (1, 0, 1, 15), ('Name', (1, 6, 1, 15), 'Exception', ('Load',)), None)], []),
+('Module', [('Raise', (1, 0, 1, 35), ('Call', (1, 6, 1, 25), ('Name', (1, 6, 1, 15), 'Exception', ('Load',)), [('Constant', (1, 16, 1, 24), 'string', None)], []), ('Constant', (1, 31, 1, 35), None, None))], []),
+('Module', [('Try', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 7, 3, 16), 'Exception', ('Load',)), None, [('Pass', (4, 2, 4, 6))])], [], [])], []),
+('Module', [('Try', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 7, 3, 16), 'Exception', ('Load',)), 'exc', [('Pass', (4, 2, 4, 6))])], [], [])], []),
+('Module', [('Try', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [], [], [('Pass', (4, 2, 4, 6))])], []),
+('Module', [('TryStar', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 8, 3, 17), 'Exception', ('Load',)), None, [('Pass', (4, 2, 4, 6))])], [], [])], []),
+('Module', [('TryStar', (1, 0, 4, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 8, 3, 17), 'Exception', ('Load',)), 'exc', [('Pass', (4, 2, 4, 6))])], [], [])], []),
+('Module', [('Try', (1, 0, 7, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 7, 3, 16), 'Exception', ('Load',)), None, [('Pass', (4, 2, 4, 6))])], [('Pass', (5, 7, 5, 11))], [('Pass', (7, 2, 7, 6))])], []),
+('Module', [('Try', (1, 0, 7, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 7, 3, 16), 'Exception', ('Load',)), 'exc', [('Pass', (4, 2, 4, 6))])], [('Pass', (5, 7, 5, 11))], [('Pass', (7, 2, 7, 6))])], []),
+('Module', [('TryStar', (1, 0, 7, 6), [('Pass', (2, 2, 2, 6))], [('ExceptHandler', (3, 0, 4, 6), ('Name', (3, 8, 3, 17), 'Exception', ('Load',)), 'exc', [('Pass', (4, 2, 4, 6))])], [('Pass', (5, 7, 5, 11))], [('Pass', (7, 2, 7, 6))])], []),
+('Module', [('Assert', (1, 0, 1, 8), ('Name', (1, 7, 1, 8), 'v', ('Load',)), None)], []),
+('Module', [('Assert', (1, 0, 1, 19), ('Name', (1, 7, 1, 8), 'v', ('Load',)), ('Constant', (1, 10, 1, 19), 'message', None))], []),
+('Module', [('Import', (1, 0, 1, 10), [('alias', (1, 7, 1, 10), 'sys', None)])], []),
+('Module', [('Import', (1, 0, 1, 17), [('alias', (1, 7, 1, 17), 'foo', 'bar')])], []),
+('Module', [('ImportFrom', (1, 0, 1, 22), 'sys', [('alias', (1, 16, 1, 22), 'x', 'y')], 0)], []),
+('Module', [('ImportFrom', (1, 0, 1, 17), 'sys', [('alias', (1, 16, 1, 17), 'v', None)], 0)], []),
+('Module', [('Global', (1, 0, 1, 8), ['v'])], []),
+('Module', [('Expr', (1, 0, 1, 1), ('Constant', (1, 0, 1, 1), 1, None))], []),
+('Module', [('Pass', (1, 0, 1, 4))], []),
+('Module', [('For', (1, 0, 1, 16), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Break', (1, 11, 1, 16))], [], None)], []),
+('Module', [('For', (1, 0, 1, 19), ('Name', (1, 4, 1, 5), 'v', ('Store',)), ('Name', (1, 9, 1, 10), 'v', ('Load',)), [('Continue', (1, 11, 1, 19))], [], None)], []),
+('Module', [('For', (1, 0, 1, 18), ('Tuple', (1, 4, 1, 7), [('Name', (1, 4, 1, 5), 'a', ('Store',)), ('Name', (1, 6, 1, 7), 'b', ('Store',))], ('Store',)), ('Name', (1, 11, 1, 12), 'c', ('Load',)), [('Pass', (1, 14, 1, 18))], [], None)], []),
+('Module', [('For', (1, 0, 1, 20), ('Tuple', (1, 4, 1, 9), [('Name', (1, 5, 1, 6), 'a', ('Store',)), ('Name', (1, 7, 1, 8), 'b', ('Store',))], ('Store',)), ('Name', (1, 13, 1, 14), 'c', ('Load',)), [('Pass', (1, 16, 1, 20))], [], None)], []),
+('Module', [('For', (1, 0, 1, 20), ('List', (1, 4, 1, 9), [('Name', (1, 5, 1, 6), 'a', ('Store',)), ('Name', (1, 7, 1, 8), 'b', ('Store',))], ('Store',)), ('Name', (1, 13, 1, 14), 'c', ('Load',)), [('Pass', (1, 16, 1, 20))], [], None)], []),
+('Module', [('Expr', (1, 0, 11, 5), ('GeneratorExp', (1, 0, 11, 5), ('Tuple', (2, 4, 6, 5), [('Name', (3, 4, 3, 6), 'Aa', ('Load',)), ('Name', (5, 7, 5, 9), 'Bb', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (8, 4, 10, 6), [('Name', (8, 4, 8, 6), 'Aa', ('Store',)), ('Name', (10, 4, 10, 6), 'Bb', ('Store',))], ('Store',)), ('Name', (10, 10, 10, 12), 'Cc', ('Load',)), [], 0)]))], []),
+('Module', [('Expr', (1, 0, 1, 34), ('DictComp', (1, 0, 1, 34), ('Name', (1, 1, 1, 2), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',)), [('comprehension', ('Name', (1, 11, 1, 12), 'w', ('Store',)), ('Name', (1, 16, 1, 17), 'x', ('Load',)), [], 0), ('comprehension', ('Name', (1, 22, 1, 23), 'm', ('Store',)), ('Name', (1, 27, 1, 28), 'p', ('Load',)), [('Name', (1, 32, 1, 33), 'g', ('Load',))], 0)]))], []),
+('Module', [('Expr', (1, 0, 1, 20), ('DictComp', (1, 0, 1, 20), ('Name', (1, 1, 1, 2), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'v', ('Store',)), ('Name', (1, 13, 1, 14), 'w', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'x', ('Load',)), [], 0)]))], []),
+('Module', [('Expr', (1, 0, 1, 19), ('SetComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 12, 1, 13), 'x', ('Load',)), [('Name', (1, 17, 1, 18), 'g', ('Load',))], 0)]))], []),
+('Module', [('Expr', (1, 0, 1, 16), ('SetComp', (1, 0, 1, 16), ('Name', (1, 1, 1, 2), 'r', ('Load',)), [('comprehension', ('Tuple', (1, 7, 1, 10), [('Name', (1, 7, 1, 8), 'l', ('Store',)), ('Name', (1, 9, 1, 10), 'm', ('Store',))], ('Store',)), ('Name', (1, 14, 1, 15), 'x', ('Load',)), [], 0)]))], []),
+('Module', [('AsyncFunctionDef', (1, 0, 3, 18), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 17), ('Constant', (2, 1, 2, 17), 'async function', None)), ('Expr', (3, 1, 3, 18), ('Await', (3, 1, 3, 18), ('Call', (3, 7, 3, 18), ('Name', (3, 7, 3, 16), 'something', ('Load',)), [], [])))], [], None, None, [])], []),
+('Module', [('AsyncFunctionDef', (1, 0, 3, 8), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncFor', (2, 1, 3, 8), ('Name', (2, 11, 2, 12), 'e', ('Store',)), ('Name', (2, 16, 2, 17), 'i', ('Load',)), [('Expr', (2, 19, 2, 20), ('Constant', (2, 19, 2, 20), 1, None))], [('Expr', (3, 7, 3, 8), ('Constant', (3, 7, 3, 8), 2, None))], None)], [], None, None, [])], []),
+('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('AsyncWith', (2, 1, 2, 21), [('withitem', ('Name', (2, 12, 2, 13), 'a', ('Load',)), ('Name', (2, 17, 2, 18), 'b', ('Store',)))], [('Expr', (2, 20, 2, 21), ('Constant', (2, 20, 2, 21), 1, None))], None)], [], None, None, [])], []),
+('Module', [('Expr', (1, 0, 1, 14), ('Dict', (1, 0, 1, 14), [None, ('Constant', (1, 10, 1, 11), 2, None)], [('Dict', (1, 3, 1, 8), [('Constant', (1, 4, 1, 5), 1, None)], [('Constant', (1, 6, 1, 7), 2, None)]), ('Constant', (1, 12, 1, 13), 3, None)]))], []),
+('Module', [('Expr', (1, 0, 1, 12), ('Set', (1, 0, 1, 12), [('Starred', (1, 1, 1, 8), ('Set', (1, 2, 1, 8), [('Constant', (1, 3, 1, 4), 1, None), ('Constant', (1, 6, 1, 7), 2, None)]), ('Load',)), ('Constant', (1, 10, 1, 11), 3, None)]))], []),
+('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 16), ('Yield', (1, 9, 1, 16), ('Constant', (1, 15, 1, 16), 1, None)))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 22), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (1, 9, 1, 22), ('YieldFrom', (1, 9, 1, 22), ('List', (1, 20, 1, 22), [], ('Load',))))], [], None, None, [])], []),
+('Module', [('AsyncFunctionDef', (1, 0, 2, 21), 'f', ('arguments', [], [], None, [], [], None, []), [('Expr', (2, 1, 2, 21), ('ListComp', (2, 1, 2, 21), ('Name', (2, 2, 2, 3), 'i', ('Load',)), [('comprehension', ('Name', (2, 14, 2, 15), 'b', ('Store',)), ('Name', (2, 19, 2, 20), 'c', ('Load',)), [], 1)]))], [], None, None, [])], []),
+('Module', [('FunctionDef', (4, 0, 4, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None, [])], []),
+('Module', [('AsyncFunctionDef', (4, 0, 4, 19), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (4, 15, 4, 19))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], None, None, [])], []),
+('Module', [('ClassDef', (4, 0, 4, 13), 'C', [], [], [('Pass', (4, 9, 4, 13))], [('Name', (1, 1, 1, 6), 'deco1', ('Load',)), ('Call', (2, 1, 2, 8), ('Name', (2, 1, 2, 6), 'deco2', ('Load',)), [], []), ('Call', (3, 1, 3, 9), ('Name', (3, 1, 3, 6), 'deco3', ('Load',)), [('Constant', (3, 7, 3, 8), 1, None)], [])], [])], []),
+('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Call', (1, 1, 1, 19), ('Name', (1, 1, 1, 5), 'deco', ('Load',)), [('GeneratorExp', (1, 5, 1, 19), ('Name', (1, 6, 1, 7), 'a', ('Load',)), [('comprehension', ('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 17, 1, 18), 'b', ('Load',)), [], 0)])], [])], None, None, [])], []),
+('Module', [('FunctionDef', (2, 0, 2, 13), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (2, 9, 2, 13))], [('Attribute', (1, 1, 1, 6), ('Attribute', (1, 1, 1, 4), ('Name', (1, 1, 1, 2), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',))], None, None, [])], []),
+('Module', [('Expr', (1, 0, 1, 8), ('NamedExpr', (1, 1, 1, 7), ('Name', (1, 1, 1, 2), 'a', ('Store',)), ('Constant', (1, 6, 1, 7), 1, None)))], []),
+('Module', [('If', (1, 0, 1, 19), ('NamedExpr', (1, 3, 1, 13), ('Name', (1, 3, 1, 4), 'a', ('Store',)), ('Call', (1, 8, 1, 13), ('Name', (1, 8, 1, 11), 'foo', ('Load',)), [], [])), [('Pass', (1, 15, 1, 19))], [])], []),
+('Module', [('While', (1, 0, 1, 22), ('NamedExpr', (1, 6, 1, 16), ('Name', (1, 6, 1, 7), 'a', ('Store',)), ('Call', (1, 11, 1, 16), ('Name', (1, 11, 1, 14), 'foo', ('Load',)), [], [])), [('Pass', (1, 18, 1, 22))], [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 18), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, []), [('Pass', (1, 14, 1, 18))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None), ('arg', (1, 15, 1, 16), 'd', None, None), ('arg', (1, 18, 1, 19), 'e', None, None)], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], None, []), [('Pass', (1, 25, 1, 29))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 39), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 12, 1, 13), 'c', None, None)], None, [('arg', (1, 18, 1, 19), 'd', None, None), ('arg', (1, 21, 1, 22), 'e', None, None)], [None, None], ('arg', (1, 26, 1, 32), 'kwargs', None, None), []), [('Pass', (1, 35, 1, 39))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 20), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None)]), [('Pass', (1, 16, 1, 20))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 29), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None), ('arg', (1, 19, 1, 20), 'c', None, None)], None, [], [], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None), ('Constant', (1, 21, 1, 22), 4, None)]), [('Pass', (1, 25, 1, 29))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 32), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 28, 1, 32))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 30), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], None, [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 26, 1, 30))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 42), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [('Constant', (1, 24, 1, 25), 4, None)], ('arg', (1, 29, 1, 35), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 38, 1, 42))], [], None, None, [])], []),
+('Module', [('FunctionDef', (1, 0, 1, 40), 'f', ('arguments', [('arg', (1, 6, 1, 7), 'a', None, None)], [('arg', (1, 14, 1, 15), 'b', None, None)], None, [('arg', (1, 22, 1, 23), 'c', None, None)], [None], ('arg', (1, 27, 1, 33), 'kwargs', None, None), [('Constant', (1, 8, 1, 9), 1, None), ('Constant', (1, 16, 1, 17), 2, None)]), [('Pass', (1, 36, 1, 40))], [], None, None, [])], []),
+('Module', [('TypeAlias', (1, 0, 1, 12), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [], ('Name', (1, 9, 1, 12), 'int', ('Load',)))], []),
+('Module', [('TypeAlias', (1, 0, 1, 15), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None, None)], ('Name', (1, 12, 1, 15), 'int', ('Load',)))], []),
+('Module', [('TypeAlias', (1, 0, 1, 32), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 8), 'T', None, None), ('TypeVarTuple', (1, 10, 1, 13), 'Ts', None), ('ParamSpec', (1, 15, 1, 18), 'P', None)], ('Tuple', (1, 22, 1, 32), [('Name', (1, 23, 1, 24), 'T', ('Load',)), ('Name', (1, 26, 1, 28), 'Ts', ('Load',)), ('Name', (1, 30, 1, 31), 'P', ('Load',))], ('Load',)))], []),
+('Module', [('TypeAlias', (1, 0, 1, 37), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 13), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',)), None), ('TypeVarTuple', (1, 15, 1, 18), 'Ts', None), ('ParamSpec', (1, 20, 1, 23), 'P', None)], ('Tuple', (1, 27, 1, 37), [('Name', (1, 28, 1, 29), 'T', ('Load',)), ('Name', (1, 31, 1, 33), 'Ts', ('Load',)), ('Name', (1, 35, 1, 36), 'P', ('Load',))], ('Load',)))], []),
+('Module', [('TypeAlias', (1, 0, 1, 44), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 20), 'T', ('Tuple', (1, 10, 1, 20), [('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Name', (1, 16, 1, 19), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 22, 1, 25), 'Ts', None), ('ParamSpec', (1, 27, 1, 30), 'P', None)], ('Tuple', (1, 34, 1, 44), [('Name', (1, 35, 1, 36), 'T', ('Load',)), ('Name', (1, 38, 1, 40), 'Ts', ('Load',)), ('Name', (1, 42, 1, 43), 'P', ('Load',))], ('Load',)))], []),
+('Module', [('TypeAlias', (1, 0, 1, 48), ('Name', (1, 5, 1, 6), 'X', ('Store',)), [('TypeVar', (1, 7, 1, 17), 'T', ('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Constant', (1, 16, 1, 17), 1, None)), ('TypeVarTuple', (1, 19, 1, 26), 'Ts', ('Constant', (1, 25, 1, 26), 2, None)), ('ParamSpec', (1, 28, 1, 34), 'P', ('Constant', (1, 33, 1, 34), 3, None))], ('Tuple', (1, 38, 1, 48), [('Name', (1, 39, 1, 40), 'T', ('Load',)), ('Name', (1, 42, 1, 44), 'Ts', ('Load',)), ('Name', (1, 46, 1, 47), 'P', ('Load',))], ('Load',)))], []),
+('Module', [('ClassDef', (1, 0, 1, 16), 'X', [], [], [('Pass', (1, 12, 1, 16))], [], [('TypeVar', (1, 8, 1, 9), 'T', None, None)])], []),
+('Module', [('ClassDef', (1, 0, 1, 26), 'X', [], [], [('Pass', (1, 22, 1, 26))], [], [('TypeVar', (1, 8, 1, 9), 'T', None, None), ('TypeVarTuple', (1, 11, 1, 14), 'Ts', None), ('ParamSpec', (1, 16, 1, 19), 'P', None)])], []),
+('Module', [('ClassDef', (1, 0, 1, 31), 'X', [], [], [('Pass', (1, 27, 1, 31))], [], [('TypeVar', (1, 8, 1, 14), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',)), None), ('TypeVarTuple', (1, 16, 1, 19), 'Ts', None), ('ParamSpec', (1, 21, 1, 24), 'P', None)])], []),
+('Module', [('ClassDef', (1, 0, 1, 38), 'X', [], [], [('Pass', (1, 34, 1, 38))], [], [('TypeVar', (1, 8, 1, 21), 'T', ('Tuple', (1, 11, 1, 21), [('Name', (1, 12, 1, 15), 'int', ('Load',)), ('Name', (1, 17, 1, 20), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 23, 1, 26), 'Ts', None), ('ParamSpec', (1, 28, 1, 31), 'P', None)])], []),
+('Module', [('ClassDef', (1, 0, 1, 43), 'X', [], [], [('Pass', (1, 39, 1, 43))], [], [('TypeVar', (1, 8, 1, 18), 'T', ('Name', (1, 11, 1, 14), 'int', ('Load',)), ('Constant', (1, 17, 1, 18), 1, None)), ('TypeVarTuple', (1, 20, 1, 27), 'Ts', ('Constant', (1, 26, 1, 27), 2, None)), ('ParamSpec', (1, 29, 1, 36), 'P', ('Constant', (1, 35, 1, 36), 3, None))])], []),
+('Module', [('FunctionDef', (1, 0, 1, 16), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 12, 1, 16))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None, None)])], []),
+('Module', [('FunctionDef', (1, 0, 1, 26), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 22, 1, 26))], [], None, None, [('TypeVar', (1, 6, 1, 7), 'T', None, None), ('TypeVarTuple', (1, 9, 1, 12), 'Ts', None), ('ParamSpec', (1, 14, 1, 17), 'P', None)])], []),
+('Module', [('FunctionDef', (1, 0, 1, 31), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 27, 1, 31))], [], None, None, [('TypeVar', (1, 6, 1, 12), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',)), None), ('TypeVarTuple', (1, 14, 1, 17), 'Ts', None), ('ParamSpec', (1, 19, 1, 22), 'P', None)])], []),
+('Module', [('FunctionDef', (1, 0, 1, 38), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 34, 1, 38))], [], None, None, [('TypeVar', (1, 6, 1, 19), 'T', ('Tuple', (1, 9, 1, 19), [('Name', (1, 10, 1, 13), 'int', ('Load',)), ('Name', (1, 15, 1, 18), 'str', ('Load',))], ('Load',)), None), ('TypeVarTuple', (1, 21, 1, 24), 'Ts', None), ('ParamSpec', (1, 26, 1, 29), 'P', None)])], []),
+('Module', [('FunctionDef', (1, 0, 1, 43), 'f', ('arguments', [], [], None, [], [], None, []), [('Pass', (1, 39, 1, 43))], [], None, None, [('TypeVar', (1, 6, 1, 16), 'T', ('Name', (1, 9, 1, 12), 'int', ('Load',)), ('Constant', (1, 15, 1, 16), 1, None)), ('TypeVarTuple', (1, 18, 1, 25), 'Ts', ('Constant', (1, 24, 1, 25), 2, None)), ('ParamSpec', (1, 27, 1, 34), 'P', ('Constant', (1, 33, 1, 34), 3, None))])], []),
+('Module', [('Match', (1, 0, 3, 6), ('Name', (1, 6, 1, 7), 'x', ('Load',)), [('match_case', ('MatchValue', (2, 6, 2, 7), ('Constant', (2, 6, 2, 7), 1, None)), None, [('Pass', (3, 2, 3, 6))])])], []),
+('Module', [('Match', (1, 0, 5, 6), ('Name', (1, 6, 1, 7), 'x', ('Load',)), [('match_case', ('MatchValue', (2, 6, 2, 7), ('Constant', (2, 6, 2, 7), 1, None)), None, [('Pass', (3, 2, 3, 6))]), ('match_case', ('MatchAs', (4, 6, 4, 7), None, None), None, [('Pass', (5, 2, 5, 6))])])], []),
+]
+single_results = [
+('Interactive', [('Expr', (1, 0, 1, 3), ('BinOp', (1, 0, 1, 3), ('Constant', (1, 0, 1, 1), 1, None), ('Add',), ('Constant', (1, 2, 1, 3), 2, None)))]),
+]
+eval_results = [
+('Expression', ('Constant', (1, 0, 1, 4), None, None)),
+('Expression', ('Constant', (1, 0, 1, 4), True, None)),
+('Expression', ('Constant', (1, 0, 1, 5), False, None)),
+('Expression', ('BoolOp', (1, 0, 1, 7), ('And',), [('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Name', (1, 6, 1, 7), 'b', ('Load',))])),
+('Expression', ('BoolOp', (1, 0, 1, 6), ('Or',), [('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Add',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Sub',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Mult',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Div',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('MatMult',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('FloorDiv',), ('Name', (1, 5, 1, 6), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Pow',), ('Name', (1, 5, 1, 6), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Mod',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('RShift',), ('Name', (1, 5, 1, 6), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('LShift',), ('Name', (1, 5, 1, 6), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('BitXor',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('BitOr',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('BinOp', (1, 0, 1, 5), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('BitAnd',), ('Name', (1, 4, 1, 5), 'b', ('Load',)))),
+('Expression', ('UnaryOp', (1, 0, 1, 5), ('Not',), ('Name', (1, 4, 1, 5), 'v', ('Load',)))),
+('Expression', ('UnaryOp', (1, 0, 1, 2), ('UAdd',), ('Name', (1, 1, 1, 2), 'v', ('Load',)))),
+('Expression', ('UnaryOp', (1, 0, 1, 2), ('USub',), ('Name', (1, 1, 1, 2), 'v', ('Load',)))),
+('Expression', ('UnaryOp', (1, 0, 1, 2), ('Invert',), ('Name', (1, 1, 1, 2), 'v', ('Load',)))),
+('Expression', ('Lambda', (1, 0, 1, 11), ('arguments', [], [], None, [], [], None, []), ('Constant', (1, 7, 1, 11), None, None))),
+('Expression', ('Dict', (1, 0, 1, 7), [('Constant', (1, 2, 1, 3), 1, None)], [('Constant', (1, 4, 1, 5), 2, None)])),
+('Expression', ('Dict', (1, 0, 1, 2), [], [])),
+('Expression', ('Set', (1, 0, 1, 7), [('Constant', (1, 1, 1, 5), None, None)])),
+('Expression', ('Dict', (1, 0, 5, 6), [('Constant', (2, 6, 2, 7), 1, None)], [('Constant', (4, 10, 4, 11), 2, None)])),
+('Expression', ('List', (1, 0, 5, 6), [('Constant', (2, 6, 2, 7), 1, None), ('Constant', (4, 8, 4, 9), 1, None)], ('Load',))),
+('Expression', ('Tuple', (1, 0, 4, 6), [('Constant', (2, 6, 2, 7), 1, None)], ('Load',))),
+('Expression', ('Set', (1, 0, 5, 6), [('Constant', (2, 6, 2, 7), 1, None), ('Constant', (4, 8, 4, 9), 1, None)])),
+('Expression', ('ListComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'b', ('Store',)), ('Name', (1, 12, 1, 13), 'c', ('Load',)), [('Name', (1, 17, 1, 18), 'd', ('Load',))], 0)])),
+('Expression', ('GeneratorExp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'b', ('Store',)), ('Name', (1, 12, 1, 13), 'c', ('Load',)), [('Name', (1, 17, 1, 18), 'd', ('Load',))], 0)])),
+('Expression', ('SetComp', (1, 0, 1, 19), ('Name', (1, 1, 1, 2), 'a', ('Load',)), [('comprehension', ('Name', (1, 7, 1, 8), 'b', ('Store',)), ('Name', (1, 12, 1, 13), 'c', ('Load',)), [('Name', (1, 17, 1, 18), 'd', ('Load',))], 0)])),
+('Expression', ('DictComp', (1, 0, 1, 25), ('Name', (1, 1, 1, 2), 'k', ('Load',)), ('Name', (1, 4, 1, 5), 'v', ('Load',)), [('comprehension', ('Tuple', (1, 10, 1, 14), [('Name', (1, 10, 1, 11), 'k', ('Store',)), ('Name', (1, 13, 1, 14), 'v', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [('Name', (1, 23, 1, 24), 'd', ('Load',))], 0)])),
+('Expression', ('ListComp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
+('Expression', ('ListComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('ListComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('SetComp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0, 1, 20), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 14), [('Name', (1, 11, 1, 12), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Store',))], ('Store',)), ('Name', (1, 18, 1, 19), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('Tuple', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('GeneratorExp', (1, 0, 1, 22), ('Tuple', (1, 1, 1, 6), [('Name', (1, 2, 1, 3), 'a', ('Load',)), ('Name', (1, 4, 1, 5), 'b', ('Load',))], ('Load',)), [('comprehension', ('List', (1, 11, 1, 16), [('Name', (1, 12, 1, 13), 'a', ('Store',)), ('Name', (1, 14, 1, 15), 'b', ('Store',))], ('Store',)), ('Name', (1, 20, 1, 21), 'c', ('Load',)), [], 0)])),
+('Expression', ('Compare', (1, 0, 1, 9), ('Constant', (1, 0, 1, 1), 1, None), [('Lt',), ('Lt',)], [('Constant', (1, 4, 1, 5), 2, None), ('Constant', (1, 8, 1, 9), 3, None)])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('Eq',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('LtE',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('GtE',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('NotEq',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('Is',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 10), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('IsNot',)], [('Name', (1, 9, 1, 10), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('In',)], [('Name', (1, 5, 1, 6), 'b', ('Load',))])),
+('Expression', ('Compare', (1, 0, 1, 10), ('Name', (1, 0, 1, 1), 'a', ('Load',)), [('NotIn',)], [('Name', (1, 9, 1, 10), 'b', ('Load',))])),
+('Expression', ('Call', (1, 0, 1, 3), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [], [])),
+('Expression', ('Call', (1, 0, 1, 17), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('Constant', (1, 2, 1, 3), 1, None), ('Constant', (1, 4, 1, 5), 2, None), ('Starred', (1, 10, 1, 12), ('Name', (1, 11, 1, 12), 'd', ('Load',)), ('Load',))], [('keyword', (1, 6, 1, 9), 'c', ('Constant', (1, 8, 1, 9), 3, None)), ('keyword', (1, 13, 1, 16), None, ('Name', (1, 15, 1, 16), 'e', ('Load',)))])),
+('Expression', ('Call', (1, 0, 1, 10), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('Starred', (1, 2, 1, 9), ('List', (1, 3, 1, 9), [('Constant', (1, 4, 1, 5), 0, None), ('Constant', (1, 7, 1, 8), 1, None)], ('Load',)), ('Load',))], [])),
+('Expression', ('Call', (1, 0, 1, 15), ('Name', (1, 0, 1, 1), 'f', ('Load',)), [('GeneratorExp', (1, 1, 1, 15), ('Name', (1, 2, 1, 3), 'a', ('Load',)), [('comprehension', ('Name', (1, 8, 1, 9), 'a', ('Store',)), ('Name', (1, 13, 1, 14), 'b', ('Load',)), [], 0)])], [])),
+('Expression', ('Constant', (1, 0, 1, 2), 10, None)),
+('Expression', ('Constant', (1, 0, 1, 2), 1j, None)),
+('Expression', ('Constant', (1, 0, 1, 8), 'string', None)),
+('Expression', ('Attribute', (1, 0, 1, 3), ('Name', (1, 0, 1, 1), 'a', ('Load',)), 'b', ('Load',))),
+('Expression', ('Subscript', (1, 0, 1, 6), ('Name', (1, 0, 1, 1), 'a', ('Load',)), ('Slice', (1, 2, 1, 5), ('Name', (1, 2, 1, 3), 'b', ('Load',)), ('Name', (1, 4, 1, 5), 'c', ('Load',)), None), ('Load',))),
+('Expression', ('Name', (1, 0, 1, 1), 'v', ('Load',))),
+('Expression', ('List', (1, 0, 1, 7), [('Constant', (1, 1, 1, 2), 1, None), ('Constant', (1, 3, 1, 4), 2, None), ('Constant', (1, 5, 1, 6), 3, None)], ('Load',))),
+('Expression', ('List', (1, 0, 1, 2), [], ('Load',))),
+('Expression', ('Tuple', (1, 0, 1, 5), [('Constant', (1, 0, 1, 1), 1, None), ('Constant', (1, 2, 1, 3), 2, None), ('Constant', (1, 4, 1, 5), 3, None)], ('Load',))),
+('Expression', ('Tuple', (1, 0, 1, 7), [('Constant', (1, 1, 1, 2), 1, None), ('Constant', (1, 3, 1, 4), 2, None), ('Constant', (1, 5, 1, 6), 3, None)], ('Load',))),
+('Expression', ('Tuple', (1, 0, 1, 2), [], ('Load',))),
+('Expression', ('Call', (1, 0, 1, 17), ('Attribute', (1, 0, 1, 7), ('Attribute', (1, 0, 1, 5), ('Attribute', (1, 0, 1, 3), ('Name', (1, 0, 1, 1), 'a', ('Load',)), 'b', ('Load',)), 'c', ('Load',)), 'd', ('Load',)), [('Subscript', (1, 8, 1, 16), ('Attribute', (1, 8, 1, 11), ('Name', (1, 8, 1, 9), 'a', ('Load',)), 'b', ('Load',)), ('Slice', (1, 12, 1, 15), ('Constant', (1, 12, 1, 13), 1, None), ('Constant', (1, 14, 1, 15), 2, None), None), ('Load',))], [])),
+('Expression', ('Subscript', (1, 0, 1, 7), ('List', (1, 0, 1, 3), [('Constant', (1, 1, 1, 2), 5, None)], ('Load',)), ('Slice', (1, 4, 1, 6), ('Constant', (1, 4, 1, 5), 1, None), None, None), ('Load',))),
+('Expression', ('Subscript', (1, 0, 1, 7), ('List', (1, 0, 1, 3), [('Constant', (1, 1, 1, 2), 5, None)], ('Load',)), ('Slice', (1, 4, 1, 6), None, ('Constant', (1, 5, 1, 6), 1, None), None), ('Load',))),
+('Expression', ('Subscript', (1, 0, 1, 8), ('List', (1, 0, 1, 3), [('Constant', (1, 1, 1, 2), 5, None)], ('Load',)), ('Slice', (1, 4, 1, 7), None, None, ('Constant', (1, 6, 1, 7), 1, None)), ('Load',))),
+('Expression', ('Subscript', (1, 0, 1, 10), ('List', (1, 0, 1, 3), [('Constant', (1, 1, 1, 2), 5, None)], ('Load',)), ('Slice', (1, 4, 1, 9), ('Constant', (1, 4, 1, 5), 1, None), ('Constant', (1, 6, 1, 7), 1, None), ('Constant', (1, 8, 1, 9), 1, None)), ('Load',))),
+('Expression', ('IfExp', (1, 0, 1, 21), ('Name', (1, 9, 1, 10), 'x', ('Load',)), ('Call', (1, 0, 1, 5), ('Name', (1, 0, 1, 3), 'foo', ('Load',)), [], []), ('Call', (1, 16, 1, 21), ('Name', (1, 16, 1, 19), 'bar', ('Load',)), [], []))),
+('Expression', ('JoinedStr', (1, 0, 1, 6), [('FormattedValue', (1, 2, 1, 5), ('Name', (1, 3, 1, 4), 'a', ('Load',)), -1, None)])),
+('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)])),
+]
+main()
diff --git a/Lib/test/test_ast/test_ast.py b/Lib/test/test_ast/test_ast.py
new file mode 100644
index 0000000000..57c19477ab
--- /dev/null
+++ b/Lib/test/test_ast/test_ast.py
@@ -0,0 +1,3642 @@
+import ast
+import builtins
+import copy
+import dis
+import enum
+import os
+import re
+import sys
+import textwrap
+import types
+import unittest
+import warnings
+import weakref
+from functools import partial
+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.ast_helper import ASTTestMixin
+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
+)
+
+
+class AST_Tests(unittest.TestCase):
+    maxDiff = None
+
+    def _is_ast_node(self, name, node):
+        if not isinstance(node, type):
+            return False
+        if "ast" not in node.__module__:
+            return False
+        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:
+            return
+        if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
+            node_pos = (ast_node.lineno, ast_node.col_offset)
+            self.assertGreaterEqual(node_pos, parent_pos)
+            parent_pos = (ast_node.lineno, ast_node.col_offset)
+        for name in ast_node._fields:
+            value = getattr(ast_node, name)
+            if isinstance(value, list):
+                first_pos = parent_pos
+                if value and name == "decorator_list":
+                    first_pos = (value[0].lineno, value[0].col_offset)
+                for child in value:
+                    self._assertTrueorder(child, first_pos)
+            elif value is not None:
+                self._assertTrueorder(value, parent_pos)
+        self.assertEqual(ast_node._fields, ast_node.__match_args__)
+
+    def test_AST_objects(self):
+        x = ast.AST()
+        self.assertEqual(x._fields, ())
+        x.foobar = 42
+        self.assertEqual(x.foobar, 42)
+        self.assertEqual(x.__dict__["foobar"], 42)
+
+        with self.assertRaises(AttributeError):
+            x.vararg
+
+        with self.assertRaises(TypeError):
+            # "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
+
+        def cleanup():
+            ast.AST._fields = old_value
+        self.addCleanup(cleanup)
+
+        del ast.AST._fields
+
+        msg = "type object 'ast.AST' has no attribute '_fields'"
+        # Both examples used to crash:
+        with self.assertRaisesRegex(AttributeError, msg):
+            ast.AST(arg1=123)
+        with self.assertRaisesRegex(AttributeError, msg):
+            ast.AST()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_AST_garbage_collection(self):
+        class X:
+            pass
+
+        a = ast.AST()
+        a.x = X()
+        a.x.a = a
+        ref = weakref.ref(a.x)
+        del a
+        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 i, o in zip(input, output):
+                with self.subTest(action="parsing", input=i):
+                    ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
+                    self.assertEqual(to_tuple(ast_tree), o)
+                    self._assertTrueorder(ast_tree, (0, 0))
+                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")
+
+    @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:
+            with self.subTest(optval=optval, expected=expected):
+                res1 = ast.parse("__debug__", optimize=optval)
+                res2 = ast.parse(ast.parse("__debug__"), optimize=optval)
+                for res in [res1, res2]:
+                    self.assertIsInstance(res.body[0], ast.Expr)
+                    if isinstance(expected, bool):
+                        self.assertIsInstance(res.body[0].value, ast.Constant)
+                        self.assertEqual(res.body[0].value.value, expected)
+                    else:
+                        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)]
+
+        for lineno, end_lineno in invalid_linenos:
+            with self.subTest(f"Check invalid linenos {lineno}:{end_lineno}"):
+                snippet = "a = 1"
+                tree = ast.parse(snippet)
+                tree.body[0].lineno = lineno
+                tree.body[0].end_lineno = end_lineno
+                with self.assertRaises(ValueError):
+                    compile(tree, "<string>", "exec")
+
+        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}"
+            ):
+                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")
+
+    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=[],
+        )
+
+        # Check that compilation doesn't crash. Note: this may crash explicitly only on debug mode.
+        compile(tree, "<string>", "exec")
+
+    def test_negative_locations_for_compile(self):
+        # See https://github.com/python/cpython/issues/130775
+        alias = ast.alias(name='traceback', lineno=0, col_offset=0)
+        for attrs in (
+            {'lineno': -2, 'col_offset': 0},
+            {'lineno': 0, 'col_offset': -2},
+            {'lineno': 0, 'col_offset': -2, 'end_col_offset': -2},
+            {'lineno': -2, 'end_lineno': -2, 'col_offset': 0},
+        ):
+            with self.subTest(attrs=attrs):
+                tree = ast.Module(body=[
+                    ast.Import(names=[alias], **attrs)
+                ], type_ignores=[])
+
+                # It used to crash on this step:
+                compile(tree, "<string>", "exec")
+
+                # This also must not crash:
+                ast.parse(tree, optimize=2)
+
+    def test_slice(self):
+        slc = ast.parse("x[::]").body[0].value.slice
+        self.assertIsNone(slc.upper)
+        self.assertIsNone(slc.lower)
+        self.assertIsNone(slc.step)
+
+    def test_from_import(self):
+        im = ast.parse("from . import y").body[0]
+        self.assertIsNone(im.module)
+
+    def test_non_interned_future_from_ast(self):
+        mod = ast.parse("from __future__ import division")
+        self.assertIsInstance(mod.body[0], ast.ImportFrom)
+        mod.body[0].module = " __future__ ".strip()
+        compile(mod, "<test>", "exec")
+
+    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.assertIsNone(alias.asname)
+        self.assertEqual(alias.lineno, 1)
+        self.assertEqual(alias.end_lineno, 1)
+        self.assertEqual(alias.col_offset, 16)
+        self.assertEqual(alias.end_col_offset, 17)
+
+        im = ast.parse("from bar import *").body[0]
+        alias = im.names[0]
+        self.assertEqual(alias.name, "*")
+        self.assertIsNone(alias.asname)
+        self.assertEqual(alias.lineno, 1)
+        self.assertEqual(alias.end_lineno, 1)
+        self.assertEqual(alias.col_offset, 16)
+        self.assertEqual(alias.end_col_offset, 17)
+
+        im = ast.parse("from bar import y as z").body[0]
+        alias = im.names[0]
+        self.assertEqual(alias.name, "y")
+        self.assertEqual(alias.asname, "z")
+        self.assertEqual(alias.lineno, 1)
+        self.assertEqual(alias.end_lineno, 1)
+        self.assertEqual(alias.col_offset, 16)
+        self.assertEqual(alias.end_col_offset, 22)
+
+        im = ast.parse("import bar as foo").body[0]
+        alias = im.names[0]
+        self.assertEqual(alias.name, "bar")
+        self.assertEqual(alias.asname, "foo")
+        self.assertEqual(alias.lineno, 1)
+        self.assertEqual(alias.end_lineno, 1)
+        self.assertEqual(alias.col_offset, 7)
+        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
+
+        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":
+                continue
+            if self._is_ast_node(name, item):
+                x = self._construct_ast_class(item)
+                if isinstance(x, ast.AST):
+                    self.assertIs(type(x._fields), tuple)
+
+    def _construct_ast_class(self, cls):
+        kwargs = {}
+        for name, typ in cls.__annotations__.items():
+            if typ is str:
+                kwargs[name] = "capybara"
+            elif typ is int:
+                kwargs[name] = 42
+            elif typ is object:
+                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.args, [])
+        self.assertIsNone(x.vararg)
+
+        x = ast.arguments(*range(1, 8))
+        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"))
+
+        with self.assertRaises(AttributeError):
+            x.value
+
+        x = ast.Constant(42)
+        self.assertEqual(x.value, 42)
+
+        with self.assertRaises(AttributeError):
+            x.lineno
+
+        with self.assertRaises(AttributeError):
+            x.foobar
+
+        x = ast.Constant(lineno=2, value=3)
+        self.assertEqual(x.lineno, 2)
+
+        x = ast.Constant(42, lineno=0)
+        self.assertEqual(x.lineno, 0)
+        self.assertEqual(x._fields, ("value", "kind"))
+        self.assertEqual(x.value, 42)
+
+        self.assertRaises(TypeError, ast.Constant, 1, None, 2)
+        self.assertRaises(TypeError, ast.Constant, 1, None, 2, lineno=0)
+
+        # Arbitrary keyword arguments are supported (but deprecated)
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(ast.Constant(1, foo="bar").foo, "bar")
+
+        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.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"
+
+        class N2(ast.Constant):
+            pass
+
+        n = N(42)
+        self.assertEqual(n.value, 42)
+        self.assertEqual(n.z, "spam")
+        self.assertEqual(type(n), N)
+        self.assertTrue(isinstance(n, N))
+        self.assertTrue(isinstance(n, ast.Constant))
+        self.assertFalse(isinstance(n, N2))
+        self.assertFalse(isinstance(ast.Constant(42), N))
+        n = N(value=42)
+        self.assertEqual(n.value, 42)
+        self.assertEqual(type(n), N)
+
+    def test_module(self):
+        body = [ast.Constant(42)]
+        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"))
+
+        # Random attribute allowed too
+        x.foobarbaz = 5
+        self.assertEqual(x.foobarbaz, 5)
+
+        n1 = ast.Constant(1)
+        n3 = ast.Constant(3)
+        addop = ast.Add()
+        x = ast.BinOp(n1, addop, n3)
+        self.assertEqual(x.left, n1)
+        self.assertEqual(x.op, addop)
+        self.assertEqual(x.right, n3)
+
+        x = ast.BinOp(1, 2, 3)
+        self.assertEqual(x.left, 1)
+        self.assertEqual(x.op, 2)
+        self.assertEqual(x.right, 3)
+
+        x = ast.BinOp(1, 2, 3, lineno=0)
+        self.assertEqual(x.left, 1)
+        self.assertEqual(x.op, 2)
+        self.assertEqual(x.right, 3)
+        self.assertEqual(x.lineno, 0)
+
+        # node raises exception when given too many arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4)
+        # node raises exception when given too many arguments
+        self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0)
+
+        # can set attributes through kwargs too
+        x = ast.BinOp(left=1, op=2, right=3, lineno=0)
+        self.assertEqual(x.left, 1)
+        self.assertEqual(x.op, 2)
+        self.assertEqual(x.right, 3)
+        self.assertEqual(x.lineno, 0)
+
+        # Random kwargs also allowed (but deprecated)
+        with self.assertWarns(DeprecationWarning):
+            x = ast.BinOp(1, 2, 3, foobarbaz=42)
+        self.assertEqual(x.foobarbaz, 42)
+
+    def test_no_fields(self):
+        # this used to fail because Sub._fields was None
+        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))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_invalid_identifier(self):
+        m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], [])
+        ast.fix_missing_locations(m)
+        with self.assertRaises(TypeError) as cm:
+            compile(m, "<test>", "exec")
+        self.assertIn("identifier must be of type str", str(cm.exception))
+
+    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"):
+                compile(e, "<test>", "eval")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    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()")
+        empty_yield_from.body[0].body[0].value.value = None
+        with self.assertRaises(ValueError) as cm:
+            compile(empty_yield_from, "<test>", "exec")
+        self.assertIn("field 'value' is required", str(cm.exception))
+
+    @support.cpython_only
+    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")
+
+    def test_issue18374_binop_col_offset(self):
+        tree = ast.parse("4+5+6+7")
+        parent_binop = tree.body[0].value
+        child_binop = parent_binop.left
+        grandchild_binop = child_binop.left
+        self.assertEqual(parent_binop.col_offset, 0)
+        self.assertEqual(parent_binop.end_col_offset, 7)
+        self.assertEqual(child_binop.col_offset, 0)
+        self.assertEqual(child_binop.end_col_offset, 5)
+        self.assertEqual(grandchild_binop.col_offset, 0)
+        self.assertEqual(grandchild_binop.end_col_offset, 3)
+
+        tree = ast.parse("4+5-\\\n 6-7")
+        parent_binop = tree.body[0].value
+        child_binop = parent_binop.left
+        grandchild_binop = child_binop.left
+        self.assertEqual(parent_binop.col_offset, 0)
+        self.assertEqual(parent_binop.lineno, 1)
+        self.assertEqual(parent_binop.end_col_offset, 4)
+        self.assertEqual(parent_binop.end_lineno, 2)
+
+        self.assertEqual(child_binop.col_offset, 0)
+        self.assertEqual(child_binop.lineno, 1)
+        self.assertEqual(child_binop.end_col_offset, 2)
+        self.assertEqual(child_binop.end_lineno, 2)
+
+        self.assertEqual(grandchild_binop.col_offset, 0)
+        self.assertEqual(grandchild_binop.lineno, 1)
+        self.assertEqual(grandchild_binop.end_col_offset, 3)
+        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")
+        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.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",
+        )
+        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_positional_only_feature_version(self):
+        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))
+        with self.assertRaises(SyntaxError):
+            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))
+        with self.assertRaises(SyntaxError):
+            ast.parse("lambda x, /: ...", feature_version=(3, 7))
+        with self.assertRaises(SyntaxError):
+            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))
+        with self.assertRaises(SyntaxError):
+            ast.parse("(x := 0)", feature_version=(3, 7))
+
+    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))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
+    def test_exception_groups_feature_version(self):
+        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",
+            "class X[T]: pass",
+            "def f[T](): pass",
+        ]
+        for sample in samples:
+            with self.subTest(sample):
+                ast.parse(sample)
+                with self.assertRaises(SyntaxError):
+                    ast.parse(sample, feature_version=(3, 11))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError not raised
+    def test_type_params_default_feature_version(self):
+        samples = [
+            "type X[*Ts=int] = int",
+            "class X[T=int]: pass",
+            "def f[**P=int](): pass",
+        ]
+        for sample in samples:
+            with self.subTest(sample):
+                ast.parse(sample)
+                with self.assertRaises(SyntaxError):
+                    ast.parse(sample, feature_version=(3, 12))
+
+    def test_invalid_major_feature_version(self):
+        with self.assertRaises(ValueError):
+            ast.parse("pass", feature_version=(2, 7))
+        with self.assertRaises(ValueError):
+            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"
+            ):
+                compile(expr, "<test>", "eval")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    def test_constant_as_unicode_name(self):
+        constants = [
+            ("True", b"Tru\xe1\xb5\x89"),
+            ("False", b"Fal\xc5\xbfe"),
+            ("None", b"N\xc2\xbane"),
+        ]
+        for constant in constants:
+            with self.assertRaisesRegex(ValueError,
+                f"identifier field can't represent '{constant[0]}' constant"):
+                ast.parse(constant[1], mode="eval")
+
+    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'
+            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'
+            ATOM = enum.auto()
+
+            def next(self):
+                try:
+                    return self.__class__(self + 1)
+                except ValueError:
+                    return self
+
+        enum._test_simple_enum(_Precedence, ast._Precedence)
+
+    @support.cpython_only
+    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)
+        if _testinternalcapi is not None:
+            remaining = _testinternalcapi.get_c_recursion_remaining()
+            success_depth = min(success_depth, remaining)
+
+        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)
+
+        check_limit("a", "()")
+        check_limit("a", ".b")
+        check_limit("a", "[0]")
+        check_limit("a", "*a")
+
+    def test_null_bytes(self):
+        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:
+        with self.subTest(f"{node.__name__}.{attr}"):
+            tree = ast.parse(source)
+            found = 0
+            for child in ast.walk(tree):
+                if isinstance(child, node):
+                    setattr(child, attr, None)
+                    found += 1
+            self.assertEqual(found, 1)
+            e = re.escape(f"field '{attr}' is required for {node.__name__}")
+            with self.assertRaisesRegex(ValueError, f"^{e}$"):
+                compile(tree, "<test>", "exec")
+
+    @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"),
+            (ast.arg, "arg", "def spam(SPAM): spam"),
+            (ast.comprehension, "target", "[spam for SPAM in spam]"),
+            (ast.comprehension, "iter", "[spam for spam in SPAM]"),
+            (ast.keyword, "value", "spam(**SPAM)"),
+            (ast.match_case, "pattern", "match spam:\n case SPAM: spam"),
+            (ast.withitem, "context_expr", "with SPAM: spam"),
+        ]
+        for node, attr, source in tests:
+            self.assert_none_check(node, attr, source)
+
+
+class CopyTests(unittest.TestCase):
+    """Test copying and pickling AST nodes."""
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pickling(self):
+        import pickle
+
+        for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
+            for code in exec_tests:
+                with self.subTest(code=code, protocol=protocol):
+                    tree = compile(code, "?", "exec", 0x400)
+                    ast2 = pickle.loads(pickle.dumps(tree, protocol))
+                    self.assertEqual(to_tuple(ast2), to_tuple(tree))
+
+    def test_copy_with_parents(self):
+        # gh-120108
+        code = """
+        ('',)
+        while i < n:
+            if ch == '':
+                ch = format[i]
+                if ch == '':
+                    if freplace is None:
+                        '' % getattr(object)
+                elif ch == '':
+                    if zreplace is None:
+                        if hasattr:
+                            offset = object.utcoffset()
+                            if offset is not None:
+                                if offset.days < 0:
+                                    offset = -offset
+                                h = divmod(timedelta(hours=0))
+                                if u:
+                                    zreplace = '' % (sign,)
+                                elif s:
+                                    zreplace = '' % (sign,)
+                                else:
+                                    zreplace = '' % (sign,)
+                elif ch == '':
+                    if Zreplace is None:
+                        Zreplace = ''
+                        if hasattr(object):
+                            s = object.tzname()
+                            if s is not None:
+                                Zreplace = s.replace('')
+                    newformat.append(Zreplace)
+                else:
+                    push('')
+            else:
+                push(ch)
+
+        """
+        tree = ast.parse(textwrap.dedent(code))
+        for node in ast.walk(tree):
+            for child in ast.iter_child_nodes(node):
+                child.parent = node
+        try:
+            with support.infinite_recursion(200):
+                tree2 = copy.deepcopy(tree)
+        finally:
+            # Singletons like ast.Load() are shared; make sure we don't
+            # leave them mutated after this test.
+            for node in ast.walk(tree):
+                if hasattr(node, "parent"):
+                    del node.parent
+
+        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,
+                    ),
+                ):
+                    self.assertEqual(to_tuple(child.parent), to_tuple(node))
+
+
+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)
+        self.assertEqual(ast.dump(a), ast.dump(b))
+
+    def test_parse_in_error(self):
+        try:
+            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),
+            "Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), "
+            "args=[Name(id='eggs', ctx=Load()), Constant(value='and cheese')]))])",
+        )
+        self.assertEqual(
+            ast.dump(node, annotate_fields=False),
+            "Module([Expr(Call(Name('spam', Load()), [Name('eggs', Load()), "
+            "Constant('and cheese')]))])",
+        )
+        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)])",
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_dump_indent(self):
+        node = ast.parse('spam(eggs, "and cheese")')
+        self.assertEqual(
+            ast.dump(node, indent=3),
+            """\
+Module(
+   body=[
+      Expr(
+         value=Call(
+            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"),
+            """\
+Module(
+\t[
+\t\tExpr(
+\t\t\tCall(
+\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),
+            """\
+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)])""",
+        )
+
+    @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)"
+        )
+        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, 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)",
+        )
+        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),
+            "arguments([], [arg('x')])",
+        )
+        node = ast.arguments(posonlyargs=[ast.arg("x")])
+        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),
+            "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),
+            "arguments([], [arg('x')], kwonlyargs=[arg('y')])",
+        )
+        node = ast.arguments()
+        self.assertEqual(
+            ast.dump(node, annotate_fields=False),
+            "arguments()",
+        )
+        # Classes:
+        node = ast.ClassDef(
+            "T",
+            [],
+            [ast.keyword("a", ast.Constant(None))],
+            [],
+            [ast.Name("dataclass", ctx=ast.Load())],
+        )
+        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),
+            "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):
+                self.assertEqual(
+                    ast.dump(node, show_empty=False, **kwargs),
+                    empty,
+                )
+            with self.subTest(show_empty=True):
+                self.assertEqual(
+                    ast.dump(node, show_empty=True, **kwargs),
+                    full,
+                )
+
+        def check_text(code, empty, full, **kwargs):
+            check_node(ast.parse(code), empty, full, **kwargs)
+
+        check_node(
+            ast.arguments(),
+            empty="arguments()",
+            full="arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[])",
+        )
+
+        check_node(
+            # Corner case: there are no real `Name` instances with `id=''`:
+            ast.Name(id="", ctx=ast.Load()),
+            empty="Name(id='', ctx=Load())",
+            full="Name(id='', ctx=Load())",
+        )
+
+        check_node(
+            ast.MatchSingleton(value=None),
+            empty="MatchSingleton(value=None)",
+            full="MatchSingleton(value=None)",
+        )
+
+        check_node(
+            ast.MatchSingleton(value=[]),
+            empty="MatchSingleton(value=[])",
+            full="MatchSingleton(value=[])",
+        )
+
+        check_node(
+            ast.Constant(value=None),
+            empty="Constant(value=None)",
+            full="Constant(value=None)",
+        )
+
+        check_node(
+            ast.Constant(value=[]),
+            empty="Constant(value=[])",
+            full="Constant(value=[])",
+        )
+
+        check_node(
+            ast.Constant(value=""),
+            empty="Constant(value='')",
+            full="Constant(value='')",
+        )
+
+        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))])])",
+            full="Module(body=[FunctionDef(name='a', args=arguments(posonlyargs=[], 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))], decorator_list=[], type_params=[])], type_ignores=[])",
+        )
+
+        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(), lineno=1, col_offset=9, end_lineno=1, end_col_offset=12), lineno=1, col_offset=6, end_lineno=1, end_col_offset=12)], kwonlyargs=[arg(arg='c', lineno=1, col_offset=21, end_lineno=1, end_col_offset=22)], kw_defaults=[None], defaults=[Constant(value=0, lineno=1, col_offset=15, end_lineno=1, end_col_offset=16)]), body=[Expr(value=Constant(value=Ellipsis, lineno=1, col_offset=25, end_lineno=1, end_col_offset=28), lineno=1, col_offset=25, end_lineno=1, end_col_offset=28)], lineno=1, col_offset=0, end_lineno=1, end_col_offset=28)])",
+            full="Module(body=[FunctionDef(name='a', args=arguments(posonlyargs=[], args=[arg(arg='b', annotation=Name(id='int', ctx=Load(), lineno=1, col_offset=9, end_lineno=1, end_col_offset=12), lineno=1, col_offset=6, end_lineno=1, end_col_offset=12)], kwonlyargs=[arg(arg='c', lineno=1, col_offset=21, end_lineno=1, end_col_offset=22)], kw_defaults=[None], defaults=[Constant(value=0, lineno=1, col_offset=15, end_lineno=1, end_col_offset=16)]), body=[Expr(value=Constant(value=Ellipsis, lineno=1, col_offset=25, end_lineno=1, end_col_offset=28), lineno=1, col_offset=25, end_lineno=1, end_col_offset=28)], decorator_list=[], type_params=[], lineno=1, col_offset=0, end_lineno=1, end_col_offset=28)], type_ignores=[])",
+            include_attributes=True,
+        )
+
+        check_text(
+            'spam(eggs, "and cheese")',
+            empty="Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), args=[Name(id='eggs', ctx=Load()), Constant(value='and cheese')]))])",
+            full="Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), args=[Name(id='eggs', ctx=Load()), Constant(value='and cheese')], keywords=[]))], type_ignores=[])",
+        )
+
+        check_text(
+            'spam(eggs, text="and cheese")',
+            empty="Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), args=[Name(id='eggs', ctx=Load())], keywords=[keyword(arg='text', value=Constant(value='and cheese'))]))])",
+            full="Module(body=[Expr(value=Call(func=Name(id='spam', ctx=Load()), args=[Name(id='eggs', ctx=Load())], keywords=[keyword(arg='text', value=Constant(value='and cheese'))]))], type_ignores=[])",
+        )
+
+        check_text(
+            "import _ast as ast; from module import sub",
+            empty="Module(body=[Import(names=[alias(name='_ast', asname='ast')]), ImportFrom(module='module', names=[alias(name='sub')], level=0)])",
+            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
+    def test_copy_location(self):
+        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
+        )
+        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")], []))
+        )
+        self.assertEqual(src, ast.fix_missing_locations(src))
+        self.maxDiff = None
+        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, "
+            "end_col_offset=12)], lineno=1, col_offset=0, end_lineno=1, "
+            "end_col_offset=13), lineno=1, col_offset=0, end_lineno=1, "
+            "end_col_offset=13), Expr(value=Call(func=Name(id='spam', ctx=Load(), "
+            "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)])",
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_increment_lineno(self):
+        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))",
+        )
+        # issue10869: do not increment lineno of root twice
+        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))",
+        )
+        src = ast.Call(
+            func=ast.Name("test", ast.Load()), args=[], keywords=[], lineno=1
+        )
+        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("""\
+        a = 1
+        b = 2 # type: ignore
+        c = 3
+        d = 4 # type: ignore@tag
+        """),
+            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")
+
+    def test_iter_fields(self):
+        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": []})
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_iter_child_nodes(self):
+        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).value, 23)
+        self.assertEqual(next(iterator).value, 42)
+        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")
+
+        node = ast.parse('class foo:\n  """line one\n  line 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")
+
+        node = ast.parse('async def foo():\n  """spam\n  ham"""')
+        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")
+
+        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("")))
+        node = ast.parse('x = "not docstring"')
+        self.assertIsNone(ast.get_docstring(node))
+        node = ast.parse("def foo():\n  pass")
+        self.assertIsNone(ast.get_docstring(node))
+
+        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")
+        self.assertIsNone(ast.get_docstring(node.body[0]))
+
+        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")
+        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")
+        self.assertIsNone(ast.get_docstring(node.body[0]))
+
+    def test_multi_line_docstring_col_offset_and_lineno_issue16806(self):
+        node = ast.parse(
+            '"""line one\nline two"""\n\n'
+            'def foo():\n  """line one\n  line two"""\n\n'
+            '  def bar():\n    """line one\n    line two"""\n'
+            '  """line one\n  line two"""\n'
+            '"""line one\nline two"""\n\n'
+        )
+        self.assertEqual(node.body[0].col_offset, 0)
+        self.assertEqual(node.body[0].lineno, 1)
+        self.assertEqual(node.body[1].body[0].col_offset, 2)
+        self.assertEqual(node.body[1].body[0].lineno, 5)
+        self.assertEqual(node.body[1].body[1].body[0].col_offset, 4)
+        self.assertEqual(node.body[1].body[1].body[0].lineno, 9)
+        self.assertEqual(node.body[1].body[2].col_offset, 2)
+        self.assertEqual(node.body[1].body[2].lineno, 11)
+        self.assertEqual(node.body[2].col_offset, 0)
+        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")
+        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")
+        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])")
+        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('{"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('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
+    def test_literal_eval_str_int_limit(self):
+        with support.adjust_int_max_str_digits(4000):
+            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))
+
+    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)")
+
+    def test_literal_eval_malformed_dict_nodes(self):
+        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)]
+        )
+        self.assertRaises(ValueError, ast.literal_eval, malformed)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_literal_eval_trailing_ws(self):
+        self.assertEqual(ast.literal_eval("    -1"), -1)
+        self.assertEqual(ast.literal_eval("\t\t-1"), -1)
+        self.assertEqual(ast.literal_eval(" \t -1"), -1)
+        self.assertRaises(IndentationError, ast.literal_eval, "\n -1")
+
+    def test_literal_eval_malformed_lineno(self):
+        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:"
+        with self.assertRaisesRegex(ValueError, msg):
+            ast.literal_eval(node)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_literal_eval_syntax_errors(self):
+        with self.assertRaisesRegex(SyntaxError, "unexpected indent"):
+            ast.literal_eval(r"""
+                \
+                (\
+            \ """)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    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,
+            )
+        ]
+        mod = ast.Module(body, [])
+        with self.assertRaises(ValueError) as cm:
+            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,
+            )
+        ]
+        mod = ast.Module(body, [])
+        code = compile(mod, "test", "exec")
+        ns = {}
+        exec(code, ns)
+        self.assertIn("sleep", ns)
+
+    @unittest.skip('TODO: RUSTPYTHON; crash')
+    def test_recursion_direct(self):
+        e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0, operand=ast.Constant(1))
+        e.operand = e
+        with self.assertRaises(RecursionError):
+            with support.infinite_recursion():
+                compile(ast.Expression(e), "<test>", "eval")
+
+    @unittest.skip('TODO: RUSTPYTHON; crash')
+    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))
+        e.operand = f
+        f.operand = e
+        with self.assertRaises(RecursionError):
+            with support.infinite_recursion():
+                compile(ast.Expression(e), "<test>", "eval")
+
+
+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)
+        if msg is None:
+            compile(mod, "<test>", mode)
+        else:
+            with self.assertRaises(exc) as cm:
+                compile(mod, "<test>", mode)
+            self.assertIn(msg, str(cm.exception))
+
+    def expr(self, node, msg=None, *, exc=ValueError):
+        mod = ast.Module([ast.Expr(node)], [])
+        self.mod(mod, msg, exc=exc)
+
+    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")
+        m = ast.Expression(ast.Name("x", ast.Store()))
+        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,
+        ):
+            if args is None:
+                args = []
+            if posonlyargs is None:
+                posonlyargs = []
+            if kwonlyargs is None:
+                kwonlyargs = []
+            if defaults is None:
+                defaults = []
+            if kw_defaults is None:
+                kw_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",
+        )
+        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
+    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, []
+        )
+        self.stmt(f, "must have Load context")
+        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()),
+                ):
+                    return True
+                case _:
+                    return False
+
+        code = """
+            @capybara
+            def foo(bar) -> pacarana:
+                pass
+        """
+        source = ast.parse(textwrap.dedent(code))
+        funcdef = source.body[0]
+        self.assertIsInstance(funcdef, ast.FunctionDef)
+        self.assertTrue(matcher(funcdef))
+
+    @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
+        ):
+            if bases is None:
+                bases = []
+            if keywords is None:
+                keywords = []
+            if body is None:
+                body = [ast.Pass()]
+            if decorator_list is None:
+                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",
+        )
+        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"
+        )
+
+    @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")
+
+    @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",
+        )
+
+    @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())
+        )
+        self.stmt(aug, "must have Store context")
+        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"
+        )
+        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",
+        )
+
+    @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()))]
+        )
+        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")
+        i = ast.withitem(ast.Constant(3), None)
+        self.stmt(ast.With([i], []), "empty body on With")
+        i = ast.withitem(ast.Name("x", ast.Store()), None)
+        self.stmt(ast.With([i], [p]), "must have Load context")
+        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")
+        r = ast.Raise(ast.Name("x", ast.Store()), None)
+        self.stmt(r, "must have Load context")
+        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])
+        self.stmt(t, "empty body on Try")
+        t = ast.Try([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
+        self.stmt(t, "must have Load context")
+        t = ast.Try([p], [], [], [])
+        self.stmt(t, "Try has neither except handlers nor finalbody")
+        t = ast.Try([p], [], [p], [p])
+        self.stmt(t, "Try has orelse but no except handlers")
+        t = ast.Try([p], [ast.ExceptHandler(None, "x", [])], [], [])
+        self.stmt(t, "empty body on ExceptHandler")
+        e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
+        self.stmt(ast.Try([p], e, [], []), "must have Load context")
+        e = [ast.ExceptHandler(None, "x", [p])]
+        t = ast.Try([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
+        self.stmt(t, "must have Load context")
+        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])
+        self.stmt(t, "empty body on TryStar")
+        t = ast.TryStar([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
+        self.stmt(t, "must have Load context")
+        t = ast.TryStar([p], [], [], [])
+        self.stmt(t, "TryStar has neither except handlers nor finalbody")
+        t = ast.TryStar([p], [], [p], [p])
+        self.stmt(t, "TryStar has orelse but no except handlers")
+        t = ast.TryStar([p], [ast.ExceptHandler(None, "x", [])], [], [])
+        self.stmt(t, "empty body on ExceptHandler")
+        e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
+        self.stmt(ast.TryStar([p], e, [], []), "must have Load context")
+        e = [ast.ExceptHandler(None, "x", [p])]
+        t = ast.TryStar([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
+        self.stmt(t, "must have Load context")
+        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(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')
+    def test_boolop(self):
+        b = ast.BoolOp(ast.And(), [])
+        self.expr(b, "less than 2 values")
+        b = ast.BoolOp(ast.And(), [ast.Constant(3)])
+        self.expr(b, "less than 2 values")
+        b = ast.BoolOp(ast.And(), [ast.Constant(4), None])
+        self.expr(b, "None disallowed")
+        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
+    def test_lambda(self):
+        a = ast.arguments([], [], None, [], [], None, [])
+        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
+    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
+    def test_set(self):
+        self.expr(ast.Set([None]), "None disallowed")
+        s = ast.Set([ast.Name("x", ast.Store())])
+        self.expr(s, "must have Load context")
+
+    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
+        )
+        self.expr(fac([g]), "must have Store context")
+        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())
+        g = ast.comprehension(x, y, [None], 0)
+        self.expr(fac([g]), "None disallowed")
+        g = ast.comprehension(x, y, [ast.Name("x", ast.Store())], 0)
+        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")
+
+        def wrap(gens):
+            return fac(ast.Name("x", ast.Store()), gens)
+
+        self._check_comprehension(wrap)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    def test_listcomp(self):
+        self._simple_comp(ast.ListComp)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    def test_setcomp(self):
+        self._simple_comp(ast.SetComp)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    def test_generatorexp(self):
+        self._simple_comp(ast.GeneratorExp)
+
+    @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])
+        self.expr(c, "must have Load context")
+        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")
+
+    @unittest.skip("TODO: RUSTPYTHON; thread 'main' panicked")
+    def test_compare(self):
+        left = ast.Name("x", ast.Load())
+        comp = ast.Compare(left, [ast.In()], [])
+        self.expr(comp, "no comparators")
+        comp = ast.Compare(left, [ast.In()], [ast.Constant(4), ast.Constant(5)])
+        self.expr(comp, "different number of comparators and operands")
+        comp = ast.Compare(ast.Constant("blah"), [ast.In()], [left])
+        self.expr(comp)
+        comp = ast.Compare(left, [ast.In()], [ast.Constant("blah")])
+        self.expr(comp)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError not raised
+    def test_call(self):
+        func = ast.Name("x", ast.Load())
+        args = [ast.Name("y", ast.Load())]
+        keywords = [ast.keyword("w", ast.Name("z", ast.Load()))]
+        call = ast.Call(ast.Name("x", ast.Store()), args, keywords)
+        self.expr(call, "must have Load context")
+        call = ast.Call(func, [None], keywords)
+        self.expr(call, "None disallowed")
+        bad_keywords = [ast.keyword("w", ast.Name("z", ast.Store()))]
+        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())
+        self.expr(sub, "must have Load context")
+        x = ast.Name("x", 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")
+        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()
+        )
+        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"
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_list(self):
+        self._sequence(ast.List)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    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")
+    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:
+            with self.subTest(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")
+
+    constant_1 = ast.Constant(1)
+    pattern_1 = ast.MatchValue(constant_1)
+
+    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())
+
+    _MATCH_PATTERNS = [
+        ast.MatchValue(
+            ast.Attribute(
+                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.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.MatchMapping(
+            [constant_true, constant_1], [pattern_x, pattern_1], rest="True"
+        ),
+        ast.MatchMapping(
+            [constant_true, ast.Starred(ast.Name("lol", ast.Load()), ast.Load())],
+            [pattern_x, pattern_1],
+            rest="legit",
+        ),
+        ast.MatchClass(
+            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]
+        ),
+        ast.MatchClass(
+            name_carter, patterns=[], kwd_attrs=[], kwd_patterns=[pattern_1]
+        ),
+        ast.MatchClass(
+            name_carter,
+            patterns=[ast.MatchSingleton("string")],
+            kwd_attrs=[],
+            kwd_patterns=[],
+        ),
+        ast.MatchClass(
+            name_carter, patterns=[ast.MatchStar()], kwd_attrs=[], kwd_patterns=[]
+        ),
+        ast.MatchClass(
+            name_carter, patterns=[], kwd_attrs=[], kwd_patterns=[ast.MatchStar()]
+        ),
+        ast.MatchClass(
+            constant_true,  # invalid name
+            patterns=[],
+            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.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())
+        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()])],
+                )
+                node = ast.fix_missing_locations(node)
+                module = ast.Module([node], [])
+                with self.assertRaises(ValueError):
+                    compile(module, "<test>", "exec")
+
+
+class ConstantTests(unittest.TestCase):
+    """Tests on the ast.Constant node type."""
+
+    def compile_constant(self, value):
+        tree = ast.parse("x = 123")
+
+        node = tree.body[0].value
+        new_node = ast.Constant(value=value)
+        ast.copy_location(new_node, node)
+        tree.body[0].value = new_node
+
+        code = compile(tree, "<string>", "exec")
+
+        ns = {}
+        exec(code, ns)
+        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")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; b'' is not b''
+    def test_singletons(self):
+        for const in (None, False, True, Ellipsis, b"", frozenset()):
+            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,
+        )
+        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")
+
+        target = tree.body[0].targets[0]
+        new_target = ast.Constant(value=1)
+        ast.copy_location(new_target, target)
+        tree.body[0].targets[0] = new_target
+
+        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",
+        )
+
+    def test_get_docstring(self):
+        tree = ast.parse("'docstring'\nx = 1")
+        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")
+        consts = []
+        for instr in dis.get_instructions(co):
+            if instr.opname == "LOAD_CONST" or instr.opname == "RETURN_CONST":
+                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.extend((Ellipsis, None))
+
+        tree = ast.parse(code)
+        self.assertEqual(self.get_load_const(tree), consts)
+
+        # Replace expression nodes with constants
+        for assign, const in zip(tree.body, consts):
+            assert isinstance(assign, ast.Assign), ast.dump(assign)
+            new_node = ast.Constant(value=const)
+            ast.copy_location(new_node, assign.value)
+            assign.value = new_node
+
+        self.assertEqual(self.get_load_const(tree), consts)
+
+    def test_literal_eval(self):
+        tree = ast.parse("1 + 2")
+        binop = tree.body[0].value
+
+        new_left = ast.Constant(value=10)
+        ast.copy_location(new_left, binop.left)
+        binop.left = new_left
+
+        new_right = ast.Constant(value=20j)
+        ast.copy_location(new_right, binop.right)
+        binop.right = new_right
+
+        self.assertEqual(ast.literal_eval(binop), 10 + 20j)
+
+    def test_string_kind(self):
+        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
+        self.assertEqual(c.value, "x")
+        self.assertEqual(c.kind, "u")
+
+        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
+        self.assertEqual(c.value, b"x")
+        self.assertEqual(c.kind, None)
+
+
+class EndPositionTests(unittest.TestCase):
+    """Tests for end position of AST nodes.
+
+    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)
+
+    def _check_content(self, source, ast_node, content):
+        self.assertEqual(ast.get_source_segment(source, ast_node), content)
+
+    def _parse_value(self, s):
+        # Use duck-typing to support both single expression
+        # and a right hand side of an assignment statement.
+        return ast.parse(s).body[0].value
+
+    def test_lambda(self):
+        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")
+
+    def test_func_def(self):
+        s = dedent("""
+            def func(x: int,
+                     *args: str,
+                     z: float = 0,
+                     **kwargs: Any) -> bool:
+                return True
+            """).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")
+
+    def test_call(self):
+        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")
+
+    def test_call_noargs(self):
+        s = "x[0]()"
+        call = self._parse_value(s)
+        self._check_content(s, call.func, "x[0]")
+        self._check_end_pos(call, 1, 6)
+
+    def test_class_def(self):
+        s = dedent("""
+            class C(A, B):
+                x: int = 0
+        """).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")
+
+    def test_class_kw(self):
+        s = "class S(metaclass=abc.ABCMeta): pass"
+        cdef = ast.parse(s).body[0]
+        self._check_content(s, cdef.keywords[0].value, "abc.ABCMeta")
+
+    def test_multi_line_str(self):
+        s = dedent('''
+            x = """Some multi-line text.
+
+            It goes on starting from same indent."""
+        ''').strip()
+        assign = ast.parse(s).body[0]
+        self._check_end_pos(assign, 3, 40)
+        self._check_end_pos(assign.value, 3, 40)
+
+    def test_continued_str(self):
+        s = dedent("""
+            x = "first part" \\
+            "second part"
+        """).strip()
+        assign = ast.parse(s).body[0]
+        self._check_end_pos(assign, 2, 13)
+        self._check_end_pos(assign.value, 2, 13)
+
+    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("""
+            while True:
+                pass
+
+            if one():
+                x = None
+            elif other():
+                y = None
+            else:
+                z = None
+
+            for x, y in stuff:
+                assert True
+
+            try:
+                raise RuntimeError
+            except TypeError as e:
+                pass
+
+            pass
+        """).strip()
+        mod = ast.parse(s)
+        while_loop = mod.body[0]
+        if_stmt = mod.body[1]
+        for_loop = mod.body[2]
+        try_stmt = mod.body[3]
+        pass_stmt = mod.body[4]
+
+        self._check_end_pos(while_loop, 2, 8)
+        self._check_end_pos(if_stmt, 9, 12)
+        self._check_end_pos(for_loop, 12, 15)
+        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")
+
+    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")
+
+    def test_fstring_multi_line(self):
+        s = dedent('''
+            f"""Some multi-line text.
+            {
+            arg_one
+            +
+            arg_two
+            }
+            It goes on..."""
+        ''').strip()
+        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")
+
+    def test_import_from_multi_line(self):
+        s = dedent("""
+            from x.y.z import (
+                a, b, c as c
+            )
+        """).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("""
+            x[ a.b: f () ,
+               g () : c.d
+              ]
+        """).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_end_pos(im, 3, 3)
+
+    def test_binop(self):
+        s = dedent("""
+            (1 * 2 + (3 ) +
+                 4
+            )
+        """).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")
+
+    def test_boolop(self):
+        s = dedent("""
+            if (one_condition and
+                    (other_condition or yet_another_one)):
+                pass
+        """).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")
+
+    def test_tuples(self):
+        s1 = "x = () ;"
+        s2 = "x = 1 , ;"
+        s3 = "x = (1 , 2 ) ;"
+        sm = dedent("""
+            x = (
+                a, b,
+            )
+        """).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_end_pos(tm, 3, 1)
+
+    def test_attribute_spaces(self):
+        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")
+
+    def test_redundant_parenthesis(self):
+        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
+        v = ast.parse(s2).body[0].value.value
+        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"),
+        )
+        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
+                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 () ,}"
+        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 ()")
+
+    def test_comprehensions(self):
+        s = dedent("""
+            x = [{x for x, y in stuff
+                  if cond.x} for stuff in things]
+        """).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")
+
+    def test_yield_await(self):
+        s = dedent("""
+            async def f():
+                yield x
+                await y
+        """).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")
+
+    def test_source_segment_multi(self):
+        s_orig = dedent("""
+            x = (
+                a, b,
+            ) + ()
+        """).strip()
+        s_tuple = dedent("""
+            (
+                a, b,
+            )
+        """).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("""
+            class C:
+                def fun(self) -> None:
+                    "ЖЖЖЖЖ"
+        """).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
+        )
+
+    def test_source_segment_endings(self):
+        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")
+
+    def test_source_segment_tabs(self):
+        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"
+
+        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"
+        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")
+
+        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"
+        v, w, x, y = ast.parse(s).body
+        del v.lineno
+        del w.end_lineno
+        del x.col_offset
+        del y.end_col_offset
+        self.assertIsNone(ast.get_source_segment(s, v))
+        self.assertIsNone(ast.get_source_segment(s, w))
+        self.assertIsNone(ast.get_source_segment(s, x))
+        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):
+        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))
+
+        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): ..."
+
+        # 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":
+                    return None
+                return node
+
+        self.assertASTTransformation(SomeTypeRemover, code, expected)
+
+    def test_node_remove_from_list(self):
+        code = """
+        def func(arg):
+            print(arg)
+            yield arg
+        """
+        expected = """
+        def func(arg):
+            print(arg)
+        """
+
+        # Since `FunctionDef.body` is defined as a list, we test
+        # the `if isinstance(old_value, list):` branch here.
+        class YieldRemover(ast.NodeTransformer):
+            def visit_Expr(self, node: ast.Expr):
+                self.generic_visit(node)
+                if isinstance(node.value, ast.Yield):
+                    return None  # Remove `yield` from a function
+                return node
+
+        self.assertASTTransformation(YieldRemover, code, expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; <class 'object'> is not <class 'NoneType'>
+    def test_node_return_list(self):
+        code = """
+        class DSL(Base, kw1=True): ...
+        """
+        expected = """
+        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":
+                    return [
+                        node,
+                        ast.keyword("kw2", ast.Constant(True)),
+                        ast.keyword("kw3", ast.Constant(False)),
+                    ]
+                return node
+
+        self.assertASTTransformation(ExtendKeywords, code, expected)
+
+    def test_node_mutate(self):
+        code = """
+        def func(arg):
+            print(arg)
+        """
+        expected = """
+        def func(arg):
+            log(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"
+                return node
+
+        self.assertASTTransformation(PrintToLog, code, expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; <class 'object'> is not <class 'NoneType'>
+    def test_node_replace(self):
+        code = """
+        def func(arg):
+            print(arg)
+        """
+        expected = """
+        def func(arg):
+            logger.log(arg, debug=True)
+        """
+
+        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":
+                    return ast.Call(
+                        func=ast.Attribute(
+                            ast.Name("logger", ctx=ast.Load()),
+                            attr="log",
+                            ctx=ast.Load(),
+                        ),
+                        args=node.args,
+                        keywords=[ast.keyword("debug", ast.Constant(True))],
+                    )
+                return node
+
+        self.assertASTTransformation(PrintToLog, code, expected)
+
+
+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'",
+        ):
+            node = ast.FunctionDef(args=args)
+        self.assertFalse(hasattr(node, "name"))
+        self.assertEqual(node.decorator_list, [])
+        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")
+        self.assertIsInstance(name.ctx, ast.Load)
+
+        name2 = ast.Name("x", ast.Store())
+        self.assertEqual(name2.id, "x")
+        self.assertIsInstance(name2.ctx, ast.Store)
+
+        name3 = ast.Name("x", ctx=ast.Del())
+        self.assertEqual(name3.id, "x")
+        self.assertIsInstance(name3.ctx, ast.Del)
+
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            r"Name\.__init__ missing 1 required positional argument: 'id'",
+        ):
+            name3 = ast.Name()
+
+    def test_custom_subclass_with_no_fields(self):
+        class NoInit(ast.AST):
+            pass
+
+        obj = NoInit()
+        self.assertIsInstance(obj, NoInit)
+        self.assertEqual(obj.__dict__, {})
+
+    def test_fields_but_no_field_types(self):
+        class Fields(ast.AST):
+            _fields = ("a",)
+
+        obj = Fields()
+        with self.assertRaises(AttributeError):
+            obj.a
+        obj = Fields(a=1)
+        self.assertEqual(obj.a, 1)
+
+    def test_fields_and_types(self):
+        class FieldsAndTypes(ast.AST):
+            _fields = ("a",)
+            _field_types = {"a": int | None}
+            a: int | None = None
+
+        obj = FieldsAndTypes()
+        self.assertIs(obj.a, None)
+        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")
+
+        obj = MyAttrs(a=1, b=2)
+        self.assertEqual(obj.a, 1)
+        self.assertEqual(obj.b, 2)
+
+        with self.assertWarnsRegex(
+            DeprecationWarning,
+            r"MyAttrs.__init__ got an unexpected keyword argument 'c'.",
+        ):
+            obj = MyAttrs(c=3)
+
+    @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}
+
+        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
+    def test_incomplete_field_types(self):
+        class MoreFieldsThanTypes(ast.AST):
+            _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",
+        ):
+            obj = MoreFieldsThanTypes()
+        self.assertIs(obj.a, None)
+        self.assertIs(obj.b, None)
+
+        obj = MoreFieldsThanTypes(a=1, b=2)
+        self.assertEqual(obj.a, 1)
+        self.assertEqual(obj.b, 2)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_complete_field_types(self):
+        class _AllFieldTypes(ast.AST):
+            _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
+            b: list[str]
+
+        obj = _AllFieldTypes()
+        self.assertIs(obj.a, None)
+        self.assertEqual(obj.b, [])
+
+
+@support.cpython_only
+class ModuleStateTests(unittest.TestCase):
+    # bpo-41194, bpo-41261, bpo-41631: The _ast module uses a global state.
+
+    def check_ast_module(self):
+        # Check that the _ast module still works as expected
+        code = "x + 1"
+        filename = "<string>"
+        mode = "eval"
+
+        # Create _ast.AST subclasses instances
+        ast_tree = compile(code, filename, mode, flags=ast.PyCF_ONLY_AST)
+
+        # Call PyAST_Check()
+        code = compile(ast_tree, filename, mode)
+        self.assertIsInstance(code, types.CodeType)
+
+    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"]
+            import _ast as ast1
+
+            del sys.modules["_ast"]
+            import _ast as ast2
+
+            self.check_ast_module()
+
+        # Unloading the two _ast module instances must not crash.
+        del ast1
+        del ast2
+        support.gc_collect()
+
+        self.check_ast_module()
+
+    def test_sys_modules(self):
+        # bpo-41631: Test reproducing a Mercurial crash when PyAST_Check()
+        # imported the _ast module internally.
+        lazy_mod = object()
+
+        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_attr(builtins, "__import__", my_import):
+                # Test that compile() does not import the _ast module
+                self.check_ast_module()
+                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("""
+            import _ast
+            import ast
+            import gc
+            import sys
+            import types
+
+            # Create _ast.AST subclasses instances and call PyAST_Check()
+            ast_tree = compile('x+1', '<string>', 'eval',
+                               flags=ast.PyCF_ONLY_AST)
+            code = compile(ast_tree, 'string', 'eval')
+            if not isinstance(code, types.CodeType):
+                raise AssertionError
+
+            # Unloading the _ast module must not crash.
+            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.
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_cli_file_input(self):
+        code = "print(1, 2, 3)"
+        expected = ast.dump(ast.parse(code), indent=3)
+
+        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)
+
+        self.assertEqual(res.err, b"")
+        self.assertEqual(expected.splitlines(), res.out.decode("utf8").splitlines())
+        self.assertEqual(res.rc, 0)
+
+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)])
+
+    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),
+            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),
+            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),
+            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
+    def test_folding_format(self):
+        code = "'%s' % (a,)"
+
+        non_optimized_target = self.wrap_expr(
+            ast.BinOp(
+                left=ast.Constant(value="%s"),
+                op=ast.Mod(),
+                right=ast.Tuple(elts=[ast.Name(id='a')]))
+        )
+        optimized_target = self.wrap_expr(
+            ast.JoinedStr(
+                values=[
+                    ast.FormattedValue(value=ast.Name(id='a'), conversion=115)
+                ]
+            )
+        )
+
+        self.assert_ast(code, non_optimized_target, optimized_target)
+
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_tuple(self):
+        code = "(1,)"
+
+        non_optimized_target = self.wrap_expr(ast.Tuple(elts=[ast.Constant(1)]))
+        optimized_target = self.wrap_expr(ast.Constant(value=(1,)))
+
+        self.assert_ast(code, non_optimized_target, optimized_target)
+
+    @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))
+
+        self.assert_ast(code, non_optimized_target, optimized_target)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: compile() unrecognized flags
+    def test_folding_type_param_in_function_def(self):
+        code = "def 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),
+        ]
+
+        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_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),
+        ]
+
+        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_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),
+        ]
+
+        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)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ast/utils.py b/Lib/test/test_ast/utils.py
new file mode 100644
index 0000000000..145e89ee94
--- /dev/null
+++ b/Lib/test/test_ast/utils.py
@@ -0,0 +1,15 @@
+def to_tuple(t):
+    if t is None or isinstance(t, (str, int, complex, float, bytes)) or t is Ellipsis:
+        return t
+    elif isinstance(t, list):
+        return [to_tuple(e) for e in t]
+    result = [t.__class__.__name__]
+    if hasattr(t, 'lineno') and hasattr(t, 'col_offset'):
+        result.append((t.lineno, t.col_offset))
+        if hasattr(t, 'end_lineno') and hasattr(t, 'end_col_offset'):
+            result[-1] += (t.end_lineno, t.end_col_offset)
+    if t._fields is None:
+        return tuple(result)
+    for f in t._fields:
+        result.append(to_tuple(getattr(t, f)))
+    return tuple(result)
diff --git a/Lib/test/test_asyncgen.py b/Lib/test/test_asyncgen.py
index f97316adeb..45d220e3e0 100644
--- a/Lib/test/test_asyncgen.py
+++ b/Lib/test/test_asyncgen.py
@@ -375,8 +375,6 @@ async def async_gen_wrapper():
 
         self.compare_generators(sync_gen_wrapper(), async_gen_wrapper())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_async_gen_api_01(self):
         async def gen():
             yield 123
@@ -467,16 +465,12 @@ async def test_throw():
         result = self.loop.run_until_complete(test_throw())
         self.assertEqual(result, "completed")
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_async_generator_anext(self):
         async def agen():
             yield 1
             yield 2
         self.check_async_iterator_anext(agen)
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_python_async_iterator_anext(self):
         class MyAsyncIter:
             """Asynchronously yield 1, then 2."""
@@ -492,8 +486,6 @@ async def __anext__(self):
                     return self.yielded
         self.check_async_iterator_anext(MyAsyncIter)
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_python_async_iterator_types_coroutine_anext(self):
         import types
         class MyAsyncIterWithTypesCoro:
@@ -523,8 +515,6 @@ async def consume():
         res = self.loop.run_until_complete(consume())
         self.assertEqual(res, [1, 2])
 
-    # TODO: RUSTPYTHON, NameError: name 'aiter' is not defined
-    @unittest.expectedFailure
     def test_async_gen_aiter_class(self):
         results = []
         class Gen:
@@ -549,8 +539,6 @@ async def gen():
         applied_twice = aiter(applied_once)
         self.assertIs(applied_once, applied_twice)
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_bad_args(self):
         async def gen():
             yield 1
@@ -571,8 +559,6 @@ async def call_with_kwarg():
         with self.assertRaises(TypeError):
             self.loop.run_until_complete(call_with_kwarg())
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_bad_await(self):
         async def bad_awaitable():
             class BadAwaitable:
@@ -603,8 +589,6 @@ async def check_anext_returning_iterator(self, aiter_class):
             await awaitable
         return "completed"
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_return_iterator(self):
         class WithIterAnext:
             def __aiter__(self):
@@ -614,8 +598,6 @@ def __anext__(self):
         result = self.loop.run_until_complete(self.check_anext_returning_iterator(WithIterAnext))
         self.assertEqual(result, "completed")
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_return_generator(self):
         class WithGenAnext:
             def __aiter__(self):
@@ -625,8 +607,6 @@ def __anext__(self):
         result = self.loop.run_until_complete(self.check_anext_returning_iterator(WithGenAnext))
         self.assertEqual(result, "completed")
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_await_raises(self):
         class RaisingAwaitable:
             def __await__(self):
@@ -648,8 +628,6 @@ async def do_test():
         result = self.loop.run_until_complete(do_test())
         self.assertEqual(result, "completed")
 
-    # TODO: RUSTPYTHON, NameError: name 'anext' is not defined
-    @unittest.expectedFailure
     def test_anext_iter(self):
         @types.coroutine
         def _async_yield(v):
@@ -1048,8 +1026,6 @@ async def run():
         fut.cancel()
         self.loop.run_until_complete(asyncio.sleep(0.01))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_async_gen_asyncio_gc_aclose_09(self):
         DONE = 0
 
@@ -1507,8 +1483,6 @@ async def main():
 
         self.assertEqual(messages, [])
 
-    # TODO: RUSTPYTHON, ValueError: not enough values to unpack (expected 1, got 0)
-    @unittest.expectedFailure
     def test_async_gen_asyncio_shutdown_exception_01(self):
         messages = []
 
@@ -1538,8 +1512,6 @@ async def main():
         self.assertIn('an error occurred during closing of asynchronous generator',
                       message['message'])
 
-    # TODO: RUSTPYTHON, ValueError: not enough values to unpack (expected 1, got 0)
-    @unittest.expectedFailure
     def test_async_gen_asyncio_shutdown_exception_02(self):
         messages = []
 
diff --git a/Lib/test/test_bdb.py b/Lib/test/test_bdb.py
index a3abbbb8db..c41fb763a1 100644
--- a/Lib/test/test_bdb.py
+++ b/Lib/test/test_bdb.py
@@ -228,6 +228,10 @@ def user_exception(self, frame, exc_info):
         self.process_event('exception', frame)
         self.next_set_method()
 
+    def user_opcode(self, frame):
+        self.process_event('opcode', frame)
+        self.next_set_method()
+
     def do_clear(self, arg):
         # The temporary breakpoints are deleted in user_line().
         bp_list = [self.currentbp]
@@ -366,7 +370,7 @@ def next_set_method(self):
         set_method = getattr(self, 'set_' + set_type)
 
         # The following set methods give back control to the tracer.
-        if set_type in ('step', 'continue', 'quit'):
+        if set_type in ('step', 'stepinstr', 'continue', 'quit'):
             set_method()
             return
         elif set_type in ('next', 'return'):
@@ -586,7 +590,7 @@ def fail(self, msg=None):
 class StateTestCase(BaseTestCase):
     """Test the step, next, return, until and quit 'set_' methods."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -597,7 +601,7 @@ def test_step(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.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):
@@ -612,7 +616,17 @@ def test_step_next_on_last_statement(self):
                 with TracerRun(self) as tracer:
                     tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.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', ),
+            ('opcode', 2, 'tfunc_main'),  ('next', ),
+            ('line',   3, 'tfunc_main'),  ('quit', ),
+        ]
+        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', ),
@@ -624,7 +638,7 @@ def test_next(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_over_import(self):
         code = """
             def main():
@@ -639,7 +653,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_on_plain_statement(self):
         # Check that set_next() is equivalent to set_step() on a plain
         # statement.
@@ -652,7 +666,7 @@ def test_next_on_plain_statement(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_in_caller_frame(self):
         # Check that set_next() in the caller frame causes the tracer
         # to stop next in the caller frame.
@@ -666,7 +680,7 @@ def test_next_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),    ('step', ),
@@ -679,7 +693,7 @@ def test_return(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),   ('step', ),
@@ -691,7 +705,7 @@ def test_return_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -703,7 +717,7 @@ def test_until(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_with_too_large_count(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),               break_in_func('tfunc_first'),
@@ -714,7 +728,7 @@ def test_until_with_too_large_count(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_until_in_caller_frame(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -726,7 +740,8 @@ def test_until_in_caller_frame(self):
         with TracerRun(self) as tracer:
             tracer.runcall(tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.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
         # 'tfunc_import()'.
@@ -759,7 +774,7 @@ def test_skip_with_no_name_module(self):
         bdb = Bdb(skip=['anything*'])
         self.assertIs(bdb.is_skipped_module(None), False)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_down(self):
         # Check that set_down() raises BdbError at the newest frame.
         self.expect_set = [
@@ -768,7 +783,7 @@ def test_down(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_main)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_up(self):
         self.expect_set = [
             ('line', 2, 'tfunc_main'),  ('step', ),
@@ -782,7 +797,7 @@ def test_up(self):
 class BreakpointTestCase(BaseTestCase):
     """Test the breakpoint set method."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_on_non_existent_module(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('break', ('/non/existent/module.py', 1))
@@ -790,7 +805,7 @@ def test_bp_on_non_existent_module(self):
         with TracerRun(self) as tracer:
             self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_after_last_statement(self):
         code = """
             def main():
@@ -804,7 +819,7 @@ def main():
             with TracerRun(self) as tracer:
                 self.assertRaises(BdbError, tracer.runcall, tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_temporary_bp(self):
         code = """
             def func():
@@ -828,7 +843,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_disabled_temporary_bp(self):
         code = """
             def func():
@@ -857,7 +872,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_condition(self):
         code = """
             def func(a):
@@ -878,7 +893,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_exception_on_condition_evaluation(self):
         code = """
             def func(a):
@@ -898,7 +913,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_bp_ignore_count(self):
         code = """
             def func():
@@ -920,7 +935,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_ignore_count_on_disabled_bp(self):
         code = """
             def func():
@@ -948,7 +963,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_two_bp_on_same_line(self):
         code = """
             def func():
@@ -974,7 +989,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_clear_at_no_bp(self):
         self.expect_set = [
             ('line', 2, 'tfunc_import'), ('clear', (__file__, 1))
@@ -1028,7 +1043,7 @@ def test_load_bps_from_previous_Bdb_instance(self):
 class RunTestCase(BaseTestCase):
     """Test run, runeval and set_trace."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_run_step(self):
         # Check that the bdb 'run' method stops at the first line event.
         code = """
@@ -1041,7 +1056,7 @@ def test_run_step(self):
         with TracerRun(self) as tracer:
             tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_runeval_step(self):
         # Test bdb 'runeval'.
         code = """
@@ -1064,7 +1079,7 @@ def main():
 class IssuesTestCase(BaseTestCase):
     """Test fixed bdb issues."""
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_step_at_return_with_no_trace_in_caller(self):
         # Issue #13183.
         # Check that the tracer does step into the caller frame when the
@@ -1095,7 +1110,7 @@ def func():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_until_return_in_generator(self):
         # Issue #16596.
         # Check that set_next(), set_until() and set_return() do not treat the
@@ -1137,7 +1152,7 @@ def main():
                     with TracerRun(self) as tracer:
                         tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_for_loop(self):
         # Issue #16596.
         code = """
@@ -1169,7 +1184,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_next_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1201,7 +1216,7 @@ def main():
             with TracerRun(self) as tracer:
                 tracer.runcall(tfunc_import)
 
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Error in atexit._run_exitfuncs
     def test_return_command_in_generator_with_subiterator(self):
         # Issue #16596.
         code = """
@@ -1233,6 +1248,20 @@ 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.
+        code = """
+            lno = 2
+        """
+        self.expect_set = [
+            ('line', 2, '<module>'),   ('step', ),
+            ('return', 2, '<module>'), ('next', ),
+        ]
+        with TracerRun(self) as tracer:
+            tracer.run(compile(textwrap.dedent(code), '<string>', 'exec'))
+
 
 class TestRegressions(unittest.TestCase):
     def test_format_stack_entry_no_lineno(self):
diff --git a/Lib/test/test_binascii.py b/Lib/test/test_binascii.py
index 40a2ca9f76..cf11ffce7f 100644
--- a/Lib/test/test_binascii.py
+++ b/Lib/test/test_binascii.py
@@ -4,7 +4,8 @@
 import binascii
 import array
 import re
-from test.support import bigmemtest, _1G, _4G, warnings_helper
+from test.support import bigmemtest, _1G, _4G
+from test.support.hypothesis_helper import hypothesis
 
 
 # Note: "*_hex" functions are aliases for "(un)hexlify"
@@ -27,6 +28,14 @@ class BinASCIITest(unittest.TestCase):
     def setUp(self):
         self.data = self.type2test(self.rawdata)
 
+    def assertConversion(self, original, converted, restored, **kwargs):
+        self.assertIsInstance(original, bytes)
+        self.assertIsInstance(converted, bytes)
+        self.assertIsInstance(restored, bytes)
+        if converted:
+            self.assertLess(max(converted), 128)
+        self.assertEqual(original, restored, msg=f'{self.type2test=} {kwargs=}')
+
     def test_exceptions(self):
         # Check module exceptions
         self.assertTrue(issubclass(binascii.Error, Exception))
@@ -52,9 +61,7 @@ def test_returned_value(self):
                 self.fail("{}/{} conversion raises {!r}".format(fb, fa, err))
             self.assertEqual(res, raw, "{}/{} conversion: "
                              "{!r} != {!r}".format(fb, fa, res, raw))
-            self.assertIsInstance(res, bytes)
-            self.assertIsInstance(a, bytes)
-            self.assertLess(max(a), 128)
+            self.assertConversion(raw, a, res)
         self.assertIsInstance(binascii.crc_hqx(raw, 0), int)
         self.assertIsInstance(binascii.crc32(raw), int)
 
@@ -110,6 +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
     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):
@@ -132,13 +140,21 @@ def assertLeadingPadding(data, non_strict_mode_expected_result: bytes):
         def assertDiscontinuousPadding(data, non_strict_mode_expected_result: bytes):
             _assertRegexTemplate(r'(?i)Discontinuous padding', data, non_strict_mode_expected_result)
 
+        def assertExcessPadding(data, non_strict_mode_expected_result: bytes):
+            _assertRegexTemplate(r'(?i)Excess padding', data, non_strict_mode_expected_result)
+
         # Test excess data exceptions
         assertExcessData(b'ab==a', b'i')
         assertExcessData(b'ab===', b'i')
+        assertExcessData(b'ab====', b'i')
         assertExcessData(b'ab==:', b'i')
         assertExcessData(b'abc=a', b'i\xb7')
         assertExcessData(b'abc=:', b'i\xb7')
         assertExcessData(b'ab==\n', b'i')
+        assertExcessData(b'abc==', b'i\xb7')
+        assertExcessData(b'abc===', b'i\xb7')
+        assertExcessData(b'abc====', b'i\xb7')
+        assertExcessData(b'abc=====', b'i\xb7')
 
         # Test non-base64 data exceptions
         assertNonBase64Data(b'\nab==', b'i')
@@ -150,8 +166,16 @@ def assertDiscontinuousPadding(data, non_strict_mode_expected_result: bytes):
         assertLeadingPadding(b'=', b'')
         assertLeadingPadding(b'==', b'')
         assertLeadingPadding(b'===', b'')
+        assertLeadingPadding(b'====', b'')
+        assertLeadingPadding(b'=====', b'')
         assertDiscontinuousPadding(b'ab=c=', b'i\xb7')
         assertDiscontinuousPadding(b'ab=ab==', b'i\xb6\x9b')
+        assertExcessPadding(b'abcd=', b'i\xb7\x1d')
+        assertExcessPadding(b'abcd==', b'i\xb7\x1d')
+        assertExcessPadding(b'abcd===', b'i\xb7\x1d')
+        assertExcessPadding(b'abcd====', b'i\xb7\x1d')
+        assertExcessPadding(b'abcd=====', b'i\xb7\x1d')
+
 
     def test_base64errors(self):
         # Test base64 with invalid padding
@@ -221,6 +245,15 @@ def test_uu(self):
         with self.assertRaises(TypeError):
             binascii.b2a_uu(b"", True)
 
+    @hypothesis.given(
+        binary=hypothesis.strategies.binary(max_size=45),
+        backtick=hypothesis.strategies.booleans(),
+    )
+    def test_b2a_roundtrip(self, binary, backtick):
+        converted = binascii.b2a_uu(self.type2test(binary), backtick=backtick)
+        restored = binascii.a2b_uu(self.type2test(converted))
+        self.assertConversion(binary, converted, restored, backtick=backtick)
+
     def test_crc_hqx(self):
         crc = binascii.crc_hqx(self.type2test(b"Test the CRC-32 of"), 0)
         crc = binascii.crc_hqx(self.type2test(b" this string."), crc)
@@ -258,6 +291,12 @@ def test_hex(self):
         self.assertEqual(binascii.hexlify(self.type2test(s)), t)
         self.assertEqual(binascii.unhexlify(self.type2test(t)), u)
 
+    @hypothesis.given(binary=hypothesis.strategies.binary())
+    def test_hex_roundtrip(self, binary):
+        converted = binascii.hexlify(self.type2test(binary))
+        restored = binascii.unhexlify(self.type2test(converted))
+        self.assertConversion(binary, converted, restored)
+
     def test_hex_separator(self):
         """Test that hexlify and b2a_hex are binary versions of bytes.hex."""
         # Logic of separators is tested in test_bytes.py.  This checks that
@@ -372,6 +411,21 @@ def test_qp(self):
         self.assertEqual(b2a_qp(type2test(b'a.\n')), b'a.\n')
         self.assertEqual(b2a_qp(type2test(b'.a')[:-1]), b'=2E')
 
+    @hypothesis.given(
+        binary=hypothesis.strategies.binary(),
+        quotetabs=hypothesis.strategies.booleans(),
+        istext=hypothesis.strategies.booleans(),
+        header=hypothesis.strategies.booleans(),
+    )
+    def test_b2a_qp_a2b_qp_round_trip(self, binary, quotetabs, istext, header):
+        converted = binascii.b2a_qp(
+            self.type2test(binary),
+            quotetabs=quotetabs, istext=istext, header=header,
+        )
+        restored = binascii.a2b_qp(self.type2test(converted), header=header)
+        self.assertConversion(binary, converted, restored,
+                              quotetabs=quotetabs, istext=istext, header=header)
+
     def test_empty_string(self):
         # A test for SF bug #1022953.  Make sure SystemError is not raised.
         empty = self.type2test(b'')
@@ -427,6 +481,21 @@ def test_b2a_base64_newline(self):
         self.assertEqual(binascii.b2a_base64(b, newline=False),
                          b'aGVsbG8=')
 
+    @hypothesis.given(
+        binary=hypothesis.strategies.binary(),
+        newline=hypothesis.strategies.booleans(),
+    )
+    def test_base64_roundtrip(self, binary, newline):
+        converted = binascii.b2a_base64(self.type2test(binary), newline=newline)
+        restored = binascii.a2b_base64(self.type2test(converted))
+        self.assertConversion(binary, converted, restored, newline=newline)
+
+    def test_c_contiguity(self):
+        m = memoryview(bytearray(b'noncontig'))
+        noncontig_writable = m[::-2]
+        with self.assertRaises(BufferError):
+            binascii.b2a_hex(noncontig_writable)
+
 
 class ArrayBinASCIITest(BinASCIITest):
     def type2test(self, s):
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index b4119305f9..38fd9ab95b 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -153,8 +153,6 @@ def check_iter_pickle(self, it, seq, proto):
         it = pickle.loads(d)
         self.assertEqual(list(it), seq[1:])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_import(self):
         __import__('sys')
         __import__('time')
@@ -1358,7 +1356,6 @@ def test_open_default_encoding(self):
             os.environ.clear()
             os.environ.update(old_environ)
 
-    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON Windows')
     @support.requires_subprocess()
     def test_open_non_inheritable(self):
         fileobj = open(__file__, encoding="utf-8")
@@ -2244,6 +2241,7 @@ def child(wpipe):
             expected = terminal_input.decode(sys.stdin.encoding)  # what else?
         self.assertEqual(input_result, expected)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_input_tty(self):
         # Test input() functionality when wired to a tty (the code path
         # is different and invokes GNU readline if available).
@@ -2260,17 +2258,21 @@ def skip_if_readline(self):
             self.skipTest("the readline module is loaded")
 
     @unittest.skipUnless(hasattr(sys.stdin, 'detach'), 'TODO: RustPython: requires detach function in TextIOWrapper')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_tty_non_ascii(self):
         self.skip_if_readline()
         # Check stdin/stdout encoding is used when invoking PyOS_Readline()
         self.check_input_tty("prompté", b"quux\xe9", "utf-8")
 
     @unittest.skipUnless(hasattr(sys.stdin, 'detach'), 'TODO: RustPython: requires detach function in TextIOWrapper')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON AssertionError: got 0 lines in pipe but expected 2, child output was: quux
     def test_input_tty_non_ascii_unicode_errors(self):
         self.skip_if_readline()
         # Check stdin/stdout error handler is used when invoking PyOS_Readline()
         self.check_input_tty("prompté", b"quux\xe9", "ascii")
 
+    @unittest.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
@@ -2402,8 +2404,6 @@ def test_type_nokwargs(self):
         with self.assertRaises(TypeError):
             type('a', (), dict={})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_name(self):
         for name in 'A', '\xc4', '\U0001f40d', 'B.A', '42', '':
             with self.subTest(name=name):
@@ -2453,8 +2453,6 @@ def test_type_qualname(self):
             A.__qualname__ = b'B'
         self.assertEqual(A.__qualname__, 'D.E')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_type_doc(self):
         for doc in 'x', '\xc4', '\U0001f40d', 'x\x00y', b'x', 42, None:
             A = type('A', (), {'__doc__': doc})
@@ -2488,8 +2486,6 @@ def test_bad_args(self):
         with self.assertRaises(TypeError):
             type('A', (int, str), {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bad_slots(self):
         with self.assertRaises(TypeError):
             type('A', (), {'__slots__': b'x'})
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 3c634b6cac..a1a711da70 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -10,6 +10,7 @@
 import sys
 import copy
 import functools
+import operator
 import pickle
 import tempfile
 import textwrap
@@ -46,6 +47,10 @@ def __index__(self):
 
 class BaseBytesTest:
 
+    def assertTypedEqual(self, actual, expected):
+        self.assertIs(type(actual), type(expected))
+        self.assertEqual(actual, expected)
+
     def test_basics(self):
         b = self.type2test()
         self.assertEqual(type(b), self.type2test)
@@ -196,8 +201,7 @@ def test_constructor_value_errors(self):
         self.assertRaises(ValueError, self.type2test, [sys.maxsize+1])
         self.assertRaises(ValueError, self.type2test, [10**100])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @bigaddrspacetest
     def test_constructor_overflow(self):
         size = MAX_Py_ssize_t
@@ -321,8 +325,7 @@ def test_decode(self):
         # Default encoding is utf-8
         self.assertEqual(self.type2test(b'\xe2\x98\x83').decode(), '\u2603')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_check_encoding_errors(self):
         # bpo-37388: bytes(str) and bytes.encode() must check encoding
         # and errors arguments in dev mode
@@ -737,6 +740,37 @@ def check(fmt, vals, result):
         check(b'%i%b %*.*b', (10, b'3', 5, 3, b'abc',), b'103   abc')
         check(b'%c', b'a', b'a')
 
+        class PseudoFloat:
+            def __init__(self, value):
+                self.value = float(value)
+            def __int__(self):
+                return int(self.value)
+
+        pi = PseudoFloat(3.1415)
+
+        exceptions_params = [
+            ('%x format: an integer is required, not float', b'%x', 3.14),
+            ('%X format: an integer is required, not float', b'%X', 2.11),
+            ('%o format: an integer is required, not float', b'%o', 1.79),
+            ('%x format: an integer is required, not PseudoFloat', b'%x', pi),
+            ('%x format: an integer is required, not complex', b'%x', 3j),
+            ('%X format: an integer is required, not complex', b'%X', 2j),
+            ('%o format: an integer is required, not complex', b'%o', 1j),
+            ('%u format: a real number is required, not complex', b'%u', 3j),
+            # See https://github.com/python/cpython/issues/130928 as for why
+            # the exception message contains '%d' instead of '%i'.
+            ('%d format: a real number is required, not complex', b'%i', 2j),
+            ('%d format: a real number is required, not complex', b'%d', 2j),
+            (
+                r'%c requires an integer in range\(256\) or a single byte',
+                b'%c', pi
+            ),
+        ]
+
+        for msg, format_bytes, value in exceptions_params:
+            with self.assertRaisesRegex(TypeError, msg):
+                operator.mod(format_bytes, value)
+
     def test_imod(self):
         b = self.type2test(b'hello, %b!')
         orig = b
@@ -936,8 +970,7 @@ def test_integer_arguments_out_of_byte_range(self):
             self.assertRaises(ValueError, method, 256)
             self.assertRaises(ValueError, method, 9999)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_find_etc_raise_correct_error_messages(self):
         # issue 11828
         b = self.type2test(b'hello')
@@ -957,8 +990,7 @@ def test_find_etc_raise_correct_error_messages(self):
         self.assertRaisesRegex(TypeError, r'\bendswith\b', b.endswith,
                                 x, None, None, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_free_after_iterating(self):
         test.support.check_free_after_iterating(self, iter, self.type2test)
         test.support.check_free_after_iterating(self, reversed, self.type2test)
@@ -995,13 +1027,13 @@ def test_translate(self):
         self.assertEqual(c, b'hllo')
 
     def test_sq_item(self):
-        _testcapi = import_helper.import_module('_testcapi')
+        _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
         obj = self.type2test((42,))
         with self.assertRaises(IndexError):
-            _testcapi.sequence_getitem(obj, -2)
+            _testlimitedcapi.sequence_getitem(obj, -2)
         with self.assertRaises(IndexError):
-            _testcapi.sequence_getitem(obj, 1)
-        self.assertEqual(_testcapi.sequence_getitem(obj, 0), 42)
+            _testlimitedcapi.sequence_getitem(obj, 1)
+        self.assertEqual(_testlimitedcapi.sequence_getitem(obj, 0), 42)
 
 
 class BytesTest(BaseBytesTest, unittest.TestCase):
@@ -1031,36 +1063,63 @@ def test_buffer_is_readonly(self):
             self.assertRaises(TypeError, f.readinto, b"")
 
     def test_custom(self):
-        class A:
-            def __bytes__(self):
-                return b'abc'
-        self.assertEqual(bytes(A()), b'abc')
-        class A: pass
-        self.assertRaises(TypeError, bytes, A())
-        class A:
-            def __bytes__(self):
-                return None
-        self.assertRaises(TypeError, bytes, A())
-        class A:
+        self.assertEqual(bytes(BytesSubclass(b'abc')), b'abc')
+        self.assertEqual(BytesSubclass(OtherBytesSubclass(b'abc')),
+                         BytesSubclass(b'abc'))
+        self.assertEqual(bytes(WithBytes(b'abc')), b'abc')
+        self.assertEqual(BytesSubclass(WithBytes(b'abc')), BytesSubclass(b'abc'))
+
+        class NoBytes: pass
+        self.assertRaises(TypeError, bytes, NoBytes())
+        self.assertRaises(TypeError, bytes, WithBytes('abc'))
+        self.assertRaises(TypeError, bytes, WithBytes(None))
+        class IndexWithBytes:
             def __bytes__(self):
                 return b'a'
             def __index__(self):
                 return 42
-        self.assertEqual(bytes(A()), b'a')
+        self.assertEqual(bytes(IndexWithBytes()), b'a')
         # Issue #25766
-        class A(str):
+        class StrWithBytes(str):
+            def __new__(cls, value):
+                self = str.__new__(cls, '\u20ac')
+                self.value = value
+                return self
             def __bytes__(self):
-                return b'abc'
-        self.assertEqual(bytes(A('\u20ac')), b'abc')
-        self.assertEqual(bytes(A('\u20ac'), 'iso8859-15'), b'\xa4')
+                return self.value
+        self.assertEqual(bytes(StrWithBytes(b'abc')), b'abc')
+        self.assertEqual(bytes(StrWithBytes(b'abc'), 'iso8859-15'), b'\xa4')
+        self.assertEqual(bytes(StrWithBytes(BytesSubclass(b'abc'))), b'abc')
+        self.assertEqual(BytesSubclass(StrWithBytes(b'abc')), BytesSubclass(b'abc'))
+        self.assertEqual(BytesSubclass(StrWithBytes(b'abc'), 'iso8859-15'),
+                         BytesSubclass(b'\xa4'))
+        self.assertEqual(BytesSubclass(StrWithBytes(BytesSubclass(b'abc'))),
+                         BytesSubclass(b'abc'))
+        self.assertEqual(BytesSubclass(StrWithBytes(OtherBytesSubclass(b'abc'))),
+                         BytesSubclass(b'abc'))
         # Issue #24731
-        class A:
+        self.assertTypedEqual(bytes(WithBytes(BytesSubclass(b'abc'))), BytesSubclass(b'abc'))
+        self.assertTypedEqual(BytesSubclass(WithBytes(BytesSubclass(b'abc'))),
+                              BytesSubclass(b'abc'))
+        self.assertTypedEqual(BytesSubclass(WithBytes(OtherBytesSubclass(b'abc'))),
+                              BytesSubclass(b'abc'))
+
+        class BytesWithBytes(bytes):
+            def __new__(cls, value):
+                self = bytes.__new__(cls, b'\xa4')
+                self.value = value
+                return self
             def __bytes__(self):
-                return OtherBytesSubclass(b'abc')
-        self.assertEqual(bytes(A()), b'abc')
-        self.assertIs(type(bytes(A())), OtherBytesSubclass)
-        self.assertEqual(BytesSubclass(A()), b'abc')
-        self.assertIs(type(BytesSubclass(A())), BytesSubclass)
+                return self.value
+        self.assertTypedEqual(bytes(BytesWithBytes(b'abc')), b'abc')
+        self.assertTypedEqual(BytesSubclass(BytesWithBytes(b'abc')),
+                              BytesSubclass(b'abc'))
+        self.assertTypedEqual(bytes(BytesWithBytes(BytesSubclass(b'abc'))),
+                              BytesSubclass(b'abc'))
+        self.assertTypedEqual(BytesSubclass(BytesWithBytes(BytesSubclass(b'abc'))),
+                              BytesSubclass(b'abc'))
+        self.assertTypedEqual(BytesSubclass(BytesWithBytes(OtherBytesSubclass(b'abc'))),
+                              BytesSubclass(b'abc'))
 
     # Test PyBytes_FromFormat()
     def test_from_format(self):
@@ -1233,6 +1292,8 @@ class SubBytes(bytes):
 class ByteArrayTest(BaseBytesTest, unittest.TestCase):
     type2test = bytearray
 
+    _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
+
     def test_getitem_error(self):
         b = bytearray(b'python')
         msg = "bytearray indices must be integers or slices"
@@ -1325,47 +1386,73 @@ def by(s):
         self.assertEqual(re.findall(br"\w+", b), [by("Hello"), by("world")])
 
     def test_setitem(self):
-        b = bytearray([1, 2, 3])
-        b[1] = 100
-        self.assertEqual(b, bytearray([1, 100, 3]))
-        b[-1] = 200
-        self.assertEqual(b, bytearray([1, 100, 200]))
-        b[0] = Indexable(10)
-        self.assertEqual(b, bytearray([10, 100, 200]))
-        try:
-            b[3] = 0
-            self.fail("Didn't raise IndexError")
-        except IndexError:
-            pass
-        try:
-            b[-10] = 0
-            self.fail("Didn't raise IndexError")
-        except IndexError:
-            pass
-        try:
-            b[0] = 256
-            self.fail("Didn't raise ValueError")
-        except ValueError:
-            pass
-        try:
-            b[0] = Indexable(-1)
-            self.fail("Didn't raise ValueError")
-        except ValueError:
-            pass
-        try:
-            b[0] = None
-            self.fail("Didn't raise TypeError")
-        except TypeError:
-            pass
+        def setitem_as_mapping(b, i, val):
+            b[i] = val
+
+        def setitem_as_sequence(b, i, val):
+            self._testlimitedcapi.sequence_setitem(b, i, val)
+
+        def do_tests(setitem):
+            b = bytearray([1, 2, 3])
+            setitem(b, 1, 100)
+            self.assertEqual(b, bytearray([1, 100, 3]))
+            setitem(b, -1, 200)
+            self.assertEqual(b, bytearray([1, 100, 200]))
+            setitem(b, 0, Indexable(10))
+            self.assertEqual(b, bytearray([10, 100, 200]))
+            try:
+                setitem(b, 3, 0)
+                self.fail("Didn't raise IndexError")
+            except IndexError:
+                pass
+            try:
+                setitem(b, -10, 0)
+                self.fail("Didn't raise IndexError")
+            except IndexError:
+                pass
+            try:
+                setitem(b, 0, 256)
+                self.fail("Didn't raise ValueError")
+            except ValueError:
+                pass
+            try:
+                setitem(b, 0, Indexable(-1))
+                self.fail("Didn't raise ValueError")
+            except ValueError:
+                pass
+            try:
+                setitem(b, 0, object())
+                self.fail("Didn't raise TypeError")
+            except TypeError:
+                pass
+
+        with self.subTest("tp_as_mapping"):
+            do_tests(setitem_as_mapping)
+
+        with self.subTest("tp_as_sequence"):
+            do_tests(setitem_as_sequence)
 
     def test_delitem(self):
-        b = bytearray(range(10))
-        del b[0]
-        self.assertEqual(b, bytearray(range(1, 10)))
-        del b[-1]
-        self.assertEqual(b, bytearray(range(1, 9)))
-        del b[4]
-        self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
+        def del_as_mapping(b, i):
+            del b[i]
+
+        def del_as_sequence(b, i):
+            self._testlimitedcapi.sequence_delitem(b, i)
+
+        def do_tests(delete):
+            b = bytearray(range(10))
+            delete(b, 0)
+            self.assertEqual(b, bytearray(range(1, 10)))
+            delete(b, -1)
+            self.assertEqual(b, bytearray(range(1, 9)))
+            delete(b, 4)
+            self.assertEqual(b, bytearray([1, 2, 3, 4, 6, 7, 8]))
+
+        with self.subTest("tp_as_mapping"):
+            do_tests(del_as_mapping)
+
+        with self.subTest("tp_as_sequence"):
+            do_tests(del_as_sequence)
 
     def test_setslice(self):
         b = bytearray(range(10))
@@ -1558,6 +1645,13 @@ def test_extend(self):
         a = bytearray(b'')
         a.extend([Indexable(ord('a'))])
         self.assertEqual(a, b'a')
+        a = bytearray(b'abc')
+        self.assertRaisesRegex(TypeError,  # Override for string.
+                               "expected iterable of integers; got: 'str'",
+                               a.extend, 'def')
+        self.assertRaisesRegex(TypeError,  # But not for others.
+                               "can't extend bytearray with float",
+                               a.extend, 1.0)
 
     def test_remove(self):
         b = bytearray(b'hello')
@@ -1747,6 +1841,10 @@ def test_repeat_after_setslice(self):
         self.assertEqual(b3, b'xcxcxc')
 
     def test_mutating_index(self):
+        # bytearray slice assignment can call into python code
+        # that reallocates the internal buffer
+        # See gh-91153
+
         class Boom:
             def __index__(self):
                 b.clear()
@@ -1758,10 +1856,42 @@ def __index__(self):
                 b[0] = Boom()
 
         with self.subTest("tp_as_sequence"):
-            _testcapi = import_helper.import_module('_testcapi')
             b = bytearray(b'Now you see me...')
             with self.assertRaises(IndexError):
-                _testcapi.sequence_setitem(b, 0, Boom())
+                self._testlimitedcapi.sequence_setitem(b, 0, Boom())
+
+    def test_mutating_index_inbounds(self):
+        # gh-91153 continued
+        # Ensure buffer is not broken even if length is correct
+
+        class MutatesOnIndex:
+            def __init__(self):
+                self.ba = bytearray(0x180)
+
+            def __index__(self):
+                self.ba.clear()
+                self.new_ba = bytearray(0x180)  # to catch out-of-bounds writes
+                self.ba.extend([0] * 0x180)     # to check bounds checks
+                return 0
+
+        with self.subTest("skip_bounds_safety"):
+            instance = MutatesOnIndex()
+            instance.ba[instance] = ord("?")
+            self.assertEqual(instance.ba[0], ord("?"), "Assigned bytearray not altered")
+            self.assertEqual(instance.new_ba, bytearray(0x180), "Wrong object altered")
+
+        with self.subTest("skip_bounds_safety_capi"):
+            instance = MutatesOnIndex()
+            instance.ba[instance] = ord("?")
+            self._testlimitedcapi.sequence_setitem(instance.ba, instance, ord("?"))
+            self.assertEqual(instance.ba[0], ord("?"), "Assigned bytearray not altered")
+            self.assertEqual(instance.new_ba, bytearray(0x180), "Wrong object altered")
+
+        with self.subTest("skip_bounds_safety_slice"):
+            instance = MutatesOnIndex()
+            instance.ba[instance:1] = [ord("?")]
+            self.assertEqual(instance.ba[0], ord("?"), "Assigned bytearray not altered")
+            self.assertEqual(instance.new_ba, bytearray(0x180), "Wrong object altered")
 
 
 class AssortedBytesTest(unittest.TestCase):
@@ -1769,16 +1899,43 @@ class AssortedBytesTest(unittest.TestCase):
     # Test various combinations of bytes and bytearray
     #
 
+    def test_bytes_repr(self, f=repr):
+        self.assertEqual(f(b''), "b''")
+        self.assertEqual(f(b"abc"), "b'abc'")
+        self.assertEqual(f(bytes([92])), r"b'\\'")
+        self.assertEqual(f(bytes([0, 1, 254, 255])), r"b'\x00\x01\xfe\xff'")
+        self.assertEqual(f(b'\a\b\t\n\v\f\r'), r"b'\x07\x08\t\n\x0b\x0c\r'")
+        self.assertEqual(f(b'"'), """b'"'""") # '"'
+        self.assertEqual(f(b"'"), '''b"'"''') # "'"
+        self.assertEqual(f(b"'\""), r"""b'\'"'""") # '\'"'
+        self.assertEqual(f(b"\"'\""), r"""b'"\'"'""") # '"\'"'
+        self.assertEqual(f(b"'\"'"), r"""b'\'"\''""") # '\'"\''
+        self.assertEqual(f(BytesSubclass(b"abc")), "b'abc'")
+
+    def test_bytearray_repr(self, f=repr):
+        self.assertEqual(f(bytearray()), "bytearray(b'')")
+        self.assertEqual(f(bytearray(b'abc')), "bytearray(b'abc')")
+        self.assertEqual(f(bytearray([92])), r"bytearray(b'\\')")
+        self.assertEqual(f(bytearray([0, 1, 254, 255])),
+                            r"bytearray(b'\x00\x01\xfe\xff')")
+        self.assertEqual(f(bytearray([7, 8, 9, 10, 11, 12, 13])),
+                            r"bytearray(b'\x07\x08\t\n\x0b\x0c\r')")
+        self.assertEqual(f(bytearray(b'"')), """bytearray(b'"')""") # '"'
+        self.assertEqual(f(bytearray(b"'")), r'''bytearray(b"\'")''') # "\'"
+        self.assertEqual(f(bytearray(b"'\"")), r"""bytearray(b'\'"')""") # '\'"'
+        self.assertEqual(f(bytearray(b"\"'\"")), r"""bytearray(b'"\'"')""") # '"\'"'
+        self.assertEqual(f(bytearray(b'\'"\'')), r"""bytearray(b'\'"\'')""") # '\'"\''
+        self.assertEqual(f(ByteArraySubclass(b"abc")), "ByteArraySubclass(b'abc')")
+        self.assertEqual(f(ByteArraySubclass.Nested(b"abc")), "Nested(b'abc')")
+        self.assertEqual(f(ByteArraySubclass.Ŭñıçöđë(b"abc")), "Ŭñıçöđë(b'abc')")
+
     @check_bytes_warnings
-    def test_repr_str(self):
-        for f in str, repr:
-            self.assertEqual(f(bytearray()), "bytearray(b'')")
-            self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
-            self.assertEqual(f(bytearray([0, 1, 254, 255])),
-                             "bytearray(b'\\x00\\x01\\xfe\\xff')")
-            self.assertEqual(f(b"abc"), "b'abc'")
-            self.assertEqual(f(b"'"), '''b"'"''') # '''
-            self.assertEqual(f(b"'\""), r"""b'\'"'""") # '
+    def test_bytes_str(self):
+        self.test_bytes_repr(str)
+
+    @check_bytes_warnings
+    def test_bytearray_str(self):
+        self.test_bytearray_repr(str)
 
     @check_bytes_warnings
     def test_format(self):
@@ -1831,15 +1988,6 @@ def test_from_bytearray(self):
         b = bytearray(buf)
         self.assertEqual(b, bytearray(sample))
 
-    @check_bytes_warnings
-    def test_to_str(self):
-        self.assertEqual(str(b''), "b''")
-        self.assertEqual(str(b'x'), "b'x'")
-        self.assertEqual(str(b'\x80'), "b'\\x80'")
-        self.assertEqual(str(bytearray(b'')), "bytearray(b'')")
-        self.assertEqual(str(bytearray(b'x')), "bytearray(b'x')")
-        self.assertEqual(str(bytearray(b'\x80')), "bytearray(b'\\x80')")
-
     def test_literal(self):
         tests =  [
             (b"Wonderful spam", "Wonderful spam"),
@@ -1990,7 +2138,6 @@ def test_join(self):
         s3 = s1.join([b"abcd"])
         self.assertIs(type(s3), self.basetype)
 
-    @unittest.skip("TODO: RUSTPYTHON, Fails on ByteArraySubclassWithSlotsTest")
     def test_pickle(self):
         a = self.type2test(b"abcd")
         a.x = 10
@@ -2005,7 +2152,6 @@ def test_pickle(self):
             self.assertEqual(type(a.z), type(b.z))
             self.assertFalse(hasattr(b, 'y'))
 
-    @unittest.skip("TODO: RUSTPYTHON, Fails on ByteArraySubclassWithSlotsTest")
     def test_copy(self):
         a = self.type2test(b"abcd")
         a.x = 10
@@ -2049,7 +2195,10 @@ def __init__(me, *args, **kwargs):
 
 
 class ByteArraySubclass(bytearray):
-    pass
+    class Nested(bytearray):
+        pass
+    class Ŭñıçöđë(bytearray):
+        pass
 
 class ByteArraySubclassWithSlots(bytearray):
     __slots__ = ('x', 'y', '__dict__')
@@ -2060,6 +2209,12 @@ class BytesSubclass(bytes):
 class OtherBytesSubclass(bytes):
     pass
 
+class WithBytes:
+    def __init__(self, value):
+        self.value = value
+    def __bytes__(self):
+        return self.value
+
 class ByteArraySubclassTest(SubclassTest, unittest.TestCase):
     basetype = bytearray
     type2test = ByteArraySubclass
diff --git a/Lib/test/test_bz2.py b/Lib/test/test_bz2.py
index dfc444cbbd..3617eba8e8 100644
--- a/Lib/test/test_bz2.py
+++ b/Lib/test/test_bz2.py
@@ -3,19 +3,19 @@
 
 import array
 import unittest
+import io
 from io import BytesIO, DEFAULT_BUFFER_SIZE
 import os
 import pickle
 import glob
 import tempfile
-import pathlib
 import random
 import shutil
 import subprocess
 import threading
 from test.support import import_helper
 from test.support import threading_helper
-from test.support.os_helper import unlink
+from test.support.os_helper import unlink, FakePath
 import _compression
 import sys
 
@@ -476,7 +476,6 @@ def testReadlinesNoNewline(self):
         self.assertEqual(xlines, [b'Test'])
 
     def testContextProtocol(self):
-        f = None
         with BZ2File(self.filename, "wb") as f:
             f.write(b"xxx")
         f = BZ2File(self.filename, "rb")
@@ -537,26 +536,210 @@ def testMultiStreamOrdering(self):
         with BZ2File(self.filename) as bz2f:
             self.assertEqual(bz2f.read(), data1 + data2)
 
+    def testOpenFilename(self):
+        with BZ2File(self.filename, "wb") as f:
+            f.write(b'content')
+            self.assertEqual(f.name, self.filename)
+            self.assertIsInstance(f.fileno(), int)
+            self.assertEqual(f.mode, 'wb')
+            self.assertIs(f.readable(), False)
+            self.assertIs(f.writable(), True)
+            self.assertIs(f.seekable(), False)
+            self.assertIs(f.closed, False)
+        self.assertIs(f.closed, True)
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+        self.assertEqual(f.mode, 'wb')
+        self.assertRaises(ValueError, f.readable)
+        self.assertRaises(ValueError, f.writable)
+        self.assertRaises(ValueError, f.seekable)
+
+        with BZ2File(self.filename, "ab") as f:
+            f.write(b'appendix')
+            self.assertEqual(f.name, self.filename)
+            self.assertIsInstance(f.fileno(), int)
+            self.assertEqual(f.mode, 'wb')
+            self.assertIs(f.readable(), False)
+            self.assertIs(f.writable(), True)
+            self.assertIs(f.seekable(), False)
+            self.assertIs(f.closed, False)
+        self.assertIs(f.closed, True)
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+        self.assertEqual(f.mode, 'wb')
+        self.assertRaises(ValueError, f.readable)
+        self.assertRaises(ValueError, f.writable)
+        self.assertRaises(ValueError, f.seekable)
+
+        with BZ2File(self.filename, 'rb') as f:
+            self.assertEqual(f.read(), b'contentappendix')
+            self.assertEqual(f.name, self.filename)
+            self.assertIsInstance(f.fileno(), int)
+            self.assertEqual(f.mode, 'rb')
+            self.assertIs(f.readable(), True)
+            self.assertIs(f.writable(), False)
+            self.assertIs(f.seekable(), True)
+            self.assertIs(f.closed, False)
+        self.assertIs(f.closed, True)
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+        self.assertEqual(f.mode, 'rb')
+        self.assertRaises(ValueError, f.readable)
+        self.assertRaises(ValueError, f.writable)
+        self.assertRaises(ValueError, f.seekable)
+
+    def testOpenFileWithName(self):
+        with open(self.filename, 'wb') as raw:
+            with BZ2File(raw, 'wb') as f:
+                f.write(b'content')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'wb')
+                self.assertIs(f.readable(), False)
+                self.assertIs(f.writable(), True)
+                self.assertIs(f.seekable(), False)
+                self.assertIs(f.closed, False)
+            self.assertIs(f.closed, True)
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+            self.assertEqual(f.mode, 'wb')
+            self.assertRaises(ValueError, f.readable)
+            self.assertRaises(ValueError, f.writable)
+            self.assertRaises(ValueError, f.seekable)
+
+        with open(self.filename, 'ab') as raw:
+            with BZ2File(raw, 'ab') as f:
+                f.write(b'appendix')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'wb')
+                self.assertIs(f.readable(), False)
+                self.assertIs(f.writable(), True)
+                self.assertIs(f.seekable(), False)
+                self.assertIs(f.closed, False)
+            self.assertIs(f.closed, True)
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+            self.assertEqual(f.mode, 'wb')
+            self.assertRaises(ValueError, f.readable)
+            self.assertRaises(ValueError, f.writable)
+            self.assertRaises(ValueError, f.seekable)
+
+        with open(self.filename, 'rb') as raw:
+            with BZ2File(raw, 'rb') as f:
+                self.assertEqual(f.read(), b'contentappendix')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'rb')
+                self.assertIs(f.readable(), True)
+                self.assertIs(f.writable(), False)
+                self.assertIs(f.seekable(), True)
+                self.assertIs(f.closed, False)
+            self.assertIs(f.closed, True)
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+            self.assertEqual(f.mode, 'rb')
+            self.assertRaises(ValueError, f.readable)
+            self.assertRaises(ValueError, f.writable)
+            self.assertRaises(ValueError, f.seekable)
+
+    def testOpenFileWithoutName(self):
+        bio = BytesIO()
+        with BZ2File(bio, 'wb') as f:
+            f.write(b'content')
+            with self.assertRaises(AttributeError):
+                f.name
+            self.assertRaises(io.UnsupportedOperation, f.fileno)
+            self.assertEqual(f.mode, 'wb')
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+
+        with BZ2File(bio, 'ab') as f:
+            f.write(b'appendix')
+            with self.assertRaises(AttributeError):
+                f.name
+            self.assertRaises(io.UnsupportedOperation, f.fileno)
+            self.assertEqual(f.mode, 'wb')
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+
+        bio.seek(0)
+        with BZ2File(bio, 'rb') as f:
+            self.assertEqual(f.read(), b'contentappendix')
+            with self.assertRaises(AttributeError):
+                f.name
+            self.assertRaises(io.UnsupportedOperation, f.fileno)
+            self.assertEqual(f.mode, 'rb')
+        with self.assertRaises(ValueError):
+            f.name
+        self.assertRaises(ValueError, f.fileno)
+
+    def testOpenFileWithIntName(self):
+        fd = os.open(self.filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
+        with open(fd, 'wb') as raw:
+            with BZ2File(raw, 'wb') as f:
+                f.write(b'content')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'wb')
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+
+        fd = os.open(self.filename, os.O_WRONLY | os.O_CREAT | os.O_APPEND)
+        with open(fd, 'ab') as raw:
+            with BZ2File(raw, 'ab') as f:
+                f.write(b'appendix')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'wb')
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+
+        fd = os.open(self.filename, os.O_RDONLY)
+        with open(fd, 'rb') as raw:
+            with BZ2File(raw, 'rb') as f:
+                self.assertEqual(f.read(), b'contentappendix')
+                self.assertEqual(f.name, raw.name)
+                self.assertEqual(f.fileno(), raw.fileno())
+                self.assertEqual(f.mode, 'rb')
+            with self.assertRaises(ValueError):
+                f.name
+            self.assertRaises(ValueError, f.fileno)
+
     def testOpenBytesFilename(self):
         str_filename = self.filename
-        try:
-            bytes_filename = str_filename.encode("ascii")
-        except UnicodeEncodeError:
-            self.skipTest("Temporary file name needs to be ASCII")
+        bytes_filename = os.fsencode(str_filename)
         with BZ2File(bytes_filename, "wb") as f:
             f.write(self.DATA)
+            self.assertEqual(f.name, bytes_filename)
         with BZ2File(bytes_filename, "rb") as f:
             self.assertEqual(f.read(), self.DATA)
+            self.assertEqual(f.name, bytes_filename)
         # Sanity check that we are actually operating on the right file.
         with BZ2File(str_filename, "rb") as f:
             self.assertEqual(f.read(), self.DATA)
+            self.assertEqual(f.name, str_filename)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def testOpenPathLikeFilename(self):
-        filename = pathlib.Path(self.filename)
+        filename = FakePath(self.filename)
         with BZ2File(filename, "wb") as f:
             f.write(self.DATA)
+            self.assertEqual(f.name, self.filename)
         with BZ2File(filename, "rb") as f:
             self.assertEqual(f.read(), self.DATA)
+            self.assertEqual(f.name, self.filename)
 
     def testDecompressLimited(self):
         """Decompressed data buffering should be limited"""
@@ -577,6 +760,9 @@ def testReadBytesIO(self):
             with BZ2File(bio) as bz2f:
                 self.assertRaises(TypeError, bz2f.read, float())
                 self.assertEqual(bz2f.read(), self.TEXT)
+                with self.assertRaises(AttributeError):
+                    bz2.name
+                self.assertEqual(bz2f.mode, 'rb')
             self.assertFalse(bio.closed)
 
     def testPeekBytesIO(self):
@@ -592,6 +778,9 @@ def testWriteBytesIO(self):
             with BZ2File(bio, "w") as bz2f:
                 self.assertRaises(TypeError, bz2f.write)
                 bz2f.write(self.TEXT)
+                with self.assertRaises(AttributeError):
+                    bz2.name
+                self.assertEqual(bz2f.mode, 'wb')
             self.assertEqual(ext_decompress(bio.getvalue()), self.TEXT)
             self.assertFalse(bio.closed)
 
diff --git a/Lib/test/test_call.py b/Lib/test/test_call.py
index 3cb9659acb..86ba0aa4b6 100644
--- a/Lib/test/test_call.py
+++ b/Lib/test/test_call.py
@@ -1,14 +1,29 @@
-import datetime
 import unittest
-from test.support import cpython_only
+from test.support import (cpython_only, is_wasi, requires_limited_api, Py_DEBUG,
+                          set_recursion_limit, skip_on_s390x, import_helper)
 try:
     import _testcapi
 except ImportError:
     _testcapi = None
+try:
+    import _testlimitedcapi
+except ImportError:
+    _testlimitedcapi = None
 import struct
 import collections
 import itertools
 import gc
+import contextlib
+import sys
+import types
+
+
+class BadStr(str):
+    def __eq__(self, other):
+        return True
+    def __hash__(self):
+        # Guaranteed different hash
+        return str.__hash__(self) ^ 3
 
 
 class FunctionCalls(unittest.TestCase):
@@ -26,124 +41,22 @@ def fn(**kw):
         self.assertIsInstance(res, dict)
         self.assertEqual(list(res.items()), expected)
 
-
-# The test cases here cover several paths through the function calling
-# code.  They depend on the METH_XXX flag that is used to define a C
-# function, which can't be verified from Python.  If the METH_XXX decl
-# for a C function changes, these tests may not cover the right paths.
-
-class CFunctionCalls(unittest.TestCase):
-
-    def test_varargs0(self):
-        self.assertRaises(TypeError, {}.__contains__)
-
-    def test_varargs1(self):
-        {}.__contains__(0)
-
-    def test_varargs2(self):
-        self.assertRaises(TypeError, {}.__contains__, 0, 1)
-
-    def test_varargs0_ext(self):
-        try:
-            {}.__contains__(*())
-        except TypeError:
-            pass
-
-    def test_varargs1_ext(self):
-        {}.__contains__(*(0,))
-
-    def test_varargs2_ext(self):
-        try:
-            {}.__contains__(*(1, 2))
-        except TypeError:
-            pass
-        else:
-            raise RuntimeError
-
-    def test_varargs1_kw(self):
-        self.assertRaises(TypeError, {}.__contains__, x=2)
-
-    def test_varargs2_kw(self):
-        self.assertRaises(TypeError, {}.__contains__, x=2, y=2)
-
-    def test_oldargs0_0(self):
-        {}.keys()
-
-    def test_oldargs0_1(self):
-        self.assertRaises(TypeError, {}.keys, 0)
-
-    def test_oldargs0_2(self):
-        self.assertRaises(TypeError, {}.keys, 0, 1)
-
-    def test_oldargs0_0_ext(self):
-        {}.keys(*())
-
-    def test_oldargs0_1_ext(self):
-        try:
-            {}.keys(*(0,))
-        except TypeError:
+    def test_frames_are_popped_after_failed_calls(self):
+        # GH-93252: stuff blows up if we don't pop the new frame after
+        # recovering from failed calls:
+        def f():
             pass
-        else:
-            raise RuntimeError
-
-    def test_oldargs0_2_ext(self):
-        try:
-            {}.keys(*(1, 2))
-        except TypeError:
-            pass
-        else:
-            raise RuntimeError
-
-    def test_oldargs0_0_kw(self):
-        try:
-            {}.keys(x=2)
-        except TypeError:
-            pass
-        else:
-            raise RuntimeError
-
-    def test_oldargs0_1_kw(self):
-        self.assertRaises(TypeError, {}.keys, x=2)
-
-    def test_oldargs0_2_kw(self):
-        self.assertRaises(TypeError, {}.keys, x=2, y=2)
-
-    def test_oldargs1_0(self):
-        self.assertRaises(TypeError, [].count)
-
-    def test_oldargs1_1(self):
-        [].count(1)
-
-    def test_oldargs1_2(self):
-        self.assertRaises(TypeError, [].count, 1, 2)
-
-    def test_oldargs1_0_ext(self):
-        try:
-            [].count(*())
-        except TypeError:
-            pass
-        else:
-            raise RuntimeError
-
-    def test_oldargs1_1_ext(self):
-        [].count(*(1,))
-
-    def test_oldargs1_2_ext(self):
-        try:
-            [].count(*(1, 2))
-        except TypeError:
-            pass
-        else:
-            raise RuntimeError
-
-    def test_oldargs1_0_kw(self):
-        self.assertRaises(TypeError, [].count, x=2)
-
-    def test_oldargs1_1_kw(self):
-        self.assertRaises(TypeError, [].count, {}, x=2)
-
-    def test_oldargs1_2_kw(self):
-        self.assertRaises(TypeError, [].count, x=2, y=2)
+        class C:
+            def m(self):
+                pass
+        callables = [f, C.m, [].__len__]
+        for c in callables:
+            for _ in range(1000):
+                try:
+                    c(None)
+                except TypeError:
+                    pass
+        # BOOM!
 
 
 @cpython_only
@@ -158,11 +71,12 @@ def test_varargs2(self):
         self.assertRaisesRegex(TypeError, msg, {}.__contains__, 0, 1)
 
     def test_varargs3(self):
-        msg = r"^from_bytes\(\) takes exactly 2 positional arguments \(3 given\)"
+        msg = r"^from_bytes\(\) takes at most 2 positional arguments \(3 given\)"
         self.assertRaisesRegex(TypeError, msg, int.from_bytes, b'a', 'little', False)
 
     def test_varargs1min(self):
-        msg = r"get expected at least 1 argument, got 0"
+        msg = (r"get\(\) takes at least 1 argument \(0 given\)|"
+               r"get expected at least 1 argument, got 0")
         self.assertRaisesRegex(TypeError, msg, {}.get)
 
         msg = r"expected 1 argument, got 0"
@@ -173,11 +87,13 @@ def test_varargs2min(self):
         self.assertRaisesRegex(TypeError, msg, getattr)
 
     def test_varargs1max(self):
-        msg = r"input expected at most 1 argument, got 2"
+        msg = (r"input\(\) takes at most 1 argument \(2 given\)|"
+               r"input expected at most 1 argument, got 2")
         self.assertRaisesRegex(TypeError, msg, input, 1, 2)
 
     def test_varargs2max(self):
-        msg = r"get expected at most 2 arguments, got 3"
+        msg = (r"get\(\) takes at most 2 arguments \(3 given\)|"
+               r"get expected at most 2 arguments, got 3")
         self.assertRaisesRegex(TypeError, msg, {}.get, 1, 2, 3)
 
     def test_varargs1_kw(self):
@@ -193,7 +109,7 @@ def test_varargs3_kw(self):
         self.assertRaisesRegex(TypeError, msg, bool, x=2)
 
     def test_varargs4_kw(self):
-        msg = r"^index\(\) takes no keyword arguments$"
+        msg = r"^(list[.])?index\(\) takes no keyword arguments$"
         self.assertRaisesRegex(TypeError, msg, [].index, x=2)
 
     def test_varargs5_kw(self):
@@ -209,19 +125,19 @@ def test_varargs7_kw(self):
         self.assertRaisesRegex(TypeError, msg, next, x=2)
 
     def test_varargs8_kw(self):
-        msg = r"^pack\(\) takes no keyword arguments$"
+        msg = r"^_struct[.]pack\(\) takes no keyword arguments$"
         self.assertRaisesRegex(TypeError, msg, struct.pack, x=2)
 
     def test_varargs9_kw(self):
-        msg = r"^pack_into\(\) takes no keyword arguments$"
+        msg = r"^_struct[.]pack_into\(\) takes no keyword arguments$"
         self.assertRaisesRegex(TypeError, msg, struct.pack_into, x=2)
 
     def test_varargs10_kw(self):
-        msg = r"^index\(\) takes no keyword arguments$"
+        msg = r"^deque[.]index\(\) takes no keyword arguments$"
         self.assertRaisesRegex(TypeError, msg, collections.deque().index, x=2)
 
     def test_varargs11_kw(self):
-        msg = r"^pack\(\) takes no keyword arguments$"
+        msg = r"^Struct[.]pack\(\) takes no keyword arguments$"
         self.assertRaisesRegex(TypeError, msg, struct.Struct.pack, struct.Struct(""), x=2)
 
     def test_varargs12_kw(self):
@@ -238,9 +154,9 @@ def test_varargs14_kw(self):
                                itertools.product, 0, repeat=1, foo=2)
 
     def test_varargs15_kw(self):
-        msg = r"^ImportError\(\) takes at most 2 keyword arguments \(3 given\)$"
+        msg = r"^ImportError\(\) takes at most 3 keyword arguments \(4 given\)$"
         self.assertRaisesRegex(TypeError, msg,
-                               ImportError, 0, name=1, path=2, foo=3)
+                               ImportError, 0, name=1, path=2, name_from=3, foo=3)
 
     def test_varargs16_kw(self):
         msg = r"^min\(\) takes at most 2 keyword arguments \(3 given\)$"
@@ -248,10 +164,22 @@ def test_varargs16_kw(self):
                                min, 0, default=1, key=2, foo=3)
 
     def test_varargs17_kw(self):
-        msg = r"^print\(\) takes at most 4 keyword arguments \(5 given\)$"
+        msg = r"print\(\) got an unexpected keyword argument 'foo'$"
         self.assertRaisesRegex(TypeError, msg,
                                print, 0, sep=1, end=2, file=3, flush=4, foo=5)
 
+    def test_varargs18_kw(self):
+        # _PyArg_UnpackKeywordsWithVararg()
+        msg = r"invalid keyword argument for print\(\)$"
+        with self.assertRaisesRegex(TypeError, msg):
+            print(0, 1, **{BadStr('foo'): ','})
+
+    def test_varargs19_kw(self):
+        # _PyArg_UnpackKeywords()
+        msg = r"invalid keyword argument for round\(\)$"
+        with self.assertRaisesRegex(TypeError, msg):
+            round(1.75, **{BadStr('foo'): 1})
+
     def test_oldargs0_1(self):
         msg = r"keys\(\) takes no arguments \(1 given\)"
         self.assertRaisesRegex(TypeError, msg, {}.keys, 0)
@@ -288,6 +216,208 @@ def test_oldargs1_2_kw(self):
         msg = r"count\(\) takes no keyword arguments"
         self.assertRaisesRegex(TypeError, msg, [].count, x=2, y=2)
 
+    def test_object_not_callable(self):
+        msg = r"^'object' object is not callable$"
+        self.assertRaisesRegex(TypeError, msg, object())
+
+    def test_module_not_callable_no_suggestion_0(self):
+        msg = r"^'module' object is not callable$"
+        self.assertRaisesRegex(TypeError, msg, types.ModuleType("mod"))
+
+    def test_module_not_callable_no_suggestion_1(self):
+        msg = r"^'module' object is not callable$"
+        mod = types.ModuleType("mod")
+        mod.mod = 42
+        self.assertRaisesRegex(TypeError, msg, mod)
+
+    def test_module_not_callable_no_suggestion_2(self):
+        msg = r"^'module' object is not callable$"
+        mod = types.ModuleType("mod")
+        del mod.__name__
+        self.assertRaisesRegex(TypeError, msg, mod)
+
+    def test_module_not_callable_no_suggestion_3(self):
+        msg = r"^'module' object is not callable$"
+        mod = types.ModuleType("mod")
+        mod.__name__ = 42
+        self.assertRaisesRegex(TypeError, msg, mod)
+
+    def test_module_not_callable_suggestion(self):
+        msg = r"^'module' object is not callable\. Did you mean: 'mod\.mod\(\.\.\.\)'\?$"
+        mod = types.ModuleType("mod")
+        mod.mod = lambda: ...
+        self.assertRaisesRegex(TypeError, msg, mod)
+
+
+@unittest.skipIf(_testcapi is None, "requires _testcapi")
+class TestCallingConventions(unittest.TestCase):
+    """Test calling using various C calling conventions (METH_*) from Python
+
+    Subclasses test several kinds of functions (module-level, methods,
+    class methods static methods) using these attributes:
+      obj: the object that contains tested functions (as attributes)
+      expected_self: expected "self" argument to the C function
+
+    The base class tests module-level functions.
+    """
+
+    def setUp(self):
+        self.obj = self.expected_self = _testcapi
+
+    def test_varargs(self):
+        self.assertEqual(
+            self.obj.meth_varargs(1, 2, 3),
+            (self.expected_self, (1, 2, 3)),
+        )
+
+    def test_varargs_ext(self):
+        self.assertEqual(
+            self.obj.meth_varargs(*(1, 2, 3)),
+            (self.expected_self, (1, 2, 3)),
+        )
+
+    def test_varargs_error_kw(self):
+        msg = r"meth_varargs\(\) takes no keyword arguments"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_varargs(k=1),
+        )
+
+    def test_varargs_keywords(self):
+        self.assertEqual(
+            self.obj.meth_varargs_keywords(1, 2, a=3, b=4),
+            (self.expected_self, (1, 2), {'a': 3, 'b': 4})
+        )
+
+    def test_varargs_keywords_ext(self):
+        self.assertEqual(
+            self.obj.meth_varargs_keywords(*[1, 2], **{'a': 3, 'b': 4}),
+            (self.expected_self, (1, 2), {'a': 3, 'b': 4})
+        )
+
+    def test_o(self):
+        self.assertEqual(self.obj.meth_o(1), (self.expected_self, 1))
+
+    def test_o_ext(self):
+        self.assertEqual(self.obj.meth_o(*[1]), (self.expected_self, 1))
+
+    def test_o_error_no_arg(self):
+        msg = r"meth_o\(\) takes exactly one argument \(0 given\)"
+        self.assertRaisesRegex(TypeError, msg, self.obj.meth_o)
+
+    def test_o_error_two_args(self):
+        msg = r"meth_o\(\) takes exactly one argument \(2 given\)"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_o(1, 2),
+        )
+
+    def test_o_error_ext(self):
+        msg = r"meth_o\(\) takes exactly one argument \(3 given\)"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_o(*(1, 2, 3)),
+        )
+
+    def test_o_error_kw(self):
+        msg = r"meth_o\(\) takes no keyword arguments"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_o(k=1),
+        )
+
+    def test_o_error_arg_kw(self):
+        msg = r"meth_o\(\) takes no keyword arguments"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_o(k=1),
+        )
+
+    def test_noargs(self):
+        self.assertEqual(self.obj.meth_noargs(), self.expected_self)
+
+    def test_noargs_ext(self):
+        self.assertEqual(self.obj.meth_noargs(*[]), self.expected_self)
+
+    def test_noargs_error_arg(self):
+        msg = r"meth_noargs\(\) takes no arguments \(1 given\)"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_noargs(1),
+        )
+
+    def test_noargs_error_arg2(self):
+        msg = r"meth_noargs\(\) takes no arguments \(2 given\)"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_noargs(1, 2),
+        )
+
+    def test_noargs_error_ext(self):
+        msg = r"meth_noargs\(\) takes no arguments \(3 given\)"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_noargs(*(1, 2, 3)),
+        )
+
+    def test_noargs_error_kw(self):
+        msg = r"meth_noargs\(\) takes no keyword arguments"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_noargs(k=1),
+        )
+
+    def test_fastcall(self):
+        self.assertEqual(
+            self.obj.meth_fastcall(1, 2, 3),
+            (self.expected_self, (1, 2, 3)),
+        )
+
+    def test_fastcall_ext(self):
+        self.assertEqual(
+            self.obj.meth_fastcall(*(1, 2, 3)),
+            (self.expected_self, (1, 2, 3)),
+        )
+
+    def test_fastcall_error_kw(self):
+        msg = r"meth_fastcall\(\) takes no keyword arguments"
+        self.assertRaisesRegex(
+            TypeError, msg, lambda: self.obj.meth_fastcall(k=1),
+        )
+
+    def test_fastcall_keywords(self):
+        self.assertEqual(
+            self.obj.meth_fastcall_keywords(1, 2, a=3, b=4),
+            (self.expected_self, (1, 2), {'a': 3, 'b': 4})
+        )
+
+    def test_fastcall_keywords_ext(self):
+        self.assertEqual(
+            self.obj.meth_fastcall_keywords(*(1, 2), **{'a': 3, 'b': 4}),
+            (self.expected_self, (1, 2), {'a': 3, 'b': 4})
+        )
+
+
+class TestCallingConventionsInstance(TestCallingConventions):
+    """Test calling instance methods using various calling conventions"""
+
+    def setUp(self):
+        self.obj = self.expected_self = _testcapi.MethInstance()
+
+
+class TestCallingConventionsClass(TestCallingConventions):
+    """Test calling class methods using various calling conventions"""
+
+    def setUp(self):
+        self.obj = self.expected_self = _testcapi.MethClass
+
+
+class TestCallingConventionsClassInstance(TestCallingConventions):
+    """Test calling class methods on instance"""
+
+    def setUp(self):
+        self.obj = _testcapi.MethClass()
+        self.expected_self = _testcapi.MethClass
+
+
+class TestCallingConventionsStatic(TestCallingConventions):
+    """Test calling static methods using various calling conventions"""
+
+    def setUp(self):
+        self.obj = _testcapi.MethStatic()
+        self.expected_self = None
+
 
 def pyfunc(arg1, arg2):
     return [arg1, arg2]
@@ -315,14 +445,15 @@ def static_method():
 
 PYTHON_INSTANCE = PythonClass()
 
-
-IGNORE_RESULT = object()
+NULL_OR_EMPTY = object()
 
 
-@cpython_only
 class FastCallTests(unittest.TestCase):
+    """Test calling using various callables from C
+    """
+
     # Test calls with positional arguments
-    CALLS_POSARGS = (
+    CALLS_POSARGS = [
         # (func, args: tuple, result)
 
         # Python function with 2 arguments
@@ -341,31 +472,11 @@ class FastCallTests(unittest.TestCase):
         (PYTHON_INSTANCE.class_method, (), "classmethod"),
         (PYTHON_INSTANCE.static_method, (), "staticmethod"),
 
-        # C function: METH_NOARGS
-        (globals, (), IGNORE_RESULT),
-
-        # C function: METH_O
-        (id, ("hello",), IGNORE_RESULT),
-
-        # C function: METH_VARARGS
-        (dir, (1,), IGNORE_RESULT),
-
-        # C function: METH_VARARGS | METH_KEYWORDS
-        (min, (5, 9), 5),
-
-        # C function: METH_FASTCALL
-        (divmod, (1000, 33), (30, 10)),
-
-        # C type static method: METH_FASTCALL | METH_CLASS
-        (int.from_bytes, (b'\x01\x00', 'little'), 1),
-
-        # bpo-30524: Test that calling a C type static method with no argument
-        # doesn't crash (ignore the result): METH_FASTCALL | METH_CLASS
-        (datetime.datetime.now, (), IGNORE_RESULT),
-    )
+        # C callables are added later
+    ]
 
     # Test calls with positional and keyword arguments
-    CALLS_KWARGS = (
+    CALLS_KWARGS = [
         # (func, args: tuple, kwargs: dict, result)
 
         # Python function with 2 arguments
@@ -376,34 +487,57 @@ class FastCallTests(unittest.TestCase):
         (PYTHON_INSTANCE.method, (1,), {'arg2': 2}, [1, 2]),
         (PYTHON_INSTANCE.method, (), {'arg1': 1, 'arg2': 2}, [1, 2]),
 
-        # C function: METH_VARARGS | METH_KEYWORDS
-        (max, ([],), {'default': 9}, 9),
-
-        # C type static method: METH_FASTCALL | METH_CLASS
-        (int.from_bytes, (b'\x01\x00',), {'byteorder': 'little'}, 1),
-        (int.from_bytes, (), {'bytes': b'\x01\x00', 'byteorder': 'little'}, 1),
-    )
+        # C callables are added later
+    ]
+
+    # Add all the calling conventions and variants of C callables
+    if _testcapi:
+        _instance = _testcapi.MethInstance()
+        for obj, expected_self in (
+            (_testcapi, _testcapi),  # module-level function
+            (_instance, _instance),  # bound method
+            (_testcapi.MethClass, _testcapi.MethClass),  # class method on class
+            (_testcapi.MethClass(), _testcapi.MethClass),  # class method on inst.
+            (_testcapi.MethStatic, None),  # static method
+        ):
+            CALLS_POSARGS.extend([
+                (obj.meth_varargs, (1, 2), (expected_self, (1, 2))),
+                (obj.meth_varargs_keywords,
+                    (1, 2), (expected_self, (1, 2), NULL_OR_EMPTY)),
+                (obj.meth_fastcall, (1, 2), (expected_self, (1, 2))),
+                (obj.meth_fastcall, (), (expected_self, ())),
+                (obj.meth_fastcall_keywords,
+                    (1, 2), (expected_self, (1, 2), NULL_OR_EMPTY)),
+                (obj.meth_fastcall_keywords,
+                    (), (expected_self, (), NULL_OR_EMPTY)),
+                (obj.meth_noargs, (), expected_self),
+                (obj.meth_o, (123, ), (expected_self, 123)),
+            ])
+
+            CALLS_KWARGS.extend([
+                (obj.meth_varargs_keywords,
+                    (1, 2), {'x': 'y'}, (expected_self, (1, 2), {'x': 'y'})),
+                (obj.meth_varargs_keywords,
+                    (), {'x': 'y'}, (expected_self, (), {'x': 'y'})),
+                (obj.meth_varargs_keywords,
+                    (1, 2), {}, (expected_self, (1, 2), NULL_OR_EMPTY)),
+                (obj.meth_fastcall_keywords,
+                    (1, 2), {'x': 'y'}, (expected_self, (1, 2), {'x': 'y'})),
+                (obj.meth_fastcall_keywords,
+                    (), {'x': 'y'}, (expected_self, (), {'x': 'y'})),
+                (obj.meth_fastcall_keywords,
+                    (1, 2), {}, (expected_self, (1, 2), NULL_OR_EMPTY)),
+            ])
 
     def check_result(self, result, expected):
-        if expected is IGNORE_RESULT:
-            return
+        if isinstance(expected, tuple) and expected[-1] is NULL_OR_EMPTY:
+            if result[-1] in ({}, None):
+                expected = (*expected[:-1], result[-1])
         self.assertEqual(result, expected)
 
-    def test_fastcall(self):
-        # Test _PyObject_FastCall()
-
-        for func, args, expected in self.CALLS_POSARGS:
-            with self.subTest(func=func, args=args):
-                result = _testcapi.pyobject_fastcall(func, args)
-                self.check_result(result, expected)
-
-                if not args:
-                    # args=NULL, nargs=0
-                    result = _testcapi.pyobject_fastcall(func, None)
-                    self.check_result(result, expected)
-
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_vectorcall_dict(self):
-        # Test _PyObject_FastCallDict()
+        # Test PyObject_VectorcallDict()
 
         for func, args, expected in self.CALLS_POSARGS:
             with self.subTest(func=func, args=args):
@@ -411,26 +545,19 @@ def test_vectorcall_dict(self):
                 result = _testcapi.pyobject_fastcalldict(func, args, None)
                 self.check_result(result, expected)
 
-                # kwargs={}
-                result = _testcapi.pyobject_fastcalldict(func, args, {})
-                self.check_result(result, expected)
-
                 if not args:
                     # args=NULL, nargs=0, kwargs=NULL
                     result = _testcapi.pyobject_fastcalldict(func, None, None)
                     self.check_result(result, expected)
 
-                    # args=NULL, nargs=0, kwargs={}
-                    result = _testcapi.pyobject_fastcalldict(func, None, {})
-                    self.check_result(result, expected)
-
         for func, args, kwargs, expected in self.CALLS_KWARGS:
             with self.subTest(func=func, args=args, kwargs=kwargs):
                 result = _testcapi.pyobject_fastcalldict(func, args, kwargs)
                 self.check_result(result, expected)
 
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_vectorcall(self):
-        # Test _PyObject_Vectorcall()
+        # Test PyObject_Vectorcall()
 
         for func, args, expected in self.CALLS_POSARGS:
             with self.subTest(func=func, args=args):
@@ -458,6 +585,7 @@ def test_vectorcall(self):
                 result = _testcapi.pyobject_vectorcall(func, args, kwnames)
                 self.check_result(result, expected)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: Expected type 'int' but 'IntWithDict' found.
     def test_fastcall_clearing_dict(self):
         # Test bpo-36907: the point of the test is just checking that this
         # does not crash.
@@ -469,7 +597,7 @@ def __index__(self):
                 self.kwargs.clear()
                 gc.collect()
                 return 0
-        x = IntWithDict(dont_inherit=IntWithDict())
+        x = IntWithDict(optimize=IntWithDict())
         # We test the argument handling of "compile" here, the compilation
         # itself is not relevant. When we pass flags=x below, x.__index__() is
         # called, which changes the keywords dict.
@@ -490,10 +618,12 @@ def testfunction_kw(self, *, kw):
     return self
 
 
+ADAPTIVE_WARMUP_DELAY = 2
+
+
+@unittest.skipIf(_testcapi is None, "requires _testcapi")
 class TestPEP590(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_method_descriptor_flag(self):
         import functools
         cached = functools.lru_cache(1)(testfunction)
@@ -508,26 +638,32 @@ def test_method_descriptor_flag(self):
         self.assertTrue(_testcapi.MethodDescriptorDerived.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
         self.assertFalse(_testcapi.MethodDescriptorNopGet.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
 
-        # Heap type should not inherit Py_TPFLAGS_METHOD_DESCRIPTOR
+        # Mutable heap types should not inherit Py_TPFLAGS_METHOD_DESCRIPTOR
         class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
             pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_METHOD_DESCRIPTOR)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_vectorcall_flag(self):
         self.assertTrue(_testcapi.MethodDescriptorBase.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
         self.assertTrue(_testcapi.MethodDescriptorDerived.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
         self.assertFalse(_testcapi.MethodDescriptorNopGet.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
         self.assertTrue(_testcapi.MethodDescriptor2.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
 
-        # Heap type should not inherit Py_TPFLAGS_HAVE_VECTORCALL
+        # Mutable heap types should inherit Py_TPFLAGS_HAVE_VECTORCALL,
+        # but should lose it when __call__ is overridden
         class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
             pass
+        self.assertTrue(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
+        MethodDescriptorHeap.__call__ = print
+        self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
+
+        # Mutable heap types should not inherit Py_TPFLAGS_HAVE_VECTORCALL if
+        # they define __call__ directly
+        class MethodDescriptorHeap(_testcapi.MethodDescriptorBase):
+            def __call__(self):
+                pass
         self.assertFalse(MethodDescriptorHeap.__flags__ & Py_TPFLAGS_HAVE_VECTORCALL)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_vectorcall_override(self):
         # Check that tp_call can correctly override vectorcall.
         # MethodDescriptorNopGet implements tp_call but it inherits from
@@ -538,14 +674,64 @@ def test_vectorcall_override(self):
         f = _testcapi.MethodDescriptorNopGet()
         self.assertIs(f(*args), args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_vectorcall_override_on_mutable_class(self):
+        """Setting __call__ should disable vectorcall"""
+        TestType = _testcapi.make_vectorcall_class()
+        instance = TestType()
+        self.assertEqual(instance(), "tp_call")
+        instance.set_vectorcall(TestType)
+        self.assertEqual(instance(), "vectorcall")  # assume vectorcall is used
+        TestType.__call__ = lambda self: "custom"
+        self.assertEqual(instance(), "custom")
+
+    def test_vectorcall_override_with_subclass(self):
+        """Setting __call__ on a superclass should disable vectorcall"""
+        SuperType = _testcapi.make_vectorcall_class()
+        class DerivedType(SuperType):
+            pass
+
+        instance = DerivedType()
+
+        # Derived types with its own vectorcall should be unaffected
+        UnaffectedType1 = _testcapi.make_vectorcall_class(DerivedType)
+        UnaffectedType2 = _testcapi.make_vectorcall_class(SuperType)
+
+        # Aside: Quickly check that the C helper actually made derived types
+        self.assertTrue(issubclass(UnaffectedType1, DerivedType))
+        self.assertTrue(issubclass(UnaffectedType2, SuperType))
+
+        # Initial state: tp_call
+        self.assertEqual(instance(), "tp_call")
+        self.assertEqual(_testcapi.has_vectorcall_flag(SuperType), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(DerivedType), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType1), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType2), True)
+
+        # Setting the vectorcall function
+        instance.set_vectorcall(SuperType)
+
+        self.assertEqual(instance(), "vectorcall")
+        self.assertEqual(_testcapi.has_vectorcall_flag(SuperType), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(DerivedType), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType1), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType2), True)
+
+        # Setting __call__ should remove vectorcall from all subclasses
+        SuperType.__call__ = lambda self: "custom"
+
+        self.assertEqual(instance(), "custom")
+        self.assertEqual(_testcapi.has_vectorcall_flag(SuperType), False)
+        self.assertEqual(_testcapi.has_vectorcall_flag(DerivedType), False)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType1), True)
+        self.assertEqual(_testcapi.has_vectorcall_flag(UnaffectedType2), True)
+
+
     def test_vectorcall(self):
         # Test a bunch of different ways to call objects:
         # 1. vectorcall using PyVectorcall_Call()
         #   (only for objects that support vectorcall directly)
         # 2. normal call
-        # 3. vectorcall using _PyObject_Vectorcall()
+        # 3. vectorcall using PyObject_Vectorcall()
         # 4. call as bound method
         # 5. call using functools.partial
 
@@ -616,6 +802,300 @@ def __call__(self, *args):
                 self.assertEqual(expected, meth(*args1, **kwargs))
                 self.assertEqual(expected, wrapped(*args, **kwargs))
 
+    def test_setvectorcall(self):
+        from _testcapi import function_setvectorcall
+        def f(num): return num + 1
+        assert_equal = self.assertEqual
+        num = 10
+        assert_equal(11, f(num))
+        function_setvectorcall(f)
+        # make sure specializer is triggered by running > 50 times
+        for _ in range(10 * ADAPTIVE_WARMUP_DELAY):
+            assert_equal("overridden", f(num))
+
+    def test_setvectorcall_load_attr_specialization_skip(self):
+        from _testcapi import function_setvectorcall
+
+        class X:
+            def __getattribute__(self, attr):
+                return attr
+
+        assert_equal = self.assertEqual
+        x = X()
+        assert_equal("a", x.a)
+        function_setvectorcall(X.__getattribute__)
+        # make sure specialization doesn't trigger
+        # when vectorcall is overridden
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            assert_equal("overridden", x.a)
+
+    def test_setvectorcall_load_attr_specialization_deopt(self):
+        from _testcapi import function_setvectorcall
+
+        class X:
+            def __getattribute__(self, attr):
+                return attr
+
+        def get_a(x):
+            return x.a
+
+        assert_equal = self.assertEqual
+        x = X()
+        # trigger LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN specialization
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            assert_equal("a", get_a(x))
+        function_setvectorcall(X.__getattribute__)
+        # make sure specialized LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN
+        # gets deopted due to overridden vectorcall
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            assert_equal("overridden", get_a(x))
+
+    @requires_limited_api
+    def test_vectorcall_limited_incoming(self):
+        from _testcapi import pyobject_vectorcall
+        obj = _testlimitedcapi.LimitedVectorCallClass()
+        self.assertEqual(pyobject_vectorcall(obj, (), ()), "vectorcall called")
+
+    @requires_limited_api
+    def test_vectorcall_limited_outgoing(self):
+        from _testlimitedcapi import call_vectorcall
+
+        args_captured = []
+        kwargs_captured = []
+
+        def f(*args, **kwargs):
+            args_captured.append(args)
+            kwargs_captured.append(kwargs)
+            return "success"
+
+        self.assertEqual(call_vectorcall(f), "success")
+        self.assertEqual(args_captured, [("foo",)])
+        self.assertEqual(kwargs_captured, [{"baz": "bar"}])
+
+    @requires_limited_api
+    def test_vectorcall_limited_outgoing_method(self):
+        from _testlimitedcapi import call_vectorcall_method
+
+        args_captured = []
+        kwargs_captured = []
+
+        class TestInstance:
+            def f(self, *args, **kwargs):
+                args_captured.append(args)
+                kwargs_captured.append(kwargs)
+                return "success"
+
+        self.assertEqual(call_vectorcall_method(TestInstance()), "success")
+        self.assertEqual(args_captured, [("foo",)])
+        self.assertEqual(kwargs_captured, [{"baz": "bar"}])
+
+class A:
+    def method_two_args(self, x, y):
+        pass
+
+    @staticmethod
+    def static_no_args():
+        pass
+
+    @staticmethod
+    def positional_only(arg, /):
+        pass
+
+@cpython_only
+class TestErrorMessagesUseQualifiedName(unittest.TestCase):
+
+    @contextlib.contextmanager
+    def check_raises_type_error(self, message):
+        with self.assertRaises(TypeError) as cm:
+            yield
+        self.assertEqual(str(cm.exception), message)
+
+    def test_missing_arguments(self):
+        msg = "A.method_two_args() missing 1 required positional argument: 'y'"
+        with self.check_raises_type_error(msg):
+            A().method_two_args("x")
+
+    def test_too_many_positional(self):
+        msg = "A.static_no_args() takes 0 positional arguments but 1 was given"
+        with self.check_raises_type_error(msg):
+            A.static_no_args("oops it's an arg")
+
+    def test_positional_only_passed_as_keyword(self):
+        msg = "A.positional_only() got some positional-only arguments passed as keyword arguments: 'arg'"
+        with self.check_raises_type_error(msg):
+            A.positional_only(arg="x")
+
+    def test_unexpected_keyword(self):
+        msg = "A.method_two_args() got an unexpected keyword argument 'bad'"
+        with self.check_raises_type_error(msg):
+            A().method_two_args(bad="x")
+
+    def test_multiple_values(self):
+        msg = "A.method_two_args() got multiple values for argument 'x'"
+        with self.check_raises_type_error(msg):
+            A().method_two_args("x", "y", x="oops")
+
+@cpython_only
+class TestErrorMessagesSuggestions(unittest.TestCase):
+    @contextlib.contextmanager
+    def check_suggestion_includes(self, message):
+        with self.assertRaises(TypeError) as cm:
+            yield
+        self.assertIn(f"Did you mean '{message}'?", str(cm.exception))
+
+    @contextlib.contextmanager
+    def check_suggestion_not_present(self):
+        with self.assertRaises(TypeError) as cm:
+            yield
+        self.assertNotIn("Did you mean", str(cm.exception))
+
+    def test_unexpected_keyword_suggestion_valid_positions(self):
+        def foo(blech=None, /, aaa=None, *args, late1=None):
+            pass
+
+        cases = [
+            ("blach", None),
+            ("aa", "aaa"),
+            ("orgs", None),
+            ("late11", "late1"),
+        ]
+
+        for keyword, suggestion in cases:
+            with self.subTest(keyword):
+                ctx = self.check_suggestion_includes(suggestion) if suggestion else self.check_suggestion_not_present()
+                with ctx:
+                    foo(**{keyword:None})
+
+    def test_unexpected_keyword_suggestion_kinds(self):
+
+        def substitution(noise=None, more_noise=None, a = None, blech = None):
+            pass
+
+        def elimination(noise = None, more_noise = None, a = None, blch = None):
+            pass
+
+        def addition(noise = None, more_noise = None, a = None, bluchin = None):
+            pass
+
+        def substitution_over_elimination(blach = None, bluc = None):
+            pass
+
+        def substitution_over_addition(blach = None, bluchi = None):
+            pass
+
+        def elimination_over_addition(bluc = None, blucha = None):
+            pass
+
+        def case_change_over_substitution(BLuch=None, Luch = None, fluch = None):
+            pass
+
+        for func, suggestion in [
+            (addition, "bluchin"),
+            (substitution, "blech"),
+            (elimination, "blch"),
+            (addition, "bluchin"),
+            (substitution_over_elimination, "blach"),
+            (substitution_over_addition, "blach"),
+            (elimination_over_addition, "bluc"),
+            (case_change_over_substitution, "BLuch"),
+        ]:
+            with self.subTest(suggestion):
+                with self.check_suggestion_includes(suggestion):
+                    func(bluch=None)
+
+    def test_unexpected_keyword_suggestion_via_getargs(self):
+        with self.check_suggestion_includes("maxsplit"):
+            "foo".split(maxsplt=1)
+
+        self.assertRaisesRegex(
+            TypeError, r"split\(\) got an unexpected keyword argument 'blech'$",
+            "foo".split, blech=1
+        )
+        with self.check_suggestion_not_present():
+            "foo".split(blech=1)
+        with self.check_suggestion_not_present():
+            "foo".split(more_noise=1, maxsplt=1)
+
+        # Also test the vgetargskeywords path
+        with self.check_suggestion_includes("name"):
+            ImportError(namez="oops")
+
+        self.assertRaisesRegex(
+            TypeError, r"ImportError\(\) got an unexpected keyword argument 'blech'$",
+            ImportError, blech=1
+        )
+        with self.check_suggestion_not_present():
+            ImportError(blech=1)
+        with self.check_suggestion_not_present():
+            ImportError(blech=1, namez="oops")
+
+@cpython_only
+class TestRecursion(unittest.TestCase):
+
+    @skip_on_s390x
+    @unittest.skipIf(is_wasi and Py_DEBUG, "requires deep stack")
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_super_deep(self):
+
+        def recurse(n):
+            if n:
+                recurse(n-1)
+
+        def py_recurse(n, m):
+            if n:
+                py_recurse(n-1, m)
+            else:
+                c_py_recurse(m-1)
+
+        def c_recurse(n):
+            if n:
+                _testcapi.pyobject_vectorcall(c_recurse, (n-1,), ())
+
+        def c_py_recurse(m):
+            if m:
+                _testcapi.pyobject_vectorcall(py_recurse, (1000, m), ())
+
+        with set_recursion_limit(100_000):
+            recurse(90_000)
+            with self.assertRaises(RecursionError):
+                recurse(101_000)
+            c_recurse(100)
+            with self.assertRaises(RecursionError):
+                c_recurse(90_000)
+            c_py_recurse(90)
+            with self.assertRaises(RecursionError):
+                c_py_recurse(100_000)
+
+
+class TestFunctionWithManyArgs(unittest.TestCase):
+    def test_function_with_many_args(self):
+        for N in (10, 500, 1000):
+            with self.subTest(N=N):
+                args = ",".join([f"a{i}" for i in range(N)])
+                src = f"def f({args}) : return a{N//2}"
+                l = {}
+                exec(src, {}, l)
+                self.assertEqual(l['f'](*range(N)), N//2)
+
+
+@unittest.skipIf(_testcapi is None, 'need _testcapi')
+class TestCAPI(unittest.TestCase):
+    def test_cfunction_call(self):
+        def func(*args, **kwargs):
+            return (args, kwargs)
+
+        # PyCFunction_Call() was removed in Python 3.13 API, but was kept in
+        # the stable ABI.
+        def PyCFunction_Call(func, *args, **kwargs):
+            if kwargs:
+                return _testcapi.pycfunction_call(func, args, kwargs)
+            else:
+                return _testcapi.pycfunction_call(func, args)
+
+        self.assertEqual(PyCFunction_Call(func), ((), {}))
+        self.assertEqual(PyCFunction_Call(func, 1, 2, 3), ((1, 2, 3), {}))
+        self.assertEqual(PyCFunction_Call(func, "arg", num=5), (("arg",), {'num': 5}))
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index 29215f0600..a70a807897 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -611,7 +611,6 @@ def assertNotOrderable(self, a, b):
         with self.assertRaises(TypeError):
             a >= b
 
-    @unittest.skip("TODO: RUSTPYTHON; unstable result")
     def testHashComparisonOfMethods(self):
         # Test comparison and hash of methods
         class A:
diff --git a/Lib/test/test_cmath.py b/Lib/test/test_cmath.py
index 51dd2ecf5f..a96a5780b3 100644
--- a/Lib/test/test_cmath.py
+++ b/Lib/test/test_cmath.py
@@ -1,4 +1,5 @@
 from test.support import requires_IEEE_754, cpython_only, import_helper
+from test.support.testcase import ComplexesAreIdenticalMixin
 from test.test_math import parse_testfile, test_file
 import test.test_math as test_math
 import unittest
@@ -49,7 +50,7 @@
         (INF, NAN)
         ]]
 
-class CMathTests(unittest.TestCase):
+class CMathTests(ComplexesAreIdenticalMixin, unittest.TestCase):
     # list of all functions in cmath
     test_functions = [getattr(cmath, fname) for fname in [
             'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh',
@@ -65,39 +66,6 @@ def setUp(self):
     def tearDown(self):
         self.test_values.close()
 
-    def assertFloatIdentical(self, x, y):
-        """Fail unless floats x and y are identical, in the sense that:
-        (1) both x and y are nans, or
-        (2) both x and y are infinities, with the same sign, or
-        (3) both x and y are zeros, with the same sign, or
-        (4) x and y are both finite and nonzero, and x == y
-
-        """
-        msg = 'floats {!r} and {!r} are not identical'
-
-        if math.isnan(x) or math.isnan(y):
-            if math.isnan(x) and math.isnan(y):
-                return
-        elif x == y:
-            if x != 0.0:
-                return
-            # both zero; check that signs match
-            elif math.copysign(1.0, x) == math.copysign(1.0, y):
-                return
-            else:
-                msg += ': zeros have different signs'
-        self.fail(msg.format(x, y))
-
-    def assertComplexIdentical(self, x, y):
-        """Fail unless complex numbers x and y have equal values and signs.
-
-        In particular, if x and y both have real (or imaginary) part
-        zero, but the zeros have different signs, this test will fail.
-
-        """
-        self.assertFloatIdentical(x.real, y.real)
-        self.assertFloatIdentical(x.imag, y.imag)
-
     def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323,
                            msg=None):
         """Fail if the two floating-point numbers are not almost equal.
@@ -299,12 +267,6 @@ def test_cmath_matches_math(self):
             for v in values:
                 z = complex_fn(v)
                 self.rAssertAlmostEqual(float_fn(v), z.real)
-                # TODO: RUSTPYTHON
-                # This line currently fails for acos and asin.
-                # cmath.asin/acos(0.2) should produce a real number,
-                # but imaginary part is 1.1102230246251565e-16 for both.
-                if fn in {"asin", "acos"}:
-                    continue
                 self.assertEqual(0., z.imag)
 
         # test two-argument version of log with various bases
@@ -314,8 +276,6 @@ def test_cmath_matches_math(self):
                 self.rAssertAlmostEqual(math.log(v, base), z.real)
                 self.assertEqual(0., z.imag)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_IEEE_754
     def test_specific_values(self):
         # Some tests need to be skipped on ancient OS X versions.
@@ -563,25 +523,21 @@ def test_isinf(self):
     @requires_IEEE_754
     def testTanhSign(self):
         for z in complex_zeros:
-            self.assertComplexIdentical(cmath.tanh(z), z)
+            self.assertComplexesAreIdentical(cmath.tanh(z), z)
 
     # The algorithm used for atan and atanh makes use of the system
     # log1p function; If that system function doesn't respect the sign
     # of zero, then atan and atanh will also have difficulties with
     # the sign of complex zeros.
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_IEEE_754
     def testAtanSign(self):
         for z in complex_zeros:
-            self.assertComplexIdentical(cmath.atan(z), z)
+            self.assertComplexesAreIdentical(cmath.atan(z), z)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_IEEE_754
     def testAtanhSign(self):
         for z in complex_zeros:
-            self.assertComplexIdentical(cmath.atanh(z), z)
+            self.assertComplexesAreIdentical(cmath.atanh(z), z)
 
 
 class IsCloseTests(test_math.IsCloseTests):
@@ -624,8 +580,6 @@ def test_complex_near_zero(self):
         self.assertIsClose(0.001-0.001j, 0.001+0.001j, abs_tol=2e-03)
         self.assertIsNotClose(0.001-0.001j, 0.001+0.001j, abs_tol=1e-03)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_complex_special(self):
         self.assertIsNotClose(INF, INF*1j)
         self.assertIsNotClose(INF*1j, INF)
diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py
index a7e4f6dd27..eb455ebaed 100644
--- a/Lib/test/test_cmd_line.py
+++ b/Lib/test/test_cmd_line.py
@@ -713,8 +713,6 @@ def run_xdev(self, *args, check_exitcode=True, xdev=True):
             self.assertEqual(proc.returncode, 0, proc)
         return proc.stdout.rstrip()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_xdev(self):
         # sys.flags.dev_mode
         code = "import sys; print(sys.flags.dev_mode)"
diff --git a/Lib/test/test_cmd_line_script.py b/Lib/test/test_cmd_line_script.py
index 833dc6b15d..d2b3a7d3e4 100644
--- a/Lib/test/test_cmd_line_script.py
+++ b/Lib/test/test_cmd_line_script.py
@@ -225,8 +225,6 @@ def test_repl_stderr_flush(self):
     def test_repl_stderr_flush_separate_stderr(self):
         self.check_repl_stderr_flush(True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_script(self):
         with os_helper.temp_dir() as script_dir:
             script_name = _make_test_script(script_dir, 'script')
@@ -249,8 +247,6 @@ def test_script_abspath(self):
                                script_dir, None,
                                importlib.machinery.SourceFileLoader)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_script_compiled(self):
         with os_helper.temp_dir() as script_dir:
             script_name = _make_test_script(script_dir, 'script')
@@ -413,8 +409,6 @@ def test_issue8202(self):
                                    script_name, script_name, script_dir, 'test_pkg',
                                    importlib.machinery.SourceFileLoader)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_issue8202_dash_c_file_ignored(self):
         # Make sure a "-c" file in the current directory
         # does not alter the value of sys.path[0]
@@ -617,8 +611,6 @@ def test_issue20500_exit_with_exception_value(self):
             text = stderr.decode('ascii')
             self.assertEqual(text.rstrip(), "some text")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_syntaxerror_unindented_caret_position(self):
         script = "1 + 1 = 2\n"
         with os_helper.temp_dir() as script_dir:
@@ -628,8 +620,7 @@ def test_syntaxerror_unindented_caret_position(self):
             # Confirm that the caret is located under the '=' sign
             self.assertIn("\n    ^^^^^\n", text)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_syntaxerror_indented_caret_position(self):
         script = textwrap.dedent("""\
             if True:
@@ -715,8 +706,6 @@ def test_syntaxerror_null_bytes_in_multiline_string(self):
                     ]
                 )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_consistent_sys_path_for_direct_execution(self):
         # This test case ensures that the following all give the same
         # sys.path configuration:
diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py
index 1aceff4efc..f2ef233a59 100644
--- a/Lib/test/test_code.py
+++ b/Lib/test/test_code.py
@@ -222,8 +222,6 @@ class List(list):
         obj = List([1, 2, 3])
         self.assertEqual(obj[0], "Foreign getitem: 1")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_constructor(self):
         def func(): pass
         co = func.__code__
@@ -249,16 +247,12 @@ def func(): pass
                         co.co_freevars,
                         co.co_cellvars)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_qualname(self):
         self.assertEqual(
             CodeTest.test_qualname.__code__.co_qualname,
             CodeTest.test_qualname.__qualname__
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_replace(self):
         def func():
             x = 1
@@ -299,8 +293,6 @@ def func2():
         self.assertEqual(new_code.co_varnames, code2.co_varnames)
         self.assertEqual(new_code.co_nlocals, code2.co_nlocals)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nlocals_mismatch(self):
         def func():
             x = 1
@@ -349,8 +341,6 @@ def func(arg):
         newcode = code.replace(co_name="func")  # Should not raise SystemError
         self.assertEqual(code, newcode)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_empty_linetable(self):
         def func():
             pass
@@ -435,8 +425,6 @@ def test_co_positions_artificial_instructions(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_endline_and_columntable_none_when_no_debug_ranges(self):
         # Make sure that if `-X no_debug_ranges` is used, there is
         # minimal debug info
@@ -452,8 +440,6 @@ def f():
             """)
         assert_python_ok('-X', 'no_debug_ranges', '-c', code)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_endline_and_columntable_none_when_no_debug_ranges_env(self):
         # Same as above but using the environment variable opt out.
         code = textwrap.dedent("""
@@ -470,8 +456,6 @@ def f():
 
     # co_positions behavior when info is missing.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # @requires_debug_ranges()
     def test_co_positions_empty_linetable(self):
         def func():
@@ -482,8 +466,6 @@ def func():
             self.assertIsNone(line)
             self.assertEqual(end_line, new_code.co_firstlineno + 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_code_equality(self):
         def f():
             try:
@@ -524,8 +506,6 @@ def test_code_hash_uses_order(self):
         self.assertNotEqual(c, swapped)
         self.assertNotEqual(hash(c), hash(swapped))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_code_hash_uses_bytecode(self):
         c = (lambda x, y: x + y).__code__
         d = (lambda x, y: x * y).__code__
@@ -737,8 +717,6 @@ def check_positions(self, func):
             self.assertEqual(l1, l2)
         self.assertEqual(len(pos1), len(pos2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positions(self):
         self.check_positions(parse_location_table)
         self.check_positions(misshappen)
@@ -753,8 +731,6 @@ def check_lines(self, func):
             self.assertEqual(l1, l2)
         self.assertEqual(len(lines1), len(lines2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_lines(self):
         self.check_lines(parse_location_table)
         self.check_lines(misshappen)
diff --git a/Lib/test/test_code_module.py b/Lib/test/test_code_module.py
index 5ac17ef16e..4d5463e6db 100644
--- a/Lib/test/test_code_module.py
+++ b/Lib/test/test_code_module.py
@@ -1,20 +1,17 @@
 "Test InteractiveConsole and InteractiveInterpreter from code module"
 import sys
+import traceback
 import unittest
 from textwrap import dedent
 from contextlib import ExitStack
 from unittest import mock
+from test.support import force_not_colorized_test_class
 from test.support import import_helper
 
-
 code = import_helper.import_module('code')
 
 
-class TestInteractiveConsole(unittest.TestCase):
-
-    def setUp(self):
-        self.console = code.InteractiveConsole()
-        self.mock_sys()
+class MockSys:
 
     def mock_sys(self):
         "Mock system environment for InteractiveConsole"
@@ -32,6 +29,15 @@ def mock_sys(self):
         del self.sysmod.ps1
         del self.sysmod.ps2
 
+
+@force_not_colorized_test_class
+class TestInteractiveConsole(unittest.TestCase, MockSys):
+    maxDiff = None
+
+    def setUp(self):
+        self.console = code.InteractiveConsole()
+        self.mock_sys()
+
     def test_ps1(self):
         self.infunc.side_effect = EOFError('Finished')
         self.console.interact()
@@ -44,9 +50,9 @@ def test_ps2(self):
         self.infunc.side_effect = EOFError('Finished')
         self.console.interact()
         self.assertEqual(self.sysmod.ps2, '... ')
-        self.sysmod.ps1 = 'custom2> '
+        self.sysmod.ps2 = 'custom2> '
         self.console.interact()
-        self.assertEqual(self.sysmod.ps1, 'custom2> ')
+        self.assertEqual(self.sysmod.ps2, 'custom2> ')
 
     def test_console_stderr(self):
         self.infunc.side_effect = ["'antioch'", "", EOFError('Finished')]
@@ -57,22 +63,167 @@ 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 = ["undefined", EOFError('Finished')]
+        self.infunc.side_effect = ["def f():",
+                                   "    x = ?",
+                                   "",
+                                    EOFError('Finished')]
         self.console.interact()
-        for call in self.stderr.method_calls:
-            if 'NameError' in ''.join(call[1]):
-                break
-        else:
-            raise AssertionError("No syntax error from console")
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[:output.index('\nnow exiting')]
+        self.assertEqual(output.splitlines()[1:], [
+            '  File "<console>", line 2',
+            '    x = ?',
+            '        ^',
+            'SyntaxError: invalid syntax'])
+        self.assertIs(self.sysmod.last_type, SyntaxError)
+        self.assertIs(type(self.sysmod.last_value), SyntaxError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[15 chars], line 1', '    1', 'IndentationError: unexpected indentation'] != ['  F[15 chars], line 1', '    1', 'IndentationError: unexpected indent']
+    @unittest.expectedFailure
+    def test_indentation_error(self):
+        self.infunc.side_effect = ["  1", EOFError('Finished')]
+        self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[:output.index('\nnow exiting')]
+        self.assertEqual(output.splitlines()[1:], [
+            '  File "<console>", line 1',
+            '    1',
+            'IndentationError: unexpected indent'])
+        self.assertIs(self.sysmod.last_type, IndentationError)
+        self.assertIs(type(self.sysmod.last_value), IndentationError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: False is not true : UnicodeDecodeError: invalid utf-8 sequence of 1 bytes from index 1
+    @unittest.expectedFailure
+    def test_unicode_error(self):
+        self.infunc.side_effect = ["'\ud800'", EOFError('Finished')]
+        self.console.interact()
+        output = ''.join(''.join(call[1]) for call in self.stderr.method_calls)
+        output = output[output.index('(InteractiveConsole)'):]
+        output = output[output.index('\n') + 1:]
+        self.assertTrue(output.startswith('UnicodeEncodeError: '), output)
+        self.assertIs(self.sysmod.last_type, UnicodeEncodeError)
+        self.assertIs(type(self.sysmod.last_value), UnicodeEncodeError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
     def test_sysexcepthook(self):
-        self.infunc.side_effect = ["raise ValueError('')",
+        self.infunc.side_effect = ["def f():",
+                                   "    raise ValueError('BOOM!')",
+                                   "",
+                                   "f()",
+                                    EOFError('Finished')]
+        hook = mock.Mock()
+        self.sysmod.excepthook = hook
+        self.console.interact()
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, ValueError)
+        self.assertIs(type(self.sysmod.last_value), ValueError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            'Traceback (most recent call last):\n',
+            '  File "<console>", line 1, in <module>\n',
+            '  File "<console>", line 2, in f\n',
+            'ValueError: BOOM!\n'])
+
+    # TODO: RUSTPYTHON
+    # 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 = ?",
+                                   "",
                                     EOFError('Finished')]
         hook = mock.Mock()
         self.sysmod.excepthook = hook
         self.console.interact()
-        self.assertTrue(hook.called)
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, SyntaxError)
+        self.assertIs(type(self.sysmod.last_value), SyntaxError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            '  File "<console>", line 2\n',
+            '    x = ?\n',
+            '        ^\n',
+            'SyntaxError: invalid syntax\n'])
+
+    # TODO: RUSTPYTHON
+    # AssertionError: Lists differ: ['  F[21 chars] 1\n', '    1\n', 'IndentationError: unexpected indentation\n'] != ['  F[21 chars] 1\n', '    1\n', 'IndentationError: unexpected indent\n']
+    @unittest.expectedFailure
+    def test_sysexcepthook_indentation_error(self):
+        self.infunc.side_effect = ["  1", EOFError('Finished')]
+        hook = mock.Mock()
+        self.sysmod.excepthook = hook
+        self.console.interact()
+        hook.assert_called()
+        hook.assert_called_with(self.sysmod.last_type,
+                                self.sysmod.last_value,
+                                self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_type, IndentationError)
+        self.assertIs(type(self.sysmod.last_value), IndentationError)
+        self.assertIsNone(self.sysmod.last_traceback)
+        self.assertIsNone(self.sysmod.last_value.__traceback__)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+        self.assertEqual(traceback.format_exception(self.sysmod.last_exc), [
+            '  File "<console>", line 1\n',
+            '    1\n',
+            'IndentationError: unexpected indent\n'])
+
+    def test_sysexcepthook_crashing_doesnt_close_repl(self):
+        self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
+        self.sysmod.excepthook = 1
+        self.console.interact()
+        self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
+        error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
+        self.assertIn("Error in sys.excepthook:", error)
+        self.assertEqual(error.count("'int' object is not callable"), 1)
+        self.assertIn("Original exception was:", error)
+        self.assertIn("division by zero", error)
+
+    def test_sysexcepthook_raising_BaseException(self):
+        self.infunc.side_effect = ["1/0", "a = 123", "print(a)", EOFError('Finished')]
+        s = "not so fast"
+        def raise_base(*args, **kwargs):
+            raise BaseException(s)
+        self.sysmod.excepthook = raise_base
+        self.console.interact()
+        self.assertEqual(['write', ('123', ), {}], self.stdout.method_calls[0])
+        error = "".join(call.args[0] for call in self.stderr.method_calls if call[0] == 'write')
+        self.assertIn("Error in sys.excepthook:", error)
+        self.assertEqual(error.count("not so fast"), 1)
+        self.assertIn("Original exception was:", error)
+        self.assertIn("division by zero", error)
+
+    def test_sysexcepthook_raising_SystemExit_gets_through(self):
+        self.infunc.side_effect = ["1/0"]
+        def raise_base(*args, **kwargs):
+            raise SystemExit
+        self.sysmod.excepthook = raise_base
+        with self.assertRaises(SystemExit):
+            self.console.interact()
 
     def test_banner(self):
         # with banner
@@ -115,8 +266,8 @@ def test_exit_msg(self):
         expected = message + '\n'
         self.assertEqual(err_msg, ['write', (expected,), {}])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cause_tb(self):
         self.infunc.side_effect = ["raise ValueError('') from AttributeError",
                                     EOFError('Finished')]
@@ -132,9 +283,12 @@ def test_cause_tb(self):
         ValueError
         """)
         self.assertIn(expected, output)
+        self.assertIs(self.sysmod.last_type, ValueError)
+        self.assertIs(type(self.sysmod.last_value), ValueError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIsNotNone(self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_context_tb(self):
         self.infunc.side_effect = ["try: ham\nexcept: eggs\n",
                                     EOFError('Finished')]
@@ -152,6 +306,28 @@ def test_context_tb(self):
         NameError: name 'eggs' is not defined
         """)
         self.assertIn(expected, output)
+        self.assertIs(self.sysmod.last_type, NameError)
+        self.assertIs(type(self.sysmod.last_value), NameError)
+        self.assertIs(self.sysmod.last_traceback, self.sysmod.last_value.__traceback__)
+        self.assertIsNotNone(self.sysmod.last_traceback)
+        self.assertIs(self.sysmod.last_exc, self.sysmod.last_value)
+
+
+class TestInteractiveConsoleLocalExit(unittest.TestCase, MockSys):
+
+    def setUp(self):
+        self.console = code.InteractiveConsole(local_exit=True)
+        self.mock_sys()
+
+    @unittest.skipIf(sys.flags.no_site, "exit() isn't defined unless there's a site module")
+    def test_exit(self):
+        # default exit message
+        self.infunc.side_effect = ["exit()"]
+        self.console.interact(banner='')
+        self.assertEqual(len(self.stderr.method_calls), 2)
+        err_msg = self.stderr.method_calls[1]
+        expected = 'now exiting InteractiveConsole...\n'
+        self.assertEqual(err_msg, ['write', (expected,), {}])
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py
index bd1dbcd626..9ca02cea35 100644
--- a/Lib/test/test_codeccallbacks.py
+++ b/Lib/test/test_codeccallbacks.py
@@ -909,8 +909,6 @@ def handle(exc):
                 self.assertEqual(exc.object, input)
                 self.assertEqual(exc.reason, "surrogates not allowed")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_badregistercall(self):
         # enhance coverage of:
         # Modules/_codecsmodule.c::register_error()
diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py
index a12e5893dc..736022599e 100644
--- a/Lib/test/test_codecs.py
+++ b/Lib/test/test_codecs.py
@@ -2,7 +2,6 @@
 import contextlib
 import copy
 import io
-import locale
 import pickle
 import sys
 import unittest
@@ -13,9 +12,9 @@
 from test.support import os_helper
 
 try:
-    import _testcapi
+    import _testlimitedcapi
 except ImportError:
-    _testcapi = None
+    _testlimitedcapi = None
 try:
     import _testinternalcapi
 except ImportError:
@@ -389,8 +388,7 @@ def test_bug1098990_b(self):
 
     ill_formed_sequence_replace = "\ufffd"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         self.assertRaises(UnicodeEncodeError, "\ud800".encode, self.encoding)
         self.assertEqual("[\uDC80]".encode(self.encoding, "backslashreplace"),
@@ -466,14 +464,7 @@ 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')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_only_one_bom(self):
         _,_,reader,writer = codecs.lookup(self.encoding)
         # encode some stream
@@ -489,19 +480,17 @@ def test_only_one_bom(self):
         f = reader(s)
         self.assertEqual(f.read(), "spamspam")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_badbom(self):
         s = io.BytesIO(4*b"\xff")
         f = codecs.getreader(self.encoding)(s)
-        self.assertRaises(UnicodeError, f.read)
+        self.assertRaises(UnicodeDecodeError, f.read)
 
         s = io.BytesIO(8*b"\xff")
         f = codecs.getreader(self.encoding)(s)
-        self.assertRaises(UnicodeError, f.read)
+        self.assertRaises(UnicodeDecodeError, f.read)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -533,30 +522,26 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_decode,
                           b"\xff", "strict", True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -567,48 +552,40 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_decode(encoded_be)[0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_a(self):
-        super().test_bug1098990_a()
+        return super().test_bug1098990_a()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_b(self):
-        super().test_bug1098990_b()
+        return super().test_bug1098990_b()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1175396(self):
-        super().test_bug1175396()
+        return super().test_bug1175396()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mixed_readline_and_read(self):
-        super().test_mixed_readline_and_read()
+        return super().test_mixed_readline_and_read()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_readline(self):
+        return super().test_readline()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readlinequeue(self):
-        super().test_readlinequeue()
+        return super().test_readlinequeue()
 
 
 class UTF32LETest(ReadTest, unittest.TestCase):
     encoding = "utf-32-le"
     ill_formed_sequence = b"\x80\xdc\x00\x00"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -636,19 +613,16 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple(self):
         self.assertEqual("\U00010203".encode(self.encoding), b"\x03\x02\x01\x00")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_le_decode,
                           b"\xff", "strict", True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -656,48 +630,40 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_le_decode(encoded)[0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_a(self):
-        super().test_bug1098990_a()
+        return super().test_bug1098990_a()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_b(self):
-        super().test_bug1098990_b()
+        return super().test_bug1098990_b()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1175396(self):
-        super().test_bug1175396()
+        return super().test_bug1175396()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mixed_readline_and_read(self):
-        super().test_mixed_readline_and_read()
+        return super().test_mixed_readline_and_read()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_readline(self):
+        return super().test_readline()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readlinequeue(self):
-        super().test_readlinequeue()
+        return super().test_readlinequeue()
 
 
 class UTF32BETest(ReadTest, unittest.TestCase):
     encoding = "utf-32-be"
     ill_formed_sequence = b"\x00\x00\xdc\x80"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -725,19 +691,16 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple(self):
         self.assertEqual("\U00010203".encode(self.encoding), b"\x00\x01\x02\x03")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         self.assertRaises(UnicodeDecodeError, codecs.utf_32_be_decode,
                           b"\xff", "strict", True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue8941(self):
         # Issue #8941: insufficient result allocation when decoding into
         # surrogate pairs on UCS-2 builds.
@@ -745,35 +708,33 @@ def test_issue8941(self):
         self.assertEqual('\U00010000' * 1024,
                          codecs.utf_32_be_decode(encoded)[0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_a(self):
-        super().test_bug1098990_a()
+        return super().test_bug1098990_a()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1098990_b(self):
-        super().test_bug1098990_b()
+        return super().test_bug1098990_b()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1175396(self):
-        super().test_bug1175396()
+        return super().test_bug1175396()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mixed_readline_and_read(self):
-        super().test_mixed_readline_and_read()
+        return super().test_mixed_readline_and_read()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_readline(self):
+        return super().test_readline()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_readlinequeue(self):
-        super().test_readlinequeue()
+        return super().test_readlinequeue()
 
 
 class UTF16Test(ReadTest, unittest.TestCase):
@@ -804,14 +765,13 @@ def test_only_one_bom(self):
     def test_badbom(self):
         s = io.BytesIO(b"\xff\xff")
         f = codecs.getreader(self.encoding)(s)
-        self.assertRaises(UnicodeError, f.read)
+        self.assertRaises(UnicodeDecodeError, f.read)
 
         s = io.BytesIO(b"\xff\xff\xff\xff")
         f = codecs.getreader(self.encoding)(s)
-        self.assertRaises(UnicodeError, f.read)
+        self.assertRaises(UnicodeDecodeError, f.read)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -833,8 +793,7 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_handlers(self):
         self.assertEqual(('\ufffd', 1),
                          codecs.utf_16_decode(b'\x01', 'replace', True))
@@ -850,9 +809,7 @@ def test_decoder_state(self):
                                          "spamspam", self.spamle)
         self.check_state_handling_decode(self.encoding,
                                          "spamspam", self.spambe)
-        
-    # TODO: RUSTPYTHON - ValueError: invalid mode 'Ub'
-    @unittest.expectedFailure
+
     def test_bug691291(self):
         # If encoding is not None, then
         # files are always opened in binary mode, even if no binary mode was
@@ -864,22 +821,32 @@ def test_bug691291(self):
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         with open(os_helper.TESTFN, 'wb') as fp:
             fp.write(s)
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            reader = codecs.open(os_helper.TESTFN, 'U', encoding=self.encoding)
-        with reader:
+        with codecs.open(os_helper.TESTFN, 'r',
+                         encoding=self.encoding) as reader:
             self.assertEqual(reader.read(), s1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    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)
+            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)
+            self.assertIn("can't have text and binary mode at once",
+                          str(cm.exception))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
+
 
 class UTF16LETest(ReadTest, unittest.TestCase):
     encoding = "utf-16-le"
     ill_formed_sequence = b"\x80\xdc"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -899,8 +866,7 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xff', '\ufffd'),
@@ -922,17 +888,15 @@ def test_nonbmp(self):
         self.assertEqual(b'\x00\xd8\x03\xde'.decode(self.encoding),
                          "\U00010203")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
 
 class UTF16BETest(ReadTest, unittest.TestCase):
     encoding = "utf-16-be"
     ill_formed_sequence = b"\xdc\x80"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\xff\u0100\uffff\U00010000",
@@ -952,8 +916,7 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xff', '\ufffd'),
@@ -975,10 +938,9 @@ def test_nonbmp(self):
         self.assertEqual(b'\xd8\x00\xde\x03'.decode(self.encoding),
                          "\U00010203")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
 
 class UTF8Test(ReadTest, unittest.TestCase):
     encoding = "utf-8"
@@ -1025,8 +987,7 @@ def test_decode_error(self):
                 self.assertEqual(data.decode(self.encoding, error_handler),
                                  expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         super().test_lone_surrogates()
         # not sure if this is making sense for
@@ -1079,13 +1040,7 @@ def test_incremental_errors(self):
 class UTF7Test(ReadTest, unittest.TestCase):
     encoding = "utf-7"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ascii(self):
         # Set D (directly encoded characters)
         set_d = ('ABCDEFGHIJKLMNOPQRSTUVWXYZ'
@@ -1112,8 +1067,7 @@ def test_ascii(self):
                          b'+AAAAAQACAAMABAAFAAYABwAIAAsADAAOAA8AEAARABIAEwAU'
                          b'ABUAFgAXABgAGQAaABsAHAAdAB4AHwBcAH4Afw-')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             'a+-b\x00c\x80d\u0100e\U00010000f',
@@ -1153,8 +1107,7 @@ def test_partial(self):
             ]
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_errors(self):
         tests = [
             (b'\xffb', '\ufffdb'),
@@ -1185,8 +1138,7 @@ def test_errors(self):
                                 raw, 'strict', True)
                 self.assertEqual(raw.decode('utf-7', 'replace'), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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-')
@@ -1202,8 +1154,7 @@ def test_nonbmp(self):
         self.assertEqual(b'+IKwgrNgB3KA'.decode(self.encoding),
                          '\u20ac\u20ac\U000104A0')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         tests = [
             (b'a+2AE-b', 'a\ud801b'),
@@ -1224,15 +1175,17 @@ def test_lone_surrogates(self):
             with self.subTest(raw=raw):
                 self.assertEqual(raw.decode('utf-7', 'replace'), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug1175396(self):
-        super().test_bug1175396()
+        return super().test_bug1175396()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental_surrogatepass(self):
-        super().test_incremental_surrogatepass()
+        return super().test_incremental_surrogatepass()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_readline(self):
+        return super().test_readline()
 
 
 class UTF16ExTest(unittest.TestCase):
@@ -1357,8 +1310,7 @@ def test_raw(self):
             if b != b'\\':
                 self.assertEqual(decode(b + b'0'), (b + b'0', 2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_escape(self):
         decode = codecs.escape_decode
         check = coding_checker(self, decode)
@@ -1379,28 +1331,43 @@ def test_escape(self):
         check(br"[\418]", b"[!8]")
         check(br"[\101]", b"[A]")
         check(br"[\1010]", b"[A0]")
-        check(br"[\501]", b"[A]")
         check(br"[\x41]", b"[A]")
         check(br"[\x410]", b"[A0]")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    def test_warnings(self):
+        decode = codecs.escape_decode
+        check = coding_checker(self, decode)
         for i in range(97, 123):
             b = bytes([i])
             if b not in b'abfnrtvx':
-                with self.assertWarns(DeprecationWarning):
+                with self.assertWarnsRegex(DeprecationWarning,
+                        r"invalid escape sequence '\\%c'" % i):
                     check(b"\\" + b, b"\\" + b)
-            with self.assertWarns(DeprecationWarning):
+            with self.assertWarnsRegex(DeprecationWarning,
+                    r"invalid escape sequence '\\%c'" % (i-32)):
                 check(b"\\" + b.upper(), b"\\" + b.upper())
-        with self.assertWarns(DeprecationWarning):
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\8'"):
             check(br"\8", b"\\8")
         with self.assertWarns(DeprecationWarning):
             check(br"\9", b"\\9")
-        with self.assertWarns(DeprecationWarning):
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\\xfa'") as cm:
             check(b"\\\xfa", b"\\\xfa")
         for i in range(0o400, 0o1000):
-            with self.assertWarns(DeprecationWarning):
+            with self.assertWarnsRegex(DeprecationWarning,
+                    r"invalid octal escape sequence '\\%o'" % i):
                 check(rb'\%o' % i, bytes([i & 0o377]))
-    
-    # TODO: RUSTPYTHON - ValueError: not raised by escape_decode
-    @unittest.expectedFailure
+
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\z'"):
+            self.assertEqual(decode(br'\x\z', 'ignore'), (b'\\z', 4))
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid octal escape sequence '\\501'"):
+            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")
@@ -1543,13 +1510,29 @@ def test_decode(self):
 
     def test_decode_invalid(self):
         testcases = [
-            (b"xn--w&", "strict", UnicodeError()),
+            (b"xn--w&", "strict", UnicodeDecodeError("punycode", b"", 5, 6, "")),
+            (b"&egbpdaj6bu4bxfgehfvwxn", "strict", UnicodeDecodeError("punycode", b"", 0, 1, "")),
+            (b"egbpdaj6bu&4bx&fgehfvwxn", "strict", UnicodeDecodeError("punycode", b"", 10, 11, "")),
+            (b"egbpdaj6bu4bxfgehfvwxn&", "strict", UnicodeDecodeError("punycode", b"", 22, 23, "")),
+            (b"\xFFProprostnemluvesky-uyb24dma41a", "strict", UnicodeDecodeError("ascii", b"", 0, 1, "")),
+            (b"Pro\xFFprostnemluvesky-uyb24dma41a", "strict", UnicodeDecodeError("ascii", b"", 3, 4, "")),
+            (b"Proprost&nemluvesky-uyb24&dma41a", "strict", UnicodeDecodeError("punycode", b"", 25, 26, "")),
+            (b"Proprostnemluvesky&-&uyb24dma41a", "strict", UnicodeDecodeError("punycode", b"", 20, 21, "")),
+            (b"Proprostnemluvesky-&uyb24dma41a", "strict", UnicodeDecodeError("punycode", b"", 19, 20, "")),
+            (b"Proprostnemluvesky-uyb24d&ma41a", "strict", UnicodeDecodeError("punycode", b"", 25, 26, "")),
+            (b"Proprostnemluvesky-uyb24dma41a&", "strict", UnicodeDecodeError("punycode", b"", 30, 31, "")),
             (b"xn--w&", "ignore", "xn-"),
         ]
         for puny, errors, expected in testcases:
             with self.subTest(puny=puny, errors=errors):
                 if isinstance(expected, Exception):
-                    self.assertRaises(UnicodeError, puny.decode, "punycode", errors)
+                    with self.assertRaises(UnicodeDecodeError) as cm:
+                        puny.decode("punycode", errors)
+                    exc = cm.exception
+                    self.assertEqual(exc.encoding, expected.encoding)
+                    self.assertEqual(exc.object, puny)
+                    self.assertEqual(exc.start, expected.start)
+                    self.assertEqual(exc.end, expected.end)
                 else:
                     self.assertEqual(puny.decode("punycode", errors), expected)
 
@@ -1719,7 +1702,7 @@ def test_nameprep(self):
             orig = str(orig, "utf-8", "surrogatepass")
             if prepped is None:
                 # Input contains prohibited characters
-                self.assertRaises(UnicodeError, nameprep, orig)
+                self.assertRaises(UnicodeEncodeError, nameprep, orig)
             else:
                 prepped = str(prepped, "utf-8", "surrogatepass")
                 try:
@@ -1729,11 +1712,46 @@ def test_nameprep(self):
 
 
 class IDNACodecTest(unittest.TestCase):
+
+    invalid_decode_testcases = [
+        (b"\xFFpython.org", UnicodeDecodeError("idna", b"\xFFpython.org", 0, 1, "")),
+        (b"pyt\xFFhon.org", UnicodeDecodeError("idna", b"pyt\xFFhon.org", 3, 4, "")),
+        (b"python\xFF.org", UnicodeDecodeError("idna", b"python\xFF.org", 6, 7, "")),
+        (b"python.\xFForg", UnicodeDecodeError("idna", b"python.\xFForg", 7, 8, "")),
+        (b"python.o\xFFrg", UnicodeDecodeError("idna", b"python.o\xFFrg", 8, 9, "")),
+        (b"python.org\xFF", UnicodeDecodeError("idna", b"python.org\xFF", 10, 11, "")),
+        (b"xn--pythn-&mua.org", UnicodeDecodeError("idna", b"xn--pythn-&mua.org", 10, 11, "")),
+        (b"xn--pythn-m&ua.org", UnicodeDecodeError("idna", b"xn--pythn-m&ua.org", 11, 12, "")),
+        (b"xn--pythn-mua&.org", UnicodeDecodeError("idna", b"xn--pythn-mua&.org", 13, 14, "")),
+    ]
+    invalid_encode_testcases = [
+        (f"foo.{'\xff'*60}", UnicodeEncodeError("idna", f"foo.{'\xff'*60}", 4, 64, "")),
+        ("あさ.\u034f", UnicodeEncodeError("idna", "あさ.\u034f", 3, 4, "")),
+    ]
+
     def test_builtin_decode(self):
         self.assertEqual(str(b"python.org", "idna"), "python.org")
         self.assertEqual(str(b"python.org.", "idna"), "python.org.")
         self.assertEqual(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org")
         self.assertEqual(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
+        self.assertEqual(str(b"XN--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
+        self.assertEqual(str(b"xN--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
+        self.assertEqual(str(b"Xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.")
+        self.assertEqual(str(b"bugs.xn--pythn-mua.org.", "idna"),
+                         "bugs.pyth\xf6n.org.")
+        self.assertEqual(str(b"bugs.XN--pythn-mua.org.", "idna"),
+                         "bugs.pyth\xf6n.org.")
+
+    def test_builtin_decode_invalid(self):
+        for case, expected in self.invalid_decode_testcases:
+            with self.subTest(case=case, expected=expected):
+                with self.assertRaises(UnicodeDecodeError) as cm:
+                    case.decode("idna")
+                exc = cm.exception
+                self.assertEqual(exc.encoding, expected.encoding)
+                self.assertEqual(exc.object, expected.object)
+                self.assertEqual(exc.start, expected.start, msg=f'reason: {exc.reason}')
+                self.assertEqual(exc.end, expected.end)
 
     def test_builtin_encode(self):
         self.assertEqual("python.org".encode("idna"), b"python.org")
@@ -1741,10 +1759,21 @@ def test_builtin_encode(self):
         self.assertEqual("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org")
         self.assertEqual("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.")
 
+    def test_builtin_encode_invalid(self):
+        for case, expected in self.invalid_encode_testcases:
+            with self.subTest(case=case, expected=expected):
+                with self.assertRaises(UnicodeEncodeError) as cm:
+                    case.encode("idna")
+                exc = cm.exception
+                self.assertEqual(exc.encoding, expected.encoding)
+                self.assertEqual(exc.object, expected.object)
+                self.assertEqual(exc.start, expected.start)
+                self.assertEqual(exc.end, expected.end)
+
     def test_builtin_decode_length_limit(self):
-        with self.assertRaisesRegex(UnicodeError, "way too long"):
+        with self.assertRaisesRegex(UnicodeDecodeError, "way too long"):
             (b"xn--016c"+b"a"*1100).decode("idna")
-        with self.assertRaisesRegex(UnicodeError, "too long"):
+        with self.assertRaisesRegex(UnicodeDecodeError, "too long"):
             (b"xn--016c"+b"a"*70).decode("idna")
 
     def test_stream(self):
@@ -1782,6 +1811,39 @@ def test_incremental_decode(self):
         self.assertEqual(decoder.decode(b"rg."), "org.")
         self.assertEqual(decoder.decode(b"", True), "")
 
+    def test_incremental_decode_invalid(self):
+        iterdecode_testcases = [
+            (b"\xFFpython.org", UnicodeDecodeError("idna", b"\xFF", 0, 1, "")),
+            (b"pyt\xFFhon.org", UnicodeDecodeError("idna", b"pyt\xFF", 3, 4, "")),
+            (b"python\xFF.org", UnicodeDecodeError("idna", b"python\xFF", 6, 7, "")),
+            (b"python.\xFForg", UnicodeDecodeError("idna", b"\xFF", 0, 1, "")),
+            (b"python.o\xFFrg", UnicodeDecodeError("idna", b"o\xFF", 1, 2, "")),
+            (b"python.org\xFF", UnicodeDecodeError("idna", b"org\xFF", 3, 4, "")),
+            (b"xn--pythn-&mua.org", UnicodeDecodeError("idna", b"xn--pythn-&mua.", 10, 11, "")),
+            (b"xn--pythn-m&ua.org", UnicodeDecodeError("idna", b"xn--pythn-m&ua.", 11, 12, "")),
+            (b"xn--pythn-mua&.org", UnicodeDecodeError("idna", b"xn--pythn-mua&.", 13, 14, "")),
+        ]
+        for case, expected in iterdecode_testcases:
+            with self.subTest(case=case, expected=expected):
+                with self.assertRaises(UnicodeDecodeError) as cm:
+                    list(codecs.iterdecode((bytes([c]) for c in case), "idna"))
+                exc = cm.exception
+                self.assertEqual(exc.encoding, expected.encoding)
+                self.assertEqual(exc.object, expected.object)
+                self.assertEqual(exc.start, expected.start)
+                self.assertEqual(exc.end, expected.end)
+
+        decoder = codecs.getincrementaldecoder("idna")()
+        for case, expected in self.invalid_decode_testcases:
+            with self.subTest(case=case, expected=expected):
+                with self.assertRaises(UnicodeDecodeError) as cm:
+                    decoder.decode(case)
+                exc = cm.exception
+                self.assertEqual(exc.encoding, expected.encoding)
+                self.assertEqual(exc.object, expected.object)
+                self.assertEqual(exc.start, expected.start)
+                self.assertEqual(exc.end, expected.end)
+
     def test_incremental_encode(self):
         self.assertEqual(
             b"".join(codecs.iterencode("python.org", "idna")),
@@ -1810,6 +1872,23 @@ def test_incremental_encode(self):
         self.assertEqual(encoder.encode("ample.org."), b"xn--xample-9ta.org.")
         self.assertEqual(encoder.encode("", True), b"")
 
+    def test_incremental_encode_invalid(self):
+        iterencode_testcases = [
+            (f"foo.{'\xff'*60}", UnicodeEncodeError("idna", f"{'\xff'*60}", 0, 60, "")),
+            ("あさ.\u034f", UnicodeEncodeError("idna", "\u034f", 0, 1, "")),
+        ]
+        for case, expected in iterencode_testcases:
+            with self.subTest(case=case, expected=expected):
+                with self.assertRaises(UnicodeEncodeError) as cm:
+                    list(codecs.iterencode(case, "idna"))
+                exc = cm.exception
+                self.assertEqual(exc.encoding, expected.encoding)
+                self.assertEqual(exc.object, expected.object)
+                self.assertEqual(exc.start, expected.start)
+                self.assertEqual(exc.end, expected.end)
+
+        # codecs.getincrementalencoder.encode() does not throw an error
+
     def test_errors(self):
         """Only supports "strict" error handler"""
         "python.org".encode("idna", "strict")
@@ -1887,16 +1966,10 @@ def test_getwriter(self):
         self.assertRaises(TypeError, codecs.getwriter)
         self.assertRaises(LookupError, codecs.getwriter, "__spam__")
 
+    @support.run_with_locale('LC_CTYPE', 'tr_TR')
     def test_lookup_issue1813(self):
         # Issue #1813: under Turkish locales, lookup of some codecs failed
         # because 'I' is lowercased as "ı" (dotless i)
-        oldlocale = locale.setlocale(locale.LC_CTYPE)
-        self.addCleanup(locale.setlocale, locale.LC_CTYPE, oldlocale)
-        try:
-            locale.setlocale(locale.LC_CTYPE, 'tr_TR')
-        except locale.Error:
-            # Unsupported locale on this system
-            self.skipTest('test needs Turkish locale')
         c = codecs.lookup('ASCII')
         self.assertEqual(c.name, 'ascii')
 
@@ -1949,6 +2022,76 @@ def test_file_closes_if_lookup_error_raised(self):
 
             file().close.assert_called()
 
+    def test_copy(self):
+        orig = codecs.lookup('utf-8')
+        dup = copy.copy(orig)
+        self.assertIsNot(dup, orig)
+        self.assertEqual(dup, orig)
+        self.assertTrue(orig._is_text_encoding)
+        self.assertEqual(dup.encode, orig.encode)
+        self.assertEqual(dup.name, orig.name)
+        self.assertEqual(dup.incrementalencoder, orig.incrementalencoder)
+
+        # Test a CodecInfo with _is_text_encoding equal to false.
+        orig = codecs.lookup("base64")
+        dup = copy.copy(orig)
+        self.assertIsNot(dup, orig)
+        self.assertEqual(dup, orig)
+        self.assertFalse(orig._is_text_encoding)
+        self.assertEqual(dup.encode, orig.encode)
+        self.assertEqual(dup.name, orig.name)
+        self.assertEqual(dup.incrementalencoder, orig.incrementalencoder)
+
+    def test_deepcopy(self):
+        orig = codecs.lookup('utf-8')
+        dup = copy.deepcopy(orig)
+        self.assertIsNot(dup, orig)
+        self.assertEqual(dup, orig)
+        self.assertTrue(orig._is_text_encoding)
+        self.assertEqual(dup.encode, orig.encode)
+        self.assertEqual(dup.name, orig.name)
+        self.assertEqual(dup.incrementalencoder, orig.incrementalencoder)
+
+        # Test a CodecInfo with _is_text_encoding equal to false.
+        orig = codecs.lookup("base64")
+        dup = copy.deepcopy(orig)
+        self.assertIsNot(dup, orig)
+        self.assertEqual(dup, orig)
+        self.assertFalse(orig._is_text_encoding)
+        self.assertEqual(dup.encode, orig.encode)
+        self.assertEqual(dup.name, orig.name)
+        self.assertEqual(dup.incrementalencoder, orig.incrementalencoder)
+
+    def test_pickle(self):
+        codec_info = codecs.lookup('utf-8')
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(protocol=proto):
+                pickled_codec_info = pickle.dumps(codec_info)
+                unpickled_codec_info = pickle.loads(pickled_codec_info)
+                self.assertIsNot(codec_info, unpickled_codec_info)
+                self.assertEqual(codec_info, unpickled_codec_info)
+                self.assertEqual(codec_info.name, unpickled_codec_info.name)
+                self.assertEqual(
+                     codec_info.incrementalencoder,
+                     unpickled_codec_info.incrementalencoder
+                )
+                self.assertTrue(unpickled_codec_info._is_text_encoding)
+
+        # Test a CodecInfo with _is_text_encoding equal to false.
+        codec_info = codecs.lookup('base64')
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(protocol=proto):
+                pickled_codec_info = pickle.dumps(codec_info)
+                unpickled_codec_info = pickle.loads(pickled_codec_info)
+                self.assertIsNot(codec_info, unpickled_codec_info)
+                self.assertEqual(codec_info, unpickled_codec_info)
+                self.assertEqual(codec_info.name, unpickled_codec_info.name)
+                self.assertEqual(
+                     codec_info.incrementalencoder,
+                     unpickled_codec_info.incrementalencoder
+                )
+                self.assertFalse(unpickled_codec_info._is_text_encoding)
+
 
 class StreamReaderTest(unittest.TestCase):
 
@@ -1979,14 +2122,14 @@ class StreamWriterTest(unittest.TestCase):
 
     def setUp(self):
         self.writer = codecs.getwriter('utf-8')
-  
+
     def test_copy(self):
         f = self.writer(Queue(b''))
         with self.assertRaisesRegex(TypeError, 'StreamWriter'):
             copy.copy(f)
         with self.assertRaisesRegex(TypeError, 'StreamWriter'):
             copy.deepcopy(f)
-    
+
     def test_pickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.subTest(protocol=proto):
@@ -2007,7 +2150,7 @@ def test_copy(self):
             copy.copy(f)
         with self.assertRaisesRegex(TypeError, 'StreamReaderWriter'):
             copy.deepcopy(f)
-    
+
     def test_pickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.subTest(protocol=proto):
@@ -2148,8 +2291,7 @@ def test_basic(self):
 
 
 class BasicUnicodeTest(unittest.TestCase, MixInCheckStateHandling):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_basics(self):
         s = "abc123"  # all codecs should be able to encode these
         for encoding in all_unicode_encodings:
@@ -2231,14 +2373,14 @@ def test_basics(self):
                                          "encoding=%r" % encoding)
 
     @support.cpython_only
-    @unittest.skipIf(_testcapi is None, 'need _testcapi module')
+    @unittest.skipIf(_testlimitedcapi is None, 'need _testlimitedcapi module')
     def test_basics_capi(self):
         s = "abc123"  # all codecs should be able to encode these
         for encoding in all_unicode_encodings:
             if encoding not in broken_unicode_with_stateful:
                 # check incremental decoder/encoder (fetched via the C API)
                 try:
-                    cencoder = _testcapi.codec_incrementalencoder(encoding)
+                    cencoder = _testlimitedcapi.codec_incrementalencoder(encoding)
                 except LookupError:  # no IncrementalEncoder
                     pass
                 else:
@@ -2247,7 +2389,7 @@ def test_basics_capi(self):
                     for c in s:
                         encodedresult += cencoder.encode(c)
                     encodedresult += cencoder.encode("", True)
-                    cdecoder = _testcapi.codec_incrementaldecoder(encoding)
+                    cdecoder = _testlimitedcapi.codec_incrementaldecoder(encoding)
                     decodedresult = ""
                     for c in encodedresult:
                         decodedresult += cdecoder.decode(bytes([c]))
@@ -2258,19 +2400,18 @@ def test_basics_capi(self):
                 if encoding not in ("idna", "mbcs"):
                     # check incremental decoder/encoder with errors argument
                     try:
-                        cencoder = _testcapi.codec_incrementalencoder(encoding, "ignore")
+                        cencoder = _testlimitedcapi.codec_incrementalencoder(encoding, "ignore")
                     except LookupError:  # no IncrementalEncoder
                         pass
                     else:
                         encodedresult = b"".join(cencoder.encode(c) for c in s)
-                        cdecoder = _testcapi.codec_incrementaldecoder(encoding, "ignore")
+                        cdecoder = _testlimitedcapi.codec_incrementaldecoder(encoding, "ignore")
                         decodedresult = "".join(cdecoder.decode(bytes([c]))
                                                 for c in encodedresult)
                         self.assertEqual(decodedresult, s,
                                          "encoding=%r" % encoding)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek(self):
         # all codecs should be able to encode these
         s = "%s\n%s\n" % (100*"abc123", 100*"def456")
@@ -2286,8 +2427,7 @@ def test_seek(self):
                 data = reader.read()
                 self.assertEqual(s, data)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_decode_args(self):
         for encoding in all_unicode_encodings:
             decoder = codecs.getdecoder(encoding)
@@ -2295,8 +2435,7 @@ def test_bad_decode_args(self):
             if encoding not in ("idna", "punycode"):
                 self.assertRaises(TypeError, decoder, 42)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_encode_args(self):
         for encoding in all_unicode_encodings:
             encoder = codecs.getencoder(encoding)
@@ -2308,8 +2447,7 @@ def test_encoding_map_type_initialized(self):
         table_type = type(cp1140.encoding_table)
         self.assertEqual(table_type, table_type)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decoder_state(self):
         # Check that getstate() and setstate() handle the state properly
         u = "abc123"
@@ -2320,8 +2458,7 @@ def test_decoder_state(self):
 
 
 class CharmapTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_string_map(self):
         self.assertEqual(
             codecs.charmap_decode(b"\x00\x01\x02", "strict", "abc"),
@@ -2377,8 +2514,7 @@ def test_decode_with_string_map(self):
             ("", len(allbytes))
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_int2str_map(self):
         self.assertEqual(
             codecs.charmap_decode(b"\x00\x01\x02", "strict",
@@ -2495,8 +2631,7 @@ def test_decode_with_int2str_map(self):
             b"\x00\x01\x02", "strict", {0: "A", 1: 'Bb', 2: 999999999}
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_with_int2int_map(self):
         a = ord('a')
         b = ord('b')
@@ -2589,8 +2724,7 @@ def test_streamreaderwriter(self):
 
 
 class TypesTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_decode_unicode(self):
         # Most decoders don't accept unicode input
         decoders = [
@@ -2636,16 +2770,6 @@ class UnicodeEscapeTest(ReadTest, unittest.TestCase):
 
     test_lone_surrogates = None
 
-    # TODO: RUSTPYTHON, TypeError: Expected type 'str', not 'bytes'
-    @unittest.expectedFailure
-    def test_incremental_surrogatepass(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_incremental_surrogatepass() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
     def test_empty(self):
         self.assertEqual(codecs.unicode_escape_encode(""), (b"", 0))
         self.assertEqual(codecs.unicode_escape_decode(b""), ("", 0))
@@ -2677,8 +2801,6 @@ def test_escape_encode(self):
         check('\u20ac', br'\u20ac')
         check('\U0001d120', br'\U0001d120')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_escape_decode(self):
         decode = codecs.unicode_escape_decode
         check = coding_checker(self, decode)
@@ -2703,24 +2825,41 @@ def test_escape_decode(self):
         check(br"[\x410]", "[A0]")
         check(br"\u20ac", "\u20ac")
         check(br"\U0001d120", "\U0001d120")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; DeprecationWarning not triggered
+    def test_decode_warnings(self):
+        decode = codecs.unicode_escape_decode
+        check = coding_checker(self, decode)
         for i in range(97, 123):
             b = bytes([i])
             if b not in b'abfnrtuvx':
-                with self.assertWarns(DeprecationWarning):
+                with self.assertWarnsRegex(DeprecationWarning,
+                        r"invalid escape sequence '\\%c'" % i):
                     check(b"\\" + b, "\\" + chr(i))
             if b.upper() not in b'UN':
-                with self.assertWarns(DeprecationWarning):
+                with self.assertWarnsRegex(DeprecationWarning,
+                        r"invalid escape sequence '\\%c'" % (i-32)):
                     check(b"\\" + b.upper(), "\\" + chr(i-32))
-        with self.assertWarns(DeprecationWarning):
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\8'"):
             check(br"\8", "\\8")
         with self.assertWarns(DeprecationWarning):
             check(br"\9", "\\9")
-        with self.assertWarns(DeprecationWarning):
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\\xfa'") as cm:
             check(b"\\\xfa", "\\\xfa")
         for i in range(0o400, 0o1000):
-            with self.assertWarns(DeprecationWarning):
+            with self.assertWarnsRegex(DeprecationWarning,
+                    r"invalid octal escape sequence '\\%o'" % i):
                 check(rb'\%o' % i, chr(i))
 
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid escape sequence '\\z'"):
+            self.assertEqual(decode(br'\x\z', 'ignore'), ('\\z', 4))
+        with self.assertWarnsRegex(DeprecationWarning,
+                r"invalid octal escape sequence '\\501'"):
+            self.assertEqual(decode(br'\x\501', 'ignore'), ('\u0141', 6))
+
     def test_decode_errors(self):
         decode = codecs.unicode_escape_decode
         for c, d in (b'x', 2), (b'u', 4), (b'U', 4):
@@ -2737,8 +2876,7 @@ def test_decode_errors(self):
         self.assertEqual(decode(br"\U00110000", "ignore"), ("", 10))
         self.assertEqual(decode(br"\U00110000", "replace"), ("\ufffd", 10))
 
-    # TODO: RUSTPYTHON, UnicodeDecodeError: ('unicodeescape', b'\\', 0, 1, '\\ at end of string')
-    @unittest.expectedFailure
+    @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",
@@ -2778,21 +2916,19 @@ 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 RawUnicodeEscapeTest(ReadTest, unittest.TestCase):
     encoding = "raw-unicode-escape"
 
     test_lone_surrogates = None
 
-    # TODO: RUSTPYTHON, AssertionError: '\\' != ''
-    @unittest.expectedFailure
-    def test_incremental_surrogatepass(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_incremental_surrogatepass() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_readline(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_readline() # TODO: RUSTPYTHON, remove when this passes
-
     def test_empty(self):
         self.assertEqual(codecs.raw_unicode_escape_encode(""), (b"", 0))
         self.assertEqual(codecs.raw_unicode_escape_decode(b""), ("", 0))
@@ -2841,8 +2977,7 @@ def test_decode_errors(self):
         self.assertEqual(decode(br"\U00110000", "ignore"), ("", 10))
         self.assertEqual(decode(br"\U00110000", "replace"), ("\ufffd", 10))
 
-    # TODO: RUSTPYTHON, AssertionError: '\x00\t\n\r\\' != '\x00\t\n\r'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_partial(self):
         self.check_partial(
             "\x00\t\n\r\\\xff\uffff\U00010000",
@@ -2872,6 +3007,14 @@ 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):
 
@@ -2914,8 +3057,7 @@ def test_ascii(self):
         self.assertEqual("foo\udc80bar".encode("ascii", "surrogateescape"),
                          b"foo\x80bar")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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"),
@@ -2930,8 +3072,7 @@ def test_latin1(self):
 
 
 class BomTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek0(self):
         data = "1234567890"
         tests = ("utf-16",
@@ -3048,8 +3189,6 @@ def test_readline(self):
                 sout = reader.readline()
                 self.assertEqual(sout, b"\x80")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_buffer_api_usage(self):
         # We check all the transform codecs accept memoryview input
         # for encoding and decoding
@@ -3112,10 +3251,8 @@ def test_binary_to_text_denylists_text_transforms(self):
                     bad_input.decode("rot_13")
                 self.assertIsNone(failure.exception.__cause__)
 
-    
-    # @unittest.skipUnless(zlib, "Requires zlib support")
-    # TODO: RUSTPYTHON, ^ restore once test passes
-    @unittest.expectedFailure
+    @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
         msg = "decoding with 'zlib_codec' codec failed"
@@ -3123,8 +3260,7 @@ def test_custom_zlib_error_is_noted(self):
             codecs.decode(b"hello", "zlib_codec")
         self.assertEqual(msg, failure.exception.__notes__[0])
 
-    # TODO: RUSTPYTHON - AttributeError: 'Error' object has no attribute '__notes__'
-    @unittest.expectedFailure 
+    @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
@@ -3204,9 +3340,8 @@ def assertNoted(self, operation, exc_type, msg):
     def raise_obj(self, *args, **kwds):
         # Helper to dynamically change the object raised by a test codec
         raise self.obj_to_raise
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @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)
@@ -3218,65 +3353,56 @@ def check_note(self, obj_to_raise, msg, exc_type=RuntimeError):
             b"bytes input".decode(self.codec_name)
         with self.assertNoted("decoding", exc_type, msg):
             codecs.decode(b"bytes input", self.codec_name)
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_by_type(self):
         self.check_note(RuntimeError, "")
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_raise_by_value(self):
         msg = "This should be noted"
         self.check_note(RuntimeError(msg), msg)
-        
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_init_override(self):
         class CustomInit(RuntimeError):
             def __init__(self):
                 pass
         self.check_note(CustomInit, "")
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure 
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_new_override(self):
         class CustomNew(RuntimeError):
             def __new__(cls):
                 return super().__new__(cls)
         self.check_note(CustomNew, "")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_str_arg(self):
         self.check_note(RuntimeError(1), "1")
-        
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multiple_args(self):
         msg_re = r"^\('a', 'b', 'c'\)$"
         self.check_note(RuntimeError('a', 'b', 'c'), msg_re)
@@ -3293,8 +3419,7 @@ def test_codec_lookup_failure(self):
         with self.assertRaisesRegex(LookupError, msg):
             codecs.decode(b"bytes input", self.codec_name)
 
-    
-    @unittest.expectedFailure
+    @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
@@ -3330,22 +3455,20 @@ def decode_to_bytes(*args, **kwds):
 class CodePageTest(unittest.TestCase):
     CP_UTF8 = 65001
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_code_page_name(self):
         self.assertRaisesRegex(UnicodeEncodeError, 'cp932',
             codecs.code_page_encode, 932, '\xff')
         self.assertRaisesRegex(UnicodeDecodeError, 'cp932',
             codecs.code_page_decode, 932, b'\x81\x00', 'strict', True)
-        self.assertRaisesRegex(UnicodeDecodeError, 'CP_UTF8',
+        self.assertRaisesRegex(UnicodeDecodeError, 'cp65001',
             codecs.code_page_decode, self.CP_UTF8, b'\xff', 'strict', True)
 
     def check_decode(self, cp, tests):
@@ -3382,8 +3505,7 @@ def check_encode(self, cp, tests):
                 self.assertRaises(UnicodeEncodeError,
                     codecs.code_page_encode, cp, text, errors)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cp932(self):
         self.check_encode(932, (
             ('abc', 'strict', b'abc'),
@@ -3417,8 +3539,7 @@ def test_cp932(self):
             (b'\x81\x00abc', 'backslashreplace', '\\x81\x00abc'),
         ))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cp1252(self):
         self.check_encode(1252, (
             ('abc', 'strict', b'abc'),
@@ -3437,8 +3558,7 @@ def test_cp1252(self):
             (b'\xff', 'strict', '\xff'),
         ))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cp_utf7(self):
         cp = 65000
         self.check_encode(cp, (
@@ -3459,8 +3579,7 @@ def test_cp_utf7(self):
             (b'[\xff]', 'strict', '[\xff]'),
         ))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multibyte_encoding(self):
         self.check_decode(932, (
             (b'\x84\xe9\x80', 'ignore', '\u9a3e'),
@@ -3475,8 +3594,7 @@ def test_multibyte_encoding(self):
             ('[\U0010ffff\uDC80]', 'replace', b'[\xf4\x8f\xbf\xbf?]'),
         ))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -3496,8 +3614,7 @@ def test_code_page_decode_flags(self):
         self.assertEqual(codecs.code_page_decode(42, b'abc'),
                          ('\uf061\uf062\uf063', 3))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incremental(self):
         decoded = codecs.code_page_decode(932, b'\x82', 'strict', False)
         self.assertEqual(decoded, ('', 0))
@@ -3682,7 +3799,7 @@ def test_seeking_write(self):
         self.assertEqual(sr.readline(), b'1\n')
         self.assertEqual(sr.readline(), b'abc\n')
         self.assertEqual(sr.readline(), b'789\n')
-    
+
     def test_copy(self):
         bio = io.BytesIO()
         codec = codecs.lookup('ascii')
@@ -3693,7 +3810,7 @@ def test_copy(self):
             copy.copy(sr)
         with self.assertRaisesRegex(TypeError, 'StreamRecoder'):
             copy.deepcopy(sr)
-    
+
     def test_pickle(self):
         q = Queue(b'')
         codec = codecs.lookup('ascii')
@@ -3860,8 +3977,7 @@ def test_rot13_func(self):
 
 class CodecNameNormalizationTest(unittest.TestCase):
     """Test codec name normalization"""
-    # TODO: RUSTPYTHON, AssertionError: Tuples differ: (1, 2, 3, 4) != (None, None, None, None)
-    @unittest.expectedFailure
+    @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 1036b970cd..c62e3748e6 100644
--- a/Lib/test/test_codeop.py
+++ b/Lib/test/test_codeop.py
@@ -227,6 +227,9 @@ def test_incomplete(self):
         ai("(x for x in")
         ai("(x for x in (")
 
+        ai('a = f"""')
+        ai('a = \\')
+
     def test_invalid(self):
         ai = self.assertInvalid
         ai("a b")
@@ -300,12 +303,11 @@ def test_warning(self):
             warnings.simplefilter('error', SyntaxWarning)
             compile_command(r"'\e'", symbol='exec')
 
-    # TODO: RUSTPYTHON
-    #def test_incomplete_warning(self):
-    #    with warnings.catch_warnings(record=True) as w:
-    #        warnings.simplefilter('always')
-    #        self.assertIncomplete("'\\e' + (")
-    #    self.assertEqual(w, [])
+    def test_incomplete_warning(self):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            self.assertIncomplete("'\\e' + (")
+        self.assertEqual(w, [])
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index 901f596cc3..7b11601fc4 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -1,5 +1,6 @@
 """Unit tests for collections.py."""
 
+import array
 import collections
 import copy
 import doctest
@@ -261,8 +262,7 @@ def __contains__(self, key):
         d = c.new_child(b=20, c=30)
         self.assertEqual(d.maps, [{'b': 20, 'c': 30}, {'a': 1, 'b': 2}])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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))
@@ -469,6 +469,7 @@ def test_module_parameter(self):
         NT = namedtuple('NT', ['x', 'y'], module=collections)
         self.assertEqual(NT.__module__, collections)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_instance(self):
         Point = namedtuple('Point', 'x y')
         p = Point(11, 22)
@@ -490,12 +491,8 @@ def test_instance(self):
         self.assertEqual(p._replace(x=1), (1, 22))      # test _replace method
         self.assertEqual(p._asdict(), dict(x=11, y=22)) # test _asdict method
 
-        try:
+        with self.assertRaises(TypeError):
             p._replace(x=1, error=2)
-        except ValueError:
-            pass
-        else:
-            self._fail('Did not detect an incorrect fieldname')
 
         # verify that field string can have commas
         Point = namedtuple('Point', 'x, y')
@@ -547,7 +544,9 @@ def test_odd_sizes(self):
         self.assertEqual(Dot(1)._replace(d=999), (999,))
         self.assertEqual(Dot(1)._fields, ('d',))
 
-        n = support.EXCEEDS_RECURSION_LIMIT
+    @support.requires_resource('cpu')
+    def test_large_size(self):
+        n = support.exceeds_recursion_limit()
         names = list(set(''.join([choice(string.ascii_letters)
                                   for j in range(10)]) for i in range(n)))
         n = len(names)
@@ -739,7 +738,7 @@ def validate_abstract_methods(self, abc, *names):
             stubs = methodstubs.copy()
             del stubs[name]
             C = type('C', (abc,), stubs)
-            self.assertRaises(TypeError, C, name)
+            self.assertRaises(TypeError, C)
 
     def validate_isinstance(self, abc, name):
         stub = lambda s, *args: 0
@@ -789,8 +788,7 @@ def _test_gen():
 
 class TestOneTrickPonyABCs(ABCTestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_Awaitable(self):
         def gen():
             yield
@@ -843,8 +841,7 @@ class CoroLike: pass
         CoroLike = None
         support.gc_collect() # Kill CoroLike to clean-up ABCMeta cache
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_Coroutine(self):
         def gen():
             yield
@@ -952,8 +949,6 @@ def __aiter__(self):
         self.validate_abstract_methods(AsyncIterable, '__aiter__')
         self.validate_isinstance(AsyncIterable, '__aiter__')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_AsyncIterator(self):
         class AI:
             def __aiter__(self):
@@ -972,7 +967,7 @@ class AnextOnly:
             async def __anext__(self):
                 raise StopAsyncIteration
         self.assertNotIsInstance(AnextOnly(), AsyncIterator)
-        self.validate_abstract_methods(AsyncIterator, '__anext__', '__aiter__')
+        self.validate_abstract_methods(AsyncIterator, '__anext__')
 
     def test_Iterable(self):
         # Check some non-iterables
@@ -1152,8 +1147,7 @@ class NonCol(ColImpl):
         self.assertFalse(issubclass(NonCol, Collection))
         self.assertFalse(isinstance(NonCol(), Collection))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
     def test_Iterator(self):
         non_samples = [None, 42, 3.14, 1j, b"", "", (), [], {}, set()]
         for x in non_samples:
@@ -1170,7 +1164,7 @@ def test_Iterator(self):
         for x in samples:
             self.assertIsInstance(x, Iterator)
             self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))
-        self.validate_abstract_methods(Iterator, '__next__', '__iter__')
+        self.validate_abstract_methods(Iterator, '__next__')
 
         # Issue 10565
         class NextOnly:
@@ -1850,14 +1844,11 @@ def test_Set_hash_matches_frozenset(self):
             fs = frozenset(s)
             self.assertEqual(hash(fs), Set._hash(fs), msg=s)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_Mapping(self):
         for sample in [dict]:
             self.assertIsInstance(sample(), Mapping)
             self.assertTrue(issubclass(sample, Mapping))
-        self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',
-            '__getitem__')
+        self.validate_abstract_methods(Mapping, '__iter__', '__len__', '__getitem__')
         class MyMapping(Mapping):
             def __len__(self):
                 return 0
@@ -1868,13 +1859,11 @@ def __iter__(self):
         self.validate_comparison(MyMapping())
         self.assertRaises(TypeError, reversed, MyMapping())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_MutableMapping(self):
         for sample in [dict]:
             self.assertIsInstance(sample(), MutableMapping)
             self.assertTrue(issubclass(sample, MutableMapping))
-        self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',
+        self.validate_abstract_methods(MutableMapping, '__iter__', '__len__',
             '__getitem__', '__setitem__', '__delitem__')
 
     def test_MutableMapping_subclass(self):
@@ -1904,8 +1893,6 @@ def test_MutableMapping_subclass(self):
         mymap['blue'] = 7               # Shouldn't affect 'z'
         self.assertEqual(z, {('orange', 3), ('red', 5)})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_Sequence(self):
         for sample in [tuple, list, bytes, str]:
             self.assertIsInstance(sample(), Sequence)
@@ -1915,8 +1902,7 @@ def test_Sequence(self):
         self.assertIsInstance(memoryview(b""), Sequence)
         self.assertTrue(issubclass(memoryview, Sequence))
         self.assertTrue(issubclass(str, Sequence))
-        self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',
-            '__getitem__')
+        self.validate_abstract_methods(Sequence, '__len__', '__getitem__')
 
     def test_Sequence_mixins(self):
         class SequenceSubclass(Sequence):
@@ -1975,10 +1961,7 @@ class X(ByteString): pass
             # No metaclass conflict
             class Z(ByteString, Awaitable): pass
 
-    # TODO: RUSTPYTHON
-    # Need to implement __buffer__ and __release_buffer__
-    # https://docs.python.org/3.13/reference/datamodel.html#emulating-buffer-types
-    @unittest.expectedFailure
+    @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)
@@ -1988,8 +1971,6 @@ def test_Buffer(self):
             self.assertFalse(issubclass(sample, Buffer))
         self.validate_abstract_methods(Buffer, '__buffer__')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_MutableSequence(self):
         for sample in [tuple, str, bytes]:
             self.assertNotIsInstance(sample(), MutableSequence)
@@ -1997,9 +1978,10 @@ def test_MutableSequence(self):
         for sample in [list, bytearray, deque]:
             self.assertIsInstance(sample(), MutableSequence)
             self.assertTrue(issubclass(sample, MutableSequence))
+        self.assertTrue(issubclass(array.array, MutableSequence))
         self.assertFalse(issubclass(str, MutableSequence))
-        self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',
-            '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')
+        self.validate_abstract_methods(MutableSequence, '__len__', '__getitem__',
+                                       '__setitem__', '__delitem__', 'insert')
 
     def test_MutableSequence_mixins(self):
         # Test the mixins of MutableSequence by creating a minimal concrete
@@ -2051,8 +2033,7 @@ def insert(self, index, value):
         self.assertEqual(len(mss), len(mss2))
         self.assertEqual(list(mss), list(mss2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_illegal_patma_flags(self):
         with self.assertRaises(TypeError):
             class Both(Collection):
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 51c834d798..bbaf3c5c19 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -108,7 +108,6 @@ def __getitem__(self, key):
         exec('z = a', g, d)
         self.assertEqual(d['z'], 12)
 
-    @unittest.skip("TODO: RUSTPYTHON; segmentation fault")
     def test_extended_arg(self):
         # default: 1000 * 2.5 = 2500 repetitions
         repeat = int(sys.getrecursionlimit() * 2.5)
@@ -138,7 +137,6 @@ def f(x):
     def test_argument_order(self):
         self.assertRaises(SyntaxError, exec, 'def f(a=1, b): pass')
 
-    @unittest.skip("TODO: RUSTPYTHON, thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseFloatError { kind: Invalid }'")
     def test_float_literals(self):
         # testing bad float literals
         self.assertRaises(SyntaxError, eval, "2e")
@@ -201,6 +199,8 @@ def test_literals_with_leading_zeroes(self):
         self.assertEqual(eval("0o777"), 511)
         self.assertEqual(eval("-0o0000010"), -8)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_int_literals_too_long(self):
         n = 3000
         source = f"a = 1\nb = 2\nc = {'3'*n}\nd = 4"
@@ -274,6 +274,8 @@ def test_none_assignment(self):
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
             self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_import(self):
         succeed = [
             'import sys',
@@ -821,6 +823,8 @@ def continue_in_while():
             self.assertEqual(None, opcodes[1].argval)
             self.assertEqual('RETURN_VALUE', opcodes[2].opname)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_consts_in_conditionals(self):
         def and_true(x):
             return True and x
@@ -844,6 +848,8 @@ 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 = [
             """\
@@ -886,6 +892,8 @@ def call():
         line1 = call.__code__.co_firstlineno + 1
         assert line1 not in [line for (_, _, line) in call.__code__.co_lines()]
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_lineno_after_implicit_return(self):
         TRUE = True
         # Don't use constant True or False, as compiler will remove test
@@ -920,6 +928,8 @@ def save_caller_frame():
                 func(save_caller_frame)
                 self.assertEqual(frame.f_lineno-frame.f_code.co_firstlineno, lastline)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_lineno_after_no_code(self):
         def no_code1():
             "doc string"
@@ -944,6 +954,8 @@ def get_code_lines(self, code):
                 last_line = line
         return res
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_lineno_attribute(self):
         def load_attr():
             return (
@@ -988,6 +1000,8 @@ def aug_store_attr():
                 code_lines = self.get_code_lines(func.__code__)
                 self.assertEqual(lines, code_lines)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_line_number_genexp(self):
 
         def return_genexp():
@@ -1002,6 +1016,8 @@ def return_genexp():
         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):
@@ -1061,6 +1077,8 @@ 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
     def test_compare_positions(self):
         for opname, op in [
             ("COMPARE_OP", "<"),
@@ -1361,64 +1379,66 @@ def check_stack_size(self, code):
         max_size = math.ceil(math.log(len(code.co_code)))
         self.assertLessEqual(code.co_stacksize, max_size)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_and(self):
         self.check_stack_size("x and " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_or(self):
         self.check_stack_size("x or " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_and_or(self):
         self.check_stack_size("x and x or " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_chained_comparison(self):
         self.check_stack_size("x < " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_if_else(self):
         self.check_stack_size("x if x else " * self.N + "x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_binop(self):
         self.check_stack_size("x + " * self.N + "x")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_list(self):
         self.check_stack_size("[" + "x, " * self.N + "x]")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_tuple(self):
         self.check_stack_size("(" + "x, " * self.N + "x)")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     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
     def test_func_args(self):
         self.check_stack_size("f(" + "x, " * self.N + ")")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_func_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("f(" +  ", ".join(kwargs) + ")")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_meth_args(self):
         self.check_stack_size("o.m(" + "x, " * self.N + ")")
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_meth_kwargs(self):
         kwargs = (f'a{i}=x' for i in range(self.N))
         self.check_stack_size("o.m(" +  ", ".join(kwargs) + ")")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_func_and(self):
         code = "def f(x):\n"
         code += "   x and x\n" * self.N
diff --git a/Lib/test/test_compileall.py b/Lib/test/test_compileall.py
index a490b8a1d5..9fa3dbc47e 100644
--- a/Lib/test/test_compileall.py
+++ b/Lib/test/test_compileall.py
@@ -325,8 +325,6 @@ def _test_ddir_only(self, *, ddir, parallel=True):
             self.assertEqual(mod_code_obj.co_filename, expected_in)
             self.assertIn(f'"{expected_in}"', os.fsdecode(err))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ddir_only_one_worker(self):
         """Recursive compile_dir ddir= contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="<a prefix>", parallel=False)
@@ -336,8 +334,6 @@ def test_ddir_multiple_workers(self):
         """Recursive compile_dir ddir= contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="<a prefix>", parallel=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ddir_empty_only_one_worker(self):
         """Recursive compile_dir ddir='' contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="", parallel=False)
@@ -347,8 +343,6 @@ def test_ddir_empty_multiple_workers(self):
         """Recursive compile_dir ddir='' contains package paths; bpo39769."""
         return self._test_ddir_only(ddir="", parallel=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_only(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
@@ -408,8 +402,6 @@ def test_prepend_only(self):
             str(err, encoding=sys.getdefaultencoding())
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_and_prepend(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
@@ -459,7 +451,6 @@ def test_multiple_optimization_levels(self):
                 except Exception:
                     pass
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_ignore_symlink_destination(self):
         # Create folders for allowed files, symlinks and prohibited area
@@ -888,8 +879,6 @@ def test_workers_available_cores(self, compile_dir):
             self.assertTrue(compile_dir.called)
             self.assertEqual(compile_dir.call_args[-1]['workers'], 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strip_and_prepend(self):
         fullpath = ["test", "build", "real", "path"]
         path = os.path.join(self.directory, *fullpath)
@@ -933,7 +922,6 @@ def test_multiple_optimization_levels(self):
                 except Exception:
                     pass
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_ignore_symlink_destination(self):
         # Create folders for allowed files, symlinks and prohibited area
diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index dd3c4f281a..86d075de8c 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -1,15 +1,19 @@
 import unittest
 import sys
 from test import support
-from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
-                               INVALID_UNDERSCORE_LITERALS)
+from test.support.testcase import ComplexesAreIdenticalMixin
+from test.support.numbers import (
+    VALID_UNDERSCORE_LITERALS,
+    INVALID_UNDERSCORE_LITERALS,
+)
 
 from random import random
-from math import atan2, isnan, copysign
+from math import isnan, copysign
 import operator
 
 INF = float("inf")
 NAN = float("nan")
+DBL_MAX = sys.float_info.max
 # These tests ensure that complex math does the right thing
 
 ZERO_DIVISION = (
@@ -20,7 +24,28 @@
     (1, 0+0j),
 )
 
-class ComplexTest(unittest.TestCase):
+class WithIndex:
+    def __init__(self, value):
+        self.value = value
+    def __index__(self):
+        return self.value
+
+class WithFloat:
+    def __init__(self, value):
+        self.value = value
+    def __float__(self):
+        return self.value
+
+class ComplexSubclass(complex):
+    pass
+
+class WithComplex:
+    def __init__(self, value):
+        self.value = value
+    def __complex__(self):
+        return self.value
+
+class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase):
 
     def assertAlmostEqual(self, a, b):
         if isinstance(a, complex):
@@ -49,29 +74,6 @@ def assertCloseAbs(self, x, y, eps=1e-9):
         # check that relative difference < eps
         self.assertTrue(abs((x-y)/y) < eps)
 
-    def assertFloatsAreIdentical(self, x, y):
-        """assert that floats x and y are identical, in the sense that:
-        (1) both x and y are nans, or
-        (2) both x and y are infinities, with the same sign, or
-        (3) both x and y are zeros, with the same sign, or
-        (4) x and y are both finite and nonzero, and x == y
-
-        """
-        msg = 'floats {!r} and {!r} are not identical'
-
-        if isnan(x) or isnan(y):
-            if isnan(x) and isnan(y):
-                return
-        elif x == y:
-            if x != 0.0:
-                return
-            # both zero; check that signs match
-            elif copysign(1.0, x) == copysign(1.0, y):
-                return
-            else:
-                msg += ': zeros have different signs'
-        self.fail(msg.format(x, y))
-
     def assertClose(self, x, y, eps=1e-9):
         """Return true iff complexes x and y "are close"."""
         self.assertCloseAbs(x.real, y.real, eps)
@@ -303,6 +305,11 @@ def test_pow(self):
                     except OverflowError:
                         pass
 
+        # gh-113841: possible undefined division by 0 in _Py_c_pow()
+        x, y = 9j, 33j**3
+        with self.assertRaises(OverflowError):
+            x**y
+
     def test_pow_with_small_integer_exponents(self):
         # Check that small integer exponents are handled identically
         # regardless of their type.
@@ -340,138 +347,93 @@ def test_boolcontext(self):
     def test_conjugate(self):
         self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_constructor(self):
-        class NS:
-            def __init__(self, value): self.value = value
-            def __complex__(self): return self.value
-        self.assertEqual(complex(NS(1+10j)), 1+10j)
-        self.assertRaises(TypeError, complex, NS(None))
-        self.assertRaises(TypeError, complex, {})
-        self.assertRaises(TypeError, complex, NS(1.5))
-        self.assertRaises(TypeError, complex, NS(1))
-        self.assertRaises(TypeError, complex, object())
-        self.assertRaises(TypeError, complex, NS(4.25+0.5j), object())
-
-        self.assertAlmostEqual(complex("1+10j"), 1+10j)
-        self.assertAlmostEqual(complex(10), 10+0j)
-        self.assertAlmostEqual(complex(10.0), 10+0j)
-        self.assertAlmostEqual(complex(10), 10+0j)
-        self.assertAlmostEqual(complex(10+0j), 10+0j)
-        self.assertAlmostEqual(complex(1,10), 1+10j)
-        self.assertAlmostEqual(complex(1,10), 1+10j)
-        self.assertAlmostEqual(complex(1,10.0), 1+10j)
-        self.assertAlmostEqual(complex(1,10), 1+10j)
-        self.assertAlmostEqual(complex(1,10), 1+10j)
-        self.assertAlmostEqual(complex(1,10.0), 1+10j)
-        self.assertAlmostEqual(complex(1.0,10), 1+10j)
-        self.assertAlmostEqual(complex(1.0,10), 1+10j)
-        self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
-        self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
-        self.assertAlmostEqual(complex(3.14), 3.14+0j)
-        self.assertAlmostEqual(complex(314), 314.0+0j)
-        self.assertAlmostEqual(complex(314), 314.0+0j)
-        self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
-        self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
-        self.assertAlmostEqual(complex(314, 0), 314.0+0j)
-        self.assertAlmostEqual(complex(314, 0), 314.0+0j)
-        self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
-        self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
-        self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
-        self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
-        self.assertAlmostEqual(complex("1"), 1+0j)
-        self.assertAlmostEqual(complex("1j"), 1j)
-        self.assertAlmostEqual(complex(),  0)
-        self.assertAlmostEqual(complex("-1"), -1)
-        self.assertAlmostEqual(complex("+1"), +1)
-        self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
-        self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
-        self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j)
-        self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
-        self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j)
-        self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j)
-        self.assertAlmostEqual(complex("J"), 1j)
-        self.assertAlmostEqual(complex("( j )"), 1j)
-        self.assertAlmostEqual(complex("+J"), 1j)
-        self.assertAlmostEqual(complex("( -j)"), -1j)
-        self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j)
-        self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j)
-        self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j)
-        self.assertEqual(complex('1-1j'), 1.0 - 1j)
-        self.assertEqual(complex('1J'), 1j)
-
-        class complex2(complex): pass
-        self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
-        self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
-        self.assertAlmostEqual(complex(real=17+23j), 17+23j)
-        self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
-        self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
+        def check(z, x, y):
+            self.assertIs(type(z), complex)
+            self.assertFloatsAreIdentical(z.real, x)
+            self.assertFloatsAreIdentical(z.imag, y)
+
+        check(complex(),  0.0, 0.0)
+        check(complex(10), 10.0, 0.0)
+        check(complex(4.25), 4.25, 0.0)
+        check(complex(4.25+0j), 4.25, 0.0)
+        check(complex(4.25+0.5j), 4.25, 0.5)
+        check(complex(ComplexSubclass(4.25+0.5j)), 4.25, 0.5)
+        check(complex(WithComplex(4.25+0.5j)), 4.25, 0.5)
+
+        check(complex(1, 10), 1.0, 10.0)
+        check(complex(1, 10.0), 1.0, 10.0)
+        check(complex(1, 4.25), 1.0, 4.25)
+        check(complex(1.0, 10), 1.0, 10.0)
+        check(complex(4.25, 10), 4.25, 10.0)
+        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.assertRaisesRegex(TypeError,
+                "second argument must be a 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)
+
+        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)
+        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)
 
         # check that the sign of a zero in the real or imaginary part
-        # is preserved when constructing from two floats.  (These checks
-        # are harmless on systems without support for signed zeros.)
-        def split_zeros(x):
-            """Function that produces different results for 0. and -0."""
-            return atan2(x, -1.)
-
-        self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
-        self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
-        self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
-        self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
-
-        c = 3.14 + 1j
-        self.assertTrue(complex(c) is c)
-        del c
-
-        self.assertRaises(TypeError, complex, "1", "1")
-        self.assertRaises(TypeError, complex, 1, "1")
-
-        # SF bug 543840:  complex(string) accepts strings with \0
-        # Fixed in 2.3.
-        self.assertRaises(ValueError, complex, '1+1j\0j')
-
-        self.assertRaises(TypeError, int, 5+3j)
-        self.assertRaises(TypeError, int, 5+3j)
-        self.assertRaises(TypeError, float, 5+3j)
-        self.assertRaises(ValueError, complex, "")
-        self.assertRaises(TypeError, complex, None)
-        self.assertRaisesRegex(TypeError, "not 'NoneType'", complex, None)
-        self.assertRaises(ValueError, complex, "\0")
-        self.assertRaises(ValueError, complex, "3\09")
-        self.assertRaises(TypeError, complex, "1", "2")
-        self.assertRaises(TypeError, complex, "1", 42)
-        self.assertRaises(TypeError, complex, 1, "2")
-        self.assertRaises(ValueError, complex, "1+")
-        self.assertRaises(ValueError, complex, "1+1j+1j")
-        self.assertRaises(ValueError, complex, "--")
-        self.assertRaises(ValueError, complex, "(1+2j")
-        self.assertRaises(ValueError, complex, "1+2j)")
-        self.assertRaises(ValueError, complex, "1+(2j)")
-        self.assertRaises(ValueError, complex, "(1+2j)123")
-        self.assertRaises(ValueError, complex, "x")
-        self.assertRaises(ValueError, complex, "1j+2")
-        self.assertRaises(ValueError, complex, "1e1ej")
-        self.assertRaises(ValueError, complex, "1e++1ej")
-        self.assertRaises(ValueError, complex, ")1+2j(")
-        self.assertRaisesRegex(
-            TypeError,
+        # is preserved when constructing from two floats.
+        for x in 1.0, -1.0:
+            for y in 0.0, -0.0:
+                check(complex(x, y), x, y)
+                check(complex(y, x), y, x)
+
+        c = complex(4.25, 1.5)
+        self.assertIs(complex(c), c)
+        c2 = ComplexSubclass(c)
+        self.assertEqual(c2, c)
+        self.assertIs(type(c2), ComplexSubclass)
+        del c, c2
+
+        self.assertRaisesRegex(TypeError,
             "first argument must be a string or a number, not 'dict'",
-            complex, {1:2}, 1)
-        self.assertRaisesRegex(
-            TypeError,
+            complex, {})
+        self.assertRaisesRegex(TypeError,
+            "first 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'",
+            complex, {1:2}, 0)
+        self.assertRaisesRegex(TypeError,
+            "can't take second arg if first is a string",
+            complex, '1', 0)
+        self.assertRaisesRegex(TypeError,
             "second argument must be a number, not 'dict'",
-            complex, 1, {1:2})
-        # the following three are accepted by Python 2.6
-        self.assertRaises(ValueError, complex, "1..1j")
-        self.assertRaises(ValueError, complex, "1.11.1j")
-        self.assertRaises(ValueError, complex, "1e1.1j")
-
-        # check that complex accepts long unicode strings
-        self.assertEqual(type(complex("1"*500)), complex)
-        # check whitespace processing
-        self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j)
-        # Invalid unicode string
-        # See bpo-34087
-        self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f')
+            complex, 0, {1:2})
+        self.assertRaisesRegex(TypeError,
+                "second arg can't be a string",
+            complex, 0, '1')
+
+        self.assertRaises(TypeError, complex, WithComplex(1.5))
+        self.assertRaises(TypeError, complex, WithComplex(1))
+        self.assertRaises(TypeError, complex, WithComplex(None))
+        self.assertRaises(TypeError, complex, WithComplex(4.25+0j), object())
+        self.assertRaises(TypeError, complex, WithComplex(1.5), object())
+        self.assertRaises(TypeError, complex, WithComplex(1), object())
+        self.assertRaises(TypeError, complex, WithComplex(None), object())
 
         class EvilExc(Exception):
             pass
@@ -482,33 +444,33 @@ def __complex__(self):
 
         self.assertRaises(EvilExc, complex, evilcomplex())
 
-        class float2:
-            def __init__(self, value):
-                self.value = value
-            def __float__(self):
-                return self.value
-
-        self.assertAlmostEqual(complex(float2(42.)), 42)
-        self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
-        self.assertRaises(TypeError, complex, float2(None))
-
-        class MyIndex:
-            def __init__(self, value):
-                self.value = value
-            def __index__(self):
-                return self.value
-
-        self.assertAlmostEqual(complex(MyIndex(42)), 42.0+0.0j)
-        self.assertAlmostEqual(complex(123, MyIndex(42)), 123.0+42.0j)
-        self.assertRaises(OverflowError, complex, MyIndex(2**2000))
-        self.assertRaises(OverflowError, complex, 123, MyIndex(2**2000))
+        check(complex(WithFloat(4.25)), 4.25, 0.0)
+        check(complex(WithFloat(4.25), 1.5), 4.25, 1.5)
+        check(complex(1.5, WithFloat(4.25)), 1.5, 4.25)
+        self.assertRaises(TypeError, complex, WithFloat(42))
+        self.assertRaises(TypeError, complex, WithFloat(42), 1.5)
+        self.assertRaises(TypeError, complex, 1.5, WithFloat(42))
+        self.assertRaises(TypeError, complex, WithFloat(None))
+        self.assertRaises(TypeError, complex, WithFloat(None), 1.5)
+        self.assertRaises(TypeError, complex, 1.5, WithFloat(None))
+
+        check(complex(WithIndex(42)), 42.0, 0.0)
+        check(complex(WithIndex(42), 1.5), 42.0, 1.5)
+        check(complex(1.5, WithIndex(42)), 1.5, 42.0)
+        self.assertRaises(OverflowError, complex, WithIndex(2**2000))
+        self.assertRaises(OverflowError, complex, WithIndex(2**2000), 1.5)
+        self.assertRaises(OverflowError, complex, 1.5, WithIndex(2**2000))
+        self.assertRaises(TypeError, complex, WithIndex(None))
+        self.assertRaises(TypeError, complex, WithIndex(None), 1.5)
+        self.assertRaises(TypeError, complex, 1.5, WithIndex(None))
 
         class MyInt:
             def __int__(self):
                 return 42
 
         self.assertRaises(TypeError, complex, MyInt())
-        self.assertRaises(TypeError, complex, 123, MyInt())
+        self.assertRaises(TypeError, complex, MyInt(), 1.5)
+        self.assertRaises(TypeError, complex, 1.5, MyInt())
 
         class complex0(complex):
             """Test usage of __complex__() when inheriting from 'complex'"""
@@ -528,9 +490,9 @@ class complex2(complex):
             def __complex__(self):
                 return None
 
-        self.assertEqual(complex(complex0(1j)), 42j)
+        check(complex(complex0(1j)), 0.0, 42.0)
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(complex(complex1(1j)), 2j)
+            check(complex(complex1(1j)), 0.0, 2.0)
         self.assertRaises(TypeError, complex, complex2(1j))
 
     def test___complex__(self):
@@ -538,36 +500,93 @@ def test___complex__(self):
         self.assertEqual(z.__complex__(), z)
         self.assertEqual(type(z.__complex__()), complex)
 
-        class complex_subclass(complex):
-            pass
-
-        z = complex_subclass(3 + 4j)
+        z = ComplexSubclass(3 + 4j)
         self.assertEqual(z.__complex__(), 3 + 4j)
         self.assertEqual(type(z.__complex__()), complex)
 
     @support.requires_IEEE_754
     def test_constructor_special_numbers(self):
-        class complex2(complex):
-            pass
         for x in 0.0, -0.0, INF, -INF, NAN:
             for y in 0.0, -0.0, INF, -INF, NAN:
                 with self.subTest(x=x, y=y):
                     z = complex(x, y)
                     self.assertFloatsAreIdentical(z.real, x)
                     self.assertFloatsAreIdentical(z.imag, y)
-                    z = complex2(x, y)
-                    self.assertIs(type(z), complex2)
+                    z = ComplexSubclass(x, y)
+                    self.assertIs(type(z), ComplexSubclass)
                     self.assertFloatsAreIdentical(z.real, x)
                     self.assertFloatsAreIdentical(z.imag, y)
-                    z = complex(complex2(x, y))
+                    z = complex(ComplexSubclass(x, y))
                     self.assertIs(type(z), complex)
                     self.assertFloatsAreIdentical(z.real, x)
                     self.assertFloatsAreIdentical(z.imag, y)
-                    z = complex2(complex(x, y))
-                    self.assertIs(type(z), complex2)
+                    z = ComplexSubclass(complex(x, y))
+                    self.assertIs(type(z), ComplexSubclass)
                     self.assertFloatsAreIdentical(z.real, x)
                     self.assertFloatsAreIdentical(z.imag, y)
 
+    def test_constructor_from_string(self):
+        def check(z, x, y):
+            self.assertIs(type(z), complex)
+            self.assertFloatsAreIdentical(z.real, x)
+            self.assertFloatsAreIdentical(z.imag, y)
+
+        check(complex("1"), 1.0, 0.0)
+        check(complex("1j"), 0.0, 1.0)
+        check(complex("-1"), -1.0, 0.0)
+        check(complex("+1"), 1.0, 0.0)
+        check(complex("1+2j"), 1.0, 2.0)
+        check(complex("(1+2j)"), 1.0, 2.0)
+        check(complex("(1.5+4.25j)"), 1.5, 4.25)
+        check(complex("4.25+1J"), 4.25, 1.0)
+        check(complex(" ( +4.25-6J )"), 4.25, -6.0)
+        check(complex(" ( +4.25-J )"), 4.25, -1.0)
+        check(complex(" ( +4.25+j )"), 4.25, 1.0)
+        check(complex("J"), 0.0, 1.0)
+        check(complex("( j )"), 0.0, 1.0)
+        check(complex("+J"), 0.0, 1.0)
+        check(complex("( -j)"), 0.0, -1.0)
+        check(complex('1-1j'), 1.0, -1.0)
+        check(complex('1J'), 0.0, 1.0)
+
+        check(complex('1e-500'), 0.0, 0.0)
+        check(complex('-1e-500j'), 0.0, -0.0)
+        check(complex('1e-500+1e-500j'), 0.0, 0.0)
+        check(complex('-1e-500+1e-500j'), -0.0, 0.0)
+        check(complex('1e-500-1e-500j'), 0.0, -0.0)
+        check(complex('-1e-500-1e-500j'), -0.0, -0.0)
+
+        # SF bug 543840:  complex(string) accepts strings with \0
+        # Fixed in 2.3.
+        self.assertRaises(ValueError, complex, '1+1j\0j')
+        self.assertRaises(ValueError, complex, "")
+        self.assertRaises(ValueError, complex, "\0")
+        self.assertRaises(ValueError, complex, "3\09")
+        self.assertRaises(ValueError, complex, "1+")
+        self.assertRaises(ValueError, complex, "1+1j+1j")
+        self.assertRaises(ValueError, complex, "--")
+        self.assertRaises(ValueError, complex, "(1+2j")
+        self.assertRaises(ValueError, complex, "1+2j)")
+        self.assertRaises(ValueError, complex, "1+(2j)")
+        self.assertRaises(ValueError, complex, "(1+2j)123")
+        self.assertRaises(ValueError, complex, "x")
+        self.assertRaises(ValueError, complex, "1j+2")
+        self.assertRaises(ValueError, complex, "1e1ej")
+        self.assertRaises(ValueError, complex, "1e++1ej")
+        self.assertRaises(ValueError, complex, ")1+2j(")
+        # the following three are accepted by Python 2.6
+        self.assertRaises(ValueError, complex, "1..1j")
+        self.assertRaises(ValueError, complex, "1.11.1j")
+        self.assertRaises(ValueError, complex, "1e1.1j")
+
+        # check that complex accepts long unicode strings
+        self.assertIs(type(complex("1"*500)), complex)
+        # check whitespace processing
+        self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j)
+        # Invalid unicode string
+        # See bpo-34087
+        self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f')
+
     def test_constructor_negative_nans_from_string(self):
         self.assertEqual(copysign(1., complex("-nan").real), -1.)
         self.assertEqual(copysign(1., complex("-nanj").imag), -1.)
@@ -589,7 +608,7 @@ def test_underscores(self):
     def test_hash(self):
         for x in range(-30, 30):
             self.assertEqual(hash(x), hash(complex(x, 0)))
-            x /= 3.0    # now check against floating point
+            x /= 3.0    # now check against floating-point
             self.assertEqual(hash(x), hash(complex(x, 0.)))
 
         self.assertNotEqual(hash(2000005 - 1j), -1)
@@ -599,6 +618,8 @@ def test_abs(self):
         for num in nums:
             self.assertAlmostEqual((num.real**2 + num.imag**2)  ** 0.5, abs(num))
 
+        self.assertRaises(OverflowError, abs, complex(DBL_MAX, DBL_MAX))
+
     def test_repr_str(self):
         def test(v, expected, test_fn=self.assertEqual):
             test_fn(repr(v), expected)
@@ -644,9 +665,6 @@ def test(v, expected, test_fn=self.assertEqual):
         test(complex(-0., -0.), "(-0-0j)")
 
     def test_pos(self):
-        class ComplexSubclass(complex):
-            pass
-
         self.assertEqual(+(1+6j), 1+6j)
         self.assertEqual(+ComplexSubclass(1, 6), 1+6j)
         self.assertIs(type(+ComplexSubclass(1, 6)), complex)
@@ -666,8 +684,8 @@ def test_getnewargs(self):
     def test_plus_minus_0j(self):
         # test that -0j and 0j literals are not identified
         z1, z2 = 0j, -0j
-        self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.))
-        self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.))
+        self.assertFloatsAreIdentical(z1.imag, 0.0)
+        self.assertFloatsAreIdentical(z2.imag, -0.0)
 
     @support.requires_IEEE_754
     def test_negated_imaginary_literal(self):
@@ -702,8 +720,7 @@ def test_repr_roundtrip(self):
             for y in vals:
                 z = complex(x, y)
                 roundtrip = complex(repr(z))
-                self.assertFloatsAreIdentical(z.real, roundtrip.real)
-                self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
+                self.assertComplexesAreIdentical(z, roundtrip)
 
         # if we predefine some constants, then eval(repr(z)) should
         # also work, except that it might change the sign of zeros
diff --git a/Lib/test/test_concurrent_futures/__init__.py b/Lib/test/test_concurrent_futures/__init__.py
new file mode 100644
index 0000000000..b38bd38d33
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/__init__.py
@@ -0,0 +1,18 @@
+import os.path
+import unittest
+from test import support
+from test.support import threading_helper
+
+
+# Adjust if we ever have a platform with processes but not threads.
+threading_helper.requires_working_threading(module=True)
+
+
+if support.check_sanitizer(address=True, memory=True):
+    # gh-90791: Skip the test because it is too slow when Python is built
+    # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
+    raise unittest.SkipTest("test too slow on ASAN/MSAN build")
+
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_concurrent_futures/executor.py b/Lib/test/test_concurrent_futures/executor.py
new file mode 100644
index 0000000000..7442d3bee5
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/executor.py
@@ -0,0 +1,162 @@
+import threading
+import time
+import unittest
+import weakref
+from concurrent import futures
+from test import support
+from test.support import Py_GIL_DISABLED
+
+
+def mul(x, y):
+    return x * y
+
+def capture(*args, **kwargs):
+    return args, kwargs
+
+
+class MyObject(object):
+    def my_method(self):
+        pass
+
+
+def make_dummy_object(_):
+    return MyObject()
+
+
+# Used in test_swallows_falsey_exceptions
+def raiser(exception, msg='std'):
+    raise exception(msg)
+
+
+class FalseyBoolException(Exception):
+    def __bool__(self):
+        return False
+
+
+class FalseyLenException(Exception):
+    def __len__(self):
+        return 0
+
+
+class ExecutorTest:
+    # Executor.shutdown() and context manager usage is tested by
+    # ExecutorShutdownTest.
+    def test_submit(self):
+        future = self.executor.submit(pow, 2, 8)
+        self.assertEqual(256, future.result())
+
+    def test_submit_keyword(self):
+        future = self.executor.submit(mul, 2, y=8)
+        self.assertEqual(16, future.result())
+        future = self.executor.submit(capture, 1, self=2, fn=3)
+        self.assertEqual(future.result(), ((1,), {'self': 2, 'fn': 3}))
+        with self.assertRaises(TypeError):
+            self.executor.submit(fn=capture, arg=1)
+        with self.assertRaises(TypeError):
+            self.executor.submit(arg=1)
+
+    def test_map(self):
+        self.assertEqual(
+                list(self.executor.map(pow, range(10), range(10))),
+                list(map(pow, range(10), range(10))))
+
+        self.assertEqual(
+                list(self.executor.map(pow, range(10), range(10), chunksize=3)),
+                list(map(pow, range(10), range(10))))
+
+    def test_map_exception(self):
+        i = self.executor.map(divmod, [1, 1, 1, 1], [2, 3, 0, 5])
+        self.assertEqual(i.__next__(), (0, 1))
+        self.assertEqual(i.__next__(), (0, 1))
+        self.assertRaises(ZeroDivisionError, i.__next__)
+
+    @support.requires_resource('walltime')
+    def test_map_timeout(self):
+        results = []
+        try:
+            for i in self.executor.map(time.sleep,
+                                       [0, 0, 6],
+                                       timeout=5):
+                results.append(i)
+        except futures.TimeoutError:
+            pass
+        else:
+            self.fail('expected TimeoutError')
+
+        self.assertEqual([None, None], results)
+
+    def test_shutdown_race_issue12456(self):
+        # Issue #12456: race condition at shutdown where trying to post a
+        # sentinel in the call queue blocks (the queue is full while processes
+        # have exited).
+        self.executor.map(str, [2] * (self.worker_count + 1))
+        self.executor.shutdown()
+
+    @support.cpython_only
+    def test_no_stale_references(self):
+        # Issue #16284: check that the executors don't unnecessarily hang onto
+        # references.
+        my_object = MyObject()
+        my_object_collected = threading.Event()
+        def set_event():
+            if Py_GIL_DISABLED:
+                # gh-117688 Avoid deadlock by setting the event in a
+                # background thread. The current thread may be in the middle
+                # of the my_object_collected.wait() call, which holds locks
+                # needed by my_object_collected.set().
+                threading.Thread(target=my_object_collected.set).start()
+            else:
+                my_object_collected.set()
+        my_object_callback = weakref.ref(my_object, lambda obj: set_event())
+        # Deliberately discarding the future.
+        self.executor.submit(my_object.my_method)
+        del my_object
+
+        if Py_GIL_DISABLED:
+            # Due to biased reference counting, my_object might only be
+            # deallocated while the thread that created it runs -- if the
+            # thread is paused waiting on an event, it may not merge the
+            # refcount of the queued object. For that reason, we alternate
+            # between running the GC and waiting for the event.
+            wait_time = 0
+            collected = False
+            while not collected and wait_time <= support.SHORT_TIMEOUT:
+                support.gc_collect()
+                collected = my_object_collected.wait(timeout=1.0)
+                wait_time += 1.0
+        else:
+            collected = my_object_collected.wait(timeout=support.SHORT_TIMEOUT)
+        self.assertTrue(collected,
+                        "Stale reference not collected within timeout.")
+
+    def test_max_workers_negative(self):
+        for number in (0, -1):
+            with self.assertRaisesRegex(ValueError,
+                                        "max_workers must be greater "
+                                        "than 0"):
+                self.executor_type(max_workers=number)
+
+    def test_free_reference(self):
+        # Issue #14406: Result iterator should not keep an internal
+        # reference to result objects.
+        for obj in self.executor.map(make_dummy_object, range(10)):
+            wr = weakref.ref(obj)
+            del obj
+            support.gc_collect()  # For PyPy or other GCs.
+
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+                if wr() is None:
+                    break
+
+    def test_swallows_falsey_exceptions(self):
+        # see gh-132063: Prevent exceptions that evaluate as falsey
+        # from being ignored.
+        # Recall: `x` is falsey if `len(x)` returns 0 or `bool(x)` returns False.
+
+        msg = 'boolbool'
+        with self.assertRaisesRegex(FalseyBoolException, msg):
+            self.executor.submit(raiser, FalseyBoolException, msg).result()
+
+        msg = 'lenlen'
+        with self.assertRaisesRegex(FalseyLenException, msg):
+            self.executor.submit(raiser, FalseyLenException, msg).result()
diff --git a/Lib/test/test_concurrent_futures/test_as_completed.py b/Lib/test/test_concurrent_futures/test_as_completed.py
new file mode 100644
index 0000000000..c90b0021d8
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_as_completed.py
@@ -0,0 +1,118 @@
+import itertools
+import time
+import unittest
+import weakref
+from concurrent import futures
+from concurrent.futures._base import (
+    CANCELLED_AND_NOTIFIED, FINISHED, Future)
+
+from test import support
+
+from .util import (
+    PENDING_FUTURE, RUNNING_FUTURE,
+    CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE, SUCCESSFUL_FUTURE,
+    create_future, create_executor_tests, setup_module)
+
+
+def mul(x, y):
+    return x * y
+
+
+class AsCompletedTests:
+    def test_no_timeout(self):
+        future1 = self.executor.submit(mul, 2, 21)
+        future2 = self.executor.submit(mul, 7, 6)
+
+        completed = set(futures.as_completed(
+                [CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 SUCCESSFUL_FUTURE,
+                 future1, future2]))
+        self.assertEqual(set(
+                [CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 SUCCESSFUL_FUTURE,
+                 future1, future2]),
+                completed)
+
+    def test_future_times_out(self):
+        """Test ``futures.as_completed`` timing out before
+        completing it's final future."""
+        already_completed = {CANCELLED_AND_NOTIFIED_FUTURE,
+                             EXCEPTION_FUTURE,
+                             SUCCESSFUL_FUTURE}
+
+        # Windows clock resolution is around 15.6 ms
+        short_timeout = 0.100
+        for timeout in (0, short_timeout):
+            with self.subTest(timeout):
+
+                completed_futures = set()
+                future = self.executor.submit(time.sleep, short_timeout * 10)
+
+                try:
+                    for f in futures.as_completed(
+                        already_completed | {future},
+                        timeout
+                    ):
+                        completed_futures.add(f)
+                except futures.TimeoutError:
+                    pass
+
+                # Check that ``future`` wasn't completed.
+                self.assertEqual(completed_futures, already_completed)
+
+    def test_duplicate_futures(self):
+        # Issue 20367. Duplicate futures should not raise exceptions or give
+        # duplicate responses.
+        # Issue #31641: accept arbitrary iterables.
+        future1 = self.executor.submit(time.sleep, 2)
+        completed = [
+            f for f in futures.as_completed(itertools.repeat(future1, 3))
+        ]
+        self.assertEqual(len(completed), 1)
+
+    def test_free_reference_yielded_future(self):
+        # Issue #14406: Generator should not keep references
+        # to finished futures.
+        futures_list = [Future() for _ in range(8)]
+        futures_list.append(create_future(state=CANCELLED_AND_NOTIFIED))
+        futures_list.append(create_future(state=FINISHED, result=42))
+
+        with self.assertRaises(futures.TimeoutError):
+            for future in futures.as_completed(futures_list, timeout=0):
+                futures_list.remove(future)
+                wr = weakref.ref(future)
+                del future
+                support.gc_collect()  # For PyPy or other GCs.
+                self.assertIsNone(wr())
+
+        futures_list[0].set_result("test")
+        for future in futures.as_completed(futures_list):
+            futures_list.remove(future)
+            wr = weakref.ref(future)
+            del future
+            support.gc_collect()  # For PyPy or other GCs.
+            self.assertIsNone(wr())
+            if futures_list:
+                futures_list[0].set_result("test")
+
+    def test_correct_timeout_exception_msg(self):
+        futures_list = [CANCELLED_AND_NOTIFIED_FUTURE, PENDING_FUTURE,
+                        RUNNING_FUTURE, SUCCESSFUL_FUTURE]
+
+        with self.assertRaises(futures.TimeoutError) as cm:
+            list(futures.as_completed(futures_list, timeout=0))
+
+        self.assertEqual(str(cm.exception), '2 (of 4) futures unfinished')
+
+
+create_executor_tests(globals(), AsCompletedTests)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_deadlock.py b/Lib/test/test_concurrent_futures/test_deadlock.py
new file mode 100644
index 0000000000..dcc1d68563
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_deadlock.py
@@ -0,0 +1,332 @@
+import contextlib
+import queue
+import signal
+import sys
+import time
+import unittest
+import unittest.mock
+from pickle import PicklingError
+from concurrent import futures
+from concurrent.futures.process import BrokenProcessPool, _ThreadWakeup
+
+from test import support
+
+from .util import (
+    create_executor_tests, setup_module,
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin)
+
+
+def _crash(delay=None):
+    """Induces a segfault."""
+    if delay:
+        time.sleep(delay)
+    import faulthandler
+    faulthandler.disable()
+    faulthandler._sigsegv()
+
+
+def _crash_with_data(data):
+    """Induces a segfault with dummy data in input."""
+    _crash()
+
+
+def _exit():
+    """Induces a sys exit with exitcode 1."""
+    sys.exit(1)
+
+
+def _raise_error(Err):
+    """Function that raises an Exception in process."""
+    raise Err()
+
+
+def _raise_error_ignore_stderr(Err):
+    """Function that raises an Exception in process and ignores stderr."""
+    import io
+    sys.stderr = io.StringIO()
+    raise Err()
+
+
+def _return_instance(cls):
+    """Function that returns a instance of cls."""
+    return cls()
+
+
+class CrashAtPickle(object):
+    """Bad object that triggers a segfault at pickling time."""
+    def __reduce__(self):
+        _crash()
+
+
+class CrashAtUnpickle(object):
+    """Bad object that triggers a segfault at unpickling time."""
+    def __reduce__(self):
+        return _crash, ()
+
+
+class ExitAtPickle(object):
+    """Bad object that triggers a process exit at pickling time."""
+    def __reduce__(self):
+        _exit()
+
+
+class ExitAtUnpickle(object):
+    """Bad object that triggers a process exit at unpickling time."""
+    def __reduce__(self):
+        return _exit, ()
+
+
+class ErrorAtPickle(object):
+    """Bad object that triggers an error at pickling time."""
+    def __reduce__(self):
+        from pickle import PicklingError
+        raise PicklingError("Error in pickle")
+
+
+class ErrorAtUnpickle(object):
+    """Bad object that triggers an error at unpickling time."""
+    def __reduce__(self):
+        from pickle import UnpicklingError
+        return _raise_error_ignore_stderr, (UnpicklingError, )
+
+
+class ExecutorDeadlockTest:
+    TIMEOUT = support.LONG_TIMEOUT
+
+    def _fail_on_deadlock(self, executor):
+        # If we did not recover before TIMEOUT seconds, consider that the
+        # executor is in a deadlock state and forcefully clean all its
+        # composants.
+        import faulthandler
+        from tempfile import TemporaryFile
+        with TemporaryFile(mode="w+") as f:
+            faulthandler.dump_traceback(file=f)
+            f.seek(0)
+            tb = f.read()
+        for p in executor._processes.values():
+            p.terminate()
+        # This should be safe to call executor.shutdown here as all possible
+        # deadlocks should have been broken.
+        executor.shutdown(wait=True)
+        print(f"\nTraceback:\n {tb}", file=sys.__stderr__)
+        self.fail(f"Executor deadlock:\n\n{tb}")
+
+
+    def _check_crash(self, error, func, *args, ignore_stderr=False):
+        # test for deadlock caused by crashes in a pool
+        self.executor.shutdown(wait=True)
+
+        executor = self.executor_type(
+            max_workers=2, mp_context=self.get_context())
+        res = executor.submit(func, *args)
+
+        if ignore_stderr:
+            cm = support.captured_stderr()
+        else:
+            cm = contextlib.nullcontext()
+
+        try:
+            with self.assertRaises(error):
+                with cm:
+                    res.result(timeout=self.TIMEOUT)
+        except futures.TimeoutError:
+            # If we did not recover before TIMEOUT seconds,
+            # consider that the executor is in a deadlock state
+            self._fail_on_deadlock(executor)
+        executor.shutdown(wait=True)
+
+    def test_error_at_task_pickle(self):
+        # Check problem occurring while pickling a task in
+        # the task_handler thread
+        self._check_crash(PicklingError, id, ErrorAtPickle())
+
+    def test_exit_at_task_unpickle(self):
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, ExitAtUnpickle())
+
+    def test_error_at_task_unpickle(self):
+        # gh-109832: Restore stderr overridden by _raise_error_ignore_stderr()
+        self.addCleanup(setattr, sys, 'stderr', sys.stderr)
+
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, ErrorAtUnpickle())
+
+    def test_crash_at_task_unpickle(self):
+        # Check problem occurring while unpickling a task on workers
+        self._check_crash(BrokenProcessPool, id, CrashAtUnpickle())
+
+    def test_crash_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(BrokenProcessPool, _crash)
+
+    def test_exit_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(SystemExit, _exit)
+
+    def test_error_during_func_exec_on_worker(self):
+        # Check problem occurring during func execution on workers
+        self._check_crash(RuntimeError, _raise_error, RuntimeError)
+
+    def test_crash_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(BrokenProcessPool, _return_instance, CrashAtPickle)
+
+    def test_exit_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(SystemExit, _return_instance, ExitAtPickle)
+
+    def test_error_during_result_pickle_on_worker(self):
+        # Check problem occurring while pickling a task result
+        # on workers
+        self._check_crash(PicklingError, _return_instance, ErrorAtPickle)
+
+    def test_error_during_result_unpickle_in_result_handler(self):
+        # gh-109832: Restore stderr overridden by _raise_error_ignore_stderr()
+        self.addCleanup(setattr, sys, 'stderr', sys.stderr)
+
+        # Check problem occurring while unpickling a task in
+        # the result_handler thread
+        self._check_crash(BrokenProcessPool,
+                          _return_instance, ErrorAtUnpickle,
+                          ignore_stderr=True)
+
+    def test_exit_during_result_unpickle_in_result_handler(self):
+        # Check problem occurring while unpickling a task in
+        # the result_handler thread
+        self._check_crash(BrokenProcessPool, _return_instance, ExitAtUnpickle)
+
+    def test_shutdown_deadlock(self):
+        # Test that the pool calling shutdown do not cause deadlock
+        # if a worker fails after the shutdown call.
+        self.executor.shutdown(wait=True)
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+            f = executor.submit(_crash, delay=.1)
+            executor.shutdown(wait=True)
+            with self.assertRaises(BrokenProcessPool):
+                f.result()
+
+    def test_shutdown_deadlock_pickle(self):
+        # Test that the pool calling shutdown with wait=False does not cause
+        # a deadlock if a task fails at pickle after the shutdown call.
+        # Reported in bpo-39104.
+        self.executor.shutdown(wait=True)
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+
+            # Start the executor and get the executor_manager_thread to collect
+            # the threads and avoid dangling thread that should be cleaned up
+            # asynchronously.
+            executor.submit(id, 42).result()
+            executor_manager = executor._executor_manager_thread
+
+            # Submit a task that fails at pickle and shutdown the executor
+            # without waiting
+            f = executor.submit(id, ErrorAtPickle())
+            executor.shutdown(wait=False)
+            with self.assertRaises(PicklingError):
+                f.result()
+
+        # Make sure the executor is eventually shutdown and do not leave
+        # dangling threads
+        executor_manager.join()
+
+    def test_crash_big_data(self):
+        # Test that there is a clean exception instad of a deadlock when a
+        # child process crashes while some data is being written into the
+        # queue.
+        # https://github.com/python/cpython/issues/94777
+        self.executor.shutdown(wait=True)
+        data = "a" * support.PIPE_MAX_SIZE
+        with self.executor_type(max_workers=2,
+                                mp_context=self.get_context()) as executor:
+            self.executor = executor  # Allow clean up in fail_on_deadlock
+            with self.assertRaises(BrokenProcessPool):
+                list(executor.map(_crash_with_data, [data] * 10))
+
+        executor.shutdown(wait=True)
+
+    def test_gh105829_should_not_deadlock_if_wakeup_pipe_full(self):
+        # Issue #105829: The _ExecutorManagerThread wakeup pipe could
+        # fill up and block. See: https://github.com/python/cpython/issues/105829
+
+        # Lots of cargo culting while writing this test, apologies if
+        # something is really stupid...
+
+        self.executor.shutdown(wait=True)
+
+        if not hasattr(signal, 'alarm'):
+            raise unittest.SkipTest(
+                "Tested platform does not support the alarm signal")
+
+        def timeout(_signum, _frame):
+            import faulthandler
+            faulthandler.dump_traceback()
+
+            raise RuntimeError("timed out while submitting jobs?")
+
+        thread_run = futures.process._ExecutorManagerThread.run
+        def mock_run(self):
+            # Delay thread startup so the wakeup pipe can fill up and block
+            time.sleep(3)
+            thread_run(self)
+
+        class MockWakeup(_ThreadWakeup):
+            """Mock wakeup object to force the wakeup to block"""
+            def __init__(self):
+                super().__init__()
+                self._dummy_queue = queue.Queue(maxsize=1)
+
+            def wakeup(self):
+                self._dummy_queue.put(None, block=True)
+                super().wakeup()
+
+            def clear(self):
+                super().clear()
+                try:
+                    while True:
+                        self._dummy_queue.get_nowait()
+                except queue.Empty:
+                    pass
+
+        with (unittest.mock.patch.object(futures.process._ExecutorManagerThread,
+                                         'run', mock_run),
+              unittest.mock.patch('concurrent.futures.process._ThreadWakeup',
+                                  MockWakeup)):
+            with self.executor_type(max_workers=2,
+                                    mp_context=self.get_context()) as executor:
+                self.executor = executor  # Allow clean up in fail_on_deadlock
+
+                job_num = 100
+                job_data = range(job_num)
+
+                # Need to use sigalarm for timeout detection because
+                # Executor.submit is not guarded by any timeout (both
+                # self._work_ids.put(self._queue_count) and
+                # self._executor_manager_thread_wakeup.wakeup() might
+                # timeout, maybe more?). In this specific case it was
+                # the wakeup call that deadlocked on a blocking pipe.
+                old_handler = signal.signal(signal.SIGALRM, timeout)
+                try:
+                    signal.alarm(int(self.TIMEOUT))
+                    self.assertEqual(job_num, len(list(executor.map(int, job_data))))
+                finally:
+                    signal.alarm(0)
+                    signal.signal(signal.SIGALRM, old_handler)
+
+
+create_executor_tests(globals(), ExecutorDeadlockTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_future.py b/Lib/test/test_concurrent_futures/test_future.py
new file mode 100644
index 0000000000..4066ea1ee4
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_future.py
@@ -0,0 +1,291 @@
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures._base import (
+    PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED, Future)
+
+from test import support
+
+from .util import (
+    PENDING_FUTURE, RUNNING_FUTURE, CANCELLED_FUTURE,
+    CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE, SUCCESSFUL_FUTURE,
+    BaseTestCase, create_future, setup_module)
+
+
+class FutureTests(BaseTestCase):
+    def test_done_callback_with_result(self):
+        callback_result = None
+        def fn(callback_future):
+            nonlocal callback_result
+            callback_result = callback_future.result()
+
+        f = Future()
+        f.add_done_callback(fn)
+        f.set_result(5)
+        self.assertEqual(5, callback_result)
+
+    def test_done_callback_with_exception(self):
+        callback_exception = None
+        def fn(callback_future):
+            nonlocal callback_exception
+            callback_exception = callback_future.exception()
+
+        f = Future()
+        f.add_done_callback(fn)
+        f.set_exception(Exception('test'))
+        self.assertEqual(('test',), callback_exception.args)
+
+    def test_done_callback_with_cancel(self):
+        was_cancelled = None
+        def fn(callback_future):
+            nonlocal was_cancelled
+            was_cancelled = callback_future.cancelled()
+
+        f = Future()
+        f.add_done_callback(fn)
+        self.assertTrue(f.cancel())
+        self.assertTrue(was_cancelled)
+
+    def test_done_callback_raises(self):
+        with support.captured_stderr() as stderr:
+            raising_was_called = False
+            fn_was_called = False
+
+            def raising_fn(callback_future):
+                nonlocal raising_was_called
+                raising_was_called = True
+                raise Exception('doh!')
+
+            def fn(callback_future):
+                nonlocal fn_was_called
+                fn_was_called = True
+
+            f = Future()
+            f.add_done_callback(raising_fn)
+            f.add_done_callback(fn)
+            f.set_result(5)
+            self.assertTrue(raising_was_called)
+            self.assertTrue(fn_was_called)
+            self.assertIn('Exception: doh!', stderr.getvalue())
+
+    def test_done_callback_already_successful(self):
+        callback_result = None
+        def fn(callback_future):
+            nonlocal callback_result
+            callback_result = callback_future.result()
+
+        f = Future()
+        f.set_result(5)
+        f.add_done_callback(fn)
+        self.assertEqual(5, callback_result)
+
+    def test_done_callback_already_failed(self):
+        callback_exception = None
+        def fn(callback_future):
+            nonlocal callback_exception
+            callback_exception = callback_future.exception()
+
+        f = Future()
+        f.set_exception(Exception('test'))
+        f.add_done_callback(fn)
+        self.assertEqual(('test',), callback_exception.args)
+
+    def test_done_callback_already_cancelled(self):
+        was_cancelled = None
+        def fn(callback_future):
+            nonlocal was_cancelled
+            was_cancelled = callback_future.cancelled()
+
+        f = Future()
+        self.assertTrue(f.cancel())
+        f.add_done_callback(fn)
+        self.assertTrue(was_cancelled)
+
+    def test_done_callback_raises_already_succeeded(self):
+        with support.captured_stderr() as stderr:
+            def raising_fn(callback_future):
+                raise Exception('doh!')
+
+            f = Future()
+
+            # Set the result first to simulate a future that runs instantly,
+            # effectively allowing the callback to be run immediately.
+            f.set_result(5)
+            f.add_done_callback(raising_fn)
+
+            self.assertIn('exception calling callback for', stderr.getvalue())
+            self.assertIn('doh!', stderr.getvalue())
+
+
+    def test_repr(self):
+        self.assertRegex(repr(PENDING_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=pending>')
+        self.assertRegex(repr(RUNNING_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=running>')
+        self.assertRegex(repr(CANCELLED_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=cancelled>')
+        self.assertRegex(repr(CANCELLED_AND_NOTIFIED_FUTURE),
+                         '<Future at 0x[0-9a-f]+ state=cancelled>')
+        self.assertRegex(
+                repr(EXCEPTION_FUTURE),
+                '<Future at 0x[0-9a-f]+ state=finished raised OSError>')
+        self.assertRegex(
+                repr(SUCCESSFUL_FUTURE),
+                '<Future at 0x[0-9a-f]+ state=finished returned int>')
+
+    def test_cancel(self):
+        f1 = create_future(state=PENDING)
+        f2 = create_future(state=RUNNING)
+        f3 = create_future(state=CANCELLED)
+        f4 = create_future(state=CANCELLED_AND_NOTIFIED)
+        f5 = create_future(state=FINISHED, exception=OSError())
+        f6 = create_future(state=FINISHED, result=5)
+
+        self.assertTrue(f1.cancel())
+        self.assertEqual(f1._state, CANCELLED)
+
+        self.assertFalse(f2.cancel())
+        self.assertEqual(f2._state, RUNNING)
+
+        self.assertTrue(f3.cancel())
+        self.assertEqual(f3._state, CANCELLED)
+
+        self.assertTrue(f4.cancel())
+        self.assertEqual(f4._state, CANCELLED_AND_NOTIFIED)
+
+        self.assertFalse(f5.cancel())
+        self.assertEqual(f5._state, FINISHED)
+
+        self.assertFalse(f6.cancel())
+        self.assertEqual(f6._state, FINISHED)
+
+    def test_cancelled(self):
+        self.assertFalse(PENDING_FUTURE.cancelled())
+        self.assertFalse(RUNNING_FUTURE.cancelled())
+        self.assertTrue(CANCELLED_FUTURE.cancelled())
+        self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.cancelled())
+        self.assertFalse(EXCEPTION_FUTURE.cancelled())
+        self.assertFalse(SUCCESSFUL_FUTURE.cancelled())
+
+    def test_done(self):
+        self.assertFalse(PENDING_FUTURE.done())
+        self.assertFalse(RUNNING_FUTURE.done())
+        self.assertTrue(CANCELLED_FUTURE.done())
+        self.assertTrue(CANCELLED_AND_NOTIFIED_FUTURE.done())
+        self.assertTrue(EXCEPTION_FUTURE.done())
+        self.assertTrue(SUCCESSFUL_FUTURE.done())
+
+    def test_running(self):
+        self.assertFalse(PENDING_FUTURE.running())
+        self.assertTrue(RUNNING_FUTURE.running())
+        self.assertFalse(CANCELLED_FUTURE.running())
+        self.assertFalse(CANCELLED_AND_NOTIFIED_FUTURE.running())
+        self.assertFalse(EXCEPTION_FUTURE.running())
+        self.assertFalse(SUCCESSFUL_FUTURE.running())
+
+    def test_result_with_timeout(self):
+        self.assertRaises(futures.TimeoutError,
+                          PENDING_FUTURE.result, timeout=0)
+        self.assertRaises(futures.TimeoutError,
+                          RUNNING_FUTURE.result, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_FUTURE.result, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_AND_NOTIFIED_FUTURE.result, timeout=0)
+        self.assertRaises(OSError, EXCEPTION_FUTURE.result, timeout=0)
+        self.assertEqual(SUCCESSFUL_FUTURE.result(timeout=0), 42)
+
+    def test_result_with_success(self):
+        # TODO(brian@sweetapp.com): This test is timing dependent.
+        def notification():
+            # Wait until the main thread is waiting for the result.
+            time.sleep(1)
+            f1.set_result(42)
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertEqual(f1.result(timeout=5), 42)
+        t.join()
+
+    def test_result_with_cancel(self):
+        # TODO(brian@sweetapp.com): This test is timing dependent.
+        def notification():
+            # Wait until the main thread is waiting for the result.
+            time.sleep(1)
+            f1.cancel()
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertRaises(futures.CancelledError,
+                          f1.result, timeout=support.SHORT_TIMEOUT)
+        t.join()
+
+    def test_exception_with_timeout(self):
+        self.assertRaises(futures.TimeoutError,
+                          PENDING_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.TimeoutError,
+                          RUNNING_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_FUTURE.exception, timeout=0)
+        self.assertRaises(futures.CancelledError,
+                          CANCELLED_AND_NOTIFIED_FUTURE.exception, timeout=0)
+        self.assertTrue(isinstance(EXCEPTION_FUTURE.exception(timeout=0),
+                                   OSError))
+        self.assertEqual(SUCCESSFUL_FUTURE.exception(timeout=0), None)
+
+    def test_exception_with_success(self):
+        def notification():
+            # Wait until the main thread is waiting for the exception.
+            time.sleep(1)
+            with f1._condition:
+                f1._state = FINISHED
+                f1._exception = OSError()
+                f1._condition.notify_all()
+
+        f1 = create_future(state=PENDING)
+        t = threading.Thread(target=notification)
+        t.start()
+
+        self.assertTrue(isinstance(f1.exception(timeout=support.SHORT_TIMEOUT), OSError))
+        t.join()
+
+    def test_multiple_set_result(self):
+        f = create_future(state=PENDING)
+        f.set_result(1)
+
+        with self.assertRaisesRegex(
+                futures.InvalidStateError,
+                'FINISHED: <Future at 0x[0-9a-f]+ '
+                'state=finished returned int>'
+        ):
+            f.set_result(2)
+
+        self.assertTrue(f.done())
+        self.assertEqual(f.result(), 1)
+
+    def test_multiple_set_exception(self):
+        f = create_future(state=PENDING)
+        e = ValueError()
+        f.set_exception(e)
+
+        with self.assertRaisesRegex(
+                futures.InvalidStateError,
+                'FINISHED: <Future at 0x[0-9a-f]+ '
+                'state=finished raised ValueError>'
+        ):
+            f.set_exception(Exception())
+
+        self.assertEqual(f.exception(), e)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_init.py b/Lib/test/test_concurrent_futures/test_init.py
new file mode 100644
index 0000000000..df64092930
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_init.py
@@ -0,0 +1,152 @@
+import contextlib
+import logging
+import queue
+import time
+import unittest
+import sys
+import io
+from concurrent.futures._base import BrokenExecutor
+from concurrent.futures.process import _check_system_limits
+
+from logging.handlers import QueueHandler
+
+from test import support
+
+from .util import ExecutorMixin, create_executor_tests, setup_module
+
+
+INITIALIZER_STATUS = 'uninitialized'
+
+def init(x):
+    global INITIALIZER_STATUS
+    INITIALIZER_STATUS = x
+
+def get_init_status():
+    return INITIALIZER_STATUS
+
+def init_fail(log_queue=None):
+    if log_queue is not None:
+        logger = logging.getLogger('concurrent.futures')
+        logger.addHandler(QueueHandler(log_queue))
+        logger.setLevel('CRITICAL')
+        logger.propagate = False
+    time.sleep(0.1)  # let some futures be scheduled
+    raise ValueError('error in initializer')
+
+
+class InitializerMixin(ExecutorMixin):
+    worker_count = 2
+
+    def setUp(self):
+        global INITIALIZER_STATUS
+        INITIALIZER_STATUS = 'uninitialized'
+        self.executor_kwargs = dict(initializer=init,
+                                    initargs=('initialized',))
+        super().setUp()
+
+    def test_initializer(self):
+        futures = [self.executor.submit(get_init_status)
+                   for _ in range(self.worker_count)]
+
+        for f in futures:
+            self.assertEqual(f.result(), 'initialized')
+
+
+class FailingInitializerMixin(ExecutorMixin):
+    worker_count = 2
+
+    def setUp(self):
+        if hasattr(self, "ctx"):
+            # Pass a queue to redirect the child's logging output
+            self.mp_context = self.get_context()
+            self.log_queue = self.mp_context.Queue()
+            self.executor_kwargs = dict(initializer=init_fail,
+                                        initargs=(self.log_queue,))
+        else:
+            # In a thread pool, the child shares our logging setup
+            # (see _assert_logged())
+            self.mp_context = None
+            self.log_queue = None
+            self.executor_kwargs = dict(initializer=init_fail)
+        super().setUp()
+
+    def test_initializer(self):
+        with self._assert_logged('ValueError: error in initializer'):
+            try:
+                future = self.executor.submit(get_init_status)
+            except BrokenExecutor:
+                # Perhaps the executor is already broken
+                pass
+            else:
+                with self.assertRaises(BrokenExecutor):
+                    future.result()
+
+            # At some point, the executor should break
+            for _ in support.sleeping_retry(support.SHORT_TIMEOUT,
+                                            "executor not broken"):
+                if self.executor._broken:
+                    break
+
+            # ... and from this point submit() is guaranteed to fail
+            with self.assertRaises(BrokenExecutor):
+                self.executor.submit(get_init_status)
+
+    @contextlib.contextmanager
+    def _assert_logged(self, msg):
+        if self.log_queue is not None:
+            yield
+            output = []
+            try:
+                while True:
+                    output.append(self.log_queue.get_nowait().getMessage())
+            except queue.Empty:
+                pass
+        else:
+            with self.assertLogs('concurrent.futures', 'CRITICAL') as cm:
+                yield
+            output = cm.output
+        self.assertTrue(any(msg in line for line in output),
+                        output)
+
+
+create_executor_tests(globals(), InitializerMixin)
+create_executor_tests(globals(), FailingInitializerMixin)
+
+
+@unittest.skipIf(sys.platform == "win32", "Resource Tracker doesn't run on Windows")
+class FailingInitializerResourcesTest(unittest.TestCase):
+    """
+    Source: https://github.com/python/cpython/issues/104090
+    """
+
+    def _test(self, test_class):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+
+        runner = unittest.TextTestRunner(stream=io.StringIO())
+        runner.run(test_class('test_initializer'))
+
+        # GH-104090:
+        # Stop resource tracker manually now, so we can verify there are not leaked resources by checking
+        # the process exit code
+        from multiprocessing.resource_tracker import _resource_tracker
+        _resource_tracker._stop()
+
+        self.assertEqual(_resource_tracker._exitcode, 0)
+
+    def test_spawn(self):
+        self._test(ProcessPoolSpawnFailingInitializerTest)
+
+    @support.skip_if_sanitizer("TSAN doesn't support threads after fork", thread=True)
+    def test_forkserver(self):
+        self._test(ProcessPoolForkserverFailingInitializerTest)
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_process_pool.py b/Lib/test/test_concurrent_futures/test_process_pool.py
new file mode 100644
index 0000000000..5d4e9677f5
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_process_pool.py
@@ -0,0 +1,232 @@
+import os
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures.process import BrokenProcessPool
+
+from test import support
+from test.support import hashlib_helper
+
+from .executor import ExecutorTest, mul
+from .util import (
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin,
+    create_executor_tests, setup_module)
+
+
+class EventfulGCObj():
+    def __init__(self, mgr):
+        self.event = mgr.Event()
+
+    def __del__(self):
+        self.event.set()
+
+
+class ProcessPoolExecutorTest(ExecutorTest):
+
+    @unittest.skipUnless(sys.platform=='win32', 'Windows-only process limit')
+    def test_max_workers_too_large(self):
+        with self.assertRaisesRegex(ValueError,
+                                    "max_workers must be <= 61"):
+            futures.ProcessPoolExecutor(max_workers=62)
+
+    def test_killed_child(self):
+        # When a child process is abruptly terminated, the whole pool gets
+        # "broken".
+        futures = [self.executor.submit(time.sleep, 3)]
+        # Get one of the processes, and terminate (kill) it
+        p = next(iter(self.executor._processes.values()))
+        p.terminate()
+        for fut in futures:
+            self.assertRaises(BrokenProcessPool, fut.result)
+        # Submitting other jobs fails as well.
+        self.assertRaises(BrokenProcessPool, self.executor.submit, pow, 2, 8)
+
+    def test_map_chunksize(self):
+        def bad_map():
+            list(self.executor.map(pow, range(40), range(40), chunksize=-1))
+
+        ref = list(map(pow, range(40), range(40)))
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=6)),
+            ref)
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=50)),
+            ref)
+        self.assertEqual(
+            list(self.executor.map(pow, range(40), range(40), chunksize=40)),
+            ref)
+        self.assertRaises(ValueError, bad_map)
+
+    @classmethod
+    def _test_traceback(cls):
+        raise RuntimeError(123) # some comment
+
+    def test_traceback(self):
+        # We want ensure that the traceback from the child process is
+        # contained in the traceback raised in the main process.
+        future = self.executor.submit(self._test_traceback)
+        with self.assertRaises(Exception) as cm:
+            future.result()
+
+        exc = cm.exception
+        self.assertIs(type(exc), RuntimeError)
+        self.assertEqual(exc.args, (123,))
+        cause = exc.__cause__
+        self.assertIs(type(cause), futures.process._RemoteTraceback)
+        self.assertIn('raise RuntimeError(123) # some comment', cause.tb)
+
+        with support.captured_stderr() as f1:
+            try:
+                raise exc
+            except RuntimeError:
+                sys.excepthook(*sys.exc_info())
+        self.assertIn('raise RuntimeError(123) # some comment',
+                      f1.getvalue())
+
+    @hashlib_helper.requires_hashdigest('md5')
+    def test_ressources_gced_in_workers(self):
+        # Ensure that argument for a job are correctly gc-ed after the job
+        # is finished
+        mgr = self.get_context().Manager()
+        obj = EventfulGCObj(mgr)
+        future = self.executor.submit(id, obj)
+        future.result()
+
+        self.assertTrue(obj.event.wait(timeout=1))
+
+        # explicitly destroy the object to ensure that EventfulGCObj.__del__()
+        # is called while manager is still running.
+        support.gc_collect()
+        obj = None
+        support.gc_collect()
+
+        mgr.shutdown()
+        mgr.join()
+
+    def test_saturation(self):
+        executor = self.executor
+        mp_context = self.get_context()
+        sem = mp_context.Semaphore(0)
+        job_count = 15 * executor._max_workers
+        for _ in range(job_count):
+            executor.submit(sem.acquire)
+        self.assertEqual(len(executor._processes), executor._max_workers)
+        for _ in range(job_count):
+            sem.release()
+
+    @support.requires_gil_enabled("gh-117344: test is flaky without the GIL")
+    def test_idle_process_reuse_one(self):
+        executor = self.executor
+        assert executor._max_workers >= 4
+        if self.get_context().get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        executor.submit(mul, 21, 2).result()
+        executor.submit(mul, 6, 7).result()
+        executor.submit(mul, 3, 14).result()
+        self.assertEqual(len(executor._processes), 1)
+
+    def test_idle_process_reuse_multiple(self):
+        executor = self.executor
+        assert executor._max_workers <= 5
+        if self.get_context().get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        executor.submit(mul, 12, 7).result()
+        executor.submit(mul, 33, 25)
+        executor.submit(mul, 25, 26).result()
+        executor.submit(mul, 18, 29)
+        executor.submit(mul, 1, 2).result()
+        executor.submit(mul, 0, 9)
+        self.assertLessEqual(len(executor._processes), 3)
+        executor.shutdown()
+
+    def test_max_tasks_per_child(self):
+        context = self.get_context()
+        if context.get_start_method(allow_none=False) == "fork":
+            with self.assertRaises(ValueError):
+                self.executor_type(1, mp_context=context, max_tasks_per_child=3)
+            return
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(
+                1, mp_context=context, max_tasks_per_child=3)
+        f1 = executor.submit(os.getpid)
+        original_pid = f1.result()
+        # The worker pid remains the same as the worker could be reused
+        f2 = executor.submit(os.getpid)
+        self.assertEqual(f2.result(), original_pid)
+        self.assertEqual(len(executor._processes), 1)
+        f3 = executor.submit(os.getpid)
+        self.assertEqual(f3.result(), original_pid)
+
+        # A new worker is spawned, with a statistically different pid,
+        # while the previous was reaped.
+        f4 = executor.submit(os.getpid)
+        new_pid = f4.result()
+        self.assertNotEqual(original_pid, new_pid)
+        self.assertEqual(len(executor._processes), 1)
+
+        executor.shutdown()
+
+    def test_max_tasks_per_child_defaults_to_spawn_context(self):
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(1, max_tasks_per_child=3)
+        self.assertEqual(executor._mp_context.get_start_method(), "spawn")
+
+    def test_max_tasks_early_shutdown(self):
+        context = self.get_context()
+        if context.get_start_method(allow_none=False) == "fork":
+            raise unittest.SkipTest("Incompatible with the fork start method.")
+        # not using self.executor as we need to control construction.
+        # arguably this could go in another class w/o that mixin.
+        executor = self.executor_type(
+                3, mp_context=context, max_tasks_per_child=1)
+        futures = []
+        for i in range(6):
+            futures.append(executor.submit(mul, i, i))
+        executor.shutdown()
+        for i, future in enumerate(futures):
+            self.assertEqual(future.result(), mul(i, i))
+
+    def test_python_finalization_error(self):
+        # gh-109047: Catch RuntimeError on thread creation
+        # during Python finalization.
+
+        context = self.get_context()
+
+        # gh-109047: Mock the threading.start_joinable_thread() function to inject
+        # RuntimeError: simulate the error raised during Python finalization.
+        # Block the second creation: create _ExecutorManagerThread, but block
+        # QueueFeederThread.
+        orig_start_new_thread = threading._start_joinable_thread
+        nthread = 0
+        def mock_start_new_thread(func, *args, **kwargs):
+            nonlocal nthread
+            if nthread >= 1:
+                raise RuntimeError("can't create new thread at "
+                                   "interpreter shutdown")
+            nthread += 1
+            return orig_start_new_thread(func, *args, **kwargs)
+
+        with support.swap_attr(threading, '_start_joinable_thread',
+                               mock_start_new_thread):
+            executor = self.executor_type(max_workers=2, mp_context=context)
+            with executor:
+                with self.assertRaises(BrokenProcessPool):
+                    list(executor.map(mul, [(2, 3)] * 10))
+            executor.shutdown()
+
+
+create_executor_tests(globals(), ProcessPoolExecutorTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_shutdown.py b/Lib/test/test_concurrent_futures/test_shutdown.py
new file mode 100644
index 0000000000..820ea6cf25
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_shutdown.py
@@ -0,0 +1,410 @@
+import signal
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+
+from test import support
+from test.support.script_helper import assert_python_ok
+
+from .util import (
+    BaseTestCase, ThreadPoolMixin, ProcessPoolForkMixin,
+    ProcessPoolForkserverMixin, ProcessPoolSpawnMixin,
+    create_executor_tests, setup_module)
+
+
+def sleep_and_print(t, msg):
+    time.sleep(t)
+    print(msg)
+    sys.stdout.flush()
+
+
+class ExecutorShutdownTest:
+    def test_run_after_shutdown(self):
+        self.executor.shutdown()
+        self.assertRaises(RuntimeError,
+                          self.executor.submit,
+                          pow, 2, 5)
+
+    @unittest.skip('TODO: RUSTPYTHON; hangs')
+    def test_interpreter_shutdown(self):
+        # Test the atexit hook for shutdown of worker threads and processes
+        rc, out, err = assert_python_ok('-c', """if 1:
+            from concurrent.futures import {executor_type}
+            from time import sleep
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                context = '{context}'
+                if context == "":
+                    t = {executor_type}(5)
+                else:
+                    from multiprocessing import get_context
+                    context = get_context(context)
+                    t = {executor_type}(5, mp_context=context)
+                t.submit(sleep_and_print, 1.0, "apple")
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, "ctx", "")))
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertFalse(err)
+        self.assertEqual(out.strip(), b"apple")
+
+    @unittest.skip('TODO: RUSTPYTHON; Hangs')
+    def test_submit_after_interpreter_shutdown(self):
+        # Test the atexit hook for shutdown of worker threads and processes
+        rc, out, err = assert_python_ok('-c', """if 1:
+            import atexit
+            @atexit.register
+            def run_last():
+                try:
+                    t.submit(id, None)
+                except RuntimeError:
+                    print("runtime-error")
+                    raise
+            from concurrent.futures import {executor_type}
+            if __name__ == "__main__":
+                context = '{context}'
+                if not context:
+                    t = {executor_type}(5)
+                else:
+                    from multiprocessing import get_context
+                    context = get_context(context)
+                    t = {executor_type}(5, mp_context=context)
+                    t.submit(id, 42).result()
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, "ctx", "")))
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertIn("RuntimeError: cannot schedule new futures", err.decode())
+        self.assertEqual(out.strip(), b"runtime-error")
+
+    def test_hang_issue12364(self):
+        fs = [self.executor.submit(time.sleep, 0.1) for _ in range(50)]
+        self.executor.shutdown()
+        for f in fs:
+            f.result()
+
+    def test_cancel_futures(self):
+        assert self.worker_count <= 5, "test needs few workers"
+        fs = [self.executor.submit(time.sleep, .1) for _ in range(50)]
+        self.executor.shutdown(cancel_futures=True)
+        # We can't guarantee the exact number of cancellations, but we can
+        # guarantee that *some* were cancelled. With few workers, many of
+        # the submitted futures should have been cancelled.
+        cancelled = [fut for fut in fs if fut.cancelled()]
+        self.assertGreater(len(cancelled), 20)
+
+        # Ensure the other futures were able to finish.
+        # Use "not fut.cancelled()" instead of "fut.done()" to include futures
+        # that may have been left in a pending state.
+        others = [fut for fut in fs if not fut.cancelled()]
+        for fut in others:
+            self.assertTrue(fut.done(), msg=f"{fut._state=}")
+            self.assertIsNone(fut.exception())
+
+        # Similar to the number of cancelled futures, we can't guarantee the
+        # exact number that completed. But, we can guarantee that at least
+        # one finished.
+        self.assertGreater(len(others), 0)
+
+    def test_hang_gh83386(self):
+        """shutdown(wait=False) doesn't hang at exit with running futures.
+
+        See https://github.com/python/cpython/issues/83386.
+        """
+        if self.executor_type == futures.ProcessPoolExecutor:
+            raise unittest.SkipTest(
+                "Hangs, see https://github.com/python/cpython/issues/83386")
+
+        rc, out, err = assert_python_ok('-c', """if True:
+            from concurrent.futures import {executor_type}
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                if {context!r}: multiprocessing.set_start_method({context!r})
+                t = {executor_type}(max_workers=3)
+                t.submit(sleep_and_print, 1.0, "apple")
+                t.shutdown(wait=False)
+            """.format(executor_type=self.executor_type.__name__,
+                       context=getattr(self, 'ctx', None)))
+        self.assertFalse(err)
+        self.assertEqual(out.strip(), b"apple")
+
+    def test_hang_gh94440(self):
+        """shutdown(wait=True) doesn't hang when a future was submitted and
+        quickly canceled right before shutdown.
+
+        See https://github.com/python/cpython/issues/94440.
+        """
+        if not hasattr(signal, 'alarm'):
+            raise unittest.SkipTest(
+                "Tested platform does not support the alarm signal")
+
+        def timeout(_signum, _frame):
+            raise RuntimeError("timed out waiting for shutdown")
+
+        kwargs = {}
+        if getattr(self, 'ctx', None):
+            kwargs['mp_context'] = self.get_context()
+        executor = self.executor_type(max_workers=1, **kwargs)
+        executor.submit(int).result()
+        old_handler = signal.signal(signal.SIGALRM, timeout)
+        try:
+            signal.alarm(5)
+            executor.submit(int).cancel()
+            executor.shutdown(wait=True)
+        finally:
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, old_handler)
+
+
+class ThreadPoolShutdownTest(ThreadPoolMixin, ExecutorShutdownTest, BaseTestCase):
+    def test_threads_terminate(self):
+        def acquire_lock(lock):
+            lock.acquire()
+
+        sem = threading.Semaphore(0)
+        for i in range(3):
+            self.executor.submit(acquire_lock, sem)
+        self.assertEqual(len(self.executor._threads), 3)
+        for i in range(3):
+            sem.release()
+        self.executor.shutdown()
+        for t in self.executor._threads:
+            t.join()
+
+    def test_context_manager_shutdown(self):
+        with futures.ThreadPoolExecutor(max_workers=5) as e:
+            executor = e
+            self.assertEqual(list(e.map(abs, range(-5, 5))),
+                             [5, 4, 3, 2, 1, 0, 1, 2, 3, 4])
+
+        for t in executor._threads:
+            t.join()
+
+    def test_del_shutdown(self):
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        res = executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+
+        for t in threads:
+            t.join()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    def test_shutdown_no_wait(self):
+        # Ensure that the executor cleans up the threads when calling
+        # shutdown with wait=False
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        res = executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        executor.shutdown(wait=False)
+        for t in threads:
+            t.join()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+
+    def test_thread_names_assigned(self):
+        executor = futures.ThreadPoolExecutor(
+            max_workers=5, thread_name_prefix='SpecialPool')
+        executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        for t in threads:
+            self.assertRegex(t.name, r'^SpecialPool_[0-4]$')
+            t.join()
+
+    def test_thread_names_default(self):
+        executor = futures.ThreadPoolExecutor(max_workers=5)
+        executor.map(abs, range(-5, 5))
+        threads = executor._threads
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        for t in threads:
+            # Ensure that our default name is reasonably sane and unique when
+            # no thread_name_prefix was supplied.
+            self.assertRegex(t.name, r'ThreadPoolExecutor-\d+_[0-4]$')
+            t.join()
+
+    def test_cancel_futures_wait_false(self):
+        # Can only be reliably tested for TPE, since PPE often hangs with
+        # `wait=False` (even without *cancel_futures*).
+        rc, out, err = assert_python_ok('-c', """if True:
+            from concurrent.futures import ThreadPoolExecutor
+            from test.test_concurrent_futures.test_shutdown import sleep_and_print
+            if __name__ == "__main__":
+                t = ThreadPoolExecutor()
+                t.submit(sleep_and_print, .1, "apple")
+                t.shutdown(wait=False, cancel_futures=True)
+            """)
+        # Errors in atexit hooks don't change the process exit code, check
+        # stderr manually.
+        self.assertFalse(err)
+        # gh-116682: stdout may be empty if shutdown happens before task
+        # starts executing.
+        self.assertIn(out.strip(), [b"apple", b""])
+
+
+class ProcessPoolShutdownTest(ExecutorShutdownTest):
+    # TODO: RUSTPYTHON - flaky, dict changed size during iteration race condition
+    @unittest.skip("TODO: RUSTPYTHON - flaky race condition on macOS")
+    def test_cancel_futures(self):
+        return super().test_cancel_futures()
+
+    def test_processes_terminate(self):
+        def acquire_lock(lock):
+            lock.acquire()
+
+        mp_context = self.get_context()
+        if mp_context.get_start_method(allow_none=False) == "fork":
+            # fork pre-spawns, not on demand.
+            expected_num_processes = self.worker_count
+        else:
+            expected_num_processes = 3
+
+        sem = mp_context.Semaphore(0)
+        for _ in range(3):
+            self.executor.submit(acquire_lock, sem)
+        self.assertEqual(len(self.executor._processes), expected_num_processes)
+        for _ in range(3):
+            sem.release()
+        processes = self.executor._processes
+        self.executor.shutdown()
+
+        for p in processes.values():
+            p.join()
+
+    def test_context_manager_shutdown(self):
+        with futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context()) as e:
+            processes = e._processes
+            self.assertEqual(list(e.map(abs, range(-5, 5))),
+                             [5, 4, 3, 2, 1, 0, 1, 2, 3, 4])
+
+        for p in processes.values():
+            p.join()
+
+    def test_del_shutdown(self):
+        executor = futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context())
+        res = executor.map(abs, range(-5, 5))
+        executor_manager_thread = executor._executor_manager_thread
+        processes = executor._processes
+        call_queue = executor._call_queue
+        executor_manager_thread = executor._executor_manager_thread
+        del executor
+        support.gc_collect()  # For PyPy or other GCs.
+
+        # Make sure that all the executor resources were properly cleaned by
+        # the shutdown process
+        executor_manager_thread.join()
+        for p in processes.values():
+            p.join()
+        call_queue.join_thread()
+
+        # Make sure the results were all computed before the
+        # executor got shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    def test_shutdown_no_wait(self):
+        # Ensure that the executor cleans up the processes when calling
+        # shutdown with wait=False
+        executor = futures.ProcessPoolExecutor(
+                max_workers=5, mp_context=self.get_context())
+        res = executor.map(abs, range(-5, 5))
+        processes = executor._processes
+        call_queue = executor._call_queue
+        executor_manager_thread = executor._executor_manager_thread
+        executor.shutdown(wait=False)
+
+        # Make sure that all the executor resources were properly cleaned by
+        # the shutdown process
+        executor_manager_thread.join()
+        for p in processes.values():
+            p.join()
+        call_queue.join_thread()
+
+        # Make sure the results were all computed before the executor got
+        # shutdown.
+        assert all([r == abs(v) for r, v in zip(res, range(-5, 5))])
+
+    @classmethod
+    def _failing_task_gh_132969(cls, n):
+        raise ValueError("failing task")
+
+    @classmethod
+    def _good_task_gh_132969(cls, n):
+        time.sleep(0.1 * n)
+        return n
+
+    def _run_test_issue_gh_132969(self, max_workers):
+        # max_workers=2 will repro exception
+        # max_workers=4 will repro exception and then hang
+
+        # Repro conditions
+        #   max_tasks_per_child=1
+        #   a task ends abnormally
+        #   shutdown(wait=False) is called
+        start_method = self.get_context().get_start_method()
+        if (start_method == "fork" or
+           (start_method == "forkserver" and sys.platform.startswith("win"))):
+                self.skipTest(f"Skipping test for {start_method = }")
+        executor = futures.ProcessPoolExecutor(
+                max_workers=max_workers,
+                max_tasks_per_child=1,
+                mp_context=self.get_context())
+        f1 = executor.submit(ProcessPoolShutdownTest._good_task_gh_132969, 1)
+        f2 = executor.submit(ProcessPoolShutdownTest._failing_task_gh_132969, 2)
+        f3 = executor.submit(ProcessPoolShutdownTest._good_task_gh_132969, 3)
+        result = 0
+        try:
+            result += f1.result()
+            result += f2.result()
+            result += f3.result()
+        except ValueError:
+            # stop processing results upon first exception
+            pass
+
+        # Ensure that the executor cleans up after called
+        # shutdown with wait=False
+        executor_manager_thread = executor._executor_manager_thread
+        executor.shutdown(wait=False)
+        time.sleep(0.2)
+        executor_manager_thread.join()
+        return result
+
+    def test_shutdown_gh_132969_case_1(self):
+        # gh-132969: test that exception "object of type 'NoneType' has no len()"
+        # is not raised when shutdown(wait=False) is called.
+        result = self._run_test_issue_gh_132969(2)
+        self.assertEqual(result, 1)
+
+    def test_shutdown_gh_132969_case_2(self):
+        # gh-132969: test that process does not hang and
+        # exception "object of type 'NoneType' has no len()" is not raised
+        # when shutdown(wait=False) is called.
+        result = self._run_test_issue_gh_132969(4)
+        self.assertEqual(result, 1)
+
+
+create_executor_tests(globals(), ProcessPoolShutdownTest,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_thread_pool.py b/Lib/test/test_concurrent_futures/test_thread_pool.py
new file mode 100644
index 0000000000..4324241b37
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_thread_pool.py
@@ -0,0 +1,121 @@
+import contextlib
+import multiprocessing as mp
+import multiprocessing.process
+import multiprocessing.util
+import os
+import threading
+import unittest
+from concurrent import futures
+from test import support
+
+from .executor import ExecutorTest, mul
+from .util import BaseTestCase, ThreadPoolMixin, setup_module
+
+
+class ThreadPoolExecutorTest(ThreadPoolMixin, ExecutorTest, BaseTestCase):
+    def test_map_submits_without_iteration(self):
+        """Tests verifying issue 11777."""
+        finished = []
+        def record_finished(n):
+            finished.append(n)
+
+        self.executor.map(record_finished, range(10))
+        self.executor.shutdown(wait=True)
+        self.assertCountEqual(finished, range(10))
+
+    def test_default_workers(self):
+        executor = self.executor_type()
+        expected = min(32, (os.process_cpu_count() or 1) + 4)
+        self.assertEqual(executor._max_workers, expected)
+
+    def test_saturation(self):
+        executor = self.executor_type(4)
+        def acquire_lock(lock):
+            lock.acquire()
+
+        sem = threading.Semaphore(0)
+        for i in range(15 * executor._max_workers):
+            executor.submit(acquire_lock, sem)
+        self.assertEqual(len(executor._threads), executor._max_workers)
+        for i in range(15 * executor._max_workers):
+            sem.release()
+        executor.shutdown(wait=True)
+
+    @support.requires_gil_enabled("gh-117344: test is flaky without the GIL")
+    def test_idle_thread_reuse(self):
+        executor = self.executor_type()
+        executor.submit(mul, 21, 2).result()
+        executor.submit(mul, 6, 7).result()
+        executor.submit(mul, 3, 14).result()
+        self.assertEqual(len(executor._threads), 1)
+        executor.shutdown(wait=True)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
+    @support.requires_resource('cpu')
+    def test_hang_global_shutdown_lock(self):
+        # bpo-45021: _global_shutdown_lock should be reinitialized in the child
+        # process, otherwise it will never exit
+        def submit(pool):
+            pool.submit(submit, pool)
+
+        with futures.ThreadPoolExecutor(1) as pool:
+            pool.submit(submit, pool)
+
+            for _ in range(50):
+                with futures.ProcessPoolExecutor(1, mp_context=mp.get_context('fork')) as workers:
+                    workers.submit(tuple)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(os, 'register_at_fork'), 'need os.register_at_fork')
+    def test_process_fork_from_a_threadpool(self):
+        # bpo-43944: clear concurrent.futures.thread._threads_queues after fork,
+        # otherwise child process will try to join parent thread
+        def fork_process_and_return_exitcode():
+            # Ignore the warning about fork with threads.
+            with self.assertWarnsRegex(DeprecationWarning,
+                                       r"use of fork\(\) may lead to deadlocks in the child"):
+                p = mp.get_context('fork').Process(target=lambda: 1)
+                p.start()
+            p.join()
+            return p.exitcode
+
+        with futures.ThreadPoolExecutor(1) as pool:
+            process_exitcode = pool.submit(fork_process_and_return_exitcode).result()
+
+        self.assertEqual(process_exitcode, 0)
+
+    def test_executor_map_current_future_cancel(self):
+        stop_event = threading.Event()
+        log = []
+
+        def log_n_wait(ident):
+            log.append(f"{ident=} started")
+            try:
+                stop_event.wait()
+            finally:
+                log.append(f"{ident=} stopped")
+
+        with self.executor_type(max_workers=1) as pool:
+            # submit work to saturate the pool
+            fut = pool.submit(log_n_wait, ident="first")
+            try:
+                with contextlib.closing(
+                    pool.map(log_n_wait, ["second", "third"], timeout=0)
+                ) as gen:
+                    with self.assertRaises(TimeoutError):
+                        next(gen)
+            finally:
+                stop_event.set()
+            fut.result()
+        # ident='second' is cancelled as a result of raising a TimeoutError
+        # ident='third' is cancelled because it remained in the collection of futures
+        self.assertListEqual(log, ["ident='first' started", "ident='first' stopped"])
+
+
+def setUpModule():
+    setup_module()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_concurrent_futures/test_wait.py b/Lib/test/test_concurrent_futures/test_wait.py
new file mode 100644
index 0000000000..7a7857671a
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/test_wait.py
@@ -0,0 +1,219 @@
+import sys
+import threading
+import unittest
+from concurrent import futures
+from test import support
+from test.support import threading_helper
+
+from .util import (
+    CANCELLED_FUTURE, CANCELLED_AND_NOTIFIED_FUTURE, EXCEPTION_FUTURE,
+    SUCCESSFUL_FUTURE,
+    create_executor_tests, setup_module,
+    BaseTestCase, ThreadPoolMixin,
+    ProcessPoolForkMixin, ProcessPoolForkserverMixin, ProcessPoolSpawnMixin)
+
+
+def mul(x, y):
+    return x * y
+
+def wait_and_raise(e):
+    e.wait()
+    raise Exception('this is an exception')
+
+
+class WaitTests:
+    def test_20369(self):
+        # See https://bugs.python.org/issue20369
+        future = self.executor.submit(mul, 1, 2)
+        done, not_done = futures.wait([future, future],
+                            return_when=futures.ALL_COMPLETED)
+        self.assertEqual({future}, done)
+        self.assertEqual(set(), not_done)
+
+
+    def test_first_completed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(mul, 21, 2)
+        future2 = self.executor.submit(event.wait)
+
+        try:
+            done, not_done = futures.wait(
+                    [CANCELLED_FUTURE, future1, future2],
+                     return_when=futures.FIRST_COMPLETED)
+
+            self.assertEqual(set([future1]), done)
+            self.assertEqual(set([CANCELLED_FUTURE, future2]), not_done)
+        finally:
+            event.set()
+        future2.result()  # wait for job to finish
+
+    def test_first_completed_some_already_completed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                     [CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE, future1],
+                     return_when=futures.FIRST_COMPLETED)
+
+            self.assertEqual(
+                    set([CANCELLED_AND_NOTIFIED_FUTURE, SUCCESSFUL_FUTURE]),
+                    finished)
+            self.assertEqual(set([future1]), pending)
+        finally:
+            event.set()
+        future1.result()  # wait for job to finish
+
+    def test_first_exception(self):
+        event1 = self.create_event()
+        event2 = self.create_event()
+        try:
+            future1 = self.executor.submit(mul, 2, 21)
+            future2 = self.executor.submit(wait_and_raise, event1)
+            future3 = self.executor.submit(event2.wait)
+
+            # Ensure that future1 is completed before future2 finishes
+            def wait_for_future1():
+                future1.result()
+                event1.set()
+
+            t = threading.Thread(target=wait_for_future1)
+            t.start()
+
+            finished, pending = futures.wait(
+                    [future1, future2, future3],
+                    return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([future1, future2]), finished)
+            self.assertEqual(set([future3]), pending)
+
+            threading_helper.join_thread(t)
+        finally:
+            event1.set()
+            event2.set()
+        future3.result()  # wait for job to finish
+
+    def test_first_exception_some_already_complete(self):
+        event = self.create_event()
+        future1 = self.executor.submit(divmod, 21, 0)
+        future2 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                    [SUCCESSFUL_FUTURE,
+                     CANCELLED_FUTURE,
+                     CANCELLED_AND_NOTIFIED_FUTURE,
+                     future1, future2],
+                    return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([SUCCESSFUL_FUTURE,
+                                  CANCELLED_AND_NOTIFIED_FUTURE,
+                                  future1]), finished)
+            self.assertEqual(set([CANCELLED_FUTURE, future2]), pending)
+        finally:
+            event.set()
+        future2.result()  # wait for job to finish
+
+    def test_first_exception_one_already_failed(self):
+        event = self.create_event()
+        future1 = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                     [EXCEPTION_FUTURE, future1],
+                     return_when=futures.FIRST_EXCEPTION)
+
+            self.assertEqual(set([EXCEPTION_FUTURE]), finished)
+            self.assertEqual(set([future1]), pending)
+        finally:
+            event.set()
+        future1.result()  # wait for job to finish
+
+    def test_all_completed(self):
+        future1 = self.executor.submit(divmod, 2, 0)
+        future2 = self.executor.submit(mul, 2, 21)
+
+        finished, pending = futures.wait(
+                [SUCCESSFUL_FUTURE,
+                 CANCELLED_AND_NOTIFIED_FUTURE,
+                 EXCEPTION_FUTURE,
+                 future1,
+                 future2],
+                return_when=futures.ALL_COMPLETED)
+
+        self.assertEqual(set([SUCCESSFUL_FUTURE,
+                              CANCELLED_AND_NOTIFIED_FUTURE,
+                              EXCEPTION_FUTURE,
+                              future1,
+                              future2]), finished)
+        self.assertEqual(set(), pending)
+
+    def test_timeout(self):
+        short_timeout = 0.050
+
+        event = self.create_event()
+        future = self.executor.submit(event.wait)
+
+        try:
+            finished, pending = futures.wait(
+                    [CANCELLED_AND_NOTIFIED_FUTURE,
+                     EXCEPTION_FUTURE,
+                     SUCCESSFUL_FUTURE,
+                     future],
+                    timeout=short_timeout,
+                    return_when=futures.ALL_COMPLETED)
+
+            self.assertEqual(set([CANCELLED_AND_NOTIFIED_FUTURE,
+                                  EXCEPTION_FUTURE,
+                                  SUCCESSFUL_FUTURE]),
+                             finished)
+            self.assertEqual(set([future]), pending)
+        finally:
+            event.set()
+        future.result()  # wait for job to finish
+
+
+class ThreadPoolWaitTests(ThreadPoolMixin, WaitTests, BaseTestCase):
+
+    def test_pending_calls_race(self):
+        # Issue #14406: multi-threaded race condition when waiting on all
+        # futures.
+        event = threading.Event()
+        def future_func():
+            event.wait()
+        oldswitchinterval = sys.getswitchinterval()
+        support.setswitchinterval(1e-6)
+        try:
+            fs = {self.executor.submit(future_func) for i in range(100)}
+            event.set()
+            futures.wait(fs, return_when=futures.ALL_COMPLETED)
+        finally:
+            sys.setswitchinterval(oldswitchinterval)
+
+
+create_executor_tests(globals(), WaitTests,
+                      executor_mixins=(ProcessPoolForkMixin,
+                                       ProcessPoolForkserverMixin,
+                                       ProcessPoolSpawnMixin))
+
+
+def setUpModule():
+    setup_module()
+
+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_concurrent_futures/util.py b/Lib/test/test_concurrent_futures/util.py
new file mode 100644
index 0000000000..e85ef3b1c9
--- /dev/null
+++ b/Lib/test/test_concurrent_futures/util.py
@@ -0,0 +1,169 @@
+import multiprocessing
+import sys
+import threading
+import time
+import unittest
+from concurrent import futures
+from concurrent.futures._base import (
+    PENDING, RUNNING, CANCELLED, CANCELLED_AND_NOTIFIED, FINISHED, Future,
+    )
+from concurrent.futures.process import _check_system_limits
+
+from test import support
+from test.support import threading_helper
+
+
+def create_future(state=PENDING, exception=None, result=None):
+    f = Future()
+    f._state = state
+    f._exception = exception
+    f._result = result
+    return f
+
+
+PENDING_FUTURE = create_future(state=PENDING)
+RUNNING_FUTURE = create_future(state=RUNNING)
+CANCELLED_FUTURE = create_future(state=CANCELLED)
+CANCELLED_AND_NOTIFIED_FUTURE = create_future(state=CANCELLED_AND_NOTIFIED)
+EXCEPTION_FUTURE = create_future(state=FINISHED, exception=OSError())
+SUCCESSFUL_FUTURE = create_future(state=FINISHED, result=42)
+
+
+class BaseTestCase(unittest.TestCase):
+    def setUp(self):
+        self._thread_key = threading_helper.threading_setup()
+
+    def tearDown(self):
+        support.reap_children()
+        threading_helper.threading_cleanup(*self._thread_key)
+
+
+class ExecutorMixin:
+    worker_count = 5
+    executor_kwargs = {}
+
+    def setUp(self):
+        super().setUp()
+
+        self.t1 = time.monotonic()
+        if hasattr(self, "ctx"):
+            self.executor = self.executor_type(
+                max_workers=self.worker_count,
+                mp_context=self.get_context(),
+                **self.executor_kwargs)
+            self.manager = self.get_context().Manager()
+        else:
+            self.executor = self.executor_type(
+                max_workers=self.worker_count,
+                **self.executor_kwargs)
+            self.manager = None
+
+    def tearDown(self):
+        self.executor.shutdown(wait=True)
+        self.executor = None
+        if self.manager is not None:
+            self.manager.shutdown()
+            self.manager = None
+
+        dt = time.monotonic() - self.t1
+        if support.verbose:
+            print("%.2fs" % dt, end=' ')
+        self.assertLess(dt, 300, "synchronization issue: test lasted too long")
+
+        super().tearDown()
+
+    def get_context(self):
+        return multiprocessing.get_context(self.ctx)
+
+
+class ThreadPoolMixin(ExecutorMixin):
+    executor_type = futures.ThreadPoolExecutor
+
+    def create_event(self):
+        return threading.Event()
+
+
+class ProcessPoolForkMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "fork"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        if sys.platform == "win32":
+            self.skipTest("require unix system")
+        if support.check_sanitizer(thread=True):
+            self.skipTest("TSAN doesn't support threads after fork")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+class ProcessPoolSpawnMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "spawn"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+class ProcessPoolForkserverMixin(ExecutorMixin):
+    executor_type = futures.ProcessPoolExecutor
+    ctx = "forkserver"
+
+    def get_context(self):
+        try:
+            _check_system_limits()
+        except NotImplementedError:
+            self.skipTest("ProcessPoolExecutor unavailable on this system")
+        if sys.platform == "win32":
+            self.skipTest("require unix system")
+        if support.check_sanitizer(thread=True):
+            self.skipTest("TSAN doesn't support threads after fork")
+        return super().get_context()
+
+    def create_event(self):
+        return self.manager.Event()
+
+
+def create_executor_tests(remote_globals, mixin, bases=(BaseTestCase,),
+                          executor_mixins=(ThreadPoolMixin,
+                                           ProcessPoolForkMixin,
+                                           ProcessPoolForkserverMixin,
+                                           ProcessPoolSpawnMixin)):
+    def strip_mixin(name):
+        if name.endswith(('Mixin', 'Tests')):
+            return name[:-5]
+        elif name.endswith('Test'):
+            return name[:-4]
+        else:
+            return name
+
+    module = remote_globals['__name__']
+    for exe in executor_mixins:
+        name = ("%s%sTest"
+                % (strip_mixin(exe.__name__), strip_mixin(mixin.__name__)))
+        cls = type(name, (mixin,) + (exe,) + bases, {'__module__': module})
+        remote_globals[name] = cls
+
+
+def setup_module():
+    try:
+        _check_system_limits()
+    except NotImplementedError:
+        pass
+    else:
+        unittest.addModuleCleanup(multiprocessing.util._cleanup_tests)
+
+    thread_info = threading_helper.threading_setup()
+    unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
diff --git a/Lib/test/test_configparser.py b/Lib/test/test_configparser.py
index 01e8e6c675..d95b504f82 100644
--- a/Lib/test/test_configparser.py
+++ b/Lib/test/test_configparser.py
@@ -2,10 +2,8 @@
 import configparser
 import io
 import os
-import pathlib
 import textwrap
 import unittest
-import warnings
 
 from test import support
 from test.support import os_helper
@@ -545,7 +543,7 @@ def test_parse_errors(self):
                                 "[Foo]\n  wrong-indent\n")
             self.assertEqual(e.args, ('<???>',))
             # read_file on a real file
-            tricky = support.findfile("cfgparser.3")
+            tricky = support.findfile("cfgparser.3", subdir="configdata")
             if self.delimiters[0] == '=':
                 error = configparser.ParsingError
                 expected = (tricky,)
@@ -648,6 +646,21 @@ def test_weird_errors(self):
                                      "'opt' in section 'Bar' already exists")
             self.assertEqual(e.args, ("Bar", "opt", "<dict>", None))
 
+    def test_get_after_duplicate_option_error(self):
+        cf = self.newconfig()
+        ini = textwrap.dedent("""\
+            [Foo]
+            x{equals}1
+            y{equals}2
+            y{equals}3
+        """.format(equals=self.delimiters[0]))
+        if self.strict:
+            with self.assertRaises(configparser.DuplicateOptionError):
+                cf.read_string(ini)
+        else:
+            cf.read_string(ini)
+        self.assertEqual(cf.get('Foo', 'x'), '1')
+
     def test_write(self):
         config_string = (
             "[Long Line]\n"
@@ -719,7 +732,7 @@ class mystr(str):
     def test_read_returns_file_list(self):
         if self.delimiters[0] != '=':
             self.skipTest('incompatible format')
-        file1 = support.findfile("cfgparser.1")
+        file1 = support.findfile("cfgparser.1", subdir="configdata")
         # check when we pass a mix of readable and non-readable files:
         cf = self.newconfig()
         parsed_files = cf.read([file1, "nonexistent-file"], encoding="utf-8")
@@ -732,12 +745,12 @@ def test_read_returns_file_list(self):
         self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
         # check when we pass only a Path object:
         cf = self.newconfig()
-        parsed_files = cf.read(pathlib.Path(file1), encoding="utf-8")
+        parsed_files = cf.read(os_helper.FakePath(file1), encoding="utf-8")
         self.assertEqual(parsed_files, [file1])
         self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
         # check when we passed both a filename and a Path object:
         cf = self.newconfig()
-        parsed_files = cf.read([pathlib.Path(file1), file1], encoding="utf-8")
+        parsed_files = cf.read([os_helper.FakePath(file1), file1], encoding="utf-8")
         self.assertEqual(parsed_files, [file1, file1])
         self.assertEqual(cf.get("Foo Bar", "foo"), "newbar")
         # check when we pass only missing files:
@@ -749,11 +762,11 @@ def test_read_returns_file_list(self):
         parsed_files = cf.read([], encoding="utf-8")
         self.assertEqual(parsed_files, [])
 
-    @unittest.skip("TODO: RUSTPYTHON, suspected to make CI hang")
+    # XXX: RUSTPYTHON; This test might cause CI hang
     def test_read_returns_file_list_with_bytestring_path(self):
         if self.delimiters[0] != '=':
             self.skipTest('incompatible format')
-        file1_bytestring = support.findfile("cfgparser.1").encode()
+        file1_bytestring = support.findfile("cfgparser.1", subdir="configdata").encode()
         # check when passing an existing bytestring path
         cf = self.newconfig()
         parsed_files = cf.read(file1_bytestring, encoding="utf-8")
@@ -909,9 +922,6 @@ def test_interpolation(self):
         if self.interpolation == configparser._UNSET:
             self.assertEqual(e.args, ("bar11", "Foo",
                 "something %(with11)s lots of interpolation (11 steps)"))
-        elif isinstance(self.interpolation, configparser.LegacyInterpolation):
-            self.assertEqual(e.args, ("bar11", "Foo",
-                "something %(with11)s lots of interpolation (11 steps)"))
 
     def test_interpolation_missing_value(self):
         cf = self.get_interpolation_config()
@@ -923,9 +933,6 @@ def test_interpolation_missing_value(self):
         if self.interpolation == configparser._UNSET:
             self.assertEqual(e.args, ('name', 'Interpolation Error',
                                     '%(reference)s', 'reference'))
-        elif isinstance(self.interpolation, configparser.LegacyInterpolation):
-            self.assertEqual(e.args, ('name', 'Interpolation Error',
-                                    '%(reference)s', 'reference'))
 
     def test_items(self):
         self.check_items_config([('default', '<default>'),
@@ -944,9 +951,6 @@ def test_safe_interpolation(self):
         self.assertEqual(cf.get("section", "ok"), "xxx/%s")
         if self.interpolation == configparser._UNSET:
             self.assertEqual(cf.get("section", "not_ok"), "xxx/xxx/%s")
-        elif isinstance(self.interpolation, configparser.LegacyInterpolation):
-            with self.assertRaises(TypeError):
-                cf.get("section", "not_ok")
 
     def test_set_malformatted_interpolation(self):
         cf = self.fromstring("[sect]\n"
@@ -1027,31 +1031,6 @@ class CustomConfigParser(configparser.ConfigParser):
         cf.read_string(self.ini)
         self.assertMatchesIni(cf)
 
-
-class ConfigParserTestCaseLegacyInterpolation(ConfigParserTestCase):
-    config_class = configparser.ConfigParser
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", DeprecationWarning)
-        interpolation = configparser.LegacyInterpolation()
-
-    def test_set_malformatted_interpolation(self):
-        cf = self.fromstring("[sect]\n"
-                             "option1{eq}foo\n".format(eq=self.delimiters[0]))
-
-        self.assertEqual(cf.get('sect', "option1"), "foo")
-
-        cf.set("sect", "option1", "%foo")
-        self.assertEqual(cf.get('sect', "option1"), "%foo")
-        cf.set("sect", "option1", "foo%")
-        self.assertEqual(cf.get('sect', "option1"), "foo%")
-        cf.set("sect", "option1", "f%oo")
-        self.assertEqual(cf.get('sect', "option1"), "f%oo")
-
-        # bug #5741: double percents are *not* malformed
-        cf.set("sect", "option2", "foo%%bar")
-        self.assertEqual(cf.get("sect", "option2"), "foo%%bar")
-
-
 class ConfigParserTestCaseInvalidInterpolationType(unittest.TestCase):
     def test_error_on_wrong_type_for_interpolation(self):
         for value in [configparser.ExtendedInterpolation,  42,  "a string"]:
@@ -1163,7 +1142,7 @@ class RawConfigParserTestSambaConf(CfgParserTestCaseClass, unittest.TestCase):
     empty_lines_in_values = False
 
     def test_reading(self):
-        smbconf = support.findfile("cfgparser.2")
+        smbconf = support.findfile("cfgparser.2", subdir="configdata")
         # check when we pass a mix of readable and non-readable files:
         cf = self.newconfig()
         parsed_files = cf.read([smbconf, "nonexistent-file"], encoding='utf-8')
@@ -1351,6 +1330,47 @@ class ConfigParserTestCaseNoValue(ConfigParserTestCase):
     allow_no_value = True
 
 
+class NoValueAndExtendedInterpolation(CfgParserTestCaseClass):
+    interpolation = configparser.ExtendedInterpolation()
+    allow_no_value = True
+
+    def test_interpolation_with_allow_no_value(self):
+        config = textwrap.dedent("""
+            [dummy]
+            a
+            b = ${a}
+        """)
+        cf = self.fromstring(config)
+
+        self.assertIs(cf["dummy"]["a"], None)
+        self.assertEqual(cf["dummy"]["b"], "")
+
+    def test_explicit_none(self):
+        config = textwrap.dedent("""
+            [dummy]
+            a = None
+            b = ${a}
+        """)
+        cf = self.fromstring(config)
+
+        self.assertEqual(cf["dummy"]["a"], "None")
+        self.assertEqual(cf["dummy"]["b"], "None")
+
+
+class ConfigParserNoValueAndExtendedInterpolationTest(
+    NoValueAndExtendedInterpolation,
+    unittest.TestCase,
+):
+    config_class = configparser.ConfigParser
+
+
+class RawConfigParserNoValueAndExtendedInterpolationTest(
+    NoValueAndExtendedInterpolation,
+    unittest.TestCase,
+):
+    config_class = configparser.RawConfigParser
+
+
 class ConfigParserTestCaseTrickyFile(CfgParserTestCaseClass, unittest.TestCase):
     config_class = configparser.ConfigParser
     delimiters = {'='}
@@ -1358,7 +1378,7 @@ class ConfigParserTestCaseTrickyFile(CfgParserTestCaseClass, unittest.TestCase):
     allow_no_value = True
 
     def test_cfgparser_dot_3(self):
-        tricky = support.findfile("cfgparser.3")
+        tricky = support.findfile("cfgparser.3", subdir="configdata")
         cf = self.newconfig()
         self.assertEqual(len(cf.read(tricky, encoding='utf-8')), 1)
         self.assertEqual(cf.sections(), ['strange',
@@ -1390,7 +1410,7 @@ def test_cfgparser_dot_3(self):
         self.assertEqual(cf.get('more interpolation', 'lets'), 'go shopping')
 
     def test_unicode_failure(self):
-        tricky = support.findfile("cfgparser.3")
+        tricky = support.findfile("cfgparser.3", subdir="configdata")
         cf = self.newconfig()
         with self.assertRaises(UnicodeDecodeError):
             cf.read(tricky, encoding='ascii')
@@ -1491,7 +1511,7 @@ def fromstring(self, string, defaults=None):
 
 class FakeFile:
     def __init__(self):
-        file_path = support.findfile("cfgparser.1")
+        file_path = support.findfile("cfgparser.1", subdir="configdata")
         with open(file_path, encoding="utf-8") as f:
             self.lines = f.readlines()
             self.lines.reverse()
@@ -1512,7 +1532,7 @@ def readline_generator(f):
 
 class ReadFileTestCase(unittest.TestCase):
     def test_file(self):
-        file_paths = [support.findfile("cfgparser.1")]
+        file_paths = [support.findfile("cfgparser.1", subdir="configdata")]
         try:
             file_paths.append(file_paths[0].encode('utf8'))
         except UnicodeEncodeError:
@@ -1592,6 +1612,30 @@ def test_source_as_bytes(self):
             "'[badbad'"
         )
 
+    def test_keys_without_value_with_extra_whitespace(self):
+        lines = [
+            '[SECT]\n',
+            'KEY1\n',
+            ' KEY2 = VAL2\n', # note the Space before the key!
+        ]
+        parser = configparser.ConfigParser(
+            comment_prefixes="",
+            allow_no_value=True,
+            strict=False,
+            delimiters=('=',),
+            interpolation=None,
+        )
+        with self.assertRaises(configparser.MultilineContinuationError) as dse:
+            parser.read_file(lines)
+        self.assertEqual(
+            str(dse.exception),
+            "Key without value continued with an indented line.\n"
+            "file: '<???>', line: 3\n"
+            "' KEY2 = VAL2\\n'"
+        )
+
+
+
 
 class CoverageOneHundredTestCase(unittest.TestCase):
     """Covers edge cases in the codebase."""
@@ -1638,14 +1682,6 @@ def test_interpolation_validation(self):
         self.assertEqual(str(cm.exception), "bad interpolation variable "
                                             "reference '%(()'")
 
-    def test_legacyinterpolation_deprecation(self):
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter("always", DeprecationWarning)
-            configparser.LegacyInterpolation()
-        self.assertGreaterEqual(len(w), 1)
-        for warning in w:
-            self.assertIs(warning.category, DeprecationWarning)
-
     def test_sectionproxy_repr(self):
         parser = configparser.ConfigParser()
         parser.read_string("""
@@ -2121,6 +2157,63 @@ def test_instance_assignment(self):
             self.assertEqual(cfg['two'].getlen('one'), 5)
 
 
+class SectionlessTestCase(unittest.TestCase):
+
+    def fromstring(self, string):
+        cfg = configparser.ConfigParser(allow_unnamed_section=True)
+        cfg.read_string(string)
+        return cfg
+
+    def test_no_first_section(self):
+        cfg1 = self.fromstring("""
+        a = 1
+        b = 2
+        [sect1]
+        c = 3
+        """)
+
+        self.assertEqual(set([configparser.UNNAMED_SECTION, 'sect1']), set(cfg1.sections()))
+        self.assertEqual('1', cfg1[configparser.UNNAMED_SECTION]['a'])
+        self.assertEqual('2', cfg1[configparser.UNNAMED_SECTION]['b'])
+        self.assertEqual('3', cfg1['sect1']['c'])
+
+        output = io.StringIO()
+        cfg1.write(output)
+        cfg2 = self.fromstring(output.getvalue())
+
+        #self.assertEqual(set([configparser.UNNAMED_SECTION, 'sect1']), set(cfg2.sections()))
+        self.assertEqual('1', cfg2[configparser.UNNAMED_SECTION]['a'])
+        self.assertEqual('2', cfg2[configparser.UNNAMED_SECTION]['b'])
+        self.assertEqual('3', cfg2['sect1']['c'])
+
+    def test_no_section(self):
+        cfg1 = self.fromstring("""
+        a = 1
+        b = 2
+        """)
+
+        self.assertEqual([configparser.UNNAMED_SECTION], cfg1.sections())
+        self.assertEqual('1', cfg1[configparser.UNNAMED_SECTION]['a'])
+        self.assertEqual('2', cfg1[configparser.UNNAMED_SECTION]['b'])
+
+        output = io.StringIO()
+        cfg1.write(output)
+        cfg2 = self.fromstring(output.getvalue())
+
+        self.assertEqual([configparser.UNNAMED_SECTION], cfg2.sections())
+        self.assertEqual('1', cfg2[configparser.UNNAMED_SECTION]['a'])
+        self.assertEqual('2', cfg2[configparser.UNNAMED_SECTION]['b'])
+
+    def test_multiple_configs(self):
+        cfg = configparser.ConfigParser(allow_unnamed_section=True)
+        cfg.read_string('a = 1')
+        cfg.read_string('b = 2')
+
+        self.assertEqual([configparser.UNNAMED_SECTION], cfg.sections())
+        self.assertEqual('1', cfg[configparser.UNNAMED_SECTION]['a'])
+        self.assertEqual('2', cfg[configparser.UNNAMED_SECTION]['b'])
+
+
 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 c533311572..471d04a76c 100644
--- a/Lib/test/test_contains.py
+++ b/Lib/test/test_contains.py
@@ -36,7 +36,6 @@ def test_common_tests(self):
 
         self.assertRaises(TypeError, lambda: None in 'abc')
 
-    @unittest.skip("TODO: RUSTPYTHON, hangs")
     def test_builtin_sequence_types(self):
         # a collection of tests on builtin sequence types
         a = range(10)
diff --git a/Lib/test/test_context.py b/Lib/test/test_context.py
index 06270e161d..6083b53222 100644
--- a/Lib/test/test_context.py
+++ b/Lib/test/test_context.py
@@ -3,6 +3,7 @@
 import functools
 import gc
 import random
+import sys
 import time
 import unittest
 import weakref
@@ -358,9 +359,9 @@ def ctx2_fun():
 
         ctx1.run(ctx1_fun)
 
-    @unittest.skip("TODO: RUSTPYTHON; threading is not safe")
     @isolated_context
     @threading_helper.requires_working_threading()
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON; Flaky on Mac, self.assertEqual(cvar.get(), num + i) AssertionError: 8 != 12')
     def test_context_threads_1(self):
         cvar = contextvars.ContextVar('cvar')
 
diff --git a/Lib/test/test_contextlib.py b/Lib/test/test_contextlib.py
index 91764696ba..420cc2510a 100644
--- a/Lib/test/test_contextlib.py
+++ b/Lib/test/test_contextlib.py
@@ -24,6 +24,16 @@ def __exit__(self, *args):
         manager = DefaultEnter()
         self.assertIs(manager.__enter__(), manager)
 
+    def test_slots(self):
+        class DefaultContextManager(AbstractContextManager):
+            __slots__ = ()
+
+            def __exit__(self, *args):
+                super().__exit__(*args)
+
+        with self.assertRaises(AttributeError):
+            DefaultContextManager().var = 42
+
     def test_exit_is_abstract(self):
         class MissingExit(AbstractContextManager):
             pass
@@ -194,6 +204,7 @@ def whoo():
                 yield
             except RuntimeError:
                 raise SyntaxError
+
         ctx = whoo()
         ctx.__enter__()
         with self.assertRaises(SyntaxError):
@@ -285,9 +296,11 @@ def woohoo():
                 yield
             except Exception as exc:
                 raise RuntimeError(f'caught {exc}') from exc
+
         with self.assertRaises(RuntimeError):
             with woohoo():
                 1 / 0
+
         # If the context manager wrapped StopIteration in a RuntimeError,
         # we also unwrap it, because we can't tell whether the wrapping was
         # done by the generator machinery or by the generator itself.
@@ -831,8 +844,6 @@ def test_exit_suppress(self):
             stack.push(lambda *exc: True)
             1/0
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exit_exception_traceback(self):
         # This test captures the current behavior of ExitStack so that we know
         # if we ever unintendedly change it. It is not a statement of what the
@@ -1143,7 +1154,7 @@ def first():
 class TestExitStack(TestBaseExitStack, unittest.TestCase):
     exit_stack = ExitStack
     callback_error_internal_frames = [
-        ('__exit__', 'raise exc_details[1]'),
+        ('__exit__', 'raise exc'),
         ('__exit__', 'if cb(*exc_details):'),
     ]
 
@@ -1294,7 +1305,6 @@ def test_exception_groups(self):
                 [KeyError("ke1"), KeyError("ke2")],
             ),
         )
-
         # Check handling of BaseExceptionGroup, using GeneratorExit so that
         # we don't accidentally discard a ctrl-c with KeyboardInterrupt.
         with suppress(GeneratorExit):
@@ -1322,8 +1332,6 @@ def make_relative_path(self, *parts):
             *parts,
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_simple(self):
         old_cwd = os.getcwd()
         target = self.make_relative_path('data')
@@ -1333,12 +1341,10 @@ def test_simple(self):
             self.assertEqual(os.getcwd(), target)
         self.assertEqual(os.getcwd(), old_cwd)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reentrant(self):
         old_cwd = os.getcwd()
         target1 = self.make_relative_path('data')
-        target2 = self.make_relative_path('ziptestdata')
+        target2 = self.make_relative_path('archivetestdata')
         self.assertNotIn(old_cwd, (target1, target2))
         chdir1, chdir2 = chdir(target1), chdir(target2)
 
@@ -1352,8 +1358,6 @@ def test_reentrant(self):
             self.assertEqual(os.getcwd(), target1)
         self.assertEqual(os.getcwd(), old_cwd)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception(self):
         old_cwd = os.getcwd()
         target = self.make_relative_path('data')
diff --git a/Lib/test/test_contextlib_async.py b/Lib/test/test_contextlib_async.py
new file mode 100644
index 0000000000..b24599f058
--- /dev/null
+++ b/Lib/test/test_contextlib_async.py
@@ -0,0 +1,746 @@
+import asyncio
+from contextlib import (
+    asynccontextmanager, AbstractAsyncContextManager,
+    AsyncExitStack, nullcontext, aclosing, contextmanager)
+from test import support
+import unittest
+import traceback
+
+from test.test_contextlib import TestBaseExitStack
+
+support.requires_working_socket(module=True)
+
+def tearDownModule():
+    asyncio.set_event_loop_policy(None)
+
+
+class TestAbstractAsyncContextManager(unittest.IsolatedAsyncioTestCase):
+
+    async def test_enter(self):
+        class DefaultEnter(AbstractAsyncContextManager):
+            async def __aexit__(self, *args):
+                await super().__aexit__(*args)
+
+        manager = DefaultEnter()
+        self.assertIs(await manager.__aenter__(), manager)
+
+        async with manager as context:
+            self.assertIs(manager, context)
+
+    async def test_slots(self):
+        class DefaultAsyncContextManager(AbstractAsyncContextManager):
+            __slots__ = ()
+
+            async def __aexit__(self, *args):
+                await super().__aexit__(*args)
+
+        with self.assertRaises(AttributeError):
+            manager = DefaultAsyncContextManager()
+            manager.var = 42
+
+    async def test_async_gen_propagates_generator_exit(self):
+        # A regression test for https://bugs.python.org/issue33786.
+
+        @asynccontextmanager
+        async def ctx():
+            yield
+
+        async def gen():
+            async with ctx():
+                yield 11
+
+        g = gen()
+        async for val in g:
+            self.assertEqual(val, 11)
+            break
+        await g.aclose()
+
+    def test_exit_is_abstract(self):
+        class MissingAexit(AbstractAsyncContextManager):
+            pass
+
+        with self.assertRaises(TypeError):
+            MissingAexit()
+
+    def test_structural_subclassing(self):
+        class ManagerFromScratch:
+            async def __aenter__(self):
+                return self
+            async def __aexit__(self, exc_type, exc_value, traceback):
+                return None
+
+        self.assertTrue(issubclass(ManagerFromScratch, AbstractAsyncContextManager))
+
+        class DefaultEnter(AbstractAsyncContextManager):
+            async def __aexit__(self, *args):
+                await super().__aexit__(*args)
+
+        self.assertTrue(issubclass(DefaultEnter, AbstractAsyncContextManager))
+
+        class NoneAenter(ManagerFromScratch):
+            __aenter__ = None
+
+        self.assertFalse(issubclass(NoneAenter, AbstractAsyncContextManager))
+
+        class NoneAexit(ManagerFromScratch):
+            __aexit__ = None
+
+        self.assertFalse(issubclass(NoneAexit, AbstractAsyncContextManager))
+
+
+class AsyncContextManagerTestCase(unittest.IsolatedAsyncioTestCase):
+
+    async def test_contextmanager_plain(self):
+        state = []
+        @asynccontextmanager
+        async def woohoo():
+            state.append(1)
+            yield 42
+            state.append(999)
+        async with woohoo() as x:
+            self.assertEqual(state, [1])
+            self.assertEqual(x, 42)
+            state.append(x)
+        self.assertEqual(state, [1, 42, 999])
+
+    async def test_contextmanager_finally(self):
+        state = []
+        @asynccontextmanager
+        async def woohoo():
+            state.append(1)
+            try:
+                yield 42
+            finally:
+                state.append(999)
+        with self.assertRaises(ZeroDivisionError):
+            async with woohoo() as x:
+                self.assertEqual(state, [1])
+                self.assertEqual(x, 42)
+                state.append(x)
+                raise ZeroDivisionError()
+        self.assertEqual(state, [1, 42, 999])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    async def test_contextmanager_traceback(self):
+        @asynccontextmanager
+        async def f():
+            yield
+
+        try:
+            async with f():
+                1/0
+        except ZeroDivisionError as e:
+            frames = traceback.extract_tb(e.__traceback__)
+
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
+        self.assertEqual(frames[0].line, '1/0')
+
+        # Repeat with RuntimeError (which goes through a different code path)
+        class RuntimeErrorSubclass(RuntimeError):
+            pass
+
+        try:
+            async with f():
+                raise RuntimeErrorSubclass(42)
+        except RuntimeErrorSubclass as e:
+            frames = traceback.extract_tb(e.__traceback__)
+
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
+        self.assertEqual(frames[0].line, 'raise RuntimeErrorSubclass(42)')
+
+        class StopIterationSubclass(StopIteration):
+            pass
+
+        class StopAsyncIterationSubclass(StopAsyncIteration):
+            pass
+
+        for stop_exc in (
+            StopIteration('spam'),
+            StopAsyncIteration('ham'),
+            StopIterationSubclass('spam'),
+            StopAsyncIterationSubclass('spam')
+        ):
+            with self.subTest(type=type(stop_exc)):
+                try:
+                    async with f():
+                        raise stop_exc
+                except type(stop_exc) as e:
+                    self.assertIs(e, stop_exc)
+                    frames = traceback.extract_tb(e.__traceback__)
+                else:
+                    self.fail(f'{stop_exc} was suppressed')
+
+                self.assertEqual(len(frames), 1)
+                self.assertEqual(frames[0].name, 'test_contextmanager_traceback')
+                self.assertEqual(frames[0].line, 'raise stop_exc')
+
+    async def test_contextmanager_no_reraise(self):
+        @asynccontextmanager
+        async def whee():
+            yield
+        ctx = whee()
+        await ctx.__aenter__()
+        # Calling __aexit__ should not result in an exception
+        self.assertFalse(await ctx.__aexit__(TypeError, TypeError("foo"), None))
+
+    async def test_contextmanager_trap_yield_after_throw(self):
+        @asynccontextmanager
+        async def whoo():
+            try:
+                yield
+            except:
+                yield
+        ctx = whoo()
+        await ctx.__aenter__()
+        with self.assertRaises(RuntimeError):
+            await ctx.__aexit__(TypeError, TypeError('foo'), None)
+        if support.check_impl_detail(cpython=True):
+            # The "gen" attribute is an implementation detail.
+            self.assertFalse(ctx.gen.ag_suspended)
+
+    async def test_contextmanager_trap_no_yield(self):
+        @asynccontextmanager
+        async def whoo():
+            if False:
+                yield
+        ctx = whoo()
+        with self.assertRaises(RuntimeError):
+            await ctx.__aenter__()
+
+    async def test_contextmanager_trap_second_yield(self):
+        @asynccontextmanager
+        async def whoo():
+            yield
+            yield
+        ctx = whoo()
+        await ctx.__aenter__()
+        with self.assertRaises(RuntimeError):
+            await ctx.__aexit__(None, None, None)
+        if support.check_impl_detail(cpython=True):
+            # The "gen" attribute is an implementation detail.
+            self.assertFalse(ctx.gen.ag_suspended)
+
+    async def test_contextmanager_non_normalised(self):
+        @asynccontextmanager
+        async def whoo():
+            try:
+                yield
+            except RuntimeError:
+                raise SyntaxError
+
+        ctx = whoo()
+        await ctx.__aenter__()
+        with self.assertRaises(SyntaxError):
+            await ctx.__aexit__(RuntimeError, None, None)
+
+    async def test_contextmanager_except(self):
+        state = []
+        @asynccontextmanager
+        async def woohoo():
+            state.append(1)
+            try:
+                yield 42
+            except ZeroDivisionError as e:
+                state.append(e.args[0])
+                self.assertEqual(state, [1, 42, 999])
+        async with woohoo() as x:
+            self.assertEqual(state, [1])
+            self.assertEqual(x, 42)
+            state.append(x)
+            raise ZeroDivisionError(999)
+        self.assertEqual(state, [1, 42, 999])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    async def test_contextmanager_except_stopiter(self):
+        @asynccontextmanager
+        async def woohoo():
+            yield
+
+        class StopIterationSubclass(StopIteration):
+            pass
+
+        class StopAsyncIterationSubclass(StopAsyncIteration):
+            pass
+
+        for stop_exc in (
+            StopIteration('spam'),
+            StopAsyncIteration('ham'),
+            StopIterationSubclass('spam'),
+            StopAsyncIterationSubclass('spam')
+        ):
+            with self.subTest(type=type(stop_exc)):
+                try:
+                    async with woohoo():
+                        raise stop_exc
+                except Exception as ex:
+                    self.assertIs(ex, stop_exc)
+                else:
+                    self.fail(f'{stop_exc} was suppressed')
+
+    async def test_contextmanager_wrap_runtimeerror(self):
+        @asynccontextmanager
+        async def woohoo():
+            try:
+                yield
+            except Exception as exc:
+                raise RuntimeError(f'caught {exc}') from exc
+
+        with self.assertRaises(RuntimeError):
+            async with woohoo():
+                1 / 0
+
+        # If the context manager wrapped StopAsyncIteration in a RuntimeError,
+        # we also unwrap it, because we can't tell whether the wrapping was
+        # done by the generator machinery or by the generator itself.
+        with self.assertRaises(StopAsyncIteration):
+            async with woohoo():
+                raise StopAsyncIteration
+
+    def _create_contextmanager_attribs(self):
+        def attribs(**kw):
+            def decorate(func):
+                for k,v in kw.items():
+                    setattr(func,k,v)
+                return func
+            return decorate
+        @asynccontextmanager
+        @attribs(foo='bar')
+        async def baz(spam):
+            """Whee!"""
+            yield
+        return baz
+
+    def test_contextmanager_attribs(self):
+        baz = self._create_contextmanager_attribs()
+        self.assertEqual(baz.__name__,'baz')
+        self.assertEqual(baz.foo, 'bar')
+
+    @support.requires_docstrings
+    def test_contextmanager_doc_attrib(self):
+        baz = self._create_contextmanager_attribs()
+        self.assertEqual(baz.__doc__, "Whee!")
+
+    @support.requires_docstrings
+    async def test_instance_docstring_given_cm_docstring(self):
+        baz = self._create_contextmanager_attribs()(None)
+        self.assertEqual(baz.__doc__, "Whee!")
+        async with baz:
+            pass  # suppress warning
+
+    async def test_keywords(self):
+        # Ensure no keyword arguments are inhibited
+        @asynccontextmanager
+        async def woohoo(self, func, args, kwds):
+            yield (self, func, args, kwds)
+        async with woohoo(self=11, func=22, args=33, kwds=44) as target:
+            self.assertEqual(target, (11, 22, 33, 44))
+
+    async def test_recursive(self):
+        depth = 0
+        ncols = 0
+
+        @asynccontextmanager
+        async def woohoo():
+            nonlocal ncols
+            ncols += 1
+
+            nonlocal depth
+            before = depth
+            depth += 1
+            yield
+            depth -= 1
+            self.assertEqual(depth, before)
+
+        @woohoo()
+        async def recursive():
+            if depth < 10:
+                await recursive()
+
+        await recursive()
+
+        self.assertEqual(ncols, 10)
+        self.assertEqual(depth, 0)
+
+    async def test_decorator(self):
+        entered = False
+
+        @asynccontextmanager
+        async def context():
+            nonlocal entered
+            entered = True
+            yield
+            entered = False
+
+        @context()
+        async def test():
+            self.assertTrue(entered)
+
+        self.assertFalse(entered)
+        await test()
+        self.assertFalse(entered)
+
+    async def test_decorator_with_exception(self):
+        entered = False
+
+        @asynccontextmanager
+        async def context():
+            nonlocal entered
+            try:
+                entered = True
+                yield
+            finally:
+                entered = False
+
+        @context()
+        async def test():
+            self.assertTrue(entered)
+            raise NameError('foo')
+
+        self.assertFalse(entered)
+        with self.assertRaisesRegex(NameError, 'foo'):
+            await test()
+        self.assertFalse(entered)
+
+    async def test_decorating_method(self):
+
+        @asynccontextmanager
+        async def context():
+            yield
+
+
+        class Test(object):
+
+            @context()
+            async def method(self, a, b, c=None):
+                self.a = a
+                self.b = b
+                self.c = c
+
+        # these tests are for argument passing when used as a decorator
+        test = Test()
+        await test.method(1, 2)
+        self.assertEqual(test.a, 1)
+        self.assertEqual(test.b, 2)
+        self.assertEqual(test.c, None)
+
+        test = Test()
+        await test.method('a', 'b', 'c')
+        self.assertEqual(test.a, 'a')
+        self.assertEqual(test.b, 'b')
+        self.assertEqual(test.c, 'c')
+
+        test = Test()
+        await test.method(a=1, b=2)
+        self.assertEqual(test.a, 1)
+        self.assertEqual(test.b, 2)
+
+
+class AclosingTestCase(unittest.IsolatedAsyncioTestCase):
+
+    @support.requires_docstrings
+    def test_instance_docs(self):
+        cm_docstring = aclosing.__doc__
+        obj = aclosing(None)
+        self.assertEqual(obj.__doc__, cm_docstring)
+
+    async def test_aclosing(self):
+        state = []
+        class C:
+            async def aclose(self):
+                state.append(1)
+        x = C()
+        self.assertEqual(state, [])
+        async with aclosing(x) as y:
+            self.assertEqual(x, y)
+        self.assertEqual(state, [1])
+
+    async def test_aclosing_error(self):
+        state = []
+        class C:
+            async def aclose(self):
+                state.append(1)
+        x = C()
+        self.assertEqual(state, [])
+        with self.assertRaises(ZeroDivisionError):
+            async with aclosing(x) as y:
+                self.assertEqual(x, y)
+                1 / 0
+        self.assertEqual(state, [1])
+
+    async def test_aclosing_bpo41229(self):
+        state = []
+
+        @contextmanager
+        def sync_resource():
+            try:
+                yield
+            finally:
+                state.append(1)
+
+        async def agenfunc():
+            with sync_resource():
+                yield -1
+                yield -2
+
+        x = agenfunc()
+        self.assertEqual(state, [])
+        with self.assertRaises(ZeroDivisionError):
+            async with aclosing(x) as y:
+                self.assertEqual(x, y)
+                self.assertEqual(-1, await x.__anext__())
+                1 / 0
+        self.assertEqual(state, [1])
+
+
+class TestAsyncExitStack(TestBaseExitStack, unittest.IsolatedAsyncioTestCase):
+    class SyncAsyncExitStack(AsyncExitStack):
+        @staticmethod
+        def run_coroutine(coro):
+            loop = asyncio.get_event_loop_policy().get_event_loop()
+            t = loop.create_task(coro)
+            t.add_done_callback(lambda f: loop.stop())
+            loop.run_forever()
+
+            exc = t.exception()
+            if not exc:
+                return t.result()
+            else:
+                context = exc.__context__
+
+                try:
+                    raise exc
+                except:
+                    exc.__context__ = context
+                    raise exc
+
+        def close(self):
+            return self.run_coroutine(self.aclose())
+
+        def __enter__(self):
+            return self.run_coroutine(self.__aenter__())
+
+        def __exit__(self, *exc_details):
+            return self.run_coroutine(self.__aexit__(*exc_details))
+
+    exit_stack = SyncAsyncExitStack
+    callback_error_internal_frames = [
+        ('__exit__', 'return self.run_coroutine(self.__aexit__(*exc_details))'),
+        ('run_coroutine', 'raise exc'),
+        ('run_coroutine', 'raise exc'),
+        ('__aexit__', 'raise exc'),
+        ('__aexit__', 'cb_suppress = cb(*exc_details)'),
+    ]
+
+    async def test_async_callback(self):
+        expected = [
+            ((), {}),
+            ((1,), {}),
+            ((1,2), {}),
+            ((), dict(example=1)),
+            ((1,), dict(example=1)),
+            ((1,2), dict(example=1)),
+        ]
+        result = []
+        async def _exit(*args, **kwds):
+            """Test metadata propagation"""
+            result.append((args, kwds))
+
+        async with AsyncExitStack() as stack:
+            for args, kwds in reversed(expected):
+                if args and kwds:
+                    f = stack.push_async_callback(_exit, *args, **kwds)
+                elif args:
+                    f = stack.push_async_callback(_exit, *args)
+                elif kwds:
+                    f = stack.push_async_callback(_exit, **kwds)
+                else:
+                    f = stack.push_async_callback(_exit)
+                self.assertIs(f, _exit)
+            for wrapper in stack._exit_callbacks:
+                self.assertIs(wrapper[1].__wrapped__, _exit)
+                self.assertNotEqual(wrapper[1].__name__, _exit.__name__)
+                self.assertIsNone(wrapper[1].__doc__, _exit.__doc__)
+
+        self.assertEqual(result, expected)
+
+        result = []
+        async with AsyncExitStack() as stack:
+            with self.assertRaises(TypeError):
+                stack.push_async_callback(arg=1)
+            with self.assertRaises(TypeError):
+                self.exit_stack.push_async_callback(arg=2)
+            with self.assertRaises(TypeError):
+                stack.push_async_callback(callback=_exit, arg=3)
+        self.assertEqual(result, [])
+
+    async def test_async_push(self):
+        exc_raised = ZeroDivisionError
+        async def _expect_exc(exc_type, exc, exc_tb):
+            self.assertIs(exc_type, exc_raised)
+        async def _suppress_exc(*exc_details):
+            return True
+        async def _expect_ok(exc_type, exc, exc_tb):
+            self.assertIsNone(exc_type)
+            self.assertIsNone(exc)
+            self.assertIsNone(exc_tb)
+        class ExitCM(object):
+            def __init__(self, check_exc):
+                self.check_exc = check_exc
+            async def __aenter__(self):
+                self.fail("Should not be called!")
+            async def __aexit__(self, *exc_details):
+                await self.check_exc(*exc_details)
+
+        async with self.exit_stack() as stack:
+            stack.push_async_exit(_expect_ok)
+            self.assertIs(stack._exit_callbacks[-1][1], _expect_ok)
+            cm = ExitCM(_expect_ok)
+            stack.push_async_exit(cm)
+            self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
+            stack.push_async_exit(_suppress_exc)
+            self.assertIs(stack._exit_callbacks[-1][1], _suppress_exc)
+            cm = ExitCM(_expect_exc)
+            stack.push_async_exit(cm)
+            self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
+            stack.push_async_exit(_expect_exc)
+            self.assertIs(stack._exit_callbacks[-1][1], _expect_exc)
+            stack.push_async_exit(_expect_exc)
+            self.assertIs(stack._exit_callbacks[-1][1], _expect_exc)
+            1/0
+
+    async def test_enter_async_context(self):
+        class TestCM(object):
+            async def __aenter__(self):
+                result.append(1)
+            async def __aexit__(self, *exc_details):
+                result.append(3)
+
+        result = []
+        cm = TestCM()
+
+        async with AsyncExitStack() as stack:
+            @stack.push_async_callback  # Registered first => cleaned up last
+            async def _exit():
+                result.append(4)
+            self.assertIsNotNone(_exit)
+            await stack.enter_async_context(cm)
+            self.assertIs(stack._exit_callbacks[-1][1].__self__, cm)
+            result.append(2)
+
+        self.assertEqual(result, [1, 2, 3, 4])
+
+    async def test_enter_async_context_errors(self):
+        class LacksEnterAndExit:
+            pass
+        class LacksEnter:
+            async def __aexit__(self, *exc_info):
+                pass
+        class LacksExit:
+            async def __aenter__(self):
+                pass
+
+        async with self.exit_stack() as stack:
+            with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+                await stack.enter_async_context(LacksEnterAndExit())
+            with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+                await stack.enter_async_context(LacksEnter())
+            with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+                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):
+            raise exc
+
+        saved_details = None
+        async def suppress_exc(*exc_details):
+            nonlocal saved_details
+            saved_details = exc_details
+            return True
+
+        try:
+            async with self.exit_stack() as stack:
+                stack.push_async_callback(raise_exc, IndexError)
+                stack.push_async_callback(raise_exc, KeyError)
+                stack.push_async_callback(raise_exc, AttributeError)
+                stack.push_async_exit(suppress_exc)
+                stack.push_async_callback(raise_exc, ValueError)
+                1 / 0
+        except IndexError as exc:
+            self.assertIsInstance(exc.__context__, KeyError)
+            self.assertIsInstance(exc.__context__.__context__, AttributeError)
+            # Inner exceptions were suppressed
+            self.assertIsNone(exc.__context__.__context__.__context__)
+        else:
+            self.fail("Expected IndexError, but no exception was raised")
+        # Check the inner exceptions
+        inner_exc = saved_details[1]
+        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.
+
+        class MyException(Exception):
+            pass
+
+        @asynccontextmanager
+        async def my_cm():
+            try:
+                yield
+            except BaseException:
+                exc = MyException()
+                try:
+                    raise exc
+                finally:
+                    exc.__context__ = None
+
+        @asynccontextmanager
+        async def my_cm_with_exit_stack():
+            async with self.exit_stack() as stack:
+                await stack.enter_async_context(my_cm())
+                yield stack
+
+        for cm in (my_cm, my_cm_with_exit_stack):
+            with self.subTest():
+                try:
+                    async with cm():
+                        raise IndexError()
+                except MyException as exc:
+                    self.assertIsNone(exc.__context__)
+                else:
+                    self.fail("Expected IndexError, but no exception was raised")
+
+    async def test_instance_bypass_async(self):
+        class Example(object): pass
+        cm = Example()
+        cm.__aenter__ = object()
+        cm.__aexit__ = object()
+        stack = self.exit_stack()
+        with self.assertRaisesRegex(TypeError, 'asynchronous context manager'):
+            await stack.enter_async_context(cm)
+        stack.push_async_exit(cm)
+        self.assertIs(stack._exit_callbacks[-1][1], cm)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; - no _asyncio module, pure Python Task adds extra frame
+    def test_exit_exception_traceback(self):
+        return super().test_exit_exception_traceback()
+
+
+class TestAsyncNullcontext(unittest.IsolatedAsyncioTestCase):
+    async def test_async_nullcontext(self):
+        class C:
+            pass
+        c = C()
+        async with nullcontext(c) as c_in:
+            self.assertIs(c_in, c)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 2f9d8ed9b6..e543cc236c 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -207,8 +207,6 @@ def __eq__(self, other):
         self.assertIsNot(y, x)
         self.assertEqual(y.foo, x.foo)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_copy_inst_getnewargs_ex(self):
         class C(int):
             def __new__(cls, *, foo):
@@ -507,8 +505,6 @@ def __eq__(self, other):
         self.assertEqual(y.foo, x.foo)
         self.assertIsNot(y.foo, x.foo)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_deepcopy_inst_getnewargs_ex(self):
         class C(int):
             def __new__(cls, *, foo):
@@ -961,8 +957,6 @@ class PointFromClass(NamedTuple):
                 with self.assertRaisesRegex(TypeError, 'unexpected field name'):
                     copy.replace(p, x=1, error=2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dataclass(self):
         from dataclasses import dataclass
         @dataclass
diff --git a/Lib/test/test_csv.py b/Lib/test/test_csv.py
index 9a1743da6d..bf9b187557 100644
--- a/Lib/test/test_csv.py
+++ b/Lib/test/test_csv.py
@@ -10,7 +10,7 @@
 import gc
 import pickle
 from test import support
-from test.support import warnings_helper, import_helper, check_disallow_instantiation
+from test.support import import_helper, check_disallow_instantiation
 from itertools import permutations
 from textwrap import dedent
 from collections import OrderedDict
@@ -28,14 +28,20 @@ class Test_Csv(unittest.TestCase):
     in TestDialectRegistry.
     """
     def _test_arg_valid(self, ctor, arg):
+        ctor(arg)
         self.assertRaises(TypeError, ctor)
         self.assertRaises(TypeError, ctor, None)
-        self.assertRaises(TypeError, ctor, arg, bad_attr = 0)
-        self.assertRaises(TypeError, ctor, arg, delimiter = 0)
-        self.assertRaises(TypeError, ctor, arg, delimiter = 'XX')
+        self.assertRaises(TypeError, ctor, arg, bad_attr=0)
+        self.assertRaises(TypeError, ctor, arg, delimiter='')
+        self.assertRaises(TypeError, ctor, arg, escapechar='')
+        self.assertRaises(TypeError, ctor, arg, quotechar='')
+        self.assertRaises(TypeError, ctor, arg, delimiter='^^')
+        self.assertRaises(TypeError, ctor, arg, escapechar='^^')
+        self.assertRaises(TypeError, ctor, arg, quotechar='^^')
         self.assertRaises(csv.Error, ctor, arg, 'foo')
         self.assertRaises(TypeError, ctor, arg, delimiter=None)
         self.assertRaises(TypeError, ctor, arg, delimiter=1)
+        self.assertRaises(TypeError, ctor, arg, escapechar=1)
         self.assertRaises(TypeError, ctor, arg, quotechar=1)
         self.assertRaises(TypeError, ctor, arg, lineterminator=None)
         self.assertRaises(TypeError, ctor, arg, lineterminator=1)
@@ -46,11 +52,46 @@ def _test_arg_valid(self, ctor, arg):
                           quoting=csv.QUOTE_ALL, quotechar=None)
         self.assertRaises(TypeError, ctor, arg,
                           quoting=csv.QUOTE_NONE, quotechar='')
-
+        self.assertRaises(ValueError, ctor, arg, delimiter='\n')
+        self.assertRaises(ValueError, ctor, arg, escapechar='\n')
+        self.assertRaises(ValueError, ctor, arg, quotechar='\n')
+        self.assertRaises(ValueError, ctor, arg, delimiter='\r')
+        self.assertRaises(ValueError, ctor, arg, escapechar='\r')
+        self.assertRaises(ValueError, ctor, arg, quotechar='\r')
+        ctor(arg, delimiter=' ')
+        ctor(arg, escapechar=' ')
+        ctor(arg, quotechar=' ')
+        ctor(arg, delimiter='\t', skipinitialspace=True)
+        ctor(arg, escapechar='\t', skipinitialspace=True)
+        ctor(arg, quotechar='\t', skipinitialspace=True)
+        ctor(arg, delimiter=' ', skipinitialspace=True)
+        self.assertRaises(ValueError, ctor, arg,
+                          escapechar=' ', skipinitialspace=True)
+        self.assertRaises(ValueError, ctor, arg,
+                          quotechar=' ', skipinitialspace=True)
+        ctor(arg, delimiter='^')
+        ctor(arg, escapechar='^')
+        ctor(arg, quotechar='^')
+        self.assertRaises(ValueError, ctor, arg, delimiter='^', escapechar='^')
+        self.assertRaises(ValueError, ctor, arg, delimiter='^', quotechar='^')
+        self.assertRaises(ValueError, ctor, arg, escapechar='^', quotechar='^')
+        ctor(arg, delimiter='\x85')
+        ctor(arg, escapechar='\x85')
+        ctor(arg, quotechar='\x85')
+        ctor(arg, lineterminator='\x85')
+        self.assertRaises(ValueError, ctor, arg,
+                          delimiter='\x85', lineterminator='\x85')
+        self.assertRaises(ValueError, ctor, arg,
+                          escapechar='\x85', lineterminator='\x85')
+        self.assertRaises(ValueError, ctor, arg,
+                          quotechar='\x85', lineterminator='\x85')
+
+    @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
     def test_writer_arg_valid(self):
         self._test_arg_valid(csv.writer, StringIO())
         class BadWriter:
@@ -150,13 +191,8 @@ def _write_error_test(self, exc, fields, **kwargs):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), '')
 
-    # TODO: RUSTPYTHON ''\r\n to ""\r\n unsupported
-    @unittest.expectedFailure
     def test_write_arg_valid(self):
         self._write_error_test(csv.Error, None)
-        self._write_test((), '')
-        self._write_test([None], '""')
-        self._write_error_test(csv.Error, [None], quoting = csv.QUOTE_NONE)
         # Check that exceptions are passed up the chain
         self._write_error_test(OSError, BadIterable())
         class BadList:
@@ -170,15 +206,13 @@ class BadItem:
             def __str__(self):
                 raise OSError
         self._write_error_test(OSError, [BadItem()])
-
     def test_write_bigfield(self):
         # This exercises the buffer realloc functionality
         bigstring = 'X' * 50000
         self._write_test([bigstring,bigstring], '%s,%s' % \
                          (bigstring, bigstring))
 
-    # TODO: RUSTPYTHON quoting style check is unsupported
-    @unittest.expectedFailure
+    @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'],
@@ -196,8 +230,7 @@ def test_write_quoting(self):
         self._write_test(['a','',None,1], '"a","",,"1"',
                          quoting = csv.QUOTE_NOTNULL)
 
-    # TODO: RUSTPYTHON doublequote check is unsupported
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_escape(self):
         self._write_test(['a',1,'p,q'], 'a,1,"p,q"',
                          escapechar='\\')
@@ -229,8 +262,7 @@ def test_write_escape(self):
         self._write_test(['C\\', '6', '7', 'X"'], 'C\\\\,6,7,"X"""',
                          escapechar='\\', quoting=csv.QUOTE_MINIMAL)
 
-    # TODO: RUSTPYTHON lineterminator double char unsupported
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_lineterminator(self):
         for lineterminator in '\r\n', '\n', '\r', '!@#', '\0':
             with self.subTest(lineterminator=lineterminator):
@@ -238,12 +270,13 @@ def test_write_lineterminator(self):
                     writer = csv.writer(sio, lineterminator=lineterminator)
                     writer.writerow(['a', 'b'])
                     writer.writerow([1, 2])
+                    writer.writerow(['\r', '\n'])
                     self.assertEqual(sio.getvalue(),
                                      f'a,b{lineterminator}'
-                                     f'1,2{lineterminator}')
+                                     f'1,2{lineterminator}'
+                                     f'"\r","\n"{lineterminator}')
 
-    # TODO: RUSTPYTHON ''\r\n to ""\r\n unspported
-    @unittest.expectedFailure
+    @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,')
@@ -285,6 +318,51 @@ def test_writerows_with_none(self):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), 'a\r\n""\r\n')
 
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_write_empty_fields(self):
+        self._write_test((), '')
+        self._write_test([''], '""')
+        self._write_error_test(csv.Error, [''], quoting=csv.QUOTE_NONE)
+        self._write_test([''], '""', quoting=csv.QUOTE_STRINGS)
+        self._write_test([''], '""', quoting=csv.QUOTE_NOTNULL)
+        self._write_test([None], '""')
+        self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_NONE)
+        self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_STRINGS)
+        self._write_error_test(csv.Error, [None], quoting=csv.QUOTE_NOTNULL)
+        self._write_test(['', ''], ',')
+        self._write_test([None, None], ',')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_write_empty_fields_space_delimiter(self):
+        self._write_test([''], '""', delimiter=' ', skipinitialspace=False)
+        self._write_test([''], '""', delimiter=' ', skipinitialspace=True)
+        self._write_test([None], '""', delimiter=' ', skipinitialspace=False)
+        self._write_test([None], '""', delimiter=' ', skipinitialspace=True)
+
+        self._write_test(['', ''], ' ', delimiter=' ', skipinitialspace=False)
+        self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=True)
+        self._write_test([None, None], ' ', delimiter=' ', skipinitialspace=False)
+        self._write_test([None, None], '"" ""', delimiter=' ', skipinitialspace=True)
+
+        self._write_test(['', ''], ' ', delimiter=' ', skipinitialspace=False,
+                         quoting=csv.QUOTE_NONE)
+        self._write_error_test(csv.Error, ['', ''],
+                               delimiter=' ', skipinitialspace=True,
+                               quoting=csv.QUOTE_NONE)
+        for quoting in csv.QUOTE_STRINGS, csv.QUOTE_NOTNULL:
+            self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=False,
+                             quoting=quoting)
+            self._write_test(['', ''], '"" ""', delimiter=' ', skipinitialspace=True,
+                             quoting=quoting)
+
+        for quoting in csv.QUOTE_NONE, csv.QUOTE_STRINGS, csv.QUOTE_NOTNULL:
+            self._write_test([None, None], ' ', delimiter=' ', skipinitialspace=False,
+                             quoting=quoting)
+            self._write_error_test(csv.Error, [None, None],
+                                   delimiter=' ', skipinitialspace=True,
+                                   quoting=quoting)
+
     def test_writerows_errors(self):
         with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
             writer = csv.writer(fileobj)
@@ -296,8 +374,7 @@ def _read_test(self, input, expect, **kwargs):
         result = list(reader)
         self.assertEqual(result, expect)
 
-    # TODO RUSTPYTHON strict mode is unsupported
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_oddinputs(self):
         self._read_test([], [])
         self._read_test([''], [[]])
@@ -308,17 +385,22 @@ def test_read_oddinputs(self):
         self.assertRaises(csv.Error, self._read_test,
                           [b'abc'], None)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_eol(self):
-        self._read_test(['a,b'], [['a','b']])
-        self._read_test(['a,b\n'], [['a','b']])
-        self._read_test(['a,b\r\n'], [['a','b']])
-        self._read_test(['a,b\r'], [['a','b']])
-        self.assertRaises(csv.Error, self._read_test, ['a,b\rc,d'], [])
-        self.assertRaises(csv.Error, self._read_test, ['a,b\nc,d'], [])
-        self.assertRaises(csv.Error, self._read_test, ['a,b\r\nc,d'], [])
-
-    # TODO RUSTPYTHON double quote umimplement
-    @unittest.expectedFailure
+        self._read_test(['a,b', 'c,d'], [['a','b'], ['c','d']])
+        self._read_test(['a,b\n', 'c,d\n'], [['a','b'], ['c','d']])
+        self._read_test(['a,b\r\n', 'c,d\r\n'], [['a','b'], ['c','d']])
+        self._read_test(['a,b\r', 'c,d\r'], [['a','b'], ['c','d']])
+
+        errmsg = "with newline=''"
+        with self.assertRaisesRegex(csv.Error, errmsg):
+            next(csv.reader(['a,b\rc,d']))
+        with self.assertRaisesRegex(csv.Error, errmsg):
+            next(csv.reader(['a,b\nc,d']))
+        with self.assertRaisesRegex(csv.Error, errmsg):
+            next(csv.reader(['a,b\r\nc,d']))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_eof(self):
         self._read_test(['a,"'], [['a', '']])
         self._read_test(['"a'], [['a']])
@@ -328,8 +410,7 @@ def test_read_eof(self):
         self.assertRaises(csv.Error, self._read_test,
                           ['^'], [], escapechar='^', strict=True)
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_nul(self):
         self._read_test(['\0'], [['\0']])
         self._read_test(['a,\0b,c'], [['a', '\0b', 'c']])
@@ -342,8 +423,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')
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @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='\\')
@@ -356,8 +436,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']])
 
-    # TODO RUSTPYTHON escapechar unsupported
-    @unittest.expectedFailure
+    @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']],
@@ -367,17 +446,56 @@ def test_read_quoting(self):
         # will this fail where locale uses comma for decimals?
         self._read_test([',3,"5",7.3, 9'], [['', 3, '5', 7.3, 9]],
                         quoting=csv.QUOTE_NONNUMERIC)
+        self._read_test([',3,"5",7.3, 9'], [[None, '3', '5', '7.3', ' 9']],
+                        quoting=csv.QUOTE_NOTNULL)
+        self._read_test([',3,"5",7.3, 9'], [[None, 3, '5', 7.3, 9]],
+                        quoting=csv.QUOTE_STRINGS)
+
+        self._read_test([',,"",'], [['', '', '', '']])
+        self._read_test([',,"",'], [['', '', '', '']],
+                        quoting=csv.QUOTE_NONNUMERIC)
+        self._read_test([',,"",'], [[None, None, '', None]],
+                        quoting=csv.QUOTE_NOTNULL)
+        self._read_test([',,"",'], [[None, None, '', None]],
+                        quoting=csv.QUOTE_STRINGS)
+
         self._read_test(['"a\nb", 7'], [['a\nb', ' 7']])
         self.assertRaises(ValueError, self._read_test,
                           ['abc,3'], [[]],
                           quoting=csv.QUOTE_NONNUMERIC)
+        self.assertRaises(ValueError, self._read_test,
+                          ['abc,3'], [[]],
+                          quoting=csv.QUOTE_STRINGS)
         self._read_test(['1,@,3,@,5'], [['1', ',3,', '5']], quotechar='@')
         self._read_test(['1,\0,3,\0,5'], [['1', ',3,', '5']], quotechar='\0')
+        self._read_test(['1\\.5,\\.5,.5'], [[1.5, 0.5, 0.5]],
+                        quoting=csv.QUOTE_NONNUMERIC, escapechar='\\')
+        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')
     def test_read_skipinitialspace(self):
         self._read_test(['no space, space,  spaces,\ttab'],
                         [['no space', 'space', 'spaces', '\ttab']],
                         skipinitialspace=True)
+        self._read_test([' , , '],
+                        [['', '', '']],
+                        skipinitialspace=True)
+        self._read_test([' , , '],
+                        [[None, None, None]],
+                        skipinitialspace=True, quoting=csv.QUOTE_NOTNULL)
+        self._read_test([' , , '],
+                        [[None, None, None]],
+                        skipinitialspace=True, quoting=csv.QUOTE_STRINGS)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_read_space_delimiter(self):
+        self._read_test(['a   b', '  a  ', '  ', ''],
+                        [['a', '', '', 'b'], ['', '', 'a', '', ''], ['', '', ''], []],
+                        delimiter=' ', skipinitialspace=False)
+        self._read_test(['a   b', '  a  ', '  ', ''],
+                        [['a', 'b'], ['a', ''], [''], []],
+                        delimiter=' ', skipinitialspace=True)
 
     def test_read_bigfield(self):
         # This exercises the buffer realloc functionality and field size
@@ -410,27 +528,47 @@ def test_read_linenum(self):
         self.assertRaises(StopIteration, next, r)
         self.assertEqual(r.line_num, 3)
 
-    # TODO: RUSTPYTHON only '\r\n' unsupported
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_quoteed_newlines(self):
-        with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
-            writer = csv.writer(fileobj)
-            rows = [['a\nb','b'],['c','x\r\nd']]
-            writer.writerows(rows)
-            fileobj.seek(0)
-            for i, row in enumerate(csv.reader(fileobj)):
-                self.assertEqual(row, rows[i])
-
-    # TODO: RUSTPYTHON only '\r\n' unsupported
-    @unittest.expectedFailure
+        rows = [
+            ['\na', 'b\nc', 'd\n'],
+            ['\re', 'f\rg', 'h\r'],
+            ['\r\ni', 'j\r\nk', 'l\r\n'],
+            ['\n\rm', 'n\n\ro', 'p\n\r'],
+            ['\r\rq', 'r\r\rs', 't\r\r'],
+            ['\n\nu', 'v\n\nw', 'x\n\n'],
+        ]
+        for lineterminator in '\r\n', '\n', '\r':
+            with self.subTest(lineterminator=lineterminator):
+                with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
+                    writer = csv.writer(fileobj, lineterminator=lineterminator)
+                    writer.writerows(rows)
+                    fileobj.seek(0)
+                    for i, row in enumerate(csv.reader(fileobj)):
+                        self.assertEqual(row, rows[i])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_roundtrip_escaped_unquoted_newlines(self):
-        with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
-            writer = csv.writer(fileobj,quoting=csv.QUOTE_NONE,escapechar="\\")
-            rows = [['a\nb','b'],['c','x\r\nd']]
-            writer.writerows(rows)
-            fileobj.seek(0)
-            for i, row in enumerate(csv.reader(fileobj,quoting=csv.QUOTE_NONE,escapechar="\\")):
-                self.assertEqual(row,rows[i])
+        rows = [
+            ['\na', 'b\nc', 'd\n'],
+            ['\re', 'f\rg', 'h\r'],
+            ['\r\ni', 'j\r\nk', 'l\r\n'],
+            ['\n\rm', 'n\n\ro', 'p\n\r'],
+            ['\r\rq', 'r\r\rs', 't\r\r'],
+            ['\n\nu', 'v\n\nw', 'x\n\n'],
+        ]
+        for lineterminator in '\r\n', '\n', '\r':
+            with self.subTest(lineterminator=lineterminator):
+                with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
+                    writer = csv.writer(fileobj, lineterminator=lineterminator,
+                                        quoting=csv.QUOTE_NONE, escapechar="\\")
+                    writer.writerows(rows)
+                    fileobj.seek(0)
+                    for i, row in enumerate(csv.reader(fileobj,
+                                                       quoting=csv.QUOTE_NONE,
+                                                       escapechar="\\")):
+                        self.assertEqual(row, rows[i])
+
 
 class TestDialectRegistry(unittest.TestCase):
     def test_registry_badargs(self):
@@ -509,10 +647,10 @@ class space(csv.excel):
             escapechar = "\\"
 
         with TemporaryFile("w+", encoding="utf-8") as fileobj:
-            fileobj.write("abc def\nc1ccccc1 benzene\n")
+            fileobj.write("abc   def\nc1ccccc1 benzene\n")
             fileobj.seek(0)
             reader = csv.reader(fileobj, dialect=space())
-            self.assertEqual(next(reader), ["abc", "def"])
+            self.assertEqual(next(reader), ["abc", "", "", "def"])
             self.assertEqual(next(reader), ["c1ccccc1", "benzene"])
 
     def compare_dialect_123(self, expected, *writeargs, **kwwriteargs):
@@ -524,8 +662,7 @@ def compare_dialect_123(self, expected, *writeargs, **kwwriteargs):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dialect_apply(self):
         class testA(csv.excel):
             delimiter = "\t"
@@ -556,21 +693,11 @@ class unspecified():
         finally:
             csv.unregister_dialect('testC')
 
-    def test_bad_dialect(self):
-        # Unknown parameter
-        self.assertRaises(TypeError, csv.reader, [], bad_attr = 0)
-        # Bad values
-        self.assertRaises(TypeError, csv.reader, [], delimiter = None)
-        self.assertRaises(TypeError, csv.reader, [], quoting = -1)
-        self.assertRaises(TypeError, csv.reader, [], quoting = 100)
-
     def test_copy(self):
         for name in csv.list_dialects():
             dialect = csv.get_dialect(name)
             self.assertRaises(TypeError, copy.copy, dialect)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickle(self):
         for name in csv.list_dialects():
             dialect = csv.get_dialect(name)
@@ -657,8 +784,7 @@ def test_quoted_quote(self):
                                  '"I see," said the blind man',
                                  'as he picked up his hammer and saw']])
 
-    # Rustpython TODO
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_quoted_nl(self):
         input = '''\
 1,2,3,"""I see,""
@@ -699,21 +825,18 @@ class EscapedExcel(csv.excel):
 class TestEscapedExcel(TestCsvBase):
     dialect = EscapedExcel()
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_escape_fieldsep(self):
         self.writerAssertEqual([['abc,def']], 'abc\\,def\r\n')
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_escape_fieldsep(self):
         self.readerAssertEqual('abc\\,def\r\n', [['abc,def']])
 
 class TestDialectUnix(TestCsvBase):
     dialect = 'unix'
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple_writer(self):
         self.writerAssertEqual([[1, 'abc def', 'abc']], '"1","abc def","abc"\n')
 
@@ -730,8 +853,7 @@ class TestQuotedEscapedExcel(TestCsvBase):
     def test_write_escape_fieldsep(self):
         self.writerAssertEqual([['abc,def']], '"abc,def"\r\n')
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_escape_fieldsep(self):
         self.readerAssertEqual('"abc\\,def"\r\n', [['abc,def']])
 
@@ -928,8 +1050,7 @@ def test_read_multi(self):
                                          "s1": 'abc',
                                          "s2": 'def'})
 
-    # TODO RUSTPYTHON 
-    @unittest.expectedFailure
+    @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"],
@@ -981,9 +1102,10 @@ def test_float_write(self):
             fileobj.seek(0)
             self.assertEqual(fileobj.read(), expected)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_char_write(self):
         import array, string
-        a = array.array('u', string.ascii_letters)
+        a = array.array('w', string.ascii_letters)
 
         with TemporaryFile("w+", encoding="utf-8", newline='') as fileobj:
             writer = csv.writer(fileobj, dialect="excel")
@@ -1007,6 +1129,12 @@ class mydialect(csv.Dialect):
         mydialect.quoting = None
         self.assertRaises(csv.Error, mydialect)
 
+        mydialect.quoting = 42
+        with self.assertRaises(csv.Error) as cm:
+            mydialect()
+        self.assertEqual(str(cm.exception),
+                         'bad "quoting" value')
+
         mydialect.doublequote = True
         mydialect.quoting = csv.QUOTE_ALL
         mydialect.quotechar = '"'
@@ -1122,11 +1250,17 @@ class mydialect(csv.Dialect):
         self.assertEqual(str(cm.exception),
                          '"lineterminator" must be a string')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_chars(self):
-        def create_invalid(field_name, value):
+        def create_invalid(field_name, value, **kwargs):
             class mydialect(csv.Dialect):
-                pass
+                delimiter = ','
+                quoting = csv.QUOTE_ALL
+                quotechar = '"'
+                lineterminator = '\r\n'
             setattr(mydialect, field_name, value)
+            for field_name, value in kwargs.items():
+                setattr(mydialect, field_name, value)
             d = mydialect()
 
         for field_name in ("delimiter", "escapechar", "quotechar"):
@@ -1135,6 +1269,11 @@ class mydialect(csv.Dialect):
                 self.assertRaises(csv.Error, create_invalid, field_name, "abc")
                 self.assertRaises(csv.Error, create_invalid, field_name, b'x')
                 self.assertRaises(csv.Error, create_invalid, field_name, 5)
+                self.assertRaises(ValueError, create_invalid, field_name, "\n")
+                self.assertRaises(ValueError, create_invalid, field_name, "\r")
+                if field_name != "delimiter":
+                    self.assertRaises(ValueError, create_invalid, field_name, " ",
+                                      skipinitialspace=True)
 
 
 class TestSniffer(unittest.TestCase):
@@ -1451,8 +1590,7 @@ def test_ordered_dict_reader(self):
 
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
-        extra = {'__doc__', '__version__'}
-        support.check__all__(self, csv, ('csv', '_csv'), extra=extra)
+        support.check__all__(self, csv, ('csv', '_csv'))
 
     def test_subclassable(self):
         # issue 44089
diff --git a/Lib/test/test_ctypes.py b/Lib/test/test_ctypes.py
deleted file mode 100644
index b0a12c9734..0000000000
--- a/Lib/test/test_ctypes.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import unittest
-from test.support.import_helper import import_module
-
-
-ctypes_test = import_module('ctypes.test')
-
-load_tests = ctypes_test.load_tests
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_ctypes/__init__.py b/Lib/test/test_ctypes/__init__.py
new file mode 100644
index 0000000000..eb9126cbe1
--- /dev/null
+++ b/Lib/test/test_ctypes/__init__.py
@@ -0,0 +1,10 @@
+import os
+from test import support
+from test.support import import_helper
+
+
+# skip tests if the _ctypes extension was not built
+import_helper.import_module('ctypes')
+
+def load_tests(*args):
+    return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_ctypes/__main__.py b/Lib/test/test_ctypes/__main__.py
new file mode 100644
index 0000000000..3003d4db89
--- /dev/null
+++ b/Lib/test/test_ctypes/__main__.py
@@ -0,0 +1,4 @@
+from test.test_ctypes import load_tests
+import unittest
+
+unittest.main()
diff --git a/Lib/test/test_ctypes/_support.py b/Lib/test/test_ctypes/_support.py
new file mode 100644
index 0000000000..e4c2b33825
--- /dev/null
+++ b/Lib/test/test_ctypes/_support.py
@@ -0,0 +1,24 @@
+# Some classes and types are not export to _ctypes module directly.
+
+import ctypes
+from _ctypes import Structure, Union, _Pointer, Array, _SimpleCData, CFuncPtr
+
+
+_CData = Structure.__base__
+assert _CData.__name__ == "_CData"
+
+class _X(Structure):
+    _fields_ = [("x", ctypes.c_int)]
+CField = type(_X.x)
+
+# metaclasses
+PyCStructType = type(Structure)
+UnionType = type(Union)
+PyCPointerType = type(_Pointer)
+PyCArrayType = type(Array)
+PyCSimpleType = type(_SimpleCData)
+PyCFuncPtrType = type(CFuncPtr)
+
+# type flags
+Py_TPFLAGS_DISALLOW_INSTANTIATION = 1 << 7
+Py_TPFLAGS_IMMUTABLETYPE = 1 << 8
diff --git a/Lib/test/test_ctypes/test_aligned_structures.py b/Lib/test/test_ctypes/test_aligned_structures.py
new file mode 100644
index 0000000000..8e8ac42990
--- /dev/null
+++ b/Lib/test/test_ctypes/test_aligned_structures.py
@@ -0,0 +1,321 @@
+from ctypes import (
+    c_char, c_uint32, c_uint16, c_ubyte, c_byte, alignment, sizeof,
+    BigEndianStructure, LittleEndianStructure,
+    BigEndianUnion, LittleEndianUnion, Structure
+)
+import struct
+import unittest
+
+
+class TestAlignedStructures(unittest.TestCase):
+    def test_aligned_string(self):
+        for base, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data =  bytearray(struct.pack(f"{e}i12x16s", 7, b"hello world!"))
+            class Aligned(base):
+                _align_ = 16
+                _fields_ = [
+                    ('value', c_char * 12)
+                ]
+
+            class Main(base):
+                _fields_ = [
+                    ('first', c_uint32),
+                    ('string', Aligned),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.first, 7)
+            self.assertEqual(main.string.value, b'hello world!')
+            self.assertEqual(bytes(main.string), b'hello world!\0\0\0\0')
+            self.assertEqual(Main.string.offset, 16)
+            self.assertEqual(Main.string.size, 16)
+            self.assertEqual(alignment(main.string), 16)
+            self.assertEqual(alignment(main), 16)
+
+    def test_aligned_structures(self):
+        for base, data in (
+            (LittleEndianStructure, bytearray(b"\1\0\0\0\1\0\0\0\7\0\0\0")),
+            (BigEndianStructure, bytearray(b"\1\0\0\0\1\0\0\0\7\0\0\0")),
+        ):
+            class SomeBools(base):
+                _align_ = 4
+                _fields_ = [
+                    ("bool1", c_ubyte),
+                    ("bool2", c_ubyte),
+                ]
+            class Main(base):
+                _fields_ = [
+                    ("x", c_ubyte),
+                    ("y", SomeBools),
+                    ("z", c_ubyte),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(SomeBools), 4)
+            self.assertEqual(alignment(main), 4)
+            self.assertEqual(alignment(main.y), 4)
+            self.assertEqual(Main.x.size, 1)
+            self.assertEqual(Main.y.offset, 4)
+            self.assertEqual(Main.y.size, 4)
+            self.assertEqual(main.y.bool1, True)
+            self.assertEqual(main.y.bool2, False)
+            self.assertEqual(Main.z.offset, 8)
+            self.assertEqual(main.z, 7)
+
+    def test_oversized_structure(self):
+        data = bytearray(b"\0" * 8)
+        for base in (LittleEndianStructure, BigEndianStructure):
+            class SomeBoolsTooBig(base):
+                _align_ = 8
+                _fields_ = [
+                    ("bool1", c_ubyte),
+                    ("bool2", c_ubyte),
+                    ("bool3", c_ubyte),
+                ]
+            class Main(base):
+                _fields_ = [
+                    ("y", SomeBoolsTooBig),
+                    ("z", c_uint32),
+                ]
+            with self.assertRaises(ValueError) as ctx:
+                Main.from_buffer(data)
+                self.assertEqual(
+                    ctx.exception.args[0],
+                    'Buffer size too small (4 instead of at least 8 bytes)'
+                )
+
+    def test_aligned_subclasses(self):
+        for base, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class UnalignedSub(base):
+                x: c_uint32
+                _fields_ = [
+                    ("x", c_uint32),
+                ]
+
+            class AlignedStruct(UnalignedSub):
+                _align_ = 8
+                _fields_ = [
+                    ("y", c_uint32),
+                ]
+
+            class Main(base):
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", AlignedStruct)
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(main.b), 8)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(sizeof(main.b), 8)
+            self.assertEqual(sizeof(main), 16)
+            self.assertEqual(main.a, 1)
+            self.assertEqual(main.b.x, 3)
+            self.assertEqual(main.b.y, 4)
+            self.assertEqual(Main.b.offset, 8)
+            self.assertEqual(Main.b.size, 8)
+
+    def test_aligned_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class AlignedUnion(ubase):
+                _align_ = 8
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", c_ubyte * 7),
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint32),
+                    ("union", AlignedUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.first, 1)
+            self.assertEqual(main.union.a, 3)
+            self.assertEqual(bytes(main.union.b), data[8:-1])
+            self.assertEqual(Main.union.offset, 8)
+            self.assertEqual(Main.union.size, 8)
+            self.assertEqual(alignment(main.union), 8)
+            self.assertEqual(alignment(main), 8)
+
+    def test_aligned_struct_in_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}4i", 1, 2, 3, 4))
+            class Sub(sbase):
+                _align_ = 8
+                _fields_ = [
+                    ("x", c_uint32),
+                    ("y", c_uint32),
+                ]
+
+            class MainUnion(ubase):
+                _fields_ = [
+                    ("a", c_uint32),
+                    ("b", Sub),
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint32),
+                    ("union", MainUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(Main.first.size, 4)
+            self.assertEqual(alignment(main.union), 8)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(Main.union.offset, 8)
+            self.assertEqual(Main.union.size, 8)
+            self.assertEqual(main.first, 1)
+            self.assertEqual(main.union.a, 3)
+            self.assertEqual(main.union.b.x, 3)
+            self.assertEqual(main.union.b.y, 4)
+
+    def test_smaller_aligned_subclassed_union(self):
+        for sbase, ubase, e in (
+            (LittleEndianStructure, LittleEndianUnion, "<"),
+            (BigEndianStructure, BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}H2xI", 1, 0xD60102D7))
+            class SubUnion(ubase):
+                _align_ = 2
+                _fields_ = [
+                    ("unsigned", c_ubyte),
+                    ("signed", c_byte),
+                ]
+
+            class MainUnion(SubUnion):
+                _fields_ = [
+                    ("num", c_uint32)
+                ]
+
+            class Main(sbase):
+                _fields_ = [
+                    ("first", c_uint16),
+                    ("union", MainUnion),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(main.union.num, 0xD60102D7)
+            self.assertEqual(main.union.unsigned, data[4])
+            self.assertEqual(main.union.signed, data[4] - 256)
+            self.assertEqual(alignment(main), 4)
+            self.assertEqual(alignment(main.union), 4)
+            self.assertEqual(Main.union.offset, 4)
+            self.assertEqual(Main.union.size, 4)
+            self.assertEqual(Main.first.size, 2)
+
+    def test_larger_aligned_subclassed_union(self):
+        for ubase, e in (
+            (LittleEndianUnion, "<"),
+            (BigEndianUnion, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}I4x", 0xD60102D6))
+            class SubUnion(ubase):
+                _align_ = 8
+                _fields_ = [
+                    ("unsigned", c_ubyte),
+                    ("signed", c_byte),
+                ]
+
+            class Main(SubUnion):
+                _fields_ = [
+                    ("num", c_uint32)
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(alignment(main), 8)
+            self.assertEqual(sizeof(main), 8)
+            self.assertEqual(main.num, 0xD60102D6)
+            self.assertEqual(main.unsigned, 0xD6)
+            self.assertEqual(main.signed, -42)
+
+    def test_aligned_packed_structures(self):
+        for sbase, e in (
+            (LittleEndianStructure, "<"),
+            (BigEndianStructure, ">"),
+        ):
+            data = bytearray(struct.pack(f"{e}B2H4xB", 1, 2, 3, 4))
+
+            class Inner(sbase):
+                _align_ = 8
+                _fields_ = [
+                    ("x", c_uint16),
+                    ("y", c_uint16),
+                ]
+
+            class Main(sbase):
+                _pack_ = 1
+                _fields_ = [
+                    ("a", c_ubyte),
+                    ("b", Inner),
+                    ("c", c_ubyte),
+                ]
+
+            main = Main.from_buffer(data)
+            self.assertEqual(sizeof(main), 10)
+            self.assertEqual(Main.b.offset, 1)
+            # Alignment == 8 because _pack_ wins out.
+            self.assertEqual(alignment(main.b), 8)
+            # Size is still 8 though since inside this Structure, it will have
+            # effect.
+            self.assertEqual(sizeof(main.b), 8)
+            self.assertEqual(Main.c.offset, 9)
+            self.assertEqual(main.a, 1)
+            self.assertEqual(main.b.x, 2)
+            self.assertEqual(main.b.y, 3)
+            self.assertEqual(main.c, 4)
+
+    def test_negative_align(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with (
+                self.subTest(base=base),
+                self.assertRaisesRegex(
+                    ValueError,
+                    '_align_ must be a non-negative integer',
+                )
+            ):
+                class MyStructure(base):
+                    _align_ = -1
+                    _fields_ = []
+
+    def test_zero_align_no_fields(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with self.subTest(base=base):
+                class MyStructure(base):
+                    _align_ = 0
+                    _fields_ = []
+
+                self.assertEqual(alignment(MyStructure), 1)
+                self.assertEqual(alignment(MyStructure()), 1)
+
+    def test_zero_align_with_fields(self):
+        for base in (Structure, LittleEndianStructure, BigEndianStructure):
+            with self.subTest(base=base):
+                class MyStructure(base):
+                    _align_ = 0
+                    _fields_ = [
+                        ("x", c_ubyte),
+                    ]
+
+                self.assertEqual(alignment(MyStructure), 1)
+                self.assertEqual(alignment(MyStructure()), 1)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/ctypes/test/test_anon.py b/Lib/test/test_ctypes/test_anon.py
similarity index 97%
rename from Lib/ctypes/test/test_anon.py
rename to Lib/test/test_ctypes/test_anon.py
index d378392ebe..b36397b510 100644
--- a/Lib/ctypes/test/test_anon.py
+++ b/Lib/test/test_ctypes/test_anon.py
@@ -1,6 +1,7 @@
 import unittest
 import test.support
-from ctypes import *
+from ctypes import c_int, Union, Structure, sizeof
+
 
 class AnonTest(unittest.TestCase):
 
@@ -69,5 +70,6 @@ class Y(Structure):
         self.assertEqual(Y._.offset, sizeof(c_int))
         self.assertEqual(Y.y.offset, sizeof(c_int) * 2)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_array_in_pointer.py b/Lib/test/test_ctypes/test_array_in_pointer.py
similarity index 93%
rename from Lib/ctypes/test/test_array_in_pointer.py
rename to Lib/test/test_ctypes/test_array_in_pointer.py
index ca1edcf621..b7c96b2fa4 100644
--- a/Lib/ctypes/test/test_array_in_pointer.py
+++ b/Lib/test/test_ctypes/test_array_in_pointer.py
@@ -1,21 +1,24 @@
-import unittest
-from ctypes import *
-from binascii import hexlify
+import binascii
 import re
+import unittest
+from ctypes import c_byte, Structure, POINTER, cast
+
 
 def dump(obj):
     # helper function to dump memory contents in hex, with a hyphen
     # between the bytes.
-    h = hexlify(memoryview(obj)).decode()
+    h = binascii.hexlify(memoryview(obj)).decode()
     return re.sub(r"(..)", r"\1-", h)[:-1]
 
 
 class Value(Structure):
     _fields_ = [("val", c_byte)]
 
+
 class Container(Structure):
     _fields_ = [("pvalues", POINTER(Value))]
 
+
 class Test(unittest.TestCase):
     def test(self):
         # create an array of 4 values
@@ -60,5 +63,6 @@ def test_2(self):
             ([1, 2, 3, 4], "01-02-03-04")
         )
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_arrays.py b/Lib/test/test_ctypes/test_arrays.py
similarity index 77%
rename from Lib/ctypes/test/test_arrays.py
rename to Lib/test/test_ctypes/test_arrays.py
index 14603b7049..c80fdff5de 100644
--- a/Lib/ctypes/test/test_arrays.py
+++ b/Lib/test/test_ctypes/test_arrays.py
@@ -1,16 +1,50 @@
+import ctypes
+import sys
 import unittest
+from ctypes import (Structure, Array, ARRAY, sizeof, addressof,
+                    create_string_buffer, create_unicode_buffer,
+                    c_char, c_wchar, c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulonglong, c_float, c_double, c_longdouble)
 from test.support import bigmemtest, _2G
-import sys
-from ctypes import *
+from ._support import (_CData, PyCArrayType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
 
-from ctypes.test import need_symbol
 
 formats = "bBhHiIlLqQfd"
 
 formats = c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint, \
           c_long, c_ulonglong, c_float, c_double, c_longdouble
 
+
 class ArrayTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(Array.mro(), [Array, _CData, object])
+
+        self.assertEqual(PyCArrayType.__name__, "PyCArrayType")
+        self.assertEqual(type(PyCArrayType), type)
+
+    def test_type_flags(self):
+        for cls in Array, PyCArrayType:
+            with self.subTest(cls=cls):
+                self.assertTrue(cls.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(cls.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewArray = PyCArrayType.__new__(PyCArrayType, 'NewArray', (Array,), {})
+        for cls in Array, NewArray:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(Array):
+            _type_ = c_int
+            _length_ = 13
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCArrayType.__init__(T, 'ptr', (), {})
+
     def test_simple(self):
         # create classes holding simple numeric types, and check
         # various properties.
@@ -34,9 +68,9 @@ def test_simple(self):
             with self.assertRaises(IndexError): ia[-alen-1]
 
             # change the items
-            from operator import setitem
             new_values = list(range(42, 42+alen))
-            [setitem(ia, n, new_values[n]) for n in range(alen)]
+            for n in range(alen):
+                ia[n] = new_values[n]
             values = [ia[i] for i in range(alen)]
             self.assertEqual(values, new_values)
 
@@ -66,8 +100,8 @@ def test_simple(self):
         self.assertEqual(len(ca), 3)
 
         # cannot delete items
-        from operator import delitem
-        self.assertRaises(TypeError, delitem, ca, 0)
+        with self.assertRaises(TypeError):
+            del ca[0]
 
     def test_step_overflow(self):
         a = (c_int * 5)()
@@ -117,7 +151,6 @@ def test_from_address(self):
         self.assertEqual(sz[1:4:2], b"o")
         self.assertEqual(sz.value, b"foo")
 
-    @need_symbol('create_unicode_buffer')
     def test_from_addressW(self):
         p = create_unicode_buffer("foo")
         sz = (c_wchar * 3).from_address(addressof(p))
@@ -178,10 +211,10 @@ def test_bad_subclass(self):
             class T(Array):
                 pass
         with self.assertRaises(AttributeError):
-            class T(Array):
+            class T2(Array):
                 _type_ = c_int
         with self.assertRaises(AttributeError):
-            class T(Array):
+            class T3(Array):
                 _length_ = 13
 
     def test_bad_length(self):
@@ -190,15 +223,15 @@ class T(Array):
                 _type_ = c_int
                 _length_ = - sys.maxsize * 2
         with self.assertRaises(ValueError):
-            class T(Array):
+            class T2(Array):
                 _type_ = c_int
                 _length_ = -1
         with self.assertRaises(TypeError):
-            class T(Array):
+            class T3(Array):
                 _type_ = c_int
                 _length_ = 1.87
         with self.assertRaises(OverflowError):
-            class T(Array):
+            class T4(Array):
                 _type_ = c_int
                 _length_ = sys.maxsize * 2
 
@@ -212,7 +245,7 @@ def test_empty_element_struct(self):
         class EmptyStruct(Structure):
             _fields_ = []
 
-        obj = (EmptyStruct * 2)()  # bpo37188: Floating point exception
+        obj = (EmptyStruct * 2)()  # bpo37188: Floating-point exception
         self.assertEqual(sizeof(obj), 0)
 
     def test_empty_element_array(self):
@@ -220,7 +253,7 @@ class EmptyArray(Array):
             _type_ = c_int
             _length_ = 0
 
-        obj = (EmptyArray * 2)()  # bpo37188: Floating point exception
+        obj = (EmptyArray * 2)()  # bpo37188: Floating-point exception
         self.assertEqual(sizeof(obj), 0)
 
     def test_bpo36504_signed_int_overflow(self):
@@ -234,5 +267,6 @@ def test_bpo36504_signed_int_overflow(self):
     def test_large_array(self, size):
         c_char * size
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_as_parameter.py b/Lib/test/test_ctypes/test_as_parameter.py
similarity index 84%
rename from Lib/ctypes/test/test_as_parameter.py
rename to Lib/test/test_ctypes/test_as_parameter.py
index 9c39179d2a..c5e1840b0e 100644
--- a/Lib/ctypes/test/test_as_parameter.py
+++ b/Lib/test/test_ctypes/test_as_parameter.py
@@ -1,24 +1,31 @@
+import ctypes
 import unittest
-from ctypes import *
-from ctypes.test import need_symbol
-import _ctypes_test
+from ctypes import (Structure, CDLL, CFUNCTYPE,
+                    POINTER, pointer, byref,
+                    c_short, c_int, c_long, c_longlong,
+                    c_byte, c_wchar, c_float, c_double,
+                    ArgumentError)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
 
 dll = CDLL(_ctypes_test.__file__)
 
 try:
-    CALLBACK_FUNCTYPE = WINFUNCTYPE
-except NameError:
+    CALLBACK_FUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
     # fake to enable this test on Linux
     CALLBACK_FUNCTYPE = CFUNCTYPE
 
+
 class POINT(Structure):
     _fields_ = [("x", c_int), ("y", c_int)]
 
+
 class BasicWrapTestCase(unittest.TestCase):
     def wrap(self, param):
         return param
 
-    @need_symbol('c_wchar')
     def test_wchar_parm(self):
         f = dll._testfunc_i_bhilfd
         f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
@@ -67,8 +74,6 @@ def callback(v):
         f(self.wrap(2**18), self.wrap(cb))
         self.assertEqual(args, expected)
 
-    ################################################################
-
     def test_callbacks(self):
         f = dll._testfunc_callback_i_if
         f.restype = c_int
@@ -77,7 +82,6 @@ def test_callbacks(self):
         MyCallback = CFUNCTYPE(c_int, c_int)
 
         def callback(value):
-            #print "called back with", value
             return value
 
         cb = MyCallback(callback)
@@ -114,7 +118,6 @@ def test_callbacks_2(self):
         f.argtypes = [c_int, MyCallback]
 
         def callback(value):
-            #print "called back with", value
             self.assertEqual(type(value), int)
             return value
 
@@ -122,9 +125,7 @@ def callback(value):
         result = f(self.wrap(-10), self.wrap(cb))
         self.assertEqual(result, -18)
 
-    @need_symbol('c_longlong')
     def test_longlong_callbacks(self):
-
         f = dll._testfunc_callback_q_qf
         f.restype = c_longlong
 
@@ -192,29 +193,32 @@ class S8I(Structure):
                              (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
 
     def test_recursive_as_param(self):
-        from ctypes import c_int
-
-        class A(object):
+        class A:
             pass
 
         a = A()
         a._as_parameter_ = a
-        with self.assertRaises(RecursionError):
-            c_int.from_param(a)
-
-
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class AsParamWrapper(object):
+        for c_type in (
+            ctypes.c_wchar_p,
+            ctypes.c_char_p,
+            ctypes.c_void_p,
+            ctypes.c_int,  # PyCSimpleType
+            POINT,  # CDataType
+        ):
+            with self.subTest(c_type=c_type):
+                with self.assertRaises(RecursionError):
+                    c_type.from_param(a)
+
+
+class AsParamWrapper:
     def __init__(self, param):
         self._as_parameter_ = param
 
 class AsParamWrapperTestCase(BasicWrapTestCase):
     wrap = AsParamWrapper
 
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-class AsParamPropertyWrapper(object):
+class AsParamPropertyWrapper:
     def __init__(self, param):
         self._param = param
 
@@ -225,7 +229,17 @@ def getParameter(self):
 class AsParamPropertyWrapperTestCase(BasicWrapTestCase):
     wrap = AsParamPropertyWrapper
 
-#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class AsParamNestedWrapperTestCase(BasicWrapTestCase):
+    """Test that _as_parameter_ is evaluated recursively.
+
+    The _as_parameter_ attribute can be another object which
+    defines its own _as_parameter_ attribute.
+    """
+
+    def wrap(self, param):
+        return AsParamWrapper(AsParamWrapper(AsParamWrapper(param)))
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_bitfields.py b/Lib/test/test_ctypes/test_bitfields.py
similarity index 95%
rename from Lib/ctypes/test/test_bitfields.py
rename to Lib/test/test_ctypes/test_bitfields.py
index 66acd62e68..0332544b58 100644
--- a/Lib/ctypes/test/test_bitfields.py
+++ b/Lib/test/test_ctypes/test_bitfields.py
@@ -1,10 +1,14 @@
-from ctypes import *
-from ctypes.test import need_symbol
-from test import support
-import unittest
 import os
+import unittest
+from ctypes import (CDLL, Structure, sizeof, POINTER, byref, alignment,
+                    LittleEndianStructure, BigEndianStructure,
+                    c_byte, c_ubyte, c_char, c_char_p, c_void_p, c_wchar,
+                    c_uint32, c_uint64,
+                    c_short, c_ushort, c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong)
+from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-import _ctypes_test
 
 class BITS(Structure):
     _fields_ = [("A", c_int, 1),
@@ -28,8 +32,6 @@ class BITS(Structure):
 func = CDLL(_ctypes_test.__file__).unpack_bitfields
 func.argtypes = POINTER(BITS), c_char
 
-##for n in "ABCDEFGHIMNOPQRS":
-##    print n, hex(getattr(BITS, n).size), getattr(BITS, n).offset
 
 class C_Test(unittest.TestCase):
 
@@ -53,6 +55,7 @@ def test_shorts(self):
                 setattr(b, name, i)
                 self.assertEqual(getattr(b, name), func(byref(b), name.encode('ascii')))
 
+
 signed_int_types = (c_byte, c_short, c_int, c_long, c_longlong)
 unsigned_int_types = (c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong)
 int_types = unsigned_int_types + signed_int_types
@@ -114,7 +117,6 @@ class X(Structure):
             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})
@@ -140,7 +142,6 @@ class Dummy(Structure):
         result = self.fail_fields(("a", Dummy, 1))
         self.assertEqual(result, (TypeError, 'bit fields not allowed for type Dummy'))
 
-    @need_symbol('c_wchar')
     def test_c_wchar(self):
         result = self.fail_fields(("a", c_wchar, 1))
         self.assertEqual(result,
@@ -192,7 +193,6 @@ class X(Structure):
         self.assertEqual(X.b.offset, sizeof(c_short)*1)
         self.assertEqual(X.c.offset, sizeof(c_short)*2)
 
-
     def get_except(self, func, *args, **kw):
         try:
             func(*args, **kw)
@@ -245,7 +245,6 @@ class Y(Structure):
             _anonymous_ = ["_"]
             _fields_ = [("_", X)]
 
-    @need_symbol('c_uint32')
     def test_uint32(self):
         class X(Structure):
             _fields_ = [("a", c_uint32, 32)]
@@ -255,7 +254,6 @@ class X(Structure):
         x.a = 0xFDCBA987
         self.assertEqual(x.a, 0xFDCBA987)
 
-    @need_symbol('c_uint64')
     def test_uint64(self):
         class X(Structure):
             _fields_ = [("a", c_uint64, 64)]
@@ -265,7 +263,6 @@ class X(Structure):
         x.a = 0xFEDCBA9876543211
         self.assertEqual(x.a, 0xFEDCBA9876543211)
 
-    @need_symbol('c_uint32')
     def test_uint32_swap_little_endian(self):
         # Issue #23319
         class Little(LittleEndianStructure):
@@ -279,7 +276,6 @@ class Little(LittleEndianStructure):
         x.c = 2
         self.assertEqual(b, b'\xef\xcd\xab\x21')
 
-    @need_symbol('c_uint32')
     def test_uint32_swap_big_endian(self):
         # Issue #23319
         class Big(BigEndianStructure):
@@ -293,5 +289,6 @@ class Big(BigEndianStructure):
         x.c = 2
         self.assertEqual(b, b'\xab\xcd\xef\x12')
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_buffers.py b/Lib/test/test_ctypes/test_buffers.py
similarity index 94%
rename from Lib/ctypes/test/test_buffers.py
rename to Lib/test/test_ctypes/test_buffers.py
index 15782be757..468f41eb7c 100644
--- a/Lib/ctypes/test/test_buffers.py
+++ b/Lib/test/test_ctypes/test_buffers.py
@@ -1,9 +1,9 @@
-from ctypes import *
-from ctypes.test import need_symbol
 import unittest
+from ctypes import (create_string_buffer, create_unicode_buffer, sizeof,
+                    c_char, c_wchar)
 
-class StringBufferTestCase(unittest.TestCase):
 
+class StringBufferTestCase(unittest.TestCase):
     def test_buffer(self):
         b = create_string_buffer(32)
         self.assertEqual(len(b), 32)
@@ -27,7 +27,6 @@ def test_buffer_interface(self):
         self.assertEqual(len(bytearray(create_string_buffer(0))), 0)
         self.assertEqual(len(bytearray(create_string_buffer(1))), 1)
 
-    @need_symbol('c_wchar')
     def test_unicode_buffer(self):
         b = create_unicode_buffer(32)
         self.assertEqual(len(b), 32)
@@ -47,7 +46,6 @@ def test_unicode_buffer(self):
 
         self.assertRaises(TypeError, create_unicode_buffer, b"abc")
 
-    @need_symbol('c_wchar')
     def test_unicode_conversion(self):
         b = create_unicode_buffer("abc")
         self.assertEqual(len(b), 4) # trailing nul char
@@ -60,7 +58,6 @@ def test_unicode_conversion(self):
         self.assertEqual(b[::2], "ac")
         self.assertEqual(b[::5], "a")
 
-    @need_symbol('c_wchar')
     def test_create_unicode_buffer_non_bmp(self):
         expected = 5 if sizeof(c_wchar) == 2 else 3
         for s in '\U00010000\U00100000', '\U00010000\U0010ffff':
diff --git a/Lib/ctypes/test/test_bytes.py b/Lib/test/test_ctypes/test_bytes.py
similarity index 95%
rename from Lib/ctypes/test/test_bytes.py
rename to Lib/test/test_ctypes/test_bytes.py
index 092ec5af05..fa11e1bbd4 100644
--- a/Lib/ctypes/test/test_bytes.py
+++ b/Lib/test/test_ctypes/test_bytes.py
@@ -1,7 +1,9 @@
 """Test where byte objects are accepted"""
-import unittest
 import sys
-from ctypes import *
+import unittest
+from _ctypes import _SimpleCData
+from ctypes import Structure, c_char, c_char_p, c_wchar, c_wchar_p
+
 
 class BytesTest(unittest.TestCase):
     def test_c_char(self):
@@ -55,7 +57,6 @@ class X(Structure):
 
     @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
     def test_BSTR(self):
-        from _ctypes import _SimpleCData
         class BSTR(_SimpleCData):
             _type_ = "X"
 
diff --git a/Lib/ctypes/test/test_byteswap.py b/Lib/test/test_ctypes/test_byteswap.py
similarity index 92%
rename from Lib/ctypes/test/test_byteswap.py
rename to Lib/test/test_ctypes/test_byteswap.py
index 7e98559dfb..78eff0392c 100644
--- a/Lib/ctypes/test/test_byteswap.py
+++ b/Lib/test/test_ctypes/test_byteswap.py
@@ -1,10 +1,21 @@
-import sys, unittest, struct, math, ctypes
-from binascii import hexlify
+import binascii
+import ctypes
+import math
+import struct
+import sys
+import unittest
+from ctypes import (Structure, Union, LittleEndianUnion, BigEndianUnion,
+                    BigEndianStructure, LittleEndianStructure,
+                    POINTER, sizeof, cast,
+                    c_byte, c_ubyte, c_char, c_wchar, c_void_p,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_uint32, c_float, c_double)
 
-from ctypes import *
 
 def bin(s):
-    return hexlify(memoryview(s)).decode().upper()
+    return binascii.hexlify(memoryview(s)).decode().upper()
+
 
 # Each *simple* type that supports different byte orders has an
 # __ctype_be__ attribute that specifies the same type in BIG ENDIAN
@@ -14,14 +25,6 @@ def bin(s):
 # For Structures and Unions, these types are created on demand.
 
 class Test(unittest.TestCase):
-    @unittest.skip('test disabled')
-    def test_X(self):
-        print(sys.byteorder, file=sys.stderr)
-        for i in range(32):
-            bits = BITS()
-            setattr(bits, "i%s" % i, 1)
-            dump(bits)
-
     def test_slots(self):
         class BigPoint(BigEndianStructure):
             __slots__ = ()
@@ -360,5 +363,24 @@ class TestUnion(parent):
                 self.assertEqual(s.point.x, 1)
                 self.assertEqual(s.point.y, 2)
 
+    def test_build_struct_union_opposite_system_byteorder(self):
+        # gh-105102
+        if sys.byteorder == "little":
+            _Structure = BigEndianStructure
+            _Union = BigEndianUnion
+        else:
+            _Structure = LittleEndianStructure
+            _Union = LittleEndianUnion
+
+        class S1(_Structure):
+            _fields_ = [("a", c_byte), ("b", c_byte)]
+
+        class U1(_Union):
+            _fields_ = [("s1", S1), ("ab", c_short)]
+
+        class S2(_Structure):
+            _fields_ = [("u1", U1), ("c", c_byte)]
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_c_simple_type_meta.py b/Lib/test/test_ctypes/test_c_simple_type_meta.py
new file mode 100644
index 0000000000..eb77d6d778
--- /dev/null
+++ b/Lib/test/test_ctypes/test_c_simple_type_meta.py
@@ -0,0 +1,152 @@
+import unittest
+import ctypes
+from ctypes import POINTER, c_void_p
+
+from ._support import PyCSimpleType
+
+
+class PyCSimpleTypeAsMetaclassTest(unittest.TestCase):
+    def tearDown(self):
+        # to not leak references, we must clean _pointer_type_cache
+        ctypes._reset_cache()
+
+    def test_creating_pointer_in_dunder_new_1(self):
+        # Test metaclass whose instances are C types; when the type is
+        # created it automatically creates a pointer type for itself.
+        # The pointer type is also an instance of the metaclass.
+        # Such an implementation is used in `IUnknown` of the `comtypes`
+        # project. See gh-124520.
+
+        class ct_meta(type):
+            def __new__(cls, name, bases, namespace):
+                self = super().__new__(cls, name, bases, namespace)
+
+                # Avoid recursion: don't set up a pointer to
+                # a pointer (to a pointer...)
+                if bases == (c_void_p,):
+                    # When creating PtrBase itself, the name
+                    # is not yet available
+                    return self
+                if issubclass(self, PtrBase):
+                    return self
+
+                if bases == (object,):
+                    ptr_bases = (self, PtrBase)
+                else:
+                    ptr_bases = (self, POINTER(bases[0]))
+                p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
+                ctypes._pointer_type_cache[self] = p
+                return self
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class PtrBase(c_void_p, metaclass=p_meta):
+            pass
+
+        class CtBase(object, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        class Sub2(Sub):
+            pass
+
+        self.assertIsInstance(POINTER(Sub2), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
+
+    def test_creating_pointer_in_dunder_new_2(self):
+        # A simpler variant of the above, used in `CoClass` of the `comtypes`
+        # project.
+
+        class ct_meta(type):
+            def __new__(cls, name, bases, namespace):
+                self = super().__new__(cls, name, bases, namespace)
+                if isinstance(self, p_meta):
+                    return self
+                p = p_meta(f"POINTER({self.__name__})", (self, c_void_p), {})
+                ctypes._pointer_type_cache[self] = p
+                return self
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class Core(object):
+            pass
+
+        class CtBase(Core, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        self.assertIsInstance(POINTER(Sub), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
+
+    def test_creating_pointer_in_dunder_init_1(self):
+        class ct_meta(type):
+            def __init__(self, name, bases, namespace):
+                super().__init__(name, bases, namespace)
+
+                # Avoid recursion.
+                # (See test_creating_pointer_in_dunder_new_1)
+                if bases == (c_void_p,):
+                    return
+                if issubclass(self, PtrBase):
+                    return
+                if bases == (object,):
+                    ptr_bases = (self, PtrBase)
+                else:
+                    ptr_bases = (self, POINTER(bases[0]))
+                p = p_meta(f"POINTER({self.__name__})", ptr_bases, {})
+                ctypes._pointer_type_cache[self] = p
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class PtrBase(c_void_p, metaclass=p_meta):
+            pass
+
+        class CtBase(object, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        class Sub2(Sub):
+            pass
+
+        self.assertIsInstance(POINTER(Sub2), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub2), Sub2))
+        self.assertTrue(issubclass(POINTER(Sub2), POINTER(Sub)))
+        self.assertTrue(issubclass(POINTER(Sub), POINTER(CtBase)))
+
+    def test_creating_pointer_in_dunder_init_2(self):
+        class ct_meta(type):
+            def __init__(self, name, bases, namespace):
+                super().__init__(name, bases, namespace)
+
+                # Avoid recursion.
+                # (See test_creating_pointer_in_dunder_new_2)
+                if isinstance(self, p_meta):
+                    return
+                p = p_meta(f"POINTER({self.__name__})", (self, c_void_p), {})
+                ctypes._pointer_type_cache[self] = p
+
+        class p_meta(PyCSimpleType, ct_meta):
+            pass
+
+        class Core(object):
+            pass
+
+        class CtBase(Core, metaclass=ct_meta):
+            pass
+
+        class Sub(CtBase):
+            pass
+
+        self.assertIsInstance(POINTER(Sub), p_meta)
+        self.assertTrue(issubclass(POINTER(Sub), Sub))
diff --git a/Lib/ctypes/test/test_callbacks.py b/Lib/test/test_ctypes/test_callbacks.py
similarity index 82%
rename from Lib/ctypes/test/test_callbacks.py
rename to Lib/test/test_ctypes/test_callbacks.py
index 8f95a24443..8f483dfe1d 100644
--- a/Lib/ctypes/test/test_callbacks.py
+++ b/Lib/test/test_ctypes/test_callbacks.py
@@ -1,19 +1,25 @@
+import ctypes
 import functools
+import gc
+import math
+import sys
 import unittest
+from _ctypes import CTYPES_MAX_ARGCOUNT
+from ctypes import (CDLL, cdll, Structure, CFUNCTYPE,
+                    ArgumentError, POINTER, sizeof,
+                    c_byte, c_ubyte, c_char,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_longlong, c_ulonglong, c_ulong,
+                    c_float, c_double, c_longdouble, py_object)
+from ctypes.util import find_library
 from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-from ctypes import *
-from ctypes.test import need_symbol
-from _ctypes import CTYPES_MAX_ARGCOUNT
-import _ctypes_test
 
 class Callbacks(unittest.TestCase):
     functype = CFUNCTYPE
 
-##    def tearDown(self):
-##        import gc
-##        gc.collect()
-
     def callback(self, *args):
         self.got_args = args
         return args[-1]
@@ -35,8 +41,6 @@ def check_type(self, typ, arg):
             self.assertEqual(self.got_args, (-3, arg))
             self.assertEqual(result, arg)
 
-    ################
-
     def test_byte(self):
         self.check_type(c_byte, 42)
         self.check_type(c_byte, -42)
@@ -65,18 +69,15 @@ def test_long(self):
     def test_ulong(self):
         self.check_type(c_ulong, 42)
 
-    @need_symbol('c_longlong')
     def test_longlong(self):
         self.check_type(c_longlong, 42)
         self.check_type(c_longlong, -42)
 
-    @need_symbol('c_ulonglong')
     def test_ulonglong(self):
         self.check_type(c_ulonglong, 42)
 
     def test_float(self):
         # only almost equal: double -> float -> double
-        import math
         self.check_type(c_float, math.e)
         self.check_type(c_float, -math.e)
 
@@ -84,7 +85,6 @@ def test_double(self):
         self.check_type(c_double, 3.14)
         self.check_type(c_double, -3.14)
 
-    @need_symbol('c_longdouble')
     def test_longdouble(self):
         self.check_type(c_longdouble, 3.14)
         self.check_type(c_longdouble, -3.14)
@@ -93,30 +93,21 @@ def test_char(self):
         self.check_type(c_char, b"x")
         self.check_type(c_char, b"a")
 
-    # disabled: would now (correctly) raise a RuntimeWarning about
-    # a memory leak.  A callback function cannot return a non-integral
-    # C type without causing a memory leak.
-    @unittest.skip('test disabled')
-    def test_char_p(self):
-        self.check_type(c_char_p, "abc")
-        self.check_type(c_char_p, "def")
-
     def test_pyobject(self):
         o = ()
-        from sys import getrefcount as grc
         for o in (), [], object():
-            initial = grc(o)
+            initial = sys.getrefcount(o)
             # This call leaks a reference to 'o'...
             self.check_type(py_object, o)
-            before = grc(o)
+            before = sys.getrefcount(o)
             # ...but this call doesn't leak any more.  Where is the refcount?
             self.check_type(py_object, o)
-            after = grc(o)
+            after = sys.getrefcount(o)
             self.assertEqual((after, o), (before, o))
 
     def test_unsupported_restype_1(self):
         # Only "fundamental" result types are supported for callback
-        # functions, the type must have a non-NULL stgdict->setfunc.
+        # functions, the type must have a non-NULL stginfo->setfunc.
         # POINTER(c_double), for example, is not supported.
 
         prototype = self.functype.__func__(POINTER(c_double))
@@ -130,12 +121,11 @@ def test_unsupported_restype_2(self):
     def test_issue_7959(self):
         proto = self.functype.__func__(None)
 
-        class X(object):
+        class X:
             def func(self): pass
             def __init__(self):
                 self.v = proto(self.func)
 
-        import gc
         for i in range(32):
             X()
         gc.collect()
@@ -144,21 +134,30 @@ def __init__(self):
         self.assertEqual(len(live), 0)
 
     def test_issue12483(self):
-        import gc
         class Nasty:
             def __del__(self):
                 gc.collect()
         CFUNCTYPE(None)(lambda x=Nasty(): None)
 
+    @unittest.skipUnless(hasattr(ctypes, 'WINFUNCTYPE'),
+                         'ctypes.WINFUNCTYPE is required')
+    def test_i38748_stackCorruption(self):
+        callback_funcType = ctypes.WINFUNCTYPE(c_long, c_long, c_longlong)
+        @callback_funcType
+        def callback(a, b):
+            c = a + b
+            print(f"a={a}, b={b}, c={c}")
+            return c
+        dll = cdll[_ctypes_test.__file__]
+        with support.captured_stdout() as out:
+            # With no fix for i38748, the next line will raise OSError and cause the test to fail.
+            self.assertEqual(dll._test_i38748_runCallback(callback, 5, 10), 15)
+            self.assertEqual(out.getvalue(), "a=5, b=10, c=15\n")
+
+if hasattr(ctypes, 'WINFUNCTYPE'):
+    class StdcallCallbacks(Callbacks):
+        functype = ctypes.WINFUNCTYPE
 
-@need_symbol('WINFUNCTYPE')
-class StdcallCallbacks(Callbacks):
-    try:
-        functype = WINFUNCTYPE
-    except NameError:
-        pass
-
-################################################################
 
 class SampleCallbacksTestCase(unittest.TestCase):
 
@@ -183,7 +182,6 @@ def func(x):
         self.assertLess(diff, 0.01, "%s not less than 0.01" % diff)
 
     def test_issue_8959_a(self):
-        from ctypes.util import find_library
         libc_path = find_library("c")
         if not libc_path:
             self.skipTest('could not find libc')
@@ -198,19 +196,21 @@ def cmp_func(a, b):
         libc.qsort(array, len(array), sizeof(c_int), cmp_func)
         self.assertEqual(array[:], [1, 5, 7, 33, 99])
 
-    @need_symbol('WINFUNCTYPE')
+    @unittest.skipUnless(hasattr(ctypes, 'WINFUNCTYPE'),
+                         'ctypes.WINFUNCTYPE is required')
     def test_issue_8959_b(self):
         from ctypes.wintypes import BOOL, HWND, LPARAM
         global windowCount
         windowCount = 0
 
-        @WINFUNCTYPE(BOOL, HWND, LPARAM)
+        @ctypes.WINFUNCTYPE(BOOL, HWND, LPARAM)
         def EnumWindowsCallbackFunc(hwnd, lParam):
             global windowCount
             windowCount += 1
             return True #Allow windows to keep enumerating
 
-        windll.user32.EnumWindows(EnumWindowsCallbackFunc, 0)
+        user32 = ctypes.windll.user32
+        user32.EnumWindows(EnumWindowsCallbackFunc, 0)
 
     def test_callback_register_int(self):
         # Issue #8275: buggy handling of callback args under Win64
@@ -324,9 +324,9 @@ def func():
 
             self.assertIsInstance(cm.unraisable.exc_value, TypeError)
             self.assertEqual(cm.unraisable.err_msg,
-                             "Exception ignored on converting result "
-                             "of ctypes callback function")
-            self.assertIs(cm.unraisable.object, func)
+                             f"Exception ignored on converting result "
+                             f"of ctypes callback function {func!r}")
+            self.assertIsNone(cm.unraisable.object)
 
 
 if __name__ == '__main__':
diff --git a/Lib/ctypes/test/test_cast.py b/Lib/test/test_ctypes/test_cast.py
similarity index 92%
rename from Lib/ctypes/test/test_cast.py
rename to Lib/test/test_ctypes/test_cast.py
index 6878f97328..db6bdc75ef 100644
--- a/Lib/ctypes/test/test_cast.py
+++ b/Lib/test/test_ctypes/test_cast.py
@@ -1,10 +1,11 @@
-from ctypes import *
-from ctypes.test import need_symbol
-import unittest
 import sys
+import unittest
+from ctypes import (Structure, Union, POINTER, cast, sizeof, addressof,
+                    c_void_p, c_char_p, c_wchar_p,
+                    c_byte, c_short, c_int)
 
-class Test(unittest.TestCase):
 
+class Test(unittest.TestCase):
     def test_array2pointer(self):
         array = (c_int * 3)(42, 17, 2)
 
@@ -12,7 +13,7 @@ def test_array2pointer(self):
         ptr = cast(array, POINTER(c_int))
         self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
 
-        if 2*sizeof(c_short) == sizeof(c_int):
+        if 2 * sizeof(c_short) == sizeof(c_int):
             ptr = cast(array, POINTER(c_short))
             if sys.byteorder == "little":
                 self.assertEqual([ptr[i] for i in range(6)],
@@ -31,6 +32,8 @@ def test_address2pointer(self):
         ptr = cast(address, POINTER(c_int))
         self.assertEqual([ptr[i] for i in range(3)], [42, 17, 2])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_p2a_objects(self):
         array = (c_char_p * 5)()
         self.assertEqual(array._objects, None)
@@ -76,11 +79,10 @@ def test_char_p(self):
         self.assertEqual(cast(cast(s, c_void_p), c_char_p).value,
                              b"hiho")
 
-    @need_symbol('c_wchar_p')
     def test_wchar_p(self):
         s = c_wchar_p("hiho")
         self.assertEqual(cast(cast(s, c_void_p), c_wchar_p).value,
-                             "hiho")
+                         "hiho")
 
     def test_bad_type_arg(self):
         # The type argument must be a ctypes pointer type.
@@ -95,5 +97,6 @@ class MyUnion(Union):
             _fields_ = [("a", c_int)]
         self.assertRaises(TypeError, cast, array, MyUnion)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_cfuncs.py b/Lib/test/test_ctypes/test_cfuncs.py
similarity index 93%
rename from Lib/ctypes/test/test_cfuncs.py
rename to Lib/test/test_ctypes/test_cfuncs.py
index 09b06840bf..48330c4b0a 100644
--- a/Lib/ctypes/test/test_cfuncs.py
+++ b/Lib/test/test_ctypes/test_cfuncs.py
@@ -1,11 +1,13 @@
-# A lot of failures in these tests on Mac OS X.
-# Byte order related?
-
+import ctypes
 import unittest
-from ctypes import *
-from ctypes.test import need_symbol
+from ctypes import (CDLL,
+                    c_byte, c_ubyte, c_char,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-import _ctypes_test
 
 class CFunctions(unittest.TestCase):
     _dll = CDLL(_ctypes_test.__file__)
@@ -111,28 +113,24 @@ def test_ulong_plus(self):
         self.assertEqual(self._dll.tf_bL(b' ', 4294967295), 1431655765)
         self.assertEqual(self.U(), 4294967295)
 
-    @need_symbol('c_longlong')
     def test_longlong(self):
         self._dll.tf_q.restype = c_longlong
         self._dll.tf_q.argtypes = (c_longlong, )
         self.assertEqual(self._dll.tf_q(-9223372036854775806), -3074457345618258602)
         self.assertEqual(self.S(), -9223372036854775806)
 
-    @need_symbol('c_longlong')
     def test_longlong_plus(self):
         self._dll.tf_bq.restype = c_longlong
         self._dll.tf_bq.argtypes = (c_byte, c_longlong)
         self.assertEqual(self._dll.tf_bq(0, -9223372036854775806), -3074457345618258602)
         self.assertEqual(self.S(), -9223372036854775806)
 
-    @need_symbol('c_ulonglong')
     def test_ulonglong(self):
         self._dll.tf_Q.restype = c_ulonglong
         self._dll.tf_Q.argtypes = (c_ulonglong, )
         self.assertEqual(self._dll.tf_Q(18446744073709551615), 6148914691236517205)
         self.assertEqual(self.U(), 18446744073709551615)
 
-    @need_symbol('c_ulonglong')
     def test_ulonglong_plus(self):
         self._dll.tf_bQ.restype = c_ulonglong
         self._dll.tf_bQ.argtypes = (c_byte, c_ulonglong)
@@ -163,14 +161,12 @@ def test_double_plus(self):
         self.assertEqual(self._dll.tf_bd(0, 42.), 14.)
         self.assertEqual(self.S(), 42)
 
-    @need_symbol('c_longdouble')
     def test_longdouble(self):
         self._dll.tf_D.restype = c_longdouble
         self._dll.tf_D.argtypes = (c_longdouble,)
         self.assertEqual(self._dll.tf_D(42.), 14.)
         self.assertEqual(self.S(), 42)
 
-    @need_symbol('c_longdouble')
     def test_longdouble_plus(self):
         self._dll.tf_bD.restype = c_longdouble
         self._dll.tf_bD.argtypes = (c_byte, c_longdouble)
@@ -195,14 +191,11 @@ def test_void(self):
         self.assertEqual(self._dll.tv_i(-42), None)
         self.assertEqual(self.S(), -42)
 
+
 # The following repeats the above tests with stdcall functions (where
 # they are available)
-try:
-    WinDLL
-except NameError:
-    def stdcall_dll(*_): pass
-else:
-    class stdcall_dll(WinDLL):
+if hasattr(ctypes, 'WinDLL'):
+    class stdcall_dll(ctypes.WinDLL):
         def __getattr__(self, name):
             if name[:2] == '__' and name[-2:] == '__':
                 raise AttributeError(name)
@@ -210,9 +203,9 @@ def __getattr__(self, name):
             setattr(self, name, func)
             return func
 
-@need_symbol('WinDLL')
-class stdcallCFunctions(CFunctions):
-    _dll = stdcall_dll(_ctypes_test.__file__)
+    class stdcallCFunctions(CFunctions):
+        _dll = stdcall_dll(_ctypes_test.__file__)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_checkretval.py b/Lib/test/test_ctypes/test_checkretval.py
new file mode 100644
index 0000000000..9d6bfdb845
--- /dev/null
+++ b/Lib/test/test_ctypes/test_checkretval.py
@@ -0,0 +1,37 @@
+import ctypes
+import unittest
+from ctypes import CDLL, c_int
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class CHECKED(c_int):
+    def _check_retval_(value):
+        # Receives a CHECKED instance.
+        return str(value.value)
+    _check_retval_ = staticmethod(_check_retval_)
+
+
+class Test(unittest.TestCase):
+    def test_checkretval(self):
+        dll = CDLL(_ctypes_test.__file__)
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = CHECKED
+        self.assertEqual("42", dll._testfunc_p_p(42))
+
+        dll._testfunc_p_p.restype = None
+        self.assertEqual(None, dll._testfunc_p_p(42))
+
+        del dll._testfunc_p_p.restype
+        self.assertEqual(42, dll._testfunc_p_p(42))
+
+    @unittest.skipUnless(hasattr(ctypes, 'oledll'),
+                         'ctypes.oledll is required')
+    def test_oledll(self):
+        oleaut32 = ctypes.oledll.oleaut32
+        self.assertRaises(OSError, oleaut32.CreateTypeLib2, 0, None, None)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_delattr.py b/Lib/test/test_ctypes/test_delattr.py
new file mode 100644
index 0000000000..e80b5fa6ef
--- /dev/null
+++ b/Lib/test/test_ctypes/test_delattr.py
@@ -0,0 +1,26 @@
+import unittest
+from ctypes import Structure, c_char, c_int
+
+
+class X(Structure):
+    _fields_ = [("foo", c_int)]
+
+
+class TestCase(unittest.TestCase):
+    def test_simple(self):
+        with self.assertRaises(TypeError):
+            del c_int(42).value
+
+    def test_chararray(self):
+        chararray = (c_char * 5)()
+        with self.assertRaises(TypeError):
+            del chararray.value
+
+    def test_struct(self):
+        struct = X()
+        with self.assertRaises(TypeError):
+            del struct.foo
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_dlerror.py b/Lib/test/test_ctypes/test_dlerror.py
new file mode 100644
index 0000000000..cd87bad382
--- /dev/null
+++ b/Lib/test/test_ctypes/test_dlerror.py
@@ -0,0 +1,180 @@
+import _ctypes
+import os
+import platform
+import sys
+import test.support
+import unittest
+from ctypes import CDLL, c_int
+from ctypes.util import find_library
+
+
+FOO_C = r"""
+#include <unistd.h>
+
+/* This is a 'GNU indirect function' (IFUNC) that will be called by
+   dlsym() to resolve the symbol "foo" to an address. Typically, such
+   a function would return the address of an actual function, but it
+   can also just return NULL.  For some background on IFUNCs, see
+   https://willnewton.name/uncategorized/using-gnu-indirect-functions.
+
+   Adapted from Michael Kerrisk's answer: https://stackoverflow.com/a/53590014.
+*/
+
+asm (".type foo STT_GNU_IFUNC");
+
+void *foo(void)
+{
+    write($DESCRIPTOR, "OK", 2);
+    return NULL;
+}
+"""
+
+
+@unittest.skipUnless(sys.platform.startswith('linux'),
+                     'test requires GNU IFUNC support')
+class TestNullDlsym(unittest.TestCase):
+    """GH-126554: Ensure that we catch NULL dlsym return values
+
+    In rare cases, such as when using GNU IFUNCs, dlsym(),
+    the C function that ctypes' CDLL uses to get the address
+    of symbols, can return NULL.
+
+    The objective way of telling if an error during symbol
+    lookup happened is to call glibc's dlerror() and check
+    for a non-NULL return value.
+
+    However, there can be cases where dlsym() returns NULL
+    and dlerror() is also NULL, meaning that glibc did not
+    encounter any error.
+
+    In the case of ctypes, we subjectively treat that as
+    an error, and throw a relevant exception.
+
+    This test case ensures that we correctly enforce
+    this 'dlsym returned NULL -> throw Error' rule.
+    """
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_null_dlsym(self):
+        import subprocess
+        import tempfile
+
+        try:
+            retcode = subprocess.call(["gcc", "--version"],
+                                      stdout=subprocess.DEVNULL,
+                                      stderr=subprocess.DEVNULL)
+        except OSError:
+            self.skipTest("gcc is missing")
+        if retcode != 0:
+            self.skipTest("gcc --version failed")
+
+        pipe_r, pipe_w = os.pipe()
+        self.addCleanup(os.close, pipe_r)
+        self.addCleanup(os.close, pipe_w)
+
+        with tempfile.TemporaryDirectory() as d:
+            # Create a C file with a GNU Indirect Function (FOO_C)
+            # and compile it into a shared library.
+            srcname = os.path.join(d, 'foo.c')
+            dstname = os.path.join(d, 'libfoo.so')
+            with open(srcname, 'w') as f:
+                f.write(FOO_C.replace('$DESCRIPTOR', str(pipe_w)))
+            args = ['gcc', '-fPIC', '-shared', '-o', dstname, srcname]
+            p = subprocess.run(args, capture_output=True)
+
+            if p.returncode != 0:
+                # IFUNC is not supported on all architectures.
+                if platform.machine() == 'x86_64':
+                    # It should be supported here. Something else went wrong.
+                    p.check_returncode()
+                else:
+                    # IFUNC might not be supported on this machine.
+                    self.skipTest(f"could not compile indirect function: {p}")
+
+            # Case #1: Test 'PyCFuncPtr_FromDll' from Modules/_ctypes/_ctypes.c
+            L = CDLL(dstname)
+            with self.assertRaisesRegex(AttributeError, "function 'foo' not found"):
+                # Try accessing the 'foo' symbol.
+                # It should resolve via dlsym() to NULL,
+                # and since we subjectively treat NULL
+                # addresses as errors, we should get
+                # an error.
+                L.foo
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+            # Case #2: Test 'CDataType_in_dll_impl' from Modules/_ctypes/_ctypes.c
+            with self.assertRaisesRegex(ValueError, "symbol 'foo' not found"):
+                c_int.in_dll(L, "foo")
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+            # Case #3: Test 'py_dl_sym' from Modules/_ctypes/callproc.c
+            dlopen = test.support.get_attribute(_ctypes, 'dlopen')
+            dlsym = test.support.get_attribute(_ctypes, 'dlsym')
+            L = dlopen(dstname)
+            with self.assertRaisesRegex(OSError, "symbol 'foo' not found"):
+                dlsym(L, "foo")
+
+            # Assert that the IFUNC was called
+            self.assertEqual(os.read(pipe_r, 2), b'OK')
+
+
+@unittest.skipUnless(os.name != 'nt', 'test requires dlerror() calls')
+class TestLocalization(unittest.TestCase):
+
+    @staticmethod
+    def configure_locales(func):
+        return test.support.run_with_locale(
+            'LC_ALL',
+            'fr_FR.iso88591', 'ja_JP.sjis', 'zh_CN.gbk',
+            'fr_FR.utf8', 'en_US.utf8',
+            '',
+        )(func)
+
+    @classmethod
+    def setUpClass(cls):
+        cls.libc_filename = find_library("c")
+        if cls.libc_filename is None:
+            raise unittest.SkipTest('cannot find libc')
+
+    @configure_locales
+    def test_localized_error_from_dll(self):
+        dll = CDLL(self.libc_filename)
+        with self.assertRaises(AttributeError):
+            dll.this_name_does_not_exist
+
+    @configure_locales
+    def test_localized_error_in_dll(self):
+        dll = CDLL(self.libc_filename)
+        with self.assertRaises(ValueError):
+            c_int.in_dll(dll, 'this_name_does_not_exist')
+
+    @unittest.skipUnless(hasattr(_ctypes, 'dlopen'),
+                         'test requires _ctypes.dlopen()')
+    @configure_locales
+    def test_localized_error_dlopen(self):
+        missing_filename = b'missing\xff.so'
+        # Depending whether the locale, we may encode '\xff' differently
+        # but we are only interested in avoiding a UnicodeDecodeError
+        # when reporting the dlerror() error message which contains
+        # the localized filename.
+        filename_pattern = r'missing.*?\.so'
+        with self.assertRaisesRegex(OSError, filename_pattern):
+            _ctypes.dlopen(missing_filename, 2)
+
+    @unittest.skipUnless(hasattr(_ctypes, 'dlopen'),
+                         'test requires _ctypes.dlopen()')
+    @unittest.skipUnless(hasattr(_ctypes, 'dlsym'),
+                         'test requires _ctypes.dlsym()')
+    @configure_locales
+    def test_localized_error_dlsym(self):
+        dll = _ctypes.dlopen(self.libc_filename)
+        with self.assertRaises(OSError):
+            _ctypes.dlsym(dll, 'this_name_does_not_exist')
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_errno.py b/Lib/test/test_ctypes/test_errno.py
new file mode 100644
index 0000000000..65d99c1e49
--- /dev/null
+++ b/Lib/test/test_ctypes/test_errno.py
@@ -0,0 +1,81 @@
+import ctypes
+import errno
+import os
+import threading
+import unittest
+from ctypes import CDLL, c_int, c_char_p, c_wchar_p, get_errno, set_errno
+from ctypes.util import find_library
+
+
+class Test(unittest.TestCase):
+    def test_open(self):
+        libc_name = find_library("c")
+        if libc_name is None:
+            self.skipTest("Unable to find C library")
+
+        libc = CDLL(libc_name, use_errno=True)
+        if os.name == "nt":
+            libc_open = libc._open
+        else:
+            libc_open = libc.open
+
+        libc_open.argtypes = c_char_p, c_int
+
+        self.assertEqual(libc_open(b"", 0), -1)
+        self.assertEqual(get_errno(), errno.ENOENT)
+
+        self.assertEqual(set_errno(32), errno.ENOENT)
+        self.assertEqual(get_errno(), 32)
+
+        def _worker():
+            set_errno(0)
+
+            libc = CDLL(libc_name, use_errno=False)
+            if os.name == "nt":
+                libc_open = libc._open
+            else:
+                libc_open = libc.open
+            libc_open.argtypes = c_char_p, c_int
+            self.assertEqual(libc_open(b"", 0), -1)
+            self.assertEqual(get_errno(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(get_errno(), 32)
+        set_errno(0)
+
+    @unittest.skipUnless(os.name == "nt", 'Test specific to Windows')
+    def test_GetLastError(self):
+        dll = ctypes.WinDLL("kernel32", use_last_error=True)
+        GetModuleHandle = dll.GetModuleHandleA
+        GetModuleHandle.argtypes = [c_wchar_p]
+
+        self.assertEqual(0, GetModuleHandle("foo"))
+        self.assertEqual(ctypes.get_last_error(), 126)
+
+        self.assertEqual(ctypes.set_last_error(32), 126)
+        self.assertEqual(ctypes.get_last_error(), 32)
+
+        def _worker():
+            ctypes.set_last_error(0)
+
+            dll = ctypes.WinDLL("kernel32", use_last_error=False)
+            GetModuleHandle = dll.GetModuleHandleW
+            GetModuleHandle.argtypes = [c_wchar_p]
+            GetModuleHandle("bar")
+
+            self.assertEqual(ctypes.get_last_error(), 0)
+
+        t = threading.Thread(target=_worker)
+        t.start()
+        t.join()
+
+        self.assertEqual(ctypes.get_last_error(), 32)
+
+        ctypes.set_last_error(0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_find.py b/Lib/test/test_ctypes/test_find.py
similarity index 80%
rename from Lib/ctypes/test/test_find.py
rename to Lib/test/test_ctypes/test_find.py
index 1ff9d019b1..85b28617d2 100644
--- a/Lib/ctypes/test/test_find.py
+++ b/Lib/test/test_ctypes/test_find.py
@@ -1,11 +1,12 @@
-import unittest
-import unittest.mock
 import os.path
 import sys
 import test.support
-from test.support import os_helper
-from ctypes import *
+import unittest
+import unittest.mock
+from ctypes import CDLL, RTLD_GLOBAL
 from ctypes.util import find_library
+from test.support import os_helper
+
 
 # On some systems, loading the OpenGL libraries needs the RTLD_GLOBAL mode.
 class Test_OpenGL_libs(unittest.TestCase):
@@ -22,7 +23,7 @@ def setUpClass(cls):
             lib_glu = find_library("GLU")
             lib_gle = find_library("gle")
 
-        ## print, for debugging
+        # print, for debugging
         if test.support.verbose:
             print("OpenGL libraries:")
             for item in (("GL", lib_gl),
@@ -36,11 +37,13 @@ def setUpClass(cls):
                 cls.gl = CDLL(lib_gl, mode=RTLD_GLOBAL)
             except OSError:
                 pass
+
         if lib_glu:
             try:
                 cls.glu = CDLL(lib_glu, RTLD_GLOBAL)
             except OSError:
                 pass
+
         if lib_gle:
             try:
                 cls.gle = CDLL(lib_gle)
@@ -122,6 +125,32 @@ def test_find_library_with_ld(self):
              unittest.mock.patch("ctypes.util._findLib_gcc", lambda *args: None):
             self.assertNotEqual(find_library('c'), None)
 
+    def test_gh114257(self):
+        self.assertIsNone(find_library("libc"))
+
+
+@unittest.skipUnless(sys.platform == 'android', 'Test only valid for Android')
+class FindLibraryAndroid(unittest.TestCase):
+    def test_find(self):
+        for name in [
+            "c", "m",  # POSIX
+            "z",  # Non-POSIX, but present on Linux
+            "log",  # Not present on Linux
+        ]:
+            with self.subTest(name=name):
+                path = find_library(name)
+                self.assertIsInstance(path, str)
+                self.assertEqual(
+                    os.path.dirname(path),
+                    "/system/lib64" if "64" in os.uname().machine
+                    else "/system/lib")
+                self.assertEqual(os.path.basename(path), f"lib{name}.so")
+                self.assertTrue(os.path.isfile(path), path)
+
+        for name in ["libc", "nonexistent"]:
+            with self.subTest(name=name):
+                self.assertIsNone(find_library(name))
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_frombuffer.py b/Lib/test/test_ctypes/test_frombuffer.py
similarity index 97%
rename from Lib/ctypes/test/test_frombuffer.py
rename to Lib/test/test_ctypes/test_frombuffer.py
index 55c244356b..d4e161f864 100644
--- a/Lib/ctypes/test/test_frombuffer.py
+++ b/Lib/test/test_ctypes/test_frombuffer.py
@@ -1,7 +1,10 @@
-from ctypes import *
 import array
 import gc
 import unittest
+from ctypes import (Structure, Union, Array, sizeof,
+                    _Pointer, _SimpleCData, _CFuncPtr,
+                    c_char, c_int)
+
 
 class X(Structure):
     _fields_ = [("c_int", c_int)]
@@ -9,6 +12,7 @@ class X(Structure):
     def __init__(self):
         self._init_called = True
 
+
 class Test(unittest.TestCase):
     def test_from_buffer(self):
         a = array.array("i", range(16))
@@ -121,8 +125,6 @@ def test_from_buffer_copy_with_offset(self):
             (c_int * 1).from_buffer_copy(a, 16 * sizeof(c_int))
 
     def test_abstract(self):
-        from ctypes import _Pointer, _SimpleCData, _CFuncPtr
-
         self.assertRaises(TypeError, Array.from_buffer, bytearray(10))
         self.assertRaises(TypeError, Structure.from_buffer, bytearray(10))
         self.assertRaises(TypeError, Union.from_buffer, bytearray(10))
@@ -137,5 +139,6 @@ def test_abstract(self):
         self.assertRaises(TypeError, _Pointer.from_buffer_copy, b"123")
         self.assertRaises(TypeError, _SimpleCData.from_buffer_copy, b"123")
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_funcptr.py b/Lib/test/test_ctypes/test_funcptr.py
new file mode 100644
index 0000000000..8362fb16d9
--- /dev/null
+++ b/Lib/test/test_ctypes/test_funcptr.py
@@ -0,0 +1,134 @@
+import ctypes
+import unittest
+from ctypes import (CDLL, Structure, CFUNCTYPE, sizeof, _CFuncPtr,
+                    c_void_p, c_char_p, c_char, c_int, c_uint, c_long)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCFuncPtrType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+try:
+    WINFUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
+    # fake to enable this test on Linux
+    WINFUNCTYPE = CFUNCTYPE
+
+lib = CDLL(_ctypes_test.__file__)
+
+
+class CFuncPtrTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_CFuncPtr.mro(), [_CFuncPtr, _CData, object])
+
+        self.assertEqual(PyCFuncPtrType.__name__, "PyCFuncPtrType")
+        self.assertEqual(type(PyCFuncPtrType), type)
+
+    def test_type_flags(self):
+        for cls in _CFuncPtr, PyCFuncPtrType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_CFuncPtr.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_CFuncPtr.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Cannot call the metaclass __init__ more than once
+        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCFuncPtrType.__init__(CdeclCallback, 'ptr', (), {})
+
+    def test_basic(self):
+        X = WINFUNCTYPE(c_int, c_int, c_int)
+
+        def func(*args):
+            return len(args)
+
+        x = X(func)
+        self.assertEqual(x.restype, c_int)
+        self.assertEqual(x.argtypes, (c_int, c_int))
+        self.assertEqual(sizeof(x), sizeof(c_void_p))
+        self.assertEqual(sizeof(X), sizeof(c_void_p))
+
+    def test_first(self):
+        StdCallback = WINFUNCTYPE(c_int, c_int, c_int)
+        CdeclCallback = CFUNCTYPE(c_int, c_int, c_int)
+
+        def func(a, b):
+            return a + b
+
+        s = StdCallback(func)
+        c = CdeclCallback(func)
+
+        self.assertEqual(s(1, 2), 3)
+        self.assertEqual(c(1, 2), 3)
+        # The following no longer raises a TypeError - it is now
+        # possible, as in C, to call cdecl functions with more parameters.
+        #self.assertRaises(TypeError, c, 1, 2, 3)
+        self.assertEqual(c(1, 2, 3, 4, 5, 6), 3)
+        if WINFUNCTYPE is not CFUNCTYPE:
+            self.assertRaises(TypeError, s, 1, 2, 3)
+
+    def test_structures(self):
+        WNDPROC = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        def wndproc(hwnd, msg, wParam, lParam):
+            return hwnd + msg + wParam + lParam
+
+        HINSTANCE = c_int
+        HICON = c_int
+        HCURSOR = c_int
+        LPCTSTR = c_char_p
+
+        class WNDCLASS(Structure):
+            _fields_ = [("style", c_uint),
+                        ("lpfnWndProc", WNDPROC),
+                        ("cbClsExtra", c_int),
+                        ("cbWndExtra", c_int),
+                        ("hInstance", HINSTANCE),
+                        ("hIcon", HICON),
+                        ("hCursor", HCURSOR),
+                        ("lpszMenuName", LPCTSTR),
+                        ("lpszClassName", LPCTSTR)]
+
+        wndclass = WNDCLASS()
+        wndclass.lpfnWndProc = WNDPROC(wndproc)
+
+        WNDPROC_2 = WINFUNCTYPE(c_long, c_int, c_int, c_int, c_int)
+
+        self.assertIs(WNDPROC, WNDPROC_2)
+        self.assertEqual(wndclass.lpfnWndProc(1, 2, 3, 4), 10)
+
+        f = wndclass.lpfnWndProc
+
+        del wndclass
+        del wndproc
+
+        self.assertEqual(f(10, 11, 12, 13), 46)
+
+    def test_dllfunctions(self):
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+        strchr.argtypes = (c_char_p, c_char)
+        self.assertEqual(strchr(b"abcdefghi", b"b"), b"bcdefghi")
+        self.assertEqual(strchr(b"abcdefghi", b"x"), None)
+
+        strtok = lib.my_strtok
+        strtok.restype = c_char_p
+
+        def c_string(init):
+            size = len(init) + 1
+            return (c_char*size)(*init)
+
+        s = b"a\nb\nc"
+        b = c_string(s)
+
+        self.assertEqual(strtok(b, b"\n"), b"a")
+        self.assertEqual(strtok(None, b"\n"), b"b")
+        self.assertEqual(strtok(None, b"\n"), b"c")
+        self.assertEqual(strtok(None, b"\n"), None)
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, _CFuncPtr, 13, "name", 42, "iid")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/ctypes/test/test_functions.py b/Lib/test/test_ctypes/test_functions.py
similarity index 76%
rename from Lib/ctypes/test/test_functions.py
rename to Lib/test/test_ctypes/test_functions.py
index fc571700ce..63e393f7b7 100644
--- a/Lib/ctypes/test/test_functions.py
+++ b/Lib/test/test_ctypes/test_functions.py
@@ -1,30 +1,36 @@
-"""
-Here is probably the place to write the docs, since the test-cases
-show how the type behave.
+import ctypes
+import sys
+import unittest
+from ctypes import (CDLL, Structure, Array, CFUNCTYPE,
+                    byref, POINTER, pointer, ArgumentError,
+                    c_char, c_wchar, c_byte, c_char_p, c_wchar_p,
+                    c_short, c_int, c_long, c_longlong, c_void_p,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from _ctypes import _Pointer,  _SimpleCData
 
-Later...
-"""
-
-from ctypes import *
-from ctypes.test import need_symbol
-import sys, unittest
 
 try:
-    WINFUNCTYPE
-except NameError:
+    WINFUNCTYPE = ctypes.WINFUNCTYPE
+except AttributeError:
     # fake to enable this test on Linux
     WINFUNCTYPE = CFUNCTYPE
 
-import _ctypes_test
 dll = CDLL(_ctypes_test.__file__)
 if sys.platform == "win32":
-    windll = WinDLL(_ctypes_test.__file__)
+    windll = ctypes.WinDLL(_ctypes_test.__file__)
+
 
 class POINT(Structure):
     _fields_ = [("x", c_int), ("y", c_int)]
+
+
 class RECT(Structure):
     _fields_ = [("left", c_int), ("top", c_int),
                 ("right", c_int), ("bottom", c_int)]
+
+
 class FunctionTestCase(unittest.TestCase):
 
     def test_mro(self):
@@ -40,21 +46,34 @@ class X(object, Array):
                 _length_ = 5
                 _type_ = "i"
 
-        from _ctypes import _Pointer
         with self.assertRaises(TypeError):
-            class X(object, _Pointer):
+            class X2(object, _Pointer):
                 pass
 
-        from _ctypes import _SimpleCData
         with self.assertRaises(TypeError):
-            class X(object, _SimpleCData):
+            class X3(object, _SimpleCData):
                 _type_ = "i"
 
         with self.assertRaises(TypeError):
-            class X(object, Structure):
+            class X4(object, Structure):
                 _fields_ = []
 
-    @need_symbol('c_wchar')
+    def test_c_char_parm(self):
+        proto = CFUNCTYPE(c_int, c_char)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+
+        self.assertEqual(callback(b"a"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(b"abc")
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: one character bytes, "
+                         "bytearray or integer expected")
+
     def test_wchar_parm(self):
         f = dll._testfunc_i_bhilfd
         f.argtypes = [c_byte, c_wchar, c_int, c_long, c_float, c_double]
@@ -62,7 +81,66 @@ def test_wchar_parm(self):
         self.assertEqual(result, 139)
         self.assertEqual(type(result), int)
 
-    @need_symbol('c_wchar')
+        with self.assertRaises(ArgumentError) as cm:
+            f(1, 2, 3, 4, 5.0, 6.0)
+        self.assertEqual(str(cm.exception),
+                         "argument 2: TypeError: unicode string expected "
+                         "instead of int instance")
+
+        with self.assertRaises(ArgumentError) as cm:
+            f(1, "abc", 3, 4, 5.0, 6.0)
+        self.assertEqual(str(cm.exception),
+                         "argument 2: TypeError: one character unicode string "
+                         "expected")
+
+    def test_c_char_p_parm(self):
+        """Test the error message when converting an incompatible type to c_char_p."""
+        proto = CFUNCTYPE(c_int, c_char_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback(b"abc"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(10)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'int' object cannot be "
+                         "interpreted as ctypes.c_char_p")
+
+    def test_c_wchar_p_parm(self):
+        """Test the error message when converting an incompatible type to c_wchar_p."""
+        proto = CFUNCTYPE(c_int, c_wchar_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback("abc"), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(10)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'int' object cannot be "
+                         "interpreted as ctypes.c_wchar_p")
+
+    def test_c_void_p_parm(self):
+        """Test the error message when converting an incompatible type to c_void_p."""
+        proto = CFUNCTYPE(c_int, c_void_p)
+        def callback(*args):
+            return 0
+
+        callback = proto(callback)
+        self.assertEqual(callback(5), 0)
+
+        with self.assertRaises(ArgumentError) as cm:
+            callback(2.5)
+
+        self.assertEqual(str(cm.exception),
+                         "argument 1: TypeError: 'float' object cannot be "
+                         "interpreted as ctypes.c_void_p")
+
     def test_wchar_result(self):
         f = dll._testfunc_i_bhilfd
         f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_double]
@@ -128,7 +206,6 @@ def test_doubleresult(self):
         self.assertEqual(result, -21)
         self.assertEqual(type(result), float)
 
-    @need_symbol('c_longdouble')
     def test_longdoubleresult(self):
         f = dll._testfunc_D_bhilfD
         f.argtypes = [c_byte, c_short, c_int, c_long, c_float, c_longdouble]
@@ -141,7 +218,6 @@ def test_longdoubleresult(self):
         self.assertEqual(result, -21)
         self.assertEqual(type(result), float)
 
-    @need_symbol('c_longlong')
     def test_longlongresult(self):
         f = dll._testfunc_q_bhilfd
         f.restype = c_longlong
@@ -200,7 +276,6 @@ def test_pointers(self):
         result = f(byref(c_int(99)))
         self.assertNotEqual(result.contents, 99)
 
-    ################################################################
     def test_shorts(self):
         f = dll._testfunc_callback_i_if
 
@@ -218,9 +293,6 @@ def callback(v):
         f(2**18, cb)
         self.assertEqual(args, expected)
 
-    ################################################################
-
-
     def test_callbacks(self):
         f = dll._testfunc_callback_i_if
         f.restype = c_int
@@ -229,7 +301,6 @@ def test_callbacks(self):
         MyCallback = CFUNCTYPE(c_int, c_int)
 
         def callback(value):
-            #print "called back with", value
             return value
 
         cb = MyCallback(callback)
@@ -262,7 +333,6 @@ def test_callbacks_2(self):
         f.argtypes = [c_int, MyCallback]
 
         def callback(value):
-            #print "called back with", value
             self.assertEqual(type(value), int)
             return value
 
@@ -270,7 +340,6 @@ def callback(value):
         result = f(-10, cb)
         self.assertEqual(result, -18)
 
-    @need_symbol('c_longlong')
     def test_longlong_callbacks(self):
 
         f = dll._testfunc_callback_q_qf
@@ -371,7 +440,7 @@ class S8I(Structure):
                 (9*2, 8*3, 7*4, 6*5, 5*6, 4*7, 3*8, 2*9))
 
     def test_sf1651235(self):
-        # see https://www.python.org/sf/1651235
+        # see https://bugs.python.org/issue1651235
 
         proto = CFUNCTYPE(c_int, RECT, POINT)
         def callback(*args):
@@ -380,5 +449,6 @@ def callback(*args):
         callback = proto(callback)
         self.assertRaises(ArgumentError, lambda: callback((1, 2, 3, 4), POINT()))
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_incomplete.py b/Lib/test/test_ctypes/test_incomplete.py
new file mode 100644
index 0000000000..9f859793d8
--- /dev/null
+++ b/Lib/test/test_ctypes/test_incomplete.py
@@ -0,0 +1,50 @@
+import ctypes
+import unittest
+import warnings
+from ctypes import Structure, POINTER, pointer, c_char_p
+
+
+# The incomplete pointer example from the tutorial
+class TestSetPointerType(unittest.TestCase):
+    def tearDown(self):
+        # to not leak references, we must clean _pointer_type_cache
+        ctypes._reset_cache()
+
+    def test_incomplete_example(self):
+        lpcell = POINTER("cell")
+        class cell(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("next", lpcell)]
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', DeprecationWarning)
+            ctypes.SetPointerType(lpcell, cell)
+
+        c1 = cell()
+        c1.name = b"foo"
+        c2 = cell()
+        c2.name = b"bar"
+
+        c1.next = pointer(c2)
+        c2.next = pointer(c1)
+
+        p = c1
+
+        result = []
+        for i in range(8):
+            result.append(p.name)
+            p = p.next[0]
+        self.assertEqual(result, [b"foo", b"bar"] * 4)
+
+    def test_deprecation(self):
+        lpcell = POINTER("cell")
+        class cell(Structure):
+            _fields_ = [("name", c_char_p),
+                        ("next", lpcell)]
+
+        with self.assertWarns(DeprecationWarning):
+            ctypes.SetPointerType(lpcell, cell)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_init.py b/Lib/test/test_ctypes/test_init.py
new file mode 100644
index 0000000000..113425e582
--- /dev/null
+++ b/Lib/test/test_ctypes/test_init.py
@@ -0,0 +1,43 @@
+import unittest
+from ctypes import Structure, c_int
+
+
+class X(Structure):
+    _fields_ = [("a", c_int),
+                ("b", c_int)]
+    new_was_called = False
+
+    def __new__(cls):
+        result = super().__new__(cls)
+        result.new_was_called = True
+        return result
+
+    def __init__(self):
+        self.a = 9
+        self.b = 12
+
+
+class Y(Structure):
+    _fields_ = [("x", X)]
+
+
+class InitTest(unittest.TestCase):
+    def test_get(self):
+        # make sure the only accessing a nested structure
+        # doesn't call the structure's __new__ and __init__
+        y = Y()
+        self.assertEqual((y.x.a, y.x.b), (0, 0))
+        self.assertEqual(y.x.new_was_called, False)
+
+        # But explicitly creating an X structure calls __new__ and __init__, of course.
+        x = X()
+        self.assertEqual((x.a, x.b), (9, 12))
+        self.assertEqual(x.new_was_called, True)
+
+        y.x = x
+        self.assertEqual((y.x.a, y.x.b), (9, 12))
+        self.assertEqual(y.x.new_was_called, False)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_internals.py b/Lib/test/test_ctypes/test_internals.py
similarity index 84%
rename from Lib/ctypes/test/test_internals.py
rename to Lib/test/test_ctypes/test_internals.py
index 271e3f57f8..292633aaa4 100644
--- a/Lib/ctypes/test/test_internals.py
+++ b/Lib/test/test_ctypes/test_internals.py
@@ -1,7 +1,4 @@
 # This tests the internal _objects attribute
-import unittest
-from ctypes import *
-from sys import getrefcount as grc
 
 # XXX This test must be reviewed for correctness!!!
 
@@ -14,22 +11,29 @@
 #
 # What about pointers?
 
+import sys
+import unittest
+from ctypes import Structure, POINTER, c_char_p, c_int
+
+
 class ObjectsTestCase(unittest.TestCase):
     def assertSame(self, a, b):
         self.assertEqual(id(a), id(b))
 
     def test_ints(self):
         i = 42000123
-        refcnt = grc(i)
+        refcnt = sys.getrefcount(i)
         ci = c_int(i)
-        self.assertEqual(refcnt, grc(i))
+        self.assertEqual(refcnt, sys.getrefcount(i))
         self.assertEqual(ci._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_c_char_p(self):
-        s = b"Hello, World"
-        refcnt = grc(s)
+        s = "Hello, World".encode("ascii")
+        refcnt = sys.getrefcount(s)
         cs = c_char_p(s)
-        self.assertEqual(refcnt + 1, grc(s))
+        self.assertEqual(refcnt + 1, sys.getrefcount(s))
         self.assertSame(cs._objects, s)
 
     def test_simple_struct(self):
@@ -60,6 +64,8 @@ class Y(Structure):
         x1.a, x2.b = 42, 93
         self.assertEqual(y._objects, {"0": {}, "1": {}})
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_xxx(self):
         class X(Structure):
             _fields_ = [("a", c_char_p), ("b", c_char_p)]
@@ -78,9 +84,6 @@ class Y(Structure):
         y = Y()
         y.x = x
         self.assertEqual(y._objects, {"0": {"0": s1, "1": s2}})
-##        x = y.x
-##        del y
-##        print x._b_base_._objects
 
     def test_ptr_struct(self):
         class X(Structure):
@@ -92,9 +95,7 @@ class X(Structure):
 
         x = X()
         x.data = a
-##XXX        print x._objects
-##XXX        print x.data[0]
-##XXX        print x.data._objects
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_keeprefs.py b/Lib/test/test_ctypes/test_keeprefs.py
similarity index 76%
rename from Lib/ctypes/test/test_keeprefs.py
rename to Lib/test/test_ctypes/test_keeprefs.py
index 94c02573fa..5aa5b86fa4 100644
--- a/Lib/ctypes/test/test_keeprefs.py
+++ b/Lib/test/test_ctypes/test_keeprefs.py
@@ -1,5 +1,7 @@
-from ctypes import *
 import unittest
+from ctypes import (Structure, POINTER, pointer,  _pointer_type_cache,
+                    c_char_p, c_int)
+
 
 class SimpleTestCase(unittest.TestCase):
     def test_cint(self):
@@ -10,6 +12,8 @@ def test_cint(self):
         x = c_int(99)
         self.assertEqual(x._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ccharp(self):
         x = c_char_p()
         self.assertEqual(x._objects, None)
@@ -18,6 +22,7 @@ def test_ccharp(self):
         x = c_char_p(b"spam")
         self.assertEqual(x._objects, b"spam")
 
+
 class StructureTestCase(unittest.TestCase):
     def test_cint_struct(self):
         class X(Structure):
@@ -30,6 +35,8 @@ class X(Structure):
         x.b = 99
         self.assertEqual(x._objects, None)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_ccharp_struct(self):
         class X(Structure):
             _fields_ = [("a", c_char_p),
@@ -64,6 +71,7 @@ class RECT(Structure):
         r.lr = POINT()
         self.assertEqual(r._objects, {'0': {}, '1': {}})
 
+
 class ArrayTestCase(unittest.TestCase):
     def test_cint_array(self):
         INTARR = c_int * 3
@@ -87,43 +95,13 @@ class X(Structure):
         x.a = ia
         self.assertEqual(x._objects, {'1': {}})
 
+
 class PointerTestCase(unittest.TestCase):
     def test_p_cint(self):
         i = c_int(42)
         x = pointer(i)
         self.assertEqual(x._objects, {'1': i})
 
-class DeletePointerTestCase(unittest.TestCase):
-    @unittest.skip('test disabled')
-    def test_X(self):
-        class X(Structure):
-            _fields_ = [("p", POINTER(c_char_p))]
-        x = X()
-        i = c_char_p("abc def")
-        from sys import getrefcount as grc
-        print("2?", grc(i))
-        x.p = pointer(i)
-        print("3?", grc(i))
-        for i in range(320):
-            c_int(99)
-            x.p[0]
-        print(x.p[0])
-##        del x
-##        print "2?", grc(i)
-##        del i
-        import gc
-        gc.collect()
-        for i in range(320):
-            c_int(99)
-            x.p[0]
-        print(x.p[0])
-        print(x.p.contents)
-##        print x._objects
-
-        x.p[0] = "spam spam"
-##        print x.p[0]
-        print("+" * 42)
-        print(x._objects)
 
 class PointerToStructure(unittest.TestCase):
     def test(self):
@@ -137,17 +115,14 @@ class RECT(Structure):
 
         r.a = pointer(p1)
         r.b = pointer(p1)
-##        from pprint import pprint as pp
-##        pp(p1._objects)
-##        pp(r._objects)
 
         r.a[0].x = 42
         r.a[0].y = 99
 
         # to avoid leaking when tests are run several times
         # clean up the types left in the cache.
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[POINT]
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_libc.py b/Lib/test/test_ctypes/test_libc.py
similarity index 78%
rename from Lib/ctypes/test/test_libc.py
rename to Lib/test/test_ctypes/test_libc.py
index 56285b5ff8..7716100b08 100644
--- a/Lib/ctypes/test/test_libc.py
+++ b/Lib/test/test_ctypes/test_libc.py
@@ -1,20 +1,24 @@
+import math
 import unittest
+from ctypes import (CDLL, CFUNCTYPE, POINTER, create_string_buffer, sizeof,
+                    c_void_p, c_char, c_int, c_double, c_size_t)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-from ctypes import *
-import _ctypes_test
 
 lib = CDLL(_ctypes_test.__file__)
 
+
 def three_way_cmp(x, y):
     """Return -1 if x < y, 0 if x == y and 1 if x > y"""
     return (x > y) - (x < y)
 
+
 class LibTest(unittest.TestCase):
     def test_sqrt(self):
         lib.my_sqrt.argtypes = c_double,
         lib.my_sqrt.restype = c_double
         self.assertEqual(lib.my_sqrt(4.0), 2.0)
-        import math
         self.assertEqual(lib.my_sqrt(2.0), math.sqrt(2.0))
 
     def test_qsort(self):
@@ -29,5 +33,6 @@ def sort(a, b):
         lib.my_qsort(chars, len(chars)-1, sizeof(c_char), comparefunc(sort))
         self.assertEqual(chars.raw, b"   ,,aaaadmmmnpppsss\x00")
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_loading.py b/Lib/test/test_ctypes/test_loading.py
new file mode 100644
index 0000000000..a4d54f676a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_loading.py
@@ -0,0 +1,208 @@
+import _ctypes
+import ctypes
+import os
+import shutil
+import subprocess
+import sys
+import test.support
+import unittest
+from ctypes import CDLL, cdll, addressof, c_void_p, c_char_p
+from ctypes.util import find_library
+from test.support import import_helper, os_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+libc_name = None
+
+
+def setUpModule():
+    global libc_name
+    if os.name == "nt":
+        libc_name = find_library("c")
+    elif sys.platform == "cygwin":
+        libc_name = "cygwin1.dll"
+    else:
+        libc_name = find_library("c")
+
+    if test.support.verbose:
+        print("libc_name is", libc_name)
+
+
+class LoaderTest(unittest.TestCase):
+
+    unknowndll = "xxrandomnamexx"
+
+    def test_load(self):
+        if libc_name is not None:
+            test_lib = libc_name
+        else:
+            if os.name == "nt":
+                test_lib = _ctypes_test.__file__
+            else:
+                self.skipTest('could not find library to load')
+        CDLL(test_lib)
+        CDLL(os.path.basename(test_lib))
+        CDLL(os_helper.FakePath(test_lib))
+        self.assertRaises(OSError, CDLL, self.unknowndll)
+
+    def test_load_version(self):
+        if libc_name is None:
+            self.skipTest('could not find libc')
+        if os.path.basename(libc_name) != 'libc.so.6':
+            self.skipTest('wrong libc path for test')
+        cdll.LoadLibrary("libc.so.6")
+        # linux uses version, libc 9 should not exist
+        self.assertRaises(OSError, cdll.LoadLibrary, "libc.so.9")
+        self.assertRaises(OSError, cdll.LoadLibrary, self.unknowndll)
+
+    def test_find(self):
+        found = False
+        for name in ("c", "m"):
+            lib = find_library(name)
+            if lib:
+                found = True
+                cdll.LoadLibrary(lib)
+                CDLL(lib)
+        if not found:
+            self.skipTest("Could not find c and m libraries")
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_library(self):
+        # CRT is no longer directly loadable. See issue23606 for the
+        # discussion about alternative approaches.
+        #self.assertIsNotNone(libc_name)
+        if test.support.verbose:
+            print(find_library("kernel32"))
+            print(find_library("user32"))
+
+        if os.name == "nt":
+            ctypes.windll.kernel32.GetModuleHandleW
+            ctypes.windll["kernel32"].GetModuleHandleW
+            ctypes.windll.LoadLibrary("kernel32").GetModuleHandleW
+            ctypes.WinDLL("kernel32").GetModuleHandleW
+            # embedded null character
+            self.assertRaises(ValueError, ctypes.windll.LoadLibrary, "kernel32\0")
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_ordinal_functions(self):
+        dll = ctypes.WinDLL(_ctypes_test.__file__)
+        # We load the same function both via ordinal and name
+        func_ord = dll[2]
+        func_name = dll.GetString
+        # addressof gets the address where the function pointer is stored
+        a_ord = addressof(func_ord)
+        a_name = addressof(func_name)
+        f_ord_addr = c_void_p.from_address(a_ord).value
+        f_name_addr = c_void_p.from_address(a_name).value
+        self.assertEqual(hex(f_ord_addr), hex(f_name_addr))
+
+        self.assertRaises(AttributeError, dll.__getitem__, 1234)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_load_without_name_and_with_handle(self):
+        handle = ctypes.windll.kernel32._handle
+        lib = ctypes.WinDLL(name=None, handle=handle)
+        self.assertIs(handle, lib._handle)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_A(self):
+        # On winXP 64-bit, advapi32 loads at an address that does
+        # NOT fit into a 32-bit integer.  FreeLibrary must be able
+        # to accept this address.
+
+        # These are tests for https://bugs.python.org/issue1703286
+        handle = _ctypes.LoadLibrary("advapi32")
+        _ctypes.FreeLibrary(handle)
+
+    @unittest.skipUnless(os.name == "nt", 'Windows-specific test')
+    def test_1703286_B(self):
+        # Since on winXP 64-bit advapi32 loads like described
+        # above, the (arbitrarily selected) CloseEventLog function
+        # also has a high address.  'call_function' should accept
+        # addresses so large.
+
+        advapi32 = ctypes.windll.advapi32
+        # Calling CloseEventLog with a NULL argument should fail,
+        # but the call should not segfault or so.
+        self.assertEqual(0, advapi32.CloseEventLog(None))
+
+        kernel32 = ctypes.windll.kernel32
+        kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        kernel32.GetProcAddress.restype = c_void_p
+        proc = kernel32.GetProcAddress(advapi32._handle, b"CloseEventLog")
+        self.assertTrue(proc)
+
+        # This is the real test: call the function via 'call_function'
+        self.assertEqual(0, _ctypes.call_function(proc, (None,)))
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_hasattr(self):
+        # bpo-34816: shouldn't raise OSError
+        self.assertFalse(hasattr(ctypes.windll, 'test'))
+
+    @unittest.skipUnless(os.name == "nt",
+                         'test specific to Windows')
+    def test_load_dll_with_flags(self):
+        _sqlite3 = import_helper.import_module("_sqlite3")
+        src = _sqlite3.__file__
+        if os.path.basename(src).partition(".")[0].lower().endswith("_d"):
+            ext = "_d.dll"
+        else:
+            ext = ".dll"
+
+        with os_helper.temp_dir() as tmp:
+            # We copy two files and load _sqlite3.dll (formerly .pyd),
+            # which has a dependency on sqlite3.dll. Then we test
+            # loading it in subprocesses to avoid it starting in memory
+            # for each test.
+            target = os.path.join(tmp, "_sqlite3.dll")
+            shutil.copy(src, target)
+            shutil.copy(os.path.join(os.path.dirname(src), "sqlite3" + ext),
+                        os.path.join(tmp, "sqlite3" + ext))
+
+            def should_pass(command):
+                with self.subTest(command):
+                    subprocess.check_output(
+                        [sys.executable, "-c",
+                         "from ctypes import *; import nt;" + command],
+                        cwd=tmp
+                    )
+
+            def should_fail(command):
+                with self.subTest(command):
+                    with self.assertRaises(subprocess.CalledProcessError):
+                        subprocess.check_output(
+                            [sys.executable, "-c",
+                             "from ctypes import *; import nt;" + command],
+                            cwd=tmp, stderr=subprocess.STDOUT,
+                        )
+
+            # Default load should not find this in CWD
+            should_fail("WinDLL('_sqlite3.dll')")
+
+            # Relative path (but not just filename) should succeed
+            should_pass("WinDLL('./_sqlite3.dll')")
+
+            # Insecure load flags should succeed
+            # Clear the DLL directory to avoid safe search settings propagating
+            should_pass("windll.kernel32.SetDllDirectoryW(None); WinDLL('_sqlite3.dll', winmode=0)")
+
+            # Full path load without DLL_LOAD_DIR shouldn't find dependency
+            should_fail("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32)")
+
+            # Full path load with DLL_LOAD_DIR should succeed
+            should_pass("WinDLL(nt._getfullpathname('_sqlite3.dll'), " +
+                        "winmode=nt._LOAD_LIBRARY_SEARCH_SYSTEM32|" +
+                        "nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR)")
+
+            # User-specified directory should succeed
+            should_pass("import os; p = os.add_dll_directory(os.getcwd());" +
+                        "WinDLL('_sqlite3.dll'); p.close()")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_macholib.py b/Lib/test/test_ctypes/test_macholib.py
similarity index 99%
rename from Lib/ctypes/test/test_macholib.py
rename to Lib/test/test_ctypes/test_macholib.py
index bc75f1a05a..9d90617995 100644
--- a/Lib/ctypes/test/test_macholib.py
+++ b/Lib/test/test_ctypes/test_macholib.py
@@ -1,7 +1,3 @@
-import os
-import sys
-import unittest
-
 # Bob Ippolito:
 #
 # Ok.. the code to find the filename for __getattr__ should look
@@ -31,10 +27,15 @@
 #
 # -bob
 
+import os
+import sys
+import unittest
+
 from ctypes.macholib.dyld import dyld_find
 from ctypes.macholib.dylib import dylib_info
 from ctypes.macholib.framework import framework_info
 
+
 def find_lib(name):
     possible = ['lib'+name+'.dylib', name+'.dylib', name+'.framework/'+name]
     for dylib in possible:
@@ -106,5 +107,6 @@ def test_framework_info(self):
         self.assertEqual(framework_info('P/F.framework/Versions/A/F_debug'),
                          d('P', 'F.framework/Versions/A/F_debug', 'F', 'A', 'debug'))
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_memfunctions.py b/Lib/test/test_ctypes/test_memfunctions.py
similarity index 87%
rename from Lib/ctypes/test/test_memfunctions.py
rename to Lib/test/test_ctypes/test_memfunctions.py
index e784b9a706..112b27ba48 100644
--- a/Lib/ctypes/test/test_memfunctions.py
+++ b/Lib/test/test_ctypes/test_memfunctions.py
@@ -1,20 +1,23 @@
 import sys
-from test import support
 import unittest
-from ctypes import *
-from ctypes.test import need_symbol
+from test import support
+from ctypes import (POINTER, sizeof, cast,
+                    create_string_buffer, string_at,
+                    create_unicode_buffer, wstring_at,
+                    memmove, memset,
+                    c_char_p, c_byte, c_ubyte, c_wchar)
+
 
 class MemFunctionsTest(unittest.TestCase):
-    @unittest.skip('test disabled')
     def test_overflow(self):
         # string_at and wstring_at must use the Python calling
         # convention (which acquires the GIL and checks the Python
         # error flag).  Provoke an error and catch it; see also issue
-        # #3554: <http://bugs.python.org/issue3554>
+        # gh-47804.
         self.assertRaises((OverflowError, MemoryError, SystemError),
-                          lambda: wstring_at(u"foo", sys.maxint - 1))
+                          lambda: wstring_at(u"foo", sys.maxsize - 1))
         self.assertRaises((OverflowError, MemoryError, SystemError),
-                          lambda: string_at("foo", sys.maxint - 1))
+                          lambda: string_at("foo", sys.maxsize - 1))
 
     def test_memmove(self):
         # large buffers apparently increase the chance that the memory
@@ -63,7 +66,6 @@ def test_string_at(self):
         self.assertEqual(string_at(b"foo bar", 7), b"foo bar")
         self.assertEqual(string_at(b"foo bar", 3), b"foo")
 
-    @need_symbol('create_unicode_buffer')
     def test_wstring_at(self):
         p = create_unicode_buffer("Hello, World")
         a = create_unicode_buffer(1000000)
@@ -75,5 +77,6 @@ def test_wstring_at(self):
         self.assertEqual(wstring_at(a, 16), "Hello, World\0\0\0\0")
         self.assertEqual(wstring_at(a, 0), "")
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_numbers.py b/Lib/test/test_ctypes/test_numbers.py
similarity index 89%
rename from Lib/ctypes/test/test_numbers.py
rename to Lib/test/test_ctypes/test_numbers.py
index a5c661b0e9..29108a28ec 100644
--- a/Lib/ctypes/test/test_numbers.py
+++ b/Lib/test/test_ctypes/test_numbers.py
@@ -1,6 +1,13 @@
-from ctypes import *
-import unittest
+import array
 import struct
+import sys
+import unittest
+from operator import truth
+from ctypes import (byref, sizeof, alignment,
+                    c_char, c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble, c_bool)
+
 
 def valid_ranges(*types):
     # given a sequence of numeric types, collect their _type_
@@ -19,36 +26,18 @@ def valid_ranges(*types):
         result.append((min(a, b, c, d), max(a, b, c, d)))
     return result
 
+
 ArgType = type(byref(c_int(0)))
 
-unsigned_types = [c_ubyte, c_ushort, c_uint, c_ulong]
+unsigned_types = [c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong]
 signed_types = [c_byte, c_short, c_int, c_long, c_longlong]
-
-bool_types = []
-
+bool_types = [c_bool]
 float_types = [c_double, c_float]
 
-try:
-    c_ulonglong
-    c_longlong
-except NameError:
-    pass
-else:
-    unsigned_types.append(c_ulonglong)
-    signed_types.append(c_longlong)
-
-try:
-    c_bool
-except NameError:
-    pass
-else:
-    bool_types.append(c_bool)
-
 unsigned_ranges = valid_ranges(*unsigned_types)
 signed_ranges = valid_ranges(*signed_types)
 bool_values = [True, False, 0, 1, -1, 5000, 'test', [], [1]]
 
-################################################################
 
 class NumberTestCase(unittest.TestCase):
 
@@ -71,7 +60,6 @@ def test_signed_values(self):
             self.assertEqual(t(h).value, h)
 
     def test_bool_values(self):
-        from operator import truth
         for t, v in zip(bool_types, bool_values):
             self.assertEqual(t(v).value, truth(v))
 
@@ -147,21 +135,20 @@ def test_alignments(self):
 
             # alignment of the type...
             self.assertEqual((code, alignment(t)),
-                             (code, align))
+                                 (code, align))
             # and alignment of an instance
             self.assertEqual((code, alignment(t())),
-                             (code, align))
+                                 (code, align))
 
     def test_int_from_address(self):
-        from array import array
         for t in signed_types + unsigned_types:
             # the array module doesn't support all format codes
             # (no 'q' or 'Q')
             try:
-                array(t._type_)
+                array.array(t._type_)
             except ValueError:
                 continue
-            a = array(t._type_, [100])
+            a = array.array(t._type_, [100])
 
             # v now is an integer at an 'external' memory location
             v = t.from_address(a.buffer_info()[0])
@@ -174,9 +161,8 @@ def test_int_from_address(self):
 
 
     def test_float_from_address(self):
-        from array import array
         for t in float_types:
-            a = array(t._type_, [3.14])
+            a = array.array(t._type_, [3.14])
             v = t.from_address(a.buffer_info()[0])
             self.assertEqual(v.value, a[0])
             self.assertIs(type(v), t)
@@ -185,10 +171,7 @@ def test_float_from_address(self):
             self.assertIs(type(v), t)
 
     def test_char_from_address(self):
-        from ctypes import c_char
-        from array import array
-
-        a = array('b', [0])
+        a = array.array('b', [0])
         a[0] = ord('x')
         v = c_char.from_address(a.buffer_info()[0])
         self.assertEqual(v.value, b'x')
@@ -204,7 +187,6 @@ def test_init(self):
         self.assertRaises(TypeError, c_int, c_long(42))
 
     def test_float_overflow(self):
-        import sys
         big_int = int(sys.float_info.max) * 2
         for t in float_types + [c_longdouble]:
             self.assertRaises(OverflowError, t, big_int)
diff --git a/Lib/ctypes/test/test_objects.py b/Lib/test/test_ctypes/test_objects.py
similarity index 78%
rename from Lib/ctypes/test/test_objects.py
rename to Lib/test/test_ctypes/test_objects.py
index 19e3dc1f2d..8db1cd873f 100644
--- a/Lib/ctypes/test/test_objects.py
+++ b/Lib/test/test_ctypes/test_objects.py
@@ -11,7 +11,7 @@
 
 Here is an array of string pointers:
 
->>> from ctypes import *
+>>> from ctypes import Structure, c_int, c_char_p
 >>> array = (c_char_p * 5)()
 >>> print(array._objects)
 None
@@ -42,7 +42,7 @@
 of 'x' ('_b_base_' is either None, or the root object owning the memory block):
 
 >>> print(x.array._b_base_) # doctest: +ELLIPSIS
-<ctypes.test.test_objects.X object at 0x...>
+<test.test_ctypes.test_objects.X object at 0x...>
 >>>
 
 >>> x.array[0] = b'spam spam spam'
@@ -51,17 +51,17 @@
 >>> x.array._b_base_._objects
 {'0:2': b'spam spam spam'}
 >>>
-
 '''
 
-import unittest, doctest
+import doctest
+import unittest
+
 
-import ctypes.test.test_objects
+def load_tests(loader, tests, pattern):
+    # TODO: RUSTPYTHON - doctest disabled due to null terminator in _objects
+    # tests.addTest(doctest.DocTestSuite())
+    return tests
 
-class TestCase(unittest.TestCase):
-    def test(self):
-        failures, tests = doctest.testmod(ctypes.test.test_objects)
-        self.assertFalse(failures, 'doctests failed, see output above')
 
 if __name__ == '__main__':
-    doctest.testmod(ctypes.test.test_objects)
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_parameters.py b/Lib/test/test_ctypes/test_parameters.py
new file mode 100644
index 0000000000..1a6ddb91a7
--- /dev/null
+++ b/Lib/test/test_ctypes/test_parameters.py
@@ -0,0 +1,288 @@
+import sys
+import unittest
+import test.support
+from ctypes import (CDLL, PyDLL, ArgumentError,
+                    Structure, Array, Union,
+                    _Pointer, _SimpleCData, _CFuncPtr,
+                    POINTER, pointer, byref,
+                    c_void_p, c_char_p, c_wchar_p, py_object,
+                    c_bool,
+                    c_char, c_wchar,
+                    c_byte, c_ubyte,
+                    c_short, c_ushort,
+                    c_int, c_uint,
+                    c_long, c_ulong,
+                    c_longlong, c_ulonglong,
+                    c_float, c_double, c_longdouble)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class SimpleTypesTestCase(unittest.TestCase):
+    def setUp(self):
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            self.prev_conv_mode = set_conversion_mode("ascii", "strict")
+
+    def tearDown(self):
+        try:
+            from _ctypes import set_conversion_mode
+        except ImportError:
+            pass
+        else:
+            set_conversion_mode(*self.prev_conv_mode)
+
+    def test_subclasses(self):
+        # ctypes 0.9.5 and before did overwrite from_param in SimpleType_new
+        class CVOIDP(c_void_p):
+            def from_param(cls, value):
+                return value * 2
+            from_param = classmethod(from_param)
+
+        class CCHARP(c_char_p):
+            def from_param(cls, value):
+                return value * 4
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CVOIDP.from_param("abc"), "abcabc")
+        self.assertEqual(CCHARP.from_param("abc"), "abcabcabcabc")
+
+    def test_subclasses_c_wchar_p(self):
+        class CWCHARP(c_wchar_p):
+            def from_param(cls, value):
+                return value * 3
+            from_param = classmethod(from_param)
+
+        self.assertEqual(CWCHARP.from_param("abc"), "abcabcabc")
+
+    # XXX Replace by c_char_p tests
+    def test_cstrings(self):
+        # c_char_p.from_param on a Python String packs the string
+        # into a cparam object
+        s = b"123"
+        self.assertIs(c_char_p.from_param(s)._obj, s)
+
+        # new in 0.9.1: convert (encode) unicode to ascii
+        self.assertEqual(c_char_p.from_param(b"123")._obj, b"123")
+        self.assertRaises(TypeError, c_char_p.from_param, "123\377")
+        self.assertRaises(TypeError, c_char_p.from_param, 42)
+
+        # calling c_char_p.from_param with a c_char_p instance
+        # returns the argument itself:
+        a = c_char_p(b"123")
+        self.assertIs(c_char_p.from_param(a), a)
+
+    def test_cw_strings(self):
+        c_wchar_p.from_param("123")
+
+        self.assertRaises(TypeError, c_wchar_p.from_param, 42)
+        self.assertRaises(TypeError, c_wchar_p.from_param, b"123\377")
+
+        pa = c_wchar_p.from_param(c_wchar_p("123"))
+        self.assertEqual(type(pa), c_wchar_p)
+
+    def test_c_char(self):
+        with self.assertRaises(TypeError) as cm:
+            c_char.from_param(b"abc")
+        self.assertEqual(str(cm.exception),
+                         "one character bytes, bytearray or integer expected")
+
+    def test_c_wchar(self):
+        with self.assertRaises(TypeError) as cm:
+            c_wchar.from_param("abc")
+        self.assertEqual(str(cm.exception),
+                         "one character unicode string expected")
+
+
+        with self.assertRaises(TypeError) as cm:
+            c_wchar.from_param(123)
+        self.assertEqual(str(cm.exception),
+                         "unicode string expected instead of int instance")
+
+    def test_int_pointers(self):
+        LPINT = POINTER(c_int)
+
+        x = LPINT.from_param(pointer(c_int(42)))
+        self.assertEqual(x.contents.value, 42)
+        self.assertEqual(LPINT(c_int(42)).contents.value, 42)
+
+        self.assertEqual(LPINT.from_param(None), None)
+
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, pointer(c_long(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_uint(42)))
+        self.assertRaises(TypeError, LPINT.from_param, pointer(c_short(42)))
+
+    def test_byref_pointer(self):
+        # The from_param class method of POINTER(typ) classes accepts what is
+        # returned by byref(obj), it type(obj) == typ
+        LPINT = POINTER(c_int)
+
+        LPINT.from_param(byref(c_int(42)))
+
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_short(22)))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPINT.from_param, byref(c_long(22)))
+        self.assertRaises(TypeError, LPINT.from_param, byref(c_uint(22)))
+
+    def test_byref_pointerpointer(self):
+        # See above
+
+        LPLPINT = POINTER(POINTER(c_int))
+        LPLPINT.from_param(byref(pointer(c_int(42))))
+
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_short(22))))
+        if c_int != c_long:
+            self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_long(22))))
+        self.assertRaises(TypeError, LPLPINT.from_param, byref(pointer(c_uint(22))))
+
+    def test_array_pointers(self):
+        INTARRAY = c_int * 3
+        ia = INTARRAY()
+        self.assertEqual(len(ia), 3)
+        self.assertEqual([ia[i] for i in range(3)], [0, 0, 0])
+
+        # Pointers are only compatible with arrays containing items of
+        # the same type!
+        LPINT = POINTER(c_int)
+        LPINT.from_param((c_int*3)())
+        self.assertRaises(TypeError, LPINT.from_param, c_short*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_long*3)
+        self.assertRaises(TypeError, LPINT.from_param, c_uint*3)
+
+    def test_noctypes_argtype(self):
+        func = CDLL(_ctypes_test.__file__)._testfunc_p_p
+        func.restype = c_void_p
+        # TypeError: has no from_param method
+        self.assertRaises(TypeError, setattr, func, "argtypes", (object,))
+
+        class Adapter:
+            def from_param(cls, obj):
+                return None
+
+        func.argtypes = (Adapter(),)
+        self.assertEqual(func(None), None)
+        self.assertEqual(func(object()), None)
+
+        class Adapter:
+            def from_param(cls, obj):
+                return obj
+
+        func.argtypes = (Adapter(),)
+        # don't know how to convert parameter 1
+        self.assertRaises(ArgumentError, func, object())
+        self.assertEqual(func(c_void_p(42)), 42)
+
+        class Adapter:
+            def from_param(cls, obj):
+                raise ValueError(obj)
+
+        func.argtypes = (Adapter(),)
+        # ArgumentError: argument 1: ValueError: 99
+        self.assertRaises(ArgumentError, func, 99)
+
+    def test_abstract(self):
+        self.assertRaises(TypeError, Array.from_param, 42)
+        self.assertRaises(TypeError, Structure.from_param, 42)
+        self.assertRaises(TypeError, Union.from_param, 42)
+        self.assertRaises(TypeError, _CFuncPtr.from_param, 42)
+        self.assertRaises(TypeError, _Pointer.from_param, 42)
+        self.assertRaises(TypeError, _SimpleCData.from_param, 42)
+
+    @test.support.cpython_only
+    def test_issue31311(self):
+        # __setstate__ should neither raise a SystemError nor crash in case
+        # of a bad __dict__.
+
+        class BadStruct(Structure):
+            @property
+            def __dict__(self):
+                pass
+        with self.assertRaises(TypeError):
+            BadStruct().__setstate__({}, b'foo')
+
+        class WorseStruct(Structure):
+            @property
+            def __dict__(self):
+                1/0
+        with self.assertRaises(ZeroDivisionError):
+            WorseStruct().__setstate__({}, b'foo')
+
+    def test_parameter_repr(self):
+        self.assertRegex(repr(c_bool.from_param(True)), r"^<cparam '\?' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_char.from_param(97)), "<cparam 'c' ('a')>")
+        self.assertRegex(repr(c_wchar.from_param('a')), r"^<cparam 'u' at 0x[A-Fa-f0-9]+>$")
+        self.assertEqual(repr(c_byte.from_param(98)), "<cparam 'b' (98)>")
+        self.assertEqual(repr(c_ubyte.from_param(98)), "<cparam 'B' (98)>")
+        self.assertEqual(repr(c_short.from_param(511)), "<cparam 'h' (511)>")
+        self.assertEqual(repr(c_ushort.from_param(511)), "<cparam 'H' (511)>")
+        self.assertRegex(repr(c_int.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_uint.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_long.from_param(20000)), r"^<cparam '[li]' \(20000\)>$")
+        self.assertRegex(repr(c_ulong.from_param(20000)), r"^<cparam '[LI]' \(20000\)>$")
+        self.assertRegex(repr(c_longlong.from_param(20000)), r"^<cparam '[liq]' \(20000\)>$")
+        self.assertRegex(repr(c_ulonglong.from_param(20000)), r"^<cparam '[LIQ]' \(20000\)>$")
+        self.assertEqual(repr(c_float.from_param(1.5)), "<cparam 'f' (1.5)>")
+        self.assertEqual(repr(c_double.from_param(1.5)), "<cparam 'd' (1.5)>")
+        if sys.float_repr_style == 'short':
+            self.assertEqual(repr(c_double.from_param(1e300)), "<cparam 'd' (1e+300)>")
+        self.assertRegex(repr(c_longdouble.from_param(1.5)), r"^<cparam ('d' \(1.5\)|'g' at 0x[A-Fa-f0-9]+)>$")
+        self.assertRegex(repr(c_char_p.from_param(b'hihi')), r"^<cparam 'z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_wchar_p.from_param('hihi')), r"^<cparam 'Z' \(0x[A-Fa-f0-9]+\)>$")
+        self.assertRegex(repr(c_void_p.from_param(0x12)), r"^<cparam 'P' \(0x0*12\)>$")
+
+    @test.support.cpython_only
+    def test_from_param_result_refcount(self):
+        # Issue #99952
+        class X(Structure):
+            """This struct size is <= sizeof(void*)."""
+            _fields_ = [("a", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, X]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+        class Y(Structure):
+            """This struct size is > sizeof(void*)."""
+            _fields_ = [("a", c_void_p), ("b", c_void_p)]
+
+            def __del__(self):
+                trace.append(4)
+
+            @classmethod
+            def from_param(cls, value):
+                trace.append(2)
+                return cls()
+
+        PyList_Append = PyDLL(_ctypes_test.__file__)._testfunc_pylist_append
+        PyList_Append.restype = c_int
+        PyList_Append.argtypes = [py_object, py_object, Y]
+
+        trace = []
+        trace.append(1)
+        PyList_Append(trace, 3, "dummy")
+        trace.append(5)
+
+        self.assertEqual(trace, [1, 2, 3, 4, 5])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_pep3118.py b/Lib/test/test_ctypes/test_pep3118.py
new file mode 100644
index 0000000000..06b2ccecad
--- /dev/null
+++ b/Lib/test/test_ctypes/test_pep3118.py
@@ -0,0 +1,250 @@
+import re
+import sys
+import unittest
+from ctypes import (CFUNCTYPE, POINTER, sizeof, Union,
+                    Structure, LittleEndianStructure, BigEndianStructure,
+                    c_char, c_byte, c_ubyte,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong, c_uint64,
+                    c_bool, c_float, c_double, c_longdouble, py_object)
+
+
+if sys.byteorder == "little":
+    THIS_ENDIAN = "<"
+    OTHER_ENDIAN = ">"
+else:
+    THIS_ENDIAN = ">"
+    OTHER_ENDIAN = "<"
+
+
+def normalize(format):
+    # Remove current endian specifier and white space from a format
+    # string
+    if format is None:
+        return ""
+    format = format.replace(OTHER_ENDIAN, THIS_ENDIAN)
+    return re.sub(r"\s", "", format)
+
+
+class Test(unittest.TestCase):
+    def test_native_types(self):
+        for tp, fmt, shape, itemtp in native_types:
+            ob = tp()
+            v = memoryview(ob)
+            self.assertEqual(normalize(v.format), normalize(fmt))
+            if shape:
+                self.assertEqual(len(v), shape[0])
+            else:
+                self.assertRaises(TypeError, len, v)
+            self.assertEqual(v.itemsize, sizeof(itemtp))
+            self.assertEqual(v.shape, shape)
+            # XXX Issue #12851: PyCData_NewGetBuffer() must provide strides
+            #     if requested. memoryview currently reconstructs missing
+            #     stride information, so this assert will fail.
+            # self.assertEqual(v.strides, ())
+
+            # they are always read/write
+            self.assertFalse(v.readonly)
+
+            n = 1
+            for dim in v.shape:
+                n = n * dim
+            self.assertEqual(n * v.itemsize, len(v.tobytes()))
+
+    def test_endian_types(self):
+        for tp, fmt, shape, itemtp in endian_types:
+            ob = tp()
+            v = memoryview(ob)
+            self.assertEqual(v.format, fmt)
+            if shape:
+                self.assertEqual(len(v), shape[0])
+            else:
+                self.assertRaises(TypeError, len, v)
+            self.assertEqual(v.itemsize, sizeof(itemtp))
+            self.assertEqual(v.shape, shape)
+            # XXX Issue #12851
+            # self.assertEqual(v.strides, ())
+
+            # they are always read/write
+            self.assertFalse(v.readonly)
+
+            n = 1
+            for dim in v.shape:
+                n = n * dim
+            self.assertEqual(n * v.itemsize, len(v.tobytes()))
+
+
+# define some structure classes
+
+class Point(Structure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class PackedPoint(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class PointMidPad(Structure):
+    _fields_ = [("x", c_byte), ("y", c_uint)]
+
+class PackedPointMidPad(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_byte), ("y", c_uint64)]
+
+class PointEndPad(Structure):
+    _fields_ = [("x", c_uint), ("y", c_byte)]
+
+class PackedPointEndPad(Structure):
+    _pack_ = 2
+    _fields_ = [("x", c_uint64), ("y", c_byte)]
+
+class Point2(Structure):
+    pass
+Point2._fields_ = [("x", c_long), ("y", c_long)]
+
+class EmptyStruct(Structure):
+    _fields_ = []
+
+class aUnion(Union):
+    _fields_ = [("a", c_int)]
+
+class StructWithArrays(Structure):
+    _fields_ = [("x", c_long * 3 * 2), ("y", Point * 4)]
+
+class Incomplete(Structure):
+    pass
+
+class Complete(Structure):
+    pass
+PComplete = POINTER(Complete)
+Complete._fields_ = [("a", c_long)]
+
+
+################################################################
+#
+# This table contains format strings as they look on little endian
+# machines.  The test replaces '<' with '>' on big endian machines.
+#
+
+# Platform-specific type codes
+s_bool = {1: '?', 2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_bool)]
+s_short = {2: 'h', 4: 'l', 8: 'q'}[sizeof(c_short)]
+s_ushort = {2: 'H', 4: 'L', 8: 'Q'}[sizeof(c_ushort)]
+s_int = {2: 'h', 4: 'i', 8: 'q'}[sizeof(c_int)]
+s_uint = {2: 'H', 4: 'I', 8: 'Q'}[sizeof(c_uint)]
+s_long = {4: 'l', 8: 'q'}[sizeof(c_long)]
+s_ulong = {4: 'L', 8: 'Q'}[sizeof(c_ulong)]
+s_longlong = "q"
+s_ulonglong = "Q"
+s_float = "f"
+s_double = "d"
+s_longdouble = "g"
+
+# Alias definitions in ctypes/__init__.py
+if c_int is c_long:
+    s_int = s_long
+if c_uint is c_ulong:
+    s_uint = s_ulong
+if c_longlong is c_long:
+    s_longlong = s_long
+if c_ulonglong is c_ulong:
+    s_ulonglong = s_ulong
+if c_longdouble is c_double:
+    s_longdouble = s_double
+
+
+native_types = [
+    # type                      format                  shape           calc itemsize
+
+    ## simple types
+
+    (c_char,                    "<c",                   (),           c_char),
+    (c_byte,                    "<b",                   (),           c_byte),
+    (c_ubyte,                   "<B",                   (),           c_ubyte),
+    (c_short,                   "<" + s_short,          (),           c_short),
+    (c_ushort,                  "<" + s_ushort,         (),           c_ushort),
+
+    (c_int,                     "<" + s_int,            (),           c_int),
+    (c_uint,                    "<" + s_uint,           (),           c_uint),
+
+    (c_long,                    "<" + s_long,           (),           c_long),
+    (c_ulong,                   "<" + s_ulong,          (),           c_ulong),
+
+    (c_longlong,                "<" + s_longlong,       (),           c_longlong),
+    (c_ulonglong,               "<" + s_ulonglong,      (),           c_ulonglong),
+
+    (c_float,                   "<f",                   (),           c_float),
+    (c_double,                  "<d",                   (),           c_double),
+
+    (c_longdouble,              "<" + s_longdouble,     (),           c_longdouble),
+
+    (c_bool,                    "<" + s_bool,           (),           c_bool),
+    (py_object,                 "<O",                   (),           py_object),
+
+    ## pointers
+
+    (POINTER(c_byte),           "&<b",                  (),           POINTER(c_byte)),
+    (POINTER(POINTER(c_long)),  "&&<" + s_long,         (),           POINTER(POINTER(c_long))),
+
+    ## arrays and pointers
+
+    (c_double * 4,              "<d",                   (4,),           c_double),
+    (c_double * 0,              "<d",                   (0,),           c_double),
+    (c_float * 4 * 3 * 2,       "<f",                   (2,3,4),        c_float),
+    (c_float * 4 * 0 * 2,       "<f",                   (2,0,4),        c_float),
+    (POINTER(c_short) * 2,      "&<" + s_short,         (2,),           POINTER(c_short)),
+    (POINTER(c_short) * 2 * 3,  "&<" + s_short,         (3,2,),         POINTER(c_short)),
+    (POINTER(c_short * 2),      "&(2)<" + s_short,      (),             POINTER(c_short)),
+
+    ## structures and unions
+
+    (Point2,                    "T{<l:x:<l:y:}".replace('l', s_long),   (),  Point2),
+    (Point,                     "T{<l:x:<l:y:}".replace('l', s_long),   (),  Point),
+    (PackedPoint,               "T{<l:x:<l:y:}".replace('l', s_long),   (),  PackedPoint),
+    (PointMidPad,               "T{<b:x:3x<I:y:}".replace('I', s_uint), (),  PointMidPad),
+    (PackedPointMidPad,         "T{<b:x:x<Q:y:}",                       (),  PackedPointMidPad),
+    (PointEndPad,               "T{<I:x:<b:y:3x}".replace('I', s_uint), (),  PointEndPad),
+    (PackedPointEndPad,         "T{<Q:x:<b:y:x}",                       (),  PackedPointEndPad),
+    (EmptyStruct,               "T{}",                                  (),  EmptyStruct),
+    # the pep doesn't support unions
+    (aUnion,                    "B",                                   (),  aUnion),
+    # structure with sub-arrays
+    (StructWithArrays, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (), StructWithArrays),
+    (StructWithArrays * 3, "T{(2,3)<l:x:(4)T{<l:x:<l:y:}:y:}".replace('l', s_long), (3,), StructWithArrays),
+
+    ## pointer to incomplete structure
+    (Incomplete,                "B",                    (),           Incomplete),
+    (POINTER(Incomplete),       "&B",                   (),           POINTER(Incomplete)),
+
+    # 'Complete' is a structure that starts incomplete, but is completed after the
+    # pointer type to it has been created.
+    (Complete,                  "T{<l:a:}".replace('l', s_long), (), Complete),
+    # Unfortunately the pointer format string is not fixed...
+    (POINTER(Complete),         "&B",                   (),           POINTER(Complete)),
+
+    ## other
+
+    # function signatures are not implemented
+    (CFUNCTYPE(None),           "X{}",                  (),           CFUNCTYPE(None)),
+
+    ]
+
+
+class BEPoint(BigEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+class LEPoint(LittleEndianStructure):
+    _fields_ = [("x", c_long), ("y", c_long)]
+
+
+# This table contains format strings as they really look, on both big
+# and little endian machines.
+endian_types = [
+    (BEPoint, "T{>l:x:>l:y:}".replace('l', s_long), (), BEPoint),
+    (LEPoint * 1, "T{<l:x:<l:y:}".replace('l', s_long), (1,), LEPoint),
+    (POINTER(BEPoint), "&T{>l:x:>l:y:}".replace('l', s_long), (), POINTER(BEPoint)),
+    (POINTER(LEPoint), "&T{<l:x:<l:y:}".replace('l', s_long), (), POINTER(LEPoint)),
+    ]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_pickling.py b/Lib/test/test_ctypes/test_pickling.py
similarity index 89%
rename from Lib/ctypes/test/test_pickling.py
rename to Lib/test/test_ctypes/test_pickling.py
index c4a79b9779..9d433fc69d 100644
--- a/Lib/ctypes/test/test_pickling.py
+++ b/Lib/test/test_ctypes/test_pickling.py
@@ -1,9 +1,15 @@
-import unittest
 import pickle
-from ctypes import *
-import _ctypes_test
+import unittest
+from ctypes import (CDLL, Structure, CFUNCTYPE, pointer,
+                    c_void_p, c_char_p, c_wchar_p,
+                    c_char, c_wchar, c_int, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
 dll = CDLL(_ctypes_test.__file__)
 
+
 class X(Structure):
     _fields_ = [("a", c_int), ("b", c_double)]
     init_called = 0
@@ -11,9 +17,11 @@ def __init__(self, *args, **kw):
         X.init_called += 1
         self.x = 42
 
+
 class Y(X):
     _fields_ = [("str", c_char_p)]
 
+
 class PickleTest:
     def dumps(self, item):
         return pickle.dumps(item, self.proto)
@@ -71,11 +79,13 @@ def test_wchar(self):
         # Issue 5049
         self.dumps(c_wchar("x"))
 
+
 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
     name = 'PickleTest_%s' % proto
     globals()[name] = type(name,
                            (PickleTest, unittest.TestCase),
                            {'proto': proto})
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_pointers.py b/Lib/test/test_ctypes/test_pointers.py
similarity index 76%
rename from Lib/ctypes/test/test_pointers.py
rename to Lib/test/test_ctypes/test_pointers.py
index e97515879f..ed4541335d 100644
--- a/Lib/ctypes/test/test_pointers.py
+++ b/Lib/test/test_ctypes/test_pointers.py
@@ -1,14 +1,43 @@
-import unittest, sys
+import array
+import ctypes
+import sys
+import unittest
+from ctypes import (CDLL, CFUNCTYPE, Structure,
+                    POINTER, pointer, _Pointer, _pointer_type_cache,
+                    byref, sizeof,
+                    c_void_p, c_char_p,
+                    c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong,
+                    c_float, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCPointerType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
 
-from ctypes import *
-import _ctypes_test
 
 ctype_types = [c_byte, c_ubyte, c_short, c_ushort, c_int, c_uint,
                  c_long, c_ulong, c_longlong, c_ulonglong, c_double, c_float]
 python_types = [int, int, int, int, int, int,
                 int, int, int, int, float, float]
 
+
 class PointersTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_Pointer.mro(), [_Pointer, _CData, object])
+
+        self.assertEqual(PyCPointerType.__name__, "PyCPointerType")
+        self.assertEqual(type(PyCPointerType), type)
+
+    def test_type_flags(self):
+        for cls in _Pointer, PyCPointerType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_Pointer.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_Pointer.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Cannot call the metaclass __init__ more than once
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCPointerType.__init__(POINTER(c_byte), 'ptr', (), {})
 
     def test_pointer_crash(self):
 
@@ -28,7 +57,6 @@ def test_pass_pointers(self):
             func.restype = c_long
 
         i = c_int(12345678)
-##        func.argtypes = (POINTER(c_int),)
         address = func(byref(i))
         self.assertEqual(c_int.from_address(address).value, 12345678)
 
@@ -71,9 +99,7 @@ def test_callbacks_with_pointers(self):
 
         def func(arg):
             for i in range(10):
-##                print arg[i],
                 self.result.append(arg[i])
-##            print
             return 0
         callback = PROTOTYPE(func)
 
@@ -83,38 +109,23 @@ def func(arg):
         # The int pointer points to a table containing the numbers 1..10
         doit = dll._testfunc_callback_with_pointer
 
-##        i = c_int(42)
-##        callback(byref(i))
-##        self.assertEqual(i.value, 84)
-
         doit(callback)
-##        print self.result
         doit(callback)
-##        print self.result
 
     def test_basics(self):
-        from operator import delitem
         for ct, pt in zip(ctype_types, python_types):
             i = ct(42)
             p = pointer(i)
-##            print type(p.contents), ct
             self.assertIs(type(p.contents), ct)
             # p.contents is the same as p[0]
-##            print p.contents
-##            self.assertEqual(p.contents, 42)
-##            self.assertEqual(p[0], 42)
 
-            self.assertRaises(TypeError, delitem, p, 0)
+            with self.assertRaises(TypeError):
+                del p[0]
 
     def test_from_address(self):
-        from array import array
-        a = array('i', [100, 200, 300, 400, 500])
+        a = array.array('i', [100, 200, 300, 400, 500])
         addr = a.buffer_info()[0]
-
         p = POINTER(POINTER(c_int))
-##        print dir(p)
-##        print p.from_address
-##        print p.from_address(addr)[0][0]
 
     def test_other(self):
         class Table(Structure):
@@ -130,7 +141,6 @@ class Table(Structure):
 
         pt.contents.c = 33
 
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[Table]
 
     def test_basic(self):
@@ -193,7 +203,7 @@ def test_pointers_bool(self):
 
         # COM methods are boolean True:
         if sys.platform == "win32":
-            mth = WINFUNCTYPE(None)(42, "name", (), None)
+            mth = ctypes.WINFUNCTYPE(None)(42, "name", (), None)
             self.assertEqual(bool(mth), True)
 
     def test_pointer_type_name(self):
@@ -201,7 +211,6 @@ def test_pointer_type_name(self):
         self.assertTrue(POINTER(LargeNamedType))
 
         # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[LargeNamedType]
 
     def test_pointer_type_str_name(self):
@@ -210,14 +219,22 @@ def test_pointer_type_str_name(self):
         self.assertTrue(P)
 
         # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[id(P)]
 
     def test_abstract(self):
-        from ctypes import _Pointer
-
         self.assertRaises(TypeError, _Pointer.set_type, 42)
 
+    def test_repeated_set_type(self):
+        # Regression test for gh-133290
+        class C(Structure):
+            _fields_ = [('a', c_int)]
+        ptr = POINTER(C)
+        # Read _type_ several times to warm up cache
+        for i in range(5):
+            self.assertIs(ptr._type_, C)
+        ptr.set_type(c_int)
+        self.assertIs(ptr._type_, c_int)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_prototypes.py b/Lib/test/test_ctypes/test_prototypes.py
similarity index 78%
rename from Lib/ctypes/test/test_prototypes.py
rename to Lib/test/test_ctypes/test_prototypes.py
index cd0c649de3..d976e8da0e 100644
--- a/Lib/ctypes/test/test_prototypes.py
+++ b/Lib/test/test_ctypes/test_prototypes.py
@@ -1,7 +1,3 @@
-from ctypes import *
-from ctypes.test import need_symbol
-import unittest
-
 # IMPORTANT INFO:
 #
 # Consider this call:
@@ -22,9 +18,18 @@
 #
 # In this case, there would have to be an additional reference to the argument...
 
-import _ctypes_test
+import unittest
+from ctypes import (CDLL, CFUNCTYPE, POINTER, ArgumentError,
+                    pointer, byref, sizeof, addressof, create_string_buffer,
+                    c_void_p, c_char_p, c_wchar_p, c_char, c_wchar,
+                    c_short, c_int, c_long, c_longlong, c_double)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
 testdll = CDLL(_ctypes_test.__file__)
 
+
 # Return machine address `a` as a (possibly long) non-negative integer.
 # Starting with Python 2.5, id(anything) is always non-negative, and
 # the ctypes addressof() inherits that via PyLong_FromVoidPtr().
@@ -38,12 +43,13 @@ def positive_address(a):
     assert a >= 0
     return a
 
+
 def c_wbuffer(init):
     n = len(init) + 1
     return (c_wchar * n)(*init)
 
-class CharPointersTestCase(unittest.TestCase):
 
+class CharPointersTestCase(unittest.TestCase):
     def setUp(self):
         func = testdll._testfunc_p_p
         func.restype = c_long
@@ -66,6 +72,32 @@ def test_paramflags(self):
         self.assertEqual(func(None), None)
         self.assertEqual(func(input=None), None)
 
+    def test_invalid_paramflags(self):
+        proto = CFUNCTYPE(c_int, c_char_p)
+        with self.assertRaises(ValueError):
+            func = proto(("myprintf", testdll), ((1, "fmt"), (1, "arg1")))
+
+    def test_invalid_setattr_argtypes(self):
+        proto = CFUNCTYPE(c_int, c_char_p)
+        func = proto(("myprintf", testdll), ((1, "fmt"),))
+
+        with self.assertRaisesRegex(TypeError, "_argtypes_ must be a sequence of types"):
+            func.argtypes = 123
+        self.assertEqual(func.argtypes, (c_char_p,))
+
+        with self.assertRaisesRegex(ValueError, "paramflags must have the same length as argtypes"):
+            func.argtypes = (c_char_p, c_int)
+        self.assertEqual(func.argtypes, (c_char_p,))
+
+    def test_paramflags_outarg(self):
+        proto = CFUNCTYPE(c_int, c_char_p, c_int)
+        with self.assertRaisesRegex(TypeError, "must be a pointer type"):
+            func = proto(("myprintf", testdll), ((1, "fmt"), (2, "out")))
+
+        proto = CFUNCTYPE(c_int, c_char_p, c_void_p)
+        func = proto(("myprintf", testdll), ((1, "fmt"), (2, "out")))
+        with self.assertRaisesRegex(TypeError, "must be a pointer type"):
+            func.argtypes = (c_char_p, c_int)
 
     def test_int_pointer_arg(self):
         func = testdll._testfunc_p_p
@@ -100,7 +132,7 @@ def test_POINTER_c_char_arg(self):
         self.assertEqual(None, func(c_char_p(None)))
         self.assertEqual(b"123", func(c_char_p(b"123")))
 
-        self.assertEqual(b"123", func(c_buffer(b"123")))
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
         ca = c_char(b"a")
         self.assertEqual(ord(b"a"), func(pointer(ca))[0])
         self.assertEqual(ord(b"a"), func(byref(ca))[0])
@@ -115,7 +147,7 @@ def test_c_char_p_arg(self):
         self.assertEqual(None, func(c_char_p(None)))
         self.assertEqual(b"123", func(c_char_p(b"123")))
 
-        self.assertEqual(b"123", func(c_buffer(b"123")))
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
         ca = c_char(b"a")
         self.assertEqual(ord(b"a"), func(pointer(ca))[0])
         self.assertEqual(ord(b"a"), func(byref(ca))[0])
@@ -130,7 +162,7 @@ def test_c_void_p_arg(self):
         self.assertEqual(b"123", func(c_char_p(b"123")))
         self.assertEqual(None, func(c_char_p(None)))
 
-        self.assertEqual(b"123", func(c_buffer(b"123")))
+        self.assertEqual(b"123", func(create_string_buffer(b"123")))
         ca = c_char(b"a")
         self.assertEqual(ord(b"a"), func(pointer(ca))[0])
         self.assertEqual(ord(b"a"), func(byref(ca))[0])
@@ -139,7 +171,6 @@ def test_c_void_p_arg(self):
         func(pointer(c_int()))
         func((c_int * 3)())
 
-    @need_symbol('c_wchar_p')
     def test_c_void_p_arg_with_c_wchar_p(self):
         func = testdll._testfunc_p_p
         func.restype = c_wchar_p
@@ -161,9 +192,8 @@ class X:
         func.argtypes = None
         self.assertEqual(None, func(X()))
 
-@need_symbol('c_wchar')
-class WCharPointersTestCase(unittest.TestCase):
 
+class WCharPointersTestCase(unittest.TestCase):
     def setUp(self):
         func = testdll._testfunc_p_p
         func.restype = c_int
@@ -203,6 +233,7 @@ def test_c_wchar_p_arg(self):
         self.assertEqual("a", func(pointer(ca))[0])
         self.assertEqual("a", func(byref(ca))[0])
 
+
 class ArrayTest(unittest.TestCase):
     def test(self):
         func = testdll._testfunc_ai8
@@ -216,7 +247,6 @@ def test(self):
         def func(): pass
         CFUNCTYPE(None, c_int * 3)(func)
 
-################################################################
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_python_api.py b/Lib/test/test_ctypes/test_python_api.py
new file mode 100644
index 0000000000..2e68b35f8a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_python_api.py
@@ -0,0 +1,85 @@
+import _ctypes
+import sys
+import unittest
+from test import support
+from ctypes import (pythonapi, POINTER, create_string_buffer, sizeof,
+                    py_object, c_char_p, c_char, c_long, c_size_t)
+
+
+class PythonAPITestCase(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_PyBytes_FromStringAndSize(self):
+        PyBytes_FromStringAndSize = pythonapi.PyBytes_FromStringAndSize
+
+        PyBytes_FromStringAndSize.restype = py_object
+        PyBytes_FromStringAndSize.argtypes = c_char_p, c_size_t
+
+        self.assertEqual(PyBytes_FromStringAndSize(b"abcdefghi", 3), b"abc")
+
+    @support.refcount_test
+    def test_PyString_FromString(self):
+        pythonapi.PyBytes_FromString.restype = py_object
+        pythonapi.PyBytes_FromString.argtypes = (c_char_p,)
+
+        s = b"abc"
+        refcnt = sys.getrefcount(s)
+        pyob = pythonapi.PyBytes_FromString(s)
+        self.assertEqual(sys.getrefcount(s), refcnt)
+        self.assertEqual(s, pyob)
+        del pyob
+        self.assertEqual(sys.getrefcount(s), refcnt)
+
+    @support.refcount_test
+    def test_PyLong_Long(self):
+        ref42 = sys.getrefcount(42)
+        pythonapi.PyLong_FromLong.restype = py_object
+        self.assertEqual(pythonapi.PyLong_FromLong(42), 42)
+
+        self.assertEqual(sys.getrefcount(42), ref42)
+
+        pythonapi.PyLong_AsLong.argtypes = (py_object,)
+        pythonapi.PyLong_AsLong.restype = c_long
+
+        res = pythonapi.PyLong_AsLong(42)
+        # Small int refcnts don't change
+        self.assertEqual(sys.getrefcount(res), ref42)
+        del res
+        self.assertEqual(sys.getrefcount(42), ref42)
+
+    @support.refcount_test
+    def test_PyObj_FromPtr(self):
+        s = object()
+        ref = sys.getrefcount(s)
+        # id(python-object) is the address
+        pyobj = _ctypes.PyObj_FromPtr(id(s))
+        self.assertIs(s, pyobj)
+
+        self.assertEqual(sys.getrefcount(s), ref + 1)
+        del pyobj
+        self.assertEqual(sys.getrefcount(s), ref)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_PyOS_snprintf(self):
+        PyOS_snprintf = pythonapi.PyOS_snprintf
+        PyOS_snprintf.argtypes = POINTER(c_char), c_size_t, c_char_p
+
+        buf = create_string_buffer(256)
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s", b"ctypes")
+        self.assertEqual(buf.value, b"Hello from ctypes")
+
+        PyOS_snprintf(buf, sizeof(buf), b"Hello from %s (%d, %d, %d)", b"ctypes", 1, 2, 3)
+        self.assertEqual(buf.value, b"Hello from ctypes (1, 2, 3)")
+
+        # not enough arguments
+        self.assertRaises(TypeError, PyOS_snprintf, buf)
+
+    def test_pyobject_repr(self):
+        self.assertEqual(repr(py_object()), "py_object(<NULL>)")
+        self.assertEqual(repr(py_object(42)), "py_object(42)")
+        self.assertEqual(repr(py_object(object)), "py_object(%r)" % object)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_random_things.py b/Lib/test/test_ctypes/test_random_things.py
new file mode 100644
index 0000000000..3908eca092
--- /dev/null
+++ b/Lib/test/test_ctypes/test_random_things.py
@@ -0,0 +1,83 @@
+import _ctypes
+import contextlib
+import ctypes
+import sys
+import unittest
+from test import support
+from ctypes import CFUNCTYPE, c_void_p, c_char_p, c_int, c_double
+
+
+def callback_func(arg):
+    42 / arg
+    raise ValueError(arg)
+
+
+@unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
+class call_function_TestCase(unittest.TestCase):
+    # _ctypes.call_function is deprecated and private, but used by
+    # Gary Bishp's readline module.  If we have it, we must test it as well.
+
+    def test(self):
+        kernel32 = ctypes.windll.kernel32
+        kernel32.LoadLibraryA.restype = c_void_p
+        kernel32.GetProcAddress.argtypes = c_void_p, c_char_p
+        kernel32.GetProcAddress.restype = c_void_p
+
+        hdll = kernel32.LoadLibraryA(b"kernel32")
+        funcaddr = kernel32.GetProcAddress(hdll, b"GetModuleHandleA")
+
+        self.assertEqual(_ctypes.call_function(funcaddr, (None,)),
+                         kernel32.GetModuleHandleA(None))
+
+
+class CallbackTracbackTestCase(unittest.TestCase):
+    # When an exception is raised in a ctypes callback function, the C
+    # code prints a traceback.
+    #
+    # This test makes sure the exception types *and* the exception
+    # value is printed correctly.
+    #
+    # Changed in 0.9.3: No longer is '(in callback)' prepended to the
+    # error message - instead an additional frame for the C code is
+    # created, then a full traceback printed.  When SystemExit is
+    # raised in a callback function, the interpreter exits.
+
+    @contextlib.contextmanager
+    def expect_unraisable(self, exc_type, exc_msg=None):
+        with support.catch_unraisable_exception() as cm:
+            yield
+
+            self.assertIsInstance(cm.unraisable.exc_value, exc_type)
+            if exc_msg is not None:
+                self.assertEqual(str(cm.unraisable.exc_value), exc_msg)
+            self.assertEqual(cm.unraisable.err_msg,
+                             f"Exception ignored on calling ctypes "
+                             f"callback function {callback_func!r}")
+            self.assertIsNone(cm.unraisable.object)
+
+    def test_ValueError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ValueError, '42'):
+            cb(42)
+
+    def test_IntegerDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_int)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0)
+
+    def test_FloatDivisionError(self):
+        cb = CFUNCTYPE(c_int, c_double)(callback_func)
+        with self.expect_unraisable(ZeroDivisionError):
+            cb(0.0)
+
+    # 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'"
+        with self.expect_unraisable(TypeError, err_msg):
+            cb(b"spam")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_refcounts.py b/Lib/test/test_ctypes/test_refcounts.py
new file mode 100644
index 0000000000..9e87cfc661
--- /dev/null
+++ b/Lib/test/test_ctypes/test_refcounts.py
@@ -0,0 +1,143 @@
+import ctypes
+import gc
+import sys
+import unittest
+from test import support
+from test.support import import_helper
+from test.support import script_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+MyCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
+OtherCallback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_ulonglong)
+
+dll = ctypes.CDLL(_ctypes_test.__file__)
+
+
+class RefcountTestCase(unittest.TestCase):
+    @support.refcount_test
+    def test_1(self):
+        f = dll._testfunc_callback_i_if
+        f.restype = ctypes.c_int
+        f.argtypes = [ctypes.c_int, MyCallback]
+
+        def callback(value):
+            return value
+
+        self.assertEqual(sys.getrefcount(callback), 2)
+        cb = MyCallback(callback)
+
+        self.assertGreater(sys.getrefcount(callback), 2)
+        result = f(-10, cb)
+        self.assertEqual(result, -18)
+        cb = None
+
+        gc.collect()
+
+        self.assertEqual(sys.getrefcount(callback), 2)
+
+    @support.refcount_test
+    def test_refcount(self):
+        def func(*args):
+            pass
+        # this is the standard refcount for func
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        f = OtherCallback(func)
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # and may release it again
+        del f
+        self.assertGreaterEqual(sys.getrefcount(func), 2)
+
+        # but now it must be gone
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        class X(ctypes.Structure):
+            _fields_ = [("a", OtherCallback)]
+        x = X()
+        x.a = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # and may release it again
+        del x
+        self.assertGreaterEqual(sys.getrefcount(func), 2)
+
+        # and now it must be gone again
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+        f = OtherCallback(func)
+
+        # the CFuncPtr instance holds at least one refcount on func:
+        self.assertGreater(sys.getrefcount(func), 2)
+
+        # create a cycle
+        f.cycle = f
+
+        del f
+        gc.collect()
+        self.assertEqual(sys.getrefcount(func), 2)
+
+
+class AnotherLeak(unittest.TestCase):
+    def test_callback(self):
+        proto = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int)
+        def func(a, b):
+            return a * b * 2
+        f = proto(func)
+
+        a = sys.getrefcount(ctypes.c_int)
+        f(1, 2)
+        self.assertEqual(sys.getrefcount(ctypes.c_int), a)
+
+    @support.refcount_test
+    def test_callback_py_object_none_return(self):
+        # bpo-36880: test that returning None from a py_object callback
+        # does not decrement the refcount of None.
+
+        for FUNCTYPE in (ctypes.CFUNCTYPE, ctypes.PYFUNCTYPE):
+            with self.subTest(FUNCTYPE=FUNCTYPE):
+                @FUNCTYPE(ctypes.py_object)
+                def func():
+                    return None
+
+                # Check that calling func does not affect None's refcount.
+                for _ in range(10000):
+                    func()
+
+
+class ModuleIsolationTest(unittest.TestCase):
+    def test_finalize(self):
+        # check if gc_decref() succeeds
+        script = (
+            "import ctypes;"
+            "import sys;"
+            "del sys.modules['_ctypes'];"
+            "import _ctypes;"
+            "exit()"
+        )
+        script_helper.assert_python_ok("-c", script)
+
+
+class PyObjectRestypeTest(unittest.TestCase):
+    def test_restype_py_object_with_null_return(self):
+        # Test that a function which returns a NULL PyObject *
+        # without setting an exception does not crash.
+        PyErr_Occurred = ctypes.pythonapi.PyErr_Occurred
+        PyErr_Occurred.argtypes = []
+        PyErr_Occurred.restype = ctypes.py_object
+
+        # At this point, there's no exception set, so PyErr_Occurred
+        # returns NULL. Given the restype is py_object, the
+        # ctypes machinery will raise a custom error.
+        with self.assertRaisesRegex(ValueError, "PyObject is NULL"):
+            PyErr_Occurred()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/ctypes/test/test_repr.py b/Lib/test/test_ctypes/test_repr.py
similarity index 80%
rename from Lib/ctypes/test/test_repr.py
rename to Lib/test/test_ctypes/test_repr.py
index 60a2c80345..e7587984a9 100644
--- a/Lib/ctypes/test/test_repr.py
+++ b/Lib/test/test_ctypes/test_repr.py
@@ -1,5 +1,8 @@
-from ctypes import *
 import unittest
+from ctypes import (c_byte, c_short, c_int, c_long, c_longlong,
+                    c_ubyte, c_ushort, c_uint, c_ulong, c_ulonglong,
+                    c_float, c_double, c_longdouble, c_bool, c_char)
+
 
 subclasses = []
 for base in [c_byte, c_short, c_int, c_long, c_longlong,
@@ -9,11 +12,12 @@ class X(base):
         pass
     subclasses.append(X)
 
+
 class X(c_char):
     pass
 
-# This test checks if the __repr__ is correct for subclasses of simple types
 
+# This test checks if the __repr__ is correct for subclasses of simple types
 class ReprTest(unittest.TestCase):
     def test_numbers(self):
         for typ in subclasses:
@@ -25,5 +29,6 @@ def test_char(self):
         self.assertEqual("c_char(b'x')", repr(c_char(b'x')))
         self.assertEqual("<X object at", repr(X(b'x'))[:12])
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_returnfuncptrs.py b/Lib/test/test_ctypes/test_returnfuncptrs.py
similarity index 94%
rename from Lib/ctypes/test/test_returnfuncptrs.py
rename to Lib/test/test_ctypes/test_returnfuncptrs.py
index 1974f40df6..337801b226 100644
--- a/Lib/ctypes/test/test_returnfuncptrs.py
+++ b/Lib/test/test_ctypes/test_returnfuncptrs.py
@@ -1,10 +1,10 @@
 import unittest
-from ctypes import *
+from ctypes import CDLL, CFUNCTYPE, ArgumentError, c_char_p, c_void_p, c_char
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-import _ctypes_test
 
 class ReturnFuncPtrTestCase(unittest.TestCase):
-
     def test_with_prototype(self):
         # The _ctypes_test shared lib/dll exports quite some functions for testing.
         # The get_strchr function returns a *pointer* to the C strchr function.
@@ -62,5 +62,6 @@ def __getitem__(self, key):
         self.assertRaises(ArgumentError, strchr, b"abcdef", 3.0)
         self.assertRaises(TypeError, strchr, b"abcdef")
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_simplesubclasses.py b/Lib/test/test_ctypes/test_simplesubclasses.py
new file mode 100644
index 0000000000..4e4bef3690
--- /dev/null
+++ b/Lib/test/test_ctypes/test_simplesubclasses.py
@@ -0,0 +1,96 @@
+import unittest
+from ctypes import Structure, CFUNCTYPE, c_int, _SimpleCData
+from ._support import (_CData, PyCSimpleType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class MyInt(c_int):
+    def __eq__(self, other):
+        if type(other) != MyInt:
+            return NotImplementedError
+        return self.value == other.value
+
+
+class Test(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(_SimpleCData.mro(), [_SimpleCData, _CData, object])
+
+        self.assertEqual(PyCSimpleType.__name__, "PyCSimpleType")
+        self.assertEqual(type(PyCSimpleType), type)
+
+        self.assertEqual(c_int.mro(), [c_int, _SimpleCData, _CData, object])
+
+    def test_type_flags(self):
+        for cls in _SimpleCData, PyCSimpleType:
+            with self.subTest(cls=cls):
+                self.assertTrue(_SimpleCData.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(_SimpleCData.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewT = PyCSimpleType.__new__(PyCSimpleType, 'NewT', (_SimpleCData,), {})
+        for cls in _SimpleCData, NewT:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(_SimpleCData):
+            _type_ = "i"
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            PyCSimpleType.__init__(T, 'ptr', (), {})
+
+    def test_swapped_type_creation(self):
+        cls = PyCSimpleType.__new__(PyCSimpleType, '', (), {'_type_': 'i'})
+        with self.assertRaises(TypeError):
+            PyCSimpleType.__init__(cls)
+        PyCSimpleType.__init__(cls, '', (), {'_type_': 'i'})
+        self.assertEqual(cls.__ctype_le__.__dict__.get('_type_'), 'i')
+        self.assertEqual(cls.__ctype_be__.__dict__.get('_type_'), 'i')
+
+    def test_compare(self):
+        self.assertEqual(MyInt(3), MyInt(3))
+        self.assertNotEqual(MyInt(42), MyInt(43))
+
+    def test_ignore_retval(self):
+        # Test if the return value of a callback is ignored
+        # if restype is None
+        proto = CFUNCTYPE(None)
+        def func():
+            return (1, "abc", None)
+
+        cb = proto(func)
+        self.assertEqual(None, cb())
+
+
+    def test_int_callback(self):
+        args = []
+        def func(arg):
+            args.append(arg)
+            return arg
+
+        cb = CFUNCTYPE(None, MyInt)(func)
+
+        self.assertEqual(None, cb(42))
+        self.assertEqual(type(args[-1]), MyInt)
+
+        cb = CFUNCTYPE(c_int, c_int)(func)
+
+        self.assertEqual(42, cb(42))
+        self.assertEqual(type(args[-1]), int)
+
+    def test_int_struct(self):
+        class X(Structure):
+            _fields_ = [("x", MyInt)]
+
+        self.assertEqual(X().x, MyInt())
+
+        s = X()
+        s.x = MyInt(42)
+
+        self.assertEqual(s.x, MyInt(42))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_sizes.py b/Lib/test/test_ctypes/test_sizes.py
new file mode 100644
index 0000000000..e981ccfad5
--- /dev/null
+++ b/Lib/test/test_ctypes/test_sizes.py
@@ -0,0 +1,38 @@
+# Test specifically-sized containers.
+
+from ctypes import (sizeof,
+                    c_int8, c_uint8, c_int16, c_uint16,
+                    c_int32, c_uint32, c_int64, c_uint64,
+                    c_void_p, c_size_t, c_ssize_t, c_time_t, SIZEOF_TIME_T)
+import unittest
+
+
+class SizesTestCase(unittest.TestCase):
+    def test_8(self):
+        self.assertEqual(1, sizeof(c_int8))
+        self.assertEqual(1, sizeof(c_uint8))
+
+    def test_16(self):
+        self.assertEqual(2, sizeof(c_int16))
+        self.assertEqual(2, sizeof(c_uint16))
+
+    def test_32(self):
+        self.assertEqual(4, sizeof(c_int32))
+        self.assertEqual(4, sizeof(c_uint32))
+
+    def test_64(self):
+        self.assertEqual(8, sizeof(c_int64))
+        self.assertEqual(8, sizeof(c_uint64))
+
+    def test_size_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_size_t))
+
+    def test_ssize_t(self):
+        self.assertEqual(sizeof(c_void_p), sizeof(c_ssize_t))
+
+    def test_time_t(self):
+        self.assertEqual(sizeof(c_time_t), SIZEOF_TIME_T)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_slicing.py b/Lib/test/test_ctypes/test_slicing.py
similarity index 78%
rename from Lib/ctypes/test/test_slicing.py
rename to Lib/test/test_ctypes/test_slicing.py
index a3932f1767..66f9e53010 100644
--- a/Lib/ctypes/test/test_slicing.py
+++ b/Lib/test/test_ctypes/test_slicing.py
@@ -1,8 +1,9 @@
 import unittest
-from ctypes import *
-from ctypes.test import need_symbol
+from ctypes import (CDLL, POINTER, sizeof,
+                    c_byte, c_short, c_int, c_long, c_char, c_wchar, c_char_p)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
 
-import _ctypes_test
 
 class SlicesTestCase(unittest.TestCase):
     def test_getslice_cint(self):
@@ -46,18 +47,21 @@ def test_setslice_cint(self):
         b[33::-3] = range(12)
         self.assertEqual(a[:], b)
 
-        from operator import setitem
-
         # TypeError: int expected instead of str instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5), "abcde")
+        with self.assertRaises(TypeError):
+            a[:5] = "abcde"
+
         # TypeError: int expected instead of str instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5),
-                          ["a", "b", "c", "d", "e"])
+        with self.assertRaises(TypeError):
+            a[:5] =  ["a", "b", "c", "d", "e"]
+
         # TypeError: int expected instead of float instance
-        self.assertRaises(TypeError, setitem, a, slice(0, 5),
-                          [1, 2, 3, 4, 3.14])
+        with self.assertRaises(TypeError):
+            a[:5] = [1, 2, 3, 4, 3.14]
+
         # ValueError: Can only assign sequence of same size
-        self.assertRaises(ValueError, setitem, a, slice(0, 5), range(32))
+        with self.assertRaises(ValueError):
+            a[:5] = range(32)
 
     def test_char_ptr(self):
         s = b"abcdefghijklmnopqrstuvwxyz"
@@ -73,18 +77,20 @@ def test_char_ptr(self):
         self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
         self.assertEqual(res[0:-1:-1], s[0::-1])
 
-        import operator
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(None, None, None))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(0, None, None))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(None, 5, -1))
-        self.assertRaises(ValueError, operator.getitem,
-                          res, slice(-5, None, None))
-
-        self.assertRaises(TypeError, operator.setitem,
-                          res, slice(0, 5), "abcde")
+        # get items
+        with self.assertRaises(ValueError):
+            res[:]
+        with self.assertRaises(ValueError):
+            res[0:]
+        with self.assertRaises(ValueError):
+            res[:5:-1]
+        with self.assertRaises(ValueError):
+            res[-5:]
+
+        # set items
+        with self.assertRaises(TypeError):
+            res[:5] = "abcde"
+
         dll.my_free(res)
 
         dll.my_strdup.restype = POINTER(c_byte)
@@ -126,7 +132,6 @@ def test_char_array(self):
         self.assertEqual(p[2:5:-3], s[2:5:-3])
 
 
-    @need_symbol('c_wchar')
     def test_wchar_ptr(self):
         s = "abcdefghijklmnopqrstuvwxyz\0"
 
@@ -140,9 +145,8 @@ def test_wchar_ptr(self):
         self.assertEqual(res[len(s)-1:-1:-1], s[::-1])
         self.assertEqual(res[len(s)-1:5:-7], s[:5:-7])
 
-        import operator
-        self.assertRaises(TypeError, operator.setitem,
-                          res, slice(0, 5), "abcde")
+        with self.assertRaises(TypeError):
+            res[:5] = "abcde"
         dll.my_free(res)
 
         if sizeof(c_wchar) == sizeof(c_short):
@@ -161,7 +165,6 @@ def test_wchar_ptr(self):
         self.assertEqual(res[len(s)-2:5:-7], tmpl[:5:-7])
         dll.my_free(res)
 
-################################################################
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_stringptr.py b/Lib/test/test_ctypes/test_stringptr.py
new file mode 100644
index 0000000000..bb6045b250
--- /dev/null
+++ b/Lib/test/test_ctypes/test_stringptr.py
@@ -0,0 +1,81 @@
+import sys
+import unittest
+from test import support
+from ctypes import (CDLL, Structure, POINTER, create_string_buffer,
+                    c_char, c_char_p)
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+lib = CDLL(_ctypes_test.__file__)
+
+
+class StringPtrTestCase(unittest.TestCase):
+    @support.refcount_test
+    def test__POINTER_c_char(self):
+        class X(Structure):
+            _fields_ = [("str", POINTER(c_char))]
+        x = X()
+
+        # NULL pointer access
+        self.assertRaises(ValueError, getattr, x.str, "contents")
+        b = create_string_buffer(b"Hello, World")
+        self.assertEqual(sys.getrefcount(b), 2)
+        x.str = b
+        self.assertEqual(sys.getrefcount(b), 3)
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and create_string_buffer() is compatible
+        for i in range(len(b)):
+            self.assertEqual(b[i], x.str[i])
+
+        self.assertRaises(TypeError, setattr, x, "str", "Hello, World")
+
+    def test__c_char_p(self):
+        class X(Structure):
+            _fields_ = [("str", c_char_p)]
+        x = X()
+
+        # c_char_p and Python string is compatible
+        # c_char_p and create_string_buffer is NOT compatible
+        self.assertEqual(x.str, None)
+        x.str = b"Hello, World"
+        self.assertEqual(x.str, b"Hello, World")
+        b = create_string_buffer(b"Hello, World")
+        self.assertRaises(TypeError, setattr, x, b"str", b)
+
+
+    def test_functions(self):
+        strchr = lib.my_strchr
+        strchr.restype = c_char_p
+
+        # c_char_p and Python string is compatible
+        # c_char_p and create_string_buffer are now compatible
+        strchr.argtypes = c_char_p, c_char
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+        self.assertEqual(strchr(create_string_buffer(b"abcdef"), b"c"),
+                         b"cdef")
+
+        # POINTER(c_char) and Python string is NOT compatible
+        # POINTER(c_char) and create_string_buffer() is compatible
+        strchr.argtypes = POINTER(c_char), c_char
+        buf = create_string_buffer(b"abcdef")
+        self.assertEqual(strchr(buf, b"c"), b"cdef")
+        self.assertEqual(strchr(b"abcdef", b"c"), b"cdef")
+
+        # XXX These calls are dangerous, because the first argument
+        # to strchr is no longer valid after the function returns!
+        # So we must keep a reference to buf separately
+
+        strchr.restype = POINTER(c_char)
+        buf = create_string_buffer(b"abcdef")
+        r = strchr(buf, b"c")
+        x = r[0], r[1], r[2], r[3], r[4]
+        self.assertEqual(x, (b"c", b"d", b"e", b"f", b"\000"))
+        del buf
+        # Because r is a pointer to memory that is freed after deleting buf,
+        # the pointer is hanging and using it would reference freed memory.
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_strings.py b/Lib/test/test_ctypes/test_strings.py
new file mode 100644
index 0000000000..3ecc6fe180
--- /dev/null
+++ b/Lib/test/test_ctypes/test_strings.py
@@ -0,0 +1,134 @@
+import unittest
+from ctypes import (create_string_buffer, create_unicode_buffer,
+                    sizeof, byref, c_char, c_wchar)
+
+
+class StringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_char * 4
+
+        buf = BUF(b"a", b"b", b"c")
+        self.assertEqual(buf.value, b"abc")
+        self.assertEqual(buf.raw, b"abc\000")
+
+        buf.value = b"ABCD"
+        self.assertEqual(buf.value, b"ABCD")
+        self.assertEqual(buf.raw, b"ABCD")
+
+        buf.value = b"x"
+        self.assertEqual(buf.value, b"x")
+        self.assertEqual(buf.raw, b"x\000CD")
+
+        buf[1] = b"Z"
+        self.assertEqual(buf.value, b"xZCD")
+        self.assertEqual(buf.raw, b"xZCD")
+
+        self.assertRaises(ValueError, setattr, buf, "value", b"aaaaaaaa")
+        self.assertRaises(TypeError, setattr, buf, "value", 42)
+
+    def test_create_string_buffer_value(self):
+        buf = create_string_buffer(32)
+
+        buf.value = b"Hello, World"
+        self.assertEqual(buf.value, b"Hello, World")
+
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"Hello, World"))
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_create_string_buffer_raw(self):
+        buf = create_string_buffer(32)
+
+        buf.raw = memoryview(b"Hello, World")
+        self.assertEqual(buf.value, b"Hello, World")
+        self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc"))
+        self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
+
+    def test_param_1(self):
+        BUF = c_char * 4
+        buf = BUF()
+
+    def test_param_2(self):
+        BUF = c_char * 4
+        buf = BUF()
+
+    def test_del_segfault(self):
+        BUF = c_char * 4
+        buf = BUF()
+        with self.assertRaises(AttributeError):
+            del buf.raw
+
+
+class WStringArrayTestCase(unittest.TestCase):
+    def test(self):
+        BUF = c_wchar * 4
+
+        buf = BUF("a", "b", "c")
+        self.assertEqual(buf.value, "abc")
+
+        buf.value = "ABCD"
+        self.assertEqual(buf.value, "ABCD")
+
+        buf.value = "x"
+        self.assertEqual(buf.value, "x")
+
+        buf[1] = "Z"
+        self.assertEqual(buf.value, "xZCD")
+
+    @unittest.skipIf(sizeof(c_wchar) < 4,
+                     "sizeof(wchar_t) is smaller than 4 bytes")
+    def test_nonbmp(self):
+        u = chr(0x10ffff)
+        w = c_wchar(u)
+        self.assertEqual(w.value, u)
+
+
+class WStringTestCase(unittest.TestCase):
+    def test_wchar(self):
+        c_wchar("x")
+        repr(byref(c_wchar("x")))
+        c_wchar("x")
+
+    def test_basic_wstrings(self):
+        cs = create_unicode_buffer("abcdef")
+        self.assertEqual(cs.value, "abcdef")
+
+        # value can be changed
+        cs.value = "abc"
+        self.assertEqual(cs.value, "abc")
+
+        # string is truncated at NUL character
+        cs.value = "def\0z"
+        self.assertEqual(cs.value, "def")
+
+        self.assertEqual(create_unicode_buffer("abc\0def").value, "abc")
+
+        # created with an empty string
+        cs = create_unicode_buffer(3)
+        self.assertEqual(cs.value, "")
+
+        cs.value = "abc"
+        self.assertEqual(cs.value, "abc")
+
+    def test_toolong(self):
+        cs = create_unicode_buffer("abc")
+        with self.assertRaises(ValueError):
+            cs.value = "abcdef"
+
+        cs = create_unicode_buffer(4)
+        with self.assertRaises(ValueError):
+            cs.value = "abcdef"
+
+
+def run_test(rep, msg, func, arg):
+    items = range(rep)
+    from time import perf_counter as clock
+    start = clock()
+    for i in items:
+        func(arg); func(arg); func(arg); func(arg); func(arg)
+    stop = clock()
+    print("%20s: %.2f us" % (msg, ((stop-start)*1e6/5/rep)))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_struct_fields.py b/Lib/test/test_ctypes/test_struct_fields.py
new file mode 100644
index 0000000000..fd9509757a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_struct_fields.py
@@ -0,0 +1,126 @@
+import unittest
+import sys
+from ctypes import Structure, Union, sizeof, c_char, c_int
+from ._support import (CField, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class StructFieldsTestCase(unittest.TestCase):
+    # Structure/Union classes must get 'finalized' sooner or
+    # later, when one of these things happen:
+    #
+    # 1. _fields_ is set.
+    # 2. An instance is created.
+    # 3. The type is used as field of another Structure/Union.
+    # 4. The type is subclassed
+    #
+    # When they are finalized, assigning _fields_ is no longer allowed.
+    def test_1_A(self):
+        class X(Structure):
+            pass
+        self.assertEqual(sizeof(X), 0) # not finalized
+        X._fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_1_B(self):
+        class X(Structure):
+            _fields_ = [] # finalized
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_2(self):
+        class X(Structure):
+            pass
+        X()
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_3(self):
+        class X(Structure):
+            pass
+        class Y(Structure):
+            _fields_ = [("x", X)] # finalizes X
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_4(self):
+        class X(Structure):
+            pass
+        class Y(X):
+            pass
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+        Y._fields_ = []
+        self.assertRaises(AttributeError, setattr, X, "_fields_", [])
+
+    def test_5(self):
+        class X(Structure):
+            _fields_ = (("char", c_char * 5),)
+
+        x = X(b'#' * 5)
+        x.char = b'a\0b\0'
+        self.assertEqual(bytes(x), b'a\x00###')
+
+    def test_6(self):
+        self.assertRaises(TypeError, CField)
+
+    def test_cfield_type_flags(self):
+        self.assertTrue(CField.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+        self.assertTrue(CField.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+
+    def test_cfield_inheritance_hierarchy(self):
+        self.assertEqual(CField.mro(), [CField, object])
+
+    def test_gh99275(self):
+        class BrokenStructure(Structure):
+            def __init_subclass__(cls, **kwargs):
+                cls._fields_ = []  # This line will fail, `stginfo` is not ready
+
+        with self.assertRaisesRegex(TypeError,
+                                    'ctypes state is not initialized'):
+            class Subclass(BrokenStructure): ...
+
+    def test_max_field_size_gh126937(self):
+        # Classes for big structs should be created successfully.
+        # (But they most likely can't be instantiated.)
+        # The size must fit in Py_ssize_t.
+
+        class X(Structure):
+            _fields_ = [('char', c_char),]
+        max_field_size = sys.maxsize
+
+        class Y(Structure):
+            _fields_ = [('largeField', X * max_field_size)]
+        class Z(Structure):
+            _fields_ = [('largeField', c_char * max_field_size)]
+
+        with self.assertRaises(OverflowError):
+            class TooBig(Structure):
+                _fields_ = [('largeField', X * (max_field_size + 1))]
+        with self.assertRaises(OverflowError):
+            class TooBig(Structure):
+                _fields_ = [('largeField', c_char * (max_field_size + 1))]
+
+    # __set__ and __get__ should raise a TypeError in case their self
+    # argument is not a ctype instance.
+    def test___set__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__set__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__set__, 'wrong type self', 42)
+
+    def test___get__(self):
+        class MyCStruct(Structure):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCStruct.field.__get__, 'wrong type self', 42)
+
+        class MyCUnion(Union):
+            _fields_ = (("field", c_int),)
+        self.assertRaises(TypeError,
+                          MyCUnion.field.__get__, 'wrong type self', 42)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/ctypes/test/test_structures.py b/Lib/test/test_ctypes/test_structures.py
similarity index 78%
rename from Lib/ctypes/test/test_structures.py
rename to Lib/test/test_ctypes/test_structures.py
index f95d5a99a3..7650c80273 100644
--- a/Lib/ctypes/test/test_structures.py
+++ b/Lib/test/test_ctypes/test_structures.py
@@ -1,16 +1,21 @@
-import platform
+from platform import architecture as _architecture
+import struct
 import sys
 import unittest
-from ctypes import *
-from ctypes.test import need_symbol
+from ctypes import (CDLL, Array, Structure, Union, POINTER, sizeof, byref, alignment,
+                    c_void_p, c_char, c_wchar, c_byte, c_ubyte,
+                    c_uint8, c_uint16, c_uint32,
+                    c_short, c_ushort, c_int, c_uint,
+                    c_long, c_ulong, c_longlong, c_ulonglong, c_float, c_double)
+from ctypes.util import find_library
 from struct import calcsize
-import _ctypes_test
+from collections import namedtuple
 from test import support
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+from ._support import (_CData, PyCStructType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
 
-# The following definition is meant to be used from time to time to assist
-# temporarily disabling tests on specific architectures while investigations
-# are in progress, to keep buildbots happy.
-MACHINE = platform.machine()
 
 class SubclassesTest(unittest.TestCase):
     def test_subclass(self):
@@ -51,6 +56,7 @@ class Z(X):
         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,
@@ -67,6 +73,36 @@ class StructureTestCase(unittest.TestCase):
                "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):
@@ -184,7 +220,6 @@ class X(Structure):
         self.assertEqual(sizeof(X), 10)
         self.assertEqual(X.b.offset, 2)
 
-        import struct
         longlong_size = struct.calcsize("q")
         longlong_align = struct.calcsize("bq") - longlong_size
 
@@ -303,7 +338,6 @@ class Person(Structure):
         self.assertEqual(p.phone.number, b"5678")
         self.assertEqual(p.age, 5)
 
-    @need_symbol('c_wchar')
     def test_structures_with_wchar(self):
         class PersonW(Structure):
             _fields_ = [("name", c_wchar * 12),
@@ -359,15 +393,6 @@ def get_except(self, func, *args):
         except Exception as detail:
             return detail.__class__, str(detail)
 
-    @unittest.skip('test disabled')
-    def test_subclass_creation(self):
-        meta = type(Structure)
-        # same as 'class X(Structure): pass'
-        # fails, since we need either a _fields_ or a _abstract_ attribute
-        cls, msg = self.get_except(meta, "X", (Structure,), {})
-        self.assertEqual((cls, msg),
-                (AttributeError, "class must define a '_fields_' attribute"))
-
     def test_abstract_class(self):
         class X(Structure):
             _abstract_ = "something"
@@ -376,9 +401,6 @@ class X(Structure):
         self.assertEqual((cls, msg), (TypeError, "abstract class"))
 
     def test_methods(self):
-##        class X(Structure):
-##            _fields_ = []
-
         self.assertIn("in_dll", dir(type(Structure)))
         self.assertIn("from_address", dir(type(Structure)))
         self.assertIn("in_dll", dir(type(Structure)))
@@ -484,37 +506,116 @@ class X(Structure):
         self.assertEqual(s.first, got.first)
         self.assertEqual(s.second, got.second)
 
+    def _test_issue18060(self, Vector):
+        # The call to atan2() should succeed if the
+        # class fields were correctly cloned in the
+        # subclasses. Otherwise, it will segfault.
+        if sys.platform == 'win32':
+            libm = CDLL(find_library('msvcrt.dll'))
+        else:
+            libm = CDLL(find_library('m'))
+
+        libm.atan2.argtypes = [Vector]
+        libm.atan2.restype = c_double
+
+        arg = Vector(y=0.0, x=-1.0)
+        self.assertAlmostEqual(libm.atan2(arg), 3.141592653589793)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_a(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment, and PyCStgInfo_clone()
+        # for the Mid and Vector class definitions.
+        class Base(Structure):
+            _fields_ = [('y', c_double),
+                        ('x', c_double)]
+        class Mid(Base):
+            pass
+        Mid._fields_ = []
+        class Vector(Mid): pass
+        self._test_issue18060(Vector)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_b(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment.
+        class Base(Structure):
+            _fields_ = [('y', c_double),
+                        ('x', c_double)]
+        class Mid(Base):
+            _fields_ = []
+        class Vector(Mid):
+            _fields_ = []
+        self._test_issue18060(Vector)
+
+    @unittest.skipIf(_architecture() == ('64bit', 'WindowsPE'), "can't test Windows x64 build")
+    @unittest.skipUnless(sys.byteorder == 'little', "can't test on this platform")
+    def test_issue18060_c(self):
+        # This test case calls
+        # PyCStructUnionType_update_stginfo() for each
+        # _fields_ assignment.
+        class Base(Structure):
+            _fields_ = [('y', c_double)]
+        class Mid(Base):
+            _fields_ = []
+        class Vector(Mid):
+            _fields_ = [('x', c_double)]
+        self._test_issue18060(Vector)
+
     def test_array_in_struct(self):
         # See bpo-22273
 
+        # Load the shared library
+        dll = CDLL(_ctypes_test.__file__)
+
         # These should mirror the structures in Modules/_ctypes/_ctypes_test.c
         class Test2(Structure):
             _fields_ = [
                 ('data', c_ubyte * 16),
             ]
 
-        class Test3(Structure):
+        class Test3AParent(Structure):
+            _fields_ = [
+                ('data', c_float * 2),
+            ]
+
+        class Test3A(Test3AParent):
+            _fields_ = [
+                ('more_data', c_float * 2),
+            ]
+
+        class Test3B(Structure):
             _fields_ = [
                 ('data', c_double * 2),
             ]
 
-        class Test3A(Structure):
+        class Test3C(Structure):
             _fields_ = [
-                ('data', c_float * 2),
+                ("data", c_double * 4)
             ]
 
-        class Test3B(Test3A):
+        class Test3D(Structure):
             _fields_ = [
-                ('more_data', c_float * 2),
+                ("data", c_double * 8)
+            ]
+
+        class Test3E(Structure):
+            _fields_ = [
+                ("data", c_double * 9)
             ]
 
+
+        # Tests for struct Test2
         s = Test2()
         expected = 0
         for i in range(16):
             s.data[i] = i
             expected += i
-        dll = CDLL(_ctypes_test.__file__)
-        func = dll._testfunc_array_in_struct1
+        func = dll._testfunc_array_in_struct2
         func.restype = c_int
         func.argtypes = (Test2,)
         result = func(s)
@@ -523,29 +624,16 @@ class Test3B(Test3A):
         for i in range(16):
             self.assertEqual(s.data[i], i)
 
-        s = Test3()
-        s.data[0] = 3.14159
-        s.data[1] = 2.71828
-        expected = 3.14159 + 2.71828
-        func = dll._testfunc_array_in_struct2
-        func.restype = c_double
-        func.argtypes = (Test3,)
-        result = func(s)
-        self.assertEqual(result, expected)
-        # check the passed-in struct hasn't changed
-        self.assertEqual(s.data[0], 3.14159)
-        self.assertEqual(s.data[1], 2.71828)
-
-        s = Test3B()
+        # Tests for struct Test3A
+        s = Test3A()
         s.data[0] = 3.14159
         s.data[1] = 2.71828
         s.more_data[0] = -3.0
         s.more_data[1] = -2.0
-
-        expected = 3.14159 + 2.71828 - 5.0
-        func = dll._testfunc_array_in_struct2a
+        expected = 3.14159 + 2.71828 - 3.0 - 2.0
+        func = dll._testfunc_array_in_struct3A
         func.restype = c_double
-        func.argtypes = (Test3B,)
+        func.argtypes = (Test3A,)
         result = func(s)
         self.assertAlmostEqual(result, expected, places=6)
         # check the passed-in struct hasn't changed
@@ -554,6 +642,61 @@ class Test3B(Test3A):
         self.assertAlmostEqual(s.more_data[0], -3.0, places=6)
         self.assertAlmostEqual(s.more_data[1], -2.0, places=6)
 
+        # Test3B, Test3C, Test3D, Test3E have the same logic with different
+        # sizes hence putting them in a loop.
+        StructCtype = namedtuple(
+            "StructCtype",
+            ["cls", "cfunc1", "cfunc2", "items"]
+        )
+        structs_to_test = [
+            StructCtype(
+                Test3B,
+                dll._testfunc_array_in_struct3B,
+                dll._testfunc_array_in_struct3B_set_defaults,
+                2),
+            StructCtype(
+                Test3C,
+                dll._testfunc_array_in_struct3C,
+                dll._testfunc_array_in_struct3C_set_defaults,
+                4),
+            StructCtype(
+                Test3D,
+                dll._testfunc_array_in_struct3D,
+                dll._testfunc_array_in_struct3D_set_defaults,
+                8),
+            StructCtype(
+                Test3E,
+                dll._testfunc_array_in_struct3E,
+                dll._testfunc_array_in_struct3E_set_defaults,
+                9),
+        ]
+
+        for sut in structs_to_test:
+            s = sut.cls()
+
+            # Test for cfunc1
+            expected = 0
+            for i in range(sut.items):
+                float_i = float(i)
+                s.data[i] = float_i
+                expected += float_i
+            func = sut.cfunc1
+            func.restype = c_double
+            func.argtypes = (sut.cls,)
+            result = func(s)
+            self.assertEqual(result, expected)
+            # check the passed-in struct hasn't changed
+            for i in range(sut.items):
+                self.assertEqual(s.data[i], float(i))
+
+            # Test for cfunc2
+            func = sut.cfunc2
+            func.restype = sut.cls
+            result = func()
+            # check if the default values have been set correctly
+            for i in range(sut.items):
+                self.assertEqual(result.data[i], float(i+1))
+
     def test_38368(self):
         class U(Union):
             _fields_ = [
@@ -738,6 +881,7 @@ class Test8(Union):
         self.assertEqual(ctx.exception.args[0], 'item 1 in _argtypes_ passes '
                          'a union by value, which is unsupported.')
 
+
 class PointerMemberTestCase(unittest.TestCase):
 
     def test(self):
@@ -764,8 +908,6 @@ class S(Structure):
 
         s.array[0] = 1
 
-##        s.array[1] = 42
-
         items = [s.array[i] for i in range(3)]
         self.assertEqual(items, [1, 2, 3])
 
@@ -779,6 +921,7 @@ class S(Structure):
         s.p = None
         self.assertEqual(s.x, 12345678)
 
+
 class TestRecursiveStructure(unittest.TestCase):
     def test_contains_itself(self):
         class Recursive(Structure):
@@ -808,5 +951,6 @@ class Second(Structure):
         else:
             self.fail("AttributeError not raised")
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_unaligned_structures.py b/Lib/test/test_ctypes/test_unaligned_structures.py
similarity index 82%
rename from Lib/ctypes/test/test_unaligned_structures.py
rename to Lib/test/test_ctypes/test_unaligned_structures.py
index ee7fb45809..58a00597ef 100644
--- a/Lib/ctypes/test/test_unaligned_structures.py
+++ b/Lib/test/test_ctypes/test_unaligned_structures.py
@@ -1,5 +1,9 @@
 import sys, unittest
-from ctypes import *
+from ctypes import (Structure, BigEndianStructure, LittleEndianStructure,
+                    c_byte, c_short, c_int, c_long, c_longlong,
+                    c_float, c_double,
+                    c_ushort, c_uint, c_ulong, c_ulonglong)
+
 
 structures = []
 byteswapped_structures = []
@@ -24,6 +28,7 @@ class Y(SwappedStructure):
     structures.append(X)
     byteswapped_structures.append(Y)
 
+
 class TestStructures(unittest.TestCase):
     def test_native(self):
         for typ in structures:
@@ -39,5 +44,6 @@ def test_swapped(self):
             o.value = 4
             self.assertEqual(o.value, 4)
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_unicode.py b/Lib/test/test_ctypes/test_unicode.py
new file mode 100644
index 0000000000..d9e17371d1
--- /dev/null
+++ b/Lib/test/test_ctypes/test_unicode.py
@@ -0,0 +1,63 @@
+import ctypes
+import unittest
+from test.support import import_helper
+_ctypes_test = import_helper.import_module("_ctypes_test")
+
+
+class UnicodeTestCase(unittest.TestCase):
+    def test_wcslen(self):
+        dll = ctypes.CDLL(_ctypes_test.__file__)
+        wcslen = dll.my_wcslen
+        wcslen.argtypes = [ctypes.c_wchar_p]
+
+        self.assertEqual(wcslen("abc"), 3)
+        self.assertEqual(wcslen("ab\u2070"), 3)
+        self.assertRaises(ctypes.ArgumentError, wcslen, b"ab\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_unicode_buffer("abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_unicode_buffer("ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], "ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], '\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], 'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], "")
+
+    def test_embedded_null(self):
+        class TestStruct(ctypes.Structure):
+            _fields_ = [("unicode", ctypes.c_wchar_p)]
+        t = TestStruct()
+        # This would raise a ValueError:
+        t.unicode = "foo\0bar\0\0"
+
+
+func = ctypes.CDLL(_ctypes_test.__file__)._testfunc_p_p
+
+class StringTestCase(UnicodeTestCase):
+    def setUp(self):
+        func.argtypes = [ctypes.c_char_p]
+        func.restype = ctypes.c_char_p
+
+    def tearDown(self):
+        func.argtypes = None
+        func.restype = ctypes.c_int
+
+    def test_func(self):
+        self.assertEqual(func(b"abc\xe4"), b"abc\xe4")
+
+    def test_buffers(self):
+        buf = ctypes.create_string_buffer(b"abc")
+        self.assertEqual(len(buf), 3+1)
+
+        buf = ctypes.create_string_buffer(b"ab\xe4\xf6\xfc")
+        self.assertEqual(buf[:], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::], b"ab\xe4\xf6\xfc\0")
+        self.assertEqual(buf[::-1], b'\x00\xfc\xf6\xe4ba')
+        self.assertEqual(buf[::2], b'a\xe4\xfc')
+        self.assertEqual(buf[6:5:-1], b"")
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_unions.py b/Lib/test/test_ctypes/test_unions.py
new file mode 100644
index 0000000000..e2dff0f22a
--- /dev/null
+++ b/Lib/test/test_ctypes/test_unions.py
@@ -0,0 +1,35 @@
+import unittest
+from ctypes import Union, c_char
+from ._support import (_CData, UnionType, Py_TPFLAGS_DISALLOW_INSTANTIATION,
+                       Py_TPFLAGS_IMMUTABLETYPE)
+
+
+class ArrayTestCase(unittest.TestCase):
+    def test_inheritance_hierarchy(self):
+        self.assertEqual(Union.mro(), [Union, _CData, object])
+
+        self.assertEqual(UnionType.__name__, "UnionType")
+        self.assertEqual(type(UnionType), type)
+
+    def test_type_flags(self):
+        for cls in Union, UnionType:
+            with self.subTest(cls=Union):
+                self.assertTrue(Union.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+                self.assertFalse(Union.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+
+    def test_metaclass_details(self):
+        # Abstract classes (whose metaclass __init__ was not called) can't be
+        # instantiated directly
+        NewUnion = UnionType.__new__(UnionType, 'NewUnion',
+                                     (Union,), {})
+        for cls in Union, NewUnion:
+            with self.subTest(cls=cls):
+                with self.assertRaisesRegex(TypeError, "abstract class"):
+                    obj = cls()
+
+        # Cannot call the metaclass __init__ more than once
+        class T(Union):
+            _fields_ = [("x", c_char),
+                        ("y", c_char)]
+        with self.assertRaisesRegex(SystemError, "already initialized"):
+            UnionType.__init__(T, 'ptr', (), {})
diff --git a/Lib/ctypes/test/test_values.py b/Lib/test/test_ctypes/test_values.py
similarity index 88%
rename from Lib/ctypes/test/test_values.py
rename to Lib/test/test_ctypes/test_values.py
index 435fdd22ea..e0d200e210 100644
--- a/Lib/ctypes/test/test_values.py
+++ b/Lib/test/test_ctypes/test_values.py
@@ -4,19 +4,24 @@
 
 import _imp
 import importlib.util
-import unittest
 import sys
-from ctypes import *
+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
 
-import _ctypes_test
 
 class ValuesTestCase(unittest.TestCase):
 
+    def setUp(self):
+        _ctypes_test = import_helper.import_module("_ctypes_test")
+        self.ctdll = CDLL(_ctypes_test.__file__)
+
     def test_an_integer(self):
         # This test checks and changes an integer stored inside the
         # _ctypes_test dll/shared lib.
-        ctdll = CDLL(_ctypes_test.__file__)
+        ctdll = self.ctdll
         an_integer = c_int.in_dll(ctdll, "an_integer")
         x = an_integer.value
         self.assertEqual(x, ctdll.get_an_integer())
@@ -28,12 +33,14 @@ def test_an_integer(self):
         self.assertEqual(x, ctdll.get_an_integer())
 
     def test_undefined(self):
-        ctdll = CDLL(_ctypes_test.__file__)
-        self.assertRaises(ValueError, c_int.in_dll, ctdll, "Undefined_Symbol")
+        self.assertRaises(ValueError, c_int.in_dll, self.ctdll, "Undefined_Symbol")
+
 
 class PythonValuesTestCase(unittest.TestCase):
     """This test only works when python itself is a dll/shared library"""
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_optimizeflag(self):
         # This test accesses the Py_OptimizeFlag integer, which is
         # exported by the Python dll and should match the sys.flags value
@@ -41,6 +48,8 @@ def test_optimizeflag(self):
         opt = c_int.in_dll(pythonapi, "Py_OptimizeFlag").value
         self.assertEqual(opt, sys.flags.optimize)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_frozentable(self):
         # Python exports a PyImport_FrozenModules symbol. This is a
         # pointer to an array of struct _frozen entries.  The end of the
@@ -55,7 +64,6 @@ class struct_frozen(Structure):
                         ("code", POINTER(c_ubyte)),
                         ("size", c_int),
                         ("is_package", c_int),
-                        ("get_code", POINTER(c_ubyte)),  # Function ptr
                         ]
         FrozenTable = POINTER(struct_frozen)
 
@@ -92,12 +100,12 @@ class struct_frozen(Structure):
                          "_PyImport_FrozenBootstrap example "
                          "in Doc/library/ctypes.rst may be out of date")
 
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[struct_frozen]
 
     def test_undefined(self):
         self.assertRaises(ValueError, c_int.in_dll, pythonapi,
                           "Undefined_Symbol")
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/ctypes/test/test_varsize_struct.py b/Lib/test/test_ctypes/test_varsize_struct.py
similarity index 97%
rename from Lib/ctypes/test/test_varsize_struct.py
rename to Lib/test/test_ctypes/test_varsize_struct.py
index f409500f01..3e6ba6fed0 100644
--- a/Lib/ctypes/test/test_varsize_struct.py
+++ b/Lib/test/test_ctypes/test_varsize_struct.py
@@ -1,5 +1,6 @@
-from ctypes import *
 import unittest
+from ctypes import Structure, sizeof, resize, c_int
+
 
 class VarSizeTest(unittest.TestCase):
     def test_resize(self):
@@ -46,5 +47,6 @@ def test_zerosized_array(self):
         self.assertRaises(IndexError, array.__setitem__, -1, None)
         self.assertRaises(IndexError, array.__getitem__, -1)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/ctypes/test/test_win32.py b/Lib/test/test_ctypes/test_win32.py
similarity index 77%
rename from Lib/ctypes/test/test_win32.py
rename to Lib/test/test_ctypes/test_win32.py
index e51bdc8ad6..4de4f0379c 100644
--- a/Lib/ctypes/test/test_win32.py
+++ b/Lib/test/test_ctypes/test_win32.py
@@ -1,33 +1,44 @@
 # Windows specific tests
 
-from ctypes import *
-import unittest, sys
+import ctypes
+import errno
+import sys
+import unittest
+from ctypes import (CDLL, Structure, POINTER, pointer, sizeof, byref,
+                    _pointer_type_cache,
+                    c_void_p, c_char, c_int, c_long)
 from test import support
+from test.support import import_helper
+from ._support import Py_TPFLAGS_DISALLOW_INSTANTIATION, Py_TPFLAGS_IMMUTABLETYPE
 
-import _ctypes_test
 
 @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
 class FunctionCallTestCase(unittest.TestCase):
     @unittest.skipUnless('MSC' in sys.version, "SEH only supported by MSC")
     @unittest.skipIf(sys.executable.lower().endswith('_d.exe'),
                      "SEH not enabled in debug builds")
+    # 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"
+        kernel32 = ctypes.windll.kernel32
         with support.disable_faulthandler():
             # Call functions with invalid arguments, and make sure
             # that access violations are trapped and raise an
             # exception.
-            self.assertRaises(OSError, windll.kernel32.GetModuleHandleA, 32)
+            self.assertRaises(OSError, kernel32.GetModuleHandleA, 32)
 
     def test_noargs(self):
         # This is a special case on win32 x64
-        windll.user32.GetDesktopWindow()
+        user32 = ctypes.windll.user32
+        user32.GetDesktopWindow()
 
 
 @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
 class ReturnStructSizesTestCase(unittest.TestCase):
     def test_sizes(self):
+        _ctypes_test = import_helper.import_module("_ctypes_test")
         dll = CDLL(_ctypes_test.__file__)
         for i in range(1, 11):
             fields = [ (f"f{f}", c_char) for f in range(1, i + 1)]
@@ -42,7 +53,6 @@ class S(Structure):
                 self.assertEqual(value, expected)
 
 
-
 @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
 class TestWintypes(unittest.TestCase):
     def test_HWND(self):
@@ -67,29 +77,36 @@ def test_COMError(self):
         self.assertEqual(ex.text, "text")
         self.assertEqual(ex.details, ("details",))
 
+        self.assertEqual(COMError.mro(),
+                         [COMError, Exception, BaseException, object])
+        self.assertFalse(COMError.__flags__ & Py_TPFLAGS_DISALLOW_INSTANTIATION)
+        self.assertTrue(COMError.__flags__ & Py_TPFLAGS_IMMUTABLETYPE)
+
+
 @unittest.skipUnless(sys.platform == "win32", 'Windows-specific test')
 class TestWinError(unittest.TestCase):
     def test_winerror(self):
         # see Issue 16169
-        import errno
         ERROR_INVALID_PARAMETER = 87
-        msg = FormatError(ERROR_INVALID_PARAMETER).strip()
+        msg = ctypes.FormatError(ERROR_INVALID_PARAMETER).strip()
         args = (errno.EINVAL, msg, None, ERROR_INVALID_PARAMETER)
 
-        e = WinError(ERROR_INVALID_PARAMETER)
+        e = ctypes.WinError(ERROR_INVALID_PARAMETER)
         self.assertEqual(e.args, args)
         self.assertEqual(e.errno, errno.EINVAL)
         self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
 
-        windll.kernel32.SetLastError(ERROR_INVALID_PARAMETER)
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetLastError(ERROR_INVALID_PARAMETER)
         try:
-            raise WinError()
+            raise ctypes.WinError()
         except OSError as exc:
             e = exc
         self.assertEqual(e.args, args)
         self.assertEqual(e.errno, errno.EINVAL)
         self.assertEqual(e.winerror, ERROR_INVALID_PARAMETER)
 
+
 class Structures(unittest.TestCase):
     def test_struct_by_value(self):
         class POINT(Structure):
@@ -102,6 +119,7 @@ class RECT(Structure):
                         ("right", c_long),
                         ("bottom", c_long)]
 
+        _ctypes_test = import_helper.import_module("_ctypes_test")
         dll = CDLL(_ctypes_test.__file__)
 
         pt = POINT(15, 25)
@@ -129,8 +147,8 @@ class RECT(Structure):
             self.assertEqual(ret.bottom, bottom.value)
 
         # to not leak references, we must clean _pointer_type_cache
-        from ctypes import _pointer_type_cache
         del _pointer_type_cache[RECT]
 
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ctypes/test_win32_com_foreign_func.py b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
new file mode 100644
index 0000000000..b12e09333b
--- /dev/null
+++ b/Lib/test/test_ctypes/test_win32_com_foreign_func.py
@@ -0,0 +1,288 @@
+import ctypes
+import gc
+import sys
+import unittest
+from ctypes import POINTER, byref, c_void_p
+from ctypes.wintypes import BYTE, DWORD, WORD
+
+if sys.platform != "win32":
+    raise unittest.SkipTest("Windows-specific test")
+
+
+from _ctypes import COMError, CopyComPointer
+from ctypes import HRESULT
+
+
+COINIT_APARTMENTTHREADED = 0x2
+CLSCTX_SERVER = 5
+S_OK = 0
+OUT = 2
+TRUE = 1
+E_NOINTERFACE = -2147467262
+
+
+class GUID(ctypes.Structure):
+    # https://learn.microsoft.com/en-us/windows/win32/api/guiddef/ns-guiddef-guid
+    _fields_ = [
+        ("Data1", DWORD),
+        ("Data2", WORD),
+        ("Data3", WORD),
+        ("Data4", BYTE * 8),
+    ]
+
+
+def create_proto_com_method(name, index, restype, *argtypes):
+    proto = ctypes.WINFUNCTYPE(restype, *argtypes)
+
+    def make_method(*args):
+        foreign_func = proto(index, name, *args)
+
+        def call(self, *args, **kwargs):
+            return foreign_func(self, *args, **kwargs)
+
+        return call
+
+    return make_method
+
+
+def create_guid(name):
+    guid = GUID()
+    # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-clsidfromstring
+    ole32.CLSIDFromString(name, byref(guid))
+    return guid
+
+
+def is_equal_guid(guid1, guid2):
+    # https://learn.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-isequalguid
+    return ole32.IsEqualGUID(byref(guid1), byref(guid2))
+
+
+ole32 = ctypes.oledll.ole32
+
+IID_IUnknown = create_guid("{00000000-0000-0000-C000-000000000046}")
+IID_IStream = create_guid("{0000000C-0000-0000-C000-000000000046}")
+IID_IPersist = create_guid("{0000010C-0000-0000-C000-000000000046}")
+CLSID_ShellLink = create_guid("{00021401-0000-0000-C000-000000000046}")
+
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)
+proto_query_interface = create_proto_com_method(
+    "QueryInterface", 0, HRESULT, POINTER(GUID), POINTER(c_void_p)
+)
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-addref
+proto_add_ref = create_proto_com_method("AddRef", 1, ctypes.c_long)
+# https://learn.microsoft.com/en-us/windows/win32/api/unknwn/nf-unknwn-iunknown-release
+proto_release = create_proto_com_method("Release", 2, ctypes.c_long)
+# https://learn.microsoft.com/en-us/windows/win32/api/objidl/nf-objidl-ipersist-getclassid
+proto_get_class_id = create_proto_com_method(
+    "GetClassID", 3, HRESULT, POINTER(GUID)
+)
+
+
+def create_shelllink_persist(typ):
+    ppst = typ()
+    # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-cocreateinstance
+    ole32.CoCreateInstance(
+        byref(CLSID_ShellLink),
+        None,
+        CLSCTX_SERVER,
+        byref(IID_IPersist),
+        byref(ppst),
+    )
+    return ppst
+
+
+class ForeignFunctionsThatWillCallComMethodsTests(unittest.TestCase):
+    def setUp(self):
+        # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-coinitializeex
+        ole32.CoInitializeEx(None, COINIT_APARTMENTTHREADED)
+
+    def tearDown(self):
+        # https://learn.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-couninitialize
+        ole32.CoUninitialize()
+        gc.collect()
+
+    def test_without_paramflags_and_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface()
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id()
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = GUID()
+        hr_getclsid = ppst.GetClassID(byref(clsid))
+        self.assertEqual(S_OK, hr_getclsid)
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(2, ppst.AddRef())
+        self.assertEqual(3, ppst.AddRef())
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(3, punk.Release())
+
+        with self.assertRaises(OSError) as e:
+            punk.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.winerror)
+
+        self.assertEqual(2, ppst.Release())
+        self.assertEqual(1, ppst.Release())
+        self.assertEqual(0, ppst.Release())
+
+    def test_with_paramflags_and_without_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),))
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = ppst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(1, punk.Release())
+
+        with self.assertRaises(OSError) as e:
+            ppst.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.winerror)
+
+        self.assertEqual(0, ppst.Release())
+
+    # TODO: RUSTPYTHON - COM iid parameter handling not implemented
+    @unittest.expectedFailure
+    def test_with_paramflags_and_iid(self):
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None, IID_IUnknown)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),), IID_IPersist)
+
+        ppst = create_shelllink_persist(IPersist)
+
+        clsid = ppst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        punk = IUnknown()
+        hr_qi = ppst.QueryInterface(IID_IUnknown, punk)
+        self.assertEqual(S_OK, hr_qi)
+        self.assertEqual(1, punk.Release())
+
+        with self.assertRaises(COMError) as e:
+            ppst.QueryInterface(IID_IStream, IUnknown())
+        self.assertEqual(E_NOINTERFACE, e.exception.hresult)
+
+        self.assertEqual(0, ppst.Release())
+
+
+class CopyComPointerTests(unittest.TestCase):
+    def setUp(self):
+        ole32.CoInitializeEx(None, COINIT_APARTMENTTHREADED)
+
+        class IUnknown(c_void_p):
+            QueryInterface = proto_query_interface(None, IID_IUnknown)
+            AddRef = proto_add_ref()
+            Release = proto_release()
+
+        class IPersist(IUnknown):
+            GetClassID = proto_get_class_id(((OUT, "pClassID"),), IID_IPersist)
+
+        self.IUnknown = IUnknown
+        self.IPersist = IPersist
+
+    def tearDown(self):
+        ole32.CoUninitialize()
+        gc.collect()
+
+    def test_both_are_null(self):
+        src = self.IPersist()
+        dst = self.IPersist()
+
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+
+        self.assertIsNone(src.value)
+        self.assertIsNone(dst.value)
+
+    def test_src_is_nonnull_and_dest_is_null(self):
+        # The reference count of the COM pointer created by `CoCreateInstance`
+        # is initially 1.
+        src = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+
+        # `CopyComPointer` calls `AddRef` explicitly in the C implementation.
+        # The refcount of `src` is incremented from 1 to 2 here.
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertEqual(src.value, dst.value)
+
+        # This indicates that the refcount was 2 before the `Release` call.
+        self.assertEqual(1, src.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(0, dst.Release())
+
+    def test_src_is_null_and_dest_is_nonnull(self):
+        src = self.IPersist()
+        dst_orig = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+        CopyComPointer(dst_orig, byref(dst))
+        self.assertEqual(1, dst_orig.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        # This does NOT affects the refcount of `dst_orig`.
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertIsNone(dst.value)
+
+        with self.assertRaises(ValueError):
+            dst.GetClassID()  # NULL COM pointer access
+
+        # This indicates that the refcount was 1 before the `Release` call.
+        self.assertEqual(0, dst_orig.Release())
+
+    def test_both_are_nonnull(self):
+        src = create_shelllink_persist(self.IPersist)
+        dst_orig = create_shelllink_persist(self.IPersist)
+        dst = self.IPersist()
+        CopyComPointer(dst_orig, byref(dst))
+        self.assertEqual(1, dst_orig.Release())
+
+        self.assertEqual(dst.value, dst_orig.value)
+        self.assertNotEqual(src.value, dst.value)
+
+        hr = CopyComPointer(src, byref(dst))
+
+        self.assertEqual(S_OK, hr)
+        self.assertEqual(src.value, dst.value)
+        self.assertNotEqual(dst.value, dst_orig.value)
+
+        self.assertEqual(1, src.Release())
+
+        clsid = dst.GetClassID()
+        self.assertEqual(TRUE, is_equal_guid(CLSID_ShellLink, clsid))
+
+        self.assertEqual(0, dst.Release())
+        self.assertEqual(0, dst_orig.Release())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_ctypes/test_wintypes.py b/Lib/test/test_ctypes/test_wintypes.py
new file mode 100644
index 0000000000..a04d725a47
--- /dev/null
+++ b/Lib/test/test_ctypes/test_wintypes.py
@@ -0,0 +1,61 @@
+# See <https://learn.microsoft.com/en-us/windows/win32/winprog/windows-data-types>
+# for reference.
+#
+# Tests also work on POSIX
+
+import unittest
+from ctypes import POINTER, cast, c_int16
+from ctypes import wintypes
+
+
+class WinTypesTest(unittest.TestCase):
+    def test_variant_bool(self):
+        # reads 16-bits from memory, anything non-zero is True
+        for true_value in (1, 32767, 32768, 65535, 65537):
+            true = POINTER(c_int16)(c_int16(true_value))
+            value = cast(true, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(True)')
+
+            vb = wintypes.VARIANT_BOOL()
+            self.assertIs(vb.value, False)
+            vb.value = True
+            self.assertIs(vb.value, True)
+            vb.value = true_value
+            self.assertIs(vb.value, True)
+
+        for false_value in (0, 65536, 262144, 2**33):
+            false = POINTER(c_int16)(c_int16(false_value))
+            value = cast(false, POINTER(wintypes.VARIANT_BOOL))
+            self.assertEqual(repr(value.contents), 'VARIANT_BOOL(False)')
+
+        # allow any bool conversion on assignment to value
+        for set_value in (65536, 262144, 2**33):
+            vb = wintypes.VARIANT_BOOL()
+            vb.value = set_value
+            self.assertIs(vb.value, True)
+
+        vb = wintypes.VARIANT_BOOL()
+        vb.value = [2, 3]
+        self.assertIs(vb.value, True)
+        vb.value = []
+        self.assertIs(vb.value, False)
+
+    def assertIsSigned(self, ctype):
+        self.assertLess(ctype(-1).value, 0)
+
+    def assertIsUnsigned(self, ctype):
+        self.assertGreater(ctype(-1).value, 0)
+
+    def test_signedness(self):
+        for ctype in (wintypes.BYTE, wintypes.WORD, wintypes.DWORD,
+                     wintypes.BOOLEAN, wintypes.UINT, wintypes.ULONG):
+            with self.subTest(ctype=ctype):
+                self.assertIsUnsigned(ctype)
+
+        for ctype in (wintypes.BOOL, wintypes.INT, wintypes.LONG):
+            with self.subTest(ctype=ctype):
+                self.assertIsSigned(ctype)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_dataclasses.py b/Lib/test/test_dataclasses.py
deleted file mode 100644
index 46430d3231..0000000000
--- a/Lib/test/test_dataclasses.py
+++ /dev/null
@@ -1,4033 +0,0 @@
-# Deliberately use "from dataclasses import *".  Every name in __all__
-# is tested, so they all must be present.  This is a way to catch
-# missing ones.
-
-from dataclasses import *
-
-import abc
-import pickle
-import inspect
-import builtins
-import types
-import unittest
-from unittest.mock import Mock
-from typing import ClassVar, Any, List, Union, Tuple, Dict, Generic, TypeVar, Optional, Protocol
-from typing import get_type_hints
-from collections import deque, OrderedDict, namedtuple
-from functools import total_ordering
-
-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.
-
-# Just any custom exception we can catch.
-class CustomError(Exception): pass
-
-class TestCase(unittest.TestCase):
-    def test_no_fields(self):
-        @dataclass
-        class C:
-            pass
-
-        o = C()
-        self.assertEqual(len(fields(C)), 0)
-
-    def test_no_fields_but_member_variable(self):
-        @dataclass
-        class C:
-            i = 0
-
-        o = C()
-        self.assertEqual(len(fields(C)), 0)
-
-    def test_one_field_no_default(self):
-        @dataclass
-        class C:
-            x: int
-
-        o = C(42)
-        self.assertEqual(o.x, 42)
-
-    def test_field_default_default_factory_error(self):
-        msg = "cannot specify both default and default_factory"
-        with self.assertRaisesRegex(ValueError, msg):
-            @dataclass
-            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.name = "id"
-        repr_output = repr(int_field)
-        expected_output = "Field(name='id',type=None," \
-                           f"default=1,default_factory={MISSING!r}," \
-                           "init=True,repr=False,hash=None," \
-                           "compare=True,metadata=mappingproxy({})," \
-                           f"kw_only={MISSING!r}," \
-                           "_field_type=None)"
-
-        self.assertEqual(repr_output, expected_output)
-
-    def test_named_init_params(self):
-        @dataclass
-        class C:
-            x: int
-
-        o = C(x=32)
-        self.assertEqual(o.x, 32)
-
-    def test_two_fields_one_default(self):
-        @dataclass
-        class C:
-            x: int
-            y: int = 0
-
-        o = C(3)
-        self.assertEqual((o.x, o.y), (3, 0))
-
-        # Non-defaults following defaults.
-        with self.assertRaisesRegex(TypeError,
-                                    "non-default argument 'y' follows "
-                                    "default argument"):
-            @dataclass
-            class C:
-                x: int = 0
-                y: int
-
-        # A derived class adds a non-default field after a default one.
-        with self.assertRaisesRegex(TypeError,
-                                    "non-default argument 'y' follows "
-                                    "default argument"):
-            @dataclass
-            class B:
-                x: int = 0
-
-            @dataclass
-            class C(B):
-                y: int
-
-        # Override a base class field and add a default to
-        #  a field which didn't use to have a default.
-        with self.assertRaisesRegex(TypeError,
-                                    "non-default argument 'y' follows "
-                                    "default argument"):
-            @dataclass
-            class B:
-                x: int
-                y: int
-
-            @dataclass
-            class C(B):
-                x: int = 0
-
-    def test_overwrite_hash(self):
-        # Test that declaring this class isn't an error.  It should
-        #  use the user-provided __hash__.
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            def __hash__(self):
-                return 301
-        self.assertEqual(hash(C(100)), 301)
-
-        # Test that declaring this class isn't an error.  It should
-        #  use the generated __hash__.
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            def __eq__(self, other):
-                return False
-        self.assertEqual(hash(C(100)), hash((100,)))
-
-        # But this one should generate an exception, because with
-        #  unsafe_hash=True, it's an error to have a __hash__ defined.
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __hash__'):
-            @dataclass(unsafe_hash=True)
-            class C:
-                def __hash__(self):
-                    pass
-
-        # Creating this class should not generate an exception,
-        #  because even though __hash__ exists before @dataclass is
-        #  called, (due to __eq__ being defined), since it's None
-        #  that's okay.
-        @dataclass(unsafe_hash=True)
-        class C:
-            x: int
-            def __eq__(self):
-                pass
-        # The generated hash function works as we'd expect.
-        self.assertEqual(hash(C(10)), hash((10,)))
-
-        # Creating this class should generate an exception, because
-        #  __hash__ exists and is not None, which it would be if it
-        #  had been auto-generated due to __eq__ being defined.
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __hash__'):
-            @dataclass(unsafe_hash=True)
-            class C:
-                x: int
-                def __eq__(self):
-                    pass
-                def __hash__(self):
-                    pass
-
-    def test_overwrite_fields_in_derived_class(self):
-        # Note that x from C1 replaces x in Base, but the order remains
-        #  the same as defined in Base.
-        @dataclass
-        class Base:
-            x: Any = 15.0
-            y: int = 0
-
-        @dataclass
-        class C1(Base):
-            z: int = 10
-            x: int = 15
-
-        o = Base()
-        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.Base(x=15.0, y=0)')
-
-        o = C1()
-        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=15, y=0, z=10)')
-
-        o = C1(x=5)
-        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=5, y=0, z=10)')
-
-    def test_field_named_self(self):
-        @dataclass
-        class C:
-            self: str
-        c=C('foo')
-        self.assertEqual(c.self, 'foo')
-
-        # Make sure the first parameter is not named 'self'.
-        sig = inspect.signature(C.__init__)
-        first = next(iter(sig.parameters))
-        self.assertNotEqual('self', first)
-
-        # But we do use 'self' if no field named self.
-        @dataclass
-        class C:
-            selfx: str
-
-        # Make sure the first parameter is named 'self'.
-        sig = inspect.signature(C.__init__)
-        first = next(iter(sig.parameters))
-        self.assertEqual('self', first)
-
-    def test_field_named_object(self):
-        @dataclass
-        class C:
-            object: str
-        c = C('foo')
-        self.assertEqual(c.object, 'foo')
-
-    def test_field_named_object_frozen(self):
-        @dataclass(frozen=True)
-        class C:
-            object: str
-        c = C('foo')
-        self.assertEqual(c.object, 'foo')
-
-    def test_field_named_like_builtin(self):
-        # Attribute names can shadow built-in names
-        # since code generation is used.
-        # Ensure that this is not happening.
-        exclusions = {'None', 'True', 'False'}
-        builtins_names = sorted(
-            b for b in builtins.__dict__.keys()
-            if not b.startswith('__') and b not in exclusions
-        )
-        attributes = [(name, str) for name in builtins_names]
-        C = make_dataclass('C', attributes)
-
-        c = C(*[name for name in builtins_names])
-
-        for name in builtins_names:
-            self.assertEqual(getattr(c, name), name)
-
-    def test_field_named_like_builtin_frozen(self):
-        # Attribute names can shadow built-in names
-        # since code generation is used.
-        # Ensure that this is not happening
-        # for frozen data classes.
-        exclusions = {'None', 'True', 'False'}
-        builtins_names = sorted(
-            b for b in builtins.__dict__.keys()
-            if not b.startswith('__') and b not in exclusions
-        )
-        attributes = [(name, str) for name in builtins_names]
-        C = make_dataclass('C', attributes, frozen=True)
-
-        c = C(*[name for name in builtins_names])
-
-        for name in builtins_names:
-            self.assertEqual(getattr(c, name), name)
-
-    def test_0_field_compare(self):
-        # Ensure that order=False is the default.
-        @dataclass
-        class C0:
-            pass
-
-        @dataclass(order=False)
-        class C1:
-            pass
-
-        for cls in [C0, C1]:
-            with self.subTest(cls=cls):
-                self.assertEqual(cls(), cls())
-                for idx, fn in enumerate([lambda a, b: a < b,
-                                          lambda a, b: a <= b,
-                                          lambda a, b: a > b,
-                                          lambda a, b: a >= b]):
-                    with self.subTest(idx=idx):
-                        with self.assertRaisesRegex(TypeError,
-                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
-                            fn(cls(), cls())
-
-        @dataclass(order=True)
-        class C:
-            pass
-        self.assertLessEqual(C(), C())
-        self.assertGreaterEqual(C(), C())
-
-    def test_1_field_compare(self):
-        # Ensure that order=False is the default.
-        @dataclass
-        class C0:
-            x: int
-
-        @dataclass(order=False)
-        class C1:
-            x: int
-
-        for cls in [C0, C1]:
-            with self.subTest(cls=cls):
-                self.assertEqual(cls(1), cls(1))
-                self.assertNotEqual(cls(0), cls(1))
-                for idx, fn in enumerate([lambda a, b: a < b,
-                                          lambda a, b: a <= b,
-                                          lambda a, b: a > b,
-                                          lambda a, b: a >= b]):
-                    with self.subTest(idx=idx):
-                        with self.assertRaisesRegex(TypeError,
-                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
-                            fn(cls(0), cls(0))
-
-        @dataclass(order=True)
-        class C:
-            x: int
-        self.assertLess(C(0), C(1))
-        self.assertLessEqual(C(0), C(1))
-        self.assertLessEqual(C(1), C(1))
-        self.assertGreater(C(1), C(0))
-        self.assertGreaterEqual(C(1), C(0))
-        self.assertGreaterEqual(C(1), C(1))
-
-    def test_simple_compare(self):
-        # Ensure that order=False is the default.
-        @dataclass
-        class C0:
-            x: int
-            y: int
-
-        @dataclass(order=False)
-        class C1:
-            x: int
-            y: int
-
-        for cls in [C0, C1]:
-            with self.subTest(cls=cls):
-                self.assertEqual(cls(0, 0), cls(0, 0))
-                self.assertEqual(cls(1, 2), cls(1, 2))
-                self.assertNotEqual(cls(1, 0), cls(0, 0))
-                self.assertNotEqual(cls(1, 0), cls(1, 1))
-                for idx, fn in enumerate([lambda a, b: a < b,
-                                          lambda a, b: a <= b,
-                                          lambda a, b: a > b,
-                                          lambda a, b: a >= b]):
-                    with self.subTest(idx=idx):
-                        with self.assertRaisesRegex(TypeError,
-                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
-                            fn(cls(0, 0), cls(0, 0))
-
-        @dataclass(order=True)
-        class C:
-            x: int
-            y: int
-
-        for idx, fn in enumerate([lambda a, b: a == b,
-                                  lambda a, b: a <= b,
-                                  lambda a, b: a >= b]):
-            with self.subTest(idx=idx):
-                self.assertTrue(fn(C(0, 0), C(0, 0)))
-
-        for idx, fn in enumerate([lambda a, b: a < b,
-                                  lambda a, b: a <= b,
-                                  lambda a, b: a != b]):
-            with self.subTest(idx=idx):
-                self.assertTrue(fn(C(0, 0), C(0, 1)))
-                self.assertTrue(fn(C(0, 1), C(1, 0)))
-                self.assertTrue(fn(C(1, 0), C(1, 1)))
-
-        for idx, fn in enumerate([lambda a, b: a > b,
-                                  lambda a, b: a >= b,
-                                  lambda a, b: a != b]):
-            with self.subTest(idx=idx):
-                self.assertTrue(fn(C(0, 1), C(0, 0)))
-                self.assertTrue(fn(C(1, 0), C(0, 1)))
-                self.assertTrue(fn(C(1, 1), C(1, 0)))
-
-    def test_compare_subclasses(self):
-        # Comparisons fail for subclasses, even if no fields
-        #  are added.
-        @dataclass
-        class B:
-            i: int
-
-        @dataclass
-        class C(B):
-            pass
-
-        for idx, (fn, expected) in enumerate([(lambda a, b: a == b, False),
-                                              (lambda a, b: a != b, True)]):
-            with self.subTest(idx=idx):
-                self.assertEqual(fn(B(0), C(0)), expected)
-
-        for idx, fn in enumerate([lambda a, b: a < b,
-                                  lambda a, b: a <= b,
-                                  lambda a, b: a > b,
-                                  lambda a, b: a >= b]):
-            with self.subTest(idx=idx):
-                with self.assertRaisesRegex(TypeError,
-                                            "not supported between instances of 'B' and 'C'"):
-                    fn(B(0), C(0))
-
-    def test_eq_order(self):
-        # Test combining eq and order.
-        for (eq,    order, result   ) in [
-            (False, False, 'neither'),
-            (False, True,  'exception'),
-            (True,  False, 'eq_only'),
-            (True,  True,  'both'),
-        ]:
-            with self.subTest(eq=eq, order=order):
-                if result == 'exception':
-                    with self.assertRaisesRegex(ValueError, 'eq must be true if order is true'):
-                        @dataclass(eq=eq, order=order)
-                        class C:
-                            pass
-                else:
-                    @dataclass(eq=eq, order=order)
-                    class C:
-                        pass
-
-                    if result == 'neither':
-                        self.assertNotIn('__eq__', C.__dict__)
-                        self.assertNotIn('__lt__', C.__dict__)
-                        self.assertNotIn('__le__', C.__dict__)
-                        self.assertNotIn('__gt__', C.__dict__)
-                        self.assertNotIn('__ge__', C.__dict__)
-                    elif result == 'both':
-                        self.assertIn('__eq__', C.__dict__)
-                        self.assertIn('__lt__', C.__dict__)
-                        self.assertIn('__le__', C.__dict__)
-                        self.assertIn('__gt__', C.__dict__)
-                        self.assertIn('__ge__', C.__dict__)
-                    elif result == 'eq_only':
-                        self.assertIn('__eq__', C.__dict__)
-                        self.assertNotIn('__lt__', C.__dict__)
-                        self.assertNotIn('__le__', C.__dict__)
-                        self.assertNotIn('__gt__', C.__dict__)
-                        self.assertNotIn('__ge__', C.__dict__)
-                    else:
-                        assert False, f'unknown result {result!r}'
-
-    def test_field_no_default(self):
-        @dataclass
-        class C:
-            x: int = field()
-
-        self.assertEqual(C(5).x, 5)
-
-        with self.assertRaisesRegex(TypeError,
-                                    r"__init__\(\) missing 1 required "
-                                    "positional argument: 'x'"):
-            C()
-
-    def test_field_default(self):
-        default = object()
-        @dataclass
-        class C:
-            x: object = field(default=default)
-
-        self.assertIs(C.x, default)
-        c = C(10)
-        self.assertEqual(c.x, 10)
-
-        # If we delete the instance attribute, we should then see the
-        #  class attribute.
-        del c.x
-        self.assertIs(c.x, default)
-
-        self.assertIs(C().x, default)
-
-    def test_not_in_repr(self):
-        @dataclass
-        class C:
-            x: int = field(repr=False)
-        with self.assertRaises(TypeError):
-            C()
-        c = C(10)
-        self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C()')
-
-        @dataclass
-        class C:
-            x: int = field(repr=False)
-            y: int
-        c = C(10, 20)
-        self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C(y=20)')
-
-    def test_not_in_compare(self):
-        @dataclass
-        class C:
-            x: int = 0
-            y: int = field(compare=False, default=4)
-
-        self.assertEqual(C(), C(0, 20))
-        self.assertEqual(C(1, 10), C(1, 20))
-        self.assertNotEqual(C(3), C(4, 10))
-        self.assertNotEqual(C(3, 10), C(4, 10))
-
-    def test_hash_field_rules(self):
-        # Test all 6 cases of:
-        #  hash=True/False/None
-        #  compare=True/False
-        for (hash_,    compare, result  ) in [
-            (True,     False,   'field' ),
-            (True,     True,    'field' ),
-            (False,    False,   'absent'),
-            (False,    True,    'absent'),
-            (None,     False,   'absent'),
-            (None,     True,    'field' ),
-            ]:
-            with self.subTest(hash=hash_, compare=compare):
-                @dataclass(unsafe_hash=True)
-                class C:
-                    x: int = field(compare=compare, hash=hash_, default=5)
-
-                if result == 'field':
-                    # __hash__ contains the field.
-                    self.assertEqual(hash(C(5)), hash((5,)))
-                elif result == 'absent':
-                    # The field is not present in the hash.
-                    self.assertEqual(hash(C(5)), hash(()))
-                else:
-                    assert False, f'unknown result {result!r}'
-
-    def test_init_false_no_default(self):
-        # If init=False and no default value, then the field won't be
-        #  present in the instance.
-        @dataclass
-        class C:
-            x: int = field(init=False)
-
-        self.assertNotIn('x', C().__dict__)
-
-        @dataclass
-        class C:
-            x: int
-            y: int = 0
-            z: int = field(init=False)
-            t: int = 10
-
-        self.assertNotIn('z', C(0).__dict__)
-        self.assertEqual(vars(C(5)), {'t': 10, 'x': 5, 'y': 0})
-
-    def test_class_marker(self):
-        @dataclass
-        class C:
-            x: int
-            y: str = field(init=False, default=None)
-            z: str = field(repr=False)
-
-        the_fields = fields(C)
-        # the_fields is a tuple of 3 items, each value
-        #  is in __annotations__.
-        self.assertIsInstance(the_fields, tuple)
-        for f in the_fields:
-            self.assertIs(type(f), Field)
-            self.assertIn(f.name, C.__annotations__)
-
-        self.assertEqual(len(the_fields), 3)
-
-        self.assertEqual(the_fields[0].name, 'x')
-        self.assertEqual(the_fields[0].type, int)
-        self.assertFalse(hasattr(C, 'x'))
-        self.assertTrue (the_fields[0].init)
-        self.assertTrue (the_fields[0].repr)
-        self.assertEqual(the_fields[1].name, 'y')
-        self.assertEqual(the_fields[1].type, str)
-        self.assertIsNone(getattr(C, 'y'))
-        self.assertFalse(the_fields[1].init)
-        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.assertTrue (the_fields[2].init)
-        self.assertFalse(the_fields[2].repr)
-
-    def test_field_order(self):
-        @dataclass
-        class B:
-            a: str = 'B:a'
-            b: str = 'B:b'
-            c: str = 'B:c'
-
-        @dataclass
-        class C(B):
-            b: str = 'C:b'
-
-        self.assertEqual([(f.name, f.default) for f in fields(C)],
-                         [('a', 'B:a'),
-                          ('b', 'C:b'),
-                          ('c', 'B:c')])
-
-        @dataclass
-        class D(B):
-            c: str = 'D:c'
-
-        self.assertEqual([(f.name, f.default) for f in fields(D)],
-                         [('a', 'B:a'),
-                          ('b', 'B:b'),
-                          ('c', 'D:c')])
-
-        @dataclass
-        class E(D):
-            a: str = 'E:a'
-            d: str = 'E:d'
-
-        self.assertEqual([(f.name, f.default) for f in fields(E)],
-                         [('a', 'E:a'),
-                          ('b', 'B:b'),
-                          ('c', 'D:c'),
-                          ('d', 'E:d')])
-
-    def test_class_attrs(self):
-        # We only have a class attribute if a default value is
-        #  specified, either directly or via a field with a default.
-        default = object()
-        @dataclass
-        class C:
-            x: int
-            y: int = field(repr=False)
-            z: object = default
-            t: int = field(default=100)
-
-        self.assertFalse(hasattr(C, 'x'))
-        self.assertFalse(hasattr(C, 'y'))
-        self.assertIs   (C.z, default)
-        self.assertEqual(C.t, 100)
-
-    def test_disallowed_mutable_defaults(self):
-        # For the known types, don't allow mutable default values.
-        for typ, empty, non_empty in [(list, [], [1]),
-                                      (dict, {}, {0:1}),
-                                      (set, set(), set([1])),
-                                      ]:
-            with self.subTest(typ=typ):
-                # Can't use a zero-length value.
-                with self.assertRaisesRegex(ValueError,
-                                            f'mutable default {typ} for field '
-                                            'x is not allowed'):
-                    @dataclass
-                    class Point:
-                        x: typ = empty
-
-
-                # Nor a non-zero-length value
-                with self.assertRaisesRegex(ValueError,
-                                            f'mutable default {typ} for field '
-                                            'y is not allowed'):
-                    @dataclass
-                    class Point:
-                        y: typ = non_empty
-
-                # Check subtypes also fail.
-                class Subclass(typ): pass
-
-                with self.assertRaisesRegex(ValueError,
-                                            f"mutable default .*Subclass'>"
-                                            ' for field z is not allowed'
-                                            ):
-                    @dataclass
-                    class Point:
-                        z: typ = Subclass()
-
-                # Because this is a ClassVar, it can be mutable.
-                @dataclass
-                class C:
-                    z: ClassVar[typ] = typ()
-
-                # Because this is a ClassVar, it can be mutable.
-                @dataclass
-                class C:
-                    x: ClassVar[typ] = Subclass()
-
-    def test_deliberately_mutable_defaults(self):
-        # If a mutable default isn't in the known list of
-        #  (list, dict, set), then it's okay.
-        class Mutable:
-            def __init__(self):
-                self.l = []
-
-        @dataclass
-        class C:
-            x: Mutable
-
-        # These 2 instances will share this value of x.
-        lst = Mutable()
-        o1 = C(lst)
-        o2 = C(lst)
-        self.assertEqual(o1, o2)
-        o1.x.l.extend([1, 2])
-        self.assertEqual(o1, o2)
-        self.assertEqual(o1.x.l, [1, 2])
-        self.assertIs(o1.x, o2.x)
-
-    def test_no_options(self):
-        # Call with dataclass().
-        @dataclass()
-        class C:
-            x: int
-
-        self.assertEqual(C(42).x, 42)
-
-    def test_not_tuple(self):
-        # Make sure we can't be compared to a tuple.
-        @dataclass
-        class Point:
-            x: int
-            y: int
-        self.assertNotEqual(Point(1, 2), (1, 2))
-
-        # And that we can't compare to another unrelated dataclass.
-        @dataclass
-        class C:
-            x: int
-            y: int
-        self.assertNotEqual(Point(1, 3), C(1, 3))
-
-    def test_not_other_dataclass(self):
-        # Test that some of the problems with namedtuple don't happen
-        #  here.
-        @dataclass
-        class Point3D:
-            x: int
-            y: int
-            z: int
-
-        @dataclass
-        class Date:
-            year: int
-            month: int
-            day: int
-
-        self.assertNotEqual(Point3D(2017, 6, 3), Date(2017, 6, 3))
-        self.assertNotEqual(Point3D(1, 2, 3), (1, 2, 3))
-
-        # Make sure we can't unpack.
-        with self.assertRaisesRegex(TypeError, 'unpack'):
-            x, y, z = Point3D(4, 5, 6)
-
-        # Make sure another class with the same field names isn't
-        #  equal.
-        @dataclass
-        class Point3Dv1:
-            x: int = 0
-            y: int = 0
-            z: int = 0
-        self.assertNotEqual(Point3D(0, 0, 0), Point3Dv1())
-
-    def test_function_annotations(self):
-        # Some dummy class and instance to use as a default.
-        class F:
-            pass
-        f = F()
-
-        def validate_class(cls):
-            # First, check __annotations__, even though they're not
-            #  function annotations.
-            self.assertEqual(cls.__annotations__['i'], int)
-            self.assertEqual(cls.__annotations__['j'], str)
-            self.assertEqual(cls.__annotations__['k'], F)
-            self.assertEqual(cls.__annotations__['l'], float)
-            self.assertEqual(cls.__annotations__['z'], complex)
-
-            # Verify __init__.
-
-            signature = inspect.signature(cls.__init__)
-            # Check the return type, should be None.
-            self.assertIs(signature.return_annotation, None)
-
-            # Check each parameter.
-            params = iter(signature.parameters.values())
-            param = next(params)
-            # This is testing an internal name, and probably shouldn't be tested.
-            self.assertEqual(param.name, 'self')
-            param = next(params)
-            self.assertEqual(param.name, 'i')
-            self.assertIs   (param.annotation, int)
-            self.assertEqual(param.default, inspect.Parameter.empty)
-            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-            param = next(params)
-            self.assertEqual(param.name, 'j')
-            self.assertIs   (param.annotation, str)
-            self.assertEqual(param.default, inspect.Parameter.empty)
-            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-            param = next(params)
-            self.assertEqual(param.name, 'k')
-            self.assertIs   (param.annotation, F)
-            # Don't test for the default, since it's set to MISSING.
-            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-            param = next(params)
-            self.assertEqual(param.name, 'l')
-            self.assertIs   (param.annotation, float)
-            # Don't test for the default, since it's set to MISSING.
-            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-            self.assertRaises(StopIteration, next, params)
-
-
-        @dataclass
-        class C:
-            i: int
-            j: str
-            k: F = f
-            l: float=field(default=None)
-            z: complex=field(default=3+4j, init=False)
-
-        validate_class(C)
-
-        # Now repeat with __hash__.
-        @dataclass(frozen=True, unsafe_hash=True)
-        class C:
-            i: int
-            j: str
-            k: F = f
-            l: float=field(default=None)
-            z: complex=field(default=3+4j, init=False)
-
-        validate_class(C)
-
-    def test_missing_default(self):
-        # Test that MISSING works the same as a default not being
-        #  specified.
-        @dataclass
-        class C:
-            x: int=field(default=MISSING)
-        with self.assertRaisesRegex(TypeError,
-                                    r'__init__\(\) missing 1 required '
-                                    'positional argument'):
-            C()
-        self.assertNotIn('x', C.__dict__)
-
-        @dataclass
-        class D:
-            x: int
-        with self.assertRaisesRegex(TypeError,
-                                    r'__init__\(\) missing 1 required '
-                                    'positional argument'):
-            D()
-        self.assertNotIn('x', D.__dict__)
-
-    def test_missing_default_factory(self):
-        # Test that MISSING works the same as a default factory not
-        #  being specified (which is really the same as a default not
-        #  being specified, too).
-        @dataclass
-        class C:
-            x: int=field(default_factory=MISSING)
-        with self.assertRaisesRegex(TypeError,
-                                    r'__init__\(\) missing 1 required '
-                                    'positional argument'):
-            C()
-        self.assertNotIn('x', C.__dict__)
-
-        @dataclass
-        class D:
-            x: int=field(default=MISSING, default_factory=MISSING)
-        with self.assertRaisesRegex(TypeError,
-                                    r'__init__\(\) missing 1 required '
-                                    'positional argument'):
-            D()
-        self.assertNotIn('x', D.__dict__)
-
-    def test_missing_repr(self):
-        self.assertIn('MISSING_TYPE object', repr(MISSING))
-
-    def test_dont_include_other_annotations(self):
-        @dataclass
-        class C:
-            i: int
-            def foo(self) -> int:
-                return 4
-            @property
-            def bar(self) -> int:
-                return 5
-        self.assertEqual(list(C.__annotations__), ['i'])
-        self.assertEqual(C(10).foo(), 4)
-        self.assertEqual(C(10).bar, 5)
-        self.assertEqual(C(10).i, 10)
-
-    def test_post_init(self):
-        # Just make sure it gets called
-        @dataclass
-        class C:
-            def __post_init__(self):
-                raise CustomError()
-        with self.assertRaises(CustomError):
-            C()
-
-        @dataclass
-        class C:
-            i: int = 10
-            def __post_init__(self):
-                if self.i == 10:
-                    raise CustomError()
-        with self.assertRaises(CustomError):
-            C()
-        # post-init gets called, but doesn't raise. This is just
-        #  checking that self is used correctly.
-        C(5)
-
-        # If there's not an __init__, then post-init won't get called.
-        @dataclass(init=False)
-        class C:
-            def __post_init__(self):
-                raise CustomError()
-        # Creating the class won't raise
-        C()
-
-        @dataclass
-        class C:
-            x: int = 0
-            def __post_init__(self):
-                self.x *= 2
-        self.assertEqual(C().x, 0)
-        self.assertEqual(C(2).x, 4)
-
-        # Make sure that if we're frozen, post-init can't set
-        #  attributes.
-        @dataclass(frozen=True)
-        class C:
-            x: int = 0
-            def __post_init__(self):
-                self.x *= 2
-        with self.assertRaises(FrozenInstanceError):
-            C()
-
-    def test_post_init_super(self):
-        # Make sure super() post-init isn't called by default.
-        class B:
-            def __post_init__(self):
-                raise CustomError()
-
-        @dataclass
-        class C(B):
-            def __post_init__(self):
-                self.x = 5
-
-        self.assertEqual(C().x, 5)
-
-        # Now call super(), and it will raise.
-        @dataclass
-        class C(B):
-            def __post_init__(self):
-                super().__post_init__()
-
-        with self.assertRaises(CustomError):
-            C()
-
-        # Make sure post-init is called, even if not defined in our
-        #  class.
-        @dataclass
-        class C(B):
-            pass
-
-        with self.assertRaises(CustomError):
-            C()
-
-    def test_post_init_staticmethod(self):
-        flag = False
-        @dataclass
-        class C:
-            x: int
-            y: int
-            @staticmethod
-            def __post_init__():
-                nonlocal flag
-                flag = True
-
-        self.assertFalse(flag)
-        c = C(3, 4)
-        self.assertEqual((c.x, c.y), (3, 4))
-        self.assertTrue(flag)
-
-    def test_post_init_classmethod(self):
-        @dataclass
-        class C:
-            flag = False
-            x: int
-            y: int
-            @classmethod
-            def __post_init__(cls):
-                cls.flag = True
-
-        self.assertFalse(C.flag)
-        c = C(3, 4)
-        self.assertEqual((c.x, c.y), (3, 4))
-        self.assertTrue(C.flag)
-
-    def test_class_var(self):
-        # Make sure ClassVars are ignored in __init__, __repr__, etc.
-        @dataclass
-        class C:
-            x: int
-            y: int = 10
-            z: ClassVar[int] = 1000
-            w: ClassVar[int] = 2000
-            t: ClassVar[int] = 3000
-            s: ClassVar      = 4000
-
-        c = C(5)
-        self.assertEqual(repr(c), 'TestCase.test_class_var.<locals>.C(x=5, y=10)')
-        self.assertEqual(len(fields(C)), 2)                 # We have 2 fields.
-        self.assertEqual(len(C.__annotations__), 6)         # And 4 ClassVars.
-        self.assertEqual(c.z, 1000)
-        self.assertEqual(c.w, 2000)
-        self.assertEqual(c.t, 3000)
-        self.assertEqual(c.s, 4000)
-        C.z += 1
-        self.assertEqual(c.z, 1001)
-        c = C(20)
-        self.assertEqual((c.x, c.y), (20, 10))
-        self.assertEqual(c.z, 1001)
-        self.assertEqual(c.w, 2000)
-        self.assertEqual(c.t, 3000)
-        self.assertEqual(c.s, 4000)
-
-    def test_class_var_no_default(self):
-        # If a ClassVar has no default value, it should not be set on the class.
-        @dataclass
-        class C:
-            x: ClassVar[int]
-
-        self.assertNotIn('x', C.__dict__)
-
-    def test_class_var_default_factory(self):
-        # It makes no sense for a ClassVar to have a default factory. When
-        #  would it be called? Call it yourself, since it's class-wide.
-        with self.assertRaisesRegex(TypeError,
-                                    'cannot have a default factory'):
-            @dataclass
-            class C:
-                x: ClassVar[int] = field(default_factory=int)
-
-            self.assertNotIn('x', C.__dict__)
-
-    def test_class_var_with_default(self):
-        # If a ClassVar has a default value, it should be set on the class.
-        @dataclass
-        class C:
-            x: ClassVar[int] = 10
-        self.assertEqual(C.x, 10)
-
-        @dataclass
-        class C:
-            x: ClassVar[int] = field(default=10)
-        self.assertEqual(C.x, 10)
-
-    def test_class_var_frozen(self):
-        # Make sure ClassVars work even if we're frozen.
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            y: int = 10
-            z: ClassVar[int] = 1000
-            w: ClassVar[int] = 2000
-            t: ClassVar[int] = 3000
-
-        c = C(5)
-        self.assertEqual(repr(C(5)), 'TestCase.test_class_var_frozen.<locals>.C(x=5, y=10)')
-        self.assertEqual(len(fields(C)), 2)                 # We have 2 fields
-        self.assertEqual(len(C.__annotations__), 5)         # And 3 ClassVars
-        self.assertEqual(c.z, 1000)
-        self.assertEqual(c.w, 2000)
-        self.assertEqual(c.t, 3000)
-        # We can still modify the ClassVar, it's only instances that are
-        #  frozen.
-        C.z += 1
-        self.assertEqual(c.z, 1001)
-        c = C(20)
-        self.assertEqual((c.x, c.y), (20, 10))
-        self.assertEqual(c.z, 1001)
-        self.assertEqual(c.w, 2000)
-        self.assertEqual(c.t, 3000)
-
-    def test_init_var_no_default(self):
-        # If an InitVar has no default value, it should not be set on the class.
-        @dataclass
-        class C:
-            x: InitVar[int]
-
-        self.assertNotIn('x', C.__dict__)
-
-    def test_init_var_default_factory(self):
-        # It makes no sense for an InitVar to have a default factory. When
-        #  would it be called? Call it yourself, since it's class-wide.
-        with self.assertRaisesRegex(TypeError,
-                                    'cannot have a default factory'):
-            @dataclass
-            class C:
-                x: InitVar[int] = field(default_factory=int)
-
-            self.assertNotIn('x', C.__dict__)
-
-    def test_init_var_with_default(self):
-        # If an InitVar has a default value, it should be set on the class.
-        @dataclass
-        class C:
-            x: InitVar[int] = 10
-        self.assertEqual(C.x, 10)
-
-        @dataclass
-        class C:
-            x: InitVar[int] = field(default=10)
-        self.assertEqual(C.x, 10)
-
-    def test_init_var(self):
-        @dataclass
-        class C:
-            x: int = None
-            init_param: InitVar[int] = None
-
-            def __post_init__(self, init_param):
-                if self.x is None:
-                    self.x = init_param*2
-
-        c = C(init_param=10)
-        self.assertEqual(c.x, 20)
-
-    def test_init_var_preserve_type(self):
-        self.assertEqual(InitVar[int].type, int)
-
-        # Make sure the repr is correct.
-        self.assertEqual(repr(InitVar[int]), 'dataclasses.InitVar[int]')
-        self.assertEqual(repr(InitVar[List[int]]),
-                         'dataclasses.InitVar[typing.List[int]]')
-        self.assertEqual(repr(InitVar[list[int]]),
-                         'dataclasses.InitVar[list[int]]')
-        self.assertEqual(repr(InitVar[int|str]),
-                         'dataclasses.InitVar[int | str]')
-
-    def test_init_var_inheritance(self):
-        # Note that this deliberately tests that a dataclass need not
-        #  have a __post_init__ function if it has an InitVar field.
-        #  It could just be used in a derived class, as shown here.
-        @dataclass
-        class Base:
-            x: int
-            init_base: InitVar[int]
-
-        # We can instantiate by passing the InitVar, even though
-        #  it's not used.
-        b = Base(0, 10)
-        self.assertEqual(vars(b), {'x': 0})
-
-        @dataclass
-        class C(Base):
-            y: int
-            init_derived: InitVar[int]
-
-            def __post_init__(self, init_base, init_derived):
-                self.x = self.x + init_base
-                self.y = self.y + init_derived
-
-        c = C(10, 11, 50, 51)
-        self.assertEqual(vars(c), {'x': 21, 'y': 101})
-
-    def test_default_factory(self):
-        # Test a factory that returns a new list.
-        @dataclass
-        class C:
-            x: int
-            y: list = field(default_factory=list)
-
-        c0 = C(3)
-        c1 = C(3)
-        self.assertEqual(c0.x, 3)
-        self.assertEqual(c0.y, [])
-        self.assertEqual(c0, c1)
-        self.assertIsNot(c0.y, c1.y)
-        self.assertEqual(astuple(C(5, [1])), (5, [1]))
-
-        # Test a factory that returns a shared list.
-        l = []
-        @dataclass
-        class C:
-            x: int
-            y: list = field(default_factory=lambda: l)
-
-        c0 = C(3)
-        c1 = C(3)
-        self.assertEqual(c0.x, 3)
-        self.assertEqual(c0.y, [])
-        self.assertEqual(c0, c1)
-        self.assertIs(c0.y, c1.y)
-        self.assertEqual(astuple(C(5, [1])), (5, [1]))
-
-        # Test various other field flags.
-        # repr
-        @dataclass
-        class C:
-            x: list = field(default_factory=list, repr=False)
-        self.assertEqual(repr(C()), 'TestCase.test_default_factory.<locals>.C()')
-        self.assertEqual(C().x, [])
-
-        # hash
-        @dataclass(unsafe_hash=True)
-        class C:
-            x: list = field(default_factory=list, hash=False)
-        self.assertEqual(astuple(C()), ([],))
-        self.assertEqual(hash(C()), hash(()))
-
-        # init (see also test_default_factory_with_no_init)
-        @dataclass
-        class C:
-            x: list = field(default_factory=list, init=False)
-        self.assertEqual(astuple(C()), ([],))
-
-        # compare
-        @dataclass
-        class C:
-            x: list = field(default_factory=list, compare=False)
-        self.assertEqual(C(), C([1]))
-
-    def test_default_factory_with_no_init(self):
-        # We need a factory with a side effect.
-        factory = Mock()
-
-        @dataclass
-        class C:
-            x: list = field(default_factory=factory, init=False)
-
-        # Make sure the default factory is called for each new instance.
-        C().x
-        self.assertEqual(factory.call_count, 1)
-        C().x
-        self.assertEqual(factory.call_count, 2)
-
-    def test_default_factory_not_called_if_value_given(self):
-        # We need a factory that we can test if it's been called.
-        factory = Mock()
-
-        @dataclass
-        class C:
-            x: int = field(default_factory=factory)
-
-        # Make sure that if a field has a default factory function,
-        #  it's not called if a value is specified.
-        C().x
-        self.assertEqual(factory.call_count, 1)
-        self.assertEqual(C(10).x, 10)
-        self.assertEqual(factory.call_count, 1)
-        C().x
-        self.assertEqual(factory.call_count, 2)
-
-    def test_default_factory_derived(self):
-        # See bpo-32896.
-        @dataclass
-        class Foo:
-            x: dict = field(default_factory=dict)
-
-        @dataclass
-        class Bar(Foo):
-            y: int = 1
-
-        self.assertEqual(Foo().x, {})
-        self.assertEqual(Bar().x, {})
-        self.assertEqual(Bar().y, 1)
-
-        @dataclass
-        class Baz(Foo):
-            pass
-        self.assertEqual(Baz().x, {})
-
-    def test_intermediate_non_dataclass(self):
-        # Test that an intermediate class that defines
-        #  annotations does not define fields.
-
-        @dataclass
-        class A:
-            x: int
-
-        class B(A):
-            y: int
-
-        @dataclass
-        class C(B):
-            z: int
-
-        c = C(1, 3)
-        self.assertEqual((c.x, c.z), (1, 3))
-
-        # .y was not initialized.
-        with self.assertRaisesRegex(AttributeError,
-                                    'object has no attribute'):
-            c.y
-
-        # And if we again derive a non-dataclass, no fields are added.
-        class D(C):
-            t: int
-        d = D(4, 5)
-        self.assertEqual((d.x, d.z), (4, 5))
-
-    def test_classvar_default_factory(self):
-        # It's an error for a ClassVar to have a factory function.
-        with self.assertRaisesRegex(TypeError,
-                                    'cannot have a default factory'):
-            @dataclass
-            class C:
-                x: ClassVar[int] = field(default_factory=int)
-
-    def test_is_dataclass(self):
-        class NotDataClass:
-            pass
-
-        self.assertFalse(is_dataclass(0))
-        self.assertFalse(is_dataclass(int))
-        self.assertFalse(is_dataclass(NotDataClass))
-        self.assertFalse(is_dataclass(NotDataClass()))
-
-        @dataclass
-        class C:
-            x: int
-
-        @dataclass
-        class D:
-            d: C
-            e: int
-
-        c = C(10)
-        d = D(c, 4)
-
-        self.assertTrue(is_dataclass(C))
-        self.assertTrue(is_dataclass(c))
-        self.assertFalse(is_dataclass(c.x))
-        self.assertTrue(is_dataclass(d.d))
-        self.assertFalse(is_dataclass(d.e))
-
-    def test_is_dataclass_when_getattr_always_returns(self):
-        # See bpo-37868.
-        class A:
-            def __getattr__(self, key):
-                return 0
-        self.assertFalse(is_dataclass(A))
-        a = A()
-
-        # Also test for an instance attribute.
-        class B:
-            pass
-        b = B()
-        b.__dataclass_fields__ = []
-
-        for obj in a, b:
-            with self.subTest(obj=obj):
-                self.assertFalse(is_dataclass(obj))
-
-                # Indirect tests for _is_dataclass_instance().
-                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
-                    asdict(obj)
-                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
-                    astuple(obj)
-                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
-                    replace(obj, x=0)
-
-    def test_is_dataclass_genericalias(self):
-        @dataclass
-        class A(types.GenericAlias):
-            origin: type
-            args: type
-        self.assertTrue(is_dataclass(A))
-        a = A(list, int)
-        self.assertTrue(is_dataclass(type(a)))
-        self.assertTrue(is_dataclass(a))
-
-
-    def test_helper_fields_with_class_instance(self):
-        # Check that we can call fields() on either a class or instance,
-        #  and get back the same thing.
-        @dataclass
-        class C:
-            x: int
-            y: float
-
-        self.assertEqual(fields(C), fields(C(0, 0.0)))
-
-    def test_helper_fields_exception(self):
-        # Check that TypeError is raised if not passed a dataclass or
-        #  instance.
-        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
-            fields(0)
-
-        class C: pass
-        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
-            fields(C)
-        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
-            fields(C())
-
-    def test_helper_asdict(self):
-        # Basic tests for asdict(), it should return a new dictionary.
-        @dataclass
-        class C:
-            x: int
-            y: int
-        c = C(1, 2)
-
-        self.assertEqual(asdict(c), {'x': 1, 'y': 2})
-        self.assertEqual(asdict(c), asdict(c))
-        self.assertIsNot(asdict(c), asdict(c))
-        c.x = 42
-        self.assertEqual(asdict(c), {'x': 42, 'y': 2})
-        self.assertIs(type(asdict(c)), dict)
-
-    def test_helper_asdict_raises_on_classes(self):
-        # asdict() should raise on a class object.
-        @dataclass
-        class C:
-            x: int
-            y: int
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            asdict(C)
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            asdict(int)
-
-    def test_helper_asdict_copy_values(self):
-        @dataclass
-        class C:
-            x: int
-            y: List[int] = field(default_factory=list)
-        initial = []
-        c = C(1, initial)
-        d = asdict(c)
-        self.assertEqual(d['y'], initial)
-        self.assertIsNot(d['y'], initial)
-        c = C(1)
-        d = asdict(c)
-        d['y'].append(1)
-        self.assertEqual(c.y, [])
-
-    def test_helper_asdict_nested(self):
-        @dataclass
-        class UserId:
-            token: int
-            group: int
-        @dataclass
-        class User:
-            name: str
-            id: UserId
-        u = User('Joe', UserId(123, 1))
-        d = asdict(u)
-        self.assertEqual(d, {'name': 'Joe', 'id': {'token': 123, 'group': 1}})
-        self.assertIsNot(asdict(u), asdict(u))
-        u.id.group = 2
-        self.assertEqual(asdict(u), {'name': 'Joe',
-                                     'id': {'token': 123, 'group': 2}})
-
-    def test_helper_asdict_builtin_containers(self):
-        @dataclass
-        class User:
-            name: str
-            id: int
-        @dataclass
-        class GroupList:
-            id: int
-            users: List[User]
-        @dataclass
-        class GroupTuple:
-            id: int
-            users: Tuple[User, ...]
-        @dataclass
-        class GroupDict:
-            id: int
-            users: Dict[str, User]
-        a = User('Alice', 1)
-        b = User('Bob', 2)
-        gl = GroupList(0, [a, b])
-        gt = GroupTuple(0, (a, b))
-        gd = GroupDict(0, {'first': a, 'second': b})
-        self.assertEqual(asdict(gl), {'id': 0, 'users': [{'name': 'Alice', 'id': 1},
-                                                         {'name': 'Bob', 'id': 2}]})
-        self.assertEqual(asdict(gt), {'id': 0, 'users': ({'name': 'Alice', 'id': 1},
-                                                         {'name': 'Bob', 'id': 2})})
-        self.assertEqual(asdict(gd), {'id': 0, 'users': {'first': {'name': 'Alice', 'id': 1},
-                                                         'second': {'name': 'Bob', 'id': 2}}})
-
-    def test_helper_asdict_builtin_object_containers(self):
-        @dataclass
-        class Child:
-            d: object
-
-        @dataclass
-        class Parent:
-            child: Child
-
-        self.assertEqual(asdict(Parent(Child([1]))), {'child': {'d': [1]}})
-        self.assertEqual(asdict(Parent(Child({1: 2}))), {'child': {'d': {1: 2}}})
-
-    def test_helper_asdict_factory(self):
-        @dataclass
-        class C:
-            x: int
-            y: int
-        c = C(1, 2)
-        d = asdict(c, dict_factory=OrderedDict)
-        self.assertEqual(d, OrderedDict([('x', 1), ('y', 2)]))
-        self.assertIsNot(d, asdict(c, dict_factory=OrderedDict))
-        c.x = 42
-        d = asdict(c, dict_factory=OrderedDict)
-        self.assertEqual(d, OrderedDict([('x', 42), ('y', 2)]))
-        self.assertIs(type(d), OrderedDict)
-
-    def test_helper_asdict_namedtuple(self):
-        T = namedtuple('T', 'a b c')
-        @dataclass
-        class C:
-            x: str
-            y: T
-        c = C('outer', T(1, C('inner', T(11, 12, 13)), 2))
-
-        d = asdict(c)
-        self.assertEqual(d, {'x': 'outer',
-                             'y': T(1,
-                                    {'x': 'inner',
-                                     'y': T(11, 12, 13)},
-                                    2),
-                             }
-                         )
-
-        # Now with a dict_factory.  OrderedDict is convenient, but
-        # since it compares to dicts, we also need to have separate
-        # assertIs tests.
-        d = asdict(c, dict_factory=OrderedDict)
-        self.assertEqual(d, {'x': 'outer',
-                             'y': T(1,
-                                    {'x': 'inner',
-                                     'y': T(11, 12, 13)},
-                                    2),
-                             }
-                         )
-
-        # Make sure that the returned dicts are actually OrderedDicts.
-        self.assertIs(type(d), OrderedDict)
-        self.assertIs(type(d['y'][1]), OrderedDict)
-
-    def test_helper_asdict_namedtuple_key(self):
-        # Ensure that a field that contains a dict which has a
-        # namedtuple as a key works with asdict().
-
-        @dataclass
-        class C:
-            f: dict
-        T = namedtuple('T', 'a')
-
-        c = C({T('an a'): 0})
-
-        self.assertEqual(asdict(c), {'f': {T(a='an a'): 0}})
-
-    def test_helper_asdict_namedtuple_derived(self):
-        class T(namedtuple('Tbase', 'a')):
-            def my_a(self):
-                return self.a
-
-        @dataclass
-        class C:
-            f: T
-
-        t = T(6)
-        c = C(t)
-
-        d = asdict(c)
-        self.assertEqual(d, {'f': T(a=6)})
-        # Make sure that t has been copied, not used directly.
-        self.assertIsNot(d['f'], t)
-        self.assertEqual(d['f'].my_a(), 6)
-
-    def test_helper_astuple(self):
-        # Basic tests for astuple(), it should return a new tuple.
-        @dataclass
-        class C:
-            x: int
-            y: int = 0
-        c = C(1)
-
-        self.assertEqual(astuple(c), (1, 0))
-        self.assertEqual(astuple(c), astuple(c))
-        self.assertIsNot(astuple(c), astuple(c))
-        c.y = 42
-        self.assertEqual(astuple(c), (1, 42))
-        self.assertIs(type(astuple(c)), tuple)
-
-    def test_helper_astuple_raises_on_classes(self):
-        # astuple() should raise on a class object.
-        @dataclass
-        class C:
-            x: int
-            y: int
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            astuple(C)
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            astuple(int)
-
-    def test_helper_astuple_copy_values(self):
-        @dataclass
-        class C:
-            x: int
-            y: List[int] = field(default_factory=list)
-        initial = []
-        c = C(1, initial)
-        t = astuple(c)
-        self.assertEqual(t[1], initial)
-        self.assertIsNot(t[1], initial)
-        c = C(1)
-        t = astuple(c)
-        t[1].append(1)
-        self.assertEqual(c.y, [])
-
-    def test_helper_astuple_nested(self):
-        @dataclass
-        class UserId:
-            token: int
-            group: int
-        @dataclass
-        class User:
-            name: str
-            id: UserId
-        u = User('Joe', UserId(123, 1))
-        t = astuple(u)
-        self.assertEqual(t, ('Joe', (123, 1)))
-        self.assertIsNot(astuple(u), astuple(u))
-        u.id.group = 2
-        self.assertEqual(astuple(u), ('Joe', (123, 2)))
-
-    def test_helper_astuple_builtin_containers(self):
-        @dataclass
-        class User:
-            name: str
-            id: int
-        @dataclass
-        class GroupList:
-            id: int
-            users: List[User]
-        @dataclass
-        class GroupTuple:
-            id: int
-            users: Tuple[User, ...]
-        @dataclass
-        class GroupDict:
-            id: int
-            users: Dict[str, User]
-        a = User('Alice', 1)
-        b = User('Bob', 2)
-        gl = GroupList(0, [a, b])
-        gt = GroupTuple(0, (a, b))
-        gd = GroupDict(0, {'first': a, 'second': b})
-        self.assertEqual(astuple(gl), (0, [('Alice', 1), ('Bob', 2)]))
-        self.assertEqual(astuple(gt), (0, (('Alice', 1), ('Bob', 2))))
-        self.assertEqual(astuple(gd), (0, {'first': ('Alice', 1), 'second': ('Bob', 2)}))
-
-    def test_helper_astuple_builtin_object_containers(self):
-        @dataclass
-        class Child:
-            d: object
-
-        @dataclass
-        class Parent:
-            child: Child
-
-        self.assertEqual(astuple(Parent(Child([1]))), (([1],),))
-        self.assertEqual(astuple(Parent(Child({1: 2}))), (({1: 2},),))
-
-    def test_helper_astuple_factory(self):
-        @dataclass
-        class C:
-            x: int
-            y: int
-        NT = namedtuple('NT', 'x y')
-        def nt(lst):
-            return NT(*lst)
-        c = C(1, 2)
-        t = astuple(c, tuple_factory=nt)
-        self.assertEqual(t, NT(1, 2))
-        self.assertIsNot(t, astuple(c, tuple_factory=nt))
-        c.x = 42
-        t = astuple(c, tuple_factory=nt)
-        self.assertEqual(t, NT(42, 2))
-        self.assertIs(type(t), NT)
-
-    def test_helper_astuple_namedtuple(self):
-        T = namedtuple('T', 'a b c')
-        @dataclass
-        class C:
-            x: str
-            y: T
-        c = C('outer', T(1, C('inner', T(11, 12, 13)), 2))
-
-        t = astuple(c)
-        self.assertEqual(t, ('outer', T(1, ('inner', (11, 12, 13)), 2)))
-
-        # Now, using a tuple_factory.  list is convenient here.
-        t = astuple(c, tuple_factory=list)
-        self.assertEqual(t, ['outer', T(1, ['inner', T(11, 12, 13)], 2)])
-
-    def test_dynamic_class_creation(self):
-        cls_dict = {'__annotations__': {'x': int, 'y': int},
-                    }
-
-        # Create the class.
-        cls = type('C', (), cls_dict)
-
-        # Make it a dataclass.
-        cls1 = dataclass(cls)
-
-        self.assertEqual(cls1, cls)
-        self.assertEqual(asdict(cls(1, 2)), {'x': 1, 'y': 2})
-
-    def test_dynamic_class_creation_using_field(self):
-        cls_dict = {'__annotations__': {'x': int, 'y': int},
-                    'y': field(default=5),
-                    }
-
-        # Create the class.
-        cls = type('C', (), cls_dict)
-
-        # Make it a dataclass.
-        cls1 = dataclass(cls)
-
-        self.assertEqual(cls1, cls)
-        self.assertEqual(asdict(cls1(1)), {'x': 1, 'y': 5})
-
-    def test_init_in_order(self):
-        @dataclass
-        class C:
-            a: int
-            b: int = field()
-            c: list = field(default_factory=list, init=False)
-            d: list = field(default_factory=list)
-            e: int = field(default=4, init=False)
-            f: int = 4
-
-        calls = []
-        def setattr(self, name, value):
-            calls.append((name, value))
-
-        C.__setattr__ = setattr
-        c = C(0, 1)
-        self.assertEqual(('a', 0), calls[0])
-        self.assertEqual(('b', 1), calls[1])
-        self.assertEqual(('c', []), calls[2])
-        self.assertEqual(('d', []), calls[3])
-        self.assertNotIn(('e', 4), calls)
-        self.assertEqual(('f', 4), calls[4])
-
-    def test_items_in_dicts(self):
-        @dataclass
-        class C:
-            a: int
-            b: list = field(default_factory=list, init=False)
-            c: list = field(default_factory=list)
-            d: int = field(default=4, init=False)
-            e: int = 0
-
-        c = C(0)
-        # Class dict
-        self.assertNotIn('a', C.__dict__)
-        self.assertNotIn('b', C.__dict__)
-        self.assertNotIn('c', C.__dict__)
-        self.assertIn('d', C.__dict__)
-        self.assertEqual(C.d, 4)
-        self.assertIn('e', C.__dict__)
-        self.assertEqual(C.e, 0)
-        # Instance dict
-        self.assertIn('a', c.__dict__)
-        self.assertEqual(c.a, 0)
-        self.assertIn('b', c.__dict__)
-        self.assertEqual(c.b, [])
-        self.assertIn('c', c.__dict__)
-        self.assertEqual(c.c, [])
-        self.assertNotIn('d', c.__dict__)
-        self.assertIn('e', c.__dict__)
-        self.assertEqual(c.e, 0)
-
-    def test_alternate_classmethod_constructor(self):
-        # Since __post_init__ can't take params, use a classmethod
-        #  alternate constructor.  This is mostly an example to show
-        #  how to use this technique.
-        @dataclass
-        class C:
-            x: int
-            @classmethod
-            def from_file(cls, filename):
-                # In a real example, create a new instance
-                #  and populate 'x' from contents of a file.
-                value_in_file = 20
-                return cls(value_in_file)
-
-        self.assertEqual(C.from_file('filename').x, 20)
-
-    def test_field_metadata_default(self):
-        # Make sure the default metadata is read-only and of
-        #  zero length.
-        @dataclass
-        class C:
-            i: int
-
-        self.assertFalse(fields(C)[0].metadata)
-        self.assertEqual(len(fields(C)[0].metadata), 0)
-        with self.assertRaisesRegex(TypeError,
-                                    'does not support item assignment'):
-            fields(C)[0].metadata['test'] = 3
-
-    def test_field_metadata_mapping(self):
-        # Make sure only a mapping can be passed as metadata
-        #  zero length.
-        with self.assertRaises(TypeError):
-            @dataclass
-            class C:
-                i: int = field(metadata=0)
-
-        # Make sure an empty dict works.
-        d = {}
-        @dataclass
-        class C:
-            i: int = field(metadata=d)
-        self.assertFalse(fields(C)[0].metadata)
-        self.assertEqual(len(fields(C)[0].metadata), 0)
-        # Update should work (see bpo-35960).
-        d['foo'] = 1
-        self.assertEqual(len(fields(C)[0].metadata), 1)
-        self.assertEqual(fields(C)[0].metadata['foo'], 1)
-        with self.assertRaisesRegex(TypeError,
-                                    'does not support item assignment'):
-            fields(C)[0].metadata['test'] = 3
-
-        # Make sure a non-empty dict works.
-        d = {'test': 10, 'bar': '42', 3: 'three'}
-        @dataclass
-        class C:
-            i: int = field(metadata=d)
-        self.assertEqual(len(fields(C)[0].metadata), 3)
-        self.assertEqual(fields(C)[0].metadata['test'], 10)
-        self.assertEqual(fields(C)[0].metadata['bar'], '42')
-        self.assertEqual(fields(C)[0].metadata[3], 'three')
-        # Update should work.
-        d['foo'] = 1
-        self.assertEqual(len(fields(C)[0].metadata), 4)
-        self.assertEqual(fields(C)[0].metadata['foo'], 1)
-        with self.assertRaises(KeyError):
-            # Non-existent key.
-            fields(C)[0].metadata['baz']
-        with self.assertRaisesRegex(TypeError,
-                                    'does not support item assignment'):
-            fields(C)[0].metadata['test'] = 3
-
-    def test_field_metadata_custom_mapping(self):
-        # Try a custom mapping.
-        class SimpleNameSpace:
-            def __init__(self, **kw):
-                self.__dict__.update(kw)
-
-            def __getitem__(self, item):
-                if item == 'xyzzy':
-                    return 'plugh'
-                return getattr(self, item)
-
-            def __len__(self):
-                return self.__dict__.__len__()
-
-        @dataclass
-        class C:
-            i: int = field(metadata=SimpleNameSpace(a=10))
-
-        self.assertEqual(len(fields(C)[0].metadata), 1)
-        self.assertEqual(fields(C)[0].metadata['a'], 10)
-        with self.assertRaises(AttributeError):
-            fields(C)[0].metadata['b']
-        # Make sure we're still talking to our custom mapping.
-        self.assertEqual(fields(C)[0].metadata['xyzzy'], 'plugh')
-
-    def test_generic_dataclasses(self):
-        T = TypeVar('T')
-
-        @dataclass
-        class LabeledBox(Generic[T]):
-            content: T
-            label: str = '<unknown>'
-
-        box = LabeledBox(42)
-        self.assertEqual(box.content, 42)
-        self.assertEqual(box.label, '<unknown>')
-
-        # Subscripting the resulting class should work, etc.
-        Alias = List[LabeledBox[int]]
-
-    def test_generic_extending(self):
-        S = TypeVar('S')
-        T = TypeVar('T')
-
-        @dataclass
-        class Base(Generic[T, S]):
-            x: T
-            y: S
-
-        @dataclass
-        class DataDerived(Base[int, T]):
-            new_field: str
-        Alias = DataDerived[str]
-        c = Alias(0, 'test1', 'test2')
-        self.assertEqual(astuple(c), (0, 'test1', 'test2'))
-
-        class NonDataDerived(Base[int, T]):
-            def new_method(self):
-                return self.y
-        Alias = NonDataDerived[float]
-        c = Alias(10, 1.0)
-        self.assertEqual(c.new_method(), 1.0)
-
-    def test_generic_dynamic(self):
-        T = TypeVar('T')
-
-        @dataclass
-        class Parent(Generic[T]):
-            x: T
-        Child = make_dataclass('Child', [('y', T), ('z', Optional[T], None)],
-                               bases=(Parent[int], Generic[T]), namespace={'other': 42})
-        self.assertIs(Child[int](1, 2).z, None)
-        self.assertEqual(Child[int](1, 2, 3).z, 3)
-        self.assertEqual(Child[int](1, 2, 3).other, 42)
-        # Check that type aliases work correctly.
-        Alias = Child[T]
-        self.assertEqual(Alias[int](1, 2).x, 1)
-        # Check MRO resolution.
-        self.assertEqual(Child.__mro__, (Child, Parent, Generic, object))
-
-    def test_dataclasses_pickleable(self):
-        global P, Q, R
-        @dataclass
-        class P:
-            x: int
-            y: int = 0
-        @dataclass
-        class Q:
-            x: int
-            y: int = field(default=0, init=False)
-        @dataclass
-        class R:
-            x: int
-            y: List[int] = field(default_factory=list)
-        q = Q(1)
-        q.y = 2
-        samples = [P(1), P(1, 2), Q(1), q, R(1), R(1, [2, 3, 4])]
-        for sample in samples:
-            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                with self.subTest(sample=sample, proto=proto):
-                    new_sample = pickle.loads(pickle.dumps(sample, proto))
-                    self.assertEqual(sample.x, new_sample.x)
-                    self.assertEqual(sample.y, new_sample.y)
-                    self.assertIsNot(sample, new_sample)
-                    new_sample.x = 42
-                    another_new_sample = pickle.loads(pickle.dumps(new_sample, proto))
-                    self.assertEqual(new_sample.x, another_new_sample.x)
-                    self.assertEqual(sample.y, another_new_sample.y)
-
-    def test_dataclasses_qualnames(self):
-        @dataclass(order=True, unsafe_hash=True, frozen=True)
-        class A:
-            x: int
-            y: int
-
-        self.assertEqual(A.__init__.__name__, "__init__")
-        for function in (
-            '__eq__',
-            '__lt__',
-            '__le__',
-            '__gt__',
-            '__ge__',
-            '__hash__',
-            '__init__',
-            '__repr__',
-            '__setattr__',
-            '__delattr__',
-        ):
-            self.assertEqual(getattr(A, function).__qualname__, f"TestCase.test_dataclasses_qualnames.<locals>.A.{function}")
-
-        with self.assertRaisesRegex(TypeError, r"A\.__init__\(\) missing"):
-            A()
-
-
-class TestFieldNoAnnotation(unittest.TestCase):
-    def test_field_without_annotation(self):
-        with self.assertRaisesRegex(TypeError,
-                                    "'f' is a field but has no type annotation"):
-            @dataclass
-            class C:
-                f = field()
-
-    def test_field_without_annotation_but_annotation_in_base(self):
-        @dataclass
-        class B:
-            f: int
-
-        with self.assertRaisesRegex(TypeError,
-                                    "'f' is a field but has no type annotation"):
-            # This is still an error: make sure we don't pick up the
-            #  type annotation in the base class.
-            @dataclass
-            class C(B):
-                f = field()
-
-    def test_field_without_annotation_but_annotation_in_base_not_dataclass(self):
-        # Same test, but with the base class not a dataclass.
-        class B:
-            f: int
-
-        with self.assertRaisesRegex(TypeError,
-                                    "'f' is a field but has no type annotation"):
-            # This is still an error: make sure we don't pick up the
-            #  type annotation in the base class.
-            @dataclass
-            class C(B):
-                f = field()
-
-
-class TestDocString(unittest.TestCase):
-    def assertDocStrEqual(self, a, b):
-        # Because 3.6 and 3.7 differ in how inspect.signature work
-        #  (see bpo #32108), for the time being just compare them with
-        #  whitespace stripped.
-        self.assertEqual(a.replace(' ', ''), b.replace(' ', ''))
-
-    def test_existing_docstring_not_overridden(self):
-        @dataclass
-        class C:
-            """Lorem ipsum"""
-            x: int
-
-        self.assertEqual(C.__doc__, "Lorem ipsum")
-
-    def test_docstring_no_fields(self):
-        @dataclass
-        class C:
-            pass
-
-        self.assertDocStrEqual(C.__doc__, "C()")
-
-    def test_docstring_one_field(self):
-        @dataclass
-        class C:
-            x: int
-
-        self.assertDocStrEqual(C.__doc__, "C(x:int)")
-
-    def test_docstring_two_fields(self):
-        @dataclass
-        class C:
-            x: int
-            y: int
-
-        self.assertDocStrEqual(C.__doc__, "C(x:int, y:int)")
-
-    def test_docstring_three_fields(self):
-        @dataclass
-        class C:
-            x: int
-            y: int
-            z: str
-
-        self.assertDocStrEqual(C.__doc__, "C(x:int, y:int, z:str)")
-
-    def test_docstring_one_field_with_default(self):
-        @dataclass
-        class C:
-            x: int = 3
-
-        self.assertDocStrEqual(C.__doc__, "C(x:int=3)")
-
-    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)")
-
-    def test_docstring_list_field(self):
-        @dataclass
-        class C:
-            x: List[int]
-
-        self.assertDocStrEqual(C.__doc__, "C(x:List[int])")
-
-    def test_docstring_list_field_with_default_factory(self):
-        @dataclass
-        class C:
-            x: List[int] = field(default_factory=list)
-
-        self.assertDocStrEqual(C.__doc__, "C(x:List[int]=<factory>)")
-
-    def test_docstring_deque_field(self):
-        @dataclass
-        class C:
-            x: deque
-
-        self.assertDocStrEqual(C.__doc__, "C(x:collections.deque)")
-
-    def test_docstring_deque_field_with_default_factory(self):
-        @dataclass
-        class C:
-            x: deque = field(default_factory=deque)
-
-        self.assertDocStrEqual(C.__doc__, "C(x:collections.deque=<factory>)")
-
-
-class TestInit(unittest.TestCase):
-    def test_base_has_init(self):
-        class B:
-            def __init__(self):
-                self.z = 100
-                pass
-
-        # Make sure that declaring this class doesn't raise an error.
-        #  The issue is that we can't override __init__ in our class,
-        #  but it should be okay to add __init__ to us if our base has
-        #  an __init__.
-        @dataclass
-        class C(B):
-            x: int = 0
-        c = C(10)
-        self.assertEqual(c.x, 10)
-        self.assertNotIn('z', vars(c))
-
-        # Make sure that if we don't add an init, the base __init__
-        #  gets called.
-        @dataclass(init=False)
-        class C(B):
-            x: int = 10
-        c = C()
-        self.assertEqual(c.x, 10)
-        self.assertEqual(c.z, 100)
-
-    def test_no_init(self):
-        dataclass(init=False)
-        class C:
-            i: int = 0
-        self.assertEqual(C().i, 0)
-
-        dataclass(init=False)
-        class C:
-            i: int = 2
-            def __init__(self):
-                self.i = 3
-        self.assertEqual(C().i, 3)
-
-    def test_overwriting_init(self):
-        # If the class has __init__, use it no matter the value of
-        #  init=.
-
-        @dataclass
-        class C:
-            x: int
-            def __init__(self, x):
-                self.x = 2 * x
-        self.assertEqual(C(3).x, 6)
-
-        @dataclass(init=True)
-        class C:
-            x: int
-            def __init__(self, x):
-                self.x = 2 * x
-        self.assertEqual(C(4).x, 8)
-
-        @dataclass(init=False)
-        class C:
-            x: int
-            def __init__(self, x):
-                self.x = 2 * x
-        self.assertEqual(C(5).x, 10)
-
-    def test_inherit_from_protocol(self):
-        # Dataclasses inheriting from protocol should preserve their own `__init__`.
-        # See bpo-45081.
-
-        class P(Protocol):
-            a: int
-
-        @dataclass
-        class C(P):
-            a: int
-
-        self.assertEqual(C(5).a, 5)
-
-        @dataclass
-        class D(P):
-            def __init__(self, a):
-                self.a = a * 2
-
-        self.assertEqual(D(5).a, 10)
-
-
-class TestRepr(unittest.TestCase):
-    def test_repr(self):
-        @dataclass
-        class B:
-            x: int
-
-        @dataclass
-        class C(B):
-            y: int = 10
-
-        o = C(4)
-        self.assertEqual(repr(o), 'TestRepr.test_repr.<locals>.C(x=4, y=10)')
-
-        @dataclass
-        class D(C):
-            x: int = 20
-        self.assertEqual(repr(D()), 'TestRepr.test_repr.<locals>.D(x=20, y=10)')
-
-        @dataclass
-        class C:
-            @dataclass
-            class D:
-                i: int
-            @dataclass
-            class E:
-                pass
-        self.assertEqual(repr(C.D(0)), 'TestRepr.test_repr.<locals>.C.D(i=0)')
-        self.assertEqual(repr(C.E()), 'TestRepr.test_repr.<locals>.C.E()')
-
-    def test_no_repr(self):
-        # Test a class with no __repr__ and repr=False.
-        @dataclass(repr=False)
-        class C:
-            x: int
-        self.assertIn(f'{__name__}.TestRepr.test_no_repr.<locals>.C object at',
-                      repr(C(3)))
-
-        # Test a class with a __repr__ and repr=False.
-        @dataclass(repr=False)
-        class C:
-            x: int
-            def __repr__(self):
-                return 'C-class'
-        self.assertEqual(repr(C(3)), 'C-class')
-
-    def test_overwriting_repr(self):
-        # If the class has __repr__, use it no matter the value of
-        #  repr=.
-
-        @dataclass
-        class C:
-            x: int
-            def __repr__(self):
-                return 'x'
-        self.assertEqual(repr(C(0)), 'x')
-
-        @dataclass(repr=True)
-        class C:
-            x: int
-            def __repr__(self):
-                return 'x'
-        self.assertEqual(repr(C(0)), 'x')
-
-        @dataclass(repr=False)
-        class C:
-            x: int
-            def __repr__(self):
-                return 'x'
-        self.assertEqual(repr(C(0)), 'x')
-
-
-class TestEq(unittest.TestCase):
-    def test_no_eq(self):
-        # Test a class with no __eq__ and eq=False.
-        @dataclass(eq=False)
-        class C:
-            x: int
-        self.assertNotEqual(C(0), C(0))
-        c = C(3)
-        self.assertEqual(c, c)
-
-        # Test a class with an __eq__ and eq=False.
-        @dataclass(eq=False)
-        class C:
-            x: int
-            def __eq__(self, other):
-                return other == 10
-        self.assertEqual(C(3), 10)
-
-    def test_overwriting_eq(self):
-        # If the class has __eq__, use it no matter the value of
-        #  eq=.
-
-        @dataclass
-        class C:
-            x: int
-            def __eq__(self, other):
-                return other == 3
-        self.assertEqual(C(1), 3)
-        self.assertNotEqual(C(1), 1)
-
-        @dataclass(eq=True)
-        class C:
-            x: int
-            def __eq__(self, other):
-                return other == 4
-        self.assertEqual(C(1), 4)
-        self.assertNotEqual(C(1), 1)
-
-        @dataclass(eq=False)
-        class C:
-            x: int
-            def __eq__(self, other):
-                return other == 5
-        self.assertEqual(C(1), 5)
-        self.assertNotEqual(C(1), 1)
-
-
-class TestOrdering(unittest.TestCase):
-    def test_functools_total_ordering(self):
-        # Test that functools.total_ordering works with this class.
-        @total_ordering
-        @dataclass
-        class C:
-            x: int
-            def __lt__(self, other):
-                # Perform the test "backward", just to make
-                #  sure this is being called.
-                return self.x >= other
-
-        self.assertLess(C(0), -1)
-        self.assertLessEqual(C(0), -1)
-        self.assertGreater(C(0), 1)
-        self.assertGreaterEqual(C(0), 1)
-
-    def test_no_order(self):
-        # Test that no ordering functions are added by default.
-        @dataclass(order=False)
-        class C:
-            x: int
-        # Make sure no order methods are added.
-        self.assertNotIn('__le__', C.__dict__)
-        self.assertNotIn('__lt__', C.__dict__)
-        self.assertNotIn('__ge__', C.__dict__)
-        self.assertNotIn('__gt__', C.__dict__)
-
-        # Test that __lt__ is still called
-        @dataclass(order=False)
-        class C:
-            x: int
-            def __lt__(self, other):
-                return False
-        # Make sure other methods aren't added.
-        self.assertNotIn('__le__', C.__dict__)
-        self.assertNotIn('__ge__', C.__dict__)
-        self.assertNotIn('__gt__', C.__dict__)
-
-    def test_overwriting_order(self):
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __lt__'
-                                    '.*using functools.total_ordering'):
-            @dataclass(order=True)
-            class C:
-                x: int
-                def __lt__(self):
-                    pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __le__'
-                                    '.*using functools.total_ordering'):
-            @dataclass(order=True)
-            class C:
-                x: int
-                def __le__(self):
-                    pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __gt__'
-                                    '.*using functools.total_ordering'):
-            @dataclass(order=True)
-            class C:
-                x: int
-                def __gt__(self):
-                    pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __ge__'
-                                    '.*using functools.total_ordering'):
-            @dataclass(order=True)
-            class C:
-                x: int
-                def __ge__(self):
-                    pass
-
-class TestHash(unittest.TestCase):
-    def test_unsafe_hash(self):
-        @dataclass(unsafe_hash=True)
-        class C:
-            x: int
-            y: str
-        self.assertEqual(hash(C(1, 'foo')), hash((1, 'foo')))
-
-    def test_hash_rules(self):
-        def non_bool(value):
-            # Map to something else that's True, but not a bool.
-            if value is None:
-                return None
-            if value:
-                return (3,)
-            return 0
-
-        def test(case, unsafe_hash, eq, frozen, with_hash, result):
-            with self.subTest(case=case, unsafe_hash=unsafe_hash, eq=eq,
-                              frozen=frozen):
-                if result != 'exception':
-                    if with_hash:
-                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
-                        class C:
-                            def __hash__(self):
-                                return 0
-                    else:
-                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
-                        class C:
-                            pass
-
-                # See if the result matches what's expected.
-                if result == 'fn':
-                    # __hash__ contains the function we generated.
-                    self.assertIn('__hash__', C.__dict__)
-                    self.assertIsNotNone(C.__dict__['__hash__'])
-
-                elif result == '':
-                    # __hash__ is not present in our class.
-                    if not with_hash:
-                        self.assertNotIn('__hash__', C.__dict__)
-
-                elif result == 'none':
-                    # __hash__ is set to None.
-                    self.assertIn('__hash__', C.__dict__)
-                    self.assertIsNone(C.__dict__['__hash__'])
-
-                elif result == 'exception':
-                    # Creating the class should cause an exception.
-                    #  This only happens with with_hash==True.
-                    assert(with_hash)
-                    with self.assertRaisesRegex(TypeError, 'Cannot overwrite attribute __hash__'):
-                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
-                        class C:
-                            def __hash__(self):
-                                return 0
-
-                else:
-                    assert False, f'unknown result {result!r}'
-
-        # There are 8 cases of:
-        #  unsafe_hash=True/False
-        #  eq=True/False
-        #  frozen=True/False
-        # And for each of these, a different result if
-        #  __hash__ is defined or not.
-        for case, (unsafe_hash,  eq,    frozen, res_no_defined_hash, res_defined_hash) in enumerate([
-                  (False,        False, False,  '',                  ''),
-                  (False,        False, True,   '',                  ''),
-                  (False,        True,  False,  'none',              ''),
-                  (False,        True,  True,   'fn',                ''),
-                  (True,         False, False,  'fn',                'exception'),
-                  (True,         False, True,   'fn',                'exception'),
-                  (True,         True,  False,  'fn',                'exception'),
-                  (True,         True,  True,   'fn',                'exception'),
-                  ], 1):
-            test(case, unsafe_hash, eq, frozen, False, res_no_defined_hash)
-            test(case, unsafe_hash, eq, frozen, True,  res_defined_hash)
-
-            # Test non-bool truth values, too.  This is just to
-            #  make sure the data-driven table in the decorator
-            #  handles non-bool values.
-            test(case, non_bool(unsafe_hash), non_bool(eq), non_bool(frozen), False, res_no_defined_hash)
-            test(case, non_bool(unsafe_hash), non_bool(eq), non_bool(frozen), True,  res_defined_hash)
-
-
-    def test_eq_only(self):
-        # If a class defines __eq__, __hash__ is automatically added
-        #  and set to None.  This is normal Python behavior, not
-        #  related to dataclasses.  Make sure we don't interfere with
-        #  that (see bpo=32546).
-
-        @dataclass
-        class C:
-            i: int
-            def __eq__(self, other):
-                return self.i == other.i
-        self.assertEqual(C(1), C(1))
-        self.assertNotEqual(C(1), C(4))
-
-        # And make sure things work in this case if we specify
-        #  unsafe_hash=True.
-        @dataclass(unsafe_hash=True)
-        class C:
-            i: int
-            def __eq__(self, other):
-                return self.i == other.i
-        self.assertEqual(C(1), C(1.0))
-        self.assertEqual(hash(C(1)), hash(C(1.0)))
-
-        # And check that the classes __eq__ is being used, despite
-        #  specifying eq=True.
-        @dataclass(unsafe_hash=True, eq=True)
-        class C:
-            i: int
-            def __eq__(self, other):
-                return self.i == 3 and self.i == other.i
-        self.assertEqual(C(3), C(3))
-        self.assertNotEqual(C(1), C(1))
-        self.assertEqual(hash(C(1)), hash(C(1.0)))
-
-    def test_0_field_hash(self):
-        @dataclass(frozen=True)
-        class C:
-            pass
-        self.assertEqual(hash(C()), hash(()))
-
-        @dataclass(unsafe_hash=True)
-        class C:
-            pass
-        self.assertEqual(hash(C()), hash(()))
-
-    def test_1_field_hash(self):
-        @dataclass(frozen=True)
-        class C:
-            x: int
-        self.assertEqual(hash(C(4)), hash((4,)))
-        self.assertEqual(hash(C(42)), hash((42,)))
-
-        @dataclass(unsafe_hash=True)
-        class C:
-            x: int
-        self.assertEqual(hash(C(4)), hash((4,)))
-        self.assertEqual(hash(C(42)), hash((42,)))
-
-    def test_hash_no_args(self):
-        # Test dataclasses with no hash= argument.  This exists to
-        #  make sure that if the @dataclass parameter name is changed
-        #  or the non-default hashing behavior changes, the default
-        #  hashability keeps working the same way.
-
-        class Base:
-            def __hash__(self):
-                return 301
-
-        # If frozen or eq is None, then use the default value (do not
-        #  specify any value in the decorator).
-        for frozen, eq,    base,   expected       in [
-            (None,  None,  object, 'unhashable'),
-            (None,  None,  Base,   'unhashable'),
-            (None,  False, object, 'object'),
-            (None,  False, Base,   'base'),
-            (None,  True,  object, 'unhashable'),
-            (None,  True,  Base,   'unhashable'),
-            (False, None,  object, 'unhashable'),
-            (False, None,  Base,   'unhashable'),
-            (False, False, object, 'object'),
-            (False, False, Base,   'base'),
-            (False, True,  object, 'unhashable'),
-            (False, True,  Base,   'unhashable'),
-            (True,  None,  object, 'tuple'),
-            (True,  None,  Base,   'tuple'),
-            (True,  False, object, 'object'),
-            (True,  False, Base,   'base'),
-            (True,  True,  object, 'tuple'),
-            (True,  True,  Base,   'tuple'),
-            ]:
-
-            with self.subTest(frozen=frozen, eq=eq, base=base, expected=expected):
-                # First, create the class.
-                if frozen is None and eq is None:
-                    @dataclass
-                    class C(base):
-                        i: int
-                elif frozen is None:
-                    @dataclass(eq=eq)
-                    class C(base):
-                        i: int
-                elif eq is None:
-                    @dataclass(frozen=frozen)
-                    class C(base):
-                        i: int
-                else:
-                    @dataclass(frozen=frozen, eq=eq)
-                    class C(base):
-                        i: int
-
-                # Now, make sure it hashes as expected.
-                if expected == 'unhashable':
-                    c = C(10)
-                    with self.assertRaisesRegex(TypeError, 'unhashable type'):
-                        hash(c)
-
-                elif expected == 'base':
-                    self.assertEqual(hash(C(10)), 301)
-
-                elif expected == 'object':
-                    # I'm not sure what test to use here.  object's
-                    #  hash isn't based on id(), so calling hash()
-                    #  won't tell us much.  So, just check the
-                    #  function used is object's.
-                    self.assertIs(C.__hash__, object.__hash__)
-
-                elif expected == 'tuple':
-                    self.assertEqual(hash(C(42)), hash((42,)))
-
-                else:
-                    assert False, f'unknown value for expected={expected!r}'
-
-
-class TestFrozen(unittest.TestCase):
-    def test_frozen(self):
-        @dataclass(frozen=True)
-        class C:
-            i: int
-
-        c = C(10)
-        self.assertEqual(c.i, 10)
-        with self.assertRaises(FrozenInstanceError):
-            c.i = 5
-        self.assertEqual(c.i, 10)
-
-    def test_inherit(self):
-        @dataclass(frozen=True)
-        class C:
-            i: int
-
-        @dataclass(frozen=True)
-        class D(C):
-            j: int
-
-        d = D(0, 10)
-        with self.assertRaises(FrozenInstanceError):
-            d.i = 5
-        with self.assertRaises(FrozenInstanceError):
-            d.j = 6
-        self.assertEqual(d.i, 0)
-        self.assertEqual(d.j, 10)
-
-    def test_inherit_nonfrozen_from_empty_frozen(self):
-        @dataclass(frozen=True)
-        class C:
-            pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'cannot inherit non-frozen dataclass from a frozen one'):
-            @dataclass
-            class D(C):
-                j: int
-
-    def test_inherit_nonfrozen_from_empty(self):
-        @dataclass
-        class C:
-            pass
-
-        @dataclass
-        class D(C):
-            j: int
-
-        d = D(3)
-        self.assertEqual(d.j, 3)
-        self.assertIsInstance(d, C)
-
-    # Test both ways: with an intermediate normal (non-dataclass)
-    #  class and without an intermediate class.
-    def test_inherit_nonfrozen_from_frozen(self):
-        for intermediate_class in [True, False]:
-            with self.subTest(intermediate_class=intermediate_class):
-                @dataclass(frozen=True)
-                class C:
-                    i: int
-
-                if intermediate_class:
-                    class I(C): pass
-                else:
-                    I = C
-
-                with self.assertRaisesRegex(TypeError,
-                                            'cannot inherit non-frozen dataclass from a frozen one'):
-                    @dataclass
-                    class D(I):
-                        pass
-
-    def test_inherit_frozen_from_nonfrozen(self):
-        for intermediate_class in [True, False]:
-            with self.subTest(intermediate_class=intermediate_class):
-                @dataclass
-                class C:
-                    i: int
-
-                if intermediate_class:
-                    class I(C): pass
-                else:
-                    I = C
-
-                with self.assertRaisesRegex(TypeError,
-                                            'cannot inherit frozen dataclass from a non-frozen one'):
-                    @dataclass(frozen=True)
-                    class D(I):
-                        pass
-
-    def test_inherit_from_normal_class(self):
-        for intermediate_class in [True, False]:
-            with self.subTest(intermediate_class=intermediate_class):
-                class C:
-                    pass
-
-                if intermediate_class:
-                    class I(C): pass
-                else:
-                    I = C
-
-                @dataclass(frozen=True)
-                class D(I):
-                    i: int
-
-            d = D(10)
-            with self.assertRaises(FrozenInstanceError):
-                d.i = 5
-
-    def test_non_frozen_normal_derived(self):
-        # See bpo-32953.
-
-        @dataclass(frozen=True)
-        class D:
-            x: int
-            y: int = 10
-
-        class S(D):
-            pass
-
-        s = S(3)
-        self.assertEqual(s.x, 3)
-        self.assertEqual(s.y, 10)
-        s.cached = True
-
-        # But can't change the frozen attributes.
-        with self.assertRaises(FrozenInstanceError):
-            s.x = 5
-        with self.assertRaises(FrozenInstanceError):
-            s.y = 5
-        self.assertEqual(s.x, 3)
-        self.assertEqual(s.y, 10)
-        self.assertEqual(s.cached, True)
-
-    def test_overwriting_frozen(self):
-        # frozen uses __setattr__ and __delattr__.
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __setattr__'):
-            @dataclass(frozen=True)
-            class C:
-                x: int
-                def __setattr__(self):
-                    pass
-
-        with self.assertRaisesRegex(TypeError,
-                                    'Cannot overwrite attribute __delattr__'):
-            @dataclass(frozen=True)
-            class C:
-                x: int
-                def __delattr__(self):
-                    pass
-
-        @dataclass(frozen=False)
-        class C:
-            x: int
-            def __setattr__(self, name, value):
-                self.__dict__['x'] = value * 2
-        self.assertEqual(C(10).x, 20)
-
-    def test_frozen_hash(self):
-        @dataclass(frozen=True)
-        class C:
-            x: Any
-
-        # If x is immutable, we can compute the hash.  No exception is
-        # raised.
-        hash(C(3))
-
-        # If x is mutable, computing the hash is an error.
-        with self.assertRaisesRegex(TypeError, 'unhashable type'):
-            hash(C({}))
-
-
-class TestSlots(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_simple(self):
-        @dataclass
-        class C:
-            __slots__ = ('x',)
-            x: Any
-
-        # There was a bug where a variable in a slot was assumed to
-        #  also have a default value (of type
-        #  types.MemberDescriptorType).
-        with self.assertRaisesRegex(TypeError,
-                                    r"__init__\(\) missing 1 required positional argument: 'x'"):
-            C()
-
-        # We can create an instance, and assign to x.
-        c = C(10)
-        self.assertEqual(c.x, 10)
-        c.x = 5
-        self.assertEqual(c.x, 5)
-
-        # We can't assign to anything else.
-        with self.assertRaisesRegex(AttributeError, "'C' object has no attribute 'y'"):
-            c.y = 5
-
-    def test_derived_added_field(self):
-        # See bpo-33100.
-        @dataclass
-        class Base:
-            __slots__ = ('x',)
-            x: Any
-
-        @dataclass
-        class Derived(Base):
-            x: int
-            y: int
-
-        d = Derived(1, 2)
-        self.assertEqual((d.x, d.y), (1, 2))
-
-        # We can add a new field to the derived instance.
-        d.z = 10
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_generated_slots(self):
-        @dataclass(slots=True)
-        class C:
-            x: int
-            y: int
-
-        c = C(1, 2)
-        self.assertEqual((c.x, c.y), (1, 2))
-
-        c.x = 3
-        c.y = 4
-        self.assertEqual((c.x, c.y), (3, 4))
-
-        with self.assertRaisesRegex(AttributeError, "'C' object has no attribute 'z'"):
-            c.z = 5
-
-    def test_add_slots_when_slots_exists(self):
-        with self.assertRaisesRegex(TypeError, '^C already specifies __slots__$'):
-            @dataclass(slots=True)
-            class C:
-                __slots__ = ('x',)
-                x: int
-
-    def test_generated_slots_value(self):
-        @dataclass(slots=True)
-        class Base:
-            x: int
-
-        self.assertEqual(Base.__slots__, ('x',))
-
-        @dataclass(slots=True)
-        class Delivered(Base):
-            y: int
-
-        self.assertEqual(Delivered.__slots__, ('x', 'y'))
-
-        @dataclass
-        class AnotherDelivered(Base):
-            z: int
-
-        self.assertTrue('__slots__' not in AnotherDelivered.__dict__)
-
-    def test_returns_new_class(self):
-        class A:
-            x: int
-
-        B = dataclass(A, slots=True)
-        self.assertIsNot(A, B)
-
-        self.assertFalse(hasattr(A, "__slots__"))
-        self.assertTrue(hasattr(B, "__slots__"))
-
-    # Can't be local to test_frozen_pickle.
-    @dataclass(frozen=True, slots=True)
-    class FrozenSlotsClass:
-        foo: str
-        bar: int
-
-    @dataclass(frozen=True)
-    class FrozenWithoutSlotsClass:
-        foo: str
-        bar: int
-
-    def test_frozen_pickle(self):
-        # bpo-43999
-
-        self.assertEqual(self.FrozenSlotsClass.__slots__, ("foo", "bar"))
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            with self.subTest(proto=proto):
-                obj = self.FrozenSlotsClass("a", 1)
-                p = pickle.loads(pickle.dumps(obj, protocol=proto))
-                self.assertIsNot(obj, p)
-                self.assertEqual(obj, p)
-
-                obj = self.FrozenWithoutSlotsClass("a", 1)
-                p = pickle.loads(pickle.dumps(obj, protocol=proto))
-                self.assertIsNot(obj, p)
-                self.assertEqual(obj, p)
-
-    def test_slots_with_default_no_init(self):
-        # Originally reported in bpo-44649.
-        @dataclass(slots=True)
-        class A:
-            a: str
-            b: str = field(default='b', init=False)
-
-        obj = A("a")
-        self.assertEqual(obj.a, 'a')
-        self.assertEqual(obj.b, 'b')
-
-    def test_slots_with_default_factory_no_init(self):
-        # Originally reported in bpo-44649.
-        @dataclass(slots=True)
-        class A:
-            a: str
-            b: str = field(default_factory=lambda:'b', init=False)
-
-        obj = A("a")
-        self.assertEqual(obj.a, 'a')
-        self.assertEqual(obj.b, 'b')
-
-class TestDescriptors(unittest.TestCase):
-    def test_set_name(self):
-        # See bpo-33141.
-
-        # Create a descriptor.
-        class D:
-            def __set_name__(self, owner, name):
-                self.name = name + 'x'
-            def __get__(self, instance, owner):
-                if instance is not None:
-                    return 1
-                return self
-
-        # This is the case of just normal descriptor behavior, no
-        #  dataclass code is involved in initializing the descriptor.
-        @dataclass
-        class C:
-            c: int=D()
-        self.assertEqual(C.c.name, 'cx')
-
-        # Now test with a default value and init=False, which is the
-        #  only time this is really meaningful.  If not using
-        #  init=False, then the descriptor will be overwritten, anyway.
-        @dataclass
-        class C:
-            c: int=field(default=D(), init=False)
-        self.assertEqual(C.c.name, 'cx')
-        self.assertEqual(C().c, 1)
-
-    def test_non_descriptor(self):
-        # PEP 487 says __set_name__ should work on non-descriptors.
-        # Create a descriptor.
-
-        class D:
-            def __set_name__(self, owner, name):
-                self.name = name + 'x'
-
-        @dataclass
-        class C:
-            c: int=field(default=D(), init=False)
-        self.assertEqual(C.c.name, 'cx')
-
-    def test_lookup_on_instance(self):
-        # See bpo-33175.
-        class D:
-            pass
-
-        d = D()
-        # Create an attribute on the instance, not type.
-        d.__set_name__ = Mock()
-
-        # Make sure d.__set_name__ is not called.
-        @dataclass
-        class C:
-            i: int=field(default=d, init=False)
-
-        self.assertEqual(d.__set_name__.call_count, 0)
-
-    def test_lookup_on_class(self):
-        # See bpo-33175.
-        class D:
-            pass
-        D.__set_name__ = Mock()
-
-        # Make sure D.__set_name__ is called.
-        @dataclass
-        class C:
-            i: int=field(default=D(), init=False)
-
-        self.assertEqual(D.__set_name__.call_count, 1)
-
-    def test_init_calls_set(self):
-        class D:
-            pass
-
-        D.__set__ = Mock()
-
-        @dataclass
-        class C:
-            i: D = D()
-
-        # Make sure D.__set__ is called.
-        D.__set__.reset_mock()
-        c = C(5)
-        self.assertEqual(D.__set__.call_count, 1)
-
-    def test_getting_field_calls_get(self):
-        class D:
-            pass
-
-        D.__set__ = Mock()
-        D.__get__ = Mock()
-
-        @dataclass
-        class C:
-            i: D = D()
-
-        c = C(5)
-
-        # Make sure D.__get__ is called.
-        D.__get__.reset_mock()
-        value = c.i
-        self.assertEqual(D.__get__.call_count, 1)
-
-    def test_setting_field_calls_set(self):
-        class D:
-            pass
-
-        D.__set__ = Mock()
-
-        @dataclass
-        class C:
-            i: D = D()
-
-        c = C(5)
-
-        # Make sure D.__set__ is called.
-        D.__set__.reset_mock()
-        c.i = 10
-        self.assertEqual(D.__set__.call_count, 1)
-
-    def test_setting_uninitialized_descriptor_field(self):
-        class D:
-            pass
-
-        D.__set__ = Mock()
-
-        @dataclass
-        class C:
-            i: D
-
-        # D.__set__ is not called because there's no D instance to call it on
-        D.__set__.reset_mock()
-        c = C(5)
-        self.assertEqual(D.__set__.call_count, 0)
-
-        # D.__set__ still isn't called after setting i to an instance of D
-        # because descriptors don't behave like that when stored as instance vars
-        c.i = D()
-        c.i = 5
-        self.assertEqual(D.__set__.call_count, 0)
-
-    def test_default_value(self):
-        class D:
-            def __get__(self, instance: Any, owner: object) -> int:
-                if instance is None:
-                    return 100
-
-                return instance._x
-
-            def __set__(self, instance: Any, value: int) -> None:
-                instance._x = value
-
-        @dataclass
-        class C:
-            i: D = D()
-
-        c = C()
-        self.assertEqual(c.i, 100)
-
-        c = C(5)
-        self.assertEqual(c.i, 5)
-
-    def test_no_default_value(self):
-        class D:
-            def __get__(self, instance: Any, owner: object) -> int:
-                if instance is None:
-                    raise AttributeError()
-
-                return instance._x
-
-            def __set__(self, instance: Any, value: int) -> None:
-                instance._x = value
-
-        @dataclass
-        class C:
-            i: D = D()
-
-        with self.assertRaisesRegex(TypeError, 'missing 1 required positional argument'):
-            c = C()
-
-class TestStringAnnotations(unittest.TestCase):
-    def test_classvar(self):
-        # Some expressions recognized as ClassVar really aren't.  But
-        #  if you're using string annotations, it's not an exact
-        #  science.
-        # These tests assume that both "import typing" and "from
-        # typing import *" have been run in this file.
-        for typestr in ('ClassVar[int]',
-                        'ClassVar [int]',
-                        ' ClassVar [int]',
-                        'ClassVar',
-                        ' ClassVar ',
-                        'typing.ClassVar[int]',
-                        'typing.ClassVar[str]',
-                        ' typing.ClassVar[str]',
-                        'typing .ClassVar[str]',
-                        'typing. ClassVar[str]',
-                        'typing.ClassVar [str]',
-                        'typing.ClassVar [ str]',
-
-                        # Not syntactically valid, but these will
-                        #  be treated as ClassVars.
-                        'typing.ClassVar.[int]',
-                        'typing.ClassVar+',
-                        ):
-            with self.subTest(typestr=typestr):
-                @dataclass
-                class C:
-                    x: typestr
-
-                # x is a ClassVar, so C() takes no args.
-                C()
-
-                # And it won't appear in the class's dict because it doesn't
-                # have a default.
-                self.assertNotIn('x', C.__dict__)
-
-    def test_isnt_classvar(self):
-        for typestr in ('CV',
-                        't.ClassVar',
-                        't.ClassVar[int]',
-                        'typing..ClassVar[int]',
-                        'Classvar',
-                        'Classvar[int]',
-                        'typing.ClassVarx[int]',
-                        'typong.ClassVar[int]',
-                        'dataclasses.ClassVar[int]',
-                        'typingxClassVar[str]',
-                        ):
-            with self.subTest(typestr=typestr):
-                @dataclass
-                class C:
-                    x: typestr
-
-                # x is not a ClassVar, so C() takes one arg.
-                self.assertEqual(C(10).x, 10)
-
-    def test_initvar(self):
-        # These tests assume that both "import dataclasses" and "from
-        #  dataclasses import *" have been run in this file.
-        for typestr in ('InitVar[int]',
-                        'InitVar [int]'
-                        ' InitVar [int]',
-                        'InitVar',
-                        ' InitVar ',
-                        'dataclasses.InitVar[int]',
-                        'dataclasses.InitVar[str]',
-                        ' dataclasses.InitVar[str]',
-                        'dataclasses .InitVar[str]',
-                        'dataclasses. InitVar[str]',
-                        'dataclasses.InitVar [str]',
-                        'dataclasses.InitVar [ str]',
-
-                        # Not syntactically valid, but these will
-                        #  be treated as InitVars.
-                        'dataclasses.InitVar.[int]',
-                        'dataclasses.InitVar+',
-                        ):
-            with self.subTest(typestr=typestr):
-                @dataclass
-                class C:
-                    x: typestr
-
-                # x is an InitVar, so doesn't create a member.
-                with self.assertRaisesRegex(AttributeError,
-                                            "object has no attribute 'x'"):
-                    C(1).x
-
-    def test_isnt_initvar(self):
-        for typestr in ('IV',
-                        'dc.InitVar',
-                        'xdataclasses.xInitVar',
-                        'typing.xInitVar[int]',
-                        ):
-            with self.subTest(typestr=typestr):
-                @dataclass
-                class C:
-                    x: typestr
-
-                # x is not an InitVar, so there will be a member x.
-                self.assertEqual(C(10).x, 10)
-
-    def test_classvar_module_level_import(self):
-        from test import dataclass_module_1
-        from test import dataclass_module_1_str
-        from test import dataclass_module_2
-        from test import dataclass_module_2_str
-
-        for m in (dataclass_module_1, dataclass_module_1_str,
-                  dataclass_module_2, dataclass_module_2_str,
-                  ):
-            with self.subTest(m=m):
-                # There's a difference in how the ClassVars are
-                # interpreted when using string annotations or
-                # not. See the imported modules for details.
-                if m.USING_STRINGS:
-                    c = m.CV(10)
-                else:
-                    c = m.CV()
-                self.assertEqual(c.cv0, 20)
-
-
-                # There's a difference in how the InitVars are
-                # interpreted when using string annotations or
-                # not. See the imported modules for details.
-                c = m.IV(0, 1, 2, 3, 4)
-
-                for field_name in ('iv0', 'iv1', 'iv2', 'iv3'):
-                    with self.subTest(field_name=field_name):
-                        with self.assertRaisesRegex(AttributeError, f"object has no attribute '{field_name}'"):
-                            # Since field_name is an InitVar, it's
-                            # not an instance field.
-                            getattr(c, field_name)
-
-                if m.USING_STRINGS:
-                    # iv4 is interpreted as a normal field.
-                    self.assertIn('not_iv4', c.__dict__)
-                    self.assertEqual(c.not_iv4, 4)
-                else:
-                    # iv4 is interpreted as an InitVar, so it
-                    # won't exist on the instance.
-                    self.assertNotIn('not_iv4', c.__dict__)
-
-    def test_text_annotations(self):
-        from test import dataclass_textanno
-
-        self.assertEqual(
-            get_type_hints(dataclass_textanno.Bar),
-            {'foo': dataclass_textanno.Foo})
-        self.assertEqual(
-            get_type_hints(dataclass_textanno.Bar.__init__),
-            {'foo': dataclass_textanno.Foo,
-             'return': type(None)})
-
-
-class TestMakeDataclass(unittest.TestCase):
-    def test_simple(self):
-        C = make_dataclass('C',
-                           [('x', int),
-                            ('y', int, field(default=5))],
-                           namespace={'add_one': lambda self: self.x + 1})
-        c = C(10)
-        self.assertEqual((c.x, c.y), (10, 5))
-        self.assertEqual(c.add_one(), 11)
-
-
-    def test_no_mutate_namespace(self):
-        # Make sure a provided namespace isn't mutated.
-        ns = {}
-        C = make_dataclass('C',
-                           [('x', int),
-                            ('y', int, field(default=5))],
-                           namespace=ns)
-        self.assertEqual(ns, {})
-
-    def test_base(self):
-        class Base1:
-            pass
-        class Base2:
-            pass
-        C = make_dataclass('C',
-                           [('x', int)],
-                           bases=(Base1, Base2))
-        c = C(2)
-        self.assertIsInstance(c, C)
-        self.assertIsInstance(c, Base1)
-        self.assertIsInstance(c, Base2)
-
-    def test_base_dataclass(self):
-        @dataclass
-        class Base1:
-            x: int
-        class Base2:
-            pass
-        C = make_dataclass('C',
-                           [('y', int)],
-                           bases=(Base1, Base2))
-        with self.assertRaisesRegex(TypeError, 'required positional'):
-            c = C(2)
-        c = C(1, 2)
-        self.assertIsInstance(c, C)
-        self.assertIsInstance(c, Base1)
-        self.assertIsInstance(c, Base2)
-
-        self.assertEqual((c.x, c.y), (1, 2))
-
-    def test_init_var(self):
-        def post_init(self, y):
-            self.x *= y
-
-        C = make_dataclass('C',
-                           [('x', int),
-                            ('y', InitVar[int]),
-                            ],
-                           namespace={'__post_init__': post_init},
-                           )
-        c = C(2, 3)
-        self.assertEqual(vars(c), {'x': 6})
-        self.assertEqual(len(fields(c)), 1)
-
-    def test_class_var(self):
-        C = make_dataclass('C',
-                           [('x', int),
-                            ('y', ClassVar[int], 10),
-                            ('z', ClassVar[int], field(default=20)),
-                            ])
-        c = C(1)
-        self.assertEqual(vars(c), {'x': 1})
-        self.assertEqual(len(fields(c)), 1)
-        self.assertEqual(C.y, 10)
-        self.assertEqual(C.z, 20)
-
-    def test_other_params(self):
-        C = make_dataclass('C',
-                           [('x', int),
-                            ('y', ClassVar[int], 10),
-                            ('z', ClassVar[int], field(default=20)),
-                            ],
-                           init=False)
-        # Make sure we have a repr, but no init.
-        self.assertNotIn('__init__', vars(C))
-        self.assertIn('__repr__', vars(C))
-
-        # Make sure random other params don't work.
-        with self.assertRaisesRegex(TypeError, 'unexpected keyword argument'):
-            C = make_dataclass('C',
-                               [],
-                               xxinit=False)
-
-    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'})
-
-        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',
-                                             'y': int,
-                                             'z': 'typing.Any'})
-
-    def test_invalid_type_specification(self):
-        for bad_field in [(),
-                          (1, 2, 3, 4),
-                          ]:
-            with self.subTest(bad_field=bad_field):
-                with self.assertRaisesRegex(TypeError, r'Invalid field: '):
-                    make_dataclass('C', ['a', bad_field])
-
-        # And test for things with no len().
-        for bad_field in [float,
-                          lambda x:x,
-                          ]:
-            with self.subTest(bad_field=bad_field):
-                with self.assertRaisesRegex(TypeError, r'has no len\(\)'):
-                    make_dataclass('C', ['a', bad_field])
-
-    def test_duplicate_field_names(self):
-        for field in ['a', 'ab']:
-            with self.subTest(field=field):
-                with self.assertRaisesRegex(TypeError, 'Field name duplicated'):
-                    make_dataclass('C', [field, 'a', field])
-
-    def test_keyword_field_names(self):
-        for field in ['for', 'async', 'await', 'as']:
-            with self.subTest(field=field):
-                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
-                    make_dataclass('C', ['a', field])
-                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
-                    make_dataclass('C', [field])
-                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
-                    make_dataclass('C', [field, 'a'])
-
-    def test_non_identifier_field_names(self):
-        for field in ['()', 'x,y', '*', '2@3', '', 'little johnny tables']:
-            with self.subTest(field=field):
-                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
-                    make_dataclass('C', ['a', field])
-                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
-                    make_dataclass('C', [field])
-                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
-                    make_dataclass('C', [field, 'a'])
-
-    def test_underscore_field_names(self):
-        # Unlike namedtuple, it's okay if dataclass field names have
-        # an underscore.
-        make_dataclass('C', ['_', '_a', 'a_a', 'a_'])
-
-    def test_funny_class_names_names(self):
-        # No reason to prevent weird class names, since
-        # types.new_class allows them.
-        for classname in ['()', 'x,y', '*', '2@3', '']:
-            with self.subTest(classname=classname):
-                C = make_dataclass(classname, ['a', 'b'])
-                self.assertEqual(C.__name__, classname)
-
-class TestReplace(unittest.TestCase):
-    def test(self):
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            y: int
-
-        c = C(1, 2)
-        c1 = replace(c, x=3)
-        self.assertEqual(c1.x, 3)
-        self.assertEqual(c1.y, 2)
-
-    def test_frozen(self):
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            y: int
-            z: int = field(init=False, default=10)
-            t: int = field(init=False, default=100)
-
-        c = C(1, 2)
-        c1 = replace(c, x=3)
-        self.assertEqual((c.x, c.y, c.z, c.t), (1, 2, 10, 100))
-        self.assertEqual((c1.x, c1.y, c1.z, c1.t), (3, 2, 10, 100))
-
-
-        with self.assertRaisesRegex(ValueError, 'init=False'):
-            replace(c, x=3, z=20, t=50)
-        with self.assertRaisesRegex(ValueError, 'init=False'):
-            replace(c, z=20)
-            replace(c, x=3, z=20, t=50)
-
-        # Make sure the result is still frozen.
-        with self.assertRaisesRegex(FrozenInstanceError, "cannot assign to field 'x'"):
-            c1.x = 3
-
-        # Make sure we can't replace an attribute that doesn't exist,
-        #  if we're also replacing one that does exist.  Test this
-        #  here, because setting attributes on frozen instances is
-        #  handled slightly differently from non-frozen ones.
-        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an unexpected "
-                                             "keyword argument 'a'"):
-            c1 = replace(c, x=20, a=5)
-
-    def test_invalid_field_name(self):
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            y: int
-
-        c = C(1, 2)
-        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an unexpected "
-                                    "keyword argument 'z'"):
-            c1 = replace(c, z=3)
-
-    def test_invalid_object(self):
-        @dataclass(frozen=True)
-        class C:
-            x: int
-            y: int
-
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            replace(C, x=3)
-
-        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
-            replace(0, x=3)
-
-    def test_no_init(self):
-        @dataclass
-        class C:
-            x: int
-            y: int = field(init=False, default=10)
-
-        c = C(1)
-        c.y = 20
-
-        # Make sure y gets the default value.
-        c1 = replace(c, x=5)
-        self.assertEqual((c1.x, c1.y), (5, 10))
-
-        # Trying to replace y is an error.
-        with self.assertRaisesRegex(ValueError, 'init=False'):
-            replace(c, x=2, y=30)
-
-        with self.assertRaisesRegex(ValueError, 'init=False'):
-            replace(c, y=30)
-
-    def test_classvar(self):
-        @dataclass
-        class C:
-            x: int
-            y: ClassVar[int] = 1000
-
-        c = C(1)
-        d = C(2)
-
-        self.assertIs(c.y, d.y)
-        self.assertEqual(c.y, 1000)
-
-        # Trying to replace y is an error: can't replace ClassVars.
-        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an "
-                                    "unexpected keyword argument 'y'"):
-            replace(c, y=30)
-
-        replace(c, x=5)
-
-    def test_initvar_is_specified(self):
-        @dataclass
-        class C:
-            x: int
-            y: InitVar[int]
-
-            def __post_init__(self, y):
-                self.x *= y
-
-        c = C(1, 10)
-        self.assertEqual(c.x, 10)
-        with self.assertRaisesRegex(ValueError, r"InitVar 'y' must be "
-                                    "specified with replace()"):
-            replace(c, x=3)
-        c = replace(c, x=3, y=5)
-        self.assertEqual(c.x, 15)
-
-    def test_initvar_with_default_value(self):
-        @dataclass
-        class C:
-            x: int
-            y: InitVar[int] = None
-            z: InitVar[int] = 42
-
-            def __post_init__(self, y, z):
-                if y is not None:
-                    self.x += y
-                if z is not None:
-                    self.x += z
-
-        c = C(x=1, y=10, z=1)
-        self.assertEqual(replace(c), C(x=12))
-        self.assertEqual(replace(c, y=4), C(x=12, y=4, z=42))
-        self.assertEqual(replace(c, y=4, z=1), C(x=12, y=4, z=1))
-
-    def test_recursive_repr(self):
-        @dataclass
-        class C:
-            f: "C"
-
-        c = C(None)
-        c.f = c
-        self.assertEqual(repr(c), "TestReplace.test_recursive_repr.<locals>.C(f=...)")
-
-    def test_recursive_repr_two_attrs(self):
-        @dataclass
-        class C:
-            f: "C"
-            g: "C"
-
-        c = C(None, None)
-        c.f = c
-        c.g = c
-        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_two_attrs"
-                                  ".<locals>.C(f=..., g=...)")
-
-    def test_recursive_repr_indirection(self):
-        @dataclass
-        class C:
-            f: "D"
-
-        @dataclass
-        class D:
-            f: "C"
-
-        c = C(None)
-        d = D(None)
-        c.f = d
-        d.f = c
-        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_indirection"
-                                  ".<locals>.C(f=TestReplace.test_recursive_repr_indirection"
-                                  ".<locals>.D(f=...))")
-
-    def test_recursive_repr_indirection_two(self):
-        @dataclass
-        class C:
-            f: "D"
-
-        @dataclass
-        class D:
-            f: "E"
-
-        @dataclass
-        class E:
-            f: "C"
-
-        c = C(None)
-        d = D(None)
-        e = E(None)
-        c.f = d
-        d.f = e
-        e.f = c
-        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_indirection_two"
-                                  ".<locals>.C(f=TestReplace.test_recursive_repr_indirection_two"
-                                  ".<locals>.D(f=TestReplace.test_recursive_repr_indirection_two"
-                                  ".<locals>.E(f=...)))")
-
-    def test_recursive_repr_misc_attrs(self):
-        @dataclass
-        class C:
-            f: "C"
-            g: int
-
-        c = C(None, 1)
-        c.f = c
-        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_misc_attrs"
-                                  ".<locals>.C(f=..., g=1)")
-
-    ## def test_initvar(self):
-    ##     @dataclass
-    ##     class C:
-    ##         x: int
-    ##         y: InitVar[int]
-
-    ##     c = C(1, 10)
-    ##     d = C(2, 20)
-
-    ##     # In our case, replacing an InitVar is a no-op
-    ##     self.assertEqual(c, replace(c, y=5))
-
-    ##     replace(c, x=5)
-
-class TestAbstract(unittest.TestCase):
-    def test_abc_implementation(self):
-        class Ordered(abc.ABC):
-            @abc.abstractmethod
-            def __lt__(self, other):
-                pass
-
-            @abc.abstractmethod
-            def __le__(self, other):
-                pass
-
-        @dataclass(order=True)
-        class Date(Ordered):
-            year: int
-            month: 'Month'
-            day: 'int'
-
-        self.assertFalse(inspect.isabstract(Date))
-        self.assertGreater(Date(2020,12,25), Date(2020,8,31))
-
-    @unittest.expectedFailure
-    def test_maintain_abc(self):
-        class A(abc.ABC):
-            @abc.abstractmethod
-            def foo(self):
-                pass
-
-        @dataclass
-        class Date(A):
-            year: int
-            month: 'Month'
-            day: 'int'
-
-        self.assertTrue(inspect.isabstract(Date))
-        msg = 'class Date with abstract method foo'
-        self.assertRaisesRegex(TypeError, msg, Date)
-
-
-class TestMatchArgs(unittest.TestCase):
-    def test_match_args(self):
-        @dataclass
-        class C:
-            a: int
-        self.assertEqual(C(42).__match_args__, ('a',))
-
-    def test_explicit_match_args(self):
-        ma = ()
-        @dataclass
-        class C:
-            a: int
-            __match_args__ = ma
-        self.assertIs(C(42).__match_args__, ma)
-
-    def test_bpo_43764(self):
-        @dataclass(repr=False, eq=False, init=False)
-        class X:
-            a: int
-            b: int
-            c: int
-        self.assertEqual(X.__match_args__, ("a", "b", "c"))
-
-    def test_match_args_argument(self):
-        @dataclass(match_args=False)
-        class X:
-            a: int
-        self.assertNotIn('__match_args__', X.__dict__)
-
-        @dataclass(match_args=False)
-        class Y:
-            a: int
-            __match_args__ = ('b',)
-        self.assertEqual(Y.__match_args__, ('b',))
-
-        @dataclass(match_args=False)
-        class Z(Y):
-            z: int
-        self.assertEqual(Z.__match_args__, ('b',))
-
-        # Ensure parent dataclass __match_args__ is seen, if child class
-        # specifies match_args=False.
-        @dataclass
-        class A:
-            a: int
-            z: int
-        @dataclass(match_args=False)
-        class B(A):
-            b: int
-        self.assertEqual(B.__match_args__, ('a', 'z'))
-
-    def test_make_dataclasses(self):
-        C = make_dataclass('C', [('x', int), ('y', int)])
-        self.assertEqual(C.__match_args__, ('x', 'y'))
-
-        C = make_dataclass('C', [('x', int), ('y', int)], match_args=True)
-        self.assertEqual(C.__match_args__, ('x', 'y'))
-
-        C = make_dataclass('C', [('x', int), ('y', int)], match_args=False)
-        self.assertNotIn('__match__args__', C.__dict__)
-
-        C = make_dataclass('C', [('x', int), ('y', int)], namespace={'__match_args__': ('z',)})
-        self.assertEqual(C.__match_args__, ('z',))
-
-
-class TestKeywordArgs(unittest.TestCase):
-    def test_no_classvar_kwarg(self):
-        msg = 'field a is a ClassVar but specifies kw_only'
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: ClassVar[int] = field(kw_only=True)
-
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: ClassVar[int] = field(kw_only=False)
-
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass(kw_only=True)
-            class A:
-                a: ClassVar[int] = field(kw_only=False)
-
-    def test_field_marked_as_kwonly(self):
-        #######################
-        # Using dataclass(kw_only=True)
-        @dataclass(kw_only=True)
-        class A:
-            a: int
-        self.assertTrue(fields(A)[0].kw_only)
-
-        @dataclass(kw_only=True)
-        class A:
-            a: int = field(kw_only=True)
-        self.assertTrue(fields(A)[0].kw_only)
-
-        @dataclass(kw_only=True)
-        class A:
-            a: int = field(kw_only=False)
-        self.assertFalse(fields(A)[0].kw_only)
-
-        #######################
-        # Using dataclass(kw_only=False)
-        @dataclass(kw_only=False)
-        class A:
-            a: int
-        self.assertFalse(fields(A)[0].kw_only)
-
-        @dataclass(kw_only=False)
-        class A:
-            a: int = field(kw_only=True)
-        self.assertTrue(fields(A)[0].kw_only)
-
-        @dataclass(kw_only=False)
-        class A:
-            a: int = field(kw_only=False)
-        self.assertFalse(fields(A)[0].kw_only)
-
-        #######################
-        # Not specifying dataclass(kw_only)
-        @dataclass
-        class A:
-            a: int
-        self.assertFalse(fields(A)[0].kw_only)
-
-        @dataclass
-        class A:
-            a: int = field(kw_only=True)
-        self.assertTrue(fields(A)[0].kw_only)
-
-        @dataclass
-        class A:
-            a: int = field(kw_only=False)
-        self.assertFalse(fields(A)[0].kw_only)
-
-    def test_match_args(self):
-        # kw fields don't show up in __match_args__.
-        @dataclass(kw_only=True)
-        class C:
-            a: int
-        self.assertEqual(C(a=42).__match_args__, ())
-
-        @dataclass
-        class C:
-            a: int
-            b: int = field(kw_only=True)
-        self.assertEqual(C(42, b=10).__match_args__, ('a',))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_KW_ONLY(self):
-        @dataclass
-        class A:
-            a: int
-            _: KW_ONLY
-            b: int
-            c: int
-        A(3, c=5, b=4)
-        msg = "takes 2 positional arguments but 4 were given"
-        with self.assertRaisesRegex(TypeError, msg):
-            A(3, 4, 5)
-
-
-        @dataclass(kw_only=True)
-        class B:
-            a: int
-            _: KW_ONLY
-            b: int
-            c: int
-        B(a=3, b=4, c=5)
-        msg = "takes 1 positional argument but 4 were given"
-        with self.assertRaisesRegex(TypeError, msg):
-            B(3, 4, 5)
-
-        # Explicitly make a field that follows KW_ONLY be non-keyword-only.
-        @dataclass
-        class C:
-            a: int
-            _: KW_ONLY
-            b: int
-            c: int = field(kw_only=False)
-        c = C(1, 2, b=3)
-        self.assertEqual(c.a, 1)
-        self.assertEqual(c.b, 3)
-        self.assertEqual(c.c, 2)
-        c = C(1, b=3, c=2)
-        self.assertEqual(c.a, 1)
-        self.assertEqual(c.b, 3)
-        self.assertEqual(c.c, 2)
-        c = C(1, b=3, c=2)
-        self.assertEqual(c.a, 1)
-        self.assertEqual(c.b, 3)
-        self.assertEqual(c.c, 2)
-        c = C(c=2, b=3, a=1)
-        self.assertEqual(c.a, 1)
-        self.assertEqual(c.b, 3)
-        self.assertEqual(c.c, 2)
-
-    def test_KW_ONLY_as_string(self):
-        @dataclass
-        class A:
-            a: int
-            _: 'dataclasses.KW_ONLY'
-            b: int
-            c: int
-        A(3, c=5, b=4)
-        msg = "takes 2 positional arguments but 4 were given"
-        with self.assertRaisesRegex(TypeError, msg):
-            A(3, 4, 5)
-
-    def test_KW_ONLY_twice(self):
-        msg = "'Y' is KW_ONLY, but KW_ONLY has already been specified"
-
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: int
-                X: KW_ONLY
-                Y: KW_ONLY
-                b: int
-                c: int
-
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: int
-                X: KW_ONLY
-                b: int
-                Y: KW_ONLY
-                c: int
-
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: int
-                X: KW_ONLY
-                b: int
-                c: int
-                Y: KW_ONLY
-
-        # But this usage is okay, since it's not using KW_ONLY.
-        @dataclass
-        class A:
-            a: int
-            _: KW_ONLY
-            b: int
-            c: int = field(kw_only=True)
-
-        # And if inheriting, it's okay.
-        @dataclass
-        class A:
-            a: int
-            _: KW_ONLY
-            b: int
-            c: int
-        @dataclass
-        class B(A):
-            _: KW_ONLY
-            d: int
-
-        # Make sure the error is raised in a derived class.
-        with self.assertRaisesRegex(TypeError, msg):
-            @dataclass
-            class A:
-                a: int
-                _: KW_ONLY
-                b: int
-                c: int
-            @dataclass
-            class B(A):
-                X: KW_ONLY
-                d: int
-                Y: KW_ONLY
-
-
-    def test_post_init(self):
-        @dataclass
-        class A:
-            a: int
-            _: KW_ONLY
-            b: InitVar[int]
-            c: int
-            d: InitVar[int]
-            def __post_init__(self, b, d):
-                raise CustomError(f'{b=} {d=}')
-        with self.assertRaisesRegex(CustomError, 'b=3 d=4'):
-            A(1, c=2, b=3, d=4)
-
-        @dataclass
-        class B:
-            a: int
-            _: KW_ONLY
-            b: InitVar[int]
-            c: int
-            d: InitVar[int]
-            def __post_init__(self, b, d):
-                self.a = b
-                self.c = d
-        b = B(1, c=2, b=3, d=4)
-        self.assertEqual(asdict(b), {'a': 3, 'c': 4})
-
-    def test_defaults(self):
-        # For kwargs, make sure we can have defaults after non-defaults.
-        @dataclass
-        class A:
-            a: int = 0
-            _: KW_ONLY
-            b: int
-            c: int = 1
-            d: int
-
-        a = A(d=4, b=3)
-        self.assertEqual(a.a, 0)
-        self.assertEqual(a.b, 3)
-        self.assertEqual(a.c, 1)
-        self.assertEqual(a.d, 4)
-
-        # Make sure we still check for non-kwarg non-defaults not following
-        # defaults.
-        err_regex = "non-default argument 'z' follows default argument"
-        with self.assertRaisesRegex(TypeError, err_regex):
-            @dataclass
-            class A:
-                a: int = 0
-                z: int
-                _: KW_ONLY
-                b: int
-                c: int = 1
-                d: int
-
-    def test_make_dataclass(self):
-        A = make_dataclass("A", ['a'], kw_only=True)
-        self.assertTrue(fields(A)[0].kw_only)
-
-        B = make_dataclass("B",
-                           ['a', ('b', int, field(kw_only=False))],
-                           kw_only=True)
-        self.assertTrue(fields(B)[0].kw_only)
-        self.assertFalse(fields(B)[1].kw_only)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/test/test_dataclasses/__init__.py b/Lib/test/test_dataclasses/__init__.py
new file mode 100644
index 0000000000..3f1e2331bc
--- /dev/null
+++ b/Lib/test/test_dataclasses/__init__.py
@@ -0,0 +1,4923 @@
+# Deliberately use "from dataclasses import *".  Every name in __all__
+# is tested, so they all must be present.  This is a way to catch
+# missing ones.
+
+from dataclasses import *
+
+import abc
+import io
+import pickle
+import inspect
+import builtins
+import types
+import weakref
+import traceback
+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
+
+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
+
+# Just any custom exception we can catch.
+class CustomError(Exception): pass
+
+class TestCase(unittest.TestCase):
+    def test_no_fields(self):
+        @dataclass
+        class C:
+            pass
+
+        o = C()
+        self.assertEqual(len(fields(C)), 0)
+
+    def test_no_fields_but_member_variable(self):
+        @dataclass
+        class C:
+            i = 0
+
+        o = C()
+        self.assertEqual(len(fields(C)), 0)
+
+    def test_one_field_no_default(self):
+        @dataclass
+        class C:
+            x: int
+
+        o = C(42)
+        self.assertEqual(o.x, 42)
+
+    def test_field_default_default_factory_error(self):
+        msg = "cannot specify both default and default_factory"
+        with self.assertRaisesRegex(ValueError, msg):
+            @dataclass
+            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.name = "id"
+        repr_output = repr(int_field)
+        expected_output = "Field(name='id',type=None," \
+                           f"default=1,default_factory={MISSING!r}," \
+                           "init=True,repr=False,hash=None," \
+                           "compare=True,metadata=mappingproxy({})," \
+                           f"kw_only={MISSING!r}," \
+                           "_field_type=None)"
+
+        self.assertEqual(repr_output, expected_output)
+
+    def test_field_recursive_repr(self):
+        rec_field = field()
+        rec_field.type = rec_field
+        rec_field.name = "id"
+        repr_output = repr(rec_field)
+
+        self.assertIn(",type=...,", repr_output)
+
+    def test_recursive_annotation(self):
+        class C:
+            pass
+
+        @dataclass
+        class D:
+            C: C = field()
+
+        self.assertIn(",type=...,", repr(D.__dataclass_fields__["C"]))
+
+    def test_dataclass_params_repr(self):
+        # Even though this is testing an internal implementation detail,
+        # it's testing a feature we want to make sure is correctly implemented
+        # for the sake of dataclasses itself
+        @dataclass(slots=True, frozen=True)
+        class Some: pass
+
+        repr_output = repr(Some.__dataclass_params__)
+        expected_output = "_DataclassParams(init=True,repr=True," \
+                          "eq=True,order=False,unsafe_hash=False,frozen=True," \
+                          "match_args=True,kw_only=False," \
+                          "slots=True,weakref_slot=False)"
+        self.assertEqual(repr_output, expected_output)
+
+    def test_dataclass_params_signature(self):
+        # Even though this is testing an internal implementation detail,
+        # it's testing a feature we want to make sure is correctly implemented
+        # for the sake of dataclasses itself
+        @dataclass
+        class Some: pass
+
+        for param in inspect.signature(dataclass).parameters:
+            if param == 'cls':
+                continue
+            self.assertTrue(hasattr(Some.__dataclass_params__, param), msg=param)
+
+    def test_named_init_params(self):
+        @dataclass
+        class C:
+            x: int
+
+        o = C(x=32)
+        self.assertEqual(o.x, 32)
+
+    def test_two_fields_one_default(self):
+        @dataclass
+        class C:
+            x: int
+            y: int = 0
+
+        o = C(3)
+        self.assertEqual((o.x, o.y), (3, 0))
+
+        # Non-defaults following defaults.
+        with self.assertRaisesRegex(TypeError,
+                                    "non-default argument 'y' follows "
+                                    "default argument 'x'"):
+            @dataclass
+            class C:
+                x: int = 0
+                y: int
+
+        # A derived class adds a non-default field after a default one.
+        with self.assertRaisesRegex(TypeError,
+                                    "non-default argument 'y' follows "
+                                    "default argument 'x'"):
+            @dataclass
+            class B:
+                x: int = 0
+
+            @dataclass
+            class C(B):
+                y: int
+
+        # Override a base class field and add a default to
+        #  a field which didn't use to have a default.
+        with self.assertRaisesRegex(TypeError,
+                                    "non-default argument 'y' follows "
+                                    "default argument 'x'"):
+            @dataclass
+            class B:
+                x: int
+                y: int
+
+            @dataclass
+            class C(B):
+                x: int = 0
+
+    def test_overwrite_hash(self):
+        # Test that declaring this class isn't an error.  It should
+        #  use the user-provided __hash__.
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            def __hash__(self):
+                return 301
+        self.assertEqual(hash(C(100)), 301)
+
+        # Test that declaring this class isn't an error.  It should
+        #  use the generated __hash__.
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            def __eq__(self, other):
+                return False
+        self.assertEqual(hash(C(100)), hash((100,)))
+
+        # But this one should generate an exception, because with
+        #  unsafe_hash=True, it's an error to have a __hash__ defined.
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __hash__'):
+            @dataclass(unsafe_hash=True)
+            class C:
+                def __hash__(self):
+                    pass
+
+        # Creating this class should not generate an exception,
+        #  because even though __hash__ exists before @dataclass is
+        #  called, (due to __eq__ being defined), since it's None
+        #  that's okay.
+        @dataclass(unsafe_hash=True)
+        class C:
+            x: int
+            def __eq__(self):
+                pass
+        # The generated hash function works as we'd expect.
+        self.assertEqual(hash(C(10)), hash((10,)))
+
+        # Creating this class should generate an exception, because
+        #  __hash__ exists and is not None, which it would be if it
+        #  had been auto-generated due to __eq__ being defined.
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __hash__'):
+            @dataclass(unsafe_hash=True)
+            class C:
+                x: int
+                def __eq__(self):
+                    pass
+                def __hash__(self):
+                    pass
+
+    def test_overwrite_fields_in_derived_class(self):
+        # Note that x from C1 replaces x in Base, but the order remains
+        #  the same as defined in Base.
+        @dataclass
+        class Base:
+            x: Any = 15.0
+            y: int = 0
+
+        @dataclass
+        class C1(Base):
+            z: int = 10
+            x: int = 15
+
+        o = Base()
+        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.Base(x=15.0, y=0)')
+
+        o = C1()
+        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=15, y=0, z=10)')
+
+        o = C1(x=5)
+        self.assertEqual(repr(o), 'TestCase.test_overwrite_fields_in_derived_class.<locals>.C1(x=5, y=0, z=10)')
+
+    def test_field_named_self(self):
+        @dataclass
+        class C:
+            self: str
+        c=C('foo')
+        self.assertEqual(c.self, 'foo')
+
+        # Make sure the first parameter is not named 'self'.
+        sig = inspect.signature(C.__init__)
+        first = next(iter(sig.parameters))
+        self.assertNotEqual('self', first)
+
+        # But we do use 'self' if no field named self.
+        @dataclass
+        class C:
+            selfx: str
+
+        # Make sure the first parameter is named 'self'.
+        sig = inspect.signature(C.__init__)
+        first = next(iter(sig.parameters))
+        self.assertEqual('self', first)
+
+    def test_field_named_object(self):
+        @dataclass
+        class C:
+            object: str
+        c = C('foo')
+        self.assertEqual(c.object, 'foo')
+
+    def test_field_named_object_frozen(self):
+        @dataclass(frozen=True)
+        class C:
+            object: str
+        c = C('foo')
+        self.assertEqual(c.object, 'foo')
+
+    def test_field_named_BUILTINS_frozen(self):
+        # gh-96151
+        @dataclass(frozen=True)
+        class C:
+            BUILTINS: int
+        c = C(5)
+        self.assertEqual(c.BUILTINS, 5)
+
+    def test_field_with_special_single_underscore_names(self):
+        # gh-98886
+
+        @dataclass
+        class X:
+            x: int = field(default_factory=lambda: 111)
+            _dflt_x: int = field(default_factory=lambda: 222)
+
+        X()
+
+        @dataclass
+        class Y:
+            y: int = field(default_factory=lambda: 111)
+            _HAS_DEFAULT_FACTORY: int = 222
+
+        assert Y(y=222).y == 222
+
+    def test_field_named_like_builtin(self):
+        # Attribute names can shadow built-in names
+        # since code generation is used.
+        # Ensure that this is not happening.
+        exclusions = {'None', 'True', 'False'}
+        builtins_names = sorted(
+            b for b in builtins.__dict__.keys()
+            if not b.startswith('__') and b not in exclusions
+        )
+        attributes = [(name, str) for name in builtins_names]
+        C = make_dataclass('C', attributes)
+
+        c = C(*[name for name in builtins_names])
+
+        for name in builtins_names:
+            self.assertEqual(getattr(c, name), name)
+
+    def test_field_named_like_builtin_frozen(self):
+        # Attribute names can shadow built-in names
+        # since code generation is used.
+        # Ensure that this is not happening
+        # for frozen data classes.
+        exclusions = {'None', 'True', 'False'}
+        builtins_names = sorted(
+            b for b in builtins.__dict__.keys()
+            if not b.startswith('__') and b not in exclusions
+        )
+        attributes = [(name, str) for name in builtins_names]
+        C = make_dataclass('C', attributes, frozen=True)
+
+        c = C(*[name for name in builtins_names])
+
+        for name in builtins_names:
+            self.assertEqual(getattr(c, name), name)
+
+    def test_0_field_compare(self):
+        # Ensure that order=False is the default.
+        @dataclass
+        class C0:
+            pass
+
+        @dataclass(order=False)
+        class C1:
+            pass
+
+        for cls in [C0, C1]:
+            with self.subTest(cls=cls):
+                self.assertEqual(cls(), cls())
+                for idx, fn in enumerate([lambda a, b: a < b,
+                                          lambda a, b: a <= b,
+                                          lambda a, b: a > b,
+                                          lambda a, b: a >= b]):
+                    with self.subTest(idx=idx):
+                        with self.assertRaisesRegex(TypeError,
+                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
+                            fn(cls(), cls())
+
+        @dataclass(order=True)
+        class C:
+            pass
+        self.assertLessEqual(C(), C())
+        self.assertGreaterEqual(C(), C())
+
+    def test_1_field_compare(self):
+        # Ensure that order=False is the default.
+        @dataclass
+        class C0:
+            x: int
+
+        @dataclass(order=False)
+        class C1:
+            x: int
+
+        for cls in [C0, C1]:
+            with self.subTest(cls=cls):
+                self.assertEqual(cls(1), cls(1))
+                self.assertNotEqual(cls(0), cls(1))
+                for idx, fn in enumerate([lambda a, b: a < b,
+                                          lambda a, b: a <= b,
+                                          lambda a, b: a > b,
+                                          lambda a, b: a >= b]):
+                    with self.subTest(idx=idx):
+                        with self.assertRaisesRegex(TypeError,
+                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
+                            fn(cls(0), cls(0))
+
+        @dataclass(order=True)
+        class C:
+            x: int
+        self.assertLess(C(0), C(1))
+        self.assertLessEqual(C(0), C(1))
+        self.assertLessEqual(C(1), C(1))
+        self.assertGreater(C(1), C(0))
+        self.assertGreaterEqual(C(1), C(0))
+        self.assertGreaterEqual(C(1), C(1))
+
+    def test_simple_compare(self):
+        # Ensure that order=False is the default.
+        @dataclass
+        class C0:
+            x: int
+            y: int
+
+        @dataclass(order=False)
+        class C1:
+            x: int
+            y: int
+
+        for cls in [C0, C1]:
+            with self.subTest(cls=cls):
+                self.assertEqual(cls(0, 0), cls(0, 0))
+                self.assertEqual(cls(1, 2), cls(1, 2))
+                self.assertNotEqual(cls(1, 0), cls(0, 0))
+                self.assertNotEqual(cls(1, 0), cls(1, 1))
+                for idx, fn in enumerate([lambda a, b: a < b,
+                                          lambda a, b: a <= b,
+                                          lambda a, b: a > b,
+                                          lambda a, b: a >= b]):
+                    with self.subTest(idx=idx):
+                        with self.assertRaisesRegex(TypeError,
+                                                    f"not supported between instances of '{cls.__name__}' and '{cls.__name__}'"):
+                            fn(cls(0, 0), cls(0, 0))
+
+        @dataclass(order=True)
+        class C:
+            x: int
+            y: int
+
+        for idx, fn in enumerate([lambda a, b: a == b,
+                                  lambda a, b: a <= b,
+                                  lambda a, b: a >= b]):
+            with self.subTest(idx=idx):
+                self.assertTrue(fn(C(0, 0), C(0, 0)))
+
+        for idx, fn in enumerate([lambda a, b: a < b,
+                                  lambda a, b: a <= b,
+                                  lambda a, b: a != b]):
+            with self.subTest(idx=idx):
+                self.assertTrue(fn(C(0, 0), C(0, 1)))
+                self.assertTrue(fn(C(0, 1), C(1, 0)))
+                self.assertTrue(fn(C(1, 0), C(1, 1)))
+
+        for idx, fn in enumerate([lambda a, b: a > b,
+                                  lambda a, b: a >= b,
+                                  lambda a, b: a != b]):
+            with self.subTest(idx=idx):
+                self.assertTrue(fn(C(0, 1), C(0, 0)))
+                self.assertTrue(fn(C(1, 0), C(0, 1)))
+                self.assertTrue(fn(C(1, 1), C(1, 0)))
+
+    def test_compare_subclasses(self):
+        # Comparisons fail for subclasses, even if no fields
+        #  are added.
+        @dataclass
+        class B:
+            i: int
+
+        @dataclass
+        class C(B):
+            pass
+
+        for idx, (fn, expected) in enumerate([(lambda a, b: a == b, False),
+                                              (lambda a, b: a != b, True)]):
+            with self.subTest(idx=idx):
+                self.assertEqual(fn(B(0), C(0)), expected)
+
+        for idx, fn in enumerate([lambda a, b: a < b,
+                                  lambda a, b: a <= b,
+                                  lambda a, b: a > b,
+                                  lambda a, b: a >= b]):
+            with self.subTest(idx=idx):
+                with self.assertRaisesRegex(TypeError,
+                                            "not supported between instances of 'B' and 'C'"):
+                    fn(B(0), C(0))
+
+    def test_eq_order(self):
+        # Test combining eq and order.
+        for (eq,    order, result   ) in [
+            (False, False, 'neither'),
+            (False, True,  'exception'),
+            (True,  False, 'eq_only'),
+            (True,  True,  'both'),
+        ]:
+            with self.subTest(eq=eq, order=order):
+                if result == 'exception':
+                    with self.assertRaisesRegex(ValueError, 'eq must be true if order is true'):
+                        @dataclass(eq=eq, order=order)
+                        class C:
+                            pass
+                else:
+                    @dataclass(eq=eq, order=order)
+                    class C:
+                        pass
+
+                    if result == 'neither':
+                        self.assertNotIn('__eq__', C.__dict__)
+                        self.assertNotIn('__lt__', C.__dict__)
+                        self.assertNotIn('__le__', C.__dict__)
+                        self.assertNotIn('__gt__', C.__dict__)
+                        self.assertNotIn('__ge__', C.__dict__)
+                    elif result == 'both':
+                        self.assertIn('__eq__', C.__dict__)
+                        self.assertIn('__lt__', C.__dict__)
+                        self.assertIn('__le__', C.__dict__)
+                        self.assertIn('__gt__', C.__dict__)
+                        self.assertIn('__ge__', C.__dict__)
+                    elif result == 'eq_only':
+                        self.assertIn('__eq__', C.__dict__)
+                        self.assertNotIn('__lt__', C.__dict__)
+                        self.assertNotIn('__le__', C.__dict__)
+                        self.assertNotIn('__gt__', C.__dict__)
+                        self.assertNotIn('__ge__', C.__dict__)
+                    else:
+                        assert False, f'unknown result {result!r}'
+
+    def test_field_no_default(self):
+        @dataclass
+        class C:
+            x: int = field()
+
+        self.assertEqual(C(5).x, 5)
+
+        with self.assertRaisesRegex(TypeError,
+                                    r"__init__\(\) missing 1 required "
+                                    "positional argument: 'x'"):
+            C()
+
+    def test_field_default(self):
+        default = object()
+        @dataclass
+        class C:
+            x: object = field(default=default)
+
+        self.assertIs(C.x, default)
+        c = C(10)
+        self.assertEqual(c.x, 10)
+
+        # If we delete the instance attribute, we should then see the
+        #  class attribute.
+        del c.x
+        self.assertIs(c.x, default)
+
+        self.assertIs(C().x, default)
+
+    def test_not_in_repr(self):
+        @dataclass
+        class C:
+            x: int = field(repr=False)
+        with self.assertRaises(TypeError):
+            C()
+        c = C(10)
+        self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C()')
+
+        @dataclass
+        class C:
+            x: int = field(repr=False)
+            y: int
+        c = C(10, 20)
+        self.assertEqual(repr(c), 'TestCase.test_not_in_repr.<locals>.C(y=20)')
+
+    def test_not_in_compare(self):
+        @dataclass
+        class C:
+            x: int = 0
+            y: int = field(compare=False, default=4)
+
+        self.assertEqual(C(), C(0, 20))
+        self.assertEqual(C(1, 10), C(1, 20))
+        self.assertNotEqual(C(3), C(4, 10))
+        self.assertNotEqual(C(3, 10), C(4, 10))
+
+    def test_no_unhashable_default(self):
+        # See bpo-44674.
+        class Unhashable:
+            __hash__ = None
+
+        unhashable_re = 'mutable default .* for field a is not allowed'
+        with self.assertRaisesRegex(ValueError, unhashable_re):
+            @dataclass
+            class A:
+                a: dict = {}
+
+        with self.assertRaisesRegex(ValueError, unhashable_re):
+            @dataclass
+            class A:
+                a: Any = Unhashable()
+
+        # Make sure that the machinery looking for hashability is using the
+        # class's __hash__, not the instance's __hash__.
+        with self.assertRaisesRegex(ValueError, unhashable_re):
+            unhashable = Unhashable()
+            # This shouldn't make the variable hashable.
+            unhashable.__hash__ = lambda: 0
+            @dataclass
+            class A:
+                a: Any = unhashable
+
+    def test_hash_field_rules(self):
+        # Test all 6 cases of:
+        #  hash=True/False/None
+        #  compare=True/False
+        for (hash_,    compare, result  ) in [
+            (True,     False,   'field' ),
+            (True,     True,    'field' ),
+            (False,    False,   'absent'),
+            (False,    True,    'absent'),
+            (None,     False,   'absent'),
+            (None,     True,    'field' ),
+            ]:
+            with self.subTest(hash=hash_, compare=compare):
+                @dataclass(unsafe_hash=True)
+                class C:
+                    x: int = field(compare=compare, hash=hash_, default=5)
+
+                if result == 'field':
+                    # __hash__ contains the field.
+                    self.assertEqual(hash(C(5)), hash((5,)))
+                elif result == 'absent':
+                    # The field is not present in the hash.
+                    self.assertEqual(hash(C(5)), hash(()))
+                else:
+                    assert False, f'unknown result {result!r}'
+
+    def test_init_false_no_default(self):
+        # If init=False and no default value, then the field won't be
+        #  present in the instance.
+        @dataclass
+        class C:
+            x: int = field(init=False)
+
+        self.assertNotIn('x', C().__dict__)
+
+        @dataclass
+        class C:
+            x: int
+            y: int = 0
+            z: int = field(init=False)
+            t: int = 10
+
+        self.assertNotIn('z', C(0).__dict__)
+        self.assertEqual(vars(C(5)), {'t': 10, 'x': 5, 'y': 0})
+
+    def test_class_marker(self):
+        @dataclass
+        class C:
+            x: int
+            y: str = field(init=False, default=None)
+            z: str = field(repr=False)
+
+        the_fields = fields(C)
+        # the_fields is a tuple of 3 items, each value
+        #  is in __annotations__.
+        self.assertIsInstance(the_fields, tuple)
+        for f in the_fields:
+            self.assertIs(type(f), Field)
+            self.assertIn(f.name, C.__annotations__)
+
+        self.assertEqual(len(the_fields), 3)
+
+        self.assertEqual(the_fields[0].name, 'x')
+        self.assertEqual(the_fields[0].type, int)
+        self.assertFalse(hasattr(C, 'x'))
+        self.assertTrue (the_fields[0].init)
+        self.assertTrue (the_fields[0].repr)
+        self.assertEqual(the_fields[1].name, 'y')
+        self.assertEqual(the_fields[1].type, str)
+        self.assertIsNone(getattr(C, 'y'))
+        self.assertFalse(the_fields[1].init)
+        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.assertTrue (the_fields[2].init)
+        self.assertFalse(the_fields[2].repr)
+
+    def test_field_order(self):
+        @dataclass
+        class B:
+            a: str = 'B:a'
+            b: str = 'B:b'
+            c: str = 'B:c'
+
+        @dataclass
+        class C(B):
+            b: str = 'C:b'
+
+        self.assertEqual([(f.name, f.default) for f in fields(C)],
+                         [('a', 'B:a'),
+                          ('b', 'C:b'),
+                          ('c', 'B:c')])
+
+        @dataclass
+        class D(B):
+            c: str = 'D:c'
+
+        self.assertEqual([(f.name, f.default) for f in fields(D)],
+                         [('a', 'B:a'),
+                          ('b', 'B:b'),
+                          ('c', 'D:c')])
+
+        @dataclass
+        class E(D):
+            a: str = 'E:a'
+            d: str = 'E:d'
+
+        self.assertEqual([(f.name, f.default) for f in fields(E)],
+                         [('a', 'E:a'),
+                          ('b', 'B:b'),
+                          ('c', 'D:c'),
+                          ('d', 'E:d')])
+
+    def test_class_attrs(self):
+        # We only have a class attribute if a default value is
+        #  specified, either directly or via a field with a default.
+        default = object()
+        @dataclass
+        class C:
+            x: int
+            y: int = field(repr=False)
+            z: object = default
+            t: int = field(default=100)
+
+        self.assertFalse(hasattr(C, 'x'))
+        self.assertFalse(hasattr(C, 'y'))
+        self.assertIs   (C.z, default)
+        self.assertEqual(C.t, 100)
+
+    def test_disallowed_mutable_defaults(self):
+        # For the known types, don't allow mutable default values.
+        for typ, empty, non_empty in [(list, [], [1]),
+                                      (dict, {}, {0:1}),
+                                      (set, set(), set([1])),
+                                      ]:
+            with self.subTest(typ=typ):
+                # Can't use a zero-length value.
+                with self.assertRaisesRegex(ValueError,
+                                            f'mutable default {typ} for field '
+                                            'x is not allowed'):
+                    @dataclass
+                    class Point:
+                        x: typ = empty
+
+
+                # Nor a non-zero-length value
+                with self.assertRaisesRegex(ValueError,
+                                            f'mutable default {typ} for field '
+                                            'y is not allowed'):
+                    @dataclass
+                    class Point:
+                        y: typ = non_empty
+
+                # Check subtypes also fail.
+                class Subclass(typ): pass
+
+                with self.assertRaisesRegex(ValueError,
+                                            "mutable default .*Subclass'>"
+                                            " for field z is not allowed"
+                                            ):
+                    @dataclass
+                    class Point:
+                        z: typ = Subclass()
+
+                # Because this is a ClassVar, it can be mutable.
+                @dataclass
+                class UsesMutableClassVar:
+                    z: ClassVar[typ] = typ()
+
+                # Because this is a ClassVar, it can be mutable.
+                @dataclass
+                class UsesMutableClassVarWithSubType:
+                    x: ClassVar[typ] = Subclass()
+
+    def test_deliberately_mutable_defaults(self):
+        # If a mutable default isn't in the known list of
+        #  (list, dict, set), then it's okay.
+        class Mutable:
+            def __init__(self):
+                self.l = []
+
+        @dataclass
+        class C:
+            x: Mutable
+
+        # These 2 instances will share this value of x.
+        lst = Mutable()
+        o1 = C(lst)
+        o2 = C(lst)
+        self.assertEqual(o1, o2)
+        o1.x.l.extend([1, 2])
+        self.assertEqual(o1, o2)
+        self.assertEqual(o1.x.l, [1, 2])
+        self.assertIs(o1.x, o2.x)
+
+    def test_no_options(self):
+        # Call with dataclass().
+        @dataclass()
+        class C:
+            x: int
+
+        self.assertEqual(C(42).x, 42)
+
+    def test_not_tuple(self):
+        # Make sure we can't be compared to a tuple.
+        @dataclass
+        class Point:
+            x: int
+            y: int
+        self.assertNotEqual(Point(1, 2), (1, 2))
+
+        # And that we can't compare to another unrelated dataclass.
+        @dataclass
+        class C:
+            x: int
+            y: int
+        self.assertNotEqual(Point(1, 3), C(1, 3))
+
+    def test_not_other_dataclass(self):
+        # Test that some of the problems with namedtuple don't happen
+        #  here.
+        @dataclass
+        class Point3D:
+            x: int
+            y: int
+            z: int
+
+        @dataclass
+        class Date:
+            year: int
+            month: int
+            day: int
+
+        self.assertNotEqual(Point3D(2017, 6, 3), Date(2017, 6, 3))
+        self.assertNotEqual(Point3D(1, 2, 3), (1, 2, 3))
+
+        # Make sure we can't unpack.
+        with self.assertRaisesRegex(TypeError, 'unpack'):
+            x, y, z = Point3D(4, 5, 6)
+
+        # Make sure another class with the same field names isn't
+        #  equal.
+        @dataclass
+        class Point3Dv1:
+            x: int = 0
+            y: int = 0
+            z: int = 0
+        self.assertNotEqual(Point3D(0, 0, 0), Point3Dv1())
+
+    def test_function_annotations(self):
+        # Some dummy class and instance to use as a default.
+        class F:
+            pass
+        f = F()
+
+        def validate_class(cls):
+            # First, check __annotations__, even though they're not
+            #  function annotations.
+            self.assertEqual(cls.__annotations__['i'], int)
+            self.assertEqual(cls.__annotations__['j'], str)
+            self.assertEqual(cls.__annotations__['k'], F)
+            self.assertEqual(cls.__annotations__['l'], float)
+            self.assertEqual(cls.__annotations__['z'], complex)
+
+            # Verify __init__.
+
+            signature = inspect.signature(cls.__init__)
+            # Check the return type, should be None.
+            self.assertIs(signature.return_annotation, None)
+
+            # Check each parameter.
+            params = iter(signature.parameters.values())
+            param = next(params)
+            # This is testing an internal name, and probably shouldn't be tested.
+            self.assertEqual(param.name, 'self')
+            param = next(params)
+            self.assertEqual(param.name, 'i')
+            self.assertIs   (param.annotation, int)
+            self.assertEqual(param.default, inspect.Parameter.empty)
+            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+            param = next(params)
+            self.assertEqual(param.name, 'j')
+            self.assertIs   (param.annotation, str)
+            self.assertEqual(param.default, inspect.Parameter.empty)
+            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+            param = next(params)
+            self.assertEqual(param.name, 'k')
+            self.assertIs   (param.annotation, F)
+            # Don't test for the default, since it's set to MISSING.
+            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+            param = next(params)
+            self.assertEqual(param.name, 'l')
+            self.assertIs   (param.annotation, float)
+            # Don't test for the default, since it's set to MISSING.
+            self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_OR_KEYWORD)
+            self.assertRaises(StopIteration, next, params)
+
+
+        @dataclass
+        class C:
+            i: int
+            j: str
+            k: F = f
+            l: float=field(default=None)
+            z: complex=field(default=3+4j, init=False)
+
+        validate_class(C)
+
+        # Now repeat with __hash__.
+        @dataclass(frozen=True, unsafe_hash=True)
+        class C:
+            i: int
+            j: str
+            k: F = f
+            l: float=field(default=None)
+            z: complex=field(default=3+4j, init=False)
+
+        validate_class(C)
+
+    def test_missing_default(self):
+        # Test that MISSING works the same as a default not being
+        #  specified.
+        @dataclass
+        class C:
+            x: int=field(default=MISSING)
+        with self.assertRaisesRegex(TypeError,
+                                    r'__init__\(\) missing 1 required '
+                                    'positional argument'):
+            C()
+        self.assertNotIn('x', C.__dict__)
+
+        @dataclass
+        class D:
+            x: int
+        with self.assertRaisesRegex(TypeError,
+                                    r'__init__\(\) missing 1 required '
+                                    'positional argument'):
+            D()
+        self.assertNotIn('x', D.__dict__)
+
+    def test_missing_default_factory(self):
+        # Test that MISSING works the same as a default factory not
+        #  being specified (which is really the same as a default not
+        #  being specified, too).
+        @dataclass
+        class C:
+            x: int=field(default_factory=MISSING)
+        with self.assertRaisesRegex(TypeError,
+                                    r'__init__\(\) missing 1 required '
+                                    'positional argument'):
+            C()
+        self.assertNotIn('x', C.__dict__)
+
+        @dataclass
+        class D:
+            x: int=field(default=MISSING, default_factory=MISSING)
+        with self.assertRaisesRegex(TypeError,
+                                    r'__init__\(\) missing 1 required '
+                                    'positional argument'):
+            D()
+        self.assertNotIn('x', D.__dict__)
+
+    def test_missing_repr(self):
+        self.assertIn('MISSING_TYPE object', repr(MISSING))
+
+    def test_dont_include_other_annotations(self):
+        @dataclass
+        class C:
+            i: int
+            def foo(self) -> int:
+                return 4
+            @property
+            def bar(self) -> int:
+                return 5
+        self.assertEqual(list(C.__annotations__), ['i'])
+        self.assertEqual(C(10).foo(), 4)
+        self.assertEqual(C(10).bar, 5)
+        self.assertEqual(C(10).i, 10)
+
+    def test_post_init(self):
+        # Just make sure it gets called
+        @dataclass
+        class C:
+            def __post_init__(self):
+                raise CustomError()
+        with self.assertRaises(CustomError):
+            C()
+
+        @dataclass
+        class C:
+            i: int = 10
+            def __post_init__(self):
+                if self.i == 10:
+                    raise CustomError()
+        with self.assertRaises(CustomError):
+            C()
+        # post-init gets called, but doesn't raise. This is just
+        #  checking that self is used correctly.
+        C(5)
+
+        # If there's not an __init__, then post-init won't get called.
+        @dataclass(init=False)
+        class C:
+            def __post_init__(self):
+                raise CustomError()
+        # Creating the class won't raise
+        C()
+
+        @dataclass
+        class C:
+            x: int = 0
+            def __post_init__(self):
+                self.x *= 2
+        self.assertEqual(C().x, 0)
+        self.assertEqual(C(2).x, 4)
+
+        # Make sure that if we're frozen, post-init can't set
+        #  attributes.
+        @dataclass(frozen=True)
+        class C:
+            x: int = 0
+            def __post_init__(self):
+                self.x *= 2
+        with self.assertRaises(FrozenInstanceError):
+            C()
+
+    def test_post_init_super(self):
+        # Make sure super() post-init isn't called by default.
+        class B:
+            def __post_init__(self):
+                raise CustomError()
+
+        @dataclass
+        class C(B):
+            def __post_init__(self):
+                self.x = 5
+
+        self.assertEqual(C().x, 5)
+
+        # Now call super(), and it will raise.
+        @dataclass
+        class C(B):
+            def __post_init__(self):
+                super().__post_init__()
+
+        with self.assertRaises(CustomError):
+            C()
+
+        # Make sure post-init is called, even if not defined in our
+        #  class.
+        @dataclass
+        class C(B):
+            pass
+
+        with self.assertRaises(CustomError):
+            C()
+
+    def test_post_init_staticmethod(self):
+        flag = False
+        @dataclass
+        class C:
+            x: int
+            y: int
+            @staticmethod
+            def __post_init__():
+                nonlocal flag
+                flag = True
+
+        self.assertFalse(flag)
+        c = C(3, 4)
+        self.assertEqual((c.x, c.y), (3, 4))
+        self.assertTrue(flag)
+
+    def test_post_init_classmethod(self):
+        @dataclass
+        class C:
+            flag = False
+            x: int
+            y: int
+            @classmethod
+            def __post_init__(cls):
+                cls.flag = True
+
+        self.assertFalse(C.flag)
+        c = C(3, 4)
+        self.assertEqual((c.x, c.y), (3, 4))
+        self.assertTrue(C.flag)
+
+    def test_post_init_not_auto_added(self):
+        # See bpo-46757, which had proposed always adding __post_init__.  As
+        # Raymond Hettinger pointed out, that would be a breaking change.  So,
+        # add a test to make sure that the current behavior doesn't change.
+
+        @dataclass
+        class A0:
+            pass
+
+        @dataclass
+        class B0:
+            b_called: bool = False
+            def __post_init__(self):
+                self.b_called = True
+
+        @dataclass
+        class C0(A0, B0):
+            c_called: bool = False
+            def __post_init__(self):
+                super().__post_init__()
+                self.c_called = True
+
+        # Since A0 has no __post_init__, and one wasn't automatically added
+        # (because that's the rule: it's never added by @dataclass, it's only
+        # the class author that can add it), then B0.__post_init__ is called.
+        # Verify that.
+        c = C0()
+        self.assertTrue(c.b_called)
+        self.assertTrue(c.c_called)
+
+        ######################################
+        # Now, the same thing, except A1 defines __post_init__.
+        @dataclass
+        class A1:
+            def __post_init__(self):
+                pass
+
+        @dataclass
+        class B1:
+            b_called: bool = False
+            def __post_init__(self):
+                self.b_called = True
+
+        @dataclass
+        class C1(A1, B1):
+            c_called: bool = False
+            def __post_init__(self):
+                super().__post_init__()
+                self.c_called = True
+
+        # This time, B1.__post_init__ isn't being called.  This mimics what
+        # would happen if A1.__post_init__ had been automatically added,
+        # instead of manually added as we see here.  This test isn't really
+        # needed, but I'm including it just to demonstrate the changed
+        # behavior when A1 does define __post_init__.
+        c = C1()
+        self.assertFalse(c.b_called)
+        self.assertTrue(c.c_called)
+
+    def test_class_var(self):
+        # Make sure ClassVars are ignored in __init__, __repr__, etc.
+        @dataclass
+        class C:
+            x: int
+            y: int = 10
+            z: ClassVar[int] = 1000
+            w: ClassVar[int] = 2000
+            t: ClassVar[int] = 3000
+            s: ClassVar      = 4000
+
+        c = C(5)
+        self.assertEqual(repr(c), 'TestCase.test_class_var.<locals>.C(x=5, y=10)')
+        self.assertEqual(len(fields(C)), 2)                 # We have 2 fields.
+        self.assertEqual(len(C.__annotations__), 6)         # And 4 ClassVars.
+        self.assertEqual(c.z, 1000)
+        self.assertEqual(c.w, 2000)
+        self.assertEqual(c.t, 3000)
+        self.assertEqual(c.s, 4000)
+        C.z += 1
+        self.assertEqual(c.z, 1001)
+        c = C(20)
+        self.assertEqual((c.x, c.y), (20, 10))
+        self.assertEqual(c.z, 1001)
+        self.assertEqual(c.w, 2000)
+        self.assertEqual(c.t, 3000)
+        self.assertEqual(c.s, 4000)
+
+    def test_class_var_no_default(self):
+        # If a ClassVar has no default value, it should not be set on the class.
+        @dataclass
+        class C:
+            x: ClassVar[int]
+
+        self.assertNotIn('x', C.__dict__)
+
+    def test_class_var_default_factory(self):
+        # It makes no sense for a ClassVar to have a default factory. When
+        #  would it be called? Call it yourself, since it's class-wide.
+        with self.assertRaisesRegex(TypeError,
+                                    'cannot have a default factory'):
+            @dataclass
+            class C:
+                x: ClassVar[int] = field(default_factory=int)
+
+            self.assertNotIn('x', C.__dict__)
+
+    def test_class_var_with_default(self):
+        # If a ClassVar has a default value, it should be set on the class.
+        @dataclass
+        class C:
+            x: ClassVar[int] = 10
+        self.assertEqual(C.x, 10)
+
+        @dataclass
+        class C:
+            x: ClassVar[int] = field(default=10)
+        self.assertEqual(C.x, 10)
+
+    def test_class_var_frozen(self):
+        # Make sure ClassVars work even if we're frozen.
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            y: int = 10
+            z: ClassVar[int] = 1000
+            w: ClassVar[int] = 2000
+            t: ClassVar[int] = 3000
+
+        c = C(5)
+        self.assertEqual(repr(C(5)), 'TestCase.test_class_var_frozen.<locals>.C(x=5, y=10)')
+        self.assertEqual(len(fields(C)), 2)                 # We have 2 fields
+        self.assertEqual(len(C.__annotations__), 5)         # And 3 ClassVars
+        self.assertEqual(c.z, 1000)
+        self.assertEqual(c.w, 2000)
+        self.assertEqual(c.t, 3000)
+        # We can still modify the ClassVar, it's only instances that are
+        #  frozen.
+        C.z += 1
+        self.assertEqual(c.z, 1001)
+        c = C(20)
+        self.assertEqual((c.x, c.y), (20, 10))
+        self.assertEqual(c.z, 1001)
+        self.assertEqual(c.w, 2000)
+        self.assertEqual(c.t, 3000)
+
+    def test_init_var_no_default(self):
+        # If an InitVar has no default value, it should not be set on the class.
+        @dataclass
+        class C:
+            x: InitVar[int]
+
+        self.assertNotIn('x', C.__dict__)
+
+    def test_init_var_default_factory(self):
+        # It makes no sense for an InitVar to have a default factory. When
+        #  would it be called? Call it yourself, since it's class-wide.
+        with self.assertRaisesRegex(TypeError,
+                                    'cannot have a default factory'):
+            @dataclass
+            class C:
+                x: InitVar[int] = field(default_factory=int)
+
+            self.assertNotIn('x', C.__dict__)
+
+    def test_init_var_with_default(self):
+        # If an InitVar has a default value, it should be set on the class.
+        @dataclass
+        class C:
+            x: InitVar[int] = 10
+        self.assertEqual(C.x, 10)
+
+        @dataclass
+        class C:
+            x: InitVar[int] = field(default=10)
+        self.assertEqual(C.x, 10)
+
+    def test_init_var(self):
+        @dataclass
+        class C:
+            x: int = None
+            init_param: InitVar[int] = None
+
+            def __post_init__(self, init_param):
+                if self.x is None:
+                    self.x = init_param*2
+
+        c = C(init_param=10)
+        self.assertEqual(c.x, 20)
+
+    def test_init_var_preserve_type(self):
+        self.assertEqual(InitVar[int].type, int)
+
+        # Make sure the repr is correct.
+        self.assertEqual(repr(InitVar[int]), 'dataclasses.InitVar[int]')
+        self.assertEqual(repr(InitVar[List[int]]),
+                         'dataclasses.InitVar[typing.List[int]]')
+        self.assertEqual(repr(InitVar[list[int]]),
+                         'dataclasses.InitVar[list[int]]')
+        self.assertEqual(repr(InitVar[int|str]),
+                         'dataclasses.InitVar[int | str]')
+
+    def test_init_var_inheritance(self):
+        # Note that this deliberately tests that a dataclass need not
+        #  have a __post_init__ function if it has an InitVar field.
+        #  It could just be used in a derived class, as shown here.
+        @dataclass
+        class Base:
+            x: int
+            init_base: InitVar[int]
+
+        # We can instantiate by passing the InitVar, even though
+        #  it's not used.
+        b = Base(0, 10)
+        self.assertEqual(vars(b), {'x': 0})
+
+        @dataclass
+        class C(Base):
+            y: int
+            init_derived: InitVar[int]
+
+            def __post_init__(self, init_base, init_derived):
+                self.x = self.x + init_base
+                self.y = self.y + init_derived
+
+        c = C(10, 11, 50, 51)
+        self.assertEqual(vars(c), {'x': 21, 'y': 101})
+
+    def test_init_var_name_shadowing(self):
+        # Because dataclasses rely exclusively on `__annotations__` for
+        # handling InitVar and `__annotations__` preserves shadowed definitions,
+        # you can actually shadow an InitVar with a method or property.
+        #
+        # This only works when there is no default value; `dataclasses` uses the
+        # actual name (which will be bound to the shadowing method) for default
+        # values.
+        @dataclass
+        class C:
+            shadowed: InitVar[int]
+            _shadowed: int = field(init=False)
+
+            def __post_init__(self, shadowed):
+                self._shadowed = shadowed * 2
+
+            @property
+            def shadowed(self):
+                return self._shadowed * 3
+
+        c = C(5)
+        self.assertEqual(c.shadowed, 30)
+
+    def test_default_factory(self):
+        # Test a factory that returns a new list.
+        @dataclass
+        class C:
+            x: int
+            y: list = field(default_factory=list)
+
+        c0 = C(3)
+        c1 = C(3)
+        self.assertEqual(c0.x, 3)
+        self.assertEqual(c0.y, [])
+        self.assertEqual(c0, c1)
+        self.assertIsNot(c0.y, c1.y)
+        self.assertEqual(astuple(C(5, [1])), (5, [1]))
+
+        # Test a factory that returns a shared list.
+        l = []
+        @dataclass
+        class C:
+            x: int
+            y: list = field(default_factory=lambda: l)
+
+        c0 = C(3)
+        c1 = C(3)
+        self.assertEqual(c0.x, 3)
+        self.assertEqual(c0.y, [])
+        self.assertEqual(c0, c1)
+        self.assertIs(c0.y, c1.y)
+        self.assertEqual(astuple(C(5, [1])), (5, [1]))
+
+        # Test various other field flags.
+        # repr
+        @dataclass
+        class C:
+            x: list = field(default_factory=list, repr=False)
+        self.assertEqual(repr(C()), 'TestCase.test_default_factory.<locals>.C()')
+        self.assertEqual(C().x, [])
+
+        # hash
+        @dataclass(unsafe_hash=True)
+        class C:
+            x: list = field(default_factory=list, hash=False)
+        self.assertEqual(astuple(C()), ([],))
+        self.assertEqual(hash(C()), hash(()))
+
+        # init (see also test_default_factory_with_no_init)
+        @dataclass
+        class C:
+            x: list = field(default_factory=list, init=False)
+        self.assertEqual(astuple(C()), ([],))
+
+        # compare
+        @dataclass
+        class C:
+            x: list = field(default_factory=list, compare=False)
+        self.assertEqual(C(), C([1]))
+
+    def test_default_factory_with_no_init(self):
+        # We need a factory with a side effect.
+        factory = Mock()
+
+        @dataclass
+        class C:
+            x: list = field(default_factory=factory, init=False)
+
+        # Make sure the default factory is called for each new instance.
+        C().x
+        self.assertEqual(factory.call_count, 1)
+        C().x
+        self.assertEqual(factory.call_count, 2)
+
+    def test_default_factory_not_called_if_value_given(self):
+        # We need a factory that we can test if it's been called.
+        factory = Mock()
+
+        @dataclass
+        class C:
+            x: int = field(default_factory=factory)
+
+        # Make sure that if a field has a default factory function,
+        #  it's not called if a value is specified.
+        C().x
+        self.assertEqual(factory.call_count, 1)
+        self.assertEqual(C(10).x, 10)
+        self.assertEqual(factory.call_count, 1)
+        C().x
+        self.assertEqual(factory.call_count, 2)
+
+    def test_default_factory_derived(self):
+        # See bpo-32896.
+        @dataclass
+        class Foo:
+            x: dict = field(default_factory=dict)
+
+        @dataclass
+        class Bar(Foo):
+            y: int = 1
+
+        self.assertEqual(Foo().x, {})
+        self.assertEqual(Bar().x, {})
+        self.assertEqual(Bar().y, 1)
+
+        @dataclass
+        class Baz(Foo):
+            pass
+        self.assertEqual(Baz().x, {})
+
+    def test_intermediate_non_dataclass(self):
+        # Test that an intermediate class that defines
+        #  annotations does not define fields.
+
+        @dataclass
+        class A:
+            x: int
+
+        class B(A):
+            y: int
+
+        @dataclass
+        class C(B):
+            z: int
+
+        c = C(1, 3)
+        self.assertEqual((c.x, c.z), (1, 3))
+
+        # .y was not initialized.
+        with self.assertRaisesRegex(AttributeError,
+                                    'object has no attribute'):
+            c.y
+
+        # And if we again derive a non-dataclass, no fields are added.
+        class D(C):
+            t: int
+        d = D(4, 5)
+        self.assertEqual((d.x, d.z), (4, 5))
+
+    def test_classvar_default_factory(self):
+        # It's an error for a ClassVar to have a factory function.
+        with self.assertRaisesRegex(TypeError,
+                                    'cannot have a default factory'):
+            @dataclass
+            class C:
+                x: ClassVar[int] = field(default_factory=int)
+
+    def test_is_dataclass(self):
+        class NotDataClass:
+            pass
+
+        self.assertFalse(is_dataclass(0))
+        self.assertFalse(is_dataclass(int))
+        self.assertFalse(is_dataclass(NotDataClass))
+        self.assertFalse(is_dataclass(NotDataClass()))
+
+        @dataclass
+        class C:
+            x: int
+
+        @dataclass
+        class D:
+            d: C
+            e: int
+
+        c = C(10)
+        d = D(c, 4)
+
+        self.assertTrue(is_dataclass(C))
+        self.assertTrue(is_dataclass(c))
+        self.assertFalse(is_dataclass(c.x))
+        self.assertTrue(is_dataclass(d.d))
+        self.assertFalse(is_dataclass(d.e))
+
+    def test_is_dataclass_when_getattr_always_returns(self):
+        # See bpo-37868.
+        class A:
+            def __getattr__(self, key):
+                return 0
+        self.assertFalse(is_dataclass(A))
+        a = A()
+
+        # Also test for an instance attribute.
+        class B:
+            pass
+        b = B()
+        b.__dataclass_fields__ = []
+
+        for obj in a, b:
+            with self.subTest(obj=obj):
+                self.assertFalse(is_dataclass(obj))
+
+                # Indirect tests for _is_dataclass_instance().
+                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
+                    asdict(obj)
+                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
+                    astuple(obj)
+                with self.assertRaisesRegex(TypeError, 'should be called on dataclass instances'):
+                    replace(obj, x=0)
+
+    def test_is_dataclass_genericalias(self):
+        @dataclass
+        class A(types.GenericAlias):
+            origin: type
+            args: type
+        self.assertTrue(is_dataclass(A))
+        a = A(list, int)
+        self.assertTrue(is_dataclass(type(a)))
+        self.assertTrue(is_dataclass(a))
+
+    def test_is_dataclass_inheritance(self):
+        @dataclass
+        class X:
+            y: int
+
+        class Z(X):
+            pass
+
+        self.assertTrue(is_dataclass(X), "X should be a dataclass")
+        self.assertTrue(
+            is_dataclass(Z),
+            "Z should be a dataclass because it inherits from X",
+        )
+        z_instance = Z(y=5)
+        self.assertTrue(
+            is_dataclass(z_instance),
+            "z_instance should be a dataclass because it is an instance of Z",
+        )
+
+    def test_helper_fields_with_class_instance(self):
+        # Check that we can call fields() on either a class or instance,
+        #  and get back the same thing.
+        @dataclass
+        class C:
+            x: int
+            y: float
+
+        self.assertEqual(fields(C), fields(C(0, 0.0)))
+
+    def test_helper_fields_exception(self):
+        # Check that TypeError is raised if not passed a dataclass or
+        #  instance.
+        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
+            fields(0)
+
+        class C: pass
+        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
+            fields(C)
+        with self.assertRaisesRegex(TypeError, 'dataclass type or instance'):
+            fields(C())
+
+    def test_clean_traceback_from_fields_exception(self):
+        stdout = io.StringIO()
+        try:
+            fields(object)
+        except TypeError as exc:
+            traceback.print_exception(exc, file=stdout)
+        printed_traceback = stdout.getvalue()
+        self.assertNotIn("AttributeError", printed_traceback)
+        self.assertNotIn("__dataclass_fields__", printed_traceback)
+
+    def test_helper_asdict(self):
+        # Basic tests for asdict(), it should return a new dictionary.
+        @dataclass
+        class C:
+            x: int
+            y: int
+        c = C(1, 2)
+
+        self.assertEqual(asdict(c), {'x': 1, 'y': 2})
+        self.assertEqual(asdict(c), asdict(c))
+        self.assertIsNot(asdict(c), asdict(c))
+        c.x = 42
+        self.assertEqual(asdict(c), {'x': 42, 'y': 2})
+        self.assertIs(type(asdict(c)), dict)
+
+    def test_helper_asdict_raises_on_classes(self):
+        # asdict() should raise on a class object.
+        @dataclass
+        class C:
+            x: int
+            y: int
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            asdict(C)
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            asdict(int)
+
+    def test_helper_asdict_copy_values(self):
+        @dataclass
+        class C:
+            x: int
+            y: List[int] = field(default_factory=list)
+        initial = []
+        c = C(1, initial)
+        d = asdict(c)
+        self.assertEqual(d['y'], initial)
+        self.assertIsNot(d['y'], initial)
+        c = C(1)
+        d = asdict(c)
+        d['y'].append(1)
+        self.assertEqual(c.y, [])
+
+    def test_helper_asdict_nested(self):
+        @dataclass
+        class UserId:
+            token: int
+            group: int
+        @dataclass
+        class User:
+            name: str
+            id: UserId
+        u = User('Joe', UserId(123, 1))
+        d = asdict(u)
+        self.assertEqual(d, {'name': 'Joe', 'id': {'token': 123, 'group': 1}})
+        self.assertIsNot(asdict(u), asdict(u))
+        u.id.group = 2
+        self.assertEqual(asdict(u), {'name': 'Joe',
+                                     'id': {'token': 123, 'group': 2}})
+
+    def test_helper_asdict_builtin_containers(self):
+        @dataclass
+        class User:
+            name: str
+            id: int
+        @dataclass
+        class GroupList:
+            id: int
+            users: List[User]
+        @dataclass
+        class GroupTuple:
+            id: int
+            users: Tuple[User, ...]
+        @dataclass
+        class GroupDict:
+            id: int
+            users: Dict[str, User]
+        a = User('Alice', 1)
+        b = User('Bob', 2)
+        gl = GroupList(0, [a, b])
+        gt = GroupTuple(0, (a, b))
+        gd = GroupDict(0, {'first': a, 'second': b})
+        self.assertEqual(asdict(gl), {'id': 0, 'users': [{'name': 'Alice', 'id': 1},
+                                                         {'name': 'Bob', 'id': 2}]})
+        self.assertEqual(asdict(gt), {'id': 0, 'users': ({'name': 'Alice', 'id': 1},
+                                                         {'name': 'Bob', 'id': 2})})
+        self.assertEqual(asdict(gd), {'id': 0, 'users': {'first': {'name': 'Alice', 'id': 1},
+                                                         'second': {'name': 'Bob', 'id': 2}}})
+
+    def test_helper_asdict_builtin_object_containers(self):
+        @dataclass
+        class Child:
+            d: object
+
+        @dataclass
+        class Parent:
+            child: Child
+
+        self.assertEqual(asdict(Parent(Child([1]))), {'child': {'d': [1]}})
+        self.assertEqual(asdict(Parent(Child({1: 2}))), {'child': {'d': {1: 2}}})
+
+    def test_helper_asdict_factory(self):
+        @dataclass
+        class C:
+            x: int
+            y: int
+        c = C(1, 2)
+        d = asdict(c, dict_factory=OrderedDict)
+        self.assertEqual(d, OrderedDict([('x', 1), ('y', 2)]))
+        self.assertIsNot(d, asdict(c, dict_factory=OrderedDict))
+        c.x = 42
+        d = asdict(c, dict_factory=OrderedDict)
+        self.assertEqual(d, OrderedDict([('x', 42), ('y', 2)]))
+        self.assertIs(type(d), OrderedDict)
+
+    def test_helper_asdict_namedtuple(self):
+        T = namedtuple('T', 'a b c')
+        @dataclass
+        class C:
+            x: str
+            y: T
+        c = C('outer', T(1, C('inner', T(11, 12, 13)), 2))
+
+        d = asdict(c)
+        self.assertEqual(d, {'x': 'outer',
+                             'y': T(1,
+                                    {'x': 'inner',
+                                     'y': T(11, 12, 13)},
+                                    2),
+                             }
+                         )
+
+        # Now with a dict_factory.  OrderedDict is convenient, but
+        # since it compares to dicts, we also need to have separate
+        # assertIs tests.
+        d = asdict(c, dict_factory=OrderedDict)
+        self.assertEqual(d, {'x': 'outer',
+                             'y': T(1,
+                                    {'x': 'inner',
+                                     'y': T(11, 12, 13)},
+                                    2),
+                             }
+                         )
+
+        # Make sure that the returned dicts are actually OrderedDicts.
+        self.assertIs(type(d), OrderedDict)
+        self.assertIs(type(d['y'][1]), OrderedDict)
+
+    def test_helper_asdict_namedtuple_key(self):
+        # Ensure that a field that contains a dict which has a
+        # namedtuple as a key works with asdict().
+
+        @dataclass
+        class C:
+            f: dict
+        T = namedtuple('T', 'a')
+
+        c = C({T('an a'): 0})
+
+        self.assertEqual(asdict(c), {'f': {T(a='an a'): 0}})
+
+    def test_helper_asdict_namedtuple_derived(self):
+        class T(namedtuple('Tbase', 'a')):
+            def my_a(self):
+                return self.a
+
+        @dataclass
+        class C:
+            f: T
+
+        t = T(6)
+        c = C(t)
+
+        d = asdict(c)
+        self.assertEqual(d, {'f': T(a=6)})
+        # Make sure that t has been copied, not used directly.
+        self.assertIsNot(d['f'], t)
+        self.assertEqual(d['f'].my_a(), 6)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_helper_asdict_defaultdict(self):
+        # Ensure asdict() does not throw exceptions when a
+        # defaultdict is a member of a dataclass
+        @dataclass
+        class C:
+            mp: DefaultDict[str, List]
+
+        dd = defaultdict(list)
+        dd["x"].append(12)
+        c = C(mp=dd)
+        d = asdict(c)
+
+        self.assertEqual(d, {"mp": {"x": [12]}})
+        self.assertTrue(d["mp"] is not c.mp)  # make sure defaultdict is copied
+
+    def test_helper_astuple(self):
+        # Basic tests for astuple(), it should return a new tuple.
+        @dataclass
+        class C:
+            x: int
+            y: int = 0
+        c = C(1)
+
+        self.assertEqual(astuple(c), (1, 0))
+        self.assertEqual(astuple(c), astuple(c))
+        self.assertIsNot(astuple(c), astuple(c))
+        c.y = 42
+        self.assertEqual(astuple(c), (1, 42))
+        self.assertIs(type(astuple(c)), tuple)
+
+    def test_helper_astuple_raises_on_classes(self):
+        # astuple() should raise on a class object.
+        @dataclass
+        class C:
+            x: int
+            y: int
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            astuple(C)
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            astuple(int)
+
+    def test_helper_astuple_copy_values(self):
+        @dataclass
+        class C:
+            x: int
+            y: List[int] = field(default_factory=list)
+        initial = []
+        c = C(1, initial)
+        t = astuple(c)
+        self.assertEqual(t[1], initial)
+        self.assertIsNot(t[1], initial)
+        c = C(1)
+        t = astuple(c)
+        t[1].append(1)
+        self.assertEqual(c.y, [])
+
+    def test_helper_astuple_nested(self):
+        @dataclass
+        class UserId:
+            token: int
+            group: int
+        @dataclass
+        class User:
+            name: str
+            id: UserId
+        u = User('Joe', UserId(123, 1))
+        t = astuple(u)
+        self.assertEqual(t, ('Joe', (123, 1)))
+        self.assertIsNot(astuple(u), astuple(u))
+        u.id.group = 2
+        self.assertEqual(astuple(u), ('Joe', (123, 2)))
+
+    def test_helper_astuple_builtin_containers(self):
+        @dataclass
+        class User:
+            name: str
+            id: int
+        @dataclass
+        class GroupList:
+            id: int
+            users: List[User]
+        @dataclass
+        class GroupTuple:
+            id: int
+            users: Tuple[User, ...]
+        @dataclass
+        class GroupDict:
+            id: int
+            users: Dict[str, User]
+        a = User('Alice', 1)
+        b = User('Bob', 2)
+        gl = GroupList(0, [a, b])
+        gt = GroupTuple(0, (a, b))
+        gd = GroupDict(0, {'first': a, 'second': b})
+        self.assertEqual(astuple(gl), (0, [('Alice', 1), ('Bob', 2)]))
+        self.assertEqual(astuple(gt), (0, (('Alice', 1), ('Bob', 2))))
+        self.assertEqual(astuple(gd), (0, {'first': ('Alice', 1), 'second': ('Bob', 2)}))
+
+    def test_helper_astuple_builtin_object_containers(self):
+        @dataclass
+        class Child:
+            d: object
+
+        @dataclass
+        class Parent:
+            child: Child
+
+        self.assertEqual(astuple(Parent(Child([1]))), (([1],),))
+        self.assertEqual(astuple(Parent(Child({1: 2}))), (({1: 2},),))
+
+    def test_helper_astuple_factory(self):
+        @dataclass
+        class C:
+            x: int
+            y: int
+        NT = namedtuple('NT', 'x y')
+        def nt(lst):
+            return NT(*lst)
+        c = C(1, 2)
+        t = astuple(c, tuple_factory=nt)
+        self.assertEqual(t, NT(1, 2))
+        self.assertIsNot(t, astuple(c, tuple_factory=nt))
+        c.x = 42
+        t = astuple(c, tuple_factory=nt)
+        self.assertEqual(t, NT(42, 2))
+        self.assertIs(type(t), NT)
+
+    def test_helper_astuple_namedtuple(self):
+        T = namedtuple('T', 'a b c')
+        @dataclass
+        class C:
+            x: str
+            y: T
+        c = C('outer', T(1, C('inner', T(11, 12, 13)), 2))
+
+        t = astuple(c)
+        self.assertEqual(t, ('outer', T(1, ('inner', (11, 12, 13)), 2)))
+
+        # Now, using a tuple_factory.  list is convenient here.
+        t = astuple(c, tuple_factory=list)
+        self.assertEqual(t, ['outer', T(1, ['inner', T(11, 12, 13)], 2)])
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_helper_astuple_defaultdict(self):
+        # Ensure astuple() does not throw exceptions when a
+        # defaultdict is a member of a dataclass
+        @dataclass
+        class C:
+            mp: DefaultDict[str, List]
+
+        dd = defaultdict(list)
+        dd["x"].append(12)
+        c = C(mp=dd)
+        t = astuple(c)
+
+        self.assertEqual(t, ({"x": [12]},))
+        self.assertTrue(t[0] is not dd) # make sure defaultdict is copied
+
+    def test_dynamic_class_creation(self):
+        cls_dict = {'__annotations__': {'x': int, 'y': int},
+                    }
+
+        # Create the class.
+        cls = type('C', (), cls_dict)
+
+        # Make it a dataclass.
+        cls1 = dataclass(cls)
+
+        self.assertEqual(cls1, cls)
+        self.assertEqual(asdict(cls(1, 2)), {'x': 1, 'y': 2})
+
+    def test_dynamic_class_creation_using_field(self):
+        cls_dict = {'__annotations__': {'x': int, 'y': int},
+                    'y': field(default=5),
+                    }
+
+        # Create the class.
+        cls = type('C', (), cls_dict)
+
+        # Make it a dataclass.
+        cls1 = dataclass(cls)
+
+        self.assertEqual(cls1, cls)
+        self.assertEqual(asdict(cls1(1)), {'x': 1, 'y': 5})
+
+    def test_init_in_order(self):
+        @dataclass
+        class C:
+            a: int
+            b: int = field()
+            c: list = field(default_factory=list, init=False)
+            d: list = field(default_factory=list)
+            e: int = field(default=4, init=False)
+            f: int = 4
+
+        calls = []
+        def setattr(self, name, value):
+            calls.append((name, value))
+
+        C.__setattr__ = setattr
+        c = C(0, 1)
+        self.assertEqual(('a', 0), calls[0])
+        self.assertEqual(('b', 1), calls[1])
+        self.assertEqual(('c', []), calls[2])
+        self.assertEqual(('d', []), calls[3])
+        self.assertNotIn(('e', 4), calls)
+        self.assertEqual(('f', 4), calls[4])
+
+    def test_items_in_dicts(self):
+        @dataclass
+        class C:
+            a: int
+            b: list = field(default_factory=list, init=False)
+            c: list = field(default_factory=list)
+            d: int = field(default=4, init=False)
+            e: int = 0
+
+        c = C(0)
+        # Class dict
+        self.assertNotIn('a', C.__dict__)
+        self.assertNotIn('b', C.__dict__)
+        self.assertNotIn('c', C.__dict__)
+        self.assertIn('d', C.__dict__)
+        self.assertEqual(C.d, 4)
+        self.assertIn('e', C.__dict__)
+        self.assertEqual(C.e, 0)
+        # Instance dict
+        self.assertIn('a', c.__dict__)
+        self.assertEqual(c.a, 0)
+        self.assertIn('b', c.__dict__)
+        self.assertEqual(c.b, [])
+        self.assertIn('c', c.__dict__)
+        self.assertEqual(c.c, [])
+        self.assertNotIn('d', c.__dict__)
+        self.assertIn('e', c.__dict__)
+        self.assertEqual(c.e, 0)
+
+    def test_alternate_classmethod_constructor(self):
+        # Since __post_init__ can't take params, use a classmethod
+        #  alternate constructor.  This is mostly an example to show
+        #  how to use this technique.
+        @dataclass
+        class C:
+            x: int
+            @classmethod
+            def from_file(cls, filename):
+                # In a real example, create a new instance
+                #  and populate 'x' from contents of a file.
+                value_in_file = 20
+                return cls(value_in_file)
+
+        self.assertEqual(C.from_file('filename').x, 20)
+
+    def test_field_metadata_default(self):
+        # Make sure the default metadata is read-only and of
+        #  zero length.
+        @dataclass
+        class C:
+            i: int
+
+        self.assertFalse(fields(C)[0].metadata)
+        self.assertEqual(len(fields(C)[0].metadata), 0)
+        with self.assertRaisesRegex(TypeError,
+                                    'does not support item assignment'):
+            fields(C)[0].metadata['test'] = 3
+
+    def test_field_metadata_mapping(self):
+        # Make sure only a mapping can be passed as metadata
+        #  zero length.
+        with self.assertRaises(TypeError):
+            @dataclass
+            class C:
+                i: int = field(metadata=0)
+
+        # Make sure an empty dict works.
+        d = {}
+        @dataclass
+        class C:
+            i: int = field(metadata=d)
+        self.assertFalse(fields(C)[0].metadata)
+        self.assertEqual(len(fields(C)[0].metadata), 0)
+        # Update should work (see bpo-35960).
+        d['foo'] = 1
+        self.assertEqual(len(fields(C)[0].metadata), 1)
+        self.assertEqual(fields(C)[0].metadata['foo'], 1)
+        with self.assertRaisesRegex(TypeError,
+                                    'does not support item assignment'):
+            fields(C)[0].metadata['test'] = 3
+
+        # Make sure a non-empty dict works.
+        d = {'test': 10, 'bar': '42', 3: 'three'}
+        @dataclass
+        class C:
+            i: int = field(metadata=d)
+        self.assertEqual(len(fields(C)[0].metadata), 3)
+        self.assertEqual(fields(C)[0].metadata['test'], 10)
+        self.assertEqual(fields(C)[0].metadata['bar'], '42')
+        self.assertEqual(fields(C)[0].metadata[3], 'three')
+        # Update should work.
+        d['foo'] = 1
+        self.assertEqual(len(fields(C)[0].metadata), 4)
+        self.assertEqual(fields(C)[0].metadata['foo'], 1)
+        with self.assertRaises(KeyError):
+            # Non-existent key.
+            fields(C)[0].metadata['baz']
+        with self.assertRaisesRegex(TypeError,
+                                    'does not support item assignment'):
+            fields(C)[0].metadata['test'] = 3
+
+    def test_field_metadata_custom_mapping(self):
+        # Try a custom mapping.
+        class SimpleNameSpace:
+            def __init__(self, **kw):
+                self.__dict__.update(kw)
+
+            def __getitem__(self, item):
+                if item == 'xyzzy':
+                    return 'plugh'
+                return getattr(self, item)
+
+            def __len__(self):
+                return self.__dict__.__len__()
+
+        @dataclass
+        class C:
+            i: int = field(metadata=SimpleNameSpace(a=10))
+
+        self.assertEqual(len(fields(C)[0].metadata), 1)
+        self.assertEqual(fields(C)[0].metadata['a'], 10)
+        with self.assertRaises(AttributeError):
+            fields(C)[0].metadata['b']
+        # Make sure we're still talking to our custom mapping.
+        self.assertEqual(fields(C)[0].metadata['xyzzy'], 'plugh')
+
+    def test_generic_dataclasses(self):
+        T = TypeVar('T')
+
+        @dataclass
+        class LabeledBox(Generic[T]):
+            content: T
+            label: str = '<unknown>'
+
+        box = LabeledBox(42)
+        self.assertEqual(box.content, 42)
+        self.assertEqual(box.label, '<unknown>')
+
+        # Subscripting the resulting class should work, etc.
+        Alias = List[LabeledBox[int]]
+
+    def test_generic_extending(self):
+        S = TypeVar('S')
+        T = TypeVar('T')
+
+        @dataclass
+        class Base(Generic[T, S]):
+            x: T
+            y: S
+
+        @dataclass
+        class DataDerived(Base[int, T]):
+            new_field: str
+        Alias = DataDerived[str]
+        c = Alias(0, 'test1', 'test2')
+        self.assertEqual(astuple(c), (0, 'test1', 'test2'))
+
+        class NonDataDerived(Base[int, T]):
+            def new_method(self):
+                return self.y
+        Alias = NonDataDerived[float]
+        c = Alias(10, 1.0)
+        self.assertEqual(c.new_method(), 1.0)
+
+    def test_generic_dynamic(self):
+        T = TypeVar('T')
+
+        @dataclass
+        class Parent(Generic[T]):
+            x: T
+        Child = make_dataclass('Child', [('y', T), ('z', Optional[T], None)],
+                               bases=(Parent[int], Generic[T]), namespace={'other': 42})
+        self.assertIs(Child[int](1, 2).z, None)
+        self.assertEqual(Child[int](1, 2, 3).z, 3)
+        self.assertEqual(Child[int](1, 2, 3).other, 42)
+        # Check that type aliases work correctly.
+        Alias = Child[T]
+        self.assertEqual(Alias[int](1, 2).x, 1)
+        # Check MRO resolution.
+        self.assertEqual(Child.__mro__, (Child, Parent, Generic, object))
+
+    def test_dataclasses_pickleable(self):
+        global P, Q, R
+        @dataclass
+        class P:
+            x: int
+            y: int = 0
+        @dataclass
+        class Q:
+            x: int
+            y: int = field(default=0, init=False)
+        @dataclass
+        class R:
+            x: int
+            y: List[int] = field(default_factory=list)
+        q = Q(1)
+        q.y = 2
+        samples = [P(1), P(1, 2), Q(1), q, R(1), R(1, [2, 3, 4])]
+        for sample in samples:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(sample=sample, proto=proto):
+                    new_sample = pickle.loads(pickle.dumps(sample, proto))
+                    self.assertEqual(sample.x, new_sample.x)
+                    self.assertEqual(sample.y, new_sample.y)
+                    self.assertIsNot(sample, new_sample)
+                    new_sample.x = 42
+                    another_new_sample = pickle.loads(pickle.dumps(new_sample, proto))
+                    self.assertEqual(new_sample.x, another_new_sample.x)
+                    self.assertEqual(sample.y, another_new_sample.y)
+
+    def test_dataclasses_qualnames(self):
+        @dataclass(order=True, unsafe_hash=True, frozen=True)
+        class A:
+            x: int
+            y: int
+
+        self.assertEqual(A.__init__.__name__, "__init__")
+        for function in (
+            '__eq__',
+            '__lt__',
+            '__le__',
+            '__gt__',
+            '__ge__',
+            '__hash__',
+            '__init__',
+            '__repr__',
+            '__setattr__',
+            '__delattr__',
+        ):
+            self.assertEqual(getattr(A, function).__qualname__, f"TestCase.test_dataclasses_qualnames.<locals>.A.{function}")
+
+        with self.assertRaisesRegex(TypeError, r"A\.__init__\(\) missing"):
+            A()
+
+
+class TestFieldNoAnnotation(unittest.TestCase):
+    def test_field_without_annotation(self):
+        with self.assertRaisesRegex(TypeError,
+                                    "'f' is a field but has no type annotation"):
+            @dataclass
+            class C:
+                f = field()
+
+    def test_field_without_annotation_but_annotation_in_base(self):
+        @dataclass
+        class B:
+            f: int
+
+        with self.assertRaisesRegex(TypeError,
+                                    "'f' is a field but has no type annotation"):
+            # This is still an error: make sure we don't pick up the
+            #  type annotation in the base class.
+            @dataclass
+            class C(B):
+                f = field()
+
+    def test_field_without_annotation_but_annotation_in_base_not_dataclass(self):
+        # Same test, but with the base class not a dataclass.
+        class B:
+            f: int
+
+        with self.assertRaisesRegex(TypeError,
+                                    "'f' is a field but has no type annotation"):
+            # This is still an error: make sure we don't pick up the
+            #  type annotation in the base class.
+            @dataclass
+            class C(B):
+                f = field()
+
+
+class TestDocString(unittest.TestCase):
+    def assertDocStrEqual(self, a, b):
+        # Because 3.6 and 3.7 differ in how inspect.signature work
+        #  (see bpo #32108), for the time being just compare them with
+        #  whitespace stripped.
+        self.assertEqual(a.replace(' ', ''), b.replace(' ', ''))
+
+    @support.requires_docstrings
+    def test_existing_docstring_not_overridden(self):
+        @dataclass
+        class C:
+            """Lorem ipsum"""
+            x: int
+
+        self.assertEqual(C.__doc__, "Lorem ipsum")
+
+    def test_docstring_no_fields(self):
+        @dataclass
+        class C:
+            pass
+
+        self.assertDocStrEqual(C.__doc__, "C()")
+
+    def test_docstring_one_field(self):
+        @dataclass
+        class C:
+            x: int
+
+        self.assertDocStrEqual(C.__doc__, "C(x:int)")
+
+    def test_docstring_two_fields(self):
+        @dataclass
+        class C:
+            x: int
+            y: int
+
+        self.assertDocStrEqual(C.__doc__, "C(x:int, y:int)")
+
+    def test_docstring_three_fields(self):
+        @dataclass
+        class C:
+            x: int
+            y: int
+            z: str
+
+        self.assertDocStrEqual(C.__doc__, "C(x:int, y:int, z:str)")
+
+    def test_docstring_one_field_with_default(self):
+        @dataclass
+        class C:
+            x: int = 3
+
+        self.assertDocStrEqual(C.__doc__, "C(x:int=3)")
+
+    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)")
+
+    def test_docstring_list_field(self):
+        @dataclass
+        class C:
+            x: List[int]
+
+        self.assertDocStrEqual(C.__doc__, "C(x:List[int])")
+
+    def test_docstring_list_field_with_default_factory(self):
+        @dataclass
+        class C:
+            x: List[int] = field(default_factory=list)
+
+        self.assertDocStrEqual(C.__doc__, "C(x:List[int]=<factory>)")
+
+    def test_docstring_deque_field(self):
+        @dataclass
+        class C:
+            x: deque
+
+        self.assertDocStrEqual(C.__doc__, "C(x:collections.deque)")
+
+    def test_docstring_deque_field_with_default_factory(self):
+        @dataclass
+        class C:
+            x: deque = field(default_factory=deque)
+
+        self.assertDocStrEqual(C.__doc__, "C(x:collections.deque=<factory>)")
+
+    def test_docstring_with_no_signature(self):
+        # See https://github.com/python/cpython/issues/103449
+        class Meta(type):
+            __call__ = dict
+        class Base(metaclass=Meta):
+            pass
+
+        @dataclass
+        class C(Base):
+            pass
+
+        self.assertDocStrEqual(C.__doc__, "C")
+
+
+class TestInit(unittest.TestCase):
+    def test_base_has_init(self):
+        class B:
+            def __init__(self):
+                self.z = 100
+
+        # Make sure that declaring this class doesn't raise an error.
+        #  The issue is that we can't override __init__ in our class,
+        #  but it should be okay to add __init__ to us if our base has
+        #  an __init__.
+        @dataclass
+        class C(B):
+            x: int = 0
+        c = C(10)
+        self.assertEqual(c.x, 10)
+        self.assertNotIn('z', vars(c))
+
+        # Make sure that if we don't add an init, the base __init__
+        #  gets called.
+        @dataclass(init=False)
+        class C(B):
+            x: int = 10
+        c = C()
+        self.assertEqual(c.x, 10)
+        self.assertEqual(c.z, 100)
+
+    def test_no_init(self):
+        @dataclass(init=False)
+        class C:
+            i: int = 0
+        self.assertEqual(C().i, 0)
+
+        @dataclass(init=False)
+        class C:
+            i: int = 2
+            def __init__(self):
+                self.i = 3
+        self.assertEqual(C().i, 3)
+
+    def test_overwriting_init(self):
+        # If the class has __init__, use it no matter the value of
+        #  init=.
+
+        @dataclass
+        class C:
+            x: int
+            def __init__(self, x):
+                self.x = 2 * x
+        self.assertEqual(C(3).x, 6)
+
+        @dataclass(init=True)
+        class C:
+            x: int
+            def __init__(self, x):
+                self.x = 2 * x
+        self.assertEqual(C(4).x, 8)
+
+        @dataclass(init=False)
+        class C:
+            x: int
+            def __init__(self, x):
+                self.x = 2 * x
+        self.assertEqual(C(5).x, 10)
+
+    def test_inherit_from_protocol(self):
+        # Dataclasses inheriting from protocol should preserve their own `__init__`.
+        # See bpo-45081.
+
+        class P(Protocol):
+            a: int
+
+        @dataclass
+        class C(P):
+            a: int
+
+        self.assertEqual(C(5).a, 5)
+
+        @dataclass
+        class D(P):
+            def __init__(self, a):
+                self.a = a * 2
+
+        self.assertEqual(D(5).a, 10)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr(self):
+        @dataclass
+        class B:
+            x: int
+
+        @dataclass
+        class C(B):
+            y: int = 10
+
+        o = C(4)
+        self.assertEqual(repr(o), 'TestRepr.test_repr.<locals>.C(x=4, y=10)')
+
+        @dataclass
+        class D(C):
+            x: int = 20
+        self.assertEqual(repr(D()), 'TestRepr.test_repr.<locals>.D(x=20, y=10)')
+
+        @dataclass
+        class C:
+            @dataclass
+            class D:
+                i: int
+            @dataclass
+            class E:
+                pass
+        self.assertEqual(repr(C.D(0)), 'TestRepr.test_repr.<locals>.C.D(i=0)')
+        self.assertEqual(repr(C.E()), 'TestRepr.test_repr.<locals>.C.E()')
+
+    def test_no_repr(self):
+        # Test a class with no __repr__ and repr=False.
+        @dataclass(repr=False)
+        class C:
+            x: int
+        self.assertIn(f'{__name__}.TestRepr.test_no_repr.<locals>.C object at',
+                      repr(C(3)))
+
+        # Test a class with a __repr__ and repr=False.
+        @dataclass(repr=False)
+        class C:
+            x: int
+            def __repr__(self):
+                return 'C-class'
+        self.assertEqual(repr(C(3)), 'C-class')
+
+    def test_overwriting_repr(self):
+        # If the class has __repr__, use it no matter the value of
+        #  repr=.
+
+        @dataclass
+        class C:
+            x: int
+            def __repr__(self):
+                return 'x'
+        self.assertEqual(repr(C(0)), 'x')
+
+        @dataclass(repr=True)
+        class C:
+            x: int
+            def __repr__(self):
+                return 'x'
+        self.assertEqual(repr(C(0)), 'x')
+
+        @dataclass(repr=False)
+        class C:
+            x: int
+            def __repr__(self):
+                return 'x'
+        self.assertEqual(repr(C(0)), 'x')
+
+
+class TestEq(unittest.TestCase):
+    def test_recursive_eq(self):
+        # Test a class with recursive child
+        @dataclass
+        class C:
+            recursive: object = ...
+        c = C()
+        c.recursive = c
+        self.assertEqual(c, c)
+
+    def test_no_eq(self):
+        # Test a class with no __eq__ and eq=False.
+        @dataclass(eq=False)
+        class C:
+            x: int
+        self.assertNotEqual(C(0), C(0))
+        c = C(3)
+        self.assertEqual(c, c)
+
+        # Test a class with an __eq__ and eq=False.
+        @dataclass(eq=False)
+        class C:
+            x: int
+            def __eq__(self, other):
+                return other == 10
+        self.assertEqual(C(3), 10)
+
+    def test_overwriting_eq(self):
+        # If the class has __eq__, use it no matter the value of
+        #  eq=.
+
+        @dataclass
+        class C:
+            x: int
+            def __eq__(self, other):
+                return other == 3
+        self.assertEqual(C(1), 3)
+        self.assertNotEqual(C(1), 1)
+
+        @dataclass(eq=True)
+        class C:
+            x: int
+            def __eq__(self, other):
+                return other == 4
+        self.assertEqual(C(1), 4)
+        self.assertNotEqual(C(1), 1)
+
+        @dataclass(eq=False)
+        class C:
+            x: int
+            def __eq__(self, other):
+                return other == 5
+        self.assertEqual(C(1), 5)
+        self.assertNotEqual(C(1), 1)
+
+
+class TestOrdering(unittest.TestCase):
+    def test_functools_total_ordering(self):
+        # Test that functools.total_ordering works with this class.
+        @total_ordering
+        @dataclass
+        class C:
+            x: int
+            def __lt__(self, other):
+                # Perform the test "backward", just to make
+                #  sure this is being called.
+                return self.x >= other
+
+        self.assertLess(C(0), -1)
+        self.assertLessEqual(C(0), -1)
+        self.assertGreater(C(0), 1)
+        self.assertGreaterEqual(C(0), 1)
+
+    def test_no_order(self):
+        # Test that no ordering functions are added by default.
+        @dataclass(order=False)
+        class C:
+            x: int
+        # Make sure no order methods are added.
+        self.assertNotIn('__le__', C.__dict__)
+        self.assertNotIn('__lt__', C.__dict__)
+        self.assertNotIn('__ge__', C.__dict__)
+        self.assertNotIn('__gt__', C.__dict__)
+
+        # Test that __lt__ is still called
+        @dataclass(order=False)
+        class C:
+            x: int
+            def __lt__(self, other):
+                return False
+        # Make sure other methods aren't added.
+        self.assertNotIn('__le__', C.__dict__)
+        self.assertNotIn('__ge__', C.__dict__)
+        self.assertNotIn('__gt__', C.__dict__)
+
+    def test_overwriting_order(self):
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __lt__'
+                                    '.*using functools.total_ordering'):
+            @dataclass(order=True)
+            class C:
+                x: int
+                def __lt__(self):
+                    pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __le__'
+                                    '.*using functools.total_ordering'):
+            @dataclass(order=True)
+            class C:
+                x: int
+                def __le__(self):
+                    pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __gt__'
+                                    '.*using functools.total_ordering'):
+            @dataclass(order=True)
+            class C:
+                x: int
+                def __gt__(self):
+                    pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __ge__'
+                                    '.*using functools.total_ordering'):
+            @dataclass(order=True)
+            class C:
+                x: int
+                def __ge__(self):
+                    pass
+
+class TestHash(unittest.TestCase):
+    def test_unsafe_hash(self):
+        @dataclass(unsafe_hash=True)
+        class C:
+            x: int
+            y: str
+        self.assertEqual(hash(C(1, 'foo')), hash((1, 'foo')))
+
+    def test_hash_rules(self):
+        def non_bool(value):
+            # Map to something else that's True, but not a bool.
+            if value is None:
+                return None
+            if value:
+                return (3,)
+            return 0
+
+        def test(case, unsafe_hash, eq, frozen, with_hash, result):
+            with self.subTest(case=case, unsafe_hash=unsafe_hash, eq=eq,
+                              frozen=frozen):
+                if result != 'exception':
+                    if with_hash:
+                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
+                        class C:
+                            def __hash__(self):
+                                return 0
+                    else:
+                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
+                        class C:
+                            pass
+
+                # See if the result matches what's expected.
+                if result == 'fn':
+                    # __hash__ contains the function we generated.
+                    self.assertIn('__hash__', C.__dict__)
+                    self.assertIsNotNone(C.__dict__['__hash__'])
+
+                elif result == '':
+                    # __hash__ is not present in our class.
+                    if not with_hash:
+                        self.assertNotIn('__hash__', C.__dict__)
+
+                elif result == 'none':
+                    # __hash__ is set to None.
+                    self.assertIn('__hash__', C.__dict__)
+                    self.assertIsNone(C.__dict__['__hash__'])
+
+                elif result == 'exception':
+                    # Creating the class should cause an exception.
+                    #  This only happens with with_hash==True.
+                    assert(with_hash)
+                    with self.assertRaisesRegex(TypeError, 'Cannot overwrite attribute __hash__'):
+                        @dataclass(unsafe_hash=unsafe_hash, eq=eq, frozen=frozen)
+                        class C:
+                            def __hash__(self):
+                                return 0
+
+                else:
+                    assert False, f'unknown result {result!r}'
+
+        # There are 8 cases of:
+        #  unsafe_hash=True/False
+        #  eq=True/False
+        #  frozen=True/False
+        # And for each of these, a different result if
+        #  __hash__ is defined or not.
+        for case, (unsafe_hash,  eq,    frozen, res_no_defined_hash, res_defined_hash) in enumerate([
+                  (False,        False, False,  '',                  ''),
+                  (False,        False, True,   '',                  ''),
+                  (False,        True,  False,  'none',              ''),
+                  (False,        True,  True,   'fn',                ''),
+                  (True,         False, False,  'fn',                'exception'),
+                  (True,         False, True,   'fn',                'exception'),
+                  (True,         True,  False,  'fn',                'exception'),
+                  (True,         True,  True,   'fn',                'exception'),
+                  ], 1):
+            test(case, unsafe_hash, eq, frozen, False, res_no_defined_hash)
+            test(case, unsafe_hash, eq, frozen, True,  res_defined_hash)
+
+            # Test non-bool truth values, too.  This is just to
+            #  make sure the data-driven table in the decorator
+            #  handles non-bool values.
+            test(case, non_bool(unsafe_hash), non_bool(eq), non_bool(frozen), False, res_no_defined_hash)
+            test(case, non_bool(unsafe_hash), non_bool(eq), non_bool(frozen), True,  res_defined_hash)
+
+
+    def test_eq_only(self):
+        # If a class defines __eq__, __hash__ is automatically added
+        #  and set to None.  This is normal Python behavior, not
+        #  related to dataclasses.  Make sure we don't interfere with
+        #  that (see bpo=32546).
+
+        @dataclass
+        class C:
+            i: int
+            def __eq__(self, other):
+                return self.i == other.i
+        self.assertEqual(C(1), C(1))
+        self.assertNotEqual(C(1), C(4))
+
+        # And make sure things work in this case if we specify
+        #  unsafe_hash=True.
+        @dataclass(unsafe_hash=True)
+        class C:
+            i: int
+            def __eq__(self, other):
+                return self.i == other.i
+        self.assertEqual(C(1), C(1.0))
+        self.assertEqual(hash(C(1)), hash(C(1.0)))
+
+        # And check that the classes __eq__ is being used, despite
+        #  specifying eq=True.
+        @dataclass(unsafe_hash=True, eq=True)
+        class C:
+            i: int
+            def __eq__(self, other):
+                return self.i == 3 and self.i == other.i
+        self.assertEqual(C(3), C(3))
+        self.assertNotEqual(C(1), C(1))
+        self.assertEqual(hash(C(1)), hash(C(1.0)))
+
+    def test_0_field_hash(self):
+        @dataclass(frozen=True)
+        class C:
+            pass
+        self.assertEqual(hash(C()), hash(()))
+
+        @dataclass(unsafe_hash=True)
+        class C:
+            pass
+        self.assertEqual(hash(C()), hash(()))
+
+    def test_1_field_hash(self):
+        @dataclass(frozen=True)
+        class C:
+            x: int
+        self.assertEqual(hash(C(4)), hash((4,)))
+        self.assertEqual(hash(C(42)), hash((42,)))
+
+        @dataclass(unsafe_hash=True)
+        class C:
+            x: int
+        self.assertEqual(hash(C(4)), hash((4,)))
+        self.assertEqual(hash(C(42)), hash((42,)))
+
+    def test_hash_no_args(self):
+        # Test dataclasses with no hash= argument.  This exists to
+        #  make sure that if the @dataclass parameter name is changed
+        #  or the non-default hashing behavior changes, the default
+        #  hashability keeps working the same way.
+
+        class Base:
+            def __hash__(self):
+                return 301
+
+        # If frozen or eq is None, then use the default value (do not
+        #  specify any value in the decorator).
+        for frozen, eq,    base,   expected       in [
+            (None,  None,  object, 'unhashable'),
+            (None,  None,  Base,   'unhashable'),
+            (None,  False, object, 'object'),
+            (None,  False, Base,   'base'),
+            (None,  True,  object, 'unhashable'),
+            (None,  True,  Base,   'unhashable'),
+            (False, None,  object, 'unhashable'),
+            (False, None,  Base,   'unhashable'),
+            (False, False, object, 'object'),
+            (False, False, Base,   'base'),
+            (False, True,  object, 'unhashable'),
+            (False, True,  Base,   'unhashable'),
+            (True,  None,  object, 'tuple'),
+            (True,  None,  Base,   'tuple'),
+            (True,  False, object, 'object'),
+            (True,  False, Base,   'base'),
+            (True,  True,  object, 'tuple'),
+            (True,  True,  Base,   'tuple'),
+            ]:
+
+            with self.subTest(frozen=frozen, eq=eq, base=base, expected=expected):
+                # First, create the class.
+                if frozen is None and eq is None:
+                    @dataclass
+                    class C(base):
+                        i: int
+                elif frozen is None:
+                    @dataclass(eq=eq)
+                    class C(base):
+                        i: int
+                elif eq is None:
+                    @dataclass(frozen=frozen)
+                    class C(base):
+                        i: int
+                else:
+                    @dataclass(frozen=frozen, eq=eq)
+                    class C(base):
+                        i: int
+
+                # Now, make sure it hashes as expected.
+                if expected == 'unhashable':
+                    c = C(10)
+                    with self.assertRaisesRegex(TypeError, 'unhashable type'):
+                        hash(c)
+
+                elif expected == 'base':
+                    self.assertEqual(hash(C(10)), 301)
+
+                elif expected == 'object':
+                    # I'm not sure what test to use here.  object's
+                    #  hash isn't based on id(), so calling hash()
+                    #  won't tell us much.  So, just check the
+                    #  function used is object's.
+                    self.assertIs(C.__hash__, object.__hash__)
+
+                elif expected == 'tuple':
+                    self.assertEqual(hash(C(42)), hash((42,)))
+
+                else:
+                    assert False, f'unknown value for expected={expected!r}'
+
+
+class TestFrozen(unittest.TestCase):
+    def test_frozen(self):
+        @dataclass(frozen=True)
+        class C:
+            i: int
+
+        c = C(10)
+        self.assertEqual(c.i, 10)
+        with self.assertRaises(FrozenInstanceError):
+            c.i = 5
+        self.assertEqual(c.i, 10)
+
+    def test_frozen_empty(self):
+        @dataclass(frozen=True)
+        class C:
+            pass
+
+        c = C()
+        self.assertFalse(hasattr(c, 'i'))
+        with self.assertRaises(FrozenInstanceError):
+            c.i = 5
+        self.assertFalse(hasattr(c, 'i'))
+        with self.assertRaises(FrozenInstanceError):
+            del c.i
+
+    def test_inherit(self):
+        @dataclass(frozen=True)
+        class C:
+            i: int
+
+        @dataclass(frozen=True)
+        class D(C):
+            j: int
+
+        d = D(0, 10)
+        with self.assertRaises(FrozenInstanceError):
+            d.i = 5
+        with self.assertRaises(FrozenInstanceError):
+            d.j = 6
+        self.assertEqual(d.i, 0)
+        self.assertEqual(d.j, 10)
+
+    def test_inherit_nonfrozen_from_empty_frozen(self):
+        @dataclass(frozen=True)
+        class C:
+            pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'cannot inherit non-frozen dataclass from a frozen one'):
+            @dataclass
+            class D(C):
+                j: int
+
+    def test_inherit_frozen_mutliple_inheritance(self):
+        @dataclass
+        class NotFrozen:
+            pass
+
+        @dataclass(frozen=True)
+        class Frozen:
+            pass
+
+        class NotDataclass:
+            pass
+
+        for bases in (
+            (NotFrozen, Frozen),
+            (Frozen, NotFrozen),
+            (Frozen, NotDataclass),
+            (NotDataclass, Frozen),
+        ):
+            with self.subTest(bases=bases):
+                with self.assertRaisesRegex(
+                    TypeError,
+                    'cannot inherit non-frozen dataclass from a frozen one',
+                ):
+                    @dataclass
+                    class NotFrozenChild(*bases):
+                        pass
+
+        for bases in (
+            (NotFrozen, Frozen),
+            (Frozen, NotFrozen),
+            (NotFrozen, NotDataclass),
+            (NotDataclass, NotFrozen),
+        ):
+            with self.subTest(bases=bases):
+                with self.assertRaisesRegex(
+                    TypeError,
+                    'cannot inherit frozen dataclass from a non-frozen one',
+                ):
+                    @dataclass(frozen=True)
+                    class FrozenChild(*bases):
+                        pass
+
+    def test_inherit_frozen_mutliple_inheritance_regular_mixins(self):
+        @dataclass(frozen=True)
+        class Frozen:
+            pass
+
+        class NotDataclass:
+            pass
+
+        class C1(Frozen, NotDataclass):
+            pass
+        self.assertEqual(C1.__mro__, (C1, Frozen, NotDataclass, object))
+
+        class C2(NotDataclass, Frozen):
+            pass
+        self.assertEqual(C2.__mro__, (C2, NotDataclass, Frozen, object))
+
+        @dataclass(frozen=True)
+        class C3(Frozen, NotDataclass):
+            pass
+        self.assertEqual(C3.__mro__, (C3, Frozen, NotDataclass, object))
+
+        @dataclass(frozen=True)
+        class C4(NotDataclass, Frozen):
+            pass
+        self.assertEqual(C4.__mro__, (C4, NotDataclass, Frozen, object))
+
+    def test_multiple_frozen_dataclasses_inheritance(self):
+        @dataclass(frozen=True)
+        class FrozenA:
+            pass
+
+        @dataclass(frozen=True)
+        class FrozenB:
+            pass
+
+        class C1(FrozenA, FrozenB):
+            pass
+        self.assertEqual(C1.__mro__, (C1, FrozenA, FrozenB, object))
+
+        class C2(FrozenB, FrozenA):
+            pass
+        self.assertEqual(C2.__mro__, (C2, FrozenB, FrozenA, object))
+
+        @dataclass(frozen=True)
+        class C3(FrozenA, FrozenB):
+            pass
+        self.assertEqual(C3.__mro__, (C3, FrozenA, FrozenB, object))
+
+        @dataclass(frozen=True)
+        class C4(FrozenB, FrozenA):
+            pass
+        self.assertEqual(C4.__mro__, (C4, FrozenB, FrozenA, object))
+
+    def test_inherit_nonfrozen_from_empty(self):
+        @dataclass
+        class C:
+            pass
+
+        @dataclass
+        class D(C):
+            j: int
+
+        d = D(3)
+        self.assertEqual(d.j, 3)
+        self.assertIsInstance(d, C)
+
+    # Test both ways: with an intermediate normal (non-dataclass)
+    #  class and without an intermediate class.
+    def test_inherit_nonfrozen_from_frozen(self):
+        for intermediate_class in [True, False]:
+            with self.subTest(intermediate_class=intermediate_class):
+                @dataclass(frozen=True)
+                class C:
+                    i: int
+
+                if intermediate_class:
+                    class I(C): pass
+                else:
+                    I = C
+
+                with self.assertRaisesRegex(TypeError,
+                                            'cannot inherit non-frozen dataclass from a frozen one'):
+                    @dataclass
+                    class D(I):
+                        pass
+
+    def test_inherit_frozen_from_nonfrozen(self):
+        for intermediate_class in [True, False]:
+            with self.subTest(intermediate_class=intermediate_class):
+                @dataclass
+                class C:
+                    i: int
+
+                if intermediate_class:
+                    class I(C): pass
+                else:
+                    I = C
+
+                with self.assertRaisesRegex(TypeError,
+                                            'cannot inherit frozen dataclass from a non-frozen one'):
+                    @dataclass(frozen=True)
+                    class D(I):
+                        pass
+
+    def test_inherit_from_normal_class(self):
+        for intermediate_class in [True, False]:
+            with self.subTest(intermediate_class=intermediate_class):
+                class C:
+                    pass
+
+                if intermediate_class:
+                    class I(C): pass
+                else:
+                    I = C
+
+                @dataclass(frozen=True)
+                class D(I):
+                    i: int
+
+            d = D(10)
+            with self.assertRaises(FrozenInstanceError):
+                d.i = 5
+
+    def test_non_frozen_normal_derived(self):
+        # See bpo-32953.
+
+        @dataclass(frozen=True)
+        class D:
+            x: int
+            y: int = 10
+
+        class S(D):
+            pass
+
+        s = S(3)
+        self.assertEqual(s.x, 3)
+        self.assertEqual(s.y, 10)
+        s.cached = True
+
+        # But can't change the frozen attributes.
+        with self.assertRaises(FrozenInstanceError):
+            s.x = 5
+        with self.assertRaises(FrozenInstanceError):
+            s.y = 5
+        self.assertEqual(s.x, 3)
+        self.assertEqual(s.y, 10)
+        self.assertEqual(s.cached, True)
+
+        with self.assertRaises(FrozenInstanceError):
+            del s.x
+        self.assertEqual(s.x, 3)
+        with self.assertRaises(FrozenInstanceError):
+            del s.y
+        self.assertEqual(s.y, 10)
+        del s.cached
+        self.assertFalse(hasattr(s, 'cached'))
+        with self.assertRaises(AttributeError) as cm:
+            del s.cached
+        self.assertNotIsInstance(cm.exception, FrozenInstanceError)
+
+    def test_non_frozen_normal_derived_from_empty_frozen(self):
+        @dataclass(frozen=True)
+        class D:
+            pass
+
+        class S(D):
+            pass
+
+        s = S()
+        self.assertFalse(hasattr(s, 'x'))
+        s.x = 5
+        self.assertEqual(s.x, 5)
+
+        del s.x
+        self.assertFalse(hasattr(s, 'x'))
+        with self.assertRaises(AttributeError) as cm:
+            del s.x
+        self.assertNotIsInstance(cm.exception, FrozenInstanceError)
+
+    def test_overwriting_frozen(self):
+        # frozen uses __setattr__ and __delattr__.
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __setattr__'):
+            @dataclass(frozen=True)
+            class C:
+                x: int
+                def __setattr__(self):
+                    pass
+
+        with self.assertRaisesRegex(TypeError,
+                                    'Cannot overwrite attribute __delattr__'):
+            @dataclass(frozen=True)
+            class C:
+                x: int
+                def __delattr__(self):
+                    pass
+
+        @dataclass(frozen=False)
+        class C:
+            x: int
+            def __setattr__(self, name, value):
+                self.__dict__['x'] = value * 2
+        self.assertEqual(C(10).x, 20)
+
+    def test_frozen_hash(self):
+        @dataclass(frozen=True)
+        class C:
+            x: Any
+
+        # If x is immutable, we can compute the hash.  No exception is
+        # raised.
+        hash(C(3))
+
+        # If x is mutable, computing the hash is an error.
+        with self.assertRaisesRegex(TypeError, 'unhashable type'):
+            hash(C({}))
+
+    def test_frozen_deepcopy_without_slots(self):
+        # see: https://github.com/python/cpython/issues/89683
+        @dataclass(frozen=True, slots=False)
+        class C:
+            s: str
+
+        c = C('hello')
+        self.assertEqual(deepcopy(c), c)
+
+    def test_frozen_deepcopy_with_slots(self):
+        # see: https://github.com/python/cpython/issues/89683
+        with self.subTest('generated __slots__'):
+            @dataclass(frozen=True, slots=True)
+            class C:
+                s: str
+
+            c = C('hello')
+            self.assertEqual(deepcopy(c), c)
+
+        with self.subTest('user-defined __slots__ and no __{get,set}state__'):
+            @dataclass(frozen=True, slots=False)
+            class C:
+                __slots__ = ('s',)
+                s: str
+
+            # with user-defined slots, __getstate__ and __setstate__ are not
+            # automatically added, hence the error
+            err = r"^cannot\ assign\ to\ field\ 's'$"
+            self.assertRaisesRegex(FrozenInstanceError, err, deepcopy, C(''))
+
+        with self.subTest('user-defined __slots__ and __{get,set}state__'):
+            @dataclass(frozen=True, slots=False)
+            class C:
+                __slots__ = ('s',)
+                __getstate__ = dataclasses._dataclass_getstate
+                __setstate__ = dataclasses._dataclass_setstate
+
+                s: str
+
+            c = C('hello')
+            self.assertEqual(deepcopy(c), c)
+
+
+class TestSlots(unittest.TestCase):
+    def test_simple(self):
+        @dataclass
+        class C:
+            __slots__ = ('x',)
+            x: Any
+
+        # There was a bug where a variable in a slot was assumed to
+        #  also have a default value (of type
+        #  types.MemberDescriptorType).
+        with self.assertRaisesRegex(TypeError,
+                                    r"__init__\(\) missing 1 required positional argument: 'x'"):
+            C()
+
+        # We can create an instance, and assign to x.
+        c = C(10)
+        self.assertEqual(c.x, 10)
+        c.x = 5
+        self.assertEqual(c.x, 5)
+
+        # We can't assign to anything else.
+        with self.assertRaisesRegex(AttributeError, "'C' object has no attribute 'y'"):
+            c.y = 5
+
+    def test_derived_added_field(self):
+        # See bpo-33100.
+        @dataclass
+        class Base:
+            __slots__ = ('x',)
+            x: Any
+
+        @dataclass
+        class Derived(Base):
+            x: int
+            y: int
+
+        d = Derived(1, 2)
+        self.assertEqual((d.x, d.y), (1, 2))
+
+        # We can add a new field to the derived instance.
+        d.z = 10
+
+    def test_generated_slots(self):
+        @dataclass(slots=True)
+        class C:
+            x: int
+            y: int
+
+        c = C(1, 2)
+        self.assertEqual((c.x, c.y), (1, 2))
+
+        c.x = 3
+        c.y = 4
+        self.assertEqual((c.x, c.y), (3, 4))
+
+        with self.assertRaisesRegex(AttributeError, "'C' object has no attribute 'z'"):
+            c.z = 5
+
+    def test_add_slots_when_slots_exists(self):
+        with self.assertRaisesRegex(TypeError, '^C already specifies __slots__$'):
+            @dataclass(slots=True)
+            class C:
+                __slots__ = ('x',)
+                x: int
+
+    def test_generated_slots_value(self):
+
+        class Root:
+            __slots__ = {'x'}
+
+        class Root2(Root):
+            __slots__ = {'k': '...', 'j': ''}
+
+        class Root3(Root2):
+            __slots__ = ['h']
+
+        class Root4(Root3):
+            __slots__ = 'aa'
+
+        @dataclass(slots=True)
+        class Base(Root4):
+            y: int
+            j: str
+            h: str
+
+        self.assertEqual(Base.__slots__, ('y', ))
+
+        @dataclass(slots=True)
+        class Derived(Base):
+            aa: float
+            x: str
+            z: int
+            k: str
+            h: str
+
+        self.assertEqual(Derived.__slots__, ('z', ))
+
+        @dataclass
+        class AnotherDerived(Base):
+            z: int
+
+        self.assertNotIn('__slots__', AnotherDerived.__dict__)
+
+    def test_cant_inherit_from_iterator_slots(self):
+
+        class Root:
+            __slots__ = iter(['a'])
+
+        class Root2(Root):
+            __slots__ = ('b', )
+
+        with self.assertRaisesRegex(
+           TypeError,
+            "^Slots of 'Root' cannot be determined"
+        ):
+            @dataclass(slots=True)
+            class C(Root2):
+                x: int
+
+    def test_returns_new_class(self):
+        class A:
+            x: int
+
+        B = dataclass(A, slots=True)
+        self.assertIsNot(A, B)
+
+        self.assertFalse(hasattr(A, "__slots__"))
+        self.assertTrue(hasattr(B, "__slots__"))
+
+    # Can't be local to test_frozen_pickle.
+    @dataclass(frozen=True, slots=True)
+    class FrozenSlotsClass:
+        foo: str
+        bar: int
+
+    @dataclass(frozen=True)
+    class FrozenWithoutSlotsClass:
+        foo: str
+        bar: int
+
+    def test_frozen_pickle(self):
+        # bpo-43999
+
+        self.assertEqual(self.FrozenSlotsClass.__slots__, ("foo", "bar"))
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                obj = self.FrozenSlotsClass("a", 1)
+                p = pickle.loads(pickle.dumps(obj, protocol=proto))
+                self.assertIsNot(obj, p)
+                self.assertEqual(obj, p)
+
+                obj = self.FrozenWithoutSlotsClass("a", 1)
+                p = pickle.loads(pickle.dumps(obj, protocol=proto))
+                self.assertIsNot(obj, p)
+                self.assertEqual(obj, p)
+
+    @dataclass(frozen=True, slots=True)
+    class FrozenSlotsGetStateClass:
+        foo: str
+        bar: int
+
+        getstate_called: bool = field(default=False, compare=False)
+
+        def __getstate__(self):
+            object.__setattr__(self, 'getstate_called', True)
+            return [self.foo, self.bar]
+
+    @dataclass(frozen=True, slots=True)
+    class FrozenSlotsSetStateClass:
+        foo: str
+        bar: int
+
+        setstate_called: bool = field(default=False, compare=False)
+
+        def __setstate__(self, state):
+            object.__setattr__(self, 'setstate_called', True)
+            object.__setattr__(self, 'foo', state[0])
+            object.__setattr__(self, 'bar', state[1])
+
+    @dataclass(frozen=True, slots=True)
+    class FrozenSlotsAllStateClass:
+        foo: str
+        bar: int
+
+        getstate_called: bool = field(default=False, compare=False)
+        setstate_called: bool = field(default=False, compare=False)
+
+        def __getstate__(self):
+            object.__setattr__(self, 'getstate_called', True)
+            return [self.foo, self.bar]
+
+        def __setstate__(self, state):
+            object.__setattr__(self, 'setstate_called', True)
+            object.__setattr__(self, 'foo', state[0])
+            object.__setattr__(self, 'bar', state[1])
+
+    def test_frozen_slots_pickle_custom_state(self):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                obj = self.FrozenSlotsGetStateClass('a', 1)
+                dumped = pickle.dumps(obj, protocol=proto)
+
+                self.assertTrue(obj.getstate_called)
+                self.assertEqual(obj, pickle.loads(dumped))
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                obj = self.FrozenSlotsSetStateClass('a', 1)
+                obj2 = pickle.loads(pickle.dumps(obj, protocol=proto))
+
+                self.assertTrue(obj2.setstate_called)
+                self.assertEqual(obj, obj2)
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                obj = self.FrozenSlotsAllStateClass('a', 1)
+                dumped = pickle.dumps(obj, protocol=proto)
+
+                self.assertTrue(obj.getstate_called)
+
+                obj2 = pickle.loads(dumped)
+                self.assertTrue(obj2.setstate_called)
+                self.assertEqual(obj, obj2)
+
+    def test_slots_with_default_no_init(self):
+        # Originally reported in bpo-44649.
+        @dataclass(slots=True)
+        class A:
+            a: str
+            b: str = field(default='b', init=False)
+
+        obj = A("a")
+        self.assertEqual(obj.a, 'a')
+        self.assertEqual(obj.b, 'b')
+
+    def test_slots_with_default_factory_no_init(self):
+        # Originally reported in bpo-44649.
+        @dataclass(slots=True)
+        class A:
+            a: str
+            b: str = field(default_factory=lambda:'b', init=False)
+
+        obj = A("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:
+            # No weakref.
+            pass
+
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A()
+        with self.assertRaisesRegex(TypeError,
+                                    "cannot create weak reference"):
+            weakref.ref(a)
+        with self.assertRaises(AttributeError):
+            a.__weakref__
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_slots_weakref(self):
+        @dataclass(slots=True, weakref_slot=True)
+        class A:
+            a: int
+
+        self.assertIn("__weakref__", A.__slots__)
+        a = A(1)
+        a_ref = weakref.ref(a)
+
+        self.assertIs(a.__weakref__, a_ref)
+
+    def test_slots_weakref_base_str(self):
+        class Base:
+            __slots__ = '__weakref__'
+
+        @dataclass(slots=True)
+        class A(Base):
+            a: int
+
+        # __weakref__ is in the base class, not A.  But an A is still weakref-able.
+        self.assertIn("__weakref__", Base.__slots__)
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A(1)
+        weakref.ref(a)
+
+    def test_slots_weakref_base_tuple(self):
+        # Same as test_slots_weakref_base, but use a tuple instead of a string
+        # in the base class.
+        class Base:
+            __slots__ = ('__weakref__',)
+
+        @dataclass(slots=True)
+        class A(Base):
+            a: int
+
+        # __weakref__ is in the base class, not A.  But an A is still
+        # weakref-able.
+        self.assertIn("__weakref__", Base.__slots__)
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A(1)
+        weakref.ref(a)
+
+    def test_weakref_slot_without_slot(self):
+        with self.assertRaisesRegex(TypeError,
+                                    "weakref_slot is True but slots is False"):
+            @dataclass(weakref_slot=True)
+            class A:
+                a: int
+
+    def test_weakref_slot_make_dataclass(self):
+        A = make_dataclass('A', [('a', int),], slots=True, weakref_slot=True)
+        self.assertIn("__weakref__", A.__slots__)
+        a = A(1)
+        weakref.ref(a)
+
+        # And make sure if raises if slots=True is not given.
+        with self.assertRaisesRegex(TypeError,
+                                    "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:
+            field: int
+
+        # A *can* also specify weakref_slot=True if it wants to (gh-93521)
+        @dataclass(slots=True, weakref_slot=True)
+        class A(Base):
+            ...
+
+        # __weakref__ is in the base class, not A.  But an instance of A
+        # is still weakref-able.
+        self.assertIn("__weakref__", Base.__slots__)
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A(1)
+        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:
+            field: int
+
+        @dataclass(slots=True)
+        class A(Base):
+            ...
+
+        # __weakref__ is in the base class, not A.  Even though A doesn't
+        # specify weakref_slot, it should still be weakref-able.
+        self.assertIn("__weakref__", Base.__slots__)
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A(1)
+        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__',)
+
+        @dataclass(slots=True, weakref_slot=True)
+        class A(Base):
+            field: int
+
+        # __weakref__ is in the base class, not A.  But an instance of
+        # A is still weakref-able.
+        self.assertIn("__weakref__", Base.__slots__)
+        self.assertNotIn("__weakref__", A.__slots__)
+        a = A(1)
+        a_ref = weakref.ref(a)
+        self.assertIs(a.__weakref__, a_ref)
+
+    def test_dataclass_derived_weakref_slot(self):
+        class A:
+            pass
+
+        @dataclass(slots=True, weakref_slot=True)
+        class B(A):
+            pass
+
+        self.assertEqual(B.__slots__, ())
+        B()
+
+    def test_dataclass_derived_generic(self):
+        T = typing.TypeVar('T')
+
+        @dataclass(slots=True, weakref_slot=True)
+        class A(typing.Generic[T]):
+            pass
+        self.assertEqual(A.__slots__, ('__weakref__',))
+        self.assertTrue(A.__weakref__)
+        A()
+
+        @dataclass(slots=True, weakref_slot=True)
+        class B[T2]:
+            pass
+        self.assertEqual(B.__slots__, ('__weakref__',))
+        self.assertTrue(B.__weakref__)
+        B()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_dataclass_derived_generic_from_base(self):
+        T = typing.TypeVar('T')
+
+        class RawBase: ...
+
+        @dataclass(slots=True, weakref_slot=True)
+        class C1(typing.Generic[T], RawBase):
+            pass
+        self.assertEqual(C1.__slots__, ())
+        self.assertTrue(C1.__weakref__)
+        C1()
+        @dataclass(slots=True, weakref_slot=True)
+        class C2(RawBase, typing.Generic[T]):
+            pass
+        self.assertEqual(C2.__slots__, ())
+        self.assertTrue(C2.__weakref__)
+        C2()
+
+        @dataclass(slots=True, weakref_slot=True)
+        class D[T2](RawBase):
+            pass
+        self.assertEqual(D.__slots__, ())
+        self.assertTrue(D.__weakref__)
+        D()
+
+    def test_dataclass_derived_generic_from_slotted_base(self):
+        T = typing.TypeVar('T')
+
+        class WithSlots:
+            __slots__ = ('a', 'b')
+
+        @dataclass(slots=True, weakref_slot=True)
+        class E1(WithSlots, Generic[T]):
+            pass
+        self.assertEqual(E1.__slots__, ('__weakref__',))
+        self.assertTrue(E1.__weakref__)
+        E1()
+        @dataclass(slots=True, weakref_slot=True)
+        class E2(Generic[T], WithSlots):
+            pass
+        self.assertEqual(E2.__slots__, ('__weakref__',))
+        self.assertTrue(E2.__weakref__)
+        E2()
+
+        @dataclass(slots=True, weakref_slot=True)
+        class F[T2](WithSlots):
+            pass
+        self.assertEqual(F.__slots__, ('__weakref__',))
+        self.assertTrue(F.__weakref__)
+        F()
+
+    def test_dataclass_derived_generic_from_slotted_base_with_weakref(self):
+        T = typing.TypeVar('T')
+
+        class WithWeakrefSlot:
+            __slots__ = ('__weakref__',)
+
+        @dataclass(slots=True, weakref_slot=True)
+        class G1(WithWeakrefSlot, Generic[T]):
+            pass
+        self.assertEqual(G1.__slots__, ())
+        self.assertTrue(G1.__weakref__)
+        G1()
+        @dataclass(slots=True, weakref_slot=True)
+        class G2(Generic[T], WithWeakrefSlot):
+            pass
+        self.assertEqual(G2.__slots__, ())
+        self.assertTrue(G2.__weakref__)
+        G2()
+
+        @dataclass(slots=True, weakref_slot=True)
+        class H[T2](WithWeakrefSlot):
+            pass
+        self.assertEqual(H.__slots__, ())
+        self.assertTrue(H.__weakref__)
+        H()
+
+    def test_dataclass_slot_dict(self):
+        class WithDictSlot:
+            __slots__ = ('__dict__',)
+
+        @dataclass(slots=True)
+        class A(WithDictSlot): ...
+
+        self.assertEqual(A.__slots__, ())
+        self.assertEqual(A().__dict__, {})
+        A()
+
+    @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')
+
+        @dataclass(slots=True)
+        class HasDictOffset(_testcapi.HeapCTypeWithDict):
+            __dict__: dict = {}
+        self.assertNotEqual(_testcapi.HeapCTypeWithDict.__dictoffset__, 0)
+        self.assertEqual(HasDictOffset.__slots__, ())
+
+        @dataclass(slots=True)
+        class DoesNotHaveDictOffset(_testcapi.HeapCTypeWithWeakref):
+            __dict__: dict = {}
+        self.assertEqual(_testcapi.HeapCTypeWithWeakref.__dictoffset__, 0)
+        self.assertEqual(DoesNotHaveDictOffset.__slots__, ('__dict__',))
+
+    @support.cpython_only
+    def test_slots_with_wrong_init_subclass(self):
+        # TODO: This test is for a kinda-buggy behavior.
+        # Ideally, it should be fixed and `__init_subclass__`
+        # should be fully supported in the future versions.
+        # See https://github.com/python/cpython/issues/91126
+        class WrongSuper:
+            def __init_subclass__(cls, arg):
+                pass
+
+        with self.assertRaisesRegex(
+            TypeError,
+            "missing 1 required positional argument: 'arg'",
+        ):
+            @dataclass(slots=True)
+            class WithWrongSuper(WrongSuper, arg=1):
+                pass
+
+        class CorrectSuper:
+            args = []
+            def __init_subclass__(cls, arg="default"):
+                cls.args.append(arg)
+
+        @dataclass(slots=True)
+        class WithCorrectSuper(CorrectSuper):
+            pass
+
+        # __init_subclass__ is called twice: once for `WithCorrectSuper`
+        # and once for `WithCorrectSuper__slots__` new class
+        # that we create internally.
+        self.assertEqual(CorrectSuper.args, ["default", "default"])
+
+
+class TestDescriptors(unittest.TestCase):
+    def test_set_name(self):
+        # See bpo-33141.
+
+        # Create a descriptor.
+        class D:
+            def __set_name__(self, owner, name):
+                self.name = name + 'x'
+            def __get__(self, instance, owner):
+                if instance is not None:
+                    return 1
+                return self
+
+        # This is the case of just normal descriptor behavior, no
+        #  dataclass code is involved in initializing the descriptor.
+        @dataclass
+        class C:
+            c: int=D()
+        self.assertEqual(C.c.name, 'cx')
+
+        # Now test with a default value and init=False, which is the
+        #  only time this is really meaningful.  If not using
+        #  init=False, then the descriptor will be overwritten, anyway.
+        @dataclass
+        class C:
+            c: int=field(default=D(), init=False)
+        self.assertEqual(C.c.name, 'cx')
+        self.assertEqual(C().c, 1)
+
+    def test_non_descriptor(self):
+        # PEP 487 says __set_name__ should work on non-descriptors.
+        # Create a descriptor.
+
+        class D:
+            def __set_name__(self, owner, name):
+                self.name = name + 'x'
+
+        @dataclass
+        class C:
+            c: int=field(default=D(), init=False)
+        self.assertEqual(C.c.name, 'cx')
+
+    def test_lookup_on_instance(self):
+        # See bpo-33175.
+        class D:
+            pass
+
+        d = D()
+        # Create an attribute on the instance, not type.
+        d.__set_name__ = Mock()
+
+        # Make sure d.__set_name__ is not called.
+        @dataclass
+        class C:
+            i: int=field(default=d, init=False)
+
+        self.assertEqual(d.__set_name__.call_count, 0)
+
+    def test_lookup_on_class(self):
+        # See bpo-33175.
+        class D:
+            pass
+        D.__set_name__ = Mock()
+
+        # Make sure D.__set_name__ is called.
+        @dataclass
+        class C:
+            i: int=field(default=D(), init=False)
+
+        self.assertEqual(D.__set_name__.call_count, 1)
+
+    def test_init_calls_set(self):
+        class D:
+            pass
+
+        D.__set__ = Mock()
+
+        @dataclass
+        class C:
+            i: D = D()
+
+        # Make sure D.__set__ is called.
+        D.__set__.reset_mock()
+        c = C(5)
+        self.assertEqual(D.__set__.call_count, 1)
+
+    def test_getting_field_calls_get(self):
+        class D:
+            pass
+
+        D.__set__ = Mock()
+        D.__get__ = Mock()
+
+        @dataclass
+        class C:
+            i: D = D()
+
+        c = C(5)
+
+        # Make sure D.__get__ is called.
+        D.__get__.reset_mock()
+        value = c.i
+        self.assertEqual(D.__get__.call_count, 1)
+
+    def test_setting_field_calls_set(self):
+        class D:
+            pass
+
+        D.__set__ = Mock()
+
+        @dataclass
+        class C:
+            i: D = D()
+
+        c = C(5)
+
+        # Make sure D.__set__ is called.
+        D.__set__.reset_mock()
+        c.i = 10
+        self.assertEqual(D.__set__.call_count, 1)
+
+    def test_setting_uninitialized_descriptor_field(self):
+        class D:
+            pass
+
+        D.__set__ = Mock()
+
+        @dataclass
+        class C:
+            i: D
+
+        # D.__set__ is not called because there's no D instance to call it on
+        D.__set__.reset_mock()
+        c = C(5)
+        self.assertEqual(D.__set__.call_count, 0)
+
+        # D.__set__ still isn't called after setting i to an instance of D
+        # because descriptors don't behave like that when stored as instance vars
+        c.i = D()
+        c.i = 5
+        self.assertEqual(D.__set__.call_count, 0)
+
+    def test_default_value(self):
+        class D:
+            def __get__(self, instance: Any, owner: object) -> int:
+                if instance is None:
+                    return 100
+
+                return instance._x
+
+            def __set__(self, instance: Any, value: int) -> None:
+                instance._x = value
+
+        @dataclass
+        class C:
+            i: D = D()
+
+        c = C()
+        self.assertEqual(c.i, 100)
+
+        c = C(5)
+        self.assertEqual(c.i, 5)
+
+    def test_no_default_value(self):
+        class D:
+            def __get__(self, instance: Any, owner: object) -> int:
+                if instance is None:
+                    raise AttributeError()
+
+                return instance._x
+
+            def __set__(self, instance: Any, value: int) -> None:
+                instance._x = value
+
+        @dataclass
+        class C:
+            i: D = D()
+
+        with self.assertRaisesRegex(TypeError, 'missing 1 required positional argument'):
+            c = C()
+
+class TestStringAnnotations(unittest.TestCase):
+    def test_classvar(self):
+        # Some expressions recognized as ClassVar really aren't.  But
+        #  if you're using string annotations, it's not an exact
+        #  science.
+        # These tests assume that both "import typing" and "from
+        # typing import *" have been run in this file.
+        for typestr in ('ClassVar[int]',
+                        'ClassVar [int]',
+                        ' ClassVar [int]',
+                        'ClassVar',
+                        ' ClassVar ',
+                        'typing.ClassVar[int]',
+                        'typing.ClassVar[str]',
+                        ' typing.ClassVar[str]',
+                        'typing .ClassVar[str]',
+                        'typing. ClassVar[str]',
+                        'typing.ClassVar [str]',
+                        'typing.ClassVar [ str]',
+
+                        # Not syntactically valid, but these will
+                        #  be treated as ClassVars.
+                        'typing.ClassVar.[int]',
+                        'typing.ClassVar+',
+                        ):
+            with self.subTest(typestr=typestr):
+                @dataclass
+                class C:
+                    x: typestr
+
+                # x is a ClassVar, so C() takes no args.
+                C()
+
+                # And it won't appear in the class's dict because it doesn't
+                # have a default.
+                self.assertNotIn('x', C.__dict__)
+
+    def test_isnt_classvar(self):
+        for typestr in ('CV',
+                        't.ClassVar',
+                        't.ClassVar[int]',
+                        'typing..ClassVar[int]',
+                        'Classvar',
+                        'Classvar[int]',
+                        'typing.ClassVarx[int]',
+                        'typong.ClassVar[int]',
+                        'dataclasses.ClassVar[int]',
+                        'typingxClassVar[str]',
+                        ):
+            with self.subTest(typestr=typestr):
+                @dataclass
+                class C:
+                    x: typestr
+
+                # x is not a ClassVar, so C() takes one arg.
+                self.assertEqual(C(10).x, 10)
+
+    def test_initvar(self):
+        # These tests assume that both "import dataclasses" and "from
+        #  dataclasses import *" have been run in this file.
+        for typestr in ('InitVar[int]',
+                        'InitVar [int]'
+                        ' InitVar [int]',
+                        'InitVar',
+                        ' InitVar ',
+                        'dataclasses.InitVar[int]',
+                        'dataclasses.InitVar[str]',
+                        ' dataclasses.InitVar[str]',
+                        'dataclasses .InitVar[str]',
+                        'dataclasses. InitVar[str]',
+                        'dataclasses.InitVar [str]',
+                        'dataclasses.InitVar [ str]',
+
+                        # Not syntactically valid, but these will
+                        #  be treated as InitVars.
+                        'dataclasses.InitVar.[int]',
+                        'dataclasses.InitVar+',
+                        ):
+            with self.subTest(typestr=typestr):
+                @dataclass
+                class C:
+                    x: typestr
+
+                # x is an InitVar, so doesn't create a member.
+                with self.assertRaisesRegex(AttributeError,
+                                            "object has no attribute 'x'"):
+                    C(1).x
+
+    def test_isnt_initvar(self):
+        for typestr in ('IV',
+                        'dc.InitVar',
+                        'xdataclasses.xInitVar',
+                        'typing.xInitVar[int]',
+                        ):
+            with self.subTest(typestr=typestr):
+                @dataclass
+                class C:
+                    x: typestr
+
+                # x is not an InitVar, so there will be a member x.
+                self.assertEqual(C(10).x, 10)
+
+    def test_classvar_module_level_import(self):
+        from test.test_dataclasses import dataclass_module_1
+        from test.test_dataclasses import dataclass_module_1_str
+        from test.test_dataclasses import dataclass_module_2
+        from test.test_dataclasses import dataclass_module_2_str
+
+        for m in (dataclass_module_1, dataclass_module_1_str,
+                  dataclass_module_2, dataclass_module_2_str,
+                  ):
+            with self.subTest(m=m):
+                # There's a difference in how the ClassVars are
+                # interpreted when using string annotations or
+                # not. See the imported modules for details.
+                if m.USING_STRINGS:
+                    c = m.CV(10)
+                else:
+                    c = m.CV()
+                self.assertEqual(c.cv0, 20)
+
+
+                # There's a difference in how the InitVars are
+                # interpreted when using string annotations or
+                # not. See the imported modules for details.
+                c = m.IV(0, 1, 2, 3, 4)
+
+                for field_name in ('iv0', 'iv1', 'iv2', 'iv3'):
+                    with self.subTest(field_name=field_name):
+                        with self.assertRaisesRegex(AttributeError, f"object has no attribute '{field_name}'"):
+                            # Since field_name is an InitVar, it's
+                            # not an instance field.
+                            getattr(c, field_name)
+
+                if m.USING_STRINGS:
+                    # iv4 is interpreted as a normal field.
+                    self.assertIn('not_iv4', c.__dict__)
+                    self.assertEqual(c.not_iv4, 4)
+                else:
+                    # iv4 is interpreted as an InitVar, so it
+                    # won't exist on the instance.
+                    self.assertNotIn('not_iv4', c.__dict__)
+
+    def test_text_annotations(self):
+        from test.test_dataclasses import dataclass_textanno
+
+        self.assertEqual(
+            get_type_hints(dataclass_textanno.Bar),
+            {'foo': dataclass_textanno.Foo})
+        self.assertEqual(
+            get_type_hints(dataclass_textanno.Bar.__init__),
+            {'foo': dataclass_textanno.Foo,
+             'return': type(None)})
+
+
+ByMakeDataClass = make_dataclass('ByMakeDataClass', [('x', int)])
+ManualModuleMakeDataClass = make_dataclass('ManualModuleMakeDataClass',
+                                           [('x', int)],
+                                           module=__name__)
+WrongNameMakeDataclass = make_dataclass('Wrong', [('x', int)])
+WrongModuleMakeDataclass = make_dataclass('WrongModuleMakeDataclass',
+                                          [('x', int)],
+                                          module='custom')
+
+class TestMakeDataclass(unittest.TestCase):
+    def test_simple(self):
+        C = make_dataclass('C',
+                           [('x', int),
+                            ('y', int, field(default=5))],
+                           namespace={'add_one': lambda self: self.x + 1})
+        c = C(10)
+        self.assertEqual((c.x, c.y), (10, 5))
+        self.assertEqual(c.add_one(), 11)
+
+
+    def test_no_mutate_namespace(self):
+        # Make sure a provided namespace isn't mutated.
+        ns = {}
+        C = make_dataclass('C',
+                           [('x', int),
+                            ('y', int, field(default=5))],
+                           namespace=ns)
+        self.assertEqual(ns, {})
+
+    def test_base(self):
+        class Base1:
+            pass
+        class Base2:
+            pass
+        C = make_dataclass('C',
+                           [('x', int)],
+                           bases=(Base1, Base2))
+        c = C(2)
+        self.assertIsInstance(c, C)
+        self.assertIsInstance(c, Base1)
+        self.assertIsInstance(c, Base2)
+
+    def test_base_dataclass(self):
+        @dataclass
+        class Base1:
+            x: int
+        class Base2:
+            pass
+        C = make_dataclass('C',
+                           [('y', int)],
+                           bases=(Base1, Base2))
+        with self.assertRaisesRegex(TypeError, 'required positional'):
+            c = C(2)
+        c = C(1, 2)
+        self.assertIsInstance(c, C)
+        self.assertIsInstance(c, Base1)
+        self.assertIsInstance(c, Base2)
+
+        self.assertEqual((c.x, c.y), (1, 2))
+
+    def test_init_var(self):
+        def post_init(self, y):
+            self.x *= y
+
+        C = make_dataclass('C',
+                           [('x', int),
+                            ('y', InitVar[int]),
+                            ],
+                           namespace={'__post_init__': post_init},
+                           )
+        c = C(2, 3)
+        self.assertEqual(vars(c), {'x': 6})
+        self.assertEqual(len(fields(c)), 1)
+
+    def test_class_var(self):
+        C = make_dataclass('C',
+                           [('x', int),
+                            ('y', ClassVar[int], 10),
+                            ('z', ClassVar[int], field(default=20)),
+                            ])
+        c = C(1)
+        self.assertEqual(vars(c), {'x': 1})
+        self.assertEqual(len(fields(c)), 1)
+        self.assertEqual(C.y, 10)
+        self.assertEqual(C.z, 20)
+
+    def test_other_params(self):
+        C = make_dataclass('C',
+                           [('x', int),
+                            ('y', ClassVar[int], 10),
+                            ('z', ClassVar[int], field(default=20)),
+                            ],
+                           init=False)
+        # Make sure we have a repr, but no init.
+        self.assertNotIn('__init__', vars(C))
+        self.assertIn('__repr__', vars(C))
+
+        # Make sure random other params don't work.
+        with self.assertRaisesRegex(TypeError, 'unexpected keyword argument'):
+            C = make_dataclass('C',
+                               [],
+                               xxinit=False)
+
+    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'})
+
+        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',
+                                             'y': int,
+                                             'z': 'typing.Any'})
+
+    def test_module_attr(self):
+        self.assertEqual(ByMakeDataClass.__module__, __name__)
+        self.assertEqual(ByMakeDataClass(1).__module__, __name__)
+        self.assertEqual(WrongModuleMakeDataclass.__module__, "custom")
+        Nested = make_dataclass('Nested', [])
+        self.assertEqual(Nested.__module__, __name__)
+        self.assertEqual(Nested().__module__, __name__)
+
+    def test_pickle_support(self):
+        for klass in [ByMakeDataClass, ManualModuleMakeDataClass]:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto):
+                    self.assertEqual(
+                        pickle.loads(pickle.dumps(klass, proto)),
+                        klass,
+                    )
+                    self.assertEqual(
+                        pickle.loads(pickle.dumps(klass(1), proto)),
+                        klass(1),
+                    )
+
+    def test_cannot_be_pickled(self):
+        for klass in [WrongNameMakeDataclass, WrongModuleMakeDataclass]:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(proto=proto):
+                    with self.assertRaises(pickle.PickleError):
+                        pickle.dumps(klass, proto)
+                    with self.assertRaises(pickle.PickleError):
+                        pickle.dumps(klass(1), proto)
+
+    def test_invalid_type_specification(self):
+        for bad_field in [(),
+                          (1, 2, 3, 4),
+                          ]:
+            with self.subTest(bad_field=bad_field):
+                with self.assertRaisesRegex(TypeError, r'Invalid field: '):
+                    make_dataclass('C', ['a', bad_field])
+
+        # And test for things with no len().
+        for bad_field in [float,
+                          lambda x:x,
+                          ]:
+            with self.subTest(bad_field=bad_field):
+                with self.assertRaisesRegex(TypeError, r'has no len\(\)'):
+                    make_dataclass('C', ['a', bad_field])
+
+    def test_duplicate_field_names(self):
+        for field in ['a', 'ab']:
+            with self.subTest(field=field):
+                with self.assertRaisesRegex(TypeError, 'Field name duplicated'):
+                    make_dataclass('C', [field, 'a', field])
+
+    def test_keyword_field_names(self):
+        for field in ['for', 'async', 'await', 'as']:
+            with self.subTest(field=field):
+                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
+                    make_dataclass('C', ['a', field])
+                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
+                    make_dataclass('C', [field])
+                with self.assertRaisesRegex(TypeError, 'must not be keywords'):
+                    make_dataclass('C', [field, 'a'])
+
+    def test_non_identifier_field_names(self):
+        for field in ['()', 'x,y', '*', '2@3', '', 'little johnny tables']:
+            with self.subTest(field=field):
+                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
+                    make_dataclass('C', ['a', field])
+                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
+                    make_dataclass('C', [field])
+                with self.assertRaisesRegex(TypeError, 'must be valid identifiers'):
+                    make_dataclass('C', [field, 'a'])
+
+    def test_underscore_field_names(self):
+        # Unlike namedtuple, it's okay if dataclass field names have
+        # an underscore.
+        make_dataclass('C', ['_', '_a', 'a_a', 'a_'])
+
+    def test_funny_class_names_names(self):
+        # No reason to prevent weird class names, since
+        # types.new_class allows them.
+        for classname in ['()', 'x,y', '*', '2@3', '']:
+            with self.subTest(classname=classname):
+                C = make_dataclass(classname, ['a', 'b'])
+                self.assertEqual(C.__name__, classname)
+
+class TestReplace(unittest.TestCase):
+    def test(self):
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            y: int
+
+        c = C(1, 2)
+        c1 = replace(c, x=3)
+        self.assertEqual(c1.x, 3)
+        self.assertEqual(c1.y, 2)
+
+    def test_frozen(self):
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            y: int
+            z: int = field(init=False, default=10)
+            t: int = field(init=False, default=100)
+
+        c = C(1, 2)
+        c1 = replace(c, x=3)
+        self.assertEqual((c.x, c.y, c.z, c.t), (1, 2, 10, 100))
+        self.assertEqual((c1.x, c1.y, c1.z, c1.t), (3, 2, 10, 100))
+
+
+        with self.assertRaisesRegex(TypeError, 'init=False'):
+            replace(c, x=3, z=20, t=50)
+        with self.assertRaisesRegex(TypeError, 'init=False'):
+            replace(c, z=20)
+            replace(c, x=3, z=20, t=50)
+
+        # Make sure the result is still frozen.
+        with self.assertRaisesRegex(FrozenInstanceError, "cannot assign to field 'x'"):
+            c1.x = 3
+
+        # Make sure we can't replace an attribute that doesn't exist,
+        #  if we're also replacing one that does exist.  Test this
+        #  here, because setting attributes on frozen instances is
+        #  handled slightly differently from non-frozen ones.
+        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an unexpected "
+                                             "keyword argument 'a'"):
+            c1 = replace(c, x=20, a=5)
+
+    def test_invalid_field_name(self):
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            y: int
+
+        c = C(1, 2)
+        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an unexpected "
+                                    "keyword argument 'z'"):
+            c1 = replace(c, z=3)
+
+    def test_invalid_object(self):
+        @dataclass(frozen=True)
+        class C:
+            x: int
+            y: int
+
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            replace(C, x=3)
+
+        with self.assertRaisesRegex(TypeError, 'dataclass instance'):
+            replace(0, x=3)
+
+    def test_no_init(self):
+        @dataclass
+        class C:
+            x: int
+            y: int = field(init=False, default=10)
+
+        c = C(1)
+        c.y = 20
+
+        # Make sure y gets the default value.
+        c1 = replace(c, x=5)
+        self.assertEqual((c1.x, c1.y), (5, 10))
+
+        # Trying to replace y is an error.
+        with self.assertRaisesRegex(TypeError, 'init=False'):
+            replace(c, x=2, y=30)
+
+        with self.assertRaisesRegex(TypeError, 'init=False'):
+            replace(c, y=30)
+
+    def test_classvar(self):
+        @dataclass
+        class C:
+            x: int
+            y: ClassVar[int] = 1000
+
+        c = C(1)
+        d = C(2)
+
+        self.assertIs(c.y, d.y)
+        self.assertEqual(c.y, 1000)
+
+        # Trying to replace y is an error: can't replace ClassVars.
+        with self.assertRaisesRegex(TypeError, r"__init__\(\) got an "
+                                    "unexpected keyword argument 'y'"):
+            replace(c, y=30)
+
+        replace(c, x=5)
+
+    def test_initvar_is_specified(self):
+        @dataclass
+        class C:
+            x: int
+            y: InitVar[int]
+
+            def __post_init__(self, y):
+                self.x *= y
+
+        c = C(1, 10)
+        self.assertEqual(c.x, 10)
+        with self.assertRaisesRegex(TypeError, r"InitVar 'y' must be "
+                                    r"specified with replace\(\)"):
+            replace(c, x=3)
+        c = replace(c, x=3, y=5)
+        self.assertEqual(c.x, 15)
+
+    def test_initvar_with_default_value(self):
+        @dataclass
+        class C:
+            x: int
+            y: InitVar[int] = None
+            z: InitVar[int] = 42
+
+            def __post_init__(self, y, z):
+                if y is not None:
+                    self.x += y
+                if z is not None:
+                    self.x += z
+
+        c = C(x=1, y=10, z=1)
+        self.assertEqual(replace(c), C(x=12))
+        self.assertEqual(replace(c, y=4), C(x=12, y=4, z=42))
+        self.assertEqual(replace(c, y=4, z=1), C(x=12, y=4, z=1))
+
+    def test_recursive_repr(self):
+        @dataclass
+        class C:
+            f: "C"
+
+        c = C(None)
+        c.f = c
+        self.assertEqual(repr(c), "TestReplace.test_recursive_repr.<locals>.C(f=...)")
+
+    def test_recursive_repr_two_attrs(self):
+        @dataclass
+        class C:
+            f: "C"
+            g: "C"
+
+        c = C(None, None)
+        c.f = c
+        c.g = c
+        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_two_attrs"
+                                  ".<locals>.C(f=..., g=...)")
+
+    def test_recursive_repr_indirection(self):
+        @dataclass
+        class C:
+            f: "D"
+
+        @dataclass
+        class D:
+            f: "C"
+
+        c = C(None)
+        d = D(None)
+        c.f = d
+        d.f = c
+        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_indirection"
+                                  ".<locals>.C(f=TestReplace.test_recursive_repr_indirection"
+                                  ".<locals>.D(f=...))")
+
+    def test_recursive_repr_indirection_two(self):
+        @dataclass
+        class C:
+            f: "D"
+
+        @dataclass
+        class D:
+            f: "E"
+
+        @dataclass
+        class E:
+            f: "C"
+
+        c = C(None)
+        d = D(None)
+        e = E(None)
+        c.f = d
+        d.f = e
+        e.f = c
+        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_indirection_two"
+                                  ".<locals>.C(f=TestReplace.test_recursive_repr_indirection_two"
+                                  ".<locals>.D(f=TestReplace.test_recursive_repr_indirection_two"
+                                  ".<locals>.E(f=...)))")
+
+    def test_recursive_repr_misc_attrs(self):
+        @dataclass
+        class C:
+            f: "C"
+            g: int
+
+        c = C(None, 1)
+        c.f = c
+        self.assertEqual(repr(c), "TestReplace.test_recursive_repr_misc_attrs"
+                                  ".<locals>.C(f=..., g=1)")
+
+    ## def test_initvar(self):
+    ##     @dataclass
+    ##     class C:
+    ##         x: int
+    ##         y: InitVar[int]
+
+    ##     c = C(1, 10)
+    ##     d = C(2, 20)
+
+    ##     # In our case, replacing an InitVar is a no-op
+    ##     self.assertEqual(c, replace(c, y=5))
+
+    ##     replace(c, x=5)
+
+class TestAbstract(unittest.TestCase):
+    def test_abc_implementation(self):
+        class Ordered(abc.ABC):
+            @abc.abstractmethod
+            def __lt__(self, other):
+                pass
+
+            @abc.abstractmethod
+            def __le__(self, other):
+                pass
+
+        @dataclass(order=True)
+        class Date(Ordered):
+            year: int
+            month: 'Month'
+            day: 'int'
+
+        self.assertFalse(inspect.isabstract(Date))
+        self.assertGreater(Date(2020,12,25), Date(2020,8,31))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_maintain_abc(self):
+        class A(abc.ABC):
+            @abc.abstractmethod
+            def foo(self):
+                pass
+
+        @dataclass
+        class Date(A):
+            year: int
+            month: 'Month'
+            day: 'int'
+
+        self.assertTrue(inspect.isabstract(Date))
+        msg = "class Date without an implementation for abstract method 'foo'"
+        self.assertRaisesRegex(TypeError, msg, Date)
+
+
+class TestMatchArgs(unittest.TestCase):
+    def test_match_args(self):
+        @dataclass
+        class C:
+            a: int
+        self.assertEqual(C(42).__match_args__, ('a',))
+
+    def test_explicit_match_args(self):
+        ma = ()
+        @dataclass
+        class C:
+            a: int
+            __match_args__ = ma
+        self.assertIs(C(42).__match_args__, ma)
+
+    def test_bpo_43764(self):
+        @dataclass(repr=False, eq=False, init=False)
+        class X:
+            a: int
+            b: int
+            c: int
+        self.assertEqual(X.__match_args__, ("a", "b", "c"))
+
+    def test_match_args_argument(self):
+        @dataclass(match_args=False)
+        class X:
+            a: int
+        self.assertNotIn('__match_args__', X.__dict__)
+
+        @dataclass(match_args=False)
+        class Y:
+            a: int
+            __match_args__ = ('b',)
+        self.assertEqual(Y.__match_args__, ('b',))
+
+        @dataclass(match_args=False)
+        class Z(Y):
+            z: int
+        self.assertEqual(Z.__match_args__, ('b',))
+
+        # Ensure parent dataclass __match_args__ is seen, if child class
+        # specifies match_args=False.
+        @dataclass
+        class A:
+            a: int
+            z: int
+        @dataclass(match_args=False)
+        class B(A):
+            b: int
+        self.assertEqual(B.__match_args__, ('a', 'z'))
+
+    def test_make_dataclasses(self):
+        C = make_dataclass('C', [('x', int), ('y', int)])
+        self.assertEqual(C.__match_args__, ('x', 'y'))
+
+        C = make_dataclass('C', [('x', int), ('y', int)], match_args=True)
+        self.assertEqual(C.__match_args__, ('x', 'y'))
+
+        C = make_dataclass('C', [('x', int), ('y', int)], match_args=False)
+        self.assertNotIn('__match__args__', C.__dict__)
+
+        C = make_dataclass('C', [('x', int), ('y', int)], namespace={'__match_args__': ('z',)})
+        self.assertEqual(C.__match_args__, ('z',))
+
+
+class TestKeywordArgs(unittest.TestCase):
+    def test_no_classvar_kwarg(self):
+        msg = 'field a is a ClassVar but specifies kw_only'
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: ClassVar[int] = field(kw_only=True)
+
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: ClassVar[int] = field(kw_only=False)
+
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass(kw_only=True)
+            class A:
+                a: ClassVar[int] = field(kw_only=False)
+
+    def test_field_marked_as_kwonly(self):
+        #######################
+        # Using dataclass(kw_only=True)
+        @dataclass(kw_only=True)
+        class A:
+            a: int
+        self.assertTrue(fields(A)[0].kw_only)
+
+        @dataclass(kw_only=True)
+        class A:
+            a: int = field(kw_only=True)
+        self.assertTrue(fields(A)[0].kw_only)
+
+        @dataclass(kw_only=True)
+        class A:
+            a: int = field(kw_only=False)
+        self.assertFalse(fields(A)[0].kw_only)
+
+        #######################
+        # Using dataclass(kw_only=False)
+        @dataclass(kw_only=False)
+        class A:
+            a: int
+        self.assertFalse(fields(A)[0].kw_only)
+
+        @dataclass(kw_only=False)
+        class A:
+            a: int = field(kw_only=True)
+        self.assertTrue(fields(A)[0].kw_only)
+
+        @dataclass(kw_only=False)
+        class A:
+            a: int = field(kw_only=False)
+        self.assertFalse(fields(A)[0].kw_only)
+
+        #######################
+        # Not specifying dataclass(kw_only)
+        @dataclass
+        class A:
+            a: int
+        self.assertFalse(fields(A)[0].kw_only)
+
+        @dataclass
+        class A:
+            a: int = field(kw_only=True)
+        self.assertTrue(fields(A)[0].kw_only)
+
+        @dataclass
+        class A:
+            a: int = field(kw_only=False)
+        self.assertFalse(fields(A)[0].kw_only)
+
+    def test_match_args(self):
+        # kw fields don't show up in __match_args__.
+        @dataclass(kw_only=True)
+        class C:
+            a: int
+        self.assertEqual(C(a=42).__match_args__, ())
+
+        @dataclass
+        class C:
+            a: int
+            b: int = field(kw_only=True)
+        self.assertEqual(C(42, b=10).__match_args__, ('a',))
+
+    def test_KW_ONLY(self):
+        @dataclass
+        class A:
+            a: int
+            _: KW_ONLY
+            b: int
+            c: int
+        A(3, c=5, b=4)
+        msg = "takes 2 positional arguments but 4 were given"
+        with self.assertRaisesRegex(TypeError, msg):
+            A(3, 4, 5)
+
+
+        @dataclass(kw_only=True)
+        class B:
+            a: int
+            _: KW_ONLY
+            b: int
+            c: int
+        B(a=3, b=4, c=5)
+        msg = "takes 1 positional argument but 4 were given"
+        with self.assertRaisesRegex(TypeError, msg):
+            B(3, 4, 5)
+
+        # Explicitly make a field that follows KW_ONLY be non-keyword-only.
+        @dataclass
+        class C:
+            a: int
+            _: KW_ONLY
+            b: int
+            c: int = field(kw_only=False)
+        c = C(1, 2, b=3)
+        self.assertEqual(c.a, 1)
+        self.assertEqual(c.b, 3)
+        self.assertEqual(c.c, 2)
+        c = C(1, b=3, c=2)
+        self.assertEqual(c.a, 1)
+        self.assertEqual(c.b, 3)
+        self.assertEqual(c.c, 2)
+        c = C(1, b=3, c=2)
+        self.assertEqual(c.a, 1)
+        self.assertEqual(c.b, 3)
+        self.assertEqual(c.c, 2)
+        c = C(c=2, b=3, a=1)
+        self.assertEqual(c.a, 1)
+        self.assertEqual(c.b, 3)
+        self.assertEqual(c.c, 2)
+
+    def test_KW_ONLY_as_string(self):
+        @dataclass
+        class A:
+            a: int
+            _: 'dataclasses.KW_ONLY'
+            b: int
+            c: int
+        A(3, c=5, b=4)
+        msg = "takes 2 positional arguments but 4 were given"
+        with self.assertRaisesRegex(TypeError, msg):
+            A(3, 4, 5)
+
+    def test_KW_ONLY_twice(self):
+        msg = "'Y' is KW_ONLY, but KW_ONLY has already been specified"
+
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: int
+                X: KW_ONLY
+                Y: KW_ONLY
+                b: int
+                c: int
+
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: int
+                X: KW_ONLY
+                b: int
+                Y: KW_ONLY
+                c: int
+
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: int
+                X: KW_ONLY
+                b: int
+                c: int
+                Y: KW_ONLY
+
+        # But this usage is okay, since it's not using KW_ONLY.
+        @dataclass
+        class NoDuplicateKwOnlyAnnotation:
+            a: int
+            _: KW_ONLY
+            b: int
+            c: int = field(kw_only=True)
+
+        # And if inheriting, it's okay.
+        @dataclass
+        class BaseUsesKwOnly:
+            a: int
+            _: KW_ONLY
+            b: int
+            c: int
+        @dataclass
+        class SubclassUsesKwOnly(BaseUsesKwOnly):
+            _: KW_ONLY
+            d: int
+
+        # Make sure the error is raised in a derived class.
+        with self.assertRaisesRegex(TypeError, msg):
+            @dataclass
+            class A:
+                a: int
+                _: KW_ONLY
+                b: int
+                c: int
+            @dataclass
+            class B(A):
+                X: KW_ONLY
+                d: int
+                Y: KW_ONLY
+
+
+    def test_post_init(self):
+        @dataclass
+        class A:
+            a: int
+            _: KW_ONLY
+            b: InitVar[int]
+            c: int
+            d: InitVar[int]
+            def __post_init__(self, b, d):
+                raise CustomError(f'{b=} {d=}')
+        with self.assertRaisesRegex(CustomError, 'b=3 d=4'):
+            A(1, c=2, b=3, d=4)
+
+        @dataclass
+        class B:
+            a: int
+            _: KW_ONLY
+            b: InitVar[int]
+            c: int
+            d: InitVar[int]
+            def __post_init__(self, b, d):
+                self.a = b
+                self.c = d
+        b = B(1, c=2, b=3, d=4)
+        self.assertEqual(asdict(b), {'a': 3, 'c': 4})
+
+    def test_defaults(self):
+        # For kwargs, make sure we can have defaults after non-defaults.
+        @dataclass
+        class A:
+            a: int = 0
+            _: KW_ONLY
+            b: int
+            c: int = 1
+            d: int
+
+        a = A(d=4, b=3)
+        self.assertEqual(a.a, 0)
+        self.assertEqual(a.b, 3)
+        self.assertEqual(a.c, 1)
+        self.assertEqual(a.d, 4)
+
+        # Make sure we still check for non-kwarg non-defaults not following
+        # defaults.
+        err_regex = "non-default argument 'z' follows default argument 'a'"
+        with self.assertRaisesRegex(TypeError, err_regex):
+            @dataclass
+            class A:
+                a: int = 0
+                z: int
+                _: KW_ONLY
+                b: int
+                c: int = 1
+                d: int
+
+    def test_make_dataclass(self):
+        A = make_dataclass("A", ['a'], kw_only=True)
+        self.assertTrue(fields(A)[0].kw_only)
+
+        B = make_dataclass("B",
+                           ['a', ('b', int, field(kw_only=False))],
+                           kw_only=True)
+        self.assertTrue(fields(B)[0].kw_only)
+        self.assertFalse(fields(B)[1].kw_only)
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/Lib/test/test_dataclasses/dataclass_module_1.py b/Lib/test/test_dataclasses/dataclass_module_1.py
new file mode 100644
index 0000000000..87a33f8191
--- /dev/null
+++ b/Lib/test/test_dataclasses/dataclass_module_1.py
@@ -0,0 +1,32 @@
+#from __future__ import annotations
+USING_STRINGS = False
+
+# dataclass_module_1.py and dataclass_module_1_str.py are identical
+# except only the latter uses string annotations.
+
+import dataclasses
+import typing
+
+T_CV2 = typing.ClassVar[int]
+T_CV3 = typing.ClassVar
+
+T_IV2 = dataclasses.InitVar[int]
+T_IV3 = dataclasses.InitVar
+
+@dataclasses.dataclass
+class CV:
+    T_CV4 = typing.ClassVar
+    cv0: typing.ClassVar[int] = 20
+    cv1: typing.ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclasses.dataclass
+class IV:
+    T_IV4 = dataclasses.InitVar
+    iv0: dataclasses.InitVar[int]
+    iv1: dataclasses.InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.
diff --git a/Lib/test/test_dataclasses/dataclass_module_1_str.py b/Lib/test/test_dataclasses/dataclass_module_1_str.py
new file mode 100644
index 0000000000..6de490b7ad
--- /dev/null
+++ b/Lib/test/test_dataclasses/dataclass_module_1_str.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+USING_STRINGS = True
+
+# dataclass_module_1.py and dataclass_module_1_str.py are identical
+# except only the latter uses string annotations.
+
+import dataclasses
+import typing
+
+T_CV2 = typing.ClassVar[int]
+T_CV3 = typing.ClassVar
+
+T_IV2 = dataclasses.InitVar[int]
+T_IV3 = dataclasses.InitVar
+
+@dataclasses.dataclass
+class CV:
+    T_CV4 = typing.ClassVar
+    cv0: typing.ClassVar[int] = 20
+    cv1: typing.ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclasses.dataclass
+class IV:
+    T_IV4 = dataclasses.InitVar
+    iv0: dataclasses.InitVar[int]
+    iv1: dataclasses.InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.
diff --git a/Lib/test/test_dataclasses/dataclass_module_2.py b/Lib/test/test_dataclasses/dataclass_module_2.py
new file mode 100644
index 0000000000..68fb733e29
--- /dev/null
+++ b/Lib/test/test_dataclasses/dataclass_module_2.py
@@ -0,0 +1,32 @@
+#from __future__ import annotations
+USING_STRINGS = False
+
+# dataclass_module_2.py and dataclass_module_2_str.py are identical
+# except only the latter uses string annotations.
+
+from dataclasses import dataclass, InitVar
+from typing import ClassVar
+
+T_CV2 = ClassVar[int]
+T_CV3 = ClassVar
+
+T_IV2 = InitVar[int]
+T_IV3 = InitVar
+
+@dataclass
+class CV:
+    T_CV4 = ClassVar
+    cv0: ClassVar[int] = 20
+    cv1: ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclass
+class IV:
+    T_IV4 = InitVar
+    iv0: InitVar[int]
+    iv1: InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.
diff --git a/Lib/test/test_dataclasses/dataclass_module_2_str.py b/Lib/test/test_dataclasses/dataclass_module_2_str.py
new file mode 100644
index 0000000000..b363d17c17
--- /dev/null
+++ b/Lib/test/test_dataclasses/dataclass_module_2_str.py
@@ -0,0 +1,32 @@
+from __future__ import annotations
+USING_STRINGS = True
+
+# dataclass_module_2.py and dataclass_module_2_str.py are identical
+# except only the latter uses string annotations.
+
+from dataclasses import dataclass, InitVar
+from typing import ClassVar
+
+T_CV2 = ClassVar[int]
+T_CV3 = ClassVar
+
+T_IV2 = InitVar[int]
+T_IV3 = InitVar
+
+@dataclass
+class CV:
+    T_CV4 = ClassVar
+    cv0: ClassVar[int] = 20
+    cv1: ClassVar = 30
+    cv2: T_CV2
+    cv3: T_CV3
+    not_cv4: T_CV4  # When using string annotations, this field is not recognized as a ClassVar.
+
+@dataclass
+class IV:
+    T_IV4 = InitVar
+    iv0: InitVar[int]
+    iv1: InitVar
+    iv2: T_IV2
+    iv3: T_IV3
+    not_iv4: T_IV4  # When using string annotations, this field is not recognized as an InitVar.
diff --git a/Lib/test/test_dataclasses/dataclass_textanno.py b/Lib/test/test_dataclasses/dataclass_textanno.py
new file mode 100644
index 0000000000..3eb6c943d4
--- /dev/null
+++ b/Lib/test/test_dataclasses/dataclass_textanno.py
@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import dataclasses
+
+
+class Foo:
+    pass
+
+
+@dataclasses.dataclass
+class Bar:
+    foo: Foo
diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm.py
index e615d284cd..6785aa273a 100644
--- a/Lib/test/test_dbm.py
+++ b/Lib/test/test_dbm.py
@@ -1,23 +1,28 @@
 """Test script for the dbm.open function based on testdumbdbm.py"""
 
 import unittest
-import glob
-import test.support
-from test.support import os_helper, import_helper
+import dbm
+import os
+from test.support import import_helper
+from test.support import os_helper
+
+
+try:
+    from dbm import sqlite3 as dbm_sqlite3
+except ImportError:
+    dbm_sqlite3 = None
 
-# Skip tests if dbm module doesn't exist.
-dbm = import_helper.import_module('dbm')
 
 try:
     from dbm import ndbm
 except ImportError:
     ndbm = None
 
-_fname = os_helper.TESTFN
+dirname = os_helper.TESTFN
+_fname = os.path.join(dirname, os_helper.TESTFN)
 
 #
-# Iterates over every database module supported by dbm currently available,
-# setting dbm to use each in turn, and yielding that module
+# Iterates over every database module supported by dbm currently available.
 #
 def dbm_iterator():
     for name in dbm._names:
@@ -31,11 +36,12 @@ def dbm_iterator():
 #
 # Clean up all scratch databases we might have created during testing
 #
-def delete_files():
-    # we don't know the precise name the underlying database uses
-    # so we use glob to locate all names
-    for f in glob.glob(glob.escape(_fname) + "*"):
-        os_helper.unlink(f)
+def cleaunup_test_dir():
+    os_helper.rmtree(dirname)
+
+def setup_test_dir():
+    cleaunup_test_dir()
+    os.mkdir(dirname)
 
 
 class AnyDBMTestCase:
@@ -129,85 +135,127 @@ def test_anydbm_access(self):
         assert(f[key] == b"Python:")
         f.close()
 
+    def test_open_with_bytes(self):
+        dbm.open(os.fsencode(_fname), "c").close()
+
+    def test_open_with_pathlib_path(self):
+        dbm.open(os_helper.FakePath(_fname), "c").close()
+
+    def test_open_with_pathlib_path_bytes(self):
+        dbm.open(os_helper.FakePath(os.fsencode(_fname)), "c").close()
+
     def read_helper(self, f):
         keys = self.keys_helper(f)
         for key in self._dict:
             self.assertEqual(self._dict[key], f[key.encode("ascii")])
 
-    def tearDown(self):
-        delete_files()
+    def test_keys(self):
+        with dbm.open(_fname, 'c') as d:
+            self.assertEqual(d.keys(), [])
+            a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
+            for k, v in a:
+                d[k] = v
+            self.assertEqual(sorted(d.keys()), sorted(k for (k, v) in a))
+            for k, v in a:
+                self.assertIn(k, d)
+                self.assertEqual(d[k], v)
+            self.assertNotIn(b'xxx', d)
+            self.assertRaises(KeyError, lambda: d[b'xxx'])
+
+    def test_clear(self):
+        with dbm.open(_fname, 'c') as d:
+            self.assertEqual(d.keys(), [])
+            a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
+            for k, v in a:
+                d[k] = v
+            for k, _ in a:
+                self.assertIn(k, d)
+            self.assertEqual(len(d), len(a))
+
+            d.clear()
+            self.assertEqual(len(d), 0)
+            for k, _ in a:
+                self.assertNotIn(k, d)
 
     def setUp(self):
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
         dbm._defaultmod = self.module
-        delete_files()
+        self.addCleanup(cleaunup_test_dir)
+        setup_test_dir()
 
 
 class WhichDBTestCase(unittest.TestCase):
     def test_whichdb(self):
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
+        _bytes_fname = os.fsencode(_fname)
+        fnames = [_fname, os_helper.FakePath(_fname),
+                  _bytes_fname, os_helper.FakePath(_bytes_fname)]
         for module in dbm_iterator():
             # Check whether whichdb correctly guesses module name
             # for databases opened with "module" module.
-            # Try with empty files first
             name = module.__name__
-            if name == 'dbm.dumb':
-                continue   # whichdb can't support dbm.dumb
-            delete_files()
-            f = module.open(_fname, 'c')
-            f.close()
-            self.assertEqual(name, self.dbm.whichdb(_fname))
+            setup_test_dir()
+            dbm._defaultmod = module
+            # Try with empty files first
+            with module.open(_fname, 'c'): pass
+            for path in fnames:
+                self.assertEqual(name, self.dbm.whichdb(path))
             # Now add a key
-            f = module.open(_fname, 'w')
-            f[b"1"] = b"1"
-            # and test that we can find it
-            self.assertIn(b"1", f)
-            # and read it
-            self.assertEqual(f[b"1"], b"1")
-            f.close()
-            self.assertEqual(name, self.dbm.whichdb(_fname))
+            with module.open(_fname, 'w') as f:
+                f[b"1"] = b"1"
+                # and test that we can find it
+                self.assertIn(b"1", f)
+                # and read it
+                self.assertEqual(f[b"1"], b"1")
+            for path in fnames:
+                self.assertEqual(name, self.dbm.whichdb(path))
 
     @unittest.skipUnless(ndbm, reason='Test requires ndbm')
     def test_whichdb_ndbm(self):
         # Issue 17198: check that ndbm which is referenced in whichdb is defined
-        db_file = '{}_ndbm.db'.format(_fname)
-        with open(db_file, 'w'):
-            self.addCleanup(os_helper.unlink, db_file)
-        self.assertIsNone(self.dbm.whichdb(db_file[:-3]))
+        with open(_fname + '.db', 'wb') as f:
+            f.write(b'spam')
+        _bytes_fname = os.fsencode(_fname)
+        fnames = [_fname, os_helper.FakePath(_fname),
+                  _bytes_fname, os_helper.FakePath(_bytes_fname)]
+        for path in fnames:
+            self.assertIsNone(self.dbm.whichdb(path))
+
+    @unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3')
+    def test_whichdb_sqlite3(self):
+        # Databases created by dbm.sqlite3 are detected correctly.
+        with dbm_sqlite3.open(_fname, "c") as db:
+            db["key"] = "value"
+        self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3")
+
+    @unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3')
+    def test_whichdb_sqlite3_existing_db(self):
+        # Existing sqlite3 databases are detected correctly.
+        sqlite3 = import_helper.import_module("sqlite3")
+        try:
+            # Create an empty database.
+            with sqlite3.connect(_fname) as cx:
+                cx.execute("CREATE TABLE dummy(database)")
+                cx.commit()
+        finally:
+            cx.close()
+        self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3")
 
-    def tearDown(self):
-        delete_files()
 
     def setUp(self):
-        delete_files()
-        self.filename = os_helper.TESTFN
-        self.d = dbm.open(self.filename, 'c')
-        self.d.close()
+        self.addCleanup(cleaunup_test_dir)
+        setup_test_dir()
         self.dbm = import_helper.import_fresh_module('dbm')
 
-    def test_keys(self):
-        self.d = dbm.open(self.filename, 'c')
-        self.assertEqual(self.d.keys(), [])
-        a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')]
-        for k, v in a:
-            self.d[k] = v
-        self.assertEqual(sorted(self.d.keys()), sorted(k for (k, v) in a))
-        for k, v in a:
-            self.assertIn(k, self.d)
-            self.assertEqual(self.d[k], v)
-        self.assertNotIn(b'xxx', self.d)
-        self.assertRaises(KeyError, lambda: self.d[b'xxx'])
-        self.d.close()
-
-
-def load_tests(loader, tests, pattern):
-    classes = []
-    for mod in dbm_iterator():
-        classes.append(type("TestCase-" + mod.__name__,
-                            (AnyDBMTestCase, unittest.TestCase),
-                            {'module': mod}))
-    suites = [unittest.makeSuite(c) for c in classes]
-
-    tests.addTests(suites)
-    return tests
+
+for mod in dbm_iterator():
+    assert mod.__name__.startswith('dbm.')
+    suffix = mod.__name__[4:]
+    testname = f'TestCase_{suffix}'
+    globals()[testname] = type(testname,
+                               (AnyDBMTestCase, unittest.TestCase),
+                               {'module': mod})
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_dbm_dumb.py b/Lib/test/test_dbm_dumb.py
index 0dc489362b..672f909220 100644
--- a/Lib/test/test_dbm_dumb.py
+++ b/Lib/test/test_dbm_dumb.py
@@ -15,6 +15,7 @@
 
 _fname = os_helper.TESTFN
 
+
 def _delete_files():
     for ext in [".dir", ".dat", ".bak"]:
         try:
@@ -41,6 +42,7 @@ def test_dumbdbm_creation(self):
             self.read_helper(f)
 
     @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    @os_helper.skip_unless_working_chmod
     def test_dumbdbm_creation_mode(self):
         try:
             old_umask = os.umask(0o002)
@@ -231,7 +233,7 @@ def test_create_new(self):
             self.assertEqual(f.keys(), [])
 
     def test_eval(self):
-        with open(_fname + '.dir', 'w') as stream:
+        with open(_fname + '.dir', 'w', encoding="utf-8") as stream:
             stream.write("str(print('Hacked!')), 0\n")
         with support.captured_stdout() as stdout:
             with self.assertRaises(ValueError):
@@ -244,9 +246,27 @@ def test_missing_data(self):
             _delete_files()
             with self.assertRaises(FileNotFoundError):
                 dumbdbm.open(_fname, value)
+            self.assertFalse(os.path.exists(_fname + '.dat'))
             self.assertFalse(os.path.exists(_fname + '.dir'))
             self.assertFalse(os.path.exists(_fname + '.bak'))
 
+        for value in ('c', 'n'):
+            _delete_files()
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dat'))
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
+        for value in ('c', 'n'):
+            _delete_files()
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dat'))
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertTrue(os.path.exists(_fname + '.bak'))
+
     def test_missing_index(self):
         with dumbdbm.open(_fname, 'n') as f:
             pass
@@ -257,6 +277,60 @@ def test_missing_index(self):
             self.assertFalse(os.path.exists(_fname + '.dir'))
             self.assertFalse(os.path.exists(_fname + '.bak'))
 
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+            os.unlink(_fname + '.dir')
+
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertTrue(os.path.exists(_fname + '.bak'))
+            os.unlink(_fname + '.dir')
+            os.unlink(_fname + '.bak')
+
+    def test_sync_empty_unmodified(self):
+        with dumbdbm.open(_fname, 'n') as f:
+            pass
+        os.unlink(_fname + '.dir')
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                f.sync()
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                os.unlink(_fname + '.dir')
+                f.sync()
+                self.assertFalse(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.dir'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
+    def test_sync_nonempty_unmodified(self):
+        with dumbdbm.open(_fname, 'n') as f:
+            pass
+        os.unlink(_fname + '.dir')
+        for value in ('c', 'n'):
+            with dumbdbm.open(_fname, value) as f:
+                f['key'] = 'value'
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+                f.sync()
+                self.assertTrue(os.path.exists(_fname + '.dir'))
+                self.assertTrue(os.path.exists(_fname + '.bak'))
+                os.unlink(_fname + '.dir')
+                os.unlink(_fname + '.bak')
+                f.sync()
+                self.assertFalse(os.path.exists(_fname + '.dir'))
+                self.assertFalse(os.path.exists(_fname + '.bak'))
+            self.assertFalse(os.path.exists(_fname + '.dir'))
+            self.assertFalse(os.path.exists(_fname + '.bak'))
+
     def test_invalid_flag(self):
         for flag in ('x', 'rf', None):
             with self.assertRaisesRegex(ValueError,
@@ -264,6 +338,7 @@ def test_invalid_flag(self):
                                         "'r', 'w', 'c', or 'n'"):
                 dumbdbm.open(_fname, flag)
 
+    @os_helper.skip_unless_working_chmod
     def test_readonly_files(self):
         with os_helper.temp_dir() as dir:
             fname = os.path.join(dir, 'db')
@@ -293,6 +368,15 @@ def test_nonascii_filename(self):
             self.assertTrue(b'key' in db)
             self.assertEqual(db[b'key'], b'value')
 
+    def test_open_with_pathlib_path(self):
+        dumbdbm.open(os_helper.FakePath(_fname), "c").close()
+
+    def test_open_with_bytes_path(self):
+        dumbdbm.open(os.fsencode(_fname), "c").close()
+
+    def test_open_with_pathlib_bytes_path(self):
+        dumbdbm.open(os_helper.FakePath(os.fsencode(_fname)), "c").close()
+
     def tearDown(self):
         _delete_files()
 
diff --git a/Lib/test/test_dbm_sqlite3.py b/Lib/test/test_dbm_sqlite3.py
new file mode 100644
index 0000000000..39eac7a35e
--- /dev/null
+++ b/Lib/test/test_dbm_sqlite3.py
@@ -0,0 +1,362 @@
+import os
+import stat
+import sys
+import test.support
+import unittest
+from contextlib import closing
+from functools import partial
+from pathlib import Path
+from test.support import cpython_only, import_helper, os_helper
+
+dbm_sqlite3 = import_helper.import_module("dbm.sqlite3")
+# N.B. The test will fail on some platforms without sqlite3
+# if the sqlite3 import is above the import of dbm.sqlite3.
+# This is deliberate: if the import helper managed to import dbm.sqlite3,
+# we must inevitably be able to import sqlite3. Else, we have a problem.
+import sqlite3
+from dbm.sqlite3 import _normalize_uri
+
+
+root_in_posix = False
+if hasattr(os, 'geteuid'):
+    root_in_posix = (os.geteuid() == 0)
+
+
+class _SQLiteDbmTests(unittest.TestCase):
+
+    def setUp(self):
+        self.filename = os_helper.TESTFN
+        db = dbm_sqlite3.open(self.filename, "c")
+        db.close()
+
+    def tearDown(self):
+        for suffix in "", "-wal", "-shm":
+            os_helper.unlink(self.filename + suffix)
+
+
+class URI(unittest.TestCase):
+
+    def test_uri_substitutions(self):
+        dataset = (
+            ("/absolute/////b/c", "/absolute/b/c"),
+            ("PRE#MID##END", "PRE%23MID%23%23END"),
+            ("%#?%%#", "%25%23%3F%25%25%23"),
+        )
+        for path, normalized in dataset:
+            with self.subTest(path=path, normalized=normalized):
+                self.assertTrue(_normalize_uri(path).endswith(normalized))
+
+    @unittest.skipUnless(sys.platform == "win32", "requires Windows")
+    def test_uri_windows(self):
+        dataset = (
+            # Relative subdir.
+            (r"2018\January.xlsx",
+             "2018/January.xlsx"),
+            # Absolute with drive letter.
+            (r"C:\Projects\apilibrary\apilibrary.sln",
+             "/C:/Projects/apilibrary/apilibrary.sln"),
+            # Relative with drive letter.
+            (r"C:Projects\apilibrary\apilibrary.sln",
+             "/C:Projects/apilibrary/apilibrary.sln"),
+        )
+        for path, normalized in dataset:
+            with self.subTest(path=path, normalized=normalized):
+                if not Path(path).is_absolute():
+                    self.skipTest(f"skipping relative path: {path!r}")
+                self.assertTrue(_normalize_uri(path).endswith(normalized))
+
+
+class ReadOnly(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        with dbm_sqlite3.open(self.filename, "w") as db:
+            db[b"key1"] = "value1"
+            db[b"key2"] = "value2"
+        self.db = dbm_sqlite3.open(self.filename, "r")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_readonly_read(self):
+        self.assertEqual(self.db[b"key1"], b"value1")
+        self.assertEqual(self.db[b"key2"], b"value2")
+
+    def test_readonly_write(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"new"] = "value"
+
+    def test_readonly_delete(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            del self.db[b"key1"]
+
+    def test_readonly_keys(self):
+        self.assertEqual(self.db.keys(), [b"key1", b"key2"])
+
+    def test_readonly_iter(self):
+        self.assertEqual([k for k in self.db], [b"key1", b"key2"])
+
+
+@unittest.skipIf(root_in_posix, "test is meanless with root privilege")
+class ReadOnlyFilesystem(unittest.TestCase):
+
+    def setUp(self):
+        self.test_dir = os_helper.TESTFN
+        self.addCleanup(os_helper.rmtree, self.test_dir)
+        os.mkdir(self.test_dir)
+        self.db_path = os.path.join(self.test_dir, "test.db")
+
+        db = dbm_sqlite3.open(self.db_path, "c")
+        db[b"key"] = b"value"
+        db.close()
+
+    def test_readonly_file_read(self):
+        os.chmod(self.db_path, stat.S_IREAD)
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_readonly_file_write(self):
+        os.chmod(self.db_path, stat.S_IREAD)
+        with dbm_sqlite3.open(self.db_path, "w") as db:
+            with self.assertRaises(dbm_sqlite3.error):
+                db[b"newkey"] = b"newvalue"
+
+    def test_readonly_dir_read(self):
+        os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_readonly_dir_write(self):
+        os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
+        with dbm_sqlite3.open(self.db_path, "w") as db:
+            try:
+                db[b"newkey"] = b"newvalue"
+                modified = True  # on Windows and macOS
+            except dbm_sqlite3.error:
+                modified = False
+        with dbm_sqlite3.open(self.db_path, "r") as db:
+            if modified:
+                self.assertEqual(db[b"newkey"], b"newvalue")
+            else:
+                self.assertNotIn(b"newkey", db)
+
+
+class ReadWrite(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def db_content(self):
+        with closing(sqlite3.connect(self.filename)) as cx:
+            keys = [r[0] for r in cx.execute("SELECT key FROM Dict")]
+            vals = [r[0] for r in cx.execute("SELECT value FROM Dict")]
+        return keys, vals
+
+    def test_readwrite_unique_key(self):
+        self.db["key"] = "value"
+        self.db["key"] = "other"
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [b"key"])
+        self.assertEqual(vals, [b"other"])
+
+    def test_readwrite_delete(self):
+        self.db["key"] = "value"
+        self.db["new"] = "other"
+
+        del self.db[b"new"]
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [b"key"])
+        self.assertEqual(vals, [b"value"])
+
+        del self.db[b"key"]
+        keys, vals = self.db_content()
+        self.assertEqual(keys, [])
+        self.assertEqual(vals, [])
+
+    def test_readwrite_null_key(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[None] = "value"
+
+    def test_readwrite_null_value(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"key"] = None
+
+
+class Misuse(_SQLiteDbmTests):
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_misuse_double_create(self):
+        self.db["key"] = "value"
+        with dbm_sqlite3.open(self.filename, "c") as db:
+            self.assertEqual(db[b"key"], b"value")
+
+    def test_misuse_double_close(self):
+        self.db.close()
+
+    def test_misuse_invalid_flag(self):
+        regex = "must be.*'r'.*'w'.*'c'.*'n', not 'invalid'"
+        with self.assertRaisesRegex(ValueError, regex):
+            dbm_sqlite3.open(self.filename, flag="invalid")
+
+    def test_misuse_double_delete(self):
+        self.db["key"] = "value"
+        del self.db[b"key"]
+        with self.assertRaises(KeyError):
+            del self.db[b"key"]
+
+    def test_misuse_invalid_key(self):
+        with self.assertRaises(KeyError):
+            self.db[b"key"]
+
+    def test_misuse_iter_close1(self):
+        self.db["1"] = 1
+        it = iter(self.db)
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            next(it)
+
+    def test_misuse_iter_close2(self):
+        self.db["1"] = 1
+        self.db["2"] = 2
+        it = iter(self.db)
+        next(it)
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            next(it)
+
+    def test_misuse_use_after_close(self):
+        self.db.close()
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"read"]
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db[b"write"] = "value"
+        with self.assertRaises(dbm_sqlite3.error):
+            del self.db[b"del"]
+        with self.assertRaises(dbm_sqlite3.error):
+            len(self.db)
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db.keys()
+
+    def test_misuse_reinit(self):
+        with self.assertRaises(dbm_sqlite3.error):
+            self.db.__init__("new.db", flag="n", mode=0o666)
+
+    def test_misuse_empty_filename(self):
+        for flag in "r", "w", "c", "n":
+            with self.assertRaises(dbm_sqlite3.error):
+                db = dbm_sqlite3.open("", flag="c")
+
+
+class DataTypes(_SQLiteDbmTests):
+
+    dataset = (
+        # (raw, coerced)
+        (42, b"42"),
+        (3.14, b"3.14"),
+        ("string", b"string"),
+        (b"bytes", b"bytes"),
+    )
+
+    def setUp(self):
+        super().setUp()
+        self.db = dbm_sqlite3.open(self.filename, "w")
+
+    def tearDown(self):
+        self.db.close()
+        super().tearDown()
+
+    def test_datatypes_values(self):
+        for raw, coerced in self.dataset:
+            with self.subTest(raw=raw, coerced=coerced):
+                self.db["key"] = raw
+                self.assertEqual(self.db[b"key"], coerced)
+
+    def test_datatypes_keys(self):
+        for raw, coerced in self.dataset:
+            with self.subTest(raw=raw, coerced=coerced):
+                self.db[raw] = "value"
+                self.assertEqual(self.db[coerced], b"value")
+                # Raw keys are silently coerced to bytes.
+                self.assertEqual(self.db[raw], b"value")
+                del self.db[raw]
+
+    def test_datatypes_replace_coerced(self):
+        self.db["10"] = "value"
+        self.db[b"10"] = "value"
+        self.db[10] = "value"
+        self.assertEqual(self.db.keys(), [b"10"])
+
+
+class CorruptDatabase(_SQLiteDbmTests):
+    """Verify that database exceptions are raised as dbm.sqlite3.error."""
+
+    def setUp(self):
+        super().setUp()
+        with closing(sqlite3.connect(self.filename)) as cx:
+            with cx:
+                cx.execute("DROP TABLE IF EXISTS Dict")
+                cx.execute("CREATE TABLE Dict (invalid_schema)")
+
+    def check(self, flag, fn, should_succeed=False):
+        with closing(dbm_sqlite3.open(self.filename, flag)) as db:
+            with self.assertRaises(dbm_sqlite3.error):
+                fn(db)
+
+    @staticmethod
+    def read(db):
+        return db["key"]
+
+    @staticmethod
+    def write(db):
+        db["key"] = "value"
+
+    @staticmethod
+    def iter(db):
+        next(iter(db))
+
+    @staticmethod
+    def keys(db):
+        db.keys()
+
+    @staticmethod
+    def del_(db):
+        del db["key"]
+
+    @staticmethod
+    def len_(db):
+        len(db)
+
+    def test_corrupt_readwrite(self):
+        for flag in "r", "w", "c":
+            with self.subTest(flag=flag):
+                check = partial(self.check, flag=flag)
+                check(fn=self.read)
+                check(fn=self.write)
+                check(fn=self.iter)
+                check(fn=self.keys)
+                check(fn=self.del_)
+                check(fn=self.len_)
+
+    def test_corrupt_force_new(self):
+        with closing(dbm_sqlite3.open(self.filename, "n")) as db:
+            db["foo"] = "write"
+            _ = db[b"foo"]
+            next(iter(db))
+            del db[b"foo"]
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
index 0493d6a41d..01b0c06196 100644
--- a/Lib/test/test_decimal.py
+++ b/Lib/test/test_decimal.py
@@ -24,6 +24,7 @@
 with the corresponding argument.
 """
 
+import logging
 import math
 import os, sys
 import operator
@@ -812,8 +813,6 @@ 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
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_unicode_digits(self):
         Decimal = self.decimal.Decimal
 
@@ -831,6 +830,11 @@ 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
+        return super().test_unicode_digits()
+
 class ImplicitConstructionTest:
     '''Unit tests for Implicit Construction cases of Decimal.'''
 
@@ -916,8 +920,6 @@ class PyImplicitConstructionTest(ImplicitConstructionTest, unittest.TestCase):
 
 class FormatTest:
     '''Unit tests for the format function.'''
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_formatting(self):
         Decimal = self.decimal.Decimal
 
@@ -1113,6 +1115,13 @@ def test_formatting(self):
             ('z>z6.1f', '-0.', 'zzz0.0'),
             ('x>z6.1f', '-0.', 'xxx0.0'),
             ('🖤>z6.1f', '-0.', '🖤🖤🖤0.0'),  # multi-byte fill char
+            ('\x00>z6.1f', '-0.', '\x00\x00\x000.0'),  # null fill char
+
+            # issue 114563 ('z' format on F type in cdecimal)
+            ('z3,.10F', '-6.24E-323', '0.0000000000'),
+
+            # issue 91060 ('#' format in cdecimal)
+            ('#', '0', '0.'),
 
             # issue 6850
             ('a=-7.0', '0.12345', 'aaaa0.1'),
@@ -1128,8 +1137,6 @@ def test_formatting(self):
         # bytes format argument
         self.assertRaises(TypeError, Decimal(1).__format__, b'-020')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_negative_zero_format_directed_rounding(self):
         with self.decimal.localcontext() as ctx:
             ctx.rounding = ROUND_CEILING
@@ -1228,7 +1235,31 @@ def get_fmt(x, override=None, fmt='n'):
         self.assertEqual(get_fmt(Decimal('-1.5'), dotsep_wide, '020n'),
                          '-0\u00b4000\u00b4000\u00b4000\u00b4001\u00bf5')
 
-    @run_with_locale('LC_ALL', 'ps_AF')
+    def test_deprecated_N_format(self):
+        Decimal = self.decimal.Decimal
+        h = Decimal('6.62607015e-34')
+        if self.decimal == C:
+            with self.assertWarns(DeprecationWarning) as cm:
+                r = format(h, 'N')
+            self.assertEqual(cm.filename, __file__)
+            self.assertEqual(r, format(h, 'n').upper())
+            with self.assertWarns(DeprecationWarning) as cm:
+                r = format(h, '010.3N')
+            self.assertEqual(cm.filename, __file__)
+            self.assertEqual(r, format(h, '010.3n').upper())
+        else:
+            self.assertRaises(ValueError, format, h, 'N')
+            self.assertRaises(ValueError, format, h, '010.3N')
+        with warnings_helper.check_no_warnings(self):
+            self.assertEqual(format(h, 'N>10.3'), 'NN6.63E-34')
+            self.assertEqual(format(h, 'N>10.3n'), 'NN6.63e-34')
+            self.assertEqual(format(h, 'N>10.3e'), 'N6.626e-34')
+            self.assertEqual(format(h, 'N>10.3f'), 'NNNNN0.000')
+            self.assertRaises(ValueError, format, h, '>Nf')
+            self.assertRaises(ValueError, format, h, '10Nf')
+            self.assertRaises(ValueError, format, h, 'Nx')
+
+    @run_with_locale('LC_ALL', 'ps_AF', '')
     def test_wide_char_separator_decimal_point(self):
         # locale with wide char separator and decimal point
         Decimal = self.decimal.Decimal
@@ -1911,8 +1942,6 @@ def hashit(d):
             x = 1100 ** 1248
             self.assertEqual(hashit(Decimal(x)), hashit(x))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_hash_method_nan(self):
         Decimal = self.decimal.Decimal
         self.assertRaises(TypeError, hash, Decimal('sNaN'))
@@ -2048,7 +2077,9 @@ def test_tonum_methods(self):
         #to quantize, which is already extensively tested
         test_triples = [
             ('123.456', -4, '0E+4'),
+            ('-123.456', -4, '-0E+4'),
             ('123.456', -3, '0E+3'),
+            ('-123.456', -3, '-0E+3'),
             ('123.456', -2, '1E+2'),
             ('123.456', -1, '1.2E+2'),
             ('123.456', 0, '123'),
@@ -2718,8 +2749,6 @@ def test_quantize(self):
         x = d.quantize(context=c, exp=Decimal("1e797"), rounding=ROUND_DOWN)
         self.assertEqual(x, Decimal('8.71E+799'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_complex(self):
         Decimal = self.decimal.Decimal
 
@@ -2894,6 +2923,7 @@ class CPythonAPItests(PythonAPItests, unittest.TestCase):
 class PyPythonAPItests(PythonAPItests, unittest.TestCase):
     decimal = P
 
+
 class ContextAPItests:
 
     def test_none_args(self):
@@ -3663,8 +3693,6 @@ def test_localcontextarg(self):
         self.assertIsNot(new_ctx, set_ctx, 'did not copy the context')
         self.assertIs(set_ctx, enter_ctx, '__enter__ returned wrong context')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_localcontext_kwargs(self):
         with self.decimal.localcontext(
             prec=10, rounding=ROUND_HALF_DOWN,
@@ -3693,8 +3721,6 @@ def test_localcontext_kwargs(self):
         self.assertRaises(TypeError, self.decimal.localcontext, Emin="")
         self.assertRaises(TypeError, self.decimal.localcontext, Emax="")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_local_context_kwargs_does_not_overwrite_existing_argument(self):
         ctx = self.decimal.getcontext()
         orig_prec = ctx.prec
@@ -4362,7 +4388,8 @@ def test_module_attributes(self):
 
         self.assertEqual(C.__version__, P.__version__)
 
-        self.assertEqual(dir(C), dir(P))
+        self.assertLessEqual(set(dir(C)), set(dir(P)))
+        self.assertEqual([n for n in dir(C) if n[:2] != '__'], sorted(P.__all__))
 
     def test_context_attributes(self):
 
@@ -4438,6 +4465,15 @@ 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)
+            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))
             # exp
             self.assertEqual(Decimal("1.01").exp(), 3)
             # is_normal
@@ -4648,6 +4684,11 @@ 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"""
 
@@ -4699,9 +4740,33 @@ def test_py_exact_power(self):
 
             c.prec = 1
             x = Decimal("152587890625") ** Decimal('-0.5')
+            self.assertEqual(x, Decimal('3e-6'))
+            c.prec = 2
+            x = Decimal("152587890625") ** Decimal('-0.5')
+            self.assertEqual(x, Decimal('2.6e-6'))
+            c.prec = 3
+            x = Decimal("152587890625") ** Decimal('-0.5')
+            self.assertEqual(x, Decimal('2.56e-6'))
+            c.prec = 28
+            x = Decimal("152587890625") ** Decimal('-0.5')
+            self.assertEqual(x, Decimal('2.56e-6'))
+
             c.prec = 201
             x = Decimal(2**578) ** Decimal("-0.5")
 
+            # See https://github.com/python/cpython/issues/118027
+            # Testing for an exact power could appear to hang, in the Python
+            # version, as it attempted to compute 10**(MAX_EMAX + 1).
+            # Fixed via https://github.com/python/cpython/pull/118503.
+            c.prec = P.MAX_PREC
+            c.Emax = P.MAX_EMAX
+            c.Emin = P.MIN_EMIN
+            c.traps[P.Inexact] = 1
+            D2 = Decimal(2)
+            # If the bug is still present, the next statement won't complete.
+            res = D2 ** 117
+            self.assertEqual(res, 1 << 117)
+
     def test_py_immutability_operations(self):
         # Do operations and check that it didn't change internal objects.
         Decimal = P.Decimal
@@ -5625,6 +5690,25 @@ def __abs__(self):
             self.assertEqual(Decimal.from_float(cls(101.1)),
                              Decimal.from_float(101.1))
 
+    def test_c_immutable_types(self):
+        SignalDict = type(C.Context().flags)
+        SignalDictMixin = SignalDict.__bases__[0]
+        ContextManager = type(C.localcontext())
+        types = (
+            SignalDictMixin,
+            ContextManager,
+            C.Decimal,
+            C.Context,
+        )
+        for tp in types:
+            with self.subTest(tp=tp):
+                with self.assertRaisesRegex(TypeError, "immutable"):
+                    tp.foo = 1
+
+    def test_c_disallow_instantiation(self):
+        ContextManager = type(C.localcontext())
+        check_disallow_instantiation(self, ContextManager)
+
     def test_c_signaldict_segfault(self):
         # See gh-106263 for details.
         SignalDict = type(C.Context().flags)
@@ -5655,6 +5739,20 @@ def test_c_signaldict_segfault(self):
         with self.assertRaisesRegex(ValueError, err_msg):
             sd.copy()
 
+    def test_format_fallback_capitals(self):
+        # Fallback to _pydecimal formatting (triggered by `#` format which
+        # is unsupported by mpdecimal) should honor the current context.
+        x = C.Decimal('6.09e+23')
+        self.assertEqual(format(x, '#'), '6.09E+23')
+        with C.localcontext(capitals=0):
+            self.assertEqual(format(x, '#'), '6.09e+23')
+
+    def test_format_fallback_rounding(self):
+        y = C.Decimal('6.09')
+        self.assertEqual(format(y, '#.1f'), '6.1')
+        with C.localcontext(rounding=C.ROUND_DOWN):
+            self.assertEqual(format(y, '#.1f'), '6.0')
+
 @requires_docstrings
 @requires_cdecimal
 class SignatureTest(unittest.TestCase):
@@ -5818,13 +5916,17 @@ def load_tests(loader, tests, pattern):
 
     if TODO_TESTS is None:
         from doctest import DocTestSuite, IGNORE_EXCEPTION_DETAIL
+        orig_context = orig_sys_decimal.getcontext().copy()
         for mod in C, P:
             if not mod:
                 continue
             def setUp(slf, mod=mod):
                 sys.modules['decimal'] = mod
-            def tearDown(slf):
+                init(mod)
+            def tearDown(slf, mod=mod):
                 sys.modules['decimal'] = orig_sys_decimal
+                mod.setcontext(ORIGINAL_CONTEXT[mod].copy())
+                orig_sys_decimal.setcontext(orig_context.copy())
             optionflags = IGNORE_EXCEPTION_DETAIL if mod is C else 0
             sys.modules['decimal'] = mod
             tests.addTest(DocTestSuite(mod, setUp=setUp, tearDown=tearDown,
@@ -5839,11 +5941,12 @@ def setUpModule():
     TEST_ALL = ARITH if ARITH is not None else is_resource_enabled('decimal')
 
 def tearDownModule():
-    if C: C.setcontext(ORIGINAL_CONTEXT[C])
-    P.setcontext(ORIGINAL_CONTEXT[P])
+    if C: C.setcontext(ORIGINAL_CONTEXT[C].copy())
+    P.setcontext(ORIGINAL_CONTEXT[P].copy())
     if not C:
-        warnings.warn('C tests skipped: no module named _decimal.',
-                      UserWarning)
+        logging.getLogger(__name__).warning(
+            'C tests skipped: no module named _decimal.'
+        )
     if not orig_sys_decimal is sys.modules['decimal']:
         raise TestFailed("Internal error: unbalanced number of changes to "
                          "sys.modules['decimal'].")
diff --git a/Lib/test/test_decorators.py b/Lib/test/test_decorators.py
index 739c9b3909..4da2c13a60 100644
--- a/Lib/test/test_decorators.py
+++ b/Lib/test/test_decorators.py
@@ -291,46 +291,7 @@ def bar(): return 42
         self.assertEqual(bar(), 42)
         self.assertEqual(actions, expected_actions)
 
-    def test_wrapped_descriptor_inside_classmethod(self):
-        class BoundWrapper:
-            def __init__(self, wrapped):
-                self.__wrapped__ = wrapped
-
-            def __call__(self, *args, **kwargs):
-                return self.__wrapped__(*args, **kwargs)
-
-        class Wrapper:
-            def __init__(self, wrapped):
-                self.__wrapped__ = wrapped
-
-            def __get__(self, instance, owner):
-                bound_function = self.__wrapped__.__get__(instance, owner)
-                return BoundWrapper(bound_function)
-
-        def decorator(wrapped):
-            return Wrapper(wrapped)
-
-        class Class:
-            @decorator
-            @classmethod
-            def inner(cls):
-                # This should already work.
-                return 'spam'
-
-            @classmethod
-            @decorator
-            def outer(cls):
-                # Raised TypeError with a message saying that the 'Wrapper'
-                # object is not callable.
-                return 'eggs'
-
-        self.assertEqual(Class.inner(), 'spam')
-        self.assertEqual(Class.outer(), 'eggs')
-        self.assertEqual(Class().inner(), 'spam')
-        self.assertEqual(Class().outer(), 'eggs')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bound_function_inside_classmethod(self):
         class A:
             def foo(self, cls):
@@ -341,91 +302,6 @@ class B:
 
         self.assertEqual(B.bar(), 'spam')
 
-    def test_wrapped_classmethod_inside_classmethod(self):
-        class MyClassMethod1:
-            def __init__(self, func):
-                self.func = func
-
-            def __call__(self, cls):
-                if hasattr(self.func, '__get__'):
-                    return self.func.__get__(cls, cls)()
-                return self.func(cls)
-
-            def __get__(self, instance, owner=None):
-                if owner is None:
-                    owner = type(instance)
-                return MethodType(self, owner)
-
-        class MyClassMethod2:
-            def __init__(self, func):
-                if isinstance(func, classmethod):
-                    func = func.__func__
-                self.func = func
-
-            def __call__(self, cls):
-                return self.func(cls)
-
-            def __get__(self, instance, owner=None):
-                if owner is None:
-                    owner = type(instance)
-                return MethodType(self, owner)
-
-        for myclassmethod in [MyClassMethod1, MyClassMethod2]:
-            class A:
-                @myclassmethod
-                def f1(cls):
-                    return cls
-
-                @classmethod
-                @myclassmethod
-                def f2(cls):
-                    return cls
-
-                @myclassmethod
-                @classmethod
-                def f3(cls):
-                    return cls
-
-                @classmethod
-                @classmethod
-                def f4(cls):
-                    return cls
-
-                @myclassmethod
-                @MyClassMethod1
-                def f5(cls):
-                    return cls
-
-                @myclassmethod
-                @MyClassMethod2
-                def f6(cls):
-                    return cls
-
-            self.assertIs(A.f1(), A)
-            self.assertIs(A.f2(), A)
-            self.assertIs(A.f3(), A)
-            self.assertIs(A.f4(), A)
-            self.assertIs(A.f5(), A)
-            self.assertIs(A.f6(), A)
-            a = A()
-            self.assertIs(a.f1(), A)
-            self.assertIs(a.f2(), A)
-            self.assertIs(a.f3(), A)
-            self.assertIs(a.f4(), A)
-            self.assertIs(a.f5(), A)
-            self.assertIs(a.f6(), A)
-
-            def f(cls):
-                return cls
-
-            self.assertIs(myclassmethod(f).__get__(a)(), A)
-            self.assertIs(myclassmethod(f).__get__(a, A)(), A)
-            self.assertIs(myclassmethod(f).__get__(A, A)(), A)
-            self.assertIs(myclassmethod(f).__get__(A)(), type(A))
-            self.assertIs(classmethod(f).__get__(a)(), A)
-            self.assertIs(classmethod(f).__get__(a, A)(), A)
-            self.assertIs(classmethod(f).__get__(A, A)(), A)
-            self.assertIs(classmethod(f).__get__(A)(), type(A))
 
 class TestClassDecorators(unittest.TestCase):
 
diff --git a/Lib/test/test_deque.py b/Lib/test/test_deque.py
index 2b0144eb06..9f00e12edd 100644
--- a/Lib/test/test_deque.py
+++ b/Lib/test/test_deque.py
@@ -166,7 +166,7 @@ def test_contains(self):
         with self.assertRaises(RuntimeError):
             n in d
 
-    def test_contains_count_stop_crashes(self):
+    def test_contains_count_index_stop_crashes(self):
         class A:
             def __eq__(self, other):
                 d.clear()
@@ -178,6 +178,10 @@ def __eq__(self, other):
         with self.assertRaises(RuntimeError):
             _ = d.count(3)
 
+        d = deque([A()])
+        with self.assertRaises(RuntimeError):
+            d.index(0)
+
     def test_extend(self):
         d = deque('a')
         self.assertRaises(TypeError, d.extend, 1)
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index d1c83cc337..2ad302690c 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -15,6 +15,7 @@
 from copy import deepcopy
 from contextlib import redirect_stdout
 from test import support
+from test.support.testcase import ExtraAssertions
 
 try:
     import _testcapi
@@ -403,15 +404,7 @@ def test_wrap_lenfunc_bad_cast(self):
         self.assertEqual(range(sys.maxsize).__len__(), sys.maxsize)
 
 
-class ClassPropertiesAndMethods(unittest.TestCase):
-
-    def assertHasAttr(self, obj, name):
-        self.assertTrue(hasattr(obj, name),
-                        '%r has no attribute %r' % (obj, name))
-
-    def assertNotHasAttr(self, obj, name):
-        self.assertFalse(hasattr(obj, name),
-                         '%r has unexpected attribute %r' % (obj, name))
+class ClassPropertiesAndMethods(unittest.TestCase, ExtraAssertions):
 
     def test_python_dicts(self):
         # Testing Python subclass of dict...
@@ -479,8 +472,6 @@ def __getitem__(self, i):
         self.assertEqual(a[2], 102)
         self.assertEqual(a[100:200], (100,200))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_metaclass(self):
         # Testing metaclasses...
         class C(metaclass=type):
@@ -991,8 +982,8 @@ class EditableScrollablePane(ScrollablePane,EditablePane): pass
 
     def test_mro_disagreement(self):
         # Testing error messages for MRO disagreement...
-        mro_err_msg = """Cannot create a consistent method resolution
-order (MRO) for bases """
+        mro_err_msg = ("Cannot create a consistent method resolution "
+                       "order (MRO) for bases ")
 
         def raises(exc, expected, callable, *args):
             try:
@@ -1111,8 +1102,7 @@ class MyFrozenSet(frozenset):
         with self.assertRaises(TypeError):
             frozenset().__class__ = MyFrozenSet
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots(self):
         # Testing __slots__...
         class C0(object):
@@ -1201,10 +1191,9 @@ class C(object):
             pass
         else:
             self.fail("[''] slots not caught")
-        class C(object):
+
+        class WithValidIdentifiers(object):
             __slots__ = ["a", "a_b", "_a", "A0123456789Z"]
-        # XXX(nnorwitz): was there supposed to be something tested
-        # from the class above?
 
         # Test a single string is not expanded as a sequence.
         class C(object):
@@ -1318,7 +1307,7 @@ class X(object):
         # Inherit from object on purpose to check some backwards compatibility paths
         class X(object):
             __slots__ = "a"
-        with self.assertRaisesRegex(AttributeError, "'X' object has no attribute 'a'"):
+        with self.assertRaisesRegex(AttributeError, "'test.test_descr.ClassPropertiesAndMethods.test_slots.<locals>.X' object has no attribute 'a'"):
             X().a
 
         # Test string subclass in `__slots__`, see gh-98783
@@ -1330,8 +1319,7 @@ class X(object):
         with self.assertRaisesRegex(AttributeError, "'X' object has no attribute 'a'"):
             X().a
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_special(self):
         # Testing __dict__ and __weakref__ in __slots__...
         class D(object):
@@ -1370,8 +1358,7 @@ class C2(D, W):
         a.foo = 42
         self.assertEqual(a.__dict__, {"foo": 42})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_special2(self):
         # Testing __qualname__ and __classcell__ in __slots__
         class Meta(type):
@@ -1412,8 +1399,6 @@ class Q2:
                 __qualname__ = object()
                 __slots__ = ["__qualname__"]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slots_descriptor(self):
         # Issue2115: slot descriptors did not correctly check
         # the type of the given object
@@ -1604,7 +1589,11 @@ def f(cls, arg):
 
         cm = classmethod(f)
         cm_dict = {'__annotations__': {},
-                   '__doc__': "f docstring",
+                   '__doc__': (
+                       "f docstring"
+                       if support.HAVE_PY_DOCSTRINGS
+                       else None
+                    ),
                    '__module__': __name__,
                    '__name__': 'f',
                    '__qualname__': f.__qualname__}
@@ -1676,8 +1665,6 @@ class SubSpam(spam.spamlist): pass
             spam_cm.__get__(None, list)
         self.assertEqual(str(cm.exception), expected_errmsg)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_staticmethods(self):
         # Testing static methods...
         class C(object):
@@ -1695,10 +1682,10 @@ class D(C):
         self.assertEqual(d.foo(1), (d, 1))
         self.assertEqual(D.foo(d, 1), (d, 1))
         sm = staticmethod(None)
-        self.assertEqual(sm.__dict__, {'__doc__': None})
+        self.assertEqual(sm.__dict__, {'__doc__': None.__doc__})
         sm.x = 42
         self.assertEqual(sm.x, 42)
-        self.assertEqual(sm.__dict__, {"x" : 42, '__doc__': None})
+        self.assertEqual(sm.__dict__, {"x" : 42, '__doc__': None.__doc__})
         del sm.x
         self.assertNotHasAttr(sm, "x")
 
@@ -1800,7 +1787,6 @@ class D(C):
         self.assertEqual(b.foo, 3)
         self.assertEqual(b.__class__, D)
 
-    @unittest.expectedFailure
     def test_bad_new(self):
         self.assertRaises(TypeError, object.__new__)
         self.assertRaises(TypeError, object.__new__, '')
@@ -1813,8 +1799,7 @@ class C(list):
             __new__ = object.__new__
         self.assertRaises(TypeError, C)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_object_new(self):
         class A(object):
             pass
@@ -1849,6 +1834,8 @@ def __init__(self, foo):
         object.__init__(A(3))
         self.assertRaises(TypeError, object.__init__, A(3), 5)
 
+    # TODO: RUSTPYTHON; The `expectedFailure` here is from CPython, so this test must fail
+    # @unittest.expectedFailure
     def test_restored_object_new(self):
         class A(object):
             def __new__(cls, *args, **kwargs):
@@ -1872,8 +1859,7 @@ def __init__(self, foo):
         self.assertEqual(b.foo, 3)
         self.assertEqual(b.__class__, B)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_altmro(self):
         # Testing mro() and overriding it...
         class A(object):
@@ -2052,8 +2038,7 @@ def test_methods_in_c(self):
             set_add.__get__(0)
         self.assertEqual(cm.exception.args[0], expected_errmsg)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -2256,8 +2241,7 @@ def __contains__(self, value):
             self.assertIn(i, p10)
         self.assertNotIn(10, p10)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weakrefs(self):
         # Testing weak references...
         import weakref
@@ -2289,8 +2273,7 @@ class Weak(object):
         self.assertEqual(r(), None)
         del r
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_properties(self):
         # Testing property...
         class C(object):
@@ -2618,8 +2601,7 @@ def __getclass(self):
 
         dir(C()) # This used to segfault
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_supers(self):
         # Testing super...
 
@@ -2732,8 +2714,7 @@ def test(klass):
         with self.assertRaises(TypeError):
             super(Base, kw=1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_basic_inheritance(self):
         # Testing inheritance from basic types...
 
@@ -3066,8 +3047,7 @@ class sublist(list):
         ##         pass
         ##     os_helper.unlink(os_helper.TESTFN)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keywords(self):
         # Testing keyword args to basic type constructors ...
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
@@ -3270,8 +3250,7 @@ def __ge__(self, other):
                                          eval("x %s y" % op),
                                          "x=%d, y=%d" % (x, y))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_descrdoc(self):
         # Testing descriptor doc strings...
         from _io import FileIO
@@ -3295,8 +3274,7 @@ class NewClass:
         self.assertEqual(NewClass.__doc__, 'object=None; type=NewClass')
         self.assertEqual(NewClass().__doc__, 'object=NewClass instance; type=NewClass')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_set_class(self):
         # Testing __class__ assignment...
         class C(object): pass
@@ -3386,8 +3364,7 @@ def __del__(self):
         l = [A() for x in range(100)]
         del l
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_set_dict(self):
         # Testing __dict__ assignment...
         class C(object): pass
@@ -3646,7 +3623,7 @@ 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')
     def test_recursive_call(self):
         # Testing recursive __call__() by setting to instance of class...
         class A(object):
@@ -3765,8 +3742,7 @@ def test_uninitialized_modules(self):
         m.foo = 1
         self.assertEqual(m.__dict__, {"foo": 1})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_funny_new(self):
         # Testing __new__ returning something unexpected...
         class C(object):
@@ -3928,7 +3904,7 @@ def __del__(self):
         # it as a leak.
         del C.__del__
 
-    @unittest.skip("TODO: RUSTPYTHON, rustpython segmentation fault")
+    @unittest.skip('TODO: RUSTPYTHON; rustpython segmentation fault')
     def test_slots_trash(self):
         # Testing slot trash...
         # Deallocating deeply nested slotted trash caused stack overflows
@@ -3941,8 +3917,7 @@ def __init__(self, x):
             o = trash(o)
         del o
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slots_multiple_inheritance(self):
         # SF bug 575229, multiple inheritance w/ slots dumps core
         class A(object):
@@ -4087,8 +4062,7 @@ class E(D):
         else:
             self.fail("shouldn't be able to create inheritance cycles")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -4133,8 +4107,7 @@ class D(C):
         else:
             self.fail("best_base calculation found wanting")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unsubclassable_types(self):
         with self.assertRaises(TypeError):
             class X(type(None)):
@@ -4167,8 +4140,7 @@ class X(object):
         with self.assertRaises(TypeError):
             X.__bases__ = type(None), O
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mutable_bases_with_failing_mro(self):
         # Testing mutable bases with failing mro...
         class WorkOnce(type):
@@ -4261,7 +4233,6 @@ class C(object):
         C.__name__ = 'D.E'
         self.assertEqual((C.__module__, C.__name__), (mod, 'D.E'))
 
-    @unittest.skip("TODO: RUSTPYTHON, rustpython hang")
     def test_evil_type_name(self):
         # A badly placed Py_DECREF in type_set_name led to arbitrary code
         # execution while the type structure was not in a sane state, and a
@@ -4276,8 +4247,7 @@ class C:
         C.__name__ = Nasty("abc")
         C.__name__ = "normal"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_right_op(self):
         # Testing correct dispatch of subclass overloading __r<op>__...
 
@@ -4412,8 +4382,7 @@ class D(C):
         self.assertIsInstance(a, C)  # Baseline
         self.assertIsInstance(pa, C) # Test
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_super(self):
         # Testing super() for a proxy object...
         class Proxy(object):
@@ -4437,8 +4406,7 @@ def f(self):
         p = Proxy(obj)
         self.assertEqual(C.__dict__["f"](p), "B.f->C.f")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_carloverre(self):
         # Testing prohibition of Carlo Verre's hack...
         try:
@@ -4471,8 +4439,7 @@ class C(B, A):
         except TypeError:
             self.fail("setattr through direct base types should be legal")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_carloverre_multi_inherit_invalid(self):
         class A(type):
             def __setattr__(cls, key, value):
@@ -4510,8 +4477,8 @@ class Oops(object):
         o = Oops()
         o.whatever = Provoker(o)
         del o
-        
-    @unittest.skip("TODO: RUSTPYTHON, rustpython segmentation fault")
+
+    @unittest.skip('TODO: RUSTPYTHON; rustpython segmentation fault')
     @support.requires_resource('cpu')
     def test_wrapper_segfault(self):
         # SF 927248: deeply nested wrappers could cause stack overflow
@@ -4586,8 +4553,7 @@ def assertNotOrderable(self, a, b):
         with self.assertRaises(TypeError):
             a >= b
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_method_wrapper(self):
         # Testing method-wrapper objects...
         # <type 'method-wrapper'> did not support any reflection before 2.5
@@ -4647,18 +4613,16 @@ def test_special_unbound_method_types(self):
     def test_not_implemented(self):
         # Testing NotImplemented...
         # all binary methods should be able to return a NotImplemented
-        import operator
 
         def specialmethod(self, other):
             return NotImplemented
 
         def check(expr, x, y):
-            try:
-                exec(expr, {'x': x, 'y': y, 'operator': operator})
-            except TypeError:
-                pass
-            else:
-                self.fail("no TypeError from %r" % (expr,))
+            with (
+                self.subTest(expr=expr, x=x, y=y),
+                self.assertRaises(TypeError),
+            ):
+                exec(expr, {'x': x, 'y': y})
 
         N1 = sys.maxsize + 1    # might trigger OverflowErrors instead of
                                 # TypeErrors
@@ -4679,12 +4643,23 @@ def check(expr, x, y):
                 ('__and__',      'x & y',                   'x &= y'),
                 ('__or__',       'x | y',                   'x |= y'),
                 ('__xor__',      'x ^ y',                   'x ^= y')]:
-            rname = '__r' + name[2:]
+            # Defines 'left' magic method:
             A = type('A', (), {name: specialmethod})
             a = A()
             check(expr, a, a)
             check(expr, a, N1)
             check(expr, a, N2)
+            # Defines 'right' magic method:
+            rname = '__r' + name[2:]
+            B = type('B', (), {rname: specialmethod})
+            b = B()
+            check(expr, b, b)
+            check(expr, a, b)
+            check(expr, b, a)
+            check(expr, b, N1)
+            check(expr, b, N2)
+            check(expr, N1, b)
+            check(expr, N2, b)
             if iexpr:
                 check(iexpr, a, a)
                 check(iexpr, a, N1)
@@ -4791,6 +4766,21 @@ class X(object):
         with self.assertRaises(AttributeError):
             del X.__abstractmethods__
 
+    @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
+        with self.assertWarnsRegex(RuntimeWarning, 'MyClass'):
+            MyClass = type('MyClass', (), {1: 2})
+
+        class meta(type):
+            def __new__(mcls, name, bases, ns):
+                ns[1] = 2
+                return super().__new__(mcls, name, bases, ns)
+
+        with self.assertWarnsRegex(RuntimeWarning, 'MyClass'):
+            MyClass = meta('MyClass', (), {})
+
     def test_proxy_call(self):
         class FakeStr:
             __class__ = str
@@ -4814,24 +4804,24 @@ class Thing:
         thing = Thing()
         for i in range(20):
             with self.assertRaises(TypeError):
-                # PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS
+                # CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS
                 list.sort(thing)
         for i in range(20):
             with self.assertRaises(TypeError):
-                # PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS
+                # CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS
                 str.split(thing)
         for i in range(20):
             with self.assertRaises(TypeError):
-                # PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS
+                # CALL_METHOD_DESCRIPTOR_NOARGS
                 str.upper(thing)
         for i in range(20):
             with self.assertRaises(TypeError):
-                # PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST
+                # CALL_METHOD_DESCRIPTOR_FAST
                 str.strip(thing)
         from collections import deque
         for i in range(20):
             with self.assertRaises(TypeError):
-                # PRECALL_NO_KW_METHOD_DESCRIPTOR_O
+                # CALL_METHOD_DESCRIPTOR_O
                 deque.append(thing, thing)
 
     def test_repr_as_str(self):
@@ -4865,8 +4855,7 @@ class A(int):
         with self.assertRaises(TypeError):
             a + a
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_slot_shadows_class_variable(self):
         with self.assertRaises(ValueError) as cm:
             class X:
@@ -4875,8 +4864,7 @@ class X:
         m = str(cm.exception)
         self.assertEqual("'foo' in __slots__ conflicts with class variable", m)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_set_doc(self):
         class X:
             "elephant"
@@ -4892,8 +4880,7 @@ class X:
         self.assertIn("cannot delete '__doc__' attribute of immutable type 'X'", str(cm.exception))
         self.assertEqual(X.__doc__, "banana")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_qualname(self):
         descriptors = [str.lower, complex.real, float.real, int.__add__]
         types = ['method', 'member', 'getset', 'wrapper']
@@ -4926,8 +4913,7 @@ class Inside:
         self.assertEqual(Y.__qualname__, 'Y')
         self.assertEqual(Y.Inside.__qualname__, 'Y.Inside')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_qualname_dict(self):
         ns = {'__qualname__': 'some.name'}
         tp = type('Foo', (), ns)
@@ -4938,8 +4924,7 @@ def test_qualname_dict(self):
         ns = {'__qualname__': 1}
         self.assertRaises(TypeError, type, 'Foo', (), ns)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cycle_through_dict(self):
         # See bug #1469629
         class X(dict):
@@ -4955,8 +4940,6 @@ def __init__(self):
         for o in gc.get_objects():
             self.assertIsNot(type(o), X)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_object_new_and_init_with_parameters(self):
         # See issue #1683368
         class OverrideNeither:
@@ -4977,8 +4960,6 @@ class OverrideBoth(OverrideNew, OverrideInit):
             self.assertRaises(TypeError, case, 1, 2, 3)
             self.assertRaises(TypeError, case, 1, 2, foo=3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclassing_does_not_duplicate_dict_descriptors(self):
         class Base:
             pass
@@ -5058,6 +5039,7 @@ 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:
@@ -5075,8 +5057,22 @@ class Child(Parent):
         gc.collect()
         self.assertEqual(Parent.__subclasses__(), [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_instance_method_get_behavior(self):
+        # test case for gh-113157
+
+        class A:
+            def meth(self):
+                return self
+
+        class B:
+            pass
+
+        a = A()
+        b = B()
+        b.meth = a.meth.__get__(b, B)
+        self.assertEqual(b.meth(), a)
+
     def test_attr_raise_through_property(self):
         # test case for gh-103272
         class A:
@@ -5111,8 +5107,7 @@ def meth(self):
                 pass
         self.C = C
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_keys(self):
@@ -5121,11 +5116,12 @@ def test_iter_keys(self):
         self.assertNotIsInstance(it, list)
         keys = list(it)
         keys.sort()
-        self.assertEqual(keys, ['__dict__', '__doc__', '__module__',
-                                '__weakref__', 'meth'])
+        self.assertEqual(keys, ['__dict__', '__doc__', '__firstlineno__',
+                                '__module__',
+                                '__static_attributes__', '__weakref__',
+                                'meth'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 5 != 7
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_values(self):
@@ -5133,10 +5129,9 @@ def test_iter_values(self):
         it = self.C.__dict__.values()
         self.assertNotIsInstance(it, list)
         values = list(it)
-        self.assertEqual(len(values), 5)
+        self.assertEqual(len(values), 7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                         'trace function introduces __local__')
     def test_iter_items(self):
@@ -5145,8 +5140,10 @@ def test_iter_items(self):
         self.assertNotIsInstance(it, list)
         keys = [item[0] for item in it]
         keys.sort()
-        self.assertEqual(keys, ['__dict__', '__doc__', '__module__',
-                                '__weakref__', 'meth'])
+        self.assertEqual(keys, ['__dict__', '__doc__', '__firstlineno__',
+                                '__module__',
+                                '__static_attributes__', '__weakref__',
+                                'meth'])
 
     def test_dict_type_with_metaclass(self):
         # Testing type of __dict__ when metaclass set...
@@ -5196,7 +5193,7 @@ def __pow__(self, *args):
 
 
 class MiscTests(unittest.TestCase):
-    @unittest.skip("TODO: RUSTPYTHON, rustpython panicked at 'dict has non-string keys: [PyObject PyBaseObject]'")
+    @unittest.skip("TODO: RUSTPYTHON; rustpython panicked at 'dict has non-string keys: [PyObject PyBaseObject]'")
     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
@@ -5216,11 +5213,17 @@ class Base2(object):
             mykey = 'from Base2'
             mykey2 = 'from Base2'
 
-        X = type('X', (Base,), {MyKey(): 5})
+        with self.assertWarnsRegex(RuntimeWarning, 'X'):
+            X = type('X', (Base,), {MyKey(): 5})
+
+        # 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.
+
         # mykey is read from Base
-        self.assertEqual(X.mykey, 'from Base')
+        self.assertEqual(getattr(X, 'mykey'), 'from Base')
         # mykey2 is read from Base2 because MyKey.__eq__ has set __bases__
-        self.assertEqual(X.mykey2, 'from Base2')
+        self.assertEqual(getattr(X, 'mykey2'), 'from Base2')
 
 
 class PicklingTests(unittest.TestCase):
@@ -5255,8 +5258,6 @@ def _check_reduce(self, proto, obj, args=(), kwargs={}, state=None,
             self.assertEqual(obj.__reduce_ex__(proto), reduce_value)
             self.assertEqual(obj.__reduce__(), reduce_value)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reduce(self):
         protocols = range(pickle.HIGHEST_PROTOCOL + 1)
         args = (-101, "spam")
@@ -5380,8 +5381,6 @@ class C16(list):
         for proto in protocols:
             self._check_reduce(proto, obj, listitems=list(obj))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_special_method_lookup(self):
         protocols = range(pickle.HIGHEST_PROTOCOL + 1)
         class Picky:
@@ -5514,8 +5513,6 @@ class E(C):
                 y = pickle_copier.copy(x)
                 self._assert_is_copy(x, y)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_reduce_copying(self):
         # Tests pickling and copying new-style classes and objects.
         global C1
@@ -5640,7 +5637,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
@@ -5781,8 +5778,7 @@ class B(A):
         class C(B):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -5819,8 +5815,7 @@ class B2(A):
         with self.assertRaises(TypeError):
             B1.__bases__ += ()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tp_subclasses_cycle_in_update_slots(self):
         """
         type_set_bases must check for reentrancy upon finishing its job
@@ -5857,8 +5852,7 @@ class C(A):
         self.assertEqual(B1.__bases__, (C,))
         self.assertEqual(C.__subclasses__(), [B1])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -5927,8 +5921,7 @@ def mro(cls):
         class A(metaclass=M):
             pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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_dict.py b/Lib/test/test_dict.py
index 4aa6f1089a..9598a7ab96 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -8,7 +8,7 @@
 import unittest
 import weakref
 from test import support
-from test.support import import_helper, C_RECURSION_LIMIT
+from test.support import import_helper, get_c_recursion_limit
 
 
 class DictTest(unittest.TestCase):
@@ -312,17 +312,34 @@ def __setitem__(self, key, value):
         self.assertRaises(Exc, baddict2.fromkeys, [1])
 
         # test fast path for dictionary inputs
+        res = dict(zip(range(6), [0]*6))
         d = dict(zip(range(6), range(6)))
-        self.assertEqual(dict.fromkeys(d, 0), dict(zip(range(6), [0]*6)))
-
+        self.assertEqual(dict.fromkeys(d, 0), res)
+        # test fast path for set inputs
+        d = set(range(6))
+        self.assertEqual(dict.fromkeys(d, 0), res)
+        # test slow path for other iterable inputs
+        d = list(range(6))
+        self.assertEqual(dict.fromkeys(d, 0), res)
+
+        # test fast path when object's constructor returns large non-empty dict
         class baddict3(dict):
             def __new__(cls):
                 return d
-        d = {i : i for i in range(10)}
+        d = {i : i for i in range(1000)}
         res = d.copy()
         res.update(a=None, b=None, c=None)
         self.assertEqual(baddict3.fromkeys({"a", "b", "c"}), res)
 
+        # test slow path when object is a proper subclass of dict
+        class baddict4(dict):
+            def __init__(self):
+                dict.__init__(self, d)
+        d = {i : i for i in range(1000)}
+        res = d.copy()
+        res.update(a=None, b=None, c=None)
+        self.assertEqual(baddict4.fromkeys({"a", "b", "c"}), res)
+
     def test_copy(self):
         d = {1: 1, 2: 2, 3: 3}
         self.assertIsNot(d.copy(), d)
@@ -596,10 +613,9 @@ def __repr__(self):
         d = {1: BadRepr()}
         self.assertRaises(Exc, repr, d)
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
     def test_repr_deep(self):
         d = {}
-        for i in range(C_RECURSION_LIMIT + 1):
+        for i in range(get_c_recursion_limit() + 1):
             d = {1: d}
         self.assertRaises(RecursionError, repr, d)
 
@@ -994,6 +1010,18 @@ 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
@@ -1108,10 +1136,8 @@ class C:
         a = C()
         a.x = 1
         d = a.__dict__
-        before_resize = sys.getsizeof(d)
         d[2] = 2 # split table is resized to a generic combined table
 
-        self.assertGreater(sys.getsizeof(d), before_resize)
         self.assertEqual(list(d), ['x', 2])
 
     def test_iterator_pickling(self):
@@ -1485,6 +1511,24 @@ def test_dict_items_result_gc_reversed(self):
         gc.collect()
         self.assertTrue(gc.is_tracked(next(it)))
 
+    def test_store_evilattr(self):
+        class EvilAttr:
+            def __init__(self, d):
+                self.d = d
+
+            def __del__(self):
+                if 'attr' in self.d:
+                    del self.d['attr']
+                gc.collect()
+
+        class Obj:
+            pass
+
+        obj = Obj()
+        obj.__dict__ = {}
+        for _ in range(10):
+            obj.attr = EvilAttr(obj.__dict__)
+
     def test_str_nonstr(self):
         # cpython uses a different lookup function if the dict only contains
         # `str` keys. Make sure the unoptimized path is used when a non-`str`
@@ -1591,8 +1635,8 @@ class CAPITest(unittest.TestCase):
     # Test _PyDict_GetItem_KnownHash()
     @support.cpython_only
     def test_getitem_knownhash(self):
-        _testcapi = import_helper.import_module('_testcapi')
-        dict_getitem_knownhash = _testcapi.dict_getitem_knownhash
+        _testinternalcapi = import_helper.import_module('_testinternalcapi')
+        dict_getitem_knownhash = _testinternalcapi.dict_getitem_knownhash
 
         d = {'x': 1, 'y': 2, 'z': 3}
         self.assertEqual(dict_getitem_knownhash(d, 'x', hash('x')), 1)
diff --git a/Lib/test/test_dictviews.py b/Lib/test/test_dictviews.py
index 172b98aa68..667cccd6cd 100644
--- a/Lib/test/test_dictviews.py
+++ b/Lib/test/test_dictviews.py
@@ -1,9 +1,8 @@
 import collections.abc
 import copy
 import pickle
-import sys
 import unittest
-from test.support import C_RECURSION_LIMIT
+from test.support import get_c_recursion_limit
 
 class DictSetTest(unittest.TestCase):
 
@@ -282,7 +281,7 @@ def test_recursive_repr(self):
     @unittest.expectedFailure
     def test_deeply_nested_repr(self):
         d = {}
-        for i in range(C_RECURSION_LIMIT//2 + 100):
+        for i in range(get_c_recursion_limit()//2 + 100):
             d = {42: d.values()}
         self.assertRaises(RecursionError, repr, d)
 
diff --git a/Lib/test/test_difflib.py b/Lib/test/test_difflib.py
index 0d669afe61..943d7a659b 100644
--- a/Lib/test/test_difflib.py
+++ b/Lib/test/test_difflib.py
@@ -29,6 +29,16 @@ def test_one_delete(self):
                 ('delete', 40, 41, 40, 40),
                 ('equal', 41, 81, 40, 80)])
 
+    def test_opcode_caching(self):
+        sm = difflib.SequenceMatcher(None, 'b' * 100, 'a' + 'b' * 100)
+        opcode = sm.get_opcodes()
+        self.assertEqual(opcode,
+            [   ('insert', 0, 0, 0, 1),
+                ('equal', 0, 100, 1, 101)])
+        # Implementation detail: opcodes are cached;
+        # `get_opcodes()` returns the same object
+        self.assertIs(opcode, sm.get_opcodes())
+
     def test_bjunk(self):
         sm = difflib.SequenceMatcher(isjunk=lambda x: x == ' ',
                 a='a' * 40 + 'b' * 40, b='a' * 44 + 'b' * 40)
@@ -186,6 +196,7 @@ def test_mdiff_catch_stop_iteration(self):
 the end"""
 
 class TestSFpatches(unittest.TestCase):
+
     def test_html_diff(self):
         # Check SF patch 914575 for generating HTML differences
         f1a = ((patch914575_from1 + '123\n'*10)*3)
@@ -272,6 +283,15 @@ def test_make_file_usascii_charset_with_nonascii_input(self):
         self.assertIn('&#305;mpl&#305;c&#305;t', output)
 
 
+    def test_one_insert(self):
+        m = difflib.Differ().compare('b' * 2, 'a' + 'b' * 2)
+        self.assertEqual(list(m), ['+ a', '  b', '  b'])
+
+    def test_one_delete(self):
+        m = difflib.Differ().compare('a' + 'b' * 2, 'b' * 2)
+        self.assertEqual(list(m), ['- a', '  b', '  b'])
+
+
 class TestOutputFormat(unittest.TestCase):
     def test_tab_delimiter(self):
         args = ['one', 'two', 'Original', 'Current',
@@ -546,6 +566,26 @@ def test_longest_match_with_popular_chars(self):
         self.assertFalse(self.longer_match_exists(a, b, match.size))
 
 
+class TestCloseMatches(unittest.TestCase):
+    # Happy paths are tested in the doctests of `difflib.get_close_matches`.
+
+    def test_invalid_inputs(self):
+        self.assertRaises(ValueError, difflib.get_close_matches, "spam", ['egg'], n=0)
+        self.assertRaises(ValueError, difflib.get_close_matches, "spam", ['egg'], n=-1)
+        self.assertRaises(ValueError, difflib.get_close_matches, "spam", ['egg'], cutoff=1.1)
+        self.assertRaises(ValueError, difflib.get_close_matches, "spam", ['egg'], cutoff=-0.1)
+
+
+class TestRestore(unittest.TestCase):
+    # Happy paths are tested in the doctests of `difflib.restore`.
+
+    def test_invalid_input(self):
+        with self.assertRaises(ValueError):
+            ''.join(difflib.restore([], 0))
+        with self.assertRaises(ValueError):
+            ''.join(difflib.restore([], 3))
+
+
 def setUpModule():
     difflib.HtmlDiff._default_prefix = 0
 
diff --git a/Lib/test/test_difflib_expect.html b/Lib/test/test_difflib_expect.html
index 3e6a7b7a99..12091206a2 100644
--- a/Lib/test/test_difflib_expect.html
+++ b/Lib/test/test_difflib_expect.html
@@ -9,7 +9,7 @@
           content="text/html; charset=utf-8" />
     <title></title>
     <style type="text/css">
-        table.diff {font-family:Courier; border:medium;}
+        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 --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
index 8bbba86a46..a585643cba 100644
--- a/Lib/test/test_dis.py
+++ b/Lib/test/test_dis.py
@@ -1,59 +1,2419 @@
-import subprocess
+# Minimal tests for dis module
+
+import contextlib
+import dis
+import functools
+import io
+import itertools
+import opcode
+import re
 import sys
+import tempfile
+import textwrap
+import types
 import unittest
+from test.support import (captured_stdout, requires_debug_ranges,
+                          requires_specialization, cpython_only,
+                          os_helper)
+from test.support.bytecode_helper import BytecodeTestCase
+
+
+CACHE = dis.opmap["CACHE"]
+
+def get_tb():
+    def _error():
+        try:
+            1 / 0
+        except Exception as e:
+            tb = e.__traceback__
+        return tb
+
+    tb = _error()
+    while tb.tb_next:
+        tb = tb.tb_next
+    return tb
 
-# This only tests that it prints something in order
-# to avoid changing this test if the bytecode changes
+TRACEBACK_CODE = get_tb().tb_frame.f_code
 
-# These tests start a new process instead of redirecting stdout because
-# stdout is being written to by rust code, which currently can't be
-# redirected by reassigning sys.stdout
+class _C:
+    def __init__(self, x):
+        self.x = x == 1
 
+    @staticmethod
+    def sm(x):
+        x = x == 1
 
-class TestDis(unittest.TestCase):
     @classmethod
-    def setUpClass(cls):
-        cls.setup = """
-import dis
-def tested_func(): pass
+    def cm(cls, x):
+        cls.x = x == 1
+
+dis_c_instance_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                1 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              LOAD_FAST                0 (self)
+              STORE_ATTR               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.__init__.__code__.co_firstlineno, _C.__init__.__code__.co_firstlineno + 1,)
+
+dis_c_instance_method_bytes = """\
+          RESUME                   0
+          LOAD_FAST                1
+          LOAD_CONST               1
+          COMPARE_OP              72 (==)
+          LOAD_FAST                0
+          STORE_ATTR               0
+          RETURN_CONST             0
+"""
+
+dis_c_class_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                1 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              LOAD_FAST                0 (cls)
+              STORE_ATTR               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.cm.__code__.co_firstlineno, _C.cm.__code__.co_firstlineno + 2,)
+
+dis_c_static_method = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                0 (x)
+              LOAD_CONST               1 (1)
+              COMPARE_OP              72 (==)
+              STORE_FAST               0 (x)
+              RETURN_CONST             0 (None)
+""" % (_C.sm.__code__.co_firstlineno, _C.sm.__code__.co_firstlineno + 2,)
+
+# Class disassembling info has an extra newline at end.
+dis_c = """\
+Disassembly of %s:
+%s
+Disassembly of %s:
+%s
+Disassembly of %s:
+%s
+""" % (_C.__init__.__name__, dis_c_instance_method,
+       _C.cm.__name__, dis_c_class_method,
+       _C.sm.__name__, dis_c_static_method)
+
+def _f(a):
+    print(a)
+    return 1
+
+dis_f = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (print + NULL)
+              LOAD_FAST                0 (a)
+              CALL                     1
+              POP_TOP
+
+%3d           RETURN_CONST             1 (1)
+""" % (_f.__code__.co_firstlineno,
+       _f.__code__.co_firstlineno + 1,
+       _f.__code__.co_firstlineno + 2)
+
+dis_f_with_offsets = """\
+%3d          0       RESUME                   0
+
+%3d          2       LOAD_GLOBAL              1 (print + NULL)
+            12       LOAD_FAST                0 (a)
+            14       CALL                     1
+            22       POP_TOP
+
+%3d         24       RETURN_CONST             1 (1)
+""" % (_f.__code__.co_firstlineno,
+       _f.__code__.co_firstlineno + 1,
+       _f.__code__.co_firstlineno + 2)
+
+
+dis_f_co_code = """\
+          RESUME                   0
+          LOAD_GLOBAL              1
+          LOAD_FAST                0
+          CALL                     1
+          POP_TOP
+          RETURN_CONST             1
+"""
+
+def bug708901():
+    for res in range(1,
+                     10):
+        pass
+
+dis_bug708901 = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (range + NULL)
+              LOAD_CONST               1 (1)
+
+%3d           LOAD_CONST               2 (10)
+
+%3d           CALL                     2
+              GET_ITER
+      L1:     FOR_ITER                 3 (to L2)
+              STORE_FAST               0 (res)
+
+%3d           JUMP_BACKWARD            5 (to L1)
+
+%3d   L2:     END_FOR
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (bug708901.__code__.co_firstlineno,
+       bug708901.__code__.co_firstlineno + 1,
+       bug708901.__code__.co_firstlineno + 2,
+       bug708901.__code__.co_firstlineno + 1,
+       bug708901.__code__.co_firstlineno + 3,
+       bug708901.__code__.co_firstlineno + 1)
+
+
+def bug1333982(x=[]):
+    assert 0, ((s for s in x) +
+              1)
+    pass
+
+dis_bug1333982 = """\
+%3d           RESUME                   0
+
+%3d           LOAD_ASSERTION_ERROR
+              LOAD_CONST               1 (<code object <genexpr> at 0x..., file "%s", line %d>)
+              MAKE_FUNCTION
+              LOAD_FAST                0 (x)
+              GET_ITER
+              CALL                     0
+
+%3d           LOAD_CONST               2 (1)
+
+%3d           BINARY_OP                0 (+)
+              CALL                     0
+              RAISE_VARARGS            1
+""" % (bug1333982.__code__.co_firstlineno,
+       bug1333982.__code__.co_firstlineno + 1,
+       __file__,
+       bug1333982.__code__.co_firstlineno + 1,
+       bug1333982.__code__.co_firstlineno + 2,
+       bug1333982.__code__.co_firstlineno + 1)
+
+
+def bug42562():
+    pass
+
+
+# Set line number for 'pass' to None
+bug42562.__code__ = bug42562.__code__.replace(co_linetable=b'\xf8')
+
+
+dis_bug42562 = """\
+          RESUME                   0
+          RETURN_CONST             0 (None)
+"""
+
+# Extended arg followed by NOP
+code_bug_45757 = bytes([
+        opcode.opmap['EXTENDED_ARG'], 0x01,  # EXTENDED_ARG 0x01
+        opcode.opmap['NOP'],          0xFF,  # NOP 0xFF
+        opcode.opmap['EXTENDED_ARG'], 0x01,  # EXTENDED_ARG 0x01
+        opcode.opmap['LOAD_CONST'],   0x29,  # LOAD_CONST 0x29
+        opcode.opmap['RETURN_VALUE'], 0x00,  # RETURN_VALUE 0x00
+    ])
+
+dis_bug_45757 = """\
+          EXTENDED_ARG             1
+          NOP
+          EXTENDED_ARG             1
+          LOAD_CONST             297
+          RETURN_VALUE
 """
-        cls.command = (sys.executable, "-c")
 
+# [255, 255, 255, 252] is -4 in a 4 byte signed integer
+bug46724 = bytes([
+    opcode.EXTENDED_ARG, 255,
+    opcode.EXTENDED_ARG, 255,
+    opcode.EXTENDED_ARG, 255,
+    opcode.opmap['JUMP_FORWARD'], 252,
+])
+
+
+dis_bug46724 = """\
+  L1:     EXTENDED_ARG           255
+          EXTENDED_ARG         65535
+          EXTENDED_ARG         16777215
+          JUMP_FORWARD            -4 (to L1)
+"""
+
+def func_w_kwargs(a, b, **c):
+    pass
+
+def wrap_func_w_kwargs():
+    func_w_kwargs(1, 2, c=5)
+
+dis_kw_names = """\
+%3d           RESUME                   0
+
+%3d           LOAD_GLOBAL              1 (func_w_kwargs + NULL)
+              LOAD_CONST               1 (1)
+              LOAD_CONST               2 (2)
+              LOAD_CONST               3 (5)
+              LOAD_CONST               4 (('c',))
+              CALL_KW                  3
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (wrap_func_w_kwargs.__code__.co_firstlineno,
+       wrap_func_w_kwargs.__code__.co_firstlineno + 1)
+
+dis_intrinsic_1_2 = """\
+  0           RESUME                   0
+
+  1           LOAD_CONST               0 (0)
+              LOAD_CONST               1 (('*',))
+              IMPORT_NAME              0 (math)
+              CALL_INTRINSIC_1         2 (INTRINSIC_IMPORT_STAR)
+              POP_TOP
+              RETURN_CONST             2 (None)
+"""
+
+dis_intrinsic_1_5 = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (a)
+              CALL_INTRINSIC_1         5 (INTRINSIC_UNARY_POSITIVE)
+              RETURN_VALUE
+"""
+
+dis_intrinsic_1_6 = """\
+  0           RESUME                   0
+
+  1           BUILD_LIST               0
+              LOAD_NAME                0 (a)
+              LIST_EXTEND              1
+              CALL_INTRINSIC_1         6 (INTRINSIC_LIST_TO_TUPLE)
+              RETURN_VALUE
+"""
+
+_BIG_LINENO_FORMAT = """\
+  1           RESUME                   0
+
+%3d           LOAD_GLOBAL              0 (spam)
+              POP_TOP
+              RETURN_CONST             0 (None)
+"""
+
+_BIG_LINENO_FORMAT2 = """\
+   1           RESUME                   0
+
+%4d           LOAD_GLOBAL              0 (spam)
+               POP_TOP
+               RETURN_CONST             0 (None)
+"""
+
+dis_module_expected_results = """\
+Disassembly of f:
+  4           RESUME                   0
+              RETURN_CONST             0 (None)
+
+Disassembly of g:
+  5           RESUME                   0
+              RETURN_CONST             0 (None)
+
+"""
+
+expr_str = "x + 1"
+
+dis_expr_str = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (x)
+              LOAD_CONST               0 (1)
+              BINARY_OP                0 (+)
+              RETURN_VALUE
+"""
+
+simple_stmt_str = "x = x + 1"
+
+dis_simple_stmt_str = """\
+  0           RESUME                   0
+
+  1           LOAD_NAME                0 (x)
+              LOAD_CONST               0 (1)
+              BINARY_OP                0 (+)
+              STORE_NAME               0 (x)
+              RETURN_CONST             1 (None)
+"""
+
+annot_stmt_str = """\
+
+x: int = 1
+y: fun(1)
+lst[fun(0)]: int = 1
+"""
+# leading newline is for a reason (tests lineno)
+
+dis_annot_stmt_str = """\
+  0           RESUME                   0
+
+  2           SETUP_ANNOTATIONS
+              LOAD_CONST               0 (1)
+              STORE_NAME               0 (x)
+              LOAD_NAME                1 (int)
+              LOAD_NAME                2 (__annotations__)
+              LOAD_CONST               1 ('x')
+              STORE_SUBSCR
+
+  3           LOAD_NAME                3 (fun)
+              PUSH_NULL
+              LOAD_CONST               0 (1)
+              CALL                     1
+              LOAD_NAME                2 (__annotations__)
+              LOAD_CONST               2 ('y')
+              STORE_SUBSCR
+
+  4           LOAD_CONST               0 (1)
+              LOAD_NAME                4 (lst)
+              LOAD_NAME                3 (fun)
+              PUSH_NULL
+              LOAD_CONST               3 (0)
+              CALL                     1
+              STORE_SUBSCR
+              LOAD_NAME                1 (int)
+              POP_TOP
+              RETURN_CONST             4 (None)
+"""
+
+compound_stmt_str = """\
+x = 0
+while 1:
+    x += 1"""
+# Trailing newline has been deliberately omitted
+
+dis_compound_stmt_str = """\
+  0           RESUME                   0
+
+  1           LOAD_CONST               0 (0)
+              STORE_NAME               0 (x)
+
+  2           NOP
+
+  3   L1:     LOAD_NAME                0 (x)
+              LOAD_CONST               1 (1)
+              BINARY_OP               13 (+=)
+              STORE_NAME               0 (x)
+
+  2           JUMP_BACKWARD            7 (to L1)
+"""
+
+dis_traceback = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d   L1:     LOAD_CONST               1 (1)
+               LOAD_CONST               2 (0)
+           --> BINARY_OP               11 (/)
+               POP_TOP
+
+%4d   L2:     LOAD_FAST_CHECK          1 (tb)
+               RETURN_VALUE
+
+  --   L3:     PUSH_EXC_INFO
+
+%4d           LOAD_GLOBAL              0 (Exception)
+               CHECK_EXC_MATCH
+               POP_JUMP_IF_FALSE       23 (to L7)
+               STORE_FAST               0 (e)
+
+%4d   L4:     LOAD_FAST                0 (e)
+               LOAD_ATTR                2 (__traceback__)
+               STORE_FAST               1 (tb)
+       L5:     POP_EXCEPT
+               LOAD_CONST               0 (None)
+               STORE_FAST               0 (e)
+               DELETE_FAST              0 (e)
+
+%4d           LOAD_FAST                1 (tb)
+               RETURN_VALUE
+
+  --   L6:     LOAD_CONST               0 (None)
+               STORE_FAST               0 (e)
+               DELETE_FAST              0 (e)
+               RERAISE                  1
+
+%4d   L7:     RERAISE                  0
+
+  --   L8:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [0]
+  L3 to L4 -> L8 [1] lasti
+  L4 to L5 -> L6 [1] lasti
+  L6 to L8 -> L8 [1] lasti
+""" % (TRACEBACK_CODE.co_firstlineno,
+       TRACEBACK_CODE.co_firstlineno + 1,
+       TRACEBACK_CODE.co_firstlineno + 2,
+       TRACEBACK_CODE.co_firstlineno + 5,
+       TRACEBACK_CODE.co_firstlineno + 3,
+       TRACEBACK_CODE.co_firstlineno + 4,
+       TRACEBACK_CODE.co_firstlineno + 5,
+       TRACEBACK_CODE.co_firstlineno + 3)
+
+def _fstring(a, b, c, d):
+    return f'{a} {b:4} {c!r} {d!r:4}'
+
+dis_fstring = """\
+%3d           RESUME                   0
+
+%3d           LOAD_FAST                0 (a)
+              FORMAT_SIMPLE
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                1 (b)
+              LOAD_CONST               2 ('4')
+              FORMAT_WITH_SPEC
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                2 (c)
+              CONVERT_VALUE            2 (repr)
+              FORMAT_SIMPLE
+              LOAD_CONST               1 (' ')
+              LOAD_FAST                3 (d)
+              CONVERT_VALUE            2 (repr)
+              LOAD_CONST               2 ('4')
+              FORMAT_WITH_SPEC
+              BUILD_STRING             7
+              RETURN_VALUE
+""" % (_fstring.__code__.co_firstlineno, _fstring.__code__.co_firstlineno + 1)
+
+def _with(c):
+    with c:
+        x = 1
+    y = 2
+
+dis_with = """\
+%4d           RESUME                   0
+
+%4d           LOAD_FAST                0 (c)
+               BEFORE_WITH
+       L1:     POP_TOP
+
+%4d           LOAD_CONST               1 (1)
+               STORE_FAST               1 (x)
+
+%4d   L2:     LOAD_CONST               0 (None)
+               LOAD_CONST               0 (None)
+               LOAD_CONST               0 (None)
+               CALL                     2
+               POP_TOP
+
+%4d           LOAD_CONST               2 (2)
+               STORE_FAST               2 (y)
+               RETURN_CONST             0 (None)
+
+%4d   L3:     PUSH_EXC_INFO
+               WITH_EXCEPT_START
+               TO_BOOL
+               POP_JUMP_IF_TRUE         1 (to L4)
+               RERAISE                  2
+       L4:     POP_TOP
+       L5:     POP_EXCEPT
+               POP_TOP
+               POP_TOP
+
+%4d           LOAD_CONST               2 (2)
+               STORE_FAST               2 (y)
+               RETURN_CONST             0 (None)
+
+  --   L6:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [1] lasti
+  L3 to L5 -> L6 [3] lasti
+""" % (_with.__code__.co_firstlineno,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 2,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 3,
+       _with.__code__.co_firstlineno + 1,
+       _with.__code__.co_firstlineno + 3,
+       )
+
+async def _asyncwith(c):
+    async with c:
+        x = 1
+    y = 2
+
+dis_asyncwith = """\
+%4d            RETURN_GENERATOR
+                POP_TOP
+        L1:     RESUME                   0
+
+%4d            LOAD_FAST                0 (c)
+                BEFORE_ASYNC_WITH
+                GET_AWAITABLE            1
+                LOAD_CONST               0 (None)
+        L2:     SEND                     3 (to L5)
+        L3:     YIELD_VALUE              1
+        L4:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L2)
+        L5:     END_SEND
+        L6:     POP_TOP
+
+%4d            LOAD_CONST               1 (1)
+                STORE_FAST               1 (x)
+
+%4d    L7:     LOAD_CONST               0 (None)
+                LOAD_CONST               0 (None)
+                LOAD_CONST               0 (None)
+                CALL                     2
+                GET_AWAITABLE            2
+                LOAD_CONST               0 (None)
+        L8:     SEND                     3 (to L11)
+        L9:     YIELD_VALUE              1
+       L10:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L8)
+       L11:     END_SEND
+                POP_TOP
+
+%4d            LOAD_CONST               2 (2)
+                STORE_FAST               2 (y)
+                RETURN_CONST             0 (None)
+
+%4d   L12:     CLEANUP_THROW
+       L13:     JUMP_BACKWARD_NO_INTERRUPT 25 (to L5)
+       L14:     CLEANUP_THROW
+       L15:     JUMP_BACKWARD_NO_INTERRUPT 9 (to L11)
+       L16:     PUSH_EXC_INFO
+                WITH_EXCEPT_START
+                GET_AWAITABLE            2
+                LOAD_CONST               0 (None)
+       L17:     SEND                     4 (to L21)
+       L18:     YIELD_VALUE              1
+       L19:     RESUME                   3
+                JUMP_BACKWARD_NO_INTERRUPT 5 (to L17)
+       L20:     CLEANUP_THROW
+       L21:     END_SEND
+                TO_BOOL
+                POP_JUMP_IF_TRUE         1 (to L22)
+                RERAISE                  2
+       L22:     POP_TOP
+       L23:     POP_EXCEPT
+                POP_TOP
+                POP_TOP
+
+%4d            LOAD_CONST               2 (2)
+                STORE_FAST               2 (y)
+                RETURN_CONST             0 (None)
+
+  --   L24:     COPY                     3
+                POP_EXCEPT
+                RERAISE                  1
+       L25:     CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
+                RERAISE                  1
+ExceptionTable:
+  L1 to L3 -> L25 [0] lasti
+  L3 to L4 -> L12 [3]
+  L4 to L6 -> L25 [0] lasti
+  L6 to L7 -> L16 [1] lasti
+  L7 to L9 -> L25 [0] lasti
+  L9 to L10 -> L14 [2]
+  L10 to L13 -> L25 [0] lasti
+  L14 to L15 -> L25 [0] lasti
+  L16 to L18 -> L24 [3] lasti
+  L18 to L19 -> L20 [6]
+  L19 to L23 -> L24 [3] lasti
+  L23 to L25 -> L25 [0] lasti
+""" % (_asyncwith.__code__.co_firstlineno,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 2,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 3,
+       _asyncwith.__code__.co_firstlineno + 1,
+       _asyncwith.__code__.co_firstlineno + 3,
+       )
+
+
+def _tryfinally(a, b):
+    try:
+        return a
+    finally:
+        b()
+
+def _tryfinallyconst(b):
+    try:
+        return 1
+    finally:
+        b()
+
+dis_tryfinally = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d   L1:     LOAD_FAST                0 (a)
+
+%4d   L2:     LOAD_FAST                1 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RETURN_VALUE
+
+  --   L3:     PUSH_EXC_INFO
+
+%4d           LOAD_FAST                1 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RERAISE                  0
+
+  --   L4:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L3 [0]
+  L3 to L4 -> L4 [1] lasti
+""" % (_tryfinally.__code__.co_firstlineno,
+       _tryfinally.__code__.co_firstlineno + 1,
+       _tryfinally.__code__.co_firstlineno + 2,
+       _tryfinally.__code__.co_firstlineno + 4,
+       _tryfinally.__code__.co_firstlineno + 4,
+       )
+
+dis_tryfinallyconst = """\
+%4d           RESUME                   0
+
+%4d           NOP
+
+%4d           NOP
+
+%4d           LOAD_FAST                0 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RETURN_CONST             1 (1)
+
+  --   L1:     PUSH_EXC_INFO
+
+%4d           LOAD_FAST                0 (b)
+               PUSH_NULL
+               CALL                     0
+               POP_TOP
+               RERAISE                  0
+
+  --   L2:     COPY                     3
+               POP_EXCEPT
+               RERAISE                  1
+ExceptionTable:
+  L1 to L2 -> L2 [1] lasti
+""" % (_tryfinallyconst.__code__.co_firstlineno,
+       _tryfinallyconst.__code__.co_firstlineno + 1,
+       _tryfinallyconst.__code__.co_firstlineno + 2,
+       _tryfinallyconst.__code__.co_firstlineno + 4,
+       _tryfinallyconst.__code__.co_firstlineno + 4,
+       )
+
+def _g(x):
+    yield x
+
+async def _ag(x):
+    yield x
+
+async def _co(x):
+    async for item in _ag(x):
+        pass
+
+def _h(y):
+    def foo(x):
+        '''funcdoc'''
+        return list(x + z for z in y)
+    return foo
+
+dis_nested_0 = """\
+  --           MAKE_CELL                0 (y)
+
+%4d           RESUME                   0
+
+%4d           LOAD_FAST                0 (y)
+               BUILD_TUPLE              1
+               LOAD_CONST               1 (<code object foo at 0x..., file "%s", line %d>)
+               MAKE_FUNCTION
+               SET_FUNCTION_ATTRIBUTE   8 (closure)
+               STORE_FAST               1 (foo)
+
+%4d           LOAD_FAST                1 (foo)
+               RETURN_VALUE
+""" % (_h.__code__.co_firstlineno,
+       _h.__code__.co_firstlineno + 1,
+       __file__,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 4,
+)
+
+dis_nested_1 = """%s
+Disassembly of <code object foo at 0x..., file "%s", line %d>:
+  --           COPY_FREE_VARS           1
+               MAKE_CELL                0 (x)
+
+%4d           RESUME                   0
+
+%4d           LOAD_GLOBAL              1 (list + NULL)
+               LOAD_FAST                0 (x)
+               BUILD_TUPLE              1
+               LOAD_CONST               1 (<code object <genexpr> at 0x..., file "%s", line %d>)
+               MAKE_FUNCTION
+               SET_FUNCTION_ATTRIBUTE   8 (closure)
+               LOAD_DEREF               1 (y)
+               GET_ITER
+               CALL                     0
+               CALL                     1
+               RETURN_VALUE
+""" % (dis_nested_0,
+       __file__,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 1,
+       _h.__code__.co_firstlineno + 3,
+       __file__,
+       _h.__code__.co_firstlineno + 3,
+)
+
+dis_nested_2 = """%s
+Disassembly of <code object <genexpr> at 0x..., file "%s", line %d>:
+  --           COPY_FREE_VARS           1
+
+%4d           RETURN_GENERATOR
+               POP_TOP
+       L1:     RESUME                   0
+               LOAD_FAST                0 (.0)
+               GET_ITER
+       L2:     FOR_ITER                10 (to L3)
+               STORE_FAST               1 (z)
+               LOAD_DEREF               2 (x)
+               LOAD_FAST                1 (z)
+               BINARY_OP                0 (+)
+               YIELD_VALUE              0
+               RESUME                   5
+               POP_TOP
+               JUMP_BACKWARD           12 (to L2)
+       L3:     END_FOR
+               POP_TOP
+               RETURN_CONST             0 (None)
+
+  --   L4:     CALL_INTRINSIC_1         3 (INTRINSIC_STOPITERATION_ERROR)
+               RERAISE                  1
+ExceptionTable:
+  L1 to L4 -> L4 [0] lasti
+""" % (dis_nested_1,
+       __file__,
+       _h.__code__.co_firstlineno + 3,
+       _h.__code__.co_firstlineno + 3,
+)
+
+def load_test(x, y=0):
+    a, b = x, y
+    return a, b
+
+dis_load_test_quickened_code = """\
+%3d           RESUME_CHECK             0
+
+%3d           LOAD_FAST_LOAD_FAST      1 (x, y)
+              STORE_FAST_STORE_FAST   50 (b, a)
+
+%3d           LOAD_FAST_LOAD_FAST     35 (a, b)
+              BUILD_TUPLE              2
+              RETURN_VALUE
+""" % (load_test.__code__.co_firstlineno,
+       load_test.__code__.co_firstlineno + 1,
+       load_test.__code__.co_firstlineno + 2)
+
+def loop_test():
+    for i in [1, 2, 3] * 3:
+        load_test(i)
+
+dis_loop_test_quickened_code = """\
+%3d           RESUME_CHECK             0
+
+%3d           BUILD_LIST               0
+              LOAD_CONST               1 ((1, 2, 3))
+              LIST_EXTEND              1
+              LOAD_CONST               2 (3)
+              BINARY_OP                5 (*)
+              GET_ITER
+      L1:     FOR_ITER_LIST           14 (to L2)
+              STORE_FAST               0 (i)
+
+%3d           LOAD_GLOBAL_MODULE       1 (load_test + NULL)
+              LOAD_FAST                0 (i)
+              CALL_PY_GENERAL          1
+              POP_TOP
+              JUMP_BACKWARD           16 (to L1)
+
+%3d   L2:     END_FOR
+              POP_TOP
+              RETURN_CONST             0 (None)
+""" % (loop_test.__code__.co_firstlineno,
+       loop_test.__code__.co_firstlineno + 1,
+       loop_test.__code__.co_firstlineno + 2,
+       loop_test.__code__.co_firstlineno + 1,)
+
+def extended_arg_quick():
+    *_, _ = ...
+
+dis_extended_arg_quick_code = """\
+%3d           RESUME                   0
+
+%3d           LOAD_CONST               1 (Ellipsis)
+              EXTENDED_ARG             1
+              UNPACK_EX              256
+              POP_TOP
+              STORE_FAST               0 (_)
+              RETURN_CONST             0 (None)
+"""% (extended_arg_quick.__code__.co_firstlineno,
+      extended_arg_quick.__code__.co_firstlineno + 1,)
+
+ADAPTIVE_WARMUP_DELAY = 2
+
+class DisTestBase(unittest.TestCase):
+    "Common utilities for DisTests and TestDisTraceback"
+
+    def strip_addresses(self, text):
+        return re.sub(r'\b0x[0-9A-Fa-f]+\b', '0x...', text)
+
+    def assert_exception_table_increasing(self, lines):
+        prev_start, prev_end = -1, -1
+        count = 0
+        for line in lines:
+            m = re.match(r'  L(\d+) to L(\d+) -> L\d+ \[\d+\]', line)
+            start, end = [int(g) for g in m.groups()]
+            self.assertGreaterEqual(end, start)
+            self.assertGreaterEqual(start, prev_end)
+            prev_start, prev_end = start, end
+            count += 1
+        return count
+
+    def do_disassembly_compare(self, got, expected):
+        if got != expected:
+            got = self.strip_addresses(got)
+        self.assertEqual(got, expected)
+
+
+class DisTests(DisTestBase):
+
+    maxDiff = None
+
+    def get_disassembly(self, func, lasti=-1, wrapper=True, **kwargs):
+        # We want to test the default printing behaviour, not the file arg
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            if wrapper:
+                dis.dis(func, **kwargs)
+            else:
+                dis.disassemble(func, lasti, **kwargs)
+        return output.getvalue()
+
+    def get_disassemble_as_string(self, func, lasti=-1):
+        return self.get_disassembly(func, lasti, False)
+
+    def do_disassembly_test(self, func, expected, **kwargs):
+        self.maxDiff = None
+        got = self.get_disassembly(func, depth=0, **kwargs)
+        self.do_disassembly_compare(got, expected)
+        # Add checks for dis.disco
+        if hasattr(func, '__code__'):
+            got_disco = io.StringIO()
+            with contextlib.redirect_stdout(got_disco):
+                dis.disco(func.__code__, **kwargs)
+            self.do_disassembly_compare(got_disco.getvalue(), expected)
+
+    def test_opmap(self):
+        self.assertEqual(dis.opmap["CACHE"], 0)
+        self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
+        self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
+
+    def test_opname(self):
+        self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
+
+    def test_boundaries(self):
+        self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 29 not less than or equal to 20
+    def test_widths(self):
+        long_opcodes = set(['JUMP_BACKWARD_NO_INTERRUPT',
+                            'INSTRUMENTED_CALL_FUNCTION_EX'])
+        for opcode, opname in enumerate(dis.opname):
+            if opname in long_opcodes or opname.startswith("INSTRUMENTED"):
+                continue
+            with self.subTest(opname=opname):
+                width = dis._OPNAME_WIDTH
+                if opcode in dis.hasarg:
+                    width += 1 + dis._OPARG_WIDTH
+                self.assertLessEqual(len(opname), width)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dis(self):
-        test_code = f"""
-{self.setup}
-dis.dis(tested_func)
-dis.dis("x = 2; print(x)")
-"""
-
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        self.assertNotEqual("", result.stdout.decode())
-        self.assertEqual("", result.stderr.decode())
-
-    def test_disassemble(self):
-        test_code = f"""
-{self.setup}
-dis.disassemble(tested_func)
-"""
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        # In CPython this would raise an AttributeError, not a
-        # TypeError because dis is implemented in python in CPython and
-        # as such the type mismatch wouldn't be caught immeadiately
-        self.assertIn("TypeError", result.stderr.decode())
-
-        test_code = f"""
-{self.setup}
-dis.disassemble(tested_func.__code__)
-"""
-        result = subprocess.run(
-            self.command + (test_code,), capture_output=True
-        )
-        self.assertNotEqual("", result.stdout.decode())
-        self.assertEqual("", result.stderr.decode())
+        self.do_disassembly_test(_f, dis_f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_dis_with_offsets(self):
+        self.do_disassembly_test(_f, dis_f_with_offsets, show_offsets=True)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_708901(self):
+        self.do_disassembly_test(bug708901, dis_bug708901)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_1333982(self):
+        # This one is checking bytecodes generated for an `assert` statement,
+        # so fails if the tests are run with -O.  Skip this test then.
+        if not __debug__:
+            self.skipTest('need asserts, run without -O')
+
+        self.do_disassembly_test(bug1333982, dis_bug1333982)
+
+    def test_bug_42562(self):
+        self.do_disassembly_test(bug42562, dis_bug42562)
+
+    def test_bug_45757(self):
+        # Extended arg followed by NOP
+        self.do_disassembly_test(code_bug_45757, dis_bug_45757)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_bug_46724(self):
+        # Test that negative operargs are handled properly
+        self.do_disassembly_test(bug46724, dis_bug46724)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_kw_names(self):
+        # Test that value is displayed for keyword argument names:
+        self.do_disassembly_test(wrap_func_w_kwargs, dis_kw_names)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_intrinsic_1(self):
+        # Test that argrepr is displayed for CALL_INTRINSIC_1
+        self.do_disassembly_test("from math import *", dis_intrinsic_1_2)
+        self.do_disassembly_test("+a", dis_intrinsic_1_5)
+        self.do_disassembly_test("(*a,)", dis_intrinsic_1_6)
+
+    def test_intrinsic_2(self):
+        self.assertIn("CALL_INTRINSIC_2         1 (INTRINSIC_PREP_RERAISE_STAR)",
+                      self.get_disassembly("try: pass\nexcept* Exception: x"))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_big_linenos(self):
+        def func(count):
+            namespace = {}
+            func = "def foo():\n " + "".join(["\n "] * count + ["spam\n"])
+            exec(func, namespace)
+            return namespace['foo']
+
+        # Test all small ranges
+        for i in range(1, 300):
+            expected = _BIG_LINENO_FORMAT % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        # Test some larger ranges too
+        for i in range(300, 1000, 10):
+            expected = _BIG_LINENO_FORMAT % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        for i in range(1000, 5000, 10):
+            expected = _BIG_LINENO_FORMAT2 % (i + 2)
+            self.do_disassembly_test(func(i), expected)
+
+        from test import dis_module
+        self.do_disassembly_test(dis_module, dis_module_expected_results)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_str(self):
+        self.do_disassembly_test(expr_str, dis_expr_str)
+        self.do_disassembly_test(simple_stmt_str, dis_simple_stmt_str)
+        self.do_disassembly_test(annot_stmt_str, dis_annot_stmt_str)
+        self.do_disassembly_test(compound_stmt_str, dis_compound_stmt_str)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_bytes(self):
+        self.do_disassembly_test(_f.__code__.co_code, dis_f_co_code)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_class(self):
+        self.do_disassembly_test(_C, dis_c)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_instance_method(self):
+        self.do_disassembly_test(_C(1).__init__, dis_c_instance_method)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_instance_method_bytes(self):
+        method_bytecode = _C(1).__init__.__code__.co_code
+        self.do_disassembly_test(method_bytecode, dis_c_instance_method_bytes)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_static_method(self):
+        self.do_disassembly_test(_C.sm, dis_c_static_method)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_class_method(self):
+        self.do_disassembly_test(_C.cm, dis_c_class_method)
+
+    def test_disassemble_generator(self):
+        gen_func_disas = self.get_disassembly(_g)  # Generator function
+        gen_disas = self.get_disassembly(_g(1))  # Generator iterator
+        self.assertEqual(gen_disas, gen_func_disas)
+
+    def test_disassemble_async_generator(self):
+        agen_func_disas = self.get_disassembly(_ag)  # Async generator function
+        agen_disas = self.get_disassembly(_ag(1))  # Async generator iterator
+        self.assertEqual(agen_disas, agen_func_disas)
+
+    def test_disassemble_coroutine(self):
+        coro_func_disas = self.get_disassembly(_co)  # Coroutine function
+        coro = _co(1)  # Coroutine object
+        coro.close()  # Avoid a RuntimeWarning (never awaited)
+        coro_disas = self.get_disassembly(coro)
+        self.assertEqual(coro_disas, coro_func_disas)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_fstring(self):
+        self.do_disassembly_test(_fstring, dis_fstring)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_with(self):
+        self.do_disassembly_test(_with, dis_with)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_asyncwith(self):
+        self.do_disassembly_test(_asyncwith, dis_asyncwith)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_try_finally(self):
+        self.do_disassembly_test(_tryfinally, dis_tryfinally)
+        self.do_disassembly_test(_tryfinallyconst, dis_tryfinallyconst)
+
+    def test_dis_none(self):
+        try:
+            del sys.last_exc
+        except AttributeError:
+            pass
+        try:
+            del sys.last_traceback
+        except AttributeError:
+            pass
+        self.assertRaises(RuntimeError, dis.dis, None)
+
+    def test_dis_traceback(self):
+        self.maxDiff = None
+        try:
+            del sys.last_traceback
+        except AttributeError:
+            pass
+
+        try:
+            1/0
+        except Exception as e:
+            tb = e.__traceback__
+            sys.last_exc = e
+
+        tb_dis = self.get_disassemble_as_string(tb.tb_frame.f_code, tb.tb_lasti)
+        self.do_disassembly_test(None, tb_dis)
+
+    def test_dis_object(self):
+        self.assertRaises(TypeError, dis.dis, object())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassemble_recursive(self):
+        def check(expected, **kwargs):
+            dis = self.get_disassembly(_h, **kwargs)
+            dis = self.strip_addresses(dis)
+            self.assertEqual(dis, expected)
+
+        check(dis_nested_0, depth=0)
+        check(dis_nested_1, depth=1)
+        check(dis_nested_2, depth=2)
+        check(dis_nested_2, depth=3)
+        check(dis_nested_2, depth=None)
+        check(dis_nested_2)
+
+    def test__try_compile_no_context_exc_on_error(self):
+        # see gh-102114
+        try:
+            dis._try_compile(")", "")
+        except Exception as e:
+            self.assertIsNone(e.__context__)
+
+    @staticmethod
+    def code_quicken(f, times=ADAPTIVE_WARMUP_DELAY):
+        for _ in range(times):
+            f()
+
+    @cpython_only
+    @requires_specialization
+    def test_super_instructions(self):
+        self.code_quicken(lambda: load_test(0, 0))
+        got = self.get_disassembly(load_test, adaptive=True)
+        self.do_disassembly_compare(got, dis_load_test_quickened_code)
+
+    @cpython_only
+    @requires_specialization
+    def test_binary_specialize(self):
+        binary_op_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (a)
+              LOAD_NAME                1 (b)
+              %s
+              RETURN_VALUE
+"""
+        co_int = compile('a + b', "<int>", "eval")
+        self.code_quicken(lambda: exec(co_int, {}, {'a': 1, 'b': 2}))
+        got = self.get_disassembly(co_int, adaptive=True)
+        self.do_disassembly_compare(got, binary_op_quicken % "BINARY_OP_ADD_INT        0 (+)")
+
+        co_unicode = compile('a + b', "<unicode>", "eval")
+        self.code_quicken(lambda: exec(co_unicode, {}, {'a': 'a', 'b': 'b'}))
+        got = self.get_disassembly(co_unicode, adaptive=True)
+        self.do_disassembly_compare(got, binary_op_quicken % "BINARY_OP_ADD_UNICODE    0 (+)")
+
+        binary_subscr_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (a)
+              LOAD_CONST               0 (0)
+              %s
+              RETURN_VALUE
+"""
+        co_list = compile('a[0]', "<list>", "eval")
+        self.code_quicken(lambda: exec(co_list, {}, {'a': [0]}))
+        got = self.get_disassembly(co_list, adaptive=True)
+        self.do_disassembly_compare(got, binary_subscr_quicken % "BINARY_SUBSCR_LIST_INT")
+
+        co_dict = compile('a[0]', "<dict>", "eval")
+        self.code_quicken(lambda: exec(co_dict, {}, {'a': {0: '1'}}))
+        got = self.get_disassembly(co_dict, adaptive=True)
+        self.do_disassembly_compare(got, binary_subscr_quicken % "BINARY_SUBSCR_DICT")
+
+    @cpython_only
+    @requires_specialization
+    def test_load_attr_specialize(self):
+        load_attr_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_CONST               0 ('a')
+              LOAD_ATTR_SLOT           0 (__class__)
+              RETURN_VALUE
+"""
+        co = compile("'a'.__class__", "", "eval")
+        self.code_quicken(lambda: exec(co, {}, {}))
+        got = self.get_disassembly(co, adaptive=True)
+        self.do_disassembly_compare(got, load_attr_quicken)
+
+    @cpython_only
+    @requires_specialization
+    def test_call_specialize(self):
+        call_quicken = """\
+  0           RESUME_CHECK             0
+
+  1           LOAD_NAME                0 (str)
+              PUSH_NULL
+              LOAD_CONST               0 (1)
+              CALL_STR_1               1
+              RETURN_VALUE
+"""
+        co = compile("str(1)", "", "eval")
+        self.code_quicken(lambda: exec(co, {}, {}))
+        got = self.get_disassembly(co, adaptive=True)
+        self.do_disassembly_compare(got, call_quicken)
+
+    @cpython_only
+    @requires_specialization
+    def test_loop_quicken(self):
+        # Loop can trigger a quicken where the loop is located
+        self.code_quicken(loop_test, 4)
+        got = self.get_disassembly(loop_test, adaptive=True)
+        expected = dis_loop_test_quickened_code
+        self.do_disassembly_compare(got, expected)
+
+    @cpython_only
+    def test_extended_arg_quick(self):
+        got = self.get_disassembly(extended_arg_quick)
+        self.do_disassembly_compare(got, dis_extended_arg_quick_code)
+
+    def get_cached_values(self, quickened, adaptive):
+        def f():
+            l = []
+            for i in range(42):
+                l.append(i)
+        if quickened:
+            self.code_quicken(f)
+        else:
+            # "copy" the code to un-quicken it:
+            f.__code__ = f.__code__.replace()
+        for instruction in _unroll_caches_as_Instructions(dis.get_instructions(
+            f, show_caches=True, adaptive=adaptive
+        ), show_caches=True):
+            if instruction.opname == "CACHE":
+                yield instruction.argrepr
+
+    @cpython_only
+    def test_show_caches(self):
+        for quickened in (False, True):
+            for adaptive in (False, True):
+                with self.subTest(f"{quickened=}, {adaptive=}"):
+                    if adaptive:
+                        pattern = r"^(\w+: \d+)?$"
+                    else:
+                        pattern = r"^(\w+: 0)?$"
+                    caches = list(self.get_cached_values(quickened, adaptive))
+                    for cache in caches:
+                        self.assertRegex(cache, pattern)
+                    total_caches = 21
+                    empty_caches = 7
+                    self.assertEqual(caches.count(""), empty_caches)
+                    self.assertEqual(len(caches), total_caches)
+
+    @cpython_only
+    def test_show_currinstr_with_cache(self):
+        """
+        Make sure that with lasti pointing to CACHE, it still shows the current
+        line correctly
+        """
+        def f():
+            print(a)
+        # The code above should generate a LOAD_GLOBAL which has CACHE instr after
+        # However, this might change in the future. So we explicitly try to find
+        # a CACHE entry in the instructions. If we can't do that, fail the test
+
+        for inst in _unroll_caches_as_Instructions(
+                dis.get_instructions(f, show_caches=True), show_caches=True):
+            if inst.opname == "CACHE":
+                op_offset = inst.offset - 2
+                cache_offset = inst.offset
+                break
+            else:
+                opname = inst.opname
+        else:
+            self.fail("Can't find a CACHE entry in the function provided to do the test")
+
+        assem_op = self.get_disassembly(f.__code__, lasti=op_offset, wrapper=False)
+        assem_cache = self.get_disassembly(f.__code__, lasti=cache_offset, wrapper=False)
+
+        # Make sure --> exists and points to the correct op
+        self.assertRegex(assem_op, fr"--> {opname}")
+        # Make sure when lasti points to cache, it shows the same disassembly
+        self.assertEqual(assem_op, assem_cache)
+
+
+class DisWithFileTests(DisTests):
+
+    # Run the tests again, using the file arg instead of print
+    def get_disassembly(self, func, lasti=-1, wrapper=True, **kwargs):
+        output = io.StringIO()
+        if wrapper:
+            dis.dis(func, file=output, **kwargs)
+        else:
+            dis.disassemble(func, lasti, file=output, **kwargs)
+        return output.getvalue()
+
+
+if dis.code_info.__doc__ is None:
+    code_info_consts = "0: None"
+else:
+    code_info_consts = "0: 'Formatted details of methods, functions, or code.'"
+
+code_info_code_info = f"""\
+Name:              code_info
+Filename:          (.*)
+Argument count:    1
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  1
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS
+Constants:
+   {code_info_consts}
+Names:
+   0: _format_code_info
+   1: _get_code_object
+Variable names:
+   0: x"""
+
+
+@staticmethod
+def tricky(a, b, /, x, y, z=True, *args, c, d, e=[], **kwds):
+    def f(c=c):
+        print(a, b, x, y, z, c, d, e, f)
+    yield a, b, x, y, z, c, d, e, f
+
+code_info_tricky = """\
+Name:              tricky
+Filename:          (.*)
+Argument count:    5
+Positional-only arguments: 2
+Kw-only arguments: 3
+Number of locals:  10
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, VARARGS, VARKEYWORDS, GENERATOR
+Constants:
+   0: None
+   1: <code object f at (.*), file "(.*)", line (.*)>
+Variable names:
+   0: a
+   1: b
+   2: x
+   3: y
+   4: z
+   5: c
+   6: d
+   7: e
+   8: args
+   9: kwds
+Cell variables:
+   0: [abedfxyz]
+   1: [abedfxyz]
+   2: [abedfxyz]
+   3: [abedfxyz]
+   4: [abedfxyz]
+   5: [abedfxyz]"""
+# NOTE: the order of the cell variables above depends on dictionary order!
+
+co_tricky_nested_f = tricky.__func__.__code__.co_consts[1]
+
+code_info_tricky_nested_f = """\
+Filename:          (.*)
+Argument count:    1
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  1
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, NESTED
+Constants:
+   0: None
+Names:
+   0: print
+Variable names:
+   0: c
+Free variables:
+   0: [abedfxyz]
+   1: [abedfxyz]
+   2: [abedfxyz]
+   3: [abedfxyz]
+   4: [abedfxyz]
+   5: [abedfxyz]"""
+
+code_info_expr_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 1
+Names:
+   0: x"""
+
+code_info_simple_stmt_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 1
+   1: None
+Names:
+   0: x"""
+
+code_info_compound_stmt_str = """\
+Name:              <module>
+Filename:          <disassembly>
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  0
+Stack size:        \\d+
+Flags:             0x0
+Constants:
+   0: 0
+   1: 1
+Names:
+   0: x"""
+
+
+async def async_def():
+    await 1
+    async for a in b: pass
+    async with c as d: pass
+
+code_info_async_def = """\
+Name:              async_def
+Filename:          (.*)
+Argument count:    0
+Positional-only arguments: 0
+Kw-only arguments: 0
+Number of locals:  2
+Stack size:        \\d+
+Flags:             OPTIMIZED, NEWLOCALS, COROUTINE
+Constants:
+   0: None
+   1: 1
+Names:
+   0: b
+   1: c
+Variable names:
+   0: a
+   1: d"""
+
+class CodeInfoTests(unittest.TestCase):
+    test_pairs = [
+      (dis.code_info, code_info_code_info),
+      (tricky, code_info_tricky),
+      (co_tricky_nested_f, code_info_tricky_nested_f),
+      (expr_str, code_info_expr_str),
+      (simple_stmt_str, code_info_simple_stmt_str),
+      (compound_stmt_str, code_info_compound_stmt_str),
+      (async_def, code_info_async_def)
+    ]
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_code_info(self):
+        self.maxDiff = 1000
+        for x, expected in self.test_pairs:
+            self.assertRegex(dis.code_info(x), expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_code(self):
+        self.maxDiff = 1000
+        for x, expected in self.test_pairs:
+            with captured_stdout() as output:
+                dis.show_code(x)
+            self.assertRegex(output.getvalue(), expected+"\n")
+            output = io.StringIO()
+            dis.show_code(x, file=output)
+            self.assertRegex(output.getvalue(), expected)
+
+    def test_code_info_object(self):
+        self.assertRaises(TypeError, dis.code_info, object())
+
+    def test_pretty_flags_no_flags(self):
+        self.assertEqual(dis.pretty_flags(0), '0x0')
+
+
+# Fodder for instruction introspection tests
+#   Editing any of these may require recalculating the expected output
+def outer(a=1, b=2):
+    def f(c=3, d=4):
+        def inner(e=5, f=6):
+            print(a, b, c, d, e, f)
+        print(a, b, c, d)
+        return inner
+    print(a, b, '', 1, [], {}, "Hello world!")
+    return f
+
+def jumpy():
+    # This won't actually run (but that's OK, we only disassemble it)
+    for i in range(10):
+        print(i)
+        if i < 4:
+            continue
+        if i > 6:
+            break
+    else:
+        print("I can haz else clause?")
+    while i:
+        print(i)
+        i -= 1
+        if i > 6:
+            continue
+        if i < 4:
+            break
+    else:
+        print("Who let lolcatz into this test suite?")
+    try:
+        1 / 0
+    except ZeroDivisionError:
+        print("Here we go, here we go, here we go...")
+    else:
+        with i as dodgy:
+            print("Never reach this")
+    finally:
+        print("OK, now we're done")
+
+# End fodder for opinfo generation tests
+expected_outer_line = 1
+_line_offset = outer.__code__.co_firstlineno - 1
+code_object_f = outer.__code__.co_consts[1]
+# expected_f_line = code_object_f.co_firstlineno - _line_offset # TODO: RUSTPYTHON; AttributeError: 'int' object has no attribute 'co_firstlineno'
+# code_object_inner = code_object_f.co_consts[1] # TODO: RUSTPYTHON; AttributeError: 'int' object has no attribute 'co_consts'
+# expected_inner_line = code_object_inner.co_firstlineno - _line_offset # TODO: RUSTPYTHON; NameError: name 'code_object_inner' is not defined
+expected_jumpy_line = 1
+
+# The following lines are useful to regenerate the expected results after
+# either the fodder is modified or the bytecode generation changes
+# After regeneration, update the references to code_object_f and
+# code_object_inner before rerunning the tests
+
+def _stringify_instruction(instr):
+    # Since line numbers and other offsets change a lot for these
+    # test cases, ignore them.
+    return f"  {instr._replace(positions=None)!r},"
+
+def _prepare_test_cases():
+    ignore = io.StringIO()
+    with contextlib.redirect_stdout(ignore):
+        f = outer()
+        inner = f()
+    _instructions_outer = dis.get_instructions(outer, first_line=expected_outer_line)
+    _instructions_f = dis.get_instructions(f, first_line=expected_f_line)
+    _instructions_inner = dis.get_instructions(inner, first_line=expected_inner_line)
+    _instructions_jumpy = dis.get_instructions(jumpy, first_line=expected_jumpy_line)
+    result = "\n".join(
+        [
+            "expected_opinfo_outer = [",
+            *map(_stringify_instruction, _instructions_outer),
+            "]",
+            "",
+            "expected_opinfo_f = [",
+            *map(_stringify_instruction, _instructions_f),
+            "]",
+            "",
+            "expected_opinfo_inner = [",
+            *map(_stringify_instruction, _instructions_inner),
+            "]",
+            "",
+            "expected_opinfo_jumpy = [",
+            *map(_stringify_instruction, _instructions_jumpy),
+            "]",
+        ]
+    )
+    result = result.replace(repr(repr(code_object_f)), "repr(code_object_f)")
+    result = result.replace(repr(code_object_f), "code_object_f")
+    result = result.replace(repr(repr(code_object_inner)), "repr(code_object_inner)")
+    result = result.replace(repr(code_object_inner), "code_object_inner")
+    print(result)
+
+# from test.test_dis import _prepare_test_cases; _prepare_test_cases()
+
+Instruction = dis.Instruction
+
+expected_opinfo_outer = [
+  Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='a', argrepr='a', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='b', argrepr='b', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=4, start_offset=4, starts_line=True, line_number=1, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=(3, 4), argrepr='(3, 4)', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='a', argrepr='a', offset=8, start_offset=8, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=1, argval='b', argrepr='b', offset=10, start_offset=10, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='BUILD_TUPLE', opcode=52, arg=2, argval=2, argrepr='', offset=12, start_offset=12, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=code_object_f, argrepr=repr(code_object_f), offset=14, start_offset=14, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='MAKE_FUNCTION', opcode=26, arg=None, argval=None, argrepr='', offset=16, start_offset=16, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=18, start_offset=18, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=20, start_offset=20, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='f', argrepr='f', offset=22, start_offset=22, starts_line=False, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=24, start_offset=24, starts_line=True, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=0, argval='a', argrepr='a', offset=34, start_offset=34, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=1, argval='b', argrepr='b', offset=36, start_offset=36, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval='', argrepr="''", offset=38, start_offset=38, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=1, argrepr='1', offset=40, start_offset=40, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='BUILD_LIST', opcode=47, arg=0, argval=0, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='BUILD_MAP', opcode=48, arg=0, argval=0, argrepr='', offset=44, start_offset=44, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=4, argval='Hello world!', argrepr="'Hello world!'", offset=46, start_offset=46, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=7, argval=7, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=7, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=2, argval='f', argrepr='f', offset=58, start_offset=58, starts_line=True, line_number=8, label=None, positions=None),
+  Instruction(opname='RETURN_VALUE', opcode=36, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=8, label=None, positions=None),
+]
+
+expected_opinfo_f = [
+  Instruction(opname='COPY_FREE_VARS', opcode=62, arg=2, argval=2, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=0, argval='c', argrepr='c', offset=2, start_offset=2, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='MAKE_CELL', opcode=94, arg=1, argval='d', argrepr='d', offset=4, start_offset=4, starts_line=False, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=6, start_offset=6, starts_line=True, line_number=2, label=None, positions=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=(5, 6), argrepr='(5, 6)', offset=8, start_offset=8, starts_line=True, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=3, argval='a', argrepr='a', offset=10, start_offset=10, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=4, argval='b', argrepr='b', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='c', argrepr='c', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=1, argval='d', argrepr='d', offset=16, start_offset=16, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='BUILD_TUPLE', opcode=52, arg=4, argval=4, argrepr='', offset=18, start_offset=18, starts_line=False, line_number=3, label=None, positions=None),
+  #Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=code_object_inner, argrepr=repr(code_object_inner), offset=20, start_offset=20, starts_line=False, line_number=3, label=None, positions=None), # TODO: RUSTPYTHON; NameError: name 'code_object_inner' is not defined
+  Instruction(opname='MAKE_FUNCTION', opcode=26, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=8, argval=8, argrepr='closure', offset=24, start_offset=24, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='SET_FUNCTION_ATTRIBUTE', opcode=106, arg=1, argval=1, argrepr='defaults', offset=26, start_offset=26, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=2, argval='inner', argrepr='inner', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=3, argval='a', argrepr='a', offset=40, start_offset=40, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=4, argval='b', argrepr='b', offset=42, start_offset=42, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=0, argval='c', argrepr='c', offset=44, start_offset=44, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=1, argval='d', argrepr='d', offset=46, start_offset=46, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=4, argval=4, argrepr='', offset=48, start_offset=48, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=2, argval='inner', argrepr='inner', offset=58, start_offset=58, starts_line=True, line_number=6, label=None, positions=None),
+  Instruction(opname='RETURN_VALUE', opcode=36, arg=None, argval=None, argrepr='', offset=60, start_offset=60, starts_line=False, line_number=6, label=None, positions=None),
+]
+
+expected_opinfo_inner = [
+  Instruction(opname='COPY_FREE_VARS', opcode=62, arg=4, argval=4, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=None, label=None, positions=None),
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='print', argrepr='print + NULL', offset=4, start_offset=4, starts_line=True, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=2, argval='a', argrepr='a', offset=14, start_offset=14, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=3, argval='b', argrepr='b', offset=16, start_offset=16, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=4, argval='c', argrepr='c', offset=18, start_offset=18, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_DEREF', opcode=84, arg=5, argval='d', argrepr='d', offset=20, start_offset=20, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='LOAD_FAST_LOAD_FAST', opcode=88, arg=1, argval=('e', 'f'), argrepr='e, f', offset=22, start_offset=22, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='CALL', opcode=53, arg=6, argval=6, argrepr='', offset=24, start_offset=24, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=32, start_offset=32, starts_line=False, line_number=4, label=None, positions=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=34, start_offset=34, starts_line=False, line_number=4, label=None, positions=None),
+]
+
+expected_opinfo_jumpy = [
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=1, argval='range', argrepr='range + NULL', offset=2, start_offset=2, starts_line=True, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=1, argval=10, argrepr='10', offset=12, start_offset=12, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=14, start_offset=14, starts_line=False, line_number=3, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='GET_ITER', opcode=19, arg=None, argval=None, argrepr='', offset=22, start_offset=22, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='FOR_ITER', opcode=72, arg=30, argval=88, argrepr='to L4', offset=24, start_offset=24, starts_line=False, line_number=3, label=1, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=28, start_offset=28, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=30, start_offset=30, starts_line=True, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=40, start_offset=40, starts_line=False, line_number=4, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=42, start_offset=42, starts_line=False, line_number=4, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=50, start_offset=50, starts_line=False, line_number=4, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=52, start_offset=52, starts_line=True, line_number=5, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=4, argrepr='4', offset=54, start_offset=54, starts_line=False, line_number=5, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=18, argval='<', argrepr='bool(<)', offset=56, start_offset=56, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=68, argrepr='to L2', offset=60, start_offset=60, starts_line=False, line_number=5, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=22, argval=24, argrepr='to L1', offset=64, start_offset=64, starts_line=True, line_number=6, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=68, start_offset=68, starts_line=True, line_number=7, label=2, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=6, argrepr='6', offset=70, start_offset=70, starts_line=False, line_number=7, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=148, argval='>', argrepr='bool(>)', offset=72, start_offset=72, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=2, argval=84, argrepr='to L3', offset=76, start_offset=76, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=30, argval=24, argrepr='to L1', offset=80, start_offset=80, starts_line=False, line_number=7, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=84, start_offset=84, starts_line=True, line_number=8, label=3, positions=None, cache_info=None),
+  Instruction(opname='JUMP_FORWARD', opcode=79, arg=13, argval=114, argrepr='to L5', offset=86, start_offset=86, starts_line=False, line_number=8, label=None, positions=None, cache_info=None),
+  Instruction(opname='END_FOR', opcode=11, arg=None, argval=None, argrepr='', offset=88, start_offset=88, starts_line=True, line_number=3, label=4, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=90, start_offset=90, starts_line=False, line_number=3, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=92, start_offset=92, starts_line=True, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=4, argval='I can haz else clause?', argrepr="'I can haz else clause?'", offset=102, start_offset=102, starts_line=False, line_number=10, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=104, start_offset=104, starts_line=False, line_number=10, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=112, start_offset=112, starts_line=False, line_number=10, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST_CHECK', opcode=87, arg=0, argval='i', argrepr='i', offset=114, start_offset=114, starts_line=True, line_number=11, label=5, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=116, start_offset=116, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=40, argval=208, argrepr='to L9', offset=124, start_offset=124, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=128, start_offset=128, starts_line=True, line_number=12, label=6, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=138, start_offset=138, starts_line=False, line_number=12, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=140, start_offset=140, starts_line=False, line_number=12, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=148, start_offset=148, starts_line=False, line_number=12, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=150, start_offset=150, starts_line=True, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=1, argrepr='1', offset=152, start_offset=152, starts_line=False, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='BINARY_OP', opcode=45, arg=23, argval=23, argrepr='-=', offset=154, start_offset=154, starts_line=False, line_number=13, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='STORE_FAST', opcode=110, arg=0, argval='i', argrepr='i', offset=158, start_offset=158, starts_line=False, line_number=13, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=160, start_offset=160, starts_line=True, line_number=14, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=3, argval=6, argrepr='6', offset=162, start_offset=162, starts_line=False, line_number=14, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=148, argval='>', argrepr='bool(>)', offset=164, start_offset=164, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=176, argrepr='to L7', offset=168, start_offset=168, starts_line=False, line_number=14, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=31, argval=114, argrepr='to L5', offset=172, start_offset=172, starts_line=True, line_number=15, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=176, start_offset=176, starts_line=True, line_number=16, label=7, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=2, argval=4, argrepr='4', offset=178, start_offset=178, starts_line=False, line_number=16, label=None, positions=None, cache_info=None),
+  Instruction(opname='COMPARE_OP', opcode=58, arg=18, argval='<', argrepr='bool(<)', offset=180, start_offset=180, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=1, argval=190, argrepr='to L8', offset=184, start_offset=184, starts_line=False, line_number=16, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_FORWARD', opcode=79, arg=20, argval=230, argrepr='to L10', offset=188, start_offset=188, starts_line=True, line_number=17, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=190, start_offset=190, starts_line=True, line_number=11, label=8, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=192, start_offset=192, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=2, argval=208, argrepr='to L9', offset=200, start_offset=200, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='JUMP_BACKWARD', opcode=77, arg=40, argval=128, argrepr='to L6', offset=204, start_offset=204, starts_line=False, line_number=11, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=208, start_offset=208, starts_line=True, line_number=19, label=9, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=6, argval='Who let lolcatz into this test suite?', argrepr="'Who let lolcatz into this test suite?'", offset=218, start_offset=218, starts_line=False, line_number=19, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=220, start_offset=220, starts_line=False, line_number=19, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=228, start_offset=228, starts_line=False, line_number=19, label=None, positions=None, cache_info=None),
+  Instruction(opname='NOP', opcode=30, arg=None, argval=None, argrepr='', offset=230, start_offset=230, starts_line=True, line_number=20, label=10, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=5, argval=1, argrepr='1', offset=232, start_offset=232, starts_line=True, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=7, argval=0, argrepr='0', offset=234, start_offset=234, starts_line=False, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='BINARY_OP', opcode=45, arg=11, argval=11, argrepr='/', offset=236, start_offset=236, starts_line=False, line_number=21, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=240, start_offset=240, starts_line=False, line_number=21, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_FAST', opcode=85, arg=0, argval='i', argrepr='i', offset=242, start_offset=242, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='BEFORE_WITH', opcode=2, arg=None, argval=None, argrepr='', offset=244, start_offset=244, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='STORE_FAST', opcode=110, arg=1, argval='dodgy', argrepr='dodgy', offset=246, start_offset=246, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=248, start_offset=248, starts_line=True, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=8, argval='Never reach this', argrepr="'Never reach this'", offset=258, start_offset=258, starts_line=False, line_number=26, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=260, start_offset=260, starts_line=False, line_number=26, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=268, start_offset=268, starts_line=False, line_number=26, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=270, start_offset=270, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=272, start_offset=272, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=0, argval=None, argrepr='None', offset=274, start_offset=274, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=2, argval=2, argrepr='', offset=276, start_offset=276, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=284, start_offset=284, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=286, start_offset=286, starts_line=True, line_number=28, label=11, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=296, start_offset=296, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=298, start_offset=298, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=306, start_offset=306, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=308, start_offset=308, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=310, start_offset=310, starts_line=True, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='WITH_EXCEPT_START', opcode=44, arg=None, argval=None, argrepr='', offset=312, start_offset=312, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='TO_BOOL', opcode=40, arg=None, argval=None, argrepr='', offset=314, start_offset=314, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_JUMP_IF_TRUE', opcode=100, arg=1, argval=328, argrepr='to L12', offset=322, start_offset=322, starts_line=False, line_number=25, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='RERAISE', opcode=102, arg=2, argval=2, argrepr='', offset=326, start_offset=326, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=328, start_offset=328, starts_line=False, line_number=25, label=12, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=330, start_offset=330, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=332, start_offset=332, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=334, start_offset=334, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=78, arg=26, argval=286, argrepr='to L11', offset=336, start_offset=336, starts_line=False, line_number=25, label=None, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=338, start_offset=338, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=340, start_offset=340, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=342, start_offset=342, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=344, start_offset=344, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=4, argval='ZeroDivisionError', argrepr='ZeroDivisionError', offset=346, start_offset=346, starts_line=True, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='CHECK_EXC_MATCH', opcode=7, arg=None, argval=None, argrepr='', offset=356, start_offset=356, starts_line=False, line_number=22, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_JUMP_IF_FALSE', opcode=97, arg=14, argval=390, argrepr='to L13', offset=358, start_offset=358, starts_line=False, line_number=22, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=362, start_offset=362, starts_line=False, line_number=22, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=364, start_offset=364, starts_line=True, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=9, argval='Here we go, here we go, here we go...', argrepr="'Here we go, here we go, here we go...'", offset=374, start_offset=374, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=376, start_offset=376, starts_line=False, line_number=23, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=384, start_offset=384, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=386, start_offset=386, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='JUMP_BACKWARD_NO_INTERRUPT', opcode=78, arg=52, argval=286, argrepr='to L11', offset=388, start_offset=388, starts_line=False, line_number=23, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=390, start_offset=390, starts_line=True, line_number=22, label=13, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=392, start_offset=392, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=394, start_offset=394, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=396, start_offset=396, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='PUSH_EXC_INFO', opcode=33, arg=None, argval=None, argrepr='', offset=398, start_offset=398, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='LOAD_GLOBAL', opcode=91, arg=3, argval='print', argrepr='print + NULL', offset=400, start_offset=400, starts_line=True, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('index', 1, b'\x00\x00'), ('module_keys_version', 1, b'\x00\x00'), ('builtin_keys_version', 1, b'\x00\x00')]),
+  Instruction(opname='LOAD_CONST', opcode=83, arg=10, argval="OK, now we're done", argrepr='"OK, now we\'re done"', offset=410, start_offset=410, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='CALL', opcode=53, arg=1, argval=1, argrepr='', offset=412, start_offset=412, starts_line=False, line_number=28, label=None, positions=None, cache_info=[('counter', 1, b'\x00\x00'), ('func_version', 2, b'\x00\x00\x00\x00')]),
+  Instruction(opname='POP_TOP', opcode=32, arg=None, argval=None, argrepr='', offset=420, start_offset=420, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=0, argval=0, argrepr='', offset=422, start_offset=422, starts_line=False, line_number=28, label=None, positions=None, cache_info=None),
+  Instruction(opname='COPY', opcode=61, arg=3, argval=3, argrepr='', offset=424, start_offset=424, starts_line=True, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='POP_EXCEPT', opcode=31, arg=None, argval=None, argrepr='', offset=426, start_offset=426, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+  Instruction(opname='RERAISE', opcode=102, arg=1, argval=1, argrepr='', offset=428, start_offset=428, starts_line=False, line_number=None, label=None, positions=None, cache_info=None),
+]
+
+# One last piece of inspect fodder to check the default line number handling
+def simple(): pass
+expected_opinfo_simple = [
+  Instruction(opname='RESUME', opcode=149, arg=0, argval=0, argrepr='', offset=0, start_offset=0, starts_line=True, line_number=simple.__code__.co_firstlineno, label=None, positions=None),
+  Instruction(opname='RETURN_CONST', opcode=103, arg=0, argval=None, argrepr='None', offset=2, start_offset=2, starts_line=False, line_number=simple.__code__.co_firstlineno, label=None),
+]
+
+
+class InstructionTestCase(BytecodeTestCase):
+
+    def assertInstructionsEqual(self, instrs_1, instrs_2, /):
+        instrs_1 = [instr_1._replace(positions=None, cache_info=None) for instr_1 in instrs_1]
+        instrs_2 = [instr_2._replace(positions=None, cache_info=None) for instr_2 in instrs_2]
+        self.assertEqual(instrs_1, instrs_2)
+
+class InstructionTests(InstructionTestCase):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.maxDiff = None
+
+    def test_instruction_str(self):
+        # smoke test for __str__
+        instrs = dis.get_instructions(simple)
+        for instr in instrs:
+            str(instr)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_default_first_line(self):
+        actual = dis.get_instructions(simple)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_simple)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_first_line_set_to_None(self):
+        actual = dis.get_instructions(simple, first_line=None)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_simple)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_outer(self):
+        actual = dis.get_instructions(outer, first_line=expected_outer_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_outer)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_nested(self):
+        with captured_stdout():
+            f = outer()
+        actual = dis.get_instructions(f, first_line=expected_f_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_f)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_doubly_nested(self):
+        with captured_stdout():
+            inner = outer()()
+        actual = dis.get_instructions(inner, first_line=expected_inner_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_inner)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_jumpy(self):
+        actual = dis.get_instructions(jumpy, first_line=expected_jumpy_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_jumpy)
+
+    @requires_debug_ranges()
+    def test_co_positions(self):
+        code = compile('f(\n  x, y, z\n)', '<test>', 'exec')
+        positions = [
+            instr.positions
+            for instr in dis.get_instructions(code)
+        ]
+        expected = [
+            (0, 1, 0, 0),
+            (1, 1, 0, 1),
+            (1, 1, 0, 1),
+            (2, 2, 2, 3),
+            (2, 2, 5, 6),
+            (2, 2, 8, 9),
+            (1, 3, 0, 1),
+            (1, 3, 0, 1),
+            (1, 3, 0, 1)
+        ]
+        self.assertEqual(positions, expected)
+
+        named_positions = [
+            (pos.lineno, pos.end_lineno, pos.col_offset, pos.end_col_offset)
+            for pos in positions
+        ]
+        self.assertEqual(named_positions, expected)
+
+    @requires_debug_ranges()
+    def test_co_positions_missing_info(self):
+        code = compile('x, y, z', '<test>', 'exec')
+        code_without_location_table = code.replace(co_linetable=b'')
+        actual = dis.get_instructions(code_without_location_table)
+        for instruction in actual:
+            with self.subTest(instruction=instruction):
+                positions = instruction.positions
+                self.assertEqual(len(positions), 4)
+                if instruction.opname == "RESUME":
+                    continue
+                self.assertIsNone(positions.lineno)
+                self.assertIsNone(positions.end_lineno)
+                self.assertIsNone(positions.col_offset)
+                self.assertIsNone(positions.end_col_offset)
+
+    @requires_debug_ranges()
+    def test_co_positions_with_lots_of_caches(self):
+        def roots(a, b, c):
+            d = b**2 - 4 * a * c
+            yield (-b - cmath.sqrt(d)) / (2 * a)
+            if d:
+                yield (-b + cmath.sqrt(d)) / (2 * a)
+        code = roots.__code__
+        ops = code.co_code[::2]
+        cache_opcode = opcode.opmap["CACHE"]
+        caches = sum(op == cache_opcode for op in ops)
+        non_caches = len(ops) - caches
+        # Make sure we have "lots of caches". If not, roots should be changed:
+        assert 1 / 3 <= caches / non_caches, "this test needs more caches!"
+        for show_caches in (False, True):
+            for adaptive in (False, True):
+                with self.subTest(f"{adaptive=}, {show_caches=}"):
+                    co_positions = [
+                        positions
+                        for op, positions in zip(ops, code.co_positions(), strict=True)
+                        if show_caches or op != cache_opcode
+                    ]
+                    dis_positions = [
+                        None if instruction.positions is None else (
+                            instruction.positions.lineno,
+                            instruction.positions.end_lineno,
+                            instruction.positions.col_offset,
+                            instruction.positions.end_col_offset,
+                        )
+                        for instruction in _unroll_caches_as_Instructions(dis.get_instructions(
+                            code, adaptive=adaptive, show_caches=show_caches
+                        ), show_caches=show_caches)
+                    ]
+                    self.assertEqual(co_positions, dis_positions)
+
+    def test_oparg_alias(self):
+        instruction = Instruction(opname="NOP", opcode=dis.opmap["NOP"], arg=None, argval=None,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(instruction.arg, instruction.oparg)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_caches_with_label(self):
+        def f(x, y, z):
+            if x:
+                res = y
+            else:
+                res = z
+            return res
+
+        output = io.StringIO()
+        dis.dis(f.__code__, file=output, show_caches=True)
+        self.assertIn("L1:", output.getvalue())
+
+    def test_baseopname_and_baseopcode(self):
+        # Standard instructions
+        for name, code in dis.opmap.items():
+            instruction = Instruction(opname=name, opcode=code, arg=None, argval=None, argrepr='', offset=0,
+                                      start_offset=0, starts_line=True, line_number=1, label=None, positions=None)
+            baseopname = instruction.baseopname
+            baseopcode = instruction.baseopcode
+            self.assertIsNotNone(baseopname)
+            self.assertIsNotNone(baseopcode)
+            self.assertEqual(name, baseopname)
+            self.assertEqual(code, baseopcode)
+
+        # Specialized instructions
+        for name in opcode._specialized_opmap:
+            instruction = Instruction(opname=name, opcode=dis._all_opmap[name], arg=None, argval=None, argrepr='',
+                                      offset=0, start_offset=0, starts_line=True, line_number=1, label=None, positions=None)
+            baseopname = instruction.baseopname
+            baseopcode = instruction.baseopcode
+            self.assertIn(name, opcode._specializations[baseopname])
+            self.assertEqual(opcode.opmap[baseopname], baseopcode)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD/JUMP_FORWARD are placeholders
+    def test_jump_target(self):
+        # Non-jump instructions should return None
+        instruction = Instruction(opname="NOP", opcode=dis.opmap["NOP"], arg=None, argval=None,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertIsNone(instruction.jump_target)
+
+        delta = 100
+        instruction = Instruction(opname="JUMP_FORWARD", opcode=dis.opmap["JUMP_FORWARD"], arg=delta, argval=delta,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(10 + 2 + 100*2, instruction.jump_target)
+
+        # Test negative deltas
+        instruction = Instruction(opname="JUMP_BACKWARD", opcode=dis.opmap["JUMP_BACKWARD"], arg=delta, argval=delta,
+                                  argrepr='', offset=200, start_offset=200, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(200 + 2 - 100*2 + 2*1, instruction.jump_target)
+
+        # Make sure cache entries are handled
+        instruction = Instruction(opname="SEND", opcode=dis.opmap["SEND"], arg=delta, argval=delta,
+                                  argrepr='', offset=10, start_offset=10, starts_line=True, line_number=1, label=None,
+                                  positions=None)
+        self.assertEqual(10 + 2 + 1*2 + 100*2, instruction.jump_target)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD is a placeholder
+    def test_argval_argrepr(self):
+        def f(opcode, oparg, offset, *init_args):
+            arg_resolver = dis.ArgResolver(*init_args)
+            return arg_resolver.get_argval_argrepr(opcode, oparg, offset)
+
+        offset = 42
+        co_consts = (0, 1, 2, 3)
+        names = {1: 'a', 2: 'b'}
+        varname_from_oparg = lambda i : names[i]
+        labels_map = {24: 1}
+        args = (offset, co_consts, names, varname_from_oparg, labels_map)
+        self.assertEqual(f(opcode.opmap["POP_TOP"], None, *args), (None, ''))
+        self.assertEqual(f(opcode.opmap["LOAD_CONST"], 1, *args), (1, '1'))
+        self.assertEqual(f(opcode.opmap["LOAD_GLOBAL"], 2, *args), ('a', 'a'))
+        self.assertEqual(f(opcode.opmap["JUMP_BACKWARD"], 11, *args), (24, 'to L1'))
+        self.assertEqual(f(opcode.opmap["COMPARE_OP"], 3, *args), ('<', '<'))
+        self.assertEqual(f(opcode.opmap["SET_FUNCTION_ATTRIBUTE"], 2, *args), (2, 'kwdefaults'))
+        self.assertEqual(f(opcode.opmap["BINARY_OP"], 3, *args), (3, '<<'))
+        self.assertEqual(f(opcode.opmap["CALL_INTRINSIC_1"], 2, *args), (2, 'INTRINSIC_IMPORT_STAR'))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON - JUMP_BACKWARD is a placeholder
+    def test_custom_arg_resolver(self):
+        class MyArgResolver(dis.ArgResolver):
+            def offset_from_jump_arg(self, op, arg, offset):
+                return arg + 1
+
+            def get_label_for_offset(self, offset):
+                return 2 * offset
+
+        def f(opcode, oparg, offset, *init_args):
+            arg_resolver = MyArgResolver(*init_args)
+            return arg_resolver.get_argval_argrepr(opcode, oparg, offset)
+        offset = 42
+        self.assertEqual(f(opcode.opmap["JUMP_BACKWARD"], 1, offset), (2, 'to L4'))
+        self.assertEqual(f(opcode.opmap["SETUP_FINALLY"], 2, offset), (3, 'to L6'))
+
+
+    def get_instructions(self, code):
+        return dis._get_instructions_bytes(code)
+
+    def test_start_offset(self):
+        # When no extended args are present,
+        # start_offset should be equal to offset
+
+        instructions = list(dis.Bytecode(_f))
+        for instruction in instructions:
+            self.assertEqual(instruction.offset, instruction.start_offset)
+
+        def last_item(iterable):
+            return functools.reduce(lambda a, b : b, iterable)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+        ])
+        labels_map = dis._make_labels_map(code)
+        jump = last_item(self.get_instructions(code))
+        self.assertEqual(4, jump.offset)
+        self.assertEqual(2, jump.start_offset)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+        ])
+        jump = last_item(self.get_instructions(code))
+        self.assertEqual(8, jump.offset)
+        self.assertEqual(2, jump.start_offset)
+
+        code = bytes([
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["EXTENDED_ARG"], 0x01,
+            opcode.opmap["POP_JUMP_IF_TRUE"], 0xFF,
+            opcode.opmap["CACHE"], 0x00,
+        ])
+        instructions = list(self.get_instructions(code))
+        # 1st jump
+        self.assertEqual(4, instructions[2].offset)
+        self.assertEqual(2, instructions[2].start_offset)
+        # 2nd jump
+        self.assertEqual(14, instructions[6].offset)
+        self.assertEqual(8, instructions[6].start_offset)
+
+    def test_cache_offset_and_end_offset(self):
+        code = bytes([
+            opcode.opmap["LOAD_GLOBAL"], 0x01,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["LOAD_FAST"], 0x00,
+            opcode.opmap["CALL"], 0x01,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00,
+            opcode.opmap["CACHE"], 0x00
+        ])
+        instructions = list(self.get_instructions(code))
+        self.assertEqual(2, instructions[0].cache_offset)
+        self.assertEqual(10, instructions[0].end_offset)
+        self.assertEqual(12, instructions[1].cache_offset)
+        self.assertEqual(12, instructions[1].end_offset)
+        self.assertEqual(14, instructions[2].cache_offset)
+        self.assertEqual(20, instructions[2].end_offset)
+
+        # end_offset of the previous instruction should be equal to the
+        # start_offset of the following instruction
+        instructions = list(dis.Bytecode(self.test_cache_offset_and_end_offset))
+        for prev, curr in zip(instructions, instructions[1:]):
+            self.assertEqual(prev.end_offset, curr.start_offset)
+
+
+# get_instructions has its own tests above, so can rely on it to validate
+# the object oriented API
+class BytecodeTests(InstructionTestCase, DisTestBase):
+
+    def test_instantiation(self):
+        # Test with function, method, code string and code object
+        for obj in [_f, _C(1).__init__, "a=1", _f.__code__]:
+            with self.subTest(obj=obj):
+                b = dis.Bytecode(obj)
+                self.assertIsInstance(b.codeobj, types.CodeType)
+
+        self.assertRaises(TypeError, dis.Bytecode, object())
+
+    def test_iteration(self):
+        for obj in [_f, _C(1).__init__, "a=1", _f.__code__]:
+            with self.subTest(obj=obj):
+                via_object = list(dis.Bytecode(obj))
+                via_generator = list(dis.get_instructions(obj))
+                self.assertInstructionsEqual(via_object, via_generator)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_explicit_first_line(self):
+        actual = dis.Bytecode(outer, first_line=expected_outer_line)
+        self.assertInstructionsEqual(list(actual), expected_opinfo_outer)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_source_line_in_disassembly(self):
+        # Use the line in the source code
+        actual = dis.Bytecode(simple).dis()
+        actual = actual.strip().partition(" ")[0]  # extract the line no
+        expected = str(simple.__code__.co_firstlineno)
+        self.assertEqual(actual, expected)
+        # Use an explicit first line number
+        actual = dis.Bytecode(simple, first_line=350).dis()
+        actual = actual.strip().partition(" ")[0]  # extract the line no
+        self.assertEqual(actual, "350")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_info(self):
+        self.maxDiff = 1000
+        for x, expected in CodeInfoTests.test_pairs:
+            b = dis.Bytecode(x)
+            self.assertRegex(b.info(), expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_disassembled(self):
+        actual = dis.Bytecode(_f).dis()
+        self.do_disassembly_compare(actual, dis_f)
+
+    def test_from_traceback(self):
+        tb = get_tb()
+        b = dis.Bytecode.from_traceback(tb)
+        while tb.tb_next: tb = tb.tb_next
+
+        self.assertEqual(b.current_offset, tb.tb_lasti)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_from_traceback_dis(self):
+        self.maxDiff = None
+        tb = get_tb()
+        b = dis.Bytecode.from_traceback(tb)
+        self.assertEqual(b.dis(), dis_traceback)
+
+    @requires_debug_ranges()
+    def test_bytecode_co_positions(self):
+        bytecode = dis.Bytecode("a=1")
+        for instr, positions in zip(bytecode, bytecode.codeobj.co_positions()):
+            assert instr.positions == positions
+
+class TestBytecodeTestCase(BytecodeTestCase):
+    def test_assert_not_in_with_op_not_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        self.assertInBytecode(code, "LOAD_CONST", 1)
+        self.assertNotInBytecode(code, "LOAD_NAME")
+        self.assertNotInBytecode(code, "LOAD_NAME", "a")
+
+    def test_assert_not_in_with_arg_not_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        self.assertInBytecode(code, "LOAD_CONST")
+        self.assertInBytecode(code, "LOAD_CONST", 1)
+        self.assertNotInBytecode(code, "LOAD_CONST", 2)
+
+    def test_assert_not_in_with_arg_in_bytecode(self):
+        code = compile("a = 1", "<string>", "exec")
+        with self.assertRaises(AssertionError):
+            self.assertNotInBytecode(code, "LOAD_CONST", 1)
+
+class TestFinderMethods(unittest.TestCase):
+    def test__find_imports(self):
+        cases = [
+            ("import a.b.c", ('a.b.c', 0, None)),
+            ("from a.b import c", ('a.b', 0, ('c',))),
+            ("from a.b import c as d", ('a.b', 0, ('c',))),
+            ("from a.b import *", ('a.b', 0, ('*',))),
+            ("from ...a.b import c as d", ('a.b', 3, ('c',))),
+            ("from ..a.b import c as d, e as f", ('a.b', 2, ('c', 'e'))),
+            ("from ..a.b import *", ('a.b', 2, ('*',))),
+        ]
+        for src, expected in cases:
+            with self.subTest(src=src):
+                code = compile(src, "<string>", "exec")
+                res = tuple(dis._find_imports(code))
+                self.assertEqual(len(res), 1)
+                self.assertEqual(res[0], expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test__find_store_names(self):
+        cases = [
+            ("x+y", ()),
+            ("x=y=1", ('x', 'y')),
+            ("x+=y", ('x',)),
+            ("global x\nx=y=1", ('x', 'y')),
+            ("global x\nz=x", ('z',)),
+        ]
+        for src, expected in cases:
+            with self.subTest(src=src):
+                code = compile(src, "<string>", "exec")
+                res = tuple(dis._find_store_names(code))
+                self.assertEqual(res, expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_findlabels(self):
+        labels = dis.findlabels(jumpy.__code__.co_code)
+        jumps = [
+            instr.offset
+            for instr in expected_opinfo_jumpy
+            if instr.is_jump_target
+        ]
+
+        self.assertEqual(sorted(labels), sorted(jumps))
+
+    def test_findlinestarts(self):
+        def func():
+            pass
+
+        code = func.__code__
+        offsets = [linestart[0] for linestart in dis.findlinestarts(code)]
+        self.assertEqual(offsets, [0, 2])
+
+
+class TestDisTraceback(DisTestBase):
+    def setUp(self) -> None:
+        try:  # We need to clean up existing tracebacks
+            del sys.last_exc
+        except AttributeError:
+            pass
+        try:  # We need to clean up existing tracebacks
+            del sys.last_traceback
+        except AttributeError:
+            pass
+        return super().setUp()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def get_disassembly(self, tb):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.distb(tb)
+        return output.getvalue()
+
+    def test_distb_empty(self):
+        with self.assertRaises(RuntimeError):
+            dis.distb()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_distb_last_traceback(self):
+        self.maxDiff = None
+        # We need to have an existing last traceback in `sys`:
+        tb = get_tb()
+        sys.last_traceback = tb
+
+        self.do_disassembly_compare(self.get_disassembly(None), dis_traceback)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_distb_explicit_arg(self):
+        self.maxDiff = None
+        tb = get_tb()
+
+        self.do_disassembly_compare(self.get_disassembly(tb), dis_traceback)
+
+
+class TestDisTracebackWithFile(TestDisTraceback):
+    # Run the `distb` tests again, using the file arg instead of print
+    def get_disassembly(self, tb):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.distb(tb, file=output)
+        return output.getvalue()
+
+def _unroll_caches_as_Instructions(instrs, show_caches=False):
+    # Cache entries are no longer reported by dis as fake instructions,
+    # but some tests assume that do. We should rewrite the tests to assume
+    # the new API, but it will be clearer to keep the tests working as
+    # before and do that in a separate PR.
+
+    for instr in instrs:
+        yield instr
+        if not show_caches:
+            continue
+
+        offset = instr.offset
+        for name, size, data in (instr.cache_info or ()):
+            for i in range(size):
+                offset += 2
+                # Only show the fancy argrepr for a CACHE instruction when it's
+                # the first entry for a particular cache value:
+                if i == 0:
+                    argrepr = f"{name}: {int.from_bytes(data, sys.byteorder)}"
+                else:
+                    argrepr = ""
+
+                yield Instruction("CACHE", CACHE, 0, None, argrepr, offset, offset,
+                                  False, None, None, instr.positions)
+
+
+class TestDisCLI(unittest.TestCase):
+
+    def setUp(self):
+        self.filename = tempfile.mktemp()
+        self.addCleanup(os_helper.unlink, self.filename)
+
+    @staticmethod
+    def text_normalize(string):
+        """Dedent *string* and strip it from its surrounding whitespaces.
+
+        This method is used by the other utility functions so that any
+        string to write or to match against can be freely indented.
+        """
+        return textwrap.dedent(string).strip()
+
+    def set_source(self, content):
+        with open(self.filename, 'w') as fp:
+            fp.write(self.text_normalize(content))
+
+    def invoke_dis(self, *flags):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            dis.main(args=[*flags, self.filename])
+        return self.text_normalize(output.getvalue())
+
+    def check_output(self, source, expect, *flags):
+        with self.subTest(source=source, flags=flags):
+            self.set_source(source)
+            res = self.invoke_dis(*flags)
+            expect = self.text_normalize(expect)
+            self.assertListEqual(res.splitlines(), expect.splitlines())
+
+    def test_invocation(self):
+        # test various combinations of parameters
+        base_flags = [
+            ('-C', '--show-caches'),
+            ('-O', '--show-offsets'),
+        ]
+
+        self.set_source('''
+            def f():
+                print(x)
+                return None
+        ''')
+
+        for r in range(1, len(base_flags) + 1):
+            for choices in itertools.combinations(base_flags, r=r):
+                for args in itertools.product(*choices):
+                    with self.subTest(args=args[1:]):
+                        _ = self.invoke_dis(*args)
+
+        with self.assertRaises(SystemExit):
+            # suppress argparse error message
+            with contextlib.redirect_stderr(io.StringIO()):
+                _ = self.invoke_dis('--unknown')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_cache(self):
+        # test 'python -m dis -C/--show-caches'
+        source = 'print()'
+        expect = '''
+            0           RESUME                   0
+
+            1           LOAD_NAME                0 (print)
+                        PUSH_NULL
+                        CALL                     0
+                        CACHE                    0 (counter: 0)
+                        CACHE                    0 (func_version: 0)
+                        CACHE                    0
+                        POP_TOP
+                        RETURN_CONST             0 (None)
+        '''
+        for flag in ['-C', '--show-caches']:
+            self.check_output(source, expect, flag)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_show_offsets(self):
+        # test 'python -m dis -O/--show-offsets'
+        source = 'pass'
+        expect = '''
+            0          0       RESUME                   0
+
+            1          2       RETURN_CONST             0 (None)
+        '''
+        for flag in ['-O', '--show-offsets']:
+            self.check_output(source, expect, flag)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_doctest/__init__.py b/Lib/test/test_doctest/__init__.py
new file mode 100644
index 0000000000..4b16ecc311
--- /dev/null
+++ b/Lib/test/test_doctest/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_doctest/decorator_mod.py b/Lib/test/test_doctest/decorator_mod.py
new file mode 100644
index 0000000000..9f10688841
--- /dev/null
+++ b/Lib/test/test_doctest/decorator_mod.py
@@ -0,0 +1,10 @@
+# This module is used in `doctest_lineno.py`.
+import functools
+
+
+def decorator(f):
+    @functools.wraps(f)
+    def inner():
+        return f()
+
+    return inner
diff --git a/Lib/test/test_doctest/doctest_aliases.py b/Lib/test/test_doctest/doctest_aliases.py
new file mode 100644
index 0000000000..30cefafa83
--- /dev/null
+++ b/Lib/test/test_doctest/doctest_aliases.py
@@ -0,0 +1,13 @@
+# Used by test_doctest.py.
+
+class TwoNames:
+    '''f() and g() are two names for the same method'''
+
+    def f(self):
+        '''
+        >>> print(TwoNames().f())
+        f
+        '''
+        return 'f'
+
+    g = f # define an alias for f
diff --git a/Lib/test/test_doctest/doctest_lineno.py b/Lib/test/test_doctest/doctest_lineno.py
new file mode 100644
index 0000000000..0bd402e982
--- /dev/null
+++ b/Lib/test/test_doctest/doctest_lineno.py
@@ -0,0 +1,107 @@
+# This module is used in `test_doctest`.
+# It must not have a docstring.
+
+def func_with_docstring():
+    """Some unrelated info."""
+
+
+def func_without_docstring():
+    pass
+
+
+def func_with_doctest():
+    """
+    This function really contains a test case.
+
+    >>> func_with_doctest.__name__
+    'func_with_doctest'
+    """
+    return 3
+
+
+class ClassWithDocstring:
+    """Some unrelated class information."""
+
+
+class ClassWithoutDocstring:
+    pass
+
+
+class ClassWithDoctest:
+    """This class really has a test case in it.
+
+    >>> ClassWithDoctest.__name__
+    'ClassWithDoctest'
+    """
+
+
+class MethodWrapper:
+    def method_with_docstring(self):
+        """Method with a docstring."""
+
+    def method_without_docstring(self):
+        pass
+
+    def method_with_doctest(self):
+        """
+        This has a doctest!
+        >>> MethodWrapper.method_with_doctest.__name__
+        'method_with_doctest'
+        """
+
+    @classmethod
+    def classmethod_with_doctest(cls):
+        """
+        This has a doctest!
+        >>> MethodWrapper.classmethod_with_doctest.__name__
+        'classmethod_with_doctest'
+        """
+
+    @property
+    def property_with_doctest(self):
+        """
+        This has a doctest!
+        >>> MethodWrapper.property_with_doctest.__name__
+        'property_with_doctest'
+        """
+
+# https://github.com/python/cpython/issues/99433
+str_wrapper = object().__str__
+
+
+# https://github.com/python/cpython/issues/115392
+from test.test_doctest.decorator_mod import decorator
+
+@decorator
+@decorator
+def func_with_docstring_wrapped():
+    """Some unrelated info."""
+
+
+# https://github.com/python/cpython/issues/136914
+import functools
+
+
+@functools.cache
+def cached_func_with_doctest(value):
+    """
+    >>> cached_func_with_doctest(1)
+    -1
+    """
+    return -value
+
+
+@functools.cache
+def cached_func_without_docstring(value):
+    return value + 1
+
+
+class ClassWithACachedProperty:
+
+    @functools.cached_property
+    def cached(self):
+        """
+        >>> X().cached
+        -1
+        """
+        return 0
diff --git a/Lib/test/test_doctest/sample_doctest.py b/Lib/test/test_doctest/sample_doctest.py
new file mode 100644
index 0000000000..049f737a0a
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest.py
@@ -0,0 +1,76 @@
+"""This is a sample module that doesn't really test anything all that
+   interesting.
+
+It simply has a few tests, some of which succeed and some of which fail.
+
+It's important that the numbers remain constant as another test is
+testing the running of these tests.
+
+
+>>> 2+2
+4
+"""
+
+
+def foo():
+    """
+
+    >>> 2+2
+    5
+
+    >>> 2+2
+    4
+    """
+
+def bar():
+    """
+
+    >>> 2+2
+    4
+    """
+
+def test_silly_setup():
+    """
+
+    >>> import test.test_doctest.test_doctest
+    >>> test.test_doctest.test_doctest.sillySetup
+    True
+    """
+
+def w_blank():
+    """
+    >>> if 1:
+    ...    print('a')
+    ...    print()
+    ...    print('b')
+    a
+    <BLANKLINE>
+    b
+    """
+
+x = 1
+def x_is_one():
+    """
+    >>> x
+    1
+    """
+
+def y_is_one():
+    """
+    >>> y
+    1
+    """
+
+__test__ = {'good': """
+                    >>> 42
+                    42
+                    """,
+            'bad':  """
+                    >>> 42
+                    666
+                    """,
+           }
+
+def test_suite():
+    import doctest
+    return doctest.DocTestSuite()
diff --git a/Lib/test/test_doctest/sample_doctest_errors.py b/Lib/test/test_doctest/sample_doctest_errors.py
new file mode 100644
index 0000000000..4a6f07af2d
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_errors.py
@@ -0,0 +1,46 @@
+"""This is a sample module used for testing doctest.
+
+This module includes various scenarios involving errors.
+
+>>> 2 + 2
+5
+>>> 1/0
+1
+"""
+
+def g():
+    [][0] # line 12
+
+def errors():
+    """
+    >>> 2 + 2
+    5
+    >>> 1/0
+    1
+    >>> def f():
+    ...     2 + '2'
+    ...
+    >>> f()
+    1
+    >>> g()
+    1
+    """
+
+def syntax_error():
+    """
+    >>> 2+*3
+    5
+    """
+
+__test__ = {
+    'bad':  """
+        >>> 2 + 2
+        5
+        >>> 1/0
+        1
+        """,
+}
+
+def test_suite():
+    import doctest
+    return doctest.DocTestSuite()
diff --git a/Lib/test/test_doctest/sample_doctest_no_docstrings.py b/Lib/test/test_doctest/sample_doctest_no_docstrings.py
new file mode 100644
index 0000000000..e4201edbce
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_no_docstrings.py
@@ -0,0 +1,12 @@
+# This is a sample module used for testing doctest.
+#
+# This module is for testing how doctest handles a module with no
+# docstrings.
+
+
+class Foo(object):
+
+    # A class with no docstring.
+
+    def __init__(self):
+        pass
diff --git a/Lib/test/test_doctest/sample_doctest_no_doctests.py b/Lib/test/test_doctest/sample_doctest_no_doctests.py
new file mode 100644
index 0000000000..7daa57231c
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_no_doctests.py
@@ -0,0 +1,15 @@
+"""This is a sample module used for testing doctest.
+
+This module is for testing how doctest handles a module with docstrings
+but no doctest examples.
+
+"""
+
+
+class Foo(object):
+    """A docstring with no doctest examples.
+
+    """
+
+    def __init__(self):
+        pass
diff --git a/Lib/test/test_doctest/sample_doctest_skip.py b/Lib/test/test_doctest/sample_doctest_skip.py
new file mode 100644
index 0000000000..1b83dec1f8
--- /dev/null
+++ b/Lib/test/test_doctest/sample_doctest_skip.py
@@ -0,0 +1,49 @@
+"""This is a sample module used for testing doctest.
+
+This module includes various scenarios involving skips.
+"""
+
+def no_skip_pass():
+    """
+    >>> 2 + 2
+    4
+    """
+
+def no_skip_fail():
+    """
+    >>> 2 + 2
+    5
+    """
+
+def single_skip():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    """
+
+def double_skip():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 3 + 3  # doctest: +SKIP
+    6
+    """
+
+def partial_skip_pass():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 3 + 3
+    6
+    """
+
+def partial_skip_fail():
+    """
+    >>> 2 + 2  # doctest: +SKIP
+    4
+    >>> 2 + 2
+    5
+    """
+
+def no_examples():
+    """A docstring with no examples should not be counted as run or skipped."""
diff --git a/Lib/test/test_doctest/test_doctest.py b/Lib/test/test_doctest/test_doctest.py
new file mode 100644
index 0000000000..48d5ff6f73
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest.py
@@ -0,0 +1,4021 @@
+"""
+Test script for doctest.
+"""
+
+from test import support
+from test.support import import_helper
+from test.support.pty_helper import FakeInput  # used in doctests
+import doctest
+import functools
+import os
+import sys
+import importlib
+import importlib.abc
+import importlib.util
+import unittest
+import tempfile
+import types
+import contextlib
+import _colorize
+
+
+def doctest_skip_if(condition):
+    def decorator(func):
+        if condition and support.HAVE_DOCSTRINGS:
+            func.__doc__ = ">>> pass  # doctest: +SKIP"
+        return func
+    return decorator
+
+
+# NOTE: There are some additional tests relating to interaction with
+#       zipimport in the test_zipimport_support test module.
+# There are also related tests in `test_doctest2` module.
+
+######################################################################
+## Sample Objects (used by test cases)
+######################################################################
+
+def sample_func(v):
+    """
+    Blah blah
+
+    >>> print(sample_func(22))
+    44
+
+    Yee ha!
+    """
+    return v+v
+
+class SampleClass:
+    """
+    >>> print(1)
+    1
+
+    >>> # comments get ignored.  so are empty PS1 and PS2 prompts:
+    >>>
+    ...
+
+    Multiline example:
+    >>> sc = SampleClass(3)
+    >>> for i in range(10):
+    ...     sc = sc.double()
+    ...     print(' ', sc.get(), sep='', end='')
+     6 12 24 48 96 192 384 768 1536 3072
+    """
+    def __init__(self, val):
+        """
+        >>> print(SampleClass(12).get())
+        12
+        """
+        self.val = val
+
+    def double(self):
+        """
+        >>> print(SampleClass(12).double().get())
+        24
+        """
+        return SampleClass(self.val + self.val)
+
+    def get(self):
+        """
+        >>> print(SampleClass(-5).get())
+        -5
+        """
+        return self.val
+
+    def setter(self, val):
+        """
+        >>> s = SampleClass(-5)
+        >>> s.setter(1)
+        >>> print(s.val)
+        1
+        """
+        self.val = val
+
+    def a_staticmethod(v):
+        """
+        >>> print(SampleClass.a_staticmethod(10))
+        11
+        """
+        return v+1
+    a_staticmethod = staticmethod(a_staticmethod)
+
+    def a_classmethod(cls, v):
+        """
+        >>> print(SampleClass.a_classmethod(10))
+        12
+        >>> print(SampleClass(0).a_classmethod(10))
+        12
+        """
+        return v+2
+    a_classmethod = classmethod(a_classmethod)
+
+    a_property = property(get, setter, doc="""
+        >>> print(SampleClass(22).a_property)
+        22
+        """)
+
+    a_class_attribute = 42
+
+    @functools.cached_property
+    def a_cached_property(self):
+        """
+        >>> print(SampleClass(29).get())
+        29
+        """
+        return "hello"
+
+    class NestedClass:
+        """
+        >>> x = SampleClass.NestedClass(5)
+        >>> y = x.square()
+        >>> print(y.get())
+        25
+        """
+        def __init__(self, val=0):
+            """
+            >>> print(SampleClass.NestedClass().get())
+            0
+            """
+            self.val = val
+        def square(self):
+            return SampleClass.NestedClass(self.val*self.val)
+        def get(self):
+            return self.val
+
+class SampleNewStyleClass(object):
+    r"""
+    >>> print('1\n2\n3')
+    1
+    2
+    3
+    """
+    def __init__(self, val):
+        """
+        >>> print(SampleNewStyleClass(12).get())
+        12
+        """
+        self.val = val
+
+    def double(self):
+        """
+        >>> print(SampleNewStyleClass(12).double().get())
+        24
+        """
+        return SampleNewStyleClass(self.val + self.val)
+
+    def get(self):
+        """
+        >>> print(SampleNewStyleClass(-5).get())
+        -5
+        """
+        return self.val
+
+######################################################################
+## Test Cases
+######################################################################
+
+def test_Example(): r"""
+Unit tests for the `Example` class.
+
+Example is a simple container class that holds:
+  - `source`: A source string.
+  - `want`: An expected output string.
+  - `exc_msg`: An expected exception message string (or None if no
+    exception is expected).
+  - `lineno`: A line number (within the docstring).
+  - `indent`: The example's indentation in the input string.
+  - `options`: An option dictionary, mapping option flags to True or
+    False.
+
+These attributes are set by the constructor.  `source` and `want` are
+required; the other attributes all have default values:
+
+    >>> example = doctest.Example('print(1)', '1\n')
+    >>> (example.source, example.want, example.exc_msg,
+    ...  example.lineno, example.indent, example.options)
+    ('print(1)\n', '1\n', None, 0, 0, {})
+
+The first three attributes (`source`, `want`, and `exc_msg`) may be
+specified positionally; the remaining arguments should be specified as
+keyword arguments:
+
+    >>> exc_msg = 'IndexError: pop from an empty list'
+    >>> example = doctest.Example('[].pop()', '', exc_msg,
+    ...                           lineno=5, indent=4,
+    ...                           options={doctest.ELLIPSIS: True})
+    >>> (example.source, example.want, example.exc_msg,
+    ...  example.lineno, example.indent, example.options)
+    ('[].pop()\n', '', 'IndexError: pop from an empty list\n', 5, 4, {8: True})
+
+The constructor normalizes the `source` string to end in a newline:
+
+    Source spans a single line: no terminating newline.
+    >>> e = doctest.Example('print(1)', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print(1)\n', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    Source spans multiple lines: require terminating newline.
+    >>> e = doctest.Example('print(1);\nprint(2)\n', '1\n2\n')
+    >>> e.source, e.want
+    ('print(1);\nprint(2)\n', '1\n2\n')
+
+    >>> e = doctest.Example('print(1);\nprint(2)', '1\n2\n')
+    >>> e.source, e.want
+    ('print(1);\nprint(2)\n', '1\n2\n')
+
+    Empty source string (which should never appear in real examples)
+    >>> e = doctest.Example('', '')
+    >>> e.source, e.want
+    ('\n', '')
+
+The constructor normalizes the `want` string to end in a newline,
+unless it's the empty string:
+
+    >>> e = doctest.Example('print(1)', '1\n')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print(1)', '1')
+    >>> e.source, e.want
+    ('print(1)\n', '1\n')
+
+    >>> e = doctest.Example('print', '')
+    >>> e.source, e.want
+    ('print\n', '')
+
+The constructor normalizes the `exc_msg` string to end in a newline,
+unless it's `None`:
+
+    Message spans one line
+    >>> exc_msg = 'IndexError: pop from an empty list'
+    >>> e = doctest.Example('[].pop()', '', exc_msg)
+    >>> e.exc_msg
+    'IndexError: pop from an empty list\n'
+
+    >>> exc_msg = 'IndexError: pop from an empty list\n'
+    >>> e = doctest.Example('[].pop()', '', exc_msg)
+    >>> e.exc_msg
+    'IndexError: pop from an empty list\n'
+
+    Message spans multiple lines
+    >>> exc_msg = 'ValueError: 1\n  2'
+    >>> e = doctest.Example('raise ValueError("1\n  2")', '', exc_msg)
+    >>> e.exc_msg
+    'ValueError: 1\n  2\n'
+
+    >>> exc_msg = 'ValueError: 1\n  2\n'
+    >>> e = doctest.Example('raise ValueError("1\n  2")', '', exc_msg)
+    >>> e.exc_msg
+    'ValueError: 1\n  2\n'
+
+    Empty (but non-None) exception message (which should never appear
+    in real examples)
+    >>> exc_msg = ''
+    >>> e = doctest.Example('raise X()', '', exc_msg)
+    >>> e.exc_msg
+    '\n'
+
+Compare `Example`:
+    >>> example = doctest.Example('print 1', '1\n')
+    >>> same_example = doctest.Example('print 1', '1\n')
+    >>> other_example = doctest.Example('print 42', '42\n')
+    >>> example == same_example
+    True
+    >>> example != same_example
+    False
+    >>> hash(example) == hash(same_example)
+    True
+    >>> example == other_example
+    False
+    >>> example != other_example
+    True
+"""
+
+def test_DocTest(): r"""
+Unit tests for the `DocTest` class.
+
+DocTest is a collection of examples, extracted from a docstring, along
+with information about where the docstring comes from (a name,
+filename, and line number).  The docstring is parsed by the `DocTest`
+constructor:
+
+    >>> docstring = '''
+    ...     >>> print(12)
+    ...     12
+    ...
+    ... Non-example text.
+    ...
+    ...     >>> print('another\\example')
+    ...     another
+    ...     example
+    ... '''
+    >>> globs = {} # globals to run the test in.
+    >>> parser = doctest.DocTestParser()
+    >>> test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                           'some_file', 20)
+    >>> print(test)
+    <DocTest some_test from some_file:20 (2 examples)>
+    >>> len(test.examples)
+    2
+    >>> e1, e2 = test.examples
+    >>> (e1.source, e1.want, e1.lineno)
+    ('print(12)\n', '12\n', 1)
+    >>> (e2.source, e2.want, e2.lineno)
+    ("print('another\\example')\n", 'another\nexample\n', 6)
+
+Source information (name, filename, and line number) is available as
+attributes on the doctest object:
+
+    >>> (test.name, test.filename, test.lineno)
+    ('some_test', 'some_file', 20)
+
+The line number of an example within its containing file is found by
+adding the line number of the example and the line number of its
+containing test:
+
+    >>> test.lineno + e1.lineno
+    21
+    >>> test.lineno + e2.lineno
+    26
+
+If the docstring contains inconsistent leading whitespace in the
+expected output of an example, then `DocTest` will raise a ValueError:
+
+    >>> docstring = r'''
+    ...       >>> print('bad\nindentation')
+    ...       bad
+    ...     indentation
+    ...     '''
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 4 of the docstring for some_test has inconsistent leading whitespace: 'indentation'
+
+If the docstring contains inconsistent leading whitespace on
+continuation lines, then `DocTest` will raise a ValueError:
+
+    >>> docstring = r'''
+    ...       >>> print(('bad indentation',
+    ...     ...          2))
+    ...       ('bad', 'indentation')
+    ...     '''
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 2 of the docstring for some_test has inconsistent leading whitespace: '...          2))'
+
+If there's no blank space after a PS1 prompt ('>>>'), then `DocTest`
+will raise a ValueError:
+
+    >>> docstring = '>>>print(1)\n1'
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the docstring for some_test lacks blank after >>>: '>>>print(1)'
+
+If there's no blank space after a PS2 prompt ('...'), then `DocTest`
+will raise a ValueError:
+
+    >>> docstring = '>>> if 1:\n...print(1)\n1'
+    >>> parser.get_doctest(docstring, globs, 'some_test', 'filename', 0)
+    Traceback (most recent call last):
+    ValueError: line 2 of the docstring for some_test lacks blank after ...: '...print(1)'
+
+Compare `DocTest`:
+
+    >>> docstring = '''
+    ...     >>> print 12
+    ...     12
+    ... '''
+    >>> test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                           'some_test', 20)
+    >>> same_test = parser.get_doctest(docstring, globs, 'some_test',
+    ...                                'some_test', 20)
+    >>> test == same_test
+    True
+    >>> test != same_test
+    False
+    >>> hash(test) == hash(same_test)
+    True
+    >>> docstring = '''
+    ...     >>> print 42
+    ...     42
+    ... '''
+    >>> other_test = parser.get_doctest(docstring, globs, 'other_test',
+    ...                                 'other_file', 10)
+    >>> test == other_test
+    False
+    >>> test != other_test
+    True
+    >>> test < other_test
+    False
+    >>> other_test < test
+    True
+
+Test comparison with lineno None on one side
+
+    >>> no_lineno = parser.get_doctest(docstring, globs, 'some_test',
+    ...                               'some_test', None)
+    >>> test.lineno is None
+    False
+    >>> no_lineno.lineno is None
+    True
+    >>> test < no_lineno
+    False
+    >>> no_lineno < test
+    True
+
+Compare `DocTestCase`:
+
+    >>> DocTestCase = doctest.DocTestCase
+    >>> test_case = DocTestCase(test)
+    >>> same_test_case = DocTestCase(same_test)
+    >>> other_test_case = DocTestCase(other_test)
+    >>> test_case == same_test_case
+    True
+    >>> test_case != same_test_case
+    False
+    >>> hash(test_case) == hash(same_test_case)
+    True
+    >>> test == other_test_case
+    False
+    >>> test != other_test_case
+    True
+
+"""
+
+class test_DocTestFinder:
+    def basics(): r"""
+Unit tests for the `DocTestFinder` class.
+
+DocTestFinder is used to extract DocTests from an object's docstring
+and the docstrings of its contained objects.  It can be used with
+modules, functions, classes, methods, staticmethods, classmethods, and
+properties.
+
+Finding Tests in Functions
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+For a function whose docstring contains examples, DocTestFinder.find()
+will return a single test (for that function's docstring):
+
+    >>> finder = doctest.DocTestFinder()
+
+We'll simulate a __file__ attr that ends in pyc:
+
+    >>> from test.test_doctest import test_doctest
+    >>> old = test_doctest.__file__
+    >>> test_doctest.__file__ = 'test_doctest.pyc'
+
+    >>> tests = finder.find(sample_func)
+
+    >>> print(tests)  # doctest: +ELLIPSIS
+    [<DocTest sample_func from test_doctest.py:38 (1 example)>]
+
+The exact name depends on how test_doctest was invoked, so allow for
+leading path components.
+
+    >>> tests[0].filename # doctest: +ELLIPSIS
+    '...test_doctest.py'
+
+    >>> test_doctest.__file__ = old
+
+
+    >>> e = tests[0].examples[0]
+    >>> (e.source, e.want, e.lineno)
+    ('print(sample_func(22))\n', '44\n', 3)
+
+By default, tests are created for objects with no docstring:
+
+    >>> def no_docstring(v):
+    ...     pass
+    >>> finder.find(no_docstring)
+    []
+
+However, the optional argument `exclude_empty` to the DocTestFinder
+constructor can be used to exclude tests for objects with empty
+docstrings:
+
+    >>> def no_docstring(v):
+    ...     pass
+    >>> excl_empty_finder = doctest.DocTestFinder(exclude_empty=True)
+    >>> excl_empty_finder.find(no_docstring)
+    []
+
+If the function has a docstring with no examples, then a test with no
+examples is returned.  (This lets `DocTestRunner` collect statistics
+about which functions have no tests -- but is that useful?  And should
+an empty test also be created when there's no docstring?)
+
+    >>> def no_examples(v):
+    ...     ''' no doctest examples '''
+    >>> finder.find(no_examples) # doctest: +ELLIPSIS
+    [<DocTest no_examples from ...:1 (no examples)>]
+
+Finding Tests in Classes
+~~~~~~~~~~~~~~~~~~~~~~~~
+For a class, DocTestFinder will create a test for the class's
+docstring, and will recursively explore its contents, including
+methods, classmethods, staticmethods, properties, and nested classes.
+
+    >>> finder = doctest.DocTestFinder()
+    >>> tests = finder.find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+New-style classes are also supported:
+
+    >>> tests = finder.find(SampleNewStyleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     1  SampleNewStyleClass
+     1  SampleNewStyleClass.__init__
+     1  SampleNewStyleClass.double
+     1  SampleNewStyleClass.get
+
+Finding Tests in Modules
+~~~~~~~~~~~~~~~~~~~~~~~~
+For a module, DocTestFinder will create a test for the class's
+docstring, and will recursively explore its contents, including
+functions, classes, and the `__test__` dictionary, if it exists:
+
+    >>> # A module
+    >>> import types
+    >>> m = types.ModuleType('some_module')
+    >>> def triple(val):
+    ...     '''
+    ...     >>> print(triple(11))
+    ...     33
+    ...     '''
+    ...     return val*3
+    >>> m.__dict__.update({
+    ...     'sample_func': sample_func,
+    ...     'SampleClass': SampleClass,
+    ...     '__doc__': '''
+    ...         Module docstring.
+    ...             >>> print('module')
+    ...             module
+    ...         ''',
+    ...     '__test__': {
+    ...         'd': '>>> print(6)\n6\n>>> print(7)\n7\n',
+    ...         'c': triple}})
+
+    >>> finder = doctest.DocTestFinder()
+    >>> # Use module=test_doctest, to prevent doctest from
+    >>> # ignoring the objects since they weren't defined in m.
+    >>> from test.test_doctest import test_doctest
+    >>> tests = finder.find(m, module=test_doctest)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     1  some_module
+     3  some_module.SampleClass
+     3  some_module.SampleClass.NestedClass
+     1  some_module.SampleClass.NestedClass.__init__
+     1  some_module.SampleClass.__init__
+     1  some_module.SampleClass.a_cached_property
+     2  some_module.SampleClass.a_classmethod
+     1  some_module.SampleClass.a_property
+     1  some_module.SampleClass.a_staticmethod
+     1  some_module.SampleClass.double
+     1  some_module.SampleClass.get
+     3  some_module.SampleClass.setter
+     1  some_module.__test__.c
+     2  some_module.__test__.d
+     1  some_module.sample_func
+
+However, doctest will ignore imported objects from other modules
+(without proper `module=`):
+
+    >>> import types
+    >>> m = types.ModuleType('poluted_namespace')
+    >>> m.__dict__.update({
+    ...     'sample_func': sample_func,
+    ...     'SampleClass': SampleClass,
+    ... })
+
+    >>> finder = doctest.DocTestFinder()
+    >>> finder.find(m)
+    []
+
+Duplicate Removal
+~~~~~~~~~~~~~~~~~
+If a single object is listed twice (under different names), then tests
+will only be generated for it once:
+
+    >>> from test.test_doctest import doctest_aliases
+    >>> assert doctest_aliases.TwoNames.f
+    >>> assert doctest_aliases.TwoNames.g
+    >>> tests = excl_empty_finder.find(doctest_aliases)
+    >>> print(len(tests))
+    2
+    >>> print(tests[0].name)
+    test.test_doctest.doctest_aliases.TwoNames
+
+    TwoNames.f and TwoNames.g are bound to the same object.
+    We can't guess which will be found in doctest's traversal of
+    TwoNames.__dict__ first, so we have to allow for either.
+
+    >>> tests[1].name.split('.')[-1] in ['f', 'g']
+    True
+
+Empty Tests
+~~~~~~~~~~~
+By default, an object with no doctests doesn't create any tests:
+
+    >>> tests = doctest.DocTestFinder().find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+By default, that excluded objects with no doctests.  exclude_empty=False
+tells it to include (empty) tests for objects with no doctests.  This feature
+is really to support backward compatibility in what doctest.master.summarize()
+displays.
+
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+     3  SampleClass.NestedClass
+     1  SampleClass.NestedClass.__init__
+     0  SampleClass.NestedClass.get
+     0  SampleClass.NestedClass.square
+     1  SampleClass.__init__
+     1  SampleClass.a_cached_property
+     2  SampleClass.a_classmethod
+     1  SampleClass.a_property
+     1  SampleClass.a_staticmethod
+     1  SampleClass.double
+     1  SampleClass.get
+     3  SampleClass.setter
+
+When used with `exclude_empty=False` we are also interested in line numbers
+of doctests that are empty.
+It used to be broken for quite some time until `bpo-28249`.
+
+    >>> from test.test_doctest import doctest_lineno
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(doctest_lineno)
+    >>> for t in tests:
+    ...     print('%5s  %s' % (t.lineno, t.name))
+     None  test.test_doctest.doctest_lineno
+     None  test.test_doctest.doctest_lineno.ClassWithACachedProperty
+      102  test.test_doctest.doctest_lineno.ClassWithACachedProperty.cached
+       22  test.test_doctest.doctest_lineno.ClassWithDocstring
+       30  test.test_doctest.doctest_lineno.ClassWithDoctest
+     None  test.test_doctest.doctest_lineno.ClassWithoutDocstring
+     None  test.test_doctest.doctest_lineno.MethodWrapper
+       53  test.test_doctest.doctest_lineno.MethodWrapper.classmethod_with_doctest
+       39  test.test_doctest.doctest_lineno.MethodWrapper.method_with_docstring
+       45  test.test_doctest.doctest_lineno.MethodWrapper.method_with_doctest
+     None  test.test_doctest.doctest_lineno.MethodWrapper.method_without_docstring
+       61  test.test_doctest.doctest_lineno.MethodWrapper.property_with_doctest
+       86  test.test_doctest.doctest_lineno.cached_func_with_doctest
+     None  test.test_doctest.doctest_lineno.cached_func_without_docstring
+        4  test.test_doctest.doctest_lineno.func_with_docstring
+       77  test.test_doctest.doctest_lineno.func_with_docstring_wrapped
+       12  test.test_doctest.doctest_lineno.func_with_doctest
+     None  test.test_doctest.doctest_lineno.func_without_docstring
+
+Turning off Recursion
+~~~~~~~~~~~~~~~~~~~~~
+DocTestFinder can be told not to look for tests in contained objects
+using the `recurse` flag:
+
+    >>> tests = doctest.DocTestFinder(recurse=False).find(SampleClass)
+    >>> for t in tests:
+    ...     print('%2s  %s' % (len(t.examples), t.name))
+     3  SampleClass
+
+Line numbers
+~~~~~~~~~~~~
+DocTestFinder finds the line number of each example:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...
+    ...     some text
+    ...
+    ...     >>> # examples are not created for comments & bare prompts.
+    ...     >>>
+    ...     ...
+    ...
+    ...     >>> for x in range(10):
+    ...     ...     print(x, end=' ')
+    ...     0 1 2 3 4 5 6 7 8 9
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> [e.lineno for e in test.examples]
+    [1, 9, 12]
+"""
+
+# TODO: RUSTPYTHON
+# Currently, only 5 builtins types exist in RustPython
+# So this test will fail
+#     if int.__doc__: # simple check for --without-doc-strings, skip if lacking
+#         def non_Python_modules(): r"""
+
+# Finding Doctests in Modules Not Written in Python
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# DocTestFinder can also find doctests in most modules not written in Python.
+# We'll use builtins as an example, since it almost certainly isn't written in
+# plain ol' Python and is guaranteed to be available.
+
+#     >>> import builtins
+#     >>> tests = doctest.DocTestFinder().find(builtins)
+#     >>> 830 < len(tests) < 860 # approximate number of objects with docstrings
+#     True
+#     >>> real_tests = [t for t in tests if len(t.examples) > 0]
+#     >>> len(real_tests) # objects that actually have doctests
+#     14
+#     >>> for t in real_tests:
+#     ...     print('{}  {}'.format(len(t.examples), t.name))
+#     ...
+#     1  builtins.bin
+#     5  builtins.bytearray.hex
+#     5  builtins.bytes.hex
+#     3  builtins.float.as_integer_ratio
+#     2  builtins.float.fromhex
+#     2  builtins.float.hex
+#     1  builtins.hex
+#     1  builtins.int
+#     3  builtins.int.as_integer_ratio
+#     2  builtins.int.bit_count
+#     2  builtins.int.bit_length
+#     5  builtins.memoryview.hex
+#     1  builtins.oct
+#     1  builtins.zip
+
+# Note here that 'bin', 'oct', and 'hex' are functions; 'float.as_integer_ratio',
+# 'float.hex', and 'int.bit_length' are methods; 'float.fromhex' is a classmethod,
+# and 'int' is a type.
+# """
+
+
+class TestDocTest(unittest.TestCase):
+
+    def test_run(self):
+        test = '''
+            >>> 1 + 1
+            11
+            >>> 2 + 3      # doctest: +SKIP
+            "23"
+            >>> 5 + 7
+            57
+        '''
+
+        def myfunc():
+            pass
+        myfunc.__doc__ = test
+
+        # test DocTestFinder.run()
+        test = doctest.DocTestFinder().find(myfunc)[0]
+        with support.captured_stdout():
+            with support.captured_stderr():
+                results = doctest.DocTestRunner(verbose=False).run(test)
+
+        # test TestResults
+        self.assertIsInstance(results, doctest.TestResults)
+        self.assertEqual(results.failed, 2)
+        self.assertEqual(results.attempted, 3)
+        self.assertEqual(results.skipped, 1)
+        self.assertEqual(tuple(results), (2, 3))
+        x, y = results
+        self.assertEqual((x, y), (2, 3))
+
+
+class TestDocTestFinder(unittest.TestCase):
+
+    def test_issue35753(self):
+        # This import of `call` should trigger issue35753 when
+        # DocTestFinder.find() is called due to inspect.unwrap() failing,
+        # however with a patched doctest this should succeed.
+        from unittest.mock import call
+        dummy_module = types.ModuleType("dummy")
+        dummy_module.__dict__['inject_call'] = call
+        finder = doctest.DocTestFinder()
+        self.assertEqual(finder.find(dummy_module), [])
+
+    def test_empty_namespace_package(self):
+        pkg_name = 'doctest_empty_pkg'
+        with tempfile.TemporaryDirectory() as parent_dir:
+            pkg_dir = os.path.join(parent_dir, pkg_name)
+            os.mkdir(pkg_dir)
+            sys.path.append(parent_dir)
+            try:
+                mod = importlib.import_module(pkg_name)
+            finally:
+                import_helper.forget(pkg_name)
+                sys.path.pop()
+
+            include_empty_finder = doctest.DocTestFinder(exclude_empty=False)
+            exclude_empty_finder = doctest.DocTestFinder(exclude_empty=True)
+
+            self.assertEqual(len(include_empty_finder.find(mod)), 1)
+            self.assertEqual(len(exclude_empty_finder.find(mod)), 0)
+
+def test_DocTestParser(): r"""
+Unit tests for the `DocTestParser` class.
+
+DocTestParser is used to parse docstrings containing doctest examples.
+
+The `parse` method divides a docstring into examples and intervening
+text:
+
+    >>> s = '''
+    ...     >>> x, y = 2, 3  # no output expected
+    ...     >>> if 1:
+    ...     ...     print(x)
+    ...     ...     print(y)
+    ...     2
+    ...     3
+    ...
+    ...     Some text.
+    ...     >>> x+y
+    ...     5
+    ...     '''
+    >>> parser = doctest.DocTestParser()
+    >>> for piece in parser.parse(s):
+    ...     if isinstance(piece, doctest.Example):
+    ...         print('Example:', (piece.source, piece.want, piece.lineno))
+    ...     else:
+    ...         print('   Text:', repr(piece))
+       Text: '\n'
+    Example: ('x, y = 2, 3  # no output expected\n', '', 1)
+       Text: ''
+    Example: ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+       Text: '\nSome text.\n'
+    Example: ('x+y\n', '5\n', 9)
+       Text: ''
+
+The `get_examples` method returns just the examples:
+
+    >>> for piece in parser.get_examples(s):
+    ...     print((piece.source, piece.want, piece.lineno))
+    ('x, y = 2, 3  # no output expected\n', '', 1)
+    ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+    ('x+y\n', '5\n', 9)
+
+The `get_doctest` method creates a Test from the examples, along with the
+given arguments:
+
+    >>> test = parser.get_doctest(s, {}, 'name', 'filename', lineno=5)
+    >>> (test.name, test.filename, test.lineno)
+    ('name', 'filename', 5)
+    >>> for piece in test.examples:
+    ...     print((piece.source, piece.want, piece.lineno))
+    ('x, y = 2, 3  # no output expected\n', '', 1)
+    ('if 1:\n    print(x)\n    print(y)\n', '2\n3\n', 2)
+    ('x+y\n', '5\n', 9)
+"""
+
+class test_DocTestRunner:
+    def basics(): r"""
+Unit tests for the `DocTestRunner` class.
+
+DocTestRunner is used to run DocTest test cases, and to accumulate
+statistics.  Here's a simple DocTest case we can use:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     12
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+
+The main DocTestRunner interface is the `run` method, which runs a
+given DocTest case in a given namespace (globs).  It returns a tuple
+`(f,t)`, where `f` is the number of failed tests and `t` is the number
+of tried tests.
+
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=3)
+
+If any example produces incorrect output, then the test runner reports
+the failure and proceeds to the next example:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     14
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=True).run(test)
+    ... # doctest: +ELLIPSIS
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        14
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        print(x)
+    Expected:
+        14
+    Got:
+        12
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=1, attempted=3)
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+    def verbose_flag(): r"""
+The `verbose` flag makes the test runner generate more detailed
+output:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x)
+    ...     12
+    ...     >>> x//2
+    ...     6
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+
+    >>> doctest.DocTestRunner(verbose=True).run(test)
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        12
+    ok
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=0, attempted=3)
+
+If the `verbose` flag is unspecified, then the output will be verbose
+iff `-v` appears in sys.argv:
+
+    >>> # Save the real sys.argv list.
+    >>> old_argv = sys.argv
+
+    >>> # If -v does not appear in sys.argv, then output isn't verbose.
+    >>> sys.argv = ['test']
+    >>> doctest.DocTestRunner().run(test)
+    TestResults(failed=0, attempted=3)
+
+    >>> # If -v does appear in sys.argv, then output is verbose.
+    >>> sys.argv = ['test', '-v']
+    >>> doctest.DocTestRunner().run(test)
+    Trying:
+        x = 12
+    Expecting nothing
+    ok
+    Trying:
+        print(x)
+    Expecting:
+        12
+    ok
+    Trying:
+        x//2
+    Expecting:
+        6
+    ok
+    TestResults(failed=0, attempted=3)
+
+    >>> # Restore sys.argv
+    >>> sys.argv = old_argv
+
+In the remaining examples, the test runner's verbosity will be
+explicitly set, to ensure that the test behavior is consistent.
+    """
+    def exceptions(): r"""
+Tests of `DocTestRunner`'s exception handling.
+
+An expected exception is specified with a traceback message.  The
+lines between the first line and the type/value may be omitted or
+replaced with any other string:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print(x//0)
+    ...     Traceback (most recent call last):
+    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+An example may not generate output before it raises an exception; if
+it does, then the traceback message will not be recognized as
+signaling an expected exception, so the example will be reported as an
+unexpected exception:
+
+    >>> def f(x):
+    ...     '''
+    ...     >>> x = 12
+    ...     >>> print('pre-exception output', x//0)
+    ...     pre-exception output
+    ...     Traceback (most recent call last):
+    ...     ZeroDivisionError: integer division or modulo by zero
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        print('pre-exception output', x//0)
+    Exception raised:
+        ...
+        ZeroDivisionError: integer division or modulo by zero
+    TestResults(failed=1, attempted=2)
+
+Exception messages may contain newlines:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('multi\nline\nmessage')
+    ...     Traceback (most recent call last):
+    ...     ValueError: multi
+    ...     line
+    ...     message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+If an exception is expected, but an exception with the wrong type or
+message is raised, then it is reported as a failure:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message')
+    ...     Traceback (most recent call last):
+    ...     ValueError: wrong message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        raise ValueError('message')
+    Expected:
+        Traceback (most recent call last):
+        ValueError: wrong message
+    Got:
+        Traceback (most recent call last):
+        ...
+        ValueError: message
+    TestResults(failed=1, attempted=1)
+
+However, IGNORE_EXCEPTION_DETAIL can be used to allow a mismatch in the
+detail:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     ValueError: wrong message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+IGNORE_EXCEPTION_DETAIL also ignores difference in exception formatting
+between Python versions. For example, in Python 2.x, the module path of
+the exception is not in the output, but this will fail under Python 3:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message')
+    ...     Traceback (most recent call last):
+    ...     HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        raise HTTPException('message')
+    Expected:
+        Traceback (most recent call last):
+        HTTPException: message
+    Got:
+        Traceback (most recent call last):
+        ...
+        http.client.HTTPException: message
+    TestResults(failed=1, attempted=2)
+
+But in Python 3 the module path is included, and therefore a test must look
+like the following test to succeed in Python 3. But that test will fail under
+Python 2.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message')
+    ...     Traceback (most recent call last):
+    ...     http.client.HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+However, with IGNORE_EXCEPTION_DETAIL, the module name of the exception
+(or its unexpected absence) will be ignored:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+The module path will be completely ignored, so two different module paths will
+still pass if IGNORE_EXCEPTION_DETAIL is given. This is intentional, so it can
+be used when exceptions have changed module.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException: message
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+But IGNORE_EXCEPTION_DETAIL does not allow a mismatch in the exception type:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     TypeError: wrong type
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        raise ValueError('message') #doctest: +IGNORE_EXCEPTION_DETAIL
+    Expected:
+        Traceback (most recent call last):
+        TypeError: wrong type
+    Got:
+        Traceback (most recent call last):
+        ...
+        ValueError: message
+    TestResults(failed=1, attempted=1)
+
+If the exception does not have a message, you can still use
+IGNORE_EXCEPTION_DETAIL to normalize the modules between Python 2 and 3:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException() #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+Note that a trailing colon doesn't matter either:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> from http.client import HTTPException
+    ...     >>> raise HTTPException() #doctest: +IGNORE_EXCEPTION_DETAIL
+    ...     Traceback (most recent call last):
+    ...     foo.bar.HTTPException:
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+If an exception is raised but not expected, then it is reported as an
+unexpected exception:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> 1//0
+    ...     0
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        1//0
+    Exception raised:
+        Traceback (most recent call last):
+        ...
+        ZeroDivisionError: integer division or modulo by zero
+    TestResults(failed=1, attempted=1)
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+    def displayhook(): r"""
+Test that changing sys.displayhook doesn't matter for doctest.
+
+    >>> import sys
+    >>> orig_displayhook = sys.displayhook
+    >>> def my_displayhook(x):
+    ...     print('hi!')
+    >>> sys.displayhook = my_displayhook
+    >>> def f():
+    ...     '''
+    ...     >>> 3
+    ...     3
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> r = doctest.DocTestRunner(verbose=False).run(test)
+    >>> post_displayhook = sys.displayhook
+
+    We need to restore sys.displayhook now, so that we'll be able to test
+    results.
+
+    >>> sys.displayhook = orig_displayhook
+
+    Ok, now we can check that everything is ok.
+
+    >>> r
+    TestResults(failed=0, attempted=1)
+    >>> post_displayhook is my_displayhook
+    True
+"""
+    def optionflags(): r"""
+Tests of `DocTestRunner`'s option flag handling.
+
+Several option flags can be used to customize the behavior of the test
+runner.  These are defined as module constants in doctest, and passed
+to the DocTestRunner constructor (multiple constants should be ORed
+together).
+
+The DONT_ACCEPT_TRUE_FOR_1 flag disables matches between True/False
+and 1/0:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     '>>> True\n1\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.DONT_ACCEPT_TRUE_FOR_1
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        True
+    Expected:
+        1
+    Got:
+        True
+    TestResults(failed=1, attempted=1)
+
+The DONT_ACCEPT_BLANKLINE flag disables the match between blank lines
+and the '<BLANKLINE>' marker:
+
+    >>> def f(x):
+    ...     '>>> print("a\\n\\nb")\na\n<BLANKLINE>\nb\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.DONT_ACCEPT_BLANKLINE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print("a\n\nb")
+    Expected:
+        a
+        <BLANKLINE>
+        b
+    Got:
+        a
+    <BLANKLINE>
+        b
+    TestResults(failed=1, attempted=1)
+
+The NORMALIZE_WHITESPACE flag causes all sequences of whitespace to be
+treated as equal:
+
+    >>> def f(x):
+    ...     '\n>>> print(1, 2, 3)\n  1   2\n 3'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print(1, 2, 3)
+    Expected:
+          1   2
+         3
+    Got:
+        1 2 3
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.NORMALIZE_WHITESPACE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    TestResults(failed=0, attempted=1)
+
+    An example from the docs:
+    >>> print(list(range(20))) #doctest: +NORMALIZE_WHITESPACE
+    [0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
+    10,  11, 12, 13, 14, 15, 16, 17, 18, 19]
+
+The ELLIPSIS flag causes ellipsis marker ("...") in the expected
+output to match any substring in the actual output:
+
+    >>> def f(x):
+    ...     '>>> print(list(range(15)))\n[0, 1, 2, ..., 14]\n'
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(15)))
+    Expected:
+        [0, 1, 2, ..., 14]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.ELLIPSIS
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    TestResults(failed=0, attempted=1)
+
+    ... also matches nothing:
+
+    >>> if 1:
+    ...     for i in range(100):
+    ...         print(i**2, end=' ') #doctest: +ELLIPSIS
+    ...     print('!')
+    0 1...4...9 16 ... 36 49 64 ... 9801 !
+
+    ... can be surprising; e.g., this test passes:
+
+    >>> if 1:  #doctest: +ELLIPSIS
+    ...     for i in range(20):
+    ...         print(i, end=' ')
+    ...     print(20)
+    0 1 2 ...1...2...0
+
+    Examples from the docs:
+
+    >>> print(list(range(20))) # doctest:+ELLIPSIS
+    [0, 1, ..., 18, 19]
+
+    >>> print(list(range(20))) # doctest: +ELLIPSIS
+    ...                 # doctest: +NORMALIZE_WHITESPACE
+    [0,    1, ...,   18,    19]
+
+The SKIP flag causes an example to be skipped entirely.  I.e., the
+example is not run.  It can be useful in contexts where doctest
+examples serve as both documentation and test cases, and an example
+should be included for documentation purposes, but should not be
+checked (e.g., because its output is random, or depends on resources
+which would be unavailable.)  The SKIP flag can also be used for
+'commenting out' broken examples.
+
+    >>> import unavailable_resource           # doctest: +SKIP
+    >>> unavailable_resource.do_something()   # doctest: +SKIP
+    >>> unavailable_resource.blow_up()        # doctest: +SKIP
+    Traceback (most recent call last):
+        ...
+    UncheckedBlowUpError:  Nobody checks me.
+
+    >>> import random
+    >>> print(random.random()) # doctest: +SKIP
+    0.721216923889
+
+The REPORT_UDIFF flag causes failures that involve multi-line expected
+and actual outputs to be displayed using a unified diff:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print('\n'.join('abcdefg'))
+    ...     a
+    ...     B
+    ...     c
+    ...     d
+    ...     f
+    ...     g
+    ...     h
+    ...     '''
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Expected:
+        a
+        B
+        c
+        d
+        f
+        g
+        h
+    Got:
+        a
+        b
+        c
+        d
+        e
+        f
+        g
+    TestResults(failed=1, attempted=1)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_UDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Differences (unified diff with -expected +actual):
+        @@ -1,7 +1,7 @@
+         a
+        -B
+        +b
+         c
+         d
+        +e
+         f
+         g
+        -h
+    TestResults(failed=1, attempted=1)
+
+The REPORT_CDIFF flag causes failures that involve multi-line expected
+and actual outputs to be displayed using a context diff:
+
+    >>> # Reuse f() from the REPORT_UDIFF example, above.
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_CDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join('abcdefg'))
+    Differences (context diff with expected followed by actual):
+        ***************
+        *** 1,7 ****
+          a
+        ! B
+          c
+          d
+          f
+          g
+        - h
+        --- 1,7 ----
+          a
+        ! b
+          c
+          d
+        + e
+          f
+          g
+    TestResults(failed=1, attempted=1)
+
+
+The REPORT_NDIFF flag causes failures to use the difflib.Differ algorithm
+used by the popular ndiff.py utility.  This does intraline difference
+marking, as well as interline differences.
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print("a b  c d e f g h i   j k l m")
+    ...     a b c d e f g h i j k 1 m
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_NDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print("a b  c d e f g h i   j k l m")
+    Differences (ndiff with -expected +actual):
+        - a b c d e f g h i j k 1 m
+        ?                       ^
+        + a b  c d e f g h i   j k l m
+        ?     +              ++    ^
+    TestResults(failed=1, attempted=1)
+
+The REPORT_ONLY_FIRST_FAILURE suppresses result output after the first
+failing example:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print(1) # first success
+    ...     1
+    ...     >>> print(2) # first failure
+    ...     200
+    ...     >>> print(3) # second failure
+    ...     300
+    ...     >>> print(4) # second success
+    ...     4
+    ...     >>> print(5) # third failure
+    ...     500
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=3, attempted=5)
+
+However, output from `report_start` is not suppressed:
+
+    >>> doctest.DocTestRunner(verbose=True, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    Trying:
+        print(1) # first success
+    Expecting:
+        1
+    ok
+    Trying:
+        print(2) # first failure
+    Expecting:
+        200
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=3, attempted=5)
+
+The FAIL_FAST flag causes the runner to exit after the first failing example,
+so subsequent examples are not even attempted:
+
+    >>> flags = doctest.FAIL_FAST
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=1, attempted=2)
+
+Specifying both FAIL_FAST and REPORT_ONLY_FIRST_FAILURE is equivalent to
+FAIL_FAST only:
+
+    >>> flags = doctest.FAIL_FAST | doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        print(2) # first failure
+    Expected:
+        200
+    Got:
+        2
+    TestResults(failed=1, attempted=2)
+
+For the purposes of both REPORT_ONLY_FIRST_FAILURE and FAIL_FAST, unexpected
+exceptions count as failures:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print(1) # first success
+    ...     1
+    ...     >>> raise ValueError(2) # first failure
+    ...     200
+    ...     >>> print(3) # second failure
+    ...     300
+    ...     >>> print(4) # second success
+    ...     4
+    ...     >>> print(5) # third failure
+    ...     500
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_ONLY_FIRST_FAILURE
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        raise ValueError(2) # first failure
+    Exception raised:
+        ...
+        ValueError: 2
+    TestResults(failed=3, attempted=5)
+    >>> flags = doctest.FAIL_FAST
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 5, in f
+    Failed example:
+        raise ValueError(2) # first failure
+    Exception raised:
+        ...
+        ValueError: 2
+    TestResults(failed=1, attempted=2)
+
+New option flags can also be registered, via register_optionflag().  Here
+we reach into doctest's internals a bit.
+
+    >>> unlikely = "UNLIKELY_OPTION_NAME"
+    >>> unlikely in doctest.OPTIONFLAGS_BY_NAME
+    False
+    >>> new_flag_value = doctest.register_optionflag(unlikely)
+    >>> unlikely in doctest.OPTIONFLAGS_BY_NAME
+    True
+
+Before 2.4.4/2.5, registering a name more than once erroneously created
+more than one flag value.  Here we verify that's fixed:
+
+    >>> redundant_flag_value = doctest.register_optionflag(unlikely)
+    >>> redundant_flag_value == new_flag_value
+    True
+
+Clean up.
+    >>> del doctest.OPTIONFLAGS_BY_NAME[unlikely]
+    >>> _colorize.COLORIZE = save_colorize
+
+    """
+
+    def option_directives(): r"""
+Tests of `DocTestRunner`'s option directive mechanism.
+
+Option directives can be used to turn option flags on or off for a
+single example.  To turn an option on for an example, follow that
+example with a comment of the form ``# doctest: +OPTION``:
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+To turn an option off for an example, follow that example with a
+comment of the form ``# doctest: -OPTION``:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> # should fail: no ellipsis
+    ...     >>> print(list(range(10)))      # doctest: -ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False,
+    ...                       optionflags=doctest.ELLIPSIS).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 6, in f
+    Failed example:
+        print(list(range(10)))      # doctest: -ELLIPSIS
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+Option directives affect only the example that they appear with; they
+do not change the options for surrounding examples:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...
+    ...     >>> print(list(range(10)))      # Should fail: no ellipsis
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    **********************************************************************
+    File ..., line 8, in f
+    Failed example:
+        print(list(range(10)))      # Should fail: no ellipsis
+    Expected:
+        [0, 1, ..., 9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=2, attempted=3)
+
+Multiple options may be modified by a single option directive.  They
+may be separated by whitespace, commas, or both:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS,+NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))      # Should fail
+    ...     [0, 1,  ...,   9]
+    ...     >>> print(list(range(10)))      # Should succeed
+    ...     ... # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+    ...     [0, 1,  ...,   9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 2, in f
+    Failed example:
+        print(list(range(10)))      # Should fail
+    Expected:
+        [0, 1,  ...,   9]
+    Got:
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    TestResults(failed=1, attempted=2)
+
+The option directive may be put on the line following the source, as
+long as a continuation prompt is used:
+
+    >>> def f(x): r'''
+    ...     >>> print(list(range(10)))
+    ...     ... # doctest: +ELLIPSIS
+    ...     [0, 1, ..., 9]
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+For examples with multi-line source, the option directive may appear
+at the end of any line:
+
+    >>> def f(x): r'''
+    ...     >>> for x in range(10): # doctest: +ELLIPSIS
+    ...     ...     print(' ', x, end='', sep='')
+    ...      0 1 2 ... 9
+    ...
+    ...     >>> for x in range(10):
+    ...     ...     print(' ', x, end='', sep='') # doctest: +ELLIPSIS
+    ...      0 1 2 ... 9
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=2)
+
+If more than one line of an example with multi-line source has an
+option directive, then they are combined:
+
+    >>> def f(x): r'''
+    ...     Should fail (option directive not on the last line):
+    ...         >>> for x in range(10): # doctest: +ELLIPSIS
+    ...         ...     print(x, end=' ') # doctest: +NORMALIZE_WHITESPACE
+    ...         0  1    2...9
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    TestResults(failed=0, attempted=1)
+
+It is an error to have a comment of the form ``# doctest:`` that is
+*not* followed by words of the form ``+OPTION`` or ``-OPTION``, where
+``OPTION`` is an option that has been registered with
+`register_option`:
+
+    >>> # Error: Option not registered
+    >>> s = '>>> print(12)  #doctest: +BADOPTION'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the doctest for s has an invalid option: '+BADOPTION'
+
+    >>> # Error: No + or - prefix
+    >>> s = '>>> print(12)  #doctest: ELLIPSIS'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 1 of the doctest for s has an invalid option: 'ELLIPSIS'
+
+It is an error to use an option directive on a line that contains no
+source:
+
+    >>> s = '>>> # doctest: +ELLIPSIS'
+    >>> test = doctest.DocTestParser().get_doctest(s, {}, 's', 's.py', 0)
+    Traceback (most recent call last):
+    ValueError: line 0 of the doctest for s has an option directive on a line with no example: '# doctest: +ELLIPSIS'
+
+    >>> _colorize.COLORIZE = save_colorize
+"""
+
+def test_testsource(): r"""
+Unit tests for `testsource()`.
+
+The testsource() function takes a module and a name, finds the (first)
+test with that name in that module, and converts it to a script. The
+example code is converted to regular Python code.  The surrounding
+words and expected output are converted to comments:
+
+    >>> from test.test_doctest import test_doctest
+    >>> name = 'test.test_doctest.test_doctest.sample_func'
+    >>> print(doctest.testsource(test_doctest, name))
+    # Blah blah
+    #
+    print(sample_func(22))
+    # Expected:
+    ## 44
+    #
+    # Yee ha!
+    <BLANKLINE>
+
+    >>> name = 'test.test_doctest.test_doctest.SampleNewStyleClass'
+    >>> print(doctest.testsource(test_doctest, name))
+    print('1\n2\n3')
+    # Expected:
+    ## 1
+    ## 2
+    ## 3
+    <BLANKLINE>
+
+    >>> name = 'test.test_doctest.test_doctest.SampleClass.a_classmethod'
+    >>> print(doctest.testsource(test_doctest, name))
+    print(SampleClass.a_classmethod(10))
+    # Expected:
+    ## 12
+    print(SampleClass(0).a_classmethod(10))
+    # Expected:
+    ## 12
+    <BLANKLINE>
+"""
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# def test_debug(): r"""
+
+# Create a docstring that we want to debug:
+
+#     >>> s = '''
+#     ...     >>> x = 12
+#     ...     >>> print(x)
+#     ...     12
+#     ...     '''
+
+# Create some fake stdin input, to feed to the debugger:
+
+#     >>> real_stdin = sys.stdin
+#     >>> sys.stdin = FakeInput(['next', 'print(x)', 'continue'])
+
+# Run the debugger on the docstring, and then restore sys.stdin.
+
+#     >>> try: doctest.debug_src(s)
+#     ... finally: sys.stdin = real_stdin
+#     > <string>(1)<module>()
+#     (Pdb) next
+#     12
+#     --Return--
+#     > <string>(1)<module>()->None
+#     (Pdb) print(x)
+#     12
+#     (Pdb) continue
+
+# """
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+# if not hasattr(sys, 'gettrace') or not sys.gettrace():
+#     def test_pdb_set_trace():
+#         """Using pdb.set_trace from a doctest.
+
+#         You can use pdb.set_trace from a doctest.  To do so, you must
+#         retrieve the set_trace function from the pdb module at the time
+#         you use it.  The doctest module changes sys.stdout so that it can
+#         capture program output.  It also temporarily replaces pdb.set_trace
+#         with a version that restores stdout.  This is necessary for you to
+#         see debugger output.
+
+#           >>> save_colorize = _colorize.COLORIZE
+#           >>> _colorize.COLORIZE = False
+
+#           >>> doc = '''
+#           ... >>> x = 42
+#           ... >>> raise Exception('clé')
+#           ... Traceback (most recent call last):
+#           ... Exception: clé
+#           ... >>> import pdb; pdb.set_trace()
+#           ... '''
+#           >>> parser = doctest.DocTestParser()
+#           >>> test = parser.get_doctest(doc, {}, "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> runner = doctest.DocTestRunner(verbose=False)
+
+#         To demonstrate this, we'll create a fake standard input that
+#         captures our debugger input:
+
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'print(x)',  # print data defined by the example
+#           ...    'continue', # stop debugging
+#           ...    ''])
+
+#           >>> try: runner.run(test)
+#           ... finally: sys.stdin = real_stdin
+#           > <doctest foo-bar@baz[2]>(1)<module>()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) print(x)
+#           42
+#           (Pdb) continue
+#           TestResults(failed=0, attempted=3)
+
+#           You can also put pdb.set_trace in a function called from a test:
+
+#           >>> def calls_set_trace():
+#           ...    y=2
+#           ...    import pdb; pdb.set_trace()
+
+#           >>> doc = '''
+#           ... >>> x=1
+#           ... >>> calls_set_trace()
+#           ... '''
+#           >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'print(y)',  # print data defined in the function
+#           ...    'up',       # out of function
+#           ...    'print(x)',  # print data defined by the example
+#           ...    'continue', # stop debugging
+#           ...    ''])
+
+#           >>> try:
+#           ...     runner.run(test)
+#           ... finally:
+#           ...     sys.stdin = real_stdin
+#           > <doctest test.test_doctest.test_doctest.test_pdb_set_trace[9]>(3)calls_set_trace()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) print(y)
+#           2
+#           (Pdb) up
+#           > <doctest foo-bar@baz[1]>(1)<module>()
+#           -> calls_set_trace()
+#           (Pdb) print(x)
+#           1
+#           (Pdb) continue
+#           TestResults(failed=0, attempted=2)
+
+#         During interactive debugging, source code is shown, even for
+#         doctest examples:
+
+#           >>> doc = '''
+#           ... >>> def f(x):
+#           ... ...     g(x*2)
+#           ... >>> def g(x):
+#           ... ...     print(x+3)
+#           ... ...     import pdb; pdb.set_trace()
+#           ... >>> f(3)
+#           ... '''
+#           >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+#           >>> real_stdin = sys.stdin
+#           >>> sys.stdin = FakeInput([
+#           ...    'step',     # return event of g
+#           ...    'list',     # list source from example 2
+#           ...    'next',     # return from g()
+#           ...    'list',     # list source from example 1
+#           ...    'next',     # return from f()
+#           ...    'list',     # list source from example 3
+#           ...    'continue', # stop debugging
+#           ...    ''])
+#           >>> try: runner.run(test)
+#           ... finally: sys.stdin = real_stdin
+#           ... # doctest: +NORMALIZE_WHITESPACE
+#           > <doctest foo-bar@baz[1]>(3)g()
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) step
+#           --Return--
+#           > <doctest foo-bar@baz[1]>(3)g()->None
+#           -> import pdb; pdb.set_trace()
+#           (Pdb) list
+#             1     def g(x):
+#             2         print(x+3)
+#             3  ->     import pdb; pdb.set_trace()
+#           [EOF]
+#           (Pdb) next
+#           --Return--
+#           > <doctest foo-bar@baz[0]>(2)f()->None
+#           -> g(x*2)
+#           (Pdb) list
+#             1     def f(x):
+#             2  ->     g(x*2)
+#           [EOF]
+#           (Pdb) next
+#           --Return--
+#           > <doctest foo-bar@baz[2]>(1)<module>()->None
+#           -> f(3)
+#           (Pdb) list
+#             1  -> f(3)
+#           [EOF]
+#           (Pdb) continue
+#           **********************************************************************
+#           File "foo-bar@baz.py", line 7, in foo-bar@baz
+#           Failed example:
+#               f(3)
+#           Expected nothing
+#           Got:
+#               9
+#           TestResults(failed=1, attempted=3)
+
+#           >>> _colorize.COLORIZE = save_colorize
+#           """
+
+    # TODO: RUSTPYTHON
+    # Issue with pdb
+    # AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+    # def test_pdb_set_trace_nested():
+    #     """This illustrates more-demanding use of set_trace with nested functions.
+
+    #     >>> class C(object):
+    #     ...     def calls_set_trace(self):
+    #     ...         y = 1
+    #     ...         import pdb; pdb.set_trace()
+    #     ...         self.f1()
+    #     ...         y = 2
+    #     ...     def f1(self):
+    #     ...         x = 1
+    #     ...         self.f2()
+    #     ...         x = 2
+    #     ...     def f2(self):
+    #     ...         z = 1
+    #     ...         z = 2
+
+    #     >>> calls_set_trace = C().calls_set_trace
+
+    #     >>> doc = '''
+    #     ... >>> a = 1
+    #     ... >>> calls_set_trace()
+    #     ... '''
+    #     >>> parser = doctest.DocTestParser()
+    #     >>> runner = doctest.DocTestRunner(verbose=False)
+    #     >>> test = parser.get_doctest(doc, globals(), "foo-bar@baz", "foo-bar@baz.py", 0)
+    #     >>> real_stdin = sys.stdin
+    #     >>> sys.stdin = FakeInput([
+    #     ...    'step',
+    #     ...    'print(y)',  # print data defined in the function
+    #     ...    'step', 'step', 'step', 'step', 'step', 'step', 'print(z)',
+    #     ...    'up', 'print(x)',
+    #     ...    'up', 'print(y)',
+    #     ...    'up', 'print(foo)',
+    #     ...    'continue', # stop debugging
+    #     ...    ''])
+
+    #     >>> try:
+    #     ...     runner.run(test)
+    #     ... finally:
+    #     ...     sys.stdin = real_stdin
+    #     ... # doctest: +REPORT_NDIFF
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(4)calls_set_trace()
+    #     -> import pdb; pdb.set_trace()
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(5)calls_set_trace()
+    #     -> self.f1()
+    #     (Pdb) print(y)
+    #     1
+    #     (Pdb) step
+    #     --Call--
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(7)f1()
+    #     -> def f1(self):
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(8)f1()
+    #     -> x = 1
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(9)f1()
+    #     -> self.f2()
+    #     (Pdb) step
+    #     --Call--
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(11)f2()
+    #     -> def f2(self):
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(12)f2()
+    #     -> z = 1
+    #     (Pdb) step
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(13)f2()
+    #     -> z = 2
+    #     (Pdb) print(z)
+    #     1
+    #     (Pdb) up
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(9)f1()
+    #     -> self.f2()
+    #     (Pdb) print(x)
+    #     1
+    #     (Pdb) up
+    #     > <doctest test.test_doctest.test_doctest.test_pdb_set_trace_nested[0]>(5)calls_set_trace()
+    #     -> self.f1()
+    #     (Pdb) print(y)
+    #     1
+    #     (Pdb) up
+    #     > <doctest foo-bar@baz[1]>(1)<module>()
+    #     -> calls_set_trace()
+    #     (Pdb) print(foo)
+    #     *** NameError: name 'foo' is not defined
+    #     (Pdb) continue
+    #     TestResults(failed=0, attempted=2)
+    # """
+
+# TODO: RUSTPYTHON
+# Issue with pdb
+# AttributeError: 'frame' object has no attribute 'f_trace_opcodes'. Did you mean: 'f_trace_lines'?
+# def test_DocTestSuite():
+#     """DocTestSuite creates a unittest test suite from a doctest.
+
+#        We create a Suite by providing a module.  A module can be provided
+#        by passing a module object:
+
+#          >>> import unittest
+#          >>> import test.test_doctest.sample_doctest
+#          >>> suite = doctest.DocTestSuite(test.test_doctest.sample_doctest)
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+#          >>> for tst, _ in result.failures:
+#          ...     print(tst)
+#          bad (test.test_doctest.sample_doctest.__test__)
+#          foo (test.test_doctest.sample_doctest)
+#          test_silly_setup (test.test_doctest.sample_doctest)
+#          y_is_one (test.test_doctest.sample_doctest)
+
+#        We can also supply the module by name:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        The module need not contain any doctest examples:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_doctests')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        The module need not contain any docstrings either:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_docstrings')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        If all examples in a docstring are skipped, unittest will report it as a
+#        skipped test:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_skip')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=6 errors=0 failures=2>
+#         >>> len(result.skipped)
+#         2
+#         >>> for tst, _ in result.skipped:
+#         ...     print(tst)
+#         double_skip (test.test_doctest.sample_doctest_skip)
+#         single_skip (test.test_doctest.sample_doctest_skip)
+#         >>> for tst, _ in result.failures:
+#         ...     print(tst)
+#         no_skip_fail (test.test_doctest.sample_doctest_skip)
+#         partial_skip_fail (test.test_doctest.sample_doctest_skip)
+
+#        We can use the current module:
+
+#          >>> suite = test.test_doctest.sample_doctest.test_suite()
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        We can also provide a DocTestFinder:
+
+#          >>> finder = doctest.DocTestFinder()
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                          test_finder=finder)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=4>
+
+#        The DocTestFinder need not return any tests:
+
+#          >>> finder = doctest.DocTestFinder()
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest_no_docstrings',
+#          ...                          test_finder=finder)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=0 errors=0 failures=0>
+
+#        We can supply global variables.  If we pass globs, they will be
+#        used instead of the module globals.  Here we'll pass an empty
+#        globals, triggering an extra error:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest', globs={})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=5>
+
+#        Alternatively, we can provide extra globals.  Here we'll make an
+#        error go away by providing an extra global variable:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                              extraglobs={'y': 1})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        You can pass option flags.  Here we'll cause an extra error
+#        by disabling the blank-line feature:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...                      optionflags=doctest.DONT_ACCEPT_BLANKLINE)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=5>
+
+#        You can supply setUp and tearDown functions:
+
+#          >>> def setUp(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     test_doctest.sillySetup = True
+
+#          >>> def tearDown(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     del test_doctest.sillySetup
+
+#        Here, we installed a silly variable that the test expects:
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest',
+#          ...      setUp=setUp, tearDown=tearDown)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        But the tearDown restores sanity:
+
+#          >>> from test.test_doctest import test_doctest
+#          >>> test_doctest.sillySetup
+#          Traceback (most recent call last):
+#          ...
+#          AttributeError: module 'test.test_doctest.test_doctest' has no attribute 'sillySetup'
+
+#        The setUp and tearDown functions are passed test objects. Here
+#        we'll use the setUp function to supply the missing variable y:
+
+#          >>> def setUp(test):
+#          ...     test.globs['y'] = 1
+
+#          >>> suite = doctest.DocTestSuite('test.test_doctest.sample_doctest', setUp=setUp)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=9 errors=0 failures=3>
+
+#        Here, we didn't need to use a tearDown function because we
+#        modified the test globals, which are a copy of the
+#        sample_doctest module dictionary.  The test globals are
+#        automatically cleared for us after a test.
+#     """
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_DocTestSuite_errors():
+#     """Tests for error reporting in DocTestSuite.
+
+#          >>> import unittest
+#          >>> import test.test_doctest.sample_doctest_errors as mod
+#          >>> suite = doctest.DocTestSuite(mod)
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=4 errors=0 failures=4>
+#          >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors
+#            File "...sample_doctest_errors.py", line 0, in sample_doctest_errors
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 5, in test.test_doctest.sample_doctest_errors
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 7, in test.test_doctest.sample_doctest_errors
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[1][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.__test__.bad
+#            File "...sample_doctest_errors.py", line unknown line number, in bad
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.__test__.bad[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[2][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.errors
+#            File "...sample_doctest_errors.py", line 14, in errors
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 16, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              2 + 2
+#          Expected:
+#              5
+#          Got:
+#              4
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 18, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              1/0
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[1]>", line 1, in <module>
+#                  1/0
+#                  ~^~
+#              ZeroDivisionError: division by zero
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 23, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              f()
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[3]>", line 1, in <module>
+#                  f()
+#                  ~^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[2]>", line 2, in f
+#                  2 + '2'
+#                  ~~^~~~~
+#              TypeError: ...
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 25, in test.test_doctest.sample_doctest_errors.errors
+#          Failed example:
+#              g()
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                  ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.errors[4]>", line 1, in <module>
+#                  g()
+#                  ~^^
+#                File "...sample_doctest_errors.py", line 12, in g
+#                  [][0] # line 12
+#                  ~~^^^
+#              IndexError: list index out of range
+#          <BLANKLINE>
+#          <BLANKLINE>
+#          >>> print(result.failures[3][1]) # doctest: +ELLIPSIS
+#          Traceback (most recent call last):
+#            File ...
+#              raise self.failureException(self.format_failure(new.getvalue()))
+#          AssertionError: Failed doctest test for test.test_doctest.sample_doctest_errors.syntax_error
+#            File "...sample_doctest_errors.py", line 29, in syntax_error
+#          <BLANKLINE>
+#          ----------------------------------------------------------------------
+#          File "...sample_doctest_errors.py", line 31, in test.test_doctest.sample_doctest_errors.syntax_error
+#          Failed example:
+#              2+*3
+#          Exception raised:
+#              Traceback (most recent call last):
+#                File ...
+#                  exec(compile(example.source, filename, "single",
+#                       ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                               compileflags, True), test.globs)
+#                               ^^^^^^^^^^^^^^^^^^^
+#                File "<doctest test.test_doctest.sample_doctest_errors.syntax_error[0]>", line 1
+#                  2+*3
+#                    ^
+#              SyntaxError: invalid syntax
+#          <BLANKLINE>
+#          <BLANKLINE>
+#     """
+
+# TODO: RUSTPYTHON
+# try finally does not work in the interactive shell
+# def test_DocFileSuite():
+#     """We can test tests found in text files using a DocFileSuite.
+
+#        We create a suite by providing the names of one or more text
+#        files that include examples:
+
+#          >>> import unittest
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        The test files are looked for in the directory containing the
+#        calling module.  A package keyword argument can be provided to
+#        specify a different relative location.
+
+#          >>> import unittest
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              package='test.test_doctest')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        Support for using a package's __loader__.get_data() is also
+#        provided.
+
+#          >>> import unittest, pkgutil, test
+#          >>> added_loader = False
+#          >>> if not hasattr(test, '__loader__'):
+#          ...     test.__loader__ = pkgutil.get_loader(test)
+#          ...     added_loader = True
+#          >>> try:
+#          ...     suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                                  'test_doctest2.txt',
+#          ...                                  'test_doctest4.txt',
+#          ...                                  package='test.test_doctest')
+#          ...     suite.run(unittest.TestResult())
+#          ... finally:
+#          ...     if added_loader:
+#          ...         del test.__loader__
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        '/' should be used as a path separator.  It will be converted
+#        to a native separator at run time:
+
+#          >>> suite = doctest.DocFileSuite('../test_doctest/test_doctest.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=1>
+
+#        If DocFileSuite is used from an interactive session, then files
+#        are resolved relative to the directory of sys.argv[0]:
+
+#          >>> import types, os.path
+#          >>> from test.test_doctest import test_doctest
+#          >>> save_argv = sys.argv
+#          >>> sys.argv = [test_doctest.__file__]
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              package=types.ModuleType('__main__'))
+#          >>> sys.argv = save_argv
+
+#        By setting `module_relative=False`, os-specific paths may be
+#        used (including absolute paths and paths relative to the
+#        working directory):
+
+#          >>> # Get the absolute path of the test package.
+#          >>> test_doctest_path = os.path.abspath(test_doctest.__file__)
+#          >>> test_pkg_path = os.path.split(test_doctest_path)[0]
+
+#          >>> # Use it to find the absolute path of test_doctest.txt.
+#          >>> test_file = os.path.join(test_pkg_path, 'test_doctest.txt')
+
+#          >>> suite = doctest.DocFileSuite(test_file, module_relative=False)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=1>
+
+#        It is an error to specify `package` when `module_relative=False`:
+
+#          >>> suite = doctest.DocFileSuite(test_file, module_relative=False,
+#          ...                              package='test')
+#          Traceback (most recent call last):
+#          ValueError: Package may only be specified for module-relative paths.
+
+#        If all examples in a file are skipped, unittest will report it as a
+#        skipped test:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              'test_doctest_skip.txt',
+#          ...                              'test_doctest_skip2.txt')
+#          >>> result = suite.run(unittest.TestResult())
+#          >>> result
+#          <unittest.result.TestResult run=4 errors=0 failures=1>
+#          >>> len(result.skipped)
+#          1
+#          >>> for tst, _ in result.skipped: # doctest: +ELLIPSIS
+#          ...     print('=', tst)
+#          = ...test_doctest_skip.txt
+
+#        You can specify initial global variables:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              globs={'favorite_color': 'blue'})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=1>
+
+#        In this case, we supplied a missing favorite color. You can
+#        provide doctest options:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                         optionflags=doctest.DONT_ACCEPT_BLANKLINE,
+#          ...                              globs={'favorite_color': 'blue'})
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+
+#        And, you can provide setUp and tearDown functions:
+
+#          >>> def setUp(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     test_doctest.sillySetup = True
+
+#          >>> def tearDown(t):
+#          ...     from test.test_doctest import test_doctest
+#          ...     del test_doctest.sillySetup
+
+#        Here, we installed a silly variable that the test expects:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              setUp=setUp, tearDown=tearDown)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=1>
+
+#        But the tearDown restores sanity:
+
+#          >>> from test.test_doctest import test_doctest
+#          >>> test_doctest.sillySetup
+#          Traceback (most recent call last):
+#          ...
+#          AttributeError: module 'test.test_doctest.test_doctest' has no attribute 'sillySetup'
+
+#        The setUp and tearDown functions are passed test objects.
+#        Here, we'll use a setUp function to set the favorite color in
+#        test_doctest.txt:
+
+#          >>> def setUp(test):
+#          ...     test.globs['favorite_color'] = 'blue'
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt', setUp=setUp)
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=0>
+
+#        Here, we didn't need to use a tearDown function because we
+#        modified the test globals.  The test globals are
+#        automatically cleared for us after a test.
+
+#        Tests in a file run using `DocFileSuite` can also access the
+#        `__file__` global, which is set to the name of the file
+#        containing the tests:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest3.txt')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=1 errors=0 failures=0>
+
+#        If the tests contain non-ASCII characters, we have to specify which
+#        encoding the file is encoded with. We do so by using the `encoding`
+#        parameter:
+
+#          >>> suite = doctest.DocFileSuite('test_doctest.txt',
+#          ...                              'test_doctest2.txt',
+#          ...                              'test_doctest4.txt',
+#          ...                              encoding='utf-8')
+#          >>> suite.run(unittest.TestResult())
+#          <unittest.result.TestResult run=3 errors=0 failures=2>
+#     """
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_DocFileSuite_errors():
+#     """Tests for error reporting in DocTestSuite.
+
+#         >>> import unittest
+#         >>> suite = doctest.DocFileSuite('test_doctest_errors.txt')
+#         >>> result = suite.run(unittest.TestResult())
+#         >>> result
+#         <unittest.result.TestResult run=1 errors=0 failures=1>
+#         >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+#         Traceback (most recent call last):
+#           File ...
+#             raise self.failureException(self.format_failure(new.getvalue()))
+#         AssertionError: Failed doctest test for test_doctest_errors.txt
+#           File "...test_doctest_errors.txt", line 0
+#         <BLANKLINE>
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 4, in test_doctest_errors.txt
+#         Failed example:
+#             2 + 2
+#         Expected:
+#             5
+#         Got:
+#             4
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 6, in test_doctest_errors.txt
+#         Failed example:
+#             1/0
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                 ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[1]>", line 1, in <module>
+#                 1/0
+#                 ~^~
+#             ZeroDivisionError: division by zero
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 11, in test_doctest_errors.txt
+#         Failed example:
+#             f()
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                 ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[3]>", line 1, in <module>
+#                 f()
+#                 ~^^
+#               File "<doctest test_doctest_errors.txt[2]>", line 2, in f
+#                 2 + '2'
+#                 ~~^~~~~
+#             TypeError: ...
+#         ----------------------------------------------------------------------
+#         File "...test_doctest_errors.txt", line 13, in test_doctest_errors.txt
+#         Failed example:
+#             2+*3
+#         Exception raised:
+#             Traceback (most recent call last):
+#               File ...
+#                 exec(compile(example.source, filename, "single",
+#                      ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                              compileflags, True), test.globs)
+#                              ^^^^^^^^^^^^^^^^^^^
+#               File "<doctest test_doctest_errors.txt[4]>", line 1
+#                 2+*3
+#                   ^
+#             SyntaxError: invalid syntax
+#         <BLANKLINE>
+#         <BLANKLINE>
+#     """
+
+def test_trailing_space_in_test():
+    """
+    Trailing spaces in expected output are significant:
+
+      >>> x, y = 'foo', ''
+      >>> print(x, y)
+      foo \n
+    """
+
+class Wrapper:
+    def __init__(self, func):
+        self.func = func
+        functools.update_wrapper(self, func)
+
+    def __call__(self, *args, **kwargs):
+        self.func(*args, **kwargs)
+
+@Wrapper
+def wrapped():
+    """
+    Docstrings in wrapped functions must be detected as well.
+
+    >>> 'one other test'
+    'one other test'
+    """
+
+def test_look_in_unwrapped():
+    """
+    Ensure that wrapped doctests work correctly.
+
+    >>> import doctest
+    >>> doctest.run_docstring_examples(
+    ...     wrapped, {}, name=wrapped.__name__, verbose=True)
+    Finding tests in wrapped
+    Trying:
+        'one other test'
+    Expecting:
+        'one other test'
+    ok
+    """
+
+@doctest_skip_if(support.check_impl_detail(cpython=False))
+def test_wrapped_c_func():
+    """
+    # https://github.com/python/cpython/issues/117692
+    >>> import binascii
+    >>> from test.test_doctest.decorator_mod import decorator
+
+    >>> c_func_wrapped = decorator(binascii.b2a_hex)
+    >>> tests = doctest.DocTestFinder(exclude_empty=False).find(c_func_wrapped)
+    >>> for test in tests:
+    ...    print(test.lineno, test.name)
+    None b2a_hex
+    """
+
+def test_unittest_reportflags():
+    """Default unittest reporting flags can be set to control reporting
+
+    Here, we'll set the REPORT_ONLY_FIRST_FAILURE option so we see
+    only the first failure of each test.  First, we'll look at the
+    output without the flag.  The file test_doctest.txt file has two
+    tests. They both fail if blank lines are disabled:
+
+      >>> suite = doctest.DocFileSuite('test_doctest.txt',
+      ...                          optionflags=doctest.DONT_ACCEPT_BLANKLINE)
+      >>> import unittest
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      ...
+      Failed example:
+          if 1:
+      ...
+
+    Note that we see both failures displayed.
+
+      >>> old = doctest.set_unittest_reportflags(
+      ...    doctest.REPORT_ONLY_FIRST_FAILURE)
+
+    Now, when we run the test:
+
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      Exception raised:
+          ...
+          NameError: name 'favorite_color' is not defined
+      <BLANKLINE>
+      <BLANKLINE>
+
+    We get only the first failure.
+
+    If we give any reporting options when we set up the tests,
+    however:
+
+      >>> suite = doctest.DocFileSuite('test_doctest.txt',
+      ...     optionflags=doctest.DONT_ACCEPT_BLANKLINE | doctest.REPORT_NDIFF)
+
+    Then the default eporting options are ignored:
+
+      >>> result = suite.run(unittest.TestResult())
+      >>> result
+      <unittest.result.TestResult run=1 errors=0 failures=1>
+
+    *NOTE*: These doctest are intentionally not placed in raw string to depict
+    the trailing whitespace using `\x20` in the diff below.
+
+      >>> print(result.failures[0][1]) # doctest: +ELLIPSIS
+      Traceback ...
+      Failed example:
+          favorite_color
+      ...
+      Failed example:
+          if 1:
+             print('a')
+             print()
+             print('b')
+      Differences (ndiff with -expected +actual):
+            a
+          - <BLANKLINE>
+          +\x20
+            b
+      <BLANKLINE>
+      <BLANKLINE>
+
+
+    Test runners can restore the formatting flags after they run:
+
+      >>> ignored = doctest.set_unittest_reportflags(old)
+
+    """
+
+def test_testfile(): r"""
+Tests for the `testfile()` function.  This function runs all the
+doctest examples in a given file.  In its simple invocation, it is
+called with the name of a file, which is taken to be relative to the
+calling module.  The return value is (#failures, #tests).
+
+We don't want color or `-v` in sys.argv for these tests.
+
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> save_argv = sys.argv
+    >>> if '-v' in sys.argv:
+    ...     sys.argv = [arg for arg in save_argv if arg != '-v']
+
+
+    >>> doctest.testfile('test_doctest.txt') # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Exception raised:
+        ...
+        NameError: name 'favorite_color' is not defined
+    **********************************************************************
+    1 item had failures:
+       1 of   2 in test_doctest.txt
+    ***Test Failed*** 1 failure.
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+(Note: we'll be clearing doctest.master after each call to
+`doctest.testfile`, to suppress warnings about multiple tests with the
+same name.)
+
+Globals may be specified with the `globs` and `extraglobs` parameters:
+
+    >>> globs = {'favorite_color': 'blue'}
+    >>> doctest.testfile('test_doctest.txt', globs=globs)
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+    >>> extraglobs = {'favorite_color': 'red'}
+    >>> doctest.testfile('test_doctest.txt', globs=globs,
+    ...                  extraglobs=extraglobs) # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Expected:
+        'blue'
+    Got:
+        'red'
+    **********************************************************************
+    1 item had failures:
+       1 of   2 in test_doctest.txt
+    ***Test Failed*** 1 failure.
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The file may be made relative to a given module or package, using the
+optional `module_relative` parameter:
+
+    >>> doctest.testfile('test_doctest.txt', globs=globs,
+    ...                  module_relative='test')
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+Verbosity can be increased with the optional `verbose` parameter:
+
+    >>> doctest.testfile('test_doctest.txt', globs=globs, verbose=True)
+    Trying:
+        favorite_color
+    Expecting:
+        'blue'
+    ok
+    Trying:
+        if 1:
+           print('a')
+           print()
+           print('b')
+    Expecting:
+        a
+        <BLANKLINE>
+        b
+    ok
+    1 item passed all tests:
+       2 tests in test_doctest.txt
+    2 tests in 1 item.
+    2 passed.
+    Test passed.
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The name of the test may be specified with the optional `name`
+parameter:
+
+    >>> doctest.testfile('test_doctest.txt', name='newname')
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in newname
+    ...
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The summary report may be suppressed with the optional `report`
+parameter:
+
+    >>> doctest.testfile('test_doctest.txt', report=False)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in test_doctest.txt
+    Failed example:
+        favorite_color
+    Exception raised:
+        ...
+        NameError: name 'favorite_color' is not defined
+    TestResults(failed=1, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+The optional keyword argument `raise_on_error` can be used to raise an
+exception on the first error (which may be useful for postmortem
+debugging):
+
+    >>> doctest.testfile('test_doctest.txt', raise_on_error=True)
+    ... # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    doctest.UnexpectedException: ...
+    >>> doctest.master = None  # Reset master.
+
+If the tests contain non-ASCII characters, the tests might fail, since
+it's unknown which encoding is used. The encoding can be specified
+using the optional keyword argument `encoding`:
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='latin-1') # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 7, in test_doctest4.txt
+    Failed example:
+        '...'
+    Expected:
+        'f\xf6\xf6'
+    Got:
+        'f\xc3\xb6\xc3\xb6'
+    **********************************************************************
+    ...
+    **********************************************************************
+    1 item had failures:
+       2 of   2 in test_doctest4.txt
+    ***Test Failed*** 2 failures.
+    TestResults(failed=2, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='utf-8')
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+
+Test the verbose output:
+
+    >>> doctest.testfile('test_doctest4.txt', encoding='utf-8', verbose=True)
+    Trying:
+        'föö'
+    Expecting:
+        'f\xf6\xf6'
+    ok
+    Trying:
+        'bąr'
+    Expecting:
+        'b\u0105r'
+    ok
+    1 item passed all tests:
+       2 tests in test_doctest4.txt
+    2 tests in 1 item.
+    2 passed.
+    Test passed.
+    TestResults(failed=0, attempted=2)
+    >>> doctest.master = None  # Reset master.
+    >>> sys.argv = save_argv
+    >>> _colorize.COLORIZE = save_colorize
+"""
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_testfile_errors(): r"""
+# Tests for error reporting in the testfile() function.
+
+#     >>> doctest.testfile('test_doctest_errors.txt', verbose=False) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 4, in test_doctest_errors.txt
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 6, in test_doctest_errors.txt
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 11, in test_doctest_errors.txt
+#     Failed example:
+#         f()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[3]>", line 1, in <module>
+#             f()
+#             ~^^
+#           File "<doctest test_doctest_errors.txt[2]>", line 2, in f
+#             2 + '2'
+#             ~~^~~~~
+#         TypeError: ...
+#     **********************************************************************
+#     File "...test_doctest_errors.txt", line 13, in test_doctest_errors.txt
+#     Failed example:
+#         2+*3
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#                  ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test_doctest_errors.txt[4]>", line 1
+#             2+*3
+#               ^
+#         SyntaxError: invalid syntax
+#     **********************************************************************
+#     1 item had failures:
+#        4 of   5 in test_doctest_errors.txt
+#     ***Test Failed*** 4 failures.
+#     TestResults(failed=4, attempted=5)
+# """
+
+class TestImporter(importlib.abc.MetaPathFinder):
+
+    def find_spec(self, fullname, path, target=None):
+        return importlib.util.spec_from_file_location(fullname, path, loader=self)
+
+    def get_data(self, path):
+        with open(path, mode='rb') as f:
+            return f.read()
+
+    def exec_module(self, module):
+        raise ImportError
+
+    def create_module(self, spec):
+        return None
+
+class TestHook:
+
+    def __init__(self, pathdir):
+        self.sys_path = sys.path[:]
+        self.meta_path = sys.meta_path[:]
+        self.path_hooks = sys.path_hooks[:]
+        sys.path.append(pathdir)
+        sys.path_importer_cache.clear()
+        self.modules_before = sys.modules.copy()
+        self.importer = TestImporter()
+        sys.meta_path.append(self.importer)
+
+    def remove(self):
+        sys.path[:] = self.sys_path
+        sys.meta_path[:] = self.meta_path
+        sys.path_hooks[:] = self.path_hooks
+        sys.path_importer_cache.clear()
+        sys.modules.clear()
+        sys.modules.update(self.modules_before)
+
+
+@contextlib.contextmanager
+def test_hook(pathdir):
+    hook = TestHook(pathdir)
+    try:
+        yield hook
+    finally:
+        hook.remove()
+
+# TODO: RUSTPYTHON
+# f.write(b'Test:\r\n\r\n  >>> x = 1 + 1\r\n\r\nDone.\r\n')
+# does not return in with...
+# def test_lineendings(): r"""
+# *nix systems use \n line endings, while Windows systems use \r\n, and
+# old Mac systems used \r, which Python still recognizes as a line ending.  Python
+# handles this using universal newline mode for reading files.  Let's make
+# sure doctest does so (issue 8473) by creating temporary test files using each
+# of the three line disciplines.  At least one will not match either the universal
+# newline \n or os.linesep for the platform the test is run on.
+
+# Windows line endings first:
+
+#     >>> import tempfile, os
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...    f.write(b'Test:\r\n\r\n  >>> x = 1 + 1\r\n\r\nDone.\r\n')
+#     35
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# And now *nix line endings:
+
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(b'Test:\n\n  >>> x = 1 + 1\n\nDone.\n')
+#     30
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# And finally old Mac line endings:
+
+#     >>> fn = tempfile.mktemp()
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(b'Test:\r\r  >>> x = 1 + 1\r\rDone.\r')
+#     30
+#     >>> doctest.testfile(fn, module_relative=False, verbose=False)
+#     TestResults(failed=0, attempted=1)
+#     >>> os.remove(fn)
+
+# Now we test with a package loader that has a get_data method, since that
+# bypasses the standard universal newline handling so doctest has to do the
+# newline conversion itself; let's make sure it does so correctly (issue 1812).
+# We'll write a file inside the package that has all three kinds of line endings
+# in it, and use a package hook to install a custom loader; on any platform,
+# at least one of the line endings will raise a ValueError for inconsistent
+# whitespace if doctest does not correctly do the newline conversion.
+
+#     >>> from test.support import os_helper
+#     >>> import shutil
+#     >>> dn = tempfile.mkdtemp()
+#     >>> pkg = os.path.join(dn, "doctest_testpkg")
+#     >>> os.mkdir(pkg)
+#     >>> os_helper.create_empty_file(os.path.join(pkg, "__init__.py"))
+#     >>> fn = os.path.join(pkg, "doctest_testfile.txt")
+#     >>> with open(fn, 'wb') as f:
+#     ...     f.write(
+#     ...         b'Test:\r\n\r\n'
+#     ...         b'  >>> x = 1 + 1\r\n\r\n'
+#     ...         b'Done.\r\n'
+#     ...         b'Test:\n\n'
+#     ...         b'  >>> x = 1 + 1\n\n'
+#     ...         b'Done.\n'
+#     ...         b'Test:\r\r'
+#     ...         b'  >>> x = 1 + 1\r\r'
+#     ...         b'Done.\r'
+#     ...     )
+#     95
+#     >>> with test_hook(dn):
+#     ...     doctest.testfile("doctest_testfile.txt", package="doctest_testpkg", verbose=False)
+#     TestResults(failed=0, attempted=3)
+#     >>> shutil.rmtree(dn)
+
+# """
+
+def test_testmod(): r"""
+Tests for the testmod function.  More might be useful, but for now we're just
+testing the case raised by Issue 6195, where trying to doctest a C module would
+fail with a UnicodeDecodeError because doctest tried to read the "source" lines
+out of the binary module.
+
+    >>> import unicodedata
+    >>> doctest.testmod(unicodedata, verbose=False)
+    TestResults(failed=0, attempted=0)
+"""
+
+# TODO: RUSTPYTHON
+# traceback + error message is different than in CPython
+# def test_testmod_errors(): r"""
+# Tests for error reporting in the testmod() function.
+
+#     >>> import test.test_doctest.sample_doctest_errors as mod
+#     >>> doctest.testmod(mod, verbose=False) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 5, in test.test_doctest.sample_doctest_errors
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 7, in test.test_doctest.sample_doctest_errors
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line ?, in test.test_doctest.sample_doctest_errors.__test__.bad
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.__test__.bad[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 16, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         2 + 2
+#     Expected:
+#         5
+#     Got:
+#         4
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 18, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         1/0
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[1]>", line 1, in <module>
+#             1/0
+#             ~^~
+#         ZeroDivisionError: division by zero
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 23, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         f()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[3]>", line 1, in <module>
+#             f()
+#             ~^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[2]>", line 2, in f
+#             2 + '2'
+#             ~~^~~~~
+#         TypeError: ...
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 25, in test.test_doctest.sample_doctest_errors.errors
+#     Failed example:
+#         g()
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.errors[4]>", line 1, in <module>
+#             g()
+#             ~^^
+#           File "...sample_doctest_errors.py", line 12, in g
+#             [][0] # line 12
+#             ~~^^^
+#         IndexError: list index out of range
+#     **********************************************************************
+#     File "...sample_doctest_errors.py", line 31, in test.test_doctest.sample_doctest_errors.syntax_error
+#     Failed example:
+#         2+*3
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#                  ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^
+#           File "<doctest test.test_doctest.sample_doctest_errors.syntax_error[0]>", line 1
+#             2+*3
+#               ^
+#         SyntaxError: invalid syntax
+#     **********************************************************************
+#     4 items had failures:
+#        2 of   2 in test.test_doctest.sample_doctest_errors
+#        2 of   2 in test.test_doctest.sample_doctest_errors.__test__.bad
+#        4 of   5 in test.test_doctest.sample_doctest_errors.errors
+#        1 of   1 in test.test_doctest.sample_doctest_errors.syntax_error
+#     ***Test Failed*** 9 failures.
+#     TestResults(failed=9, attempted=10)
+# """
+
+try:
+    os.fsencode("foo-bär@baz.py")
+    supports_unicode = True
+except UnicodeEncodeError:
+    # Skip the test: the filesystem encoding is unable to encode the filename
+    supports_unicode = False
+
+# TODO: RUSTPYTHON
+# traceback message is different than in CPython
+# if supports_unicode:
+#     def test_unicode(): """
+# Check doctest with a non-ascii filename:
+
+#     >>> save_colorize = _colorize.COLORIZE
+#     >>> _colorize.COLORIZE = False
+
+#     >>> doc = '''
+#     ... >>> raise Exception('clé')
+#     ... '''
+#     ...
+#     >>> parser = doctest.DocTestParser()
+#     >>> test = parser.get_doctest(doc, {}, "foo-bär@baz", "foo-bär@baz.py", 0)
+#     >>> test
+#     <DocTest foo-bär@baz from foo-bär@baz.py:0 (1 example)>
+#     >>> runner = doctest.DocTestRunner(verbose=False)
+#     >>> runner.run(test) # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "foo-bär@baz.py", line 2, in foo-bär@baz
+#     Failed example:
+#         raise Exception('clé')
+#     Exception raised:
+#         Traceback (most recent call last):
+#           File ...
+#             exec(compile(example.source, filename, "single",
+#             ~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#                          compileflags, True), test.globs)
+#                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+#           File "<doctest foo-bär@baz[0]>", line 1, in <module>
+#             raise Exception('clé')
+#         Exception: clé
+#     TestResults(failed=1, attempted=1)
+
+#     >>> _colorize.COLORIZE = save_colorize
+#     """
+
+
+# TODO: RUSTPYTHON
+# Difference in Error:
+# FileNotFoundError: [Errno ...] ...nosuchfile... vs FileNotFoundError: (2, 'No such file or directory')
+# @doctest_skip_if(not support.has_subprocess_support)
+# def test_CLI(): r"""
+# The doctest module can be used to run doctests against an arbitrary file.
+# These tests test this CLI functionality.
+
+# We'll use the support module's script_helpers for this, and write a test files
+# to a temp dir to run the command against.  Due to a current limitation in
+# script_helpers, though, we need a little utility function to turn the returned
+# output into something we can doctest against:
+
+#     >>> def normalize(s):
+#     ...     return '\n'.join(s.decode().splitlines())
+
+# With those preliminaries out of the way, we'll start with a file with two
+# simple tests and no errors.  We'll run both the unadorned doctest command, and
+# the verbose version, and then check the output:
+
+#     >>> from test.support import script_helper
+#     >>> from test.support.os_helper import temp_dir
+#     >>> with temp_dir() as tmpdir:
+#     ...     fn = os.path.join(tmpdir, 'myfile.doc')
+#     ...     with open(fn, 'w', encoding='utf-8') as f:
+#     ...         _ = f.write('This is a very simple test file.\n')
+#     ...         _ = f.write('   >>> 1 + 1\n')
+#     ...         _ = f.write('   2\n')
+#     ...         _ = f.write('   >>> "a"\n')
+#     ...         _ = f.write("   'a'\n")
+#     ...         _ = f.write('\n')
+#     ...         _ = f.write('And that is it.\n')
+#     ...     rc1, out1, err1 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', fn)
+#     ...     rc2, out2, err2 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-v', fn)
+
+# With no arguments and passing tests, we should get no output:
+
+#     >>> rc1, out1, err1
+#     (0, b'', b'')
+
+# With the verbose flag, we should see the test output, but no error output:
+
+#     >>> rc2, err2
+#     (0, b'')
+#     >>> print(normalize(out2))
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "a"
+#     Expecting:
+#         'a'
+#     ok
+#     1 item passed all tests:
+#        2 tests in myfile.doc
+#     2 tests in 1 item.
+#     2 passed.
+#     Test passed.
+
+# Now we'll write a couple files, one with three tests, the other a python module
+# with two tests, both of the files having "errors" in the tests that can be made
+# non-errors by applying the appropriate doctest options to the run (ELLIPSIS in
+# the first file, NORMALIZE_WHITESPACE in the second).  This combination will
+# allow thoroughly testing the -f and -o flags, as well as the doctest command's
+# ability to process more than one file on the command line and, since the second
+# file ends in '.py', its handling of python module files (as opposed to straight
+# text files).
+
+#     >>> from test.support import script_helper
+#     >>> from test.support.os_helper import temp_dir
+#     >>> with temp_dir() as tmpdir:
+#     ...     fn = os.path.join(tmpdir, 'myfile.doc')
+#     ...     with open(fn, 'w', encoding="utf-8") as f:
+#     ...         _ = f.write('This is another simple test file.\n')
+#     ...         _ = f.write('   >>> 1 + 1\n')
+#     ...         _ = f.write('   2\n')
+#     ...         _ = f.write('   >>> "abcdef"\n')
+#     ...         _ = f.write("   'a...f'\n")
+#     ...         _ = f.write('   >>> "ajkml"\n')
+#     ...         _ = f.write("   'a...l'\n")
+#     ...         _ = f.write('\n')
+#     ...         _ = f.write('And that is it.\n')
+#     ...     fn2 = os.path.join(tmpdir, 'myfile2.py')
+#     ...     with open(fn2, 'w', encoding='utf-8') as f:
+#     ...         _ = f.write('def test_func():\n')
+#     ...         _ = f.write('   \"\"\"\n')
+#     ...         _ = f.write('   This is simple python test function.\n')
+#     ...         _ = f.write('       >>> 1 + 1\n')
+#     ...         _ = f.write('       2\n')
+#     ...         _ = f.write('       >>> "abc   def"\n')
+#     ...         _ = f.write("       'abc def'\n")
+#     ...         _ = f.write("\n")
+#     ...         _ = f.write('   \"\"\"\n')
+#     ...     rc1, out1, err1 = script_helper.assert_python_failure(
+#     ...             '-m', 'doctest', fn, fn2)
+#     ...     rc2, out2, err2 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-o', 'ELLIPSIS', fn)
+#     ...     rc3, out3, err3 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-o', 'ELLIPSIS',
+#     ...             '-o', 'NORMALIZE_WHITESPACE', fn, fn2)
+#     ...     rc4, out4, err4 = script_helper.assert_python_failure(
+#     ...             '-m', 'doctest', '-f', fn, fn2)
+#     ...     rc5, out5, err5 = script_helper.assert_python_ok(
+#     ...             '-m', 'doctest', '-v', '-o', 'ELLIPSIS',
+#     ...             '-o', 'NORMALIZE_WHITESPACE', fn, fn2)
+
+# Our first test run will show the errors from the first file (doctest stops if a
+# file has errors).  Note that doctest test-run error output appears on stdout,
+# not stderr:
+
+#     >>> rc1, err1
+#     (1, b'')
+#     >>> print(normalize(out1))                # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...myfile.doc", line 4, in myfile.doc
+#     Failed example:
+#         "abcdef"
+#     Expected:
+#         'a...f'
+#     Got:
+#         'abcdef'
+#     **********************************************************************
+#     File "...myfile.doc", line 6, in myfile.doc
+#     Failed example:
+#         "ajkml"
+#     Expected:
+#         'a...l'
+#     Got:
+#         'ajkml'
+#     **********************************************************************
+#     1 item had failures:
+#        2 of   3 in myfile.doc
+#     ***Test Failed*** 2 failures.
+
+# With -o ELLIPSIS specified, the second run, against just the first file, should
+# produce no errors, and with -o NORMALIZE_WHITESPACE also specified, neither
+# should the third, which ran against both files:
+
+#     >>> rc2, out2, err2
+#     (0, b'', b'')
+#     >>> rc3, out3, err3
+#     (0, b'', b'')
+
+# The fourth run uses FAIL_FAST, so we should see only one error:
+
+#     >>> rc4, err4
+#     (1, b'')
+#     >>> print(normalize(out4))                # doctest: +ELLIPSIS
+#     **********************************************************************
+#     File "...myfile.doc", line 4, in myfile.doc
+#     Failed example:
+#         "abcdef"
+#     Expected:
+#         'a...f'
+#     Got:
+#         'abcdef'
+#     **********************************************************************
+#     1 item had failures:
+#        1 of   2 in myfile.doc
+#     ***Test Failed*** 1 failure.
+
+# The fifth test uses verbose with the two options, so we should get verbose
+# success output for the tests in both files:
+
+#     >>> rc5, err5
+#     (0, b'')
+#     >>> print(normalize(out5))
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "abcdef"
+#     Expecting:
+#         'a...f'
+#     ok
+#     Trying:
+#         "ajkml"
+#     Expecting:
+#         'a...l'
+#     ok
+#     1 item passed all tests:
+#        3 tests in myfile.doc
+#     3 tests in 1 item.
+#     3 passed.
+#     Test passed.
+#     Trying:
+#         1 + 1
+#     Expecting:
+#         2
+#     ok
+#     Trying:
+#         "abc   def"
+#     Expecting:
+#         'abc def'
+#     ok
+#     1 item had no tests:
+#         myfile2
+#     1 item passed all tests:
+#        2 tests in myfile2.test_func
+#     2 tests in 2 items.
+#     2 passed.
+#     Test passed.
+
+# We should also check some typical error cases.
+
+# Invalid file name:
+
+#     >>> rc, out, err = script_helper.assert_python_failure(
+#     ...         '-m', 'doctest', 'nosuchfile')
+#     >>> rc, out
+#     (1, b'')
+#     >>> # The exact error message changes depending on the platform.
+#     >>> print(normalize(err))                    # doctest: +ELLIPSIS
+#     Traceback (most recent call last):
+#       ...
+#     FileNotFoundError: [Errno ...] ...nosuchfile...
+
+# Invalid doctest option:
+
+#     >>> rc, out, err = script_helper.assert_python_failure(
+#     ...         '-m', 'doctest', '-o', 'nosuchoption')
+#     >>> rc, out
+#     (2, b'')
+#     >>> print(normalize(err))                    # doctest: +ELLIPSIS
+#     usage...invalid...nosuchoption...
+
+# """
+
+def test_no_trailing_whitespace_stripping():
+    r"""
+    The fancy reports had a bug for a long time where any trailing whitespace on
+    the reported diff lines was stripped, making it impossible to see the
+    differences in line reported as different that differed only in the amount of
+    trailing whitespace.  The whitespace still isn't particularly visible unless
+    you use NDIFF, but at least it is now there to be found.
+
+    *NOTE*: This snippet was intentionally put inside a raw string to get rid of
+    leading whitespace error in executing the example below
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> print('\n'.join(['a    ', 'b']))
+    ...     a
+    ...     b
+    ...     '''
+    """
+    """
+    *NOTE*: These doctest are not placed in raw string to depict the trailing whitespace
+    using `\x20`
+
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.REPORT_NDIFF
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 3, in f
+    Failed example:
+        print('\n'.join(['a    ', 'b']))
+    Differences (ndiff with -expected +actual):
+        - a
+        + a
+          b
+    TestResults(failed=1, attempted=1)
+
+    *NOTE*: `\x20` is for checking the trailing whitespace on the +a line above.
+    We cannot use actual spaces there, as a commit hook prevents from committing
+    patches that contain trailing whitespace. More info on Issue 24746.
+    """
+
+
+def test_run_doctestsuite_multiple_times():
+    """
+    It was not possible to run the same DocTestSuite multiple times
+    http://bugs.python.org/issue2604
+    http://bugs.python.org/issue9736
+
+    >>> import unittest
+    >>> import test.test_doctest.sample_doctest
+    >>> suite = doctest.DocTestSuite(test.test_doctest.sample_doctest)
+    >>> suite.run(unittest.TestResult())
+    <unittest.result.TestResult run=9 errors=0 failures=4>
+    >>> suite.run(unittest.TestResult())
+    <unittest.result.TestResult run=9 errors=0 failures=4>
+    """
+
+
+def test_exception_with_note(note):
+    """
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> test_exception_with_note('Note')
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    Note
+
+    >>> test_exception_with_note('Note')  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    Note
+
+    >>> test_exception_with_note('''Note
+    ... multiline
+    ... example''')
+    Traceback (most recent call last):
+    ValueError: Text
+    Note
+    multiline
+    example
+
+    Different note will fail the test:
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> exc = ValueError('message')
+    ...     >>> exc.add_note('note')
+    ...     >>> raise exc
+    ...     Traceback (most recent call last):
+    ...     ValueError: message
+    ...     wrong note
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 5, in f
+    Failed example:
+        raise exc
+    Expected:
+        Traceback (most recent call last):
+        ValueError: message
+        wrong note
+    Got:
+        Traceback (most recent call last):
+          ...
+        ValueError: message
+        note
+    TestResults(failed=1, attempted=...)
+
+    >>> _colorize.COLORIZE = save_colorize
+    """
+    exc = ValueError('Text')
+    exc.add_note(note)
+    raise exc
+
+
+def test_exception_with_multiple_notes():
+    """
+    >>> test_exception_with_multiple_notes()
+    Traceback (most recent call last):
+      ...
+    ValueError: Text
+    One
+    Two
+    """
+    exc = ValueError('Text')
+    exc.add_note('One')
+    exc.add_note('Two')
+    raise exc
+
+
+def test_syntax_error_with_note(cls, multiline=False):
+    """
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+      ...
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(SyntaxError)
+    Traceback (most recent call last):
+      ...
+      File "x.py", line 23
+        bad syntax
+    SyntaxError: error
+    Note
+
+    >>> test_syntax_error_with_note(IndentationError)
+    Traceback (most recent call last):
+      ...
+    IndentationError: error
+    Note
+
+    >>> test_syntax_error_with_note(TabError, multiline=True)
+    Traceback (most recent call last):
+      ...
+    TabError: error
+    Note
+    Line
+    """
+    exc = cls("error", ("x.py", 23, None, "bad syntax"))
+    exc.add_note('Note\nLine' if multiline else 'Note')
+    raise exc
+
+
+def test_syntax_error_subclass_from_stdlib():
+    """
+    `ParseError` is a subclass of `SyntaxError`, but it is not a builtin:
+
+    >>> test_syntax_error_subclass_from_stdlib()
+    Traceback (most recent call last):
+      ...
+    xml.etree.ElementTree.ParseError: error
+    error
+    Note
+    Line
+    """
+    from xml.etree.ElementTree import ParseError
+    exc = ParseError("error\nerror")
+    exc.add_note('Note\nLine')
+    raise exc
+
+
+def test_syntax_error_with_incorrect_expected_note():
+    """
+    >>> save_colorize = _colorize.COLORIZE
+    >>> _colorize.COLORIZE = False
+
+    >>> def f(x):
+    ...     r'''
+    ...     >>> exc = SyntaxError("error", ("x.py", 23, None, "bad syntax"))
+    ...     >>> exc.add_note('note1')
+    ...     >>> exc.add_note('note2')
+    ...     >>> raise exc
+    ...     Traceback (most recent call last):
+    ...     SyntaxError: error
+    ...     wrong note
+    ...     '''
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File "...", line 6, in f
+    Failed example:
+        raise exc
+    Expected:
+        Traceback (most recent call last):
+        SyntaxError: error
+        wrong note
+    Got:
+        Traceback (most recent call last):
+          ...
+        SyntaxError: error
+        note1
+        note2
+    TestResults(failed=1, attempted=...)
+
+    >>> _colorize.COLORIZE = save_colorize
+    """
+
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(doctest))
+    tests.addTest(doctest.DocTestSuite())
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main(module='test.test_doctest.test_doctest')
diff --git a/Lib/test/test_doctest/test_doctest.txt b/Lib/test/test_doctest/test_doctest.txt
new file mode 100644
index 0000000000..23446d1d22
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest.txt
@@ -0,0 +1,17 @@
+This is a sample doctest in a text file.
+
+In this example, we'll rely on a global variable being set for us
+already:
+
+  >>> favorite_color
+  'blue'
+
+We can make this fail by disabling the blank-line feature.
+
+  >>> if 1:
+  ...    print('a')
+  ...    print()
+  ...    print('b')
+  a
+  <BLANKLINE>
+  b
diff --git a/Lib/test/test_doctest/test_doctest2.py b/Lib/test/test_doctest/test_doctest2.py
new file mode 100644
index 0000000000..ab8a069673
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest2.py
@@ -0,0 +1,126 @@
+"""A module to test whether doctest recognizes some 2.2 features,
+like static and class methods.
+
+>>> print('yup')  # 1
+yup
+
+We include some (random) encoded (utf-8) text in the text surrounding
+the example.  It should be ignored:
+
+ЉЊЈЁЂ
+
+"""
+
+import sys
+import unittest
+if sys.flags.optimize >= 2:
+    raise unittest.SkipTest("Cannot test docstrings with -O2")
+
+class C(object):
+    """Class C.
+
+    >>> print(C())  # 2
+    42
+
+
+    We include some (random) encoded (utf-8) text in the text surrounding
+    the example.  It should be ignored:
+
+        ЉЊЈЁЂ
+
+    """
+
+    def __init__(self):
+        """C.__init__.
+
+        >>> print(C()) # 3
+        42
+        """
+
+    def __str__(self):
+        """
+        >>> print(C()) # 4
+        42
+        """
+        return "42"
+
+    class D(object):
+        """A nested D class.
+
+        >>> print("In D!")   # 5
+        In D!
+        """
+
+        def nested(self):
+            """
+            >>> print(3) # 6
+            3
+            """
+
+    def getx(self):
+        """
+        >>> c = C()    # 7
+        >>> c.x = 12   # 8
+        >>> print(c.x)  # 9
+        -12
+        """
+        return -self._x
+
+    def setx(self, value):
+        """
+        >>> c = C()     # 10
+        >>> c.x = 12    # 11
+        >>> print(c.x)   # 12
+        -12
+        """
+        self._x = value
+
+    x = property(getx, setx, doc="""\
+        >>> c = C()    # 13
+        >>> c.x = 12   # 14
+        >>> print(c.x)  # 15
+        -12
+        """)
+
+    @staticmethod
+    def statm():
+        """
+        A static method.
+
+        >>> print(C.statm())    # 16
+        666
+        >>> print(C().statm())  # 17
+        666
+        """
+        return 666
+
+    @classmethod
+    def clsm(cls, val):
+        """
+        A class method.
+
+        >>> print(C.clsm(22))    # 18
+        22
+        >>> print(C().clsm(23))  # 19
+        23
+        """
+        return val
+
+
+class Test(unittest.TestCase):
+    def test_testmod(self):
+        import doctest, sys
+        EXPECTED = 19
+        f, t = doctest.testmod(sys.modules[__name__])
+        if f:
+            self.fail("%d of %d doctests failed" % (f, t))
+        if t != EXPECTED:
+            self.fail("expected %d tests to run, not %d" % (EXPECTED, t))
+
+
+# Pollute the namespace with a bunch of imported functions and classes,
+# to make sure they don't get tested.
+from doctest import *
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_doctest/test_doctest2.txt b/Lib/test/test_doctest/test_doctest2.txt
new file mode 100644
index 0000000000..76dab94a9c
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest2.txt
@@ -0,0 +1,14 @@
+This is a sample doctest in a text file.
+
+In this example, we'll rely on some silly setup:
+
+  >>> import test.test_doctest.test_doctest
+  >>> test.test_doctest.test_doctest.sillySetup
+  True
+
+This test also has some (random) encoded (utf-8) unicode text:
+
+  ЉЊЈЁЂ
+
+This doesn't cause a problem in the tect surrounding the examples, but
+we include it here (in this test text file) to make sure. :)
diff --git a/Lib/test/test_doctest/test_doctest3.txt b/Lib/test/test_doctest/test_doctest3.txt
new file mode 100644
index 0000000000..dd8557e57a
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest3.txt
@@ -0,0 +1,5 @@
+
+Here we check that `__file__` is provided:
+
+  >>> type(__file__)
+  <class 'str'>
diff --git a/Lib/test/test_doctest/test_doctest4.txt b/Lib/test/test_doctest/test_doctest4.txt
new file mode 100644
index 0000000000..0428e6f963
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest4.txt
@@ -0,0 +1,11 @@
+This is a sample doctest in a text file that contains non-ASCII characters.
+This file is encoded using UTF-8.
+
+In order to get this test to pass, we have to manually specify the
+encoding.
+
+  >>> 'föö'
+  'f\xf6\xf6'
+
+  >>> 'bąr'
+  'b\u0105r'
diff --git a/Lib/test/test_doctest/test_doctest_errors.txt b/Lib/test/test_doctest/test_doctest_errors.txt
new file mode 100644
index 0000000000..93c3c106e6
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_errors.txt
@@ -0,0 +1,14 @@
+This is a sample doctest in a text file, in which all examples fail
+or raise an exception.
+
+  >>> 2 + 2
+  5
+  >>> 1/0
+  1
+  >>> def f():
+  ...     2 + '2'
+  ...
+  >>> f()
+  1
+  >>> 2+*3
+  5
diff --git a/Lib/test/test_doctest/test_doctest_skip.txt b/Lib/test/test_doctest/test_doctest_skip.txt
new file mode 100644
index 0000000000..06c23d06e6
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_skip.txt
@@ -0,0 +1,6 @@
+This is a sample doctest in a text file, in which all examples are skipped.
+
+  >>> 2 + 2  # doctest: +SKIP
+  5
+  >>> 2 + 2  # doctest: +SKIP
+  4
diff --git a/Lib/test/test_doctest/test_doctest_skip2.txt b/Lib/test/test_doctest/test_doctest_skip2.txt
new file mode 100644
index 0000000000..85e4938c34
--- /dev/null
+++ b/Lib/test/test_doctest/test_doctest_skip2.txt
@@ -0,0 +1,6 @@
+This is a sample doctest in a text file, in which some examples are skipped.
+
+  >>> 2 + 2  # doctest: +SKIP
+  5
+  >>> 2 + 2
+  4
diff --git a/Lib/test/test_docxmlrpc.py b/Lib/test/test_docxmlrpc.py
index 99469a5849..999533a72a 100644
--- a/Lib/test/test_docxmlrpc.py
+++ b/Lib/test/test_docxmlrpc.py
@@ -100,8 +100,6 @@ def test_valid_get_response(self):
         # Server raises an exception if we don't start to read the data
         response.read()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_get_css(self):
         self.client.request("GET", "/pydoc.css")
         response = self.client.getresponse()
@@ -121,6 +119,7 @@ def test_invalid_get_response(self):
 
         response.read()
 
+    @unittest.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
@@ -161,6 +160,7 @@ 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,6 +190,7 @@ def test_system_methods(self):
              b'<br>\nThis&nbsp;server&nbsp;does&nbsp;NOT&nbsp;support&nbsp;system'
              b'.methodSignature.</tt></dd></dl>'), response)
 
+    @unittest.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."""
@@ -199,6 +200,7 @@ 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", "/")
@@ -212,6 +214,7 @@ 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_dtrace.py b/Lib/test/test_dtrace.py
index e1adf8e974..a63978fd1b 100644
--- a/Lib/test/test_dtrace.py
+++ b/Lib/test/test_dtrace.py
@@ -159,11 +159,43 @@ class DTraceNormalTests(TraceTests, unittest.TestCase):
     backend = DTraceBackend()
     optimize_python = 0
 
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_function_entry_return(self):
+        return super().test_function_entry_return()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_verify_call_opcodes(self):
+        return super().test_verify_call_opcodes()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_gc(self):
+        return super().test_gc()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_line(self):
+        return super().test_line()
+
 
 class DTraceOptimizedTests(TraceTests, unittest.TestCase):
     backend = DTraceBackend()
     optimize_python = 2
 
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_function_entry_return(self):
+        return super().test_function_entry_return()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_verify_call_opcodes(self):
+        return super().test_verify_call_opcodes()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_gc(self):
+        return super().test_gc()
+
+    @unittest.expectedFailureIfWindows('TODO: RUSTPYTHON')
+    def test_line(self):
+        return super().test_line()
+
 
 class SystemTapNormalTests(TraceTests, unittest.TestCase):
     backend = SystemTapBackend()
diff --git a/Lib/test/test_dynamic.py b/Lib/test/test_dynamic.py
index 4217e8e01c..9fd2d86710 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
+from test.support import swap_item, swap_attr, is_wasi, Py_DEBUG
 
 
 class RebindBuiltinsTests(unittest.TestCase):
@@ -134,8 +134,8 @@ def test_eval_gives_lambda_custom_globals(self):
 
         self.assertEqual(foo(), 7)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipIf(is_wasi and Py_DEBUG, "requires too much stack")
     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_email/__init__.py b/Lib/test/test_email/__init__.py
new file mode 100644
index 0000000000..455dc48fac
--- /dev/null
+++ b/Lib/test/test_email/__init__.py
@@ -0,0 +1,167 @@
+import os
+import unittest
+import collections
+import email
+from email.message import Message
+from email._policybase import compat32
+from test.support import load_package_tests
+from test.support.testcase import ExtraAssertions
+from test.test_email import __file__ as landmark
+
+# Load all tests in package
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
+
+
+# helper code used by a number of test modules.
+
+def openfile(filename, *args, **kws):
+    path = os.path.join(os.path.dirname(landmark), 'data', filename)
+    return open(path, *args, **kws)
+
+
+# Base test class
+class TestEmailBase(unittest.TestCase, ExtraAssertions):
+
+    maxDiff = None
+    # Currently the default policy is compat32.  By setting that as the default
+    # here we make minimal changes in the test_email tests compared to their
+    # pre-3.3 state.
+    policy = compat32
+    # Likewise, the default message object is Message.
+    message = Message
+
+    def __init__(self, *args, **kw):
+        super().__init__(*args, **kw)
+        self.addTypeEqualityFunc(bytes, self.assertBytesEqual)
+
+    # Backward compatibility to minimize test_email test changes.
+    ndiffAssertEqual = unittest.TestCase.assertEqual
+
+    def _msgobj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            return email.message_from_file(fp, policy=self.policy)
+
+    def _str_msg(self, string, message=None, policy=None):
+        if policy is None:
+            policy = self.policy
+        if message is None:
+            message = self.message
+        return email.message_from_string(string, message, policy=policy)
+
+    def _bytes_msg(self, bytestring, message=None, policy=None):
+        if policy is None:
+            policy = self.policy
+        if message is None:
+            message = self.message
+        return email.message_from_bytes(bytestring, message, policy=policy)
+
+    def _make_message(self):
+        return self.message(policy=self.policy)
+
+    def _bytes_repr(self, b):
+        return [repr(x) for x in b.splitlines(keepends=True)]
+
+    def assertBytesEqual(self, first, second, msg):
+        """Our byte strings are really encoded strings; improve diff output"""
+        self.assertEqual(self._bytes_repr(first), self._bytes_repr(second))
+
+    def assertDefectsEqual(self, actual, expected):
+        self.assertEqual(len(actual), len(expected), actual)
+        for i in range(len(actual)):
+            self.assertIsInstance(actual[i], expected[i],
+                                    'item {}'.format(i))
+
+
+def parameterize(cls):
+    """A test method parameterization class decorator.
+
+    Parameters are specified as the value of a class attribute that ends with
+    the string '_params'.  Call the portion before '_params' the prefix.  Then
+    a method to be parameterized must have the same prefix, the string
+    '_as_', and an arbitrary suffix.
+
+    The value of the _params attribute may be either a dictionary or a list.
+    The values in the dictionary and the elements of the list may either be
+    single values, or a list.  If single values, they are turned into single
+    element tuples.  However derived, the resulting sequence is passed via
+    *args to the parameterized test function.
+
+    In a _params dictionary, the keys become part of the name of the generated
+    tests.  In a _params list, the values in the list are converted into a
+    string by joining the string values of the elements of the tuple by '_' and
+    converting any blanks into '_'s, and this become part of the name.
+    The  full name of a generated test is a 'test_' prefix, the portion of the
+    test function name after the  '_as_' separator, plus an '_', plus the name
+    derived as explained above.
+
+    For example, if we have:
+
+        count_params = range(2)
+
+        def count_as_foo_arg(self, foo):
+            self.assertEqual(foo+1, myfunc(foo))
+
+    we will get parameterized test methods named:
+        test_foo_arg_0
+        test_foo_arg_1
+        test_foo_arg_2
+
+    Or we could have:
+
+        example_params = {'foo': ('bar', 1), 'bing': ('bang', 2)}
+
+        def example_as_myfunc_input(self, name, count):
+            self.assertEqual(name+str(count), myfunc(name, count))
+
+    and get:
+        test_myfunc_input_foo
+        test_myfunc_input_bing
+
+    Note: if and only if the generated test name is a valid identifier can it
+    be used to select the test individually from the unittest command line.
+
+    The values in the params dict can be a single value, a tuple, or a
+    dict.  If a single value of a tuple, it is passed to the test function
+    as positional arguments.  If a dict, it is a passed via **kw.
+
+    """
+    paramdicts = {}
+    testers = collections.defaultdict(list)
+    for name, attr in cls.__dict__.items():
+        if name.endswith('_params'):
+            if not hasattr(attr, 'keys'):
+                d = {}
+                for x in attr:
+                    if not hasattr(x, '__iter__'):
+                        x = (x,)
+                    n = '_'.join(str(v) for v in x).replace(' ', '_')
+                    d[n] = x
+                attr = d
+            paramdicts[name[:-7] + '_as_'] = attr
+        if '_as_' in name:
+            testers[name.split('_as_')[0] + '_as_'].append(name)
+    testfuncs = {}
+    for name in paramdicts:
+        if name not in testers:
+            raise ValueError("No tester found for {}".format(name))
+    for name in testers:
+        if name not in paramdicts:
+            raise ValueError("No params found for {}".format(name))
+    for name, attr in cls.__dict__.items():
+        for paramsname, paramsdict in paramdicts.items():
+            if name.startswith(paramsname):
+                testnameroot = 'test_' + name[len(paramsname):]
+                for paramname, params in paramsdict.items():
+                    if hasattr(params, 'keys'):
+                        test = (lambda self, name=name, params=params:
+                                    getattr(self, name)(**params))
+                    else:
+                        test = (lambda self, name=name, params=params:
+                                        getattr(self, name)(*params))
+                    testname = testnameroot + '_' + paramname
+                    test.__name__ = testname
+                    testfuncs[testname] = test
+    for key, value in testfuncs.items():
+        setattr(cls, key, value)
+    return cls
diff --git a/Lib/test/test_email/__main__.py b/Lib/test/test_email/__main__.py
new file mode 100644
index 0000000000..4b14f773db
--- /dev/null
+++ b/Lib/test/test_email/__main__.py
@@ -0,0 +1,4 @@
+from test.test_email import load_tests
+import unittest
+
+unittest.main()
diff --git a/Lib/test/test_email/data/msg_01.txt b/Lib/test/test_email/data/msg_01.txt
new file mode 100644
index 0000000000..7e33bcf96a
--- /dev/null
+++ b/Lib/test/test_email/data/msg_01.txt
@@ -0,0 +1,19 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_02.txt b/Lib/test/test_email/data/msg_02.txt
new file mode 100644
index 0000000000..5d0a7e16c8
--- /dev/null
+++ b/Lib/test/test_email/data/msg_02.txt
@@ -0,0 +1,136 @@
+MIME-version: 1.0
+From: ppp-request@zzz.org
+Sender: ppp-admin@zzz.org
+To: ppp@zzz.org
+Subject: Ppp digest, Vol 1 #2 - 5 msgs
+Date: Fri, 20 Apr 2001 20:18:00 -0400 (EDT)
+X-Mailer: Mailman v2.0.4
+X-Mailman-Version: 2.0.4
+Content-Type: multipart/mixed; boundary="192.168.1.2.889.32614.987812255.500.21814"
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Masthead (Ppp digest, Vol 1 #2)
+
+Send Ppp mailing list submissions to
+	ppp@zzz.org
+
+To subscribe or unsubscribe via the World Wide Web, visit
+	http://www.zzz.org/mailman/listinfo/ppp
+or, via email, send a message with subject or body 'help' to
+	ppp-request@zzz.org
+
+You can reach the person managing the list at
+	ppp-admin@zzz.org
+
+When replying, please edit your Subject line so it is more specific
+than "Re: Contents of Ppp digest..."
+
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Today's Topics (5 msgs)
+
+Today's Topics:
+
+   1. testing #1 (Barry A. Warsaw)
+   2. testing #2 (Barry A. Warsaw)
+   3. testing #3 (Barry A. Warsaw)
+   4. testing #4 (Barry A. Warsaw)
+   5. testing #5 (Barry A. Warsaw)
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-Type: multipart/digest; boundary="__--__--"
+
+--__--__--
+
+Message: 1
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Date: Fri, 20 Apr 2001 20:16:13 -0400
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #1
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 2
+Date: Fri, 20 Apr 2001 20:16:21 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 3
+Date: Fri, 20 Apr 2001 20:16:25 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #3
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 4
+Date: Fri, 20 Apr 2001 20:16:28 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #4
+Precedence: bulk
+
+
+hello
+
+
+--__--__--
+
+Message: 5
+Date: Fri, 20 Apr 2001 20:16:32 -0400
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+To: ppp@zzz.org
+From: barry@digicool.com (Barry A. Warsaw)
+Subject: [Ppp] testing #5
+Precedence: bulk
+
+
+hello
+
+
+
+
+--__--__----
+
+--192.168.1.2.889.32614.987812255.500.21814
+Content-type: text/plain; charset=us-ascii
+Content-description: Digest Footer
+
+_______________________________________________
+Ppp mailing list
+Ppp@zzz.org
+http://www.zzz.org/mailman/listinfo/ppp
+
+
+--192.168.1.2.889.32614.987812255.500.21814--
+
+End of Ppp Digest
+
diff --git a/Lib/test/test_email/data/msg_03.txt b/Lib/test/test_email/data/msg_03.txt
new file mode 100644
index 0000000000..c748ebf117
--- /dev/null
+++ b/Lib/test/test_email/data/msg_03.txt
@@ -0,0 +1,16 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_04.txt b/Lib/test/test_email/data/msg_04.txt
new file mode 100644
index 0000000000..1f633c4496
--- /dev/null
+++ b/Lib/test/test_email/data/msg_04.txt
@@ -0,0 +1,37 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Received: by mail.python.org (Postfix, from userid 889)
+	id C2BF0D37C6; Tue, 11 Sep 2001 00:05:05 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="h90VIIIKmx"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15261.36209.358846.118674@anthem.python.org>
+From: barry@python.org (Barry A. Warsaw)
+To: barry@python.org
+Subject: a simple multipart
+Date: Tue, 11 Sep 2001 00:05:05 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Make a door into a window
+
+
+--h90VIIIKmx
+Content-Type: text/plain
+Content-Disposition: inline;
+	filename="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx
+Content-Type: text/plain
+Content-Disposition: inline;
+	filename="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx--
+
diff --git a/Lib/test/test_email/data/msg_05.txt b/Lib/test/test_email/data/msg_05.txt
new file mode 100644
index 0000000000..87d5e9cbf8
--- /dev/null
+++ b/Lib/test/test_email/data/msg_05.txt
@@ -0,0 +1,28 @@
+From: foo
+Subject: bar
+To: baz
+MIME-Version: 1.0
+Content-Type: multipart/report; report-type=delivery-status;
+	boundary="D1690A7AC1.996856090/mail.example.com"
+Message-Id: <20010803162810.0CA8AA7ACC@mail.example.com>
+
+This is a MIME-encapsulated message.
+
+--D1690A7AC1.996856090/mail.example.com
+Content-Type: text/plain
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com
+Content-Type: message/rfc822
+
+From: nobody@python.org
+
+Yadda yadda yadda
+
+--D1690A7AC1.996856090/mail.example.com--
+
diff --git a/Lib/test/test_email/data/msg_06.txt b/Lib/test/test_email/data/msg_06.txt
new file mode 100644
index 0000000000..f51ac96114
--- /dev/null
+++ b/Lib/test/test_email/data/msg_06.txt
@@ -0,0 +1,33 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+MIME-Version: 1.0
+Content-Type: message/rfc822
+Content-Description: forwarded message
+Content-Transfer-Encoding: 7bit
+Message-ID: <15265.9482.641338.555352@python.org>
+From: barry@python.org (Barry A. Warsaw)
+Sender: barry@python.org
+To: barry@python.org
+Subject: forwarded message from Barry A. Warsaw
+Date: Thu, 13 Sep 2001 17:28:42 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Be dirty
+X-Url: http://barry.wooz.org
+
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Message-ID: <15265.9468.713530.98441@python.org>
+From: barry@python.org (Barry A. Warsaw)
+Sender: barry@python.org
+To: barry@python.org
+Subject: testing
+Date: Thu, 13 Sep 2001 17:28:28 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Spectrum analysis
+X-Url: http://barry.wooz.org
+
+
diff --git a/Lib/test/test_email/data/msg_07.txt b/Lib/test/test_email/data/msg_07.txt
new file mode 100644
index 0000000000..721f3a0d31
--- /dev/null
+++ b/Lib/test/test_email/data/msg_07.txt
@@ -0,0 +1,83 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+Hi there,
+
+This is the dingus fish.
+
+--BOUNDARY
+Content-Type: image/gif; name="dingusfish.gif"
+Content-Transfer-Encoding: base64
+content-disposition: attachment; filename="dingusfish.gif"
+
+R0lGODdhAAEAAfAAAP///wAAACwAAAAAAAEAAQAC/oSPqcvtD6OctNqLs968+w+G4kiW5omm6sq2
+7gvH8kzX9o3n+s73/g8MCofEovGITGICTKbyCV0FDNOo9SqpQqpOrJfXzTQj2vD3TGtqL+NtGQ2f
+qTXmxzuOd7WXdcc9DyjU53ewFni4s0fGhdiYaEhGBelICTNoV1j5NUnFcrmUqemjNifJVWpaOqaI
+oFq3SspZsSraE7sHq3jr1MZqWvi662vxV4tD+pvKW6aLDOCLyur8PDwbanyDeq0N3DctbQYeLDvR
+RY6t95m6UB0d3mwIrV7e2VGNvjjffukeJp4w7F65KecGFsTHQGAygOrgrWs1jt28Rc88KESYcGLA
+/obvTkH6p+CinWJiJmIMqXGQwH/y4qk0SYjgQTczT3ajKZGfuI0uJ4kkVI/DT5s3/ejkxI0aT4Y+
+YTYgWbImUaXk9nlLmnSh1qJiJFl0OpUqRK4oOy7NyRQtHWofhoYVxkwWXKUSn0YsS+fUV6lhqfYb
+6ayd3Z5qQdG1B7bvQzaJjwUV2lixMUZ7JVsOlfjWVr/3NB/uFvnySBN6Dcb6rGwaRM3wsormw5cC
+M9NxWy/bWdufudCvy8bOAjXjVVwta/uO21sE5RHBCzNFXtgq9ORtH4eYjVP4Yryo026nvkFmCeyA
+B29efV6ravCMK5JwWd5897Qrx7ll38o6iHDZ/rXPR//feevhF4l7wjUGX3xq1eeRfM4RSJGBIV1D
+z1gKPkfWag3mVBVvva1RlX5bAJTPR/2YqNtw/FkIYYEi/pIZiAdpcxpoHtmnYYoZtvhUftzdx5ZX
+JSKDW405zkGcZzzGZ6KEv4FI224oDmijlEf+xp6MJK5ojY/ASeVUR+wsKRuJ+XFZ5o7ZeEime8t1
+ouUsU6YjF5ZtUihhkGfCdFQLWQFJ3UXxmElfhQnR+eCdcDbkFZp6vTRmj56ApCihn5QGpaToNZmR
+n3NVSpZcQpZ2KEONusaiCsKAug0wkQbJSFO+PTSjneGxOuFjPlUk3ovWvdIerjUg9ZGIOtGq/qeX
+eCYrrCX+1UPsgTKGGRSbzd5q156d/gpfbJxe66eD5iQKrXj7RGgruGxs62qebBHUKS32CKluCiqZ
+qh+pmehmEb71noAUoe5e9Zm17S7773V10pjrtG4CmuurCV/n6zLK5turWNhqOvFXbjhZrMD0YhKe
+wR0zOyuvsh6MWrGoIuzvyWu5y1WIFAqmJselypxXh6dKLNOKEB98L88bS2rkNqqlKzCNJp9c0G0j
+Gzh0iRrCbHSXmPR643QS+4rWhgFmnSbSuXCjS0xAOWkU2UdLqyuUNfHSFdUouy3bm5i5GnDM3tG8
+doJ4r5tqu3pPbRSVfvs8uJzeNXhp3n4j/tZ42SwH7eaWUUOjc3qFV9453UHTXZfcLH+OeNs5g36x
+lBnHvTm7EbMbLeuaLncao8vWCXimfo1o+843Ak6y4ChNeGntvAYvfLK4ezmoyNIbNCLTCXO9ZV3A
+E8/s88RczPzDwI4Ob7XZyl7+9Miban29h+tJZPrE21wgvBphDfrrfPdCTPKJD/y98L1rZwHcV6Jq
+Zab0metpuNIX/qAFPoz171WUaUb4HAhBSzHuHfjzHb3kha/2Cctis/ORArVHNYfFyYRH2pYIRzic
+isVOfPWD1b6mRTqpCRBozzof6UZVvFXRxWIr3GGrEviGYgyPMfahheiSaLs/9QeFu7oZ/ndSY8DD
+ya9x+uPed+7mxN2IzIISBOMLFYWVqC3Pew1T2nFuuCiwZS5/v6II10i4t1OJcUH2U9zxKodHsGGv
+Oa+zkvNUYUOa/TCCRutF9MzDwdlUMJADTCGSbDQ5OV4PTamDoPEi6Ecc/RF5RWwkcdSXvSOaDWSn
+I9LlvubFTQpuc6JKXLcKeb+xdbKRBnwREemXyjg6ME65aJiOuBgrktzykfPLJBKR9ClMavJ62/Ff
+BlNIyod9yX9wcSXexnXFpvkrbXk64xsx5Db7wXKP5fSgsvwIMM/9631VLBfkmtbHRXpqmtei52hG
+pUwSlo+BASQoeILDOBgREECxBBh5/iYmNsQ9dIv5+OI++QkqdsJPc3uykz5fkM+OraeekcQF7X4n
+B5S67za5U967PmooGQhUXfF7afXyCD7ONdRe17QogYjVx38uLwtrS6nhTnm15LQUnu9E2uK6CNI/
+1HOABj0ESwOjut4FEpFQpdNAm4K2LHnDWHNcmKB2ioKBogysVZtMO2nSxUdZ8Yk2kJc7URioLVI0
+YgmtIwZj4LoeKemgnOnbUdGnzZ4Oa6scqiolBGqS6RgWNLu0RMhcaE6rhhU4hiuqFXPAG8fGwTPW
+FKeLMtdVmXLSs5YJGF/YeVm7rREMlY3UYE+yCxbaMXX8y15m5zVHq6GOKDMynzII/jdUHdyVqIy0
+ifX2+r/EgtZcvRzSb72gU9ui87M2VecjKildW/aFqaYhKoryUjfB/g4qtyVuc60xFDGmCxwjW+qu
+zjuwl2GkOWn66+3QiiEctvd04OVvcCVzjgT7lrkvjVGKKHmmlDUKowSeikb5kK/mJReuWOxONx+s
+ULsl+Lqb0CVn0SrVyJ6wt4t6yTeSCafhPhAf0OXn6L60UMxiLolFAtmN35S2Ob1lZpQ1r/n0Qb5D
+oQ1zJiRVDgF8N3Q8TYfbi3DyWCy3lT1nxyBs6FT3S2GOzWRlxwKvlRP0RPJA9SjxEy0UoEnkA+M4
+cnzLMJrBGWLFEaaUb5lvpqbq/loOaU5+DFuHPxo82/OZuM8FXG3oVNZhtWpMpb/0Xu5m/LfLhHZQ
+7yuVI0MqZ7NE43imC8jH3IwGZlbPm0xkJYs7+2U48hXTsFSMqgGDvai0kLxyynKNT/waj+q1c1tz
+GjOpPBgdCSq3UKZxCSsqFIY+O6JbAWGWcV1pwqLyj5sGqCF1xb1F3varUWqrJv6cN3PrUXzijtfZ
+FshpBL3Xwr4GIPvU2N8EjrJgS1zl21rbXQMXeXc5jjFyrhpCzijSv/RQtyPSzHCFMhlME95fHglt
+pRsX+dfSQjUeHAlpWzJ5iOo79Ldnaxai6bXTcGO3fp07ri7HLEmXXPlYi8bv/qVxvNcdra6m7Rlb
+6JBTb5fd66VhFRjGArh2n7R1rDW4P5NOT9K0I183T2scYkeZ3q/VFyLb09U9ajzXBS8Kgkhc4mBS
+kYY9cy3Vy9lUnuNJH8HGIclUilwnBtjUOH0gteGOZ4c/XNrhXLSYDyxfnD8z1pDy7rYRvDolhnbe
+UMzxCZUs40s6s7UIvBnLgc0+vKuOkIXeOrDymlp+Zxra4MZLBbVrqD/jTJ597pDmnw5c4+DbyB88
+9Cg9DodYcSuMZT/114pptqc/EuTjRPvH/z5slzI3tluOEBBLqOXLOX+0I5929tO97wkvl/atCz+y
+xJrdwteW2FNW/NSmBP+f/maYtVs/bYyBC7Ox3jsYZHL05CIrBa/nS+b3bHfiYm4Ueil1YZZSgAUI
+fFZ1dxUmeA2oQRQ3RuGXNGLFV9/XbGFGPV6kfzk1TBBCd+izc7q1H+OHMJwmaBX2IQNYVAKHYepV
+SSGCe6CnbYHHETKGNe43EDvFgZr0gB/nVHPHZ80VV1ojOiI3XDvYIkl4ayo4bxQIgrFXWTvBI0nH
+VElWMuw2aLUWCRHHf8ymVCHjFlJnOSojfevCYyyyZDH0IcvHhrsnQ5O1OsWzONuVVKIxSxiFZ/tR
+fKDAf6xFTnw4O9Qig2VCfW2hJQrmMOuHW0W3dLQmCMO2ccdUd/xyfflH/olTiHZVdGwb8nIwRzSE
+J15jFlOJuBZBZ4CiyHyd2IFylFlB+HgHhYabhWOGwYO1ZH/Og1dtQlFMk352CGRSIFTapnWQEUtN
+l4zv8S0aaCFDyGCBqDUxZYpxGHX01y/JuH1xhn7TOCnNCI4eKDs5WGX4R425F4vF1o3BJ4vO0otq
+I3rimI7jJY1jISqnBxknCIvruF83mF5wN4X7qGLIhR8A2Vg0yFERSIXn9Vv3GHy3Vj/WIkKddlYi
+yIMv2I/VMjTLpW7pt05SWIZR0RPyxpB4SIUM9lBPGBl0GC7oSEEwRYLe4pJpZY2P0zbI1n+Oc44w
+qY3PUnmF0ixjVpDD/mJ9wpOBGTVgXlaCaZiPcIWK5NiKBIiPdGaQ0TWGvAiG7nMchdZb7Vgf8zNi
+MuMyzRdy/lePe9iC4TRx7WhhOQI/QiSVNAmAa2lT/piFbuh7ofJoYSZzrSZ1bvmWw3eN2nKUPVky
+uPN5/VRfohRd0VYZoqhKIlU6TXYhJxmPUIloAwc1bPmHEpaZYZORHNlXUJM07hATwHR8MJYqkwWR
+WaIezFhxSFlc8/Fq82hEnpeRozg3ULhhr9lAGtVEkCg5ZNRuuVleBPaZadhG0ZgkyPmDOTOKzViM
+YgOcpukKqQcbjAWS0IleQ2ROjdh6A+md1qWdBRSX7iSYgFRTtRmBpJioieXJiHfJiMGIR9fJOn8I
+MSfXYhspn4ooSa2mSAj4n+8Bmg03fBJZoPOJgsVZRxu1oOMRPXYYjdqjihFaEoZpXBREanuJoRI6
+cibFinq4ngUKh/wQd/H5ofYCZ0HJXR62opZFaAT0iFIZo4DIiUojkjeqKiuoZirKo5Y1a7AWckGa
+BkuYoD5lpDK6eUs6CkDqpETwl1EqpfhJpVeKpVl6EgUAADs=
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_08.txt b/Lib/test/test_email/data/msg_08.txt
new file mode 100644
index 0000000000..132ce7ada9
--- /dev/null
+++ b/Lib/test/test_email/data/msg_08.txt
@@ -0,0 +1,24 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_09.txt b/Lib/test/test_email/data/msg_09.txt
new file mode 100644
index 0000000000..0cfa6bab2b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_09.txt
@@ -0,0 +1,24 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: text/plain
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_10.txt b/Lib/test/test_email/data/msg_10.txt
new file mode 100644
index 0000000000..d49e477a81
--- /dev/null
+++ b/Lib/test/test_email/data/msg_10.txt
@@ -0,0 +1,39 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+Content-Transfer-Encoding: 7bit
+
+This is a 7bit encoded message.
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+Content-Transfer-Encoding: Quoted-Printable
+
+=A1This is a Quoted Printable encoded message!
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+Content-Transfer-Encoding: Base64
+
+VGhpcyBpcyBhIEJhc2U2NCBlbmNvZGVkIG1lc3NhZ2Uu
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+Content-Transfer-Encoding: Base64
+
+VGhpcyBpcyBhIEJhc2U2NCBlbmNvZGVkIG1lc3NhZ2UuCg==
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="iso-8859-1"
+
+This has no Content-Transfer-Encoding: header.
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_11.txt b/Lib/test/test_email/data/msg_11.txt
new file mode 100644
index 0000000000..8f7f1991cb
--- /dev/null
+++ b/Lib/test/test_email/data/msg_11.txt
@@ -0,0 +1,7 @@
+Content-Type: message/rfc822
+MIME-Version: 1.0
+Subject: The enclosing message
+
+Subject: An enclosed message
+
+Here is the body of the message.
diff --git a/Lib/test/test_email/data/msg_12.txt b/Lib/test/test_email/data/msg_12.txt
new file mode 100644
index 0000000000..b109b985c8
--- /dev/null
+++ b/Lib/test/test_email/data/msg_12.txt
@@ -0,0 +1,36 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: multipart/mixed; boundary="ANOTHER"
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-3"
+
+--ANOTHER--
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_12a.txt b/Lib/test/test_email/data/msg_12a.txt
new file mode 100644
index 0000000000..2092aa0c35
--- /dev/null
+++ b/Lib/test/test_email/data/msg_12a.txt
@@ -0,0 +1,38 @@
+MIME-Version: 1.0
+From: Barry Warsaw <barry@python.org>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Lyrics
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/html; charset="iso-8859-1"
+
+
+--BOUNDARY
+Content-Type: multipart/mixed; boundary="ANOTHER"
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-2"
+
+
+--ANOTHER
+Content-Type: text/plain; charset="iso-8859-3"
+
+
+--ANOTHER--
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="koi8-r"
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_13.txt b/Lib/test/test_email/data/msg_13.txt
new file mode 100644
index 0000000000..8e6d52d5be
--- /dev/null
+++ b/Lib/test/test_email/data/msg_13.txt
@@ -0,0 +1,94 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="OUTER"
+
+--OUTER
+Content-Type: text/plain; charset="us-ascii"
+
+A text/plain part
+
+--OUTER
+Content-Type: multipart/mixed; boundary=BOUNDARY
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+
+Hi there,
+
+This is the dingus fish.
+
+--BOUNDARY
+Content-Type: image/gif; name="dingusfish.gif"
+Content-Transfer-Encoding: base64
+content-disposition: attachment; filename="dingusfish.gif"
+
+R0lGODdhAAEAAfAAAP///wAAACwAAAAAAAEAAQAC/oSPqcvtD6OctNqLs968+w+G4kiW5omm6sq2
+7gvH8kzX9o3n+s73/g8MCofEovGITGICTKbyCV0FDNOo9SqpQqpOrJfXzTQj2vD3TGtqL+NtGQ2f
+qTXmxzuOd7WXdcc9DyjU53ewFni4s0fGhdiYaEhGBelICTNoV1j5NUnFcrmUqemjNifJVWpaOqaI
+oFq3SspZsSraE7sHq3jr1MZqWvi662vxV4tD+pvKW6aLDOCLyur8PDwbanyDeq0N3DctbQYeLDvR
+RY6t95m6UB0d3mwIrV7e2VGNvjjffukeJp4w7F65KecGFsTHQGAygOrgrWs1jt28Rc88KESYcGLA
+/obvTkH6p+CinWJiJmIMqXGQwH/y4qk0SYjgQTczT3ajKZGfuI0uJ4kkVI/DT5s3/ejkxI0aT4Y+
+YTYgWbImUaXk9nlLmnSh1qJiJFl0OpUqRK4oOy7NyRQtHWofhoYVxkwWXKUSn0YsS+fUV6lhqfYb
+6ayd3Z5qQdG1B7bvQzaJjwUV2lixMUZ7JVsOlfjWVr/3NB/uFvnySBN6Dcb6rGwaRM3wsormw5cC
+M9NxWy/bWdufudCvy8bOAjXjVVwta/uO21sE5RHBCzNFXtgq9ORtH4eYjVP4Yryo026nvkFmCeyA
+B29efV6ravCMK5JwWd5897Qrx7ll38o6iHDZ/rXPR//feevhF4l7wjUGX3xq1eeRfM4RSJGBIV1D
+z1gKPkfWag3mVBVvva1RlX5bAJTPR/2YqNtw/FkIYYEi/pIZiAdpcxpoHtmnYYoZtvhUftzdx5ZX
+JSKDW405zkGcZzzGZ6KEv4FI224oDmijlEf+xp6MJK5ojY/ASeVUR+wsKRuJ+XFZ5o7ZeEime8t1
+ouUsU6YjF5ZtUihhkGfCdFQLWQFJ3UXxmElfhQnR+eCdcDbkFZp6vTRmj56ApCihn5QGpaToNZmR
+n3NVSpZcQpZ2KEONusaiCsKAug0wkQbJSFO+PTSjneGxOuFjPlUk3ovWvdIerjUg9ZGIOtGq/qeX
+eCYrrCX+1UPsgTKGGRSbzd5q156d/gpfbJxe66eD5iQKrXj7RGgruGxs62qebBHUKS32CKluCiqZ
+qh+pmehmEb71noAUoe5e9Zm17S7773V10pjrtG4CmuurCV/n6zLK5turWNhqOvFXbjhZrMD0YhKe
+wR0zOyuvsh6MWrGoIuzvyWu5y1WIFAqmJselypxXh6dKLNOKEB98L88bS2rkNqqlKzCNJp9c0G0j
+Gzh0iRrCbHSXmPR643QS+4rWhgFmnSbSuXCjS0xAOWkU2UdLqyuUNfHSFdUouy3bm5i5GnDM3tG8
+doJ4r5tqu3pPbRSVfvs8uJzeNXhp3n4j/tZ42SwH7eaWUUOjc3qFV9453UHTXZfcLH+OeNs5g36x
+lBnHvTm7EbMbLeuaLncao8vWCXimfo1o+843Ak6y4ChNeGntvAYvfLK4ezmoyNIbNCLTCXO9ZV3A
+E8/s88RczPzDwI4Ob7XZyl7+9Miban29h+tJZPrE21wgvBphDfrrfPdCTPKJD/y98L1rZwHcV6Jq
+Zab0metpuNIX/qAFPoz171WUaUb4HAhBSzHuHfjzHb3kha/2Cctis/ORArVHNYfFyYRH2pYIRzic
+isVOfPWD1b6mRTqpCRBozzof6UZVvFXRxWIr3GGrEviGYgyPMfahheiSaLs/9QeFu7oZ/ndSY8DD
+ya9x+uPed+7mxN2IzIISBOMLFYWVqC3Pew1T2nFuuCiwZS5/v6II10i4t1OJcUH2U9zxKodHsGGv
+Oa+zkvNUYUOa/TCCRutF9MzDwdlUMJADTCGSbDQ5OV4PTamDoPEi6Ecc/RF5RWwkcdSXvSOaDWSn
+I9LlvubFTQpuc6JKXLcKeb+xdbKRBnwREemXyjg6ME65aJiOuBgrktzykfPLJBKR9ClMavJ62/Ff
+BlNIyod9yX9wcSXexnXFpvkrbXk64xsx5Db7wXKP5fSgsvwIMM/9631VLBfkmtbHRXpqmtei52hG
+pUwSlo+BASQoeILDOBgREECxBBh5/iYmNsQ9dIv5+OI++QkqdsJPc3uykz5fkM+OraeekcQF7X4n
+B5S67za5U967PmooGQhUXfF7afXyCD7ONdRe17QogYjVx38uLwtrS6nhTnm15LQUnu9E2uK6CNI/
+1HOABj0ESwOjut4FEpFQpdNAm4K2LHnDWHNcmKB2ioKBogysVZtMO2nSxUdZ8Yk2kJc7URioLVI0
+YgmtIwZj4LoeKemgnOnbUdGnzZ4Oa6scqiolBGqS6RgWNLu0RMhcaE6rhhU4hiuqFXPAG8fGwTPW
+FKeLMtdVmXLSs5YJGF/YeVm7rREMlY3UYE+yCxbaMXX8y15m5zVHq6GOKDMynzII/jdUHdyVqIy0
+ifX2+r/EgtZcvRzSb72gU9ui87M2VecjKildW/aFqaYhKoryUjfB/g4qtyVuc60xFDGmCxwjW+qu
+zjuwl2GkOWn66+3QiiEctvd04OVvcCVzjgT7lrkvjVGKKHmmlDUKowSeikb5kK/mJReuWOxONx+s
+ULsl+Lqb0CVn0SrVyJ6wt4t6yTeSCafhPhAf0OXn6L60UMxiLolFAtmN35S2Ob1lZpQ1r/n0Qb5D
+oQ1zJiRVDgF8N3Q8TYfbi3DyWCy3lT1nxyBs6FT3S2GOzWRlxwKvlRP0RPJA9SjxEy0UoEnkA+M4
+cnzLMJrBGWLFEaaUb5lvpqbq/loOaU5+DFuHPxo82/OZuM8FXG3oVNZhtWpMpb/0Xu5m/LfLhHZQ
+7yuVI0MqZ7NE43imC8jH3IwGZlbPm0xkJYs7+2U48hXTsFSMqgGDvai0kLxyynKNT/waj+q1c1tz
+GjOpPBgdCSq3UKZxCSsqFIY+O6JbAWGWcV1pwqLyj5sGqCF1xb1F3varUWqrJv6cN3PrUXzijtfZ
+FshpBL3Xwr4GIPvU2N8EjrJgS1zl21rbXQMXeXc5jjFyrhpCzijSv/RQtyPSzHCFMhlME95fHglt
+pRsX+dfSQjUeHAlpWzJ5iOo79Ldnaxai6bXTcGO3fp07ri7HLEmXXPlYi8bv/qVxvNcdra6m7Rlb
+6JBTb5fd66VhFRjGArh2n7R1rDW4P5NOT9K0I183T2scYkeZ3q/VFyLb09U9ajzXBS8Kgkhc4mBS
+kYY9cy3Vy9lUnuNJH8HGIclUilwnBtjUOH0gteGOZ4c/XNrhXLSYDyxfnD8z1pDy7rYRvDolhnbe
+UMzxCZUs40s6s7UIvBnLgc0+vKuOkIXeOrDymlp+Zxra4MZLBbVrqD/jTJ597pDmnw5c4+DbyB88
+9Cg9DodYcSuMZT/114pptqc/EuTjRPvH/z5slzI3tluOEBBLqOXLOX+0I5929tO97wkvl/atCz+y
+xJrdwteW2FNW/NSmBP+f/maYtVs/bYyBC7Ox3jsYZHL05CIrBa/nS+b3bHfiYm4Ueil1YZZSgAUI
+fFZ1dxUmeA2oQRQ3RuGXNGLFV9/XbGFGPV6kfzk1TBBCd+izc7q1H+OHMJwmaBX2IQNYVAKHYepV
+SSGCe6CnbYHHETKGNe43EDvFgZr0gB/nVHPHZ80VV1ojOiI3XDvYIkl4ayo4bxQIgrFXWTvBI0nH
+VElWMuw2aLUWCRHHf8ymVCHjFlJnOSojfevCYyyyZDH0IcvHhrsnQ5O1OsWzONuVVKIxSxiFZ/tR
+fKDAf6xFTnw4O9Qig2VCfW2hJQrmMOuHW0W3dLQmCMO2ccdUd/xyfflH/olTiHZVdGwb8nIwRzSE
+J15jFlOJuBZBZ4CiyHyd2IFylFlB+HgHhYabhWOGwYO1ZH/Og1dtQlFMk352CGRSIFTapnWQEUtN
+l4zv8S0aaCFDyGCBqDUxZYpxGHX01y/JuH1xhn7TOCnNCI4eKDs5WGX4R425F4vF1o3BJ4vO0otq
+I3rimI7jJY1jISqnBxknCIvruF83mF5wN4X7qGLIhR8A2Vg0yFERSIXn9Vv3GHy3Vj/WIkKddlYi
+yIMv2I/VMjTLpW7pt05SWIZR0RPyxpB4SIUM9lBPGBl0GC7oSEEwRYLe4pJpZY2P0zbI1n+Oc44w
+qY3PUnmF0ixjVpDD/mJ9wpOBGTVgXlaCaZiPcIWK5NiKBIiPdGaQ0TWGvAiG7nMchdZb7Vgf8zNi
+MuMyzRdy/lePe9iC4TRx7WhhOQI/QiSVNAmAa2lT/piFbuh7ofJoYSZzrSZ1bvmWw3eN2nKUPVky
+uPN5/VRfohRd0VYZoqhKIlU6TXYhJxmPUIloAwc1bPmHEpaZYZORHNlXUJM07hATwHR8MJYqkwWR
+WaIezFhxSFlc8/Fq82hEnpeRozg3ULhhr9lAGtVEkCg5ZNRuuVleBPaZadhG0ZgkyPmDOTOKzViM
+YgOcpukKqQcbjAWS0IleQ2ROjdh6A+md1qWdBRSX7iSYgFRTtRmBpJioieXJiHfJiMGIR9fJOn8I
+MSfXYhspn4ooSa2mSAj4n+8Bmg03fBJZoPOJgsVZRxu1oOMRPXYYjdqjihFaEoZpXBREanuJoRI6
+cibFinq4ngUKh/wQd/H5ofYCZ0HJXR62opZFaAT0iFIZo4DIiUojkjeqKiuoZirKo5Y1a7AWckGa
+BkuYoD5lpDK6eUs6CkDqpETwl1EqpfhJpVeKpVl6EgUAADs=
+
+--BOUNDARY--
+
+--OUTER--
diff --git a/Lib/test/test_email/data/msg_14.txt b/Lib/test/test_email/data/msg_14.txt
new file mode 100644
index 0000000000..5d98d2fd14
--- /dev/null
+++ b/Lib/test/test_email/data/msg_14.txt
@@ -0,0 +1,23 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+I'm sorry but I'm using a drainbread ISP, which although big and
+wealthy can't seem to generate standard compliant email. :(
+
+This message has a Content-Type: header with no subtype.  I hope you
+can still read it.
+
+-Me
diff --git a/Lib/test/test_email/data/msg_15.txt b/Lib/test/test_email/data/msg_15.txt
new file mode 100644
index 0000000000..0025624e75
--- /dev/null
+++ b/Lib/test/test_email/data/msg_15.txt
@@ -0,0 +1,52 @@
+Return-Path: <xx@xx.dk>
+Received: from fepD.post.tele.dk (195.41.46.149) by mail.groupcare.dk (LSMTP for Windows NT v1.1b) with SMTP id <0.0014F8A2@mail.groupcare.dk>; Mon, 30 Apr 2001 12:17:50 +0200
+User-Agent: Microsoft-Outlook-Express-Macintosh-Edition/5.02.2106
+Subject: XX
+From: xx@xx.dk
+To: XX
+Message-ID: <xxxx>
+Mime-version: 1.0
+Content-type: multipart/mixed;
+   boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+> Denne meddelelse er i MIME-format. Da dit postl
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: multipart/alternative;
+   boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: text/plain; charset="ISO-8859-1"
+Content-transfer-encoding: quoted-printable
+
+Some removed test. 
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: text/html; charset="ISO-8859-1"
+Content-transfer-encoding: quoted-printable
+
+<HTML>
+<HEAD>
+<TITLE>Some removed HTML</TITLE>
+</HEAD>
+<BODY>
+Some removed text.
+</BODY>
+</HTML>
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part--
+
+
+--MS_Mac_OE_3071477847_720252_MIME_Part
+Content-type: image/gif; name="xx.gif";
+ x-mac-creator="6F676C65";
+ x-mac-type="47494666"
+Content-disposition: attachment
+Content-transfer-encoding: base64
+
+Some removed base64 encoded chars.
+
+--MS_Mac_OE_3071477847_720252_MIME_Part--
+
diff --git a/Lib/test/test_email/data/msg_16.txt b/Lib/test/test_email/data/msg_16.txt
new file mode 100644
index 0000000000..56167e9f5b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_16.txt
@@ -0,0 +1,123 @@
+Return-Path: <>
+Delivered-To: scr-admin@socal-raves.org
+Received: from cougar.noc.ucla.edu (cougar.noc.ucla.edu [169.232.10.18])
+	by babylon.socal-raves.org (Postfix) with ESMTP id CCC2C51B84
+	for <scr-admin@socal-raves.org>; Sun, 23 Sep 2001 20:13:54 -0700 (PDT)
+Received: from sims-ms-daemon by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8Y@cougar.noc.ucla.edu> for scr-admin@socal-raves.org; Sun,
+ 23 Sep 2001 20:14:35 -0700 (PDT)
+Received: from cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8X@cougar.noc.ucla.edu>; Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+Date: Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+From: Internet Mail Delivery <postmaster@ucla.edu>
+Subject: Delivery Notification: Delivery has failed
+To: scr-admin@socal-raves.org
+Message-id: <0GK500B04D0B8X@cougar.noc.ucla.edu>
+MIME-version: 1.0
+Sender: scr-owner@socal-raves.org
+Errors-To: scr-owner@socal-raves.org
+X-BeenThere: scr@socal-raves.org
+X-Mailman-Version: 2.1a3
+Precedence: bulk
+List-Help: <mailto:scr-request@socal-raves.org?subject=help>
+List-Post: <mailto:scr@socal-raves.org>
+List-Subscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+	<mailto:scr-request@socal-raves.org?subject=subscribe>
+List-Id: SoCal-Raves <scr.socal-raves.org>
+List-Unsubscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+	<mailto:scr-request@socal-raves.org?subject=unsubscribe>
+List-Archive: <http://socal-raves.org/mailman/private/scr/>
+Content-Type: multipart/report; boundary="Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)"
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: text/plain; charset=ISO-8859-1
+
+This report relates to a message you sent with the following header fields:
+
+  Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+  Date: Sun, 23 Sep 2001 20:10:55 -0700
+  From: "Ian T. Henry" <henryi@oxy.edu>
+  To: SoCal Raves <scr@socal-raves.org>
+  Subject: [scr] yeah for Ians!!
+
+Your message cannot be delivered to the following recipients:
+
+  Recipient address: jangel1@cougar.noc.ucla.edu
+  Reason: recipient reached disk quota
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: message/DELIVERY-STATUS
+
+Original-envelope-id: 0GK500B4HD0888@cougar.noc.ucla.edu
+Reporting-MTA: dns; cougar.noc.ucla.edu
+
+Action: failed
+Status: 5.0.0 (recipient reached disk quota)
+Original-recipient: rfc822;jangel1@cougar.noc.ucla.edu
+Final-recipient: rfc822;jangel1@cougar.noc.ucla.edu
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)
+Content-type: MESSAGE/RFC822
+
+Return-path: scr-admin@socal-raves.org
+Received: from sims-ms-daemon by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ id <0GK500B01D0B8X@cougar.noc.ucla.edu>; Sun, 23 Sep 2001 20:14:35 -0700 (PDT)
+Received: from panther.noc.ucla.edu by cougar.noc.ucla.edu
+ (Sun Internet Mail Server sims.3.5.2000.03.23.18.03.p10)
+ with ESMTP id <0GK500B4GD0888@cougar.noc.ucla.edu> for jangel1@sims-ms-daemon;
+ Sun, 23 Sep 2001 20:14:33 -0700 (PDT)
+Received: from babylon.socal-raves.org
+ (ip-209-85-222-117.dreamhost.com [209.85.222.117])
+ by panther.noc.ucla.edu (8.9.1a/8.9.1) with ESMTP id UAA09793 for
+ <jangel1@ucla.edu>; Sun, 23 Sep 2001 20:14:32 -0700 (PDT)
+Received: from babylon (localhost [127.0.0.1]) by babylon.socal-raves.org
+ (Postfix) with ESMTP id D3B2951B70; Sun, 23 Sep 2001 20:13:47 -0700 (PDT)
+Received: by babylon.socal-raves.org (Postfix, from userid 60001)
+ id A611F51B82; Sun, 23 Sep 2001 20:13:46 -0700 (PDT)
+Received: from tiger.cc.oxy.edu (tiger.cc.oxy.edu [134.69.3.112])
+ by babylon.socal-raves.org (Postfix) with ESMTP id ADA7351B70 for
+ <scr@socal-raves.org>; Sun, 23 Sep 2001 20:13:44 -0700 (PDT)
+Received: from ent (n16h86.dhcp.oxy.edu [134.69.16.86])
+ by tiger.cc.oxy.edu (8.8.8/8.8.8) with SMTP id UAA08100 for
+ <scr@socal-raves.org>; Sun, 23 Sep 2001 20:14:24 -0700 (PDT)
+Date: Sun, 23 Sep 2001 20:10:55 -0700
+From: "Ian T. Henry" <henryi@oxy.edu>
+Subject: [scr] yeah for Ians!!
+Sender: scr-admin@socal-raves.org
+To: SoCal Raves <scr@socal-raves.org>
+Errors-to: scr-admin@socal-raves.org
+Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+MIME-version: 1.0
+X-Mailer: Microsoft Outlook Express 5.50.4522.1200
+Content-type: text/plain; charset=us-ascii
+Precedence: bulk
+Delivered-to: scr-post@babylon.socal-raves.org
+Delivered-to: scr@socal-raves.org
+X-Converted-To-Plain-Text: from multipart/alternative by demime 0.98e
+X-Converted-To-Plain-Text: Alternative section used was text/plain
+X-BeenThere: scr@socal-raves.org
+X-Mailman-Version: 2.1a3
+List-Help: <mailto:scr-request@socal-raves.org?subject=help>
+List-Post: <mailto:scr@socal-raves.org>
+List-Subscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+ <mailto:scr-request@socal-raves.org?subject=subscribe>
+List-Id: SoCal-Raves <scr.socal-raves.org>
+List-Unsubscribe: <http://socal-raves.org/mailman/listinfo/scr>,
+ <mailto:scr-request@socal-raves.org?subject=unsubscribe>
+List-Archive: <http://socal-raves.org/mailman/private/scr/>
+
+I always love to find more Ian's that are over 3 years old!!
+
+Ian
+_______________________________________________
+For event info, list questions, or to unsubscribe, see http://www.socal-raves.org/
+
+
+
+--Boundary_(ID_PGS2F2a+z+/jL7hupKgRhA)--
+
diff --git a/Lib/test/test_email/data/msg_17.txt b/Lib/test/test_email/data/msg_17.txt
new file mode 100644
index 0000000000..8d86e4180d
--- /dev/null
+++ b/Lib/test/test_email/data/msg_17.txt
@@ -0,0 +1,12 @@
+MIME-Version: 1.0
+From: Barry <barry@digicool.com>
+To: Dingus Lovers <cravindogs@cravindogs.com>
+Subject: Here is your dingus fish
+Date: Fri, 20 Apr 2001 19:35:02 -0400
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+Hi there,
+
+This is the dingus fish.
+
+[Non-text (image/gif) part of message omitted, filename dingusfish.gif]
diff --git a/Lib/test/test_email/data/msg_18.txt b/Lib/test/test_email/data/msg_18.txt
new file mode 100644
index 0000000000..f9f4904d36
--- /dev/null
+++ b/Lib/test/test_email/data/msg_18.txt
@@ -0,0 +1,6 @@
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
+	spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
+
diff --git a/Lib/test/test_email/data/msg_19.txt b/Lib/test/test_email/data/msg_19.txt
new file mode 100644
index 0000000000..49bf7fccdd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_19.txt
@@ -0,0 +1,43 @@
+Send Ppp mailing list submissions to
+	ppp@zzz.org
+
+To subscribe or unsubscribe via the World Wide Web, visit
+	http://www.zzz.org/mailman/listinfo/ppp
+or, via email, send a message with subject or body 'help' to
+	ppp-request@zzz.org
+
+You can reach the person managing the list at
+	ppp-admin@zzz.org
+
+When replying, please edit your Subject line so it is more specific
+than "Re: Contents of Ppp digest..."
+
+Today's Topics:
+
+   1. testing #1 (Barry A. Warsaw)
+   2. testing #2 (Barry A. Warsaw)
+   3. testing #3 (Barry A. Warsaw)
+   4. testing #4 (Barry A. Warsaw)
+   5. testing #5 (Barry A. Warsaw)
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+hello
+
+
+
+_______________________________________________
+Ppp mailing list
+Ppp@zzz.org
+http://www.zzz.org/mailman/listinfo/ppp
+
diff --git a/Lib/test/test_email/data/msg_20.txt b/Lib/test/test_email/data/msg_20.txt
new file mode 100644
index 0000000000..1a6a88783e
--- /dev/null
+++ b/Lib/test/test_email/data/msg_20.txt
@@ -0,0 +1,22 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Cc: ccc@zzz.org
+CC: ddd@zzz.org
+cc: eee@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_21.txt b/Lib/test/test_email/data/msg_21.txt
new file mode 100644
index 0000000000..23590b255d
--- /dev/null
+++ b/Lib/test/test_email/data/msg_21.txt
@@ -0,0 +1,20 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: Test
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+MIME message
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+One
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+Two
+--BOUNDARY--
+End of MIME message
diff --git a/Lib/test/test_email/data/msg_22.txt b/Lib/test/test_email/data/msg_22.txt
new file mode 100644
index 0000000000..af9de5fa27
--- /dev/null
+++ b/Lib/test/test_email/data/msg_22.txt
@@ -0,0 +1,46 @@
+Mime-Version: 1.0
+Message-Id: <a05001902b7f1c33773e9@[134.84.183.138]>
+Date: Tue, 16 Oct 2001 13:59:25 +0300
+To: a@example.com
+From: b@example.com
+Content-Type: multipart/mixed; boundary="============_-1208892523==_============"
+
+--============_-1208892523==_============
+Content-Type: text/plain; charset="us-ascii" ; format="flowed"
+
+Text text text.
+--============_-1208892523==_============
+Content-Id: <a05001902b7f1c33773e9@[134.84.183.138].0.0>
+Content-Type: image/jpeg; name="wibble.JPG"
+ ; x-mac-type="4A504547"
+ ; x-mac-creator="474B4F4E"
+Content-Disposition: attachment; filename="wibble.JPG"
+Content-Transfer-Encoding: base64
+
+/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAALCAXABIEBAREA
+g6bCjjw/pIZSjO6FWFpldjySOmCNrO7DBZibUXhTwtCixw+GtAijVdqxxaPp0aKvmGXa
+qrbBQvms0mAMeYS/3iTV1dG0hHaRNK01XblnWxtVdjkHLMIgTyqnk9VB7CrP2KzIINpa
+4O7I+zxYO9WV8jZg71Zlb+8rMDkEirAVQFAUAKAFAAAUAYAUDgADgY6DjpRtXj5RxjHA
+4wQRj0wQCMdCAewpaKKK/9k=
+--============_-1208892523==_============
+Content-Id: <a05001902b7f1c33773e9@[134.84.183.138].0.1>
+Content-Type: image/jpeg; name="wibble2.JPG"
+ ; x-mac-type="4A504547"
+ ; x-mac-creator="474B4F4E"
+Content-Disposition: attachment; filename="wibble2.JPG"
+Content-Transfer-Encoding: base64
+
+/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
+AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQH/wAALCAXABJ0BAREA
+/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQA
+W6NFJJBEkU10kKGTcWMDwxuU+0JHvk8qAtOpNwqSR0n8c3BlDyXHlqsUltHEiTvdXLxR
+7vMiGDNJAJWkAMk8ZkCFp5G2oo5W++INrbQtNfTQxJAuXlupz9oS4d5Y1W+E2XlWZJJE
+Y7LWYQxTLE1zuMbfBPxw8X2fibVdIbSbI6nLZxX635t9TjtYreWR7WGKJTLJFFKSlozO
+0ShxIXM43uC3/9k=
+--============_-1208892523==_============
+Content-Type: text/plain; charset="us-ascii" ; format="flowed"
+
+Text text text.
+--============_-1208892523==_============--
+
diff --git a/Lib/test/test_email/data/msg_23.txt b/Lib/test/test_email/data/msg_23.txt
new file mode 100644
index 0000000000..bb2e8ec36b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_23.txt
@@ -0,0 +1,8 @@
+From: aperson@dom.ain
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+--BOUNDARY
+Content-Type: text/plain
+
+A message part
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_24.txt b/Lib/test/test_email/data/msg_24.txt
new file mode 100644
index 0000000000..4e52339e86
--- /dev/null
+++ b/Lib/test/test_email/data/msg_24.txt
@@ -0,0 +1,10 @@
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_25.txt b/Lib/test/test_email/data/msg_25.txt
new file mode 100644
index 0000000000..9e35275fe0
--- /dev/null
+++ b/Lib/test/test_email/data/msg_25.txt
@@ -0,0 +1,117 @@
+From MAILER-DAEMON Fri Apr 06 16:46:09 2001
+Received: from [204.245.199.98] (helo=zinfandel.lacita.com)
+	by www.linux.org.uk with esmtp (Exim 3.13 #1)
+	id 14lYR6-0008Iv-00
+	for linuxuser-admin@www.linux.org.uk; Fri, 06 Apr 2001 16:46:09 +0100
+Received: from localhost (localhost) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with internal id JAB03225; Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+From: Mail Delivery Subsystem <MAILER-DAEMON@zinfandel.lacita.com>
+Subject: Returned mail: Too many hops 19 (17 max): from <linuxuser-admin@www.linux.org.uk> via [199.164.235.226], to <scoffman@wellpartner.com>
+Message-Id: <200104061723.JAB03225@zinfandel.lacita.com>
+To: <linuxuser-admin@www.linux.org.uk>
+To: postmaster@zinfandel.lacita.com
+MIME-Version: 1.0
+Content-Type: multipart/report; report-type=delivery-status;
+	bo
+Auto-Submitted: auto-generated (failure)
+
+This is a MIME-encapsulated message
+
+--JAB03225.986577786/zinfandel.lacita.com
+
+The original message was received at Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+from [199.164.235.226]
+
+   ----- The following addresses have delivery notifications -----
+<scoffman@wellpartner.com>  (unrecoverable error)
+
+   ----- Transcript of session follows -----
+554 Too many hops 19 (17 max): from <linuxuser-admin@www.linux.org.uk> via [199.164.235.226], to <scoffman@wellpartner.com>
+
+--JAB03225.986577786/zinfandel.lacita.com
+Content-Type: message/delivery-status
+
+Reporting-MTA: dns; zinfandel.lacita.com
+Received-From-MTA: dns; [199.164.235.226]
+Arrival-Date: Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+
+Final-Recipient: rfc822; scoffman@wellpartner.com
+Action: failed
+Status: 5.4.6
+Last-Attempt-Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+
+--JAB03225.986577786/zinfandel.lacita.com
+Content-Type: text/rfc822-headers
+
+Return-Path: linuxuser-admin@www.linux.org.uk
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03225 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:23:03 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03221 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:22:18 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03217 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:21:37 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03213 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:20:56 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03209 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:20:15 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03205 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:19:33 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03201 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:18:52 -0800 (GMT-0800)
+Received: from zinfandel.lacita.com ([204.245.199.98])
+	by
+	fo
+Received: from ns1.wellpartner.net ([199.164.235.226]) by zinfandel.lacita.com (8.7.3/8.6.10-MT4.00) with ESMTP id JAA03197 for <scoffman@wellpartner.com>; Fri, 6 Apr 2001 09:17:54 -0800 (GMT-0800)
+Received: from www.linux.org.uk (parcelfarce.linux.theplanet.co.uk [195.92.249.252])
+	by
+	fo
+Received: from localhost.localdomain
+	([
+	by
+	id
+Received: from [212.1.130.11] (helo=s1.uklinux.net ident=root)
+	by
+	id
+	fo
+Received: from server (ppp-2-22.cvx4.telinco.net [212.1.149.22])
+	by
+	fo
+From: Daniel James <daniel@linuxuser.co.uk>
+Organization: LinuxUser
+To: linuxuser@www.linux.org.uk
+X-Mailer: KMail [version 1.1.99]
+Content-Type: text/plain;
+  c
+MIME-Version: 1.0
+Message-Id: <01040616033903.00962@server>
+Content-Transfer-Encoding: 8bit
+Subject: [LinuxUser] bulletin no. 45
+Sender: linuxuser-admin@www.linux.org.uk
+Errors-To: linuxuser-admin@www.linux.org.uk
+X-BeenThere: linuxuser@www.linux.org.uk
+X-Mailman-Version: 2.0.3
+Precedence: bulk
+List-Help: <mailto:linuxuser-request@www.linux.org.uk?subject=help>
+List-Post: <mailto:linuxuser@www.linux.org.uk>
+List-Subscribe: <http://www.linux.org.uk/mailman/listinfo/linuxuser>,
+	<m
+List-Id: bulletins from LinuxUser magazine <linuxuser.www.linux.org.uk>
+List-Unsubscribe: <http://www.linux.org.uk/mailman/listinfo/linuxuser>,
+	<m
+List-Archive: <http://www.linux.org.uk/pipermail/linuxuser/>
+Date: Fri, 6 Apr 2001 16:03:39 +0100
+
+--JAB03225.986577786/zinfandel.lacita.com--
+
+
diff --git a/Lib/test/test_email/data/msg_26.txt b/Lib/test/test_email/data/msg_26.txt
new file mode 100644
index 0000000000..58efaa9c9a
--- /dev/null
+++ b/Lib/test/test_email/data/msg_26.txt
@@ -0,0 +1,46 @@
+Received: from xcar [192.168.0.2] by jeeves.wooster.local
+  (SMTPD32-7.07 EVAL) id AFF92F0214; Sun, 12 May 2002 08:55:37 +0100
+Date: Sun, 12 May 2002 08:56:15 +0100
+From: Father Time <father.time@xcar.wooster.local>
+To: timbo@jeeves.wooster.local
+Subject: IMAP file test
+Message-ID: <6df65d354b.father.time@rpc.wooster.local>
+X-Organization: Home
+User-Agent: Messenger-Pro/2.50a (MsgServe/1.50) (RISC-OS/4.02) POPstar/2.03
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="1618492860--2051301190--113853680"
+Status: R
+X-UIDL: 319998302
+
+This message is in MIME format which your mailer apparently does not support.
+You either require a newer version of your software which supports MIME, or
+a separate MIME decoding utility.  Alternatively, ask the sender of this
+message to resend it in a different format.
+
+--1618492860--2051301190--113853680
+Content-Type: text/plain; charset=us-ascii
+
+Simple email with attachment.
+
+
+--1618492860--2051301190--113853680
+Content-Type: application/riscos; name="clock.bmp,69c"; type=BMP;
+	load=&fff69c4b; exec=&355dd4d1; access=&03
+Content-Disposition: attachment; filename="clock.bmp"
+Content-Transfer-Encoding: base64
+
+Qk12AgAAAAAAAHYAAAAoAAAAIAAAACAAAAABAAQAAAAAAAAAAADXDQAA1w0AAAAAAAAA
+AAAAAAAAAAAAiAAAiAAAAIiIAIgAAACIAIgAiIgAALu7uwCIiIgAERHdACLuIgAz//8A
+zAAAAN0R3QDu7iIA////AAAAAAAAAAAAAAAAAAAAAAAAAAi3AAAAAAAAADeAAAAAAAAA
+C3ADMzMzMANwAAAAAAAAAAAHMAAAAANwAAAAAAAAAACAMAd3zPfwAwgAAAAAAAAIAwd/
+f8x/f3AwgAAAAAAAgDB0x/f3//zPAwgAAAAAAAcHfM9////8z/AwAAAAAAiwd/f3////
+////A4AAAAAAcEx/f///////zAMAAAAAiwfM9////3///8zwOAAAAAcHf3////B/////
+8DAAAAALB/f3///wd3d3//AwAAAABwTPf//wCQAAD/zAMAAAAAsEx/f///B////8wDAA
+AAAHB39////wf/////AwAAAACwf39///8H/////wMAAAAIcHfM9///B////M8DgAAAAA
+sHTH///wf///xAMAAAAACHB3f3//8H////cDgAAAAAALB3zH//D//M9wMAAAAAAAgLB0
+z39///xHAwgAAAAAAAgLB3d3RHd3cDCAAAAAAAAAgLAHd0R3cAMIAAAAAAAAgAgLcAAA
+AAMwgAgAAAAACDAAAAu7t7cwAAgDgAAAAABzcIAAAAAAAAgDMwAAAAAAN7uwgAAAAAgH
+MzMAAAAACH97tzAAAAALu3c3gAAAAAAL+7tzDABAu7f7cAAAAAAACA+3MA7EQAv/sIAA
+AAAAAAAIAAAAAAAAAIAAAAAA
+
+--1618492860--2051301190--113853680--
diff --git a/Lib/test/test_email/data/msg_27.txt b/Lib/test/test_email/data/msg_27.txt
new file mode 100644
index 0000000000..d0191769d7
--- /dev/null
+++ b/Lib/test/test_email/data/msg_27.txt
@@ -0,0 +1,15 @@
+Return-Path: <aperson@dom.ain>
+Received: by mail.dom.ain (Postfix, from userid 889)
+	id B9D0AD35DB; Tue,  4 Jun 2002 21:46:59 -0400 (EDT)
+Message-ID: <15613.28051.707126.569693@dom.ain>
+Date: Tue, 4 Jun 2002 21:46:59 -0400
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii
+Content-Transfer-Encoding: 7bit
+Subject: bug demonstration
+	12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+	more text
+From: aperson@dom.ain (Anne P. Erson)
+To: bperson@dom.ain (Barney P. Erson)
+
+test
diff --git a/Lib/test/test_email/data/msg_28.txt b/Lib/test/test_email/data/msg_28.txt
new file mode 100644
index 0000000000..1e4824cabb
--- /dev/null
+++ b/Lib/test/test_email/data/msg_28.txt
@@ -0,0 +1,25 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/digest; boundary=BOUNDARY
+
+--BOUNDARY
+Content-Type: message/rfc822
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 1
+
+--BOUNDARY
+Content-Type: message/rfc822
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_29.txt b/Lib/test/test_email/data/msg_29.txt
new file mode 100644
index 0000000000..1fab561617
--- /dev/null
+++ b/Lib/test/test_email/data/msg_29.txt
@@ -0,0 +1,22 @@
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+	id 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=us-ascii;
+     title*0*="us-ascii'en'This%20is%20even%20more%20";
+     title*1*="%2A%2A%2Afun%2A%2A%2A%20";
+     title*2="isn't it!"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+
+
+Hi,
+
+Do you like this message?
+
+-Me
diff --git a/Lib/test/test_email/data/msg_30.txt b/Lib/test/test_email/data/msg_30.txt
new file mode 100644
index 0000000000..4334bb6e60
--- /dev/null
+++ b/Lib/test/test_email/data/msg_30.txt
@@ -0,0 +1,23 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/digest; boundary=BOUNDARY
+
+--BOUNDARY
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 1
+
+--BOUNDARY
+
+Content-Type: text/plain; charset=us-ascii
+To: aa@bb.org
+From: cc@dd.org
+Subject: ee
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_31.txt b/Lib/test/test_email/data/msg_31.txt
new file mode 100644
index 0000000000..1e58e56cf5
--- /dev/null
+++ b/Lib/test/test_email/data/msg_31.txt
@@ -0,0 +1,15 @@
+From: aperson@dom.ain
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=BOUNDARY_
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 1
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 2
+
+--BOUNDARY--
diff --git a/Lib/test/test_email/data/msg_32.txt b/Lib/test/test_email/data/msg_32.txt
new file mode 100644
index 0000000000..07ec5af9a3
--- /dev/null
+++ b/Lib/test/test_email/data/msg_32.txt
@@ -0,0 +1,14 @@
+Delivered-To: freebsd-isp@freebsd.org
+Date: Tue, 26 Sep 2000 12:23:03 -0500
+From: Anne Person <aperson@example.com>
+To: Barney Dude <bdude@example.com>
+Subject: Re: Limiting Perl CPU Utilization...
+Mime-Version: 1.0
+Content-Type: text/plain; charset*=ansi-x3.4-1968''us-ascii
+Content-Disposition: inline
+User-Agent: Mutt/1.3.8i
+Sender: owner-freebsd-isp@FreeBSD.ORG
+Precedence: bulk
+X-Loop: FreeBSD.org
+
+Some message.
diff --git a/Lib/test/test_email/data/msg_33.txt b/Lib/test/test_email/data/msg_33.txt
new file mode 100644
index 0000000000..042787a4fd
--- /dev/null
+++ b/Lib/test/test_email/data/msg_33.txt
@@ -0,0 +1,29 @@
+Delivered-To: freebsd-isp@freebsd.org
+Date: Wed, 27 Sep 2000 11:11:09 -0500
+From: Anne Person <aperson@example.com>
+To: Barney Dude <bdude@example.com>
+Subject: Re: Limiting Perl CPU Utilization...
+Mime-Version: 1.0
+Content-Type: multipart/signed; micalg*=ansi-x3.4-1968''pgp-md5;
+	protocol*=ansi-x3.4-1968''application%2Fpgp-signature;
+	boundary*="ansi-x3.4-1968''EeQfGwPcQSOJBaQU"
+Content-Disposition: inline
+Sender: owner-freebsd-isp@FreeBSD.ORG
+Precedence: bulk
+X-Loop: FreeBSD.org
+
+
+--EeQfGwPcQSOJBaQU
+Content-Type: text/plain; charset*=ansi-x3.4-1968''us-ascii
+Content-Disposition: inline
+Content-Transfer-Encoding: quoted-printable
+
+part 1
+
+--EeQfGwPcQSOJBaQU
+Content-Type: text/plain
+Content-Disposition: inline
+
+part 2
+
+--EeQfGwPcQSOJBaQU--
diff --git a/Lib/test/test_email/data/msg_34.txt b/Lib/test/test_email/data/msg_34.txt
new file mode 100644
index 0000000000..055dfea531
--- /dev/null
+++ b/Lib/test/test_email/data/msg_34.txt
@@ -0,0 +1,19 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Content-Type: multipart/digest; boundary=XYZ
+
+--XYZ
+Content-Type: text/plain
+
+
+This is a text plain part that is counter to recommended practice in
+RFC 2046, $5.1.5, but is not illegal
+
+--XYZ
+
+From: cperson@dom.ain
+To: dperson@dom.ain
+
+A submessage
+
+--XYZ--
diff --git a/Lib/test/test_email/data/msg_35.txt b/Lib/test/test_email/data/msg_35.txt
new file mode 100644
index 0000000000..0e2bbcaf71
--- /dev/null
+++ b/Lib/test/test_email/data/msg_35.txt
@@ -0,0 +1,4 @@
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: here's something interesting
+counter to RFC 5322, there's no separating newline here
diff --git a/Lib/test/test_email/data/msg_36.txt b/Lib/test/test_email/data/msg_36.txt
new file mode 100644
index 0000000000..5632c3062c
--- /dev/null
+++ b/Lib/test/test_email/data/msg_36.txt
@@ -0,0 +1,40 @@
+Mime-Version: 1.0
+Content-Type: Multipart/Mixed; Boundary="NextPart"
+To: IETF-Announce:;
+From: Internet-Drafts@ietf.org
+Subject: I-D ACTION:draft-ietf-mboned-mix-00.txt
+Date: Tue, 22 Dec 1998 16:55:06 -0500
+
+--NextPart
+
+Blah blah blah
+
+--NextPart
+Content-Type: Multipart/Alternative; Boundary="OtherAccess"
+
+--OtherAccess
+Content-Type: Message/External-body;
+	access-type="mail-server";
+	server="mailserv@ietf.org"
+
+Content-Type: text/plain
+Content-ID: <19981222151406.I-D@ietf.org>
+
+ENCODING mime
+FILE /internet-drafts/draft-ietf-mboned-mix-00.txt
+
+--OtherAccess
+Content-Type: Message/External-body;
+	name="draft-ietf-mboned-mix-00.txt";
+	site="ftp.ietf.org";
+	access-type="anon-ftp";
+	directory="internet-drafts"
+
+Content-Type: text/plain
+Content-ID: <19981222151406.I-D@ietf.org>
+
+
+--OtherAccess--
+
+--NextPart--
+
diff --git a/Lib/test/test_email/data/msg_37.txt b/Lib/test/test_email/data/msg_37.txt
new file mode 100644
index 0000000000..038d34a1a4
--- /dev/null
+++ b/Lib/test/test_email/data/msg_37.txt
@@ -0,0 +1,22 @@
+Content-Type: multipart/mixed; boundary=ABCDE
+
+--ABCDE
+Content-Type: text/x-one
+
+Blah
+
+--ABCDE
+--ABCDE
+Content-Type: text/x-two
+
+Blah
+
+--ABCDE
+--ABCDE
+--ABCDE
+--ABCDE
+Content-Type: text/x-two
+
+Blah
+
+--ABCDE--
diff --git a/Lib/test/test_email/data/msg_38.txt b/Lib/test/test_email/data/msg_38.txt
new file mode 100644
index 0000000000..006df81cb5
--- /dev/null
+++ b/Lib/test/test_email/data/msg_38.txt
@@ -0,0 +1,101 @@
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
+
+------- =_aaaaaaaaaa0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.1@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa2"
+Content-ID: <20592.1022586929.2@example.com>
+
+------- =_aaaaaaaaaa2
+Content-Type: text/plain
+Content-ID: <20592.1022586929.3@example.com>
+Content-Description: very tricky
+Content-Transfer-Encoding: 7bit
+
+
+Unlike the test test_nested-multiples-with-internal-boundary, this
+piece of text not only contains the outer boundary tags 
+------- =_aaaaaaaaaa1 
+and 
+------- =_aaaaaaaaaa0 
+but puts them at the start of a line! And, to be even nastier, it
+even includes a couple of end tags, such as this one:
+
+------- =_aaaaaaaaaa1--
+
+and this one, which is from a multipart we haven't even seen yet!
+
+------- =_aaaaaaaaaa4--
+
+This will, I'm sure, cause much breakage of MIME parsers. But, as 
+far as I can tell, it's perfectly legal. I have not yet ever seen
+a case of this in the wild, but I've seen *similar* things.
+
+
+------- =_aaaaaaaaaa2
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.4@example.com>
+Content-Description: patch2
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa2--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa3"
+Content-ID: <20592.1022586929.6@example.com>
+
+------- =_aaaaaaaaaa3
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.7@example.com>
+Content-Description: patch3
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa3
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.8@example.com>
+Content-Description: patch4
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa3--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa4"
+Content-ID: <20592.1022586929.10@example.com>
+
+------- =_aaaaaaaaaa4
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.11@example.com>
+Content-Description: patch5
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa4
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.12@example.com>
+Content-Description: patch6
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa4--
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa0
+Content-Type: text/plain; charset="us-ascii"
+Content-ID: <20592.1022586929.15@example.com>
+
+--
+It's never too late to have a happy childhood.
+
+------- =_aaaaaaaaaa0--
diff --git a/Lib/test/test_email/data/msg_39.txt b/Lib/test/test_email/data/msg_39.txt
new file mode 100644
index 0000000000..124b269192
--- /dev/null
+++ b/Lib/test/test_email/data/msg_39.txt
@@ -0,0 +1,83 @@
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa0"
+
+------- =_aaaaaaaaaa0
+Content-Type: multipart/mixed; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.1@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.2@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.3@example.com>
+Content-Description: patch1
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.4@example.com>
+Content-Description: patch2
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.6@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.7@example.com>
+Content-Description: patch3
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.8@example.com>
+Content-Description: patch4
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1
+Content-Type: multipart/alternative; boundary="----- =_aaaaaaaaaa1"
+Content-ID: <20592.1022586929.10@example.com>
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.11@example.com>
+Content-Description: patch5
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1
+Content-Type: application/octet-stream
+Content-ID: <20592.1022586929.12@example.com>
+Content-Description: patch6
+Content-Transfer-Encoding: base64
+
+XXX
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa1--
+
+------- =_aaaaaaaaaa0
+Content-Type: text/plain; charset="us-ascii"
+Content-ID: <20592.1022586929.15@example.com>
+
+--
+It's never too late to have a happy childhood.
+
+------- =_aaaaaaaaaa0--
diff --git a/Lib/test/test_email/data/msg_40.txt b/Lib/test/test_email/data/msg_40.txt
new file mode 100644
index 0000000000..1435fa1e1a
--- /dev/null
+++ b/Lib/test/test_email/data/msg_40.txt
@@ -0,0 +1,10 @@
+MIME-Version: 1.0
+Content-Type: text/html; boundary="--961284236552522269"
+
+----961284236552522269
+Content-Type: text/html;
+Content-Transfer-Encoding: 7Bit
+
+<html></html>
+
+----961284236552522269--
diff --git a/Lib/test/test_email/data/msg_41.txt b/Lib/test/test_email/data/msg_41.txt
new file mode 100644
index 0000000000..76cdd1cb7f
--- /dev/null
+++ b/Lib/test/test_email/data/msg_41.txt
@@ -0,0 +1,8 @@
+From: "Allison Dunlap" <xxx@example.com>
+To: yyy@example.com
+Subject: 64423
+Date: Sun, 11 Jul 2004 16:09:27 -0300
+MIME-Version: 1.0
+Content-Type: multipart/alternative;
+
+Blah blah blah
diff --git a/Lib/test/test_email/data/msg_42.txt b/Lib/test/test_email/data/msg_42.txt
new file mode 100644
index 0000000000..a75f8f4a02
--- /dev/null
+++ b/Lib/test/test_email/data/msg_42.txt
@@ -0,0 +1,20 @@
+Content-Type: multipart/mixed; boundary="AAA"
+From: Mail Delivery Subsystem <xxx@example.com>
+To: yyy@example.com
+
+This is a MIME-encapsulated message
+
+--AAA
+
+Stuff
+
+--AAA
+Content-Type: message/rfc822
+
+From: webmaster@python.org
+To: zzz@example.com
+Content-Type: multipart/mixed; boundary="BBB"
+
+--BBB--
+
+--AAA--
diff --git a/Lib/test/test_email/data/msg_43.txt b/Lib/test/test_email/data/msg_43.txt
new file mode 100644
index 0000000000..797d12c568
--- /dev/null
+++ b/Lib/test/test_email/data/msg_43.txt
@@ -0,0 +1,217 @@
+From SRS0=aO/p=ON=bag.python.org=None@bounce2.pobox.com  Fri Nov 26 21:40:36 2004
+X-VM-v5-Data: ([nil nil nil nil nil nil nil nil nil]
+	[nil nil nil nil nil nil nil "MAILER DAEMON <>" "MAILER DAEMON <>" nil nil "Banned file: auto__mail.python.bat in mail from you" "^From:" nil nil nil nil "Banned file: auto__mail.python.bat in mail from you" nil nil nil nil nil nil nil]
+	nil)
+MIME-Version: 1.0
+Message-Id: <edab.7804f5cb8070@python.org>
+Content-Type: multipart/report; report-type=delivery-status;
+    charset=utf-8;
+    boundary="----------=_1101526904-1956-5"
+X-Virus-Scanned: by XS4ALL Virus Scanner
+X-UIDL: 4\G!!!<c"!UV["!M7C!!
+From: MAILER DAEMON <>
+To: <webmaster@python.org>
+Subject: Banned file: auto__mail.python.bat in mail from you
+Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+This is a multi-part message in MIME format...
+
+------------=_1101526904-1956-5
+Content-Type: text/plain; charset="utf-8"
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+
+BANNED FILENAME ALERT
+
+Your message to: xxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxx@dot.ca.gov, xxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxx@dot.ca.gov, xxxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxx@dot.ca.gov, xxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxx@dot.ca.gov, xxxx@dot.ca.gov, xxxxxxxx@dot.ca.gov, xxxxxxxxxx@dot.ca.gov, xxxxxxxxxxxxxxxxxx@dot.ca.gov
+was blocked by our Spam Firewall. The email you sent with the following subject has NOT BEEN DELIVERED:
+
+Subject: Delivery_failure_notice
+
+An attachment in that mail was of a file type that the Spam Firewall is set to block.
+
+
+
+------------=_1101526904-1956-5
+Content-Type: message/delivery-status
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+Content-Description: Delivery error report
+
+Reporting-MTA: dns; sacspam01.dot.ca.gov
+Received-From-MTA: smtp; sacspam01.dot.ca.gov ([127.0.0.1])
+Arrival-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+Final-Recipient: rfc822; xxxxxxx@dot.ca.gov
+Action: failed
+Status: 5.7.1
+Diagnostic-Code: smtp; 550 5.7.1 Message content rejected, id=01956-02-2 - BANNED: auto__mail.python.bat
+Last-Attempt-Date: Fri, 26 Nov 2004 19:41:44 -0800 (PST)
+
+------------=_1101526904-1956-5
+Content-Type: text/rfc822-headers
+Content-Disposition: inline
+Content-Transfer-Encoding: 7bit
+Content-Description: Undelivered-message headers
+
+Received: from kgsav.org (ppp-70-242-162-63.dsl.spfdmo.swbell.net [70.242.162.63])
+	by sacspam01.dot.ca.gov (Spam Firewall) with SMTP
+	id A232AD03DE3A; Fri, 26 Nov 2004 19:41:35 -0800 (PST)
+From: webmaster@python.org
+To: xxxxx@dot.ca.gov
+Date: Sat, 27 Nov 2004 03:35:30 UTC
+Subject: Delivery_failure_notice
+Importance: Normal
+X-Priority: 3 (Normal)
+X-MSMail-Priority: Normal
+Message-ID: <edab.7804f5cb8070@python.org>
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="====67bd2b7a5.f99f7"
+Content-Transfer-Encoding: 7bit
+
+------------=_1101526904-1956-5--
+
diff --git a/Lib/test/test_email/data/msg_44.txt b/Lib/test/test_email/data/msg_44.txt
new file mode 100644
index 0000000000..15a225287b
--- /dev/null
+++ b/Lib/test/test_email/data/msg_44.txt
@@ -0,0 +1,33 @@
+Return-Path: <barry@python.org>
+Delivered-To: barry@python.org
+Received: by mail.python.org (Postfix, from userid 889)
+	id C2BF0D37C6; Tue, 11 Sep 2001 00:05:05 -0400 (EDT)
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="h90VIIIKmx"
+Content-Transfer-Encoding: 7bit
+Message-ID: <15261.36209.358846.118674@anthem.python.org>
+From: barry@python.org (Barry A. Warsaw)
+To: barry@python.org
+Subject: a simple multipart
+Date: Tue, 11 Sep 2001 00:05:05 -0400
+X-Mailer: VM 6.95 under 21.4 (patch 4) "Artificial Intelligence" XEmacs Lucid
+X-Attribution: BAW
+X-Oblique-Strategy: Make a door into a window
+
+
+--h90VIIIKmx
+Content-Type: text/plain; name="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx
+Content-Type: text/plain; name="msg.txt"
+Content-Transfer-Encoding: 7bit
+
+a simple kind of mirror
+to reflect upon our own
+
+--h90VIIIKmx--
+
diff --git a/Lib/test/test_email/data/msg_45.txt b/Lib/test/test_email/data/msg_45.txt
new file mode 100644
index 0000000000..58fde956e7
--- /dev/null
+++ b/Lib/test/test_email/data/msg_45.txt
@@ -0,0 +1,33 @@
+From: <foo@bar.baz>
+To: <baz@bar.foo>
+Subject: test
+X-Long-Line: Some really long line contains a lot of text and thus has to be rewrapped because it is some
+	really long
+        line
+MIME-Version: 1.0
+Content-Type: multipart/signed; boundary="borderline";
+	protocol="application/pgp-signature"; micalg=pgp-sha1
+
+This is an OpenPGP/MIME signed message (RFC 2440 and 3156)
+--borderline
+Content-Type: text/plain
+X-Long-Line: Another really long line contains a lot of text and thus has to be rewrapped because it is another
+	really long
+        line
+
+This is the signed contents.
+
+--borderline
+Content-Type: application/pgp-signature; name="signature.asc"
+Content-Description: OpenPGP digital signature
+Content-Disposition: attachment; filename="signature.asc"
+
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.6 (GNU/Linux)
+
+iD8DBQFG03voRhp6o4m9dFsRApSZAKCCAN3IkJlVRg6NvAiMHlvvIuMGPQCeLZtj
+FGwfnRHFBFO/S4/DKysm0lI=
+=t7+s
+-----END PGP SIGNATURE-----
+
+--borderline--
diff --git a/Lib/test/test_email/data/msg_46.txt b/Lib/test/test_email/data/msg_46.txt
new file mode 100644
index 0000000000..1e22c4f600
--- /dev/null
+++ b/Lib/test/test_email/data/msg_46.txt
@@ -0,0 +1,23 @@
+Return-Path: <sender@example.net>
+Delivery-Date: Mon, 08 Feb 2010 14:05:16 +0100
+Received: from example.org (example.org [64.5.53.58])
+    by example.net (node=mxbap2) with ESMTP (Nemesis)
+    id UNIQUE for someone@example.com; Mon, 08 Feb 2010 14:05:16 +0100
+Date: Mon, 01 Feb 2010 12:21:16 +0100
+From: "Sender" <sender@example.net>
+To: <someone@example.com>
+Subject: GroupwiseForwardingTest
+Mime-Version: 1.0
+Content-Type: message/rfc822
+
+Return-path: <sender@example.net>
+Message-ID: <4B66B890.4070408@teconcept.de>
+Date: Mon, 01 Feb 2010 12:18:40 +0100
+From: "Dr. Sender" <sender@example.net>
+MIME-Version: 1.0
+To: "Recipient" <recipient@example.com>
+Subject: GroupwiseForwardingTest
+Content-Type: text/plain; charset=ISO-8859-15
+Content-Transfer-Encoding: 7bit
+
+Testing email forwarding with Groupwise 1.2.2010
diff --git a/Lib/test/test_email/data/msg_47.txt b/Lib/test/test_email/data/msg_47.txt
new file mode 100644
index 0000000000..bb48b47d96
--- /dev/null
+++ b/Lib/test/test_email/data/msg_47.txt
@@ -0,0 +1,14 @@
+Date: 01 Jan 2001 00:01+0000
+From: arthur@example.example
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary=foo
+
+--foo
+Content-Type: text/plain
+bar
+
+--foo
+Content-Type: text/html
+<html><body><p>baz</p></body></html>
+
+--foo--
\ No newline at end of file
diff --git a/Lib/test/test_email/data/python.bmp b/Lib/test/test_email/data/python.bmp
new file mode 100644
index 0000000000..675f95191a
Binary files /dev/null and b/Lib/test/test_email/data/python.bmp differ
diff --git a/Lib/test/test_email/data/python.exr b/Lib/test/test_email/data/python.exr
new file mode 100644
index 0000000000..773c81ee1f
Binary files /dev/null and b/Lib/test/test_email/data/python.exr differ
diff --git a/Lib/test/test_email/data/python.gif b/Lib/test/test_email/data/python.gif
new file mode 100644
index 0000000000..efa0be3861
Binary files /dev/null and b/Lib/test/test_email/data/python.gif differ
diff --git a/Lib/test/test_email/data/python.jpg b/Lib/test/test_email/data/python.jpg
new file mode 100644
index 0000000000..21222c09f5
Binary files /dev/null and b/Lib/test/test_email/data/python.jpg differ
diff --git a/Lib/test/test_email/data/python.pbm b/Lib/test/test_email/data/python.pbm
new file mode 100644
index 0000000000..1848ba7ff0
--- /dev/null
+++ b/Lib/test/test_email/data/python.pbm
@@ -0,0 +1,3 @@
+P4
+16 16
+�������[�a_�X
�
�
����?��
\ No newline at end of file
diff --git a/Lib/test/test_email/data/python.pgm b/Lib/test/test_email/data/python.pgm
new file mode 100644
index 0000000000..8349f2a53a
Binary files /dev/null and b/Lib/test/test_email/data/python.pgm differ
diff --git a/Lib/test/test_email/data/python.png b/Lib/test/test_email/data/python.png
new file mode 100644
index 0000000000..1a987f79fc
Binary files /dev/null and b/Lib/test/test_email/data/python.png differ
diff --git a/Lib/test/test_email/data/python.ppm b/Lib/test/test_email/data/python.ppm
new file mode 100644
index 0000000000..7d9cdb3215
Binary files /dev/null and b/Lib/test/test_email/data/python.ppm differ
diff --git a/Lib/test/test_email/data/python.ras b/Lib/test/test_email/data/python.ras
new file mode 100644
index 0000000000..130e96f817
Binary files /dev/null and b/Lib/test/test_email/data/python.ras differ
diff --git a/Lib/test/test_email/data/python.sgi b/Lib/test/test_email/data/python.sgi
new file mode 100644
index 0000000000..ffe9081c7a
Binary files /dev/null and b/Lib/test/test_email/data/python.sgi differ
diff --git a/Lib/test/test_email/data/python.tiff b/Lib/test/test_email/data/python.tiff
new file mode 100644
index 0000000000..39d0bfcec0
Binary files /dev/null and b/Lib/test/test_email/data/python.tiff differ
diff --git a/Lib/test/test_email/data/python.webp b/Lib/test/test_email/data/python.webp
new file mode 100644
index 0000000000..e824ec7fb1
Binary files /dev/null and b/Lib/test/test_email/data/python.webp differ
diff --git a/Lib/test/test_email/data/python.xbm b/Lib/test/test_email/data/python.xbm
new file mode 100644
index 0000000000..cfbee2e980
--- /dev/null
+++ b/Lib/test/test_email/data/python.xbm
@@ -0,0 +1,6 @@
+#define python_width 16
+#define python_height 16
+static char python_bits[] = {
+  0xDF, 0xFE, 0x8F, 0xFD, 0x5F, 0xFB, 0xAB, 0xFE, 0xB5, 0x8D, 0xDA, 0x8F, 
+  0xA5, 0x86, 0xFA, 0x83, 0x1A, 0x80, 0x0D, 0x80, 0x0D, 0x80, 0x0F, 0xE0, 
+  0x0F, 0xF8, 0x0F, 0xF8, 0x0F, 0xFC, 0xFF, 0xFF, };
diff --git a/Lib/test/test_email/data/sndhdr.aifc b/Lib/test/test_email/data/sndhdr.aifc
new file mode 100644
index 0000000000..8aae4e730b
Binary files /dev/null and b/Lib/test/test_email/data/sndhdr.aifc differ
diff --git a/Lib/test/test_email/data/sndhdr.aiff b/Lib/test/test_email/data/sndhdr.aiff
new file mode 100644
index 0000000000..8c279a762f
Binary files /dev/null and b/Lib/test/test_email/data/sndhdr.aiff differ
diff --git a/Lib/test/test_email/data/sndhdr.au b/Lib/test/test_email/data/sndhdr.au
new file mode 100644
index 0000000000..f76b0501b8
Binary files /dev/null and b/Lib/test/test_email/data/sndhdr.au differ
diff --git a/Lib/test/test_email/data/sndhdr.wav b/Lib/test/test_email/data/sndhdr.wav
new file mode 100644
index 0000000000..0dca36739c
Binary files /dev/null and b/Lib/test/test_email/data/sndhdr.wav differ
diff --git a/Lib/test/test_email/test__encoded_words.py b/Lib/test/test_email/test__encoded_words.py
new file mode 100644
index 0000000000..dcac7d34e9
--- /dev/null
+++ b/Lib/test/test_email/test__encoded_words.py
@@ -0,0 +1,208 @@
+import unittest
+from email import _encoded_words as _ew
+from email import errors
+from test.test_email import TestEmailBase
+
+
+class TestDecodeQ(TestEmailBase):
+
+    def _test(self, source, ex_result, ex_defects=[]):
+        result, defects = _ew.decode_q(source)
+        self.assertEqual(result, ex_result)
+        self.assertDefectsEqual(defects, ex_defects)
+
+    def test_no_encoded(self):
+        self._test(b'foobar', b'foobar')
+
+    def test_spaces(self):
+        self._test(b'foo=20bar=20', b'foo bar ')
+        self._test(b'foo_bar_', b'foo bar ')
+
+    def test_run_of_encoded(self):
+        self._test(b'foo=20=20=21=2Cbar', b'foo  !,bar')
+
+
+class TestDecodeB(TestEmailBase):
+
+    def _test(self, source, ex_result, ex_defects=[]):
+        result, defects = _ew.decode_b(source)
+        self.assertEqual(result, ex_result)
+        self.assertDefectsEqual(defects, ex_defects)
+
+    def test_simple(self):
+        self._test(b'Zm9v', b'foo')
+
+    def test_missing_padding(self):
+        # 1 missing padding character
+        self._test(b'dmk', b'vi', [errors.InvalidBase64PaddingDefect])
+        # 2 missing padding characters
+        self._test(b'dg', b'v', [errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_character(self):
+        self._test(b'dm\x01k===', b'vi', [errors.InvalidBase64CharactersDefect])
+
+    def test_invalid_character_and_bad_padding(self):
+        self._test(b'dm\x01k', b'vi', [errors.InvalidBase64CharactersDefect,
+                                       errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_length(self):
+        self._test(b'abcde', b'abcde', [errors.InvalidBase64LengthDefect])
+
+
+class TestDecode(TestEmailBase):
+
+    def test_wrong_format_input_raises(self):
+        with self.assertRaises(ValueError):
+            _ew.decode('=?badone?=')
+        with self.assertRaises(ValueError):
+            _ew.decode('=?')
+        with self.assertRaises(ValueError):
+            _ew.decode('')
+        with self.assertRaises(KeyError):
+            _ew.decode('=?utf-8?X?somevalue?=')
+
+    def _test(self, source, result, charset='us-ascii', lang='', defects=[]):
+        res, char, l, d = _ew.decode(source)
+        self.assertEqual(res, result)
+        self.assertEqual(char, charset)
+        self.assertEqual(l, lang)
+        self.assertDefectsEqual(d, defects)
+
+    def test_simple_q(self):
+        self._test('=?us-ascii?q?foo?=', 'foo')
+
+    def test_simple_b(self):
+        self._test('=?us-ascii?b?dmk=?=', 'vi')
+
+    def test_q_case_ignored(self):
+        self._test('=?us-ascii?Q?foo?=', 'foo')
+
+    def test_b_case_ignored(self):
+        self._test('=?us-ascii?B?dmk=?=', 'vi')
+
+    def test_non_trivial_q(self):
+        self._test('=?latin-1?q?=20F=fcr=20Elise=20?=', ' Für Elise ', 'latin-1')
+
+    def test_q_escaped_bytes_preserved(self):
+        self._test(b'=?us-ascii?q?=20\xACfoo?='.decode('us-ascii',
+                                                       'surrogateescape'),
+                   ' \uDCACfoo',
+                   defects = [errors.UndecodableBytesDefect])
+
+    def test_b_undecodable_bytes_ignored_with_defect(self):
+        self._test(b'=?us-ascii?b?dm\xACk?='.decode('us-ascii',
+                                                   'surrogateescape'),
+                   'vi',
+                   defects = [
+                    errors.InvalidBase64CharactersDefect,
+                    errors.InvalidBase64PaddingDefect])
+
+    def test_b_invalid_bytes_ignored_with_defect(self):
+        self._test('=?us-ascii?b?dm\x01k===?=',
+                   'vi',
+                   defects = [errors.InvalidBase64CharactersDefect])
+
+    def test_b_invalid_bytes_incorrect_padding(self):
+        self._test('=?us-ascii?b?dm\x01k?=',
+                   'vi',
+                   defects = [
+                    errors.InvalidBase64CharactersDefect,
+                    errors.InvalidBase64PaddingDefect])
+
+    def test_b_padding_defect(self):
+        self._test('=?us-ascii?b?dmk?=',
+                   'vi',
+                    defects = [errors.InvalidBase64PaddingDefect])
+
+    def test_nonnull_lang(self):
+        self._test('=?us-ascii*jive?q?test?=', 'test', lang='jive')
+
+    def test_unknown_8bit_charset(self):
+        self._test('=?unknown-8bit?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'unknown-8bit',
+                   defects = [])
+
+    def test_unknown_charset(self):
+        self._test('=?foobar?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'foobar',
+                   # XXX Should this be a new Defect instead?
+                   defects = [errors.CharsetError])
+
+    @unittest.skip("TODO: RUSTPYTHON; str has surrogates")
+    def test_invalid_character_in_charset(self):
+        self._test('=?utf-8\udce2\udc80\udc9d?q?foo=ACbar?=',
+                   b'foo\xacbar'.decode('ascii', 'surrogateescape'),
+                   charset = 'utf-8\udce2\udc80\udc9d',
+                   # XXX Should this be a new Defect instead?
+                   defects = [errors.CharsetError])
+
+    def test_q_nonascii(self):
+        self._test('=?utf-8?q?=C3=89ric?=',
+                   'Éric',
+                   charset='utf-8')
+
+
+class TestEncodeQ(TestEmailBase):
+
+    def _test(self, src, expected):
+        self.assertEqual(_ew.encode_q(src), expected)
+
+    def test_all_safe(self):
+        self._test(b'foobar', 'foobar')
+
+    def test_spaces(self):
+        self._test(b'foo bar ', 'foo_bar_')
+
+    def test_run_of_encodables(self):
+        self._test(b'foo  ,,bar', 'foo__=2C=2Cbar')
+
+
+class TestEncodeB(TestEmailBase):
+
+    def test_simple(self):
+        self.assertEqual(_ew.encode_b(b'foo'), 'Zm9v')
+
+    def test_padding(self):
+        self.assertEqual(_ew.encode_b(b'vi'), 'dmk=')
+
+
+class TestEncode(TestEmailBase):
+
+    def test_q(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8', 'q'), '=?utf-8?q?foo?=')
+
+    def test_b(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8', 'b'), '=?utf-8?b?Zm9v?=')
+
+    def test_auto_q(self):
+        self.assertEqual(_ew.encode('foo', 'utf-8'), '=?utf-8?q?foo?=')
+
+    def test_auto_q_if_short_mostly_safe(self):
+        self.assertEqual(_ew.encode('vi.', 'utf-8'), '=?utf-8?q?vi=2E?=')
+
+    def test_auto_b_if_enough_unsafe(self):
+        self.assertEqual(_ew.encode('.....', 'utf-8'), '=?utf-8?b?Li4uLi4=?=')
+
+    def test_auto_b_if_long_unsafe(self):
+        self.assertEqual(_ew.encode('vi.vi.vi.vi.vi.', 'utf-8'),
+                         '=?utf-8?b?dmkudmkudmkudmkudmku?=')
+
+    def test_auto_q_if_long_mostly_safe(self):
+        self.assertEqual(_ew.encode('vi vi vi.vi ', 'utf-8'),
+                         '=?utf-8?q?vi_vi_vi=2Evi_?=')
+
+    def test_utf8_default(self):
+        self.assertEqual(_ew.encode('foo'), '=?utf-8?q?foo?=')
+
+    def test_lang(self):
+        self.assertEqual(_ew.encode('foo', lang='jive'), '=?utf-8*jive?q?foo?=')
+
+    def test_unknown_8bit(self):
+        self.assertEqual(_ew.encode('foo\uDCACbar', charset='unknown-8bit'),
+                         '=?unknown-8bit?q?foo=ACbar?=')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test__header_value_parser.py b/Lib/test/test_email/test__header_value_parser.py
new file mode 100644
index 0000000000..64bc3677e8
--- /dev/null
+++ b/Lib/test/test_email/test__header_value_parser.py
@@ -0,0 +1,3259 @@
+import string
+import unittest
+from email import _header_value_parser as parser
+from email import errors
+from email import policy
+from test.test_email import TestEmailBase, parameterize
+
+class TestTokens(TestEmailBase):
+
+    # EWWhiteSpaceTerminal
+
+    def test_EWWhiteSpaceTerminal(self):
+        x = parser.EWWhiteSpaceTerminal(' \t', 'fws')
+        self.assertEqual(x, ' \t')
+        self.assertEqual(str(x), '')
+        self.assertEqual(x.value, '')
+        self.assertEqual(x.token_type, 'fws')
+
+
+class TestParserMixin:
+
+    def _assert_results(self, tl, rest, string, value, defects, remainder,
+                        comments=None):
+        self.assertEqual(str(tl), string)
+        self.assertEqual(tl.value, value)
+        self.assertDefectsEqual(tl.all_defects, defects)
+        self.assertEqual(rest, remainder)
+        if comments is not None:
+            self.assertEqual(tl.comments, comments)
+
+    def _test_get_x(self, method, source, string, value, defects,
+                          remainder, comments=None):
+        tl, rest = method(source)
+        self._assert_results(tl, rest, string, value, defects, remainder,
+                             comments=None)
+        return tl
+
+    def _test_parse_x(self, method, input, string, value, defects,
+                             comments=None):
+        tl = method(input)
+        self._assert_results(tl, '', string, value, defects, '', comments)
+        return tl
+
+
+class TestParser(TestParserMixin, TestEmailBase):
+
+    # _wsp_splitter
+
+    rfc_printable_ascii = bytes(range(33, 127)).decode('ascii')
+    rfc_atext_chars = (string.ascii_letters + string.digits +
+                        "!#$%&\'*+-/=?^_`{}|~")
+    rfc_dtext_chars = rfc_printable_ascii.translate(str.maketrans('','',r'\[]'))
+
+    def test__wsp_splitter_one_word(self):
+        self.assertEqual(parser._wsp_splitter('foo', 1), ['foo'])
+
+    def test__wsp_splitter_two_words(self):
+        self.assertEqual(parser._wsp_splitter('foo def', 1),
+                                               ['foo', ' ', 'def'])
+
+    def test__wsp_splitter_ws_runs(self):
+        self.assertEqual(parser._wsp_splitter('foo \t def jik', 1),
+                                              ['foo', ' \t ', 'def jik'])
+
+
+    # get_fws
+
+    def test_get_fws_only(self):
+        fws = self._test_get_x(parser.get_fws, ' \t  ', ' \t  ', ' ', [], '')
+        self.assertEqual(fws.token_type, 'fws')
+
+    def test_get_fws_space(self):
+        self._test_get_x(parser.get_fws, ' foo', ' ', ' ', [], 'foo')
+
+    def test_get_fws_ws_run(self):
+        self._test_get_x(parser.get_fws, ' \t foo ', ' \t ', ' ', [], 'foo ')
+
+    # get_encoded_word
+
+    def test_get_encoded_word_missing_start_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('abc')
+
+    def test_get_encoded_word_missing_end_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?abc')
+
+    def test_get_encoded_word_missing_middle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?abc?=')
+
+    def test_get_encoded_word_invalid_cte(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_encoded_word('=?utf-8?X?somevalue?=')
+
+    def test_get_encoded_word_valid_ew(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?this_is_a_test?=  bird',
+                         'this is a test',
+                         'this is a test',
+                         [],
+                         '  bird')
+
+    def test_get_encoded_word_internal_spaces(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?this is a test?=  bird',
+                         'this is a test',
+                         'this is a test',
+                         [errors.InvalidHeaderDefect],
+                         '  bird')
+
+    def test_get_encoded_word_gets_first(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first?=  =?utf-8?q?second?=',
+                         'first',
+                         'first',
+                         [],
+                         '  =?utf-8?q?second?=')
+
+    def test_get_encoded_word_gets_first_even_if_no_space(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first?==?utf-8?q?second?=',
+                         'first',
+                         'first',
+                         [errors.InvalidHeaderDefect],
+                         '=?utf-8?q?second?=')
+
+    def test_get_encoded_word_sets_extra_attributes(self):
+        ew = self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii*jive?q?first_second?=',
+                         'first second',
+                         'first second',
+                         [],
+                         '')
+        self.assertEqual(ew.charset, 'us-ascii')
+        self.assertEqual(ew.lang, 'jive')
+
+    def test_get_encoded_word_lang_default_is_blank(self):
+        ew = self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first_second?=',
+                         'first second',
+                         'first second',
+                         [],
+                         '')
+        self.assertEqual(ew.charset, 'us-ascii')
+        self.assertEqual(ew.lang, '')
+
+    def test_get_encoded_word_non_printable_defect(self):
+        self._test_get_x(parser.get_encoded_word,
+                         '=?us-ascii?q?first\x02second?=',
+                         'first\x02second',
+                         'first\x02second',
+                         [errors.NonPrintableDefect],
+                         '')
+
+    def test_get_encoded_word_leading_internal_space(self):
+        self._test_get_x(parser.get_encoded_word,
+                        '=?us-ascii?q?=20foo?=',
+                        ' foo',
+                        ' foo',
+                        [],
+                        '')
+
+    def test_get_encoded_word_quopri_utf_escape_follows_cte(self):
+        # Issue 18044
+        self._test_get_x(parser.get_encoded_word,
+                        '=?utf-8?q?=C3=89ric?=',
+                        'Éric',
+                        'Éric',
+                        [],
+                        '')
+
+    # get_unstructured
+
+    def _get_unst(self, value):
+        token = parser.get_unstructured(value)
+        return token, ''
+
+    def test_get_unstructured_null(self):
+        self._test_get_x(self._get_unst, '', '', '', [], '')
+
+    def test_get_unstructured_one_word(self):
+        self._test_get_x(self._get_unst, 'foo', 'foo', 'foo', [], '')
+
+    def test_get_unstructured_normal_phrase(self):
+        self._test_get_x(self._get_unst, 'foo bar bird',
+                                         'foo bar bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_normal_phrase_with_whitespace(self):
+        self._test_get_x(self._get_unst, 'foo \t bar      bird',
+                                         'foo \t bar      bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_leading_whitespace(self):
+        self._test_get_x(self._get_unst, '  foo bar',
+                                         '  foo bar',
+                                         ' foo bar',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_trailing_whitespace(self):
+        self._test_get_x(self._get_unst, 'foo bar  ',
+                                         'foo bar  ',
+                                         'foo bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_leading_and_trailing_whitespace(self):
+        self._test_get_x(self._get_unst, '  foo bar  ',
+                                         '  foo bar  ',
+                                         ' foo bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_valid_ew_no_ws(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?=',
+                                         'bar',
+                                         'bar',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_ew_trailing_ws(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?=  ',
+                                         'bar  ',
+                                         'bar ',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_one_valid_ew_trailing_text(self):
+        self._test_get_x(self._get_unst, '=?us-ascii?q?bar?= bird',
+                                         'bar bird',
+                                         'bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_phrase_with_ew_in_middle_of_text(self):
+        self._test_get_x(self._get_unst, 'foo =?us-ascii?q?bar?= bird',
+                                         'foo bar bird',
+                                         'foo bar bird',
+                                         [],
+                                         '')
+
+    def test_get_unstructured_phrase_with_two_ew(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?=',
+            'foo barbird',
+            'foo barbird',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_two_ew_trailing_ws(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= =?us-ascii?q?bird?=   ',
+            'foo barbird   ',
+            'foo barbird ',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_ew_with_leading_ws(self):
+        self._test_get_x(self._get_unst,
+            '  =?us-ascii?q?bar?=',
+            '  bar',
+            ' bar',
+            [],
+            '')
+
+    def test_get_unstructured_phrase_with_two_ew_extra_ws(self):
+        self._test_get_x(self._get_unst,
+            'foo =?us-ascii?q?bar?= \t  =?us-ascii?q?bird?=',
+            'foo barbird',
+            'foo barbird',
+            [],
+            '')
+
+    def test_get_unstructured_two_ew_extra_ws_trailing_text(self):
+        self._test_get_x(self._get_unst,
+            '=?us-ascii?q?test?=   =?us-ascii?q?foo?=  val',
+            'testfoo  val',
+            'testfoo val',
+            [],
+            '')
+
+    def test_get_unstructured_ew_with_internal_ws(self):
+        self._test_get_x(self._get_unst,
+            '=?iso-8859-1?q?hello=20world?=',
+            'hello world',
+            'hello world',
+            [],
+            '')
+
+    def test_get_unstructured_ew_with_internal_leading_ws(self):
+        self._test_get_x(self._get_unst,
+            '   =?us-ascii?q?=20test?=   =?us-ascii?q?=20foo?=  val',
+            '    test foo  val',
+            '  test foo val',
+            [],
+            '')
+
+    def test_get_unstructured_invalid_ew(self):
+        self._test_get_x(self._get_unst,
+            '=?test val',
+            '=?test val',
+            '=?test val',
+            [],
+            '')
+
+    def test_get_unstructured_undecodable_bytes(self):
+        self._test_get_x(self._get_unst,
+            b'test \xACfoo  val'.decode('ascii', 'surrogateescape'),
+            'test \uDCACfoo  val',
+            'test \uDCACfoo val',
+            [errors.UndecodableBytesDefect],
+            '')
+
+    def test_get_unstructured_undecodable_bytes_in_EW(self):
+        self._test_get_x(self._get_unst,
+            (b'=?us-ascii?q?=20test?=   =?us-ascii?q?=20\xACfoo?='
+                b'  val').decode('ascii', 'surrogateescape'),
+            ' test \uDCACfoo  val',
+            ' test \uDCACfoo val',
+            [errors.UndecodableBytesDefect]*2,
+            '')
+
+    def test_get_unstructured_missing_base64_padding(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dmk?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64PaddingDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_character(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dm\x01k===?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64CharactersDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_character_and_bad_padding(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?dm\x01k?=',
+            'vi',
+            'vi',
+            [errors.InvalidBase64CharactersDefect,
+             errors.InvalidBase64PaddingDefect],
+            '')
+
+    def test_get_unstructured_invalid_base64_length(self):
+        # bpo-27397: Return the encoded string since there's no way to decode.
+        self._test_get_x(self._get_unst,
+            '=?utf-8?b?abcde?=',
+            'abcde',
+            'abcde',
+            [errors.InvalidBase64LengthDefect],
+            '')
+
+    def test_get_unstructured_no_whitespace_between_ews(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?foo?==?utf-8?q?bar?=',
+            'foobar',
+            'foobar',
+            [errors.InvalidHeaderDefect,
+            errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_ew_without_leading_whitespace(self):
+        self._test_get_x(
+            self._get_unst,
+            'nowhitespace=?utf-8?q?somevalue?=',
+            'nowhitespacesomevalue',
+            'nowhitespacesomevalue',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_ew_without_trailing_whitespace(self):
+        self._test_get_x(
+            self._get_unst,
+            '=?utf-8?q?somevalue?=nowhitespace',
+            'somevaluenowhitespace',
+            'somevaluenowhitespace',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_without_trailing_whitespace_hang_case(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?somevalue?=aa',
+            'somevalueaa',
+            'somevalueaa',
+            [errors.InvalidHeaderDefect],
+            '')
+
+    def test_get_unstructured_invalid_ew2(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?q?=somevalue?=',
+            '=?utf-8?q?=somevalue?=',
+            '=?utf-8?q?=somevalue?=',
+            [],
+            '')
+
+    def test_get_unstructured_invalid_ew_cte(self):
+        self._test_get_x(self._get_unst,
+            '=?utf-8?X?=somevalue?=',
+            '=?utf-8?X?=somevalue?=',
+            '=?utf-8?X?=somevalue?=',
+            [],
+            '')
+
+    # get_qp_ctext
+
+    def test_get_qp_ctext_only(self):
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                'foobar', 'foobar', ' ', [], '')
+        self.assertEqual(ptext.token_type, 'ptext')
+
+    def test_get_qp_ctext_all_printables(self):
+        with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
+        with_qp = with_qp.  replace('(', r'\(')
+        with_qp = with_qp.replace(')', r'\)')
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                 with_qp, self.rfc_printable_ascii, ' ', [], '')
+
+    def test_get_qp_ctext_two_words_gets_first(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo de', 'foo', ' ', [], ' de')
+
+    def test_get_qp_ctext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo \t\tde', 'foo', ' ', [], ' \t\tde')
+
+    def test_get_qp_ctext_up_to_close_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo)', 'foo', ' ', [], ')')
+
+    def test_get_qp_ctext_wsp_before_close_paren_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo  )', 'foo', ' ', [], '  )')
+
+    def test_get_qp_ctext_close_paren_mid_word(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo)bar', 'foo', ' ', [], ')bar')
+
+    def test_get_qp_ctext_up_to_open_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo(', 'foo', ' ', [], '(')
+
+    def test_get_qp_ctext_wsp_before_open_paren_preserved(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo  (', 'foo', ' ', [], '  (')
+
+    def test_get_qp_ctext_open_paren_mid_word(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        'foo(bar', 'foo', ' ', [], '(bar')
+
+    def test_get_qp_ctext_non_printables(self):
+        ptext = self._test_get_x(parser.get_qp_ctext,
+                                'foo\x00bar)', 'foo\x00bar', ' ',
+                                [errors.NonPrintableDefect], ')')
+        self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
+
+    def test_get_qp_ctext_close_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        ')', '', ' ', [], ')')
+
+    def test_get_qp_ctext_open_paren_only(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        '(', '', ' ', [], '(')
+
+    def test_get_qp_ctext_no_end_char(self):
+        self._test_get_x(parser.get_qp_ctext,
+                        '', '', ' ', [], '')
+
+
+    # get_qcontent
+
+    def test_get_qcontent_only(self):
+        ptext = self._test_get_x(parser.get_qcontent,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(ptext.token_type, 'ptext')
+
+    def test_get_qcontent_all_printables(self):
+        with_qp = self.rfc_printable_ascii.replace('\\', '\\\\')
+        with_qp = with_qp.  replace('"', r'\"')
+        ptext = self._test_get_x(parser.get_qcontent, with_qp,
+                                 self.rfc_printable_ascii,
+                                 self.rfc_printable_ascii, [], '')
+
+    def test_get_qcontent_two_words_gets_first(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo de', 'foo', 'foo', [], ' de')
+
+    def test_get_qcontent_following_wsp_preserved(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo \t\tde', 'foo', 'foo', [], ' \t\tde')
+
+    def test_get_qcontent_up_to_dquote_only(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo"', 'foo', 'foo', [], '"')
+
+    def test_get_qcontent_wsp_before_close_paren_preserved(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo  "', 'foo', 'foo', [], '  "')
+
+    def test_get_qcontent_close_paren_mid_word(self):
+        self._test_get_x(parser.get_qcontent,
+                        'foo"bar', 'foo', 'foo', [], '"bar')
+
+    def test_get_qcontent_non_printables(self):
+        ptext = self._test_get_x(parser.get_qcontent,
+                                'foo\x00fg"', 'foo\x00fg', 'foo\x00fg',
+                                [errors.NonPrintableDefect], '"')
+        self.assertEqual(ptext.defects[0].non_printables[0], '\x00')
+
+    def test_get_qcontent_empty(self):
+        self._test_get_x(parser.get_qcontent,
+                         '"', '', '', [], '"')
+
+    def test_get_qcontent_no_end_char(self):
+        self._test_get_x(parser.get_qcontent,
+                         '', '', '', [], '')
+
+    # get_atext
+
+    def test_get_atext_only(self):
+        atext = self._test_get_x(parser.get_atext,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(atext.token_type, 'atext')
+
+    def test_get_atext_all_atext(self):
+        atext = self._test_get_x(parser.get_atext, self.rfc_atext_chars,
+                                 self.rfc_atext_chars,
+                                 self.rfc_atext_chars, [], '')
+
+    def test_get_atext_two_words_gets_first(self):
+        self._test_get_x(parser.get_atext,
+                        'foo bar', 'foo', 'foo', [], ' bar')
+
+    def test_get_atext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_atext,
+                        'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
+
+    def test_get_atext_up_to_special(self):
+        self._test_get_x(parser.get_atext,
+                        'foo@bar', 'foo', 'foo', [], '@bar')
+
+    def test_get_atext_non_printables(self):
+        atext = self._test_get_x(parser.get_atext,
+                                'foo\x00bar(', 'foo\x00bar', 'foo\x00bar',
+                                [errors.NonPrintableDefect], '(')
+        self.assertEqual(atext.defects[0].non_printables[0], '\x00')
+
+    # get_bare_quoted_string
+
+    def test_get_bare_quoted_string_only(self):
+        bqs = self._test_get_x(parser.get_bare_quoted_string,
+                               '"foo"', '"foo"', 'foo', [], '')
+        self.assertEqual(bqs.token_type, 'bare-quoted-string')
+
+    def test_get_bare_quoted_string_must_start_with_dquote(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_bare_quoted_string('foo"')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_bare_quoted_string('  "foo"')
+
+    def test_get_bare_quoted_string_only_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+                         '""', '""', '', [], '')
+
+    def test_get_bare_quoted_string_missing_endquotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+                         '"', '""', '', [errors.InvalidHeaderDefect], '')
+
+    def test_get_bare_quoted_string_following_wsp_preserved(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo"\t bar', '"foo"', 'foo', [], '\t bar')
+
+    def test_get_bare_quoted_string_multiple_words(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo bar moo"', '"foo bar moo"', 'foo bar moo', [], '')
+
+    def test_get_bare_quoted_string_multiple_words_wsp_preserved(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '" foo  moo\t"', '" foo  moo\t"', ' foo  moo\t', [], '')
+
+    def test_get_bare_quoted_string_end_dquote_mid_word(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo"bar', '"foo"', 'foo', [], 'bar')
+
+    def test_get_bare_quoted_string_quoted_dquote(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             r'"foo\"in"a', r'"foo\"in"', 'foo"in', [], 'a')
+
+    def test_get_bare_quoted_string_non_printables(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"a\x01a"', '"a\x01a"', 'a\x01a',
+             [errors.NonPrintableDefect], '')
+
+    def test_get_bare_quoted_string_no_end_dquote(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo', '"foo"', 'foo',
+             [errors.InvalidHeaderDefect], '')
+        self._test_get_x(parser.get_bare_quoted_string,
+             '"foo ', '"foo "', 'foo ',
+             [errors.InvalidHeaderDefect], '')
+
+    def test_get_bare_quoted_string_empty_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+            '""', '""', '', [], '')
+
+    # Issue 16983: apply postel's law to some bad encoding.
+    def test_encoded_word_inside_quotes(self):
+        self._test_get_x(parser.get_bare_quoted_string,
+            '"=?utf-8?Q?not_really_valid?="',
+            '"not really valid"',
+            'not really valid',
+            [errors.InvalidHeaderDefect,
+             errors.InvalidHeaderDefect],
+            '')
+
+    # get_comment
+
+    def test_get_comment_only(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(comment)', '(comment)', ' ', [], '', ['comment'])
+        self.assertEqual(comment.token_type, 'comment')
+
+    def test_get_comment_must_start_with_paren(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_comment('foo"')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_comment('  (foo"')
+
+    def test_get_comment_following_wsp_preserved(self):
+        self._test_get_x(parser.get_comment,
+            '(comment)  \t', '(comment)', ' ', [], '  \t', ['comment'])
+
+    def test_get_comment_multiple_words(self):
+        self._test_get_x(parser.get_comment,
+            '(foo bar)  \t', '(foo bar)', ' ', [], '  \t', ['foo bar'])
+
+    def test_get_comment_multiple_words_wsp_preserved(self):
+        self._test_get_x(parser.get_comment,
+            '( foo  bar\t )  \t', '( foo  bar\t )', ' ', [], '  \t',
+                [' foo  bar\t '])
+
+    def test_get_comment_end_paren_mid_word(self):
+        self._test_get_x(parser.get_comment,
+            '(foo)bar', '(foo)', ' ', [], 'bar', ['foo'])
+
+    def test_get_comment_quoted_parens(self):
+        self._test_get_x(parser.get_comment,
+            r'(foo\) \(\)bar)', r'(foo\) \(\)bar)', ' ', [], '', ['foo) ()bar'])
+
+    def test_get_comment_non_printable(self):
+        self._test_get_x(parser.get_comment,
+            '(foo\x7Fbar)', '(foo\x7Fbar)', ' ',
+            [errors.NonPrintableDefect], '', ['foo\x7Fbar'])
+
+    def test_get_comment_no_end_paren(self):
+        self._test_get_x(parser.get_comment,
+            '(foo bar', '(foo bar)', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo bar'])
+        self._test_get_x(parser.get_comment,
+            '(foo bar  ', '(foo bar  )', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo bar  '])
+
+    def test_get_comment_nested_comment(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(foo(bar))', '(foo(bar))', ' ', [], '', ['foo(bar)'])
+        self.assertEqual(comment[1].content, 'bar')
+
+    def test_get_comment_nested_comment_wsp(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(foo ( bar ) )', '(foo ( bar ) )', ' ', [], '', ['foo ( bar ) '])
+        self.assertEqual(comment[2].content, ' bar ')
+
+    def test_get_comment_empty_comment(self):
+        self._test_get_x(parser.get_comment,
+            '()', '()', ' ', [], '', [''])
+
+    def test_get_comment_multiple_nesting(self):
+        comment = self._test_get_x(parser.get_comment,
+            '(((((foo)))))', '(((((foo)))))', ' ', [], '', ['((((foo))))'])
+        for i in range(4, 0, -1):
+            self.assertEqual(comment[0].content, '('*(i-1)+'foo'+')'*(i-1))
+            comment = comment[0]
+        self.assertEqual(comment.content, 'foo')
+
+    def test_get_comment_missing_end_of_nesting(self):
+        self._test_get_x(parser.get_comment,
+            '(((((foo)))', '(((((foo)))))', ' ',
+            [errors.InvalidHeaderDefect]*2, '', ['((((foo))))'])
+
+    def test_get_comment_qs_in_nested_comment(self):
+        comment = self._test_get_x(parser.get_comment,
+            r'(foo (b\)))', r'(foo (b\)))', ' ', [], '', [r'foo (b\))'])
+        self.assertEqual(comment[2].content, 'b)')
+
+    # get_cfws
+
+    def test_get_cfws_only_ws(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '  \t \t', '  \t \t', ' ', [], '', [])
+        self.assertEqual(cfws.token_type, 'cfws')
+
+    def test_get_cfws_only_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo)', '(foo)', ' ', [], '', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_only_mixed(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            ' (foo )  ( bar) ', ' (foo )  ( bar) ', ' ', [], '',
+                ['foo ', ' bar'])
+        self.assertEqual(cfws[1].content, 'foo ')
+        self.assertEqual(cfws[3].content, ' bar')
+
+    def test_get_cfws_ends_at_non_leader(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo) bar', '(foo) ', ' ', [], 'bar', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_ends_at_non_printable(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo) \x07', '(foo) ', ' ', [], '\x07', ['foo'])
+        self.assertEqual(cfws[0].content, 'foo')
+
+    def test_get_cfws_non_printable_in_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo \x07) "test"', '(foo \x07) ', ' ',
+            [errors.NonPrintableDefect], '"test"', ['foo \x07'])
+        self.assertEqual(cfws[0].content, 'foo \x07')
+
+    def test_get_cfws_header_ends_in_comment(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '  (foo ', '  (foo )', ' ',
+            [errors.InvalidHeaderDefect], '', ['foo '])
+        self.assertEqual(cfws[1].content, 'foo ')
+
+    def test_get_cfws_multiple_nested_comments(self):
+        cfws = self._test_get_x(parser.get_cfws,
+            '(foo (bar)) ((a)(a))', '(foo (bar)) ((a)(a))', ' ', [],
+                '', ['foo (bar)', '(a)(a)'])
+        self.assertEqual(cfws[0].comments, ['foo (bar)'])
+        self.assertEqual(cfws[2].comments, ['(a)(a)'])
+
+    # get_quoted_string
+
+    def test_get_quoted_string_only(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '"bob"', '"bob"', 'bob', [], '')
+        self.assertEqual(qs.token_type, 'quoted-string')
+        self.assertEqual(qs.quoted_value, '"bob"')
+        self.assertEqual(qs.content, 'bob')
+
+    def test_get_quoted_string_with_wsp(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '\t "bob"  ', '\t "bob"  ', ' bob ', [], '')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+        self.assertEqual(qs.content, 'bob')
+
+    def test_get_quoted_string_with_comments_and_wsp(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (foo) "bob"(bar)', ' (foo) "bob"(bar)', ' bob ', [], '')
+        self.assertEqual(qs[0][1].content, 'foo')
+        self.assertEqual(qs[2][0].content, 'bar')
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_with_multiple_comments(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (foo) (bar) "bob"(bird)', ' (foo) (bar) "bob"(bird)', ' bob ',
+                [], '')
+        self.assertEqual(qs[0].comments, ['foo', 'bar'])
+        self.assertEqual(qs[2].comments, ['bird'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_non_printable_in_comment(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (\x0A) "bob"', ' (\x0A) "bob"', ' bob',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(qs[0].comments, ['\x0A'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob"')
+
+    def test_get_quoted_string_non_printable_in_qcontent(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "a\x0B"', ' (a) "a\x0B"', ' a\x0B',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'a\x0B')
+        self.assertEqual(qs.quoted_value, ' "a\x0B"')
+
+    def test_get_quoted_string_internal_ws(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "foo  bar "', ' (a) "foo  bar "', ' foo  bar ',
+                [], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'foo  bar ')
+        self.assertEqual(qs.quoted_value, ' "foo  bar "')
+
+    def test_get_quoted_string_header_ends_in_comment(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "bob" (a', ' (a) "bob" (a)', ' bob ',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs[2].comments, ['a'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    def test_get_quoted_string_header_ends_in_qcontent(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            ' (a) "bob', ' (a) "bob"', ' bob',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(qs[0].comments, ['a'])
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob"')
+
+    def test_get_quoted_string_cfws_only_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_quoted_string(' (foo) ')
+
+    def test_get_quoted_string_no_quoted_string(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_quoted_string(' (ab) xyz')
+
+    def test_get_quoted_string_qs_ends_at_noncfws(self):
+        qs = self._test_get_x(parser.get_quoted_string,
+            '\t "bob" fee', '\t "bob" ', ' bob ', [], 'fee')
+        self.assertEqual(qs.content, 'bob')
+        self.assertEqual(qs.quoted_value, ' "bob" ')
+
+    # get_atom
+
+    def test_get_atom_only(self):
+        atom = self._test_get_x(parser.get_atom,
+            'bob', 'bob', 'bob', [], '')
+        self.assertEqual(atom.token_type, 'atom')
+
+    def test_get_atom_with_wsp(self):
+        self._test_get_x(parser.get_atom,
+            '\t bob  ', '\t bob  ', ' bob ', [], '')
+
+    def test_get_atom_with_comments_and_wsp(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) bob(bar)', ' (foo) bob(bar)', ' bob ', [], '')
+        self.assertEqual(atom[0][1].content, 'foo')
+        self.assertEqual(atom[2][0].content, 'bar')
+
+    def test_get_atom_with_multiple_comments(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) (bar) bob(bird)', ' (foo) (bar) bob(bird)', ' bob ',
+                [], '')
+        self.assertEqual(atom[0].comments, ['foo', 'bar'])
+        self.assertEqual(atom[2].comments, ['bird'])
+
+    def test_get_atom_non_printable_in_comment(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (\x0A) bob', ' (\x0A) bob', ' bob',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(atom[0].comments, ['\x0A'])
+
+    def test_get_atom_non_printable_in_atext(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (a) a\x0B', ' (a) a\x0B', ' a\x0B',
+                [errors.NonPrintableDefect], '')
+        self.assertEqual(atom[0].comments, ['a'])
+
+    def test_get_atom_header_ends_in_comment(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (a) bob (a', ' (a) bob (a)', ' bob ',
+                [errors.InvalidHeaderDefect], '')
+        self.assertEqual(atom[0].comments, ['a'])
+        self.assertEqual(atom[2].comments, ['a'])
+
+    def test_get_atom_no_atom(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_atom(' (ab) ')
+
+    def test_get_atom_no_atom_before_special(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_atom(' (ab) @')
+
+    def test_get_atom_atom_ends_at_special(self):
+        atom = self._test_get_x(parser.get_atom,
+            ' (foo) bob(bar)  @bang', ' (foo) bob(bar)  ', ' bob ', [], '@bang')
+        self.assertEqual(atom[0].comments, ['foo'])
+        self.assertEqual(atom[2].comments, ['bar'])
+
+    def test_get_atom_atom_ends_at_noncfws(self):
+        self._test_get_x(parser.get_atom,
+            'bob  fred', 'bob  ', 'bob ', [], 'fred')
+
+    def test_get_atom_rfc2047_atom(self):
+        self._test_get_x(parser.get_atom,
+            '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
+
+    # get_dot_atom_text
+
+    def test_get_dot_atom_text(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo.bar.bang', 'foo.bar.bang', 'foo.bar.bang', [], '')
+        self.assertEqual(dot_atom_text.token_type, 'dot-atom-text')
+        self.assertEqual(len(dot_atom_text), 5)
+
+    def test_get_dot_atom_text_lone_atom_is_valid(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo', 'foo', 'foo', [], '')
+
+    def test_get_dot_atom_text_raises_on_leading_dot(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('.foo.bar')
+
+    def test_get_dot_atom_text_raises_on_trailing_dot(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('foo.bar.')
+
+    def test_get_dot_atom_text_raises_on_leading_non_atext(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text(' foo.bar')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('@foo.bar')
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom_text('"foo.bar"')
+
+    def test_get_dot_atom_text_trailing_text_preserved(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo@bar', 'foo', 'foo', [], '@bar')
+
+    def test_get_dot_atom_text_trailing_ws_preserved(self):
+        dot_atom_text = self._test_get_x(parser.get_dot_atom_text,
+            'foo .bar', 'foo', 'foo', [], ' .bar')
+
+    # get_dot_atom
+
+    def test_get_dot_atom_only(self):
+        dot_atom = self._test_get_x(parser.get_dot_atom,
+            'foo.bar.bing', 'foo.bar.bing', 'foo.bar.bing', [], '')
+        self.assertEqual(dot_atom.token_type, 'dot-atom')
+        self.assertEqual(len(dot_atom), 1)
+
+    def test_get_dot_atom_with_wsp(self):
+        self._test_get_x(parser.get_dot_atom,
+            '\t  foo.bar.bing  ', '\t  foo.bar.bing  ', ' foo.bar.bing ', [], '')
+
+    def test_get_dot_atom_with_comments_and_wsp(self):
+        self._test_get_x(parser.get_dot_atom,
+            ' (sing)  foo.bar.bing (here) ', ' (sing)  foo.bar.bing (here) ',
+                ' foo.bar.bing ', [], '')
+
+    def test_get_dot_atom_space_ends_dot_atom(self):
+        self._test_get_x(parser.get_dot_atom,
+            ' (sing)  foo.bar .bing (here) ', ' (sing)  foo.bar ',
+                ' foo.bar ', [], '.bing (here) ')
+
+    def test_get_dot_atom_no_atom_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) ')
+
+    def test_get_dot_atom_leading_dot_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) .bar')
+
+    def test_get_dot_atom_two_dots_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom('bar..bang')
+
+    def test_get_dot_atom_trailing_dot_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_dot_atom(' (foo) bar.bang. foo')
+
+    def test_get_dot_atom_rfc2047_atom(self):
+        self._test_get_x(parser.get_dot_atom,
+            '=?utf-8?q?=20bob?=', ' bob', ' bob', [], '')
+
+    # get_word (if this were black box we'd repeat all the qs/atom tests)
+
+    def test_get_word_atom_yields_atom(self):
+        word = self._test_get_x(parser.get_word,
+            ' (foo) bar (bang) :ah', ' (foo) bar (bang) ', ' bar ', [], ':ah')
+        self.assertEqual(word.token_type, 'atom')
+        self.assertEqual(word[0].token_type, 'cfws')
+
+    def test_get_word_all_CFWS(self):
+        # bpo-29412: Test that we don't raise IndexError when parsing CFWS only
+        # token.
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_word('(Recipients list suppressed')
+
+    def test_get_word_qs_yields_qs(self):
+        word = self._test_get_x(parser.get_word,
+            '"bar " (bang) ah', '"bar " (bang) ', 'bar  ', [], 'ah')
+        self.assertEqual(word.token_type, 'quoted-string')
+        self.assertEqual(word[0].token_type, 'bare-quoted-string')
+        self.assertEqual(word[0].value, 'bar ')
+        self.assertEqual(word.content, 'bar ')
+
+    def test_get_word_ends_at_dot(self):
+        self._test_get_x(parser.get_word,
+            'foo.', 'foo', 'foo', [], '.')
+
+    # get_phrase
+
+    def test_get_phrase_simple(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            '"Fred A. Johnson" is his name, oh.',
+            '"Fred A. Johnson" is his name',
+            'Fred A. Johnson is his name',
+            [],
+            ', oh.')
+        self.assertEqual(phrase.token_type, 'phrase')
+
+    def test_get_phrase_complex(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            ' (A) bird (in (my|your)) "hand  " is messy\t<>\t',
+            ' (A) bird (in (my|your)) "hand  " is messy\t',
+            ' bird hand   is messy ',
+            [],
+            '<>\t')
+        self.assertEqual(phrase[0][0].comments, ['A'])
+        self.assertEqual(phrase[0][2].comments, ['in (my|your)'])
+
+    def test_get_phrase_obsolete(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            'Fred A.(weird).O Johnson',
+            'Fred A.(weird).O Johnson',
+            'Fred A. .O Johnson',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(phrase), 7)
+        self.assertEqual(phrase[3].comments, ['weird'])
+
+    def test_get_phrase_pharse_must_start_with_word(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            '(even weirder).name',
+            '(even weirder).name',
+            ' .name',
+            [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(phrase), 3)
+        self.assertEqual(phrase[0].comments, ['even weirder'])
+
+    def test_get_phrase_ending_with_obsolete(self):
+        phrase = self._test_get_x(parser.get_phrase,
+            'simple phrase.(with trailing comment):boo',
+            'simple phrase.(with trailing comment)',
+            'simple phrase. ',
+            [errors.ObsoleteHeaderDefect]*2,
+            ':boo')
+        self.assertEqual(len(phrase), 4)
+        self.assertEqual(phrase[3].comments, ['with trailing comment'])
+
+    def get_phrase_cfws_only_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_phrase(' (foo) ')
+
+    # get_local_part
+
+    def test_get_local_part_simple(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'dinsdale@python.org', 'dinsdale', 'dinsdale', [], '@python.org')
+        self.assertEqual(local_part.token_type, 'local-part')
+        self.assertEqual(local_part.local_part, 'dinsdale')
+
+    def test_get_local_part_with_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'Fred.A.Johnson@python.org',
+            'Fred.A.Johnson',
+            'Fred.A.Johnson',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_with_whitespace(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' Fred.A.Johnson  @python.org',
+            ' Fred.A.Johnson  ',
+            ' Fred.A.Johnson ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_with_cfws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo) Fred.A.Johnson (bar (bird))  @python.org',
+            ' (foo) Fred.A.Johnson (bar (bird))  ',
+            ' Fred.A.Johnson ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+        self.assertEqual(local_part[0][0].comments, ['foo'])
+        self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
+
+    def test_get_local_part_simple_quoted(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '"dinsdale"@python.org', '"dinsdale"', '"dinsdale"', [], '@python.org')
+        self.assertEqual(local_part.token_type, 'local-part')
+        self.assertEqual(local_part.local_part, 'dinsdale')
+
+    def test_get_local_part_with_quoted_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '"Fred.A.Johnson"@python.org',
+            '"Fred.A.Johnson"',
+            '"Fred.A.Johnson"',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_quoted_with_whitespace(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' "Fred A. Johnson"  @python.org',
+            ' "Fred A. Johnson"  ',
+            ' "Fred A. Johnson" ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred A. Johnson')
+
+    def test_get_local_part_quoted_with_cfws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo) " Fred A. Johnson " (bar (bird))  @python.org',
+            ' (foo) " Fred A. Johnson " (bar (bird))  ',
+            ' " Fred A. Johnson " ',
+            [],
+            '@python.org')
+        self.assertEqual(local_part.local_part, ' Fred A. Johnson ')
+        self.assertEqual(local_part[0][0].comments, ['foo'])
+        self.assertEqual(local_part[0][2].comments, ['bar (bird)'])
+
+
+    def test_get_local_part_simple_obsolete(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            'Fred. A.Johnson@python.org',
+            'Fred. A.Johnson',
+            'Fred. A.Johnson',
+            [errors.ObsoleteHeaderDefect],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson')
+
+    def test_get_local_part_complex_obsolete_1(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and  dogs "@python.org',
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson."and  dogs "',
+            ' Fred . A. Johnson.and  dogs ',
+            [errors.ObsoleteHeaderDefect],
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson.and  dogs ')
+
+    def test_get_local_part_complex_obsolete_invalid(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and  dogs"@python.org',
+            ' (foo )Fred (bar).(bird) A.(sheep)Johnson "and  dogs"',
+            ' Fred . A. Johnson and  dogs',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'Fred.A.Johnson and  dogs')
+
+    def test_get_local_part_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part('')
+
+    def test_get_local_part_no_part_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part(' (foo) ')
+
+    def test_get_local_part_special_instead_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_local_part(' (foo) @python.org')
+
+    def test_get_local_part_trailing_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris.@python.org',
+            ' borris.',
+            ' borris.',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris.')
+
+    def test_get_local_part_trailing_dot_with_ws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris. @python.org',
+            ' borris. ',
+            ' borris. ',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris.')
+
+    def test_get_local_part_leading_dot(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '.borris@python.org',
+            '.borris',
+            '.borris',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, '.borris')
+
+    def test_get_local_part_leading_dot_after_ws(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' .borris@python.org',
+            ' .borris',
+            ' .borris',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, '.borris')
+
+    def test_get_local_part_double_dot_raises(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            ' borris.(foo).natasha@python.org',
+            ' borris.(foo).natasha',
+            ' borris. .natasha',
+            [errors.InvalidHeaderDefect]*2,
+            '@python.org')
+        self.assertEqual(local_part.local_part, 'borris..natasha')
+
+    def test_get_local_part_quoted_strings_in_atom_list(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            '""example" example"@example.com',
+            '""example" example"',
+            'example example',
+            [errors.InvalidHeaderDefect]*3,
+            '@example.com')
+        self.assertEqual(local_part.local_part, 'example example')
+
+    def test_get_local_part_valid_and_invalid_qp_in_atom_list(self):
+        local_part = self._test_get_x(parser.get_local_part,
+            r'"\\"example\\" example"@example.com',
+            r'"\\"example\\" example"',
+            r'\example\\ example',
+            [errors.InvalidHeaderDefect]*5,
+            '@example.com')
+        self.assertEqual(local_part.local_part, r'\example\\ example')
+
+    def test_get_local_part_unicode_defect(self):
+        # Currently this only happens when parsing unicode, not when parsing
+        # stuff that was originally binary.
+        local_part = self._test_get_x(parser.get_local_part,
+            'exámple@example.com',
+            'exámple',
+            'exámple',
+            [errors.NonASCIILocalPartDefect],
+            '@example.com')
+        self.assertEqual(local_part.local_part, 'exámple')
+
+    # get_dtext
+
+    def test_get_dtext_only(self):
+        dtext = self._test_get_x(parser.get_dtext,
+                                'foobar', 'foobar', 'foobar', [], '')
+        self.assertEqual(dtext.token_type, 'ptext')
+
+    def test_get_dtext_all_dtext(self):
+        dtext = self._test_get_x(parser.get_dtext, self.rfc_dtext_chars,
+                                 self.rfc_dtext_chars,
+                                 self.rfc_dtext_chars, [], '')
+
+    def test_get_dtext_two_words_gets_first(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo bar', 'foo', 'foo', [], ' bar')
+
+    def test_get_dtext_following_wsp_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo \t\tbar', 'foo', 'foo', [], ' \t\tbar')
+
+    def test_get_dtext_non_printables(self):
+        dtext = self._test_get_x(parser.get_dtext,
+                                'foo\x00bar]', 'foo\x00bar', 'foo\x00bar',
+                                [errors.NonPrintableDefect], ']')
+        self.assertEqual(dtext.defects[0].non_printables[0], '\x00')
+
+    def test_get_dtext_with_qp(self):
+        ptext = self._test_get_x(parser.get_dtext,
+                                 r'foo\]\[\\bar\b\e\l\l',
+                                 r'foo][\barbell',
+                                 r'foo][\barbell',
+                                 [errors.ObsoleteHeaderDefect],
+                                 '')
+
+    def test_get_dtext_up_to_close_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo]', 'foo', 'foo', [], ']')
+
+    def test_get_dtext_wsp_before_close_bracket_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo  ]', 'foo', 'foo', [], '  ]')
+
+    def test_get_dtext_close_bracket_mid_word(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo]bar', 'foo', 'foo', [], ']bar')
+
+    def test_get_dtext_up_to_open_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo[', 'foo', 'foo', [], '[')
+
+    def test_get_dtext_wsp_before_open_bracket_preserved(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo  [', 'foo', 'foo', [], '  [')
+
+    def test_get_dtext_open_bracket_mid_word(self):
+        self._test_get_x(parser.get_dtext,
+                        'foo[bar', 'foo', 'foo', [], '[bar')
+
+    def test_get_dtext_open_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        '[', '', '', [], '[')
+
+    def test_get_dtext_close_bracket_only(self):
+        self._test_get_x(parser.get_dtext,
+                        ']', '', '', [], ']')
+
+    def test_get_dtext_empty(self):
+        self._test_get_x(parser.get_dtext,
+                        '', '', '', [], '')
+
+    # get_domain_literal
+
+    def test_get_domain_literal_only(self):
+        domain_literal = domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '[127.0.0.1]',
+                                '[127.0.0.1]',
+                                '[127.0.0.1]',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.token_type, 'domain-literal')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_with_internal_ws(self):
+        domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '[  127.0.0.1\t ]',
+                                '[  127.0.0.1\t ]',
+                                '[ 127.0.0.1 ]',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_with_surrounding_cfws(self):
+        domain_literal = self._test_get_x(parser.get_domain_literal,
+                                '(foo)[  127.0.0.1] (bar)',
+                                '(foo)[  127.0.0.1] (bar)',
+                                ' [ 127.0.0.1] ',
+                                [],
+                                '')
+        self.assertEqual(domain_literal.domain, '[127.0.0.1]')
+        self.assertEqual(domain_literal.ip, '127.0.0.1')
+
+    def test_get_domain_literal_no_start_char_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) ')
+
+    def test_get_domain_literal_no_start_char_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) @')
+
+    def test_get_domain_literal_bad_dtext_char_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain_literal('(foo) [abc[@')
+
+    # get_domain
+
+    def test_get_domain_regular_domain_only(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  'example.com',
+                                  'example.com',
+                                  'example.com',
+                                  [],
+                                  '')
+        self.assertEqual(domain.token_type, 'domain')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_only(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '[127.0.0.1]',
+                                  '[127.0.0.1]',
+                                  '[127.0.0.1]',
+                                  [],
+                                  '')
+        self.assertEqual(domain.token_type, 'domain')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_with_cfws(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo) example.com(bar)\t',
+                                  '(foo) example.com(bar)\t',
+                                  ' example.com ',
+                                  [],
+                                  '')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_with_cfws(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  ' [127.0.0.1] ',
+                                  [],
+                                  '')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_domain_with_cfws_ends_at_special(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)example.com\t(bar), next',
+                                  '(foo)example.com\t(bar)',
+                                  ' example.com ',
+                                  [],
+                                  ', next')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_domain_literal_with_cfws_ends_at_special(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo)[127.0.0.1]\t(bar), next',
+                                  '(foo)[127.0.0.1]\t(bar)',
+                                  ' [127.0.0.1] ',
+                                  [],
+                                  ', next')
+        self.assertEqual(domain.domain, '[127.0.0.1]')
+
+    def test_get_domain_obsolete(self):
+        domain = self._test_get_x(parser.get_domain,
+                                  '(foo) example . (bird)com(bar)\t',
+                                  '(foo) example . (bird)com(bar)\t',
+                                  ' example . com ',
+                                  [errors.ObsoleteHeaderDefect],
+                                  '')
+        self.assertEqual(domain.domain, 'example.com')
+
+    def test_get_domain_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("")
+
+    def test_get_domain_no_non_cfws_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("  (foo)\t")
+
+    def test_get_domain_no_atom_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_domain("  (foo)\t, broken")
+
+
+    # get_addr_spec
+
+    def test_get_addr_spec_normal(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                                    'dinsdale@example.com',
+                                    'dinsdale@example.com',
+                                    'dinsdale@example.com',
+                                    [],
+                                    '')
+        self.assertEqual(addr_spec.token_type, 'addr-spec')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@example.com')
+
+    def test_get_addr_spec_with_doamin_literal(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                                    'dinsdale@[127.0.0.1]',
+                                    'dinsdale@[127.0.0.1]',
+                                    'dinsdale@[127.0.0.1]',
+                                    [],
+                                    '')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, '[127.0.0.1]')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@[127.0.0.1]')
+
+    def test_get_addr_spec_with_cfws(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) dinsdale(bar)@ (bird) example.com (bog)',
+                '(foo) dinsdale(bar)@ (bird) example.com (bog)',
+                ' dinsdale@example.com ',
+                [],
+                '')
+        self.assertEqual(addr_spec.local_part, 'dinsdale')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'dinsdale@example.com')
+
+    def test_get_addr_spec_with_qouoted_string_and_cfws(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog)',
+                ' "roy a bug"@example.com ',
+                [],
+                '')
+        self.assertEqual(addr_spec.local_part, 'roy a bug')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
+
+    def test_get_addr_spec_ends_at_special(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog) , next',
+                '(foo) "roy a bug"(bar)@ (bird) example.com (bog) ',
+                ' "roy a bug"@example.com ',
+                [],
+                ', next')
+        self.assertEqual(addr_spec.local_part, 'roy a bug')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"roy a bug"@example.com')
+
+    def test_get_addr_spec_quoted_strings_in_atom_list(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(addr_spec.local_part, 'example example')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, '"example example"@example.com')
+
+    def test_get_addr_spec_dot_atom(self):
+        addr_spec = self._test_get_x(parser.get_addr_spec,
+            'star.a.star@example.com',
+            'star.a.star@example.com',
+            'star.a.star@example.com',
+            [],
+            '')
+        self.assertEqual(addr_spec.local_part, 'star.a.star')
+        self.assertEqual(addr_spec.domain, 'example.com')
+        self.assertEqual(addr_spec.addr_spec, 'star.a.star@example.com')
+
+    def test_get_addr_spec_multiple_domains(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@a.star@example.com')
+
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@a@example.com')
+
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_addr_spec('star@172.17.0.1@example.com')
+
+    # get_obs_route
+
+    def test_get_obs_route_simple(self):
+        obs_route = self._test_get_x(parser.get_obs_route,
+            '@example.com, @two.example.com:',
+            '@example.com, @two.example.com:',
+            '@example.com, @two.example.com:',
+            [],
+            '')
+        self.assertEqual(obs_route.token_type, 'obs-route')
+        self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
+
+    def test_get_obs_route_complex(self):
+        obs_route = self._test_get_x(parser.get_obs_route,
+            '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
+            '(foo),, (blue)@example.com (bar),@two.(foo) example.com (bird):',
+            ' ,, @example.com ,@two. example.com :',
+            [errors.ObsoleteHeaderDefect],  # This is the obs-domain
+            '')
+        self.assertEqual(obs_route.token_type, 'obs-route')
+        self.assertEqual(obs_route.domains, ['example.com', 'two.example.com'])
+
+    def test_get_obs_route_no_route_before_end_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com,')
+
+    def test_get_obs_route_no_route_before_end_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com, (foo) ')
+
+    def test_get_obs_route_no_route_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) [abc],')
+
+    def test_get_obs_route_no_route_before_special_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('(foo) @example.com [abc],')
+
+    def test_get_obs_route_no_domain_after_at_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('@')
+
+    def test_get_obs_route_no_domain_after_at_raises2(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_obs_route('@example.com, @')
+
+    # get_angle_addr
+
+    def test_get_angle_addr_simple(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_empty(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<>',
+            '<>',
+            '<>',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertIsNone(angle_addr.local_part)
+        self.assertIsNone(angle_addr.domain)
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '<>')
+
+    def test_get_angle_addr_qs_only_quotes(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<""@example.com>',
+            '<""@example.com>',
+            '<""@example.com>',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, '')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '""@example.com')
+
+    def test_get_angle_addr_with_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            ' (foo) <dinsdale@example.com>(bar)',
+            ' (foo) <dinsdale@example.com>(bar)',
+            ' <dinsdale@example.com> ',
+            [],
+            '')
+        self.assertEqual(angle_addr.token_type, 'angle-addr')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_qs_and_domain_literal(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<"Fred Perfect"@[127.0.0.1]>',
+            '<"Fred Perfect"@[127.0.0.1]>',
+            '<"Fred Perfect"@[127.0.0.1]>',
+            [],
+            '')
+        self.assertEqual(angle_addr.local_part, 'Fred Perfect')
+        self.assertEqual(angle_addr.domain, '[127.0.0.1]')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, '"Fred Perfect"@[127.0.0.1]')
+
+    def test_get_angle_addr_internal_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<(foo) dinsdale@example.com(bar)>',
+            '<(foo) dinsdale@example.com(bar)>',
+            '< dinsdale@example.com >',
+            [],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_obs_route(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '(foo)<@example.com, (bird) @two.example.com: dinsdale@example.com> (bar) ',
+            '(foo)<@example.com, (bird) @two.example.com: dinsdale@example.com> (bar) ',
+            ' <@example.com, @two.example.com: dinsdale@example.com> ',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertEqual(angle_addr.route, ['example.com', 'two.example.com'])
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_missing_closing_angle(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_missing_closing_angle_with_cfws(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com (foo)',
+            '<dinsdale@example.com (foo)>',
+            '<dinsdale@example.com >',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_ends_at_special(self):
+        angle_addr = self._test_get_x(parser.get_angle_addr,
+            '<dinsdale@example.com> (foo), next',
+            '<dinsdale@example.com> (foo)',
+            '<dinsdale@example.com> ',
+            [],
+            ', next')
+        self.assertEqual(angle_addr.local_part, 'dinsdale')
+        self.assertEqual(angle_addr.domain, 'example.com')
+        self.assertIsNone(angle_addr.route)
+        self.assertEqual(angle_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_angle_addr_empty_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('')
+
+    def test_get_angle_addr_left_angle_only_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('<')
+
+    def test_get_angle_addr_no_angle_raise(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) ')
+
+    def test_get_angle_addr_no_angle_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) , next')
+
+    def test_get_angle_addr_no_angle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('bar')
+
+    def test_get_angle_addr_special_after_angle_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_angle_addr('(foo) <, bar')
+
+    # get_display_name  This is phrase but with a different value.
+
+    def test_get_display_name_simple(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'Fred A Johnson',
+            'Fred A Johnson',
+            'Fred A Johnson',
+            [],
+            '')
+        self.assertEqual(display_name.token_type, 'display-name')
+        self.assertEqual(display_name.display_name, 'Fred A Johnson')
+
+    def test_get_display_name_complex1(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            '"Fred A. Johnson" is his name, oh.',
+            '"Fred A. Johnson" is his name',
+            '"Fred A. Johnson is his name"',
+            [],
+            ', oh.')
+        self.assertEqual(display_name.token_type, 'display-name')
+        self.assertEqual(display_name.display_name, 'Fred A. Johnson is his name')
+
+    def test_get_display_name_complex2(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            ' (A) bird (in (my|your)) "hand  " is messy\t<>\t',
+            ' (A) bird (in (my|your)) "hand  " is messy\t',
+            ' "bird hand   is messy" ',
+            [],
+            '<>\t')
+        self.assertEqual(display_name[0][0].comments, ['A'])
+        self.assertEqual(display_name[0][2].comments, ['in (my|your)'])
+        self.assertEqual(display_name.display_name, 'bird hand   is messy')
+
+    def test_get_display_name_obsolete(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'Fred A.(weird).O Johnson',
+            'Fred A.(weird).O Johnson',
+            '"Fred A. .O Johnson"',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(display_name), 7)
+        self.assertEqual(display_name[3].comments, ['weird'])
+        self.assertEqual(display_name.display_name, 'Fred A. .O Johnson')
+
+    def test_get_display_name_pharse_must_start_with_word(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            '(even weirder).name',
+            '(even weirder).name',
+            ' ".name"',
+            [errors.InvalidHeaderDefect] + [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(display_name), 3)
+        self.assertEqual(display_name[0].comments, ['even weirder'])
+        self.assertEqual(display_name.display_name, '.name')
+
+    def test_get_display_name_ending_with_obsolete(self):
+        display_name = self._test_get_x(parser.get_display_name,
+            'simple phrase.(with trailing comment):boo',
+            'simple phrase.(with trailing comment)',
+            '"simple phrase." ',
+            [errors.ObsoleteHeaderDefect]*2,
+            ':boo')
+        self.assertEqual(len(display_name), 4)
+        self.assertEqual(display_name[3].comments, ['with trailing comment'])
+        self.assertEqual(display_name.display_name, 'simple phrase.')
+
+    def test_get_display_name_for_invalid_address_field(self):
+        # bpo-32178: Test that address fields starting with `:` don't cause
+        # IndexError when parsing the display name.
+        display_name = self._test_get_x(
+            parser.get_display_name,
+            ':Foo ', '', '', [errors.InvalidHeaderDefect], ':Foo ')
+        self.assertEqual(display_name.value, '')
+
+    # get_name_addr
+
+    def test_get_name_addr_angle_addr_only(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.token_type, 'name-addr')
+        self.assertIsNone(name_addr.display_name)
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_atom_name(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            'Dinsdale <dinsdale@example.com>',
+            'Dinsdale <dinsdale@example.com>',
+            'Dinsdale <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.token_type, 'name-addr')
+        self.assertEqual(name_addr.display_name, 'Dinsdale')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_atom_name_with_cfws(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '(foo) Dinsdale (bar) <dinsdale@example.com> (bird)',
+            '(foo) Dinsdale (bar) <dinsdale@example.com> (bird)',
+            ' Dinsdale <dinsdale@example.com> ',
+            [],
+            '')
+        self.assertEqual(name_addr.display_name, 'Dinsdale')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_name_with_cfws_and_dots(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '(foo) Roy.A.Bear (bar) <dinsdale@example.com> (bird)',
+            '(foo) Roy.A.Bear (bar) <dinsdale@example.com> (bird)',
+            ' "Roy.A.Bear" <dinsdale@example.com> ',
+            [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_qs_name(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_ending_with_dot_without_space(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            'John X.<jxd@example.com>',
+            'John X.<jxd@example.com>',
+            '"John X."<jxd@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, 'John X.')
+        self.assertEqual(name_addr.local_part, 'jxd')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'jxd@example.com')
+
+    def test_get_name_addr_starting_with_dot(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '. Doe <jxd@example.com>',
+            '. Doe <jxd@example.com>',
+            '". Doe" <jxd@example.com>',
+            [errors.InvalidHeaderDefect, errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, '. Doe')
+        self.assertEqual(name_addr.local_part, 'jxd')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'jxd@example.com')
+
+    def test_get_name_addr_with_route(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            '"Roy.A.Bear" <@two.example.com: dinsdale@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertEqual(name_addr.route, ['two.example.com'])
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_ends_at_special(self):
+        name_addr = self._test_get_x(parser.get_name_addr,
+            '"Roy.A.Bear" <dinsdale@example.com>, next',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            '"Roy.A.Bear" <dinsdale@example.com>',
+            [],
+            ', next')
+        self.assertEqual(name_addr.display_name, 'Roy.A.Bear')
+        self.assertEqual(name_addr.local_part, 'dinsdale')
+        self.assertEqual(name_addr.domain, 'example.com')
+        self.assertIsNone(name_addr.route)
+        self.assertEqual(name_addr.addr_spec, 'dinsdale@example.com')
+
+    def test_get_name_addr_empty_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr('')
+
+    def test_get_name_addr_no_content_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr(' (foo) ')
+
+    def test_get_name_addr_no_content_before_special_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr(' (foo) ,')
+
+    def test_get_name_addr_no_angle_after_display_name_raises(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_name_addr('foo bar')
+
+    # get_mailbox
+
+    def test_get_mailbox_addr_spec_only(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_angle_addr_only(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            '<dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_name_addr(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertEqual(mailbox.display_name, 'Roy A. Bear')
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_ends_at_special(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '"Roy A. Bear" <dinsdale@example.com>, rest',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            '"Roy A. Bear" <dinsdale@example.com>',
+            [],
+            ', rest')
+        self.assertEqual(mailbox.token_type, 'mailbox')
+        self.assertEqual(mailbox.display_name, 'Roy A. Bear')
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+
+    def test_get_mailbox_quoted_strings_in_atom_list(self):
+        mailbox = self._test_get_x(parser.get_mailbox,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(mailbox.local_part, 'example example')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertEqual(mailbox.addr_spec, '"example example"@example.com')
+
+    # get_mailbox_list
+
+    def test_get_mailbox_list_single_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(mailbox_list.token_type, 'mailbox-list')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        mailbox = mailbox_list.mailboxes[0]
+        self.assertIsNone(mailbox.display_name)
+        self.assertEqual(mailbox.local_part, 'dinsdale')
+        self.assertEqual(mailbox.domain, 'example.com')
+        self.assertIsNone(mailbox.route)
+        self.assertEqual(mailbox.addr_spec, 'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_simple_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            'dinsdale@example.com, dinsdale@test.example.com',
+            'dinsdale@example.com, dinsdale@test.example.com',
+            'dinsdale@example.com, dinsdale@test.example.com',
+            [],
+            '')
+        self.assertEqual(mailbox_list.token_type, 'mailbox-list')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_name_addr(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_two_complex(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('(foo) "Roy A. Bear" <dinsdale@example.com>(bar),'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('(foo) "Roy A. Bear" <dinsdale@example.com>(bar),'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            (' "Roy A. Bear" <dinsdale@example.com> ,'
+                ' "Fred Flintstone" <dinsdale@test. example.com>'),
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+        self.assertEqual(mailbox_list.mailboxes,
+                         mailbox_list.all_mailboxes)
+
+    def test_get_mailbox_list_unparseable_mailbox_null(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test.(bird)example.com>'),
+            ('"Roy A. Bear"[] dinsdale@example.com,'
+                ' "Fred Flintstone" <dinsdale@test. example.com>'),
+            [errors.InvalidHeaderDefect,   # the 'extra' text after the local part
+             errors.InvalidHeaderDefect,   # the local part with no angle-addr
+             errors.ObsoleteHeaderDefect,  # period in extra text (example.com)
+             errors.ObsoleteHeaderDefect], # (bird) in valid address.
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        self.assertEqual(len(mailbox_list.all_mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
+                        'invalid-mailbox')
+        self.assertIsNone(mailbox_list.all_mailboxes[0].display_name)
+        self.assertEqual(mailbox_list.all_mailboxes[0].local_part,
+                        'Roy A. Bear')
+        self.assertIsNone(mailbox_list.all_mailboxes[0].domain)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        '"Roy A. Bear"')
+        self.assertIs(mailbox_list.all_mailboxes[1],
+                        mailbox_list.mailboxes[0])
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_junk_after_valid_address(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>@@,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 1)
+        self.assertEqual(len(mailbox_list.all_mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.all_mailboxes[0].token_type,
+                        'invalid-mailbox')
+        self.assertIs(mailbox_list.all_mailboxes[1],
+                        mailbox_list.mailboxes[0])
+        self.assertEqual(mailbox_list.mailboxes[0].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[0].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_empty_list_element(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, (bird),,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, (bird),,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, ,,'
+                ' "Fred Flintstone" <dinsdale@test.example.com>'),
+            [errors.ObsoleteHeaderDefect]*2,
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 2)
+        self.assertEqual(mailbox_list.all_mailboxes,
+                         mailbox_list.mailboxes)
+        self.assertEqual(mailbox_list.all_mailboxes[0].addr_spec,
+                        'dinsdale@example.com')
+        self.assertEqual(mailbox_list.all_mailboxes[0].display_name,
+                        'Roy A. Bear')
+        self.assertEqual(mailbox_list.mailboxes[1].addr_spec,
+                        'dinsdale@test.example.com')
+        self.assertEqual(mailbox_list.mailboxes[1].display_name,
+                        'Fred Flintstone')
+
+    def test_get_mailbox_list_only_empty_elements(self):
+        mailbox_list = self._test_get_x(parser.get_mailbox_list,
+            '(foo),, (bar)',
+            '(foo),, (bar)',
+            ' ,, ',
+            [errors.ObsoleteHeaderDefect]*3,
+            '')
+        self.assertEqual(len(mailbox_list.mailboxes), 0)
+        self.assertEqual(mailbox_list.all_mailboxes,
+                         mailbox_list.mailboxes)
+
+    # get_group_list
+
+    def test_get_group_list_cfws_only(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            '(hidden);',
+            '(hidden)',
+            ' ',
+            [],
+            ';')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    def test_get_group_list_mailbox_list(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            'dinsdale@example.org, "Fred A. Bear" <dinsdale@example.org>',
+            [],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 2)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+        self.assertEqual(group_list.mailboxes[1].display_name,
+                         'Fred A. Bear')
+
+    def test_get_group_list_obs_group_list(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            ', (foo),,(bar)',
+            ', (foo),,(bar)',
+            ', ,, ',
+            [errors.ObsoleteHeaderDefect],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    def test_get_group_list_comment_only_invalid(self):
+        group_list = self._test_get_x(parser.get_group_list,
+            '(bar)',
+            '(bar)',
+            ' ',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group_list.token_type, 'group-list')
+        self.assertEqual(len(group_list.mailboxes), 0)
+        self.assertEqual(group_list.mailboxes,
+                         group_list.all_mailboxes)
+
+    # get_group
+
+    def test_get_group_empty(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python:;',
+            'Monty Python:;',
+            'Monty Python:;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+
+    def test_get_group_null_addr_spec(self):
+        group = self._test_get_x(parser.get_group,
+            'foo: <>;',
+            'foo: <>;',
+            'foo: <>;',
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group.display_name, 'foo')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(len(group.all_mailboxes), 1)
+        self.assertEqual(group.all_mailboxes[0].value, '<>')
+
+    def test_get_group_cfws_only(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python: (hidden);',
+            'Monty Python: (hidden);',
+            'Monty Python: ;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 0)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+
+    def test_get_group_single_mailbox(self):
+        group = self._test_get_x(parser.get_group,
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            'Monty Python: "Fred A. Bear" <dinsdale@example.com>;',
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 1)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].addr_spec,
+                         'dinsdale@example.com')
+
+    def test_get_group_mixed_list(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger <ping@exampele.com>, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger <ping@exampele.com>, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                ' Roger <ping@exampele.com>, x@test.example.com;'),
+            [],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 3)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].display_name,
+                         'Roger')
+        self.assertEqual(group.mailboxes[2].local_part, 'x')
+
+    def test_get_group_one_invalid(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger ping@exampele.com, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                '(foo) Roger ping@exampele.com, x@test.example.com;'),
+            ('Monty Python: "Fred A. Bear" <dinsdale@example.com>,'
+                ' Roger ping@exampele.com, x@test.example.com;'),
+            [errors.InvalidHeaderDefect,   # non-angle addr makes local part invalid
+             errors.InvalidHeaderDefect],   # and its not obs-local either: no dots.
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 2)
+        self.assertEqual(len(group.all_mailboxes), 3)
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].local_part, 'x')
+        self.assertIsNone(group.all_mailboxes[1].display_name)
+
+    def test_get_group_missing_final_semicol(self):
+        group = self._test_get_x(parser.get_group,
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>'),
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>;'),
+            ('Monty Python:"Fred A. Bear" <dinsdale@example.com>,'
+             'eric@where.test,John <jdoe@test>;'),
+            [errors.InvalidHeaderDefect],
+            '')
+        self.assertEqual(group.token_type, 'group')
+        self.assertEqual(group.display_name, 'Monty Python')
+        self.assertEqual(len(group.mailboxes), 3)
+        self.assertEqual(group.mailboxes,
+                         group.all_mailboxes)
+        self.assertEqual(group.mailboxes[0].addr_spec,
+                         'dinsdale@example.com')
+        self.assertEqual(group.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(group.mailboxes[1].addr_spec,
+                         'eric@where.test')
+        self.assertEqual(group.mailboxes[2].display_name,
+                         'John')
+        self.assertEqual(group.mailboxes[2].addr_spec,
+                         'jdoe@test')
+    # get_address
+
+    def test_get_address_simple(self):
+        address = self._test_get_x(parser.get_address,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_complex(self):
+        address = self._test_get_x(parser.get_address,
+            '(foo) "Fred A. Bear" <(bird)dinsdale@example.com>',
+            '(foo) "Fred A. Bear" <(bird)dinsdale@example.com>',
+            ' "Fred A. Bear" < dinsdale@example.com>',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].display_name,
+                         'Fred A. Bear')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_rfc2047_display_name(self):
+        address = self._test_get_x(parser.get_address,
+            '=?utf-8?q?=C3=89ric?= <foo@example.com>',
+            'Éric <foo@example.com>',
+            'Éric <foo@example.com>',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].display_name,
+                         'Éric')
+        self.assertEqual(address[0].token_type,
+                         'mailbox')
+
+    def test_get_address_empty_group(self):
+        address = self._test_get_x(parser.get_address,
+            'Monty Python:;',
+            'Monty Python:;',
+            'Monty Python:;',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address[0].token_type,
+                         'group')
+        self.assertEqual(address[0].display_name,
+                         'Monty Python')
+
+    def test_get_address_group(self):
+        address = self._test_get_x(parser.get_address,
+            'Monty Python: x@example.com, y@example.com;',
+            'Monty Python: x@example.com, y@example.com;',
+            'Monty Python: x@example.com, y@example.com;',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 2)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address[0].token_type,
+                         'group')
+        self.assertEqual(address[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address.mailboxes[0].local_part, 'x')
+
+    def test_get_address_quoted_local_part(self):
+        address = self._test_get_x(parser.get_address,
+            '"foo bar"@example.com',
+            '"foo bar"@example.com',
+            '"foo bar"@example.com',
+            [],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address.mailboxes[0].local_part,
+                         'foo bar')
+        self.assertEqual(address[0].token_type, 'mailbox')
+
+    def test_get_address_ends_at_special(self):
+        address = self._test_get_x(parser.get_address,
+            'dinsdale@example.com, next',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            ', next')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 1)
+        self.assertEqual(address.mailboxes,
+                         address.all_mailboxes)
+        self.assertEqual(address.mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address[0].token_type, 'mailbox')
+
+    def test_get_address_invalid_mailbox_invalid(self):
+        address = self._test_get_x(parser.get_address,
+            'ping example.com, next',
+            'ping example.com',
+            'ping example.com',
+            [errors.InvalidHeaderDefect,    # addr-spec with no domain
+             errors.InvalidHeaderDefect,    # invalid local-part
+             errors.InvalidHeaderDefect,    # missing .s in local-part
+            ],
+            ', next')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertIsNone(address.all_mailboxes[0].domain)
+        self.assertEqual(address.all_mailboxes[0].local_part, 'ping example.com')
+        self.assertEqual(address[0].token_type, 'invalid-mailbox')
+
+    def test_get_address_quoted_strings_in_atom_list(self):
+        address = self._test_get_x(parser.get_address,
+            '""example" example"@example.com',
+            '""example" example"@example.com',
+            'example example@example.com',
+            [errors.InvalidHeaderDefect]*3,
+            '')
+        self.assertEqual(address.all_mailboxes[0].local_part, 'example example')
+        self.assertEqual(address.all_mailboxes[0].domain, 'example.com')
+        self.assertEqual(address.all_mailboxes[0].addr_spec, '"example example"@example.com')
+
+    def test_get_address_with_invalid_domain(self):
+        address = self._test_get_x(parser.get_address,
+            '<T@[',
+            '<T@[]>',
+            '<T@[]>',
+            [errors.InvalidHeaderDefect,    # missing trailing '>' on angle-addr
+             errors.InvalidHeaderDefect,    # end of input inside domain-literal
+            ],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertEqual(address.all_mailboxes[0].domain, '[]')
+        self.assertEqual(address.all_mailboxes[0].local_part, 'T')
+        self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
+        self.assertEqual(address[0].token_type, 'invalid-mailbox')
+
+        address = self._test_get_x(parser.get_address,
+            '!an??:=m==fr2@[C',
+            '!an??:=m==fr2@[C];',
+            '!an??:=m==fr2@[C];',
+            [errors.InvalidHeaderDefect,    # end of header in group
+             errors.InvalidHeaderDefect,    # end of input inside domain-literal
+            ],
+            '')
+        self.assertEqual(address.token_type, 'address')
+        self.assertEqual(len(address.mailboxes), 0)
+        self.assertEqual(len(address.all_mailboxes), 1)
+        self.assertEqual(address.all_mailboxes[0].domain, '[C]')
+        self.assertEqual(address.all_mailboxes[0].local_part, '=m==fr2')
+        self.assertEqual(address.all_mailboxes[0].token_type, 'invalid-mailbox')
+        self.assertEqual(address[0].token_type, 'group')
+
+    # get_address_list
+
+    def test_get_address_list_CFWS(self):
+        address_list = self._test_get_x(parser.get_address_list,
+                                        '(Recipient list suppressed)',
+                                        '(Recipient list suppressed)',
+                                        ' ',
+                                        [errors.ObsoleteHeaderDefect],  # no content in address list
+                                        '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 0)
+        self.assertEqual(address_list.mailboxes, address_list.all_mailboxes)
+
+    def test_get_address_list_mailboxes_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            'dinsdale@example.com',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list[0].token_type, 'address')
+        self.assertIsNone(address_list[0].display_name)
+
+    def test_get_address_list_mailboxes_two_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            'foo@example.com, "Fred A. Bar" <bar@example.com>',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 2)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].local_part, 'foo')
+        self.assertEqual(address_list.mailboxes[1].display_name, "Fred A. Bar")
+
+    def test_get_address_list_mailboxes_complex(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo <x@example.com>,'
+                'Nobody Is. Special <y@(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo <x@example.com>,'
+                'Nobody Is. Special <y@(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                'Foo <x@example.com>,'
+                '"Nobody Is. Special" <y@example. com>'),
+            [errors.ObsoleteHeaderDefect, # period in Is.
+            errors.ObsoleteHeaderDefect], # cfws in domain
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 3)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual([str(x) for x in address_list.mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.mailboxes[1].local_part, 'x')
+        self.assertEqual(address_list.mailboxes[2].display_name,
+                         'Nobody Is. Special')
+
+    def test_get_address_list_mailboxes_invalid_addresses(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo x@example.com[],'
+                'Nobody Is. Special <(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                '(ping) Foo x@example.com[],'
+                'Nobody Is. Special <(bird)example.(bad)com>'),
+            ('"Roy A. Bear" <dinsdale@example.com>, '
+                'Foo x@example.com[],'
+                '"Nobody Is. Special" < example. com>'),
+             [errors.InvalidHeaderDefect,   # invalid address in list
+              errors.InvalidHeaderDefect,   # 'Foo x' local part invalid.
+              errors.InvalidHeaderDefect,   # Missing . in 'Foo x' local part
+              errors.ObsoleteHeaderDefect,  # period in 'Is.' disp-name phrase
+              errors.InvalidHeaderDefect,   # no domain part in addr-spec
+              errors.ObsoleteHeaderDefect], # addr-spec has comment in it
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(len(address_list.all_mailboxes), 3)
+        self.assertEqual([str(x) for x in address_list.all_mailboxes],
+                         [str(x) for x in address_list.addresses])
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.mailboxes[0].token_type, 'mailbox')
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.addresses[1].token_type, 'address')
+        self.assertEqual(len(address_list.addresses[0].mailboxes), 1)
+        self.assertEqual(len(address_list.addresses[1].mailboxes), 0)
+        self.assertEqual(len(address_list.addresses[1].mailboxes), 0)
+        self.assertEqual(
+            address_list.addresses[1].all_mailboxes[0].local_part, 'Foo x')
+        self.assertEqual(
+            address_list.addresses[2].all_mailboxes[0].display_name,
+                "Nobody Is. Special")
+
+    def test_get_address_list_group_empty(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'Monty Python: ;',
+            'Monty Python: ;',
+            'Monty Python: ;',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 0)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(len(address_list.addresses), 1)
+        self.assertEqual(address_list.addresses[0].token_type, 'address')
+        self.assertEqual(address_list.addresses[0].display_name, 'Monty Python')
+        self.assertEqual(len(address_list.addresses[0].mailboxes), 0)
+
+    def test_get_address_list_group_simple(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            'Monty Python: dinsdale@example.com;',
+            'Monty Python: dinsdale@example.com;',
+            'Monty Python: dinsdale@example.com;',
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 1)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(address_list.mailboxes[0].domain, 'example.com')
+        self.assertEqual(address_list.addresses[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
+                         'example.com')
+
+    def test_get_address_list_group_and_mailboxes(self):
+        address_list = self._test_get_x(parser.get_address_list,
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            ('Monty Python: dinsdale@example.com, "Fred" <flint@example.com>;, '
+                'Abe <x@example.com>, Bee <y@example.com>'),
+            [],
+            '')
+        self.assertEqual(address_list.token_type, 'address-list')
+        self.assertEqual(len(address_list.mailboxes), 4)
+        self.assertEqual(address_list.mailboxes,
+                         address_list.all_mailboxes)
+        self.assertEqual(len(address_list.addresses), 3)
+        self.assertEqual(address_list.mailboxes[0].local_part, 'dinsdale')
+        self.assertEqual(address_list.addresses[0].display_name,
+                         'Monty Python')
+        self.assertEqual(address_list.addresses[0].mailboxes[0].domain,
+                         'example.com')
+        self.assertEqual(address_list.addresses[0].mailboxes[1].local_part,
+                         'flint')
+        self.assertEqual(address_list.addresses[1].mailboxes[0].local_part,
+                         'x')
+        self.assertEqual(address_list.addresses[2].mailboxes[0].local_part,
+                         'y')
+        self.assertEqual(str(address_list.addresses[1]),
+                         str(address_list.mailboxes[2]))
+
+    def test_invalid_content_disposition(self):
+        content_disp = self._test_parse_x(
+            parser.parse_content_disposition_header,
+            ";attachment", "; attachment", ";attachment",
+            [errors.InvalidHeaderDefect]*2
+        )
+
+    def test_invalid_content_transfer_encoding(self):
+        cte = self._test_parse_x(
+            parser.parse_content_transfer_encoding_header,
+            ";foo", ";foo", ";foo", [errors.InvalidHeaderDefect]*3
+        )
+
+    # get_msg_id
+
+    def test_get_msg_id_empty(self):
+        # bpo-38708: Test that HeaderParseError is raised and not IndexError.
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id('')
+
+    def test_get_msg_id_valid(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simeple.local@example.something.com>",
+            "<simeple.local@example.something.com>",
+            "<simeple.local@example.something.com>",
+            [],
+            '',
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_obsolete_local(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            '<"simeple.local"@example.com>',
+            '<"simeple.local"@example.com>',
+            '<simeple.local@example.com>',
+            [errors.ObsoleteHeaderDefect],
+            '',
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_non_folding_literal_domain(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simple.local@[someexamplecom.domain]>",
+            "<simple.local@[someexamplecom.domain]>",
+            "<simple.local@[someexamplecom.domain]>",
+            [],
+            "",
+            )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+
+    def test_get_msg_id_obsolete_domain_part(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal@(old)example.com>",
+            "<simplelocal@(old)example.com>",
+            "<simplelocal@ example.com>",
+            [errors.ObsoleteHeaderDefect],
+            ""
+        )
+
+    def test_get_msg_id_no_id_right_part(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal>",
+            "<simplelocal>",
+            "<simplelocal>",
+            [errors.InvalidHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_invalid_expected_msg_id_not_found(self):
+        text = "935-XPB-567:0:45327:9:90305:17843586-40@example.com"
+        msg_id = parser.parse_message_id(text)
+        self.assertDefectsEqual(
+            msg_id.all_defects,
+            [errors.InvalidHeaderDefect])
+
+    def test_parse_invalid_message_id(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            "935-XPB-567:0:45327:9:90305:17843586-40@example.com",
+            [errors.InvalidHeaderDefect],
+            )
+        self.assertEqual(message_id.token_type, 'invalid-message-id')
+
+    def test_parse_valid_message_id(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<aperson@somedomain>",
+            "<aperson@somedomain>",
+            "<aperson@somedomain>",
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+
+    def test_parse_message_id_with_invalid_domain(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<T@[",
+            "<T@[]>",
+            "<T@[]>",
+            [errors.ObsoleteHeaderDefect] + [errors.InvalidHeaderDefect] * 2,
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+        self.assertEqual(str(message_id.all_defects[-1]),
+                         "end of input inside domain-literal")
+
+    def test_parse_message_id_with_remaining(self):
+        message_id = self._test_parse_x(
+            parser.parse_message_id,
+            "<validmessageid@example>thensomething",
+            "<validmessageid@example>",
+            "<validmessageid@example>",
+            [errors.InvalidHeaderDefect],
+            [],
+            )
+        self.assertEqual(message_id.token_type, 'message-id')
+        self.assertEqual(str(message_id.all_defects[0]),
+                         "Unexpected 'thensomething'")
+
+    def test_get_msg_id_no_angle_start(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("msgwithnoankle")
+
+    def test_get_msg_id_no_angle_end(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "<simplelocal@domain",
+            "<simplelocal@domain>",
+            "<simplelocal@domain>",
+            [errors.InvalidHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+    def test_get_msg_id_empty_id_left(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<@domain>")
+
+    def test_get_msg_id_empty_id_right(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<simplelocal@>")
+
+    def test_get_msg_id_no_id_right(self):
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<simplelocal@")
+
+    def test_get_msg_id_with_brackets(self):
+        # Microsof Outlook generates non-standard one-off addresses:
+        # https://learn.microsoft.com/en-us/office/client-developer/outlook/mapi/one-off-addresses
+        with self.assertRaises(errors.HeaderParseError):
+            parser.get_msg_id("<[abrakadabra@microsoft.com]>")
+
+    def test_get_msg_id_ws_only_local(self):
+        msg_id = self._test_get_x(
+            parser.get_msg_id,
+            "< @domain>",
+            "< @domain>",
+            "< @domain>",
+            [errors.ObsoleteHeaderDefect],
+            ""
+        )
+        self.assertEqual(msg_id.token_type, 'msg-id')
+
+
+
+@parameterize
+class Test_parse_mime_parameters(TestParserMixin, TestEmailBase):
+
+    def mime_parameters_as_value(self,
+                                 value,
+                                 tl_str,
+                                 tl_value,
+                                 params,
+                                 defects):
+        mime_parameters = self._test_parse_x(parser.parse_mime_parameters,
+            value, tl_str, tl_value, defects)
+        self.assertEqual(mime_parameters.token_type, 'mime-parameters')
+        self.assertEqual(list(mime_parameters.params), params)
+
+
+    mime_parameters_params = {
+
+        'simple': (
+            'filename="abc.py"',
+            ' filename="abc.py"',
+            'filename=abc.py',
+            [('filename', 'abc.py')],
+            []),
+
+        'multiple_keys': (
+            'filename="abc.py"; xyz=abc',
+            ' filename="abc.py"; xyz="abc"',
+            'filename=abc.py; xyz=abc',
+            [('filename', 'abc.py'), ('xyz', 'abc')],
+            []),
+
+        'split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            [('filename', '201.tif')],
+            []),
+
+        # Note that it is undefined what we should do for error recovery when
+        # there are duplicate parameter names or duplicate parts in a split
+        # part.  We choose to ignore all duplicate parameters after the first
+        # and to take duplicate or missing rfc 2231 parts in appearance order.
+        # This is backward compatible with get_param's behavior, but the
+        # decisions are arbitrary.
+
+        'duplicate_key': (
+            'filename=abc.gif; filename=def.tiff',
+            ' filename="abc.gif"',
+            "filename=abc.gif; filename=def.tiff",
+            [('filename', 'abc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_key_with_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename=abc.gif",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename=abc.gif",
+            [('filename', '201.tif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_key_with_split_value_other_order': (
+            "filename=abc.gif; "
+                " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            ' filename="abc.gif"',
+            "filename=abc.gif;"
+                " filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66",
+            [('filename', 'abc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_in_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename*1*=abc.gif",
+            ' filename="201.tifabc.gif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*1*=%74%69%66;"
+                " filename*1*=abc.gif",
+            [('filename', '201.tifabc.gif')],
+            [errors.InvalidHeaderDefect]),
+
+        'missing_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
+            ' filename="201.tif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;",
+            [('filename', '201.tif')],
+            [errors.InvalidHeaderDefect]),
+
+        'duplicate_and_missing_split_value': (
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
+                " filename*3*=abc.gif",
+            ' filename="201.tifabc.gif"',
+            "filename*0*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66;"
+                " filename*3*=abc.gif",
+            [('filename', '201.tifabc.gif')],
+            [errors.InvalidHeaderDefect]*2),
+
+        # Here we depart from get_param and assume the *0* was missing.
+        'duplicate_with_broken_split_value': (
+            "filename=abc.gif; "
+                " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
+            ' filename="abc.gif201.tif"',
+            "filename=abc.gif;"
+                " filename*2*=iso-8859-1''%32%30%31%2E; filename*3*=%74%69%66",
+            [('filename', 'abc.gif201.tif')],
+            # Defects are apparent missing *0*, and two 'out of sequence'.
+            [errors.InvalidHeaderDefect]*3),
+
+        # bpo-37461: Check that we don't go into an infinite loop.
+        'extra_dquote': (
+            'r*="\'a\'\\"',
+            ' r="\\""',
+            'r*=\'a\'"',
+            [('r', '"')],
+            [errors.InvalidHeaderDefect]*2),
+    }
+
+@parameterize
+class Test_parse_mime_version(TestParserMixin, TestEmailBase):
+
+    def mime_version_as_value(self,
+                              value,
+                              tl_str,
+                              tl_value,
+                              major,
+                              minor,
+                              defects):
+        mime_version = self._test_parse_x(parser.parse_mime_version,
+            value, tl_str, tl_value, defects)
+        self.assertEqual(mime_version.major, major)
+        self.assertEqual(mime_version.minor, minor)
+
+    mime_version_params = {
+
+        'rfc_2045_1': (
+            '1.0',
+            '1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_2': (
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 ',
+            1,
+            0,
+            []),
+
+        'RFC_2045_3': (
+            '(produced by MetaSend Vx.x) 1.0',
+            '(produced by MetaSend Vx.x) 1.0',
+            ' 1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_4': (
+            '1.(produced by MetaSend Vx.x)0',
+            '1.(produced by MetaSend Vx.x)0',
+            '1. 0',
+            1,
+            0,
+            []),
+
+        'empty': (
+            '',
+            '',
+            '',
+            None,
+            None,
+            [errors.HeaderMissingRequiredValue]),
+
+        }
+
+
+
+class TestFolding(TestEmailBase):
+
+    policy = policy.default
+
+    def _test(self, tl, folded, policy=policy):
+        self.assertEqual(tl.fold(policy=policy), folded, tl.ppstr())
+
+    def test_simple_unstructured_no_folds(self):
+        self._test(parser.get_unstructured("This is a test"),
+                   "This is a test\n")
+
+    def test_simple_unstructured_folded(self):
+        self._test(parser.get_unstructured("This is also a test, but this "
+                        "time there are enough words (and even some "
+                        "symbols) to make it wrap; at least in theory."),
+                   "This is also a test, but this time there are enough "
+                        "words (and even some\n"
+                   " symbols) to make it wrap; at least in theory.\n")
+
+    def test_unstructured_with_unicode_no_folds(self):
+        self._test(parser.get_unstructured("hübsch kleiner beißt"),
+                   "=?utf-8?q?h=C3=BCbsch_kleiner_bei=C3=9Ft?=\n")
+
+    def test_one_ew_on_each_of_two_wrapped_lines(self):
+        self._test(parser.get_unstructured("Mein kleiner Kaktus ist sehr "
+                                           "hübsch.  Es hat viele Stacheln "
+                                           "und oft beißt mich."),
+                   "Mein kleiner Kaktus ist sehr =?utf-8?q?h=C3=BCbsch=2E?=  "
+                        "Es hat viele Stacheln\n"
+                   " und oft =?utf-8?q?bei=C3=9Ft?= mich.\n")
+
+    def test_ews_combined_before_wrap(self):
+        self._test(parser.get_unstructured("Mein Kaktus ist hübsch.  "
+                                           "Es beißt mich.  "
+                                           "And that's all I'm sayin."),
+                   "Mein Kaktus ist =?utf-8?q?h=C3=BCbsch=2E__Es_bei=C3=9Ft?= "
+                        "mich.  And that's\n"
+                   " all I'm sayin.\n")
+
+    def test_unicode_after_unknown_not_combined(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=\xa4"),
+                   "=?unknown-8bit?q?=A4?==?utf-8?q?=C2=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=\xa4"),
+                   prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?=C2=A4?=\n")
+
+    def test_ascii_after_unknown_not_combined(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=A4?=abc"),
+                   "=?unknown-8bit?q?=A4?=abc\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=A4?=abc"),
+                   prefix + "=?unknown-8bit?q?=A4?=\n =?utf-8?q?abc?=\n")
+
+    def test_unknown_after_unicode_not_combined(self):
+        self._test(parser.get_unstructured("\xa4"
+                                           "=?unknown-8bit?q?=A4?="),
+                   "=?utf-8?q?=C2=A4?==?unknown-8bit?q?=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "\xa4=?unknown-8bit?q?=A4?="),
+                   prefix + "=?utf-8?q?=C2=A4?=\n =?unknown-8bit?q?=A4?=\n")
+
+    def test_unknown_after_ascii_not_combined(self):
+        self._test(parser.get_unstructured("abc"
+                                           "=?unknown-8bit?q?=A4?="),
+                   "abc=?unknown-8bit?q?=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "abcd=?unknown-8bit?q?=A4?="),
+                   prefix + "abcd\n =?unknown-8bit?q?=A4?=\n")
+
+    def test_unknown_after_unknown(self):
+        self._test(parser.get_unstructured("=?unknown-8bit?q?=C2?="
+                                           "=?unknown-8bit?q?=A4?="),
+                   "=?unknown-8bit?q?=C2=A4?=\n")
+        prefix = "0123456789 "*5
+        self._test(parser.get_unstructured(prefix + "=?unknown-8bit?q?=C2?="
+                                           "=?unknown-8bit?q?=A4?="),
+                   prefix + "=?unknown-8bit?q?=C2?=\n =?unknown-8bit?q?=A4?=\n")
+
+    # XXX Need test of an encoded word so long that it needs to be wrapped
+
+    def test_simple_address(self):
+        self._test(parser.get_address_list("abc <xyz@example.com>")[0],
+                   "abc <xyz@example.com>\n")
+
+    def test_address_list_folding_at_commas(self):
+        self._test(parser.get_address_list('abc <xyz@example.com>, '
+                                            '"Fred Blunt" <sharp@example.com>, '
+                                            '"J.P.Cool" <hot@example.com>, '
+                                            '"K<>y" <key@example.com>, '
+                                            'Firesale <cheap@example.com>, '
+                                            '<end@example.com>')[0],
+                    'abc <xyz@example.com>, "Fred Blunt" <sharp@example.com>,\n'
+                    ' "J.P.Cool" <hot@example.com>, "K<>y" <key@example.com>,\n'
+                    ' Firesale <cheap@example.com>, <end@example.com>\n')
+
+    def test_address_list_with_unicode_names(self):
+        self._test(parser.get_address_list(
+            'Hübsch Kaktus <beautiful@example.com>, '
+                'beißt beißt <biter@example.com>')[0],
+            '=?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>,\n'
+                ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <biter@example.com>\n')
+
+    def test_address_list_with_unicode_names_in_quotes(self):
+        self._test(parser.get_address_list(
+            '"Hübsch Kaktus" <beautiful@example.com>, '
+                '"beißt" beißt <biter@example.com>')[0],
+            '=?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>,\n'
+                ' =?utf-8?q?bei=C3=9Ft_bei=C3=9Ft?= <biter@example.com>\n')
+
+    def test_address_list_with_specials_in_encoded_word(self):
+        # An encoded-word parsed from a structured header must remain
+        # encoded when it contains specials. Regression for gh-121284.
+        policy = self.policy.clone(max_line_length=40)
+        cases = [
+            # (to, folded)
+            ('=?utf-8?q?A_v=C3=A9ry_long_name_with=2C_comma?= <to@example.com>',
+             'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
+             ' =?utf-8?q?=2C?= comma <to@example.com>\n'),
+            ('=?utf-8?q?This_long_name_does_not_need_encoded=2Dword?= <to@example.com>',
+             'This long name does not need\n'
+             ' encoded-word <to@example.com>\n'),
+            ('"A véry long name with, comma" <to@example.com>',
+             # (This isn't the best fold point, but it's not invalid.)
+             'A =?utf-8?q?v=C3=A9ry_long_name_with?=\n'
+             ' =?utf-8?q?=2C?= comma <to@example.com>\n'),
+            ('"A véry long name containing a, comma" <to@example.com>',
+             'A =?utf-8?q?v=C3=A9ry?= long name\n'
+             ' containing =?utf-8?q?a=2C?= comma\n'
+             ' <to@example.com>\n'),
+        ]
+        for (to, folded) in cases:
+            with self.subTest(to=to):
+                self._test(parser.get_address_list(to)[0], folded, policy=policy)
+
+    def test_address_list_with_list_separator_after_fold(self):
+        a = 'x' * 66 + '@example.com'
+        to = f'{a}, "Hübsch Kaktus" <beautiful@example.com>'
+        self._test(parser.get_address_list(to)[0],
+            f'{a},\n =?utf-8?q?H=C3=BCbsch?= Kaktus <beautiful@example.com>\n')
+
+        a = '.' * 79  # ('.' is a special, so must be in quoted-string.)
+        to = f'"{a}" <xyz@example.com>, "Hübsch Kaktus" <beautiful@example.com>'
+        self._test(parser.get_address_list(to)[0],
+            f'"{a}"\n'
+            ' <xyz@example.com>, =?utf-8?q?H=C3=BCbsch?= Kaktus '
+            '<beautiful@example.com>\n')
+
+    def test_address_list_with_specials_in_long_quoted_string(self):
+        # Regression for gh-80222.
+        policy = self.policy.clone(max_line_length=40)
+        cases = [
+            # (to, folded)
+            ('"Exfiltrator <spy@example.org> (unclosed comment?" <to@example.com>',
+             '"Exfiltrator <spy@example.org> (unclosed\n'
+             ' comment?" <to@example.com>\n'),
+            ('"Escaped \\" chars \\\\ in quoted-string stay escaped" <to@example.com>',
+             '"Escaped \\" chars \\\\ in quoted-string\n'
+             ' stay escaped" <to@example.com>\n'),
+            ('This long display name does not need quotes <to@example.com>',
+             'This long display name does not need\n'
+             ' quotes <to@example.com>\n'),
+            ('"Quotes are not required but are retained here" <to@example.com>',
+             '"Quotes are not required but are\n'
+             ' retained here" <to@example.com>\n'),
+            ('"A quoted-string, it can be a valid local-part"@example.com',
+             '"A quoted-string, it can be a valid\n'
+             ' local-part"@example.com\n'),
+            ('"local-part-with-specials@but-no-fws.cannot-fold"@example.com',
+             '"local-part-with-specials@but-no-fws.cannot-fold"@example.com\n'),
+        ]
+        for (to, folded) in cases:
+            with self.subTest(to=to):
+                self._test(parser.get_address_list(to)[0], folded, policy=policy)
+
+    # XXX Need tests with comments on various sides of a unicode token,
+    # and with unicode tokens in the comments.  Spaces inside the quotes
+    # currently don't do the right thing.
+
+    def test_split_at_whitespace_after_header_before_long_token(self):
+        body = parser.get_unstructured('   ' + 'x'*77)
+        header = parser.Header([
+            parser.HeaderLabel([parser.ValueTerminal('test:', 'atext')]),
+            parser.CFWSList([parser.WhiteSpaceTerminal(' ', 'fws')]), body])
+        self._test(header, 'test:   \n ' + 'x'*77 + '\n')
+
+    def test_split_at_whitespace_before_long_token(self):
+        self._test(parser.get_unstructured('xxx   ' + 'y'*77),
+                   'xxx  \n ' + 'y'*77 + '\n')
+
+    def test_overlong_encodeable_is_wrapped(self):
+        first_token_with_whitespace = 'xxx   '
+        chrome_leader = '=?utf-8?q?'
+        len_chrome = len(chrome_leader) + 2
+        len_non_y = len_chrome + len(first_token_with_whitespace)
+        self._test(parser.get_unstructured(first_token_with_whitespace +
+                                           'y'*80),
+                   first_token_with_whitespace + chrome_leader +
+                       'y'*(78-len_non_y) + '?=\n' +
+                       ' ' + chrome_leader + 'y'*(80-(78-len_non_y)) + '?=\n')
+
+    def test_long_filename_attachment(self):
+        self._test(parser.parse_content_disposition_header(
+            'attachment; filename="TEST_TEST_TEST_TEST'
+                '_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TEST_TES.txt"'),
+            "attachment;\n"
+            " filename*0*=us-ascii''TEST_TEST_TEST_TEST_TEST_TEST"
+                "_TEST_TEST_TEST_TEST_TEST;\n"
+            " filename*1*=_TEST_TES.txt\n",
+            )
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_asian_codecs.py b/Lib/test/test_email/test_asian_codecs.py
new file mode 100644
index 0000000000..1e0caeeaed
--- /dev/null
+++ b/Lib/test/test_email/test_asian_codecs.py
@@ -0,0 +1,81 @@
+# Copyright (C) 2002-2006 Python Software Foundation
+# Contact: email-sig@python.org
+# email package unit tests for (optional) Asian codecs
+
+import unittest
+
+from test.test_email import TestEmailBase
+from email.charset import Charset
+from email.header import Header, decode_header
+from email.message import Message
+
+# We're compatible with Python 2.3, but it doesn't have the built-in Asian
+# codecs, so we have to skip all these tests.
+try:
+    str(b'foo', 'euc-jp')
+except LookupError:
+    raise unittest.SkipTest
+
+
+
+class TestEmailAsianCodecs(TestEmailBase):
+    def test_japanese_codecs(self):
+        eq = self.ndiffAssertEqual
+        jcode = "euc-jp"
+        gcode = "iso-8859-1"
+        j = Charset(jcode)
+        g = Charset(gcode)
+        h = Header("Hello World!")
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', jcode)
+        ghello = str(b'Gr\xfc\xdf Gott!', gcode)
+        h.append(jhello, j)
+        h.append(ghello, g)
+        # BAW: This used to -- and maybe should -- fold the two iso-8859-1
+        # chunks into a single encoded word.  However it doesn't violate the
+        # standard to have them as two encoded chunks and maybe it's
+        # reasonable <wink> for each .append() call to result in a separate
+        # encoded word.
+        eq(h.encode(), """\
+Hello World! =?iso-2022-jp?b?GyRCJU8lbSE8JW8hPCVrJUkhKhsoQg==?=
+ =?iso-8859-1?q?Gr=FC=DF_Gott!?=""")
+        eq(decode_header(h.encode()),
+           [(b'Hello World! ', None),
+            (b'\x1b$B%O%m!<%o!<%k%I!*\x1b(B', 'iso-2022-jp'),
+            (b'Gr\xfc\xdf Gott!', gcode)])
+        subject_bytes = (b'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5'
+            b'\xa4\xec\xa4\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2'
+            b'\xf1\xbc\xd4\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3'
+            b'\xa4\xc6\xa4\xa4\xa4\xde\xa4\xb9')
+        subject = str(subject_bytes, jcode)
+        h = Header(subject, j, header_name="Subject")
+        # test a very long header
+        enc = h.encode()
+        # TK: splitting point may differ by codec design and/or Header encoding
+        eq(enc , """\
+=?iso-2022-jp?b?dGVzdC1qYSAbJEIkWEVqOUYkNSRsJD8lYSE8JWskTztKGyhC?=
+ =?iso-2022-jp?b?GyRCMnE8VCROPjVHJyRyQlQkQyRGJCQkXiQ5GyhC?=""")
+        # TK: full decode comparison
+        eq(str(h).encode(jcode), subject_bytes)
+
+    def test_payload_encoding_utf8(self):
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', 'euc-jp')
+        msg = Message()
+        msg.set_payload(jhello, 'utf-8')
+        ustr = msg.get_payload(decode=True).decode(msg.get_content_charset())
+        self.assertEqual(jhello, ustr)
+
+    def test_payload_encoding(self):
+        jcode  = 'euc-jp'
+        jhello = str(b'\xa5\xcf\xa5\xed\xa1\xbc\xa5\xef\xa1\xbc'
+                     b'\xa5\xeb\xa5\xc9\xa1\xaa', jcode)
+        msg = Message()
+        msg.set_payload(jhello, jcode)
+        ustr = msg.get_payload(decode=True).decode(msg.get_content_charset())
+        self.assertEqual(jhello, ustr)
+
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_contentmanager.py b/Lib/test/test_email/test_contentmanager.py
new file mode 100644
index 0000000000..dceb54f15e
--- /dev/null
+++ b/Lib/test/test_email/test_contentmanager.py
@@ -0,0 +1,836 @@
+import unittest
+from test.test_email import TestEmailBase, parameterize
+import textwrap
+from email import policy
+from email.message import EmailMessage
+from email.contentmanager import ContentManager, raw_data_manager
+
+
+@parameterize
+class TestContentManager(TestEmailBase):
+
+    policy = policy.default
+    message = EmailMessage
+
+    get_key_params = {
+        'full_type':        (1, 'text/plain',),
+        'maintype_only':    (2, 'text',),
+        'null_key':         (3, '',),
+        }
+
+    def get_key_as_get_content_key(self, order, key):
+        def foo_getter(msg, foo=None):
+            bar = msg['X-Bar-Header']
+            return foo, bar
+        cm = ContentManager()
+        cm.add_get_handler(key, foo_getter)
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        m['X-Bar-Header'] = 'foo'
+        self.assertEqual(cm.get_content(m, foo='bar'), ('bar', 'foo'))
+
+    def get_key_as_get_content_key_order(self, order, key):
+        def bar_getter(msg):
+            return msg['X-Bar-Header']
+        def foo_getter(msg):
+            return msg['X-Foo-Header']
+        cm = ContentManager()
+        cm.add_get_handler(key, foo_getter)
+        for precedence, key in self.get_key_params.values():
+            if precedence > order:
+                cm.add_get_handler(key, bar_getter)
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        m['X-Bar-Header'] = 'bar'
+        m['X-Foo-Header'] = 'foo'
+        self.assertEqual(cm.get_content(m), ('foo'))
+
+    def test_get_content_raises_if_unknown_mimetype_and_no_default(self):
+        cm = ContentManager()
+        m = self._make_message()
+        m['Content-Type'] = 'text/plain'
+        with self.assertRaisesRegex(KeyError, 'text/plain'):
+            cm.get_content(m)
+
+    class BaseThing(str):
+        pass
+    baseobject_full_path = __name__ + '.' + 'TestContentManager.BaseThing'
+    class Thing(BaseThing):
+        pass
+    testobject_full_path = __name__ + '.' + 'TestContentManager.Thing'
+
+    set_key_params = {
+        'type':             (0,  Thing,),
+        'full_path':        (1,  testobject_full_path,),
+        'qualname':         (2,  'TestContentManager.Thing',),
+        'name':             (3,  'Thing',),
+        'base_type':        (4,  BaseThing,),
+        'base_full_path':   (5,  baseobject_full_path,),
+        'base_qualname':    (6,  'TestContentManager.BaseThing',),
+        'base_name':        (7,  'BaseThing',),
+        'str_type':         (8,  str,),
+        'str_full_path':    (9,  'builtins.str',),
+        'str_name':         (10, 'str',),   # str name and qualname are the same
+        'null_key':         (11, None,),
+        }
+
+    def set_key_as_set_content_key(self, order, key):
+        def foo_setter(msg, obj, foo=None):
+            msg['X-Foo-Header'] = foo
+            msg.set_payload(obj)
+        cm = ContentManager()
+        cm.add_set_handler(key, foo_setter)
+        m = self._make_message()
+        msg_obj = self.Thing()
+        cm.set_content(m, msg_obj, foo='bar')
+        self.assertEqual(m['X-Foo-Header'], 'bar')
+        self.assertEqual(m.get_payload(), msg_obj)
+
+    def set_key_as_set_content_key_order(self, order, key):
+        def foo_setter(msg, obj):
+            msg['X-FooBar-Header'] = 'foo'
+            msg.set_payload(obj)
+        def bar_setter(msg, obj):
+            msg['X-FooBar-Header'] = 'bar'
+        cm = ContentManager()
+        cm.add_set_handler(key, foo_setter)
+        for precedence, key in self.get_key_params.values():
+            if precedence > order:
+                cm.add_set_handler(key, bar_setter)
+        m = self._make_message()
+        msg_obj = self.Thing()
+        cm.set_content(m, msg_obj)
+        self.assertEqual(m['X-FooBar-Header'], 'foo')
+        self.assertEqual(m.get_payload(), msg_obj)
+
+    def test_set_content_raises_if_unknown_type_and_no_default(self):
+        cm = ContentManager()
+        m = self._make_message()
+        msg_obj = self.Thing()
+        with self.assertRaisesRegex(KeyError, self.testobject_full_path):
+            cm.set_content(m, msg_obj)
+
+    def test_set_content_raises_if_called_on_multipart(self):
+        cm = ContentManager()
+        m = self._make_message()
+        m['Content-Type'] = 'multipart/foo'
+        with self.assertRaises(TypeError):
+            cm.set_content(m, 'test')
+
+    def test_set_content_calls_clear_content(self):
+        m = self._make_message()
+        m['Content-Foo'] = 'bar'
+        m['Content-Type'] = 'text/html'
+        m['To'] = 'test'
+        m.set_payload('abc')
+        cm = ContentManager()
+        cm.add_set_handler(str, lambda *args, **kw: None)
+        m.set_content('xyz', content_manager=cm)
+        self.assertIsNone(m['Content-Foo'])
+        self.assertIsNone(m['Content-Type'])
+        self.assertEqual(m['To'], 'test')
+        self.assertIsNone(m.get_payload())
+
+
+@parameterize
+class TestRawDataManager(TestEmailBase):
+    # Note: these tests are dependent on the order in which headers are added
+    # to the message objects by the code.  There's no defined ordering in
+    # RFC5322/MIME, so this makes the tests more fragile than the standards
+    # require.  However, if the header order changes it is best to understand
+    # *why*, and make sure it isn't a subtle bug in whatever change was
+    # applied.
+
+    policy = policy.default.clone(max_line_length=60,
+                                  content_manager=raw_data_manager)
+    message = EmailMessage
+
+    def test_get_text_plain(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain
+
+            Basic text.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basic text.\n")
+
+    def test_get_text_html(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/html
+
+            <p>Basic text.</p>
+            """))
+        self.assertEqual(raw_data_manager.get_content(m),
+                         "<p>Basic text.</p>\n")
+
+    def test_get_text_plain_latin1(self):
+        m = self._bytes_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset=latin1
+
+            Basìc tëxt.
+            """).encode('latin1'))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_latin1_quoted_printable(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="latin-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=ECc t=EBxt.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_utf8_base64(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: base64
+
+            QmFzw6xjIHTDq3h0Lgo=
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt.\n")
+
+    def test_get_text_plain_bad_utf8_quoted_printable(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=c3=acc t=c3=abxt=fd.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m), "Basìc tëxt�.\n")
+
+    def test_get_text_plain_bad_utf8_quoted_printable_ignore_errors(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Bas=c3=acc t=c3=abxt=fd.
+            """))
+        self.assertEqual(raw_data_manager.get_content(m, errors='ignore'),
+                         "Basìc tëxt.\n")
+
+    def test_get_text_plain_utf8_base64_recoverable_bad_CTE_data(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf8"
+            Content-Transfer-Encoding: base64
+
+            QmFzw6xjIHTDq3h0Lgo\xFF=
+            """))
+        self.assertEqual(raw_data_manager.get_content(m, errors='ignore'),
+                         "Basìc tëxt.\n")
+
+    def test_get_text_invalid_keyword(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: text/plain
+
+            Basic text.
+            """))
+        with self.assertRaises(TypeError):
+            raw_data_manager.get_content(m, foo='ignore')
+
+    def test_get_non_text(self):
+        template = textwrap.dedent("""\
+            Content-Type: {}
+            Content-Transfer-Encoding: base64
+
+            Ym9ndXMgZGF0YQ==
+            """)
+        for maintype in 'audio image video application'.split():
+            with self.subTest(maintype=maintype):
+                m = self._str_msg(template.format(maintype+'/foo'))
+                self.assertEqual(raw_data_manager.get_content(m), b"bogus data")
+
+    def test_get_non_text_invalid_keyword(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: image/jpg
+            Content-Transfer-Encoding: base64
+
+            Ym9ndXMgZGF0YQ==
+            """))
+        with self.assertRaises(TypeError):
+            raw_data_manager.get_content(m, errors='ignore')
+
+    def test_get_raises_on_multipart(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: multipart/mixed; boundary="==="
+
+            --===
+            --===--
+            """))
+        with self.assertRaises(KeyError):
+            raw_data_manager.get_content(m)
+
+    def test_get_message_rfc822_and_external_body(self):
+        template = textwrap.dedent("""\
+            Content-Type: message/{}
+
+            To: foo@example.com
+            From: bar@example.com
+            Subject: example
+
+            an example message
+            """)
+        for subtype in 'rfc822 external-body'.split():
+            with self.subTest(subtype=subtype):
+                m = self._str_msg(template.format(subtype))
+                sub_msg = raw_data_manager.get_content(m)
+                self.assertIsInstance(sub_msg, self.message)
+                self.assertEqual(raw_data_manager.get_content(sub_msg),
+                                 "an example message\n")
+                self.assertEqual(sub_msg['to'], 'foo@example.com')
+                self.assertEqual(sub_msg['from'].addresses[0].username, 'bar')
+
+    def test_get_message_non_rfc822_or_external_body_yields_bytes(self):
+        m = self._str_msg(textwrap.dedent("""\
+            Content-Type: message/partial
+
+            To: foo@example.com
+            From: bar@example.com
+            Subject: example
+
+            The real body is in another message.
+            """))
+        self.assertStartsWith(raw_data_manager.get_content(m), b'To: foo@ex')
+
+    def test_set_text_plain(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_plain_null(self):
+        m = self._make_message()
+        content = ''
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), '\n')
+        self.assertEqual(m.get_content(), '\n')
+
+    def test_set_text_html(self):
+        m = self._make_message()
+        content = "<p>Simple message.</p>\n"
+        raw_data_manager.set_content(m, content, subtype='html')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/html; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+
+            <p>Simple message.</p>
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_charset_latin_1(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content, charset='latin-1')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_plain_long_line_heuristics(self):
+        m = self._make_message()
+        content = ("Simple but long message that is over 78 characters"
+                   " long to force transfer encoding.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+
+            Simple but long message that is over 78 characters long to =
+            force transfer encoding.
+            """))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_short_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = "et là il est monté sur moi et il commence à m'éto.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            et là il est monté sur moi et il commence à m'éto.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_long_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = ("j'ai un problème de python. il est sorti de son"
+                   " vivarium.  et là il est monté sur moi et il commence"
+                   " à m'éto.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+
+            j'ai un probl=C3=A8me de python. il est sorti de son vivari=
+            um.  et l=C3=A0 il est mont=C3=A9 sur moi et il commence =
+            =C3=A0 m'=C3=A9to.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_long_line_minimal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = '\n'*10 + (
+                  "j'ai un problème de python. il est sorti de son"
+                  " vivarium.  et là il est monté sur moi et il commence"
+                  " à m'éto.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+            """ + '\n'*10 + """
+            j'ai un probl=C3=A8me de python. il est sorti de son vivari=
+            um.  et l=C3=A0 il est mont=C3=A9 sur moi et il commence =
+            =C3=A0 m'=C3=A9to.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = "áàäéèęöő.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            áàäéèęöő.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = '\n'*10 + "áàäéèęöő.\n"
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            """ + '\n'*10 + """
+            áàäéèęöő.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_long_line_maximal_non_ascii_heuristics(self):
+        m = self._make_message()
+        content = ("áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            w6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TDqcOoxJnD
+            tsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TDqcOo
+            xJnDtsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOgw6TD
+            qcOoxJnDtsWRw6HDoMOkw6nDqMSZw7bFkcOhw6DDpMOpw6jEmcO2xZHDocOg
+            w6TDqcOoxJnDtsWRLgo=
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_11_lines_long_line_maximal_non_ascii_heuristics(self):
+        # Yes, it chooses "wrong" here.  It's a heuristic.  So this result
+        # could change if we come up with a better heuristic.
+        m = self._make_message()
+        content = ('\n'*10 +
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                   "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        raw_data_manager.set_content(m, "\n"*10 +
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő"
+                                        "áàäéèęöőáàäéèęöőáàäéèęöőáàäéèęöő.\n")
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: quoted-printable
+            """ + '\n'*10 + """
+            =C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=
+            =A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=
+            =C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=
+            =A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=
+            =C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=
+            =91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=
+            =C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=
+            =A4=C3=A9=C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=
+            =C3=A8=C4=99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=
+            =99=C3=B6=C5=91=C3=A1=C3=A0=C3=A4=C3=A9=C3=A8=C4=99=C3=B6=
+            =C5=91.
+            """).encode('utf-8'))
+        self.assertEqual(m.get_payload(decode=True).decode('utf-8'), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_text_non_ascii_with_cte_7bit_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", cte='7bit')
+
+    def test_set_text_non_ascii_with_charset_ascii_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", charset='ascii')
+
+    def test_set_text_non_ascii_with_cte_7bit_and_charset_ascii_raises(self):
+        m = self._make_message()
+        with self.assertRaises(UnicodeError):
+            raw_data_manager.set_content(m,"áàäéèęöő.\n", cte='7bit', charset='ascii')
+
+    def test_set_message(self):
+        m = self._make_message()
+        m['Subject'] = "Forwarded message"
+        content = self._make_message()
+        content['To'] = 'python@vivarium.org'
+        content['From'] = 'police@monty.org'
+        content['Subject'] = "get back in your box"
+        content.set_content("Or face the comfy chair.")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Subject: Forwarded message
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: python@vivarium.org
+            From: police@monty.org
+            Subject: get back in your box
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            Or face the comfy chair.
+            """))
+        payload = m.get_payload(0)
+        self.assertIsInstance(payload, self.message)
+        self.assertEqual(str(payload), str(content))
+        self.assertIsInstance(m.get_content(), self.message)
+        self.assertEqual(str(m.get_content()), str(content))
+
+    def test_set_message_with_non_ascii_and_coercion_to_7bit(self):
+        m = self._make_message()
+        m['Subject'] = "Escape report"
+        content = self._make_message()
+        content['To'] = 'police@monty.org'
+        content['From'] = 'victim@monty.org'
+        content['Subject'] = "Help"
+        content.set_content("j'ai un problème de python. il est sorti de son"
+                            " vivarium.")
+        raw_data_manager.set_content(m, content)
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Subject: Escape report
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: police@monty.org
+            From: victim@monty.org
+            Subject: Help
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            j'ai un problème de python. il est sorti de son vivarium.
+            """).encode('utf-8'))
+        # The choice of base64 for the body encoding is because generator
+        # doesn't bother with heuristics and uses it unconditionally for utf-8
+        # text.
+        # XXX: the first cte should be 7bit, too...that's a generator bug.
+        # XXX: the line length in the body also looks like a generator bug.
+        self.assertEqual(m.as_string(maxheaderlen=self.policy.max_line_length),
+                         textwrap.dedent("""\
+            Subject: Escape report
+            Content-Type: message/rfc822
+            Content-Transfer-Encoding: 8bit
+
+            To: police@monty.org
+            From: victim@monty.org
+            Subject: Help
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+            MIME-Version: 1.0
+
+            aidhaSB1biBwcm9ibMOobWUgZGUgcHl0aG9uLiBpbCBlc3Qgc29ydGkgZGUgc29uIHZpdmFyaXVt
+            Lgo=
+            """))
+        self.assertIsInstance(m.get_content(), self.message)
+        self.assertEqual(str(m.get_content()), str(content))
+
+    def test_set_message_invalid_cte_raises(self):
+        m = self._make_message()
+        content = self._make_message()
+        for cte in 'quoted-printable base64'.split():
+            for subtype in 'rfc822 external-body'.split():
+                with self.subTest(cte=cte, subtype=subtype):
+                    with self.assertRaises(ValueError) as ar:
+                        m.set_content(content, subtype, cte=cte)
+                    exc = str(ar.exception)
+                    self.assertIn(cte, exc)
+                    self.assertIn(subtype, exc)
+        subtype = 'external-body'
+        for cte in '8bit binary'.split():
+            with self.subTest(cte=cte, subtype=subtype):
+                with self.assertRaises(ValueError) as ar:
+                    m.set_content(content, subtype, cte=cte)
+                exc = str(ar.exception)
+                self.assertIn(cte, exc)
+                self.assertIn(subtype, exc)
+
+    def test_set_image_jpg(self):
+        for content in (b"bogus content",
+                        bytearray(b"bogus content"),
+                        memoryview(b"bogus content")):
+            with self.subTest(content=content):
+                m = self._make_message()
+                raw_data_manager.set_content(m, content, 'image', 'jpeg')
+                self.assertEqual(str(m), textwrap.dedent("""\
+                    Content-Type: image/jpeg
+                    Content-Transfer-Encoding: base64
+
+                    Ym9ndXMgY29udGVudA==
+                    """))
+                self.assertEqual(m.get_payload(decode=True), content)
+                self.assertEqual(m.get_content(), content)
+
+    def test_set_audio_aif_with_quoted_printable_cte(self):
+        # Why you would use qp, I don't know, but it is technically supported.
+        # XXX: the incorrect line length is because binascii.b2a_qp doesn't
+        # support a line length parameter, but we must use it to get newline
+        # encoding.
+        # XXX: what about that lack of tailing newline?  Do we actually handle
+        # that correctly in all cases?  That is, if the *source* has an
+        # unencoded newline, do we add an extra newline to the returned payload
+        # or not?  And can that actually be disambiguated based on the RFC?
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent ' + b'z'*100
+        m.set_content(content, 'audio', 'aif', cte='quoted-printable')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: audio/aif
+            Content-Transfer-Encoding: quoted-printable
+            MIME-Version: 1.0
+
+            b=FFgus=09con=0At=0Dent=20zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=
+            zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz""").encode('latin-1'))
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_video_mpeg_with_binary_cte(self):
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent ' + b'z'*100
+        m.set_content(content, 'video', 'mpeg', cte='binary')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: video/mpeg
+            Content-Transfer-Encoding: binary
+            MIME-Version: 1.0
+
+            """).encode('ascii') +
+            # XXX: the second \n ought to be a \r, but generator gets it wrong.
+            # THIS MEANS WE DON'T ACTUALLY SUPPORT THE 'binary' CTE.
+            b'b\xFFgus\tcon\nt\nent zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz' +
+            b'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz')
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_application_octet_stream_with_8bit_cte(self):
+        # In 8bit mode, universal line end logic applies.  It is up to the
+        # application to make sure the lines are short enough; we don't check.
+        m = self._make_message()
+        content = b'b\xFFgus\tcon\nt\rent\n' + b'z'*60 + b'\n'
+        m.set_content(content, 'application', 'octet-stream', cte='8bit')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: application/octet-stream
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            """).encode('ascii') +
+            b'b\xFFgus\tcon\nt\nent\n' +
+            b'zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\n')
+        self.assertEqual(m.get_payload(decode=True), content)
+        self.assertEqual(m.get_content(), content)
+
+    def test_set_headers_from_header_objects(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        raw_data_manager.set_content(m, content, headers=(
+            header_factory("To", "foo@example.com"),
+            header_factory("From", "foo@example.com"),
+            header_factory("Subject", "I'm talking to myself.")))
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            To: foo@example.com
+            From: foo@example.com
+            Subject: I'm talking to myself.
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+
+    def test_set_headers_from_strings(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        raw_data_manager.set_content(m, content, headers=(
+            "X-Foo-Header: foo",
+            "X-Bar-Header: bar",))
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            X-Foo-Header: foo
+            X-Bar-Header: bar
+            Content-Transfer-Encoding: 7bit
+
+            Simple message.
+            """))
+
+    def test_set_headers_with_invalid_duplicate_string_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        with self.assertRaisesRegex(ValueError, 'Content-Type'):
+            raw_data_manager.set_content(m, content, headers=(
+                "Content-Type: foo/bar",)
+                )
+
+    def test_set_headers_with_invalid_duplicate_header_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        with self.assertRaisesRegex(ValueError, 'Content-Type'):
+            raw_data_manager.set_content(m, content, headers=(
+                header_factory("Content-Type", " foo/bar"),)
+                )
+
+    def test_set_headers_with_defective_string_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        with self.assertRaisesRegex(ValueError, 'a@fairly@@invalid@address'):
+            raw_data_manager.set_content(m, content, headers=(
+                'To: a@fairly@@invalid@address',)
+                )
+            print(m['To'].defects)
+
+    def test_set_headers_with_defective_header_header_raises(self):
+        m = self._make_message()
+        content = "Simple message.\n"
+        header_factory = self.policy.header_factory
+        with self.assertRaisesRegex(ValueError, 'a@fairly@@invalid@address'):
+            raw_data_manager.set_content(m, content, headers=(
+                header_factory('To', 'a@fairly@@invalid@address'),)
+                )
+            print(m['To'].defects)
+
+    def test_set_disposition_inline(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='inline')
+        self.assertEqual(m['Content-Disposition'], 'inline')
+
+    def test_set_disposition_attachment(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='attachment')
+        self.assertEqual(m['Content-Disposition'], 'attachment')
+
+    def test_set_disposition_foo(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='foo')
+        self.assertEqual(m['Content-Disposition'], 'foo')
+
+    # XXX: we should have a 'strict' policy mode (beyond raise_on_defect) that
+    # would cause 'foo' above to raise.
+
+    def test_set_filename(self):
+        m = self._make_message()
+        m.set_content('foo', filename='bar.txt')
+        self.assertEqual(m['Content-Disposition'],
+                         'attachment; filename="bar.txt"')
+
+    def test_set_filename_and_disposition_inline(self):
+        m = self._make_message()
+        m.set_content('foo', disposition='inline', filename='bar.txt')
+        self.assertEqual(m['Content-Disposition'], 'inline; filename="bar.txt"')
+
+    def test_set_non_ascii_filename(self):
+        m = self._make_message()
+        m.set_content('foo', filename='ábárî.txt')
+        self.assertEqual(bytes(m), textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            Content-Disposition: attachment;
+             filename*=utf-8''%C3%A1b%C3%A1r%C3%AE.txt
+            MIME-Version: 1.0
+
+            foo
+            """).encode('ascii'))
+
+    def test_set_content_bytes_cte_7bit(self):
+        m = self._make_message()
+        m.set_content(b'ASCII-only message.\n',
+            maintype='application', subtype='octet-stream', cte='7bit')
+        self.assertEqual(str(m), textwrap.dedent("""\
+            Content-Type: application/octet-stream
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            ASCII-only message.
+            """))
+
+    content_object_params = {
+        'text_plain': ('content', ()),
+        'text_html': ('content', ('html',)),
+        'application_octet_stream': (b'content',
+                                     ('application', 'octet_stream')),
+        'image_jpeg': (b'content', ('image', 'jpeg')),
+        'message_rfc822': (message(), ()),
+        'message_external_body': (message(), ('external-body',)),
+        }
+
+    def content_object_as_header_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, headers=(
+            'To: foo@example.com',
+            'From: bar@simple.net'))
+        self.assertEqual(m['to'], 'foo@example.com')
+        self.assertEqual(m['from'], 'bar@simple.net')
+
+    def content_object_as_disposition_inline_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, disposition='inline')
+        self.assertEqual(m['Content-Disposition'], 'inline')
+
+    def content_object_as_non_ascii_filename_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, disposition='inline', filename='bár.txt')
+        self.assertEqual(m['Content-Disposition'], 'inline; filename="bár.txt"')
+        self.assertEqual(m.get_filename(), "bár.txt")
+        self.assertEqual(m['Content-Disposition'].params['filename'], "bár.txt")
+
+    def content_object_as_cid_receiver(self, obj, mimetype):
+        m = self._make_message()
+        m.set_content(obj, *mimetype, cid='some_random_stuff')
+        self.assertEqual(m['Content-ID'], 'some_random_stuff')
+
+    def content_object_as_params_receiver(self, obj, mimetype):
+        m = self._make_message()
+        params = {'foo': 'bár', 'abc': 'xyz'}
+        m.set_content(obj, *mimetype, params=params)
+        if isinstance(obj, str):
+            params['charset'] = 'utf-8'
+        self.assertEqual(m['Content-Type'].params, params)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_defect_handling.py b/Lib/test/test_email/test_defect_handling.py
new file mode 100644
index 0000000000..44e76c8ce5
--- /dev/null
+++ b/Lib/test/test_email/test_defect_handling.py
@@ -0,0 +1,337 @@
+import textwrap
+import unittest
+import contextlib
+from email import policy
+from email import errors
+from test.test_email import TestEmailBase
+
+
+class TestDefectsBase:
+
+    policy = policy.default
+    raise_expected = False
+
+    @contextlib.contextmanager
+    def _raise_point(self, defect):
+        yield
+
+    def test_same_boundary_inner_outer(self):
+        source = textwrap.dedent("""\
+            Subject: XX
+            From: xx@xx.dk
+            To: XX
+            Mime-version: 1.0
+            Content-type: multipart/mixed;
+               boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: multipart/alternative;
+               boundary="MS_Mac_OE_3071477847_720252_MIME_Part"
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: text/plain; charset="ISO-8859-1"
+            Content-transfer-encoding: quoted-printable
+
+            text
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: text/html; charset="ISO-8859-1"
+            Content-transfer-encoding: quoted-printable
+
+            <HTML></HTML>
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part--
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part
+            Content-type: image/gif; name="xx.gif";
+            Content-disposition: attachment
+            Content-transfer-encoding: base64
+
+            Some removed base64 encoded chars.
+
+            --MS_Mac_OE_3071477847_720252_MIME_Part--
+
+            """)
+        # XXX better would be to actually detect the duplicate.
+        with self._raise_point(errors.StartBoundaryNotFoundDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        inner = msg.get_payload(0)
+        self.assertHasAttr(inner, 'defects')
+        self.assertEqual(len(self.get_defects(inner)), 1)
+        self.assertIsInstance(self.get_defects(inner)[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    def test_multipart_no_boundary(self):
+        source = textwrap.dedent("""\
+            Date: Fri, 6 Apr 2001 09:23:06 -0800 (GMT-0800)
+            From: foobar
+            Subject: broken mail
+            MIME-Version: 1.0
+            Content-Type: multipart/report; report-type=delivery-status;
+
+            --JAB03225.986577786/zinfandel.lacita.com
+
+            One part
+
+            --JAB03225.986577786/zinfandel.lacita.com
+            Content-Type: message/delivery-status
+
+            Header: Another part
+
+            --JAB03225.986577786/zinfandel.lacita.com--
+            """)
+        with self._raise_point(errors.NoBoundaryInMultipartDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertEqual(len(self.get_defects(msg)), 2)
+        self.assertIsInstance(self.get_defects(msg)[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(self.get_defects(msg)[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    multipart_msg = textwrap.dedent("""\
+        Date: Wed, 14 Nov 2007 12:56:23 GMT
+        From: foo@bar.invalid
+        To: foo@bar.invalid
+        Subject: Content-Transfer-Encoding: base64 and multipart
+        MIME-Version: 1.0
+        Content-Type: multipart/mixed;
+            boundary="===============3344438784458119861=="{}
+
+        --===============3344438784458119861==
+        Content-Type: text/plain
+
+        Test message
+
+        --===============3344438784458119861==
+        Content-Type: application/octet-stream
+        Content-Transfer-Encoding: base64
+
+        YWJj
+
+        --===============3344438784458119861==--
+        """)
+
+    def test_multipart_invalid_cte(self):
+        with self._raise_point(
+                errors.InvalidMultipartContentTransferEncodingDefect):
+            msg = self._str_msg(
+                    self.multipart_msg.format(
+                        "\nContent-Transfer-Encoding: base64"))
+        if self.raise_expected: return
+        self.assertEqual(len(self.get_defects(msg)), 1)
+        self.assertIsInstance(self.get_defects(msg)[0],
+            errors.InvalidMultipartContentTransferEncodingDefect)
+
+    def test_multipart_no_cte_no_defect(self):
+        if self.raise_expected: return
+        msg = self._str_msg(self.multipart_msg.format(''))
+        self.assertEqual(len(self.get_defects(msg)), 0)
+
+    def test_multipart_valid_cte_no_defect(self):
+        if self.raise_expected: return
+        for cte in ('7bit', '8bit', 'BINary'):
+            msg = self._str_msg(
+                self.multipart_msg.format("\nContent-Transfer-Encoding: "+cte))
+            self.assertEqual(len(self.get_defects(msg)), 0, "cte="+cte)
+
+    def test_lying_multipart(self):
+        source = textwrap.dedent("""\
+            From: "Allison Dunlap" <xxx@example.com>
+            To: yyy@example.com
+            Subject: 64423
+            Date: Sun, 11 Jul 2004 16:09:27 -0300
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+
+            Blah blah blah
+            """)
+        with self._raise_point(errors.NoBoundaryInMultipartDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertHasAttr(msg, 'defects')
+        self.assertEqual(len(self.get_defects(msg)), 2)
+        self.assertIsInstance(self.get_defects(msg)[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(self.get_defects(msg)[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    def test_missing_start_boundary(self):
+        source = textwrap.dedent("""\
+            Content-Type: multipart/mixed; boundary="AAA"
+            From: Mail Delivery Subsystem <xxx@example.com>
+            To: yyy@example.com
+
+            --AAA
+
+            Stuff
+
+            --AAA
+            Content-Type: message/rfc822
+
+            From: webmaster@python.org
+            To: zzz@example.com
+            Content-Type: multipart/mixed; boundary="BBB"
+
+            --BBB--
+
+            --AAA--
+
+            """)
+        # The message structure is:
+        #
+        # multipart/mixed
+        #    text/plain
+        #    message/rfc822
+        #        multipart/mixed [*]
+        #
+        # [*] This message is missing its start boundary
+        with self._raise_point(errors.StartBoundaryNotFoundDefect):
+            outer = self._str_msg(source)
+        if self.raise_expected: return
+        bad = outer.get_payload(1).get_payload(0)
+        self.assertEqual(len(self.get_defects(bad)), 1)
+        self.assertIsInstance(self.get_defects(bad)[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    def test_first_line_is_continuation_header(self):
+        with self._raise_point(errors.FirstHeaderLineIsContinuationDefect):
+            msg = self._str_msg(' Line 1\nSubject: test\n\nbody')
+        if self.raise_expected: return
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'body')
+        self.assertEqual(len(self.get_defects(msg)), 1)
+        self.assertDefectsEqual(self.get_defects(msg),
+                                 [errors.FirstHeaderLineIsContinuationDefect])
+        self.assertEqual(self.get_defects(msg)[0].line, ' Line 1\n')
+
+    def test_missing_header_body_separator(self):
+        # Our heuristic if we see a line that doesn't look like a header (no
+        # leading whitespace but no ':') is to assume that the blank line that
+        # separates the header from the body is missing, and to stop parsing
+        # headers and start parsing the body.
+        with self._raise_point(errors.MissingHeaderBodySeparatorDefect):
+            msg = self._str_msg('Subject: test\nnot a header\nTo: abc\n\nb\n')
+        if self.raise_expected: return
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'not a header\nTo: abc\n\nb\n')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.MissingHeaderBodySeparatorDefect])
+
+    def test_bad_padding_in_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            dmk
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64PaddingDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'vi')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64PaddingDefect])
+
+    def test_invalid_chars_in_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            dm\x01k===
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64CharactersDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'vi')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64CharactersDefect])
+
+    def test_invalid_length_of_base64_payload(self):
+        source = textwrap.dedent("""\
+            Subject: test
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: base64
+
+            abcde
+            """)
+        msg = self._str_msg(source)
+        with self._raise_point(errors.InvalidBase64LengthDefect):
+            payload = msg.get_payload(decode=True)
+        if self.raise_expected: return
+        self.assertEqual(payload, b'abcde')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.InvalidBase64LengthDefect])
+
+    def test_missing_ending_boundary(self):
+        source = textwrap.dedent("""\
+            To: 1@harrydomain4.com
+            Subject: Fwd: 1
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+             boundary="------------000101020201080900040301"
+
+            --------------000101020201080900040301
+            Content-Type: text/plain; charset=ISO-8859-1
+            Content-Transfer-Encoding: 7bit
+
+            Alternative 1
+
+            --------------000101020201080900040301
+            Content-Type: text/html; charset=ISO-8859-1
+            Content-Transfer-Encoding: 7bit
+
+            Alternative 2
+
+            """)
+        with self._raise_point(errors.CloseBoundaryNotFoundDefect):
+            msg = self._str_msg(source)
+        if self.raise_expected: return
+        self.assertEqual(len(msg.get_payload()), 2)
+        self.assertEqual(msg.get_payload(1).get_payload(), 'Alternative 2\n')
+        self.assertDefectsEqual(self.get_defects(msg),
+                                [errors.CloseBoundaryNotFoundDefect])
+
+
+class TestDefectDetection(TestDefectsBase, TestEmailBase):
+
+    def get_defects(self, obj):
+        return obj.defects
+
+
+class TestDefectCapture(TestDefectsBase, TestEmailBase):
+
+    class CapturePolicy(policy.EmailPolicy):
+        captured = None
+        def register_defect(self, obj, defect):
+            self.captured.append(defect)
+
+    def setUp(self):
+        self.policy = self.CapturePolicy(captured=list())
+
+    def get_defects(self, obj):
+        return self.policy.captured
+
+
+class TestDefectRaising(TestDefectsBase, TestEmailBase):
+
+    policy = TestDefectsBase.policy
+    policy = policy.clone(raise_on_defect=True)
+    raise_expected = True
+
+    @contextlib.contextmanager
+    def _raise_point(self, defect):
+        with self.assertRaises(defect):
+            yield
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_email.py b/Lib/test/test_email/test_email.py
new file mode 100644
index 0000000000..2d843c7d72
--- /dev/null
+++ b/Lib/test/test_email/test_email.py
@@ -0,0 +1,5907 @@
+# Copyright (C) 2001-2010 Python Software Foundation
+# Contact: email-sig@python.org
+# email package unit tests
+
+import re
+import time
+import base64
+import unittest
+import textwrap
+
+from io import StringIO, BytesIO
+from itertools import chain
+from random import choice
+from threading import Thread
+from unittest.mock import patch
+
+import email
+import email.policy
+import email.utils
+
+from email.charset import Charset
+from email.generator import Generator, DecodedGenerator, BytesGenerator
+from email.header import Header, decode_header, make_header
+from email.headerregistry import HeaderRegistry
+from email.message import Message
+from email.mime.application import MIMEApplication
+from email.mime.audio import MIMEAudio
+from email.mime.base import MIMEBase
+from email.mime.image import MIMEImage
+from email.mime.message import MIMEMessage
+from email.mime.multipart import MIMEMultipart
+from email.mime.nonmultipart import MIMENonMultipart
+from email.mime.text import MIMEText
+from email.parser import Parser, HeaderParser
+from email import base64mime
+from email import encoders
+from email import errors
+from email import iterators
+from email import quoprimime
+from email import utils
+
+from test import support
+from test.support import threading_helper
+from test.support.os_helper import unlink
+from test.test_email import openfile, TestEmailBase
+
+# These imports are documented to work, but we are testing them using a
+# different path, so we import them here just to make sure they are importable.
+from email.parser import FeedParser
+
+NL = '\n'
+EMPTYSTRING = ''
+SPACE = ' '
+
+
+# Test various aspects of the Message class's API
+class TestMessageAPI(TestEmailBase):
+    def test_get_all(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_20.txt')
+        eq(msg.get_all('cc'), ['ccc@zzz.org', 'ddd@zzz.org', 'eee@zzz.org'])
+        eq(msg.get_all('xx', 'n/a'), 'n/a')
+
+    def test_getset_charset(self):
+        eq = self.assertEqual
+        msg = Message()
+        eq(msg.get_charset(), None)
+        charset = Charset('iso-8859-1')
+        msg.set_charset(charset)
+        eq(msg['mime-version'], '1.0')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg['content-type'], 'text/plain; charset="iso-8859-1"')
+        eq(msg.get_param('charset'), 'iso-8859-1')
+        eq(msg['content-transfer-encoding'], 'quoted-printable')
+        eq(msg.get_charset().input_charset, 'iso-8859-1')
+        # Remove the charset
+        msg.set_charset(None)
+        eq(msg.get_charset(), None)
+        eq(msg['content-type'], 'text/plain')
+        # Try adding a charset when there's already MIME headers present
+        msg = Message()
+        msg['MIME-Version'] = '2.0'
+        msg['Content-Type'] = 'text/x-weird'
+        msg['Content-Transfer-Encoding'] = 'quinted-puntable'
+        msg.set_charset(charset)
+        eq(msg['mime-version'], '2.0')
+        eq(msg['content-type'], 'text/x-weird; charset="iso-8859-1"')
+        eq(msg['content-transfer-encoding'], 'quinted-puntable')
+
+    def test_set_charset_from_string(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_charset('us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+
+    def test_set_payload_with_charset(self):
+        msg = Message()
+        charset = Charset('iso-8859-1')
+        msg.set_payload('This is a string payload', charset)
+        self.assertEqual(msg.get_charset().input_charset, 'iso-8859-1')
+
+    def test_set_payload_with_8bit_data_and_charset(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        msg = Message()
+        msg.set_payload(data, charset)
+        self.assertEqual(msg['content-transfer-encoding'], 'base64')
+        self.assertEqual(msg.get_payload(decode=True), data)
+        self.assertEqual(msg.get_payload(), '0JDQkdCS\n')
+
+    def test_set_payload_with_non_ascii_and_charset_body_encoding_none(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        charset.body_encoding = None # Disable base64 encoding
+        msg = Message()
+        msg.set_payload(data.decode('utf-8'), charset)
+        self.assertEqual(msg['content-transfer-encoding'], '8bit')
+        self.assertEqual(msg.get_payload(decode=True), data)
+
+    def test_set_payload_with_8bit_data_and_charset_body_encoding_none(self):
+        data = b'\xd0\x90\xd0\x91\xd0\x92'
+        charset = Charset('utf-8')
+        charset.body_encoding = None # Disable base64 encoding
+        msg = Message()
+        msg.set_payload(data, charset)
+        self.assertEqual(msg['content-transfer-encoding'], '8bit')
+        self.assertEqual(msg.get_payload(decode=True), data)
+
+    def test_set_payload_to_list(self):
+        msg = Message()
+        msg.set_payload([])
+        self.assertEqual(msg.get_payload(), [])
+
+    def test_attach_when_payload_is_string(self):
+        msg = Message()
+        msg['Content-Type'] = 'multipart/mixed'
+        msg.set_payload('string payload')
+        sub_msg = MIMEMessage(Message())
+        self.assertRaisesRegex(TypeError, "[Aa]ttach.*non-multipart",
+                               msg.attach, sub_msg)
+
+    def test_get_charsets(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_08.txt')
+        charsets = msg.get_charsets()
+        eq(charsets, [None, 'us-ascii', 'iso-8859-1', 'iso-8859-2', 'koi8-r'])
+
+        msg = self._msgobj('msg_09.txt')
+        charsets = msg.get_charsets('dingbat')
+        eq(charsets, ['dingbat', 'us-ascii', 'iso-8859-1', 'dingbat',
+                      'koi8-r'])
+
+        msg = self._msgobj('msg_12.txt')
+        charsets = msg.get_charsets()
+        eq(charsets, [None, 'us-ascii', 'iso-8859-1', None, 'iso-8859-2',
+                      'iso-8859-3', 'us-ascii', 'koi8-r'])
+
+    def test_get_filename(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_04.txt')
+        filenames = [p.get_filename() for p in msg.get_payload()]
+        eq(filenames, ['msg.txt', 'msg.txt'])
+
+        msg = self._msgobj('msg_07.txt')
+        subpart = msg.get_payload(1)
+        eq(subpart.get_filename(), 'dingusfish.gif')
+
+    def test_get_filename_with_name_parameter(self):
+        eq = self.assertEqual
+
+        msg = self._msgobj('msg_44.txt')
+        filenames = [p.get_filename() for p in msg.get_payload()]
+        eq(filenames, ['msg.txt', 'msg.txt'])
+
+    def test_get_boundary(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_07.txt')
+        # No quotes!
+        eq(msg.get_boundary(), 'BOUNDARY')
+
+    def test_set_boundary(self):
+        eq = self.assertEqual
+        # This one has no existing boundary parameter, but the Content-Type:
+        # header appears fifth.
+        msg = self._msgobj('msg_01.txt')
+        msg.set_boundary('BOUNDARY')
+        header, value = msg.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'text/plain; charset="us-ascii"; boundary="BOUNDARY"')
+        # This one has a Content-Type: header, with a boundary, stuck in the
+        # middle of its headers.  Make sure the order is preserved; it should
+        # be fifth.
+        msg = self._msgobj('msg_04.txt')
+        msg.set_boundary('BOUNDARY')
+        header, value = msg.items()[4]
+        eq(header.lower(), 'content-type')
+        eq(value, 'multipart/mixed; boundary="BOUNDARY"')
+        # And this one has no Content-Type: header at all.
+        msg = self._msgobj('msg_03.txt')
+        self.assertRaises(errors.HeaderParseError,
+                          msg.set_boundary, 'BOUNDARY')
+
+    def test_make_boundary(self):
+        msg = MIMEMultipart('form-data')
+        # Note that when the boundary gets created is an implementation
+        # detail and might change.
+        self.assertEqual(msg.items()[0][1], 'multipart/form-data')
+        # Trigger creation of boundary
+        msg.as_string()
+        self.assertStartsWith(msg.items()[0][1],
+                              'multipart/form-data; boundary="==')
+        # XXX: there ought to be tests of the uniqueness of the boundary, too.
+
+    def test_message_rfc822_only(self):
+        # Issue 7970: message/rfc822 not in multipart parsed by
+        # HeaderParser caused an exception when flattened.
+        with openfile('msg_46.txt', encoding="utf-8") as fp:
+            msgdata = fp.read()
+        parser = HeaderParser()
+        msg = parser.parsestr(msgdata)
+        out = StringIO()
+        gen = Generator(out, True, 0)
+        gen.flatten(msg, False)
+        self.assertEqual(out.getvalue(), msgdata)
+
+    def test_byte_message_rfc822_only(self):
+        # Make sure new bytes header parser also passes this.
+        with openfile('msg_46.txt', encoding="utf-8") as fp:
+            msgdata = fp.read().encode('ascii')
+        parser = email.parser.BytesHeaderParser()
+        msg = parser.parsebytes(msgdata)
+        out = BytesIO()
+        gen = email.generator.BytesGenerator(out)
+        gen.flatten(msg)
+        self.assertEqual(out.getvalue(), msgdata)
+
+    def test_get_decoded_payload(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_10.txt')
+        # The outer message is a multipart
+        eq(msg.get_payload(decode=True), None)
+        # Subpart 1 is 7bit encoded
+        eq(msg.get_payload(0).get_payload(decode=True),
+           b'This is a 7bit encoded message.\n')
+        # Subpart 2 is quopri
+        eq(msg.get_payload(1).get_payload(decode=True),
+           b'\xa1This is a Quoted Printable encoded message!\n')
+        # Subpart 3 is base64
+        eq(msg.get_payload(2).get_payload(decode=True),
+           b'This is a Base64 encoded message.')
+        # Subpart 4 is base64 with a trailing newline, which
+        # used to be stripped (issue 7143).
+        eq(msg.get_payload(3).get_payload(decode=True),
+           b'This is a Base64 encoded message.\n')
+        # Subpart 5 has no Content-Transfer-Encoding: header.
+        eq(msg.get_payload(4).get_payload(decode=True),
+           b'This has no Content-Transfer-Encoding: header.\n')
+
+    def test_get_decoded_uu_payload(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_payload('begin 666 -\n+:&5L;&\\@=V]R;&0 \n \nend\n')
+        for cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
+            msg['content-transfer-encoding'] = cte
+            eq(msg.get_payload(decode=True), b'hello world')
+        # Now try some bogus data
+        msg.set_payload('foo')
+        eq(msg.get_payload(decode=True), b'foo')
+
+    def test_get_payload_n_raises_on_non_multipart(self):
+        msg = Message()
+        self.assertRaises(TypeError, msg.get_payload, 1)
+
+    def test_decoded_generator(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_07.txt')
+        with openfile('msg_17.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        s = StringIO()
+        g = DecodedGenerator(s)
+        g.flatten(msg)
+        eq(s.getvalue(), text)
+
+    def test__contains__(self):
+        msg = Message()
+        msg['From'] = 'Me'
+        msg['to'] = 'You'
+        # Check for case insensitivity
+        self.assertIn('from', msg)
+        self.assertIn('From', msg)
+        self.assertIn('FROM', msg)
+        self.assertIn('to', msg)
+        self.assertIn('To', msg)
+        self.assertIn('TO', msg)
+
+    def test_as_string(self):
+        msg = self._msgobj('msg_01.txt')
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        self.assertEqual(text, str(msg))
+        fullrepr = msg.as_string(unixfrom=True)
+        lines = fullrepr.split('\n')
+        self.assertStartsWith(lines[0], 'From ')
+        self.assertEqual(text, NL.join(lines[1:]))
+
+    def test_as_string_policy(self):
+        msg = self._msgobj('msg_01.txt')
+        newpolicy = msg.policy.clone(linesep='\r\n')
+        fullrepr = msg.as_string(policy=newpolicy)
+        s = StringIO()
+        g = Generator(s, policy=newpolicy)
+        g.flatten(msg)
+        self.assertEqual(fullrepr, s.getvalue())
+
+    def test_nonascii_as_string_without_cte(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="iso-8859-1"
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            F=F6=F6 b=E4r
+            """)
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_nonascii_as_string_with_ascii_charset(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-type: text/plain; charset="us-ascii"
+            Content-Transfer-Encoding: 8bit
+
+            Test if non-ascii messages with no Content-Transfer-Encoding set
+            can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = source.decode('ascii', 'replace')
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_nonascii_as_string_without_content_type_and_cte(self):
+        m = textwrap.dedent("""\
+            MIME-Version: 1.0
+
+            Test if non-ascii messages with no Content-Type nor
+            Content-Transfer-Encoding set can be as_string'd:
+            Föö bär
+            """)
+        source = m.encode('iso-8859-1')
+        expected = source.decode('ascii', 'replace')
+        msg = email.message_from_bytes(source)
+        self.assertEqual(msg.as_string(), expected)
+
+    def test_as_bytes(self):
+        msg = self._msgobj('msg_01.txt')
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            data = fp.read().encode('ascii')
+        self.assertEqual(data, bytes(msg))
+        fullrepr = msg.as_bytes(unixfrom=True)
+        lines = fullrepr.split(b'\n')
+        self.assertStartsWith(lines[0], b'From ')
+        self.assertEqual(data, b'\n'.join(lines[1:]))
+
+    def test_as_bytes_policy(self):
+        msg = self._msgobj('msg_01.txt')
+        newpolicy = msg.policy.clone(linesep='\r\n')
+        fullrepr = msg.as_bytes(policy=newpolicy)
+        s = BytesIO()
+        g = BytesGenerator(s,policy=newpolicy)
+        g.flatten(msg)
+        self.assertEqual(fullrepr, s.getvalue())
+
+    # test_headerregistry.TestContentTypeHeader.bad_params
+    def test_bad_param(self):
+        msg = email.message_from_string("Content-Type: blarg; baz; boo\n")
+        self.assertEqual(msg.get_param('baz'), '')
+
+    def test_continuation_sorting_part_order(self):
+        msg = email.message_from_string(
+            "Content-Disposition: attachment; "
+            "filename*=\"ignored\"; "
+            "filename*0*=\"utf-8''foo%20\"; "
+            "filename*1*=\"bar.txt\"\n"
+        )
+        filename = msg.get_filename()
+        self.assertEqual(filename, 'foo bar.txt')
+
+    def test_sorting_no_continuations(self):
+        msg = email.message_from_string(
+            "Content-Disposition: attachment; "
+            "filename*=\"bar.txt\"; "
+        )
+        filename = msg.get_filename()
+        self.assertEqual(filename, 'bar.txt')
+
+    def test_missing_filename(self):
+        msg = email.message_from_string("From: foo\n")
+        self.assertEqual(msg.get_filename(), None)
+
+    def test_bogus_filename(self):
+        msg = email.message_from_string(
+        "Content-Disposition: blarg; filename\n")
+        self.assertEqual(msg.get_filename(), '')
+
+    def test_missing_boundary(self):
+        msg = email.message_from_string("From: foo\n")
+        self.assertEqual(msg.get_boundary(), None)
+
+    def test_get_params(self):
+        eq = self.assertEqual
+        msg = email.message_from_string(
+            'X-Header: foo=one; bar=two; baz=three\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', 'one'), ('bar', 'two'), ('baz', 'three')])
+        msg = email.message_from_string(
+            'X-Header: foo; bar=one; baz=two\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', ''), ('bar', 'one'), ('baz', 'two')])
+        eq(msg.get_params(), None)
+        msg = email.message_from_string(
+            'X-Header: foo; bar="one"; baz=two\n')
+        eq(msg.get_params(header='x-header'),
+           [('foo', ''), ('bar', 'one'), ('baz', 'two')])
+
+    # test_headerregistry.TestContentTypeHeader.spaces_around_param_equals
+    def test_get_param_liberal(self):
+        msg = Message()
+        msg['Content-Type'] = 'Content-Type: Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"'
+        self.assertEqual(msg.get_param('boundary'), 'CPIMSSMTPC06p5f3tG')
+
+    def test_get_param(self):
+        eq = self.assertEqual
+        msg = email.message_from_string(
+            "X-Header: foo=one; bar=two; baz=three\n")
+        eq(msg.get_param('bar', header='x-header'), 'two')
+        eq(msg.get_param('quuz', header='x-header'), None)
+        eq(msg.get_param('quuz'), None)
+        msg = email.message_from_string(
+            'X-Header: foo; bar="one"; baz=two\n')
+        eq(msg.get_param('foo', header='x-header'), '')
+        eq(msg.get_param('bar', header='x-header'), 'one')
+        eq(msg.get_param('baz', header='x-header'), 'two')
+        # XXX: We are not RFC-2045 compliant!  We cannot parse:
+        # msg["Content-Type"] = 'text/plain; weird="hey; dolly? [you] @ <\\"home\\">?"'
+        # msg.get_param("weird")
+        # yet.
+
+    # test_headerregistry.TestContentTypeHeader.spaces_around_semis
+    def test_get_param_funky_continuation_lines(self):
+        msg = self._msgobj('msg_22.txt')
+        self.assertEqual(msg.get_payload(1).get_param('name'), 'wibble.JPG')
+
+    # test_headerregistry.TestContentTypeHeader.semis_inside_quotes
+    def test_get_param_with_semis_in_quotes(self):
+        msg = email.message_from_string(
+            'Content-Type: image/pjpeg; name="Jim&amp;&amp;Jill"\n')
+        self.assertEqual(msg.get_param('name'), 'Jim&amp;&amp;Jill')
+        self.assertEqual(msg.get_param('name', unquote=False),
+                         '"Jim&amp;&amp;Jill"')
+
+    # test_headerregistry.TestContentTypeHeader.quotes_inside_rfc2231_value
+    def test_get_param_with_quotes(self):
+        msg = email.message_from_string(
+            'Content-Type: foo; bar*0="baz\\"foobar"; bar*1="\\"baz"')
+        self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
+        msg = email.message_from_string(
+            "Content-Type: foo; bar*0=\"baz\\\"foobar\"; bar*1=\"\\\"baz\"")
+        self.assertEqual(msg.get_param('bar'), 'baz"foobar"baz')
+
+    @unittest.skip('TODO: RUSTPYTHON; Takes a long time to the point of timeouting')
+    def test_get_param_linear_complexity(self):
+        # Ensure that email.message._parseparam() is fast.
+        # See https://github.com/python/cpython/issues/136063.
+        N = 100_000
+        for s, r in [
+            ("", ""),
+            ("foo=bar", "foo=bar"),
+            (" FOO = bar    ", "foo=bar"),
+        ]:
+            with self.subTest(s=s, r=r, N=N):
+                src = f'{s};' * (N - 1) + s
+                res = email.message._parseparam(src)
+                self.assertEqual(len(res), N)
+                self.assertEqual(len(set(res)), 1)
+                self.assertEqual(res[0], r)
+
+        # This will be considered as a single parameter.
+        malformed = 's="' + ';' * (N - 1)
+        res = email.message._parseparam(malformed)
+        self.assertEqual(res, [malformed])
+
+    def test_field_containment(self):
+        msg = email.message_from_string('Header: exists')
+        self.assertIn('header', msg)
+        self.assertIn('Header', msg)
+        self.assertIn('HEADER', msg)
+        self.assertNotIn('headerx', msg)
+
+    def test_set_param(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_param('charset', 'iso-2022-jp')
+        eq(msg.get_param('charset'), 'iso-2022-jp')
+        msg.set_param('importance', 'high value')
+        eq(msg.get_param('importance'), 'high value')
+        eq(msg.get_param('importance', unquote=False), '"high value"')
+        eq(msg.get_params(), [('text/plain', ''),
+                              ('charset', 'iso-2022-jp'),
+                              ('importance', 'high value')])
+        eq(msg.get_params(unquote=False), [('text/plain', ''),
+                                       ('charset', '"iso-2022-jp"'),
+                                       ('importance', '"high value"')])
+        msg.set_param('charset', 'iso-9999-xx', header='X-Jimmy')
+        eq(msg.get_param('charset', header='X-Jimmy'), 'iso-9999-xx')
+
+    def test_del_param(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_05.txt')
+        eq(msg.get_params(),
+           [('multipart/report', ''), ('report-type', 'delivery-status'),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])
+        old_val = msg.get_param("report-type")
+        msg.del_param("report-type")
+        eq(msg.get_params(),
+           [('multipart/report', ''),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com')])
+        msg.set_param("report-type", old_val)
+        eq(msg.get_params(),
+           [('multipart/report', ''),
+            ('boundary', 'D1690A7AC1.996856090/mail.example.com'),
+            ('report-type', old_val)])
+
+    def test_del_param_on_other_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment', filename='bud.gif')
+        msg.del_param('filename', 'content-disposition')
+        self.assertEqual(msg['content-disposition'], 'attachment')
+
+    def test_del_param_on_nonexistent_header(self):
+        msg = Message()
+        # Deleting param on empty msg should not raise exception.
+        msg.del_param('filename', 'content-disposition')
+
+    def test_del_nonexistent_param(self):
+        msg = Message()
+        msg.add_header('Content-Type', 'text/plain', charset='utf-8')
+        existing_header = msg['Content-Type']
+        msg.del_param('foobar', header='Content-Type')
+        self.assertEqual(msg['Content-Type'], existing_header)
+
+    def test_set_type(self):
+        eq = self.assertEqual
+        msg = Message()
+        self.assertRaises(ValueError, msg.set_type, 'text')
+        msg.set_type('text/plain')
+        eq(msg['content-type'], 'text/plain')
+        msg.set_param('charset', 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        msg.set_type('text/html')
+        eq(msg['content-type'], 'text/html; charset="us-ascii"')
+
+    def test_set_type_on_other_header(self):
+        msg = Message()
+        msg['X-Content-Type'] = 'text/plain'
+        msg.set_type('application/octet-stream', 'X-Content-Type')
+        self.assertEqual(msg['x-content-type'], 'application/octet-stream')
+
+    def test_get_content_type_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_type_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_type(), 'message/rfc822')
+
+    def test_get_content_type_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_type(),
+                         'message/rfc822')
+
+    def test_get_content_type_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_type(),
+                         'message/rfc822')
+
+    def test_get_content_type_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_type_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_type(), 'text/plain')
+
+    def test_get_content_maintype_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_maintype_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_maintype(), 'message')
+
+    def test_get_content_maintype_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_maintype_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_subtype_missing(self):
+        msg = Message()
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_subtype_missing_with_default_type(self):
+        msg = Message()
+        msg.set_default_type('message/rfc822')
+        self.assertEqual(msg.get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_implicit(self):
+        msg = self._msgobj('msg_30.txt')
+        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_explicit(self):
+        msg = self._msgobj('msg_28.txt')
+        self.assertEqual(msg.get_payload(0).get_content_subtype(), 'rfc822')
+
+    def test_get_content_subtype_from_message_text_plain_implicit(self):
+        msg = self._msgobj('msg_03.txt')
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_subtype_from_message_text_plain_explicit(self):
+        msg = self._msgobj('msg_01.txt')
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_get_content_maintype_error(self):
+        msg = Message()
+        msg['Content-Type'] = 'no-slash-in-this-string'
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_content_subtype_error(self):
+        msg = Message()
+        msg['Content-Type'] = 'no-slash-in-this-string'
+        self.assertEqual(msg.get_content_subtype(), 'plain')
+
+    def test_replace_header(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.add_header('First', 'One')
+        msg.add_header('Second', 'Two')
+        msg.add_header('Third', 'Three')
+        eq(msg.keys(), ['First', 'Second', 'Third'])
+        eq(msg.values(), ['One', 'Two', 'Three'])
+        msg.replace_header('Second', 'Twenty')
+        eq(msg.keys(), ['First', 'Second', 'Third'])
+        eq(msg.values(), ['One', 'Twenty', 'Three'])
+        msg.add_header('First', 'Eleven')
+        msg.replace_header('First', 'One Hundred')
+        eq(msg.keys(), ['First', 'Second', 'Third', 'First'])
+        eq(msg.values(), ['One Hundred', 'Twenty', 'Three', 'Eleven'])
+        self.assertRaises(KeyError, msg.replace_header, 'Fourth', 'Missing')
+
+    def test_get_content_disposition(self):
+        msg = Message()
+        self.assertIsNone(msg.get_content_disposition())
+        msg.add_header('Content-Disposition', 'attachment',
+                       filename='random.avi')
+        self.assertEqual(msg.get_content_disposition(), 'attachment')
+        msg.replace_header('Content-Disposition', 'inline')
+        self.assertEqual(msg.get_content_disposition(), 'inline')
+        msg.replace_header('Content-Disposition', 'InlinE')
+        self.assertEqual(msg.get_content_disposition(), 'inline')
+
+    # test_defect_handling:test_invalid_chars_in_base64_payload
+    def test_broken_base64_payload(self):
+        x = 'AwDp0P7//y6LwKEAcPa/6Q=9'
+        msg = Message()
+        msg['content-type'] = 'audio/x-midi'
+        msg['content-transfer-encoding'] = 'base64'
+        msg.set_payload(x)
+        self.assertEqual(msg.get_payload(decode=True),
+                         (b'\x03\x00\xe9\xd0\xfe\xff\xff.\x8b\xc0'
+                          b'\xa1\x00p\xf6\xbf\xe9\x0f'))
+        self.assertIsInstance(msg.defects[0],
+                              errors.InvalidBase64CharactersDefect)
+
+    def test_broken_unicode_payload(self):
+        # This test improves coverage but is not a compliance test.
+        # The behavior in this situation is currently undefined by the API.
+        x = 'this is a br\xf6ken thing to do'
+        msg = Message()
+        msg['content-type'] = 'text/plain'
+        msg['content-transfer-encoding'] = '8bit'
+        msg.set_payload(x)
+        self.assertEqual(msg.get_payload(decode=True),
+                         bytes(x, 'raw-unicode-escape'))
+
+    def test_questionable_bytes_payload(self):
+        # This test improves coverage but is not a compliance test,
+        # since it involves poking inside the black box.
+        x = 'this is a quéstionable thing to do'.encode('utf-8')
+        msg = Message()
+        msg['content-type'] = 'text/plain; charset="utf-8"'
+        msg['content-transfer-encoding'] = '8bit'
+        msg._payload = x
+        self.assertEqual(msg.get_payload(decode=True), x)
+
+    # Issue 1078919
+    def test_ascii_add_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+                       filename='bud.gif')
+        self.assertEqual('attachment; filename="bud.gif"',
+            msg['Content-Disposition'])
+
+    def test_noascii_add_header(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="Fußballer.ppt")
+        self.assertEqual(
+            'attachment; filename*=utf-8\'\'Fu%C3%9Fballer.ppt',
+            msg['Content-Disposition'])
+
+    def test_nonascii_add_header_via_triple(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename=('iso-8859-1', '', 'Fußballer.ppt'))
+        self.assertEqual(
+            'attachment; filename*=iso-8859-1\'\'Fu%DFballer.ppt',
+            msg['Content-Disposition'])
+
+    def test_ascii_add_header_with_tspecial(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="windows [filename].ppt")
+        self.assertEqual(
+            'attachment; filename="windows [filename].ppt"',
+            msg['Content-Disposition'])
+
+    def test_nonascii_add_header_with_tspecial(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'attachment',
+            filename="Fußballer [filename].ppt")
+        self.assertEqual(
+            "attachment; filename*=utf-8''Fu%C3%9Fballer%20%5Bfilename%5D.ppt",
+            msg['Content-Disposition'])
+
+    def test_binary_quopri_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            msg = Message()
+            msg['content-type'] = 'text/plain; charset=%s' % charset
+            msg['content-transfer-encoding'] = 'quoted-printable'
+            msg.set_payload(b'foo=e6=96=87bar')
+            self.assertEqual(
+                msg.get_payload(decode=True),
+                b'foo\xe6\x96\x87bar',
+                'get_payload returns wrong result with charset %s.' % charset)
+
+    def test_binary_base64_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            msg = Message()
+            msg['content-type'] = 'text/plain; charset=%s' % charset
+            msg['content-transfer-encoding'] = 'base64'
+            msg.set_payload(b'Zm9v5paHYmFy')
+            self.assertEqual(
+                msg.get_payload(decode=True),
+                b'foo\xe6\x96\x87bar',
+                'get_payload returns wrong result with charset %s.' % charset)
+
+    def test_binary_uuencode_payload(self):
+        for charset in ('latin-1', 'ascii'):
+            for encoding in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
+                msg = Message()
+                msg['content-type'] = 'text/plain; charset=%s' % charset
+                msg['content-transfer-encoding'] = encoding
+                msg.set_payload(b"begin 666 -\n)9F]OYI:'8F%R\n \nend\n")
+                self.assertEqual(
+                    msg.get_payload(decode=True),
+                    b'foo\xe6\x96\x87bar',
+                    str(('get_payload returns wrong result ',
+                         'with charset {0} and encoding {1}.')).\
+                        format(charset, encoding))
+
+    def test_add_header_with_name_only_param(self):
+        msg = Message()
+        msg.add_header('Content-Disposition', 'inline', foo_bar=None)
+        self.assertEqual("inline; foo-bar", msg['Content-Disposition'])
+
+    def test_add_header_with_no_value(self):
+        msg = Message()
+        msg.add_header('X-Status', None)
+        self.assertEqual('', msg['X-Status'])
+
+    # Issue 5871: reject an attempt to embed a header inside a header value
+    # (header injection attack).
+    def test_embedded_header_via_Header_rejected(self):
+        msg = Message()
+        msg['Dummy'] = Header('dummy\nX-Injected-Header: test')
+        self.assertRaises(errors.HeaderParseError, msg.as_string)
+
+    def test_embedded_header_via_string_rejected(self):
+        msg = Message()
+        msg['Dummy'] = 'dummy\nX-Injected-Header: test'
+        self.assertRaises(errors.HeaderParseError, msg.as_string)
+
+    def test_unicode_header_defaults_to_utf8_encoding(self):
+        # Issue 14291
+        m = MIMEText('abc\n')
+        m['Subject'] = 'É test'
+        self.assertEqual(str(m),textwrap.dedent("""\
+            Content-Type: text/plain; charset="us-ascii"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: 7bit
+            Subject: =?utf-8?q?=C3=89_test?=
+
+            abc
+            """))
+
+    def test_unicode_body_defaults_to_utf8_encoding(self):
+        # Issue 14291
+        m = MIMEText('É testabc\n')
+        self.assertEqual(str(m),textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: base64
+
+            w4kgdGVzdGFiYwo=
+            """))
+
+    def test_string_payload_with_base64_cte(self):
+        msg = email.message_from_string(textwrap.dedent("""\
+        Content-Transfer-Encoding: base64
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg['content-transfer-encoding'].defects, [])
+
+
+
+# Test the email.encoders module
+class TestEncoders(unittest.TestCase):
+
+    def test_EncodersEncode_base64(self):
+        with openfile('python.gif', 'rb') as fp:
+            bindata = fp.read()
+        mimed = email.mime.image.MIMEImage(bindata)
+        base64ed = mimed.get_payload()
+        # the transfer-encoded body lines should all be <=76 characters
+        lines = base64ed.split('\n')
+        self.assertLessEqual(max([ len(x) for x in lines ]), 76)
+
+    def test_encode_empty_payload(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.set_charset('us-ascii')
+        eq(msg['content-transfer-encoding'], '7bit')
+
+    def test_default_cte(self):
+        eq = self.assertEqual
+        # 7bit data and the default us-ascii _charset
+        msg = MIMEText('hello world')
+        eq(msg['content-transfer-encoding'], '7bit')
+        # Similar, but with 8bit data
+        msg = MIMEText('hello \xf8 world')
+        eq(msg['content-transfer-encoding'], 'base64')
+        # And now with a different charset
+        msg = MIMEText('hello \xf8 world', _charset='iso-8859-1')
+        eq(msg['content-transfer-encoding'], 'quoted-printable')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_encode7or8bit(self):
+        # Make sure a charset whose input character set is 8bit but
+        # whose output character set is 7bit gets a transfer-encoding
+        # of 7bit.
+        eq = self.assertEqual
+        msg = MIMEText('文\n', _charset='euc-jp')
+        eq(msg['content-transfer-encoding'], '7bit')
+        eq(msg.as_string(), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="iso-2022-jp"
+            Content-Transfer-Encoding: 7bit
+
+            \x1b$BJ8\x1b(B
+            """))
+
+    def test_qp_encode_latin1(self):
+        msg = MIMEText('\xe1\xf6\n', 'text', 'ISO-8859-1')
+        self.assertEqual(str(msg), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/text; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            =E1=F6
+            """))
+
+    def test_qp_encode_non_latin1(self):
+        # Issue 16948
+        msg = MIMEText('\u017c\n', 'text', 'ISO-8859-2')
+        self.assertEqual(str(msg), textwrap.dedent("""\
+            MIME-Version: 1.0
+            Content-Type: text/text; charset="iso-8859-2"
+            Content-Transfer-Encoding: quoted-printable
+
+            =BF
+            """))
+
+
+# Test long header wrapping
+class TestLongHeaders(TestEmailBase):
+
+    maxDiff = None
+
+    def test_split_long_continuation(self):
+        eq = self.ndiffAssertEqual
+        msg = email.message_from_string("""\
+Subject: bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text
+
+test
+""")
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+Subject: bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text
+
+test
+""")
+
+    def test_another_long_almost_unsplittable_header(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text"""
+        h = Header(hstr, continuation_ws='\t')
+        eq(h.encode(), """\
+bug demonstration
+\t12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+\tmore text""")
+        h = Header(hstr.replace('\t', ' '))
+        eq(h.encode(), """\
+bug demonstration
+ 12345678911234567892123456789312345678941234567895123456789612345678971234567898112345678911234567892123456789112345678911234567892123456789
+ more text""")
+
+    def test_long_nonstring(self):
+        eq = self.ndiffAssertEqual
+        g = Charset("iso-8859-1")
+        cz = Charset("iso-8859-2")
+        utf8 = Charset("utf-8")
+        g_head = (b'Die Mieter treten hier ein werden mit einem Foerderband '
+                  b'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
+                  b'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
+                  b'bef\xf6rdert. ')
+        cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
+                   b'd\xf9vtipu.. ')
+        utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
+                     '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
+                     '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
+                     '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
+                     '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
+                     'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
+                     'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
+                     '\u3044\u307e\u3059\u3002')
+        h = Header(g_head, g, header_name='Subject')
+        h.append(cz_head, cz)
+        h.append(utf8_head, utf8)
+        msg = Message()
+        msg['Subject'] = h
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+Subject: =?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderb?=
+ =?iso-8859-1?q?and_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen?=
+ =?iso-8859-1?q?_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef?=
+ =?iso-8859-1?q?=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hrouti?=
+ =?iso-8859-2?q?ly_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
+ =?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC5LiA?=
+ =?utf-8?b?6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn44Gf44KJ?=
+ =?utf-8?b?44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFzIE51bnN0dWNr?=
+ =?utf-8?b?IGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5kIGRhcyBPZGVyIGRp?=
+ =?utf-8?b?ZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIDjgaPjgabjgYTjgb7jgZk=?=
+ =?utf-8?b?44CC?=
+
+""")
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerde?=
+ =?iso-8859-1?q?rband_komfortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndis?=
+ =?iso-8859-1?q?chen_Wandgem=E4lden_vorbei=2C_gegen_die_rotierenden_Klinge?=
+ =?iso-8859-1?q?n_bef=F6rdert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se?=
+ =?iso-8859-2?q?_hroutily_pod_tlakem_jejich_d=F9vtipu=2E=2E_?=
+ =?utf-8?b?5q2j56K644Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb?=
+ =?utf-8?b?44KT44CC5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go?=
+ =?utf-8?b?44Gv44Gn44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBp?=
+ =?utf-8?b?c3QgZGFzIE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWlo?=
+ =?utf-8?b?ZXJodW5kIGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI0=?=
+ =?utf-8?b?44Go6KiA44Gj44Gm44GE44G+44GZ44CC?=""")
+
+    def test_long_header_encode(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    def test_long_header_encode_with_tab_continuation_is_just_a_hint(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals"; '
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit',
+                   continuation_ws='\t')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    def test_long_header_encode_with_tab_continuation(self):
+        eq = self.ndiffAssertEqual
+        h = Header('wasnipoop; giraffes="very-long-necked-animals";\t'
+                   'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"',
+                   header_name='X-Foobar-Spoink-Defrobnit',
+                   continuation_ws='\t')
+        eq(h.encode(), '''\
+wasnipoop; giraffes="very-long-necked-animals";
+\tspooge="yummy"; hippos="gargantuan"; marshmallows="gooey"''')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_header_encode_with_different_output_charset(self):
+        h = Header('文', 'euc-jp')
+        self.assertEqual(h.encode(), "=?iso-2022-jp?b?GyRCSjgbKEI=?=")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: euc-jp
+    def test_long_header_encode_with_different_output_charset(self):
+        h = Header(b'test-ja \xa4\xd8\xc5\xea\xb9\xc6\xa4\xb5\xa4\xec\xa4'
+            b'\xbf\xa5\xe1\xa1\xbc\xa5\xeb\xa4\xcf\xbb\xca\xb2\xf1\xbc\xd4'
+            b'\xa4\xce\xbe\xb5\xc7\xa7\xa4\xf2\xc2\xd4\xa4\xc3\xa4\xc6\xa4'
+            b'\xa4\xa4\xde\xa4\xb9'.decode('euc-jp'), 'euc-jp')
+        res = """\
+=?iso-2022-jp?b?dGVzdC1qYSAbJEIkWEVqOUYkNSRsJD8lYSE8JWskTztKMnE8VCROPjUbKEI=?=
+ =?iso-2022-jp?b?GyRCRyckckJUJEMkRiQkJF4kORsoQg==?="""
+        self.assertEqual(h.encode(), res)
+
+    def test_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = MIMEText('')
+        # It'd be great if we could use add_header() here, but that doesn't
+        # guarantee an order of the parameters.
+        msg['X-Foobar-Spoink-Defrobnit'] = (
+            'wasnipoop; giraffes="very-long-necked-animals"; '
+            'spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), '''\
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+X-Foobar-Spoink-Defrobnit: wasnipoop; giraffes="very-long-necked-animals";
+ spooge="yummy"; hippos="gargantuan"; marshmallows="gooey"
+
+''')
+
+    def test_no_semis_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join('<%d@dom.ain>' % i for i in range(10))
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <0@dom.ain> <1@dom.ain> <2@dom.ain> <3@dom.ain> <4@dom.ain>
+ <5@dom.ain> <6@dom.ain> <7@dom.ain> <8@dom.ain> <9@dom.ain>
+
+Test""")
+
+    def test_last_split_chunk_does_not_fit(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Subject: the first part of this is short, but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+Subject: the first part of this is short,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_splittable_leading_char_followed_by_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(', but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_multiple_splittable_leading_char_followed_by_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(', , but_the_second'
+            '_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line'
+            '_all_by_itself')
+        eq(h.encode(), """\
+, ,
+ but_the_second_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself""")
+
+    def test_trailing_splittable_on_overlong_unsplittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself;')
+        eq(h.encode(), "this_part_does_not_fit_within_maxlinelen_and_thus_should_"
+            "be_on_a_line_all_by_itself;")
+
+    def test_trailing_splittable_on_overlong_unsplittable_with_leading_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header('; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_long_header_with_multiple_sequential_split_chars(self):
+        eq = self.ndiffAssertEqual
+        h = Header('This is a long line that has two whitespaces  in a row.  '
+            'This used to cause truncation of the header when folded')
+        eq(h.encode(), """\
+This is a long line that has two whitespaces  in a row.  This used to cause
+ truncation of the header when folded""")
+
+    def test_splitter_split_on_punctuation_only_if_fws_with_header(self):
+        eq = self.ndiffAssertEqual
+        h = Header('thisverylongheaderhas;semicolons;and,commas,but'
+            'they;arenotlegal;fold,points')
+        eq(h.encode(), "thisverylongheaderhas;semicolons;and,commas,butthey;"
+                        "arenotlegal;fold,points")
+
+    def test_leading_splittable_in_the_middle_just_before_overlong_last_part(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this is a  test where we need to have more than one line '
+            'before; our final line that is just too big to fit;; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself;')
+        eq(h.encode(), """\
+this is a  test where we need to have more than one line before;
+ our final line that is just too big to fit;;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself;""")
+
+    def test_overlong_last_part_followed_by_split_point(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself ')
+        eq(h.encode(), "this_part_does_not_fit_within_maxlinelen_and_thus_"
+                        "should_be_on_a_line_all_by_itself ")
+
+    def test_multiline_with_overlong_parts_separated_by_two_split_points(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this_is_a__test_where_we_need_to_have_more_than_one_line_'
+            'before_our_final_line_; ; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+this_is_a__test_where_we_need_to_have_more_than_one_line_before_our_final_line_;
+ ;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_multiline_with_overlong_last_part_followed_by_split_point(self):
+        eq = self.ndiffAssertEqual
+        h = Header('this is a test where we need to have more than one line '
+            'before our final line; ; '
+            'this_part_does_not_fit_within_maxlinelen_and_thus_should_'
+            'be_on_a_line_all_by_itself; ')
+        eq(h.encode(), """\
+this is a test where we need to have more than one line before our final line;
+ ;
+ this_part_does_not_fit_within_maxlinelen_and_thus_should_be_on_a_line_all_by_itself; """)
+
+    def test_long_header_with_whitespace_runs(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join(['<foo@dom.ain>  '] * 10)
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>
+   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>   <foo@dom.ain>
+   <foo@dom.ain>   <foo@dom.ain>\x20\x20
+
+Test""")
+
+    def test_long_run_with_semi_header_splitter(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = SPACE.join(['<foo@dom.ain>'] * 10) + '; abc'
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References: <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain>
+ <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain> <foo@dom.ain>
+ <foo@dom.ain>; abc
+
+Test""")
+
+    def test_splitter_split_on_punctuation_only_if_fws(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'test@dom.ain'
+        msg['References'] = ('thisverylongheaderhas;semicolons;and,commas,but'
+            'they;arenotlegal;fold,points')
+        msg.set_payload('Test')
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        # XXX the space after the header should not be there.
+        eq(sfp.getvalue(), """\
+From: test@dom.ain
+References:\x20
+ thisverylongheaderhas;semicolons;and,commas,butthey;arenotlegal;fold,points
+
+Test""")
+
+    def test_no_split_long_header(self):
+        eq = self.ndiffAssertEqual
+        hstr = 'References: ' + 'x' * 80
+        h = Header(hstr)
+        # These come on two lines because Headers are really field value
+        # classes and don't really know about their field names.
+        eq(h.encode(), """\
+References:
+ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx""")
+        h = Header('x' * 80)
+        eq(h.encode(), 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')
+
+    def test_splitting_multiple_long_lines(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+from babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]); by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81; for <mailman-admin@babylon.socal-raves.org>; Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+"""
+        h = Header(hstr, continuation_ws='\t')
+        eq(h.encode(), """\
+from babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)
+\tfrom babylon.socal-raves.org (localhost [127.0.0.1]);
+ by babylon.socal-raves.org (Postfix) with ESMTP id B570E51B81;
+ for <mailman-admin@babylon.socal-raves.org>;
+ Sat, 2 Feb 2002 17:00:06 -0800 (PST)""")
+
+    def test_splitting_first_line_only_is_long(self):
+        eq = self.ndiffAssertEqual
+        hstr = """\
+from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93] helo=cthulhu.gerg.ca)
+\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
+\tid 17k4h5-00034i-00
+\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400"""
+        h = Header(hstr, maxlinelen=78, header_name='Received',
+                   continuation_ws='\t')
+        eq(h.encode(), """\
+from modemcable093.139-201-24.que.mc.videotron.ca ([24.201.139.93]
+ helo=cthulhu.gerg.ca)
+\tby kronos.mems-exchange.org with esmtp (Exim 4.05)
+\tid 17k4h5-00034i-00
+\tfor test@mems-exchange.org; Wed, 28 Aug 2002 11:25:20 -0400""")
+
+    def test_long_8bit_header(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        h = Header('Britische Regierung gibt', 'iso-8859-1',
+                    header_name='Subject')
+        h.append('gr\xfcnes Licht f\xfcr Offshore-Windkraftprojekte')
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
+ =?iso-8859-1?q?hore-Windkraftprojekte?=""")
+        msg['Subject'] = h
+        eq(msg.as_string(maxheaderlen=76), """\
+Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offs?=
+ =?iso-8859-1?q?hore-Windkraftprojekte?=
+
+""")
+        eq(msg.as_string(maxheaderlen=0), """\
+Subject: =?iso-8859-1?q?Britische_Regierung_gibt_gr=FCnes_Licht_f=FCr_Offshore-Windkraftprojekte?=
+
+""")
+
+    def test_long_8bit_header_no_charset(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        header_string = ('Britische Regierung gibt gr\xfcnes Licht '
+                         'f\xfcr Offshore-Windkraftprojekte '
+                         '<a-very-long-address@example.com>')
+        msg['Reply-To'] = header_string
+        eq(msg.as_string(maxheaderlen=78), """\
+Reply-To: =?utf-8?q?Britische_Regierung_gibt_gr=C3=BCnes_Licht_f=C3=BCr_Offs?=
+ =?utf-8?q?hore-Windkraftprojekte_=3Ca-very-long-address=40example=2Ecom=3E?=
+
+""")
+        msg = Message()
+        msg['Reply-To'] = Header(header_string,
+                                 header_name='Reply-To')
+        eq(msg.as_string(maxheaderlen=78), """\
+Reply-To: =?utf-8?q?Britische_Regierung_gibt_gr=C3=BCnes_Licht_f=C3=BCr_Offs?=
+ =?utf-8?q?hore-Windkraftprojekte_=3Ca-very-long-address=40example=2Ecom=3E?=
+
+""")
+
+    def test_long_to_header(self):
+        eq = self.ndiffAssertEqual
+        to = ('"Someone Test #A" <someone@eecs.umich.edu>,'
+              '<someone@eecs.umich.edu>, '
+              '"Someone Test #B" <someone@umich.edu>, '
+              '"Someone Test #C" <someone@eecs.umich.edu>, '
+              '"Someone Test #D" <someone@eecs.umich.edu>')
+        msg = Message()
+        msg['To'] = to
+        eq(msg.as_string(maxheaderlen=78), '''\
+To: "Someone Test #A" <someone@eecs.umich.edu>,<someone@eecs.umich.edu>,
+ "Someone Test #B" <someone@umich.edu>,
+ "Someone Test #C" <someone@eecs.umich.edu>,
+ "Someone Test #D" <someone@eecs.umich.edu>
+
+''')
+
+    def test_long_line_after_append(self):
+        eq = self.ndiffAssertEqual
+        s = 'This is an example of string which has almost the limit of header length.'
+        h = Header(s)
+        h.append('Add another line.')
+        eq(h.encode(maxlinelen=76), """\
+This is an example of string which has almost the limit of header length.
+ Add another line.""")
+
+    def test_shorter_line_with_append(self):
+        eq = self.ndiffAssertEqual
+        s = 'This is a shorter line.'
+        h = Header(s)
+        h.append('Add another sentence. (Surprise?)')
+        eq(h.encode(),
+           'This is a shorter line. Add another sentence. (Surprise?)')
+
+    def test_long_field_name(self):
+        eq = self.ndiffAssertEqual
+        fn = 'X-Very-Very-Very-Long-Header-Name'
+        gs = ('Die Mieter treten hier ein werden mit einem Foerderband '
+              'komfortabel den Korridor entlang, an s\xfcdl\xfcndischen '
+              'Wandgem\xe4lden vorbei, gegen die rotierenden Klingen '
+              'bef\xf6rdert. ')
+        h = Header(gs, 'iso-8859-1', header_name=fn)
+        # BAW: this seems broken because the first line is too long
+        eq(h.encode(maxlinelen=76), """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_e?=
+ =?iso-8859-1?q?in_werden_mit_einem_Foerderband_komfortabel_den_Korridor_e?=
+ =?iso-8859-1?q?ntlang=2C_an_s=FCdl=FCndischen_Wandgem=E4lden_vorbei=2C_ge?=
+ =?iso-8859-1?q?gen_die_rotierenden_Klingen_bef=F6rdert=2E_?=""")
+
+    def test_long_received_header(self):
+        h = ('from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) '
+             'by hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP; '
+             'Wed, 05 Mar 2003 18:10:18 -0700')
+        msg = Message()
+        msg['Received-1'] = Header(h, continuation_ws='\t')
+        msg['Received-2'] = h
+        # This should be splitting on spaces not semicolons.
+        self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
+Received-1: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by
+ hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
+ Wed, 05 Mar 2003 18:10:18 -0700
+Received-2: from FOO.TLD (vizworld.acl.foo.tld [123.452.678.9]) by
+ hrothgar.la.mastaler.com (tmda-ofmipd) with ESMTP;
+ Wed, 05 Mar 2003 18:10:18 -0700
+
+""")
+
+    def test_string_headerinst_eq(self):
+        h = ('<15975.17901.207240.414604@sgigritzmann1.mathematik.'
+             'tu-muenchen.de> (David Bremner\'s message of '
+             '"Thu, 6 Mar 2003 13:58:21 +0100")')
+        msg = Message()
+        msg['Received-1'] = Header(h, header_name='Received-1',
+                                   continuation_ws='\t')
+        msg['Received-2'] = h
+        # XXX The space after the ':' should not be there.
+        self.ndiffAssertEqual(msg.as_string(maxheaderlen=78), """\
+Received-1:\x20
+ <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David
+ Bremner's message of \"Thu, 6 Mar 2003 13:58:21 +0100\")
+Received-2:\x20
+ <15975.17901.207240.414604@sgigritzmann1.mathematik.tu-muenchen.de> (David
+ Bremner's message of \"Thu, 6 Mar 2003 13:58:21 +0100\")
+
+""")
+
+    def test_long_unbreakable_lines_with_continuation(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        t = """\
+iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp"""
+        msg['Face-1'] = t
+        msg['Face-2'] = Header(t, header_name='Face-2')
+        msg['Face-3'] = ' ' + t
+        # XXX This splitting is all wrong.  It the first value line should be
+        # snug against the field name or the space after the header not there.
+        eq(msg.as_string(maxheaderlen=78), """\
+Face-1:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+Face-2:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+Face-3:\x20
+ iVBORw0KGgoAAAANSUhEUgAAADAAAAAwBAMAAAClLOS0AAAAGFBMVEUAAAAkHiJeRUIcGBi9
+ locQDQ4zJykFBAXJfWDjAAACYUlEQVR4nF2TQY/jIAyFc6lydlG5x8Nyp1Y69wj1PN2I5gzp
+
+""")
+
+    def test_another_long_multiline_header(self):
+        eq = self.ndiffAssertEqual
+        m = ('Received: from siimage.com '
+             '([172.25.1.3]) by zima.siliconimage.com with '
+             'Microsoft SMTPSVC(5.0.2195.4905); '
+             'Wed, 16 Oct 2002 07:41:11 -0700')
+        msg = email.message_from_string(m)
+        eq(msg.as_string(maxheaderlen=78), '''\
+Received: from siimage.com ([172.25.1.3]) by zima.siliconimage.com with
+ Microsoft SMTPSVC(5.0.2195.4905); Wed, 16 Oct 2002 07:41:11 -0700
+
+''')
+
+    def test_long_lines_with_different_header(self):
+        eq = self.ndiffAssertEqual
+        h = ('List-Unsubscribe: '
+             '<http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,'
+             '        <mailto:spamassassin-talk-request@lists.sourceforge.net'
+             '?subject=unsubscribe>')
+        msg = Message()
+        msg['List'] = h
+        msg['List'] = Header(h, header_name='List')
+        eq(msg.as_string(maxheaderlen=78), """\
+List: List-Unsubscribe:
+ <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
+        <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
+List: List-Unsubscribe:
+ <http://lists.sourceforge.net/lists/listinfo/spamassassin-talk>,
+        <mailto:spamassassin-talk-request@lists.sourceforge.net?subject=unsubscribe>
+
+""")
+
+    def test_long_rfc2047_header_with_embedded_fws(self):
+        h = Header(textwrap.dedent("""\
+            We're going to pretend this header is in a non-ascii character set
+            \tto see if line wrapping with encoded words and embedded
+               folding white space works"""),
+                   charset='utf-8',
+                   header_name='Test')
+        self.assertEqual(h.encode()+'\n', textwrap.dedent("""\
+            =?utf-8?q?We=27re_going_to_pretend_this_header_is_in_a_non-ascii_chara?=
+             =?utf-8?q?cter_set?=
+             =?utf-8?q?_to_see_if_line_wrapping_with_encoded_words_and_embedded?=
+             =?utf-8?q?_folding_white_space_works?=""")+'\n')
+
+
+
+# Test mangling of "From " lines in the body of a message
+class TestFromMangling(unittest.TestCase):
+    def setUp(self):
+        self.msg = Message()
+        self.msg['From'] = 'aaa@bbb.org'
+        self.msg.set_payload("""\
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_mangled_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=True)
+        g.flatten(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+>From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_dont_mangle_from(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=False)
+        g.flatten(self.msg)
+        self.assertEqual(s.getvalue(), """\
+From: aaa@bbb.org
+
+From the desk of A.A.A.:
+Blah blah blah
+""")
+
+    def test_mangle_from_in_preamble_and_epilog(self):
+        s = StringIO()
+        g = Generator(s, mangle_from_=True)
+        msg = email.message_from_string(textwrap.dedent("""\
+            From: foo@bar.com
+            Mime-Version: 1.0
+            Content-Type: multipart/mixed; boundary=XXX
+
+            From somewhere unknown
+
+            --XXX
+            Content-Type: text/plain
+
+            foo
+
+            --XXX--
+
+            From somewhere unknowable
+            """))
+        g.flatten(msg)
+        self.assertEqual(len([1 for x in s.getvalue().split('\n')
+                                  if x.startswith('>From ')]), 2)
+
+    def test_mangled_from_with_bad_bytes(self):
+        source = textwrap.dedent("""\
+            Content-Type: text/plain; charset="utf-8"
+            MIME-Version: 1.0
+            Content-Transfer-Encoding: 8bit
+            From: aaa@bbb.org
+
+        """).encode('utf-8')
+        msg = email.message_from_bytes(source + b'From R\xc3\xb6lli\n')
+        b = BytesIO()
+        g = BytesGenerator(b, mangle_from_=True)
+        g.flatten(msg)
+        self.assertEqual(b.getvalue(), source + b'>From R\xc3\xb6lli\n')
+
+    def test_multipart_with_bad_bytes_in_cte(self):
+        # bpo30835
+        source = textwrap.dedent("""\
+            From: aperson@example.com
+            Content-Type: multipart/mixed; boundary="1"
+            Content-Transfer-Encoding: \xc8
+        """).encode('utf-8')
+        msg = email.message_from_bytes(source)
+
+
+# Test the basic MIMEAudio class
+class TestMIMEAudio(unittest.TestCase):
+    def _make_audio(self, ext):
+        with openfile(f'sndhdr.{ext}', 'rb') as fp:
+            self._audiodata = fp.read()
+        self._au = MIMEAudio(self._audiodata)
+
+    def test_guess_minor_type(self):
+        for ext, subtype in {
+            'aifc': 'x-aiff',
+            'aiff': 'x-aiff',
+            'wav': 'x-wav',
+            'au': 'basic',
+        }.items():
+            self._make_audio(ext)
+            subtype = ext if subtype is None else subtype
+            self.assertEqual(self._au.get_content_type(), f'audio/{subtype}')
+
+    def test_encoding(self):
+        self._make_audio('au')
+        payload = self._au.get_payload()
+        self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
+                         self._audiodata)
+
+    def test_checkSetMinor(self):
+        self._make_audio('au')
+        au = MIMEAudio(self._audiodata, 'fish')
+        self.assertEqual(au.get_content_type(), 'audio/fish')
+
+    def test_add_header(self):
+        self._make_audio('au')
+        eq = self.assertEqual
+        self._au.add_header('Content-Disposition', 'attachment',
+                            filename='sndhdr.au')
+        eq(self._au['content-disposition'],
+           'attachment; filename="sndhdr.au"')
+        eq(self._au.get_params(header='content-disposition'),
+           [('attachment', ''), ('filename', 'sndhdr.au')])
+        eq(self._au.get_param('filename', header='content-disposition'),
+           'sndhdr.au')
+        missing = []
+        eq(self._au.get_param('attachment', header='content-disposition'), '')
+        self.assertIs(self._au.get_param(
+            'foo', failobj=missing,
+            header='content-disposition'), missing)
+        # Try some missing stuff
+        self.assertIs(self._au.get_param('foobar', missing), missing)
+        self.assertIs(self._au.get_param('attachment', missing,
+                                         header='foobar'), missing)
+
+
+
+# Test the basic MIMEImage class
+class TestMIMEImage(unittest.TestCase):
+    def _make_image(self, ext):
+        with openfile(f'python.{ext}', 'rb') as fp:
+            self._imgdata = fp.read()
+        self._im = MIMEImage(self._imgdata)
+
+    def test_guess_minor_type(self):
+        for ext, subtype in {
+            'bmp': None,
+            'exr': None,
+            'gif': None,
+            'jpg': 'jpeg',
+            'pbm': None,
+            'pgm': None,
+            'png': None,
+            'ppm': None,
+            'ras': 'rast',
+            'sgi': 'rgb',
+            'tiff': None,
+            'webp': None,
+            'xbm': None,
+        }.items():
+            self._make_image(ext)
+            subtype = ext if subtype is None else subtype
+            self.assertEqual(self._im.get_content_type(), f'image/{subtype}')
+
+    def test_encoding(self):
+        self._make_image('gif')
+        payload = self._im.get_payload()
+        self.assertEqual(base64.decodebytes(bytes(payload, 'ascii')),
+                         self._imgdata)
+
+    def test_checkSetMinor(self):
+        self._make_image('gif')
+        im = MIMEImage(self._imgdata, 'fish')
+        self.assertEqual(im.get_content_type(), 'image/fish')
+
+    def test_add_header(self):
+        self._make_image('gif')
+        eq = self.assertEqual
+        self._im.add_header('Content-Disposition', 'attachment',
+                            filename='dingusfish.gif')
+        eq(self._im['content-disposition'],
+           'attachment; filename="dingusfish.gif"')
+        eq(self._im.get_params(header='content-disposition'),
+           [('attachment', ''), ('filename', 'dingusfish.gif')])
+        eq(self._im.get_param('filename', header='content-disposition'),
+           'dingusfish.gif')
+        missing = []
+        eq(self._im.get_param('attachment', header='content-disposition'), '')
+        self.assertIs(self._im.get_param('foo', failobj=missing,
+                                         header='content-disposition'), missing)
+        # Try some missing stuff
+        self.assertIs(self._im.get_param('foobar', missing), missing)
+        self.assertIs(self._im.get_param('attachment', missing,
+                                         header='foobar'), missing)
+
+
+# Test the basic MIMEApplication class
+class TestMIMEApplication(unittest.TestCase):
+    def test_headers(self):
+        eq = self.assertEqual
+        msg = MIMEApplication(b'\xfa\xfb\xfc\xfd\xfe\xff')
+        eq(msg.get_content_type(), 'application/octet-stream')
+        eq(msg['content-transfer-encoding'], 'base64')
+
+    def test_body(self):
+        eq = self.assertEqual
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata)
+        # whitespace in the cte encoded block is RFC-irrelevant.
+        eq(msg.get_payload().strip(), '+vv8/f7/')
+        eq(msg.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_encode_7or8bit(self):
+        # Issue 17171.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_7or8bit)
+        # Treated as a string, this will be invalid code points.
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg['Content-Transfer-Encoding'], '8bit')
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg2['Content-Transfer-Encoding'], '8bit')
+
+    def test_binary_body_with_encode_noop(self):
+        # Issue 16564: This does not produce an RFC valid message, since to be
+        # valid it should have a CTE of binary.  But the below works in
+        # Python2, and is documented as working this way.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_noop)
+        # Treated as a string, this will be invalid code points.
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '\uFFFD' * len(bytesdata))
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_unicode_linend_encode_noop(self):
+        # Issue 19003: This is a variation on #16564.
+        bytesdata = b'\x0b\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_noop)
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+    def test_binary_body_with_encode_quopri(self):
+        # Issue 14360.
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff '
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_quopri)
+        self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg['Content-Transfer-Encoding'], 'quoted-printable')
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '=FA=FB=FC=FD=FE=FF=20')
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+        self.assertEqual(msg2['Content-Transfer-Encoding'], 'quoted-printable')
+
+    def test_binary_body_with_encode_base64(self):
+        bytesdata = b'\xfa\xfb\xfc\xfd\xfe\xff'
+        msg = MIMEApplication(bytesdata, _encoder=encoders.encode_base64)
+        self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
+        self.assertEqual(msg.get_payload(decode=True), bytesdata)
+        s = BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        wireform = s.getvalue()
+        msg2 = email.message_from_bytes(wireform)
+        self.assertEqual(msg.get_payload(), '+vv8/f7/\n')
+        self.assertEqual(msg2.get_payload(decode=True), bytesdata)
+
+
+# Test the basic MIMEText class
+class TestMIMEText(unittest.TestCase):
+    def setUp(self):
+        self._msg = MIMEText('hello there')
+
+    def test_types(self):
+        eq = self.assertEqual
+        eq(self._msg.get_content_type(), 'text/plain')
+        eq(self._msg.get_param('charset'), 'us-ascii')
+        missing = []
+        self.assertIs(self._msg.get_param('foobar', missing), missing)
+        self.assertIs(self._msg.get_param('charset', missing, header='foobar'),
+                      missing)
+
+    def test_payload(self):
+        self.assertEqual(self._msg.get_payload(), 'hello there')
+        self.assertFalse(self._msg.is_multipart())
+
+    def test_charset(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there', _charset='us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        # Also accept a Charset instance
+        charset = Charset('utf-8')
+        charset.body_encoding = None
+        msg = MIMEText('hello there', _charset=charset)
+        eq(msg.get_charset().input_charset, 'utf-8')
+        eq(msg['content-type'], 'text/plain; charset="utf-8"')
+        eq(msg.get_payload(), 'hello there')
+
+    def test_7bit_input(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there', _charset='us-ascii')
+        eq(msg.get_charset().input_charset, 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+
+    def test_7bit_input_no_charset(self):
+        eq = self.assertEqual
+        msg = MIMEText('hello there')
+        eq(msg.get_charset(), 'us-ascii')
+        eq(msg['content-type'], 'text/plain; charset="us-ascii"')
+        self.assertIn('hello there', msg.as_string())
+
+    def test_utf8_input(self):
+        teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
+        eq = self.assertEqual
+        msg = MIMEText(teststr, _charset='utf-8')
+        eq(msg.get_charset().output_charset, 'utf-8')
+        eq(msg['content-type'], 'text/plain; charset="utf-8"')
+        eq(msg.get_payload(decode=True), teststr.encode('utf-8'))
+
+    @unittest.skip("can't fix because of backward compat in email5, "
+        "will fix in email6")
+    def test_utf8_input_no_charset(self):
+        teststr = '\u043a\u0438\u0440\u0438\u043b\u0438\u0446\u0430'
+        self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
+
+
+
+# Test complicated multipart/* messages
+class TestMultipart(TestEmailBase):
+    def setUp(self):
+        with openfile('python.gif', 'rb') as fp:
+            data = fp.read()
+        container = MIMEBase('multipart', 'mixed', boundary='BOUNDARY')
+        image = MIMEImage(data, name='dingusfish.gif')
+        image.add_header('content-disposition', 'attachment',
+                         filename='dingusfish.gif')
+        intro = MIMEText('''\
+Hi there,
+
+This is the dingus fish.
+''')
+        container.attach(intro)
+        container.attach(image)
+        container['From'] = 'Barry <barry@digicool.com>'
+        container['To'] = 'Dingus Lovers <cravindogs@cravindogs.com>'
+        container['Subject'] = 'Here is your dingus fish'
+
+        now = 987809702.54848599
+        timetuple = time.localtime(now)
+        if timetuple[-1] == 0:
+            tzsecs = time.timezone
+        else:
+            tzsecs = time.altzone
+        if tzsecs > 0:
+            sign = '-'
+        else:
+            sign = '+'
+        tzoffset = ' %s%04d' % (sign, tzsecs / 36)
+        container['Date'] = time.strftime(
+            '%a, %d %b %Y %H:%M:%S',
+            time.localtime(now)) + tzoffset
+        self._msg = container
+        self._im = image
+        self._txt = intro
+
+    def test_hierarchy(self):
+        # convenience
+        eq = self.assertEqual
+        raises = self.assertRaises
+        # tests
+        m = self._msg
+        self.assertTrue(m.is_multipart())
+        eq(m.get_content_type(), 'multipart/mixed')
+        eq(len(m.get_payload()), 2)
+        raises(IndexError, m.get_payload, 2)
+        m0 = m.get_payload(0)
+        m1 = m.get_payload(1)
+        self.assertIs(m0, self._txt)
+        self.assertIs(m1, self._im)
+        eq(m.get_payload(), [m0, m1])
+        self.assertFalse(m0.is_multipart())
+        self.assertFalse(m1.is_multipart())
+
+    def test_empty_multipart_idempotent(self):
+        text = """\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+
+
+--BOUNDARY--
+"""
+        msg = Parser().parsestr(text)
+        self.ndiffAssertEqual(text, msg.as_string())
+
+    def test_no_parts_in_a_multipart_with_none_epilogue(self):
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.set_boundary('BOUNDARY')
+        self.ndiffAssertEqual(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+
+--BOUNDARY--
+''')
+
+    def test_no_parts_in_a_multipart_with_empty_epilogue(self):
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = ''
+        outer.epilogue = ''
+        outer.set_boundary('BOUNDARY')
+        self.ndiffAssertEqual(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+
+--BOUNDARY--
+''')
+
+    def test_one_part_in_a_multipart(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.set_boundary('BOUNDARY')
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+    def test_seq_parts_in_a_multipart_with_empty_preamble(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = ''
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_none_preamble(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.preamble = None
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_none_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = None
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_empty_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = ''
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+''')
+
+
+    def test_seq_parts_in_a_multipart_with_nl_epilogue(self):
+        eq = self.ndiffAssertEqual
+        outer = MIMEBase('multipart', 'mixed')
+        outer['Subject'] = 'A subject'
+        outer['To'] = 'aperson@dom.ain'
+        outer['From'] = 'bperson@dom.ain'
+        outer.epilogue = '\n'
+        msg = MIMEText('hello world')
+        outer.attach(msg)
+        outer.set_boundary('BOUNDARY')
+        eq(outer.as_string(), '''\
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+MIME-Version: 1.0
+Subject: A subject
+To: aperson@dom.ain
+From: bperson@dom.ain
+
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+hello world
+--BOUNDARY--
+
+''')
+
+    def test_message_external_body(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_36.txt')
+        eq(len(msg.get_payload()), 2)
+        msg1 = msg.get_payload(1)
+        eq(msg1.get_content_type(), 'multipart/alternative')
+        eq(len(msg1.get_payload()), 2)
+        for subpart in msg1.get_payload():
+            eq(subpart.get_content_type(), 'message/external-body')
+            eq(len(subpart.get_payload()), 1)
+            subsubpart = subpart.get_payload(0)
+            eq(subsubpart.get_content_type(), 'text/plain')
+
+    def test_double_boundary(self):
+        # msg_37.txt is a multipart that contains two dash-boundary's in a
+        # row.  Our interpretation of RFC 2046 calls for ignoring the second
+        # and subsequent boundaries.
+        msg = self._msgobj('msg_37.txt')
+        self.assertEqual(len(msg.get_payload()), 3)
+
+    def test_nested_inner_contains_outer_boundary(self):
+        eq = self.ndiffAssertEqual
+        # msg_38.txt has an inner part that contains outer boundaries.  My
+        # interpretation of RFC 2046 (based on sections 5.1 and 5.1.2) say
+        # these are illegal and should be interpreted as unterminated inner
+        # parts.
+        msg = self._msgobj('msg_38.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/mixed
+    multipart/mixed
+        multipart/alternative
+            text/plain
+        text/plain
+    text/plain
+    text/plain
+""")
+
+    def test_nested_with_same_boundary(self):
+        eq = self.ndiffAssertEqual
+        # msg 39.txt is similarly evil in that it's got inner parts that use
+        # the same boundary as outer parts.  Again, I believe the way this is
+        # parsed is closest to the spirit of RFC 2046
+        msg = self._msgobj('msg_39.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/mixed
+    multipart/mixed
+        multipart/alternative
+        application/octet-stream
+        application/octet-stream
+    text/plain
+""")
+
+    def test_boundary_in_non_multipart(self):
+        msg = self._msgobj('msg_40.txt')
+        self.assertEqual(msg.as_string(), '''\
+MIME-Version: 1.0
+Content-Type: text/html; boundary="--961284236552522269"
+
+----961284236552522269
+Content-Type: text/html;
+Content-Transfer-Encoding: 7Bit
+
+<html></html>
+
+----961284236552522269--
+''')
+
+    def test_boundary_with_leading_space(self):
+        eq = self.assertEqual
+        msg = email.message_from_string('''\
+MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="    XXXX"
+
+--    XXXX
+Content-Type: text/plain
+
+
+--    XXXX
+Content-Type: text/plain
+
+--    XXXX--
+''')
+        self.assertTrue(msg.is_multipart())
+        eq(msg.get_boundary(), '    XXXX')
+        eq(len(msg.get_payload()), 2)
+
+    def test_boundary_without_trailing_newline(self):
+        m = Parser().parsestr("""\
+Content-Type: multipart/mixed; boundary="===============0012394164=="
+MIME-Version: 1.0
+
+--===============0012394164==
+Content-Type: image/file1.jpg
+MIME-Version: 1.0
+Content-Transfer-Encoding: base64
+
+YXNkZg==
+--===============0012394164==--""")
+        self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
+
+    def test_mimebase_default_policy(self):
+        m = MIMEBase('multipart', 'mixed')
+        self.assertIs(m.policy, email.policy.compat32)
+
+    def test_mimebase_custom_policy(self):
+        m = MIMEBase('multipart', 'mixed', policy=email.policy.default)
+        self.assertIs(m.policy, email.policy.default)
+
+# Test some badly formatted messages
+class TestNonConformant(TestEmailBase):
+
+    def test_parse_missing_minor_type(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_14.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+
+    # test_defect_handling
+    def test_same_boundary_inner_outer(self):
+        msg = self._msgobj('msg_15.txt')
+        # XXX We can probably eventually do better
+        inner = msg.get_payload(0)
+        self.assertHasAttr(inner, 'defects')
+        self.assertEqual(len(inner.defects), 1)
+        self.assertIsInstance(inner.defects[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    # test_defect_handling
+    def test_multipart_no_boundary(self):
+        msg = self._msgobj('msg_25.txt')
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertEqual(len(msg.defects), 2)
+        self.assertIsInstance(msg.defects[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(msg.defects[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    multipart_msg = textwrap.dedent("""\
+        Date: Wed, 14 Nov 2007 12:56:23 GMT
+        From: foo@bar.invalid
+        To: foo@bar.invalid
+        Subject: Content-Transfer-Encoding: base64 and multipart
+        MIME-Version: 1.0
+        Content-Type: multipart/mixed;
+            boundary="===============3344438784458119861=="{}
+
+        --===============3344438784458119861==
+        Content-Type: text/plain
+
+        Test message
+
+        --===============3344438784458119861==
+        Content-Type: application/octet-stream
+        Content-Transfer-Encoding: base64
+
+        YWJj
+
+        --===============3344438784458119861==--
+        """)
+
+    # test_defect_handling
+    def test_multipart_invalid_cte(self):
+        msg = self._str_msg(
+            self.multipart_msg.format("\nContent-Transfer-Encoding: base64"))
+        self.assertEqual(len(msg.defects), 1)
+        self.assertIsInstance(msg.defects[0],
+            errors.InvalidMultipartContentTransferEncodingDefect)
+
+    # test_defect_handling
+    def test_multipart_no_cte_no_defect(self):
+        msg = self._str_msg(self.multipart_msg.format(''))
+        self.assertEqual(len(msg.defects), 0)
+
+    # test_defect_handling
+    def test_multipart_valid_cte_no_defect(self):
+        for cte in ('7bit', '8bit', 'BINary'):
+            msg = self._str_msg(
+                self.multipart_msg.format(
+                    "\nContent-Transfer-Encoding: {}".format(cte)))
+            self.assertEqual(len(msg.defects), 0)
+
+    # test_headerregistry.TestContentTypeHeader invalid_1 and invalid_2.
+    def test_invalid_content_type(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        msg = Message()
+        # RFC 2045, $5.2 says invalid yields text/plain
+        msg['Content-Type'] = 'text'
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_content_type(), 'text/plain')
+        # Clear the old value and try something /really/ invalid
+        del msg['content-type']
+        msg['Content-Type'] = 'foo'
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_content_type(), 'text/plain')
+        # Still, make sure that the message is idempotently generated
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(msg)
+        neq(s.getvalue(), 'Content-Type: foo\n\n')
+
+    def test_no_start_boundary(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_31.txt')
+        eq(msg.get_payload(), """\
+--BOUNDARY
+Content-Type: text/plain
+
+message 1
+
+--BOUNDARY
+Content-Type: text/plain
+
+message 2
+
+--BOUNDARY--
+""")
+
+    def test_no_separating_blank_line(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_35.txt')
+        eq(msg.as_string(), """\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: here's something interesting
+
+counter to RFC 5322, there's no separating newline here
+""")
+
+    # test_defect_handling
+    def test_lying_multipart(self):
+        msg = self._msgobj('msg_41.txt')
+        self.assertHasAttr(msg, 'defects')
+        self.assertEqual(len(msg.defects), 2)
+        self.assertIsInstance(msg.defects[0],
+                              errors.NoBoundaryInMultipartDefect)
+        self.assertIsInstance(msg.defects[1],
+                              errors.MultipartInvariantViolationDefect)
+
+    # test_defect_handling
+    def test_missing_start_boundary(self):
+        outer = self._msgobj('msg_42.txt')
+        # The message structure is:
+        #
+        # multipart/mixed
+        #    text/plain
+        #    message/rfc822
+        #        multipart/mixed [*]
+        #
+        # [*] This message is missing its start boundary
+        bad = outer.get_payload(1).get_payload(0)
+        self.assertEqual(len(bad.defects), 1)
+        self.assertIsInstance(bad.defects[0],
+                              errors.StartBoundaryNotFoundDefect)
+
+    # test_defect_handling
+    def test_first_line_is_continuation_header(self):
+        eq = self.assertEqual
+        m = ' Line 1\nSubject: test\n\nbody'
+        msg = email.message_from_string(m)
+        eq(msg.keys(), ['Subject'])
+        eq(msg.get_payload(), 'body')
+        eq(len(msg.defects), 1)
+        self.assertDefectsEqual(msg.defects,
+                                 [errors.FirstHeaderLineIsContinuationDefect])
+        eq(msg.defects[0].line, ' Line 1\n')
+
+    # test_defect_handling
+    def test_missing_header_body_separator(self):
+        # Our heuristic if we see a line that doesn't look like a header (no
+        # leading whitespace but no ':') is to assume that the blank line that
+        # separates the header from the body is missing, and to stop parsing
+        # headers and start parsing the body.
+        msg = self._str_msg('Subject: test\nnot a header\nTo: abc\n\nb\n')
+        self.assertEqual(msg.keys(), ['Subject'])
+        self.assertEqual(msg.get_payload(), 'not a header\nTo: abc\n\nb\n')
+        self.assertDefectsEqual(msg.defects,
+                                [errors.MissingHeaderBodySeparatorDefect])
+
+    def test_string_payload_with_extra_space_after_cte(self):
+        # https://github.com/python/cpython/issues/98188
+        cte = "base64 "
+        msg = email.message_from_string(textwrap.dedent(f"""\
+        Content-Transfer-Encoding: {cte}
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg['content-transfer-encoding'].defects, [])
+
+    def test_string_payload_with_extra_text_after_cte(self):
+        msg = email.message_from_string(textwrap.dedent("""\
+        Content-Transfer-Encoding: base64 some text
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.default)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        cte = msg['content-transfer-encoding']
+        self.assertDefectsEqual(cte.defects, [email.errors.InvalidHeaderDefect])
+
+    def test_string_payload_with_extra_space_after_cte_compat32(self):
+        cte = "base64 "
+        msg = email.message_from_string(textwrap.dedent(f"""\
+        Content-Transfer-Encoding: {cte}
+
+        SGVsbG8uIFRlc3Rpbmc=
+        """), policy=email.policy.compat32)
+        pasted_cte = msg['content-transfer-encoding']
+        self.assertEqual(pasted_cte, cte)
+        self.assertEqual(msg.get_payload(decode=True), b"Hello. Testing")
+        self.assertDefectsEqual(msg.defects, [])
+
+
+
+# Test RFC 2047 header encoding and decoding
+class TestRFC2047(TestEmailBase):
+    def test_rfc2047_multiline(self):
+        eq = self.assertEqual
+        s = """Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz
+ foo bar =?mac-iceland?q?r=8Aksm=9Arg=8Cs?="""
+        dh = decode_header(s)
+        eq(dh, [
+            (b'Re: ', None),
+            (b'r\x8aksm\x9arg\x8cs', 'mac-iceland'),
+            (b' baz foo bar ', None),
+            (b'r\x8aksm\x9arg\x8cs', 'mac-iceland')])
+        header = make_header(dh)
+        eq(str(header),
+           'Re: r\xe4ksm\xf6rg\xe5s baz foo bar r\xe4ksm\xf6rg\xe5s')
+        self.ndiffAssertEqual(header.encode(maxlinelen=76), """\
+Re: =?mac-iceland?q?r=8Aksm=9Arg=8Cs?= baz foo bar =?mac-iceland?q?r=8Aksm?=
+ =?mac-iceland?q?=9Arg=8Cs?=""")
+
+    def test_whitespace_keeper_unicode(self):
+        eq = self.assertEqual
+        s = '=?ISO-8859-1?Q?Andr=E9?= Pirard <pirard@dom.ain>'
+        dh = decode_header(s)
+        eq(dh, [(b'Andr\xe9', 'iso-8859-1'),
+                (b' Pirard <pirard@dom.ain>', None)])
+        header = str(make_header(dh))
+        eq(header, 'Andr\xe9 Pirard <pirard@dom.ain>')
+
+    def test_whitespace_keeper_unicode_2(self):
+        eq = self.assertEqual
+        s = 'The =?iso-8859-1?b?cXVpY2sgYnJvd24gZm94?= jumped over the =?iso-8859-1?b?bGF6eSBkb2c=?='
+        dh = decode_header(s)
+        eq(dh, [(b'The ', None), (b'quick brown fox', 'iso-8859-1'),
+                (b' jumped over the ', None), (b'lazy dog', 'iso-8859-1')])
+        hu = str(make_header(dh))
+        eq(hu, 'The quick brown fox jumped over the lazy dog')
+
+    def test_rfc2047_missing_whitespace(self):
+        s = 'Sm=?ISO-8859-1?B?9g==?=rg=?ISO-8859-1?B?5Q==?=sbord'
+        dh = decode_header(s)
+        self.assertEqual(dh, [(b'Sm', None), (b'\xf6', 'iso-8859-1'),
+                              (b'rg', None), (b'\xe5', 'iso-8859-1'),
+                              (b'sbord', None)])
+
+    def test_rfc2047_with_whitespace(self):
+        s = 'Sm =?ISO-8859-1?B?9g==?= rg =?ISO-8859-1?B?5Q==?= sbord'
+        dh = decode_header(s)
+        self.assertEqual(dh, [(b'Sm ', None), (b'\xf6', 'iso-8859-1'),
+                              (b' rg ', None), (b'\xe5', 'iso-8859-1'),
+                              (b' sbord', None)])
+
+    def test_rfc2047_B_bad_padding(self):
+        s = '=?iso-8859-1?B?%s?='
+        data = [                                # only test complete bytes
+            ('dm==', b'v'), ('dm=', b'v'), ('dm', b'v'),
+            ('dmk=', b'vi'), ('dmk', b'vi')
+          ]
+        for q, a in data:
+            dh = decode_header(s % q)
+            self.assertEqual(dh, [(a, 'iso-8859-1')])
+
+    def test_rfc2047_Q_invalid_digits(self):
+        # issue 10004.
+        s = '=?iso-8859-1?Q?andr=e9=zz?='
+        self.assertEqual(decode_header(s),
+                        [(b'andr\xe9=zz', 'iso-8859-1')])
+
+    def test_rfc2047_rfc2047_1(self):
+        # 1st testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_2(self):
+        # 2nd testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= b)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b' b)', None)])
+
+    def test_rfc2047_rfc2047_3(self):
+        # 3rd testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_4(self):
+        # 4th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?=  =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_5a(self):
+        # 5th testcase at end of RFC 2047 newline is \r\n
+        s = '(=?ISO-8859-1?Q?a?=\r\n    =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_5b(self):
+        # 5th testcase at end of RFC 2047 newline is \n
+        s = '(=?ISO-8859-1?Q?a?=\n    =?ISO-8859-1?Q?b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'ab', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_6(self):
+        # 6th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a_b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a b', 'iso-8859-1'), (b')', None)])
+
+    def test_rfc2047_rfc2047_7(self):
+        # 7th testcase at end of RFC 2047
+        s = '(=?ISO-8859-1?Q?a?= =?ISO-8859-2?Q?_b?=)'
+        self.assertEqual(decode_header(s),
+            [(b'(', None), (b'a', 'iso-8859-1'), (b' b', 'iso-8859-2'),
+             (b')', None)])
+        self.assertEqual(make_header(decode_header(s)).encode(), s.lower())
+        self.assertEqual(str(make_header(decode_header(s))), '(a b)')
+
+    def test_multiline_header(self):
+        s = '=?windows-1252?q?=22M=FCller_T=22?=\r\n <T.Mueller@xxx.com>'
+        self.assertEqual(decode_header(s),
+            [(b'"M\xfcller T"', 'windows-1252'),
+             (b'<T.Mueller@xxx.com>', None)])
+        self.assertEqual(make_header(decode_header(s)).encode(),
+                         ''.join(s.splitlines()))
+        self.assertEqual(str(make_header(decode_header(s))),
+                         '"Müller T" <T.Mueller@xxx.com>')
+
+    def test_unencoded_ascii(self):
+        # bpo-22833/gh-67022: returns [(str, None)] rather than [(bytes, None)]
+        s = 'header without encoded words'
+        self.assertEqual(decode_header(s),
+            [('header without encoded words', None)])
+
+    def test_unencoded_utf8(self):
+        # bpo-22833/gh-67022: returns [(str, None)] rather than [(bytes, None)]
+        s = 'header with unexpected non ASCII caract\xe8res'
+        self.assertEqual(decode_header(s),
+            [('header with unexpected non ASCII caract\xe8res', None)])
+
+
+# Test the MIMEMessage class
+class TestMIMEMessage(TestEmailBase):
+    def setUp(self):
+        with openfile('msg_11.txt', encoding="utf-8") as fp:
+            self._text = fp.read()
+
+    def test_type_error(self):
+        self.assertRaises(TypeError, MIMEMessage, 'a plain string')
+
+    def test_valid_argument(self):
+        eq = self.assertEqual
+        subject = 'A sub-message'
+        m = Message()
+        m['Subject'] = subject
+        r = MIMEMessage(m)
+        eq(r.get_content_type(), 'message/rfc822')
+        payload = r.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        subpart = payload[0]
+        self.assertIs(subpart, m)
+        eq(subpart['subject'], subject)
+
+    def test_bad_multipart(self):
+        msg1 = Message()
+        msg1['Subject'] = 'subpart 1'
+        msg2 = Message()
+        msg2['Subject'] = 'subpart 2'
+        r = MIMEMessage(msg1)
+        self.assertRaises(errors.MultipartConversionError, r.attach, msg2)
+
+    def test_generate(self):
+        # First craft the message to be encapsulated
+        m = Message()
+        m['Subject'] = 'An enclosed message'
+        m.set_payload('Here is the body of the message.\n')
+        r = MIMEMessage(m)
+        r['Subject'] = 'The enclosing message'
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(r)
+        self.assertEqual(s.getvalue(), """\
+Content-Type: message/rfc822
+MIME-Version: 1.0
+Subject: The enclosing message
+
+Subject: An enclosed message
+
+Here is the body of the message.
+""")
+
+    def test_parse_message_rfc822(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_11.txt')
+        eq(msg.get_content_type(), 'message/rfc822')
+        payload = msg.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        submsg = payload[0]
+        self.assertIsInstance(submsg, Message)
+        eq(submsg['subject'], 'An enclosed message')
+        eq(submsg.get_payload(), 'Here is the body of the message.\n')
+
+    def test_dsn(self):
+        eq = self.assertEqual
+        # msg 16 is a Delivery Status Notification, see RFC 1894
+        msg = self._msgobj('msg_16.txt')
+        eq(msg.get_content_type(), 'multipart/report')
+        self.assertTrue(msg.is_multipart())
+        eq(len(msg.get_payload()), 3)
+        # Subpart 1 is a text/plain, human readable section
+        subpart = msg.get_payload(0)
+        eq(subpart.get_content_type(), 'text/plain')
+        eq(subpart.get_payload(), """\
+This report relates to a message you sent with the following header fields:
+
+  Message-id: <002001c144a6$8752e060$56104586@oxy.edu>
+  Date: Sun, 23 Sep 2001 20:10:55 -0700
+  From: "Ian T. Henry" <henryi@oxy.edu>
+  To: SoCal Raves <scr@socal-raves.org>
+  Subject: [scr] yeah for Ians!!
+
+Your message cannot be delivered to the following recipients:
+
+  Recipient address: jangel1@cougar.noc.ucla.edu
+  Reason: recipient reached disk quota
+
+""")
+        # Subpart 2 contains the machine parsable DSN information.  It
+        # consists of two blocks of headers, represented by two nested Message
+        # objects.
+        subpart = msg.get_payload(1)
+        eq(subpart.get_content_type(), 'message/delivery-status')
+        eq(len(subpart.get_payload()), 2)
+        # message/delivery-status should treat each block as a bunch of
+        # headers, i.e. a bunch of Message objects.
+        dsn1 = subpart.get_payload(0)
+        self.assertIsInstance(dsn1, Message)
+        eq(dsn1['original-envelope-id'], '0GK500B4HD0888@cougar.noc.ucla.edu')
+        eq(dsn1.get_param('dns', header='reporting-mta'), '')
+        # Try a missing one <wink>
+        eq(dsn1.get_param('nsd', header='reporting-mta'), None)
+        dsn2 = subpart.get_payload(1)
+        self.assertIsInstance(dsn2, Message)
+        eq(dsn2['action'], 'failed')
+        eq(dsn2.get_params(header='original-recipient'),
+           [('rfc822', ''), ('jangel1@cougar.noc.ucla.edu', '')])
+        eq(dsn2.get_param('rfc822', header='final-recipient'), '')
+        # Subpart 3 is the original message
+        subpart = msg.get_payload(2)
+        eq(subpart.get_content_type(), 'message/rfc822')
+        payload = subpart.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        subsubpart = payload[0]
+        self.assertIsInstance(subsubpart, Message)
+        eq(subsubpart.get_content_type(), 'text/plain')
+        eq(subsubpart['message-id'],
+           '<002001c144a6$8752e060$56104586@oxy.edu>')
+
+    def test_epilogue(self):
+        eq = self.ndiffAssertEqual
+        with openfile('msg_21.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = Message()
+        msg['From'] = 'aperson@dom.ain'
+        msg['To'] = 'bperson@dom.ain'
+        msg['Subject'] = 'Test'
+        msg.preamble = 'MIME message'
+        msg.epilogue = 'End of MIME message\n'
+        msg1 = MIMEText('One')
+        msg2 = MIMEText('Two')
+        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
+        msg.attach(msg1)
+        msg.attach(msg2)
+        sfp = StringIO()
+        g = Generator(sfp)
+        g.flatten(msg)
+        eq(sfp.getvalue(), text)
+
+    def test_no_nl_preamble(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg['From'] = 'aperson@dom.ain'
+        msg['To'] = 'bperson@dom.ain'
+        msg['Subject'] = 'Test'
+        msg.preamble = 'MIME message'
+        msg.epilogue = ''
+        msg1 = MIMEText('One')
+        msg2 = MIMEText('Two')
+        msg.add_header('Content-Type', 'multipart/mixed', boundary='BOUNDARY')
+        msg.attach(msg1)
+        msg.attach(msg2)
+        eq(msg.as_string(), """\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: Test
+Content-Type: multipart/mixed; boundary="BOUNDARY"
+
+MIME message
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+One
+--BOUNDARY
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+Two
+--BOUNDARY--
+""")
+
+    def test_default_type(self):
+        eq = self.assertEqual
+        with openfile('msg_30.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        container1 = msg.get_payload(0)
+        eq(container1.get_default_type(), 'message/rfc822')
+        eq(container1.get_content_type(), 'message/rfc822')
+        container2 = msg.get_payload(1)
+        eq(container2.get_default_type(), 'message/rfc822')
+        eq(container2.get_content_type(), 'message/rfc822')
+        container1a = container1.get_payload(0)
+        eq(container1a.get_default_type(), 'text/plain')
+        eq(container1a.get_content_type(), 'text/plain')
+        container2a = container2.get_payload(0)
+        eq(container2a.get_default_type(), 'text/plain')
+        eq(container2a.get_content_type(), 'text/plain')
+
+    def test_default_type_with_explicit_container_type(self):
+        eq = self.assertEqual
+        with openfile('msg_28.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        container1 = msg.get_payload(0)
+        eq(container1.get_default_type(), 'message/rfc822')
+        eq(container1.get_content_type(), 'message/rfc822')
+        container2 = msg.get_payload(1)
+        eq(container2.get_default_type(), 'message/rfc822')
+        eq(container2.get_content_type(), 'message/rfc822')
+        container1a = container1.get_payload(0)
+        eq(container1a.get_default_type(), 'text/plain')
+        eq(container1a.get_content_type(), 'text/plain')
+        container2a = container2.get_payload(0)
+        eq(container2a.get_default_type(), 'text/plain')
+        eq(container2a.get_content_type(), 'text/plain')
+
+    def test_default_type_non_parsed(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        # Set up container
+        container = MIMEMultipart('digest', 'BOUNDARY')
+        container.epilogue = ''
+        # Set up subparts
+        subpart1a = MIMEText('message 1\n')
+        subpart2a = MIMEText('message 2\n')
+        subpart1 = MIMEMessage(subpart1a)
+        subpart2 = MIMEMessage(subpart2a)
+        container.attach(subpart1)
+        container.attach(subpart2)
+        eq(subpart1.get_content_type(), 'message/rfc822')
+        eq(subpart1.get_default_type(), 'message/rfc822')
+        eq(subpart2.get_content_type(), 'message/rfc822')
+        eq(subpart2.get_default_type(), 'message/rfc822')
+        neq(container.as_string(0), '''\
+Content-Type: multipart/digest; boundary="BOUNDARY"
+MIME-Version: 1.0
+
+--BOUNDARY
+Content-Type: message/rfc822
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 1
+
+--BOUNDARY
+Content-Type: message/rfc822
+MIME-Version: 1.0
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 2
+
+--BOUNDARY--
+''')
+        del subpart1['content-type']
+        del subpart1['mime-version']
+        del subpart2['content-type']
+        del subpart2['mime-version']
+        eq(subpart1.get_content_type(), 'message/rfc822')
+        eq(subpart1.get_default_type(), 'message/rfc822')
+        eq(subpart2.get_content_type(), 'message/rfc822')
+        eq(subpart2.get_default_type(), 'message/rfc822')
+        neq(container.as_string(0), '''\
+Content-Type: multipart/digest; boundary="BOUNDARY"
+MIME-Version: 1.0
+
+--BOUNDARY
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 1
+
+--BOUNDARY
+
+Content-Type: text/plain; charset="us-ascii"
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+
+message 2
+
+--BOUNDARY--
+''')
+
+    def test_mime_attachments_in_constructor(self):
+        eq = self.assertEqual
+        text1 = MIMEText('')
+        text2 = MIMEText('')
+        msg = MIMEMultipart(_subparts=(text1, text2))
+        eq(len(msg.get_payload()), 2)
+        eq(msg.get_payload(0), text1)
+        eq(msg.get_payload(1), text2)
+
+    def test_default_multipart_constructor(self):
+        msg = MIMEMultipart()
+        self.assertTrue(msg.is_multipart())
+
+    def test_multipart_default_policy(self):
+        msg = MIMEMultipart()
+        msg['To'] = 'a@b.com'
+        msg['To'] = 'c@d.com'
+        self.assertEqual(msg.get_all('to'), ['a@b.com', 'c@d.com'])
+
+    def test_multipart_custom_policy(self):
+        msg = MIMEMultipart(policy=email.policy.default)
+        msg['To'] = 'a@b.com'
+        with self.assertRaises(ValueError) as cm:
+            msg['To'] = 'c@d.com'
+        self.assertEqual(str(cm.exception),
+                         'There may be at most 1 To headers in a message')
+
+
+# Test the NonMultipart class
+class TestNonMultipart(TestEmailBase):
+    def test_nonmultipart_is_not_multipart(self):
+        msg = MIMENonMultipart('text', 'plain')
+        self.assertFalse(msg.is_multipart())
+
+    def test_attach_raises_exception(self):
+        msg = Message()
+        msg['Subject'] = 'subpart 1'
+        r = MIMENonMultipart('text', 'plain')
+        self.assertRaises(errors.MultipartConversionError, r.attach, msg)
+
+
+# A general test of parser->model->generator idempotency.  IOW, read a message
+# in, parse it into a message object tree, then without touching the tree,
+# regenerate the plain text.  The original text and the transformed text
+# should be identical.  Note: that we ignore the Unix-From since that may
+# contain a changed date.
+class TestIdempotent(TestEmailBase):
+
+    linesep = '\n'
+
+    def _msgobj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            data = fp.read()
+        msg = email.message_from_string(data)
+        return msg, data
+
+    def _idempotent(self, msg, text, unixfrom=False):
+        eq = self.ndiffAssertEqual
+        s = StringIO()
+        g = Generator(s, maxheaderlen=0)
+        g.flatten(msg, unixfrom=unixfrom)
+        eq(text, s.getvalue())
+
+    def test_parse_text_message(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_01.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_content_maintype(), 'text')
+        eq(msg.get_content_subtype(), 'plain')
+        eq(msg.get_params()[1], ('charset', 'us-ascii'))
+        eq(msg.get_param('charset'), 'us-ascii')
+        eq(msg.preamble, None)
+        eq(msg.epilogue, None)
+        self._idempotent(msg, text)
+
+    def test_parse_untyped_message(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_03.txt')
+        eq(msg.get_content_type(), 'text/plain')
+        eq(msg.get_params(), None)
+        eq(msg.get_param('charset'), None)
+        self._idempotent(msg, text)
+
+    def test_simple_multipart(self):
+        msg, text = self._msgobj('msg_04.txt')
+        self._idempotent(msg, text)
+
+    def test_MIME_digest(self):
+        msg, text = self._msgobj('msg_02.txt')
+        self._idempotent(msg, text)
+
+    def test_long_header(self):
+        msg, text = self._msgobj('msg_27.txt')
+        self._idempotent(msg, text)
+
+    def test_MIME_digest_with_part_headers(self):
+        msg, text = self._msgobj('msg_28.txt')
+        self._idempotent(msg, text)
+
+    def test_mixed_with_image(self):
+        msg, text = self._msgobj('msg_06.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_report(self):
+        msg, text = self._msgobj('msg_05.txt')
+        self._idempotent(msg, text)
+
+    def test_dsn(self):
+        msg, text = self._msgobj('msg_16.txt')
+        self._idempotent(msg, text)
+
+    def test_preamble_epilogue(self):
+        msg, text = self._msgobj('msg_21.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_one_part(self):
+        msg, text = self._msgobj('msg_23.txt')
+        self._idempotent(msg, text)
+
+    def test_multipart_no_parts(self):
+        msg, text = self._msgobj('msg_24.txt')
+        self._idempotent(msg, text)
+
+    def test_no_start_boundary(self):
+        msg, text = self._msgobj('msg_31.txt')
+        self._idempotent(msg, text)
+
+    def test_rfc2231_charset(self):
+        msg, text = self._msgobj('msg_32.txt')
+        self._idempotent(msg, text)
+
+    def test_more_rfc2231_parameters(self):
+        msg, text = self._msgobj('msg_33.txt')
+        self._idempotent(msg, text)
+
+    def test_text_plain_in_a_multipart_digest(self):
+        msg, text = self._msgobj('msg_34.txt')
+        self._idempotent(msg, text)
+
+    def test_nested_multipart_mixeds(self):
+        msg, text = self._msgobj('msg_12a.txt')
+        self._idempotent(msg, text)
+
+    def test_message_external_body_idempotent(self):
+        msg, text = self._msgobj('msg_36.txt')
+        self._idempotent(msg, text)
+
+    def test_message_delivery_status(self):
+        msg, text = self._msgobj('msg_43.txt')
+        self._idempotent(msg, text, unixfrom=True)
+
+    def test_message_signed_idempotent(self):
+        msg, text = self._msgobj('msg_45.txt')
+        self._idempotent(msg, text)
+
+    def test_content_type(self):
+        eq = self.assertEqual
+        # Get a message object and reset the seek pointer for other tests
+        msg, text = self._msgobj('msg_05.txt')
+        eq(msg.get_content_type(), 'multipart/report')
+        # Test the Content-Type: parameters
+        params = {}
+        for pk, pv in msg.get_params():
+            params[pk] = pv
+        eq(params['report-type'], 'delivery-status')
+        eq(params['boundary'], 'D1690A7AC1.996856090/mail.example.com')
+        eq(msg.preamble, 'This is a MIME-encapsulated message.' + self.linesep)
+        eq(msg.epilogue, self.linesep)
+        eq(len(msg.get_payload()), 3)
+        # Make sure the subparts are what we expect
+        msg1 = msg.get_payload(0)
+        eq(msg1.get_content_type(), 'text/plain')
+        eq(msg1.get_payload(), 'Yadda yadda yadda' + self.linesep)
+        msg2 = msg.get_payload(1)
+        eq(msg2.get_content_type(), 'text/plain')
+        eq(msg2.get_payload(), 'Yadda yadda yadda' + self.linesep)
+        msg3 = msg.get_payload(2)
+        eq(msg3.get_content_type(), 'message/rfc822')
+        self.assertIsInstance(msg3, Message)
+        payload = msg3.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        msg4 = payload[0]
+        self.assertIsInstance(msg4, Message)
+        eq(msg4.get_payload(), 'Yadda yadda yadda' + self.linesep)
+
+    def test_parser(self):
+        eq = self.assertEqual
+        msg, text = self._msgobj('msg_06.txt')
+        # Check some of the outer headers
+        eq(msg.get_content_type(), 'message/rfc822')
+        # Make sure the payload is a list of exactly one sub-Message, and that
+        # that submessage has a type of text/plain
+        payload = msg.get_payload()
+        self.assertIsInstance(payload, list)
+        eq(len(payload), 1)
+        msg1 = payload[0]
+        self.assertIsInstance(msg1, Message)
+        eq(msg1.get_content_type(), 'text/plain')
+        self.assertIsInstance(msg1.get_payload(), str)
+        eq(msg1.get_payload(), self.linesep)
+
+
+
+# Test various other bits of the package's functionality
+class TestMiscellaneous(TestEmailBase):
+    def test_message_from_string(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = email.message_from_string(text)
+        s = StringIO()
+        # Don't wrap/continue long headers since we're trying to test
+        # idempotency.
+        g = Generator(s, maxheaderlen=0)
+        g.flatten(msg)
+        self.assertEqual(text, s.getvalue())
+
+    def test_message_from_file(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+            fp.seek(0)
+            msg = email.message_from_file(fp)
+            s = StringIO()
+            # Don't wrap/continue long headers since we're trying to test
+            # idempotency.
+            g = Generator(s, maxheaderlen=0)
+            g.flatten(msg)
+            self.assertEqual(text, s.getvalue())
+
+    def test_message_from_string_with_class(self):
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            text = fp.read()
+
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+
+        msg = email.message_from_string(text, MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+        # Try something more complicated
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            text = fp.read()
+        msg = email.message_from_string(text, MyMessage)
+        for subpart in msg.walk():
+            self.assertIsInstance(subpart, MyMessage)
+
+    def test_message_from_file_with_class(self):
+        # Create a subclass
+        class MyMessage(Message):
+            pass
+
+        with openfile('msg_01.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp, MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+        # Try something more complicated
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp, MyMessage)
+        for subpart in msg.walk():
+            self.assertIsInstance(subpart, MyMessage)
+
+    def test_custom_message_does_not_require_arguments(self):
+        class MyMessage(Message):
+            def __init__(self):
+                super().__init__()
+        msg = self._str_msg("Subject: test\n\ntest", MyMessage)
+        self.assertIsInstance(msg, MyMessage)
+
+    def test__all__(self):
+        module = __import__('email')
+        self.assertEqual(sorted(module.__all__), [
+            'base64mime', 'charset', 'encoders', 'errors', 'feedparser',
+            'generator', 'header', 'iterators', 'message',
+            'message_from_binary_file', 'message_from_bytes',
+            'message_from_file', 'message_from_string', 'mime', 'parser',
+            'quoprimime', 'utils',
+            ])
+
+    def test_formatdate(self):
+        now = time.time()
+        self.assertEqual(utils.parsedate(utils.formatdate(now))[:6],
+                         time.gmtime(now)[:6])
+
+    def test_formatdate_localtime(self):
+        now = time.time()
+        self.assertEqual(
+            utils.parsedate(utils.formatdate(now, localtime=True))[:6],
+            time.localtime(now)[:6])
+
+    def test_formatdate_usegmt(self):
+        now = time.time()
+        self.assertEqual(
+            utils.formatdate(now, localtime=False),
+            time.strftime('%a, %d %b %Y %H:%M:%S -0000', time.gmtime(now)))
+        self.assertEqual(
+            utils.formatdate(now, localtime=False, usegmt=True),
+            time.strftime('%a, %d %b %Y %H:%M:%S GMT', time.gmtime(now)))
+
+    # parsedate and parsedate_tz will become deprecated interfaces someday
+    def test_parsedate_returns_None_for_invalid_strings(self):
+        # See also test_parsedate_to_datetime_with_invalid_raises_valueerror
+        # in test_utils.
+        invalid_dates = [
+            '',
+            ' ',
+            '0',
+            'A Complete Waste of Time',
+            'Wed, 3 Apr 2002 12.34.56.78+0800',
+            '17 June , 2022',
+            'Friday, -Nov-82 16:14:55 EST',
+            'Friday, Nov--82 16:14:55 EST',
+            'Friday, 19-Nov- 16:14:55 EST',
+        ]
+        for dtstr in invalid_dates:
+            with self.subTest(dtstr=dtstr):
+                self.assertIsNone(utils.parsedate(dtstr))
+                self.assertIsNone(utils.parsedate_tz(dtstr))
+        # Not a part of the spec but, but this has historically worked:
+        self.assertIsNone(utils.parsedate(None))
+        self.assertIsNone(utils.parsedate_tz(None))
+
+    def test_parsedate_compact(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        # The FWS after the comma is optional
+        self.assertEqual(utils.parsedate_tz('Wed,3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        # The comma is optional
+        self.assertEqual(utils.parsedate_tz('Wed 3 Apr 2002 14:58:26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+
+    def test_parsedate_no_dayofweek(self):
+        eq = self.assertEqual
+        eq(utils.parsedate_tz('5 Feb 2003 13:47:26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+        eq(utils.parsedate_tz('February 5, 2003 13:47:26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+
+    def test_parsedate_no_space_before_positive_offset(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26+0800'),
+           (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+
+    def test_parsedate_no_space_before_negative_offset(self):
+        # Issue 1155362: we already handled '+' for this case.
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58:26-0800'),
+           (2002, 4, 3, 14, 58, 26, 0, 1, -1, -28800))
+
+    def test_parsedate_accepts_time_with_dots(self):
+        eq = self.assertEqual
+        eq(utils.parsedate_tz('5 Feb 2003 13.47.26 -0800'),
+           (2003, 2, 5, 13, 47, 26, 0, 1, -1, -28800))
+        eq(utils.parsedate_tz('5 Feb 2003 13.47 -0800'),
+           (2003, 2, 5, 13, 47, 0, 0, 1, -1, -28800))
+
+    def test_parsedate_rfc_850(self):
+        self.assertEqual(utils.parsedate_tz('Friday, 19-Nov-82 16:14:55 EST'),
+           (1982, 11, 19, 16, 14, 55, 0, 1, -1, -18000))
+
+    def test_parsedate_no_seconds(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14:58 +0800'),
+                         (2002, 4, 3, 14, 58, 0, 0, 1, -1, 28800))
+
+    def test_parsedate_dot_time_delimiter(self):
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58.26 +0800'),
+                         (2002, 4, 3, 14, 58, 26, 0, 1, -1, 28800))
+        self.assertEqual(utils.parsedate_tz('Wed, 3 Apr 2002 14.58 +0800'),
+                         (2002, 4, 3, 14, 58, 0, 0, 1, -1, 28800))
+
+    def test_parsedate_acceptable_to_time_functions(self):
+        eq = self.assertEqual
+        timetup = utils.parsedate('5 Feb 2003 13:47:26 -0800')
+        t = int(time.mktime(timetup))
+        eq(time.localtime(t)[:6], timetup[:6])
+        eq(int(time.strftime('%Y', timetup)), 2003)
+        timetup = utils.parsedate_tz('5 Feb 2003 13:47:26 -0800')
+        t = int(time.mktime(timetup[:9]))
+        eq(time.localtime(t)[:6], timetup[:6])
+        eq(int(time.strftime('%Y', timetup[:9])), 2003)
+
+    def test_mktime_tz(self):
+        self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
+                                          -1, -1, -1, 0)), 0)
+        self.assertEqual(utils.mktime_tz((1970, 1, 1, 0, 0, 0,
+                                          -1, -1, -1, 1234)), -1234)
+
+    def test_parsedate_y2k(self):
+        """Test for parsing a date with a two-digit year.
+
+        Parsing a date with a two-digit year should return the correct
+        four-digit year. RFC 822 allows two-digit years, but RFC 5322 (which
+        obsoletes RFC 2822, which obsoletes RFC 822) requires four-digit years.
+
+        """
+        self.assertEqual(utils.parsedate_tz('25 Feb 03 13:47:26 -0800'),
+                         utils.parsedate_tz('25 Feb 2003 13:47:26 -0800'))
+        self.assertEqual(utils.parsedate_tz('25 Feb 71 13:47:26 -0800'),
+                         utils.parsedate_tz('25 Feb 1971 13:47:26 -0800'))
+
+    def test_parseaddr_empty(self):
+        self.assertEqual(utils.parseaddr('<>'), ('', ''))
+        self.assertEqual(utils.formataddr(utils.parseaddr('<>')), '')
+
+    def test_parseaddr_multiple_domains(self):
+        self.assertEqual(
+            utils.parseaddr('a@b@c'),
+            ('', '')
+        )
+        self.assertEqual(
+            utils.parseaddr('a@b.c@c'),
+            ('', '')
+        )
+        self.assertEqual(
+            utils.parseaddr('a@172.17.0.1@c'),
+            ('', '')
+        )
+
+    def test_noquote_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A Silly Person', 'person@dom.ain')),
+            'A Silly Person <person@dom.ain>')
+
+    def test_escape_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A (Very) Silly Person', 'person@dom.ain')),
+            r'"A (Very) Silly Person" <person@dom.ain>')
+        self.assertEqual(
+            utils.parseaddr(r'"A \(Very\) Silly Person" <person@dom.ain>'),
+            ('A (Very) Silly Person', 'person@dom.ain'))
+        a = r'A \(Special\) Person'
+        b = 'person@dom.ain'
+        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
+
+    def test_escape_backslashes(self):
+        self.assertEqual(
+            utils.formataddr((r'Arthur \Backslash\ Foobar', 'person@dom.ain')),
+            r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>')
+        a = r'Arthur \Backslash\ Foobar'
+        b = 'person@dom.ain'
+        self.assertEqual(utils.parseaddr(utils.formataddr((a, b))), (a, b))
+
+    def test_quotes_unicode_names(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        utf8_base64 = "=?utf-8?b?SMOkbnMgV8O8cnN0?= <person@dom.ain>"
+        latin1_quopri = "=?iso-8859-1?q?H=E4ns_W=FCrst?= <person@dom.ain>"
+        self.assertEqual(utils.formataddr((name, addr)), utf8_base64)
+        self.assertEqual(utils.formataddr((name, addr), 'iso-8859-1'),
+            latin1_quopri)
+
+    def test_accepts_any_charset_like_object(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        utf8_base64 = "=?utf-8?b?SMOkbnMgV8O8cnN0?= <person@dom.ain>"
+        foobar = "FOOBAR"
+        class CharsetMock:
+            def header_encode(self, string):
+                return foobar
+        mock = CharsetMock()
+        mock_expected = "%s <%s>" % (foobar, addr)
+        self.assertEqual(utils.formataddr((name, addr), mock), mock_expected)
+        self.assertEqual(utils.formataddr((name, addr), Charset('utf-8')),
+            utf8_base64)
+
+    def test_invalid_charset_like_object_raises_error(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        name = "H\u00e4ns W\u00fcrst"
+        addr = 'person@dom.ain'
+        # An object without a header_encode method:
+        bad_charset = object()
+        self.assertRaises(AttributeError, utils.formataddr, (name, addr),
+            bad_charset)
+
+    def test_unicode_address_raises_error(self):
+        # issue 1690608.  email.utils.formataddr() should be RFC 2047 aware.
+        addr = 'pers\u00f6n@dom.in'
+        self.assertRaises(UnicodeError, utils.formataddr, (None, addr))
+        self.assertRaises(UnicodeError, utils.formataddr, ("Name", addr))
+
+    def test_name_with_dot(self):
+        x = 'John X. Doe <jxd@example.com>'
+        y = '"John X. Doe" <jxd@example.com>'
+        a, b = ('John X. Doe', 'jxd@example.com')
+        self.assertEqual(utils.parseaddr(x), (a, b))
+        self.assertEqual(utils.parseaddr(y), (a, b))
+        # formataddr() quotes the name if there's a dot in it
+        self.assertEqual(utils.formataddr((a, b)), y)
+
+    def test_parseaddr_preserves_quoted_pairs_in_addresses(self):
+        # issue 10005.  Note that in the third test the second pair of
+        # backslashes is not actually a quoted pair because it is not inside a
+        # comment or quoted string: the address being parsed has a quoted
+        # string containing a quoted backslash, followed by 'example' and two
+        # backslashes, followed by another quoted string containing a space and
+        # the word 'example'.  parseaddr copies those two backslashes
+        # literally.  Per RFC 5322 this is not technically correct since a \ may
+        # not appear in an address outside of a quoted string.  It is probably
+        # a sensible Postel interpretation, though.
+        eq = self.assertEqual
+        eq(utils.parseaddr('""example" example"@example.com'),
+          ('', '""example" example"@example.com'))
+        eq(utils.parseaddr('"\\"example\\" example"@example.com'),
+          ('', '"\\"example\\" example"@example.com'))
+        eq(utils.parseaddr('"\\\\"example\\\\" example"@example.com'),
+          ('', '"\\\\"example\\\\" example"@example.com'))
+
+    def test_parseaddr_preserves_spaces_in_local_part(self):
+        # issue 9286.  A normal RFC 5322 local part should not contain any
+        # folding white space, but legacy local parts can (they are a sequence
+        # of atoms, not dotatoms).  On the other hand we strip whitespace from
+        # before the @ and around dots, on the assumption that the whitespace
+        # around the punctuation is a mistake in what would otherwise be
+        # an RFC 5322 local part.  Leading whitespace is, usual, stripped as well.
+        self.assertEqual(('', "merwok wok@xample.com"),
+            utils.parseaddr("merwok wok@xample.com"))
+        self.assertEqual(('', "merwok  wok@xample.com"),
+            utils.parseaddr("merwok  wok@xample.com"))
+        self.assertEqual(('', "merwok  wok@xample.com"),
+            utils.parseaddr(" merwok  wok  @xample.com"))
+        self.assertEqual(('', 'merwok"wok"  wok@xample.com'),
+            utils.parseaddr('merwok"wok"  wok@xample.com'))
+        self.assertEqual(('', 'merwok.wok.wok@xample.com'),
+            utils.parseaddr('merwok. wok .  wok@xample.com'))
+
+    def test_formataddr_does_not_quote_parens_in_quoted_string(self):
+        addr = ("'foo@example.com' (foo@example.com)",
+                'foo@example.com')
+        addrstr = ('"\'foo@example.com\' '
+                            '(foo@example.com)" <foo@example.com>')
+        self.assertEqual(utils.parseaddr(addrstr), addr)
+        self.assertEqual(utils.formataddr(addr), addrstr)
+
+
+    def test_multiline_from_comment(self):
+        x = """\
+Foo
+\tBar <foo@example.com>"""
+        self.assertEqual(utils.parseaddr(x), ('Foo Bar', 'foo@example.com'))
+
+    def test_quote_dump(self):
+        self.assertEqual(
+            utils.formataddr(('A Silly; Person', 'person@dom.ain')),
+            r'"A Silly; Person" <person@dom.ain>')
+
+    def test_charset_richcomparisons(self):
+        eq = self.assertEqual
+        ne = self.assertNotEqual
+        cset1 = Charset()
+        cset2 = Charset()
+        eq(cset1, 'us-ascii')
+        eq(cset1, 'US-ASCII')
+        eq(cset1, 'Us-AsCiI')
+        eq('us-ascii', cset1)
+        eq('US-ASCII', cset1)
+        eq('Us-AsCiI', cset1)
+        ne(cset1, 'usascii')
+        ne(cset1, 'USASCII')
+        ne(cset1, 'UsAsCiI')
+        ne('usascii', cset1)
+        ne('USASCII', cset1)
+        ne('UsAsCiI', cset1)
+        eq(cset1, cset2)
+        eq(cset2, cset1)
+
+    def test_getaddresses(self):
+        eq = self.assertEqual
+        eq(utils.getaddresses(['aperson@dom.ain (Al Person)',
+                               'Bud Person <bperson@dom.ain>']),
+           [('Al Person', 'aperson@dom.ain'),
+            ('Bud Person', 'bperson@dom.ain')])
+
+    def test_getaddresses_comma_in_name(self):
+        """GH-106669 regression test."""
+        self.assertEqual(
+            utils.getaddresses(
+                [
+                    '"Bud, Person" <bperson@dom.ain>',
+                    'aperson@dom.ain (Al Person)',
+                    '"Mariusz Felisiak" <to@example.com>',
+                ]
+            ),
+            [
+                ('Bud, Person', 'bperson@dom.ain'),
+                ('Al Person', 'aperson@dom.ain'),
+                ('Mariusz Felisiak', 'to@example.com'),
+            ],
+        )
+
+    def test_parsing_errors(self):
+        """Test for parsing errors from CVE-2023-27043 and CVE-2019-16056"""
+        alice = 'alice@example.org'
+        bob = 'bob@example.com'
+        empty = ('', '')
+
+        # Test utils.getaddresses() and utils.parseaddr() on malformed email
+        # addresses: default behavior (strict=True) rejects malformed address,
+        # and strict=False which tolerates malformed address.
+        for invalid_separator, expected_non_strict in (
+            ('(', [(f'<{bob}>', alice)]),
+            (')', [('', alice), empty, ('', bob)]),
+            ('<', [('', alice), empty, ('', bob), empty]),
+            ('>', [('', alice), empty, ('', bob)]),
+            ('[', [('', f'{alice}[<{bob}>]')]),
+            (']', [('', alice), empty, ('', bob)]),
+            ('@', [empty, empty, ('', bob)]),
+            (';', [('', alice), empty, ('', bob)]),
+            (':', [('', alice), ('', bob)]),
+            ('.', [('', alice + '.'), ('', bob)]),
+            ('"', [('', alice), ('', f'<{bob}>')]),
+        ):
+            address = f'{alice}{invalid_separator}<{bob}>'
+            with self.subTest(address=address):
+                self.assertEqual(utils.getaddresses([address]),
+                                 [empty])
+                self.assertEqual(utils.getaddresses([address], strict=False),
+                                 expected_non_strict)
+
+                self.assertEqual(utils.parseaddr([address]),
+                                 empty)
+                self.assertEqual(utils.parseaddr([address], strict=False),
+                                 ('', address))
+
+        # Comma (',') is treated differently depending on strict parameter.
+        # Comma without quotes.
+        address = f'{alice},<{bob}>'
+        self.assertEqual(utils.getaddresses([address]),
+                         [('', alice), ('', bob)])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('', alice), ('', bob)])
+        self.assertEqual(utils.parseaddr([address]),
+                         empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Real name between quotes containing comma.
+        address = '"Alice, alice@example.org" <bob@example.com>'
+        expected_strict = ('Alice, alice@example.org', 'bob@example.com')
+        self.assertEqual(utils.getaddresses([address]), [expected_strict])
+        self.assertEqual(utils.getaddresses([address], strict=False), [expected_strict])
+        self.assertEqual(utils.parseaddr([address]), expected_strict)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Valid parenthesis in comments.
+        address = 'alice@example.org (Alice)'
+        expected_strict = ('Alice', 'alice@example.org')
+        self.assertEqual(utils.getaddresses([address]), [expected_strict])
+        self.assertEqual(utils.getaddresses([address], strict=False), [expected_strict])
+        self.assertEqual(utils.parseaddr([address]), expected_strict)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Invalid parenthesis in comments.
+        address = 'alice@example.org )Alice('
+        self.assertEqual(utils.getaddresses([address]), [empty])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('', 'alice@example.org'), ('', ''), ('', 'Alice')])
+        self.assertEqual(utils.parseaddr([address]), empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Two addresses with quotes separated by comma.
+        address = '"Jane Doe" <jane@example.net>, "John Doe" <john@example.net>'
+        self.assertEqual(utils.getaddresses([address]),
+                         [('Jane Doe', 'jane@example.net'),
+                          ('John Doe', 'john@example.net')])
+        self.assertEqual(utils.getaddresses([address], strict=False),
+                         [('Jane Doe', 'jane@example.net'),
+                          ('John Doe', 'john@example.net')])
+        self.assertEqual(utils.parseaddr([address]), empty)
+        self.assertEqual(utils.parseaddr([address], strict=False),
+                         ('', address))
+
+        # Test email.utils.supports_strict_parsing attribute
+        self.assertEqual(email.utils.supports_strict_parsing, True)
+
+    def test_getaddresses_nasty(self):
+        for addresses, expected in (
+            (['"Sürname, Firstname" <to@example.com>'],
+             [('Sürname, Firstname', 'to@example.com')]),
+
+            (['foo: ;'],
+             [('', '')]),
+
+            (['foo: ;', '"Jason R. Mastaler" <jason@dom.ain>'],
+             [('', ''), ('Jason R. Mastaler', 'jason@dom.ain')]),
+
+            ([r'Pete(A nice \) chap) <pete(his account)@silly.test(his host)>'],
+             [('Pete (A nice ) chap his account his host)', 'pete@silly.test')]),
+
+            (['(Empty list)(start)Undisclosed recipients  :(nobody(I know))'],
+             [('', '')]),
+
+            (['Mary <@machine.tld:mary@example.net>, , jdoe@test   . example'],
+             [('Mary', 'mary@example.net'), ('', ''), ('', 'jdoe@test.example')]),
+
+            (['John Doe <jdoe@machine(comment).  example>'],
+             [('John Doe (comment)', 'jdoe@machine.example')]),
+
+            (['"Mary Smith: Personal Account" <smith@home.example>'],
+             [('Mary Smith: Personal Account', 'smith@home.example')]),
+
+            (['Undisclosed recipients:;'],
+             [('', '')]),
+
+            ([r'<boss@nil.test>, "Giant; \"Big\" Box" <bob@example.net>'],
+             [('', 'boss@nil.test'), ('Giant; "Big" Box', 'bob@example.net')]),
+        ):
+            with self.subTest(addresses=addresses):
+                self.assertEqual(utils.getaddresses(addresses),
+                                 expected)
+                self.assertEqual(utils.getaddresses(addresses, strict=False),
+                                 expected)
+
+        addresses = ['[]*-- =~$']
+        self.assertEqual(utils.getaddresses(addresses),
+                         [('', '')])
+        self.assertEqual(utils.getaddresses(addresses, strict=False),
+                         [('', ''), ('', ''), ('', '*--')])
+
+    def test_getaddresses_embedded_comment(self):
+        """Test proper handling of a nested comment"""
+        eq = self.assertEqual
+        addrs = utils.getaddresses(['User ((nested comment)) <foo@bar.com>'])
+        eq(addrs[0][1], 'foo@bar.com')
+
+    def test_getaddresses_header_obj(self):
+        """Test the handling of a Header object."""
+        addrs = utils.getaddresses([Header('Al Person <aperson@dom.ain>')])
+        self.assertEqual(addrs[0][1], 'aperson@dom.ain')
+
+    @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
+    def test_make_msgid_collisions(self):
+        # Test make_msgid uniqueness, even with multiple threads
+        class MsgidsThread(Thread):
+            def run(self):
+                # generate msgids for 3 seconds
+                self.msgids = []
+                append = self.msgids.append
+                make_msgid = utils.make_msgid
+                clock = time.monotonic
+                tfin = clock() + 3.0
+                while clock() < tfin:
+                    append(make_msgid(domain='testdomain-string'))
+
+        threads = [MsgidsThread() for i in range(5)]
+        with threading_helper.start_threads(threads):
+            pass
+        all_ids = sum([t.msgids for t in threads], [])
+        self.assertEqual(len(set(all_ids)), len(all_ids))
+
+    def test_utils_quote_unquote(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg.add_header('content-disposition', 'attachment',
+                       filename='foo\\wacky"name')
+        eq(msg.get_filename(), 'foo\\wacky"name')
+
+    def test_get_body_encoding_with_bogus_charset(self):
+        charset = Charset('not a charset')
+        self.assertEqual(charset.get_body_encoding(), 'base64')
+
+    def test_get_body_encoding_with_uppercase_charset(self):
+        eq = self.assertEqual
+        msg = Message()
+        msg['Content-Type'] = 'text/plain; charset=UTF-8'
+        eq(msg['content-type'], 'text/plain; charset=UTF-8')
+        charsets = msg.get_charsets()
+        eq(len(charsets), 1)
+        eq(charsets[0], 'utf-8')
+        charset = Charset(charsets[0])
+        eq(charset.get_body_encoding(), 'base64')
+        msg.set_payload(b'hello world', charset=charset)
+        eq(msg.get_payload(), 'aGVsbG8gd29ybGQ=\n')
+        eq(msg.get_payload(decode=True), b'hello world')
+        eq(msg['content-transfer-encoding'], 'base64')
+        # Try another one
+        msg = Message()
+        msg['Content-Type'] = 'text/plain; charset="US-ASCII"'
+        charsets = msg.get_charsets()
+        eq(len(charsets), 1)
+        eq(charsets[0], 'us-ascii')
+        charset = Charset(charsets[0])
+        eq(charset.get_body_encoding(), encoders.encode_7or8bit)
+        msg.set_payload('hello world', charset=charset)
+        eq(msg.get_payload(), 'hello world')
+        eq(msg['content-transfer-encoding'], '7bit')
+
+    def test_charsets_case_insensitive(self):
+        lc = Charset('us-ascii')
+        uc = Charset('US-ASCII')
+        self.assertEqual(lc.get_body_encoding(), uc.get_body_encoding())
+
+    def test_partial_falls_inside_message_delivery_status(self):
+        eq = self.ndiffAssertEqual
+        # The Parser interface provides chunks of data to FeedParser in 8192
+        # byte gulps.  SF bug #1076485 found one of those chunks inside
+        # message/delivery-status header block, which triggered an
+        # unreadline() of NeedMoreData.
+        msg = self._msgobj('msg_43.txt')
+        sfp = StringIO()
+        iterators._structure(msg, sfp)
+        eq(sfp.getvalue(), """\
+multipart/report
+    text/plain
+    message/delivery-status
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+        text/plain
+    text/rfc822-headers
+""")
+
+    def test_make_msgid_domain(self):
+        self.assertEqual(
+            email.utils.make_msgid(domain='testdomain-string')[-19:],
+            '@testdomain-string>')
+
+    def test_make_msgid_idstring(self):
+        self.assertEqual(
+            email.utils.make_msgid(idstring='test-idstring',
+                domain='testdomain-string')[-33:],
+            '.test-idstring@testdomain-string>')
+
+    def test_make_msgid_default_domain(self):
+        with patch('socket.getfqdn') as mock_getfqdn:
+            mock_getfqdn.return_value = domain = 'pythontest.example.com'
+            self.assertEndsWith(email.utils.make_msgid(), '@' + domain + '>')
+
+    def test_Generator_linend(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as f:
+            msgtxt = f.read()
+        msgtxt_nl = msgtxt.replace('\r\n', '\n')
+        msg = email.message_from_string(msgtxt)
+        s = StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), msgtxt_nl)
+
+    def test_BytesGenerator_linend(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as f:
+            msgtxt = f.read()
+        msgtxt_nl = msgtxt.replace('\r\n', '\n')
+        msg = email.message_from_string(msgtxt_nl)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue().decode('ascii'), msgtxt)
+
+    def test_BytesGenerator_linend_with_non_ascii(self):
+        # Issue 14645.
+        with openfile('msg_26.txt', 'rb') as f:
+            msgtxt = f.read()
+        msgtxt = msgtxt.replace(b'with attachment', b'fo\xf6')
+        msgtxt_nl = msgtxt.replace(b'\r\n', b'\n')
+        msg = email.message_from_bytes(msgtxt_nl)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), msgtxt)
+
+    def test_mime_classes_policy_argument(self):
+        with openfile('sndhdr.au', 'rb') as fp:
+            audiodata = fp.read()
+        with openfile('python.gif', 'rb') as fp:
+            bindata = fp.read()
+        classes = [
+            (MIMEApplication, ('',)),
+            (MIMEAudio, (audiodata,)),
+            (MIMEImage, (bindata,)),
+            (MIMEMessage, (Message(),)),
+            (MIMENonMultipart, ('multipart', 'mixed')),
+            (MIMEText, ('',)),
+        ]
+        for cls, constructor in classes:
+            with self.subTest(cls=cls.__name__, policy='compat32'):
+                m = cls(*constructor)
+                self.assertIs(m.policy, email.policy.compat32)
+            with self.subTest(cls=cls.__name__, policy='default'):
+                m = cls(*constructor, policy=email.policy.default)
+                self.assertIs(m.policy, email.policy.default)
+
+    def test_iter_escaped_chars(self):
+        self.assertEqual(list(utils._iter_escaped_chars(r'a\\b\"c\\"d')),
+                         [(0, 'a'),
+                          (2, '\\\\'),
+                          (3, 'b'),
+                          (5, '\\"'),
+                          (6, 'c'),
+                          (8, '\\\\'),
+                          (9, '"'),
+                          (10, 'd')])
+        self.assertEqual(list(utils._iter_escaped_chars('a\\')),
+                         [(0, 'a'), (1, '\\')])
+
+    def test_strip_quoted_realnames(self):
+        def check(addr, expected):
+            self.assertEqual(utils._strip_quoted_realnames(addr), expected)
+
+        check('"Jane Doe" <jane@example.net>, "John Doe" <john@example.net>',
+              ' <jane@example.net>,  <john@example.net>')
+        check(r'"Jane \"Doe\"." <jane@example.net>',
+              ' <jane@example.net>')
+
+        # special cases
+        check(r'before"name"after', 'beforeafter')
+        check(r'before"name"', 'before')
+        check(r'b"name"', 'b')  # single char
+        check(r'"name"after', 'after')
+        check(r'"name"a', 'a')  # single char
+        check(r'"name"', '')
+
+        # no change
+        for addr in (
+            'Jane Doe <jane@example.net>, John Doe <john@example.net>',
+            'lone " quote',
+        ):
+            self.assertEqual(utils._strip_quoted_realnames(addr), addr)
+
+
+    def test_check_parenthesis(self):
+        addr = 'alice@example.net'
+        self.assertTrue(utils._check_parenthesis(f'{addr} (Alice)'))
+        self.assertFalse(utils._check_parenthesis(f'{addr} )Alice('))
+        self.assertFalse(utils._check_parenthesis(f'{addr} (Alice))'))
+        self.assertFalse(utils._check_parenthesis(f'{addr} ((Alice)'))
+
+        # Ignore real name between quotes
+        self.assertTrue(utils._check_parenthesis(f'")Alice((" {addr}'))
+
+
+# Test the iterator/generators
+class TestIterators(TestEmailBase):
+    def test_body_line_iterator(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        # First a simple non-multipart message
+        msg = self._msgobj('msg_01.txt')
+        it = iterators.body_line_iterator(msg)
+        lines = list(it)
+        eq(len(lines), 6)
+        neq(EMPTYSTRING.join(lines), msg.get_payload())
+        # Now a more complicated multipart
+        msg = self._msgobj('msg_02.txt')
+        it = iterators.body_line_iterator(msg)
+        lines = list(it)
+        eq(len(lines), 43)
+        with openfile('msg_19.txt', encoding="utf-8") as fp:
+            neq(EMPTYSTRING.join(lines), fp.read())
+
+    def test_typed_subpart_iterator(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_04.txt')
+        it = iterators.typed_subpart_iterator(msg, 'text')
+        lines = []
+        subparts = 0
+        for subpart in it:
+            subparts += 1
+            lines.append(subpart.get_payload())
+        eq(subparts, 2)
+        eq(EMPTYSTRING.join(lines), """\
+a simple kind of mirror
+to reflect upon our own
+a simple kind of mirror
+to reflect upon our own
+""")
+
+    def test_typed_subpart_iterator_default_type(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_03.txt')
+        it = iterators.typed_subpart_iterator(msg, 'text', 'plain')
+        lines = []
+        subparts = 0
+        for subpart in it:
+            subparts += 1
+            lines.append(subpart.get_payload())
+        eq(subparts, 1)
+        eq(EMPTYSTRING.join(lines), """\
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_pushCR_LF(self):
+        '''FeedParser BufferedSubFile.push() assumed it received complete
+           line endings.  A CR ending one push() followed by a LF starting
+           the next push() added an empty line.
+        '''
+        imt = [
+            ("a\r \n",  2),
+            ("b",       0),
+            ("c\n",     1),
+            ("",        0),
+            ("d\r\n",   1),
+            ("e\r",     0),
+            ("\nf",     1),
+            ("\r\n",    1),
+          ]
+        from email.feedparser import BufferedSubFile, NeedMoreData
+        bsf = BufferedSubFile()
+        om = []
+        nt = 0
+        for il, n in imt:
+            bsf.push(il)
+            nt += n
+            n1 = 0
+            for ol in iter(bsf.readline, NeedMoreData):
+                om.append(ol)
+                n1 += 1
+            self.assertEqual(n, n1)
+        self.assertEqual(len(om), nt)
+        self.assertEqual(''.join([il for il, n in imt]), ''.join(om))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_push_random(self):
+        from email.feedparser import BufferedSubFile, NeedMoreData
+
+        n = 10000
+        chunksize = 5
+        chars = 'abcd \t\r\n'
+
+        s = ''.join(choice(chars) for i in range(n)) + '\n'
+        target = s.splitlines(True)
+
+        bsf = BufferedSubFile()
+        lines = []
+        for i in range(0, len(s), chunksize):
+            chunk = s[i:i+chunksize]
+            bsf.push(chunk)
+            lines.extend(iter(bsf.readline, NeedMoreData))
+        self.assertEqual(lines, target)
+
+
+class TestFeedParsers(TestEmailBase):
+
+    def parse(self, chunks):
+        feedparser = FeedParser()
+        for chunk in chunks:
+            feedparser.feed(chunk)
+        return feedparser.close()
+
+    def test_empty_header_name_handled(self):
+        # Issue 19996
+        msg = self.parse("First: val\n: bad\nSecond: val")
+        self.assertEqual(msg['First'], 'val')
+        self.assertEqual(msg['Second'], 'val')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; Feedparser.feed -> Feedparser._input.push, Feedparser._call_parse -> Feedparser._parse does not keep _input state between calls
+    def test_newlines(self):
+        m = self.parse(['a:\nb:\rc:\r\nd:\n'])
+        self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
+        m = self.parse(['a:\nb:\rc:\r\nd:'])
+        self.assertEqual(m.keys(), ['a', 'b', 'c', 'd'])
+        m = self.parse(['a:\rb', 'c:\n'])
+        self.assertEqual(m.keys(), ['a', 'bc'])
+        m = self.parse(['a:\r', 'b:\n'])
+        self.assertEqual(m.keys(), ['a', 'b'])
+        m = self.parse(['a:\r', '\nb:\n'])
+        self.assertEqual(m.keys(), ['a', 'b'])
+
+        # Only CR and LF should break header fields
+        m = self.parse(['a:\x85b:\u2028c:\n'])
+        self.assertEqual(m.items(), [('a', '\x85b:\u2028c:')])
+        m = self.parse(['a:\r', 'b:\x85', 'c:\n'])
+        self.assertEqual(m.items(), [('a', ''), ('b', '\x85c:')])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_long_lines(self):
+        # Expected peak memory use on 32-bit platform: 6*N*M bytes.
+        M, N = 1000, 20000
+        m = self.parse(['a:b\n\n'] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), 'x'*M*N)
+        m = self.parse(['a:b\r\r'] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), 'x'*M*N)
+        m = self.parse(['a:b\r\r'] + ['x'*M+'\x85'] * N)
+        self.assertEqual(m.items(), [('a', 'b')])
+        self.assertEqual(m.get_payload(), ('x'*M+'\x85')*N)
+        m = self.parse(['a:\r', 'b: '] + ['x'*M] * N)
+        self.assertEqual(m.items(), [('a', ''), ('b', 'x'*M*N)])
+
+
+class TestParsers(TestEmailBase):
+
+    def test_header_parser(self):
+        eq = self.assertEqual
+        # Parse only the headers of a complex multipart MIME document
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            msg = HeaderParser().parse(fp)
+        eq(msg['from'], 'ppp-request@zzz.org')
+        eq(msg['to'], 'ppp@zzz.org')
+        eq(msg.get_content_type(), 'multipart/mixed')
+        self.assertFalse(msg.is_multipart())
+        self.assertIsInstance(msg.get_payload(), str)
+
+    def test_bytes_header_parser(self):
+        eq = self.assertEqual
+        # Parse only the headers of a complex multipart MIME document
+        with openfile('msg_02.txt', 'rb') as fp:
+            msg = email.parser.BytesHeaderParser().parse(fp)
+        eq(msg['from'], 'ppp-request@zzz.org')
+        eq(msg['to'], 'ppp@zzz.org')
+        eq(msg.get_content_type(), 'multipart/mixed')
+        self.assertFalse(msg.is_multipart())
+        self.assertIsInstance(msg.get_payload(), str)
+        self.assertIsInstance(msg.get_payload(decode=True), bytes)
+
+    def test_header_parser_multipart_is_valid(self):
+        # Don't flag valid multipart emails as having defects
+        with openfile('msg_47.txt', encoding="utf-8") as fp:
+            msgdata = fp.read()
+
+        parser = email.parser.Parser(policy=email.policy.default)
+        parsed_msg = parser.parsestr(msgdata, headersonly=True)
+
+        self.assertEqual(parsed_msg.defects, [])
+
+    def test_bytes_parser_does_not_close_file(self):
+        with openfile('msg_02.txt', 'rb') as fp:
+            email.parser.BytesParser().parse(fp)
+            self.assertFalse(fp.closed)
+
+    def test_bytes_parser_on_exception_does_not_close_file(self):
+        with openfile('msg_15.txt', 'rb') as fp:
+            bytesParser = email.parser.BytesParser
+            self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
+                              bytesParser(policy=email.policy.strict).parse,
+                              fp)
+            self.assertFalse(fp.closed)
+
+    def test_parser_does_not_close_file(self):
+        with openfile('msg_02.txt', encoding="utf-8") as fp:
+            email.parser.Parser().parse(fp)
+            self.assertFalse(fp.closed)
+
+    def test_parser_on_exception_does_not_close_file(self):
+        with openfile('msg_15.txt', encoding="utf-8") as fp:
+            parser = email.parser.Parser
+            self.assertRaises(email.errors.StartBoundaryNotFoundDefect,
+                              parser(policy=email.policy.strict).parse, fp)
+            self.assertFalse(fp.closed)
+
+    def test_whitespace_continuation(self):
+        eq = self.assertEqual
+        # This message contains a line after the Subject: header that has only
+        # whitespace, but it is not empty!
+        msg = email.message_from_string("""\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Subject: the next line has a space on it
+\x20
+Date: Mon, 8 Apr 2002 15:09:19 -0400
+Message-ID: spam
+
+Here's the message body
+""")
+        eq(msg['subject'], 'the next line has a space on it\n ')
+        eq(msg['message-id'], 'spam')
+        eq(msg.get_payload(), "Here's the message body\n")
+
+    def test_whitespace_continuation_last_header(self):
+        eq = self.assertEqual
+        # Like the previous test, but the subject line is the last
+        # header.
+        msg = email.message_from_string("""\
+From: aperson@dom.ain
+To: bperson@dom.ain
+Date: Mon, 8 Apr 2002 15:09:19 -0400
+Message-ID: spam
+Subject: the next line has a space on it
+\x20
+
+Here's the message body
+""")
+        eq(msg['subject'], 'the next line has a space on it\n ')
+        eq(msg['message-id'], 'spam')
+        eq(msg.get_payload(), "Here's the message body\n")
+
+    def test_crlf_separation(self):
+        eq = self.assertEqual
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as fp:
+            msg = Parser().parse(fp)
+        eq(len(msg.get_payload()), 2)
+        part1 = msg.get_payload(0)
+        eq(part1.get_content_type(), 'text/plain')
+        eq(part1.get_payload(), 'Simple email with attachment.\r\n\r\n')
+        part2 = msg.get_payload(1)
+        eq(part2.get_content_type(), 'application/riscos')
+
+    def test_crlf_flatten(self):
+        # Using newline='\n' preserves the crlfs in this input file.
+        with openfile('msg_26.txt', encoding="utf-8", newline='\n') as fp:
+            text = fp.read()
+        msg = email.message_from_string(text)
+        s = StringIO()
+        g = Generator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), text)
+
+    maxDiff = None
+
+    def test_multipart_digest_with_extra_mime_headers(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        with openfile('msg_28.txt', encoding="utf-8") as fp:
+            msg = email.message_from_file(fp)
+        # Structure is:
+        # multipart/digest
+        #   message/rfc822
+        #     text/plain
+        #   message/rfc822
+        #     text/plain
+        eq(msg.is_multipart(), 1)
+        eq(len(msg.get_payload()), 2)
+        part1 = msg.get_payload(0)
+        eq(part1.get_content_type(), 'message/rfc822')
+        eq(part1.is_multipart(), 1)
+        eq(len(part1.get_payload()), 1)
+        part1a = part1.get_payload(0)
+        eq(part1a.is_multipart(), 0)
+        eq(part1a.get_content_type(), 'text/plain')
+        neq(part1a.get_payload(), 'message 1\n')
+        # next message/rfc822
+        part2 = msg.get_payload(1)
+        eq(part2.get_content_type(), 'message/rfc822')
+        eq(part2.is_multipart(), 1)
+        eq(len(part2.get_payload()), 1)
+        part2a = part2.get_payload(0)
+        eq(part2a.is_multipart(), 0)
+        eq(part2a.get_content_type(), 'text/plain')
+        neq(part2a.get_payload(), 'message 2\n')
+
+    def test_three_lines(self):
+        # A bug report by Andrew McNamara
+        lines = ['From: Andrew Person <aperson@dom.ain',
+                 'Subject: Test',
+                 'Date: Tue, 20 Aug 2002 16:43:45 +1000']
+        msg = email.message_from_string(NL.join(lines))
+        self.assertEqual(msg['date'], 'Tue, 20 Aug 2002 16:43:45 +1000')
+
+    def test_strip_line_feed_and_carriage_return_in_headers(self):
+        eq = self.assertEqual
+        # For [ 1002475 ] email message parser doesn't handle \r\n correctly
+        value1 = 'text'
+        value2 = 'more text'
+        m = 'Header: %s\r\nNext-Header: %s\r\n\r\nBody\r\n\r\n' % (
+            value1, value2)
+        msg = email.message_from_string(m)
+        eq(msg.get('Header'), value1)
+        eq(msg.get('Next-Header'), value2)
+
+    def test_rfc2822_header_syntax(self):
+        eq = self.assertEqual
+        m = '>From: foo\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
+        msg = email.message_from_string(m)
+        eq(len(msg), 3)
+        eq(sorted(field for field in msg), ['!"#QUX;~', '>From', 'From'])
+        eq(msg.get_payload(), 'body')
+
+    def test_rfc2822_space_not_allowed_in_header(self):
+        eq = self.assertEqual
+        m = '>From foo@example.com 11:25:53\nFrom: bar\n!"#QUX;~: zoo\n\nbody'
+        msg = email.message_from_string(m)
+        eq(len(msg.keys()), 0)
+
+    def test_rfc2822_one_character_header(self):
+        eq = self.assertEqual
+        m = 'A: first header\nB: second header\nCC: third header\n\nbody'
+        msg = email.message_from_string(m)
+        headers = msg.keys()
+        headers.sort()
+        eq(headers, ['A', 'B', 'CC'])
+        eq(msg.get_payload(), 'body')
+
+    def test_CRLFLF_at_end_of_part(self):
+        # issue 5610: feedparser should not eat two chars from body part ending
+        # with "\r\n\n".
+        m = (
+            "From: foo@bar.com\n"
+            "To: baz\n"
+            "Mime-Version: 1.0\n"
+            "Content-Type: multipart/mixed; boundary=BOUNDARY\n"
+            "\n"
+            "--BOUNDARY\n"
+            "Content-Type: text/plain\n"
+            "\n"
+            "body ending with CRLF newline\r\n"
+            "\n"
+            "--BOUNDARY--\n"
+          )
+        msg = email.message_from_string(m)
+        self.assertEndsWith(msg.get_payload(0).get_payload(), '\r\n')
+
+
+class Test8BitBytesHandling(TestEmailBase):
+    # In Python3 all input is string, but that doesn't work if the actual input
+    # uses an 8bit transfer encoding.  To hack around that, in email 5.1 we
+    # decode byte streams using the surrogateescape error handler, and
+    # reconvert to binary at appropriate places if we detect surrogates.  This
+    # doesn't allow us to transform headers with 8bit bytes (they get munged),
+    # but it does allow us to parse and preserve them, and to decode body
+    # parts that use an 8bit CTE.
+
+    bodytest_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: baz
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset={charset}
+        Content-Transfer-Encoding: {cte}
+
+        {bodyline}
+        """)
+
+    def test_known_8bit_CTE(self):
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='8bit',
+                                     bodyline='pöstal').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "pöstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+    def test_unknown_8bit_CTE(self):
+        m = self.bodytest_msg.format(charset='notavalidcharset',
+                                     cte='8bit',
+                                     bodyline='pöstal').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "p\uFFFD\uFFFDstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+    def test_8bit_in_quopri_body(self):
+        # This is non-RFC compliant data...without 'decode' the library code
+        # decodes the body using the charset from the headers, and because the
+        # source byte really is utf-8 this works.  This is likely to fail
+        # against real dirty data (ie: produce mojibake), but the data is
+        # invalid anyway so it is as good a guess as any.  But this means that
+        # this test just confirms the current behavior; that behavior is not
+        # necessarily the best possible behavior.  With 'decode' it is
+        # returning the raw bytes, so that test should be of correct behavior,
+        # or at least produce the same result that email4 did.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='quoted-printable',
+                                     bodyline='p=C3=B6stál').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), 'p=C3=B6stál\n')
+        self.assertEqual(msg.get_payload(decode=True),
+                         'pöstál\n'.encode('utf-8'))
+
+    def test_invalid_8bit_in_non_8bit_cte_uses_replace(self):
+        # This is similar to the previous test, but proves that if the 8bit
+        # byte is undecodeable in the specified charset, it gets replaced
+        # by the unicode 'unknown' character.  Again, this may or may not
+        # be the ideal behavior.  Note that if decode=False none of the
+        # decoders will get involved, so this is the only test we need
+        # for this behavior.
+        m = self.bodytest_msg.format(charset='ascii',
+                                     cte='quoted-printable',
+                                     bodyline='p=C3=B6stál').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), 'p=C3=B6st\uFFFD\uFFFDl\n')
+        self.assertEqual(msg.get_payload(decode=True),
+                        'pöstál\n'.encode('utf-8'))
+
+    # test_defect_handling:test_invalid_chars_in_base64_payload
+    def test_8bit_in_base64_body(self):
+        # If we get 8bit bytes in a base64 body, we can just ignore them
+        # as being outside the base64 alphabet and decode anyway.  But
+        # we register a defect.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='base64',
+                                     bodyline='cMO2c3RhbAá=').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(decode=True),
+                         'pöstal'.encode('utf-8'))
+        self.assertIsInstance(msg.defects[0],
+                              errors.InvalidBase64CharactersDefect)
+
+    def test_8bit_in_uuencode_body(self):
+        # Sticking an 8bit byte in a uuencode block makes it undecodable by
+        # normal means, so the block is returned undecoded, but as bytes.
+        m = self.bodytest_msg.format(charset='utf-8',
+                                     cte='uuencode',
+                                     bodyline='<,.V<W1A; á ').encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(decode=True),
+                         '<,.V<W1A; á \n'.encode('utf-8'))
+
+    def test_rfc2231_charset_8bit_CTE(self):
+        m = textwrap.dedent("""\
+        From: foo@bar.com
+        To: baz
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset*=ansi-x3.4-1968''utf-8
+        Content-Transfer-Encoding: 8bit
+
+        pöstal
+        """).encode('utf-8')
+        msg = email.message_from_bytes(m)
+        self.assertEqual(msg.get_payload(), "pöstal\n")
+        self.assertEqual(msg.get_payload(decode=True),
+                         "pöstal\n".encode('utf-8'))
+
+
+    headertest_headers = (
+        ('From: foo@bar.com', ('From', 'foo@bar.com')),
+        ('To: báz', ('To', '=?unknown-8bit?q?b=C3=A1z?=')),
+        ('Subject: Maintenant je vous présente mon collègue, le pouf célèbre\n'
+            '\tJean de Baddie',
+            ('Subject', '=?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
+                'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=\n'
+                ' =?unknown-8bit?q?_Jean_de_Baddie?=')),
+        ('From: göst', ('From', '=?unknown-8bit?b?Z8O2c3Q=?=')),
+        )
+    headertest_msg = ('\n'.join([src for (src, _) in headertest_headers]) +
+        '\nYes, they are flying.\n').encode('utf-8')
+
+    def test_get_8bit_header(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertEqual(str(msg.get('to')), 'b\uFFFD\uFFFDz')
+        self.assertEqual(str(msg['to']), 'b\uFFFD\uFFFDz')
+
+    def test_print_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertEqual(str(msg),
+                         textwrap.dedent("""\
+                            From: {}
+                            To: {}
+                            Subject: {}
+                            From: {}
+
+                            Yes, they are flying.
+                            """).format(*[expected[1] for (_, expected) in
+                                        self.headertest_headers]))
+
+    def test_values_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([str(x) for x in msg.values()],
+                              ['foo@bar.com',
+                               'b\uFFFD\uFFFDz',
+                               'Maintenant je vous pr\uFFFD\uFFFDsente mon '
+                                   'coll\uFFFD\uFFFDgue, le pouf '
+                                   'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
+                                   '\tJean de Baddie',
+                               "g\uFFFD\uFFFDst"])
+
+    def test_items_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([(str(x), str(y)) for (x, y) in msg.items()],
+                              [('From', 'foo@bar.com'),
+                               ('To', 'b\uFFFD\uFFFDz'),
+                               ('Subject', 'Maintenant je vous '
+                                  'pr\uFFFD\uFFFDsente '
+                                  'mon coll\uFFFD\uFFFDgue, le pouf '
+                                  'c\uFFFD\uFFFDl\uFFFD\uFFFDbre\n'
+                                  '\tJean de Baddie'),
+                               ('From', 'g\uFFFD\uFFFDst')])
+
+    def test_get_all_with_8bit_headers(self):
+        msg = email.message_from_bytes(self.headertest_msg)
+        self.assertListEqual([str(x) for x in msg.get_all('from')],
+                              ['foo@bar.com',
+                               'g\uFFFD\uFFFDst'])
+
+    def test_get_content_type_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/pl\xA7in; charset=utf-8
+            """).encode('latin-1'))
+        self.assertEqual(msg.get_content_type(), "text/pl\uFFFDin")
+        self.assertEqual(msg.get_content_maintype(), "text")
+        self.assertEqual(msg.get_content_subtype(), "pl\uFFFDin")
+
+    # test_headerregistry.TestContentTypeHeader.non_ascii_in_params
+    def test_get_params_with_8bit(self):
+        msg = email.message_from_bytes(
+            'X-Header: foo=\xa7ne; b\xa7r=two; baz=three\n'.encode('latin-1'))
+        self.assertEqual(msg.get_params(header='x-header'),
+           [('foo', '\uFFFDne'), ('b\uFFFDr', 'two'), ('baz', 'three')])
+        self.assertEqual(msg.get_param('Foo', header='x-header'), '\uFFFdne')
+        # XXX: someday you might be able to get 'b\xa7r', for now you can't.
+        self.assertEqual(msg.get_param('b\xa7r', header='x-header'), None)
+
+    # test_headerregistry.TestContentTypeHeader.non_ascii_in_rfc2231_value
+    def test_get_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        self.assertEqual(msg.get_param('title'),
+            ('us-ascii', 'en', 'This is not f\uFFFDn'))
+
+    def test_set_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        msg.set_param('title', 'test')
+        self.assertEqual(msg.get_param('title'), 'test')
+
+    def test_del_rfc2231_params_with_8bit(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Type: text/plain; charset=us-ascii;
+             title*=us-ascii'en'This%20is%20not%20f\xa7n"""
+             ).encode('latin-1'))
+        msg.del_param('title')
+        self.assertEqual(msg.get_param('title'), None)
+        self.assertEqual(msg.get_content_maintype(), 'text')
+
+    def test_get_payload_with_8bit_cte_header(self):
+        msg = email.message_from_bytes(textwrap.dedent("""\
+            Content-Transfer-Encoding: b\xa7se64
+            Content-Type: text/plain; charset=latin-1
+
+            payload
+            """).encode('latin-1'))
+        self.assertEqual(msg.get_payload(), 'payload\n')
+        self.assertEqual(msg.get_payload(decode=True), b'payload\n')
+
+    non_latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: báz
+        Subject: Maintenant je vous présente mon collègue, le pouf célèbre
+        \tJean de Baddie
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: 8bit
+
+        Да, они летят.
+        """).encode('utf-8')
+
+    def test_bytes_generator(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), self.non_latin_bin_msg)
+
+    def test_bytes_generator_handles_None_body(self):
+        #Issue 11019
+        msg = email.message.Message()
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), b"\n")
+
+    non_latin_bin_msg_as7bit_wrapped = textwrap.dedent("""\
+        From: foo@bar.com
+        To: =?unknown-8bit?q?b=C3=A1z?=
+        Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_coll=C3=A8gue?=
+         =?unknown-8bit?q?=2C_le_pouf_c=C3=A9l=C3=A8bre?=
+         =?unknown-8bit?q?_Jean_de_Baddie?=
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: base64
+
+        0JTQsCwg0L7QvdC4INC70LXRgtGP0YIuCg==
+        """)
+
+    def test_generator_handles_8bit(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = StringIO()
+        email.generator.Generator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), self.non_latin_bin_msg_as7bit_wrapped)
+
+    def test_str_generator_should_not_mutate_msg_when_handling_8bit(self):
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        BytesGenerator(out).flatten(msg)
+        orig_value = out.getvalue()
+        Generator(StringIO()).flatten(msg) # Should not mutate msg!
+        out = BytesIO()
+        BytesGenerator(out).flatten(msg)
+        self.assertEqual(out.getvalue(), orig_value)
+
+    def test_bytes_generator_with_unix_from(self):
+        # The unixfrom contains a current date, so we can't check it
+        # literally.  Just make sure the first word is 'From' and the
+        # rest of the message matches the input.
+        msg = email.message_from_bytes(self.non_latin_bin_msg)
+        out = BytesIO()
+        email.generator.BytesGenerator(out).flatten(msg, unixfrom=True)
+        lines = out.getvalue().split(b'\n')
+        self.assertEqual(lines[0].split()[0], b'From')
+        self.assertEqual(b'\n'.join(lines[1:]), self.non_latin_bin_msg)
+
+    non_latin_bin_msg_as7bit = non_latin_bin_msg_as7bit_wrapped.split('\n')
+    non_latin_bin_msg_as7bit[2:4] = [
+        'Subject: =?unknown-8bit?q?Maintenant_je_vous_pr=C3=A9sente_mon_'
+         'coll=C3=A8gue=2C_le_pouf_c=C3=A9l=C3=A8bre?=']
+    non_latin_bin_msg_as7bit = '\n'.join(non_latin_bin_msg_as7bit)
+
+    def test_message_from_binary_file(self):
+        fn = 'test.msg'
+        self.addCleanup(unlink, fn)
+        with open(fn, 'wb') as testfile:
+            testfile.write(self.non_latin_bin_msg)
+        with open(fn, 'rb') as testfile:
+            m = email.parser.BytesParser().parse(testfile)
+        self.assertEqual(str(m), self.non_latin_bin_msg_as7bit)
+
+    latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: Dinsdale
+        Subject: Nudge nudge, wink, wink
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="latin-1"
+        Content-Transfer-Encoding: 8bit
+
+        oh là là, know what I mean, know what I mean?
+        """).encode('latin-1')
+
+    latin_bin_msg_as7bit = textwrap.dedent("""\
+        From: foo@bar.com
+        To: Dinsdale
+        Subject: Nudge nudge, wink, wink
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="iso-8859-1"
+        Content-Transfer-Encoding: quoted-printable
+
+        oh l=E0 l=E0, know what I mean, know what I mean?
+        """)
+
+    def test_string_generator_reencodes_to_quopri_when_appropriate(self):
+        m = email.message_from_bytes(self.latin_bin_msg)
+        self.assertEqual(str(m), self.latin_bin_msg_as7bit)
+
+    def test_decoded_generator_emits_unicode_body(self):
+        m = email.message_from_bytes(self.latin_bin_msg)
+        out = StringIO()
+        email.generator.DecodedGenerator(out).flatten(m)
+        #DecodedHeader output contains an extra blank line compared
+        #to the input message.  RDM: not sure if this is a bug or not,
+        #but it is not specific to the 8bit->7bit conversion.
+        self.assertEqual(out.getvalue(),
+            self.latin_bin_msg.decode('latin-1')+'\n')
+
+    def test_bytes_feedparser(self):
+        bfp = email.feedparser.BytesFeedParser()
+        for i in range(0, len(self.latin_bin_msg), 10):
+            bfp.feed(self.latin_bin_msg[i:i+10])
+        m = bfp.close()
+        self.assertEqual(str(m), self.latin_bin_msg_as7bit)
+
+    def test_crlf_flatten(self):
+        with openfile('msg_26.txt', 'rb') as fp:
+            text = fp.read()
+        msg = email.message_from_bytes(text)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg, linesep='\r\n')
+        self.assertEqual(s.getvalue(), text)
+
+    def test_8bit_multipart(self):
+        # Issue 11605
+        source = textwrap.dedent("""\
+            Date: Fri, 18 Mar 2011 17:15:43 +0100
+            To: foo@example.com
+            From: foodwatch-Newsletter <bar@example.com>
+            Subject: Aktuelles zu Japan, Klonfleisch und Smiley-System
+            Message-ID: <76a486bee62b0d200f33dc2ca08220ad@localhost.localdomain>
+            MIME-Version: 1.0
+            Content-Type: multipart/alternative;
+                    boundary="b1_76a486bee62b0d200f33dc2ca08220ad"
+
+            --b1_76a486bee62b0d200f33dc2ca08220ad
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            Guten Tag, ,
+
+            mit großer Betroffenheit verfolgen auch wir im foodwatch-Team die
+            Nachrichten aus Japan.
+
+
+            --b1_76a486bee62b0d200f33dc2ca08220ad
+            Content-Type: text/html; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+
+            <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+                "http://www.w3.org/TR/html4/loose.dtd">
+            <html lang="de">
+            <head>
+                    <title>foodwatch - Newsletter</title>
+            </head>
+            <body>
+              <p>mit gro&szlig;er Betroffenheit verfolgen auch wir im foodwatch-Team
+                 die Nachrichten aus Japan.</p>
+            </body>
+            </html>
+            --b1_76a486bee62b0d200f33dc2ca08220ad--
+
+            """).encode('utf-8')
+        msg = email.message_from_bytes(source)
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), source)
+
+    def test_bytes_generator_b_encoding_linesep(self):
+        # Issue 14062: b encoding was tacking on an extra \n.
+        m = Message()
+        # This has enough non-ascii that it should always end up b encoded.
+        m['Subject'] = Header('žluťoučký kůň')
+        s = BytesIO()
+        g = email.generator.BytesGenerator(s)
+        g.flatten(m, linesep='\r\n')
+        self.assertEqual(
+            s.getvalue(),
+            b'Subject: =?utf-8?b?xb5sdcWlb3XEjWvDvSBrxa/FiA==?=\r\n\r\n')
+
+    def test_generator_b_encoding_linesep(self):
+        # Since this broke in ByteGenerator, test Generator for completeness.
+        m = Message()
+        # This has enough non-ascii that it should always end up b encoded.
+        m['Subject'] = Header('žluťoučký kůň')
+        s = StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(m, linesep='\r\n')
+        self.assertEqual(
+            s.getvalue(),
+            'Subject: =?utf-8?b?xb5sdcWlb3XEjWvDvSBrxa/FiA==?=\r\n\r\n')
+
+    maxDiff = None
+
+
+class BaseTestBytesGeneratorIdempotent:
+
+    maxDiff = None
+
+    def _msgobj(self, filename):
+        with openfile(filename, 'rb') as fp:
+            data = fp.read()
+        data = self.normalize_linesep_regex.sub(self.blinesep, data)
+        msg = email.message_from_bytes(data)
+        return msg, data
+
+    def _idempotent(self, msg, data, unixfrom=False):
+        b = BytesIO()
+        g = email.generator.BytesGenerator(b, maxheaderlen=0)
+        g.flatten(msg, unixfrom=unixfrom, linesep=self.linesep)
+        self.assertEqual(data, b.getvalue())
+
+
+class TestBytesGeneratorIdempotentNL(BaseTestBytesGeneratorIdempotent,
+                                    TestIdempotent):
+    linesep = '\n'
+    blinesep = b'\n'
+    normalize_linesep_regex = re.compile(br'\r\n')
+
+
+class TestBytesGeneratorIdempotentCRLF(BaseTestBytesGeneratorIdempotent,
+                                       TestIdempotent):
+    linesep = '\r\n'
+    blinesep = b'\r\n'
+    normalize_linesep_regex = re.compile(br'(?<!\r)\n')
+
+
+class TestBase64(unittest.TestCase):
+    def test_len(self):
+        eq = self.assertEqual
+        eq(base64mime.header_length('hello'),
+           len(base64mime.body_encode(b'hello', eol='')))
+        for size in range(15):
+            if   size == 0 : bsize = 0
+            elif size <= 3 : bsize = 4
+            elif size <= 6 : bsize = 8
+            elif size <= 9 : bsize = 12
+            elif size <= 12: bsize = 16
+            else           : bsize = 20
+            eq(base64mime.header_length('x' * size), bsize)
+
+    def test_decode(self):
+        eq = self.assertEqual
+        eq(base64mime.decode(''), b'')
+        eq(base64mime.decode('aGVsbG8='), b'hello')
+
+    def test_encode(self):
+        eq = self.assertEqual
+        eq(base64mime.body_encode(b''), '')
+        eq(base64mime.body_encode(b'hello'), 'aGVsbG8=\n')
+        # Test the binary flag
+        eq(base64mime.body_encode(b'hello\n'), 'aGVsbG8K\n')
+        # Test the maxlinelen arg
+        eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40), """\
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg
+eHh4eCB4eHh4IA==
+""")
+        # Test the eol argument
+        eq(base64mime.body_encode(b'xxxx ' * 20, maxlinelen=40, eol='\r\n'),
+           """\
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IHh4eHggeHh4eCB4eHh4IHh4eHgg\r
+eHh4eCB4eHh4IA==\r
+""")
+
+    def test_header_encode(self):
+        eq = self.assertEqual
+        he = base64mime.header_encode
+        eq(he('hello'), '=?iso-8859-1?b?aGVsbG8=?=')
+        eq(he('hello\r\nworld'), '=?iso-8859-1?b?aGVsbG8NCndvcmxk?=')
+        eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
+        # Test the charset option
+        eq(he('hello', charset='iso-8859-2'), '=?iso-8859-2?b?aGVsbG8=?=')
+        eq(he('hello\nworld'), '=?iso-8859-1?b?aGVsbG8Kd29ybGQ=?=')
+
+
+class TestQuopri(unittest.TestCase):
+    def setUp(self):
+        # Set of characters (as byte integers) that don't need to be encoded
+        # in headers.
+        self.hlit = list(chain(
+            range(ord('a'), ord('z') + 1),
+            range(ord('A'), ord('Z') + 1),
+            range(ord('0'), ord('9') + 1),
+            (c for c in b'!*+-/')))
+        # Set of characters (as byte integers) that do need to be encoded in
+        # headers.
+        self.hnon = [c for c in range(256) if c not in self.hlit]
+        assert len(self.hlit) + len(self.hnon) == 256
+        # Set of characters (as byte integers) that don't need to be encoded
+        # in bodies.
+        self.blit = list(range(ord(' '), ord('~') + 1))
+        self.blit.append(ord('\t'))
+        self.blit.remove(ord('='))
+        # Set of characters (as byte integers) that do need to be encoded in
+        # bodies.
+        self.bnon = [c for c in range(256) if c not in self.blit]
+        assert len(self.blit) + len(self.bnon) == 256
+
+    def test_quopri_header_check(self):
+        for c in self.hlit:
+            self.assertFalse(quoprimime.header_check(c),
+                        'Should not be header quopri encoded: %s' % chr(c))
+        for c in self.hnon:
+            self.assertTrue(quoprimime.header_check(c),
+                            'Should be header quopri encoded: %s' % chr(c))
+
+    def test_quopri_body_check(self):
+        for c in self.blit:
+            self.assertFalse(quoprimime.body_check(c),
+                        'Should not be body quopri encoded: %s' % chr(c))
+        for c in self.bnon:
+            self.assertTrue(quoprimime.body_check(c),
+                            'Should be body quopri encoded: %s' % chr(c))
+
+    def test_header_quopri_len(self):
+        eq = self.assertEqual
+        eq(quoprimime.header_length(b'hello'), 5)
+        # RFC 2047 chrome is not included in header_length().
+        eq(len(quoprimime.header_encode(b'hello', charset='xxx')),
+           quoprimime.header_length(b'hello') +
+           # =?xxx?q?...?= means 10 extra characters
+           10)
+        eq(quoprimime.header_length(b'h@e@l@l@o@'), 20)
+        # RFC 2047 chrome is not included in header_length().
+        eq(len(quoprimime.header_encode(b'h@e@l@l@o@', charset='xxx')),
+           quoprimime.header_length(b'h@e@l@l@o@') +
+           # =?xxx?q?...?= means 10 extra characters
+           10)
+        for c in self.hlit:
+            eq(quoprimime.header_length(bytes([c])), 1,
+               'expected length 1 for %r' % chr(c))
+        for c in self.hnon:
+            # Space is special; it's encoded to _
+            if c == ord(' '):
+                continue
+            eq(quoprimime.header_length(bytes([c])), 3,
+               'expected length 3 for %r' % chr(c))
+        eq(quoprimime.header_length(b' '), 1)
+
+    def test_body_quopri_len(self):
+        eq = self.assertEqual
+        for c in self.blit:
+            eq(quoprimime.body_length(bytes([c])), 1)
+        for c in self.bnon:
+            eq(quoprimime.body_length(bytes([c])), 3)
+
+    def test_quote_unquote_idempotent(self):
+        for x in range(256):
+            c = chr(x)
+            self.assertEqual(quoprimime.unquote(quoprimime.quote(c)), c)
+
+    def _test_header_encode(self, header, expected_encoded_header, charset=None):
+        if charset is None:
+            encoded_header = quoprimime.header_encode(header)
+        else:
+            encoded_header = quoprimime.header_encode(header, charset)
+        self.assertEqual(encoded_header, expected_encoded_header)
+
+    def test_header_encode_null(self):
+        self._test_header_encode(b'', '')
+
+    def test_header_encode_one_word(self):
+        self._test_header_encode(b'hello', '=?iso-8859-1?q?hello?=')
+
+    def test_header_encode_two_lines(self):
+        self._test_header_encode(b'hello\nworld',
+                                '=?iso-8859-1?q?hello=0Aworld?=')
+
+    def test_header_encode_non_ascii(self):
+        self._test_header_encode(b'hello\xc7there',
+                                '=?iso-8859-1?q?hello=C7there?=')
+
+    def test_header_encode_alt_charset(self):
+        self._test_header_encode(b'hello', '=?iso-8859-2?q?hello?=',
+                charset='iso-8859-2')
+
+    def _test_header_decode(self, encoded_header, expected_decoded_header):
+        decoded_header = quoprimime.header_decode(encoded_header)
+        self.assertEqual(decoded_header, expected_decoded_header)
+
+    def test_header_decode_null(self):
+        self._test_header_decode('', '')
+
+    def test_header_decode_one_word(self):
+        self._test_header_decode('hello', 'hello')
+
+    def test_header_decode_two_lines(self):
+        self._test_header_decode('hello=0Aworld', 'hello\nworld')
+
+    def test_header_decode_non_ascii(self):
+        self._test_header_decode('hello=C7there', 'hello\xc7there')
+
+    def test_header_decode_re_bug_18380(self):
+        # Issue 18380: Call re.sub with a positional argument for flags in the wrong position
+        self.assertEqual(quoprimime.header_decode('=30' * 257), '0' * 257)
+
+    def _test_decode(self, encoded, expected_decoded, eol=None):
+        if eol is None:
+            decoded = quoprimime.decode(encoded)
+        else:
+            decoded = quoprimime.decode(encoded, eol=eol)
+        self.assertEqual(decoded, expected_decoded)
+
+    def test_decode_null_word(self):
+        self._test_decode('', '')
+
+    def test_decode_null_line_null_word(self):
+        self._test_decode('\r\n', '\n')
+
+    def test_decode_one_word(self):
+        self._test_decode('hello', 'hello')
+
+    def test_decode_one_word_eol(self):
+        self._test_decode('hello', 'hello', eol='X')
+
+    def test_decode_one_line(self):
+        self._test_decode('hello\r\n', 'hello\n')
+
+    def test_decode_one_line_lf(self):
+        self._test_decode('hello\n', 'hello\n')
+
+    def test_decode_one_line_cr(self):
+        self._test_decode('hello\r', 'hello\n')
+
+    def test_decode_one_line_nl(self):
+        self._test_decode('hello\n', 'helloX', eol='X')
+
+    def test_decode_one_line_crnl(self):
+        self._test_decode('hello\r\n', 'helloX', eol='X')
+
+    def test_decode_one_line_one_word(self):
+        self._test_decode('hello\r\nworld', 'hello\nworld')
+
+    def test_decode_one_line_one_word_eol(self):
+        self._test_decode('hello\r\nworld', 'helloXworld', eol='X')
+
+    def test_decode_two_lines(self):
+        self._test_decode('hello\r\nworld\r\n', 'hello\nworld\n')
+
+    def test_decode_two_lines_eol(self):
+        self._test_decode('hello\r\nworld\r\n', 'helloXworldX', eol='X')
+
+    def test_decode_one_long_line(self):
+        self._test_decode('Spam' * 250, 'Spam' * 250)
+
+    def test_decode_one_space(self):
+        self._test_decode(' ', '')
+
+    def test_decode_multiple_spaces(self):
+        self._test_decode(' ' * 5, '')
+
+    def test_decode_one_line_trailing_spaces(self):
+        self._test_decode('hello    \r\n', 'hello\n')
+
+    def test_decode_two_lines_trailing_spaces(self):
+        self._test_decode('hello    \r\nworld   \r\n', 'hello\nworld\n')
+
+    def test_decode_quoted_word(self):
+        self._test_decode('=22quoted=20words=22', '"quoted words"')
+
+    def test_decode_uppercase_quoting(self):
+        self._test_decode('ab=CD=EF', 'ab\xcd\xef')
+
+    def test_decode_lowercase_quoting(self):
+        self._test_decode('ab=cd=ef', 'ab\xcd\xef')
+
+    def test_decode_soft_line_break(self):
+        self._test_decode('soft line=\r\nbreak', 'soft linebreak')
+
+    def test_decode_false_quoting(self):
+        self._test_decode('A=1,B=A ==> A+B==2', 'A=1,B=A ==> A+B==2')
+
+    def _test_encode(self, body, expected_encoded_body, maxlinelen=None, eol=None):
+        kwargs = {}
+        if maxlinelen is None:
+            # Use body_encode's default.
+            maxlinelen = 76
+        else:
+            kwargs['maxlinelen'] = maxlinelen
+        if eol is None:
+            # Use body_encode's default.
+            eol = '\n'
+        else:
+            kwargs['eol'] = eol
+        encoded_body = quoprimime.body_encode(body, **kwargs)
+        self.assertEqual(encoded_body, expected_encoded_body)
+        if eol == '\n' or eol == '\r\n':
+            # We know how to split the result back into lines, so maxlinelen
+            # can be checked.
+            for line in encoded_body.splitlines():
+                self.assertLessEqual(len(line), maxlinelen)
+
+    def test_encode_null(self):
+        self._test_encode('', '')
+
+    def test_encode_null_lines(self):
+        self._test_encode('\n\n', '\n\n')
+
+    def test_encode_one_line(self):
+        self._test_encode('hello\n', 'hello\n')
+
+    def test_encode_one_line_crlf(self):
+        self._test_encode('hello\r\n', 'hello\n')
+
+    def test_encode_one_line_eol(self):
+        self._test_encode('hello\n', 'hello\r\n', eol='\r\n')
+
+    def test_encode_one_line_eol_after_non_ascii(self):
+        # issue 20206; see changeset 0cf700464177 for why the encode/decode.
+        self._test_encode('hello\u03c5\n'.encode('utf-8').decode('latin1'),
+                          'hello=CF=85\r\n', eol='\r\n')
+
+    def test_encode_one_space(self):
+        self._test_encode(' ', '=20')
+
+    def test_encode_one_line_one_space(self):
+        self._test_encode(' \n', '=20\n')
+
+# XXX: body_encode() expect strings, but uses ord(char) from these strings
+# to index into a 256-entry list.  For code points above 255, this will fail.
+# Should there be a check for 8-bit only ord() values in body, or at least
+# a comment about the expected input?
+
+    def test_encode_two_lines_one_space(self):
+        self._test_encode(' \n \n', '=20\n=20\n')
+
+    def test_encode_one_word_trailing_spaces(self):
+        self._test_encode('hello   ', 'hello  =20')
+
+    def test_encode_one_line_trailing_spaces(self):
+        self._test_encode('hello   \n', 'hello  =20\n')
+
+    def test_encode_one_word_trailing_tab(self):
+        self._test_encode('hello  \t', 'hello  =09')
+
+    def test_encode_one_line_trailing_tab(self):
+        self._test_encode('hello  \t\n', 'hello  =09\n')
+
+    def test_encode_trailing_space_before_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abcd =\n\n1234', maxlinelen=6)
+
+    def test_encode_trailing_space_at_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abcd=\n=20\n1234', maxlinelen=5)
+
+    def test_encode_trailing_space_beyond_maxlinelen(self):
+        self._test_encode('abcd \n1234', 'abc=\nd=20\n1234', maxlinelen=4)
+
+    def test_encode_whitespace_lines(self):
+        self._test_encode(' \n' * 5, '=20\n' * 5)
+
+    def test_encode_quoted_equals(self):
+        self._test_encode('a = b', 'a =3D b')
+
+    def test_encode_one_long_string(self):
+        self._test_encode('x' * 100, 'x' * 75 + '=\n' + 'x' * 25)
+
+    def test_encode_one_long_line(self):
+        self._test_encode('x' * 100 + '\n', 'x' * 75 + '=\n' + 'x' * 25 + '\n')
+
+    def test_encode_one_very_long_line(self):
+        self._test_encode('x' * 200 + '\n',
+                2 * ('x' * 75 + '=\n') + 'x' * 50 + '\n')
+
+    def test_encode_shortest_maxlinelen(self):
+        self._test_encode('=' * 5, '=3D=\n' * 4 + '=3D', maxlinelen=4)
+
+    def test_encode_maxlinelen_too_small(self):
+        self.assertRaises(ValueError, self._test_encode, '', '', maxlinelen=3)
+
+    def test_encode(self):
+        eq = self.assertEqual
+        eq(quoprimime.body_encode(''), '')
+        eq(quoprimime.body_encode('hello'), 'hello')
+        # Test the binary flag
+        eq(quoprimime.body_encode('hello\r\nworld'), 'hello\nworld')
+        # Test the maxlinelen arg
+        eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40), """\
+xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=
+ xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=
+x xxxx xxxx xxxx xxxx=20""")
+        # Test the eol argument
+        eq(quoprimime.body_encode('xxxx ' * 20, maxlinelen=40, eol='\r\n'),
+           """\
+xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx=\r
+ xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxx=\r
+x xxxx xxxx xxxx xxxx=20""")
+        eq(quoprimime.body_encode("""\
+one line
+
+two line"""), """\
+one line
+
+two line""")
+
+
+
+# Test the Charset class
+class TestCharset(unittest.TestCase):
+    def tearDown(self):
+        from email import charset as CharsetModule
+        try:
+            del CharsetModule.CHARSETS['fake']
+        except KeyError:
+            pass
+
+    def test_codec_encodeable(self):
+        eq = self.assertEqual
+        # Make sure us-ascii = no Unicode conversion
+        c = Charset('us-ascii')
+        eq(c.header_encode('Hello World!'), 'Hello World!')
+        # Test 8-bit idempotency with us-ascii
+        s = '\xa4\xa2\xa4\xa4\xa4\xa6\xa4\xa8\xa4\xaa'
+        self.assertRaises(UnicodeError, c.header_encode, s)
+        c = Charset('utf-8')
+        eq(c.header_encode(s), '=?utf-8?b?wqTCosKkwqTCpMKmwqTCqMKkwqo=?=')
+
+    def test_body_encode(self):
+        eq = self.assertEqual
+        # Try a charset with QP body encoding
+        c = Charset('iso-8859-1')
+        eq('hello w=F6rld', c.body_encode('hello w\xf6rld'))
+        # Try a charset with Base64 body encoding
+        c = Charset('utf-8')
+        eq('aGVsbG8gd29ybGQ=\n', c.body_encode(b'hello world'))
+        # Try a charset with None body encoding
+        c = Charset('us-ascii')
+        eq('hello world', c.body_encode('hello world'))
+        # Try the convert argument, where input codec != output codec
+        c = Charset('euc-jp')
+        # With apologies to Tokio Kikuchi ;)
+        # XXX FIXME
+##         try:
+##             eq('\x1b$B5FCO;~IW\x1b(B',
+##                c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7'))
+##             eq('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7',
+##                c.body_encode('\xb5\xc6\xc3\xcf\xbb\xfe\xc9\xd7', False))
+##         except LookupError:
+##             # We probably don't have the Japanese codecs installed
+##             pass
+        # Testing SF bug #625509, which we have to fake, since there are no
+        # built-in encodings where the header encoding is QP but the body
+        # encoding is not.
+        from email import charset as CharsetModule
+        CharsetModule.add_charset('fake', CharsetModule.QP, None, 'utf-8')
+        c = Charset('fake')
+        eq('hello world', c.body_encode('hello world'))
+
+    def test_unicode_charset_name(self):
+        charset = Charset('us-ascii')
+        self.assertEqual(str(charset), 'us-ascii')
+        self.assertRaises(errors.CharsetError, Charset, 'asc\xffii')
+
+
+
+# Test multilingual MIME headers.
+class TestHeader(TestEmailBase):
+    def test_simple(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Hello World!')
+        eq(h.encode(), 'Hello World!')
+        h.append(' Goodbye World!')
+        eq(h.encode(), 'Hello World!  Goodbye World!')
+
+    def test_simple_surprise(self):
+        eq = self.ndiffAssertEqual
+        h = Header('Hello World!')
+        eq(h.encode(), 'Hello World!')
+        h.append('Goodbye World!')
+        eq(h.encode(), 'Hello World! Goodbye World!')
+
+    def test_header_needs_no_decoding(self):
+        h = 'no decoding needed'
+        self.assertEqual(decode_header(h), [(h, None)])
+
+    def test_long(self):
+        h = Header("I am the very model of a modern Major-General; I've information vegetable, animal, and mineral; I know the kings of England, and I quote the fights historical from Marathon to Waterloo, in order categorical; I'm very well acquainted, too, with matters mathematical; I understand equations, both the simple and quadratical; about binomial theorem I'm teeming with a lot o' news, with many cheerful facts about the square of the hypotenuse.",
+                   maxlinelen=76)
+        for l in h.encode(splitchars=' ').split('\n '):
+            self.assertLessEqual(len(l), 76)
+
+    def test_multilingual(self):
+        eq = self.ndiffAssertEqual
+        g = Charset("iso-8859-1")
+        cz = Charset("iso-8859-2")
+        utf8 = Charset("utf-8")
+        g_head = (b'Die Mieter treten hier ein werden mit einem '
+                  b'Foerderband komfortabel den Korridor entlang, '
+                  b'an s\xfcdl\xfcndischen Wandgem\xe4lden vorbei, '
+                  b'gegen die rotierenden Klingen bef\xf6rdert. ')
+        cz_head = (b'Finan\xe8ni metropole se hroutily pod tlakem jejich '
+                   b'd\xf9vtipu.. ')
+        utf8_head = ('\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
+                     '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
+                     '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
+                     '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
+                     '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das '
+                     'Nunstuck git und Slotermeyer? Ja! Beiherhund das Oder '
+                     'die Flipperwaldt gersput.\u300d\u3068\u8a00\u3063\u3066'
+                     '\u3044\u307e\u3059\u3002')
+        h = Header(g_head, g)
+        h.append(cz_head, cz)
+        h.append(utf8_head, utf8)
+        enc = h.encode(maxlinelen=76)
+        eq(enc, """\
+=?iso-8859-1?q?Die_Mieter_treten_hier_ein_werden_mit_einem_Foerderband_kom?=
+ =?iso-8859-1?q?fortabel_den_Korridor_entlang=2C_an_s=FCdl=FCndischen_Wand?=
+ =?iso-8859-1?q?gem=E4lden_vorbei=2C_gegen_die_rotierenden_Klingen_bef=F6r?=
+ =?iso-8859-1?q?dert=2E_?= =?iso-8859-2?q?Finan=E8ni_metropole_se_hroutily?=
+ =?iso-8859-2?q?_pod_tlakem_jejich_d=F9vtipu=2E=2E_?= =?utf-8?b?5q2j56K6?=
+ =?utf-8?b?44Gr6KiA44GG44Go57+76Kiz44Gv44GV44KM44Gm44GE44G+44Gb44KT44CC?=
+ =?utf-8?b?5LiA6YOo44Gv44OJ44Kk44OE6Kqe44Gn44GZ44GM44CB44GC44Go44Gv44Gn?=
+ =?utf-8?b?44Gf44KJ44KB44Gn44GZ44CC5a6f6Zqb44Gr44Gv44CMV2VubiBpc3QgZGFz?=
+ =?utf-8?b?IE51bnN0dWNrIGdpdCB1bmQgU2xvdGVybWV5ZXI/IEphISBCZWloZXJodW5k?=
+ =?utf-8?b?IGRhcyBPZGVyIGRpZSBGbGlwcGVyd2FsZHQgZ2Vyc3B1dC7jgI3jgajoqIA=?=
+ =?utf-8?b?44Gj44Gm44GE44G+44GZ44CC?=""")
+        decoded = decode_header(enc)
+        eq(len(decoded), 3)
+        eq(decoded[0], (g_head, 'iso-8859-1'))
+        eq(decoded[1], (cz_head, 'iso-8859-2'))
+        eq(decoded[2], (utf8_head.encode('utf-8'), 'utf-8'))
+        ustr = str(h)
+        eq(ustr,
+           (b'Die Mieter treten hier ein werden mit einem Foerderband '
+            b'komfortabel den Korridor entlang, an s\xc3\xbcdl\xc3\xbcndischen '
+            b'Wandgem\xc3\xa4lden vorbei, gegen die rotierenden Klingen '
+            b'bef\xc3\xb6rdert. Finan\xc4\x8dni metropole se hroutily pod '
+            b'tlakem jejich d\xc5\xafvtipu.. \xe6\xad\xa3\xe7\xa2\xba\xe3\x81'
+            b'\xab\xe8\xa8\x80\xe3\x81\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3'
+            b'\xe3\x81\xaf\xe3\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3'
+            b'\x81\xbe\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'
+            b'\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8\xaa\x9e'
+            b'\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81\xe3\x81\x82\xe3'
+            b'\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81\x9f\xe3\x82\x89\xe3\x82'
+            b'\x81\xe3\x81\xa7\xe3\x81\x99\xe3\x80\x82\xe5\xae\x9f\xe9\x9a\x9b'
+            b'\xe3\x81\xab\xe3\x81\xaf\xe3\x80\x8cWenn ist das Nunstuck git '
+            b'und Slotermeyer? Ja! Beiherhund das Oder die Flipperwaldt '
+            b'gersput.\xe3\x80\x8d\xe3\x81\xa8\xe8\xa8\x80\xe3\x81\xa3\xe3\x81'
+            b'\xa6\xe3\x81\x84\xe3\x81\xbe\xe3\x81\x99\xe3\x80\x82'
+            ).decode('utf-8'))
+        # Test make_header()
+        newh = make_header(decode_header(enc))
+        eq(newh, h)
+
+    def test_empty_header_encode(self):
+        h = Header()
+        self.assertEqual(h.encode(), '')
+
+    def test_header_ctor_default_args(self):
+        eq = self.ndiffAssertEqual
+        h = Header()
+        eq(h, '')
+        h.append('foo', Charset('iso-8859-1'))
+        eq(h, 'foo')
+
+    def test_explicit_maxlinelen(self):
+        eq = self.ndiffAssertEqual
+        hstr = ('A very long line that must get split to something other '
+                'than at the 76th character boundary to test the non-default '
+                'behavior')
+        h = Header(hstr)
+        eq(h.encode(), '''\
+A very long line that must get split to something other than at the 76th
+ character boundary to test the non-default behavior''')
+        eq(str(h), hstr)
+        h = Header(hstr, header_name='Subject')
+        eq(h.encode(), '''\
+A very long line that must get split to something other than at the
+ 76th character boundary to test the non-default behavior''')
+        eq(str(h), hstr)
+        h = Header(hstr, maxlinelen=1024, header_name='Subject')
+        eq(h.encode(), hstr)
+        eq(str(h), hstr)
+
+    def test_quopri_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(charset='iso-8859-1', maxlinelen=20)
+        x = 'xxxx ' * 20
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?iso-8859-1?q?xxx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_x?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?x_?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?xx?=
+ =?iso-8859-1?q?_?=""")
+        eq(x, str(make_header(decode_header(s))))
+        h = Header(charset='iso-8859-1', maxlinelen=40)
+        h.append('xxxx ' * 20)
+        s = h.encode()
+        eq(s, """\
+=?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xxx?=
+ =?iso-8859-1?q?x_xxxx_xxxx_xxxx_xxxx_?=
+ =?iso-8859-1?q?xxxx_xxxx_xxxx_xxxx_xx?=
+ =?iso-8859-1?q?xx_xxxx_xxxx_xxxx_xxxx?=
+ =?iso-8859-1?q?_xxxx_xxxx_?=""")
+        eq(x, str(make_header(decode_header(s))))
+
+    def test_base64_splittable(self):
+        eq = self.ndiffAssertEqual
+        h = Header(charset='koi8-r', maxlinelen=20)
+        x = 'xxxx ' * 20
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IHh4?=
+ =?koi8-r?b?eHgg?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?eCB4?=
+ =?koi8-r?b?eHh4?=
+ =?koi8-r?b?IA==?=""")
+        eq(x, str(make_header(decode_header(s))))
+        h = Header(charset='koi8-r', maxlinelen=40)
+        h.append(x)
+        s = h.encode()
+        eq(s, """\
+=?koi8-r?b?eHh4eCB4eHh4IHh4eHggeHh4?=
+ =?koi8-r?b?eCB4eHh4IHh4eHggeHh4eCB4?=
+ =?koi8-r?b?eHh4IHh4eHggeHh4eCB4eHh4?=
+ =?koi8-r?b?IHh4eHggeHh4eCB4eHh4IHh4?=
+ =?koi8-r?b?eHggeHh4eCB4eHh4IHh4eHgg?=
+ =?koi8-r?b?eHh4eCB4eHh4IA==?=""")
+        eq(x, str(make_header(decode_header(s))))
+
+    def test_us_ascii_header(self):
+        eq = self.assertEqual
+        s = 'hello'
+        x = decode_header(s)
+        eq(x, [('hello', None)])
+        h = make_header(x)
+        eq(s, h.encode())
+
+    def test_string_charset(self):
+        eq = self.assertEqual
+        h = Header()
+        h.append('hello', 'iso-8859-1')
+        eq(h, 'hello')
+
+##    def test_unicode_error(self):
+##        raises = self.assertRaises
+##        raises(UnicodeError, Header, u'[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, Header, '[P\xf6stal]', 'us-ascii')
+##        h = Header()
+##        raises(UnicodeError, h.append, u'[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, h.append, '[P\xf6stal]', 'us-ascii')
+##        raises(UnicodeError, Header, u'\u83ca\u5730\u6642\u592b', 'iso-8859-1')
+
+    def test_utf8_shortest(self):
+        eq = self.assertEqual
+        h = Header('p\xf6stal', 'utf-8')
+        eq(h.encode(), '=?utf-8?q?p=C3=B6stal?=')
+        h = Header('\u83ca\u5730\u6642\u592b', 'utf-8')
+        eq(h.encode(), '=?utf-8?b?6I+K5Zyw5pmC5aSr?=')
+
+    def test_bad_8bit_header(self):
+        raises = self.assertRaises
+        eq = self.assertEqual
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        raises(UnicodeError, Header, x)
+        h = Header()
+        raises(UnicodeError, h.append, x)
+        e = x.decode('utf-8', 'replace')
+        eq(str(Header(x, errors='replace')), e)
+        h.append(x, errors='replace')
+        eq(str(h), e)
+
+    def test_escaped_8bit_header(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        e = x.decode('ascii', 'surrogateescape')
+        h = Header(e, charset=email.charset.UNKNOWN8BIT)
+        self.assertEqual(str(h),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
+
+    def test_header_handles_binary_unknown8bit(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        h = Header(x, charset=email.charset.UNKNOWN8BIT)
+        self.assertEqual(str(h),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h), [(x, 'unknown-8bit')])
+
+    def test_make_header_handles_binary_unknown8bit(self):
+        x = b'Ynwp4dUEbay Auction Semiar- No Charge \x96 Earn Big'
+        h = Header(x, charset=email.charset.UNKNOWN8BIT)
+        h2 = email.header.make_header(email.header.decode_header(h))
+        self.assertEqual(str(h2),
+                        'Ynwp4dUEbay Auction Semiar- No Charge \uFFFD Earn Big')
+        self.assertEqual(email.header.decode_header(h2), [(x, 'unknown-8bit')])
+
+    def test_modify_returned_list_does_not_change_header(self):
+        h = Header('test')
+        chunks = email.header.decode_header(h)
+        chunks.append(('ascii', 'test2'))
+        self.assertEqual(str(h), 'test')
+
+    def test_encoded_adjacent_nonencoded(self):
+        eq = self.assertEqual
+        h = Header()
+        h.append('hello', 'iso-8859-1')
+        h.append('world')
+        s = h.encode()
+        eq(s, '=?iso-8859-1?q?hello?= world')
+        h = make_header(decode_header(s))
+        eq(h.encode(), s)
+
+    def test_whitespace_keeper(self):
+        eq = self.assertEqual
+        s = 'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztk=?= =?koi8-r?q?=CA?= zz.'
+        parts = decode_header(s)
+        eq(parts, [(b'Subject: ', None), (b'\xf0\xd2\xcf\xd7\xc5\xd2\xcb\xc1 \xce\xc1 \xc6\xc9\xce\xc1\xcc\xd8\xce\xd9\xca', 'koi8-r'), (b' zz.', None)])
+        hdr = make_header(parts)
+        eq(hdr.encode(),
+           'Subject: =?koi8-r?b?8NLP18XSy8EgzsEgxsnOwczYztnK?= zz.')
+
+    def test_broken_base64_header(self):
+        raises = self.assertRaises
+        s = 'Subject: =?EUC-KR?B?CSixpLDtKSC/7Liuvsax4iC6uLmwMcijIKHaILzSwd/H0SC8+LCjwLsgv7W/+Mj3I ?='
+        raises(errors.HeaderParseError, decode_header, s)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; LookupError: unknown encoding: iso-2022-jp
+    def test_shift_jis_charset(self):
+        h = Header('文', charset='shift_jis')
+        self.assertEqual(h.encode(), '=?iso-2022-jp?b?GyRCSjgbKEI=?=')
+
+    def test_flatten_header_with_no_value(self):
+        # Issue 11401 (regression from email 4.x)  Note that the space after
+        # the header doesn't reflect the input, but this is also the way
+        # email 4.x behaved.  At some point it would be nice to fix that.
+        msg = email.message_from_string("EmptyHeader:")
+        self.assertEqual(str(msg), "EmptyHeader: \n\n")
+
+    def test_encode_preserves_leading_ws_on_value(self):
+        msg = Message()
+        msg['SomeHeader'] = '   value with leading ws'
+        self.assertEqual(str(msg), "SomeHeader:    value with leading ws\n\n")
+
+    def test_whitespace_header(self):
+        self.assertEqual(Header(' ').encode(), ' ')
+
+
+
+# Test RFC 2231 header parameters (en/de)coding
+class TestRFC2231(TestEmailBase):
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_with_double_quotes
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_inside_double_quotes
+    def test_get_param(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_29.txt')
+        eq(msg.get_param('title'),
+           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))
+        eq(msg.get_param('title', unquote=False),
+           ('us-ascii', 'en', '"This is even more ***fun*** isn\'t it!"'))
+
+    def test_set_param(self):
+        eq = self.ndiffAssertEqual
+        msg = Message()
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii')
+        eq(msg.get_param('title'),
+           ('us-ascii', '', 'This is even more ***fun*** isn\'t it!'))
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii', language='en')
+        eq(msg.get_param('title'),
+           ('us-ascii', 'en', 'This is even more ***fun*** isn\'t it!'))
+        msg = self._msgobj('msg_01.txt')
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+                      charset='us-ascii', language='en')
+        eq(msg.as_string(maxheaderlen=78), """\
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+\tid 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+Content-Type: text/plain; charset=us-ascii;
+ title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
+
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    def test_set_param_requote(self):
+        msg = Message()
+        msg.set_param('title', 'foo')
+        self.assertEqual(msg['content-type'], 'text/plain; title="foo"')
+        msg.set_param('title', 'bar', requote=False)
+        self.assertEqual(msg['content-type'], 'text/plain; title=bar')
+        # tspecial is still quoted.
+        msg.set_param('title', "(bar)bell", requote=False)
+        self.assertEqual(msg['content-type'], 'text/plain; title="(bar)bell"')
+
+    def test_del_param(self):
+        eq = self.ndiffAssertEqual
+        msg = self._msgobj('msg_01.txt')
+        msg.set_param('foo', 'bar', charset='us-ascii', language='en')
+        msg.set_param('title', 'This is even more ***fun*** isn\'t it!',
+            charset='us-ascii', language='en')
+        msg.del_param('foo', header='Content-Type')
+        eq(msg.as_string(maxheaderlen=78), """\
+Return-Path: <bbb@zzz.org>
+Delivered-To: bbb@zzz.org
+Received: by mail.zzz.org (Postfix, from userid 889)
+\tid 27CEAD38CC; Fri,  4 May 2001 14:05:44 -0400 (EDT)
+MIME-Version: 1.0
+Content-Transfer-Encoding: 7bit
+Message-ID: <15090.61304.110929.45684@aaa.zzz.org>
+From: bbb@ddd.com (John X. Doe)
+To: bbb@zzz.org
+Subject: This is a test message
+Date: Fri, 4 May 2001 14:05:44 -0400
+Content-Type: text/plain; charset="us-ascii";
+ title*=us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20isn%27t%20it%21
+
+
+Hi,
+
+Do you like this message?
+
+-Me
+""")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_charset
+    # I changed the charset name, though, because the one in the file isn't
+    # a legal charset name.  Should add a test for an illegal charset.
+    def test_rfc2231_get_content_charset(self):
+        eq = self.assertEqual
+        msg = self._msgobj('msg_32.txt')
+        eq(msg.get_content_charset(), 'us-ascii')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_no_double_quotes
+    def test_rfc2231_parse_rfc_quoting(self):
+        m = textwrap.dedent('''\
+            Content-Disposition: inline;
+            \tfilename*0*=''This%20is%20even%20more%20;
+            \tfilename*1*=%2A%2A%2Afun%2A%2A%2A%20;
+            \tfilename*2="is it not.pdf"
+
+            ''')
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+        self.assertEqual(m, msg.as_string())
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_with_double_quotes
+    def test_rfc2231_parse_extra_quoting(self):
+        m = textwrap.dedent('''\
+            Content-Disposition: inline;
+            \tfilename*0*="''This%20is%20even%20more%20";
+            \tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+            \tfilename*2="is it not.pdf"
+
+            ''')
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+        self.assertEqual(m, msg.as_string())
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_no_language_or_charset
+    # but new test uses *0* because otherwise lang/charset is not valid.
+    # test_headerregistry.TestContentTypeHeader.rfc2231_segmented_normal_values
+    def test_rfc2231_no_language_or_charset(self):
+        m = '''\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename="file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm"
+Content-Type: text/html; NAME*0=file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEM; NAME*1=P_nsmail.htm
+
+'''
+        msg = email.message_from_string(m)
+        param = msg.get_param('NAME')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(
+            param,
+            'file____C__DOCUMENTS_20AND_20SETTINGS_FABIEN_LOCAL_20SETTINGS_TEMP_nsmail.htm')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_no_charset
+    def test_rfc2231_no_language_or_charset_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    # Duplicate of previous test?
+    def test_rfc2231_no_language_or_charset_in_filename_encoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_partly_encoded,
+    # but the test below is wrong (the first part should be decoded).
+    def test_rfc2231_partly_encoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0="''This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            'This%20is%20even%20more%20***fun*** is it not.pdf')
+
+    def test_rfc2231_partly_nonencoded(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0="This%20is%20even%20more%20";
+\tfilename*1="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20is it not.pdf')
+
+    def test_rfc2231_no_language_or_charset_in_boundary(self):
+        m = '''\
+Content-Type: multipart/alternative;
+\tboundary*0*="''This%20is%20even%20more%20";
+\tboundary*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tboundary*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_boundary(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    def test_rfc2231_no_language_or_charset_in_charset(self):
+        # This is a nonsensical charset value, but tests the code anyway
+        m = '''\
+Content-Type: text/plain;
+\tcharset*0*="This%20is%20even%20more%20";
+\tcharset*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tcharset*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_content_charset(),
+                         'this is even more ***fun*** is it not.pdf')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_unknown_charset_treated_as_ascii
+    def test_rfc2231_bad_encoding_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="bogus'xx'This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2="is it not.pdf"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf')
+
+    def test_rfc2231_bad_encoding_in_charset(self):
+        m = """\
+Content-Type: text/plain; charset*=bogus''utf-8%E2%80%9D
+
+"""
+        msg = email.message_from_string(m)
+        # This should return None because non-ascii characters in the charset
+        # are not allowed.
+        self.assertEqual(msg.get_content_charset(), None)
+
+    def test_rfc2231_bad_character_in_charset(self):
+        m = """\
+Content-Type: text/plain; charset*=ascii''utf-8%E2%80%9D
+
+"""
+        msg = email.message_from_string(m)
+        # This should return None because non-ascii characters in the charset
+        # are not allowed.
+        self.assertEqual(msg.get_content_charset(), None)
+
+    def test_rfc2231_bad_character_in_filename(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="ascii'xx'This%20is%20even%20more%20";
+\tfilename*1*="%2A%2A%2Afun%2A%2A%2A%20";
+\tfilename*2*="is it not.pdf%E2"
+
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(),
+                         'This is even more ***fun*** is it not.pdf\ufffd')
+
+    def test_rfc2231_unknown_encoding(self):
+        m = """\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename*=X-UNKNOWN''myfile.txt
+
+"""
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(), 'myfile.txt')
+
+    def test_rfc2231_bad_character_in_encoding(self):
+        m = """\
+Content-Transfer-Encoding: 8bit
+Content-Disposition: inline; filename*=utf-8\udce2\udc80\udc9d''myfile.txt
+
+"""
+        msg = email.message_from_string(m)
+        self.assertEqual(msg.get_filename(), 'myfile.txt')
+
+    def test_rfc2231_single_tick_in_filename_extended(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"Frank's\"; name*1*=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, None)
+        eq(language, None)
+        eq(s, "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_inside_double_quotes
+    def test_rfc2231_single_tick_in_filename(self):
+        m = """\
+Content-Type: application/x-foo; name*0=\"Frank's\"; name*1=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        param = msg.get_param('name')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(param, "Frank's Document")
+
+    def test_rfc2231_missing_tick(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="'This%20is%20broken";
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            "'This is broken")
+
+    def test_rfc2231_missing_tick_with_encoded_non_ascii(self):
+        m = '''\
+Content-Disposition: inline;
+\tfilename*0*="'This%20is%E2broken";
+'''
+        msg = email.message_from_string(m)
+        self.assertEqual(
+            msg.get_filename(),
+            "'This is\ufffdbroken")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_in_value_with_charset_and_lang
+    def test_rfc2231_tick_attack_extended(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quote_in_non_encoded_value
+    def test_rfc2231_tick_attack(self):
+        m = """\
+Content-Type: application/x-foo;
+\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\"
+
+"""
+        msg = email.message_from_string(m)
+        param = msg.get_param('name')
+        self.assertNotIsInstance(param, tuple)
+        self.assertEqual(param, "us-ascii'en-us'Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_single_quotes_inside_quotes
+    def test_rfc2231_no_extended_values(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo; name=\"Frank's Document\"
+
+"""
+        msg = email.message_from_string(m)
+        eq(msg.get_param('name'), "Frank's Document")
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_encoded_then_unencoded_segments
+    def test_rfc2231_encoded_then_unencoded_segments(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0*=\"us-ascii'en-us'My\";
+\tname*1=\" Document\";
+\tname*2*=\" For You\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, 'My Document For You')
+
+    # test_headerregistry.TestContentTypeHeader.rfc2231_unencoded_then_encoded_segments
+    # test_headerregistry.TestContentTypeHeader.rfc2231_quoted_unencoded_then_encoded_segments
+    def test_rfc2231_unencoded_then_encoded_segments(self):
+        eq = self.assertEqual
+        m = """\
+Content-Type: application/x-foo;
+\tname*0=\"us-ascii'en-us'My\";
+\tname*1*=\" Document\";
+\tname*2*=\" For You\"
+
+"""
+        msg = email.message_from_string(m)
+        charset, language, s = msg.get_param('name')
+        eq(charset, 'us-ascii')
+        eq(language, 'en-us')
+        eq(s, 'My Document For You')
+
+    def test_should_not_hang_on_invalid_ew_messages(self):
+        messages = ["""From: user@host.com
+To: user@host.com
+Bad-Header:
+ =?us-ascii?Q?LCSwrV11+IB0rSbSker+M9vWR7wEDSuGqmHD89Gt=ea0nJFSaiz4vX3XMJPT4vrE?=
+ =?us-ascii?Q?xGUZeOnp0o22pLBB7CYLH74Js=wOlK6Tfru2U47qR?=
+ =?us-ascii?Q?72OfyEY2p2=2FrA9xNFyvH+fBTCmazxwzF8nGkK6D?=
+
+Hello!
+""", """From: ����� �������� <xxx@xxx>
+To: "xxx" <xxx@xxx>
+Subject:   ��� ���������� ����� ����� � ��������� �� ����
+MIME-Version: 1.0
+Content-Type: text/plain; charset="windows-1251";
+Content-Transfer-Encoding: 8bit
+
+�� ����� � ���� ������ ��� ��������
+"""]
+        for m in messages:
+            with self.subTest(m=m):
+                msg = email.message_from_string(m)
+
+
+# Tests to ensure that signed parts of an email are completely preserved, as
+# required by RFC1847 section 2.1.  Note that these are incomplete, because the
+# email package does not currently always preserve the body.  See issue 1670765.
+class TestSigned(TestEmailBase):
+
+    def _msg_and_obj(self, filename):
+        with openfile(filename, encoding="utf-8") as fp:
+            original = fp.read()
+            msg = email.message_from_string(original)
+        return original, msg
+
+    def _signed_parts_eq(self, original, result):
+        # Extract the first mime part of each message
+        import re
+        repart = re.compile(r'^--([^\n]+)\n(.*?)\n--\1$', re.S | re.M)
+        inpart = repart.search(original).group(2)
+        outpart = repart.search(result).group(2)
+        self.assertEqual(outpart, inpart)
+
+    def test_long_headers_as_string(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        result = msg.as_string()
+        self._signed_parts_eq(original, result)
+
+    def test_long_headers_as_string_maxheaderlen(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        result = msg.as_string(maxheaderlen=60)
+        self._signed_parts_eq(original, result)
+
+    def test_long_headers_flatten(self):
+        original, msg = self._msg_and_obj('msg_45.txt')
+        fp = StringIO()
+        Generator(fp).flatten(msg)
+        result = fp.getvalue()
+        self._signed_parts_eq(original, result)
+
+class TestHeaderRegistry(TestEmailBase):
+    # See issue gh-93010.
+    def test_HeaderRegistry(self):
+        reg = HeaderRegistry()
+        a = reg('Content-Disposition', 'attachment; 0*00="foo"')
+        self.assertIsInstance(a.defects[0], errors.InvalidHeaderDefect)
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_generator.py b/Lib/test/test_email/test_generator.py
new file mode 100644
index 0000000000..c75a842c33
--- /dev/null
+++ b/Lib/test/test_email/test_generator.py
@@ -0,0 +1,477 @@
+import io
+import textwrap
+import unittest
+from email import message_from_string, message_from_bytes
+from email.message import EmailMessage
+from email.generator import Generator, BytesGenerator
+from email.headerregistry import Address
+from email import policy
+import email.errors
+from test.test_email import TestEmailBase, parameterize
+
+
+@parameterize
+class TestGeneratorBase:
+
+    policy = policy.default
+
+    def msgmaker(self, msg, policy=None):
+        policy = self.policy if policy is None else policy
+        return self.msgfunc(msg, policy=policy)
+
+    refold_long_expected = {
+        0: textwrap.dedent("""\
+            To: whom_it_may_concern@example.com
+            From: nobody_you_want_to_know@example.com
+            Subject: We the willing led by the unknowing are doing the
+             impossible for the ungrateful. We have done so much for so long with so little
+             we are now qualified to do anything with nothing.
+
+            None
+            """),
+        40: textwrap.dedent("""\
+            To: whom_it_may_concern@example.com
+            From:
+             nobody_you_want_to_know@example.com
+            Subject: We the willing led by the
+             unknowing are doing the impossible for
+             the ungrateful. We have done so much
+             for so long with so little we are now
+             qualified to do anything with nothing.
+
+            None
+            """),
+        20: textwrap.dedent("""\
+            To:
+             whom_it_may_concern@example.com
+            From:
+             nobody_you_want_to_know@example.com
+            Subject: We the
+             willing led by the
+             unknowing are doing
+             the impossible for
+             the ungrateful. We
+             have done so much
+             for so long with so
+             little we are now
+             qualified to do
+             anything with
+             nothing.
+
+            None
+            """),
+        }
+    refold_long_expected[100] = refold_long_expected[0]
+
+    refold_all_expected = refold_long_expected.copy()
+    refold_all_expected[0] = (
+            "To: whom_it_may_concern@example.com\n"
+            "From: nobody_you_want_to_know@example.com\n"
+            "Subject: We the willing led by the unknowing are doing the "
+              "impossible for the ungrateful. We have done so much for "
+              "so long with so little we are now qualified to do anything "
+              "with nothing.\n"
+              "\n"
+              "None\n")
+    refold_all_expected[100] = (
+            "To: whom_it_may_concern@example.com\n"
+            "From: nobody_you_want_to_know@example.com\n"
+            "Subject: We the willing led by the unknowing are doing the "
+                "impossible for the ungrateful. We have\n"
+              " done so much for so long with so little we are now qualified "
+                "to do anything with nothing.\n"
+              "\n"
+              "None\n")
+
+    length_params = [n for n in refold_long_expected]
+
+    def length_as_maxheaderlen_parameter(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, maxheaderlen=n, policy=self.policy)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_max_line_length_policy(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_maxheaderlen_parm_overrides_policy(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, maxheaderlen=n,
+                          policy=self.policy.clone(max_line_length=10))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[n]))
+
+    def length_as_max_line_length_with_refold_none_does_not_fold(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='none',
+                                                      max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[0]))
+
+    def length_as_max_line_length_with_refold_all_folds(self, n):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all',
+                                                      max_line_length=n))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_all_expected[n]))
+
+    def test_crlf_control_via_policy(self):
+        source = "Subject: test\r\n\r\ntest body\r\n"
+        expected = source
+        msg = self.msgmaker(self.typ(source))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.SMTP)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_linesep_overrides_policy(self):
+        source = "Subject: test\n\ntest body\n"
+        expected = source
+        msg = self.msgmaker(self.typ(source))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.SMTP)
+        g.flatten(msg, linesep='\n')
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_linesep(self):
+        source = 'Subject: one\n two\r three\r\n four\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one two three four')
+
+        expected = 'Subject: one\n two\n three\n four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        expected = 'Subject: one two three four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_flatten_control_linesep(self):
+        source = 'Subject: one\v two\f three\x1c four\x1d five\x1e six\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one\v two\f three\x1c four\x1d five\x1e six')
+
+        expected = 'Subject: one\v two\f three\x1c four\x1d five\x1e six\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_set_mangle_from_via_policy(self):
+        source = textwrap.dedent("""\
+            Subject: test that
+             from is mangled in the body!
+
+            From time to time I write a rhyme.
+            """)
+        variants = (
+            (None, True),
+            (policy.compat32, True),
+            (policy.default, False),
+            (policy.default.clone(mangle_from_=True), True),
+            )
+        for p, mangle in variants:
+            expected = source.replace('From ', '>From ') if mangle else source
+            with self.subTest(policy=p, mangle_from_=mangle):
+                msg = self.msgmaker(self.typ(source))
+                s = self.ioclass()
+                g = self.genclass(s, policy=p)
+                g.flatten(msg)
+                self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_compat32_max_line_length_does_not_fold_when_none(self):
+        msg = self.msgmaker(self.typ(self.refold_long_expected[0]))
+        s = self.ioclass()
+        g = self.genclass(s, policy=policy.compat32.clone(max_line_length=None))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(self.refold_long_expected[0]))
+
+    def test_rfc2231_wrapping(self):
+        # This is pretty much just to make sure we don't have an infinite
+        # loop; I don't expect anyone to hit this in the field.
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename="afilenamelongenoghtowraphere"
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename*0*=us-ascii''afilename;
+             filename*1*=longenoghtowraphere
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=33))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_rfc2231_wrapping_switches_to_default_len_if_too_narrow(self):
+        # This is just to make sure we don't have an infinite loop; I don't
+        # expect anyone to hit this in the field, so I'm not bothering to make
+        # the result optimal (the encoding isn't needed).
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Content-Disposition: attachment;
+             filename="afilenamelongenoghtowraphere"
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Content-Disposition:
+             attachment;
+             filename*0*=us-ascii''afilenamelongenoghtowraphere
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=20))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_keep_encoded_newlines(self):
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=80))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_keep_long_encoded_newlines(self):
+        msg = self.msgmaker(self.typ(textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject=?UTF-8?Q?=0A?=Bcc: injection@example.com
+
+            None
+            """)))
+        expected = textwrap.dedent("""\
+            To: nobody
+            Subject: Bad subject
+             =?utf-8?q?=0A?=Bcc:
+             injection@example.com
+
+            None
+            """)
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(max_line_length=30))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+
+class TestGenerator(TestGeneratorBase, TestEmailBase):
+
+    msgfunc = staticmethod(message_from_string)
+    genclass = Generator
+    ioclass = io.StringIO
+    typ = str
+
+    def test_flatten_unicode_linesep(self):
+        source = 'Subject: one\x85 two\u2028 three\u2029 four\r\n\r\ntest body\r\n'
+        msg = self.msgmaker(self.typ(source))
+        self.assertEqual(msg['Subject'], 'one\x85 two\u2028 three\u2029 four')
+
+        expected = 'Subject: =?utf-8?b?b25lwoUgdHdv4oCoIHRocmVl4oCp?= four\n\ntest body\n'
+        s = self.ioclass()
+        g = self.genclass(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+        s = self.ioclass()
+        g = self.genclass(s, policy=self.policy.clone(refold_source='all'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), self.typ(expected))
+
+    def test_verify_generated_headers(self):
+        """gh-121650: by default the generator prevents header injection"""
+        class LiteralHeader(str):
+            name = 'Header'
+            def fold(self, **kwargs):
+                return self
+
+        for text in (
+            'Value\r\nBad Injection\r\n',
+            'NoNewLine'
+        ):
+            with self.subTest(text=text):
+                message = message_from_string(
+                    "Header: Value\r\n\r\nBody",
+                    policy=self.policy,
+                )
+
+                del message['Header']
+                message['Header'] = LiteralHeader(text)
+
+                with self.assertRaises(email.errors.HeaderWriteError):
+                    message.as_string()
+
+
+class TestBytesGenerator(TestGeneratorBase, TestEmailBase):
+
+    msgfunc = staticmethod(message_from_bytes)
+    genclass = BytesGenerator
+    ioclass = io.BytesIO
+    typ = lambda self, x: x.encode('ascii')
+
+    def test_defaults_handle_spaces_between_encoded_words_when_folded(self):
+        source = ("Уведомление о принятии в работу обращения для"
+                  " подключения услуги")
+        expected = ('Subject: =?utf-8?b?0KPQstC10LTQvtC80LvQtdC90LjQtSDQviDQv9GA0LjQvdGP0YLQuNC4?=\n'
+                    ' =?utf-8?b?INCyINGA0LDQsdC+0YLRgyDQvtCx0YDQsNGJ0LXQvdC40Y8g0LTQu9GPINC/0L4=?=\n'
+                    ' =?utf-8?b?0LTQutC70Y7Rh9C10L3QuNGPINGD0YHQu9GD0LPQuA==?=\n\n').encode('ascii')
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_when_encoded_words_is_folded_in_middle(self):
+        source = ('A very long long long long long long long long long long long long '
+                  'long long long long long long long long long long long súmmäry')
+        expected = ('Subject: A very long long long long long long long long long long long long\n'
+                    ' long long long long long long long long long long long =?utf-8?q?s=C3=BAmm?=\n'
+                    ' =?utf-8?q?=C3=A4ry?=\n\n').encode('ascii')
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_at_start_of_subject(self):
+        source = " Уведомление"
+        expected = b"Subject:  =?utf-8?b?0KPQstC10LTQvtC80LvQtdC90LjQtQ==?=\n\n"
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_defaults_handle_spaces_at_start_of_continuation_line(self):
+        source = " ф ффффффффффффффффффф ф ф"
+        expected = (b"Subject:  "
+                    b"=?utf-8?b?0YQg0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YTRhNGE0YQ=?=\n"
+                    b" =?utf-8?b?INGEINGE?=\n\n")
+        msg = EmailMessage()
+        msg['Subject'] = source
+        s = io.BytesIO()
+        g = BytesGenerator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_cte_type_7bit_handles_unknown_8bit(self):
+        source = ("Subject: Maintenant je vous présente mon "
+                 "collègue\n\n").encode('utf-8')
+        expected = ('Subject: Maintenant je vous =?unknown-8bit?q?'
+                    'pr=C3=A9sente_mon_coll=C3=A8gue?=\n\n').encode('ascii')
+        msg = message_from_bytes(source)
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=self.policy.clone(cte_type='7bit'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_cte_type_7bit_transforms_8bit_cte(self):
+        source = textwrap.dedent("""\
+            From: foo@bar.com
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink
+            Mime-Version: 1.0
+            Content-Type: text/plain; charset="latin-1"
+            Content-Transfer-Encoding: 8bit
+
+            oh là là, know what I mean, know what I mean?
+            """).encode('latin1')
+        msg = message_from_bytes(source)
+        expected =  textwrap.dedent("""\
+            From: foo@bar.com
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink
+            Mime-Version: 1.0
+            Content-Type: text/plain; charset="iso-8859-1"
+            Content-Transfer-Encoding: quoted-printable
+
+            oh l=E0 l=E0, know what I mean, know what I mean?
+            """).encode('ascii')
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=self.policy.clone(cte_type='7bit',
+                                                       linesep='\n'))
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_smtputf8_policy(self):
+        msg = EmailMessage()
+        msg['From'] = "Páolo <főo@bar.com>"
+        msg['To'] = 'Dinsdale'
+        msg['Subject'] = 'Nudge nudge, wink, wink \u1F609'
+        msg.set_content("oh là là, know what I mean, know what I mean?")
+        expected = textwrap.dedent("""\
+            From: Páolo <főo@bar.com>
+            To: Dinsdale
+            Subject: Nudge nudge, wink, wink \u1F609
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 8bit
+            MIME-Version: 1.0
+
+            oh là là, know what I mean, know what I mean?
+            """).encode('utf-8').replace(b'\n', b'\r\n')
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=policy.SMTPUTF8)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+    def test_smtp_policy(self):
+        msg = EmailMessage()
+        msg["From"] = Address(addr_spec="foo@bar.com", display_name="Páolo")
+        msg["To"] = Address(addr_spec="bar@foo.com", display_name="Dinsdale")
+        msg["Subject"] = "Nudge nudge, wink, wink"
+        msg.set_content("oh boy, know what I mean, know what I mean?")
+        expected = textwrap.dedent("""\
+            From: =?utf-8?q?P=C3=A1olo?= <foo@bar.com>
+            To: Dinsdale <bar@foo.com>
+            Subject: Nudge nudge, wink, wink
+            Content-Type: text/plain; charset="utf-8"
+            Content-Transfer-Encoding: 7bit
+            MIME-Version: 1.0
+
+            oh boy, know what I mean, know what I mean?
+            """).encode().replace(b"\n", b"\r\n")
+        s = io.BytesIO()
+        g = BytesGenerator(s, policy=policy.SMTP)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), expected)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_headerregistry.py b/Lib/test/test_email/test_headerregistry.py
new file mode 100644
index 0000000000..d2c571299b
--- /dev/null
+++ b/Lib/test/test_email/test_headerregistry.py
@@ -0,0 +1,1822 @@
+import datetime
+import textwrap
+import unittest
+from email import errors
+from email import policy
+from email.message import Message
+from test.test_email import TestEmailBase, parameterize
+from email import headerregistry
+from email.headerregistry import Address, Group
+from email.header import decode_header
+from test.support import ALWAYS_EQ
+
+
+DITTO = object()
+
+
+class TestHeaderRegistry(TestEmailBase):
+
+    def test_arbitrary_name_unstructured(self):
+        factory = headerregistry.HeaderRegistry()
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_name_case_ignored(self):
+        factory = headerregistry.HeaderRegistry()
+        # Whitebox check that test is valid
+        self.assertNotIn('Subject', factory.registry)
+        h = factory('Subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UniqueUnstructuredHeader)
+
+    class FooBase:
+        def __init__(self, *args, **kw):
+            pass
+
+    def test_override_default_base_class(self):
+        factory = headerregistry.HeaderRegistry(base_class=self.FooBase)
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, self.FooBase)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    class FooDefault:
+        parse = headerregistry.UnstructuredHeader.parse
+
+    def test_override_default_class(self):
+        factory = headerregistry.HeaderRegistry(default_class=self.FooDefault)
+        h = factory('foobar', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, self.FooDefault)
+
+    def test_override_default_class_only_overrides_default(self):
+        factory = headerregistry.HeaderRegistry(default_class=self.FooDefault)
+        h = factory('subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UniqueUnstructuredHeader)
+
+    def test_dont_use_default_map(self):
+        factory = headerregistry.HeaderRegistry(use_default_map=False)
+        h = factory('subject', 'test')
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_map_to_type(self):
+        factory = headerregistry.HeaderRegistry()
+        h1 = factory('foobar', 'test')
+        factory.map_to_type('foobar', headerregistry.UniqueUnstructuredHeader)
+        h2 = factory('foobar', 'test')
+        self.assertIsInstance(h1, headerregistry.BaseHeader)
+        self.assertIsInstance(h1, headerregistry.UnstructuredHeader)
+        self.assertIsInstance(h2, headerregistry.BaseHeader)
+        self.assertIsInstance(h2, headerregistry.UniqueUnstructuredHeader)
+
+
+class TestHeaderBase(TestEmailBase):
+
+    factory = headerregistry.HeaderRegistry()
+
+    def make_header(self, name, value):
+        return self.factory(name, value)
+
+
+class TestBaseHeaderFeatures(TestHeaderBase):
+
+    def test_str(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertIsInstance(h, str)
+        self.assertEqual(h, 'this is a test')
+        self.assertEqual(str(h), 'this is a test')
+
+    def test_substr(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h[5:7], 'is')
+
+    def test_has_name(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h.name, 'subject')
+
+    def _test_attr_ro(self, attr):
+        h = self.make_header('subject', 'this is a test')
+        with self.assertRaises(AttributeError):
+            setattr(h, attr, 'foo')
+
+    def test_name_read_only(self):
+        self._test_attr_ro('name')
+
+    def test_defects_read_only(self):
+        self._test_attr_ro('defects')
+
+    def test_defects_is_tuple(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(len(h.defects), 0)
+        self.assertIsInstance(h.defects, tuple)
+        # Make sure it is still true when there are defects.
+        h = self.make_header('date', '')
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects, tuple)
+
+    # XXX: FIXME
+    #def test_CR_in_value(self):
+    #    # XXX: this also re-raises the issue of embedded headers,
+    #    # need test and solution for that.
+    #    value = '\r'.join(['this is', ' a test'])
+    #    h = self.make_header('subject', value)
+    #    self.assertEqual(h, value)
+    #    self.assertDefectsEqual(h.defects, [errors.ObsoleteHeaderDefect])
+
+
+@parameterize
+class TestUnstructuredHeader(TestHeaderBase):
+
+    def string_as_value(self,
+                        source,
+                        decoded,
+                        *args):
+        # TODO: RUSTPYTHON; RustPython currently does not support non-utf8 encoding
+        if source == '=?gb2312?b?1eLKx9bQzsSy4srUo6E=?=':
+            raise unittest.SkipTest("TODO: RUSTPYTHON; RustPython currently does not support non-utf8 encoding")
+        # RUSTPYTHON: End
+        # ------------------------------------------------------------------
+        l = len(args)
+        defects = args[0] if l>0 else []
+        header = 'Subject:' + (' ' if source else '')
+        folded = header + (args[1] if l>1 else source) + '\n'
+        h = self.make_header('Subject', source)
+        self.assertEqual(h, decoded)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    string_params = {
+
+        'rfc2047_simple_quopri': (
+            '=?utf-8?q?this_is_a_test?=',
+            'this is a test',
+            [],
+            'this is a test'),
+
+        'rfc2047_gb2312_base64': (
+            '=?gb2312?b?1eLKx9bQzsSy4srUo6E=?=',
+            '\u8fd9\u662f\u4e2d\u6587\u6d4b\u8bd5\uff01',
+            [],
+            '=?utf-8?b?6L+Z5piv5Lit5paH5rWL6K+V77yB?='),
+
+        'rfc2047_simple_nonascii_quopri': (
+            '=?utf-8?q?=C3=89ric?=',
+            'Éric'),
+
+        'rfc2047_quopri_with_regular_text': (
+            'The =?utf-8?q?=C3=89ric=2C?= Himself',
+            'The Éric, Himself'),
+
+    }
+
+
+@parameterize
+class TestDateHeader(TestHeaderBase):
+
+    datestring = 'Sun, 23 Sep 2001 20:10:55 -0700'
+    utcoffset = datetime.timedelta(hours=-7)
+    tz = datetime.timezone(utcoffset)
+    dt = datetime.datetime(2001, 9, 23, 20, 10, 55, tzinfo=tz)
+
+    def test_parse_date(self):
+        h = self.make_header('date', self.datestring)
+        self.assertEqual(h, self.datestring)
+        self.assertEqual(h.datetime, self.dt)
+        self.assertEqual(h.datetime.utcoffset(), self.utcoffset)
+        self.assertEqual(h.defects, ())
+
+    def test_set_from_datetime(self):
+        h = self.make_header('date', self.dt)
+        self.assertEqual(h, self.datestring)
+        self.assertEqual(h.datetime, self.dt)
+        self.assertEqual(h.defects, ())
+
+    def test_date_header_properties(self):
+        h = self.make_header('date', self.datestring)
+        self.assertIsInstance(h, headerregistry.UniqueDateHeader)
+        self.assertEqual(h.max_count, 1)
+        self.assertEqual(h.defects, ())
+
+    def test_resent_date_header_properties(self):
+        h = self.make_header('resent-date', self.datestring)
+        self.assertIsInstance(h, headerregistry.DateHeader)
+        self.assertEqual(h.max_count, None)
+        self.assertEqual(h.defects, ())
+
+    def test_no_value_is_defect(self):
+        h = self.make_header('date', '')
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.HeaderMissingRequiredValue)
+
+    def test_invalid_date_format(self):
+        s = 'Not a date header'
+        h = self.make_header('date', s)
+        self.assertEqual(h, s)
+        self.assertIsNone(h.datetime)
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.InvalidDateDefect)
+
+    def test_invalid_date_value(self):
+        s = 'Tue, 06 Jun 2017 27:39:33 +0600'
+        h = self.make_header('date', s)
+        self.assertEqual(h, s)
+        self.assertIsNone(h.datetime)
+        self.assertEqual(len(h.defects), 1)
+        self.assertIsInstance(h.defects[0], errors.InvalidDateDefect)
+
+    def test_datetime_read_only(self):
+        h = self.make_header('date', self.datestring)
+        with self.assertRaises(AttributeError):
+            h.datetime = 'foo'
+
+    def test_set_date_header_from_datetime(self):
+        m = Message(policy=policy.default)
+        m['Date'] = self.dt
+        self.assertEqual(m['Date'], self.datestring)
+        self.assertEqual(m['Date'].datetime, self.dt)
+
+
+@parameterize
+class TestContentTypeHeader(TestHeaderBase):
+
+    def content_type_as_value(self,
+                              source,
+                              content_type,
+                              maintype,
+                              subtype,
+                              *args):
+        l = len(args)
+        parmdict = args[0] if l>0 else {}
+        defects =  args[1] if l>1 else []
+        decoded =  args[2] if l>2 and args[2] is not DITTO else source
+        header = 'Content-Type:' + ' ' if source else ''
+        folded = args[3] if l>3 else header + decoded + '\n'
+        h = self.make_header('Content-Type', source)
+        self.assertEqual(h.content_type, content_type)
+        self.assertEqual(h.maintype, maintype)
+        self.assertEqual(h.subtype, subtype)
+        self.assertEqual(h.params, parmdict)
+        with self.assertRaises(TypeError):
+            h.params['abc'] = 'xyz'   # make sure params is read-only.
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    content_type_params = {
+
+        # Examples from RFC 2045.
+
+        'RFC_2045_1': (
+            'text/plain; charset=us-ascii (Plain text)',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        'RFC_2045_2': (
+            'text/plain; charset=us-ascii',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        'RFC_2045_3': (
+            'text/plain; charset="us-ascii"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'}),
+
+        # RFC 2045 5.2 says syntactically invalid values are to be treated as
+        # text/plain.
+
+        'no_subtype_in_content_type': (
+            'text/',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'no_slash_in_content_type': (
+            'foo',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'junk_text_in_content_type': (
+            '<crazy "stuff">',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'too_many_slashes_in_content_type': (
+            'image/jpeg/foo',
+            'text/plain',
+            'text',
+            'plain',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        # But unknown names are OK.  We could make non-IANA names a defect, but
+        # by not doing so we make ourselves future proof.  The fact that they
+        # are unknown will be detectable by the fact that they don't appear in
+        # the mime_registry...and the application is free to extend that list
+        # to handle them even if the core library doesn't.
+
+        'unknown_content_type': (
+            'bad/names',
+            'bad/names',
+            'bad',
+            'names'),
+
+        # The content type is case insensitive, and CFWS is ignored.
+
+        'mixed_case_content_type': (
+            'ImAge/JPeg',
+            'image/jpeg',
+            'image',
+            'jpeg'),
+
+        'spaces_in_content_type': (
+            '  text  /  plain  ',
+            'text/plain',
+            'text',
+            'plain'),
+
+        'cfws_in_content_type': (
+            '(foo) text (bar)/(baz)plain(stuff)',
+            'text/plain',
+            'text',
+            'plain'),
+
+        # test some parameters (more tests could be added for parameters
+        # associated with other content types, but since parameter parsing is
+        # generic they would be redundant for the current implementation).
+
+        'charset_param': (
+            'text/plain; charset="utf-8"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8'}),
+
+        'capitalized_charset': (
+            'text/plain; charset="US-ASCII"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'US-ASCII'}),
+
+        'unknown_charset': (
+            'text/plain; charset="fOo"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'fOo'}),
+
+        'capitalized_charset_param_name_and_comment': (
+            'text/plain; (interjection) Charset="utf-8"',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8'},
+            [],
+            # Should the parameter name be lowercased here?
+            'text/plain; Charset="utf-8"'),
+
+        # Since this is pretty much the ur-mimeheader, we'll put all the tests
+        # that exercise the parameter parsing and formatting here.  Note that
+        # when we refold we may canonicalize, so things like whitespace,
+        # quoting, and rfc2231 encoding may change from what was in the input
+        # header.
+
+        'unquoted_param_value': (
+            'text/plain; title=foo',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': 'foo'},
+            [],
+            'text/plain; title="foo"',
+            ),
+
+        'param_value_with_tspecials': (
+            'text/plain; title="(bar)foo blue"',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': '(bar)foo blue'}),
+
+        'param_with_extra_quoted_whitespace': (
+            'text/plain; title="  a     loong  way \t home   "',
+            'text/plain',
+            'text',
+            'plain',
+            {'title': '  a     loong  way \t home   '}),
+
+        'bad_params': (
+            'blarg; baz; boo',
+            'text/plain',
+            'text',
+            'plain',
+            {'baz': '', 'boo': ''},
+            [errors.InvalidHeaderDefect]*3),
+
+        'spaces_around_param_equals': (
+            'Multipart/mixed; boundary = "CPIMSSMTPC06p5f3tG"',
+            'multipart/mixed',
+            'multipart',
+            'mixed',
+            {'boundary': 'CPIMSSMTPC06p5f3tG'},
+            [],
+            'Multipart/mixed; boundary="CPIMSSMTPC06p5f3tG"',
+            ),
+
+        'spaces_around_semis': (
+            ('image/jpeg; name="wibble.JPG" ; x-mac-type="4A504547" ; '
+                'x-mac-creator="474B4F4E"'),
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'wibble.JPG',
+             'x-mac-type': '4A504547',
+             'x-mac-creator': '474B4F4E'},
+            [],
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"'),
+            ('Content-Type: image/jpeg; name="wibble.JPG";'
+                ' x-mac-type="4A504547";\n'
+             ' x-mac-creator="474B4F4E"\n'),
+            ),
+
+        'lots_of_mime_params': (
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"; x-extrastuff="make it longer"'),
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'wibble.JPG',
+             'x-mac-type': '4A504547',
+             'x-mac-creator': '474B4F4E',
+             'x-extrastuff': 'make it longer'},
+            [],
+            ('image/jpeg; name="wibble.JPG"; x-mac-type="4A504547"; '
+                'x-mac-creator="474B4F4E"; x-extrastuff="make it longer"'),
+            # In this case the whole of the MimeParameters does *not* fit
+            # one one line, so we break at a lower syntactic level.
+            ('Content-Type: image/jpeg; name="wibble.JPG";'
+                ' x-mac-type="4A504547";\n'
+             ' x-mac-creator="474B4F4E"; x-extrastuff="make it longer"\n'),
+            ),
+
+        'semis_inside_quotes': (
+            'image/jpeg; name="Jim&amp;&amp;Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'Jim&amp;&amp;Jill'}),
+
+        'single_quotes_inside_quotes': (
+            'image/jpeg; name="Jim \'Bob\' Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': "Jim 'Bob' Jill"}),
+
+        'double_quotes_inside_quotes': (
+            r'image/jpeg; name="Jim \"Bob\" Jill"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': 'Jim "Bob" Jill'},
+            [],
+            r'image/jpeg; name="Jim \"Bob\" Jill"'),
+
+        'non_ascii_in_params': (
+            ('foo\xa7/bar; b\xa7r=two; '
+                'baz=thr\xa7e'.encode('latin-1').decode('us-ascii',
+                                                        'surrogateescape')),
+            'foo\uFFFD/bar',
+            'foo\uFFFD',
+            'bar',
+            {'b\uFFFDr': 'two', 'baz': 'thr\uFFFDe'},
+            [errors.UndecodableBytesDefect]*3,
+            'foo�/bar; b�r="two"; baz="thr�e"',
+            # XXX Two bugs here: the mime type is not allowed to be an encoded
+            # word, and we shouldn't be emitting surrogates in the parameter
+            # names.  But I don't know what the behavior should be here, so I'm
+            # punting for now.  In practice this is unlikely to be encountered
+            # since headers with binary in them only come from a binary source
+            # and are almost certain to be re-emitted without refolding.
+            'Content-Type: =?unknown-8bit?q?foo=A7?=/bar; b\udca7r="two";\n'
+            " baz*=unknown-8bit''thr%A7e\n",
+            ),
+
+        # RFC 2231 parameter tests.
+
+        'rfc2231_segmented_normal_values': (
+            'image/jpeg; name*0="abc"; name*1=".html"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'name': "abc.html"},
+            [],
+            'image/jpeg; name="abc.html"'),
+
+        'quotes_inside_rfc2231_value': (
+            r'image/jpeg; bar*0="baz\"foobar"; bar*1="\"baz"',
+            'image/jpeg',
+            'image',
+            'jpeg',
+            {'bar': 'baz"foobar"baz'},
+            [],
+            r'image/jpeg; bar="baz\"foobar\"baz"'),
+
+        'non_ascii_rfc2231_value': (
+            ('text/plain; charset=us-ascii; '
+             "title*=us-ascii'en'This%20is%20"
+             'not%20f\xa7n').encode('latin-1').decode('us-ascii',
+                                                     'surrogateescape'),
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii', 'title': 'This is not f\uFFFDn'},
+             [errors.UndecodableBytesDefect],
+             'text/plain; charset="us-ascii"; title="This is not f�n"',
+            'Content-Type: text/plain; charset="us-ascii";\n'
+            " title*=unknown-8bit''This%20is%20not%20f%A7n\n",
+            ),
+
+        'rfc2231_encoded_charset': (
+            'text/plain; charset*=ansi-x3.4-1968\'\'us-ascii',
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii'},
+            [],
+            'text/plain; charset="us-ascii"'),
+
+        # This follows the RFC: no double quotes around encoded values.
+        'rfc2231_encoded_no_double_quotes': (
+            ("text/plain;"
+                "\tname*0*=''This%20is%20;"
+                "\tname*1*=%2A%2A%2Afun%2A%2A%2A%20;"
+                '\tname*2="is it not.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is ***fun*** is it not.pdf'},
+            [],
+            'text/plain; name="This is ***fun*** is it not.pdf"',
+            ),
+
+        # Make sure we also handle it if there are spurious double quotes.
+        'rfc2231_encoded_with_double_quotes': (
+            ("text/plain;"
+                '\tname*0*="us-ascii\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it not.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it not.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it not.pdf"',
+            ),
+
+        'rfc2231_single_quote_inside_double_quotes': (
+            ('text/plain; charset=us-ascii;'
+               '\ttitle*0*="us-ascii\'en\'This%20is%20really%20";'
+               '\ttitle*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+               '\ttitle*2="isn\'t it!"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'us-ascii', 'title': "This is really ***fun*** isn't it!"},
+            [errors.InvalidHeaderDefect]*2,
+            ('text/plain; charset="us-ascii"; '
+               'title="This is really ***fun*** isn\'t it!"'),
+            ('Content-Type: text/plain; charset="us-ascii";\n'
+                ' title="This is really ***fun*** isn\'t it!"\n'),
+            ),
+
+        'rfc2231_single_quote_in_value_with_charset_and_lang': (
+            ('application/x-foo;'
+                "\tname*0*=\"us-ascii'en-us'Frank's\"; name*1*=\" Document\""),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "Frank's Document"},
+            [errors.InvalidHeaderDefect]*2,
+            'application/x-foo; name="Frank\'s Document"',
+            ),
+
+        'rfc2231_single_quote_in_non_encoded_value': (
+            ('application/x-foo;'
+                "\tname*0=\"us-ascii'en-us'Frank's\"; name*1=\" Document\""),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "us-ascii'en-us'Frank's Document"},
+            [],
+            'application/x-foo; name="us-ascii\'en-us\'Frank\'s Document"',
+             ),
+
+        'rfc2231_no_language_or_charset': (
+            'text/plain; NAME*0*=english_is_the_default.html',
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'english_is_the_default.html'},
+            [errors.InvalidHeaderDefect],
+            'text/plain; NAME="english_is_the_default.html"'),
+
+        'rfc2231_encoded_no_charset': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it.pdf"',
+            ),
+
+        'rfc2231_partly_encoded': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1*="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more ***fun*** is it.pdf'},
+            [errors.InvalidHeaderDefect]*2,
+            'text/plain; name="This is even more ***fun*** is it.pdf"',
+            ),
+
+        'rfc2231_partly_encoded_2': (
+            ("text/plain;"
+                '\tname*0*="\'\'This%20is%20even%20more%20";'
+                '\tname*1="%2A%2A%2Afun%2A%2A%2A%20";'
+                '\tname*2="is it.pdf"'),
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'This is even more %2A%2A%2Afun%2A%2A%2A%20is it.pdf'},
+            [errors.InvalidHeaderDefect],
+            ('text/plain;'
+             ' name="This is even more %2A%2A%2Afun%2A%2A%2A%20is it.pdf"'),
+            ('Content-Type: text/plain;\n'
+             ' name="This is even more %2A%2A%2Afun%2A%2A%2A%20is'
+                ' it.pdf"\n'),
+            ),
+
+        'rfc2231_unknown_charset_treated_as_ascii': (
+            "text/plain; name*0*=bogus'xx'ascii_is_the_default",
+            'text/plain',
+            'text',
+            'plain',
+            {'name': 'ascii_is_the_default'},
+            [],
+            'text/plain; name="ascii_is_the_default"'),
+
+        'rfc2231_bad_character_in_charset_parameter_value': (
+            "text/plain; charset*=ascii''utf-8%F1%F2%F3",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8\uFFFD\uFFFD\uFFFD'},
+            [errors.UndecodableBytesDefect],
+            'text/plain; charset="utf-8\uFFFD\uFFFD\uFFFD"',
+            "Content-Type: text/plain;"
+            " charset*=unknown-8bit''utf-8%F1%F2%F3\n",
+            ),
+
+        'rfc2231_utf8_in_supposedly_ascii_charset_parameter_value': (
+            "text/plain; charset*=ascii''utf-8%E2%80%9D",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8”'},
+            [errors.UndecodableBytesDefect],
+            'text/plain; charset="utf-8”"',
+            # XXX Should folding change the charset to utf8?  Currently it just
+            # reproduces the original, which is arguably fine.
+            "Content-Type: text/plain;"
+            " charset*=unknown-8bit''utf-8%E2%80%9D\n",
+            ),
+
+        'rfc2231_nonascii_in_charset_of_charset_parameter_value': (
+            "text/plain; charset*=utf-8”''utf-8%E2%80%9D",
+            'text/plain',
+            'text',
+            'plain',
+            {'charset': 'utf-8”'},
+            [],
+            'text/plain; charset="utf-8”"',
+            "Content-Type: text/plain;"
+            " charset*=utf-8''utf-8%E2%80%9D\n",
+            ),
+
+        'rfc2231_encoded_then_unencoded_segments': (
+            ('application/x-foo;'
+                '\tname*0*="us-ascii\'en-us\'My";'
+                '\tname*1=" Document";'
+                '\tname*2=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': 'My Document For You'},
+            [errors.InvalidHeaderDefect],
+            'application/x-foo; name="My Document For You"',
+            ),
+
+        # My reading of the RFC is that this is an invalid header.  The RFC
+        # says that if charset and language information is given, the first
+        # segment *must* be encoded.
+        'rfc2231_unencoded_then_encoded_segments': (
+            ('application/x-foo;'
+                '\tname*0=us-ascii\'en-us\'My;'
+                '\tname*1*=" Document";'
+                '\tname*2*=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': 'My Document For You'},
+            [errors.InvalidHeaderDefect]*3,
+            'application/x-foo; name="My Document For You"',
+            ),
+
+        # XXX: I would say this one should default to ascii/en for the
+        # "encoded" segment, since the first segment is not encoded and is
+        # in double quotes, making the value a valid non-encoded string.  The
+        # old parser decodes this just like the previous case, which may be the
+        # better Postel rule, but could equally result in borking headers that
+        # intentionally have quoted quotes in them.  We could get this 98%
+        # right if we treat it as a quoted string *unless* it matches the
+        # charset'lang'value pattern exactly *and* there is at least one
+        # encoded segment.  Implementing that algorithm will require some
+        # refactoring, so I haven't done it (yet).
+        'rfc2231_quoted_unencoded_then_encoded_segments': (
+            ('application/x-foo;'
+                '\tname*0="us-ascii\'en-us\'My";'
+                '\tname*1*=" Document";'
+                '\tname*2*=" For You"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "us-ascii'en-us'My Document For You"},
+            [errors.InvalidHeaderDefect]*2,
+            'application/x-foo; name="us-ascii\'en-us\'My Document For You"',
+            ),
+
+        # Make sure our folding algorithm produces multiple sections correctly.
+        # We could mix encoded and non-encoded segments, but we don't, we just
+        # make them all encoded.  It might be worth fixing that, since the
+        # sections can get used for wrapping ascii text.
+        'rfc2231_folded_segments_correctly_formatted': (
+            ('application/x-foo;'
+                '\tname="' + "with spaces"*8 + '"'),
+            'application/x-foo',
+            'application',
+            'x-foo',
+            {'name': "with spaces"*8},
+            [],
+            'application/x-foo; name="' + "with spaces"*8 + '"',
+            "Content-Type: application/x-foo;\n"
+            " name*0*=us-ascii''with%20spaceswith%20spaceswith%20spaceswith"
+                "%20spaceswith;\n"
+            " name*1*=%20spaceswith%20spaceswith%20spaceswith%20spaces\n"
+            ),
+
+    }
+
+
+@parameterize
+class TestContentTransferEncoding(TestHeaderBase):
+
+    def cte_as_value(self,
+                     source,
+                     cte,
+                     *args):
+        l = len(args)
+        defects =  args[0] if l>0 else []
+        decoded =  args[1] if l>1 and args[1] is not DITTO else source
+        header = 'Content-Transfer-Encoding:' + ' ' if source else ''
+        folded = args[2] if l>2 else header + source + '\n'
+        h = self.make_header('Content-Transfer-Encoding', source)
+        self.assertEqual(h.cte, cte)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    cte_params = {
+
+        'RFC_2183_1': (
+            'base64',
+            'base64',),
+
+        'no_value': (
+            '',
+            '7bit',
+            [errors.HeaderMissingRequiredValue],
+            '',
+            'Content-Transfer-Encoding:\n',
+            ),
+
+        'junk_after_cte': (
+            '7bit and a bunch more',
+            '7bit',
+            [errors.InvalidHeaderDefect]),
+
+        'extra_space_after_cte': (
+            'base64 ',
+            'base64',
+            []),
+
+    }
+
+
+@parameterize
+class TestContentDisposition(TestHeaderBase):
+
+    def content_disp_as_value(self,
+                              source,
+                              content_disposition,
+                              *args):
+        l = len(args)
+        parmdict = args[0] if l>0 else {}
+        defects =  args[1] if l>1 else []
+        decoded =  args[2] if l>2 and args[2] is not DITTO else source
+        header = 'Content-Disposition:' + ' ' if source else ''
+        folded = args[3] if l>3 else header + source + '\n'
+        h = self.make_header('Content-Disposition', source)
+        self.assertEqual(h.content_disposition, content_disposition)
+        self.assertEqual(h.params, parmdict)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.fold(policy=policy.default), folded)
+
+    content_disp_params = {
+
+        # Examples from RFC 2183.
+
+        'RFC_2183_1': (
+            'inline',
+            'inline',),
+
+        'RFC_2183_2': (
+            ('attachment; filename=genome.jpeg;'
+             '  modification-date="Wed, 12 Feb 1997 16:29:51 -0500";'),
+            'attachment',
+            {'filename': 'genome.jpeg',
+             'modification-date': 'Wed, 12 Feb 1997 16:29:51 -0500'},
+            [],
+            ('attachment; filename="genome.jpeg"; '
+                 'modification-date="Wed, 12 Feb 1997 16:29:51 -0500"'),
+            ('Content-Disposition: attachment; filename="genome.jpeg";\n'
+             ' modification-date="Wed, 12 Feb 1997 16:29:51 -0500"\n'),
+            ),
+
+        'no_value': (
+            '',
+            None,
+            {},
+            [errors.HeaderMissingRequiredValue],
+            '',
+            'Content-Disposition:\n'),
+
+        'invalid_value': (
+            'ab./k',
+            'ab.',
+            {},
+            [errors.InvalidHeaderDefect]),
+
+        'invalid_value_with_params': (
+            'ab./k; filename="foo"',
+            'ab.',
+            {'filename': 'foo'},
+            [errors.InvalidHeaderDefect]),
+
+        'invalid_parameter_value_with_fws_between_ew': (
+            'attachment; filename="=?UTF-8?Q?Schulbesuchsbest=C3=A4ttigung=2E?='
+            '               =?UTF-8?Q?pdf?="',
+            'attachment',
+            {'filename': 'Schulbesuchsbestättigung.pdf'},
+            [errors.InvalidHeaderDefect]*3,
+            ('attachment; filename="Schulbesuchsbestättigung.pdf"'),
+            ('Content-Disposition: attachment;\n'
+             ' filename*=utf-8\'\'Schulbesuchsbest%C3%A4ttigung.pdf\n'),
+            ),
+
+        'parameter_value_with_fws_between_tokens': (
+            'attachment; filename="File =?utf-8?q?Name?= With Spaces.pdf"',
+            'attachment',
+            {'filename': 'File Name With Spaces.pdf'},
+            [errors.InvalidHeaderDefect],
+            'attachment; filename="File Name With Spaces.pdf"',
+            ('Content-Disposition: attachment; filename="File Name With Spaces.pdf"\n'),
+            )
+    }
+
+
+@parameterize
+class TestMIMEVersionHeader(TestHeaderBase):
+
+    def version_string_as_MIME_Version(self,
+                                       source,
+                                       decoded,
+                                       version,
+                                       major,
+                                       minor,
+                                       defects):
+        h = self.make_header('MIME-Version', source)
+        self.assertEqual(h, decoded)
+        self.assertEqual(h.version, version)
+        self.assertEqual(h.major, major)
+        self.assertEqual(h.minor, minor)
+        self.assertDefectsEqual(h.defects, defects)
+        if source:
+            source = ' ' + source
+        self.assertEqual(h.fold(policy=policy.default),
+                         'MIME-Version:' + source + '\n')
+
+    version_string_params = {
+
+        # Examples from the RFC.
+
+        'RFC_2045_1': (
+            '1.0',
+            '1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_2': (
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0 (produced by MetaSend Vx.x)',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_3': (
+            '(produced by MetaSend Vx.x) 1.0',
+            '(produced by MetaSend Vx.x) 1.0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'RFC_2045_4': (
+            '1.(produced by MetaSend Vx.x)0',
+            '1.(produced by MetaSend Vx.x)0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        # Other valid values.
+
+        '1_1': (
+            '1.1',
+            '1.1',
+            '1.1',
+            1,
+            1,
+            []),
+
+        '2_1': (
+            '2.1',
+            '2.1',
+            '2.1',
+            2,
+            1,
+            []),
+
+        'whitespace': (
+            '1 .0',
+            '1 .0',
+            '1.0',
+            1,
+            0,
+            []),
+
+        'leading_trailing_whitespace_ignored': (
+            '  1.0  ',
+            '  1.0  ',
+            '1.0',
+            1,
+            0,
+            []),
+
+        # Recoverable invalid values.  We can recover here only because we
+        # already have a valid value by the time we encounter the garbage.
+        # Anywhere else, and we don't know where the garbage ends.
+
+        'non_comment_garbage_after': (
+            '1.0 <abc>',
+            '1.0 <abc>',
+            '1.0',
+            1,
+            0,
+            [errors.InvalidHeaderDefect]),
+
+        # Unrecoverable invalid values.  We *could* apply more heuristics to
+        # get something out of the first two, but doing so is not worth the
+        # effort.
+
+        'non_comment_garbage_before': (
+            '<abc> 1.0',
+            '<abc> 1.0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'non_comment_garbage_inside': (
+            '1.<abc>0',
+            '1.<abc>0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'two_periods': (
+            '1..0',
+            '1..0',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        '2_x': (
+            '2.x',
+            '2.x',
+            None,  # This could be 2, but it seems safer to make it None.
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'foo': (
+            'foo',
+            'foo',
+            None,
+            None,
+            None,
+            [errors.InvalidHeaderDefect]),
+
+        'missing': (
+            '',
+            '',
+            None,
+            None,
+            None,
+            [errors.HeaderMissingRequiredValue]),
+
+        }
+
+
+@parameterize
+class TestAddressHeader(TestHeaderBase):
+
+    example_params = {
+
+        'empty':
+            ('<>',
+             [errors.InvalidHeaderDefect],
+             '<>',
+             '',
+             '<>',
+             '',
+             '',
+             None),
+
+        'address_only':
+            ('zippy@pinhead.com',
+             [],
+             'zippy@pinhead.com',
+             '',
+             'zippy@pinhead.com',
+             'zippy',
+             'pinhead.com',
+             None),
+
+        'name_and_address':
+            ('Zaphrod Beblebrux <zippy@pinhead.com>',
+             [],
+             'Zaphrod Beblebrux <zippy@pinhead.com>',
+             'Zaphrod Beblebrux',
+             'zippy@pinhead.com',
+             'zippy',
+             'pinhead.com',
+             None),
+
+        'quoted_local_part':
+            ('Zaphrod Beblebrux <"foo bar"@pinhead.com>',
+             [],
+             'Zaphrod Beblebrux <"foo bar"@pinhead.com>',
+             'Zaphrod Beblebrux',
+             '"foo bar"@pinhead.com',
+             'foo bar',
+             'pinhead.com',
+             None),
+
+        'quoted_parens_in_name':
+            (r'"A \(Special\) Person" <person@dom.ain>',
+             [],
+             '"A (Special) Person" <person@dom.ain>',
+             'A (Special) Person',
+             'person@dom.ain',
+             'person',
+             'dom.ain',
+             None),
+
+        'quoted_backslashes_in_name':
+            (r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>',
+             [],
+             r'"Arthur \\Backslash\\ Foobar" <person@dom.ain>',
+             r'Arthur \Backslash\ Foobar',
+             'person@dom.ain',
+             'person',
+             'dom.ain',
+             None),
+
+        'name_with_dot':
+            ('John X. Doe <jxd@example.com>',
+             [errors.ObsoleteHeaderDefect],
+             '"John X. Doe" <jxd@example.com>',
+             'John X. Doe',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        'quoted_strings_in_local_part':
+            ('""example" example"@example.com',
+             [errors.InvalidHeaderDefect]*3,
+             '"example example"@example.com',
+             '',
+             '"example example"@example.com',
+             'example example',
+             'example.com',
+             None),
+
+        'escaped_quoted_strings_in_local_part':
+            (r'"\"example\" example"@example.com',
+             [],
+             r'"\"example\" example"@example.com',
+             '',
+             r'"\"example\" example"@example.com',
+             r'"example" example',
+             'example.com',
+            None),
+
+        'escaped_escapes_in_local_part':
+            (r'"\\"example\\" example"@example.com',
+             [errors.InvalidHeaderDefect]*5,
+             r'"\\example\\\\ example"@example.com',
+             '',
+             r'"\\example\\\\ example"@example.com',
+             r'\example\\ example',
+             'example.com',
+            None),
+
+        'spaces_in_unquoted_local_part_collapsed':
+            ('merwok  wok  @example.com',
+             [errors.InvalidHeaderDefect]*2,
+             '"merwok wok"@example.com',
+             '',
+             '"merwok wok"@example.com',
+             'merwok wok',
+             'example.com',
+             None),
+
+        'spaces_around_dots_in_local_part_removed':
+            ('merwok. wok .  wok@example.com',
+             [errors.ObsoleteHeaderDefect],
+             'merwok.wok.wok@example.com',
+             '',
+             'merwok.wok.wok@example.com',
+             'merwok.wok.wok',
+             'example.com',
+             None),
+
+        'rfc2047_atom_is_decoded':
+            ('=?utf-8?q?=C3=89ric?= <foo@example.com>',
+            [],
+            'Éric <foo@example.com>',
+            'Éric',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'rfc2047_atom_in_phrase_is_decoded':
+            ('The =?utf-8?q?=C3=89ric=2C?= Himself <foo@example.com>',
+            [],
+            '"The Éric, Himself" <foo@example.com>',
+            'The Éric, Himself',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'rfc2047_atom_in_quoted_string_is_decoded':
+            ('"=?utf-8?q?=C3=89ric?=" <foo@example.com>',
+            [errors.InvalidHeaderDefect,
+            errors.InvalidHeaderDefect],
+            'Éric <foo@example.com>',
+            'Éric',
+            'foo@example.com',
+            'foo',
+            'example.com',
+            None),
+
+        'name_ending_with_dot_without_space':
+            ('John X.<jxd@example.com>',
+             [errors.ObsoleteHeaderDefect],
+             '"John X." <jxd@example.com>',
+             'John X.',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        'name_starting_with_dot':
+            ('. Doe <jxd@example.com>',
+             [errors.InvalidHeaderDefect, errors.ObsoleteHeaderDefect],
+             '". Doe" <jxd@example.com>',
+             '. Doe',
+             'jxd@example.com',
+             'jxd',
+             'example.com',
+             None),
+
+        }
+
+        # XXX: Need many more examples, and in particular some with names in
+        # trailing comments, which aren't currently handled.  comments in
+        # general are not handled yet.
+
+    def example_as_address(self, source, defects, decoded, display_name,
+                           addr_spec, username, domain, comment):
+        h = self.make_header('sender', source)
+        self.assertEqual(h, decoded)
+        self.assertDefectsEqual(h.defects, defects)
+        a = h.address
+        self.assertEqual(str(a), decoded)
+        self.assertEqual(len(h.groups), 1)
+        self.assertEqual([a], list(h.groups[0].addresses))
+        self.assertEqual([a], list(h.addresses))
+        self.assertEqual(a.display_name, display_name)
+        self.assertEqual(a.addr_spec, addr_spec)
+        self.assertEqual(a.username, username)
+        self.assertEqual(a.domain, domain)
+        # XXX: we have no comment support yet.
+        #self.assertEqual(a.comment, comment)
+
+    def example_as_group(self, source, defects, decoded, display_name,
+                         addr_spec, username, domain, comment):
+        source = 'foo: {};'.format(source)
+        gdecoded = 'foo: {};'.format(decoded) if decoded else 'foo:;'
+        h = self.make_header('to', source)
+        self.assertEqual(h, gdecoded)
+        self.assertDefectsEqual(h.defects, defects)
+        self.assertEqual(h.groups[0].addresses, h.addresses)
+        self.assertEqual(len(h.groups), 1)
+        self.assertEqual(len(h.addresses), 1)
+        a = h.addresses[0]
+        self.assertEqual(str(a), decoded)
+        self.assertEqual(a.display_name, display_name)
+        self.assertEqual(a.addr_spec, addr_spec)
+        self.assertEqual(a.username, username)
+        self.assertEqual(a.domain, domain)
+
+    def test_simple_address_list(self):
+        value = ('Fred <dinsdale@python.org>, foo@example.com, '
+                    '"Harry W. Hastings" <hasty@example.com>')
+        h = self.make_header('to', value)
+        self.assertEqual(h, value)
+        self.assertEqual(len(h.groups), 3)
+        self.assertEqual(len(h.addresses), 3)
+        for i in range(3):
+            self.assertEqual(h.groups[i].addresses[0], h.addresses[i])
+        self.assertEqual(str(h.addresses[0]), 'Fred <dinsdale@python.org>')
+        self.assertEqual(str(h.addresses[1]), 'foo@example.com')
+        self.assertEqual(str(h.addresses[2]),
+            '"Harry W. Hastings" <hasty@example.com>')
+        self.assertEqual(h.addresses[2].display_name,
+            'Harry W. Hastings')
+
+    def test_complex_address_list(self):
+        examples = list(self.example_params.values())
+        source = ('dummy list:;, another: (empty);,' +
+                 ', '.join([x[0] for x in examples[:4]]) + ', ' +
+                 r'"A \"list\"": ' +
+                    ', '.join([x[0] for x in examples[4:6]]) + ';,' +
+                 ', '.join([x[0] for x in examples[6:]])
+            )
+        # XXX: the fact that (empty) disappears here is a potential API design
+        # bug.  We don't currently have a way to preserve comments.
+        expected = ('dummy list:;, another:;, ' +
+                 ', '.join([x[2] for x in examples[:4]]) + ', ' +
+                 r'"A \"list\"": ' +
+                    ', '.join([x[2] for x in examples[4:6]]) + ';, ' +
+                 ', '.join([x[2] for x in examples[6:]])
+            )
+
+        h = self.make_header('to', source)
+        self.assertEqual(h.split(','), expected.split(','))
+        self.assertEqual(h, expected)
+        self.assertEqual(len(h.groups), 7 + len(examples) - 6)
+        self.assertEqual(h.groups[0].display_name, 'dummy list')
+        self.assertEqual(h.groups[1].display_name, 'another')
+        self.assertEqual(h.groups[6].display_name, 'A "list"')
+        self.assertEqual(len(h.addresses), len(examples))
+        for i in range(4):
+            self.assertIsNone(h.groups[i+2].display_name)
+            self.assertEqual(str(h.groups[i+2].addresses[0]), examples[i][2])
+        for i in range(7, 7 + len(examples) - 6):
+            self.assertIsNone(h.groups[i].display_name)
+            self.assertEqual(str(h.groups[i].addresses[0]), examples[i-1][2])
+        for i in range(len(examples)):
+            self.assertEqual(str(h.addresses[i]), examples[i][2])
+            self.assertEqual(h.addresses[i].addr_spec, examples[i][4])
+
+    def test_address_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.address = 'foo'
+
+    def test_addresses_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.addresses = 'foo'
+
+    def test_groups_read_only(self):
+        h = self.make_header('sender', 'abc@xyz.com')
+        with self.assertRaises(AttributeError):
+            h.groups = 'foo'
+
+    def test_addresses_types(self):
+        source = 'me <who@example.com>'
+        h = self.make_header('to', source)
+        self.assertIsInstance(h.addresses, tuple)
+        self.assertIsInstance(h.addresses[0], Address)
+
+    def test_groups_types(self):
+        source = 'me <who@example.com>'
+        h = self.make_header('to', source)
+        self.assertIsInstance(h.groups, tuple)
+        self.assertIsInstance(h.groups[0], Group)
+
+    def test_set_from_Address(self):
+        h = self.make_header('to', Address('me', 'foo', 'example.com'))
+        self.assertEqual(h, 'me <foo@example.com>')
+
+    def test_set_from_Address_list(self):
+        h = self.make_header('to', [Address('me', 'foo', 'example.com'),
+                                    Address('you', 'bar', 'example.com')])
+        self.assertEqual(h, 'me <foo@example.com>, you <bar@example.com>')
+
+    def test_set_from_Address_and_Group_list(self):
+        h = self.make_header('to', [Address('me', 'foo', 'example.com'),
+                                    Group('bing', [Address('fiz', 'z', 'b.com'),
+                                                   Address('zif', 'f', 'c.com')]),
+                                    Address('you', 'bar', 'example.com')])
+        self.assertEqual(h, 'me <foo@example.com>, bing: fiz <z@b.com>, '
+                            'zif <f@c.com>;, you <bar@example.com>')
+        self.assertEqual(h.fold(policy=policy.default.clone(max_line_length=40)),
+                        'to: me <foo@example.com>,\n'
+                        ' bing: fiz <z@b.com>, zif <f@c.com>;,\n'
+                        ' you <bar@example.com>\n')
+
+    def test_set_from_Group_list(self):
+        h = self.make_header('to', [Group('bing', [Address('fiz', 'z', 'b.com'),
+                                                   Address('zif', 'f', 'c.com')])])
+        self.assertEqual(h, 'bing: fiz <z@b.com>, zif <f@c.com>;')
+
+
+class TestAddressAndGroup(TestEmailBase):
+
+    def _test_attr_ro(self, obj, attr):
+        with self.assertRaises(AttributeError):
+            setattr(obj, attr, 'foo')
+
+    def test_address_display_name_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'display_name')
+
+    def test_address_username_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'username')
+
+    def test_address_domain_ro(self):
+        self._test_attr_ro(Address('foo', 'bar', 'baz'), 'domain')
+
+    def test_group_display_name_ro(self):
+        self._test_attr_ro(Group('foo'), 'display_name')
+
+    def test_group_addresses_ro(self):
+        self._test_attr_ro(Group('foo'), 'addresses')
+
+    def test_address_from_username_domain(self):
+        a = Address('foo', 'bar', 'baz')
+        self.assertEqual(a.display_name, 'foo')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'foo <bar@baz>')
+
+    def test_address_from_addr_spec(self):
+        a = Address('foo', addr_spec='bar@baz')
+        self.assertEqual(a.display_name, 'foo')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'foo <bar@baz>')
+
+    def test_address_with_no_display_name(self):
+        a = Address(addr_spec='bar@baz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, 'bar')
+        self.assertEqual(a.domain, 'baz')
+        self.assertEqual(a.addr_spec, 'bar@baz')
+        self.assertEqual(str(a), 'bar@baz')
+
+    def test_null_address(self):
+        a = Address()
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, '<>')
+        self.assertEqual(str(a), '<>')
+
+    def test_domain_only(self):
+        # This isn't really a valid address.
+        a = Address(domain='buzz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, 'buzz')
+        self.assertEqual(a.addr_spec, '@buzz')
+        self.assertEqual(str(a), '@buzz')
+
+    def test_username_only(self):
+        # This isn't really a valid address.
+        a = Address(username='buzz')
+        self.assertEqual(a.display_name, '')
+        self.assertEqual(a.username, 'buzz')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, 'buzz')
+        self.assertEqual(str(a), 'buzz')
+
+    def test_display_name_only(self):
+        a = Address('buzz')
+        self.assertEqual(a.display_name, 'buzz')
+        self.assertEqual(a.username, '')
+        self.assertEqual(a.domain, '')
+        self.assertEqual(a.addr_spec, '<>')
+        self.assertEqual(str(a), 'buzz <>')
+
+    def test_quoting(self):
+        # Ideally we'd check every special individually, but I'm not up for
+        # writing that many tests.
+        a = Address('Sara J.', 'bad name', 'example.com')
+        self.assertEqual(a.display_name, 'Sara J.')
+        self.assertEqual(a.username, 'bad name')
+        self.assertEqual(a.domain, 'example.com')
+        self.assertEqual(a.addr_spec, '"bad name"@example.com')
+        self.assertEqual(str(a), '"Sara J." <"bad name"@example.com>')
+
+    def test_il8n(self):
+        a = Address('Éric', 'wok', 'exàmple.com')
+        self.assertEqual(a.display_name, 'Éric')
+        self.assertEqual(a.username, 'wok')
+        self.assertEqual(a.domain, 'exàmple.com')
+        self.assertEqual(a.addr_spec, 'wok@exàmple.com')
+        self.assertEqual(str(a), 'Éric <wok@exàmple.com>')
+
+    # XXX: there is an API design issue that needs to be solved here.
+    #def test_non_ascii_username_raises(self):
+    #    with self.assertRaises(ValueError):
+    #        Address('foo', 'wők', 'example.com')
+
+    def test_crlf_in_constructor_args_raises(self):
+        cases = (
+            dict(display_name='foo\r'),
+            dict(display_name='foo\n'),
+            dict(display_name='foo\r\n'),
+            dict(domain='example.com\r'),
+            dict(domain='example.com\n'),
+            dict(domain='example.com\r\n'),
+            dict(username='wok\r'),
+            dict(username='wok\n'),
+            dict(username='wok\r\n'),
+            dict(addr_spec='wok@example.com\r'),
+            dict(addr_spec='wok@example.com\n'),
+            dict(addr_spec='wok@example.com\r\n')
+        )
+        for kwargs in cases:
+            with self.subTest(kwargs=kwargs), self.assertRaisesRegex(ValueError, "invalid arguments"):
+                Address(**kwargs)
+
+    def test_non_ascii_username_in_addr_spec_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec='wők@example.com')
+
+    def test_address_addr_spec_and_username_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', username='bing', addr_spec='bar@baz')
+
+    def test_address_addr_spec_and_domain_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', domain='bing', addr_spec='bar@baz')
+
+    def test_address_addr_spec_and_username_and_domain_raises(self):
+        with self.assertRaises(TypeError):
+            Address('foo', username='bong', domain='bing', addr_spec='bar@baz')
+
+    def test_space_in_addr_spec_username_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec="bad name@example.com")
+
+    def test_bad_addr_sepc_raises(self):
+        with self.assertRaises(ValueError):
+            Address('foo', addr_spec="name@ex[]ample.com")
+
+    def test_empty_group(self):
+        g = Group('foo')
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo:;')
+
+    def test_empty_group_list(self):
+        g = Group('foo', addresses=[])
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo:;')
+
+    def test_null_group(self):
+        g = Group()
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'None:;')
+
+    def test_group_with_addresses(self):
+        addrs = [Address('b', 'b', 'c'), Address('a', 'b','c')]
+        g = Group('foo', addrs)
+        self.assertEqual(g.display_name, 'foo')
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'foo: b <b@c>, a <b@c>;')
+
+    def test_group_with_addresses_no_display_name(self):
+        addrs = [Address('b', 'b', 'c'), Address('a', 'b','c')]
+        g = Group(addresses=addrs)
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'None: b <b@c>, a <b@c>;')
+
+    def test_group_with_one_address_no_display_name(self):
+        addrs = [Address('b', 'b', 'c')]
+        g = Group(addresses=addrs)
+        self.assertIsNone(g.display_name)
+        self.assertEqual(g.addresses, tuple(addrs))
+        self.assertEqual(str(g), 'b <b@c>')
+
+    def test_display_name_quoting(self):
+        g = Group('foo.bar')
+        self.assertEqual(g.display_name, 'foo.bar')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), '"foo.bar":;')
+
+    def test_display_name_blanks_not_quoted(self):
+        g = Group('foo bar')
+        self.assertEqual(g.display_name, 'foo bar')
+        self.assertEqual(g.addresses, tuple())
+        self.assertEqual(str(g), 'foo bar:;')
+
+    def test_set_message_header_from_address(self):
+        a = Address('foo', 'bar', 'example.com')
+        m = Message(policy=policy.default)
+        m['To'] = a
+        self.assertEqual(m['to'], 'foo <bar@example.com>')
+        self.assertEqual(m['to'].addresses, (a,))
+
+    def test_set_message_header_from_group(self):
+        g = Group('foo bar')
+        m = Message(policy=policy.default)
+        m['To'] = g
+        self.assertEqual(m['to'], 'foo bar:;')
+        self.assertEqual(m['to'].addresses, g.addresses)
+
+    def test_address_comparison(self):
+        a = Address('foo', 'bar', 'example.com')
+        self.assertEqual(Address('foo', 'bar', 'example.com'), a)
+        self.assertNotEqual(Address('baz', 'bar', 'example.com'), a)
+        self.assertNotEqual(Address('foo', 'baz', 'example.com'), a)
+        self.assertNotEqual(Address('foo', 'bar', 'baz'), a)
+        self.assertFalse(a == object())
+        self.assertTrue(a == ALWAYS_EQ)
+
+    def test_group_comparison(self):
+        a = Address('foo', 'bar', 'example.com')
+        g = Group('foo bar', [a])
+        self.assertEqual(Group('foo bar', (a,)), g)
+        self.assertNotEqual(Group('baz', [a]), g)
+        self.assertNotEqual(Group('foo bar', []), g)
+        self.assertFalse(g == object())
+        self.assertTrue(g == ALWAYS_EQ)
+
+
+class TestFolding(TestHeaderBase):
+
+    def test_address_display_names(self):
+        """Test the folding and encoding of address headers."""
+        for name, result in (
+                ('Foo Bar, France', '"Foo Bar, France"'),
+                ('Foo Bar (France)', '"Foo Bar (France)"'),
+                ('Foo Bar, España', 'Foo =?utf-8?q?Bar=2C_Espa=C3=B1a?='),
+                ('Foo Bar (España)', 'Foo Bar =?utf-8?b?KEVzcGHDsWEp?='),
+                ('Foo, Bar España', '=?utf-8?q?Foo=2C_Bar_Espa=C3=B1a?='),
+                ('Foo, Bar [España]', '=?utf-8?q?Foo=2C_Bar_=5BEspa=C3=B1a=5D?='),
+                ('Foo Bär, France', 'Foo =?utf-8?q?B=C3=A4r=2C?= France'),
+                ('Foo Bär <France>', 'Foo =?utf-8?q?B=C3=A4r_=3CFrance=3E?='),
+                (
+                    'Lôrem ipsum dôlôr sit amet, cônsectetuer adipiscing. '
+                    'Suspendisse pôtenti. Aliquam nibh. Suspendisse pôtenti.',
+                    '=?utf-8?q?L=C3=B4rem_ipsum_d=C3=B4l=C3=B4r_sit_amet=2C_c'
+                    '=C3=B4nsectetuer?=\n =?utf-8?q?_adipiscing=2E_Suspendisse'
+                    '_p=C3=B4tenti=2E_Aliquam_nibh=2E?=\n Suspendisse =?utf-8'
+                    '?q?p=C3=B4tenti=2E?=',
+                    ),
+                ):
+            h = self.make_header('To', Address(name, addr_spec='a@b.com'))
+            self.assertEqual(h.fold(policy=policy.default),
+                                    'To: %s <a@b.com>\n' % result)
+
+    def test_short_unstructured(self):
+        h = self.make_header('subject', 'this is a test')
+        self.assertEqual(h.fold(policy=policy.default),
+                         'subject: this is a test\n')
+
+    def test_long_unstructured(self):
+        h = self.make_header('Subject', 'This is a long header '
+            'line that will need to be folded into two lines '
+            'and will demonstrate basic folding')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Subject: This is a long header line that will '
+                            'need to be folded into two lines\n'
+                        ' and will demonstrate basic folding\n')
+
+    def test_unstructured_short_max_line_length(self):
+        h = self.make_header('Subject', 'this is a short header '
+            'that will be folded anyway')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            textwrap.dedent("""\
+                Subject: this is a
+                 short header that
+                 will be folded
+                 anyway
+                """))
+
+    def test_fold_unstructured_single_word(self):
+        h = self.make_header('Subject', 'test')
+        self.assertEqual(h.fold(policy=policy.default), 'Subject: test\n')
+
+    def test_fold_unstructured_short(self):
+        h = self.make_header('Subject', 'test test test')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Subject: test test test\n')
+
+    def test_fold_unstructured_with_overlong_word(self):
+        h = self.make_header('Subject', 'thisisaverylonglineconsistingofa'
+            'singlewordthatwontfit')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Subject: \n'
+            ' =?utf-8?q?thisisa?=\n'
+            ' =?utf-8?q?verylon?=\n'
+            ' =?utf-8?q?glineco?=\n'
+            ' =?utf-8?q?nsistin?=\n'
+            ' =?utf-8?q?gofasin?=\n'
+            ' =?utf-8?q?gleword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit?=\n'
+            )
+
+    def test_fold_unstructured_with_two_overlong_words(self):
+        h = self.make_header('Subject', 'thisisaverylonglineconsistingofa'
+            'singlewordthatwontfit plusanotherverylongwordthatwontfit')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Subject: \n'
+            ' =?utf-8?q?thisisa?=\n'
+            ' =?utf-8?q?verylon?=\n'
+            ' =?utf-8?q?glineco?=\n'
+            ' =?utf-8?q?nsistin?=\n'
+            ' =?utf-8?q?gofasin?=\n'
+            ' =?utf-8?q?gleword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit_pl?=\n'
+            ' =?utf-8?q?usanoth?=\n'
+            ' =?utf-8?q?erveryl?=\n'
+            ' =?utf-8?q?ongword?=\n'
+            ' =?utf-8?q?thatwon?=\n'
+            ' =?utf-8?q?tfit?=\n'
+            )
+
+    # XXX Need test for when max_line_length is less than the chrome size.
+
+    def test_fold_unstructured_with_slightly_long_word(self):
+        h = self.make_header('Subject', 'thislongwordislessthanmaxlinelen')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=35)),
+            'Subject:\n thislongwordislessthanmaxlinelen\n')
+
+    def test_fold_unstructured_with_commas(self):
+        # The old wrapper would fold this at the commas.
+        h = self.make_header('Subject', "This header is intended to "
+            "demonstrate, in a fairly succinct way, that we now do "
+            "not give a , special treatment in unstructured headers.")
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=60)),
+            textwrap.dedent("""\
+                Subject: This header is intended to demonstrate, in a fairly
+                 succinct way, that we now do not give a , special treatment
+                 in unstructured headers.
+                 """))
+
+    def test_fold_address_list(self):
+        h = self.make_header('To', '"Theodore H. Perfect" <yes@man.com>, '
+            '"My address is very long because my name is long" <foo@bar.com>, '
+            '"Only A. Friend" <no@yes.com>')
+        self.assertEqual(h.fold(policy=policy.default), textwrap.dedent("""\
+            To: "Theodore H. Perfect" <yes@man.com>,
+             "My address is very long because my name is long" <foo@bar.com>,
+             "Only A. Friend" <no@yes.com>
+             """))
+
+    def test_fold_date_header(self):
+        h = self.make_header('Date', 'Sat, 2 Feb 2002 17:00:06 -0800')
+        self.assertEqual(h.fold(policy=policy.default),
+                        'Date: Sat, 02 Feb 2002 17:00:06 -0800\n')
+
+    def test_fold_overlong_words_using_RFC2047(self):
+        h = self.make_header(
+            'X-Report-Abuse',
+            '<https://www.mailitapp.com/report_abuse.php?'
+              'mid=xxx-xxx-xxxxxxxxxxxxxxxxxxxxxxxx==-xxx-xx-xx>')
+        self.assertEqual(
+            h.fold(policy=policy.default),
+            'X-Report-Abuse: =?utf-8?q?=3Chttps=3A//www=2Emailitapp=2E'
+                'com/report=5Fabuse?=\n'
+            ' =?utf-8?q?=2Ephp=3Fmid=3Dxxx-xxx-xxxx'
+                'xxxxxxxxxxxxxxxxxxxx=3D=3D-xxx-xx-xx?=\n'
+            ' =?utf-8?q?=3E?=\n')
+
+    def test_message_id_header_is_not_folded(self):
+        h = self.make_header(
+            'Message-ID',
+            '<somemessageidlongerthan@maxlinelength.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID: <somemessageidlongerthan@maxlinelength.com>\n')
+
+        # Test message-id isn't folded when id-right is no-fold-literal.
+        h = self.make_header(
+            'Message-ID',
+            '<somemessageidlongerthan@[127.0.0.0.0.0.0.0.0.1]>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID: <somemessageidlongerthan@[127.0.0.0.0.0.0.0.0.1]>\n')
+
+        # Test message-id isn't folded when id-right is non-ascii characters.
+        h = self.make_header('Message-ID', '<ईमेल@wők.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=30)),
+            'Message-ID: <ईमेल@wők.com>\n')
+
+        # Test message-id is folded without breaking the msg-id token into
+        # encoded words, *even* if they don't fit into max_line_length.
+        h = self.make_header('Message-ID', '<ईमेलfromMessage@wők.com>')
+        self.assertEqual(
+            h.fold(policy=policy.default.clone(max_line_length=20)),
+            'Message-ID:\n <ईमेलfromMessage@wők.com>\n')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_inversion.py b/Lib/test/test_email/test_inversion.py
new file mode 100644
index 0000000000..7bd7f2a720
--- /dev/null
+++ b/Lib/test/test_email/test_inversion.py
@@ -0,0 +1,78 @@
+"""Test the parser and generator are inverses.
+
+Note that this is only strictly true if we are parsing RFC valid messages and
+producing RFC valid messages.
+"""
+
+import io
+import unittest
+from email import policy, message_from_bytes
+from email.message import EmailMessage
+from email.generator import BytesGenerator
+from test.test_email import TestEmailBase, parameterize
+
+# This is like textwrap.dedent for bytes, except that it uses \r\n for the line
+# separators on the rebuilt string.
+def dedent(bstr):
+    lines = bstr.splitlines()
+    if not lines[0].strip():
+        raise ValueError("First line must contain text")
+    stripamt = len(lines[0]) - len(lines[0].lstrip())
+    return b'\r\n'.join(
+        [x[stripamt:] if len(x)>=stripamt else b''
+            for x in lines])
+
+
+@parameterize
+class TestInversion(TestEmailBase):
+
+    policy = policy.default
+    message = EmailMessage
+
+    def msg_as_input(self, msg):
+        m = message_from_bytes(msg, policy=policy.SMTP)
+        b = io.BytesIO()
+        g = BytesGenerator(b)
+        g.flatten(m)
+        self.assertEqual(b.getvalue(), msg)
+
+    # XXX: spaces are not preserved correctly here yet in the general case.
+    msg_params = {
+        'header_with_one_space_body': (dedent(b"""\
+            From: abc@xyz.com
+            X-Status:\x20
+            Subject: test
+
+            foo
+            """),),
+
+        'header_with_invalid_date': (dedent(b"""\
+            Date: Tue, 06 Jun 2017 27:39:33 +0600
+            From: abc@xyz.com
+            Subject: timezones
+
+            How do they work even?
+            """),),
+
+            }
+
+    payload_params = {
+        'plain_text': dict(payload='This is a test\n'*20),
+        'base64_text': dict(payload=(('xy a'*40+'\n')*5), cte='base64'),
+        'qp_text': dict(payload=(('xy a'*40+'\n')*5), cte='quoted-printable'),
+        }
+
+    def payload_as_body(self, payload, **kw):
+        msg = self._make_message()
+        msg['From'] = 'foo'
+        msg['To'] = 'bar'
+        msg['Subject'] = 'payload round trip test'
+        msg.set_content(payload, **kw)
+        b = bytes(msg)
+        msg2 = message_from_bytes(b, policy=self.policy)
+        self.assertEqual(bytes(msg2), b)
+        self.assertEqual(msg2.get_content(), payload)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_message.py b/Lib/test/test_email/test_message.py
new file mode 100644
index 0000000000..966615dcc1
--- /dev/null
+++ b/Lib/test/test_email/test_message.py
@@ -0,0 +1,1094 @@
+import textwrap
+import unittest
+from email import message_from_bytes, message_from_string, policy
+from email.message import EmailMessage, MIMEPart
+from test.test_email import TestEmailBase, parameterize
+
+
+# Helper.
+def first(iterable):
+    return next(filter(lambda x: x is not None, iterable), None)
+
+
+class Test(TestEmailBase):
+
+    policy = policy.default
+
+    def test_error_on_setitem_if_max_count_exceeded(self):
+        m = self._str_msg("")
+        m['To'] = 'abc@xyz'
+        with self.assertRaises(ValueError):
+            m['To'] = 'xyz@abc'
+
+    def test_rfc2043_auto_decoded_and_emailmessage_used(self):
+        m = message_from_string(textwrap.dedent("""\
+            Subject: Ayons asperges pour le =?utf-8?q?d=C3=A9jeuner?=
+            From: =?utf-8?q?Pep=C3=A9?= Le Pew <pepe@example.com>
+            To: "Penelope Pussycat" <"penelope@example.com">
+            MIME-Version: 1.0
+            Content-Type: text/plain; charset="utf-8"
+
+            sample text
+            """), policy=policy.default)
+        self.assertEqual(m['subject'], "Ayons asperges pour le déjeuner")
+        self.assertEqual(m['from'], "Pepé Le Pew <pepe@example.com>")
+        self.assertIsInstance(m, EmailMessage)
+
+
+@parameterize
+class TestEmailMessageBase:
+
+    policy = policy.default
+
+    # The first argument is a triple (related, html, plain) of indices into the
+    # list returned by 'walk' called on a Message constructed from the third.
+    # The indices indicate which part should match the corresponding part-type
+    # when passed to get_body (ie: the "first" part of that type in the
+    # message).  The second argument is a list of indices into the 'walk' list
+    # of the attachments that should be returned by a call to
+    # 'iter_attachments'.  The third argument is a list of indices into 'walk'
+    # that should be returned by a call to 'iter_parts'.  Note that the first
+    # item returned by 'walk' is the Message itself.
+
+    message_params = {
+
+        'empty_message': (
+            (None, None, 0),
+            (),
+            (),
+            ""),
+
+        'non_mime_plain': (
+            (None, None, 0),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+
+                simple text body
+                """)),
+
+        'mime_non_text': (
+            (None, None, None),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: image/jpg
+
+                bogus body.
+                """)),
+
+        'plain_html_alternative': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/alternative; boundary="==="
+
+                preamble
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+                --===--
+                """)),
+
+        'plain_html_mixed': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                preamble
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'plain_html_attachment_mixed': (
+            (None, None, 1),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+
+                simple body
+
+                --===
+                Content-Type: text/html
+                Content-Disposition: attachment
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'html_text_attachment_mixed': (
+            (None, 2, None),
+            (1,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+                Content-Disposition: AtTaChment
+
+                simple body
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        'html_text_attachment_inline_mixed': (
+            (None, 2, 1),
+            (),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+                Content-Disposition: InLine
+
+                simple body
+
+                --===
+                Content-Type: text/html
+                Content-Disposition: inline
+
+                <p>simple body</p>
+
+                --===--
+                """)),
+
+        # RFC 2387
+        'related': (
+            (0, 1, None),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/related; boundary="==="; type=text/html
+
+                --===
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --===
+                Content-Type: image/jpg
+                Content-ID: <image1>
+
+                bogus data
+
+                --===--
+                """)),
+
+        # This message structure will probably never be seen in the wild, but
+        # it proves we distinguish between text parts based on 'start'.  The
+        # content would not, of course, actually work :)
+        'related_with_start': (
+            (0, 2, None),
+            (1,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/related; boundary="==="; type=text/html;
+                 start="<body>"
+
+                --===
+                Content-Type: text/html
+                Content-ID: <include>
+
+                useless text
+
+                --===
+                Content-Type: text/html
+                Content-ID: <body>
+
+                <p>simple body</p>
+                <!--#include file="<include>"-->
+
+                --===--
+                """)),
+
+
+        'mixed_alternative_plain_related': (
+            (3, 4, 2),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/alternative; boundary="+++"
+
+                --+++
+                Content-Type: text/plain
+
+                simple body
+
+                --+++
+                Content-Type: multipart/related; boundary="___"
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --___--
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: AttacHmenT
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        # This structure suggested by Stephen J. Turnbull...may not exist/be
+        # supported in the wild, but we want to support it.
+        'mixed_related_alternative_plain_html': (
+            (1, 4, 3),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/related; boundary="+++"
+
+                --+++
+                Content-Type: multipart/alternative; boundary="___"
+
+                --___
+                Content-Type: text/plain
+
+                simple body
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___--
+
+                --+++
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        # Same thing, but proving we only look at the root part, which is the
+        # first one if there isn't any start parameter.  That is, this is a
+        # broken related.
+        'mixed_related_alternative_plain_html_wrong_order': (
+            (1, None, None),
+            (6, 7),
+            (1, 6, 7),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: multipart/related; boundary="+++"
+
+                --+++
+                Content-Type: image/jpg
+                Content-ID: <image1@cid>
+
+                bogus jpg body
+
+                --+++
+                Content-Type: multipart/alternative; boundary="___"
+
+                --___
+                Content-Type: text/plain
+
+                simple body
+
+                --___
+                Content-Type: text/html
+
+                <p>simple body</p>
+
+                --___--
+
+                --+++--
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                bogus jpg body
+
+                --===
+                Content-Type: image/jpg
+                Content-Disposition: attachment
+
+                another bogus jpg body
+
+                --===--
+                """)),
+
+        'message_rfc822': (
+            (None, None, None),
+            (),
+            (),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: message/rfc822
+
+                To: bar@example.com
+                From: robot@examp.com
+
+                this is a message body.
+                """)),
+
+        'mixed_text_message_rfc822': (
+            (None, None, 1),
+            (2,),
+            (1, 2),
+            textwrap.dedent("""\
+                To: foo@example.com
+                MIME-Version: 1.0
+                Content-Type: multipart/mixed; boundary="==="
+
+                --===
+                Content-Type: text/plain
+
+                Your message has bounced, sir.
+
+                --===
+                Content-Type: message/rfc822
+
+                To: bar@example.com
+                From: robot@examp.com
+
+                this is a message body.
+
+                --===--
+                """)),
+
+         }
+
+    def message_as_get_body(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        expected = [None if n is None else allparts[n] for n in body_parts]
+        related = 0; html = 1; plain = 2
+        self.assertEqual(m.get_body(), first(expected))
+        self.assertEqual(m.get_body(preferencelist=(
+                                        'related', 'html', 'plain')),
+                         first(expected))
+        self.assertEqual(m.get_body(preferencelist=('related', 'html')),
+                         first(expected[related:html+1]))
+        self.assertEqual(m.get_body(preferencelist=('related', 'plain')),
+                         first([expected[related], expected[plain]]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'plain')),
+                         first(expected[html:plain+1]))
+        self.assertEqual(m.get_body(preferencelist=['related']),
+                         expected[related])
+        self.assertEqual(m.get_body(preferencelist=['html']), expected[html])
+        self.assertEqual(m.get_body(preferencelist=['plain']), expected[plain])
+        self.assertEqual(m.get_body(preferencelist=('plain', 'html')),
+                         first(expected[plain:html-1:-1]))
+        self.assertEqual(m.get_body(preferencelist=('plain', 'related')),
+                         first([expected[plain], expected[related]]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'related')),
+                         first(expected[html::-1]))
+        self.assertEqual(m.get_body(preferencelist=('plain', 'html', 'related')),
+                         first(expected[::-1]))
+        self.assertEqual(m.get_body(preferencelist=('html', 'plain', 'related')),
+                         first([expected[html],
+                                expected[plain],
+                                expected[related]]))
+
+    def message_as_iter_attachment(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        attachments = [allparts[n] for n in attachments]
+        self.assertEqual(list(m.iter_attachments()), attachments)
+
+    def message_as_iter_parts(self, body_parts, attachments, parts, msg):
+        def _is_multipart_msg(msg):
+            return 'Content-Type: multipart' in msg
+
+        m = self._str_msg(msg)
+        allparts = list(m.walk())
+        parts = [allparts[n] for n in parts]
+        iter_parts = list(m.iter_parts()) if _is_multipart_msg(msg) else []
+        self.assertEqual(iter_parts, parts)
+
+    class _TestContentManager:
+        def get_content(self, msg, *args, **kw):
+            return msg, args, kw
+        def set_content(self, msg, *args, **kw):
+            self.msg = msg
+            self.args = args
+            self.kw = kw
+
+    def test_get_content_with_cm(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertEqual(m.get_content(content_manager=cm), (m, (), {}))
+        msg, args, kw = m.get_content('foo', content_manager=cm, bar=1, k=2)
+        self.assertEqual(msg, m)
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(kw, dict(bar=1, k=2))
+
+    def test_get_content_default_cm_comes_from_policy(self):
+        p = policy.default.clone(content_manager=self._TestContentManager())
+        m = self._str_msg('', policy=p)
+        self.assertEqual(m.get_content(), (m, (), {}))
+        msg, args, kw = m.get_content('foo', bar=1, k=2)
+        self.assertEqual(msg, m)
+        self.assertEqual(args, ('foo',))
+        self.assertEqual(kw, dict(bar=1, k=2))
+
+    def test_set_content_with_cm(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        m.set_content(content_manager=cm)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ())
+        self.assertEqual(cm.kw, {})
+        m.set_content('foo', content_manager=cm, bar=1, k=2)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ('foo',))
+        self.assertEqual(cm.kw, dict(bar=1, k=2))
+
+    def test_set_content_default_cm_comes_from_policy(self):
+        cm = self._TestContentManager()
+        p = policy.default.clone(content_manager=cm)
+        m = self._str_msg('', policy=p)
+        m.set_content()
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ())
+        self.assertEqual(cm.kw, {})
+        m.set_content('foo', bar=1, k=2)
+        self.assertEqual(cm.msg, m)
+        self.assertEqual(cm.args, ('foo',))
+        self.assertEqual(cm.kw, dict(bar=1, k=2))
+
+    # outcome is whether xxx_method should raise ValueError error when called
+    # on multipart/subtype.  Blank outcome means it depends on xxx (add
+    # succeeds, make raises).  Note: 'none' means there are content-type
+    # headers but payload is None...this happening in practice would be very
+    # unusual, so treating it as if there were content seems reasonable.
+    #    method          subtype           outcome
+    subtype_params = (
+        ('related',      'no_content',     'succeeds'),
+        ('related',      'none',           'succeeds'),
+        ('related',      'plain',          'succeeds'),
+        ('related',      'related',        ''),
+        ('related',      'alternative',    'raises'),
+        ('related',      'mixed',          'raises'),
+        ('alternative',  'no_content',     'succeeds'),
+        ('alternative',  'none',           'succeeds'),
+        ('alternative',  'plain',          'succeeds'),
+        ('alternative',  'related',        'succeeds'),
+        ('alternative',  'alternative',    ''),
+        ('alternative',  'mixed',          'raises'),
+        ('mixed',        'no_content',     'succeeds'),
+        ('mixed',        'none',           'succeeds'),
+        ('mixed',        'plain',          'succeeds'),
+        ('mixed',        'related',        'succeeds'),
+        ('mixed',        'alternative',    'succeeds'),
+        ('mixed',        'mixed',          ''),
+        )
+
+    def _make_subtype_test_message(self, subtype):
+        m = self.message()
+        payload = None
+        msg_headers =  [
+            ('To', 'foo@bar.com'),
+            ('From', 'bar@foo.com'),
+            ]
+        if subtype != 'no_content':
+            ('content-shadow', 'Logrus'),
+        msg_headers.append(('X-Random-Header', 'Corwin'))
+        if subtype == 'text':
+            payload = ''
+            msg_headers.append(('Content-Type', 'text/plain'))
+            m.set_payload('')
+        elif subtype != 'no_content':
+            payload = []
+            msg_headers.append(('Content-Type', 'multipart/' + subtype))
+        msg_headers.append(('X-Trump', 'Random'))
+        m.set_payload(payload)
+        for name, value in msg_headers:
+            m[name] = value
+        return m, msg_headers, payload
+
+    def _check_disallowed_subtype_raises(self, m, method_name, subtype, method):
+        with self.assertRaises(ValueError) as ar:
+            getattr(m, method)()
+        exc_text = str(ar.exception)
+        self.assertIn(subtype, exc_text)
+        self.assertIn(method_name, exc_text)
+
+    def _check_make_multipart(self, m, msg_headers, payload):
+        count = 0
+        for name, value in msg_headers:
+            if not name.lower().startswith('content-'):
+                self.assertEqual(m[name], value)
+                count += 1
+        self.assertEqual(len(m), count+1) # +1 for new Content-Type
+        part = next(m.iter_parts())
+        count = 0
+        for name, value in msg_headers:
+            if name.lower().startswith('content-'):
+                self.assertEqual(part[name], value)
+                count += 1
+        self.assertEqual(len(part), count)
+        self.assertEqual(part.get_payload(), payload)
+
+    def subtype_as_make(self, method, subtype, outcome):
+        m, msg_headers, payload = self._make_subtype_test_message(subtype)
+        make_method = 'make_' + method
+        if outcome in ('', 'raises'):
+            self._check_disallowed_subtype_raises(m, method, subtype, make_method)
+            return
+        getattr(m, make_method)()
+        self.assertEqual(m.get_content_maintype(), 'multipart')
+        self.assertEqual(m.get_content_subtype(), method)
+        if subtype == 'no_content':
+            self.assertEqual(len(m.get_payload()), 0)
+            self.assertEqual(m.items(),
+                             msg_headers + [('Content-Type',
+                                             'multipart/'+method)])
+        else:
+            self.assertEqual(len(m.get_payload()), 1)
+            self._check_make_multipart(m, msg_headers, payload)
+
+    def subtype_as_make_with_boundary(self, method, subtype, outcome):
+        # Doing all variation is a bit of overkill...
+        m = self.message()
+        if outcome in ('', 'raises'):
+            m['Content-Type'] = 'multipart/' + subtype
+            with self.assertRaises(ValueError) as cm:
+                getattr(m, 'make_' + method)()
+            return
+        if subtype == 'plain':
+            m['Content-Type'] = 'text/plain'
+        elif subtype != 'no_content':
+            m['Content-Type'] = 'multipart/' + subtype
+        getattr(m, 'make_' + method)(boundary="abc")
+        self.assertTrue(m.is_multipart())
+        self.assertEqual(m.get_boundary(), 'abc')
+
+    def test_policy_on_part_made_by_make_comes_from_message(self):
+        for method in ('make_related', 'make_alternative', 'make_mixed'):
+            m = self.message(policy=self.policy.clone(content_manager='foo'))
+            m['Content-Type'] = 'text/plain'
+            getattr(m, method)()
+            self.assertEqual(m.get_payload(0).policy.content_manager, 'foo')
+
+    class _TestSetContentManager:
+        def set_content(self, msg, content, *args, **kw):
+            msg['Content-Type'] = 'text/plain'
+            msg.set_payload(content)
+
+    def subtype_as_add(self, method, subtype, outcome):
+        m, msg_headers, payload = self._make_subtype_test_message(subtype)
+        cm = self._TestSetContentManager()
+        add_method = 'add_attachment' if method=='mixed' else 'add_' + method
+        if outcome == 'raises':
+            self._check_disallowed_subtype_raises(m, method, subtype, add_method)
+            return
+        getattr(m, add_method)('test', content_manager=cm)
+        self.assertEqual(m.get_content_maintype(), 'multipart')
+        self.assertEqual(m.get_content_subtype(), method)
+        if method == subtype or subtype == 'no_content':
+            self.assertEqual(len(m.get_payload()), 1)
+            for name, value in msg_headers:
+                self.assertEqual(m[name], value)
+            part = m.get_payload()[0]
+        else:
+            self.assertEqual(len(m.get_payload()), 2)
+            self._check_make_multipart(m, msg_headers, payload)
+            part = m.get_payload()[1]
+        self.assertEqual(part.get_content_type(), 'text/plain')
+        self.assertEqual(part.get_payload(), 'test')
+        if method=='mixed':
+            self.assertEqual(part['Content-Disposition'], 'attachment')
+        elif method=='related':
+            self.assertEqual(part['Content-Disposition'], 'inline')
+        else:
+            # Otherwise we don't guess.
+            self.assertIsNone(part['Content-Disposition'])
+
+    class _TestSetRaisingContentManager:
+        class CustomError(Exception):
+            pass
+        def set_content(self, msg, content, *args, **kw):
+            raise self.CustomError('test')
+
+    def test_default_content_manager_for_add_comes_from_policy(self):
+        cm = self._TestSetRaisingContentManager()
+        m = self.message(policy=self.policy.clone(content_manager=cm))
+        for method in ('add_related', 'add_alternative', 'add_attachment'):
+            with self.assertRaises(self._TestSetRaisingContentManager.CustomError) as ar:
+                getattr(m, method)('')
+            self.assertEqual(str(ar.exception), 'test')
+
+    def message_as_clear(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        m.clear()
+        self.assertEqual(len(m), 0)
+        self.assertEqual(list(m.items()), [])
+        self.assertIsNone(m.get_payload())
+        self.assertEqual(list(m.iter_parts()), [])
+
+    def message_as_clear_content(self, body_parts, attachments, parts, msg):
+        m = self._str_msg(msg)
+        expected_headers = [h for h in m.keys()
+                            if not h.lower().startswith('content-')]
+        m.clear_content()
+        self.assertEqual(list(m.keys()), expected_headers)
+        self.assertIsNone(m.get_payload())
+        self.assertEqual(list(m.iter_parts()), [])
+
+    def test_is_attachment(self):
+        m = self._make_message()
+        self.assertFalse(m.is_attachment())
+        m['Content-Disposition'] = 'inline'
+        self.assertFalse(m.is_attachment())
+        m.replace_header('Content-Disposition', 'attachment')
+        self.assertTrue(m.is_attachment())
+        m.replace_header('Content-Disposition', 'AtTachMent')
+        self.assertTrue(m.is_attachment())
+        m.set_param('filename', 'abc.png', 'Content-Disposition')
+        self.assertTrue(m.is_attachment())
+
+    def test_iter_attachments_mutation(self):
+        # We had a bug where iter_attachments was mutating the list.
+        m = self._make_message()
+        m.set_content('arbitrary text as main part')
+        m.add_related('more text as a related part')
+        m.add_related('yet more text as a second "attachment"')
+        orig = m.get_payload().copy()
+        self.assertEqual(len(list(m.iter_attachments())), 2)
+        self.assertEqual(m.get_payload(), orig)
+
+    get_payload_surrogate_params = {
+
+        'good_surrogateescape': (
+            "String that can be encod\udcc3\udcabd with surrogateescape",
+            b'String that can be encod\xc3\xabd with surrogateescape'
+            ),
+
+        'string_with_utf8': (
+            "String with utf-8 charactër",
+            b'String with utf-8 charact\xebr'
+            ),
+
+        'surrogate_and_utf8': (
+            "String that cannot be ëncod\udcc3\udcabd with surrogateescape",
+             b'String that cannot be \xebncod\\udcc3\\udcabd with surrogateescape'
+            ),
+
+        'out_of_range_surrogate': (
+            "String with \udfff cannot be encoded with surrogateescape",
+             b'String with \\udfff cannot be encoded with surrogateescape'
+            ),
+    }
+
+    def get_payload_surrogate_as_gh_94606(self, msg, expected):
+        """test for GH issue 94606"""
+        m = self._str_msg(msg)
+        payload = m.get_payload(decode=True)
+        self.assertEqual(expected, payload)
+
+
+class TestEmailMessage(TestEmailMessageBase, TestEmailBase):
+    message = EmailMessage
+
+    def test_set_content_adds_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertEqual(m['MIME-Version'], '1.0')
+
+    class _MIME_Version_adding_CM:
+        def set_content(self, msg, *args, **kw):
+            msg['MIME-Version'] = '1.0'
+
+    def test_set_content_does_not_duplicate_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._MIME_Version_adding_CM()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertEqual(m['MIME-Version'], '1.0')
+
+    def test_as_string_uses_max_header_length_by_default(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(m.as_string().strip().splitlines()), 3)
+
+    def test_as_string_allows_maxheaderlen(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(m.as_string(maxheaderlen=0).strip().splitlines()),
+                         1)
+        self.assertEqual(len(m.as_string(maxheaderlen=34).strip().splitlines()),
+                         6)
+
+    def test_as_string_unixform(self):
+        m = self._str_msg('test')
+        m.set_unixfrom('From foo@bar Thu Jan  1 00:00:00 1970')
+        self.assertEqual(m.as_string(unixfrom=True),
+                        'From foo@bar Thu Jan  1 00:00:00 1970\n\ntest')
+        self.assertEqual(m.as_string(unixfrom=False), '\ntest')
+
+    def test_str_defaults_to_policy_max_line_length(self):
+        m = self._str_msg('Subject: long line' + ' ab'*50 + '\n\n')
+        self.assertEqual(len(str(m).strip().splitlines()), 3)
+
+    def test_str_defaults_to_utf8(self):
+        m = EmailMessage()
+        m['Subject'] = 'unicöde'
+        self.assertEqual(str(m), 'Subject: unicöde\n\n')
+
+    def test_folding_with_utf8_encoding_1(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached within an ASCII
+        # word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello Wörld! Hello Wörld! '            \
+                       'Hello Wörld! Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: Hello =?utf-8?q?W=C3=B6rld!_Hello_W'
+                         b'=C3=B6rld!_Hello_W=C3=B6rld!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+
+    def test_folding_with_utf8_encoding_2(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached at the end of an
+        # encoded word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello Wörld! Hello Wörld! '                \
+                       'Hello Wörlds123! Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: Hello =?utf-8?q?W=C3=B6rld!_Hello_W'
+                         b'=C3=B6rld!_Hello_W=C3=B6rlds123!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_3(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the whitespace fold point, where the
+        # line length limit is reached at the end of the
+        # first word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello-Wörld!-Hello-Wörld!-Hello-Wörlds123! ' \
+                       'Hello Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m), \
+                         b'Subject: =?utf-8?q?Hello-W=C3=B6rld!-Hello-W'
+                         b'=C3=B6rld!-Hello-W=C3=B6rlds123!?=\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_4(self):
+        # bpo-36520
+        #
+        # Fold a line that contains UTF-8 words before
+        # and after the fold point, where the first
+        # word is UTF-8 and the fold point is within
+        # the word.
+
+        m = EmailMessage()
+        m['Subject'] = 'Hello-Wörld!-Hello-Wörld!-Hello-Wörlds123!-Hello' \
+                       ' Wörld!Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: =?utf-8?q?Hello-W=C3=B6rld!-Hello-W'
+                         b'=C3=B6rld!-Hello-W=C3=B6rlds123!?=\n'
+                         b' =?utf-8?q?-Hello_W=C3=B6rld!Hello_W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_5(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a UTF-8 word after
+        # the fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 123456789 123456789 123456789' \
+                       ' 123456789 123456789 Hello Wörld!'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 123456789 123456789'
+                         b' 123456789 123456789 123456789\n'
+                         b' Hello =?utf-8?q?W=C3=B6rld!?=\n\n')
+
+    def test_folding_with_utf8_encoding_6(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a UTF-8 word before
+        # the fold point and ASCII words after
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 123456789 123456789 Hello Wörld!' \
+                       ' 123456789 123456789 123456789 123456789 123456789'   \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 123456789 123456789'
+                         b' Hello =?utf-8?q?W=C3=B6rld!?=\n 123456789 '
+                         b'123456789 123456789 123456789 123456789 '
+                         b'123456789\n\n')
+
+    def test_folding_with_utf8_encoding_7(self):
+        # bpo-36520
+        #
+        # Fold a line twice that contains UTF-8 words before
+        # and after the first fold point, and ASCII words
+        # after the second fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 Hello Wörld! Hello Wörld! '       \
+                       '123456789-123456789 123456789 Hello Wörld! 123456789' \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 Hello =?utf-8?q?'
+                         b'W=C3=B6rld!_Hello_W=C3=B6rld!?=\n'
+                         b' 123456789-123456789 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!?= 123456789\n 123456789\n\n')
+
+    def test_folding_with_utf8_encoding_8(self):
+        # bpo-36520
+        #
+        # Fold a line twice that contains UTF-8 words before
+        # the first fold point, and ASCII words after the
+        # first fold point, and UTF-8 words after the second
+        # fold point.
+
+        m = EmailMessage()
+        m['Subject'] = '123456789 123456789 Hello Wörld! Hello Wörld! '       \
+                       '123456789 123456789 123456789 123456789 123456789 '   \
+                       '123456789-123456789 123456789 Hello Wörld! 123456789' \
+                       ' 123456789'
+        self.assertEqual(bytes(m),
+                         b'Subject: 123456789 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!_Hello_W=C3=B6rld!?=\n 123456789 '
+                         b'123456789 123456789 123456789 123456789 '
+                         b'123456789-123456789\n 123456789 Hello '
+                         b'=?utf-8?q?W=C3=B6rld!?= 123456789 123456789\n\n')
+
+    def test_folding_with_short_nospace_1(self):
+        # bpo-36520
+        #
+        # Fold a line that contains a long whitespace after
+        # the fold point.
+
+        m = EmailMessage(policy.default)
+        m['Message-ID'] = '123456789' * 3
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_default_policy_1(self):
+        # Fixed: https://github.com/python/cpython/issues/124452
+        #
+        # When the value is too long, it should be converted back
+        # to its original form without any modifications.
+
+        m = EmailMessage(policy.default)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        self.assertEqual(m.as_bytes(),
+                         f'Message-ID:\n {message}\n\n'.encode())
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_compat32_policy_1(self):
+        m = EmailMessage(policy.compat32)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_smtp_policy_1(self):
+        m = EmailMessage(policy.SMTP)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_folding_with_long_nospace_http_policy_1(self):
+        m = EmailMessage(policy.HTTP)
+        message = '123456789' * 10
+        m['Message-ID'] = message
+        parsed_msg = message_from_bytes(m.as_bytes(), policy=policy.default)
+        self.assertEqual(parsed_msg['Message-ID'], m['Message-ID'])
+
+    def test_no_wrapping_max_line_length(self):
+        # Test that falsey 'max_line_length' are converted to sys.maxsize.
+        for n in [0, None]:
+            with self.subTest(max_line_length=n):
+                self.do_test_no_wrapping_max_line_length(n)
+
+    def do_test_no_wrapping_max_line_length(self, falsey):
+        self.assertFalse(falsey)
+        pol = policy.default.clone(max_line_length=falsey)
+        subj = "S" * 100
+        body = "B" * 100
+        msg = EmailMessage(policy=pol)
+        msg["From"] = "a@ex.com"
+        msg["To"] = "b@ex.com"
+        msg["Subject"] = subj
+        msg.set_content(body)
+
+        raw = msg.as_bytes()
+        self.assertNotIn(b"=\n", raw,
+                         "Found fold indicator; wrapping not disabled")
+
+        parsed = message_from_bytes(raw, policy=policy.default)
+        self.assertEqual(parsed["Subject"], subj)
+        parsed_body = parsed.get_body().get_content().rstrip('\n')
+        self.assertEqual(parsed_body, body)
+
+    def test_get_body_malformed(self):
+        """test for bpo-42892"""
+        msg = textwrap.dedent("""\
+            Message-ID: <674392CA.4347091@email.au>
+            Date: Wed, 08 Nov 2017 08:50:22 +0700
+            From: Foo Bar <email@email.au>
+            MIME-Version: 1.0
+            To: email@email.com <email@email.com>
+            Subject: Python Email
+            Content-Type: multipart/mixed;
+            boundary="------------879045806563892972123996"
+            X-Global-filter:Messagescannedforspamandviruses:passedalltests
+
+            This is a multi-part message in MIME format.
+            --------------879045806563892972123996
+            Content-Type: text/plain; charset=ISO-8859-1; format=flowed
+            Content-Transfer-Encoding: 7bit
+
+            Your message is ready to be sent with the following file or link
+            attachments:
+            XU89 - 08.11.2017
+            """)
+        m = self._str_msg(msg)
+        # In bpo-42892, this would raise
+        # AttributeError: 'str' object has no attribute 'is_attachment'
+        m.get_body()
+
+    def test_get_bytes_payload_with_quoted_printable_encoding(self):
+        # We use a memoryview to avoid directly changing the private payload
+        # and to prevent using the dedicated paths for string or bytes objects.
+        payload = memoryview(b'Some payload')
+        m = self._make_message()
+        m.add_header('Content-Transfer-Encoding', 'quoted-printable')
+        m.set_payload(payload)
+        self.assertEqual(m.get_payload(decode=True), payload)
+
+
+class TestMIMEPart(TestEmailMessageBase, TestEmailBase):
+    # Doing the full test run here may seem a bit redundant, since the two
+    # classes are almost identical.  But what if they drift apart?  So we do
+    # the full tests so that any future drift doesn't introduce bugs.
+    message = MIMEPart
+
+    def test_set_content_does_not_add_MIME_Version(self):
+        m = self._str_msg('')
+        cm = self._TestContentManager()
+        self.assertNotIn('MIME-Version', m)
+        m.set_content(content_manager=cm)
+        self.assertNotIn('MIME-Version', m)
+
+    def test_string_payload_with_multipart_content_type(self):
+        msg = message_from_string(textwrap.dedent("""\
+        Content-Type: multipart/mixed; charset="utf-8"
+
+        sample text
+        """), policy=policy.default)
+        attachments = msg.iter_attachments()
+        self.assertEqual(list(attachments), [])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_parser.py b/Lib/test/test_email/test_parser.py
new file mode 100644
index 0000000000..06c86408ab
--- /dev/null
+++ b/Lib/test/test_email/test_parser.py
@@ -0,0 +1,110 @@
+import io
+import email
+import unittest
+from email.message import Message, EmailMessage
+from email.policy import default
+from test.test_email import TestEmailBase
+
+
+class TestCustomMessage(TestEmailBase):
+
+    class MyMessage(Message):
+        def __init__(self, policy):
+            self.check_policy = policy
+            super().__init__()
+
+    MyPolicy = TestEmailBase.policy.clone(linesep='boo')
+
+    def test_custom_message_gets_policy_if_possible_from_string(self):
+        msg = email.message_from_string("Subject: bogus\n\nmsg\n",
+                                        self.MyMessage,
+                                        policy=self.MyPolicy)
+        self.assertIsInstance(msg, self.MyMessage)
+        self.assertIs(msg.check_policy, self.MyPolicy)
+
+    def test_custom_message_gets_policy_if_possible_from_file(self):
+        source_file = io.StringIO("Subject: bogus\n\nmsg\n")
+        msg = email.message_from_file(source_file,
+                                      self.MyMessage,
+                                      policy=self.MyPolicy)
+        self.assertIsInstance(msg, self.MyMessage)
+        self.assertIs(msg.check_policy, self.MyPolicy)
+
+    # XXX add tests for other functions that take Message arg.
+
+
+class TestParserBase:
+
+    def test_only_split_on_cr_lf(self):
+        # The unicode line splitter splits on unicode linebreaks, which are
+        # more numerous than allowed by the email RFCs; make sure we are only
+        # splitting on those two.
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                msg = parser(
+                    "Next-Line: not\x85broken\r\n"
+                    "Null: not\x00broken\r\n"
+                    "Vertical-Tab: not\vbroken\r\n"
+                    "Form-Feed: not\fbroken\r\n"
+                    "File-Separator: not\x1Cbroken\r\n"
+                    "Group-Separator: not\x1Dbroken\r\n"
+                    "Record-Separator: not\x1Ebroken\r\n"
+                    "Line-Separator: not\u2028broken\r\n"
+                    "Paragraph-Separator: not\u2029broken\r\n"
+                    "\r\n",
+                    policy=default,
+                )
+                self.assertEqual(msg.items(), [
+                    ("Next-Line", "not\x85broken"),
+                    ("Null", "not\x00broken"),
+                    ("Vertical-Tab", "not\vbroken"),
+                    ("Form-Feed", "not\fbroken"),
+                    ("File-Separator", "not\x1Cbroken"),
+                    ("Group-Separator", "not\x1Dbroken"),
+                    ("Record-Separator", "not\x1Ebroken"),
+                    ("Line-Separator", "not\u2028broken"),
+                    ("Paragraph-Separator", "not\u2029broken"),
+                ])
+                self.assertEqual(msg.get_payload(), "")
+
+    class MyMessage(EmailMessage):
+        pass
+
+    def test_custom_message_factory_on_policy(self):
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                MyPolicy = default.clone(message_factory=self.MyMessage)
+                msg = parser("To: foo\n\ntest", policy=MyPolicy)
+                self.assertIsInstance(msg, self.MyMessage)
+
+    def test_factory_arg_overrides_policy(self):
+        for parser in self.parsers:
+            with self.subTest(parser=parser.__name__):
+                MyPolicy = default.clone(message_factory=self.MyMessage)
+                msg = parser("To: foo\n\ntest", Message, policy=MyPolicy)
+                self.assertNotIsInstance(msg, self.MyMessage)
+                self.assertIsInstance(msg, Message)
+
+# Play some games to get nice output in subTest.  This code could be clearer
+# if staticmethod supported __name__.
+
+def message_from_file(s, *args, **kw):
+    f = io.StringIO(s)
+    return email.message_from_file(f, *args, **kw)
+
+class TestParser(TestParserBase, TestEmailBase):
+    parsers = (email.message_from_string, message_from_file)
+
+def message_from_bytes(s, *args, **kw):
+    return email.message_from_bytes(s.encode(), *args, **kw)
+
+def message_from_binary_file(s, *args, **kw):
+    f = io.BytesIO(s.encode())
+    return email.message_from_binary_file(f, *args, **kw)
+
+class TestBytesParser(TestParserBase, TestEmailBase):
+    parsers = (message_from_bytes, message_from_binary_file)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_pickleable.py b/Lib/test/test_email/test_pickleable.py
new file mode 100644
index 0000000000..16b4467114
--- /dev/null
+++ b/Lib/test/test_email/test_pickleable.py
@@ -0,0 +1,76 @@
+import unittest
+import textwrap
+import copy
+import pickle
+import email
+import email.message
+from email import policy
+from email.headerregistry import HeaderRegistry
+from test.test_email import TestEmailBase, parameterize
+
+
+@parameterize
+class TestPickleCopyHeader(TestEmailBase):
+
+    header_factory = HeaderRegistry()
+
+    unstructured = header_factory('subject', 'this is a test')
+
+    header_params = {
+        'subject': ('subject', 'this is a test'),
+        'from':    ('from',    'frodo@mordor.net'),
+        'to':      ('to',      'a: k@b.com, y@z.com;, j@f.com'),
+        'date':    ('date',    'Tue, 29 May 2012 09:24:26 +1000'),
+        }
+
+    def header_as_deepcopy(self, name, value):
+        header = self.header_factory(name, value)
+        h = copy.deepcopy(header)
+        self.assertEqual(str(h), str(header))
+
+    def header_as_pickle(self, name, value):
+        header = self.header_factory(name, value)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            p = pickle.dumps(header, proto)
+            h = pickle.loads(p)
+            self.assertEqual(str(h), str(header))
+
+
+@parameterize
+class TestPickleCopyMessage(TestEmailBase):
+
+    # Message objects are a sequence, so we have to make them a one-tuple in
+    # msg_params so they get passed to the parameterized test method as a
+    # single argument instead of as a list of headers.
+    msg_params = {}
+
+    # Note: there will be no custom header objects in the parsed message.
+    msg_params['parsed'] = (email.message_from_string(textwrap.dedent("""\
+        Date: Tue, 29 May 2012 09:24:26 +1000
+        From: frodo@mordor.net
+        To: bilbo@underhill.org
+        Subject: help
+
+        I think I forgot the ring.
+        """), policy=policy.default),)
+
+    msg_params['created'] = (email.message.Message(policy=policy.default),)
+    msg_params['created'][0]['Date'] = 'Tue, 29 May 2012 09:24:26 +1000'
+    msg_params['created'][0]['From'] = 'frodo@mordor.net'
+    msg_params['created'][0]['To'] = 'bilbo@underhill.org'
+    msg_params['created'][0]['Subject'] = 'help'
+    msg_params['created'][0].set_payload('I think I forgot the ring.')
+
+    def msg_as_deepcopy(self, msg):
+        msg2 = copy.deepcopy(msg)
+        self.assertEqual(msg2.as_string(), msg.as_string())
+
+    def msg_as_pickle(self, msg):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            p = pickle.dumps(msg, proto)
+            msg2 = pickle.loads(p)
+            self.assertEqual(msg2.as_string(), msg.as_string())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_policy.py b/Lib/test/test_email/test_policy.py
new file mode 100644
index 0000000000..baa35fd68e
--- /dev/null
+++ b/Lib/test/test_email/test_policy.py
@@ -0,0 +1,429 @@
+import io
+import types
+import textwrap
+import unittest
+import email.errors
+import email.policy
+import email.parser
+import email.generator
+import email.message
+from email import headerregistry
+
+def make_defaults(base_defaults, differences):
+    defaults = base_defaults.copy()
+    defaults.update(differences)
+    return defaults
+
+class PolicyAPITests(unittest.TestCase):
+
+    longMessage = True
+
+    # Base default values.
+    compat32_defaults = {
+        'max_line_length':          78,
+        'linesep':                  '\n',
+        'cte_type':                 '8bit',
+        'raise_on_defect':          False,
+        'mangle_from_':             True,
+        'message_factory':          None,
+        'verify_generated_headers': True,
+        }
+    # These default values are the ones set on email.policy.default.
+    # If any of these defaults change, the docs must be updated.
+    policy_defaults = compat32_defaults.copy()
+    policy_defaults.update({
+        'utf8':                     False,
+        'raise_on_defect':          False,
+        'header_factory':           email.policy.EmailPolicy.header_factory,
+        'refold_source':            'long',
+        'content_manager':          email.policy.EmailPolicy.content_manager,
+        'mangle_from_':             False,
+        'message_factory':          email.message.EmailMessage,
+        })
+
+    # For each policy under test, we give here what we expect the defaults to
+    # be for that policy.  The second argument to make defaults is the
+    # difference between the base defaults and that for the particular policy.
+    new_policy = email.policy.EmailPolicy()
+    policies = {
+        email.policy.compat32: make_defaults(compat32_defaults, {}),
+        email.policy.default: make_defaults(policy_defaults, {}),
+        email.policy.SMTP: make_defaults(policy_defaults,
+                                         {'linesep': '\r\n'}),
+        email.policy.SMTPUTF8: make_defaults(policy_defaults,
+                                             {'linesep': '\r\n',
+                                              'utf8': True}),
+        email.policy.HTTP: make_defaults(policy_defaults,
+                                         {'linesep': '\r\n',
+                                          'max_line_length': None}),
+        email.policy.strict: make_defaults(policy_defaults,
+                                           {'raise_on_defect': True}),
+        new_policy: make_defaults(policy_defaults, {}),
+        }
+    # Creating a new policy creates a new header factory.  There is a test
+    # later that proves this.
+    policies[new_policy]['header_factory'] = new_policy.header_factory
+
+    def test_defaults(self):
+        for policy, expected in self.policies.items():
+            for attr, value in expected.items():
+                with self.subTest(policy=policy, attr=attr):
+                    self.assertEqual(getattr(policy, attr), value,
+                                    ("change {} docs/docstrings if defaults have "
+                                    "changed").format(policy))
+
+    def test_all_attributes_covered(self):
+        for policy, expected in self.policies.items():
+            for attr in dir(policy):
+                with self.subTest(policy=policy, attr=attr):
+                    if (attr.startswith('_') or
+                            isinstance(getattr(email.policy.EmailPolicy, attr),
+                                  types.FunctionType)):
+                        continue
+                    else:
+                        self.assertIn(attr, expected,
+                                      "{} is not fully tested".format(attr))
+
+    def test_abc(self):
+        with self.assertRaises(TypeError) as cm:
+            email.policy.Policy()
+        msg = str(cm.exception)
+        abstract_methods = ('fold',
+                            'fold_binary',
+                            'header_fetch_parse',
+                            'header_source_parse',
+                            'header_store_parse')
+        for method in abstract_methods:
+            self.assertIn(method, msg)
+
+    def test_policy_is_immutable(self):
+        for policy, defaults in self.policies.items():
+            for attr in defaults:
+                with self.assertRaisesRegex(AttributeError, attr+".*read-only"):
+                    setattr(policy, attr, None)
+            with self.assertRaisesRegex(AttributeError, 'no attribute.*foo'):
+                policy.foo = None
+
+    def test_set_policy_attrs_when_cloned(self):
+        # None of the attributes has a default value of None, so we set them
+        # all to None in the clone call and check that it worked.
+        for policyclass, defaults in self.policies.items():
+            testattrdict = {attr: None for attr in defaults}
+            policy = policyclass.clone(**testattrdict)
+            for attr in defaults:
+                self.assertIsNone(getattr(policy, attr))
+
+    def test_reject_non_policy_keyword_when_called(self):
+        for policyclass in self.policies:
+            with self.assertRaises(TypeError):
+                policyclass(this_keyword_should_not_be_valid=None)
+            with self.assertRaises(TypeError):
+                policyclass(newtline=None)
+
+    def test_policy_addition(self):
+        expected = self.policy_defaults.copy()
+        p1 = email.policy.default.clone(max_line_length=100)
+        p2 = email.policy.default.clone(max_line_length=50)
+        added = p1 + p2
+        expected.update(max_line_length=50)
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+        added = p2 + p1
+        expected.update(max_line_length=100)
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+        added = added + email.policy.default
+        for attr, value in expected.items():
+            self.assertEqual(getattr(added, attr), value)
+
+    def test_fold_utf8(self):
+        expected_ascii = 'Subject: =?utf-8?q?=C3=A1?=\n'
+        expected_utf8 = 'Subject: á\n'
+
+        msg = email.message.EmailMessage()
+        s = 'á'
+        msg['Subject'] = s
+
+        p_ascii = email.policy.default.clone()
+        p_utf8 = email.policy.default.clone(utf8=True)
+
+        self.assertEqual(p_ascii.fold('Subject', msg['Subject']), expected_ascii)
+        self.assertEqual(p_utf8.fold('Subject', msg['Subject']), expected_utf8)
+
+        self.assertEqual(p_ascii.fold('Subject', s), expected_ascii)
+        self.assertEqual(p_utf8.fold('Subject', s), expected_utf8)
+
+    def test_fold_zero_max_line_length(self):
+        expected = 'Subject: =?utf-8?q?=C3=A1?=\n'
+
+        msg = email.message.EmailMessage()
+        msg['Subject'] = 'á'
+
+        p1 = email.policy.default.clone(max_line_length=0)
+        p2 = email.policy.default.clone(max_line_length=None)
+
+        self.assertEqual(p1.fold('Subject', msg['Subject']), expected)
+        self.assertEqual(p2.fold('Subject', msg['Subject']), expected)
+
+    def test_register_defect(self):
+        class Dummy:
+            def __init__(self):
+                self.defects = []
+        obj = Dummy()
+        defect = object()
+        policy = email.policy.EmailPolicy()
+        policy.register_defect(obj, defect)
+        self.assertEqual(obj.defects, [defect])
+        defect2 = object()
+        policy.register_defect(obj, defect2)
+        self.assertEqual(obj.defects, [defect, defect2])
+
+    class MyObj:
+        def __init__(self):
+            self.defects = []
+
+    class MyDefect(Exception):
+        pass
+
+    def test_handle_defect_raises_on_strict(self):
+        foo = self.MyObj()
+        defect = self.MyDefect("the telly is broken")
+        with self.assertRaisesRegex(self.MyDefect, "the telly is broken"):
+            email.policy.strict.handle_defect(foo, defect)
+
+    def test_handle_defect_registers_defect(self):
+        foo = self.MyObj()
+        defect1 = self.MyDefect("one")
+        email.policy.default.handle_defect(foo, defect1)
+        self.assertEqual(foo.defects, [defect1])
+        defect2 = self.MyDefect("two")
+        email.policy.default.handle_defect(foo, defect2)
+        self.assertEqual(foo.defects, [defect1, defect2])
+
+    class MyPolicy(email.policy.EmailPolicy):
+        defects = None
+        def __init__(self, *args, **kw):
+            super().__init__(*args, defects=[], **kw)
+        def register_defect(self, obj, defect):
+            self.defects.append(defect)
+
+    def test_overridden_register_defect_still_raises(self):
+        foo = self.MyObj()
+        defect = self.MyDefect("the telly is broken")
+        with self.assertRaisesRegex(self.MyDefect, "the telly is broken"):
+            self.MyPolicy(raise_on_defect=True).handle_defect(foo, defect)
+
+    def test_overridden_register_defect_works(self):
+        foo = self.MyObj()
+        defect1 = self.MyDefect("one")
+        my_policy = self.MyPolicy()
+        my_policy.handle_defect(foo, defect1)
+        self.assertEqual(my_policy.defects, [defect1])
+        self.assertEqual(foo.defects, [])
+        defect2 = self.MyDefect("two")
+        my_policy.handle_defect(foo, defect2)
+        self.assertEqual(my_policy.defects, [defect1, defect2])
+        self.assertEqual(foo.defects, [])
+
+    def test_default_header_factory(self):
+        h = email.policy.default.header_factory('Test', 'test')
+        self.assertEqual(h.name, 'Test')
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+        self.assertIsInstance(h, headerregistry.BaseHeader)
+
+    class Foo:
+        parse = headerregistry.UnstructuredHeader.parse
+
+    def test_each_Policy_gets_unique_factory(self):
+        policy1 = email.policy.EmailPolicy()
+        policy2 = email.policy.EmailPolicy()
+        policy1.header_factory.map_to_type('foo', self.Foo)
+        h = policy1.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+        self.assertNotIsInstance(h, headerregistry.UnstructuredHeader)
+        h = policy2.header_factory('foo', 'test')
+        self.assertNotIsInstance(h, self.Foo)
+        self.assertIsInstance(h, headerregistry.UnstructuredHeader)
+
+    def test_clone_copies_factory(self):
+        policy1 = email.policy.EmailPolicy()
+        policy2 = policy1.clone()
+        policy1.header_factory.map_to_type('foo', self.Foo)
+        h = policy1.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+        h = policy2.header_factory('foo', 'test')
+        self.assertIsInstance(h, self.Foo)
+
+    def test_new_factory_overrides_default(self):
+        mypolicy = email.policy.EmailPolicy()
+        myfactory = mypolicy.header_factory
+        newpolicy = mypolicy + email.policy.strict
+        self.assertEqual(newpolicy.header_factory, myfactory)
+        newpolicy = email.policy.strict + mypolicy
+        self.assertEqual(newpolicy.header_factory, myfactory)
+
+    def test_adding_default_policies_preserves_default_factory(self):
+        newpolicy = email.policy.default + email.policy.strict
+        self.assertEqual(newpolicy.header_factory,
+                         email.policy.EmailPolicy.header_factory)
+        self.assertEqual(newpolicy.__dict__, {'raise_on_defect': True})
+
+    def test_non_ascii_chars_do_not_cause_inf_loop(self):
+        policy = email.policy.default.clone(max_line_length=20)
+        actual = policy.fold('Subject', 'ą' * 12)
+        self.assertEqual(
+            actual,
+            'Subject: \n' +
+            12 * ' =?utf-8?q?=C4=85?=\n')
+
+    def test_short_maxlen_error(self):
+        # RFC 2047 chrome takes up 7 characters, plus the length of the charset
+        # name, so folding should fail if maxlen is lower than the minimum
+        # required length for a line.
+
+        # Note: This is only triggered when there is a single word longer than
+        # max_line_length, hence the 1234567890 at the end of this whimsical
+        # subject. This is because when we encounter a word longer than
+        # max_line_length, it is broken down into encoded words to fit
+        # max_line_length. If the max_line_length isn't large enough to even
+        # contain the RFC 2047 chrome (`?=<charset>?q??=`), we fail.
+        subject = "Melt away the pounds with this one simple trick! 1234567890"
+
+        for maxlen in [3, 7, 9]:
+            with self.subTest(maxlen=maxlen):
+                policy = email.policy.default.clone(max_line_length=maxlen)
+                with self.assertRaises(email.errors.HeaderParseError):
+                    policy.fold("Subject", subject)
+
+    def test_verify_generated_headers(self):
+        """Turning protection off allows header injection"""
+        policy = email.policy.default.clone(verify_generated_headers=False)
+        for text in (
+            'Header: Value\r\nBad: Injection\r\n',
+            'Header: NoNewLine'
+        ):
+            with self.subTest(text=text):
+                message = email.message_from_string(
+                    "Header: Value\r\n\r\nBody",
+                    policy=policy,
+                )
+                class LiteralHeader(str):
+                    name = 'Header'
+                    def fold(self, **kwargs):
+                        return self
+
+                del message['Header']
+                message['Header'] = LiteralHeader(text)
+
+                self.assertEqual(
+                    message.as_string(),
+                    f"{text}\nBody",
+                )
+
+    # XXX: Need subclassing tests.
+    # For adding subclassed objects, make sure the usual rules apply (subclass
+    # wins), but that the order still works (right overrides left).
+
+
+class TestException(Exception):
+    pass
+
+class TestPolicyPropagation(unittest.TestCase):
+
+    # The abstract methods are used by the parser but not by the wrapper
+    # functions that call it, so if the exception gets raised we know that the
+    # policy was actually propagated all the way to feedparser.
+    class MyPolicy(email.policy.Policy):
+        def badmethod(self, *args, **kw):
+            raise TestException("test")
+        fold = fold_binary = header_fetch_parser = badmethod
+        header_source_parse = header_store_parse = badmethod
+
+    def test_message_from_string(self):
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_string("Subject: test\n\n",
+                                      policy=self.MyPolicy)
+
+    def test_message_from_bytes(self):
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_bytes(b"Subject: test\n\n",
+                                     policy=self.MyPolicy)
+
+    def test_message_from_file(self):
+        f = io.StringIO('Subject: test\n\n')
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_file(f, policy=self.MyPolicy)
+
+    def test_message_from_binary_file(self):
+        f = io.BytesIO(b'Subject: test\n\n')
+        with self.assertRaisesRegex(TestException, "^test$"):
+            email.message_from_binary_file(f, policy=self.MyPolicy)
+
+    # These are redundant, but we need them for black-box completeness.
+
+    def test_parser(self):
+        p = email.parser.Parser(policy=self.MyPolicy)
+        with self.assertRaisesRegex(TestException, "^test$"):
+            p.parsestr('Subject: test\n\n')
+
+    def test_bytes_parser(self):
+        p = email.parser.BytesParser(policy=self.MyPolicy)
+        with self.assertRaisesRegex(TestException, "^test$"):
+            p.parsebytes(b'Subject: test\n\n')
+
+    # Now that we've established that all the parse methods get the
+    # policy in to feedparser, we can use message_from_string for
+    # the rest of the propagation tests.
+
+    def _make_msg(self, source='Subject: test\n\n', policy=None):
+        self.policy = email.policy.default.clone() if policy is None else policy
+        return email.message_from_string(source, policy=self.policy)
+
+    def test_parser_propagates_policy_to_message(self):
+        msg = self._make_msg()
+        self.assertIs(msg.policy, self.policy)
+
+    def test_parser_propagates_policy_to_sub_messages(self):
+        msg = self._make_msg(textwrap.dedent("""\
+            Subject: mime test
+            MIME-Version: 1.0
+            Content-Type: multipart/mixed, boundary="XXX"
+
+            --XXX
+            Content-Type: text/plain
+
+            test
+            --XXX
+            Content-Type: text/plain
+
+            test2
+            --XXX--
+            """))
+        for part in msg.walk():
+            self.assertIs(part.policy, self.policy)
+
+    def test_message_policy_propagates_to_generator(self):
+        msg = self._make_msg("Subject: test\nTo: foo\n\n",
+                             policy=email.policy.default.clone(linesep='X'))
+        s = io.StringIO()
+        g = email.generator.Generator(s)
+        g.flatten(msg)
+        self.assertEqual(s.getvalue(), "Subject: testXTo: fooXX")
+
+    def test_message_policy_used_by_as_string(self):
+        msg = self._make_msg("Subject: test\nTo: foo\n\n",
+                             policy=email.policy.default.clone(linesep='X'))
+        self.assertEqual(msg.as_string(), "Subject: testXTo: fooXX")
+
+
+class TestConcretePolicies(unittest.TestCase):
+
+    def test_header_store_parse_rejects_newlines(self):
+        instance = email.policy.EmailPolicy()
+        self.assertRaises(ValueError,
+                          instance.header_store_parse,
+                          'From', 'spam\negg@foo.py')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/test_utils.py b/Lib/test/test_email/test_utils.py
new file mode 100644
index 0000000000..d04b3909ef
--- /dev/null
+++ b/Lib/test/test_email/test_utils.py
@@ -0,0 +1,186 @@
+import datetime
+from email import utils
+import test.support
+import time
+import unittest
+import sys
+import os.path
+import zoneinfo
+
+class DateTimeTests(unittest.TestCase):
+
+    datestring = 'Sun, 23 Sep 2001 20:10:55'
+    dateargs = (2001, 9, 23, 20, 10, 55)
+    offsetstring = ' -0700'
+    utcoffset = datetime.timedelta(hours=-7)
+    tz = datetime.timezone(utcoffset)
+    naive_dt = datetime.datetime(*dateargs)
+    aware_dt = datetime.datetime(*dateargs, tzinfo=tz)
+
+    def test_naive_datetime(self):
+        self.assertEqual(utils.format_datetime(self.naive_dt),
+                         self.datestring + ' -0000')
+
+    def test_aware_datetime(self):
+        self.assertEqual(utils.format_datetime(self.aware_dt),
+                         self.datestring + self.offsetstring)
+
+    def test_usegmt(self):
+        utc_dt = datetime.datetime(*self.dateargs,
+                                   tzinfo=datetime.timezone.utc)
+        self.assertEqual(utils.format_datetime(utc_dt, usegmt=True),
+                         self.datestring + ' GMT')
+
+    def test_usegmt_with_naive_datetime_raises(self):
+        with self.assertRaises(ValueError):
+            utils.format_datetime(self.naive_dt, usegmt=True)
+
+    def test_usegmt_with_non_utc_datetime_raises(self):
+        with self.assertRaises(ValueError):
+            utils.format_datetime(self.aware_dt, usegmt=True)
+
+    def test_parsedate_to_datetime(self):
+        self.assertEqual(
+            utils.parsedate_to_datetime(self.datestring + self.offsetstring),
+            self.aware_dt)
+
+    def test_parsedate_to_datetime_naive(self):
+        self.assertEqual(
+            utils.parsedate_to_datetime(self.datestring + ' -0000'),
+            self.naive_dt)
+
+    def test_parsedate_to_datetime_with_invalid_raises_valueerror(self):
+        # See also test_parsedate_returns_None_for_invalid_strings in test_email.
+        invalid_dates = [
+            '',
+            ' ',
+            '0',
+            'A Complete Waste of Time',
+            'Wed, 3 Apr 2002 12.34.56.78+0800'
+            'Tue, 06 Jun 2017 27:39:33 +0600',
+            'Tue, 06 Jun 2017 07:39:33 +2600',
+            'Tue, 06 Jun 2017 27:39:33',
+            '17 June , 2022',
+            'Friday, -Nov-82 16:14:55 EST',
+            'Friday, Nov--82 16:14:55 EST',
+            'Friday, 19-Nov- 16:14:55 EST',
+        ]
+        for dtstr in invalid_dates:
+            with self.subTest(dtstr=dtstr):
+                self.assertRaises(ValueError, utils.parsedate_to_datetime, dtstr)
+
+class LocaltimeTests(unittest.TestCase):
+
+    def test_localtime_is_tz_aware_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t = utils.localtime()
+        self.assertIsNotNone(t.tzinfo)
+
+    def test_localtime_is_tz_aware_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t = utils.localtime()
+        self.assertIsNotNone(t.tzinfo)
+
+    def test_localtime_daylight_true_dst_false(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    def test_localtime_daylight_false_dst_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_localtime_daylight_true_dst_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_localtime_daylight_false_dst_true(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(2012, 3, 12, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t1)
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
+    def test_localtime_epoch_utc_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(1990, 1, 1, tzinfo = datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        t2 = t0 - datetime.timedelta(hours=5)
+        t2 = t2.replace(tzinfo = datetime.timezone(datetime.timedelta(hours=-5)))
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
+    def test_localtime_epoch_utc_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(1990, 1, 1, tzinfo = datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        t2 = t0 - datetime.timedelta(hours=5)
+        t2 = t2.replace(tzinfo = datetime.timezone(datetime.timedelta(hours=-5)))
+        self.assertEqual(t1, t2)
+
+    def test_localtime_epoch_notz_daylight_true(self):
+        test.support.patch(self, time, 'daylight', True)
+        t0 = datetime.datetime(1990, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t0.replace(tzinfo=None))
+        self.assertEqual(t1, t2)
+
+    def test_localtime_epoch_notz_daylight_false(self):
+        test.support.patch(self, time, 'daylight', False)
+        t0 = datetime.datetime(1990, 1, 1)
+        t1 = utils.localtime(t0)
+        t2 = utils.localtime(t0.replace(tzinfo=None))
+        self.assertEqual(t1, t2)
+
+    @test.support.run_with_tz('Europe/Kyiv')
+    def test_variable_tzname(self):
+        t0 = datetime.datetime(1984, 1, 1, tzinfo=datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        if t1.tzname() in ('Europe', 'UTC'):
+            self.skipTest("Can't find a Kyiv timezone database")
+        self.assertEqual(t1.tzname(), 'MSK')
+        t0 = datetime.datetime(1994, 1, 1, tzinfo=datetime.timezone.utc)
+        t1 = utils.localtime(t0)
+        self.assertEqual(t1.tzname(), 'EET')
+
+    def test_isdst_deprecation(self):
+        with self.assertWarns(DeprecationWarning):
+            t0 = datetime.datetime(1990, 1, 1)
+            t1 = utils.localtime(t0, isdst=True)
+
+# Issue #24836: The timezone files are out of date (pre 2011k)
+# on Mac OS X Snow Leopard.
+@test.support.requires_mac_ver(10, 7)
+class FormatDateTests(unittest.TestCase):
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_formatdate(self):
+        timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
+        string = utils.formatdate(timeval, localtime=False, usegmt=False)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 -0000')
+        string = utils.formatdate(timeval, localtime=False, usegmt=True)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 15:00:00 GMT')
+
+    @test.support.run_with_tz('Europe/Minsk')
+    def test_formatdate_with_localtime(self):
+        timeval = time.mktime((2011, 1, 1, 18, 0, 0, 6, 1, 0))
+        string = utils.formatdate(timeval, localtime=True)
+        self.assertEqual(string, 'Sat, 01 Jan 2011 18:00:00 +0200')
+        # Minsk moved from +0200 (with DST) to +0300 (without DST) in 2011
+        timeval = time.mktime((2011, 12, 1, 18, 0, 0, 4, 335, 0))
+        string = utils.formatdate(timeval, localtime=True)
+        self.assertEqual(string, 'Thu, 01 Dec 2011 18:00:00 +0300')
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_email/torture_test.py b/Lib/test/test_email/torture_test.py
new file mode 100644
index 0000000000..9cf9362c9b
--- /dev/null
+++ b/Lib/test/test_email/torture_test.py
@@ -0,0 +1,127 @@
+# Copyright (C) 2002-2004 Python Software Foundation
+#
+# A torture test of the email package.  This should not be run as part of the
+# standard Python test suite since it requires several meg of email messages
+# collected in the wild.  These source messages are not checked into the
+# Python distro, but are available as part of the standalone email package at
+# http://sf.net/projects/mimelib
+
+import sys
+import os
+import unittest
+from io import StringIO
+
+from test.test_email import TestEmailBase
+
+import email
+from email import __file__ as testfile
+from email.iterators import _structure
+
+def openfile(filename):
+    from os.path import join, dirname, abspath
+    path = abspath(join(dirname(testfile), os.pardir, 'moredata', filename))
+    return open(path, 'r')
+
+# Prevent this test from running in the Python distro
+def setUpModule():
+    try:
+        openfile('crispin-torture.txt')
+    except OSError:
+        raise unittest.SkipTest
+
+
+
+class TortureBase(TestEmailBase):
+    def _msgobj(self, filename):
+        fp = openfile(filename)
+        try:
+            msg = email.message_from_file(fp)
+        finally:
+            fp.close()
+        return msg
+
+
+
+class TestCrispinTorture(TortureBase):
+    # Mark Crispin's torture test from the SquirrelMail project
+    def test_mondo_message(self):
+        eq = self.assertEqual
+        neq = self.ndiffAssertEqual
+        msg = self._msgobj('crispin-torture.txt')
+        payload = msg.get_payload()
+        eq(type(payload), list)
+        eq(len(payload), 12)
+        eq(msg.preamble, None)
+        eq(msg.epilogue, '\n')
+        # Probably the best way to verify the message is parsed correctly is to
+        # dump its structure and compare it against the known structure.
+        fp = StringIO()
+        _structure(msg, fp=fp)
+        neq(fp.getvalue(), """\
+multipart/mixed
+    text/plain
+    message/rfc822
+        multipart/alternative
+            text/plain
+            multipart/mixed
+                text/richtext
+            application/andrew-inset
+    message/rfc822
+        audio/basic
+    audio/basic
+    image/pbm
+    message/rfc822
+        multipart/mixed
+            multipart/mixed
+                text/plain
+                audio/x-sun
+            multipart/mixed
+                image/gif
+                image/gif
+                application/x-be2
+                application/atomicmail
+            audio/x-sun
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pgm
+            text/plain
+    message/rfc822
+        multipart/mixed
+            text/plain
+            image/pbm
+    message/rfc822
+        application/postscript
+    image/gif
+    message/rfc822
+        multipart/mixed
+            audio/basic
+            audio/basic
+    message/rfc822
+        multipart/mixed
+            application/postscript
+            text/plain
+            message/rfc822
+                multipart/mixed
+                    text/plain
+                    multipart/parallel
+                        image/gif
+                        audio/basic
+                    application/atomicmail
+                    message/rfc822
+                        audio/x-sun
+""")
+
+def _testclasses():
+    mod = sys.modules[__name__]
+    return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
+
+
+def load_tests(loader, tests, pattern):
+    suite = loader.suiteClass()
+    for testclass in _testclasses():
+        suite.addTest(loader.loadTestsFromTestCase(testclass))
+    return suite
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_ensurepip.py b/Lib/test/test_ensurepip.py
index 69ab2a4fea..a4b36a90d8 100644
--- a/Lib/test/test_ensurepip.py
+++ b/Lib/test/test_ensurepip.py
@@ -6,6 +6,8 @@
 import test.support
 import unittest
 import unittest.mock
+from importlib.resources.abc import Traversable
+from pathlib import Path
 
 import ensurepip
 import ensurepip._uninstall
@@ -20,41 +22,35 @@ def test_version(self):
         # Test version()
         with tempfile.TemporaryDirectory() as tmpdir:
             self.touch(tmpdir, "pip-1.2.3b1-py2.py3-none-any.whl")
-            with (unittest.mock.patch.object(ensurepip, '_PACKAGES', None),
-                  unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', tmpdir)):
+            with unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', Path(tmpdir)):
                 self.assertEqual(ensurepip.version(), '1.2.3b1')
 
-    def test_get_packages_no_dir(self):
-        # Test _get_packages() without a wheel package directory
-        with (unittest.mock.patch.object(ensurepip, '_PACKAGES', None),
-              unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', None)):
-            packages = ensurepip._get_packages()
-
-            # when bundled wheel packages are used, we get _PIP_VERSION
+    def test_version_no_dir(self):
+        # Test version() without a wheel package directory
+        with unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', None):
+            # when the bundled pip wheel is used, we get _PIP_VERSION
             self.assertEqual(ensurepip._PIP_VERSION, ensurepip.version())
 
-        # use bundled wheel packages
-        self.assertIsNotNone(packages['pip'].wheel_name)
+    def test_selected_wheel_path_no_dir(self):
+        pip_filename = f'pip-{ensurepip._PIP_VERSION}-py3-none-any.whl'
+        with unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', None):
+            with ensurepip._get_pip_whl_path_ctx() as bundled_wheel_path:
+                self.assertEqual(pip_filename, bundled_wheel_path.name)
 
-    def test_get_packages_with_dir(self):
-        # Test _get_packages() with a wheel package directory
+    def test_selected_wheel_path_with_dir(self):
+        # Test _get_pip_whl_path_ctx() with a wheel package directory
         pip_filename = "pip-20.2.2-py2.py3-none-any.whl"
 
         with tempfile.TemporaryDirectory() as tmpdir:
             self.touch(tmpdir, pip_filename)
-            # not used, make sure that it's ignored
+            # not used, make sure that they're ignored
+            self.touch(tmpdir, "pip-1.2.3-py2.py3-none-any.whl")
             self.touch(tmpdir, "wheel-0.34.2-py2.py3-none-any.whl")
+            self.touch(tmpdir, "pip-script.py")
 
-            with (unittest.mock.patch.object(ensurepip, '_PACKAGES', None),
-                  unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', tmpdir)):
-                packages = ensurepip._get_packages()
-
-            self.assertEqual(packages['pip'].version, '20.2.2')
-            self.assertEqual(packages['pip'].wheel_path,
-                             os.path.join(tmpdir, pip_filename))
-
-            # wheel package is ignored
-            self.assertEqual(sorted(packages), ['pip'])
+            with unittest.mock.patch.object(ensurepip, '_WHEEL_PKG_DIR', Path(tmpdir)):
+                with ensurepip._get_pip_whl_path_ctx() as bundled_wheel_path:
+                    self.assertEqual(pip_filename, bundled_wheel_path.name)
 
 
 class EnsurepipMixin:
@@ -69,7 +65,7 @@ def setUp(self):
         real_devnull = os.devnull
         os_patch = unittest.mock.patch("ensurepip.os")
         patched_os = os_patch.start()
-        # But expose os.listdir() used by _find_packages()
+        # But expose os.listdir() used by _find_wheel_pkg_dir_pip()
         patched_os.listdir = os.listdir
         self.addCleanup(os_patch.stop)
         patched_os.devnull = real_devnull
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index bff85a7ec2..21a3b8edd4 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -11,14 +11,15 @@
 import builtins as bltns
 from collections import OrderedDict
 from datetime import date
+from functools import partial
 from enum import Enum, EnumMeta, IntEnum, StrEnum, EnumType, Flag, IntFlag, unique, auto
 from enum import STRICT, CONFORM, EJECT, KEEP, _simple_enum, _test_simple_enum
 from enum import verify, UNIQUE, CONTINUOUS, NAMED_FLAGS, ReprEnum
-from enum import member, nonmember, _iter_bits_lsb
+from enum import member, nonmember, _iter_bits_lsb, EnumDict
 from io import StringIO
 from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
 from test import support
-from test.support import ALWAYS_EQ
+from test.support import ALWAYS_EQ, REPO_ROOT
 from test.support import threading_helper
 from datetime import timedelta
 
@@ -26,18 +27,42 @@
 
 def load_tests(loader, tests, ignore):
     tests.addTests(doctest.DocTestSuite(enum))
-    if os.path.exists('Doc/library/enum.rst'):
+
+    lib_tests = os.path.join(REPO_ROOT, 'Doc/library/enum.rst')
+    if os.path.exists(lib_tests):
         tests.addTests(doctest.DocFileSuite(
-                '../../Doc/library/enum.rst',
+                lib_tests,
+                module_relative=False,
                 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
                 ))
-    if os.path.exists('Doc/howto/enum.rst'):
+    howto_tests = os.path.join(REPO_ROOT, 'Doc/howto/enum.rst')
+    if os.path.exists(howto_tests) and sys.float_repr_style == 'short':
         tests.addTests(doctest.DocFileSuite(
-                '../../Doc/howto/enum.rst',
+                howto_tests,
+                module_relative=False,
                 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
                 ))
     return tests
 
+def reraise_if_not_enum(*enum_types_or_exceptions):
+    from functools import wraps
+
+    def decorator(func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            excs = [
+                e
+                for e in enum_types_or_exceptions
+                if isinstance(e, Exception)
+            ]
+            if len(excs) == 1:
+                raise excs[0]
+            elif excs:
+                raise ExceptionGroup('Enum Exceptions', excs)
+            return func(*args, **kwargs)
+        return inner
+    return decorator
+
 MODULE = __name__
 SHORT_MODULE = MODULE.split('.')[-1]
 
@@ -75,30 +100,42 @@ class FlagStooges(Flag):
 except Exception as exc:
     FlagStooges = exc
 
-class FlagStoogesWithZero(Flag):
-    NOFLAG = 0
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
-
-class IntFlagStooges(IntFlag):
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
-
-class IntFlagStoogesWithZero(IntFlag):
-    NOFLAG = 0
-    LARRY = 1
-    CURLY = 2
-    MOE = 4
-    BIG = 389
+try:
+    class FlagStoogesWithZero(Flag):
+        NOFLAG = 0
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    FlagStoogesWithZero = exc
+
+try:
+    class IntFlagStooges(IntFlag):
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    IntFlagStooges = exc
+
+try:
+    class IntFlagStoogesWithZero(IntFlag):
+        NOFLAG = 0
+        LARRY = 1
+        CURLY = 2
+        MOE = 4
+        BIG = 389
+except Exception as exc:
+    IntFlagStoogesWithZero = exc
 
 # for pickle test and subclass tests
-class Name(StrEnum):
-    BDFL = 'Guido van Rossum'
-    FLUFL = 'Barry Warsaw'
+try:
+    class Name(StrEnum):
+        BDFL = 'Guido van Rossum'
+        FLUFL = 'Barry Warsaw'
+except Exception as exc:
+    Name = exc
 
 try:
     Question = Enum('Question', 'who what when where why', module=__name__)
@@ -140,7 +177,7 @@ class TestHelpers(unittest.TestCase):
 
     sunder_names = '_bad_', '_good_', '_what_ho_'
     dunder_names = '__mal__', '__bien__', '__que_que__'
-    private_names = '_MyEnum__private', '_MyEnum__still_private'
+    private_names = '_MyEnum__private', '_MyEnum__still_private', '_MyEnum___triple_private'
     private_and_sunder_names = '_MyEnum__private_', '_MyEnum__also_private_'
     random_names = 'okay', '_semi_private', '_weird__', '_MyEnum__'
 
@@ -204,26 +241,35 @@ def __get__(self, instance, ownerclass):
 
 # for global repr tests
 
-@enum.global_enum
-class HeadlightsK(IntFlag, boundary=enum.KEEP):
-    OFF_K = 0
-    LOW_BEAM_K = auto()
-    HIGH_BEAM_K = auto()
-    FOG_K = auto()
+try:
+    @enum.global_enum
+    class HeadlightsK(IntFlag, boundary=enum.KEEP):
+        OFF_K = 0
+        LOW_BEAM_K = auto()
+        HIGH_BEAM_K = auto()
+        FOG_K = auto()
+except Exception as exc:
+    HeadlightsK = exc
 
 
-@enum.global_enum
-class HeadlightsC(IntFlag, boundary=enum.CONFORM):
-    OFF_C = 0
-    LOW_BEAM_C = auto()
-    HIGH_BEAM_C = auto()
-    FOG_C = auto()
+try:
+    @enum.global_enum
+    class HeadlightsC(IntFlag, boundary=enum.CONFORM):
+        OFF_C = 0
+        LOW_BEAM_C = auto()
+        HIGH_BEAM_C = auto()
+        FOG_C = auto()
+except Exception as exc:
+    HeadlightsC = exc
 
 
-@enum.global_enum
-class NoName(Flag):
-    ONE = 1
-    TWO = 2
+try:
+    @enum.global_enum
+    class NoName(Flag):
+        ONE = 1
+        TWO = 2
+except Exception as exc:
+    NoName = exc
 
 
 # tests
@@ -399,10 +445,12 @@ def spam(cls):
         with self.assertRaises(AttributeError):
             del Season.SPRING.name
 
+    @unittest.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,
-                'has no members defined',
+                'do not use .super...__new__;',
             ):
             class BadSuper(self.enum_type):
                 def __new__(cls, value):
@@ -417,6 +465,7 @@ def test_basics(self):
             self.assertEqual(str(TE), "<flag 'MainEnum'>")
             self.assertEqual(format(TE), "<flag 'MainEnum'>")
             self.assertTrue(TE(5) is self.dupe2)
+            self.assertTrue(7 in TE)
         else:
             self.assertEqual(repr(TE), "<enum 'MainEnum'>")
             self.assertEqual(str(TE), "<enum 'MainEnum'>")
@@ -469,6 +518,7 @@ def test_contains_tf(self):
             self.assertFalse('first' in MainEnum)
         val = MainEnum.dupe
         self.assertIn(val, MainEnum)
+        self.assertNotIn(float('nan'), MainEnum)
         #
         class OtherEnum(Enum):
             one = auto()
@@ -1005,6 +1055,22 @@ class TestPlainEnumFunction(_EnumTests, _PlainOutputTests, unittest.TestCase):
 class TestPlainFlagClass(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
     enum_type = Flag
 
+    def test_none_member(self):
+        class FlagWithNoneMember(Flag):
+            A = 1
+            E = None
+
+        self.assertEqual(FlagWithNoneMember.A.value, 1)
+        self.assertIs(FlagWithNoneMember.E.value, None)
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with |"):
+            FlagWithNoneMember.A | FlagWithNoneMember.E
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with &"):
+            FlagWithNoneMember.E & FlagWithNoneMember.A
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with \^"):
+            FlagWithNoneMember.A ^ FlagWithNoneMember.E
+        with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be inverted"):
+            ~FlagWithNoneMember.E
+
 
 class TestPlainFlagFunction(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
     enum_type = Flag
@@ -1292,7 +1358,7 @@ class Color(Enum):
                 red = 1
                 green = 2
                 blue = 3
-                def red(self):
+                def red(self):  # noqa: F811
                     return 'red'
         #
         with self.assertRaises(TypeError):
@@ -1300,13 +1366,12 @@ class Color(Enum):
                 @enum.property
                 def red(self):
                     return 'redder'
-                red = 1
+                red = 1  # noqa: F811
                 green = 2
                 blue = 3
 
+    @reraise_if_not_enum(Theory)
     def test_enum_function_with_qualname(self):
-        if isinstance(Theory, Exception):
-            raise Theory
         self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
 
     def test_enum_of_types(self):
@@ -1369,12 +1434,10 @@ class Inner(Enum):
             [Outer.a, Outer.b, Outer.Inner],
             )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'inner classes are still members',
+            )
     def test_nested_classes_in_enum_are_not_members(self):
         """Support locally-defined nested classes."""
         class Outer(Enum):
@@ -1439,6 +1502,27 @@ class SpamEnum(Enum):
             spam = nonmember(SpamEnumIsInner)
         self.assertTrue(SpamEnum.spam is SpamEnumIsInner)
 
+    def test_using_members_as_nonmember(self):
+        class Example(Flag):
+            A = 1
+            B = 2
+            ALL = nonmember(A | B)
+
+        self.assertEqual(Example.A.value, 1)
+        self.assertEqual(Example.B.value, 2)
+        self.assertEqual(Example.ALL, 3)
+        self.assertIs(type(Example.ALL), int)
+
+        class Example(Flag):
+            A = auto()
+            B = auto()
+            ALL = nonmember(A | B)
+
+        self.assertEqual(Example.A.value, 1)
+        self.assertEqual(Example.B.value, 2)
+        self.assertEqual(Example.ALL, 3)
+        self.assertIs(type(Example.ALL), int)
+
     def test_nested_classes_in_enum_with_member(self):
         """Support locally-defined nested classes."""
         class Outer(Enum):
@@ -1460,6 +1544,22 @@ class Inner(Enum):
             [Outer.a, Outer.b, Outer.Inner],
             )
 
+    # TODO: RUSTPYTHON
+    # AssertionError: FutureWarning not triggered
+    @unittest.expectedFailure
+    def test_partial(self):
+        def func(a, b=5):
+            return a, b
+        with self.assertWarnsRegex(FutureWarning, r'partial.*enum\.member') as cm:
+            class E(Enum):
+                a = 1
+                b = partial(func)
+        self.assertEqual(cm.filename, __file__)
+        self.assertIsInstance(E.b, partial)
+        self.assertEqual(E.b(2), (2, 5))
+        with self.assertWarnsRegex(FutureWarning, 'partial'):
+            self.assertEqual(E.a.b(2), (2, 5))
+
     def test_enum_with_value_name(self):
         class Huh(Enum):
             name = 1
@@ -1491,6 +1591,17 @@ class IntFlag1(IntFlag):
         self.assertIn(IntEnum1.X, IntFlag1)
         self.assertIn(IntFlag1.X, IntEnum1)
 
+    def test_contains_does_not_call_missing(self):
+        class AnEnum(Enum):
+            UNKNOWN = None
+            LUCKY = 3
+            @classmethod
+            def _missing_(cls, *values):
+                return cls.UNKNOWN
+        self.assertTrue(None in AnEnum)
+        self.assertTrue(3 in AnEnum)
+        self.assertFalse(7 in AnEnum)
+
     def test_inherited_data_type(self):
         class HexInt(int):
             __qualname__ = 'HexInt'
@@ -1537,6 +1648,7 @@ class MyUnBrokenEnum(UnBrokenInt, Enum):
         test_pickle_dump_load(self.assertIs, MyUnBrokenEnum.I)
         test_pickle_dump_load(self.assertIs, MyUnBrokenEnum)
 
+    @reraise_if_not_enum(FloatStooges)
     def test_floatenum_fromhex(self):
         h = float.hex(FloatStooges.MOE.value)
         self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
@@ -1657,8 +1769,8 @@ class ThreePart(Enum):
         self.assertIs(ThreePart((3, 3.0, 'three')), ThreePart.THREE)
         self.assertIs(ThreePart(3, 3.0, 'three'), ThreePart.THREE)
 
-    # TODO: RUSTPYTHON, AssertionError: <test.test_enum.IntStooges object at 0x55c70c38a240> is not <IntStooges.MOE: 3>
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: <test.test_enum.IntStooges object at 0x55c70c38a240> is not <IntStooges.MOE: 3>
+    @reraise_if_not_enum(IntStooges)
     def test_intenum_from_bytes(self):
         self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
         with self.assertRaises(ValueError):
@@ -1687,33 +1799,28 @@ def repr(self):
             class Huh(MyStr, MyInt, Enum):
                 One = 1
 
+    @reraise_if_not_enum(Stooges)
     def test_pickle_enum(self):
-        if isinstance(Stooges, Exception):
-            raise Stooges
         test_pickle_dump_load(self.assertIs, Stooges.CURLY)
         test_pickle_dump_load(self.assertIs, Stooges)
 
+    @reraise_if_not_enum(IntStooges)
     def test_pickle_int(self):
-        if isinstance(IntStooges, Exception):
-            raise IntStooges
         test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
         test_pickle_dump_load(self.assertIs, IntStooges)
 
+    @reraise_if_not_enum(FloatStooges)
     def test_pickle_float(self):
-        if isinstance(FloatStooges, Exception):
-            raise FloatStooges
         test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
         test_pickle_dump_load(self.assertIs, FloatStooges)
 
+    @reraise_if_not_enum(Answer)
     def test_pickle_enum_function(self):
-        if isinstance(Answer, Exception):
-            raise Answer
         test_pickle_dump_load(self.assertIs, Answer.him)
         test_pickle_dump_load(self.assertIs, Answer)
 
+    @reraise_if_not_enum(Question)
     def test_pickle_enum_function_with_module(self):
-        if isinstance(Question, Exception):
-            raise Question
         test_pickle_dump_load(self.assertIs, Question.who)
         test_pickle_dump_load(self.assertIs, Question)
 
@@ -1776,9 +1883,8 @@ class Season(Enum):
                 [Season.SUMMER, Season.WINTER, Season.AUTUMN, Season.SPRING],
                 )
 
+    @reraise_if_not_enum(Name)
     def test_subclassing(self):
-        if isinstance(Name, Exception):
-            raise Name
         self.assertEqual(Name.BDFL, 'Guido van Rossum')
         self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
         self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
@@ -1817,6 +1923,27 @@ def test_wrong_inheritance_order(self):
             class Wrong(Enum, str):
                 NotHere = 'error before this point'
 
+    @unittest.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):
+                self.r = r
+                self.g = g
+                self.b = b
+                super().__init__(f'({r}, {g}, {b}) is not a valid RGB color')
+
+        with self.assertRaises(InvalidRgbColorError):
+            class RgbColor(Enum):
+                RED = (255, 0, 0)
+                GREEN = (0, 255, 0)
+                BLUE = (0, 0, 255)
+                INVALID = (256, 0, 0)
+
+                def __init__(self, r, g, b):
+                    if not all(0 <= val <= 255 for val in (r, g, b)):
+                        raise InvalidRgbColorError(r, g, b)
+
     def test_intenum_transitivity(self):
         class number(IntEnum):
             one = 1
@@ -2003,8 +2130,6 @@ class NEI(NamedInt, Enum):
         test_pickle_dump_load(self.assertIs, NEI.y)
         test_pickle_dump_load(self.assertIs, NEI)
 
-    # TODO: RUSTPYTHON, fails on pickle
-    @unittest.expectedFailure
     def test_subclasses_with_getnewargs_ex(self):
         class NamedInt(int):
             __qualname__ = 'NamedInt'       # needed for pickle protocol 4
@@ -2312,6 +2437,40 @@ class SomeTuple(tuple, Enum):
         globals()['SomeTuple'] = SomeTuple
         test_pickle_dump_load(self.assertIs, SomeTuple.first)
 
+    def test_tuple_subclass_with_auto_1(self):
+        from collections import namedtuple
+        T = namedtuple('T', 'index desc')
+        class SomeEnum(T, Enum):
+            __qualname__ = 'SomeEnum'      # needed for pickle protocol 4
+            first = auto(), 'for the money'
+            second = auto(), 'for the show'
+            third = auto(), 'for the music'
+        self.assertIs(type(SomeEnum.first), SomeEnum)
+        self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
+        self.assertIsInstance(SomeEnum.third.value, T)
+        self.assertEqual(SomeEnum.first.index, 1)
+        self.assertEqual(SomeEnum.second.desc, 'for the show')
+        globals()['SomeEnum'] = SomeEnum
+        globals()['T'] = T
+        test_pickle_dump_load(self.assertIs, SomeEnum.first)
+
+    def test_tuple_subclass_with_auto_2(self):
+        from collections import namedtuple
+        T = namedtuple('T', 'index desc')
+        class SomeEnum(Enum):
+            __qualname__ = 'SomeEnum'      # needed for pickle protocol 4
+            first = T(auto(), 'for the money')
+            second = T(auto(), 'for the show')
+            third = T(auto(), 'for the music')
+        self.assertIs(type(SomeEnum.first), SomeEnum)
+        self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
+        self.assertIsInstance(SomeEnum.third.value, T)
+        self.assertEqual(SomeEnum.first.value.index, 1)
+        self.assertEqual(SomeEnum.second.value.desc, 'for the show')
+        globals()['SomeEnum'] = SomeEnum
+        globals()['T'] = T
+        test_pickle_dump_load(self.assertIs, SomeEnum.first)
+
     def test_duplicate_values_give_unique_enum_items(self):
         class AutoNumber(Enum):
             first = ()
@@ -2453,6 +2612,8 @@ 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):
@@ -2838,6 +2999,8 @@ 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'
@@ -2900,8 +3063,7 @@ class ThirdFailedStrEnum(StrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
-    # TODO: RUSTPYTHON, fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; fails on encoding testing : TypeError: Expected type 'str' but 'builtin_function_or_method' found
     def test_custom_strenum(self):
         class CustomStrEnum(str, Enum):
             pass
@@ -2952,15 +3114,19 @@ class SecondFailedStrEnum(CustomStrEnum):
         class ThirdFailedStrEnum(CustomStrEnum):
             one = '1'
             two = 2  # this will become '2'
-        with self.assertRaisesRegex(TypeError, '.encoding. must be str, not '):
+        with self.assertRaisesRegex(TypeError,
+                r"argument (2|'encoding') must be str, not "):
             class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', sys.getdefaultencoding
-        with self.assertRaisesRegex(TypeError, '.errors. must be str, not '):
+        with self.assertRaisesRegex(TypeError,
+                r"argument (3|'errors') must be str, not "):
             class ThirdFailedStrEnum(CustomStrEnum):
                 one = '1'
                 two = b'2', 'ascii', 9
 
+    @unittest.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):
@@ -3170,6 +3336,37 @@ class NTEnum(Enum):
                 [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
                 )
 
+        self.assertRaises(AttributeError, getattr, NTEnum.NONE, 'id')
+        #
+        class NTCEnum(TTuple, Enum):
+            NONE = 0, 0, []
+            A = 1, 2, [4]
+            B = 2, 4, [0, 1, 2]
+        self.assertEqual(repr(NTCEnum.NONE), "<NTCEnum.NONE: TTuple(id=0, a=0, blist=[])>")
+        self.assertEqual(NTCEnum.NONE.value, TTuple(id=0, a=0, blist=[]))
+        self.assertEqual(NTCEnum.NONE.id, 0)
+        self.assertEqual(NTCEnum.A.a, 2)
+        self.assertEqual(NTCEnum.B.blist, [0, 1 ,2])
+        self.assertEqual(
+                [x.value for x in NTCEnum],
+                [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
+                )
+        #
+        class NTDEnum(Enum):
+            def __new__(cls, id, a, blist):
+                member = object.__new__(cls)
+                member.id = id
+                member.a = a
+                member.blist = blist
+                return member
+            NONE = TTuple(0, 0, [])
+            A = TTuple(1, 2, [4])
+            B = TTuple(2, 4, [0, 1, 2])
+        self.assertEqual(repr(NTDEnum.NONE), "<NTDEnum.NONE: TTuple(id=0, a=0, blist=[])>")
+        self.assertEqual(NTDEnum.NONE.id, 0)
+        self.assertEqual(NTDEnum.A.a, 2)
+        self.assertEqual(NTDEnum.B.blist, [0, 1 ,2])
+
     def test_flag_with_custom_new(self):
         class FlagFromChar(IntFlag):
             def __new__(cls, c):
@@ -3216,6 +3413,8 @@ 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):
@@ -3237,6 +3436,102 @@ def __new__(cls, value):
                     member._value_ = Base(value)
                     return member
 
+    def test_extra_member_creation(self):
+        class IDEnumMeta(EnumMeta):
+            def __new__(metacls, cls, bases, classdict, **kwds):
+                # add new entries to classdict
+                for name in classdict.member_names:
+                    classdict[f'{name}_DESC'] = f'-{classdict[name]}'
+                return super().__new__(metacls, cls, bases, classdict, **kwds)
+        class IDEnum(StrEnum, metaclass=IDEnumMeta):
+            pass
+        class MyEnum(IDEnum):
+            ID = 'id'
+            NAME = 'name'
+        self.assertEqual(list(MyEnum), [MyEnum.ID, MyEnum.NAME, MyEnum.ID_DESC, MyEnum.NAME_DESC])
+
+    def test_add_alias(self):
+        class mixin:
+            @property
+            def ORG(self):
+                return 'huh'
+        class Color(mixin, Enum):
+            RED = 1
+            GREEN = 2
+            BLUE = 3
+        Color.RED._add_alias_('ROJO')
+        self.assertIs(Color.RED, Color['ROJO'])
+        self.assertIs(Color.RED, Color.ROJO)
+        Color.BLUE._add_alias_('ORG')
+        self.assertIs(Color.BLUE, Color['ORG'])
+        self.assertIs(Color.BLUE, Color.ORG)
+        self.assertEqual(Color.RED.ORG, 'huh')
+        self.assertEqual(Color.GREEN.ORG, 'huh')
+        self.assertEqual(Color.BLUE.ORG, 'huh')
+        self.assertEqual(Color.ORG.ORG, 'huh')
+
+    def test_add_value_alias_after_creation(self):
+        class Color(Enum):
+            RED = 1
+            GREEN = 2
+            BLUE = 3
+        Color.RED._add_value_alias_(5)
+        self.assertIs(Color.RED, Color(5))
+
+    def test_add_value_alias_during_creation(self):
+        class Types(Enum):
+            Unknown = 0,
+            Source  = 1, 'src'
+            NetList = 2, 'nl'
+            def __new__(cls, int_value, *value_aliases):
+                member = object.__new__(cls)
+                member._value_ = int_value
+                for alias in value_aliases:
+                    member._add_value_alias_(alias)
+                return member
+        self.assertIs(Types(0), Types.Unknown)
+        self.assertIs(Types(1), Types.Source)
+        self.assertIs(Types('src'), Types.Source)
+        self.assertIs(Types(2), Types.NetList)
+        self.assertIs(Types('nl'), Types.NetList)
+
+    def test_second_tuple_item_is_falsey(self):
+        class Cardinal(Enum):
+            RIGHT = (1, 0)
+            UP = (0, 1)
+            LEFT = (-1, 0)
+            DOWN = (0, -1)
+        self.assertIs(Cardinal(1, 0), Cardinal.RIGHT)
+        self.assertIs(Cardinal(-1, 0), Cardinal.LEFT)
+
+    def test_no_members(self):
+        with self.assertRaisesRegex(
+                TypeError,
+                'has no members',
+            ):
+            Enum(7)
+        with self.assertRaisesRegex(
+                TypeError,
+                'has no members',
+            ):
+            Flag(7)
+
+    def test_empty_names(self):
+        for nothing in '', [], {}:
+            for e_type in None, int:
+                empty_enum = Enum('empty_enum', nothing, type=e_type)
+                self.assertEqual(len(empty_enum), 0)
+                self.assertRaisesRegex(TypeError, 'has no members', empty_enum, 0)
+        self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', names=0)
+        self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', 0, type=int)
+
+    def test_nonhashable_matches_hashable(self):    # issue 125710
+        class Directions(Enum):
+            DOWN_ONLY = frozenset({"sc"})
+            UP_ONLY = frozenset({"cs"})
+            UNRESTRICTED = frozenset({"sc", "cs"})
+        self.assertIs(Directions({"sc"}), Directions.DOWN_ONLY)
+
 
 class TestOrder(unittest.TestCase):
     "test usage of the `_order_` attribute"
@@ -3518,9 +3813,13 @@ def test_programatic_function_from_dict(self):
             self.assertIn(e, Perm)
             self.assertIs(type(e), Perm)
 
+    @reraise_if_not_enum(
+        FlagStooges,
+        FlagStoogesWithZero,
+        IntFlagStooges,
+        IntFlagStoogesWithZero,
+    )
     def test_pickle(self):
-        if isinstance(FlagStooges, Exception):
-            raise FlagStooges
         test_pickle_dump_load(self.assertIs, FlagStooges.CURLY)
         test_pickle_dump_load(self.assertEqual,
                         FlagStooges.CURLY|FlagStooges.MOE)
@@ -3704,7 +4003,7 @@ class Color(StrMixin, AllMixin, Flag):
         self.assertEqual(Color.ALL.value, 7)
         self.assertEqual(str(Color.BLUE), 'blue')
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_unique_composite(self):
@@ -3826,6 +4125,7 @@ def test_type(self):
         self.assertTrue(isinstance(Open.WO | Open.RW, Open))
         self.assertEqual(Open.WO | Open.RW, 3)
 
+    @reraise_if_not_enum(HeadlightsK)
     def test_global_repr_keep(self):
         self.assertEqual(
                 repr(HeadlightsK(0)),
@@ -3840,6 +4140,7 @@ def test_global_repr_keep(self):
                 '%(m)s.HeadlightsK(8)' % {'m': SHORT_MODULE},
                 )
 
+    @reraise_if_not_enum(HeadlightsC)
     def test_global_repr_conform1(self):
         self.assertEqual(
                 repr(HeadlightsC(0)),
@@ -3854,13 +4155,14 @@ def test_global_repr_conform1(self):
                 '%(m)s.OFF_C' % {'m': SHORT_MODULE},
                 )
 
+    @reraise_if_not_enum(NoName)
     def test_global_enum_str(self):
+        self.assertEqual(repr(NoName.ONE), 'test_enum.ONE')
+        self.assertEqual(repr(NoName(0)), 'test_enum.NoName(0)')
         self.assertEqual(str(NoName.ONE & NoName.TWO), 'NoName(0)')
         self.assertEqual(str(NoName(0)), 'NoName(0)')
 
-
-    # TODO: RUSTPYTHON, format(NewPerm.R) does not use __str__
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; format(NewPerm.R) does not use __str__
     def test_format(self):
         Perm = self.Perm
         self.assertEqual(format(Perm.R, ''), '4')
@@ -4223,7 +4525,7 @@ class Color(StrMixin, AllMixin, IntFlag):
         self.assertEqual(Color.ALL.value, 7)
         self.assertEqual(str(Color.BLUE), 'blue')
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_unique_composite(self):
@@ -4548,35 +4850,28 @@ class Color(Enum):
                 red = 'red'
                 blue = 2
                 green = auto()
-                yellow = auto()
 
-        self.assertEqual(list(Color),
-                         [Color.red, Color.blue, Color.green, Color.yellow])
+        self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
         self.assertEqual(Color.red.value, 'red')
         self.assertEqual(Color.blue.value, 2)
         self.assertEqual(Color.green.value, 3)
-        self.assertEqual(Color.yellow.value, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'mixed types with auto() will raise in 3.13',
+            )
     def test_auto_garbage_fail(self):
-        with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
+        with self.assertRaisesRegex(TypeError, "unable to increment 'red'"):
             class Color(Enum):
                 red = 'red'
                 blue = auto()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'mixed types with auto() will raise in 3.13',
+            )
     def test_auto_garbage_corrected_fail(self):
-        with self.assertRaisesRegex(TypeError, 'will require all values to be sortable'):
+        with self.assertRaisesRegex(TypeError, 'unable to sort non-numeric values'):
             class Color(Enum):
                 red = 'red'
                 blue = 2
@@ -4604,9 +4899,9 @@ def _generate_next_value_(name, start, count, last):
         self.assertEqual(Color.blue.value, 'blue')
 
     @unittest.skipIf(
-        python_version < (3, 13),
-        'inner classes are still members',
-    )
+            python_version < (3, 13),
+            'auto() will return highest value + 1 in 3.13',
+            )
     def test_auto_with_aliases(self):
         class Color(Enum):
             red = auto()
@@ -4670,8 +4965,6 @@ def _generate_next_value_(name, start, count, last):
         self.assertEqual(Huh.TWO.value, (2, 2))
         self.assertEqual(Huh.THREE.value, (3, 3, 3))
 
-class TestEnumTypeSubclassing(unittest.TestCase):
-    pass
 
 expected_help_output_with_docs = """\
 Help on class Color in module %s:
@@ -4702,22 +4995,23 @@ class Color(enum.Enum)
  |      The value of the Enum member.
  |
  |  ----------------------------------------------------------------------
- |  Methods inherited from enum.EnumType:
+ |  Static methods inherited from enum.EnumType:
  |
- |  __contains__(value) from enum.EnumType
+ |  __contains__(value)
  |      Return True if `value` is in `cls`.
  |
  |      `value` is in `cls` if:
  |      1) `value` is a member of `cls`, or
  |      2) `value` is the value of one of the `cls`'s members.
+ |      3) `value` is a pseudo-member (flags)
  |
- |  __getitem__(name) from enum.EnumType
+ |  __getitem__(name)
  |      Return the member matching `name`.
  |
- |  __iter__() from enum.EnumType
+ |  __iter__()
  |      Return members in definition order.
  |
- |  __len__() from enum.EnumType
+ |  __len__()
  |      Return the number of members (no aliases)
  |
  |  ----------------------------------------------------------------------
@@ -4742,11 +5036,11 @@ class Color(enum.Enum)
  |
  |  Data and other attributes defined here:
  |
- |  YELLOW = <Color.YELLOW: 3>
+ |  CYAN = <Color.CYAN: 1>
  |
  |  MAGENTA = <Color.MAGENTA: 2>
  |
- |  CYAN = <Color.CYAN: 1>
+ |  YELLOW = <Color.YELLOW: 3>
  |
  |  ----------------------------------------------------------------------
  |  Data descriptors inherited from enum.Enum:
@@ -4756,7 +5050,18 @@ class Color(enum.Enum)
  |  value
  |
  |  ----------------------------------------------------------------------
- |  Data descriptors inherited from enum.EnumType:
+ |  Static methods inherited from enum.EnumType:
+ |
+ |  __contains__(value)
+ |
+ |  __getitem__(name)
+ |
+ |  __iter__()
+ |
+ |  __len__()
+ |
+ |  ----------------------------------------------------------------------
+ |  Readonly properties inherited from enum.EnumType:
  |
  |  __members__"""
 
@@ -4769,8 +5074,7 @@ class Color(Enum):
         MAGENTA = 2
         YELLOW = 3
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pydoc(self):
         # indirectly test __objclass__
         if StrEnum.__doc__ is None:
@@ -4882,8 +5186,6 @@ def test_inspect_classify_class_attrs(self):
         if failed:
             self.fail("result does not equal expected, see print above")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_inspect_signatures(self):
         from inspect import signature, Signature, Parameter
         self.assertEqual(
@@ -4905,8 +5207,6 @@ def test_inspect_signatures(self):
                     ]),
                 )
 
-    # TODO: RUSTPYTHON, len is often/always > 256
-    @unittest.expectedFailure
     def test_test_simple_enum(self):
         @_simple_enum(Enum)
         class SimpleColor:
@@ -4923,12 +5223,14 @@ class CheckedColor(Enum):
             @bltns.property
             def zeroth(self):
                 return 'zeroed %s' % self.name
-        self.assertTrue(_test_simple_enum(CheckedColor, SimpleColor) is None)
+        _test_simple_enum(CheckedColor, SimpleColor)
         SimpleColor.MAGENTA._value_ = 9
         self.assertRaisesRegex(
                 TypeError, "enum mismatch",
                 _test_simple_enum, CheckedColor, SimpleColor,
                 )
+        #
+        #
         class CheckedMissing(IntFlag, boundary=KEEP):
             SIXTY_FOUR = 64
             ONE_TWENTY_EIGHT = 128
@@ -4945,8 +5247,78 @@ class Missing:
             ALL = 2048 + 128 + 64 + 12
         M = Missing
         self.assertEqual(list(CheckedMissing), [M.SIXTY_FOUR, M.ONE_TWENTY_EIGHT, M.TWENTY_FORTY_EIGHT])
-        #
         _test_simple_enum(CheckedMissing, Missing)
+        #
+        #
+        class CheckedUnhashable(Enum):
+            ONE = dict()
+            TWO = set()
+            name = 'python'
+        self.assertIn(dict(), CheckedUnhashable)
+        self.assertIn('python', CheckedUnhashable)
+        self.assertEqual(CheckedUnhashable.name.value, 'python')
+        self.assertEqual(CheckedUnhashable.name.name, 'name')
+        #
+        @_simple_enum()
+        class Unhashable:
+            ONE = dict()
+            TWO = set()
+            name = 'python'
+        self.assertIn(dict(), Unhashable)
+        self.assertIn('python', Unhashable)
+        self.assertEqual(Unhashable.name.value, 'python')
+        self.assertEqual(Unhashable.name.name, 'name')
+        _test_simple_enum(CheckedUnhashable, Unhashable)
+        ##
+        class CheckedComplexStatus(IntEnum):
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            SOME_HINTS = 103, 'Some Early Hints'
+        #
+        @_simple_enum(IntEnum)
+        class ComplexStatus:
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            SOME_HINTS = 103, 'Some Early Hints'
+        _test_simple_enum(CheckedComplexStatus, ComplexStatus)
+        #
+        #
+        class CheckedComplexFlag(IntFlag):
+            def __new__(cls, value, label):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.label = label
+                return obj
+            SHIRT = 1, 'upper half'
+            VEST = 1, 'outer upper half'
+            PANTS = 2, 'lower half'
+        self.assertIs(CheckedComplexFlag.SHIRT, CheckedComplexFlag.VEST)
+        #
+        @_simple_enum(IntFlag)
+        class ComplexFlag:
+            def __new__(cls, value, label):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+                obj.label = label
+                return obj
+            SHIRT = 1, 'upper half'
+            VEST = 1, 'uppert half'
+            PANTS = 2, 'lower half'
+        _test_simple_enum(CheckedComplexFlag, ComplexFlag)
 
 
 class MiscTestCase(unittest.TestCase):
@@ -5033,7 +5405,7 @@ def test_convert_value_lookup_priority(self):
                 filter=lambda x: x.startswith('CONVERT_TEST_'))
         # We don't want the reverse lookup value to vary when there are
         # multiple possible names for a given value.  It should always
-        # report the first lexigraphical name in that case.
+        # report the first lexicographical name in that case.
         self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
 
     def test_convert_int(self):
@@ -5119,6 +5491,37 @@ def test_convert_repr_and_str(self):
         self.assertEqual(format(test_type.CONVERT_STRING_TEST_NAME_A), '5')
 
 
+class TestEnumDict(unittest.TestCase):
+    def test_enum_dict_in_metaclass(self):
+        """Test that EnumDict is usable as a class namespace"""
+        class Meta(type):
+            @classmethod
+            def __prepare__(metacls, cls, bases, **kwds):
+                return EnumDict(cls)
+
+        class MyClass(metaclass=Meta):
+            a = 1
+
+            with self.assertRaises(TypeError):
+                a = 2  # duplicate
+
+            with self.assertRaises(ValueError):
+                _a_sunder_ = 3
+
+    def test_enum_dict_standalone(self):
+        """Test that EnumDict is usable on its own"""
+        enumdict = EnumDict()
+        enumdict['a'] = 1
+
+        with self.assertRaises(TypeError):
+            enumdict['a'] = 'other value'
+
+        # Only MutableMapping interface is overridden for now.
+        # If this stops passing, update the documentation.
+        enumdict |= {'a': 'other value'}
+        self.assertEqual(enumdict['a'], 'other value')
+
+
 # helpers
 
 def enum_dir(cls):
@@ -5153,7 +5556,7 @@ def member_dir(member):
                     allowed.add(name)
                 else:
                     allowed.discard(name)
-            else:
+            elif name not in member._member_map_:
                 allowed.add(name)
     return sorted(allowed)
 
diff --git a/Lib/test/test_enumerate.py b/Lib/test/test_enumerate.py
index 5785cb4649..5cb54cff9b 100644
--- a/Lib/test/test_enumerate.py
+++ b/Lib/test/test_enumerate.py
@@ -2,6 +2,7 @@
 import operator
 import sys
 import pickle
+import gc
 
 from test import support
 
@@ -127,6 +128,18 @@ def test_argumentcheck(self):
         self.assertRaises(TypeError, self.enum, 'abc', 'a') # wrong type
         self.assertRaises(TypeError, self.enum, 'abc', 2, 3) # too many arguments
 
+    def test_kwargs(self):
+        self.assertEqual(list(self.enum(iterable=Ig(self.seq))), self.res)
+        expected = list(self.enum(Ig(self.seq), 0))
+        self.assertEqual(list(self.enum(iterable=Ig(self.seq), start=0)),
+                         expected)
+        self.assertEqual(list(self.enum(start=0, iterable=Ig(self.seq))),
+                         expected)
+        self.assertRaises(TypeError, self.enum, iterable=[], x=3)
+        self.assertRaises(TypeError, self.enum, start=0, x=3)
+        self.assertRaises(TypeError, self.enum, x=0, y=3)
+        self.assertRaises(TypeError, self.enum, x=0)
+
     @support.cpython_only
     def test_tuple_reuse(self):
         # Tests an implementation detail where tuple is reused
@@ -134,6 +147,18 @@ def test_tuple_reuse(self):
         self.assertEqual(len(set(map(id, list(enumerate(self.seq))))), len(self.seq))
         self.assertEqual(len(set(map(id, enumerate(self.seq)))), min(1,len(self.seq)))
 
+    @support.cpython_only
+    def test_enumerate_result_gc(self):
+        # bpo-42536: enumerate's tuple-reuse speed trick breaks the GC's
+        # assumptions about what can be untracked. Make sure we re-track result
+        # tuples whenever we reuse them.
+        it = self.enum([[]])
+        gc.collect()
+        # That GC collection probably untracked the recycled internal result
+        # tuple, which is initialized to (None, None). Make sure it's re-tracked
+        # when it's mutated and returned from __next__:
+        self.assertTrue(gc.is_tracked(next(it)))
+
 class MyEnum(enumerate):
     pass
 
@@ -253,14 +278,16 @@ def test_basicfunction(self):
 
 
 class TestStart(EnumerateStartTestCase):
+    def enum(self, iterable, start=11):
+        return enumerate(iterable, start=start)
 
-    enum = lambda self, i: enumerate(i, start=11)
     seq, res = 'abc', [(11, 'a'), (12, 'b'), (13, 'c')]
 
 
 class TestLongStart(EnumerateStartTestCase):
+    def enum(self, iterable, start=sys.maxsize + 1):
+        return enumerate(iterable, start=start)
 
-    enum = lambda self, i: enumerate(i, start=sys.maxsize+1)
     seq, res = 'abc', [(sys.maxsize+1,'a'), (sys.maxsize+2,'b'),
                        (sys.maxsize+3,'c')]
 
diff --git a/Lib/test/test_eof.py b/Lib/test/test_eof.py
index 082103b338..2c74e2d87d 100644
--- a/Lib/test/test_eof.py
+++ b/Lib/test/test_eof.py
@@ -1,87 +1,177 @@
 """test script for a few new invalid token catches"""
 
 import sys
-from test import support
+from codecs import BOM_UTF8
+from test.support import force_not_colorized
 from test.support import os_helper
 from test.support import script_helper
 from test.support import warnings_helper
 import unittest
 
 class EOFTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_EOF_single_quote(self):
         expect = "unterminated string literal (detected at line 1) (<string>, line 1)"
         for quote in ("'", "\""):
-            try:
+            with self.assertRaises(SyntaxError) as cm:
                 eval(f"""{quote}this is a test\
                 """)
-            except SyntaxError as msg:
-                self.assertEqual(str(msg), expect)
-                self.assertEqual(msg.offset, 1)
-            else:
-                raise support.TestFailed
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+            self.assertEqual(str(cm.exception), expect)
+            self.assertEqual(cm.exception.offset, 1)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_EOFS(self):
-        expect = ("unterminated triple-quoted string literal (detected at line 1) (<string>, line 1)")
-        try:
-            eval("""'''this is a test""")
-        except SyntaxError as msg:
-            self.assertEqual(str(msg), expect)
-            self.assertEqual(msg.offset, 1)
-        else:
-            raise support.TestFailed
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        expect = ("unterminated triple-quoted string literal (detected at line 3) (<string>, line 1)")
+        with self.assertRaises(SyntaxError) as cm:
+            eval("""ä = '''thîs is \na \ntest""")
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, "ä = '''thîs is ")
+        self.assertEqual(cm.exception.offset, 5)
+
+        with self.assertRaises(SyntaxError) as cm:
+            eval("""ä = '''thîs is \na \ntest""".encode())
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, "ä = '''thîs is ")
+        self.assertEqual(cm.exception.offset, 5)
+
+        with self.assertRaises(SyntaxError) as cm:
+            eval(BOM_UTF8 + """ä = '''thîs is \na \ntest""".encode())
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, "ä = '''thîs is ")
+        self.assertEqual(cm.exception.offset, 5)
+
+        with self.assertRaises(SyntaxError) as cm:
+            eval("""# coding: latin1\nä = '''thîs is \na \ntest""".encode('latin1'))
+        self.assertEqual(str(cm.exception), "unterminated triple-quoted string literal (detected at line 4) (<string>, line 2)")
+        self.assertEqual(cm.exception.text, "ä = '''thîs is ")
+        self.assertEqual(cm.exception.offset, 5)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
     def test_EOFS_with_file(self):
         expect = ("(<string>, line 1)")
         with os_helper.temp_dir() as temp_dir:
-            file_name = script_helper.make_script(temp_dir, 'foo', """'''this is \na \ntest""")
-            rc, out, err = script_helper.assert_python_failure(file_name)
-        self.assertIn(b'unterminated triple-quoted string literal (detected at line 3)', err)
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  """ä = '''thîs is \na \ntest""")
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                "    ä = '''thîs is ",
+                '        ^',
+                'SyntaxError: unterminated triple-quoted string literal (detected at line 3)'])
+
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  """ä = '''thîs is \na \ntest""".encode())
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                "    ä = '''thîs is ",
+                '        ^',
+                'SyntaxError: unterminated triple-quoted string literal (detected at line 3)'])
+
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  BOM_UTF8 + """ä = '''thîs is \na \ntest""".encode())
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                "    ä = '''thîs is ",
+                '        ^',
+                'SyntaxError: unterminated triple-quoted string literal (detected at line 3)'])
+
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  """# coding: latin1\nä = '''thîs is \na \ntest""".encode('latin1'))
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                "    ä = '''thîs is ",
+                '        ^',
+                'SyntaxError: unterminated triple-quoted string literal (detected at line 4)'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @warnings_helper.ignore_warnings(category=SyntaxWarning)
     def test_eof_with_line_continuation(self):
         expect = "unexpected EOF while parsing (<string>, line 1)"
-        try:
+        with self.assertRaises(SyntaxError) as cm:
             compile('"\\Xhh" \\', '<string>', 'exec')
-        except SyntaxError as msg:
-            self.assertEqual(str(msg), expect)
-        else:
-            raise support.TestFailed
+        self.assertEqual(str(cm.exception), expect)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_line_continuation_EOF(self):
         """A continuation at the end of input must be an error; bpo2180."""
         expect = 'unexpected EOF while parsing (<string>, line 1)'
-        with self.assertRaises(SyntaxError) as excinfo:
-            exec('x = 5\\')
-        self.assertEqual(str(excinfo.exception), expect)
-        with self.assertRaises(SyntaxError) as excinfo:
+        with self.assertRaises(SyntaxError) as cm:
+            exec('ä = 5\\')
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, 'ä = 5\\\n')
+        self.assertEqual(cm.exception.offset, 7)
+
+        with self.assertRaises(SyntaxError) as cm:
+            exec('ä = 5\\'.encode())
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, 'ä = 5\\\n')
+        self.assertEqual(cm.exception.offset, 7)
+
+        with self.assertRaises(SyntaxError) as cm:
+            exec('# coding:latin1\nä = 5\\'.encode('latin1'))
+        self.assertEqual(str(cm.exception),
+                         'unexpected EOF while parsing (<string>, line 2)')
+        self.assertEqual(cm.exception.text, 'ä = 5\\\n')
+        self.assertEqual(cm.exception.offset, 7)
+
+        with self.assertRaises(SyntaxError) as cm:
+            exec(BOM_UTF8 + 'ä = 5\\'.encode())
+        self.assertEqual(str(cm.exception), expect)
+        self.assertEqual(cm.exception.text, 'ä = 5\\\n')
+        self.assertEqual(cm.exception.offset, 7)
+
+        with self.assertRaises(SyntaxError) as cm:
             exec('\\')
-        self.assertEqual(str(excinfo.exception), expect)
+        self.assertEqual(str(cm.exception), expect)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(not sys.executable, "sys.executable required")
+    @force_not_colorized
     def test_line_continuation_EOF_from_file_bpo2180(self):
         """Ensure tok_nextc() does not add too many ending newlines."""
         with os_helper.temp_dir() as temp_dir:
             file_name = script_helper.make_script(temp_dir, 'foo', '\\')
-            rc, out, err = script_helper.assert_python_failure(file_name)
-            self.assertIn(b'unexpected EOF while parsing', err)
-            self.assertIn(b'line 1', err)
-            self.assertIn(b'\\', err)
-
-            file_name = script_helper.make_script(temp_dir, 'foo', 'y = 6\\')
-            rc, out, err = script_helper.assert_python_failure(file_name)
-            self.assertIn(b'unexpected EOF while parsing', err)
-            self.assertIn(b'line 1', err)
-            self.assertIn(b'y = 6\\', err)
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-2:], [
+                '    \\',
+                'SyntaxError: unexpected EOF while parsing'])
+            self.assertEqual(err[-3][-8:], ', line 1', err)
+
+            file_name = script_helper.make_script(temp_dir, 'foo', 'ä = 6\\')
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                '    ä = 6\\',
+                '          ^',
+                'SyntaxError: unexpected EOF while parsing'])
+            self.assertEqual(err[-4][-8:], ', line 1', err)
+
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  '# coding:latin1\n'
+                                                  'ä = 7\\'.encode('latin1'))
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                '    ä = 7\\',
+                '          ^',
+                'SyntaxError: unexpected EOF while parsing'])
+            self.assertEqual(err[-4][-8:], ', line 2', err)
+
+            file_name = script_helper.make_script(temp_dir, 'foo',
+                                                  BOM_UTF8 + 'ä = 8\\'.encode())
+            rc, out, err = script_helper.assert_python_failure('-X', 'utf8', file_name)
+            err = err.decode().splitlines()
+            self.assertEqual(err[-3:], [
+                '    ä = 8\\',
+                '          ^',
+                'SyntaxError: unexpected EOF while parsing'])
+            self.assertEqual(err[-4][-8:], ', line 1', err)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_except_star.py b/Lib/test/test_except_star.py
new file mode 100644
index 0000000000..3e0f8caa9b
--- /dev/null
+++ b/Lib/test/test_except_star.py
@@ -0,0 +1,1220 @@
+import sys
+import unittest
+import textwrap
+from test.support.testcase import ExceptionIsLikeMixin
+
+class TestInvalidExceptStar(unittest.TestCase):
+    def test_mixed_except_and_except_star_is_syntax_error(self):
+        errors = [
+            "try: pass\nexcept ValueError: pass\nexcept* TypeError: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept TypeError: pass\n",
+            "try: pass\nexcept ValueError as e: pass\nexcept* TypeError: pass\n",
+            "try: pass\nexcept* ValueError as e: pass\nexcept TypeError: pass\n",
+            "try: pass\nexcept ValueError: pass\nexcept* TypeError as e: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept TypeError as e: pass\n",
+            "try: pass\nexcept ValueError: pass\nexcept*: pass\n",
+            "try: pass\nexcept* ValueError: pass\nexcept: pass\n",
+        ]
+
+        for err in errors:
+            with self.assertRaises(SyntaxError):
+                compile(err, "<string>", "exec")
+
+    def test_except_star_ExceptionGroup_is_runtime_error_single(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise OSError("blah")
+            except* ExceptionGroup as e:
+                pass
+
+    def test_except_star_ExceptionGroup_is_runtime_error_tuple(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise ExceptionGroup("eg", [ValueError(42)])
+            except* (TypeError, ExceptionGroup):
+                pass
+
+    def test_except_star_invalid_exception_type(self):
+        with self.assertRaises(TypeError):
+            try:
+                raise ValueError
+            except* 42:
+                pass
+
+        with self.assertRaises(TypeError):
+            try:
+                raise ValueError
+            except* (ValueError, 42):
+                pass
+
+
+class TestBreakContinueReturnInExceptStarBlock(unittest.TestCase):
+    MSG = (r"'break', 'continue' and 'return'"
+           r" cannot appear in an except\* block")
+
+    def check_invalid(self, src):
+        with self.assertRaisesRegex(SyntaxError, self.MSG):
+            compile(textwrap.dedent(src), "<string>", "exec")
+
+    def test_break_in_except_star(self):
+        self.check_invalid(
+            """
+            try:
+                raise ValueError
+            except* Exception as e:
+                break
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        break
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        break
+                finally:
+                    return 0
+            """)
+
+
+    def test_continue_in_except_star_block_invalid(self):
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    raise ValueError
+                except* Exception as e:
+                    continue
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        continue
+            """)
+
+        self.check_invalid(
+            """
+            for i in range(5):
+                try:
+                    pass
+                except* Exception as e:
+                    if i == 2:
+                        continue
+                finally:
+                    return 0
+            """)
+
+    def test_return_in_except_star_block_invalid(self):
+        self.check_invalid(
+            """
+            def f():
+                try:
+                    raise ValueError
+                except* Exception as e:
+                    return 42
+            """)
+
+        self.check_invalid(
+            """
+            def f():
+                try:
+                    pass
+                except* Exception as e:
+                    return 42
+                finally:
+                    finished = True
+            """)
+
+    def test_break_continue_in_except_star_block_valid(self):
+        try:
+            raise ValueError(42)
+        except* Exception as e:
+            count = 0
+            for i in range(5):
+                if i == 0:
+                    continue
+                if i == 4:
+                    break
+                count += 1
+
+            self.assertEqual(count, 3)
+            self.assertEqual(i, 4)
+            exc = e
+        self.assertIsInstance(exc, ExceptionGroup)
+
+    def test_return_in_except_star_block_valid(self):
+        try:
+            raise ValueError(42)
+        except* Exception as e:
+            def f(x):
+                return 2*x
+            r = f(3)
+            exc = e
+        self.assertEqual(r, 6)
+        self.assertIsInstance(exc, ExceptionGroup)
+
+
+class ExceptStarTest(ExceptionIsLikeMixin, unittest.TestCase):
+    def assertMetadataEqual(self, e1, e2):
+        if e1 is None or e2 is None:
+            self.assertTrue(e1 is None and e2 is None)
+        else:
+            self.assertEqual(e1.__context__, e2.__context__)
+            self.assertEqual(e1.__cause__, e2.__cause__)
+            self.assertEqual(e1.__traceback__, e2.__traceback__)
+
+    def assertMetadataNotEqual(self, e1, e2):
+        if e1 is None or e2 is None:
+            self.assertNotEqual(e1, e2)
+        else:
+            return not (e1.__context__ == e2.__context__
+                        and e1.__cause__ == e2.__cause__
+                        and e1.__traceback__ == e2.__traceback__)
+
+
+class TestExceptStarSplitSemantics(ExceptStarTest):
+    def doSplitTestNamed(self, exc, T, match_template, rest_template):
+        initial_sys_exception = sys.exception()
+        sys_exception = match = rest = None
+        try:
+            try:
+                raise exc
+            except* T as e:
+                sys_exception = sys.exception()
+                match = e
+        except BaseException as e:
+            rest = e
+
+        self.assertEqual(sys_exception, match)
+        self.assertExceptionIsLike(match, match_template)
+        self.assertExceptionIsLike(rest, rest_template)
+        self.assertEqual(sys.exception(), initial_sys_exception)
+
+    def doSplitTestUnnamed(self, exc, T, match_template, rest_template):
+        initial_sys_exception = sys.exception()
+        sys_exception = match = rest = None
+        try:
+            try:
+                raise exc
+            except* T:
+                sys_exception = match = sys.exception()
+            else:
+                if rest_template:
+                    self.fail("Exception not raised")
+        except BaseException as e:
+            rest = e
+        self.assertExceptionIsLike(match, match_template)
+        self.assertExceptionIsLike(rest, rest_template)
+        self.assertEqual(sys.exception(), initial_sys_exception)
+
+    def doSplitTestInExceptHandler(self, exc, T, match_template, rest_template):
+        try:
+            raise ExceptionGroup('eg', [TypeError(1), ValueError(2)])
+        except Exception:
+            self.doSplitTestNamed(exc, T, match_template, rest_template)
+            self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+
+    def doSplitTestInExceptStarHandler(self, exc, T, match_template, rest_template):
+        try:
+            raise ExceptionGroup('eg', [TypeError(1), ValueError(2)])
+        except* Exception:
+            self.doSplitTestNamed(exc, T, match_template, rest_template)
+            self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+
+    def doSplitTest(self, exc, T, match_template, rest_template):
+        self.doSplitTestNamed(exc, T, match_template, rest_template)
+        self.doSplitTestUnnamed(exc, T, match_template, rest_template)
+        self.doSplitTestInExceptHandler(exc, T, match_template, rest_template)
+        self.doSplitTestInExceptStarHandler(exc, T, match_template, rest_template)
+
+    def test_no_match_single_type(self):
+        self.doSplitTest(
+            ExceptionGroup("test1", [ValueError("V"), TypeError("T")]),
+            SyntaxError,
+            None,
+            ExceptionGroup("test1", [ValueError("V"), TypeError("T")]))
+
+    def test_match_single_type(self):
+        self.doSplitTest(
+            ExceptionGroup("test2", [ValueError("V1"), ValueError("V2")]),
+            ValueError,
+            ExceptionGroup("test2", [ValueError("V1"), ValueError("V2")]),
+            None)
+
+    def test_match_single_type_partial_match(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "test3",
+                [ValueError("V1"), OSError("OS"), ValueError("V2")]),
+            ValueError,
+            ExceptionGroup("test3", [ValueError("V1"), ValueError("V2")]),
+            ExceptionGroup("test3", [OSError("OS")]))
+
+    def test_match_single_type_nested(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "g1", [
+                ValueError("V1"),
+                OSError("OS1"),
+                ExceptionGroup(
+                    "g2", [
+                    OSError("OS2"),
+                    ValueError("V2"),
+                    TypeError("T")])]),
+            ValueError,
+            ExceptionGroup(
+                "g1", [
+                ValueError("V1"),
+                ExceptionGroup("g2", [ValueError("V2")])]),
+            ExceptionGroup("g1", [
+                OSError("OS1"),
+                ExceptionGroup("g2", [
+                    OSError("OS2"), TypeError("T")])]))
+
+    def test_match_type_tuple_nested(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "h1", [
+                ValueError("V1"),
+                OSError("OS1"),
+                ExceptionGroup(
+                    "h2", [OSError("OS2"), ValueError("V2"), TypeError("T")])]),
+            (ValueError, TypeError),
+            ExceptionGroup(
+                "h1", [
+                ValueError("V1"),
+                ExceptionGroup("h2", [ValueError("V2"), TypeError("T")])]),
+            ExceptionGroup(
+                "h1", [
+                OSError("OS1"),
+                ExceptionGroup("h2", [OSError("OS2")])]))
+
+    def test_empty_groups_removed(self):
+        self.doSplitTest(
+            ExceptionGroup(
+                "eg", [
+                ExceptionGroup("i1", [ValueError("V1")]),
+                ExceptionGroup("i2", [ValueError("V2"), TypeError("T1")]),
+                ExceptionGroup("i3", [TypeError("T2")])]),
+            TypeError,
+            ExceptionGroup("eg", [
+                ExceptionGroup("i2", [TypeError("T1")]),
+                ExceptionGroup("i3", [TypeError("T2")])]),
+            ExceptionGroup("eg", [
+                    ExceptionGroup("i1", [ValueError("V1")]),
+                    ExceptionGroup("i2", [ValueError("V2")])]))
+
+    def test_singleton_groups_are_kept(self):
+        self.doSplitTest(
+            ExceptionGroup("j1", [
+                ExceptionGroup("j2", [
+                    ExceptionGroup("j3", [ValueError("V1")]),
+                    ExceptionGroup("j4", [TypeError("T")])])]),
+            TypeError,
+            ExceptionGroup(
+                "j1",
+                [ExceptionGroup("j2", [ExceptionGroup("j4", [TypeError("T")])])]),
+            ExceptionGroup(
+                "j1",
+                [ExceptionGroup("j2", [ExceptionGroup("j3", [ValueError("V1")])])]))
+
+    def test_naked_exception_matched_wrapped1(self):
+        self.doSplitTest(
+            ValueError("V"),
+            ValueError,
+            ExceptionGroup("", [ValueError("V")]),
+            None)
+
+    def test_naked_exception_matched_wrapped2(self):
+        self.doSplitTest(
+            ValueError("V"),
+            Exception,
+            ExceptionGroup("", [ValueError("V")]),
+            None)
+
+    def test_exception_group_except_star_Exception_not_wrapped(self):
+        self.doSplitTest(
+            ExceptionGroup("eg", [ValueError("V")]),
+            Exception,
+            ExceptionGroup("eg", [ValueError("V")]),
+            None)
+
+    def test_plain_exception_not_matched(self):
+        self.doSplitTest(
+            ValueError("V"),
+            TypeError,
+            None,
+            ValueError("V"))
+
+    def test_match__supertype(self):
+        self.doSplitTest(
+            ExceptionGroup("st", [BlockingIOError("io"), TypeError("T")]),
+            OSError,
+            ExceptionGroup("st", [BlockingIOError("io")]),
+            ExceptionGroup("st", [TypeError("T")]))
+
+    def test_multiple_matches_named(self):
+        try:
+            raise ExceptionGroup("mmn", [OSError("os"), BlockingIOError("io")])
+        except* BlockingIOError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmn", [BlockingIOError("io")]))
+        except* OSError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmn", [OSError("os")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_multiple_matches_unnamed(self):
+        try:
+            raise ExceptionGroup("mmu", [OSError("os"), BlockingIOError("io")])
+        except* BlockingIOError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmu", [BlockingIOError("io")]))
+        except* OSError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("mmu", [OSError("os")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_first_match_wins_named(self):
+        try:
+            raise ExceptionGroup("fst", [BlockingIOError("io")])
+        except* OSError as e:
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("fst", [BlockingIOError("io")]))
+        except* BlockingIOError:
+            self.fail("Should have been matched as OSError")
+        else:
+            self.fail("Exception not raised")
+
+    def test_first_match_wins_unnamed(self):
+        try:
+            raise ExceptionGroup("fstu", [BlockingIOError("io")])
+        except* OSError:
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                ExceptionGroup("fstu", [BlockingIOError("io")]))
+        except* BlockingIOError:
+            pass
+        else:
+            self.fail("Exception not raised")
+
+    def test_nested_except_stars(self):
+        try:
+            raise ExceptionGroup("n", [BlockingIOError("io")])
+        except* BlockingIOError:
+            try:
+                raise ExceptionGroup("n", [ValueError("io")])
+            except* ValueError:
+                pass
+            else:
+                self.fail("Exception not raised")
+            e = sys.exception()
+            self.assertExceptionIsLike(e,
+                 ExceptionGroup("n", [BlockingIOError("io")]))
+        else:
+            self.fail("Exception not raised")
+
+    def test_nested_in_loop(self):
+        for _ in range(2):
+            try:
+                raise ExceptionGroup("nl", [BlockingIOError("io")])
+            except* BlockingIOError:
+                pass
+            else:
+                self.fail("Exception not raised")
+
+
+class TestExceptStarReraise(ExceptStarTest):
+    def test_reraise_all_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                raise
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2), OSError(3)]))
+
+    def test_reraise_all_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                raise
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2), OSError(3)]))
+
+    def test_reraise_some_handle_all_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                pass
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_partial_handle_all_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                pass
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1)]))
+
+    def test_reraise_partial_handle_some_named(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError as e:
+                raise
+            except* ValueError as e:
+                pass
+            # OSError not handled
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_partial_handle_some_unnamed(self):
+        try:
+            try:
+                raise ExceptionGroup(
+                    "eg", [TypeError(1), ValueError(2), OSError(3)])
+            except* TypeError:
+                raise
+            except* ValueError:
+                pass
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("eg", [TypeError(1), OSError(3)]))
+
+    def test_reraise_plain_exception_named(self):
+        try:
+            try:
+                raise ValueError(42)
+            except* ValueError as e:
+                raise
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [ValueError(42)]))
+
+    def test_reraise_plain_exception_unnamed(self):
+        try:
+            try:
+                raise ValueError(42)
+            except* ValueError:
+                raise
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [ValueError(42)]))
+
+
+class TestExceptStarRaise(ExceptStarTest):
+    def test_raise_named(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError as e:
+                raise TypeError(3)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+
+    def test_raise_unnamed(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError:
+                raise TypeError(3)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+
+    def test_raise_handle_all_raise_one_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3)
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+
+    def test_raise_handle_all_raise_one_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3)
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+
+    def test_raise_handle_all_raise_two_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError as e:
+                raise SyntaxError(3)
+            except* ValueError as e:
+                raise SyntaxError(4)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+
+    def test_raise_handle_all_raise_two_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError:
+                raise SyntaxError(3)
+            except* ValueError:
+                raise SyntaxError(4)
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+
+
+class TestExceptStarRaiseFrom(ExceptStarTest):
+    def test_raise_named(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError as e:
+                raise TypeError(3) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__cause__)
+
+    def test_raise_unnamed(self):
+        orig = ExceptionGroup("eg", [ValueError(1), OSError(2)])
+        try:
+            try:
+                raise orig
+            except* OSError:
+                e = sys.exception()
+                raise TypeError(3) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc,
+            ExceptionGroup(
+                "", [TypeError(3), ExceptionGroup("eg", [ValueError(1)])]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [OSError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataNotEqual(orig, exc.exceptions[1].__cause__)
+
+    def test_raise_handle_all_raise_one_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                raise SyntaxError(3) from e
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.__cause__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+        self.assertMetadataEqual(orig, exc.__cause__)
+
+    def test_raise_handle_all_raise_one_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* (TypeError, ValueError) as e:
+                e = sys.exception()
+                raise SyntaxError(3) from e
+        except SyntaxError as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, SyntaxError(3))
+
+        self.assertExceptionIsLike(
+            exc.__context__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.__cause__,
+            ExceptionGroup("eg", [TypeError(1), ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.__context__)
+        self.assertMetadataEqual(orig, exc.__cause__)
+
+    def test_raise_handle_all_raise_two_named(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError as e:
+                raise SyntaxError(3) from e
+            except* ValueError as e:
+                raise SyntaxError(4) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__cause__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+
+    def test_raise_handle_all_raise_two_unnamed(self):
+        orig = ExceptionGroup("eg", [TypeError(1), ValueError(2)])
+        try:
+            try:
+                raise orig
+            except* TypeError:
+                e = sys.exception()
+                raise SyntaxError(3) from e
+            except* ValueError:
+                e = sys.exception()
+                raise SyntaxError(4) from e
+        except ExceptionGroup as e:
+            exc = e
+
+        self.assertExceptionIsLike(
+            exc, ExceptionGroup("", [SyntaxError(3), SyntaxError(4)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__context__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[0].__cause__,
+            ExceptionGroup("eg", [TypeError(1)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__context__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertExceptionIsLike(
+            exc.exceptions[1].__cause__,
+            ExceptionGroup("eg", [ValueError(2)]))
+
+        self.assertMetadataNotEqual(orig, exc)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[0].__cause__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__context__)
+        self.assertMetadataEqual(orig, exc.exceptions[1].__cause__)
+
+
+class TestExceptStarExceptionGroupSubclass(ExceptStarTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_except_star_EG_subclass(self):
+        class EG(ExceptionGroup):
+            def __new__(cls, message, excs, code):
+                obj = super().__new__(cls, message, excs)
+                obj.code = code
+                return obj
+
+            def derive(self, excs):
+                return EG(self.message, excs, self.code)
+
+        try:
+            try:
+                try:
+                    try:
+                        raise TypeError(2)
+                    except TypeError as te:
+                        raise EG("nested", [te], 101) from None
+                except EG as nested:
+                    try:
+                        raise ValueError(1)
+                    except ValueError as ve:
+                        raise EG("eg", [ve, nested], 42)
+            except* ValueError as eg:
+                veg = eg
+        except EG as eg:
+            teg = eg
+
+        self.assertIsInstance(veg, EG)
+        self.assertIsInstance(teg, EG)
+        self.assertIsInstance(teg.exceptions[0], EG)
+        self.assertMetadataEqual(veg, teg)
+        self.assertEqual(veg.code, 42)
+        self.assertEqual(teg.code, 42)
+        self.assertEqual(teg.exceptions[0].code, 101)
+
+    def test_falsy_exception_group_subclass(self):
+        class FalsyEG(ExceptionGroup):
+            def __bool__(self):
+                return False
+
+            def derive(self, excs):
+                return FalsyEG(self.message, excs)
+
+        try:
+            try:
+                raise FalsyEG("eg", [TypeError(1), ValueError(2)])
+            except *TypeError as e:
+                tes = e
+                raise
+            except *ValueError as e:
+                ves = e
+                pass
+        except Exception as e:
+            exc = e
+
+        for e in [tes, ves, exc]:
+            self.assertFalse(e)
+            self.assertIsInstance(e, FalsyEG)
+
+        self.assertExceptionIsLike(exc, FalsyEG("eg", [TypeError(1)]))
+        self.assertExceptionIsLike(tes, FalsyEG("eg", [TypeError(1)]))
+        self.assertExceptionIsLike(ves, FalsyEG("eg", [ValueError(2)]))
+
+    def test_exception_group_subclass_with_bad_split_func(self):
+        # see gh-128049.
+        class BadEG1(ExceptionGroup):
+            def split(self, *args):
+                return "NOT A 2-TUPLE!"
+
+        class BadEG2(ExceptionGroup):
+            def split(self, *args):
+                return ("NOT A 2-TUPLE!",)
+
+        eg_list = [
+            (BadEG1("eg", [OSError(123), ValueError(456)]),
+             r"split must return a tuple, not str"),
+            (BadEG2("eg", [OSError(123), ValueError(456)]),
+             r"split must return a 2-tuple, got tuple of size 1")
+        ]
+
+        for eg_class, msg in eg_list:
+            with self.assertRaisesRegex(TypeError, msg) as m:
+                try:
+                    raise eg_class
+                except* ValueError:
+                    pass
+                except* OSError:
+                    pass
+
+            self.assertExceptionIsLike(m.exception.__context__, eg_class)
+
+        # we allow tuples of length > 2 for backwards compatibility
+        class WeirdEG(ExceptionGroup):
+            def split(self, *args):
+                return super().split(*args) + ("anything", 123456, None)
+
+        try:
+            raise WeirdEG("eg", [OSError(123), ValueError(456)])
+        except* OSError as e:
+            oeg = e
+        except* ValueError as e:
+            veg = e
+
+        self.assertExceptionIsLike(oeg, WeirdEG("eg", [OSError(123)]))
+        self.assertExceptionIsLike(veg, WeirdEG("eg", [ValueError(456)]))
+
+
+class TestExceptStarCleanup(ExceptStarTest):
+    def test_sys_exception_restored(self):
+        try:
+            try:
+                raise ValueError(42)
+            except:
+                try:
+                    raise TypeError(int)
+                except* Exception:
+                    pass
+                1/0
+        except Exception as e:
+            exc = e
+
+        self.assertExceptionIsLike(exc, ZeroDivisionError('division by zero'))
+        self.assertExceptionIsLike(exc.__context__, ValueError(42))
+        self.assertEqual(sys.exception(), None)
+
+
+class TestExceptStar_WeirdLeafExceptions(ExceptStarTest):
+    # Test that except* works when leaf exceptions are
+    # unhashable or have a bad custom __eq__
+
+    class UnhashableExc(ValueError):
+        __hash__ = None
+
+    class AlwaysEqualExc(ValueError):
+        def __eq__(self, other):
+            return True
+
+    class NeverEqualExc(ValueError):
+        def __eq__(self, other):
+            return False
+
+    class BrokenEqualExc(ValueError):
+        def __eq__(self, other):
+            raise RuntimeError()
+
+    def setUp(self):
+        self.bad_types = [self.UnhashableExc,
+                          self.AlwaysEqualExc,
+                          self.NeverEqualExc,
+                          self.BrokenEqualExc]
+
+    def except_type(self, eg, type):
+        match, rest = None, None
+        try:
+            try:
+                raise eg
+            except* type  as e:
+                match = e
+        except Exception as e:
+            rest = e
+        return match, rest
+
+    def test_catch_unhashable_leaf_exception(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, Bad)
+                self.assertExceptionIsLike(
+                    match, ExceptionGroup("eg", [Bad(2)]))
+                self.assertExceptionIsLike(
+                    rest, ExceptionGroup("eg", [TypeError(1)]))
+
+    def test_propagate_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, TypeError)
+                self.assertExceptionIsLike(
+                    match, ExceptionGroup("eg", [TypeError(1)]))
+                self.assertExceptionIsLike(
+                    rest, ExceptionGroup("eg", [Bad(2)]))
+
+    def test_catch_nothing_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, OSError)
+                self.assertIsNone(match)
+                self.assertExceptionIsLike(rest, eg)
+
+    def test_catch_everything_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup("eg", [TypeError(1), Bad(2)])
+                match, rest = self.except_type(eg, Exception)
+                self.assertExceptionIsLike(match, eg)
+                self.assertIsNone(rest)
+
+    def test_reraise_unhashable_leaf(self):
+        for Bad in self.bad_types:
+            with self.subTest(Bad):
+                eg = ExceptionGroup(
+                    "eg", [TypeError(1), Bad(2), ValueError(3)])
+
+                try:
+                    try:
+                        raise eg
+                    except* TypeError:
+                        pass
+                    except* Bad:
+                        raise
+                except Exception as e:
+                    exc = e
+
+                self.assertExceptionIsLike(
+                    exc, ExceptionGroup("eg", [Bad(2), ValueError(3)]))
+
+
+class TestExceptStar_WeirdExceptionGroupSubclass(ExceptStarTest):
+    # Test that except* works with exception groups that are
+    # unhashable or have a bad custom __eq__
+
+    class UnhashableEG(ExceptionGroup):
+        __hash__ = None
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class AlwaysEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            return True
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class NeverEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            return False
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    class BrokenEqualEG(ExceptionGroup):
+        def __eq__(self, other):
+            raise RuntimeError()
+
+        def derive(self, excs):
+            return type(self)(self.message, excs)
+
+    def setUp(self):
+        self.bad_types = [self.UnhashableEG,
+                          self.AlwaysEqualEG,
+                          self.NeverEqualEG,
+                          self.BrokenEqualEG]
+
+    def except_type(self, eg, type):
+        match, rest = None, None
+        try:
+            try:
+                raise eg
+            except* type  as e:
+                match = e
+        except Exception as e:
+            rest = e
+        return match, rest
+
+    def test_catch_some_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, TypeError)
+                self.assertExceptionIsLike(match, BadEG("eg", [TypeError(1)]))
+                self.assertExceptionIsLike(rest,
+                    BadEG("eg", [BadEG("nested", [ValueError(2)])]))
+
+    def test_catch_none_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, OSError)
+                self.assertIsNone(match)
+                self.assertExceptionIsLike(rest, eg)
+
+    def test_catch_all_unhashable_exception_group_subclass(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1),
+                            BadEG("nested", [ValueError(2)])])
+
+                match, rest = self.except_type(eg, Exception)
+                self.assertExceptionIsLike(match, eg)
+                self.assertIsNone(rest)
+
+    def test_reraise_unhashable_eg(self):
+        for BadEG in self.bad_types:
+            with self.subTest(BadEG):
+
+                eg = BadEG("eg",
+                           [TypeError(1), ValueError(2),
+                            BadEG("nested", [ValueError(3), OSError(4)])])
+
+                try:
+                    try:
+                        raise eg
+                    except* ValueError:
+                        pass
+                    except* OSError:
+                        raise
+                except Exception as e:
+                    exc = e
+
+                self.assertExceptionIsLike(
+                    exc, BadEG("eg", [TypeError(1),
+                               BadEG("nested", [OSError(4)])]))
+
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file
diff --git a/Lib/test/test_exception_group.py b/Lib/test/test_exception_group.py
index d0d81490df..2b48530a30 100644
--- a/Lib/test/test_exception_group.py
+++ b/Lib/test/test_exception_group.py
@@ -1,7 +1,7 @@
 import collections.abc
 import types
 import unittest
-from test.support import C_RECURSION_LIMIT
+from test.support import get_c_recursion_limit
 
 class TestExceptionGroupTypeHierarchy(unittest.TestCase):
     def test_exception_group_types(self):
@@ -15,8 +15,6 @@ def test_exception_is_not_generic_type(self):
         with self.assertRaisesRegex(TypeError, 'Exception'):
             Exception[OSError]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_group_is_generic_type(self):
         E = OSError
         self.assertIsInstance(ExceptionGroup[E], types.GenericAlias)
@@ -300,6 +298,15 @@ def assertMatchesTemplate(self, exc, exc_type, template):
             self.assertEqual(type(exc), type(template))
             self.assertEqual(exc.args, template.args)
 
+class Predicate:
+    def __init__(self, func):
+        self.func = func
+
+    def __call__(self, e):
+        return self.func(e)
+
+    def method(self, e):
+        return self.func(e)
 
 class ExceptionGroupSubgroupTests(ExceptionGroupTestBase):
     def setUp(self):
@@ -307,10 +314,15 @@ def setUp(self):
         self.eg_template = [ValueError(1), TypeError(int), ValueError(2)]
 
     def test_basics_subgroup_split__bad_arg_type(self):
+        class C:
+            pass
+
         bad_args = ["bad arg",
+                    C,
                     OSError('instance not type'),
                     [OSError, TypeError],
-                    (OSError, 42)]
+                    (OSError, 42),
+                   ]
         for arg in bad_args:
             with self.assertRaises(TypeError):
                 self.eg.subgroup(arg)
@@ -342,10 +354,14 @@ def test_basics_subgroup_by_type__match(self):
                 self.assertMatchesTemplate(subeg, ExceptionGroup, template)
 
     def test_basics_subgroup_by_predicate__passthrough(self):
-        self.assertIs(self.eg, self.eg.subgroup(lambda e: True))
+        f = lambda e: True
+        for callable in [f, Predicate(f), Predicate(f).method]:
+            self.assertIs(self.eg, self.eg.subgroup(callable))
 
     def test_basics_subgroup_by_predicate__no_match(self):
-        self.assertIsNone(self.eg.subgroup(lambda e: False))
+        f = lambda e: False
+        for callable in [f, Predicate(f), Predicate(f).method]:
+            self.assertIsNone(self.eg.subgroup(callable))
 
     def test_basics_subgroup_by_predicate__match(self):
         eg = self.eg
@@ -356,9 +372,12 @@ def test_basics_subgroup_by_predicate__match(self):
             ((ValueError, TypeError), self.eg_template)]
 
         for match_type, template in testcases:
-            subeg = eg.subgroup(lambda e: isinstance(e, match_type))
-            self.assertEqual(subeg.message, eg.message)
-            self.assertMatchesTemplate(subeg, ExceptionGroup, template)
+            f = lambda e: isinstance(e, match_type)
+            for callable in [f, Predicate(f), Predicate(f).method]:
+                with self.subTest(callable=callable):
+                    subeg = eg.subgroup(f)
+                    self.assertEqual(subeg.message, eg.message)
+                    self.assertMatchesTemplate(subeg, ExceptionGroup, template)
 
 
 class ExceptionGroupSplitTests(ExceptionGroupTestBase):
@@ -405,14 +424,18 @@ def test_basics_split_by_type__match(self):
                 self.assertIsNone(rest)
 
     def test_basics_split_by_predicate__passthrough(self):
-        match, rest = self.eg.split(lambda e: True)
-        self.assertMatchesTemplate(match, ExceptionGroup, self.eg_template)
-        self.assertIsNone(rest)
+        f = lambda e: True
+        for callable in [f, Predicate(f), Predicate(f).method]:
+            match, rest = self.eg.split(callable)
+            self.assertMatchesTemplate(match, ExceptionGroup, self.eg_template)
+            self.assertIsNone(rest)
 
     def test_basics_split_by_predicate__no_match(self):
-        match, rest = self.eg.split(lambda e: False)
-        self.assertIsNone(match)
-        self.assertMatchesTemplate(rest, ExceptionGroup, self.eg_template)
+        f = lambda e: False
+        for callable in [f, Predicate(f), Predicate(f).method]:
+            match, rest = self.eg.split(callable)
+            self.assertIsNone(match)
+            self.assertMatchesTemplate(rest, ExceptionGroup, self.eg_template)
 
     def test_basics_split_by_predicate__match(self):
         eg = self.eg
@@ -426,20 +449,22 @@ def test_basics_split_by_predicate__match(self):
         ]
 
         for match_type, match_template, rest_template in testcases:
-            match, rest = eg.split(lambda e: isinstance(e, match_type))
-            self.assertEqual(match.message, eg.message)
-            self.assertMatchesTemplate(
-                match, ExceptionGroup, match_template)
-            if rest_template is not None:
-                self.assertEqual(rest.message, eg.message)
+            f = lambda e: isinstance(e, match_type)
+            for callable in [f, Predicate(f), Predicate(f).method]:
+                match, rest = eg.split(callable)
+                self.assertEqual(match.message, eg.message)
                 self.assertMatchesTemplate(
-                    rest, ExceptionGroup, rest_template)
+                    match, ExceptionGroup, match_template)
+                if rest_template is not None:
+                    self.assertEqual(rest.message, eg.message)
+                    self.assertMatchesTemplate(
+                        rest, ExceptionGroup, rest_template)
 
 
 class DeepRecursionInSplitAndSubgroup(unittest.TestCase):
     def make_deep_eg(self):
         e = TypeError(1)
-        for i in range(C_RECURSION_LIMIT + 1):
+        for i in range(get_c_recursion_limit() + 1):
             e = ExceptionGroup('eg', [e])
         return e
 
@@ -783,8 +808,6 @@ def test_split_copies_notes(self):
         self.assertEqual(match.__notes__, orig_notes + ["match"])
         self.assertEqual(rest.__notes__, orig_notes + ["rest"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_split_does_not_copy_non_sequence_notes(self):
         # __notes__ should be a sequence, which is shallow copied.
         # If it is not a sequence, the split parts don't get any notes.
@@ -794,8 +817,6 @@ def test_split_does_not_copy_non_sequence_notes(self):
         self.assertFalse(hasattr(match, '__notes__'))
         self.assertFalse(hasattr(rest, '__notes__'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_drive_invalid_return_value(self):
         class MyEg(ExceptionGroup):
             def derive(self, excs):
diff --git a/Lib/test/test_exception_hierarchy.py b/Lib/test/test_exception_hierarchy.py
index efee88cd5e..e8c1c7fd1e 100644
--- a/Lib/test/test_exception_hierarchy.py
+++ b/Lib/test/test_exception_hierarchy.py
@@ -127,7 +127,6 @@ def test_windows_error(self):
         else:
             self.assertNotIn('winerror', dir(OSError))
 
-    @unittest.skip("TODO: RUSTPYTHON")
     def test_posix_error(self):
         e = OSError(EEXIST, "File already exists", "foo.txt")
         self.assertEqual(e.errno, EEXIST)
@@ -137,8 +136,6 @@ def test_posix_error(self):
         if os.name == "nt":
             self.assertEqual(e.winerror, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(os.name == "nt", "Windows-specific test")
     def test_errno_translation(self):
         # ERROR_ALREADY_EXISTS (183) -> EEXIST
diff --git a/Lib/test/test_exception_variations.py b/Lib/test/test_exception_variations.py
index d874b0e3d1..e103eaf846 100644
--- a/Lib/test/test_exception_variations.py
+++ b/Lib/test/test_exception_variations.py
@@ -1,7 +1,7 @@
 
 import unittest
 
-class ExceptionTestCase(unittest.TestCase):
+class ExceptTestCases(unittest.TestCase):
     def test_try_except_else_finally(self):
         hit_except = False
         hit_else = False
@@ -172,5 +172,406 @@ def test_nested_else(self):
         self.assertTrue(hit_finally)
         self.assertTrue(hit_except)
 
+    def test_nested_exception_in_except(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+
+        try:
+            try:
+                raise Exception('inner exception')
+            except:
+                hit_inner_except = True
+                raise Exception('outer exception')
+            else:
+                hit_inner_else = True
+        except:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_inner_except)
+        self.assertFalse(hit_inner_else)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+    def test_nested_exception_in_else(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+
+        try:
+            try:
+                pass
+            except:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+                raise Exception('outer exception')
+        except:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_inner_except)
+        self.assertTrue(hit_inner_else)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+    def test_nested_exception_in_finally_no_exception(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+        hit_inner_finally = False
+
+        try:
+            try:
+                pass
+            except:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+            finally:
+                hit_inner_finally = True
+                raise Exception('outer exception')
+        except:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_inner_except)
+        self.assertTrue(hit_inner_else)
+        self.assertTrue(hit_inner_finally)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+    def test_nested_exception_in_finally_with_exception(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+        hit_inner_finally = False
+
+        try:
+            try:
+                raise Exception('inner exception')
+            except:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+            finally:
+                hit_inner_finally = True
+                raise Exception('outer exception')
+        except:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+
+        self.assertTrue(hit_inner_except)
+        self.assertFalse(hit_inner_else)
+        self.assertTrue(hit_inner_finally)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+
+# TODO: RUSTPYTHON
+'''
+class ExceptStarTestCases(unittest.TestCase):
+    def test_try_except_else_finally(self):
+        hit_except = False
+        hit_else = False
+        hit_finally = False
+
+        try:
+            raise Exception('nyaa!')
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_except)
+        self.assertTrue(hit_finally)
+        self.assertFalse(hit_else)
+
+    def test_try_except_else_finally_no_exception(self):
+        hit_except = False
+        hit_else = False
+        hit_finally = False
+
+        try:
+            pass
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_except)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_else)
+
+    def test_try_except_finally(self):
+        hit_except = False
+        hit_finally = False
+
+        try:
+            raise Exception('yarr!')
+        except* BaseException:
+            hit_except = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_except)
+        self.assertTrue(hit_finally)
+
+    def test_try_except_finally_no_exception(self):
+        hit_except = False
+        hit_finally = False
+
+        try:
+            pass
+        except* BaseException:
+            hit_except = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_except)
+        self.assertTrue(hit_finally)
+
+    def test_try_except(self):
+        hit_except = False
+
+        try:
+            raise Exception('ahoy!')
+        except* BaseException:
+            hit_except = True
+
+        self.assertTrue(hit_except)
+
+    def test_try_except_no_exception(self):
+        hit_except = False
+
+        try:
+            pass
+        except* BaseException:
+            hit_except = True
+
+        self.assertFalse(hit_except)
+
+    def test_try_except_else(self):
+        hit_except = False
+        hit_else = False
+
+        try:
+            raise Exception('foo!')
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_except)
+
+    def test_try_except_else_no_exception(self):
+        hit_except = False
+        hit_else = False
+
+        try:
+            pass
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+
+        self.assertFalse(hit_except)
+        self.assertTrue(hit_else)
+
+    def test_try_finally_no_exception(self):
+        hit_finally = False
+
+        try:
+            pass
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_finally)
+
+    def test_nested(self):
+        hit_finally = False
+        hit_inner_except = False
+        hit_inner_finally = False
+
+        try:
+            try:
+                raise Exception('inner exception')
+            except* BaseException:
+                hit_inner_except = True
+            finally:
+                hit_inner_finally = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_inner_except)
+        self.assertTrue(hit_inner_finally)
+        self.assertTrue(hit_finally)
+
+    def test_nested_else(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+
+        try:
+            try:
+                pass
+            except* BaseException:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+
+            raise Exception('outer exception')
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_inner_except)
+        self.assertTrue(hit_inner_else)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+    def test_nested_mixed1(self):
+        hit_except = False
+        hit_finally = False
+        hit_inner_except = False
+        hit_inner_finally = False
+
+        try:
+            try:
+                raise Exception('inner exception')
+            except* BaseException:
+                hit_inner_except = True
+            finally:
+                hit_inner_finally = True
+        except:
+            hit_except = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_inner_except)
+        self.assertTrue(hit_inner_finally)
+        self.assertFalse(hit_except)
+        self.assertTrue(hit_finally)
+
+    def test_nested_mixed2(self):
+        hit_except = False
+        hit_finally = False
+        hit_inner_except = False
+        hit_inner_finally = False
+
+        try:
+            try:
+                raise Exception('inner exception')
+            except:
+                hit_inner_except = True
+            finally:
+                hit_inner_finally = True
+        except* BaseException:
+            hit_except = True
+        finally:
+            hit_finally = True
+
+        self.assertTrue(hit_inner_except)
+        self.assertTrue(hit_inner_finally)
+        self.assertFalse(hit_except)
+        self.assertTrue(hit_finally)
+
+
+    def test_nested_else_mixed1(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+
+        try:
+            try:
+                pass
+            except* BaseException:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+
+            raise Exception('outer exception')
+        except:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_inner_except)
+        self.assertTrue(hit_inner_else)
+        self.assertFalse(hit_else)
+        self.assertTrue(hit_finally)
+        self.assertTrue(hit_except)
+
+    def test_nested_else_mixed2(self):
+        hit_else = False
+        hit_finally = False
+        hit_except = False
+        hit_inner_except = False
+        hit_inner_else = False
+
+        try:
+            try:
+                pass
+            except:
+                hit_inner_except = True
+            else:
+                hit_inner_else = True
+
+            raise Exception('outer exception')
+        except* BaseException:
+            hit_except = True
+        else:
+            hit_else = True
+        finally:
+            hit_finally = True
+
+        self.assertFalse(hit_inner_except)
+        self.assertTrue(hit_inner_else)
+        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 1864e611ab..ceb94df324 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -1,24 +1,33 @@
 # Python test set -- part 5, built-in exceptions
 
 import copy
-import gc
 import os
 import sys
 import unittest
 import pickle
 import weakref
 import errno
+from codecs import BOM_UTF8
+from itertools import product
 from textwrap import dedent
 
 from test.support import (captured_stderr, check_impl_detail,
                           cpython_only, gc_collect,
                           no_tracing, script_helper,
-                          SuppressCrashReport)
+                          SuppressCrashReport,
+                          force_not_colorized)
 from test.support.import_helper import import_module
 from test.support.os_helper import TESTFN, unlink
 from test.support.warnings_helper import check_warnings
 from test import support
 
+try:
+    import _testcapi
+    from _testcapi import INT_MAX
+except ImportError:
+    _testcapi = None
+    INT_MAX = 2**31 - 1
+
 
 class NaiveException(Exception):
     def __init__(self, x):
@@ -35,6 +44,7 @@ def __str__(self):
 
 # XXX This is not really enough, each *operation* should be tested!
 
+
 class ExceptionTests(unittest.TestCase):
 
     def raise_catch(self, exc, excname):
@@ -50,8 +60,7 @@ def raise_catch(self, exc, excname):
             self.assertEqual(buf1, buf2)
             self.assertEqual(exc.__name__, excname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testRaising(self):
         self.raise_catch(AttributeError, "AttributeError")
         self.assertRaises(AttributeError, getattr, sys, "undefined_attribute")
@@ -136,8 +145,7 @@ def testRaising(self):
 
         self.raise_catch(StopAsyncIteration, "StopAsyncIteration")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testSyntaxErrorMessage(self):
         # make sure the right exception message is raised for each of
         # these code fragments
@@ -160,9 +168,9 @@ def ckmsg(src, msg):
 
         ckmsg(s, "'continue' not properly in loop")
         ckmsg("continue\n", "'continue' not properly in loop")
+        ckmsg("f'{6 0}'", "invalid syntax. Perhaps you forgot a comma?")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testSyntaxErrorMissingParens(self):
         def ckmsg(src, msg, exception=SyntaxError):
             try:
@@ -220,15 +228,13 @@ def check(self, src, lineno, offset, end_lineno=None, end_offset=None, encoding=
                     src = src.decode(encoding, 'replace')
                 line = src.split('\n')[lineno-1]
                 self.assertIn(line, cm.exception.text)
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_error_offset_continuation_characters(self):
         check = self.check
         check('"\\\n"(1 for c in I,\\\n\\', 2, 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testSyntaxErrorOffset(self):
         check = self.check
         check('def fact(x):\n\treturn x!\n', 2, 10)
@@ -238,7 +244,7 @@ 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, 18)
+        check(b'Python = "\xcf\xb3\xf2\xee\xed" +', 1, 10)
         check('x = "a', 1, 5)
         check('lambda x: x = 2', 1, 1)
         check('f{a + b + c}', 1, 2)
@@ -263,7 +269,7 @@ def testSyntaxErrorOffset(self):
         check('try:\n  pass\nexcept*:\n  pass', 3, 8)
         check('try:\n  pass\nexcept*:\n  pass\nexcept* ValueError:\n  pass', 3, 8)
 
-        # Errors thrown by tokenizer.c
+        # Errors thrown by the tokenizer
         check('(0x+1)', 1, 3)
         check('x = 0xI', 1, 6)
         check('0010 + 2', 1, 1)
@@ -305,6 +311,7 @@ def baz():
             {
             6
             0="""''', 5, 13)
+        check('b"fooжжж"'.encode(), 1, 1, 1, 10)
 
         # Errors thrown by symtable.c
         check('x = [(yield i) for i in range(3)]', 1, 7)
@@ -317,8 +324,8 @@ def baz():
         check('def f():\n  global x\n  nonlocal x', 2, 3)
 
         # Errors thrown by future.c
-        check('from __future__ import doesnt_exist', 1, 1)
-        check('from __future__ import braces', 1, 1)
+        check('from __future__ import doesnt_exist', 1, 24)
+        check('from __future__ import braces', 1, 24)
         check('x=1\nfrom __future__ import division', 2, 1)
         check('foo(1=2)', 1, 5)
         check('def f():\n  x, y: int', 2, 3)
@@ -328,6 +335,14 @@ def baz():
         check('(yield i) = 2', 1, 2)
         check('def f(*):\n  pass', 1, 7)
 
+    @unittest.skipIf(INT_MAX >= sys.maxsize, "Downcasting to int is safe for col_offset")
+    @support.requires_resource('cpu')
+    @support.bigmemtest(INT_MAX, memuse=2, dry_run=False)
+    def testMemoryErrorBigSource(self, size):
+        src = b"if True:\n%*s" % (size, b"pass")
+        with self.assertRaisesRegex(OverflowError, "Parser column offset overflow"):
+            compile(src, '<fragment>', 'exec')
+
     @cpython_only
     def testSettingException(self):
         # test that setting an exception at the C level works even if the
@@ -340,24 +355,23 @@ def __init__(self_):
         class InvalidException:
             pass
 
+        @unittest.skipIf(_testcapi is None, "requires _testcapi")
         def test_capi1():
-            import _testcapi
             try:
                 _testcapi.raise_exception(BadException, 1)
             except TypeError as err:
-                exc, err, tb = sys.exc_info()
-                co = tb.tb_frame.f_code
+                co = err.__traceback__.tb_frame.f_code
                 self.assertEqual(co.co_name, "test_capi1")
                 self.assertTrue(co.co_filename.endswith('test_exceptions.py'))
             else:
                 self.fail("Expected exception")
 
+        @unittest.skipIf(_testcapi is None, "requires _testcapi")
         def test_capi2():
-            import _testcapi
             try:
                 _testcapi.raise_exception(BadException, 0)
             except RuntimeError as err:
-                exc, err, tb = sys.exc_info()
+                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'))
@@ -366,15 +380,14 @@ def test_capi2():
             else:
                 self.fail("Expected exception")
 
+        @unittest.skipIf(_testcapi is None, "requires _testcapi")
         def test_capi3():
-            import _testcapi
             self.assertRaises(SystemError, _testcapi.raise_exception,
                               InvalidException, 1)
 
-        if not sys.platform.startswith('java'):
-            test_capi1()
-            test_capi2()
-            test_capi3()
+        test_capi1()
+        test_capi2()
+        test_capi3()
 
     def test_WindowsError(self):
         try:
@@ -417,6 +430,7 @@ def test_WindowsError(self):
 
     @unittest.skipUnless(sys.platform == 'win32',
                          'test specific to Windows')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_windows_message(self):
         """Should fill in unknown error code in Windows error message"""
         ctypes = import_module('ctypes')
@@ -425,49 +439,50 @@ def test_windows_message(self):
         with self.assertRaisesRegex(OSError, 'Windows Error 0x%x' % code):
             ctypes.pythonapi.PyErr_SetFromWindowsErr(code)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def testAttributes(self):
         # test that exception attributes are happy
 
         exceptionList = [
-            (BaseException, (), {'args' : ()}),
-            (BaseException, (1, ), {'args' : (1,)}),
-            (BaseException, ('foo',),
+            (BaseException, (), {}, {'args' : ()}),
+            (BaseException, (1, ), {}, {'args' : (1,)}),
+            (BaseException, ('foo',), {},
                 {'args' : ('foo',)}),
-            (BaseException, ('foo', 1),
+            (BaseException, ('foo', 1), {},
                 {'args' : ('foo', 1)}),
-            (SystemExit, ('foo',),
+            (SystemExit, ('foo',), {},
                 {'args' : ('foo',), 'code' : 'foo'}),
-            (OSError, ('foo',),
+            (OSError, ('foo',), {},
                 {'args' : ('foo',), 'filename' : None, 'filename2' : None,
                  'errno' : None, 'strerror' : None}),
-            (OSError, ('foo', 'bar'),
+            (OSError, ('foo', 'bar'), {},
                 {'args' : ('foo', 'bar'),
                  'filename' : None, 'filename2' : None,
                  'errno' : 'foo', 'strerror' : 'bar'}),
-            (OSError, ('foo', 'bar', 'baz'),
+            (OSError, ('foo', 'bar', 'baz'), {},
                 {'args' : ('foo', 'bar'),
                  'filename' : 'baz', 'filename2' : None,
                  'errno' : 'foo', 'strerror' : 'bar'}),
-            (OSError, ('foo', 'bar', 'baz', None, 'quux'),
+            (OSError, ('foo', 'bar', 'baz', None, 'quux'), {},
                 {'args' : ('foo', 'bar'), 'filename' : 'baz', 'filename2': 'quux'}),
-            (OSError, ('errnoStr', 'strErrorStr', 'filenameStr'),
+            (OSError, ('errnoStr', 'strErrorStr', 'filenameStr'), {},
                 {'args' : ('errnoStr', 'strErrorStr'),
                  'strerror' : 'strErrorStr', 'errno' : 'errnoStr',
                  'filename' : 'filenameStr'}),
-            (OSError, (1, 'strErrorStr', 'filenameStr'),
+            (OSError, (1, 'strErrorStr', 'filenameStr'), {},
                 {'args' : (1, 'strErrorStr'), 'errno' : 1,
                  'strerror' : 'strErrorStr',
                  'filename' : 'filenameStr', 'filename2' : None}),
-            (SyntaxError, (), {'msg' : None, 'text' : None,
+            (SyntaxError, (), {}, {'msg' : None, 'text' : None,
                 'filename' : None, 'lineno' : None, 'offset' : None,
                 'end_offset': None, 'print_file_and_line' : None}),
-            (SyntaxError, ('msgStr',),
+            (SyntaxError, ('msgStr',), {},
                 {'args' : ('msgStr',), 'text' : None,
                  'print_file_and_line' : None, 'msg' : 'msgStr',
                  'filename' : None, 'lineno' : None, 'offset' : None,
                  'end_offset': None}),
             (SyntaxError, ('msgStr', ('filenameStr', 'linenoStr', 'offsetStr',
-                           'textStr', 'endLinenoStr', 'endOffsetStr')),
+                           'textStr', 'endLinenoStr', 'endOffsetStr')), {},
                 {'offset' : 'offsetStr', 'text' : 'textStr',
                  'args' : ('msgStr', ('filenameStr', 'linenoStr',
                                       'offsetStr', 'textStr',
@@ -477,7 +492,7 @@ def testAttributes(self):
                  'end_lineno': 'endLinenoStr', 'end_offset': 'endOffsetStr'}),
             (SyntaxError, ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr',
                            'textStr', 'endLinenoStr', 'endOffsetStr',
-                           'print_file_and_lineStr'),
+                           'print_file_and_lineStr'), {},
                 {'text' : None,
                  'args' : ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr',
                            'textStr', 'endLinenoStr', 'endOffsetStr',
@@ -485,38 +500,40 @@ def testAttributes(self):
                  'print_file_and_line' : None, 'msg' : 'msgStr',
                  'filename' : None, 'lineno' : None, 'offset' : None,
                  'end_lineno': None, 'end_offset': None}),
-            (UnicodeError, (), {'args' : (),}),
+            (UnicodeError, (), {}, {'args' : (),}),
             (UnicodeEncodeError, ('ascii', 'a', 0, 1,
-                                  'ordinal not in range'),
+                                  'ordinal not in range'), {},
                 {'args' : ('ascii', 'a', 0, 1,
                                            'ordinal not in range'),
                  'encoding' : 'ascii', 'object' : 'a',
                  'start' : 0, 'reason' : 'ordinal not in range'}),
             (UnicodeDecodeError, ('ascii', bytearray(b'\xff'), 0, 1,
-                                  'ordinal not in range'),
+                                  'ordinal not in range'), {},
                 {'args' : ('ascii', bytearray(b'\xff'), 0, 1,
                                            'ordinal not in range'),
                  'encoding' : 'ascii', 'object' : b'\xff',
                  'start' : 0, 'reason' : 'ordinal not in range'}),
             (UnicodeDecodeError, ('ascii', b'\xff', 0, 1,
-                                  'ordinal not in range'),
+                                  'ordinal not in range'), {},
                 {'args' : ('ascii', b'\xff', 0, 1,
                                            'ordinal not in range'),
                  'encoding' : 'ascii', 'object' : b'\xff',
                  'start' : 0, 'reason' : 'ordinal not in range'}),
-            (UnicodeTranslateError, ("\u3042", 0, 1, "ouch"),
+            (UnicodeTranslateError, ("\u3042", 0, 1, "ouch"), {},
                 {'args' : ('\u3042', 0, 1, 'ouch'),
                  'object' : '\u3042', 'reason' : 'ouch',
                  'start' : 0, 'end' : 1}),
-            (NaiveException, ('foo',),
+            (NaiveException, ('foo',), {},
                 {'args': ('foo',), 'x': 'foo'}),
-            (SlottedNaiveException, ('foo',),
+            (SlottedNaiveException, ('foo',), {},
                 {'args': ('foo',), 'x': 'foo'}),
+            (AttributeError, ('foo',), dict(name='name', obj='obj'),
+                dict(args=('foo',), name='name', obj='obj')),
         ]
         try:
             # More tests are in test_WindowsError
             exceptionList.append(
-                (WindowsError, (1, 'strErrorStr', 'filenameStr'),
+                (WindowsError, (1, 'strErrorStr', 'filenameStr'), {},
                     {'args' : (1, 'strErrorStr'),
                      'strerror' : 'strErrorStr', 'winerror' : None,
                      'errno' : 1,
@@ -525,11 +542,11 @@ def testAttributes(self):
         except NameError:
             pass
 
-        for exc, args, expected in exceptionList:
+        for exc, args, kwargs, expected in exceptionList:
             try:
-                e = exc(*args)
+                e = exc(*args, **kwargs)
             except:
-                print("\nexc=%r, args=%r" % (exc, args), file=sys.stderr)
+                print(f"\nexc={exc!r}, args={args!r}", file=sys.stderr)
                 # raise
             else:
                 # Verify module name
@@ -552,13 +569,39 @@ def testAttributes(self):
                         new = p.loads(s)
                         for checkArgName in expected:
                             got = repr(getattr(new, checkArgName))
-                            want = repr(expected[checkArgName])
+                            if exc == AttributeError and checkArgName == 'obj':
+                                # See GH-103352, we're not pickling
+                                # obj at this point. So verify it's None.
+                                want = repr(None)
+                            else:
+                                want = repr(expected[checkArgName])
                             self.assertEqual(got, want,
                                              'pickled "%r", attribute "%s' %
                                              (e, checkArgName))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_setstate(self):
+        e = Exception(42)
+        e.blah = 53
+        self.assertEqual(e.args, (42,))
+        self.assertEqual(e.blah, 53)
+        self.assertRaises(AttributeError, getattr, e, 'a')
+        self.assertRaises(AttributeError, getattr, e, 'b')
+        e.__setstate__({'a': 1 , 'b': 2})
+        self.assertEqual(e.args, (42,))
+        self.assertEqual(e.blah, 53)
+        self.assertEqual(e.a, 1)
+        self.assertEqual(e.b, 2)
+        e.__setstate__({'a': 11, 'args': (1,2,3), 'blah': 35})
+        self.assertEqual(e.args, (1,2,3))
+        self.assertEqual(e.blah, 35)
+        self.assertEqual(e.a, 11)
+        self.assertEqual(e.b, 2)
+
+    def test_invalid_setstate(self):
+        e = Exception(42)
+        with self.assertRaisesRegex(TypeError, "state is not a dictionary"):
+            e.__setstate__(42)
+
     def test_notes(self):
         for e in [BaseException(1), Exception(2), ValueError(3)]:
             with self.subTest(e=e):
@@ -589,8 +632,8 @@ def test_notes(self):
     def testWithTraceback(self):
         try:
             raise IndexError(4)
-        except:
-            tb = sys.exc_info()[2]
+        except Exception as e:
+            tb = e.__traceback__
 
         e = BaseException().with_traceback(tb)
         self.assertIsInstance(e, BaseException)
@@ -615,17 +658,38 @@ def testInvalidTraceback(self):
         else:
             self.fail("No exception raised")
 
-    def testInvalidAttrs(self):
-        self.assertRaises(TypeError, setattr, Exception(), '__cause__', 1)
-        self.assertRaises(TypeError, delattr, Exception(), '__cause__')
-        self.assertRaises(TypeError, setattr, Exception(), '__context__', 1)
-        self.assertRaises(TypeError, delattr, Exception(), '__context__')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_invalid_setattr(self):
+        TE = TypeError
+        exc = Exception()
+        msg = "'int' object is not iterable"
+        self.assertRaisesRegex(TE, msg, setattr, exc, 'args', 1)
+        msg = "__traceback__ must be a traceback or None"
+        self.assertRaisesRegex(TE, msg, setattr, exc, '__traceback__', 1)
+        msg = "exception cause must be None or derive from BaseException"
+        self.assertRaisesRegex(TE, msg, setattr, exc, '__cause__', 1)
+        msg = "exception context must be None or derive from BaseException"
+        self.assertRaisesRegex(TE, msg, setattr, exc, '__context__', 1)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_invalid_delattr(self):
+        TE = TypeError
+        try:
+            raise IndexError(4)
+        except Exception as e:
+            exc = e
+
+        msg = "may not be deleted"
+        self.assertRaisesRegex(TE, msg, delattr, exc, 'args')
+        self.assertRaisesRegex(TE, msg, delattr, exc, '__traceback__')
+        self.assertRaisesRegex(TE, msg, delattr, exc, '__cause__')
+        self.assertRaisesRegex(TE, msg, delattr, exc, '__context__')
 
     def testNoneClearsTracebackAttr(self):
         try:
             raise IndexError(4)
-        except:
-            tb = sys.exc_info()[2]
+        except Exception as e:
+            tb = e.__traceback__
 
         e = Exception()
         e.__traceback__ = tb
@@ -679,8 +743,8 @@ 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
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
     def testInfiniteRecursion(self):
         def f():
             return f()
@@ -860,28 +924,28 @@ def yield_raise():
             try:
                 raise KeyError("caught")
             except KeyError:
-                yield sys.exc_info()[0]
-                yield sys.exc_info()[0]
-            yield sys.exc_info()[0]
+                yield sys.exception()
+                yield sys.exception()
+            yield sys.exception()
         g = yield_raise()
-        self.assertEqual(next(g), KeyError)
-        self.assertEqual(sys.exc_info()[0], None)
-        self.assertEqual(next(g), KeyError)
-        self.assertEqual(sys.exc_info()[0], None)
-        self.assertEqual(next(g), None)
+        self.assertIsInstance(next(g), KeyError)
+        self.assertIsNone(sys.exception())
+        self.assertIsInstance(next(g), KeyError)
+        self.assertIsNone(sys.exception())
+        self.assertIsNone(next(g))
 
         # Same test, but inside an exception handler
         try:
             raise TypeError("foo")
         except TypeError:
             g = yield_raise()
-            self.assertEqual(next(g), KeyError)
-            self.assertEqual(sys.exc_info()[0], TypeError)
-            self.assertEqual(next(g), KeyError)
-            self.assertEqual(sys.exc_info()[0], TypeError)
-            self.assertEqual(next(g), TypeError)
+            self.assertIsInstance(next(g), KeyError)
+            self.assertIsInstance(sys.exception(), TypeError)
+            self.assertIsInstance(next(g), KeyError)
+            self.assertIsInstance(sys.exception(), TypeError)
+            self.assertIsInstance(next(g), TypeError)
             del g
-            self.assertEqual(sys.exc_info()[0], TypeError)
+            self.assertIsInstance(sys.exception(), TypeError)
 
     def test_generator_leaking2(self):
         # See issue 12475.
@@ -896,7 +960,7 @@ def g():
             next(it)
         except StopIteration:
             pass
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def test_generator_leaking3(self):
         # See issue #23353.  When gen.throw() is called, the caller's
@@ -905,17 +969,17 @@ def g():
             try:
                 yield
             except ZeroDivisionError:
-                yield sys.exc_info()[1]
+                yield sys.exception()
         it = g()
         next(it)
         try:
             1/0
         except ZeroDivisionError as e:
-            self.assertIs(sys.exc_info()[1], e)
+            self.assertIs(sys.exception(), e)
             gen_exc = it.throw(e)
-            self.assertIs(sys.exc_info()[1], e)
+            self.assertIs(sys.exception(), e)
             self.assertIs(gen_exc, e)
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def test_generator_leaking4(self):
         # See issue #23353.  When an exception is raised by a generator,
@@ -924,7 +988,7 @@ def g():
             try:
                 1/0
             except ZeroDivisionError:
-                yield sys.exc_info()[0]
+                yield sys.exception()
                 raise
         it = g()
         try:
@@ -932,7 +996,7 @@ def g():
         except TypeError:
             # The caller's exception state (TypeError) is temporarily
             # saved in the generator.
-            tp = next(it)
+            tp = type(next(it))
         self.assertIs(tp, ZeroDivisionError)
         try:
             next(it)
@@ -940,15 +1004,15 @@ def g():
             # with an exception, it shouldn't have restored the old
             # exception state (TypeError).
         except ZeroDivisionError as e:
-            self.assertIs(sys.exc_info()[1], e)
+            self.assertIs(sys.exception(), e)
         # We used to find TypeError here.
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def test_generator_doesnt_retain_old_exc(self):
         def g():
-            self.assertIsInstance(sys.exc_info()[1], RuntimeError)
+            self.assertIsInstance(sys.exception(), RuntimeError)
             yield
-            self.assertEqual(sys.exc_info(), (None, None, None))
+            self.assertIsNone(sys.exception())
         it = g()
         try:
             raise RuntimeError
@@ -956,7 +1020,7 @@ def g():
             next(it)
         self.assertRaises(StopIteration, next, it)
 
-    def test_generator_finalizing_and_exc_info(self):
+    def test_generator_finalizing_and_sys_exception(self):
         # See #7173
         def simple_gen():
             yield 1
@@ -968,7 +1032,7 @@ def run_gen():
                 return next(gen)
         run_gen()
         gc_collect()
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def _check_generator_cleanup_exc_state(self, testfunc):
         # Issue #12791: exception state is cleaned up as soon as a generator
@@ -1039,14 +1103,14 @@ def test_3114(self):
         class MyObject:
             def __del__(self):
                 nonlocal e
-                e = sys.exc_info()
+                e = sys.exception()
         e = ()
         try:
             raise Exception(MyObject())
         except:
             pass
         gc_collect()  # For PyPy or other GCs.
-        self.assertEqual(e, (None, None, None))
+        self.assertIsNone(e)
 
     def test_raise_does_not_create_context_chain_cycle(self):
         class A(Exception):
@@ -1088,9 +1152,6 @@ class C(Exception):
         self.assertIs(c.__context__, b)
         self.assertIsNone(b.__context__)
 
-
-    # TODO: RUSTPYTHON
-    @unittest.skip("Infinite loop")
     def test_no_hang_on_context_chain_cycle1(self):
         # See issue 25782. Cycle in context chain.
 
@@ -1110,7 +1171,6 @@ def cycle():
         self.assertIsInstance(exc.__context__, ValueError)
         self.assertIs(exc.__context__.__context__, exc.__context__)
 
-    @unittest.skip("See issue 44895")
     def test_no_hang_on_context_chain_cycle2(self):
         # See issue 25782. Cycle at head of context chain.
 
@@ -1147,8 +1207,6 @@ class C(Exception):
         self.assertIs(b.__context__, a)
         self.assertIs(a.__context__, c)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("Infinite loop")
     def test_no_hang_on_context_chain_cycle3(self):
         # See issue 25782. Longer context chain with cycle.
 
@@ -1246,8 +1304,7 @@ def test_context_of_exception_in_else_and_finally(self):
         self.assertIs(exc, oe)
         self.assertIs(exc.__context__, ve)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unicode_change_attributes(self):
         # See issue 7309. This was a crasher.
 
@@ -1291,8 +1348,32 @@ 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
+    def test_unicode_error_str_does_not_crash(self):
+        # Test that str(UnicodeError(...)) does not crash.
+        # See https://github.com/python/cpython/issues/123378.
+
+        for start, end, objlen in product(
+            range(-5, 5),
+            range(-5, 5),
+            range(7),
+        ):
+            obj = 'a' * objlen
+            with self.subTest('encode', objlen=objlen, start=start, end=end):
+                exc = UnicodeEncodeError('utf-8', obj, start, end, '')
+                self.assertIsInstance(str(exc), str)
+
+            with self.subTest('translate', objlen=objlen, start=start, end=end):
+                exc = UnicodeTranslateError(obj, start, end, '')
+                self.assertIsInstance(str(exc), str)
+
+            encoded = obj.encode()
+            with self.subTest('decode', objlen=objlen, start=start, end=end):
+                exc = UnicodeDecodeError('utf-8', encoded, start, end, '')
+                self.assertIsInstance(str(exc), str)
+
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     @no_tracing
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
     def test_badisinstance(self):
         # Bug #2542: if issubclass(e, MyException) raises an exception,
         # it should be ignored
@@ -1317,14 +1398,15 @@ class MyException(Exception, metaclass=Meta):
         def g():
             try:
                 return g()
-            except RecursionError:
-                return sys.exc_info()
-        e, v, tb = g()
-        self.assertIsInstance(v, RecursionError, type(v))
-        self.assertIn("maximum recursion depth exceeded", str(v))
+            except RecursionError as e:
+                return e
+        exc = g()
+        self.assertIsInstance(exc, RecursionError, type(exc))
+        self.assertIn("maximum recursion depth exceeded", str(exc))
 
 
     @cpython_only
+    @support.requires_resource('cpu')
     def test_trashcan_recursion(self):
         # See bpo-33930
 
@@ -1340,6 +1422,7 @@ def foo():
 
     @cpython_only
     def test_recursion_normalizing_exception(self):
+        import_module("_testinternalcapi")
         # Issue #22898.
         # Test that a RecursionError is raised when tstate->recursion_depth is
         # equal to recursion_limit in PyErr_NormalizeException() and check
@@ -1352,6 +1435,7 @@ def test_recursion_normalizing_exception(self):
         code = """if 1:
             import sys
             from _testinternalcapi import get_recursion_depth
+            from test import support
 
             class MyException(Exception): pass
 
@@ -1379,13 +1463,8 @@ def gen():
             generator = gen()
             next(generator)
             recursionlimit = sys.getrecursionlimit()
-            depth = get_recursion_depth()
             try:
-                # Upon the last recursive invocation of recurse(),
-                # tstate->recursion_depth is equal to (recursion_limit - 1)
-                # and is equal to recursion_limit when _gen_throw() calls
-                # PyErr_NormalizeException().
-                recurse(setrecursionlimit(depth + 2) - depth)
+                recurse(support.exceeds_recursion_limit())
             finally:
                 sys.setrecursionlimit(recursionlimit)
                 print('Done.')
@@ -1398,10 +1477,12 @@ def gen():
         self.assertIn(b'Done.', out)
 
     @cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    @force_not_colorized
     def test_recursion_normalizing_infinite_exception(self):
         # Issue #30697. Test that a RecursionError is raised when
-        # PyErr_NormalizeException() maximum recursion depth has been
-        # exceeded.
+        # maximum recursion depth has been exceeded when creating
+        # an exception
         code = """if 1:
             import _testcapi
             try:
@@ -1411,8 +1492,8 @@ def test_recursion_normalizing_infinite_exception(self):
         """
         rc, out, err = script_helper.assert_python_failure("-c", code)
         self.assertEqual(rc, 1)
-        self.assertIn(b'RecursionError: maximum recursion depth exceeded '
-                      b'while normalizing an exception', err)
+        expected = b'RecursionError: maximum recursion depth exceeded'
+        self.assertTrue(expected in err, msg=f"{expected!r} not found in {err[:3_000]!r}... (truncated)")
         self.assertIn(b'Done.', out)
 
 
@@ -1464,6 +1545,10 @@ def recurse_in_body_and_except():
 
 
     @cpython_only
+    # 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')
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_recursion_normalizing_with_no_memory(self):
         # Issue #30697. Test that in the abort that occurs when there is no
         # memory left and the size of the Python frames stack is greater than
@@ -1486,6 +1571,7 @@ def recurse(cnt):
             self.assertIn(b'MemoryError', err)
 
     @cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_MemoryError(self):
         # PyErr_NoMemory always raises the same exception instance.
         # Check that the traceback is not doubled.
@@ -1505,8 +1591,8 @@ def raiseMemError():
         self.assertEqual(tb1, tb2)
 
     @cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_exception_with_doc(self):
-        import _testcapi
         doc2 = "This is a test docstring."
         doc4 = "This is another test docstring."
 
@@ -1545,6 +1631,7 @@ class C(object):
         self.assertEqual(error5.__doc__, "")
 
     @cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_memory_error_cleanup(self):
         # Issue #5437: preallocated MemoryError instances should not keep
         # traceback objects alive.
@@ -1567,8 +1654,8 @@ def inner():
         gc_collect()  # For PyPy or other GCs.
         self.assertEqual(wr(), None)
 
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     @no_tracing
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
     def test_recursion_error_cleanup(self):
         # Same test as above, but with "recursion exceeded" errors
         class C:
@@ -1589,7 +1676,7 @@ def inner():
         gc_collect()  # For PyPy or other GCs.
         self.assertEqual(wr(), None)
 
-    @unittest.skipIf(sys.platform == 'win32', 'error specific to cpython')
+    @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:
@@ -1612,8 +1699,7 @@ def __del__(self):
             self.assertEqual(cm.unraisable.object, BrokenDel.__del__)
             self.assertIsNotNone(cm.unraisable.exc_traceback)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unhandled(self):
         # Check for sensible reporting of unhandled exceptions
         for exc_type in (ValueError, BrokenStrException):
@@ -1636,6 +1722,10 @@ def test_unhandled(self):
                 self.assertTrue(report.endswith("\n"))
 
     @cpython_only
+    # 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')
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_memory_error_in_PyErr_PrintEx(self):
         code = """if 1:
             import _testcapi
@@ -1682,7 +1772,7 @@ def g():
                 raise ValueError
             except ValueError:
                 yield 1
-            self.assertEqual(sys.exc_info(), (None, None, None))
+            self.assertIsNone(sys.exception())
             yield 2
 
         gen = g()
@@ -1708,8 +1798,7 @@ def g():
                 next(i)
                 next(i)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
     def test_assert_shadowing(self):
         # Shadowing AssertionError would cause the assert statement to
@@ -1756,280 +1845,60 @@ class TestException(MemoryError):
 
             gc_collect()
 
-global_for_suggestions = None
-
-class NameErrorTests(unittest.TestCase):
-    def test_name_error_has_name(self):
-        try:
-            bluch
-        except NameError as exc:
-            self.assertEqual("bluch", exc.name)
-
-    def test_name_error_suggestions(self):
-        def Substitution():
-            noise = more_noise = a = bc = None
-            blech = None
-            print(bluch)
-
-        def Elimination():
-            noise = more_noise = a = bc = None
-            blch = None
-            print(bluch)
-
-        def Addition():
-            noise = more_noise = a = bc = None
-            bluchin = None
-            print(bluch)
-
-        def SubstitutionOverElimination():
-            blach = None
-            bluc = None
-            print(bluch)
-
-        def SubstitutionOverAddition():
-            blach = None
-            bluchi = None
-            print(bluch)
-
-        def EliminationOverAddition():
-            blucha = None
-            bluc = None
-            print(bluch)
-
-        for func, suggestion in [(Substitution, "'blech'?"),
-                                (Elimination, "'blch'?"),
-                                (Addition, "'bluchin'?"),
-                                (EliminationOverAddition, "'blucha'?"),
-                                (SubstitutionOverElimination, "'blach'?"),
-                                (SubstitutionOverAddition, "'blach'?")]:
-            err = None
-            try:
-                func()
-            except NameError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertIn(suggestion, err.getvalue())
-
-    def test_name_error_suggestions_from_globals(self):
-        def func():
-            print(global_for_suggestio)
-        try:
-            func()
-        except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-        self.assertIn("'global_for_suggestions'?", err.getvalue())
-
-    def test_name_error_suggestions_from_builtins(self):
-        def func():
-            print(ZeroDivisionErrrrr)
-        try:
-            func()
-        except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-        self.assertIn("'ZeroDivisionError'?", err.getvalue())
-
-    def test_name_error_suggestions_do_not_trigger_for_long_names(self):
-        def f():
-            somethingverywronghehehehehehe = None
-            print(somethingverywronghe)
-
-        try:
-            f()
-        except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("somethingverywronghehe", err.getvalue())
-
-    def test_name_error_bad_suggestions_do_not_trigger_for_small_names(self):
-        vvv = mom = w = id = pytho = None
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def test_memory_error_in_subinterp(self):
+        # gh-109894: subinterpreters shouldn't count on last resort memory error
+        # when MemoryError is raised through PyErr_NoMemory() call,
+        # and should preallocate memory errors as does the main interpreter.
+        # interp.static_objects.last_resort_memory_error.args
+        # should be initialized to empty tuple to avoid crash on attempt to print it.
+        code = f"""if 1:
+            import _testcapi
+            _testcapi.run_in_subinterp(\"[0]*{sys.maxsize}\")
+            exit(0)
+        """
+        rc, _, err = script_helper.assert_python_ok("-c", code)
+        self.assertIn(b'MemoryError', err)
 
-        with self.subTest(name="b"):
-            try:
-                b
-            except NameError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="v"):
-            try:
-                v
-            except NameError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="m"):
-            try:
-                m
-            except NameError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="py"):
+    @cpython_only
+    # 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_exec_set_nomemory_hang(self):
+        import_module("_testcapi")
+        # gh-134163: A MemoryError inside code that was wrapped by a try/except
+        # block would lead to an infinite loop.
+
+        # The frame_lasti needs to be greater than 257 to prevent
+        # 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
+        user_input = warmup_code + dedent("""
             try:
-                py
-            except NameError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-    def test_name_error_suggestions_do_not_trigger_for_too_many_locals(self):
-        def f():
-            # Mutating locals() is unreliable, so we need to do it by hand
-            a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = a10 = \
-            a11 = a12 = a13 = a14 = a15 = a16 = a17 = a18 = a19 = a20 = \
-            a21 = a22 = a23 = a24 = a25 = a26 = a27 = a28 = a29 = a30 = \
-            a31 = a32 = a33 = a34 = a35 = a36 = a37 = a38 = a39 = a40 = \
-            a41 = a42 = a43 = a44 = a45 = a46 = a47 = a48 = a49 = a50 = \
-            a51 = a52 = a53 = a54 = a55 = a56 = a57 = a58 = a59 = a60 = \
-            a61 = a62 = a63 = a64 = a65 = a66 = a67 = a68 = a69 = a70 = \
-            a71 = a72 = a73 = a74 = a75 = a76 = a77 = a78 = a79 = a80 = \
-            a81 = a82 = a83 = a84 = a85 = a86 = a87 = a88 = a89 = a90 = \
-            a91 = a92 = a93 = a94 = a95 = a96 = a97 = a98 = a99 = a100 = \
-            a101 = a102 = a103 = a104 = a105 = a106 = a107 = a108 = a109 = a110 = \
-            a111 = a112 = a113 = a114 = a115 = a116 = a117 = a118 = a119 = a120 = \
-            a121 = a122 = a123 = a124 = a125 = a126 = a127 = a128 = a129 = a130 = \
-            a131 = a132 = a133 = a134 = a135 = a136 = a137 = a138 = a139 = a140 = \
-            a141 = a142 = a143 = a144 = a145 = a146 = a147 = a148 = a149 = a150 = \
-            a151 = a152 = a153 = a154 = a155 = a156 = a157 = a158 = a159 = a160 = \
-            a161 = a162 = a163 = a164 = a165 = a166 = a167 = a168 = a169 = a170 = \
-            a171 = a172 = a173 = a174 = a175 = a176 = a177 = a178 = a179 = a180 = \
-            a181 = a182 = a183 = a184 = a185 = a186 = a187 = a188 = a189 = a190 = \
-            a191 = a192 = a193 = a194 = a195 = a196 = a197 = a198 = a199 = a200 = \
-            a201 = a202 = a203 = a204 = a205 = a206 = a207 = a208 = a209 = a210 = \
-            a211 = a212 = a213 = a214 = a215 = a216 = a217 = a218 = a219 = a220 = \
-            a221 = a222 = a223 = a224 = a225 = a226 = a227 = a228 = a229 = a230 = \
-            a231 = a232 = a233 = a234 = a235 = a236 = a237 = a238 = a239 = a240 = \
-            a241 = a242 = a243 = a244 = a245 = a246 = a247 = a248 = a249 = a250 = \
-            a251 = a252 = a253 = a254 = a255 = a256 = a257 = a258 = a259 = a260 = \
-            a261 = a262 = a263 = a264 = a265 = a266 = a267 = a268 = a269 = a270 = \
-            a271 = a272 = a273 = a274 = a275 = a276 = a277 = a278 = a279 = a280 = \
-            a281 = a282 = a283 = a284 = a285 = a286 = a287 = a288 = a289 = a290 = \
-            a291 = a292 = a293 = a294 = a295 = a296 = a297 = a298 = a299 = a300 = \
-            a301 = a302 = a303 = a304 = a305 = a306 = a307 = a308 = a309 = a310 = \
-            a311 = a312 = a313 = a314 = a315 = a316 = a317 = a318 = a319 = a320 = \
-            a321 = a322 = a323 = a324 = a325 = a326 = a327 = a328 = a329 = a330 = \
-            a331 = a332 = a333 = a334 = a335 = a336 = a337 = a338 = a339 = a340 = \
-            a341 = a342 = a343 = a344 = a345 = a346 = a347 = a348 = a349 = a350 = \
-            a351 = a352 = a353 = a354 = a355 = a356 = a357 = a358 = a359 = a360 = \
-            a361 = a362 = a363 = a364 = a365 = a366 = a367 = a368 = a369 = a370 = \
-            a371 = a372 = a373 = a374 = a375 = a376 = a377 = a378 = a379 = a380 = \
-            a381 = a382 = a383 = a384 = a385 = a386 = a387 = a388 = a389 = a390 = \
-            a391 = a392 = a393 = a394 = a395 = a396 = a397 = a398 = a399 = a400 = \
-            a401 = a402 = a403 = a404 = a405 = a406 = a407 = a408 = a409 = a410 = \
-            a411 = a412 = a413 = a414 = a415 = a416 = a417 = a418 = a419 = a420 = \
-            a421 = a422 = a423 = a424 = a425 = a426 = a427 = a428 = a429 = a430 = \
-            a431 = a432 = a433 = a434 = a435 = a436 = a437 = a438 = a439 = a440 = \
-            a441 = a442 = a443 = a444 = a445 = a446 = a447 = a448 = a449 = a450 = \
-            a451 = a452 = a453 = a454 = a455 = a456 = a457 = a458 = a459 = a460 = \
-            a461 = a462 = a463 = a464 = a465 = a466 = a467 = a468 = a469 = a470 = \
-            a471 = a472 = a473 = a474 = a475 = a476 = a477 = a478 = a479 = a480 = \
-            a481 = a482 = a483 = a484 = a485 = a486 = a487 = a488 = a489 = a490 = \
-            a491 = a492 = a493 = a494 = a495 = a496 = a497 = a498 = a499 = a500 = \
-            a501 = a502 = a503 = a504 = a505 = a506 = a507 = a508 = a509 = a510 = \
-            a511 = a512 = a513 = a514 = a515 = a516 = a517 = a518 = a519 = a520 = \
-            a521 = a522 = a523 = a524 = a525 = a526 = a527 = a528 = a529 = a530 = \
-            a531 = a532 = a533 = a534 = a535 = a536 = a537 = a538 = a539 = a540 = \
-            a541 = a542 = a543 = a544 = a545 = a546 = a547 = a548 = a549 = a550 = \
-            a551 = a552 = a553 = a554 = a555 = a556 = a557 = a558 = a559 = a560 = \
-            a561 = a562 = a563 = a564 = a565 = a566 = a567 = a568 = a569 = a570 = \
-            a571 = a572 = a573 = a574 = a575 = a576 = a577 = a578 = a579 = a580 = \
-            a581 = a582 = a583 = a584 = a585 = a586 = a587 = a588 = a589 = a590 = \
-            a591 = a592 = a593 = a594 = a595 = a596 = a597 = a598 = a599 = a600 = \
-            a601 = a602 = a603 = a604 = a605 = a606 = a607 = a608 = a609 = a610 = \
-            a611 = a612 = a613 = a614 = a615 = a616 = a617 = a618 = a619 = a620 = \
-            a621 = a622 = a623 = a624 = a625 = a626 = a627 = a628 = a629 = a630 = \
-            a631 = a632 = a633 = a634 = a635 = a636 = a637 = a638 = a639 = a640 = \
-            a641 = a642 = a643 = a644 = a645 = a646 = a647 = a648 = a649 = a650 = \
-            a651 = a652 = a653 = a654 = a655 = a656 = a657 = a658 = a659 = a660 = \
-            a661 = a662 = a663 = a664 = a665 = a666 = a667 = a668 = a669 = a670 = \
-            a671 = a672 = a673 = a674 = a675 = a676 = a677 = a678 = a679 = a680 = \
-            a681 = a682 = a683 = a684 = a685 = a686 = a687 = a688 = a689 = a690 = \
-            a691 = a692 = a693 = a694 = a695 = a696 = a697 = a698 = a699 = a700 = \
-            a701 = a702 = a703 = a704 = a705 = a706 = a707 = a708 = a709 = a710 = \
-            a711 = a712 = a713 = a714 = a715 = a716 = a717 = a718 = a719 = a720 = \
-            a721 = a722 = a723 = a724 = a725 = a726 = a727 = a728 = a729 = a730 = \
-            a731 = a732 = a733 = a734 = a735 = a736 = a737 = a738 = a739 = a740 = \
-            a741 = a742 = a743 = a744 = a745 = a746 = a747 = a748 = a749 = a750 = \
-            a751 = a752 = a753 = a754 = a755 = a756 = a757 = a758 = a759 = a760 = \
-            a761 = a762 = a763 = a764 = a765 = a766 = a767 = a768 = a769 = a770 = \
-            a771 = a772 = a773 = a774 = a775 = a776 = a777 = a778 = a779 = a780 = \
-            a781 = a782 = a783 = a784 = a785 = a786 = a787 = a788 = a789 = a790 = \
-            a791 = a792 = a793 = a794 = a795 = a796 = a797 = a798 = a799 = a800 \
-                = None
-            print(a0)
-
-        try:
-            f()
-        except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotRegex(err.getvalue(), r"NameError.*a1")
-
-    def test_name_error_with_custom_exceptions(self):
-        def f():
-            blech = None
-            raise NameError()
-
-        try:
-            f()
-        except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
+                import _testcapi
+                _testcapi.set_nomemory(0)
+                b = list(range(1000, 2000))
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+            """)
+        with SuppressCrashReport():
+            with script_helper.spawn_python('-c', user_input) as p:
+                p.wait()
+                output = p.stdout.read()
 
-        self.assertNotIn("blech", err.getvalue())
+        self.assertIn(p.returncode, (0, 1))
+        self.assertGreater(len(output), 0)  # At minimum, should not hang
+        self.assertIn(b"MemoryError", output)
 
-        def f():
-            blech = None
-            raise NameError
 
+class NameErrorTests(unittest.TestCase):
+    def test_name_error_has_name(self):
         try:
-            f()
+            bluch
         except NameError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("blech", err.getvalue())
-
-    def test_unbound_local_error_doesn_not_match(self):
-        def foo():
-            something = 3
-            print(somethong)
-            somethong = 3
-
-        try:
-            foo()
-        except UnboundLocalError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("something", err.getvalue())
+            self.assertEqual("bluch", exc.name)
 
     def test_issue45826(self):
         # regression test for bpo-45826
@@ -2042,6 +1911,8 @@ def f():
         except self.failureException:
             with support.captured_stderr() as err:
                 sys.__excepthook__(*sys.exc_info())
+        else:
+            self.fail("assertRaisesRegex should have failed.")
 
         self.assertIn("aab", err.getvalue())
 
@@ -2062,6 +1933,15 @@ def f():
         self.assertIn("nonsense", err.getvalue())
         self.assertIn("ZeroDivisionError", err.getvalue())
 
+    def test_gh_111654(self):
+        def f():
+            class TestClass:
+                TestClass
+
+        self.assertRaises(NameError, f)
+
+    # Note: name suggestion tests live in `test_traceback`.
+
 
 class AttributeErrorTests(unittest.TestCase):
     def test_attributes(self):
@@ -2103,244 +1983,12 @@ def blech(self):
             self.assertEqual("bluch", exc.name)
             self.assertEqual(obj, exc.obj)
 
-    def test_getattr_suggestions(self):
-        class Substitution:
-            noise = more_noise = a = bc = None
-            blech = None
-
-        class Elimination:
-            noise = more_noise = a = bc = None
-            blch = None
-
-        class Addition:
-            noise = more_noise = a = bc = None
-            bluchin = None
-
-        class SubstitutionOverElimination:
-            blach = None
-            bluc = None
-
-        class SubstitutionOverAddition:
-            blach = None
-            bluchi = None
-
-        class EliminationOverAddition:
-            blucha = None
-            bluc = None
-
-        for cls, suggestion in [(Substitution, "'blech'?"),
-                                (Elimination, "'blch'?"),
-                                (Addition, "'bluchin'?"),
-                                (EliminationOverAddition, "'bluc'?"),
-                                (SubstitutionOverElimination, "'blach'?"),
-                                (SubstitutionOverAddition, "'blach'?")]:
-            try:
-                cls().bluch
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-
-            self.assertIn(suggestion, err.getvalue())
-
-    def test_getattr_suggestions_do_not_trigger_for_long_attributes(self):
-        class A:
-            blech = None
-
-        try:
-            A().somethingverywrong
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("blech", err.getvalue())
-
-    def test_getattr_error_bad_suggestions_do_not_trigger_for_small_names(self):
-        class MyClass:
-            vvv = mom = w = id = pytho = None
-
-        with self.subTest(name="b"):
-            try:
-                MyClass.b
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="v"):
-            try:
-                MyClass.v
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="m"):
-            try:
-                MyClass.m
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-        with self.subTest(name="py"):
-            try:
-                MyClass.py
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-            self.assertNotIn("you mean", err.getvalue())
-            self.assertNotIn("vvv", err.getvalue())
-            self.assertNotIn("mom", err.getvalue())
-            self.assertNotIn("'id'", err.getvalue())
-            self.assertNotIn("'w'", err.getvalue())
-            self.assertNotIn("'pytho'", err.getvalue())
-
-
-    def test_getattr_suggestions_do_not_trigger_for_big_dicts(self):
-        class A:
-            blech = None
-        # A class with a very big __dict__ will not be consider
-        # for suggestions.
-        for index in range(2000):
-            setattr(A, f"index_{index}", None)
-
-        try:
-            A().bluch
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("blech", err.getvalue())
-
-    def test_getattr_suggestions_no_args(self):
-        class A:
-            blech = None
-            def __getattr__(self, attr):
-                raise AttributeError()
-
-        try:
-            A().bluch
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertIn("blech", err.getvalue())
-
-        class A:
-            blech = None
-            def __getattr__(self, attr):
-                raise AttributeError
-
-        try:
-            A().bluch
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertIn("blech", err.getvalue())
-
-    def test_getattr_suggestions_invalid_args(self):
-        class NonStringifyClass:
-            __str__ = None
-            __repr__ = None
-
-        class A:
-            blech = None
-            def __getattr__(self, attr):
-                raise AttributeError(NonStringifyClass())
-
-        class B:
-            blech = None
-            def __getattr__(self, attr):
-                raise AttributeError("Error", 23)
-
-        class C:
-            blech = None
-            def __getattr__(self, attr):
-                raise AttributeError(23)
-
-        for cls in [A, B, C]:
-            try:
-                cls().bluch
-            except AttributeError as exc:
-                with support.captured_stderr() as err:
-                    sys.__excepthook__(*sys.exc_info())
-
-            self.assertIn("blech", err.getvalue())
-
-    def test_getattr_suggestions_for_same_name(self):
-        class A:
-            def __dir__(self):
-                return ['blech']
-        try:
-            A().blech
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("Did you mean", err.getvalue())
-
-    def test_attribute_error_with_failing_dict(self):
-        class T:
-            bluch = 1
-            def __dir__(self):
-                raise AttributeError("oh no!")
-
-        try:
-            T().blich
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("blech", err.getvalue())
-        self.assertNotIn("oh no!", err.getvalue())
-
-    def test_attribute_error_with_bad_name(self):
-        try:
-            raise AttributeError(name=12, obj=23)
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertNotIn("?", err.getvalue())
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_attribute_error_inside_nested_getattr(self):
-        class A:
-            bluch = 1
-
-        class B:
-            def __getattribute__(self, attr):
-                a = A()
-                return a.blich
-
-        try:
-            B().something
-        except AttributeError as exc:
-            with support.captured_stderr() as err:
-                sys.__excepthook__(*sys.exc_info())
-
-        self.assertIn("Did you mean", err.getvalue())
-        self.assertIn("bluch", err.getvalue())
+    # Note: name suggestion tests live in `test_traceback`.
 
 
 class ImportErrorTests(unittest.TestCase):
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_attributes(self):
         # Setting 'name' and 'path' should not be a problem.
         exc = ImportError('test')
@@ -2359,7 +2007,7 @@ def test_attributes(self):
         self.assertEqual(exc.name, 'somename')
         self.assertEqual(exc.path, 'somepath')
 
-        msg = "'invalid' is an invalid keyword argument for ImportError"
+        msg = r"ImportError\(\) got an unexpected keyword argument 'invalid'"
         with self.assertRaisesRegex(TypeError, msg):
             ImportError('test', invalid='keyword')
 
@@ -2415,9 +2063,159 @@ def test_copy_pickle(self):
                 self.assertEqual(exc.name, orig.name)
                 self.assertEqual(exc.path, orig.path)
 
+
+def run_script(source):
+    if isinstance(source, str):
+        with open(TESTFN, 'w', encoding='utf-8') as testfile:
+            testfile.write(dedent(source))
+    else:
+        with open(TESTFN, 'wb') as testfile:
+            testfile.write(source)
+    _rc, _out, err = script_helper.assert_python_failure('-Wd', '-X', 'utf8', TESTFN)
+    return err.decode('utf-8').splitlines()
+
+class AssertionErrorTests(unittest.TestCase):
+    def tearDown(self):
+        unlink(TESTFN)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
+    def test_assertion_error_location(self):
+        cases = [
+            ('assert None',
+                [
+                    '    assert None',
+                    '           ^^^^',
+                    'AssertionError',
+                ],
+            ),
+            ('assert 0',
+                [
+                    '    assert 0',
+                    '           ^',
+                    'AssertionError',
+                ],
+            ),
+            ('assert 1 > 2',
+                [
+                    '    assert 1 > 2',
+                    '           ^^^^^',
+                    'AssertionError',
+                ],
+            ),
+            ('assert 1 > 2 and 3 > 2',
+                [
+                    '    assert 1 > 2 and 3 > 2',
+                    '           ^^^^^^^^^^^^^^^',
+                    'AssertionError',
+                ],
+            ),
+            ('assert 1 > 2, "messäge"',
+                [
+                    '    assert 1 > 2, "messäge"',
+                    '           ^^^^^',
+                    'AssertionError: messäge',
+                ],
+            ),
+            ('assert 1 > 2, "messäge"'.encode(),
+                [
+                    '    assert 1 > 2, "messäge"',
+                    '           ^^^^^',
+                    'AssertionError: messäge',
+                ],
+            ),
+            ('# coding: latin1\nassert 1 > 2, "messäge"'.encode('latin1'),
+                [
+                    '    assert 1 > 2, "messäge"',
+                    '           ^^^^^',
+                    'AssertionError: messäge',
+                ],
+            ),
+            (BOM_UTF8 + 'assert 1 > 2, "messäge"'.encode(),
+                [
+                    '    assert 1 > 2, "messäge"',
+                    '           ^^^^^',
+                    'AssertionError: messäge',
+                ],
+            ),
+
+            # Multiline:
+            ("""
+             assert (
+                 1 > 2)
+             """,
+                [
+                    '    1 > 2)',
+                    '    ^^^^^',
+                    'AssertionError',
+                ],
+            ),
+            ("""
+             assert (
+                 1 > 2), "Message"
+             """,
+                [
+                    '    1 > 2), "Message"',
+                    '    ^^^^^',
+                    'AssertionError: Message',
+                ],
+            ),
+            ("""
+             assert (
+                 1 > 2), \\
+                 "Message"
+             """,
+                [
+                    '    1 > 2), \\',
+                    '    ^^^^^',
+                    'AssertionError: Message',
+                ],
+            ),
+        ]
+        for source, expected in cases:
+            with self.subTest(source=source):
+                result = run_script(source)
+                self.assertEqual(result[-3:], expected)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
+    def test_multiline_not_highlighted(self):
+        cases = [
+            ("""
+             assert (
+                 1 > 2
+             )
+             """,
+                [
+                    '    1 > 2',
+                    'AssertionError',
+                ],
+            ),
+            ("""
+             assert (
+                 1 < 2 and
+                 3 > 4
+             )
+             """,
+                [
+                    '    1 < 2 and',
+                    '    3 > 4',
+                    'AssertionError',
+                ],
+            ),
+        ]
+        for source, expected in cases:
+            with self.subTest(source=source):
+                result = run_script(source)
+                self.assertEqual(result[-len(expected):], expected)
+
+
+@support.force_not_colorized_test_class
 class SyntaxErrorTests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    maxDiff = None
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
     def test_range_of_offsets(self):
         cases = [
             # Basic range from 2->7
@@ -2508,50 +2306,126 @@ def test_range_of_offsets(self):
                     self.assertIn(expected, err.getvalue())
                     the_exception = exc
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_subclass(self):
+        class MySyntaxError(SyntaxError):
+            pass
+
+        try:
+            raise MySyntaxError("bad bad", ("bad.py", 1, 2, "abcdefg", 1, 7))
+        except SyntaxError as exc:
+            with support.captured_stderr() as err:
+                sys.__excepthook__(*sys.exc_info())
+            self.assertIn("""
+  File "bad.py", line 1
+    abcdefg
+     ^^^^^
+""", err.getvalue())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encodings(self):
+        self.addCleanup(unlink, TESTFN)
         source = (
             '# -*- coding: cp437 -*-\n'
             '"¢¢¢¢¢¢" + f(4, x for x in range(1))\n'
         )
-        try:
-            with open(TESTFN, 'w', encoding='cp437') as testfile:
-                testfile.write(source)
-            rc, out, err = script_helper.assert_python_failure('-Wd', '-X', 'utf8', TESTFN)
-            err = err.decode('utf-8').splitlines()
-
-            self.assertEqual(err[-3], '    "¢¢¢¢¢¢" + f(4, x for x in range(1))')
-            self.assertEqual(err[-2], '                          ^^^^^^^^^^^^^^^^^^^')
-        finally:
-            unlink(TESTFN)
+        err = run_script(source.encode('cp437'))
+        self.assertEqual(err[-3], '    "¢¢¢¢¢¢" + f(4, x for x in range(1))')
+        self.assertEqual(err[-2], '                          ^^^^^^^^^^^^^^^^^^^')
 
         # Check backwards tokenizer errors
         source = '# -*- coding: ascii -*-\n\n(\n'
-        try:
-            with open(TESTFN, 'w', encoding='ascii') as testfile:
-                testfile.write(source)
-            rc, out, err = script_helper.assert_python_failure('-Wd', '-X', 'utf8', TESTFN)
-            err = err.decode('utf-8').splitlines()
+        err = run_script(source)
+        self.assertEqual(err[-3], '    (')
+        self.assertEqual(err[-2], '    ^')
 
-            self.assertEqual(err[-3], '    (')
-            self.assertEqual(err[-2], '    ^')
-        finally:
-            unlink(TESTFN)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_utf8(self):
         # Check non utf-8 characters
-        try:
-            with open(TESTFN, 'bw') as testfile:
-                testfile.write(b"\x89")
-            rc, out, err = script_helper.assert_python_failure('-Wd', '-X', 'utf8', TESTFN)
-            err = err.decode('utf-8').splitlines()
+        self.addCleanup(unlink, TESTFN)
+        err = run_script(b"\x89")
+        self.assertIn("SyntaxError: Non-UTF-8 code starting with '\\x89' in file", err[-1])
 
-            self.assertIn("SyntaxError: Non-UTF-8 code starting with '\\x89' in file", err[-1])
-        finally:
-            unlink(TESTFN)
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_string_source(self):
+        def try_compile(source):
+            with self.assertRaises(SyntaxError) as cm:
+                compile(source, '<string>', 'exec')
+            return cm.exception
+
+        exc = try_compile('return "ä"')
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 1)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+        exc = try_compile('return "ä"'.encode())
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 1)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+        exc = try_compile(BOM_UTF8 + 'return "ä"'.encode())
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 1)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+        exc = try_compile('# coding: latin1\nreturn "ä"'.encode('latin1'))
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 2)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+        exc = try_compile('return "ä" #' + 'ä'*1000)
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 1)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+        exc = try_compile('return "ä" # ' + 'ä'*1000)
+        self.assertEqual(str(exc), "'return' outside function (<string>, line 1)")
+        self.assertIsNone(exc.text)
+        self.assertEqual(exc.offset, 1)
+        self.assertEqual(exc.end_offset, 12)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_file_source(self):
+        self.addCleanup(unlink, TESTFN)
+        err = run_script('return "ä"')
+        self.assertEqual(err[-3:], [
+                         '    return "ä"',
+                         '    ^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+
+        err = run_script('return "ä"'.encode())
+        self.assertEqual(err[-3:], [
+                         '    return "ä"',
+                         '    ^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+
+        err = run_script(BOM_UTF8 + 'return "ä"'.encode())
+        self.assertEqual(err[-3:], [
+                         '    return "ä"',
+                         '    ^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+
+        err = run_script('# coding: latin1\nreturn "ä"'.encode('latin1'))
+        self.assertEqual(err[-3:], [
+                         '    return "ä"',
+                         '    ^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+
+        err = run_script('return "ä" #' + 'ä'*1000)
+        self.assertEqual(err[-2:], [
+                         '    ^^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+        self.assertEqual(err[-3][:100], '    return "ä" #' + 'ä'*84)
+
+        err = run_script('return "ä" # ' + 'ä'*1000)
+        self.assertEqual(err[-2:], [
+                         '    ^^^^^^^^^^^',
+                         "SyntaxError: 'return' outside function"])
+        self.assertEqual(err[-3][:100], '    return "ä" # ' + 'ä'*83)
 
     def test_attributes_new_constructor(self):
         args = ("bad.py", 1, 2, "abcdefg", 1, 100)
@@ -2577,8 +2451,7 @@ def test_attributes_old_constructor(self):
         self.assertEqual(error, the_exception.text)
         self.assertEqual("bad bad", the_exception.msg)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_incorrect_constructor(self):
         args = ("bad.py", 1, 2)
         self.assertRaises(TypeError, SyntaxError, "bad bad", args)
@@ -2640,8 +2513,7 @@ def in_except():
                 pass
         self.lineno_after_raise(in_except, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lineno_after_other_except(self):
         def other_except():
             try:
@@ -2659,8 +2531,7 @@ def in_named_except():
                 pass
         self.lineno_after_raise(in_named_except, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lineno_in_try(self):
         def in_try():
             try:
@@ -2687,8 +2558,6 @@ def in_finally_except():
                 pass
         self.lineno_after_raise(in_finally_except, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_lineno_after_with(self):
         class Noop:
             def __enter__(self):
@@ -2701,8 +2570,7 @@ def after_with():
                 pass
         self.lineno_after_raise(after_with, 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_missing_lineno_shows_as_none(self):
         def f():
             1/0
diff --git a/Lib/test/test_faulthandler.py b/Lib/test/test_faulthandler.py
index c9838cb714..5596e5b166 100644
--- a/Lib/test/test_faulthandler.py
+++ b/Lib/test/test_faulthandler.py
@@ -7,9 +7,7 @@
 import subprocess
 import sys
 from test import support
-from test.support import os_helper
-from test.support import script_helper, is_android
-from test.support import skip_if_sanitizer
+from test.support import os_helper, script_helper, is_android, MS_WINDOWS, threading_helper
 import tempfile
 import unittest
 from textwrap import dedent
@@ -23,7 +21,6 @@
     raise unittest.SkipTest("test module requires subprocess")
 
 TIMEOUT = 0.5
-MS_WINDOWS = (os.name == 'nt')
 
 
 def expected_traceback(lineno1, lineno2, header, min_count=1):
@@ -36,7 +33,7 @@ def expected_traceback(lineno1, lineno2, header, min_count=1):
         return '^' + regex + '$'
 
 def skip_segfault_on_android(test):
-    # Issue #32138: Raising SIGSEGV on Android may not cause a crash.
+    # gh-76319: Raising SIGSEGV on Android may not cause a crash.
     return unittest.skipIf(is_android,
                            'raising SIGSEGV on Android is unreliable')(test)
 
@@ -64,8 +61,16 @@ def get_output(self, code, filename=None, fd=None):
         pass_fds = []
         if fd is not None:
             pass_fds.append(fd)
+        env = dict(os.environ)
+
+        # Sanitizers must not handle SIGSEGV (ex: for test_enable_fd())
+        option = 'handle_segv=0'
+        support.set_sanitizer_env_var(env, option)
+
         with support.SuppressCrashReport():
-            process = script_helper.spawn_python('-c', code, pass_fds=pass_fds)
+            process = script_helper.spawn_python('-c', code,
+                                                 pass_fds=pass_fds,
+                                                 env=env)
             with process:
                 output, stderr = process.communicate()
                 exitcode = process.wait()
@@ -243,7 +248,7 @@ def test_sigfpe(self):
             faulthandler._sigfpe()
             """,
             3,
-            'Floating point exception')
+            'Floating-point exception')
 
     @unittest.skipIf(_testcapi is None, 'need _testcapi')
     @unittest.skipUnless(hasattr(signal, 'SIGBUS'), 'need signal.SIGBUS')
@@ -273,6 +278,7 @@ def test_sigill(self):
             5,
             'Illegal instruction')
 
+    @unittest.skipIf(_testcapi is None, 'need _testcapi')
     def check_fatal_error_func(self, release_gil):
         # Test that Py_FatalError() dumps a traceback
         with support.SuppressCrashReport():
@@ -282,7 +288,7 @@ def check_fatal_error_func(self, release_gil):
                 """,
                 2,
                 'xyz',
-                func='test_fatal_error',
+                func='_testcapi_fatal_error_impl',
                 py_fatal_error=True)
 
     # TODO: RUSTPYTHON
@@ -324,8 +330,6 @@ def test_gil_released(self):
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    @skip_if_sanitizer(memory=True, ub=True, reason="sanitizer "
-                       "builds change crashing process output.")
     @skip_segfault_on_android
     def test_enable_file(self):
         with temporary_filename() as filename:
@@ -343,8 +347,6 @@ def test_enable_file(self):
     @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32",
                      "subprocess doesn't support pass_fds on Windows")
-    @skip_if_sanitizer(memory=True, ub=True, reason="sanitizer "
-                       "builds change crashing process output.")
     @skip_segfault_on_android
     def test_enable_fd(self):
         with tempfile.TemporaryFile('wb+') as fp:
@@ -372,7 +374,6 @@ def test_enable_single_thread(self):
             'Segmentation fault',
             all_threads=False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AttributeError: module 'msvcrt' has no attribute 'GetErrorMode'")
     @skip_segfault_on_android
     def test_disable(self):
         code = """
@@ -410,8 +411,6 @@ def test_dump_ext_modules(self):
         for name in ('sys', 'faulthandler'):
             self.assertIn(name, modules)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'faulthandler' has no attribute 'is_enabled'
-    @unittest.expectedFailure
     def test_is_enabled(self):
         orig_stderr = sys.stderr
         try:
@@ -434,8 +433,6 @@ def test_is_enabled(self):
         finally:
             sys.stderr = orig_stderr
 
-    # TODO: RUSTPYTHON, subprocess.CalledProcessError: Command ... returned non-zero exit status 1.
-    @unittest.expectedFailure
     @support.requires_subprocess()
     def test_disabled_by_default(self):
         # By default, the module should be disabled
@@ -445,8 +442,6 @@ def test_disabled_by_default(self):
         output = subprocess.check_output(args)
         self.assertEqual(output.rstrip(), b"False")
 
-    # TODO: RUSTPYTHON, subprocess.CalledProcessError: Command '<filter object at ...>' returned non-zero exit status 1.
-    @unittest.expectedFailure
     @support.requires_subprocess()
     def test_sys_xoptions(self):
         # Test python -X faulthandler
@@ -460,8 +455,6 @@ def test_sys_xoptions(self):
         output = subprocess.check_output(args, env=env)
         self.assertEqual(output.rstrip(), b"True")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @support.requires_subprocess()
     def test_env_var(self):
         # empty env var
@@ -527,12 +520,10 @@ def funcA():
         self.assertEqual(trace, expected)
         self.assertEqual(exitcode, 0)
 
-    # TODO: RUSTPYTHON, AssertionError: Lists differ
-    @unittest.expectedFailure
     def test_dump_traceback(self):
         self.check_dump_traceback()
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - binary file write needs different handling
     @unittest.expectedFailure
     def test_dump_traceback_file(self):
         with temporary_filename() as filename:
@@ -546,8 +537,6 @@ def test_dump_traceback_fd(self):
         with tempfile.TemporaryFile('wb+') as fp:
             self.check_dump_traceback(fd=fp.fileno())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_truncate(self):
         maxlen = 500
         func_name = 'x' * (maxlen + 50)
@@ -616,10 +605,12 @@ def run(self):
             lineno = 8
         else:
             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\):
             (?:  File ".*threading.py", line [0-9]+ in [_a-z]+
-            ){{1,3}}  File "<string>", line 23 in run
+            ){{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
 
@@ -735,6 +726,7 @@ def test_dump_traceback_later_fd(self):
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_dump_traceback_later_twice(self):
         self.check_dump_traceback_later(loops=2)
 
@@ -866,8 +858,6 @@ def check_stderr_none(self):
         finally:
             sys.stderr = stderr
 
-    # TODO: RUSTPYTHON, AssertionError: RuntimeError not raised
-    @unittest.expectedFailure
     def test_stderr_None(self):
         # Issue #21497: provide a helpful error if sys.stderr is None,
         # instead of just an attribute error: "None has no attribute fileno".
@@ -898,8 +888,6 @@ def test_raise_exception(self):
                 3,
                 name)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'msvcrt' has no attribute 'GetErrorMode'
-    @unittest.expectedFailure
     @unittest.skipUnless(MS_WINDOWS, 'specific to Windows')
     def test_ignore_exception(self):
         for exc_code in (
@@ -916,8 +904,6 @@ def test_ignore_exception(self):
             self.assertEqual(output, [])
             self.assertEqual(exitcode, exc_code)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'msvcrt' has no attribute 'GetErrorMode'
-    @unittest.expectedFailure
     @unittest.skipUnless(MS_WINDOWS, 'specific to Windows')
     def test_raise_nonfatal_exception(self):
         # These exceptions are not strictly errors. Letting
@@ -946,8 +932,6 @@ def test_raise_nonfatal_exception(self):
             self.assertIn(exitcode,
                           (exc, exc & ~0x10000000))
 
-    # TODO: RUSTPYTHON, AttributeError: module 'msvcrt' has no attribute 'GetErrorMode'
-    @unittest.expectedFailure
     @unittest.skipUnless(MS_WINDOWS, 'specific to Windows')
     def test_disable_windows_exc_handler(self):
         code = dedent("""
@@ -961,8 +945,6 @@ def test_disable_windows_exc_handler(self):
         self.assertEqual(output, [])
         self.assertEqual(exitcode, 0xC0000005)
 
-    # TODO: RUSTPYTHON, AssertionError: Lists differ
-    @unittest.expectedFailure
     def test_cancel_later_without_dump_traceback_later(self):
         # bpo-37933: Calling cancel_dump_traceback_later()
         # without dump_traceback_later() must not segfault.
@@ -974,6 +956,34 @@ def test_cancel_later_without_dump_traceback_later(self):
         self.assertEqual(output, [])
         self.assertEqual(exitcode, 0)
 
+    @threading_helper.requires_working_threading()
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful if the GIL is disabled")
+    def test_free_threaded_dump_traceback(self):
+        # gh-128400: Other threads need to be paused to invoke faulthandler
+        code = dedent("""
+        import faulthandler
+        from threading import Thread, Event
+
+        class Waiter(Thread):
+            def __init__(self):
+                Thread.__init__(self)
+                self.running = Event()
+                self.stop = Event()
+
+            def run(self):
+                self.running.set()
+                self.stop.wait()
+
+        for _ in range(100):
+            waiter = Waiter()
+            waiter.start()
+            waiter.running.wait()
+            faulthandler.dump_traceback(all_threads=True)
+            waiter.stop.set()
+            waiter.join()
+        """)
+        _, exitcode = self.get_output(code)
+        self.assertEqual(exitcode, 0)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index d998af936a..36aea52a5a 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -344,10 +344,6 @@ def testIteration(self):
 class COtherFileTests(OtherFileTests, unittest.TestCase):
     open = io.open
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def testSetBufferSize(self):
-        super().testSetBufferSize()
 
 class PyOtherFileTests(OtherFileTests, unittest.TestCase):
     open = staticmethod(pyio.open)
diff --git a/Lib/test/test_file_eintr.py b/Lib/test/test_file_eintr.py
new file mode 100644
index 0000000000..fa9c6637fd
--- /dev/null
+++ b/Lib/test/test_file_eintr.py
@@ -0,0 +1,260 @@
+# Written to test interrupted system calls interfering with our many buffered
+# IO implementations.  http://bugs.python.org/issue12268
+#
+# It was suggested that this code could be merged into test_io and the tests
+# made to work using the same method as the existing signal tests in test_io.
+# I was unable to get single process tests using alarm or setitimer that way
+# to reproduce the EINTR problems.  This process based test suite reproduces
+# the problems prior to the issue12268 patch reliably on Linux and OSX.
+#  - gregory.p.smith
+
+import os
+import select
+import signal
+import subprocess
+import sys
+import time
+import unittest
+from test import support
+
+if not support.has_subprocess_support:
+    raise unittest.SkipTest("test module requires subprocess")
+
+# Test import all of the things we're about to try testing up front.
+import _io
+import _pyio
+
+@unittest.skipUnless(os.name == 'posix', 'tests requires a posix system.')
+class TestFileIOSignalInterrupt:
+    def setUp(self):
+        self._process = None
+
+    def tearDown(self):
+        if self._process and self._process.poll() is None:
+            try:
+                self._process.kill()
+            except OSError:
+                pass
+
+    def _generate_infile_setup_code(self):
+        """Returns the infile = ... line of code for the reader process.
+
+        subclasseses should override this to test different IO objects.
+        """
+        return ('import %s as io ;'
+                'infile = io.FileIO(sys.stdin.fileno(), "rb")' %
+                self.modname)
+
+    def fail_with_process_info(self, why, stdout=b'', stderr=b'',
+                               communicate=True):
+        """A common way to cleanup and fail with useful debug output.
+
+        Kills the process if it is still running, collects remaining output
+        and fails the test with an error message including the output.
+
+        Args:
+            why: Text to go after "Error from IO process" in the message.
+            stdout, stderr: standard output and error from the process so
+                far to include in the error message.
+            communicate: bool, when True we call communicate() on the process
+                after killing it to gather additional output.
+        """
+        if self._process.poll() is None:
+            time.sleep(0.1)  # give it time to finish printing the error.
+            try:
+                self._process.terminate()  # Ensure it dies.
+            except OSError:
+                pass
+        if communicate:
+            stdout_end, stderr_end = self._process.communicate()
+            stdout += stdout_end
+            stderr += stderr_end
+        self.fail('Error from IO process %s:\nSTDOUT:\n%sSTDERR:\n%s\n' %
+                  (why, stdout.decode(), stderr.decode()))
+
+    def _test_reading(self, data_to_write, read_and_verify_code):
+        """Generic buffered read method test harness to validate EINTR behavior.
+
+        Also validates that Python signal handlers are run during the read.
+
+        Args:
+            data_to_write: String to write to the child process for reading
+                before sending it a signal, confirming the signal was handled,
+                writing a final newline and closing the infile pipe.
+            read_and_verify_code: Single "line" of code to read from a file
+                object named 'infile' and validate the result.  This will be
+                executed as part of a python subprocess fed data_to_write.
+        """
+        infile_setup_code = self._generate_infile_setup_code()
+        # Total pipe IO in this function is smaller than the minimum posix OS
+        # pipe buffer size of 512 bytes.  No writer should block.
+        assert len(data_to_write) < 512, 'data_to_write must fit in pipe buf.'
+
+        # Start a subprocess to call our read method while handling a signal.
+        self._process = subprocess.Popen(
+                [sys.executable, '-u', '-c',
+                 'import signal, sys ;'
+                 'signal.signal(signal.SIGINT, '
+                               'lambda s, f: sys.stderr.write("$\\n")) ;'
+                 + infile_setup_code + ' ;' +
+                 'sys.stderr.write("Worm Sign!\\n") ;'
+                 + read_and_verify_code + ' ;' +
+                 'infile.close()'
+                ],
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE)
+
+        # Wait for the signal handler to be installed.
+        worm_sign = self._process.stderr.read(len(b'Worm Sign!\n'))
+        if worm_sign != b'Worm Sign!\n':  # See also, Dune by Frank Herbert.
+            self.fail_with_process_info('while awaiting a sign',
+                                        stderr=worm_sign)
+        self._process.stdin.write(data_to_write)
+
+        signals_sent = 0
+        rlist = []
+        # We don't know when the read_and_verify_code in our child is actually
+        # executing within the read system call we want to interrupt.  This
+        # loop waits for a bit before sending the first signal to increase
+        # the likelihood of that.  Implementations without correct EINTR
+        # and signal handling usually fail this test.
+        while not rlist:
+            rlist, _, _ = select.select([self._process.stderr], (), (), 0.05)
+            self._process.send_signal(signal.SIGINT)
+            signals_sent += 1
+            if signals_sent > 200:
+                self._process.kill()
+                self.fail('reader process failed to handle our signals.')
+        # This assumes anything unexpected that writes to stderr will also
+        # write a newline.  That is true of the traceback printing code.
+        signal_line = self._process.stderr.readline()
+        if signal_line != b'$\n':
+            self.fail_with_process_info('while awaiting signal',
+                                        stderr=signal_line)
+
+        # We append a newline to our input so that a readline call can
+        # end on its own before the EOF is seen and so that we're testing
+        # the read call that was interrupted by a signal before the end of
+        # the data stream has been reached.
+        stdout, stderr = self._process.communicate(input=b'\n')
+        if self._process.returncode:
+            self.fail_with_process_info(
+                    'exited rc=%d' % self._process.returncode,
+                    stdout, stderr, communicate=False)
+        # PASS!
+
+    # String format for the read_and_verify_code used by read methods.
+    _READING_CODE_TEMPLATE = (
+            'got = infile.{read_method_name}() ;'
+            'expected = {expected!r} ;'
+            'assert got == expected, ('
+                    '"{read_method_name} returned wrong data.\\n"'
+                    '"got data %r\\nexpected %r" % (got, expected))'
+            )
+
+    def test_readline(self):
+        """readline() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello, world!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='readline',
+                        expected=b'hello, world!\n'))
+
+    def test_readlines(self):
+        """readlines() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='readlines',
+                        expected=[b'hello\n', b'world!\n']))
+
+    def test_readall(self):
+        """readall() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='readall',
+                        expected=b'hello\nworld!\n'))
+        # read() is the same thing as readall().
+        self._test_reading(
+                data_to_write=b'hello\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='read',
+                        expected=b'hello\nworld!\n'))
+
+
+class CTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
+    modname = '_io'
+
+    # TODO: RUSTPYTHON - _io.FileIO.readall uses read_to_end which differs from _pyio.FileIO.readall
+    @unittest.expectedFailure
+    def test_readall(self):
+        super().test_readall()
+
+class PyTestFileIOSignalInterrupt(TestFileIOSignalInterrupt, unittest.TestCase):
+    modname = '_pyio'
+
+
+class TestBufferedIOSignalInterrupt(TestFileIOSignalInterrupt):
+    def _generate_infile_setup_code(self):
+        """Returns the infile = ... line of code to make a BufferedReader."""
+        return ('import %s as io ;infile = io.open(sys.stdin.fileno(), "rb") ;'
+                'assert isinstance(infile, io.BufferedReader)' %
+                self.modname)
+
+    def test_readall(self):
+        """BufferedReader.read() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='read',
+                        expected=b'hello\nworld!\n'))
+
+class CTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
+    modname = '_io'
+
+class PyTestBufferedIOSignalInterrupt(TestBufferedIOSignalInterrupt, unittest.TestCase):
+    modname = '_pyio'
+
+
+class TestTextIOSignalInterrupt(TestFileIOSignalInterrupt):
+    def _generate_infile_setup_code(self):
+        """Returns the infile = ... line of code to make a TextIOWrapper."""
+        return ('import %s as io ;'
+                'infile = io.open(sys.stdin.fileno(), encoding="utf-8", newline=None) ;'
+                'assert isinstance(infile, io.TextIOWrapper)' %
+                self.modname)
+
+    def test_readline(self):
+        """readline() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello, world!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='readline',
+                        expected='hello, world!\n'))
+
+    def test_readlines(self):
+        """readlines() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello\r\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='readlines',
+                        expected=['hello\n', 'world!\n']))
+
+    def test_readall(self):
+        """read() must handle signals and not lose data."""
+        self._test_reading(
+                data_to_write=b'hello\nworld!',
+                read_and_verify_code=self._READING_CODE_TEMPLATE.format(
+                        read_method_name='read',
+                        expected="hello\nworld!\n"))
+
+class CTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
+    modname = '_io'
+
+class PyTestTextIOSignalInterrupt(TestTextIOSignalInterrupt, unittest.TestCase):
+    modname = '_pyio'
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_filecmp.py b/Lib/test/test_filecmp.py
index 9b5ac12bcc..2c83667b22 100644
--- a/Lib/test/test_filecmp.py
+++ b/Lib/test/test_filecmp.py
@@ -1,5 +1,6 @@
 import filecmp
 import os
+import re
 import shutil
 import tempfile
 import unittest
@@ -8,11 +9,24 @@
 from test.support import os_helper
 
 
+def _create_file_shallow_equal(template_path, new_path):
+    """create a file with the same size and mtime but different content."""
+    shutil.copy2(template_path, new_path)
+    with open(new_path, 'r+b') as f:
+        next_char = bytearray(f.read(1))
+        next_char[0] = (next_char[0] + 1) % 256
+        f.seek(0)
+        f.write(next_char)
+    shutil.copystat(template_path, new_path)
+    assert os.stat(new_path).st_size == os.stat(template_path).st_size
+    assert os.stat(new_path).st_mtime == os.stat(template_path).st_mtime
+
 class FileCompareTestCase(unittest.TestCase):
     def setUp(self):
         self.name = os_helper.TESTFN
         self.name_same = os_helper.TESTFN + '-same'
         self.name_diff = os_helper.TESTFN + '-diff'
+        self.name_same_shallow = os_helper.TESTFN + '-same-shallow'
         data = 'Contents of file go here.\n'
         for name in [self.name, self.name_same, self.name_diff]:
             with open(name, 'w', encoding="utf-8") as output:
@@ -20,12 +34,19 @@ def setUp(self):
 
         with open(self.name_diff, 'a+', encoding="utf-8") as output:
             output.write('An extra line.\n')
+
+        for name in [self.name_same, self.name_diff]:
+            shutil.copystat(self.name, name)
+
+        _create_file_shallow_equal(self.name, self.name_same_shallow)
+
         self.dir = tempfile.gettempdir()
 
     def tearDown(self):
         os.unlink(self.name)
         os.unlink(self.name_same)
         os.unlink(self.name_diff)
+        os.unlink(self.name_same_shallow)
 
     def test_matching(self):
         self.assertTrue(filecmp.cmp(self.name, self.name),
@@ -36,12 +57,17 @@ def test_matching(self):
                         "Comparing file to identical file fails")
         self.assertTrue(filecmp.cmp(self.name, self.name_same, shallow=False),
                         "Comparing file to identical file fails")
+        self.assertTrue(filecmp.cmp(self.name, self.name_same_shallow),
+                        "Shallow identical files should be considered equal")
 
     def test_different(self):
         self.assertFalse(filecmp.cmp(self.name, self.name_diff),
                     "Mismatched files compare as equal")
         self.assertFalse(filecmp.cmp(self.name, self.dir),
                     "File and directory compare as equal")
+        self.assertFalse(filecmp.cmp(self.name, self.name_same_shallow,
+                                     shallow=False),
+                        "Mismatched file to shallow identical file compares as equal")
 
     def test_cache_clear(self):
         first_compare = filecmp.cmp(self.name, self.name_same, shallow=False)
@@ -56,6 +82,8 @@ def setUp(self):
         self.dir = os.path.join(tmpdir, 'dir')
         self.dir_same = os.path.join(tmpdir, 'dir-same')
         self.dir_diff = os.path.join(tmpdir, 'dir-diff')
+        self.dir_diff_file = os.path.join(tmpdir, 'dir-diff-file')
+        self.dir_same_shallow = os.path.join(tmpdir, 'dir-same-shallow')
 
         # Another dir is created under dir_same, but it has a name from the
         # ignored list so it should not affect testing results.
@@ -63,7 +91,17 @@ def setUp(self):
 
         self.caseinsensitive = os.path.normcase('A') == os.path.normcase('a')
         data = 'Contents of file go here.\n'
-        for dir in (self.dir, self.dir_same, self.dir_diff, self.dir_ignored):
+
+        shutil.rmtree(self.dir, True)
+        os.mkdir(self.dir)
+        subdir_path = os.path.join(self.dir, 'subdir')
+        os.mkdir(subdir_path)
+        dir_file_path = os.path.join(self.dir, "file")
+        with open(dir_file_path, 'w', encoding="utf-8") as output:
+            output.write(data)
+
+        for dir in (self.dir_same, self.dir_same_shallow,
+                    self.dir_diff, self.dir_diff_file):
             shutil.rmtree(dir, True)
             os.mkdir(dir)
             subdir_path = os.path.join(dir, 'subdir')
@@ -72,14 +110,25 @@ def setUp(self):
                 fn = 'FiLe'     # Verify case-insensitive comparison
             else:
                 fn = 'file'
-            with open(os.path.join(dir, fn), 'w', encoding="utf-8") as output:
-                output.write(data)
+
+            file_path = os.path.join(dir, fn)
+
+            if dir is self.dir_same_shallow:
+                _create_file_shallow_equal(dir_file_path, file_path)
+            else:
+                shutil.copy2(dir_file_path, file_path)
 
         with open(os.path.join(self.dir_diff, 'file2'), 'w', encoding="utf-8") as output:
             output.write('An extra file.\n')
 
+        # Add different file2 with respect to dir_diff
+        with open(os.path.join(self.dir_diff_file, 'file2'), 'w', encoding="utf-8") as output:
+            output.write('Different contents.\n')
+
+
     def tearDown(self):
-        for dir in (self.dir, self.dir_same, self.dir_diff):
+        for dir in (self.dir, self.dir_same, self.dir_diff,
+                    self.dir_same_shallow, self.dir_diff_file):
             shutil.rmtree(dir)
 
     def test_default_ignores(self):
@@ -102,25 +151,65 @@ def test_cmpfiles(self):
                                          shallow=False),
                         "Comparing directory to same fails")
 
-        # Add different file2
-        with open(os.path.join(self.dir, 'file2'), 'w', encoding="utf-8") as output:
-            output.write('Different contents.\n')
-
-        self.assertFalse(filecmp.cmpfiles(self.dir, self.dir_same,
+        self.assertFalse(filecmp.cmpfiles(self.dir, self.dir_diff_file,
                                      ['file', 'file2']) ==
                     (['file'], ['file2'], []),
                     "Comparing mismatched directories fails")
 
+    def test_cmpfiles_invalid_names(self):
+        # See https://github.com/python/cpython/issues/122400.
+        for file, desc in [
+            ('\x00', 'NUL bytes filename'),
+            (__file__ + '\x00', 'filename with embedded NUL bytes'),
+            ("\uD834\uDD1E.py", 'surrogate codes (MUSICAL SYMBOL G CLEF)'),
+            ('a' * 1_000_000, 'very long filename'),
+        ]:
+            for other_dir in [self.dir, self.dir_same, self.dir_diff]:
+                with self.subTest(f'cmpfiles: {desc}', other_dir=other_dir):
+                    res = filecmp.cmpfiles(self.dir, other_dir, [file])
+                    self.assertTupleEqual(res, ([], [], [file]))
+
+    def test_dircmp_invalid_names(self):
+        for bad_dir, desc in [
+            ('\x00', 'NUL bytes dirname'),
+            (f'Top{os.sep}Mid\x00', 'dirname with embedded NUL bytes'),
+            ("\uD834\uDD1E", 'surrogate codes (MUSICAL SYMBOL G CLEF)'),
+            ('a' * 1_000_000, 'very long dirname'),
+        ]:
+            d1 = filecmp.dircmp(self.dir, bad_dir)
+            d2 = filecmp.dircmp(bad_dir, self.dir)
+            for target in [
+                # attributes where os.listdir() raises OSError or ValueError
+                'left_list', 'right_list',
+                'left_only', 'right_only', 'common',
+            ]:
+                with self.subTest(f'dircmp(ok, bad): {desc}', target=target):
+                    with self.assertRaises((OSError, ValueError)):
+                        getattr(d1, target)
+                with self.subTest(f'dircmp(bad, ok): {desc}', target=target):
+                    with self.assertRaises((OSError, ValueError)):
+                        getattr(d2, target)
 
     def _assert_lists(self, actual, expected):
         """Assert that two lists are equal, up to ordering."""
         self.assertEqual(sorted(actual), sorted(expected))
 
+    def test_dircmp_identical_directories(self):
+        self._assert_dircmp_identical_directories()
+        self._assert_dircmp_identical_directories(shallow=False)
+
+    def test_dircmp_different_file(self):
+        self._assert_dircmp_different_file()
+        self._assert_dircmp_different_file(shallow=False)
 
-    def test_dircmp(self):
+    def test_dircmp_different_directories(self):
+        self._assert_dircmp_different_directories()
+        self._assert_dircmp_different_directories(shallow=False)
+
+    def _assert_dircmp_identical_directories(self, **options):
         # Check attributes for comparison of two identical directories
         left_dir, right_dir = self.dir, self.dir_same
-        d = filecmp.dircmp(left_dir, right_dir)
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         if self.caseinsensitive:
@@ -142,9 +231,10 @@ def test_dircmp(self):
         ]
         self._assert_report(d.report, expected_report)
 
+    def _assert_dircmp_different_directories(self, **options):
         # Check attributes for comparison of two different directories (right)
         left_dir, right_dir = self.dir, self.dir_diff
-        d = filecmp.dircmp(left_dir, right_dir)
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         self._assert_lists(d.left_list, ['file', 'subdir'])
@@ -164,12 +254,8 @@ def test_dircmp(self):
         self._assert_report(d.report, expected_report)
 
         # Check attributes for comparison of two different directories (left)
-        left_dir, right_dir = self.dir, self.dir_diff
-        shutil.move(
-            os.path.join(self.dir_diff, 'file2'),
-            os.path.join(self.dir, 'file2')
-        )
-        d = filecmp.dircmp(left_dir, right_dir)
+        left_dir, right_dir = self.dir_diff, self.dir
+        d = filecmp.dircmp(left_dir, right_dir, **options)
         self.assertEqual(d.left, left_dir)
         self.assertEqual(d.right, right_dir)
         self._assert_lists(d.left_list, ['file', 'file2', 'subdir'])
@@ -180,27 +266,62 @@ def test_dircmp(self):
         self.assertEqual(d.same_files, ['file'])
         self.assertEqual(d.diff_files, [])
         expected_report = [
-            "diff {} {}".format(self.dir, self.dir_diff),
-            "Only in {} : ['file2']".format(self.dir),
+            "diff {} {}".format(self.dir_diff, self.dir),
+            "Only in {} : ['file2']".format(self.dir_diff),
             "Identical files : ['file']",
             "Common subdirectories : ['subdir']",
         ]
         self._assert_report(d.report, expected_report)
 
-        # Add different file2
-        with open(os.path.join(self.dir_diff, 'file2'), 'w', encoding="utf-8") as output:
-            output.write('Different contents.\n')
-        d = filecmp.dircmp(self.dir, self.dir_diff)
+
+    def _assert_dircmp_different_file(self, **options):
+        # A different file2
+        d = filecmp.dircmp(self.dir_diff, self.dir_diff_file, **options)
         self.assertEqual(d.same_files, ['file'])
         self.assertEqual(d.diff_files, ['file2'])
         expected_report = [
-            "diff {} {}".format(self.dir, self.dir_diff),
+            "diff {} {}".format(self.dir_diff, self.dir_diff_file),
             "Identical files : ['file']",
             "Differing files : ['file2']",
             "Common subdirectories : ['subdir']",
         ]
         self._assert_report(d.report, expected_report)
 
+    def test_dircmp_no_shallow_different_file(self):
+        # A non shallow different file2
+        d = filecmp.dircmp(self.dir, self.dir_same_shallow, shallow=False)
+        self.assertEqual(d.same_files, [])
+        self.assertEqual(d.diff_files, ['file'])
+        expected_report = [
+            "diff {} {}".format(self.dir, self.dir_same_shallow),
+            "Differing files : ['file']",
+            "Common subdirectories : ['subdir']",
+        ]
+        self._assert_report(d.report, expected_report)
+
+    def test_dircmp_shallow_same_file(self):
+        # A non shallow different file2
+        d = filecmp.dircmp(self.dir, self.dir_same_shallow)
+        self.assertEqual(d.same_files, ['file'])
+        self.assertEqual(d.diff_files, [])
+        expected_report = [
+            "diff {} {}".format(self.dir, self.dir_same_shallow),
+            "Identical files : ['file']",
+            "Common subdirectories : ['subdir']",
+        ]
+        self._assert_report(d.report, expected_report)
+
+    def test_dircmp_shallow_is_keyword_only(self):
+        with self.assertRaisesRegex(
+            TypeError,
+            re.escape("dircmp.__init__() takes from 3 to 5 positional arguments but 6 were given"),
+        ):
+            filecmp.dircmp(self.dir, self.dir_same, None, None, True)
+        self.assertIsInstance(
+            filecmp.dircmp(self.dir, self.dir_same, None, None, shallow=True),
+            filecmp.dircmp,
+        )
+
     def test_dircmp_subdirs_type(self):
         """Check that dircmp.subdirs respects subclassing."""
         class MyDirCmp(filecmp.dircmp):
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
index d1a2452d88..fdb36ed997 100644
--- a/Lib/test/test_fileio.py
+++ b/Lib/test/test_fileio.py
@@ -10,10 +10,14 @@
 from functools import wraps
 
 from test.support import (
-    cpython_only, swap_attr, gc_collect, is_emscripten, is_wasi
+    cpython_only, swap_attr, gc_collect, is_emscripten, is_wasi,
+    infinite_recursion,
 )
-from test.support.os_helper import (TESTFN, TESTFN_UNICODE, make_bad_fd)
+from test.support.os_helper import (
+    TESTFN, TESTFN_ASCII, TESTFN_UNICODE, make_bad_fd,
+    )
 from test.support.warnings_helper import check_warnings
+from test.support.import_helper import import_module
 from collections import UserList
 
 import _io  # C implementation of io
@@ -171,6 +175,16 @@ def testRepr(self):
         self.assertEqual(repr(self.f),
                          "<%s.FileIO [closed]>" % (self.modulename,))
 
+    def test_subclass_repr(self):
+        class TestSubclass(self.FileIO):
+            pass
+
+        f = TestSubclass(TESTFN)
+        with f:
+            self.assertIn(TestSubclass.__name__, repr(f))
+
+        self.assertIn(TestSubclass.__name__, repr(f))
+
     def testReprNoCloseFD(self):
         fd = os.open(TESTFN, os.O_RDONLY)
         try:
@@ -181,6 +195,7 @@ def testReprNoCloseFD(self):
         finally:
             os.close(fd)
 
+    @infinite_recursion(25)
     def testRecursiveRepr(self):
         # Issue #25455
         with swap_attr(self.f, 'name', self.f):
@@ -348,52 +363,13 @@ class CAutoFileTests(AutoFileTests, unittest.TestCase):
     FileIO = _io.FileIO
     modulename = '_io'
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def testBlksize(self):
-        super().testBlksize()
-
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @unittest.expectedFailure
-        def testErrnoOnClosedSeek(self):
-            super().testErrnoOnClosedSeek()
-
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @unittest.expectedFailure
-        def testErrnoOnClosedTell(self):
-            super().testErrnoOnClosedTell()
-
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @unittest.expectedFailure
-        def testErrnoOnClosedTruncate(self):
-            super().testErrnoOnClosedTruncate()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def testMethods(self):
-        super().testMethods()
-    
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def testOpenDirFD(self):
-        super().testOpenDirFD()
-
-
-@unittest.skipIf(sys.platform == "win32", "TODO: RUSTPYTHON, test setUp errors on Windows")
 class PyAutoFileTests(AutoFileTests, unittest.TestCase):
     FileIO = _pyio.FileIO
     modulename = '_pyio'
 
-    def testOpendir(self):
-        super().testOpendir()
-
 
 class OtherFileTests:
 
-    @unittest.skip("TODO: non-deterministic failures, FileIO.seekable()?")
     def testAbles(self):
         try:
             f = self.FileIO(TESTFN, "w")
@@ -470,18 +446,15 @@ def testUnicodeOpen(self):
 
     def testBytesOpen(self):
         # Opening a bytes filename
-        try:
-            fn = TESTFN.encode("ascii")
-        except UnicodeEncodeError:
-            self.skipTest('could not encode %r to ascii' % TESTFN)
+        fn = TESTFN_ASCII.encode("ascii")
         f = self.FileIO(fn, "w")
         try:
             f.write(b"abc")
             f.close()
-            with open(TESTFN, "rb") as f:
+            with self.open(TESTFN_ASCII, "rb") as f:
                 self.assertEqual(f.read(), b"abc")
         finally:
-            os.unlink(TESTFN)
+            os.unlink(TESTFN_ASCII)
 
     @unittest.skipIf(sys.getfilesystemencoding() != 'utf-8',
                      "test only works for utf-8 filesystems")
@@ -495,7 +468,7 @@ def testUtf8BytesOpen(self):
         try:
             f.write(b"abc")
             f.close()
-            with open(TESTFN_UNICODE, "rb") as f:
+            with self.open(TESTFN_UNICODE, "rb") as f:
                 self.assertEqual(f.read(), b"abc")
         finally:
             os.unlink(TESTFN_UNICODE)
@@ -512,6 +485,14 @@ def testInvalidFd(self):
             import msvcrt
             self.assertRaises(OSError, msvcrt.get_osfhandle, make_bad_fd())
 
+    def testBooleanFd(self):
+        for fd in False, True:
+            with self.assertWarnsRegex(RuntimeWarning,
+                    'bool is used as a file descriptor') as cm:
+                f = self.FileIO(fd, closefd=False)
+            f.close()
+            self.assertEqual(cm.filename, __file__)
+
     def testBadModeArgument(self):
         # verify that we get a sensible error message for bad mode argument
         bad_mode = "qwerty"
@@ -542,7 +523,7 @@ def testTruncate(self):
 
     def testTruncateOnWindows(self):
         def bug801631():
-            # SF bug <http://www.python.org/sf/801631>
+            # SF bug <https://bugs.python.org/issue801631>
             # "file.truncate fault on windows"
             f = self.FileIO(TESTFN, 'w')
             f.write(bytes(range(11)))
@@ -571,13 +552,13 @@ def bug801631():
 
     def testAppend(self):
         try:
-            f = open(TESTFN, 'wb')
+            f = self.FileIO(TESTFN, 'wb')
             f.write(b'spam')
             f.close()
-            f = open(TESTFN, 'ab')
+            f = self.FileIO(TESTFN, 'ab')
             f.write(b'eggs')
             f.close()
-            f = open(TESTFN, 'rb')
+            f = self.FileIO(TESTFN, 'rb')
             d = f.read()
             f.close()
             self.assertEqual(d, b'spameggs')
@@ -613,16 +594,12 @@ def __setattr__(self, name, value):
 class COtherFileTests(OtherFileTests, unittest.TestCase):
     FileIO = _io.FileIO
     modulename = '_io'
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def testUnclosedFDOnException(self):
-        super().testUnclosedFDOnException()
+    open = _io.open
 
     @cpython_only
     def testInvalidFd_overflow(self):
         # Issue 15989
-        import _testcapi
+        _testcapi = import_module("_testcapi")
         self.assertRaises(TypeError, self.FileIO, _testcapi.INT_MAX + 1)
         self.assertRaises(TypeError, self.FileIO, _testcapi.INT_MIN - 1)
 
@@ -639,6 +616,7 @@ def test_open_code(self):
 class PyOtherFileTests(OtherFileTests, unittest.TestCase):
     FileIO = _pyio.FileIO
     modulename = '_pyio'
+    open = _pyio.open
 
     def test_open_code(self):
         # Check that the default behaviour of open_code matches
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index d94a2bdadd..4ca4103f42 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -9,8 +9,10 @@
 
 from test import support
 from test.support.testcase import FloatsAreIdenticalMixin
-from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
-                               INVALID_UNDERSCORE_LITERALS)
+from test.support.numbers import (
+    VALID_UNDERSCORE_LITERALS,
+    INVALID_UNDERSCORE_LITERALS,
+)
 from math import isinf, isnan, copysign, ldexp
 import math
 
@@ -726,8 +728,8 @@ def test_format(self):
         self.assertEqual(format(INF, 'F'), 'INF')
 
     @support.requires_IEEE_754
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipUnless(sys.float_repr_style == 'short',
+                         "applies only when using short float repr style")
     def test_format_testfile(self):
         with open(format_testfile, encoding="utf-8") as testfile:
             for line in testfile:
@@ -772,8 +774,6 @@ def test_issue35560(self):
         self.assertEqual(format(-123.34, '00.10g'), '-123.34')
 
 class ReprTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_repr(self):
         with open(os.path.join(os.path.split(__file__)[0],
                   'mathdata',
@@ -1513,4 +1513,4 @@ def __init__(self, value):
 
 
 if __name__ == '__main__':
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_fnmatch.py b/Lib/test/test_fnmatch.py
index 092cd56285..10ed496d4e 100644
--- a/Lib/test/test_fnmatch.py
+++ b/Lib/test/test_fnmatch.py
@@ -71,7 +71,6 @@ def test_fnmatchcase(self):
         check('usr/bin', 'usr\\bin', False, fnmatchcase)
         check('usr\\bin', 'usr\\bin', True, fnmatchcase)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_bytes(self):
         self.check_match(b'test', b'te*')
         self.check_match(b'test\xff', b'te*\xff')
@@ -239,17 +238,9 @@ def test_translate(self):
         self.assertEqual(translate('A*********?[?]?'), r'(?s:A.*.[?].)\Z')
         # fancy translation to prevent exponential-time match failure
         t = translate('**a*a****a')
-        digits = re.findall(r'\d+', t)
-        self.assertEqual(len(digits), 4)
-        self.assertEqual(digits[0], digits[1])
-        self.assertEqual(digits[2], digits[3])
-        g1 = f"g{digits[0]}"  # e.g., group name "g4"
-        g2 = f"g{digits[2]}"  # e.g., group name "g5"
-        self.assertEqual(t,
-         fr'(?s:(?=(?P<{g1}>.*?a))(?P={g1})(?=(?P<{g2}>.*?a))(?P={g2}).*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; all the pain of generating unique group
-        # names across calls exists to support this
+        # feature that this works
         r1 = translate('**a**a**a*')
         r2 = translate('**b**b**b*')
         r3 = translate('*c*c*c*')
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index 41f93390b5..67c9b98d67 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -2,7 +2,7 @@
 
 import cmath
 from decimal import Decimal
-# from test.support import requires_IEEE_754
+from test.support import requires_IEEE_754, adjust_int_max_str_digits
 import math
 import numbers
 import operator
@@ -19,7 +19,7 @@
 
 #locate file with float format test values
 test_dir = os.path.dirname(__file__) or os.curdir
-format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt')
+format_testfile = os.path.join(test_dir, 'mathdata', 'formatfloat_testcases.txt')
 
 class DummyFloat(object):
     """Dummy float class for testing comparisons with Fractions"""
@@ -97,7 +97,7 @@ def typed_approx_eq(a, b):
 
 class Symbolic:
     """Simple non-numeric class for testing mixed arithmetic.
-    It is not Integral, Rational, Real or Complex, and cannot be conveted
+    It is not Integral, Rational, Real or Complex, and cannot be converted
     to int, float or complex. but it supports some arithmetic operations.
     """
     def __init__(self, value):
@@ -331,7 +331,7 @@ def testInit(self):
         self.assertRaises(TypeError, F, 3, 1j)
         self.assertRaises(TypeError, F, 1, 2, 3)
 
-    # @requires_IEEE_754
+    @requires_IEEE_754
     def testInitFromFloat(self):
         self.assertEqual((5, 2), _components(F(2.5)))
         self.assertEqual((0, 1), _components(F(-0.0)))
@@ -357,12 +357,14 @@ def testInitFromDecimal(self):
 
     def testFromString(self):
         self.assertEqual((5, 1), _components(F("5")))
+        self.assertEqual((5, 1), _components(F("005")))
         self.assertEqual((3, 2), _components(F("3/2")))
         self.assertEqual((3, 2), _components(F("3 / 2")))
         self.assertEqual((3, 2), _components(F(" \n  +3/2")))
         self.assertEqual((-3, 2), _components(F("-3/2  ")))
-        self.assertEqual((13, 2), _components(F("    013/02 \n  ")))
+        self.assertEqual((13, 2), _components(F("    0013/002 \n  ")))
         self.assertEqual((16, 5), _components(F(" 3.2 ")))
+        self.assertEqual((16, 5), _components(F("003.2")))
         self.assertEqual((-16, 5), _components(F(" -3.2 ")))
         self.assertEqual((-3, 1), _components(F(" -3. ")))
         self.assertEqual((3, 5), _components(F(" .6 ")))
@@ -381,116 +383,102 @@ def testFromString(self):
         self.assertRaisesMessage(
             ZeroDivisionError, "Fraction(3, 0)",
             F, "3/0")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '3/'",
-            F, "3/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '/2'",
-            F, "/2")
-        self.assertRaisesMessage(
-            # Denominators don't need a sign.
-            ValueError, "Invalid literal for Fraction: '3/+2'",
-            F, "3/+2")
-        self.assertRaisesMessage(
-            # Imitate float's parsing.
-            ValueError, "Invalid literal for Fraction: '+ 3/2'",
-            F, "+ 3/2")
-        self.assertRaisesMessage(
-            # Avoid treating '.' as a regex special character.
-            ValueError, "Invalid literal for Fraction: '3a2'",
-            F, "3a2")
-        self.assertRaisesMessage(
-            # Don't accept combinations of decimals and rationals.
-            ValueError, "Invalid literal for Fraction: '3/7.2'",
-            F, "3/7.2")
-        self.assertRaisesMessage(
-            # Don't accept combinations of decimals and rationals.
-            ValueError, "Invalid literal for Fraction: '3.2/7'",
-            F, "3.2/7")
-        self.assertRaisesMessage(
-            # Allow 3. and .3, but not .
-            ValueError, "Invalid literal for Fraction: '.'",
-            F, ".")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_'",
-            F, "_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_1'",
-            F, "_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1__2'",
-            F, "1__2")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '/_'",
-            F, "/_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1_/'",
-            F, "1_/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '_1/'",
-            F, "_1/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1__2/'",
-            F, "1__2/")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/_'",
-            F, "1/_")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/_1'",
-            F, "1/_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/1__2'",
-            F, "1/1__2")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1._111'",
-            F, "1._111")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1__1'",
-            F, "1.1__1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1e+_1'",
-            F, "1.1e+_1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1e+1__1'",
-            F, "1.1e+1__1")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '123.dd'",
-            F, "123.dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '123.5_dd'",
-            F, "123.5_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: 'dd.5'",
-            F, "dd.5")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '7_dd'",
-            F, "7_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/dd'",
-            F, "1/dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/123_dd'",
-            F, "1/123_dd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '789edd'",
-            F, "789edd")
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '789e2_dd'",
-            F, "789e2_dd")
+
+        def check_invalid(s):
+            msg = "Invalid literal for Fraction: " + repr(s)
+            self.assertRaisesMessage(ValueError, msg, F, s)
+
+        check_invalid("3/")
+        check_invalid("/2")
+        # Denominators don't need a sign.
+        check_invalid("3/+2")
+        check_invalid("3/-2")
+        # Imitate float's parsing.
+        check_invalid("+ 3/2")
+        check_invalid("- 3/2")
+        # Avoid treating '.' as a regex special character.
+        check_invalid("3a2")
+        # Don't accept combinations of decimals and rationals.
+        check_invalid("3/7.2")
+        check_invalid("3.2/7")
+        # No space around dot.
+        check_invalid("3 .2")
+        check_invalid("3. 2")
+        # No space around e.
+        check_invalid("3.2 e1")
+        check_invalid("3.2e 1")
+        # Fractional part don't need a sign.
+        check_invalid("3.+2")
+        check_invalid("3.-2")
+        # Only accept base 10.
+        check_invalid("0x10")
+        check_invalid("0x10/1")
+        check_invalid("1/0x10")
+        check_invalid("0x10.")
+        check_invalid("0x10.1")
+        check_invalid("1.0x10")
+        check_invalid("1.0e0x10")
+        # Only accept decimal digits.
+        check_invalid("³")
+        check_invalid("³/2")
+        check_invalid("3/²")
+        check_invalid("³.2")
+        check_invalid("3.²")
+        check_invalid("3.2e²")
+        check_invalid("¼")
+        # Allow 3. and .3, but not .
+        check_invalid(".")
+        check_invalid("_")
+        check_invalid("_1")
+        check_invalid("1__2")
+        check_invalid("/_")
+        check_invalid("1_/")
+        check_invalid("_1/")
+        check_invalid("1__2/")
+        check_invalid("1/_")
+        check_invalid("1/_1")
+        check_invalid("1/1__2")
+        check_invalid("1._111")
+        check_invalid("1.1__1")
+        check_invalid("1.1e+_1")
+        check_invalid("1.1e+1__1")
+        check_invalid("123.dd")
+        check_invalid("123.5_dd")
+        check_invalid("dd.5")
+        check_invalid("7_dd")
+        check_invalid("1/dd")
+        check_invalid("1/123_dd")
+        check_invalid("789edd")
+        check_invalid("789e2_dd")
         # Test catastrophic backtracking.
         val = "9"*50 + "_"
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '" + val + "'",
-            F, val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1/" + val + "'",
-            F, "1/" + val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1." + val + "'",
-            F, "1." + val)
-        self.assertRaisesMessage(
-            ValueError, "Invalid literal for Fraction: '1.1+e" + val + "'",
-            F, "1.1+e" + val)
+        check_invalid(val)
+        check_invalid("1/" + val)
+        check_invalid("1." + val)
+        check_invalid("." + val)
+        check_invalid("1.1+e" + val)
+        check_invalid("1.1e" + val)
+
+    def test_limit_int(self):
+        maxdigits = 5000
+        with adjust_int_max_str_digits(maxdigits):
+            msg = 'Exceeds the limit'
+            val = '1' * maxdigits
+            num = (10**maxdigits - 1)//9
+            self.assertEqual((num, 1), _components(F(val)))
+            self.assertRaisesRegex(ValueError, msg, F, val + '1')
+            self.assertEqual((num, 2), _components(F(val + '/2')))
+            self.assertRaisesRegex(ValueError, msg, F, val + '1/2')
+            self.assertEqual((1, num), _components(F('1/' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '1/1' + val)
+            self.assertEqual(((10**(maxdigits+1) - 1)//9, 10**maxdigits),
+                             _components(F('1.' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '1.1' + val)
+            self.assertEqual((num, 10**maxdigits), _components(F('.' + val)))
+            self.assertRaisesRegex(ValueError, msg, F, '.1' + val)
+            self.assertRaisesRegex(ValueError, msg, F, '1.1e1' + val)
+            self.assertEqual((11, 10), _components(F('1.1e' + '0' * maxdigits)))
+            self.assertRaisesRegex(ValueError, msg, F, '1.1e' + '0' * (maxdigits+1))
 
     def testImmutable(self):
         r = F(7, 3)
@@ -922,21 +910,21 @@ def testMixedPower(self):
         self.assertTypedEquals(Root(4) ** F(2, 1), Root(4, F(1)))
         self.assertTypedEquals(Root(4) ** F(-2, 1), Root(4, -F(1)))
         self.assertTypedEquals(Root(4) ** F(-2, 3), Root(4, -3.0))
-        self.assertEqual(F(3, 2) ** SymbolicReal('X'), SymbolicReal('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** SymbolicReal('X'), SymbolicReal('3/2 ** X'))
         self.assertEqual(SymbolicReal('X') ** F(3, 2), SymbolicReal('X ** 1.5'))
 
-        self.assertTypedEquals(F(3, 2) ** Rect(2, 0), Polar(2.25, 0.0))
-        self.assertTypedEquals(F(1, 1) ** Rect(2, 3), Polar(1.0, 0.0))
+        self.assertTypedEquals(F(3, 2) ** Rect(2, 0), Polar(F(9,4), 0.0))
+        self.assertTypedEquals(F(1, 1) ** Rect(2, 3), Polar(F(1), 0.0))
         self.assertTypedEquals(F(3, 2) ** RectComplex(2, 0), Polar(2.25, 0.0))
         self.assertTypedEquals(F(1, 1) ** RectComplex(2, 3), Polar(1.0, 0.0))
         self.assertTypedEquals(Polar(4, 2) ** F(3, 2), Polar(8.0, 3.0))
         self.assertTypedEquals(Polar(4, 2) ** F(3, 1), Polar(64, 6))
         self.assertTypedEquals(Polar(4, 2) ** F(-3, 1), Polar(0.015625, -6))
         self.assertTypedEquals(Polar(4, 2) ** F(-3, 2), Polar(0.125, -3.0))
-        self.assertEqual(F(3, 2) ** SymbolicComplex('X'), SymbolicComplex('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** SymbolicComplex('X'), SymbolicComplex('3/2 ** X'))
         self.assertEqual(SymbolicComplex('X') ** F(3, 2), SymbolicComplex('X ** 1.5'))
 
-        self.assertEqual(F(3, 2) ** Symbolic('X'), Symbolic('1.5 ** X'))
+        self.assertEqual(F(3, 2) ** Symbolic('X'), Symbolic('3/2 ** X'))
         self.assertEqual(Symbolic('X') ** F(3, 2), Symbolic('X ** 1.5'))
 
     def testMixingWithDecimal(self):
@@ -1137,8 +1125,6 @@ def test_copy_deepcopy_pickle(self):
         self.assertTypedEquals(dr, copy(dr))
         self.assertTypedEquals(dr, deepcopy(dr))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slots(self):
         # Issue 4998
         r = F(13, 7)
@@ -1167,12 +1153,50 @@ def denominator(self):
         self.assertEqual(type(f.denominator), myint)
 
     def test_format_no_presentation_type(self):
-        # Triples (fraction, specification, expected_result)
+        # Triples (fraction, specification, expected_result).
         testcases = [
-            (F(1, 3), '', '1/3'),
-            (F(-1, 3), '', '-1/3'),
-            (F(3), '', '3'),
-            (F(-3), '', '-3'),
+            # Explicit sign handling
+            (F(2, 3), '+', '+2/3'),
+            (F(-2, 3), '+', '-2/3'),
+            (F(3), '+', '+3'),
+            (F(-3), '+', '-3'),
+            (F(2, 3), ' ', ' 2/3'),
+            (F(-2, 3), ' ', '-2/3'),
+            (F(3), ' ', ' 3'),
+            (F(-3), ' ', '-3'),
+            (F(2, 3), '-', '2/3'),
+            (F(-2, 3), '-', '-2/3'),
+            (F(3), '-', '3'),
+            (F(-3), '-', '-3'),
+            # Padding
+            (F(0), '5', '    0'),
+            (F(2, 3), '5', '  2/3'),
+            (F(-2, 3), '5', ' -2/3'),
+            (F(2, 3), '0', '2/3'),
+            (F(2, 3), '1', '2/3'),
+            (F(2, 3), '2', '2/3'),
+            # Alignment
+            (F(2, 3), '<5', '2/3  '),
+            (F(2, 3), '>5', '  2/3'),
+            (F(2, 3), '^5', ' 2/3 '),
+            (F(2, 3), '=5', '  2/3'),
+            (F(-2, 3), '<5', '-2/3 '),
+            (F(-2, 3), '>5', ' -2/3'),
+            (F(-2, 3), '^5', '-2/3 '),
+            (F(-2, 3), '=5', '- 2/3'),
+            # Fill
+            (F(2, 3), 'X>5', 'XX2/3'),
+            (F(-2, 3), '.<5', '-2/3.'),
+            (F(-2, 3), '\n^6', '\n-2/3\n'),
+            # Thousands separators
+            (F(1234, 5679), ',', '1,234/5,679'),
+            (F(-1234, 5679), '_', '-1_234/5_679'),
+            (F(1234567), '_', '1_234_567'),
+            (F(-1234567), ',', '-1,234,567'),
+            # Alternate form forces a slash in the output
+            (F(123), '#', '123/1'),
+            (F(-123), '#', '-123/1'),
+            (F(0), '#', '0/1'),
         ]
         for fraction, spec, expected in testcases:
             with self.subTest(fraction=fraction, spec=spec):
@@ -1387,11 +1411,8 @@ def test_format_f_presentation_type(self):
             (F('-1234.5678'), '08,.0f', '-001,235'),
             (F('-1234.5678'), '09,.0f', '-0,001,235'),
             # Corner-case - zero-padding specified through fill and align
-            # instead of the zero-pad character - in this case, treat '0' as a
-            # regular fill character and don't attempt to insert commas into
-            # the filled portion. This differs from the int and float
-            # behaviour.
-            (F('1234.5678'), '0=12,.2f', '00001,234.57'),
+            # instead of the zero-pad character.
+            (F('1234.5678'), '0=12,.2f', '0,001,234.57'),
             # Corner case where it's not clear whether the '0' indicates zero
             # padding or gives the minimum width, but there's still an obvious
             # answer to give. We want this to work in case the minimum width
@@ -1536,13 +1557,17 @@ def test_invalid_formats(self):
             '.%',
             # Z instead of z for negative zero suppression
             'Z.2f'
+            # z flag not supported for general formatting
+            'z',
+            # zero padding not supported for general formatting
+            '05',
         ]
         for spec in invalid_specs:
             with self.subTest(spec=spec):
                 with self.assertRaises(ValueError):
                     format(fraction, spec)
 
-    # @requires_IEEE_754
+    @requires_IEEE_754
     def test_float_format_testfile(self):
         with open(format_testfile, encoding="utf-8") as testfile:
             for line in testfile:
@@ -1566,6 +1591,36 @@ def test_float_format_testfile(self):
                     self.assertEqual(float(format(f, fmt2)), float(rhs))
                     self.assertEqual(float(format(-f, fmt2)), float('-' + rhs))
 
+    # TODO: RUSTPYTHON
+    # TypeError: '%' not supported between instances of 'Fraction' and 'complex'
+    @unittest.expectedFailure
+    def test_complex_handling(self):
+        # See issue gh-102840 for more details.
+
+        a = F(1, 2)
+        b = 1j
+        message = "unsupported operand type(s) for %s: '%s' and '%s'"
+        # test forward
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "Fraction", "complex"),
+                                 operator.mod, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "Fraction", "complex"),
+                                 operator.floordiv, a, b)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "Fraction", "complex"),
+                                 divmod, a, b)
+        # test reverse
+        self.assertRaisesMessage(TypeError,
+                                 message % ("%", "complex", "Fraction"),
+                                 operator.mod, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("//", "complex", "Fraction"),
+                                 operator.floordiv, b, a)
+        self.assertRaisesMessage(TypeError,
+                                 message % ("divmod()", "complex", "Fraction"),
+                                 divmod, b, a)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_fstring.py b/Lib/test/test_fstring.py
index 4996eedc1c..930e409fb2 100644
--- a/Lib/test/test_fstring.py
+++ b/Lib/test/test_fstring.py
@@ -9,6 +9,7 @@
 
 import ast
 import datetime
+import dis
 import os
 import re
 import types
@@ -19,7 +20,7 @@
 from test.support.os_helper import temp_cwd
 from test.support.script_helper import assert_python_failure, assert_python_ok
 
-a_global = "global variable"
+a_global = 'global variable'
 
 # You could argue that I'm too strict in looking for specific error
 #  values with assertRaisesRegex, but without it it's way too easy to
@@ -28,7 +29,6 @@
 #  worthwhile tradeoff. When I switched to this method, I found many
 #  examples where I wasn't testing what I thought I was.
 
-
 class TestCase(unittest.TestCase):
     def assertAllRaise(self, exception_type, regex, error_strings):
         for str in error_strings:
@@ -40,45 +40,43 @@ def test__format__lookup(self):
         # Make sure __format__ is looked up on the type, not the instance.
         class X:
             def __format__(self, spec):
-                return "class"
+                return 'class'
 
         x = X()
 
         # Add a bound __format__ method to the 'y' instance, but not
         #  the 'x' instance.
         y = X()
-        y.__format__ = types.MethodType(lambda self, spec: "instance", y)
+        y.__format__ = types.MethodType(lambda self, spec: 'instance', y)
 
-        self.assertEqual(f"{y}", format(y))
-        self.assertEqual(f"{y}", "class")
+        self.assertEqual(f'{y}', format(y))
+        self.assertEqual(f'{y}', 'class')
         self.assertEqual(format(x), format(y))
 
         # __format__ is not called this way, but still make sure it
         #  returns what we expect (so we can make sure we're bypassing
         #  it).
-        self.assertEqual(x.__format__(""), "class")
-        self.assertEqual(y.__format__(""), "instance")
+        self.assertEqual(x.__format__(''), 'class')
+        self.assertEqual(y.__format__(''), 'instance')
 
         # This is how __format__ is actually called.
-        self.assertEqual(type(x).__format__(x, ""), "class")
-        self.assertEqual(type(y).__format__(y, ""), "class")
+        self.assertEqual(type(x).__format__(x, ''), 'class')
+        self.assertEqual(type(y).__format__(y, ''), 'class')
 
     def test_ast(self):
         # Inspired by http://bugs.python.org/issue24975
         class X:
             def __init__(self):
                 self.called = False
-
             def __call__(self):
                 self.called = True
                 return 4
-
         x = X()
         expr = """
 a = 10
 f'{a * x()}'"""
         t = ast.parse(expr)
-        c = compile(t, "", "exec")
+        c = compile(t, '', 'exec')
 
         # Make sure x was not called.
         self.assertFalse(x.called)
@@ -284,6 +282,7 @@ def test_ast_line_numbers_duplicate_expression(self):
         self.assertEqual(binop.right.col_offset, 27)
 
     def test_ast_numbers_fstring_with_formatting(self):
+
         t = ast.parse('f"Here is that pesky {xxx:.3f} again"')
         self.assertEqual(len(t.body), 1)
         self.assertEqual(t.body[0].lineno, 1)
@@ -384,8 +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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ast_line_numbers_with_parentheses(self):
         expr = """
 x = (
@@ -441,12 +439,24 @@ def test_ast_line_numbers_with_parentheses(self):
         x, y = t.body
 
         # Check the single quoted string offsets first.
-        offsets = [(elt.col_offset, elt.end_col_offset) for elt in x.value.elts]
-        self.assertTrue(all(offset == (4, 10) for offset in offsets))
+        offsets = [
+            (elt.col_offset, elt.end_col_offset)
+            for elt in x.value.elts
+        ]
+        self.assertTrue(all(
+            offset == (4, 10)
+            for offset in offsets
+        ))
 
         # Check the triple quoted string offsets.
-        offsets = [(elt.col_offset, elt.end_col_offset) for elt in y.value.elts]
-        self.assertTrue(all(offset == (4, 14) for offset in offsets))
+        offsets = [
+            (elt.col_offset, elt.end_col_offset)
+            for elt in y.value.elts
+        ]
+        self.assertTrue(all(
+            offset == (4, 14)
+            for offset in offsets
+        ))
 
         expr = """
 x = (
@@ -507,612 +517,530 @@ def test_ast_fstring_empty_format_spec(self):
         self.assertEqual(type(format_spec), ast.JoinedStr)
         self.assertEqual(len(format_spec.values), 0)
 
+    def test_ast_fstring_format_spec(self):
+        expr = "f'{1:{name}}'"
+
+        mod = ast.parse(expr)
+        self.assertEqual(type(mod), ast.Module)
+        self.assertEqual(len(mod.body), 1)
+
+        fstring = mod.body[0].value
+        self.assertEqual(type(fstring), ast.JoinedStr)
+        self.assertEqual(len(fstring.values), 1)
+
+        fv = fstring.values[0]
+        self.assertEqual(type(fv), ast.FormattedValue)
+
+        format_spec = fv.format_spec
+        self.assertEqual(type(format_spec), ast.JoinedStr)
+        self.assertEqual(len(format_spec.values), 1)
+
+        format_spec_value = format_spec.values[0]
+        self.assertEqual(type(format_spec_value), ast.FormattedValue)
+        self.assertEqual(format_spec_value.value.id, 'name')
+
+        expr = "f'{1:{name1}{name2}}'"
+
+        mod = ast.parse(expr)
+        self.assertEqual(type(mod), ast.Module)
+        self.assertEqual(len(mod.body), 1)
+
+        fstring = mod.body[0].value
+        self.assertEqual(type(fstring), ast.JoinedStr)
+        self.assertEqual(len(fstring.values), 1)
+
+        fv = fstring.values[0]
+        self.assertEqual(type(fv), ast.FormattedValue)
+
+        format_spec = fv.format_spec
+        self.assertEqual(type(format_spec), ast.JoinedStr)
+        self.assertEqual(len(format_spec.values), 2)
+
+        format_spec_value = format_spec.values[0]
+        self.assertEqual(type(format_spec_value), ast.FormattedValue)
+        self.assertEqual(format_spec_value.value.id, 'name1')
+
+        format_spec_value = format_spec.values[1]
+        self.assertEqual(type(format_spec_value), ast.FormattedValue)
+        self.assertEqual(format_spec_value.value.id, 'name2')
+
+
     def test_docstring(self):
         def f():
-            f"""Not a docstring"""
-
+            f'''Not a docstring'''
         self.assertIsNone(f.__doc__)
-
         def g():
-            """Not a docstring""" f""
-
+            '''Not a docstring''' \
+            f''
         self.assertIsNone(g.__doc__)
 
     def test_literal_eval(self):
-        with self.assertRaisesRegex(ValueError, "malformed node or string"):
+        with self.assertRaisesRegex(ValueError, 'malformed node or string'):
             ast.literal_eval("f'x'")
 
     def test_ast_compile_time_concat(self):
-        x = [""]
+        x = ['']
 
         expr = """x[0] = 'foo' f'{3}'"""
         t = ast.parse(expr)
-        c = compile(t, "", "exec")
+        c = compile(t, '', 'exec')
         exec(c)
-        self.assertEqual(x[0], "foo3")
+        self.assertEqual(x[0], 'foo3')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compile_time_concat_errors(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "cannot mix bytes and nonbytes literals",
-            [
-                r"""f'' b''""",
-                r"""b'' f''""",
-            ],
-        )
+        self.assertAllRaise(SyntaxError,
+                            'cannot mix bytes and nonbytes literals',
+                            [r"""f'' b''""",
+                             r"""b'' f''""",
+                             ])
 
     def test_literal(self):
-        self.assertEqual(f"", "")
-        self.assertEqual(f"a", "a")
-        self.assertEqual(f" ", " ")
+        self.assertEqual(f'', '')
+        self.assertEqual(f'a', 'a')
+        self.assertEqual(f' ', ' ')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unterminated_string(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "unterminated string",
-            [
-                r"""f'{"x'""",
-                r"""f'{"x}'""",
-                r"""f'{("x'""",
-                r"""f'{("x}'""",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, 'unterminated string',
+                            [r"""f'{"x'""",
+                             r"""f'{"x}'""",
+                             r"""f'{("x'""",
+                             r"""f'{("x}'""",
+                             ])
+
+    @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 '\}' " r"does not match opening parenthesis '\('",
-            [
-                "f'{((}'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            r"closing parenthesis '\)' " r"does not match opening parenthesis '\['",
-            [
-                "f'{a[4)}'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            r"closing parenthesis '\]' " r"does not match opening parenthesis '\('",
-            [
-                "f'{a(4]}'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            r"closing parenthesis '\}' " r"does not match opening parenthesis '\['",
-            [
-                "f'{a[4}'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            r"closing parenthesis '\}' " r"does not match opening parenthesis '\('",
-            [
-                "f'{a(4}'",
-            ],
-        )
-        self.assertRaises(SyntaxError, eval, "f'{" + "(" * 500 + "}'")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
+                            r"does not match opening parenthesis '\('",
+                            ["f'{((}'",
+                             ])
+        self.assertAllRaise(SyntaxError, r"closing parenthesis '\)' "
+                            r"does not match opening parenthesis '\['",
+                            ["f'{a[4)}'",
+                            ])
+        self.assertAllRaise(SyntaxError, r"closing parenthesis '\]' "
+                            r"does not match opening parenthesis '\('",
+                            ["f'{a(4]}'",
+                            ])
+        self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
+                            r"does not match opening parenthesis '\['",
+                            ["f'{a[4}'",
+                            ])
+        self.assertAllRaise(SyntaxError, r"closing parenthesis '\}' "
+                            r"does not match opening parenthesis '\('",
+                            ["f'{a(4}'",
+                            ])
+        self.assertRaises(SyntaxError, eval, "f'{" + "("*500 + "}'")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @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}}}}"'],
-        )
+        self.assertAllRaise(SyntaxError,
+                            "f-string: expressions nested too deeply",
+                            ['f"{1+2:{1+2:{1+1:{1}}}}"'])
 
         def create_nested_fstring(n):
             if n == 0:
                 return "1+1"
-            prev = create_nested_fstring(n - 1)
+            prev = create_nested_fstring(n-1)
             return f'f"{{{prev}}}"'
 
-        self.assertAllRaise(
-            SyntaxError, "too many nested f-strings", [create_nested_fstring(160)]
-        )
+        self.assertAllRaise(SyntaxError,
+                            "too many nested f-strings",
+                            [create_nested_fstring(160)])
 
     def test_syntax_error_in_nested_fstring(self):
         # See gh-104016 for more information on this crash
-        self.assertAllRaise(
-            SyntaxError, "invalid syntax", ['f"{1 1:' + ('{f"1:' * 199)]
-        )
+        self.assertAllRaise(SyntaxError,
+                            "invalid syntax",
+                            ['f"{1 1:' + ('{f"1:' * 199)])
 
     def test_double_braces(self):
-        self.assertEqual(f"{{", "{")
-        self.assertEqual(f"a{{", "a{")
-        self.assertEqual(f"{{b", "{b")
-        self.assertEqual(f"a{{b", "a{b")
-        self.assertEqual(f"}}", "}")
-        self.assertEqual(f"a}}", "a}")
-        self.assertEqual(f"}}b", "}b")
-        self.assertEqual(f"a}}b", "a}b")
-        self.assertEqual(f"{{}}", "{}")
-        self.assertEqual(f"a{{}}", "a{}")
-        self.assertEqual(f"{{b}}", "{b}")
-        self.assertEqual(f"{{}}c", "{}c")
-        self.assertEqual(f"a{{b}}", "a{b}")
-        self.assertEqual(f"a{{}}c", "a{}c")
-        self.assertEqual(f"{{b}}c", "{b}c")
-        self.assertEqual(f"a{{b}}c", "a{b}c")
-
-        self.assertEqual(f"{{{10}", "{10")
-        self.assertEqual(f"}}{10}", "}10")
-        self.assertEqual(f"}}{{{10}", "}{10")
-        self.assertEqual(f"}}a{{{10}", "}a{10")
-
-        self.assertEqual(f"{10}{{", "10{")
-        self.assertEqual(f"{10}}}", "10}")
-        self.assertEqual(f"{10}}}{{", "10}{")
-        self.assertEqual(f"{10}}}a{{" "}", "10}a{}")
+        self.assertEqual(f'{{', '{')
+        self.assertEqual(f'a{{', 'a{')
+        self.assertEqual(f'{{b', '{b')
+        self.assertEqual(f'a{{b', 'a{b')
+        self.assertEqual(f'}}', '}')
+        self.assertEqual(f'a}}', 'a}')
+        self.assertEqual(f'}}b', '}b')
+        self.assertEqual(f'a}}b', 'a}b')
+        self.assertEqual(f'{{}}', '{}')
+        self.assertEqual(f'a{{}}', 'a{}')
+        self.assertEqual(f'{{b}}', '{b}')
+        self.assertEqual(f'{{}}c', '{}c')
+        self.assertEqual(f'a{{b}}', 'a{b}')
+        self.assertEqual(f'a{{}}c', 'a{}c')
+        self.assertEqual(f'{{b}}c', '{b}c')
+        self.assertEqual(f'a{{b}}c', 'a{b}c')
+
+        self.assertEqual(f'{{{10}', '{10')
+        self.assertEqual(f'}}{10}', '}10')
+        self.assertEqual(f'}}{{{10}', '}{10')
+        self.assertEqual(f'}}a{{{10}', '}a{10')
+
+        self.assertEqual(f'{10}{{', '10{')
+        self.assertEqual(f'{10}}}', '10}')
+        self.assertEqual(f'{10}}}{{', '10}{')
+        self.assertEqual(f'{10}}}a{{' '}', '10}a{}')
 
         # Inside of strings, don't interpret doubled brackets.
-        self.assertEqual(f'{"{{}}"}', "{{}}")
-
-        self.assertAllRaise(
-            TypeError,
-            "unhashable type",
-            [
-                "f'{ {{}} }'",  # dict in a set
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f'{"{{}}"}', '{{}}')
+
+        self.assertAllRaise(TypeError, 'unhashable type',
+                            ["f'{ {{}} }'", # dict in a set
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_compile_time_concat(self):
-        x = "def"
-        self.assertEqual("abc" f"## {x}ghi", "abc## defghi")
-        self.assertEqual("abc" f"{x}" "ghi", "abcdefghi")
-        self.assertEqual("abc" f"{x}" "gh" f"i{x:4}", "abcdefghidef ")
-        self.assertEqual("{x}" f"{x}", "{x}def")
-        self.assertEqual("{x" f"{x}", "{xdef")
-        self.assertEqual("{x}" f"{x}", "{x}def")
-        self.assertEqual("{{x}}" f"{x}", "{{x}}def")
-        self.assertEqual("{{x" f"{x}", "{{xdef")
-        self.assertEqual("x}}" f"{x}", "x}}def")
-        self.assertEqual(f"{x}" "x}}", "defx}}")
-        self.assertEqual(f"{x}" "", "def")
-        self.assertEqual("" f"{x}" "", "def")
-        self.assertEqual("" f"{x}", "def")
-        self.assertEqual(f"{x}" "2", "def2")
-        self.assertEqual("1" f"{x}" "2", "1def2")
-        self.assertEqual("1" f"{x}", "1def")
-        self.assertEqual(f"{x}" f"-{x}", "def-def")
-        self.assertEqual("" f"", "")
-        self.assertEqual("" f"" "", "")
-        self.assertEqual("" f"" "" f"", "")
-        self.assertEqual(f"", "")
-        self.assertEqual(f"" "", "")
-        self.assertEqual(f"" "" f"", "")
-        self.assertEqual(f"" "" f"" "", "")
+        x = 'def'
+        self.assertEqual('abc' f'## {x}ghi', 'abc## defghi')
+        self.assertEqual('abc' f'{x}' 'ghi', 'abcdefghi')
+        self.assertEqual('abc' f'{x}' 'gh' f'i{x:4}', 'abcdefghidef ')
+        self.assertEqual('{x}' f'{x}', '{x}def')
+        self.assertEqual('{x' f'{x}', '{xdef')
+        self.assertEqual('{x}' f'{x}', '{x}def')
+        self.assertEqual('{{x}}' f'{x}', '{{x}}def')
+        self.assertEqual('{{x' f'{x}', '{{xdef')
+        self.assertEqual('x}}' f'{x}', 'x}}def')
+        self.assertEqual(f'{x}' 'x}}', 'defx}}')
+        self.assertEqual(f'{x}' '', 'def')
+        self.assertEqual('' f'{x}' '', 'def')
+        self.assertEqual('' f'{x}', 'def')
+        self.assertEqual(f'{x}' '2', 'def2')
+        self.assertEqual('1' f'{x}' '2', '1def2')
+        self.assertEqual('1' f'{x}', '1def')
+        self.assertEqual(f'{x}' f'-{x}', 'def-def')
+        self.assertEqual('' f'', '')
+        self.assertEqual('' f'' '', '')
+        self.assertEqual('' f'' '' f'', '')
+        self.assertEqual(f'', '')
+        self.assertEqual(f'' '', '')
+        self.assertEqual(f'' '' f'', '')
+        self.assertEqual(f'' '' f'' '', '')
 
         # This is not really [f'{'] + [f'}'] since we treat the inside
         # of braces as a purely new context, so it is actually f'{ and
         # then eval('  f') (a valid expression) and then }' which would
         # constitute a valid f-string.
-        # TODO: RUSTPYTHON SyntaxError
-        # self.assertEqual(f'{' f'}', " f")
-
-        self.assertAllRaise(
-            SyntaxError,
-            "expecting '}'",
-            [
-                '''f'{3' f"}"''',  # can't concat to get a valid f-string
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f'{' f'}', ' f')
+
+        self.assertAllRaise(SyntaxError, "expecting '}'",
+                            ['''f'{3' f"}"''',  # can't concat to get a valid f-string
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_comments(self):
         # These aren't comments, since they're in strings.
-        d = {"#": "hash"}
-        self.assertEqual(f'{"#"}', "#")
-        self.assertEqual(f'{d["#"]}', "hash")
-
-        self.assertAllRaise(
-            SyntaxError,
-            "'{' was never closed",
-            [
-                "f'{1#}'",  # error because everything after '#' is a comment
-                "f'{#}'",
-                "f'one: {1#}'",
-                "f'{1# one} {2 this is a comment still#}'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            r"f-string: unmatched '\)'",
-            [
-                "f'{)#}'",  # When wrapped in parens, this becomes
-                #  '()#)'.  Make sure that doesn't compile.
-            ],
-        )
-        self.assertEqual(
-            f"""A complex trick: {
+        d = {'#': 'hash'}
+        self.assertEqual(f'{"#"}', '#')
+        self.assertEqual(f'{d["#"]}', 'hash')
+
+        self.assertAllRaise(SyntaxError, "'{' was never closed",
+                            ["f'{1#}'",   # error because everything after '#' is a comment
+                             "f'{#}'",
+                             "f'one: {1#}'",
+                             "f'{1# one} {2 this is a comment still#}'",
+                             ])
+        self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
+                            ["f'{)#}'",   # When wrapped in parens, this becomes
+                                          #  '()#)'.  Make sure that doesn't compile.
+                             ])
+        self.assertEqual(f'''A complex trick: {
 2  # two
-}""",
-            "A complex trick: 2",
-        )
-        self.assertEqual(
-            f"""
+}''', 'A complex trick: 2')
+        self.assertEqual(f'''
 {
 40 # forty
 +  # plus
 2  # two
-}""",
-            "\n42",
-        )
-        self.assertEqual(
-            f"""
+}''', '\n42')
+        self.assertEqual(f'''
 {
 40 # forty
 +  # plus
 2  # two
-}""",
-            "\n42",
-        )
-# TODO: RUSTPYTHON SyntaxError
-#         self.assertEqual(
-#             f"""
-# # this is not a comment
-# { # the following operation it's
-# 3 # this is a number
-# * 2}""",
-#             "\n# this is not a comment\n6",
-#         )
-        self.assertEqual(
-            f"""
+}''', '\n42')
+
+        self.assertEqual(f'''
+# this is not a comment
+{ # the following operation it's
+3 # this is a number
+* 2}''', '\n# this is not a comment\n6')
+        self.assertEqual(f'''
 {# f'a {comment}'
 86 # constant
 # nothing more
-}""",
-            "\n86",
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            r"f-string: valid expression required before '}'",
-            [
-                """f'''
+}''', '\n86')
+
+        self.assertAllRaise(SyntaxError, r"f-string: valid expression required before '}'",
+                            ["""f'''
 {
 # only a comment
 }'''
-""",  # this is equivalent to f'{}'
-            ],
-        )
+""", # this is equivalent to f'{}'
+                             ])
 
     def test_many_expressions(self):
         # Create a string with many expressions in it. Note that
         #  because we have a space in here as a literal, we're actually
         #  going to use twice as many ast nodes: one for each literal
         #  plus one for each expression.
-        def build_fstr(n, extra=""):
-            return "f'" + ("{x} " * n) + extra + "'"
+        def build_fstr(n, extra=''):
+            return "f'" + ('{x} ' * n) + extra + "'"
 
-        x = "X"
+        x = 'X'
         width = 1
 
         # Test around 256.
         for i in range(250, 260):
-            self.assertEqual(eval(build_fstr(i)), (x + " ") * i)
+            self.assertEqual(eval(build_fstr(i)), (x+' ')*i)
 
         # Test concatenating 2 largs fstrings.
-        self.assertEqual(eval(build_fstr(255) * 256), (x + " ") * (255 * 256))
+        self.assertEqual(eval(build_fstr(255)*256), (x+' ')*(255*256))
 
-        s = build_fstr(253, "{x:{width}} ")
-        self.assertEqual(eval(s), (x + " ") * 254)
+        s = build_fstr(253, '{x:{width}} ')
+        self.assertEqual(eval(s), (x+' ')*254)
 
         # Test lots of expressions and constants, concatenated.
         s = "f'{1}' 'x' 'y'" * 1024
-        self.assertEqual(eval(s), "1xy" * 1024)
+        self.assertEqual(eval(s), '1xy' * 1024)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_format_specifier_expressions(self):
         width = 10
         precision = 4
-        value = decimal.Decimal("12.34567")
-        self.assertEqual(f"result: {value:{width}.{precision}}", "result:      12.35")
-        self.assertEqual(f"result: {value:{width!r}.{precision}}", "result:      12.35")
-        self.assertEqual(
-            f"result: {value:{width:0}.{precision:1}}", "result:      12.35"
-        )
-        self.assertEqual(
-            f"result: {value:{1}{0:0}.{precision:1}}", "result:      12.35"
-        )
-        self.assertEqual(
-            f"result: {value:{ 1}{ 0:0}.{ precision:1}}", "result:      12.35"
-        )
-        self.assertEqual(f"{10:#{1}0x}", "       0xa")
-        self.assertEqual(f'{10:{"#"}1{0}{"x"}}', "       0xa")
-        self.assertEqual(f'{-10:-{"#"}1{0}x}', "      -0xa")
-        self.assertEqual(f'{-10:{"-"}#{1}0{"x"}}', "      -0xa")
-        self.assertEqual(f"{10:#{3 != {4:5} and width}x}", "       0xa")
-
-        # TODO: RUSTPYTHON SyntaxError
-        # self.assertEqual(
-        #     f"result: {value:{width:{0}}.{precision:1}}", "result:      12.35"
-        # )
-
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting ':' or '}'",
-            [
-                """f'{"s"!r{":10"}}'""",
-                # This looks like a nested format spec.
-            ],
-        )
-
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting a valid expression after '{'",
-            [  # Invalid syntax inside a nested spec.
-                "f'{4:{/5}}'",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: invalid conversion character",
-            [  # No expansion inside conversion or for
-                #  the : or ! itself.
-                """f'{"s"!{"r"}}'""",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        value = decimal.Decimal('12.34567')
+        self.assertEqual(f'result: {value:{width}.{precision}}', 'result:      12.35')
+        self.assertEqual(f'result: {value:{width!r}.{precision}}', 'result:      12.35')
+        self.assertEqual(f'result: {value:{width:0}.{precision:1}}', 'result:      12.35')
+        self.assertEqual(f'result: {value:{1}{0:0}.{precision:1}}', 'result:      12.35')
+        self.assertEqual(f'result: {value:{ 1}{ 0:0}.{ precision:1}}', 'result:      12.35')
+        self.assertEqual(f'{10:#{1}0x}', '       0xa')
+        self.assertEqual(f'{10:{"#"}1{0}{"x"}}', '       0xa')
+        self.assertEqual(f'{-10:-{"#"}1{0}x}', '      -0xa')
+        self.assertEqual(f'{-10:{"-"}#{1}0{"x"}}', '      -0xa')
+        self.assertEqual(f'{10:#{3 != {4:5} and width}x}', '       0xa')
+        self.assertEqual(f'result: {value:{width:{0}}.{precision:1}}', 'result:      12.35')
+
+        self.assertAllRaise(SyntaxError, "f-string: expecting ':' or '}'",
+                            ["""f'{"s"!r{":10"}}'""",
+                             # This looks like a nested format spec.
+                             ])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: expecting a valid expression after '{'",
+                            [# Invalid syntax inside a nested spec.
+                             "f'{4:{/5}}'",
+                             ])
+
+        self.assertAllRaise(SyntaxError, 'f-string: invalid conversion character',
+                            [# No expansion inside conversion or for
+                             #  the : or ! itself.
+                             """f'{"s"!{"r"}}'""",
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_custom_format_specifier(self):
         class CustomFormat:
             def __format__(self, format_spec):
                 return format_spec
 
-        self.assertEqual(f"{CustomFormat():\n}", "\n")
-        self.assertEqual(f"{CustomFormat():\u2603}", "☃")
+        self.assertEqual(f'{CustomFormat():\n}', '\n')
+        self.assertEqual(f'{CustomFormat():\u2603}', '☃')
         with self.assertWarns(SyntaxWarning):
-            exec(r'f"{F():¯\_(ツ)_/¯}"', {"F": CustomFormat})
+            exec(r'f"{F():¯\_(ツ)_/¯}"', {'F': CustomFormat})
 
     def test_side_effect_order(self):
         class X:
             def __init__(self):
                 self.i = 0
-
             def __format__(self, spec):
                 self.i += 1
                 return str(self.i)
 
         x = X()
-        self.assertEqual(f"{x} {x}", "1 2")
+        self.assertEqual(f'{x} {x}', '1 2')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_missing_expression(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: valid expression required before '}'",
-            [
-                "f'{}'",
-                "f'{ }'" "f' {} '",
-                "f'{10:{ }}'",
-                "f' { } '",
-                # The Python parser ignores also the following
-                # whitespace characters in additional to a space.
-                "f'''{\t\f\r\n}'''",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: valid expression required before '!'",
-            [
-                "f'{!r}'",
-                "f'{ !r}'",
-                "f'{!}'",
-                "f'''{\t\f\r\n!a}'''",
-                # Catch empty expression before the
-                #  missing closing brace.
-                "f'{!'",
-                "f'{!s:'",
-                # Catch empty expression before the
-                #  invalid conversion.
-                "f'{!x}'",
-                "f'{ !xr}'",
-                "f'{!x:}'",
-                "f'{!x:a}'",
-                "f'{ !xr:}'",
-                "f'{ !xr:a}'",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: valid expression required before ':'",
-            [
-                "f'{:}'",
-                "f'{ :!}'",
-                "f'{:2}'",
-                "f'''{\t\f\r\n:a}'''",
-                "f'{:'",
-                "F'{[F'{:'}[F'{:'}]]]",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: valid expression required before '='",
-            [
-                "f'{=}'",
-                "f'{ =}'",
-                "f'{ =:}'",
-                "f'{   =!}'",
-                "f'''{\t\f\r\n=}'''",
-                "f'{='",
-            ],
-        )
+        self.assertAllRaise(SyntaxError,
+                            "f-string: valid expression required before '}'",
+                            ["f'{}'",
+                             "f'{ }'"
+                             "f' {} '",
+                             "f'{10:{ }}'",
+                             "f' { } '",
+
+                             # The Python parser ignores also the following
+                             # whitespace characters in additional to a space.
+                             "f'''{\t\f\r\n}'''",
+                             ])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: valid expression required before '!'",
+                            ["f'{!r}'",
+                             "f'{ !r}'",
+                             "f'{!}'",
+                             "f'''{\t\f\r\n!a}'''",
+
+                             # Catch empty expression before the
+                             #  missing closing brace.
+                             "f'{!'",
+                             "f'{!s:'",
+
+                             # Catch empty expression before the
+                             #  invalid conversion.
+                             "f'{!x}'",
+                             "f'{ !xr}'",
+                             "f'{!x:}'",
+                             "f'{!x:a}'",
+                             "f'{ !xr:}'",
+                             "f'{ !xr:a}'",
+                             ])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: valid expression required before ':'",
+                            ["f'{:}'",
+                             "f'{ :!}'",
+                             "f'{:2}'",
+                             "f'''{\t\f\r\n:a}'''",
+                             "f'{:'",
+                             "F'{[F'{:'}[F'{:'}]]]",
+                             ])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: valid expression required before '='",
+                            ["f'{=}'",
+                             "f'{ =}'",
+                             "f'{ =:}'",
+                             "f'{   =!}'",
+                             "f'''{\t\f\r\n=}'''",
+                             "f'{='",
+                             ])
 
         # Different error message is raised for other whitespace characters.
-        self.assertAllRaise(
-            SyntaxError,
-            r"invalid non-printable character U\+00A0",
-            [
-                "f'''{\xa0}'''",
-                "\xa0",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, r"invalid non-printable character U\+00A0",
+                            ["f'''{\xa0}'''",
+                             "\xa0",
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parens_in_expressions(self):
-        self.assertEqual(f"{3,}", "(3,)")
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting a valid expression after '{'",
-            [
-                "f'{,}'",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            r"f-string: unmatched '\)'",
-            [
-                "f'{3)+(4}'",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f'{3,}', '(3,)')
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: expecting a valid expression after '{'",
+                            ["f'{,}'",
+                             ])
+
+        self.assertAllRaise(SyntaxError, r"f-string: unmatched '\)'",
+                            ["f'{3)+(4}'",
+                             ])
+
+    @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'{.}'"],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        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")
-        self.assertEqual(rf"\t", "\\t")
-        self.assertEqual(f"{2}\t", "2\t")
-        self.assertEqual(f"{2}\t{3}", "2\t3")
-        self.assertEqual(f"\t{3}", "\t3")
-
-        self.assertEqual(f"\u0394", "\u0394")
-        self.assertEqual(r"\u0394", "\\u0394")
-        self.assertEqual(rf"\u0394", "\\u0394")
-        self.assertEqual(f"{2}\u0394", "2\u0394")
-        self.assertEqual(f"{2}\u0394{3}", "2\u03943")
-        self.assertEqual(f"\u0394{3}", "\u03943")
-
-        self.assertEqual(f"\U00000394", "\u0394")
-        self.assertEqual(r"\U00000394", "\\U00000394")
-        self.assertEqual(rf"\U00000394", "\\U00000394")
-        self.assertEqual(f"{2}\U00000394", "2\u0394")
-        self.assertEqual(f"{2}\U00000394{3}", "2\u03943")
-        self.assertEqual(f"\U00000394{3}", "\u03943")
-
-        self.assertEqual(f"\N{GREEK CAPITAL LETTER DELTA}", "\u0394")
-        self.assertEqual(f"{2}\N{GREEK CAPITAL LETTER DELTA}", "2\u0394")
-        self.assertEqual(f"{2}\N{GREEK CAPITAL LETTER DELTA}{3}", "2\u03943")
-        self.assertEqual(f"\N{GREEK CAPITAL LETTER DELTA}{3}", "\u03943")
-        self.assertEqual(f"2\N{GREEK CAPITAL LETTER DELTA}", "2\u0394")
-        self.assertEqual(f"2\N{GREEK CAPITAL LETTER DELTA}3", "2\u03943")
-        self.assertEqual(f"\N{GREEK CAPITAL LETTER DELTA}3", "\u03943")
-
-        self.assertEqual(f"\x20", " ")
-        self.assertEqual(r"\x20", "\\x20")
-        self.assertEqual(rf"\x20", "\\x20")
-        self.assertEqual(f"{2}\x20", "2 ")
-        self.assertEqual(f"{2}\x20{3}", "2 3")
-        self.assertEqual(f"\x20{3}", " 3")
-
-        self.assertEqual(f"2\x20", "2 ")
-        self.assertEqual(f"2\x203", "2 3")
-        self.assertEqual(f"\x203", " 3")
+        self.assertEqual(f'\t', '\t')
+        self.assertEqual(r'\t', '\\t')
+        self.assertEqual(rf'\t', '\\t')
+        self.assertEqual(f'{2}\t', '2\t')
+        self.assertEqual(f'{2}\t{3}', '2\t3')
+        self.assertEqual(f'\t{3}', '\t3')
+
+        self.assertEqual(f'\u0394', '\u0394')
+        self.assertEqual(r'\u0394', '\\u0394')
+        self.assertEqual(rf'\u0394', '\\u0394')
+        self.assertEqual(f'{2}\u0394', '2\u0394')
+        self.assertEqual(f'{2}\u0394{3}', '2\u03943')
+        self.assertEqual(f'\u0394{3}', '\u03943')
+
+        self.assertEqual(f'\U00000394', '\u0394')
+        self.assertEqual(r'\U00000394', '\\U00000394')
+        self.assertEqual(rf'\U00000394', '\\U00000394')
+        self.assertEqual(f'{2}\U00000394', '2\u0394')
+        self.assertEqual(f'{2}\U00000394{3}', '2\u03943')
+        self.assertEqual(f'\U00000394{3}', '\u03943')
+
+        self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}', '\u0394')
+        self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
+        self.assertEqual(f'{2}\N{GREEK CAPITAL LETTER DELTA}{3}', '2\u03943')
+        self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}{3}', '\u03943')
+        self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}', '2\u0394')
+        self.assertEqual(f'2\N{GREEK CAPITAL LETTER DELTA}3', '2\u03943')
+        self.assertEqual(f'\N{GREEK CAPITAL LETTER DELTA}3', '\u03943')
+
+        self.assertEqual(f'\x20', ' ')
+        self.assertEqual(r'\x20', '\\x20')
+        self.assertEqual(rf'\x20', '\\x20')
+        self.assertEqual(f'{2}\x20', '2 ')
+        self.assertEqual(f'{2}\x20{3}', '2 3')
+        self.assertEqual(f'\x20{3}', ' 3')
+
+        self.assertEqual(f'2\x20', '2 ')
+        self.assertEqual(f'2\x203', '2 3')
+        self.assertEqual(f'\x203', ' 3')
 
         with self.assertWarns(SyntaxWarning):  # invalid escape sequence
             value = eval(r"f'\{6*7}'")
-        self.assertEqual(value, "\\42")
+        self.assertEqual(value, '\\42')
         with self.assertWarns(SyntaxWarning):  # invalid escape sequence
             value = eval(r"f'\g'")
-        self.assertEqual(value, "\\g")
-        self.assertEqual(f"\\{6*7}", "\\42")
-        self.assertEqual(rf"\{6*7}", "\\42")
+        self.assertEqual(value, '\\g')
+        self.assertEqual(f'\\{6*7}', '\\42')
+        self.assertEqual(fr'\{6*7}', '\\42')
 
-        AMPERSAND = "spam"
+        AMPERSAND = 'spam'
         # Get the right unicode character (&), or pick up local variable
         # depending on the number of backslashes.
-        self.assertEqual(f"\N{AMPERSAND}", "&")
-        self.assertEqual(f"\\N{AMPERSAND}", "\\Nspam")
-        self.assertEqual(rf"\N{AMPERSAND}", "\\Nspam")
-        self.assertEqual(f"\\\N{AMPERSAND}", "\\&")
+        self.assertEqual(f'\N{AMPERSAND}', '&')
+        self.assertEqual(f'\\N{AMPERSAND}', '\\Nspam')
+        self.assertEqual(fr'\N{AMPERSAND}', '\\Nspam')
+        self.assertEqual(f'\\\N{AMPERSAND}', '\\&')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_misformed_unicode_character_name(self):
         # These test are needed because unicode names are parsed
         # differently inside f-strings.
-        self.assertAllRaise(
-            SyntaxError,
-            r"\(unicode error\) 'unicodeescape' codec can't decode bytes in position .*: malformed \\N character escape",
-            [
-                r"f'\N'",
-                r"f'\N '",
-                r"f'\N  '",  # See bpo-46503.
-                r"f'\N{'",
-                r"f'\N{GREEK CAPITAL LETTER DELTA'",
-                # Here are the non-f-string versions,
-                #  which should give the same errors.
-                r"'\N'",
-                r"'\N '",
-                r"'\N  '",
-                r"'\N{'",
-                r"'\N{GREEK CAPITAL LETTER DELTA'",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, r"\(unicode error\) 'unicodeescape' codec can't decode bytes in position .*: malformed \\N character escape",
+                            [r"f'\N'",
+                             r"f'\N '",
+                             r"f'\N  '",  # See bpo-46503.
+                             r"f'\N{'",
+                             r"f'\N{GREEK CAPITAL LETTER DELTA'",
+
+                             # Here are the non-f-string versions,
+                             #  which should give the same errors.
+                             r"'\N'",
+                             r"'\N '",
+                             r"'\N  '",
+                             r"'\N{'",
+                             r"'\N{GREEK CAPITAL LETTER DELTA'",
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_backslashes_in_expression_part(self):
-        # TODO: RUSTPYTHON SyntaxError
-        # self.assertEqual(
-        #     f"{(
-        #                 1 +
-        #                 2
-        # )}",
-        #     "3",
-        # )
-
-        self.assertEqual("\N{LEFT CURLY BRACKET}", "{")
-        self.assertEqual(f'{"\N{LEFT CURLY BRACKET}"}', "{")
-        self.assertEqual(rf'{"\N{LEFT CURLY BRACKET}"}', "{")
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: valid expression required before '}'",
-            [
-                "f'{\n}'",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f"{(
+                        1 +
+                        2
+        )}", "3")
+
+        self.assertEqual("\N{LEFT CURLY BRACKET}", '{')
+        self.assertEqual(f'{"\N{LEFT CURLY BRACKET}"}', '{')
+        self.assertEqual(rf'{"\N{LEFT CURLY BRACKET}"}', '{')
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: valid expression required before '}'",
+                            ["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.
@@ -1129,30 +1057,25 @@ def test_invalid_backslashes_inside_fstring_context(self):
                 r"\\"[0],
             ]
         ]
-        self.assertAllRaise(
-            SyntaxError, "unexpected character after line continuation", cases
-        )
+        self.assertAllRaise(SyntaxError, 'unexpected character after line continuation',
+                            cases)
 
     def test_no_escapes_for_braces(self):
         """
         Only literal curly braces begin an expression.
         """
         # \x7b is '{'.
-        self.assertEqual(f"\x7b1+1}}", "{1+1}")
-        self.assertEqual(f"\x7b1+1", "{1+1")
-        self.assertEqual(f"\u007b1+1", "{1+1")
-        self.assertEqual(f"\N{LEFT CURLY BRACKET}1+1\N{RIGHT CURLY BRACKET}", "{1+1}")
+        self.assertEqual(f'\x7b1+1}}', '{1+1}')
+        self.assertEqual(f'\x7b1+1', '{1+1')
+        self.assertEqual(f'\u007b1+1', '{1+1')
+        self.assertEqual(f'\N{LEFT CURLY BRACKET}1+1\N{RIGHT CURLY BRACKET}', '{1+1}')
 
     def test_newlines_in_expressions(self):
-        self.assertEqual(f"{0}", "0")
-        self.assertEqual(
-            rf"""{3+
-4}""",
-            "7",
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f'{0}', '0')
+        self.assertEqual(rf'''{3+
+4}''', '7')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lambda(self):
         x = 5
         self.assertEqual(f'{(lambda y:x*y)("8")!r}', "'88888'")
@@ -1162,67 +1085,60 @@ def test_lambda(self):
         # lambda doesn't work without parens, because the colon
         # makes the parser think it's a format_spec
         # emit warning if we can match a format_spec
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: lambda expressions are not allowed " "without parentheses",
-            [
-                "f'{lambda x:x}'",
-                "f'{lambda :x}'",
-                "f'{lambda *arg, :x}'",
-                "f'{1, lambda:x}'",
-                "f'{lambda x:}'",
-                "f'{lambda :}'",
-            ],
-        )
+        self.assertAllRaise(SyntaxError,
+                            "f-string: lambda expressions are not allowed "
+                            "without parentheses",
+                            ["f'{lambda x:x}'",
+                             "f'{lambda :x}'",
+                             "f'{lambda *arg, :x}'",
+                             "f'{1, lambda:x}'",
+                             "f'{lambda x:}'",
+                             "f'{lambda :}'",
+                             ])
         # Ensure the detection of invalid lambdas doesn't trigger detection
         # for valid lambdas in the second error pass
         with self.assertRaisesRegex(SyntaxError, "invalid syntax"):
             compile("lambda name_3=f'{name_4}': {name_3}\n1 $ 1", "<string>", "exec")
 
         # but don't emit the paren warning in general cases
-        with self.assertRaisesRegex(
-            SyntaxError, "f-string: expecting a valid expression after '{'"
-        ):
+        with self.assertRaisesRegex(SyntaxError, "f-string: expecting a valid expression after '{'"):
             eval("f'{+ lambda:None}'")
 
     def test_valid_prefixes(self):
-        self.assertEqual(f"{1}", "1")
-        self.assertEqual(Rf"{2}", "2")
-        self.assertEqual(Rf"{3}", "3")
+        self.assertEqual(F'{1}', "1")
+        self.assertEqual(FR'{2}', "2")
+        self.assertEqual(fR'{3}', "3")
 
     def test_roundtrip_raw_quotes(self):
-        self.assertEqual(rf"\'", "\\'")
-        self.assertEqual(rf"\"", '\\"')
-        self.assertEqual(rf"\"\'", "\\\"\\'")
-        self.assertEqual(rf"\'\"", "\\'\\\"")
-        self.assertEqual(rf"\"\'\"", '\\"\\\'\\"')
-        self.assertEqual(rf"\'\"\'", "\\'\\\"\\'")
-        self.assertEqual(rf"\"\'\"\'", "\\\"\\'\\\"\\'")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(fr"\'", "\\'")
+        self.assertEqual(fr'\"', '\\"')
+        self.assertEqual(fr'\"\'', '\\"\\\'')
+        self.assertEqual(fr'\'\"', '\\\'\\"')
+        self.assertEqual(fr'\"\'\"', '\\"\\\'\\"')
+        self.assertEqual(fr'\'\"\'', '\\\'\\"\\\'')
+        self.assertEqual(fr'\"\'\"\'', '\\"\\\'\\"\\\'')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fstring_backslash_before_double_bracket(self):
         deprecated_cases = [
-            (r"f'\{{\}}'", "\\{\\}"),
-            (r"f'\{{'", "\\{"),
-            (r"f'\{{{1+1}'", "\\{2"),
-            (r"f'\}}{1+1}'", "\\}2"),
-            (r"f'{1+1}\}}'", "2\\}"),
+            (r"f'\{{\}}'",   '\\{\\}'),
+            (r"f'\{{'",      '\\{'),
+            (r"f'\{{{1+1}'", '\\{2'),
+            (r"f'\}}{1+1}'", '\\}2'),
+            (r"f'{1+1}\}}'", '2\\}')
         ]
-
         for case, expected_result in deprecated_cases:
             with self.subTest(case=case, expected_result=expected_result):
                 with self.assertWarns(SyntaxWarning):
                     result = eval(case)
                 self.assertEqual(result, expected_result)
-        self.assertEqual(rf"\{{\}}", "\\{\\}")
-        self.assertEqual(rf"\{{", "\\{")
-        self.assertEqual(rf"\{{{1+1}", "\\{2")
-        self.assertEqual(rf"\}}{1+1}", "\\}2")
-        self.assertEqual(rf"{1+1}\}}", "2\\}")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(fr'\{{\}}', '\\{\\}')
+        self.assertEqual(fr'\{{', '\\{')
+        self.assertEqual(fr'\{{{1+1}', '\\{2')
+        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'\{{'")
@@ -1230,18 +1146,18 @@ def test_fstring_backslash_before_double_bracket_warns_once(self):
         self.assertEqual(w.warnings[0].category, SyntaxWarning)
 
     def test_fstring_backslash_prefix_raw(self):
-        self.assertEqual(f"\\", "\\")
-        self.assertEqual(f"\\\\", "\\\\")
-        self.assertEqual(rf"\\", r"\\")
-        self.assertEqual(rf"\\\\", r"\\\\")
-        self.assertEqual(rf"\\", r"\\")
-        self.assertEqual(rf"\\\\", r"\\\\")
-        self.assertEqual(Rf"\\", R"\\")
-        self.assertEqual(Rf"\\\\", R"\\\\")
-        self.assertEqual(Rf"\\", R"\\")
-        self.assertEqual(Rf"\\\\", R"\\\\")
-        self.assertEqual(Rf"\\", R"\\")
-        self.assertEqual(Rf"\\\\", R"\\\\")
+        self.assertEqual(f'\\', '\\')
+        self.assertEqual(f'\\\\', '\\\\')
+        self.assertEqual(fr'\\', r'\\')
+        self.assertEqual(fr'\\\\', r'\\\\')
+        self.assertEqual(rf'\\', r'\\')
+        self.assertEqual(rf'\\\\', r'\\\\')
+        self.assertEqual(Rf'\\', R'\\')
+        self.assertEqual(Rf'\\\\', R'\\\\')
+        self.assertEqual(fR'\\', R'\\')
+        self.assertEqual(fR'\\\\', R'\\\\')
+        self.assertEqual(FR'\\', R'\\')
+        self.assertEqual(FR'\\\\', R'\\\\')
 
     def test_fstring_format_spec_greedy_matching(self):
         self.assertEqual(f"{1:}}}", "1}")
@@ -1251,8 +1167,8 @@ def test_yield(self):
         # Not terribly useful, but make sure the yield turns
         #  a function into a generator
         def fn(y):
-            f"y:{yield y*2}"
-            f"{yield}"
+            f'y:{yield y*2}'
+            f'{yield}'
 
         g = fn(4)
         self.assertEqual(next(g), 8)
@@ -1260,331 +1176,287 @@ def fn(y):
 
     def test_yield_send(self):
         def fn(x):
-            yield f"x:{yield (lambda i: x * i)}"
+            yield f'x:{yield (lambda i: x * i)}'
 
         g = fn(10)
         the_lambda = next(g)
         self.assertEqual(the_lambda(4), 40)
-        self.assertEqual(g.send("string"), "x:string")
+        self.assertEqual(g.send('string'), 'x:string')
 
-    # TODO: RUSTPYTHON SyntaxError
-    # def test_expressions_with_triple_quoted_strings(self):
-    #     self.assertEqual(f"{'''x'''}", 'x')
-    #     self.assertEqual(f"{'''eric's'''}", "eric's")
+    def test_expressions_with_triple_quoted_strings(self):
+        self.assertEqual(f"{'''x'''}", 'x')
+        self.assertEqual(f"{'''eric's'''}", "eric's")
 
-    #     # Test concatenation within an expression
-    #     self.assertEqual(f'{"x" """eric"s""" "y"}', 'xeric"sy')
-    #     self.assertEqual(f'{"x" """eric"s"""}', 'xeric"s')
-    #     self.assertEqual(f'{"""eric"s""" "y"}', 'eric"sy')
-    #     self.assertEqual(f'{"""x""" """eric"s""" "y"}', 'xeric"sy')
-    #     self.assertEqual(f'{"""x""" """eric"s""" """y"""}', 'xeric"sy')
-    #     self.assertEqual(f'{r"""x""" """eric"s""" """y"""}', 'xeric"sy')
+        # Test concatenation within an expression
+        self.assertEqual(f'{"x" """eric"s""" "y"}', 'xeric"sy')
+        self.assertEqual(f'{"x" """eric"s"""}', 'xeric"s')
+        self.assertEqual(f'{"""eric"s""" "y"}', 'eric"sy')
+        self.assertEqual(f'{"""x""" """eric"s""" "y"}', 'xeric"sy')
+        self.assertEqual(f'{"""x""" """eric"s""" """y"""}', 'xeric"sy')
+        self.assertEqual(f'{r"""x""" """eric"s""" """y"""}', 'xeric"sy')
 
     def test_multiple_vars(self):
         x = 98
-        y = "abc"
-        self.assertEqual(f"{x}{y}", "98abc")
+        y = 'abc'
+        self.assertEqual(f'{x}{y}', '98abc')
 
-        self.assertEqual(f"X{x}{y}", "X98abc")
-        self.assertEqual(f"{x}X{y}", "98Xabc")
-        self.assertEqual(f"{x}{y}X", "98abcX")
+        self.assertEqual(f'X{x}{y}', 'X98abc')
+        self.assertEqual(f'{x}X{y}', '98Xabc')
+        self.assertEqual(f'{x}{y}X', '98abcX')
 
-        self.assertEqual(f"X{x}Y{y}", "X98Yabc")
-        self.assertEqual(f"X{x}{y}Y", "X98abcY")
-        self.assertEqual(f"{x}X{y}Y", "98XabcY")
+        self.assertEqual(f'X{x}Y{y}', 'X98Yabc')
+        self.assertEqual(f'X{x}{y}Y', 'X98abcY')
+        self.assertEqual(f'{x}X{y}Y', '98XabcY')
 
-        self.assertEqual(f"X{x}Y{y}Z", "X98YabcZ")
+        self.assertEqual(f'X{x}Y{y}Z', 'X98YabcZ')
 
     def test_closure(self):
         def outer(x):
             def inner():
-                return f"x:{x}"
-
+                return f'x:{x}'
             return inner
 
-        self.assertEqual(outer("987")(), "x:987")
-        self.assertEqual(outer(7)(), "x:7")
+        self.assertEqual(outer('987')(), 'x:987')
+        self.assertEqual(outer(7)(), 'x:7')
 
     def test_arguments(self):
         y = 2
-
         def f(x, width):
-            return f"x={x*y:{width}}"
+            return f'x={x*y:{width}}'
 
-        self.assertEqual(f("foo", 10), "x=foofoo    ")
-        x = "bar"
-        self.assertEqual(f(10, 10), "x=        20")
+        self.assertEqual(f('foo', 10), 'x=foofoo    ')
+        x = 'bar'
+        self.assertEqual(f(10, 10), 'x=        20')
 
     def test_locals(self):
         value = 123
-        self.assertEqual(f"v:{value}", "v:123")
+        self.assertEqual(f'v:{value}', 'v:123')
 
     def test_missing_variable(self):
         with self.assertRaises(NameError):
-            f"v:{value}"
+            f'v:{value}'
 
     def test_missing_format_spec(self):
         class O:
             def __format__(self, spec):
                 if not spec:
-                    return "*"
+                    return '*'
                 return spec
 
-        self.assertEqual(f"{O():x}", "x")
-        self.assertEqual(f"{O()}", "*")
-        self.assertEqual(f"{O():}", "*")
+        self.assertEqual(f'{O():x}', 'x')
+        self.assertEqual(f'{O()}', '*')
+        self.assertEqual(f'{O():}', '*')
 
-        self.assertEqual(f"{3:}", "3")
-        self.assertEqual(f"{3!s:}", "3")
+        self.assertEqual(f'{3:}', '3')
+        self.assertEqual(f'{3!s:}', '3')
 
     def test_global(self):
-        self.assertEqual(f"g:{a_global}", "g:global variable")
-        self.assertEqual(f"g:{a_global!r}", "g:'global variable'")
+        self.assertEqual(f'g:{a_global}', 'g:global variable')
+        self.assertEqual(f'g:{a_global!r}', "g:'global variable'")
 
-        a_local = "local variable"
-        self.assertEqual(
-            f"g:{a_global} l:{a_local}", "g:global variable l:local variable"
-        )
-        self.assertEqual(f"g:{a_global!r}", "g:'global variable'")
-        self.assertEqual(
-            f"g:{a_global} l:{a_local!r}", "g:global variable l:'local variable'"
-        )
+        a_local = 'local variable'
+        self.assertEqual(f'g:{a_global} l:{a_local}',
+                         'g:global variable l:local variable')
+        self.assertEqual(f'g:{a_global!r}',
+                         "g:'global variable'")
+        self.assertEqual(f'g:{a_global} l:{a_local!r}',
+                         "g:global variable l:'local variable'")
 
-        self.assertIn("module 'unittest' from", f"{unittest}")
+        self.assertIn("module 'unittest' from", f'{unittest}')
 
     def test_shadowed_global(self):
-        a_global = "really a local"
-        self.assertEqual(f"g:{a_global}", "g:really a local")
-        self.assertEqual(f"g:{a_global!r}", "g:'really a local'")
-
-        a_local = "local variable"
-        self.assertEqual(
-            f"g:{a_global} l:{a_local}", "g:really a local l:local variable"
-        )
-        self.assertEqual(f"g:{a_global!r}", "g:'really a local'")
-        self.assertEqual(
-            f"g:{a_global} l:{a_local!r}", "g:really a local l:'local variable'"
-        )
+        a_global = 'really a local'
+        self.assertEqual(f'g:{a_global}', 'g:really a local')
+        self.assertEqual(f'g:{a_global!r}', "g:'really a local'")
+
+        a_local = 'local variable'
+        self.assertEqual(f'g:{a_global} l:{a_local}',
+                         'g:really a local l:local variable')
+        self.assertEqual(f'g:{a_global!r}',
+                         "g:'really a local'")
+        self.assertEqual(f'g:{a_global} l:{a_local!r}',
+                         "g:really a local l:'local variable'")
 
     def test_call(self):
         def foo(x):
-            return "x=" + str(x)
+            return 'x=' + str(x)
 
-        self.assertEqual(f"{foo(10)}", "x=10")
+        self.assertEqual(f'{foo(10)}', 'x=10')
 
     def test_nested_fstrings(self):
         y = 5
-        self.assertEqual(f'{f"{0}"*3}', "000")
-        self.assertEqual(f'{f"{y}"*3}', "555")
+        self.assertEqual(f'{f"{0}"*3}', '000')
+        self.assertEqual(f'{f"{y}"*3}', '555')
 
     def test_invalid_string_prefixes(self):
-        single_quote_cases = [
-            "fu''",
-            "uf''",
-            "Fu''",
-            "fU''",
-            "Uf''",
-            "uF''",
-            "ufr''",
-            "urf''",
-            "fur''",
-            "fru''",
-            "rfu''",
-            "ruf''",
-            "FUR''",
-            "Fur''",
-            "fb''",
-            "fB''",
-            "Fb''",
-            "FB''",
-            "bf''",
-            "bF''",
-            "Bf''",
-            "BF''",
-        ]
+        single_quote_cases = ["fu''",
+                             "uf''",
+                             "Fu''",
+                             "fU''",
+                             "Uf''",
+                             "uF''",
+                             "ufr''",
+                             "urf''",
+                             "fur''",
+                             "fru''",
+                             "rfu''",
+                             "ruf''",
+                             "FUR''",
+                             "Fur''",
+                             "fb''",
+                             "fB''",
+                             "Fb''",
+                             "FB''",
+                             "bf''",
+                             "bF''",
+                             "Bf''",
+                             "BF''",]
         double_quote_cases = [case.replace("'", '"') for case in single_quote_cases]
-        self.assertAllRaise(
-            SyntaxError, "invalid syntax", single_quote_cases + double_quote_cases
-        )
+        self.assertAllRaise(SyntaxError, 'invalid syntax',
+                            single_quote_cases + double_quote_cases)
 
     def test_leading_trailing_spaces(self):
-        self.assertEqual(f"{ 3}", "3")
-        self.assertEqual(f"{  3}", "3")
-        self.assertEqual(f"{3 }", "3")
-        self.assertEqual(f"{3  }", "3")
+        self.assertEqual(f'{ 3}', '3')
+        self.assertEqual(f'{  3}', '3')
+        self.assertEqual(f'{3 }', '3')
+        self.assertEqual(f'{3  }', '3')
 
-        self.assertEqual(f"expr={ {x: y for x, y in [(1, 2), ]}}", "expr={1: 2}")
-        self.assertEqual(f"expr={ {x: y for x, y in [(1, 2), ]} }", "expr={1: 2}")
+        self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]}}',
+                         'expr={1: 2}')
+        self.assertEqual(f'expr={ {x: y for x, y in [(1, 2), ]} }',
+                         'expr={1: 2}')
 
     def test_not_equal(self):
         # There's a special test for this because there's a special
         #  case in the f-string parser to look for != as not ending an
         #  expression. Normally it would, while looking for !s or !r.
 
-        self.assertEqual(f"{3!=4}", "True")
-        self.assertEqual(f"{3!=4:}", "True")
-        self.assertEqual(f"{3!=4!s}", "True")
-        self.assertEqual(f"{3!=4!s:.3}", "Tru")
+        self.assertEqual(f'{3!=4}', 'True')
+        self.assertEqual(f'{3!=4:}', 'True')
+        self.assertEqual(f'{3!=4!s}', 'True')
+        self.assertEqual(f'{3!=4!s:.3}', 'Tru')
 
     def test_equal_equal(self):
         # Because an expression ending in = has special meaning,
         # there's a special test for ==. Make sure it works.
 
-        self.assertEqual(f"{0==1}", "False")
+        self.assertEqual(f'{0==1}', 'False')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_conversions(self):
-        self.assertEqual(f"{3.14:10.10}", "      3.14")
-        self.assertEqual(f"{3.14!s:10.10}", "3.14      ")
-        self.assertEqual(f"{3.14!r:10.10}", "3.14      ")
-        self.assertEqual(f"{3.14!a:10.10}", "3.14      ")
+        self.assertEqual(f'{3.14:10.10}', '      3.14')
+        self.assertEqual(f'{1.25!s:10.10}', '1.25      ')
+        self.assertEqual(f'{1.25!r:10.10}', '1.25      ')
+        self.assertEqual(f'{1.25!a:10.10}', '1.25      ')
 
-        self.assertEqual(f'{"a"}', "a")
+        self.assertEqual(f'{"a"}', 'a')
         self.assertEqual(f'{"a"!r}', "'a'")
         self.assertEqual(f'{"a"!a}', "'a'")
 
         # Conversions can have trailing whitespace after them since it
         # does not provide any significance
-        # TODO: RUSTPYTHON SyntaxError
-        # self.assertEqual(f"{3!s  }", "3")
-        # self.assertEqual(f"{3.14!s  :10.10}", "3.14      ")
+        self.assertEqual(f"{3!s  }", "3")
+        self.assertEqual(f'{1.25!s  :10.10}', '1.25      ')
 
         # Not a conversion.
         self.assertEqual(f'{"a!r"}', "a!r")
 
         # Not a conversion, but show that ! is allowed in a format spec.
-        self.assertEqual(f"{3.14:!<10.10}", "3.14!!!!!!")
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting '}'",
-            [
-                "f'{3!'",
-                "f'{3!s'",
-                "f'{3!g'",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: missing conversion character",
-            [
-                "f'{3!}'",
-                "f'{3!:'",
-                "f'{3!:}'",
-            ],
-        )
-
-        for conv_identifier in "g", "A", "G", "ä", "ɐ":
-            self.assertAllRaise(
-                SyntaxError,
-                "f-string: invalid conversion character %r: "
-                "expected 's', 'r', or 'a'" % conv_identifier,
-                ["f'{3!" + conv_identifier + "}'"],
-            )
-
-        for conv_non_identifier in "3", "!":
-            self.assertAllRaise(
-                SyntaxError,
-                "f-string: invalid conversion character",
-                ["f'{3!" + conv_non_identifier + "}'"],
-            )
-
-        for conv in " s", " s ":
-            self.assertAllRaise(
-                SyntaxError,
-                "f-string: conversion type must come right after the"
-                " exclamanation mark",
-                ["f'{3!" + conv + "}'"],
-            )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: invalid conversion character 'ss': " "expected 's', 'r', or 'a'",
-            [
-                "f'{3!ss}'",
-                "f'{3!ss:}'",
-                "f'{3!ss:s}'",
-            ],
-        )
+        self.assertEqual(f'{3.14:!<10.10}', '3.14!!!!!!')
+
+        self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
+                            ["f'{3!'",
+                             "f'{3!s'",
+                             "f'{3!g'",
+                             ])
+
+        self.assertAllRaise(SyntaxError, 'f-string: missing conversion character',
+                            ["f'{3!}'",
+                             "f'{3!:'",
+                             "f'{3!:}'",
+                             ])
+
+        for conv_identifier in 'g', 'A', 'G', 'ä', 'ɐ':
+            self.assertAllRaise(SyntaxError,
+                                "f-string: invalid conversion character %r: "
+                                "expected 's', 'r', or 'a'" % conv_identifier,
+                                ["f'{3!" + conv_identifier + "}'"])
+
+        for conv_non_identifier in '3', '!':
+            self.assertAllRaise(SyntaxError,
+                                "f-string: invalid conversion character",
+                                ["f'{3!" + conv_non_identifier + "}'"])
+
+        for conv in ' s', ' s ':
+            self.assertAllRaise(SyntaxError,
+                                "f-string: conversion type must come right after the"
+                                " exclamation mark",
+                                ["f'{3!" + conv + "}'"])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: invalid conversion character 'ss': "
+                            "expected 's', 'r', or 'a'",
+                            ["f'{3!ss}'",
+                             "f'{3!ss:}'",
+                             "f'{3!ss:s}'",
+                             ])
 
     def test_assignment(self):
-        self.assertAllRaise(
-            SyntaxError,
-            r"invalid syntax",
-            [
-                "f'' = 3",
-                "f'{0}' = x",
-                "f'{x}' = x",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, r'invalid syntax',
+                            ["f'' = 3",
+                             "f'{0}' = x",
+                             "f'{x}' = x",
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_del(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "invalid syntax",
-            [
-                "del f''",
-                "del '' f''",
-            ],
-        )
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertAllRaise(SyntaxError, 'invalid syntax',
+                            ["del f''",
+                             "del '' f''",
+                             ])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mismatched_braces(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: single '}' is not allowed",
-            [
-                "f'{{}'",
-                "f'{{}}}'",
-                "f'}'",
-                "f'x}'",
-                "f'x}x'",
-                r"f'\u007b}'",
-                # Can't have { or } in a format spec.
-                "f'{3:}>10}'",
-                "f'{3:}}>10}'",
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting '}'",
-            [
-                "f'{3'",
-                "f'{3!'",
-                "f'{3:'",
-                "f'{3!s'",
-                "f'{3!s:'",
-                "f'{3!s:3'",
-                "f'x{'",
-                "f'x{x'",
-                "f'{x'",
-                "f'{3:s'",
-                "f'{{{'",
-                "f'{{}}{'",
-                "f'{'",
-                "f'{i='",  # See gh-93418.
-            ],
-        )
-
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting a valid expression after '{'",
-            [
-                "f'{3:{{>10}'",
-            ],
-        )
+        self.assertAllRaise(SyntaxError, "f-string: single '}' is not allowed",
+                            ["f'{{}'",
+                             "f'{{}}}'",
+                             "f'}'",
+                             "f'x}'",
+                             "f'x}x'",
+                             r"f'\u007b}'",
+
+                             # Can't have { or } in a format spec.
+                             "f'{3:}>10}'",
+                             "f'{3:}}>10}'",
+                             ])
+
+        self.assertAllRaise(SyntaxError, "f-string: expecting '}'",
+                            ["f'{3'",
+                             "f'{3!'",
+                             "f'{3:'",
+                             "f'{3!s'",
+                             "f'{3!s:'",
+                             "f'{3!s:3'",
+                             "f'x{'",
+                             "f'x{x'",
+                             "f'{x'",
+                             "f'{3:s'",
+                             "f'{{{'",
+                             "f'{{}}{'",
+                             "f'{'",
+                             "f'{i='",  # See gh-93418.
+                             ])
+
+        self.assertAllRaise(SyntaxError,
+                            "f-string: expecting a valid expression after '{'",
+                            ["f'{3:{{>10}'",
+                             ])
 
         # But these are just normal strings.
-        self.assertEqual(f'{"{"}', "{")
-        self.assertEqual(f'{"}"}', "}")
-        self.assertEqual(f'{3:{"}"}>10}', "}}}}}}}}}3")
-        self.assertEqual(f'{2:{"{"}>10}', "{{{{{{{{{2")
+        self.assertEqual(f'{"{"}', '{')
+        self.assertEqual(f'{"}"}', '}')
+        self.assertEqual(f'{3:{"}"}>10}', '}}}}}}}}}3')
+        self.assertEqual(f'{2:{"{"}>10}', '{{{{{{{{{2')
 
     def test_if_conditional(self):
         # There's special logic in compile.c to test if the
@@ -1593,7 +1465,7 @@ def test_if_conditional(self):
 
         def test_fstring(x, expected):
             flag = 0
-            if f"{x}":
+            if f'{x}':
                 flag = 1
             else:
                 flag = 2
@@ -1601,7 +1473,7 @@ def test_fstring(x, expected):
 
         def test_concat_empty(x, expected):
             flag = 0
-            if "" f"{x}":
+            if '' f'{x}':
                 flag = 1
             else:
                 flag = 2
@@ -1609,151 +1481,139 @@ def test_concat_empty(x, expected):
 
         def test_concat_non_empty(x, expected):
             flag = 0
-            if " " f"{x}":
+            if ' ' f'{x}':
                 flag = 1
             else:
                 flag = 2
             self.assertEqual(flag, expected)
 
-        test_fstring("", 2)
-        test_fstring(" ", 1)
+        test_fstring('', 2)
+        test_fstring(' ', 1)
 
-        test_concat_empty("", 2)
-        test_concat_empty(" ", 1)
+        test_concat_empty('', 2)
+        test_concat_empty(' ', 1)
 
-        test_concat_non_empty("", 1)
-        test_concat_non_empty(" ", 1)
+        test_concat_non_empty('', 1)
+        test_concat_non_empty(' ', 1)
 
     def test_empty_format_specifier(self):
-        x = "test"
-        self.assertEqual(f"{x}", "test")
-        self.assertEqual(f"{x:}", "test")
-        self.assertEqual(f"{x!s:}", "test")
-        self.assertEqual(f"{x!r:}", "'test'")
+        x = 'test'
+        self.assertEqual(f'{x}', 'test')
+        self.assertEqual(f'{x:}', 'test')
+        self.assertEqual(f'{x!s:}', 'test')
+        self.assertEqual(f'{x!r:}', "'test'")
 
     def test_str_format_differences(self):
-        d = {
-            "a": "string",
-            0: "integer",
-        }
+        d = {'a': 'string',
+             0: 'integer',
+             }
         a = 0
-        self.assertEqual(f"{d[0]}", "integer")
-        self.assertEqual(f'{d["a"]}', "string")
-        self.assertEqual(f"{d[a]}", "integer")
-        self.assertEqual("{d[a]}".format(d=d), "string")
-        self.assertEqual("{d[0]}".format(d=d), "integer")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        self.assertEqual(f'{d[0]}', 'integer')
+        self.assertEqual(f'{d["a"]}', 'string')
+        self.assertEqual(f'{d[a]}', 'integer')
+        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",
-            [
-                r"f'{(lambda: 0):x}'",
-                r"f'{(0,):x}'",
-            ],
-        )
-        self.assertAllRaise(
-            ValueError,
-            "Unknown format code",
-            [
-                r"f'{1000:j}'",
-                r"f'{1000:j}'",
-            ],
-        )
+        self.assertAllRaise(TypeError, 'unsupported',
+                            [r"f'{(lambda: 0):x}'",
+                             r"f'{(0,):x}'",
+                             ])
+        self.assertAllRaise(ValueError, 'Unknown format code',
+                            [r"f'{1000:j}'",
+                             r"f'{1000:j}'",
+                            ])
 
     def test_filename_in_syntaxerror(self):
         # see issue 38964
         with temp_cwd() as cwd:
-            file_path = os.path.join(cwd, "t.py")
-            with open(file_path, "w", encoding="utf-8") as f:
-                f.write('f"{a b}"')  # This generates a SyntaxError
-            _, _, stderr = assert_python_failure(file_path, PYTHONIOENCODING="ascii")
-        self.assertIn(file_path.encode("ascii", "backslashreplace"), stderr)
+            file_path = os.path.join(cwd, 't.py')
+            with open(file_path, 'w', encoding="utf-8") as f:
+                f.write('f"{a b}"') # This generates a SyntaxError
+            _, _, stderr = assert_python_failure(file_path,
+                                                 PYTHONIOENCODING='ascii')
+        self.assertIn(file_path.encode('ascii', 'backslashreplace'), stderr)
 
     def test_loop(self):
         for i in range(1000):
-            self.assertEqual(f"i:{i}", "i:" + str(i))
+            self.assertEqual(f'i:{i}', 'i:' + str(i))
 
     def test_dict(self):
-        d = {
-            '"': "dquote",
-            "'": "squote",
-            "foo": "bar",
-        }
-        self.assertEqual(f"""{d["'"]}""", "squote")
-        self.assertEqual(f"""{d['"']}""", "dquote")
+        d = {'"': 'dquote',
+             "'": 'squote',
+             'foo': 'bar',
+             }
+        self.assertEqual(f'''{d["'"]}''', 'squote')
+        self.assertEqual(f"""{d['"']}""", 'dquote')
 
-        self.assertEqual(f'{d["foo"]}', "bar")
-        self.assertEqual(f"{d['foo']}", "bar")
+        self.assertEqual(f'{d["foo"]}', 'bar')
+        self.assertEqual(f"{d['foo']}", 'bar')
 
     def test_backslash_char(self):
         # Check eval of a backslash followed by a control char.
         # See bpo-30682: this used to raise an assert in pydebug mode.
-        self.assertEqual(eval('f"\\\n"'), "")
-        self.assertEqual(eval('f"\\\r"'), "")
+        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))
-        self.assertEqual(f"{x =}", "x =" + repr(x))
-        self.assertEqual(f"{x=!s}", "x=" + str(x))
-        self.assertEqual(f"{x=!r}", "x=" + repr(x))
-        self.assertEqual(f"{x=!a}", "x=" + ascii(x))
+        x = 'A string'
+        self.assertEqual(f'{x=}', 'x=' + repr(x))
+        self.assertEqual(f'{x =}', 'x =' + repr(x))
+        self.assertEqual(f'{x=!s}', 'x=' + str(x))
+        self.assertEqual(f'{x=!r}', 'x=' + repr(x))
+        self.assertEqual(f'{x=!a}', 'x=' + ascii(x))
 
         x = 2.71828
-        self.assertEqual(f"{x=:.2f}", "x=" + format(x, ".2f"))
-        self.assertEqual(f"{x=:}", "x=" + format(x, ""))
-        self.assertEqual(f"{x=!r:^20}", "x=" + format(repr(x), "^20"))
-        self.assertEqual(f"{x=!s:^20}", "x=" + format(str(x), "^20"))
-        self.assertEqual(f"{x=!a:^20}", "x=" + format(ascii(x), "^20"))
+        self.assertEqual(f'{x=:.2f}', 'x=' + format(x, '.2f'))
+        self.assertEqual(f'{x=:}', 'x=' + format(x, ''))
+        self.assertEqual(f'{x=!r:^20}', 'x=' + format(repr(x), '^20'))
+        self.assertEqual(f'{x=!s:^20}', 'x=' + format(str(x), '^20'))
+        self.assertEqual(f'{x=!a:^20}', 'x=' + format(ascii(x), '^20'))
 
         x = 9
-        self.assertEqual(f"{3*x+15=}", "3*x+15=42")
+        self.assertEqual(f'{3*x+15=}', '3*x+15=42')
 
         # There is code in ast.c that deals with non-ascii expression values.  So,
         # use a unicode identifier to trigger that.
         tenπ = 31.4
-        self.assertEqual(f"{tenπ=:.2f}", "tenπ=31.40")
+        self.assertEqual(f'{tenπ=:.2f}', 'tenπ=31.40')
 
         # Also test with Unicode in non-identifiers.
-        self.assertEqual(f'{"Σ"=}', "\"Σ\"='Σ'")
+        self.assertEqual(f'{"Σ"=}', '"Σ"=\'Σ\'')
 
         # Make sure nested fstrings still work.
-        self.assertEqual(f'{f"{3.1415=:.1f}":*^20}', "*****3.1415=3.1*****")
+        self.assertEqual(f'{f"{3.1415=:.1f}":*^20}', '*****3.1415=3.1*****')
 
         # Make sure text before and after an expression with = works
         # correctly.
-        pi = "π"
-        self.assertEqual(f"alpha α {pi=} ω omega", "alpha α pi='π' ω omega")
+        pi = 'π'
+        self.assertEqual(f'alpha α {pi=} ω omega', "alpha α pi='π' ω omega")
 
         # Check multi-line expressions.
-        self.assertEqual(
-            f"""{
+        self.assertEqual(f'''{
 3
-=}""",
-            "\n3\n=3",
-        )
+=}''', '\n3\n=3')
 
         # Since = is handled specially, make sure all existing uses of
         # it still work.
 
-        self.assertEqual(f"{0==1}", "False")
-        self.assertEqual(f"{0!=1}", "True")
-        self.assertEqual(f"{0<=1}", "True")
-        self.assertEqual(f"{0>=1}", "False")
-        self.assertEqual(f'{(x:="5")}', "5")
-        self.assertEqual(x, "5")
-        self.assertEqual(f"{(x:=5)}", "5")
+        self.assertEqual(f'{0==1}', 'False')
+        self.assertEqual(f'{0!=1}', 'True')
+        self.assertEqual(f'{0<=1}', 'True')
+        self.assertEqual(f'{0>=1}', 'False')
+        self.assertEqual(f'{(x:="5")}', '5')
+        self.assertEqual(x, '5')
+        self.assertEqual(f'{(x:=5)}', '5')
         self.assertEqual(x, 5)
-        self.assertEqual(f'{"="}', "=")
+        self.assertEqual(f'{"="}', '=')
 
         x = 20
         # This isn't an assignment expression, it's 'x', with a format
         # spec of '=10'.  See test_walrus: you need to use parens.
-        self.assertEqual(f"{x:=10}", "        20")
+        self.assertEqual(f'{x:=10}', '        20')
 
         # Test named function parameters, to make sure '=' parsing works
         # there.
@@ -1762,54 +1622,60 @@ def f(a):
             oldx = x
             x = a
             return oldx
-
         x = 0
-        self.assertEqual(f'{f(a="3=")}', "0")
-        self.assertEqual(x, "3=")
-        self.assertEqual(f"{f(a=4)}", "3=")
+        self.assertEqual(f'{f(a="3=")}', '0')
+        self.assertEqual(x, '3=')
+        self.assertEqual(f'{f(a=4)}', '3=')
         self.assertEqual(x, 4)
 
         # Check debug expressions in format spec
         y = 20
         self.assertEqual(f"{2:{y=}}", "yyyyyyyyyyyyyyyyyyy2")
-        self.assertEqual(
-            f"{datetime.datetime.now():h1{y=}h2{y=}h3{y=}}", "h1y=20h2y=20h3y=20"
-        )
+        self.assertEqual(f"{datetime.datetime.now():h1{y=}h2{y=}h3{y=}}",
+                         'h1y=20h2y=20h3y=20')
 
         # Make sure __format__ is being called.
         class C:
             def __format__(self, s):
-                return f"FORMAT-{s}"
-
+                return f'FORMAT-{s}'
             def __repr__(self):
-                return "REPR"
+                return 'REPR'
 
-        self.assertEqual(f"{C()=}", "C()=REPR")
-        self.assertEqual(f"{C()=!r}", "C()=REPR")
-        self.assertEqual(f"{C()=:}", "C()=FORMAT-")
-        self.assertEqual(f"{C()=: }", "C()=FORMAT- ")
-        self.assertEqual(f"{C()=:x}", "C()=FORMAT-x")
-        self.assertEqual(f"{C()=!r:*^20}", "C()=********REPR********")
-        self.assertEqual(f"{C():{20=}}", "FORMAT-20=20")
+        self.assertEqual(f'{C()=}', 'C()=REPR')
+        self.assertEqual(f'{C()=!r}', 'C()=REPR')
+        self.assertEqual(f'{C()=:}', 'C()=FORMAT-')
+        self.assertEqual(f'{C()=: }', 'C()=FORMAT- ')
+        self.assertEqual(f'{C()=:x}', 'C()=FORMAT-x')
+        self.assertEqual(f'{C()=!r:*^20}', 'C()=********REPR********')
+        self.assertEqual(f"{C():{20=}}", 'FORMAT-20=20')
 
         self.assertRaises(SyntaxError, eval, "f'{C=]'")
 
+
         # Make sure leading and following text works.
-        x = "foo"
-        self.assertEqual(f"X{x=}Y", "Xx=" + repr(x) + "Y")
+        x = 'foo'
+        self.assertEqual(f'X{x=}Y', 'Xx='+repr(x)+'Y')
 
         # Make sure whitespace around the = works.
-        self.assertEqual(f"X{x  =}Y", "Xx  =" + repr(x) + "Y")
-        self.assertEqual(f"X{x=  }Y", "Xx=  " + repr(x) + "Y")
-        self.assertEqual(f"X{x  =  }Y", "Xx  =  " + repr(x) + "Y")
+        self.assertEqual(f'X{x  =}Y', 'Xx  ='+repr(x)+'Y')
+        self.assertEqual(f'X{x=  }Y', 'Xx=  '+repr(x)+'Y')
+        self.assertEqual(f'X{x  =  }Y', 'Xx  =  '+repr(x)+'Y')
         self.assertEqual(f"sadsd {1 + 1 =  :{1 + 1:1d}f}", "sadsd 1 + 1 =  2.000000")
 
-# TODO: RUSTPYTHON SyntaxError
-#         self.assertEqual(
-#             f"{1+2 = # my comment
-#   }",
-#             "1+2 = \n  3",
-#         )
+        self.assertEqual(f"{1+2 = # my comment
+  }", '1+2 = \n  3')
+
+        self.assertEqual(f'{""" # booo
+  """=}', '""" # booo\n  """=\' # booo\\n  \'')
+
+        self.assertEqual(f'{" # nooo "=}', '" # nooo "=\' # nooo \'')
+        self.assertEqual(f'{" \" # nooo \" "=}', '" \\" # nooo \\" "=\' " # nooo " \'')
+
+        self.assertEqual(f'{ # some comment goes here
+  """hello"""=}',  ' \n  """hello"""=\'hello\'')
+        self.assertEqual(f'{"""# this is not a comment
+        a""" # this is a comment
+        }', '# this is not a comment\n        a')
 
         # These next lines contains tabs.  Backslash escapes don't
         # work in f-strings.
@@ -1817,65 +1683,68 @@ def __repr__(self):
         # this will be to dynamically created and exec the f-strings.  But
         # that's such a hassle I'll save it for another day.  For now, convert
         # the tabs to spaces just to shut up patchcheck.
-        # self.assertEqual(f'X{x =}Y', 'Xx\t='+repr(x)+'Y')
-        # self.assertEqual(f'X{x =       }Y', 'Xx\t=\t'+repr(x)+'Y')
+        #self.assertEqual(f'X{x =}Y', 'Xx\t='+repr(x)+'Y')
+        #self.assertEqual(f'X{x =       }Y', 'Xx\t=\t'+repr(x)+'Y')
+
+    def test_debug_expressions_are_raw_strings(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', SyntaxWarning)
+            self.assertEqual(eval("""f'{b"\\N{OX}"=}'"""), 'b"\\N{OX}"=b\'\\\\N{OX}\'')
+        self.assertEqual(f'{r"\xff"=}', 'r"\\xff"=\'\\\\xff\'')
+        self.assertEqual(f'{r"\n"=}', 'r"\\n"=\'\\\\n\'')
+        self.assertEqual(f"{'\''=}", "'\\''=\"'\"")
+        self.assertEqual(f'{'\xc5'=}', r"'\xc5'='Å'")
 
     def test_walrus(self):
         x = 20
         # This isn't an assignment expression, it's 'x', with a format
         # spec of '=10'.
-        self.assertEqual(f"{x:=10}", "        20")
+        self.assertEqual(f'{x:=10}', '        20')
 
         # This is an assignment expression, which requires parens.
-        self.assertEqual(f"{(x:=10)}", "10")
+        self.assertEqual(f'{(x:=10)}', '10')
         self.assertEqual(x, 10)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_syntax_error_message(self):
-        with self.assertRaisesRegex(
-            SyntaxError, "f-string: expecting '=', or '!', or ':', or '}'"
-        ):
+        with self.assertRaisesRegex(SyntaxError,
+                                    "f-string: expecting '=', or '!', or ':', or '}'"):
             compile("f'{a $ b}'", "?", "exec")
 
     def test_with_two_commas_in_format_specifier(self):
         error_msg = re.escape("Cannot specify ',' with ','.")
         with self.assertRaisesRegex(ValueError, error_msg):
-            f"{1:,,}"
+            f'{1:,,}'
 
     def test_with_two_underscore_in_format_specifier(self):
         error_msg = re.escape("Cannot specify '_' with '_'.")
         with self.assertRaisesRegex(ValueError, error_msg):
-            f"{1:__}"
+            f'{1:__}'
 
     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):
-            f"{1:,_}"
+            f'{1:,_}'
 
     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):
-            f"{1:_,}"
+            f'{1:_,}'
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_syntax_error_for_starred_expressions(self):
         with self.assertRaisesRegex(SyntaxError, "can't use starred expression here"):
             compile("f'{*a}'", "?", "exec")
 
-        with self.assertRaisesRegex(
-            SyntaxError, "f-string: expecting a valid expression after '{'"
-        ):
+        with self.assertRaisesRegex(SyntaxError,
+                                    "f-string: expecting a valid expression after '{'"):
             compile("f'{**a}'", "?", "exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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", ['f"""', "f'''"]
-        )
+        self.assertAllRaise(SyntaxError, "unterminated triple-quoted f-string literal",
+                            ['f"""', "f'''"])
         # Ensure that the errors are reported at the correct line number.
         data = '''\
 x = 1 + 1
@@ -1891,56 +1760,124 @@ def test_not_closing_quotes(self):
         except SyntaxError as e:
             self.assertEqual(e.text, 'z = f"""')
             self.assertEqual(e.lineno, 3)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_syntax_error_after_debug(self):
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting a valid expression after '{'",
-            [
-                "f'{1=}{;'",
-                "f'{1=}{+;'",
-                "f'{1=}{2}{;'",
-                "f'{1=}{3}{;'",
-            ],
-        )
-        self.assertAllRaise(
-            SyntaxError,
-            "f-string: expecting '=', or '!', or ':', or '}'",
-            [
-                "f'{1=}{1;'",
-                "f'{1=}{1;}'",
-            ],
-        )
+        self.assertAllRaise(SyntaxError, "f-string: expecting a valid expression after '{'",
+                            [
+                                "f'{1=}{;'",
+                                "f'{1=}{+;'",
+                                "f'{1=}{2}{;'",
+                                "f'{1=}{3}{;'",
+                            ])
+        self.assertAllRaise(SyntaxError, "f-string: expecting '=', or '!', or ':', or '}'",
+                            [
+                                "f'{1=}{1;'",
+                                "f'{1=}{1;}'",
+                            ])
 
     def test_debug_in_file(self):
         with temp_cwd():
-            script = "script.py"
-            with open("script.py", "w") as f:
+            script = 'script.py'
+            with open('script.py', 'w') as f:
                 f.write(f"""\
 print(f'''{{
 3
 =}}''')""")
 
             _, stdout, _ = assert_python_ok(script)
-        self.assertEqual(
-            stdout.decode("utf-8").strip().replace("\r\n", "\n").replace("\r", "\n"),
-            "3\n=3",
-        )
+        self.assertEqual(stdout.decode('utf-8').strip().replace('\r\n', '\n').replace('\r', '\n'),
+                         "3\n=3")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_syntax_warning_infinite_recursion_in_file(self):
         with temp_cwd():
-            script = "script.py"
-            with open(script, "w") as f:
+            script = 'script.py'
+            with open(script, 'w') as f:
                 f.write(r"print(f'\{1}')")
 
             _, stdout, stderr = assert_python_ok(script)
-            self.assertIn(rb"\1", stdout)
+            self.assertIn(rb'\1', stdout)
             self.assertEqual(len(stderr.strip().splitlines()), 2)
 
+    def test_fstring_without_formatting_bytecode(self):
+        # f-string without any formatting should emit the same bytecode
+        # as a normal string. See gh-99606.
+        def get_code(s):
+            return [(i.opname, i.oparg) for i in dis.get_instructions(s)]
+
+        for s in ["", "some string"]:
+            self.assertEqual(get_code(f"'{s}'"), get_code(f"f'{s}'"))
+
+    def test_gh129093(self):
+        self.assertEqual(f'{1==2=}', '1==2=False')
+        self.assertEqual(f'{1 == 2=}', '1 == 2=False')
+        self.assertEqual(f'{1!=2=}', '1!=2=True')
+        self.assertEqual(f'{1 != 2=}', '1 != 2=True')
+
+        self.assertEqual(f'{(1) != 2=}', '(1) != 2=True')
+        self.assertEqual(f'{(1*2) != (3)=}', '(1*2) != (3)=True')
+
+        self.assertEqual(f'{1 != 2 == 3 != 4=}', '1 != 2 == 3 != 4=False')
+        self.assertEqual(f'{1 == 2 != 3 == 4=}', '1 == 2 != 3 == 4=False')
+
+        self.assertEqual(f'{f'{1==2=}'=}', "f'{1==2=}'='1==2=False'")
+        self.assertEqual(f'{f'{1 == 2=}'=}', "f'{1 == 2=}'='1 == 2=False'")
+        self.assertEqual(f'{f'{1!=2=}'=}', "f'{1!=2=}'='1!=2=True'")
+        self.assertEqual(f'{f'{1 != 2=}'=}', "f'{1 != 2=}'='1 != 2=True'")
+
+    def test_newlines_in_format_specifiers(self):
+        cases = [
+            """f'{1:d\n}'""",
+            """f'__{
+                1:d
+            }__'""",
+            '''f"{value:.
+               {'2f'}}"''',
+            '''f"{value:
+               {'.2f'}f}"''',
+            '''f"{value:
+                #{'x'}}"''',
+        ]
+        self.assertAllRaise(SyntaxError, "f-string: newlines are not allowed in format specifiers", cases)
+
+        valid_cases = [
+            """f'''__{
+                1:d
+            }__'''""",
+            """f'''{1:d\n}'''""",
+        ]
+
+        for case in valid_cases:
+            compile(case, "<string>", "exec")
+
+    def test_raw_fstring_format_spec(self):
+        # Test raw f-string format spec behavior (Issue #137314).
+        #
+        # Raw f-strings should preserve literal backslashes in format specifications,
+        # not interpret them as escape sequences.
+        class UnchangedFormat:
+            """Test helper that returns the format spec unchanged."""
+            def __format__(self, format):
+                return format
+
+        # Test basic escape sequences
+        self.assertEqual(f"{UnchangedFormat():\xFF}", 'ÿ')
+        self.assertEqual(rf"{UnchangedFormat():\xFF}", '\\xFF')
+
+        # Test nested expressions with raw/non-raw combinations
+        self.assertEqual(rf"{UnchangedFormat():{'\xFF'}}", 'ÿ')
+        self.assertEqual(f"{UnchangedFormat():{r'\xFF'}}", '\\xFF')
+        self.assertEqual(rf"{UnchangedFormat():{r'\xFF'}}", '\\xFF')
+
+        # Test continuation character in format specs
+        self.assertEqual(f"""{UnchangedFormat():{'a'\
+                        'b'}}""", 'ab')
+        self.assertEqual(rf"""{UnchangedFormat():{'a'\
+                         'b'}}""", 'ab')
+
+        # Test multiple format specs in same raw f-string
+        self.assertEqual(rf"{UnchangedFormat():\xFF} {UnchangedFormat():\n}", '\\xFF \\n')
+
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index b3e4e776a4..684f5d438b 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -18,6 +18,7 @@
 
 from unittest import TestCase, skipUnless
 from test import support
+from test.support import requires_subprocess
 from test.support import threading_helper
 from test.support import socket_helper
 from test.support import warnings_helper
@@ -32,7 +33,7 @@
 DEFAULT_ENCODING = 'utf-8'
 # the dummy data returned by server over the data channel when
 # RETR, LIST, NLST, MLSD commands are issued
-RETR_DATA = 'abcde12345\r\n' * 1000 + 'non-ascii char \xAE\r\n'
+RETR_DATA = 'abcde\xB9\xB2\xB3\xA4\xA6\r\n' * 1000
 LIST_DATA = 'foo\r\nbar\r\n non-ascii char \xAE\r\n'
 NLST_DATA = 'foo\r\nbar\r\n non-ascii char \xAE\r\n'
 MLSD_DATA = ("type=cdir;perm=el;unique==keVO1+ZF4; test\r\n"
@@ -67,11 +68,11 @@ class DummyDTPHandler(asynchat.async_chat):
     def __init__(self, conn, baseclass):
         asynchat.async_chat.__init__(self, conn)
         self.baseclass = baseclass
-        self.baseclass.last_received_data = ''
+        self.baseclass.last_received_data = bytearray()
         self.encoding = baseclass.encoding
 
     def handle_read(self):
-        new_data = self.recv(1024).decode(self.encoding, 'replace')
+        new_data = self.recv(1024)
         self.baseclass.last_received_data += new_data
 
     def handle_close(self):
@@ -80,7 +81,7 @@ def handle_close(self):
         # (behaviour witnessed with test_data_connection)
         if not self.dtp_conn_closed:
             self.baseclass.push('226 transfer complete')
-            self.close()
+            self.shutdown()
             self.dtp_conn_closed = True
 
     def push(self, what):
@@ -94,6 +95,9 @@ def push(self, what):
     def handle_error(self):
         default_error_handler()
 
+    def shutdown(self):
+        self.close()
+
 
 class DummyFTPHandler(asynchat.async_chat):
 
@@ -107,7 +111,7 @@ def __init__(self, conn, encoding=DEFAULT_ENCODING):
         self.in_buffer = []
         self.dtp = None
         self.last_received_cmd = None
-        self.last_received_data = ''
+        self.last_received_data = bytearray()
         self.next_response = ''
         self.next_data = None
         self.rest = None
@@ -226,7 +230,7 @@ def cmd_type(self, arg):
 
     def cmd_quit(self, arg):
         self.push('221 quit ok')
-        self.close()
+        self.shutdown()
 
     def cmd_abor(self, arg):
         self.push('226 abor ok')
@@ -313,7 +317,7 @@ def handle_accepted(self, conn, addr):
         self.handler_instance = self.handler(conn, encoding=self.encoding)
 
     def handle_connect(self):
-        self.close()
+        self.shutdown()
     handle_read = handle_connect
 
     def writable(self):
@@ -325,8 +329,8 @@ def handle_error(self):
 
 if ssl is not None:
 
-    CERTFILE = os.path.join(os.path.dirname(__file__), "keycert3.pem")
-    CAFILE = os.path.join(os.path.dirname(__file__), "pycacert.pem")
+    CERTFILE = os.path.join(os.path.dirname(__file__), "certdata", "keycert3.pem")
+    CAFILE = os.path.join(os.path.dirname(__file__), "certdata", "pycacert.pem")
 
     class SSLConnection(asyncore.dispatcher):
         """An asyncore.dispatcher subclass supporting TLS/SSL."""
@@ -425,12 +429,12 @@ def recv(self, buffer_size):
         def handle_error(self):
             default_error_handler()
 
-        def close(self):
+        def shutdown(self):
             if (isinstance(self.socket, ssl.SSLSocket) and
                     self.socket._sslobj is not None):
                 self._do_ssl_shutdown()
             else:
-                super(SSLConnection, self).close()
+                self.close()
 
 
     class DummyTLS_DTPHandler(SSLConnection, DummyDTPHandler):
@@ -542,8 +546,8 @@ def test_set_pasv(self):
         self.assertFalse(self.client.passiveserver)
 
     def test_voidcmd(self):
-        self.client.voidcmd('echo 200')
-        self.client.voidcmd('echo 299')
+        self.assertEqual(self.client.voidcmd('echo 200'), '200')
+        self.assertEqual(self.client.voidcmd('echo 299'), '299')
         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 199')
         self.assertRaises(ftplib.error_reply, self.client.voidcmd, 'echo 300')
 
@@ -590,30 +594,28 @@ def test_abort(self):
         self.client.abort()
 
     def test_retrbinary(self):
-        def callback(data):
-            received.append(data.decode(self.client.encoding))
         received = []
-        self.client.retrbinary('retr', callback)
-        self.check_data(''.join(received), RETR_DATA)
+        self.client.retrbinary('retr', received.append)
+        self.check_data(b''.join(received),
+                        RETR_DATA.encode(self.client.encoding))
 
     def test_retrbinary_rest(self):
-        def callback(data):
-            received.append(data.decode(self.client.encoding))
         for rest in (0, 10, 20):
             received = []
-            self.client.retrbinary('retr', callback, rest=rest)
-            self.check_data(''.join(received), RETR_DATA[rest:])
+            self.client.retrbinary('retr', received.append, rest=rest)
+            self.check_data(b''.join(received),
+                            RETR_DATA[rest:].encode(self.client.encoding))
 
     def test_retrlines(self):
         received = []
         self.client.retrlines('retr', received.append)
         self.check_data(''.join(received), RETR_DATA.replace('\r\n', ''))
 
-    @unittest.skip("TODO: RUSTPYTHON; weird limiting to 8192, something w/ buffering?")
     def test_storbinary(self):
         f = io.BytesIO(RETR_DATA.encode(self.client.encoding))
         self.client.storbinary('stor', f)
-        self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
+        self.check_data(self.server.handler_instance.last_received_data,
+                        RETR_DATA.encode(self.server.encoding))
         # test new callback arg
         flag = []
         f.seek(0)
@@ -632,7 +634,8 @@ def test_storlines(self):
         data = RETR_DATA.replace('\r\n', '\n').encode(self.client.encoding)
         f = io.BytesIO(data)
         self.client.storlines('stor', f)
-        self.check_data(self.server.handler_instance.last_received_data, RETR_DATA)
+        self.check_data(self.server.handler_instance.last_received_data,
+                        RETR_DATA.encode(self.server.encoding))
         # test new callback arg
         flag = []
         f.seek(0)
@@ -650,7 +653,7 @@ def test_nlst(self):
 
     def test_dir(self):
         l = []
-        self.client.dir(lambda x: l.append(x))
+        self.client.dir(l.append)
         self.assertEqual(''.join(l), LIST_DATA.replace('\r\n', ''))
 
     def test_mlsd(self):
@@ -890,20 +893,19 @@ def test_makepasv(self):
 
     def test_transfer(self):
         def retr():
-            def callback(data):
-                received.append(data.decode(self.client.encoding))
             received = []
-            self.client.retrbinary('retr', callback)
-            self.assertEqual(len(''.join(received)), len(RETR_DATA))
-            self.assertEqual(''.join(received), RETR_DATA)
+            self.client.retrbinary('retr', received.append)
+            self.assertEqual(b''.join(received),
+                             RETR_DATA.encode(self.client.encoding))
         self.client.set_pasv(True)
         retr()
         self.client.set_pasv(False)
         retr()
 
 
+@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; figure out why do_handshake() is throwing 'ssl session has been shut down'. SslSession object?")
+@requires_subprocess()
 class TestTLS_FTPClassMixin(TestFTPClass):
     """Repeat TestFTPClass tests starting the TLS layer for both control
     and data connections first.
@@ -920,7 +922,8 @@ def setUp(self, encoding=DEFAULT_ENCODING):
 
 
 @skipUnless(ssl, "SSL not available")
-@unittest.skip("TODO: RUSTPYTHON; fix ssl")
+@unittest.skip("TODO: RUSTPYTHON; SSL + asyncore has problem")
+@requires_subprocess()
 class TestTLS_FTPClass(TestCase):
     """Specific TLS_FTP class tests."""
 
@@ -968,6 +971,7 @@ def test_data_connection(self):
                              LIST_DATA.encode(self.client.encoding))
         self.assertEqual(self.client.voidresp(), "226 transfer complete")
 
+    @unittest.skip('TODO: RUSTPYTHON flaky TimeoutError')
     def test_login(self):
         # login() is supposed to implicitly secure the control connection
         self.assertNotIsInstance(self.client.sock, ssl.SSLSocket)
@@ -980,6 +984,7 @@ def test_auth_issued_twice(self):
         self.client.auth()
         self.assertRaises(ValueError, self.client.auth)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky TimeoutError')
     def test_context(self):
         self.client.quit()
         ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
diff --git a/Lib/test/test_funcattrs.py b/Lib/test/test_funcattrs.py
index 5fd268fd90..e06e9f7f4a 100644
--- a/Lib/test/test_funcattrs.py
+++ b/Lib/test/test_funcattrs.py
@@ -65,8 +65,6 @@ def duplicate():
             return 3
         self.assertNotEqual(self.b, duplicate)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_copying___code__(self):
         def test(): pass
         self.assertEqual(test(), None)
@@ -176,8 +174,6 @@ def test___name__(self):
         self.assertEqual(self.fi.a.__name__, 'a')
         self.cannot_set_attr(self.fi.a, "__name__", 'a', AttributeError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test___qualname__(self):
         # PEP 3155
         self.assertEqual(self.b.__qualname__, 'FuncAttrsTest.setUp.<locals>.b')
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index 32b442b0c0..047916caf0 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -31,10 +31,6 @@
 
 decimal = import_helper.import_fresh_module('decimal', fresh=['_decimal'])
 
-_partial_types = [py_functools.partial]
-if c_functools:
-    _partial_types.append(c_functools.partial)
-
 
 @contextlib.contextmanager
 def replaced_module(name, replacement):
@@ -189,6 +185,19 @@ def test_nested_optimization(self):
         flat = partial(signature, 'asdf', bar=True)
         self.assertEqual(signature(nested), signature(flat))
 
+    def test_nested_optimization_bug(self):
+        partial = self.partial
+        class Builder:
+            def __call__(self, tag, *children, **attrib):
+                return (tag, children, attrib)
+
+            def __getattr__(self, tag):
+                return partial(self, tag)
+
+        B = Builder()
+        m = B.m
+        assert m(1, 2, a=2) == ('m', (1, 2), dict(a=2))
+
     def test_nested_partial_with_attribute(self):
         # see issue 25137
         partial = self.partial
@@ -207,10 +216,7 @@ def test_repr(self):
         kwargs = {'a': object(), 'b': object()}
         kwargs_reprs = ['a={a!r}, b={b!r}'.format_map(kwargs),
                         'b={b!r}, a={a!r}'.format_map(kwargs)]
-        if self.partial in _partial_types:
-            name = 'functools.partial'
-        else:
-            name = self.partial.__name__
+        name = f"{self.partial.__module__}.{self.partial.__qualname__}"
 
         f = self.partial(capture)
         self.assertEqual(f'{name}({capture!r})', repr(f))
@@ -229,10 +235,7 @@ def test_repr(self):
                        for kwargs_repr in kwargs_reprs])
 
     def test_recursive_repr(self):
-        if self.partial in _partial_types:
-            name = 'functools.partial'
-        else:
-            name = self.partial.__name__
+        name = f"{self.partial.__module__}.{self.partial.__qualname__}"
 
         f = self.partial(capture)
         f.__setstate__((f, (), {}, {}))
@@ -344,8 +347,10 @@ def test_recursive_pickle(self):
             f.__setstate__((f, (), {}, {}))
             try:
                 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    with self.assertRaises(RecursionError):
-                        pickle.dumps(f, proto)
+                    # gh-117008: Small limit since pickle uses C stack memory
+                    with support.infinite_recursion(100):
+                        with self.assertRaises(RecursionError):
+                            pickle.dumps(f, proto)
             finally:
                 f.__setstate__((capture, (), {}, {}))
 
@@ -390,6 +395,30 @@ def __getitem__(self, key):
         f = self.partial(object)
         self.assertRaises(TypeError, f.__setstate__, BadSequence())
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_partial_as_method(self):
+        class A:
+            meth = self.partial(capture, 1, a=2)
+            cmeth = classmethod(self.partial(capture, 1, a=2))
+            smeth = staticmethod(self.partial(capture, 1, a=2))
+
+        a = A()
+        self.assertEqual(A.meth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
+        self.assertEqual(A.cmeth(3, b=4), ((1, A, 3), {'a': 2, 'b': 4}))
+        self.assertEqual(A.smeth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
+        with self.assertWarns(FutureWarning) as w:
+            self.assertEqual(a.meth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
+        self.assertEqual(w.filename, __file__)
+        self.assertEqual(a.cmeth(3, b=4), ((1, A, 3), {'a': 2, 'b': 4}))
+        self.assertEqual(a.smeth(3, b=4), ((1, 3), {'a': 2, 'b': 4}))
+
+    def test_partial_genericalias(self):
+        alias = self.partial[int]
+        self.assertIs(alias.__origin__, self.partial)
+        self.assertEqual(alias.__args__, (int,))
+        self.assertEqual(alias.__parameters__, ())
+
+
 @unittest.skipUnless(c_functools, 'requires the C _functools module')
 class TestPartialC(TestPartial, unittest.TestCase):
     if c_functools:
@@ -436,6 +465,12 @@ def __str__(self):
         self.assertIn('astr', r)
         self.assertIn("['sth']", r)
 
+    def test_repr(self):
+        return super().test_repr()
+
+    def test_recursive_repr(self):
+        return super().test_recursive_repr()
+
 
 class TestPartialPy(TestPartial, unittest.TestCase):
     module = py_functools
@@ -454,14 +489,6 @@ class TestPartialCSubclass(TestPartialC):
     if c_functools:
         partial = CPartialSubclass
 
-    # TODO: RUSTPYTHON
-    def test_pickle(self):
-        TestPartial.test_pickle(self)
-
-    # TODO: RUSTPYTHON
-    def test_recursive_pickle(self):
-        TestPartial.test_recursive_pickle(self)
-
     # partial subclasses are not optimized for nested calls
     test_nested_optimization = None
 
@@ -572,6 +599,14 @@ class B:
                 method = functools.partialmethod(func=capture, a=1)
 
     def test_repr(self):
+        self.assertEqual(repr(vars(self.A)['nothing']),
+                         'functools.partialmethod({})'.format(capture))
+        self.assertEqual(repr(vars(self.A)['positional']),
+                         'functools.partialmethod({}, 1)'.format(capture))
+        self.assertEqual(repr(vars(self.A)['keywords']),
+                         'functools.partialmethod({}, a=2)'.format(capture))
+        self.assertEqual(repr(vars(self.A)['spec_keywords']),
+                         'functools.partialmethod({}, self=1, func=2)'.format(capture))
         self.assertEqual(repr(vars(self.A)['both']),
                          'functools.partialmethod({}, 3, b=4)'.format(capture))
 
@@ -620,9 +655,7 @@ def check_wrapper(self, wrapper, wrapped,
 
 
     def _default_update(self):
-        # XXX: RUSTPYTHON; f[T] is not supported yet
-        # def f[T](a:'This is a new annotation'):
-        def f(a:'This is a new annotation'):
+        def f[T](a:'This is a new annotation'):
             """This is a test"""
             pass
         f.attr = 'This is also a test'
@@ -632,8 +665,6 @@ def wrapper(b:'This is the prior annotation'):
         functools.update_wrapper(wrapper, f)
         return wrapper, f
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_default_update(self):
         wrapper, f = self._default_update()
         self.check_wrapper(wrapper, f)
@@ -717,6 +748,14 @@ def wrapper():
         self.assertTrue(wrapper.__doc__.startswith('max('))
         self.assertEqual(wrapper.__annotations__, {})
 
+    def test_update_type_wrapper(self):
+        def wrapper(*args): pass
+
+        functools.update_wrapper(wrapper, type)
+        self.assertEqual(wrapper.__name__, 'type')
+        self.assertEqual(wrapper.__annotations__, {})
+        self.assertEqual(wrapper.__type_params__, ())
+
 
 class TestWraps(TestUpdateWrapper):
 
@@ -951,9 +990,16 @@ def mycmp(x, y):
         self.assertRaises(TypeError, hash, k)
         self.assertNotIsInstance(k, collections.abc.Hashable)
 
+    @unittest.skipIf(support.MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
     def test_cmp_to_signature(self):
-        self.assertEqual(str(Signature.from_callable(self.cmp_to_key)),
-                         '(mycmp)')
+        sig = Signature.from_callable(self.cmp_to_key)
+        self.assertEqual(str(sig), '(mycmp)')
+        def mycmp(x, y):
+            return y - x
+        sig = Signature.from_callable(self.cmp_to_key(mycmp))
+        self.assertEqual(str(sig), '(obj)')
+
 
 
 @unittest.skipUnless(c_functools, 'requires the C _functools module')
@@ -961,52 +1007,44 @@ class TestCmpToKeyC(TestCmpToKey, unittest.TestCase):
     if c_functools:
         cmp_to_key = c_functools.cmp_to_key
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
+    def test_disallow_instantiation(self):
+        # Ensure that the type disallows instantiation (bpo-43916)
+        support.check_disallow_instantiation(
+            self, type(c_functools.cmp_to_key(None))
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_cmp(self):
-        super().test_bad_cmp()
+        return super().test_bad_cmp()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cmp_to_key(self):
-        super().test_cmp_to_key()
+        return super().test_cmp_to_key()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cmp_to_key_arguments(self):
-        super().test_cmp_to_key_arguments()
+        return super().test_cmp_to_key_arguments()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_cmp_to_signature(self):
+        return super().test_cmp_to_signature()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_hash(self):
-        super().test_hash()
+        return super().test_hash()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_obj_field(self):
-        super().test_obj_field()
+        return super().test_obj_field()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sort_int(self):
-        super().test_sort_int()
+        return super().test_sort_int()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sort_int_str(self):
-        super().test_sort_int_str()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_cmp_to_signature(self):
-        super().test_cmp_to_signature()
-
-    @support.cpython_only
-    def test_disallow_instantiation(self):
-        # Ensure that the type disallows instantiation (bpo-43916)
-        support.check_disallow_instantiation(
-            self, type(c_functools.cmp_to_key(None))
-        )
+        return super().test_sort_int_str()
 
 
 class TestCmpToKeyPy(TestCmpToKey, unittest.TestCase):
@@ -1340,6 +1378,16 @@ def fib(n):
             self.module._CacheInfo(hits=0, misses=0, maxsize=None, currsize=0))
 
 
+class TestCachePy(TestCache, unittest.TestCase):
+    module = py_functools
+
+
+@unittest.skipUnless(c_functools, 'requires the C _functools module')
+class TestCacheC(TestCache, unittest.TestCase):
+    if c_functools:
+        module = c_functools
+
+
 class TestLRU:
 
     def test_lru(self):
@@ -1773,8 +1821,7 @@ def f(x):
             time.sleep(.01)
             return 3 * x
         def test(i, x):
-            with self.subTest(thread=i):
-                self.assertEqual(f(x), 3 * x, i)
+            self.assertEqual(f(x), 3 * x, i)
         threads = [threading.Thread(target=test, args=(i, v))
                    for i, v in enumerate([1, 2, 2, 3, 2])]
         with threading_helper.start_threads(threads):
@@ -1878,6 +1925,7 @@ def f():
             return 1
         self.assertEqual(f.cache_parameters(), {'maxsize': 1000, "typed": True})
 
+    @support.suppress_immortalization()
     def test_lru_cache_weakrefable(self):
         @self.module.lru_cache
         def test_function(x):
@@ -1908,12 +1956,33 @@ def test_staticmethod(x):
             self.assertIsNone(ref())
 
     def test_common_signatures(self):
-        def orig(): ...
+        def orig(a, /, b, c=True): ...
         lru = self.module.lru_cache(1)(orig)
 
+        self.assertEqual(str(Signature.from_callable(lru)), '(a, /, b, c=True)')
         self.assertEqual(str(Signature.from_callable(lru.cache_info)), '()')
         self.assertEqual(str(Signature.from_callable(lru.cache_clear)), '()')
 
+    @support.skip_on_s390x
+    @unittest.skipIf(support.is_wasi, "WASI has limited C stack")
+    def test_lru_recursion(self):
+
+        @self.module.lru_cache
+        def fib(n):
+            if n <= 1:
+                return n
+            return fib(n-1) + fib(n-2)
+
+        if not support.Py_DEBUG:
+            depth = support.get_c_recursion_limit()*2//7
+            with support.infinite_recursion():
+                fib(depth)
+        if self.module == c_functools:
+            fib.cache_clear()
+            with support.infinite_recursion():
+                with self.assertRaises(RecursionError):
+                    fib(10000)
+
 
 @py_functools.lru_cache()
 def py_cached_func(x, y):
@@ -2524,6 +2593,74 @@ def _(arg):
         self.assertTrue(A.t(''))
         self.assertEqual(A.t(0.0), 0.0)
 
+    def test_slotted_class(self):
+        class Slot:
+            __slots__ = ('a', 'b')
+            @functools.singledispatchmethod
+            def go(self, item, arg):
+                pass
+
+            @go.register
+            def _(self, item: int, arg):
+                return item + arg
+
+        s = Slot()
+        self.assertEqual(s.go(1, 1), 2)
+
+    def test_classmethod_slotted_class(self):
+        class Slot:
+            __slots__ = ('a', 'b')
+            @functools.singledispatchmethod
+            @classmethod
+            def go(cls, item, arg):
+                pass
+
+            @go.register
+            @classmethod
+            def _(cls, item: int, arg):
+                return item + arg
+
+        s = Slot()
+        self.assertEqual(s.go(1, 1), 2)
+        self.assertEqual(Slot.go(1, 1), 2)
+
+    def test_staticmethod_slotted_class(self):
+        class A:
+            __slots__ = ['a']
+            @functools.singledispatchmethod
+            @staticmethod
+            def t(arg):
+                return arg
+            @t.register(int)
+            @staticmethod
+            def _(arg):
+                return isinstance(arg, int)
+            @t.register(str)
+            @staticmethod
+            def _(arg):
+                return isinstance(arg, str)
+        a = A()
+
+        self.assertTrue(A.t(0))
+        self.assertTrue(A.t(''))
+        self.assertEqual(A.t(0.0), 0.0)
+        self.assertTrue(a.t(0))
+        self.assertTrue(a.t(''))
+        self.assertEqual(a.t(0.0), 0.0)
+
+    def test_assignment_behavior(self):
+        # see gh-106448
+        class A:
+            @functools.singledispatchmethod
+            def t(arg):
+                return arg
+
+        a = A()
+        a.t.foo = 'bar'
+        a2 = A()
+        with self.assertRaises(AttributeError):
+            a2.t.foo
+
     def test_classmethod_register(self):
         class A:
             def __init__(self, arg):
@@ -2659,6 +2796,7 @@ def static_func(arg: int) -> str:
                 """My function docstring"""
                 return str(arg)
 
+        prefix = A.__qualname__ + '.'
         for meth in (
             A.func,
             A().func,
@@ -2668,7 +2806,11 @@ def static_func(arg: int) -> str:
             A().static_func
         ):
             with self.subTest(meth=meth):
-                self.assertEqual(meth.__doc__, 'My function docstring')
+                self.assertEqual(meth.__qualname__, prefix + meth.__name__)
+                self.assertEqual(meth.__doc__,
+                                 ('My function docstring'
+                                  if support.HAVE_PY_DOCSTRINGS
+                                  else None))
                 self.assertEqual(meth.__annotations__['arg'], int)
 
         self.assertEqual(A.func.__name__, 'func')
@@ -2757,7 +2899,10 @@ def decorated_classmethod(cls, arg: int) -> str:
             WithSingleDispatch().decorated_classmethod
         ):
             with self.subTest(meth=meth):
-                self.assertEqual(meth.__doc__, 'My function docstring')
+                self.assertEqual(meth.__doc__,
+                                 ('My function docstring'
+                                  if support.HAVE_PY_DOCSTRINGS
+                                  else None))
                 self.assertEqual(meth.__annotations__['arg'], int)
 
         self.assertEqual(
@@ -2829,11 +2974,26 @@ def _(arg: typing.Union[int, typing.Iterable[str]]):
 
     def test_invalid_positional_argument(self):
         @functools.singledispatch
-        def f(*args):
+        def f(*args, **kwargs):
             pass
         msg = 'f requires at least 1 positional argument'
         with self.assertRaisesRegex(TypeError, msg):
             f()
+        msg = 'f requires at least 1 positional argument'
+        with self.assertRaisesRegex(TypeError, msg):
+            f(a=1)
+
+    def test_invalid_positional_argument_singledispatchmethod(self):
+        class A:
+            @functools.singledispatchmethod
+            def t(self, *args, **kwargs):
+                pass
+        msg = 't requires at least 1 positional argument'
+        with self.assertRaisesRegex(TypeError, msg):
+            A().t()
+        msg = 't requires at least 1 positional argument'
+        with self.assertRaisesRegex(TypeError, msg):
+            A().t(a=1)
 
     def test_union(self):
         @functools.singledispatch
@@ -2957,6 +3117,115 @@ def _(arg: typing.List[float] | bytes):
         self.assertEqual(f(""), "default")
         self.assertEqual(f(b""), "default")
 
+    def test_method_equal_instances(self):
+        # gh-127750: Reference to self was cached
+        class A:
+            def __eq__(self, other):
+                return True
+            def __hash__(self):
+                return 1
+            @functools.singledispatchmethod
+            def t(self, arg):
+                return self
+
+        a = A()
+        b = A()
+        self.assertIs(a.t(1), a)
+        self.assertIs(b.t(2), b)
+
+    def test_method_bad_hash(self):
+        class A:
+            def __eq__(self, other):
+                raise AssertionError
+            def __hash__(self):
+                raise AssertionError
+            @functools.singledispatchmethod
+            def t(self, arg):
+                pass
+
+        # Should not raise
+        A().t(1)
+        hash(A().t)
+        A().t == A().t
+
+    def test_method_no_reference_loops(self):
+        # gh-127750: Created a strong reference to self
+        class A:
+            @functools.singledispatchmethod
+            def t(self, arg):
+                return weakref.ref(self)
+
+        a = A()
+        r = a.t(1)
+        self.assertIsNotNone(r())
+        del a  # delete a after a.t
+        if not support.check_impl_detail(cpython=True):
+            support.gc_collect()
+        self.assertIsNone(r())
+
+        a = A()
+        t = a.t
+        del a # delete a before a.t
+        support.gc_collect()
+        r = t(1)
+        self.assertIsNotNone(r())
+        del t
+        if not support.check_impl_detail(cpython=True):
+            support.gc_collect()
+        self.assertIsNone(r())
+
+    def test_signatures(self):
+        @functools.singledispatch
+        def func(item, arg: int) -> str:
+            return str(item)
+        @func.register
+        def _(item: int, arg: bytes) -> str:
+            return str(item)
+
+        self.assertEqual(str(Signature.from_callable(func)),
+                         '(item, arg: int) -> 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:
+                return str(item)
+
+            @functools.singledispatchmethod
+            @classmethod
+            def cls_func(cls, item, arg: int) -> str:
+                return str(arg)
+            @func.register
+            @classmethod
+            def _(cls, item, arg: bytes) -> str:
+                return str(item)
+
+            @functools.singledispatchmethod
+            @staticmethod
+            def static_func(item, arg: int) -> str:
+                return str(arg)
+            @func.register
+            @staticmethod
+            def _(item, arg: bytes) -> str:
+                return str(item)
+
+        self.assertEqual(str(Signature.from_callable(A.func)),
+                         '(self, item, arg: int) -> str')
+        self.assertEqual(str(Signature.from_callable(A().func)),
+                         '(self, item, arg: int) -> str')
+        self.assertEqual(str(Signature.from_callable(A.cls_func)),
+                         '(cls, item, arg: int) -> str')
+        self.assertEqual(str(Signature.from_callable(A.static_func)),
+                         '(item, arg: int) -> str')
+
 
 class CachedCostItem:
     _cost = 1
@@ -3007,8 +3276,6 @@ def test_cached_attribute_name_differs_from_func_name(self):
         self.assertEqual(item.get_cost(), 4)
         self.assertEqual(item.cached_cost, 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_object_with_slots(self):
         item = CachedCostItemWithSlots()
         with self.assertRaisesRegex(
@@ -3032,8 +3299,7 @@ class MyClass(metaclass=MyMeta):
         ):
             MyClass.prop
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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:
@@ -3089,7 +3355,13 @@ def test_access_from_class(self):
         self.assertIsInstance(CachedCostItem.cost, py_functools.cached_property)
 
     def test_doc(self):
-        self.assertEqual(CachedCostItem.cost.__doc__, "The cost of the item.")
+        self.assertEqual(CachedCostItem.cost.__doc__,
+                         ("The cost of the item."
+                          if support.HAVE_PY_DOCSTRINGS
+                          else None))
+
+    def test_module(self):
+        self.assertEqual(CachedCostItem.cost.__module__, CachedCostItem.__module__)
 
     def test_subclass_with___set__(self):
         """Caching still works for a subclass defining __set__."""
diff --git a/Lib/test/test_future_stmt/badsyntax_future10.py b/Lib/test/test_future_stmt/badsyntax_future.py
similarity index 100%
rename from Lib/test/test_future_stmt/badsyntax_future10.py
rename to Lib/test/test_future_stmt/badsyntax_future.py
diff --git a/Lib/test/test_future_stmt/badsyntax_future3.py b/Lib/test/test_future_stmt/badsyntax_future3.py
deleted file mode 100644
index f1c8417eda..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future3.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-from __future__ import nested_scopes
-from __future__ import rested_snopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future4.py b/Lib/test/test_future_stmt/badsyntax_future4.py
deleted file mode 100644
index b5f4c98e92..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future4.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-import __future__
-from __future__ import nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future5.py b/Lib/test/test_future_stmt/badsyntax_future5.py
deleted file mode 100644
index 8a7e5fcb70..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future5.py
+++ /dev/null
@@ -1,12 +0,0 @@
-"""This is a test"""
-from __future__ import nested_scopes
-import foo
-from __future__ import nested_scopes
-
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future6.py b/Lib/test/test_future_stmt/badsyntax_future6.py
deleted file mode 100644
index 5a8b55a02c..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future6.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-"this isn't a doc string"
-from __future__ import nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future7.py b/Lib/test/test_future_stmt/badsyntax_future7.py
deleted file mode 100644
index 131db2c216..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future7.py
+++ /dev/null
@@ -1,11 +0,0 @@
-"""This is a test"""
-
-from __future__ import nested_scopes; import string; from __future__ import \
-     nested_scopes
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-result = f(2)(4)
diff --git a/Lib/test/test_future_stmt/badsyntax_future8.py b/Lib/test/test_future_stmt/badsyntax_future8.py
deleted file mode 100644
index ca45289e2e..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future8.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-
-from __future__ import *
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-print(f(2)(4))
diff --git a/Lib/test/test_future_stmt/badsyntax_future9.py b/Lib/test/test_future_stmt/badsyntax_future9.py
deleted file mode 100644
index 916de06ab7..0000000000
--- a/Lib/test/test_future_stmt/badsyntax_future9.py
+++ /dev/null
@@ -1,10 +0,0 @@
-"""This is a test"""
-
-from __future__ import nested_scopes, braces
-
-def f(x):
-    def g(y):
-        return x + y
-    return g
-
-print(f(2)(4))
diff --git a/Lib/test/test_future_stmt/future_test1.py b/Lib/test/test_future_stmt/import_nested_scope_twice.py
similarity index 100%
rename from Lib/test/test_future_stmt/future_test1.py
rename to Lib/test/test_future_stmt/import_nested_scope_twice.py
diff --git a/Lib/test/test_future_stmt/future_test2.py b/Lib/test/test_future_stmt/nested_scope.py
similarity index 100%
rename from Lib/test/test_future_stmt/future_test2.py
rename to Lib/test/test_future_stmt/nested_scope.py
diff --git a/Lib/test/test_future_stmt/test_future.py b/Lib/test/test_future_stmt/test_future.py
index 9c30054963..febd9fb095 100644
--- a/Lib/test/test_future_stmt/test_future.py
+++ b/Lib/test/test_future_stmt/test_future.py
@@ -10,6 +10,8 @@
 import re
 import sys
 
+TOP_LEVEL_MSG = 'from __future__ imports must occur at the beginning of the file'
+
 rx = re.compile(r'\((\S+).py, line (\d+)')
 
 def get_error_location(msg):
@@ -18,21 +20,48 @@ def get_error_location(msg):
 
 class FutureTest(unittest.TestCase):
 
-    def check_syntax_error(self, err, basename, lineno, offset=1):
-        self.assertIn('%s.py, line %d' % (basename, lineno), str(err))
-        self.assertEqual(os.path.basename(err.filename), basename + '.py')
+    def check_syntax_error(self, err, basename,
+                           *,
+                           lineno,
+                           message=TOP_LEVEL_MSG, offset=1):
+        if basename != '<string>':
+            basename += '.py'
+
+        self.assertEqual(f'{message} ({basename}, line {lineno})', str(err))
+        self.assertEqual(os.path.basename(err.filename), basename)
         self.assertEqual(err.lineno, lineno)
         self.assertEqual(err.offset, offset)
 
-    def test_future1(self):
-        with import_helper.CleanImport('test.test_future_stmt.future_test1'):
-            from test.test_future_stmt import future_test1
-            self.assertEqual(future_test1.result, 6)
+    def assertSyntaxError(self, code,
+                          *,
+                          lineno=1,
+                          message=TOP_LEVEL_MSG, offset=1,
+                          parametrize_docstring=True):
+        code = dedent(code.lstrip('\n'))
+        for add_docstring in ([False, True] if parametrize_docstring else [False]):
+            with self.subTest(code=code, add_docstring=add_docstring):
+                if add_docstring:
+                    code = '"""Docstring"""\n' + code
+                    lineno += 1
+                with self.assertRaises(SyntaxError) as cm:
+                    exec(code)
+                self.check_syntax_error(cm.exception, "<string>",
+                                        lineno=lineno,
+                                        message=message,
+                                        offset=offset)
+
+    def test_import_nested_scope_twice(self):
+        # Import the name nested_scopes twice to trigger SF bug #407394
+        with import_helper.CleanImport(
+            'test.test_future_stmt.import_nested_scope_twice',
+        ):
+            from test.test_future_stmt import import_nested_scope_twice
+        self.assertEqual(import_nested_scope_twice.result, 6)
 
-    def test_future2(self):
-        with import_helper.CleanImport('test.test_future_stmt.future_test2'):
-            from test.test_future_stmt import future_test2
-            self.assertEqual(future_test2.result, 6)
+    def test_nested_scope(self):
+        with import_helper.CleanImport('test.test_future_stmt.nested_scope'):
+            from test.test_future_stmt import nested_scope
+        self.assertEqual(nested_scope.result, 6)
 
     def test_future_single_import(self):
         with import_helper.CleanImport(
@@ -52,47 +81,92 @@ def test_future_multiple_features(self):
         ):
             from test.test_future_stmt import test_future_multiple_features
 
-    def test_badfuture3(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future3
-        self.check_syntax_error(cm.exception, "badsyntax_future3", 3)
+    # TODO: RUSTPYTHON
+    # AssertionError: 1 != 24
+    @unittest.expectedFailure
+    def test_unknown_future_flag(self):
+        code = """
+            from __future__ import nested_scopes
+            from __future__ import rested_snopes  # typo error here: nested => rested
+        """
+        self.assertSyntaxError(
+            code, lineno=2,
+            message='future feature rested_snopes is not defined', offset=24,
+        )
 
-    def test_badfuture4(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future4
-        self.check_syntax_error(cm.exception, "badsyntax_future4", 3)
+    def test_future_import_not_on_top(self):
+        code = """
+            import some_module
+            from __future__ import annotations
+        """
+        self.assertSyntaxError(code, lineno=2)
 
-    def test_badfuture5(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future5
-        self.check_syntax_error(cm.exception, "badsyntax_future5", 4)
+        code = """
+            import __future__
+            from __future__ import annotations
+        """
+        self.assertSyntaxError(code, lineno=2)
+
+        code = """
+            from __future__ import absolute_import
+            "spam, bar, blah"
+            from __future__ import print_function
+        """
+        self.assertSyntaxError(code, lineno=3)
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
-    def test_badfuture6(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future6
-        self.check_syntax_error(cm.exception, "badsyntax_future6", 3)
+    def test_future_import_with_extra_string(self):
+        code = """
+            '''Docstring'''
+            "this isn't a doc string"
+            from __future__ import nested_scopes
+        """
+        self.assertSyntaxError(code, lineno=3, parametrize_docstring=False)
 
-    def test_badfuture7(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future7
-        self.check_syntax_error(cm.exception, "badsyntax_future7", 3, 54)
+    def test_multiple_import_statements_on_same_line(self):
+        # With `\`:
+        code = """
+            from __future__ import nested_scopes; import string; from __future__ import \
+        nested_scopes
+        """
+        self.assertSyntaxError(code, offset=54)
 
-    def test_badfuture8(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future8
-        self.check_syntax_error(cm.exception, "badsyntax_future8", 3)
+        # Without `\`:
+        code = """
+            from __future__ import nested_scopes; import string; from __future__ import  nested_scopes
+        """
+        self.assertSyntaxError(code, offset=54)
 
-    def test_badfuture9(self):
-        with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future9
-        self.check_syntax_error(cm.exception, "badsyntax_future9", 3)
+    # TODO: RUSTPYTHON
+    # AssertionError: 1 != 24
+    @unittest.expectedFailure
+    def test_future_import_star(self):
+        code = """
+            from __future__ import *
+        """
+        self.assertSyntaxError(code, message='future feature * is not defined', offset=24)
+
+    # TODO: RUSTPYTHON
+    # AssertionError: 'not a chance (<string>, line 2)' != 'future feature braces is not defined (<string>, line 2)'
+    @unittest.expectedFailure
+    def test_future_import_braces(self):
+        code = """
+            from __future__ import braces
+        """
+        # Congrats, you found an easter egg!
+        self.assertSyntaxError(code, message='not a chance', offset=24)
 
-    def test_badfuture10(self):
+        code = """
+            from __future__ import nested_scopes, braces
+        """
+        self.assertSyntaxError(code, message='not a chance', offset=39)
+
+    def test_module_with_future_import_not_on_top(self):
         with self.assertRaises(SyntaxError) as cm:
-            from test.test_future_stmt import badsyntax_future10
-        self.check_syntax_error(cm.exception, "badsyntax_future10", 3)
+            from test.test_future_stmt import badsyntax_future
+        self.check_syntax_error(cm.exception, "badsyntax_future", lineno=3)
 
     def test_ensure_flags_dont_clash(self):
         # bpo-39562: test that future flags and compiler flags doesn't clash
@@ -109,26 +183,6 @@ def test_ensure_flags_dont_clash(self):
         }
         self.assertCountEqual(set(flags.values()), flags.values())
 
-    def test_parserhack(self):
-        # test that the parser.c::future_hack function works as expected
-        # Note: although this test must pass, it's not testing the original
-        #       bug as of 2.6 since the with statement is not optional and
-        #       the parser hack disabled. If a new keyword is introduced in
-        #       2.6, change this to refer to the new future import.
-        try:
-            exec("from __future__ import print_function; print 0")
-        except SyntaxError:
-            pass
-        else:
-            self.fail("syntax error didn't occur")
-
-        try:
-            exec("from __future__ import (print_function); print 0")
-        except SyntaxError:
-            pass
-        else:
-            self.fail("syntax error didn't occur")
-
     def test_unicode_literals_exec(self):
         scope = {}
         exec("from __future__ import unicode_literals; x = ''", {}, scope)
@@ -141,6 +195,27 @@ def test_syntactical_future_repl(self):
         out = kill_python(p)
         self.assertNotIn(b'SyntaxError: invalid syntax', out)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    # SyntaxError: future feature spam is not defined
+    def test_future_dotted_import(self):
+        with self.assertRaises(ImportError):
+            exec("from .__future__ import spam")
+
+        code = dedent(
+            """
+            from __future__ import print_function
+            from ...__future__ import ham
+            """
+        )
+        with self.assertRaises(ImportError):
+            exec(code)
+
+        code = """
+            from .__future__ import nested_scopes
+            from __future__ import barry_as_FLUFL
+        """
+        self.assertSyntaxError(code, lineno=2)
+
 class AnnotationsFutureTestCase(unittest.TestCase):
     template = dedent(
         """
@@ -385,6 +460,7 @@ def test_infinity_numbers(self):
         self.assertAnnotationEqual("(1e1000, (1e1000j,))", expected=f"({inf}, ({infj},))")
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
     def test_annotation_with_complex_target(self):
         with self.assertRaises(SyntaxError):
@@ -410,6 +486,7 @@ def bar():
         self.assertEqual(foo().__code__.co_freevars, ())
 
     # TODO: RUSTPYTHON
+    # AssertionError: SyntaxError not raised
     @unittest.expectedFailure
     def test_annotations_forbidden(self):
         with self.assertRaises(SyntaxError):
diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index 5ed0986150..853767135a 100644
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -2,9 +2,11 @@
 import gc
 import pickle
 import sys
+import doctest
 import unittest
 import weakref
 import inspect
+import types
 
 from test import support
 
@@ -46,8 +48,7 @@ def test_raise_and_yield_from(self):
 
 class FinalizationTest(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_frame_resurrect(self):
         # A generator frame can be resurrected by a generator's finalization.
         def gen():
@@ -67,8 +68,7 @@ def gen():
         del frame
         support.gc_collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_refcycle(self):
         # A generator caught in a refcycle gets finalized anyway.
         old_garbage = gc.garbage[:]
@@ -92,9 +92,12 @@ def gen():
         self.assertEqual(gc.garbage, old_garbage)
 
     def test_lambda_generator(self):
-        # Issue #23192: Test that a lambda returning a generator behaves
+        # bpo-23192, gh-119897: Test that a lambda returning a generator behaves
         # like the equivalent function
         f = lambda: (yield 1)
+        self.assertIsInstance(f(), types.GeneratorType)
+        self.assertEqual(next(f()), 1)
+
         def g(): return (yield 1)
 
         # test 'yield from'
@@ -114,8 +117,6 @@ def g3(): return (yield from f())
 
 class GeneratorTest(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_name(self):
         def func():
             yield 1
@@ -175,6 +176,153 @@ 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
+        #See https://github.com/python/cpython/issues/94262
+
+        def cb(*args):
+            inspect.stack()
+
+        def gen():
+            yield 1
+
+        thresholds = gc.get_threshold()
+
+        gc.callbacks.append(cb)
+        gc.set_threshold(1, 0, 0)
+        try:
+            gen()
+        finally:
+            gc.set_threshold(*thresholds)
+            gc.callbacks.pop()
+
+        class Sneaky:
+            def __del__(self):
+                inspect.stack()
+
+        sneaky = Sneaky()
+        sneaky._s = Sneaky()
+        sneaky._s._s = sneaky
+
+        gc.set_threshold(1, 0, 0)
+        try:
+            del sneaky
+            gen()
+        finally:
+            gc.set_threshold(*thresholds)
+
+    def test_ag_frame_f_back(self):
+        async def f():
+            yield
+        ag = f()
+        self.assertIsNone(ag.ag_frame.f_back)
+
+    def test_cr_frame_f_back(self):
+        async def f():
+            pass
+        cr = f()
+        self.assertIsNone(cr.cr_frame.f_back)
+        cr.close()  # Suppress RuntimeWarning.
+
+    def test_gi_frame_f_back(self):
+        def f():
+            yield
+        gi = f()
+        self.assertIsNone(gi.gi_frame.f_back)
+
+    def test_issue103488(self):
+
+        def gen_raises():
+            yield
+            raise ValueError()
+
+        def loop():
+            try:
+                for _ in gen_raises():
+                    if True is False:
+                        return
+            except ValueError:
+                pass
+
+        #This should not raise
+        loop()
+
+
+class ModifyUnderlyingIterableTest(unittest.TestCase):
+    iterables = [
+        range(0),
+        range(20),
+        [1, 2, 3],
+        (2,),
+        {13, 48, 211},
+        frozenset((15, 8, 6)),
+        {1: 2, 3: 4},
+    ]
+
+    non_iterables = [
+        None,
+        42,
+        3.0,
+        2j,
+    ]
+
+    def genexpr(self):
+        return (x for x in range(10))
+
+    def genfunc(self):
+        def gen(it):
+            for x in it:
+                yield x
+        return gen(range(10))
+
+    def process_tests(self, get_generator):
+        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))
+
+            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)
+
+    @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
+            return g
+
+        def get_generator_genexpr(obj):
+            return modify_f_locals(self.genexpr(), '.0', 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)
+
+    @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, {})
+            return generator_func(obj)
+
+        def get_generator_genexpr(obj):
+            return new_gen_from_gi_code(self.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)
+
 
 class ExceptionTest(unittest.TestCase):
     # Tests for the issue #23353: check that the currently handled exception
@@ -183,16 +331,16 @@ class ExceptionTest(unittest.TestCase):
     def test_except_throw(self):
         def store_raise_exc_generator():
             try:
-                self.assertEqual(sys.exc_info()[0], None)
+                self.assertIsNone(sys.exception())
                 yield
             except Exception as exc:
                 # exception raised by gen.throw(exc)
-                self.assertEqual(sys.exc_info()[0], ValueError)
+                self.assertIsInstance(sys.exception(), ValueError)
                 self.assertIsNone(exc.__context__)
                 yield
 
                 # ensure that the exception is not lost
-                self.assertEqual(sys.exc_info()[0], ValueError)
+                self.assertIsInstance(sys.exception(), ValueError)
                 yield
 
                 # we should be able to raise back the ValueError
@@ -214,11 +362,11 @@ def store_raise_exc_generator():
             next(make)
         self.assertIsNone(cm.exception.__context__)
 
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def test_except_next(self):
         def gen():
-            self.assertEqual(sys.exc_info()[0], ValueError)
+            self.assertIsInstance(sys.exception(), ValueError)
             yield "done"
 
         g = gen()
@@ -226,23 +374,23 @@ def gen():
             raise ValueError
         except Exception:
             self.assertEqual(next(g), "done")
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
     def test_except_gen_except(self):
         def gen():
             try:
-                self.assertEqual(sys.exc_info()[0], None)
+                self.assertIsNone(sys.exception())
                 yield
                 # we are called from "except ValueError:", TypeError must
                 # inherit ValueError in its context
                 raise TypeError()
             except TypeError as exc:
-                self.assertEqual(sys.exc_info()[0], TypeError)
+                self.assertIsInstance(sys.exception(), TypeError)
                 self.assertEqual(type(exc.__context__), ValueError)
             # here we are still called from the "except ValueError:"
-            self.assertEqual(sys.exc_info()[0], ValueError)
+            self.assertIsInstance(sys.exception(), ValueError)
             yield
-            self.assertIsNone(sys.exc_info()[0])
+            self.assertIsNone(sys.exception())
             yield "done"
 
         g = gen()
@@ -253,25 +401,45 @@ def gen():
             next(g)
 
         self.assertEqual(next(g), "done")
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
+
+    def test_nested_gen_except_loop(self):
+        def gen():
+            for i in range(100):
+                self.assertIsInstance(sys.exception(), TypeError)
+                yield "doing"
+
+        def outer():
+            try:
+                raise TypeError
+            except:
+                for x in gen():
+                    yield x
+
+        try:
+            raise ValueError
+        except Exception:
+            for x in outer():
+                self.assertEqual(x, "doing")
+        self.assertEqual(sys.exception(), None)
 
     def test_except_throw_exception_context(self):
         def gen():
             try:
                 try:
-                    self.assertEqual(sys.exc_info()[0], None)
+                    self.assertIsNone(sys.exception())
                     yield
                 except ValueError:
                     # we are called from "except ValueError:"
-                    self.assertEqual(sys.exc_info()[0], ValueError)
+                    self.assertIsInstance(sys.exception(), ValueError)
                     raise TypeError()
             except Exception as exc:
-                self.assertEqual(sys.exc_info()[0], TypeError)
+                self.assertIsInstance(sys.exception(), TypeError)
                 self.assertEqual(type(exc.__context__), ValueError)
             # we are still called from "except ValueError:"
-            self.assertEqual(sys.exc_info()[0], ValueError)
+            self.assertIsInstance(sys.exception(), ValueError)
             yield
-            self.assertIsNone(sys.exc_info()[0])
+            self.assertIsNone(sys.exception())
             yield "done"
 
         g = gen()
@@ -282,10 +450,9 @@ def gen():
             g.throw(exc)
 
         self.assertEqual(next(g), "done")
-        self.assertEqual(sys.exc_info(), (None, None, None))
+        self.assertIsNone(sys.exception())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_except_throw_bad_exception(self):
         class E(Exception):
             def __new__(cls, *args, **kwargs):
@@ -312,6 +479,15 @@ def generator():
         with self.assertRaises(StopIteration):
             gen.throw(E)
 
+    def test_gen_3_arg_deprecation_warning(self):
+        def g():
+            yield 42
+
+        gen = g()
+        with self.assertWarns(DeprecationWarning):
+            with self.assertRaises(TypeError):
+                gen.throw(TypeError, TypeError(24), None)
+
     def test_stopiteration_error(self):
         # See also PEP 479.
 
@@ -358,10 +534,197 @@ def g():
         self.assertEqual(cm.exception.value.value, 2)
 
 
+class GeneratorCloseTest(unittest.TestCase):
+
+    def test_close_no_return_value(self):
+        def f():
+            yield
+
+        gen = f()
+        gen.send(None)
+        self.assertIsNone(gen.close())
+
+    @unittest.expectedFailure # AssertionError: None != 0
+    def test_close_return_value(self):
+        def f():
+            try:
+                yield
+                # close() raises GeneratorExit here, which is caught
+            except GeneratorExit:
+                return 0
+
+        gen = f()
+        gen.send(None)
+        self.assertEqual(gen.close(), 0)
+
+    def test_close_not_catching_exit(self):
+        def f():
+            yield
+            # close() raises GeneratorExit here, which isn't caught and
+            # therefore propagates -- no return value
+            return 0
+
+        gen = f()
+        gen.send(None)
+        self.assertIsNone(gen.close())
+
+    def test_close_not_started(self):
+        def f():
+            try:
+                yield
+            except GeneratorExit:
+                return 0
+
+        gen = f()
+        self.assertIsNone(gen.close())
+
+    def test_close_exhausted(self):
+        def f():
+            try:
+                yield
+            except GeneratorExit:
+                return 0
+
+        gen = f()
+        next(gen)
+        with self.assertRaises(StopIteration):
+            next(gen)
+        self.assertIsNone(gen.close())
+
+    @unittest.expectedFailure # AssertionError: None != 0
+    def test_close_closed(self):
+        def f():
+            try:
+                yield
+            except GeneratorExit:
+                return 0
+
+        gen = f()
+        gen.send(None)
+        self.assertEqual(gen.close(), 0)
+        self.assertIsNone(gen.close())
+
+    def test_close_raises(self):
+        def f():
+            try:
+                yield
+            except GeneratorExit:
+                pass
+            raise RuntimeError
+
+        gen = f()
+        gen.send(None)
+        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
+
+        class Foo:
+            pass
+
+        f = Foo()
+        f_wr = weakref.ref(f)
+
+        def genfn():
+            a = f
+            yield
+
+        g = genfn()
+        next(g)
+        del f
+        g.close()
+        support.gc_collect()
+        self.assertIsNone(f_wr())
+
+
+# See https://github.com/python/cpython/issues/125723
+class GeneratorDeallocTest(unittest.TestCase):
+    def test_frame_outlives_generator(self):
+        def g1():
+            a = 42
+            yield sys._getframe()
+
+        def g2():
+            a = 42
+            yield
+
+        def g3(obj):
+            a = 42
+            obj.frame = sys._getframe()
+            yield
+
+        class ObjectWithFrame():
+            def __init__(self):
+                self.frame = None
+
+        def get_frame(index):
+            if index == 1:
+                return next(g1())
+            elif index == 2:
+                gen = g2()
+                next(gen)
+                return gen.gi_frame
+            elif index == 3:
+                obj = ObjectWithFrame()
+                next(g3(obj))
+                return obj.frame
+            else:
+                return None
+
+        for index in (1, 2, 3):
+            with self.subTest(index=index):
+                frame = get_frame(index)
+                frame_locals = frame.f_locals
+                self.assertIn('a', frame_locals)
+                self.assertEqual(frame_locals['a'], 42)
+
+    @unittest.expectedFailure # AssertionError: 'a' not found in {'frame_locals1': None}
+    def test_frame_locals_outlive_generator(self):
+        frame_locals1 = None
+
+        def g1():
+            nonlocal frame_locals1
+            frame_locals1 = sys._getframe().f_locals
+            a = 42
+            yield
+
+        def g2():
+            a = 42
+            yield sys._getframe().f_locals
+
+        def get_frame_locals(index):
+            if index == 1:
+                nonlocal frame_locals1
+                next(g1())
+                return frame_locals1
+            if index == 2:
+                return next(g2())
+            else:
+                return None
+
+        for index in (1, 2):
+            with self.subTest(index=index):
+                frame_locals = get_frame_locals(index)
+                self.assertIn('a', frame_locals)
+                self.assertEqual(frame_locals['a'], 42)
+
+    def test_frame_locals_outlive_generator_with_exec(self):
+        def g():
+            a = 42
+            yield locals(), sys._getframe().f_locals
+
+        locals_ = {'g': g}
+        for i in range(10):
+            exec("snapshot, live_locals = next(g())", locals=locals_)
+            for l in (locals_['snapshot'], locals_['live_locals']):
+                self.assertIn('a', l)
+                self.assertEqual(l['a'], 42)
+
+
 class GeneratorThrowTest(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_context_with_yield(self):
         def f():
             try:
@@ -398,8 +761,6 @@ def f():
         # This ensures that the assertions inside were executed.
         self.assertEqual(actual, 'b')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_context_with_yield_from(self):
         def f():
             yield
@@ -511,8 +872,7 @@ def call_throw(gen):
 
 
 class YieldFromTests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_generator_gi_yieldfrom(self):
         def a():
             self.assertEqual(inspect.getgeneratorstate(gen_b), inspect.GEN_RUNNING)
@@ -910,7 +1270,7 @@ def b():
 >>> type(i)
 <class 'generator'>
 >>> [s for s in dir(i) if not s.startswith('_')]
-['close', 'gi_code', 'gi_frame', 'gi_running', 'gi_yieldfrom', 'send', 'throw']
+['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).')
 Implement next(self).
@@ -2054,11 +2414,20 @@ def printsolution(self, x):
   ...
 SyntaxError: 'yield' outside function
 
-# Pegen does not produce this error message yet
-# >>> def f(): x = yield = y
-# Traceback (most recent call last):
-#   ...
-# SyntaxError: assignment to yield expression not possible
+>>> f=lambda: (yield from (1,2)), (yield from (3,4))
+Traceback (most recent call last):
+  ...
+SyntaxError: 'yield from' outside function
+
+>>> yield from [1,2]
+Traceback (most recent call last):
+  ...
+SyntaxError: 'yield from' outside function
+
+>>> def f(): x = yield = y
+Traceback (most recent call last):
+  ...
+SyntaxError: assignment to yield expression not possible
 
 >>> def f(): (yield bar) = y
 Traceback (most recent call last):
@@ -2089,6 +2458,13 @@ def printsolution(self, x):
 >>> g.throw(ValueError("xyz"))  # value only
 caught ValueError (xyz)
 
+>>> import warnings
+>>> old_filters = warnings.filters.copy()
+>>> warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Filter DeprecationWarning: regarding the (type, val, tb) signature of throw().
+# Deprecation warnings are re-enabled below.
+
 >>> g.throw(ValueError, ValueError(1))   # value+matching type
 caught ValueError (1)
 
@@ -2157,6 +2533,11 @@ def printsolution(self, x):
   ...
 ValueError: 7
 
+>>> warnings.filters[:] = old_filters
+
+# Re-enable DeprecationWarning: the (type, val, tb) exception representation is deprecated,
+#                               and may be removed in a future version of Python.
+
 Plain "raise" inside a generator should preserve the traceback (#13188).
 The traceback should have 3 levels:
 - g.throw()
@@ -2393,16 +2774,10 @@ def printsolution(self, x):
             "refleaks": refleaks_tests,
             }
 
-# Magic test name that regrtest.py invokes *after* importing this module.
-# This worms around a bootstrap problem.
-# Note that doctest and regrtest both look in sys.argv for a "-v" argument,
-# so this works as expected in both ways of running regrtest.
-def test_main(verbose=None):
-    from test import support, test_generators
-    support.run_unittest(__name__)
-    # TODO: RUSTPYTHON
-    # support.run_doctest(test_generators, verbose)
-
-# This part isn't needed for regrtest, but for running the test directly.
+def load_tests(loader, tests, pattern):
+    # tests.addTest(doctest.DocTestSuite()) # TODO: RUSTPYTHON
+    return tests
+
+
 if __name__ == "__main__":
-    test_main(1)
+    unittest.main()
diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
index 0daaff099a..c1c49dc29d 100644
--- a/Lib/test/test_genericalias.py
+++ b/Lib/test/test_genericalias.py
@@ -2,6 +2,7 @@
 
 import unittest
 import pickle
+from array import array
 import copy
 from collections import (
     defaultdict, deque, OrderedDict, Counter, UserDict, UserList
@@ -11,8 +12,11 @@
 from concurrent.futures.thread import _WorkItem
 from contextlib import AbstractContextManager, AbstractAsyncContextManager
 from contextvars import ContextVar, Token
+from csv import DictReader, DictWriter
 from dataclasses import Field
 from functools import partial, partialmethod, cached_property
+from graphlib import TopologicalSorter
+from logging import LoggerAdapter, StreamHandler
 from mailbox import Mailbox, _PartialFile
 try:
     import ctypes
@@ -23,29 +27,73 @@
 from fileinput import FileInput
 from itertools import chain
 from http.cookies import Morsel
-from multiprocessing.managers import ValueProxy
-from multiprocessing.pool import ApplyResult
+try:
+    from multiprocessing.managers import ValueProxy, DictProxy, ListProxy
+    from multiprocessing.pool import ApplyResult
+    from multiprocessing.queues import SimpleQueue as MPSimpleQueue
+    from multiprocessing.queues import Queue as MPQueue
+    from multiprocessing.queues import JoinableQueue as MPJoinableQueue
+except ImportError:
+    # _multiprocessing module is optional
+    ValueProxy = None
+    DictProxy = None
+    ListProxy = None
+    ApplyResult = None
+    MPSimpleQueue = None
+    MPQueue = None
+    MPJoinableQueue = None
 try:
     from multiprocessing.shared_memory import ShareableList
 except ImportError:
     # multiprocessing.shared_memory is not available on e.g. Android
     ShareableList = None
-from multiprocessing.queues import SimpleQueue as MPSimpleQueue
 from os import DirEntry
 from re import Pattern, Match
-from types import GenericAlias, MappingProxyType, AsyncGeneratorType
+from types import GenericAlias, MappingProxyType, AsyncGeneratorType, CoroutineType, GeneratorType
 from tempfile import TemporaryDirectory, SpooledTemporaryFile
 from urllib.parse import SplitResult, ParseResult
 from unittest.case import _AssertRaisesContext
 from queue import Queue, SimpleQueue
 from weakref import WeakSet, ReferenceType, ref
 import typing
+from typing import Unpack
 
 from typing import TypeVar
 T = TypeVar('T')
 K = TypeVar('K')
 V = TypeVar('V')
 
+_UNPACKED_TUPLES = [
+    # Unpacked tuple using `*`
+    (*tuple[int],)[0],
+    (*tuple[T],)[0],
+    (*tuple[int, str],)[0],
+    (*tuple[int, ...],)[0],
+    (*tuple[T, ...],)[0],
+    tuple[*tuple[int, ...]],
+    tuple[*tuple[T, ...]],
+    tuple[str, *tuple[int, ...]],
+    tuple[*tuple[int, ...], str],
+    tuple[float, *tuple[int, ...], str],
+    tuple[*tuple[*tuple[int, ...]]],
+    # Unpacked tuple using `Unpack`
+    Unpack[tuple[int]],
+    Unpack[tuple[T]],
+    Unpack[tuple[int, str]],
+    Unpack[tuple[int, ...]],
+    Unpack[tuple[T, ...]],
+    tuple[Unpack[tuple[int, ...]]],
+    tuple[Unpack[tuple[T, ...]]],
+    tuple[str, Unpack[tuple[int, ...]]],
+    tuple[Unpack[tuple[int, ...]], str],
+    tuple[float, Unpack[tuple[int, ...]], str],
+    tuple[Unpack[tuple[Unpack[tuple[int, ...]]]]],
+    # Unpacked tuple using `*` AND `Unpack`
+    tuple[Unpack[tuple[*tuple[int, ...]]]],
+    tuple[*tuple[Unpack[tuple[int, ...]]]],
+]
+
+
 class BaseTest(unittest.TestCase):
     """Test basics."""
     generic_types = [type, tuple, list, dict, set, frozenset, enumerate,
@@ -56,6 +104,7 @@ class BaseTest(unittest.TestCase):
                      OrderedDict, Counter, UserDict, UserList,
                      Pattern, Match,
                      partial, partialmethod, cached_property,
+                     TopologicalSorter,
                      AbstractContextManager, AbstractAsyncContextManager,
                      Awaitable, Coroutine,
                      AsyncIterable, AsyncIterator,
@@ -71,19 +120,25 @@ class BaseTest(unittest.TestCase):
                      KeysView, ItemsView, ValuesView,
                      Sequence, MutableSequence,
                      MappingProxyType, AsyncGeneratorType,
+                     GeneratorType, CoroutineType,
                      DirEntry,
                      chain,
+                     LoggerAdapter, StreamHandler,
                      TemporaryDirectory, SpooledTemporaryFile,
                      Queue, SimpleQueue,
                      _AssertRaisesContext,
                      SplitResult, ParseResult,
-                     ValueProxy, ApplyResult,
                      WeakSet, ReferenceType, ref,
-                     ShareableList, MPSimpleQueue,
+                     ShareableList,
                      Future, _WorkItem,
-                     Morsel]
+                     Morsel,
+                     DictReader, DictWriter,
+                     array]
     if ctypes is not None:
         generic_types.extend((ctypes.Array, ctypes.LibraryLoader))
+    if ValueProxy is not None:
+        generic_types.extend((ValueProxy, DictProxy, ListProxy, ApplyResult,
+                              MPSimpleQueue, MPQueue, MPJoinableQueue))
 
     def test_subscriptable(self):
         for t in self.generic_types:
@@ -96,11 +151,12 @@ 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__
             with self.subTest(f"Testing {tname}"):
-                with self.assertRaises(TypeError):
+                with self.assertRaisesRegex(TypeError, tname):
                     t[int]
 
     def test_instantiate(self):
@@ -154,15 +210,30 @@ class MyList(list):
         self.assertEqual(t.__args__, (int,))
         self.assertEqual(t.__parameters__, ())
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_repr(self):
         class MyList(list):
             pass
+        class MyGeneric:
+            __class_getitem__ = classmethod(GenericAlias)
+
         self.assertEqual(repr(list[str]), 'list[str]')
         self.assertEqual(repr(list[()]), 'list[()]')
         self.assertEqual(repr(tuple[int, ...]), 'tuple[int, ...]')
+        x1 = tuple[*tuple[int]]
+        self.assertEqual(repr(x1), 'tuple[*tuple[int]]')
+        x2 = tuple[*tuple[int, str]]
+        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.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]]'))
+
     def test_exposed_type(self):
         import types
         a = types.GenericAlias(list, int)
@@ -173,6 +244,7 @@ def test_exposed_type(self):
 
     def test_parameters(self):
         from typing import List, Dict, Callable
+
         D0 = dict[str, int]
         self.assertEqual(D0.__args__, (str, int))
         self.assertEqual(D0.__parameters__, ())
@@ -188,6 +260,7 @@ def test_parameters(self):
         D2b = dict[T, T]
         self.assertEqual(D2b.__args__, (T, T))
         self.assertEqual(D2b.__parameters__, (T,))
+
         L0 = list[str]
         self.assertEqual(L0.__args__, (str,))
         self.assertEqual(L0.__parameters__, ())
@@ -210,6 +283,27 @@ def test_parameters(self):
         self.assertEqual(L5.__args__, (Callable[[K, V], K],))
         self.assertEqual(L5.__parameters__, (K, V))
 
+        T1 = tuple[*tuple[int]]
+        self.assertEqual(
+            T1.__args__,
+            (*tuple[int],),
+        )
+        self.assertEqual(T1.__parameters__, ())
+
+        T2 = tuple[*tuple[T]]
+        self.assertEqual(
+            T2.__args__,
+            (*tuple[T],),
+        )
+        self.assertEqual(T2.__parameters__, (T,))
+
+        T4 = tuple[*tuple[int, str]]
+        self.assertEqual(
+            T4.__args__,
+            (*tuple[int, str],),
+        )
+        self.assertEqual(T4.__parameters__, ())
+
     def test_parameter_chaining(self):
         from typing import List, Dict, Union, Callable
         self.assertEqual(list[T][int], list[int])
@@ -233,16 +327,24 @@ def test_parameter_chaining(self):
 
         with self.assertRaises(TypeError):
             list[int][int]
+        with self.assertRaises(TypeError):
             dict[T, int][str, int]
+        with self.assertRaises(TypeError):
             dict[str, T][str, int]
+        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])
+        self.assertEqual((*tuple[int],)[0], (*tuple[int],)[0])
+        self.assertEqual(tuple[*tuple[int]], tuple[*tuple[int]])
         self.assertNotEqual(dict[str, int], dict[str, str])
         self.assertNotEqual(list, list[int])
         self.assertNotEqual(list[int], list)
+        self.assertNotEqual(list[int], tuple[int])
+        self.assertNotEqual((*tuple[int],)[0], tuple[int])
 
     def test_isinstance(self):
         self.assertTrue(isinstance([], list))
@@ -263,20 +365,24 @@ 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
-        with self.assertRaises(TypeError):
+        with self.assertRaisesRegex(TypeError, 'MyType'):
             MyType[int]
 
     def test_pickle(self):
-        alias = GenericAlias(list, T)
-        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-            s = pickle.dumps(alias, proto)
-            loaded = pickle.loads(s)
-            self.assertEqual(loaded.__origin__, alias.__origin__)
-            self.assertEqual(loaded.__args__, alias.__args__)
-            self.assertEqual(loaded.__parameters__, alias.__parameters__)
+        aliases = [GenericAlias(list, T)] + _UNPACKED_TUPLES
+        for alias in aliases:
+            for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                with self.subTest(alias=alias, proto=proto):
+                    s = pickle.dumps(alias, proto)
+                    loaded = pickle.loads(s)
+                    self.assertEqual(loaded.__origin__, alias.__origin__)
+                    self.assertEqual(loaded.__args__, alias.__args__)
+                    self.assertEqual(loaded.__parameters__, alias.__parameters__)
+                    self.assertEqual(type(loaded), type(alias))
 
     def test_copy(self):
         class X(list):
@@ -285,16 +391,30 @@ def __copy__(self):
             def __deepcopy__(self, memo):
                 return self
 
-        for origin in list, deque, X:
-            alias = GenericAlias(origin, T)
-            copied = copy.copy(alias)
-            self.assertEqual(copied.__origin__, alias.__origin__)
-            self.assertEqual(copied.__args__, alias.__args__)
-            self.assertEqual(copied.__parameters__, alias.__parameters__)
-            copied = copy.deepcopy(alias)
-            self.assertEqual(copied.__origin__, alias.__origin__)
-            self.assertEqual(copied.__args__, alias.__args__)
-            self.assertEqual(copied.__parameters__, alias.__parameters__)
+        aliases = [
+            GenericAlias(list, T),
+            GenericAlias(deque, T),
+            GenericAlias(X, T),
+            X[T],
+            list[T],
+            deque[T],
+        ] + _UNPACKED_TUPLES
+        for alias in aliases:
+            with self.subTest(alias=alias):
+                copied = copy.copy(alias)
+                self.assertEqual(copied.__origin__, alias.__origin__)
+                self.assertEqual(copied.__args__, alias.__args__)
+                self.assertEqual(copied.__parameters__, alias.__parameters__)
+                copied = copy.deepcopy(alias)
+                self.assertEqual(copied.__origin__, alias.__origin__)
+                self.assertEqual(copied.__args__, alias.__args__)
+                self.assertEqual(copied.__parameters__, alias.__parameters__)
+
+    def test_unpack(self):
+        alias = tuple[str, ...]
+        self.assertIs(alias.__unpacked__, False)
+        unpacked = (*alias,)[0]
+        self.assertIs(unpacked.__unpacked__, True)
 
     def test_union(self):
         a = typing.Union[list[int], list[str]]
@@ -306,11 +426,28 @@ 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):
-        dir_of_gen_alias = set(dir(list[int]))
+        ga = list[int]
+        dir_of_gen_alias = set(dir(ga))
         self.assertTrue(dir_of_gen_alias.issuperset(dir(list)))
-        for generic_alias_property in ("__origin__", "__args__", "__parameters__"):
-            self.assertIn(generic_alias_property, dir_of_gen_alias)
+        for generic_alias_property in (
+            "__origin__", "__args__", "__parameters__",
+            "__unpacked__",
+        ):
+            with self.subTest(generic_alias_property=generic_alias_property):
+                self.assertIn(generic_alias_property, dir_of_gen_alias)
+        for blocked in (
+            "__bases__",
+            "__copy__",
+            "__deepcopy__",
+        ):
+            with self.subTest(blocked=blocked):
+                self.assertNotIn(blocked, dir_of_gen_alias)
+
+        for entry in dir_of_gen_alias:
+            with self.subTest(entry=entry):
+                getattr(ga, entry)  # must not raise `AttributeError`
 
     def test_weakref(self):
         for t in self.generic_types:
@@ -337,6 +474,44 @@ def __new__(cls, *args, **kwargs):
         with self.assertRaises(TypeError):
             Bad(list, int, bad=int)
 
+    def test_iter_creates_starred_tuple(self):
+        t = tuple[int, str]
+        iter_t = iter(t)
+        x = next(iter_t)
+        self.assertEqual(repr(x), '*tuple[int, str]')
+
+    def test_calling_next_twice_raises_stopiteration(self):
+        t = tuple[int, str]
+        iter_t = iter(t)
+        next(iter_t)
+        with self.assertRaises(StopIteration):
+            next(iter_t)
+
+    def test_del_iter(self):
+        t = tuple[int, str]
+        iter_x = iter(t)
+        del iter_x
+
+
+class TypeIterationTests(unittest.TestCase):
+    _UNITERABLE_TYPES = (list, tuple)
+
+    def test_cannot_iterate(self):
+        for test_type in self._UNITERABLE_TYPES:
+            with self.subTest(type=test_type):
+                expected_error_regex = "object is not iterable"
+                with self.assertRaisesRegex(TypeError, expected_error_regex):
+                    iter(test_type)
+                with self.assertRaisesRegex(TypeError, expected_error_regex):
+                    list(test_type)
+                with self.assertRaisesRegex(TypeError, expected_error_regex):
+                    for _ in test_type:
+                        pass
+
+    def test_is_not_instance_of_iterable(self):
+        for type_to_test in self._UNITERABLE_TYPES:
+            self.assertNotIsInstance(type_to_test, Iterable)
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py
index 4f311c2d49..89e4fe1882 100644
--- a/Lib/test/test_genericpath.py
+++ b/Lib/test/test_genericpath.py
@@ -7,9 +7,9 @@
 import sys
 import unittest
 import warnings
-from test.support import is_emscripten
-from test.support import os_helper
-from test.support import warnings_helper
+from test.support import (
+    is_apple, is_emscripten, os_helper, warnings_helper
+)
 from test.support.script_helper import assert_python_ok
 from test.support.os_helper import FakePath
 
@@ -135,6 +135,9 @@ def test_exists(self):
         self.assertIs(self.pathmodule.exists(filename), False)
         self.assertIs(self.pathmodule.exists(bfilename), False)
 
+        self.assertIs(self.pathmodule.lexists(filename), False)
+        self.assertIs(self.pathmodule.lexists(bfilename), False)
+
         create_file(filename)
 
         self.assertIs(self.pathmodule.exists(filename), True)
@@ -145,14 +148,17 @@ def test_exists(self):
         self.assertIs(self.pathmodule.exists(filename + '\x00'), False)
         self.assertIs(self.pathmodule.exists(bfilename + b'\x00'), False)
 
-        if self.pathmodule is not genericpath:
-            self.assertIs(self.pathmodule.lexists(filename), True)
-            self.assertIs(self.pathmodule.lexists(bfilename), True)
+        self.assertIs(self.pathmodule.lexists(filename), True)
+        self.assertIs(self.pathmodule.lexists(bfilename), True)
+
+        self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False)
+        self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False)
+        self.assertIs(self.pathmodule.lexists(filename + '\x00'), False)
+        self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False)
 
-            self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False)
-            self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False)
-            self.assertIs(self.pathmodule.lexists(filename + '\x00'), False)
-            self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False)
+        # Keyword arguments are accepted
+        self.assertIs(self.pathmodule.exists(path=filename), True)
+        self.assertIs(self.pathmodule.lexists(path=filename), True)
 
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     @unittest.skipIf(is_emscripten, "Emscripten pipe fds have no stat")
@@ -165,6 +171,14 @@ def test_exists_fd(self):
             os.close(w)
         self.assertFalse(self.pathmodule.exists(r))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exists_bool(self):
+        for fd in False, True:
+            with self.assertWarnsRegex(RuntimeWarning,
+                    'bool is used as a file descriptor'):
+                self.pathmodule.exists(fd)
+
     def test_isdir(self):
         filename = os_helper.TESTFN
         bfilename = os.fsencode(filename)
@@ -338,6 +352,7 @@ def test_invalid_paths(self):
                     with self.assertRaisesRegex(ValueError, 'embedded null'):
                         func(b'/tmp\x00abcds')
 
+
 # Following TestCase is not supposed to be run from test_genericpath.
 # It is inherited by other test modules (ntpath, posixpath).
 
@@ -483,12 +498,16 @@ def test_abspath_issue3426(self):
                     self.assertIsInstance(abspath(path), str)
 
     def test_nonascii_abspath(self):
-        if (os_helper.TESTFN_UNDECODABLE
-        # macOS and Emscripten deny the creation of a directory with an
-        # invalid UTF-8 name. Windows allows creating a directory with an
-        # arbitrary bytes name, but fails to enter this directory
-        # (when the bytes name is used).
-        and sys.platform not in ('win32', 'darwin', 'emscripten', 'wasi')):
+        if (
+            os_helper.TESTFN_UNDECODABLE
+            # Apple platforms and Emscripten/WASI deny the creation of a
+            # directory with an invalid UTF-8 name. Windows allows creating a
+            # directory with an arbitrary bytes name, but fails to enter this
+            # directory (when the bytes name is used).
+            and sys.platform not in {
+                "win32", "emscripten", "wasi"
+            } and not is_apple
+        ):
             name = os_helper.TESTFN_UNDECODABLE
         elif os_helper.TESTFN_NONASCII:
             name = os_helper.TESTFN_NONASCII
diff --git a/Lib/test/test_gettext.py b/Lib/test/test_gettext.py
index 8430fc234d..0653bb762a 100644
--- a/Lib/test/test_gettext.py
+++ b/Lib/test/test_gettext.py
@@ -2,6 +2,8 @@
 import base64
 import gettext
 import unittest
+import unittest.mock
+from functools import partial
 
 from test import support
 from test.support import os_helper
@@ -37,6 +39,9 @@
 bmsgd2luayAoaW4gIm15IG90aGVyIGNvbnRleHQiKQB3aW5rIHdpbmsA
 '''
 
+# .mo file with an invalid magic number
+GNU_MO_DATA_BAD_MAGIC_NUMBER = base64.b64encode(b'ABCD')
+
 # This data contains an invalid major version number (5)
 # An unexpected major version number should be treated as an error when
 # parsing a .mo file
@@ -85,6 +90,49 @@
 ciBUQUgKdHJnZ3JrZyB6cmZmbnRyIHBuZ255YnQgeXZvZW5lbC4AYmFjb24Ad2luayB3aW5rAA==
 '''
 
+# Corrupt .mo file
+# Generated from
+#
+# msgid "foo"
+# msgstr "bar"
+#
+# with msgfmt --no-hash
+#
+# The translation offset is changed to 0xFFFFFFFF,
+# making it larger than the file size, which should
+# raise an error when parsing.
+GNU_MO_DATA_CORRUPT = base64.b64encode(bytes([
+    0xDE, 0x12, 0x04, 0x95,  # Magic
+    0x00, 0x00, 0x00, 0x00,  # Version
+    0x01, 0x00, 0x00, 0x00,  # Message count
+    0x1C, 0x00, 0x00, 0x00,  # Message offset
+    0x24, 0x00, 0x00, 0x00,  # Translation offset
+    0x00, 0x00, 0x00, 0x00,  # Hash table size
+    0x2C, 0x00, 0x00, 0x00,  # Hash table offset
+    0x03, 0x00, 0x00, 0x00,  # 1st message length
+    0x2C, 0x00, 0x00, 0x00,  # 1st message offset
+    0x03, 0x00, 0x00, 0x00,  # 1st trans length
+    0xFF, 0xFF, 0xFF, 0xFF,  # 1st trans offset (Modified to make it invalid)
+    0x66, 0x6F, 0x6F, 0x00,  # Message data
+    0x62, 0x61, 0x72, 0x00,  # Message data
+]))
+
+
+GNU_MO_DATA_BIG_ENDIAN = base64.b64encode(bytes([
+    0x95, 0x04, 0x12, 0xDE,  # Magic
+    0x00, 0x00, 0x00, 0x00,  # Version
+    0x00, 0x00, 0x00, 0x01,  # Message count
+    0x00, 0x00, 0x00, 0x1C,  # Message offset
+    0x00, 0x00, 0x00, 0x24,  # Translation offset
+    0x00, 0x00, 0x00, 0x00,  # Hash table size
+    0x00, 0x00, 0x00, 0x2C,  # Hash table offset
+    0x00, 0x00, 0x00, 0x03,  # 1st message length
+    0x00, 0x00, 0x00, 0x2C,  # 1st message offset
+    0x00, 0x00, 0x00, 0x03,  # 1st trans length
+    0x00, 0x00, 0x00, 0x30,  # 1st trans offset
+    0x66, 0x6F, 0x6F, 0x00,  # Message data
+    0x62, 0x61, 0x72, 0x00,  # Message data
+]))
 
 UMO_DATA = b'''\
 3hIElQAAAAADAAAAHAAAADQAAAAAAAAAAAAAAAAAAABMAAAABAAAAE0AAAAQAAAAUgAAAA8BAABj
@@ -109,30 +157,49 @@
 
 LOCALEDIR = os.path.join('xx', 'LC_MESSAGES')
 MOFILE = os.path.join(LOCALEDIR, 'gettext.mo')
+MOFILE_BAD_MAGIC_NUMBER = os.path.join(LOCALEDIR, 'gettext_bad_magic_number.mo')
 MOFILE_BAD_MAJOR_VERSION = os.path.join(LOCALEDIR, 'gettext_bad_major_version.mo')
 MOFILE_BAD_MINOR_VERSION = os.path.join(LOCALEDIR, 'gettext_bad_minor_version.mo')
+MOFILE_CORRUPT = os.path.join(LOCALEDIR, 'gettext_corrupt.mo')
+MOFILE_BIG_ENDIAN = os.path.join(LOCALEDIR, 'gettext_big_endian.mo')
 UMOFILE = os.path.join(LOCALEDIR, 'ugettext.mo')
 MMOFILE = os.path.join(LOCALEDIR, 'metadata.mo')
 
 
+def reset_gettext():
+    gettext._localedirs.clear()
+    gettext._current_domain = 'messages'
+    gettext._translations.clear()
+
+
 class GettextBaseTest(unittest.TestCase):
-    def setUp(self):
-        self.addCleanup(os_helper.rmtree, os.path.split(LOCALEDIR)[0])
+    @classmethod
+    def setUpClass(cls):
+        cls.addClassCleanup(os_helper.rmtree, os.path.split(LOCALEDIR)[0])
         if not os.path.isdir(LOCALEDIR):
             os.makedirs(LOCALEDIR)
         with open(MOFILE, 'wb') as fp:
             fp.write(base64.decodebytes(GNU_MO_DATA))
+        with open(MOFILE_BAD_MAGIC_NUMBER, 'wb') as fp:
+            fp.write(base64.decodebytes(GNU_MO_DATA_BAD_MAGIC_NUMBER))
         with open(MOFILE_BAD_MAJOR_VERSION, 'wb') as fp:
             fp.write(base64.decodebytes(GNU_MO_DATA_BAD_MAJOR_VERSION))
         with open(MOFILE_BAD_MINOR_VERSION, 'wb') as fp:
             fp.write(base64.decodebytes(GNU_MO_DATA_BAD_MINOR_VERSION))
+        with open(MOFILE_CORRUPT, 'wb') as fp:
+            fp.write(base64.decodebytes(GNU_MO_DATA_CORRUPT))
+        with open(MOFILE_BIG_ENDIAN, 'wb') as fp:
+            fp.write(base64.decodebytes(GNU_MO_DATA_BIG_ENDIAN))
         with open(UMOFILE, 'wb') as fp:
             fp.write(base64.decodebytes(UMO_DATA))
         with open(MMOFILE, 'wb') as fp:
             fp.write(base64.decodebytes(MMO_DATA))
+
+    def setUp(self):
         self.env = self.enterContext(os_helper.EnvironmentVarGuard())
         self.env['LANGUAGE'] = 'xx'
-        gettext._translations.clear()
+        reset_gettext()
+        self.addCleanup(reset_gettext)
 
 
 GNU_MO_DATA_ISSUE_17898 = b'''\
@@ -237,6 +304,16 @@ def test_bindtextdomain(self):
     def test_textdomain(self):
         self.assertEqual(gettext.textdomain(), 'gettext')
 
+    def test_bad_magic_number(self):
+        with open(MOFILE_BAD_MAGIC_NUMBER, 'rb') as fp:
+            with self.assertRaises(OSError) as cm:
+                gettext.GNUTranslations(fp)
+
+            exception = cm.exception
+            self.assertEqual(exception.errno, 0)
+            self.assertEqual(exception.strerror, "Bad magic number")
+            self.assertEqual(exception.filename, MOFILE_BAD_MAGIC_NUMBER)
+
     def test_bad_major_version(self):
         with open(MOFILE_BAD_MAJOR_VERSION, 'rb') as fp:
             with self.assertRaises(OSError) as cm:
@@ -252,6 +329,22 @@ def test_bad_minor_version(self):
             # Check that no error is thrown with a bad minor version number
             gettext.GNUTranslations(fp)
 
+    def test_corrupt_file(self):
+        with open(MOFILE_CORRUPT, 'rb') as fp:
+            with self.assertRaises(OSError) as cm:
+                gettext.GNUTranslations(fp)
+
+            exception = cm.exception
+            self.assertEqual(exception.errno, 0)
+            self.assertEqual(exception.strerror, "File is corrupt")
+            self.assertEqual(exception.filename, MOFILE_CORRUPT)
+
+    def test_big_endian_file(self):
+        with open(MOFILE_BIG_ENDIAN, 'rb') as fp:
+            t = gettext.GNUTranslations(fp)
+
+        self.assertEqual(t.gettext('foo'), 'bar')
+
     def test_some_translations(self):
         eq = self.assertEqual
         # test some translations
@@ -309,55 +402,153 @@ def test_multiline_strings(self):
 trggrkg zrffntr pngnybt yvoenel.''')
 
 
-class PluralFormsTestCase(GettextBaseTest):
+class PluralFormsTests:
+
+    def _test_plural_forms(self, ngettext, gettext,
+                           singular, plural, tsingular, tplural,
+                           numbers_only=True):
+        x = ngettext(singular, plural, 1)
+        self.assertEqual(x, tsingular)
+        x = ngettext(singular, plural, 2)
+        self.assertEqual(x, tplural)
+        x = gettext(singular)
+        self.assertEqual(x, tsingular)
+
+        lineno = self._test_plural_forms.__code__.co_firstlineno + 12
+        with self.assertWarns(DeprecationWarning) as cm:
+            x = ngettext(singular, plural, 1.0)
+        self.assertEqual(cm.filename, __file__)
+        self.assertEqual(cm.lineno, lineno)
+        self.assertEqual(x, tsingular)
+        with self.assertWarns(DeprecationWarning) as cm:
+            x = ngettext(singular, plural, 1.1)
+        self.assertEqual(cm.filename, __file__)
+        self.assertEqual(cm.lineno, lineno + 5)
+        self.assertEqual(x, tplural)
+
+        if numbers_only:
+            with self.assertRaises(TypeError):
+                ngettext(singular, plural, None)
+        else:
+            with self.assertWarns(DeprecationWarning) as cm:
+                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,
+            'There is %s file', 'There are %s files',
+            'Hay %s fichero', 'Hay %s ficheros')
+        self._test_plural_forms(
+            self.ngettext, self.gettext,
+            '%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')
+        self._test_plural_forms(
+            ngettext, gettext,
+            'There is %s file', 'There are %s files',
+            'Hay %s fichero (context)', 'Hay %s ficheros (context)')
+        self._test_plural_forms(
+            ngettext, gettext,
+            '%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'),
+            partial(self.pgettext, 'Unknown context'),
+            'There is %s file', 'There are %s files',
+            'There is %s file', 'There are %s files')
+
+
+class GNUTranslationsPluralFormsTestCase(PluralFormsTests, GettextBaseTest):
     def setUp(self):
         GettextBaseTest.setUp(self)
-        self.mofile = MOFILE
+        # Set up the bindings
+        gettext.bindtextdomain('gettext', os.curdir)
+        gettext.textdomain('gettext')
 
-    def test_plural_forms1(self):
-        eq = self.assertEqual
-        x = gettext.ngettext('There is %s file', 'There are %s files', 1)
-        eq(x, 'Hay %s fichero')
-        x = gettext.ngettext('There is %s file', 'There are %s files', 2)
-        eq(x, 'Hay %s ficheros')
-        x = gettext.gettext('There is %s file')
-        eq(x, 'Hay %s fichero')
-
-    def test_plural_context_forms1(self):
-        eq = self.assertEqual
-        x = gettext.npgettext('With context',
-                              'There is %s file', 'There are %s files', 1)
-        eq(x, 'Hay %s fichero (context)')
-        x = gettext.npgettext('With context',
-                              'There is %s file', 'There are %s files', 2)
-        eq(x, 'Hay %s ficheros (context)')
-        x = gettext.pgettext('With context', 'There is %s file')
-        eq(x, 'Hay %s fichero (context)')
-
-    def test_plural_forms2(self):
-        eq = self.assertEqual
-        with open(self.mofile, 'rb') as fp:
-            t = gettext.GNUTranslations(fp)
-        x = t.ngettext('There is %s file', 'There are %s files', 1)
-        eq(x, 'Hay %s fichero')
-        x = t.ngettext('There is %s file', 'There are %s files', 2)
-        eq(x, 'Hay %s ficheros')
-        x = t.gettext('There is %s file')
-        eq(x, 'Hay %s fichero')
-
-    def test_plural_context_forms2(self):
-        eq = self.assertEqual
-        with open(self.mofile, 'rb') as fp:
+        self.gettext = gettext.gettext
+        self.ngettext = gettext.ngettext
+        self.pgettext = gettext.pgettext
+        self.npgettext = gettext.npgettext
+
+
+class GNUTranslationsWithDomainPluralFormsTestCase(PluralFormsTests, GettextBaseTest):
+    def setUp(self):
+        GettextBaseTest.setUp(self)
+        # Set up the bindings
+        gettext.bindtextdomain('gettext', os.curdir)
+
+        self.gettext = partial(gettext.dgettext, 'gettext')
+        self.ngettext = partial(gettext.dngettext, 'gettext')
+        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'),
+            partial(gettext.dgettext, 'unknown'),
+            'There is %s file', 'There are %s files',
+            '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'),
+            partial(gettext.dpgettext, 'unknown', 'With context'),
+            'There is %s file', 'There are %s files',
+            'There is %s file', 'There are %s files',
+            numbers_only=False)
+
+
+class GNUTranslationsClassPluralFormsTestCase(PluralFormsTests, GettextBaseTest):
+    def setUp(self):
+        GettextBaseTest.setUp(self)
+        with open(MOFILE, 'rb') as fp:
             t = gettext.GNUTranslations(fp)
-        x = t.npgettext('With context',
-                        'There is %s file', 'There are %s files', 1)
-        eq(x, 'Hay %s fichero (context)')
-        x = t.npgettext('With context',
-                        'There is %s file', 'There are %s files', 2)
-        eq(x, 'Hay %s ficheros (context)')
-        x = gettext.pgettext('With context', 'There is %s file')
-        eq(x, 'Hay %s fichero (context)')
 
+        self.gettext = t.gettext
+        self.ngettext = t.ngettext
+        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(
+            t.ngettext, t.gettext,
+            'There is %s file', 'There are %s files',
+            '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(
+            partial(t.npgettext, 'With context'),
+            partial(t.pgettext, 'With context'),
+            'There is %s file', 'There are %s files',
+            'There is %s file', 'There are %s files',
+            numbers_only=False)
+
+
+class PluralFormsInternalTestCase(unittest.TestCase):
     # Examples from http://www.gnu.org/software/gettext/manual/gettext.html
 
     def test_ja(self):
@@ -472,12 +663,18 @@ def test_decimal_number(self):
     def test_invalid_syntax(self):
         invalid_expressions = [
             'x>1', '(n>1', 'n>1)', '42**42**42', '0xa', '1.0', '1e2',
-            'n>0x1', '+n', '-n', 'n()', 'n(1)', '1+', 'nn', 'n n',
+            'n>0x1', '+n', '-n', 'n()', 'n(1)', '1+', 'nn', 'n n', 'n ? 1 2'
         ]
         for expr in invalid_expressions:
             with self.assertRaises(ValueError):
                 gettext.c2py(expr)
 
+    def test_negation(self):
+        f = gettext.c2py('!!!n')
+        self.assertEqual(f(0), 1)
+        self.assertEqual(f(1), 0)
+        self.assertEqual(f(2), 0)
+
     def test_nested_condition_operator(self):
         self.assertEqual(gettext.c2py('n?1?2:3:4')(0), 4)
         self.assertEqual(gettext.c2py('n?1?2:3:4')(1), 2)
@@ -640,6 +837,158 @@ def test_cache(self):
         self.assertEqual(t.__class__, DummyGNUTranslations)
 
 
+class FallbackTranslations(gettext.NullTranslations):
+    def gettext(self, message):
+        return f'gettext: {message}'
+
+    def ngettext(self, msgid1, msgid2, n):
+        return f'ngettext: {msgid1}, {msgid2}, {n}'
+
+    def pgettext(self, context, message):
+        return f'pgettext: {context}, {message}'
+
+    def npgettext(self, context, msgid1, msgid2, n):
+        return f'npgettext: {context}, {msgid1}, {msgid2}, {n}'
+
+
+class FallbackTestCase(GettextBaseTest):
+    def test_null_translations_fallback(self):
+        t = gettext.NullTranslations()
+        t.add_fallback(FallbackTranslations())
+        self.assertEqual(t.gettext('foo'), 'gettext: foo')
+        self.assertEqual(t.ngettext('foo', 'foos', 1),
+                         'ngettext: foo, foos, 1')
+        self.assertEqual(t.pgettext('context', 'foo'),
+                         'pgettext: context, foo')
+        self.assertEqual(t.npgettext('context', 'foo', 'foos', 1),
+                         'npgettext: context, foo, foos, 1')
+
+    def test_gnu_translations_fallback(self):
+        with open(MOFILE, 'rb') as fp:
+            t = gettext.GNUTranslations(fp)
+        t.add_fallback(FallbackTranslations())
+        self.assertEqual(t.gettext('foo'), 'gettext: foo')
+        self.assertEqual(t.ngettext('foo', 'foos', 1),
+                         'ngettext: foo, foos, 1')
+        self.assertEqual(t.pgettext('context', 'foo'),
+                         'pgettext: context, foo')
+        self.assertEqual(t.npgettext('context', 'foo', 'foos', 1),
+                         'npgettext: context, foo, foos, 1')
+
+    def test_nested_fallbacks(self):
+        class NestedFallback(gettext.NullTranslations):
+            def gettext(self, message):
+                if message == 'foo':
+                    return 'fallback'
+                return super().gettext(message)
+
+        fallback1 = NestedFallback()
+        fallback2 = FallbackTranslations()
+        t = gettext.NullTranslations()
+        t.add_fallback(fallback1)
+        t.add_fallback(fallback2)
+
+        self.assertEqual(fallback1.gettext('bar'), 'gettext: bar')
+        self.assertEqual(t.gettext('foo'), 'fallback')
+        self.assertEqual(t.gettext('bar'), 'gettext: bar')
+
+
+class ExpandLangTestCase(unittest.TestCase):
+    def test_expand_lang(self):
+        # Test all combinations of territory, charset and
+        # modifier (locale extension)
+        locales = {
+            'cs': ['cs'],
+            'cs_CZ': ['cs_CZ', 'cs'],
+            'cs.ISO8859-2': ['cs.ISO8859-2', 'cs'],
+            'cs@euro': ['cs@euro', 'cs'],
+            'cs_CZ.ISO8859-2': ['cs_CZ.ISO8859-2', 'cs_CZ', 'cs.ISO8859-2',
+                                'cs'],
+            'cs_CZ@euro': ['cs_CZ@euro', 'cs@euro', 'cs_CZ', 'cs'],
+            'cs.ISO8859-2@euro': ['cs.ISO8859-2@euro', 'cs@euro',
+                                  'cs.ISO8859-2', 'cs'],
+            'cs_CZ.ISO8859-2@euro': ['cs_CZ.ISO8859-2@euro', 'cs_CZ@euro',
+                                     'cs.ISO8859-2@euro', 'cs@euro',
+                                     'cs_CZ.ISO8859-2', 'cs_CZ',
+                                     'cs.ISO8859-2', 'cs'],
+        }
+        for locale, expanded in locales.items():
+            with self.subTest(locale=locale):
+                with unittest.mock.patch("locale.normalize",
+                                         return_value=locale):
+                    self.assertEqual(gettext._expand_lang(locale), expanded)
+
+
+class FindTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.env = self.enterContext(os_helper.EnvironmentVarGuard())
+        self.tempdir = self.enterContext(os_helper.temp_cwd())
+
+        for key in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
+            self.env.unset(key)
+
+    def create_mo_file(self, lang):
+        locale_dir = os.path.join(self.tempdir, "locale")
+        mofile_dir = os.path.join(locale_dir, lang, "LC_MESSAGES")
+        os.makedirs(mofile_dir)
+        mo_file = os.path.join(mofile_dir, "mofile.mo")
+        with open(mo_file, "wb") as f:
+            f.write(GNU_MO_DATA)
+        return mo_file
+
+    def test_find_with_env_vars(self):
+        # test that find correctly finds the environment variables
+        # when languages are not supplied
+        mo_file = self.create_mo_file("ga_IE")
+        for var in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
+            self.env.set(var, 'ga_IE')
+            result = gettext.find("mofile",
+                                  localedir=os.path.join(self.tempdir, "locale"))
+            self.assertEqual(result, mo_file)
+            self.env.unset(var)
+
+    def test_find_with_languages(self):
+        # test that passed languages are used
+        self.env.set('LANGUAGE', 'pt_BR')
+        mo_file = self.create_mo_file("ga_IE")
+
+        result = gettext.find("mofile",
+                              localedir=os.path.join(self.tempdir, "locale"),
+                              languages=['ga_IE'])
+        self.assertEqual(result, mo_file)
+
+    @unittest.mock.patch('gettext._expand_lang')
+    def test_find_with_no_lang(self, patch_expand_lang):
+        # no language can be found
+        gettext.find('foo')
+        patch_expand_lang.assert_called_with('C')
+
+    @unittest.mock.patch('gettext._expand_lang')
+    def test_find_with_c(self, patch_expand_lang):
+        # 'C' is already in languages
+        self.env.set('LANGUAGE', 'C')
+        gettext.find('foo')
+        patch_expand_lang.assert_called_with('C')
+
+    def test_find_all(self):
+        # test that all are returned when all is set
+        paths = []
+        for lang in ["ga_IE", "es_ES"]:
+            paths.append(self.create_mo_file(lang))
+        result = gettext.find('mofile',
+                              localedir=os.path.join(self.tempdir, "locale"),
+                              languages=["ga_IE", "es_ES"], all=True)
+        self.assertEqual(sorted(result), sorted(paths))
+
+    def test_find_deduplication(self):
+        # test that find removes duplicate languages
+        mo_file = [self.create_mo_file('ga_IE')]
+        result = gettext.find("mofile", localedir=os.path.join(self.tempdir, "locale"),
+                              languages=['ga_IE', 'ga_IE'], all=True)
+        self.assertEqual(result, mo_file)
+
+
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
         support.check__all__(self, gettext,
diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py
index e11ea81a7d..c3fb8939a6 100644
--- a/Lib/test/test_glob.py
+++ b/Lib/test/test_glob.py
@@ -1,9 +1,12 @@
 import glob
 import os
+import re
 import shutil
 import sys
 import unittest
+import warnings
 
+from test.support import is_wasi, Py_DEBUG
 from test.support.os_helper import (TESTFN, skip_unless_symlink,
                                     can_symlink, create_empty_file, change_cwd)
 
@@ -167,37 +170,45 @@ def test_glob_directory_names(self):
                                     self.norm('aab', 'F')])
 
     def test_glob_directory_with_trailing_slash(self):
-        # Patterns ending with a slash shouldn't match non-dirs
-        res = glob.glob(self.norm('Z*Z') + os.sep)
-        self.assertEqual(res, [])
-        res = glob.glob(self.norm('ZZZ') + os.sep)
-        self.assertEqual(res, [])
-        # When there is a wildcard pattern which ends with os.sep, glob()
-        # doesn't blow up.
-        res = glob.glob(self.norm('aa*') + os.sep)
-        self.assertEqual(len(res), 2)
-        # either of these results is reasonable
-        self.assertIn(set(res), [
-                      {self.norm('aaa'), self.norm('aab')},
-                      {self.norm('aaa') + os.sep, self.norm('aab') + os.sep},
-                      ])
+        seps = (os.sep, os.altsep) if os.altsep else (os.sep,)
+        for sep in seps:
+            # Patterns ending with a slash shouldn't match non-dirs
+            self.assertEqual(glob.glob(self.norm('Z*Z') + sep), [])
+            self.assertEqual(glob.glob(self.norm('ZZZ') + sep), [])
+            self.assertEqual(glob.glob(self.norm('aaa') + sep),
+                             [self.norm('aaa') + sep])
+            # Preserving the redundant separators is an implementation detail.
+            self.assertEqual(glob.glob(self.norm('aaa') + sep*2),
+                             [self.norm('aaa') + sep*2])
+            # When there is a wildcard pattern which ends with a pathname
+            # separator, glob() doesn't blow.
+            # The result should end with the pathname separator.
+            # Normalizing the trailing separator is an implementation detail.
+            eq = self.assertSequencesEqual_noorder
+            eq(glob.glob(self.norm('aa*') + sep),
+               [self.norm('aaa') + os.sep, self.norm('aab') + os.sep])
+            # Stripping the redundant separators is an implementation detail.
+            eq(glob.glob(self.norm('aa*') + sep*2),
+               [self.norm('aaa') + os.sep, self.norm('aab') + os.sep])
 
     def test_glob_bytes_directory_with_trailing_slash(self):
         # Same as test_glob_directory_with_trailing_slash, but with a
         # bytes argument.
-        res = glob.glob(os.fsencode(self.norm('Z*Z') + os.sep))
-        self.assertEqual(res, [])
-        res = glob.glob(os.fsencode(self.norm('ZZZ') + os.sep))
-        self.assertEqual(res, [])
-        res = glob.glob(os.fsencode(self.norm('aa*') + os.sep))
-        self.assertEqual(len(res), 2)
-        # either of these results is reasonable
-        self.assertIn(set(res), [
-                      {os.fsencode(self.norm('aaa')),
-                       os.fsencode(self.norm('aab'))},
-                      {os.fsencode(self.norm('aaa') + os.sep),
-                       os.fsencode(self.norm('aab') + os.sep)},
-                      ])
+        seps = (os.sep, os.altsep) if os.altsep else (os.sep,)
+        for sep in seps:
+            self.assertEqual(glob.glob(os.fsencode(self.norm('Z*Z') + sep)), [])
+            self.assertEqual(glob.glob(os.fsencode(self.norm('ZZZ') + sep)), [])
+            self.assertEqual(glob.glob(os.fsencode(self.norm('aaa') + sep)),
+               [os.fsencode(self.norm('aaa') + sep)])
+            self.assertEqual(glob.glob(os.fsencode(self.norm('aaa') + sep*2)),
+               [os.fsencode(self.norm('aaa') + sep*2)])
+            eq = self.assertSequencesEqual_noorder
+            eq(glob.glob(os.fsencode(self.norm('aa*') + sep)),
+               [os.fsencode(self.norm('aaa') + os.sep),
+                os.fsencode(self.norm('aab') + os.sep)])
+            eq(glob.glob(os.fsencode(self.norm('aa*') + sep*2)),
+               [os.fsencode(self.norm('aaa') + os.sep),
+                os.fsencode(self.norm('aab') + os.sep)])
 
     @skip_unless_symlink
     def test_glob_symlinks(self):
@@ -205,8 +216,7 @@ def test_glob_symlinks(self):
         eq(self.glob('sym3'), [self.norm('sym3')])
         eq(self.glob('sym3', '*'), [self.norm('sym3', 'EF'),
                                     self.norm('sym3', 'efg')])
-        self.assertIn(self.glob('sym3' + os.sep),
-                      [[self.norm('sym3')], [self.norm('sym3') + os.sep]])
+        eq(self.glob('sym3' + os.sep), [self.norm('sym3') + os.sep])
         eq(self.glob('*', '*F'),
            [self.norm('aaa', 'zzzF'),
             self.norm('aab', 'F'), self.norm('sym3', 'EF')])
@@ -364,6 +374,8 @@ def test_glob_named_pipe(self):
         self.assertEqual(self.rglob('mypipe', 'sub'), [])
         self.assertEqual(self.rglob('mypipe', '*'), [])
 
+
+    @unittest.skipIf(is_wasi and Py_DEBUG, "requires too much stack")
     def test_glob_many_open_files(self):
         depth = 30
         base = os.path.join(self.tempdir, 'deep')
@@ -381,10 +393,134 @@ def test_glob_many_open_files(self):
             for it in iters:
                 self.assertEqual(next(it), p)
 
+    def test_glob0(self):
+        with self.assertWarns(DeprecationWarning):
+            glob.glob0(self.tempdir, 'a')
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            eq = self.assertSequencesEqual_noorder
+            eq(glob.glob0(self.tempdir, 'a'), ['a'])
+            eq(glob.glob0(self.tempdir, '.bb'), ['.bb'])
+            eq(glob.glob0(self.tempdir, '.b*'), [])
+            eq(glob.glob0(self.tempdir, 'b'), [])
+            eq(glob.glob0(self.tempdir, '?'), [])
+            eq(glob.glob0(self.tempdir, '*a'), [])
+            eq(glob.glob0(self.tempdir, 'a*'), [])
+
+    def test_glob1(self):
+        with self.assertWarns(DeprecationWarning):
+            glob.glob1(self.tempdir, 'a')
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore')
+            eq = self.assertSequencesEqual_noorder
+            eq(glob.glob1(self.tempdir, 'a'), ['a'])
+            eq(glob.glob1(self.tempdir, '.bb'), ['.bb'])
+            eq(glob.glob1(self.tempdir, '.b*'), ['.bb'])
+            eq(glob.glob1(self.tempdir, 'b'), [])
+            eq(glob.glob1(self.tempdir, '?'), ['a'])
+            eq(glob.glob1(self.tempdir, '*a'), ['a', 'aaa'])
+            eq(glob.glob1(self.tempdir, 'a*'), ['a', 'aaa', 'aab'])
+
+    def test_translate_matching(self):
+        match = re.compile(glob.translate('*')).match
+        self.assertIsNotNone(match('foo'))
+        self.assertIsNotNone(match('foo.bar'))
+        self.assertIsNone(match('.foo'))
+        match = re.compile(glob.translate('.*')).match
+        self.assertIsNotNone(match('.foo'))
+        match = re.compile(glob.translate('**', recursive=True)).match
+        self.assertIsNotNone(match('foo'))
+        self.assertIsNone(match('.foo'))
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/*', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('*/**', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', 'bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/.bar', recursive=True)).match
+        self.assertIsNotNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNone(match(os.path.join('.foo', '.bar')))
+        match = re.compile(glob.translate('**/*.*', recursive=True)).match
+        self.assertIsNone(match(os.path.join('foo', 'bar')))
+        self.assertIsNone(match(os.path.join('foo', '.bar')))
+        self.assertIsNotNone(match(os.path.join('foo', 'bar.txt')))
+        self.assertIsNone(match(os.path.join('foo', '.bar.txt')))
+
+    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('/**/*/*.*/**'),
+                         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')
+
+    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')
+
+    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)
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index e40f569d2c..323f4ee4c6 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -2,7 +2,7 @@
 # This just tests whether the parser accepts them all.
 
 from test.support import check_syntax_error
-from test.support.warnings_helper import check_syntax_warning
+from test.support import import_helper
 import inspect
 import unittest
 import sys
@@ -12,97 +12,19 @@
 
 # different import patterns to check that __annotations__ does not interfere
 # with import machinery
-# import test.ann_module as ann_module
+import test.typinganndata.ann_module as ann_module
 import typing
-from collections import ChainMap
-# from test import ann_module2
+from test.typinganndata import ann_module2
 import test
-
-# These are shared with test_tokenize and other test modules.
-#
-# Note: since several test cases filter out floats by looking for "e" and ".",
-# don't add hexadecimal literals that contain "e" or "E".
-VALID_UNDERSCORE_LITERALS = [
-    '0_0_0',
-    '4_2',
-    '1_0000_0000',
-    '0b1001_0100',
-    '0xffff_ffff',
-    '0o5_7_7',
-    '1_00_00.5',
-    '1_00_00.5e5',
-    '1_00_00e5_1',
-    '1e1_0',
-    '.1_4',
-    '.1_4e1',
-    '0b_0',
-    '0x_f',
-    '0o_5',
-    '1_00_00j',
-    '1_00_00.5j',
-    '1_00_00e5_1j',
-    '.1_4j',
-    '(1_2.5+3_3j)',
-    '(.5_6j)',
-]
-INVALID_UNDERSCORE_LITERALS = [
-    # Trailing underscores:
-    '0_',
-    '42_',
-    '1.4j_',
-    '0x_',
-    '0b1_',
-    '0xf_',
-    '0o5_',
-    '0 if 1_Else 1',
-    # Underscores in the base selector:
-    '0_b0',
-    '0_xf',
-    '0_o5',
-    # Old-style octal, still disallowed:
-    '0_7',
-    '09_99',
-    # Multiple consecutive underscores:
-    '4_______2',
-    '0.1__4',
-    '0.1__4j',
-    '0b1001__0100',
-    '0xffff__ffff',
-    '0x___',
-    '0o5__77',
-    '1e1__0',
-    '1e1__0j',
-    # Underscore right before a dot:
-    '1_.4',
-    '1_.4j',
-    # Underscore right after a dot:
-    '1._4',
-    '1._4j',
-    '._5',
-    '._5j',
-    # Underscore right after a sign:
-    '1.0e+_1',
-    '1.0e+_1j',
-    # Underscore right before j:
-    '1.4_j',
-    '1.4e5_j',
-    # Underscore right before e:
-    '1_e1',
-    '1.4_e1',
-    '1.4_e1j',
-    # Underscore right after e:
-    '1e_1',
-    '1.4e_1',
-    '1.4e_1j',
-    # Complex cases with parens:
-    '(1+1.5_j_)',
-    '(1+1.5_j)',
-]
-
+from test.support.numbers import (
+    VALID_UNDERSCORE_LITERALS,
+    INVALID_UNDERSCORE_LITERALS,
+)
 
 class TokenTests(unittest.TestCase):
 
     from test.support import check_syntax_error
+    from test.support.warnings_helper import check_syntax_warning
 
     def test_backslash(self):
         # Backslash means line continuation:
@@ -164,7 +86,7 @@ def test_floats(self):
         x = 3.14
         x = 314.
         x = 0.314
-        # XXX x = 000.314
+        x = 000.314
         x = .314
         x = 3e14
         x = 3E14
@@ -176,8 +98,10 @@ def test_floats(self):
 
     def test_float_exponent_tokenization(self):
         # See issue 21642.
-        self.assertEqual(1 if 1else 0, 1)
-        self.assertEqual(1 if 0else 0, 0)
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', SyntaxWarning)
+            self.assertEqual(eval("1 if 1else 0"), 1)
+            self.assertEqual(eval("1 if 0else 0"), 0)
         self.assertRaises(SyntaxError, eval, "0 if 1Else 0")
 
     def test_underscore_literals(self):
@@ -188,8 +112,7 @@ def test_underscore_literals(self):
         # Sanity check: no literal begins with an underscore
         self.assertRaises(NameError, eval, "_0")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_numerical_literals(self):
         check = self.check_syntax_error
         check("0b12", "invalid digit '2' in binary literal")
@@ -212,6 +135,47 @@ def test_bad_numerical_literals(self):
         check("1e2_", "invalid decimal literal")
         check("1e+", "invalid decimal literal")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_end_of_numerical_literals(self):
+        def check(test, error=False):
+            with self.subTest(expr=test):
+                if error:
+                    with warnings.catch_warnings(record=True) as w:
+                        with self.assertRaisesRegex(SyntaxError,
+                                    r'invalid \w+ literal'):
+                            compile(test, "<testcase>", "eval")
+                    self.assertEqual(w,  [])
+                else:
+                    self.check_syntax_warning(test,
+                            errtext=r'invalid \w+ literal')
+
+        for num in "0xf", "0o7", "0b1", "9", "0", "1.", "1e3", "1j":
+            compile(num, "<testcase>", "eval")
+            check(f"{num}and x", error=(num == "0xf"))
+            check(f"{num}or x", error=(num == "0"))
+            check(f"{num}in x")
+            check(f"{num}not in x")
+            check(f"{num}if x else y")
+            check(f"x if {num}else y", error=(num == "0xf"))
+            check(f"[{num}for x in ()]")
+            check(f"{num}spam", error=True)
+
+            # gh-88943: Invalid non-ASCII character following a numerical literal.
+            with self.assertRaisesRegex(SyntaxError, r"invalid character '⁄' \(U\+2044\)"):
+                compile(f"{num}⁄7", "<testcase>", "eval")
+
+            with self.assertWarnsRegex(SyntaxWarning, r'invalid \w+ literal'):
+                compile(f"{num}is x", "<testcase>", "eval")
+            with warnings.catch_warnings():
+                warnings.simplefilter('error', SyntaxWarning)
+                with self.assertRaisesRegex(SyntaxError,
+                            r'invalid \w+ literal'):
+                    compile(f"{num}is x", "<testcase>", "eval")
+
+        check("[0x1ffor x in ()]")
+        check("[0x1for x in ()]")
+        check("[0xfor x in ()]")
+
     def test_string_literals(self):
         x = ''; y = ""; self.assertTrue(len(x) == 0 and x == y)
         x = '\''; y = "'"; self.assertTrue(len(x) == 1 and x == y and ord(x) == 39)
@@ -257,12 +221,13 @@ 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:
             with self.assertRaises(SyntaxError) as cm:
                 compile(s, "<test>", "exec")
-            self.assertIn("unexpected EOF", str(cm.exception))
+            self.assertIn("was never closed", str(cm.exception))
 
 var_annot_global: int # a global annotated is necessary for test_var_annot
 
@@ -281,6 +246,7 @@ class GrammarTests(unittest.TestCase):
 
     from test.support import check_syntax_error
     from test.support.warnings_helper import check_syntax_warning
+    from test.support.warnings_helper import check_no_warnings
 
     # single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
     # XXX can't test in a script -- this rule is only used when interactive
@@ -307,14 +273,18 @@ def one():
         my_lst[one()-1]: int = 5
         self.assertEqual(my_lst, [5])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_syntax_errors(self):
         # parser pass
         check_syntax_error(self, "def f: int")
         check_syntax_error(self, "x: int: str")
         check_syntax_error(self, "def f():\n"
                                  "    nonlocal x: int\n")
+        check_syntax_error(self, "def f():\n"
+                                 "    global x: int\n")
+        check_syntax_error(self, "x: int = y = 1")
+        check_syntax_error(self, "z = w: int = 1")
+        check_syntax_error(self, "x: int = y: int = 1")
         # AST pass
         check_syntax_error(self, "[x, 0]: int\n")
         check_syntax_error(self, "f(): int\n")
@@ -328,9 +298,14 @@ def test_var_annot_syntax_errors(self):
         check_syntax_error(self, "def f():\n"
                                  "    global x\n"
                                  "    x: int\n")
+        check_syntax_error(self, "def f():\n"
+                                 "    x: int\n"
+                                 "    nonlocal x\n")
+        check_syntax_error(self, "def f():\n"
+                                 "    nonlocal x\n"
+                                 "    x: int\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_basic_semantics(self):
         # execution order
         with self.assertRaises(ZeroDivisionError):
@@ -377,6 +352,28 @@ class Cbad2(C):
                 x: int
                 x.y: list = []
 
+    def test_annotations_inheritance(self):
+        # Check that annotations are not inherited by derived classes
+        class A:
+            attr: int
+        class B(A):
+            pass
+        class C(A):
+            attr: str
+        class D:
+            attr2: int
+        class E(A, D):
+            pass
+        class F(C, A):
+            pass
+        self.assertEqual(A.__annotations__, {"attr": int})
+        self.assertEqual(B.__annotations__, {})
+        self.assertEqual(C.__annotations__, {"attr" : str})
+        self.assertEqual(D.__annotations__, {"attr2" : int})
+        self.assertEqual(E.__annotations__, {})
+        self.assertEqual(F.__annotations__, {})
+
+
     def test_var_annot_metaclass_semantics(self):
         class CMeta(type):
             @classmethod
@@ -386,13 +383,11 @@ class CC(metaclass=CMeta):
             XX: 'ANNOT'
         self.assertEqual(CC.__annotations__['xx'], 'ANNOT')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_module_semantics(self):
-        with self.assertRaises(AttributeError):
-            print(test.__annotations__)
+        self.assertEqual(test.__annotations__, {})
         self.assertEqual(ann_module.__annotations__,
-                     {1: 2, 'x': int, 'y': str, 'f': typing.Tuple[int, int]})
+                     {1: 2, 'x': int, 'y': str, 'f': typing.Tuple[int, int], 'u': int | float})
         self.assertEqual(ann_module.M.__annotations__,
                               {'123': 123, 'o': type})
         self.assertEqual(ann_module2.__annotations__, {})
@@ -400,13 +395,13 @@ def test_var_annot_module_semantics(self):
     def test_var_annot_in_module(self):
         # check that functions fail the same way when executed
         # outside of module where they were defined
-        from test.typinganndata.ann_module3 import f_bad_ann, g_bad_ann, D_bad_ann
+        ann_module3 = import_helper.import_fresh_module("test.typinganndata.ann_module3")
         with self.assertRaises(NameError):
-            f_bad_ann()
+            ann_module3.f_bad_ann()
         with self.assertRaises(NameError):
-            g_bad_ann()
+            ann_module3.g_bad_ann()
         with self.assertRaises(NameError):
-            D_bad_ann(5)
+            ann_module3.D_bad_ann(5)
 
     def test_var_annot_simple_exec(self):
         gns = {}; lns= {}
@@ -417,8 +412,7 @@ def test_var_annot_simple_exec(self):
         with self.assertRaises(KeyError):
             gns['__annotations__']
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_custom_maps(self):
         # tests with custom locals() and __annotations__
         ns = {'__annotations__': CNS()}
@@ -440,8 +434,7 @@ def __getitem__(self, item):
         exec('x: int = 1', {}, CNS2())
         self.assertEqual(nonloc_ns['__annotations__']['x'], int)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_var_annot_refleak(self):
         # complex case: custom locals plus custom __annotations__
         # this was causing refleak
@@ -459,7 +452,6 @@ def __getitem__(self, item):
         exec('X: str', {}, CNS2())
         self.assertEqual(nonloc_ns['__annotations__']['x'], str)
 
-
     def test_var_annot_rhs(self):
         ns = {}
         exec('x: tuple = 1, 2', ns)
@@ -475,7 +467,7 @@ def test_var_annot_rhs(self):
 
     def test_funcdef(self):
         ### [decorators] 'def' NAME parameters ['->' test] ':' suite
-        ### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+        ### decorator: '@' namedexpr_test NEWLINE
         ### decorators: decorator+
         ### parameters: '(' [typedargslist] ')'
         ### typedargslist: ((tfpdef ['=' test] ',')*
@@ -597,12 +589,14 @@ def d22v(a, b, c=1, d=2, *rest): pass
         d22v(1, *(2, 3), **{'d': 4})
 
         # keyword argument type tests
-        try:
-            str('x', **{b'foo':1 })
-        except TypeError:
-            pass
-        else:
-            self.fail('Bytes should not work as keyword argument names')
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', BytesWarning)
+            try:
+                str('x', **{b'foo':1 })
+            except TypeError:
+                pass
+            else:
+                self.fail('Bytes should not work as keyword argument names')
         # keyword only argument tests
         def pos0key1(*, key): return key
         pos0key1(key=100)
@@ -681,6 +675,20 @@ def null(x): return x
         def f(x) -> list: pass
         self.assertEqual(f.__annotations__, {'return': list})
 
+        # Test expressions as decorators (PEP 614):
+        @False or null
+        def f(x): pass
+        @d := null
+        def f(x): pass
+        @lambda f: null(f)
+        def f(x): pass
+        @[..., null, ...][1]
+        def f(x): pass
+        @null(null)(null)
+        def f(x): pass
+        @[null][0].__call__.__call__
+        def f(x): pass
+
         # test closures with a variety of opargs
         closure = 1
         def f(): return closure
@@ -768,10 +776,9 @@ def test_expr_stmt(self):
         check_syntax_error(self, "x + 1 = 1")
         check_syntax_error(self, "a + 1 = b + 2")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Check the heuristic for print & exec covers significant cases
     # As well as placing some limits on false positives
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_former_statements_refer_to_builtins(self):
         keywords = "print", "exec"
         # Cases where we want the custom error
@@ -804,6 +811,23 @@ def test_del_stmt(self):
         del abc
         del x, y, (z, xyz)
 
+        x, y, z = "xyz"
+        del x
+        del y,
+        del (z)
+        del ()
+
+        a, b, c, d, e, f, g = "abcdefg"
+        del a, (b, c), (d, (e, f))
+
+        a, b, c, d, e, f, g = "abcdefg"
+        del a, [b, c], (d, [e, f])
+
+        abcd = list("abcd")
+        del abcd[1:2]
+
+        compile("del a, (b[0].c, (d.e, f.g[1:2])), [h.i.j], ()", "<testcase>", "exec")
+
     def test_pass_stmt(self):
         # 'pass'
         pass
@@ -1062,8 +1086,7 @@ def g2(x):
         self.assertEqual(g2(False), 0)
         self.assertEqual(g2(True), ('end', 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_yield(self):
         # Allowed as standalone statement
         def g(): yield 1
@@ -1103,8 +1126,7 @@ def g(): rest = 4, 5, 6; yield 1, 2, 3, *rest
         # Check annotation refleak on SyntaxError
         check_syntax_error(self, "def g(a:(yield)): pass")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_yield_in_comprehensions(self):
         # Check yield in comprehensions
         def g(): [x for x in [(yield 1)]]
@@ -1184,11 +1206,9 @@ def test_assert(self):
             self.fail("'assert True, msg' should not have "
                       "raised an AssertionError")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # these tests fail if python is run with -O, so check __debug__
     @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
-    def testAssert2(self):
+    def test_assert_failures(self):
         try:
             assert 0, "msg"
         except AssertionError as e:
@@ -1203,11 +1223,38 @@ def testAssert2(self):
         else:
             self.fail("AssertionError not raised by 'assert False'")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assert_syntax_warnings(self):
+        # Ensure that we warn users if they provide a non-zero length tuple as
+        # the assertion test.
         self.check_syntax_warning('assert(x, "msg")',
                                   'assertion is always true')
+        self.check_syntax_warning('assert(False, "msg")',
+                                  'assertion is always true')
+        self.check_syntax_warning('assert(False,)',
+                                  'assertion is always true')
+
+        with self.check_no_warnings(category=SyntaxWarning):
+            compile('assert x, "msg"', '<testcase>', 'exec')
+            compile('assert False, "msg"', '<testcase>', 'exec')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_assert_warning_promotes_to_syntax_error(self):
+        # If SyntaxWarning is configured to be an error, it actually raises a
+        # SyntaxError.
+        # https://bugs.python.org/issue35029
         with warnings.catch_warnings():
             warnings.simplefilter('error', SyntaxWarning)
-            compile('assert x, "msg"', '<testcase>', 'exec')
+            try:
+                compile('assert x, "msg" ', '<testcase>', 'exec')
+            except SyntaxError:
+                self.fail('SyntaxError incorrectly raised for \'assert x, "msg"\'')
+            with self.assertRaises(SyntaxError):
+                compile('assert(x, "msg")', '<testcase>', 'exec')
+            with self.assertRaises(SyntaxError):
+                compile('assert(False, "msg")', '<testcase>', 'exec')
+            with self.assertRaises(SyntaxError):
+                compile('assert(False,)', '<testcase>', 'exec')
 
 
     ### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
@@ -1268,10 +1315,16 @@ def __getitem__(self, i):
             result.append(x)
         self.assertEqual(result, [1, 2, 3])
 
+        result = []
+        a = b = c = [1, 2, 3]
+        for x in *a, *b, *c:
+            result.append(x)
+        self.assertEqual(result, 3 * a)
+
     def test_try(self):
         ### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
         ###         | 'try' ':' suite 'finally' ':' suite
-        ### except_clause: 'except' [expr ['as' expr]]
+        ### except_clause: 'except' [expr ['as' NAME]]
         try:
             1/0
         except ZeroDivisionError:
@@ -1289,6 +1342,36 @@ def test_try(self):
         except (EOFError, TypeError, ZeroDivisionError) as msg: pass
         try: pass
         finally: pass
+        with self.assertRaises(SyntaxError):
+            compile("try:\n    pass\nexcept Exception as a.b:\n    pass", "?", "exec")
+            compile("try:\n    pass\nexcept Exception as a[b]:\n    pass", "?", "exec")
+
+    # TODO: RUSTPYTHON
+    '''
+    def test_try_star(self):
+        ### try_stmt: 'try': suite (except_star_clause : suite) + ['else' ':' suite]
+        ### except_star_clause: 'except*' expr ['as' NAME]
+        try:
+            1/0
+        except* ZeroDivisionError:
+            pass
+        else:
+            pass
+        try: 1/0
+        except* EOFError: pass
+        except* ZeroDivisionError as msg: pass
+        else: pass
+        try: 1/0
+        except* (EOFError, TypeError, ZeroDivisionError): pass
+        try: 1/0
+        except* (EOFError, TypeError, ZeroDivisionError) as msg: pass
+        try: pass
+        finally: pass
+        with self.assertRaises(SyntaxError):
+            compile("try:\n    pass\nexcept* Exception as a.b:\n    pass", "?", "exec")
+            compile("try:\n    pass\nexcept* Exception as a[b]:\n    pass", "?", "exec")
+            compile("try:\n    pass\nexcept*:\n    pass", "?", "exec")
+    '''
 
     def test_suite(self):
         # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
@@ -1333,17 +1416,24 @@ def test_comparison(self):
         if 1 not in (): pass
         if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in x is x is not x: pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_comparison_is_literal(self):
-        def check(test, msg='"is" with a literal'):
+        def check(test, msg):
             self.check_syntax_warning(test, msg)
 
-        check('x is 1')
-        check('x is "thing"')
-        check('1 is x')
-        check('x is y is 1')
-        check('x is not 1', '"is not" with a literal')
+        check('x is 1', '"is" with \'int\' literal')
+        check('x is "thing"', '"is" with \'str\' literal')
+        check('1 is x', '"is" with \'int\' literal')
+        check('x is y is 1', '"is" with \'int\' literal')
+        check('x is not 1', '"is not" with \'int\' literal')
+        check('x is not (1, 2)', '"is not" with \'tuple\' literal')
+        check('(1, 2) is not x', '"is not" with \'tuple\' literal')
+
+        check('None is 1', '"is" with \'int\' literal')
+        check('1 is None', '"is" with \'int\' literal')
+
+        check('x == 3 is y', '"is" with \'int\' literal')
+        check('x == "thing" is y', '"is" with \'str\' literal')
 
         with warnings.catch_warnings():
             warnings.simplefilter('error', SyntaxWarning)
@@ -1351,9 +1441,12 @@ def check(test, msg='"is" with a literal'):
             compile('x is False', '<testcase>', 'exec')
             compile('x is True', '<testcase>', 'exec')
             compile('x is ...', '<testcase>', 'exec')
+            compile('None is x', '<testcase>', 'exec')
+            compile('False is x', '<testcase>', 'exec')
+            compile('True is x', '<testcase>', 'exec')
+            compile('... is x', '<testcase>', 'exec')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_warn_missed_comma(self):
         def check(test):
             self.check_syntax_warning(test, msg)
@@ -1483,7 +1576,7 @@ def test_selectors(self):
         s = a[-5:]
         s = a[:-1]
         s = a[-4:-3]
-        # A rough test of SF bug 1333982.  http://python.org/sf/1333982
+        # A rough test of SF bug 1333982.  https://bugs.python.org/issue1333982
         # The testing here is fairly incomplete.
         # Test cases should include: commas with 1 and 2 colons
         d = {}
@@ -1530,6 +1623,8 @@ def test_atoms(self):
     ### testlist: test (',' test)* [',']
     # These have been exercised enough above
 
+    # TODO: RUSTPYTHON
+    '''
     def test_classdef(self):
         # 'class' NAME ['(' [testlist] ')'] ':' suite
         class B: pass
@@ -1542,13 +1637,28 @@ def meth1(self): pass
             def meth2(self, arg): pass
             def meth3(self, a1, a2): pass
 
-        # decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
+        # decorator: '@' namedexpr_test NEWLINE
         # decorators: decorator+
         # decorated: decorators (classdef | funcdef)
         def class_decorator(x): return x
         @class_decorator
         class G: pass
 
+        # Test expressions as decorators (PEP 614):
+        @False or class_decorator
+        class H: pass
+        @d := class_decorator
+        class I: pass
+        @lambda c: class_decorator(c)
+        class J: pass
+        @[..., class_decorator, ...][1]
+        class K: pass
+        @class_decorator(class_decorator)(class_decorator)
+        class L: pass
+        @[class_decorator][0].__call__.__call__
+        class M: pass
+    '''
+
     def test_dictcomps(self):
         # dictorsetmaker: ( (test ':' test (comp_for |
         #                                   (',' test ':' test)* [','])) |
@@ -1693,6 +1803,54 @@ def __exit__(self, *args):
         with manager() as x, manager():
             pass
 
+        with (
+            manager()
+        ):
+            pass
+
+        with (
+            manager() as x
+        ):
+            pass
+
+        with (
+            manager() as (x, y),
+            manager() as z,
+        ):
+            pass
+
+        with (
+            manager(),
+            manager()
+        ):
+            pass
+
+        with (
+            manager() as x,
+            manager() as y
+        ):
+            pass
+
+        with (
+            manager() as x,
+            manager()
+        ):
+            pass
+
+        with (
+            manager() as x,
+            manager() as y,
+            manager() as z,
+        ):
+            pass
+
+        with (
+            manager() as x,
+            manager() as y,
+            manager(),
+        ):
+            pass
+
     def test_if_else_expr(self):
         # Test ifelse expressions in various cases
         def _checkeval(msg, ret):
@@ -1815,6 +1973,18 @@ async def foo():
         with self.assertRaises(Done):
             foo().send(None)
 
+    def test_complex_lambda(self):
+        def test1(foo, bar):
+            return ""
+
+        def test2():
+            return f"{test1(
+                foo=lambda: '、、、、、、、、、、、、、、、、、',
+                bar=lambda: 'abcdefghijklmnopqrstuvwxyz 123456789 123456789',
+            )}"
+
+        self.assertEqual(test2(), "")
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py
index 5055c4c7f7..cd9cbe9bff 100644
--- a/Lib/test/test_hashlib.py
+++ b/Lib/test/test_hashlib.py
@@ -784,6 +784,7 @@ def test_case_blake2b_all_parameters(self):
           inner_size=7,
           last_node=True)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_blake2
     def test_blake2b_vectors(self):
         for msg, key, md in read_vectors('blake2b'):
@@ -831,6 +832,7 @@ def test_case_blake2s_all_parameters(self):
           inner_size=7,
           last_node=True)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_blake2
     def test_blake2s_vectors(self):
         for msg, key, md in read_vectors('blake2s'):
diff --git a/Lib/test/test_hmac.py b/Lib/test/test_hmac.py
index 8e1a4a204c..1726975e86 100644
--- a/Lib/test/test_hmac.py
+++ b/Lib/test/test_hmac.py
@@ -432,8 +432,6 @@ def test_dot_new_with_str_key(self):
         with self.assertRaises(TypeError):
             h = hmac.new("key", digestmod='sha256')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_withtext(self):
         # Constructor call with text.
@@ -443,8 +441,6 @@ def test_withtext(self):
             self.fail("Constructor call with text argument raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_with_bytearray(self):
         try:
@@ -454,8 +450,6 @@ def test_with_bytearray(self):
             self.fail("Constructor call with bytearray arguments raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_with_memoryview_msg(self):
         try:
@@ -464,8 +458,6 @@ def test_with_memoryview_msg(self):
             self.fail("Constructor call with memoryview msg raised exception.")
         self.assertEqual(h.hexdigest(), self.expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @hashlib_helper.requires_hashdigest('sha256')
     def test_withmodule(self):
         # Constructor call with text and digest module.
@@ -513,6 +505,14 @@ def test_exercise_all_methods(self):
             self.fail("Exception raised during normal usage of HMAC class.")
 
 
+class UpdateTestCase(unittest.TestCase):
+    @hashlib_helper.requires_hashdigest('sha256')
+    def test_with_str_update(self):
+        with self.assertRaises(TypeError):
+            h = hmac.new(b"key", digestmod='sha256')
+            h.update("invalid update")
+
+
 class CopyTestCase(unittest.TestCase):
 
     @hashlib_helper.requires_hashdigest('sha256')
diff --git a/Lib/test/test_htmlparser.py b/Lib/test/test_htmlparser.py
index 12917755a5..6a1d69335a 100644
--- a/Lib/test/test_htmlparser.py
+++ b/Lib/test/test_htmlparser.py
@@ -4,13 +4,19 @@
 import pprint
 import unittest
 
+from unittest.mock import patch
+from test import support
+
 
 class EventCollector(html.parser.HTMLParser):
 
-    def __init__(self, *args, **kw):
+    def __init__(self, *args, autocdata=False, **kw):
+        self.autocdata = autocdata
         self.events = []
         self.append = self.events.append
         html.parser.HTMLParser.__init__(self, *args, **kw)
+        if autocdata:
+            self._set_support_cdata(False)
 
     def get_events(self):
         # Normalize the list of events so that buffer artefacts don't
@@ -31,12 +37,16 @@ def get_events(self):
 
     def handle_starttag(self, tag, attrs):
         self.append(("starttag", tag, attrs))
+        if self.autocdata and tag == 'svg':
+            self._set_support_cdata(True)
 
     def handle_startendtag(self, tag, attrs):
         self.append(("startendtag", tag, attrs))
 
     def handle_endtag(self, tag):
         self.append(("endtag", tag))
+        if self.autocdata and tag == 'svg':
+            self._set_support_cdata(False)
 
     # all other markup
 
@@ -78,6 +88,13 @@ def handle_entityref(self, data):
         self.fail('This should never be called with convert_charrefs=True')
 
 
+# The normal event collector normalizes the events in get_events,
+# so we override it to return the original list of events.
+class EventCollectorNoNormalize(EventCollector):
+    def get_events(self):
+        return self.events
+
+
 class TestCaseBase(unittest.TestCase):
 
     def get_collector(self):
@@ -262,8 +279,7 @@ def test_get_starttag_text(self):
             ("starttag", "foo:bar", [("one", "1"), ("two", "2")]),
             ("starttag_text", s)])
 
-    def test_cdata_content(self):
-        contents = [
+    @support.subTests('content', [
             '<!-- not a comment --> &not-an-entity-ref;',
             "<not a='start tag'>",
             '<a href="" /> <p> <span></span>',
@@ -276,60 +292,223 @@ def test_cdata_content(self):
              'src="http://www.example.org/r=\'+new '
              'Date().getTime()+\'"><\\/s\'+\'cript>\');\n//]]>'),
             '\n<!-- //\nvar foo = 3.14;\n// -->\n',
-            'foo = "</sty" + "le>";',
             '<!-- \u2603 -->',
-            # these two should be invalid according to the HTML 5 spec,
-            # section 8.1.2.2
-            #'foo = </\nscript>',
-            #'foo = </ script>',
-        ]
-        elements = ['script', 'style', 'SCRIPT', 'STYLE', 'Script', 'Style']
-        for content in contents:
-            for element in elements:
-                element_lower = element.lower()
-                s = '<{element}>{content}</{element}>'.format(element=element,
-                                                               content=content)
-                self._run_check(s, [("starttag", element_lower, []),
-                                    ("data", content),
-                                    ("endtag", element_lower)])
-
-    def test_cdata_with_closing_tags(self):
+            'foo = "</ script>"',
+            'foo = "</scripture>"',
+            'foo = "</script\v>"',
+            'foo = "</script\xa0>"',
+            'foo = "</ſcript>"',
+            'foo = "</scrıpt>"',
+        ])
+    def test_script_content(self, content):
+        s = f'<script>{content}</script>'
+        self._run_check(s, [("starttag", "script", []),
+                            ("data", content),
+                            ("endtag", "script")])
+
+    @support.subTests('content', [
+            'a::before { content: "<!-- not a comment -->"; }',
+            'a::before { content: "&not-an-entity-ref;"; }',
+            'a::before { content: "<not a=\'start tag\'>"; }',
+            'a::before { content: "\u2603"; }',
+            'a::before { content: "< /style>"; }',
+            'a::before { content: "</ style>"; }',
+            'a::before { content: "</styled>"; }',
+            'a::before { content: "</style\v>"; }',
+            'a::before { content: "</style\xa0>"; }',
+            'a::before { content: "</ſtyle>"; }',
+        ])
+    def test_style_content(self, content):
+        s = f'<style>{content}</style>'
+        self._run_check(s, [("starttag", "style", []),
+                            ("data", content),
+                            ("endtag", "style")])
+
+    @support.subTests('content', [
+            '<!-- not a comment -->',
+            "<not a='start tag'>",
+            '<![CDATA[not a cdata]]>',
+            '<!not a bogus comment>',
+            '</not a bogus comment>',
+            '\u2603',
+            '< /title>',
+            '</ title>',
+            '</titled>',
+            '</title\v>',
+            '</title\xa0>',
+            '</tıtle>',
+        ])
+    def test_title_content(self, content):
+        source = f"<title>{content}</title>"
+        self._run_check(source, [
+            ("starttag", "title", []),
+            ("data", content),
+            ("endtag", "title"),
+        ])
+
+    @support.subTests('content', [
+            '<!-- not a comment -->',
+            "<not a='start tag'>",
+            '<![CDATA[not a cdata]]>',
+            '<!not a bogus comment>',
+            '</not a bogus comment>',
+            '\u2603',
+            '< /textarea>',
+            '</ textarea>',
+            '</textareable>',
+            '</textarea\v>',
+            '</textarea\xa0>',
+        ])
+    def test_textarea_content(self, content):
+        source = f"<textarea>{content}</textarea>"
+        self._run_check(source, [
+            ("starttag", "textarea", []),
+            ("data", content),
+            ("endtag", "textarea"),
+        ])
+
+    @support.subTests('endtag', ['script', 'SCRIPT', 'script ', 'script\n',
+                                 'script/', 'script foo=bar', 'script foo=">"'])
+    def test_script_closing_tag(self, endtag):
         # see issue #13358
         # make sure that HTMLParser calls handle_data only once for each CDATA.
-        # The normal event collector normalizes  the events in get_events,
-        # so we override it to return the original list of events.
-        class Collector(EventCollector):
-            def get_events(self):
-                return self.events
-
         content = """<!-- not a comment --> &not-an-entity-ref;
                   <a href="" /> </p><p> <span></span></style>
                   '</script' + '>'"""
-        for element in [' script', 'script ', ' script ',
-                        '\nscript', 'script\n', '\nscript\n']:
-            element_lower = element.lower().strip()
-            s = '<script>{content}</{element}>'.format(element=element,
-                                                       content=content)
-            self._run_check(s, [("starttag", element_lower, []),
-                                ("data", content),
-                                ("endtag", element_lower)],
-                            collector=Collector(convert_charrefs=False))
+        s = f'<ScrIPt>{content}</{endtag}>'
+        self._run_check(s, [("starttag", "script", []),
+                            ("data", content),
+                            ("endtag", "script")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
+
+    @support.subTests('endtag', ['style', 'STYLE', 'style ', 'style\n',
+                                 'style/', 'style foo=bar', 'style foo=">"'])
+    def test_style_closing_tag(self, endtag):
+        content = """
+            b::before { content: "<!-- not a comment -->"; }
+            p::before { content: "&not-an-entity-ref;"; }
+            a::before { content: "<i>"; }
+            a::after { content: "</i>"; }
+            """
+        s = f'<StyLE>{content}</{endtag}>'
+        self._run_check(s, [("starttag", "style", []),
+                            ("data", content),
+                            ("endtag", "style")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
+
+    @support.subTests('endtag', ['title', 'TITLE', 'title ', 'title\n',
+                                 'title/', 'title foo=bar', 'title foo=">"'])
+    def test_title_closing_tag(self, endtag):
+        content = "<!-- not a comment --><i>Egg &amp; Spam</i>"
+        s = f'<TitLe>{content}</{endtag}>'
+        self._run_check(s, [("starttag", "title", []),
+                            ('data', '<!-- not a comment --><i>Egg & Spam</i>'),
+                            ("endtag", "title")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=True))
+        self._run_check(s, [("starttag", "title", []),
+                            ('data', '<!-- not a comment --><i>Egg '),
+                            ('entityref', 'amp'),
+                            ('data', ' Spam</i>'),
+                            ("endtag", "title")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
+
+    @support.subTests('endtag', ['textarea', 'TEXTAREA', 'textarea ', 'textarea\n',
+                                 'textarea/', 'textarea foo=bar', 'textarea foo=">"'])
+    def test_textarea_closing_tag(self, endtag):
+        content = "<!-- not a comment --><i>Egg &amp; Spam</i>"
+        s = f'<TexTarEa>{content}</{endtag}>'
+        self._run_check(s, [("starttag", "textarea", []),
+                            ('data', '<!-- not a comment --><i>Egg & Spam</i>'),
+                            ("endtag", "textarea")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=True))
+        self._run_check(s, [("starttag", "textarea", []),
+                            ('data', '<!-- not a comment --><i>Egg '),
+                            ('entityref', 'amp'),
+                            ('data', ' Spam</i>'),
+                            ("endtag", "textarea")],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
+
+    @support.subTests('tail,end', [
+        ('', False),
+        ('<', False),
+        ('</', False),
+        ('</s', False),
+        ('</script', False),
+        ('</script ', True),
+        ('</script foo=bar', True),
+        ('</script foo=">', True),
+    ])
+    def test_eof_in_script(self, tail, end):
+        content = "a = 123"
+        s = f'<ScrIPt>{content}{tail}'
+        self._run_check(s, [("starttag", "script", []),
+                            ("data", content if end else content + tail)],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
+
+    @support.subTests('tail,end', [
+        ('', False),
+        ('<', False),
+        ('</', False),
+        ('</t', False),
+        ('</title', False),
+        ('</title ', True),
+        ('</title foo=bar', True),
+        ('</title foo=">', True),
+    ])
+    def test_eof_in_title(self, tail, end):
+        s = f'<TitLe>Egg &amp; Spam{tail}'
+        self._run_check(s, [("starttag", "title", []),
+                            ("data", "Egg & Spam" + ('' if end else tail))],
+                        collector=EventCollectorNoNormalize(convert_charrefs=True))
+        self._run_check(s, [("starttag", "title", []),
+                            ('data', 'Egg '),
+                            ('entityref', 'amp'),
+                            ('data', ' Spam' + ('' if end else tail))],
+                        collector=EventCollectorNoNormalize(convert_charrefs=False))
 
     def test_comments(self):
         html = ("<!-- I'm a valid comment -->"
                 '<!--me too!-->'
                 '<!------>'
+                '<!----->'
                 '<!---->'
+                # abrupt-closing-of-empty-comment
+                '<!--->'
+                '<!-->'
                 '<!----I have many hyphens---->'
                 '<!-- I have a > in the middle -->'
-                '<!-- and I have -- in the middle! -->')
+                '<!-- and I have -- in the middle! -->'
+                '<!--incorrectly-closed-comment--!>'
+                '<!----!>'
+                '<!----!-->'
+                '<!---- >-->'
+                '<!---!>-->'
+                '<!--!>-->'
+                # nested-comment
+                '<!-- <!-- nested --> -->'
+                '<!--<!-->'
+                '<!--<!--!>'
+        )
         expected = [('comment', " I'm a valid comment "),
                     ('comment', 'me too!'),
                     ('comment', '--'),
+                    ('comment', '-'),
+                    ('comment', ''),
+                    ('comment', ''),
                     ('comment', ''),
                     ('comment', '--I have many hyphens--'),
                     ('comment', ' I have a > in the middle '),
-                    ('comment', ' and I have -- in the middle! ')]
+                    ('comment', ' and I have -- in the middle! '),
+                    ('comment', 'incorrectly-closed-comment'),
+                    ('comment', ''),
+                    ('comment', '--!'),
+                    ('comment', '-- >'),
+                    ('comment', '-!>'),
+                    ('comment', '!>'),
+                    ('comment', ' <!-- nested '), ('data', ' -->'),
+                    ('comment', '<!'),
+                    ('comment', '<!'),
+        ]
         self._run_check(html, expected)
 
     def test_condcoms(self):
@@ -346,18 +525,16 @@ def test_convert_charrefs(self):
         collector = lambda: EventCollectorCharrefs()
         self.assertTrue(collector().convert_charrefs)
         charrefs = ['&quot;', '&#34;', '&#x22;', '&quot', '&#34', '&#x22']
-        # check charrefs in the middle of the text/attributes
-        expected = [('starttag', 'a', [('href', 'foo"zar')]),
-                    ('data', 'a"z'), ('endtag', 'a')]
+        # check charrefs in the middle of the text
+        expected = [('starttag', 'a', []), ('data', 'a"z'), ('endtag', 'a')]
         for charref in charrefs:
-            self._run_check('<a href="foo{0}zar">a{0}z</a>'.format(charref),
+            self._run_check('<a>a{0}z</a>'.format(charref),
                             expected, collector=collector())
-        # check charrefs at the beginning/end of the text/attributes
-        expected = [('data', '"'),
-                    ('starttag', 'a', [('x', '"'), ('y', '"X'), ('z', 'X"')]),
+        # check charrefs at the beginning/end of the text
+        expected = [('data', '"'), ('starttag', 'a', []),
                     ('data', '"'), ('endtag', 'a'), ('data', '"')]
         for charref in charrefs:
-            self._run_check('{0}<a x="{0}" y="{0}X" z="X{0}">'
+            self._run_check('{0}<a>'
                             '{0}</a>{0}'.format(charref),
                             expected, collector=collector())
         # check charrefs in <script>/<style> elements
@@ -380,6 +557,35 @@ def test_convert_charrefs(self):
         self._run_check('no charrefs here', [('data', 'no charrefs here')],
                         collector=collector())
 
+    def test_convert_charrefs_in_attribute_values(self):
+        # default value for convert_charrefs is now True
+        collector = lambda: EventCollectorCharrefs()
+        self.assertTrue(collector().convert_charrefs)
+
+        # always unescape terminated entity refs, numeric and hex char refs:
+        # - regardless whether they are at start, middle, end of attribute
+        # - or followed by alphanumeric, non-alphanumeric, or equals char
+        charrefs = ['&cent;', '&#xa2;', '&#xa2', '&#162;', '&#162']
+        expected = [('starttag', 'a',
+                     [('x', '¢'), ('x', 'z¢'), ('x', '¢z'),
+                      ('x', 'z¢z'), ('x', '¢ z'), ('x', '¢=z')]),
+                    ('endtag', 'a')]
+        for charref in charrefs:
+            self._run_check('<a x="{0}" x="z{0}" x="{0}z" '
+                            '   x="z{0}z" x="{0} z" x="{0}=z"></a>'
+                            .format(charref), expected, collector=collector())
+
+        # only unescape unterminated entity matches if they are not followed by
+        # an alphanumeric or an equals sign
+        charref = '&cent'
+        expected = [('starttag', 'a',
+                     [('x', '¢'), ('x', 'z¢'), ('x', '&centz'),
+                      ('x', 'z&centz'), ('x', '¢ z'), ('x', '&cent=z')]),
+                    ('endtag', 'a')]
+        self._run_check('<a x="{0}" x="z{0}" x="{0}z" '
+                        '   x="z{0}z" x="{0} z" x="{0}=z"></a>'
+                        .format(charref), expected, collector=collector())
+
     # the remaining tests were for the "tolerant" parser (which is now
     # the default), and check various kind of broken markup
     def test_tolerant_parsing(self):
@@ -391,28 +597,34 @@ def test_tolerant_parsing(self):
                             ('data', '<'),
                             ('starttag', 'bc<', [('a', None)]),
                             ('endtag', 'html'),
-                            ('data', '\n<img src="URL>'),
-                            ('comment', '/img'),
-                            ('endtag', 'html<')])
+                            ('data', '\n')])
 
     def test_starttag_junk_chars(self):
+        self._run_check("<", [('data', '<')])
+        self._run_check("<>", [('data', '<>')])
+        self._run_check("< >", [('data', '< >')])
+        self._run_check("< ", [('data', '< ')])
         self._run_check("</>", [])
+        self._run_check("<$>", [('data', '<$>')])
         self._run_check("</$>", [('comment', '$')])
         self._run_check("</", [('data', '</')])
-        self._run_check("</a", [('data', '</a')])
+        self._run_check("</a", [])
+        self._run_check("</ a>", [('comment', ' a')])
+        self._run_check("</ a", [('comment', ' a')])
         self._run_check("<a<a>", [('starttag', 'a<a', [])])
         self._run_check("</a<a>", [('endtag', 'a<a')])
-        self._run_check("<!", [('data', '<!')])
-        self._run_check("<a", [('data', '<a')])
-        self._run_check("<a foo='bar'", [('data', "<a foo='bar'")])
-        self._run_check("<a foo='bar", [('data', "<a foo='bar")])
-        self._run_check("<a foo='>'", [('data', "<a foo='>'")])
-        self._run_check("<a foo='>", [('data', "<a foo='>")])
+        self._run_check("<!", [('comment', '')])
+        self._run_check("<a", [])
+        self._run_check("<a foo='bar'", [])
+        self._run_check("<a foo='bar", [])
+        self._run_check("<a foo='>'", [])
+        self._run_check("<a foo='>", [])
         self._run_check("<a$>", [('starttag', 'a$', [])])
         self._run_check("<a$b>", [('starttag', 'a$b', [])])
         self._run_check("<a$b/>", [('startendtag', 'a$b', [])])
         self._run_check("<a$b  >", [('starttag', 'a$b', [])])
         self._run_check("<a$b  />", [('startendtag', 'a$b', [])])
+        self._run_check("</a$b>", [('endtag', 'a$b')])
 
     def test_slashes_in_starttag(self):
         self._run_check('<a foo="var"/>', [('startendtag', 'a', [('foo', 'var')])])
@@ -445,6 +657,10 @@ def test_slashes_in_starttag(self):
         ]
         self._run_check(html, expected)
 
+    def test_slashes_in_endtag(self):
+        self._run_check('</a/>', [('endtag', 'a')])
+        self._run_check('</a foo="var"/>', [('endtag', 'a')])
+
     def test_declaration_junk_chars(self):
         self._run_check("<!DOCTYPE foo $ >", [('decl', 'DOCTYPE foo $ ')])
 
@@ -479,15 +695,11 @@ def test_invalid_end_tags(self):
         self._run_check(html, expected)
 
     def test_broken_invalid_end_tag(self):
-        # This is technically wrong (the "> shouldn't be included in the 'data')
-        # but is probably not worth fixing it (in addition to all the cases of
-        # the previous test, it would require a full attribute parsing).
-        # see #13993
         html = '<b>This</b attr=">"> confuses the parser'
         expected = [('starttag', 'b', []),
                     ('data', 'This'),
                     ('endtag', 'b'),
-                    ('data', '"> confuses the parser')]
+                    ('data', ' confuses the parser')]
         self._run_check(html, expected)
 
     def test_correct_detection_of_start_tags(self):
@@ -537,55 +749,165 @@ def test_EOF_in_charref(self):
         for html, expected in data:
             self._run_check(html, expected)
 
-    def test_broken_comments(self):
-        html = ('<! not really a comment >'
+    def test_eof_in_comments(self):
+        data = [
+            ('<!--', [('comment', '')]),
+            ('<!---', [('comment', '')]),
+            ('<!----', [('comment', '')]),
+            ('<!-----', [('comment', '-')]),
+            ('<!------', [('comment', '--')]),
+            ('<!----!', [('comment', '')]),
+            ('<!---!', [('comment', '-!')]),
+            ('<!---!>', [('comment', '-!>')]),
+            ('<!--foo', [('comment', 'foo')]),
+            ('<!--foo-', [('comment', 'foo')]),
+            ('<!--foo--', [('comment', 'foo')]),
+            ('<!--foo--!', [('comment', 'foo')]),
+            ('<!--<!--', [('comment', '<!')]),
+            ('<!--<!--!', [('comment', '<!')]),
+        ]
+        for html, expected in data:
+            self._run_check(html, expected)
+
+    def test_eof_in_declarations(self):
+        data = [
+            ('<!', [('comment', '')]),
+            ('<!-', [('comment', '-')]),
+            ('<![', [('comment', '[')]),
+            ('<!DOCTYPE', [('decl', 'DOCTYPE')]),
+            ('<!DOCTYPE ', [('decl', 'DOCTYPE ')]),
+            ('<!DOCTYPE html', [('decl', 'DOCTYPE html')]),
+            ('<!DOCTYPE html ', [('decl', 'DOCTYPE html ')]),
+            ('<!DOCTYPE html PUBLIC', [('decl', 'DOCTYPE html PUBLIC')]),
+            ('<!DOCTYPE html PUBLIC "foo', [('decl', 'DOCTYPE html PUBLIC "foo')]),
+            ('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "foo',
+             [('decl', 'DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "foo')]),
+        ]
+        for html, expected in data:
+            self._run_check(html, expected)
+
+    @support.subTests('content', ['', 'x', 'x]', 'x]]'])
+    def test_eof_in_cdata(self, content):
+        self._run_check('<![CDATA[' + content,
+                        [('unknown decl', 'CDATA[' + content)])
+        self._run_check('<![CDATA[' + content,
+                        [('comment', '[CDATA[' + content)],
+                        collector=EventCollector(autocdata=True))
+        self._run_check('<svg><text y="100"><![CDATA[' + content,
+                        [('starttag', 'svg', []),
+                         ('starttag', 'text', [('y', '100')]),
+                         ('unknown decl', 'CDATA[' + content)])
+
+    def test_bogus_comments(self):
+        html = ('<!ELEMENT br EMPTY>'
+                '<! not really a comment >'
                 '<! not a comment either -->'
                 '<! -- close enough -->'
                 '<!><!<-- this was an empty comment>'
-                '<!!! another bogus comment !!!>')
+                '<!!! another bogus comment !!!>'
+                # see #32876
+                '<![with square brackets]!>'
+                '<![\nmultiline\nbogusness\n]!>'
+                '<![more brackets]-[and a hyphen]!>'
+                '<![cdata[should be uppercase]]>'
+                '<![CDATA [whitespaces are not ignored]]>'
+                '<![CDATA]]>'  # required '[' after CDATA
+        )
         expected = [
+            ('comment', 'ELEMENT br EMPTY'),
             ('comment', ' not really a comment '),
             ('comment', ' not a comment either --'),
             ('comment', ' -- close enough --'),
             ('comment', ''),
             ('comment', '<-- this was an empty comment'),
             ('comment', '!! another bogus comment !!!'),
+            ('comment', '[with square brackets]!'),
+            ('comment', '[\nmultiline\nbogusness\n]!'),
+            ('comment', '[more brackets]-[and a hyphen]!'),
+            ('comment', '[cdata[should be uppercase]]'),
+            ('comment', '[CDATA [whitespaces are not ignored]]'),
+            ('comment', '[CDATA]]'),
         ]
         self._run_check(html, expected)
 
     def test_broken_condcoms(self):
         # these condcoms are missing the '--' after '<!' and before the '>'
+        # and they are considered bogus comments according to
+        # "8.2.4.42. Markup declaration open state"
         html = ('<![if !(IE)]>broken condcom<![endif]>'
                 '<![if ! IE]><link href="favicon.tiff"/><![endif]>'
                 '<![if !IE 6]><img src="firefox.png" /><![endif]>'
                 '<![if !ie 6]><b>foo</b><![endif]>'
                 '<![if (!IE)|(lt IE 9)]><img src="mammoth.bmp" /><![endif]>')
-        # According to the HTML5 specs sections "8.2.4.44 Bogus comment state"
-        # and "8.2.4.45 Markup declaration open state", comment tokens should
-        # be emitted instead of 'unknown decl', but calling unknown_decl
-        # provides more flexibility.
-        # See also Lib/_markupbase.py:parse_declaration
         expected = [
-            ('unknown decl', 'if !(IE)'),
+            ('comment', '[if !(IE)]'),
             ('data', 'broken condcom'),
-            ('unknown decl', 'endif'),
-            ('unknown decl', 'if ! IE'),
+            ('comment', '[endif]'),
+            ('comment', '[if ! IE]'),
             ('startendtag', 'link', [('href', 'favicon.tiff')]),
-            ('unknown decl', 'endif'),
-            ('unknown decl', 'if !IE 6'),
+            ('comment', '[endif]'),
+            ('comment', '[if !IE 6]'),
             ('startendtag', 'img', [('src', 'firefox.png')]),
-            ('unknown decl', 'endif'),
-            ('unknown decl', 'if !ie 6'),
+            ('comment', '[endif]'),
+            ('comment', '[if !ie 6]'),
             ('starttag', 'b', []),
             ('data', 'foo'),
             ('endtag', 'b'),
-            ('unknown decl', 'endif'),
-            ('unknown decl', 'if (!IE)|(lt IE 9)'),
+            ('comment', '[endif]'),
+            ('comment', '[if (!IE)|(lt IE 9)]'),
             ('startendtag', 'img', [('src', 'mammoth.bmp')]),
-            ('unknown decl', 'endif')
+            ('comment', '[endif]')
         ]
         self._run_check(html, expected)
 
+    @support.subTests('content', [
+        'just some plain text',
+        '<!-- not a comment -->',
+        '&not-an-entity-ref;',
+        "<not a='start tag'>",
+        '',
+        '[[I have many brackets]]',
+        'I have a > in the middle',
+        'I have a ]] in the middle',
+        '] ]>',
+        ']] >',
+        ('\n'
+         '    if (a < b && a > b) {\n'
+         '        printf("[<marquee>How?</marquee>]");\n'
+         '    }\n'),
+    ])
+    def test_cdata_section_content(self, content):
+        # See "13.2.5.42 Markup declaration open state",
+        # "13.2.5.69 CDATA section state", and issue bpo-32876.
+        html = f'<svg><text y="100"><![CDATA[{content}]]></text></svg>'
+        expected = [
+            ('starttag', 'svg', []),
+            ('starttag', 'text', [('y', '100')]),
+            ('unknown decl', 'CDATA[' + content),
+            ('endtag', 'text'),
+            ('endtag', 'svg'),
+        ]
+        self._run_check(html, expected)
+        self._run_check(html, expected, collector=EventCollector(autocdata=True))
+
+    def test_cdata_section(self):
+        # See "13.2.5.42 Markup declaration open state".
+        html = ('<![CDATA[foo<br>bar]]>'
+                '<svg><text y="100"><![CDATA[foo<br>bar]]></text></svg>'
+                '<![CDATA[foo<br>bar]]>')
+        expected = [
+            ('comment', '[CDATA[foo<br'),
+            ('data', 'bar]]>'),
+            ('starttag', 'svg', []),
+            ('starttag', 'text', [('y', '100')]),
+            ('unknown decl', 'CDATA[foo<br>bar'),
+            ('endtag', 'text'),
+            ('endtag', 'svg'),
+            ('comment', '[CDATA[foo<br'),
+            ('data', 'bar]]>'),
+        ]
+        self._run_check(html, expected, collector=EventCollector(autocdata=True))
+
     def test_convert_charrefs_dropped_text(self):
         # #23144: make sure that all the events are triggered when
         # convert_charrefs is True, even if we don't call .close()
@@ -598,6 +920,26 @@ def test_convert_charrefs_dropped_text(self):
              ('endtag', 'a'), ('data', ' bar & baz')]
         )
 
+    @support.requires_resource('cpu')
+    def test_eof_no_quadratic_complexity(self):
+        # Each of these examples used to take about an hour.
+        # Now they take a fraction of a second.
+        def check(source):
+            parser = html.parser.HTMLParser()
+            parser.feed(source)
+            parser.close()
+        n = 120_000
+        check("<a " * n)
+        check("<a a=" * n)
+        check("</a " * 14 * n)
+        check("</a a=" * 11 * n)
+        check("<!--" * 4 * n)
+        check("<!" * 60 * n)
+        check("<?" * 19 * n)
+        check("</$" * 15 * n)
+        check("<![CDATA[" * 9 * n)
+        check("<!doctype" * 35 * n)
+
 
 class AttributesTestCase(TestCaseBase):
 
@@ -606,9 +948,15 @@ def test_attr_syntax(self):
           ("starttag", "a", [("b", "v"), ("c", "v"), ("d", "v"), ("e", None)])
         ]
         self._run_check("""<a b='v' c="v" d=v e>""", output)
-        self._run_check("""<a  b = 'v' c = "v" d = v e>""", output)
-        self._run_check("""<a\nb\n=\n'v'\nc\n=\n"v"\nd\n=\nv\ne>""", output)
-        self._run_check("""<a\tb\t=\t'v'\tc\t=\t"v"\td\t=\tv\te>""", output)
+        self._run_check("<a foo==bar>", [('starttag', 'a', [('foo', '=bar')])])
+        self._run_check("<a foo =bar>", [('starttag', 'a', [('foo', 'bar')])])
+        self._run_check("<a foo\t=bar>", [('starttag', 'a', [('foo', 'bar')])])
+        self._run_check("<a foo\v=bar>", [('starttag', 'a', [('foo\v', 'bar')])])
+        self._run_check("<a foo\xa0=bar>", [('starttag', 'a', [('foo\xa0', 'bar')])])
+        self._run_check("<a foo= bar>", [('starttag', 'a', [('foo', 'bar')])])
+        self._run_check("<a foo=\tbar>", [('starttag', 'a', [('foo', 'bar')])])
+        self._run_check("<a foo=\vbar>", [('starttag', 'a', [('foo', '\vbar')])])
+        self._run_check("<a foo=\xa0bar>", [('starttag', 'a', [('foo', '\xa0bar')])])
 
     def test_attr_values(self):
         self._run_check("""<a b='xxx\n\txxx' c="yyy\t\nyyy" d='\txyz\n'>""",
@@ -617,6 +965,10 @@ def test_attr_values(self):
                                             ("d", "\txyz\n")])])
         self._run_check("""<a b='' c="">""",
                         [("starttag", "a", [("b", ""), ("c", "")])])
+        self._run_check("<a b=\tx c=\ny>",
+                        [('starttag', 'a', [('b', 'x'), ('c', 'y')])])
+        self._run_check("<a b=\v c=\xa0>",
+                        [("starttag", "a", [("b", "\v"), ("c", "\xa0")])])
         # Regression test for SF patch #669683.
         self._run_check("<e a=rgb(1,2,3)>",
                         [("starttag", "e", [("a", "rgb(1,2,3)")])])
@@ -683,13 +1035,17 @@ def test_malformed_attributes(self):
         )
         expected = [
             ('starttag', 'a', [('href', "test'style='color:red;bad1'")]),
-            ('data', 'test - bad1'), ('endtag', 'a'),
+            ('data', 'test - bad1'),
+            ('endtag', 'a'),
             ('starttag', 'a', [('href', "test'+style='color:red;ba2'")]),
-            ('data', 'test - bad2'), ('endtag', 'a'),
+            ('data', 'test - bad2'),
+            ('endtag', 'a'),
             ('starttag', 'a', [('href', "test'\xa0style='color:red;bad3'")]),
-            ('data', 'test - bad3'), ('endtag', 'a'),
+            ('data', 'test - bad3'),
+            ('endtag', 'a'),
             ('starttag', 'a', [('href', "test'\xa0style='color:red;bad4'")]),
-            ('data', 'test - bad4'), ('endtag', 'a')
+            ('data', 'test - bad4'),
+            ('endtag', 'a'),
         ]
         self._run_check(html, expected)
 
@@ -787,5 +1143,17 @@ def test_weird_chars_in_unquoted_attribute_values(self):
                             ('starttag', 'form',
                                 [('action', 'bogus|&#()value')])])
 
+
+class TestInheritance(unittest.TestCase):
+
+    @patch("_markupbase.ParserBase.__init__")
+    @patch("_markupbase.ParserBase.reset")
+    def test_base_class_methods_called(self, super_reset_method, super_init_method):
+        with patch('_markupbase.ParserBase') as parser_base:
+            EventCollector()
+            super_init_method.assert_called_once()
+            super_reset_method.assert_called_once()
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py
index f4b9dc6a28..51fa4a3d41 100644
--- a/Lib/test/test_http_cookiejar.py
+++ b/Lib/test/test_http_cookiejar.py
@@ -1,14 +1,16 @@
 """Tests for http/cookiejar.py."""
 
 import os
+import stat
+import sys
 import re
-import test.support
+from test import support
 from test.support import os_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 import time
 import unittest
 import urllib.request
-import pathlib
 
 from http.cookiejar import (time2isoz, http2time, iso2time, time2netscape,
      parse_ns_headers, join_header_words, split_header_words, Cookie,
@@ -17,6 +19,7 @@
      reach, is_HDN, domain_match, user_domain_match, request_path,
      request_port, request_host)
 
+mswindows = (sys.platform == "win32")
 
 class DateTimeTests(unittest.TestCase):
 
@@ -104,8 +107,7 @@ def test_http2time_formats(self):
             self.assertEqual(http2time(s.lower()), test_t, s.lower())
             self.assertEqual(http2time(s.upper()), test_t, s.upper())
 
-    def test_http2time_garbage(self):
-        for test in [
+    @support.subTests('test', [
             '',
             'Garbage',
             'Mandag 16. September 1996',
@@ -120,12 +122,10 @@ def test_http2time_garbage(self):
             '08-01-3697739',
             '09 Feb 19942632 22:23:32 GMT',
             'Wed, 09 Feb 1994834 22:23:32 GMT',
-            ]:
-            self.assertIsNone(http2time(test),
-                              "http2time(%s) is not None\n"
-                              "http2time(test) %s" % (test, http2time(test)))
+        ])
+    def test_http2time_garbage(self, test):
+        self.assertIsNone(http2time(test))
 
-    @unittest.skip("TODO: RUSTPYTHON, regressed to cubic complexity")
     def test_http2time_redos_regression_actually_completes(self):
         # LOOSE_HTTP_DATE_RE was vulnerable to malicious input which caused catastrophic backtracking (REDoS).
         # If we regress to cubic complexity, this test will take a very long time to succeed.
@@ -149,9 +149,7 @@ def parse_date(text):
         self.assertEqual(parse_date("1994-02-03 19:45:29 +0530"),
                          (1994, 2, 3, 14, 15, 29))
 
-    def test_iso2time_formats(self):
-        # test iso2time for supported dates.
-        tests = [
+    @support.subTests('s', [
             '1994-02-03 00:00:00 -0000', # ISO 8601 format
             '1994-02-03 00:00:00 +0000', # ISO 8601 format
             '1994-02-03 00:00:00',       # zone is optional
@@ -164,16 +162,15 @@ def test_iso2time_formats(self):
             # A few tests with extra space at various places
             '  1994-02-03 ',
             '  1994-02-03T00:00:00  ',
-        ]
-
+        ])
+    def test_iso2time_formats(self, s):
+        # test iso2time for supported dates.
         test_t = 760233600  # assume broken POSIX counting of seconds
-        for s in tests:
-            self.assertEqual(iso2time(s), test_t, s)
-            self.assertEqual(iso2time(s.lower()), test_t, s.lower())
-            self.assertEqual(iso2time(s.upper()), test_t, s.upper())
+        self.assertEqual(iso2time(s), test_t, s)
+        self.assertEqual(iso2time(s.lower()), test_t, s.lower())
+        self.assertEqual(iso2time(s.upper()), test_t, s.upper())
 
-    def test_iso2time_garbage(self):
-        for test in [
+    @support.subTests('test', [
             '',
             'Garbage',
             'Thursday, 03-Feb-94 00:00:00 GMT',
@@ -186,11 +183,10 @@ def test_iso2time_garbage(self):
             '01-01-1980 00:00:62',
             '01-01-1980T00:00:62',
             '19800101T250000Z',
-            ]:
-            self.assertIsNone(iso2time(test),
-                              "iso2time(%r)" % test)
+        ])
+    def test_iso2time_garbage(self, test):
+        self.assertIsNone(iso2time(test))
 
-    @unittest.skip("TODO, RUSTPYTHON, regressed to quadratic complexity")
     def test_iso2time_performance_regression(self):
         # If ISO_DATE_RE regresses to quadratic complexity, this test will take a very long time to succeed.
         # If fixed, it should complete within a fraction of a second.
@@ -200,24 +196,23 @@ def test_iso2time_performance_regression(self):
 
 class HeaderTests(unittest.TestCase):
 
-    def test_parse_ns_headers(self):
-        # quotes should be stripped
-        expected = [[('foo', 'bar'), ('expires', 2209069412), ('version', '0')]]
-        for hdr in [
+    @support.subTests('hdr', [
             'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
             'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
-            ]:
-            self.assertEqual(parse_ns_headers([hdr]), expected)
-
-    def test_parse_ns_headers_version(self):
-
+        ])
+    def test_parse_ns_headers(self, hdr):
         # quotes should be stripped
-        expected = [[('foo', 'bar'), ('version', '1')]]
-        for hdr in [
+        expected = [[('foo', 'bar'), ('expires', 2209069412), ('version', '0')]]
+        self.assertEqual(parse_ns_headers([hdr]), expected)
+
+    @support.subTests('hdr', [
             'foo=bar; version="1"',
             'foo=bar; Version="1"',
-            ]:
-            self.assertEqual(parse_ns_headers([hdr]), expected)
+        ])
+    def test_parse_ns_headers_version(self, hdr):
+        # quotes should be stripped
+        expected = [[('foo', 'bar'), ('version', '1')]]
+        self.assertEqual(parse_ns_headers([hdr]), expected)
 
     def test_parse_ns_headers_special_names(self):
         # names such as 'expires' are not special in first name=value pair
@@ -233,8 +228,7 @@ def test_join_header_words(self):
 
         self.assertEqual(join_header_words([[]]), "")
 
-    def test_split_header_words(self):
-        tests = [
+    @support.subTests('arg,expect', [
             ("foo", [[("foo", None)]]),
             ("foo=bar", [[("foo", "bar")]]),
             ("   foo   ", [[("foo", None)]]),
@@ -251,24 +245,22 @@ def test_split_header_words(self):
             (r'foo; bar=baz, spam=, foo="\,\;\"", bar= ',
              [[("foo", None), ("bar", "baz")],
               [("spam", "")], [("foo", ',;"')], [("bar", "")]]),
-            ]
-
-        for arg, expect in tests:
-            try:
-                result = split_header_words([arg])
-            except:
-                import traceback, io
-                f = io.StringIO()
-                traceback.print_exc(None, f)
-                result = "(error -- traceback follows)\n\n%s" % f.getvalue()
-            self.assertEqual(result,  expect, """
+        ])
+    def test_split_header_words(self, arg, expect):
+        try:
+            result = split_header_words([arg])
+        except:
+            import traceback, io
+            f = io.StringIO()
+            traceback.print_exc(None, f)
+            result = "(error -- traceback follows)\n\n%s" % f.getvalue()
+        self.assertEqual(result,  expect, """
 When parsing: '%s'
 Expected:     '%s'
 Got:          '%s'
 """ % (arg, expect, result))
 
-    def test_roundtrip(self):
-        tests = [
+    @support.subTests('arg,expect', [
             ("foo", "foo"),
             ("foo=bar", "foo=bar"),
             ("   foo   ", "foo"),
@@ -277,23 +269,35 @@ def test_roundtrip(self):
             ("foo=bar;bar=baz", "foo=bar; bar=baz"),
             ('foo bar baz', "foo; bar; baz"),
             (r'foo="\"" bar="\\"', r'foo="\""; bar="\\"'),
+            ("föo=bär", 'föo="bär"'),
             ('foo,,,bar', 'foo, bar'),
             ('foo=bar,bar=baz', 'foo=bar, bar=baz'),
+            ("foo=\n", 'foo=""'),
+            ('foo="\n"', 'foo="\n"'),
+            ('foo=bar\n', 'foo=bar'),
+            ('foo="bar\n"', 'foo="bar\n"'),
+            ('foo=bar\nbaz', 'foo=bar; baz'),
+            ('foo="bar\nbaz"', 'foo="bar\nbaz"'),
 
             ('text/html; charset=iso-8859-1',
-             'text/html; charset="iso-8859-1"'),
+             'text/html; charset=iso-8859-1'),
+
+            ('text/html; charset="iso-8859/1"',
+             'text/html; charset="iso-8859/1"'),
 
             ('foo="bar"; port="80,81"; discard, bar=baz',
              'foo=bar; port="80,81"; discard, bar=baz'),
 
             (r'Basic realm="\"foo\\\\bar\""',
-             r'Basic; realm="\"foo\\\\bar\""')
-            ]
-
-        for arg, expect in tests:
-            input = split_header_words([arg])
-            res = join_header_words(input)
-            self.assertEqual(res, expect, """
+             r'Basic; realm="\"foo\\\\bar\""'),
+
+            ('n; foo="foo;_", bar="foo,_"',
+             'n; foo="foo;_", bar="foo,_"'),
+        ])
+    def test_roundtrip(self, arg, expect):
+        input = split_header_words([arg])
+        res = join_header_words(input)
+        self.assertEqual(res, expect, """
 When parsing: '%s'
 Expected:     '%s'
 Got:          '%s'
@@ -337,9 +341,9 @@ def test_constructor_with_str(self):
         self.assertEqual(c.filename, filename)
 
     def test_constructor_with_path_like(self):
-        filename = pathlib.Path(os_helper.TESTFN)
-        c = LWPCookieJar(filename)
-        self.assertEqual(c.filename, os.fspath(filename))
+        filename = os_helper.TESTFN
+        c = LWPCookieJar(os_helper.FakePath(filename))
+        self.assertEqual(c.filename, filename)
 
     def test_constructor_with_none(self):
         c = LWPCookieJar(None)
@@ -366,10 +370,63 @@ def test_lwp_valueless_cookie(self):
             c = LWPCookieJar()
             c.load(filename, ignore_discard=True)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
         self.assertEqual(c._cookies["www.acme.com"]["/"]["boo"].value, None)
 
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_lwp_filepermissions(self):
+        # Cookie file should only be readable by the creator
+        filename = os_helper.TESTFN
+        c = LWPCookieJar()
+        interact_netscape(c, "http://www.acme.com/", 'boo')
+        try:
+            c.save(filename, ignore_discard=True)
+            st = os.stat(filename)
+            self.assertEqual(stat.S_IMODE(st.st_mode), 0o600)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_mozilla_filepermissions(self):
+        # Cookie file should only be readable by the creator
+        filename = os_helper.TESTFN
+        c = MozillaCookieJar()
+        interact_netscape(c, "http://www.acme.com/", 'boo')
+        try:
+            c.save(filename, ignore_discard=True)
+            st = os.stat(filename)
+            self.assertEqual(stat.S_IMODE(st.st_mode), 0o600)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipIf(mswindows, "windows file permissions are incompatible with file modes")
+    @os_helper.skip_unless_working_chmod
+    def test_cookie_files_are_truncated(self):
+        filename = os_helper.TESTFN
+        for cookiejar_class in (LWPCookieJar, MozillaCookieJar):
+            c = cookiejar_class(filename)
+
+            req = urllib.request.Request("http://www.acme.com/")
+            headers = ["Set-Cookie: pll_lang=en; Max-Age=31536000; path=/"]
+            res = FakeResponse(headers, "http://www.acme.com/")
+            c.extract_cookies(res, req)
+            self.assertEqual(len(c), 1)
+
+            try:
+                # Save the first version with contents:
+                c.save()
+                # Now, clear cookies and re-save:
+                c.clear()
+                c.save()
+                # Check that file was truncated:
+                c.load()
+            finally:
+                os_helper.unlink(filename)
+
+            self.assertEqual(len(c), 0)
+
     def test_bad_magic(self):
         # OSErrors (eg. file doesn't exist) are allowed to propagate
         filename = os_helper.TESTFN
@@ -393,8 +450,7 @@ def test_bad_magic(self):
                     c = cookiejar_class()
                     self.assertRaises(LoadError, c.load, filename)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
 
 class CookieTests(unittest.TestCase):
     # XXX
@@ -443,14 +499,7 @@ class CookieTests(unittest.TestCase):
 ##   just the 7 special TLD's listed in their spec. And folks rely on
 ##   that...
 
-    def test_domain_return_ok(self):
-        # test optimization: .domain_return_ok() should filter out most
-        # domains in the CookieJar before we try to access them (because that
-        # may require disk access -- in particular, with MSIECookieJar)
-        # This is only a rough check for performance reasons, so it's not too
-        # critical as long as it's sufficiently liberal.
-        pol = DefaultCookiePolicy()
-        for url, domain, ok in [
+    @support.subTests('url,domain,ok', [
             ("http://foo.bar.com/", "blah.com", False),
             ("http://foo.bar.com/", "rhubarb.blah.com", False),
             ("http://foo.bar.com/", "rhubarb.foo.bar.com", False),
@@ -470,11 +519,18 @@ def test_domain_return_ok(self):
             ("http://foo/", ".local", True),
             ("http://barfoo.com", ".foo.com", False),
             ("http://barfoo.com", "foo.com", False),
-            ]:
-            request = urllib.request.Request(url)
-            r = pol.domain_return_ok(domain, request)
-            if ok: self.assertTrue(r)
-            else: self.assertFalse(r)
+        ])
+    def test_domain_return_ok(self, url, domain, ok):
+        # test optimization: .domain_return_ok() should filter out most
+        # domains in the CookieJar before we try to access them (because that
+        # may require disk access -- in particular, with MSIECookieJar)
+        # This is only a rough check for performance reasons, so it's not too
+        # critical as long as it's sufficiently liberal.
+        pol = DefaultCookiePolicy()
+        request = urllib.request.Request(url)
+        r = pol.domain_return_ok(domain, request)
+        if ok: self.assertTrue(r)
+        else: self.assertFalse(r)
 
     def test_missing_value(self):
         # missing = sign in Cookie: header is regarded by Mozilla as a missing
@@ -490,7 +546,7 @@ def test_missing_value(self):
         self.assertIsNone(cookie.value)
         self.assertEqual(cookie.name, '"spam"')
         self.assertEqual(lwp_cookie_str(cookie), (
-            r'"spam"; path="/foo/"; domain="www.acme.com"; '
+            r'"spam"; path="/foo/"; domain=www.acme.com; '
             'path_spec; discard; version=0'))
         old_str = repr(c)
         c.save(ignore_expires=True, ignore_discard=True)
@@ -498,7 +554,7 @@ def test_missing_value(self):
             c = MozillaCookieJar(filename)
             c.revert(ignore_expires=True, ignore_discard=True)
         finally:
-            os.unlink(c.filename)
+            os_helper.unlink(c.filename)
         # cookies unchanged apart from lost info re. whether path was specified
         self.assertEqual(
             repr(c),
@@ -508,10 +564,7 @@ def test_missing_value(self):
         self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"),
                          '"spam"; eggs')
 
-    def test_rfc2109_handling(self):
-        # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
-        # dependent on policy settings
-        for rfc2109_as_netscape, rfc2965, version in [
+    @support.subTests('rfc2109_as_netscape,rfc2965,version', [
             # default according to rfc2965 if not explicitly specified
             (None, False, 0),
             (None, True, 1),
@@ -520,24 +573,27 @@ def test_rfc2109_handling(self):
             (False, True, 1),
             (True, False, 0),
             (True, True, 0),
-            ]:
-            policy = DefaultCookiePolicy(
-                rfc2109_as_netscape=rfc2109_as_netscape,
-                rfc2965=rfc2965)
-            c = CookieJar(policy)
-            interact_netscape(c, "http://www.example.com/", "ni=ni; Version=1")
-            try:
-                cookie = c._cookies["www.example.com"]["/"]["ni"]
-            except KeyError:
-                self.assertIsNone(version)  # didn't expect a stored cookie
-            else:
-                self.assertEqual(cookie.version, version)
-                # 2965 cookies are unaffected
-                interact_2965(c, "http://www.example.com/",
-                              "foo=bar; Version=1")
-                if rfc2965:
-                    cookie2965 = c._cookies["www.example.com"]["/"]["foo"]
-                    self.assertEqual(cookie2965.version, 1)
+        ])
+    def test_rfc2109_handling(self, rfc2109_as_netscape, rfc2965, version):
+        # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
+        # dependent on policy settings
+        policy = DefaultCookiePolicy(
+            rfc2109_as_netscape=rfc2109_as_netscape,
+            rfc2965=rfc2965)
+        c = CookieJar(policy)
+        interact_netscape(c, "http://www.example.com/", "ni=ni; Version=1")
+        try:
+            cookie = c._cookies["www.example.com"]["/"]["ni"]
+        except KeyError:
+            self.assertIsNone(version)  # didn't expect a stored cookie
+        else:
+            self.assertEqual(cookie.version, version)
+            # 2965 cookies are unaffected
+            interact_2965(c, "http://www.example.com/",
+                            "foo=bar; Version=1")
+            if rfc2965:
+                cookie2965 = c._cookies["www.example.com"]["/"]["foo"]
+                self.assertEqual(cookie2965.version, 1)
 
     def test_ns_parser(self):
         c = CookieJar()
@@ -598,8 +654,6 @@ def test_ns_parser_special_names(self):
         self.assertIn('expires', cookies)
         self.assertIn('version', cookies)
 
-    # TODO: RUSTPYTHON; need to update http library to remove warnings
-    @unittest.expectedFailure
     def test_expires(self):
         # if expires is in future, keep cookie...
         c = CookieJar()
@@ -707,8 +761,7 @@ def test_default_path_with_query(self):
         # Cookie is sent back to the same URI.
         self.assertEqual(interact_netscape(cj, uri), value)
 
-    def test_escape_path(self):
-        cases = [
+    @support.subTests('arg,result', [
             # quoted safe
             ("/foo%2f/bar", "/foo%2F/bar"),
             ("/foo%2F/bar", "/foo%2F/bar"),
@@ -728,9 +781,9 @@ def test_escape_path(self):
             ("/foo/bar\u00fc", "/foo/bar%C3%BC"),     # UTF-8 encoded
             # unicode
             ("/foo/bar\uabcd", "/foo/bar%EA%AF%8D"),  # UTF-8 encoded
-            ]
-        for arg, result in cases:
-            self.assertEqual(escape_path(arg), result)
+        ])
+    def test_escape_path(self, arg, result):
+        self.assertEqual(escape_path(arg), result)
 
     def test_request_path(self):
         # with parameters
@@ -924,6 +977,48 @@ def test_two_component_domain_ns(self):
 ##         self.assertEqual(len(c), 2)
         self.assertEqual(len(c), 4)
 
+    def test_localhost_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=localhost;")
+
+        self.assertEqual(len(c), 1)
+
+    def test_localhost_domain_contents(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=localhost;")
+
+        self.assertEqual(c._cookies[".localhost"]["/"]["foo"].value, "bar")
+
+    def test_localhost_domain_contents_2(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar;")
+
+        self.assertEqual(c._cookies["localhost.local"]["/"]["foo"].value, "bar")
+
+    def test_evil_nonlocal_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://evil.com", "foo=bar; domain=.localhost")
+
+        self.assertEqual(len(c), 0)
+
+    def test_evil_local_domain(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=.evil.com")
+
+        self.assertEqual(len(c), 0)
+
+    def test_evil_local_domain_2(self):
+        c = CookieJar()
+
+        interact_netscape(c, "http://localhost", "foo=bar; domain=.someother.local")
+
+        self.assertEqual(len(c), 0)
+
     def test_two_component_domain_rfc2965(self):
         pol = DefaultCookiePolicy(rfc2965=True)
         c = CookieJar(pol)
@@ -1255,11 +1350,11 @@ def test_Cookie_iterator(self):
                       r'port="90,100, 80,8080"; '
                       r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
 
-        versions = [1, 1, 1, 0, 1]
-        names = ["bang", "foo", "foo", "spam", "foo"]
-        domains = [".sol.no", "blah.spam.org", "www.acme.com",
-                   "www.acme.com", "www.acme.com"]
-        paths = ["/", "/", "/", "/blah", "/blah/"]
+        versions = [1, 0, 1, 1, 1]
+        names = ["foo", "spam", "foo", "foo", "bang"]
+        domains = ["blah.spam.org", "www.acme.com", "www.acme.com",
+                   "www.acme.com", ".sol.no"]
+        paths = ["/", "/blah", "/blah/", "/", "/"]
 
         for i in range(4):
             i = 0
@@ -1332,7 +1427,7 @@ def cookiejar_from_cookie_headers(headers):
         self.assertIsNone(cookie.expires)
 
 
-class LWPCookieTests(unittest.TestCase):
+class LWPCookieTests(unittest.TestCase, ExtraAssertions):
     # Tests taken from libwww-perl, with a few modifications and additions.
 
     def test_netscape_example_1(self):
@@ -1424,7 +1519,7 @@ def test_netscape_example_1(self):
         h = req.get_header("Cookie")
         self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
         self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
-        self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
+        self.assertStartsWith(h, "SHIPPING=FEDEX;")
 
     def test_netscape_example_2(self):
         # Second Example transaction sequence:
@@ -1728,8 +1823,7 @@ def test_rejection(self):
             c = LWPCookieJar(policy=pol)
             c.load(filename, ignore_discard=True)
         finally:
-            try: os.unlink(filename)
-            except OSError: pass
+            os_helper.unlink(filename)
 
         self.assertEqual(old, repr(c))
 
@@ -1788,8 +1882,7 @@ def save_and_restore(cj, ignore_discard):
                                          DefaultCookiePolicy(rfc2965=True))
                 new_c.load(ignore_discard=ignore_discard)
             finally:
-                try: os.unlink(filename)
-                except OSError: pass
+                os_helper.unlink(filename)
             return new_c
 
         new_c = save_and_restore(c, True)
diff --git a/Lib/test/test_http_cookies.py b/Lib/test/test_http_cookies.py
index 6072c7e15e..3e0b4d1d5c 100644
--- a/Lib/test/test_http_cookies.py
+++ b/Lib/test/test_http_cookies.py
@@ -1,13 +1,15 @@
 # Simple test suite for http/cookies.py
 
 import copy
-from test.support import run_unittest, run_doctest
 import unittest
+import doctest
 from http import cookies
 import pickle
+from test import support
+from test.support.testcase import ExtraAssertions
 
 
-class CookieTests(unittest.TestCase):
+class CookieTests(unittest.TestCase, ExtraAssertions):
 
     def test_basic(self):
         cases = [
@@ -58,6 +60,90 @@ def test_basic(self):
             for k, v in sorted(case['dict'].items()):
                 self.assertEqual(C[k].value, v)
 
+    def test_obsolete_rfc850_date_format(self):
+        # Test cases with different days and dates in obsolete RFC 850 format
+        test_cases = [
+            # from RFC 850, change EST to GMT
+            # https://datatracker.ietf.org/doc/html/rfc850#section-2
+            {
+                'data': 'key=value; expires=Saturday, 01-Jan-83 00:00:00 GMT',
+                'output': 'Saturday, 01-Jan-83 00:00:00 GMT'
+            },
+            {
+                'data': 'key=value; expires=Friday, 19-Nov-82 16:59:30 GMT',
+                'output': 'Friday, 19-Nov-82 16:59:30 GMT'
+            },
+            # from RFC 9110
+            # https://www.rfc-editor.org/rfc/rfc9110.html#section-5.6.7-6
+            {
+                'data': 'key=value; expires=Sunday, 06-Nov-94 08:49:37 GMT',
+                'output': 'Sunday, 06-Nov-94 08:49:37 GMT'
+            },
+            # other test cases
+            {
+                'data': 'key=value; expires=Wednesday, 09-Nov-94 08:49:37 GMT',
+                'output': 'Wednesday, 09-Nov-94 08:49:37 GMT'
+            },
+            {
+                'data': 'key=value; expires=Friday, 11-Nov-94 08:49:37 GMT',
+                'output': 'Friday, 11-Nov-94 08:49:37 GMT'
+            },
+            {
+                'data': 'key=value; expires=Monday, 14-Nov-94 08:49:37 GMT',
+                'output': 'Monday, 14-Nov-94 08:49:37 GMT'
+            },
+        ]
+
+        for case in test_cases:
+            with self.subTest(data=case['data']):
+                C = cookies.SimpleCookie()
+                C.load(case['data'])
+
+                # Extract the cookie name from the data string
+                cookie_name = case['data'].split('=')[0]
+
+                # Check if the cookie is loaded correctly
+                self.assertIn(cookie_name, C)
+                self.assertEqual(C[cookie_name].get('expires'), case['output'])
+
+    def test_unquote(self):
+        cases = [
+            (r'a="b=\""', 'b="'),
+            (r'a="b=\\"', 'b=\\'),
+            (r'a="b=\="', 'b=='),
+            (r'a="b=\n"', 'b=n'),
+            (r'a="b=\042"', 'b="'),
+            (r'a="b=\134"', 'b=\\'),
+            (r'a="b=\377"', 'b=\xff'),
+            (r'a="b=\400"', 'b=400'),
+            (r'a="b=\42"', 'b=42'),
+            (r'a="b=\\042"', 'b=\\042'),
+            (r'a="b=\\134"', 'b=\\134'),
+            (r'a="b=\\\""', 'b=\\"'),
+            (r'a="b=\\\042"', 'b=\\"'),
+            (r'a="b=\134\""', 'b=\\"'),
+            (r'a="b=\134\042"', 'b=\\"'),
+        ]
+        for encoded, decoded in cases:
+            with self.subTest(encoded):
+                C = cookies.SimpleCookie()
+                C.load(encoded)
+                self.assertEqual(C['a'].value, decoded)
+
+    @support.requires_resource('cpu')
+    def test_unquote_large(self):
+        #n = 10**6
+        n = 10**4 # XXX: RUSTPYTHON; This takes more than 10 minutes to run. lower to 4
+        for encoded in r'\\', r'\134':
+            with self.subTest(encoded):
+                data = 'a="b=' + encoded*n + ';"'
+                C = cookies.SimpleCookie()
+                C.load(data)
+                value = C['a'].value
+                self.assertEqual(value[:3], 'b=\\')
+                self.assertEqual(value[-2:], '\\;')
+                self.assertEqual(len(value), n + 3)
+
     def test_load(self):
         C = cookies.SimpleCookie()
         C.load('Customer="WILE_E_COYOTE"; Version=1; Path=/acme')
@@ -96,7 +182,7 @@ def test_special_attrs(self):
         C = cookies.SimpleCookie('Customer="WILE_E_COYOTE"')
         C['Customer']['expires'] = 0
         # can't test exact output, it always depends on current date/time
-        self.assertTrue(C.output().endswith('GMT'))
+        self.assertEndsWith(C.output(), 'GMT')
 
         # loading 'expires'
         C = cookies.SimpleCookie()
@@ -479,9 +565,11 @@ def test_repr(self):
                 r'Set-Cookie: key=coded_val; '
                 r'expires=\w+, \d+ \w+ \d+ \d+:\d+:\d+ \w+')
 
-def test_main():
-    run_unittest(CookieTests, MorselTests)
-    run_doctest(cookies)
+
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite(cookies))
+    return tests
+
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py
index 5a59f372ad..275578d53c 100644
--- a/Lib/test/test_httplib.py
+++ b/Lib/test/test_httplib.py
@@ -1,4 +1,4 @@
-import sys
+import enum
 import errno
 from http import client, HTTPStatus
 import io
@@ -8,7 +8,6 @@
 import re
 import socket
 import threading
-import warnings
 
 import unittest
 from unittest import mock
@@ -17,16 +16,19 @@
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
-from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
+support.requires_working_socket(module=True)
 
 here = os.path.dirname(__file__)
 # Self-signed cert file for 'localhost'
-CERT_localhost = os.path.join(here, 'keycert.pem')
+CERT_localhost = os.path.join(here, 'certdata', 'keycert.pem')
 # Self-signed cert file for 'fakehostname'
-CERT_fakehostname = os.path.join(here, 'keycert2.pem')
+CERT_fakehostname = os.path.join(here, 'certdata', 'keycert2.pem')
 # Self-signed cert file for self-signed.pythontest.net
-CERT_selfsigned_pythontestdotnet = os.path.join(here, 'selfsigned_pythontestdotnet.pem')
+CERT_selfsigned_pythontestdotnet = os.path.join(
+    here, 'certdata', 'selfsigned_pythontestdotnet.pem',
+)
 
 # constants for testing chunked encoding
 chunked_start = (
@@ -133,7 +135,7 @@ def connect(self):
     def create_connection(self, *pos, **kw):
         return FakeSocket(*self.fake_socket_args)
 
-class HeaderTests(TestCase):
+class HeaderTests(TestCase, ExtraAssertions):
     def test_auto_headers(self):
         # Some headers are added automatically, but should not be added by
         # .request() if they are explicitly set.
@@ -272,7 +274,7 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertTrue(sock.data.startswith(expected))
+        self.assertStartsWith(sock.data, expected)
 
         expected = b'GET /foo HTTP/1.1\r\nHost: [2001:102A::]\r\n' \
                    b'Accept-Encoding: identity\r\n\r\n'
@@ -280,7 +282,23 @@ def test_ipv6host_header(self):
         sock = FakeSocket('')
         conn.sock = sock
         conn.request('GET', '/foo')
-        self.assertTrue(sock.data.startswith(expected))
+        self.assertStartsWith(sock.data, expected)
+
+        expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]\r\n' \
+                   b'Accept-Encoding: identity\r\n\r\n'
+        conn = client.HTTPConnection('[fe80::%2]')
+        sock = FakeSocket('')
+        conn.sock = sock
+        conn.request('GET', '/foo')
+        self.assertStartsWith(sock.data, expected)
+
+        expected = b'GET /foo HTTP/1.1\r\nHost: [fe80::]:81\r\n' \
+                   b'Accept-Encoding: identity\r\n\r\n'
+        conn = client.HTTPConnection('[fe80::%2]:81')
+        sock = FakeSocket('')
+        conn.sock = sock
+        conn.request('GET', '/foo')
+        self.assertStartsWith(sock.data, expected)
 
     def test_malformed_headers_coped_with(self):
         # Issue 19996
@@ -318,9 +336,9 @@ def test_parse_all_octets(self):
         self.assertIsNotNone(resp.getheader('obs-text'))
         self.assertIn('obs-text', resp.msg)
         for folded in (resp.getheader('obs-fold'), resp.msg['obs-fold']):
-            self.assertTrue(folded.startswith('text'))
+            self.assertStartsWith(folded, 'text')
             self.assertIn(' folded with space', folded)
-            self.assertTrue(folded.endswith('folded with tab'))
+            self.assertEndsWith(folded, 'folded with tab')
 
     def test_invalid_headers(self):
         conn = client.HTTPConnection('example.com')
@@ -520,11 +538,203 @@ def _parse_chunked(self, data):
         return b''.join(body)
 
 
-class BasicTest(TestCase):
+class BasicTest(TestCase, ExtraAssertions):
     def test_dir_with_added_behavior_on_status(self):
         # see issue40084
         self.assertTrue({'description', 'name', 'phrase', 'value'} <= set(dir(HTTPStatus(404))))
 
+    def test_simple_httpstatus(self):
+        class CheckedHTTPStatus(enum.IntEnum):
+            """HTTP status codes and reason phrases
+
+            Status codes from the following RFCs are all observed:
+
+                * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
+                * RFC 6585: Additional HTTP Status Codes
+                * RFC 3229: Delta encoding in HTTP
+                * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
+                * RFC 5842: Binding Extensions to WebDAV
+                * RFC 7238: Permanent Redirect
+                * RFC 2295: Transparent Content Negotiation in HTTP
+                * RFC 2774: An HTTP Extension Framework
+                * RFC 7725: An HTTP Status Code to Report Legal Obstacles
+                * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
+                * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
+                * RFC 8297: An HTTP Status Code for Indicating Hints
+                * RFC 8470: Using Early Data in HTTP
+            """
+            def __new__(cls, value, phrase, description=''):
+                obj = int.__new__(cls, value)
+                obj._value_ = value
+
+                obj.phrase = phrase
+                obj.description = description
+                return obj
+
+            @property
+            def is_informational(self):
+                return 100 <= self <= 199
+
+            @property
+            def is_success(self):
+                return 200 <= self <= 299
+
+            @property
+            def is_redirection(self):
+                return 300 <= self <= 399
+
+            @property
+            def is_client_error(self):
+                return 400 <= self <= 499
+
+            @property
+            def is_server_error(self):
+                return 500 <= self <= 599
+
+            # informational
+            CONTINUE = 100, 'Continue', 'Request received, please continue'
+            SWITCHING_PROTOCOLS = (101, 'Switching Protocols',
+                    'Switching to new protocol; obey Upgrade header')
+            PROCESSING = 102, 'Processing'
+            EARLY_HINTS = 103, 'Early Hints'
+            # success
+            OK = 200, 'OK', 'Request fulfilled, document follows'
+            CREATED = 201, 'Created', 'Document created, URL follows'
+            ACCEPTED = (202, 'Accepted',
+                'Request accepted, processing continues off-line')
+            NON_AUTHORITATIVE_INFORMATION = (203,
+                'Non-Authoritative Information', 'Request fulfilled from cache')
+            NO_CONTENT = 204, 'No Content', 'Request fulfilled, nothing follows'
+            RESET_CONTENT = 205, 'Reset Content', 'Clear input form for further input'
+            PARTIAL_CONTENT = 206, 'Partial Content', 'Partial content follows'
+            MULTI_STATUS = 207, 'Multi-Status'
+            ALREADY_REPORTED = 208, 'Already Reported'
+            IM_USED = 226, 'IM Used'
+            # redirection
+            MULTIPLE_CHOICES = (300, 'Multiple Choices',
+                'Object has several resources -- see URI list')
+            MOVED_PERMANENTLY = (301, 'Moved Permanently',
+                'Object moved permanently -- see URI list')
+            FOUND = 302, 'Found', 'Object moved temporarily -- see URI list'
+            SEE_OTHER = 303, 'See Other', 'Object moved -- see Method and URL list'
+            NOT_MODIFIED = (304, 'Not Modified',
+                'Document has not changed since given time')
+            USE_PROXY = (305, 'Use Proxy',
+                'You must use proxy specified in Location to access this resource')
+            TEMPORARY_REDIRECT = (307, 'Temporary Redirect',
+                'Object moved temporarily -- see URI list')
+            PERMANENT_REDIRECT = (308, 'Permanent Redirect',
+                'Object moved permanently -- see URI list')
+            # client error
+            BAD_REQUEST = (400, 'Bad Request',
+                'Bad request syntax or unsupported method')
+            UNAUTHORIZED = (401, 'Unauthorized',
+                'No permission -- see authorization schemes')
+            PAYMENT_REQUIRED = (402, 'Payment Required',
+                'No payment -- see charging schemes')
+            FORBIDDEN = (403, 'Forbidden',
+                'Request forbidden -- authorization will not help')
+            NOT_FOUND = (404, 'Not Found',
+                'Nothing matches the given URI')
+            METHOD_NOT_ALLOWED = (405, 'Method Not Allowed',
+                'Specified method is invalid for this resource')
+            NOT_ACCEPTABLE = (406, 'Not Acceptable',
+                'URI not available in preferred format')
+            PROXY_AUTHENTICATION_REQUIRED = (407,
+                'Proxy Authentication Required',
+                'You must authenticate with this proxy before proceeding')
+            REQUEST_TIMEOUT = (408, 'Request Timeout',
+                'Request timed out; try again later')
+            CONFLICT = 409, 'Conflict', 'Request conflict'
+            GONE = (410, 'Gone',
+                'URI no longer exists and has been permanently removed')
+            LENGTH_REQUIRED = (411, 'Length Required',
+                'Client must specify Content-Length')
+            PRECONDITION_FAILED = (412, 'Precondition Failed',
+                'Precondition in headers is false')
+            CONTENT_TOO_LARGE = (413, 'Content Too Large',
+                'Content is too large')
+            REQUEST_ENTITY_TOO_LARGE = CONTENT_TOO_LARGE
+            URI_TOO_LONG = (414, 'URI Too Long', 'URI is too long')
+            REQUEST_URI_TOO_LONG = URI_TOO_LONG
+            UNSUPPORTED_MEDIA_TYPE = (415, 'Unsupported Media Type',
+                'Entity body in unsupported format')
+            RANGE_NOT_SATISFIABLE = (416,
+                'Range Not Satisfiable',
+                'Cannot satisfy request range')
+            REQUESTED_RANGE_NOT_SATISFIABLE = RANGE_NOT_SATISFIABLE
+            EXPECTATION_FAILED = (417, 'Expectation Failed',
+                'Expect condition could not be satisfied')
+            IM_A_TEAPOT = (418, 'I\'m a Teapot',
+                'Server refuses to brew coffee because it is a teapot.')
+            MISDIRECTED_REQUEST = (421, 'Misdirected Request',
+                'Server is not able to produce a response')
+            UNPROCESSABLE_CONTENT = 422, 'Unprocessable Content'
+            UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
+            LOCKED = 423, 'Locked'
+            FAILED_DEPENDENCY = 424, 'Failed Dependency'
+            TOO_EARLY = 425, 'Too Early'
+            UPGRADE_REQUIRED = 426, 'Upgrade Required'
+            PRECONDITION_REQUIRED = (428, 'Precondition Required',
+                'The origin server requires the request to be conditional')
+            TOO_MANY_REQUESTS = (429, 'Too Many Requests',
+                'The user has sent too many requests in '
+                'a given amount of time ("rate limiting")')
+            REQUEST_HEADER_FIELDS_TOO_LARGE = (431,
+                'Request Header Fields Too Large',
+                'The server is unwilling to process the request because its header '
+                'fields are too large')
+            UNAVAILABLE_FOR_LEGAL_REASONS = (451,
+                'Unavailable For Legal Reasons',
+                'The server is denying access to the '
+                'resource as a consequence of a legal demand')
+            # server errors
+            INTERNAL_SERVER_ERROR = (500, 'Internal Server Error',
+                'Server got itself in trouble')
+            NOT_IMPLEMENTED = (501, 'Not Implemented',
+                'Server does not support this operation')
+            BAD_GATEWAY = (502, 'Bad Gateway',
+                'Invalid responses from another server/proxy')
+            SERVICE_UNAVAILABLE = (503, 'Service Unavailable',
+                'The server cannot process the request due to a high load')
+            GATEWAY_TIMEOUT = (504, 'Gateway Timeout',
+                'The gateway server did not receive a timely response')
+            HTTP_VERSION_NOT_SUPPORTED = (505, 'HTTP Version Not Supported',
+                'Cannot fulfill request')
+            VARIANT_ALSO_NEGOTIATES = 506, 'Variant Also Negotiates'
+            INSUFFICIENT_STORAGE = 507, 'Insufficient Storage'
+            LOOP_DETECTED = 508, 'Loop Detected'
+            NOT_EXTENDED = 510, 'Not Extended'
+            NETWORK_AUTHENTICATION_REQUIRED = (511,
+                'Network Authentication Required',
+                'The client needs to authenticate to gain network access')
+        enum._test_simple_enum(CheckedHTTPStatus, HTTPStatus)
+
+    def test_httpstatus_range(self):
+        """Checks that the statuses are in the 100-599 range"""
+
+        for member in HTTPStatus.__members__.values():
+            self.assertGreaterEqual(member, 100)
+            self.assertLessEqual(member, 599)
+
+    def test_httpstatus_category(self):
+        """Checks that the statuses belong to the standard categories"""
+
+        categories = (
+            ((100, 199), "is_informational"),
+            ((200, 299), "is_success"),
+            ((300, 399), "is_redirection"),
+            ((400, 499), "is_client_error"),
+            ((500, 599), "is_server_error"),
+        )
+        for member in HTTPStatus.__members__.values():
+            for (lower, upper), category in categories:
+                category_indicator = getattr(member, category)
+                if lower <= member <= upper:
+                    self.assertTrue(category_indicator)
+                else:
+                    self.assertFalse(category_indicator)
+
     def test_status_lines(self):
         # Test HTTP status lines
 
@@ -780,8 +990,7 @@ def test_send_file(self):
             sock = FakeSocket(body)
             conn.sock = sock
             conn.request('GET', '/foo', body)
-            self.assertTrue(sock.data.startswith(expected), '%r != %r' %
-                    (sock.data[:len(expected)], expected))
+            self.assertStartsWith(sock.data, expected)
 
     def test_send(self):
         expected = b'this is a test this is only a test'
@@ -872,6 +1081,25 @@ def test_chunked(self):
         self.assertEqual(resp.read(), expected)
         resp.close()
 
+        # Explicit full read
+        for n in (-123, -1, None):
+            with self.subTest('full read', n=n):
+                sock = FakeSocket(chunked_start + last_chunk + chunked_end)
+                resp = client.HTTPResponse(sock, method="GET")
+                resp.begin()
+                self.assertTrue(resp.chunked)
+                self.assertEqual(resp.read(n), expected)
+                resp.close()
+
+        # Read first chunk
+        with self.subTest('read1(-1)'):
+            sock = FakeSocket(chunked_start + last_chunk + chunked_end)
+            resp = client.HTTPResponse(sock, method="GET")
+            resp.begin()
+            self.assertTrue(resp.chunked)
+            self.assertEqual(resp.read1(-1), b"hello worl")
+            resp.close()
+
         # Various read sizes
         for n in range(1, 12):
             sock = FakeSocket(chunked_start + last_chunk + chunked_end)
@@ -1227,6 +1455,72 @@ def run_server():
         thread.join()
         self.assertEqual(result, b"proxied data\n")
 
+    def test_large_content_length(self):
+        serv = socket.create_server((HOST, 0))
+        self.addCleanup(serv.close)
+
+        def run_server():
+            [conn, address] = serv.accept()
+            with conn:
+                while conn.recv(1024):
+                    conn.sendall(
+                        b"HTTP/1.1 200 Ok\r\n"
+                        b"Content-Length: %d\r\n"
+                        b"\r\n" % size)
+                    conn.sendall(b'A' * (size//3))
+                    conn.sendall(b'B' * (size - size//3))
+
+        thread = threading.Thread(target=run_server)
+        thread.start()
+        self.addCleanup(thread.join, 1.0)
+
+        conn = client.HTTPConnection(*serv.getsockname())
+        try:
+            for w in range(15, 27):
+                size = 1 << w
+                conn.request("GET", "/")
+                with conn.getresponse() as response:
+                    self.assertEqual(len(response.read()), size)
+        finally:
+            conn.close()
+            thread.join(1.0)
+
+    def test_large_content_length_truncated(self):
+        serv = socket.create_server((HOST, 0))
+        self.addCleanup(serv.close)
+
+        def run_server():
+            while True:
+                [conn, address] = serv.accept()
+                with conn:
+                    conn.recv(1024)
+                    if not size:
+                        break
+                    conn.sendall(
+                        b"HTTP/1.1 200 Ok\r\n"
+                        b"Content-Length: %d\r\n"
+                        b"\r\n"
+                        b"Text" % size)
+
+        thread = threading.Thread(target=run_server)
+        thread.start()
+        self.addCleanup(thread.join, 1.0)
+
+        conn = client.HTTPConnection(*serv.getsockname())
+        try:
+            for w in range(18, 65):
+                size = 1 << w
+                conn.request("GET", "/")
+                with conn.getresponse() as response:
+                    self.assertRaises(client.IncompleteRead, response.read)
+                conn.close()
+        finally:
+            conn.close()
+            size = 0
+            conn.request("GET", "/")
+            conn.close()
+            thread.join(1.0)
+
     def test_putrequest_override_domain_validation(self):
         """
         It should be possible to override the default validation
@@ -1266,7 +1560,7 @@ def _encode_request(self, str_url):
         conn.putrequest('GET', '/☃')
 
 
-class ExtendedReadTest(TestCase):
+class ExtendedReadTest(TestCase, ExtraAssertions):
     """
     Test peek(), read1(), readline()
     """
@@ -1325,7 +1619,7 @@ def mypeek(n=-1):
                 # then unbounded peek
                 p2 = resp.peek()
                 self.assertGreaterEqual(len(p2), len(p))
-                self.assertTrue(p2.startswith(p))
+                self.assertStartsWith(p2, p)
                 next = resp.read(len(p2))
                 self.assertEqual(next, p2)
             else:
@@ -1340,18 +1634,22 @@ def test_readline(self):
         resp = self.resp
         self._verify_readline(self.resp.readline, self.lines_expected)
 
-    def _verify_readline(self, readline, expected):
+    def test_readline_without_limit(self):
+        self._verify_readline(self.resp.readline, self.lines_expected, limit=-1)
+
+    def _verify_readline(self, readline, expected, limit=5):
         all = []
         while True:
             # short readlines
-            line = readline(5)
+            line = readline(limit)
             if line and line != b"foo":
                 if len(line) < 5:
-                    self.assertTrue(line.endswith(b"\n"))
+                    self.assertEndsWith(line, b"\n")
             all.append(line)
             if not line:
                 break
         self.assertEqual(b"".join(all), expected)
+        self.assertTrue(self.resp.isclosed())
 
     def test_read1(self):
         resp = self.resp
@@ -1371,6 +1669,7 @@ def test_read1_unbounded(self):
                 break
             all.append(data)
         self.assertEqual(b"".join(all), self.lines_expected)
+        self.assertTrue(resp.isclosed())
 
     def test_read1_bounded(self):
         resp = self.resp
@@ -1382,15 +1681,22 @@ def test_read1_bounded(self):
             self.assertLessEqual(len(data), 10)
             all.append(data)
         self.assertEqual(b"".join(all), self.lines_expected)
+        self.assertTrue(resp.isclosed())
 
     def test_read1_0(self):
         self.assertEqual(self.resp.read1(0), b"")
+        self.assertFalse(self.resp.isclosed())
 
     def test_peek_0(self):
         p = self.resp.peek(0)
         self.assertLessEqual(0, len(p))
 
 
+class ExtendedReadTestContentLengthKnown(ExtendedReadTest):
+    _header, _body = ExtendedReadTest.lines.split('\r\n\r\n', 1)
+    lines = _header + f'\r\nContent-Length: {len(_body)}\r\n\r\n' + _body
+
+
 class ExtendedReadTestChunked(ExtendedReadTest):
     """
     Test peek(), read1(), readline() in chunked mode
@@ -1447,7 +1753,7 @@ def readline(self, limit):
             raise
 
 
-class OfflineTest(TestCase):
+class OfflineTest(TestCase, ExtraAssertions):
     def test_all(self):
         # Documented objects defined in the module should be in __all__
         expected = {"responses"}  # Allowlist documented dict() object
@@ -1500,13 +1806,17 @@ def test_client_constants(self):
             'GONE',
             'LENGTH_REQUIRED',
             'PRECONDITION_FAILED',
+            'CONTENT_TOO_LARGE',
             'REQUEST_ENTITY_TOO_LARGE',
+            'URI_TOO_LONG',
             'REQUEST_URI_TOO_LONG',
             'UNSUPPORTED_MEDIA_TYPE',
+            'RANGE_NOT_SATISFIABLE',
             'REQUESTED_RANGE_NOT_SATISFIABLE',
             'EXPECTATION_FAILED',
             'IM_A_TEAPOT',
             'MISDIRECTED_REQUEST',
+            'UNPROCESSABLE_CONTENT',
             'UNPROCESSABLE_ENTITY',
             'LOCKED',
             'FAILED_DEPENDENCY',
@@ -1529,7 +1839,7 @@ def test_client_constants(self):
         ]
         for const in expected:
             with self.subTest(constant=const):
-                self.assertTrue(hasattr(client, const))
+                self.assertHasAttr(client, const)
 
 
 class SourceAddressTest(TestCase):
@@ -1733,8 +2043,6 @@ def test_networked_trusted_by_default_cert(self):
             h.close()
             self.assertIn('text/html', content_type)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_networked_good_cert(self):
         # We feed the server's cert as a validating cert
         import ssl
@@ -1768,6 +2076,7 @@ def test_networked_good_cert(self):
             h.close()
             self.assertIn('nginx', server_string)
 
+    @support.requires_resource('walltime')
     def test_networked_bad_cert(self):
         # We feed a "CA" cert that is unrelated to the server's cert
         import ssl
@@ -1780,9 +2089,6 @@ def test_networked_bad_cert(self):
                 h.request('GET', '/')
             self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(sys.platform == 'darwin', 'Occasionally success on macOS')
     def test_local_unknown_cert(self):
         # The custom cert isn't known to the default trust bundle
         import ssl
@@ -1792,8 +2098,9 @@ def test_local_unknown_cert(self):
             h.request('GET', '/')
         self.assertEqual(exc_info.exception.reason, 'CERTIFICATE_VERIFY_FAILED')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON http.client.RemoteDisconnected: Remote end closed connection without response
     def test_local_good_hostname(self):
-        # The (valid) cert validates the HTTP hostname
+        # The (valid) cert validates the HTTPS hostname
         import ssl
         server = self.make_server(CERT_localhost)
         context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
@@ -1805,10 +2112,9 @@ def test_local_good_hostname(self):
         self.addCleanup(resp.close)
         self.assertEqual(resp.status, 404)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON http.client.RemoteDisconnected: Remote end closed connection without response
     def test_local_bad_hostname(self):
-        # The (valid) cert doesn't validate the HTTP hostname
+        # The (valid) cert doesn't validate the HTTPS hostname
         import ssl
         server = self.make_server(CERT_fakehostname)
         context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
@@ -1816,38 +2122,21 @@ def test_local_bad_hostname(self):
         h = client.HTTPSConnection('localhost', server.port, context=context)
         with self.assertRaises(ssl.CertificateError):
             h.request('GET', '/')
-        # Same with explicit check_hostname=True
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=True)
+
+        # Same with explicit context.check_hostname=True
+        context.check_hostname = True
+        h = client.HTTPSConnection('localhost', server.port, context=context)
         with self.assertRaises(ssl.CertificateError):
             h.request('GET', '/')
-        # With check_hostname=False, the mismatching is ignored
-        context.check_hostname = False
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=False)
-        h.request('GET', '/nonexistent')
-        resp = h.getresponse()
-        resp.close()
-        h.close()
-        self.assertEqual(resp.status, 404)
-        # The context's check_hostname setting is used if one isn't passed to
-        # HTTPSConnection.
+
+        # With context.check_hostname=False, the mismatching is ignored
         context.check_hostname = False
         h = client.HTTPSConnection('localhost', server.port, context=context)
         h.request('GET', '/nonexistent')
         resp = h.getresponse()
-        self.assertEqual(resp.status, 404)
         resp.close()
         h.close()
-        # Passing check_hostname to HTTPSConnection should override the
-        # context's setting.
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            h = client.HTTPSConnection('localhost', server.port,
-                                       context=context, check_hostname=True)
-        with self.assertRaises(ssl.CertificateError):
-            h.request('GET', '/')
+        self.assertEqual(resp.status, 404)
 
     @unittest.skipIf(not hasattr(client, 'HTTPSConnection'),
                      'http.client.HTTPSConnection not available')
@@ -1883,11 +2172,9 @@ def test_tls13_pha(self):
         self.assertIs(h._context, context)
         self.assertFalse(h._context.post_handshake_auth)
 
-        with warnings.catch_warnings():
-            warnings.filterwarnings('ignore', 'key_file, cert_file and check_hostname are deprecated',
-                                    DeprecationWarning)
-            h = client.HTTPSConnection('localhost', 443, context=context,
-                                       cert_file=CERT_localhost)
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT, cert_file=CERT_localhost)
+        context.post_handshake_auth = True
+        h = client.HTTPSConnection('localhost', 443, context=context)
         self.assertTrue(h._context.post_handshake_auth)
 
 
@@ -2022,14 +2309,15 @@ def test_getting_header_defaultint(self):
         header = self.resp.getheader('No-Such-Header',default=42)
         self.assertEqual(header, 42)
 
-class TunnelTests(TestCase):
+class TunnelTests(TestCase, ExtraAssertions):
     def setUp(self):
         response_text = (
-            'HTTP/1.0 200 OK\r\n\r\n' # Reply to CONNECT
+            'HTTP/1.1 200 OK\r\n\r\n' # Reply to CONNECT
             'HTTP/1.1 200 OK\r\n' # Reply to HEAD
             'Content-Length: 42\r\n\r\n'
         )
         self.host = 'proxy.com'
+        self.port = client.HTTP_PORT
         self.conn = client.HTTPConnection(self.host)
         self.conn._create_connection = self._create_connection(response_text)
 
@@ -2041,15 +2329,45 @@ def create_connection(address, timeout=None, source_address=None):
             return FakeSocket(response_text, host=address[0], port=address[1])
         return create_connection
 
-    def test_set_tunnel_host_port_headers(self):
+    def test_set_tunnel_host_port_headers_add_host_missing(self):
         tunnel_host = 'destination.com'
         tunnel_port = 8888
         tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)'}
+        tunnel_headers_after = tunnel_headers.copy()
+        tunnel_headers_after['Host'] = '%s:%d' % (tunnel_host, tunnel_port)
         self.conn.set_tunnel(tunnel_host, port=tunnel_port,
                              headers=tunnel_headers)
         self.conn.request('HEAD', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
-        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertEqual(self.conn._tunnel_host, tunnel_host)
+        self.assertEqual(self.conn._tunnel_port, tunnel_port)
+        self.assertEqual(self.conn._tunnel_headers, tunnel_headers_after)
+
+    def test_set_tunnel_host_port_headers_set_host_identical(self):
+        tunnel_host = 'destination.com'
+        tunnel_port = 8888
+        tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)',
+                          'Host': '%s:%d' % (tunnel_host, tunnel_port)}
+        self.conn.set_tunnel(tunnel_host, port=tunnel_port,
+                             headers=tunnel_headers)
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertEqual(self.conn._tunnel_host, tunnel_host)
+        self.assertEqual(self.conn._tunnel_port, tunnel_port)
+        self.assertEqual(self.conn._tunnel_headers, tunnel_headers)
+
+    def test_set_tunnel_host_port_headers_set_host_different(self):
+        tunnel_host = 'destination.com'
+        tunnel_port = 8888
+        tunnel_headers = {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11)',
+                          'Host': '%s:%d' % ('example.com', 4200)}
+        self.conn.set_tunnel(tunnel_host, port=tunnel_port,
+                             headers=tunnel_headers)
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
         self.assertEqual(self.conn._tunnel_host, tunnel_host)
         self.assertEqual(self.conn._tunnel_port, tunnel_port)
         self.assertEqual(self.conn._tunnel_headers, tunnel_headers)
@@ -2061,17 +2379,96 @@ def test_disallow_set_tunnel_after_connect(self):
                           'destination.com')
 
     def test_connect_with_tunnel(self):
-        self.conn.set_tunnel('destination.com')
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_with_default_port(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'), port=d[b'port'])
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_with_nonstandard_port(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': 8888,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'), port=d[b'port'])
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s:%(port)d\r\n' % d,
+                      self.conn.sock.data)
+
+    # This request is not RFC-valid, but it's been possible with the library
+    # for years, so don't break it unexpectedly... This also tests
+    # case-insensitivity when injecting Host: headers if they're missing.
+    def test_connect_with_tunnel_with_different_host_header(self):
+        d = {
+            b'host': b'destination.com',
+            b'tunnel_host_header': b'example.com:9876',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(
+            d[b'host'].decode('ascii'),
+            headers={'HOST': d[b'tunnel_host_header'].decode('ascii')})
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'HOST: %(tunnel_host_header)s\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_different_host(self):
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('HEAD', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'HEAD / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_with_tunnel_idna(self):
+        dest = '\u03b4\u03c0\u03b8.gr'
+        dest_port = b'%s:%d' % (dest.encode('idna'), client.HTTP_PORT)
+        expected = b'CONNECT %s HTTP/1.1\r\nHost: %s\r\n\r\n' % (
+            dest_port, dest_port)
+        self.conn.set_tunnel(dest)
         self.conn.request('HEAD', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
         self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
-        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
-        # issue22095
-        self.assertNotIn(b'Host: destination.com:None', self.conn.sock.data)
-        self.assertIn(b'Host: destination.com', self.conn.sock.data)
-
-        # This test should be removed when CONNECT gets the HTTP/1.1 blessing
-        self.assertNotIn(b'Host: proxy.com', self.conn.sock.data)
+        self.assertIn(expected, self.conn.sock.data)
 
     def test_tunnel_connect_single_send_connection_setup(self):
         """Regresstion test for https://bugs.python.org/issue43332."""
@@ -2086,17 +2483,39 @@ def test_tunnel_connect_single_send_connection_setup(self):
                 msg=f'unexpected number of send calls: {mock_send.mock_calls}')
         proxy_setup_data_sent = mock_send.mock_calls[0][1][0]
         self.assertIn(b'CONNECT destination.com', proxy_setup_data_sent)
-        self.assertTrue(
-                proxy_setup_data_sent.endswith(b'\r\n\r\n'),
+        self.assertEndsWith(proxy_setup_data_sent, b'\r\n\r\n',
                 msg=f'unexpected proxy data sent {proxy_setup_data_sent!r}')
 
     def test_connect_put_request(self):
-        self.conn.set_tunnel('destination.com')
+        d = {
+            b'host': b'destination.com',
+            b'port': client.HTTP_PORT,
+        }
+        self.conn.set_tunnel(d[b'host'].decode('ascii'))
+        self.conn.request('PUT', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, self.port)
+        self.assertIn(b'CONNECT %(host)s:%(port)d HTTP/1.1\r\n'
+                      b'Host: %(host)s:%(port)d\r\n\r\n' % d,
+                      self.conn.sock.data)
+        self.assertIn(b'PUT / HTTP/1.1\r\nHost: %(host)s\r\n' % d,
+                      self.conn.sock.data)
+
+    def test_connect_put_request_ipv6(self):
+        self.conn.set_tunnel('[1:2:3::4]', 1234)
+        self.conn.request('PUT', '/', '')
+        self.assertEqual(self.conn.sock.host, self.host)
+        self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
+        self.assertIn(b'CONNECT [1:2:3::4]:1234', self.conn.sock.data)
+        self.assertIn(b'Host: [1:2:3::4]:1234', self.conn.sock.data)
+
+    def test_connect_put_request_ipv6_port(self):
+        self.conn.set_tunnel('[1:2:3::4]:1234')
         self.conn.request('PUT', '/', '')
         self.assertEqual(self.conn.sock.host, self.host)
         self.assertEqual(self.conn.sock.port, client.HTTP_PORT)
-        self.assertIn(b'CONNECT destination.com', self.conn.sock.data)
-        self.assertIn(b'Host: destination.com', self.conn.sock.data)
+        self.assertIn(b'CONNECT [1:2:3::4]:1234', self.conn.sock.data)
+        self.assertIn(b'Host: [1:2:3::4]:1234', self.conn.sock.data)
 
     def test_tunnel_debuglog(self):
         expected_header = 'X-Dummy: 1'
@@ -2111,6 +2530,56 @@ def test_tunnel_debuglog(self):
         lines = output.getvalue().splitlines()
         self.assertIn('header: {}'.format(expected_header), lines)
 
+    def test_proxy_response_headers(self):
+        expected_header = ('X-Dummy', '1')
+        response_text = (
+            'HTTP/1.0 200 OK\r\n'
+            '{0}\r\n\r\n'.format(':'.join(expected_header))
+        )
+
+        self.conn._create_connection = self._create_connection(response_text)
+        self.conn.set_tunnel('destination.com')
+
+        self.conn.request('PUT', '/', '')
+        headers = self.conn.get_proxy_response_headers()
+        self.assertIn(expected_header, headers.items())
+
+    def test_no_proxy_response_headers(self):
+        expected_header = ('X-Dummy', '1')
+        response_text = (
+            'HTTP/1.0 200 OK\r\n'
+            '{0}\r\n\r\n'.format(':'.join(expected_header))
+        )
+
+        self.conn._create_connection = self._create_connection(response_text)
+
+        self.conn.request('PUT', '/', '')
+        headers = self.conn.get_proxy_response_headers()
+        self.assertIsNone(headers)
+
+    def test_tunnel_leak(self):
+        sock = None
+
+        def _create_connection(address, timeout=None, source_address=None):
+            nonlocal sock
+            sock = FakeSocket(
+                'HTTP/1.1 404 NOT FOUND\r\n\r\n',
+                host=address[0],
+                port=address[1],
+            )
+            return sock
+
+        self.conn._create_connection = _create_connection
+        self.conn.set_tunnel('destination.com')
+        exc = None
+        try:
+            self.conn.request('HEAD', '/', '')
+        except OSError as e:
+            # keeping a reference to exc keeps response alive in the traceback
+            exc = e
+        self.assertIsNotNone(exc)
+        self.assertTrue(sock.file_closed)
+
 
 if __name__ == '__main__':
     unittest.main(verbosity=2)
diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py
index cd689492ca..63b778d8b9 100644
--- a/Lib/test/test_httpservers.py
+++ b/Lib/test/test_httpservers.py
@@ -8,6 +8,7 @@
      SimpleHTTPRequestHandler, CGIHTTPRequestHandler
 from http import server, HTTPStatus
 
+import contextlib
 import os
 import socket
 import sys
@@ -26,13 +27,16 @@
 import datetime
 import threading
 from unittest import mock
-from io import BytesIO
+from io import BytesIO, StringIO
 
 import unittest
 from test import support
-from test.support import os_helper
-from test.support import threading_helper
+from test.support import (
+    is_apple, os_helper, requires_subprocess, threading_helper
+)
+from test.support.testcase import ExtraAssertions
 
+support.requires_working_socket(module=True)
 
 class NoLogRequestHandler:
     def log_message(self, *args):
@@ -64,7 +68,7 @@ def stop(self):
         self.join()
 
 
-class BaseTestCase(unittest.TestCase):
+class BaseTestCase(unittest.TestCase, ExtraAssertions):
     def setUp(self):
         self._threads = threading_helper.threading_setup()
         os.environ = os_helper.EnvironmentVarGuard()
@@ -163,6 +167,27 @@ def test_version_digits(self):
         res = self.con.getresponse()
         self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
 
+    def test_version_signs_and_underscores(self):
+        self.con._http_vsn_str = 'HTTP/-9_9_9.+9_9_9'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
+    def test_major_version_number_too_long(self):
+        self.con._http_vsn_str = 'HTTP/909876543210.0'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
+    def test_minor_version_number_too_long(self):
+        self.con._http_vsn_str = 'HTTP/1.909876543210'
+        self.con.putrequest('GET', '/')
+        self.con.endheaders()
+        res = self.con.getresponse()
+        self.assertEqual(res.status, HTTPStatus.BAD_REQUEST)
+
     def test_version_none_get(self):
         self.con._http_vsn_str = ''
         self.con.putrequest('GET', '/')
@@ -292,6 +317,44 @@ def test_head_via_send_error(self):
             self.assertEqual(b'', data)
 
 
+class HTTP09ServerTestCase(BaseTestCase):
+
+    class request_handler(NoLogRequestHandler, BaseHTTPRequestHandler):
+        """Request handler for HTTP/0.9 server."""
+
+        def do_GET(self):
+            self.wfile.write(f'OK: here is {self.path}\r\n'.encode())
+
+    def setUp(self):
+        super().setUp()
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock = self.enterContext(self.sock)
+        self.sock.connect((self.HOST, self.PORT))
+
+    def test_simple_get(self):
+        self.sock.send(b'GET /index.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertEqual(res, b"OK: here is /index.html\r\n")
+
+    def test_invalid_request(self):
+        self.sock.send(b'POST /index.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertIn(b"Bad HTTP/0.9 request type ('POST')", res)
+
+    def test_single_request(self):
+        self.sock.send(b'GET /foo.html\r\n')
+        res = self.sock.recv(1024)
+        self.assertEqual(res, b"OK: here is /foo.html\r\n")
+
+        # Ignore errors if the connection is already closed,
+        # as this is the expected behavior of HTTP/0.9.
+        with contextlib.suppress(OSError):
+            self.sock.send(b'GET /bar.html\r\n')
+            res = self.sock.recv(1024)
+            # The server should not process our request.
+            self.assertEqual(res, b'')
+
+
 class RequestHandlerLoggingTestCase(BaseTestCase):
     class request_handler(BaseHTTPRequestHandler):
         protocol_version = 'HTTP/1.1'
@@ -312,8 +375,7 @@ def test_get(self):
             self.con.request('GET', '/')
             self.con.getresponse()
 
-        self.assertTrue(
-            err.getvalue().endswith('"GET / HTTP/1.1" 200 -\n'))
+        self.assertEndsWith(err.getvalue(), '"GET / HTTP/1.1" 200 -\n')
 
     def test_err(self):
         self.con = http.client.HTTPConnection(self.HOST, self.PORT)
@@ -324,8 +386,8 @@ def test_err(self):
             self.con.getresponse()
 
         lines = err.getvalue().split('\n')
-        self.assertTrue(lines[0].endswith('code 404, message File not found'))
-        self.assertTrue(lines[1].endswith('"ERROR / HTTP/1.1" 404 -'))
+        self.assertEndsWith(lines[0], 'code 404, message File not found')
+        self.assertEndsWith(lines[1], '"ERROR / HTTP/1.1" 404 -')
 
 
 class SimpleHTTPServerTestCase(BaseTestCase):
@@ -333,7 +395,7 @@ class request_handler(NoLogRequestHandler, SimpleHTTPRequestHandler):
         pass
 
     def setUp(self):
-        BaseTestCase.setUp(self)
+        super().setUp()
         self.cwd = os.getcwd()
         basetempdir = tempfile.gettempdir()
         os.chdir(basetempdir)
@@ -361,7 +423,7 @@ def tearDown(self):
             except:
                 pass
         finally:
-            BaseTestCase.tearDown(self)
+            super().tearDown()
 
     def check_status_and_reason(self, response, status, data=None):
         def close_conn():
@@ -388,35 +450,175 @@ def close_conn():
         reader.close()
         return body
 
-    @unittest.skipIf(sys.platform == 'darwin',
-                     'undecodable name cannot always be decoded on macOS')
-    @unittest.skipIf(sys.platform == 'win32',
-                     'undecodable name cannot be decoded on win32')
-    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
-                         'need os_helper.TESTFN_UNDECODABLE')
-    def test_undecodable_filename(self):
+    def check_list_dir_dirname(self, dirname, quotedname=None):
+        fullpath = os.path.join(self.tempdir, dirname)
+        try:
+            os.mkdir(os.path.join(self.tempdir, dirname))
+        except (OSError, UnicodeEncodeError):
+            self.skipTest(f'Can not create directory {dirname!a} '
+                          f'on current file system')
+
+        if quotedname is None:
+            quotedname = urllib.parse.quote(dirname, errors='surrogatepass')
+        response = self.request(self.base_url + '/' + quotedname + '/')
+        body = self.check_status_and_reason(response, HTTPStatus.OK)
+        displaypath = html.escape(f'{self.base_url}/{dirname}/', quote=False)
         enc = sys.getfilesystemencoding()
-        filename = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.txt'
-        with open(os.path.join(self.tempdir, filename), 'wb') as f:
-            f.write(os_helper.TESTFN_UNDECODABLE)
+        prefix = f'listing for {displaypath}</'.encode(enc, 'surrogateescape')
+        self.assertIn(prefix + b'title>', body)
+        self.assertIn(prefix + b'h1>', body)
+
+    def check_list_dir_filename(self, filename):
+        fullpath = os.path.join(self.tempdir, filename)
+        content = ascii(fullpath).encode() + (os_helper.TESTFN_UNDECODABLE or b'\xff')
+        try:
+            with open(fullpath, 'wb') as f:
+                f.write(content)
+        except OSError:
+            self.skipTest(f'Can not create file {filename!a} '
+                          f'on current file system')
+
         response = self.request(self.base_url + '/')
-        if sys.platform == 'darwin':
-            # On Mac OS the HFS+ filesystem replaces bytes that aren't valid
-            # UTF-8 into a percent-encoded value.
-            for name in os.listdir(self.tempdir):
-                if name != 'test': # Ignore a filename created in setUp().
-                    filename = name
-                    break
         body = self.check_status_and_reason(response, HTTPStatus.OK)
         quotedname = urllib.parse.quote(filename, errors='surrogatepass')
-        self.assertIn(('href="%s"' % quotedname)
-                      .encode(enc, 'surrogateescape'), body)
-        self.assertIn(('>%s<' % html.escape(filename, quote=False))
-                      .encode(enc, 'surrogateescape'), body)
+        enc = response.headers.get_content_charset()
+        self.assertIsNotNone(enc)
+        self.assertIn((f'href="{quotedname}"').encode('ascii'), body)
+        displayname = html.escape(filename, quote=False)
+        self.assertIn(f'>{displayname}<'.encode(enc, 'surrogateescape'), body)
+
         response = self.request(self.base_url + '/' + quotedname)
-        self.check_status_and_reason(response, HTTPStatus.OK,
-                                     data=os_helper.TESTFN_UNDECODABLE)
+        self.check_status_and_reason(response, HTTPStatus.OK, data=content)
+
+    @unittest.skipUnless(os_helper.TESTFN_NONASCII,
+                         'need os_helper.TESTFN_NONASCII')
+    def test_list_dir_nonascii_dirname(self):
+        dirname = os_helper.TESTFN_NONASCII + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipUnless(os_helper.TESTFN_NONASCII,
+                         'need os_helper.TESTFN_NONASCII')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_nonascii_filename(self):
+        filename = os_helper.TESTFN_NONASCII + '.txt'
+        self.check_list_dir_filename(filename)
+
+    @unittest.skipIf(is_apple,
+                     'undecodable name cannot always be decoded on Apple platforms')
+    @unittest.skipIf(sys.platform == 'win32',
+                     'undecodable name cannot be decoded on win32')
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
+    def test_list_dir_undecodable_dirname(self):
+        dirname = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipIf(is_apple,
+                     'undecodable name cannot always be decoded on Apple platforms')
+    @unittest.skipIf(sys.platform == 'win32',
+                     'undecodable name cannot be decoded on win32')
+    @unittest.skipUnless(os_helper.TESTFN_UNDECODABLE,
+                         'need os_helper.TESTFN_UNDECODABLE')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_undecodable_filename(self):
+        filename = os.fsdecode(os_helper.TESTFN_UNDECODABLE) + '.txt'
+        self.check_list_dir_filename(filename)
+
+    def test_list_dir_undecodable_dirname2(self):
+        dirname = '\ufffd.dir'
+        self.check_list_dir_dirname(dirname, quotedname='%ff.dir')
+
+    @unittest.skipUnless(os_helper.TESTFN_UNENCODABLE,
+                         'need os_helper.TESTFN_UNENCODABLE')
+    def test_list_dir_unencodable_dirname(self):
+        dirname = os_helper.TESTFN_UNENCODABLE + '.dir'
+        self.check_list_dir_dirname(dirname)
+
+    @unittest.skipUnless(os_helper.TESTFN_UNENCODABLE,
+                         'need os_helper.TESTFN_UNENCODABLE')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_unencodable_filename(self):
+        filename = os_helper.TESTFN_UNENCODABLE + '.txt'
+        self.check_list_dir_filename(filename)
+
+    def test_list_dir_escape_dirname(self):
+        # Characters that need special treating in URL or HTML.
+        for name in ('q?', 'f#', '&amp;', '&amp', '<i>', '"dq"', "'sq'",
+                     '%A4', '%E2%82%AC'):
+            with self.subTest(name=name):
+                dirname = name + '.dir'
+                self.check_list_dir_dirname(dirname,
+                        quotedname=urllib.parse.quote(dirname, safe='&<>\'"'))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
+    def test_list_dir_escape_filename(self):
+        # Characters that need special treating in URL or HTML.
+        for name in ('q?', 'f#', '&amp;', '&amp', '<i>', '"dq"', "'sq'",
+                     '%A4', '%E2%82%AC'):
+            with self.subTest(name=name):
+                filename = name + '.txt'
+                self.check_list_dir_filename(filename)
+                os_helper.unlink(os.path.join(self.tempdir, filename))
+
+    def test_list_dir_with_query_and_fragment(self):
+        prefix = f'listing for {self.base_url}/</'.encode('latin1')
+        response = self.request(self.base_url + '/#123').read()
+        self.assertIn(prefix + b'title>', response)
+        self.assertIn(prefix + b'h1>', response)
+        response = self.request(self.base_url + '/?x=123').read()
+        self.assertIn(prefix + b'title>', response)
+        self.assertIn(prefix + b'h1>', response)
+
+    def test_get_dir_redirect_location_domain_injection_bug(self):
+        """Ensure //evil.co/..%2f../../X does not put //evil.co/ in Location.
+
+        //netloc/ in a Location header is a redirect to a new host.
+        https://github.com/python/cpython/issues/87389
+
+        This checks that a path resolving to a directory on our server cannot
+        resolve into a redirect to another server.
+        """
+        os.mkdir(os.path.join(self.tempdir, 'existing_directory'))
+        url = f'/python.org/..%2f..%2f..%2f..%2f..%2f../%0a%0d/../{self.tempdir_name}/existing_directory'
+        expected_location = f'{url}/'  # /python.org.../ single slash single prefix, trailing slash
+        # Canonicalizes to /tmp/tempdir_name/existing_directory which does
+        # exist and is a dir, triggering the 301 redirect logic.
+        response = self.request(url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        self.assertEqual(location, expected_location, msg='non-attack failed!')
 
+        # //python.org... multi-slash prefix, no trailing slash
+        attack_url = f'/{url}'
+        response = self.request(attack_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        self.assertNotStartsWith(location, '//')
+        self.assertEqual(location, expected_location,
+                msg='Expected Location header to start with a single / and '
+                'end with a / as this is a directory redirect.')
+
+        # ///python.org... triple-slash prefix, no trailing slash
+        attack3_url = f'//{url}'
+        response = self.request(attack3_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader('Location'), expected_location)
+
+        # If the second word in the http request (Request-URI for the http
+        # method) is a full URI, we don't worry about it, as that'll be parsed
+        # and reassembled as a full URI within BaseHTTPRequestHandler.send_head
+        # so no errant scheme-less //netloc//evil.co/ domain mixup can happen.
+        attack_scheme_netloc_2slash_url = f'https://pypi.org/{url}'
+        expected_scheme_netloc_location = f'{attack_scheme_netloc_2slash_url}/'
+        response = self.request(attack_scheme_netloc_2slash_url)
+        self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        location = response.getheader('Location')
+        # We're just ensuring that the scheme and domain make it through, if
+        # there are or aren't multiple slashes at the start of the path that
+        # follows that isn't important in this Location: header.
+        self.assertStartsWith(location, 'https://pypi.org/')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get(self):
         #constructs the path relative to the root directory of the HTTPServer
         response = self.request(self.base_url + '/test')
@@ -424,10 +626,19 @@ def test_get(self):
         # check for trailing "/" which should return 404. See Issue17324
         response = self.request(self.base_url + '/test/')
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        response = self.request(self.base_url + '/test%2f')
+        self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        response = self.request(self.base_url + '/test%2F')
+        self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
         response = self.request(self.base_url + '/')
         self.check_status_and_reason(response, HTTPStatus.OK)
+        response = self.request(self.base_url + '%2f')
+        self.check_status_and_reason(response, HTTPStatus.OK)
+        response = self.request(self.base_url + '%2F')
+        self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.base_url)
         self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader("Location"), self.base_url + "/")
         self.assertEqual(response.getheader("Content-Length"), "0")
         response = self.request(self.base_url + '/?hi=2')
         self.check_status_and_reason(response, HTTPStatus.OK)
@@ -439,6 +650,9 @@ def test_get(self):
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
         response = self.request('/' + 'ThisDoesNotExist' + '/')
         self.check_status_and_reason(response, HTTPStatus.NOT_FOUND)
+        os.makedirs(os.path.join(self.tempdir, 'spam', 'index.html'))
+        response = self.request(self.base_url + '/spam/')
+        self.check_status_and_reason(response, HTTPStatus.OK)
 
         data = b"Dummy index file\r\n"
         with open(os.path.join(self.tempdir_name, 'index.html'), 'wb') as f:
@@ -456,6 +670,7 @@ def test_get(self):
             finally:
                 os.chmod(self.tempdir, 0o755)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_head(self):
         response = self.request(
             self.base_url + '/test', method='HEAD')
@@ -465,6 +680,7 @@ def test_head(self):
         self.assertEqual(response.getheader('content-type'),
                          'application/octet-stream')
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache(self):
         """Check that when a request to /test is sent with the request header
         If-Modified-Since set to date of last modification, the server returns
@@ -483,6 +699,7 @@ def test_browser_cache(self):
         response = self.request(self.base_url + '/test', headers=headers)
         self.check_status_and_reason(response, HTTPStatus.NOT_MODIFIED)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache_file_changed(self):
         # with If-Modified-Since earlier than Last-Modified, must return 200
         dt = self.last_modif_datetime
@@ -494,6 +711,7 @@ def test_browser_cache_file_changed(self):
         response = self.request(self.base_url + '/test', headers=headers)
         self.check_status_and_reason(response, HTTPStatus.OK)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_browser_cache_with_If_None_Match_header(self):
         # if If-None-Match header is present, ignore If-Modified-Since
 
@@ -512,6 +730,7 @@ def test_invalid_requests(self):
         response = self.request('/', method='GETs')
         self.check_status_and_reason(response, HTTPStatus.NOT_IMPLEMENTED)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_last_modified(self):
         """Checks that the datetime returned in Last-Modified response header
         is the actual datetime of last modification, rounded to the second
@@ -521,6 +740,7 @@ def test_last_modified(self):
         last_modif_header = response.headers['Last-modified']
         self.assertEqual(last_modif_header, self.last_modif_header)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; http.client.RemoteDisconnected: Remote end closed connection without response
     def test_path_without_leading_slash(self):
         response = self.request(self.tempdir_name + '/test')
         self.check_status_and_reason(response, HTTPStatus.OK, data=self.data)
@@ -530,6 +750,8 @@ def test_path_without_leading_slash(self):
         self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.tempdir_name)
         self.check_status_and_reason(response, HTTPStatus.MOVED_PERMANENTLY)
+        self.assertEqual(response.getheader("Location"),
+                         self.tempdir_name + "/")
         response = self.request(self.tempdir_name + '/?hi=2')
         self.check_status_and_reason(response, HTTPStatus.OK)
         response = self.request(self.tempdir_name + '?hi=1')
@@ -537,27 +759,6 @@ def test_path_without_leading_slash(self):
         self.assertEqual(response.getheader("Location"),
                          self.tempdir_name + "/?hi=1")
 
-    def test_html_escape_filename(self):
-        filename = '<test&>.txt'
-        fullpath = os.path.join(self.tempdir, filename)
-
-        try:
-            open(fullpath, 'wb').close()
-        except OSError:
-            raise unittest.SkipTest('Can not create file %s on current file '
-                                    'system' % filename)
-
-        try:
-            response = self.request(self.base_url + '/')
-            body = self.check_status_and_reason(response, HTTPStatus.OK)
-            enc = response.headers.get_content_charset()
-        finally:
-            os.unlink(fullpath)  # avoid affecting test_undecodable_filename
-
-        self.assertIsNotNone(enc)
-        html_text = '>%s<' % html.escape(filename, quote=False)
-        self.assertIn(html_text.encode(enc), body)
-
 
 cgi_file1 = """\
 #!%s
@@ -569,14 +770,19 @@ def test_html_escape_filename(self):
 
 cgi_file2 = """\
 #!%s
-import cgi
+import os
+import sys
+import urllib.parse
 
 print("Content-type: text/html")
 print()
 
-form = cgi.FieldStorage()
-print("%%s, %%s, %%s" %% (form.getfirst("spam"), form.getfirst("eggs"),
-                          form.getfirst("bacon")))
+content_length = int(os.environ["CONTENT_LENGTH"])
+query_string = sys.stdin.buffer.read(content_length)
+params = {key.decode("utf-8"): val.decode("utf-8")
+            for key, val in urllib.parse.parse_qsl(query_string)}
+
+print("%%s, %%s, %%s" %% (params["spam"], params["eggs"], params["bacon"]))
 """
 
 cgi_file4 = """\
@@ -607,17 +813,40 @@ def test_html_escape_filename(self):
 print("</pre>")
 """
 
-@unittest.skipIf(not hasattr(os, '_exit'),
-        "TODO: RUSTPYTHON, run_cgi in http/server.py gets stuck as os._exit(127) doesn't currently kill forked processes")
+cgi_file7 = """\
+#!%s
+import os
+import sys
+
+print("Content-type: text/plain")
+print()
+
+content_length = int(os.environ["CONTENT_LENGTH"])
+body = sys.stdin.buffer.read(content_length)
+
+print(f"{content_length} {len(body)}")
+"""
+
+
 @unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0,
         "This test can't be run reliably as root (issue #13308).")
+@requires_subprocess()
 class CGIHTTPServerTestCase(BaseTestCase):
     class request_handler(NoLogRequestHandler, CGIHTTPRequestHandler):
-        pass
+        _test_case_self = None  # populated by each setUp() method call.
+
+        def __init__(self, *args, **kwargs):
+            with self._test_case_self.assertWarnsRegex(
+                    DeprecationWarning,
+                    r'http\.server\.CGIHTTPRequestHandler'):
+                # This context also happens to catch and silence the
+                # threading DeprecationWarning from os.fork().
+                super().__init__(*args, **kwargs)
 
     linesep = os.linesep.encode('ascii')
 
     def setUp(self):
+        self.request_handler._test_case_self = self  # practical, but yuck.
         BaseTestCase.setUp(self)
         self.cwd = os.getcwd()
         self.parent_dir = tempfile.mkdtemp()
@@ -637,12 +866,13 @@ def setUp(self):
         self.file3_path = None
         self.file4_path = None
         self.file5_path = None
+        self.file6_path = None
+        self.file7_path = None
 
         # The shebang line should be pure ASCII: use symlink if possible.
         # See issue #7668.
         self._pythonexe_symlink = None
-        # TODO: RUSTPYTHON; dl_nt not supported yet
-        if os_helper.can_symlink() and sys.platform != 'win32':
+        if os_helper.can_symlink():
             self.pythonexe = os.path.join(self.parent_dir, 'python')
             self._pythonexe_symlink = support.PythonSymlink(self.pythonexe).__enter__()
         else:
@@ -692,9 +922,15 @@ def setUp(self):
             file6.write(cgi_file6 % self.pythonexe)
         os.chmod(self.file6_path, 0o777)
 
+        self.file7_path = os.path.join(self.cgi_dir, 'file7.py')
+        with open(self.file7_path, 'w', encoding='utf-8') as file7:
+            file7.write(cgi_file7 % self.pythonexe)
+        os.chmod(self.file7_path, 0o777)
+
         os.chdir(self.parent_dir)
 
     def tearDown(self):
+        self.request_handler._test_case_self = None
         try:
             os.chdir(self.cwd)
             if self._pythonexe_symlink:
@@ -713,11 +949,16 @@ def tearDown(self):
                 os.remove(self.file5_path)
             if self.file6_path:
                 os.remove(self.file6_path)
+            if self.file7_path:
+                os.remove(self.file7_path)
             os.rmdir(self.cgi_child_dir)
             os.rmdir(self.cgi_dir)
             os.rmdir(self.cgi_dir_in_sub_dir)
             os.rmdir(self.sub_dir_2)
             os.rmdir(self.sub_dir_1)
+            # The 'gmon.out' file can be written in the current working
+            # directory if C-level code profiling with gprof is enabled.
+            os_helper.unlink(os.path.join(self.parent_dir, 'gmon.out'))
             os.rmdir(self.parent_dir)
         finally:
             BaseTestCase.tearDown(self)
@@ -764,8 +1005,7 @@ def test_url_collapse_path(self):
                                  msg='path = %r\nGot:    %r\nWanted: %r' %
                                  (path, actual, expected))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"", None, 200) != (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>)')
     def test_headers_and_content(self):
         res = self.request('/cgi-bin/file1.py')
         self.assertEqual(
@@ -776,9 +1016,7 @@ def test_issue19435(self):
         res = self.request('///////////nocgi.py/../cgi-bin/nothere.sh')
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
-    @unittest.expectedFailure
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; b"" != b"1, python, 123456\n"')
     def test_post(self):
         params = urllib.parse.urlencode(
             {'spam' : 1, 'eggs' : 'python', 'bacon' : 123456})
@@ -787,13 +1025,30 @@ def test_post(self):
 
         self.assertEqual(res.read(), b'1, python, 123456' + self.linesep)
 
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"" != b"32768 32768\n"')
+    def test_large_content_length(self):
+        for w in range(15, 25):
+            size = 1 << w
+            body = b'X' * size
+            headers = {'Content-Length' : str(size)}
+            res = self.request('/cgi-bin/file7.py', 'POST', body, headers)
+            self.assertEqual(res.read(), b'%d %d' % (size, size) + self.linesep)
+
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"" != b"Hello World\n"')
+    def test_large_content_length_truncated(self):
+        with support.swap_attr(self.request_handler, 'timeout', 0.001):
+            for w in range(18, 65):
+                size = 1 << w
+                headers = {'Content-Length' : str(size)}
+                res = self.request('/cgi-bin/file1.py', 'POST', b'x', headers)
+                self.assertEqual(res.read(), b'Hello World' + self.linesep)
+
     def test_invaliduri(self):
         res = self.request('/cgi-bin/invalid')
         res.read()
         self.assertEqual(res.status, HTTPStatus.NOT_FOUND)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_authorization(self):
         headers = {b'Authorization' : b'Basic ' +
                    base64.b64encode(b'username:pass')}
@@ -802,8 +1057,7 @@ def test_authorization(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_no_leading_slash(self):
         # http://bugs.python.org/issue2254
         res = self.request('cgi-bin/file1.py')
@@ -811,8 +1065,7 @@ def test_no_leading_slash(self):
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_os_environ_is_not_altered(self):
         signature = "Test CGI Server"
         os.environ['SERVER_SOFTWARE'] = signature
@@ -822,32 +1075,28 @@ def test_os_environ_is_not_altered(self):
             (res.read(), res.getheader('Content-type'), res.status))
         self.assertEqual(os.environ['SERVER_SOFTWARE'], signature)
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_urlquote_decoding_in_cgi_check(self):
         res = self.request('/cgi-bin%2ffile1.py')
         self.assertEqual(
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_nested_cgi_path_issue21323(self):
         res = self.request('/cgi-bin/child-dir/file3.py')
         self.assertEqual(
             (b'Hello World' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; ValueError: signal only works in main thread')
     def test_query_with_multiple_question_mark(self):
         res = self.request('/cgi-bin/file4.py?a=b?c=d')
         self.assertEqual(
             (b'a=b?c=d' + self.linesep, 'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: Tuples differ: (b"k=aa%2F%2Fbb&//q//p//=//a//b//\n", "text/html", <HTTPStatus.OK: 200>) != (b"", None, 200)')
     def test_query_with_continuous_slashes(self):
         res = self.request('/cgi-bin/file4.py?k=aa%2F%2Fbb&//q//p//=//a//b//')
         self.assertEqual(
@@ -855,8 +1104,7 @@ def test_query_with_continuous_slashes(self):
              'text/html', HTTPStatus.OK),
             (res.read(), res.getheader('Content-type'), res.status))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; Tuples differ: (b"", None, 200) != (b"Hello World\n", "text/html", <HTTPStatus.OK: 200>)')
     def test_cgi_path_in_sub_directories(self):
         try:
             CGIHTTPRequestHandler.cgi_directories.append('/sub/dir/cgi-bin')
@@ -867,8 +1115,7 @@ def test_cgi_path_in_sub_directories(self):
         finally:
             CGIHTTPRequestHandler.cgi_directories.remove('/sub/dir/cgi-bin')
 
-    # TODO: RUSTPYTHON
-    @unittest.skipIf(sys.platform != 'win32', "TODO: RUSTPYTHON; works only on windows")
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON; AssertionError: b"HTTP_ACCEPT=text/html,text/plain" not found in b""')
     def test_accept(self):
         browser_accept = \
                     'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'
@@ -929,7 +1176,7 @@ def numWrites(self):
         return len(self.datas)
 
 
-class BaseHTTPRequestHandlerTestCase(unittest.TestCase):
+class BaseHTTPRequestHandlerTestCase(unittest.TestCase, ExtraAssertions):
     """Test the functionality of the BaseHTTPServer.
 
        Test the support for the Expect 100-continue header.
@@ -960,6 +1207,27 @@ def verify_http_server_response(self, response):
         match = self.HTTPResponseMatch.search(response)
         self.assertIsNotNone(match)
 
+    def test_unprintable_not_logged(self):
+        # We call the method from the class directly as our Socketless
+        # Handler subclass overrode it... nice for everything BUT this test.
+        self.handler.client_address = ('127.0.0.1', 1337)
+        log_message = BaseHTTPRequestHandler.log_message
+        with mock.patch.object(sys, 'stderr', StringIO()) as fake_stderr:
+            log_message(self.handler, '/foo')
+            log_message(self.handler, '/\033bar\000\033')
+            log_message(self.handler, '/spam %s.', 'a')
+            log_message(self.handler, '/spam %s.', '\033\x7f\x9f\xa0beans')
+            log_message(self.handler, '"GET /foo\\b"ar\007 HTTP/1.0"')
+        stderr = fake_stderr.getvalue()
+        self.assertNotIn('\033', stderr)  # non-printable chars are caught.
+        self.assertNotIn('\000', stderr)  # non-printable chars are caught.
+        lines = stderr.splitlines()
+        self.assertIn('/foo', lines[0])
+        self.assertIn(r'/\x1bbar\x00\x1b', lines[1])
+        self.assertIn('/spam a.', lines[2])
+        self.assertIn('/spam \\x1b\\x7f\\x9f\xa0beans.', lines[3])
+        self.assertIn(r'"GET /foo\\b"ar\x07 HTTP/1.0"', lines[4])
+
     def test_http_1_1(self):
         result = self.send_typical_request(b'GET / HTTP/1.1\r\n\r\n')
         self.verify_http_server_response(result[0])
@@ -996,7 +1264,7 @@ def test_extra_space(self):
             b'Host: dummy\r\n'
             b'\r\n'
         )
-        self.assertTrue(result[0].startswith(b'HTTP/1.1 400 '))
+        self.assertStartsWith(result[0], b'HTTP/1.1 400 ')
         self.verify_expected_headers(result[1:result.index(b'\r\n')])
         self.assertFalse(self.handler.get_called)
 
@@ -1110,7 +1378,7 @@ def test_request_length(self):
         # Issue #10714: huge request lines are discarded, to avoid Denial
         # of Service attacks.
         result = self.send_typical_request(b'GET ' + b'x' * 65537)
-        self.assertEqual(result[0], b'HTTP/1.1 414 Request-URI Too Long\r\n')
+        self.assertEqual(result[0], b'HTTP/1.1 414 URI Too Long\r\n')
         self.assertFalse(self.handler.get_called)
         self.assertIsInstance(self.handler.requestline, str)
 
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
index 89e5ec1534..abe8b75e7d 100644
--- a/Lib/test/test_import/__init__.py
+++ b/Lib/test/test_import/__init__.py
@@ -1,9 +1,16 @@
 import builtins
-import contextlib
 import errno
 import glob
+import json
 import importlib.util
 from importlib._bootstrap_external import _get_sourcefile
+from importlib.machinery import (
+    AppleFrameworkLoader,
+    BuiltinImporter,
+    ExtensionFileLoader,
+    FrozenImporter,
+    SourceFileLoader,
+)
 import marshal
 import os
 import py_compile
@@ -15,27 +22,125 @@
 import textwrap
 import threading
 import time
+import types
 import unittest
 from unittest import mock
+import _imp
 
 from test.support import os_helper
 from test.support import (
-    STDLIB_DIR, is_jython, swap_attr, swap_item, cpython_only, is_emscripten,
-    is_wasi)
+    STDLIB_DIR,
+    swap_attr,
+    swap_item,
+    cpython_only,
+    is_apple_mobile,
+    is_emscripten,
+    is_wasi,
+    run_in_subinterp,
+    run_in_subinterp_with_config,
+    Py_TRACE_REFS,
+    requires_gil_enabled,
+    Py_GIL_DISABLED,
+    force_not_colorized_test_class,
+)
 from test.support.import_helper import (
-    forget, make_legacy_pyc, unlink, unload, DirsOnSysPath, CleanImport)
+    forget, make_legacy_pyc, unlink, unload, ready_to_import,
+    DirsOnSysPath, CleanImport, import_module)
 from test.support.os_helper import (
-    TESTFN, rmtree, temp_umask, TESTFN_UNENCODABLE, temp_dir)
+    TESTFN, rmtree, temp_umask, TESTFN_UNENCODABLE)
 from test.support import script_helper
 from test.support import threading_helper
+from test.support.testcase import ExtraAssertions
 from test.test_importlib.util import uncache
 from types import ModuleType
+try:
+    import _testsinglephase
+except ImportError:
+    _testsinglephase = None
+try:
+    import _testmultiphase
+except ImportError:
+    _testmultiphase = None
+try:
+    import _interpreters
+except ModuleNotFoundError:
+    _interpreters = None
+try:
+    import _testinternalcapi
+except ImportError:
+    _testinternalcapi = None
 
 
 skip_if_dont_write_bytecode = unittest.skipIf(
         sys.dont_write_bytecode,
         "test meaningful only when writing bytecode")
 
+
+def _require_loader(module, loader, skip):
+    if isinstance(module, str):
+        module = __import__(module)
+
+    MODULE_KINDS = {
+        BuiltinImporter: 'built-in',
+        ExtensionFileLoader: 'extension',
+        AppleFrameworkLoader: 'framework extension',
+        FrozenImporter: 'frozen',
+        SourceFileLoader: 'pure Python',
+    }
+
+    expected = loader
+    assert isinstance(expected, type), expected
+    expected = MODULE_KINDS[expected]
+
+    actual = module.__spec__.loader
+    if not isinstance(actual, type):
+        actual = type(actual)
+    actual = MODULE_KINDS[actual]
+
+    if actual != expected:
+        err = f'expected module to be {expected}, got {module.__spec__}'
+        if skip:
+            raise unittest.SkipTest(err)
+        raise Exception(err)
+    return module
+
+def require_builtin(module, *, skip=False):
+    module = _require_loader(module, BuiltinImporter, skip)
+    assert module.__spec__.origin == 'built-in', module.__spec__
+
+def require_extension(module, *, skip=False):
+    # Apple extensions must be distributed as frameworks. This requires
+    # a specialist loader.
+    if is_apple_mobile:
+        _require_loader(module, AppleFrameworkLoader, skip)
+    else:
+        _require_loader(module, ExtensionFileLoader, skip)
+
+def require_frozen(module, *, skip=True):
+    module = _require_loader(module, FrozenImporter, skip)
+    assert module.__spec__.origin == 'frozen', module.__spec__
+
+def require_pure_python(module, *, skip=False):
+    _require_loader(module, SourceFileLoader, skip)
+
+def create_extension_loader(modname, filename):
+    # Apple extensions must be distributed as frameworks. This requires
+    # a specialist loader.
+    if is_apple_mobile:
+        return AppleFrameworkLoader(modname, filename)
+    else:
+        return ExtensionFileLoader(modname, filename)
+
+def import_extension_from_file(modname, filename, *, put_in_sys_modules=True):
+    loader = create_extension_loader(modname, filename)
+    spec = importlib.util.spec_from_loader(modname, loader)
+    module = importlib.util.module_from_spec(spec)
+    loader.exec_module(module)
+    if put_in_sys_modules:
+        sys.modules[modname] = module
+    return module
+
+
 def remove_files(name):
     for f in (name + ".py",
               name + ".pyc",
@@ -45,28 +150,222 @@ def remove_files(name):
     rmtree('__pycache__')
 
 
-@contextlib.contextmanager
-def _ready_to_import(name=None, source=""):
-    # sets up a temporary directory and removes it
-    # creates the module file
-    # temporarily clears the module from sys.modules (if any)
-    # reverts or removes the module when cleaning up
-    name = name or "spam"
-    with temp_dir() as tempdir:
-        path = script_helper.make_script(tempdir, name, source)
-        old_module = sys.modules.pop(name, None)
+def no_rerun(reason):
+    """Skip rerunning for a particular test.
+
+    WARNING: Use this decorator with care; skipping rerunning makes it
+    impossible to find reference leaks. Provide a clear reason for skipping the
+    test using the 'reason' parameter.
+    """
+    def deco(func):
+        _has_run = False
+        def wrapper(self):
+            nonlocal _has_run
+            if _has_run:
+                self.skipTest(reason)
+            func(self)
+            _has_run = True
+        return wrapper
+    return deco
+
+
+if _testsinglephase is not None:
+    def restore__testsinglephase(*, _orig=_testsinglephase):
+        # We started with the module imported and want to restore
+        # it to its nominal state.
+        sys.modules.pop('_testsinglephase', None)
+        _orig._clear_globals()
+        origin = _orig.__spec__.origin
+        _testinternalcapi.clear_extension('_testsinglephase', origin)
+        import _testsinglephase
+
+
+def requires_singlephase_init(meth):
+    """Decorator to skip if single-phase init modules are not supported."""
+    if not isinstance(meth, type):
+        def meth(self, _meth=meth):
+            try:
+                return _meth(self)
+            finally:
+                restore__testsinglephase()
+    meth = cpython_only(meth)
+    msg = "gh-117694: free-threaded build does not currently support single-phase init modules in sub-interpreters"
+    meth = requires_gil_enabled(msg)(meth)
+    return unittest.skipIf(_testsinglephase is None,
+                           'test requires _testsinglephase module')(meth)
+
+
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(_interpreters is None,
+                           'subinterpreters required')(meth)
+
+
+class ModuleSnapshot(types.SimpleNamespace):
+    """A representation of a module for testing.
+
+    Fields:
+
+    * id - the module's object ID
+    * module - the actual module or an adequate substitute
+       * __file__
+       * __spec__
+          * name
+          * origin
+    * ns - a copy (dict) of the module's __dict__ (or None)
+    * ns_id - the object ID of the module's __dict__
+    * cached - the sys.modules[mod.__spec__.name] entry (or None)
+    * cached_id - the object ID of the sys.modules entry (or None)
+
+    In cases where the value is not available (e.g. due to serialization),
+    the value will be None.
+    """
+    _fields = tuple('id module ns ns_id cached cached_id'.split())
+
+    @classmethod
+    def from_module(cls, mod):
+        name = mod.__spec__.name
+        cached = sys.modules.get(name)
+        return cls(
+            id=id(mod),
+            module=mod,
+            ns=types.SimpleNamespace(**mod.__dict__),
+            ns_id=id(mod.__dict__),
+            cached=cached,
+            cached_id=id(cached),
+        )
+
+    SCRIPT = textwrap.dedent('''
+        {imports}
+
+        name = {name!r}
+
+        {prescript}
+
+        mod = {name}
+
+        {body}
+
+        {postscript}
+        ''')
+    IMPORTS = textwrap.dedent('''
+        import sys
+        ''').strip()
+    SCRIPT_BODY = textwrap.dedent('''
+        # Capture the snapshot data.
+        cached = sys.modules.get(name)
+        snapshot = dict(
+            id=id(mod),
+            module=dict(
+                __file__=mod.__file__,
+                __spec__=dict(
+                    name=mod.__spec__.name,
+                    origin=mod.__spec__.origin,
+                ),
+            ),
+            ns=None,
+            ns_id=id(mod.__dict__),
+            cached=None,
+            cached_id=id(cached) if cached else None,
+        )
+        ''').strip()
+    CLEANUP_SCRIPT = textwrap.dedent('''
+        # Clean up the module.
+        sys.modules.pop(name, None)
+        ''').strip()
+
+    @classmethod
+    def build_script(cls, name, *,
+                     prescript=None,
+                     import_first=False,
+                     postscript=None,
+                     postcleanup=False,
+                     ):
+        if postcleanup is True:
+            postcleanup = cls.CLEANUP_SCRIPT
+        elif isinstance(postcleanup, str):
+            postcleanup = textwrap.dedent(postcleanup).strip()
+            postcleanup = cls.CLEANUP_SCRIPT + os.linesep + postcleanup
+        else:
+            postcleanup = ''
+        prescript = textwrap.dedent(prescript).strip() if prescript else ''
+        postscript = textwrap.dedent(postscript).strip() if postscript else ''
+
+        if postcleanup:
+            if postscript:
+                postscript = postscript + os.linesep * 2 + postcleanup
+            else:
+                postscript = postcleanup
+
+        if import_first:
+            prescript += textwrap.dedent(f'''
+
+                # Now import the module.
+                assert name not in sys.modules
+                import {name}''')
+
+        return cls.SCRIPT.format(
+            imports=cls.IMPORTS.strip(),
+            name=name,
+            prescript=prescript.strip(),
+            body=cls.SCRIPT_BODY.strip(),
+            postscript=postscript,
+        )
+
+    @classmethod
+    def parse(cls, text):
+        raw = json.loads(text)
+        mod = raw['module']
+        mod['__spec__'] = types.SimpleNamespace(**mod['__spec__'])
+        raw['module'] = types.SimpleNamespace(**mod)
+        return cls(**raw)
+
+    @classmethod
+    def from_subinterp(cls, name, interpid=None, *, pipe=None, **script_kwds):
+        if pipe is not None:
+            return cls._from_subinterp(name, interpid, pipe, script_kwds)
+        pipe = os.pipe()
         try:
-            sys.path.insert(0, tempdir)
-            yield name, path
-            sys.path.remove(tempdir)
+            return cls._from_subinterp(name, interpid, pipe, script_kwds)
         finally:
-            if old_module is not None:
-                sys.modules[name] = old_module
-            elif name in sys.modules:
-                del sys.modules[name]
+            r, w = pipe
+            os.close(r)
+            os.close(w)
+
+    @classmethod
+    def _from_subinterp(cls, name, interpid, pipe, script_kwargs):
+        r, w = pipe
+
+        # Build the script.
+        postscript = textwrap.dedent(f'''
+            # Send the result over the pipe.
+            import json
+            import os
+            os.write({w}, json.dumps(snapshot).encode())
+
+            ''')
+        _postscript = script_kwargs.get('postscript')
+        if _postscript:
+            _postscript = textwrap.dedent(_postscript).lstrip()
+            postscript += _postscript
+        script_kwargs['postscript'] = postscript.strip()
+        script = cls.build_script(name, **script_kwargs)
+
+        # Run the script.
+        if interpid is None:
+            ret = run_in_subinterp(script)
+            if ret != 0:
+                raise AssertionError(f'{ret} != 0')
+        else:
+            _interpreters.run_string(interpid, script)
+
+        # Parse the results.
+        text = os.read(r, 1000)
+        return cls.parse(text.decode())
 
 
-class ImportTests(unittest.TestCase):
+@force_not_colorized_test_class
+class ImportTests(unittest.TestCase, ExtraAssertions):
 
     def setUp(self):
         remove_files(TESTFN)
@@ -87,8 +386,7 @@ def test_from_import_missing_attr_raises_ImportError(self):
         with self.assertRaises(ImportError):
             from importlib import something_that_should_not_exist_anywhere
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_missing_attr_has_name_and_path(self):
         with CleanImport('os'):
             import os
@@ -100,15 +398,19 @@ def test_from_import_missing_attr_has_name_and_path(self):
 
     @cpython_only
     def test_from_import_missing_attr_has_name_and_so_path(self):
-        import _testcapi
+        _testcapi = import_module("_testcapi")
         with self.assertRaises(ImportError) as cm:
             from _testcapi import i_dont_exist
         self.assertEqual(cm.exception.name, '_testcapi')
         if hasattr(_testcapi, "__file__"):
-            self.assertEqual(cm.exception.path, _testcapi.__file__)
+            # The path on the exception is strictly the spec origin, not the
+            # module's __file__. For most cases, these are the same; but on
+            # iOS, the Framework relocation process results in the exception
+            # being raised from the spec location.
+            self.assertEqual(cm.exception.path, _testcapi.__spec__.origin)
             self.assertRegex(
                 str(cm.exception),
-                r"cannot import name 'i_dont_exist' from '_testcapi' \(.*\.(so|pyd)\)"
+                r"cannot import name 'i_dont_exist' from '_testcapi' \(.*(\.(so|pyd))?\)"
             )
         else:
             self.assertEqual(
@@ -123,19 +425,17 @@ def test_from_import_missing_attr_has_name(self):
         self.assertEqual(cm.exception.name, '_warning')
         self.assertIsNone(cm.exception.path)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_missing_attr_path_is_canonical(self):
         with self.assertRaises(ImportError) as cm:
             from os.path import i_dont_exist
         self.assertIn(cm.exception.name, {'posixpath', 'ntpath'})
         self.assertIsNotNone(cm.exception)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_star_invalid_type(self):
         import re
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("__all__ = [b'invalid_type']")
             globals = {}
@@ -144,7 +444,7 @@ def test_from_import_star_invalid_type(self):
             ):
                 exec(f"from {name} import *", globals)
             self.assertNotIn(b"invalid_type", globals)
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("globals()[b'invalid_type'] = object()")
             globals = {}
@@ -161,18 +461,18 @@ def test_case_sensitivity(self):
             import RAnDoM
 
     def test_double_const(self):
-        # Another brief digression to test the accuracy of manifest float
-        # constants.
-        from test import double_const  # don't blink -- that *was* the test
+        # Importing double_const checks that float constants
+        # serialiazed by marshal as PYC files don't lose precision
+        # (SF bug 422177).
+        from test.test_import.data import double_const
+        unload('test.test_import.data.double_const')
+        from test.test_import.data import double_const  # noqa: F811
 
     def test_import(self):
         def test_with_extension(ext):
             # The extension is normally ".py", perhaps ".pyw".
             source = TESTFN + ext
-            if is_jython:
-                pyc = TESTFN + "$py.class"
-            else:
-                pyc = TESTFN + ".pyc"
+            pyc = TESTFN + ".pyc"
 
             with open(source, "w", encoding='utf-8') as f:
                 print("# This tests Python's ability to import a",
@@ -274,7 +574,7 @@ def test_import_name_binding(self):
         import test as x
         import test.support
         self.assertIs(x, test, x.__name__)
-        self.assertTrue(hasattr(test.support, "__file__"))
+        self.assertHasAttr(test.support, "__file__")
 
         # import x.y.z as w binds z as w
         import test.support as y
@@ -295,7 +595,7 @@ def test_issue31286(self):
 
         # import in a 'for' loop resulted in segmentation fault
         for i in range(2):
-            import test.support.script_helper as x
+            import test.support.script_helper as x  # noqa: F811
 
     def test_failing_reload(self):
         # A failing reload should leave the module object in sys.modules.
@@ -345,7 +645,7 @@ def test_file_to_source(self):
         sys.path.insert(0, os.curdir)
         try:
             mod = __import__(TESTFN)
-            self.assertTrue(mod.__file__.endswith('.py'))
+            self.assertEndsWith(mod.__file__, '.py')
             os.remove(source)
             del sys.modules[TESTFN]
             make_legacy_pyc(source)
@@ -427,8 +727,7 @@ def test_from_import_message_for_existing_module(self):
         with self.assertRaisesRegex(ImportError, "^cannot import name 'bogus'"):
             from re import bogus
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_import_AttributeError(self):
         # Issue #24492: trying to import an attribute that raises an
         # AttributeError should lead to an ImportError.
@@ -492,7 +791,7 @@ def run():
         finally:
             del sys.path[0]
 
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; FileNotFoundError: [WinError 2] No such file or directory: 'built-in'
     @unittest.skipUnless(sys.platform == "win32", "Windows-specific")
     def test_dll_dependency_import(self):
         from _winapi import GetModuleFileName
@@ -538,6 +837,453 @@ def test_dll_dependency_import(self):
                                     env=env,
                                     cwd=os.path.dirname(pyexe))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON _imp.get_frozen_object("x", b"6\'\xd5Cu\x12"). TypeError: expected at most 1 arguments, got 2
+    def test_issue105979(self):
+        # this used to crash
+        with self.assertRaises(ImportError) as cm:
+            _imp.get_frozen_object("x", b"6\'\xd5Cu\x12")
+        self.assertIn("Frozen object named 'x' is invalid",
+                      str(cm.exception))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_frozen_module_from_import_error(self):
+        with self.assertRaises(ImportError) as cm:
+            from os import this_will_never_exist
+        self.assertIn(
+            f"cannot import name 'this_will_never_exist' from 'os' ({os.__file__})",
+            str(cm.exception),
+        )
+        with self.assertRaises(ImportError) as cm:
+            from sys import this_will_never_exist
+        self.assertIn(
+            "cannot import name 'this_will_never_exist' from 'sys' (unknown location)",
+            str(cm.exception),
+        )
+
+        scripts = [
+            """
+import os
+os.__spec__.has_location = False
+os.__file__ = []
+from os import this_will_never_exist
+""",
+            """
+import os
+os.__spec__.has_location = False
+del os.__file__
+from os import this_will_never_exist
+""",
+              """
+import os
+os.__spec__.origin = []
+os.__file__ = []
+from os import this_will_never_exist
+"""
+        ]
+        for script in scripts:
+            with self.subTest(script=script):
+                expected_error = (
+                    b"cannot import name 'this_will_never_exist' "
+                    b"from 'os' (unknown location)"
+                )
+                popen = script_helper.spawn_python("-c", script)
+                stdout, stderr = popen.communicate()
+                self.assertIn(expected_error, stdout)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_non_module_from_import_error(self):
+        prefix = """
+import sys
+class NotAModule: ...
+nm = NotAModule()
+nm.symbol = 123
+sys.modules["not_a_module"] = nm
+from not_a_module import symbol
+"""
+        scripts = [
+            prefix + "from not_a_module import missing_symbol",
+            prefix + "nm.__spec__ = []\nfrom not_a_module import missing_symbol",
+        ]
+        for script in scripts:
+            with self.subTest(script=script):
+                expected_error = (
+                    b"ImportError: cannot import name 'missing_symbol' from "
+                    b"'<unknown module name>' (unknown location)"
+                )
+            popen = script_helper.spawn_python("-c", script)
+            stdout, stderr = popen.communicate()
+            self.assertIn(expected_error, stdout)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib(self):
+        script_errors = [
+            (
+                "import fractions\nfractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*fractions.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                # and there's no error at all when using -P
+                popen = script_helper.spawn_python('-P', 'fractions.py', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')
+
+                tmp_child = os.path.join(tmp, "child")
+                os.mkdir(tmp_child)
+
+                # test the logic with different cwd
+                popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')  # no error
+
+                popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp_child)
+                stdout, stderr = popen.communicate()
+                self.assertEqual(stdout, b'')  # no error
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_package_shadowing_stdlib_module(self):
+        script_errors = [
+            (
+                "fractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                os.mkdir(os.path.join(tmp, "fractions"))
+                with open(
+                    os.path.join(tmp, "fractions", "__init__.py"), "w", encoding='utf-8'
+                ) as f:
+                    f.write("shadowing_module = True")
+                with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                    f.write("import fractions; fractions.shadowing_module\n")
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*[\\/]fractions[\\/]+__init__.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "main.py"), cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'main', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                # and there's no shadowing at all when using -P
+                popen = script_helper.spawn_python('-P', 'main.py', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, b"module 'fractions' has no attribute 'shadowing_module'")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_third_party(self):
+        script_errors = [
+            (
+                "import numpy\nnumpy.array",
+                rb"AttributeError: module 'numpy' has no attribute 'array'"
+            ),
+            (
+                "from numpy import array",
+                rb"ImportError: cannot import name 'array' from 'numpy'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
+                    f.write(script)
+
+                expected_error = error + (
+                    rb" \(consider renaming '.*numpy.py' if it has the "
+                    rb"same name as a library you intended to import\)\s+\Z"
+                )
+
+                popen = script_helper.spawn_python(os.path.join(tmp, "numpy.py"))
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-m', 'numpy', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+                popen = script_helper.spawn_python('-c', 'import numpy', cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_maybe_not_shadowing_third_party(self):
+        with os_helper.temp_dir() as tmp:
+            with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
+                f.write("this_script_does_not_attempt_to_import_numpy = True")
+
+            expected_error = (
+                rb"AttributeError: module 'numpy' has no attribute 'attr'\s+\Z"
+            )
+            popen = script_helper.spawn_python('-c', 'import numpy; numpy.attr', cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertRegex(stdout, expected_error)
+
+            expected_error = (
+                rb"ImportError: cannot import name 'attr' from 'numpy' \(.*\)\s+\Z"
+            )
+            popen = script_helper.spawn_python('-c', 'from numpy import attr', cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib_edge_cases(self):
+        with os_helper.temp_dir() as tmp:
+            with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                f.write("shadowing_module = True")
+
+            # Unhashable str subclass
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+class substr(str):
+    __hash__ = None
+fractions.__name__ = substr('fractions')
+try:
+    fractions.Fraction
+except TypeError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+class substr(str):
+    __hash__ = None
+fractions.__name__ = substr('fractions')
+try:
+    from fractions import Fraction
+except TypeError as e:
+    print(str(e))
+""")
+
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            self.assertEqual(stdout.rstrip(), b"unhashable type: 'substr'")
+
+            # Various issues with sys module
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+
+import sys
+sys.stdlib_module_names = None
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+del sys.stdlib_module_names
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+sys.path = [0]
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 3)
+            for line in lines:
+                self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+
+import sys
+sys.stdlib_module_names = None
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+del sys.stdlib_module_names
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+sys.path = [0]
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 3)
+            for line in lines:
+                self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
+
+            # Various issues with origin
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+del fractions.__spec__.origin
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+
+fractions.__spec__.origin = []
+try:
+    fractions.Fraction
+except AttributeError as e:
+    print(str(e))
+""")
+
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 2)
+            for line in lines:
+                self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
+
+            with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write("""
+import fractions
+fractions.shadowing_module
+del fractions.__spec__.origin
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+
+fractions.__spec__.origin = []
+try:
+    from fractions import Fraction
+except ImportError as e:
+    print(str(e))
+""")
+            popen = script_helper.spawn_python("main.py", cwd=tmp)
+            stdout, stderr = popen.communicate()
+            lines = stdout.splitlines()
+            self.assertEqual(len(lines), 2)
+            for line in lines:
+                self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
+
+    @unittest.skipIf(sys.platform == 'win32', 'Cannot delete cwd on Windows')
+    @unittest.skipIf(sys.platform == 'sunos5', 'Cannot delete cwd on Solaris/Illumos')
+    @unittest.skipIf(sys.platform.startswith('aix'), 'Cannot delete cwd on AIX')
+    def test_script_shadowing_stdlib_cwd_failure(self):
+        with os_helper.temp_dir() as tmp:
+            subtmp = os.path.join(tmp, "subtmp")
+            os.mkdir(subtmp)
+            with open(os.path.join(subtmp, "main.py"), "w", encoding='utf-8') as f:
+                f.write(f"""
+import sys
+assert sys.path[0] == ''
+
+import os
+import shutil
+shutil.rmtree(os.getcwd())
+
+os.does_not_exist
+""")
+            # Use -c to ensure sys.path[0] is ""
+            popen = script_helper.spawn_python("-c", "import main", cwd=subtmp)
+            stdout, stderr = popen.communicate()
+            expected_error = rb"AttributeError: module 'os' has no attribute 'does_not_exist'"
+            self.assertRegex(stdout, expected_error)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_script_shadowing_stdlib_sys_path_modification(self):
+        script_errors = [
+            (
+                "import fractions\nfractions.Fraction",
+                rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
+            ),
+            (
+                "from fractions import Fraction",
+                rb"ImportError: cannot import name 'Fraction' from 'fractions'"
+            )
+        ]
+        for script, error in script_errors:
+            with self.subTest(script=script), os_helper.temp_dir() as tmp:
+                with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
+                    f.write("shadowing_module = True")
+                with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
+                    f.write('import sys; sys.path.insert(0, "this_folder_does_not_exist")\n')
+                    f.write(script)
+                expected_error = error + (
+                    rb" \(consider renaming '.*fractions.py' since it has the "
+                    rb"same name as the standard library module named 'fractions' "
+                    rb"and prevents importing that standard library module\)"
+                )
+
+                popen = script_helper.spawn_python("main.py", cwd=tmp)
+                stdout, stderr = popen.communicate()
+                self.assertRegex(stdout, expected_error)
+
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "_imp" has no attribute "create_dynamic"')
+    def test_create_dynamic_null(self):
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec:
+                name = "a\x00b"
+                origin = "abc"
+            _imp.create_dynamic(Spec())
+
+        with self.assertRaisesRegex(ValueError, 'embedded null character'):
+            class Spec2:
+                name = "abc"
+                origin = "a\x00b"
+            _imp.create_dynamic(Spec2())
+
 
 @skip_if_dont_write_bytecode
 class FilePermissionTests(unittest.TestCase):
@@ -551,7 +1297,7 @@ class FilePermissionTests(unittest.TestCase):
     )
     def test_creation_mode(self):
         mask = 0o022
-        with temp_umask(mask), _ready_to_import() as (name, path):
+        with temp_umask(mask), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             module = __import__(name)
             if not os.path.exists(cached_path):
@@ -570,7 +1316,7 @@ def test_creation_mode(self):
     def test_cached_mode_issue_2051(self):
         # permissions of .pyc should match those of .py, regardless of mask
         mode = 0o600
-        with temp_umask(0o022), _ready_to_import() as (name, path):
+        with temp_umask(0o022), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             os.chmod(path, mode)
             __import__(name)
@@ -586,7 +1332,7 @@ def test_cached_mode_issue_2051(self):
     @os_helper.skip_unless_working_chmod
     def test_cached_readonly(self):
         mode = 0o400
-        with temp_umask(0o022), _ready_to_import() as (name, path):
+        with temp_umask(0o022), ready_to_import() as (name, path):
             cached_path = importlib.util.cache_from_source(path)
             os.chmod(path, mode)
             __import__(name)
@@ -601,7 +1347,7 @@ def test_cached_readonly(self):
     def test_pyc_always_writable(self):
         # Initially read-only .pyc files on Windows used to cause problems
         # with later updates, see issue #6074 for details
-        with _ready_to_import() as (name, path):
+        with ready_to_import() as (name, path):
             # Write a Python file, make it read-only and import it
             with open(path, 'w', encoding='utf-8') as f:
                 f.write("x = 'original'\n")
@@ -683,8 +1429,7 @@ def test_basics(self):
         self.assertEqual(mod.code_filename, self.file_name)
         self.assertEqual(mod.func_filename, self.file_name)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: 'another_module.py' != .../unlikely_module_name.py
     def test_incorrect_code_name(self):
         py_compile.compile(self.file_name, dfile="another_module.py")
         mod = self.import_module()
@@ -720,7 +1465,7 @@ def test_foreign_code(self):
         self.assertEqual(mod.constant.co_filename, foreign_code.co_filename)
 
 
-class PathsTests(unittest.TestCase):
+class PathsTests(unittest.TestCase, ExtraAssertions):
     SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8',
                'test\u00b0\u00b3\u00b2')
     path = TESTFN
@@ -770,11 +1515,11 @@ def test_UNC_path(self):
             self.fail("could not import 'test_unc_path' from %r: %r"
                       % (unc, e))
         self.assertEqual(mod.testdata, 'test_unc_path')
-        self.assertTrue(mod.__file__.startswith(unc), mod.__file__)
+        self.assertStartsWith(mod.__file__, unc)
         unload("test_unc_path")
 
 
-class RelativeImportTests(unittest.TestCase):
+class RelativeImportTests(unittest.TestCase, ExtraAssertions):
 
     def tearDown(self):
         unload("test.relimport")
@@ -783,7 +1528,7 @@ def tearDown(self):
     def test_relimport_star(self):
         # This will import * from .test_import.
         from .. import relimport
-        self.assertTrue(hasattr(relimport, "RelativeImportTests"))
+        self.assertHasAttr(relimport, "RelativeImportTests")
 
     def test_issue3221(self):
         # Note for mergers: the 'absolute' tests from the 2.x branch
@@ -842,10 +1587,37 @@ def test_import_from_unloaded_package(self):
             import package2.submodule1
             package2.submodule1.submodule2
 
+    def test_rebinding(self):
+        # The same data is also used for testing pkgutil.resolve_name()
+        # in test_pkgutil and mock.patch in test_unittest.
+        path = os.path.join(os.path.dirname(__file__), 'data')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            from package3 import submodule
+            self.assertEqual(submodule.attr, 'rebound')
+            import package3.submodule as submodule
+            self.assertEqual(submodule.attr, 'rebound')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            import package3.submodule as submodule
+            self.assertEqual(submodule.attr, 'rebound')
+            from package3 import submodule
+            self.assertEqual(submodule.attr, 'rebound')
+
+    def test_rebinding2(self):
+        path = os.path.join(os.path.dirname(__file__), 'data')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            import package4.submodule as submodule
+            self.assertEqual(submodule.attr, 'submodule')
+            from package4 import submodule
+            self.assertEqual(submodule.attr, 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            from package4 import submodule
+            self.assertEqual(submodule.attr, 'origin')
+            import package4.submodule as submodule
+            self.assertEqual(submodule.attr, 'submodule')
+
 
 class OverridingImportBuiltinTests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_override_builtin(self):
         # Test that overriding builtins.__import__ can bypass sys.modules.
         import os
@@ -1074,7 +1846,7 @@ def test_symlinked_dir_importable(self):
 
 
 @cpython_only
-class ImportlibBootstrapTests(unittest.TestCase):
+class ImportlibBootstrapTests(unittest.TestCase, ExtraAssertions):
     # These tests check that importlib is bootstrapped.
 
     def test_frozen_importlib(self):
@@ -1087,7 +1859,7 @@ def test_frozen_importlib_is_bootstrap(self):
         self.assertIs(mod, _bootstrap)
         self.assertEqual(mod.__name__, 'importlib._bootstrap')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertTrue(mod.__file__.endswith('_bootstrap.py'), mod.__file__)
+        self.assertEndsWith(mod.__file__, '_bootstrap.py')
 
     def test_frozen_importlib_external_is_bootstrap_external(self):
         from importlib import _bootstrap_external
@@ -1095,7 +1867,7 @@ def test_frozen_importlib_external_is_bootstrap_external(self):
         self.assertIs(mod, _bootstrap_external)
         self.assertEqual(mod.__name__, 'importlib._bootstrap_external')
         self.assertEqual(mod.__package__, 'importlib')
-        self.assertTrue(mod.__file__.endswith('_bootstrap_external.py'), mod.__file__)
+        self.assertEndsWith(mod.__file__, '_bootstrap_external.py')
 
     def test_there_can_be_only_one(self):
         # Issue #15386 revealed a tricky loophole in the bootstrapping
@@ -1305,8 +2077,7 @@ def exec_module(*args):
             else:
                 importlib.SourceLoader.exec_module = old_exec_module
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(TESTFN_UNENCODABLE, 'need TESTFN_UNENCODABLE')
     def test_unencodable_filename(self):
         # Issue #11619: The Python parser and the import machinery must not
@@ -1357,8 +2128,7 @@ def test_rebinding(self):
         from test.test_import.data.circular_imports.subpkg import util
         self.assertIs(util.util, rebinding.util)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON AttributeError: module "test.test_import.data.circular_imports" has no attribute "binding"
     def test_binding(self):
         try:
             import test.test_import.data.circular_imports.binding
@@ -1369,8 +2139,7 @@ def test_crossreference1(self):
         import test.test_import.data.circular_imports.use
         import test.test_import.data.circular_imports.source
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_crossreference2(self):
         with self.assertRaises(AttributeError) as cm:
             import test.test_import.data.circular_imports.source
@@ -1380,8 +2149,6 @@ def test_crossreference2(self):
         self.assertIn('partially initialized module', errmsg)
         self.assertIn('circular import', errmsg)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_circular_from_import(self):
         with self.assertRaises(ImportError) as cm:
             import test.test_import.data.circular_imports.from_cycle1
@@ -1392,8 +2159,16 @@ def test_circular_from_import(self):
             str(cm.exception),
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_circular_import(self):
+        with self.assertRaisesRegex(
+            AttributeError,
+            r"partially initialized module 'test.test_import.data.circular_imports.import_cycle' "
+            r"from '.*' has no attribute 'some_attribute' \(most likely due to a circular import\)"
+        ):
+            import test.test_import.data.circular_imports.import_cycle
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_absolute_circular_submodule(self):
         with self.assertRaises(AttributeError) as cm:
             import test.test_import.data.circular_imports.subpkg2.parent
@@ -1404,8 +2179,37 @@ def test_absolute_circular_submodule(self):
             str(cm.exception),
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @requires_singlephase_init
+    @unittest.skipIf(_testsinglephase is None, "test requires _testsinglephase module")
+    def test_singlephase_circular(self):
+        """Regression test for gh-123950
+
+        Import a single-phase-init module that imports itself
+        from the PyInit_* function (before it's added to sys.modules).
+        Manages its own cache (which is `static`, and so incompatible
+        with multiple interpreters or interpreter reset).
+        """
+        name = '_testsinglephase_circular'
+        helper_name = 'test.test_import.data.circular_imports.singlephase'
+        with uncache(name, helper_name):
+            filename = _testsinglephase.__file__
+            # We don't put the module in sys.modules: that the *inner*
+            # import should do that.
+            mod = import_extension_from_file(name, filename,
+                                             put_in_sys_modules=False)
+
+            self.assertEqual(mod.helper_mod_name, helper_name)
+            self.assertIn(name, sys.modules)
+            self.assertIn(helper_name, sys.modules)
+
+            self.assertIn(name, sys.modules)
+            self.assertIn(helper_name, sys.modules)
+        self.assertNotIn(name, sys.modules)
+        self.assertNotIn(helper_name, sys.modules)
+        self.assertIs(mod.clear_static_var(), mod)
+        _testinternalcapi.clear_extension('_testsinglephase_circular',
+                                          mod.__spec__.origin)
+
     def test_unwritable_module(self):
         self.addCleanup(unload, "test.test_import.data.unwritable")
         self.addCleanup(unload, "test.test_import.data.unwritable.x")
@@ -1420,6 +2224,1187 @@ def test_unwritable_module(self):
             unwritable.x = 42
 
 
+class SubinterpImportTests(unittest.TestCase):
+
+    RUN_KWARGS = dict(
+        allow_fork=False,
+        allow_exec=False,
+        allow_threads=True,
+        allow_daemon_threads=False,
+        # Isolation-related config values aren't included here.
+    )
+    ISOLATED = dict(
+        use_main_obmalloc=False,
+        gil=2,
+    )
+    NOT_ISOLATED = {k: not v for k, v in ISOLATED.items()}
+    NOT_ISOLATED['gil'] = 1
+
+    @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
+    def pipe(self):
+        r, w = os.pipe()
+        self.addCleanup(os.close, r)
+        self.addCleanup(os.close, w)
+        if hasattr(os, 'set_blocking'):
+            os.set_blocking(r, False)
+        return (r, w)
+
+    def import_script(self, name, fd, filename=None, check_override=None):
+        override_text = ''
+        if check_override is not None:
+            override_text = f'''
+                import _imp
+                _imp._override_multi_interp_extensions_check({check_override})
+                '''
+        if filename:
+            # Apple extensions must be distributed as frameworks. This requires
+            # a specialist loader.
+            if is_apple_mobile:
+                loader = "AppleFrameworkLoader"
+            else:
+                loader = "ExtensionFileLoader"
+
+            return textwrap.dedent(f'''
+                from importlib.util import spec_from_loader, module_from_spec
+                from importlib.machinery import {loader}
+                import os, sys
+                {override_text}
+                loader = {loader}({name!r}, {filename!r})
+                spec = spec_from_loader({name!r}, loader)
+                try:
+                    module = module_from_spec(spec)
+                    loader.exec_module(module)
+                except ImportError as exc:
+                    text = 'ImportError: ' + str(exc)
+                else:
+                    text = 'okay'
+                os.write({fd}, text.encode('utf-8'))
+                ''')
+        else:
+            return textwrap.dedent(f'''
+                import os, sys
+                {override_text}
+                try:
+                    import {name}
+                except ImportError as exc:
+                    text = 'ImportError: ' + str(exc)
+                else:
+                    text = 'okay'
+                os.write({fd}, text.encode('utf-8'))
+                ''')
+
+    def run_here(self, name, filename=None, *,
+                 check_singlephase_setting=False,
+                 check_singlephase_override=None,
+                 isolated=False,
+                 ):
+        """
+        Try importing the named module in a subinterpreter.
+
+        The subinterpreter will be in the current process.
+        The module will have already been imported in the main interpreter.
+        Thus, for extension/builtin modules, the module definition will
+        have been loaded already and cached globally.
+
+        "check_singlephase_setting" determines whether or not
+        the interpreter will be configured to check for modules
+        that are not compatible with use in multiple interpreters.
+
+        This should always return "okay" for all modules if the
+        setting is False (with no override).
+        """
+        __import__(name)
+
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=check_singlephase_setting,
+        )
+
+        r, w = self.pipe()
+        script = self.import_script(name, w, filename,
+                                    check_singlephase_override)
+
+        ret = run_in_subinterp_with_config(script, **kwargs)
+        self.assertEqual(ret, 0)
+        return os.read(r, 100)
+
+    def check_compatible_here(self, name, filename=None, *,
+                              strict=False,
+                              isolated=False,
+                              ):
+        # Verify that the named module may be imported in a subinterpreter.
+        # (See run_here() for more info.)
+        out = self.run_here(name, filename,
+                            check_singlephase_setting=strict,
+                            isolated=isolated,
+                            )
+        self.assertEqual(out, b'okay')
+
+    def check_incompatible_here(self, name, filename=None, *, isolated=False):
+        # Differences from check_compatible_here():
+        #  * verify that import fails
+        #  * "strict" is always True
+        out = self.run_here(name, filename,
+                            check_singlephase_setting=True,
+                            isolated=isolated,
+                            )
+        self.assertEqual(
+            out.decode('utf-8'),
+            f'ImportError: module {name} does not support loading in subinterpreters',
+        )
+
+    def check_compatible_fresh(self, name, *, strict=False, isolated=False):
+        # Differences from check_compatible_here():
+        #  * subinterpreter in a new process
+        #  * module has never been imported before in that process
+        #  * this tests importing the module for the first time
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=strict,
+        )
+        gil = kwargs['gil']
+        kwargs['gil'] = 'default' if gil == 0 else (
+            'shared' if gil == 1 else 'own' if gil == 2 else gil)
+        _, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
+            import _testinternalcapi, sys
+            assert (
+                {name!r} in sys.builtin_module_names or
+                {name!r} not in sys.modules
+            ), repr({name!r})
+            config = type(sys.implementation)(**{kwargs})
+            ret = _testinternalcapi.run_in_subinterp_with_config(
+                {self.import_script(name, "sys.stdout.fileno()")!r},
+                config,
+            )
+            assert ret == 0, ret
+            '''))
+        self.assertEqual(err, b'')
+        self.assertEqual(out, b'okay')
+
+    def check_incompatible_fresh(self, name, *, isolated=False):
+        # Differences from check_compatible_fresh():
+        #  * verify that import fails
+        #  * "strict" is always True
+        kwargs = dict(
+            **self.RUN_KWARGS,
+            **(self.ISOLATED if isolated else self.NOT_ISOLATED),
+            check_multi_interp_extensions=True,
+        )
+        gil = kwargs['gil']
+        kwargs['gil'] = 'default' if gil == 0 else (
+            'shared' if gil == 1 else 'own' if gil == 2 else gil)
+        _, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
+            import _testinternalcapi, sys
+            assert {name!r} not in sys.modules, {name!r}
+            config = type(sys.implementation)(**{kwargs})
+            ret = _testinternalcapi.run_in_subinterp_with_config(
+                {self.import_script(name, "sys.stdout.fileno()")!r},
+                config,
+            )
+            assert ret == 0, ret
+            '''))
+        self.assertEqual(err, b'')
+        self.assertEqual(
+            out.decode('utf-8'),
+            f'ImportError: module {name} does not support loading in subinterpreters',
+        )
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_builtin_compat(self):
+        # For now we avoid using sys or builtins
+        # since they still don't implement multi-phase init.
+        module = '_imp'
+        require_builtin(module)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+
+    @cpython_only
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_frozen_compat(self):
+        module = '_frozen_importlib'
+        require_frozen(module, skip=True)
+        if __import__(module).__spec__.origin != 'frozen':
+            raise unittest.SkipTest(f'{module} is unexpectedly not frozen')
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+
+    @requires_singlephase_init
+    def test_single_init_extension_compat(self):
+        module = '_testsinglephase'
+        require_extension(module)
+        with self.subTest(f'{module}: not strict'):
+            self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_incompatible_here(module)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_incompatible_fresh(module)
+        with self.subTest(f'{module}: isolated, fresh'):
+            self.check_incompatible_fresh(module, isolated=True)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_compat(self):
+        # Module with Py_MOD_PER_INTERPRETER_GIL_SUPPORTED
+        module = '_testmultiphase'
+        require_extension(module)
+
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_non_isolated_compat(self):
+        # Module with Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
+        # and Py_MOD_GIL_NOT_USED
+        modname = '_test_non_isolated'
+        filename = _testmultiphase.__file__
+        module = import_extension_from_file(modname, filename)
+
+        require_extension(module)
+        with self.subTest(f'{modname}: isolated'):
+            self.check_incompatible_here(modname, filename, isolated=True)
+        with self.subTest(f'{modname}: not isolated'):
+            self.check_incompatible_here(modname, filename, isolated=False)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{modname}: not strict'):
+                self.check_compatible_here(modname, filename, strict=False)
+
+    @unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
+    def test_multi_init_extension_per_interpreter_gil_compat(self):
+
+        # _test_shared_gil_only:
+        #   Explicit Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED (default)
+        #   and Py_MOD_GIL_NOT_USED
+        # _test_no_multiple_interpreter_slot:
+        #   No Py_mod_multiple_interpreters slot
+        #   and Py_MOD_GIL_NOT_USED
+        for modname in ('_test_shared_gil_only',
+                        '_test_no_multiple_interpreter_slot'):
+            with self.subTest(modname=modname):
+
+                filename = _testmultiphase.__file__
+                module = import_extension_from_file(modname, filename)
+
+                require_extension(module)
+                with self.subTest(f'{modname}: isolated, strict'):
+                    self.check_incompatible_here(modname, filename,
+                                                 isolated=True)
+                with self.subTest(f'{modname}: not isolated, strict'):
+                    self.check_compatible_here(modname, filename,
+                                               strict=True, isolated=False)
+                if not Py_GIL_DISABLED:
+                    with self.subTest(f'{modname}: not isolated, not strict'):
+                        self.check_compatible_here(
+                            modname, filename, strict=False, isolated=False)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_python_compat(self):
+        module = 'threading'
+        require_pure_python(module)
+        if not Py_GIL_DISABLED:
+            with self.subTest(f'{module}: not strict'):
+                self.check_compatible_here(module, strict=False)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True)
+
+    @requires_singlephase_init
+    def test_singlephase_check_with_setting_and_override(self):
+        module = '_testsinglephase'
+        require_extension(module)
+
+        def check_compatible(setting, override):
+            out = self.run_here(
+                module,
+                check_singlephase_setting=setting,
+                check_singlephase_override=override,
+            )
+            self.assertEqual(out, b'okay')
+
+        def check_incompatible(setting, override):
+            out = self.run_here(
+                module,
+                check_singlephase_setting=setting,
+                check_singlephase_override=override,
+            )
+            self.assertNotEqual(out, b'okay')
+
+        with self.subTest('config: check enabled; override: enabled'):
+            check_incompatible(True, 1)
+        with self.subTest('config: check enabled; override: use config'):
+            check_incompatible(True, 0)
+        with self.subTest('config: check enabled; override: disabled'):
+            check_compatible(True, -1)
+
+        with self.subTest('config: check disabled; override: enabled'):
+            check_incompatible(False, 1)
+        with self.subTest('config: check disabled; override: use config'):
+            check_compatible(False, 0)
+        with self.subTest('config: check disabled; override: disabled'):
+            check_compatible(False, -1)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_isolated_config(self):
+        module = 'threading'
+        require_pure_python(module)
+        with self.subTest(f'{module}: strict, not fresh'):
+            self.check_compatible_here(module, strict=True, isolated=True)
+        with self.subTest(f'{module}: strict, fresh'):
+            self.check_compatible_fresh(module, strict=True, isolated=True)
+
+    @requires_subinterpreters
+    @requires_singlephase_init
+    def test_disallowed_reimport(self):
+        # See https://github.com/python/cpython/issues/104621.
+        script = textwrap.dedent('''
+            import _testsinglephase
+            print(_testsinglephase)
+            ''')
+        interpid = _interpreters.create()
+        self.addCleanup(lambda: _interpreters.destroy(interpid))
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
+
+
+class TestSinglePhaseSnapshot(ModuleSnapshot):
+    """A representation of a single-phase init module for testing.
+
+    Fields from ModuleSnapshot:
+
+    * id - id(mod)
+    * module - mod or a SimpleNamespace with __file__ & __spec__
+    * ns - a shallow copy of mod.__dict__
+    * ns_id - id(mod.__dict__)
+    * cached - sys.modules[name] (or None if not there or not snapshotable)
+    * cached_id - id(sys.modules[name]) (or None if not there)
+
+    Extra fields:
+
+    * summed - the result of calling "mod.sum(1, 2)"
+    * lookedup - the result of calling "mod.look_up_self()"
+    * lookedup_id - the object ID of self.lookedup
+    * state_initialized - the result of calling "mod.state_initialized()"
+    * init_count - (optional) the result of calling "mod.initialized_count()"
+
+    Overridden methods from ModuleSnapshot:
+
+    * from_module()
+    * parse()
+
+    Other methods from ModuleSnapshot:
+
+    * build_script()
+    * from_subinterp()
+
+    ----
+
+    There are 5 modules in Modules/_testsinglephase.c:
+
+    * _testsinglephase
+       * has global state
+       * extra loads skip the init function, copy def.m_base.m_copy
+       * counts calls to init function
+    * _testsinglephase_basic_wrapper
+       * _testsinglephase by another name (and separate init function symbol)
+    * _testsinglephase_basic_copy
+       * same as _testsinglephase but with own def (and init func)
+    * _testsinglephase_with_reinit
+       * has no global or module state
+       * mod.state_initialized returns None
+       * an extra load in the main interpreter calls the cached init func
+       * an extra load in legacy subinterpreters does a full load
+    * _testsinglephase_with_state
+       * has module state
+       * an extra load in the main interpreter calls the cached init func
+       * an extra load in legacy subinterpreters does a full load
+
+    (See Modules/_testsinglephase.c for more info.)
+
+    For all those modules, the snapshot after the initial load (not in
+    the global extensions cache) would look like the following:
+
+    * initial load
+       * id: ID of nww module object
+       * ns: exactly what the module init put there
+       * ns_id: ID of new module's __dict__
+       * cached_id: same as self.id
+       * summed: 3  (never changes)
+       * lookedup_id: same as self.id
+       * state_initialized: a timestamp between the time of the load
+         and the time of the snapshot
+       * init_count: 1  (None for _testsinglephase_with_reinit)
+
+    For the other scenarios it varies.
+
+    For the _testsinglephase, _testsinglephase_basic_wrapper, and
+    _testsinglephase_basic_copy modules, the snapshot should look
+    like the following:
+
+    * reloaded
+       * id: no change
+       * ns: matches what the module init function put there,
+         including the IDs of all contained objects,
+         plus any extra attributes added before the reload
+       * ns_id: no change
+       * cached_id: no change
+       * lookedup_id: no change
+       * state_initialized: no change
+       * init_count: no change
+    * already loaded
+       * (same as initial load except for ns and state_initialized)
+       * ns: matches the initial load, incl. IDs of contained objects
+       * state_initialized: no change from initial load
+
+    For _testsinglephase_with_reinit:
+
+    * reloaded: same as initial load (old module & ns is discarded)
+    * already loaded: same as initial load (old module & ns is discarded)
+
+    For _testsinglephase_with_state:
+
+    * reloaded
+       * (same as initial load (old module & ns is discarded),
+         except init_count)
+       * init_count: increase by 1
+    * already loaded: same as reloaded
+    """
+
+    @classmethod
+    def from_module(cls, mod):
+        self = super().from_module(mod)
+        self.summed = mod.sum(1, 2)
+        self.lookedup = mod.look_up_self()
+        self.lookedup_id = id(self.lookedup)
+        self.state_initialized = mod.state_initialized()
+        if hasattr(mod, 'initialized_count'):
+            self.init_count = mod.initialized_count()
+        return self
+
+    SCRIPT_BODY = ModuleSnapshot.SCRIPT_BODY + textwrap.dedent('''
+        snapshot['module'].update(dict(
+            int_const=mod.int_const,
+            str_const=mod.str_const,
+            _module_initialized=mod._module_initialized,
+        ))
+        snapshot.update(dict(
+            summed=mod.sum(1, 2),
+            lookedup_id=id(mod.look_up_self()),
+            state_initialized=mod.state_initialized(),
+            init_count=mod.initialized_count(),
+            has_spam=hasattr(mod, 'spam'),
+            spam=getattr(mod, 'spam', None),
+        ))
+        ''').rstrip()
+
+    @classmethod
+    def parse(cls, text):
+        self = super().parse(text)
+        if not self.has_spam:
+            del self.spam
+        del self.has_spam
+        return self
+
+
+@requires_singlephase_init
+class SinglephaseInitTests(unittest.TestCase, ExtraAssertions):
+
+    NAME = '_testsinglephase'
+
+    @classmethod
+    def setUpClass(cls):
+        spec = importlib.util.find_spec(cls.NAME)
+        cls.LOADER = type(spec.loader)
+
+        # Apple extensions must be distributed as frameworks. This requires
+        # a specialist loader, and we need to differentiate between the
+        # spec.origin and the original file location.
+        if is_apple_mobile:
+            assert cls.LOADER is AppleFrameworkLoader
+
+            cls.ORIGIN = spec.origin
+            with open(spec.origin + ".origin", "r") as f:
+                cls.FILE = os.path.join(
+                    os.path.dirname(sys.executable),
+                    f.read().strip()
+                )
+        else:
+            assert cls.LOADER is ExtensionFileLoader
+
+            cls.ORIGIN = spec.origin
+            cls.FILE = spec.origin
+
+        # Start fresh.
+        cls.clean_up()
+
+    def tearDown(self):
+        # Clean up the module.
+        self.clean_up()
+
+    @classmethod
+    def clean_up(cls):
+        name = cls.NAME
+        if name in sys.modules:
+            if hasattr(sys.modules[name], '_clear_globals'):
+                assert sys.modules[name].__file__ == cls.FILE, \
+                    f"{sys.modules[name].__file__} != {cls.FILE}"
+
+                sys.modules[name]._clear_globals()
+            del sys.modules[name]
+        # Clear all internally cached data for the extension.
+        _testinternalcapi.clear_extension(name, cls.ORIGIN)
+
+    #########################
+    # helpers
+
+    def add_module_cleanup(self, name):
+        def clean_up():
+            # Clear all internally cached data for the extension.
+            _testinternalcapi.clear_extension(name, self.ORIGIN)
+        self.addCleanup(clean_up)
+
+    def _load_dynamic(self, name, path):
+        """
+        Load an extension module.
+        """
+        # This is essentially copied from the old imp module.
+        from importlib._bootstrap import _load
+        loader = self.LOADER(name, path)
+
+        # Issue bpo-24748: Skip the sys.modules check in _load_module_shim;
+        # always load new extension.
+        spec = importlib.util.spec_from_file_location(name, path,
+                                                      loader=loader)
+        return _load(spec)
+
+    def load(self, name):
+        try:
+            already_loaded = self.already_loaded
+        except AttributeError:
+            already_loaded = self.already_loaded = {}
+        assert name not in already_loaded
+        mod = self._load_dynamic(name, self.ORIGIN)
+        self.assertNotIn(mod, already_loaded.values())
+        already_loaded[name] = mod
+        return types.SimpleNamespace(
+            name=name,
+            module=mod,
+            snapshot=TestSinglePhaseSnapshot.from_module(mod),
+        )
+
+    def re_load(self, name, mod):
+        assert sys.modules[name] is mod
+        assert mod.__dict__ == mod.__dict__
+        reloaded = self._load_dynamic(name, self.ORIGIN)
+        return types.SimpleNamespace(
+            name=name,
+            module=reloaded,
+            snapshot=TestSinglePhaseSnapshot.from_module(reloaded),
+        )
+
+    # subinterpreters
+
+    def add_subinterpreter(self):
+        interpid = _interpreters.create('legacy')
+        def ensure_destroyed():
+            try:
+                _interpreters.destroy(interpid)
+            except _interpreters.InterpreterNotFoundError:
+                pass
+        self.addCleanup(ensure_destroyed)
+        _interpreters.exec(interpid, textwrap.dedent('''
+            import sys
+            import _testinternalcapi
+            '''))
+        def clean_up():
+            _interpreters.exec(interpid, textwrap.dedent(f'''
+                name = {self.NAME!r}
+                if name in sys.modules:
+                    sys.modules.pop(name)._clear_globals()
+                _testinternalcapi.clear_extension(name, {self.ORIGIN!r})
+                '''))
+            _interpreters.destroy(interpid)
+        self.addCleanup(clean_up)
+        return interpid
+
+    def import_in_subinterp(self, interpid=None, *,
+                            postscript=None,
+                            postcleanup=False,
+                            ):
+        name = self.NAME
+
+        if postcleanup:
+            import_ = 'import _testinternalcapi' if interpid is None else ''
+            postcleanup = f'''
+                {import_}
+                mod._clear_globals()
+                _testinternalcapi.clear_extension(name, {self.ORIGIN!r})
+                '''
+
+        try:
+            pipe = self._pipe
+        except AttributeError:
+            r, w = pipe = self._pipe = os.pipe()
+            self.addCleanup(os.close, r)
+            self.addCleanup(os.close, w)
+
+        snapshot = TestSinglePhaseSnapshot.from_subinterp(
+            name,
+            interpid,
+            pipe=pipe,
+            import_first=True,
+            postscript=postscript,
+            postcleanup=postcleanup,
+        )
+
+        return types.SimpleNamespace(
+            name=name,
+            module=None,
+            snapshot=snapshot,
+        )
+
+    # checks
+
+    def check_common(self, loaded):
+        isolated = False
+
+        mod = loaded.module
+        if not mod:
+            # It came from a subinterpreter.
+            isolated = True
+            mod = loaded.snapshot.module
+        # mod.__name__  might not match, but the spec will.
+        self.assertEqual(mod.__spec__.name, loaded.name)
+        self.assertEqual(mod.__file__, self.FILE)
+        self.assertEqual(mod.__spec__.origin, self.ORIGIN)
+        if not isolated:
+            self.assertIsSubclass(mod.error, Exception)
+        self.assertEqual(mod.int_const, 1969)
+        self.assertEqual(mod.str_const, 'something different')
+        self.assertIsInstance(mod._module_initialized, float)
+        self.assertGreater(mod._module_initialized, 0)
+
+        snap = loaded.snapshot
+        self.assertEqual(snap.summed, 3)
+        if snap.state_initialized is not None:
+            self.assertIsInstance(snap.state_initialized, float)
+            self.assertGreater(snap.state_initialized, 0)
+        if isolated:
+            # The "looked up" module is interpreter-specific
+            # (interp->imports.modules_by_index was set for the module).
+            self.assertEqual(snap.lookedup_id, snap.id)
+            self.assertEqual(snap.cached_id, snap.id)
+            with self.assertRaises(AttributeError):
+                snap.spam
+        else:
+            self.assertIs(snap.lookedup, mod)
+            self.assertIs(snap.cached, mod)
+
+    def check_direct(self, loaded):
+        # The module has its own PyModuleDef, with a matching name.
+        self.assertEqual(loaded.module.__name__, loaded.name)
+        self.assertIs(loaded.snapshot.lookedup, loaded.module)
+
+    def check_indirect(self, loaded, orig):
+        # The module re-uses another's PyModuleDef, with a different name.
+        assert orig is not loaded.module
+        assert orig.__name__ != loaded.name
+        self.assertNotEqual(loaded.module.__name__, loaded.name)
+        self.assertIs(loaded.snapshot.lookedup, loaded.module)
+
+    def check_basic(self, loaded, expected_init_count):
+        # m_size == -1
+        # The module loads fresh the first time and copies m_copy after.
+        snap = loaded.snapshot
+        self.assertIsNot(snap.state_initialized, None)
+        self.assertIsInstance(snap.init_count, int)
+        self.assertGreater(snap.init_count, 0)
+        self.assertEqual(snap.init_count, expected_init_count)
+
+    def check_with_reinit(self, loaded):
+        # m_size >= 0
+        # The module loads fresh every time.
+        pass
+
+    def check_fresh(self, loaded):
+        """
+        The module had not been loaded before (at least since fully reset).
+        """
+        snap = loaded.snapshot
+        # The module's init func was run.
+        # A copy of the module's __dict__ was stored in def->m_base.m_copy.
+        # The previous m_copy was deleted first.
+        # _PyRuntime.imports.extensions was set.
+        self.assertEqual(snap.init_count, 1)
+        # The global state was initialized.
+        # The module attrs were initialized from that state.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+
+    def check_semi_fresh(self, loaded, base, prev):
+        """
+        The module had been loaded before and then reset
+        (but the module global state wasn't).
+        """
+        snap = loaded.snapshot
+        # The module's init func was run again.
+        # A copy of the module's __dict__ was stored in def->m_base.m_copy.
+        # The previous m_copy was deleted first.
+        # The module globals did not get reset.
+        self.assertNotEqual(snap.id, base.snapshot.id)
+        self.assertNotEqual(snap.id, prev.snapshot.id)
+        self.assertEqual(snap.init_count, prev.snapshot.init_count + 1)
+        # The global state was updated.
+        # The module attrs were initialized from that state.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+        self.assertNotEqual(snap.state_initialized,
+                            base.snapshot.state_initialized)
+        self.assertNotEqual(snap.state_initialized,
+                            prev.snapshot.state_initialized)
+
+    def check_copied(self, loaded, base):
+        """
+        The module had been loaded before and never reset.
+        """
+        snap = loaded.snapshot
+        # The module's init func was not run again.
+        # The interpreter copied m_copy, as set by the other interpreter,
+        # with objects owned by the other interpreter.
+        # The module globals did not get reset.
+        self.assertNotEqual(snap.id, base.snapshot.id)
+        self.assertEqual(snap.init_count, base.snapshot.init_count)
+        # The global state was not updated since the init func did not run.
+        # The module attrs were not directly initialized from that state.
+        # The state and module attrs still match the previous loading.
+        self.assertEqual(snap.module._module_initialized,
+                         snap.state_initialized)
+        self.assertEqual(snap.state_initialized,
+                         base.snapshot.state_initialized)
+
+    #########################
+    # the tests
+
+    def test_cleared_globals(self):
+        loaded = self.load(self.NAME)
+        _testsinglephase = loaded.module
+        init_before = _testsinglephase.state_initialized()
+
+        _testsinglephase._clear_globals()
+        init_after = _testsinglephase.state_initialized()
+        init_count = _testsinglephase.initialized_count()
+
+        self.assertGreater(init_before, 0)
+        self.assertEqual(init_after, 0)
+        self.assertEqual(init_count, -1)
+
+    def test_variants(self):
+        # Exercise the most meaningful variants described in Python/import.c.
+        self.maxDiff = None
+
+        # Check the "basic" module.
+
+        name = self.NAME
+        expected_init_count = 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_direct(loaded)
+            self.check_basic(loaded, expected_init_count)
+        basic = loaded.module
+
+        # Check its indirect variants.
+
+        name = f'{self.NAME}_basic_wrapper'
+        self.add_module_cleanup(name)
+        expected_init_count += 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_indirect(loaded, basic)
+            self.check_basic(loaded, expected_init_count)
+
+            # Currently PyState_AddModule() always replaces the cached module.
+            self.assertIs(basic.look_up_self(), loaded.module)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # The cached module shouldn't change after this point.
+        basic_lookedup = loaded.module
+
+        # Check its direct variant.
+
+        name = f'{self.NAME}_basic_copy'
+        self.add_module_cleanup(name)
+        expected_init_count += 1
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.check_direct(loaded)
+            self.check_basic(loaded, expected_init_count)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # Check the non-basic variant that has no state.
+
+        name = f'{self.NAME}_with_reinit'
+        self.add_module_cleanup(name)
+        with self.subTest(name):
+            loaded = self.load(name)
+
+            self.check_common(loaded)
+            self.assertIs(loaded.snapshot.state_initialized, None)
+            self.check_direct(loaded)
+            self.check_with_reinit(loaded)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+        # Check the basic variant that has state.
+
+        name = f'{self.NAME}_with_state'
+        self.add_module_cleanup(name)
+        with self.subTest(name):
+            loaded = self.load(name)
+            self.addCleanup(loaded.module._clear_module_state)
+
+            self.check_common(loaded)
+            self.assertIsNot(loaded.snapshot.state_initialized, None)
+            self.check_direct(loaded)
+            self.check_with_reinit(loaded)
+
+            # This should change the cached module for _testsinglephase.
+            self.assertIs(basic.look_up_self(), basic_lookedup)
+            self.assertEqual(basic.initialized_count(), expected_init_count)
+
+    def test_basic_reloaded(self):
+        # m_copy is copied into the existing module object.
+        # Global state is not changed.
+        self.maxDiff = None
+
+        for name in [
+            self.NAME,  # the "basic" module
+            f'{self.NAME}_basic_wrapper',  # the indirect variant
+            f'{self.NAME}_basic_copy',  # the direct variant
+        ]:
+            self.add_module_cleanup(name)
+            with self.subTest(name):
+                loaded = self.load(name)
+                reloaded = self.re_load(name, loaded.module)
+
+                self.check_common(loaded)
+                self.check_common(reloaded)
+
+                # Make sure the original __dict__ did not get replaced.
+                self.assertEqual(id(loaded.module.__dict__),
+                                 loaded.snapshot.ns_id)
+                self.assertEqual(loaded.snapshot.ns.__dict__,
+                                 loaded.module.__dict__)
+
+                self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
+                self.assertEqual(reloaded.module.__name__,
+                                 reloaded.snapshot.ns.__name__)
+
+                self.assertIs(reloaded.module, loaded.module)
+                self.assertIs(reloaded.module.__dict__, loaded.module.__dict__)
+                # It only happens to be the same but that's good enough here.
+                # We really just want to verify that the re-loaded attrs
+                # didn't change.
+                self.assertIs(reloaded.snapshot.lookedup,
+                              loaded.snapshot.lookedup)
+                self.assertEqual(reloaded.snapshot.state_initialized,
+                                 loaded.snapshot.state_initialized)
+                self.assertEqual(reloaded.snapshot.init_count,
+                                 loaded.snapshot.init_count)
+
+                self.assertIs(reloaded.snapshot.cached, reloaded.module)
+
+    def test_with_reinit_reloaded(self):
+        # The module's m_init func is run again.
+        self.maxDiff = None
+
+        # Keep a reference around.
+        basic = self.load(self.NAME)
+
+        for name, has_state in [
+            (f'{self.NAME}_with_reinit', False),  # m_size == 0
+            (f'{self.NAME}_with_state', True),    # m_size > 0
+        ]:
+            self.add_module_cleanup(name)
+            with self.subTest(name=name, has_state=has_state):
+                loaded = self.load(name)
+                if has_state:
+                    self.addCleanup(loaded.module._clear_module_state)
+
+                reloaded = self.re_load(name, loaded.module)
+                if has_state:
+                    self.addCleanup(reloaded.module._clear_module_state)
+
+                self.check_common(loaded)
+                self.check_common(reloaded)
+
+                # Make sure the original __dict__ did not get replaced.
+                self.assertEqual(id(loaded.module.__dict__),
+                                 loaded.snapshot.ns_id)
+                self.assertEqual(loaded.snapshot.ns.__dict__,
+                                 loaded.module.__dict__)
+
+                self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
+                self.assertEqual(reloaded.module.__name__,
+                                 reloaded.snapshot.ns.__name__)
+
+                self.assertIsNot(reloaded.module, loaded.module)
+                self.assertNotEqual(reloaded.module.__dict__,
+                                    loaded.module.__dict__)
+                self.assertIs(reloaded.snapshot.lookedup, reloaded.module)
+                if loaded.snapshot.state_initialized is None:
+                    self.assertIs(reloaded.snapshot.state_initialized, None)
+                else:
+                    self.assertGreater(reloaded.snapshot.state_initialized,
+                                       loaded.snapshot.state_initialized)
+
+                self.assertIs(reloaded.snapshot.cached, reloaded.module)
+
+    @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
+    def test_check_state_first(self):
+        for variant in ['', '_with_reinit', '_with_state']:
+            name = f'{self.NAME}{variant}_check_cache_first'
+            with self.subTest(name):
+                mod = self._load_dynamic(name, self.ORIGIN)
+                self.assertEqual(mod.__name__, name)
+                sys.modules.pop(name, None)
+                _testinternalcapi.clear_extension(name, self.ORIGIN)
+
+    # Currently, for every single-phrase init module loaded
+    # in multiple interpreters, those interpreters share a
+    # PyModuleDef for that object, which can be a problem.
+    # Also, we test with a single-phase module that has global state,
+    # which is shared by all interpreters.
+
+    @no_rerun(reason="module state is not cleared (see gh-140657)")
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_main_no_reset(self):
+        # without resetting; already loaded in main interpreter
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        main_loaded = self.load(self.NAME)
+        _testsinglephase = main_loaded.module
+        # Attrs set after loading are not in m_copy.
+        _testsinglephase.spam = 'spam, spam, spam, spam, eggs, and spam'
+
+        self.check_common(main_loaded)
+        self.check_fresh(main_loaded)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # At this point:
+        #  * alive in 1 interpreter (main)
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy was copied from the main interpreter (was NULL)
+        #  * module's global state was initialized
+
+        # Use an interpreter that gets destroyed right away.
+        loaded = self.import_in_subinterp()
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 1 interpreter (main)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy is NULL (claered when the interpreter was destroyed)
+        #    (was from main interpreter)
+        #  * module's global state was updated, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded = self.import_in_subinterp(interpid1)
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 2 interpreters (main, interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp1
+        #  * module's global state was updated, not reset
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded = self.import_in_subinterp(interpid2)
+        self.check_common(loaded)
+        self.check_copied(loaded, main_loaded)
+
+        # At this point:
+        #  * alive in 3 interpreters (main, interp1, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp2 (was from interp1)
+        #  * module's global state was updated, not reset
+
+    @no_rerun(reason="rerun not possible; module state is never cleared (see gh-102251)")
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_deleted_no_reset(self):
+        # without resetting; already loaded in a deleted interpreter
+
+        if Py_TRACE_REFS:
+            # It's a Py_TRACE_REFS build.
+            # This test breaks interpreter isolation a little,
+            # which causes problems on Py_TRACE_REF builds.
+            raise unittest.SkipTest('crashes on Py_TRACE_REFS builds')
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # First, load in the main interpreter but then completely clear it.
+        loaded_main = self.load(self.NAME)
+        loaded_main.module._clear_globals()
+        _testinternalcapi.clear_extension(self.NAME, self.ORIGIN)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def loaded already
+        #  * module def was in _PyRuntime.imports.extensions, but cleared
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy was set, but cleared (was NULL)
+        #  * module's global state was initialized but cleared
+
+        # Start with an interpreter that gets destroyed right away.
+        base = self.import_in_subinterp(
+            postscript='''
+                # Attrs set after loading are not in m_copy.
+                mod.spam = 'spam, spam, mash, spam, eggs, and spam'
+                ''')
+        self.check_common(base)
+        self.check_fresh(base)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset)
+        #  * m_copy is still set (owned by main interpreter)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded_interp1 = self.import_in_subinterp(interpid1)
+        self.check_common(loaded_interp1)
+        self.check_copied(loaded_interp1, base)
+
+        # At this point:
+        #  * alive in 1 interpreter (interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func did not run again
+        #  * m_copy was not changed
+        #  * module's global state was not touched
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded_interp2 = self.import_in_subinterp(interpid2)
+        self.check_common(loaded_interp2)
+        self.check_copied(loaded_interp2, loaded_interp1)
+
+        # At this point:
+        #  * alive in 2 interpreters (interp1, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func did not run again
+        #  * m_copy was not changed
+        #  * module's global state was not touched
+
+    @requires_subinterpreters
+    def test_basic_multiple_interpreters_reset_each(self):
+        # resetting between each interpreter
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def may or may not be loaded already
+        #  * module def not in _PyRuntime.imports.extensions
+        #  * mod init func has not run yet (since reset, at least)
+        #  * m_copy not set (hasn't been loaded yet or already cleared)
+        #  * module's global state has not been initialized yet
+        #    (or already cleared)
+
+        interpid1 = self.add_subinterpreter()
+        interpid2 = self.add_subinterpreter()
+
+        # Use an interpreter that gets destroyed right away.
+        loaded = self.import_in_subinterp(
+            postscript='''
+            # Attrs set after loading are not in m_copy.
+            mod.spam = 'spam, spam, mash, spam, eggs, and spam'
+            ''',
+            postcleanup=True,
+        )
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 0 interpreters
+        #  * module def in _PyRuntime.imports.extensions
+        #  * mod init func ran for the first time (since reset, at least)
+        #  * m_copy is NULL (claered when the interpreter was destroyed)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter that sticks around.
+        loaded = self.import_in_subinterp(interpid1, postcleanup=True)
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 1 interpreter (interp1)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp1 (was NULL)
+        #  * module's global state was initialized, not reset
+
+        # Use a subinterpreter while the previous one is still alive.
+        loaded = self.import_in_subinterp(interpid2, postcleanup=True)
+        self.check_common(loaded)
+        self.check_fresh(loaded)
+
+        # At this point:
+        #  * alive in 2 interpreters (interp2, interp2)
+        #  * module def still in _PyRuntime.imports.extensions
+        #  * mod init func ran again
+        #  * m_copy was copied from interp2 (was from interp1)
+        #  * module's global state was initialized, not reset
+
+
 if __name__ == '__main__':
     # Test needs to be a package, so we can do relative imports.
     unittest.main()
diff --git a/Lib/test/test_import/data/circular_imports/import_cycle.py b/Lib/test/test_import/data/circular_imports/import_cycle.py
new file mode 100644
index 0000000000..cd9507b5f6
--- /dev/null
+++ b/Lib/test/test_import/data/circular_imports/import_cycle.py
@@ -0,0 +1,3 @@
+import test.test_import.data.circular_imports.import_cycle as m
+
+m.some_attribute
diff --git a/Lib/test/test_import/data/circular_imports/singlephase.py b/Lib/test/test_import/data/circular_imports/singlephase.py
new file mode 100644
index 0000000000..05618bc72f
--- /dev/null
+++ b/Lib/test/test_import/data/circular_imports/singlephase.py
@@ -0,0 +1,13 @@
+"""Circular import involving a single-phase-init extension.
+
+This module is imported from the _testsinglephase_circular module from
+_testsinglephase, and imports that module again.
+"""
+
+import importlib
+import _testsinglephase
+from test.test_import import import_extension_from_file
+
+name = '_testsinglephase_circular'
+filename = _testsinglephase.__file__
+mod = import_extension_from_file(name, filename)
diff --git a/Lib/test/test_import/data/double_const.py b/Lib/test/test_import/data/double_const.py
new file mode 100644
index 0000000000..67852aaf98
--- /dev/null
+++ b/Lib/test/test_import/data/double_const.py
@@ -0,0 +1,30 @@
+from test.support import TestFailed
+
+# A test for SF bug 422177:  manifest float constants varied way too much in
+# precision depending on whether Python was loading a module for the first
+# time, or reloading it from a precompiled .pyc.  The "expected" failure
+# mode is that when test_import imports this after all .pyc files have been
+# erased, it passes, but when test_import imports this from
+# double_const.pyc, it fails.  This indicates a woeful loss of precision in
+# the marshal format for doubles.  It's also possible that repr() doesn't
+# produce enough digits to get reasonable precision for this box.
+
+PI    = 3.14159265358979324
+TWOPI = 6.28318530717958648
+
+PI_str    = "3.14159265358979324"
+TWOPI_str = "6.28318530717958648"
+
+# Verify that the double x is within a few bits of eval(x_str).
+def check_ok(x, x_str):
+    assert x > 0.0
+    x2 = eval(x_str)
+    assert x2 > 0.0
+    diff = abs(x - x2)
+    # If diff is no larger than 3 ULP (wrt x2), then diff/8 is no larger
+    # than 0.375 ULP, so adding diff/8 to x2 should have no effect.
+    if x2 + (diff / 8.) != x2:
+        raise TestFailed("Manifest const %s lost too much precision " % x_str)
+
+check_ok(PI, PI_str)
+check_ok(TWOPI, TWOPI_str)
diff --git a/Lib/test/test_import/data/package3/__init__.py b/Lib/test/test_import/data/package3/__init__.py
new file mode 100644
index 0000000000..7033c22a71
--- /dev/null
+++ b/Lib/test/test_import/data/package3/__init__.py
@@ -0,0 +1,2 @@
+"""Rebinding the package attribute after importing the module."""
+from .submodule import submodule
diff --git a/Lib/test/test_import/data/package3/submodule.py b/Lib/test/test_import/data/package3/submodule.py
new file mode 100644
index 0000000000..cd7b30db15
--- /dev/null
+++ b/Lib/test/test_import/data/package3/submodule.py
@@ -0,0 +1,7 @@
+attr = 'submodule'
+class A:
+    attr = 'submodule'
+class submodule:
+    attr = 'rebound'
+    class B:
+        attr = 'rebound'
diff --git a/Lib/test/test_import/data/package4/__init__.py b/Lib/test/test_import/data/package4/__init__.py
new file mode 100644
index 0000000000..d8af60ab38
--- /dev/null
+++ b/Lib/test/test_import/data/package4/__init__.py
@@ -0,0 +1,5 @@
+"""Binding the package attribute without importing the module."""
+class submodule:
+    attr = 'origin'
+    class B:
+        attr = 'origin'
diff --git a/Lib/test/test_import/data/package4/submodule.py b/Lib/test/test_import/data/package4/submodule.py
new file mode 100644
index 0000000000..c861417aec
--- /dev/null
+++ b/Lib/test/test_import/data/package4/submodule.py
@@ -0,0 +1,3 @@
+attr = 'submodule'
+class A:
+    attr = 'submodule'
diff --git a/Lib/test/test_importlib/import_/test___package__.py b/Lib/test/test_importlib/import_/test___package__.py
index 431faea5b4..7130c99a6f 100644
--- a/Lib/test/test_importlib/import_/test___package__.py
+++ b/Lib/test/test_importlib/import_/test___package__.py
@@ -56,8 +56,6 @@ def test_using___name__(self):
                                          '__path__': []})
         self.assertEqual(module.__name__, 'pkg')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warn_when_using___name__(self):
         with self.assertWarns(ImportWarning):
             self.import_module({'__name__': 'pkg.fake', '__path__': []})
@@ -75,8 +73,6 @@ def test_spec_fallback(self):
         module = self.import_module({'__spec__': FakeSpec('pkg.fake')})
         self.assertEqual(module.__name__, 'pkg')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warn_when_package_and_spec_disagree(self):
         # Raise a DeprecationWarning if __package__ != __spec__.parent.
         with self.assertWarns(DeprecationWarning):
diff --git a/Lib/test/test_importlib/import_/test_helpers.py b/Lib/test/test_importlib/import_/test_helpers.py
index 28cdc0e526..550f88d1d7 100644
--- a/Lib/test/test_importlib/import_/test_helpers.py
+++ b/Lib/test/test_importlib/import_/test_helpers.py
@@ -126,8 +126,6 @@ def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
             ValueError,
             _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_no_spec(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -137,8 +135,6 @@ def test_gh86298_no_spec(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_spec_is_none(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -148,8 +144,6 @@ def test_gh86298_spec_is_none(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_no_spec_loader(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
@@ -159,8 +153,6 @@ def test_gh86298_no_spec_loader(self):
                 DeprecationWarning,
                 _bootstrap_external._bless_my_loader, bar.__dict__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gh86298_loader_and_spec_loader_disagree(self):
         bar = ModuleType('bar')
         bar.__loader__ = object()
diff --git a/Lib/test/test_importlib/import_/test_meta_path.py b/Lib/test/test_importlib/import_/test_meta_path.py
index 26e7b070b9..8689017ba4 100644
--- a/Lib/test/test_importlib/import_/test_meta_path.py
+++ b/Lib/test/test_importlib/import_/test_meta_path.py
@@ -30,8 +30,6 @@ def test_continuing(self):
             with util.import_state(meta_path=[first, second]):
                 self.assertIs(self.__import__(mod_name), second.modules[mod_name])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_empty(self):
         # Raise an ImportWarning if sys.meta_path is empty.
         module_name = 'nothing'
diff --git a/Lib/test/test_importlib/import_/test_path.py b/Lib/test/test_importlib/import_/test_path.py
index 9cf3a77cb8..89b52fbd1e 100644
--- a/Lib/test/test_importlib/import_/test_path.py
+++ b/Lib/test/test_importlib/import_/test_path.py
@@ -68,8 +68,6 @@ def test_path_hooks(self):
             self.assertIn(path, sys.path_importer_cache)
             self.assertIs(sys.path_importer_cache[path], importer)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_empty_path_hooks(self):
         # Test that if sys.path_hooks is empty a warning is raised,
         # sys.path_importer_cache gets None set, and PathFinder returns None.
diff --git a/Lib/test/test_importlib/resources/test_resource.py b/Lib/test/test_importlib/resources/test_resource.py
index 6f75cf57f0..54d32d9b29 100644
--- a/Lib/test/test_importlib/resources/test_resource.py
+++ b/Lib/test/test_importlib/resources/test_resource.py
@@ -192,6 +192,11 @@ def test_is_file_failure_does_not_keep_open(self):
     def test_as_file_does_not_keep_open(self):  # pragma: no cover
         resources.as_file(resources.files('ziptestdata') / 'binary.file')
 
+    import os  # TODO: RUSTPYTHON see below
+    @unittest.skipIf(
+        'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,
+        "TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to tmpfile leak"
+    )
     def test_entered_path_does_not_keep_open(self):
         """
         Mimic what certifi does on import to make its bundle
diff --git a/Lib/test/test_importlib/source/test_file_loader.py b/Lib/test/test_importlib/source/test_file_loader.py
index 9c85bd234f..fa0efee8da 100644
--- a/Lib/test/test_importlib/source/test_file_loader.py
+++ b/Lib/test/test_importlib/source/test_file_loader.py
@@ -236,7 +236,6 @@ def test_unloadable(self):
                 warnings.simplefilter('ignore', DeprecationWarning)
                 loader.load_module('bad name')
 
-    @unittest.skip("TODO: RUSTPYTHON; successful only for Frozen")
     @util.writes_bytecode_files
     def test_checked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping:
@@ -293,7 +292,6 @@ def test_overridden_checked_hash_based_pyc(self):
             loader.exec_module(mod)
             self.assertEqual(mod.state, 'old')
 
-    @unittest.skip("TODO: RUSTPYTHON; successful only for Frozen")
     @util.writes_bytecode_files
     def test_unchecked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping:
@@ -324,7 +322,6 @@ def test_unchecked_hash_based_pyc(self):
                 data[8:16],
             )
 
-    @unittest.skip("TODO: RUSTPYTHON; successful only for Frozen")
     @util.writes_bytecode_files
     def test_overridden_unchecked_hash_based_pyc(self):
         with util.create_modules('_temp') as mapping, \
@@ -362,7 +359,6 @@ 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
@@ -672,31 +668,27 @@ def test_read_only_bytecode(self):
                 os.chmod(bytecode_path, stat.S_IWUSR)
 
 
-# TODO: RUSTPYTHON
-# class SourceLoaderBadBytecodeTestPEP451(
-#         SourceLoaderBadBytecodeTest, BadBytecodeTestPEP451):
-#     pass
-
-
-# (Frozen_SourceBadBytecodePEP451,
-#  Source_SourceBadBytecodePEP451
-#  ) = util.test_both(SourceLoaderBadBytecodeTestPEP451, importlib=importlib,
-#                     machinery=machinery, abc=importlib_abc,
-#                     util=importlib_util)
+class SourceLoaderBadBytecodeTestPEP451(
+        SourceLoaderBadBytecodeTest, BadBytecodeTestPEP451):
+    pass
 
 
-# TODO: RUSTPYTHON
-# class SourceLoaderBadBytecodeTestPEP302(
-#         SourceLoaderBadBytecodeTest, BadBytecodeTestPEP302):
-#     pass
+(Frozen_SourceBadBytecodePEP451,
+ Source_SourceBadBytecodePEP451
+ ) = util.test_both(SourceLoaderBadBytecodeTestPEP451, importlib=importlib,
+                    machinery=machinery, abc=importlib_abc,
+                    util=importlib_util)
 
+class SourceLoaderBadBytecodeTestPEP302(
+        SourceLoaderBadBytecodeTest, BadBytecodeTestPEP302):
+    pass
 
-# (Frozen_SourceBadBytecodePEP302,
-#  Source_SourceBadBytecodePEP302
-#  ) = util.test_both(SourceLoaderBadBytecodeTestPEP302, importlib=importlib,
-#                     machinery=machinery, abc=importlib_abc,
-#                     util=importlib_util)
 
+(Frozen_SourceBadBytecodePEP302,
+ Source_SourceBadBytecodePEP302
+ ) = util.test_both(SourceLoaderBadBytecodeTestPEP302, importlib=importlib,
+                    machinery=machinery, abc=importlib_abc,
+                    util=importlib_util)
 
 class SourcelessLoaderBadBytecodeTest:
 
@@ -772,30 +764,27 @@ def test_non_code_marshal(self):
         self._test_non_code_marshal(del_source=True)
 
 
-# TODO: RUSTPYTHON
-# class SourcelessLoaderBadBytecodeTestPEP451(SourcelessLoaderBadBytecodeTest,
-#         BadBytecodeTestPEP451):
-#     pass
-
-
-# (Frozen_SourcelessBadBytecodePEP451,
-#  Source_SourcelessBadBytecodePEP451
-#  ) = util.test_both(SourcelessLoaderBadBytecodeTestPEP451, importlib=importlib,
-#                     machinery=machinery, abc=importlib_abc,
-#                     util=importlib_util)
+class SourcelessLoaderBadBytecodeTestPEP451(SourcelessLoaderBadBytecodeTest,
+        BadBytecodeTestPEP451):
+    pass
 
 
-# class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
-#         BadBytecodeTestPEP302):
-#     pass
+(Frozen_SourcelessBadBytecodePEP451,
+ Source_SourcelessBadBytecodePEP451
+ ) = util.test_both(SourcelessLoaderBadBytecodeTestPEP451, importlib=importlib,
+                    machinery=machinery, abc=importlib_abc,
+                    util=importlib_util)
 
+class SourcelessLoaderBadBytecodeTestPEP302(SourcelessLoaderBadBytecodeTest,
+        BadBytecodeTestPEP302):
+    pass
 
-# (Frozen_SourcelessBadBytecodePEP302,
-#  Source_SourcelessBadBytecodePEP302
-#  ) = util.test_both(SourcelessLoaderBadBytecodeTestPEP302, importlib=importlib,
-#                     machinery=machinery, abc=importlib_abc,
-#                     util=importlib_util)
 
+(Frozen_SourcelessBadBytecodePEP302,
+ Source_SourcelessBadBytecodePEP302
+ ) = util.test_both(SourcelessLoaderBadBytecodeTestPEP302, importlib=importlib,
+                    machinery=machinery, abc=importlib_abc,
+                    util=importlib_util)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_importlib/test_locks.py b/Lib/test/test_importlib/test_locks.py
index 17cce741cc..edf0329c75 100644
--- a/Lib/test/test_importlib/test_locks.py
+++ b/Lib/test/test_importlib/test_locks.py
@@ -29,6 +29,8 @@ class ModuleLockAsRLockTests:
     test_timeout = None
     # _release_save() unsupported
     test_release_save_unacquired = None
+    # _recursion_count() unsupported
+    test_recursion_count = None
     # lock status in repr unsupported
     test_repr = None
     test_locked_repr = None
@@ -92,7 +94,8 @@ def f():
                 b.release()
             if ra:
                 a.release()
-        lock_tests.Bunch(f, NTHREADS).wait_for_finished()
+        with lock_tests.Bunch(f, NTHREADS):
+            pass
         self.assertEqual(len(results), NTHREADS)
         return results
 
diff --git a/Lib/test/test_importlib/test_metadata_api.py b/Lib/test/test_importlib/test_metadata_api.py
index 55c9f8007e..33c6e85ee9 100644
--- a/Lib/test/test_importlib/test_metadata_api.py
+++ b/Lib/test/test_importlib/test_metadata_api.py
@@ -139,8 +139,6 @@ def test_entry_points_missing_name(self):
     def test_entry_points_missing_group(self):
         assert entry_points(group='missing') == ()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_entry_points_allows_no_attributes(self):
         ep = entry_points().select(group='entries', name='main')
         with self.assertRaises(AttributeError):
diff --git a/Lib/test/test_importlib/test_threaded_import.py b/Lib/test/test_importlib/test_threaded_import.py
index 148b2e4370..f624e7d2c8 100644
--- a/Lib/test/test_importlib/test_threaded_import.py
+++ b/Lib/test/test_importlib/test_threaded_import.py
@@ -249,15 +249,14 @@ def target():
             __import__(TESTFN)
         del sys.modules[TESTFN]
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
+    @unittest.skip('TODO: RUSTPYTHON; hang; Suspected cause of crashes in Windows CI - PermissionError: [WinError 32] Permission denied: "C:\\Users\\RUNNER~1\\AppData\\Local\\Temp\\test_python_0cdrhhs_\\test_python_6340æ"')
     def test_concurrent_futures_circular_import(self):
         # Regression test for bpo-43515
         fn = os.path.join(os.path.dirname(__file__),
                           'partial', 'cfimport.py')
         script_helper.assert_python_ok(fn)
 
-    @unittest.skipUnless(hasattr(_multiprocessing, "SemLock"), "TODO: RUSTPYTHON, pool_in_threads.py needs _multiprocessing.SemLock")                                                                                      
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
+    @unittest.skip('TODO: RUSTPYTHON; hang')
     def test_multiprocessing_pool_circular_import(self):
         # Regression test for bpo-41567
         fn = os.path.join(os.path.dirname(__file__),
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
index 201f506911..bc47159b23 100644
--- a/Lib/test/test_importlib/test_util.py
+++ b/Lib/test/test_importlib/test_util.py
@@ -327,15 +327,6 @@ def test_incorporates_rn(self):
  ) = util.test_both(MagicNumberTests, util=importlib_util)
 
 
-# TODO: RUSTPYTHON
-@unittest.expectedFailure
-def test_incorporates_rn_MONKEYPATCH(self):
-    self.assertTrue(self.util.MAGIC_NUMBER.endswith(b'\r\n'))
-
-# TODO: RUSTPYTHON
-Frozen_MagicNumberTests.test_incorporates_rn = test_incorporates_rn_MONKEYPATCH
-
-
 class PEP3147Tests:
 
     """Tests of PEP 3147-related functions: cache_from_source and source_from_cache."""
@@ -645,7 +636,7 @@ def test_magic_number(self):
         # stakeholders such as OS package maintainers must be notified
         # in advance. Such exceptional releases will then require an
         # adjustment to this test case.
-        EXPECTED_MAGIC_NUMBER = 3531
+        EXPECTED_MAGIC_NUMBER = 2997
         actual = int.from_bytes(importlib.util.MAGIC_NUMBER[:2], 'little')
 
         msg = (
diff --git a/Lib/test/test_inspect/__init__.py b/Lib/test/test_inspect/__init__.py
new file mode 100644
index 0000000000..f2a39a3fe2
--- /dev/null
+++ b/Lib/test/test_inspect/__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_inspect/inspect_fodder.py b/Lib/test/test_inspect/inspect_fodder.py
new file mode 100644
index 0000000000..febd54c86f
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_fodder.py
@@ -0,0 +1,120 @@
+# line 1
+'A module docstring.'
+
+import inspect
+# line 5
+
+# line 7
+def spam(a, /, b, c, d=3, e=4, f=5, *g, **h):
+    eggs(b + d, c + f)
+
+# line 11
+def eggs(x, y):
+    "A docstring."
+    global fr, st
+    fr = inspect.currentframe()
+    st = inspect.stack()
+    p = x
+    q = y / 0
+
+# line 20
+class StupidGit:
+    """A longer,
+
+    indented
+
+    docstring."""
+# line 27
+
+    def abuse(self, a, b, c):
+        """Another
+
+\tdocstring
+
+        containing
+
+\ttabs
+\t
+        """
+        self.argue(a, b, c)
+# line 40
+    def argue(self, a, b, c):
+        try:
+            spam(a, b, c)
+        except BaseException as e:
+            self.ex = e
+            self.tr = inspect.trace()
+
+    @property
+    def contradiction(self):
+        'The automatic gainsaying.'
+        pass
+
+# line 53
+class MalodorousPervert(StupidGit):
+    def abuse(self, a, b, c):
+        pass
+
+    @property
+    def contradiction(self):
+        pass
+
+Tit = MalodorousPervert
+
+class ParrotDroppings:
+    pass
+
+class FesteringGob(MalodorousPervert, ParrotDroppings):
+    def abuse(self, a, b, c):
+        pass
+
+    def _getter(self):
+        pass
+    contradiction = property(_getter)
+
+async def lobbest(grenade):
+    pass
+
+currentframe = inspect.currentframe()
+try:
+    raise Exception()
+except BaseException as e:
+    tb = e.__traceback__
+
+class Callable:
+    def __call__(self, *args):
+        return args
+
+    def as_method_of(self, obj):
+        from types import MethodType
+        return MethodType(self, obj)
+
+custom_method = Callable().as_method_of(42)
+del Callable
+
+# line 95
+class WhichComments:
+  # line 97
+    # before f
+    def f(self):
+      # line 100
+        # start f
+        return 1
+        # line 103
+        # end f
+       # line 105
+    # after f
+
+    # before asyncf - line 108
+    async def asyncf(self):
+        # start asyncf
+        return 2
+        # end asyncf
+       # after asyncf - line 113
+    # end of WhichComments - line 114
+  # after WhichComments - line 115
+
+# Test that getsource works on a line that includes
+# a closing parenthesis with the opening paren being in another line
+(
+); after_closing = lambda: 1
diff --git a/Lib/test/test_inspect/inspect_fodder2.py b/Lib/test/test_inspect/inspect_fodder2.py
new file mode 100644
index 0000000000..157e12167b
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_fodder2.py
@@ -0,0 +1,403 @@
+# line 1
+def wrap(foo=None):
+    def wrapper(func):
+        return func
+    return wrapper
+
+# line 7
+def replace(func):
+    def insteadfunc():
+        print('hello')
+    return insteadfunc
+
+# line 13
+@wrap()
+@wrap(wrap)
+def wrapped():
+    pass
+
+# line 19
+@replace
+def gone():
+    pass
+
+# line 24
+oll = lambda m: m
+
+# line 27
+tll = lambda g: g and \
+g and \
+g
+
+# line 32
+tlli = lambda d: d and \
+    d
+
+# line 36
+def onelinefunc(): pass
+
+# line 39
+def manyargs(arg1, arg2,
+arg3, arg4): pass
+
+# line 43
+def twolinefunc(m): return m and \
+m
+
+# line 47
+a = [None,
+     lambda x: x,
+     None]
+
+# line 52
+def setfunc(func):
+    globals()["anonymous"] = func
+setfunc(lambda x, y: x*y)
+
+# line 57
+def with_comment():  # hello
+    world
+
+# line 61
+multiline_sig = [
+    lambda x, \
+            y: x+y,
+    None,
+    ]
+
+# line 68
+def func69():
+    class cls70:
+        def func71():
+            pass
+    return cls70
+extra74 = 74
+
+# line 76
+def func77(): pass
+(extra78, stuff78) = 'xy'
+extra79 = 'stop'
+
+# line 81
+class cls82:
+    def func83(): pass
+(extra84, stuff84) = 'xy'
+extra85 = 'stop'
+
+# line 87
+def func88():
+    # comment
+    return 90
+
+# line 92
+def f():
+    class X:
+        def g():
+            "doc"
+            return 42
+    return X
+method_in_dynamic_class = f().g
+
+#line 101
+def keyworded(*arg1, arg2=1):
+    pass
+
+#line 105
+def annotated(arg1: list):
+    pass
+
+#line 109
+def keyword_only_arg(*, arg):
+    pass
+
+@wrap(lambda: None)
+def func114():
+    return 115
+
+class ClassWithMethod:
+    def method(self):
+        pass
+
+from functools import wraps
+
+def decorator(func):
+    @wraps(func)
+    def fake():
+        return 42
+    return fake
+
+#line 129
+@decorator
+def real():
+    return 20
+
+#line 134
+class cls135:
+    def func136():
+        def func137():
+            never_reached1
+            never_reached2
+
+# line 141
+class cls142:
+    a = """
+class cls149:
+    ...
+"""
+
+# line 148
+class cls149:
+
+    def func151(self):
+        pass
+
+'''
+class cls160:
+    pass
+'''
+
+# line 159
+class cls160:
+
+    def func162(self):
+        pass
+
+# line 165
+class cls166:
+    a = '''
+    class cls175:
+        ...
+    '''
+
+# line 172
+class cls173:
+
+    class cls175:
+        pass
+
+# line 178
+class cls179:
+    pass
+
+# line 182
+class cls183:
+
+    class cls185:
+
+        def func186(self):
+            pass
+
+def class_decorator(cls):
+    return cls
+
+# line 193
+@class_decorator
+@class_decorator
+class cls196:
+
+    @class_decorator
+    @class_decorator
+    class cls200:
+        pass
+
+class cls203:
+    class cls204:
+        class cls205:
+            pass
+    class cls207:
+        class cls205:
+            pass
+
+# line 211
+def func212():
+    class cls213:
+        pass
+    return cls213
+
+# line 217
+class cls213:
+    def func219(self):
+        class cls220:
+            pass
+        return cls220
+
+# line 224
+async def func225():
+    class cls226:
+        pass
+    return cls226
+
+# line 230
+class cls226:
+    async def func232(self):
+        class cls233:
+            pass
+        return cls233
+
+if True:
+    class cls238:
+        class cls239:
+            '''if clause cls239'''
+else:
+    class cls238:
+        class cls239:
+            '''else clause 239'''
+            pass
+
+#line 247
+def positional_only_arg(a, /):
+    pass
+
+#line 251
+def all_markers(a, b, /, c, d, *, e, f):
+    pass
+
+# line 255
+def all_markers_with_args_and_kwargs(a, b, /, c, d, *args, e, f, **kwargs):
+    pass
+
+#line 259
+def all_markers_with_defaults(a, b=1, /, c=2, d=3, *, e=4, f=5):
+    pass
+
+# line 263
+def deco_factory(**kwargs):
+    def deco(f):
+        @wraps(f)
+        def wrapper(*a, **kwd):
+            kwd.update(kwargs)
+            return f(*a, **kwd)
+        return wrapper
+    return deco
+
+@deco_factory(foo=(1 + 2), bar=lambda: 1)
+def complex_decorated(foo=0, bar=lambda: 0):
+    return foo + bar()
+
+# line 276
+parenthesized_lambda = (
+    lambda: ())
+parenthesized_lambda2 = [
+    lambda: ()][0]
+parenthesized_lambda3 = {0:
+    lambda: ()}[0]
+
+# line 285
+post_line_parenthesized_lambda1 = (lambda: ()
+)
+
+# line 289
+nested_lambda = (
+    lambda right: [].map(
+        lambda length: ()))
+
+# line 294
+if True:
+    class cls296:
+        def f():
+            pass
+else:
+    class cls296:
+        def g():
+            pass
+
+# line 304
+if False:
+    class cls310:
+        def f():
+            pass
+else:
+    class cls310:
+        def g():
+            pass
+
+# line 314
+class ClassWithCodeObject:
+    import sys
+    code = sys._getframe(0).f_code
+
+import enum
+
+# line 321
+class enum322(enum.Enum):
+    A = 'a'
+
+# line 325
+class enum326(enum.IntEnum):
+    A = 1
+
+# line 329
+class flag330(enum.Flag):
+    A = 1
+
+# line 333
+class flag334(enum.IntFlag):
+    A = 1
+
+# line 337
+simple_enum338 = enum.Enum('simple_enum338', 'A')
+simple_enum339 = enum.IntEnum('simple_enum339', 'A')
+simple_flag340 = enum.Flag('simple_flag340', 'A')
+simple_flag341 = enum.IntFlag('simple_flag341', 'A')
+
+import typing
+
+# line 345
+class nt346(typing.NamedTuple):
+    x: int
+    y: int
+
+# line 350
+nt351 = typing.NamedTuple('nt351', (('x', int), ('y', int)))
+
+# line 353
+class td354(typing.TypedDict):
+    x: int
+    y: int
+
+# line 358
+td359 = typing.TypedDict('td359', (('x', int), ('y', int)))
+
+import dataclasses
+
+# line 363
+@dataclasses.dataclass
+class dc364:
+    x: int
+    y: int
+
+# line 369
+dc370 = dataclasses.make_dataclass('dc370', (('x', int), ('y', int)))
+dc371 = dataclasses.make_dataclass('dc370', (('x', int), ('y', int)), module=__name__)
+
+import inspect
+import itertools
+
+# line 376
+ge377 = (
+    inspect.currentframe()
+    for i in itertools.count()
+)
+
+# line 382
+def func383():
+    # line 384
+    ge385 = (
+        inspect.currentframe()
+        for i in itertools.count()
+    )
+    return ge385
+
+# line 391
+@decorator
+# comment
+def func394():
+    return 395
+
+# line 397
+@decorator
+
+def func400():
+    return 401
+
+pass # end of file
diff --git a/Lib/test/test_inspect/inspect_stock_annotations.py b/Lib/test/test_inspect/inspect_stock_annotations.py
new file mode 100644
index 0000000000..d115a25b65
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_stock_annotations.py
@@ -0,0 +1,28 @@
+a:int=3
+b:str="foo"
+
+class MyClass:
+    a:int=4
+    b:str="bar"
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+    def __eq__(self, other):
+        return isinstance(other, MyClass) and self.a == other.a and self.b == other.b
+
+def function(a:int, b:str) -> MyClass:
+    return MyClass(a, b)
+
+
+def function2(a:int, b:"str", c:MyClass) -> MyClass:
+    pass
+
+
+def function3(a:"int", b:"str", c:"MyClass"):
+    pass
+
+
+class UnannotatedClass:
+    pass
+
+def unannotated_function(a, b, c): pass
diff --git a/Lib/test/test_inspect/inspect_stringized_annotations.py b/Lib/test/test_inspect/inspect_stringized_annotations.py
new file mode 100644
index 0000000000..a56fb050ea
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_stringized_annotations.py
@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+a:int=3
+b:str="foo"
+
+class MyClass:
+    a:int=4
+    b:str="bar"
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+    def __eq__(self, other):
+        return isinstance(other, MyClass) and self.a == other.a and self.b == other.b
+
+def function(a:int, b:str) -> MyClass:
+    return MyClass(a, b)
+
+
+def function2(a:int, b:"str", c:MyClass) -> MyClass:
+    pass
+
+
+def function3(a:"int", b:"str", c:"MyClass"):
+    pass
+
+
+class UnannotatedClass:
+    pass
+
+def unannotated_function(a, b, c): pass
+
+class MyClassWithLocalAnnotations:
+    mytype = int
+    x: mytype
diff --git a/Lib/test/test_inspect/inspect_stringized_annotations_2.py b/Lib/test/test_inspect/inspect_stringized_annotations_2.py
new file mode 100644
index 0000000000..87206d5a64
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_stringized_annotations_2.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+def foo(a, b, c):  pass
diff --git a/Lib/test/test_inspect/inspect_stringized_annotations_pep695.py b/Lib/test/test_inspect/inspect_stringized_annotations_pep695.py
new file mode 100644
index 0000000000..39bfe2edb0
--- /dev/null
+++ b/Lib/test/test_inspect/inspect_stringized_annotations_pep695.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+from typing import Callable, Unpack
+
+
+class A[T, *Ts, **P]:
+    x: T
+    y: tuple[*Ts]
+    z: Callable[P, str]
+
+
+class B[T, *Ts, **P]:
+    T = int
+    Ts = str
+    P = bytes
+    x: T
+    y: Ts
+    z: P
+
+
+Eggs = int
+Spam = str
+
+
+class C[Eggs, **Spam]:
+    x: Eggs
+    y: Spam
+
+
+def generic_function[T, *Ts, **P](
+    x: T, *y: Unpack[Ts], z: P.args, zz: P.kwargs
+) -> None: ...
+
+
+def generic_function_2[Eggs, **Spam](x: Eggs, y: Spam): pass
+
+
+class D:
+    Foo = int
+    Bar = str
+
+    def generic_method[Foo, **Bar](
+        self, x: Foo, y: Bar
+    ) -> None: ...
+
+    def generic_method_2[Eggs, **Spam](self, x: Eggs, y: Spam): pass
+
+
+# Eggs is `int` in globals, a TypeVar in type_params, and `str` in locals:
+class E[Eggs]:
+    Eggs = str
+    x: Eggs
+
+
+
+def nested():
+    from types import SimpleNamespace
+    from inspect import get_annotations
+
+    Eggs = bytes
+    Spam = memoryview
+
+
+    class F[Eggs, **Spam]:
+        x: Eggs
+        y: Spam
+
+        def generic_method[Eggs, **Spam](self, x: Eggs, y: Spam): pass
+
+
+    def generic_function[Eggs, **Spam](x: Eggs, y: Spam): pass
+
+
+    # Eggs is `int` in globals, `bytes` in the function scope,
+    # a TypeVar in the type_params, and `str` in locals:
+    class G[Eggs]:
+        Eggs = str
+        x: Eggs
+
+
+    return SimpleNamespace(
+        F=F,
+        F_annotations=get_annotations(F, eval_str=True),
+        F_meth_annotations=get_annotations(F.generic_method, eval_str=True),
+        G_annotations=get_annotations(G, eval_str=True),
+        generic_func=generic_function,
+        generic_func_annotations=get_annotations(generic_function, eval_str=True)
+    )
diff --git a/Lib/test/test_inspect/test_inspect.py b/Lib/test/test_inspect/test_inspect.py
new file mode 100644
index 0000000000..7d037d0554
--- /dev/null
+++ b/Lib/test/test_inspect/test_inspect.py
@@ -0,0 +1,6749 @@
+import asyncio
+import builtins
+import collections
+import copy
+import datetime
+import functools
+import gc
+import importlib
+import inspect
+import io
+import linecache
+import os
+import dis
+from os.path import normcase
+import pickle
+import shutil
+import stat
+import sys
+import subprocess
+import time
+import types
+import tempfile
+import textwrap
+from typing import Unpack
+import unicodedata
+import unittest
+import unittest.mock
+import warnings
+import weakref
+
+# XXX: RUSTPYTHON; skip _pickle tests if _pickle is not available
+try:
+    import _pickle
+except ImportError:
+    _pickle = None
+
+
+try:
+    from concurrent.futures import ThreadPoolExecutor
+except ImportError:
+    ThreadPoolExecutor = None
+
+from test.support import cpython_only, import_helper, suppress_immortalization
+from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ
+# XXX: RUSTPYTHON; test.support is not updated yet
+from test.support.import_helper import DirsOnSysPath #, ready_to_import
+from test.support.os_helper import TESTFN, temp_cwd
+from test.support.script_helper import assert_python_ok, assert_python_failure, kill_python
+from test.support import has_subprocess_support, SuppressCrashReport
+from test import support
+
+from test.test_inspect import inspect_fodder as mod
+from test.test_inspect import inspect_fodder2 as mod2
+from test.test_inspect import inspect_stock_annotations
+from test.test_inspect import inspect_stringized_annotations
+from test.test_inspect import inspect_stringized_annotations_2
+from test.test_inspect import inspect_stringized_annotations_pep695
+
+
+# Functions tested in this suite:
+# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
+# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,
+# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,
+# getclasstree, getargvalues, formatargvalues, currentframe,
+# stack, trace, ismethoddescriptor, isdatadescriptor, ismethodwrapper
+
+# NOTE: There are some additional tests relating to interaction with
+#       zipimport in the test_zipimport_support test module.
+
+modfile = mod.__file__
+if modfile.endswith(('c', 'o')):
+    modfile = modfile[:-1]
+
+# Normalize file names: on Windows, the case of file names of compiled
+# modules depends on the path used to start the python executable.
+modfile = normcase(modfile)
+
+def revise(filename, *args):
+    return (normcase(filename),) + args
+
+git = mod.StupidGit()
+
+
+def tearDownModule():
+    if support.has_socket_support:
+        asyncio.set_event_loop_policy(None)
+
+
+def signatures_with_lexicographic_keyword_only_parameters():
+    """
+    Yields a whole bunch of functions with only keyword-only parameters,
+    where those parameters are always in lexicographically sorted order.
+    """
+    parameters = ['a', 'bar', 'c', 'delta', 'ephraim', 'magical', 'yoyo', 'z']
+    for i in range(1, 2**len(parameters)):
+        p = []
+        bit = 1
+        for j in range(len(parameters)):
+            if i & (bit << j):
+                p.append(parameters[j])
+        fn_text = "def foo(*, " + ", ".join(p) + "): pass"
+        symbols = {}
+        exec(fn_text, symbols, symbols)
+        yield symbols['foo']
+
+
+def unsorted_keyword_only_parameters_fn(*, throw, out, the, baby, with_,
+                                        the_, bathwater):
+    pass
+
+unsorted_keyword_only_parameters = 'throw out the baby with_ the_ bathwater'.split()
+
+class IsTestBase(unittest.TestCase):
+    predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
+                      inspect.isframe, inspect.isfunction, inspect.ismethod,
+                      inspect.ismodule, inspect.istraceback,
+                      inspect.isgenerator, inspect.isgeneratorfunction,
+                      inspect.iscoroutine, inspect.iscoroutinefunction,
+                      inspect.isasyncgen, inspect.isasyncgenfunction,
+                      inspect.ismethodwrapper])
+
+    def istest(self, predicate, exp):
+        obj = eval(exp)
+        self.assertTrue(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
+
+        for other in self.predicates - set([predicate]):
+            if (predicate == inspect.isgeneratorfunction or \
+               predicate == inspect.isasyncgenfunction or \
+               predicate == inspect.iscoroutinefunction) and \
+               other == inspect.isfunction:
+                continue
+            self.assertFalse(other(obj), 'not %s(%s)' % (other.__name__, exp))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test__all__(self):
+        support.check__all__(self, inspect, not_exported=("modulesbyfile",))
+
+def generator_function_example(self):
+    for i in range(2):
+        yield i
+
+async def async_generator_function_example(self):
+    async for i in range(2):
+        yield i
+
+async def coroutine_function_example(self):
+    return 'spam'
+
+@types.coroutine
+def gen_coroutine_function_example(self):
+    yield
+    return 'spam'
+
+def meth_noargs(): pass
+def meth_o(object, /): pass
+def meth_self_noargs(self, /): pass
+def meth_self_o(self, object, /): pass
+def meth_type_noargs(type, /): pass
+def meth_type_o(type, object, /): pass
+
+# Decorator decorator that returns a simple wrapped function
+def identity_wrapper(func):
+    @functools.wraps(func)
+    def wrapped(*args, **kwargs):
+        return func(*args, **kwargs)
+    return wrapped
+
+# Original signature of the simple wrapped function returned by
+# identity_wrapper().
+varargs_signature = (
+    (('args', ..., ..., 'var_positional'),
+    ('kwargs', ..., ..., 'var_keyword')),
+    ...,
+)
+
+# Decorator decorator that returns a simple descriptor
+class custom_descriptor:
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        return self.func.__get__(instance, owner)
+
+
+class TestPredicates(IsTestBase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_excluding_predicates(self):
+        global tb
+        self.istest(inspect.isbuiltin, 'sys.exit')
+        self.istest(inspect.isbuiltin, '[].append')
+        self.istest(inspect.iscode, 'mod.spam.__code__')
+        try:
+            1/0
+        except Exception as e:
+            tb = e.__traceback__
+            self.istest(inspect.isframe, 'tb.tb_frame')
+            self.istest(inspect.istraceback, 'tb')
+            if hasattr(types, 'GetSetDescriptorType'):
+                self.istest(inspect.isgetsetdescriptor,
+                            'type(tb.tb_frame).f_locals')
+            else:
+                self.assertFalse(inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals))
+        finally:
+            # Clear traceback and all the frames and local variables hanging to it.
+            tb = None
+        self.istest(inspect.isfunction, 'mod.spam')
+        self.istest(inspect.isfunction, 'mod.StupidGit.abuse')
+        self.istest(inspect.ismethod, 'git.argue')
+        self.istest(inspect.ismethod, 'mod.custom_method')
+        self.istest(inspect.ismodule, 'mod')
+        self.istest(inspect.ismethoddescriptor, 'int.__add__')
+        self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')
+        self.istest(inspect.isgenerator, '(x for x in range(2))')
+        self.istest(inspect.isgeneratorfunction, 'generator_function_example')
+        self.istest(inspect.isasyncgen,
+                    'async_generator_function_example(1)')
+        self.istest(inspect.isasyncgenfunction,
+                    'async_generator_function_example')
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            self.istest(inspect.iscoroutine, 'coroutine_function_example(1)')
+            self.istest(inspect.iscoroutinefunction, 'coroutine_function_example')
+
+        if hasattr(types, 'MemberDescriptorType'):
+            self.istest(inspect.ismemberdescriptor, 'datetime.timedelta.days')
+        else:
+            self.assertFalse(inspect.ismemberdescriptor(datetime.timedelta.days))
+        self.istest(inspect.ismethodwrapper, "object().__str__")
+        self.istest(inspect.ismethodwrapper, "object().__eq__")
+        self.istest(inspect.ismethodwrapper, "object().__repr__")
+        self.assertFalse(inspect.ismethodwrapper(type))
+        self.assertFalse(inspect.ismethodwrapper(int))
+        self.assertFalse(inspect.ismethodwrapper(type("AnyClass", (), {})))
+
+
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_iscoroutine(self):
+        async_gen_coro = async_generator_function_example(1)
+        gen_coro = gen_coroutine_function_example(1)
+        coro = coroutine_function_example(1)
+
+        class PMClass:
+            async_generator_partialmethod_example = functools.partialmethod(
+                async_generator_function_example)
+            coroutine_partialmethod_example = functools.partialmethod(
+                coroutine_function_example)
+            gen_coroutine_partialmethod_example = functools.partialmethod(
+                gen_coroutine_function_example)
+
+        # partialmethods on the class, bound to an instance
+        pm_instance = PMClass()
+        async_gen_coro_pmi = pm_instance.async_generator_partialmethod_example
+        gen_coro_pmi = pm_instance.gen_coroutine_partialmethod_example
+        coro_pmi = pm_instance.coroutine_partialmethod_example
+
+        # partialmethods on the class, unbound but accessed via the class
+        async_gen_coro_pmc = PMClass.async_generator_partialmethod_example
+        gen_coro_pmc = PMClass.gen_coroutine_partialmethod_example
+        coro_pmc = PMClass.coroutine_partialmethod_example
+
+        self.assertFalse(
+            inspect.iscoroutinefunction(gen_coroutine_function_example))
+        self.assertFalse(
+            inspect.iscoroutinefunction(
+                functools.partial(functools.partial(
+                    gen_coroutine_function_example))))
+        self.assertFalse(inspect.iscoroutinefunction(gen_coro_pmi))
+        self.assertFalse(inspect.iscoroutinefunction(gen_coro_pmc))
+        self.assertFalse(inspect.iscoroutinefunction(inspect))
+        self.assertFalse(inspect.iscoroutine(gen_coro))
+
+        self.assertTrue(
+            inspect.isgeneratorfunction(gen_coroutine_function_example))
+        self.assertTrue(
+            inspect.isgeneratorfunction(
+                functools.partial(functools.partial(
+                    gen_coroutine_function_example))))
+        self.assertTrue(inspect.isgeneratorfunction(gen_coro_pmi))
+        self.assertTrue(inspect.isgeneratorfunction(gen_coro_pmc))
+        self.assertTrue(inspect.isgenerator(gen_coro))
+
+        async def _fn3():
+            pass
+
+        @inspect.markcoroutinefunction
+        def fn3():
+            return _fn3()
+
+        self.assertTrue(inspect.iscoroutinefunction(fn3))
+        self.assertTrue(
+            inspect.iscoroutinefunction(
+                inspect.markcoroutinefunction(lambda: _fn3())
+            )
+        )
+
+        class Cl:
+            async def __call__(self):
+                pass
+
+        self.assertFalse(inspect.iscoroutinefunction(Cl))
+        # instances with async def __call__ are NOT recognised.
+        self.assertFalse(inspect.iscoroutinefunction(Cl()))
+        # unless explicitly marked.
+        self.assertTrue(inspect.iscoroutinefunction(
+            inspect.markcoroutinefunction(Cl())
+        ))
+
+        class Cl2:
+            @inspect.markcoroutinefunction
+            def __call__(self):
+                pass
+
+        self.assertFalse(inspect.iscoroutinefunction(Cl2))
+        # instances with marked __call__ are NOT recognised.
+        self.assertFalse(inspect.iscoroutinefunction(Cl2()))
+        # unless explicitly marked.
+        self.assertTrue(inspect.iscoroutinefunction(
+            inspect.markcoroutinefunction(Cl2())
+        ))
+
+        class Cl3:
+            @inspect.markcoroutinefunction
+            @classmethod
+            def do_something_classy(cls):
+                pass
+
+            @inspect.markcoroutinefunction
+            @staticmethod
+            def do_something_static():
+                pass
+
+        self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_classy))
+        self.assertTrue(inspect.iscoroutinefunction(Cl3.do_something_static))
+
+        self.assertFalse(
+            inspect.iscoroutinefunction(unittest.mock.Mock()))
+        self.assertTrue(
+            inspect.iscoroutinefunction(unittest.mock.AsyncMock()))
+        self.assertTrue(
+            inspect.iscoroutinefunction(coroutine_function_example))
+        self.assertTrue(
+            inspect.iscoroutinefunction(
+                functools.partial(functools.partial(
+                    coroutine_function_example))))
+        self.assertTrue(inspect.iscoroutinefunction(coro_pmi))
+        self.assertTrue(inspect.iscoroutinefunction(coro_pmc))
+        self.assertTrue(inspect.iscoroutine(coro))
+
+        self.assertFalse(
+            inspect.isgeneratorfunction(unittest.mock.Mock()))
+        self.assertFalse(
+            inspect.isgeneratorfunction(unittest.mock.AsyncMock()))
+        self.assertFalse(
+            inspect.isgeneratorfunction(coroutine_function_example))
+        self.assertFalse(
+            inspect.isgeneratorfunction(
+                functools.partial(functools.partial(
+                    coroutine_function_example))))
+        self.assertFalse(inspect.isgeneratorfunction(coro_pmi))
+        self.assertFalse(inspect.isgeneratorfunction(coro_pmc))
+        self.assertFalse(inspect.isgenerator(coro))
+
+        self.assertFalse(
+            inspect.isasyncgenfunction(unittest.mock.Mock()))
+        self.assertFalse(
+            inspect.isasyncgenfunction(unittest.mock.AsyncMock()))
+        self.assertFalse(
+            inspect.isasyncgenfunction(coroutine_function_example))
+        self.assertTrue(
+            inspect.isasyncgenfunction(async_generator_function_example))
+        self.assertTrue(
+            inspect.isasyncgenfunction(
+                functools.partial(functools.partial(
+                    async_generator_function_example))))
+        self.assertTrue(inspect.isasyncgenfunction(async_gen_coro_pmi))
+        self.assertTrue(inspect.isasyncgenfunction(async_gen_coro_pmc))
+        self.assertTrue(inspect.isasyncgen(async_gen_coro))
+
+        coro.close(); gen_coro.close(); # silence warnings
+
+    def test_isawaitable(self):
+        def gen(): yield
+        self.assertFalse(inspect.isawaitable(gen()))
+
+        coro = coroutine_function_example(1)
+        gen_coro = gen_coroutine_function_example(1)
+
+        self.assertTrue(inspect.isawaitable(coro))
+        self.assertTrue(inspect.isawaitable(gen_coro))
+
+        class Future:
+            def __await__():
+                pass
+        self.assertTrue(inspect.isawaitable(Future()))
+        self.assertFalse(inspect.isawaitable(Future))
+
+        class NotFuture: pass
+        not_fut = NotFuture()
+        not_fut.__await__ = lambda: None
+        self.assertFalse(inspect.isawaitable(not_fut))
+
+        coro.close(); gen_coro.close() # silence warnings
+
+    def test_isroutine(self):
+        # method
+        self.assertTrue(inspect.isroutine(git.argue))
+        self.assertTrue(inspect.isroutine(mod.custom_method))
+        self.assertTrue(inspect.isroutine([].count))
+        # function
+        self.assertTrue(inspect.isroutine(mod.spam))
+        self.assertTrue(inspect.isroutine(mod.StupidGit.abuse))
+        # slot-wrapper
+        self.assertTrue(inspect.isroutine(object.__init__))
+        self.assertTrue(inspect.isroutine(object.__str__))
+        self.assertTrue(inspect.isroutine(object.__lt__))
+        self.assertTrue(inspect.isroutine(int.__lt__))
+        # method-wrapper
+        self.assertTrue(inspect.isroutine(object().__init__))
+        self.assertTrue(inspect.isroutine(object().__str__))
+        self.assertTrue(inspect.isroutine(object().__lt__))
+        self.assertTrue(inspect.isroutine((42).__lt__))
+        # method-descriptor
+        self.assertTrue(inspect.isroutine(str.join))
+        self.assertTrue(inspect.isroutine(list.append))
+        self.assertTrue(inspect.isroutine(''.join))
+        self.assertTrue(inspect.isroutine([].append))
+        # object
+        self.assertFalse(inspect.isroutine(object))
+        self.assertFalse(inspect.isroutine(object()))
+        self.assertFalse(inspect.isroutine(str()))
+        # module
+        self.assertFalse(inspect.isroutine(mod))
+        # type
+        self.assertFalse(inspect.isroutine(type))
+        self.assertFalse(inspect.isroutine(int))
+        self.assertFalse(inspect.isroutine(type('some_class', (), {})))
+        # partial
+        self.assertFalse(inspect.isroutine(functools.partial(mod.spam)))
+
+    def test_isroutine_singledispatch(self):
+        self.assertTrue(inspect.isroutine(functools.singledispatch(mod.spam)))
+
+        class A:
+            @functools.singledispatchmethod
+            def method(self, arg):
+                pass
+            @functools.singledispatchmethod
+            @classmethod
+            def class_method(cls, arg):
+                pass
+            @functools.singledispatchmethod
+            @staticmethod
+            def static_method(arg):
+                pass
+
+        self.assertTrue(inspect.isroutine(A.method))
+        self.assertTrue(inspect.isroutine(A().method))
+        self.assertTrue(inspect.isroutine(A.static_method))
+        self.assertTrue(inspect.isroutine(A.class_method))
+
+    def test_isclass(self):
+        self.istest(inspect.isclass, 'mod.StupidGit')
+        self.assertTrue(inspect.isclass(list))
+
+        class CustomGetattr(object):
+            def __getattr__(self, attr):
+                return None
+        self.assertFalse(inspect.isclass(CustomGetattr()))
+
+    def test_get_slot_members(self):
+        class C(object):
+            __slots__ = ("a", "b")
+        x = C()
+        x.a = 42
+        members = dict(inspect.getmembers(x))
+        self.assertIn('a', members)
+        self.assertNotIn('b', members)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_isabstract(self):
+        from abc import ABCMeta, abstractmethod
+
+        class AbstractClassExample(metaclass=ABCMeta):
+
+            @abstractmethod
+            def foo(self):
+                pass
+
+        class ClassExample(AbstractClassExample):
+            def foo(self):
+                pass
+
+        a = ClassExample()
+
+        # Test general behaviour.
+        self.assertTrue(inspect.isabstract(AbstractClassExample))
+        self.assertFalse(inspect.isabstract(ClassExample))
+        self.assertFalse(inspect.isabstract(a))
+        self.assertFalse(inspect.isabstract(int))
+        self.assertFalse(inspect.isabstract(5))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_isabstract_during_init_subclass(self):
+        from abc import ABCMeta, abstractmethod
+        isabstract_checks = []
+        class AbstractChecker(metaclass=ABCMeta):
+            def __init_subclass__(cls):
+                isabstract_checks.append(inspect.isabstract(cls))
+        class AbstractClassExample(AbstractChecker):
+            @abstractmethod
+            def foo(self):
+                pass
+        class ClassExample(AbstractClassExample):
+            def foo(self):
+                pass
+        self.assertEqual(isabstract_checks, [True, False])
+
+        isabstract_checks.clear()
+        class AbstractChild(AbstractClassExample):
+            pass
+        class AbstractGrandchild(AbstractChild):
+            pass
+        class ConcreteGrandchild(ClassExample):
+            pass
+        self.assertEqual(isabstract_checks, [True, True, False])
+
+
+class TestInterpreterStack(IsTestBase):
+    def __init__(self, *args, **kwargs):
+        unittest.TestCase.__init__(self, *args, **kwargs)
+
+        git.abuse(7, 8, 9)
+
+    def test_abuse_done(self):
+        self.istest(inspect.istraceback, 'git.ex.__traceback__')
+        self.istest(inspect.isframe, 'mod.fr')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_stack(self):
+        self.assertTrue(len(mod.st) >= 5)
+        frame1, frame2, frame3, frame4, *_ = mod.st
+        frameinfo = revise(*frame1[1:])
+        self.assertEqual(frameinfo,
+             (modfile, 16, 'eggs', ['    st = inspect.stack()\n'], 0))
+        self.assertEqual(frame1.positions, dis.Positions(16, 16, 9, 24))
+        frameinfo = revise(*frame2[1:])
+        self.assertEqual(frameinfo,
+             (modfile, 9, 'spam', ['    eggs(b + d, c + f)\n'], 0))
+        self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))
+        frameinfo = revise(*frame3[1:])
+        self.assertEqual(frameinfo,
+             (modfile, 43, 'argue', ['            spam(a, b, c)\n'], 0))
+        self.assertEqual(frame3.positions, dis.Positions(43, 43, 12, 25))
+        frameinfo = revise(*frame4[1:])
+        self.assertEqual(frameinfo,
+             (modfile, 39, 'abuse', ['        self.argue(a, b, c)\n'], 0))
+        self.assertEqual(frame4.positions, dis.Positions(39, 39, 8, 27))
+        # Test named tuple fields
+        record = mod.st[0]
+        self.assertIs(record.frame, mod.fr)
+        self.assertEqual(record.lineno, 16)
+        self.assertEqual(record.filename, mod.__file__)
+        self.assertEqual(record.function, 'eggs')
+        self.assertIn('inspect.stack()', record.code_context[0])
+        self.assertEqual(record.index, 0)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_trace(self):
+        self.assertEqual(len(git.tr), 3)
+        frame1, frame2, frame3, = git.tr
+        self.assertEqual(revise(*frame1[1:]),
+             (modfile, 43, 'argue', ['            spam(a, b, c)\n'], 0))
+        self.assertEqual(frame1.positions, dis.Positions(43, 43, 12, 25))
+        self.assertEqual(revise(*frame2[1:]),
+             (modfile, 9, 'spam', ['    eggs(b + d, c + f)\n'], 0))
+        self.assertEqual(frame2.positions, dis.Positions(9, 9, 4, 22))
+        self.assertEqual(revise(*frame3[1:]),
+             (modfile, 18, 'eggs', ['    q = y / 0\n'], 0))
+        self.assertEqual(frame3.positions, dis.Positions(18, 18, 8, 13))
+
+    def test_frame(self):
+        args, varargs, varkw, locals = inspect.getargvalues(mod.fr)
+        self.assertEqual(args, ['x', 'y'])
+        self.assertEqual(varargs, None)
+        self.assertEqual(varkw, None)
+        self.assertEqual(locals, {'x': 11, 'p': 11, 'y': 14})
+        self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
+                         '(x=11, y=14)')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_previous_frame(self):
+        args, varargs, varkw, locals = inspect.getargvalues(mod.fr.f_back)
+        self.assertEqual(args, ['a', 'b', 'c', 'd', 'e', 'f'])
+        self.assertEqual(varargs, 'g')
+        self.assertEqual(varkw, 'h')
+        self.assertEqual(inspect.formatargvalues(args, varargs, varkw, locals),
+             '(a=7, b=8, c=9, d=3, e=4, f=5, *g=(), **h={})')
+
+class GetSourceBase(unittest.TestCase):
+    # Subclasses must override.
+    fodderModule = None
+
+    def setUp(self):
+        with open(inspect.getsourcefile(self.fodderModule), encoding="utf-8") as fp:
+            self.source = fp.read()
+
+    def sourcerange(self, top, bottom):
+        lines = self.source.split("\n")
+        return "\n".join(lines[top-1:bottom]) + ("\n" if bottom else "")
+
+    def assertSourceEqual(self, obj, top, bottom):
+        self.assertEqual(inspect.getsource(obj),
+                         self.sourcerange(top, bottom))
+
+class SlotUser:
+    'Docstrings for __slots__'
+    __slots__ = {'power': 'measured in kilowatts',
+                 'distance': 'measured in kilometers'}
+
+class TestRetrievingSourceCode(GetSourceBase):
+    fodderModule = mod
+
+    def test_getclasses(self):
+        classes = inspect.getmembers(mod, inspect.isclass)
+        self.assertEqual(classes,
+                         [('FesteringGob', mod.FesteringGob),
+                          ('MalodorousPervert', mod.MalodorousPervert),
+                          ('ParrotDroppings', mod.ParrotDroppings),
+                          ('StupidGit', mod.StupidGit),
+                          ('Tit', mod.MalodorousPervert),
+                          ('WhichComments', mod.WhichComments),
+                         ])
+        tree = inspect.getclasstree([cls[1] for cls in classes])
+        self.assertEqual(tree,
+                         [(object, ()),
+                          [(mod.ParrotDroppings, (object,)),
+                           [(mod.FesteringGob, (mod.MalodorousPervert,
+                                                   mod.ParrotDroppings))
+                            ],
+                           (mod.StupidGit, (object,)),
+                           [(mod.MalodorousPervert, (mod.StupidGit,)),
+                            [(mod.FesteringGob, (mod.MalodorousPervert,
+                                                    mod.ParrotDroppings))
+                             ]
+                            ],
+                            (mod.WhichComments, (object,),)
+                           ]
+                          ])
+        tree = inspect.getclasstree([cls[1] for cls in classes], True)
+        self.assertEqual(tree,
+                         [(object, ()),
+                          [(mod.ParrotDroppings, (object,)),
+                           (mod.StupidGit, (object,)),
+                           [(mod.MalodorousPervert, (mod.StupidGit,)),
+                            [(mod.FesteringGob, (mod.MalodorousPervert,
+                                                    mod.ParrotDroppings))
+                             ]
+                            ],
+                            (mod.WhichComments, (object,),)
+                           ]
+                          ])
+
+    def test_getfunctions(self):
+        functions = inspect.getmembers(mod, inspect.isfunction)
+        self.assertEqual(functions, [('after_closing', mod.after_closing),
+                                     ('eggs', mod.eggs),
+                                     ('lobbest', mod.lobbest),
+                                     ('spam', mod.spam)])
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getdoc(self):
+        self.assertEqual(inspect.getdoc(mod), 'A module docstring.')
+        self.assertEqual(inspect.getdoc(mod.StupidGit),
+                         'A longer,\n\nindented\n\ndocstring.')
+        self.assertEqual(inspect.getdoc(git.abuse),
+                         'Another\n\ndocstring\n\ncontaining\n\ntabs')
+        self.assertEqual(inspect.getdoc(SlotUser.power),
+                         'measured in kilowatts')
+        self.assertEqual(inspect.getdoc(SlotUser.distance),
+                         'measured in kilometers')
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_getdoc_inherited(self):
+        self.assertEqual(inspect.getdoc(mod.FesteringGob),
+                         'A longer,\n\nindented\n\ndocstring.')
+        self.assertEqual(inspect.getdoc(mod.FesteringGob.abuse),
+                         'Another\n\ndocstring\n\ncontaining\n\ntabs')
+        self.assertEqual(inspect.getdoc(mod.FesteringGob().abuse),
+                         'Another\n\ndocstring\n\ncontaining\n\ntabs')
+        self.assertEqual(inspect.getdoc(mod.FesteringGob.contradiction),
+                         'The automatic gainsaying.')
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS, "test requires docstrings")
+    def test_finddoc(self):
+        finddoc = inspect._finddoc
+        self.assertEqual(finddoc(int), int.__doc__)
+        self.assertEqual(finddoc(int.to_bytes), int.to_bytes.__doc__)
+        self.assertEqual(finddoc(int().to_bytes), int.to_bytes.__doc__)
+        self.assertEqual(finddoc(int.from_bytes), int.from_bytes.__doc__)
+        self.assertEqual(finddoc(int.real), int.real.__doc__)
+
+    cleandoc_testdata = [
+        # first line should have different margin
+        (' An\n  indented\n   docstring.', 'An\nindented\n docstring.'),
+        # trailing whitespace are not removed.
+        (' An \n   \n  indented \n   docstring. ',
+         'An \n \nindented \n docstring. '),
+        # NUL is not termination.
+        ('doc\0string\n\n  second\0line\n  third\0line\0',
+         'doc\0string\n\nsecond\0line\nthird\0line\0'),
+        # first line is lstrip()-ped. other lines are kept when no margin.[w:
+        ('   ', ''),
+        # compiler.cleandoc() doesn't strip leading/trailing newlines
+        # to keep maximum backward compatibility.
+        # inspect.cleandoc() removes them.
+        ('\n\n\n  first paragraph\n\n   second paragraph\n\n',
+         '\n\n\nfirst paragraph\n\n second paragraph\n\n'),
+        ('   \n \n  \n   ', '\n \n  \n   '),
+    ]
+
+    def test_cleandoc(self):
+        func = inspect.cleandoc
+        for i, (input, expected) in enumerate(self.cleandoc_testdata):
+            # only inspect.cleandoc() strip \n
+            expected = expected.strip('\n')
+            with self.subTest(i=i):
+                self.assertEqual(func(input), expected)
+
+    @cpython_only
+    def test_c_cleandoc(self):
+        try:
+            import _testinternalcapi
+        except ImportError:
+            return unittest.skip("requires _testinternalcapi")
+        func = _testinternalcapi.compiler_cleandoc
+        for i, (input, expected) in enumerate(self.cleandoc_testdata):
+            with self.subTest(i=i):
+                self.assertEqual(func(input), expected)
+
+    def test_getcomments(self):
+        self.assertEqual(inspect.getcomments(mod), '# line 1\n')
+        self.assertEqual(inspect.getcomments(mod.StupidGit), '# line 20\n')
+        self.assertEqual(inspect.getcomments(mod2.cls160), '# line 159\n')
+        # If the object source file is not available, return None.
+        co = compile('x=1', '_non_existing_filename.py', 'exec')
+        self.assertIsNone(inspect.getcomments(co))
+        # If the object has been defined in C, return None.
+        self.assertIsNone(inspect.getcomments(list))
+
+    def test_getmodule(self):
+        # Check actual module
+        self.assertEqual(inspect.getmodule(mod), mod)
+        # Check class (uses __module__ attribute)
+        self.assertEqual(inspect.getmodule(mod.StupidGit), mod)
+        # Check a method (no __module__ attribute, falls back to filename)
+        self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
+        # Do it again (check the caching isn't broken)
+        self.assertEqual(inspect.getmodule(mod.StupidGit.abuse), mod)
+        # Check a builtin
+        self.assertEqual(inspect.getmodule(str), sys.modules["builtins"])
+        # Check filename override
+        self.assertEqual(inspect.getmodule(None, modfile), mod)
+
+    def test_getmodule_file_not_found(self):
+        # See bpo-45406
+        def _getabsfile(obj, _filename):
+            raise FileNotFoundError('bad file')
+        with unittest.mock.patch('inspect.getabsfile', _getabsfile):
+            f = inspect.currentframe()
+            self.assertIsNone(inspect.getmodule(f))
+            inspect.getouterframes(f)  # smoke test
+
+    def test_getframeinfo_get_first_line(self):
+        frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)
+        self.assertEqual(frame_info.code_context[0], "# line 1\n")
+        self.assertEqual(frame_info.code_context[1], "'A module docstring.'\n")
+
+    def test_getsource(self):
+        self.assertSourceEqual(git.abuse, 29, 39)
+        self.assertSourceEqual(mod.StupidGit, 21, 51)
+        self.assertSourceEqual(mod.lobbest, 75, 76)
+        self.assertSourceEqual(mod.after_closing, 120, 120)
+
+    def test_getsourcefile(self):
+        self.assertEqual(normcase(inspect.getsourcefile(mod.spam)), modfile)
+        self.assertEqual(normcase(inspect.getsourcefile(git.abuse)), modfile)
+        fn = "_non_existing_filename_used_for_sourcefile_test.py"
+        co = compile("x=1", fn, "exec")
+        self.assertEqual(inspect.getsourcefile(co), None)
+        linecache.cache[co.co_filename] = (1, None, "None", co.co_filename)
+        try:
+            self.assertEqual(normcase(inspect.getsourcefile(co)), fn)
+        finally:
+            del linecache.cache[co.co_filename]
+
+    def test_getsource_empty_file(self):
+        with temp_cwd() as cwd:
+            with open('empty_file.py', 'w'):
+                pass
+            sys.path.insert(0, cwd)
+            try:
+                import empty_file
+                self.assertEqual(inspect.getsource(empty_file), '\n')
+                self.assertEqual(inspect.getsourcelines(empty_file), (['\n'], 0))
+            finally:
+                sys.path.remove(cwd)
+
+    def test_getfile(self):
+        self.assertEqual(inspect.getfile(mod.StupidGit), mod.__file__)
+
+    def test_getfile_builtin_module(self):
+        with self.assertRaises(TypeError) as e:
+            inspect.getfile(sys)
+        self.assertTrue(str(e.exception).startswith('<module'))
+
+    def test_getfile_builtin_class(self):
+        with self.assertRaises(TypeError) as e:
+            inspect.getfile(int)
+        self.assertTrue(str(e.exception).startswith('<class'))
+
+    def test_getfile_builtin_function_or_method(self):
+        with self.assertRaises(TypeError) as e_abs:
+            inspect.getfile(abs)
+        self.assertIn('expected, got', str(e_abs.exception))
+        with self.assertRaises(TypeError) as e_append:
+            inspect.getfile(list.append)
+        self.assertIn('expected, got', str(e_append.exception))
+
+    @suppress_immortalization()
+    def test_getfile_class_without_module(self):
+        class CM(type):
+            @property
+            def __module__(cls):
+                raise AttributeError
+        class C(metaclass=CM):
+            pass
+        with self.assertRaises(TypeError):
+            inspect.getfile(C)
+
+    def test_getfile_broken_repr(self):
+        class ErrorRepr:
+            def __repr__(self):
+                raise Exception('xyz')
+        er = ErrorRepr()
+        with self.assertRaises(TypeError):
+            inspect.getfile(er)
+
+    def test_getmodule_recursion(self):
+        from types import ModuleType
+        name = '__inspect_dummy'
+        m = sys.modules[name] = ModuleType(name)
+        m.__file__ = "<string>" # hopefully not a real filename...
+        m.__loader__ = "dummy"  # pretend the filename is understood by a loader
+        exec("def x(): pass", m.__dict__)
+        self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')
+        del sys.modules[name]
+        inspect.getmodule(compile('a=10','','single'))
+
+    def test_proceed_with_fake_filename(self):
+        '''doctest monkeypatches linecache to enable inspection'''
+        fn, source = '<test>', 'def x(): pass\n'
+        getlines = linecache.getlines
+        def monkey(filename, module_globals=None):
+            if filename == fn:
+                return source.splitlines(keepends=True)
+            else:
+                return getlines(filename, module_globals)
+        linecache.getlines = monkey
+        try:
+            ns = {}
+            exec(compile(source, fn, 'single'), ns)
+            inspect.getsource(ns["x"])
+        finally:
+            linecache.getlines = getlines
+
+    def test_getsource_on_code_object(self):
+        self.assertSourceEqual(mod.eggs.__code__, 12, 18)
+
+    def test_getsource_on_generated_class(self):
+        A = type('A', (unittest.TestCase,), {})
+        self.assertEqual(inspect.getsourcefile(A), __file__)
+        self.assertEqual(inspect.getfile(A), __file__)
+        self.assertIs(inspect.getmodule(A), sys.modules[__name__])
+        self.assertRaises(OSError, inspect.getsource, A)
+        self.assertRaises(OSError, inspect.getsourcelines, A)
+        self.assertIsNone(inspect.getcomments(A))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getsource_on_class_without_firstlineno(self):
+        __firstlineno__ = 1
+        class C:
+            nonlocal __firstlineno__
+        self.assertRaises(OSError, inspect.getsource, C)
+
+class TestGetsourceStdlib(unittest.TestCase):
+    # Test Python implementations of the stdlib modules
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getsource_stdlib_collections_abc(self):
+        import collections.abc
+        lines, lineno = inspect.getsourcelines(collections.abc.Sequence)
+        self.assertEqual(lines[0], 'class Sequence(Reversible, Collection):\n')
+        src = inspect.getsource(collections.abc.Sequence)
+        self.assertEqual(src.splitlines(True), lines)
+
+    def test_getsource_stdlib_tomllib(self):
+        import tomllib
+        self.assertRaises(OSError, inspect.getsource, tomllib.TOMLDecodeError)
+        self.assertRaises(OSError, inspect.getsourcelines, tomllib.TOMLDecodeError)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getsource_stdlib_abc(self):
+        # Pure Python implementation
+        abc = import_helper.import_fresh_module('abc', blocked=['_abc'])
+        with support.swap_item(sys.modules, 'abc', abc):
+            self.assertRaises(OSError, inspect.getsource, abc.ABCMeta)
+            self.assertRaises(OSError, inspect.getsourcelines, abc.ABCMeta)
+        # With C acceleration
+        import abc
+        try:
+            src = inspect.getsource(abc.ABCMeta)
+            lines, lineno = inspect.getsourcelines(abc.ABCMeta)
+        except OSError:
+            pass
+        else:
+            self.assertEqual(lines[0], '    class ABCMeta(type):\n')
+            self.assertEqual(src.splitlines(True), lines)
+
+    def test_getsource_stdlib_decimal(self):
+        # Pure Python implementation
+        decimal = import_helper.import_fresh_module('decimal', blocked=['_decimal'])
+        with support.swap_item(sys.modules, 'decimal', decimal):
+            src = inspect.getsource(decimal.Decimal)
+            lines, lineno = inspect.getsourcelines(decimal.Decimal)
+        self.assertEqual(lines[0], 'class Decimal(object):\n')
+        self.assertEqual(src.splitlines(True), lines)
+
+class TestGetsourceInteractive(unittest.TestCase):
+    @support.force_not_colorized
+    def test_getclasses_interactive(self):
+        # bpo-44648: simulate a REPL session;
+        # there is no `__file__` in the __main__ module
+        code = "import sys, inspect; \
+                assert not hasattr(sys.modules['__main__'], '__file__'); \
+                A = type('A', (), {}); \
+                inspect.getsource(A)"
+        _, _, stderr = assert_python_failure("-c", code, __isolated=True)
+        self.assertIn(b'OSError: source code not available', stderr)
+
+class TestGettingSourceOfToplevelFrames(GetSourceBase):
+    fodderModule = mod
+
+    def test_range_toplevel_frame(self):
+        self.maxDiff = None
+        self.assertSourceEqual(mod.currentframe, 1, None)
+
+    def test_range_traceback_toplevel_frame(self):
+        self.assertSourceEqual(mod.tb, 1, None)
+
+class TestDecorators(GetSourceBase):
+    fodderModule = mod2
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_wrapped_decorator(self):
+        self.assertSourceEqual(mod2.wrapped, 14, 17)
+
+    def test_replacing_decorator(self):
+        self.assertSourceEqual(mod2.gone, 9, 10)
+
+    def test_getsource_unwrap(self):
+        self.assertSourceEqual(mod2.real, 130, 132)
+
+    def test_decorator_with_lambda(self):
+        self.assertSourceEqual(mod2.func114, 113, 115)
+
+class TestOneliners(GetSourceBase):
+    fodderModule = mod2
+    def test_oneline_lambda(self):
+        # Test inspect.getsource with a one-line lambda function.
+        self.assertSourceEqual(mod2.oll, 25, 25)
+
+    def test_threeline_lambda(self):
+        # Test inspect.getsource with a three-line lambda function,
+        # where the second and third lines are _not_ indented.
+        self.assertSourceEqual(mod2.tll, 28, 30)
+
+    def test_twoline_indented_lambda(self):
+        # Test inspect.getsource with a two-line lambda function,
+        # where the second line _is_ indented.
+        self.assertSourceEqual(mod2.tlli, 33, 34)
+
+    def test_parenthesized_multiline_lambda(self):
+        # Test inspect.getsource with a parenthesized multi-line lambda
+        # function.
+        self.assertSourceEqual(mod2.parenthesized_lambda, 279, 279)
+        self.assertSourceEqual(mod2.parenthesized_lambda2, 281, 281)
+        self.assertSourceEqual(mod2.parenthesized_lambda3, 283, 283)
+
+    def test_post_line_parenthesized_lambda(self):
+        # Test inspect.getsource with a parenthesized multi-line lambda
+        # function.
+        self.assertSourceEqual(mod2.post_line_parenthesized_lambda1, 286, 287)
+
+    def test_nested_lambda(self):
+        # Test inspect.getsource with a nested lambda function.
+        self.assertSourceEqual(mod2.nested_lambda, 291, 292)
+
+    def test_onelinefunc(self):
+        # Test inspect.getsource with a regular one-line function.
+        self.assertSourceEqual(mod2.onelinefunc, 37, 37)
+
+    def test_manyargs(self):
+        # Test inspect.getsource with a regular function where
+        # the arguments are on two lines and _not_ indented and
+        # the body on the second line with the last arguments.
+        self.assertSourceEqual(mod2.manyargs, 40, 41)
+
+    def test_twolinefunc(self):
+        # Test inspect.getsource with a regular function where
+        # the body is on two lines, following the argument list and
+        # continued on the next line by a \\.
+        self.assertSourceEqual(mod2.twolinefunc, 44, 45)
+
+    def test_lambda_in_list(self):
+        # Test inspect.getsource with a one-line lambda function
+        # defined in a list, indented.
+        self.assertSourceEqual(mod2.a[1], 49, 49)
+
+    def test_anonymous(self):
+        # Test inspect.getsource with a lambda function defined
+        # as argument to another function.
+        self.assertSourceEqual(mod2.anonymous, 55, 55)
+
+    def test_enum(self):
+        self.assertSourceEqual(mod2.enum322, 322, 323)
+        self.assertSourceEqual(mod2.enum326, 326, 327)
+        self.assertSourceEqual(mod2.flag330, 330, 331)
+        self.assertSourceEqual(mod2.flag334, 334, 335)
+        self.assertRaises(OSError, inspect.getsource, mod2.simple_enum338)
+        self.assertRaises(OSError, inspect.getsource, mod2.simple_enum339)
+        self.assertRaises(OSError, inspect.getsource, mod2.simple_flag340)
+        self.assertRaises(OSError, inspect.getsource, mod2.simple_flag341)
+
+    def test_namedtuple(self):
+        self.assertSourceEqual(mod2.nt346, 346, 348)
+        self.assertRaises(OSError, inspect.getsource, mod2.nt351)
+
+    def test_typeddict(self):
+        self.assertSourceEqual(mod2.td354, 354, 356)
+        self.assertRaises(OSError, inspect.getsource, mod2.td359)
+
+    def test_dataclass(self):
+        self.assertSourceEqual(mod2.dc364, 364, 367)
+        self.assertRaises(OSError, inspect.getsource, mod2.dc370)
+        self.assertRaises(OSError, inspect.getsource, mod2.dc371)
+
+class TestBlockComments(GetSourceBase):
+    fodderModule = mod
+
+    def test_toplevel_class(self):
+        self.assertSourceEqual(mod.WhichComments, 96, 114)
+
+    def test_class_method(self):
+        self.assertSourceEqual(mod.WhichComments.f, 99, 104)
+
+    def test_class_async_method(self):
+        self.assertSourceEqual(mod.WhichComments.asyncf, 109, 112)
+
+class TestBuggyCases(GetSourceBase):
+    fodderModule = mod2
+
+    def test_with_comment(self):
+        self.assertSourceEqual(mod2.with_comment, 58, 59)
+
+    def test_multiline_sig(self):
+        self.assertSourceEqual(mod2.multiline_sig[0], 63, 64)
+
+    def test_nested_class(self):
+        self.assertSourceEqual(mod2.func69().func71, 71, 72)
+
+    def test_one_liner_followed_by_non_name(self):
+        self.assertSourceEqual(mod2.func77, 77, 77)
+
+    def test_one_liner_dedent_non_name(self):
+        self.assertSourceEqual(mod2.cls82.func83, 83, 83)
+
+    def test_with_comment_instead_of_docstring(self):
+        self.assertSourceEqual(mod2.func88, 88, 90)
+
+    def test_method_in_dynamic_class(self):
+        self.assertSourceEqual(mod2.method_in_dynamic_class, 95, 97)
+
+    # This should not skip for CPython, but might on a repackaged python where
+    # unicodedata is not an external module, or on pypy.
+    @unittest.skipIf(not hasattr(unicodedata, '__file__') or
+                                 unicodedata.__file__.endswith('.py'),
+                     "unicodedata is not an external binary module")
+    def test_findsource_binary(self):
+        self.assertRaises(OSError, inspect.getsource, unicodedata)
+        self.assertRaises(OSError, inspect.findsource, unicodedata)
+
+    def test_findsource_code_in_linecache(self):
+        lines = ["x=1"]
+        co = compile(lines[0], "_dynamically_created_file", "exec")
+        self.assertRaises(OSError, inspect.findsource, co)
+        self.assertRaises(OSError, inspect.getsource, co)
+        linecache.cache[co.co_filename] = (1, None, lines, co.co_filename)
+        try:
+            self.assertEqual(inspect.findsource(co), (lines,0))
+            self.assertEqual(inspect.getsource(co), lines[0])
+        finally:
+            del linecache.cache[co.co_filename]
+
+    def test_findsource_without_filename(self):
+        for fname in ['', '<string>']:
+            co = compile('x=1', fname, "exec")
+            self.assertRaises(IOError, inspect.findsource, co)
+            self.assertRaises(IOError, inspect.getsource, co)
+
+    def test_findsource_on_func_with_out_of_bounds_lineno(self):
+        mod_len = len(inspect.getsource(mod))
+        src = '\n' * 2* mod_len + "def f(): pass"
+        co = compile(src, mod.__file__, "exec")
+        g, l = {}, {}
+        eval(co, g, l)
+        func = l['f']
+        self.assertEqual(func.__code__.co_firstlineno, 1+2*mod_len)
+        with self.assertRaisesRegex(OSError, "lineno is out of bounds"):
+            inspect.findsource(func)
+
+    def test_findsource_on_class_with_out_of_bounds_lineno(self):
+        mod_len = len(inspect.getsource(mod))
+        src = '\n' * 2* mod_len + "class A: pass"
+        co = compile(src, mod.__file__, "exec")
+        g, l = {'__name__': mod.__name__}, {}
+        eval(co, g, l)
+        cls = l['A']
+        self.assertEqual(cls.__firstlineno__, 1+2*mod_len)
+        with self.assertRaisesRegex(OSError, "lineno is out of bounds"):
+            inspect.findsource(cls)
+
+    def test_getsource_on_method(self):
+        self.assertSourceEqual(mod2.ClassWithMethod.method, 118, 119)
+
+    def test_getsource_on_class_code_object(self):
+        self.assertSourceEqual(mod2.ClassWithCodeObject.code, 315, 317)
+
+    def test_nested_func(self):
+        self.assertSourceEqual(mod2.cls135.func136, 136, 139)
+
+    def test_class_definition_in_multiline_string_definition(self):
+        self.assertSourceEqual(mod2.cls149, 149, 152)
+
+    def test_class_definition_in_multiline_comment(self):
+        self.assertSourceEqual(mod2.cls160, 160, 163)
+
+    def test_nested_class_definition_indented_string(self):
+        self.assertSourceEqual(mod2.cls173.cls175, 175, 176)
+
+    def test_nested_class_definition(self):
+        self.assertSourceEqual(mod2.cls183, 183, 188)
+        self.assertSourceEqual(mod2.cls183.cls185, 185, 188)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_class_decorator(self):
+        self.assertSourceEqual(mod2.cls196, 194, 201)
+        self.assertSourceEqual(mod2.cls196.cls200, 198, 201)
+
+    @support.requires_docstrings
+    def test_class_inside_conditional(self):
+        # We skip this test when docstrings are not present,
+        # because docstrings are one of the main factors of
+        # finding the correct class in the source code.
+        self.assertSourceEqual(mod2.cls238.cls239, 239, 240)
+
+    def test_multiple_children_classes(self):
+        self.assertSourceEqual(mod2.cls203, 203, 209)
+        self.assertSourceEqual(mod2.cls203.cls204, 204, 206)
+        self.assertSourceEqual(mod2.cls203.cls204.cls205, 205, 206)
+        self.assertSourceEqual(mod2.cls203.cls207, 207, 209)
+        self.assertSourceEqual(mod2.cls203.cls207.cls205, 208, 209)
+
+    def test_nested_class_definition_inside_function(self):
+        self.assertSourceEqual(mod2.func212(), 213, 214)
+        self.assertSourceEqual(mod2.cls213, 218, 222)
+        self.assertSourceEqual(mod2.cls213().func219(), 220, 221)
+
+    def test_class_with_method_from_other_module(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            with open(os.path.join(tempdir, 'inspect_actual%spy' % os.extsep),
+                      'w', encoding='utf-8') as f:
+                f.write(textwrap.dedent("""
+                    import inspect_other
+                    class A:
+                        def f(self):
+                            pass
+                    class A:
+                        def f(self):
+                            pass  # correct one
+                    A.f = inspect_other.A.f
+                    """))
+
+            with open(os.path.join(tempdir, 'inspect_other%spy' % os.extsep),
+                      'w', encoding='utf-8') as f:
+                f.write(textwrap.dedent("""
+                    class A:
+                        def f(self):
+                            pass
+                    """))
+
+            with DirsOnSysPath(tempdir):
+                import inspect_actual
+                self.assertIn("correct", inspect.getsource(inspect_actual.A))
+                # Remove the module from sys.modules to force it to be reloaded.
+                # This is necessary when the test is run multiple times.
+                sys.modules.pop("inspect_actual")
+
+    @unittest.skipIf(
+        support.is_emscripten or support.is_wasi,
+        "socket.accept is broken"
+    )
+    def test_nested_class_definition_inside_async_function(self):
+        import asyncio
+        self.addCleanup(asyncio.set_event_loop_policy, None)
+        self.assertSourceEqual(asyncio.run(mod2.func225()), 226, 227)
+        self.assertSourceEqual(mod2.cls226, 231, 235)
+        self.assertSourceEqual(mod2.cls226.func232, 232, 235)
+        self.assertSourceEqual(asyncio.run(mod2.cls226().func232()), 233, 234)
+
+    def test_class_definition_same_name_diff_methods(self):
+        self.assertSourceEqual(mod2.cls296, 296, 298)
+        self.assertSourceEqual(mod2.cls310, 310, 312)
+
+    def test_generator_expression(self):
+        self.assertSourceEqual(next(mod2.ge377), 377, 380)
+        self.assertSourceEqual(next(mod2.func383()), 385, 388)
+
+    def test_comment_or_empty_line_after_decorator(self):
+        self.assertSourceEqual(mod2.func394, 392, 395)
+        self.assertSourceEqual(mod2.func400, 398, 401)
+
+
+class TestNoEOL(GetSourceBase):
+    def setUp(self):
+        self.tempdir = TESTFN + '_dir'
+        os.mkdir(self.tempdir)
+        with open(os.path.join(self.tempdir, 'inspect_fodder3%spy' % os.extsep),
+                  'w', encoding='utf-8') as f:
+            f.write("class X:\n    pass # No EOL")
+        with DirsOnSysPath(self.tempdir):
+            import inspect_fodder3 as mod3
+        self.fodderModule = mod3
+        super().setUp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+
+    def test_class(self):
+        self.assertSourceEqual(self.fodderModule.X, 1, 2)
+
+
+class TestComplexDecorator(GetSourceBase):
+    fodderModule = mod2
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_parens_in_decorator(self):
+        self.assertSourceEqual(self.fodderModule.complex_decorated, 273, 275)
+
+class _BrokenDataDescriptor(object):
+    """
+    A broken data descriptor. See bug #1785.
+    """
+    def __get__(*args):
+        raise AttributeError("broken data descriptor")
+
+    def __set__(*args):
+        raise RuntimeError
+
+    def __getattr__(*args):
+        raise AttributeError("broken data descriptor")
+
+
+class _BrokenMethodDescriptor(object):
+    """
+    A broken method descriptor. See bug #1785.
+    """
+    def __get__(*args):
+        raise AttributeError("broken method descriptor")
+
+    def __getattr__(*args):
+        raise AttributeError("broken method descriptor")
+
+
+# Helper for testing classify_class_attrs.
+def attrs_wo_objs(cls):
+    return [t[:3] for t in inspect.classify_class_attrs(cls)]
+
+
+class TestClassesAndFunctions(unittest.TestCase):
+    def test_newstyle_mro(self):
+        # The same w/ new-class MRO.
+        class A(object):    pass
+        class B(A): pass
+        class C(A): pass
+        class D(B, C): pass
+
+        expected = (D, B, C, A, object)
+        got = inspect.getmro(D)
+        self.assertEqual(expected, got)
+
+    def assertFullArgSpecEquals(self, routine, args_e, varargs_e=None,
+                                    varkw_e=None, defaults_e=None,
+                                    posonlyargs_e=[], kwonlyargs_e=[],
+                                    kwonlydefaults_e=None,
+                                    ann_e={}):
+        args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, ann = \
+            inspect.getfullargspec(routine)
+        self.assertEqual(args, args_e)
+        self.assertEqual(varargs, varargs_e)
+        self.assertEqual(varkw, varkw_e)
+        self.assertEqual(defaults, defaults_e)
+        self.assertEqual(kwonlyargs, kwonlyargs_e)
+        self.assertEqual(kwonlydefaults, kwonlydefaults_e)
+        self.assertEqual(ann, ann_e)
+
+    def test_getfullargspec(self):
+        self.assertFullArgSpecEquals(mod2.keyworded, [], varargs_e='arg1',
+                                     kwonlyargs_e=['arg2'],
+                                     kwonlydefaults_e={'arg2':1})
+
+        self.assertFullArgSpecEquals(mod2.annotated, ['arg1'],
+                                     ann_e={'arg1' : list})
+        self.assertFullArgSpecEquals(mod2.keyword_only_arg, [],
+                                     kwonlyargs_e=['arg'])
+
+        self.assertFullArgSpecEquals(mod2.all_markers, ['a', 'b', 'c', 'd'],
+                                     kwonlyargs_e=['e', 'f'])
+
+        self.assertFullArgSpecEquals(mod2.all_markers_with_args_and_kwargs,
+                                     ['a', 'b', 'c', 'd'],
+                                     varargs_e='args',
+                                     varkw_e='kwargs',
+                                     kwonlyargs_e=['e', 'f'])
+
+        self.assertFullArgSpecEquals(mod2.all_markers_with_defaults, ['a', 'b', 'c', 'd'],
+                                     defaults_e=(1,2,3),
+                                     kwonlyargs_e=['e', 'f'],
+                                     kwonlydefaults_e={'e': 4, 'f': 5})
+
+    def test_argspec_api_ignores_wrapped(self):
+        # Issue 20684: low level introspection API must ignore __wrapped__
+        @functools.wraps(mod.spam)
+        def ham(x, y):
+            pass
+        # Basic check
+        self.assertFullArgSpecEquals(ham, ['x', 'y'])
+        self.assertFullArgSpecEquals(functools.partial(ham),
+                                     ['x', 'y'])
+
+    def test_getfullargspec_signature_attr(self):
+        def test():
+            pass
+        spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY)
+        test.__signature__ = inspect.Signature(parameters=(spam_param,))
+
+        self.assertFullArgSpecEquals(test, ['spam'])
+
+    def test_getfullargspec_signature_annos(self):
+        def test(a:'spam') -> 'ham': pass
+        spec = inspect.getfullargspec(test)
+        self.assertEqual(test.__annotations__, spec.annotations)
+
+        def test(): pass
+        spec = inspect.getfullargspec(test)
+        self.assertEqual(test.__annotations__, spec.annotations)
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    @unittest.skipIf(_pickle is None, "requires _pickle")
+    def test_getfullargspec_builtin_methods(self):
+        self.assertFullArgSpecEquals(_pickle.Pickler.dump, ['self', 'obj'])
+
+        self.assertFullArgSpecEquals(_pickle.Pickler(io.BytesIO()).dump, ['self', 'obj'])
+
+        self.assertFullArgSpecEquals(
+             os.stat,
+             args_e=['path'],
+             kwonlyargs_e=['dir_fd', 'follow_symlinks'],
+             kwonlydefaults_e={'dir_fd': None, 'follow_symlinks': True})
+
+    @cpython_only
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_getfullargspec_builtin_func(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        builtin = _testcapi.docstring_with_signature_with_defaults
+        spec = inspect.getfullargspec(builtin)
+        self.assertEqual(spec.defaults[0], 'avocado')
+
+    @cpython_only
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_getfullargspec_builtin_func_no_signature(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        builtin = _testcapi.docstring_no_signature
+        with self.assertRaises(TypeError):
+            inspect.getfullargspec(builtin)
+
+        cls = _testcapi.DocStringNoSignatureTest
+        obj = _testcapi.DocStringNoSignatureTest()
+        tests = [
+            (_testcapi.docstring_no_signature_noargs, meth_noargs),
+            (_testcapi.docstring_no_signature_o, meth_o),
+            (cls.meth_noargs, meth_self_noargs),
+            (cls.meth_o, meth_self_o),
+            (obj.meth_noargs, meth_self_noargs),
+            (obj.meth_o, meth_self_o),
+            (cls.meth_noargs_class, meth_type_noargs),
+            (cls.meth_o_class, meth_type_o),
+            (cls.meth_noargs_static, meth_noargs),
+            (cls.meth_o_static, meth_o),
+            (cls.meth_noargs_coexist, meth_self_noargs),
+            (cls.meth_o_coexist, meth_self_o),
+
+            (time.time, meth_noargs),
+            (str.lower, meth_self_noargs),
+            (''.lower, meth_self_noargs),
+            (set.add, meth_self_o),
+            (set().add, meth_self_o),
+            (set.__contains__, meth_self_o),
+            (set().__contains__, meth_self_o),
+            (datetime.datetime.__dict__['utcnow'], meth_type_noargs),
+            (datetime.datetime.utcnow, meth_type_noargs),
+            (dict.__dict__['__class_getitem__'], meth_type_o),
+            (dict.__class_getitem__, meth_type_o),
+        ]
+        try:
+            import _stat
+        except ImportError:
+            # if the _stat extension is not available, stat.S_IMODE() is
+            # implemented in Python, not in C
+            pass
+        else:
+            tests.append((stat.S_IMODE, meth_o))
+        for builtin, template in tests:
+            with self.subTest(builtin):
+                self.assertEqual(inspect.getfullargspec(builtin),
+                                 inspect.getfullargspec(template))
+
+    def test_getfullargspec_definition_order_preserved_on_kwonly(self):
+        for fn in signatures_with_lexicographic_keyword_only_parameters():
+            signature = inspect.getfullargspec(fn)
+            l = list(signature.kwonlyargs)
+            sorted_l = sorted(l)
+            self.assertTrue(l)
+            self.assertEqual(l, sorted_l)
+        signature = inspect.getfullargspec(unsorted_keyword_only_parameters_fn)
+        l = list(signature.kwonlyargs)
+        self.assertEqual(l, unsorted_keyword_only_parameters)
+
+    def test_classify_newstyle(self):
+        class A(object):
+
+            def s(): pass
+            s = staticmethod(s)
+
+            def c(cls): pass
+            c = classmethod(c)
+
+            def getp(self): pass
+            p = property(getp)
+
+            def m(self): pass
+
+            def m1(self): pass
+
+            datablob = '1'
+
+            dd = _BrokenDataDescriptor()
+            md = _BrokenMethodDescriptor()
+
+        attrs = attrs_wo_objs(A)
+
+        self.assertIn(('__new__', 'static method', object), attrs,
+                      'missing __new__')
+        self.assertIn(('__init__', 'method', object), attrs, 'missing __init__')
+
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'class method', A), attrs, 'missing class method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', A), attrs,
+                      'missing plain method: %r' % attrs)
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+        self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+        self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
+
+        class B(A):
+
+            def m(self): pass
+
+        attrs = attrs_wo_objs(B)
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'class method', A), attrs, 'missing class method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', B), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+        self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+        self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
+
+
+        class C(A):
+
+            def m(self): pass
+            def c(self): pass
+
+        attrs = attrs_wo_objs(C)
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', A), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+        self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+        self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
+
+        class D(B, C):
+
+            def m1(self): pass
+
+        attrs = attrs_wo_objs(D)
+        self.assertIn(('s', 'static method', A), attrs, 'missing static method')
+        self.assertIn(('c', 'method', C), attrs, 'missing plain method')
+        self.assertIn(('p', 'property', A), attrs, 'missing property')
+        self.assertIn(('m', 'method', B), attrs, 'missing plain method')
+        self.assertIn(('m1', 'method', D), attrs, 'missing plain method')
+        self.assertIn(('datablob', 'data', A), attrs, 'missing data')
+        self.assertIn(('md', 'method', A), attrs, 'missing method descriptor')
+        self.assertIn(('dd', 'data', A), attrs, 'missing data descriptor')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_classify_builtin_types(self):
+        # Simple sanity check that all built-in types can have their
+        # attributes classified.
+        for name in dir(__builtins__):
+            builtin = getattr(__builtins__, name)
+            if isinstance(builtin, type):
+                inspect.classify_class_attrs(builtin)
+
+        attrs = attrs_wo_objs(bool)
+        self.assertIn(('__new__', 'static method', bool), attrs,
+                      'missing __new__')
+        self.assertIn(('from_bytes', 'class method', int), attrs,
+                      'missing class method')
+        self.assertIn(('to_bytes', 'method', int), attrs,
+                      'missing plain method')
+        self.assertIn(('__add__', 'method', int), attrs,
+                      'missing plain method')
+        self.assertIn(('__and__', 'method', bool), attrs,
+                      'missing plain method')
+
+    def test_classify_DynamicClassAttribute(self):
+        class Meta(type):
+            def __getattr__(self, name):
+                if name == 'ham':
+                    return 'spam'
+                return super().__getattr__(name)
+        class VA(metaclass=Meta):
+            @types.DynamicClassAttribute
+            def ham(self):
+                return 'eggs'
+        should_find_dca = inspect.Attribute('ham', 'data', VA, VA.__dict__['ham'])
+        self.assertIn(should_find_dca, inspect.classify_class_attrs(VA))
+        should_find_ga = inspect.Attribute('ham', 'data', Meta, 'spam')
+        self.assertIn(should_find_ga, inspect.classify_class_attrs(VA))
+
+    def test_classify_overrides_bool(self):
+        class NoBool(object):
+            def __eq__(self, other):
+                return NoBool()
+
+            def __bool__(self):
+                raise NotImplementedError(
+                    "This object does not specify a boolean value")
+
+        class HasNB(object):
+            dd = NoBool()
+
+        should_find_attr = inspect.Attribute('dd', 'data', HasNB, HasNB.dd)
+        self.assertIn(should_find_attr, inspect.classify_class_attrs(HasNB))
+
+    def test_classify_metaclass_class_attribute(self):
+        class Meta(type):
+            fish = 'slap'
+            def __dir__(self):
+                return ['__class__', '__module__', '__name__', 'fish']
+        class Class(metaclass=Meta):
+            pass
+        should_find = inspect.Attribute('fish', 'data', Meta, 'slap')
+        self.assertIn(should_find, inspect.classify_class_attrs(Class))
+
+    def test_classify_VirtualAttribute(self):
+        class Meta(type):
+            def __dir__(cls):
+                return ['__class__', '__module__', '__name__', 'BOOM']
+            def __getattr__(self, name):
+                if name =='BOOM':
+                    return 42
+                return super().__getattr(name)
+        class Class(metaclass=Meta):
+            pass
+        should_find = inspect.Attribute('BOOM', 'data', Meta, 42)
+        self.assertIn(should_find, inspect.classify_class_attrs(Class))
+
+    def test_classify_VirtualAttribute_multi_classes(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
+
+        should_find1 = inspect.Attribute('one', 'data', Meta1, 1)
+        should_find2 = inspect.Attribute('two', 'data', Meta2, 2)
+        should_find3 = inspect.Attribute('three', 'data', Meta3, 3)
+        cca = inspect.classify_class_attrs(Class2)
+        for sf in (should_find1, should_find2, should_find3):
+            self.assertIn(sf, cca)
+
+    def test_classify_class_attrs_with_buggy_dir(self):
+        class M(type):
+            def __dir__(cls):
+                return ['__class__', '__name__', 'missing']
+        class C(metaclass=M):
+            pass
+        attrs = [a[0] for a in inspect.classify_class_attrs(C)]
+        self.assertNotIn('missing', attrs)
+
+    def test_getmembers_descriptors(self):
+        class A(object):
+            dd = _BrokenDataDescriptor()
+            md = _BrokenMethodDescriptor()
+
+        def pred_wrapper(pred):
+            # A quick'n'dirty way to discard standard attributes of new-style
+            # classes.
+            class Empty(object):
+                pass
+            def wrapped(x):
+                if '__name__' in dir(x) and hasattr(Empty, x.__name__):
+                    return False
+                return pred(x)
+            return wrapped
+
+        ismethoddescriptor = pred_wrapper(inspect.ismethoddescriptor)
+        isdatadescriptor = pred_wrapper(inspect.isdatadescriptor)
+
+        self.assertEqual(inspect.getmembers(A, ismethoddescriptor),
+            [('md', A.__dict__['md'])])
+        self.assertEqual(inspect.getmembers(A, isdatadescriptor),
+            [('dd', A.__dict__['dd'])])
+
+        class B(A):
+            pass
+
+        self.assertEqual(inspect.getmembers(B, ismethoddescriptor),
+            [('md', A.__dict__['md'])])
+        self.assertEqual(inspect.getmembers(B, isdatadescriptor),
+            [('dd', A.__dict__['dd'])])
+
+    def test_getmembers_method(self):
+        class B:
+            def f(self):
+                pass
+
+        self.assertIn(('f', B.f), inspect.getmembers(B))
+        self.assertNotIn(('f', B.f), inspect.getmembers(B, inspect.ismethod))
+        b = B()
+        self.assertIn(('f', b.f), inspect.getmembers(b))
+        self.assertIn(('f', b.f), inspect.getmembers(b, inspect.ismethod))
+
+    def test_getmembers_custom_dir(self):
+        class CorrectDir:
+            def __init__(self, attr):
+                self.attr = attr
+            def method(self):
+                return self.attr + 1
+            def __dir__(self):
+                return ['attr', 'method']
+
+        cd = CorrectDir(5)
+        self.assertEqual(inspect.getmembers(cd), [
+            ('attr', 5),
+            ('method', cd.method),
+        ])
+        self.assertEqual(inspect.getmembers(cd, inspect.ismethod), [
+            ('method', cd.method),
+        ])
+
+    def test_getmembers_custom_broken_dir(self):
+        # inspect.getmembers calls `dir()` on the passed object inside.
+        # if `__dir__` mentions some non-existent attribute,
+        # we still need to return others correctly.
+        class BrokenDir:
+            existing = 1
+            def method(self):
+                return self.existing + 1
+            def __dir__(self):
+                return ['method', 'missing', 'existing']
+
+        bd = BrokenDir()
+        self.assertEqual(inspect.getmembers(bd), [
+            ('existing', 1),
+            ('method', bd.method),
+        ])
+        self.assertEqual(inspect.getmembers(bd, inspect.ismethod), [
+            ('method', bd.method),
+        ])
+
+    def test_getmembers_custom_duplicated_dir(self):
+        # Duplicates in `__dir__` must not fail and return just one result.
+        class DuplicatedDir:
+            attr = 1
+            def __dir__(self):
+                return ['attr', 'attr']
+
+        dd = DuplicatedDir()
+        self.assertEqual(inspect.getmembers(dd), [
+            ('attr', 1),
+        ])
+
+    def test_getmembers_VirtualAttribute(self):
+        class M(type):
+            def __getattr__(cls, name):
+                if name == 'eggs':
+                    return 'scrambled'
+                return super().__getattr__(name)
+        class A(metaclass=M):
+            @types.DynamicClassAttribute
+            def eggs(self):
+                return 'spam'
+        class B:
+            def __getattr__(self, attribute):
+                return None
+        self.assertIn(('eggs', 'scrambled'), inspect.getmembers(A))
+        self.assertIn(('eggs', 'spam'), inspect.getmembers(A()))
+        b = B()
+        self.assertIn(('__getattr__', b.__getattr__), inspect.getmembers(b))
+
+    def test_getmembers_static(self):
+        class A:
+            @property
+            def name(self):
+                raise NotImplementedError
+            @types.DynamicClassAttribute
+            def eggs(self):
+                raise NotImplementedError
+
+        a = A()
+        instance_members = inspect.getmembers_static(a)
+        class_members = inspect.getmembers_static(A)
+        self.assertIn(('name', inspect.getattr_static(a, 'name')), instance_members)
+        self.assertIn(('eggs', inspect.getattr_static(a, 'eggs')), instance_members)
+        self.assertIn(('name', inspect.getattr_static(A, 'name')), class_members)
+        self.assertIn(('eggs', inspect.getattr_static(A, 'eggs')), class_members)
+
+    def test_getmembers_with_buggy_dir(self):
+        class M(type):
+            def __dir__(cls):
+                return ['__class__', '__name__', 'missing']
+        class C(metaclass=M):
+            pass
+        attrs = [a[0] for a in inspect.getmembers(C)]
+        self.assertNotIn('missing', attrs)
+
+    def test_get_annotations_with_stock_annotations(self):
+        def foo(a:int, b:str): pass
+        self.assertEqual(inspect.get_annotations(foo), {'a': int, 'b': str})
+
+        foo.__annotations__ = {'a': 'foo', 'b':'str'}
+        self.assertEqual(inspect.get_annotations(foo), {'a': 'foo', 'b': 'str'})
+
+        self.assertEqual(inspect.get_annotations(foo, eval_str=True, locals=locals()), {'a': foo, 'b': str})
+        self.assertEqual(inspect.get_annotations(foo, eval_str=True, globals=locals()), {'a': foo, 'b': str})
+
+        isa = inspect_stock_annotations
+        self.assertEqual(inspect.get_annotations(isa), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.function), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function2), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function3), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(inspect), {}) # inspect module has no annotations
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
+
+        self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': int, 'b': str, 'c': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(inspect, eval_str=True), {})
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
+
+        self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(inspect, eval_str=False), {})
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
+
+        def times_three(fn):
+            @functools.wraps(fn)
+            def wrapper(a, b):
+                return fn(a*3, b*3)
+            return wrapper
+
+        wrapped = times_three(isa.function)
+        self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
+        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
+        self.assertEqual(inspect.get_annotations(wrapped), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': int, 'b': str, 'return': isa.MyClass})
+
+    def test_get_annotations_with_stringized_annotations(self):
+        isa = inspect_stringized_annotations
+        self.assertEqual(inspect.get_annotations(isa), {'a': 'int', 'b': 'str'})
+        self.assertEqual(inspect.get_annotations(isa.MyClass), {'a': 'int', 'b': 'str'})
+        self.assertEqual(inspect.get_annotations(isa.function), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(isa.function2), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(isa.function3), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function), {})
+
+        self.assertEqual(inspect.get_annotations(isa, eval_str=True), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=True), {'a': int, 'b': str})
+        self.assertEqual(inspect.get_annotations(isa.function, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=True), {'a': int, 'b': 'str', 'c': isa.MyClass, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=True), {'a': 'int', 'b': 'str', 'c': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=True), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=True), {})
+
+        self.assertEqual(inspect.get_annotations(isa, eval_str=False), {'a': 'int', 'b': 'str'})
+        self.assertEqual(inspect.get_annotations(isa.MyClass, eval_str=False), {'a': 'int', 'b': 'str'})
+        self.assertEqual(inspect.get_annotations(isa.function, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(isa.function2, eval_str=False), {'a': 'int', 'b': "'str'", 'c': 'MyClass', 'return': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(isa.function3, eval_str=False), {'a': "'int'", 'b': "'str'", 'c': "'MyClass'"})
+        self.assertEqual(inspect.get_annotations(isa.UnannotatedClass, eval_str=False), {})
+        self.assertEqual(inspect.get_annotations(isa.unannotated_function, eval_str=False), {})
+
+        isa2 = inspect_stringized_annotations_2
+        self.assertEqual(inspect.get_annotations(isa2), {})
+        self.assertEqual(inspect.get_annotations(isa2, eval_str=True), {})
+        self.assertEqual(inspect.get_annotations(isa2, eval_str=False), {})
+
+        def times_three(fn):
+            @functools.wraps(fn)
+            def wrapper(a, b):
+                return fn(a*3, b*3)
+            return wrapper
+
+        wrapped = times_three(isa.function)
+        self.assertEqual(wrapped(1, 'x'), isa.MyClass(3, 'xxx'))
+        self.assertIsNot(wrapped.__globals__, isa.function.__globals__)
+        self.assertEqual(inspect.get_annotations(wrapped), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
+        self.assertEqual(inspect.get_annotations(wrapped, eval_str=True), {'a': int, 'b': str, 'return': isa.MyClass})
+        self.assertEqual(inspect.get_annotations(wrapped, eval_str=False), {'a': 'int', 'b': 'str', 'return': 'MyClass'})
+
+        # test that local namespace lookups work
+        self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations), {'x': 'mytype'})
+        self.assertEqual(inspect.get_annotations(isa.MyClassWithLocalAnnotations, eval_str=True), {'x': int})
+
+    def test_pep695_generic_class_with_future_annotations(self):
+        ann_module695 = inspect_stringized_annotations_pep695
+        A_annotations = inspect.get_annotations(ann_module695.A, eval_str=True)
+        A_type_params = ann_module695.A.__type_params__
+        self.assertIs(A_annotations["x"], A_type_params[0])
+        self.assertEqual(A_annotations["y"].__args__[0], Unpack[A_type_params[1]])
+        self.assertIs(A_annotations["z"].__args__[0], A_type_params[2])
+
+    def test_pep695_generic_class_with_future_annotations_and_local_shadowing(self):
+        B_annotations = inspect.get_annotations(
+            inspect_stringized_annotations_pep695.B, eval_str=True
+        )
+        self.assertEqual(B_annotations, {"x": int, "y": str, "z": bytes})
+
+    def test_pep695_generic_class_with_future_annotations_name_clash_with_global_vars(self):
+        ann_module695 = inspect_stringized_annotations_pep695
+        C_annotations = inspect.get_annotations(ann_module695.C, eval_str=True)
+        self.assertEqual(
+            set(C_annotations.values()),
+            set(ann_module695.C.__type_params__)
+        )
+
+    def test_pep_695_generic_function_with_future_annotations(self):
+        ann_module695 = inspect_stringized_annotations_pep695
+        generic_func_annotations = inspect.get_annotations(
+            ann_module695.generic_function, eval_str=True
+        )
+        func_t_params = ann_module695.generic_function.__type_params__
+        self.assertEqual(
+            generic_func_annotations.keys(), {"x", "y", "z", "zz", "return"}
+        )
+        self.assertIs(generic_func_annotations["x"], func_t_params[0])
+        self.assertEqual(generic_func_annotations["y"], Unpack[func_t_params[1]])
+        self.assertIs(generic_func_annotations["z"].__origin__, func_t_params[2])
+        self.assertIs(generic_func_annotations["zz"].__origin__, func_t_params[2])
+
+    def test_pep_695_generic_function_with_future_annotations_name_clash_with_global_vars(self):
+        self.assertEqual(
+            set(
+                inspect.get_annotations(
+                    inspect_stringized_annotations_pep695.generic_function_2,
+                    eval_str=True
+                ).values()
+            ),
+            set(
+                inspect_stringized_annotations_pep695.generic_function_2.__type_params__
+            )
+        )
+
+    def test_pep_695_generic_method_with_future_annotations(self):
+        ann_module695 = inspect_stringized_annotations_pep695
+        generic_method_annotations = inspect.get_annotations(
+            ann_module695.D.generic_method, eval_str=True
+        )
+        params = {
+            param.__name__: param
+            for param in ann_module695.D.generic_method.__type_params__
+        }
+        self.assertEqual(
+            generic_method_annotations,
+            {"x": params["Foo"], "y": params["Bar"], "return": None}
+        )
+
+    def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_vars(self):
+        self.assertEqual(
+            set(
+                inspect.get_annotations(
+                    inspect_stringized_annotations_pep695.D.generic_method_2,
+                    eval_str=True
+                ).values()
+            ),
+            set(
+                inspect_stringized_annotations_pep695.D.generic_method_2.__type_params__
+            )
+        )
+
+    def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_and_local_vars(self):
+        self.assertEqual(
+            inspect.get_annotations(
+                inspect_stringized_annotations_pep695.E, eval_str=True
+            ),
+            {"x": str},
+        )
+
+    def test_pep_695_generics_with_future_annotations_nested_in_function(self):
+        results = inspect_stringized_annotations_pep695.nested()
+
+        self.assertEqual(
+            set(results.F_annotations.values()),
+            set(results.F.__type_params__)
+        )
+        self.assertEqual(
+            set(results.F_meth_annotations.values()),
+            set(results.F.generic_method.__type_params__)
+        )
+        self.assertNotEqual(
+            set(results.F_meth_annotations.values()),
+            set(results.F.__type_params__)
+        )
+        self.assertEqual(
+            set(results.F_meth_annotations.values()).intersection(results.F.__type_params__),
+            set()
+        )
+
+        self.assertEqual(results.G_annotations, {"x": str})
+
+        self.assertEqual(
+            set(results.generic_func_annotations.values()),
+            set(results.generic_func.__type_params__)
+        )
+
+
+class TestFormatAnnotation(unittest.TestCase):
+    def test_typing_replacement(self):
+        from test.typinganndata.ann_module9 import A, ann, ann1
+        self.assertEqual(inspect.formatannotation(ann), 'Union[List[str], int]')
+        self.assertEqual(inspect.formatannotation(ann1), 'Union[List[testModule.typing.A], int]')
+
+        self.assertEqual(inspect.formatannotation(A, 'testModule.typing'), 'A')
+        self.assertEqual(inspect.formatannotation(A, 'other'), 'testModule.typing.A')
+        self.assertEqual(
+            inspect.formatannotation(ann1, 'testModule.typing'),
+            'Union[List[testModule.typing.A], int]',
+        )
+
+    def test_formatannotationrelativeto(self):
+        from test.typinganndata.ann_module9 import A, ann1
+
+        # Builtin types:
+        self.assertEqual(
+            inspect.formatannotationrelativeto(object)(type),
+            'type',
+        )
+
+        # Custom types:
+        self.assertEqual(
+            inspect.formatannotationrelativeto(None)(A),
+            'testModule.typing.A',
+        )
+
+        class B: ...
+        B.__module__ = 'testModule.typing'
+
+        self.assertEqual(
+            inspect.formatannotationrelativeto(B)(A),
+            'A',
+        )
+
+        self.assertEqual(
+            inspect.formatannotationrelativeto(object)(A),
+            'testModule.typing.A',
+        )
+
+        # Not an instance of "type":
+        self.assertEqual(
+            inspect.formatannotationrelativeto(A)(ann1),
+            'Union[List[testModule.typing.A], int]',
+        )
+
+
+class TestIsMethodDescriptor(unittest.TestCase):
+
+    def test_custom_descriptors(self):
+        class MethodDescriptor:
+            def __get__(self, *_): pass
+        class MethodDescriptorSub(MethodDescriptor):
+            pass
+        class DataDescriptorWithNoGet:
+            def __set__(self, *_): pass
+        class DataDescriptorWithGetSet:
+            def __get__(self, *_): pass
+            def __set__(self, *_): pass
+        class DataDescriptorWithGetDelete:
+            def __get__(self, *_): pass
+            def __delete__(self, *_): pass
+        class DataDescriptorSub(DataDescriptorWithNoGet,
+                                DataDescriptorWithGetDelete):
+            pass
+
+        # Custom method descriptors:
+        self.assertTrue(
+            inspect.ismethoddescriptor(MethodDescriptor()),
+            '__get__ and no __set__/__delete__ => method descriptor')
+        self.assertTrue(
+            inspect.ismethoddescriptor(MethodDescriptorSub()),
+            '__get__ (inherited) and no __set__/__delete__'
+            ' => method descriptor')
+
+        # Custom data descriptors:
+        self.assertFalse(
+            inspect.ismethoddescriptor(DataDescriptorWithNoGet()),
+            '__set__ (and no __get__) => not a method descriptor')
+        self.assertFalse(
+            inspect.ismethoddescriptor(DataDescriptorWithGetSet()),
+            '__get__ and __set__ => not a method descriptor')
+        self.assertFalse(
+            inspect.ismethoddescriptor(DataDescriptorWithGetDelete()),
+            '__get__ and __delete__ => not a method descriptor')
+        self.assertFalse(
+            inspect.ismethoddescriptor(DataDescriptorSub()),
+            '__get__, __set__ and __delete__ => not a method descriptor')
+
+        # Classes of descriptors (are *not* descriptors themselves):
+        self.assertFalse(inspect.ismethoddescriptor(MethodDescriptor))
+        self.assertFalse(inspect.ismethoddescriptor(MethodDescriptorSub))
+        self.assertFalse(inspect.ismethoddescriptor(DataDescriptorSub))
+
+    def test_builtin_descriptors(self):
+        builtin_slot_wrapper = int.__add__  # This one is mentioned in docs.
+        class Owner:
+            def instance_method(self): pass
+            @classmethod
+            def class_method(cls): pass
+            @staticmethod
+            def static_method(): pass
+            @property
+            def a_property(self): pass
+        class Slotermeyer:
+            __slots__ = 'a_slot',
+        def function():
+            pass
+        a_lambda = lambda: None
+
+        # Example builtin method descriptors:
+        self.assertTrue(
+            inspect.ismethoddescriptor(builtin_slot_wrapper),
+            'a builtin slot wrapper is a method descriptor')
+        self.assertTrue(
+            inspect.ismethoddescriptor(Owner.__dict__['class_method']),
+            'a classmethod object is a method descriptor')
+        self.assertTrue(
+            inspect.ismethoddescriptor(Owner.__dict__['static_method']),
+            'a staticmethod object is a method descriptor')
+
+        # Example builtin data descriptors:
+        self.assertFalse(
+            inspect.ismethoddescriptor(Owner.__dict__['a_property']),
+            'a property is not a method descriptor')
+        self.assertFalse(
+            inspect.ismethoddescriptor(Slotermeyer.__dict__['a_slot']),
+            'a slot is not a method descriptor')
+
+        # `types.MethodType`/`types.FunctionType` instances (they *are*
+        # method descriptors, but `ismethoddescriptor()` explicitly
+        # excludes them):
+        self.assertFalse(inspect.ismethoddescriptor(Owner().instance_method))
+        self.assertFalse(inspect.ismethoddescriptor(Owner().class_method))
+        self.assertFalse(inspect.ismethoddescriptor(Owner().static_method))
+        self.assertFalse(inspect.ismethoddescriptor(Owner.instance_method))
+        self.assertFalse(inspect.ismethoddescriptor(Owner.class_method))
+        self.assertFalse(inspect.ismethoddescriptor(Owner.static_method))
+        self.assertFalse(inspect.ismethoddescriptor(function))
+        self.assertFalse(inspect.ismethoddescriptor(a_lambda))
+        self.assertFalse(inspect.ismethoddescriptor(functools.partial(function)))
+
+    def test_descriptor_being_a_class(self):
+        class MethodDescriptorMeta(type):
+            def __get__(self, *_): pass
+        class ClassBeingMethodDescriptor(metaclass=MethodDescriptorMeta):
+            pass
+        # `ClassBeingMethodDescriptor` itself *is* a method descriptor,
+        # but it is *also* a class, and `ismethoddescriptor()` explicitly
+        # excludes classes.
+        self.assertFalse(
+            inspect.ismethoddescriptor(ClassBeingMethodDescriptor),
+            'classes (instances of type) are explicitly excluded')
+
+    def test_non_descriptors(self):
+        class Test:
+            pass
+        self.assertFalse(inspect.ismethoddescriptor(Test()))
+        self.assertFalse(inspect.ismethoddescriptor(Test))
+        self.assertFalse(inspect.ismethoddescriptor([42]))
+        self.assertFalse(inspect.ismethoddescriptor(42))
+
+
+class TestIsDataDescriptor(unittest.TestCase):
+
+    def test_custom_descriptors(self):
+        class NonDataDescriptor:
+            def __get__(self, value, type=None): pass
+        class DataDescriptor0:
+            def __set__(self, name, value): pass
+        class DataDescriptor1:
+            def __delete__(self, name): pass
+        class DataDescriptor2:
+            __set__ = None
+        self.assertFalse(inspect.isdatadescriptor(NonDataDescriptor()),
+                         'class with only __get__ not a data descriptor')
+        self.assertTrue(inspect.isdatadescriptor(DataDescriptor0()),
+                        'class with __set__ is a data descriptor')
+        self.assertTrue(inspect.isdatadescriptor(DataDescriptor1()),
+                        'class with __delete__ is a data descriptor')
+        self.assertTrue(inspect.isdatadescriptor(DataDescriptor2()),
+                        'class with __set__ = None is a data descriptor')
+
+    def test_slot(self):
+        class Slotted:
+            __slots__ = 'foo',
+        self.assertTrue(inspect.isdatadescriptor(Slotted.foo),
+                        'a slot is a data descriptor')
+
+    def test_property(self):
+        class Propertied:
+            @property
+            def a_property(self):
+                pass
+        self.assertTrue(inspect.isdatadescriptor(Propertied.a_property),
+                        'a property is a data descriptor')
+
+    def test_functions(self):
+        class Test(object):
+            def instance_method(self): pass
+            @classmethod
+            def class_method(cls): pass
+            @staticmethod
+            def static_method(): pass
+        def function():
+            pass
+        a_lambda = lambda: None
+        self.assertFalse(inspect.isdatadescriptor(Test().instance_method),
+                         'a instance method is not a data descriptor')
+        self.assertFalse(inspect.isdatadescriptor(Test().class_method),
+                         'a class method is not a data descriptor')
+        self.assertFalse(inspect.isdatadescriptor(Test().static_method),
+                         'a static method is not a data descriptor')
+        self.assertFalse(inspect.isdatadescriptor(function),
+                         'a function is not a data descriptor')
+        self.assertFalse(inspect.isdatadescriptor(a_lambda),
+                         'a lambda is not a data descriptor')
+
+
+_global_ref = object()
+class TestGetClosureVars(unittest.TestCase):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_name_resolution(self):
+        # Basic test of the 4 different resolution mechanisms
+        def f(nonlocal_ref):
+            def g(local_ref):
+                print(local_ref, nonlocal_ref, _global_ref, unbound_ref)
+            return g
+        _arg = object()
+        nonlocal_vars = {"nonlocal_ref": _arg}
+        global_vars = {"_global_ref": _global_ref}
+        builtin_vars = {"print": print}
+        unbound_names = {"unbound_ref"}
+        expected = inspect.ClosureVars(nonlocal_vars, global_vars,
+                                       builtin_vars, unbound_names)
+        self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_generator_closure(self):
+        def f(nonlocal_ref):
+            def g(local_ref):
+                print(local_ref, nonlocal_ref, _global_ref, unbound_ref)
+                yield
+            return g
+        _arg = object()
+        nonlocal_vars = {"nonlocal_ref": _arg}
+        global_vars = {"_global_ref": _global_ref}
+        builtin_vars = {"print": print}
+        unbound_names = {"unbound_ref"}
+        expected = inspect.ClosureVars(nonlocal_vars, global_vars,
+                                       builtin_vars, unbound_names)
+        self.assertEqual(inspect.getclosurevars(f(_arg)), expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_method_closure(self):
+        class C:
+            def f(self, nonlocal_ref):
+                def g(local_ref):
+                    print(local_ref, nonlocal_ref, _global_ref, unbound_ref)
+                return g
+        _arg = object()
+        nonlocal_vars = {"nonlocal_ref": _arg}
+        global_vars = {"_global_ref": _global_ref}
+        builtin_vars = {"print": print}
+        unbound_names = {"unbound_ref"}
+        expected = inspect.ClosureVars(nonlocal_vars, global_vars,
+                                       builtin_vars, unbound_names)
+        self.assertEqual(inspect.getclosurevars(C().f(_arg)), expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_attribute_same_name_as_global_var(self):
+        class C:
+            _global_ref = object()
+        def f():
+            print(C._global_ref, _global_ref)
+        nonlocal_vars = {"C": C}
+        global_vars = {"_global_ref": _global_ref}
+        builtin_vars = {"print": print}
+        unbound_names = {"_global_ref"}
+        expected = inspect.ClosureVars(nonlocal_vars, global_vars,
+                                       builtin_vars, unbound_names)
+        self.assertEqual(inspect.getclosurevars(f), expected)
+
+    def test_nonlocal_vars(self):
+        # More complex tests of nonlocal resolution
+        def _nonlocal_vars(f):
+            return inspect.getclosurevars(f).nonlocals
+
+        def make_adder(x):
+            def add(y):
+                return x + y
+            return add
+
+        def curry(func, arg1):
+            return lambda arg2: func(arg1, arg2)
+
+        def less_than(a, b):
+            return a < b
+
+        # The infamous Y combinator.
+        def Y(le):
+            def g(f):
+                return le(lambda x: f(f)(x))
+            Y.g_ref = g
+            return g(g)
+
+        def check_y_combinator(func):
+            self.assertEqual(_nonlocal_vars(func), {'f': Y.g_ref})
+
+        inc = make_adder(1)
+        add_two = make_adder(2)
+        greater_than_five = curry(less_than, 5)
+
+        self.assertEqual(_nonlocal_vars(inc), {'x': 1})
+        self.assertEqual(_nonlocal_vars(add_two), {'x': 2})
+        self.assertEqual(_nonlocal_vars(greater_than_five),
+                         {'arg1': 5, 'func': less_than})
+        self.assertEqual(_nonlocal_vars((lambda x: lambda y: x + y)(3)),
+                         {'x': 3})
+        Y(check_y_combinator)
+
+    def test_getclosurevars_empty(self):
+        def foo(): pass
+        _empty = inspect.ClosureVars({}, {}, {}, set())
+        self.assertEqual(inspect.getclosurevars(lambda: True), _empty)
+        self.assertEqual(inspect.getclosurevars(foo), _empty)
+
+    def test_getclosurevars_error(self):
+        class T: pass
+        self.assertRaises(TypeError, inspect.getclosurevars, 1)
+        self.assertRaises(TypeError, inspect.getclosurevars, list)
+        self.assertRaises(TypeError, inspect.getclosurevars, {})
+
+    def _private_globals(self):
+        code = """def f(): print(path)"""
+        ns = {}
+        exec(code, ns)
+        return ns["f"], ns
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_builtins_fallback(self):
+        f, ns = self._private_globals()
+        ns.pop("__builtins__", None)
+        expected = inspect.ClosureVars({}, {}, {"print":print}, {"path"})
+        self.assertEqual(inspect.getclosurevars(f), expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_builtins_as_dict(self):
+        f, ns = self._private_globals()
+        ns["__builtins__"] = {"path":1}
+        expected = inspect.ClosureVars({}, {}, {"path":1}, {"print"})
+        self.assertEqual(inspect.getclosurevars(f), expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_builtins_as_module(self):
+        f, ns = self._private_globals()
+        ns["__builtins__"] = os
+        expected = inspect.ClosureVars({}, {}, {"path":os.path}, {"print"})
+        self.assertEqual(inspect.getclosurevars(f), expected)
+
+
+class TestGetcallargsFunctions(unittest.TestCase):
+
+    def assertEqualCallArgs(self, func, call_params_string, locs=None):
+        locs = dict(locs or {}, func=func)
+        r1 = eval('func(%s)' % call_params_string, None, locs)
+        r2 = eval('inspect.getcallargs(func, %s)' % call_params_string, None,
+                  locs)
+        self.assertEqual(r1, r2)
+
+    def assertEqualException(self, func, call_param_string, locs=None):
+        locs = dict(locs or {}, func=func)
+        try:
+            eval('func(%s)' % call_param_string, None, locs)
+        except Exception as e:
+            ex1 = e
+        else:
+            self.fail('Exception not raised')
+        try:
+            eval('inspect.getcallargs(func, %s)' % call_param_string, None,
+                 locs)
+        except Exception as e:
+            ex2 = e
+        else:
+            self.fail('Exception not raised')
+        self.assertIs(type(ex1), type(ex2))
+        self.assertEqual(str(ex1), str(ex2))
+        del ex1, ex2
+
+    def makeCallable(self, signature):
+        """Create a function that returns its locals()"""
+        code = "lambda %s: locals()"
+        return eval(code % signature)
+
+    def test_plain(self):
+        f = self.makeCallable('a, b=1')
+        self.assertEqualCallArgs(f, '2')
+        self.assertEqualCallArgs(f, '2, 3')
+        self.assertEqualCallArgs(f, 'a=2')
+        self.assertEqualCallArgs(f, 'b=3, a=2')
+        self.assertEqualCallArgs(f, '2, b=3')
+        # expand *iterable / **mapping
+        self.assertEqualCallArgs(f, '*(2,)')
+        self.assertEqualCallArgs(f, '*[2]')
+        self.assertEqualCallArgs(f, '*(2, 3)')
+        self.assertEqualCallArgs(f, '*[2, 3]')
+        self.assertEqualCallArgs(f, '**{"a":2}')
+        self.assertEqualCallArgs(f, 'b=3, **{"a":2}')
+        self.assertEqualCallArgs(f, '2, **{"b":3}')
+        self.assertEqualCallArgs(f, '**{"b":3, "a":2}')
+        # expand UserList / UserDict
+        self.assertEqualCallArgs(f, '*collections.UserList([2])')
+        self.assertEqualCallArgs(f, '*collections.UserList([2, 3])')
+        self.assertEqualCallArgs(f, '**collections.UserDict(a=2)')
+        self.assertEqualCallArgs(f, '2, **collections.UserDict(b=3)')
+        self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3)')
+
+    def test_varargs(self):
+        f = self.makeCallable('a, b=1, *c')
+        self.assertEqualCallArgs(f, '2')
+        self.assertEqualCallArgs(f, '2, 3')
+        self.assertEqualCallArgs(f, '2, 3, 4')
+        self.assertEqualCallArgs(f, '*(2,3,4)')
+        self.assertEqualCallArgs(f, '2, *[3,4]')
+        self.assertEqualCallArgs(f, '2, 3, *collections.UserList([4])')
+
+    def test_varkw(self):
+        f = self.makeCallable('a, b=1, **c')
+        self.assertEqualCallArgs(f, 'a=2')
+        self.assertEqualCallArgs(f, '2, b=3, c=4')
+        self.assertEqualCallArgs(f, 'b=3, a=2, c=4')
+        self.assertEqualCallArgs(f, 'c=4, **{"a":2, "b":3}')
+        self.assertEqualCallArgs(f, '2, c=4, **{"b":3}')
+        self.assertEqualCallArgs(f, 'b=2, **{"a":3, "c":4}')
+        self.assertEqualCallArgs(f, '**collections.UserDict(a=2, b=3, c=4)')
+        self.assertEqualCallArgs(f, '2, c=4, **collections.UserDict(b=3)')
+        self.assertEqualCallArgs(f, 'b=2, **collections.UserDict(a=3, c=4)')
+
+    def test_varkw_only(self):
+        # issue11256:
+        f = self.makeCallable('**c')
+        self.assertEqualCallArgs(f, '')
+        self.assertEqualCallArgs(f, 'a=1')
+        self.assertEqualCallArgs(f, 'a=1, b=2')
+        self.assertEqualCallArgs(f, 'c=3, **{"a": 1, "b": 2}')
+        self.assertEqualCallArgs(f, '**collections.UserDict(a=1, b=2)')
+        self.assertEqualCallArgs(f, 'c=3, **collections.UserDict(a=1, b=2)')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_keyword_only(self):
+        f = self.makeCallable('a=3, *, c, d=2')
+        self.assertEqualCallArgs(f, 'c=3')
+        self.assertEqualCallArgs(f, 'c=3, a=3')
+        self.assertEqualCallArgs(f, 'a=2, c=4')
+        self.assertEqualCallArgs(f, '4, c=4')
+        self.assertEqualException(f, '')
+        self.assertEqualException(f, '3')
+        self.assertEqualException(f, 'a=3')
+        self.assertEqualException(f, 'd=4')
+
+        f = self.makeCallable('*, c, d=2')
+        self.assertEqualCallArgs(f, 'c=3')
+        self.assertEqualCallArgs(f, 'c=3, d=4')
+        self.assertEqualCallArgs(f, 'd=4, c=3')
+
+    def test_multiple_features(self):
+        f = self.makeCallable('a, b=2, *f, **g')
+        self.assertEqualCallArgs(f, '2, 3, 7')
+        self.assertEqualCallArgs(f, '2, 3, x=8')
+        self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
+        self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9')
+        self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9')
+        self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
+                                 '[2, 3, (4,[5,6])]), **{"y":9, "z":10}')
+        self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
+                                 '(4,[5,6])]), **collections.UserDict('
+                                 'y=9, z=10)')
+
+        f = self.makeCallable('a, b=2, *f, x, y=99, **g')
+        self.assertEqualCallArgs(f, '2, 3, x=8')
+        self.assertEqualCallArgs(f, '2, 3, x=8, *[(4,[5,6]), 7]')
+        self.assertEqualCallArgs(f, '2, x=8, *[3, (4,[5,6]), 7], y=9, z=10')
+        self.assertEqualCallArgs(f, 'x=8, *[2, 3, (4,[5,6])], y=9, z=10')
+        self.assertEqualCallArgs(f, 'x=8, *collections.UserList('
+                                 '[2, 3, (4,[5,6])]), q=0, **{"y":9, "z":10}')
+        self.assertEqualCallArgs(f, '2, x=8, *collections.UserList([3, '
+                                 '(4,[5,6])]), q=0, **collections.UserDict('
+                                 'y=9, z=10)')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_errors(self):
+        f0 = self.makeCallable('')
+        f1 = self.makeCallable('a, b')
+        f2 = self.makeCallable('a, b=1')
+        # f0 takes no arguments
+        self.assertEqualException(f0, '1')
+        self.assertEqualException(f0, 'x=1')
+        self.assertEqualException(f0, '1,x=1')
+        # f1 takes exactly 2 arguments
+        self.assertEqualException(f1, '')
+        self.assertEqualException(f1, '1')
+        self.assertEqualException(f1, 'a=2')
+        self.assertEqualException(f1, 'b=3')
+        # f2 takes at least 1 argument
+        self.assertEqualException(f2, '')
+        self.assertEqualException(f2, 'b=3')
+        for f in f1, f2:
+            # f1/f2 takes exactly/at most 2 arguments
+            self.assertEqualException(f, '2, 3, 4')
+            self.assertEqualException(f, '1, 2, 3, a=1')
+            self.assertEqualException(f, '2, 3, 4, c=5')
+            self.assertEqualException(f, '2, 3, 4, a=1, c=5')
+            # f got an unexpected keyword argument
+            self.assertEqualException(f, 'c=2')
+            self.assertEqualException(f, '2, c=3')
+            self.assertEqualException(f, '2, 3, c=4')
+            self.assertEqualException(f, '2, c=4, b=3')
+            self.assertEqualException(f, '**{u"\u03c0\u03b9": 4}')
+            # f got multiple values for keyword argument
+            self.assertEqualException(f, '1, a=2')
+            self.assertEqualException(f, '1, **{"a":2}')
+            self.assertEqualException(f, '1, 2, b=3')
+            self.assertEqualException(f, '1, c=3, a=2')
+        # issue11256:
+        f3 = self.makeCallable('**c')
+        self.assertEqualException(f3, '1, 2')
+        self.assertEqualException(f3, '1, 2, a=1, b=2')
+        f4 = self.makeCallable('*, a, b=0')
+        self.assertEqualException(f4, '1, 2')
+        self.assertEqualException(f4, '1, 2, a=1, b=2')
+        self.assertEqualException(f4, 'a=1, a=3')
+        self.assertEqualException(f4, 'a=1, c=3')
+        self.assertEqualException(f4, 'a=1, a=3, b=4')
+        self.assertEqualException(f4, 'a=1, b=2, a=3, b=4')
+        self.assertEqualException(f4, 'a=1, a=2, a=3, b=4')
+
+        # issue #20816: getcallargs() fails to iterate over non-existent
+        # kwonlydefaults and raises a wrong TypeError
+        def f5(*, a): pass
+        with self.assertRaisesRegex(TypeError,
+                                    'missing 1 required keyword-only'):
+            inspect.getcallargs(f5)
+
+
+        # issue20817:
+        def f6(a, b, c):
+            pass
+        with self.assertRaisesRegex(TypeError, "'a', 'b' and 'c'"):
+            inspect.getcallargs(f6)
+
+        # bpo-33197
+        with self.assertRaisesRegex(ValueError,
+                                    'variadic keyword parameters cannot'
+                                    ' have default values'):
+            inspect.Parameter("foo", kind=inspect.Parameter.VAR_KEYWORD,
+                              default=42)
+        with self.assertRaisesRegex(ValueError,
+                                    "value 5 is not a valid Parameter.kind"):
+            inspect.Parameter("bar", kind=5, default=42)
+
+        with self.assertRaisesRegex(TypeError,
+                                   'name must be a str, not a int'):
+            inspect.Parameter(123, kind=4)
+
+class TestGetcallargsMethods(TestGetcallargsFunctions):
+
+    def setUp(self):
+        class Foo(object):
+            pass
+        self.cls = Foo
+        self.inst = Foo()
+
+    def makeCallable(self, signature):
+        assert 'self' not in signature
+        mk = super(TestGetcallargsMethods, self).makeCallable
+        self.cls.method = mk('self, ' + signature)
+        return self.inst.method
+
+class TestGetcallargsUnboundMethods(TestGetcallargsMethods):
+
+    def makeCallable(self, signature):
+        super(TestGetcallargsUnboundMethods, self).makeCallable(signature)
+        return self.cls.method
+
+    def assertEqualCallArgs(self, func, call_params_string, locs=None):
+        return super(TestGetcallargsUnboundMethods, self).assertEqualCallArgs(
+            *self._getAssertEqualParams(func, call_params_string, locs))
+
+    def assertEqualException(self, func, call_params_string, locs=None):
+        return super(TestGetcallargsUnboundMethods, self).assertEqualException(
+            *self._getAssertEqualParams(func, call_params_string, locs))
+
+    def _getAssertEqualParams(self, func, call_params_string, locs=None):
+        assert 'inst' not in call_params_string
+        locs = dict(locs or {}, inst=self.inst)
+        return (func, 'inst,' + call_params_string, locs)
+
+
+class TestGetattrStatic(unittest.TestCase):
+
+    def test_basic(self):
+        class Thing(object):
+            x = object()
+
+        thing = Thing()
+        self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
+        self.assertEqual(inspect.getattr_static(thing, 'x', None), Thing.x)
+        with self.assertRaises(AttributeError):
+            inspect.getattr_static(thing, 'y')
+
+        self.assertEqual(inspect.getattr_static(thing, 'y', 3), 3)
+
+    def test_inherited(self):
+        class Thing(object):
+            x = object()
+        class OtherThing(Thing):
+            pass
+
+        something = OtherThing()
+        self.assertEqual(inspect.getattr_static(something, 'x'), Thing.x)
+
+    def test_instance_attr(self):
+        class Thing(object):
+            x = 2
+            def __init__(self, x):
+                self.x = x
+        thing = Thing(3)
+        self.assertEqual(inspect.getattr_static(thing, 'x'), 3)
+        del thing.x
+        self.assertEqual(inspect.getattr_static(thing, 'x'), 2)
+
+    def test_property(self):
+        class Thing(object):
+            @property
+            def x(self):
+                raise AttributeError("I'm pretending not to exist")
+        thing = Thing()
+        self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
+
+    def test_descriptor_raises_AttributeError(self):
+        class descriptor(object):
+            def __get__(*_):
+                raise AttributeError("I'm pretending not to exist")
+        desc = descriptor()
+        class Thing(object):
+            x = desc
+        thing = Thing()
+        self.assertEqual(inspect.getattr_static(thing, 'x'), desc)
+
+    def test_classAttribute(self):
+        class Thing(object):
+            x = object()
+
+        self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.x)
+
+    def test_classVirtualAttribute(self):
+        class Thing(object):
+            @types.DynamicClassAttribute
+            def x(self):
+                return self._x
+            _x = object()
+
+        self.assertEqual(inspect.getattr_static(Thing, 'x'), Thing.__dict__['x'])
+
+    def test_inherited_classattribute(self):
+        class Thing(object):
+            x = object()
+        class OtherThing(Thing):
+            pass
+
+        self.assertEqual(inspect.getattr_static(OtherThing, 'x'), Thing.x)
+
+    def test_slots(self):
+        class Thing(object):
+            y = 'bar'
+            __slots__ = ['x']
+            def __init__(self):
+                self.x = 'foo'
+        thing = Thing()
+        self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
+        self.assertEqual(inspect.getattr_static(thing, 'y'), 'bar')
+
+        del thing.x
+        self.assertEqual(inspect.getattr_static(thing, 'x'), Thing.x)
+
+    def test_metaclass(self):
+        class meta(type):
+            attr = 'foo'
+        class Thing(object, metaclass=meta):
+            pass
+        self.assertEqual(inspect.getattr_static(Thing, 'attr'), 'foo')
+
+        class sub(meta):
+            pass
+        class OtherThing(object, metaclass=sub):
+            x = 3
+        self.assertEqual(inspect.getattr_static(OtherThing, 'attr'), 'foo')
+
+        class OtherOtherThing(OtherThing):
+            pass
+        # this test is odd, but it was added as it exposed a bug
+        self.assertEqual(inspect.getattr_static(OtherOtherThing, 'x'), 3)
+
+    def test_no_dict_no_slots(self):
+        self.assertEqual(inspect.getattr_static(1, 'foo', None), None)
+        self.assertNotEqual(inspect.getattr_static('foo', 'lower'), None)
+
+    def test_no_dict_no_slots_instance_member(self):
+        # returns descriptor
+        with open(__file__, encoding='utf-8') as handle:
+            self.assertEqual(inspect.getattr_static(handle, 'name'), type(handle).name)
+
+    def test_inherited_slots(self):
+        # returns descriptor
+        class Thing(object):
+            __slots__ = ['x']
+            def __init__(self):
+                self.x = 'foo'
+
+        class OtherThing(Thing):
+            pass
+        # it would be nice if this worked...
+        # we get the descriptor instead of the instance attribute
+        self.assertEqual(inspect.getattr_static(OtherThing(), 'x'), Thing.x)
+
+    def test_descriptor(self):
+        class descriptor(object):
+            def __get__(self, instance, owner):
+                return 3
+        class Foo(object):
+            d = descriptor()
+
+        foo = Foo()
+
+        # for a non data descriptor we return the instance attribute
+        foo.__dict__['d'] = 1
+        self.assertEqual(inspect.getattr_static(foo, 'd'), 1)
+
+        # if the descriptor is a data-descriptor we should return the
+        # descriptor
+        descriptor.__set__ = lambda s, i, v: None
+        self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d'])
+
+        del descriptor.__set__
+        descriptor.__delete__ = lambda s, i, o: None
+        self.assertEqual(inspect.getattr_static(foo, 'd'), Foo.__dict__['d'])
+
+    def test_metaclass_with_descriptor(self):
+        class descriptor(object):
+            def __get__(self, instance, owner):
+                return 3
+        class meta(type):
+            d = descriptor()
+        class Thing(object, metaclass=meta):
+            pass
+        self.assertEqual(inspect.getattr_static(Thing, 'd'), meta.__dict__['d'])
+
+
+    def test_class_as_property(self):
+        class Base(object):
+            foo = 3
+
+        class Something(Base):
+            executed = False
+            @property
+            def __class__(self):
+                self.executed = True
+                return object
+
+        instance = Something()
+        self.assertEqual(inspect.getattr_static(instance, 'foo'), 3)
+        self.assertFalse(instance.executed)
+        self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
+
+    def test_mro_as_property(self):
+        class Meta(type):
+            @property
+            def __mro__(self):
+                return (object,)
+
+        class Base(object):
+            foo = 3
+
+        class Something(Base, metaclass=Meta):
+            pass
+
+        self.assertEqual(inspect.getattr_static(Something(), 'foo'), 3)
+        self.assertEqual(inspect.getattr_static(Something, 'foo'), 3)
+
+    def test_dict_as_property(self):
+        test = self
+        test.called = False
+
+        class Foo(dict):
+            a = 3
+            @property
+            def __dict__(self):
+                test.called = True
+                return {}
+
+        foo = Foo()
+        foo.a = 4
+        self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
+        self.assertFalse(test.called)
+
+        class Bar(Foo): pass
+
+        bar = Bar()
+        bar.a = 5
+        self.assertEqual(inspect.getattr_static(bar, 'a'), 3)
+        self.assertFalse(test.called)
+
+    def test_mutated_mro(self):
+        test = self
+        test.called = False
+
+        class Foo(dict):
+            a = 3
+            @property
+            def __dict__(self):
+                test.called = True
+                return {}
+
+        class Bar(dict):
+            a = 4
+
+        class Baz(Bar): pass
+
+        baz = Baz()
+        self.assertEqual(inspect.getattr_static(baz, 'a'), 4)
+        Baz.__bases__ = (Foo,)
+        self.assertEqual(inspect.getattr_static(baz, 'a'), 3)
+        self.assertFalse(test.called)
+
+    def test_custom_object_dict(self):
+        test = self
+        test.called = False
+
+        class Custom(dict):
+            def get(self, key, default=None):
+                test.called = True
+                super().get(key, default)
+
+        class Foo(object):
+            a = 3
+        foo = Foo()
+        foo.__dict__ = Custom()
+        self.assertEqual(inspect.getattr_static(foo, 'a'), 3)
+        self.assertFalse(test.called)
+
+    def test_metaclass_dict_as_property(self):
+        class Meta(type):
+            @property
+            def __dict__(self):
+                self.executed = True
+
+        class Thing(metaclass=Meta):
+            executed = False
+
+            def __init__(self):
+                self.spam = 42
+
+        instance = Thing()
+        self.assertEqual(inspect.getattr_static(instance, "spam"), 42)
+        self.assertFalse(Thing.executed)
+
+    def test_module(self):
+        sentinel = object()
+        self.assertIsNot(inspect.getattr_static(sys, "version", sentinel),
+                         sentinel)
+
+    def test_metaclass_with_metaclass_with_dict_as_property(self):
+        class MetaMeta(type):
+            @property
+            def __dict__(self):
+                self.executed = True
+                return dict(spam=42)
+
+        class Meta(type, metaclass=MetaMeta):
+            executed = False
+
+        class Thing(metaclass=Meta):
+            pass
+
+        with self.assertRaises(AttributeError):
+            inspect.getattr_static(Thing, "spam")
+        self.assertFalse(Thing.executed)
+
+    def test_custom___getattr__(self):
+        test = self
+        test.called = False
+
+        class Foo:
+            def __getattr__(self, attr):
+                test.called = True
+                return {}
+
+        with self.assertRaises(AttributeError):
+            inspect.getattr_static(Foo(), 'whatever')
+
+        self.assertFalse(test.called)
+
+    def test_custom___getattribute__(self):
+        test = self
+        test.called = False
+
+        class Foo:
+            def __getattribute__(self, attr):
+                test.called = True
+                return {}
+
+        with self.assertRaises(AttributeError):
+            inspect.getattr_static(Foo(), 'really_could_be_anything')
+
+        self.assertFalse(test.called)
+
+    @suppress_immortalization()
+    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
+        # dynamically created classes to have extended lifetimes even
+        # when no other strong references to those classes remain.
+        # Since these classes can themselves hold strong references to
+        # other objects, this can cause unexpected memory consumption.
+        class Foo: pass
+        Foo.instance = Foo()
+        weakref_to_class = weakref.ref(Foo)
+        inspect.getattr_static(Foo.instance, 'whatever', 'irrelevant')
+        del Foo
+        gc.collect()
+        self.assertIsNone(weakref_to_class())
+
+
+class TestGetGeneratorState(unittest.TestCase):
+
+    def setUp(self):
+        def number_generator():
+            for number in range(5):
+                yield number
+        self.generator = number_generator()
+
+    def _generatorstate(self):
+        return inspect.getgeneratorstate(self.generator)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_created(self):
+        self.assertEqual(self._generatorstate(), inspect.GEN_CREATED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_suspended(self):
+        next(self.generator)
+        self.assertEqual(self._generatorstate(), inspect.GEN_SUSPENDED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_exhaustion(self):
+        for i in self.generator:
+            pass
+        self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_immediate_exception(self):
+        with self.assertRaises(RuntimeError):
+            self.generator.throw(RuntimeError)
+        self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_close(self):
+        self.generator.close()
+        self.assertEqual(self._generatorstate(), inspect.GEN_CLOSED)
+
+    def test_running(self):
+        # As mentioned on issue #10220, checking for the RUNNING state only
+        # makes sense inside the generator itself.
+        # The following generator checks for this by using the closure's
+        # reference to self and the generator state checking helper method
+        def running_check_generator():
+            for number in range(5):
+                self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
+                yield number
+                self.assertEqual(self._generatorstate(), inspect.GEN_RUNNING)
+        self.generator = running_check_generator()
+        # Running up to the first yield
+        next(self.generator)
+        # Running after the first yield
+        next(self.generator)
+
+    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()
+        for name in names:
+            state = getattr(inspect, name)
+            self.assertIn(name, repr(state))
+            self.assertIn(name, str(state))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getgeneratorlocals(self):
+        def each(lst, a=None):
+            b=(1, 2, 3)
+            for v in lst:
+                if v == 3:
+                    c = 12
+                yield v
+
+        numbers = each([1, 2, 3])
+        self.assertEqual(inspect.getgeneratorlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3]})
+        next(numbers)
+        self.assertEqual(inspect.getgeneratorlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 1,
+                          'b': (1, 2, 3)})
+        next(numbers)
+        self.assertEqual(inspect.getgeneratorlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 2,
+                          'b': (1, 2, 3)})
+        next(numbers)
+        self.assertEqual(inspect.getgeneratorlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 3,
+                          'b': (1, 2, 3), 'c': 12})
+        try:
+            next(numbers)
+        except StopIteration:
+            pass
+        self.assertEqual(inspect.getgeneratorlocals(numbers), {})
+
+    def test_getgeneratorlocals_empty(self):
+        def yield_one():
+            yield 1
+        one = yield_one()
+        self.assertEqual(inspect.getgeneratorlocals(one), {})
+        try:
+            next(one)
+        except StopIteration:
+            pass
+        self.assertEqual(inspect.getgeneratorlocals(one), {})
+
+    def test_getgeneratorlocals_error(self):
+        self.assertRaises(TypeError, inspect.getgeneratorlocals, 1)
+        self.assertRaises(TypeError, inspect.getgeneratorlocals, lambda x: True)
+        self.assertRaises(TypeError, inspect.getgeneratorlocals, set)
+        self.assertRaises(TypeError, inspect.getgeneratorlocals, (2,3))
+
+
+class TestGetCoroutineState(unittest.TestCase):
+
+    def setUp(self):
+        @types.coroutine
+        def number_coroutine():
+            for number in range(5):
+                yield number
+        async def coroutine():
+            await number_coroutine()
+        self.coroutine = coroutine()
+
+    def tearDown(self):
+        self.coroutine.close()
+
+    def _coroutinestate(self):
+        return inspect.getcoroutinestate(self.coroutine)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_created(self):
+        self.assertEqual(self._coroutinestate(), inspect.CORO_CREATED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_suspended(self):
+        self.coroutine.send(None)
+        self.assertEqual(self._coroutinestate(), inspect.CORO_SUSPENDED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_exhaustion(self):
+        while True:
+            try:
+                self.coroutine.send(None)
+            except StopIteration:
+                break
+
+        self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_immediate_exception(self):
+        with self.assertRaises(RuntimeError):
+            self.coroutine.throw(RuntimeError)
+        self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_closed_after_close(self):
+        self.coroutine.close()
+        self.assertEqual(self._coroutinestate(), inspect.CORO_CLOSED)
+
+    def test_easy_debugging(self):
+        # repr() and str() of a coroutine state should contain the state name
+        names = 'CORO_CREATED CORO_RUNNING CORO_SUSPENDED CORO_CLOSED'.split()
+        for name in names:
+            state = getattr(inspect, name)
+            self.assertIn(name, repr(state))
+            self.assertIn(name, str(state))
+
+    def test_getcoroutinelocals(self):
+        @types.coroutine
+        def gencoro():
+            yield
+
+        gencoro = gencoro()
+        async def func(a=None):
+            b = 'spam'
+            await gencoro
+
+        coro = func()
+        self.assertEqual(inspect.getcoroutinelocals(coro),
+                         {'a': None, 'gencoro': gencoro})
+        coro.send(None)
+        self.assertEqual(inspect.getcoroutinelocals(coro),
+                         {'a': None, 'gencoro': gencoro, 'b': 'spam'})
+
+
+@support.requires_working_socket()
+class TestGetAsyncGenState(unittest.IsolatedAsyncioTestCase):
+
+    def setUp(self):
+        async def number_asyncgen():
+            for number in range(5):
+                yield number
+        self.asyncgen = number_asyncgen()
+
+    async def asyncTearDown(self):
+        await self.asyncgen.aclose()
+
+    def _asyncgenstate(self):
+        return inspect.getasyncgenstate(self.asyncgen)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_created(self):
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_CREATED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    async def test_suspended(self):
+        value = await anext(self.asyncgen)
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED)
+        self.assertEqual(value, 0)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    async def test_closed_after_exhaustion(self):
+        countdown = 7
+        with self.assertRaises(StopAsyncIteration):
+            while countdown := countdown - 1:
+                await anext(self.asyncgen)
+        self.assertEqual(countdown, 1)
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    async def test_closed_after_immediate_exception(self):
+        with self.assertRaises(RuntimeError):
+            await self.asyncgen.athrow(RuntimeError)
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_CLOSED)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    async def test_running(self):
+        async def running_check_asyncgen():
+            for number in range(5):
+                self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING)
+                yield number
+                self.assertEqual(self._asyncgenstate(), inspect.AGEN_RUNNING)
+        self.asyncgen = running_check_asyncgen()
+        # Running up to the first yield
+        await anext(self.asyncgen)
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED)
+        # Running after the first yield
+        await anext(self.asyncgen)
+        self.assertEqual(self._asyncgenstate(), inspect.AGEN_SUSPENDED)
+
+    def test_easy_debugging(self):
+        # repr() and str() of a asyncgen state should contain the state name
+        names = 'AGEN_CREATED AGEN_RUNNING AGEN_SUSPENDED AGEN_CLOSED'.split()
+        for name in names:
+            state = getattr(inspect, name)
+            self.assertIn(name, repr(state))
+            self.assertIn(name, str(state))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    async def test_getasyncgenlocals(self):
+        async def each(lst, a=None):
+            b=(1, 2, 3)
+            for v in lst:
+                if v == 3:
+                    c = 12
+                yield v
+
+        numbers = each([1, 2, 3])
+        self.assertEqual(inspect.getasyncgenlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3]})
+        await anext(numbers)
+        self.assertEqual(inspect.getasyncgenlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 1,
+                          'b': (1, 2, 3)})
+        await anext(numbers)
+        self.assertEqual(inspect.getasyncgenlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 2,
+                          'b': (1, 2, 3)})
+        await anext(numbers)
+        self.assertEqual(inspect.getasyncgenlocals(numbers),
+                         {'a': None, 'lst': [1, 2, 3], 'v': 3,
+                          'b': (1, 2, 3), 'c': 12})
+        with self.assertRaises(StopAsyncIteration):
+            await anext(numbers)
+        self.assertEqual(inspect.getasyncgenlocals(numbers), {})
+
+    async def test_getasyncgenlocals_empty(self):
+        async def yield_one():
+            yield 1
+        one = yield_one()
+        self.assertEqual(inspect.getasyncgenlocals(one), {})
+        await anext(one)
+        self.assertEqual(inspect.getasyncgenlocals(one), {})
+        with self.assertRaises(StopAsyncIteration):
+            await anext(one)
+        self.assertEqual(inspect.getasyncgenlocals(one), {})
+
+    def test_getasyncgenlocals_error(self):
+        self.assertRaises(TypeError, inspect.getasyncgenlocals, 1)
+        self.assertRaises(TypeError, inspect.getasyncgenlocals, lambda x: True)
+        self.assertRaises(TypeError, inspect.getasyncgenlocals, set)
+        self.assertRaises(TypeError, inspect.getasyncgenlocals, (2,3))
+
+
+class MySignature(inspect.Signature):
+    # Top-level to make it picklable;
+    # used in test_signature_object_pickle
+    pass
+
+class MyParameter(inspect.Parameter):
+    # Top-level to make it picklable;
+    # used in test_signature_object_pickle
+    pass
+
+
+
+class TestSignatureObject(unittest.TestCase):
+    @staticmethod
+    def signature(func, **kw):
+        sig = inspect.signature(func, **kw)
+        return (tuple((param.name,
+                       (... if param.default is param.empty else param.default),
+                       (... if param.annotation is param.empty
+                                                        else param.annotation),
+                       str(param.kind).lower())
+                                    for param in sig.parameters.values()),
+                (... if sig.return_annotation is sig.empty
+                                            else sig.return_annotation))
+
+    def test_signature_object(self):
+        S = inspect.Signature
+        P = inspect.Parameter
+
+        self.assertEqual(str(S()), '()')
+        self.assertEqual(repr(S().parameters), 'mappingproxy(OrderedDict())')
+
+        def test(po, /, pk, pkd=100, *args, ko, kod=10, **kwargs):
+            pass
+
+        sig = inspect.signature(test)
+        self.assertTrue(repr(sig).startswith('<Signature'))
+        self.assertTrue('(po, /, pk' in repr(sig))
+
+        # We need two functions, because it is impossible to represent
+        # all param kinds in a single one.
+        def test2(pod=42, /):
+            pass
+
+        sig2 = inspect.signature(test2)
+        self.assertTrue(repr(sig2).startswith('<Signature'))
+        self.assertTrue('(pod=42, /)' in repr(sig2))
+
+        po = sig.parameters['po']
+        pod = sig2.parameters['pod']
+        pk = sig.parameters['pk']
+        pkd = sig.parameters['pkd']
+        args = sig.parameters['args']
+        ko = sig.parameters['ko']
+        kod = sig.parameters['kod']
+        kwargs = sig.parameters['kwargs']
+
+        S((po, pk, args, ko, kwargs))
+        S((po, pk, ko, kod))
+        S((po, pod, ko))
+        S((po, pod, kod))
+        S((pod, ko, kod))
+        S((pod, kod))
+        S((pod, args, kod, kwargs))
+        # keyword-only parameters without default values
+        # can follow keyword-only parameters with default values:
+        S((kod, ko))
+        S((kod, ko, kwargs))
+        S((args, kod, ko))
+
+        with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
+            S((pk, po, args, ko, kwargs))
+
+        with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
+            S((po, args, pk, ko, kwargs))
+
+        with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
+            S((args, po, pk, ko, kwargs))
+
+        with self.assertRaisesRegex(ValueError, 'wrong parameter order'):
+            S((po, pk, args, kwargs, ko))
+
+        kwargs2 = kwargs.replace(name='args')
+        with self.assertRaisesRegex(ValueError, 'duplicate parameter name'):
+            S((po, pk, args, kwargs2, ko))
+
+        with self.assertRaisesRegex(ValueError, 'follows default argument'):
+            S((pod, po))
+
+        with self.assertRaisesRegex(ValueError, 'follows default argument'):
+            S((pod, pk))
+
+        with self.assertRaisesRegex(ValueError, 'follows default argument'):
+            S((po, pod, pk))
+
+        with self.assertRaisesRegex(ValueError, 'follows default argument'):
+            S((po, pkd, pk))
+
+        with self.assertRaisesRegex(ValueError, 'follows default argument'):
+            S((pkd, pk))
+
+    def test_signature_object_pickle(self):
+        def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass
+        foo_partial = functools.partial(foo, a=1)
+
+        sig = inspect.signature(foo_partial)
+
+        for ver in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(pickle_ver=ver, subclass=False):
+                sig_pickled = pickle.loads(pickle.dumps(sig, ver))
+                self.assertEqual(sig, sig_pickled)
+
+        # Test that basic sub-classing works
+        sig = inspect.signature(foo)
+        myparam = MyParameter(name='z', kind=inspect.Parameter.POSITIONAL_ONLY)
+        myparams = collections.OrderedDict(sig.parameters, a=myparam)
+        mysig = MySignature().replace(parameters=myparams.values(),
+                                      return_annotation=sig.return_annotation)
+        self.assertTrue(isinstance(mysig, MySignature))
+        self.assertTrue(isinstance(mysig.parameters['z'], MyParameter))
+
+        for ver in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(pickle_ver=ver, subclass=True):
+                sig_pickled = pickle.loads(pickle.dumps(mysig, ver))
+                self.assertEqual(mysig, sig_pickled)
+                self.assertTrue(isinstance(sig_pickled, MySignature))
+                self.assertTrue(isinstance(sig_pickled.parameters['z'],
+                                           MyParameter))
+
+    def test_signature_immutability(self):
+        def test(a):
+            pass
+        sig = inspect.signature(test)
+
+        with self.assertRaises(AttributeError):
+            sig.foo = 'bar'
+
+        with self.assertRaises(TypeError):
+            sig.parameters['a'] = None
+
+    def test_signature_on_noarg(self):
+        def test():
+            pass
+        self.assertEqual(self.signature(test), ((), ...))
+
+    def test_signature_on_wargs(self):
+        def test(a, b:'foo') -> 123:
+            pass
+        self.assertEqual(self.signature(test),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., 'foo', "positional_or_keyword")),
+                          123))
+
+    def test_signature_on_wkwonly(self):
+        def test(*, a:float, b:str) -> int:
+            pass
+        self.assertEqual(self.signature(test),
+                         ((('a', ..., float, "keyword_only"),
+                           ('b', ..., str, "keyword_only")),
+                           int))
+
+    def test_signature_on_complex_args(self):
+        def test(a, b:'foo'=10, *args:'bar', spam:'baz', ham=123, **kwargs:int):
+            pass
+        self.assertEqual(self.signature(test),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', 10, 'foo', "positional_or_keyword"),
+                           ('args', ..., 'bar', "var_positional"),
+                           ('spam', ..., 'baz', "keyword_only"),
+                           ('ham', 123, ..., "keyword_only"),
+                           ('kwargs', ..., int, "var_keyword")),
+                          ...))
+
+    def test_signature_without_self(self):
+        def test_args_only(*args):  # NOQA
+            pass
+
+        def test_args_kwargs_only(*args, **kwargs):  # NOQA
+            pass
+
+        class A:
+            @classmethod
+            def test_classmethod(*args):  # NOQA
+                pass
+
+            @staticmethod
+            def test_staticmethod(*args):  # NOQA
+                pass
+
+            f1 = functools.partialmethod((test_classmethod), 1)
+            f2 = functools.partialmethod((test_args_only), 1)
+            f3 = functools.partialmethod((test_staticmethod), 1)
+            f4 = functools.partialmethod((test_args_kwargs_only),1)
+
+        self.assertEqual(self.signature(test_args_only),
+                         ((('args', ..., ..., 'var_positional'),), ...))
+        self.assertEqual(self.signature(test_args_kwargs_only),
+                         ((('args', ..., ..., 'var_positional'),
+                           ('kwargs', ..., ..., 'var_keyword')), ...))
+        self.assertEqual(self.signature(A.f1),
+                         ((('args', ..., ..., 'var_positional'),), ...))
+        self.assertEqual(self.signature(A.f2),
+                         ((('args', ..., ..., 'var_positional'),), ...))
+        self.assertEqual(self.signature(A.f3),
+                         ((('args', ..., ..., 'var_positional'),), ...))
+        self.assertEqual(self.signature(A.f4),
+                         ((('args', ..., ..., 'var_positional'),
+                            ('kwargs', ..., ..., 'var_keyword')), ...))
+    @cpython_only
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_signature_on_builtins(self):
+        _testcapi = import_helper.import_module("_testcapi")
+
+        def test_unbound_method(o):
+            """Use this to test unbound methods (things that should have a self)"""
+            signature = inspect.signature(o)
+            self.assertTrue(isinstance(signature, inspect.Signature))
+            self.assertEqual(list(signature.parameters.values())[0].name, 'self')
+            return signature
+
+        def test_callable(o):
+            """Use this to test bound methods or normal callables (things that don't expect self)"""
+            signature = inspect.signature(o)
+            self.assertTrue(isinstance(signature, inspect.Signature))
+            if signature.parameters:
+                self.assertNotEqual(list(signature.parameters.values())[0].name, 'self')
+            return signature
+
+        signature = test_callable(_testcapi.docstring_with_signature_with_defaults)
+        def p(name): return signature.parameters[name].default
+        self.assertEqual(p('s'), 'avocado')
+        self.assertEqual(p('b'), b'bytes')
+        self.assertEqual(p('d'), 3.14)
+        self.assertEqual(p('i'), 35)
+        self.assertEqual(p('n'), None)
+        self.assertEqual(p('t'), True)
+        self.assertEqual(p('f'), False)
+        self.assertEqual(p('local'), 3)
+        self.assertEqual(p('sys'), sys.maxsize)
+        self.assertEqual(p('exp'), sys.maxsize - 1)
+
+        test_callable(object)
+
+        # normal method
+        # (PyMethodDescr_Type, "method_descriptor")
+        test_unbound_method(_pickle.Pickler.dump)
+        d = _pickle.Pickler(io.StringIO())
+        test_callable(d.dump)
+
+        # static method
+        test_callable(bytes.maketrans)
+        test_callable(b'abc'.maketrans)
+
+        # class method
+        test_callable(dict.fromkeys)
+        test_callable({}.fromkeys)
+
+        # wrapper around slot (PyWrapperDescr_Type, "wrapper_descriptor")
+        test_unbound_method(type.__call__)
+        test_unbound_method(int.__add__)
+        test_callable((3).__add__)
+
+        # _PyMethodWrapper_Type
+        # support for 'method-wrapper'
+        test_callable(min.__call__)
+
+        # This doesn't work now.
+        # (We don't have a valid signature for "type" in 3.4)
+        class ThisWorksNow:
+            __call__ = type
+        # TODO: Support type.
+        self.assertEqual(ThisWorksNow()(1), int)
+        self.assertEqual(ThisWorksNow()('A', (), {}).__name__, 'A')
+        with self.assertRaisesRegex(ValueError, "no signature found"):
+            test_callable(ThisWorksNow())
+
+        # Regression test for issue #20786
+        test_unbound_method(dict.__delitem__)
+        test_unbound_method(property.__delete__)
+
+        # Regression test for issue #20586
+        test_callable(_testcapi.docstring_with_signature_but_no_doc)
+
+        # Regression test for gh-104955
+        method = bytearray.__release_buffer__
+        sig = test_unbound_method(method)
+        self.assertEqual(list(sig.parameters), ['self', 'buffer'])
+
+    @cpython_only
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_signature_on_decorated_builtins(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        func = _testcapi.docstring_with_signature_with_defaults
+
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs) -> int:
+                return func(*args, **kwargs)
+            return wrapper
+
+        decorated_func = decorator(func)
+
+        self.assertEqual(inspect.signature(func),
+                         inspect.signature(decorated_func))
+
+        def wrapper_like(*args, **kwargs) -> int: pass
+        self.assertEqual(inspect.signature(decorated_func,
+                                           follow_wrapped=False),
+                         inspect.signature(wrapper_like))
+
+    @cpython_only
+    def test_signature_on_builtins_no_signature(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        with self.assertRaisesRegex(ValueError,
+                                    'no signature found for builtin'):
+            inspect.signature(_testcapi.docstring_no_signature)
+
+        with self.assertRaisesRegex(ValueError,
+                                    'no signature found for builtin'):
+            inspect.signature(str)
+
+        cls = _testcapi.DocStringNoSignatureTest
+        obj = _testcapi.DocStringNoSignatureTest()
+        tests = [
+            (_testcapi.docstring_no_signature_noargs, meth_noargs),
+            (_testcapi.docstring_no_signature_o, meth_o),
+            (cls.meth_noargs, meth_self_noargs),
+            (cls.meth_o, meth_self_o),
+            (obj.meth_noargs, meth_noargs),
+            (obj.meth_o, meth_o),
+            (cls.meth_noargs_class, meth_noargs),
+            (cls.meth_o_class, meth_o),
+            (cls.meth_noargs_static, meth_noargs),
+            (cls.meth_o_static, meth_o),
+            (cls.meth_noargs_coexist, meth_self_noargs),
+            (cls.meth_o_coexist, meth_self_o),
+
+            (time.time, meth_noargs),
+            (str.lower, meth_self_noargs),
+            (''.lower, meth_noargs),
+            (set.add, meth_self_o),
+            (set().add, meth_o),
+            (set.__contains__, meth_self_o),
+            (set().__contains__, meth_o),
+            (datetime.datetime.__dict__['utcnow'], meth_type_noargs),
+            (datetime.datetime.utcnow, meth_noargs),
+            (dict.__dict__['__class_getitem__'], meth_type_o),
+            (dict.__class_getitem__, meth_o),
+        ]
+        try:
+            import _stat
+        except ImportError:
+            # if the _stat extension is not available, stat.S_IMODE() is
+            # implemented in Python, not in C
+            pass
+        else:
+            tests.append((stat.S_IMODE, meth_o))
+        for builtin, template in tests:
+            with self.subTest(builtin):
+                self.assertEqual(inspect.signature(builtin),
+                                 inspect.signature(template))
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_signature_parsing_with_defaults(self):
+        _testcapi = import_helper.import_module("_testcapi")
+        meth = _testcapi.DocStringUnrepresentableSignatureTest.with_default
+        self.assertEqual(str(inspect.signature(meth)), '(self, /, x=1)')
+
+    def test_signature_on_non_function(self):
+        with self.assertRaisesRegex(TypeError, 'is not a callable object'):
+            inspect.signature(42)
+
+    def test_signature_from_functionlike_object(self):
+        def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs):
+            pass
+
+        class funclike:
+            # Has to be callable, and have correct
+            # __code__, __annotations__, __defaults__, __name__,
+            # and __kwdefaults__ attributes
+
+            def __init__(self, func):
+                self.__name__ = func.__name__
+                self.__code__ = func.__code__
+                self.__annotations__ = func.__annotations__
+                self.__defaults__ = func.__defaults__
+                self.__kwdefaults__ = func.__kwdefaults__
+                self.func = func
+
+            def __call__(self, *args, **kwargs):
+                return self.func(*args, **kwargs)
+
+        sig_func = inspect.Signature.from_callable(func)
+
+        sig_funclike = inspect.Signature.from_callable(funclike(func))
+        self.assertEqual(sig_funclike, sig_func)
+
+        sig_funclike = inspect.signature(funclike(func))
+        self.assertEqual(sig_funclike, sig_func)
+
+        # If object is not a duck type of function, then
+        # signature will try to get a signature for its '__call__'
+        # method
+        fl = funclike(func)
+        del fl.__defaults__
+        self.assertEqual(self.signature(fl),
+                         ((('args', ..., ..., "var_positional"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                           ...))
+
+        # Test with cython-like builtins:
+        _orig_isdesc = inspect.ismethoddescriptor
+        def _isdesc(obj):
+            if hasattr(obj, '_builtinmock'):
+                return True
+            return _orig_isdesc(obj)
+
+        with unittest.mock.patch('inspect.ismethoddescriptor', _isdesc):
+            builtin_func = funclike(func)
+            # Make sure that our mock setup is working
+            self.assertFalse(inspect.ismethoddescriptor(builtin_func))
+            builtin_func._builtinmock = True
+            self.assertTrue(inspect.ismethoddescriptor(builtin_func))
+            self.assertEqual(inspect.signature(builtin_func), sig_func)
+
+    def test_signature_functionlike_class(self):
+        # We only want to duck type function-like objects,
+        # not classes.
+
+        def func(a,b, *args, kwonly=True, kwonlyreq, **kwargs):
+            pass
+
+        class funclike:
+            def __init__(self, marker):
+                pass
+
+            __name__ = func.__name__
+            __code__ = func.__code__
+            __annotations__ = func.__annotations__
+            __defaults__ = func.__defaults__
+            __kwdefaults__ = func.__kwdefaults__
+
+        self.assertEqual(str(inspect.signature(funclike)), '(marker)')
+
+    def test_signature_on_method(self):
+        class Test:
+            def __init__(*args):
+                pass
+            def m1(self, arg1, arg2=1) -> int:
+                pass
+            def m2(*args):
+                pass
+            def __call__(*, a):
+                pass
+
+        self.assertEqual(self.signature(Test().m1),
+                         ((('arg1', ..., ..., "positional_or_keyword"),
+                           ('arg2', 1, ..., "positional_or_keyword")),
+                          int))
+
+        self.assertEqual(self.signature(Test().m2),
+                         ((('args', ..., ..., "var_positional"),),
+                          ...))
+
+        self.assertEqual(self.signature(Test),
+                         ((('args', ..., ..., "var_positional"),),
+                          ...))
+
+        with self.assertRaisesRegex(ValueError, 'invalid method signature'):
+            self.signature(Test())
+
+    def test_signature_wrapped_bound_method(self):
+        # Issue 24298
+        class Test:
+            def m1(self, arg1, arg2=1) -> int:
+                pass
+        @functools.wraps(Test().m1)
+        def m1d(*args, **kwargs):
+            pass
+        self.assertEqual(self.signature(m1d),
+                         ((('arg1', ..., ..., "positional_or_keyword"),
+                           ('arg2', 1, ..., "positional_or_keyword")),
+                          int))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_classmethod(self):
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertEqual(self.signature(classmethod),
+                            ((('function', ..., ..., "positional_only"),),
+                            ...))
+
+        class Test:
+            @classmethod
+            def foo(cls, arg1, *, arg2=1):
+                pass
+
+        meth = Test().foo
+        self.assertEqual(self.signature(meth),
+                         ((('arg1', ..., ..., "positional_or_keyword"),
+                           ('arg2', 1, ..., "keyword_only")),
+                          ...))
+
+        meth = Test.foo
+        self.assertEqual(self.signature(meth),
+                         ((('arg1', ..., ..., "positional_or_keyword"),
+                           ('arg2', 1, ..., "keyword_only")),
+                          ...))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_staticmethod(self):
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertEqual(self.signature(staticmethod),
+                            ((('function', ..., ..., "positional_only"),),
+                            ...))
+
+        class Test:
+            @staticmethod
+            def foo(cls, *, arg):
+                pass
+
+        meth = Test().foo
+        self.assertEqual(self.signature(meth),
+                         ((('cls', ..., ..., "positional_or_keyword"),
+                           ('arg', ..., ..., "keyword_only")),
+                          ...))
+
+        meth = Test.foo
+        self.assertEqual(self.signature(meth),
+                         ((('cls', ..., ..., "positional_or_keyword"),
+                           ('arg', ..., ..., "keyword_only")),
+                          ...))
+
+    def test_signature_on_partial(self):
+        from functools import partial
+
+        def test():
+            pass
+
+        self.assertEqual(self.signature(partial(test)), ((), ...))
+
+        with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
+            inspect.signature(partial(test, 1))
+
+        with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
+            inspect.signature(partial(test, a=1))
+
+        def test(a, b, *, c, d):
+            pass
+
+        self.assertEqual(self.signature(partial(test)),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword"),
+                           ('c', ..., ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 1)),
+                         ((('b', ..., ..., "positional_or_keyword"),
+                           ('c', ..., ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 1, c=2)),
+                         ((('b', ..., ..., "positional_or_keyword"),
+                           ('c', 2, ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, b=1, c=2)),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', 1, ..., "keyword_only"),
+                           ('c', 2, ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 0, b=1, c=2)),
+                         ((('b', 1, ..., "keyword_only"),
+                           ('c', 2, ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, a=1)),
+                         ((('a', 1, ..., "keyword_only"),
+                           ('b', ..., ..., "keyword_only"),
+                           ('c', ..., ..., "keyword_only"),
+                           ('d', ..., ..., "keyword_only")),
+                          ...))
+
+        def test(a, *args, b, **kwargs):
+            pass
+
+        self.assertEqual(self.signature(partial(test, 1)),
+                         ((('args', ..., ..., "var_positional"),
+                           ('b', ..., ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, a=1)),
+                         ((('a', 1, ..., "keyword_only"),
+                           ('b', ..., ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 1, 2, 3)),
+                         ((('args', ..., ..., "var_positional"),
+                           ('b', ..., ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 1, 2, 3, test=True)),
+                         ((('args', ..., ..., "var_positional"),
+                           ('b', ..., ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, 1, 2, 3, test=1, b=0)),
+                         ((('args', ..., ..., "var_positional"),
+                           ('b', 0, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, b=0)),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('args', ..., ..., "var_positional"),
+                           ('b', 0, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(partial(test, b=0, test=1)),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('args', ..., ..., "var_positional"),
+                           ('b', 0, ..., "keyword_only"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...))
+
+        def test(a, b, c:int) -> 42:
+            pass
+
+        sig = test.__signature__ = inspect.signature(test)
+
+        self.assertEqual(self.signature(partial(partial(test, 1))),
+                         ((('b', ..., ..., "positional_or_keyword"),
+                           ('c', ..., int, "positional_or_keyword")),
+                          42))
+
+        self.assertEqual(self.signature(partial(partial(test, 1), 2)),
+                         ((('c', ..., int, "positional_or_keyword"),),
+                          42))
+
+        def foo(a):
+            return a
+        _foo = partial(partial(foo, a=10), a=20)
+        self.assertEqual(self.signature(_foo),
+                         ((('a', 20, ..., "keyword_only"),),
+                          ...))
+        # check that we don't have any side-effects in signature(),
+        # and the partial object is still functioning
+        self.assertEqual(_foo(), 20)
+
+        def foo(a, b, c):
+            return a, b, c
+        _foo = partial(partial(foo, 1, b=20), b=30)
+
+        self.assertEqual(self.signature(_foo),
+                         ((('b', 30, ..., "keyword_only"),
+                           ('c', ..., ..., "keyword_only")),
+                          ...))
+        self.assertEqual(_foo(c=10), (1, 30, 10))
+
+        def foo(a, b, c, *, d):
+            return a, b, c, d
+        _foo = partial(partial(foo, d=20, c=20), b=10, d=30)
+        self.assertEqual(self.signature(_foo),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', 10, ..., "keyword_only"),
+                           ('c', 20, ..., "keyword_only"),
+                           ('d', 30, ..., "keyword_only"),
+                           ),
+                          ...))
+        ba = inspect.signature(_foo).bind(a=200, b=11)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (200, 11, 20, 30))
+
+        def foo(a=1, b=2, c=3):
+            return a, b, c
+        _foo = partial(foo, c=13) # (a=1, b=2, *, c=13)
+
+        ba = inspect.signature(_foo).bind(a=11)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 2, 13))
+
+        ba = inspect.signature(_foo).bind(11, 12)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13))
+
+        ba = inspect.signature(_foo).bind(11, b=12)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (11, 12, 13))
+
+        ba = inspect.signature(_foo).bind(b=12)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (1, 12, 13))
+
+        _foo = partial(_foo, b=10, c=20)
+        ba = inspect.signature(_foo).bind(12)
+        self.assertEqual(_foo(*ba.args, **ba.kwargs), (12, 10, 20))
+
+
+        def foo(a, b, /, c, d, **kwargs):
+            pass
+        sig = inspect.signature(foo)
+        self.assertEqual(str(sig), '(a, b, /, c, d, **kwargs)')
+
+        self.assertEqual(self.signature(partial(foo, 1)),
+                         ((('b', ..., ..., 'positional_only'),
+                           ('c', ..., ..., 'positional_or_keyword'),
+                           ('d', ..., ..., 'positional_or_keyword'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                         ...))
+
+        self.assertEqual(self.signature(partial(foo, 1, 2)),
+                         ((('c', ..., ..., 'positional_or_keyword'),
+                           ('d', ..., ..., 'positional_or_keyword'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                         ...))
+
+        self.assertEqual(self.signature(partial(foo, 1, 2, 3)),
+                         ((('d', ..., ..., 'positional_or_keyword'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                         ...))
+
+        self.assertEqual(self.signature(partial(foo, 1, 2, c=3)),
+                         ((('c', 3, ..., 'keyword_only'),
+                           ('d', ..., ..., 'keyword_only'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                         ...))
+
+        self.assertEqual(self.signature(partial(foo, 1, c=3)),
+                         ((('b', ..., ..., 'positional_only'),
+                           ('c', 3, ..., 'keyword_only'),
+                           ('d', ..., ..., 'keyword_only'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                         ...))
+
+    def test_signature_on_partialmethod(self):
+        from functools import partialmethod
+
+        class Spam:
+            def test():
+                pass
+            ham = partialmethod(test)
+
+        with self.assertRaisesRegex(ValueError, "has incorrect arguments"):
+            inspect.signature(Spam.ham)
+
+        class Spam:
+            def test(it, a, *, c) -> 'spam':
+                pass
+            ham = partialmethod(test, c=1)
+
+        self.assertEqual(self.signature(Spam.ham, eval_str=False),
+                         ((('it', ..., ..., 'positional_or_keyword'),
+                           ('a', ..., ..., 'positional_or_keyword'),
+                           ('c', 1, ..., 'keyword_only')),
+                          'spam'))
+
+        self.assertEqual(self.signature(Spam().ham, eval_str=False),
+                         ((('a', ..., ..., 'positional_or_keyword'),
+                           ('c', 1, ..., 'keyword_only')),
+                          'spam'))
+
+        class Spam:
+            def test(self: 'anno', x):
+                pass
+
+            g = partialmethod(test, 1)
+
+        self.assertEqual(self.signature(Spam.g, eval_str=False),
+                         ((('self', ..., 'anno', 'positional_or_keyword'),),
+                          ...))
+
+    def test_signature_on_fake_partialmethod(self):
+        def foo(a): pass
+        foo.__partialmethod__ = 'spam'
+        self.assertEqual(str(inspect.signature(foo)), '(a)')
+
+    def test_signature_on_decorated(self):
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs) -> int:
+                return func(*args, **kwargs)
+            return wrapper
+
+        class Foo:
+            @decorator
+            def bar(self, a, b):
+                pass
+
+        bar = decorator(Foo().bar)
+
+        self.assertEqual(self.signature(Foo.bar),
+                         ((('self', ..., ..., "positional_or_keyword"),
+                           ('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(Foo().bar),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(Foo.bar, follow_wrapped=False),
+                         ((('args', ..., ..., "var_positional"),
+                           ('kwargs', ..., ..., "var_keyword")),
+                          ...)) # functools.wraps will copy __annotations__
+                                # from "func" to "wrapper", hence no
+                                # return_annotation
+
+        self.assertEqual(self.signature(bar),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword")),
+                          ...))
+
+        # Test that we handle method wrappers correctly
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs) -> int:
+                return func(42, *args, **kwargs)
+            sig = inspect.signature(func)
+            new_params = tuple(sig.parameters.values())[1:]
+            wrapper.__signature__ = sig.replace(parameters=new_params)
+            return wrapper
+
+        class Foo:
+            @decorator
+            def __call__(self, a, b):
+                pass
+
+        self.assertEqual(self.signature(Foo.__call__),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(Foo().__call__),
+                         ((('b', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        # Test we handle __signature__ partway down the wrapper stack
+        def wrapped_foo_call():
+            pass
+        wrapped_foo_call.__wrapped__ = Foo.__call__
+
+        self.assertEqual(self.signature(wrapped_foo_call),
+                         ((('a', ..., ..., "positional_or_keyword"),
+                           ('b', ..., ..., "positional_or_keyword")),
+                          ...))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_class(self):
+        class C:
+            def __init__(self, a):
+                pass
+
+        self.assertEqual(self.signature(C),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        class CM(type):
+            def __call__(cls, a):
+                pass
+        class C(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        self.assertEqual(self.signature(C),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        with self.subTest('classmethod'):
+            class CM(type):
+                @classmethod
+                def __call__(cls, a):
+                    return a
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class CM(type):
+                @staticmethod
+                def __call__(a):
+                    return a
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                def call(self, a):
+                    return a
+            class CM(type):
+                __call__ = A().call
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class CM(type):
+                __call__ = functools.partial(lambda x, a: (x, a), 2)
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(C(1), (2, 1))
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(self.signature(C),
+                                ((('a', ..., ..., "positional_or_keyword"),),
+                                ...))
+
+        with self.subTest('partialmethod'):
+            class CM(type):
+                __call__ = functools.partialmethod(lambda self, x, a: (x, a), 2)
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('BuiltinMethodType'):
+            class CM(type):
+                __call__ = ':'.join
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(['a', 'bc']), 'a:bc')
+            # BUG: Returns '<Signature (b)>'
+            with self.assertRaises(AssertionError):
+                self.assertEqual(self.signature(C), self.signature(''.join))
+
+        with self.subTest('MethodWrapperType'):
+            class CM(type):
+                __call__ = (2).__pow__
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(3), 8)
+            self.assertEqual(C(3, 7), 1)
+            if not support.MISSING_C_DOCSTRINGS:
+                # BUG: Returns '<Signature (b)>'
+                with self.assertRaises(AssertionError):
+                    self.assertEqual(self.signature(C), self.signature((0).__pow__))
+
+        class CM(type):
+            def __new__(mcls, name, bases, dct, *, foo=1):
+                return super().__new__(mcls, name, bases, dct)
+        class C(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        self.assertEqual(self.signature(C),
+                         ((('b', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        self.assertEqual(self.signature(CM),
+                         ((('name', ..., ..., "positional_or_keyword"),
+                           ('bases', ..., ..., "positional_or_keyword"),
+                           ('dct', ..., ..., "positional_or_keyword"),
+                           ('foo', 1, ..., "keyword_only")),
+                          ...))
+
+        class CMM(type):
+            def __new__(mcls, name, bases, dct, *, foo=1):
+                return super().__new__(mcls, name, bases, dct)
+            def __call__(cls, nm, bs, dt):
+                return type(nm, bs, dt)
+        class CM(type, metaclass=CMM):
+            def __new__(mcls, name, bases, dct, *, bar=2):
+                return super().__new__(mcls, name, bases, dct)
+        class C(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        self.assertEqual(self.signature(CMM),
+                         ((('name', ..., ..., "positional_or_keyword"),
+                           ('bases', ..., ..., "positional_or_keyword"),
+                           ('dct', ..., ..., "positional_or_keyword"),
+                           ('foo', 1, ..., "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(CM),
+                         ((('nm', ..., ..., "positional_or_keyword"),
+                           ('bs', ..., ..., "positional_or_keyword"),
+                           ('dt', ..., ..., "positional_or_keyword")),
+                          ...))
+
+        self.assertEqual(self.signature(C),
+                         ((('b', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        class CM(type):
+            def __init__(cls, name, bases, dct, *, bar=2):
+                return super().__init__(name, bases, dct)
+        class C(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        self.assertEqual(self.signature(CM),
+                         ((('name', ..., ..., "positional_or_keyword"),
+                           ('bases', ..., ..., "positional_or_keyword"),
+                           ('dct', ..., ..., "positional_or_keyword"),
+                           ('bar', 2, ..., "keyword_only")),
+                          ...))
+
+    def test_signature_on_class_with_wrapped_metaclass_call(self):
+        class CM(type):
+            @identity_wrapper
+            def __call__(cls, a):
+                pass
+        class C(metaclass=CM):
+            def __init__(self, b):
+                pass
+
+        self.assertEqual(self.signature(C),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        with self.subTest('classmethod'):
+            class CM(type):
+                @classmethod
+                @identity_wrapper
+                def __call__(cls, a):
+                    return a
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class CM(type):
+                @staticmethod
+                @identity_wrapper
+                def __call__(a):
+                    return a
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                @identity_wrapper
+                def call(self, a):
+                    return a
+            class CM(type):
+                __call__ = A().call
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('descriptor'):
+            class CM(type):
+                @custom_descriptor
+                @identity_wrapper
+                def __call__(self, a):
+                    return a
+            class C(metaclass=CM):
+                def __init__(self, b):
+                    pass
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+            self.assertEqual(self.signature(C.__call__),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+            self.assertEqual(self.signature(C, follow_wrapped=False),
+                             varargs_signature)
+            self.assertEqual(self.signature(C.__call__, follow_wrapped=False),
+                             varargs_signature)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_class_with_wrapped_init(self):
+        class C:
+            @identity_wrapper
+            def __init__(self, b):
+                pass
+
+        C(1)  # does not raise
+        self.assertEqual(self.signature(C),
+                        ((('b', ..., ..., "positional_or_keyword"),),
+                        ...))
+
+        with self.subTest('classmethod'):
+            class C:
+                @classmethod
+                @identity_wrapper
+                def __init__(cls, b):
+                    pass
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class C:
+                @staticmethod
+                @identity_wrapper
+                def __init__(b):
+                    pass
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                @identity_wrapper
+                def call(self, a):
+                    pass
+
+            class C:
+                __init__ = A().call
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class C:
+                __init__ = functools.partial(identity_wrapper(lambda x, a: None), 2)
+
+            with self.assertWarns(FutureWarning):
+                C(1)  # does not raise
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(self.signature(C),
+                                ((('a', ..., ..., "positional_or_keyword"),),
+                                ...))
+
+        with self.subTest('partialmethod'):
+            class C:
+                @identity_wrapper
+                def _init(self, x, a):
+                    self.a = (x, a)
+                __init__ = functools.partialmethod(_init, 2)
+
+            self.assertEqual(C(1).a, (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('descriptor'):
+            class C:
+                @custom_descriptor
+                @identity_wrapper
+                def __init__(self, a):
+                    pass
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+            self.assertEqual(self.signature(C.__init__),
+                            ((('self', ..., ..., "positional_or_keyword"),
+                            ('a', ..., ..., "positional_or_keyword")),
+                            ...))
+
+            self.assertEqual(self.signature(C, follow_wrapped=False),
+                             varargs_signature)
+            if support.MISSING_C_DOCSTRINGS:
+                self.assertRaisesRegex(
+                    ValueError, "no signature found",
+                    self.signature, C.__new__, follow_wrapped=False,
+                )
+            else:
+                self.assertEqual(self.signature(C.__new__, follow_wrapped=False),
+                                varargs_signature)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_class_with_wrapped_new(self):
+        with self.subTest('FunctionType'):
+            class C:
+                @identity_wrapper
+                def __new__(cls, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('classmethod'):
+            class C:
+                @classmethod
+                @identity_wrapper
+                def __new__(cls, cls2, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class C:
+                @staticmethod
+                @identity_wrapper
+                def __new__(cls, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                @identity_wrapper
+                def call(self, cls, a):
+                    return a
+            class C:
+                __new__ = A().call
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class C:
+                __new__ = functools.partial(identity_wrapper(lambda x, cls, a: (x, a)), 2)
+
+            self.assertEqual(C(1), (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partialmethod'):
+            class C:
+                __new__ = functools.partialmethod(identity_wrapper(lambda cls, x, a: (x, a)), 2)
+
+            self.assertEqual(C(1), (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('descriptor'):
+            class C:
+                @custom_descriptor
+                @identity_wrapper
+                def __new__(cls, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+            self.assertEqual(self.signature(C.__new__),
+                            ((('cls', ..., ..., "positional_or_keyword"),
+                            ('a', ..., ..., "positional_or_keyword")),
+                            ...))
+
+            self.assertEqual(self.signature(C, follow_wrapped=False),
+                             varargs_signature)
+            self.assertEqual(self.signature(C.__new__, follow_wrapped=False),
+                             varargs_signature)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_class_with_init(self):
+        class C:
+            def __init__(self, b):
+                pass
+
+        C(1)  # does not raise
+        self.assertEqual(self.signature(C),
+                        ((('b', ..., ..., "positional_or_keyword"),),
+                        ...))
+
+        with self.subTest('classmethod'):
+            class C:
+                @classmethod
+                def __init__(cls, b):
+                    pass
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class C:
+                @staticmethod
+                def __init__(b):
+                    pass
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('b', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                def call(self, a):
+                    pass
+            class C:
+                __init__ = A().call
+
+            C(1)  # does not raise
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class C:
+                __init__ = functools.partial(lambda x, a: None, 2)
+
+            with self.assertWarns(FutureWarning):
+                C(1)  # does not raise
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(self.signature(C),
+                                ((('a', ..., ..., "positional_or_keyword"),),
+                                ...))
+
+        with self.subTest('partialmethod'):
+            class C:
+                def _init(self, x, a):
+                    self.a = (x, a)
+                __init__ = functools.partialmethod(_init, 2)
+
+            self.assertEqual(C(1).a, (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_class_with_new(self):
+        with self.subTest('FunctionType'):
+            class C:
+                def __new__(cls, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('classmethod'):
+            class C:
+                @classmethod
+                def __new__(cls, cls2, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class C:
+                @staticmethod
+                def __new__(cls, a):
+                    return a
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                def call(self, cls, a):
+                    return a
+            class C:
+                __new__ = A().call
+
+            self.assertEqual(C(1), 1)
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class C:
+                __new__ = functools.partial(lambda x, cls, a: (x, a), 2)
+
+            self.assertEqual(C(1), (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partialmethod'):
+            class C:
+                __new__ = functools.partialmethod(lambda cls, x, a: (x, a), 2)
+
+            self.assertEqual(C(1), (2, 1))
+            self.assertEqual(self.signature(C),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('BuiltinMethodType'):
+            class C:
+                __new__ = str.__subclasscheck__
+
+            self.assertEqual(C(), False)
+            # TODO: Support BuiltinMethodType
+            # self.assertEqual(self.signature(C), ((), ...))
+            self.assertRaises(ValueError, self.signature, C)
+
+        with self.subTest('MethodWrapperType'):
+            class C:
+                __new__ = type.__or__.__get__(int, type)
+
+            self.assertEqual(C(), C | int)
+            # TODO: Support MethodWrapperType
+            # self.assertEqual(self.signature(C), ((), ...))
+            self.assertRaises(ValueError, self.signature, C)
+
+        # TODO: Test ClassMethodDescriptorType
+
+        with self.subTest('MethodDescriptorType'):
+            class C:
+                __new__ = type.__dict__['__subclasscheck__']
+
+            self.assertEqual(C(C), True)
+            self.assertEqual(self.signature(C), self.signature(C.__subclasscheck__))
+
+        with self.subTest('WrapperDescriptorType'):
+            class C:
+                __new__ = type.__or__
+
+            self.assertEqual(C(int), C | int)
+            # TODO: Support WrapperDescriptorType
+            # self.assertEqual(self.signature(C), self.signature(C.__or__))
+            self.assertRaises(ValueError, self.signature, C)
+
+    def test_signature_on_subclass(self):
+        class A:
+            def __new__(cls, a=1, *args, **kwargs):
+                return object.__new__(cls)
+        class B(A):
+            def __init__(self, b):
+                pass
+        class C(A):
+            def __new__(cls, a=1, b=2, *args, **kwargs):
+                return object.__new__(cls)
+        class D(A):
+            pass
+
+        self.assertEqual(self.signature(B),
+                         ((('b', ..., ..., "positional_or_keyword"),),
+                          ...))
+        self.assertEqual(self.signature(C),
+                         ((('a', 1, ..., 'positional_or_keyword'),
+                           ('b', 2, ..., 'positional_or_keyword'),
+                           ('args', ..., ..., 'var_positional'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                          ...))
+        self.assertEqual(self.signature(D),
+                         ((('a', 1, ..., 'positional_or_keyword'),
+                           ('args', ..., ..., 'var_positional'),
+                           ('kwargs', ..., ..., 'var_keyword')),
+                          ...))
+
+    def test_signature_on_generic_subclass(self):
+        from typing import Generic, TypeVar
+
+        T = TypeVar('T')
+
+        class A(Generic[T]):
+            def __init__(self, *, a: int) -> None:
+                pass
+
+        self.assertEqual(self.signature(A),
+                         ((('a', ..., int, 'keyword_only'),),
+                          None))
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_signature_on_class_without_init(self):
+        # Test classes without user-defined __init__ or __new__
+        class C: pass
+        self.assertEqual(str(inspect.signature(C)), '()')
+        class D(C): pass
+        self.assertEqual(str(inspect.signature(D)), '()')
+
+        # Test meta-classes without user-defined __init__ or __new__
+        class C(type): pass
+        class D(C): pass
+        self.assertEqual(C('A', (), {}).__name__, 'A')
+        # TODO: Support type.
+        with self.assertRaisesRegex(ValueError, "callable.*is not supported"):
+            self.assertEqual(inspect.signature(C), None)
+        self.assertEqual(D('A', (), {}).__name__, 'A')
+        with self.assertRaisesRegex(ValueError, "callable.*is not supported"):
+            self.assertEqual(inspect.signature(D), None)
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    @unittest.skipIf(_pickle is None, "requires _pickle")
+    def test_signature_on_builtin_class(self):
+        expected = ('(file, protocol=None, fix_imports=True, '
+                    'buffer_callback=None)')
+        self.assertEqual(str(inspect.signature(_pickle.Pickler)), expected)
+
+        class P(_pickle.Pickler): pass
+        class EmptyTrait: pass
+        class P2(EmptyTrait, P): pass
+        self.assertEqual(str(inspect.signature(P)), expected)
+        self.assertEqual(str(inspect.signature(P2)), expected)
+
+        class P3(P2):
+            def __init__(self, spam):
+                pass
+        self.assertEqual(str(inspect.signature(P3)), '(spam)')
+
+        class MetaP(type):
+            def __call__(cls, foo, bar):
+                pass
+        class P4(P2, metaclass=MetaP):
+            pass
+        self.assertEqual(str(inspect.signature(P4)), '(foo, bar)')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_callable_objects(self):
+        class Foo:
+            def __call__(self, a):
+                pass
+
+        self.assertEqual(self.signature(Foo()),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        class Spam:
+            pass
+        with self.assertRaisesRegex(TypeError, "is not a callable object"):
+            inspect.signature(Spam())
+
+        class Bar(Spam, Foo):
+            pass
+
+        self.assertEqual(self.signature(Bar()),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+
+        with self.subTest('classmethod'):
+            class C:
+                @classmethod
+                def __call__(cls, a):
+                    pass
+
+            self.assertEqual(self.signature(C()),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('staticmethod'):
+            class C:
+                @staticmethod
+                def __call__(a):
+                    pass
+
+            self.assertEqual(self.signature(C()),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('MethodType'):
+            class A:
+                def call(self, a):
+                    return a
+            class C:
+                __call__ = A().call
+
+            self.assertEqual(C()(1), 1)
+            self.assertEqual(self.signature(C()),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('partial'):
+            class C:
+                __call__ = functools.partial(lambda x, a: (x, a), 2)
+
+            c = C()
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(c(1), (2, 1))
+            with self.assertWarns(FutureWarning):
+                self.assertEqual(self.signature(c),
+                                ((('a', ..., ..., "positional_or_keyword"),),
+                                ...))
+
+        with self.subTest('partialmethod'):
+            class C:
+                __call__ = functools.partialmethod(lambda self, x, a: (x, a), 2)
+
+            self.assertEqual(C()(1), (2, 1))
+            self.assertEqual(self.signature(C()),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+        with self.subTest('BuiltinMethodType'):
+            class C:
+                __call__ = ':'.join
+
+            self.assertEqual(C()(['a', 'bc']), 'a:bc')
+            self.assertEqual(self.signature(C()), self.signature(''.join))
+
+        with self.subTest('MethodWrapperType'):
+            class C:
+                __call__ = (2).__pow__
+
+            self.assertEqual(C()(3), 8)
+            if not support.MISSING_C_DOCSTRINGS:
+                self.assertEqual(self.signature(C()), self.signature((0).__pow__))
+
+        with self.subTest('ClassMethodDescriptorType'):
+            class C(dict):
+                __call__ = dict.__dict__['fromkeys']
+
+            res = C()([1, 2], 3)
+            self.assertEqual(res, {1: 3, 2: 3})
+            self.assertEqual(type(res), C)
+            if not support.MISSING_C_DOCSTRINGS:
+                self.assertEqual(self.signature(C()), self.signature(dict.fromkeys))
+
+        with self.subTest('MethodDescriptorType'):
+            class C(str):
+                __call__ = str.join
+
+            self.assertEqual(C(':')(['a', 'bc']), 'a:bc')
+            self.assertEqual(self.signature(C()), self.signature(''.join))
+
+        with self.subTest('WrapperDescriptorType'):
+            class C(int):
+                __call__ = int.__pow__
+
+            self.assertEqual(C(2)(3), 8)
+            if not support.MISSING_C_DOCSTRINGS:
+                self.assertEqual(self.signature(C()), self.signature((0).__pow__))
+
+        with self.subTest('MemberDescriptorType'):
+            class C:
+                __slots__ = '__call__'
+            c = C()
+            c.__call__ = lambda a: a
+            self.assertEqual(c(1), 1)
+            self.assertEqual(self.signature(c),
+                            ((('a', ..., ..., "positional_or_keyword"),),
+                            ...))
+
+    def test_signature_on_callable_objects_with_text_signature_attr(self):
+        class C:
+            __text_signature__ = '(a, /, b, c=True)'
+            def __call__(self, *args, **kwargs):
+                pass
+
+        if not support.MISSING_C_DOCSTRINGS:
+            self.assertEqual(self.signature(C), ((), ...))
+        self.assertEqual(self.signature(C()),
+                         ((('a', ..., ..., "positional_only"),
+                           ('b', ..., ..., "positional_or_keyword"),
+                           ('c', True, ..., "positional_or_keyword"),
+                          ),
+                          ...))
+
+        c = C()
+        c.__text_signature__ = '(x, y)'
+        self.assertEqual(self.signature(c),
+                         ((('x', ..., ..., "positional_or_keyword"),
+                           ('y', ..., ..., "positional_or_keyword"),
+                          ),
+                          ...))
+
+    def test_signature_on_wrapper(self):
+        class Wrapper:
+            def __call__(self, b):
+                pass
+        wrapper = Wrapper()
+        wrapper.__wrapped__ = lambda a: None
+        self.assertEqual(self.signature(wrapper),
+                         ((('a', ..., ..., "positional_or_keyword"),),
+                          ...))
+        # wrapper loop:
+        wrapper = Wrapper()
+        wrapper.__wrapped__ = wrapper
+        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
+            self.signature(wrapper)
+
+    def test_signature_on_lambdas(self):
+        self.assertEqual(self.signature((lambda a=10: a)),
+                         ((('a', 10, ..., "positional_or_keyword"),),
+                          ...))
+
+    def test_signature_on_mocks(self):
+        # https://github.com/python/cpython/issues/96127
+        for mock in (
+            unittest.mock.Mock(),
+            unittest.mock.AsyncMock(),
+            unittest.mock.MagicMock(),
+        ):
+            with self.subTest(mock=mock):
+                self.assertEqual(str(inspect.signature(mock)), '(*args, **kwargs)')
+
+    def test_signature_on_noncallable_mocks(self):
+        for mock in (
+            unittest.mock.NonCallableMock(),
+            unittest.mock.NonCallableMagicMock(),
+        ):
+            with self.subTest(mock=mock):
+                with self.assertRaises(TypeError):
+                    inspect.signature(mock)
+
+    def test_signature_equality(self):
+        def foo(a, *, b:int) -> float: pass
+        self.assertFalse(inspect.signature(foo) == 42)
+        self.assertTrue(inspect.signature(foo) != 42)
+        self.assertTrue(inspect.signature(foo) == ALWAYS_EQ)
+        self.assertFalse(inspect.signature(foo) != ALWAYS_EQ)
+
+        def bar(a, *, b:int) -> float: pass
+        self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
+        self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
+        self.assertEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def bar(a, *, b:int) -> int: pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def bar(a, *, b:int): pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def bar(a, *, b:int=42) -> float: pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def bar(a, *, c) -> float: pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def bar(a, b:int) -> float: pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+        def spam(b:int, a) -> float: pass
+        self.assertFalse(inspect.signature(spam) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(spam) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(spam)), hash(inspect.signature(bar)))
+
+        def foo(*, a, b, c): pass
+        def bar(*, c, b, a): pass
+        self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
+        self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
+        self.assertEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def foo(*, a=1, b, c): pass
+        def bar(*, c, b, a=1): pass
+        self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
+        self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
+        self.assertEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def foo(pos, *, a=1, b, c): pass
+        def bar(pos, *, c, b, a=1): pass
+        self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
+        self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
+        self.assertEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def foo(pos, *, a, b, c): pass
+        def bar(pos, *, c, b, a=1): pass
+        self.assertFalse(inspect.signature(foo) == inspect.signature(bar))
+        self.assertTrue(inspect.signature(foo) != inspect.signature(bar))
+        self.assertNotEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+        def foo(pos, *args, a=42, b, c, **kwargs:int): pass
+        def bar(pos, *args, c, b, a=42, **kwargs:int): pass
+        self.assertTrue(inspect.signature(foo) == inspect.signature(bar))
+        self.assertFalse(inspect.signature(foo) != inspect.signature(bar))
+        self.assertEqual(
+            hash(inspect.signature(foo)), hash(inspect.signature(bar)))
+
+    def test_signature_hashable(self):
+        S = inspect.Signature
+        P = inspect.Parameter
+
+        def foo(a): pass
+        foo_sig = inspect.signature(foo)
+
+        manual_sig = S(parameters=[P('a', P.POSITIONAL_OR_KEYWORD)])
+
+        self.assertEqual(hash(foo_sig), hash(manual_sig))
+        self.assertNotEqual(hash(foo_sig),
+                            hash(manual_sig.replace(return_annotation='spam')))
+
+        def bar(a) -> 1: pass
+        self.assertNotEqual(hash(foo_sig), hash(inspect.signature(bar)))
+
+        def foo(a={}): pass
+        with self.assertRaisesRegex(TypeError, 'unhashable type'):
+            hash(inspect.signature(foo))
+
+        def foo(a) -> {}: pass
+        with self.assertRaisesRegex(TypeError, 'unhashable type'):
+            hash(inspect.signature(foo))
+
+    def test_signature_str(self):
+        def foo(a:int=1, *, b, c=None, **kwargs) -> 42:
+            pass
+        self.assertEqual(str(inspect.signature(foo)),
+                         '(a: int = 1, *, b, c=None, **kwargs) -> 42')
+        self.assertEqual(str(inspect.signature(foo)),
+                         inspect.signature(foo).format())
+
+        def foo(a:int=1, *args, b, c=None, **kwargs) -> 42:
+            pass
+        self.assertEqual(str(inspect.signature(foo)),
+                         '(a: int = 1, *args, b, c=None, **kwargs) -> 42')
+        self.assertEqual(str(inspect.signature(foo)),
+                         inspect.signature(foo).format())
+
+        def foo():
+            pass
+        self.assertEqual(str(inspect.signature(foo)), '()')
+        self.assertEqual(str(inspect.signature(foo)),
+                         inspect.signature(foo).format())
+
+        def foo(a: list[str]) -> tuple[str, float]:
+            pass
+        self.assertEqual(str(inspect.signature(foo)),
+                         '(a: list[str]) -> tuple[str, float]')
+        self.assertEqual(str(inspect.signature(foo)),
+                         inspect.signature(foo).format())
+
+        from typing import Tuple
+        def foo(a: list[str]) -> Tuple[str, float]:
+            pass
+        self.assertEqual(str(inspect.signature(foo)),
+                         '(a: list[str]) -> Tuple[str, float]')
+        self.assertEqual(str(inspect.signature(foo)),
+                         inspect.signature(foo).format())
+
+    def test_signature_str_positional_only(self):
+        P = inspect.Parameter
+        S = inspect.Signature
+
+        def test(a_po, /, *, b, **kwargs):
+            return a_po, kwargs
+
+        self.assertEqual(str(inspect.signature(test)),
+                         '(a_po, /, *, b, **kwargs)')
+        self.assertEqual(str(inspect.signature(test)),
+                         inspect.signature(test).format())
+
+        test = S(parameters=[P('foo', P.POSITIONAL_ONLY)])
+        self.assertEqual(str(test), '(foo, /)')
+        self.assertEqual(str(test), test.format())
+
+        test = S(parameters=[P('foo', P.POSITIONAL_ONLY),
+                             P('bar', P.VAR_KEYWORD)])
+        self.assertEqual(str(test), '(foo, /, **bar)')
+        self.assertEqual(str(test), test.format())
+
+        test = S(parameters=[P('foo', P.POSITIONAL_ONLY),
+                             P('bar', P.VAR_POSITIONAL)])
+        self.assertEqual(str(test), '(foo, /, *bar)')
+        self.assertEqual(str(test), test.format())
+
+    def test_signature_format(self):
+        from typing import Annotated, Literal
+
+        def func(x: Annotated[int, 'meta'], y: Literal['a', 'b'], z: 'LiteralString'):
+            pass
+
+        expected_singleline = "(x: Annotated[int, 'meta'], y: Literal['a', 'b'], z: 'LiteralString')"
+        expected_multiline = """(
+    x: Annotated[int, 'meta'],
+    y: Literal['a', 'b'],
+    z: 'LiteralString'
+)"""
+        self.assertEqual(
+            inspect.signature(func).format(),
+            expected_singleline,
+        )
+        self.assertEqual(
+            inspect.signature(func).format(max_width=None),
+            expected_singleline,
+        )
+        self.assertEqual(
+            inspect.signature(func).format(max_width=len(expected_singleline)),
+            expected_singleline,
+        )
+        self.assertEqual(
+            inspect.signature(func).format(max_width=len(expected_singleline) - 1),
+            expected_multiline,
+        )
+        self.assertEqual(
+            inspect.signature(func).format(max_width=0),
+            expected_multiline,
+        )
+        self.assertEqual(
+            inspect.signature(func).format(max_width=-1),
+            expected_multiline,
+        )
+
+    def test_signature_format_all_arg_types(self):
+        from typing import Annotated, Literal
+
+        def func(
+            x: Annotated[int, 'meta'],
+            /,
+            y: Literal['a', 'b'],
+            *,
+            z: 'LiteralString',
+            **kwargs: object,
+        ) -> None:
+            pass
+
+        expected_multiline = """(
+    x: Annotated[int, 'meta'],
+    /,
+    y: Literal['a', 'b'],
+    *,
+    z: 'LiteralString',
+    **kwargs: object
+) -> None"""
+        self.assertEqual(
+            inspect.signature(func).format(max_width=-1),
+            expected_multiline,
+        )
+
+    def test_signature_replace_parameters(self):
+        def test(a, b) -> 42:
+            pass
+
+        sig = inspect.signature(test)
+        parameters = sig.parameters
+        sig = sig.replace(parameters=list(parameters.values())[1:])
+        self.assertEqual(list(sig.parameters), ['b'])
+        self.assertEqual(sig.parameters['b'], parameters['b'])
+        self.assertEqual(sig.return_annotation, 42)
+        sig = sig.replace(parameters=())
+        self.assertEqual(dict(sig.parameters), {})
+
+        sig = inspect.signature(test)
+        parameters = sig.parameters
+        sig = copy.replace(sig, parameters=list(parameters.values())[1:])
+        self.assertEqual(list(sig.parameters), ['b'])
+        self.assertEqual(sig.parameters['b'], parameters['b'])
+        self.assertEqual(sig.return_annotation, 42)
+        sig = copy.replace(sig, parameters=())
+        self.assertEqual(dict(sig.parameters), {})
+
+    def test_signature_replace_anno(self):
+        def test() -> 42:
+            pass
+
+        sig = inspect.signature(test)
+        sig = sig.replace(return_annotation=None)
+        self.assertIs(sig.return_annotation, None)
+        sig = sig.replace(return_annotation=sig.empty)
+        self.assertIs(sig.return_annotation, sig.empty)
+        sig = sig.replace(return_annotation=42)
+        self.assertEqual(sig.return_annotation, 42)
+        self.assertEqual(sig, inspect.signature(test))
+
+        sig = inspect.signature(test)
+        sig = copy.replace(sig, return_annotation=None)
+        self.assertIs(sig.return_annotation, None)
+        sig = copy.replace(sig, return_annotation=sig.empty)
+        self.assertIs(sig.return_annotation, sig.empty)
+        sig = copy.replace(sig, return_annotation=42)
+        self.assertEqual(sig.return_annotation, 42)
+        self.assertEqual(sig, inspect.signature(test))
+
+    def test_signature_replaced(self):
+        def test():
+            pass
+
+        spam_param = inspect.Parameter('spam', inspect.Parameter.POSITIONAL_ONLY)
+        sig = test.__signature__ = inspect.Signature(parameters=(spam_param,))
+        self.assertEqual(sig, inspect.signature(test))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_on_mangled_parameters(self):
+        class Spam:
+            def foo(self, __p1:1=2, *, __p2:2=3):
+                pass
+        class Ham(Spam):
+            pass
+
+        self.assertEqual(self.signature(Spam.foo),
+                         ((('self', ..., ..., "positional_or_keyword"),
+                           ('_Spam__p1', 2, 1, "positional_or_keyword"),
+                           ('_Spam__p2', 3, 2, "keyword_only")),
+                          ...))
+
+        self.assertEqual(self.signature(Spam.foo),
+                         self.signature(Ham.foo))
+
+    def test_signature_from_callable_python_obj(self):
+        class MySignature(inspect.Signature): pass
+        def foo(a, *, b:1): pass
+        foo_sig = MySignature.from_callable(foo)
+        self.assertIsInstance(foo_sig, MySignature)
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def test_signature_from_callable_class(self):
+        # A regression test for a class inheriting its signature from `object`.
+        class MySignature(inspect.Signature): pass
+        class foo: pass
+        foo_sig = MySignature.from_callable(foo)
+        self.assertIsInstance(foo_sig, MySignature)
+
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    @unittest.skipIf(_pickle is None, "requires _pickle")
+    def test_signature_from_callable_builtin_obj(self):
+        class MySignature(inspect.Signature): pass
+        sig = MySignature.from_callable(_pickle.Pickler)
+        self.assertIsInstance(sig, MySignature)
+
+    def test_signature_definition_order_preserved_on_kwonly(self):
+        for fn in signatures_with_lexicographic_keyword_only_parameters():
+            signature = inspect.signature(fn)
+            l = list(signature.parameters)
+            sorted_l = sorted(l)
+            self.assertTrue(l)
+            self.assertEqual(l, sorted_l)
+        signature = inspect.signature(unsorted_keyword_only_parameters_fn)
+        l = list(signature.parameters)
+        self.assertEqual(l, unsorted_keyword_only_parameters)
+
+    def test_signater_parameters_is_ordered(self):
+        p1 = inspect.signature(lambda x, y: None).parameters
+        p2 = inspect.signature(lambda y, x: None).parameters
+        self.assertNotEqual(p1, p2)
+
+    def test_signature_annotations_with_local_namespaces(self):
+        class Foo: ...
+        def func(foo: Foo) -> int: pass
+        def func2(foo: Foo, bar: 'Bar') -> int: pass
+
+        for signature_func in (inspect.signature, inspect.Signature.from_callable):
+            with self.subTest(signature_func = signature_func):
+                sig1 = signature_func(func)
+                self.assertEqual(sig1.return_annotation, int)
+                self.assertEqual(sig1.parameters['foo'].annotation, Foo)
+
+                sig2 = signature_func(func, locals=locals())
+                self.assertEqual(sig2.return_annotation, int)
+                self.assertEqual(sig2.parameters['foo'].annotation, Foo)
+
+                sig3 = signature_func(func2, globals={'Bar': int}, locals=locals())
+                self.assertEqual(sig3.return_annotation, int)
+                self.assertEqual(sig3.parameters['foo'].annotation, Foo)
+                self.assertEqual(sig3.parameters['bar'].annotation, 'Bar')
+
+    def test_signature_eval_str(self):
+        isa = inspect_stringized_annotations
+        sig = inspect.Signature
+        par = inspect.Parameter
+        PORK = inspect.Parameter.POSITIONAL_OR_KEYWORD
+        for signature_func in (inspect.signature, inspect.Signature.from_callable):
+            with self.subTest(signature_func = signature_func):
+                self.assertEqual(
+                    signature_func(isa.MyClass),
+                    sig(
+                        parameters=(
+                            par('a', PORK),
+                            par('b', PORK),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function),
+                    sig(
+                        return_annotation='MyClass',
+                        parameters=(
+                            par('a', PORK, annotation='int'),
+                            par('b', PORK, annotation='str'),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function2),
+                    sig(
+                        return_annotation='MyClass',
+                        parameters=(
+                            par('a', PORK, annotation='int'),
+                            par('b', PORK, annotation="'str'"),
+                            par('c', PORK, annotation="MyClass"),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function3),
+                    sig(
+                        parameters=(
+                            par('a', PORK, annotation="'int'"),
+                            par('b', PORK, annotation="'str'"),
+                            par('c', PORK, annotation="'MyClass'"),
+                        )))
+
+                if not MISSING_C_DOCSTRINGS:
+                    self.assertEqual(signature_func(isa.UnannotatedClass), sig())
+                self.assertEqual(signature_func(isa.unannotated_function),
+                    sig(
+                        parameters=(
+                            par('a', PORK),
+                            par('b', PORK),
+                            par('c', PORK),
+                        )))
+
+                self.assertEqual(
+                    signature_func(isa.MyClass, eval_str=True),
+                    sig(
+                        parameters=(
+                            par('a', PORK),
+                            par('b', PORK),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function, eval_str=True),
+                    sig(
+                        return_annotation=isa.MyClass,
+                        parameters=(
+                            par('a', PORK, annotation=int),
+                            par('b', PORK, annotation=str),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function2, eval_str=True),
+                    sig(
+                        return_annotation=isa.MyClass,
+                        parameters=(
+                            par('a', PORK, annotation=int),
+                            par('b', PORK, annotation='str'),
+                            par('c', PORK, annotation=isa.MyClass),
+                        )))
+                self.assertEqual(
+                    signature_func(isa.function3, eval_str=True),
+                    sig(
+                        parameters=(
+                            par('a', PORK, annotation='int'),
+                            par('b', PORK, annotation='str'),
+                            par('c', PORK, annotation='MyClass'),
+                        )))
+
+                globalns = {'int': float, 'str': complex}
+                localns = {'str': tuple, 'MyClass': dict}
+                with self.assertRaises(NameError):
+                    signature_func(isa.function, eval_str=True, globals=globalns)
+
+                self.assertEqual(
+                    signature_func(isa.function, eval_str=True, locals=localns),
+                    sig(
+                        return_annotation=dict,
+                        parameters=(
+                            par('a', PORK, annotation=int),
+                            par('b', PORK, annotation=tuple),
+                        )))
+
+                self.assertEqual(
+                    signature_func(isa.function, eval_str=True, globals=globalns, locals=localns),
+                    sig(
+                        return_annotation=dict,
+                        parameters=(
+                            par('a', PORK, annotation=float),
+                            par('b', PORK, annotation=tuple),
+                        )))
+
+    def test_signature_none_annotation(self):
+        class funclike:
+            # Has to be callable, and have correct
+            # __code__, __annotations__, __defaults__, __name__,
+            # and __kwdefaults__ attributes
+
+            def __init__(self, func):
+                self.__name__ = func.__name__
+                self.__code__ = func.__code__
+                self.__annotations__ = func.__annotations__
+                self.__defaults__ = func.__defaults__
+                self.__kwdefaults__ = func.__kwdefaults__
+                self.func = func
+
+            def __call__(self, *args, **kwargs):
+                return self.func(*args, **kwargs)
+
+        def foo(): pass
+        foo = funclike(foo)
+        foo.__annotations__ = None
+        for signature_func in (inspect.signature, inspect.Signature.from_callable):
+            with self.subTest(signature_func = signature_func):
+                self.assertEqual(signature_func(foo), inspect.Signature())
+        self.assertEqual(inspect.get_annotations(foo), {})
+
+    def test_signature_as_str(self):
+        self.maxDiff = None
+        class S:
+            __signature__ = '(a, b=2)'
+
+        self.assertEqual(self.signature(S),
+                         ((('a', ..., ..., 'positional_or_keyword'),
+                           ('b', 2, ..., 'positional_or_keyword')),
+                          ...))
+
+    def test_signature_as_callable(self):
+        # __signature__ should be either a staticmethod or a bound classmethod
+        class S:
+            @classmethod
+            def __signature__(cls):
+                return '(a, b=2)'
+
+        self.assertEqual(self.signature(S),
+                         ((('a', ..., ..., 'positional_or_keyword'),
+                           ('b', 2, ..., 'positional_or_keyword')),
+                          ...))
+
+        class S:
+            @staticmethod
+            def __signature__():
+                return '(a, b=2)'
+
+        self.assertEqual(self.signature(S),
+                         ((('a', ..., ..., 'positional_or_keyword'),
+                           ('b', 2, ..., 'positional_or_keyword')),
+                          ...))
+
+    def test_signature_on_derived_classes(self):
+        # gh-105080: Make sure that signatures are consistent on derived classes
+
+        class B:
+            def __new__(self, *args, **kwargs):
+                return super().__new__(self)
+            def __init__(self, value):
+                self.value = value
+
+        class D1(B):
+            def __init__(self, value):
+                super().__init__(value)
+
+        class D2(D1):
+            pass
+
+        self.assertEqual(inspect.signature(D2), inspect.signature(D1))
+
+    def test_signature_on_non_comparable(self):
+        class NoncomparableCallable:
+            def __call__(self, a):
+                pass
+            def __eq__(self, other):
+                1/0
+        self.assertEqual(self.signature(NoncomparableCallable()),
+                         ((('a', ..., ..., 'positional_or_keyword'),),
+                          ...))
+
+
+class TestParameterObject(unittest.TestCase):
+    def test_signature_parameter_kinds(self):
+        P = inspect.Parameter
+        self.assertTrue(P.POSITIONAL_ONLY < P.POSITIONAL_OR_KEYWORD < \
+                        P.VAR_POSITIONAL < P.KEYWORD_ONLY < P.VAR_KEYWORD)
+
+        self.assertEqual(str(P.POSITIONAL_ONLY), 'POSITIONAL_ONLY')
+        self.assertTrue('POSITIONAL_ONLY' in repr(P.POSITIONAL_ONLY))
+
+    def test_signature_parameter_object(self):
+        p = inspect.Parameter('foo', default=10,
+                              kind=inspect.Parameter.POSITIONAL_ONLY)
+        self.assertEqual(p.name, 'foo')
+        self.assertEqual(p.default, 10)
+        self.assertIs(p.annotation, p.empty)
+        self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)
+
+        with self.assertRaisesRegex(ValueError, "value '123' is "
+                                    "not a valid Parameter.kind"):
+            inspect.Parameter('foo', default=10, kind='123')
+
+        with self.assertRaisesRegex(ValueError, 'not a valid parameter name'):
+            inspect.Parameter('1', kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError, 'not a valid parameter name'):
+            inspect.Parameter('from', kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(TypeError, 'name must be a str'):
+            inspect.Parameter(None, kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError,
+                                    'is not a valid parameter name'):
+            inspect.Parameter('$', kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError,
+                                    'is not a valid parameter name'):
+            inspect.Parameter('.a', kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError, 'cannot have default values'):
+            inspect.Parameter('a', default=42,
+                              kind=inspect.Parameter.VAR_KEYWORD)
+
+        with self.assertRaisesRegex(ValueError, 'cannot have default values'):
+            inspect.Parameter('a', default=42,
+                              kind=inspect.Parameter.VAR_POSITIONAL)
+
+        p = inspect.Parameter('a', default=42,
+                              kind=inspect.Parameter.POSITIONAL_OR_KEYWORD)
+        with self.assertRaisesRegex(ValueError, 'cannot have default values'):
+            p.replace(kind=inspect.Parameter.VAR_POSITIONAL)
+
+        self.assertTrue(repr(p).startswith('<Parameter'))
+        self.assertTrue('"a=42"' in repr(p))
+
+    def test_signature_parameter_hashable(self):
+        P = inspect.Parameter
+        foo = P('foo', kind=P.POSITIONAL_ONLY)
+        self.assertEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY)))
+        self.assertNotEqual(hash(foo), hash(P('foo', kind=P.POSITIONAL_ONLY,
+                                              default=42)))
+        self.assertNotEqual(hash(foo),
+                            hash(foo.replace(kind=P.VAR_POSITIONAL)))
+
+    def test_signature_parameter_equality(self):
+        P = inspect.Parameter
+        p = P('foo', default=42, kind=inspect.Parameter.KEYWORD_ONLY)
+
+        self.assertTrue(p == p)
+        self.assertFalse(p != p)
+        self.assertFalse(p == 42)
+        self.assertTrue(p != 42)
+        self.assertTrue(p == ALWAYS_EQ)
+        self.assertFalse(p != ALWAYS_EQ)
+
+        self.assertTrue(p == P('foo', default=42,
+                               kind=inspect.Parameter.KEYWORD_ONLY))
+        self.assertFalse(p != P('foo', default=42,
+                                kind=inspect.Parameter.KEYWORD_ONLY))
+
+    def test_signature_parameter_replace(self):
+        p = inspect.Parameter('foo', default=42,
+                              kind=inspect.Parameter.KEYWORD_ONLY)
+
+        self.assertIsNot(p.replace(), p)
+        self.assertEqual(p.replace(), p)
+        self.assertIsNot(copy.replace(p), p)
+        self.assertEqual(copy.replace(p), p)
+
+        p2 = p.replace(annotation=1)
+        self.assertEqual(p2.annotation, 1)
+        p2 = p2.replace(annotation=p2.empty)
+        self.assertEqual(p2, p)
+        p3 = copy.replace(p, annotation=1)
+        self.assertEqual(p3.annotation, 1)
+        p3 = copy.replace(p3, annotation=p3.empty)
+        self.assertEqual(p3, p)
+
+        p2 = p2.replace(name='bar')
+        self.assertEqual(p2.name, 'bar')
+        self.assertNotEqual(p2, p)
+        p3 = copy.replace(p3, name='bar')
+        self.assertEqual(p3.name, 'bar')
+        self.assertNotEqual(p3, p)
+
+        with self.assertRaisesRegex(ValueError,
+                                    'name is a required attribute'):
+            p2 = p2.replace(name=p2.empty)
+        with self.assertRaisesRegex(ValueError,
+                                    'name is a required attribute'):
+            p3 = copy.replace(p3, name=p3.empty)
+
+        p2 = p2.replace(name='foo', default=None)
+        self.assertIs(p2.default, None)
+        self.assertNotEqual(p2, p)
+        p3 = copy.replace(p3, name='foo', default=None)
+        self.assertIs(p3.default, None)
+        self.assertNotEqual(p3, p)
+
+        p2 = p2.replace(name='foo', default=p2.empty)
+        self.assertIs(p2.default, p2.empty)
+        p3 = copy.replace(p3, name='foo', default=p3.empty)
+        self.assertIs(p3.default, p3.empty)
+
+        p2 = p2.replace(default=42, kind=p2.POSITIONAL_OR_KEYWORD)
+        self.assertEqual(p2.kind, p2.POSITIONAL_OR_KEYWORD)
+        self.assertNotEqual(p2, p)
+        p3 = copy.replace(p3, default=42, kind=p3.POSITIONAL_OR_KEYWORD)
+        self.assertEqual(p3.kind, p3.POSITIONAL_OR_KEYWORD)
+        self.assertNotEqual(p3, p)
+
+        with self.assertRaisesRegex(ValueError,
+                                    "value <class 'inspect._empty'> "
+                                    "is not a valid Parameter.kind"):
+            p2 = p2.replace(kind=p2.empty)
+        with self.assertRaisesRegex(ValueError,
+                                    "value <class 'inspect._empty'> "
+                                    "is not a valid Parameter.kind"):
+            p3 = copy.replace(p3, kind=p3.empty)
+
+        p2 = p2.replace(kind=p2.KEYWORD_ONLY)
+        self.assertEqual(p2, p)
+        p3 = copy.replace(p3, kind=p3.KEYWORD_ONLY)
+        self.assertEqual(p3, p)
+
+    def test_signature_parameter_positional_only(self):
+        with self.assertRaisesRegex(TypeError, 'name must be a str'):
+            inspect.Parameter(None, kind=inspect.Parameter.POSITIONAL_ONLY)
+
+    @cpython_only
+    def test_signature_parameter_implicit(self):
+        with self.assertRaisesRegex(ValueError,
+                                    'implicit arguments must be passed as '
+                                    'positional or keyword arguments, '
+                                    'not positional-only'):
+            inspect.Parameter('.0', kind=inspect.Parameter.POSITIONAL_ONLY)
+
+        param = inspect.Parameter(
+            '.0', kind=inspect.Parameter.POSITIONAL_OR_KEYWORD)
+        self.assertEqual(param.kind, inspect.Parameter.POSITIONAL_ONLY)
+        self.assertEqual(param.name, 'implicit0')
+
+    def test_signature_parameter_immutability(self):
+        p = inspect.Parameter('spam', kind=inspect.Parameter.KEYWORD_ONLY)
+
+        with self.assertRaises(AttributeError):
+            p.foo = 'bar'
+
+        with self.assertRaises(AttributeError):
+            p.kind = 123
+
+
+class TestSignatureBind(unittest.TestCase):
+    @staticmethod
+    def call(func, *args, **kwargs):
+        sig = inspect.signature(func)
+        ba = sig.bind(*args, **kwargs)
+        # Prevent unexpected success of assertRaises(TypeError, ...)
+        try:
+            return func(*ba.args, **ba.kwargs)
+        except TypeError as e:
+            raise AssertionError from e
+
+    def test_signature_bind_empty(self):
+        def test():
+            return 42
+
+        self.assertEqual(self.call(test), 42)
+        with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
+            self.call(test, 1)
+        with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
+            self.call(test, 1, spam=10)
+        with self.assertRaisesRegex(
+            TypeError, "got an unexpected keyword argument 'spam'"):
+
+            self.call(test, spam=1)
+
+    def test_signature_bind_var(self):
+        def test(*args, **kwargs):
+            return args, kwargs
+
+        self.assertEqual(self.call(test), ((), {}))
+        self.assertEqual(self.call(test, 1), ((1,), {}))
+        self.assertEqual(self.call(test, 1, 2), ((1, 2), {}))
+        self.assertEqual(self.call(test, foo='bar'), ((), {'foo': 'bar'}))
+        self.assertEqual(self.call(test, 1, foo='bar'), ((1,), {'foo': 'bar'}))
+        self.assertEqual(self.call(test, args=10), ((), {'args': 10}))
+        self.assertEqual(self.call(test, 1, 2, foo='bar'),
+                         ((1, 2), {'foo': 'bar'}))
+
+    def test_signature_bind_just_args(self):
+        def test(a, b, c):
+            return a, b, c
+
+        self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
+
+        with self.assertRaisesRegex(TypeError, 'too many positional arguments'):
+            self.call(test, 1, 2, 3, 4)
+
+        with self.assertRaisesRegex(TypeError,
+                                    "missing a required argument: 'b'"):
+            self.call(test, 1)
+
+        with self.assertRaisesRegex(TypeError,
+                                    "missing a required argument: 'a'"):
+            self.call(test)
+
+        def test(a, b, c=10):
+            return a, b, c
+        self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
+        self.assertEqual(self.call(test, 1, 2), (1, 2, 10))
+
+        def test(a=1, b=2, c=3):
+            return a, b, c
+        self.assertEqual(self.call(test, a=10, c=13), (10, 2, 13))
+        self.assertEqual(self.call(test, a=10), (10, 2, 3))
+        self.assertEqual(self.call(test, b=10), (1, 10, 3))
+
+    def test_signature_bind_varargs_order(self):
+        def test(*args):
+            return args
+
+        self.assertEqual(self.call(test), ())
+        self.assertEqual(self.call(test, 1, 2, 3), (1, 2, 3))
+
+    def test_signature_bind_args_and_varargs(self):
+        def test(a, b, c=3, *args):
+            return a, b, c, args
+
+        self.assertEqual(self.call(test, 1, 2, 3, 4, 5), (1, 2, 3, (4, 5)))
+        self.assertEqual(self.call(test, 1, 2), (1, 2, 3, ()))
+        self.assertEqual(self.call(test, b=1, a=2), (2, 1, 3, ()))
+        self.assertEqual(self.call(test, 1, b=2), (1, 2, 3, ()))
+
+        with self.assertRaisesRegex(TypeError,
+                                     "multiple values for argument 'c'"):
+            self.call(test, 1, 2, 3, c=4)
+
+    def test_signature_bind_just_kwargs(self):
+        def test(**kwargs):
+            return kwargs
+
+        self.assertEqual(self.call(test), {})
+        self.assertEqual(self.call(test, foo='bar', spam='ham'),
+                         {'foo': 'bar', 'spam': 'ham'})
+
+    def test_signature_bind_args_and_kwargs(self):
+        def test(a, b, c=3, **kwargs):
+            return a, b, c, kwargs
+
+        self.assertEqual(self.call(test, 1, 2), (1, 2, 3, {}))
+        self.assertEqual(self.call(test, 1, 2, foo='bar', spam='ham'),
+                         (1, 2, 3, {'foo': 'bar', 'spam': 'ham'}))
+        self.assertEqual(self.call(test, b=2, a=1, foo='bar', spam='ham'),
+                         (1, 2, 3, {'foo': 'bar', 'spam': 'ham'}))
+        self.assertEqual(self.call(test, a=1, b=2, foo='bar', spam='ham'),
+                         (1, 2, 3, {'foo': 'bar', 'spam': 'ham'}))
+        self.assertEqual(self.call(test, 1, b=2, foo='bar', spam='ham'),
+                         (1, 2, 3, {'foo': 'bar', 'spam': 'ham'}))
+        self.assertEqual(self.call(test, 1, b=2, c=4, foo='bar', spam='ham'),
+                         (1, 2, 4, {'foo': 'bar', 'spam': 'ham'}))
+        self.assertEqual(self.call(test, 1, 2, 4, foo='bar'),
+                         (1, 2, 4, {'foo': 'bar'}))
+        self.assertEqual(self.call(test, c=5, a=4, b=3),
+                         (4, 3, 5, {}))
+
+    def test_signature_bind_kwonly(self):
+        def test(*, foo):
+            return foo
+        with self.assertRaisesRegex(TypeError,
+                                     'too many positional arguments'):
+            self.call(test, 1)
+        self.assertEqual(self.call(test, foo=1), 1)
+
+        def test(a, *, foo=1, bar):
+            return foo
+        with self.assertRaisesRegex(TypeError,
+                                     "missing a required argument: 'bar'"):
+            self.call(test, 1)
+
+        def test(foo, *, bar):
+            return foo, bar
+        self.assertEqual(self.call(test, 1, bar=2), (1, 2))
+        self.assertEqual(self.call(test, bar=2, foo=1), (1, 2))
+
+        with self.assertRaisesRegex(
+            TypeError, "got an unexpected keyword argument 'spam'"):
+
+            self.call(test, bar=2, foo=1, spam=10)
+
+        with self.assertRaisesRegex(TypeError,
+                                     'too many positional arguments'):
+            self.call(test, 1, 2)
+
+        with self.assertRaisesRegex(TypeError,
+                                     'too many positional arguments'):
+            self.call(test, 1, 2, bar=2)
+
+        with self.assertRaisesRegex(
+            TypeError, "got an unexpected keyword argument 'spam'"):
+
+            self.call(test, 1, bar=2, spam='ham')
+
+        with self.assertRaisesRegex(TypeError,
+                                     "missing a required keyword-only "
+                                     "argument: 'bar'"):
+            self.call(test, 1)
+
+        def test(foo, *, bar, **bin):
+            return foo, bar, bin
+        self.assertEqual(self.call(test, 1, bar=2), (1, 2, {}))
+        self.assertEqual(self.call(test, foo=1, bar=2), (1, 2, {}))
+        self.assertEqual(self.call(test, 1, bar=2, spam='ham'),
+                         (1, 2, {'spam': 'ham'}))
+        self.assertEqual(self.call(test, spam='ham', foo=1, bar=2),
+                         (1, 2, {'spam': 'ham'}))
+        with self.assertRaisesRegex(TypeError,
+                                    "missing a required argument: 'foo'"):
+            self.call(test, spam='ham', bar=2)
+        self.assertEqual(self.call(test, 1, bar=2, bin=1, spam=10),
+                         (1, 2, {'bin': 1, 'spam': 10}))
+
+    def test_signature_bind_arguments(self):
+        def test(a, *args, b, z=100, **kwargs):
+            pass
+        sig = inspect.signature(test)
+        ba = sig.bind(10, 20, b=30, c=40, args=50, kwargs=60)
+        # we won't have 'z' argument in the bound arguments object, as we didn't
+        # pass it to the 'bind'
+        self.assertEqual(tuple(ba.arguments.items()),
+                         (('a', 10), ('args', (20,)), ('b', 30),
+                          ('kwargs', {'c': 40, 'args': 50, 'kwargs': 60})))
+        self.assertEqual(ba.kwargs,
+                         {'b': 30, 'c': 40, 'args': 50, 'kwargs': 60})
+        self.assertEqual(ba.args, (10, 20))
+
+    def test_signature_bind_positional_only(self):
+        def test(a_po, b_po, c_po=3, /, foo=42, *, bar=50, **kwargs):
+            return a_po, b_po, c_po, foo, bar, kwargs
+
+        self.assertEqual(self.call(test, 1, 2, 4, 5, bar=6),
+                         (1, 2, 4, 5, 6, {}))
+
+        self.assertEqual(self.call(test, 1, 2),
+                         (1, 2, 3, 42, 50, {}))
+
+        self.assertEqual(self.call(test, 1, 2, foo=4, bar=5),
+                         (1, 2, 3, 4, 5, {}))
+
+        self.assertEqual(self.call(test, 1, 2, foo=4, bar=5, c_po=10),
+                         (1, 2, 3, 4, 5, {'c_po': 10}))
+
+        self.assertEqual(self.call(test, 1, 2, 30, c_po=31, foo=4, bar=5),
+                         (1, 2, 30, 4, 5, {'c_po': 31}))
+
+        self.assertEqual(self.call(test, 1, 2, 30, foo=4, bar=5, c_po=31),
+                         (1, 2, 30, 4, 5, {'c_po': 31}))
+
+        self.assertEqual(self.call(test, 1, 2, c_po=4),
+                         (1, 2, 3, 42, 50, {'c_po': 4}))
+
+        with self.assertRaisesRegex(TypeError, "missing a required positional-only argument: 'a_po'"):
+            self.call(test, a_po=1, b_po=2)
+
+        def without_var_kwargs(c_po=3, d_po=4, /):
+            return c_po, d_po
+
+        with self.assertRaisesRegex(
+            TypeError,
+            "positional-only arguments passed as keyword arguments: 'c_po, d_po'",
+        ):
+            self.call(without_var_kwargs, c_po=33, d_po=44)
+
+    def test_signature_bind_with_self_arg(self):
+        # Issue #17071: one of the parameters is named "self
+        def test(a, self, b):
+            pass
+        sig = inspect.signature(test)
+        ba = sig.bind(1, 2, 3)
+        self.assertEqual(ba.args, (1, 2, 3))
+        ba = sig.bind(1, self=2, b=3)
+        self.assertEqual(ba.args, (1, 2, 3))
+
+    def test_signature_bind_vararg_name(self):
+        def test(a, *args):
+            return a, args
+        sig = inspect.signature(test)
+
+        with self.assertRaisesRegex(
+            TypeError, "got an unexpected keyword argument 'args'"):
+
+            sig.bind(a=0, args=1)
+
+        def test(*args, **kwargs):
+            return args, kwargs
+        self.assertEqual(self.call(test, args=1), ((), {'args': 1}))
+
+        sig = inspect.signature(test)
+        ba = sig.bind(args=1)
+        self.assertEqual(ba.arguments, {'kwargs': {'args': 1}})
+
+    @cpython_only
+    def test_signature_bind_implicit_arg(self):
+        # Issue #19611: getcallargs should work with comprehensions
+        def make_set():
+            return set(z * z for z in range(5))
+        gencomp_code = make_set.__code__.co_consts[1]
+        gencomp_func = types.FunctionType(gencomp_code, {})
+
+        iterator = iter(range(5))
+        self.assertEqual(set(self.call(gencomp_func, iterator)), {0, 1, 4, 9, 16})
+
+    def test_signature_bind_posonly_kwargs(self):
+        def foo(bar, /, **kwargs):
+            return bar, kwargs.get(bar)
+
+        sig = inspect.signature(foo)
+        result = sig.bind("pos-only", bar="keyword")
+
+        self.assertEqual(result.kwargs, {"bar": "keyword"})
+        self.assertIn(("bar", "pos-only"), result.arguments.items())
+
+
+class TestBoundArguments(unittest.TestCase):
+    def test_signature_bound_arguments_unhashable(self):
+        def foo(a): pass
+        ba = inspect.signature(foo).bind(1)
+
+        with self.assertRaisesRegex(TypeError, 'unhashable type'):
+            hash(ba)
+
+    def test_signature_bound_arguments_equality(self):
+        def foo(a): pass
+        ba = inspect.signature(foo).bind(1)
+        self.assertTrue(ba == ba)
+        self.assertFalse(ba != ba)
+        self.assertTrue(ba == ALWAYS_EQ)
+        self.assertFalse(ba != ALWAYS_EQ)
+
+        ba2 = inspect.signature(foo).bind(1)
+        self.assertTrue(ba == ba2)
+        self.assertFalse(ba != ba2)
+
+        ba3 = inspect.signature(foo).bind(2)
+        self.assertFalse(ba == ba3)
+        self.assertTrue(ba != ba3)
+        ba3.arguments['a'] = 1
+        self.assertTrue(ba == ba3)
+        self.assertFalse(ba != ba3)
+
+        def bar(b): pass
+        ba4 = inspect.signature(bar).bind(1)
+        self.assertFalse(ba == ba4)
+        self.assertTrue(ba != ba4)
+
+        def foo(*, a, b): pass
+        sig = inspect.signature(foo)
+        ba1 = sig.bind(a=1, b=2)
+        ba2 = sig.bind(b=2, a=1)
+        self.assertTrue(ba1 == ba2)
+        self.assertFalse(ba1 != ba2)
+
+    def test_signature_bound_arguments_pickle(self):
+        def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass
+        sig = inspect.signature(foo)
+        ba = sig.bind(20, 30, z={})
+
+        for ver in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(pickle_ver=ver):
+                ba_pickled = pickle.loads(pickle.dumps(ba, ver))
+                self.assertEqual(ba, ba_pickled)
+
+    def test_signature_bound_arguments_repr(self):
+        def foo(a, b, *, c:1={}, **kw) -> {42:'ham'}: pass
+        sig = inspect.signature(foo)
+        ba = sig.bind(20, 30, z={})
+        self.assertRegex(repr(ba), r'<BoundArguments \(a=20,.*\}\}\)>')
+
+    def test_signature_bound_arguments_apply_defaults(self):
+        def foo(a, b=1, *args, c:1={}, **kw): pass
+        sig = inspect.signature(foo)
+
+        ba = sig.bind(20)
+        ba.apply_defaults()
+        self.assertEqual(
+            list(ba.arguments.items()),
+            [('a', 20), ('b', 1), ('args', ()), ('c', {}), ('kw', {})])
+
+        # Make sure that we preserve the order:
+        # i.e. 'c' should be *before* 'kw'.
+        ba = sig.bind(10, 20, 30, d=1)
+        ba.apply_defaults()
+        self.assertEqual(
+            list(ba.arguments.items()),
+            [('a', 10), ('b', 20), ('args', (30,)), ('c', {}), ('kw', {'d':1})])
+
+        # Make sure that BoundArguments produced by bind_partial()
+        # are supported.
+        def foo(a, b): pass
+        sig = inspect.signature(foo)
+        ba = sig.bind_partial(20)
+        ba.apply_defaults()
+        self.assertEqual(
+            list(ba.arguments.items()),
+            [('a', 20)])
+
+        # Test no args
+        def foo(): pass
+        sig = inspect.signature(foo)
+        ba = sig.bind()
+        ba.apply_defaults()
+        self.assertEqual(list(ba.arguments.items()), [])
+
+        # Make sure a no-args binding still acquires proper defaults.
+        def foo(a='spam'): pass
+        sig = inspect.signature(foo)
+        ba = sig.bind()
+        ba.apply_defaults()
+        self.assertEqual(list(ba.arguments.items()), [('a', 'spam')])
+
+    def test_signature_bound_arguments_arguments_type(self):
+        def foo(a): pass
+        ba = inspect.signature(foo).bind(1)
+        self.assertIs(type(ba.arguments), dict)
+
+class TestSignaturePrivateHelpers(unittest.TestCase):
+    def _strip_non_python_syntax(self, input,
+        clean_signature, self_parameter):
+        computed_clean_signature, \
+            computed_self_parameter = \
+            inspect._signature_strip_non_python_syntax(input)
+        self.assertEqual(computed_clean_signature, clean_signature)
+        self.assertEqual(computed_self_parameter, self_parameter)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_signature_strip_non_python_syntax(self):
+        self._strip_non_python_syntax(
+            "($module, /, path, mode, *, dir_fd=None, " +
+                "effective_ids=False,\n       follow_symlinks=True)",
+            "(module, /, path, mode, *, dir_fd=None, " +
+                "effective_ids=False, follow_symlinks=True)",
+            0)
+
+        self._strip_non_python_syntax(
+            "($module, word, salt, /)",
+            "(module, word, salt, /)",
+            0)
+
+        self._strip_non_python_syntax(
+            "(x, y=None, z=None, /)",
+            "(x, y=None, z=None, /)",
+            None)
+
+        self._strip_non_python_syntax(
+            "(x, y=None, z=None)",
+            "(x, y=None, z=None)",
+            None)
+
+        self._strip_non_python_syntax(
+            "(x,\n    y=None,\n      z = None  )",
+            "(x, y=None, z=None)",
+            None)
+
+        self._strip_non_python_syntax(
+            "",
+            "",
+            None)
+
+        self._strip_non_python_syntax(
+            None,
+            None,
+            None)
+
+class TestSignatureDefinitions(unittest.TestCase):
+    # This test case provides a home for checking that particular APIs
+    # have signatures available for introspection
+
+    @staticmethod
+    def is_public(name):
+        return not name.startswith('_') or name.startswith('__') and name.endswith('__')
+
+    @cpython_only
+    @unittest.skipIf(MISSING_C_DOCSTRINGS,
+                     "Signature information for builtins requires docstrings")
+    def _test_module_has_signatures(self, module,
+                no_signature=(), unsupported_signature=(),
+                methods_no_signature={}, methods_unsupported_signature={},
+                good_exceptions=()):
+        # This checks all builtin callables in CPython have signatures
+        # A few have signatures Signature can't yet handle, so we skip those
+        # since they will have to wait until PEP 457 adds the required
+        # introspection support to the inspect module
+        # Some others also haven't been converted yet for various other
+        # reasons, so we also skip those for the time being, but design
+        # the test to fail in order to indicate when it needs to be
+        # updated.
+        no_signature = no_signature or set()
+        # Check the signatures we expect to be there
+        ns = vars(module)
+        try:
+            names = set(module.__all__)
+        except AttributeError:
+            names = set(name for name in ns if self.is_public(name))
+        for name, obj in sorted(ns.items()):
+            if name not in names:
+                continue
+            if not callable(obj):
+                continue
+            if (isinstance(obj, type) and
+                issubclass(obj, BaseException) and
+                name not in good_exceptions):
+                no_signature.add(name)
+            if name not in no_signature and name not in unsupported_signature:
+                with self.subTest('supported', builtin=name):
+                    self.assertIsNotNone(inspect.signature(obj))
+            if isinstance(obj, type):
+                with self.subTest(type=name):
+                    self._test_builtin_methods_have_signatures(obj,
+                            methods_no_signature.get(name, ()),
+                            methods_unsupported_signature.get(name, ()))
+        # Check callables that haven't been converted don't claim a signature
+        # This ensures this test will start failing as more signatures are
+        # added, so the affected items can be moved into the scope of the
+        # regression test above
+        for name in no_signature:
+            with self.subTest('none', builtin=name):
+                obj = ns[name]
+                self.assertIsNone(obj.__text_signature__)
+                self.assertRaises(ValueError, inspect.signature, obj)
+        for name in unsupported_signature:
+            with self.subTest('unsupported', builtin=name):
+                obj = ns[name]
+                self.assertIsNotNone(obj.__text_signature__)
+                self.assertRaises(ValueError, inspect.signature, obj)
+
+    def _test_builtin_methods_have_signatures(self, cls, no_signature, unsupported_signature):
+        ns = vars(cls)
+        for name in ns:
+            obj = getattr(cls, name, None)
+            if not callable(obj) or isinstance(obj, type):
+                continue
+            if name not in no_signature and name not in unsupported_signature:
+                with self.subTest('supported', method=name):
+                    self.assertIsNotNone(inspect.signature(obj))
+        for name in no_signature:
+            with self.subTest('none', method=name):
+                self.assertIsNone(getattr(cls, name).__text_signature__)
+                self.assertRaises(ValueError, inspect.signature, getattr(cls, name))
+        for name in unsupported_signature:
+            with self.subTest('unsupported', method=name):
+                self.assertIsNotNone(getattr(cls, name).__text_signature__)
+                self.assertRaises(ValueError, inspect.signature, getattr(cls, name))
+
+    def test_builtins_have_signatures(self):
+        no_signature = {'type', 'super', 'bytearray', 'bytes', 'dict', 'int', 'str'}
+        # These need PEP 457 groups
+        needs_groups = {"range", "slice", "dir", "getattr",
+                        "next", "iter", "vars"}
+        no_signature |= needs_groups
+        # These have unrepresentable parameter default values of NULL
+        unsupported_signature = {"anext"}
+        # These need *args support in Argument Clinic
+        needs_varargs = {"min", "max", "__build_class__"}
+        no_signature |= needs_varargs
+
+        methods_no_signature = {
+            'dict': {'update'},
+            'object': {'__class__'},
+        }
+        methods_unsupported_signature = {
+            'bytearray': {'count', 'endswith', 'find', 'hex', 'index', 'rfind', 'rindex', 'startswith'},
+            'bytes': {'count', 'endswith', 'find', 'hex', 'index', 'rfind', 'rindex', 'startswith'},
+            'dict': {'pop'},
+            'int': {'__round__'},
+            'memoryview': {'cast', 'hex'},
+            'str': {'count', 'endswith', 'find', 'index', 'maketrans', 'rfind', 'rindex', 'startswith'},
+        }
+        self._test_module_has_signatures(builtins,
+                no_signature, unsupported_signature,
+                methods_no_signature, methods_unsupported_signature)
+
+    def test_types_module_has_signatures(self):
+        unsupported_signature = {'CellType'}
+        methods_no_signature = {
+            'AsyncGeneratorType': {'athrow'},
+            'CoroutineType': {'throw'},
+            'GeneratorType': {'throw'},
+        }
+        self._test_module_has_signatures(types,
+                unsupported_signature=unsupported_signature,
+                methods_no_signature=methods_no_signature)
+
+    def test_sys_module_has_signatures(self):
+        no_signature = {'getsizeof', 'set_asyncgen_hooks'}
+        no_signature |= {name for name in ['getobjects']
+                         if hasattr(sys, name)}
+        self._test_module_has_signatures(sys, no_signature)
+
+    def test_abc_module_has_signatures(self):
+        import abc
+        self._test_module_has_signatures(abc)
+
+    def test_atexit_module_has_signatures(self):
+        import atexit
+        self._test_module_has_signatures(atexit)
+
+    def test_codecs_module_has_signatures(self):
+        import codecs
+        methods_no_signature = {'StreamReader': {'charbuffertype'}}
+        self._test_module_has_signatures(codecs,
+                methods_no_signature=methods_no_signature)
+
+    def test_collections_module_has_signatures(self):
+        no_signature = {'OrderedDict', 'defaultdict'}
+        unsupported_signature = {'deque'}
+        methods_no_signature = {
+            'OrderedDict': {'update'},
+        }
+        methods_unsupported_signature = {
+            'deque': {'index'},
+            'OrderedDict': {'pop'},
+            'UserString': {'maketrans'},
+        }
+        self._test_module_has_signatures(collections,
+                no_signature, unsupported_signature,
+                methods_no_signature, methods_unsupported_signature)
+
+    def test_collections_abc_module_has_signatures(self):
+        import collections.abc
+        self._test_module_has_signatures(collections.abc)
+
+    def test_errno_module_has_signatures(self):
+        import errno
+        self._test_module_has_signatures(errno)
+
+    def test_faulthandler_module_has_signatures(self):
+        import faulthandler
+        unsupported_signature = {'dump_traceback', 'dump_traceback_later', 'enable'}
+        unsupported_signature |= {name for name in ['register']
+                                  if hasattr(faulthandler, name)}
+        self._test_module_has_signatures(faulthandler, unsupported_signature=unsupported_signature)
+
+    def test_functools_module_has_signatures(self):
+        no_signature = {'reduce'}
+        self._test_module_has_signatures(functools, no_signature)
+
+    def test_gc_module_has_signatures(self):
+        import gc
+        no_signature = {'set_threshold'}
+        self._test_module_has_signatures(gc, no_signature)
+
+    def test_io_module_has_signatures(self):
+        methods_no_signature = {
+            'BufferedRWPair': {'read', 'peek', 'read1', 'readinto', 'readinto1', 'write'},
+        }
+        self._test_module_has_signatures(io,
+                methods_no_signature=methods_no_signature)
+
+    def test_itertools_module_has_signatures(self):
+        import itertools
+        no_signature = {'islice', 'repeat'}
+        self._test_module_has_signatures(itertools, no_signature)
+
+    def test_locale_module_has_signatures(self):
+        import locale
+        self._test_module_has_signatures(locale)
+
+    def test_marshal_module_has_signatures(self):
+        import marshal
+        self._test_module_has_signatures(marshal)
+
+    def test_operator_module_has_signatures(self):
+        import operator
+        self._test_module_has_signatures(operator)
+
+    def test_os_module_has_signatures(self):
+        unsupported_signature = {'chmod', 'utime'}
+        unsupported_signature |= {name for name in
+            ['get_terminal_size', 'posix_spawn', 'posix_spawnp',
+             'register_at_fork', 'startfile']
+            if hasattr(os, name)}
+        self._test_module_has_signatures(os, unsupported_signature=unsupported_signature)
+
+    def test_pwd_module_has_signatures(self):
+        pwd = import_helper.import_module('pwd')
+        self._test_module_has_signatures(pwd)
+
+    def test_re_module_has_signatures(self):
+        import re
+        methods_no_signature = {'Match': {'group'}}
+        self._test_module_has_signatures(re,
+                methods_no_signature=methods_no_signature,
+                good_exceptions={'error', 'PatternError'})
+
+    def test_signal_module_has_signatures(self):
+        import signal
+        self._test_module_has_signatures(signal)
+
+    def test_stat_module_has_signatures(self):
+        import stat
+        self._test_module_has_signatures(stat)
+
+    def test_string_module_has_signatures(self):
+        import string
+        self._test_module_has_signatures(string)
+
+    def test_symtable_module_has_signatures(self):
+        import symtable
+        self._test_module_has_signatures(symtable)
+
+    def test_sysconfig_module_has_signatures(self):
+        import sysconfig
+        self._test_module_has_signatures(sysconfig)
+
+    def test_threading_module_has_signatures(self):
+        import threading
+        self._test_module_has_signatures(threading)
+        self.assertIsNotNone(inspect.signature(threading.__excepthook__))
+
+    def test_thread_module_has_signatures(self):
+        import _thread
+        no_signature = {'RLock'}
+        self._test_module_has_signatures(_thread, no_signature)
+
+    def test_time_module_has_signatures(self):
+        no_signature = {
+            'asctime', 'ctime', 'get_clock_info', 'gmtime', 'localtime',
+            'strftime', 'strptime'
+        }
+        no_signature |= {name for name in
+            ['clock_getres', 'clock_settime', 'clock_settime_ns',
+             'pthread_getcpuclockid']
+            if hasattr(time, name)}
+        self._test_module_has_signatures(time, no_signature)
+
+    def test_tokenize_module_has_signatures(self):
+        import tokenize
+        self._test_module_has_signatures(tokenize)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tracemalloc_module_has_signatures(self):
+        import tracemalloc
+        self._test_module_has_signatures(tracemalloc)
+
+    def test_typing_module_has_signatures(self):
+        import typing
+        no_signature = {'ParamSpec', 'ParamSpecArgs', 'ParamSpecKwargs',
+                        'Text', 'TypeAliasType', 'TypeVar', 'TypeVarTuple'}
+        methods_no_signature = {
+            'Generic': {'__class_getitem__', '__init_subclass__'},
+        }
+        methods_unsupported_signature = {
+            'Text': {'count', 'find', 'index', 'rfind', 'rindex', 'startswith', 'endswith', 'maketrans'},
+        }
+        self._test_module_has_signatures(typing, no_signature,
+                methods_no_signature=methods_no_signature,
+                methods_unsupported_signature=methods_unsupported_signature)
+
+    def test_warnings_module_has_signatures(self):
+        unsupported_signature = {'warn', 'warn_explicit'}
+        self._test_module_has_signatures(warnings, unsupported_signature=unsupported_signature)
+
+    def test_weakref_module_has_signatures(self):
+        import weakref
+        no_signature = {'ReferenceType', 'ref'}
+        self._test_module_has_signatures(weakref, no_signature)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_python_function_override_signature(self):
+        def func(*args, **kwargs):
+            pass
+        func.__text_signature__ = '($self, a, b=1, *args, c, d=2, **kwargs)'
+        sig = inspect.signature(func)
+        self.assertIsNotNone(sig)
+        self.assertEqual(str(sig), '(self, /, a, b=1, *args, c, d=2, **kwargs)')
+
+        func.__text_signature__ = '($self, a, b=1, /, *args, c, d=2, **kwargs)'
+        sig = inspect.signature(func)
+        self.assertEqual(str(sig), '(self, a, b=1, /, *args, c, d=2, **kwargs)')
+
+        func.__text_signature__ = '(self, a=1+2, b=4-3, c=1 | 3 | 16)'
+        sig = inspect.signature(func)
+        self.assertEqual(str(sig), '(self, a=3, b=1, c=19)')
+
+        func.__text_signature__ = '(self, a=1,\nb=2,\n\n\n   c=3)'
+        sig = inspect.signature(func)
+        self.assertEqual(str(sig), '(self, a=1, b=2, c=3)')
+
+        func.__text_signature__ = '(self, x=does_not_exist)'
+        with self.assertRaises(ValueError):
+            inspect.signature(func)
+        func.__text_signature__ = '(self, x=sys, y=inspect)'
+        with self.assertRaises(ValueError):
+            inspect.signature(func)
+        func.__text_signature__ = '(self, 123)'
+        with self.assertRaises(ValueError):
+            inspect.signature(func)
+
+    @support.requires_docstrings
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_base_class_have_text_signature(self):
+        # see issue 43118
+        from test.typinganndata.ann_module7 import BufferedReader
+        class MyBufferedReader(BufferedReader):
+            """buffer reader class."""
+
+        text_signature = BufferedReader.__text_signature__
+        self.assertEqual(text_signature, '(raw, buffer_size=DEFAULT_BUFFER_SIZE)')
+        sig = inspect.signature(MyBufferedReader)
+        self.assertEqual(str(sig), '(raw, buffer_size=8192)')
+
+
+class NTimesUnwrappable:
+    def __init__(self, n):
+        self.n = n
+        self._next = None
+
+    @property
+    def __wrapped__(self):
+        if self.n <= 0:
+            raise Exception("Unwrapped too many times")
+        if self._next is None:
+            self._next = NTimesUnwrappable(self.n - 1)
+        return self._next
+
+class TestUnwrap(unittest.TestCase):
+
+    def test_unwrap_one(self):
+        def func(a, b):
+            return a + b
+        wrapper = functools.lru_cache(maxsize=20)(func)
+        self.assertIs(inspect.unwrap(wrapper), func)
+
+    def test_unwrap_several(self):
+        def func(a, b):
+            return a + b
+        wrapper = func
+        for __ in range(10):
+            @functools.wraps(wrapper)
+            def wrapper():
+                pass
+        self.assertIsNot(wrapper.__wrapped__, func)
+        self.assertIs(inspect.unwrap(wrapper), func)
+
+    def test_stop(self):
+        def func1(a, b):
+            return a + b
+        @functools.wraps(func1)
+        def func2():
+            pass
+        @functools.wraps(func2)
+        def wrapper():
+            pass
+        func2.stop_here = 1
+        unwrapped = inspect.unwrap(wrapper,
+                                   stop=(lambda f: hasattr(f, "stop_here")))
+        self.assertIs(unwrapped, func2)
+
+    def test_cycle(self):
+        def func1(): pass
+        func1.__wrapped__ = func1
+        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
+            inspect.unwrap(func1)
+
+        def func2(): pass
+        func2.__wrapped__ = func1
+        func1.__wrapped__ = func2
+        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
+            inspect.unwrap(func1)
+        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
+            inspect.unwrap(func2)
+
+    def test_unhashable(self):
+        def func(): pass
+        func.__wrapped__ = None
+        class C:
+            __hash__ = None
+            __wrapped__ = func
+        self.assertIsNone(inspect.unwrap(C()))
+
+    def test_recursion_limit(self):
+        obj = NTimesUnwrappable(sys.getrecursionlimit() + 1)
+        with self.assertRaisesRegex(ValueError, 'wrapper loop'):
+            inspect.unwrap(obj)
+
+    def test_wrapped_descriptor(self):
+        self.assertIs(inspect.unwrap(NTimesUnwrappable), NTimesUnwrappable)
+        self.assertIs(inspect.unwrap(staticmethod), staticmethod)
+        self.assertIs(inspect.unwrap(classmethod), classmethod)
+        self.assertIs(inspect.unwrap(staticmethod(classmethod)), classmethod)
+        self.assertIs(inspect.unwrap(classmethod(staticmethod)), staticmethod)
+
+
+class TestMain(unittest.TestCase):
+    def test_only_source(self):
+        module = importlib.import_module('unittest')
+        rc, out, err = assert_python_ok('-m', 'inspect',
+                                        'unittest')
+        lines = out.decode().splitlines()
+        # ignore the final newline
+        self.assertEqual(lines[:-1], inspect.getsource(module).splitlines())
+        self.assertEqual(err, b'')
+
+    def test_custom_getattr(self):
+        def foo():
+            pass
+        foo.__signature__ = 42
+        with self.assertRaises(TypeError):
+            inspect.signature(foo)
+
+    @unittest.skipIf(ThreadPoolExecutor is None,
+            'threads required to test __qualname__ for source files')
+    def test_qualname_source(self):
+        rc, out, err = assert_python_ok('-m', 'inspect',
+                                     'concurrent.futures:ThreadPoolExecutor')
+        lines = out.decode().splitlines()
+        # ignore the final newline
+        self.assertEqual(lines[:-1],
+                         inspect.getsource(ThreadPoolExecutor).splitlines())
+        self.assertEqual(err, b'')
+
+    def test_builtins(self):
+        _, out, err = assert_python_failure('-m', 'inspect',
+                                            'sys')
+        lines = err.decode().splitlines()
+        self.assertEqual(lines, ["Can't get info for builtin modules."])
+
+    def test_details(self):
+        module = importlib.import_module('unittest')
+        args = support.optim_args_from_interpreter_flags()
+        rc, out, err = assert_python_ok(*args, '-m', 'inspect',
+                                        'unittest', '--details')
+        output = out.decode()
+        # Just a quick sanity check on the output
+        self.assertIn(module.__spec__.name, output)
+        self.assertIn(module.__name__, output)
+        self.assertIn(module.__spec__.origin, output)
+        self.assertIn(module.__file__, output)
+        self.assertIn(module.__spec__.cached, output)
+        self.assertIn(module.__cached__, output)
+        self.assertEqual(err, b'')
+
+
+class TestReload(unittest.TestCase):
+
+    src_before = textwrap.dedent("""\
+def foo():
+    print("Bla")
+    """)
+
+    src_after = textwrap.dedent("""\
+def foo():
+    print("Oh no!")
+    """)
+
+    def assertInspectEqual(self, path, source):
+        inspected_src = inspect.getsource(source)
+        with open(path, encoding='utf-8') as src:
+            self.assertEqual(
+                src.read().splitlines(True),
+                inspected_src.splitlines(True)
+            )
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getsource_reload(self):
+        # see issue 1218234
+        with ready_to_import('reload_bug', self.src_before) as (name, path):
+            module = importlib.import_module(name)
+            self.assertInspectEqual(path, module)
+            with open(path, 'w', encoding='utf-8') as src:
+                src.write(self.src_after)
+            self.assertInspectEqual(path, module)
+
+
+class TestRepl(unittest.TestCase):
+
+    def spawn_repl(self, *args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, **kw):
+        """Run the Python REPL with the given arguments.
+
+        kw is extra keyword args to pass to subprocess.Popen. Returns a Popen
+        object.
+        """
+
+        # To run the REPL without using a terminal, spawn python with the command
+        # line option '-i' and the process name set to '<stdin>'.
+        # The directory of argv[0] must match the directory of the Python
+        # executable for the Popen() call to python to succeed as the directory
+        # path may be used by Py_GetPath() to build the default module search
+        # path.
+        stdin_fname = os.path.join(os.path.dirname(sys.executable), "<stdin>")
+        cmd_line = [stdin_fname, '-E', '-i']
+        cmd_line.extend(args)
+
+        # Set TERM=vt100, for the rationale see the comments in spawn_python() of
+        # test.support.script_helper.
+        env = kw.setdefault('env', dict(os.environ))
+        env['TERM'] = 'vt100'
+        return subprocess.Popen(cmd_line,
+                                executable=sys.executable,
+                                text=True,
+                                stdin=subprocess.PIPE,
+                                stdout=stdout, stderr=stderr,
+                                **kw)
+
+    def run_on_interactive_mode(self, source):
+        """Spawn a new Python interpreter, pass the given
+        input source code from the stdin and return the
+        result back. If the interpreter exits non-zero, it
+        raises a ValueError."""
+
+        process = self.spawn_repl()
+        process.stdin.write(source)
+        output = kill_python(process)
+
+        if process.returncode != 0:
+            raise ValueError("Process didn't exit properly.")
+        return output
+
+    @unittest.skipIf(not has_subprocess_support, "test requires subprocess")
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_getsource(self):
+        output = self.run_on_interactive_mode(textwrap.dedent("""\
+        def f():
+            print(0)
+            return 1 + 2
+
+        import inspect
+        print(f"The source is: <<<{inspect.getsource(f)}>>>")
+        """))
+
+        expected = "The source is: <<<def f():\n    print(0)\n    return 1 + 2\n>>>"
+        self.assertIn(expected, output)
+
+
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py
index 7ac83288f4..1ab7a1fb6d 100644
--- a/Lib/test/test_int.py
+++ b/Lib/test/test_int.py
@@ -1,9 +1,22 @@
 import sys
+import time
 
 import unittest
+# TODO: RUSTPYTHON
+# This is one of the tests that we run on wasi. `unittest.mock` requires `_socket`
+# which we don't have on wasi (yet). Also, every test here the needs `unittest.mock`
+# is cpython specifc, so this import is redundent anyway.
+# from unittest import mock
 from test import support
-from test.test_grammar import (VALID_UNDERSCORE_LITERALS,
-                               INVALID_UNDERSCORE_LITERALS)
+from test.support.numbers import (
+    VALID_UNDERSCORE_LITERALS,
+    INVALID_UNDERSCORE_LITERALS,
+)
+
+try:
+    import _pylong
+except ImportError:
+    _pylong = None
 
 L = [
         ('0', 0),
@@ -83,6 +96,7 @@ def test_basic(self):
 
 
         self.assertRaises(TypeError, int, 1, 12)
+        self.assertRaises(TypeError, int, "10", 2, 1)
 
         self.assertEqual(int('0o123', 0), 83)
         self.assertEqual(int('0x123', 16), 291)
@@ -148,6 +162,8 @@ def test_basic(self):
         self.assertEqual(int(' 0O123   ', 0), 83)
         self.assertEqual(int(' 0X123  ', 0), 291)
         self.assertEqual(int(' 0B100 ', 0), 4)
+        with self.assertRaises(ValueError):
+            int('010', 0)
 
         # without base still base 10
         self.assertEqual(int('0123'), 123)
@@ -214,6 +230,26 @@ def test_basic(self):
         self.assertEqual(int('2br45qc', 35), 4294967297)
         self.assertEqual(int('1z141z5', 36), 4294967297)
 
+    def test_invalid_signs(self):
+        with self.assertRaises(ValueError):
+            int('+')
+        with self.assertRaises(ValueError):
+            int('-')
+        with self.assertRaises(ValueError):
+            int('- 1')
+        with self.assertRaises(ValueError):
+            int('+ 1')
+        with self.assertRaises(ValueError):
+            int(' + 1 ')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_unicode(self):
+        self.assertEqual(int("१२३४५६७८९०1234567890"), 12345678901234567890)
+        self.assertEqual(int('١٢٣٤٥٦٧٨٩٠'), 1234567890)
+        self.assertEqual(int("१२३४५६७८९०1234567890", 0), 12345678901234567890)
+        self.assertEqual(int('١٢٣٤٥٦٧٨٩٠', 0), 1234567890)
+
     def test_underscores(self):
         for lit in VALID_UNDERSCORE_LITERALS:
             if any(ch in lit for ch in '.eEjJ'):
@@ -233,7 +269,7 @@ def test_underscores(self):
         self.assertRaises(ValueError, int, "1__00")
         self.assertRaises(ValueError, int, "100_")
 
-    # @support.cpython_only
+    @support.cpython_only
     def test_small_ints(self):
         # Bug #3236: Return small longs from PyLong_FromString
         self.assertIs(int('10'), 10)
@@ -369,12 +405,14 @@ def __trunc__(self):
             class JustTrunc(base):
                 def __trunc__(self):
                     return 42
-            self.assertEqual(int(JustTrunc()), 42)
+            with self.assertWarns(DeprecationWarning):
+                self.assertEqual(int(JustTrunc()), 42)
 
             class ExceptionalTrunc(base):
                 def __trunc__(self):
                     1 / 0
-            with self.assertRaises(ZeroDivisionError):
+            with self.assertRaises(ZeroDivisionError), \
+                 self.assertWarns(DeprecationWarning):
                 int(ExceptionalTrunc())
 
             for trunc_result_base in (object, Classic):
@@ -385,7 +423,8 @@ def __index__(self):
                 class TruncReturnsNonInt(base):
                     def __trunc__(self):
                         return Index()
-                self.assertEqual(int(TruncReturnsNonInt()), 42)
+                with self.assertWarns(DeprecationWarning):
+                    self.assertEqual(int(TruncReturnsNonInt()), 42)
 
                 class Intable(trunc_result_base):
                     def __int__(self):
@@ -394,7 +433,8 @@ def __int__(self):
                 class TruncReturnsNonIndex(base):
                     def __trunc__(self):
                         return Intable()
-                self.assertEqual(int(TruncReturnsNonInt()), 42)
+                with self.assertWarns(DeprecationWarning):
+                    self.assertEqual(int(TruncReturnsNonInt()), 42)
 
                 class NonIntegral(trunc_result_base):
                     def __trunc__(self):
@@ -405,7 +445,8 @@ class TruncReturnsNonIntegral(base):
                     def __trunc__(self):
                         return NonIntegral()
                 try:
-                    int(TruncReturnsNonIntegral())
+                    with self.assertWarns(DeprecationWarning):
+                        int(TruncReturnsNonIntegral())
                 except TypeError as e:
                     self.assertEqual(str(e),
                                       "__trunc__ returned non-Integral"
@@ -423,7 +464,8 @@ class TruncReturnsBadInt(base):
                     def __trunc__(self):
                         return BadInt()
 
-                with self.assertRaises(TypeError):
+                with self.assertRaises(TypeError), \
+                     self.assertWarns(DeprecationWarning):
                     int(TruncReturnsBadInt())
 
     def test_int_subclass_with_index(self):
@@ -517,13 +559,16 @@ def __trunc__(self):
         self.assertIs(type(n), int)
 
         bad_int = TruncReturnsBadInt()
-        self.assertRaises(TypeError, int, bad_int)
+        with self.assertWarns(DeprecationWarning):
+            self.assertRaises(TypeError, int, bad_int)
 
         good_int = TruncReturnsIntSubclass()
-        n = int(good_int)
+        with self.assertWarns(DeprecationWarning):
+            n = int(good_int)
         self.assertEqual(n, 1)
         self.assertIs(type(n), int)
-        n = IntSubclass(good_int)
+        with self.assertWarns(DeprecationWarning):
+            n = IntSubclass(good_int)
         self.assertEqual(n, 1)
         self.assertIs(type(n), IntSubclass)
 
@@ -568,5 +613,326 @@ def test_issue31619(self):
         self.assertEqual(int('1_2_3_4_5_6_7', 32), 1144132807)
 
 
+class IntStrDigitLimitsTests(unittest.TestCase):
+
+    int_class = int  # Override this in subclasses to reuse the suite.
+
+    def setUp(self):
+        super().setUp()
+        self._previous_limit = sys.get_int_max_str_digits()
+        sys.set_int_max_str_digits(2048)
+
+    def tearDown(self):
+        sys.set_int_max_str_digits(self._previous_limit)
+        super().tearDown()
+
+    def test_disabled_limit(self):
+        self.assertGreater(sys.get_int_max_str_digits(), 0)
+        self.assertLess(sys.get_int_max_str_digits(), 20_000)
+        with support.adjust_int_max_str_digits(0):
+            self.assertEqual(sys.get_int_max_str_digits(), 0)
+            i = self.int_class('1' * 20_000)
+            str(i)
+        self.assertGreater(sys.get_int_max_str_digits(), 0)
+
+    def test_max_str_digits_edge_cases(self):
+        """Ignore the +/- sign and space padding."""
+        int_class = self.int_class
+        maxdigits = sys.get_int_max_str_digits()
+
+        int_class('1' * maxdigits)
+        int_class(' ' + '1' * maxdigits)
+        int_class('1' * maxdigits + ' ')
+        int_class('+' + '1' * maxdigits)
+        int_class('-' + '1' * maxdigits)
+        self.assertEqual(len(str(10 ** (maxdigits - 1))), maxdigits)
+
+    def check(self, i, base=None):
+        with self.assertRaises(ValueError):
+            if base is None:
+                self.int_class(i)
+            else:
+                self.int_class(i, base)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_max_str_digits(self):
+        maxdigits = sys.get_int_max_str_digits()
+
+        self.check('1' * (maxdigits + 1))
+        self.check(' ' + '1' * (maxdigits + 1))
+        self.check('1' * (maxdigits + 1) + ' ')
+        self.check('+' + '1' * (maxdigits + 1))
+        self.check('-' + '1' * (maxdigits + 1))
+        self.check('1' * (maxdigits + 1))
+
+        i = 10 ** maxdigits
+        with self.assertRaises(ValueError):
+            str(i)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    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()
+        assert maxdigits < 50_000, maxdigits  # A test prerequisite.
+
+        huge_int = int(f'0x{"c"*65_000}', base=16)  # 78268 decimal digits.
+        digits = 78_268
+        with (
+                support.adjust_int_max_str_digits(digits),
+                support.CPUStopwatch() as sw_convert):
+            huge_decimal = str(huge_int)
+        self.assertEqual(len(huge_decimal), digits)
+        # Ensuring that we chose a slow enough conversion to measure.
+        # It takes 0.1 seconds on a Zen based cloud VM in an opt build.
+        # Some OSes have a low res 1/64s timer, skip if hard to measure.
+        if sw_convert.seconds < sw_convert.clock_info.resolution * 2:
+            raise unittest.SkipTest('"slow" conversion took only '
+                                    f'{sw_convert.seconds} seconds.')
+
+        # We test with the limit almost at the size needed to check performance.
+        # The performant limit check is slightly fuzzy, give it a some room.
+        with support.adjust_int_max_str_digits(int(.995 * digits)):
+            with (
+                    self.assertRaises(ValueError) as err,
+                    support.CPUStopwatch() as sw_fail_huge):
+                str(huge_int)
+        self.assertIn('conversion', str(err.exception))
+        self.assertLessEqual(sw_fail_huge.seconds, sw_convert.seconds/2)
+
+        # Now we test that a conversion that would take 30x as long also fails
+        # in a similarly fast fashion.
+        extra_huge_int = int(f'0x{"c"*500_000}', base=16)  # 602060 digits.
+        with (
+                self.assertRaises(ValueError) as err,
+                support.CPUStopwatch() as sw_fail_extra_huge):
+            # If not limited, 8 seconds said Zen based cloud VM.
+            str(extra_huge_int)
+        self.assertIn('conversion', str(err.exception))
+        self.assertLess(sw_fail_extra_huge.seconds, sw_convert.seconds/2)
+
+    @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()
+        assert maxdigits < 100_000, maxdigits  # A test prerequisite.
+
+        digits = 133700
+        huge = '8'*digits
+        with (
+                support.adjust_int_max_str_digits(digits),
+                support.CPUStopwatch() as sw_convert):
+            int(huge)
+        # Ensuring that we chose a slow enough conversion to measure.
+        # It takes 0.1 seconds on a Zen based cloud VM in an opt build.
+        # Some OSes have a low res 1/64s timer, skip if hard to measure.
+        if sw_convert.seconds < sw_convert.clock_info.resolution * 2:
+            raise unittest.SkipTest('"slow" conversion took only '
+                                    f'{sw_convert.seconds} seconds.')
+
+        with support.adjust_int_max_str_digits(digits - 1):
+            with (
+                    self.assertRaises(ValueError) as err,
+                    support.CPUStopwatch() as sw_fail_huge):
+                int(huge)
+        self.assertIn('conversion', str(err.exception))
+        self.assertLessEqual(sw_fail_huge.seconds, sw_convert.seconds/2)
+
+        # Now we test that a conversion that would take 30x as long also fails
+        # in a similarly fast fashion.
+        extra_huge = '7'*1_200_000
+        with (
+                self.assertRaises(ValueError) as err,
+                support.CPUStopwatch() as sw_fail_extra_huge):
+            # If not limited, 8 seconds in the Zen based cloud VM.
+            int(extra_huge)
+        self.assertIn('conversion', str(err.exception))
+        self.assertLessEqual(sw_fail_extra_huge.seconds, sw_convert.seconds/2)
+
+    def test_power_of_two_bases_unlimited(self):
+        """The limit does not apply to power of 2 bases."""
+        maxdigits = sys.get_int_max_str_digits()
+
+        for base in (2, 4, 8, 16, 32):
+            with self.subTest(base=base):
+                self.int_class('1' * (maxdigits + 1), base)
+                assert maxdigits < 100_000
+                self.int_class('1' * 100_000, base)
+
+    def test_underscores_ignored(self):
+        maxdigits = sys.get_int_max_str_digits()
+
+        triples = maxdigits // 3
+        s = '111' * triples
+        s_ = '1_11' * triples
+        self.int_class(s)  # succeeds
+        self.int_class(s_)  # succeeds
+        self.check(f'{s}111')
+        self.check(f'{s_}_111')
+
+    def test_sign_not_counted(self):
+        int_class = self.int_class
+        max_digits = sys.get_int_max_str_digits()
+        s = '5' * max_digits
+        i = int_class(s)
+        pos_i = int_class(f'+{s}')
+        assert i == pos_i
+        neg_i = int_class(f'-{s}')
+        assert -pos_i == neg_i
+        str(pos_i)
+        str(neg_i)
+
+    def _other_base_helper(self, base):
+        int_class = self.int_class
+        max_digits = sys.get_int_max_str_digits()
+        s = '2' * max_digits
+        i = int_class(s, base)
+        if base > 10:
+            with self.assertRaises(ValueError):
+                str(i)
+        elif base < 10:
+            str(i)
+        with self.assertRaises(ValueError) as err:
+            int_class(f'{s}1', base)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_int_from_other_bases(self):
+        base = 3
+        with self.subTest(base=base):
+            self._other_base_helper(base)
+        base = 36
+        with self.subTest(base=base):
+            self._other_base_helper(base)
+
+    def test_int_max_str_digits_is_per_interpreter(self):
+        # Changing the limit in one interpreter does not change others.
+        code = """if 1:
+        # Subinterpreters maintain and enforce their own limit
+        import sys
+        sys.set_int_max_str_digits(2323)
+        try:
+            int('3'*3333)
+        except ValueError:
+            pass
+        else:
+            raise AssertionError('Expected a int max str digits ValueError.')
+        """
+        with support.adjust_int_max_str_digits(4000):
+            before_value = sys.get_int_max_str_digits()
+            self.assertEqual(support.run_in_subinterp(code), 0,
+                             'subinterp code failure, check stderr.')
+            after_value = sys.get_int_max_str_digits()
+            self.assertEqual(before_value, after_value)
+
+
+class IntSubclassStrDigitLimitsTests(IntStrDigitLimitsTests):
+    int_class = IntSubclass
+
+
+class PyLongModuleTests(unittest.TestCase):
+    # Tests of the functions in _pylong.py.  Those get used when the
+    # number of digits in the input values are large enough.
+
+    def setUp(self):
+        super().setUp()
+        self._previous_limit = sys.get_int_max_str_digits()
+        sys.set_int_max_str_digits(0)
+
+    def tearDown(self):
+        sys.set_int_max_str_digits(self._previous_limit)
+        super().tearDown()
+
+    def _test_pylong_int_to_decimal(self, n, suffix):
+        s = str(n)
+        self.assertEqual(s[-10:], suffix)
+        s2 = str(-n)
+        self.assertEqual(s2, '-' + s)
+        s3 = '%d' % n
+        self.assertEqual(s3, s)
+        s4 = b'%d' % n
+        self.assertEqual(s4, s.encode('ascii'))
+
+    def test_pylong_int_to_decimal(self):
+        self._test_pylong_int_to_decimal((1 << 100_000), '9883109376')
+        self._test_pylong_int_to_decimal((1 << 100_000) - 1, '9883109375')
+        self._test_pylong_int_to_decimal(10**30_000, '0000000000')
+        self._test_pylong_int_to_decimal(10**30_000 - 1, '9999999999')
+        self._test_pylong_int_to_decimal(3**60_000, '9313200001')
+
+    @support.requires_resource('cpu')
+    def test_pylong_int_to_decimal_2(self):
+        self._test_pylong_int_to_decimal(2**1_000_000, '2747109376')
+        self._test_pylong_int_to_decimal(10**300_000, '0000000000')
+        self._test_pylong_int_to_decimal(3**600_000, '3132000001')
+
+    def test_pylong_int_divmod(self):
+        n = (1 << 100_000)
+        a, b = divmod(n*3 + 1, n)
+        assert a == 3 and b == 1
+
+    def test_pylong_str_to_int(self):
+        v1 = 1 << 100_000
+        s = str(v1)
+        v2 = int(s)
+        assert v1 == v2
+        v3 = int(' -' + s)
+        assert -v1 == v3
+        v4 = int(' +' + s + ' ')
+        assert v1 == v4
+        with self.assertRaises(ValueError) as err:
+            int(s + 'z')
+        with self.assertRaises(ValueError) as err:
+            int(s + '_')
+        with self.assertRaises(ValueError) as err:
+            int('_' + s)
+
+    @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
+    def test_pylong_misbehavior_error_path_to_str(
+            self, mock_int_to_str):
+        with support.adjust_int_max_str_digits(20_000):
+            big_value = int('7'*19_999)
+            mock_int_to_str.return_value = None  # not a str
+            with self.assertRaises(TypeError) as ctx:
+                str(big_value)
+            self.assertIn('_pylong.int_to_decimal_string did not',
+                          str(ctx.exception))
+            mock_int_to_str.side_effect = RuntimeError("testABC")
+            with self.assertRaises(RuntimeError):
+                str(big_value)
+
+    @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
+    def test_pylong_misbehavior_error_path_from_str(
+            self, mock_int_from_str):
+        big_value = '7'*19_999
+        with support.adjust_int_max_str_digits(20_000):
+            mock_int_from_str.return_value = b'not an int'
+            with self.assertRaises(TypeError) as ctx:
+                int(big_value)
+            self.assertIn('_pylong.int_from_string did not',
+                          str(ctx.exception))
+
+            mock_int_from_str.side_effect = RuntimeError("test123")
+            with self.assertRaises(RuntimeError):
+                int(big_value)
+
+    def test_pylong_roundtrip(self):
+        from random import randrange, getrandbits
+        bits = 5000
+        while bits <= 1_000_000:
+            bits += randrange(-100, 101) # break bitlength patterns
+            hibit = 1 << (bits - 1)
+            n = hibit | getrandbits(bits - 1)
+            assert n.bit_length() == bits
+            sn = str(n)
+            self.assertFalse(sn.startswith('0'))
+            self.assertEqual(n, int(sn))
+            bits <<= 1
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index e91d454b72..741920a586 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -39,11 +39,9 @@
 from test import support
 from test.support.script_helper import (
     assert_python_ok, assert_python_failure, run_python_until_end)
-from test.support import import_helper
-from test.support import os_helper
-from test.support import threading_helper
-from test.support import warnings_helper
-from test.support import skip_if_sanitizer
+from test.support import (
+    import_helper, is_apple, os_helper, threading_helper, warnings_helper,
+)
 from test.support.os_helper import FakePath
 
 import codecs
@@ -66,10 +64,6 @@ def byteslike(*pos, **kw):
     class EmptyStruct(ctypes.Structure):
         pass
 
-# Does io.IOBase finalizer log the exception if the close() method fails?
-# The exception is ignored silently by default in release build.
-IOBASE_EMITS_UNRAISABLE = (support.Py_DEBUG or sys.flags.dev_mode)
-
 
 def _default_chunk_size():
     """Get the default TextIOWrapper chunk size"""
@@ -631,10 +625,10 @@ def test_raw_bytes_io(self):
         self.read_ops(f, True)
 
     def test_large_file_ops(self):
-        # On Windows and Mac OSX this test consumes large resources; It takes
-        # a long time to build the >2 GiB file and takes >2 GiB of disk space
-        # therefore the resource must be enabled to run this test.
-        if sys.platform[:3] == 'win' or sys.platform == 'darwin':
+        # On Windows and Apple platforms this test consumes large resources; It
+        # takes a long time to build the >2 GiB file and takes >2 GiB of disk
+        # space therefore the resource must be enabled to run this test.
+        if sys.platform[:3] == 'win' or is_apple:
             support.requires(
                 'largefile',
                 'test requires %s bytes and a long time to run' % self.LARGE)
@@ -645,11 +639,9 @@ def test_large_file_ops(self):
 
     def test_with_open(self):
         for bufsize in (0, 100):
-            f = None
             with self.open(os_helper.TESTFN, "wb", bufsize) as f:
                 f.write(b"xxx")
             self.assertEqual(f.closed, True)
-            f = None
             try:
                 with self.open(os_helper.TESTFN, "wb", bufsize) as f:
                     1/0
@@ -788,8 +780,8 @@ def test_closefd_attr(self):
             file = self.open(f.fileno(), "r", encoding="utf-8", closefd=False)
             self.assertEqual(file.buffer.raw.closefd, False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
         # FileIO objects are collected, and collecting them flushes
         # all data to disk.
@@ -879,6 +871,22 @@ def test_RawIOBase_read(self):
         self.assertEqual(rawio.read(2), None)
         self.assertEqual(rawio.read(2), b"")
 
+    def test_RawIOBase_read_bounds_checking(self):
+        # Make sure a `.readinto` call which returns a value outside
+        # (0, len(buffer)) raises.
+        class Misbehaved(self.RawIOBase):
+            def __init__(self, readinto_return) -> None:
+                self._readinto_return = readinto_return
+            def readinto(self, b):
+                return self._readinto_return
+
+        with self.assertRaises(ValueError) as cm:
+            Misbehaved(2).read(1)
+        self.assertEqual(str(cm.exception), "readinto returned 2 outside buffer size 1")
+        for bad_size in (2147483647, sys.maxsize, -1, -1000):
+            with self.assertRaises(ValueError):
+                Misbehaved(bad_size).read()
+
     def test_types_have_dict(self):
         test = (
             self.IOBase(),
@@ -904,7 +912,7 @@ def test_bad_opener_negative_1(self):
         def badopener(fname, flags):
             return -1
         with self.assertRaises(ValueError) as cm:
-            open('non-existent', 'r', opener=badopener)
+            self.open('non-existent', 'r', opener=badopener)
         self.assertEqual(str(cm.exception), 'opener returned -1')
 
     def test_bad_opener_other_negative(self):
@@ -912,7 +920,7 @@ def test_bad_opener_other_negative(self):
         def badopener(fname, flags):
             return -2
         with self.assertRaises(ValueError) as cm:
-            open('non-existent', 'r', opener=badopener)
+            self.open('non-existent', 'r', opener=badopener)
         self.assertEqual(str(cm.exception), 'opener returned -2')
 
     def test_opener_invalid_fd(self):
@@ -1048,11 +1056,41 @@ def flush(self):
         # Silence destructor error
         R.flush = lambda self: None
 
+    @threading_helper.requires_working_threading()
+    def test_write_readline_races(self):
+        # gh-134908: Concurrent iteration over a file caused races
+        thread_count = 2
+        write_count = 100
+        read_count = 100
+
+        def writer(file, barrier):
+            barrier.wait()
+            for _ in range(write_count):
+                file.write("x")
+
+        def reader(file, barrier):
+            barrier.wait()
+            for _ in range(read_count):
+                for line in file:
+                    self.assertEqual(line, "")
+
+        with self.open(os_helper.TESTFN, "w+") as f:
+            barrier = threading.Barrier(thread_count + 1)
+            reader = threading.Thread(target=reader, args=(f, barrier))
+            writers = [threading.Thread(target=writer, args=(f, barrier))
+                       for _ in range(thread_count)]
+            with threading_helper.catch_threading_exception() as cm:
+                with threading_helper.start_threads(writers + [reader]):
+                    pass
+                self.assertIsNone(cm.exc_type)
+
+        self.assertEqual(os.stat(os_helper.TESTFN).st_size,
+                         write_count * thread_count)
+
 
 class CIOTest(IOTest):
 
-    # TODO: RUSTPYTHON, cyclic gc
-    @unittest.expectedFailure
+    @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
@@ -1071,10 +1109,9 @@ def close(self):
         support.gc_collect()
         self.assertIsNone(wr(), wr)
 
-    # TODO: RUSTPYTHON, AssertionError: filter ('', ResourceWarning) did not catch any warning
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: filter ('', ResourceWarning) did not catch any warning
     def test_destructor(self):
-        super().test_destructor(self)
+        return super().test_destructor()
 
 @support.cpython_only
 class TestIOCTypes(unittest.TestCase):
@@ -1165,6 +1202,21 @@ def test_disallow_instantiation(self):
         _io = self._io
         support.check_disallow_instantiation(self, _io._BytesIOBuffer)
 
+    def test_stringio_setstate(self):
+        # gh-127182: Calling __setstate__() with invalid arguments must not crash
+        obj = self._io.StringIO()
+        with self.assertRaisesRegex(
+            TypeError,
+            'initial_value must be str or None, not int',
+        ):
+            obj.__setstate__((1, '', 0, {}))
+
+        obj.__setstate__((None, '', 0, {}))  # should not crash
+        self.assertEqual(obj.getvalue(), '')
+
+        obj.__setstate__(('', '', 0, {}))
+        self.assertEqual(obj.getvalue(), '')
+
 class PyIOTest(IOTest):
     pass
 
@@ -1175,7 +1227,7 @@ class APIMismatchTest(unittest.TestCase):
     def test_RawIOBase_io_in_pyio_match(self):
         """Test that pyio RawIOBase class has all c RawIOBase methods"""
         mismatch = support.detect_api_mismatch(pyio.RawIOBase, io.RawIOBase,
-                                               ignore=('__weakref__',))
+                                               ignore=('__weakref__', '__static_attributes__'))
         self.assertEqual(mismatch, set(), msg='Python RawIOBase does not have all C RawIOBase methods')
 
     def test_RawIOBase_pyio_in_io_match(self):
@@ -1252,10 +1304,7 @@ def test_error_through_destructor(self):
             with self.assertRaises(AttributeError):
                 self.tp(rawio).xyzzy
 
-            if not IOBASE_EMITS_UNRAISABLE:
-                self.assertIsNone(cm.unraisable)
-            elif cm.unraisable is not None:
-                self.assertEqual(cm.unraisable.exc_type, OSError)
+            self.assertEqual(cm.unraisable.exc_type, OSError)
 
     def test_repr(self):
         raw = self.MockRawIO()
@@ -1271,11 +1320,9 @@ def test_recursive_repr(self):
         # Issue #25455
         raw = self.MockRawIO()
         b = self.tp(raw)
-        with support.swap_attr(raw, 'name', b):
-            try:
+        with support.swap_attr(raw, 'name', b), support.infinite_recursion(25):
+            with self.assertRaises(RuntimeError):
                 repr(b)  # Should not crash
-            except RuntimeError:
-                pass
 
     def test_flush_error_on_close(self):
         # Test that buffered file is closed despite failed flush
@@ -1356,6 +1403,28 @@ def test_readonly_attributes(self):
         with self.assertRaises(AttributeError):
             buf.raw = x
 
+    def test_pickling_subclass(self):
+        global MyBufferedIO
+        class MyBufferedIO(self.tp):
+            def __init__(self, raw, tag):
+                super().__init__(raw)
+                self.tag = tag
+            def __getstate__(self):
+                return self.tag, self.raw.getvalue()
+            def __setstate__(slf, state):
+                tag, value = state
+                slf.__init__(self.BytesIO(value), tag)
+
+        raw = self.BytesIO(b'data')
+        buf = MyBufferedIO(raw, tag='ham')
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(protocol=proto):
+                pickled = pickle.dumps(buf, proto)
+                newbuf = pickle.loads(pickled)
+                self.assertEqual(newbuf.raw.getvalue(), b'data')
+                self.assertEqual(newbuf.tag, 'ham')
+        del MyBufferedIO
+
 
 class SizeofTest:
 
@@ -1717,20 +1786,6 @@ def test_seek_character_device_file(self):
 class CBufferedReaderTest(BufferedReaderTest, SizeofTest):
     tp = io.BufferedReader
 
-    @unittest.skip("TODO: RUSTPYTHON, fallible allocation")
-    @skip_if_sanitizer(memory=True, address=True, thread=True,
-                       reason="sanitizer defaults to crashing "
-                       "instead of returning NULL for malloc failure.")
-    def test_constructor(self):
-        BufferedReaderTest.test_constructor(self)
-        # The allocation can succeed on 32-bit builds, e.g. with more
-        # than 2 GiB RAM and a 64-bit kernel.
-        if sys.maxsize > 0x7FFFFFFF:
-            rawio = self.MockRawIO()
-            bufio = self.tp(rawio)
-            self.assertRaises((OverflowError, MemoryError, ValueError),
-                bufio.__init__, rawio, sys.maxsize)
-
     def test_initialization(self):
         rawio = self.MockRawIO([b"abc"])
         bufio = self.tp(rawio)
@@ -1748,8 +1803,8 @@ def test_misbehaved_io_read(self):
         # checking this is not so easy.
         self.assertRaises(OSError, bufio.read, 10)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
         # C BufferedReader objects are collected.
         # The Python version has __del__, so it ends into gc.garbage instead
@@ -1766,40 +1821,31 @@ def test_garbage_collection(self):
     def test_args_error(self):
         # Issue #17275
         with self.assertRaisesRegex(TypeError, "BufferedReader"):
-            self.tp(io.BytesIO(), 1024, 1024, 1024)
+            self.tp(self.BytesIO(), 1024, 1024, 1024)
 
     def test_bad_readinto_value(self):
-        rawio = io.BufferedReader(io.BytesIO(b"12"))
+        rawio = self.tp(self.BytesIO(b"12"))
         rawio.readinto = lambda buf: -1
         bufio = self.tp(rawio)
         with self.assertRaises(OSError) as cm:
             bufio.readline()
         self.assertIsNone(cm.exception.__cause__)
 
-    # TODO: RUSTPYTHON, TypeError: 'bytes' object cannot be interpreted as an integer")
-    @unittest.expectedFailure
     def test_bad_readinto_type(self):
-        rawio = io.BufferedReader(io.BytesIO(b"12"))
+        rawio = self.tp(self.BytesIO(b"12"))
         rawio.readinto = lambda buf: b''
         bufio = self.tp(rawio)
         with self.assertRaises(OSError) as cm:
             bufio.readline()
         self.assertIsInstance(cm.exception.__cause__, TypeError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_flush_error_on_close(self):
-        super().test_flush_error_on_close()
-
-    # TODO: RUSTPYTHON, AssertionError: UnsupportedOperation not raised by truncate
-    @unittest.expectedFailure
-    def test_truncate_on_read_only(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_truncate_on_read_only() # TODO: RUSTPYTHON, remove when this passes
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_seek_character_device_file(self):
-        super().test_seek_character_device_file()
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pickling_subclass(self):
+        return super().test_pickling_subclass()
 
 
 class PyBufferedReaderTest(BufferedReaderTest):
@@ -1909,8 +1955,6 @@ def _seekrel(bufio):
     def test_writes_and_truncates(self):
         self.check_writes(lambda bufio: bufio.truncate(bufio.tell()))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_write_non_blocking(self):
         raw = self.MockNonBlockWriterIO()
         bufio = self.tp(raw, 8)
@@ -2107,20 +2151,6 @@ def test_slow_close_from_thread(self):
 class CBufferedWriterTest(BufferedWriterTest, SizeofTest):
     tp = io.BufferedWriter
 
-    @unittest.skip("TODO: RUSTPYTHON, fallible allocation")
-    @skip_if_sanitizer(memory=True, address=True, thread=True,
-                       reason="sanitizer defaults to crashing "
-                       "instead of returning NULL for malloc failure.")
-    def test_constructor(self):
-        BufferedWriterTest.test_constructor(self)
-        # The allocation can succeed on 32-bit builds, e.g. with more
-        # than 2 GiB RAM and a 64-bit kernel.
-        if sys.maxsize > 0x7FFFFFFF:
-            rawio = self.MockRawIO()
-            bufio = self.tp(rawio)
-            self.assertRaises((OverflowError, MemoryError, ValueError),
-                bufio.__init__, rawio, sys.maxsize)
-
     def test_initialization(self):
         rawio = self.MockRawIO()
         bufio = self.tp(rawio)
@@ -2131,8 +2161,8 @@ def test_initialization(self):
         self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
         self.assertRaises(ValueError, bufio.write, b"def")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
         # C BufferedWriter objects are collected, and collecting them flushes
         # all data to disk.
@@ -2155,11 +2185,13 @@ def test_args_error(self):
         with self.assertRaisesRegex(TypeError, "BufferedWriter"):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_flush_error_on_close(self):
-        super().test_flush_error_on_close()
+    @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
@@ -2637,22 +2669,8 @@ def test_interleaved_readline_write(self):
 class CBufferedRandomTest(BufferedRandomTest, SizeofTest):
     tp = io.BufferedRandom
 
-    @unittest.skip("TODO: RUSTPYTHON, fallible allocation")
-    @skip_if_sanitizer(memory=True, address=True, thread=True,
-                       reason="sanitizer defaults to crashing "
-                       "instead of returning NULL for malloc failure.")
-    def test_constructor(self):
-        BufferedRandomTest.test_constructor(self)
-        # The allocation can succeed on 32-bit builds, e.g. with more
-        # than 2 GiB RAM and a 64-bit kernel.
-        if sys.maxsize > 0x7FFFFFFF:
-            rawio = self.MockRawIO()
-            bufio = self.tp(rawio)
-            self.assertRaises((OverflowError, MemoryError, ValueError),
-                bufio.__init__, rawio, sys.maxsize)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
         CBufferedReaderTest.test_garbage_collection(self)
         CBufferedWriterTest.test_garbage_collection(self)
@@ -2662,20 +2680,13 @@ def test_args_error(self):
         with self.assertRaisesRegex(TypeError, "BufferedRandom"):
             self.tp(self.BytesIO(), 1024, 1024, 1024)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_flush_error_on_close(self):
-        super().test_flush_error_on_close()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_seek_character_device_file(self):
-        super().test_seek_character_device_file()
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_through_destructor(self):
+        return super().test_error_through_destructor()
 
-    # TODO: RUSTPYTHON; f.read1(1) returns b'a'
-    @unittest.expectedFailure
-    def test_read1_after_write(self):
-        super().test_read1_after_write()
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pickling_subclass(self):
+        return super().test_pickling_subclass()
 
 
 class PyBufferedRandomTest(BufferedRandomTest):
@@ -2935,11 +2946,16 @@ def test_recursive_repr(self):
         # Issue #25455
         raw = self.BytesIO()
         t = self.TextIOWrapper(raw, encoding="utf-8")
-        with support.swap_attr(raw, 'name', t):
-            try:
+        with support.swap_attr(raw, 'name', t), support.infinite_recursion(25):
+            with self.assertRaises(RuntimeError):
                 repr(t)  # Should not crash
-            except RuntimeError:
-                pass
+
+    def test_subclass_repr(self):
+        class TestSubclass(self.TextIOWrapper):
+            pass
+
+        f = TestSubclass(self.StringIO())
+        self.assertIn(TestSubclass.__name__, repr(f))
 
     def test_line_buffering(self):
         r = self.BytesIO()
@@ -3174,10 +3190,7 @@ def test_error_through_destructor(self):
             with self.assertRaises(AttributeError):
                 self.TextIOWrapper(rawio, encoding="utf-8").xyzzy
 
-            if not IOBASE_EMITS_UNRAISABLE:
-                self.assertIsNone(cm.unraisable)
-            elif cm.unraisable is not None:
-                self.assertEqual(cm.unraisable.exc_type, OSError)
+            self.assertEqual(cm.unraisable.exc_type, OSError)
 
     # Systematic tests of the text I/O API
 
@@ -3327,8 +3340,7 @@ def test_seek_and_tell_with_data(data, min_pos=0):
         finally:
             StatefulIncrementalDecoder.codecEnabled = 0
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multibyte_seek_and_tell(self):
         f = self.open(os_helper.TESTFN, "w", encoding="euc_jp")
         f.write("AB\n\u3046\u3048\n")
@@ -3344,8 +3356,24 @@ def test_multibyte_seek_and_tell(self):
         self.assertEqual(f.tell(), p1)
         f.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_tell_after_readline_with_cr(self):
+        # Test for gh-141314: TextIOWrapper.tell() assertion failure
+        # when dealing with standalone carriage returns
+        data = b'line1\r'
+        with self.open(os_helper.TESTFN, "wb") as f:
+            f.write(data)
+
+        with self.open(os_helper.TESTFN, "r") as f:
+            # Read line that ends with \r
+            line = f.readline()
+            self.assertEqual(line, "line1\n")
+            # This should not cause an assertion failure
+            pos = f.tell()
+            # Verify we can seek back to this position
+            f.seek(pos)
+            remaining = f.read()
+            self.assertEqual(remaining, "")
+
     def test_seek_with_encoder_state(self):
         f = self.open(os_helper.TESTFN, "w", encoding="euc_jis_2004")
         f.write("\u00e6\u0300")
@@ -3359,8 +3387,7 @@ def test_seek_with_encoder_state(self):
         self.assertEqual(f.readline(), "\u00e6\u0300\u0300")
         f.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encoded_writes(self):
         data = "1234567890"
         tests = ("utf-16",
@@ -3499,8 +3526,7 @@ def test_issue2282(self):
 
         self.assertEqual(buffer.seekable(), txt.seekable())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -3516,8 +3542,7 @@ def test_append_bom(self):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'aaaxxx'.encode(charset))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_seek_bom(self):
         # Same test, but when seeking manually
         filename = os_helper.TESTFN
@@ -3533,8 +3558,7 @@ def test_seek_bom(self):
             with self.open(filename, 'rb') as f:
                 self.assertEqual(f.read(), 'bbbzzz'.encode(charset))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -3795,17 +3819,14 @@ def _check_create_at_shutdown(self, **kwargs):
             codecs.lookup('utf-8')
 
             class C:
-                def __init__(self):
-                    self.buf = io.BytesIO()
                 def __del__(self):
-                    io.TextIOWrapper(self.buf, **{kwargs})
+                    io.TextIOWrapper(io.BytesIO(), **{kwargs})
                     print("ok")
             c = C()
             """.format(iomod=iomod, kwargs=kwargs)
         return assert_python_ok("-c", code)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_create_at_shutdown_without_encoding(self):
         rc, out, err = self._check_create_at_shutdown()
         if err:
@@ -3815,8 +3836,7 @@ def test_create_at_shutdown_without_encoding(self):
         else:
             self.assertEqual("ok", out.decode().strip())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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')
@@ -4042,6 +4062,28 @@ def test_issue35928(self):
         f.write(res)
         self.assertEqual(res + f.readline(), 'foo\nbar\n')
 
+    def test_pickling_subclass(self):
+        global MyTextIO
+        class MyTextIO(self.TextIOWrapper):
+            def __init__(self, raw, tag):
+                super().__init__(raw)
+                self.tag = tag
+            def __getstate__(self):
+                return self.tag, self.buffer.getvalue()
+            def __setstate__(slf, state):
+                tag, value = state
+                slf.__init__(self.BytesIO(value), tag)
+
+        raw = self.BytesIO(b'data')
+        txt = MyTextIO(raw, 'ham')
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(protocol=proto):
+                pickled = pickle.dumps(txt, proto)
+                newtxt = pickle.loads(pickled)
+                self.assertEqual(newtxt.buffer.getvalue(), b'data')
+                self.assertEqual(newtxt.tag, 'ham')
+        del MyTextIO
+
 
 class MemviewBytesIO(io.BytesIO):
     '''A BytesIO object whose read method returns memoryviews
@@ -4066,98 +4108,7 @@ class CTextIOWrapperTest(TextIOWrapperTest):
     io = io
     shutdown_error = "LookupError: unknown encoding: ascii"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_constructor(self):
-        super().test_constructor()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_detach(self):
-        super().test_detach()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_encoding_read(self):
-        super().test_reconfigure_encoding_read()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_line_buffering(self):
-        super().test_reconfigure_line_buffering()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_basic_io(self):
-        super().test_basic_io()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_telling(self):
-        super().test_telling()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_uninitialized(self):
-        super().test_uninitialized()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_non_text_encoding_codecs_are_rejected(self):
-        super().test_non_text_encoding_codecs_are_rejected()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_repr(self):
-        super().test_repr()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newlines(self):
-        super().test_newlines()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_newlines_input(self):
-        super().test_newlines_input()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_write_through(self):
-        super().test_reconfigure_write_through()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_write_fromascii(self):
-        super().test_reconfigure_write_fromascii()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_write(self):
-        super().test_reconfigure_write()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_defaults(self):
-        super().test_reconfigure_defaults()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_newline(self):
-        super().test_reconfigure_newline()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_errors(self):
-        super().test_reconfigure_errors()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reconfigure_locale(self):
-        super().test_reconfigure_locale()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_initialization(self):
         r = self.BytesIO(b"\xc3\xa9\n\n")
         b = self.BufferedReader(r, 1000)
@@ -4168,8 +4119,8 @@ def test_initialization(self):
         t = self.TextIOWrapper.__new__(self.TextIOWrapper)
         self.assertRaises(Exception, repr, t)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; cyclic GC not supported, causes file locking')
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_garbage_collection(self):
         # C TextIOWrapper objects are collected, and collecting them flushes
         # all data to disk.
@@ -4233,20 +4184,119 @@ 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
+
+        class MockIO(self.MockRawIO):
+            written = False
+            def write(self, data):
+                if not self.written:
+                    self.written = True
+                    t.write("middle")
+                return super().write(data)
+
+        buf = MockIO()
+        t = self.TextIOWrapper(buf)
+        t.write("abc")
+        t.write("def")
+        # writing data which size >= chunk_size cause flushing buffer before write.
+        t.write("g" * chunk_size)
+        t.flush()
+
+        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()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_pickling_subclass(self):
+        return super().test_pickling_subclass()
+
+    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
+    @unittest.expectedFailure
+    def test_seek_with_encoder_state(self):
+        return super().test_seek_with_encoder_state()
+
 
 class PyTextIOWrapperTest(TextIOWrapperTest):
     io = pyio
     shutdown_error = "LookupError: unknown encoding: ascii"
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: ValueError not raised
     def test_constructor(self):
-        super().test_constructor()
+        return super().test_constructor()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newlines(self):
-        super().test_newlines()
+        return super().test_newlines()
+
+    # TODO: RUSTPYTHON; euc_jis_2004 encoding not supported
+    @unittest.expectedFailure
+    def test_seek_with_encoder_state(self):
+        return super().test_seek_with_encoder_state()
 
 
 class IncrementalNewlineDecoderTest(unittest.TestCase):
@@ -4326,8 +4376,7 @@ def _decode_bytewise(s):
         self.assertEqual(decoder.decode(input), "abc")
         self.assertEqual(decoder.newlines, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newline_decoder(self):
         encodings = (
             # None meaning the IncrementalNewlineDecoder takes unicode input
@@ -4489,8 +4538,7 @@ def test_io_after_close(self):
             self.assertRaises(ValueError, f.writelines, [])
             self.assertRaises(ValueError, next, f)
 
-    # TODO: RUSTPYTHON, cyclic gc
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; cyclic gc
     def test_blockingioerror(self):
         # Various BlockingIOError issues
         class C(str):
@@ -4538,15 +4586,13 @@ def test_abc_inheritance_official(self):
         self._check_abc_inheritance(io)
 
     def _check_warn_on_dealloc(self, *args, **kwargs):
-        f = open(*args, **kwargs)
+        f = self.open(*args, **kwargs)
         r = repr(f)
         with self.assertWarns(ResourceWarning) as cm:
             f = None
             support.gc_collect()
         self.assertIn(r, str(cm.warning.args[0]))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_warn_on_dealloc(self):
         self._check_warn_on_dealloc(os_helper.TESTFN, "wb", buffering=0)
         self._check_warn_on_dealloc(os_helper.TESTFN, "wb")
@@ -4569,10 +4615,8 @@ def cleanup_fds():
         r, w = os.pipe()
         fds += r, w
         with warnings_helper.check_no_resource_warning(self):
-            open(r, *args, closefd=False, **kwargs)
+            self.open(r, *args, closefd=False, **kwargs)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
     def test_warn_on_dealloc_fd(self):
         self._check_warn_on_dealloc_fd("rb", buffering=0)
@@ -4602,16 +4646,12 @@ def test_pickling(self):
                         with self.assertRaisesRegex(TypeError, msg):
                             pickle.dumps(f, protocol)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
         support.is_emscripten, "fstat() of a pipe fd is not supported"
     )
     def test_nonblock_pipe_write_bigbuf(self):
         self._test_nonblock_pipe_write(16*1024)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
         support.is_emscripten, "fstat() of a pipe fd is not supported"
     )
@@ -4733,8 +4773,7 @@ def test_check_encoding_errors(self):
         proc = assert_python_failure('-X', 'dev', '-c', code)
         self.assertEqual(proc.rc, 10, proc)
 
-    # TODO: RUSTPYTHON, AssertionError: 0 != 2
-    @unittest.expectedFailure
+    @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.
@@ -4758,8 +4797,7 @@ def test_check_encoding_warning(self):
         self.assertTrue(
             warnings[1].startswith(b"<string>:8: EncodingWarning: "))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -4837,10 +4875,19 @@ def test_daemon_threads_shutdown_stdout_deadlock(self):
     def test_daemon_threads_shutdown_stderr_deadlock(self):
         self.check_daemon_threads_shutdown_deadlock('stderr')
 
-    # TODO: RUSTPYTHON, AssertionError: 22 != 10 : _PythonRunResult(rc=22, out=b'', err=b'')
+    @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_check_encoding_errors(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_check_encoding_errors() # TODO: RUSTPYTHON, remove when this passes
+    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):
@@ -5014,16 +5061,12 @@ def alarm_handler(sig, frame):
             os.close(w)
             os.close(r)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_read_retry_buffered(self):
         self.check_interrupted_read_retry(lambda x: x.decode('latin1'),
                                           mode="rb")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_alarm
     @support.requires_resource('walltime')
     def test_interrupted_read_retry_text(self):
@@ -5098,15 +5141,13 @@ def alarm2(sig, frame):
                 if e.errno != errno.EBADF:
                     raise
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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):
@@ -5116,6 +5157,10 @@ def test_interrupted_write_retry_text(self):
 class CSignalsTest(SignalsTest):
     io = io
 
+    @unittest.skip("TODO: RUSTPYTHON thread 'main' (103833) panicked at crates/vm/src/stdlib/signal.rs:233:43: RefCell already borrowed")
+    def test_interrupted_read_retry_buffered(self):  # TODO: RUSTPYTHON
+        return super().test_interrupted_read_retry_buffered()  # TODO: RUSTPYTHON
+
 class PySignalsTest(SignalsTest):
     io = pyio
 
diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
index de80e47209..95a119ba68 100644
--- a/Lib/test/test_isinstance.py
+++ b/Lib/test/test_isinstance.py
@@ -352,9 +352,7 @@ def blowstack(fxn, arg, compare_to):
     # Make sure that calling isinstance with a deeply nested tuple for its
     # argument will raise RecursionError eventually.
     tuple_arg = (compare_to,)
-    # XXX: RUSTPYTHON; support.exceeds_recursion_limit() is not available yet.
-    import sys
-    for cnt in range(sys.getrecursionlimit()+5):
+    for cnt in range(support.exceeds_recursion_limit()):
         tuple_arg = (tuple_arg,)
         fxn(arg, tuple_arg)
 
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 8709948b92..1c0c38ee04 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -1,5 +1,6 @@
 import doctest
 import unittest
+import itertools
 from test import support
 from test.support import threading_helper, script_helper
 from itertools import *
@@ -29,10 +30,11 @@ def inner(self):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", category=DeprecationWarning)
             testfunc(self)
-        with warnings.catch_warnings():
-            warnings.simplefilter("error", category=DeprecationWarning)
-            with self.assertRaises((DeprecationWarning, AssertionError, SystemError)):
-                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
 
@@ -144,8 +146,7 @@ def expand(it, i=0):
             c = expand(compare[took:])
             self.assertEqual(a, c);
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -189,7 +190,11 @@ def test_batched(self):
                              [('A', 'B'), ('C', 'D'), ('E', 'F'), ('G',)])
         self.assertEqual(list(batched('ABCDEFG', 1)),
                             [('A',), ('B',), ('C',), ('D',), ('E',), ('F',), ('G',)])
+        self.assertEqual(list(batched('ABCDEF', 2, strict=True)),
+                             [('A', 'B'), ('C', 'D'), ('E', 'F')])
 
+        with self.assertRaises(ValueError):         # Incomplete batch when strict
+            list(batched('ABCDEFG', 3, strict=True))
         with self.assertRaises(TypeError):          # Too few arguments
             list(batched('ABCDEFG'))
         with self.assertRaises(TypeError):
@@ -243,8 +248,6 @@ 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])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_chain_reducible(self):
         for oper in [copy.deepcopy] + picklecopiers:
@@ -259,8 +262,7 @@ def test_chain_reducible(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             self.pickletest(proto, chain('abc', 'def'), compare=list('abcdef'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_chain_setstate(self):
         self.assertRaises(TypeError, chain().__setstate__, ())
@@ -275,8 +277,7 @@ def test_chain_setstate(self):
         it.__setstate__((iter(['abc', 'def']), iter(['ghi'])))
         self.assertEqual(list(it), ['ghi', 'a', 'b', 'c', 'd', 'e', 'f'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_combinations(self):
         self.assertRaises(TypeError, combinations, 'abc')       # missing r argument
@@ -368,8 +369,7 @@ 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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_combinations_with_replacement(self):
         cwr = combinations_with_replacement
@@ -459,8 +459,7 @@ def test_combinations_with_replacement_tuple_reuse(self):
         self.assertEqual(len(set(map(id, cwr('abcde', 3)))), 1)
         self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_permutations(self):
         self.assertRaises(TypeError, permutations)              # too few arguments
@@ -568,8 +567,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
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_compress(self):
         self.assertEqual(list(compress(data='ABCDEF', selectors=[1,0,1,0,1,1])), list('ACEF'))
@@ -604,8 +601,6 @@ def test_compress(self):
                     next(testIntermediate)
                     self.assertEqual(list(op(testIntermediate)), list(result2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_count(self):
         self.assertEqual(lzip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
@@ -615,6 +610,8 @@ def test_count(self):
         self.assertEqual(take(2, zip('abc',count(-3))), [('a', -3), ('b', -2)])
         self.assertRaises(TypeError, count, 2, 3, 4)
         self.assertRaises(TypeError, count, 'a')
+        self.assertEqual(take(3, count(maxsize)),
+                        [maxsize, maxsize + 1, maxsize + 2])
         self.assertEqual(take(10, count(maxsize-5)),
                          list(range(maxsize-5, maxsize+5)))
         self.assertEqual(take(10, count(-maxsize-5)),
@@ -637,6 +634,15 @@ def test_count(self):
         self.assertEqual(next(c), -8)
         self.assertEqual(repr(count(10.25)), 'count(10.25)')
         self.assertEqual(repr(count(10.0)), 'count(10.0)')
+
+        self.assertEqual(repr(count(maxsize)), f'count({maxsize})')
+        c = count(maxsize - 1)
+        self.assertEqual(repr(c), f'count({maxsize - 1})')
+        next(c)  # c is now at masize
+        self.assertEqual(repr(c), f'count({maxsize})')
+        next(c)
+        self.assertEqual(repr(c), f'count({maxsize + 1})')
+
         self.assertEqual(type(next(count(10.0))), float)
         for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
             # Test repr
@@ -655,10 +661,9 @@ def test_count(self):
         #check proper internal error handling for large "step' sizes
         count(1, maxsize+5); sys.exc_info()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 'count(10.5)' != 'count(10.5, 1.0)'
     @pickle_deprecated
-    def test_count_with_stride(self):
+    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)),
                          [('a', 2), ('b', 5), ('c', 8)])
@@ -672,6 +677,12 @@ def test_count_with_stride(self):
         self.assertEqual(take(20, count(-maxsize-15, 3)), take(20, range(-maxsize-15,-maxsize+100, 3)))
         self.assertEqual(take(3, count(10, maxsize+5)),
                          list(range(10, 10+3*(maxsize+5), maxsize+5)))
+        self.assertEqual(take(3, count(maxsize, 2)),
+                         [maxsize, maxsize + 2, maxsize + 4])
+        self.assertEqual(take(3, count(maxsize, maxsize)),
+                         [maxsize, 2 * maxsize, 3 * maxsize])
+        self.assertEqual(take(3, count(-maxsize, maxsize)),
+                        [-maxsize, 0, maxsize])
         self.assertEqual(take(3, count(2, 1.25)), [2, 3.25, 4.5])
         self.assertEqual(take(3, count(2, 3.25-4j)), [2, 5.25-4j, 8.5-8j])
         self.assertEqual(take(3, count(Decimal('1.1'), Decimal('.1'))),
@@ -713,6 +724,42 @@ def test_count_with_stride(self):
                 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)')
+        next(c)  # c is now at masize
+        self.assertEqual(repr(c), f'count({maxsize}, 2)')
+        next(c)
+        self.assertEqual(repr(c), f'count({maxsize + 2}, 2)')
+
+        c = count(maxsize + 1, -1)
+        self.assertEqual(repr(c), f'count({maxsize + 1}, -1)')
+        next(c)  # c is now at masize
+        self.assertEqual(repr(c), f'count({maxsize}, -1)')
+        next(c)
+        self.assertEqual(repr(c), f'count({maxsize - 1}, -1)')
+
+    @threading_helper.requires_working_threading()
+    def test_count_threading(self, step=1):
+        # this test verifies multithreading consistency, which is
+        # mostly for testing builds without GIL, but nice to test anyway
+        count_to = 10_000
+        num_threads = 10
+        c = count(step=step)
+        def counting_thread():
+            for i in range(count_to):
+                next(c)
+        threads = []
+        for i in range(num_threads):
+            thread = threading.Thread(target=counting_thread)
+            thread.start()
+            threads.append(thread)
+        for thread in threads:
+            thread.join()
+        self.assertEqual(next(c), count_to * num_threads * step)
+
+    def test_count_with_step_threading(self):
+        self.test_count_threading(step=5)
+
     def test_cycle(self):
         self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
         self.assertEqual(list(cycle('')), [])
@@ -720,8 +767,7 @@ 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])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_cycle_copy_pickle(self):
         # check copy, deepcopy, pickle
@@ -759,8 +805,7 @@ def test_cycle_copy_pickle(self):
             d = pickle.loads(p)                  # rebuild the cycle object
             self.assertEqual(take(20, d), list('cdeabcdeabcdeabcdeab'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_cycle_unpickle_compat(self):
         testcases = [
@@ -793,8 +838,7 @@ def test_cycle_unpickle_compat(self):
             it = pickle.loads(t)
             self.assertEqual(take(10, it), [2, 3, 1, 2, 3, 1, 2, 3, 1, 2])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_cycle_setstate(self):
         # Verify both modes for restoring state
@@ -832,8 +876,7 @@ def test_cycle_setstate(self):
         self.assertRaises(TypeError, cycle('').__setstate__, ())
         self.assertRaises(TypeError, cycle('').__setstate__, ([],))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_groupby(self):
         # Check whether it accepts arguments correctly
@@ -992,8 +1035,6 @@ def test_filter(self):
             c = filter(isEven, range(6))
             self.pickletest(proto, c)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_filterfalse(self):
         self.assertEqual(list(filterfalse(isEven, range(6))), [1,3,5])
@@ -1101,8 +1142,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))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_zip_longest_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -1292,12 +1331,16 @@ def product1(*args, **kwds):
                 else:
                     return
 
-        def product2(*args, **kwds):
+        def product2(*iterables, repeat=1):
             'Pure python version used in docs'
-            pools = list(map(tuple, args)) * kwds.get('repeat', 1)
+            if repeat < 0:
+                raise ValueError('repeat argument cannot be negative')
+            pools = [tuple(pool) for pool in iterables] * repeat
+
             result = [[]]
             for pool in pools:
                 result = [x+[y] for x in result for y in pool]
+
             for prod in result:
                 yield tuple(prod)
 
@@ -1322,8 +1365,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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_product_pickling(self):
         # check copy, deepcopy, pickle
@@ -1340,8 +1381,7 @@ def test_product_pickling(self):
             for proto in range(pickle.HIGHEST_PROTOCOL + 1):
                 self.pickletest(proto, product(*args))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_product_issue_25021(self):
         # test that indices are properly clamped to the length of the tuples
@@ -1353,8 +1393,6 @@ def test_product_issue_25021(self):
         p.__setstate__((0, 0, 0x1000))  # will access tuple element 1 if not clamped
         self.assertRaises(StopIteration, next, p)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_repeat(self):
         self.assertEqual(list(repeat(object='a', times=3)), ['a', 'a', 'a'])
@@ -1388,8 +1426,7 @@ def test_repeat_with_negative_times(self):
         self.assertEqual(repr(repeat('a', times=-1)), "repeat('a', 0)")
         self.assertEqual(repr(repeat('a', times=-2)), "repeat('a', 0)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_map(self):
         self.assertEqual(list(map(operator.pow, range(3), range(1,7))),
@@ -1421,8 +1458,6 @@ def test_map(self):
             c = map(tupleize, 'abc', count())
             self.pickletest(proto, c)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_starmap(self):
         self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
@@ -1451,8 +1486,7 @@ def test_starmap(self):
             c = starmap(operator.pow, zip(range(3), range(1,7)))
             self.pickletest(proto, c)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_islice(self):
         for args in [          # islice(args) should agree with range(args)
@@ -1548,8 +1582,6 @@ def __index__(self):
         self.assertEqual(list(islice(range(100), IntLike(10), IntLike(50), IntLike(5))),
                          list(range(10,50,5)))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_takewhile(self):
         data = [1, 3, 5, 20, 2, 4, 6, 8]
@@ -1571,8 +1603,7 @@ def test_takewhile(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             self.pickletest(proto, takewhile(underten, data))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_dropwhile(self):
         data = [1, 3, 5, 20, 2, 4, 6, 8]
@@ -1591,8 +1622,7 @@ def test_dropwhile(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             self.pickletest(proto, dropwhile(underten, data))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_tee(self):
         n = 200
@@ -1660,10 +1690,11 @@ def test_tee(self):
             self.assertEqual(len(result), n)
             self.assertEqual([list(x) for x in result], [list('abc')]*n)
 
-        # tee pass-through to copyable iterator
+        # tee objects are independent (see bug gh-123884)
         a, b = tee('abc')
         c, d = tee(a)
-        self.assertTrue(a is c)
+        e, f = tee(c)
+        self.assertTrue(len({a, b, c, d, e, f}) == 6)
 
         # test tee_new
         t1, t2 = tee('abc')
@@ -1761,8 +1792,6 @@ def test_tee_del_backward(self):
             del forward, backward
             raise
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_tee_reenter(self):
         class I:
             first = True
@@ -1778,7 +1807,6 @@ def __next__(self):
         with self.assertRaisesRegex(RuntimeError, "tee"):
             next(a)
 
-    @unittest.skip("TODO: RUSTPYTHON, hangs")
     @threading_helper.requires_working_threading()
     def test_tee_concurrent(self):
         start = threading.Event()
@@ -1868,6 +1896,13 @@ def test_zip_longest_result_gc(self):
         gc.collect()
         self.assertTrue(gc.is_tracked(next(it)))
 
+    @support.cpython_only
+    def test_pairwise_result_gc(self):
+        # Ditto for pairwise.
+        it = pairwise([None, None])
+        gc.collect()
+        self.assertTrue(gc.is_tracked(next(it)))
+
     @support.cpython_only
     def test_immutable_types(self):
         from itertools import _grouper, _tee, _tee_dataobject
@@ -1906,8 +1941,6 @@ class TestExamples(unittest.TestCase):
     def test_accumulate(self):
         self.assertEqual(list(accumulate([1,2,3,4,5])), [1, 3, 6, 10, 15])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @pickle_deprecated
     def test_accumulate_reducible(self):
         # check copy, deepcopy, pickle
@@ -1924,8 +1957,7 @@ def test_accumulate_reducible(self):
         self.assertEqual(list(copy.deepcopy(it)), accumulated[1:])
         self.assertEqual(list(copy.copy(it)), accumulated[1:])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @pickle_deprecated
     def test_accumulate_reducible_none(self):
         # Issue #25718: total is None
@@ -2084,6 +2116,172 @@ def test_islice_recipe(self):
         self.assertEqual(next(c), 3)
 
 
+    def test_tee_recipe(self):
+
+        # Begin tee() recipe ###########################################
+
+        def tee(iterable, n=2):
+            if n < 0:
+                raise ValueError
+            if n == 0:
+                return ()
+            iterator = _tee(iterable)
+            result = [iterator]
+            for _ in range(n - 1):
+                result.append(_tee(iterator))
+            return tuple(result)
+
+        class _tee:
+
+            def __init__(self, iterable):
+                it = iter(iterable)
+                if isinstance(it, _tee):
+                    self.iterator = it.iterator
+                    self.link = it.link
+                else:
+                    self.iterator = it
+                    self.link = [None, None]
+
+            def __iter__(self):
+                return self
+
+            def __next__(self):
+                link = self.link
+                if link[1] is None:
+                    link[0] = next(self.iterator)
+                    link[1] = [None, None]
+                value, self.link = link
+                return value
+
+        # End tee() recipe #############################################
+
+        n = 200
+
+        a, b = tee([])        # test empty iterator
+        self.assertEqual(list(a), [])
+        self.assertEqual(list(b), [])
+
+        a, b = tee(irange(n)) # test 100% interleaved
+        self.assertEqual(lzip(a,b), lzip(range(n), range(n)))
+
+        a, b = tee(irange(n)) # test 0% interleaved
+        self.assertEqual(list(a), list(range(n)))
+        self.assertEqual(list(b), list(range(n)))
+
+        a, b = tee(irange(n)) # test dealloc of leading iterator
+        for i in range(100):
+            self.assertEqual(next(a), i)
+        del a
+        self.assertEqual(list(b), list(range(n)))
+
+        a, b = tee(irange(n)) # test dealloc of trailing iterator
+        for i in range(100):
+            self.assertEqual(next(a), i)
+        del b
+        self.assertEqual(list(a), list(range(100, n)))
+
+        for j in range(5):   # test randomly interleaved
+            order = [0]*n + [1]*n
+            random.shuffle(order)
+            lists = ([], [])
+            its = tee(irange(n))
+            for i in order:
+                value = next(its[i])
+                lists[i].append(value)
+            self.assertEqual(lists[0], list(range(n)))
+            self.assertEqual(lists[1], list(range(n)))
+
+        # test argument format checking
+        self.assertRaises(TypeError, tee)
+        self.assertRaises(TypeError, tee, 3)
+        self.assertRaises(TypeError, tee, [1,2], 'x')
+        self.assertRaises(TypeError, tee, [1,2], 3, 'x')
+
+        # tee object should be instantiable
+        a, b = tee('abc')
+        c = type(a)('def')
+        self.assertEqual(list(c), list('def'))
+
+        # test long-lagged and multi-way split
+        a, b, c = tee(range(2000), 3)
+        for i in range(100):
+            self.assertEqual(next(a), i)
+        self.assertEqual(list(b), list(range(2000)))
+        self.assertEqual([next(c), next(c)], list(range(2)))
+        self.assertEqual(list(a), list(range(100,2000)))
+        self.assertEqual(list(c), list(range(2,2000)))
+
+        # test invalid values of n
+        self.assertRaises(TypeError, tee, 'abc', 'invalid')
+        self.assertRaises(ValueError, tee, [], -1)
+
+        for n in range(5):
+            result = tee('abc', n)
+            self.assertEqual(type(result), tuple)
+            self.assertEqual(len(result), n)
+            self.assertEqual([list(x) for x in result], [list('abc')]*n)
+
+        # tee objects are independent (see bug gh-123884)
+        a, b = tee('abc')
+        c, d = tee(a)
+        e, f = tee(c)
+        self.assertTrue(len({a, b, c, d, e, f}) == 6)
+
+        # test tee_new
+        t1, t2 = tee('abc')
+        tnew = type(t1)
+        self.assertRaises(TypeError, tnew)
+        self.assertRaises(TypeError, tnew, 10)
+        t3 = tnew(t1)
+        self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc'))
+
+        # test that tee objects are weak referencable
+        a, b = tee(range(10))
+        p = weakref.proxy(a)
+        self.assertEqual(getattr(p, '__class__'), type(b))
+        del a
+        gc.collect()  # For PyPy or other GCs.
+        self.assertRaises(ReferenceError, getattr, p, '__class__')
+
+        ans = list('abc')
+        long_ans = list(range(10000))
+
+        # Tests not applicable to the tee() recipe
+        if False:
+            # check copy
+            a, b = tee('abc')
+            self.assertEqual(list(copy.copy(a)), ans)
+            self.assertEqual(list(copy.copy(b)), ans)
+            a, b = tee(list(range(10000)))
+            self.assertEqual(list(copy.copy(a)), long_ans)
+            self.assertEqual(list(copy.copy(b)), long_ans)
+
+            # check partially consumed copy
+            a, b = tee('abc')
+            take(2, a)
+            take(1, b)
+            self.assertEqual(list(copy.copy(a)), ans[2:])
+            self.assertEqual(list(copy.copy(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.copy(a)), long_ans[100:])
+            self.assertEqual(list(copy.copy(b)), long_ans[60:])
+            self.assertEqual(list(a), long_ans[100:])
+            self.assertEqual(list(b), long_ans[60:])
+
+        # Issue 13454: Crash when deleting backward iterator from tee()
+        forward, backward = tee(repeat(None, 2000)) # 20000000
+        try:
+            any(forward)  # exhaust the iterator
+            del backward
+        except:
+            del forward, backward
+            raise
+
+
 class TestGC(unittest.TestCase):
 
     def makecycle(self, iterator, container):
@@ -2570,8 +2768,7 @@ def __eq__(self, other):
 
 
 class SubclassWithKwargsTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keywords_in_subclass(self):
         # count is not subclassable...
         testcases = [
@@ -2666,7 +2863,7 @@ def test_permutations_sizeof(self):
 
 
 def load_tests(loader, tests, pattern):
-    tests.addTest(doctest.DocTestSuite())
+    tests.addTest(doctest.DocTestSuite(itertools))
     return tests
 
 
diff --git a/Lib/test/test_json/test_decode.py b/Lib/test/test_json/test_decode.py
index e48e36c54b..ad37d47f08 100644
--- a/Lib/test/test_json/test_decode.py
+++ b/Lib/test/test_json/test_decode.py
@@ -2,21 +2,50 @@
 from io import StringIO
 from collections import OrderedDict
 from test.test_json import PyTest, CTest
+from test import support
 
-import unittest
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
 
 
 class TestDecode:
     def test_decimal(self):
         rval = self.loads('1.1', parse_float=decimal.Decimal)
-        self.assertTrue(isinstance(rval, decimal.Decimal))
+        self.assertIsInstance(rval, decimal.Decimal)
         self.assertEqual(rval, decimal.Decimal('1.1'))
 
     def test_float(self):
         rval = self.loads('1', parse_int=float)
-        self.assertTrue(isinstance(rval, float))
+        self.assertIsInstance(rval, float)
         self.assertEqual(rval, 1.0)
 
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; called `Result::unwrap()` on an `Err` value: ParseFloatError { kind: Invalid }")
+    def test_nonascii_digits_rejected(self):
+        # JSON specifies only ascii digits, see gh-125687
+        for num in ["1\uff10", "0.\uff10", "0e\uff10"]:
+            with self.assertRaises(self.JSONDecodeError):
+                self.loads(num)
+
+    def test_bytes(self):
+        self.assertEqual(self.loads(b"1"), 1)
+
+    def test_parse_constant(self):
+        for constant, expected in [
+            ("Infinity", "INFINITY"),
+            ("-Infinity", "-INFINITY"),
+            ("NaN", "NAN"),
+        ]:
+            self.assertEqual(
+                self.loads(constant, parse_constant=str.upper), expected
+            )
+
+    def test_constant_invalid_case(self):
+        for constant in [
+            "nan", "NAN", "naN", "infinity", "INFINITY", "inFiniTy"
+        ]:
+            with self.assertRaises(self.JSONDecodeError):
+                self.loads(constant)
+
     def test_empty_objects(self):
         self.assertEqual(self.loads('{}'), {})
         self.assertEqual(self.loads('[]'), [])
@@ -89,7 +118,8 @@ def test_string_with_utf8_bom(self):
             self.json.load(StringIO(bom_json))
         self.assertIn('BOM', str(cm.exception))
         # make sure that the BOM is not detected in the middle of a string
-        bom_in_str = '"{}"'.format(''.encode('utf-8-sig').decode('utf-8'))
+        bom = ''.encode('utf-8-sig').decode('utf-8')
+        bom_in_str = f'"{bom}"'
         self.assertEqual(self.loads(bom_in_str), '\ufeff')
         self.assertEqual(self.json.load(StringIO(bom_in_str)), '\ufeff')
 
@@ -97,10 +127,21 @@ def test_negative_index(self):
         d = self.json.JSONDecoder()
         self.assertRaises(ValueError, d.raw_decode, 'a'*42, -50000)
 
+    def test_limit_int(self):
+        maxdigits = 5000
+        with support.adjust_int_max_str_digits(maxdigits):
+            self.loads('1' * maxdigits)
+            with self.assertRaises(ValueError):
+                self.loads('1' * (maxdigits + 1))
+
+
 class TestPyDecode(TestDecode, PyTest): pass
-# TODO: RUSTPYTHON
-class TestCDecode(TestDecode, CTest): # pass
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+class TestCDecode(TestDecode, CTest):
     def test_keys_reuse(self):
         return super().test_keys_reuse()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    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 9b8325e9c3..3ce16684a0 100644
--- a/Lib/test/test_json/test_default.py
+++ b/Lib/test/test_json/test_default.py
@@ -1,3 +1,4 @@
+import collections
 from test.test_json import PyTest, CTest
 
 
@@ -7,6 +8,16 @@ def test_default(self):
             self.dumps(type, default=repr),
             self.dumps(repr(type)))
 
+    def test_ordereddict(self):
+        od = collections.OrderedDict(a=1, b=2, c=3, d=4)
+        od.move_to_end('b')
+        self.assertEqual(
+            self.dumps(od),
+            '{"a": 1, "c": 3, "d": 4, "b": 2}')
+        self.assertEqual(
+            self.dumps(od, sort_keys=True),
+            '{"a": 1, "b": 2, "c": 3, "d": 4}')
+
 
 class TestPyDefault(TestDefault, PyTest): pass
 class TestCDefault(TestDefault, CTest): pass
diff --git a/Lib/test/test_json/test_dump.py b/Lib/test/test_json/test_dump.py
index 13b4002078..3947075400 100644
--- a/Lib/test/test_json/test_dump.py
+++ b/Lib/test/test_json/test_dump.py
@@ -22,6 +22,14 @@ def test_dump_skipkeys(self):
         self.assertIn('valid_key', o)
         self.assertNotIn(b'invalid_key', o)
 
+    def test_dump_skipkeys_indent_empty(self):
+        v = {b'invalid_key': False}
+        self.assertEqual(self.json.dumps(v, skipkeys=True, indent=4), '{}')
+
+    def test_skipkeys_indent(self):
+        v = {b'invalid_key': False, 'valid_key': True}
+        self.assertEqual(self.json.dumps(v, skipkeys=True, indent=4), '{\n    "valid_key": true\n}')
+
     def test_encode_truefalse(self):
         self.assertEqual(self.dumps(
                  {True: False, False: True}, sort_keys=True),
diff --git a/Lib/test/test_json/test_encode_basestring_ascii.py b/Lib/test/test_json/test_encode_basestring_ascii.py
index 4bbc6c7148..c90d3e968e 100644
--- a/Lib/test/test_json/test_encode_basestring_ascii.py
+++ b/Lib/test/test_json/test_encode_basestring_ascii.py
@@ -8,13 +8,12 @@
     ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
     ('controls', '"controls"'),
     ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
+    ('\x00\x1f\x7f', '"\\u0000\\u001f\\u007f"'),
     ('{"object with 1 member":["array with 1 element"]}', '"{\\"object with 1 member\\":[\\"array with 1 element\\"]}"'),
     (' s p a c e d ', '" s p a c e d "'),
     ('\U0001d120', '"\\ud834\\udd20"'),
     ('\u03b1\u03a9', '"\\u03b1\\u03a9"'),
     ("`1~!@#$%^&*()_+-={':[,]}|;.</>?", '"`1~!@#$%^&*()_+-={\':[,]}|;.</>?"'),
-    ('\x08\x0c\n\r\t', '"\\b\\f\\n\\r\\t"'),
-    ('\u0123\u4567\u89ab\ucdef\uabcd\uef4a', '"\\u0123\\u4567\\u89ab\\ucdef\\uabcd\\uef4a"'),
 ]
 
 class TestEncodeBasestringAscii:
@@ -23,8 +22,7 @@ def test_encode_basestring_ascii(self):
         for input_string, expect in CASES:
             result = self.json.encoder.encode_basestring_ascii(input_string)
             self.assertEqual(result, expect,
-                '{0!r} != {1!r} for {2}({3!r})'.format(
-                    result, expect, fname, input_string))
+                f'{result!r} != {expect!r} for {fname}({input_string!r})')
 
     def test_ordered_dict(self):
         # See issue 6105
diff --git a/Lib/test/test_json/test_fail.py b/Lib/test/test_json/test_fail.py
index dcadc1c51c..7a85665c81 100644
--- a/Lib/test/test_json/test_fail.py
+++ b/Lib/test/test_json/test_fail.py
@@ -1,75 +1,76 @@
-import unittest
 from test.test_json import PyTest, CTest
 
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+
 # 2007-10-05
 JSONDOCS = [
-    # http://json.org/JSON_checker/test/fail1.json
+    # https://json.org/JSON_checker/test/fail1.json
     '"A JSON payload should be an object or array, not a string."',
-    # http://json.org/JSON_checker/test/fail2.json
+    # https://json.org/JSON_checker/test/fail2.json
     '["Unclosed array"',
-    # http://json.org/JSON_checker/test/fail3.json
+    # https://json.org/JSON_checker/test/fail3.json
     '{unquoted_key: "keys must be quoted"}',
-    # http://json.org/JSON_checker/test/fail4.json
+    # https://json.org/JSON_checker/test/fail4.json
     '["extra comma",]',
-    # http://json.org/JSON_checker/test/fail5.json
+    # https://json.org/JSON_checker/test/fail5.json
     '["double extra comma",,]',
-    # http://json.org/JSON_checker/test/fail6.json
+    # https://json.org/JSON_checker/test/fail6.json
     '[   , "<-- missing value"]',
-    # http://json.org/JSON_checker/test/fail7.json
+    # https://json.org/JSON_checker/test/fail7.json
     '["Comma after the close"],',
-    # http://json.org/JSON_checker/test/fail8.json
+    # https://json.org/JSON_checker/test/fail8.json
     '["Extra close"]]',
-    # http://json.org/JSON_checker/test/fail9.json
+    # https://json.org/JSON_checker/test/fail9.json
     '{"Extra comma": true,}',
-    # http://json.org/JSON_checker/test/fail10.json
+    # https://json.org/JSON_checker/test/fail10.json
     '{"Extra value after close": true} "misplaced quoted value"',
-    # http://json.org/JSON_checker/test/fail11.json
+    # https://json.org/JSON_checker/test/fail11.json
     '{"Illegal expression": 1 + 2}',
-    # http://json.org/JSON_checker/test/fail12.json
+    # https://json.org/JSON_checker/test/fail12.json
     '{"Illegal invocation": alert()}',
-    # http://json.org/JSON_checker/test/fail13.json
+    # https://json.org/JSON_checker/test/fail13.json
     '{"Numbers cannot have leading zeroes": 013}',
-    # http://json.org/JSON_checker/test/fail14.json
+    # https://json.org/JSON_checker/test/fail14.json
     '{"Numbers cannot be hex": 0x14}',
-    # http://json.org/JSON_checker/test/fail15.json
+    # https://json.org/JSON_checker/test/fail15.json
     '["Illegal backslash escape: \\x15"]',
-    # http://json.org/JSON_checker/test/fail16.json
+    # https://json.org/JSON_checker/test/fail16.json
     '[\\naked]',
-    # http://json.org/JSON_checker/test/fail17.json
+    # https://json.org/JSON_checker/test/fail17.json
     '["Illegal backslash escape: \\017"]',
-    # http://json.org/JSON_checker/test/fail18.json
+    # https://json.org/JSON_checker/test/fail18.json
     '[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]',
-    # http://json.org/JSON_checker/test/fail19.json
+    # https://json.org/JSON_checker/test/fail19.json
     '{"Missing colon" null}',
-    # http://json.org/JSON_checker/test/fail20.json
+    # https://json.org/JSON_checker/test/fail20.json
     '{"Double colon":: null}',
-    # http://json.org/JSON_checker/test/fail21.json
+    # https://json.org/JSON_checker/test/fail21.json
     '{"Comma instead of colon", null}',
-    # http://json.org/JSON_checker/test/fail22.json
+    # https://json.org/JSON_checker/test/fail22.json
     '["Colon instead of comma": false]',
-    # http://json.org/JSON_checker/test/fail23.json
+    # https://json.org/JSON_checker/test/fail23.json
     '["Bad value", truth]',
-    # http://json.org/JSON_checker/test/fail24.json
+    # https://json.org/JSON_checker/test/fail24.json
     "['single quote']",
-    # http://json.org/JSON_checker/test/fail25.json
+    # https://json.org/JSON_checker/test/fail25.json
     '["\ttab\tcharacter\tin\tstring\t"]',
-    # http://json.org/JSON_checker/test/fail26.json
+    # https://json.org/JSON_checker/test/fail26.json
     '["tab\\   character\\   in\\  string\\  "]',
-    # http://json.org/JSON_checker/test/fail27.json
+    # https://json.org/JSON_checker/test/fail27.json
     '["line\nbreak"]',
-    # http://json.org/JSON_checker/test/fail28.json
+    # https://json.org/JSON_checker/test/fail28.json
     '["line\\\nbreak"]',
-    # http://json.org/JSON_checker/test/fail29.json
+    # https://json.org/JSON_checker/test/fail29.json
     '[0e]',
-    # http://json.org/JSON_checker/test/fail30.json
+    # https://json.org/JSON_checker/test/fail30.json
     '[0e+]',
-    # http://json.org/JSON_checker/test/fail31.json
+    # https://json.org/JSON_checker/test/fail31.json
     '[0e+-1]',
-    # http://json.org/JSON_checker/test/fail32.json
+    # https://json.org/JSON_checker/test/fail32.json
     '{"Comma instead if closing brace": true,',
-    # http://json.org/JSON_checker/test/fail33.json
+    # https://json.org/JSON_checker/test/fail33.json
     '["mismatch"}',
-    # http://code.google.com/p/simplejson/issues/detail?id=3
+    # https://code.google.com/archive/p/simplejson/issues/3
     '["A\u001FZ control characters in string"]',
 ]
 
@@ -90,7 +91,7 @@ def test_failures(self):
             except self.JSONDecodeError:
                 pass
             else:
-                self.fail("Expected failure for fail{0}.json: {1!r}".format(idx, doc))
+                self.fail(f"Expected failure for fail{idx}.json: {doc!r}")
 
     def test_non_string_keys_dict(self):
         data = {'a' : 1, (1, 2) : 2}
@@ -144,11 +145,11 @@ def test_unexpected_data(self):
             ('{"spam":[}', 'Expecting value', 9),
             ('[42:', "Expecting ',' delimiter", 3),
             ('[42 "spam"', "Expecting ',' delimiter", 4),
-            ('[42,]', 'Expecting value', 4),
+            ('[42,]', "Illegal trailing comma before end of array", 3),
             ('{"spam":[42}', "Expecting ',' delimiter", 11),
             ('["]', 'Unterminated string starting at', 1),
             ('["spam":', "Expecting ',' delimiter", 7),
-            ('["spam",]', 'Expecting value', 8),
+            ('["spam",]', "Illegal trailing comma before end of array", 7),
             ('{:', 'Expecting property name enclosed in double quotes', 1),
             ('{,', 'Expecting property name enclosed in double quotes', 1),
             ('{42', 'Expecting property name enclosed in double quotes', 1),
@@ -160,7 +161,9 @@ def test_unexpected_data(self):
             ('[{"spam":]', 'Expecting value', 9),
             ('{"spam":42 "ham"', "Expecting ',' delimiter", 11),
             ('[{"spam":42]', "Expecting ',' delimiter", 11),
-            ('{"spam":42,}', 'Expecting property name enclosed in double quotes', 11),
+            ('{"spam":42,}', "Illegal trailing comma before end of object", 10),
+            ('{"spam":42 , }', "Illegal trailing comma before end of object", 11),
+            ('[123  , ]', "Illegal trailing comma before end of array", 6),
         ]
         for data, msg, idx in test_cases:
             with self.assertRaises(self.JSONDecodeError) as cm:
@@ -217,10 +220,9 @@ def test_linecol(self):
                              (line, col, idx))
 
 class TestPyFail(TestFail, PyTest): pass
-class TestCFail(TestFail, CTest): pass
-# TODO: RUSTPYTHON
+
 class TestCFail(TestFail, CTest):
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_failures(self):
-        super().test_failures()
+        return super().test_failures()
diff --git a/Lib/test/test_json/test_float.py b/Lib/test/test_json/test_float.py
index d0c7214334..61540a3a02 100644
--- a/Lib/test/test_json/test_float.py
+++ b/Lib/test/test_json/test_float.py
@@ -26,7 +26,8 @@ def test_allow_nan(self):
                 res = self.loads(out)
                 self.assertEqual(len(res), 1)
                 self.assertNotEqual(res[0], res[0])
-            self.assertRaises(ValueError, self.dumps, [val], allow_nan=False)
+            msg = f'Out of range float values are not JSON compliant: {val}'
+            self.assertRaisesRegex(ValueError, msg, self.dumps, [val], allow_nan=False)
 
 
 class TestPyFloat(TestFloat, PyTest): pass
diff --git a/Lib/test/test_json/test_pass1.py b/Lib/test/test_json/test_pass1.py
index 15e64b0aea..26bf3cdbd7 100644
--- a/Lib/test/test_json/test_pass1.py
+++ b/Lib/test/test_json/test_pass1.py
@@ -1,7 +1,7 @@
 from test.test_json import PyTest, CTest
 
 
-# from http://json.org/JSON_checker/test/pass1.json
+# from https://json.org/JSON_checker/test/pass1.json
 JSON = r'''
 [
     "JSON Test Pattern pass1",
diff --git a/Lib/test/test_json/test_pass2.py b/Lib/test/test_json/test_pass2.py
index 35075249e3..9340de665a 100644
--- a/Lib/test/test_json/test_pass2.py
+++ b/Lib/test/test_json/test_pass2.py
@@ -1,7 +1,7 @@
 from test.test_json import PyTest, CTest
 
 
-# from http://json.org/JSON_checker/test/pass2.json
+# from https://json.org/JSON_checker/test/pass2.json
 JSON = r'''
 [[[[[[[[[[[[[[[[[[["Not too deep"]]]]]]]]]]]]]]]]]]]
 '''
diff --git a/Lib/test/test_json/test_pass3.py b/Lib/test/test_json/test_pass3.py
index cd0cf170d2..0adccc1c2a 100644
--- a/Lib/test/test_json/test_pass3.py
+++ b/Lib/test/test_json/test_pass3.py
@@ -1,7 +1,7 @@
 from test.test_json import PyTest, CTest
 
 
-# from http://json.org/JSON_checker/test/pass3.json
+# from https://json.org/JSON_checker/test/pass3.json
 JSON = r'''
 {
     "JSON Test Pattern pass3": {
diff --git a/Lib/test/test_json/test_recursion.py b/Lib/test/test_json/test_recursion.py
index 9919d7fbe5..59f6f2c4b1 100644
--- a/Lib/test/test_json/test_recursion.py
+++ b/Lib/test/test_json/test_recursion.py
@@ -1,6 +1,8 @@
 from test import support
 from test.test_json import PyTest, CTest
 
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+
 
 class JSONTestObject:
     pass
@@ -65,7 +67,8 @@ def default(self, o):
         else:
             self.fail("didn't raise ValueError on default recursion")
 
-
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; crashes")
     def test_highly_nested_objects_decoding(self):
         # test that loading highly-nested objects doesn't segfault when C
         # accelerations are used. See #12017
@@ -79,16 +82,17 @@ def test_highly_nested_objects_decoding(self):
             with support.infinite_recursion():
                 self.loads('[' * 100000 + '1' + ']' * 100000)
 
+    @support.requires_resource('cpu')
     def test_highly_nested_objects_encoding(self):
         # See #12051
         l, d = [], {}
         for x in range(100000):
             l, d = [l], {'k':d}
         with self.assertRaises(RecursionError):
-            with support.infinite_recursion():
+            with support.infinite_recursion(5000):
                 self.dumps(l)
         with self.assertRaises(RecursionError):
-            with support.infinite_recursion():
+            with support.infinite_recursion(5000):
                 self.dumps(d)
 
     def test_endless_recursion(self):
@@ -99,7 +103,7 @@ def default(self, o):
                 return [o]
 
         with self.assertRaises(RecursionError):
-            with support.infinite_recursion():
+            with support.infinite_recursion(1000):
                 EndlessJSONEncoder(check_circular=False).encode(5j)
 
 
diff --git a/Lib/test/test_json/test_scanstring.py b/Lib/test/test_json/test_scanstring.py
index af4bb3a639..d6922c3b1b 100644
--- a/Lib/test/test_json/test_scanstring.py
+++ b/Lib/test/test_json/test_scanstring.py
@@ -1,7 +1,8 @@
-import unittest
 import sys
 from test.test_json import PyTest, CTest
 
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+
 
 class TestScanstring:
     def test_scanstring(self):
@@ -117,6 +118,11 @@ def test_bad_escapes(self):
             '"\\u012z"',
             '"\\u0x12"',
             '"\\u0X12"',
+            '"\\u{0}"'.format("\uff10" * 4),
+            '"\\u 123"',
+            '"\\u-123"',
+            '"\\u+123"',
+            '"\\u1_23"',
             '"\\ud834\\"',
             '"\\ud834\\u"',
             '"\\ud834\\ud"',
@@ -128,6 +134,11 @@ def test_bad_escapes(self):
             '"\\ud834\\udd2z"',
             '"\\ud834\\u0x20"',
             '"\\ud834\\u0X20"',
+            '"\\ud834\\u{0}"'.format("\uff10" * 4),
+            '"\\ud834\\u 123"',
+            '"\\ud834\\u-123"',
+            '"\\ud834\\u+123"',
+            '"\\ud834\\u1_23"',
         ]
         for s in bad_escapes:
             with self.assertRaises(self.JSONDecodeError, msg=s):
@@ -137,7 +148,7 @@ def test_bad_escapes(self):
     @unittest.expectedFailure
     def test_overflow(self):
         with self.assertRaises(OverflowError):
-            self.json.decoder.scanstring(b"xxx", sys.maxsize+1)
+            self.json.decoder.scanstring("xxx", sys.maxsize+1)
 
 
 class TestPyScanstring(TestScanstring, PyTest): pass
diff --git a/Lib/test/test_json/test_speedups.py b/Lib/test/test_json/test_speedups.py
index 66ce1d1b33..ada9672912 100644
--- a/Lib/test/test_json/test_speedups.py
+++ b/Lib/test/test_json/test_speedups.py
@@ -1,6 +1,7 @@
 from test.test_json import CTest
 
-import unittest
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+
 
 class BadBool:
     def __bool__(self):
@@ -39,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)
 
-    # TODO: RUSTPYTHON, TypeError: 'NoneType' object is not callable
+    # TODO: RUSTPYTHON; TypeError: 'NoneType' object is not callable
     @unittest.expectedFailure
     def test_bad_str_encoder(self):
         # Issue #31505: There shouldn't be an assertion failure in case
@@ -73,7 +74,7 @@ def test_bad_markers_argument_to_encoder(self):
             self.json.encoder.c_make_encoder(1, None, None, None, ': ', ', ',
                                              False, False, False)
 
-    # TODO: RUSTPYTHON, translate the encoder to Rust
+    # TODO: RUSTPYTHON; ZeroDivisionError not raised by test
     @unittest.expectedFailure
     def test_bad_bool_args(self):
         def test(name):
diff --git a/Lib/test/test_json/test_tool.py b/Lib/test/test_json/test_tool.py
index 1d7fca6efb..2b63810d53 100644
--- a/Lib/test/test_json/test_tool.py
+++ b/Lib/test/test_json/test_tool.py
@@ -10,6 +10,7 @@
 from test.support.script_helper import assert_python_ok
 
 
+@support.requires_subprocess()
 class TestTool(unittest.TestCase):
     data = """
 
diff --git a/Lib/test/test_json/test_unicode.py b/Lib/test/test_json/test_unicode.py
index e5882a1ef4..be0ac8823d 100644
--- a/Lib/test/test_json/test_unicode.py
+++ b/Lib/test/test_json/test_unicode.py
@@ -1,8 +1,9 @@
-import unittest
 import codecs
 from collections import OrderedDict
 from test.test_json import PyTest, CTest
 
+import unittest # XXX: RUSTPYTHON; importing to be able to skip tests
+
 
 class TestUnicode:
     # test_encoding1 and test_encoding2 from 2.x are irrelevant (only str
@@ -21,12 +22,40 @@ def test_encoding4(self):
     def test_encoding5(self):
         u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = self.dumps(u, ensure_ascii=False)
-        self.assertEqual(j, '"{0}"'.format(u))
+        self.assertEqual(j, f'"{u}"')
 
     def test_encoding6(self):
         u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
         j = self.dumps([u], ensure_ascii=False)
-        self.assertEqual(j, '["{0}"]'.format(u))
+        self.assertEqual(j, f'["{u}"]')
+
+    def test_encoding7(self):
+        u = '\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}'
+        j = self.dumps(u + "\n", ensure_ascii=False)
+        self.assertEqual(j, f'"{u}\\n"')
+
+    def test_ascii_non_printable_encode(self):
+        u = '\b\t\n\f\r\x00\x1f\x7f'
+        self.assertEqual(self.dumps(u),
+                         '"\\b\\t\\n\\f\\r\\u0000\\u001f\\u007f"')
+        self.assertEqual(self.dumps(u, ensure_ascii=False),
+                         '"\\b\\t\\n\\f\\r\\u0000\\u001f\x7f"')
+
+    def test_ascii_non_printable_decode(self):
+        self.assertEqual(self.loads('"\\b\\t\\n\\f\\r"'),
+                         '\b\t\n\f\r')
+        s = ''.join(map(chr, range(32)))
+        for c in s:
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"{c}"')
+        self.assertEqual(self.loads(f'"{s}"', strict=False), s)
+        self.assertEqual(self.loads('"\x7f"'), '\x7f')
+
+    def test_escaped_decode(self):
+        self.assertEqual(self.loads('"\\b\\t\\n\\f\\r"'), '\b\t\n\f\r')
+        self.assertEqual(self.loads('"\\"\\\\\\/"'), '"\\/')
+        for c in set(map(chr, range(0x100))) - set('"\\/bfnrt'):
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"\\{c}"')
+            self.assertRaises(self.JSONDecodeError, self.loads, f'"\\{c}"', strict=False)
 
     def test_big_unicode_encode(self):
         u = '\U0001d120'
@@ -35,15 +64,27 @@ def test_big_unicode_encode(self):
 
     def test_big_unicode_decode(self):
         u = 'z\U0001d120x'
-        self.assertEqual(self.loads('"' + u + '"'), u)
+        self.assertEqual(self.loads(f'"{u}"'), u)
         self.assertEqual(self.loads('"z\\ud834\\udd20x"'), u)
 
     def test_unicode_decode(self):
         for i in range(0, 0xd7ff):
             u = chr(i)
-            s = '"\\u{0:04x}"'.format(i)
+            s = f'"\\u{i:04x}"'
             self.assertEqual(self.loads(s), u)
 
+    def test_single_surrogate_encode(self):
+        self.assertEqual(self.dumps('\uD83D'), '"\\ud83d"')
+        self.assertEqual(self.dumps('\uD83D', ensure_ascii=False), '"\ud83d"')
+        self.assertEqual(self.dumps('\uDC0D'), '"\\udc0d"')
+        self.assertEqual(self.dumps('\uDC0D', ensure_ascii=False), '"\udc0d"')
+
+    def test_single_surrogate_decode(self):
+        self.assertEqual(self.loads('"\uD83D"'), '\ud83d')
+        self.assertEqual(self.loads('"\\uD83D"'), '\ud83d')
+        self.assertEqual(self.loads('"\udc0d"'), '\udc0d')
+        self.assertEqual(self.loads('"\\udc0d"'), '\udc0d')
+
     def test_unicode_preservation(self):
         self.assertEqual(type(self.loads('""')), str)
         self.assertEqual(type(self.loads('"a"')), str)
@@ -98,4 +139,19 @@ def test_object_pairs_hook_with_unicode(self):
 
 
 class TestPyUnicode(TestUnicode, PyTest): pass
-class TestCUnicode(TestUnicode, CTest): pass
+
+class TestCUnicode(TestUnicode, CTest):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_ascii_non_printable_encode(self):
+        return super().test_ascii_non_printable_encode()
+
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; panics with 'str has surrogates'")
+    def test_single_surrogate_decode(self):
+        return super().test_single_surrogate_decode()
+
+    # TODO: RUSTPYTHON
+    @unittest.skip("TODO: RUSTPYTHON; panics with 'str has surrogates'")
+    def test_single_surrogate_encode(self):
+        return super().test_single_surrogate_encode()
diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py
index 9e9c6651dd..8fd2e89122 100644
--- a/Lib/test/test_keywordonlyarg.py
+++ b/Lib/test/test_keywordonlyarg.py
@@ -58,8 +58,6 @@ def testSyntaxForManyArguments(self):
         fundef = "def f(*, %s):\n  pass\n" % ', '.join('i%d' % i for i in range(300))
         compile(fundef, "<test>", "single")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testTooManyPositionalErrorMessage(self):
         def f(a, b=None, *, c=None):
             pass
@@ -158,8 +156,7 @@ def test_issue13343(self):
         # used to fail with a SystemError.
         lambda *, k1=unittest: None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_mangling(self):
         class X:
             def f(self, *, __a=42):
@@ -174,7 +171,7 @@ def f(v=a, x=b, *, y=c, z=d):
                 pass
         self.assertEqual(str(err.exception), "name 'b' is not defined")
         with self.assertRaises(NameError) as err:
-            f = lambda v=a, x=b, *, y=c, z=d: None
+            g = lambda v=a, x=b, *, y=c, z=d: None
         self.assertEqual(str(err.exception), "name 'b' is not defined")
 
 
diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py
index 998fd9d464..e94edcbc10 100644
--- a/Lib/test/test_kqueue.py
+++ b/Lib/test/test_kqueue.py
@@ -5,6 +5,7 @@
 import os
 import select
 import socket
+from test import support
 import time
 import unittest
 
@@ -256,6 +257,23 @@ def test_fd_non_inheritable(self):
         self.addCleanup(kqueue.close)
         self.assertEqual(os.get_inheritable(kqueue.fileno()), False)
 
+    @support.requires_fork()
+    def test_fork(self):
+        # gh-110395: kqueue objects must be closed after fork
+        kqueue = select.kqueue()
+        if (pid := os.fork()) == 0:
+            try:
+                self.assertTrue(kqueue.closed)
+                with self.assertRaisesRegex(ValueError, "closed kqueue"):
+                    kqueue.fileno()
+            except:
+                os._exit(1)
+            finally:
+                os._exit(0)
+        else:
+            support.wait_process(pid, exitcode=0)
+            self.assertFalse(kqueue.closed)  # child done, we're still open.
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_list.py b/Lib/test/test_list.py
index c82bf5067d..ed061384f1 100644
--- a/Lib/test/test_list.py
+++ b/Lib/test/test_list.py
@@ -1,6 +1,8 @@
 import sys
+import textwrap
 from test import list_tests
 from test.support import cpython_only
+from test.support.script_helper import assert_python_ok
 import pickle
 import unittest
 
@@ -46,8 +48,7 @@ def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             list(sequence=[])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keywords_in_subclass(self):
         class subclass(list):
             pass
@@ -98,8 +99,12 @@ def imul(a, b): a *= b
         self.assertRaises((MemoryError, OverflowError), mul, lst, n)
         self.assertRaises((MemoryError, OverflowError), imul, lst, n)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("Crashes on windows debug build")
+    def test_empty_slice(self):
+        x = []
+        x[:] = x
+        self.assertEqual(x, [])
+
+    @unittest.skip("TODO: RUSTPYTHON; crash")
     def test_list_resize_overflow(self):
         # gh-97616: test new_allocated * sizeof(PyObject*) overflow
         # check in list_resize()
@@ -113,13 +118,27 @@ 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
+            def __repr__():
+                try:
+                    mylist.pop()
+                except IndexError:
+                    pass
+                return 'obj'
+
+        mylist = [Obj() for _ in range(5)]
+        self.assertEqual(repr(mylist), '[obj, obj, obj]')
+
     def test_repr_large(self):
         # Check the repr of large list objects
         def check(n):
             l = [0] * n
             s = repr(l)
             self.assertEqual(s,
-                             '[' + ', '.join(['0'] * n) + ']')
+                '[' + ', '.join(['0'] * n) + ']')
         check(10)       # check our checking code
         check(1000000)
 
@@ -208,7 +227,6 @@ class L(list): pass
         with self.assertRaises(TypeError):
             (3,) + L([1,2])
 
-    # TODO: RUSTPYTHON
     @unittest.skip("TODO: RUSTPYTHON; hang")
     def test_equal_operator_modifying_operand(self):
         # test fix for seg fault reported in bpo-38588 part 2.
@@ -235,7 +253,6 @@ def __eq__(self, other):
         list4 = [1]
         self.assertFalse(list3 == list4)
 
-    # TODO: RUSTPYTHON
     @unittest.skip("TODO: RUSTPYTHON; hang")
     def test_lt_operator_modifying_operand(self):
         # See gh-120298
@@ -302,6 +319,35 @@ def __eq__(self, other):
         lst = [X(), X()]
         X() in lst
 
+    def test_tier2_invalidates_iterator(self):
+        # GH-121012
+        for _ in range(100):
+            a = [1, 2, 3]
+            it = iter(a)
+            for _ in it:
+                pass
+            a.append(4)
+            self.assertEqual(list(it), [])
+
+    def test_deopt_from_append_list(self):
+        # gh-132011: it used to crash, because
+        # of `CALL_LIST_APPEND` specialization failure.
+        code = textwrap.dedent("""
+            l = []
+            def lappend(l, x, y):
+                l.append((x, y))
+            for x in range(3):
+                lappend(l, None, None)
+            try:
+                lappend(list, None, None)
+            except TypeError:
+                pass
+            else:
+                raise AssertionError
+        """)
+
+        rc, _, _ = assert_python_ok("-c", code)
+        self.assertEqual(rc, 0)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_listcomps.py b/Lib/test/test_listcomps.py
index ad1c5053a3..1380c08d28 100644
--- a/Lib/test/test_listcomps.py
+++ b/Lib/test/test_listcomps.py
@@ -177,7 +177,7 @@ def test_references___class___defined(self):
             res = [__class__ for x in [1]]
         """
         self._check_in_scopes(
-            code, outputs={"res": [2]}, scopes=["module", "function"])
+                code, outputs={"res": [2]}, scopes=["module", "function"])
         self._check_in_scopes(code, raises=NameError, scopes=["class"])
 
     def test_references___class___enclosing(self):
@@ -648,11 +648,18 @@ def test_exception_in_post_comp_call(self):
         """
         self._check_in_scopes(code, {"value": [1, None]})
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_frame_locals(self):
         code = """
-            val = [sys._getframe().f_locals for a in [0]][0]["a"]
+            val = "a" in [sys._getframe().f_locals for a in [0]][0]
         """
         import sys
+        self._check_in_scopes(code, {"val": False}, ns={"sys": sys})
+
+        code = """
+            val = [sys._getframe().f_locals["a"] for a in [0]][0]
+        """
         self._check_in_scopes(code, {"val": 0}, ns={"sys": sys})
 
     def _recursive_replace(self, maybe_code):
@@ -736,7 +743,7 @@ def iter_raises():
         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]
diff --git a/Lib/test/test_locale.py b/Lib/test/test_locale.py
index b0d7998559..71d03f3a3f 100644
--- a/Lib/test/test_locale.py
+++ b/Lib/test/test_locale.py
@@ -1,8 +1,11 @@
 from decimal import Decimal
 from test.support import verbose, is_android, is_emscripten, is_wasi
 from test.support.warnings_helper import check_warnings
+from test.support.import_helper import import_fresh_module
+from unittest import mock
 import unittest
 import locale
+import os
 import sys
 import codecs
 
@@ -342,8 +345,7 @@ def setUp(self):
         enc = codecs.lookup(locale.getencoding() or 'ascii').name
         if enc not in ('utf-8', 'iso8859-1', 'cp1252'):
             raise unittest.SkipTest('encoding not suitable')
-        if enc != 'iso8859-1' and (sys.platform == 'darwin' or is_android or
-                                   sys.platform.startswith('freebsd')):
+        if enc != 'iso8859-1' and is_android:
             raise unittest.SkipTest('wcscoll/wcsxfrm have known bugs')
         BaseLocalizedTest.setUp(self)
 
@@ -353,6 +355,8 @@ def setUp(self):
         is_emscripten or is_wasi,
         "musl libc issue on Emscripten/WASI, 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):
         self.assertLess(locale.strcoll('à', 'b'), 0)
 
@@ -362,6 +366,8 @@ def test_strcoll_with_diacritic(self):
         is_emscripten or is_wasi,
         "musl libc issue on Emscripten/WASI, 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):
         self.assertLess(locale.strxfrm('à'), locale.strxfrm('b'))
 
@@ -382,6 +388,10 @@ def test_c(self):
         self.check('c', 'C')
         self.check('posix', 'C')
 
+    def test_c_utf8(self):
+        self.check('c.utf8', 'C.UTF-8')
+        self.check('C.UTF-8', 'C.UTF-8')
+
     def test_english(self):
         self.check('en', 'en_US.ISO8859-1')
         self.check('EN', 'en_US.ISO8859-1')
@@ -477,6 +487,54 @@ def test_japanese(self):
         self.check('jp_jp', 'ja_JP.eucJP')
 
 
+class TestRealLocales(unittest.TestCase):
+    def setUp(self):
+        oldlocale = locale.setlocale(locale.LC_CTYPE)
+        self.addCleanup(locale.setlocale, locale.LC_CTYPE, oldlocale)
+
+    def test_getsetlocale_issue1813(self):
+        # Issue #1813: setting and getting the locale under a Turkish locale
+        try:
+            locale.setlocale(locale.LC_CTYPE, 'tr_TR')
+        except locale.Error:
+            # Unsupported locale on this system
+            self.skipTest('test needs Turkish locale')
+        loc = locale.getlocale(locale.LC_CTYPE)
+        if verbose:
+            print('testing with %a' % (loc,), end=' ', flush=True)
+        try:
+            locale.setlocale(locale.LC_CTYPE, loc)
+        except locale.Error as exc:
+            # bpo-37945: setlocale(LC_CTYPE) fails with getlocale(LC_CTYPE)
+            # and the tr_TR locale on Windows. getlocale() builds a locale
+            # which is not recognize by setlocale().
+            self.skipTest(f"setlocale(LC_CTYPE, {loc!r}) failed: {exc!r}")
+        self.assertEqual(loc, locale.getlocale(locale.LC_CTYPE))
+
+    @unittest.skipUnless(os.name == 'nt', 'requires Windows')
+    def test_setlocale_long_encoding(self):
+        with self.assertRaises(locale.Error):
+            locale.setlocale(locale.LC_CTYPE, 'English.%016d' % 1252)
+        locale.setlocale(locale.LC_CTYPE, 'English.%015d' % 1252)
+        loc = locale.setlocale(locale.LC_ALL)
+        self.assertIn('.1252', loc)
+        loc2 = loc.replace('.1252', '.%016d' % 1252, 1)
+        with self.assertRaises(locale.Error):
+            locale.setlocale(locale.LC_ALL, loc2)
+        loc2 = loc.replace('.1252', '.%015d' % 1252, 1)
+        locale.setlocale(locale.LC_ALL, loc2)
+
+        # gh-137273: Debug assertion failure on Windows for long encoding.
+        with self.assertRaises(locale.Error):
+            locale.setlocale(locale.LC_CTYPE, 'en_US.' + 'x'*16)
+        locale.setlocale(locale.LC_CTYPE, 'en_US.UTF-8')
+        loc = locale.setlocale(locale.LC_ALL)
+        self.assertIn('.UTF-8', loc)
+        loc2 = loc.replace('.UTF-8', '.' + 'x'*16, 1)
+        with self.assertRaises(locale.Error):
+            locale.setlocale(locale.LC_ALL, loc2)
+
+
 class TestMiscellaneous(unittest.TestCase):
     def test_defaults_UTF8(self):
         # Issue #18378: on (at least) macOS setting LC_CTYPE to "UTF-8" is
@@ -523,6 +581,15 @@ def test_getencoding(self):
         # make sure it is valid
         codecs.lookup(enc)
 
+    def test_getencoding_fallback(self):
+        # When _locale.getencoding() is missing, locale.getencoding() uses
+        # the Python filesystem
+        encoding = 'FALLBACK_ENCODING'
+        with mock.patch.object(sys, 'getfilesystemencoding',
+                               return_value=encoding):
+            locale_fallback = import_fresh_module('locale', blocked=['_locale'])
+            self.assertEqual(locale_fallback.getencoding(), encoding)
+
     def test_getpreferredencoding(self):
         # Invoke getpreferredencoding to make sure it does not cause exceptions.
         enc = locale.getpreferredencoding()
@@ -546,27 +613,6 @@ def test_setlocale_category(self):
         # crasher from bug #7419
         self.assertRaises(locale.Error, locale.setlocale, 12345)
 
-    def test_getsetlocale_issue1813(self):
-        # Issue #1813: setting and getting the locale under a Turkish locale
-        oldlocale = locale.setlocale(locale.LC_CTYPE)
-        self.addCleanup(locale.setlocale, locale.LC_CTYPE, oldlocale)
-        try:
-            locale.setlocale(locale.LC_CTYPE, 'tr_TR')
-        except locale.Error:
-            # Unsupported locale on this system
-            self.skipTest('test needs Turkish locale')
-        loc = locale.getlocale(locale.LC_CTYPE)
-        if verbose:
-            print('testing with %a' % (loc,), end=' ', flush=True)
-        try:
-            locale.setlocale(locale.LC_CTYPE, loc)
-        except locale.Error as exc:
-            # bpo-37945: setlocale(LC_CTYPE) fails with getlocale(LC_CTYPE)
-            # and the tr_TR locale on Windows. getlocale() builds a locale
-            # which is not recognize by setlocale().
-            self.skipTest(f"setlocale(LC_CTYPE, {loc!r}) failed: {exc!r}")
-        self.assertEqual(loc, locale.getlocale(locale.LC_CTYPE))
-
     def test_invalid_locale_format_in_localetuple(self):
         with self.assertRaises(TypeError):
             locale.setlocale(locale.LC_ALL, b'fi_FI')
diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py
index 370685f1c6..12b61e7642 100644
--- a/Lib/test/test_logging.py
+++ b/Lib/test/test_logging.py
@@ -100,8 +100,7 @@ def setUp(self):
         self._threading_key = threading_helper.threading_setup()
 
         logger_dict = logging.getLogger().manager.loggerDict
-        logging._acquireLock()
-        try:
+        with logging._lock:
             self.saved_handlers = logging._handlers.copy()
             self.saved_handler_list = logging._handlerList[:]
             self.saved_loggers = saved_loggers = logger_dict.copy()
@@ -111,8 +110,6 @@ def setUp(self):
             for name in saved_loggers:
                 logger_states[name] = getattr(saved_loggers[name],
                                               'disabled', None)
-        finally:
-            logging._releaseLock()
 
         # Set two unused loggers
         self.logger1 = logging.getLogger("\xab\xd7\xbb")
@@ -146,8 +143,7 @@ def tearDown(self):
             self.root_logger.removeHandler(h)
             h.close()
         self.root_logger.setLevel(self.original_logging_level)
-        logging._acquireLock()
-        try:
+        with logging._lock:
             logging._levelToName.clear()
             logging._levelToName.update(self.saved_level_to_name)
             logging._nameToLevel.clear()
@@ -164,8 +160,6 @@ def tearDown(self):
             for name in self.logger_states:
                 if logger_states[name] is not None:
                     self.saved_loggers[name].disabled = logger_states[name]
-        finally:
-            logging._releaseLock()
 
         self.doCleanups()
         threading_helper.threading_cleanup(*self._threading_key)
@@ -182,7 +176,7 @@ def assert_log_lines(self, expected_values, stream=None, pat=None):
             match = pat.search(actual)
             if not match:
                 self.fail("Log line does not match expected pattern:\n" +
-                          actual)
+                            actual)
             self.assertEqual(tuple(match.groups()), expected)
         s = stream.read()
         if s:
@@ -588,7 +582,7 @@ def test_specific_filters(self):
                 ('Effusive', '17'),
                 ('Terse', '18'),
                 ('Silent', '20'),
-            ])
+        ])
         finally:
             if specific_filter:
                 self.root_logger.removeFilter(specific_filter)
@@ -613,7 +607,7 @@ def test_name(self):
     def test_builtin_handlers(self):
         # We can't actually *use* too many handlers in the tests,
         # but we can try instantiating them with various options
-        if sys.platform in ('linux', 'darwin'):
+        if sys.platform in ('linux', 'android', 'darwin'):
             for existing in (True, False):
                 fn = make_temp_file()
                 if not existing:
@@ -673,11 +667,11 @@ def test_pathlike_objects(self):
         os.unlink(fn)
         pfn = os_helper.FakePath(fn)
         cases = (
-            (logging.FileHandler, (pfn, 'w')),
-            (logging.handlers.RotatingFileHandler, (pfn, 'a')),
-            (logging.handlers.TimedRotatingFileHandler, (pfn, 'h')),
-        )
-        if sys.platform in ('linux', 'darwin'):
+                    (logging.FileHandler, (pfn, 'w')),
+                    (logging.handlers.RotatingFileHandler, (pfn, 'a')),
+                    (logging.handlers.TimedRotatingFileHandler, (pfn, 'h')),
+                )
+        if sys.platform in ('linux', 'android', 'darwin'):
             cases += ((logging.handlers.WatchedFileHandler, (pfn, 'w')),)
         for cls, args in cases:
             h = cls(*args, encoding="utf-8")
@@ -742,6 +736,7 @@ def remove_loop(fname, tries):
     @threading_helper.requires_working_threading()
     @skip_if_asan_fork
     @skip_if_tsan_fork
+    @unittest.skip("TODO: RUSTPYTHON; Flaky")
     def test_post_fork_child_no_deadlock(self):
         """Ensure child logging locks are not held; bpo-6721 & bpo-36533."""
         class _OurHandler(logging.Handler):
@@ -751,11 +746,8 @@ def __init__(self):
                     stream=open('/dev/null', 'wt', encoding='utf-8'))
 
             def emit(self, record):
-                self.sub_handler.acquire()
-                try:
+                with self.sub_handler.lock:
                     self.sub_handler.emit(record)
-                finally:
-                    self.sub_handler.release()
 
         self.assertEqual(len(logging._handlers), 0)
         refed_h = _OurHandler()
@@ -771,33 +763,26 @@ def emit(self, record):
         fork_happened__release_locks_and_end_thread = threading.Event()
 
         def lock_holder_thread_fn():
-            logging._acquireLock()
-            try:
-                refed_h.acquire()
-                try:
-                    # Tell the main thread to do the fork.
-                    locks_held__ready_to_fork.set()
-
-                    # If the deadlock bug exists, the fork will happen
-                    # without dealing with the locks we hold, deadlocking
-                    # the child.
-
-                    # Wait for a successful fork or an unreasonable amount of
-                    # time before releasing our locks.  To avoid a timing based
-                    # test we'd need communication from os.fork() as to when it
-                    # has actually happened.  Given this is a regression test
-                    # for a fixed issue, potentially less reliably detecting
-                    # regression via timing is acceptable for simplicity.
-                    # The test will always take at least this long. :(
-                    fork_happened__release_locks_and_end_thread.wait(0.5)
-                finally:
-                    refed_h.release()
-            finally:
-                logging._releaseLock()
+            with logging._lock, refed_h.lock:
+                # Tell the main thread to do the fork.
+                locks_held__ready_to_fork.set()
+
+                # If the deadlock bug exists, the fork will happen
+                # without dealing with the locks we hold, deadlocking
+                # the child.
+
+                # Wait for a successful fork or an unreasonable amount of
+                # time before releasing our locks.  To avoid a timing based
+                # test we'd need communication from os.fork() as to when it
+                # has actually happened.  Given this is a regression test
+                # for a fixed issue, potentially less reliably detecting
+                # regression via timing is acceptable for simplicity.
+                # The test will always take at least this long. :(
+                fork_happened__release_locks_and_end_thread.wait(0.5)
 
         lock_holder_thread = threading.Thread(
-            target=lock_holder_thread_fn,
-            name='test_post_fork_child_no_deadlock lock holder')
+                target=lock_holder_thread_fn,
+                name='test_post_fork_child_no_deadlock lock holder')
         lock_holder_thread.start()
 
         locks_held__ready_to_fork.wait()
@@ -1131,8 +1116,6 @@ class SMTPHandlerTest(BaseTest):
     # bpo-14314, bpo-19665, bpo-34092: don't wait forever
     TIMEOUT = support.LONG_TIMEOUT
 
-    # TODO: RUSTPYTHON
-    @unittest.skip(reason="Hangs RustPython")
     def test_basic(self):
         sockmap = {}
         server = TestSMTPServer((socket_helper.HOST, 0), self.process_message, 0.001,
@@ -1657,7 +1640,7 @@ def test_config4_ok(self):
                 logging.exception("just testing")
             sys.stdout.seek(0)
             self.assertEqual(output.getvalue(),
-                             "ERROR:root:just testing\nGot a [RuntimeError]\n")
+                "ERROR:root:just testing\nGot a [RuntimeError]\n")
             # Original logger output is empty
             self.assert_log_lines([])
 
@@ -2170,8 +2153,6 @@ def handle_request(self, request):
         request.end_headers()
         self.handled.set()
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("RUSTPYTHON")
     def test_output(self):
         # The log message sent to the HTTPHandler is properly received.
         logger = logging.getLogger("http")
@@ -2195,7 +2176,7 @@ def test_output(self):
                 sslctx = None
                 context = None
             self.server = server = TestHTTPServer(addr, self.handle_request,
-                                                  0.01, sslctx=sslctx)
+                                                    0.01, sslctx=sslctx)
             server.start()
             server.ready.wait()
             host = 'localhost:%d' % server.server_port
@@ -2212,7 +2193,8 @@ def test_output(self):
                 self.handled.clear()
                 msg = "sp\xe4m"
                 logger.error(msg)
-                self.handled.wait()
+                handled = self.handled.wait(support.SHORT_TIMEOUT)
+                self.assertTrue(handled, "HTTP request timed out")
                 self.assertEqual(self.log_data.path, '/frob')
                 self.assertEqual(self.command, method)
                 if method == 'GET':
@@ -2253,7 +2235,7 @@ def _assertTruesurvival(self):
                 dead.append(repr_)
         if dead:
             self.fail("%d objects should have survived "
-                      "but have been destroyed: %s" % (len(dead), ", ".join(dead)))
+                "but have been destroyed: %s" % (len(dead), ", ".join(dead)))
 
     def test_persistent_loggers(self):
         # Logger objects are persistent and retain their configuration, even
@@ -2351,7 +2333,7 @@ def test_warnings(self):
             s = a_file.getvalue()
             a_file.close()
             self.assertEqual(s,
-                             "dummy.py:42: UserWarning: Explicit\n  Dummy line\n")
+                "dummy.py:42: UserWarning: Explicit\n  Dummy line\n")
 
     def test_warnings_no_handlers(self):
         with warnings.catch_warnings():
@@ -2632,7 +2614,7 @@ class ConfigDictTest(BaseTest):
         },
         'root' : {
             'level' : 'NOTSET',
-            'handlers' : ['hand1'],
+                'handlers' : ['hand1'],
         },
     }
 
@@ -2666,7 +2648,7 @@ class ConfigDictTest(BaseTest):
         },
         'root' : {
             'level' : 'NOTSET',
-            'handlers' : ['hand1'],
+                'handlers' : ['hand1'],
         },
     }
 
@@ -3277,7 +3259,7 @@ def format(self, record):
             'h1' : {
                 'class': 'logging.FileHandler',
             },
-            # key is before depended on handlers to test that deferred config works
+             # key is before depended on handlers to test that deferred config works
             'ah' : {
                 'class': 'logging.handlers.QueueHandler',
                 'handlers': ['h1']
@@ -3355,7 +3337,7 @@ def test_config4_ok(self):
                 logging.exception("just testing")
             sys.stdout.seek(0)
             self.assertEqual(output.getvalue(),
-                             "ERROR:root:just testing\nGot a [RuntimeError]\n")
+                "ERROR:root:just testing\nGot a [RuntimeError]\n")
             # Original logger output is empty
             self.assert_log_lines([])
 
@@ -3370,7 +3352,7 @@ def test_config4a_ok(self):
                 logging.exception("just testing")
             sys.stdout.seek(0)
             self.assertEqual(output.getvalue(),
-                             "ERROR:root:just testing\nGot a [RuntimeError]\n")
+                "ERROR:root:just testing\nGot a [RuntimeError]\n")
             # Original logger output is empty
             self.assert_log_lines([])
 
@@ -3770,7 +3752,28 @@ def test_baseconfig(self):
         d = {
             'atuple': (1, 2, 3),
             'alist': ['a', 'b', 'c'],
-            'adict': {'d': 'e', 'f': 3 },
+            'adict': {
+                'd': 'e', 'f': 3 ,
+                'alpha numeric 1 with spaces' : 5,
+                'alpha numeric 1 %( - © ©ß¯' : 9,
+                'alpha numeric ] 1 with spaces' : 15,
+                'alpha ]] numeric 1 %( - © ©ß¯]' : 19,
+                ' alpha [ numeric 1 %( - © ©ß¯] ' : 11,
+                ' alpha ' : 32,
+                '' : 10,
+                'nest4' : {
+                    'd': 'e', 'f': 3 ,
+                    'alpha numeric 1 with spaces' : 5,
+                    'alpha numeric 1 %( - © ©ß¯' : 9,
+                    '' : 10,
+                    'somelist' :  ('g', ('h', 'i'), 'j'),
+                    'somedict' : {
+                        'a' : 1,
+                        'a with 1 and space' : 3,
+                        'a with ( and space' : 4,
+                    }
+                }
+            },
             'nest1': ('g', ('h', 'i'), 'j'),
             'nest2': ['k', ['l', 'm'], 'n'],
             'nest3': ['o', 'cfg://alist', 'p'],
@@ -3782,11 +3785,36 @@ def test_baseconfig(self):
         self.assertEqual(bc.convert('cfg://nest2[1][1]'), 'm')
         self.assertEqual(bc.convert('cfg://adict.d'), 'e')
         self.assertEqual(bc.convert('cfg://adict[f]'), 3)
+        self.assertEqual(bc.convert('cfg://adict[alpha numeric 1 with spaces]'), 5)
+        self.assertEqual(bc.convert('cfg://adict[alpha numeric 1 %( - © ©ß¯]'), 9)
+        self.assertEqual(bc.convert('cfg://adict[]'), 10)
+        self.assertEqual(bc.convert('cfg://adict.nest4.d'), 'e')
+        self.assertEqual(bc.convert('cfg://adict.nest4[d]'), 'e')
+        self.assertEqual(bc.convert('cfg://adict[nest4].d'), 'e')
+        self.assertEqual(bc.convert('cfg://adict[nest4][f]'), 3)
+        self.assertEqual(bc.convert('cfg://adict[nest4][alpha numeric 1 with spaces]'), 5)
+        self.assertEqual(bc.convert('cfg://adict[nest4][alpha numeric 1 %( - © ©ß¯]'), 9)
+        self.assertEqual(bc.convert('cfg://adict[nest4][]'), 10)
+        self.assertEqual(bc.convert('cfg://adict[nest4][somelist][0]'), 'g')
+        self.assertEqual(bc.convert('cfg://adict[nest4][somelist][1][0]'), 'h')
+        self.assertEqual(bc.convert('cfg://adict[nest4][somelist][1][1]'), 'i')
+        self.assertEqual(bc.convert('cfg://adict[nest4][somelist][2]'), 'j')
+        self.assertEqual(bc.convert('cfg://adict[nest4].somedict.a'), 1)
+        self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a]'), 1)
+        self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a with 1 and space]'), 3)
+        self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a with ( and space]'), 4)
+        self.assertEqual(bc.convert('cfg://adict.nest4.somelist[1][1]'), 'i')
+        self.assertEqual(bc.convert('cfg://adict.nest4.somelist[2]'), 'j')
+        self.assertEqual(bc.convert('cfg://adict.nest4.somedict.a'), 1)
+        self.assertEqual(bc.convert('cfg://adict.nest4.somedict[a]'), 1)
         v = bc.convert('cfg://nest3')
         self.assertEqual(v.pop(1), ['a', 'b', 'c'])
         self.assertRaises(KeyError, bc.convert, 'cfg://nosuch')
         self.assertRaises(ValueError, bc.convert, 'cfg://!')
         self.assertRaises(KeyError, bc.convert, 'cfg://adict[2]')
+        self.assertRaises(KeyError, bc.convert, 'cfg://adict[alpha numeric ] 1 with spaces]')
+        self.assertRaises(ValueError, bc.convert, 'cfg://adict[ alpha ]] numeric 1 %( - © ©ß¯] ]')
+        self.assertRaises(ValueError, bc.convert, 'cfg://adict[ alpha [ numeric 1 %( - © ©ß¯] ]')
 
     def test_namedtuple(self):
         # see bpo-39142
@@ -3992,7 +4020,7 @@ def test_config_reject_simple_queue_handler_multiprocessing_context(self):
     @skip_if_tsan_fork
     @support.requires_subprocess()
     @unittest.skipUnless(support.Py_DEBUG, "requires a debug build for testing"
-                                           "assertions in multiprocessing")
+                                           " assertions in multiprocessing")
     def test_config_queue_handler_multiprocessing_context(self):
         # regression test for gh-121723
         if support.MS_WINDOWS:
@@ -4029,8 +4057,10 @@ def _mpinit_issue121723(qspec, message_to_log):
         # log a message (this creates a record put in the queue)
         logging.getLogger().info(message_to_log)
 
-    # TODO: RustPython
-    @unittest.expectedFailure
+    @unittest.skip('TODO: RUSTPYTHON, flaky EOFError')
+    # TODO: RUSTPYTHON - SemLock not implemented on Windows
+    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
+    @skip_if_tsan_fork
     @support.requires_subprocess()
     def test_multiprocessing_queues(self):
         # See gh-119819
@@ -4089,8 +4119,8 @@ def test_90195(self):
         # Logger should be enabled, since explicitly mentioned
         self.assertFalse(logger.disabled)
 
-    # TODO: RustPython
-    @unittest.expectedFailure
+    # 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
@@ -4208,7 +4238,7 @@ def filter(self, record):
                 t = type(record)
                 if t is not self.cls:
                     msg = 'Unexpected LogRecord type %s, expected %s' % (t,
-                                                                         self.cls)
+                            self.cls)
                     raise TypeError(msg)
                 return True
 
@@ -4228,7 +4258,7 @@ def test_logrecord_class(self):
         logging.setLogRecordFactory(DerivedLogRecord)
         self.root_logger.error(self.next_message())
         self.assert_log_lines([
-            ('root', 'ERROR', '2'),
+           ('root', 'ERROR', '2'),
         ])
 
 
@@ -4276,8 +4306,6 @@ def test_formatting(self):
         self.assertEqual(formatted_msg, log_record.msg)
         self.assertEqual(formatted_msg, log_record.message)
 
-    @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
-                         'logging.handlers.QueueListener required for this test')
     def test_queue_listener(self):
         handler = TestHandler(support.Matcher())
         listener = logging.handlers.QueueListener(self.queue, handler)
@@ -4288,6 +4316,7 @@ def test_queue_listener(self):
             self.que_logger.critical(self.next_message())
         finally:
             listener.stop()
+            listener.stop()  # gh-114706 - ensure no crash if called again
         self.assertTrue(handler.matches(levelno=logging.WARNING, message='1'))
         self.assertTrue(handler.matches(levelno=logging.ERROR, message='2'))
         self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='3'))
@@ -4311,8 +4340,18 @@ def test_queue_listener(self):
         self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='6'))
         handler.close()
 
-    @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
-                         'logging.handlers.QueueListener required for this test')
+        # doesn't hurt to call stop() more than once.
+        listener.stop()
+        self.assertIsNone(listener._thread)
+
+    def test_queue_listener_multi_start(self):
+        handler = TestHandler(support.Matcher())
+        listener = logging.handlers.QueueListener(self.queue, handler)
+        listener.start()
+        self.assertRaises(RuntimeError, listener.start)
+        listener.stop()
+        self.assertIsNone(listener._thread)
+
     def test_queue_listener_with_StreamHandler(self):
         # Test that traceback and stack-info only appends once (bpo-34334, bpo-46755).
         listener = logging.handlers.QueueListener(self.queue, self.root_hdlr)
@@ -4327,8 +4366,6 @@ def test_queue_listener_with_StreamHandler(self):
         self.assertEqual(self.stream.getvalue().strip().count('Traceback'), 1)
         self.assertEqual(self.stream.getvalue().strip().count('Stack'), 1)
 
-    @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
-                         'logging.handlers.QueueListener required for this test')
     def test_queue_listener_with_multiple_handlers(self):
         # Test that queue handler format doesn't affect other handler formats (bpo-35726).
         self.que_hdlr.setFormatter(self.root_formatter)
@@ -4344,6 +4381,7 @@ def test_queue_listener_with_multiple_handlers(self):
     import multiprocessing
     from unittest.mock import patch
 
+    @skip_if_tsan_fork
     @threading_helper.requires_working_threading()
     class QueueListenerTest(BaseTest):
         """
@@ -4427,8 +4465,8 @@ def test_no_messages_in_queue_after_stop(self):
                 expected = [[], [logging.handlers.QueueListener._sentinel]]
                 self.assertIn(items, expected,
                               'Found unexpected messages in queue: %s' % (
-                                  [m.msg if isinstance(m, logging.LogRecord)
-                                   else m for m in items]))
+                                    [m.msg if isinstance(m, logging.LogRecord)
+                                     else m for m in items]))
 
         def test_calls_task_done_after_stop(self):
             # Issue 36813: Make sure queue.join does not deadlock.
@@ -4538,8 +4576,7 @@ def test_dollars(self):
         f = logging.Formatter('${asctime}--', style='$')
         self.assertTrue(f.usesTime())
 
-    # TODO: RustPython
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ValueError: Unexpected error parsing format string
     def test_format_validate(self):
         # Check correct formatting
         # Percentage style
@@ -4713,8 +4750,6 @@ def test_defaults_parameter(self):
     def test_invalid_style(self):
         self.assertRaises(ValueError, logging.Formatter, None, None, 'x')
 
-    # TODO: RustPython
-    @unittest.expectedFailure
     def test_time(self):
         r = self.get_record()
         dt = datetime.datetime(1993, 4, 21, 8, 3, 0, 0, utc)
@@ -4729,8 +4764,6 @@ def test_time(self):
         f.format(r)
         self.assertEqual(r.asctime, '1993-04-21 08:03:00,123')
 
-    # TODO: RustPython
-    @unittest.expectedFailure
     def test_default_msec_format_none(self):
         class NoMsecFormatter(logging.Formatter):
             default_msec_format = None
@@ -4751,6 +4784,77 @@ def test_issue_89047(self):
             s = f.format(r)
             self.assertNotIn('.1000', s)
 
+    def test_msecs_has_no_floating_point_precision_loss(self):
+        # See issue gh-102402
+        tests = (
+            # time_ns is approx. 2023-03-04 04:25:20 UTC
+            # (time_ns, expected_msecs_value)
+            (1_677_902_297_100_000_000, 100.0),  # exactly 100ms
+            (1_677_903_920_999_998_503, 999.0),  # check truncating doesn't round
+            (1_677_903_920_000_998_503, 0.0),  # check truncating doesn't round
+            (1_677_903_920_999_999_900, 0.0), # check rounding up
+        )
+        for ns, want in tests:
+            with patch('time.time_ns') as patched_ns:
+                patched_ns.return_value = ns
+                record = logging.makeLogRecord({'msg': 'test'})
+            with self.subTest(ns):
+                self.assertEqual(record.msecs, want)
+                self.assertEqual(record.created, ns / 1e9)
+                self.assertAlmostEqual(record.created - int(record.created),
+                                       record.msecs / 1e3,
+                                       delta=1e-3)
+
+    def test_relativeCreated_has_higher_precision(self):
+        # See issue gh-102402.
+        # Run the code in the subprocess, because the time module should
+        # be patched before the first import of the logging package.
+        # Temporary unloading and re-importing the logging package has
+        # side effects (including registering the atexit callback and
+        # references leak).
+        start_ns = 1_677_903_920_000_998_503  # approx. 2023-03-04 04:25:20 UTC
+        offsets_ns = (200, 500, 12_354, 99_999, 1_677_903_456_999_123_456)
+        code = textwrap.dedent(f"""
+            start_ns = {start_ns!r}
+            offsets_ns = {offsets_ns!r}
+            start_monotonic_ns = start_ns - 1
+
+            import time
+            # Only time.time_ns needs to be patched for the current
+            # implementation, but patch also other functions to make
+            # the test less implementation depending.
+            old_time_ns = time.time_ns
+            old_time = time.time
+            old_monotonic_ns = time.monotonic_ns
+            old_monotonic = time.monotonic
+            time_ns_result = start_ns
+            time.time_ns = lambda: time_ns_result
+            time.time = lambda: time.time_ns()/1e9
+            time.monotonic_ns = lambda: time_ns_result - start_monotonic_ns
+            time.monotonic = lambda: time.monotonic_ns()/1e9
+            try:
+                import logging
+
+                for offset_ns in offsets_ns:
+                    # mock for log record creation
+                    time_ns_result = start_ns + offset_ns
+                    record = logging.makeLogRecord({{'msg': 'test'}})
+                    print(record.created, record.relativeCreated)
+            finally:
+                time.time_ns = old_time_ns
+                time.time = old_time
+                time.monotonic_ns = old_monotonic_ns
+                time.monotonic = old_monotonic
+        """)
+        rc, out, err = assert_python_ok("-c", code)
+        out = out.decode()
+        for offset_ns, line in zip(offsets_ns, out.splitlines(), strict=True):
+            with self.subTest(offset_ns=offset_ns):
+                created, relativeCreated = map(float, line.split())
+                self.assertAlmostEqual(created, (start_ns + offset_ns) / 1e9, places=6)
+                # After PR gh-102412, precision (places) increases from 3 to 7
+                self.assertAlmostEqual(relativeCreated, offset_ns / 1e6, places=7)
+
 
 class TestBufferingFormatter(logging.BufferingFormatter):
     def formatHeader(self, records):
@@ -4795,9 +4899,9 @@ def test_formatting(self):
         self.assertTrue(r.exc_text.endswith('\nRuntimeError: '
                                             'deliberate mistake'))
         self.assertTrue(r.stack_info.startswith('Stack (most recent '
-                                                'call last):\n'))
+                                              'call last):\n'))
         self.assertTrue(r.stack_info.endswith('logging.exception(\'failed\', '
-                                              'stack_info=True)'))
+                                            'stack_info=True)'))
 
 
 class LastResortTest(BaseTest):
@@ -5061,8 +5165,7 @@ def __init__(self, name='MyLogger', level=logging.NOTSET):
             h.close()
             logging.setLoggerClass(logging.Logger)
 
-    # TODO: RustPython
-    @unittest.expectedFailure
+    @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("""
@@ -5082,8 +5185,7 @@ def __del__(self):
         self.assertIn("exception in __del__", err)
         self.assertIn("ValueError: some error", err)
 
-    # TODO: RustPython
-    @unittest.expectedFailure
+    @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
@@ -5175,7 +5277,7 @@ def _extract_logrecord_process_name(key, logMultiprocessing, conn=None):
             results = {'processName'  : name,
                        'r1.processName': r1.processName,
                        'r2.processName': r2.processName,
-                       }
+                      }
         finally:
             logging.logMultiprocessing = prev_logMultiprocessing
         if conn:
@@ -5183,6 +5285,7 @@ def _extract_logrecord_process_name(key, logMultiprocessing, conn=None):
         else:
             return results
 
+    @skip_if_tsan_fork
     def test_multiprocessing(self):
         support.skip_if_broken_multiprocessing_synchronize()
         multiprocessing_imported = 'multiprocessing' in sys.modules
@@ -5333,7 +5436,7 @@ def test_strformatstyle(self):
             logging.error("Log an error")
             sys.stdout.seek(0)
             self.assertEqual(output.getvalue().strip(),
-                             "ERROR:root:Log an error")
+                "ERROR:root:Log an error")
 
     def test_stringtemplatestyle(self):
         with support.captured_stdout() as output:
@@ -5341,7 +5444,7 @@ def test_stringtemplatestyle(self):
             logging.error("Log an error")
             sys.stdout.seek(0)
             self.assertEqual(output.getvalue().strip(),
-                             "ERROR:root:Log an error")
+                "ERROR:root:Log an error")
 
     def test_filename(self):
 
@@ -5418,11 +5521,11 @@ def test_incompatible(self):
         handlers = [logging.StreamHandler()]
         stream = sys.stderr
         assertRaises(ValueError, logging.basicConfig, filename='test.log',
-                     stream=stream)
+                                                      stream=stream)
         assertRaises(ValueError, logging.basicConfig, filename='test.log',
-                     handlers=handlers)
+                                                      handlers=handlers)
         assertRaises(ValueError, logging.basicConfig, stream=stream,
-                     handlers=handlers)
+                                                      handlers=handlers)
         # Issue 23207: test for invalid kwargs
         assertRaises(ValueError, logging.basicConfig, loglevel=logging.INFO)
         # Should pop both filename and filemode even if filename is None
@@ -5803,6 +5906,30 @@ def test_extra_not_merged_by_default(self):
         record = self.recording.records[0]
         self.assertFalse(hasattr(record, 'foo'))
 
+    def test_extra_merged(self):
+        self.adapter = logging.LoggerAdapter(logger=self.logger,
+                                             extra={'foo': '1'},
+                                             merge_extra=True)
+
+        self.adapter.critical('foo and bar should be here', extra={'bar': '2'})
+        self.assertEqual(len(self.recording.records), 1)
+        record = self.recording.records[0]
+        self.assertTrue(hasattr(record, 'foo'))
+        self.assertTrue(hasattr(record, 'bar'))
+        self.assertEqual(record.foo, '1')
+        self.assertEqual(record.bar, '2')
+
+    def test_extra_merged_log_call_has_precedence(self):
+        self.adapter = logging.LoggerAdapter(logger=self.logger,
+                                             extra={'foo': '1'},
+                                             merge_extra=True)
+
+        self.adapter.critical('foo shall be min', extra={'foo': '2'})
+        self.assertEqual(len(self.recording.records), 1)
+        record = self.recording.records[0]
+        self.assertTrue(hasattr(record, 'foo'))
+        self.assertEqual(record.foo, '2')
+
 
 class PrefixAdapter(logging.LoggerAdapter):
     prefix = 'Adapter'
@@ -6112,14 +6239,14 @@ def test_should_not_rollover(self):
 
         # If maxBytes is zero rollover never occurs
         rh = logging.handlers.RotatingFileHandler(
-            self.fn, encoding="utf-8", maxBytes=0)
+                self.fn, encoding="utf-8", maxBytes=0)
         self.assertFalse(rh.shouldRollover(None))
         rh.close()
 
         with open(self.fn, 'wb') as f:
             f.write(b'\n')
         rh = logging.handlers.RotatingFileHandler(
-            self.fn, encoding="utf-8", maxBytes=0)
+                self.fn, encoding="utf-8", maxBytes=0)
         self.assertFalse(rh.shouldRollover(None))
         rh.close()
 
@@ -6129,7 +6256,7 @@ def test_should_not_rollover_non_file(self):
         # We set maxBytes to 1 so that rollover would normally happen, except
         # for the check for regular files
         rh = logging.handlers.RotatingFileHandler(
-            os.devnull, encoding="utf-8", maxBytes=1)
+                os.devnull, encoding="utf-8", maxBytes=1)
         self.assertFalse(rh.shouldRollover(self.next_rec()))
         rh.close()
 
@@ -6259,13 +6386,11 @@ def rotator(source, dest):
         rh.close()
 
 class TimedRotatingFileHandlerTest(BaseFileTest):
-    # TODO: RUSTPYTHON
-    @unittest.skip("OS dependent bug")
     @unittest.skipIf(support.is_wasi, "WASI does not have /dev/null.")
     def test_should_not_rollover(self):
         # See bpo-45401. Should only ever rollover regular files
         fh = logging.handlers.TimedRotatingFileHandler(
-            os.devnull, 'S', encoding="utf-8", backupCount=1)
+                os.devnull, 'S', encoding="utf-8", backupCount=1)
         time.sleep(1.1)    # a little over a second ...
         r = logging.makeLogRecord({'msg': 'testing - device file'})
         self.assertFalse(fh.shouldRollover(r))
@@ -6274,7 +6399,7 @@ def test_should_not_rollover(self):
     # other test methods added below
     def test_rollover(self):
         fh = logging.handlers.TimedRotatingFileHandler(
-            self.fn, 'S', encoding="utf-8", backupCount=1)
+                self.fn, 'S', encoding="utf-8", backupCount=1)
         fmt = logging.Formatter('%(asctime)s %(message)s')
         fh.setFormatter(fmt)
         r1 = logging.makeLogRecord({'msg': 'testing - initial'})
@@ -6314,8 +6439,6 @@ def test_rollover(self):
                     print(tf.read())
         self.assertTrue(found, msg=msg)
 
-    # TODO: RustPython
-    @unittest.skip("OS dependent bug")
     def test_rollover_at_midnight(self, weekly=False):
         os_helper.unlink(self.fn)
         now = datetime.datetime.now()
@@ -6359,8 +6482,6 @@ def test_rollover_at_midnight(self, weekly=False):
             for i, line in enumerate(f):
                 self.assertIn(f'testing1 {i}', line)
 
-    # TODO: RustPython
-    @unittest.skip("OS dependent bug")
     def test_rollover_at_weekday(self):
         self.test_rollover_at_midnight(weekly=True)
 
@@ -6944,7 +7065,7 @@ def secs(**kw):
                   ('MIDNIGHT', 60 * 60 * 24),
                   # current time (epoch start) is a Thursday, W0 means Monday
                   ('W0', secs(days=4, hours=24)),
-                  ):
+                 ):
     for interval in 1, 3:
         def test_compute_rollover(self, when=when, interval=interval, exp=exp):
             rh = logging.handlers.TimedRotatingFileHandler(
@@ -6970,8 +7091,8 @@ def test_compute_rollover(self, when=when, interval=interval, exp=exp):
                         currentSecond = t[5]
                         # r is the number of seconds left between now and midnight
                         r = logging.handlers._MIDNIGHT - ((currentHour * 60 +
-                                                           currentMinute) * 60 +
-                                                          currentSecond)
+                                                        currentMinute) * 60 +
+                                currentSecond)
                         result = currentTime + r
                         print('t: %s (%s)' % (t, rh.utc), file=sys.stderr)
                         print('currentHour: %s' % currentHour, file=sys.stderr)
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index 2a38b133f1..dbcc85bd69 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -412,8 +412,7 @@ def check_float_conversion(self, n):
                "Got {}, expected {}.".format(n, actual, expected))
         self.assertEqual(actual, expected, msg)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_IEEE_754
     def test_float_conversion(self):
 
@@ -824,8 +823,7 @@ def check_truediv(self, a, b, skip_small=True):
         self.assertEqual(expected, got, "Incorrectly rounded division {}/{}: "
                          "expected {}, got {}".format(a, b, expected, got))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_IEEE_754
     def test_correctly_rounded_true_division(self):
         # more stringent tests than those above, checking that the
@@ -1326,17 +1324,22 @@ def equivalent_python(n, length, byteorder, signed=False):
         check(tests4, 'little', signed=False)
 
         self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=False)
-        self.assertRaises(OverflowError, (256).to_bytes, 1, 'big', signed=True)
         self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=False)
-        self.assertRaises(OverflowError, (256).to_bytes, 1, 'little', signed=True)
+        self.assertRaises(OverflowError, (128).to_bytes, 1, 'big', signed=True)
+        self.assertRaises(OverflowError, (128).to_bytes, 1, 'little', signed=True)
+        self.assertRaises(OverflowError, (-129).to_bytes, 1, 'big', signed=True)
+        self.assertRaises(OverflowError, (-129).to_bytes, 1, 'little', signed=True)
         self.assertRaises(OverflowError, (-1).to_bytes, 2, 'big', signed=False)
         self.assertRaises(OverflowError, (-1).to_bytes, 2, 'little', signed=False)
         self.assertEqual((0).to_bytes(0, 'big'), b'')
+        self.assertEqual((0).to_bytes(0, 'big', signed=True), b'')
         self.assertEqual((1).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x01')
         self.assertEqual((0).to_bytes(5, 'big'), b'\x00\x00\x00\x00\x00')
         self.assertEqual((-1).to_bytes(5, 'big', signed=True),
                          b'\xff\xff\xff\xff\xff')
         self.assertRaises(OverflowError, (1).to_bytes, 0, 'big')
+        self.assertRaises(OverflowError, (-1).to_bytes, 0, 'big', signed=True)
+        self.assertRaises(OverflowError, (-1).to_bytes, 0, 'little', signed=True)
 
         # gh-98783
         class SubStr(str):
@@ -1344,8 +1347,7 @@ class SubStr(str):
         self.assertEqual((0).to_bytes(1, SubStr('big')), b'\x00')
         self.assertEqual((0).to_bytes(0, SubStr('little')), b'')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_from_bytes(self):
         def check(tests, byteorder, signed=False):
             def equivalent_python(byte_array, byteorder, signed=False):
@@ -1559,6 +1561,11 @@ def test_from_bytes_small(self):
             b = i.to_bytes(2, signed=True)
             self.assertIs(int.from_bytes(b, signed=True), i)
 
+    def test_is_integer(self):
+        self.assertTrue((-1).is_integer())
+        self.assertTrue((0).is_integer())
+        self.assertTrue((1).is_integer())
+
     def test_access_to_nonexistent_digit_0(self):
         # http://bugs.python.org/issue14630: A bug in _PyLong_Copy meant that
         # ob_digit[0] was being incorrectly accessed for instances of a
@@ -1602,5 +1609,63 @@ def test_square(self):
                 self.assertEqual(n**2,
                     (1 << (2 * bitlen)) - (1 << (bitlen + 1)) + 1)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test___sizeof__(self):
+        self.assertEqual(int.__itemsize__, sys.int_info.sizeof_digit)
+
+        # Pairs (test_value, number of allocated digits)
+        test_values = [
+            # We always allocate space for at least one digit, even for
+            # a value of zero; sys.getsizeof should reflect that.
+            (0, 1),
+            (1, 1),
+            (-1, 1),
+            (BASE-1, 1),
+            (1-BASE, 1),
+            (BASE, 2),
+            (-BASE, 2),
+            (BASE*BASE - 1, 2),
+            (BASE*BASE, 3),
+        ]
+
+        for value, ndigits in test_values:
+            with self.subTest(value):
+                self.assertEqual(
+                    value.__sizeof__(),
+                    int.__basicsize__ + int.__itemsize__ * ndigits
+                )
+
+        # Same test for a subclass of int.
+        class MyInt(int):
+            pass
+
+        self.assertEqual(MyInt.__itemsize__, sys.int_info.sizeof_digit)
+
+        for value, ndigits in test_values:
+            with self.subTest(value):
+                self.assertEqual(
+                    MyInt(value).__sizeof__(),
+                    MyInt.__basicsize__ + MyInt.__itemsize__ * ndigits
+                )
+
+        # GH-117195 -- This shouldn't crash
+        object.__sizeof__(1)
+
+    def test_hash(self):
+        # gh-136599
+        self.assertEqual(hash(-1), -2)
+        self.assertEqual(hash(0), 0)
+        self.assertEqual(hash(10), 10)
+
+        self.assertEqual(hash(sys.hash_info.modulus - 2), sys.hash_info.modulus - 2)
+        self.assertEqual(hash(sys.hash_info.modulus - 1), sys.hash_info.modulus - 1)
+        self.assertEqual(hash(sys.hash_info.modulus), 0)
+        self.assertEqual(hash(sys.hash_info.modulus + 1), 1)
+
+        self.assertEqual(hash(-sys.hash_info.modulus - 2), -2)
+        self.assertEqual(hash(-sys.hash_info.modulus - 1), -2)
+        self.assertEqual(hash(-sys.hash_info.modulus), 0)
+        self.assertEqual(hash(-sys.hash_info.modulus + 1), -sys.hash_info.modulus + 1)
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_lzma.py b/Lib/test/test_lzma.py
index 1bac61f59e..4010ef9c34 100644
--- a/Lib/test/test_lzma.py
+++ b/Lib/test/test_lzma.py
@@ -409,8 +409,6 @@ def test_decompressor_bigmem(self, size):
 
     # Pickling raises an exception; there's no way to serialize an lzma_stream.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises(TypeError):
@@ -2194,4 +2192,4 @@ def test_filter_properties_roundtrip(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
new file mode 100644
index 0000000000..940baf3941
--- /dev/null
+++ b/Lib/test/test_mailbox.py
@@ -0,0 +1,2495 @@
+import os
+import sys
+import time
+import stat
+import socket
+import email
+import email.message
+import re
+import io
+import tempfile
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+from test.support import refleak_helper
+from test.support import socket_helper
+from test.support.testcase import ExtraAssertions
+import unittest
+import textwrap
+import mailbox
+import glob
+
+
+if not socket_helper.has_gethostname:
+    raise unittest.SkipTest("test requires gethostname()")
+
+
+class TestBase:
+
+    all_mailbox_types = (mailbox.Message, mailbox.MaildirMessage,
+                         mailbox.mboxMessage, mailbox.MHMessage,
+                         mailbox.BabylMessage, mailbox.MMDFMessage)
+
+    def _check_sample(self, msg):
+        # Inspect a mailbox.Message representation of the sample message
+        self.assertIsInstance(msg, email.message.Message)
+        self.assertIsInstance(msg, mailbox.Message)
+        for key, value in _sample_headers:
+            self.assertIn(value, msg.get_all(key))
+        self.assertTrue(msg.is_multipart())
+        self.assertEqual(len(msg.get_payload()), len(_sample_payloads))
+        for i, payload in enumerate(_sample_payloads):
+            part = msg.get_payload(i)
+            self.assertIsInstance(part, email.message.Message)
+            self.assertNotIsInstance(part, mailbox.Message)
+            self.assertEqual(part.get_payload(), payload)
+
+    def _delete_recursively(self, target):
+        # Delete a file or delete a directory recursively
+        if os.path.isdir(target):
+            os_helper.rmtree(target)
+        elif os.path.exists(target):
+            os_helper.unlink(target)
+
+
+class TestMailbox(TestBase):
+
+    maxDiff = None
+
+    _factory = None     # Overridden by subclasses to reuse tests
+    _template = 'From: foo\n\n%s\n'
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._delete_recursively(self._path)
+        self._box = self._factory(self._path)
+
+    def tearDown(self):
+        self._box.close()
+        self._delete_recursively(self._path)
+
+    def test_add(self):
+        # Add copies of a sample message
+        keys = []
+        keys.append(self._box.add(self._template % 0))
+        self.assertEqual(len(self._box), 1)
+        keys.append(self._box.add(mailbox.Message(_sample_message)))
+        self.assertEqual(len(self._box), 2)
+        keys.append(self._box.add(email.message_from_string(_sample_message)))
+        self.assertEqual(len(self._box), 3)
+        keys.append(self._box.add(io.BytesIO(_bytes_sample_message)))
+        self.assertEqual(len(self._box), 4)
+        keys.append(self._box.add(_sample_message))
+        self.assertEqual(len(self._box), 5)
+        keys.append(self._box.add(_bytes_sample_message))
+        self.assertEqual(len(self._box), 6)
+        with self.assertWarns(DeprecationWarning):
+            keys.append(self._box.add(
+                io.TextIOWrapper(io.BytesIO(_bytes_sample_message), encoding="utf-8")))
+        self.assertEqual(len(self._box), 7)
+        self.assertEqual(self._box.get_string(keys[0]), self._template % 0)
+        for i in (1, 2, 3, 4, 5, 6):
+            self._check_sample(self._box[keys[i]])
+
+    _nonascii_msg = textwrap.dedent("""\
+            From: foo
+            Subject: Falinaptár házhozszállítással. Már rendeltél?
+
+            0
+            """)
+
+    def test_add_invalid_8bit_bytes_header(self):
+        key = self._box.add(self._nonascii_msg.encode('latin-1'))
+        self.assertEqual(len(self._box), 1)
+        self.assertEqual(self._box.get_bytes(key),
+            self._nonascii_msg.encode('latin-1'))
+
+    def test_invalid_nonascii_header_as_string(self):
+        subj = self._nonascii_msg.splitlines()[1]
+        key = self._box.add(subj.encode('latin-1'))
+        self.assertEqual(self._box.get_string(key),
+            'Subject: =?unknown-8bit?b?RmFsaW5hcHThciBo4Xpob3pzeuFsbO104XNz'
+            'YWwuIE3hciByZW5kZWx06Ww/?=\n\n')
+
+    def test_add_nonascii_string_header_raises(self):
+        with self.assertRaisesRegex(ValueError, "ASCII-only"):
+            self._box.add(self._nonascii_msg)
+        self._box.flush()
+        self.assertEqual(len(self._box), 0)
+        self.assertMailboxEmpty()
+
+    def test_add_that_raises_leaves_mailbox_empty(self):
+        class CustomError(Exception): ...
+        exc_msg = "a fake error"
+
+        def raiser(*args, **kw):
+            raise CustomError(exc_msg)
+        support.patch(self, email.generator.BytesGenerator, 'flatten', raiser)
+        with self.assertRaisesRegex(CustomError, exc_msg):
+            self._box.add(email.message_from_string("From: Alphöso"))
+        self.assertEqual(len(self._box), 0)
+        self._box.close()
+        self.assertMailboxEmpty()
+
+    _non_latin_bin_msg = textwrap.dedent("""\
+        From: foo@bar.com
+        To: báz
+        Subject: Maintenant je vous présente mon collègue, le pouf célèbre
+        \tJean de Baddie
+        Mime-Version: 1.0
+        Content-Type: text/plain; charset="utf-8"
+        Content-Transfer-Encoding: 8bit
+
+        Да, они летят.
+        """).encode('utf-8')
+
+    def test_add_8bit_body(self):
+        key = self._box.add(self._non_latin_bin_msg)
+        self.assertEqual(self._box.get_bytes(key),
+                         self._non_latin_bin_msg)
+        with self._box.get_file(key) as f:
+            self.assertEqual(f.read(),
+                             self._non_latin_bin_msg.replace(b'\n',
+                                os.linesep.encode()))
+        self.assertEqual(self._box[key].get_payload(),
+                        "Да, они летят.\n")
+
+    def test_add_binary_file(self):
+        with tempfile.TemporaryFile('wb+') as f:
+            f.write(_bytes_sample_message)
+            f.seek(0)
+            key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            _bytes_sample_message.split(b'\n'))
+
+    def test_add_binary_nonascii_file(self):
+        with tempfile.TemporaryFile('wb+') as f:
+            f.write(self._non_latin_bin_msg)
+            f.seek(0)
+            key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            self._non_latin_bin_msg.split(b'\n'))
+
+    def test_add_text_file_warns(self):
+        with tempfile.TemporaryFile('w+', encoding='utf-8') as f:
+            f.write(_sample_message)
+            f.seek(0)
+            with self.assertWarns(DeprecationWarning):
+                key = self._box.add(f)
+        self.assertEqual(self._box.get_bytes(key).split(b'\n'),
+            _bytes_sample_message.split(b'\n'))
+
+    def test_add_StringIO_warns(self):
+        with self.assertWarns(DeprecationWarning):
+            key = self._box.add(io.StringIO(self._template % "0"))
+        self.assertEqual(self._box.get_string(key), self._template % "0")
+
+    def test_add_nonascii_StringIO_raises(self):
+        with self.assertWarns(DeprecationWarning):
+            with self.assertRaisesRegex(ValueError, "ASCII-only"):
+                self._box.add(io.StringIO(self._nonascii_msg))
+        self.assertEqual(len(self._box), 0)
+        self._box.close()
+        self.assertMailboxEmpty()
+
+    def test_remove(self):
+        # Remove messages using remove()
+        self._test_remove_or_delitem(self._box.remove)
+
+    def test_delitem(self):
+        # Remove messages using __delitem__()
+        self._test_remove_or_delitem(self._box.__delitem__)
+
+    def _test_remove_or_delitem(self, method):
+        # (Used by test_remove() and test_delitem().)
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(len(self._box), 2)
+        method(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+        self.assertRaises(KeyError, lambda: method(key0))
+        self.assertEqual(self._box.get_string(key1), self._template % 1)
+        key2 = self._box.add(self._template % 2)
+        self.assertEqual(len(self._box), 2)
+        method(key2)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key2])
+        self.assertRaises(KeyError, lambda: method(key2))
+        self.assertEqual(self._box.get_string(key1), self._template % 1)
+        method(key1)
+        self.assertEqual(len(self._box), 0)
+        self.assertRaises(KeyError, lambda: self._box[key1])
+        self.assertRaises(KeyError, lambda: method(key1))
+
+    def test_discard(self, repetitions=10):
+        # Discard messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(len(self._box), 2)
+        self._box.discard(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+        self._box.discard(key0)
+        self.assertEqual(len(self._box), 1)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+
+    def test_get(self):
+        # Retrieve messages using get()
+        key0 = self._box.add(self._template % 0)
+        msg = self._box.get(key0)
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '0\n')
+        self.assertIsNone(self._box.get('foo'))
+        self.assertIs(self._box.get('foo', False), False)
+        self._box.close()
+        self._box = self._factory(self._path)
+        key1 = self._box.add(self._template % 1)
+        msg = self._box.get(key1)
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '1\n')
+
+    def test_getitem(self):
+        # Retrieve message using __getitem__()
+        key0 = self._box.add(self._template % 0)
+        msg = self._box[key0]
+        self.assertEqual(msg['from'], 'foo')
+        self.assertEqual(msg.get_payload(), '0\n')
+        self.assertRaises(KeyError, lambda: self._box['foo'])
+        self._box.discard(key0)
+        self.assertRaises(KeyError, lambda: self._box[key0])
+
+    def test_get_message(self):
+        # Get Message representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        msg0 = self._box.get_message(key0)
+        self.assertIsInstance(msg0, mailbox.Message)
+        self.assertEqual(msg0['from'], 'foo')
+        self.assertEqual(msg0.get_payload(), '0\n')
+        self._check_sample(self._box.get_message(key1))
+
+    def test_get_bytes(self):
+        # Get bytes representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        self.assertEqual(self._box.get_bytes(key0),
+            (self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1), _bytes_sample_message)
+
+    def test_get_string(self):
+        # Get string representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        self.assertEqual(self._box.get_string(key0), self._template % 0)
+        self.assertEqual(self._box.get_string(key1).split('\n'),
+                         _sample_message.split('\n'))
+
+    def test_get_file(self):
+        # Get file representations of messages
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(_sample_message)
+        with self._box.get_file(key0) as file:
+            data0 = file.read()
+        with self._box.get_file(key1) as file:
+            data1 = file.read()
+        self.assertEqual(data0.decode('ascii').replace(os.linesep, '\n'),
+                         self._template % 0)
+        self.assertEqual(data1.decode('ascii').replace(os.linesep, '\n'),
+                         _sample_message)
+
+    def test_get_file_can_be_closed_twice(self):
+        # Issue 11700
+        key = self._box.add(_sample_message)
+        f = self._box.get_file(key)
+        f.close()
+        f.close()
+
+    def test_iterkeys(self):
+        # Get keys using iterkeys()
+        self._check_iteration(self._box.iterkeys, do_keys=True, do_values=False)
+
+    def test_keys(self):
+        # Get keys using keys()
+        self._check_iteration(self._box.keys, do_keys=True, do_values=False)
+
+    def test_itervalues(self):
+        # Get values using itervalues()
+        self._check_iteration(self._box.itervalues, do_keys=False,
+                              do_values=True)
+
+    def test_iter(self):
+        # Get values using __iter__()
+        self._check_iteration(self._box.__iter__, do_keys=False,
+                              do_values=True)
+
+    def test_values(self):
+        # Get values using values()
+        self._check_iteration(self._box.values, do_keys=False, do_values=True)
+
+    def test_iteritems(self):
+        # Get keys and values using iteritems()
+        self._check_iteration(self._box.iteritems, do_keys=True,
+                              do_values=True)
+
+    def test_items(self):
+        # Get keys and values using items()
+        self._check_iteration(self._box.items, do_keys=True, do_values=True)
+
+    def _check_iteration(self, method, do_keys, do_values, repetitions=10):
+        for value in method():
+            self.fail("Not empty")
+        keys, values = [], []
+        for i in range(repetitions):
+            keys.append(self._box.add(self._template % i))
+            values.append(self._template % i)
+        if do_keys and not do_values:
+            returned_keys = list(method())
+        elif do_values and not do_keys:
+            returned_values = list(method())
+        else:
+            returned_keys, returned_values = [], []
+            for key, value in method():
+                returned_keys.append(key)
+                returned_values.append(value)
+        if do_keys:
+            self.assertEqual(len(keys), len(returned_keys))
+            self.assertEqual(set(keys), set(returned_keys))
+        if do_values:
+            count = 0
+            for value in returned_values:
+                self.assertEqual(value['from'], 'foo')
+                self.assertLess(int(value.get_payload()), repetitions)
+                count += 1
+            self.assertEqual(len(values), count)
+
+    def test_contains(self):
+        # Check existence of keys using __contains__()
+        self.assertNotIn('foo', self._box)
+        key0 = self._box.add(self._template % 0)
+        self.assertIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+        key1 = self._box.add(self._template % 1)
+        self.assertIn(key1, self._box)
+        self.assertIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+        self._box.remove(key0)
+        self.assertNotIn(key0, self._box)
+        self.assertIn(key1, self._box)
+        self.assertNotIn('foo', self._box)
+        self._box.remove(key1)
+        self.assertNotIn(key1, self._box)
+        self.assertNotIn(key0, self._box)
+        self.assertNotIn('foo', self._box)
+
+    def test_len(self, repetitions=10):
+        # Get message count
+        keys = []
+        for i in range(repetitions):
+            self.assertEqual(len(self._box), i)
+            keys.append(self._box.add(self._template % i))
+            self.assertEqual(len(self._box), i + 1)
+        for i in range(repetitions):
+            self.assertEqual(len(self._box), repetitions - i)
+            self._box.remove(keys[i])
+            self.assertEqual(len(self._box), repetitions - i - 1)
+
+    def test_set_item(self):
+        # Modify messages using __setitem__()
+        key0 = self._box.add(self._template % 'original 0')
+        self.assertEqual(self._box.get_string(key0),
+                         self._template % 'original 0')
+        key1 = self._box.add(self._template % 'original 1')
+        self.assertEqual(self._box.get_string(key1),
+                         self._template % 'original 1')
+        self._box[key0] = self._template % 'changed 0'
+        self.assertEqual(self._box.get_string(key0),
+                         self._template % 'changed 0')
+        self._box[key1] = self._template % 'changed 1'
+        self.assertEqual(self._box.get_string(key1),
+                         self._template % 'changed 1')
+        self._box[key0] = _sample_message
+        self._check_sample(self._box[key0])
+        self._box[key1] = self._box[key0]
+        self._check_sample(self._box[key1])
+        self._box[key0] = self._template % 'original 0'
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'original 0')
+        self._check_sample(self._box[key1])
+        self.assertRaises(KeyError,
+                          lambda: self._box.__setitem__('foo', 'bar'))
+        self.assertRaises(KeyError, lambda: self._box['foo'])
+        self.assertEqual(len(self._box), 2)
+
+    def test_clear(self, iterations=10):
+        # Remove all messages using clear()
+        keys = []
+        for i in range(iterations):
+            self._box.add(self._template % i)
+        for i, key in enumerate(keys):
+            self.assertEqual(self._box.get_string(key), self._template % i)
+        self._box.clear()
+        self.assertEqual(len(self._box), 0)
+        for i, key in enumerate(keys):
+            self.assertRaises(KeyError, lambda: self._box.get_string(key))
+
+    def test_pop(self):
+        # Get and remove a message using pop()
+        key0 = self._box.add(self._template % 0)
+        self.assertIn(key0, self._box)
+        key1 = self._box.add(self._template % 1)
+        self.assertIn(key1, self._box)
+        self.assertEqual(self._box.pop(key0).get_payload(), '0\n')
+        self.assertNotIn(key0, self._box)
+        self.assertIn(key1, self._box)
+        key2 = self._box.add(self._template % 2)
+        self.assertIn(key2, self._box)
+        self.assertEqual(self._box.pop(key2).get_payload(), '2\n')
+        self.assertNotIn(key2, self._box)
+        self.assertIn(key1, self._box)
+        self.assertEqual(self._box.pop(key1).get_payload(), '1\n')
+        self.assertNotIn(key1, self._box)
+        self.assertEqual(len(self._box), 0)
+
+    def test_popitem(self, iterations=10):
+        # Get and remove an arbitrary (key, message) using popitem()
+        keys = []
+        for i in range(10):
+            keys.append(self._box.add(self._template % i))
+        seen = []
+        for i in range(10):
+            key, msg = self._box.popitem()
+            self.assertIn(key, keys)
+            self.assertNotIn(key, seen)
+            seen.append(key)
+            self.assertEqual(int(msg.get_payload()), keys.index(key))
+        self.assertEqual(len(self._box), 0)
+        for key in keys:
+            self.assertRaises(KeyError, lambda: self._box[key])
+
+    def test_update(self):
+        # Modify multiple messages using update()
+        key0 = self._box.add(self._template % 'original 0')
+        key1 = self._box.add(self._template % 'original 1')
+        key2 = self._box.add(self._template % 'original 2')
+        self._box.update({key0: self._template % 'changed 0',
+                          key2: _sample_message})
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'changed 0')
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % 'original 1')
+        self._check_sample(self._box[key2])
+        self._box.update([(key2, self._template % 'changed 2'),
+                    (key1, self._template % 'changed 1'),
+                    (key0, self._template % 'original 0')])
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % 'original 0')
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % 'changed 1')
+        self.assertEqual(self._box.get_string(key2),
+                     self._template % 'changed 2')
+        self.assertRaises(KeyError,
+                          lambda: self._box.update({'foo': 'bar',
+                                          key0: self._template % "changed 0"}))
+        self.assertEqual(len(self._box), 3)
+        self.assertEqual(self._box.get_string(key0),
+                     self._template % "changed 0")
+        self.assertEqual(self._box.get_string(key1),
+                     self._template % "changed 1")
+        self.assertEqual(self._box.get_string(key2),
+                     self._template % "changed 2")
+
+    def test_flush(self):
+        # Write changes to disk
+        self._test_flush_or_close(self._box.flush, True)
+
+    def test_popitem_and_flush_twice(self):
+        # See #15036.
+        self._box.add(self._template % 0)
+        self._box.add(self._template % 1)
+        self._box.flush()
+
+        self._box.popitem()
+        self._box.flush()
+        self._box.popitem()
+        self._box.flush()
+
+    def test_lock_unlock(self):
+        # Lock and unlock the mailbox
+        self.assertFalse(os.path.exists(self._get_lock_path()))
+        self._box.lock()
+        self.assertTrue(os.path.exists(self._get_lock_path()))
+        self._box.unlock()
+        self.assertFalse(os.path.exists(self._get_lock_path()))
+
+    def test_close(self):
+        # Close mailbox and flush changes to disk
+        self._test_flush_or_close(self._box.close, False)
+
+    def _test_flush_or_close(self, method, should_call_close):
+        contents = [self._template % i for i in range(3)]
+        self._box.add(contents[0])
+        self._box.add(contents[1])
+        self._box.add(contents[2])
+        oldbox = self._box
+        method()
+        if should_call_close:
+            self._box.close()
+        self._box = self._factory(self._path)
+        keys = self._box.keys()
+        self.assertEqual(len(keys), 3)
+        for key in keys:
+            self.assertIn(self._box.get_string(key), contents)
+        oldbox.close()
+
+    def test_dump_message(self):
+        # Write message representations to disk
+        for input in (email.message_from_string(_sample_message),
+                      _sample_message, io.BytesIO(_bytes_sample_message)):
+            output = io.BytesIO()
+            self._box._dump_message(input, output)
+            self.assertEqual(output.getvalue(),
+                _bytes_sample_message.replace(b'\n', os.linesep.encode()))
+        output = io.BytesIO()
+        self.assertRaises(TypeError,
+                          lambda: self._box._dump_message(None, output))
+
+    def _get_lock_path(self):
+        # Return the path of the dot lock file. May be overridden.
+        return self._path + '.lock'
+
+
+class TestMailboxSuperclass(TestBase, unittest.TestCase):
+
+    def test_notimplemented(self):
+        # Test that all Mailbox methods raise NotImplementedException.
+        box = mailbox.Mailbox('path')
+        self.assertRaises(NotImplementedError, lambda: box.add(''))
+        self.assertRaises(NotImplementedError, lambda: box.remove(''))
+        self.assertRaises(NotImplementedError, lambda: box.__delitem__(''))
+        self.assertRaises(NotImplementedError, lambda: box.discard(''))
+        self.assertRaises(NotImplementedError, lambda: box.__setitem__('', ''))
+        self.assertRaises(NotImplementedError, lambda: box.iterkeys())
+        self.assertRaises(NotImplementedError, lambda: box.keys())
+        self.assertRaises(NotImplementedError, lambda: box.itervalues().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.__iter__().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.values())
+        self.assertRaises(NotImplementedError, lambda: box.iteritems().__next__())
+        self.assertRaises(NotImplementedError, lambda: box.items())
+        self.assertRaises(NotImplementedError, lambda: box.get(''))
+        self.assertRaises(NotImplementedError, lambda: box.__getitem__(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_message(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_string(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_bytes(''))
+        self.assertRaises(NotImplementedError, lambda: box.get_file(''))
+        self.assertRaises(NotImplementedError, lambda: '' in box)
+        self.assertRaises(NotImplementedError, lambda: box.__contains__(''))
+        self.assertRaises(NotImplementedError, lambda: box.__len__())
+        self.assertRaises(NotImplementedError, lambda: box.clear())
+        self.assertRaises(NotImplementedError, lambda: box.pop(''))
+        self.assertRaises(NotImplementedError, lambda: box.popitem())
+        self.assertRaises(NotImplementedError, lambda: box.update((('', ''),)))
+        self.assertRaises(NotImplementedError, lambda: box.flush())
+        self.assertRaises(NotImplementedError, lambda: box.lock())
+        self.assertRaises(NotImplementedError, lambda: box.unlock())
+        self.assertRaises(NotImplementedError, lambda: box.close())
+
+
+class TestMaildir(TestMailbox, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.Maildir(path, factory)
+
+    def setUp(self):
+        TestMailbox.setUp(self)
+        if (os.name == 'nt') or (sys.platform == 'cygwin'):
+            self._box.colon = '!'
+
+    def assertMailboxEmpty(self):
+        self.assertEqual(os.listdir(os.path.join(self._path, 'tmp')), [])
+
+    def test_add_MM(self):
+        # Add a MaildirMessage instance
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_info('foo')
+        key = self._box.add(msg)
+        self.assertTrue(os.path.exists(os.path.join(self._path, 'cur', '%s%sfoo' %
+                                                 (key, self._box.colon))))
+
+    def test_get_MM(self):
+        # Get a MaildirMessage instance
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_flags('RF')
+        key = self._box.add(msg)
+        msg_returned = self._box.get_message(key)
+        self.assertIsInstance(msg_returned, mailbox.MaildirMessage)
+        self.assertEqual(msg_returned.get_subdir(), 'cur')
+        self.assertEqual(msg_returned.get_flags(), 'FR')
+
+    def test_set_MM(self):
+        # Set with a MaildirMessage instance
+        msg0 = mailbox.MaildirMessage(self._template % 0)
+        msg0.set_flags('TP')
+        key = self._box.add(msg0)
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), 'PT')
+        msg1 = mailbox.MaildirMessage(self._template % 1)
+        self._box[key] = msg1
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), '')
+        self.assertEqual(msg_returned.get_payload(), '1\n')
+        msg2 = mailbox.MaildirMessage(self._template % 2)
+        msg2.set_info('2,S')
+        self._box[key] = msg2
+        self._box[key] = self._template % 3
+        msg_returned = self._box.get_message(key)
+        self.assertEqual(msg_returned.get_subdir(), 'new')
+        self.assertEqual(msg_returned.get_flags(), 'S')
+        self.assertEqual(msg_returned.get_payload(), '3\n')
+
+    def test_consistent_factory(self):
+        # Add a message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        msg.set_subdir('cur')
+        msg.set_flags('RF')
+        key = self._box.add(msg)
+
+        # Create new mailbox with
+        class FakeMessage(mailbox.MaildirMessage):
+            pass
+        box = mailbox.Maildir(self._path, factory=FakeMessage)
+        box.colon = self._box.colon
+        msg2 = box.get_message(key)
+        self.assertIsInstance(msg2, FakeMessage)
+
+    def test_initialize_new(self):
+        # Initialize a non-existent mailbox
+        self.tearDown()
+        self._box = mailbox.Maildir(self._path)
+        self._check_basics()
+        self._delete_recursively(self._path)
+        self._box = self._factory(self._path, factory=None)
+        self._check_basics()
+
+    def test_initialize_existing(self):
+        # Initialize an existing mailbox
+        self.tearDown()
+        for subdir in '', 'tmp', 'new', 'cur':
+            os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
+        self._box = mailbox.Maildir(self._path)
+        self._check_basics()
+
+    def test_filename_leading_dot(self):
+        self.tearDown()
+        for subdir in '', 'tmp', 'new', 'cur':
+            os.mkdir(os.path.normpath(os.path.join(self._path, subdir)))
+        for subdir in 'tmp', 'new', 'cur':
+            fname = os.path.join(self._path, subdir, '.foo' + subdir)
+            with open(fname, 'wb') as f:
+                f.write(b"@")
+        self._box = mailbox.Maildir(self._path)
+        self.assertNotIn('.footmp', self._box)
+        self.assertNotIn('.foonew', self._box)
+        self.assertNotIn('.foocur', self._box)
+        self.assertEqual(list(self._box.iterkeys()), [])
+
+    def _check_basics(self, factory=None):
+        # (Used by test_open_new() and test_open_existing().)
+        self.assertEqual(self._box._path, os.path.abspath(self._path))
+        self.assertEqual(self._box._factory, factory)
+        for subdir in '', 'tmp', 'new', 'cur':
+            path = os.path.join(self._path, subdir)
+            self.assertTrue(os.path.isdir(path), f"Not a directory: {path!r}")
+
+    def test_list_folders(self):
+        # List folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 3)
+        self.assertEqual(set(self._box.list_folders()),
+                     set(('one', 'two', 'three')))
+
+    def test_get_folder(self):
+        # Open folders
+        self._box.add_folder('foo.bar')
+        folder0 = self._box.get_folder('foo.bar')
+        folder0.add(self._template % 'bar')
+        self.assertTrue(os.path.isdir(os.path.join(self._path, '.foo.bar')))
+        folder1 = self._box.get_folder('foo.bar')
+        self.assertEqual(folder1.get_string(folder1.keys()[0]),
+                         self._template % 'bar')
+
+    def test_add_and_remove_folders(self):
+        # Delete folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
+        self._box.remove_folder('one')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
+        self._box.remove_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.remove_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 0)
+        self.assertEqual(self._box.list_folders(), [])
+
+    def test_clean(self):
+        # Remove old files from 'tmp'
+        foo_path = os.path.join(self._path, 'tmp', 'foo')
+        bar_path = os.path.join(self._path, 'tmp', 'bar')
+        with open(foo_path, 'w', encoding='utf-8') as f:
+            f.write("@")
+        with open(bar_path, 'w', encoding='utf-8') as f:
+            f.write("@")
+        self._box.clean()
+        self.assertTrue(os.path.exists(foo_path))
+        self.assertTrue(os.path.exists(bar_path))
+        foo_stat = os.stat(foo_path)
+        os.utime(foo_path, (time.time() - 129600 - 2,
+                            foo_stat.st_mtime))
+        self._box.clean()
+        self.assertFalse(os.path.exists(foo_path))
+        self.assertTrue(os.path.exists(bar_path))
+
+    def test_create_tmp(self, repetitions=10):
+        # Create files in tmp directory
+        hostname = socket.gethostname()
+        if '/' in hostname:
+            hostname = hostname.replace('/', r'\057')
+        if ':' in hostname:
+            hostname = hostname.replace(':', r'\072')
+        pid = os.getpid()
+        pattern = re.compile(r"(?P<time>\d+)\.M(?P<M>\d{1,6})P(?P<P>\d+)"
+                             r"Q(?P<Q>\d+)\.(?P<host>[^:/]*)")
+        previous_groups = None
+        for x in range(repetitions):
+            tmp_file = self._box._create_tmp()
+            head, tail = os.path.split(tmp_file.name)
+            self.assertEqual(head, os.path.abspath(os.path.join(self._path,
+                                                                "tmp")),
+                             "File in wrong location: '%s'" % head)
+            match = pattern.match(tail)
+            self.assertIsNotNone(match, "Invalid file name: '%s'" % tail)
+            groups = match.groups()
+            if previous_groups is not None:
+                self.assertGreaterEqual(int(groups[0]), int(previous_groups[0]),
+                             "Non-monotonic seconds: '%s' before '%s'" %
+                             (previous_groups[0], groups[0]))
+                if int(groups[0]) == int(previous_groups[0]):
+                    self.assertGreaterEqual(int(groups[1]), int(previous_groups[1]),
+                                "Non-monotonic milliseconds: '%s' before '%s'" %
+                                (previous_groups[1], groups[1]))
+                self.assertEqual(int(groups[2]), pid,
+                             "Process ID mismatch: '%s' should be '%s'" %
+                             (groups[2], pid))
+                self.assertEqual(int(groups[3]), int(previous_groups[3]) + 1,
+                             "Non-sequential counter: '%s' before '%s'" %
+                             (previous_groups[3], groups[3]))
+                self.assertEqual(groups[4], hostname,
+                             "Host name mismatch: '%s' should be '%s'" %
+                             (groups[4], hostname))
+            previous_groups = groups
+            tmp_file.write(_bytes_sample_message)
+            tmp_file.seek(0)
+            self.assertEqual(tmp_file.read(), _bytes_sample_message)
+            tmp_file.close()
+        file_count = len(os.listdir(os.path.join(self._path, "tmp")))
+        self.assertEqual(file_count, repetitions,
+                     "Wrong file count: '%s' should be '%s'" %
+                     (file_count, repetitions))
+
+    def test_refresh(self):
+        # Update the table of contents
+        self.assertEqual(self._box._toc, {})
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+        self.assertEqual(self._box._toc, {})
+        self._box._refresh()
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1)})
+        key2 = self._box.add(self._template % 2)
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1)})
+        self._box._refresh()
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0),
+                                          key1: os.path.join('new', key1),
+                                          key2: os.path.join('new', key2)})
+
+    def test_refresh_after_safety_period(self):
+        # Issue #13254: Call _refresh after the "file system safety
+        # period" of 2 seconds has passed; _toc should still be
+        # updated because this is the first call to _refresh.
+        key0 = self._box.add(self._template % 0)
+        key1 = self._box.add(self._template % 1)
+
+        self._box = self._factory(self._path)
+        self.assertEqual(self._box._toc, {})
+
+        # Emulate sleeping. Instead of sleeping for 2 seconds, use the
+        # skew factor to make _refresh think that the filesystem
+        # safety period has passed and re-reading the _toc is only
+        # required if mtimes differ.
+        self._box._skewfactor = -3
+
+        self._box._refresh()
+        self.assertEqual(sorted(self._box._toc.keys()), sorted([key0, key1]))
+
+    def test_lookup(self):
+        # Look up message subpaths in the TOC
+        self.assertRaises(KeyError, lambda: self._box._lookup('foo'))
+        key0 = self._box.add(self._template % 0)
+        self.assertEqual(self._box._lookup(key0), os.path.join('new', key0))
+        os.remove(os.path.join(self._path, 'new', key0))
+        self.assertEqual(self._box._toc, {key0: os.path.join('new', key0)})
+        # Be sure that the TOC is read back from disk (see issue #6896
+        # about bad mtime behaviour on some systems).
+        self._box.flush()
+        self.assertRaises(KeyError, lambda: self._box._lookup(key0))
+        self.assertEqual(self._box._toc, {})
+
+    def test_lock_unlock(self):
+        # Lock and unlock the mailbox. For Maildir, this does nothing.
+        self._box.lock()
+        self._box.unlock()
+
+    def test_get_info(self):
+        # Test getting message info from Maildir, not the message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_info(key), '')
+        msg.set_info('OurTestInfo')
+        self._box[key] = msg
+        self.assertEqual(self._box.get_info(key), 'OurTestInfo')
+
+    def test_set_info(self):
+        # Test setting message info from Maildir, not the message.
+        # This should immediately rename the message file.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        def check_info(oldinfo, newinfo):
+            oldfilename = os.path.join(self._box._path, self._box._lookup(key))
+            newsubpath = self._box._lookup(key).split(self._box.colon)[0]
+            if newinfo:
+                newsubpath += self._box.colon + newinfo
+            newfilename = os.path.join(self._box._path, newsubpath)
+            # assert initial conditions
+            self.assertEqual(self._box.get_info(key), oldinfo)
+            if not oldinfo:
+                self.assertNotIn(self._box._lookup(key), self._box.colon)
+            self.assertTrue(os.path.exists(oldfilename))
+            if oldinfo != newinfo:
+                self.assertFalse(os.path.exists(newfilename))
+            # do the rename
+            self._box.set_info(key, newinfo)
+            # assert post conditions
+            if not newinfo:
+                self.assertNotIn(self._box._lookup(key), self._box.colon)
+            if oldinfo != newinfo:
+                self.assertFalse(os.path.exists(oldfilename))
+            self.assertTrue(os.path.exists(newfilename))
+            self.assertEqual(self._box.get_info(key), newinfo)
+        # none -> has info
+        check_info('', 'info1')
+        # has info -> same info
+        check_info('info1', 'info1')
+        # has info -> different info
+        check_info('info1', 'info2')
+        # has info -> none
+        check_info('info2', '')
+        # none -> none
+        check_info('', '')
+
+    def test_get_flags(self):
+        # Test getting message flags from Maildir, not the message.
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        msg.set_flags('T')
+        self._box[key] = msg
+        self.assertEqual(self._box.get_flags(key), 'T')
+
+    def test_set_flags(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        self._box.set_flags(key, 'S')
+        self.assertEqual(self._box.get_flags(key), 'S')
+
+    def test_add_flag(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self.assertEqual(self._box.get_flags(key), '')
+        self._box.add_flag(key, 'B')
+        self.assertEqual(self._box.get_flags(key), 'B')
+        self._box.add_flag(key, 'B')
+        self.assertEqual(self._box.get_flags(key), 'B')
+        self._box.add_flag(key, 'AC')
+        self.assertEqual(self._box.get_flags(key), 'ABC')
+
+    def test_remove_flag(self):
+        msg = mailbox.MaildirMessage(self._template % 0)
+        key = self._box.add(msg)
+        self._box.set_flags(key, 'abc')
+        self.assertEqual(self._box.get_flags(key), 'abc')
+        self._box.remove_flag(key, 'b')
+        self.assertEqual(self._box.get_flags(key), 'ac')
+        self._box.remove_flag(key, 'b')
+        self.assertEqual(self._box.get_flags(key), 'ac')
+        self._box.remove_flag(key, 'ac')
+        self.assertEqual(self._box.get_flags(key), '')
+
+    def test_folder (self):
+        # Test for bug #1569790: verify that folders returned by .get_folder()
+        # use the same factory function.
+        def dummy_factory (s):
+            return None
+        box = self._factory(self._path, factory=dummy_factory)
+        folder = box.add_folder('folder1')
+        self.assertIs(folder._factory, dummy_factory)
+
+        folder1_alias = box.get_folder('folder1')
+        self.assertIs(folder1_alias._factory, dummy_factory)
+
+    def test_directory_in_folder (self):
+        # Test that mailboxes still work if there's a stray extra directory
+        # in a folder.
+        for i in range(10):
+            self._box.add(mailbox.Message(_sample_message))
+
+        # Create a stray directory
+        os.mkdir(os.path.join(self._path, 'cur', 'stray-dir'))
+
+        # Check that looping still works with the directory present.
+        for msg in self._box:
+            pass
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_file_permissions(self):
+        # Verify that message files are created without execute permissions
+        msg = mailbox.MaildirMessage(self._template % 0)
+        orig_umask = os.umask(0)
+        try:
+            key = self._box.add(msg)
+        finally:
+            os.umask(orig_umask)
+        path = os.path.join(self._path, self._box._lookup(key))
+        mode = os.stat(path).st_mode
+        self.assertFalse(mode & 0o111)
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_folder_file_perms(self):
+        # From bug #3228, we want to verify that the file created inside a Maildir
+        # subfolder isn't marked as executable.
+        orig_umask = os.umask(0)
+        try:
+            subfolder = self._box.add_folder('subfolder')
+        finally:
+            os.umask(orig_umask)
+
+        path = os.path.join(subfolder._path, 'maildirfolder')
+        st = os.stat(path)
+        perms = st.st_mode
+        self.assertFalse((perms & 0o111)) # Execute bits should all be off.
+
+    def test_reread(self):
+        # Do an initial unconditional refresh
+        self._box._refresh()
+
+        # Put the last modified times more than two seconds into the past
+        # (because mtime may have a two second granularity)
+        for subdir in ('cur', 'new'):
+            os.utime(os.path.join(self._box._path, subdir),
+                     (time.time()-5,)*2)
+
+        # Because mtime has a two second granularity in worst case (FAT), a
+        # refresh is done unconditionally if called for within
+        # two-second-plus-a-bit of the last one, just in case the mbox has
+        # changed; so now we have to wait for that interval to expire.
+        #
+        # Because this is a test, emulate sleeping. Instead of
+        # sleeping for 2 seconds, use the skew factor to make _refresh
+        # think that 2 seconds have passed and re-reading the _toc is
+        # only required if mtimes differ.
+        self._box._skewfactor = -3
+
+        # Re-reading causes the ._toc attribute to be assigned a new dictionary
+        # object, so we'll check that the ._toc attribute isn't a different
+        # object.
+        orig_toc = self._box._toc
+        def refreshed():
+            return self._box._toc is not orig_toc
+
+        self._box._refresh()
+        self.assertFalse(refreshed())
+
+        # Now, write something into cur and remove it.  This changes
+        # the mtime and should cause a re-read. Note that "sleep
+        # emulation" is still in effect, as skewfactor is -3.
+        filename = os.path.join(self._path, 'cur', 'stray-file')
+        os_helper.create_empty_file(filename)
+        os.unlink(filename)
+        self._box._refresh()
+        self.assertTrue(refreshed())
+
+
+class _TestSingleFile(TestMailbox):
+    '''Common tests for single-file mailboxes'''
+
+    def test_add_doesnt_rewrite(self):
+        # When only adding messages, flush() should not rewrite the
+        # mailbox file. See issue #9559.
+
+        # Inode number changes if the contents are written to another
+        # file which is then renamed over the original file. So we
+        # must check that the inode number doesn't change.
+        inode_before = os.stat(self._path).st_ino
+
+        self._box.add(self._template % 0)
+        self._box.flush()
+
+        inode_after = os.stat(self._path).st_ino
+        self.assertEqual(inode_before, inode_after)
+
+        # Make sure the message was really added
+        self._box.close()
+        self._box = self._factory(self._path)
+        self.assertEqual(len(self._box), 1)
+
+    def test_permissions_after_flush(self):
+        # See issue #5346
+
+        # Make the mailbox world writable. It's unlikely that the new
+        # mailbox file would have these permissions after flush(),
+        # because umask usually prevents it.
+        mode = os.stat(self._path).st_mode | 0o666
+        os.chmod(self._path, mode)
+
+        self._box.add(self._template % 0)
+        i = self._box.add(self._template % 1)
+        # Need to remove one message to make flush() create a new file
+        self._box.remove(i)
+        self._box.flush()
+
+        self.assertEqual(os.stat(self._path).st_mode, mode)
+
+    @unittest.skipUnless(hasattr(os, 'chown'), 'requires os.chown')
+    def test_ownership_after_flush(self):
+        # See issue gh-117467
+
+        pwd = import_helper.import_module('pwd')
+        grp = import_helper.import_module('grp')
+        st = os.stat(self._path)
+
+        for e in pwd.getpwall():
+            if e.pw_uid != st.st_uid:
+                other_uid = e.pw_uid
+                break
+        else:
+            self.skipTest("test needs more than one user")
+
+        for e in grp.getgrall():
+            if e.gr_gid != st.st_gid:
+                other_gid = e.gr_gid
+                break
+        else:
+            self.skipTest("test needs more than one group")
+
+        try:
+            os.chown(self._path, other_uid, other_gid)
+        except OSError:
+            self.skipTest('test needs root privilege')
+        # Change permissions as in test_permissions_after_flush.
+        mode = st.st_mode | 0o666
+        os.chmod(self._path, mode)
+
+        self._box.add(self._template % 0)
+        i = self._box.add(self._template % 1)
+        # Need to remove one message to make flush() create a new file
+        self._box.remove(i)
+        self._box.flush()
+
+        st = os.stat(self._path)
+        self.assertEqual(st.st_uid, other_uid)
+        self.assertEqual(st.st_gid, other_gid)
+        self.assertEqual(st.st_mode, mode)
+
+
+class _TestMboxMMDF(_TestSingleFile):
+
+    def tearDown(self):
+        super().tearDown()
+        self._box.close()
+        self._delete_recursively(self._path)
+        for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
+            os_helper.unlink(lock_remnant)
+
+    def assertMailboxEmpty(self):
+        with open(self._path, 'rb') as f:
+            self.assertEqual(f.readlines(), [])
+
+    def test_get_bytes_from(self):
+        # Get bytes representations of messages with _unixfrom.
+        unixfrom = 'From foo@bar blah\n'
+        key0 = self._box.add(unixfrom + self._template % 0)
+        key1 = self._box.add(unixfrom + _sample_message)
+        self.assertEqual(self._box.get_bytes(key0, from_=False),
+            (self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1, from_=False),
+            _bytes_sample_message)
+        self.assertEqual(self._box.get_bytes(key0, from_=True),
+            (unixfrom + self._template % 0).encode('ascii'))
+        self.assertEqual(self._box.get_bytes(key1, from_=True),
+            unixfrom.encode('ascii') + _bytes_sample_message)
+
+    def test_get_string_from(self):
+        # Get string representations of messages with _unixfrom.
+        unixfrom = 'From foo@bar blah\n'
+        key0 = self._box.add(unixfrom + self._template % 0)
+        key1 = self._box.add(unixfrom + _sample_message)
+        self.assertEqual(self._box.get_string(key0, from_=False),
+                         self._template % 0)
+        self.assertEqual(self._box.get_string(key1, from_=False).split('\n'),
+                         _sample_message.split('\n'))
+        self.assertEqual(self._box.get_string(key0, from_=True),
+                         unixfrom + self._template % 0)
+        self.assertEqual(self._box.get_string(key1, from_=True).split('\n'),
+                         (unixfrom + _sample_message).split('\n'))
+
+    def test_add_from_string(self):
+        # Add a string starting with 'From ' to the mailbox
+        key = self._box.add('From foo@bar blah\nFrom: foo\n\n0\n')
+        self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
+        self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
+        self.assertEqual(self._box[key].get_payload(), '0\n')
+
+    def test_add_from_bytes(self):
+        # Add a byte string starting with 'From ' to the mailbox
+        key = self._box.add(b'From foo@bar blah\nFrom: foo\n\n0\n')
+        self.assertEqual(self._box[key].get_from(), 'foo@bar blah')
+        self.assertEqual(self._box[key].get_unixfrom(), 'From foo@bar blah')
+        self.assertEqual(self._box[key].get_payload(), '0\n')
+
+    def test_add_mbox_or_mmdf_message(self):
+        # Add an mboxMessage or MMDFMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg = class_('From foo@bar blah\nFrom: foo\n\n0\n')
+            key = self._box.add(msg)
+
+    def test_open_close_open(self):
+        # Open and inspect previously-created mailbox
+        values = [self._template % i for i in range(3)]
+        for value in values:
+            self._box.add(value)
+        self._box.close()
+        mtime = os.path.getmtime(self._path)
+        self._box = self._factory(self._path)
+        self.assertEqual(len(self._box), 3)
+        for key in self._box.iterkeys():
+            self.assertIn(self._box.get_string(key), values)
+        self._box.close()
+        self.assertEqual(mtime, os.path.getmtime(self._path))
+
+    def test_add_and_close(self):
+        # Verifying that closing a mailbox doesn't change added items
+        self._box.add(_sample_message)
+        for i in range(3):
+            self._box.add(self._template % i)
+        self._box.add(_sample_message)
+        self._box._file.flush()
+        self._box._file.seek(0)
+        contents = self._box._file.read()
+        self._box.close()
+        with open(self._path, 'rb') as f:
+            self.assertEqual(contents, f.read())
+        self._box = self._factory(self._path)
+
+    @support.requires_fork()
+    @unittest.skipUnless(hasattr(socket, 'socketpair'), "Test needs socketpair().")
+    def test_lock_conflict(self):
+        # Fork off a child process that will lock the mailbox temporarily,
+        # unlock it and exit.
+        c, p = socket.socketpair()
+        self.addCleanup(c.close)
+        self.addCleanup(p.close)
+
+        pid = os.fork()
+        if pid == 0:
+            # child
+            try:
+                # lock the mailbox, and signal the parent it can proceed
+                self._box.lock()
+                c.send(b'c')
+
+                # wait until the parent is done, and unlock the mailbox
+                c.recv(1)
+                self._box.unlock()
+            finally:
+                os._exit(0)
+
+        # In the parent, wait until the child signals it locked the mailbox.
+        p.recv(1)
+        try:
+            self.assertRaises(mailbox.ExternalClashError,
+                              self._box.lock)
+        finally:
+            # Signal the child it can now release the lock and exit.
+            p.send(b'p')
+            # Wait for child to exit.  Locking should now succeed.
+            support.wait_process(pid, exitcode=0)
+
+        self._box.lock()
+        self._box.unlock()
+
+    def test_relock(self):
+        # Test case for bug #1575506: the mailbox class was locking the
+        # wrong file object in its flush() method.
+        msg = "Subject: sub\n\nbody\n"
+        key1 = self._box.add(msg)
+        self._box.flush()
+        self._box.close()
+
+        self._box = self._factory(self._path)
+        self._box.lock()
+        key2 = self._box.add(msg)
+        self._box.flush()
+        self.assertTrue(self._box._locked)
+        self._box.close()
+
+
+class TestMbox(_TestMboxMMDF, unittest.TestCase, ExtraAssertions):
+
+    _factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
+
+    @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
+    def test_file_perms(self):
+        # From bug #3228, we want to verify that the mailbox file isn't executable,
+        # even if the umask is set to something that would leave executable bits set.
+        # We only run this test on platforms that support umask.
+        try:
+            old_umask = os.umask(0o077)
+            self._box.close()
+            os.unlink(self._path)
+            self._box = mailbox.mbox(self._path, create=True)
+            self._box.add('')
+            self._box.close()
+        finally:
+            os.umask(old_umask)
+
+        st = os.stat(self._path)
+        perms = st.st_mode
+        self.assertFalse((perms & 0o111)) # Execute bits should all be off.
+
+    def test_terminating_newline(self):
+        message = email.message.Message()
+        message['From'] = 'john@example.com'
+        message.set_payload('No newline at the end')
+        i = self._box.add(message)
+
+        # A newline should have been appended to the payload
+        message = self._box.get(i)
+        self.assertEqual(message.get_payload(), 'No newline at the end\n')
+
+    def test_message_separator(self):
+        # Check there's always a single blank line after each message
+        self._box.add('From: foo\n\n0')  # No newline at the end
+        with open(self._path, encoding='utf-8') as f:
+            data = f.read()
+            self.assertEndsWith(data, '0\n\n')
+
+        self._box.add('From: foo\n\n0\n')  # Newline at the end
+        with open(self._path, encoding='utf-8') as f:
+            data = f.read()
+            self.assertEndsWith(data, '0\n\n')
+
+
+class TestMMDF(_TestMboxMMDF, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.MMDF(path, factory)
+
+
+class TestMH(TestMailbox, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.MH(path, factory)
+
+    def assertMailboxEmpty(self):
+        self.assertEqual(os.listdir(self._path), ['.mh_sequences'])
+
+    def test_list_folders(self):
+        # List folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 3)
+        self.assertEqual(set(self._box.list_folders()),
+                     set(('one', 'two', 'three')))
+
+    def test_get_folder(self):
+        # Open folders
+        def dummy_factory (s):
+            return None
+        self._box = self._factory(self._path, dummy_factory)
+
+        new_folder = self._box.add_folder('foo.bar')
+        folder0 = self._box.get_folder('foo.bar')
+        folder0.add(self._template % 'bar')
+        self.assertTrue(os.path.isdir(os.path.join(self._path, 'foo.bar')))
+        folder1 = self._box.get_folder('foo.bar')
+        self.assertEqual(folder1.get_string(folder1.keys()[0]),
+                         self._template % 'bar')
+
+        # Test for bug #1569790: verify that folders returned by .get_folder()
+        # use the same factory function.
+        self.assertIs(new_folder._factory, self._box._factory)
+        self.assertIs(folder0._factory, self._box._factory)
+
+    def test_add_and_remove_folders(self):
+        # Delete folders
+        self._box.add_folder('one')
+        self._box.add_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('one', 'two')))
+        self._box.remove_folder('one')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.add_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 2)
+        self.assertEqual(set(self._box.list_folders()), set(('two', 'three')))
+        self._box.remove_folder('three')
+        self.assertEqual(len(self._box.list_folders()), 1)
+        self.assertEqual(set(self._box.list_folders()), set(('two',)))
+        self._box.remove_folder('two')
+        self.assertEqual(len(self._box.list_folders()), 0)
+        self.assertEqual(self._box.list_folders(), [])
+
+    def test_sequences(self):
+        # Get and set sequences
+        self.assertEqual(self._box.get_sequences(), {})
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg0.add_sequence('foo')
+        key0 = self._box.add(msg0)
+        self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
+        msg1 = mailbox.MHMessage(self._template % 1)
+        msg1.set_sequences(['bar', 'replied', 'foo'])
+        key1 = self._box.add(msg1)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0, key1], 'bar':[key1], 'replied':[key1]})
+        msg0.set_sequences(['flagged'])
+        self._box[key0] = msg0
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key1], 'bar':[key1], 'replied':[key1],
+                      'flagged':[key0]})
+        self._box.remove(key1)
+        self.assertEqual(self._box.get_sequences(), {'flagged':[key0]})
+
+        self._box.set_sequences({'foo':[key0]})
+        self.assertEqual(self._box.get_sequences(), {'foo':[key0]})
+
+    def test_no_dot_mh_sequences_file(self):
+        path = os.path.join(self._path, 'foo.bar')
+        os.mkdir(path)
+        box = self._factory(path)
+        self.assertEqual(os.listdir(path), [])
+        self.assertEqual(box.get_sequences(), {})
+        self.assertEqual(os.listdir(path), [])
+        box.set_sequences({})
+        self.assertEqual(os.listdir(path), ['.mh_sequences'])
+
+    def test_lock_unlock_no_dot_mh_sequences_file(self):
+        path = os.path.join(self._path, 'foo.bar')
+        os.mkdir(path)
+        box = self._factory(path)
+        self.assertEqual(os.listdir(path), [])
+        box.lock()
+        box.unlock()
+        self.assertEqual(os.listdir(path), ['.mh_sequences'])
+
+    def test_issue2625(self):
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg0.add_sequence('foo')
+        key0 = self._box.add(msg0)
+        refmsg0 = self._box.get_message(key0)
+
+    def test_issue7627(self):
+        msg0 = mailbox.MHMessage(self._template % 0)
+        key0 = self._box.add(msg0)
+        self._box.lock()
+        self._box.remove(key0)
+        self._box.unlock()
+
+    def test_pack(self):
+        # Pack the contents of the mailbox
+        msg0 = mailbox.MHMessage(self._template % 0)
+        msg1 = mailbox.MHMessage(self._template % 1)
+        msg2 = mailbox.MHMessage(self._template % 2)
+        msg3 = mailbox.MHMessage(self._template % 3)
+        msg0.set_sequences(['foo', 'unseen'])
+        msg1.set_sequences(['foo'])
+        msg2.set_sequences(['foo', 'flagged'])
+        msg3.set_sequences(['foo', 'bar', 'replied'])
+        key0 = self._box.add(msg0)
+        key1 = self._box.add(msg1)
+        key2 = self._box.add(msg2)
+        key3 = self._box.add(msg3)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0,key1,key2,key3], 'unseen':[key0],
+                      'flagged':[key2], 'bar':[key3], 'replied':[key3]})
+        self._box.remove(key2)
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[key0,key1,key3], 'unseen':[key0], 'bar':[key3],
+                      'replied':[key3]})
+        self._box.pack()
+        self.assertEqual(self._box.keys(), [1, 2, 3])
+        key0 = key0
+        key1 = key0 + 1
+        key2 = key1 + 1
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[1, 2, 3], 'unseen':[1], 'bar':[3], 'replied':[3]})
+
+        # Test case for packing while holding the mailbox locked.
+        key0 = self._box.add(msg1)
+        key1 = self._box.add(msg1)
+        key2 = self._box.add(msg1)
+        key3 = self._box.add(msg1)
+
+        self._box.remove(key0)
+        self._box.remove(key2)
+        self._box.lock()
+        self._box.pack()
+        self._box.unlock()
+        self.assertEqual(self._box.get_sequences(),
+                     {'foo':[1, 2, 3, 4, 5],
+                      'unseen':[1], 'bar':[3], 'replied':[3]})
+
+    def _get_lock_path(self):
+        return os.path.join(self._path, '.mh_sequences.lock')
+
+
+class TestBabyl(_TestSingleFile, unittest.TestCase):
+
+    _factory = lambda self, path, factory=None: mailbox.Babyl(path, factory)
+
+    def assertMailboxEmpty(self):
+        with open(self._path, 'rb') as f:
+            self.assertEqual(f.readlines(), [])
+
+    def tearDown(self):
+        super().tearDown()
+        self._box.close()
+        self._delete_recursively(self._path)
+        for lock_remnant in glob.glob(glob.escape(self._path) + '.*'):
+            os_helper.unlink(lock_remnant)
+
+    def test_labels(self):
+        # Get labels from the mailbox
+        self.assertEqual(self._box.get_labels(), [])
+        msg0 = mailbox.BabylMessage(self._template % 0)
+        msg0.add_label('foo')
+        key0 = self._box.add(msg0)
+        self.assertEqual(self._box.get_labels(), ['foo'])
+        msg1 = mailbox.BabylMessage(self._template % 1)
+        msg1.set_labels(['bar', 'answered', 'foo'])
+        key1 = self._box.add(msg1)
+        self.assertEqual(set(self._box.get_labels()), set(['foo', 'bar']))
+        msg0.set_labels(['blah', 'filed'])
+        self._box[key0] = msg0
+        self.assertEqual(set(self._box.get_labels()),
+                     set(['foo', 'bar', 'blah']))
+        self._box.remove(key1)
+        self.assertEqual(set(self._box.get_labels()), set(['blah']))
+
+
+class FakeFileLikeObject:
+
+    def __init__(self):
+        self.closed = False
+
+    def close(self):
+        self.closed = True
+
+
+class FakeMailBox(mailbox.Mailbox):
+
+    def __init__(self):
+        mailbox.Mailbox.__init__(self, '', lambda file: None)
+        self.files = [FakeFileLikeObject() for i in range(10)]
+
+    def get_file(self, key):
+        return self.files[key]
+
+
+class TestFakeMailBox(unittest.TestCase):
+
+    def test_closing_fd(self):
+        box = FakeMailBox()
+        for i in range(10):
+            self.assertFalse(box.files[i].closed)
+        for i in range(10):
+            box[i]
+        for i in range(10):
+            self.assertTrue(box.files[i].closed)
+
+
+class TestMessage(TestBase, unittest.TestCase):
+
+    _factory = mailbox.Message      # Overridden by subclasses to reuse tests
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+
+    def tearDown(self):
+        self._delete_recursively(self._path)
+
+    def test_initialize_with_eMM(self):
+        # Initialize based on email.message.Message instance
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory(eMM)
+        self._post_initialize_hook(msg)
+        self._check_sample(msg)
+
+    def test_initialize_with_string(self):
+        # Initialize based on string
+        msg = self._factory(_sample_message)
+        self._post_initialize_hook(msg)
+        self._check_sample(msg)
+
+    def test_initialize_with_file(self):
+        # Initialize based on contents of file
+        with open(self._path, 'w+', encoding='utf-8') as f:
+            f.write(_sample_message)
+            f.seek(0)
+            msg = self._factory(f)
+            self._post_initialize_hook(msg)
+            self._check_sample(msg)
+
+    def test_initialize_with_binary_file(self):
+        # Initialize based on contents of binary file
+        with open(self._path, 'wb+') as f:
+            f.write(_bytes_sample_message)
+            f.seek(0)
+            msg = self._factory(f)
+            self._post_initialize_hook(msg)
+            self._check_sample(msg)
+
+    def test_initialize_with_nothing(self):
+        # Initialize without arguments
+        msg = self._factory()
+        self._post_initialize_hook(msg)
+        self.assertIsInstance(msg, email.message.Message)
+        self.assertIsInstance(msg, mailbox.Message)
+        self.assertIsInstance(msg, self._factory)
+        self.assertEqual(msg.keys(), [])
+        self.assertFalse(msg.is_multipart())
+        self.assertIsNone(msg.get_payload())
+
+    def test_initialize_incorrectly(self):
+        # Initialize with invalid argument
+        self.assertRaises(TypeError, lambda: self._factory(object()))
+
+    def test_all_eMM_attributes_exist(self):
+        # Issue 12537
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory(_sample_message)
+        for attr in eMM.__dict__:
+            self.assertIn(attr, msg.__dict__,
+                '{} attribute does not exist'.format(attr))
+
+    def test_become_message(self):
+        # Take on the state of another message
+        eMM = email.message_from_string(_sample_message)
+        msg = self._factory()
+        msg._become_message(eMM)
+        self._check_sample(msg)
+
+    def test_explain_to(self):
+        # Copy self's format-specific data to other message formats.
+        # This test is superficial; better ones are in TestMessageConversion.
+        msg = self._factory()
+        for class_ in self.all_mailbox_types:
+            other_msg = class_()
+            msg._explain_to(other_msg)
+        other_msg = email.message.Message()
+        self.assertRaises(TypeError, lambda: msg._explain_to(other_msg))
+
+    def _post_initialize_hook(self, msg):
+        # Overridden by subclasses to check extra things after initialization
+        pass
+
+
+class TestMaildirMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.MaildirMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._subdir, 'new')
+        self.assertEqual(msg._info, '')
+
+    def test_subdir(self):
+        # Use get_subdir() and set_subdir()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_subdir('cur')
+        self.assertEqual(msg.get_subdir(), 'cur')
+        msg.set_subdir('new')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self.assertRaises(ValueError, lambda: msg.set_subdir('tmp'))
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_subdir('new')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self._check_sample(msg)
+
+    def test_flags(self):
+        # Use get_flags(), set_flags(), add_flag(), remove_flag()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_subdir(), 'new')
+        msg.set_flags('F')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self.assertEqual(msg.get_flags(), 'F')
+        msg.set_flags('SDTP')
+        self.assertEqual(msg.get_flags(), 'DPST')
+        msg.add_flag('FT')
+        self.assertEqual(msg.get_flags(), 'DFPST')
+        msg.remove_flag('TDRP')
+        self.assertEqual(msg.get_flags(), 'FS')
+        self.assertEqual(msg.get_subdir(), 'new')
+        self._check_sample(msg)
+
+    def test_date(self):
+        # Use get_date() and set_date()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertLess(abs(msg.get_date() - time.time()), 60)
+        msg.set_date(0.0)
+        self.assertEqual(msg.get_date(), 0.0)
+
+    def test_info(self):
+        # Use get_info() and set_info()
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_info(), '')
+        msg.set_info('1,foo=bar')
+        self.assertEqual(msg.get_info(), '1,foo=bar')
+        self.assertRaises(TypeError, lambda: msg.set_info(None))
+        self._check_sample(msg)
+
+    def test_info_and_flags(self):
+        # Test interaction of info and flag methods
+        msg = mailbox.MaildirMessage(_sample_message)
+        self.assertEqual(msg.get_info(), '')
+        msg.set_flags('SF')
+        self.assertEqual(msg.get_flags(), 'FS')
+        self.assertEqual(msg.get_info(), '2,FS')
+        msg.set_info('1,')
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_info(), '1,')
+        msg.remove_flag('RPT')
+        self.assertEqual(msg.get_flags(), '')
+        self.assertEqual(msg.get_info(), '1,')
+        msg.add_flag('D')
+        self.assertEqual(msg.get_flags(), 'D')
+        self.assertEqual(msg.get_info(), '2,D')
+        self._check_sample(msg)
+
+
+class _TestMboxMMDFMessage:
+
+    _factory = mailbox._mboxMMDFMessage
+
+    def _post_initialize_hook(self, msg):
+        self._check_from(msg)
+
+    def test_initialize_with_unixfrom(self):
+        # Initialize with a message that already has a _unixfrom attribute
+        msg = mailbox.Message(_sample_message)
+        msg.set_unixfrom('From foo@bar blah')
+        msg = mailbox.mboxMessage(msg)
+        self.assertEqual(msg.get_from(), 'foo@bar blah')
+        self.assertEqual(msg.get_unixfrom(), 'From foo@bar blah')
+
+    def test_from(self):
+        # Get and set "From " line
+        msg = mailbox.mboxMessage(_sample_message)
+        self._check_from(msg)
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('foo bar')
+        self.assertEqual(msg.get_from(), 'foo bar')
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('foo@bar', True)
+        self._check_from(msg, 'foo@bar')
+        self.assertIsNone(msg.get_unixfrom())
+        msg.set_from('blah@temp', time.localtime())
+        self._check_from(msg, 'blah@temp')
+        self.assertIsNone(msg.get_unixfrom())
+
+    def test_flags(self):
+        # Use get_flags(), set_flags(), add_flag(), remove_flag()
+        msg = mailbox.mboxMessage(_sample_message)
+        self.assertEqual(msg.get_flags(), '')
+        msg.set_flags('F')
+        self.assertEqual(msg.get_flags(), 'F')
+        msg.set_flags('XODR')
+        self.assertEqual(msg.get_flags(), 'RODX')
+        msg.add_flag('FA')
+        self.assertEqual(msg.get_flags(), 'RODFAX')
+        msg.remove_flag('FDXA')
+        self.assertEqual(msg.get_flags(), 'RO')
+        self._check_sample(msg)
+
+    def _check_from(self, msg, sender=None):
+        # Check contents of "From " line
+        if sender is None:
+            sender = "MAILER-DAEMON"
+        self.assertIsNotNone(re.match(
+                sender + r" \w{3} \w{3} [\d ]\d [\d ]\d:\d{2}:\d{2} \d{4}",
+                msg.get_from()))
+
+
+class TestMboxMessage(_TestMboxMMDFMessage, TestMessage):
+
+    _factory = mailbox.mboxMessage
+
+
+class TestMHMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.MHMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._sequences, [])
+
+    def test_sequences(self):
+        # Get, set, join, and leave sequences
+        msg = mailbox.MHMessage(_sample_message)
+        self.assertEqual(msg.get_sequences(), [])
+        msg.set_sequences(['foobar'])
+        self.assertEqual(msg.get_sequences(), ['foobar'])
+        msg.set_sequences([])
+        self.assertEqual(msg.get_sequences(), [])
+        msg.add_sequence('unseen')
+        self.assertEqual(msg.get_sequences(), ['unseen'])
+        msg.add_sequence('flagged')
+        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
+        msg.add_sequence('flagged')
+        self.assertEqual(msg.get_sequences(), ['unseen', 'flagged'])
+        msg.remove_sequence('unseen')
+        self.assertEqual(msg.get_sequences(), ['flagged'])
+        msg.add_sequence('foobar')
+        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
+        msg.remove_sequence('replied')
+        self.assertEqual(msg.get_sequences(), ['flagged', 'foobar'])
+        msg.set_sequences(['foobar', 'replied'])
+        self.assertEqual(msg.get_sequences(), ['foobar', 'replied'])
+
+
+class TestBabylMessage(TestMessage, unittest.TestCase):
+
+    _factory = mailbox.BabylMessage
+
+    def _post_initialize_hook(self, msg):
+        self.assertEqual(msg._labels, [])
+
+    def test_labels(self):
+        # Get, set, join, and leave labels
+        msg = mailbox.BabylMessage(_sample_message)
+        self.assertEqual(msg.get_labels(), [])
+        msg.set_labels(['foobar'])
+        self.assertEqual(msg.get_labels(), ['foobar'])
+        msg.set_labels([])
+        self.assertEqual(msg.get_labels(), [])
+        msg.add_label('filed')
+        self.assertEqual(msg.get_labels(), ['filed'])
+        msg.add_label('resent')
+        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
+        msg.add_label('resent')
+        self.assertEqual(msg.get_labels(), ['filed', 'resent'])
+        msg.remove_label('filed')
+        self.assertEqual(msg.get_labels(), ['resent'])
+        msg.add_label('foobar')
+        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
+        msg.remove_label('unseen')
+        self.assertEqual(msg.get_labels(), ['resent', 'foobar'])
+        msg.set_labels(['foobar', 'answered'])
+        self.assertEqual(msg.get_labels(), ['foobar', 'answered'])
+
+    def test_visible(self):
+        # Get, set, and update visible headers
+        msg = mailbox.BabylMessage(_sample_message)
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), [])
+        self.assertIsNone(visible.get_payload())
+        visible['User-Agent'] = 'FooBar 1.0'
+        visible['X-Whatever'] = 'Blah'
+        self.assertEqual(msg.get_visible().keys(), [])
+        msg.set_visible(visible)
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
+        self.assertEqual(visible['User-Agent'], 'FooBar 1.0')
+        self.assertEqual(visible['X-Whatever'], 'Blah')
+        self.assertIsNone(visible.get_payload())
+        msg.update_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'X-Whatever'])
+        self.assertIsNone(visible.get_payload())
+        visible = msg.get_visible()
+        self.assertEqual(visible.keys(), ['User-Agent', 'Date', 'From', 'To',
+                                          'Subject'])
+        for header in ('User-Agent', 'Date', 'From', 'To', 'Subject'):
+            self.assertEqual(visible[header], msg[header])
+
+
+class TestMMDFMessage(_TestMboxMMDFMessage, TestMessage):
+
+    _factory = mailbox.MMDFMessage
+
+
+class TestMessageConversion(TestBase, unittest.TestCase):
+
+    def test_plain_to_x(self):
+        # Convert Message to all formats
+        for class_ in self.all_mailbox_types:
+            msg_plain = mailbox.Message(_sample_message)
+            msg = class_(msg_plain)
+            self._check_sample(msg)
+
+    def test_x_to_plain(self):
+        # Convert all formats to Message
+        for class_ in self.all_mailbox_types:
+            msg = class_(_sample_message)
+            msg_plain = mailbox.Message(msg)
+            self._check_sample(msg_plain)
+
+    def test_x_from_bytes(self):
+        # Convert all formats to Message
+        for class_ in self.all_mailbox_types:
+            msg = class_(_bytes_sample_message)
+            self._check_sample(msg)
+
+    def test_x_to_invalid(self):
+        # Convert all formats to an invalid format
+        for class_ in self.all_mailbox_types:
+            self.assertRaises(TypeError, lambda: class_(False))
+
+    def test_type_specific_attributes_removed_on_conversion(self):
+        reference = {class_: class_(_sample_message).__dict__
+                        for class_ in self.all_mailbox_types}
+        for class1 in self.all_mailbox_types:
+            for class2 in self.all_mailbox_types:
+                if class1 is class2:
+                    continue
+                source = class1(_sample_message)
+                target = class2(source)
+                type_specific = [a for a in reference[class1]
+                                   if a not in reference[class2]]
+                for attr in type_specific:
+                    self.assertNotIn(attr, target.__dict__,
+                        "while converting {} to {}".format(class1, class2))
+
+    def test_maildir_to_maildir(self):
+        # Convert MaildirMessage to MaildirMessage
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        msg_maildir.set_flags('DFPRST')
+        msg_maildir.set_subdir('cur')
+        date = msg_maildir.get_date()
+        msg = mailbox.MaildirMessage(msg_maildir)
+        self._check_sample(msg)
+        self.assertEqual(msg.get_flags(), 'DFPRST')
+        self.assertEqual(msg.get_subdir(), 'cur')
+        self.assertEqual(msg.get_date(), date)
+
+    def test_maildir_to_mboxmmdf(self):
+        # Convert MaildirMessage to mboxmessage and MMDFMessage
+        pairs = (('D', ''), ('F', 'F'), ('P', ''), ('R', 'A'), ('S', 'R'),
+                 ('T', 'D'), ('DFPRST', 'RDFA'))
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_maildir = mailbox.MaildirMessage(_sample_message)
+            msg_maildir.set_date(0.0)
+            for setting, result in pairs:
+                msg_maildir.set_flags(setting)
+                msg = class_(msg_maildir)
+                self.assertEqual(msg.get_flags(), result)
+                self.assertEqual(msg.get_from(), 'MAILER-DAEMON %s' %
+                             time.asctime(time.gmtime(0.0)))
+                self.assertIsNone(msg.get_unixfrom())
+            msg_maildir.set_subdir('cur')
+            self.assertEqual(class_(msg_maildir).get_flags(), 'RODFA')
+
+    def test_maildir_to_mh(self):
+        # Convert MaildirMessage to MHMessage
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        pairs = (('D', ['unseen']), ('F', ['unseen', 'flagged']),
+                 ('P', ['unseen']), ('R', ['unseen', 'replied']), ('S', []),
+                 ('T', ['unseen']), ('DFPRST', ['replied', 'flagged']))
+        for setting, result in pairs:
+            msg_maildir.set_flags(setting)
+            self.assertEqual(mailbox.MHMessage(msg_maildir).get_sequences(),
+                             result)
+
+    def test_maildir_to_babyl(self):
+        # Convert MaildirMessage to Babyl
+        msg_maildir = mailbox.MaildirMessage(_sample_message)
+        pairs = (('D', ['unseen']), ('F', ['unseen']),
+                 ('P', ['unseen', 'forwarded']), ('R', ['unseen', 'answered']),
+                 ('S', []), ('T', ['unseen', 'deleted']),
+                 ('DFPRST', ['deleted', 'answered', 'forwarded']))
+        for setting, result in pairs:
+            msg_maildir.set_flags(setting)
+            self.assertEqual(mailbox.BabylMessage(msg_maildir).get_labels(),
+                             result)
+
+    def test_mboxmmdf_to_maildir(self):
+        # Convert mboxMessage and MMDFMessage to MaildirMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            msg_mboxMMDF.set_from('foo@bar', time.gmtime(0.0))
+            pairs = (('R', 'S'), ('O', ''), ('D', 'T'), ('F', 'F'), ('A', 'R'),
+                     ('RODFA', 'FRST'))
+            for setting, result in pairs:
+                msg_mboxMMDF.set_flags(setting)
+                msg = mailbox.MaildirMessage(msg_mboxMMDF)
+                self.assertEqual(msg.get_flags(), result)
+                self.assertEqual(msg.get_date(), 0.0)
+            msg_mboxMMDF.set_flags('O')
+            self.assertEqual(mailbox.MaildirMessage(msg_mboxMMDF).get_subdir(),
+                             'cur')
+
+    def test_mboxmmdf_to_mboxmmdf(self):
+        # Convert mboxMessage and MMDFMessage to mboxMessage and MMDFMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            msg_mboxMMDF.set_flags('RODFA')
+            msg_mboxMMDF.set_from('foo@bar')
+            self.assertIsNone(msg_mboxMMDF.get_unixfrom())
+            for class2_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                msg2 = class2_(msg_mboxMMDF)
+                self.assertEqual(msg2.get_flags(), 'RODFA')
+                self.assertEqual(msg2.get_from(), 'foo@bar')
+                self.assertIsNone(msg2.get_unixfrom())
+
+    def test_mboxmmdf_to_mh(self):
+        # Convert mboxMessage and MMDFMessage to MHMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg_mboxMMDF = class_(_sample_message)
+            pairs = (('R', []), ('O', ['unseen']), ('D', ['unseen']),
+                     ('F', ['unseen', 'flagged']),
+                     ('A', ['unseen', 'replied']),
+                     ('RODFA', ['replied', 'flagged']))
+            for setting, result in pairs:
+                msg_mboxMMDF.set_flags(setting)
+                self.assertEqual(mailbox.MHMessage(msg_mboxMMDF).get_sequences(),
+                                 result)
+
+    def test_mboxmmdf_to_babyl(self):
+        # Convert mboxMessage and MMDFMessage to BabylMessage
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            msg = class_(_sample_message)
+            pairs = (('R', []), ('O', ['unseen']),
+                     ('D', ['unseen', 'deleted']), ('F', ['unseen']),
+                     ('A', ['unseen', 'answered']),
+                     ('RODFA', ['deleted', 'answered']))
+            for setting, result in pairs:
+                msg.set_flags(setting)
+                self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
+
+    def test_mh_to_maildir(self):
+        # Convert MHMessage to MaildirMessage
+        pairs = (('unseen', ''), ('replied', 'RS'), ('flagged', 'FS'))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'FR')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+
+    def test_mh_to_mboxmmdf(self):
+        # Convert MHMessage to mboxMessage and MMDFMessage
+        pairs = (('unseen', 'O'), ('replied', 'ROA'), ('flagged', 'ROF'))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                self.assertEqual(class_(msg).get_flags(), result)
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            self.assertEqual(class_(msg).get_flags(), 'OFA')
+
+    def test_mh_to_mh(self):
+        # Convert MHMessage to MHMessage
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+                         ['unseen', 'replied', 'flagged'])
+
+    def test_mh_to_babyl(self):
+        # Convert MHMessage to BabylMessage
+        pairs = (('unseen', ['unseen']), ('replied', ['answered']),
+                 ('flagged', []))
+        for setting, result in pairs:
+            msg = mailbox.MHMessage(_sample_message)
+            msg.add_sequence(setting)
+            self.assertEqual(mailbox.BabylMessage(msg).get_labels(), result)
+        msg = mailbox.MHMessage(_sample_message)
+        msg.add_sequence('unseen')
+        msg.add_sequence('replied')
+        msg.add_sequence('flagged')
+        self.assertEqual(mailbox.BabylMessage(msg).get_labels(),
+                         ['unseen', 'answered'])
+
+    def test_babyl_to_maildir(self):
+        # Convert BabylMessage to MaildirMessage
+        pairs = (('unseen', ''), ('deleted', 'ST'), ('filed', 'S'),
+                 ('answered', 'RS'), ('forwarded', 'PS'), ('edited', 'S'),
+                 ('resent', 'PS'))
+        for setting, result in pairs:
+            msg = mailbox.BabylMessage(_sample_message)
+            msg.add_label(setting)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), result)
+            self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        self.assertEqual(mailbox.MaildirMessage(msg).get_flags(), 'PRT')
+        self.assertEqual(mailbox.MaildirMessage(msg).get_subdir(), 'cur')
+
+    def test_babyl_to_mboxmmdf(self):
+        # Convert BabylMessage to mboxMessage and MMDFMessage
+        pairs = (('unseen', 'O'), ('deleted', 'ROD'), ('filed', 'RO'),
+                 ('answered', 'ROA'), ('forwarded', 'RO'), ('edited', 'RO'),
+                 ('resent', 'RO'))
+        for setting, result in pairs:
+            for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+                msg = mailbox.BabylMessage(_sample_message)
+                msg.add_label(setting)
+                self.assertEqual(class_(msg).get_flags(), result)
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        for class_ in (mailbox.mboxMessage, mailbox.MMDFMessage):
+            self.assertEqual(class_(msg).get_flags(), 'ODA')
+
+    def test_babyl_to_mh(self):
+        # Convert BabylMessage to MHMessage
+        pairs = (('unseen', ['unseen']), ('deleted', []), ('filed', []),
+                 ('answered', ['replied']), ('forwarded', []), ('edited', []),
+                 ('resent', []))
+        for setting, result in pairs:
+            msg = mailbox.BabylMessage(_sample_message)
+            msg.add_label(setting)
+            self.assertEqual(mailbox.MHMessage(msg).get_sequences(), result)
+        msg = mailbox.BabylMessage(_sample_message)
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        self.assertEqual(mailbox.MHMessage(msg).get_sequences(),
+                         ['unseen', 'replied'])
+
+    def test_babyl_to_babyl(self):
+        # Convert BabylMessage to BabylMessage
+        msg = mailbox.BabylMessage(_sample_message)
+        msg.update_visible()
+        for label in ('unseen', 'deleted', 'filed', 'answered', 'forwarded',
+                      'edited', 'resent'):
+            msg.add_label(label)
+        msg2 = mailbox.BabylMessage(msg)
+        self.assertEqual(msg2.get_labels(), ['unseen', 'deleted', 'filed',
+                                             'answered', 'forwarded', 'edited',
+                                             'resent'])
+        self.assertEqual(msg.get_visible().keys(), msg2.get_visible().keys())
+        for key in msg.get_visible().keys():
+            self.assertEqual(msg.get_visible()[key], msg2.get_visible()[key])
+
+
+class TestProxyFileBase(TestBase):
+
+    def _test_read(self, proxy):
+        # Read by byte
+        proxy.seek(0)
+        self.assertEqual(proxy.read(), b'bar')
+        proxy.seek(1)
+        self.assertEqual(proxy.read(), b'ar')
+        proxy.seek(0)
+        self.assertEqual(proxy.read(2), b'ba')
+        proxy.seek(1)
+        self.assertEqual(proxy.read(-1), b'ar')
+        proxy.seek(2)
+        self.assertEqual(proxy.read(1000), b'r')
+
+    def _test_readline(self, proxy):
+        # Read by line
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        self.assertEqual(proxy.readline(), b'foo' + linesep)
+        self.assertEqual(proxy.readline(), b'bar' + linesep)
+        self.assertEqual(proxy.readline(), b'fred' + linesep)
+        self.assertEqual(proxy.readline(), b'bob')
+        proxy.seek(2)
+        self.assertEqual(proxy.readline(), b'o' + linesep)
+        proxy.seek(6 + 2 * len(os.linesep))
+        self.assertEqual(proxy.readline(), b'fred' + linesep)
+        proxy.seek(6 + 2 * len(os.linesep))
+        self.assertEqual(proxy.readline(2), b'fr')
+        self.assertEqual(proxy.readline(-10), b'ed' + linesep)
+
+    def _test_readlines(self, proxy):
+        # Read multiple lines
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        self.assertEqual(proxy.readlines(), [b'foo' + linesep,
+                                           b'bar' + linesep,
+                                           b'fred' + linesep, b'bob'])
+        proxy.seek(0)
+        self.assertEqual(proxy.readlines(2), [b'foo' + linesep])
+        proxy.seek(3 + len(linesep))
+        self.assertEqual(proxy.readlines(4 + len(linesep)),
+                     [b'bar' + linesep, b'fred' + linesep])
+        proxy.seek(3)
+        self.assertEqual(proxy.readlines(1000), [linesep, b'bar' + linesep,
+                                               b'fred' + linesep, b'bob'])
+
+    def _test_iteration(self, proxy):
+        # Iterate by line
+        linesep = os.linesep.encode()
+        proxy.seek(0)
+        iterator = iter(proxy)
+        self.assertEqual(next(iterator), b'foo' + linesep)
+        self.assertEqual(next(iterator), b'bar' + linesep)
+        self.assertEqual(next(iterator), b'fred' + linesep)
+        self.assertEqual(next(iterator), b'bob')
+        self.assertRaises(StopIteration, next, iterator)
+
+    def _test_seek_and_tell(self, proxy):
+        # Seek and use tell to check position
+        linesep = os.linesep.encode()
+        proxy.seek(3)
+        self.assertEqual(proxy.tell(), 3)
+        self.assertEqual(proxy.read(len(linesep)), linesep)
+        proxy.seek(2, 1)
+        self.assertEqual(proxy.read(1 + len(linesep)), b'r' + linesep)
+        proxy.seek(-3 - len(linesep), 2)
+        self.assertEqual(proxy.read(3), b'bar')
+        proxy.seek(2, 0)
+        self.assertEqual(proxy.read(), b'o' + linesep + b'bar' + linesep)
+        proxy.seek(100)
+        self.assertFalse(proxy.read())
+
+    def _test_close(self, proxy):
+        # Close a file
+        self.assertFalse(proxy.closed)
+        proxy.close()
+        self.assertTrue(proxy.closed)
+        # Issue 11700 subsequent closes should be a no-op.
+        proxy.close()
+        self.assertTrue(proxy.closed)
+
+
+class TestProxyFile(TestProxyFileBase, unittest.TestCase):
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._file = open(self._path, 'wb+')
+
+    def tearDown(self):
+        self._file.close()
+        self._delete_recursively(self._path)
+
+    def test_initialize(self):
+        # Initialize and check position
+        self._file.write(b'foo')
+        pos = self._file.tell()
+        proxy0 = mailbox._ProxyFile(self._file)
+        self.assertEqual(proxy0.tell(), pos)
+        self.assertEqual(self._file.tell(), pos)
+        proxy1 = mailbox._ProxyFile(self._file, 0)
+        self.assertEqual(proxy1.tell(), 0)
+        self.assertEqual(self._file.tell(), pos)
+
+    def test_read(self):
+        self._file.write(b'bar')
+        self._test_read(mailbox._ProxyFile(self._file))
+
+    def test_readline(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_readline(mailbox._ProxyFile(self._file))
+
+    def test_readlines(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_readlines(mailbox._ProxyFile(self._file))
+
+    def test_iteration(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob' % (os.linesep, os.linesep,
+                                                  os.linesep), 'ascii'))
+        self._test_iteration(mailbox._ProxyFile(self._file))
+
+    def test_seek_and_tell(self):
+        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._test_seek_and_tell(mailbox._ProxyFile(self._file))
+
+    def test_close(self):
+        self._file.write(bytes('foo%sbar%s' % (os.linesep, os.linesep), 'ascii'))
+        self._test_close(mailbox._ProxyFile(self._file))
+
+
+class TestPartialFile(TestProxyFileBase, unittest.TestCase):
+
+    def setUp(self):
+        self._path = os_helper.TESTFN
+        self._file = open(self._path, 'wb+')
+
+    def tearDown(self):
+        self._file.close()
+        self._delete_recursively(self._path)
+
+    def test_initialize(self):
+        # Initialize and check position
+        self._file.write(bytes('foo' + os.linesep + 'bar', 'ascii'))
+        pos = self._file.tell()
+        proxy = mailbox._PartialFile(self._file, 2, 5)
+        self.assertEqual(proxy.tell(), 0)
+        self.assertEqual(self._file.tell(), pos)
+
+    def test_read(self):
+        self._file.write(bytes('***bar***', 'ascii'))
+        self._test_read(mailbox._PartialFile(self._file, 3, 6))
+
+    def test_readline(self):
+        self._file.write(bytes('!!!!!foo%sbar%sfred%sbob!!!!!' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_readline(mailbox._PartialFile(self._file, 5,
+                                                 18 + 3 * len(os.linesep)))
+
+    def test_readlines(self):
+        self._file.write(bytes('foo%sbar%sfred%sbob?????' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_readlines(mailbox._PartialFile(self._file, 0,
+                                                  13 + 3 * len(os.linesep)))
+
+    def test_iteration(self):
+        self._file.write(bytes('____foo%sbar%sfred%sbob####' %
+                         (os.linesep, os.linesep, os.linesep), 'ascii'))
+        self._test_iteration(mailbox._PartialFile(self._file, 4,
+                                                  17 + 3 * len(os.linesep)))
+
+    def test_seek_and_tell(self):
+        self._file.write(bytes('(((foo%sbar%s$$$' % (os.linesep, os.linesep), 'ascii'))
+        self._test_seek_and_tell(mailbox._PartialFile(self._file, 3,
+                                                      9 + 2 * len(os.linesep)))
+
+    def test_close(self):
+        self._file.write(bytes('&foo%sbar%s^' % (os.linesep, os.linesep), 'ascii'))
+        self._test_close(mailbox._PartialFile(self._file, 1,
+                                              6 + 3 * len(os.linesep)))
+
+
+## Start: tests from the original module (for backward compatibility).
+
+FROM_ = "From some.body@dummy.domain  Sat Jul 24 13:43:35 2004\n"
+DUMMY_MESSAGE = """\
+From: some.body@dummy.domain
+To: me@my.domain
+Subject: Simple Test
+
+This is a dummy message.
+"""
+
+class MaildirTestCase(unittest.TestCase):
+
+    def setUp(self):
+        # create a new maildir mailbox to work with:
+        self._dir = os_helper.TESTFN
+        if os.path.isdir(self._dir):
+            os_helper.rmtree(self._dir)
+        elif os.path.isfile(self._dir):
+            os_helper.unlink(self._dir)
+        os.mkdir(self._dir)
+        os.mkdir(os.path.join(self._dir, "cur"))
+        os.mkdir(os.path.join(self._dir, "tmp"))
+        os.mkdir(os.path.join(self._dir, "new"))
+        self._counter = 1
+        self._msgfiles = []
+
+    def tearDown(self):
+        list(map(os.unlink, self._msgfiles))
+        os_helper.rmdir(os.path.join(self._dir, "cur"))
+        os_helper.rmdir(os.path.join(self._dir, "tmp"))
+        os_helper.rmdir(os.path.join(self._dir, "new"))
+        os_helper.rmdir(self._dir)
+
+    def createMessage(self, dir, mbox=False):
+        t = int(time.time() % 1000000)
+        pid = self._counter
+        self._counter += 1
+        filename = ".".join((str(t), str(pid), "myhostname", "mydomain"))
+        tmpname = os.path.join(self._dir, "tmp", filename)
+        newname = os.path.join(self._dir, dir, filename)
+        with open(tmpname, "w", encoding="utf-8") as fp:
+            self._msgfiles.append(tmpname)
+            if mbox:
+                fp.write(FROM_)
+            fp.write(DUMMY_MESSAGE)
+        try:
+            os.link(tmpname, newname)
+        except (AttributeError, PermissionError):
+            with open(newname, "w") as fp:
+                fp.write(DUMMY_MESSAGE)
+        self._msgfiles.append(newname)
+        return tmpname
+
+    def test_empty_maildir(self):
+        """Test an empty maildir mailbox"""
+        # Test for regression on bug #117490:
+        # Make sure the boxes attribute actually gets set.
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertHasAttr(self.mbox, "boxes")
+        #self.assertEqual(len(self.mbox.boxes), 0)
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_cur(self):
+        self.createMessage("cur")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 1)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_new(self):
+        self.createMessage("new")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 1)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+    def test_nonempty_maildir_both(self):
+        self.createMessage("cur")
+        self.createMessage("new")
+        self.mbox = mailbox.Maildir(os_helper.TESTFN)
+        #self.assertEqual(len(self.mbox.boxes), 2)
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNotNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+        self.assertIsNone(self.mbox.next())
+
+## End: tests from the original module (for backward compatibility).
+
+
+_sample_message = """\
+Return-Path: <gkj@gregorykjohnson.com>
+X-Original-To: gkj+person@localhost
+Delivered-To: gkj+person@localhost
+Received: from localhost (localhost [127.0.0.1])
+        by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
+        for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
+Delivered-To: gkj@sundance.gregorykjohnson.com
+Received: from localhost [127.0.0.1]
+        by localhost with POP3 (fetchmail-6.2.5)
+        for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)
+Received: from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
+        by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
+        for <gkj@gregorykjohnson.com>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
+Received: by andy.gregorykjohnson.com (Postfix, from userid 1000)
+        id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)
+Date: Wed, 13 Jul 2005 17:23:11 -0400
+From: "Gregory K. Johnson" <gkj@gregorykjohnson.com>
+To: gkj@gregorykjohnson.com
+Subject: Sample message
+Message-ID: <20050713212311.GC4701@andy.gregorykjohnson.com>
+Mime-Version: 1.0
+Content-Type: multipart/mixed; boundary="NMuMz9nt05w80d4+"
+Content-Disposition: inline
+User-Agent: Mutt/1.5.9i
+
+
+--NMuMz9nt05w80d4+
+Content-Type: text/plain; charset=us-ascii
+Content-Disposition: inline
+
+This is a sample message.
+
+--
+Gregory K. Johnson
+
+--NMuMz9nt05w80d4+
+Content-Type: application/octet-stream
+Content-Disposition: attachment; filename="text.gz"
+Content-Transfer-Encoding: base64
+
+H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
+3FYlAAAA
+
+--NMuMz9nt05w80d4+--
+"""
+
+_bytes_sample_message = _sample_message.encode('ascii')
+
+_sample_headers = [
+    ("Return-Path", "<gkj@gregorykjohnson.com>"),
+    ("X-Original-To", "gkj+person@localhost"),
+    ("Delivered-To", "gkj+person@localhost"),
+    ("Received", """from localhost (localhost [127.0.0.1])
+        by andy.gregorykjohnson.com (Postfix) with ESMTP id 356ED9DD17
+        for <gkj+person@localhost>; Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
+    ("Delivered-To", "gkj@sundance.gregorykjohnson.com"),
+    ("Received", """from localhost [127.0.0.1]
+        by localhost with POP3 (fetchmail-6.2.5)
+        for gkj+person@localhost (single-drop); Wed, 13 Jul 2005 17:23:16 -0400 (EDT)"""),
+    ("Received", """from andy.gregorykjohnson.com (andy.gregorykjohnson.com [64.32.235.228])
+        by sundance.gregorykjohnson.com (Postfix) with ESMTP id 5B056316746
+        for <gkj@gregorykjohnson.com>; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
+    ("Received", """by andy.gregorykjohnson.com (Postfix, from userid 1000)
+        id 490CD9DD17; Wed, 13 Jul 2005 17:23:11 -0400 (EDT)"""),
+    ("Date", "Wed, 13 Jul 2005 17:23:11 -0400"),
+    ("From", """"Gregory K. Johnson" <gkj@gregorykjohnson.com>"""),
+    ("To", "gkj@gregorykjohnson.com"),
+    ("Subject", "Sample message"),
+    ("Mime-Version", "1.0"),
+    ("Content-Type", """multipart/mixed; boundary="NMuMz9nt05w80d4+\""""),
+    ("Content-Disposition", "inline"),
+    ("User-Agent", "Mutt/1.5.9i"),
+]
+
+_sample_payloads = ("""This is a sample message.
+
+--
+Gregory K. Johnson
+""",
+"""H4sICM2D1UIAA3RleHQAC8nILFYAokSFktSKEoW0zJxUPa7wzJIMhZLyfIWczLzUYj0uAHTs
+3FYlAAAA
+""")
+
+
+class MiscTestCase(unittest.TestCase):
+    def test__all__(self):
+        support.check__all__(self, mailbox,
+                             not_exported={"linesep", "fcntl"})
+
+
+def tearDownModule():
+    support.reap_children()
+    # reap_children may have re-populated caches:
+    if refleak_helper.hunting_for_refleaks():
+        sys._clear_internal_caches()
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 2161e06b2f..142b45f6a4 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -35,7 +35,7 @@ def test_ints(self):
                 self.helper(expected)
             n = n >> 1
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_int64(self):
         # Simulate int marshaling with TYPE_INT64.
         maxint64 = (1 << 63) - 1
@@ -232,7 +232,7 @@ def check(s):
             self.assertRaises(ValueError, marshal.loads, s)
         run_tests(2**20, check)
 
-    @unittest.skip("TODO: RUSTPYTHON; segfault")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; segfault
     def test_recursion_limit(self):
         # Create a deeply nested structure.
         head = last = []
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index 16d12f9688..d14336f8ba 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -573,6 +573,8 @@ def testFloor(self):
         #self.assertEqual(math.ceil(NINF), NINF)
         #self.assertTrue(math.isnan(math.floor(NAN)))
 
+        class TestFloorIsNone(float):
+            __floor__ = None
         class TestFloor:
             def __floor__(self):
                 return 42
@@ -588,6 +590,7 @@ class TestBadFloor:
         self.assertEqual(math.floor(FloatLike(41.9)), 41)
         self.assertRaises(TypeError, math.floor, TestNoFloor())
         self.assertRaises(ValueError, math.floor, TestBadFloor())
+        self.assertRaises(TypeError, math.floor, TestFloorIsNone(3.5))
 
         t = TestNoFloor()
         t.__floor__ = lambda *args: args
@@ -1125,6 +1128,15 @@ def __index__(self):
                 with self.assertRaises(TypeError):
                     math.isqrt(value)
 
+    @support.bigmemtest(2**32, memuse=0.85)
+    def test_isqrt_huge(self, size):
+        if size & 1:
+            size += 1
+        v = 1 << size
+        w = math.isqrt(v)
+        self.assertEqual(w.bit_length(), size // 2 + 1)
+        self.assertEqual(w.bit_count(), 1)
+
     def test_lcm(self):
         lcm = math.lcm
         self.assertEqual(lcm(0, 0), 0)
@@ -1202,6 +1214,12 @@ def testLdexp(self):
             self.assertEqual(math.ldexp(NINF, n), NINF)
             self.assertTrue(math.isnan(math.ldexp(NAN, n)))
 
+    @requires_IEEE_754
+    def testLdexp_denormal(self):
+        # Denormal output incorrectly rounded (truncated)
+        # on some Windows.
+        self.assertEqual(math.ldexp(6993274598585239, -1126), 1e-323)
+
     def testLog(self):
         self.assertRaises(TypeError, math.log)
         self.assertRaises(TypeError, math.log, 1, 2, 3)
@@ -1266,6 +1284,13 @@ def testLog10(self):
         self.assertEqual(math.log(INF), INF)
         self.assertTrue(math.isnan(math.log10(NAN)))
 
+    @support.bigmemtest(2**32, memuse=0.2)
+    def test_log_huge_integer(self, size):
+        v = 1 << size
+        self.assertAlmostEqual(math.log2(v), size)
+        self.assertAlmostEqual(math.log(v), size * 0.6931471805599453)
+        self.assertAlmostEqual(math.log10(v), size * 0.3010299956639812)
+
     def testSumProd(self):
         sumprod = math.sumprod
         Decimal = decimal.Decimal
@@ -1374,7 +1399,6 @@ def test_sumprod_accuracy(self):
         self.assertEqual(sumprod([True, False] * 10, [0.1] * 20), 1.0)
         self.assertEqual(sumprod([1.0, 10E100, 1.0, -10E100], [1.0]*4), 2.0)
 
-    @unittest.skip("TODO: RUSTPYTHON, Taking a few minutes.")
     @support.requires_resource('cpu')
     def test_sumprod_stress(self):
         sumprod = math.sumprod
@@ -2014,8 +2038,6 @@ def test_exceptions(self):
         else:
             self.fail("sqrt(-1) didn't raise ValueError")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @requires_IEEE_754
     def test_testfile(self):
         # Some tests need to be skipped on ancient OS X versions.
@@ -2490,6 +2512,46 @@ def test_input_exceptions(self):
         self.assertRaises(TypeError, math.atan2, 1.0)
         self.assertRaises(TypeError, math.atan2, 1.0, 2.0, 3.0)
 
+    def test_exception_messages(self):
+        x = -1.1
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a nonnegative input, got {x}"):
+            math.sqrt(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(123, x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x, 123)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log2(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log10(x)
+        x = decimal.Decimal('-1.1')
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {x}"):
+            math.log(x)
+        x = fractions.Fraction(1, 10**400)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a positive input, got {float(x)}"):
+            math.log(x)
+        x = -123
+        with self.assertRaisesRegex(ValueError,
+                                    "expected a positive input$"):
+            math.log(x)
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a noninteger or positive integer, got {x}"):
+            math.gamma(x)
+        x = 1.0
+        with self.assertRaisesRegex(ValueError,
+                                    f"expected a number between -1 and 1, got {x}"):
+            math.atanh(x)
+
     # Custom assertions.
 
     def assertIsNaN(self, value):
@@ -2640,9 +2702,10 @@ def test_fma_nan_results(self):
 
         # If any input is a NaN, the result should be a NaN, too.
         for a, b in itertools.product(values, repeat=2):
-            self.assertIsNaN(math.fma(math.nan, a, b))
-            self.assertIsNaN(math.fma(a, math.nan, b))
-            self.assertIsNaN(math.fma(a, b, math.nan))
+            with self.subTest(a=a, b=b):
+                self.assertIsNaN(math.fma(math.nan, a, b))
+                self.assertIsNaN(math.fma(a, math.nan, b))
+                self.assertIsNaN(math.fma(a, b, math.nan))
 
     def test_fma_infinities(self):
         # Cases involving infinite inputs or results.
@@ -2654,86 +2717,96 @@ def test_fma_infinities(self):
         for c in non_nans:
             for infinity in [math.inf, -math.inf]:
                 for zero in [0.0, -0.0]:
-                    with self.assertRaises(ValueError):
-                        math.fma(infinity, zero, c)
-                    with self.assertRaises(ValueError):
-                        math.fma(zero, infinity, c)
+                    with self.subTest(c=c, infinity=infinity, zero=zero):
+                        with self.assertRaises(ValueError):
+                            math.fma(infinity, zero, c)
+                        with self.assertRaises(ValueError):
+                            math.fma(zero, infinity, c)
 
         # ValueError when a*b and c both infinite of opposite signs.
         for b in positives:
-            with self.assertRaises(ValueError):
-                math.fma(math.inf, b, -math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(math.inf, -b, math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(-math.inf, -b, -math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(-math.inf, b, math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(b, math.inf, -math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(-b, math.inf, math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(-b, -math.inf, -math.inf)
-            with self.assertRaises(ValueError):
-                math.fma(b, -math.inf, math.inf)
+            with self.subTest(b=b):
+                with self.assertRaises(ValueError):
+                    math.fma(math.inf, b, -math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(math.inf, -b, math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(-math.inf, -b, -math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(-math.inf, b, math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(b, math.inf, -math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(-b, math.inf, math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(-b, -math.inf, -math.inf)
+                with self.assertRaises(ValueError):
+                    math.fma(b, -math.inf, math.inf)
 
         # Infinite result when a*b and c both infinite of the same sign.
         for b in positives:
-            self.assertEqual(math.fma(math.inf, b, math.inf), math.inf)
-            self.assertEqual(math.fma(math.inf, -b, -math.inf), -math.inf)
-            self.assertEqual(math.fma(-math.inf, -b, math.inf), math.inf)
-            self.assertEqual(math.fma(-math.inf, b, -math.inf), -math.inf)
-            self.assertEqual(math.fma(b, math.inf, math.inf), math.inf)
-            self.assertEqual(math.fma(-b, math.inf, -math.inf), -math.inf)
-            self.assertEqual(math.fma(-b, -math.inf, math.inf), math.inf)
-            self.assertEqual(math.fma(b, -math.inf, -math.inf), -math.inf)
+            with self.subTest(b=b):
+                self.assertEqual(math.fma(math.inf, b, math.inf), math.inf)
+                self.assertEqual(math.fma(math.inf, -b, -math.inf), -math.inf)
+                self.assertEqual(math.fma(-math.inf, -b, math.inf), math.inf)
+                self.assertEqual(math.fma(-math.inf, b, -math.inf), -math.inf)
+                self.assertEqual(math.fma(b, math.inf, math.inf), math.inf)
+                self.assertEqual(math.fma(-b, math.inf, -math.inf), -math.inf)
+                self.assertEqual(math.fma(-b, -math.inf, math.inf), math.inf)
+                self.assertEqual(math.fma(b, -math.inf, -math.inf), -math.inf)
 
         # Infinite result when a*b finite, c infinite.
         for a, b in itertools.product(finites, finites):
-            self.assertEqual(math.fma(a, b, math.inf), math.inf)
-            self.assertEqual(math.fma(a, b, -math.inf), -math.inf)
+            with self.subTest(b=b):
+                self.assertEqual(math.fma(a, b, math.inf), math.inf)
+                self.assertEqual(math.fma(a, b, -math.inf), -math.inf)
 
         # Infinite result when a*b infinite, c finite.
         for b, c in itertools.product(positives, finites):
-            self.assertEqual(math.fma(math.inf, b, c), math.inf)
-            self.assertEqual(math.fma(-math.inf, b, c), -math.inf)
-            self.assertEqual(math.fma(-math.inf, -b, c), math.inf)
-            self.assertEqual(math.fma(math.inf, -b, c), -math.inf)
+            with self.subTest(b=b, c=c):
+                self.assertEqual(math.fma(math.inf, b, c), math.inf)
+                self.assertEqual(math.fma(-math.inf, b, c), -math.inf)
+                self.assertEqual(math.fma(-math.inf, -b, c), math.inf)
+                self.assertEqual(math.fma(math.inf, -b, c), -math.inf)
 
-            self.assertEqual(math.fma(b, math.inf, c), math.inf)
-            self.assertEqual(math.fma(b, -math.inf, c), -math.inf)
-            self.assertEqual(math.fma(-b, -math.inf, c), math.inf)
-            self.assertEqual(math.fma(-b, math.inf, c), -math.inf)
+                self.assertEqual(math.fma(b, math.inf, c), math.inf)
+                self.assertEqual(math.fma(b, -math.inf, c), -math.inf)
+                self.assertEqual(math.fma(-b, -math.inf, c), math.inf)
+                self.assertEqual(math.fma(-b, math.inf, c), -math.inf)
 
     # gh-73468: On some platforms, libc fma() doesn't implement IEE 754-2008
     # properly: it doesn't use the right sign when the result is zero.
     @unittest.skipIf(
-        sys.platform.startswith(("freebsd", "wasi", "netbsd"))
-        or (sys.platform == "android" and platform.machine() == "x86_64"),
+        sys.platform.startswith(("freebsd", "wasi", "netbsd", "emscripten"))
+        or (sys.platform == "android" and platform.machine() == "x86_64")
+        or support.linked_to_musl(),  # gh-131032
         f"this platform doesn't implement IEE 754-2008 properly")
+    # gh-131032: musl is fixed but the fix is not yet released; when the fixed
+    # version is known change this to:
+    #   or support.linked_to_musl() < (1, <m>, <p>)
     def test_fma_zero_result(self):
         nonnegative_finites = [0.0, 1e-300, 2.3, 1e300]
 
         # Zero results from exact zero inputs.
         for b in nonnegative_finites:
-            self.assertIsPositiveZero(math.fma(0.0, b, 0.0))
-            self.assertIsPositiveZero(math.fma(0.0, b, -0.0))
-            self.assertIsNegativeZero(math.fma(0.0, -b, -0.0))
-            self.assertIsPositiveZero(math.fma(0.0, -b, 0.0))
-            self.assertIsPositiveZero(math.fma(-0.0, -b, 0.0))
-            self.assertIsPositiveZero(math.fma(-0.0, -b, -0.0))
-            self.assertIsNegativeZero(math.fma(-0.0, b, -0.0))
-            self.assertIsPositiveZero(math.fma(-0.0, b, 0.0))
-
-            self.assertIsPositiveZero(math.fma(b, 0.0, 0.0))
-            self.assertIsPositiveZero(math.fma(b, 0.0, -0.0))
-            self.assertIsNegativeZero(math.fma(-b, 0.0, -0.0))
-            self.assertIsPositiveZero(math.fma(-b, 0.0, 0.0))
-            self.assertIsPositiveZero(math.fma(-b, -0.0, 0.0))
-            self.assertIsPositiveZero(math.fma(-b, -0.0, -0.0))
-            self.assertIsNegativeZero(math.fma(b, -0.0, -0.0))
-            self.assertIsPositiveZero(math.fma(b, -0.0, 0.0))
+            with self.subTest(b=b):
+                self.assertIsPositiveZero(math.fma(0.0, b, 0.0))
+                self.assertIsPositiveZero(math.fma(0.0, b, -0.0))
+                self.assertIsNegativeZero(math.fma(0.0, -b, -0.0))
+                self.assertIsPositiveZero(math.fma(0.0, -b, 0.0))
+                self.assertIsPositiveZero(math.fma(-0.0, -b, 0.0))
+                self.assertIsPositiveZero(math.fma(-0.0, -b, -0.0))
+                self.assertIsNegativeZero(math.fma(-0.0, b, -0.0))
+                self.assertIsPositiveZero(math.fma(-0.0, b, 0.0))
+
+                self.assertIsPositiveZero(math.fma(b, 0.0, 0.0))
+                self.assertIsPositiveZero(math.fma(b, 0.0, -0.0))
+                self.assertIsNegativeZero(math.fma(-b, 0.0, -0.0))
+                self.assertIsPositiveZero(math.fma(-b, 0.0, 0.0))
+                self.assertIsPositiveZero(math.fma(-b, -0.0, 0.0))
+                self.assertIsPositiveZero(math.fma(-b, -0.0, -0.0))
+                self.assertIsNegativeZero(math.fma(b, -0.0, -0.0))
+                self.assertIsPositiveZero(math.fma(b, -0.0, 0.0))
 
         # Exact zero result from nonzero inputs.
         self.assertIsPositiveZero(math.fma(2.0, 2.0, -4.0))
@@ -2839,12 +2912,14 @@ def test_random(self):
              '0x1.f5467b1911fd6p-2', '0x1.b5cee3225caa5p-1'),
         ]
         for a_hex, b_hex, c_hex, expected_hex in test_values:
-            a = float.fromhex(a_hex)
-            b = float.fromhex(b_hex)
-            c = float.fromhex(c_hex)
-            expected = float.fromhex(expected_hex)
-            self.assertEqual(math.fma(a, b, c), expected)
-            self.assertEqual(math.fma(b, a, c), expected)
+            with self.subTest(a_hex=a_hex, b_hex=b_hex, c_hex=c_hex,
+                              expected_hex=expected_hex):
+                a = float.fromhex(a_hex)
+                b = float.fromhex(b_hex)
+                c = float.fromhex(c_hex)
+                expected = float.fromhex(expected_hex)
+                self.assertEqual(math.fma(a, b, c), expected)
+                self.assertEqual(math.fma(b, a, c), expected)
 
     # Custom assertions.
     def assertIsNaN(self, value):
diff --git a/Lib/test/test_math_property.py b/Lib/test/test_math_property.py
new file mode 100644
index 0000000000..7d51aa17b4
--- /dev/null
+++ b/Lib/test/test_math_property.py
@@ -0,0 +1,41 @@
+import functools
+import unittest
+from math import isnan, nextafter
+from test.support import requires_IEEE_754
+from test.support.hypothesis_helper import hypothesis
+
+floats = hypothesis.strategies.floats
+integers = hypothesis.strategies.integers
+
+
+def assert_equal_float(x, y):
+    assert isnan(x) and isnan(y) or x == y
+
+
+def via_reduce(x, y, steps):
+    return functools.reduce(nextafter, [y] * steps, x)
+
+
+class NextafterTests(unittest.TestCase):
+    @requires_IEEE_754
+    @hypothesis.given(
+        x=floats(),
+        y=floats(),
+        steps=integers(min_value=0, max_value=2**16))
+    def test_count(self, x, y, steps):
+        assert_equal_float(via_reduce(x, y, steps),
+                           nextafter(x, y, steps=steps))
+
+    @requires_IEEE_754
+    @hypothesis.given(
+        x=floats(),
+        y=floats(),
+        a=integers(min_value=0),
+        b=integers(min_value=0))
+    def test_addition_commutes(self, x, y, a, b):
+        first = nextafter(x, y, steps=a)
+        second = nextafter(first, y, steps=b)
+        combined = nextafter(x, y, steps=a+b)
+        hypothesis.note(f"{first} -> {second} == {combined}")
+
+        assert_equal_float(second, combined)
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index 5b695f167a..343e5dd7a6 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -724,8 +724,6 @@ class CBytesIOTest(PyBytesIOTest):
     ioclass = io.BytesIO
     UnsupportedOperation = io.UnsupportedOperation
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bytes_array(self):
         super().test_bytes_array()
 
@@ -739,8 +737,6 @@ def test_flags(self):
     def test_getbuffer(self):
         super().test_getbuffer()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         super().test_init()
 
@@ -749,8 +745,6 @@ def test_init(self):
     def test_issue5449(self):
         super().test_issue5449()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickling(self):
         super().test_pickling()
 
@@ -770,8 +764,6 @@ def test_relative_seek(self):
     def test_seek(self):
         super().test_seek()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclassing(self):
         super().test_subclassing()
 
@@ -783,8 +775,6 @@ def test_truncate(self):
     def test_write(self):
         super().test_write()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getstate(self):
         memio = self.ioclass()
         state = memio.__getstate__()
@@ -884,8 +874,6 @@ def test_detach(self):
     def test_flags(self):
         super().test_flags()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         super().test_init()
 
@@ -919,8 +907,6 @@ def test_newline_none(self):
     def test_newlines_property(self):
         super().test_newlines_property()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickling(self):
         super().test_pickling()
 
@@ -940,8 +926,6 @@ def test_relative_seek(self):
     def test_seek(self):
         super().test_seek()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_textio_properties(self):
         super().test_textio_properties()
 
@@ -964,8 +948,6 @@ def test_widechar(self):
         self.assertEqual(memio.tell(), len(buf) * 2)
         self.assertEqual(memio.getvalue(), buf + buf)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getstate(self):
         memio = self.ioclass()
         state = memio.__getstate__()
@@ -1016,8 +998,6 @@ def test_newline_cr(self):
     def test_newline_crlf(self):
         super().test_newline_crlf()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_newline_default(self):
         super().test_newline_default()
 
@@ -1026,8 +1006,6 @@ def test_newline_default(self):
     def test_newline_empty(self):
         super().test_newline_empty()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_newline_lf(self):
         super().test_newline_lf()
 
@@ -1046,8 +1024,6 @@ def test_newlines_property(self):
     def test_relative_seek(self):
         super().test_relative_seek()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_textio_properties(self):
         super().test_textio_properties()
 
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index ed96be53cc..f80df63bb8 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -618,6 +618,7 @@ 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"
@@ -867,6 +868,7 @@ 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_multiprocessing_fork/__init__.py b/Lib/test/test_multiprocessing_fork/__init__.py
index aa1fff50b2..b35e82879d 100644
--- a/Lib/test/test_multiprocessing_fork/__init__.py
+++ b/Lib/test/test_multiprocessing_fork/__init__.py
@@ -12,5 +12,8 @@
 if sys.platform == 'darwin':
     raise unittest.SkipTest("test may crash on macOS (bpo-33725)")
 
+if support.check_sanitizer(thread=True):
+    raise unittest.SkipTest("TSAN doesn't support threads after fork")
+
 def load_tests(*args):
     return support.load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_multiprocessing_fork/test_manager.py b/Lib/test/test_multiprocessing_fork/test_manager.py
index 9efbb83bbb..f8d7eddd65 100644
--- a/Lib/test/test_multiprocessing_fork/test_manager.py
+++ b/Lib/test/test_multiprocessing_fork/test_manager.py
@@ -3,5 +3,22 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="manager")
 
+import sys  # TODO: RUSTPYTHON
+class WithManagerTestCondition(WithManagerTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON, times out')
+    def test_notify_all(self): super().test_notify_all()  # TODO: RUSTPYTHON
+
+class WithManagerTestQueue(WithManagerTestQueue):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON, times out')
+    def test_fork(self): super().test_fork()  # TODO: RUSTPYTHON
+
+local_globs = globals().copy()  # TODO: RUSTPYTHON
+for name, base in local_globs.items():  # TODO: RUSTPYTHON
+    if name.startswith('WithManagerTest') and issubclass(base, unittest.TestCase):  # TODO: RUSTPYTHON
+        base = unittest.skipIf(  # TODO: RUSTPYTHON
+            sys.platform == 'linux',  # TODO: RUSTPYTHON
+            'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError'
+        )(base)  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_fork/test_misc.py b/Lib/test/test_multiprocessing_fork/test_misc.py
index 891a494020..bcf0858258 100644
--- a/Lib/test/test_multiprocessing_fork/test_misc.py
+++ b/Lib/test/test_multiprocessing_fork/test_misc.py
@@ -3,5 +3,24 @@
 
 install_tests_in_module_dict(globals(), 'fork', exclude_types=True)
 
+import sys  # TODO: RUSTPYTHON
+class TestManagerExceptions(TestManagerExceptions):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_queue_get(self): super().test_queue_get()  # TODO: RUSTPYTHON
+
+@unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+class TestInitializers(TestInitializers): pass  # TODO: RUSTPYTHON
+
+class TestStartMethod(TestStartMethod):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_nested_startmethod(self): super().test_nested_startmethod()  # TODO: RUSTPYTHON
+
+@unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+class TestSyncManagerTypes(TestSyncManagerTypes): pass  # TODO: RUSTPYTHON
+
+class MiscTestCase(MiscTestCase):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', "TODO: RUSTPYTHON flaky")
+    def test_forked_thread_not_started(self): super().test_forked_thread_not_started()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_fork/test_processes.py b/Lib/test/test_multiprocessing_fork/test_processes.py
index e64e9afc01..8c7e6b5689 100644
--- a/Lib/test/test_multiprocessing_fork/test_processes.py
+++ b/Lib/test/test_multiprocessing_fork/test_processes.py
@@ -3,5 +3,57 @@
 
 install_tests_in_module_dict(globals(), 'fork', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify_all(self): super().test_notify_all()  # TODO: RUSTPYTHON
+
+class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_repr_lock(self): super().test_repr_lock()  # TODO: RUSTPYTHON
+
+class WithProcessesTestManagerRestart(WithProcessesTestManagerRestart):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_rapid_restart(self): super().test_rapid_restart()  # TODO: RUSTPYTHON
+
+class WithProcessesTestProcess(WithProcessesTestProcess):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_args_argument(self): super().test_args_argument()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_process(self): super().test_process()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPool(WithProcessesTestPool):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_async_timeout(self): super().test_async_timeout()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_terminate(self): super().test_terminate()  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform == 'linux' and 'RUSTPYTHON_SKIP_ENV_POLLUTERS' in os.environ,  # TODO: RUSTPYTHON
+        'TODO: RUSTPYTHON environment pollution when running rustpython -m test --fail-env-changed due to unknown reason'
+    )  # TODO: RUSTPYTHON
+    def test_traceback(self): super().test_traceback()  # TODO: RUSTPYTHON
+
+class WithProcessesTestPoolWorkerLifetime(WithProcessesTestPoolWorkerLifetime):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_pool_worker_lifetime(self): super().test_pool_worker_lifetime()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_pool_worker_lifetime_early_close(self): super().test_pool_worker_lifetime_early_close()  # TODO: RUSTPYTHON
+
+class WithProcessesTestQueue(WithProcessesTestQueue):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_fork(self): super().test_fork()  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky timeout')
+    def test_get(self): super().test_get()  # TODO: RUSTPYTHON
+
+class WithProcessesTestSharedMemory(WithProcessesTestSharedMemory):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'linux', 'TODO: RUSTPYTHON flaky BrokenPipeError, flaky ConnectionRefusedError, flaky ConnectionResetError, flaky EOFError')
+    def test_shared_memory_SharedMemoryManager_basics(self): super().test_shared_memory_SharedMemoryManager_basics()  # TODO: RUSTPYTHON
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_multiprocessing_fork/test_threads.py b/Lib/test/test_multiprocessing_fork/test_threads.py
index 1670e34cb1..1065ebf7fe 100644
--- a/Lib/test/test_multiprocessing_fork/test_threads.py
+++ b/Lib/test/test_multiprocessing_fork/test_threads.py
@@ -3,5 +3,14 @@
 
 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 360967cf1a..a4a2aa21a3 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_processes.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_processes.py
@@ -3,5 +3,41 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skip('TODO: RUSTPYTHON flaky timeout')
+    def test_notify(self): super().test_notify()
+    @unittest.skip('TODO: RUSTPYTHON flaky timeout')
+    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 719c752aa0..1ca30b0bb8 100644
--- a/Lib/test/test_multiprocessing_forkserver/test_threads.py
+++ b/Lib/test/test_multiprocessing_forkserver/test_threads.py
@@ -3,5 +3,13 @@
 
 install_tests_in_module_dict(globals(), 'forkserver', only_type="threads")
 
+import os  # 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 af764b0d84..f3468a86a0 100644
--- a/Lib/test/test_multiprocessing_spawn/test_processes.py
+++ b/Lib/test/test_multiprocessing_spawn/test_processes.py
@@ -3,5 +3,39 @@
 
 install_tests_in_module_dict(globals(), 'spawn', only_type="processes")
 
+import os, sys  # TODO: RUSTPYTHON
+class WithProcessesTestCondition(WithProcessesTestCondition):  # TODO: RUSTPYTHON
+    @unittest.skipIf(sys.platform == 'darwin', 'TODO: RUSTPYTHON flaky timeout')
+    def test_notify(self): super().test_notify()
+
+class WithProcessesTestLock(WithProcessesTestLock):  # TODO: RUSTPYTHON
+    @unittest.skipIf(  # TODO: RUSTPYTHON
+        sys.platform 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_multiprocessing_spawn/test_threads.py b/Lib/test/test_multiprocessing_spawn/test_threads.py
index c1257749b9..54c52c4188 100644
--- a/Lib/test/test_multiprocessing_spawn/test_threads.py
+++ b/Lib/test/test_multiprocessing_spawn/test_threads.py
@@ -3,5 +3,10 @@
 
 install_tests_in_module_dict(globals(), 'spawn', 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
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_named_expressions.py b/Lib/test/test_named_expressions.py
index 03f5384b63..68e4a7704f 100644
--- a/Lib/test/test_named_expressions.py
+++ b/Lib/test/test_named_expressions.py
@@ -165,8 +165,6 @@ def test_named_expression_invalid_rebinding_list_comprehension_iteration_variabl
                 with self.assertRaisesRegex(SyntaxError, msg):
                     exec(code, {}, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure # wrong error message
     def test_named_expression_invalid_rebinding_list_comprehension_inner_loop(self):
         cases = [
             ("Inner reuse", 'j', "[i for i in range(5) if (j := 0) for j in range(5)]"),
@@ -223,8 +221,6 @@ def test_named_expression_invalid_rebinding_set_comprehension_iteration_variable
                 with self.assertRaisesRegex(SyntaxError, msg):
                     exec(code, {}, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_named_expression_invalid_rebinding_set_comprehension_inner_loop(self):
         cases = [
             ("Inner reuse", 'j', "{i for i in range(5) if (j := 0) for j in range(5)}"),
diff --git a/Lib/test/test_netrc.py b/Lib/test/test_netrc.py
index 573d636de9..9d720f6271 100644
--- a/Lib/test/test_netrc.py
+++ b/Lib/test/test_netrc.py
@@ -1,10 +1,6 @@
 import netrc, os, unittest, sys, textwrap
-from test.support import os_helper, run_unittest
-
-try:
-    import pwd
-except ImportError:
-    pwd = None
+from test import support
+from test.support import os_helper
 
 temp_filename = os_helper.TESTFN
 
@@ -269,9 +265,14 @@ def test_comment_at_end_of_machine_line_pass_has_hash(self):
             machine bar.domain.com login foo password pass
             """, '#pass')
 
+    @unittest.skipUnless(support.is_wasi, 'WASI only test')
+    def test_security_on_WASI(self):
+        self.assertFalse(netrc._can_security_check())
+        self.assertEqual(netrc._getpwuid(0), 'uid 0')
+        self.assertEqual(netrc._getpwuid(123456), 'uid 123456')
 
     @unittest.skipUnless(os.name == 'posix', 'POSIX only test')
-    @unittest.skipIf(pwd is None, 'security check requires pwd module')
+    @unittest.skipUnless(hasattr(os, 'getuid'), "os.getuid is required")
     @os_helper.skip_unless_working_chmod
     def test_security(self):
         # This test is incomplete since we are normally not run as root and
@@ -308,8 +309,6 @@ def test_security(self):
             self.assertEqual(nrc.hosts['foo.domain.com'],
                              ('anonymous', '', 'pass'))
 
-def test_main():
-    run_unittest(NetrcTestCase)
 
 if __name__ == "__main__":
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_ntpath.py b/Lib/test/test_ntpath.py
index 7609ecea79..e1982dfd0b 100644
--- a/Lib/test/test_ntpath.py
+++ b/Lib/test/test_ntpath.py
@@ -2,9 +2,12 @@
 import ntpath
 import os
 import string
+import subprocess
 import sys
 import unittest
 import warnings
+from ntpath import ALLOW_MISSING
+from test import support
 from test.support import cpython_only, os_helper
 from test.support import TestFailed, is_emscripten
 from test.support.os_helper import FakePath
@@ -76,6 +79,10 @@ def tester(fn, wantResult):
               %(str(fn), str(wantResult), repr(gotResult)))
 
 
+def _parameterize(*parameters):
+    return support.subTests('kwargs', parameters, _do_cleanups=True)
+
+
 class NtpathTestCase(unittest.TestCase):
     def assertPathEqual(self, path1, path2):
         if path1 == path2 or _norm(path1) == _norm(path2):
@@ -123,6 +130,22 @@ def test_splitdrive(self):
         tester('ntpath.splitdrive("//?/UNC/server/share/dir")',
                ("//?/UNC/server/share", "/dir"))
 
+    def test_splitdrive_invalid_paths(self):
+        splitdrive = ntpath.splitdrive
+        self.assertEqual(splitdrive('\\\\ser\x00ver\\sha\x00re\\di\x00r'),
+                         ('\\\\ser\x00ver\\sha\x00re', '\\di\x00r'))
+        self.assertEqual(splitdrive(b'\\\\ser\x00ver\\sha\x00re\\di\x00r'),
+                         (b'\\\\ser\x00ver\\sha\x00re', b'\\di\x00r'))
+        self.assertEqual(splitdrive("\\\\\udfff\\\udffe\\\udffd"),
+                         ('\\\\\udfff\\\udffe', '\\\udffd'))
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, splitdrive, b'\\\\\xff\\share\\dir')
+            self.assertRaises(UnicodeDecodeError, splitdrive, b'\\\\server\\\xff\\dir')
+            self.assertRaises(UnicodeDecodeError, splitdrive, b'\\\\server\\share\\\xff')
+        else:
+            self.assertEqual(splitdrive(b'\\\\\xff\\\xfe\\\xfd'),
+                             (b'\\\\\xff\\\xfe', b'\\\xfd'))
+
     def test_splitroot(self):
         tester("ntpath.splitroot('')", ('', '', ''))
         tester("ntpath.splitroot('foo')", ('', '', 'foo'))
@@ -213,6 +236,22 @@ def test_splitroot(self):
         tester('ntpath.splitroot(" :/foo")', (" :", "/", "foo"))
         tester('ntpath.splitroot("/:/foo")', ("", "/", ":/foo"))
 
+    def test_splitroot_invalid_paths(self):
+        splitroot = ntpath.splitroot
+        self.assertEqual(splitroot('\\\\ser\x00ver\\sha\x00re\\di\x00r'),
+                         ('\\\\ser\x00ver\\sha\x00re', '\\', 'di\x00r'))
+        self.assertEqual(splitroot(b'\\\\ser\x00ver\\sha\x00re\\di\x00r'),
+                         (b'\\\\ser\x00ver\\sha\x00re', b'\\', b'di\x00r'))
+        self.assertEqual(splitroot("\\\\\udfff\\\udffe\\\udffd"),
+                         ('\\\\\udfff\\\udffe', '\\', '\udffd'))
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, splitroot, b'\\\\\xff\\share\\dir')
+            self.assertRaises(UnicodeDecodeError, splitroot, b'\\\\server\\\xff\\dir')
+            self.assertRaises(UnicodeDecodeError, splitroot, b'\\\\server\\share\\\xff')
+        else:
+            self.assertEqual(splitroot(b'\\\\\xff\\\xfe\\\xfd'),
+                             (b'\\\\\xff\\\xfe', b'\\', b'\xfd'))
+
     def test_split(self):
         tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
         tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")',
@@ -225,11 +264,34 @@ def test_split(self):
         tester('ntpath.split("c:/")', ('c:/', ''))
         tester('ntpath.split("//conky/mountpoint/")', ('//conky/mountpoint/', ''))
 
+    def test_split_invalid_paths(self):
+        split = ntpath.split
+        self.assertEqual(split('c:\\fo\x00o\\ba\x00r'),
+                         ('c:\\fo\x00o', 'ba\x00r'))
+        self.assertEqual(split(b'c:\\fo\x00o\\ba\x00r'),
+                         (b'c:\\fo\x00o', b'ba\x00r'))
+        self.assertEqual(split('c:\\\udfff\\\udffe'),
+                         ('c:\\\udfff', '\udffe'))
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, split, b'c:\\\xff\\bar')
+            self.assertRaises(UnicodeDecodeError, split, b'c:\\foo\\\xff')
+        else:
+            self.assertEqual(split(b'c:\\\xff\\\xfe'),
+                             (b'c:\\\xff', b'\xfe'))
+
     def test_isabs(self):
+        tester('ntpath.isabs("foo\\bar")', 0)
+        tester('ntpath.isabs("foo/bar")', 0)
         tester('ntpath.isabs("c:\\")', 1)
+        tester('ntpath.isabs("c:\\foo\\bar")', 1)
+        tester('ntpath.isabs("c:/foo/bar")', 1)
         tester('ntpath.isabs("\\\\conky\\mountpoint\\")', 1)
-        tester('ntpath.isabs("\\foo")', 1)
-        tester('ntpath.isabs("\\foo\\bar")', 1)
+
+        # gh-44626: paths with only a drive or root are not absolute.
+        tester('ntpath.isabs("\\foo\\bar")', 0)
+        tester('ntpath.isabs("/foo/bar")', 0)
+        tester('ntpath.isabs("c:foo\\bar")', 0)
+        tester('ntpath.isabs("c:foo/bar")', 0)
 
         # gh-96290: normal UNC paths and device paths without trailing backslashes
         tester('ntpath.isabs("\\\\conky\\mountpoint")', 1)
@@ -255,6 +317,7 @@ def test_join(self):
         tester('ntpath.join("a", "b", "c")', 'a\\b\\c')
         tester('ntpath.join("a\\", "b", "c")', 'a\\b\\c')
         tester('ntpath.join("a", "b\\", "c")', 'a\\b\\c')
+        tester('ntpath.join("a", "b", "c\\")', 'a\\b\\c\\')
         tester('ntpath.join("a", "b", "\\c")', '\\c')
         tester('ntpath.join("d:\\", "\\pleep")', 'd:\\pleep')
         tester('ntpath.join("d:\\", "a", "b")', 'd:\\a\\b')
@@ -312,6 +375,40 @@ def test_join(self):
         tester("ntpath.join('\\\\computer\\', 'share')", '\\\\computer\\share')
         tester("ntpath.join('\\\\computer\\share\\', 'a')", '\\\\computer\\share\\a')
         tester("ntpath.join('\\\\computer\\share\\a\\', 'b')", '\\\\computer\\share\\a\\b')
+        # Second part is anchored, so that the first part is ignored.
+        tester("ntpath.join('a', 'Z:b', 'c')", 'Z:b\\c')
+        tester("ntpath.join('a', 'Z:\\b', 'c')", 'Z:\\b\\c')
+        tester("ntpath.join('a', '\\\\b\\c', 'd')", '\\\\b\\c\\d')
+        # Second part has a root but not drive.
+        tester("ntpath.join('a', '\\b', 'c')", '\\b\\c')
+        tester("ntpath.join('Z:/a', '/b', 'c')", 'Z:\\b\\c')
+        tester("ntpath.join('//?/Z:/a', '/b', 'c')",  '\\\\?\\Z:\\b\\c')
+        tester("ntpath.join('D:a', './c:b')", 'D:a\\.\\c:b')
+        tester("ntpath.join('D:/a', './c:b')", 'D:\\a\\.\\c:b')
+
+    def test_normcase(self):
+        normcase = ntpath.normcase
+        self.assertEqual(normcase(''), '')
+        self.assertEqual(normcase(b''), b'')
+        self.assertEqual(normcase('ABC'), 'abc')
+        self.assertEqual(normcase(b'ABC'), b'abc')
+        self.assertEqual(normcase('\xc4\u0141\u03a8'), '\xe4\u0142\u03c8')
+        expected = '\u03c9\u2126' if sys.platform == 'win32' else '\u03c9\u03c9'
+        self.assertEqual(normcase('\u03a9\u2126'), expected)
+        if sys.platform == 'win32' or sys.getfilesystemencoding() == 'utf-8':
+            self.assertEqual(normcase('\xc4\u0141\u03a8'.encode()),
+                             '\xe4\u0142\u03c8'.encode())
+            self.assertEqual(normcase('\u03a9\u2126'.encode()),
+                             expected.encode())
+
+    def test_normcase_invalid_paths(self):
+        normcase = ntpath.normcase
+        self.assertEqual(normcase('abc\x00def'), 'abc\x00def')
+        self.assertEqual(normcase(b'abc\x00def'), b'abc\x00def')
+        self.assertEqual(normcase('\udfff'), '\udfff')
+        if sys.platform == 'win32':
+            path = b'ABC' + bytes(range(128, 256))
+            self.assertEqual(normcase(path), path.lower())
 
     def test_normpath(self):
         tester("ntpath.normpath('A//////././//.//B')", r'A\B')
@@ -327,13 +424,18 @@ def test_normpath(self):
 
         tester("ntpath.normpath('..')", r'..')
         tester("ntpath.normpath('.')", r'.')
+        tester("ntpath.normpath('c:.')", 'c:')
         tester("ntpath.normpath('')", r'.')
         tester("ntpath.normpath('/')", '\\')
         tester("ntpath.normpath('c:/')", 'c:\\')
         tester("ntpath.normpath('/../.././..')", '\\')
         tester("ntpath.normpath('c:/../../..')", 'c:\\')
+        tester("ntpath.normpath('/./a/b')", r'\a\b')
+        tester("ntpath.normpath('c:/./a/b')", r'c:\a\b')
         tester("ntpath.normpath('../.././..')", r'..\..\..')
         tester("ntpath.normpath('K:../.././..')", r'K:..\..\..')
+        tester("ntpath.normpath('./a/b')", r'a\b')
+        tester("ntpath.normpath('c:./a/b')", r'c:a\b')
         tester("ntpath.normpath('C:////a/b')", r'C:\a\b')
         tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b')
 
@@ -354,6 +456,22 @@ def test_normpath(self):
         tester("ntpath.normpath('\\\\foo\\')", '\\\\foo\\')
         tester("ntpath.normpath('\\\\foo')", '\\\\foo')
         tester("ntpath.normpath('\\\\')", '\\\\')
+        tester("ntpath.normpath('//?/UNC/server/share/..')", '\\\\?\\UNC\\server\\share\\')
+
+    def test_normpath_invalid_paths(self):
+        normpath = ntpath.normpath
+        self.assertEqual(normpath('fo\x00o'), 'fo\x00o')
+        self.assertEqual(normpath(b'fo\x00o'), b'fo\x00o')
+        self.assertEqual(normpath('fo\x00o\\..\\bar'), 'bar')
+        self.assertEqual(normpath(b'fo\x00o\\..\\bar'), b'bar')
+        self.assertEqual(normpath('\udfff'), '\udfff')
+        self.assertEqual(normpath('\udfff\\..\\foo'), 'foo')
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, normpath, b'\xff')
+            self.assertRaises(UnicodeDecodeError, normpath, b'\xff\\..\\foo')
+        else:
+            self.assertEqual(normpath(b'\xff'), b'\xff')
+            self.assertEqual(normpath(b'\xff\\..\\foo'), b'foo')
 
     def test_realpath_curdir(self):
         expected = ntpath.normpath(os.getcwd())
@@ -363,6 +481,27 @@ def test_realpath_curdir(self):
         tester("ntpath.realpath('.\\.')", expected)
         tester("ntpath.realpath('\\'.join(['.'] * 100))", expected)
 
+    def test_realpath_curdir_strict(self):
+        expected = ntpath.normpath(os.getcwd())
+        tester("ntpath.realpath('.', strict=True)", expected)
+        tester("ntpath.realpath('./.', strict=True)", expected)
+        tester("ntpath.realpath('/'.join(['.'] * 100), strict=True)", expected)
+        tester("ntpath.realpath('.\\.', strict=True)", expected)
+        tester("ntpath.realpath('\\'.join(['.'] * 100), strict=True)", expected)
+
+    def test_realpath_curdir_missing_ok(self):
+        expected = ntpath.normpath(os.getcwd())
+        tester("ntpath.realpath('.', strict=ALLOW_MISSING)",
+               expected)
+        tester("ntpath.realpath('./.', strict=ALLOW_MISSING)",
+               expected)
+        tester("ntpath.realpath('/'.join(['.'] * 100), strict=ALLOW_MISSING)",
+               expected)
+        tester("ntpath.realpath('.\\.', strict=ALLOW_MISSING)",
+               expected)
+        tester("ntpath.realpath('\\'.join(['.'] * 100), strict=ALLOW_MISSING)",
+               expected)
+
     def test_realpath_pardir(self):
         expected = ntpath.normpath(os.getcwd())
         tester("ntpath.realpath('..')", ntpath.dirname(expected))
@@ -375,28 +514,59 @@ def test_realpath_pardir(self):
         tester("ntpath.realpath('\\'.join(['..'] * 50))",
                ntpath.splitdrive(expected)[0] + '\\')
 
+    def test_realpath_pardir_strict(self):
+        expected = ntpath.normpath(os.getcwd())
+        tester("ntpath.realpath('..', strict=True)", ntpath.dirname(expected))
+        tester("ntpath.realpath('../..', strict=True)",
+               ntpath.dirname(ntpath.dirname(expected)))
+        tester("ntpath.realpath('/'.join(['..'] * 50), strict=True)",
+               ntpath.splitdrive(expected)[0] + '\\')
+        tester("ntpath.realpath('..\\..', strict=True)",
+               ntpath.dirname(ntpath.dirname(expected)))
+        tester("ntpath.realpath('\\'.join(['..'] * 50), strict=True)",
+               ntpath.splitdrive(expected)[0] + '\\')
+
+    def test_realpath_pardir_missing_ok(self):
+        expected = ntpath.normpath(os.getcwd())
+        tester("ntpath.realpath('..', strict=ALLOW_MISSING)",
+               ntpath.dirname(expected))
+        tester("ntpath.realpath('../..', strict=ALLOW_MISSING)",
+               ntpath.dirname(ntpath.dirname(expected)))
+        tester("ntpath.realpath('/'.join(['..'] * 50), strict=ALLOW_MISSING)",
+               ntpath.splitdrive(expected)[0] + '\\')
+        tester("ntpath.realpath('..\\..', strict=ALLOW_MISSING)",
+               ntpath.dirname(ntpath.dirname(expected)))
+        tester("ntpath.realpath('\\'.join(['..'] * 50), strict=ALLOW_MISSING)",
+               ntpath.splitdrive(expected)[0] + '\\')
+
     @os_helper.skip_unless_symlink
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
-    def test_realpath_basic(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_basic(self, kwargs):
         ABSTFN = ntpath.abspath(os_helper.TESTFN)
         open(ABSTFN, "wb").close()
         self.addCleanup(os_helper.unlink, ABSTFN)
         self.addCleanup(os_helper.unlink, ABSTFN + "1")
 
         os.symlink(ABSTFN, ABSTFN + "1")
-        self.assertPathEqual(ntpath.realpath(ABSTFN + "1"), ABSTFN)
-        self.assertPathEqual(ntpath.realpath(os.fsencode(ABSTFN + "1")),
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "1", **kwargs), ABSTFN)
+        self.assertPathEqual(ntpath.realpath(os.fsencode(ABSTFN + "1"), **kwargs),
                          os.fsencode(ABSTFN))
 
         # gh-88013: call ntpath.realpath with binary drive name may raise a
         # TypeError. The drive should not exist to reproduce the bug.
         drives = {f"{c}:\\" for c in string.ascii_uppercase} - set(os.listdrives())
         d = drives.pop().encode()
-        self.assertEqual(ntpath.realpath(d), d)
+        self.assertEqual(ntpath.realpath(d, strict=False), d)
 
         # gh-106242: Embedded nulls and non-strict fallback to abspath
-        self.assertEqual(ABSTFN + "\0spam",
-                         ntpath.realpath(os_helper.TESTFN + "\0spam", strict=False))
+        if kwargs:
+            with self.assertRaises(OSError):
+                ntpath.realpath(os_helper.TESTFN + "\0spam",
+                                **kwargs)
+        else:
+            self.assertEqual(ABSTFN + "\0spam",
+                                ntpath.realpath(os_helper.TESTFN + "\0spam", **kwargs))
 
     @os_helper.skip_unless_symlink
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
@@ -408,22 +578,78 @@ def test_realpath_strict(self):
         self.addCleanup(os_helper.unlink, ABSTFN)
         self.assertRaises(FileNotFoundError, ntpath.realpath, ABSTFN, strict=True)
         self.assertRaises(FileNotFoundError, ntpath.realpath, ABSTFN + "2", strict=True)
+
+    @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
+    def test_realpath_invalid_paths(self):
+        realpath = ntpath.realpath
+        ABSTFN = ntpath.abspath(os_helper.TESTFN)
+        ABSTFNb = os.fsencode(ABSTFN)
+        path = ABSTFN + '\x00'
+        # gh-106242: Embedded nulls and non-strict fallback to abspath
+        self.assertEqual(realpath(path, strict=False), path)
         # gh-106242: Embedded nulls should raise OSError (not ValueError)
-        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "\0spam", strict=True)
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+        path = ABSTFNb + b'\x00'
+        self.assertEqual(realpath(path, strict=False), path)
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+        path = ABSTFN + '\\nonexistent\\x\x00'
+        self.assertEqual(realpath(path, strict=False), path)
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+        path = ABSTFNb + b'\\nonexistent\\x\x00'
+        self.assertEqual(realpath(path, strict=False), path)
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+        path = ABSTFN + '\x00\\..'
+        self.assertEqual(realpath(path, strict=False), os.getcwd())
+        self.assertEqual(realpath(path, strict=True), os.getcwd())
+        self.assertEqual(realpath(path, strict=ALLOW_MISSING), os.getcwd())
+        path = ABSTFNb + b'\x00\\..'
+        self.assertEqual(realpath(path, strict=False), os.getcwdb())
+        self.assertEqual(realpath(path, strict=True), os.getcwdb())
+        self.assertEqual(realpath(path, strict=ALLOW_MISSING), os.getcwdb())
+        path = ABSTFN + '\\nonexistent\\x\x00\\..'
+        self.assertEqual(realpath(path, strict=False), ABSTFN + '\\nonexistent')
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertEqual(realpath(path, strict=ALLOW_MISSING), ABSTFN + '\\nonexistent')
+        path = ABSTFNb + b'\\nonexistent\\x\x00\\..'
+        self.assertEqual(realpath(path, strict=False), ABSTFNb + b'\\nonexistent')
+        self.assertRaises(OSError, realpath, path, strict=True)
+        self.assertEqual(realpath(path, strict=ALLOW_MISSING), ABSTFNb + b'\\nonexistent')
+
+    @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_invalid_unicode_paths(self, kwargs):
+        realpath = ntpath.realpath
+        ABSTFN = ntpath.abspath(os_helper.TESTFN)
+        ABSTFNb = os.fsencode(ABSTFN)
+        path = ABSTFNb + b'\xff'
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        path = ABSTFNb + b'\\nonexistent\\\xff'
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        path = ABSTFNb + b'\xff\\..'
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        path = ABSTFNb + b'\\nonexistent\\\xff\\..'
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
+        self.assertRaises(UnicodeDecodeError, realpath, path, **kwargs)
 
     @os_helper.skip_unless_symlink
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
-    def test_realpath_relative(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_relative(self, kwargs):
         ABSTFN = ntpath.abspath(os_helper.TESTFN)
         open(ABSTFN, "wb").close()
         self.addCleanup(os_helper.unlink, ABSTFN)
         self.addCleanup(os_helper.unlink, ABSTFN + "1")
 
         os.symlink(ABSTFN, ntpath.relpath(ABSTFN + "1"))
-        self.assertPathEqual(ntpath.realpath(ABSTFN + "1"), ABSTFN)
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "1", **kwargs), ABSTFN)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @os_helper.skip_unless_symlink
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
     def test_realpath_broken_symlinks(self):
@@ -574,7 +800,62 @@ def test_realpath_symlink_loops_strict(self):
 
     @os_helper.skip_unless_symlink
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
-    def test_realpath_symlink_prefix(self):
+    def test_realpath_symlink_loops_raise(self):
+        # Symlink loops raise OSError in ALLOW_MISSING mode
+        ABSTFN = ntpath.abspath(os_helper.TESTFN)
+        self.addCleanup(os_helper.unlink, ABSTFN)
+        self.addCleanup(os_helper.unlink, ABSTFN + "1")
+        self.addCleanup(os_helper.unlink, ABSTFN + "2")
+        self.addCleanup(os_helper.unlink, ABSTFN + "y")
+        self.addCleanup(os_helper.unlink, ABSTFN + "c")
+        self.addCleanup(os_helper.unlink, ABSTFN + "a")
+        self.addCleanup(os_helper.unlink, ABSTFN + "x")
+
+        os.symlink(ABSTFN, ABSTFN)
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN, strict=ALLOW_MISSING)
+
+        os.symlink(ABSTFN + "1", ABSTFN + "2")
+        os.symlink(ABSTFN + "2", ABSTFN + "1")
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "1",
+                            strict=ALLOW_MISSING)
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "2",
+                            strict=ALLOW_MISSING)
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "1\\x",
+                            strict=ALLOW_MISSING)
+
+        # Windows eliminates '..' components before resolving links;
+        # realpath is not expected to raise if this removes the loop.
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\.."),
+                             ntpath.dirname(ABSTFN))
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\..\\x"),
+                             ntpath.dirname(ABSTFN) + "\\x")
+
+        os.symlink(ABSTFN + "x", ABSTFN + "y")
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "1\\..\\"
+                                             + ntpath.basename(ABSTFN) + "y"),
+                             ABSTFN + "x")
+        self.assertRaises(
+            OSError, ntpath.realpath,
+            ABSTFN + "1\\..\\" + ntpath.basename(ABSTFN) + "1",
+            strict=ALLOW_MISSING)
+
+        os.symlink(ntpath.basename(ABSTFN) + "a\\b", ABSTFN + "a")
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "a",
+                            strict=ALLOW_MISSING)
+
+        os.symlink("..\\" + ntpath.basename(ntpath.dirname(ABSTFN))
+                + "\\" + ntpath.basename(ABSTFN) + "c", ABSTFN + "c")
+        self.assertRaises(OSError, ntpath.realpath, ABSTFN + "c",
+                            strict=ALLOW_MISSING)
+
+        # Test using relative path as well.
+        self.assertRaises(OSError, ntpath.realpath, ntpath.basename(ABSTFN),
+                            strict=ALLOW_MISSING)
+
+    @os_helper.skip_unless_symlink
+    @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_symlink_prefix(self, kwargs):
         ABSTFN = ntpath.abspath(os_helper.TESTFN)
         self.addCleanup(os_helper.unlink, ABSTFN + "3")
         self.addCleanup(os_helper.unlink, "\\\\?\\" + ABSTFN + "3.")
@@ -589,9 +870,9 @@ def test_realpath_symlink_prefix(self):
             f.write(b'1')
         os.symlink("\\\\?\\" + ABSTFN + "3.", ABSTFN + "3.link")
 
-        self.assertPathEqual(ntpath.realpath(ABSTFN + "3link"),
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "3link", **kwargs),
                              ABSTFN + "3")
-        self.assertPathEqual(ntpath.realpath(ABSTFN + "3.link"),
+        self.assertPathEqual(ntpath.realpath(ABSTFN + "3.link", **kwargs),
                              "\\\\?\\" + ABSTFN + "3.")
 
         # Resolved paths should be usable to open target files
@@ -601,14 +882,17 @@ def test_realpath_symlink_prefix(self):
             self.assertEqual(f.read(), b'1')
 
         # When the prefix is included, it is not stripped
-        self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3link"),
+        self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3link", **kwargs),
                              "\\\\?\\" + ABSTFN + "3")
-        self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3.link"),
+        self.assertPathEqual(ntpath.realpath("\\\\?\\" + ABSTFN + "3.link", **kwargs),
                              "\\\\?\\" + ABSTFN + "3.")
 
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
     def test_realpath_nul(self):
         tester("ntpath.realpath('NUL')", r'\\.\NUL')
+        tester("ntpath.realpath('NUL', strict=False)", r'\\.\NUL')
+        tester("ntpath.realpath('NUL', strict=True)", r'\\.\NUL')
+        tester("ntpath.realpath('NUL', strict=ALLOW_MISSING)", r'\\.\NUL')
 
     @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
     @unittest.skipUnless(HAVE_GETSHORTPATHNAME, 'need _getshortpathname')
@@ -632,14 +916,66 @@ def test_realpath_cwd(self):
 
         self.assertPathEqual(test_file_long, ntpath.realpath(test_file_short))
 
-        with os_helper.change_cwd(test_dir_long):
-            self.assertPathEqual(test_file_long, ntpath.realpath("file.txt"))
-        with os_helper.change_cwd(test_dir_long.lower()):
-            self.assertPathEqual(test_file_long, ntpath.realpath("file.txt"))
-        with os_helper.change_cwd(test_dir_short):
-            self.assertPathEqual(test_file_long, ntpath.realpath("file.txt"))
+        for kwargs in {}, {'strict': True}, {'strict': ALLOW_MISSING}:
+            with self.subTest(**kwargs):
+                with os_helper.change_cwd(test_dir_long):
+                    self.assertPathEqual(
+                        test_file_long,
+                        ntpath.realpath("file.txt", **kwargs))
+                with os_helper.change_cwd(test_dir_long.lower()):
+                    self.assertPathEqual(
+                        test_file_long,
+                        ntpath.realpath("file.txt", **kwargs))
+                with os_helper.change_cwd(test_dir_short):
+                    self.assertPathEqual(
+                        test_file_long,
+                        ntpath.realpath("file.txt", **kwargs))
+
+    @unittest.skipUnless(HAVE_GETFINALPATHNAME, 'need _getfinalpathname')
+    def test_realpath_permission(self):
+        # Test whether python can resolve the real filename of a
+        # shortened file name even if it does not have permission to access it.
+        ABSTFN = ntpath.realpath(os_helper.TESTFN)
+
+        os_helper.unlink(ABSTFN)
+        os_helper.rmtree(ABSTFN)
+        os.mkdir(ABSTFN)
+        self.addCleanup(os_helper.rmtree, ABSTFN)
+
+        test_file = ntpath.join(ABSTFN, "LongFileName123.txt")
+        test_file_short = ntpath.join(ABSTFN, "LONGFI~1.TXT")
+
+        with open(test_file, "wb") as f:
+            f.write(b"content")
+        # Automatic generation of short names may be disabled on
+        # NTFS volumes for the sake of performance.
+        # They're not supported at all on ReFS and exFAT.
+        p = subprocess.run(
+            # Try to set the short name manually.
+            ['fsutil.exe', 'file', 'setShortName', test_file, 'LONGFI~1.TXT'],
+            creationflags=subprocess.DETACHED_PROCESS
+        )
+
+        if p.returncode:
+            raise unittest.SkipTest('failed to set short name')
+
+        try:
+            self.assertPathEqual(test_file, ntpath.realpath(test_file_short))
+        except AssertionError:
+            raise unittest.SkipTest('the filesystem seems to lack support for short filenames')
+
+        # Deny the right to [S]YNCHRONIZE on the file to
+        # force nt._getfinalpathname to fail with ERROR_ACCESS_DENIED.
+        p = subprocess.run(
+            ['icacls.exe', test_file, '/deny', '*S-1-5-32-545:(S)'],
+            creationflags=subprocess.DETACHED_PROCESS
+        )
+
+        if p.returncode:
+            raise unittest.SkipTest('failed to deny access to the test file')
+
+        self.assertPathEqual(test_file, ntpath.realpath(test_file_short))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; ValueError: illegal environment variable name")
     def test_expandvars(self):
         with os_helper.EnvironmentVarGuard() as env:
             env.clear()
@@ -666,7 +1002,6 @@ def test_expandvars(self):
             tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
             tester('ntpath.expandvars("bar\'%foo%")', "bar\'%foo%")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; ValueError: illegal environment variable name")
     @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
     def test_expandvars_nonascii(self):
         def check(value, expected):
@@ -687,7 +1022,6 @@ def check(value, expected):
             check('%spam%bar', '%sbar' % nonascii)
             check('%{}%bar'.format(nonascii), 'ham%sbar' % nonascii)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_expanduser(self):
         tester('ntpath.expanduser("test")', 'test')
 
@@ -748,6 +1082,7 @@ def test_abspath(self):
         tester('ntpath.abspath("C:\\spam. . .")', "C:\\spam")
         tester('ntpath.abspath("C:/nul")',  "\\\\.\\nul")
         tester('ntpath.abspath("C:\\nul")', "\\\\.\\nul")
+        self.assertTrue(ntpath.isabs(ntpath.abspath("C:spam")))
         tester('ntpath.abspath("//..")',           "\\\\")
         tester('ntpath.abspath("//../")',          "\\\\..\\")
         tester('ntpath.abspath("//../..")',        "\\\\..\\")
@@ -781,6 +1116,26 @@ def test_abspath(self):
             drive, _ = ntpath.splitdrive(cwd_dir)
             tester('ntpath.abspath("/abc/")', drive + "\\abc")
 
+    def test_abspath_invalid_paths(self):
+        abspath = ntpath.abspath
+        if sys.platform == 'win32':
+            self.assertEqual(abspath("C:\x00"), ntpath.join(abspath("C:"), "\x00"))
+            self.assertEqual(abspath(b"C:\x00"), ntpath.join(abspath(b"C:"), b"\x00"))
+            self.assertEqual(abspath("\x00:spam"), "\x00:\\spam")
+            self.assertEqual(abspath(b"\x00:spam"), b"\x00:\\spam")
+        self.assertEqual(abspath('c:\\fo\x00o'), 'c:\\fo\x00o')
+        self.assertEqual(abspath(b'c:\\fo\x00o'), b'c:\\fo\x00o')
+        self.assertEqual(abspath('c:\\fo\x00o\\..\\bar'), 'c:\\bar')
+        self.assertEqual(abspath(b'c:\\fo\x00o\\..\\bar'), b'c:\\bar')
+        self.assertEqual(abspath('c:\\\udfff'), 'c:\\\udfff')
+        self.assertEqual(abspath('c:\\\udfff\\..\\foo'), 'c:\\foo')
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, abspath, b'c:\\\xff')
+            self.assertRaises(UnicodeDecodeError, abspath, b'c:\\\xff\\..\\foo')
+        else:
+            self.assertEqual(abspath(b'c:\\\xff'), b'c:\\\xff')
+            self.assertEqual(abspath(b'c:\\\xff\\..\\foo'), b'c:\\foo')
+
     def test_relpath(self):
         tester('ntpath.relpath("a")', 'a')
         tester('ntpath.relpath(ntpath.abspath("a"))', 'a')
@@ -809,43 +1164,47 @@ def test_commonpath(self):
         def check(paths, expected):
             tester(('ntpath.commonpath(%r)' % paths).replace('\\\\', '\\'),
                    expected)
-        def check_error(exc, paths):
-            self.assertRaises(exc, ntpath.commonpath, paths)
-            self.assertRaises(exc, ntpath.commonpath,
-                              [os.fsencode(p) for p in paths])
-
+        def check_error(paths, expected):
+            self.assertRaisesRegex(ValueError, expected, ntpath.commonpath, paths)
+            self.assertRaisesRegex(ValueError, expected, ntpath.commonpath, paths[::-1])
+            self.assertRaisesRegex(ValueError, expected, ntpath.commonpath,
+                                   [os.fsencode(p) for p in paths])
+            self.assertRaisesRegex(ValueError, expected, ntpath.commonpath,
+                                   [os.fsencode(p) for p in paths[::-1]])
+
+        self.assertRaises(TypeError, ntpath.commonpath, None)
         self.assertRaises(ValueError, ntpath.commonpath, [])
-        check_error(ValueError, ['C:\\Program Files', 'Program Files'])
-        check_error(ValueError, ['C:\\Program Files', 'C:Program Files'])
-        check_error(ValueError, ['\\Program Files', 'Program Files'])
-        check_error(ValueError, ['Program Files', 'C:\\Program Files'])
-        check(['C:\\Program Files'], 'C:\\Program Files')
-        check(['C:\\Program Files', 'C:\\Program Files'], 'C:\\Program Files')
-        check(['C:\\Program Files\\', 'C:\\Program Files'],
-              'C:\\Program Files')
-        check(['C:\\Program Files\\', 'C:\\Program Files\\'],
-              'C:\\Program Files')
-        check(['C:\\\\Program Files', 'C:\\Program Files\\\\'],
-              'C:\\Program Files')
-        check(['C:\\.\\Program Files', 'C:\\Program Files\\.'],
-              'C:\\Program Files')
-        check(['C:\\', 'C:\\bin'], 'C:\\')
-        check(['C:\\Program Files', 'C:\\bin'], 'C:\\')
-        check(['C:\\Program Files', 'C:\\Program Files\\Bar'],
-              'C:\\Program Files')
-        check(['C:\\Program Files\\Foo', 'C:\\Program Files\\Bar'],
-              'C:\\Program Files')
-        check(['C:\\Program Files', 'C:\\Projects'], 'C:\\')
-        check(['C:\\Program Files\\', 'C:\\Projects'], 'C:\\')
-
-        check(['C:\\Program Files\\Foo', 'C:/Program Files/Bar'],
-              'C:\\Program Files')
-        check(['C:\\Program Files\\Foo', 'c:/program files/bar'],
-              'C:\\Program Files')
-        check(['c:/program files/bar', 'C:\\Program Files\\Foo'],
-              'c:\\program files')
-
-        check_error(ValueError, ['C:\\Program Files', 'D:\\Program Files'])
+        self.assertRaises(ValueError, ntpath.commonpath, iter([]))
+
+        # gh-117381: Logical error messages
+        check_error(['C:\\Foo', 'C:Foo'], "Can't mix absolute and relative paths")
+        check_error(['C:\\Foo', '\\Foo'], "Paths don't have the same drive")
+        check_error(['C:\\Foo', 'Foo'], "Paths don't have the same drive")
+        check_error(['C:Foo', '\\Foo'], "Paths don't have the same drive")
+        check_error(['C:Foo', 'Foo'], "Paths don't have the same drive")
+        check_error(['\\Foo', 'Foo'], "Can't mix rooted and not-rooted paths")
+
+        check(['C:\\Foo'], 'C:\\Foo')
+        check(['C:\\Foo', 'C:\\Foo'], 'C:\\Foo')
+        check(['C:\\Foo\\', 'C:\\Foo'], 'C:\\Foo')
+        check(['C:\\Foo\\', 'C:\\Foo\\'], 'C:\\Foo')
+        check(['C:\\\\Foo', 'C:\\Foo\\\\'], 'C:\\Foo')
+        check(['C:\\.\\Foo', 'C:\\Foo\\.'], 'C:\\Foo')
+        check(['C:\\', 'C:\\baz'], 'C:\\')
+        check(['C:\\Bar', 'C:\\baz'], 'C:\\')
+        check(['C:\\Foo', 'C:\\Foo\\Baz'], 'C:\\Foo')
+        check(['C:\\Foo\\Bar', 'C:\\Foo\\Baz'], 'C:\\Foo')
+        check(['C:\\Bar', 'C:\\Baz'], 'C:\\')
+        check(['C:\\Bar\\', 'C:\\Baz'], 'C:\\')
+
+        check(['C:\\Foo\\Bar', 'C:/Foo/Baz'], 'C:\\Foo')
+        check(['C:\\Foo\\Bar', 'c:/foo/baz'], 'C:\\Foo')
+        check(['c:/foo/bar', 'C:\\Foo\\Baz'], 'c:\\foo')
+
+        # gh-117381: Logical error messages
+        check_error(['C:\\Foo', 'D:\\Foo'], "Paths don't have the same drive")
+        check_error(['C:\\Foo', 'D:Foo'], "Paths don't have the same drive")
+        check_error(['C:Foo', 'D:Foo'], "Paths don't have the same drive")
 
         check(['spam'], 'spam')
         check(['spam', 'spam'], 'spam')
@@ -859,20 +1218,16 @@ def check_error(exc, paths):
 
         check([''], '')
         check(['', 'spam\\alot'], '')
-        check_error(ValueError, ['', '\\spam\\alot'])
-
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          [b'C:\\Program Files', 'C:\\Program Files\\Foo'])
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          [b'C:\\Program Files', 'Program Files\\Foo'])
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          [b'Program Files', 'C:\\Program Files\\Foo'])
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          ['C:\\Program Files', b'C:\\Program Files\\Foo'])
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          ['C:\\Program Files', b'Program Files\\Foo'])
-        self.assertRaises(TypeError, ntpath.commonpath,
-                          ['Program Files', b'C:\\Program Files\\Foo'])
+
+        # gh-117381: Logical error messages
+        check_error(['', '\\spam\\alot'], "Can't mix rooted and not-rooted paths")
+
+        self.assertRaises(TypeError, ntpath.commonpath, [b'C:\\Foo', 'C:\\Foo\\Baz'])
+        self.assertRaises(TypeError, ntpath.commonpath, [b'C:\\Foo', 'Foo\\Baz'])
+        self.assertRaises(TypeError, ntpath.commonpath, [b'Foo', 'C:\\Foo\\Baz'])
+        self.assertRaises(TypeError, ntpath.commonpath, ['C:\\Foo', b'C:\\Foo\\Baz'])
+        self.assertRaises(TypeError, ntpath.commonpath, ['C:\\Foo', b'Foo\\Baz'])
+        self.assertRaises(TypeError, ntpath.commonpath, ['Foo', b'C:\\Foo\\Baz'])
 
     @unittest.skipIf(is_emscripten, "Emscripten cannot fstat unnamed files.")
     def test_sameopenfile(self):
@@ -924,6 +1279,74 @@ def test_ismount(self):
             self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$"))
             self.assertTrue(ntpath.ismount(b"\\\\localhost\\c$\\"))
 
+    def test_ismount_invalid_paths(self):
+        ismount = ntpath.ismount
+        self.assertFalse(ismount("c:\\\udfff"))
+        if sys.platform == 'win32':
+            self.assertRaises(ValueError, ismount, "c:\\\x00")
+            self.assertRaises(ValueError, ismount, b"c:\\\x00")
+            self.assertRaises(UnicodeDecodeError, ismount, b"c:\\\xff")
+        else:
+            self.assertFalse(ismount("c:\\\x00"))
+            self.assertFalse(ismount(b"c:\\\x00"))
+            self.assertFalse(ismount(b"c:\\\xff"))
+
+    def test_isreserved(self):
+        self.assertFalse(ntpath.isreserved(''))
+        self.assertFalse(ntpath.isreserved('.'))
+        self.assertFalse(ntpath.isreserved('..'))
+        self.assertFalse(ntpath.isreserved('/'))
+        self.assertFalse(ntpath.isreserved('/foo/bar'))
+        # A name that ends with a space or dot is reserved.
+        self.assertTrue(ntpath.isreserved('foo.'))
+        self.assertTrue(ntpath.isreserved('foo '))
+        # ASCII control characters are reserved.
+        self.assertTrue(ntpath.isreserved('\foo'))
+        # Wildcard characters, colon, and pipe are reserved.
+        self.assertTrue(ntpath.isreserved('foo*bar'))
+        self.assertTrue(ntpath.isreserved('foo?bar'))
+        self.assertTrue(ntpath.isreserved('foo"bar'))
+        self.assertTrue(ntpath.isreserved('foo<bar'))
+        self.assertTrue(ntpath.isreserved('foo>bar'))
+        self.assertTrue(ntpath.isreserved('foo:bar'))
+        self.assertTrue(ntpath.isreserved('foo|bar'))
+        # Case-insensitive DOS-device names are reserved.
+        self.assertTrue(ntpath.isreserved('nul'))
+        self.assertTrue(ntpath.isreserved('aux'))
+        self.assertTrue(ntpath.isreserved('prn'))
+        self.assertTrue(ntpath.isreserved('con'))
+        self.assertTrue(ntpath.isreserved('conin$'))
+        self.assertTrue(ntpath.isreserved('conout$'))
+        # COM/LPT + 1-9 or + superscript 1-3 are reserved.
+        self.assertTrue(ntpath.isreserved('COM1'))
+        self.assertTrue(ntpath.isreserved('LPT9'))
+        self.assertTrue(ntpath.isreserved('com\xb9'))
+        self.assertTrue(ntpath.isreserved('com\xb2'))
+        self.assertTrue(ntpath.isreserved('lpt\xb3'))
+        # DOS-device name matching ignores characters after a dot or
+        # a colon and also ignores trailing spaces.
+        self.assertTrue(ntpath.isreserved('NUL.txt'))
+        self.assertTrue(ntpath.isreserved('PRN  '))
+        self.assertTrue(ntpath.isreserved('AUX  .txt'))
+        self.assertTrue(ntpath.isreserved('COM1:bar'))
+        self.assertTrue(ntpath.isreserved('LPT9   :bar'))
+        # DOS-device names are only matched at the beginning
+        # of a path component.
+        self.assertFalse(ntpath.isreserved('bar.com9'))
+        self.assertFalse(ntpath.isreserved('bar.lpt9'))
+        # The entire path is checked, except for the drive.
+        self.assertTrue(ntpath.isreserved('c:/bar/baz/NUL'))
+        self.assertTrue(ntpath.isreserved('c:/NUL/bar/baz'))
+        self.assertFalse(ntpath.isreserved('//./NUL'))
+        # Bytes are supported.
+        self.assertFalse(ntpath.isreserved(b''))
+        self.assertFalse(ntpath.isreserved(b'.'))
+        self.assertFalse(ntpath.isreserved(b'..'))
+        self.assertFalse(ntpath.isreserved(b'/'))
+        self.assertFalse(ntpath.isreserved(b'/foo/bar'))
+        self.assertTrue(ntpath.isreserved(b'foo.'))
+        self.assertTrue(ntpath.isreserved(b'nul'))
+
     def assertEqualCI(self, s1, s2):
         """Assert that two strings are equal ignoring case differences."""
         self.assertEqual(s1.lower(), s2.lower())
@@ -974,6 +1397,13 @@ def test_isjunction(self):
                 self.assertFalse(ntpath.isjunction('tmpdir'))
                 self.assertPathEqual(ntpath.realpath('testjunc'), ntpath.realpath('tmpdir'))
 
+    def test_isfile_invalid_paths(self):
+        isfile = ntpath.isfile
+        self.assertIs(isfile('/tmp\udfffabcds'), False)
+        self.assertIs(isfile(b'/tmp\xffabcds'), False)
+        self.assertIs(isfile('/tmp\x00abcds'), False)
+        self.assertIs(isfile(b'/tmp\x00abcds'), False)
+
     @unittest.skipIf(sys.platform != 'win32', "drive letters are a windows concept")
     def test_isfile_driveletter(self):
         drive = os.environ.get('SystemDrive')
@@ -981,8 +1411,27 @@ def test_isfile_driveletter(self):
             raise unittest.SkipTest('SystemDrive is not defined or malformed')
         self.assertFalse(os.path.isfile('\\\\.\\' + drive))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipUnless(hasattr(os, 'pipe'), "need os.pipe()")
+    def test_isfile_anonymous_pipe(self):
+        pr, pw = os.pipe()
+        try:
+            self.assertFalse(ntpath.isfile(pr))
+        finally:
+            os.close(pr)
+            os.close(pw)
+
+    @unittest.skipIf(sys.platform != 'win32', "windows only")
+    def test_isfile_named_pipe(self):
+        import _winapi
+        named_pipe = f'//./PIPE/python_isfile_test_{os.getpid()}'
+        h = _winapi.CreateNamedPipe(named_pipe,
+                                    _winapi.PIPE_ACCESS_INBOUND,
+                                    0, 1, 0, 0, 0, 0)
+        try:
+            self.assertFalse(ntpath.isfile(named_pipe))
+        finally:
+            _winapi.CloseHandle(h)
+
     @unittest.skipIf(sys.platform != 'win32', "windows only")
     def test_con_device(self):
         self.assertFalse(os.path.isfile(r"\\.\CON"))
@@ -996,17 +1445,23 @@ def test_fast_paths_in_use(self):
         # There are fast paths of these functions implemented in posixmodule.c.
         # Confirm that they are being used, and not the Python fallbacks in
         # genericpath.py.
+        self.assertTrue(os.path.splitroot is nt._path_splitroot_ex)
+        self.assertFalse(inspect.isfunction(os.path.splitroot))
+        self.assertTrue(os.path.normpath is nt._path_normpath)
+        self.assertFalse(inspect.isfunction(os.path.normpath))
         self.assertTrue(os.path.isdir is nt._path_isdir)
         self.assertFalse(inspect.isfunction(os.path.isdir))
         self.assertTrue(os.path.isfile is nt._path_isfile)
         self.assertFalse(inspect.isfunction(os.path.isfile))
         self.assertTrue(os.path.islink is nt._path_islink)
         self.assertFalse(inspect.isfunction(os.path.islink))
+        self.assertTrue(os.path.isjunction is nt._path_isjunction)
+        self.assertFalse(inspect.isfunction(os.path.isjunction))
         self.assertTrue(os.path.exists is nt._path_exists)
         self.assertFalse(inspect.isfunction(os.path.exists))
+        self.assertTrue(os.path.lexists is nt._path_lexists)
+        self.assertFalse(inspect.isfunction(os.path.lexists))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(os.name != 'nt', "Dev Drives only exist on Win32")
     def test_isdevdrive(self):
         # Result may be True or False, but shouldn't raise
@@ -1032,18 +1487,6 @@ class NtCommonTest(test_genericpath.CommonTest, unittest.TestCase):
     pathmodule = ntpath
     attributes = ['relpath']
 
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        # TODO: RUSTPYTHON, ValueError: illegal environment variable name
-        @unittest.expectedFailure
-        def test_expandvars(self):  # TODO: RUSTPYTHON; remove when done
-            super().test_expandvars()
-
-        # TODO: RUSTPYTHON, ValueError: illegal environment variable name
-        @unittest.expectedFailure
-        def test_expandvars_nonascii(self):  # TODO: RUSTPYTHON; remove when done
-            super().test_expandvars_nonascii()
-
 
 class PathLikeTests(NtpathTestCase):
 
@@ -1059,12 +1502,8 @@ def setUp(self):
     def _check_function(self, func):
         self.assertPathEqual(func(self.file_path), func(self.file_name))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: 'ωω' != 'ωΩ'")
     def test_path_normcase(self):
         self._check_function(self.path.normcase)
-        if sys.platform == 'win32':
-            self.assertEqual(ntpath.normcase('\u03a9\u2126'), 'ωΩ')
-            self.assertEqual(ntpath.normcase('abc\x00def'), 'abc\x00def')
 
     def test_path_isabs(self):
         self._check_function(self.path.isabs)
diff --git a/Lib/test/test_opcache.py b/Lib/test/test_opcache.py
index 8f1f8764b1..aeb4de6caa 100644
--- a/Lib/test/test_opcache.py
+++ b/Lib/test/test_opcache.py
@@ -1,4 +1,61 @@
+import copy
+import pickle
+import dis
+import threading
+import types
 import unittest
+from test.support import threading_helper, check_impl_detail, requires_specialization
+from test.support.import_helper import import_module
+
+# Skip this module on other interpreters, it is cpython specific:
+if check_impl_detail(cpython=False):
+    raise unittest.SkipTest('implementation detail specific to cpython')
+
+_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
+
+
+class TestBase(unittest.TestCase):
+    def assert_specialized(self, f, opname):
+        instructions = dis.get_instructions(f, adaptive=True)
+        opnames = {instruction.opname for instruction in instructions}
+        self.assertIn(opname, opnames)
+
+
+class TestLoadSuperAttrCache(unittest.TestCase):
+    def test_descriptor_not_double_executed_on_spec_fail(self):
+        calls = []
+        class Descriptor:
+            def __get__(self, instance, owner):
+                calls.append((instance, owner))
+                return lambda: 1
+
+        class C:
+            d = Descriptor()
+
+        class D(C):
+            def f(self):
+                return super().d()
+
+        d = D()
+
+        self.assertEqual(d.f(), 1)  # warmup
+        calls.clear()
+        self.assertEqual(d.f(), 1)  # try to specialize
+        self.assertEqual(calls, [(d, D)])
 
 
 class TestLoadAttrCache(unittest.TestCase):
@@ -177,8 +234,6 @@ def f():
         for _ in range(1025):
             self.assertFalse(f())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_load_shadowing_slot_should_raise_type_error(self):
         class Class:
             __slots__ = ("slot",)
@@ -197,8 +252,6 @@ def f(o):
             with self.assertRaises(TypeError):
                 f(o)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_store_shadowing_slot_should_raise_type_error(self):
         class Class:
             __slots__ = ("slot",)
@@ -216,7 +269,6 @@ def f(o):
             with self.assertRaises(TypeError):
                 f(o)
 
-    @unittest.skip("TODO: RUSTPYTHON")
     def test_load_borrowed_slot_should_not_crash(self):
         class Class:
             __slots__ = ("slot",)
@@ -233,7 +285,6 @@ def f(o):
             with self.assertRaises(TypeError):
                 f(o)
 
-    @unittest.skip("TODO: RUSTPYTHON")
     def test_store_borrowed_slot_should_not_crash(self):
         class Class:
             __slots__ = ("slot",)
@@ -435,6 +486,693 @@ def f():
             self.assertFalse(f())
 
 
+class TestCallCache(TestBase):
+    def test_too_many_defaults_0(self):
+        def f():
+            pass
+
+        f.__defaults__ = (None,)
+        for _ in range(1025):
+            f()
+
+    def test_too_many_defaults_1(self):
+        def f(x):
+            pass
+
+        f.__defaults__ = (None, None)
+        for _ in range(1025):
+            f(None)
+            f()
+
+    def test_too_many_defaults_2(self):
+        def f(x, y):
+            pass
+
+        f.__defaults__ = (None, None, None)
+        for _ in range(1025):
+            f(None, None)
+            f(None)
+            f()
+
+    @disabling_optimizer
+    @requires_specialization
+    def test_assign_init_code(self):
+        class MyClass:
+            def __init__(self):
+                pass
+
+        def instantiate():
+            return MyClass()
+
+        # Trigger specialization
+        for _ in range(1025):
+            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
+        MyClass.__init__.__code__ = count_args.__code__
+        instantiate()
+
+
+@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
+    def assert_races_do_not_crash(
+        self, opname, get_items, read, write, *, check_items=False
+    ):
+        # This might need a few dozen loops in some cases:
+        for _ in range(self.LOOPS):
+            items = get_items()
+            # Reset:
+            if check_items:
+                for item in items:
+                    item.__code__ = item.__code__.replace()
+            else:
+                read.__code__ = read.__code__.replace()
+            # Specialize:
+            for _ in range(self.WARMUPS):
+                read(items)
+            if check_items:
+                for item in items:
+                    self.assert_specialized(item, opname)
+            else:
+                self.assert_specialized(read, opname)
+            # Create writers:
+            writers = []
+            for _ in range(self.WRITERS):
+                writer = threading.Thread(target=write, args=[items])
+                writers.append(writer)
+            # Run:
+            for writer in writers:
+                writer.start()
+            read(items)  # BOOM!
+            for writer in writers:
+                writer.join()
+
+    def test_binary_subscr_getitem(self):
+        def get_items():
+            class C:
+                __getitem__ = lambda self, item: None
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item[None]
+                except TypeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    del item.__getitem__
+                except AttributeError:
+                    pass
+                type(item).__getitem__ = lambda self, item: None
+
+        opname = "BINARY_SUBSCR_GETITEM"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_binary_subscr_list_int(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = [None]
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item[0]
+                except IndexError:
+                    pass
+
+        def write(items):
+            for item in items:
+                item.clear()
+                item.append(None)
+
+        opname = "BINARY_SUBSCR_LIST_INT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_for_iter_gen(self):
+        def get_items():
+            def g():
+                yield
+                yield
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = g()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    for _ in item:
+                        break
+                except ValueError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    for _ in item:
+                        break
+                except ValueError:
+                    pass
+
+        opname = "FOR_ITER_GEN"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_for_iter_list(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = [None]
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                for item in item:
+                    break
+
+        def write(items):
+            for item in items:
+                item.clear()
+                item.append(None)
+
+        opname = "FOR_ITER_LIST"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_class(self):
+        def get_items():
+            class C:
+                a = object()
+
+            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 = object()
+
+        opname = "LOAD_ATTR_CLASS"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_getattribute_overridden(self):
+        def get_items():
+            class C:
+                __getattribute__ = lambda self, name: None
+
+            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.__getattribute__
+                except AttributeError:
+                    pass
+                type(item).__getattribute__ = lambda self, name: None
+
+        opname = "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_instance_value(self):
+        def get_items():
+            class C:
+                pass
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                item.a = None
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item.a
+
+        def write(items):
+            for item in items:
+                item.__dict__[None] = None
+
+        opname = "LOAD_ATTR_INSTANCE_VALUE"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_method_lazy_dict(self):
+        def get_items():
+            class C(Exception):
+                m = lambda self: None
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item.m()
+                except AttributeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    del item.m
+                except AttributeError:
+                    pass
+                type(item).m = lambda self: None
+
+        opname = "LOAD_ATTR_METHOD_LAZY_DICT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_method_no_dict(self):
+        def get_items():
+            class C:
+                __slots__ = ()
+                m = lambda self: None
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item.m()
+                except AttributeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    del item.m
+                except AttributeError:
+                    pass
+                type(item).m = lambda self: None
+
+        opname = "LOAD_ATTR_METHOD_NO_DICT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_method_with_values(self):
+        def get_items():
+            class C:
+                m = lambda self: None
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item.m()
+                except AttributeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                try:
+                    del item.m
+                except AttributeError:
+                    pass
+                type(item).m = lambda self: None
+
+        opname = "LOAD_ATTR_METHOD_WITH_VALUES"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_module(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = types.ModuleType("<item>")
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item.__name__
+                except AttributeError:
+                    pass
+
+        def write(items):
+            for item in items:
+                d = item.__dict__.copy()
+                item.__dict__.clear()
+                item.__dict__.update(d)
+
+        opname = "LOAD_ATTR_MODULE"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_property(self):
+        def get_items():
+            class C:
+                a = property(lambda self: None)
+
+            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 type(item).a
+                except AttributeError:
+                    pass
+                type(item).a = property(lambda self: None)
+
+        opname = "LOAD_ATTR_PROPERTY"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_attr_with_hint(self):
+        def get_items():
+            class C:
+                pass
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                item.a = None
+                # Resize into a combined unicode dict:
+                for i in range(29):
+                    setattr(item, f"_{i}", None)
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item.a
+
+        def write(items):
+            for item in items:
+                item.__dict__[None] = None
+
+        opname = "LOAD_ATTR_WITH_HINT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_load_global_module(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = eval("lambda: x", {"x": None})
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item()
+
+        def write(items):
+            for item in items:
+                item.__globals__[None] = None
+
+        opname = "LOAD_GLOBAL_MODULE"
+        self.assert_races_do_not_crash(
+            opname, get_items, read, write, check_items=True
+        )
+
+    def test_store_attr_instance_value(self):
+        def get_items():
+            class C:
+                pass
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item.a = None
+
+        def write(items):
+            for item in items:
+                item.__dict__[None] = None
+
+        opname = "STORE_ATTR_INSTANCE_VALUE"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_store_attr_with_hint(self):
+        def get_items():
+            class C:
+                pass
+
+            items = []
+            for _ in range(self.ITEMS):
+                item = C()
+                # Resize into a combined unicode dict:
+                for i in range(29):
+                    setattr(item, f"_{i}", None)
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                item.a = None
+
+        def write(items):
+            for item in items:
+                item.__dict__[None] = None
+
+        opname = "STORE_ATTR_WITH_HINT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_store_subscr_list_int(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = [None]
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    item[0] = None
+                except IndexError:
+                    pass
+
+        def write(items):
+            for item in items:
+                item.clear()
+                item.append(None)
+
+        opname = "STORE_SUBSCR_LIST_INT"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+    def test_unpack_sequence_list(self):
+        def get_items():
+            items = []
+            for _ in range(self.ITEMS):
+                item = [None]
+                items.append(item)
+            return items
+
+        def read(items):
+            for item in items:
+                try:
+                    [_] = item
+                except ValueError:
+                    pass
+
+        def write(items):
+            for item in items:
+                item.clear()
+                item.append(None)
+
+        opname = "UNPACK_SEQUENCE_LIST"
+        self.assert_races_do_not_crash(opname, get_items, read, write)
+
+class C:
+    pass
+
+@requires_specialization
+class TestInstanceDict(unittest.TestCase):
+
+    def setUp(self):
+        c = C()
+        c.a, c.b, c.c = 0,0,0
+
+    def test_values_on_instance(self):
+        c = C()
+        c.a = 1
+        C().b = 2
+        c.c = 3
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c),
+            (1, '<NULL>', 3)
+        )
+
+    def test_dict_materialization(self):
+        c = C()
+        c.a = 1
+        c.b = 2
+        c.__dict__
+        self.assertEqual(c.__dict__, {"a":1, "b": 2})
+
+    def test_dict_dematerialization(self):
+        c = C()
+        c.a = 1
+        c.b = 2
+        c.__dict__
+        for _ in range(100):
+            c.a
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c),
+            (1, 2, '<NULL>')
+        )
+
+    def test_dict_dematerialization_multiple_refs(self):
+        c = C()
+        c.a = 1
+        c.b = 2
+        d = c.__dict__
+        for _ in range(100):
+            c.a
+        self.assertIs(c.__dict__, d)
+
+    def test_dict_dematerialization_copy(self):
+        c = C()
+        c.a = 1
+        c.b = 2
+        c2 = copy.copy(c)
+        for _ in range(100):
+            c.a
+            c2.a
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c),
+            (1, 2, '<NULL>')
+        )
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c2),
+            (1, 2, '<NULL>')
+        )
+        c3 = copy.deepcopy(c)
+        for _ in range(100):
+            c.a
+            c3.a
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c),
+            (1, 2, '<NULL>')
+        )
+        #NOTE -- c3.__dict__ does not de-materialize
+
+    def test_dict_dematerialization_pickle(self):
+        c = C()
+        c.a = 1
+        c.b = 2
+        c2 = pickle.loads(pickle.dumps(c))
+        for _ in range(100):
+            c.a
+            c2.a
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c),
+            (1, 2, '<NULL>')
+        )
+        self.assertEqual(
+            _testinternalcapi.get_object_dict_values(c2),
+            (1, 2, '<NULL>')
+        )
+
+    def test_dict_dematerialization_subclass(self):
+        class D(dict): pass
+        c = C()
+        c.a = 1
+        c.b = 2
+        c.__dict__ = D(c.__dict__)
+        for _ in range(100):
+            c.a
+        self.assertIs(
+            _testinternalcapi.get_object_dict_values(c),
+            None
+        )
+        self.assertEqual(
+            c.__dict__,
+            {'a':1, 'b':2}
+        )
+
+    def test_store_attr_with_hint(self):
+        # gh-133441: Regression test for STORE_ATTR_WITH_HINT bytecode
+        class Node:
+            def __init__(self):
+                self.parents = {}
+
+            def __setstate__(self, data_dict):
+                self.__dict__ = data_dict
+                self.parents = {}
+
+        class Dict(dict):
+            pass
+
+        obj = Node()
+        obj.__setstate__({'parents': {}})
+        obj.__setstate__({'parents': {}})
+        obj.__setstate__(Dict({'parents': {}}))
+
+
 if __name__ == "__main__":
-    import unittest
     unittest.main()
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index 1db738d228..05b7a7462d 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -1,6 +1,9 @@
 import unittest
+import inspect
 import pickle
 import sys
+from decimal import Decimal
+from fractions import Fraction
 
 from test import support
 from test.support import import_helper
@@ -508,6 +511,44 @@ def __getitem__(self, other): return 5  # so that C is a sequence
         self.assertEqual(operator.ixor     (c, 5), "ixor")
         self.assertEqual(operator.iconcat  (c, c), "iadd")
 
+    def test_iconcat_without_getitem(self):
+        operator = self.module
+
+        msg = "'int' object can't be concatenated"
+        with self.assertRaisesRegex(TypeError, msg):
+            operator.iconcat(1, 0.5)
+
+    def test_index(self):
+        operator = self.module
+        class X:
+            def __index__(self):
+                return 1
+
+        self.assertEqual(operator.index(X()), 1)
+        self.assertEqual(operator.index(0), 0)
+        self.assertEqual(operator.index(1), 1)
+        self.assertEqual(operator.index(2), 2)
+        with self.assertRaises((AttributeError, TypeError)):
+            operator.index(1.5)
+        with self.assertRaises((AttributeError, TypeError)):
+            operator.index(Fraction(3, 7))
+        with self.assertRaises((AttributeError, TypeError)):
+            operator.index(Decimal(1))
+        with self.assertRaises((AttributeError, TypeError)):
+            operator.index(None)
+
+    def test_not_(self):
+        operator = self.module
+        class C:
+            def __bool__(self):
+                raise SyntaxError
+        self.assertRaises(TypeError, operator.not_)
+        self.assertRaises(SyntaxError, operator.not_, C())
+        self.assertFalse(operator.not_(5))
+        self.assertFalse(operator.not_([0]))
+        self.assertTrue(operator.not_(0))
+        self.assertTrue(operator.not_([]))
+
     def test_length_hint(self):
         operator = self.module
         class X(object):
@@ -533,6 +574,13 @@ def __length_hint__(self):
         with self.assertRaises(LookupError):
             operator.length_hint(X(LookupError))
 
+        class Y: pass
+
+        msg = "'str' object cannot be interpreted as an integer"
+        with self.assertRaisesRegex(TypeError, msg):
+            operator.length_hint(X(2), "abc")
+        self.assertEqual(operator.length_hint(Y(), 10), 10)
+
     def test_call(self):
         operator = self.module
 
@@ -555,6 +603,31 @@ def test_dunder_is_original(self):
             if dunder:
                 self.assertIs(dunder, orig)
 
+    @support.requires_docstrings
+    def test_attrgetter_signature(self):
+        operator = self.module
+        sig = inspect.signature(operator.attrgetter)
+        self.assertEqual(str(sig), '(attr, /, *attrs)')
+        sig = inspect.signature(operator.attrgetter('x', 'z', 'y'))
+        self.assertEqual(str(sig), '(obj, /)')
+
+    @support.requires_docstrings
+    def test_itemgetter_signature(self):
+        operator = self.module
+        sig = inspect.signature(operator.itemgetter)
+        self.assertEqual(str(sig), '(item, /, *items)')
+        sig = inspect.signature(operator.itemgetter(2, 3, 5))
+        self.assertEqual(str(sig), '(obj, /)')
+
+    @support.requires_docstrings
+    def test_methodcaller_signature(self):
+        operator = self.module
+        sig = inspect.signature(operator.methodcaller)
+        self.assertEqual(str(sig), '(name, /, *args, **kwargs)')
+        sig = inspect.signature(operator.methodcaller('foo', 2, y=3))
+        self.assertEqual(str(sig), '(obj, /)')
+
+
 class PyOperatorTestCase(OperatorTestCase, unittest.TestCase):
     module = py_operator
 
@@ -562,6 +635,21 @@ class PyOperatorTestCase(OperatorTestCase, unittest.TestCase):
 class COperatorTestCase(OperatorTestCase, unittest.TestCase):
     module = c_operator
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_attrgetter_signature(self):
+        super().test_attrgetter_signature()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_itemgetter_signature(self):
+        super().test_itemgetter_signature()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_methodcaller_signature(self):
+        super().test_methodcaller_signature()
+
 
 class OperatorPickleTestCase:
     def copy(self, obj, proto):
diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py
index 28b2744623..c68214961e 100644
--- a/Lib/test/test_optparse.py
+++ b/Lib/test/test_optparse.py
@@ -15,7 +15,7 @@
 from io import StringIO
 from test import support
 from test.support import os_helper
-
+from test.support.i18n_helper import TestTranslationsBase, update_translation_snapshots
 
 import optparse
 from optparse import make_option, Option, \
@@ -614,9 +614,9 @@ def test_float_default(self):
         self.parser.add_option(
             "-p", "--prob",
             help="blow up with probability PROB [default: %default]")
-        self.parser.set_defaults(prob=0.43)
+        self.parser.set_defaults(prob=0.25)
         expected_help = self.help_prefix + \
-            "  -p PROB, --prob=PROB  blow up with probability PROB [default: 0.43]\n"
+            "  -p PROB, --prob=PROB  blow up with probability PROB [default: 0.25]\n"
         self.assertHelp(self.parser, expected_help)
 
     def test_alt_expand(self):
@@ -1656,5 +1656,14 @@ def test__all__(self):
         support.check__all__(self, optparse, not_exported=not_exported)
 
 
+class TestTranslations(TestTranslationsBase):
+    def test_translations(self):
+        self.assertMsgidsEqual(optparse)
+
+
 if __name__ == '__main__':
+    # To regenerate translation snapshots
+    if len(sys.argv) > 1 and sys.argv[1] == '--snapshot-update':
+        update_translation_snapshots(optparse)
+        sys.exit(0)
     unittest.main()
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index 3b19d3d3cd..4755aef080 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -14,6 +14,7 @@
 import os
 import pickle
 import select
+import selectors
 import shutil
 import signal
 import socket
@@ -33,7 +34,7 @@
 from test.support import import_helper
 from test.support import os_helper
 from test.support import socket_helper
-from test.support import set_recursion_limit
+from test.support import infinite_recursion
 from test.support import warnings_helper
 from platform import win32_is_iot
 
@@ -55,8 +56,10 @@
 except (ImportError, AttributeError):
     all_users = []
 try:
+    import _testcapi
     from _testcapi import INT_MAX, PY_SSIZE_T_MAX
 except ImportError:
+    _testcapi = None
     INT_MAX = PY_SSIZE_T_MAX = sys.maxsize
 
 try:
@@ -184,7 +187,7 @@ 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(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."
     )
@@ -711,7 +714,6 @@ def check_file_attributes(self, result):
         self.assertTrue(isinstance(result.st_file_attributes, int))
         self.assertTrue(0 <= result.st_file_attributes <= 0xFFFFFFFF)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.stat return value doesnt have st_file_attributes attribute")
     @unittest.skipUnless(sys.platform == "win32",
                          "st_file_attributes is Win32 specific")
     def test_file_attributes(self):
@@ -733,7 +735,6 @@ def test_file_attributes(self):
             result.st_file_attributes & stat.FILE_ATTRIBUTE_DIRECTORY,
             stat.FILE_ATTRIBUTE_DIRECTORY)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.stat (PermissionError: [Errno 5] Access is denied.)")
     @unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
     def test_access_denied(self):
         # Default to FindFirstFile WIN32_FIND_DATA when access is
@@ -756,7 +757,6 @@ def test_access_denied(self):
         self.assertNotEqual(result.st_size, 0)
         self.assertTrue(os.path.isfile(fname))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.stat (PermissionError: [Errno 1] Incorrect function.)")
     @unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
     def test_stat_block_device(self):
         # bpo-38030: os.stat fails for block devices
@@ -814,7 +814,6 @@ def _test_utime(self, set_time, filename=None):
         self.assertEqual(st.st_atime_ns, atime_ns)
         self.assertEqual(st.st_mtime_ns, mtime_ns)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: 2.002003 != 1.002003 within 1e-06 delta (1.0000000000000002 difference))")
     def test_utime(self):
         def set_time(filename, ns):
             # test the ns keyword parameter
@@ -826,12 +825,12 @@ 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: RUSTCPYTHON os.utime() use `[Duration::from_secs_f64](https://doc.rust-lang.org/std/time/struct.Duration.html#method.try_from_secs_f64)`
+        # 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)
 
     def test_utime_by_indexed(self):
-        # pass times as floating point seconds as the second indexed parameter
+        # pass times as floating-point seconds as the second indexed parameter
         def set_time(filename, ns):
             atime_ns, mtime_ns = ns
             atime = self.ns_to_sec(atime_ns)
@@ -880,7 +879,6 @@ def set_time(filename, ns):
                 os.utime(name, dir_fd=dirfd, ns=ns)
         self._test_utime(set_time)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: 2.002003 != 1.002003 within 1e-06 delta (1.0000000000000002 difference))")
     def test_utime_directory(self):
         def set_time(filename, ns):
             # test calling os.utime() on a directory
@@ -909,20 +907,25 @@ def _test_utime_current(self, set_time):
         self.assertAlmostEqual(st.st_mtime, current,
                                delta=delta, msg=msg)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: 3359485824.516508 != 1679742912.516503 within 0.05 delta (1679742912.000005 difference) : st_time=3359485824.516508, current=1679742912.516503, dt=1679742912.000005)")
     def test_utime_current(self):
         def set_time(filename):
             # Set to the current time in the new way
             os.utime(self.fname)
         self._test_utime_current(set_time)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: 3359485824.5186944 != 1679742912.5186892 within 0.05 delta (1679742912.0000052 difference) : st_time=3359485824.5186944, current=1679742912.5186892, dt=1679742912.0000052)")
     def test_utime_current_old(self):
         def set_time(filename):
             # Set to the current time in the old explicit way.
             os.utime(self.fname, None)
         self._test_utime_current(set_time)
 
+    def test_utime_nonexistent(self):
+        now = time.time()
+        filename = 'nonexistent'
+        with self.assertRaises(FileNotFoundError) as cm:
+            os.utime(filename, (now, now))
+        self.assertEqual(cm.exception.filename, filename)
+
     def get_file_system(self, path):
         if sys.platform == 'win32':
             root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'
@@ -936,7 +939,6 @@ def get_file_system(self, path):
                 return buf.value
         # return None if the filesystem is unknown
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (ModuleNotFoundError: No module named '_ctypes')")
     def test_large_time(self):
         # Many filesystems are limited to the year 2038. At least, the test
         # pass with NTFS filesystem.
@@ -947,7 +949,6 @@ def test_large_time(self):
         os.utime(self.fname, (large, large))
         self.assertEqual(os.stat(self.fname).st_mtime, large)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: NotImplementedError not raised)")
     def test_utime_invalid_arguments(self):
         # seconds and nanoseconds parameters are mutually exclusive
         with self.assertRaises(ValueError):
@@ -1149,7 +1150,6 @@ def test_putenv_unsetenv(self):
                                   stdout=subprocess.PIPE, text=True)
             self.assertEqual(proc.stdout.rstrip(), repr(None))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: ValueError not raised by putenv)")
     # On OS X < 10.6, unsetenv() doesn't return a value (bpo-13415).
     @support.requires_mac_ver(10, 6)
     def test_putenv_unsetenv_error(self):
@@ -1574,7 +1574,7 @@ def test_walk_many_open_files(self):
     def test_walk_above_recursion_limit(self):
         depth = 50
         os.makedirs(os.path.join(self.walk_path, *(['d'] * depth)))
-        with set_recursion_limit(depth - 5):
+        with infinite_recursion(depth - 5):
             all = list(self.walk(self.walk_path))
 
         sub2_path = self.sub2_tree[0]
@@ -1671,6 +1671,9 @@ def test_yields_correct_dir_fd(self):
     @unittest.skipIf(
         support.is_emscripten, "Cannot dup stdout on Emscripten"
     )
+    @unittest.skipIf(
+        support.is_android, "dup return value is unpredictable on Android"
+    )
     def test_fd_leak(self):
         # Since we're opening a lot of FDs, we must be careful to avoid leaks:
         # we both check that calling fwalk() a large number of times doesn't
@@ -1684,10 +1687,29 @@ 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"
+    )
+    def test_fd_finalization(self):
+        # Check that close()ing the fwalk() generator closes FDs
+        def getfd():
+            fd = os.dup(1)
+            os.close(fd)
+            return fd
+        for topdown in (False, True):
+            old_fd = getfd()
+            it = self.fwalk(os_helper.TESTFN, topdown=topdown)
+            self.assertEqual(getfd(), old_fd)
+            next(it)
+            self.assertGreater(getfd(), old_fd)
+            it.close()
+            self.assertEqual(getfd(), old_fd)
+
     # fwalk() keeps file descriptors open
     test_walk_many_open_files = None
-    # fwalk() still uses recursion
-    test_walk_above_recursion_limit = None
 
 
 class BytesWalkTests(WalkTests):
@@ -1703,6 +1725,18 @@ 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):
     """Tests for os.walk() with bytes."""
@@ -1715,26 +1749,6 @@ def fwalk(self, top='.', *args, **kwargs):
             bdirs[:] = list(map(os.fsencode, dirs))
             bfiles[:] = list(map(os.fsencode, files))
 
-    # TODO: RUSTPYTHON (TypeError: Can't mix strings and bytes in path components)
-    @unittest.expectedFailure
-    def test_compare_to_walk(self):
-        super().test_compare_to_walk()
-
-    # TODO: RUSTPYTHON (TypeError: Can't mix strings and bytes in path components)
-    @unittest.expectedFailure
-    def test_dir_fd(self):
-        super().test_dir_fd()
-
-    # TODO: RUSTPYTHON (TypeError: Can't mix strings and bytes in path components)
-    @unittest.expectedFailure
-    def test_yields_correct_dir_fd(self):
-        super().test_yields_correct_dir_fd()
-
-    # TODO: RUSTPYTHON (TypeError: Can't mix strings and bytes in path components)
-    @unittest.expectedFailure
-    def test_walk_bottom_up(self):
-        super().test_walk_bottom_up()
-
 
 class MakedirTests(unittest.TestCase):
     def setUp(self):
@@ -1771,7 +1785,6 @@ def test_mode(self):
                 self.assertEqual(os.stat(path).st_mode & 0o777, 0o555)
                 self.assertEqual(os.stat(parent).st_mode & 0o777, 0o775)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.umask not implemented yet for all platforms")
     @unittest.skipIf(
         support.is_emscripten or support.is_wasi,
         "Emscripten's/WASI's umask is a stub."
@@ -1790,7 +1803,6 @@ def test_exist_ok_existing_directory(self):
         # Issue #25583: A drive root could raise PermissionError on Windows
         os.makedirs(os.path.abspath('/'), exist_ok=True)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.umask not implemented yet for all platforms")
     @unittest.skipIf(
         support.is_emscripten or support.is_wasi,
         "Emscripten's/WASI's umask is a stub."
@@ -1832,6 +1844,19 @@ def test_exist_ok_existing_regular_file(self):
         self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
         os.remove(path)
 
+    @unittest.skipUnless(os.name == 'nt', "requires Windows")
+    def test_win32_mkdir_700(self):
+        base = os_helper.TESTFN
+        path = os.path.abspath(os.path.join(os_helper.TESTFN, 'dir'))
+        os.mkdir(path, mode=0o700)
+        out = subprocess.check_output(["cacls.exe", path, "/s"], encoding="oem")
+        os.rmdir(path)
+        out = out.strip().rsplit(" ", 1)[1]
+        self.assertEqual(
+            out,
+            '"D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)"',
+        )
+
     def tearDown(self):
         path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
                             'dir4', 'dir5', 'dir6')
@@ -2064,7 +2089,6 @@ def test_urandom_failure(self):
             """
         assert_python_ok('-c', code)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON on Windows (ModuleNotFoundError: No module named 'os')")
     def test_urandom_fd_closed(self):
         # Issue #21207: urandom() should reopen its fd to /dev/urandom if
         # closed.
@@ -2079,7 +2103,6 @@ def test_urandom_fd_closed(self):
             """
         rc, out, err = assert_python_ok('-Sc', code)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (ModuleNotFoundError: No module named 'os'")
     def test_urandom_fd_reopened(self):
         # Issue #21207: urandom() should detect its fd to /dev/urandom
         # changed to something else, and reopen it.
@@ -2167,7 +2190,6 @@ def test_execv_with_bad_arglist(self):
         self.assertRaises(ValueError, os.execv, 'notepad', ('',))
         self.assertRaises(ValueError, os.execv, 'notepad', [''])
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.execve not implemented yet for all platforms")
     def test_execvpe_with_bad_arglist(self):
         self.assertRaises(ValueError, os.execvpe, 'notepad', [], None)
         self.assertRaises(ValueError, os.execvpe, 'notepad', [], {})
@@ -2227,7 +2249,6 @@ def test_internal_execvpe_str(self):
         if os.name != "nt":
             self._test_internal_execvpe(bytes)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.execve not implemented yet for all platforms")
     def test_execve_invalid_env(self):
         args = [sys.executable, '-c', 'pass']
 
@@ -2249,7 +2270,6 @@ def test_execve_invalid_env(self):
         with self.assertRaises(ValueError):
             os.execve(args[0], args, newenv)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.execve not implemented yet for all platforms")
     @unittest.skipUnless(sys.platform == "win32", "Win32-specific test")
     def test_execve_with_empty_path(self):
         # bpo-32890: Check GetLastError() misuse
@@ -2301,12 +2321,15 @@ def test_chmod(self):
 class TestInvalidFD(unittest.TestCase):
     singles = ["fchdir", "dup", "fdatasync", "fstat",
                "fstatvfs", "fsync", "tcgetpgrp", "ttyname"]
+    singles_fildes = {"fchdir", "fdatasync", "fsync"}
     #singles.append("close")
     #We omit close because it doesn't raise an exception on some platforms
     def get_single(f):
         def helper(self):
             if  hasattr(os, f):
                 self.check(getattr(os, f))
+                if f in self.singles_fildes:
+                    self.check_bool(getattr(os, f))
         return helper
     for f in singles:
         locals()["test_"+f] = get_single(f)
@@ -2320,9 +2343,17 @@ def check(self, f, *args, **kwargs):
             self.fail("%r didn't raise an OSError with a bad file descriptor"
                       % f)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: <function fdopen at 0x1caa19ae6c0> didn't raise an OSError with a bad file descriptor)")
+    def check_bool(self, f, *args, **kwargs):
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", RuntimeWarning)
+            for fd in False, True:
+                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")
 
     @unittest.skipUnless(hasattr(os, 'isatty'), 'test needs os.isatty()')
     def test_isatty(self):
@@ -2376,27 +2407,30 @@ 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.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: <builtin_function_or_method object at 0x1f330cd8e60> didn't raise an OSError with a bad file descriptor)")
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(hasattr(os, 'ftruncate'), 'test needs os.ftruncate()')
     def test_ftruncate(self):
         self.check(os.truncate, 0)
         self.check(os.ftruncate, 0)
+        self.check_bool(os.truncate, 0)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (OSError: [Errno 18] There are no more files.)")
     @unittest.skipUnless(hasattr(os, 'lseek'), 'test needs os.lseek()')
     def test_lseek(self):
         self.check(os.lseek, 0, 0)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (OSError: [Errno 18] There are no more files.)")
     @unittest.skipUnless(hasattr(os, 'read'), 'test needs os.read()')
     def test_read(self):
         self.check(os.read, 1)
@@ -2410,7 +2444,6 @@ def test_readv(self):
     def test_tcsetpgrpt(self):
         self.check(os.tcsetpgrp, 0)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (OSError: [Errno 18] There are no more files.)")
     @unittest.skipUnless(hasattr(os, 'write'), 'test needs os.write()')
     def test_write(self):
         self.check(os.write, b" ")
@@ -2419,7 +2452,6 @@ def test_write(self):
     def test_writev(self):
         self.check(os.writev, [b'abc'])
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.get_inheritable not implemented yet for all platforms")
     @support.requires_subprocess()
     def test_inheritable(self):
         self.check(os.get_inheritable)
@@ -2431,6 +2463,14 @@ 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')
 class LinkTests(unittest.TestCase):
@@ -2590,8 +2630,10 @@ def test_listdir(self):
         # test listdir without arguments
         current_directory = os.getcwd()
         try:
-            os.chdir(os.sep)
-            self.assertEqual(set(os.listdir()), set(os.listdir(os.sep)))
+            # The root directory is not readable on Android, so use a directory
+            # we created ourselves.
+            os.chdir(self.dir)
+            self.assertEqual(set(os.listdir()), expected)
         finally:
             os.chdir(current_directory)
 
@@ -2669,12 +2711,10 @@ def _kill(self, sig):
         os.kill(proc.pid, sig)
         self.assertEqual(proc.wait(), sig)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (ModuleNotFoundError: No module named '_ctypes')")
     def test_kill_sigterm(self):
         # SIGTERM doesn't mean anything special, but make sure it works
         self._kill(signal.SIGTERM)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (ModuleNotFoundError: No module named '_ctypes')")
     def test_kill_int(self):
         # os.kill on Windows can take an int which gets set as the exit code
         self._kill(100)
@@ -2733,8 +2773,7 @@ def test_CTRL_C_EVENT(self):
 
         self._kill_with_event(signal.CTRL_C_EVENT, "CTRL_C_EVENT")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_CTRL_BREAK_EVENT(self):
         self._kill_with_event(signal.CTRL_BREAK_EVENT, "CTRL_BREAK_EVENT")
@@ -3088,7 +3127,6 @@ def tearDown(self):
         if os.path.lexists(self.junction):
             os.unlink(self.junction)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AttributeError: module '_winapi' has no attribute 'CreateJunction')")
     def test_create_junction(self):
         _winapi.CreateJunction(self.junction_target, self.junction)
         self.assertTrue(os.path.lexists(self.junction))
@@ -3102,7 +3140,6 @@ def test_create_junction(self):
         self.assertEqual(os.path.normcase("\\\\?\\" + self.junction_target),
                          os.path.normcase(os.readlink(self.junction)))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AttributeError: module '_winapi' has no attribute 'CreateJunction')")
     def test_unlink_removes_junction(self):
         _winapi.CreateJunction(self.junction_target, self.junction)
         self.assertTrue(os.path.exists(self.junction))
@@ -3116,7 +3153,8 @@ class Win32NtTests(unittest.TestCase):
     def test_getfinalpathname_handles(self):
         nt = import_helper.import_module('nt')
         ctypes = import_helper.import_module('ctypes')
-        import ctypes.wintypes
+        # Ruff false positive -- it thinks we're redefining `ctypes` here
+        import ctypes.wintypes  # noqa: F811
 
         kernel = ctypes.WinDLL('Kernel32.dll', use_last_error=True)
         kernel.GetCurrentProcess.restype = ctypes.wintypes.HANDLE
@@ -3161,7 +3199,6 @@ def test_getfinalpathname_handles(self):
 
         self.assertEqual(0, handle_delta)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.stat (PermissionError: [Errno 5] Access is denied.)")
     @support.requires_subprocess()
     def test_stat_unlink_race(self):
         # bpo-46785: the implementation of os.stat() falls back to reading
@@ -3229,9 +3266,8 @@ def test_stat_inaccessible_file(self):
             self.skipTest("Unable to create inaccessible file")
 
         def cleanup():
-            # Give delete permission. We are the file owner, so we can do this
-            # even though we removed all permissions earlier.
-            subprocess.check_output([ICACLS, filename, "/grant", "Everyone:(D)"],
+            # Give delete permission to the owner (us)
+            subprocess.check_output([ICACLS, filename, "/grant", "*WD:(D)"],
                                     stderr=subprocess.STDOUT)
             os.unlink(filename)
 
@@ -3372,7 +3408,6 @@ def test_waitstatus_to_exitcode(self):
         with self.assertRaises(TypeError):
             os.waitstatus_to_exitcode(0.0)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.spawnv not implemented yet for all platforms")
     @unittest.skipUnless(sys.platform == 'win32', 'win32-specific test')
     def test_waitpid_windows(self):
         # bpo-40138: test os.waitpid() and os.waitstatus_to_exitcode()
@@ -3381,7 +3416,6 @@ def test_waitpid_windows(self):
         code = f'import _winapi; _winapi.ExitProcess({STATUS_CONTROL_C_EXIT})'
         self.check_waitpid(code, exitcode=STATUS_CONTROL_C_EXIT)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (OverflowError: Python int too large to convert to Rust i32)")
     @unittest.skipUnless(sys.platform == 'win32', 'win32-specific test')
     def test_waitstatus_to_exitcode_windows(self):
         max_exitcode = 2 ** 32 - 1
@@ -3454,6 +3488,7 @@ def test_spawnl(self):
         self.assertEqual(exitcode, self.exitcode)
 
     @requires_os_func('spawnle')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnle(self):
         program, args = self.create_args(with_env=True)
         exitcode = os.spawnle(os.P_WAIT, program, *args, self.env)
@@ -3482,6 +3517,7 @@ def test_spawnv(self):
         self.assertEqual(exitcode, self.exitcode)
 
     @requires_os_func('spawnve')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnve(self):
         program, args = self.create_args(with_env=True)
         exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
@@ -3505,8 +3541,7 @@ def test_nowait(self):
         pid = os.spawnv(os.P_NOWAIT, program, args)
         support.wait_process(pid, exitcode=self.exitcode)
 
-    # TODO: RUSTPYTHON fix spawnv bytes
-    @unittest.expectedFailure    
+    @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)
@@ -3591,6 +3626,7 @@ def _test_invalid_env(self, spawn):
         self.assertEqual(exitcode, 0)
 
     @requires_os_func('spawnve')
+    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; fix spawnve on Windows")
     def test_spawnve_invalid_env(self):
         self._test_invalid_env(os.spawnve)
 
@@ -3637,9 +3673,8 @@ def test_set_get_priority(self):
 class TestSendfile(unittest.IsolatedAsyncioTestCase):
 
     DATA = b"12345abcde" * 16 * 1024  # 160 KiB
-    SUPPORT_HEADERS_TRAILERS = not sys.platform.startswith("linux") and \
-                               not sys.platform.startswith("solaris") and \
-                               not sys.platform.startswith("sunos")
+    SUPPORT_HEADERS_TRAILERS = (
+        not sys.platform.startswith(("linux", "android", "solaris", "sunos")))
     requires_headers_trailers = unittest.skipUnless(SUPPORT_HEADERS_TRAILERS,
             'requires headers and trailers support')
     requires_32b = unittest.skipUnless(sys.maxsize < 2**32,
@@ -3912,10 +3947,10 @@ def _check_xattrs_str(self, s, getxattr, setxattr, removexattr, listxattr, **kwa
         xattr.remove("user.test")
         self.assertEqual(set(listxattr(fn)), xattr)
         self.assertEqual(getxattr(fn, s("user.test2"), **kwargs), b"foo")
-        setxattr(fn, s("user.test"), b"a"*1024, **kwargs)
-        self.assertEqual(getxattr(fn, s("user.test"), **kwargs), b"a"*1024)
+        setxattr(fn, s("user.test"), b"a"*256, **kwargs)
+        self.assertEqual(getxattr(fn, s("user.test"), **kwargs), b"a"*256)
         removexattr(fn, s("user.test"), **kwargs)
-        many = sorted("user.test{}".format(i) for i in range(100))
+        many = sorted("user.test{}".format(i) for i in range(32))
         for thing in many:
             setxattr(fn, thing, b"x", **kwargs)
         self.assertEqual(set(listxattr(fn)), set(init_xattr) | set(many))
@@ -3962,7 +3997,12 @@ def test_does_not_crash(self):
         try:
             size = os.get_terminal_size()
         except OSError as e:
-            if sys.platform == "win32" or e.errno in (errno.EINVAL, errno.ENOTTY):
+            known_errnos = [errno.EINVAL, errno.ENOTTY]
+            if sys.platform == "android":
+                # The Android testbed redirects the native stdout to a pipe,
+                # which returns a different error code.
+                known_errnos.append(errno.EACCES)
+            if sys.platform == "win32" or e.errno in known_errnos:
                 # Under win32 a generic OSError can be thrown if the
                 # handle cannot be retrieved
                 self.skipTest("failed to query terminal size")
@@ -3971,6 +4011,7 @@ def test_does_not_crash(self):
         self.assertGreaterEqual(size.columns, 0)
         self.assertGreaterEqual(size.lines, 0)
 
+    @support.requires_subprocess()
     def test_stty_match(self):
         """Check if stty returns the same results
 
@@ -4112,6 +4153,333 @@ def test_eventfd_select(self):
         self.assertEqual((rfd, wfd, xfd), ([fd], [], []))
         os.eventfd_read(fd)
 
+@unittest.skipUnless(hasattr(os, 'timerfd_create'), 'requires os.timerfd_create')
+@unittest.skipIf(sys.platform == "android", "gh-124873: Test is flaky on Android")
+@support.requires_linux_version(2, 6, 30)
+class TimerfdTests(unittest.TestCase):
+    # gh-126112: Use 10 ms to tolerate slow buildbots
+    CLOCK_RES_PLACES = 2  # 10 ms
+    CLOCK_RES = 10 ** -CLOCK_RES_PLACES
+    CLOCK_RES_NS = 10 ** (9 - CLOCK_RES_PLACES)
+
+    def timerfd_create(self, *args, **kwargs):
+        fd = os.timerfd_create(*args, **kwargs)
+        self.assertGreaterEqual(fd, 0)
+        self.assertFalse(os.get_inheritable(fd))
+        self.addCleanup(os.close, fd)
+        return fd
+
+    def read_count_signaled(self, fd):
+        # read 8 bytes
+        data = os.read(fd, 8)
+        return int.from_bytes(data, byteorder=sys.byteorder)
+
+    def test_timerfd_initval(self):
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        initial_expiration = 0.25
+        interval = 0.125
+
+        # 1st call
+        next_expiration, interval2 = os.timerfd_settime(fd, initial=initial_expiration, interval=interval)
+        self.assertAlmostEqual(interval2, 0.0, places=self.CLOCK_RES_PLACES)
+        self.assertAlmostEqual(next_expiration, 0.0, places=self.CLOCK_RES_PLACES)
+
+        # 2nd call
+        next_expiration, interval2 = os.timerfd_settime(fd, initial=initial_expiration, interval=interval)
+        self.assertAlmostEqual(interval2, interval, places=self.CLOCK_RES_PLACES)
+        self.assertAlmostEqual(next_expiration, initial_expiration, places=self.CLOCK_RES_PLACES)
+
+        # timerfd_gettime
+        next_expiration, interval2 = os.timerfd_gettime(fd)
+        self.assertAlmostEqual(interval2, interval, places=self.CLOCK_RES_PLACES)
+        self.assertAlmostEqual(next_expiration, initial_expiration, places=self.CLOCK_RES_PLACES)
+
+    def test_timerfd_non_blocking(self):
+        fd = self.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
+
+        # 0.1 second later
+        initial_expiration = 0.1
+        os.timerfd_settime(fd, initial=initial_expiration, interval=0)
+
+        # read() raises OSError with errno is EAGAIN for non-blocking timer.
+        with self.assertRaises(OSError) as ctx:
+            self.read_count_signaled(fd)
+        self.assertEqual(ctx.exception.errno, errno.EAGAIN)
+
+        # Wait more than 0.1 seconds
+        time.sleep(initial_expiration + 0.1)
+
+        # confirm if timerfd is readable and read() returns 1 as bytes.
+        self.assertEqual(self.read_count_signaled(fd), 1)
+
+    @unittest.skipIf(sys.platform.startswith('netbsd'),
+                     "gh-131263: Skip on NetBSD due to system freeze "
+                     "with negative timer values")
+    def test_timerfd_negative(self):
+        one_sec_in_nsec = 10**9
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        test_flags = [0, os.TFD_TIMER_ABSTIME]
+        if hasattr(os, 'TFD_TIMER_CANCEL_ON_SET'):
+            test_flags.append(os.TFD_TIMER_ABSTIME | os.TFD_TIMER_CANCEL_ON_SET)
+
+        # Any of 'initial' and 'interval' is negative value.
+        for initial, interval in ( (-1, 0), (1, -1), (-1, -1),  (-0.1, 0), (1, -0.1), (-0.1, -0.1)):
+            for flags in test_flags:
+                with self.subTest(flags=flags, initial=initial, interval=interval):
+                    with self.assertRaises(OSError) as context:
+                        os.timerfd_settime(fd, flags=flags, initial=initial, interval=interval)
+                    self.assertEqual(context.exception.errno, errno.EINVAL)
+
+                    with self.assertRaises(OSError) as context:
+                        initial_ns = int( one_sec_in_nsec * initial )
+                        interval_ns = int( one_sec_in_nsec * interval )
+                        os.timerfd_settime_ns(fd, flags=flags, initial=initial_ns, interval=interval_ns)
+                    self.assertEqual(context.exception.errno, errno.EINVAL)
+
+    def test_timerfd_interval(self):
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        # 1 second
+        initial_expiration = 1
+        # 0.5 second
+        interval = 0.5
+
+        os.timerfd_settime(fd, initial=initial_expiration, interval=interval)
+
+        # timerfd_gettime
+        next_expiration, interval2 = os.timerfd_gettime(fd)
+        self.assertAlmostEqual(interval2, interval, places=self.CLOCK_RES_PLACES)
+        self.assertAlmostEqual(next_expiration, initial_expiration, places=self.CLOCK_RES_PLACES)
+
+        count = 3
+        t = time.perf_counter()
+        for _ in range(count):
+            self.assertEqual(self.read_count_signaled(fd), 1)
+        t = time.perf_counter() - t
+
+        total_time = initial_expiration + interval * (count - 1)
+        self.assertGreater(t, total_time - self.CLOCK_RES)
+
+        # wait 3.5 time of interval
+        time.sleep( (count+0.5) * interval)
+        self.assertEqual(self.read_count_signaled(fd), count)
+
+    def test_timerfd_TFD_TIMER_ABSTIME(self):
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        now = time.clock_gettime(time.CLOCK_REALTIME)
+
+        # 1 second later from now.
+        offset = 1
+        initial_expiration = now + offset
+        # not interval timer
+        interval = 0
+
+        os.timerfd_settime(fd, flags=os.TFD_TIMER_ABSTIME, initial=initial_expiration, interval=interval)
+
+        # timerfd_gettime
+        # Note: timerfd_gettime returns relative values even if TFD_TIMER_ABSTIME is specified.
+        next_expiration, interval2 = os.timerfd_gettime(fd)
+        self.assertAlmostEqual(interval2, interval, places=self.CLOCK_RES_PLACES)
+        self.assertAlmostEqual(next_expiration, offset, places=self.CLOCK_RES_PLACES)
+
+        t = time.perf_counter()
+        count_signaled = self.read_count_signaled(fd)
+        t = time.perf_counter() - t
+        self.assertEqual(count_signaled, 1)
+
+        self.assertGreater(t, offset - self.CLOCK_RES)
+
+    def test_timerfd_select(self):
+        fd = self.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
+
+        rfd, wfd, xfd = select.select([fd], [fd], [fd], 0)
+        self.assertEqual((rfd, wfd, xfd), ([], [], []))
+
+        # 0.25 second
+        initial_expiration = 0.25
+        # every 0.125 second
+        interval = 0.125
+
+        os.timerfd_settime(fd, initial=initial_expiration, interval=interval)
+
+        count = 3
+        t = time.perf_counter()
+        for _ in range(count):
+            rfd, wfd, xfd = select.select([fd], [fd], [fd], initial_expiration + interval)
+            self.assertEqual((rfd, wfd, xfd), ([fd], [], []))
+            self.assertEqual(self.read_count_signaled(fd), 1)
+        t = time.perf_counter() - t
+
+        total_time = initial_expiration + interval * (count - 1)
+        self.assertGreater(t, total_time - self.CLOCK_RES)
+
+    def check_timerfd_poll(self, nanoseconds):
+        fd = self.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
+
+        selector = selectors.DefaultSelector()
+        selector.register(fd, selectors.EVENT_READ)
+        self.addCleanup(selector.close)
+
+        sec_to_nsec = 10 ** 9
+        # 0.25 second
+        initial_expiration_ns = sec_to_nsec // 4
+        # every 0.125 second
+        interval_ns = sec_to_nsec // 8
+
+        if nanoseconds:
+            os.timerfd_settime_ns(fd,
+                                  initial=initial_expiration_ns,
+                                  interval=interval_ns)
+        else:
+            os.timerfd_settime(fd,
+                               initial=initial_expiration_ns / sec_to_nsec,
+                               interval=interval_ns / sec_to_nsec)
+
+        count = 3
+        if nanoseconds:
+            t = time.perf_counter_ns()
+        else:
+            t = time.perf_counter()
+        for i in range(count):
+            timeout_margin_ns = interval_ns
+            if i == 0:
+                timeout_ns = initial_expiration_ns + interval_ns + timeout_margin_ns
+            else:
+                timeout_ns = interval_ns + timeout_margin_ns
+
+            ready = selector.select(timeout_ns / sec_to_nsec)
+            self.assertEqual(len(ready), 1, ready)
+            event = ready[0][1]
+            self.assertEqual(event, selectors.EVENT_READ)
+
+            self.assertEqual(self.read_count_signaled(fd), 1)
+
+        total_time = initial_expiration_ns + interval_ns * (count - 1)
+        if nanoseconds:
+            dt = time.perf_counter_ns() - t
+            self.assertGreater(dt, total_time - self.CLOCK_RES_NS)
+        else:
+            dt = time.perf_counter() - t
+            self.assertGreater(dt, total_time / sec_to_nsec - self.CLOCK_RES)
+        selector.unregister(fd)
+
+    def test_timerfd_poll(self):
+        self.check_timerfd_poll(False)
+
+    def test_timerfd_ns_poll(self):
+        self.check_timerfd_poll(True)
+
+    def test_timerfd_ns_initval(self):
+        one_sec_in_nsec = 10**9
+        limit_error = one_sec_in_nsec // 10**3
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        # 1st call
+        initial_expiration_ns = 0
+        interval_ns = one_sec_in_nsec // 1000
+        next_expiration_ns, interval_ns2  = os.timerfd_settime_ns(fd, initial=initial_expiration_ns, interval=interval_ns)
+        self.assertEqual(interval_ns2, 0)
+        self.assertEqual(next_expiration_ns, 0)
+
+        # 2nd call
+        next_expiration_ns, interval_ns2 = os.timerfd_settime_ns(fd, initial=initial_expiration_ns, interval=interval_ns)
+        self.assertEqual(interval_ns2, interval_ns)
+        self.assertEqual(next_expiration_ns, initial_expiration_ns)
+
+        # timerfd_gettime
+        next_expiration_ns, interval_ns2 = os.timerfd_gettime_ns(fd)
+        self.assertEqual(interval_ns2, interval_ns)
+        self.assertLessEqual(next_expiration_ns, initial_expiration_ns)
+
+        self.assertAlmostEqual(next_expiration_ns, initial_expiration_ns, delta=limit_error)
+
+    def test_timerfd_ns_interval(self):
+        one_sec_in_nsec = 10**9
+        limit_error = one_sec_in_nsec // 10**3
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        # 1 second
+        initial_expiration_ns = one_sec_in_nsec
+        # every 0.5 second
+        interval_ns = one_sec_in_nsec // 2
+
+        os.timerfd_settime_ns(fd, initial=initial_expiration_ns, interval=interval_ns)
+
+        # timerfd_gettime
+        next_expiration_ns, interval_ns2 = os.timerfd_gettime_ns(fd)
+        self.assertEqual(interval_ns2, interval_ns)
+        self.assertLessEqual(next_expiration_ns, initial_expiration_ns)
+
+        count = 3
+        t = time.perf_counter_ns()
+        for _ in range(count):
+            self.assertEqual(self.read_count_signaled(fd), 1)
+        t = time.perf_counter_ns() - t
+
+        total_time_ns = initial_expiration_ns + interval_ns * (count - 1)
+        self.assertGreater(t, total_time_ns - self.CLOCK_RES_NS)
+
+        # wait 3.5 time of interval
+        time.sleep( (count+0.5) * interval_ns / one_sec_in_nsec)
+        self.assertEqual(self.read_count_signaled(fd), count)
+
+
+    def test_timerfd_ns_TFD_TIMER_ABSTIME(self):
+        one_sec_in_nsec = 10**9
+        limit_error = one_sec_in_nsec // 10**3
+        fd = self.timerfd_create(time.CLOCK_REALTIME)
+
+        now_ns = time.clock_gettime_ns(time.CLOCK_REALTIME)
+
+        # 1 second later from now.
+        offset_ns = one_sec_in_nsec
+        initial_expiration_ns = now_ns + offset_ns
+        # not interval timer
+        interval_ns = 0
+
+        os.timerfd_settime_ns(fd, flags=os.TFD_TIMER_ABSTIME, initial=initial_expiration_ns, interval=interval_ns)
+
+        # timerfd_gettime
+        # Note: timerfd_gettime returns relative values even if TFD_TIMER_ABSTIME is specified.
+        next_expiration_ns, interval_ns2 = os.timerfd_gettime_ns(fd)
+        self.assertLess(abs(interval_ns2 - interval_ns),  limit_error)
+        self.assertLess(abs(next_expiration_ns - offset_ns),  limit_error)
+
+        t = time.perf_counter_ns()
+        count_signaled = self.read_count_signaled(fd)
+        t = time.perf_counter_ns() - t
+        self.assertEqual(count_signaled, 1)
+
+        self.assertGreater(t, offset_ns - self.CLOCK_RES_NS)
+
+    def test_timerfd_ns_select(self):
+        one_sec_in_nsec = 10**9
+
+        fd = self.timerfd_create(time.CLOCK_REALTIME, flags=os.TFD_NONBLOCK)
+
+        rfd, wfd, xfd = select.select([fd], [fd], [fd], 0)
+        self.assertEqual((rfd, wfd, xfd), ([], [], []))
+
+        # 0.25 second
+        initial_expiration_ns = one_sec_in_nsec // 4
+        # every 0.125 second
+        interval_ns = one_sec_in_nsec // 8
+
+        os.timerfd_settime_ns(fd, initial=initial_expiration_ns, interval=interval_ns)
+
+        count = 3
+        t = time.perf_counter_ns()
+        for _ in range(count):
+            rfd, wfd, xfd = select.select([fd], [fd], [fd], (initial_expiration_ns + interval_ns) / 1e9 )
+            self.assertEqual((rfd, wfd, xfd), ([fd], [], []))
+            self.assertEqual(self.read_count_signaled(fd), 1)
+        t = time.perf_counter_ns() - t
+
+        total_time_ns = initial_expiration_ns + interval_ns * (count - 1)
+        self.assertGreater(t, total_time_ns - self.CLOCK_RES_NS)
 
 class OSErrorTests(unittest.TestCase):
     def setUp(self):
@@ -4134,8 +4502,6 @@ class Str(str):
 
         self.filenames = self.bytes_filenames + self.unicode_filenames
 
-    # TODO: RUSTPYTHON (AssertionError: b'@test_22106_tmp\xe7w\xf0' is not b'@test_22106_tmp\xe7w\xf0' : <built-in function chdir>)
-    @unittest.expectedFailure
     def test_oserror_filename(self):
         funcs = [
             (self.filenames, os.chdir,),
@@ -4188,19 +4554,46 @@ def test_oserror_filename(self):
                     self.fail(f"No exception thrown by {func}")
 
 class CPUCountTests(unittest.TestCase):
+    def check_cpu_count(self, cpus):
+        if cpus is None:
+            self.skipTest("Could not determine the number of CPUs")
+
+        self.assertIsInstance(cpus, int)
+        self.assertGreater(cpus, 0)
+
     def test_cpu_count(self):
         cpus = os.cpu_count()
-        if cpus is not None:
-            self.assertIsInstance(cpus, int)
-            self.assertGreater(cpus, 0)
-        else:
+        self.check_cpu_count(cpus)
+
+    def test_process_cpu_count(self):
+        cpus = os.process_cpu_count()
+        self.assertLessEqual(cpus, os.cpu_count())
+        self.check_cpu_count(cpus)
+
+    @unittest.skipUnless(hasattr(os, 'sched_setaffinity'),
+                         "don't have sched affinity support")
+    def test_process_cpu_count_affinity(self):
+        affinity1 = os.process_cpu_count()
+        if affinity1 is None:
             self.skipTest("Could not determine the number of CPUs")
 
+        # Disable one CPU
+        mask = os.sched_getaffinity(0)
+        if len(mask) <= 1:
+            self.skipTest(f"sched_getaffinity() returns less than "
+                          f"2 CPUs: {sorted(mask)}")
+        self.addCleanup(os.sched_setaffinity, 0, list(mask))
+        mask.pop()
+        os.sched_setaffinity(0, mask)
+
+        # test process_cpu_count()
+        affinity2 = os.process_cpu_count()
+        self.assertEqual(affinity2, affinity1 - 1)
+
 
 # FD inheritance check is only useful for systems with process support.
 @support.requires_subprocess()
 class FDInheritanceTests(unittest.TestCase):
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.get_inheritable not implemented yet for all platforms")
     def test_get_set_inheritable(self):
         fd = os.open(__file__, os.O_RDONLY)
         self.addCleanup(os.close, fd)
@@ -4245,7 +4638,6 @@ def test_get_set_inheritable_o_path(self):
         os.set_inheritable(fd, False)
         self.assertEqual(os.get_inheritable(fd), False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.get_inheritable not implemented yet for all platforms")
     def test_get_set_inheritable_badf(self):
         fd = os_helper.make_bad_fd()
 
@@ -4261,7 +4653,6 @@ def test_get_set_inheritable_badf(self):
             os.set_inheritable(fd, False)
         self.assertEqual(ctx.exception.errno, errno.EBADF)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.get_inheritable not implemented yet for all platforms")
     def test_open(self):
         fd = os.open(__file__, os.O_RDONLY)
         self.addCleanup(os.close, fd)
@@ -4275,7 +4666,6 @@ def test_pipe(self):
         self.assertEqual(os.get_inheritable(rfd), False)
         self.assertEqual(os.get_inheritable(wfd), False)
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; os.dup on windows")
     def test_dup(self):
         fd1 = os.open(__file__, os.O_RDONLY)
         self.addCleanup(os.close, fd1)
@@ -4284,13 +4674,11 @@ def test_dup(self):
         self.addCleanup(os.close, fd2)
         self.assertEqual(os.get_inheritable(fd2), False)
 
-    @unittest.skipIf(sys.platform == 'win32', "TODO: RUSTPYTHON; os.dup on windows")
     def test_dup_standard_stream(self):
         fd = os.dup(1)
         self.addCleanup(os.close, fd)
         self.assertGreater(fd, 0)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON os.dup not implemented yet for all platforms")
     @unittest.skipUnless(sys.platform == 'win32', 'win32-specific test')
     def test_dup_nul(self):
         # os.dup() was creating inheritable fds for character files.
@@ -4317,13 +4705,105 @@ def test_dup2(self):
         self.assertEqual(os.dup2(fd, fd3, inheritable=False), fd3)
         self.assertFalse(os.get_inheritable(fd3))
 
-    @unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+@unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+class PseudoterminalTests(unittest.TestCase):
+    def open_pty(self):
+        """Open a pty fd-pair, and schedule cleanup for it"""
+        main_fd, second_fd = os.openpty()
+        self.addCleanup(os.close, main_fd)
+        self.addCleanup(os.close, second_fd)
+        return main_fd, second_fd
+
     def test_openpty(self):
-        master_fd, slave_fd = os.openpty()
-        self.addCleanup(os.close, master_fd)
-        self.addCleanup(os.close, slave_fd)
-        self.assertEqual(os.get_inheritable(master_fd), False)
-        self.assertEqual(os.get_inheritable(slave_fd), False)
+        main_fd, second_fd = self.open_pty()
+        self.assertEqual(os.get_inheritable(main_fd), False)
+        self.assertEqual(os.get_inheritable(second_fd), False)
+
+    @unittest.skipUnless(hasattr(os, 'ptsname'), "need os.ptsname()")
+    @unittest.skipUnless(hasattr(os, 'O_RDWR'), "need os.O_RDWR")
+    @unittest.skipUnless(hasattr(os, 'O_NOCTTY'), "need os.O_NOCTTY")
+    def test_open_via_ptsname(self):
+        main_fd, second_fd = self.open_pty()
+        second_path = os.ptsname(main_fd)
+        reopened_second_fd = os.open(second_path, os.O_RDWR|os.O_NOCTTY)
+        self.addCleanup(os.close, reopened_second_fd)
+        os.write(reopened_second_fd, b'foo')
+        self.assertEqual(os.read(main_fd, 3), b'foo')
+
+    @unittest.skipUnless(hasattr(os, 'posix_openpt'), "need os.posix_openpt()")
+    @unittest.skipUnless(hasattr(os, 'grantpt'), "need os.grantpt()")
+    @unittest.skipUnless(hasattr(os, 'unlockpt'), "need os.unlockpt()")
+    @unittest.skipUnless(hasattr(os, 'ptsname'), "need os.ptsname()")
+    @unittest.skipUnless(hasattr(os, 'O_RDWR'), "need os.O_RDWR")
+    @unittest.skipUnless(hasattr(os, 'O_NOCTTY'), "need os.O_NOCTTY")
+    def test_posix_pty_functions(self):
+        mother_fd = os.posix_openpt(os.O_RDWR|os.O_NOCTTY)
+        self.addCleanup(os.close, mother_fd)
+        os.grantpt(mother_fd)
+        os.unlockpt(mother_fd)
+        son_path = os.ptsname(mother_fd)
+        son_fd = os.open(son_path, os.O_RDWR|os.O_NOCTTY)
+        self.addCleanup(os.close, son_fd)
+        self.assertEqual(os.ptsname(mother_fd), os.ttyname(son_fd))
+
+    @unittest.skipUnless(hasattr(os, 'spawnl'), "need os.spawnl()")
+    @support.requires_subprocess()
+    def test_pipe_spawnl(self):
+        # gh-77046: On Windows, os.pipe() file descriptors must be created with
+        # _O_NOINHERIT to make them non-inheritable. UCRT has no public API to
+        # get (_osfile(fd) & _O_NOINHERIT), so use a functional test.
+        #
+        # Make sure that fd is not inherited by a child process created by
+        # os.spawnl(): get_osfhandle() and dup() must fail with EBADF.
+
+        fd, fd2 = os.pipe()
+        self.addCleanup(os.close, fd)
+        self.addCleanup(os.close, fd2)
+
+        code = textwrap.dedent(f"""
+            import errno
+            import os
+            import test.support
+            try:
+                import msvcrt
+            except ImportError:
+                msvcrt = None
+
+            fd = {fd}
+
+            with test.support.SuppressCrashReport():
+                if msvcrt is not None:
+                    try:
+                        handle = msvcrt.get_osfhandle(fd)
+                    except OSError as exc:
+                        if exc.errno != errno.EBADF:
+                            raise
+                        # get_osfhandle(fd) failed with EBADF as expected
+                    else:
+                        raise Exception("get_osfhandle() must fail")
+
+                try:
+                    fd3 = os.dup(fd)
+                except OSError as exc:
+                    if exc.errno != errno.EBADF:
+                        raise
+                    # os.dup(fd) failed with EBADF as expected
+                else:
+                    os.close(fd3)
+                    raise Exception("dup must fail")
+        """)
+
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        with open(filename, "w") as fp:
+            print(code, file=fp, end="")
+
+        executable = sys.executable
+        cmd = [executable, filename]
+        if os.name == "nt" and " " in cmd[0]:
+            cmd[0] = f'"{cmd[0]}"'
+        exitcode = os.spawnl(os.P_WAIT, executable, *cmd)
+        self.assertEqual(exitcode, 0)
 
 
 class PathTConverterTests(unittest.TestCase):
@@ -4338,8 +4818,6 @@ class PathTConverterTests(unittest.TestCase):
         ('open', False, (os.O_RDONLY,), getattr(os, 'close', None)),
     ]
 
-    # TODO: RUSTPYTHON (AssertionError: TypeError not raised)
-    @unittest.expectedFailure
     def test_path_t_converter(self):
         str_filename = os_helper.TESTFN
         if os.name == 'nt':
@@ -4424,13 +4902,9 @@ def setUp(self):
         self.addCleanup(os_helper.rmtree, self.path)
         os.mkdir(self.path)
 
-    # TODO: RUSTPYTHON (AssertionError: TypeError not raised by DirEntry)
-    @unittest.expectedFailure
     def test_uninstantiable(self):
         self.assertRaises(TypeError, os.DirEntry)
 
-    # TODO: RUSTPYTHON (pickle.PicklingError: Can't pickle <class '_os.DirEntry'>: it's not found as _os.DirEntry)
-    @unittest.expectedFailure
     def test_unpickable(self):
         filename = create_file(os.path.join(self.path, "file.txt"), b'python')
         entry = [entry for entry in os.scandir(self.path)].pop()
@@ -4475,8 +4949,6 @@ def assert_stat_equal(self, stat1, stat2, skip_fields):
         else:
             self.assertEqual(stat1, stat2)
 
-    # TODO: RUSTPYTHON (AssertionError: TypeError not raised by ScandirIter)
-    @unittest.expectedFailure
     def test_uninstantiable(self):
         scandir_iter = os.scandir(self.path)
         self.assertRaises(TypeError, type(scandir_iter))
@@ -4519,9 +4991,9 @@ 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 = hasattr(os, 'link')
+        link = os_helper.can_hardlink()
         symlink = os_helper.can_symlink()
 
         dirname = os.path.join(self.path, "dir")
@@ -4619,7 +5091,6 @@ def test_fspath_protocol_bytes(self):
         self.assertEqual(fspath,
                          os.path.join(os.fsencode(self.path),bytes_filename))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON entry.is_dir() is False")
     def test_removed_dir(self):
         path = os.path.join(self.path, 'dir')
 
@@ -4642,7 +5113,6 @@ def test_removed_dir(self):
             self.assertRaises(FileNotFoundError, entry.stat)
             self.assertRaises(FileNotFoundError, entry.stat, follow_symlinks=False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON entry.is_file() is False")
     def test_removed_file(self):
         entry = self.create_file_entry()
         os.unlink(entry.path)
@@ -4703,8 +5173,7 @@ def test_bytes_like(self):
             with self.assertRaises(TypeError):
                 os.scandir(path_bytes)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(os.listdir in os.supports_fd,
                          'fd support for listdir required for this test.')
     def test_fd(self):
@@ -4731,7 +5200,6 @@ def test_fd(self):
                     st = os.stat(entry.name, dir_fd=fd, follow_symlinks=False)
                     self.assertEqual(entry.stat(follow_symlinks=False), st)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON (AssertionError: FileNotFoundError not raised by scandir)")
     @unittest.skipIf(support.is_wasi, "WASI maps '' to cwd")
     def test_empty_path(self):
         self.assertRaises(FileNotFoundError, os.scandir, '')
@@ -4787,8 +5255,7 @@ def test_context_manager_exception(self):
         with self.check_no_resource_warning():
             del iterator
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_resource_warning(self):
         self.create_file("file.txt")
         self.create_file("file2.txt")
@@ -4861,6 +5328,51 @@ class A(os.PathLike):
     def test_pathlike_class_getitem(self):
         self.assertIsInstance(os.PathLike[bytes], types.GenericAlias)
 
+    def test_pathlike_subclass_slots(self):
+        class A(os.PathLike):
+            __slots__ = ()
+            def __fspath__(self):
+                return ''
+        self.assertFalse(hasattr(A(), '__dict__'))
+
+    def test_fspath_set_to_None(self):
+        class Foo:
+            __fspath__ = None
+
+        class Bar:
+            def __fspath__(self):
+                return 'bar'
+
+        class Baz(Bar):
+            __fspath__ = None
+
+        good_error_msg = (
+            r"expected str, bytes or os.PathLike object, not {}".format
+        )
+
+        with self.assertRaisesRegex(TypeError, good_error_msg("Foo")):
+            self.fspath(Foo())
+
+        self.assertEqual(self.fspath(Bar()), 'bar')
+
+        with self.assertRaisesRegex(TypeError, good_error_msg("Baz")):
+            self.fspath(Baz())
+
+        with self.assertRaisesRegex(TypeError, good_error_msg("Foo")):
+            open(Foo())
+
+        with self.assertRaisesRegex(TypeError, good_error_msg("Baz")):
+            open(Baz())
+
+        other_good_error_msg = (
+            r"should be string, bytes or os.PathLike, not {}".format
+        )
+
+        with self.assertRaisesRegex(TypeError, other_good_error_msg("Foo")):
+            os.rename(Foo(), "foooo")
+
+        with self.assertRaisesRegex(TypeError, other_good_error_msg("Baz")):
+            os.rename(Baz(), "bazzz")
 
 class TimesTests(unittest.TestCase):
     def test_times(self):
@@ -4891,12 +5403,14 @@ def test_fork(self):
                 support.wait_process(pid, exitcode=0)
         """
         assert_python_ok("-c", code)
-        assert_python_ok("-c", code, PYTHONMALLOC="malloc_debug")
+        if support.Py_GIL_DISABLED:
+            assert_python_ok("-c", code, PYTHONMALLOC="mimalloc_debug")
+        else:
+            assert_python_ok("-c", code, PYTHONMALLOC="malloc_debug")
 
-    # TODO: RUSTPYTHON; requires _testcapi
-    @unittest.expectedFailure
-    @unittest.skipUnless(sys.platform in ("linux", "darwin"),
+    @unittest.skipUnless(sys.platform in ("linux", "android", "darwin"),
                          "Only Linux and macOS detect this today.")
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_fork_warns_when_non_python_thread_exists(self):
         code = """if 1:
             import os, threading, warnings
@@ -4923,8 +5437,7 @@ def test_fork_warns_when_non_python_thread_exists(self):
         self.assertEqual(err.decode("utf-8"), "")
         self.assertEqual(out.decode("utf-8"), "")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fork_at_finalization(self):
         code = """if 1:
             import atexit
diff --git a/Lib/test/test_pathlib.py b/Lib/test/test_pathlib.py
deleted file mode 100644
index c1696bb373..0000000000
--- a/Lib/test/test_pathlib.py
+++ /dev/null
@@ -1,3328 +0,0 @@
-import contextlib
-import collections.abc
-import io
-import os
-import sys
-import errno
-import pathlib
-import pickle
-import socket
-import stat
-import tempfile
-import unittest
-from unittest import mock
-
-from test.support import import_helper
-from test.support import set_recursion_limit
-from test.support import is_emscripten, is_wasi
-from test.support import os_helper
-from test.support.os_helper import TESTFN, FakePath
-
-try:
-    import grp, pwd
-except ImportError:
-    grp = pwd = None
-
-
-#
-# Tests for the pure classes.
-#
-
-class _BasePurePathSubclass(object):
-    def __init__(self, *pathsegments, session_id):
-        super().__init__(*pathsegments)
-        self.session_id = session_id
-
-    def with_segments(self, *pathsegments):
-        return type(self)(*pathsegments, session_id=self.session_id)
-
-
-class _BasePurePathTest(object):
-
-    # Keys are canonical paths, values are list of tuples of arguments
-    # supposed to produce equal paths.
-    equivalences = {
-        'a/b': [
-            ('a', 'b'), ('a/', 'b'), ('a', 'b/'), ('a/', 'b/'),
-            ('a/b/',), ('a//b',), ('a//b//',),
-            # Empty components get removed.
-            ('', 'a', 'b'), ('a', '', 'b'), ('a', 'b', ''),
-            ],
-        '/b/c/d': [
-            ('a', '/b/c', 'd'), ('/a', '/b/c', 'd'),
-            # Empty components get removed.
-            ('/', 'b', '', 'c/d'), ('/', '', 'b/c/d'), ('', '/b/c/d'),
-            ],
-    }
-
-    def setUp(self):
-        p = self.cls('a')
-        self.flavour = p._flavour
-        self.sep = self.flavour.sep
-        self.altsep = self.flavour.altsep
-
-    def test_constructor_common(self):
-        P = self.cls
-        p = P('a')
-        self.assertIsInstance(p, P)
-        P('a', 'b', 'c')
-        P('/a', 'b', 'c')
-        P('a/b/c')
-        P('/a/b/c')
-        P(FakePath("a/b/c"))
-        self.assertEqual(P(P('a')), P('a'))
-        self.assertEqual(P(P('a'), 'b'), P('a/b'))
-        self.assertEqual(P(P('a'), P('b')), P('a/b'))
-        self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
-        self.assertEqual(P(P('./a:b')), P('./a:b'))
-
-    def test_bytes(self):
-        P = self.cls
-        message = (r"argument should be a str or an os\.PathLike object "
-                   r"where __fspath__ returns a str, not 'bytes'")
-        with self.assertRaisesRegex(TypeError, message):
-            P(b'a')
-        with self.assertRaisesRegex(TypeError, message):
-            P(b'a', 'b')
-        with self.assertRaisesRegex(TypeError, message):
-            P('a', b'b')
-        with self.assertRaises(TypeError):
-            P('a').joinpath(b'b')
-        with self.assertRaises(TypeError):
-            P('a') / b'b'
-        with self.assertRaises(TypeError):
-            b'a' / P('b')
-        with self.assertRaises(TypeError):
-            P('a').match(b'b')
-        with self.assertRaises(TypeError):
-            P('a').relative_to(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_name(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_stem(b'b')
-        with self.assertRaises(TypeError):
-            P('a').with_suffix(b'b')
-
-    def _check_str_subclass(self, *args):
-        # Issue #21127: it should be possible to construct a PurePath object
-        # from a str subclass instance, and it then gets converted to
-        # a pure str object.
-        class StrSubclass(str):
-            pass
-        P = self.cls
-        p = P(*(StrSubclass(x) for x in args))
-        self.assertEqual(p, P(*args))
-        for part in p.parts:
-            self.assertIs(type(part), str)
-
-    def test_str_subclass_common(self):
-        self._check_str_subclass('')
-        self._check_str_subclass('.')
-        self._check_str_subclass('a')
-        self._check_str_subclass('a/b.txt')
-        self._check_str_subclass('/a/b.txt')
-
-    @unittest.skip("TODO: RUSTPYTHON; PyObject::set_slot index out of bounds")
-    def test_with_segments_common(self):
-        class P(_BasePurePathSubclass, self.cls):
-            pass
-        p = P('foo', 'bar', session_id=42)
-        self.assertEqual(42, (p / 'foo').session_id)
-        self.assertEqual(42, ('foo' / p).session_id)
-        self.assertEqual(42, p.joinpath('foo').session_id)
-        self.assertEqual(42, p.with_name('foo').session_id)
-        self.assertEqual(42, p.with_stem('foo').session_id)
-        self.assertEqual(42, p.with_suffix('.foo').session_id)
-        self.assertEqual(42, p.with_segments('foo').session_id)
-        self.assertEqual(42, p.relative_to('foo').session_id)
-        self.assertEqual(42, p.parent.session_id)
-        for parent in p.parents:
-            self.assertEqual(42, parent.session_id)
-
-    def _get_drive_root_parts(self, parts):
-        path = self.cls(*parts)
-        return path.drive, path.root, path.parts
-
-    def _check_drive_root_parts(self, arg, *expected):
-        sep = self.flavour.sep
-        actual = self._get_drive_root_parts([x.replace('/', sep) for x in arg])
-        self.assertEqual(actual, expected)
-        if altsep := self.flavour.altsep:
-            actual = self._get_drive_root_parts([x.replace('/', altsep) for x in arg])
-            self.assertEqual(actual, expected)
-
-    def test_drive_root_parts_common(self):
-        check = self._check_drive_root_parts
-        sep = self.flavour.sep
-        # Unanchored parts.
-        check((),                   '', '', ())
-        check(('a',),               '', '', ('a',))
-        check(('a/',),              '', '', ('a',))
-        check(('a', 'b'),           '', '', ('a', 'b'))
-        # Expansion.
-        check(('a/b',),             '', '', ('a', 'b'))
-        check(('a/b/',),            '', '', ('a', 'b'))
-        check(('a', 'b/c', 'd'),    '', '', ('a', 'b', 'c', 'd'))
-        # Collapsing and stripping excess slashes.
-        check(('a', 'b//c', 'd'),   '', '', ('a', 'b', 'c', 'd'))
-        check(('a', 'b/c/', 'd'),   '', '', ('a', 'b', 'c', 'd'))
-        # Eliminating standalone dots.
-        check(('.',),               '', '', ())
-        check(('.', '.', 'b'),      '', '', ('b',))
-        check(('a', '.', 'b'),      '', '', ('a', 'b'))
-        check(('a', '.', '.'),      '', '', ('a',))
-        # The first part is anchored.
-        check(('/a/b',),            '', sep, (sep, 'a', 'b'))
-        check(('/a', 'b'),          '', sep, (sep, 'a', 'b'))
-        check(('/a/', 'b'),         '', sep, (sep, 'a', 'b'))
-        # Ignoring parts before an anchored part.
-        check(('a', '/b', 'c'),     '', sep, (sep, 'b', 'c'))
-        check(('a', '/b', '/c'),    '', sep, (sep, 'c'))
-
-    def test_join_common(self):
-        P = self.cls
-        p = P('a/b')
-        pp = p.joinpath('c')
-        self.assertEqual(pp, P('a/b/c'))
-        self.assertIs(type(pp), type(p))
-        pp = p.joinpath('c', 'd')
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = p.joinpath(P('c'))
-        self.assertEqual(pp, P('a/b/c'))
-        pp = p.joinpath('/c')
-        self.assertEqual(pp, P('/c'))
-
-    def test_div_common(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('a/b')
-        pp = p / 'c'
-        self.assertEqual(pp, P('a/b/c'))
-        self.assertIs(type(pp), type(p))
-        pp = p / 'c/d'
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = p / 'c' / 'd'
-        self.assertEqual(pp, P('a/b/c/d'))
-        pp = 'c' / p / 'd'
-        self.assertEqual(pp, P('c/a/b/d'))
-        pp = p / P('c')
-        self.assertEqual(pp, P('a/b/c'))
-        pp = p/ '/c'
-        self.assertEqual(pp, P('/c'))
-
-    def _check_str(self, expected, args):
-        p = self.cls(*args)
-        self.assertEqual(str(p), expected.replace('/', self.sep))
-
-    def test_str_common(self):
-        # Canonicalized paths roundtrip.
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            self._check_str(pathstr, (pathstr,))
-        # Special case for the empty path.
-        self._check_str('.', ('',))
-        # Other tests for str() are in test_equivalences().
-
-    def test_as_posix_common(self):
-        P = self.cls
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            self.assertEqual(P(pathstr).as_posix(), pathstr)
-        # Other tests for as_posix() are in test_equivalences().
-
-    def test_as_bytes_common(self):
-        sep = os.fsencode(self.sep)
-        P = self.cls
-        self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
-
-    def test_as_uri_common(self):
-        P = self.cls
-        with self.assertRaises(ValueError):
-            P('a').as_uri()
-        with self.assertRaises(ValueError):
-            P().as_uri()
-
-    def test_repr_common(self):
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            with self.subTest(pathstr=pathstr):
-                p = self.cls(pathstr)
-                clsname = p.__class__.__name__
-                r = repr(p)
-                # The repr() is in the form ClassName("forward-slashes path").
-                self.assertTrue(r.startswith(clsname + '('), r)
-                self.assertTrue(r.endswith(')'), r)
-                inner = r[len(clsname) + 1 : -1]
-                self.assertEqual(eval(inner), p.as_posix())
-
-    def test_repr_roundtrips(self):
-        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
-            with self.subTest(pathstr=pathstr):
-                p = self.cls(pathstr)
-                r = repr(p)
-                # The repr() roundtrips.
-                q = eval(r, pathlib.__dict__)
-                self.assertIs(q.__class__, p.__class__)
-                self.assertEqual(q, p)
-                self.assertEqual(repr(q), r)
-
-    def test_eq_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b'), P('a/b'))
-        self.assertEqual(P('a/b'), P('a', 'b'))
-        self.assertNotEqual(P('a/b'), P('a'))
-        self.assertNotEqual(P('a/b'), P('/a/b'))
-        self.assertNotEqual(P('a/b'), P())
-        self.assertNotEqual(P('/a/b'), P('/'))
-        self.assertNotEqual(P(), P('/'))
-        self.assertNotEqual(P(), "")
-        self.assertNotEqual(P(), {})
-        self.assertNotEqual(P(), int)
-
-    def test_match_common(self):
-        P = self.cls
-        self.assertRaises(ValueError, P('a').match, '')
-        self.assertRaises(ValueError, P('a').match, '.')
-        # Simple relative pattern.
-        self.assertTrue(P('b.py').match('b.py'))
-        self.assertTrue(P('a/b.py').match('b.py'))
-        self.assertTrue(P('/a/b.py').match('b.py'))
-        self.assertFalse(P('a.py').match('b.py'))
-        self.assertFalse(P('b/py').match('b.py'))
-        self.assertFalse(P('/a.py').match('b.py'))
-        self.assertFalse(P('b.py/c').match('b.py'))
-        # Wildcard relative pattern.
-        self.assertTrue(P('b.py').match('*.py'))
-        self.assertTrue(P('a/b.py').match('*.py'))
-        self.assertTrue(P('/a/b.py').match('*.py'))
-        self.assertFalse(P('b.pyc').match('*.py'))
-        self.assertFalse(P('b./py').match('*.py'))
-        self.assertFalse(P('b.py/c').match('*.py'))
-        # Multi-part relative pattern.
-        self.assertTrue(P('ab/c.py').match('a*/*.py'))
-        self.assertTrue(P('/d/ab/c.py').match('a*/*.py'))
-        self.assertFalse(P('a.py').match('a*/*.py'))
-        self.assertFalse(P('/dab/c.py').match('a*/*.py'))
-        self.assertFalse(P('ab/c.py/d').match('a*/*.py'))
-        # Absolute pattern.
-        self.assertTrue(P('/b.py').match('/*.py'))
-        self.assertFalse(P('b.py').match('/*.py'))
-        self.assertFalse(P('a/b.py').match('/*.py'))
-        self.assertFalse(P('/a/b.py').match('/*.py'))
-        # Multi-part absolute pattern.
-        self.assertTrue(P('/a/b.py').match('/a/*.py'))
-        self.assertFalse(P('/ab.py').match('/a/*.py'))
-        self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
-        # Multi-part glob-style pattern.
-        self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
-        self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
-        # Case-sensitive flag
-        self.assertFalse(P('A.py').match('a.PY', case_sensitive=True))
-        self.assertTrue(P('A.py').match('a.PY', case_sensitive=False))
-        self.assertFalse(P('c:/a/B.Py').match('C:/A/*.pY', case_sensitive=True))
-        self.assertTrue(P('/a/b/c.py').match('/A/*/*.Py', case_sensitive=False))
-        # Matching against empty path
-        self.assertFalse(P().match('*'))
-        self.assertTrue(P().match('**'))
-        self.assertFalse(P().match('**/*'))
-
-    def test_ordering_common(self):
-        # Ordering is tuple-alike.
-        def assertLess(a, b):
-            self.assertLess(a, b)
-            self.assertGreater(b, a)
-        P = self.cls
-        a = P('a')
-        b = P('a/b')
-        c = P('abc')
-        d = P('b')
-        assertLess(a, b)
-        assertLess(a, c)
-        assertLess(a, d)
-        assertLess(b, c)
-        assertLess(c, d)
-        P = self.cls
-        a = P('/a')
-        b = P('/a/b')
-        c = P('/abc')
-        d = P('/b')
-        assertLess(a, b)
-        assertLess(a, c)
-        assertLess(a, d)
-        assertLess(b, c)
-        assertLess(c, d)
-        with self.assertRaises(TypeError):
-            P() < {}
-
-    def test_parts_common(self):
-        # `parts` returns a tuple.
-        sep = self.sep
-        P = self.cls
-        p = P('a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('a', 'b'))
-        # When the path is absolute, the anchor is a separate part.
-        p = P('/a/b')
-        parts = p.parts
-        self.assertEqual(parts, (sep, 'a', 'b'))
-
-    def test_fspath_common(self):
-        P = self.cls
-        p = P('a/b')
-        self._check_str(p.__fspath__(), ('a/b',))
-        self._check_str(os.fspath(p), ('a/b',))
-
-    def test_equivalences(self):
-        for k, tuples in self.equivalences.items():
-            canon = k.replace('/', self.sep)
-            posix = k.replace(self.sep, '/')
-            if canon != posix:
-                tuples = tuples + [
-                    tuple(part.replace('/', self.sep) for part in t)
-                    for t in tuples
-                    ]
-                tuples.append((posix, ))
-            pcanon = self.cls(canon)
-            for t in tuples:
-                p = self.cls(*t)
-                self.assertEqual(p, pcanon, "failed with args {}".format(t))
-                self.assertEqual(hash(p), hash(pcanon))
-                self.assertEqual(str(p), canon)
-                self.assertEqual(p.as_posix(), posix)
-
-    def test_parent_common(self):
-        # Relative
-        P = self.cls
-        p = P('a/b/c')
-        self.assertEqual(p.parent, P('a/b'))
-        self.assertEqual(p.parent.parent, P('a'))
-        self.assertEqual(p.parent.parent.parent, P())
-        self.assertEqual(p.parent.parent.parent.parent, P())
-        # Anchored
-        p = P('/a/b/c')
-        self.assertEqual(p.parent, P('/a/b'))
-        self.assertEqual(p.parent.parent, P('/a'))
-        self.assertEqual(p.parent.parent.parent, P('/'))
-        self.assertEqual(p.parent.parent.parent.parent, P('/'))
-
-    def test_parents_common(self):
-        # Relative
-        P = self.cls
-        p = P('a/b/c')
-        par = p.parents
-        self.assertEqual(len(par), 3)
-        self.assertEqual(par[0], P('a/b'))
-        self.assertEqual(par[1], P('a'))
-        self.assertEqual(par[2], P('.'))
-        self.assertEqual(par[-1], P('.'))
-        self.assertEqual(par[-2], P('a'))
-        self.assertEqual(par[-3], P('a/b'))
-        self.assertEqual(par[0:1], (P('a/b'),))
-        self.assertEqual(par[:2], (P('a/b'), P('a')))
-        self.assertEqual(par[:-1], (P('a/b'), P('a')))
-        self.assertEqual(par[1:], (P('a'), P('.')))
-        self.assertEqual(par[::2], (P('a/b'), P('.')))
-        self.assertEqual(par[::-1], (P('.'), P('a'), P('a/b')))
-        self.assertEqual(list(par), [P('a/b'), P('a'), P('.')])
-        with self.assertRaises(IndexError):
-            par[-4]
-        with self.assertRaises(IndexError):
-            par[3]
-        with self.assertRaises(TypeError):
-            par[0] = p
-        # Anchored
-        p = P('/a/b/c')
-        par = p.parents
-        self.assertEqual(len(par), 3)
-        self.assertEqual(par[0], P('/a/b'))
-        self.assertEqual(par[1], P('/a'))
-        self.assertEqual(par[2], P('/'))
-        self.assertEqual(par[-1], P('/'))
-        self.assertEqual(par[-2], P('/a'))
-        self.assertEqual(par[-3], P('/a/b'))
-        self.assertEqual(par[0:1], (P('/a/b'),))
-        self.assertEqual(par[:2], (P('/a/b'), P('/a')))
-        self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
-        self.assertEqual(par[1:], (P('/a'), P('/')))
-        self.assertEqual(par[::2], (P('/a/b'), P('/')))
-        self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
-        self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
-        with self.assertRaises(IndexError):
-            par[-4]
-        with self.assertRaises(IndexError):
-            par[3]
-
-    def test_drive_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').drive, '')
-        self.assertEqual(P('/a/b').drive, '')
-        self.assertEqual(P('').drive, '')
-
-    def test_root_common(self):
-        P = self.cls
-        sep = self.sep
-        self.assertEqual(P('').root, '')
-        self.assertEqual(P('a/b').root, '')
-        self.assertEqual(P('/').root, sep)
-        self.assertEqual(P('/a/b').root, sep)
-
-    def test_anchor_common(self):
-        P = self.cls
-        sep = self.sep
-        self.assertEqual(P('').anchor, '')
-        self.assertEqual(P('a/b').anchor, '')
-        self.assertEqual(P('/').anchor, sep)
-        self.assertEqual(P('/a/b').anchor, sep)
-
-    def test_name_common(self):
-        P = self.cls
-        self.assertEqual(P('').name, '')
-        self.assertEqual(P('.').name, '')
-        self.assertEqual(P('/').name, '')
-        self.assertEqual(P('a/b').name, 'b')
-        self.assertEqual(P('/a/b').name, 'b')
-        self.assertEqual(P('/a/b/.').name, 'b')
-        self.assertEqual(P('a/b.py').name, 'b.py')
-        self.assertEqual(P('/a/b.py').name, 'b.py')
-
-    def test_suffix_common(self):
-        P = self.cls
-        self.assertEqual(P('').suffix, '')
-        self.assertEqual(P('.').suffix, '')
-        self.assertEqual(P('..').suffix, '')
-        self.assertEqual(P('/').suffix, '')
-        self.assertEqual(P('a/b').suffix, '')
-        self.assertEqual(P('/a/b').suffix, '')
-        self.assertEqual(P('/a/b/.').suffix, '')
-        self.assertEqual(P('a/b.py').suffix, '.py')
-        self.assertEqual(P('/a/b.py').suffix, '.py')
-        self.assertEqual(P('a/.hgrc').suffix, '')
-        self.assertEqual(P('/a/.hgrc').suffix, '')
-        self.assertEqual(P('a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('/a/Some name. Ending with a dot.').suffix, '')
-
-    def test_suffixes_common(self):
-        P = self.cls
-        self.assertEqual(P('').suffixes, [])
-        self.assertEqual(P('.').suffixes, [])
-        self.assertEqual(P('/').suffixes, [])
-        self.assertEqual(P('a/b').suffixes, [])
-        self.assertEqual(P('/a/b').suffixes, [])
-        self.assertEqual(P('/a/b/.').suffixes, [])
-        self.assertEqual(P('a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('/a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('a/.hgrc').suffixes, [])
-        self.assertEqual(P('/a/.hgrc').suffixes, [])
-        self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('a/Some name. Ending with a dot.').suffixes, [])
-        self.assertEqual(P('/a/Some name. Ending with a dot.').suffixes, [])
-
-    def test_stem_common(self):
-        P = self.cls
-        self.assertEqual(P('').stem, '')
-        self.assertEqual(P('.').stem, '')
-        self.assertEqual(P('..').stem, '..')
-        self.assertEqual(P('/').stem, '')
-        self.assertEqual(P('a/b').stem, 'b')
-        self.assertEqual(P('a/b.py').stem, 'b')
-        self.assertEqual(P('a/.hgrc').stem, '.hgrc')
-        self.assertEqual(P('a/.hg.rc').stem, '.hg')
-        self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
-        self.assertEqual(P('a/Some name. Ending with a dot.').stem,
-                         'Some name. Ending with a dot.')
-
-    def test_with_name_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
-        self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
-        self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
-        self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
-        self.assertRaises(ValueError, P('').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('.').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('/').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('a/b').with_name, '')
-        self.assertRaises(ValueError, P('a/b').with_name, '.')
-        self.assertRaises(ValueError, P('a/b').with_name, '/c')
-        self.assertRaises(ValueError, P('a/b').with_name, 'c/')
-        self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
-
-    def test_with_stem_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
-        self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
-        self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
-        self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
-        self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
-        self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d'))
-        self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d'))
-        self.assertRaises(ValueError, P('').with_stem, 'd')
-        self.assertRaises(ValueError, P('.').with_stem, 'd')
-        self.assertRaises(ValueError, P('/').with_stem, 'd')
-        self.assertRaises(ValueError, P('a/b').with_stem, '')
-        self.assertRaises(ValueError, P('a/b').with_stem, '.')
-        self.assertRaises(ValueError, P('a/b').with_stem, '/c')
-        self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
-        self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
-
-    def test_with_suffix_common(self):
-        P = self.cls
-        self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
-        self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
-        self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
-        self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
-        # Stripping suffix.
-        self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
-        self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
-        # Path doesn't have a "filename" component.
-        self.assertRaises(ValueError, P('').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
-        # Invalid suffix.
-        self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '/')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
-        self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
-        self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
-        self.assertRaises(ValueError, P('a/b').with_suffix,
-                          (self.flavour.sep, 'd'))
-
-    def test_relative_to_common(self):
-        P = self.cls
-        p = P('a/b')
-        self.assertRaises(TypeError, p.relative_to)
-        self.assertRaises(TypeError, p.relative_to, b'a')
-        self.assertEqual(p.relative_to(P()), P('a/b'))
-        self.assertEqual(p.relative_to(''), P('a/b'))
-        self.assertEqual(p.relative_to(P('a')), P('b'))
-        self.assertEqual(p.relative_to('a'), P('b'))
-        self.assertEqual(p.relative_to('a/'), P('b'))
-        self.assertEqual(p.relative_to(P('a/b')), P())
-        self.assertEqual(p.relative_to('a/b'), P())
-        self.assertEqual(p.relative_to(P(), walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P())
-        self.assertEqual(p.relative_to('a/b', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
-        self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
-        # With several args.
-        with self.assertWarns(DeprecationWarning):
-            p.relative_to('a', 'b')
-            p.relative_to('a', 'b', walk_up=True)
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('c'))
-        self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
-        self.assertRaises(ValueError, p.relative_to, P('a/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a'))
-        self.assertRaises(ValueError, p.relative_to, P("../a"))
-        self.assertRaises(ValueError, p.relative_to, P("a/.."))
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
-        p = P('/a/b')
-        self.assertEqual(p.relative_to(P('/')), P('a/b'))
-        self.assertEqual(p.relative_to('/'), P('a/b'))
-        self.assertEqual(p.relative_to(P('/a')), P('b'))
-        self.assertEqual(p.relative_to('/a'), P('b'))
-        self.assertEqual(p.relative_to('/a/'), P('b'))
-        self.assertEqual(p.relative_to(P('/a/b')), P())
-        self.assertEqual(p.relative_to('/a/b'), P())
-        self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
-        self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
-        self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P())
-        self.assertEqual(p.relative_to('/a/b', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
-        self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
-        self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
-        self.assertRaises(ValueError, p.relative_to, P('/a/c'))
-        self.assertRaises(ValueError, p.relative_to, P())
-        self.assertRaises(ValueError, p.relative_to, '')
-        self.assertRaises(ValueError, p.relative_to, P('a'))
-        self.assertRaises(ValueError, p.relative_to, P("../a"))
-        self.assertRaises(ValueError, p.relative_to, P("a/.."))
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
-        self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
-
-    def test_is_relative_to_common(self):
-        P = self.cls
-        p = P('a/b')
-        self.assertRaises(TypeError, p.is_relative_to)
-        self.assertRaises(TypeError, p.is_relative_to, b'a')
-        self.assertTrue(p.is_relative_to(P()))
-        self.assertTrue(p.is_relative_to(''))
-        self.assertTrue(p.is_relative_to(P('a')))
-        self.assertTrue(p.is_relative_to('a/'))
-        self.assertTrue(p.is_relative_to(P('a/b')))
-        self.assertTrue(p.is_relative_to('a/b'))
-        # With several args.
-        with self.assertWarns(DeprecationWarning):
-            p.is_relative_to('a', 'b')
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('c')))
-        self.assertFalse(p.is_relative_to(P('a/b/c')))
-        self.assertFalse(p.is_relative_to(P('a/c')))
-        self.assertFalse(p.is_relative_to(P('/a')))
-        p = P('/a/b')
-        self.assertTrue(p.is_relative_to(P('/')))
-        self.assertTrue(p.is_relative_to('/'))
-        self.assertTrue(p.is_relative_to(P('/a')))
-        self.assertTrue(p.is_relative_to('/a'))
-        self.assertTrue(p.is_relative_to('/a/'))
-        self.assertTrue(p.is_relative_to(P('/a/b')))
-        self.assertTrue(p.is_relative_to('/a/b'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('/c')))
-        self.assertFalse(p.is_relative_to(P('/a/b/c')))
-        self.assertFalse(p.is_relative_to(P('/a/c')))
-        self.assertFalse(p.is_relative_to(P()))
-        self.assertFalse(p.is_relative_to(''))
-        self.assertFalse(p.is_relative_to(P('a')))
-
-    def test_pickling_common(self):
-        P = self.cls
-        p = P('/a/b')
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            dumped = pickle.dumps(p, proto)
-            pp = pickle.loads(dumped)
-            self.assertIs(pp.__class__, p.__class__)
-            self.assertEqual(pp, p)
-            self.assertEqual(hash(pp), hash(p))
-            self.assertEqual(str(pp), str(p))
-
-
-class PurePosixPathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PurePosixPath
-
-    def test_drive_root_parts(self):
-        check = self._check_drive_root_parts
-        # Collapsing of excess leading slashes, except for the double-slash
-        # special case.
-        check(('//a', 'b'),             '', '//', ('//', 'a', 'b'))
-        check(('///a', 'b'),            '', '/', ('/', 'a', 'b'))
-        check(('////a', 'b'),           '', '/', ('/', 'a', 'b'))
-        # Paths which look like NT paths aren't treated specially.
-        check(('c:a',),                 '', '', ('c:a',))
-        check(('c:\\a',),               '', '', ('c:\\a',))
-        check(('\\a',),                 '', '', ('\\a',))
-
-    def test_root(self):
-        P = self.cls
-        self.assertEqual(P('/a/b').root, '/')
-        self.assertEqual(P('///a/b').root, '/')
-        # POSIX special case for two leading slashes.
-        self.assertEqual(P('//a/b').root, '//')
-
-    def test_eq(self):
-        P = self.cls
-        self.assertNotEqual(P('a/b'), P('A/b'))
-        self.assertEqual(P('/a'), P('///a'))
-        self.assertNotEqual(P('/a'), P('//a'))
-
-    def test_as_uri(self):
-        P = self.cls
-        self.assertEqual(P('/').as_uri(), 'file:///')
-        self.assertEqual(P('/a/b.c').as_uri(), 'file:///a/b.c')
-        self.assertEqual(P('/a/b%#c').as_uri(), 'file:///a/b%25%23c')
-
-    def test_as_uri_non_ascii(self):
-        from urllib.parse import quote_from_bytes
-        P = self.cls
-        try:
-            os.fsencode('\xe9')
-        except UnicodeEncodeError:
-            self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
-        self.assertEqual(P('/a/b\xe9').as_uri(),
-                         'file:///a/b' + quote_from_bytes(os.fsencode('\xe9')))
-
-    def test_match(self):
-        P = self.cls
-        self.assertFalse(P('A.py').match('a.PY'))
-
-    def test_is_absolute(self):
-        P = self.cls
-        self.assertFalse(P().is_absolute())
-        self.assertFalse(P('a').is_absolute())
-        self.assertFalse(P('a/b/').is_absolute())
-        self.assertTrue(P('/').is_absolute())
-        self.assertTrue(P('/a').is_absolute())
-        self.assertTrue(P('/a/b/').is_absolute())
-        self.assertTrue(P('//a').is_absolute())
-        self.assertTrue(P('//a/b').is_absolute())
-
-    def test_is_reserved(self):
-        P = self.cls
-        self.assertIs(False, P('').is_reserved())
-        self.assertIs(False, P('/').is_reserved())
-        self.assertIs(False, P('/foo/bar').is_reserved())
-        self.assertIs(False, P('/dev/con/PRN/NUL').is_reserved())
-
-    def test_join(self):
-        P = self.cls
-        p = P('//a')
-        pp = p.joinpath('b')
-        self.assertEqual(pp, P('//a/b'))
-        pp = P('/a').joinpath('//c')
-        self.assertEqual(pp, P('//c'))
-        pp = P('//a').joinpath('/c')
-        self.assertEqual(pp, P('/c'))
-
-    def test_div(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('//a')
-        pp = p / 'b'
-        self.assertEqual(pp, P('//a/b'))
-        pp = P('/a') / '//c'
-        self.assertEqual(pp, P('//c'))
-        pp = P('//a') / '/c'
-        self.assertEqual(pp, P('/c'))
-
-    def test_parse_windows_path(self):
-        P = self.cls
-        p = P('c:', 'a', 'b')
-        pp = P(pathlib.PureWindowsPath('c:\\a\\b'))
-        self.assertEqual(p, pp)
-
-
-class PureWindowsPathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PureWindowsPath
-
-    equivalences = _BasePurePathTest.equivalences.copy()
-    equivalences.update({
-        './a:b': [ ('./a:b',) ],
-        'c:a': [ ('c:', 'a'), ('c:', 'a/'), ('.', 'c:', 'a') ],
-        'c:/a': [
-            ('c:/', 'a'), ('c:', '/', 'a'), ('c:', '/a'),
-            ('/z', 'c:/', 'a'), ('//x/y', 'c:/', 'a'),
-            ],
-        '//a/b/': [ ('//a/b',) ],
-        '//a/b/c': [
-            ('//a/b', 'c'), ('//a/b/', 'c'),
-            ],
-    })
-
-    def test_drive_root_parts(self):
-        check = self._check_drive_root_parts
-        # First part is anchored.
-        check(('c:',),                  'c:', '', ('c:',))
-        check(('c:/',),                 'c:', '\\', ('c:\\',))
-        check(('/',),                   '', '\\', ('\\',))
-        check(('c:a',),                 'c:', '', ('c:', 'a'))
-        check(('c:/a',),                'c:', '\\', ('c:\\', 'a'))
-        check(('/a',),                  '', '\\', ('\\', 'a'))
-        # UNC paths.
-        check(('//',),                  '\\\\', '', ('\\\\',))
-        check(('//a',),                 '\\\\a', '', ('\\\\a',))
-        check(('//a/',),                '\\\\a\\', '', ('\\\\a\\',))
-        check(('//a/b',),               '\\\\a\\b', '\\', ('\\\\a\\b\\',))
-        check(('//a/b/',),              '\\\\a\\b', '\\', ('\\\\a\\b\\',))
-        check(('//a/b/c',),             '\\\\a\\b', '\\', ('\\\\a\\b\\', 'c'))
-        # Second part is anchored, so that the first part is ignored.
-        check(('a', 'Z:b', 'c'),        'Z:', '', ('Z:', 'b', 'c'))
-        check(('a', 'Z:/b', 'c'),       'Z:', '\\', ('Z:\\', 'b', 'c'))
-        # UNC paths.
-        check(('a', '//b/c', 'd'),      '\\\\b\\c', '\\', ('\\\\b\\c\\', 'd'))
-        # Collapsing and stripping excess slashes.
-        check(('a', 'Z://b//c/', 'd/'), 'Z:', '\\', ('Z:\\', 'b', 'c', 'd'))
-        # UNC paths.
-        check(('a', '//b/c//', 'd'),    '\\\\b\\c', '\\', ('\\\\b\\c\\', 'd'))
-        # Extended paths.
-        check(('//./c:',),              '\\\\.\\c:', '', ('\\\\.\\c:',))
-        check(('//?/c:/',),             '\\\\?\\c:', '\\', ('\\\\?\\c:\\',))
-        check(('//?/c:/a',),            '\\\\?\\c:', '\\', ('\\\\?\\c:\\', 'a'))
-        check(('//?/c:/a', '/b'),       '\\\\?\\c:', '\\', ('\\\\?\\c:\\', 'b'))
-        # Extended UNC paths (format is "\\?\UNC\server\share").
-        check(('//?',),                 '\\\\?', '', ('\\\\?',))
-        check(('//?/',),                '\\\\?\\', '', ('\\\\?\\',))
-        check(('//?/UNC',),             '\\\\?\\UNC', '', ('\\\\?\\UNC',))
-        check(('//?/UNC/',),            '\\\\?\\UNC\\', '', ('\\\\?\\UNC\\',))
-        check(('//?/UNC/b',),           '\\\\?\\UNC\\b', '', ('\\\\?\\UNC\\b',))
-        check(('//?/UNC/b/',),          '\\\\?\\UNC\\b\\', '', ('\\\\?\\UNC\\b\\',))
-        check(('//?/UNC/b/c',),         '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\',))
-        check(('//?/UNC/b/c/',),        '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\',))
-        check(('//?/UNC/b/c/d',),       '\\\\?\\UNC\\b\\c', '\\', ('\\\\?\\UNC\\b\\c\\', 'd'))
-        # UNC device paths
-        check(('//./BootPartition/',),   '\\\\.\\BootPartition', '\\', ('\\\\.\\BootPartition\\',))
-        check(('//?/BootPartition/',),   '\\\\?\\BootPartition', '\\', ('\\\\?\\BootPartition\\',))
-        check(('//./PhysicalDrive0',),   '\\\\.\\PhysicalDrive0', '', ('\\\\.\\PhysicalDrive0',))
-        check(('//?/Volume{}/',),        '\\\\?\\Volume{}', '\\', ('\\\\?\\Volume{}\\',))
-        check(('//./nul',),              '\\\\.\\nul', '', ('\\\\.\\nul',))
-        # Second part has a root but not drive.
-        check(('a', '/b', 'c'),         '', '\\', ('\\', 'b', 'c'))
-        check(('Z:/a', '/b', 'c'),      'Z:', '\\', ('Z:\\', 'b', 'c'))
-        check(('//?/Z:/a', '/b', 'c'),  '\\\\?\\Z:', '\\', ('\\\\?\\Z:\\', 'b', 'c'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        check(('c:/a/b', 'c:x/y'),      'c:', '\\', ('c:\\', 'a', 'b', 'x', 'y'))
-        check(('c:/a/b', 'c:/x/y'),     'c:', '\\', ('c:\\', 'x', 'y'))
-        # Paths to files with NTFS alternate data streams
-        check(('./c:s',),               '', '', ('c:s',))
-        check(('cc:s',),                '', '', ('cc:s',))
-        check(('C:c:s',),               'C:', '', ('C:', 'c:s'))
-        check(('C:/c:s',),              'C:', '\\', ('C:\\', 'c:s'))
-        check(('D:a', './c:b'),         'D:', '', ('D:', 'a', 'c:b'))
-        check(('D:/a', './c:b'),        'D:', '\\', ('D:\\', 'a', 'c:b'))
-
-    def test_str(self):
-        p = self.cls('a/b/c')
-        self.assertEqual(str(p), 'a\\b\\c')
-        p = self.cls('c:/a/b/c')
-        self.assertEqual(str(p), 'c:\\a\\b\\c')
-        p = self.cls('//a/b')
-        self.assertEqual(str(p), '\\\\a\\b\\')
-        p = self.cls('//a/b/c')
-        self.assertEqual(str(p), '\\\\a\\b\\c')
-        p = self.cls('//a/b/c/d')
-        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
-
-    def test_str_subclass(self):
-        self._check_str_subclass('.\\a:b')
-        self._check_str_subclass('c:')
-        self._check_str_subclass('c:a')
-        self._check_str_subclass('c:a\\b.txt')
-        self._check_str_subclass('c:\\')
-        self._check_str_subclass('c:\\a')
-        self._check_str_subclass('c:\\a\\b.txt')
-        self._check_str_subclass('\\\\some\\share')
-        self._check_str_subclass('\\\\some\\share\\a')
-        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
-
-    def test_eq(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b'), P('c:a/b'))
-        self.assertEqual(P('c:a/b'), P('c:', 'a', 'b'))
-        self.assertNotEqual(P('c:a/b'), P('d:a/b'))
-        self.assertNotEqual(P('c:a/b'), P('c:/a/b'))
-        self.assertNotEqual(P('/a/b'), P('c:/a/b'))
-        # Case-insensitivity.
-        self.assertEqual(P('a/B'), P('A/b'))
-        self.assertEqual(P('C:a/B'), P('c:A/b'))
-        self.assertEqual(P('//Some/SHARE/a/B'), P('//somE/share/A/b'))
-        self.assertEqual(P('\u0130'), P('i\u0307'))
-
-    def test_as_uri(self):
-        P = self.cls
-        with self.assertRaises(ValueError):
-            P('/a/b').as_uri()
-        with self.assertRaises(ValueError):
-            P('c:a/b').as_uri()
-        self.assertEqual(P('c:/').as_uri(), 'file:///c:/')
-        self.assertEqual(P('c:/a/b.c').as_uri(), 'file:///c:/a/b.c')
-        self.assertEqual(P('c:/a/b%#c').as_uri(), 'file:///c:/a/b%25%23c')
-        self.assertEqual(P('c:/a/b\xe9').as_uri(), 'file:///c:/a/b%C3%A9')
-        self.assertEqual(P('//some/share/').as_uri(), 'file://some/share/')
-        self.assertEqual(P('//some/share/a/b.c').as_uri(),
-                         'file://some/share/a/b.c')
-        self.assertEqual(P('//some/share/a/b%#c\xe9').as_uri(),
-                         'file://some/share/a/b%25%23c%C3%A9')
-
-    def test_match(self):
-        P = self.cls
-        # Absolute patterns.
-        self.assertTrue(P('c:/b.py').match('*:/*.py'))
-        self.assertTrue(P('c:/b.py').match('c:/*.py'))
-        self.assertFalse(P('d:/b.py').match('c:/*.py'))  # wrong drive
-        self.assertFalse(P('b.py').match('/*.py'))
-        self.assertFalse(P('b.py').match('c:*.py'))
-        self.assertFalse(P('b.py').match('c:/*.py'))
-        self.assertFalse(P('c:b.py').match('/*.py'))
-        self.assertFalse(P('c:b.py').match('c:/*.py'))
-        self.assertFalse(P('/b.py').match('c:*.py'))
-        self.assertFalse(P('/b.py').match('c:/*.py'))
-        # UNC patterns.
-        self.assertTrue(P('//some/share/a.py').match('//*/*/*.py'))
-        self.assertTrue(P('//some/share/a.py').match('//some/share/*.py'))
-        self.assertFalse(P('//other/share/a.py').match('//some/share/*.py'))
-        self.assertFalse(P('//some/share/a/b.py').match('//some/share/*.py'))
-        # Case-insensitivity.
-        self.assertTrue(P('B.py').match('b.PY'))
-        self.assertTrue(P('c:/a/B.Py').match('C:/A/*.pY'))
-        self.assertTrue(P('//Some/Share/B.Py').match('//somE/sharE/*.pY'))
-        # Path anchor doesn't match pattern anchor
-        self.assertFalse(P('c:/b.py').match('/*.py'))  # 'c:/' vs '/'
-        self.assertFalse(P('c:/b.py').match('c:*.py'))  # 'c:/' vs 'c:'
-        self.assertFalse(P('//some/share/a.py').match('/*.py'))  # '//some/share/' vs '/'
-
-    def test_ordering_common(self):
-        # Case-insensitivity.
-        def assertOrderedEqual(a, b):
-            self.assertLessEqual(a, b)
-            self.assertGreaterEqual(b, a)
-        P = self.cls
-        p = P('c:A/b')
-        q = P('C:a/B')
-        assertOrderedEqual(p, q)
-        self.assertFalse(p < q)
-        self.assertFalse(p > q)
-        p = P('//some/Share/A/b')
-        q = P('//Some/SHARE/a/B')
-        assertOrderedEqual(p, q)
-        self.assertFalse(p < q)
-        self.assertFalse(p > q)
-
-    def test_parts(self):
-        P = self.cls
-        p = P('c:a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('c:', 'a', 'b'))
-        p = P('c:/a/b')
-        parts = p.parts
-        self.assertEqual(parts, ('c:\\', 'a', 'b'))
-        p = P('//a/b/c/d')
-        parts = p.parts
-        self.assertEqual(parts, ('\\\\a\\b\\', 'c', 'd'))
-
-    def test_parent(self):
-        # Anchored
-        P = self.cls
-        p = P('z:a/b/c')
-        self.assertEqual(p.parent, P('z:a/b'))
-        self.assertEqual(p.parent.parent, P('z:a'))
-        self.assertEqual(p.parent.parent.parent, P('z:'))
-        self.assertEqual(p.parent.parent.parent.parent, P('z:'))
-        p = P('z:/a/b/c')
-        self.assertEqual(p.parent, P('z:/a/b'))
-        self.assertEqual(p.parent.parent, P('z:/a'))
-        self.assertEqual(p.parent.parent.parent, P('z:/'))
-        self.assertEqual(p.parent.parent.parent.parent, P('z:/'))
-        p = P('//a/b/c/d')
-        self.assertEqual(p.parent, P('//a/b/c'))
-        self.assertEqual(p.parent.parent, P('//a/b'))
-        self.assertEqual(p.parent.parent.parent, P('//a/b'))
-
-    def test_parents(self):
-        # Anchored
-        P = self.cls
-        p = P('z:a/b/')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('z:a'))
-        self.assertEqual(par[1], P('z:'))
-        self.assertEqual(par[0:1], (P('z:a'),))
-        self.assertEqual(par[:-1], (P('z:a'),))
-        self.assertEqual(par[:2], (P('z:a'), P('z:')))
-        self.assertEqual(par[1:], (P('z:'),))
-        self.assertEqual(par[::2], (P('z:a'),))
-        self.assertEqual(par[::-1], (P('z:'), P('z:a')))
-        self.assertEqual(list(par), [P('z:a'), P('z:')])
-        with self.assertRaises(IndexError):
-            par[2]
-        p = P('z:/a/b/')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('z:/a'))
-        self.assertEqual(par[1], P('z:/'))
-        self.assertEqual(par[0:1], (P('z:/a'),))
-        self.assertEqual(par[0:-1], (P('z:/a'),))
-        self.assertEqual(par[:2], (P('z:/a'), P('z:/')))
-        self.assertEqual(par[1:], (P('z:/'),))
-        self.assertEqual(par[::2], (P('z:/a'),))
-        self.assertEqual(par[::-1], (P('z:/'), P('z:/a'),))
-        self.assertEqual(list(par), [P('z:/a'), P('z:/')])
-        with self.assertRaises(IndexError):
-            par[2]
-        p = P('//a/b/c/d')
-        par = p.parents
-        self.assertEqual(len(par), 2)
-        self.assertEqual(par[0], P('//a/b/c'))
-        self.assertEqual(par[1], P('//a/b'))
-        self.assertEqual(par[0:1], (P('//a/b/c'),))
-        self.assertEqual(par[0:-1], (P('//a/b/c'),))
-        self.assertEqual(par[:2], (P('//a/b/c'), P('//a/b')))
-        self.assertEqual(par[1:], (P('//a/b'),))
-        self.assertEqual(par[::2], (P('//a/b/c'),))
-        self.assertEqual(par[::-1], (P('//a/b'), P('//a/b/c')))
-        self.assertEqual(list(par), [P('//a/b/c'), P('//a/b')])
-        with self.assertRaises(IndexError):
-            par[2]
-
-    def test_drive(self):
-        P = self.cls
-        self.assertEqual(P('c:').drive, 'c:')
-        self.assertEqual(P('c:a/b').drive, 'c:')
-        self.assertEqual(P('c:/').drive, 'c:')
-        self.assertEqual(P('c:/a/b/').drive, 'c:')
-        self.assertEqual(P('//a/b').drive, '\\\\a\\b')
-        self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
-        self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
-        self.assertEqual(P('./c:a').drive, '')
-
-    def test_root(self):
-        P = self.cls
-        self.assertEqual(P('c:').root, '')
-        self.assertEqual(P('c:a/b').root, '')
-        self.assertEqual(P('c:/').root, '\\')
-        self.assertEqual(P('c:/a/b/').root, '\\')
-        self.assertEqual(P('//a/b').root, '\\')
-        self.assertEqual(P('//a/b/').root, '\\')
-        self.assertEqual(P('//a/b/c/d').root, '\\')
-
-    def test_anchor(self):
-        P = self.cls
-        self.assertEqual(P('c:').anchor, 'c:')
-        self.assertEqual(P('c:a/b').anchor, 'c:')
-        self.assertEqual(P('c:/').anchor, 'c:\\')
-        self.assertEqual(P('c:/a/b/').anchor, 'c:\\')
-        self.assertEqual(P('//a/b').anchor, '\\\\a\\b\\')
-        self.assertEqual(P('//a/b/').anchor, '\\\\a\\b\\')
-        self.assertEqual(P('//a/b/c/d').anchor, '\\\\a\\b\\')
-
-    def test_name(self):
-        P = self.cls
-        self.assertEqual(P('c:').name, '')
-        self.assertEqual(P('c:/').name, '')
-        self.assertEqual(P('c:a/b').name, 'b')
-        self.assertEqual(P('c:/a/b').name, 'b')
-        self.assertEqual(P('c:a/b.py').name, 'b.py')
-        self.assertEqual(P('c:/a/b.py').name, 'b.py')
-        self.assertEqual(P('//My.py/Share.php').name, '')
-        self.assertEqual(P('//My.py/Share.php/a/b').name, 'b')
-
-    def test_suffix(self):
-        P = self.cls
-        self.assertEqual(P('c:').suffix, '')
-        self.assertEqual(P('c:/').suffix, '')
-        self.assertEqual(P('c:a/b').suffix, '')
-        self.assertEqual(P('c:/a/b').suffix, '')
-        self.assertEqual(P('c:a/b.py').suffix, '.py')
-        self.assertEqual(P('c:/a/b.py').suffix, '.py')
-        self.assertEqual(P('c:a/.hgrc').suffix, '')
-        self.assertEqual(P('c:/a/.hgrc').suffix, '')
-        self.assertEqual(P('c:a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('c:/a/.hg.rc').suffix, '.rc')
-        self.assertEqual(P('c:a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('c:/a/b.tar.gz').suffix, '.gz')
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffix, '')
-        self.assertEqual(P('//My.py/Share.php').suffix, '')
-        self.assertEqual(P('//My.py/Share.php/a/b').suffix, '')
-
-    def test_suffixes(self):
-        P = self.cls
-        self.assertEqual(P('c:').suffixes, [])
-        self.assertEqual(P('c:/').suffixes, [])
-        self.assertEqual(P('c:a/b').suffixes, [])
-        self.assertEqual(P('c:/a/b').suffixes, [])
-        self.assertEqual(P('c:a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('c:/a/b.py').suffixes, ['.py'])
-        self.assertEqual(P('c:a/.hgrc').suffixes, [])
-        self.assertEqual(P('c:/a/.hgrc').suffixes, [])
-        self.assertEqual(P('c:a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('c:/a/.hg.rc').suffixes, ['.rc'])
-        self.assertEqual(P('c:a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('c:/a/b.tar.gz').suffixes, ['.tar', '.gz'])
-        self.assertEqual(P('//My.py/Share.php').suffixes, [])
-        self.assertEqual(P('//My.py/Share.php/a/b').suffixes, [])
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffixes, [])
-        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffixes, [])
-
-    def test_stem(self):
-        P = self.cls
-        self.assertEqual(P('c:').stem, '')
-        self.assertEqual(P('c:.').stem, '')
-        self.assertEqual(P('c:..').stem, '..')
-        self.assertEqual(P('c:/').stem, '')
-        self.assertEqual(P('c:a/b').stem, 'b')
-        self.assertEqual(P('c:a/b.py').stem, 'b')
-        self.assertEqual(P('c:a/.hgrc').stem, '.hgrc')
-        self.assertEqual(P('c:a/.hg.rc').stem, '.hg')
-        self.assertEqual(P('c:a/b.tar.gz').stem, 'b.tar')
-        self.assertEqual(P('c:a/Some name. Ending with a dot.').stem,
-                         'Some name. Ending with a dot.')
-
-    def test_with_name(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_name('d.xml'), P('c:a/d.xml'))
-        self.assertEqual(P('c:/a/b').with_name('d.xml'), P('c:/a/d.xml'))
-        self.assertEqual(P('c:a/Dot ending.').with_name('d.xml'), P('c:a/d.xml'))
-        self.assertEqual(P('c:/a/Dot ending.').with_name('d.xml'), P('c:/a/d.xml'))
-        self.assertRaises(ValueError, P('c:').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('c:/').with_name, 'd.xml')
-        self.assertRaises(ValueError, P('//My/Share').with_name, 'd.xml')
-        self.assertEqual(str(P('a').with_name('d:')), '.\\d:')
-        self.assertEqual(str(P('a').with_name('d:e')), '.\\d:e')
-        self.assertEqual(P('c:a/b').with_name('d:'), P('c:a/d:'))
-        self.assertEqual(P('c:a/b').with_name('d:e'), P('c:a/d:e'))
-        self.assertRaises(ValueError, P('c:a/b').with_name, 'd:/e')
-        self.assertRaises(ValueError, P('c:a/b').with_name, '//My/Share')
-
-    def test_with_stem(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_stem('d'), P('c:a/d'))
-        self.assertEqual(P('c:/a/b').with_stem('d'), P('c:/a/d'))
-        self.assertEqual(P('c:a/Dot ending.').with_stem('d'), P('c:a/d'))
-        self.assertEqual(P('c:/a/Dot ending.').with_stem('d'), P('c:/a/d'))
-        self.assertRaises(ValueError, P('c:').with_stem, 'd')
-        self.assertRaises(ValueError, P('c:/').with_stem, 'd')
-        self.assertRaises(ValueError, P('//My/Share').with_stem, 'd')
-        self.assertEqual(str(P('a').with_stem('d:')), '.\\d:')
-        self.assertEqual(str(P('a').with_stem('d:e')), '.\\d:e')
-        self.assertEqual(P('c:a/b').with_stem('d:'), P('c:a/d:'))
-        self.assertEqual(P('c:a/b').with_stem('d:e'), P('c:a/d:e'))
-        self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:/e')
-        self.assertRaises(ValueError, P('c:a/b').with_stem, '//My/Share')
-
-    def test_with_suffix(self):
-        P = self.cls
-        self.assertEqual(P('c:a/b').with_suffix('.gz'), P('c:a/b.gz'))
-        self.assertEqual(P('c:/a/b').with_suffix('.gz'), P('c:/a/b.gz'))
-        self.assertEqual(P('c:a/b.py').with_suffix('.gz'), P('c:a/b.gz'))
-        self.assertEqual(P('c:/a/b.py').with_suffix('.gz'), P('c:/a/b.gz'))
-        # Path doesn't have a "filename" component.
-        self.assertRaises(ValueError, P('').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
-        self.assertRaises(ValueError, P('//My/Share').with_suffix, '.gz')
-        # Invalid suffix.
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:.gz')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c/d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c\\d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c/d')
-        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c\\d')
-
-    def test_relative_to(self):
-        P = self.cls
-        p = P('C:Foo/Bar')
-        self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO'), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:foO/baR')), P())
-        self.assertEqual(p.relative_to('c:foO/baR'), P())
-        self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
-        self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
-        self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
-        self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P())
-        self.assertRaises(ValueError, p.relative_to, '')
-        self.assertRaises(ValueError, p.relative_to, P('d:'))
-        self.assertRaises(ValueError, p.relative_to, P('/'))
-        self.assertRaises(ValueError, p.relative_to, P('Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
-        p = P('C:/Foo/Bar')
-        self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
-        self.assertEqual(p.relative_to('c:/foO/baR'), P())
-        self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
-        self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
-        self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
-        self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
-        self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, 'c:')
-        self.assertRaises(ValueError, p.relative_to, P('c:'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('d:'))
-        self.assertRaises(ValueError, p.relative_to, P('d:/'))
-        self.assertRaises(ValueError, p.relative_to, P('/'))
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
-        self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
-        # UNC paths.
-        p = P('//Server/Share/Foo/Bar')
-        self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
-        self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
-        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
-        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
-        self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
-        self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
-        # Unrelated paths.
-        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
-        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
-        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
-
-    def test_is_relative_to(self):
-        P = self.cls
-        p = P('C:Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('c:')))
-        self.assertTrue(p.is_relative_to('c:'))
-        self.assertTrue(p.is_relative_to(P('c:foO')))
-        self.assertTrue(p.is_relative_to('c:foO'))
-        self.assertTrue(p.is_relative_to('c:foO/'))
-        self.assertTrue(p.is_relative_to(P('c:foO/baR')))
-        self.assertTrue(p.is_relative_to('c:foO/baR'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P()))
-        self.assertFalse(p.is_relative_to(''))
-        self.assertFalse(p.is_relative_to(P('d:')))
-        self.assertFalse(p.is_relative_to(P('/')))
-        self.assertFalse(p.is_relative_to(P('Foo')))
-        self.assertFalse(p.is_relative_to(P('/Foo')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo')))
-        self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
-        p = P('C:/Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('c:/')))
-        self.assertTrue(p.is_relative_to(P('c:/foO')))
-        self.assertTrue(p.is_relative_to('c:/foO/'))
-        self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
-        self.assertTrue(p.is_relative_to('c:/foO/baR'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to('c:'))
-        self.assertFalse(p.is_relative_to(P('C:/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
-        self.assertFalse(p.is_relative_to(P('C:Foo')))
-        self.assertFalse(p.is_relative_to(P('d:')))
-        self.assertFalse(p.is_relative_to(P('d:/')))
-        self.assertFalse(p.is_relative_to(P('/')))
-        self.assertFalse(p.is_relative_to(P('/Foo')))
-        self.assertFalse(p.is_relative_to(P('//C/Foo')))
-        # UNC paths.
-        p = P('//Server/Share/Foo/Bar')
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare'))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/'))
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
-        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
-        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
-        # Unrelated paths.
-        self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
-        self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
-
-    def test_is_absolute(self):
-        P = self.cls
-        # Under NT, only paths with both a drive and a root are absolute.
-        self.assertFalse(P().is_absolute())
-        self.assertFalse(P('a').is_absolute())
-        self.assertFalse(P('a/b/').is_absolute())
-        self.assertFalse(P('/').is_absolute())
-        self.assertFalse(P('/a').is_absolute())
-        self.assertFalse(P('/a/b/').is_absolute())
-        self.assertFalse(P('c:').is_absolute())
-        self.assertFalse(P('c:a').is_absolute())
-        self.assertFalse(P('c:a/b/').is_absolute())
-        self.assertTrue(P('c:/').is_absolute())
-        self.assertTrue(P('c:/a').is_absolute())
-        self.assertTrue(P('c:/a/b/').is_absolute())
-        # UNC paths are absolute by definition.
-        self.assertTrue(P('//a/b').is_absolute())
-        self.assertTrue(P('//a/b/').is_absolute())
-        self.assertTrue(P('//a/b/c').is_absolute())
-        self.assertTrue(P('//a/b/c/d').is_absolute())
-
-    def test_join(self):
-        P = self.cls
-        p = P('C:/a/b')
-        pp = p.joinpath('x/y')
-        self.assertEqual(pp, P('C:/a/b/x/y'))
-        pp = p.joinpath('/x/y')
-        self.assertEqual(pp, P('C:/x/y'))
-        # Joining with a different drive => the first path is ignored, even
-        # if the second path is relative.
-        pp = p.joinpath('D:x/y')
-        self.assertEqual(pp, P('D:x/y'))
-        pp = p.joinpath('D:/x/y')
-        self.assertEqual(pp, P('D:/x/y'))
-        pp = p.joinpath('//host/share/x/y')
-        self.assertEqual(pp, P('//host/share/x/y'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        pp = p.joinpath('c:x/y')
-        self.assertEqual(pp, P('C:/a/b/x/y'))
-        pp = p.joinpath('c:/x/y')
-        self.assertEqual(pp, P('C:/x/y'))
-        # Joining with files with NTFS data streams => the filename should
-        # not be parsed as a drive letter
-        pp = p.joinpath(P('./d:s'))
-        self.assertEqual(pp, P('C:/a/b/d:s'))
-        pp = p.joinpath(P('./dd:s'))
-        self.assertEqual(pp, P('C:/a/b/dd:s'))
-        pp = p.joinpath(P('E:d:s'))
-        self.assertEqual(pp, P('E:d:s'))
-        # Joining onto a UNC path with no root
-        pp = P('//').joinpath('server')
-        self.assertEqual(pp, P('//server'))
-        pp = P('//server').joinpath('share')
-        self.assertEqual(pp, P('//server/share'))
-        pp = P('//./BootPartition').joinpath('Windows')
-        self.assertEqual(pp, P('//./BootPartition/Windows'))
-
-    def test_div(self):
-        # Basically the same as joinpath().
-        P = self.cls
-        p = P('C:/a/b')
-        self.assertEqual(p / 'x/y', P('C:/a/b/x/y'))
-        self.assertEqual(p / 'x' / 'y', P('C:/a/b/x/y'))
-        self.assertEqual(p / '/x/y', P('C:/x/y'))
-        self.assertEqual(p / '/x' / 'y', P('C:/x/y'))
-        # Joining with a different drive => the first path is ignored, even
-        # if the second path is relative.
-        self.assertEqual(p / 'D:x/y', P('D:x/y'))
-        self.assertEqual(p / 'D:' / 'x/y', P('D:x/y'))
-        self.assertEqual(p / 'D:/x/y', P('D:/x/y'))
-        self.assertEqual(p / 'D:' / '/x/y', P('D:/x/y'))
-        self.assertEqual(p / '//host/share/x/y', P('//host/share/x/y'))
-        # Joining with the same drive => the first path is appended to if
-        # the second path is relative.
-        self.assertEqual(p / 'c:x/y', P('C:/a/b/x/y'))
-        self.assertEqual(p / 'c:/x/y', P('C:/x/y'))
-        # Joining with files with NTFS data streams => the filename should
-        # not be parsed as a drive letter
-        self.assertEqual(p / P('./d:s'), P('C:/a/b/d:s'))
-        self.assertEqual(p / P('./dd:s'), P('C:/a/b/dd:s'))
-        self.assertEqual(p / P('E:d:s'), P('E:d:s'))
-
-    def test_is_reserved(self):
-        P = self.cls
-        self.assertIs(False, P('').is_reserved())
-        self.assertIs(False, P('/').is_reserved())
-        self.assertIs(False, P('/foo/bar').is_reserved())
-        # UNC paths are never reserved.
-        self.assertIs(False, P('//my/share/nul/con/aux').is_reserved())
-        # Case-insensitive DOS-device names are reserved.
-        self.assertIs(True, P('nul').is_reserved())
-        self.assertIs(True, P('aux').is_reserved())
-        self.assertIs(True, P('prn').is_reserved())
-        self.assertIs(True, P('con').is_reserved())
-        self.assertIs(True, P('conin$').is_reserved())
-        self.assertIs(True, P('conout$').is_reserved())
-        # COM/LPT + 1-9 or + superscript 1-3 are reserved.
-        self.assertIs(True, P('COM1').is_reserved())
-        self.assertIs(True, P('LPT9').is_reserved())
-        self.assertIs(True, P('com\xb9').is_reserved())
-        self.assertIs(True, P('com\xb2').is_reserved())
-        self.assertIs(True, P('lpt\xb3').is_reserved())
-        # DOS-device name mataching ignores characters after a dot or
-        # a colon and also ignores trailing spaces.
-        self.assertIs(True, P('NUL.txt').is_reserved())
-        self.assertIs(True, P('PRN  ').is_reserved())
-        self.assertIs(True, P('AUX  .txt').is_reserved())
-        self.assertIs(True, P('COM1:bar').is_reserved())
-        self.assertIs(True, P('LPT9   :bar').is_reserved())
-        # DOS-device names are only matched at the beginning
-        # of a path component.
-        self.assertIs(False, P('bar.com9').is_reserved())
-        self.assertIs(False, P('bar.lpt9').is_reserved())
-        # Only the last path component matters.
-        self.assertIs(True, P('c:/baz/con/NUL').is_reserved())
-        self.assertIs(False, P('c:/NUL/con/baz').is_reserved())
-
-class PurePathTest(_BasePurePathTest, unittest.TestCase):
-    cls = pathlib.PurePath
-
-    def test_concrete_class(self):
-        p = self.cls('a')
-        self.assertIs(type(p),
-            pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath)
-
-    def test_different_flavours_unequal(self):
-        p = pathlib.PurePosixPath('a')
-        q = pathlib.PureWindowsPath('a')
-        self.assertNotEqual(p, q)
-
-    def test_different_flavours_unordered(self):
-        p = pathlib.PurePosixPath('a')
-        q = pathlib.PureWindowsPath('a')
-        with self.assertRaises(TypeError):
-            p < q
-        with self.assertRaises(TypeError):
-            p <= q
-        with self.assertRaises(TypeError):
-            p > q
-        with self.assertRaises(TypeError):
-            p >= q
-
-
-#
-# Tests for the concrete classes.
-#
-
-# Make sure any symbolic links in the base test path are resolved.
-BASE = os.path.realpath(TESTFN)
-join = lambda *x: os.path.join(BASE, *x)
-rel_join = lambda *x: os.path.join(TESTFN, *x)
-
-only_nt = unittest.skipIf(os.name != 'nt',
-                          'test requires a Windows-compatible system')
-only_posix = unittest.skipIf(os.name == 'nt',
-                             'test requires a POSIX-compatible system')
-
-@only_posix
-class PosixPathAsPureTest(PurePosixPathTest):
-    cls = pathlib.PosixPath
-
-@only_nt
-class WindowsPathAsPureTest(PureWindowsPathTest):
-    cls = pathlib.WindowsPath
-
-    def test_owner(self):
-        P = self.cls
-        with self.assertRaises(NotImplementedError):
-            P('c:/').owner()
-
-    def test_group(self):
-        P = self.cls
-        with self.assertRaises(NotImplementedError):
-            P('c:/').group()
-
-
-class _BasePathTest(object):
-    """Tests for the FS-accessing functionalities of the Path classes."""
-
-    # (BASE)
-    #  |
-    #  |-- brokenLink -> non-existing
-    #  |-- dirA
-    #  |   `-- linkC -> ../dirB
-    #  |-- dirB
-    #  |   |-- fileB
-    #  |   `-- linkD -> ../dirB
-    #  |-- dirC
-    #  |   |-- dirD
-    #  |   |   `-- fileD
-    #  |   `-- fileC
-    #  |   `-- novel.txt
-    #  |-- dirE  # No permissions
-    #  |-- fileA
-    #  |-- linkA -> fileA
-    #  |-- linkB -> dirB
-    #  `-- brokenLinkLoop -> brokenLinkLoop
-    #
-
-    def setUp(self):
-        def cleanup():
-            os.chmod(join('dirE'), 0o777)
-            os_helper.rmtree(BASE)
-        self.addCleanup(cleanup)
-        os.mkdir(BASE)
-        os.mkdir(join('dirA'))
-        os.mkdir(join('dirB'))
-        os.mkdir(join('dirC'))
-        os.mkdir(join('dirC', 'dirD'))
-        os.mkdir(join('dirE'))
-        with open(join('fileA'), 'wb') as f:
-            f.write(b"this is file A\n")
-        with open(join('dirB', 'fileB'), 'wb') as f:
-            f.write(b"this is file B\n")
-        with open(join('dirC', 'fileC'), 'wb') as f:
-            f.write(b"this is file C\n")
-        with open(join('dirC', 'novel.txt'), 'wb') as f:
-            f.write(b"this is a novel\n")
-        with open(join('dirC', 'dirD', 'fileD'), 'wb') as f:
-            f.write(b"this is file D\n")
-        os.chmod(join('dirE'), 0)
-        if os_helper.can_symlink():
-            # Relative symlinks.
-            os.symlink('fileA', join('linkA'))
-            os.symlink('non-existing', join('brokenLink'))
-            self.dirlink('dirB', join('linkB'))
-            self.dirlink(os.path.join('..', 'dirB'), join('dirA', 'linkC'))
-            # This one goes upwards, creating a loop.
-            self.dirlink(os.path.join('..', 'dirB'), join('dirB', 'linkD'))
-            # Broken symlink (pointing to itself).
-            os.symlink('brokenLinkLoop',  join('brokenLinkLoop'))
-
-    if os.name == 'nt':
-        # Workaround for http://bugs.python.org/issue13772.
-        def dirlink(self, src, dest):
-            os.symlink(src, dest, target_is_directory=True)
-    else:
-        def dirlink(self, src, dest):
-            os.symlink(src, dest)
-
-    def assertSame(self, path_a, path_b):
-        self.assertTrue(os.path.samefile(str(path_a), str(path_b)),
-                        "%r and %r don't point to the same file" %
-                        (path_a, path_b))
-
-    def assertFileNotFound(self, func, *args, **kwargs):
-        with self.assertRaises(FileNotFoundError) as cm:
-            func(*args, **kwargs)
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-
-    def assertEqualNormCase(self, path_a, path_b):
-        self.assertEqual(os.path.normcase(path_a), os.path.normcase(path_b))
-
-    def _test_cwd(self, p):
-        q = self.cls(os.getcwd())
-        self.assertEqual(p, q)
-        self.assertEqualNormCase(str(p), str(q))
-        self.assertIs(type(p), type(q))
-        self.assertTrue(p.is_absolute())
-
-    def test_cwd(self):
-        p = self.cls.cwd()
-        self._test_cwd(p)
-
-    def test_absolute_common(self):
-        P = self.cls
-
-        with mock.patch("os.getcwd") as getcwd:
-            getcwd.return_value = BASE
-
-            # Simple relative paths.
-            self.assertEqual(str(P().absolute()), BASE)
-            self.assertEqual(str(P('.').absolute()), BASE)
-            self.assertEqual(str(P('a').absolute()), os.path.join(BASE, 'a'))
-            self.assertEqual(str(P('a', 'b', 'c').absolute()), os.path.join(BASE, 'a', 'b', 'c'))
-
-            # Symlinks should not be resolved.
-            self.assertEqual(str(P('linkB', 'fileB').absolute()), os.path.join(BASE, 'linkB', 'fileB'))
-            self.assertEqual(str(P('brokenLink').absolute()), os.path.join(BASE, 'brokenLink'))
-            self.assertEqual(str(P('brokenLinkLoop').absolute()), os.path.join(BASE, 'brokenLinkLoop'))
-
-            # '..' entries should be preserved and not normalised.
-            self.assertEqual(str(P('..').absolute()), os.path.join(BASE, '..'))
-            self.assertEqual(str(P('a', '..').absolute()), os.path.join(BASE, 'a', '..'))
-            self.assertEqual(str(P('..', 'b').absolute()), os.path.join(BASE, '..', 'b'))
-
-    def _test_home(self, p):
-        q = self.cls(os.path.expanduser('~'))
-        self.assertEqual(p, q)
-        self.assertEqualNormCase(str(p), str(q))
-        self.assertIs(type(p), type(q))
-        self.assertTrue(p.is_absolute())
-
-    @unittest.skipIf(
-        pwd is None, reason="Test requires pwd module to get homedir."
-    )
-    def test_home(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            self._test_home(self.cls.home())
-
-            env.clear()
-            env['USERPROFILE'] = os.path.join(BASE, 'userprofile')
-            self._test_home(self.cls.home())
-
-            # bpo-38883: ignore `HOME` when set on windows
-            env['HOME'] = os.path.join(BASE, 'home')
-            self._test_home(self.cls.home())
-
-    @unittest.skip("TODO: RUSTPYTHON; PyObject::set_slot index out of bounds")
-    def test_with_segments(self):
-        class P(_BasePurePathSubclass, self.cls):
-            pass
-        p = P(BASE, session_id=42)
-        self.assertEqual(42, p.absolute().session_id)
-        self.assertEqual(42, p.resolve().session_id)
-        if not is_wasi:  # WASI has no user accounts.
-            self.assertEqual(42, p.with_segments('~').expanduser().session_id)
-        self.assertEqual(42, (p / 'fileA').rename(p / 'fileB').session_id)
-        self.assertEqual(42, (p / 'fileB').replace(p / 'fileA').session_id)
-        if os_helper.can_symlink():
-            self.assertEqual(42, (p / 'linkA').readlink().session_id)
-        for path in p.iterdir():
-            self.assertEqual(42, path.session_id)
-        for path in p.glob('*'):
-            self.assertEqual(42, path.session_id)
-        for path in p.rglob('*'):
-            self.assertEqual(42, path.session_id)
-        for dirpath, dirnames, filenames in p.walk():
-            self.assertEqual(42, dirpath.session_id)
-
-    def test_samefile(self):
-        fileA_path = os.path.join(BASE, 'fileA')
-        fileB_path = os.path.join(BASE, 'dirB', 'fileB')
-        p = self.cls(fileA_path)
-        pp = self.cls(fileA_path)
-        q = self.cls(fileB_path)
-        self.assertTrue(p.samefile(fileA_path))
-        self.assertTrue(p.samefile(pp))
-        self.assertFalse(p.samefile(fileB_path))
-        self.assertFalse(p.samefile(q))
-        # Test the non-existent file case
-        non_existent = os.path.join(BASE, 'foo')
-        r = self.cls(non_existent)
-        self.assertRaises(FileNotFoundError, p.samefile, r)
-        self.assertRaises(FileNotFoundError, p.samefile, non_existent)
-        self.assertRaises(FileNotFoundError, r.samefile, p)
-        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
-        self.assertRaises(FileNotFoundError, r.samefile, r)
-        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
-
-    def test_empty_path(self):
-        # The empty path points to '.'
-        p = self.cls('')
-        self.assertEqual(p.stat(), os.stat('.'))
-
-    @unittest.skipIf(is_wasi, "WASI has no user accounts.")
-    def test_expanduser_common(self):
-        P = self.cls
-        p = P('~')
-        self.assertEqual(p.expanduser(), P(os.path.expanduser('~')))
-        p = P('foo')
-        self.assertEqual(p.expanduser(), p)
-        p = P('/~')
-        self.assertEqual(p.expanduser(), p)
-        p = P('../~')
-        self.assertEqual(p.expanduser(), p)
-        p = P(P('').absolute().anchor) / '~'
-        self.assertEqual(p.expanduser(), p)
-        p = P('~/a:b')
-        self.assertEqual(p.expanduser(), P(os.path.expanduser('~'), './a:b'))
-
-    def test_exists(self):
-        P = self.cls
-        p = P(BASE)
-        self.assertIs(True, p.exists())
-        self.assertIs(True, (p / 'dirA').exists())
-        self.assertIs(True, (p / 'fileA').exists())
-        self.assertIs(False, (p / 'fileA' / 'bah').exists())
-        if os_helper.can_symlink():
-            self.assertIs(True, (p / 'linkA').exists())
-            self.assertIs(True, (p / 'linkB').exists())
-            self.assertIs(True, (p / 'linkB' / 'fileB').exists())
-            self.assertIs(False, (p / 'linkA' / 'bah').exists())
-            self.assertIs(False, (p / 'brokenLink').exists())
-            self.assertIs(True, (p / 'brokenLink').exists(follow_symlinks=False))
-        self.assertIs(False, (p / 'foo').exists())
-        self.assertIs(False, P('/xyzzy').exists())
-        self.assertIs(False, P(BASE + '\udfff').exists())
-        self.assertIs(False, P(BASE + '\x00').exists())
-
-    def test_open_common(self):
-        p = self.cls(BASE)
-        with (p / 'fileA').open('r') as f:
-            self.assertIsInstance(f, io.TextIOBase)
-            self.assertEqual(f.read(), "this is file A\n")
-        with (p / 'fileA').open('rb') as f:
-            self.assertIsInstance(f, io.BufferedIOBase)
-            self.assertEqual(f.read().strip(), b"this is file A")
-        with (p / 'fileA').open('rb', buffering=0) as f:
-            self.assertIsInstance(f, io.RawIOBase)
-            self.assertEqual(f.read().strip(), b"this is file A")
-
-    def test_read_write_bytes(self):
-        p = self.cls(BASE)
-        (p / 'fileA').write_bytes(b'abcdefg')
-        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
-        # Check that trying to write str does not truncate the file.
-        self.assertRaises(TypeError, (p / 'fileA').write_bytes, 'somestr')
-        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
-
-    def test_read_write_text(self):
-        p = self.cls(BASE)
-        (p / 'fileA').write_text('äbcdefg', encoding='latin-1')
-        self.assertEqual((p / 'fileA').read_text(
-            encoding='utf-8', errors='ignore'), 'bcdefg')
-        # Check that trying to write bytes does not truncate the file.
-        self.assertRaises(TypeError, (p / 'fileA').write_text, b'somebytes')
-        self.assertEqual((p / 'fileA').read_text(encoding='latin-1'), 'äbcdefg')
-
-    def test_write_text_with_newlines(self):
-        p = self.cls(BASE)
-        # Check that `\n` character change nothing
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\n')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\nfghlk\n\rmnopq')
-        # Check that `\r` character replaces `\n`
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\rfghlk\r\rmnopq')
-        # Check that `\r\n` character replaces `\n`
-        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r\n')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                         b'abcde\r\r\nfghlk\r\n\rmnopq')
-        # Check that no argument passed will change `\n` to `os.linesep`
-        os_linesep_byte = bytes(os.linesep, encoding='ascii')
-        (p / 'fileA').write_text('abcde\nfghlk\n\rmnopq')
-        self.assertEqual((p / 'fileA').read_bytes(),
-                          b'abcde' + os_linesep_byte + b'fghlk' + os_linesep_byte + b'\rmnopq')
-
-    def test_iterdir(self):
-        P = self.cls
-        p = P(BASE)
-        it = p.iterdir()
-        paths = set(it)
-        expected = ['dirA', 'dirB', 'dirC', 'dirE', 'fileA']
-        if os_helper.can_symlink():
-            expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
-        self.assertEqual(paths, { P(BASE, q) for q in expected })
-
-    @os_helper.skip_unless_symlink
-    def test_iterdir_symlink(self):
-        # __iter__ on a symlink to a directory.
-        P = self.cls
-        p = P(BASE, 'linkB')
-        paths = set(p.iterdir())
-        expected = { P(BASE, 'linkB', q) for q in ['fileB', 'linkD'] }
-        self.assertEqual(paths, expected)
-
-    def test_iterdir_nodir(self):
-        # __iter__ on something that is not a directory.
-        p = self.cls(BASE, 'fileA')
-        with self.assertRaises(OSError) as cm:
-            next(p.iterdir())
-        # ENOENT or EINVAL under Windows, ENOTDIR otherwise
-        # (see issue #12802).
-        self.assertIn(cm.exception.errno, (errno.ENOTDIR,
-                                           errno.ENOENT, errno.EINVAL))
-
-    def test_glob_common(self):
-        def _check(glob, expected):
-            self.assertEqual(set(glob), { P(BASE, q) for q in expected })
-        P = self.cls
-        p = P(BASE)
-        it = p.glob("fileA")
-        self.assertIsInstance(it, collections.abc.Iterator)
-        _check(it, ["fileA"])
-        _check(p.glob("fileB"), [])
-        _check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
-        if not os_helper.can_symlink():
-            _check(p.glob("*A"), ['dirA', 'fileA'])
-        else:
-            _check(p.glob("*A"), ['dirA', 'fileA', 'linkA'])
-        if not os_helper.can_symlink():
-            _check(p.glob("*B/*"), ['dirB/fileB'])
-        else:
-            _check(p.glob("*B/*"), ['dirB/fileB', 'dirB/linkD',
-                                    'linkB/fileB', 'linkB/linkD'])
-        if not os_helper.can_symlink():
-            _check(p.glob("*/fileB"), ['dirB/fileB'])
-        else:
-            _check(p.glob("*/fileB"), ['dirB/fileB', 'linkB/fileB'])
-        if os_helper.can_symlink():
-            _check(p.glob("brokenLink"), ['brokenLink'])
-
-        if not os_helper.can_symlink():
-            _check(p.glob("*/"), ["dirA", "dirB", "dirC", "dirE"])
-        else:
-            _check(p.glob("*/"), ["dirA", "dirB", "dirC", "dirE", "linkB"])
-
-    def test_glob_case_sensitive(self):
-        P = self.cls
-        def _check(path, pattern, case_sensitive, expected):
-            actual = {str(q) for q in path.glob(pattern, case_sensitive=case_sensitive)}
-            expected = {str(P(BASE, q)) for q in expected}
-            self.assertEqual(actual, expected)
-        path = P(BASE)
-        _check(path, "DIRB/FILE*", True, [])
-        _check(path, "DIRB/FILE*", False, ["dirB/fileB"])
-        _check(path, "dirb/file*", True, [])
-        _check(path, "dirb/file*", False, ["dirB/fileB"])
-
-    def test_rglob_common(self):
-        def _check(glob, expected):
-            self.assertEqual(sorted(glob), sorted(P(BASE, q) for q in expected))
-        P = self.cls
-        p = P(BASE)
-        it = p.rglob("fileA")
-        self.assertIsInstance(it, collections.abc.Iterator)
-        _check(it, ["fileA"])
-        _check(p.rglob("fileB"), ["dirB/fileB"])
-        _check(p.rglob("**/fileB"), ["dirB/fileB"])
-        _check(p.rglob("*/fileA"), [])
-        if not os_helper.can_symlink():
-            _check(p.rglob("*/fileB"), ["dirB/fileB"])
-        else:
-            _check(p.rglob("*/fileB"), ["dirB/fileB", "dirB/linkD/fileB",
-                                        "linkB/fileB", "dirA/linkC/fileB"])
-        _check(p.rglob("file*"), ["fileA", "dirB/fileB",
-                                  "dirC/fileC", "dirC/dirD/fileD"])
-        if not os_helper.can_symlink():
-            _check(p.rglob("*/"), [
-                "dirA", "dirB", "dirC", "dirC/dirD", "dirE",
-            ])
-        else:
-            _check(p.rglob("*/"), [
-                "dirA", "dirA/linkC", "dirB", "dirB/linkD", "dirC",
-                "dirC/dirD", "dirE", "linkB",
-            ])
-        _check(p.rglob(""), ["", "dirA", "dirB", "dirC", "dirE", "dirC/dirD"])
-
-        p = P(BASE, "dirC")
-        _check(p.rglob("*"), ["dirC/fileC", "dirC/novel.txt",
-                              "dirC/dirD", "dirC/dirD/fileD"])
-        _check(p.rglob("file*"), ["dirC/fileC", "dirC/dirD/fileD"])
-        _check(p.rglob("**/file*"), ["dirC/fileC", "dirC/dirD/fileD"])
-        _check(p.rglob("dir*/**"), ["dirC/dirD"])
-        _check(p.rglob("*/*"), ["dirC/dirD/fileD"])
-        _check(p.rglob("*/"), ["dirC/dirD"])
-        _check(p.rglob(""), ["dirC", "dirC/dirD"])
-        _check(p.rglob("**"), ["dirC", "dirC/dirD"])
-        # gh-91616, a re module regression
-        _check(p.rglob("*.txt"), ["dirC/novel.txt"])
-        _check(p.rglob("*.*"), ["dirC/novel.txt"])
-
-    @os_helper.skip_unless_symlink
-    def test_rglob_symlink_loop(self):
-        # Don't get fooled by symlink loops (Issue #26012).
-        P = self.cls
-        p = P(BASE)
-        given = set(p.rglob('*'))
-        expect = {'brokenLink',
-                  'dirA', 'dirA/linkC',
-                  'dirB', 'dirB/fileB', 'dirB/linkD',
-                  'dirC', 'dirC/dirD', 'dirC/dirD/fileD',
-                  'dirC/fileC', 'dirC/novel.txt',
-                  'dirE',
-                  'fileA',
-                  'linkA',
-                  'linkB',
-                  'brokenLinkLoop',
-                  }
-        self.assertEqual(given, {p / x for x in expect})
-
-    def test_glob_many_open_files(self):
-        depth = 30
-        P = self.cls
-        base = P(BASE) / 'deep'
-        p = P(base, *(['d']*depth))
-        p.mkdir(parents=True)
-        pattern = '/'.join(['*'] * depth)
-        iters = [base.glob(pattern) for j in range(100)]
-        for it in iters:
-            self.assertEqual(next(it), p)
-        iters = [base.rglob('d') for j in range(100)]
-        p = base
-        for i in range(depth):
-            p = p / 'd'
-            for it in iters:
-                self.assertEqual(next(it), p)
-
-    def test_glob_dotdot(self):
-        # ".." is not special in globs.
-        P = self.cls
-        p = P(BASE)
-        self.assertEqual(set(p.glob("..")), { P(BASE, "..") })
-        self.assertEqual(set(p.glob("../..")), { P(BASE, "..", "..") })
-        self.assertEqual(set(p.glob("dirA/..")), { P(BASE, "dirA", "..") })
-        self.assertEqual(set(p.glob("dirA/../file*")), { P(BASE, "dirA/../fileA") })
-        self.assertEqual(set(p.glob("dirA/../file*/..")), set())
-        self.assertEqual(set(p.glob("../xyzzy")), set())
-        self.assertEqual(set(p.glob("xyzzy/..")), set())
-        self.assertEqual(set(p.glob("/".join([".."] * 50))), { P(BASE, *[".."] * 50)})
-
-    @os_helper.skip_unless_symlink
-    def test_glob_permissions(self):
-        # See bpo-38894
-        P = self.cls
-        base = P(BASE) / 'permissions'
-        base.mkdir()
-        self.addCleanup(os_helper.rmtree, base)
-
-        for i in range(100):
-            link = base / f"link{i}"
-            if i % 2:
-                link.symlink_to(P(BASE, "dirE", "nonexistent"))
-            else:
-                link.symlink_to(P(BASE, "dirC"))
-
-        self.assertEqual(len(set(base.glob("*"))), 100)
-        self.assertEqual(len(set(base.glob("*/"))), 50)
-        self.assertEqual(len(set(base.glob("*/fileC"))), 50)
-        self.assertEqual(len(set(base.glob("*/file*"))), 50)
-
-    @os_helper.skip_unless_symlink
-    def test_glob_long_symlink(self):
-        # See gh-87695
-        base = self.cls(BASE) / 'long_symlink'
-        base.mkdir()
-        bad_link = base / 'bad_link'
-        bad_link.symlink_to("bad" * 200)
-        self.assertEqual(sorted(base.glob('**/*')), [bad_link])
-
-    def test_glob_above_recursion_limit(self):
-        recursion_limit = 50
-        # directory_depth > recursion_limit
-        directory_depth = recursion_limit + 10
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d'] * directory_depth))
-        path.mkdir(parents=True)
-
-        with set_recursion_limit(recursion_limit):
-            list(base.glob('**'))
-
-    def _check_resolve(self, p, expected, strict=True):
-        q = p.resolve(strict)
-        self.assertEqual(q, expected)
-
-    # This can be used to check both relative and absolute resolutions.
-    _check_resolve_relative = _check_resolve_absolute = _check_resolve
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_common(self):
-        P = self.cls
-        p = P(BASE, 'foo')
-        with self.assertRaises(OSError) as cm:
-            p.resolve(strict=True)
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-        # Non-strict
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.join(BASE, 'foo'))
-        p = P(BASE, 'foo', 'in', 'spam')
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.join(BASE, 'foo', 'in', 'spam'))
-        p = P(BASE, '..', 'foo', 'in', 'spam')
-        self.assertEqualNormCase(str(p.resolve(strict=False)),
-                                 os.path.abspath(os.path.join('foo', 'in', 'spam')))
-        # These are all relative symlinks.
-        p = P(BASE, 'dirB', 'fileB')
-        self._check_resolve_relative(p, p)
-        p = P(BASE, 'linkA')
-        self._check_resolve_relative(p, P(BASE, 'fileA'))
-        p = P(BASE, 'dirA', 'linkC', 'fileB')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
-        p = P(BASE, 'dirB', 'linkD', 'fileB')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB'))
-        # Non-strict
-        p = P(BASE, 'dirA', 'linkC', 'fileB', 'foo', 'in', 'spam')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'fileB', 'foo', 'in',
-                                          'spam'), False)
-        p = P(BASE, 'dirA', 'linkC', '..', 'foo', 'in', 'spam')
-        if os.name == 'nt':
-            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
-            # resolves to 'dirA' without resolving linkY first.
-            self._check_resolve_relative(p, P(BASE, 'dirA', 'foo', 'in',
-                                              'spam'), False)
-        else:
-            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
-            # resolves to 'dirB/..' first before resolving to parent of dirB.
-            self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
-        # Now create absolute symlinks.
-        d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
-                                                 dir=os.getcwd()))
-        self.addCleanup(os_helper.rmtree, d)
-        os.symlink(os.path.join(d), join('dirA', 'linkX'))
-        os.symlink(join('dirB'), os.path.join(d, 'linkY'))
-        p = P(BASE, 'dirA', 'linkX', 'linkY', 'fileB')
-        self._check_resolve_absolute(p, P(BASE, 'dirB', 'fileB'))
-        # Non-strict
-        p = P(BASE, 'dirA', 'linkX', 'linkY', 'foo', 'in', 'spam')
-        self._check_resolve_relative(p, P(BASE, 'dirB', 'foo', 'in', 'spam'),
-                                     False)
-        p = P(BASE, 'dirA', 'linkX', 'linkY', '..', 'foo', 'in', 'spam')
-        if os.name == 'nt':
-            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
-            # resolves to 'dirA' without resolving linkY first.
-            self._check_resolve_relative(p, P(d, 'foo', 'in', 'spam'), False)
-        else:
-            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
-            # resolves to 'dirB/..' first before resolving to parent of dirB.
-            self._check_resolve_relative(p, P(BASE, 'foo', 'in', 'spam'), False)
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_dot(self):
-        # See http://web.archive.org/web/20200623062557/https://bitbucket.org/pitrou/pathlib/issues/9/
-        p = self.cls(BASE)
-        self.dirlink('.', join('0'))
-        self.dirlink(os.path.join('0', '0'), join('1'))
-        self.dirlink(os.path.join('1', '1'), join('2'))
-        q = p / '2'
-        self.assertEqual(q.resolve(strict=True), p)
-        r = q / '3' / '4'
-        self.assertRaises(FileNotFoundError, r.resolve, strict=True)
-        # Non-strict
-        self.assertEqual(r.resolve(strict=False), p / '3' / '4')
-
-    def test_resolve_nonexist_relative_issue38671(self):
-        p = self.cls('non', 'exist')
-
-        old_cwd = os.getcwd()
-        os.chdir(BASE)
-        try:
-            self.assertEqual(p.resolve(), self.cls(BASE, p))
-        finally:
-            os.chdir(old_cwd)
-
-    def test_with(self):
-        p = self.cls(BASE)
-        it = p.iterdir()
-        it2 = p.iterdir()
-        next(it2)
-        # bpo-46556: path context managers are deprecated in Python 3.11.
-        with self.assertWarns(DeprecationWarning):
-            with p:
-                pass
-        # Using a path as a context manager is a no-op, thus the following
-        # operations should still succeed after the context manage exits.
-        next(it)
-        next(it2)
-        p.exists()
-        p.resolve()
-        p.absolute()
-        with self.assertWarns(DeprecationWarning):
-            with p:
-                pass
-
-    @os_helper.skip_unless_working_chmod
-    def test_chmod(self):
-        p = self.cls(BASE) / 'fileA'
-        mode = p.stat().st_mode
-        # Clear writable bit.
-        new_mode = mode & ~0o222
-        p.chmod(new_mode)
-        self.assertEqual(p.stat().st_mode, new_mode)
-        # Set writable bit.
-        new_mode = mode | 0o222
-        p.chmod(new_mode)
-        self.assertEqual(p.stat().st_mode, new_mode)
-
-    # On Windows, os.chmod does not follow symlinks (issue #15411)
-    @only_posix
-    @os_helper.skip_unless_working_chmod
-    def test_chmod_follow_symlinks_true(self):
-        p = self.cls(BASE) / 'linkA'
-        q = p.resolve()
-        mode = q.stat().st_mode
-        # Clear writable bit.
-        new_mode = mode & ~0o222
-        p.chmod(new_mode, follow_symlinks=True)
-        self.assertEqual(q.stat().st_mode, new_mode)
-        # Set writable bit
-        new_mode = mode | 0o222
-        p.chmod(new_mode, follow_symlinks=True)
-        self.assertEqual(q.stat().st_mode, new_mode)
-
-    # XXX also need a test for lchmod.
-
-    @os_helper.skip_unless_working_chmod
-    def test_stat(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(p.stat(), st)
-        # Change file mode by flipping write bit.
-        p.chmod(st.st_mode ^ 0o222)
-        self.addCleanup(p.chmod, st.st_mode)
-        self.assertNotEqual(p.stat(), st)
-
-    @os_helper.skip_unless_symlink
-    def test_stat_no_follow_symlinks(self):
-        p = self.cls(BASE) / 'linkA'
-        st = p.stat()
-        self.assertNotEqual(st, p.stat(follow_symlinks=False))
-
-    def test_stat_no_follow_symlinks_nosymlink(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(st, p.stat(follow_symlinks=False))
-
-    @os_helper.skip_unless_symlink
-    def test_lstat(self):
-        p = self.cls(BASE)/ 'linkA'
-        st = p.stat()
-        self.assertNotEqual(st, p.lstat())
-
-    def test_lstat_nosymlink(self):
-        p = self.cls(BASE) / 'fileA'
-        st = p.stat()
-        self.assertEqual(st, p.lstat())
-
-    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
-    def test_owner(self):
-        p = self.cls(BASE) / 'fileA'
-        uid = p.stat().st_uid
-        try:
-            name = pwd.getpwuid(uid).pw_name
-        except KeyError:
-            self.skipTest(
-                "user %d doesn't have an entry in the system database" % uid)
-        self.assertEqual(name, p.owner())
-
-    @unittest.skipUnless(grp, "the grp module is needed for this test")
-    def test_group(self):
-        p = self.cls(BASE) / 'fileA'
-        gid = p.stat().st_gid
-        try:
-            name = grp.getgrgid(gid).gr_name
-        except KeyError:
-            self.skipTest(
-                "group %d doesn't have an entry in the system database" % gid)
-        self.assertEqual(name, p.group())
-
-    def test_unlink(self):
-        p = self.cls(BASE) / 'fileA'
-        p.unlink()
-        self.assertFileNotFound(p.stat)
-        self.assertFileNotFound(p.unlink)
-
-    def test_unlink_missing_ok(self):
-        p = self.cls(BASE) / 'fileAAA'
-        self.assertFileNotFound(p.unlink)
-        p.unlink(missing_ok=True)
-
-    def test_rmdir(self):
-        p = self.cls(BASE) / 'dirA'
-        for q in p.iterdir():
-            q.unlink()
-        p.rmdir()
-        self.assertFileNotFound(p.stat)
-        self.assertFileNotFound(p.unlink)
-
-    @unittest.skipUnless(hasattr(os, "link"), "os.link() is not present")
-    def test_hardlink_to(self):
-        P = self.cls(BASE)
-        target = P / 'fileA'
-        size = target.stat().st_size
-        # linking to another path.
-        link = P / 'dirA' / 'fileAA'
-        link.hardlink_to(target)
-        self.assertEqual(link.stat().st_size, size)
-        self.assertTrue(os.path.samefile(target, link))
-        self.assertTrue(target.exists())
-        # Linking to a str of a relative path.
-        link2 = P / 'dirA' / 'fileAAA'
-        target2 = rel_join('fileA')
-        link2.hardlink_to(target2)
-        self.assertEqual(os.stat(target2).st_size, size)
-        self.assertTrue(link2.exists())
-
-    @unittest.skipIf(hasattr(os, "link"), "os.link() is present")
-    def test_link_to_not_implemented(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        # linking to another path.
-        q = P / 'dirA' / 'fileAA'
-        with self.assertRaises(NotImplementedError):
-            q.hardlink_to(p)
-
-    def test_rename(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        size = p.stat().st_size
-        # Renaming to another path.
-        q = P / 'dirA' / 'fileAA'
-        renamed_p = p.rename(q)
-        self.assertEqual(renamed_p, q)
-        self.assertEqual(q.stat().st_size, size)
-        self.assertFileNotFound(p.stat)
-        # Renaming to a str of a relative path.
-        r = rel_join('fileAAA')
-        renamed_q = q.rename(r)
-        self.assertEqual(renamed_q, self.cls(r))
-        self.assertEqual(os.stat(r).st_size, size)
-        self.assertFileNotFound(q.stat)
-
-    def test_replace(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        size = p.stat().st_size
-        # Replacing a non-existing path.
-        q = P / 'dirA' / 'fileAA'
-        replaced_p = p.replace(q)
-        self.assertEqual(replaced_p, q)
-        self.assertEqual(q.stat().st_size, size)
-        self.assertFileNotFound(p.stat)
-        # Replacing another (existing) path.
-        r = rel_join('dirB', 'fileB')
-        replaced_q = q.replace(r)
-        self.assertEqual(replaced_q, self.cls(r))
-        self.assertEqual(os.stat(r).st_size, size)
-        self.assertFileNotFound(q.stat)
-
-    @os_helper.skip_unless_symlink
-    def test_readlink(self):
-        P = self.cls(BASE)
-        self.assertEqual((P / 'linkA').readlink(), self.cls('fileA'))
-        self.assertEqual((P / 'brokenLink').readlink(),
-                         self.cls('non-existing'))
-        self.assertEqual((P / 'linkB').readlink(), self.cls('dirB'))
-        with self.assertRaises(OSError):
-            (P / 'fileA').readlink()
-
-    def test_touch_common(self):
-        P = self.cls(BASE)
-        p = P / 'newfileA'
-        self.assertFalse(p.exists())
-        p.touch()
-        self.assertTrue(p.exists())
-        st = p.stat()
-        old_mtime = st.st_mtime
-        old_mtime_ns = st.st_mtime_ns
-        # Rewind the mtime sufficiently far in the past to work around
-        # filesystem-specific timestamp granularity.
-        os.utime(str(p), (old_mtime - 10, old_mtime - 10))
-        # The file mtime should be refreshed by calling touch() again.
-        p.touch()
-        st = p.stat()
-        self.assertGreaterEqual(st.st_mtime_ns, old_mtime_ns)
-        self.assertGreaterEqual(st.st_mtime, old_mtime)
-        # Now with exist_ok=False.
-        p = P / 'newfileB'
-        self.assertFalse(p.exists())
-        p.touch(mode=0o700, exist_ok=False)
-        self.assertTrue(p.exists())
-        self.assertRaises(OSError, p.touch, exist_ok=False)
-
-    def test_touch_nochange(self):
-        P = self.cls(BASE)
-        p = P / 'fileA'
-        p.touch()
-        with p.open('rb') as f:
-            self.assertEqual(f.read().strip(), b"this is file A")
-
-    def test_mkdir(self):
-        P = self.cls(BASE)
-        p = P / 'newdirA'
-        self.assertFalse(p.exists())
-        p.mkdir()
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_parents(self):
-        # Creating a chain of directories.
-        p = self.cls(BASE, 'newdirB', 'newdirC')
-        self.assertFalse(p.exists())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.ENOENT)
-        p.mkdir(parents=True)
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(OSError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        # Test `mode` arg.
-        mode = stat.S_IMODE(p.stat().st_mode)  # Default mode.
-        p = self.cls(BASE, 'newdirD', 'newdirE')
-        p.mkdir(0o555, parents=True)
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        if os.name != 'nt':
-            # The directory's permissions follow the mode argument.
-            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o7555 & mode)
-        # The parent's permissions follow the default process settings.
-        self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), mode)
-
-    def test_mkdir_exist_ok(self):
-        p = self.cls(BASE, 'dirB')
-        st_ctime_first = p.stat().st_ctime
-        self.assertTrue(p.exists())
-        self.assertTrue(p.is_dir())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p.mkdir(exist_ok=True)
-        self.assertTrue(p.exists())
-        self.assertEqual(p.stat().st_ctime, st_ctime_first)
-
-    def test_mkdir_exist_ok_with_parent(self):
-        p = self.cls(BASE, 'dirC')
-        self.assertTrue(p.exists())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p = p / 'newdirC'
-        p.mkdir(parents=True)
-        st_ctime_first = p.stat().st_ctime
-        self.assertTrue(p.exists())
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        p.mkdir(parents=True, exist_ok=True)
-        self.assertTrue(p.exists())
-        self.assertEqual(p.stat().st_ctime, st_ctime_first)
-
-    @unittest.skipIf(is_emscripten, "FS root cannot be modified on Emscripten.")
-    def test_mkdir_exist_ok_root(self):
-        # Issue #25803: A drive root could raise PermissionError on Windows.
-        self.cls('/').resolve().mkdir(exist_ok=True)
-        self.cls('/').resolve().mkdir(parents=True, exist_ok=True)
-
-    @only_nt  # XXX: not sure how to test this on POSIX.
-    def test_mkdir_with_unknown_drive(self):
-        for d in 'ZYXWVUTSRQPONMLKJIHGFEDCBA':
-            p = self.cls(d + ':\\')
-            if not p.is_dir():
-                break
-        else:
-            self.skipTest("cannot find a drive that doesn't exist")
-        with self.assertRaises(OSError):
-            (p / 'child' / 'path').mkdir(parents=True)
-
-    def test_mkdir_with_child_file(self):
-        p = self.cls(BASE, 'dirB', 'fileB')
-        self.assertTrue(p.exists())
-        # An exception is raised when the last path component is an existing
-        # regular file, regardless of whether exist_ok is true or not.
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(parents=True, exist_ok=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_no_parents_file(self):
-        p = self.cls(BASE, 'fileA')
-        self.assertTrue(p.exists())
-        # An exception is raised when the last path component is an existing
-        # regular file, regardless of whether exist_ok is true or not.
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir()
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-        with self.assertRaises(FileExistsError) as cm:
-            p.mkdir(exist_ok=True)
-        self.assertEqual(cm.exception.errno, errno.EEXIST)
-
-    def test_mkdir_concurrent_parent_creation(self):
-        for pattern_num in range(32):
-            p = self.cls(BASE, 'dirCPC%d' % pattern_num)
-            self.assertFalse(p.exists())
-
-            real_mkdir = os.mkdir
-            def my_mkdir(path, mode=0o777):
-                path = str(path)
-                # Emulate another process that would create the directory
-                # just before we try to create it ourselves.  We do it
-                # in all possible pattern combinations, assuming that this
-                # function is called at most 5 times (dirCPC/dir1/dir2,
-                # dirCPC/dir1, dirCPC, dirCPC/dir1, dirCPC/dir1/dir2).
-                if pattern.pop():
-                    real_mkdir(path, mode)  # From another process.
-                    concurrently_created.add(path)
-                real_mkdir(path, mode)  # Our real call.
-
-            pattern = [bool(pattern_num & (1 << n)) for n in range(5)]
-            concurrently_created = set()
-            p12 = p / 'dir1' / 'dir2'
-            try:
-                with mock.patch("os.mkdir", my_mkdir):
-                    p12.mkdir(parents=True, exist_ok=False)
-            except FileExistsError:
-                self.assertIn(str(p12), concurrently_created)
-            else:
-                self.assertNotIn(str(p12), concurrently_created)
-            self.assertTrue(p.exists())
-
-    @os_helper.skip_unless_symlink
-    def test_symlink_to(self):
-        P = self.cls(BASE)
-        target = P / 'fileA'
-        # Symlinking a path target.
-        link = P / 'dirA' / 'linkAA'
-        link.symlink_to(target)
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        # Symlinking a str target.
-        link = P / 'dirA' / 'linkAAA'
-        link.symlink_to(str(target))
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        self.assertFalse(link.is_dir())
-        # Symlinking to a directory.
-        target = P / 'dirB'
-        link = P / 'dirA' / 'linkAAAA'
-        link.symlink_to(target, target_is_directory=True)
-        self.assertEqual(link.stat(), target.stat())
-        self.assertNotEqual(link.lstat(), target.stat())
-        self.assertTrue(link.is_dir())
-        self.assertTrue(list(link.iterdir()))
-
-    def test_is_dir(self):
-        P = self.cls(BASE)
-        self.assertTrue((P / 'dirA').is_dir())
-        self.assertFalse((P / 'fileA').is_dir())
-        self.assertFalse((P / 'non-existing').is_dir())
-        self.assertFalse((P / 'fileA' / 'bah').is_dir())
-        if os_helper.can_symlink():
-            self.assertFalse((P / 'linkA').is_dir())
-            self.assertTrue((P / 'linkB').is_dir())
-            self.assertFalse((P/ 'brokenLink').is_dir(), False)
-        self.assertIs((P / 'dirA\udfff').is_dir(), False)
-        self.assertIs((P / 'dirA\x00').is_dir(), False)
-
-    def test_is_file(self):
-        P = self.cls(BASE)
-        self.assertTrue((P / 'fileA').is_file())
-        self.assertFalse((P / 'dirA').is_file())
-        self.assertFalse((P / 'non-existing').is_file())
-        self.assertFalse((P / 'fileA' / 'bah').is_file())
-        if os_helper.can_symlink():
-            self.assertTrue((P / 'linkA').is_file())
-            self.assertFalse((P / 'linkB').is_file())
-            self.assertFalse((P/ 'brokenLink').is_file())
-        self.assertIs((P / 'fileA\udfff').is_file(), False)
-        self.assertIs((P / 'fileA\x00').is_file(), False)
-
-    def test_is_mount(self):
-        P = self.cls(BASE)
-        if os.name == 'nt':
-            R = self.cls('c:\\')
-        else:
-            R = self.cls('/')
-        self.assertFalse((P / 'fileA').is_mount())
-        self.assertFalse((P / 'dirA').is_mount())
-        self.assertFalse((P / 'non-existing').is_mount())
-        self.assertFalse((P / 'fileA' / 'bah').is_mount())
-        self.assertTrue(R.is_mount())
-        if os_helper.can_symlink():
-            self.assertFalse((P / 'linkA').is_mount())
-        self.assertIs((R / '\udfff').is_mount(), False)
-
-    def test_is_symlink(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_symlink())
-        self.assertFalse((P / 'dirA').is_symlink())
-        self.assertFalse((P / 'non-existing').is_symlink())
-        self.assertFalse((P / 'fileA' / 'bah').is_symlink())
-        if os_helper.can_symlink():
-            self.assertTrue((P / 'linkA').is_symlink())
-            self.assertTrue((P / 'linkB').is_symlink())
-            self.assertTrue((P/ 'brokenLink').is_symlink())
-        self.assertIs((P / 'fileA\udfff').is_file(), False)
-        self.assertIs((P / 'fileA\x00').is_file(), False)
-        if os_helper.can_symlink():
-            self.assertIs((P / 'linkA\udfff').is_file(), False)
-            self.assertIs((P / 'linkA\x00').is_file(), False)
-
-    def test_is_junction(self):
-        P = self.cls(BASE)
-
-        with mock.patch.object(P._flavour, 'isjunction'):
-            self.assertEqual(P.is_junction(), P._flavour.isjunction.return_value)
-            P._flavour.isjunction.assert_called_once_with(P)
-
-    def test_is_fifo_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_fifo())
-        self.assertFalse((P / 'dirA').is_fifo())
-        self.assertFalse((P / 'non-existing').is_fifo())
-        self.assertFalse((P / 'fileA' / 'bah').is_fifo())
-        self.assertIs((P / 'fileA\udfff').is_fifo(), False)
-        self.assertIs((P / 'fileA\x00').is_fifo(), False)
-
-    @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
-    @unittest.skipIf(sys.platform == "vxworks",
-                    "fifo requires special path on VxWorks")
-    def test_is_fifo_true(self):
-        P = self.cls(BASE, 'myfifo')
-        try:
-            os.mkfifo(str(P))
-        except PermissionError as e:
-            self.skipTest('os.mkfifo(): %s' % e)
-        self.assertTrue(P.is_fifo())
-        self.assertFalse(P.is_socket())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(BASE, 'myfifo\udfff').is_fifo(), False)
-        self.assertIs(self.cls(BASE, 'myfifo\x00').is_fifo(), False)
-
-    def test_is_socket_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_socket())
-        self.assertFalse((P / 'dirA').is_socket())
-        self.assertFalse((P / 'non-existing').is_socket())
-        self.assertFalse((P / 'fileA' / 'bah').is_socket())
-        self.assertIs((P / 'fileA\udfff').is_socket(), False)
-        self.assertIs((P / 'fileA\x00').is_socket(), False)
-
-    @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
-    @unittest.skipIf(
-        is_emscripten, "Unix sockets are not implemented on Emscripten."
-    )
-    @unittest.skipIf(
-        is_wasi, "Cannot create socket on WASI."
-    )
-    def test_is_socket_true(self):
-        P = self.cls(BASE, 'mysock')
-        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-        self.addCleanup(sock.close)
-        try:
-            sock.bind(str(P))
-        except OSError as e:
-            if (isinstance(e, PermissionError) or
-                    "AF_UNIX path too long" in str(e)):
-                self.skipTest("cannot bind Unix socket: " + str(e))
-        self.assertTrue(P.is_socket())
-        self.assertFalse(P.is_fifo())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(BASE, 'mysock\udfff').is_socket(), False)
-        self.assertIs(self.cls(BASE, 'mysock\x00').is_socket(), False)
-
-    def test_is_block_device_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_block_device())
-        self.assertFalse((P / 'dirA').is_block_device())
-        self.assertFalse((P / 'non-existing').is_block_device())
-        self.assertFalse((P / 'fileA' / 'bah').is_block_device())
-        self.assertIs((P / 'fileA\udfff').is_block_device(), False)
-        self.assertIs((P / 'fileA\x00').is_block_device(), False)
-
-    def test_is_char_device_false(self):
-        P = self.cls(BASE)
-        self.assertFalse((P / 'fileA').is_char_device())
-        self.assertFalse((P / 'dirA').is_char_device())
-        self.assertFalse((P / 'non-existing').is_char_device())
-        self.assertFalse((P / 'fileA' / 'bah').is_char_device())
-        self.assertIs((P / 'fileA\udfff').is_char_device(), False)
-        self.assertIs((P / 'fileA\x00').is_char_device(), False)
-
-    def test_is_char_device_true(self):
-        # os.devnull should generally be a char device.
-        P = self.cls(os.devnull)
-        if not P.exists():
-            self.skipTest("null device required")
-        self.assertTrue(P.is_char_device())
-        self.assertFalse(P.is_block_device())
-        self.assertFalse(P.is_file())
-        self.assertIs(self.cls(f'{os.devnull}\udfff').is_char_device(), False)
-        self.assertIs(self.cls(f'{os.devnull}\x00').is_char_device(), False)
-
-    def test_pickling_common(self):
-        p = self.cls(BASE, 'fileA')
-        for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            dumped = pickle.dumps(p, proto)
-            pp = pickle.loads(dumped)
-            self.assertEqual(pp.stat(), p.stat())
-
-    def test_parts_interning(self):
-        P = self.cls
-        p = P('/usr/bin/foo')
-        q = P('/usr/local/bin')
-        # 'usr'
-        self.assertIs(p.parts[1], q.parts[1])
-        # 'bin'
-        self.assertIs(p.parts[2], q.parts[3])
-
-    def _check_complex_symlinks(self, link0_target):
-        # Test solving a non-looping chain of symlinks (issue #19887).
-        P = self.cls(BASE)
-        self.dirlink(os.path.join('link0', 'link0'), join('link1'))
-        self.dirlink(os.path.join('link1', 'link1'), join('link2'))
-        self.dirlink(os.path.join('link2', 'link2'), join('link3'))
-        self.dirlink(link0_target, join('link0'))
-
-        # Resolve absolute paths.
-        p = (P / 'link0').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link1').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link2').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-        p = (P / 'link3').resolve()
-        self.assertEqual(p, P)
-        self.assertEqualNormCase(str(p), BASE)
-
-        # Resolve relative paths.
-        old_path = os.getcwd()
-        os.chdir(BASE)
-        try:
-            p = self.cls('link0').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link1').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link2').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-            p = self.cls('link3').resolve()
-            self.assertEqual(p, P)
-            self.assertEqualNormCase(str(p), BASE)
-        finally:
-            os.chdir(old_path)
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_absolute(self):
-        self._check_complex_symlinks(BASE)
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_relative(self):
-        self._check_complex_symlinks('.')
-
-    @os_helper.skip_unless_symlink
-    def test_complex_symlinks_relative_dot_dot(self):
-        self._check_complex_symlinks(os.path.join('dirA', '..'))
-
-    def test_passing_kwargs_deprecated(self):
-        with self.assertWarns(DeprecationWarning):
-            self.cls(foo="bar")
-
-
-class WalkTests(unittest.TestCase):
-
-    def setUp(self):
-        self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
-
-        # Build:
-        #     TESTFN/
-        #       TEST1/              a file kid and two directory kids
-        #         tmp1
-        #         SUB1/             a file kid and a directory kid
-        #           tmp2
-        #           SUB11/          no kids
-        #         SUB2/             a file kid and a dirsymlink kid
-        #           tmp3
-        #           SUB21/          not readable
-        #             tmp5
-        #           link/           a symlink to TEST2
-        #           broken_link
-        #           broken_link2
-        #           broken_link3
-        #       TEST2/
-        #         tmp4              a lone file
-        self.walk_path = pathlib.Path(os_helper.TESTFN, "TEST1")
-        self.sub1_path = self.walk_path / "SUB1"
-        self.sub11_path = self.sub1_path / "SUB11"
-        self.sub2_path = self.walk_path / "SUB2"
-        sub21_path= self.sub2_path / "SUB21"
-        tmp1_path = self.walk_path / "tmp1"
-        tmp2_path = self.sub1_path / "tmp2"
-        tmp3_path = self.sub2_path / "tmp3"
-        tmp5_path = sub21_path / "tmp3"
-        self.link_path = self.sub2_path / "link"
-        t2_path = pathlib.Path(os_helper.TESTFN, "TEST2")
-        tmp4_path = pathlib.Path(os_helper.TESTFN, "TEST2", "tmp4")
-        broken_link_path = self.sub2_path / "broken_link"
-        broken_link2_path = self.sub2_path / "broken_link2"
-        broken_link3_path = self.sub2_path / "broken_link3"
-
-        os.makedirs(self.sub11_path)
-        os.makedirs(self.sub2_path)
-        os.makedirs(sub21_path)
-        os.makedirs(t2_path)
-
-        for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path, tmp5_path:
-            with open(path, "x", encoding='utf-8') as f:
-                f.write(f"I'm {path} and proud of it.  Blame test_pathlib.\n")
-
-        if os_helper.can_symlink():
-            os.symlink(os.path.abspath(t2_path), self.link_path)
-            os.symlink('broken', broken_link_path, True)
-            os.symlink(pathlib.Path('tmp3', 'broken'), broken_link2_path, True)
-            os.symlink(pathlib.Path('SUB21', 'tmp5'), broken_link3_path, True)
-            self.sub2_tree = (self.sub2_path, ["SUB21"],
-                              ["broken_link", "broken_link2", "broken_link3",
-                               "link", "tmp3"])
-        else:
-            self.sub2_tree = (self.sub2_path, ["SUB21"], ["tmp3"])
-
-        if not is_emscripten:
-            # Emscripten fails with inaccessible directories.
-            os.chmod(sub21_path, 0)
-        try:
-            os.listdir(sub21_path)
-        except PermissionError:
-            self.addCleanup(os.chmod, sub21_path, stat.S_IRWXU)
-        else:
-            os.chmod(sub21_path, stat.S_IRWXU)
-            os.unlink(tmp5_path)
-            os.rmdir(sub21_path)
-            del self.sub2_tree[1][:1]
-
-    def test_walk_topdown(self):
-        walker = self.walk_path.walk()
-        entry = next(walker)
-        entry[1].sort()  # Ensure we visit SUB1 before SUB2
-        self.assertEqual(entry, (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
-        entry = next(walker)
-        self.assertEqual(entry, (self.sub1_path, ["SUB11"], ["tmp2"]))
-        entry = next(walker)
-        self.assertEqual(entry, (self.sub11_path, [], []))
-        entry = next(walker)
-        entry[1].sort()
-        entry[2].sort()
-        self.assertEqual(entry, self.sub2_tree)
-        with self.assertRaises(StopIteration):
-            next(walker)
-
-    def test_walk_prune(self, walk_path=None):
-        if walk_path is None:
-            walk_path = self.walk_path
-        # Prune the search.
-        all = []
-        for root, dirs, files in walk_path.walk():
-            all.append((root, dirs, files))
-            if 'SUB1' in dirs:
-                # Note that this also mutates the dirs we appended to all!
-                dirs.remove('SUB1')
-
-        self.assertEqual(len(all), 2)
-        self.assertEqual(all[0], (self.walk_path, ["SUB2"], ["tmp1"]))
-
-        all[1][-1].sort()
-        all[1][1].sort()
-        self.assertEqual(all[1], self.sub2_tree)
-
-    def test_file_like_path(self):
-        self.test_walk_prune(FakePath(self.walk_path).__fspath__())
-
-    def test_walk_bottom_up(self):
-        seen_testfn = seen_sub1 = seen_sub11 = seen_sub2 = False
-        for path, dirnames, filenames in self.walk_path.walk(top_down=False):
-            if path == self.walk_path:
-                self.assertFalse(seen_testfn)
-                self.assertTrue(seen_sub1)
-                self.assertTrue(seen_sub2)
-                self.assertEqual(sorted(dirnames), ["SUB1", "SUB2"])
-                self.assertEqual(filenames, ["tmp1"])
-                seen_testfn = True
-            elif path == self.sub1_path:
-                self.assertFalse(seen_testfn)
-                self.assertFalse(seen_sub1)
-                self.assertTrue(seen_sub11)
-                self.assertEqual(dirnames, ["SUB11"])
-                self.assertEqual(filenames, ["tmp2"])
-                seen_sub1 = True
-            elif path == self.sub11_path:
-                self.assertFalse(seen_sub1)
-                self.assertFalse(seen_sub11)
-                self.assertEqual(dirnames, [])
-                self.assertEqual(filenames, [])
-                seen_sub11 = True
-            elif path == self.sub2_path:
-                self.assertFalse(seen_testfn)
-                self.assertFalse(seen_sub2)
-                self.assertEqual(sorted(dirnames), sorted(self.sub2_tree[1]))
-                self.assertEqual(sorted(filenames), sorted(self.sub2_tree[2]))
-                seen_sub2 = True
-            else:
-                raise AssertionError(f"Unexpected path: {path}")
-        self.assertTrue(seen_testfn)
-
-    @os_helper.skip_unless_symlink
-    def test_walk_follow_symlinks(self):
-        walk_it = self.walk_path.walk(follow_symlinks=True)
-        for root, dirs, files in walk_it:
-            if root == self.link_path:
-                self.assertEqual(dirs, [])
-                self.assertEqual(files, ["tmp4"])
-                break
-        else:
-            self.fail("Didn't follow symlink with follow_symlinks=True")
-
-    @os_helper.skip_unless_symlink
-    def test_walk_symlink_location(self):
-        # Tests whether symlinks end up in filenames or dirnames depending
-        # on the `follow_symlinks` argument.
-        walk_it = self.walk_path.walk(follow_symlinks=False)
-        for root, dirs, files in walk_it:
-            if root == self.sub2_path:
-                self.assertIn("link", files)
-                break
-        else:
-            self.fail("symlink not found")
-
-        walk_it = self.walk_path.walk(follow_symlinks=True)
-        for root, dirs, files in walk_it:
-            if root == self.sub2_path:
-                self.assertIn("link", dirs)
-                break
-
-    def test_walk_bad_dir(self):
-        errors = []
-        walk_it = self.walk_path.walk(on_error=errors.append)
-        root, dirs, files = next(walk_it)
-        self.assertEqual(errors, [])
-        dir1 = 'SUB1'
-        path1 = root / dir1
-        path1new = (root / dir1).with_suffix(".new")
-        path1.rename(path1new)
-        try:
-            roots = [r for r, _, _ in walk_it]
-            self.assertTrue(errors)
-            self.assertNotIn(path1, roots)
-            self.assertNotIn(path1new, roots)
-            for dir2 in dirs:
-                if dir2 != dir1:
-                    self.assertIn(root / dir2, roots)
-        finally:
-            path1new.rename(path1)
-
-    def test_walk_many_open_files(self):
-        depth = 30
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d']*depth))
-        path.mkdir(parents=True)
-
-        iters = [base.walk(top_down=False) for _ in range(100)]
-        for i in range(depth + 1):
-            expected = (path, ['d'] if i else [], [])
-            for it in iters:
-                self.assertEqual(next(it), expected)
-            path = path.parent
-
-        iters = [base.walk(top_down=True) for _ in range(100)]
-        path = base
-        for i in range(depth + 1):
-            expected = (path, ['d'] if i < depth else [], [])
-            for it in iters:
-                self.assertEqual(next(it), expected)
-            path = path / 'd'
-
-    def test_walk_above_recursion_limit(self):
-        recursion_limit = 40
-        # directory_depth > recursion_limit
-        directory_depth = recursion_limit + 10
-        base = pathlib.Path(os_helper.TESTFN, 'deep')
-        path = pathlib.Path(base, *(['d'] * directory_depth))
-        path.mkdir(parents=True)
-
-        with set_recursion_limit(recursion_limit):
-            list(base.walk())
-            list(base.walk(top_down=False))
-
-
-class PathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.Path
-
-    def test_concrete_class(self):
-        p = self.cls('a')
-        self.assertIs(type(p),
-            pathlib.WindowsPath if os.name == 'nt' else pathlib.PosixPath)
-
-    def test_unsupported_flavour(self):
-        if os.name == 'nt':
-            self.assertRaises(NotImplementedError, pathlib.PosixPath)
-        else:
-            self.assertRaises(NotImplementedError, pathlib.WindowsPath)
-
-    def test_glob_empty_pattern(self):
-        p = self.cls()
-        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
-            list(p.glob(''))
-
-
-@only_posix
-class PosixPathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.PosixPath
-
-    def test_absolute(self):
-        P = self.cls
-        self.assertEqual(str(P('/').absolute()), '/')
-        self.assertEqual(str(P('/a').absolute()), '/a')
-        self.assertEqual(str(P('/a/b').absolute()), '/a/b')
-
-        # '//'-prefixed absolute path (supported by POSIX).
-        self.assertEqual(str(P('//').absolute()), '//')
-        self.assertEqual(str(P('//a').absolute()), '//a')
-        self.assertEqual(str(P('//a/b').absolute()), '//a/b')
-
-    def _check_symlink_loop(self, *args, strict=True):
-        path = self.cls(*args)
-        with self.assertRaises(RuntimeError):
-            print(path.resolve(strict))
-
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "umask is not implemented on Emscripten/WASI."
-    )
-    def test_open_mode(self):
-        old_mask = os.umask(0)
-        self.addCleanup(os.umask, old_mask)
-        p = self.cls(BASE)
-        with (p / 'new_file').open('wb'):
-            pass
-        st = os.stat(join('new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
-        os.umask(0o022)
-        with (p / 'other_new_file').open('wb'):
-            pass
-        st = os.stat(join('other_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
-
-    def test_resolve_root(self):
-        current_directory = os.getcwd()
-        try:
-            os.chdir('/')
-            p = self.cls('spam')
-            self.assertEqual(str(p.resolve()), '/spam')
-        finally:
-            os.chdir(current_directory)
-
-    @unittest.skipIf(
-        is_emscripten or is_wasi,
-        "umask is not implemented on Emscripten/WASI."
-    )
-    def test_touch_mode(self):
-        old_mask = os.umask(0)
-        self.addCleanup(os.umask, old_mask)
-        p = self.cls(BASE)
-        (p / 'new_file').touch()
-        st = os.stat(join('new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o666)
-        os.umask(0o022)
-        (p / 'other_new_file').touch()
-        st = os.stat(join('other_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o644)
-        (p / 'masked_new_file').touch(mode=0o750)
-        st = os.stat(join('masked_new_file'))
-        self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
-
-    @os_helper.skip_unless_symlink
-    def test_resolve_loop(self):
-        # Loops with relative symlinks.
-        os.symlink('linkX/inside', join('linkX'))
-        self._check_symlink_loop(BASE, 'linkX')
-        os.symlink('linkY', join('linkY'))
-        self._check_symlink_loop(BASE, 'linkY')
-        os.symlink('linkZ/../linkZ', join('linkZ'))
-        self._check_symlink_loop(BASE, 'linkZ')
-        # Non-strict
-        self._check_symlink_loop(BASE, 'linkZ', 'foo', strict=False)
-        # Loops with absolute symlinks.
-        os.symlink(join('linkU/inside'), join('linkU'))
-        self._check_symlink_loop(BASE, 'linkU')
-        os.symlink(join('linkV'), join('linkV'))
-        self._check_symlink_loop(BASE, 'linkV')
-        os.symlink(join('linkW/../linkW'), join('linkW'))
-        self._check_symlink_loop(BASE, 'linkW')
-        # Non-strict
-        self._check_symlink_loop(BASE, 'linkW', 'foo', strict=False)
-
-    def test_glob(self):
-        P = self.cls
-        p = P(BASE)
-        given = set(p.glob("FILEa"))
-        expect = set() if not os_helper.fs_is_case_insensitive(BASE) else given
-        self.assertEqual(given, expect)
-        self.assertEqual(set(p.glob("FILEa*")), set())
-
-    def test_rglob(self):
-        P = self.cls
-        p = P(BASE, "dirC")
-        given = set(p.rglob("FILEd"))
-        expect = set() if not os_helper.fs_is_case_insensitive(BASE) else given
-        self.assertEqual(given, expect)
-        self.assertEqual(set(p.rglob("FILEd*")), set())
-
-    @unittest.skipUnless(hasattr(pwd, 'getpwall'),
-                         'pwd module does not expose getpwall()')
-    @unittest.skipIf(sys.platform == "vxworks",
-                     "no home directory on VxWorks")
-    def test_expanduser(self):
-        P = self.cls
-        import_helper.import_module('pwd')
-        import pwd
-        pwdent = pwd.getpwuid(os.getuid())
-        username = pwdent.pw_name
-        userhome = pwdent.pw_dir.rstrip('/') or '/'
-        # Find arbitrary different user (if exists).
-        for pwdent in pwd.getpwall():
-            othername = pwdent.pw_name
-            otherhome = pwdent.pw_dir.rstrip('/')
-            if othername != username and otherhome:
-                break
-        else:
-            othername = username
-            otherhome = userhome
-
-        fakename = 'fakeuser'
-        # This user can theoretically exist on a test runner. Create unique name:
-        try:
-            while pwd.getpwnam(fakename):
-                fakename += '1'
-        except KeyError:
-            pass  # Non-existent name found
-
-        p1 = P('~/Documents')
-        p2 = P(f'~{username}/Documents')
-        p3 = P(f'~{othername}/Documents')
-        p4 = P(f'../~{username}/Documents')
-        p5 = P(f'/~{username}/Documents')
-        p6 = P('')
-        p7 = P(f'~{fakename}/Documents')
-
-        with os_helper.EnvironmentVarGuard() as env:
-            env.pop('HOME', None)
-
-            self.assertEqual(p1.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-            self.assertRaises(RuntimeError, p7.expanduser)
-
-            env['HOME'] = '/tmp'
-            self.assertEqual(p1.expanduser(), P('/tmp/Documents'))
-            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
-            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-            self.assertRaises(RuntimeError, p7.expanduser)
-
-    @unittest.skipIf(sys.platform != "darwin",
-                     "Bad file descriptor in /dev/fd affects only macOS")
-    def test_handling_bad_descriptor(self):
-        try:
-            file_descriptors = list(pathlib.Path('/dev/fd').rglob("*"))[3:]
-            if not file_descriptors:
-                self.skipTest("no file descriptors - issue was not reproduced")
-            # Checking all file descriptors because there is no guarantee
-            # which one will fail.
-            for f in file_descriptors:
-                f.exists()
-                f.is_dir()
-                f.is_file()
-                f.is_symlink()
-                f.is_block_device()
-                f.is_char_device()
-                f.is_fifo()
-                f.is_socket()
-        except OSError as e:
-            if e.errno == errno.EBADF:
-                self.fail("Bad file descriptor not handled.")
-            raise
-
-
-@only_nt
-class WindowsPathTest(_BasePathTest, unittest.TestCase):
-    cls = pathlib.WindowsPath
-
-    def test_absolute(self):
-        P = self.cls
-
-        # Simple absolute paths.
-        self.assertEqual(str(P('c:\\').absolute()), 'c:\\')
-        self.assertEqual(str(P('c:\\a').absolute()), 'c:\\a')
-        self.assertEqual(str(P('c:\\a\\b').absolute()), 'c:\\a\\b')
-
-        # UNC absolute paths.
-        share = '\\\\server\\share\\'
-        self.assertEqual(str(P(share).absolute()), share)
-        self.assertEqual(str(P(share + 'a').absolute()), share + 'a')
-        self.assertEqual(str(P(share + 'a\\b').absolute()), share + 'a\\b')
-
-        # UNC relative paths.
-        with mock.patch("os.getcwd") as getcwd:
-            getcwd.return_value = share
-
-            self.assertEqual(str(P().absolute()), share)
-            self.assertEqual(str(P('.').absolute()), share)
-            self.assertEqual(str(P('a').absolute()), os.path.join(share, 'a'))
-            self.assertEqual(str(P('a', 'b', 'c').absolute()),
-                             os.path.join(share, 'a', 'b', 'c'))
-
-        drive = os.path.splitdrive(BASE)[0]
-        with os_helper.change_cwd(BASE):
-            # Relative path with root
-            self.assertEqual(str(P('\\').absolute()), drive + '\\')
-            self.assertEqual(str(P('\\foo').absolute()), drive + '\\foo')
-
-            # Relative path on current drive
-            self.assertEqual(str(P(drive).absolute()), BASE)
-            self.assertEqual(str(P(drive + 'foo').absolute()), os.path.join(BASE, 'foo'))
-
-        with os_helper.subst_drive(BASE) as other_drive:
-            # Set the working directory on the substitute drive
-            saved_cwd = os.getcwd()
-            other_cwd = f'{other_drive}\\dirA'
-            os.chdir(other_cwd)
-            os.chdir(saved_cwd)
-
-            # Relative path on another drive
-            self.assertEqual(str(P(other_drive).absolute()), other_cwd)
-            self.assertEqual(str(P(other_drive + 'foo').absolute()), other_cwd + '\\foo')
-
-    def test_glob(self):
-        P = self.cls
-        p = P(BASE)
-        self.assertEqual(set(p.glob("FILEa")), { P(BASE, "fileA") })
-        self.assertEqual(set(p.glob("*a\\")), { P(BASE, "dirA") })
-        self.assertEqual(set(p.glob("F*a")), { P(BASE, "fileA") })
-        self.assertEqual(set(map(str, p.glob("FILEa"))), {f"{p}\\fileA"})
-        self.assertEqual(set(map(str, p.glob("F*a"))), {f"{p}\\fileA"})
-
-    def test_rglob(self):
-        P = self.cls
-        p = P(BASE, "dirC")
-        self.assertEqual(set(p.rglob("FILEd")), { P(BASE, "dirC/dirD/fileD") })
-        self.assertEqual(set(p.rglob("*\\")), { P(BASE, "dirC/dirD") })
-        self.assertEqual(set(map(str, p.rglob("FILEd"))), {f"{p}\\dirD\\fileD"})
-
-    def test_expanduser(self):
-        P = self.cls
-        with os_helper.EnvironmentVarGuard() as env:
-            env.pop('HOME', None)
-            env.pop('USERPROFILE', None)
-            env.pop('HOMEPATH', None)
-            env.pop('HOMEDRIVE', None)
-            env['USERNAME'] = 'alice'
-
-            # test that the path returns unchanged
-            p1 = P('~/My Documents')
-            p2 = P('~alice/My Documents')
-            p3 = P('~bob/My Documents')
-            p4 = P('/~/My Documents')
-            p5 = P('d:~/My Documents')
-            p6 = P('')
-            self.assertRaises(RuntimeError, p1.expanduser)
-            self.assertRaises(RuntimeError, p2.expanduser)
-            self.assertRaises(RuntimeError, p3.expanduser)
-            self.assertEqual(p4.expanduser(), p4)
-            self.assertEqual(p5.expanduser(), p5)
-            self.assertEqual(p6.expanduser(), p6)
-
-            def check():
-                env.pop('USERNAME', None)
-                self.assertEqual(p1.expanduser(),
-                                 P('C:/Users/alice/My Documents'))
-                self.assertRaises(RuntimeError, p2.expanduser)
-                env['USERNAME'] = 'alice'
-                self.assertEqual(p2.expanduser(),
-                                 P('C:/Users/alice/My Documents'))
-                self.assertEqual(p3.expanduser(),
-                                 P('C:/Users/bob/My Documents'))
-                self.assertEqual(p4.expanduser(), p4)
-                self.assertEqual(p5.expanduser(), p5)
-                self.assertEqual(p6.expanduser(), p6)
-
-            env['HOMEPATH'] = 'C:\\Users\\alice'
-            check()
-
-            env['HOMEDRIVE'] = 'C:\\'
-            env['HOMEPATH'] = 'Users\\alice'
-            check()
-
-            env.pop('HOMEDRIVE', None)
-            env.pop('HOMEPATH', None)
-            env['USERPROFILE'] = 'C:\\Users\\alice'
-            check()
-
-            # bpo-38883: ignore `HOME` when set on windows
-            env['HOME'] = 'C:\\Users\\eve'
-            check()
-
-
-class PurePathSubclassTest(_BasePurePathTest, unittest.TestCase):
-    class cls(pathlib.PurePath):
-        pass
-
-    # repr() roundtripping is not supported in custom subclass.
-    test_repr_roundtrips = None
-
-
-class PathSubclassTest(_BasePathTest, unittest.TestCase):
-    class cls(pathlib.Path):
-        pass
-
-    # repr() roundtripping is not supported in custom subclass.
-    test_repr_roundtrips = None
-
-
-class CompatiblePathTest(unittest.TestCase):
-    """
-    Test that a type can be made compatible with PurePath
-    derivatives by implementing division operator overloads.
-    """
-
-    class CompatPath:
-        """
-        Minimum viable class to test PurePath compatibility.
-        Simply uses the division operator to join a given
-        string and the string value of another object with
-        a forward slash.
-        """
-        def __init__(self, string):
-            self.string = string
-
-        def __truediv__(self, other):
-            return type(self)(f"{self.string}/{other}")
-
-        def __rtruediv__(self, other):
-            return type(self)(f"{other}/{self.string}")
-
-    def test_truediv(self):
-        result = pathlib.PurePath("test") / self.CompatPath("right")
-        self.assertIsInstance(result, self.CompatPath)
-        self.assertEqual(result.string, "test/right")
-
-        with self.assertRaises(TypeError):
-            # Verify improper operations still raise a TypeError
-            pathlib.PurePath("test") / 10
-
-    def test_rtruediv(self):
-        result = self.CompatPath("left") / pathlib.PurePath("test")
-        self.assertIsInstance(result, self.CompatPath)
-        self.assertEqual(result.string, "left/test")
-
-        with self.assertRaises(TypeError):
-            # Verify improper operations still raise a TypeError
-            10 / pathlib.PurePath("test")
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_pathlib/__init__.py b/Lib/test/test_pathlib/__init__.py
new file mode 100644
index 0000000000..4b16ecc311
--- /dev/null
+++ b/Lib/test/test_pathlib/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_pathlib/test_pathlib.py b/Lib/test/test_pathlib/test_pathlib.py
new file mode 100644
index 0000000000..6cbc15d767
--- /dev/null
+++ b/Lib/test/test_pathlib/test_pathlib.py
@@ -0,0 +1,1660 @@
+# TODO: RUSTPYTHON
+# Has not been tested with Windows style paths
+import io
+import os
+import sys
+import errno
+import ntpath
+import pathlib
+import pickle
+import posixpath
+import socket
+import stat
+import tempfile
+import unittest
+from unittest import mock
+from urllib.request import pathname2url
+
+from test.support import import_helper
+from test.support import is_emscripten, is_wasi
+from test.support import infinite_recursion
+from test.support import os_helper
+from test.support.os_helper import TESTFN, FS_NONASCII, FakePath
+from test.test_pathlib import test_pathlib_abc
+from test.test_pathlib.test_pathlib_abc import needs_posix, needs_windows, needs_symlinks
+
+try:
+    import grp, pwd
+except ImportError:
+    grp = pwd = None
+
+
+root_in_posix = False
+if hasattr(os, 'geteuid'):
+    root_in_posix = (os.geteuid() == 0)
+
+#
+# Tests for the pure classes.
+#
+
+class PurePathTest(test_pathlib_abc.DummyPurePathTest):
+    cls = pathlib.PurePath
+
+    # Make sure any symbolic links in the base test path are resolved.
+    base = os.path.realpath(TESTFN)
+
+    # Keys are canonical paths, values are list of tuples of arguments
+    # supposed to produce equal paths.
+    equivalences = {
+        'a/b': [
+            ('a', 'b'), ('a/', 'b'), ('a', 'b/'), ('a/', 'b/'),
+            ('a/b/',), ('a//b',), ('a//b//',),
+            # Empty components get removed.
+            ('', 'a', 'b'), ('a', '', 'b'), ('a', 'b', ''),
+            ],
+        '/b/c/d': [
+            ('a', '/b/c', 'd'), ('/a', '/b/c', 'd'),
+            # Empty components get removed.
+            ('/', 'b', '', 'c/d'), ('/', '', 'b/c/d'), ('', '/b/c/d'),
+            ],
+    }
+
+    def test_concrete_class(self):
+        if self.cls is pathlib.PurePath:
+            expected = pathlib.PureWindowsPath if os.name == 'nt' else pathlib.PurePosixPath
+        else:
+            expected = self.cls
+        p = self.cls('a')
+        self.assertIs(type(p), expected)
+
+    def test_concrete_parser(self):
+        if self.cls is pathlib.PurePosixPath:
+            expected = posixpath
+        elif self.cls is pathlib.PureWindowsPath:
+            expected = ntpath
+        else:
+            expected = os.path
+        p = self.cls('a')
+        self.assertIs(p.parser, expected)
+
+    def test_different_parsers_unequal(self):
+        p = self.cls('a')
+        if p.parser is posixpath:
+            q = pathlib.PureWindowsPath('a')
+        else:
+            q = pathlib.PurePosixPath('a')
+        self.assertNotEqual(p, q)
+
+    def test_different_parsers_unordered(self):
+        p = self.cls('a')
+        if p.parser is posixpath:
+            q = pathlib.PureWindowsPath('a')
+        else:
+            q = pathlib.PurePosixPath('a')
+        with self.assertRaises(TypeError):
+            p < q
+        with self.assertRaises(TypeError):
+            p <= q
+        with self.assertRaises(TypeError):
+            p > q
+        with self.assertRaises(TypeError):
+            p >= q
+
+    def test_constructor_nested(self):
+        P = self.cls
+        P(FakePath("a/b/c"))
+        self.assertEqual(P(P('a')), P('a'))
+        self.assertEqual(P(P('a'), 'b'), P('a/b'))
+        self.assertEqual(P(P('a'), P('b')), P('a/b'))
+        self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
+        self.assertEqual(P(P('./a:b')), P('./a:b'))
+
+    @needs_windows
+    def test_constructor_nested_foreign_flavour(self):
+        # See GH-125069.
+        p1 = pathlib.PurePosixPath('b/c:\\d')
+        p2 = pathlib.PurePosixPath('b/', 'c:\\d')
+        self.assertEqual(p1, p2)
+        self.assertEqual(self.cls(p1), self.cls('b/c:/d'))
+        self.assertEqual(self.cls(p2), self.cls('b/c:/d'))
+
+    def _check_parse_path(self, raw_path, *expected):
+        sep = self.parser.sep
+        actual = self.cls._parse_path(raw_path.replace('/', sep))
+        self.assertEqual(actual, expected)
+        if altsep := self.parser.altsep:
+            actual = self.cls._parse_path(raw_path.replace('/', altsep))
+            self.assertEqual(actual, expected)
+
+    def test_parse_path_common(self):
+        check = self._check_parse_path
+        sep = self.parser.sep
+        check('',         '', '', [])
+        check('a',        '', '', ['a'])
+        check('a/',       '', '', ['a'])
+        check('a/b',      '', '', ['a', 'b'])
+        check('a/b/',     '', '', ['a', 'b'])
+        check('a/b/c/d',  '', '', ['a', 'b', 'c', 'd'])
+        check('a/b//c/d', '', '', ['a', 'b', 'c', 'd'])
+        check('a/b/c/d',  '', '', ['a', 'b', 'c', 'd'])
+        check('.',        '', '', [])
+        check('././b',    '', '', ['b'])
+        check('a/./b',    '', '', ['a', 'b'])
+        check('a/./.',    '', '', ['a'])
+        check('/a/b',     '', sep, ['a', 'b'])
+
+    def test_empty_path(self):
+        # The empty path points to '.'
+        p = self.cls('')
+        self.assertEqual(str(p), '.')
+        # Special case for the empty path.
+        self._check_str('.', ('',))
+
+    def test_parts_interning(self):
+        P = self.cls
+        p = P('/usr/bin/foo')
+        q = P('/usr/local/bin')
+        # 'usr'
+        self.assertIs(p.parts[1], q.parts[1])
+        # 'bin'
+        self.assertIs(p.parts[2], q.parts[3])
+
+    def test_join_nested(self):
+        P = self.cls
+        p = P('a/b').joinpath(P('c'))
+        self.assertEqual(p, P('a/b/c'))
+
+    def test_div_nested(self):
+        P = self.cls
+        p = P('a/b') / P('c')
+        self.assertEqual(p, P('a/b/c'))
+
+    def test_pickling_common(self):
+        P = self.cls
+        for pathstr in ('a', 'a/', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c', 'a/b/c/'):
+            with self.subTest(pathstr=pathstr):
+                p = P(pathstr)
+                for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
+                    dumped = pickle.dumps(p, proto)
+                    pp = pickle.loads(dumped)
+                    self.assertIs(pp.__class__, p.__class__)
+                    self.assertEqual(pp, p)
+                    self.assertEqual(hash(pp), hash(p))
+                    self.assertEqual(str(pp), str(p))
+
+    def test_repr_common(self):
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            with self.subTest(pathstr=pathstr):
+                p = self.cls(pathstr)
+                clsname = p.__class__.__name__
+                r = repr(p)
+                # The repr() is in the form ClassName("forward-slashes path").
+                self.assertTrue(r.startswith(clsname + '('), r)
+                self.assertTrue(r.endswith(')'), r)
+                inner = r[len(clsname) + 1 : -1]
+                self.assertEqual(eval(inner), p.as_posix())
+
+    def test_fspath_common(self):
+        P = self.cls
+        p = P('a/b')
+        self._check_str(p.__fspath__(), ('a/b',))
+        self._check_str(os.fspath(p), ('a/b',))
+
+    def test_bytes_exc_message(self):
+        P = self.cls
+        message = (r"argument should be a str or an os\.PathLike object "
+                   r"where __fspath__ returns a str, not 'bytes'")
+        with self.assertRaisesRegex(TypeError, message):
+            P(b'a')
+        with self.assertRaisesRegex(TypeError, message):
+            P(b'a', 'b')
+        with self.assertRaisesRegex(TypeError, message):
+            P('a', b'b')
+
+    def test_as_bytes_common(self):
+        sep = os.fsencode(self.sep)
+        P = self.cls
+        self.assertEqual(bytes(P('a/b')), b'a' + sep + b'b')
+
+    def test_eq_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b'), P('a/b'))
+        self.assertEqual(P('a/b'), P('a', 'b'))
+        self.assertNotEqual(P('a/b'), P('a'))
+        self.assertNotEqual(P('a/b'), P('/a/b'))
+        self.assertNotEqual(P('a/b'), P())
+        self.assertNotEqual(P('/a/b'), P('/'))
+        self.assertNotEqual(P(), P('/'))
+        self.assertNotEqual(P(), "")
+        self.assertNotEqual(P(), {})
+        self.assertNotEqual(P(), int)
+
+    def test_equivalences(self, equivalences=None):
+        if equivalences is None:
+            equivalences = self.equivalences
+        for k, tuples in equivalences.items():
+            canon = k.replace('/', self.sep)
+            posix = k.replace(self.sep, '/')
+            if canon != posix:
+                tuples = tuples + [
+                    tuple(part.replace('/', self.sep) for part in t)
+                    for t in tuples
+                    ]
+                tuples.append((posix, ))
+            pcanon = self.cls(canon)
+            for t in tuples:
+                p = self.cls(*t)
+                self.assertEqual(p, pcanon, "failed with args {}".format(t))
+                self.assertEqual(hash(p), hash(pcanon))
+                self.assertEqual(str(p), canon)
+                self.assertEqual(p.as_posix(), posix)
+
+    def test_ordering_common(self):
+        # Ordering is tuple-alike.
+        def assertLess(a, b):
+            self.assertLess(a, b)
+            self.assertGreater(b, a)
+        P = self.cls
+        a = P('a')
+        b = P('a/b')
+        c = P('abc')
+        d = P('b')
+        assertLess(a, b)
+        assertLess(a, c)
+        assertLess(a, d)
+        assertLess(b, c)
+        assertLess(c, d)
+        P = self.cls
+        a = P('/a')
+        b = P('/a/b')
+        c = P('/abc')
+        d = P('/b')
+        assertLess(a, b)
+        assertLess(a, c)
+        assertLess(a, d)
+        assertLess(b, c)
+        assertLess(c, d)
+        with self.assertRaises(TypeError):
+            P() < {}
+
+    def test_as_uri_common(self):
+        P = self.cls
+        with self.assertRaises(ValueError):
+            P('a').as_uri()
+        with self.assertRaises(ValueError):
+            P().as_uri()
+
+    def test_repr_roundtrips(self):
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            with self.subTest(pathstr=pathstr):
+                p = self.cls(pathstr)
+                r = repr(p)
+                # The repr() roundtrips.
+                q = eval(r, pathlib.__dict__)
+                self.assertIs(q.__class__, p.__class__)
+                self.assertEqual(q, p)
+                self.assertEqual(repr(q), r)
+
+    def test_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').name, '')
+        self.assertEqual(P('.').name, '')
+        self.assertEqual(P('/a/b/.').name, 'b')
+
+    def test_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').stem, '')
+        self.assertEqual(P('.').stem, '')
+
+    def test_with_name_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('.').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('/').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('a/b').with_name, '')
+        self.assertRaises(ValueError, P('a/b').with_name, '.')
+
+    def test_with_stem_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('').with_stem, 'd')
+        self.assertRaises(ValueError, P('.').with_stem, 'd')
+        self.assertRaises(ValueError, P('/').with_stem, 'd')
+        self.assertRaises(ValueError, P('a/b').with_stem, '')
+        self.assertRaises(ValueError, P('a/b').with_stem, '.')
+
+    def test_relative_to_several_args(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.relative_to('a', 'b')
+            p.relative_to('a', 'b', walk_up=True)
+
+    def test_is_relative_to_several_args(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.is_relative_to('a', 'b')
+
+    def test_is_reserved_deprecated(self):
+        P = self.cls
+        p = P('a/b')
+        with self.assertWarns(DeprecationWarning):
+            p.is_reserved()
+
+    def test_match_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a').match, '')
+        self.assertRaises(ValueError, P('a').match, '.')
+
+    @needs_posix
+    def test_parse_path_posix(self):
+        check = self._check_parse_path
+        # Collapsing of excess leading slashes, except for the double-slash
+        # special case.
+        check('//a/b',   '', '//', ['a', 'b'])
+        check('///a/b',  '', '/', ['a', 'b'])
+        check('////a/b', '', '/', ['a', 'b'])
+        # Paths which look like NT paths aren't treated specially.
+        check('c:a',     '', '', ['c:a',])
+        check('c:\\a',   '', '', ['c:\\a',])
+        check('\\a',     '', '', ['\\a',])
+
+    @needs_posix
+    def test_eq_posix(self):
+        P = self.cls
+        self.assertNotEqual(P('a/b'), P('A/b'))
+        self.assertEqual(P('/a'), P('///a'))
+        self.assertNotEqual(P('/a'), P('//a'))
+
+    @needs_posix
+    def test_as_uri_posix(self):
+        P = self.cls
+        self.assertEqual(P('/').as_uri(), 'file:///')
+        self.assertEqual(P('/a/b.c').as_uri(), 'file:///a/b.c')
+        self.assertEqual(P('/a/b%#c').as_uri(), 'file:///a/b%25%23c')
+
+    @needs_posix
+    def test_as_uri_non_ascii(self):
+        from urllib.parse import quote_from_bytes
+        P = self.cls
+        try:
+            os.fsencode('\xe9')
+        except UnicodeEncodeError:
+            self.skipTest("\\xe9 cannot be encoded to the filesystem encoding")
+        self.assertEqual(P('/a/b\xe9').as_uri(),
+                         'file:///a/b' + quote_from_bytes(os.fsencode('\xe9')))
+
+    @needs_posix
+    def test_parse_windows_path(self):
+        P = self.cls
+        p = P('c:', 'a', 'b')
+        pp = P(pathlib.PureWindowsPath('c:\\a\\b'))
+        self.assertEqual(p, pp)
+
+    windows_equivalences = {
+        './a:b': [ ('./a:b',) ],
+        'c:a': [ ('c:', 'a'), ('c:', 'a/'), ('.', 'c:', 'a') ],
+        'c:/a': [
+            ('c:/', 'a'), ('c:', '/', 'a'), ('c:', '/a'),
+            ('/z', 'c:/', 'a'), ('//x/y', 'c:/', 'a'),
+            ],
+        '//a/b/': [ ('//a/b',) ],
+        '//a/b/c': [
+            ('//a/b', 'c'), ('//a/b/', 'c'),
+            ],
+    }
+
+    @needs_windows
+    def test_equivalences_windows(self):
+        self.test_equivalences(self.windows_equivalences)
+
+    @needs_windows
+    def test_parse_path_windows(self):
+        check = self._check_parse_path
+        # First part is anchored.
+        check('c:',                  'c:', '', [])
+        check('c:/',                 'c:', '\\', [])
+        check('/',                   '', '\\', [])
+        check('c:a',                 'c:', '', ['a'])
+        check('c:/a',                'c:', '\\', ['a'])
+        check('/a',                  '', '\\', ['a'])
+        # UNC paths.
+        check('//',                  '\\\\', '', [])
+        check('//a',                 '\\\\a', '', [])
+        check('//a/',                '\\\\a\\', '', [])
+        check('//a/b',               '\\\\a\\b', '\\', [])
+        check('//a/b/',              '\\\\a\\b', '\\', [])
+        check('//a/b/c',             '\\\\a\\b', '\\', ['c'])
+        # Collapsing and stripping excess slashes.
+        check('Z://b//c/d/',         'Z:', '\\', ['b', 'c', 'd'])
+        # UNC paths.
+        check('//b/c//d',            '\\\\b\\c', '\\', ['d'])
+        # Extended paths.
+        check('//./c:',              '\\\\.\\c:', '', [])
+        check('//?/c:/',             '\\\\?\\c:', '\\', [])
+        check('//?/c:/a',            '\\\\?\\c:', '\\', ['a'])
+        # Extended UNC paths (format is "\\?\UNC\server\share").
+        check('//?',                 '\\\\?', '', [])
+        check('//?/',                '\\\\?\\', '', [])
+        check('//?/UNC',             '\\\\?\\UNC', '', [])
+        check('//?/UNC/',            '\\\\?\\UNC\\', '', [])
+        check('//?/UNC/b',           '\\\\?\\UNC\\b', '', [])
+        check('//?/UNC/b/',          '\\\\?\\UNC\\b\\', '', [])
+        check('//?/UNC/b/c',         '\\\\?\\UNC\\b\\c', '\\', [])
+        check('//?/UNC/b/c/',        '\\\\?\\UNC\\b\\c', '\\', [])
+        check('//?/UNC/b/c/d',       '\\\\?\\UNC\\b\\c', '\\', ['d'])
+        # UNC device paths
+        check('//./BootPartition/',  '\\\\.\\BootPartition', '\\', [])
+        check('//?/BootPartition/',  '\\\\?\\BootPartition', '\\', [])
+        check('//./PhysicalDrive0',  '\\\\.\\PhysicalDrive0', '', [])
+        check('//?/Volume{}/',       '\\\\?\\Volume{}', '\\', [])
+        check('//./nul',             '\\\\.\\nul', '', [])
+        # Paths to files with NTFS alternate data streams
+        check('./c:s',               '', '', ['c:s'])
+        check('cc:s',                '', '', ['cc:s'])
+        check('C:c:s',               'C:', '', ['c:s'])
+        check('C:/c:s',              'C:', '\\', ['c:s'])
+        check('D:a/c:b',             'D:', '', ['a', 'c:b'])
+        check('D:/a/c:b',            'D:', '\\', ['a', 'c:b'])
+
+    @needs_windows
+    def test_eq_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b'), P('c:a/b'))
+        self.assertEqual(P('c:a/b'), P('c:', 'a', 'b'))
+        self.assertNotEqual(P('c:a/b'), P('d:a/b'))
+        self.assertNotEqual(P('c:a/b'), P('c:/a/b'))
+        self.assertNotEqual(P('/a/b'), P('c:/a/b'))
+        # Case-insensitivity.
+        self.assertEqual(P('a/B'), P('A/b'))
+        self.assertEqual(P('C:a/B'), P('c:A/b'))
+        self.assertEqual(P('//Some/SHARE/a/B'), P('//somE/share/A/b'))
+        self.assertEqual(P('\u0130'), P('i\u0307'))
+
+    @needs_windows
+    def test_as_uri_windows(self):
+        P = self.cls
+        with self.assertRaises(ValueError):
+            P('/a/b').as_uri()
+        with self.assertRaises(ValueError):
+            P('c:a/b').as_uri()
+        self.assertEqual(P('c:/').as_uri(), 'file:///c:/')
+        self.assertEqual(P('c:/a/b.c').as_uri(), 'file:///c:/a/b.c')
+        self.assertEqual(P('c:/a/b%#c').as_uri(), 'file:///c:/a/b%25%23c')
+        self.assertEqual(P('//some/share/').as_uri(), 'file://some/share/')
+        self.assertEqual(P('//some/share/a/b.c').as_uri(),
+                         'file://some/share/a/b.c')
+
+        from urllib.parse import quote_from_bytes
+        QUOTED_FS_NONASCII = quote_from_bytes(os.fsencode(FS_NONASCII))
+        self.assertEqual(P('c:/a/b' + FS_NONASCII).as_uri(),
+                         'file:///c:/a/b' + QUOTED_FS_NONASCII)
+        self.assertEqual(P('//some/share/a/b%#c' + FS_NONASCII).as_uri(),
+                         'file://some/share/a/b%25%23c' + QUOTED_FS_NONASCII)
+
+    @needs_windows
+    def test_ordering_windows(self):
+        # Case-insensitivity.
+        def assertOrderedEqual(a, b):
+            self.assertLessEqual(a, b)
+            self.assertGreaterEqual(b, a)
+        P = self.cls
+        p = P('c:A/b')
+        q = P('C:a/B')
+        assertOrderedEqual(p, q)
+        self.assertFalse(p < q)
+        self.assertFalse(p > q)
+        p = P('//some/Share/A/b')
+        q = P('//Some/SHARE/a/B')
+        assertOrderedEqual(p, q)
+        self.assertFalse(p < q)
+        self.assertFalse(p > q)
+
+
+class PurePosixPathTest(PurePathTest):
+    cls = pathlib.PurePosixPath
+
+
+class PureWindowsPathTest(PurePathTest):
+    cls = pathlib.PureWindowsPath
+
+
+class PurePathSubclassTest(PurePathTest):
+    class cls(pathlib.PurePath):
+        pass
+
+    # repr() roundtripping is not supported in custom subclass.
+    test_repr_roundtrips = None
+
+
+#
+# Tests for the concrete classes.
+#
+
+class PathTest(test_pathlib_abc.DummyPathTest, PurePathTest):
+    """Tests for the FS-accessing functionalities of the Path classes."""
+    cls = pathlib.Path
+    can_symlink = os_helper.can_symlink()
+
+    def setUp(self):
+        super().setUp()
+        os.chmod(self.parser.join(self.base, 'dirE'), 0)
+
+    def tearDown(self):
+        os.chmod(self.parser.join(self.base, 'dirE'), 0o777)
+        os_helper.rmtree(self.base)
+
+    def tempdir(self):
+        d = os_helper._longpath(tempfile.mkdtemp(suffix='-dirD',
+                                                 dir=os.getcwd()))
+        self.addCleanup(os_helper.rmtree, d)
+        return d
+
+    def test_matches_pathbase_api(self):
+        our_names = {name for name in dir(self.cls) if name[0] != '_'}
+        our_names.remove('is_reserved')  # only present in PurePath
+        path_names = {name for name in dir(pathlib._abc.PathBase) if name[0] != '_'}
+        self.assertEqual(our_names, path_names)
+        for attr_name in our_names:
+            if attr_name == 'parser':
+                # On Windows, Path.parser is ntpath, but PathBase.parser is
+                # posixpath, and so their docstrings differ.
+                continue
+            our_attr = getattr(self.cls, attr_name)
+            path_attr = getattr(pathlib._abc.PathBase, attr_name)
+            self.assertEqual(our_attr.__doc__, path_attr.__doc__)
+
+    def test_concrete_class(self):
+        if self.cls is pathlib.Path:
+            expected = pathlib.WindowsPath if os.name == 'nt' else pathlib.PosixPath
+        else:
+            expected = self.cls
+        p = self.cls('a')
+        self.assertIs(type(p), expected)
+
+    def test_unsupported_parser(self):
+        if self.cls.parser is os.path:
+            self.skipTest("path parser is supported")
+        else:
+            self.assertRaises(pathlib.UnsupportedOperation, self.cls)
+
+    def _test_cwd(self, p):
+        q = self.cls(os.getcwd())
+        self.assertEqual(p, q)
+        self.assertEqualNormCase(str(p), str(q))
+        self.assertIs(type(p), type(q))
+        self.assertTrue(p.is_absolute())
+
+    def test_cwd(self):
+        p = self.cls.cwd()
+        self._test_cwd(p)
+
+    def test_absolute_common(self):
+        P = self.cls
+
+        with mock.patch("os.getcwd") as getcwd:
+            getcwd.return_value = self.base
+
+            # Simple relative paths.
+            self.assertEqual(str(P().absolute()), self.base)
+            self.assertEqual(str(P('.').absolute()), self.base)
+            self.assertEqual(str(P('a').absolute()), os.path.join(self.base, 'a'))
+            self.assertEqual(str(P('a', 'b', 'c').absolute()), os.path.join(self.base, 'a', 'b', 'c'))
+
+            # Symlinks should not be resolved.
+            self.assertEqual(str(P('linkB', 'fileB').absolute()), os.path.join(self.base, 'linkB', 'fileB'))
+            self.assertEqual(str(P('brokenLink').absolute()), os.path.join(self.base, 'brokenLink'))
+            self.assertEqual(str(P('brokenLinkLoop').absolute()), os.path.join(self.base, 'brokenLinkLoop'))
+
+            # '..' entries should be preserved and not normalised.
+            self.assertEqual(str(P('..').absolute()), os.path.join(self.base, '..'))
+            self.assertEqual(str(P('a', '..').absolute()), os.path.join(self.base, 'a', '..'))
+            self.assertEqual(str(P('..', 'b').absolute()), os.path.join(self.base, '..', 'b'))
+
+    def _test_home(self, p):
+        q = self.cls(os.path.expanduser('~'))
+        self.assertEqual(p, q)
+        self.assertEqualNormCase(str(p), str(q))
+        self.assertIs(type(p), type(q))
+        self.assertTrue(p.is_absolute())
+
+    @unittest.skipIf(
+        pwd is None, reason="Test requires pwd module to get homedir."
+    )
+    def test_home(self):
+        with os_helper.EnvironmentVarGuard() as env:
+            self._test_home(self.cls.home())
+
+            env.clear()
+            env['USERPROFILE'] = os.path.join(self.base, 'userprofile')
+            self._test_home(self.cls.home())
+
+            # bpo-38883: ignore `HOME` when set on windows
+            env['HOME'] = os.path.join(self.base, 'home')
+            self._test_home(self.cls.home())
+
+    @unittest.skipIf(is_wasi, "WASI has no user accounts.")
+    def test_expanduser_common(self):
+        P = self.cls
+        p = P('~')
+        self.assertEqual(p.expanduser(), P(os.path.expanduser('~')))
+        p = P('foo')
+        self.assertEqual(p.expanduser(), p)
+        p = P('/~')
+        self.assertEqual(p.expanduser(), p)
+        p = P('../~')
+        self.assertEqual(p.expanduser(), p)
+        p = P(P('').absolute().anchor) / '~'
+        self.assertEqual(p.expanduser(), p)
+        p = P('~/a:b')
+        self.assertEqual(p.expanduser(), P(os.path.expanduser('~'), './a:b'))
+
+    def test_with_segments(self):
+        class P(self.cls):
+            def __init__(self, *pathsegments, session_id):
+                super().__init__(*pathsegments)
+                self.session_id = session_id
+
+            def with_segments(self, *pathsegments):
+                return type(self)(*pathsegments, session_id=self.session_id)
+        p = P(self.base, session_id=42)
+        self.assertEqual(42, p.absolute().session_id)
+        self.assertEqual(42, p.resolve().session_id)
+        if not is_wasi:  # WASI has no user accounts.
+            self.assertEqual(42, p.with_segments('~').expanduser().session_id)
+        self.assertEqual(42, (p / 'fileA').rename(p / 'fileB').session_id)
+        self.assertEqual(42, (p / 'fileB').replace(p / 'fileA').session_id)
+        if self.can_symlink:
+            self.assertEqual(42, (p / 'linkA').readlink().session_id)
+        for path in p.iterdir():
+            self.assertEqual(42, path.session_id)
+        for path in p.glob('*'):
+            self.assertEqual(42, path.session_id)
+        for path in p.rglob('*'):
+            self.assertEqual(42, path.session_id)
+        for dirpath, dirnames, filenames in p.walk():
+            self.assertEqual(42, dirpath.session_id)
+
+    def test_open_unbuffered(self):
+        p = self.cls(self.base)
+        with (p / 'fileA').open('rb', buffering=0) as f:
+            self.assertIsInstance(f, io.RawIOBase)
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_resolve_nonexist_relative_issue38671(self):
+        p = self.cls('non', 'exist')
+
+        old_cwd = os.getcwd()
+        os.chdir(self.base)
+        try:
+            self.assertEqual(p.resolve(), self.cls(self.base, p))
+        finally:
+            os.chdir(old_cwd)
+
+    @os_helper.skip_unless_working_chmod
+    def test_chmod(self):
+        p = self.cls(self.base) / 'fileA'
+        mode = p.stat().st_mode
+        # Clear writable bit.
+        new_mode = mode & ~0o222
+        p.chmod(new_mode)
+        self.assertEqual(p.stat().st_mode, new_mode)
+        # Set writable bit.
+        new_mode = mode | 0o222
+        p.chmod(new_mode)
+        self.assertEqual(p.stat().st_mode, new_mode)
+
+    # On Windows, os.chmod does not follow symlinks (issue #15411)
+    @needs_posix
+    @os_helper.skip_unless_working_chmod
+    def test_chmod_follow_symlinks_true(self):
+        p = self.cls(self.base) / 'linkA'
+        q = p.resolve()
+        mode = q.stat().st_mode
+        # Clear writable bit.
+        new_mode = mode & ~0o222
+        p.chmod(new_mode, follow_symlinks=True)
+        self.assertEqual(q.stat().st_mode, new_mode)
+        # Set writable bit
+        new_mode = mode | 0o222
+        p.chmod(new_mode, follow_symlinks=True)
+        self.assertEqual(q.stat().st_mode, new_mode)
+
+    # XXX also need a test for lchmod.
+
+    def _get_pw_name_or_skip_test(self, uid):
+        try:
+            return pwd.getpwuid(uid).pw_name
+        except KeyError:
+            self.skipTest(
+                "user %d doesn't have an entry in the system database" % uid)
+
+    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
+    def test_owner(self):
+        p = self.cls(self.base) / 'fileA'
+        expected_uid = p.stat().st_uid
+        expected_name = self._get_pw_name_or_skip_test(expected_uid)
+
+        self.assertEqual(expected_name, p.owner())
+
+    @unittest.skipUnless(pwd, "the pwd module is needed for this test")
+    @unittest.skipUnless(root_in_posix, "test needs root privilege")
+    def test_owner_no_follow_symlinks(self):
+        all_users = [u.pw_uid for u in pwd.getpwall()]
+        if len(all_users) < 2:
+            self.skipTest("test needs more than one user")
+
+        target = self.cls(self.base) / 'fileA'
+        link = self.cls(self.base) / 'linkA'
+
+        uid_1, uid_2 = all_users[:2]
+        os.chown(target, uid_1, -1)
+        os.chown(link, uid_2, -1, follow_symlinks=False)
+
+        expected_uid = link.stat(follow_symlinks=False).st_uid
+        expected_name = self._get_pw_name_or_skip_test(expected_uid)
+
+        self.assertEqual(expected_uid, uid_2)
+        self.assertEqual(expected_name, link.owner(follow_symlinks=False))
+
+    def _get_gr_name_or_skip_test(self, gid):
+        try:
+            return grp.getgrgid(gid).gr_name
+        except KeyError:
+            self.skipTest(
+                "group %d doesn't have an entry in the system database" % gid)
+
+    @unittest.skipUnless(grp, "the grp module is needed for this test")
+    def test_group(self):
+        p = self.cls(self.base) / 'fileA'
+        expected_gid = p.stat().st_gid
+        expected_name = self._get_gr_name_or_skip_test(expected_gid)
+
+        self.assertEqual(expected_name, p.group())
+
+    @unittest.skipUnless(grp, "the grp module is needed for this test")
+    @unittest.skipUnless(root_in_posix, "test needs root privilege")
+    def test_group_no_follow_symlinks(self):
+        all_groups = [g.gr_gid for g in grp.getgrall()]
+        if len(all_groups) < 2:
+            self.skipTest("test needs more than one group")
+
+        target = self.cls(self.base) / 'fileA'
+        link = self.cls(self.base) / 'linkA'
+
+        gid_1, gid_2 = all_groups[:2]
+        os.chown(target, -1, gid_1)
+        os.chown(link, -1, gid_2, follow_symlinks=False)
+
+        expected_gid = link.stat(follow_symlinks=False).st_gid
+        expected_name = self._get_gr_name_or_skip_test(expected_gid)
+
+        self.assertEqual(expected_gid, gid_2)
+        self.assertEqual(expected_name, link.group(follow_symlinks=False))
+
+    def test_unlink(self):
+        p = self.cls(self.base) / 'fileA'
+        p.unlink()
+        self.assertFileNotFound(p.stat)
+        self.assertFileNotFound(p.unlink)
+
+    def test_unlink_missing_ok(self):
+        p = self.cls(self.base) / 'fileAAA'
+        self.assertFileNotFound(p.unlink)
+        p.unlink(missing_ok=True)
+
+    def test_rmdir(self):
+        p = self.cls(self.base) / 'dirA'
+        for q in p.iterdir():
+            q.unlink()
+        p.rmdir()
+        self.assertFileNotFound(p.stat)
+        self.assertFileNotFound(p.unlink)
+
+    @os_helper.skip_unless_hardlink
+    def test_hardlink_to(self):
+        P = self.cls(self.base)
+        target = P / 'fileA'
+        size = target.stat().st_size
+        # linking to another path.
+        link = P / 'dirA' / 'fileAA'
+        link.hardlink_to(target)
+        self.assertEqual(link.stat().st_size, size)
+        self.assertTrue(os.path.samefile(target, link))
+        self.assertTrue(target.exists())
+        # Linking to a str of a relative path.
+        link2 = P / 'dirA' / 'fileAAA'
+        target2 = self.parser.join(TESTFN, 'fileA')
+        link2.hardlink_to(target2)
+        self.assertEqual(os.stat(target2).st_size, size)
+        self.assertTrue(link2.exists())
+
+    @unittest.skipIf(hasattr(os, "link"), "os.link() is present")
+    def test_hardlink_to_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        # linking to another path.
+        q = P / 'dirA' / 'fileAA'
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            q.hardlink_to(p)
+
+    def test_rename(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        size = p.stat().st_size
+        # Renaming to another path.
+        q = P / 'dirA' / 'fileAA'
+        renamed_p = p.rename(q)
+        self.assertEqual(renamed_p, q)
+        self.assertEqual(q.stat().st_size, size)
+        self.assertFileNotFound(p.stat)
+        # Renaming to a str of a relative path.
+        r = self.parser.join(TESTFN, 'fileAAA')
+        renamed_q = q.rename(r)
+        self.assertEqual(renamed_q, self.cls(r))
+        self.assertEqual(os.stat(r).st_size, size)
+        self.assertFileNotFound(q.stat)
+
+    def test_replace(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        size = p.stat().st_size
+        # Replacing a non-existing path.
+        q = P / 'dirA' / 'fileAA'
+        replaced_p = p.replace(q)
+        self.assertEqual(replaced_p, q)
+        self.assertEqual(q.stat().st_size, size)
+        self.assertFileNotFound(p.stat)
+        # Replacing another (existing) path.
+        r = self.parser.join(TESTFN, 'dirB', 'fileB')
+        replaced_q = q.replace(r)
+        self.assertEqual(replaced_q, self.cls(r))
+        self.assertEqual(os.stat(r).st_size, size)
+        self.assertFileNotFound(q.stat)
+
+    def test_touch_common(self):
+        P = self.cls(self.base)
+        p = P / 'newfileA'
+        self.assertFalse(p.exists())
+        p.touch()
+        self.assertTrue(p.exists())
+        st = p.stat()
+        old_mtime = st.st_mtime
+        old_mtime_ns = st.st_mtime_ns
+        # Rewind the mtime sufficiently far in the past to work around
+        # filesystem-specific timestamp granularity.
+        os.utime(str(p), (old_mtime - 10, old_mtime - 10))
+        # The file mtime should be refreshed by calling touch() again.
+        p.touch()
+        st = p.stat()
+        self.assertGreaterEqual(st.st_mtime_ns, old_mtime_ns)
+        self.assertGreaterEqual(st.st_mtime, old_mtime)
+        # Now with exist_ok=False.
+        p = P / 'newfileB'
+        self.assertFalse(p.exists())
+        p.touch(mode=0o700, exist_ok=False)
+        self.assertTrue(p.exists())
+        self.assertRaises(OSError, p.touch, exist_ok=False)
+
+    def test_touch_nochange(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        p.touch()
+        with p.open('rb') as f:
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_mkdir(self):
+        P = self.cls(self.base)
+        p = P / 'newdirA'
+        self.assertFalse(p.exists())
+        p.mkdir()
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_parents(self):
+        # Creating a chain of directories.
+        p = self.cls(self.base, 'newdirB', 'newdirC')
+        self.assertFalse(p.exists())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        p.mkdir(parents=True)
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(OSError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        # Test `mode` arg.
+        mode = stat.S_IMODE(p.stat().st_mode)  # Default mode.
+        p = self.cls(self.base, 'newdirD', 'newdirE')
+        p.mkdir(0o555, parents=True)
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        if os.name != 'nt':
+            # The directory's permissions follow the mode argument.
+            self.assertEqual(stat.S_IMODE(p.stat().st_mode), 0o7555 & mode)
+        # The parent's permissions follow the default process settings.
+        self.assertEqual(stat.S_IMODE(p.parent.stat().st_mode), mode)
+
+    def test_mkdir_exist_ok(self):
+        p = self.cls(self.base, 'dirB')
+        st_ctime_first = p.stat().st_ctime
+        self.assertTrue(p.exists())
+        self.assertTrue(p.is_dir())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p.mkdir(exist_ok=True)
+        self.assertTrue(p.exists())
+        self.assertEqual(p.stat().st_ctime, st_ctime_first)
+
+    def test_mkdir_exist_ok_with_parent(self):
+        p = self.cls(self.base, 'dirC')
+        self.assertTrue(p.exists())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p = p / 'newdirC'
+        p.mkdir(parents=True)
+        st_ctime_first = p.stat().st_ctime
+        self.assertTrue(p.exists())
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        p.mkdir(parents=True, exist_ok=True)
+        self.assertTrue(p.exists())
+        self.assertEqual(p.stat().st_ctime, st_ctime_first)
+
+    @unittest.skipIf(is_emscripten, "FS root cannot be modified on Emscripten.")
+    def test_mkdir_exist_ok_root(self):
+        # Issue #25803: A drive root could raise PermissionError on Windows.
+        self.cls('/').resolve().mkdir(exist_ok=True)
+        self.cls('/').resolve().mkdir(parents=True, exist_ok=True)
+
+    @needs_windows  # XXX: not sure how to test this on POSIX.
+    def test_mkdir_with_unknown_drive(self):
+        for d in 'ZYXWVUTSRQPONMLKJIHGFEDCBA':
+            p = self.cls(d + ':\\')
+            if not p.is_dir():
+                break
+        else:
+            self.skipTest("cannot find a drive that doesn't exist")
+        with self.assertRaises(OSError):
+            (p / 'child' / 'path').mkdir(parents=True)
+
+    def test_mkdir_with_child_file(self):
+        p = self.cls(self.base, 'dirB', 'fileB')
+        self.assertTrue(p.exists())
+        # An exception is raised when the last path component is an existing
+        # regular file, regardless of whether exist_ok is true or not.
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(parents=True, exist_ok=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_no_parents_file(self):
+        p = self.cls(self.base, 'fileA')
+        self.assertTrue(p.exists())
+        # An exception is raised when the last path component is an existing
+        # regular file, regardless of whether exist_ok is true or not.
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir()
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+        with self.assertRaises(FileExistsError) as cm:
+            p.mkdir(exist_ok=True)
+        self.assertEqual(cm.exception.errno, errno.EEXIST)
+
+    def test_mkdir_concurrent_parent_creation(self):
+        for pattern_num in range(32):
+            p = self.cls(self.base, 'dirCPC%d' % pattern_num)
+            self.assertFalse(p.exists())
+
+            real_mkdir = os.mkdir
+            def my_mkdir(path, mode=0o777):
+                path = str(path)
+                # Emulate another process that would create the directory
+                # just before we try to create it ourselves.  We do it
+                # in all possible pattern combinations, assuming that this
+                # function is called at most 5 times (dirCPC/dir1/dir2,
+                # dirCPC/dir1, dirCPC, dirCPC/dir1, dirCPC/dir1/dir2).
+                if pattern.pop():
+                    real_mkdir(path, mode)  # From another process.
+                    concurrently_created.add(path)
+                real_mkdir(path, mode)  # Our real call.
+
+            pattern = [bool(pattern_num & (1 << n)) for n in range(5)]
+            concurrently_created = set()
+            p12 = p / 'dir1' / 'dir2'
+            try:
+                with mock.patch("os.mkdir", my_mkdir):
+                    p12.mkdir(parents=True, exist_ok=False)
+            except FileExistsError:
+                self.assertIn(str(p12), concurrently_created)
+            else:
+                self.assertNotIn(str(p12), concurrently_created)
+            self.assertTrue(p.exists())
+
+    @needs_symlinks
+    def test_symlink_to(self):
+        P = self.cls(self.base)
+        target = P / 'fileA'
+        # Symlinking a path target.
+        link = P / 'dirA' / 'linkAA'
+        link.symlink_to(target)
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        # Symlinking a str target.
+        link = P / 'dirA' / 'linkAAA'
+        link.symlink_to(str(target))
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        self.assertFalse(link.is_dir())
+        # Symlinking to a directory.
+        target = P / 'dirB'
+        link = P / 'dirA' / 'linkAAAA'
+        link.symlink_to(target, target_is_directory=True)
+        self.assertEqual(link.stat(), target.stat())
+        self.assertNotEqual(link.lstat(), target.stat())
+        self.assertTrue(link.is_dir())
+        self.assertTrue(list(link.iterdir()))
+
+    @unittest.skipIf(hasattr(os, "symlink"), "os.symlink() is present")
+    def test_symlink_to_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        # linking to another path.
+        q = P / 'dirA' / 'fileAA'
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            q.symlink_to(p)
+
+    def test_is_junction(self):
+        P = self.cls(self.base)
+
+        with mock.patch.object(P.parser, 'isjunction'):
+            self.assertEqual(P.is_junction(), P.parser.isjunction.return_value)
+            P.parser.isjunction.assert_called_once_with(P)
+
+    @unittest.skipUnless(hasattr(os, "mkfifo"), "os.mkfifo() required")
+    @unittest.skipIf(sys.platform == "vxworks",
+                    "fifo requires special path on VxWorks")
+    def test_is_fifo_true(self):
+        P = self.cls(self.base, 'myfifo')
+        try:
+            os.mkfifo(str(P))
+        except PermissionError as e:
+            self.skipTest('os.mkfifo(): %s' % e)
+        self.assertTrue(P.is_fifo())
+        self.assertFalse(P.is_socket())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(self.base, 'myfifo\udfff').is_fifo(), False)
+        self.assertIs(self.cls(self.base, 'myfifo\x00').is_fifo(), False)
+
+    @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
+    @unittest.skipIf(
+        is_emscripten, "Unix sockets are not implemented on Emscripten."
+    )
+    @unittest.skipIf(
+        is_wasi, "Cannot create socket on WASI."
+    )
+    def test_is_socket_true(self):
+        P = self.cls(self.base, 'mysock')
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.addCleanup(sock.close)
+        try:
+            sock.bind(str(P))
+        except OSError as e:
+            if (isinstance(e, PermissionError) or
+                    "AF_UNIX path too long" in str(e)):
+                self.skipTest("cannot bind Unix socket: " + str(e))
+        self.assertTrue(P.is_socket())
+        self.assertFalse(P.is_fifo())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(self.base, 'mysock\udfff').is_socket(), False)
+        self.assertIs(self.cls(self.base, 'mysock\x00').is_socket(), False)
+
+    def test_is_char_device_true(self):
+        # os.devnull should generally be a char device.
+        P = self.cls(os.devnull)
+        if not P.exists():
+            self.skipTest("null device required")
+        self.assertTrue(P.is_char_device())
+        self.assertFalse(P.is_block_device())
+        self.assertFalse(P.is_file())
+        self.assertIs(self.cls(f'{os.devnull}\udfff').is_char_device(), False)
+        self.assertIs(self.cls(f'{os.devnull}\x00').is_char_device(), False)
+
+    def test_is_mount_root(self):
+        if os.name == 'nt':
+            R = self.cls('c:\\')
+        else:
+            R = self.cls('/')
+        self.assertTrue(R.is_mount())
+        self.assertFalse((R / '\udfff').is_mount())
+
+    def test_passing_kwargs_deprecated(self):
+        with self.assertWarns(DeprecationWarning):
+            self.cls(foo="bar")
+
+    def setUpWalk(self):
+        super().setUpWalk()
+        sub21_path= self.sub2_path / "SUB21"
+        tmp5_path = sub21_path / "tmp3"
+        broken_link3_path = self.sub2_path / "broken_link3"
+
+        os.makedirs(sub21_path)
+        tmp5_path.write_text("I am tmp5, blame test_pathlib.")
+        if self.can_symlink:
+            os.symlink(tmp5_path, broken_link3_path)
+            self.sub2_tree[2].append('broken_link3')
+            self.sub2_tree[2].sort()
+        if not is_emscripten:
+            # Emscripten fails with inaccessible directories.
+            os.chmod(sub21_path, 0)
+        try:
+            os.listdir(sub21_path)
+        except PermissionError:
+            self.sub2_tree[1].append('SUB21')
+        else:
+            os.chmod(sub21_path, stat.S_IRWXU)
+            os.unlink(tmp5_path)
+            os.rmdir(sub21_path)
+
+    def test_walk_bad_dir(self):
+        self.setUpWalk()
+        errors = []
+        walk_it = self.walk_path.walk(on_error=errors.append)
+        root, dirs, files = next(walk_it)
+        self.assertEqual(errors, [])
+        dir1 = 'SUB1'
+        path1 = root / dir1
+        path1new = (root / dir1).with_suffix(".new")
+        path1.rename(path1new)
+        try:
+            roots = [r for r, _, _ in walk_it]
+            self.assertTrue(errors)
+            self.assertNotIn(path1, roots)
+            self.assertNotIn(path1new, roots)
+            for dir2 in dirs:
+                if dir2 != dir1:
+                    self.assertIn(root / dir2, roots)
+        finally:
+            path1new.rename(path1)
+
+    def test_walk_many_open_files(self):
+        depth = 30
+        base = self.cls(self.base, 'deep')
+        path = self.cls(base, *(['d']*depth))
+        path.mkdir(parents=True)
+
+        iters = [base.walk(top_down=False) for _ in range(100)]
+        for i in range(depth + 1):
+            expected = (path, ['d'] if i else [], [])
+            for it in iters:
+                self.assertEqual(next(it), expected)
+            path = path.parent
+
+        iters = [base.walk(top_down=True) for _ in range(100)]
+        path = base
+        for i in range(depth + 1):
+            expected = (path, ['d'] if i < depth else [], [])
+            for it in iters:
+                self.assertEqual(next(it), expected)
+            path = path / 'd'
+
+    def test_walk_above_recursion_limit(self):
+        recursion_limit = 40
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = self.cls(self.base, 'deep')
+        path = base.joinpath(*(['d'] * directory_depth))
+        path.mkdir(parents=True)
+
+        with infinite_recursion(recursion_limit):
+            list(base.walk())
+            list(base.walk(top_down=False))
+
+    def test_glob_empty_pattern(self):
+        p = self.cls('')
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob(''))
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob('.'))
+        with self.assertRaisesRegex(ValueError, 'Unacceptable pattern'):
+            list(p.glob('./'))
+
+    def test_glob_many_open_files(self):
+        depth = 30
+        P = self.cls
+        p = base = P(self.base) / 'deep'
+        p.mkdir()
+        for _ in range(depth):
+            p /= 'd'
+            p.mkdir()
+        pattern = '/'.join(['*'] * depth)
+        iters = [base.glob(pattern) for j in range(100)]
+        for it in iters:
+            self.assertEqual(next(it), p)
+        iters = [base.rglob('d') for j in range(100)]
+        p = base
+        for i in range(depth):
+            p = p / 'd'
+            for it in iters:
+                self.assertEqual(next(it), p)
+
+    def test_glob_above_recursion_limit(self):
+        recursion_limit = 50
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = self.cls(self.base, 'deep')
+        path = base.joinpath(*(['d'] * directory_depth))
+        path.mkdir(parents=True)
+
+        with infinite_recursion(recursion_limit):
+            list(base.glob('**/'))
+
+    def test_glob_pathlike(self):
+        P = self.cls
+        p = P(self.base)
+        pattern = "dir*/file*"
+        expect = {p / "dirB/fileB", p / "dirC/fileC"}
+        self.assertEqual(expect, set(p.glob(P(pattern))))
+        self.assertEqual(expect, set(p.glob(FakePath(pattern))))
+
+    @needs_symlinks
+    def test_glob_dot(self):
+        P = self.cls
+        with os_helper.change_cwd(P(self.base, "dirC")):
+            self.assertEqual(
+                set(P('.').glob('*')), {P("fileC"), P("novel.txt"), P("dirD")})
+            self.assertEqual(
+                set(P('.').glob('**')), {P("fileC"), P("novel.txt"), P("dirD"), P("dirD/fileD"), P(".")})
+            self.assertEqual(
+                set(P('.').glob('**/*')), {P("fileC"), P("novel.txt"), P("dirD"), P("dirD/fileD")})
+            self.assertEqual(
+                set(P('.').glob('**/*/*')), {P("dirD/fileD")})
+
+    def test_glob_inaccessible(self):
+        P = self.cls
+        p = P(self.base, "mydir1", "mydir2")
+        p.mkdir(parents=True)
+        p.parent.chmod(0)
+        self.assertEqual(set(p.glob('*')), set())
+
+    def test_rglob_pathlike(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        pattern = "**/file*"
+        expect = {p / "fileC", p / "dirD/fileD"}
+        self.assertEqual(expect, set(p.rglob(P(pattern))))
+        self.assertEqual(expect, set(p.rglob(FakePath(pattern))))
+
+    @needs_posix
+    def test_absolute_posix(self):
+        P = self.cls
+        self.assertEqual(str(P('/').absolute()), '/')
+        self.assertEqual(str(P('/a').absolute()), '/a')
+        self.assertEqual(str(P('/a/b').absolute()), '/a/b')
+
+        # '//'-prefixed absolute path (supported by POSIX).
+        self.assertEqual(str(P('//').absolute()), '//')
+        self.assertEqual(str(P('//a').absolute()), '//a')
+        self.assertEqual(str(P('//a/b').absolute()), '//a/b')
+
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    @needs_posix
+    def test_open_mode(self):
+        # Unmask all permissions except world-write, which may
+        # not be supported on some filesystems (see GH-85633.)
+        old_mask = os.umask(0o002)
+        self.addCleanup(os.umask, old_mask)
+        p = self.cls(self.base)
+        with (p / 'new_file').open('wb'):
+            pass
+        st = os.stat(self.parser.join(self.base, 'new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o664)
+        os.umask(0o026)
+        with (p / 'other_new_file').open('wb'):
+            pass
+        st = os.stat(self.parser.join(self.base, 'other_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o640)
+
+    @needs_posix
+    def test_resolve_root(self):
+        current_directory = os.getcwd()
+        try:
+            os.chdir('/')
+            p = self.cls('spam')
+            self.assertEqual(str(p.resolve()), '/spam')
+        finally:
+            os.chdir(current_directory)
+
+    @unittest.skipIf(
+        is_emscripten or is_wasi,
+        "umask is not implemented on Emscripten/WASI."
+    )
+    @needs_posix
+    def test_touch_mode(self):
+        # Unmask all permissions except world-write, which may
+        # not be supported on some filesystems (see GH-85633.)
+        old_mask = os.umask(0o002)
+        self.addCleanup(os.umask, old_mask)
+        p = self.cls(self.base)
+        (p / 'new_file').touch()
+        st = os.stat(self.parser.join(self.base, 'new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o664)
+        os.umask(0o026)
+        (p / 'other_new_file').touch()
+        st = os.stat(self.parser.join(self.base, 'other_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o640)
+        (p / 'masked_new_file').touch(mode=0o750)
+        st = os.stat(self.parser.join(self.base, 'masked_new_file'))
+        self.assertEqual(stat.S_IMODE(st.st_mode), 0o750)
+
+    @unittest.skipUnless(hasattr(pwd, 'getpwall'),
+                         'pwd module does not expose getpwall()')
+    @unittest.skipIf(sys.platform == "vxworks",
+                     "no home directory on VxWorks")
+    @needs_posix
+    def test_expanduser_posix(self):
+        P = self.cls
+        import_helper.import_module('pwd')
+        import pwd
+        pwdent = pwd.getpwuid(os.getuid())
+        username = pwdent.pw_name
+        userhome = pwdent.pw_dir.rstrip('/') or '/'
+        # Find arbitrary different user (if exists).
+        for pwdent in pwd.getpwall():
+            othername = pwdent.pw_name
+            otherhome = pwdent.pw_dir.rstrip('/')
+            if othername != username and otherhome:
+                break
+        else:
+            othername = username
+            otherhome = userhome
+
+        fakename = 'fakeuser'
+        # This user can theoretically exist on a test runner. Create unique name:
+        try:
+            while pwd.getpwnam(fakename):
+                fakename += '1'
+        except KeyError:
+            pass  # Non-existent name found
+
+        p1 = P('~/Documents')
+        p2 = P(f'~{username}/Documents')
+        p3 = P(f'~{othername}/Documents')
+        p4 = P(f'../~{username}/Documents')
+        p5 = P(f'/~{username}/Documents')
+        p6 = P('')
+        p7 = P(f'~{fakename}/Documents')
+
+        with os_helper.EnvironmentVarGuard() as env:
+            env.unset('HOME')
+
+            self.assertEqual(p1.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+            self.assertRaises(RuntimeError, p7.expanduser)
+
+            env['HOME'] = '/tmp'
+            self.assertEqual(p1.expanduser(), P('/tmp/Documents'))
+            self.assertEqual(p2.expanduser(), P(userhome) / 'Documents')
+            self.assertEqual(p3.expanduser(), P(otherhome) / 'Documents')
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+            self.assertRaises(RuntimeError, p7.expanduser)
+
+    @unittest.skipIf(sys.platform != "darwin",
+                     "Bad file descriptor in /dev/fd affects only macOS")
+    @needs_posix
+    def test_handling_bad_descriptor(self):
+        try:
+            file_descriptors = list(pathlib.Path('/dev/fd').rglob("*"))[3:]
+            if not file_descriptors:
+                self.skipTest("no file descriptors - issue was not reproduced")
+            # Checking all file descriptors because there is no guarantee
+            # which one will fail.
+            for f in file_descriptors:
+                f.exists()
+                f.is_dir()
+                f.is_file()
+                f.is_symlink()
+                f.is_block_device()
+                f.is_char_device()
+                f.is_fifo()
+                f.is_socket()
+        except OSError as e:
+            if e.errno == errno.EBADF:
+                self.fail("Bad file descriptor not handled.")
+            raise
+
+    @needs_posix
+    def test_from_uri_posix(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:/foo/bar'), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file://foo/bar'), P('//foo/bar'))
+        self.assertEqual(P.from_uri('file:///foo/bar'), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file:////foo/bar'), P('//foo/bar'))
+        self.assertEqual(P.from_uri('file://localhost/foo/bar'), P('/foo/bar'))
+        self.assertRaises(ValueError, P.from_uri, 'foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '/foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '//foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'file:foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'http://foo/bar')
+
+    @needs_posix
+    def test_from_uri_pathname2url_posix(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:' + pathname2url('/foo/bar')), P('/foo/bar'))
+        self.assertEqual(P.from_uri('file:' + pathname2url('//foo/bar')), P('//foo/bar'))
+
+    @needs_windows
+    def test_absolute_windows(self):
+        P = self.cls
+
+        # Simple absolute paths.
+        self.assertEqual(str(P('c:\\').absolute()), 'c:\\')
+        self.assertEqual(str(P('c:\\a').absolute()), 'c:\\a')
+        self.assertEqual(str(P('c:\\a\\b').absolute()), 'c:\\a\\b')
+
+        # UNC absolute paths.
+        share = '\\\\server\\share\\'
+        self.assertEqual(str(P(share).absolute()), share)
+        self.assertEqual(str(P(share + 'a').absolute()), share + 'a')
+        self.assertEqual(str(P(share + 'a\\b').absolute()), share + 'a\\b')
+
+        # UNC relative paths.
+        with mock.patch("os.getcwd") as getcwd:
+            getcwd.return_value = share
+
+            self.assertEqual(str(P().absolute()), share)
+            self.assertEqual(str(P('.').absolute()), share)
+            self.assertEqual(str(P('a').absolute()), os.path.join(share, 'a'))
+            self.assertEqual(str(P('a', 'b', 'c').absolute()),
+                             os.path.join(share, 'a', 'b', 'c'))
+
+        drive = os.path.splitdrive(self.base)[0]
+        with os_helper.change_cwd(self.base):
+            # Relative path with root
+            self.assertEqual(str(P('\\').absolute()), drive + '\\')
+            self.assertEqual(str(P('\\foo').absolute()), drive + '\\foo')
+
+            # Relative path on current drive
+            self.assertEqual(str(P(drive).absolute()), self.base)
+            self.assertEqual(str(P(drive + 'foo').absolute()), os.path.join(self.base, 'foo'))
+
+        with os_helper.subst_drive(self.base) as other_drive:
+            # Set the working directory on the substitute drive
+            saved_cwd = os.getcwd()
+            other_cwd = f'{other_drive}\\dirA'
+            os.chdir(other_cwd)
+            os.chdir(saved_cwd)
+
+            # Relative path on another drive
+            self.assertEqual(str(P(other_drive).absolute()), other_cwd)
+            self.assertEqual(str(P(other_drive + 'foo').absolute()), other_cwd + '\\foo')
+
+    @needs_windows
+    def test_expanduser_windows(self):
+        P = self.cls
+        with os_helper.EnvironmentVarGuard() as env:
+            env.unset('HOME', 'USERPROFILE', 'HOMEPATH', 'HOMEDRIVE')
+            env['USERNAME'] = 'alice'
+
+            # test that the path returns unchanged
+            p1 = P('~/My Documents')
+            p2 = P('~alice/My Documents')
+            p3 = P('~bob/My Documents')
+            p4 = P('/~/My Documents')
+            p5 = P('d:~/My Documents')
+            p6 = P('')
+            self.assertRaises(RuntimeError, p1.expanduser)
+            self.assertRaises(RuntimeError, p2.expanduser)
+            self.assertRaises(RuntimeError, p3.expanduser)
+            self.assertEqual(p4.expanduser(), p4)
+            self.assertEqual(p5.expanduser(), p5)
+            self.assertEqual(p6.expanduser(), p6)
+
+            def check():
+                env.pop('USERNAME', None)
+                self.assertEqual(p1.expanduser(),
+                                 P('C:/Users/alice/My Documents'))
+                self.assertRaises(RuntimeError, p2.expanduser)
+                env['USERNAME'] = 'alice'
+                self.assertEqual(p2.expanduser(),
+                                 P('C:/Users/alice/My Documents'))
+                self.assertEqual(p3.expanduser(),
+                                 P('C:/Users/bob/My Documents'))
+                self.assertEqual(p4.expanduser(), p4)
+                self.assertEqual(p5.expanduser(), p5)
+                self.assertEqual(p6.expanduser(), p6)
+
+            env['HOMEPATH'] = 'C:\\Users\\alice'
+            check()
+
+            env['HOMEDRIVE'] = 'C:\\'
+            env['HOMEPATH'] = 'Users\\alice'
+            check()
+
+            env.unset('HOMEDRIVE', 'HOMEPATH')
+            env['USERPROFILE'] = 'C:\\Users\\alice'
+            check()
+
+            # bpo-38883: ignore `HOME` when set on windows
+            env['HOME'] = 'C:\\Users\\eve'
+            check()
+
+    @needs_windows
+    def test_from_uri_windows(self):
+        P = self.cls
+        # DOS drive paths
+        self.assertEqual(P.from_uri('file:c:/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:c|/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:/c|/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:///c|/path/to/file'), P('c:/path/to/file'))
+        # UNC paths
+        self.assertEqual(P.from_uri('file://server/path/to/file'), P('//server/path/to/file'))
+        self.assertEqual(P.from_uri('file:////server/path/to/file'), P('//server/path/to/file'))
+        self.assertEqual(P.from_uri('file://///server/path/to/file'), P('//server/path/to/file'))
+        # Localhost paths
+        self.assertEqual(P.from_uri('file://localhost/c:/path/to/file'), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file://localhost/c|/path/to/file'), P('c:/path/to/file'))
+        # Invalid paths
+        self.assertRaises(ValueError, P.from_uri, 'foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'c:/foo/bar')
+        self.assertRaises(ValueError, P.from_uri, '//foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'file:foo/bar')
+        self.assertRaises(ValueError, P.from_uri, 'http://foo/bar')
+
+    @needs_windows
+    def test_from_uri_pathname2url_windows(self):
+        P = self.cls
+        self.assertEqual(P.from_uri('file:' + pathname2url(r'c:\path\to\file')), P('c:/path/to/file'))
+        self.assertEqual(P.from_uri('file:' + pathname2url(r'\\server\path\to\file')), P('//server/path/to/file'))
+
+    @needs_windows
+    def test_owner_windows(self):
+        P = self.cls
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            P('c:/').owner()
+
+    @needs_windows
+    def test_group_windows(self):
+        P = self.cls
+        with self.assertRaises(pathlib.UnsupportedOperation):
+            P('c:/').group()
+
+
+@unittest.skipIf(os.name == 'nt', 'test requires a POSIX-compatible system')
+class PosixPathTest(PathTest, PurePosixPathTest):
+    cls = pathlib.PosixPath
+
+
+@unittest.skipIf(os.name != 'nt', 'test requires a Windows-compatible system')
+class WindowsPathTest(PathTest, PureWindowsPathTest):
+    cls = pathlib.WindowsPath
+
+
+class PathSubclassTest(PathTest):
+    class cls(pathlib.Path):
+        pass
+
+    # repr() roundtripping is not supported in custom subclass.
+    test_repr_roundtrips = None
+
+
+class CompatiblePathTest(unittest.TestCase):
+    """
+    Test that a type can be made compatible with PurePath
+    derivatives by implementing division operator overloads.
+    """
+
+    class CompatPath:
+        """
+        Minimum viable class to test PurePath compatibility.
+        Simply uses the division operator to join a given
+        string and the string value of another object with
+        a forward slash.
+        """
+        def __init__(self, string):
+            self.string = string
+
+        def __truediv__(self, other):
+            return type(self)(f"{self.string}/{other}")
+
+        def __rtruediv__(self, other):
+            return type(self)(f"{other}/{self.string}")
+
+    def test_truediv(self):
+        result = pathlib.PurePath("test") / self.CompatPath("right")
+        self.assertIsInstance(result, self.CompatPath)
+        self.assertEqual(result.string, "test/right")
+
+        with self.assertRaises(TypeError):
+            # Verify improper operations still raise a TypeError
+            pathlib.PurePath("test") / 10
+
+    def test_rtruediv(self):
+        result = self.CompatPath("left") / pathlib.PurePath("test")
+        self.assertIsInstance(result, self.CompatPath)
+        self.assertEqual(result.string, "left/test")
+
+        with self.assertRaises(TypeError):
+            # Verify improper operations still raise a TypeError
+            10 / pathlib.PurePath("test")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pathlib/test_pathlib_abc.py b/Lib/test/test_pathlib/test_pathlib_abc.py
new file mode 100644
index 0000000000..2e05036215
--- /dev/null
+++ b/Lib/test/test_pathlib/test_pathlib_abc.py
@@ -0,0 +1,2499 @@
+# TODO: RUSTPYTHON
+# Has not been tested with Windows style paths
+import collections
+import io
+import os
+import errno
+import stat
+import unittest
+
+from pathlib._abc import UnsupportedOperation, ParserBase, PurePathBase, PathBase
+import posixpath
+
+from test.support import is_wasi
+from test.support.os_helper import TESTFN
+
+
+_tests_needing_posix = set()
+_tests_needing_windows = set()
+_tests_needing_symlinks = set()
+
+
+def needs_posix(fn):
+    """Decorator that marks a test as requiring a POSIX-flavoured path class."""
+    _tests_needing_posix.add(fn.__name__)
+    return fn
+
+def needs_windows(fn):
+    """Decorator that marks a test as requiring a Windows-flavoured path class."""
+    _tests_needing_windows.add(fn.__name__)
+    return fn
+
+def needs_symlinks(fn):
+    """Decorator that marks a test as requiring a path class that supports symlinks."""
+    _tests_needing_symlinks.add(fn.__name__)
+    return fn
+
+
+class UnsupportedOperationTest(unittest.TestCase):
+    def test_is_notimplemented(self):
+        self.assertTrue(issubclass(UnsupportedOperation, NotImplementedError))
+        self.assertTrue(isinstance(UnsupportedOperation(), NotImplementedError))
+
+
+class ParserBaseTest(unittest.TestCase):
+    cls = ParserBase
+
+    def test_unsupported_operation(self):
+        m = self.cls()
+        e = UnsupportedOperation
+        with self.assertRaises(e):
+            m.sep
+        self.assertRaises(e, m.join, 'foo')
+        self.assertRaises(e, m.split, 'foo')
+        self.assertRaises(e, m.splitdrive, 'foo')
+        self.assertRaises(e, m.normcase, 'foo')
+        self.assertRaises(e, m.isabs, 'foo')
+
+#
+# Tests for the pure classes.
+#
+
+
+class PurePathBaseTest(unittest.TestCase):
+    cls = PurePathBase
+
+    def test_unsupported_operation_pure(self):
+        p = self.cls('foo')
+        e = UnsupportedOperation
+        with self.assertRaises(e):
+            p.drive
+        with self.assertRaises(e):
+            p.root
+        with self.assertRaises(e):
+            p.anchor
+        with self.assertRaises(e):
+            p.parts
+        with self.assertRaises(e):
+            p.parent
+        with self.assertRaises(e):
+            p.parents
+        with self.assertRaises(e):
+            p.name
+        with self.assertRaises(e):
+            p.stem
+        with self.assertRaises(e):
+            p.suffix
+        with self.assertRaises(e):
+            p.suffixes
+        with self.assertRaises(e):
+            p / 'bar'
+        with self.assertRaises(e):
+            'bar' / p
+        self.assertRaises(e, p.joinpath, 'bar')
+        self.assertRaises(e, p.with_name, 'bar')
+        self.assertRaises(e, p.with_stem, 'bar')
+        self.assertRaises(e, p.with_suffix, '.txt')
+        self.assertRaises(e, p.relative_to, '')
+        self.assertRaises(e, p.is_relative_to, '')
+        self.assertRaises(e, p.is_absolute)
+        self.assertRaises(e, p.match, '*')
+
+    def test_magic_methods(self):
+        P = self.cls
+        self.assertFalse(hasattr(P, '__fspath__'))
+        self.assertFalse(hasattr(P, '__bytes__'))
+        self.assertIs(P.__reduce__, object.__reduce__)
+        self.assertIs(P.__repr__, object.__repr__)
+        self.assertIs(P.__hash__, object.__hash__)
+        self.assertIs(P.__eq__, object.__eq__)
+        self.assertIs(P.__lt__, object.__lt__)
+        self.assertIs(P.__le__, object.__le__)
+        self.assertIs(P.__gt__, object.__gt__)
+        self.assertIs(P.__ge__, object.__ge__)
+
+    def test_parser(self):
+        self.assertIsInstance(self.cls.parser, ParserBase)
+
+
+class DummyPurePath(PurePathBase):
+    __slots__ = ()
+    parser = posixpath
+
+    def __eq__(self, other):
+        if not isinstance(other, DummyPurePath):
+            return NotImplemented
+        return str(self) == str(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+
+class DummyPurePathTest(unittest.TestCase):
+    cls = DummyPurePath
+
+    # Use a base path that's unrelated to any real filesystem path.
+    base = f'/this/path/kills/fascists/{TESTFN}'
+
+    def setUp(self):
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_posix and self.cls.parser is not posixpath:
+            self.skipTest('requires POSIX-flavoured path class')
+        if name in _tests_needing_windows and self.cls.parser is posixpath:
+            self.skipTest('requires Windows-flavoured path class')
+        p = self.cls('a')
+        self.parser = p.parser
+        self.sep = self.parser.sep
+        self.altsep = self.parser.altsep
+
+    def test_constructor_common(self):
+        P = self.cls
+        p = P('a')
+        self.assertIsInstance(p, P)
+        P('a', 'b', 'c')
+        P('/a', 'b', 'c')
+        P('a/b/c')
+        P('/a/b/c')
+
+    def test_bytes(self):
+        P = self.cls
+        with self.assertRaises(TypeError):
+            P(b'a')
+        with self.assertRaises(TypeError):
+            P(b'a', 'b')
+        with self.assertRaises(TypeError):
+            P('a', b'b')
+        with self.assertRaises(TypeError):
+            P('a').joinpath(b'b')
+        with self.assertRaises(TypeError):
+            P('a') / b'b'
+        with self.assertRaises(TypeError):
+            b'a' / P('b')
+        with self.assertRaises(TypeError):
+            P('a').match(b'b')
+        with self.assertRaises(TypeError):
+            P('a').relative_to(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_name(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_stem(b'b')
+        with self.assertRaises(TypeError):
+            P('a').with_suffix(b'b')
+
+    def _check_str_subclass(self, *args):
+        # Issue #21127: it should be possible to construct a PurePath object
+        # from a str subclass instance, and it then gets converted to
+        # a pure str object.
+        class StrSubclass(str):
+            pass
+        P = self.cls
+        p = P(*(StrSubclass(x) for x in args))
+        self.assertEqual(p, P(*args))
+        for part in p.parts:
+            self.assertIs(type(part), str)
+
+    def test_str_subclass_common(self):
+        self._check_str_subclass('')
+        self._check_str_subclass('.')
+        self._check_str_subclass('a')
+        self._check_str_subclass('a/b.txt')
+        self._check_str_subclass('/a/b.txt')
+
+    @needs_windows
+    def test_str_subclass_windows(self):
+        self._check_str_subclass('.\\a:b')
+        self._check_str_subclass('c:')
+        self._check_str_subclass('c:a')
+        self._check_str_subclass('c:a\\b.txt')
+        self._check_str_subclass('c:\\')
+        self._check_str_subclass('c:\\a')
+        self._check_str_subclass('c:\\a\\b.txt')
+        self._check_str_subclass('\\\\some\\share')
+        self._check_str_subclass('\\\\some\\share\\a')
+        self._check_str_subclass('\\\\some\\share\\a\\b.txt')
+
+    def test_with_segments_common(self):
+        class P(self.cls):
+            def __init__(self, *pathsegments, session_id):
+                super().__init__(*pathsegments)
+                self.session_id = session_id
+
+            def with_segments(self, *pathsegments):
+                return type(self)(*pathsegments, session_id=self.session_id)
+        p = P('foo', 'bar', session_id=42)
+        self.assertEqual(42, (p / 'foo').session_id)
+        self.assertEqual(42, ('foo' / p).session_id)
+        self.assertEqual(42, p.joinpath('foo').session_id)
+        self.assertEqual(42, p.with_name('foo').session_id)
+        self.assertEqual(42, p.with_stem('foo').session_id)
+        self.assertEqual(42, p.with_suffix('.foo').session_id)
+        self.assertEqual(42, p.with_segments('foo').session_id)
+        self.assertEqual(42, p.relative_to('foo').session_id)
+        self.assertEqual(42, p.parent.session_id)
+        for parent in p.parents:
+            self.assertEqual(42, parent.session_id)
+
+    def test_join_common(self):
+        P = self.cls
+        p = P('a/b')
+        pp = p.joinpath('c')
+        self.assertEqual(pp, P('a/b/c'))
+        self.assertIs(type(pp), type(p))
+        pp = p.joinpath('c', 'd')
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = p.joinpath('/c')
+        self.assertEqual(pp, P('/c'))
+
+    @needs_posix
+    def test_join_posix(self):
+        P = self.cls
+        p = P('//a')
+        pp = p.joinpath('b')
+        self.assertEqual(pp, P('//a/b'))
+        pp = P('/a').joinpath('//c')
+        self.assertEqual(pp, P('//c'))
+        pp = P('//a').joinpath('/c')
+        self.assertEqual(pp, P('/c'))
+
+    @needs_windows
+    def test_join_windows(self):
+        P = self.cls
+        p = P('C:/a/b')
+        pp = p.joinpath('x/y')
+        self.assertEqual(pp, P('C:/a/b/x/y'))
+        pp = p.joinpath('/x/y')
+        self.assertEqual(pp, P('C:/x/y'))
+        # Joining with a different drive => the first path is ignored, even
+        # if the second path is relative.
+        pp = p.joinpath('D:x/y')
+        self.assertEqual(pp, P('D:x/y'))
+        pp = p.joinpath('D:/x/y')
+        self.assertEqual(pp, P('D:/x/y'))
+        pp = p.joinpath('//host/share/x/y')
+        self.assertEqual(pp, P('//host/share/x/y'))
+        # Joining with the same drive => the first path is appended to if
+        # the second path is relative.
+        pp = p.joinpath('c:x/y')
+        self.assertEqual(pp, P('C:/a/b/x/y'))
+        pp = p.joinpath('c:/x/y')
+        self.assertEqual(pp, P('C:/x/y'))
+        # Joining with files with NTFS data streams => the filename should
+        # not be parsed as a drive letter
+        pp = p.joinpath(P('./d:s'))
+        self.assertEqual(pp, P('C:/a/b/d:s'))
+        pp = p.joinpath(P('./dd:s'))
+        self.assertEqual(pp, P('C:/a/b/dd:s'))
+        pp = p.joinpath(P('E:d:s'))
+        self.assertEqual(pp, P('E:d:s'))
+        # Joining onto a UNC path with no root
+        pp = P('//').joinpath('server')
+        self.assertEqual(pp, P('//server'))
+        pp = P('//server').joinpath('share')
+        self.assertEqual(pp, P('//server/share'))
+        pp = P('//./BootPartition').joinpath('Windows')
+        self.assertEqual(pp, P('//./BootPartition/Windows'))
+
+    def test_div_common(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('a/b')
+        pp = p / 'c'
+        self.assertEqual(pp, P('a/b/c'))
+        self.assertIs(type(pp), type(p))
+        pp = p / 'c/d'
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = p / 'c' / 'd'
+        self.assertEqual(pp, P('a/b/c/d'))
+        pp = 'c' / p / 'd'
+        self.assertEqual(pp, P('c/a/b/d'))
+        pp = p/ '/c'
+        self.assertEqual(pp, P('/c'))
+
+    @needs_posix
+    def test_div_posix(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('//a')
+        pp = p / 'b'
+        self.assertEqual(pp, P('//a/b'))
+        pp = P('/a') / '//c'
+        self.assertEqual(pp, P('//c'))
+        pp = P('//a') / '/c'
+        self.assertEqual(pp, P('/c'))
+
+    @needs_windows
+    def test_div_windows(self):
+        # Basically the same as joinpath().
+        P = self.cls
+        p = P('C:/a/b')
+        self.assertEqual(p / 'x/y', P('C:/a/b/x/y'))
+        self.assertEqual(p / 'x' / 'y', P('C:/a/b/x/y'))
+        self.assertEqual(p / '/x/y', P('C:/x/y'))
+        self.assertEqual(p / '/x' / 'y', P('C:/x/y'))
+        # Joining with a different drive => the first path is ignored, even
+        # if the second path is relative.
+        self.assertEqual(p / 'D:x/y', P('D:x/y'))
+        self.assertEqual(p / 'D:' / 'x/y', P('D:x/y'))
+        self.assertEqual(p / 'D:/x/y', P('D:/x/y'))
+        self.assertEqual(p / 'D:' / '/x/y', P('D:/x/y'))
+        self.assertEqual(p / '//host/share/x/y', P('//host/share/x/y'))
+        # Joining with the same drive => the first path is appended to if
+        # the second path is relative.
+        self.assertEqual(p / 'c:x/y', P('C:/a/b/x/y'))
+        self.assertEqual(p / 'c:/x/y', P('C:/x/y'))
+        # Joining with files with NTFS data streams => the filename should
+        # not be parsed as a drive letter
+        self.assertEqual(p / P('./d:s'), P('C:/a/b/d:s'))
+        self.assertEqual(p / P('./dd:s'), P('C:/a/b/dd:s'))
+        self.assertEqual(p / P('E:d:s'), P('E:d:s'))
+
+    def _check_str(self, expected, args):
+        p = self.cls(*args)
+        self.assertEqual(str(p), expected.replace('/', self.sep))
+
+    def test_str_common(self):
+        # Canonicalized paths roundtrip.
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            self._check_str(pathstr, (pathstr,))
+        # Other tests for str() are in test_equivalences().
+
+    @needs_windows
+    def test_str_windows(self):
+        p = self.cls('a/b/c')
+        self.assertEqual(str(p), 'a\\b\\c')
+        p = self.cls('c:/a/b/c')
+        self.assertEqual(str(p), 'c:\\a\\b\\c')
+        p = self.cls('//a/b')
+        self.assertEqual(str(p), '\\\\a\\b\\')
+        p = self.cls('//a/b/c')
+        self.assertEqual(str(p), '\\\\a\\b\\c')
+        p = self.cls('//a/b/c/d')
+        self.assertEqual(str(p), '\\\\a\\b\\c\\d')
+
+    def test_as_posix_common(self):
+        P = self.cls
+        for pathstr in ('a', 'a/b', 'a/b/c', '/', '/a/b', '/a/b/c'):
+            self.assertEqual(P(pathstr).as_posix(), pathstr)
+        # Other tests for as_posix() are in test_equivalences().
+
+    def test_match_empty(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a').match, '')
+
+    def test_match_common(self):
+        P = self.cls
+        # Simple relative pattern.
+        self.assertTrue(P('b.py').match('b.py'))
+        self.assertTrue(P('a/b.py').match('b.py'))
+        self.assertTrue(P('/a/b.py').match('b.py'))
+        self.assertFalse(P('a.py').match('b.py'))
+        self.assertFalse(P('b/py').match('b.py'))
+        self.assertFalse(P('/a.py').match('b.py'))
+        self.assertFalse(P('b.py/c').match('b.py'))
+        # Wildcard relative pattern.
+        self.assertTrue(P('b.py').match('*.py'))
+        self.assertTrue(P('a/b.py').match('*.py'))
+        self.assertTrue(P('/a/b.py').match('*.py'))
+        self.assertFalse(P('b.pyc').match('*.py'))
+        self.assertFalse(P('b./py').match('*.py'))
+        self.assertFalse(P('b.py/c').match('*.py'))
+        # Multi-part relative pattern.
+        self.assertTrue(P('ab/c.py').match('a*/*.py'))
+        self.assertTrue(P('/d/ab/c.py').match('a*/*.py'))
+        self.assertFalse(P('a.py').match('a*/*.py'))
+        self.assertFalse(P('/dab/c.py').match('a*/*.py'))
+        self.assertFalse(P('ab/c.py/d').match('a*/*.py'))
+        # Absolute pattern.
+        self.assertTrue(P('/b.py').match('/*.py'))
+        self.assertFalse(P('b.py').match('/*.py'))
+        self.assertFalse(P('a/b.py').match('/*.py'))
+        self.assertFalse(P('/a/b.py').match('/*.py'))
+        # Multi-part absolute pattern.
+        self.assertTrue(P('/a/b.py').match('/a/*.py'))
+        self.assertFalse(P('/ab.py').match('/a/*.py'))
+        self.assertFalse(P('/a/b/c.py').match('/a/*.py'))
+        # Multi-part glob-style pattern.
+        self.assertFalse(P('/a/b/c.py').match('/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').match('/a/**/*.py'))
+        # Case-sensitive flag
+        self.assertFalse(P('A.py').match('a.PY', case_sensitive=True))
+        self.assertTrue(P('A.py').match('a.PY', case_sensitive=False))
+        self.assertFalse(P('c:/a/B.Py').match('C:/A/*.pY', case_sensitive=True))
+        self.assertTrue(P('/a/b/c.py').match('/A/*/*.Py', case_sensitive=False))
+        # Matching against empty path
+        self.assertFalse(P('').match('*'))
+        self.assertFalse(P('').match('**'))
+        self.assertFalse(P('').match('**/*'))
+
+    @needs_posix
+    def test_match_posix(self):
+        P = self.cls
+        self.assertFalse(P('A.py').match('a.PY'))
+
+    @needs_windows
+    def test_match_windows(self):
+        P = self.cls
+        # Absolute patterns.
+        self.assertTrue(P('c:/b.py').match('*:/*.py'))
+        self.assertTrue(P('c:/b.py').match('c:/*.py'))
+        self.assertFalse(P('d:/b.py').match('c:/*.py'))  # wrong drive
+        self.assertFalse(P('b.py').match('/*.py'))
+        self.assertFalse(P('b.py').match('c:*.py'))
+        self.assertFalse(P('b.py').match('c:/*.py'))
+        self.assertFalse(P('c:b.py').match('/*.py'))
+        self.assertFalse(P('c:b.py').match('c:/*.py'))
+        self.assertFalse(P('/b.py').match('c:*.py'))
+        self.assertFalse(P('/b.py').match('c:/*.py'))
+        # UNC patterns.
+        self.assertTrue(P('//some/share/a.py').match('//*/*/*.py'))
+        self.assertTrue(P('//some/share/a.py').match('//some/share/*.py'))
+        self.assertFalse(P('//other/share/a.py').match('//some/share/*.py'))
+        self.assertFalse(P('//some/share/a/b.py').match('//some/share/*.py'))
+        # Case-insensitivity.
+        self.assertTrue(P('B.py').match('b.PY'))
+        self.assertTrue(P('c:/a/B.Py').match('C:/A/*.pY'))
+        self.assertTrue(P('//Some/Share/B.Py').match('//somE/sharE/*.pY'))
+        # Path anchor doesn't match pattern anchor
+        self.assertFalse(P('c:/b.py').match('/*.py'))  # 'c:/' vs '/'
+        self.assertFalse(P('c:/b.py').match('c:*.py'))  # 'c:/' vs 'c:'
+        self.assertFalse(P('//some/share/a.py').match('/*.py'))  # '//some/share/' vs '/'
+
+    def test_full_match_common(self):
+        P = self.cls
+        # Simple relative pattern.
+        self.assertTrue(P('b.py').full_match('b.py'))
+        self.assertFalse(P('a/b.py').full_match('b.py'))
+        self.assertFalse(P('/a/b.py').full_match('b.py'))
+        self.assertFalse(P('a.py').full_match('b.py'))
+        self.assertFalse(P('b/py').full_match('b.py'))
+        self.assertFalse(P('/a.py').full_match('b.py'))
+        self.assertFalse(P('b.py/c').full_match('b.py'))
+        # Wildcard relative pattern.
+        self.assertTrue(P('b.py').full_match('*.py'))
+        self.assertFalse(P('a/b.py').full_match('*.py'))
+        self.assertFalse(P('/a/b.py').full_match('*.py'))
+        self.assertFalse(P('b.pyc').full_match('*.py'))
+        self.assertFalse(P('b./py').full_match('*.py'))
+        self.assertFalse(P('b.py/c').full_match('*.py'))
+        # Multi-part relative pattern.
+        self.assertTrue(P('ab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('/d/ab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('a.py').full_match('a*/*.py'))
+        self.assertFalse(P('/dab/c.py').full_match('a*/*.py'))
+        self.assertFalse(P('ab/c.py/d').full_match('a*/*.py'))
+        # Absolute pattern.
+        self.assertTrue(P('/b.py').full_match('/*.py'))
+        self.assertFalse(P('b.py').full_match('/*.py'))
+        self.assertFalse(P('a/b.py').full_match('/*.py'))
+        self.assertFalse(P('/a/b.py').full_match('/*.py'))
+        # Multi-part absolute pattern.
+        self.assertTrue(P('/a/b.py').full_match('/a/*.py'))
+        self.assertFalse(P('/ab.py').full_match('/a/*.py'))
+        self.assertFalse(P('/a/b/c.py').full_match('/a/*.py'))
+        # Multi-part glob-style pattern.
+        self.assertTrue(P('a').full_match('**'))
+        self.assertTrue(P('c.py').full_match('**'))
+        self.assertTrue(P('a/b/c.py').full_match('**'))
+        self.assertTrue(P('/a/b/c.py').full_match('**'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/**'))
+        self.assertTrue(P('/a/b/c.py').full_match('**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/a/b/**/*.py'))
+        self.assertTrue(P('/a/b/c.py').full_match('/**/**/**/**/*.py'))
+        self.assertFalse(P('c.py').full_match('**/a.py'))
+        self.assertFalse(P('c.py').full_match('c/**'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c.'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
+        self.assertFalse(P('a/b/c.py').full_match('**/a/b/c./**'))
+        self.assertFalse(P('a/b/c.py').full_match('/a/b/c.py/**'))
+        self.assertFalse(P('a/b/c.py').full_match('/**/a/b/c.py'))
+        # Case-sensitive flag
+        self.assertFalse(P('A.py').full_match('a.PY', case_sensitive=True))
+        self.assertTrue(P('A.py').full_match('a.PY', case_sensitive=False))
+        self.assertFalse(P('c:/a/B.Py').full_match('C:/A/*.pY', case_sensitive=True))
+        self.assertTrue(P('/a/b/c.py').full_match('/A/*/*.Py', case_sensitive=False))
+        # Matching against empty path
+        self.assertFalse(P('').full_match('*'))
+        self.assertTrue(P('').full_match('**'))
+        self.assertFalse(P('').full_match('**/*'))
+        # Matching with empty pattern
+        self.assertTrue(P('').full_match(''))
+        self.assertTrue(P('.').full_match('.'))
+        self.assertFalse(P('/').full_match(''))
+        self.assertFalse(P('/').full_match('.'))
+        self.assertFalse(P('foo').full_match(''))
+        self.assertFalse(P('foo').full_match('.'))
+
+    def test_parts_common(self):
+        # `parts` returns a tuple.
+        sep = self.sep
+        P = self.cls
+        p = P('a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('a', 'b'))
+        # When the path is absolute, the anchor is a separate part.
+        p = P('/a/b')
+        parts = p.parts
+        self.assertEqual(parts, (sep, 'a', 'b'))
+
+    @needs_windows
+    def test_parts_windows(self):
+        P = self.cls
+        p = P('c:a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:', 'a', 'b'))
+        p = P('c:/a/b')
+        parts = p.parts
+        self.assertEqual(parts, ('c:\\', 'a', 'b'))
+        p = P('//a/b/c/d')
+        parts = p.parts
+        self.assertEqual(parts, ('\\\\a\\b\\', 'c', 'd'))
+
+    def test_parent_common(self):
+        # Relative
+        P = self.cls
+        p = P('a/b/c')
+        self.assertEqual(p.parent, P('a/b'))
+        self.assertEqual(p.parent.parent, P('a'))
+        self.assertEqual(p.parent.parent.parent, P(''))
+        self.assertEqual(p.parent.parent.parent.parent, P(''))
+        # Anchored
+        p = P('/a/b/c')
+        self.assertEqual(p.parent, P('/a/b'))
+        self.assertEqual(p.parent.parent, P('/a'))
+        self.assertEqual(p.parent.parent.parent, P('/'))
+        self.assertEqual(p.parent.parent.parent.parent, P('/'))
+
+    @needs_windows
+    def test_parent_windows(self):
+        # Anchored
+        P = self.cls
+        p = P('z:a/b/c')
+        self.assertEqual(p.parent, P('z:a/b'))
+        self.assertEqual(p.parent.parent, P('z:a'))
+        self.assertEqual(p.parent.parent.parent, P('z:'))
+        self.assertEqual(p.parent.parent.parent.parent, P('z:'))
+        p = P('z:/a/b/c')
+        self.assertEqual(p.parent, P('z:/a/b'))
+        self.assertEqual(p.parent.parent, P('z:/a'))
+        self.assertEqual(p.parent.parent.parent, P('z:/'))
+        self.assertEqual(p.parent.parent.parent.parent, P('z:/'))
+        p = P('//a/b/c/d')
+        self.assertEqual(p.parent, P('//a/b/c'))
+        self.assertEqual(p.parent.parent, P('//a/b'))
+        self.assertEqual(p.parent.parent.parent, P('//a/b'))
+
+    def test_parents_common(self):
+        # Relative
+        P = self.cls
+        p = P('a/b/c')
+        par = p.parents
+        self.assertEqual(len(par), 3)
+        self.assertEqual(par[0], P('a/b'))
+        self.assertEqual(par[1], P('a'))
+        self.assertEqual(par[2], P(''))
+        self.assertEqual(par[-1], P(''))
+        self.assertEqual(par[-2], P('a'))
+        self.assertEqual(par[-3], P('a/b'))
+        self.assertEqual(par[0:1], (P('a/b'),))
+        self.assertEqual(par[:2], (P('a/b'), P('a')))
+        self.assertEqual(par[:-1], (P('a/b'), P('a')))
+        self.assertEqual(par[1:], (P('a'), P('')))
+        self.assertEqual(par[::2], (P('a/b'), P('')))
+        self.assertEqual(par[::-1], (P(''), P('a'), P('a/b')))
+        self.assertEqual(list(par), [P('a/b'), P('a'), P('')])
+        with self.assertRaises(IndexError):
+            par[-4]
+        with self.assertRaises(IndexError):
+            par[3]
+        with self.assertRaises(TypeError):
+            par[0] = p
+        # Anchored
+        p = P('/a/b/c')
+        par = p.parents
+        self.assertEqual(len(par), 3)
+        self.assertEqual(par[0], P('/a/b'))
+        self.assertEqual(par[1], P('/a'))
+        self.assertEqual(par[2], P('/'))
+        self.assertEqual(par[-1], P('/'))
+        self.assertEqual(par[-2], P('/a'))
+        self.assertEqual(par[-3], P('/a/b'))
+        self.assertEqual(par[0:1], (P('/a/b'),))
+        self.assertEqual(par[:2], (P('/a/b'), P('/a')))
+        self.assertEqual(par[:-1], (P('/a/b'), P('/a')))
+        self.assertEqual(par[1:], (P('/a'), P('/')))
+        self.assertEqual(par[::2], (P('/a/b'), P('/')))
+        self.assertEqual(par[::-1], (P('/'), P('/a'), P('/a/b')))
+        self.assertEqual(list(par), [P('/a/b'), P('/a'), P('/')])
+        with self.assertRaises(IndexError):
+            par[-4]
+        with self.assertRaises(IndexError):
+            par[3]
+
+    @needs_windows
+    def test_parents_windows(self):
+        # Anchored
+        P = self.cls
+        p = P('z:a/b/')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('z:a'))
+        self.assertEqual(par[1], P('z:'))
+        self.assertEqual(par[0:1], (P('z:a'),))
+        self.assertEqual(par[:-1], (P('z:a'),))
+        self.assertEqual(par[:2], (P('z:a'), P('z:')))
+        self.assertEqual(par[1:], (P('z:'),))
+        self.assertEqual(par[::2], (P('z:a'),))
+        self.assertEqual(par[::-1], (P('z:'), P('z:a')))
+        self.assertEqual(list(par), [P('z:a'), P('z:')])
+        with self.assertRaises(IndexError):
+            par[2]
+        p = P('z:/a/b/')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('z:/a'))
+        self.assertEqual(par[1], P('z:/'))
+        self.assertEqual(par[0:1], (P('z:/a'),))
+        self.assertEqual(par[0:-1], (P('z:/a'),))
+        self.assertEqual(par[:2], (P('z:/a'), P('z:/')))
+        self.assertEqual(par[1:], (P('z:/'),))
+        self.assertEqual(par[::2], (P('z:/a'),))
+        self.assertEqual(par[::-1], (P('z:/'), P('z:/a'),))
+        self.assertEqual(list(par), [P('z:/a'), P('z:/')])
+        with self.assertRaises(IndexError):
+            par[2]
+        p = P('//a/b/c/d')
+        par = p.parents
+        self.assertEqual(len(par), 2)
+        self.assertEqual(par[0], P('//a/b/c'))
+        self.assertEqual(par[1], P('//a/b'))
+        self.assertEqual(par[0:1], (P('//a/b/c'),))
+        self.assertEqual(par[0:-1], (P('//a/b/c'),))
+        self.assertEqual(par[:2], (P('//a/b/c'), P('//a/b')))
+        self.assertEqual(par[1:], (P('//a/b'),))
+        self.assertEqual(par[::2], (P('//a/b/c'),))
+        self.assertEqual(par[::-1], (P('//a/b'), P('//a/b/c')))
+        self.assertEqual(list(par), [P('//a/b/c'), P('//a/b')])
+        with self.assertRaises(IndexError):
+            par[2]
+
+    def test_drive_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').drive, '')
+        self.assertEqual(P('/a/b').drive, '')
+        self.assertEqual(P('').drive, '')
+
+    @needs_windows
+    def test_drive_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').drive, 'c:')
+        self.assertEqual(P('c:a/b').drive, 'c:')
+        self.assertEqual(P('c:/').drive, 'c:')
+        self.assertEqual(P('c:/a/b/').drive, 'c:')
+        self.assertEqual(P('//a/b').drive, '\\\\a\\b')
+        self.assertEqual(P('//a/b/').drive, '\\\\a\\b')
+        self.assertEqual(P('//a/b/c/d').drive, '\\\\a\\b')
+        self.assertEqual(P('./c:a').drive, '')
+
+    def test_root_common(self):
+        P = self.cls
+        sep = self.sep
+        self.assertEqual(P('').root, '')
+        self.assertEqual(P('a/b').root, '')
+        self.assertEqual(P('/').root, sep)
+        self.assertEqual(P('/a/b').root, sep)
+
+    @needs_posix
+    def test_root_posix(self):
+        P = self.cls
+        self.assertEqual(P('/a/b').root, '/')
+        # POSIX special case for two leading slashes.
+        self.assertEqual(P('//a/b').root, '//')
+
+    @needs_windows
+    def test_root_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').root, '')
+        self.assertEqual(P('c:a/b').root, '')
+        self.assertEqual(P('c:/').root, '\\')
+        self.assertEqual(P('c:/a/b/').root, '\\')
+        self.assertEqual(P('//a/b').root, '\\')
+        self.assertEqual(P('//a/b/').root, '\\')
+        self.assertEqual(P('//a/b/c/d').root, '\\')
+
+    def test_anchor_common(self):
+        P = self.cls
+        sep = self.sep
+        self.assertEqual(P('').anchor, '')
+        self.assertEqual(P('a/b').anchor, '')
+        self.assertEqual(P('/').anchor, sep)
+        self.assertEqual(P('/a/b').anchor, sep)
+
+    @needs_windows
+    def test_anchor_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').anchor, 'c:')
+        self.assertEqual(P('c:a/b').anchor, 'c:')
+        self.assertEqual(P('c:/').anchor, 'c:\\')
+        self.assertEqual(P('c:/a/b/').anchor, 'c:\\')
+        self.assertEqual(P('//a/b').anchor, '\\\\a\\b\\')
+        self.assertEqual(P('//a/b/').anchor, '\\\\a\\b\\')
+        self.assertEqual(P('//a/b/c/d').anchor, '\\\\a\\b\\')
+
+    def test_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').name, '')
+        self.assertEqual(P('.').name, '.')
+        self.assertEqual(P('/a/b/.').name, '.')
+
+    def test_name_common(self):
+        P = self.cls
+        self.assertEqual(P('/').name, '')
+        self.assertEqual(P('a/b').name, 'b')
+        self.assertEqual(P('/a/b').name, 'b')
+        self.assertEqual(P('a/b.py').name, 'b.py')
+        self.assertEqual(P('/a/b.py').name, 'b.py')
+
+    @needs_windows
+    def test_name_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').name, '')
+        self.assertEqual(P('c:/').name, '')
+        self.assertEqual(P('c:a/b').name, 'b')
+        self.assertEqual(P('c:/a/b').name, 'b')
+        self.assertEqual(P('c:a/b.py').name, 'b.py')
+        self.assertEqual(P('c:/a/b.py').name, 'b.py')
+        self.assertEqual(P('//My.py/Share.php').name, '')
+        self.assertEqual(P('//My.py/Share.php/a/b').name, 'b')
+
+    def test_suffix_common(self):
+        P = self.cls
+        self.assertEqual(P('').suffix, '')
+        self.assertEqual(P('.').suffix, '')
+        self.assertEqual(P('..').suffix, '')
+        self.assertEqual(P('/').suffix, '')
+        self.assertEqual(P('a/b').suffix, '')
+        self.assertEqual(P('/a/b').suffix, '')
+        self.assertEqual(P('/a/b/.').suffix, '')
+        self.assertEqual(P('a/b.py').suffix, '.py')
+        self.assertEqual(P('/a/b.py').suffix, '.py')
+        self.assertEqual(P('a/.hgrc').suffix, '')
+        self.assertEqual(P('/a/.hgrc').suffix, '')
+        self.assertEqual(P('a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('/a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('/a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('/a/Some name. Ending with a dot.').suffix, '')
+
+    @needs_windows
+    def test_suffix_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').suffix, '')
+        self.assertEqual(P('c:/').suffix, '')
+        self.assertEqual(P('c:a/b').suffix, '')
+        self.assertEqual(P('c:/a/b').suffix, '')
+        self.assertEqual(P('c:a/b.py').suffix, '.py')
+        self.assertEqual(P('c:/a/b.py').suffix, '.py')
+        self.assertEqual(P('c:a/.hgrc').suffix, '')
+        self.assertEqual(P('c:/a/.hgrc').suffix, '')
+        self.assertEqual(P('c:a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('c:/a/.hg.rc').suffix, '.rc')
+        self.assertEqual(P('c:a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('c:/a/b.tar.gz').suffix, '.gz')
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffix, '')
+        self.assertEqual(P('//My.py/Share.php').suffix, '')
+        self.assertEqual(P('//My.py/Share.php/a/b').suffix, '')
+
+    def test_suffixes_common(self):
+        P = self.cls
+        self.assertEqual(P('').suffixes, [])
+        self.assertEqual(P('.').suffixes, [])
+        self.assertEqual(P('/').suffixes, [])
+        self.assertEqual(P('a/b').suffixes, [])
+        self.assertEqual(P('/a/b').suffixes, [])
+        self.assertEqual(P('/a/b/.').suffixes, [])
+        self.assertEqual(P('a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('/a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('a/.hgrc').suffixes, [])
+        self.assertEqual(P('/a/.hgrc').suffixes, [])
+        self.assertEqual(P('a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('/a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('/a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('a/Some name. Ending with a dot.').suffixes, [])
+        self.assertEqual(P('/a/Some name. Ending with a dot.').suffixes, [])
+
+    @needs_windows
+    def test_suffixes_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').suffixes, [])
+        self.assertEqual(P('c:/').suffixes, [])
+        self.assertEqual(P('c:a/b').suffixes, [])
+        self.assertEqual(P('c:/a/b').suffixes, [])
+        self.assertEqual(P('c:a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('c:/a/b.py').suffixes, ['.py'])
+        self.assertEqual(P('c:a/.hgrc').suffixes, [])
+        self.assertEqual(P('c:/a/.hgrc').suffixes, [])
+        self.assertEqual(P('c:a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('c:/a/.hg.rc').suffixes, ['.rc'])
+        self.assertEqual(P('c:a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('c:/a/b.tar.gz').suffixes, ['.tar', '.gz'])
+        self.assertEqual(P('//My.py/Share.php').suffixes, [])
+        self.assertEqual(P('//My.py/Share.php/a/b').suffixes, [])
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').suffixes, [])
+        self.assertEqual(P('c:/a/Some name. Ending with a dot.').suffixes, [])
+
+    def test_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').stem, '')
+        self.assertEqual(P('.').stem, '.')
+
+    def test_stem_common(self):
+        P = self.cls
+        self.assertEqual(P('..').stem, '..')
+        self.assertEqual(P('/').stem, '')
+        self.assertEqual(P('a/b').stem, 'b')
+        self.assertEqual(P('a/b.py').stem, 'b')
+        self.assertEqual(P('a/.hgrc').stem, '.hgrc')
+        self.assertEqual(P('a/.hg.rc').stem, '.hg')
+        self.assertEqual(P('a/b.tar.gz').stem, 'b.tar')
+        self.assertEqual(P('a/Some name. Ending with a dot.').stem,
+                         'Some name. Ending with a dot.')
+
+    @needs_windows
+    def test_stem_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:').stem, '')
+        self.assertEqual(P('c:.').stem, '')
+        self.assertEqual(P('c:..').stem, '..')
+        self.assertEqual(P('c:/').stem, '')
+        self.assertEqual(P('c:a/b').stem, 'b')
+        self.assertEqual(P('c:a/b.py').stem, 'b')
+        self.assertEqual(P('c:a/.hgrc').stem, '.hgrc')
+        self.assertEqual(P('c:a/.hg.rc').stem, '.hg')
+        self.assertEqual(P('c:a/b.tar.gz').stem, 'b.tar')
+        self.assertEqual(P('c:a/Some name. Ending with a dot.').stem,
+                         'Some name. Ending with a dot.')
+    def test_with_name_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/b').with_name('d.xml'), P('/a/d.xml'))
+        self.assertEqual(P('a/b.py').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/b.py').with_name('d.xml'), P('/a/d.xml'))
+        self.assertEqual(P('a/Dot ending.').with_name('d.xml'), P('a/d.xml'))
+        self.assertEqual(P('/a/Dot ending.').with_name('d.xml'), P('/a/d.xml'))
+
+    @needs_windows
+    def test_with_name_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_name('d.xml'), P('c:a/d.xml'))
+        self.assertEqual(P('c:/a/b').with_name('d.xml'), P('c:/a/d.xml'))
+        self.assertEqual(P('c:a/Dot ending.').with_name('d.xml'), P('c:a/d.xml'))
+        self.assertEqual(P('c:/a/Dot ending.').with_name('d.xml'), P('c:/a/d.xml'))
+        self.assertRaises(ValueError, P('c:').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('c:/').with_name, 'd.xml')
+        self.assertRaises(ValueError, P('//My/Share').with_name, 'd.xml')
+        self.assertEqual(str(P('a').with_name('d:')), '.\\d:')
+        self.assertEqual(str(P('a').with_name('d:e')), '.\\d:e')
+        self.assertEqual(P('c:a/b').with_name('d:'), P('c:a/d:'))
+        self.assertEqual(P('c:a/b').with_name('d:e'), P('c:a/d:e'))
+        self.assertRaises(ValueError, P('c:a/b').with_name, 'd:/e')
+        self.assertRaises(ValueError, P('c:a/b').with_name, '//My/Share')
+
+    def test_with_name_empty(self):
+        P = self.cls
+        self.assertEqual(P('').with_name('d.xml'), P('d.xml'))
+        self.assertEqual(P('.').with_name('d.xml'), P('d.xml'))
+        self.assertEqual(P('/').with_name('d.xml'), P('/d.xml'))
+        self.assertEqual(P('a/b').with_name(''), P('a/'))
+        self.assertEqual(P('a/b').with_name('.'), P('a/.'))
+
+    def test_with_name_seps(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a/b').with_name, '/c')
+        self.assertRaises(ValueError, P('a/b').with_name, 'c/')
+        self.assertRaises(ValueError, P('a/b').with_name, 'c/d')
+
+    def test_with_stem_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_stem('d'), P('a/d'))
+        self.assertEqual(P('/a/b').with_stem('d'), P('/a/d'))
+        self.assertEqual(P('a/b.py').with_stem('d'), P('a/d.py'))
+        self.assertEqual(P('/a/b.py').with_stem('d'), P('/a/d.py'))
+        self.assertEqual(P('/a/b.tar.gz').with_stem('d'), P('/a/d.gz'))
+        self.assertEqual(P('a/Dot ending.').with_stem('d'), P('a/d'))
+        self.assertEqual(P('/a/Dot ending.').with_stem('d'), P('/a/d'))
+
+    @needs_windows
+    def test_with_stem_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_stem('d'), P('c:a/d'))
+        self.assertEqual(P('c:/a/b').with_stem('d'), P('c:/a/d'))
+        self.assertEqual(P('c:a/Dot ending.').with_stem('d'), P('c:a/d'))
+        self.assertEqual(P('c:/a/Dot ending.').with_stem('d'), P('c:/a/d'))
+        self.assertRaises(ValueError, P('c:').with_stem, 'd')
+        self.assertRaises(ValueError, P('c:/').with_stem, 'd')
+        self.assertRaises(ValueError, P('//My/Share').with_stem, 'd')
+        self.assertEqual(str(P('a').with_stem('d:')), '.\\d:')
+        self.assertEqual(str(P('a').with_stem('d:e')), '.\\d:e')
+        self.assertEqual(P('c:a/b').with_stem('d:'), P('c:a/d:'))
+        self.assertEqual(P('c:a/b').with_stem('d:e'), P('c:a/d:e'))
+        self.assertRaises(ValueError, P('c:a/b').with_stem, 'd:/e')
+        self.assertRaises(ValueError, P('c:a/b').with_stem, '//My/Share')
+
+    def test_with_stem_empty(self):
+        P = self.cls
+        self.assertEqual(P('').with_stem('d'), P('d'))
+        self.assertEqual(P('.').with_stem('d'), P('d'))
+        self.assertEqual(P('/').with_stem('d'), P('/d'))
+        self.assertEqual(P('a/b').with_stem(''), P('a/'))
+        self.assertEqual(P('a/b').with_stem('.'), P('a/.'))
+        self.assertRaises(ValueError, P('foo.gz').with_stem, '')
+        self.assertRaises(ValueError, P('/a/b/foo.gz').with_stem, '')
+
+    def test_with_stem_seps(self):
+        P = self.cls
+        self.assertRaises(ValueError, P('a/b').with_stem, '/c')
+        self.assertRaises(ValueError, P('a/b').with_stem, 'c/')
+        self.assertRaises(ValueError, P('a/b').with_stem, 'c/d')
+
+    def test_with_suffix_common(self):
+        P = self.cls
+        self.assertEqual(P('a/b').with_suffix('.gz'), P('a/b.gz'))
+        self.assertEqual(P('/a/b').with_suffix('.gz'), P('/a/b.gz'))
+        self.assertEqual(P('a/b.py').with_suffix('.gz'), P('a/b.gz'))
+        self.assertEqual(P('/a/b.py').with_suffix('.gz'), P('/a/b.gz'))
+        # Stripping suffix.
+        self.assertEqual(P('a/b.py').with_suffix(''), P('a/b'))
+        self.assertEqual(P('/a/b').with_suffix(''), P('/a/b'))
+
+    @needs_windows
+    def test_with_suffix_windows(self):
+        P = self.cls
+        self.assertEqual(P('c:a/b').with_suffix('.gz'), P('c:a/b.gz'))
+        self.assertEqual(P('c:/a/b').with_suffix('.gz'), P('c:/a/b.gz'))
+        self.assertEqual(P('c:a/b.py').with_suffix('.gz'), P('c:a/b.gz'))
+        self.assertEqual(P('c:/a/b.py').with_suffix('.gz'), P('c:/a/b.gz'))
+        # Path doesn't have a "filename" component.
+        self.assertRaises(ValueError, P('').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('.').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('//My/Share').with_suffix, '.gz')
+        # Invalid suffix.
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '/.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '\\.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c:.gz')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c/d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, 'c\\d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c/d')
+        self.assertRaises(ValueError, P('c:a/b').with_suffix, '.c\\d')
+        self.assertRaises(TypeError, P('c:a/b').with_suffix, None)
+
+    def test_with_suffix_empty(self):
+        P = self.cls
+        # Path doesn't have a "filename" component.
+        self.assertRaises(ValueError, P('').with_suffix, '.gz')
+        self.assertRaises(ValueError, P('/').with_suffix, '.gz')
+
+    def test_with_suffix_invalid(self):
+        P = self.cls
+        # Invalid suffix.
+        self.assertRaises(ValueError, P('a/b').with_suffix, 'gz')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '/')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '/.gz')
+        self.assertRaises(ValueError, P('a/b').with_suffix, 'c/d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.c/.d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, './.d')
+        self.assertRaises(ValueError, P('a/b').with_suffix, '.d/.')
+        self.assertRaises(TypeError, P('a/b').with_suffix, None)
+
+    def test_relative_to_common(self):
+        P = self.cls
+        p = P('a/b')
+        self.assertRaises(TypeError, p.relative_to)
+        self.assertRaises(TypeError, p.relative_to, b'a')
+        self.assertEqual(p.relative_to(P('')), P('a/b'))
+        self.assertEqual(p.relative_to(''), P('a/b'))
+        self.assertEqual(p.relative_to(P('a')), P('b'))
+        self.assertEqual(p.relative_to('a'), P('b'))
+        self.assertEqual(p.relative_to('a/'), P('b'))
+        self.assertEqual(p.relative_to(P('a/b')), P(''))
+        self.assertEqual(p.relative_to('a/b'), P(''))
+        self.assertEqual(p.relative_to(P(''), walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to('', walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to(P('a'), walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('a', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('a/', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to(P('a/b'), walk_up=True), P(''))
+        self.assertEqual(p.relative_to('a/b', walk_up=True), P(''))
+        self.assertEqual(p.relative_to(P('a/c'), walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to('a/c', walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to(P('a/b/c'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('a/b/c', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('c'), walk_up=True), P('../a/b'))
+        self.assertEqual(p.relative_to('c', walk_up=True), P('../a/b'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('c'))
+        self.assertRaises(ValueError, p.relative_to, P('a/b/c'))
+        self.assertRaises(ValueError, p.relative_to, P('a/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a'))
+        self.assertRaises(ValueError, p.relative_to, P("../a"))
+        self.assertRaises(ValueError, p.relative_to, P("a/.."))
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/a'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
+        p = P('/a/b')
+        self.assertEqual(p.relative_to(P('/')), P('a/b'))
+        self.assertEqual(p.relative_to('/'), P('a/b'))
+        self.assertEqual(p.relative_to(P('/a')), P('b'))
+        self.assertEqual(p.relative_to('/a'), P('b'))
+        self.assertEqual(p.relative_to('/a/'), P('b'))
+        self.assertEqual(p.relative_to(P('/a/b')), P(''))
+        self.assertEqual(p.relative_to('/a/b'), P(''))
+        self.assertEqual(p.relative_to(P('/'), walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to('/', walk_up=True), P('a/b'))
+        self.assertEqual(p.relative_to(P('/a'), walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('/a', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to('/a/', walk_up=True), P('b'))
+        self.assertEqual(p.relative_to(P('/a/b'), walk_up=True), P(''))
+        self.assertEqual(p.relative_to('/a/b', walk_up=True), P(''))
+        self.assertEqual(p.relative_to(P('/a/c'), walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to('/a/c', walk_up=True), P('../b'))
+        self.assertEqual(p.relative_to(P('/a/b/c'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('/a/b/c', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('/c'), walk_up=True), P('../a/b'))
+        self.assertEqual(p.relative_to('/c', walk_up=True), P('../a/b'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a/b/c'))
+        self.assertRaises(ValueError, p.relative_to, P('/a/c'))
+        self.assertRaises(ValueError, p.relative_to, P(''))
+        self.assertRaises(ValueError, p.relative_to, '')
+        self.assertRaises(ValueError, p.relative_to, P('a'))
+        self.assertRaises(ValueError, p.relative_to, P("../a"))
+        self.assertRaises(ValueError, p.relative_to, P("a/.."))
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."))
+        self.assertRaises(ValueError, p.relative_to, P(''), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('a'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("../a"), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("a/.."), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P("/a/.."), walk_up=True)
+
+    @needs_windows
+    def test_relative_to_windows(self):
+        P = self.cls
+        p = P('C:Foo/Bar')
+        self.assertEqual(p.relative_to(P('c:')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:foO')), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO'), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:foO/baR')), P())
+        self.assertEqual(p.relative_to('c:foO/baR'), P())
+        self.assertEqual(p.relative_to(P('c:'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:foO'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:foO/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:foO/baR'), walk_up=True), P())
+        self.assertEqual(p.relative_to('c:foO/baR', walk_up=True), P())
+        self.assertEqual(p.relative_to(P('C:Foo/Bar/Baz'), walk_up=True), P('..'))
+        self.assertEqual(p.relative_to(P('C:Foo/Baz'), walk_up=True), P('../Bar'))
+        self.assertEqual(p.relative_to(P('C:Baz/Bar'), walk_up=True), P('../../Foo/Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P())
+        self.assertRaises(ValueError, p.relative_to, '')
+        self.assertRaises(ValueError, p.relative_to, P('d:'))
+        self.assertRaises(ValueError, p.relative_to, P('/'))
+        self.assertRaises(ValueError, p.relative_to, P('Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Bar/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P(), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, '', walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo'), walk_up=True)
+        p = P('C:/Foo/Bar')
+        self.assertEqual(p.relative_to(P('c:/')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:/'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO')), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO'), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO/baR')), P())
+        self.assertEqual(p.relative_to('c:/foO/baR'), P())
+        self.assertEqual(p.relative_to(P('c:/'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('c:/', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('c:/foO/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('c:/foO/baR'), walk_up=True), P())
+        self.assertEqual(p.relative_to('c:/foO/baR', walk_up=True), P())
+        self.assertEqual(p.relative_to('C:/Baz', walk_up=True), P('../Foo/Bar'))
+        self.assertEqual(p.relative_to('C:/Foo/Bar/Baz', walk_up=True), P('..'))
+        self.assertEqual(p.relative_to('C:/Foo/Baz', walk_up=True), P('../Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, 'c:')
+        self.assertRaises(ValueError, p.relative_to, P('c:'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Bar/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:/Foo/Baz'))
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('d:'))
+        self.assertRaises(ValueError, p.relative_to, P('d:/'))
+        self.assertRaises(ValueError, p.relative_to, P('/'))
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'))
+        self.assertRaises(ValueError, p.relative_to, 'c:', walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('c:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('C:Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('d:/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//C/Foo'), walk_up=True)
+        # UNC paths.
+        p = P('//Server/Share/Foo/Bar')
+        self.assertEqual(p.relative_to(P('//sErver/sHare')), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/'), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo')), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo'), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/'), P('Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar')), P())
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar'), P())
+        self.assertEqual(p.relative_to(P('//sErver/sHare'), walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/', walk_up=True), P('Foo/Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo'), walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/', walk_up=True), P('Bar'))
+        self.assertEqual(p.relative_to(P('//sErver/sHare/Foo/Bar'), walk_up=True), P())
+        self.assertEqual(p.relative_to('//sErver/sHare/Foo/Bar', walk_up=True), P())
+        self.assertEqual(p.relative_to(P('//sErver/sHare/bar'), walk_up=True), P('../Foo/Bar'))
+        self.assertEqual(p.relative_to('//sErver/sHare/bar', walk_up=True), P('../Foo/Bar'))
+        # Unrelated paths.
+        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'))
+        self.assertRaises(ValueError, p.relative_to, P('/Server/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('c:/Server/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//z/Share/Foo'), walk_up=True)
+        self.assertRaises(ValueError, p.relative_to, P('//Server/z/Foo'), walk_up=True)
+
+    def test_is_relative_to_common(self):
+        P = self.cls
+        p = P('a/b')
+        self.assertRaises(TypeError, p.is_relative_to)
+        self.assertRaises(TypeError, p.is_relative_to, b'a')
+        self.assertTrue(p.is_relative_to(P('')))
+        self.assertTrue(p.is_relative_to(''))
+        self.assertTrue(p.is_relative_to(P('a')))
+        self.assertTrue(p.is_relative_to('a/'))
+        self.assertTrue(p.is_relative_to(P('a/b')))
+        self.assertTrue(p.is_relative_to('a/b'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('c')))
+        self.assertFalse(p.is_relative_to(P('a/b/c')))
+        self.assertFalse(p.is_relative_to(P('a/c')))
+        self.assertFalse(p.is_relative_to(P('/a')))
+        p = P('/a/b')
+        self.assertTrue(p.is_relative_to(P('/')))
+        self.assertTrue(p.is_relative_to('/'))
+        self.assertTrue(p.is_relative_to(P('/a')))
+        self.assertTrue(p.is_relative_to('/a'))
+        self.assertTrue(p.is_relative_to('/a/'))
+        self.assertTrue(p.is_relative_to(P('/a/b')))
+        self.assertTrue(p.is_relative_to('/a/b'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('/c')))
+        self.assertFalse(p.is_relative_to(P('/a/b/c')))
+        self.assertFalse(p.is_relative_to(P('/a/c')))
+        self.assertFalse(p.is_relative_to(P('')))
+        self.assertFalse(p.is_relative_to(''))
+        self.assertFalse(p.is_relative_to(P('a')))
+
+    @needs_windows
+    def test_is_relative_to_windows(self):
+        P = self.cls
+        p = P('C:Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('c:')))
+        self.assertTrue(p.is_relative_to('c:'))
+        self.assertTrue(p.is_relative_to(P('c:foO')))
+        self.assertTrue(p.is_relative_to('c:foO'))
+        self.assertTrue(p.is_relative_to('c:foO/'))
+        self.assertTrue(p.is_relative_to(P('c:foO/baR')))
+        self.assertTrue(p.is_relative_to('c:foO/baR'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P()))
+        self.assertFalse(p.is_relative_to(''))
+        self.assertFalse(p.is_relative_to(P('d:')))
+        self.assertFalse(p.is_relative_to(P('/')))
+        self.assertFalse(p.is_relative_to(P('Foo')))
+        self.assertFalse(p.is_relative_to(P('/Foo')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo')))
+        self.assertFalse(p.is_relative_to(P('C:Foo/Bar/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:Foo/Baz')))
+        p = P('C:/Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('c:/')))
+        self.assertTrue(p.is_relative_to(P('c:/foO')))
+        self.assertTrue(p.is_relative_to('c:/foO/'))
+        self.assertTrue(p.is_relative_to(P('c:/foO/baR')))
+        self.assertTrue(p.is_relative_to('c:/foO/baR'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to('c:'))
+        self.assertFalse(p.is_relative_to(P('C:/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo/Bar/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:/Foo/Baz')))
+        self.assertFalse(p.is_relative_to(P('C:Foo')))
+        self.assertFalse(p.is_relative_to(P('d:')))
+        self.assertFalse(p.is_relative_to(P('d:/')))
+        self.assertFalse(p.is_relative_to(P('/')))
+        self.assertFalse(p.is_relative_to(P('/Foo')))
+        self.assertFalse(p.is_relative_to(P('//C/Foo')))
+        # UNC paths.
+        p = P('//Server/Share/Foo/Bar')
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare'))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/'))
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo'))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/'))
+        self.assertTrue(p.is_relative_to(P('//sErver/sHare/Foo/Bar')))
+        self.assertTrue(p.is_relative_to('//sErver/sHare/Foo/Bar'))
+        # Unrelated paths.
+        self.assertFalse(p.is_relative_to(P('/Server/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('c:/Server/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('//z/Share/Foo')))
+        self.assertFalse(p.is_relative_to(P('//Server/z/Foo')))
+
+    @needs_posix
+    def test_is_absolute_posix(self):
+        P = self.cls
+        self.assertFalse(P('').is_absolute())
+        self.assertFalse(P('a').is_absolute())
+        self.assertFalse(P('a/b/').is_absolute())
+        self.assertTrue(P('/').is_absolute())
+        self.assertTrue(P('/a').is_absolute())
+        self.assertTrue(P('/a/b/').is_absolute())
+        self.assertTrue(P('//a').is_absolute())
+        self.assertTrue(P('//a/b').is_absolute())
+
+    @needs_windows
+    def test_is_absolute_windows(self):
+        P = self.cls
+        # Under NT, only paths with both a drive and a root are absolute.
+        self.assertFalse(P().is_absolute())
+        self.assertFalse(P('a').is_absolute())
+        self.assertFalse(P('a/b/').is_absolute())
+        self.assertFalse(P('/').is_absolute())
+        self.assertFalse(P('/a').is_absolute())
+        self.assertFalse(P('/a/b/').is_absolute())
+        self.assertFalse(P('c:').is_absolute())
+        self.assertFalse(P('c:a').is_absolute())
+        self.assertFalse(P('c:a/b/').is_absolute())
+        self.assertTrue(P('c:/').is_absolute())
+        self.assertTrue(P('c:/a').is_absolute())
+        self.assertTrue(P('c:/a/b/').is_absolute())
+        # UNC paths are absolute by definition.
+        self.assertTrue(P('//').is_absolute())
+        self.assertTrue(P('//a').is_absolute())
+        self.assertTrue(P('//a/b').is_absolute())
+        self.assertTrue(P('//a/b/').is_absolute())
+        self.assertTrue(P('//a/b/c').is_absolute())
+        self.assertTrue(P('//a/b/c/d').is_absolute())
+        self.assertTrue(P('//?/UNC/').is_absolute())
+        self.assertTrue(P('//?/UNC/spam').is_absolute())
+
+
+#
+# Tests for the virtual classes.
+#
+
+class PathBaseTest(PurePathBaseTest):
+    cls = PathBase
+
+    def test_unsupported_operation(self):
+        P = self.cls
+        p = self.cls('')
+        e = UnsupportedOperation
+        self.assertRaises(e, p.stat)
+        self.assertRaises(e, p.lstat)
+        self.assertRaises(e, p.exists)
+        self.assertRaises(e, p.samefile, 'foo')
+        self.assertRaises(e, p.is_dir)
+        self.assertRaises(e, p.is_file)
+        self.assertRaises(e, p.is_mount)
+        self.assertRaises(e, p.is_symlink)
+        self.assertRaises(e, p.is_block_device)
+        self.assertRaises(e, p.is_char_device)
+        self.assertRaises(e, p.is_fifo)
+        self.assertRaises(e, p.is_socket)
+        self.assertRaises(e, p.open)
+        self.assertRaises(e, p.read_bytes)
+        self.assertRaises(e, p.read_text)
+        self.assertRaises(e, p.write_bytes, b'foo')
+        self.assertRaises(e, p.write_text, 'foo')
+        self.assertRaises(e, p.iterdir)
+        self.assertRaises(e, p.glob, '*')
+        self.assertRaises(e, p.rglob, '*')
+        self.assertRaises(e, lambda: list(p.walk()))
+        self.assertRaises(e, p.absolute)
+        self.assertRaises(e, P.cwd)
+        self.assertRaises(e, p.expanduser)
+        self.assertRaises(e, p.home)
+        self.assertRaises(e, p.readlink)
+        self.assertRaises(e, p.symlink_to, 'foo')
+        self.assertRaises(e, p.hardlink_to, 'foo')
+        self.assertRaises(e, p.mkdir)
+        self.assertRaises(e, p.touch)
+        self.assertRaises(e, p.rename, 'foo')
+        self.assertRaises(e, p.replace, 'foo')
+        self.assertRaises(e, p.chmod, 0o755)
+        self.assertRaises(e, p.lchmod, 0o755)
+        self.assertRaises(e, p.unlink)
+        self.assertRaises(e, p.rmdir)
+        self.assertRaises(e, p.owner)
+        self.assertRaises(e, p.group)
+        self.assertRaises(e, p.as_uri)
+
+    def test_as_uri_common(self):
+        e = UnsupportedOperation
+        self.assertRaises(e, self.cls('').as_uri)
+
+    def test_fspath_common(self):
+        self.assertRaises(TypeError, os.fspath, self.cls(''))
+
+    def test_as_bytes_common(self):
+        self.assertRaises(TypeError, bytes, self.cls(''))
+
+
+class DummyPathIO(io.BytesIO):
+    """
+    Used by DummyPath to implement `open('w')`
+    """
+
+    def __init__(self, files, path):
+        super().__init__()
+        self.files = files
+        self.path = path
+
+    def close(self):
+        self.files[self.path] = self.getvalue()
+        super().close()
+
+
+DummyPathStatResult = collections.namedtuple(
+    'DummyPathStatResult',
+    'st_mode st_ino st_dev st_nlink st_uid st_gid st_size st_atime st_mtime st_ctime')
+
+
+class DummyPath(PathBase):
+    """
+    Simple implementation of PathBase that keeps files and directories in
+    memory.
+    """
+    __slots__ = ()
+    parser = posixpath
+
+    _files = {}
+    _directories = {}
+    _symlinks = {}
+
+    def __eq__(self, other):
+        if not isinstance(other, DummyPath):
+            return NotImplemented
+        return str(self) == str(other)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __repr__(self):
+        return "{}({!r})".format(self.__class__.__name__, self.as_posix())
+
+    def stat(self, *, follow_symlinks=True):
+        if follow_symlinks or self.name in ('', '.', '..'):
+            path = str(self.resolve(strict=True))
+        else:
+            path = str(self.parent.resolve(strict=True) / self.name)
+        if path in self._files:
+            st_mode = stat.S_IFREG
+        elif path in self._directories:
+            st_mode = stat.S_IFDIR
+        elif path in self._symlinks:
+            st_mode = stat.S_IFLNK
+        else:
+            raise FileNotFoundError(errno.ENOENT, "Not found", str(self))
+        return DummyPathStatResult(st_mode, hash(str(self)), 0, 0, 0, 0, 0, 0, 0, 0)
+
+    def open(self, mode='r', buffering=-1, encoding=None,
+             errors=None, newline=None):
+        if buffering != -1:
+            raise NotImplementedError
+        path_obj = self.resolve()
+        path = str(path_obj)
+        name = path_obj.name
+        parent = str(path_obj.parent)
+        if path in self._directories:
+            raise IsADirectoryError(errno.EISDIR, "Is a directory", path)
+
+        text = 'b' not in mode
+        mode = ''.join(c for c in mode if c not in 'btU')
+        if mode == 'r':
+            if path not in self._files:
+                raise FileNotFoundError(errno.ENOENT, "File not found", path)
+            stream = io.BytesIO(self._files[path])
+        elif mode == 'w':
+            if parent not in self._directories:
+                raise FileNotFoundError(errno.ENOENT, "File not found", parent)
+            stream = DummyPathIO(self._files, path)
+            self._files[path] = b''
+            self._directories[parent].add(name)
+        else:
+            raise NotImplementedError
+        if text:
+            stream = io.TextIOWrapper(stream, encoding=encoding, errors=errors, newline=newline)
+        return stream
+
+    def iterdir(self):
+        path = str(self.resolve())
+        if path in self._files:
+            raise NotADirectoryError(errno.ENOTDIR, "Not a directory", path)
+        elif path in self._directories:
+            return (self / name for name in self._directories[path])
+        else:
+            raise FileNotFoundError(errno.ENOENT, "File not found", path)
+
+    def mkdir(self, mode=0o777, parents=False, exist_ok=False):
+        path = str(self.resolve())
+        if path in self._directories:
+            if exist_ok:
+                return
+            else:
+                raise FileExistsError(errno.EEXIST, "File exists", path)
+        try:
+            if self.name:
+                self._directories[str(self.parent)].add(self.name)
+            self._directories[path] = set()
+        except KeyError:
+            if not parents:
+                raise FileNotFoundError(errno.ENOENT, "File not found", str(self.parent)) from None
+            self.parent.mkdir(parents=True, exist_ok=True)
+            self.mkdir(mode, parents=False, exist_ok=exist_ok)
+
+
+class DummyPathTest(DummyPurePathTest):
+    """Tests for PathBase methods that use stat(), open() and iterdir()."""
+
+    cls = DummyPath
+    can_symlink = False
+
+    # (self.base)
+    #  |
+    #  |-- brokenLink -> non-existing
+    #  |-- dirA
+    #  |   `-- linkC -> ../dirB
+    #  |-- dirB
+    #  |   |-- fileB
+    #  |   `-- linkD -> ../dirB
+    #  |-- dirC
+    #  |   |-- dirD
+    #  |   |   `-- fileD
+    #  |   `-- fileC
+    #  |   `-- novel.txt
+    #  |-- dirE  # No permissions
+    #  |-- fileA
+    #  |-- linkA -> fileA
+    #  |-- linkB -> dirB
+    #  `-- brokenLinkLoop -> brokenLinkLoop
+    #
+
+    def setUp(self):
+        super().setUp()
+        name = self.id().split('.')[-1]
+        if name in _tests_needing_symlinks and not self.can_symlink:
+            self.skipTest('requires symlinks')
+        parser = self.cls.parser
+        p = self.cls(self.base)
+        p.mkdir(parents=True)
+        p.joinpath('dirA').mkdir()
+        p.joinpath('dirB').mkdir()
+        p.joinpath('dirC').mkdir()
+        p.joinpath('dirC', 'dirD').mkdir()
+        p.joinpath('dirE').mkdir()
+        with p.joinpath('fileA').open('wb') as f:
+            f.write(b"this is file A\n")
+        with p.joinpath('dirB', 'fileB').open('wb') as f:
+            f.write(b"this is file B\n")
+        with p.joinpath('dirC', 'fileC').open('wb') as f:
+            f.write(b"this is file C\n")
+        with p.joinpath('dirC', 'novel.txt').open('wb') as f:
+            f.write(b"this is a novel\n")
+        with p.joinpath('dirC', 'dirD', 'fileD').open('wb') as f:
+            f.write(b"this is file D\n")
+        if self.can_symlink:
+            p.joinpath('linkA').symlink_to('fileA')
+            p.joinpath('brokenLink').symlink_to('non-existing')
+            p.joinpath('linkB').symlink_to('dirB')
+            p.joinpath('dirA', 'linkC').symlink_to(parser.join('..', 'dirB'))
+            p.joinpath('dirB', 'linkD').symlink_to(parser.join('..', 'dirB'))
+            p.joinpath('brokenLinkLoop').symlink_to('brokenLinkLoop')
+
+    def tearDown(self):
+        cls = self.cls
+        cls._files.clear()
+        cls._directories.clear()
+        cls._symlinks.clear()
+
+    def tempdir(self):
+        path = self.cls(self.base).with_name('tmp-dirD')
+        path.mkdir()
+        return path
+
+    def assertFileNotFound(self, func, *args, **kwargs):
+        with self.assertRaises(FileNotFoundError) as cm:
+            func(*args, **kwargs)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+
+    def assertEqualNormCase(self, path_a, path_b):
+        normcase = self.parser.normcase
+        self.assertEqual(normcase(path_a), normcase(path_b))
+
+    def test_samefile(self):
+        parser = self.parser
+        fileA_path = parser.join(self.base, 'fileA')
+        fileB_path = parser.join(self.base, 'dirB', 'fileB')
+        p = self.cls(fileA_path)
+        pp = self.cls(fileA_path)
+        q = self.cls(fileB_path)
+        self.assertTrue(p.samefile(fileA_path))
+        self.assertTrue(p.samefile(pp))
+        self.assertFalse(p.samefile(fileB_path))
+        self.assertFalse(p.samefile(q))
+        # Test the non-existent file case
+        non_existent = parser.join(self.base, 'foo')
+        r = self.cls(non_existent)
+        self.assertRaises(FileNotFoundError, p.samefile, r)
+        self.assertRaises(FileNotFoundError, p.samefile, non_existent)
+        self.assertRaises(FileNotFoundError, r.samefile, p)
+        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
+        self.assertRaises(FileNotFoundError, r.samefile, r)
+        self.assertRaises(FileNotFoundError, r.samefile, non_existent)
+
+    def test_exists(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertIs(True, p.exists())
+        self.assertIs(True, (p / 'dirA').exists())
+        self.assertIs(True, (p / 'fileA').exists())
+        self.assertIs(False, (p / 'fileA' / 'bah').exists())
+        if self.can_symlink:
+            self.assertIs(True, (p / 'linkA').exists())
+            self.assertIs(True, (p / 'linkB').exists())
+            self.assertIs(True, (p / 'linkB' / 'fileB').exists())
+            self.assertIs(False, (p / 'linkA' / 'bah').exists())
+            self.assertIs(False, (p / 'brokenLink').exists())
+            self.assertIs(True, (p / 'brokenLink').exists(follow_symlinks=False))
+        self.assertIs(False, (p / 'foo').exists())
+        self.assertIs(False, P('/xyzzy').exists())
+        self.assertIs(False, P(self.base + '\udfff').exists())
+        self.assertIs(False, P(self.base + '\x00').exists())
+
+    def test_open_common(self):
+        p = self.cls(self.base)
+        with (p / 'fileA').open('r') as f:
+            self.assertIsInstance(f, io.TextIOBase)
+            self.assertEqual(f.read(), "this is file A\n")
+        with (p / 'fileA').open('rb') as f:
+            self.assertIsInstance(f, io.BufferedIOBase)
+            self.assertEqual(f.read().strip(), b"this is file A")
+
+    def test_read_write_bytes(self):
+        p = self.cls(self.base)
+        (p / 'fileA').write_bytes(b'abcdefg')
+        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
+        # Check that trying to write str does not truncate the file.
+        self.assertRaises(TypeError, (p / 'fileA').write_bytes, 'somestr')
+        self.assertEqual((p / 'fileA').read_bytes(), b'abcdefg')
+
+    def test_read_write_text(self):
+        p = self.cls(self.base)
+        (p / 'fileA').write_text('äbcdefg', encoding='latin-1')
+        self.assertEqual((p / 'fileA').read_text(
+            encoding='utf-8', errors='ignore'), 'bcdefg')
+        # Check that trying to write bytes does not truncate the file.
+        self.assertRaises(TypeError, (p / 'fileA').write_text, b'somebytes')
+        self.assertEqual((p / 'fileA').read_text(encoding='latin-1'), 'äbcdefg')
+
+    def test_read_text_with_newlines(self):
+        p = self.cls(self.base)
+        # Check that `\n` character change nothing
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\n'),
+                         'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r` character replaces `\n`
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\r'),
+                         'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r\n` character replaces `\n`
+        (p / 'fileA').write_bytes(b'abcde\r\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_text(newline='\r\n'),
+                             'abcde\r\nfghlk\n\rmnopq')
+
+    def test_write_text_with_newlines(self):
+        p = self.cls(self.base)
+        # Check that `\n` character change nothing
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\n')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\nfghlk\n\rmnopq')
+        # Check that `\r` character replaces `\n`
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\rfghlk\r\rmnopq')
+        # Check that `\r\n` character replaces `\n`
+        (p / 'fileA').write_text('abcde\r\nfghlk\n\rmnopq', newline='\r\n')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                         b'abcde\r\r\nfghlk\r\n\rmnopq')
+        # Check that no argument passed will change `\n` to `os.linesep`
+        os_linesep_byte = bytes(os.linesep, encoding='ascii')
+        (p / 'fileA').write_text('abcde\nfghlk\n\rmnopq')
+        self.assertEqual((p / 'fileA').read_bytes(),
+                          b'abcde' + os_linesep_byte + b'fghlk' + os_linesep_byte + b'\rmnopq')
+
+    def test_iterdir(self):
+        P = self.cls
+        p = P(self.base)
+        it = p.iterdir()
+        paths = set(it)
+        expected = ['dirA', 'dirB', 'dirC', 'dirE', 'fileA']
+        if self.can_symlink:
+            expected += ['linkA', 'linkB', 'brokenLink', 'brokenLinkLoop']
+        self.assertEqual(paths, { P(self.base, q) for q in expected })
+
+    @needs_symlinks
+    def test_iterdir_symlink(self):
+        # __iter__ on a symlink to a directory.
+        P = self.cls
+        p = P(self.base, 'linkB')
+        paths = set(p.iterdir())
+        expected = { P(self.base, 'linkB', q) for q in ['fileB', 'linkD'] }
+        self.assertEqual(paths, expected)
+
+    def test_iterdir_nodir(self):
+        # __iter__ on something that is not a directory.
+        p = self.cls(self.base, 'fileA')
+        with self.assertRaises(OSError) as cm:
+            p.iterdir()
+        # ENOENT or EINVAL under Windows, ENOTDIR otherwise
+        # (see issue #12802).
+        self.assertIn(cm.exception.errno, (errno.ENOTDIR,
+                                           errno.ENOENT, errno.EINVAL))
+
+    def test_glob_common(self):
+        def _check(glob, expected):
+            self.assertEqual(set(glob), { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        it = p.glob("fileA")
+        self.assertIsInstance(it, collections.abc.Iterator)
+        _check(it, ["fileA"])
+        _check(p.glob("fileB"), [])
+        _check(p.glob("dir*/file*"), ["dirB/fileB", "dirC/fileC"])
+        if not self.can_symlink:
+            _check(p.glob("*A"), ['dirA', 'fileA'])
+        else:
+            _check(p.glob("*A"), ['dirA', 'fileA', 'linkA'])
+        if not self.can_symlink:
+            _check(p.glob("*B/*"), ['dirB/fileB'])
+        else:
+            _check(p.glob("*B/*"), ['dirB/fileB', 'dirB/linkD',
+                                    'linkB/fileB', 'linkB/linkD'])
+        if not self.can_symlink:
+            _check(p.glob("*/fileB"), ['dirB/fileB'])
+        else:
+            _check(p.glob("*/fileB"), ['dirB/fileB', 'linkB/fileB'])
+        if self.can_symlink:
+            _check(p.glob("brokenLink"), ['brokenLink'])
+
+        if not self.can_symlink:
+            _check(p.glob("*/"), ["dirA/", "dirB/", "dirC/", "dirE/"])
+        else:
+            _check(p.glob("*/"), ["dirA/", "dirB/", "dirC/", "dirE/", "linkB/"])
+
+    @needs_posix
+    def test_glob_posix(self):
+        P = self.cls
+        p = P(self.base)
+        q = p / "FILEa"
+        given = set(p.glob("FILEa"))
+        expect = {q} if q.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.glob("FILEa*")), set())
+
+    @needs_windows
+    def test_glob_windows(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(set(p.glob("FILEa")), { P(self.base, "fileA") })
+        self.assertEqual(set(p.glob("*a\\")), { P(self.base, "dirA/") })
+        self.assertEqual(set(p.glob("F*a")), { P(self.base, "fileA") })
+
+    def test_glob_empty_pattern(self):
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(list(p.glob("")), [p])
+        self.assertEqual(list(p.glob(".")), [p / "."])
+        self.assertEqual(list(p.glob("./")), [p / "./"])
+
+    def test_glob_case_sensitive(self):
+        P = self.cls
+        def _check(path, pattern, case_sensitive, expected):
+            actual = {str(q) for q in path.glob(pattern, case_sensitive=case_sensitive)}
+            expected = {str(P(self.base, q)) for q in expected}
+            self.assertEqual(actual, expected)
+        path = P(self.base)
+        _check(path, "DIRB/FILE*", True, [])
+        _check(path, "DIRB/FILE*", False, ["dirB/fileB"])
+        _check(path, "dirb/file*", True, [])
+        _check(path, "dirb/file*", False, ["dirB/fileB"])
+
+    @needs_symlinks
+    def test_glob_recurse_symlinks_common(self):
+        def _check(path, glob, expected):
+            actual = {path for path in path.glob(glob, recurse_symlinks=True)
+                      if path.parts.count("linkD") <= 1}  # exclude symlink loop.
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        _check(p, "fileB", [])
+        _check(p, "dir*/file*", ["dirB/fileB", "dirC/fileC"])
+        _check(p, "*A", ["dirA", "fileA", "linkA"])
+        _check(p, "*B/*", ["dirB/fileB", "dirB/linkD", "linkB/fileB", "linkB/linkD"])
+        _check(p, "*/fileB", ["dirB/fileB", "linkB/fileB"])
+        _check(p, "*/", ["dirA/", "dirB/", "dirC/", "dirE/", "linkB/"])
+        _check(p, "dir*/*/..", ["dirC/dirD/..", "dirA/linkC/..", "dirB/linkD/.."])
+        _check(p, "dir*/**", [
+            "dirA/", "dirA/linkC", "dirA/linkC/fileB", "dirA/linkC/linkD", "dirA/linkC/linkD/fileB",
+            "dirB/", "dirB/fileB", "dirB/linkD", "dirB/linkD/fileB",
+            "dirC/", "dirC/fileC", "dirC/dirD",  "dirC/dirD/fileD", "dirC/novel.txt",
+            "dirE/"])
+        _check(p, "dir*/**/", ["dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                               "dirC/", "dirC/dirD/", "dirE/"])
+        _check(p, "dir*/**/..", ["dirA/..", "dirA/linkC/..", "dirB/..",
+                                 "dirB/linkD/..", "dirA/linkC/linkD/..",
+                                 "dirC/..", "dirC/dirD/..", "dirE/.."])
+        _check(p, "dir*/*/**", [
+            "dirA/linkC/", "dirA/linkC/linkD", "dirA/linkC/fileB", "dirA/linkC/linkD/fileB",
+            "dirB/linkD/", "dirB/linkD/fileB",
+            "dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "dir*/*/**/", ["dirA/linkC/", "dirA/linkC/linkD/", "dirB/linkD/", "dirC/dirD/"])
+        _check(p, "dir*/*/**/..", ["dirA/linkC/..", "dirA/linkC/linkD/..",
+                                   "dirB/linkD/..", "dirC/dirD/.."])
+        _check(p, "dir*/**/fileC", ["dirC/fileC"])
+        _check(p, "dir*/*/../dirD/**/", ["dirC/dirD/../dirD/"])
+        _check(p, "*/dirD/**", ["dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "*/dirD/**/", ["dirC/dirD/"])
+
+    def test_rglob_recurse_symlinks_false(self):
+        def _check(path, glob, expected):
+            actual = set(path.rglob(glob, recurse_symlinks=False))
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        it = p.rglob("fileA")
+        self.assertIsInstance(it, collections.abc.Iterator)
+        _check(p, "fileA", ["fileA"])
+        _check(p, "fileB", ["dirB/fileB"])
+        _check(p, "**/fileB", ["dirB/fileB"])
+        _check(p, "*/fileA", [])
+
+        if self.can_symlink:
+            _check(p, "*/fileB", ["dirB/fileB", "dirB/linkD/fileB",
+                                  "linkB/fileB", "dirA/linkC/fileB"])
+            _check(p, "*/", [
+                "dirA/", "dirA/linkC/", "dirB/", "dirB/linkD/", "dirC/",
+                "dirC/dirD/", "dirE/", "linkB/"])
+        else:
+            _check(p, "*/fileB", ["dirB/fileB"])
+            _check(p, "*/", ["dirA/", "dirB/", "dirC/", "dirC/dirD/", "dirE/"])
+
+        _check(p, "file*", ["fileA", "dirB/fileB", "dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "", ["", "dirA/", "dirB/", "dirC/", "dirE/", "dirC/dirD/"])
+        p = P(self.base, "dirC")
+        _check(p, "*", ["dirC/fileC", "dirC/novel.txt",
+                              "dirC/dirD", "dirC/dirD/fileD"])
+        _check(p, "file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "**/file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "dir*/**", ["dirC/dirD/", "dirC/dirD/fileD"])
+        _check(p, "dir*/**/", ["dirC/dirD/"])
+        _check(p, "*/*", ["dirC/dirD/fileD"])
+        _check(p, "*/", ["dirC/dirD/"])
+        _check(p, "", ["dirC/", "dirC/dirD/"])
+        _check(p, "**", ["dirC/", "dirC/fileC", "dirC/dirD", "dirC/dirD/fileD", "dirC/novel.txt"])
+        _check(p, "**/", ["dirC/", "dirC/dirD/"])
+        # gh-91616, a re module regression
+        _check(p, "*.txt", ["dirC/novel.txt"])
+        _check(p, "*.*", ["dirC/novel.txt"])
+
+    @needs_posix
+    def test_rglob_posix(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        q = p / "dirD" / "FILEd"
+        given = set(p.rglob("FILEd"))
+        expect = {q} if q.exists() else set()
+        self.assertEqual(given, expect)
+        self.assertEqual(set(p.rglob("FILEd*")), set())
+
+    @needs_windows
+    def test_rglob_windows(self):
+        P = self.cls
+        p = P(self.base, "dirC")
+        self.assertEqual(set(p.rglob("FILEd")), { P(self.base, "dirC/dirD/fileD") })
+        self.assertEqual(set(p.rglob("*\\")), { P(self.base, "dirC/dirD/") })
+
+    @needs_symlinks
+    def test_rglob_recurse_symlinks_common(self):
+        def _check(path, glob, expected):
+            actual = {path for path in path.rglob(glob, recurse_symlinks=True)
+                      if path.parts.count("linkD") <= 1}  # exclude symlink loop.
+            self.assertEqual(actual, { P(self.base, q) for q in expected })
+        P = self.cls
+        p = P(self.base)
+        _check(p, "fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB",
+                            "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB"])
+        _check(p, "*/fileA", [])
+        _check(p, "*/fileB", ["dirB/fileB", "dirA/linkC/fileB", "linkB/fileB",
+                              "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB"])
+        _check(p, "file*", ["fileA", "dirA/linkC/fileB", "dirB/fileB",
+                            "dirA/linkC/linkD/fileB", "dirB/linkD/fileB", "linkB/linkD/fileB",
+                            "dirC/fileC", "dirC/dirD/fileD", "linkB/fileB"])
+        _check(p, "*/", ["dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                         "dirC/", "dirC/dirD/", "dirE/", "linkB/", "linkB/linkD/"])
+        _check(p, "", ["", "dirA/", "dirA/linkC/", "dirA/linkC/linkD/", "dirB/", "dirB/linkD/",
+                       "dirC/", "dirE/", "dirC/dirD/", "linkB/", "linkB/linkD/"])
+
+        p = P(self.base, "dirC")
+        _check(p, "*", ["dirC/fileC", "dirC/novel.txt",
+                        "dirC/dirD", "dirC/dirD/fileD"])
+        _check(p, "file*", ["dirC/fileC", "dirC/dirD/fileD"])
+        _check(p, "*/*", ["dirC/dirD/fileD"])
+        _check(p, "*/", ["dirC/dirD/"])
+        _check(p, "", ["dirC/", "dirC/dirD/"])
+        # gh-91616, a re module regression
+        _check(p, "*.txt", ["dirC/novel.txt"])
+        _check(p, "*.*", ["dirC/novel.txt"])
+
+    @needs_symlinks
+    def test_rglob_symlink_loop(self):
+        # Don't get fooled by symlink loops (Issue #26012).
+        P = self.cls
+        p = P(self.base)
+        given = set(p.rglob('*', recurse_symlinks=False))
+        expect = {'brokenLink',
+                  'dirA', 'dirA/linkC',
+                  'dirB', 'dirB/fileB', 'dirB/linkD',
+                  'dirC', 'dirC/dirD', 'dirC/dirD/fileD',
+                  'dirC/fileC', 'dirC/novel.txt',
+                  'dirE',
+                  'fileA',
+                  'linkA',
+                  'linkB',
+                  'brokenLinkLoop',
+                  }
+        self.assertEqual(given, {p / x for x in expect})
+
+    # See https://github.com/WebAssembly/wasi-filesystem/issues/26
+    @unittest.skipIf(is_wasi, "WASI resolution of '..' parts doesn't match POSIX")
+    def test_glob_dotdot(self):
+        # ".." is not special in globs.
+        P = self.cls
+        p = P(self.base)
+        self.assertEqual(set(p.glob("..")), { P(self.base, "..") })
+        self.assertEqual(set(p.glob("../..")), { P(self.base, "..", "..") })
+        self.assertEqual(set(p.glob("dirA/..")), { P(self.base, "dirA", "..") })
+        self.assertEqual(set(p.glob("dirA/../file*")), { P(self.base, "dirA/../fileA") })
+        self.assertEqual(set(p.glob("dirA/../file*/..")), set())
+        self.assertEqual(set(p.glob("../xyzzy")), set())
+        if self.cls.parser is posixpath:
+            self.assertEqual(set(p.glob("xyzzy/..")), set())
+        else:
+            # ".." segments are normalized first on Windows, so this path is stat()able.
+            self.assertEqual(set(p.glob("xyzzy/..")), { P(self.base, "xyzzy", "..") })
+        self.assertEqual(set(p.glob("/".join([".."] * 50))), { P(self.base, *[".."] * 50)})
+
+    @needs_symlinks
+    def test_glob_permissions(self):
+        # See bpo-38894
+        P = self.cls
+        base = P(self.base) / 'permissions'
+        base.mkdir()
+
+        for i in range(100):
+            link = base / f"link{i}"
+            if i % 2:
+                link.symlink_to(P(self.base, "dirE", "nonexistent"))
+            else:
+                link.symlink_to(P(self.base, "dirC"))
+
+        self.assertEqual(len(set(base.glob("*"))), 100)
+        self.assertEqual(len(set(base.glob("*/"))), 50)
+        self.assertEqual(len(set(base.glob("*/fileC"))), 50)
+        self.assertEqual(len(set(base.glob("*/file*"))), 50)
+
+    @needs_symlinks
+    def test_glob_long_symlink(self):
+        # See gh-87695
+        base = self.cls(self.base) / 'long_symlink'
+        base.mkdir()
+        bad_link = base / 'bad_link'
+        bad_link.symlink_to("bad" * 200)
+        self.assertEqual(sorted(base.glob('**/*')), [bad_link])
+
+    @needs_symlinks
+    def test_readlink(self):
+        P = self.cls(self.base)
+        self.assertEqual((P / 'linkA').readlink(), self.cls('fileA'))
+        self.assertEqual((P / 'brokenLink').readlink(),
+                         self.cls('non-existing'))
+        self.assertEqual((P / 'linkB').readlink(), self.cls('dirB'))
+        self.assertEqual((P / 'linkB' / 'linkD').readlink(), self.cls('../dirB'))
+        with self.assertRaises(OSError):
+            (P / 'fileA').readlink()
+
+    @unittest.skipIf(hasattr(os, "readlink"), "os.readlink() is present")
+    def test_readlink_unsupported(self):
+        P = self.cls(self.base)
+        p = P / 'fileA'
+        with self.assertRaises(UnsupportedOperation):
+            q.readlink(p)
+
+    def _check_resolve(self, p, expected, strict=True):
+        q = p.resolve(strict)
+        self.assertEqual(q, expected)
+
+    # This can be used to check both relative and absolute resolutions.
+    _check_resolve_relative = _check_resolve_absolute = _check_resolve
+
+    @needs_symlinks
+    def test_resolve_common(self):
+        P = self.cls
+        p = P(self.base, 'foo')
+        with self.assertRaises(OSError) as cm:
+            p.resolve(strict=True)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        # Non-strict
+        parser = self.parser
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(self.base, 'foo'))
+        p = P(self.base, 'foo', 'in', 'spam')
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(self.base, 'foo', 'in', 'spam'))
+        p = P(self.base, '..', 'foo', 'in', 'spam')
+        self.assertEqualNormCase(str(p.resolve(strict=False)),
+                                 parser.join(parser.dirname(self.base), 'foo', 'in', 'spam'))
+        # These are all relative symlinks.
+        p = P(self.base, 'dirB', 'fileB')
+        self._check_resolve_relative(p, p)
+        p = P(self.base, 'linkA')
+        self._check_resolve_relative(p, P(self.base, 'fileA'))
+        p = P(self.base, 'dirA', 'linkC', 'fileB')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB'))
+        p = P(self.base, 'dirB', 'linkD', 'fileB')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB'))
+        # Non-strict
+        p = P(self.base, 'dirA', 'linkC', 'fileB', 'foo', 'in', 'spam')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'fileB', 'foo', 'in',
+                                          'spam'), False)
+        p = P(self.base, 'dirA', 'linkC', '..', 'foo', 'in', 'spam')
+        if self.cls.parser is not posixpath:
+            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
+            # resolves to 'dirA' without resolving linkY first.
+            self._check_resolve_relative(p, P(self.base, 'dirA', 'foo', 'in',
+                                              'spam'), False)
+        else:
+            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
+            # resolves to 'dirB/..' first before resolving to parent of dirB.
+            self._check_resolve_relative(p, P(self.base, 'foo', 'in', 'spam'), False)
+        # Now create absolute symlinks.
+        d = self.tempdir()
+        P(self.base, 'dirA', 'linkX').symlink_to(d)
+        P(self.base, str(d), 'linkY').symlink_to(self.parser.join(self.base, 'dirB'))
+        p = P(self.base, 'dirA', 'linkX', 'linkY', 'fileB')
+        self._check_resolve_absolute(p, P(self.base, 'dirB', 'fileB'))
+        # Non-strict
+        p = P(self.base, 'dirA', 'linkX', 'linkY', 'foo', 'in', 'spam')
+        self._check_resolve_relative(p, P(self.base, 'dirB', 'foo', 'in', 'spam'),
+                                     False)
+        p = P(self.base, 'dirA', 'linkX', 'linkY', '..', 'foo', 'in', 'spam')
+        if self.cls.parser is not posixpath:
+            # In Windows, if linkY points to dirB, 'dirA\linkY\..'
+            # resolves to 'dirA' without resolving linkY first.
+            self._check_resolve_relative(p, P(d, 'foo', 'in', 'spam'), False)
+        else:
+            # In Posix, if linkY points to dirB, 'dirA/linkY/..'
+            # resolves to 'dirB/..' first before resolving to parent of dirB.
+            self._check_resolve_relative(p, P(self.base, 'foo', 'in', 'spam'), False)
+
+    @needs_symlinks
+    def test_resolve_dot(self):
+        # See http://web.archive.org/web/20200623062557/https://bitbucket.org/pitrou/pathlib/issues/9/
+        parser = self.parser
+        p = self.cls(self.base)
+        p.joinpath('0').symlink_to('.', target_is_directory=True)
+        p.joinpath('1').symlink_to(parser.join('0', '0'), target_is_directory=True)
+        p.joinpath('2').symlink_to(parser.join('1', '1'), target_is_directory=True)
+        q = p / '2'
+        self.assertEqual(q.resolve(strict=True), p)
+        r = q / '3' / '4'
+        self.assertRaises(FileNotFoundError, r.resolve, strict=True)
+        # Non-strict
+        self.assertEqual(r.resolve(strict=False), p / '3' / '4')
+
+    def _check_symlink_loop(self, *args):
+        path = self.cls(*args)
+        with self.assertRaises(OSError) as cm:
+            path.resolve(strict=True)
+        self.assertEqual(cm.exception.errno, errno.ELOOP)
+
+    @needs_posix
+    @needs_symlinks
+    def test_resolve_loop(self):
+        # Loops with relative symlinks.
+        self.cls(self.base, 'linkX').symlink_to('linkX/inside')
+        self._check_symlink_loop(self.base, 'linkX')
+        self.cls(self.base, 'linkY').symlink_to('linkY')
+        self._check_symlink_loop(self.base, 'linkY')
+        self.cls(self.base, 'linkZ').symlink_to('linkZ/../linkZ')
+        self._check_symlink_loop(self.base, 'linkZ')
+        # Non-strict
+        p = self.cls(self.base, 'linkZ', 'foo')
+        self.assertEqual(p.resolve(strict=False), p)
+        # Loops with absolute symlinks.
+        self.cls(self.base, 'linkU').symlink_to(self.parser.join(self.base, 'linkU/inside'))
+        self._check_symlink_loop(self.base, 'linkU')
+        self.cls(self.base, 'linkV').symlink_to(self.parser.join(self.base, 'linkV'))
+        self._check_symlink_loop(self.base, 'linkV')
+        self.cls(self.base, 'linkW').symlink_to(self.parser.join(self.base, 'linkW/../linkW'))
+        self._check_symlink_loop(self.base, 'linkW')
+        # Non-strict
+        q = self.cls(self.base, 'linkW', 'foo')
+        self.assertEqual(q.resolve(strict=False), q)
+
+    def test_stat(self):
+        statA = self.cls(self.base).joinpath('fileA').stat()
+        statB = self.cls(self.base).joinpath('dirB', 'fileB').stat()
+        statC = self.cls(self.base).joinpath('dirC').stat()
+        # st_mode: files are the same, directory differs.
+        self.assertIsInstance(statA.st_mode, int)
+        self.assertEqual(statA.st_mode, statB.st_mode)
+        self.assertNotEqual(statA.st_mode, statC.st_mode)
+        self.assertNotEqual(statB.st_mode, statC.st_mode)
+        # st_ino: all different,
+        self.assertIsInstance(statA.st_ino, int)
+        self.assertNotEqual(statA.st_ino, statB.st_ino)
+        self.assertNotEqual(statA.st_ino, statC.st_ino)
+        self.assertNotEqual(statB.st_ino, statC.st_ino)
+        # st_dev: all the same.
+        self.assertIsInstance(statA.st_dev, int)
+        self.assertEqual(statA.st_dev, statB.st_dev)
+        self.assertEqual(statA.st_dev, statC.st_dev)
+        # other attributes not used by pathlib.
+
+    @needs_symlinks
+    def test_stat_no_follow_symlinks(self):
+        p = self.cls(self.base) / 'linkA'
+        st = p.stat()
+        self.assertNotEqual(st, p.stat(follow_symlinks=False))
+
+    def test_stat_no_follow_symlinks_nosymlink(self):
+        p = self.cls(self.base) / 'fileA'
+        st = p.stat()
+        self.assertEqual(st, p.stat(follow_symlinks=False))
+
+    @needs_symlinks
+    def test_lstat(self):
+        p = self.cls(self.base)/ 'linkA'
+        st = p.stat()
+        self.assertNotEqual(st, p.lstat())
+
+    def test_lstat_nosymlink(self):
+        p = self.cls(self.base) / 'fileA'
+        st = p.stat()
+        self.assertEqual(st, p.lstat())
+
+    def test_is_dir(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'dirA').is_dir())
+        self.assertFalse((P / 'fileA').is_dir())
+        self.assertFalse((P / 'non-existing').is_dir())
+        self.assertFalse((P / 'fileA' / 'bah').is_dir())
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_dir())
+            self.assertTrue((P / 'linkB').is_dir())
+            self.assertFalse((P/ 'brokenLink').is_dir())
+        self.assertFalse((P / 'dirA\udfff').is_dir())
+        self.assertFalse((P / 'dirA\x00').is_dir())
+
+    def test_is_dir_no_follow_symlinks(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'dirA').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'fileA').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'non-existing').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'fileA' / 'bah').is_dir(follow_symlinks=False))
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_dir(follow_symlinks=False))
+            self.assertFalse((P / 'linkB').is_dir(follow_symlinks=False))
+            self.assertFalse((P/ 'brokenLink').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'dirA\udfff').is_dir(follow_symlinks=False))
+        self.assertFalse((P / 'dirA\x00').is_dir(follow_symlinks=False))
+
+    def test_is_file(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'fileA').is_file())
+        self.assertFalse((P / 'dirA').is_file())
+        self.assertFalse((P / 'non-existing').is_file())
+        self.assertFalse((P / 'fileA' / 'bah').is_file())
+        if self.can_symlink:
+            self.assertTrue((P / 'linkA').is_file())
+            self.assertFalse((P / 'linkB').is_file())
+            self.assertFalse((P/ 'brokenLink').is_file())
+        self.assertFalse((P / 'fileA\udfff').is_file())
+        self.assertFalse((P / 'fileA\x00').is_file())
+
+    def test_is_file_no_follow_symlinks(self):
+        P = self.cls(self.base)
+        self.assertTrue((P / 'fileA').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'dirA').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'non-existing').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA' / 'bah').is_file(follow_symlinks=False))
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_file(follow_symlinks=False))
+            self.assertFalse((P / 'linkB').is_file(follow_symlinks=False))
+            self.assertFalse((P/ 'brokenLink').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA\udfff').is_file(follow_symlinks=False))
+        self.assertFalse((P / 'fileA\x00').is_file(follow_symlinks=False))
+
+    def test_is_mount(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_mount())
+        self.assertFalse((P / 'dirA').is_mount())
+        self.assertFalse((P / 'non-existing').is_mount())
+        self.assertFalse((P / 'fileA' / 'bah').is_mount())
+        if self.can_symlink:
+            self.assertFalse((P / 'linkA').is_mount())
+
+    def test_is_symlink(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_symlink())
+        self.assertFalse((P / 'dirA').is_symlink())
+        self.assertFalse((P / 'non-existing').is_symlink())
+        self.assertFalse((P / 'fileA' / 'bah').is_symlink())
+        if self.can_symlink:
+            self.assertTrue((P / 'linkA').is_symlink())
+            self.assertTrue((P / 'linkB').is_symlink())
+            self.assertTrue((P/ 'brokenLink').is_symlink())
+        self.assertIs((P / 'fileA\udfff').is_file(), False)
+        self.assertIs((P / 'fileA\x00').is_file(), False)
+        if self.can_symlink:
+            self.assertIs((P / 'linkA\udfff').is_file(), False)
+            self.assertIs((P / 'linkA\x00').is_file(), False)
+
+    def test_is_junction_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_junction())
+        self.assertFalse((P / 'dirA').is_junction())
+        self.assertFalse((P / 'non-existing').is_junction())
+        self.assertFalse((P / 'fileA' / 'bah').is_junction())
+        self.assertFalse((P / 'fileA\udfff').is_junction())
+        self.assertFalse((P / 'fileA\x00').is_junction())
+
+    def test_is_fifo_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_fifo())
+        self.assertFalse((P / 'dirA').is_fifo())
+        self.assertFalse((P / 'non-existing').is_fifo())
+        self.assertFalse((P / 'fileA' / 'bah').is_fifo())
+        self.assertIs((P / 'fileA\udfff').is_fifo(), False)
+        self.assertIs((P / 'fileA\x00').is_fifo(), False)
+
+    def test_is_socket_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_socket())
+        self.assertFalse((P / 'dirA').is_socket())
+        self.assertFalse((P / 'non-existing').is_socket())
+        self.assertFalse((P / 'fileA' / 'bah').is_socket())
+        self.assertIs((P / 'fileA\udfff').is_socket(), False)
+        self.assertIs((P / 'fileA\x00').is_socket(), False)
+
+    def test_is_block_device_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_block_device())
+        self.assertFalse((P / 'dirA').is_block_device())
+        self.assertFalse((P / 'non-existing').is_block_device())
+        self.assertFalse((P / 'fileA' / 'bah').is_block_device())
+        self.assertIs((P / 'fileA\udfff').is_block_device(), False)
+        self.assertIs((P / 'fileA\x00').is_block_device(), False)
+
+    def test_is_char_device_false(self):
+        P = self.cls(self.base)
+        self.assertFalse((P / 'fileA').is_char_device())
+        self.assertFalse((P / 'dirA').is_char_device())
+        self.assertFalse((P / 'non-existing').is_char_device())
+        self.assertFalse((P / 'fileA' / 'bah').is_char_device())
+        self.assertIs((P / 'fileA\udfff').is_char_device(), False)
+        self.assertIs((P / 'fileA\x00').is_char_device(), False)
+
+    def _check_complex_symlinks(self, link0_target):
+        # Test solving a non-looping chain of symlinks (issue #19887).
+        parser = self.parser
+        P = self.cls(self.base)
+        P.joinpath('link1').symlink_to(parser.join('link0', 'link0'), target_is_directory=True)
+        P.joinpath('link2').symlink_to(parser.join('link1', 'link1'), target_is_directory=True)
+        P.joinpath('link3').symlink_to(parser.join('link2', 'link2'), target_is_directory=True)
+        P.joinpath('link0').symlink_to(link0_target, target_is_directory=True)
+
+        # Resolve absolute paths.
+        p = (P / 'link0').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link1').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link2').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+        p = (P / 'link3').resolve()
+        self.assertEqual(p, P)
+        self.assertEqualNormCase(str(p), self.base)
+
+        # Resolve relative paths.
+        try:
+            self.cls('').absolute()
+        except UnsupportedOperation:
+            return
+        old_path = os.getcwd()
+        os.chdir(self.base)
+        try:
+            p = self.cls('link0').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link1').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link2').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+            p = self.cls('link3').resolve()
+            self.assertEqual(p, P)
+            self.assertEqualNormCase(str(p), self.base)
+        finally:
+            os.chdir(old_path)
+
+    @needs_symlinks
+    def test_complex_symlinks_absolute(self):
+        self._check_complex_symlinks(self.base)
+
+    @needs_symlinks
+    def test_complex_symlinks_relative(self):
+        self._check_complex_symlinks('.')
+
+    @needs_symlinks
+    def test_complex_symlinks_relative_dot_dot(self):
+        self._check_complex_symlinks(self.parser.join('dirA', '..'))
+
+    def setUpWalk(self):
+        # Build:
+        #     TESTFN/
+        #       TEST1/              a file kid and two directory kids
+        #         tmp1
+        #         SUB1/             a file kid and a directory kid
+        #           tmp2
+        #           SUB11/          no kids
+        #         SUB2/             a file kid and a dirsymlink kid
+        #           tmp3
+        #           link/           a symlink to TEST2
+        #           broken_link
+        #           broken_link2
+        #       TEST2/
+        #         tmp4              a lone file
+        self.walk_path = self.cls(self.base, "TEST1")
+        self.sub1_path = self.walk_path / "SUB1"
+        self.sub11_path = self.sub1_path / "SUB11"
+        self.sub2_path = self.walk_path / "SUB2"
+        tmp1_path = self.walk_path / "tmp1"
+        tmp2_path = self.sub1_path / "tmp2"
+        tmp3_path = self.sub2_path / "tmp3"
+        self.link_path = self.sub2_path / "link"
+        t2_path = self.cls(self.base, "TEST2")
+        tmp4_path = self.cls(self.base, "TEST2", "tmp4")
+        broken_link_path = self.sub2_path / "broken_link"
+        broken_link2_path = self.sub2_path / "broken_link2"
+
+        self.sub11_path.mkdir(parents=True)
+        self.sub2_path.mkdir(parents=True)
+        t2_path.mkdir(parents=True)
+
+        for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path:
+            with path.open("w", encoding='utf-8') as f:
+                f.write(f"I'm {path} and proud of it.  Blame test_pathlib.\n")
+
+        if self.can_symlink:
+            self.link_path.symlink_to(t2_path)
+            broken_link_path.symlink_to('broken')
+            broken_link2_path.symlink_to(self.cls('tmp3', 'broken'))
+            self.sub2_tree = (self.sub2_path, [], ["broken_link", "broken_link2", "link", "tmp3"])
+        else:
+            self.sub2_tree = (self.sub2_path, [], ["tmp3"])
+
+    def test_walk_topdown(self):
+        self.setUpWalk()
+        walker = self.walk_path.walk()
+        entry = next(walker)
+        entry[1].sort()  # Ensure we visit SUB1 before SUB2
+        self.assertEqual(entry, (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
+        entry = next(walker)
+        self.assertEqual(entry, (self.sub1_path, ["SUB11"], ["tmp2"]))
+        entry = next(walker)
+        self.assertEqual(entry, (self.sub11_path, [], []))
+        entry = next(walker)
+        entry[1].sort()
+        entry[2].sort()
+        self.assertEqual(entry, self.sub2_tree)
+        with self.assertRaises(StopIteration):
+            next(walker)
+
+    def test_walk_prune(self):
+        self.setUpWalk()
+        # Prune the search.
+        all = []
+        for root, dirs, files in self.walk_path.walk():
+            all.append((root, dirs, files))
+            if 'SUB1' in dirs:
+                # Note that this also mutates the dirs we appended to all!
+                dirs.remove('SUB1')
+
+        self.assertEqual(len(all), 2)
+        self.assertEqual(all[0], (self.walk_path, ["SUB2"], ["tmp1"]))
+
+        all[1][-1].sort()
+        all[1][1].sort()
+        self.assertEqual(all[1], self.sub2_tree)
+
+    def test_walk_bottom_up(self):
+        self.setUpWalk()
+        seen_testfn = seen_sub1 = seen_sub11 = seen_sub2 = False
+        for path, dirnames, filenames in self.walk_path.walk(top_down=False):
+            if path == self.walk_path:
+                self.assertFalse(seen_testfn)
+                self.assertTrue(seen_sub1)
+                self.assertTrue(seen_sub2)
+                self.assertEqual(sorted(dirnames), ["SUB1", "SUB2"])
+                self.assertEqual(filenames, ["tmp1"])
+                seen_testfn = True
+            elif path == self.sub1_path:
+                self.assertFalse(seen_testfn)
+                self.assertFalse(seen_sub1)
+                self.assertTrue(seen_sub11)
+                self.assertEqual(dirnames, ["SUB11"])
+                self.assertEqual(filenames, ["tmp2"])
+                seen_sub1 = True
+            elif path == self.sub11_path:
+                self.assertFalse(seen_sub1)
+                self.assertFalse(seen_sub11)
+                self.assertEqual(dirnames, [])
+                self.assertEqual(filenames, [])
+                seen_sub11 = True
+            elif path == self.sub2_path:
+                self.assertFalse(seen_testfn)
+                self.assertFalse(seen_sub2)
+                self.assertEqual(sorted(dirnames), sorted(self.sub2_tree[1]))
+                self.assertEqual(sorted(filenames), sorted(self.sub2_tree[2]))
+                seen_sub2 = True
+            else:
+                raise AssertionError(f"Unexpected path: {path}")
+        self.assertTrue(seen_testfn)
+
+    @needs_symlinks
+    def test_walk_follow_symlinks(self):
+        self.setUpWalk()
+        walk_it = self.walk_path.walk(follow_symlinks=True)
+        for root, dirs, files in walk_it:
+            if root == self.link_path:
+                self.assertEqual(dirs, [])
+                self.assertEqual(files, ["tmp4"])
+                break
+        else:
+            self.fail("Didn't follow symlink with follow_symlinks=True")
+
+    @needs_symlinks
+    def test_walk_symlink_location(self):
+        self.setUpWalk()
+        # Tests whether symlinks end up in filenames or dirnames depending
+        # on the `follow_symlinks` argument.
+        walk_it = self.walk_path.walk(follow_symlinks=False)
+        for root, dirs, files in walk_it:
+            if root == self.sub2_path:
+                self.assertIn("link", files)
+                break
+        else:
+            self.fail("symlink not found")
+
+        walk_it = self.walk_path.walk(follow_symlinks=True)
+        for root, dirs, files in walk_it:
+            if root == self.sub2_path:
+                self.assertIn("link", dirs)
+                break
+        else:
+            self.fail("symlink not found")
+
+
+class DummyPathWithSymlinks(DummyPath):
+    __slots__ = ()
+
+    # Reduce symlink traversal limit to make tests run faster.
+    _max_symlinks = 20
+
+    def readlink(self):
+        path = str(self.parent.resolve() / self.name)
+        if path in self._symlinks:
+            return self.with_segments(self._symlinks[path])
+        elif path in self._files or path in self._directories:
+            raise OSError(errno.EINVAL, "Not a symlink", path)
+        else:
+            raise FileNotFoundError(errno.ENOENT, "File not found", path)
+
+    def symlink_to(self, target, target_is_directory=False):
+        self._directories[str(self.parent)].add(self.name)
+        self._symlinks[str(self)] = str(target)
+
+
+class DummyPathWithSymlinksTest(DummyPathTest):
+    cls = DummyPathWithSymlinks
+    can_symlink = True
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_patma.py b/Lib/test/test_patma.py
new file mode 100644
index 0000000000..6ca1fa0ba4
--- /dev/null
+++ b/Lib/test/test_patma.py
@@ -0,0 +1,3571 @@
+import array
+import collections
+import dataclasses
+import dis
+import enum
+import inspect
+import sys
+import unittest
+
+
+@dataclasses.dataclass
+class Point:
+    x: int
+    y: int
+
+
+class TestCompiler(unittest.TestCase):
+
+    def test_refleaks(self):
+        # Hunting for leaks using -R doesn't catch leaks in the compiler itself,
+        # just the code under test. This test ensures that if there are leaks in
+        # the pattern compiler, those runs will fail:
+        with open(__file__) as file:
+            compile(file.read(), __file__, "exec")
+
+
+class TestInheritance(unittest.TestCase):
+
+    @staticmethod
+    def check_sequence_then_mapping(x):
+        match x:
+            case [*_]:
+                return "seq"
+            case {}:
+                return "map"
+
+    @staticmethod
+    def check_mapping_then_sequence(x):
+        match x:
+            case {}:
+                return "map"
+            case [*_]:
+                return "seq"
+
+    def test_multiple_inheritance_mapping(self):
+        class C:
+            pass
+        class M1(collections.UserDict, collections.abc.Sequence):
+            pass
+        class M2(C, collections.UserDict, collections.abc.Sequence):
+            pass
+        class M3(collections.UserDict, C, list):
+            pass
+        class M4(dict, collections.abc.Sequence, C):
+            pass
+        self.assertEqual(self.check_sequence_then_mapping(M1()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(M2()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(M3()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(M4()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(M1()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(M2()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(M3()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(M4()), "map")
+
+    def test_multiple_inheritance_sequence(self):
+        class C:
+            pass
+        class S1(collections.UserList, collections.abc.Mapping):
+            pass
+        class S2(C, collections.UserList, collections.abc.Mapping):
+            pass
+        class S3(list, C, collections.abc.Mapping):
+            pass
+        class S4(collections.UserList, dict, C):
+            pass
+        self.assertEqual(self.check_sequence_then_mapping(S1()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(S2()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(S3()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(S4()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(S1()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(S2()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(S3()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(S4()), "seq")
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_late_registration_mapping(self):
+        class Parent:
+            pass
+        class ChildPre(Parent):
+            pass
+        class GrandchildPre(ChildPre):
+            pass
+        collections.abc.Mapping.register(Parent)
+        class ChildPost(Parent):
+            pass
+        class GrandchildPost(ChildPost):
+            pass
+        self.assertEqual(self.check_sequence_then_mapping(Parent()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(ChildPre()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(GrandchildPre()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(ChildPost()), "map")
+        self.assertEqual(self.check_sequence_then_mapping(GrandchildPost()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(Parent()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(ChildPre()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(GrandchildPre()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(ChildPost()), "map")
+        self.assertEqual(self.check_mapping_then_sequence(GrandchildPost()), "map")
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_late_registration_sequence(self):
+        class Parent:
+            pass
+        class ChildPre(Parent):
+            pass
+        class GrandchildPre(ChildPre):
+            pass
+        collections.abc.Sequence.register(Parent)
+        class ChildPost(Parent):
+            pass
+        class GrandchildPost(ChildPost):
+            pass
+        self.assertEqual(self.check_sequence_then_mapping(Parent()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(ChildPre()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(GrandchildPre()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(ChildPost()), "seq")
+        self.assertEqual(self.check_sequence_then_mapping(GrandchildPost()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(Parent()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(ChildPre()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(GrandchildPre()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(ChildPost()), "seq")
+        self.assertEqual(self.check_mapping_then_sequence(GrandchildPost()), "seq")
+
+
+class TestPatma(unittest.TestCase):
+
+    def test_patma_000(self):
+        match 0:
+            case 0:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_001(self):
+        match 0:
+            case 0 if False:
+                x = False
+            case 0 if True:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_002(self):
+        match 0:
+            case 0:
+                x = True
+            case 0:
+                x = False
+        self.assertIs(x, True)
+
+    def test_patma_003(self):
+        x = False
+        match 0:
+            case 0 | 1 | 2 | 3:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_004(self):
+        x = False
+        match 1:
+            case 0 | 1 | 2 | 3:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_005(self):
+        x = False
+        match 2:
+            case 0 | 1 | 2 | 3:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_006(self):
+        x = False
+        match 3:
+            case 0 | 1 | 2 | 3:
+                x = True
+        self.assertIs(x, True)
+
+    def test_patma_007(self):
+        x = False
+        match 4:
+            case 0 | 1 | 2 | 3:
+                x = True
+        self.assertIs(x, False)
+
+    def test_patma_008(self):
+        x = 0
+        class A:
+            y = 1
+        match x:
+            case A.y as z:
+                pass
+        self.assertEqual(x, 0)
+        self.assertEqual(A.y, 1)
+
+    def test_patma_009(self):
+        class A:
+            B = 0
+        match 0:
+            case x if x:
+                z = 0
+            case _ as y if y == x and y:
+                z = 1
+            case A.B:
+                z = 2
+        self.assertEqual(A.B, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 2)
+
+    def test_patma_010(self):
+        match ():
+            case []:
+                x = 0
+        self.assertEqual(x, 0)
+
+    def test_patma_011(self):
+        match (0, 1, 2):
+            case [*x]:
+                y = 0
+        self.assertEqual(x, [0, 1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_012(self):
+        match (0, 1, 2):
+            case [0, *x]:
+                y = 0
+        self.assertEqual(x, [1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_013(self):
+        match (0, 1, 2):
+            case [0, 1, *x,]:
+                y = 0
+        self.assertEqual(x, [2])
+        self.assertEqual(y, 0)
+
+    def test_patma_014(self):
+        match (0, 1, 2):
+            case [0, 1, 2, *x]:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_015(self):
+        match (0, 1, 2):
+            case [*x, 2,]:
+                y = 0
+        self.assertEqual(x, [0, 1])
+        self.assertEqual(y, 0)
+
+    def test_patma_016(self):
+        match (0, 1, 2):
+            case [*x, 1, 2]:
+                y = 0
+        self.assertEqual(x, [0])
+        self.assertEqual(y, 0)
+
+    def test_patma_017(self):
+        match (0, 1, 2):
+            case [*x, 0, 1, 2,]:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_018(self):
+        match (0, 1, 2):
+            case [0, *x, 2]:
+                y = 0
+        self.assertEqual(x, [1])
+        self.assertEqual(y, 0)
+
+    def test_patma_019(self):
+        match (0, 1, 2):
+            case [0, 1, *x, 2,]:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_020(self):
+        match (0, 1, 2):
+            case [0, *x, 1, 2]:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_021(self):
+        match (0, 1, 2):
+            case [*x,]:
+                y = 0
+        self.assertEqual(x, [0, 1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_022(self):
+        x = {}
+        match x:
+            case {}:
+                y = 0
+        self.assertEqual(x, {})
+        self.assertEqual(y, 0)
+
+    def test_patma_023(self):
+        x = {0: 0}
+        match x:
+            case {}:
+                y = 0
+        self.assertEqual(x, {0: 0})
+        self.assertEqual(y, 0)
+
+    def test_patma_024(self):
+        x = {}
+        y = None
+        match x:
+            case {0: 0}:
+                y = 0
+        self.assertEqual(x, {})
+        self.assertIs(y, None)
+
+    def test_patma_025(self):
+        x = {0: 0}
+        match x:
+            case {0: (0 | 1 | 2 as z)}:
+                y = 0
+        self.assertEqual(x, {0: 0})
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_026(self):
+        x = {0: 1}
+        match x:
+            case {0: (0 | 1 | 2 as z)}:
+                y = 0
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 1)
+
+    def test_patma_027(self):
+        x = {0: 2}
+        match x:
+            case {0: (0 | 1 | 2 as z)}:
+                y = 0
+        self.assertEqual(x, {0: 2})
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 2)
+
+    def test_patma_028(self):
+        x = {0: 3}
+        y = None
+        match x:
+            case {0: (0 | 1 | 2 as z)}:
+                y = 0
+        self.assertEqual(x, {0: 3})
+        self.assertIs(y, None)
+
+    def test_patma_029(self):
+        x = {}
+        y = None
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: [1, 2, {}], 1: [[]]}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {})
+        self.assertIs(y, None)
+
+    def test_patma_030(self):
+        x = {False: (True, 2.0, {})}
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: [1, 2, {}], 1: [[]]}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {False: (True, 2.0, {})})
+        self.assertEqual(y, 0)
+
+    def test_patma_031(self):
+        x = {False: (True, 2.0, {}), 1: [[]], 2: 0}
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: [1, 2, {}], 1: [[]]}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {False: (True, 2.0, {}), 1: [[]], 2: 0})
+        self.assertEqual(y, 0)
+
+    def test_patma_032(self):
+        x = {False: (True, 2.0, {}), 1: [[]], 2: 0}
+        match x:
+            case {0: [1, 2]}:
+                y = 0
+            case {0: [1, 2, {}], 1: [[]]}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {False: (True, 2.0, {}), 1: [[]], 2: 0})
+        self.assertEqual(y, 1)
+
+    def test_patma_033(self):
+        x = []
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: [1, 2, {}], 1: [[]]}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, [])
+        self.assertEqual(y, 2)
+
+    def test_patma_034(self):
+        x = {0: 0}
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: ([1, 2, {}] | False)} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {0: 0})
+        self.assertEqual(y, 1)
+
+    def test_patma_035(self):
+        x = {0: 0}
+        match x:
+            case {0: [1, 2, {}]}:
+                y = 0
+            case {0: [1, 2, {}] | True} | {1: [[]]} | {0: [1, 2, {}]} | [] | "X" | {}:
+                y = 1
+            case []:
+                y = 2
+        self.assertEqual(x, {0: 0})
+        self.assertEqual(y, 1)
+
+    def test_patma_036(self):
+        x = 0
+        match x:
+            case 0 | 1 | 2:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_037(self):
+        x = 1
+        match x:
+            case 0 | 1 | 2:
+                y = 0
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 0)
+
+    def test_patma_038(self):
+        x = 2
+        match x:
+            case 0 | 1 | 2:
+                y = 0
+        self.assertEqual(x, 2)
+        self.assertEqual(y, 0)
+
+    def test_patma_039(self):
+        x = 3
+        y = None
+        match x:
+            case 0 | 1 | 2:
+                y = 0
+        self.assertEqual(x, 3)
+        self.assertIs(y, None)
+
+    def test_patma_040(self):
+        x = 0
+        match x:
+            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_041(self):
+        x = 1
+        match x:
+            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
+                y = 0
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 1)
+
+    def test_patma_042(self):
+        x = 2
+        y = None
+        match x:
+            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
+                y = 0
+        self.assertEqual(x, 2)
+        self.assertIs(y, None)
+        self.assertEqual(z, 2)
+
+    def test_patma_043(self):
+        x = 3
+        y = None
+        match x:
+            case (0 as z) | (1 as z) | (2 as z) if z == x % 2:
+                y = 0
+        self.assertEqual(x, 3)
+        self.assertIs(y, None)
+
+    def test_patma_044(self):
+        x = ()
+        match x:
+            case []:
+                y = 0
+        self.assertEqual(x, ())
+        self.assertEqual(y, 0)
+
+    def test_patma_045(self):
+        x = ()
+        match x:
+            case ():
+                y = 0
+        self.assertEqual(x, ())
+        self.assertEqual(y, 0)
+
+    def test_patma_046(self):
+        x = (0,)
+        match x:
+            case [0]:
+                y = 0
+        self.assertEqual(x, (0,))
+        self.assertEqual(y, 0)
+
+    def test_patma_047(self):
+        x = ((),)
+        match x:
+            case [[]]:
+                y = 0
+        self.assertEqual(x, ((),))
+        self.assertEqual(y, 0)
+
+    def test_patma_048(self):
+        x = [0, 1]
+        match x:
+            case [0, 1] | [1, 0]:
+                y = 0
+        self.assertEqual(x, [0, 1])
+        self.assertEqual(y, 0)
+
+    def test_patma_049(self):
+        x = [1, 0]
+        match x:
+            case [0, 1] | [1, 0]:
+                y = 0
+        self.assertEqual(x, [1, 0])
+        self.assertEqual(y, 0)
+
+    def test_patma_050(self):
+        x = [0, 0]
+        y = None
+        match x:
+            case [0, 1] | [1, 0]:
+                y = 0
+        self.assertEqual(x, [0, 0])
+        self.assertIs(y, None)
+
+    def test_patma_051(self):
+        w = None
+        x = [1, 0]
+        match x:
+            case [(0 as w)]:
+                y = 0
+            case [z] | [1, (0 | 1 as z)] | [z]:
+                y = 1
+        self.assertIs(w, None)
+        self.assertEqual(x, [1, 0])
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_052(self):
+        x = [1, 0]
+        match x:
+            case [0]:
+                y = 0
+            case [1, 0] if (x := x[:0]):
+                y = 1
+            case [1, 0]:
+                y = 2
+        self.assertEqual(x, [])
+        self.assertEqual(y, 2)
+
+    def test_patma_053(self):
+        x = {0}
+        y = None
+        match x:
+            case [0]:
+                y = 0
+        self.assertEqual(x, {0})
+        self.assertIs(y, None)
+
+    def test_patma_054(self):
+        x = set()
+        y = None
+        match x:
+            case []:
+                y = 0
+        self.assertEqual(x, set())
+        self.assertIs(y, None)
+
+    def test_patma_055(self):
+        x = iter([1, 2, 3])
+        y = None
+        match x:
+            case []:
+                y = 0
+        self.assertEqual([*x], [1, 2, 3])
+        self.assertIs(y, None)
+
+    def test_patma_056(self):
+        x = {}
+        y = None
+        match x:
+            case []:
+                y = 0
+        self.assertEqual(x, {})
+        self.assertIs(y, None)
+
+    def test_patma_057(self):
+        x = {0: False, 1: True}
+        y = None
+        match x:
+            case [0, 1]:
+                y = 0
+        self.assertEqual(x, {0: False, 1: True})
+        self.assertIs(y, None)
+
+    def test_patma_058(self):
+        x = 0
+        match x:
+            case 0:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_059(self):
+        x = 0
+        y = None
+        match x:
+            case False:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, None)
+
+    def test_patma_060(self):
+        x = 0
+        y = None
+        match x:
+            case 1:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_061(self):
+        x = 0
+        y = None
+        match x:
+            case None:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_062(self):
+        x = 0
+        match x:
+            case 0:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_063(self):
+        x = 0
+        y = None
+        match x:
+            case 1:
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_064(self):
+        x = "x"
+        match x:
+            case "x":
+                y = 0
+            case "y":
+                y = 1
+        self.assertEqual(x, "x")
+        self.assertEqual(y, 0)
+
+    def test_patma_065(self):
+        x = "x"
+        match x:
+            case "y":
+                y = 0
+            case "x":
+                y = 1
+        self.assertEqual(x, "x")
+        self.assertEqual(y, 1)
+
+    def test_patma_066(self):
+        x = "x"
+        match x:
+            case "":
+                y = 0
+            case "x":
+                y = 1
+        self.assertEqual(x, "x")
+        self.assertEqual(y, 1)
+
+    def test_patma_067(self):
+        x = b"x"
+        match x:
+            case b"y":
+                y = 0
+            case b"x":
+                y = 1
+        self.assertEqual(x, b"x")
+        self.assertEqual(y, 1)
+
+    def test_patma_068(self):
+        x = 0
+        match x:
+            case 0 if False:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_069(self):
+        x = 0
+        y = None
+        match x:
+            case 0 if 0:
+                y = 0
+            case 0 if 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_070(self):
+        x = 0
+        match x:
+            case 0 if True:
+                y = 0
+            case 0 if True:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_071(self):
+        x = 0
+        match x:
+            case 0 if 1:
+                y = 0
+            case 0 if 1:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_072(self):
+        x = 0
+        match x:
+            case 0 if True:
+                y = 0
+            case 0 if True:
+                y = 1
+        y = 2
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 2)
+
+    def test_patma_073(self):
+        x = 0
+        match x:
+            case 0 if 0:
+                y = 0
+            case 0 if 1:
+                y = 1
+        y = 2
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 2)
+
+    def test_patma_074(self):
+        x = 0
+        y = None
+        match x:
+            case 0 if not (x := 1):
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 1)
+        self.assertIs(y, None)
+
+    def test_patma_075(self):
+        x = "x"
+        match x:
+            case ["x"]:
+                y = 0
+            case "x":
+                y = 1
+        self.assertEqual(x, "x")
+        self.assertEqual(y, 1)
+
+    def test_patma_076(self):
+        x = b"x"
+        match x:
+            case [b"x"]:
+                y = 0
+            case ["x"]:
+                y = 1
+            case [120]:
+                y = 2
+            case b"x":
+                y = 4
+        self.assertEqual(x, b"x")
+        self.assertEqual(y, 4)
+
+    def test_patma_077(self):
+        x = bytearray(b"x")
+        y = None
+        match x:
+            case [120]:
+                y = 0
+            case 120:
+                y = 1
+        self.assertEqual(x, b"x")
+        self.assertIs(y, None)
+
+    def test_patma_078(self):
+        x = ""
+        match x:
+            case []:
+                y = 0
+            case [""]:
+                y = 1
+            case "":
+                y = 2
+        self.assertEqual(x, "")
+        self.assertEqual(y, 2)
+
+    def test_patma_079(self):
+        x = "xxx"
+        match x:
+            case ["x", "x", "x"]:
+                y = 0
+            case ["xxx"]:
+                y = 1
+            case "xxx":
+                y = 2
+        self.assertEqual(x, "xxx")
+        self.assertEqual(y, 2)
+
+    def test_patma_080(self):
+        x = b"xxx"
+        match x:
+            case [120, 120, 120]:
+                y = 0
+            case [b"xxx"]:
+                y = 1
+            case b"xxx":
+                y = 2
+        self.assertEqual(x, b"xxx")
+        self.assertEqual(y, 2)
+
+    def test_patma_081(self):
+        x = 0
+        match x:
+            case 0 if not (x := 1):
+                y = 0
+            case (0 as z):
+                y = 1
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_082(self):
+        x = 0
+        match x:
+            case (1 as z) if not (x := 1):
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_083(self):
+        x = 0
+        match x:
+            case (0 as z):
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_084(self):
+        x = 0
+        y = None
+        match x:
+            case (1 as z):
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_085(self):
+        x = 0
+        y = None
+        match x:
+            case (0 as z) if (w := 0):
+                y = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+        self.assertEqual(z, 0)
+
+    def test_patma_086(self):
+        x = 0
+        match x:
+            case ((0 as w) as z):
+                y = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_087(self):
+        x = 0
+        match x:
+            case (0 | 1) | 2:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_088(self):
+        x = 1
+        match x:
+            case (0 | 1) | 2:
+                y = 0
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 0)
+
+    def test_patma_089(self):
+        x = 2
+        match x:
+            case (0 | 1) | 2:
+                y = 0
+        self.assertEqual(x, 2)
+        self.assertEqual(y, 0)
+
+    def test_patma_090(self):
+        x = 3
+        y = None
+        match x:
+            case (0 | 1) | 2:
+                y = 0
+        self.assertEqual(x, 3)
+        self.assertIs(y, None)
+
+    def test_patma_091(self):
+        x = 0
+        match x:
+            case 0 | (1 | 2):
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_092(self):
+        x = 1
+        match x:
+            case 0 | (1 | 2):
+                y = 0
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 0)
+
+    def test_patma_093(self):
+        x = 2
+        match x:
+            case 0 | (1 | 2):
+                y = 0
+        self.assertEqual(x, 2)
+        self.assertEqual(y, 0)
+
+    def test_patma_094(self):
+        x = 3
+        y = None
+        match x:
+            case 0 | (1 | 2):
+                y = 0
+        self.assertEqual(x, 3)
+        self.assertIs(y, None)
+
+    def test_patma_095(self):
+        x = 0
+        match x:
+            case -0:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_096(self):
+        x = 0
+        match x:
+            case -0.0:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_097(self):
+        x = 0
+        match x:
+            case -0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_098(self):
+        x = 0
+        match x:
+            case -0.0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_099(self):
+        x = -1
+        match x:
+            case -1:
+                y = 0
+        self.assertEqual(x, -1)
+        self.assertEqual(y, 0)
+
+    def test_patma_100(self):
+        x = -1.5
+        match x:
+            case -1.5:
+                y = 0
+        self.assertEqual(x, -1.5)
+        self.assertEqual(y, 0)
+
+    def test_patma_101(self):
+        x = -1j
+        match x:
+            case -1j:
+                y = 0
+        self.assertEqual(x, -1j)
+        self.assertEqual(y, 0)
+
+    def test_patma_102(self):
+        x = -1.5j
+        match x:
+            case -1.5j:
+                y = 0
+        self.assertEqual(x, -1.5j)
+        self.assertEqual(y, 0)
+
+    def test_patma_103(self):
+        x = 0
+        match x:
+            case 0 + 0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_104(self):
+        x = 0
+        match x:
+            case 0 - 0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_105(self):
+        x = 0
+        match x:
+            case -0 + 0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_106(self):
+        x = 0
+        match x:
+            case -0 - 0j:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_107(self):
+        x = 0.25 + 1.75j
+        match x:
+            case 0.25 + 1.75j:
+                y = 0
+        self.assertEqual(x, 0.25 + 1.75j)
+        self.assertEqual(y, 0)
+
+    def test_patma_108(self):
+        x = 0.25 - 1.75j
+        match x:
+            case 0.25 - 1.75j:
+                y = 0
+        self.assertEqual(x, 0.25 - 1.75j)
+        self.assertEqual(y, 0)
+
+    def test_patma_109(self):
+        x = -0.25 + 1.75j
+        match x:
+            case -0.25 + 1.75j:
+                y = 0
+        self.assertEqual(x, -0.25 + 1.75j)
+        self.assertEqual(y, 0)
+
+    def test_patma_110(self):
+        x = -0.25 - 1.75j
+        match x:
+            case -0.25 - 1.75j:
+                y = 0
+        self.assertEqual(x, -0.25 - 1.75j)
+        self.assertEqual(y, 0)
+
+    def test_patma_111(self):
+        class A:
+            B = 0
+        x = 0
+        match x:
+            case A.B:
+                y = 0
+        self.assertEqual(A.B, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_112(self):
+        class A:
+            class B:
+                C = 0
+        x = 0
+        match x:
+            case A.B.C:
+                y = 0
+        self.assertEqual(A.B.C, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_113(self):
+        class A:
+            class B:
+                C = 0
+                D = 1
+        x = 1
+        match x:
+            case A.B.C:
+                y = 0
+            case A.B.D:
+                y = 1
+        self.assertEqual(A.B.C, 0)
+        self.assertEqual(A.B.D, 1)
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 1)
+
+    def test_patma_114(self):
+        class A:
+            class B:
+                class C:
+                    D = 0
+        x = 0
+        match x:
+            case A.B.C.D:
+                y = 0
+        self.assertEqual(A.B.C.D, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_115(self):
+        class A:
+            class B:
+                class C:
+                    D = 0
+                    E = 1
+        x = 1
+        match x:
+            case A.B.C.D:
+                y = 0
+            case A.B.C.E:
+                y = 1
+        self.assertEqual(A.B.C.D, 0)
+        self.assertEqual(A.B.C.E, 1)
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 1)
+
+    def test_patma_116(self):
+        match = case = 0
+        match match:
+            case case:
+                x = 0
+        self.assertEqual(match, 0)
+        self.assertEqual(case, 0)
+        self.assertEqual(x, 0)
+
+    def test_patma_117(self):
+        match = case = 0
+        match case:
+            case match:
+                x = 0
+        self.assertEqual(match, 0)
+        self.assertEqual(case, 0)
+        self.assertEqual(x, 0)
+
+    def test_patma_118(self):
+        x = []
+        match x:
+            case [*_, _]:
+                y = 0
+            case []:
+                y = 1
+        self.assertEqual(x, [])
+        self.assertEqual(y, 1)
+
+    def test_patma_119(self):
+        x = collections.defaultdict(int)
+        match x:
+            case {0: 0}:
+                y = 0
+            case {}:
+                y = 1
+        self.assertEqual(x, {})
+        self.assertEqual(y, 1)
+
+    def test_patma_120(self):
+        x = collections.defaultdict(int)
+        match x:
+            case {0: 0}:
+                y = 0
+            case {**z}:
+                y = 1
+        self.assertEqual(x, {})
+        self.assertEqual(y, 1)
+        self.assertEqual(z, {})
+
+    def test_patma_121(self):
+        match ():
+            case ():
+                x = 0
+        self.assertEqual(x, 0)
+
+    def test_patma_122(self):
+        match (0, 1, 2):
+            case (*x,):
+                y = 0
+        self.assertEqual(x, [0, 1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_123(self):
+        match (0, 1, 2):
+            case 0, *x:
+                y = 0
+        self.assertEqual(x, [1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_124(self):
+        match (0, 1, 2):
+            case (0, 1, *x,):
+                y = 0
+        self.assertEqual(x, [2])
+        self.assertEqual(y, 0)
+
+    def test_patma_125(self):
+        match (0, 1, 2):
+            case 0, 1, 2, *x:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_126(self):
+        match (0, 1, 2):
+            case *x, 2,:
+                y = 0
+        self.assertEqual(x, [0, 1])
+        self.assertEqual(y, 0)
+
+    def test_patma_127(self):
+        match (0, 1, 2):
+            case (*x, 1, 2):
+                y = 0
+        self.assertEqual(x, [0])
+        self.assertEqual(y, 0)
+
+    def test_patma_128(self):
+        match (0, 1, 2):
+            case *x, 0, 1, 2,:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_129(self):
+        match (0, 1, 2):
+            case (0, *x, 2):
+                y = 0
+        self.assertEqual(x, [1])
+        self.assertEqual(y, 0)
+
+    def test_patma_130(self):
+        match (0, 1, 2):
+            case 0, 1, *x, 2,:
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_131(self):
+        match (0, 1, 2):
+            case (0, *x, 1, 2):
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+
+    def test_patma_132(self):
+        match (0, 1, 2):
+            case *x,:
+                y = 0
+        self.assertEqual(x, [0, 1, 2])
+        self.assertEqual(y, 0)
+
+    def test_patma_133(self):
+        x = collections.defaultdict(int, {0: 1})
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 1
+            case {}:
+                y = 2
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 2)
+
+    def test_patma_134(self):
+        x = collections.defaultdict(int, {0: 1})
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 1
+            case {**z}:
+                y = 2
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 2)
+        self.assertEqual(z, {0: 1})
+
+    def test_patma_135(self):
+        x = collections.defaultdict(int, {0: 1})
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 1
+            case {0: _, **z}:
+                y = 2
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 2)
+        self.assertEqual(z, {})
+
+    def test_patma_136(self):
+        x = {0: 1}
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 0
+            case {}:
+                y = 1
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 1)
+
+    def test_patma_137(self):
+        x = {0: 1}
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 0
+            case {**z}:
+                y = 1
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 1)
+        self.assertEqual(z, {0: 1})
+
+    def test_patma_138(self):
+        x = {0: 1}
+        match x:
+            case {1: 0}:
+                y = 0
+            case {0: 0}:
+                y = 0
+            case {0: _, **z}:
+                y = 1
+        self.assertEqual(x, {0: 1})
+        self.assertEqual(y, 1)
+        self.assertEqual(z, {})
+
+    def test_patma_139(self):
+        x = False
+        match x:
+            case bool(z):
+                y = 0
+        self.assertIs(x, False)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_140(self):
+        x = True
+        match x:
+            case bool(z):
+                y = 0
+        self.assertIs(x, True)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_141(self):
+        x = bytearray()
+        match x:
+            case bytearray(z):
+                y = 0
+        self.assertEqual(x, bytearray())
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_142(self):
+        x = b""
+        match x:
+            case bytes(z):
+                y = 0
+        self.assertEqual(x, b"")
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_143(self):
+        x = {}
+        match x:
+            case dict(z):
+                y = 0
+        self.assertEqual(x, {})
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_144(self):
+        x = 0.0
+        match x:
+            case float(z):
+                y = 0
+        self.assertEqual(x, 0.0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_145(self):
+        x = frozenset()
+        match x:
+            case frozenset(z):
+                y = 0
+        self.assertEqual(x, frozenset())
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_146(self):
+        x = 0
+        match x:
+            case int(z):
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_147(self):
+        x = []
+        match x:
+            case list(z):
+                y = 0
+        self.assertEqual(x, [])
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_148(self):
+        x = set()
+        match x:
+            case set(z):
+                y = 0
+        self.assertEqual(x, set())
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_149(self):
+        x = ""
+        match x:
+            case str(z):
+                y = 0
+        self.assertEqual(x, "")
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_150(self):
+        x = ()
+        match x:
+            case tuple(z):
+                y = 0
+        self.assertEqual(x, ())
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_151(self):
+        x = 0
+        match x,:
+            case y,:
+                z = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, x)
+        self.assertIs(z, 0)
+
+    def test_patma_152(self):
+        w = 0
+        x = 0
+        match w, x:
+            case y, z:
+                v = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, 0)
+        self.assertIs(y, w)
+        self.assertIs(z, x)
+        self.assertEqual(v, 0)
+
+    def test_patma_153(self):
+        x = 0
+        match w := x,:
+            case y as v,:
+                z = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, x)
+        self.assertEqual(z, 0)
+        self.assertIs(w, x)
+        self.assertIs(v, y)
+
+    def test_patma_154(self):
+        x = 0
+        y = None
+        match x:
+            case 0 if x:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_155(self):
+        x = 0
+        y = None
+        match x:
+            case 1e1000:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_156(self):
+        x = 0
+        match x:
+            case z:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_157(self):
+        x = 0
+        y = None
+        match x:
+            case _ if x:
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_158(self):
+        x = 0
+        match x:
+            case -1e1000:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_159(self):
+        x = 0
+        match x:
+            case 0 if not x:
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_160(self):
+        x = 0
+        z = None
+        match x:
+            case 0:
+                y = 0
+            case z if x:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, None)
+
+    def test_patma_161(self):
+        x = 0
+        match x:
+            case 0:
+                y = 0
+            case _:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_162(self):
+        x = 0
+        match x:
+            case 1 if x:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_163(self):
+        x = 0
+        y = None
+        match x:
+            case 1:
+                y = 0
+            case 1 if not x:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_164(self):
+        x = 0
+        match x:
+            case 1:
+                y = 0
+            case z:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertIs(z, x)
+
+    def test_patma_165(self):
+        x = 0
+        match x:
+            case 1 if x:
+                y = 0
+            case _:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_166(self):
+        x = 0
+        match x:
+            case z if not z:
+                y = 0
+            case 0 if x:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_167(self):
+        x = 0
+        match x:
+            case z if not z:
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_168(self):
+        x = 0
+        match x:
+            case z if not x:
+                y = 0
+            case z:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_169(self):
+        x = 0
+        match x:
+            case z if not z:
+                y = 0
+            case _ if x:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, x)
+
+    def test_patma_170(self):
+        x = 0
+        match x:
+            case _ if not x:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_171(self):
+        x = 0
+        y = None
+        match x:
+            case _ if x:
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertIs(y, None)
+
+    def test_patma_172(self):
+        x = 0
+        z = None
+        match x:
+            case _ if not x:
+                y = 0
+            case z if not x:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertIs(z, None)
+
+    def test_patma_173(self):
+        x = 0
+        match x:
+            case _ if not x:
+                y = 0
+            case _:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_174(self):
+        def http_error(status):
+            match status:
+                case 400:
+                    return "Bad request"
+                case 401:
+                    return "Unauthorized"
+                case 403:
+                    return "Forbidden"
+                case 404:
+                    return "Not found"
+                case 418:
+                    return "I'm a teapot"
+                case _:
+                    return "Something else"
+        self.assertEqual(http_error(400), "Bad request")
+        self.assertEqual(http_error(401), "Unauthorized")
+        self.assertEqual(http_error(403), "Forbidden")
+        self.assertEqual(http_error(404), "Not found")
+        self.assertEqual(http_error(418), "I'm a teapot")
+        self.assertEqual(http_error(123), "Something else")
+        self.assertEqual(http_error("400"), "Something else")
+        self.assertEqual(http_error(401 | 403 | 404), "Something else")  # 407
+
+    def test_patma_175(self):
+        def http_error(status):
+            match status:
+                case 400:
+                    return "Bad request"
+                case 401 | 403 | 404:
+                    return "Not allowed"
+                case 418:
+                    return "I'm a teapot"
+        self.assertEqual(http_error(400), "Bad request")
+        self.assertEqual(http_error(401), "Not allowed")
+        self.assertEqual(http_error(403), "Not allowed")
+        self.assertEqual(http_error(404), "Not allowed")
+        self.assertEqual(http_error(418), "I'm a teapot")
+        self.assertIs(http_error(123), None)
+        self.assertIs(http_error("400"), None)
+        self.assertIs(http_error(401 | 403 | 404), None)  # 407
+
+    def test_patma_176(self):
+        def whereis(point):
+            match point:
+                case (0, 0):
+                    return "Origin"
+                case (0, y):
+                    return f"Y={y}"
+                case (x, 0):
+                    return f"X={x}"
+                case (x, y):
+                    return f"X={x}, Y={y}"
+                case _:
+                    return "Not a point"
+        self.assertEqual(whereis((0, 0)), "Origin")
+        self.assertEqual(whereis((0, -1.0)), "Y=-1.0")
+        self.assertEqual(whereis(("X", 0)), "X=X")
+        self.assertEqual(whereis((None, 1j)), "X=None, Y=1j")
+        self.assertEqual(whereis(42), "Not a point")
+
+    def test_patma_177(self):
+        def whereis(point):
+            match point:
+                case Point(0, 0):
+                    return "Origin"
+                case Point(0, y):
+                    return f"Y={y}"
+                case Point(x, 0):
+                    return f"X={x}"
+                case Point():
+                    return "Somewhere else"
+                case _:
+                    return "Not a point"
+        self.assertEqual(whereis(Point(1, 0)), "X=1")
+        self.assertEqual(whereis(Point(0, 0)), "Origin")
+        self.assertEqual(whereis(10), "Not a point")
+        self.assertEqual(whereis(Point(False, False)), "Origin")
+        self.assertEqual(whereis(Point(0, -1.0)), "Y=-1.0")
+        self.assertEqual(whereis(Point("X", 0)), "X=X")
+        self.assertEqual(whereis(Point(None, 1j)), "Somewhere else")
+        self.assertEqual(whereis(Point), "Not a point")
+        self.assertEqual(whereis(42), "Not a point")
+
+    def test_patma_178(self):
+        def whereis(point):
+            match point:
+                case Point(1, var):
+                    return var
+        self.assertEqual(whereis(Point(1, 0)), 0)
+        self.assertIs(whereis(Point(0, 0)), None)
+
+    def test_patma_179(self):
+        def whereis(point):
+            match point:
+                case Point(1, y=var):
+                    return var
+        self.assertEqual(whereis(Point(1, 0)), 0)
+        self.assertIs(whereis(Point(0, 0)), None)
+
+    def test_patma_180(self):
+        def whereis(point):
+            match point:
+                case Point(x=1, y=var):
+                    return var
+        self.assertEqual(whereis(Point(1, 0)), 0)
+        self.assertIs(whereis(Point(0, 0)), None)
+
+    def test_patma_181(self):
+        def whereis(point):
+            match point:
+                case Point(y=var, x=1):
+                    return var
+        self.assertEqual(whereis(Point(1, 0)), 0)
+        self.assertIs(whereis(Point(0, 0)), None)
+
+    def test_patma_182(self):
+        def whereis(points):
+            match points:
+                case []:
+                    return "No points"
+                case [Point(0, 0)]:
+                    return "The origin"
+                case [Point(x, y)]:
+                    return f"Single point {x}, {y}"
+                case [Point(0, y1), Point(0, y2)]:
+                    return f"Two on the Y axis at {y1}, {y2}"
+                case _:
+                    return "Something else"
+        self.assertEqual(whereis([]), "No points")
+        self.assertEqual(whereis([Point(0, 0)]), "The origin")
+        self.assertEqual(whereis([Point(0, 1)]), "Single point 0, 1")
+        self.assertEqual(whereis([Point(0, 0), Point(0, 0)]), "Two on the Y axis at 0, 0")
+        self.assertEqual(whereis([Point(0, 1), Point(0, 1)]), "Two on the Y axis at 1, 1")
+        self.assertEqual(whereis([Point(0, 0), Point(1, 0)]), "Something else")
+        self.assertEqual(whereis([Point(0, 0), Point(0, 0), Point(0, 0)]), "Something else")
+        self.assertEqual(whereis([Point(0, 1), Point(0, 1), Point(0, 1)]), "Something else")
+
+    def test_patma_183(self):
+        def whereis(point):
+            match point:
+                case Point(x, y) if x == y:
+                    return f"Y=X at {x}"
+                case Point(x, y):
+                    return "Not on the diagonal"
+        self.assertEqual(whereis(Point(0, 0)), "Y=X at 0")
+        self.assertEqual(whereis(Point(0, False)), "Y=X at 0")
+        self.assertEqual(whereis(Point(False, 0)), "Y=X at False")
+        self.assertEqual(whereis(Point(-1 - 1j, -1 - 1j)), "Y=X at (-1-1j)")
+        self.assertEqual(whereis(Point("X", "X")), "Y=X at X")
+        self.assertEqual(whereis(Point("X", "x")), "Not on the diagonal")
+
+    def test_patma_184(self):
+        class Seq(collections.abc.Sequence):
+            __getitem__ = None
+            def __len__(self):
+                return 0
+        match Seq():
+            case []:
+                y = 0
+        self.assertEqual(y, 0)
+
+    def test_patma_185(self):
+        class Seq(collections.abc.Sequence):
+            __getitem__ = None
+            def __len__(self):
+                return 42
+        match Seq():
+            case [*_]:
+                y = 0
+        self.assertEqual(y, 0)
+
+    def test_patma_186(self):
+        class Seq(collections.abc.Sequence):
+            def __getitem__(self, i):
+                return i
+            def __len__(self):
+                return 42
+        match Seq():
+            case [x, *_, y]:
+                z = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 41)
+        self.assertEqual(z, 0)
+
+    def test_patma_187(self):
+        w = range(10)
+        match w:
+            case [x, y, *rest]:
+                z = 0
+        self.assertEqual(w, range(10))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+        self.assertEqual(rest, list(range(2, 10)))
+
+    def test_patma_188(self):
+        w = range(100)
+        match w:
+            case (x, y, *rest):
+                z = 0
+        self.assertEqual(w, range(100))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+        self.assertEqual(rest, list(range(2, 100)))
+
+    def test_patma_189(self):
+        w = range(1000)
+        match w:
+            case x, y, *rest:
+                z = 0
+        self.assertEqual(w, range(1000))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+        self.assertEqual(rest, list(range(2, 1000)))
+
+    def test_patma_190(self):
+        w = range(1 << 10)
+        match w:
+            case [x, y, *_]:
+                z = 0
+        self.assertEqual(w, range(1 << 10))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_191(self):
+        w = range(1 << 20)
+        match w:
+            case (x, y, *_):
+                z = 0
+        self.assertEqual(w, range(1 << 20))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_192(self):
+        w = range(1 << 30)
+        match w:
+            case x, y, *_:
+                z = 0
+        self.assertEqual(w, range(1 << 30))
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_193(self):
+        x = {"bandwidth": 0, "latency": 1}
+        match x:
+            case {"bandwidth": b, "latency": l}:
+                y = 0
+        self.assertEqual(x, {"bandwidth": 0, "latency": 1})
+        self.assertIs(b, x["bandwidth"])
+        self.assertIs(l, x["latency"])
+        self.assertEqual(y, 0)
+
+    def test_patma_194(self):
+        x = {"bandwidth": 0, "latency": 1, "key": "value"}
+        match x:
+            case {"latency": l, "bandwidth": b}:
+                y = 0
+        self.assertEqual(x, {"bandwidth": 0, "latency": 1, "key": "value"})
+        self.assertIs(l, x["latency"])
+        self.assertIs(b, x["bandwidth"])
+        self.assertEqual(y, 0)
+
+    def test_patma_195(self):
+        x = {"bandwidth": 0, "latency": 1, "key": "value"}
+        match x:
+            case {"bandwidth": b, "latency": l, **rest}:
+                y = 0
+        self.assertEqual(x, {"bandwidth": 0, "latency": 1, "key": "value"})
+        self.assertIs(b, x["bandwidth"])
+        self.assertIs(l, x["latency"])
+        self.assertEqual(rest, {"key": "value"})
+        self.assertEqual(y, 0)
+
+    def test_patma_196(self):
+        x = {"bandwidth": 0, "latency": 1}
+        match x:
+            case {"latency": l, "bandwidth": b, **rest}:
+                y = 0
+        self.assertEqual(x, {"bandwidth": 0, "latency": 1})
+        self.assertIs(l, x["latency"])
+        self.assertIs(b, x["bandwidth"])
+        self.assertEqual(rest, {})
+        self.assertEqual(y, 0)
+
+    def test_patma_197(self):
+        w = [Point(-1, 0), Point(1, 2)]
+        match w:
+            case (Point(x1, y1), Point(x2, y2) as p2):
+                z = 0
+        self.assertEqual(w, [Point(-1, 0), Point(1, 2)])
+        self.assertIs(x1, w[0].x)
+        self.assertIs(y1, w[0].y)
+        self.assertIs(p2, w[1])
+        self.assertIs(x2, w[1].x)
+        self.assertIs(y2, w[1].y)
+        self.assertIs(z, 0)
+
+    def test_patma_198(self):
+        class Color(enum.Enum):
+            RED = 0
+            GREEN = 1
+            BLUE = 2
+        def f(color):
+            match color:
+                case Color.RED:
+                    return "I see red!"
+                case Color.GREEN:
+                    return "Grass is green"
+                case Color.BLUE:
+                    return "I'm feeling the blues :("
+        self.assertEqual(f(Color.RED), "I see red!")
+        self.assertEqual(f(Color.GREEN), "Grass is green")
+        self.assertEqual(f(Color.BLUE), "I'm feeling the blues :(")
+        self.assertIs(f(Color), None)
+        self.assertIs(f(0), None)
+        self.assertIs(f(1), None)
+        self.assertIs(f(2), None)
+        self.assertIs(f(3), None)
+        self.assertIs(f(False), None)
+        self.assertIs(f(True), None)
+        self.assertIs(f(2+0j), None)
+        self.assertIs(f(3.0), None)
+
+    def test_patma_199(self):
+        class Color(int, enum.Enum):
+            RED = 0
+            GREEN = 1
+            BLUE = 2
+        def f(color):
+            match color:
+                case Color.RED:
+                    return "I see red!"
+                case Color.GREEN:
+                    return "Grass is green"
+                case Color.BLUE:
+                    return "I'm feeling the blues :("
+        self.assertEqual(f(Color.RED), "I see red!")
+        self.assertEqual(f(Color.GREEN), "Grass is green")
+        self.assertEqual(f(Color.BLUE), "I'm feeling the blues :(")
+        self.assertIs(f(Color), None)
+        self.assertEqual(f(0), "I see red!")
+        self.assertEqual(f(1), "Grass is green")
+        self.assertEqual(f(2), "I'm feeling the blues :(")
+        self.assertIs(f(3), None)
+        self.assertEqual(f(False), "I see red!")
+        self.assertEqual(f(True), "Grass is green")
+        self.assertEqual(f(2+0j), "I'm feeling the blues :(")
+        self.assertIs(f(3.0), None)
+
+    def test_patma_200(self):
+        class Class:
+            __match_args__ = ("a", "b")
+        c = Class()
+        c.a = 0
+        c.b = 1
+        match c:
+            case Class(x, y):
+                z = 0
+        self.assertIs(x, c.a)
+        self.assertIs(y, c.b)
+        self.assertEqual(z, 0)
+
+    def test_patma_201(self):
+        class Class:
+            __match_args__ = ("a", "b")
+        c = Class()
+        c.a = 0
+        c.b = 1
+        match c:
+            case Class(x, b=y):
+                z = 0
+        self.assertIs(x, c.a)
+        self.assertIs(y, c.b)
+        self.assertEqual(z, 0)
+
+    def test_patma_202(self):
+        class Parent:
+            __match_args__ = "a", "b"
+        class Child(Parent):
+            __match_args__ = ("c", "d")
+        c = Child()
+        c.a = 0
+        c.b = 1
+        match c:
+            case Parent(x, y):
+                z = 0
+        self.assertIs(x, c.a)
+        self.assertIs(y, c.b)
+        self.assertEqual(z, 0)
+
+    def test_patma_203(self):
+        class Parent:
+            __match_args__ = ("a", "b")
+        class Child(Parent):
+            __match_args__ = "c", "d"
+        c = Child()
+        c.a = 0
+        c.b = 1
+        match c:
+            case Parent(x, b=y):
+                z = 0
+        self.assertIs(x, c.a)
+        self.assertIs(y, c.b)
+        self.assertEqual(z, 0)
+
+    def test_patma_204(self):
+        def f(w):
+            match w:
+                case 42:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(42), {})
+        self.assertIs(f(0), None)
+        self.assertEqual(f(42.0), {})
+        self.assertIs(f("42"), None)
+
+    def test_patma_205(self):
+        def f(w):
+            match w:
+                case 42.0:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(42.0), {})
+        self.assertEqual(f(42), {})
+        self.assertIs(f(0.0), None)
+        self.assertIs(f(0), None)
+
+    def test_patma_206(self):
+        def f(w):
+            match w:
+                case 1 | 2 | 3:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(1), {})
+        self.assertEqual(f(2), {})
+        self.assertEqual(f(3), {})
+        self.assertEqual(f(3.0), {})
+        self.assertIs(f(0), None)
+        self.assertIs(f(4), None)
+        self.assertIs(f("1"), None)
+
+    def test_patma_207(self):
+        def f(w):
+            match w:
+                case [1, 2] | [3, 4]:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f([1, 2]), {})
+        self.assertEqual(f([3, 4]), {})
+        self.assertIs(f(42), None)
+        self.assertIs(f([2, 3]), None)
+        self.assertIs(f([1, 2, 3]), None)
+        self.assertEqual(f([1, 2.0]), {})
+
+    def test_patma_208(self):
+        def f(w):
+            match w:
+                case x:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(42), {"x": 42})
+        self.assertEqual(f((1, 2)), {"x": (1, 2)})
+        self.assertEqual(f(None), {"x": None})
+
+    def test_patma_209(self):
+        def f(w):
+            match w:
+                case _:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(42), {})
+        self.assertEqual(f(None), {})
+        self.assertEqual(f((1, 2)), {})
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_patma_210(self):
+        def f(w):
+            match w:
+                case (x, y, z):
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f((1, 2, 3)), {"x": 1, "y": 2, "z": 3})
+        self.assertIs(f((1, 2)), None)
+        self.assertIs(f((1, 2, 3, 4)), None)
+        self.assertIs(f(123), None)
+        self.assertIs(f("abc"), None)
+        self.assertIs(f(b"abc"), None)
+        self.assertEqual(f(array.array("b", b"abc")), {'x': 97, 'y': 98, 'z': 99})
+        self.assertEqual(f(memoryview(b"abc")), {"x": 97, "y": 98, "z": 99})
+        self.assertIs(f(bytearray(b"abc")), None)
+
+    def test_patma_211(self):
+        def f(w):
+            match w:
+                case {"x": x, "y": "y", "z": z}:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f({"x": "x", "y": "y", "z": "z"}), {"x": "x", "z": "z"})
+        self.assertEqual(f({"x": "x", "y": "y", "z": "z", "a": "a"}), {"x": "x", "z": "z"})
+        self.assertIs(f(({"x": "x", "y": "yy", "z": "z", "a": "a"})), None)
+        self.assertIs(f(({"x": "x", "y": "y"})), None)
+
+    def test_patma_212(self):
+        def f(w):
+            match w:
+                case Point(int(xx), y="hello"):
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f(Point(42, "hello")), {"xx": 42})
+
+    def test_patma_213(self):
+        def f(w):
+            match w:
+                case (p, q) as x:
+                    out = locals()
+                    del out["w"]
+                    return out
+        self.assertEqual(f((1, 2)), {"p": 1, "q": 2, "x": (1, 2)})
+        self.assertEqual(f([1, 2]), {"p": 1, "q": 2, "x": [1, 2]})
+        self.assertIs(f(12), None)
+        self.assertIs(f((1, 2, 3)), None)
+
+    def test_patma_214(self):
+        def f():
+            match 42:
+                case 42:
+                    return locals()
+        self.assertEqual(set(f()), set())
+
+    def test_patma_215(self):
+        def f():
+            match 1:
+                case 1 | 2 | 3:
+                    return locals()
+        self.assertEqual(set(f()), set())
+
+    def test_patma_216(self):
+        def f():
+            match ...:
+                case _:
+                    return locals()
+        self.assertEqual(set(f()), set())
+
+    def test_patma_217(self):
+        def f():
+            match ...:
+                case abc:
+                    return locals()
+        self.assertEqual(set(f()), {"abc"})
+
+    def test_patma_218(self):
+        def f():
+            match ..., ...:
+                case a, b:
+                    return locals()
+        self.assertEqual(set(f()), {"a", "b"})
+
+    def test_patma_219(self):
+        def f():
+            match {"k": ..., "l": ...}:
+                case {"k": a, "l": b}:
+                    return locals()
+        self.assertEqual(set(f()), {"a", "b"})
+
+    def test_patma_220(self):
+        def f():
+            match Point(..., ...):
+                case Point(x, y=y):
+                    return locals()
+        self.assertEqual(set(f()), {"x", "y"})
+
+    def test_patma_221(self):
+        def f():
+            match ...:
+                case b as a:
+                    return locals()
+        self.assertEqual(set(f()), {"a", "b"})
+
+    def test_patma_222(self):
+        def f(x):
+            match x:
+                case _:
+                    return 0
+        self.assertEqual(f(0), 0)
+        self.assertEqual(f(1), 0)
+        self.assertEqual(f(2), 0)
+        self.assertEqual(f(3), 0)
+
+    def test_patma_223(self):
+        def f(x):
+            match x:
+                case 0:
+                    return 0
+        self.assertEqual(f(0), 0)
+        self.assertIs(f(1), None)
+        self.assertIs(f(2), None)
+        self.assertIs(f(3), None)
+
+    def test_patma_224(self):
+        def f(x):
+            match x:
+                case 0:
+                    return 0
+                case _:
+                    return 1
+        self.assertEqual(f(0), 0)
+        self.assertEqual(f(1), 1)
+        self.assertEqual(f(2), 1)
+        self.assertEqual(f(3), 1)
+
+    def test_patma_225(self):
+        def f(x):
+            match x:
+                case 0:
+                    return 0
+                case 1:
+                    return 1
+        self.assertEqual(f(0), 0)
+        self.assertEqual(f(1), 1)
+        self.assertIs(f(2), None)
+        self.assertIs(f(3), None)
+
+    def test_patma_226(self):
+        def f(x):
+            match x:
+                case 0:
+                    return 0
+                case 1:
+                    return 1
+                case _:
+                    return 2
+        self.assertEqual(f(0), 0)
+        self.assertEqual(f(1), 1)
+        self.assertEqual(f(2), 2)
+        self.assertEqual(f(3), 2)
+
+    def test_patma_227(self):
+        def f(x):
+            match x:
+                case 0:
+                    return 0
+                case 1:
+                    return 1
+                case 2:
+                    return 2
+        self.assertEqual(f(0), 0)
+        self.assertEqual(f(1), 1)
+        self.assertEqual(f(2), 2)
+        self.assertIs(f(3), None)
+
+    def test_patma_228(self):
+        match():
+            case():
+                x = 0
+        self.assertEqual(x, 0)
+
+    def test_patma_229(self):
+        x = 0
+        match(x):
+            case(x):
+                y = 0
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+
+    def test_patma_230(self):
+        x = 0
+        match x:
+            case False:
+                y = 0
+            case 0:
+                y = 1
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 1)
+
+    def test_patma_231(self):
+        x = 1
+        match x:
+            case True:
+                y = 0
+            case 1:
+                y = 1
+        self.assertEqual(x, 1)
+        self.assertEqual(y, 1)
+
+    def test_patma_232(self):
+        class Eq:
+            def __eq__(self, other):
+                return True
+        x = eq = Eq()
+        # None
+        y = None
+        match x:
+            case None:
+                y = 0
+        self.assertIs(x, eq)
+        self.assertEqual(y, None)
+        # True
+        y = None
+        match x:
+            case True:
+                y = 0
+        self.assertIs(x, eq)
+        self.assertEqual(y, None)
+        # False
+        y = None
+        match x:
+            case False:
+                y = 0
+        self.assertIs(x, eq)
+        self.assertEqual(y, None)
+
+    def test_patma_233(self):
+        x = False
+        match x:
+            case False:
+                y = 0
+        self.assertIs(x, False)
+        self.assertEqual(y, 0)
+
+    def test_patma_234(self):
+        x = True
+        match x:
+            case True:
+                y = 0
+        self.assertIs(x, True)
+        self.assertEqual(y, 0)
+
+    def test_patma_235(self):
+        x = None
+        match x:
+            case None:
+                y = 0
+        self.assertIs(x, None)
+        self.assertEqual(y, 0)
+
+    def test_patma_236(self):
+        x = 0
+        match x:
+            case (0 as w) as z:
+                y = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_237(self):
+        x = 0
+        match x:
+            case (0 as w) as z:
+                y = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 0)
+
+    def test_patma_238(self):
+        x = ((0, 1), (2, 3))
+        match x:
+            case ((a as b, c as d) as e) as w, ((f as g, h) as i) as z:
+                y = 0
+        self.assertEqual(a, 0)
+        self.assertEqual(b, 0)
+        self.assertEqual(c, 1)
+        self.assertEqual(d, 1)
+        self.assertEqual(e, (0, 1))
+        self.assertEqual(f, 2)
+        self.assertEqual(g, 2)
+        self.assertEqual(h, 3)
+        self.assertEqual(i, (2, 3))
+        self.assertEqual(w, (0, 1))
+        self.assertEqual(x, ((0, 1), (2, 3)))
+        self.assertEqual(y, 0)
+        self.assertEqual(z, (2, 3))
+
+    def test_patma_239(self):
+        x = collections.UserDict({0: 1, 2: 3})
+        match x:
+            case {2: 3}:
+                y = 0
+        self.assertEqual(x, {0: 1, 2: 3})
+        self.assertEqual(y, 0)
+
+    def test_patma_240(self):
+        x = collections.UserDict({0: 1, 2: 3})
+        match x:
+            case {2: 3, **z}:
+                y = 0
+        self.assertEqual(x, {0: 1, 2: 3})
+        self.assertEqual(y, 0)
+        self.assertEqual(z, {0: 1})
+
+    # TODO: RUSTPYTHON
+    # def test_patma_241(self):
+    #     x = [[{0: 0}]]
+    #     match x:
+    #         case list([({-0-0j: int(real=0+0j, imag=0-0j) | (1) as z},)]):
+    #             y = 0
+    #     self.assertEqual(x, [[{0: 0}]])
+    #     self.assertEqual(y, 0)
+    #     self.assertEqual(z, 0)
+
+    def test_patma_242(self):
+        x = range(3)
+        match x:
+            case [y, *_, z]:
+                w = 0
+        self.assertEqual(w, 0)
+        self.assertEqual(x, range(3))
+        self.assertEqual(y, 0)
+        self.assertEqual(z, 2)
+
+    def test_patma_243(self):
+        x = range(3)
+        match x:
+            case [_, *_, y]:
+                z = 0
+        self.assertEqual(x, range(3))
+        self.assertEqual(y, 2)
+        self.assertEqual(z, 0)
+
+    def test_patma_244(self):
+        x = range(3)
+        match x:
+            case [*_, y]:
+                z = 0
+        self.assertEqual(x, range(3))
+        self.assertEqual(y, 2)
+        self.assertEqual(z, 0)
+
+    def test_patma_245(self):
+        x = {"y": 1}
+        match x:
+            case {"y": (0 as y) | (1 as y)}:
+                z = 0
+        self.assertEqual(x, {"y": 1})
+        self.assertEqual(y, 1)
+        self.assertEqual(z, 0)
+
+    def test_patma_246(self):
+        def f(x):
+            match x:
+                case ((a, b, c, d, e, f, g, h, i, 9) |
+                      (h, g, i, a, b, d, e, c, f, 10) |
+                      (g, b, a, c, d, -5, e, h, i, f) |
+                      (-1, d, f, b, g, e, i, a, h, c)):
+                    w = 0
+            out = locals()
+            del out["x"]
+            return out
+        alts = [
+            dict(a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7, i=8, w=0),
+            dict(h=1, g=2, i=3, a=4, b=5, d=6, e=7, c=8, f=9, w=0),
+            dict(g=0, b=-1, a=-2, c=-3, d=-4, e=-6, h=-7, i=-8, f=-9, w=0),
+            dict(d=-2, f=-3, b=-4, g=-5, e=-6, i=-7, a=-8, h=-9, c=-10, w=0),
+            dict(),
+        ]
+        self.assertEqual(f(range(10)), alts[0])
+        self.assertEqual(f(range(1, 11)), alts[1])
+        self.assertEqual(f(range(0, -10, -1)), alts[2])
+        self.assertEqual(f(range(-1, -11, -1)), alts[3])
+        self.assertEqual(f(range(10, 20)), alts[4])
+
+    def test_patma_247(self):
+        def f(x):
+            match x:
+                case [y, (a, b, c, d, e, f, g, h, i, 9) |
+                         (h, g, i, a, b, d, e, c, f, 10) |
+                         (g, b, a, c, d, -5, e, h, i, f) |
+                         (-1, d, f, b, g, e, i, a, h, c), z]:
+                    w = 0
+            out = locals()
+            del out["x"]
+            return out
+        alts = [
+            dict(a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7, i=8, w=0, y=False, z=True),
+            dict(h=1, g=2, i=3, a=4, b=5, d=6, e=7, c=8, f=9, w=0, y=False, z=True),
+            dict(g=0, b=-1, a=-2, c=-3, d=-4, e=-6, h=-7, i=-8, f=-9, w=0, y=False, z=True),
+            dict(d=-2, f=-3, b=-4, g=-5, e=-6, i=-7, a=-8, h=-9, c=-10, w=0, y=False, z=True),
+            dict(),
+        ]
+        self.assertEqual(f((False, range(10), True)), alts[0])
+        self.assertEqual(f((False, range(1, 11), True)), alts[1])
+        self.assertEqual(f((False, range(0, -10, -1), True)), alts[2])
+        self.assertEqual(f((False, range(-1, -11, -1), True)), alts[3])
+        self.assertEqual(f((False, range(10, 20), True)), alts[4])
+
+    def test_patma_248(self):
+        class C(dict):
+            @staticmethod
+            def get(key, default=None):
+                return 'bar'
+
+        x = C({'foo': 'bar'})
+        match x:
+            case {'foo': bar}:
+                y = bar
+
+        self.assertEqual(y, 'bar')
+
+    def test_patma_249(self):
+        class C:
+            __attr = "eggs"  # mangled to _C__attr
+            _Outer__attr = "bacon"
+        class Outer:
+            def f(self, x):
+                match x:
+                    # looks up __attr, not _C__attr or _Outer__attr
+                    case C(__attr=y):
+                        return y
+        c = C()
+        setattr(c, "__attr", "spam")  # setattr is needed because we're in a class scope
+        self.assertEqual(Outer().f(c), "spam")
+
+    def test_patma_250(self):
+        def f(x):
+            match x:
+                case {"foo": y} if y >= 0:
+                    return True
+                case {"foo": y} if y < 0:
+                    return False
+
+        self.assertIs(f({"foo": 1}), True)
+        self.assertIs(f({"foo": -1}), False)
+
+    def test_patma_251(self):
+        def f(v, x):
+            match v:
+                case x.attr if x.attr >= 0:
+                    return True
+                case x.attr if x.attr < 0:
+                    return False
+                case _:
+                    return None
+
+        class X:
+            def __init__(self, attr):
+                self.attr = attr
+
+        self.assertIs(f(1, X(1)), True)
+        self.assertIs(f(-1, X(-1)), False)
+        self.assertIs(f(1, X(-1)), None)
+
+    def test_patma_252(self):
+        # Side effects must be possible in guards:
+        effects = []
+        def lt(x, y):
+            effects.append((x, y))
+            return x < y
+
+        res = None
+        match {"foo": 1}:
+            case {"foo": x} if lt(x, 0):
+                res = 0
+            case {"foo": x} if lt(x, 1):
+                res = 1
+            case {"foo": x} if lt(x, 2):
+                res = 2
+
+        self.assertEqual(res, 2)
+        self.assertEqual(effects, [(1, 0), (1, 1), (1, 2)])
+
+    def test_patma_253(self):
+        def f(v):
+            match v:
+                case [x] | x:
+                    return x
+
+        self.assertEqual(f(1), 1)
+        self.assertEqual(f([1]), 1)
+
+    def test_patma_254(self):
+        def f(v):
+            match v:
+                case {"x": x} | x:
+                    return x
+
+        self.assertEqual(f(1), 1)
+        self.assertEqual(f({"x": 1}), 1)
+
+    def test_patma_255(self):
+        x = []
+        match x:
+            case [] as z if z.append(None):
+                y = 0
+            case [None]:
+                y = 1
+        self.assertEqual(x, [None])
+        self.assertEqual(y, 1)
+        self.assertIs(z, x)
+
+    def test_patma_runtime_checkable_protocol(self):
+        # Runtime-checkable protocol
+        from typing import Protocol, runtime_checkable
+
+        @runtime_checkable
+        class P(Protocol):
+            x: int
+            y: int
+
+        class A:
+            def __init__(self, x: int, y: int):
+                self.x = x
+                self.y = y
+
+        class B(A): ...
+
+        for cls in (A, B):
+            with self.subTest(cls=cls.__name__):
+                inst = cls(1, 2)
+                w = 0
+                match inst:
+                    case P() as p:
+                        self.assertIsInstance(p, cls)
+                        self.assertEqual(p.x, 1)
+                        self.assertEqual(p.y, 2)
+                        w = 1
+                self.assertEqual(w, 1)
+
+                q = 0
+                match inst:
+                    case P(x=x, y=y):
+                        self.assertEqual(x, 1)
+                        self.assertEqual(y, 2)
+                        q = 1
+                self.assertEqual(q, 1)
+
+
+    def test_patma_generic_protocol(self):
+        # Runtime-checkable generic protocol
+        from typing import Generic, TypeVar, Protocol, runtime_checkable
+
+        T = TypeVar('T')  # not using PEP695 to be able to backport changes
+
+        @runtime_checkable
+        class P(Protocol[T]):
+            a: T
+            b: T
+
+        class A:
+            def __init__(self, x: int, y: int):
+                self.x = x
+                self.y = y
+
+        class G(Generic[T]):
+            def __init__(self, x: T, y: T):
+                self.x = x
+                self.y = y
+
+        for cls in (A, G):
+            with self.subTest(cls=cls.__name__):
+                inst = cls(1, 2)
+                w = 0
+                match inst:
+                    case P():
+                        w = 1
+                self.assertEqual(w, 0)
+
+    def test_patma_protocol_with_match_args(self):
+        # Runtime-checkable protocol with `__match_args__`
+        from typing import Protocol, runtime_checkable
+
+        # Used to fail before
+        # https://github.com/python/cpython/issues/110682
+        @runtime_checkable
+        class P(Protocol):
+            __match_args__ = ('x', 'y')
+            x: int
+            y: int
+
+        class A:
+            def __init__(self, x: int, y: int):
+                self.x = x
+                self.y = y
+
+        class B(A): ...
+
+        for cls in (A, B):
+            with self.subTest(cls=cls.__name__):
+                inst = cls(1, 2)
+                w = 0
+                match inst:
+                    case P() as p:
+                        self.assertIsInstance(p, cls)
+                        self.assertEqual(p.x, 1)
+                        self.assertEqual(p.y, 2)
+                        w = 1
+                self.assertEqual(w, 1)
+
+                q = 0
+                match inst:
+                    case P(x=x, y=y):
+                        self.assertEqual(x, 1)
+                        self.assertEqual(y, 2)
+                        q = 1
+                self.assertEqual(q, 1)
+
+                j = 0
+                match inst:
+                    case P(x=1, y=2):
+                        j = 1
+                self.assertEqual(j, 1)
+
+                g = 0
+                match inst:
+                    case P(x, y):
+                        self.assertEqual(x, 1)
+                        self.assertEqual(y, 2)
+                        g = 1
+                self.assertEqual(g, 1)
+
+                h = 0
+                match inst:
+                    case P(1, 2):
+                        h = 1
+                self.assertEqual(h, 1)
+
+
+class TestSyntaxErrors(unittest.TestCase):
+
+    def assert_syntax_error(self, code: str):
+        with self.assertRaises(SyntaxError):
+            compile(inspect.cleandoc(code), "<test>", "exec")
+
+    def test_alternative_patterns_bind_different_names_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case "a" | a:
+                pass
+        """)
+
+    def test_alternative_patterns_bind_different_names_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case [a, [b] | [c] | [d]]:
+                pass
+        """)
+
+
+    def test_attribute_name_repeated_in_class_pattern(self):
+        self.assert_syntax_error("""
+        match ...:
+            case Class(a=_, a=_):
+                pass
+        """)
+
+    def test_imaginary_number_required_in_complex_literal_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case 0+0:
+                pass
+        """)
+
+    def test_imaginary_number_required_in_complex_literal_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0+0: _}:
+                pass
+        """)
+
+    def test_invalid_syntax_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {**rest, "key": value}:
+                pass
+        """)
+
+    def test_invalid_syntax_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {"first": first, **rest, "last": last}:
+                pass
+        """)
+
+    def test_invalid_syntax_2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {**_}:
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_invalid_syntax_3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case 42 as _:
+                pass
+        """)
+
+    def test_len1_tuple_sequence_pattern_comma(self):
+        # correct syntax would be `case(*x,):`
+        self.assert_syntax_error("""
+        match ...:
+            case (*x):
+                pass
+        """)
+
+    def test_mapping_pattern_keys_may_only_match_literals_and_attribute_lookups(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {f"": _}:
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case a, a:
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {"k": a, "l": a}:
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case MyClass(x, x):
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case MyClass(x=x, y=x):
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_4(self):
+        self.assert_syntax_error("""
+        match ...:
+            case MyClass(x, y=x):
+                pass
+        """)
+
+    def test_multiple_assignments_to_name_in_pattern_5(self):
+        self.assert_syntax_error("""
+        match ...:
+            case a as a:
+                pass
+        """)
+
+    def test_multiple_starred_names_in_sequence_pattern_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case *a, b, *c, d, *e:
+                pass
+        """)
+
+    def test_multiple_starred_names_in_sequence_pattern_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case a, *b, c, *d, e:
+                pass
+        """)
+
+    def test_name_capture_makes_remaining_patterns_unreachable_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case a | "a":
+                pass
+        """)
+
+    def test_name_capture_makes_remaining_patterns_unreachable_1(self):
+        self.assert_syntax_error("""
+        match 42:
+            case x:
+                pass
+            case y:
+                pass
+        """)
+
+    def test_name_capture_makes_remaining_patterns_unreachable_2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case x | [_ as x] if x:
+                pass
+        """)
+
+    def test_name_capture_makes_remaining_patterns_unreachable_3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case x:
+                pass
+            case [x] if x:
+                pass
+        """)
+
+    def test_name_capture_makes_remaining_patterns_unreachable_4(self):
+        self.assert_syntax_error("""
+        match ...:
+            case x:
+                pass
+            case _:
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_patterns_may_only_match_literals_and_attribute_lookups_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case f"":
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_patterns_may_only_match_literals_and_attribute_lookups_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case f"{x}":
+                pass
+        """)
+
+    def test_real_number_required_in_complex_literal_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case 0j+0:
+                pass
+        """)
+
+    def test_real_number_required_in_complex_literal_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case 0j+0j:
+                pass
+        """)
+
+    def test_real_number_required_in_complex_literal_2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0j+0: _}:
+                pass
+        """)
+
+    def test_real_number_required_in_complex_literal_3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0j+0j: _}:
+                pass
+        """)
+
+    def test_real_number_multiple_ops(self):
+        self.assert_syntax_error("""
+        match ...:
+            case 0 + 0j + 0:
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_real_number_wrong_ops(self):
+        for op in ["*", "/", "@", "**", "%", "//"]:
+            with self.subTest(op=op):
+                self.assert_syntax_error(f"""
+                match ...:
+                    case 0 {op} 0j:
+                        pass
+                """)
+                self.assert_syntax_error(f"""
+                match ...:
+                    case 0j {op} 0:
+                        pass
+                """)
+                self.assert_syntax_error(f"""
+                match ...:
+                    case -0j {op} 0:
+                        pass
+                """)
+                self.assert_syntax_error(f"""
+                match ...:
+                    case 0j {op} -0:
+                        pass
+                """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case _ | _:
+                pass
+        """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case (_ as x) | [x]:
+                pass
+        """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case _ | _ if condition():
+                pass
+        """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case _:
+                pass
+            case None:
+                pass
+        """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_4(self):
+        self.assert_syntax_error("""
+        match ...:
+            case (None | _) | _:
+                pass
+        """)
+
+    def test_wildcard_makes_remaining_patterns_unreachable_5(self):
+        self.assert_syntax_error("""
+        match ...:
+            case _ | (True | False):
+                pass
+        """)
+
+    def test_mapping_pattern_duplicate_key(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {"a": _, "a": _}:
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_mapping_pattern_duplicate_key_edge_case0(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0: _, False: _}:
+                pass
+        """)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_mapping_pattern_duplicate_key_edge_case1(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0: _, 0.0: _}:
+                pass
+        """)
+
+    def test_mapping_pattern_duplicate_key_edge_case2(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0: _, -0: _}:
+                pass
+        """)
+
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_mapping_pattern_duplicate_key_edge_case3(self):
+        self.assert_syntax_error("""
+        match ...:
+            case {0: _, 0j: _}:
+                pass
+        """)
+
+class TestTypeErrors(unittest.TestCase):
+
+    def test_accepts_positional_subpatterns_0(self):
+        class Class:
+            __match_args__ = ()
+        x = Class()
+        y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y):
+                    z = 0
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_accepts_positional_subpatterns_1(self):
+        x = range(10)
+        y = None
+        with self.assertRaises(TypeError):
+            match x:
+                case range(10):
+                    y = 0
+        self.assertEqual(x, range(10))
+        self.assertIs(y, None)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_got_multiple_subpatterns_for_attribute_0(self):
+        class Class:
+            __match_args__ = ("a", "a")
+            a = None
+        x = Class()
+        w = y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y, z):
+                    w = 0
+        self.assertIs(w, None)
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_got_multiple_subpatterns_for_attribute_1(self):
+        class Class:
+            __match_args__ = ("a",)
+            a = None
+        x = Class()
+        w = y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y, a=z):
+                    w = 0
+        self.assertIs(w, None)
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_match_args_elements_must_be_strings(self):
+        class Class:
+            __match_args__ = (None,)
+        x = Class()
+        y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y):
+                    z = 0
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_match_args_must_be_a_tuple_0(self):
+        class Class:
+            __match_args__ = None
+        x = Class()
+        y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y):
+                    z = 0
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_match_args_must_be_a_tuple_1(self):
+        class Class:
+            __match_args__ = "XYZ"
+        x = Class()
+        y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y):
+                    z = 0
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_match_args_must_be_a_tuple_2(self):
+        class Class:
+            __match_args__ = ["spam", "eggs"]
+            spam = 0
+            eggs = 1
+        x = Class()
+        w = y = z = None
+        with self.assertRaises(TypeError):
+            match x:
+                case Class(y, z):
+                    w = 0
+        self.assertIs(w, None)
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+    def test_class_pattern_not_type(self):
+        w = None
+        with self.assertRaises(TypeError):
+            match 1:
+                case max(0, 1):
+                    w = 0
+        self.assertIsNone(w)
+
+    def test_regular_protocol(self):
+        from typing import Protocol
+        class P(Protocol): ...
+        msg = (
+            'Instance and class checks can only be used '
+            'with @runtime_checkable protocols'
+        )
+        w = None
+        with self.assertRaisesRegex(TypeError, msg):
+            match 1:
+                case P():
+                    w = 0
+        self.assertIsNone(w)
+
+    def test_positional_patterns_with_regular_protocol(self):
+        from typing import Protocol
+        class P(Protocol):
+            x: int  # no `__match_args__`
+            y: int
+        class A:
+            x = 1
+            y = 2
+        w = None
+        with self.assertRaises(TypeError):
+            match A():
+                case P(x, y):
+                    w = 0
+        self.assertIsNone(w)
+
+
+class TestValueErrors(unittest.TestCase):
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_mapping_pattern_checks_duplicate_key_1(self):
+        class Keys:
+            KEY = "a"
+        x = {"a": 0, "b": 1}
+        w = y = z = None
+        with self.assertRaises(ValueError):
+            match x:
+                case {Keys.KEY: y, "a": z}:
+                    w = 0
+        self.assertIs(w, None)
+        self.assertIs(y, None)
+        self.assertIs(z, None)
+
+class TestSourceLocations(unittest.TestCase):
+    def test_jump_threading(self):
+        # See gh-123048
+        def f():
+            x = 0
+            v = 1
+            match v:
+                case 1:
+                    if x < 0:
+                        x = 1
+                case 2:
+                    if x < 0:
+                        x = 1
+            x += 1
+
+        for inst in dis.get_instructions(f):
+            if inst.opcode in dis.hasjump:
+                self.assertIsNotNone(inst.positions.lineno, "jump without location")
+
+class TestTracing(unittest.TestCase):
+
+    @staticmethod
+    def _trace(func, *args, **kwargs):
+        actual_linenos = []
+
+        def trace(frame, event, arg):
+            if event == "line" and frame.f_code.co_name == func.__name__:
+                assert arg is None
+                relative_lineno = frame.f_lineno - func.__code__.co_firstlineno
+                actual_linenos.append(relative_lineno)
+            return trace
+
+        old_trace = sys.gettrace()
+        sys.settrace(trace)
+        try:
+            func(*args, **kwargs)
+        finally:
+            sys.settrace(old_trace)
+        return actual_linenos
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_default_wildcard(self):
+        def f(command):                                         # 0
+            match command.split():                              # 1
+                case ["go", direction] if direction in "nesw":  # 2
+                    return f"go {direction}"                    # 3
+                case ["go", _]:                                 # 4
+                    return "no go"                              # 5
+                case _:                                         # 6
+                    return "default"                            # 7
+
+        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
+        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4, 6, 7])
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_default_capture(self):
+        def f(command):                                         # 0
+            match command.split():                              # 1
+                case ["go", direction] if direction in "nesw":  # 2
+                    return f"go {direction}"                    # 3
+                case ["go", _]:                                 # 4
+                    return "no go"                              # 5
+                case x:                                         # 6
+                    return x                                    # 7
+
+        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
+        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4, 6, 7])
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_no_default(self):
+        def f(command):                                         # 0
+            match command.split():                              # 1
+                case ["go", direction] if direction in "nesw":  # 2
+                    return f"go {direction}"                    # 3
+                case ["go", _]:                                 # 4
+                    return "no go"                              # 5
+
+        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "go x"), [1, 2, 4, 5])
+        self.assertListEqual(self._trace(f, "spam"), [1, 2, 4])
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_only_default_wildcard(self):
+        def f(command):               # 0
+            match command.split():    # 1
+                case _:               # 2
+                    return "default"  # 3
+
+        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "go x"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "spam"), [1, 2, 3])
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_only_default_capture(self):
+        def f(command):             # 0
+            match command.split():  # 1
+                case x:             # 2
+                    return x        # 3
+
+        self.assertListEqual(self._trace(f, "go n"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "go x"), [1, 2, 3])
+        self.assertListEqual(self._trace(f, "spam"), [1, 2, 3])
+
+    @unittest.expectedFailure   # TODO: RUSTPYTHON
+    def test_unreachable_code(self):
+        def f(command):               # 0
+            match command:            # 1
+                case 1:               # 2
+                    if False:         # 3
+                        return 1      # 4
+                case _:               # 5
+                    if False:         # 6
+                        return 0      # 7
+
+        self.assertListEqual(self._trace(f, 1), [1, 2, 3])
+        self.assertListEqual(self._trace(f, 0), [1, 2, 5, 6])
+
+    def test_parser_deeply_nested_patterns(self):
+        # Deeply nested patterns can cause exponential backtracking when parsing.
+        # See gh-93671 for more information.
+
+        levels = 100
+
+        patterns = [
+            "A" + "(" * levels + ")" * levels,
+            "{1:" * levels + "1" + "}" * levels,
+            "[" * levels + "1" + "]" * levels,
+        ]
+
+        for pattern in patterns:
+            with self.subTest(pattern):
+                code = inspect.cleandoc("""
+                    match None:
+                        case {}:
+                            pass
+                """.format(pattern))
+                compile(code, "<string>", "exec")
+
+
+if __name__ == "__main__":
+    """
+    # From inside environment using this Python, with pyperf installed:
+    sudo $(which pyperf) system tune && \
+         $(which python) -m test.test_patma --rigorous; \
+    sudo $(which pyperf) system reset
+    """
+    import pyperf
+
+
+    class PerfPatma(TestPatma):
+
+        def assertEqual(*_, **__):
+            pass
+
+        def assertIs(*_, **__):
+            pass
+
+        def assertRaises(*_, **__):
+            assert False, "this test should be a method of a different class!"
+
+        def run_perf(self, count):
+            tests = []
+            for attr in vars(TestPatma):
+                if attr.startswith("test_"):
+                    tests.append(getattr(self, attr))
+            tests *= count
+            start = pyperf.perf_counter()
+            for test in tests:
+                test()
+            return pyperf.perf_counter() - start
+
+
+    runner = pyperf.Runner()
+    runner.bench_time_func("patma", PerfPatma().run_perf)
diff --git a/Lib/test/test_pickle.py b/Lib/test/test_pickle.py
index e01ddcf0a8..7271696a19 100644
--- a/Lib/test/test_pickle.py
+++ b/Lib/test/test_pickle.py
@@ -16,6 +16,7 @@
 
 from test.pickletester import AbstractHookTests
 from test.pickletester import AbstractUnpickleTests
+from test.pickletester import AbstractPicklingErrorTests
 from test.pickletester import AbstractPickleTests
 from test.pickletester import AbstractPickleModuleTests
 from test.pickletester import AbstractPersistentPicklerTests
@@ -40,15 +41,15 @@ class PyPickleTests(AbstractPickleModuleTests, unittest.TestCase):
     Pickler = pickle._Pickler
     Unpickler = pickle._Unpickler
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_dump_load_oob_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_dump_load_oob_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_dump_load_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_dump_load_oob_buffers()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_dumps_loads_oob_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_dumps_loads_oob_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_dumps_loads_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_dumps_loads_oob_buffers()
 
 
 class PyUnpicklerTests(AbstractUnpickleTests, unittest.TestCase):
@@ -59,71 +60,59 @@ class PyUnpicklerTests(AbstractUnpickleTests, unittest.TestCase):
                         AttributeError, ValueError,
                         struct.error, IndexError, ImportError)
 
-    # TODO: RUSTPYTHON, AssertionError: ValueError not raised
-    @unittest.expectedFailure
-    def test_badly_escaped_string(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_badly_escaped_string() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON, AssertionError
-    @unittest.expectedFailure
-    def test_correctly_quoted_string(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_correctly_quoted_string() # TODO: RUSTPYTHON, remove when this passes
-
-    # TODO: RUSTPYTHON, AssertionError
-    @unittest.expectedFailure
-    def test_load_python2_str_as_bytes(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_load_python2_str_as_bytes() # TODO: RUSTPYTHON, remove when this passes
-
     def loads(self, buf, **kwds):
         f = io.BytesIO(buf)
         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()
 
-class PyPicklerTests(AbstractPickleTests, unittest.TestCase):
+    # 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):
 
     pickler = pickle._Pickler
-    unpickler = pickle._Unpickler
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_buffer_callback_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffer_callback_error() # TODO: RUSTPYTHON, remove when this passes
+    def dumps(self, arg, proto=None, **kwargs):
+        f = io.BytesIO()
+        p = self.pickler(f, proto, **kwargs)
+        p.dump(arg)
+        f.seek(0)
+        return bytes(f.read())
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_buffers_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffers_error() # TODO: RUSTPYTHON, remove when this passes
+    def test_picklebuffer_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_picklebuffer_error()
 
-    # TODO: RUSTPYTHON, AssertionError
-    @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_complex_newobj_ex() # TODO: RUSTPYTHON, remove when this passes
 
-    # TODO: RUSTPYTHON, TypeError: cannot pickle 'method' object
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_in_band_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_buffer_callback_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_buffer_callback_error()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_non_continuous_buffer(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_non_continuous_buffer()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_oob_buffers_writable_to_readonly(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers_writable_to_readonly() # TODO: RUSTPYTHON, remove when this passes
 
-    # TODO: RUSTPYTHON, TypeError: Expected type 'bytes', not 'bytearray'
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_optional_frames() # TODO: RUSTPYTHON, remove when this passes
+class PyPicklerTests(AbstractPickleTests, unittest.TestCase):
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_picklebuffer_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_picklebuffer_error() # TODO: RUSTPYTHON, remove when this passes
+    pickler = pickle._Pickler
+    unpickler = pickle._Unpickler
 
     def dumps(self, arg, proto=None, **kwargs):
         f = io.BytesIO()
@@ -137,69 +126,91 @@ 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()
 
-class InMemoryPickleTests(AbstractPickleTests, AbstractUnpickleTests,
-                          BigmemPickleTests, unittest.TestCase):
 
-    bad_stack_errors = (pickle.UnpicklingError, IndexError)
-    truncated_errors = (pickle.UnpicklingError, EOFError,
-                        AttributeError, ValueError,
-                        struct.error, IndexError, ImportError)
 
-    # TODO: RUSTPYTHON, AssertionError: ValueError not raised
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_buffers_error()
+
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_badly_escaped_string(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_badly_escaped_string() # TODO: RUSTPYTHON, remove when this passes
+    def test_builtin_functions(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_builtin_functions()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_buffer_callback_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffer_callback_error() # TODO: RUSTPYTHON, remove when this passes
+    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytearray_memoization()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_buffers_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffers_error() # TODO: RUSTPYTHON, remove when this passes
+    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytes_memoization()
 
-    # TODO: RUSTPYTHON, AssertionError
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_complex_newobj_ex() # TODO: RUSTPYTHON, remove when this passes
+    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_in_band_buffers()
 
-    # TODO: RUSTPYTHON, AssertionError
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_correctly_quoted_string(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_correctly_quoted_string() # TODO: RUSTPYTHON, remove when this passes
+    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_oob_buffers()
 
-    # TODO: RUSTPYTHON, TypeError: cannot pickle 'method' object
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_in_band_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_oob_buffers_writable_to_readonly(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_oob_buffers_writable_to_readonly()
 
-    # TODO: RUSTPYTHON, AssertionError
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_load_python2_str_as_bytes(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_load_python2_str_as_bytes() # TODO: RUSTPYTHON, remove when this passes
+    def test_buffers_error(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_buffers_error()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers() # TODO: RUSTPYTHON, remove when this passes
+    def test_builtin_functions(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_builtin_functions()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_oob_buffers_writable_to_readonly(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers_writable_to_readonly() # TODO: RUSTPYTHON, remove when this passes
+    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytearray_memoization()
 
-    # TODO: RUSTPYTHON, TypeError: Expected type 'bytes', not 'bytearray'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_optional_frames(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_optional_frames() # TODO: RUSTPYTHON, remove when this passes
+    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytes_memoization()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_picklebuffer_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_picklebuffer_error() # TODO: RUSTPYTHON, remove when this passes
+    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_in_band_buffers()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        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
+        return super().test_oob_buffers_writable_to_readonly()
+
+
+class InMemoryPickleTests(AbstractPickleTests, AbstractUnpickleTests,
+                          BigmemPickleTests, unittest.TestCase):
+
+    bad_stack_errors = (pickle.UnpicklingError, IndexError)
+    truncated_errors = (pickle.UnpicklingError, EOFError,
+                        AttributeError, ValueError,
+                        struct.error, IndexError, ImportError)
 
     def dumps(self, arg, protocol=None, **kwargs):
         return pickle.dumps(arg, protocol, **kwargs)
@@ -208,7 +219,65 @@ def loads(self, buf, **kwds):
         return pickle.loads(buf, **kwds)
 
     test_framed_write_sizes_with_delayed_writer = None
+    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
+        return super().test_buffers_error()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_builtin_functions(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_builtin_functions()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytearray_memoization()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytes_memoization()
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_in_band_buffers()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_oob_buffers()
 
 class PersistentPicklerUnpicklerMixin(object):
 
@@ -242,6 +311,7 @@ class PyIdPersPicklerTests(AbstractIdentityPersistentPicklerTests,
 
     pickler = pickle._Pickler
     unpickler = pickle._Unpickler
+    persistent_load_error = pickle.UnpicklingError
 
     @support.cpython_only
     def test_pickler_reference_cycle(self):
@@ -296,7 +366,6 @@ class DispatchTable:
         support.gc_collect()
         self.assertIsNone(table_ref())
 
-
     @support.cpython_only
     def test_unpickler_reference_cycle(self):
         def check(Unpickler):
@@ -326,6 +395,111 @@ def persistent_load(pid):
                 return pid
         check(PersUnpickler)
 
+    def test_pickler_super(self):
+        class PersPickler(self.pickler):
+            def persistent_id(subself, obj):
+                called.append(obj)
+                self.assertIsNone(super().persistent_id(obj))
+                return obj
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            f = io.BytesIO()
+            pickler = PersPickler(f, proto)
+            called = []
+            pickler.dump('abc')
+            self.assertEqual(called, ['abc'])
+            self.assertEqual(self.loads(f.getvalue()), 'abc')
+
+    def test_unpickler_super(self):
+        class PersUnpickler(self.unpickler):
+            def persistent_load(subself, pid):
+                called.append(pid)
+                with self.assertRaises(self.persistent_load_error):
+                    super().persistent_load(pid)
+                return pid
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            unpickler = PersUnpickler(io.BytesIO(self.dumps('abc', proto)))
+            called = []
+            self.assertEqual(unpickler.load(), 'abc')
+            self.assertEqual(called, ['abc'])
+
+    def test_pickler_instance_attribute(self):
+        def persistent_id(obj):
+            called.append(obj)
+            return obj
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            f = io.BytesIO()
+            pickler = self.pickler(f, proto)
+            called = []
+            old_persistent_id = pickler.persistent_id
+            pickler.persistent_id = persistent_id
+            self.assertEqual(pickler.persistent_id, persistent_id)
+            pickler.dump('abc')
+            self.assertEqual(called, ['abc'])
+            self.assertEqual(self.loads(f.getvalue()), 'abc')
+            del pickler.persistent_id
+            self.assertEqual(pickler.persistent_id, old_persistent_id)
+
+    def test_unpickler_instance_attribute(self):
+        def persistent_load(pid):
+            called.append(pid)
+            return pid
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            unpickler = self.unpickler(io.BytesIO(self.dumps('abc', proto)))
+            called = []
+            old_persistent_load = unpickler.persistent_load
+            unpickler.persistent_load = persistent_load
+            self.assertEqual(unpickler.persistent_load, persistent_load)
+            self.assertEqual(unpickler.load(), 'abc')
+            self.assertEqual(called, ['abc'])
+            del unpickler.persistent_load
+            self.assertEqual(unpickler.persistent_load, old_persistent_load)
+
+    def test_pickler_super_instance_attribute(self):
+        class PersPickler(self.pickler):
+            def persistent_id(subself, obj):
+                raise AssertionError('should never be called')
+            def _persistent_id(subself, obj):
+                called.append(obj)
+                self.assertIsNone(super().persistent_id(obj))
+                return obj
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            f = io.BytesIO()
+            pickler = PersPickler(f, proto)
+            called = []
+            old_persistent_id = pickler.persistent_id
+            pickler.persistent_id = pickler._persistent_id
+            self.assertEqual(pickler.persistent_id, pickler._persistent_id)
+            pickler.dump('abc')
+            self.assertEqual(called, ['abc'])
+            self.assertEqual(self.loads(f.getvalue()), 'abc')
+            del pickler.persistent_id
+            self.assertEqual(pickler.persistent_id, old_persistent_id)
+
+    def test_unpickler_super_instance_attribute(self):
+        class PersUnpickler(self.unpickler):
+            def persistent_load(subself, pid):
+                raise AssertionError('should never be called')
+            def _persistent_load(subself, pid):
+                called.append(pid)
+                with self.assertRaises(self.persistent_load_error):
+                    super().persistent_load(pid)
+                return pid
+
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            unpickler = PersUnpickler(io.BytesIO(self.dumps('abc', proto)))
+            called = []
+            old_persistent_load = unpickler.persistent_load
+            unpickler.persistent_load = unpickler._persistent_load
+            self.assertEqual(unpickler.persistent_load, unpickler._persistent_load)
+            self.assertEqual(unpickler.load(), 'abc')
+            self.assertEqual(called, ['abc'])
+            del unpickler.persistent_load
+            self.assertEqual(unpickler.persistent_load, old_persistent_load)
 
 class PyPicklerUnpicklerObjectTests(AbstractPicklerUnpicklerObjectTests, unittest.TestCase):
 
@@ -365,6 +539,9 @@ class CUnpicklerTests(PyUnpicklerTests):
         bad_stack_errors = (pickle.UnpicklingError,)
         truncated_errors = (pickle.UnpicklingError,)
 
+    class CPicklingErrorTests(PyPicklingErrorTests):
+        pickler = _pickle.Pickler
+
     class CPicklerTests(PyPicklerTests):
         pickler = _pickle.Pickler
         unpickler = _pickle.Unpickler
@@ -376,6 +553,7 @@ class CPersPicklerTests(PyPersPicklerTests):
     class CIdPersPicklerTests(PyIdPersPicklerTests):
         pickler = _pickle.Pickler
         unpickler = _pickle.Unpickler
+        persistent_load_error = _pickle.UnpicklingError
 
     class CDumpPickle_LoadPickle(PyPicklerTests):
         pickler = _pickle.Pickler
@@ -499,7 +677,9 @@ def recurse(deep):
             check_unpickler(recurse(1), 32, 20)
             check_unpickler(recurse(20), 32, 20)
             check_unpickler(recurse(50), 64, 60)
-            check_unpickler(recurse(100), 128, 140)
+            if not (support.is_wasi and support.Py_DEBUG):
+                # stack depth too shallow in pydebug WASI.
+                check_unpickler(recurse(100), 128, 140)
 
             u = unpickler(io.BytesIO(pickle.dumps('a', 0)),
                           encoding='ASCII', errors='strict')
@@ -642,6 +822,8 @@ def test_reverse_name_mapping(self):
                 module, name = mapping(module, name)
                 self.assertEqual((module, name), (module3, name3))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_exceptions(self):
         self.assertEqual(mapping('exceptions', 'StandardError'),
                          ('builtins', 'Exception'))
@@ -659,13 +841,12 @@ def test_exceptions(self):
                 if exc in (BlockingIOError,
                            ResourceWarning,
                            StopAsyncIteration,
+                           PythonFinalizationError,
                            RecursionError,
                            EncodingWarning,
                            BaseExceptionGroup,
-                           ExceptionGroup):
-                    continue
-                # TODO: RUSTPYTHON: fix name mapping for _IncompleteInputError
-                if exc is _IncompleteInputError:
+                           ExceptionGroup,
+                           _IncompleteInputError):
                     continue
                 if exc is not OSError and issubclass(exc, OSError):
                     self.assertEqual(reverse_mapping('builtins', name),
@@ -692,9 +873,8 @@ def test_multiprocessing_exceptions(self):
                 self.assertEqual(mapping('multiprocessing', name),
                                  ('multiprocessing.context', name))
 
-
 def load_tests(loader, tests, pattern):
-    tests.addTest(doctest.DocTestSuite())
+    tests.addTest(doctest.DocTestSuite(pickle))
     return tests
 
 
diff --git a/Lib/test/test_picklebuffer.py b/Lib/test/test_picklebuffer.py
new file mode 100644
index 0000000000..a14f6a86b4
--- /dev/null
+++ b/Lib/test/test_picklebuffer.py
@@ -0,0 +1,179 @@
+"""Unit tests for the PickleBuffer object.
+
+Pickling tests themselves are in pickletester.py.
+"""
+
+import gc
+# TODO: RUSTPYTHON; Implment PickleBuffer
+try:
+    from pickle import PickleBuffer
+except ImportError:
+    PickleBuffer = None
+import weakref
+import unittest
+
+from test.support import import_helper
+
+
+class B(bytes):
+    pass
+
+
+class PickleBufferTest(unittest.TestCase):
+
+    def check_memoryview(self, pb, equiv):
+        with memoryview(pb) as m:
+            with memoryview(equiv) as expected:
+                self.assertEqual(m.nbytes, expected.nbytes)
+                self.assertEqual(m.readonly, expected.readonly)
+                self.assertEqual(m.itemsize, expected.itemsize)
+                self.assertEqual(m.shape, expected.shape)
+                self.assertEqual(m.strides, expected.strides)
+                self.assertEqual(m.c_contiguous, expected.c_contiguous)
+                self.assertEqual(m.f_contiguous, expected.f_contiguous)
+                self.assertEqual(m.format, expected.format)
+                self.assertEqual(m.tobytes(), expected.tobytes())
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_constructor_failure(self):
+        with self.assertRaises(TypeError):
+            PickleBuffer()
+        with self.assertRaises(TypeError):
+            PickleBuffer("foo")
+        # Released memoryview fails taking a buffer
+        m = memoryview(b"foo")
+        m.release()
+        with self.assertRaises(ValueError):
+            PickleBuffer(m)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_basics(self):
+        pb = PickleBuffer(b"foo")
+        self.assertEqual(b"foo", bytes(pb))
+        with memoryview(pb) as m:
+            self.assertTrue(m.readonly)
+
+        pb = PickleBuffer(bytearray(b"foo"))
+        self.assertEqual(b"foo", bytes(pb))
+        with memoryview(pb) as m:
+            self.assertFalse(m.readonly)
+            m[0] = 48
+        self.assertEqual(b"0oo", bytes(pb))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_release(self):
+        pb = PickleBuffer(b"foo")
+        pb.release()
+        with self.assertRaises(ValueError) as raises:
+            memoryview(pb)
+        self.assertIn("operation forbidden on released PickleBuffer object",
+                      str(raises.exception))
+        # Idempotency
+        pb.release()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cycle(self):
+        b = B(b"foo")
+        pb = PickleBuffer(b)
+        b.cycle = pb
+        wpb = weakref.ref(pb)
+        del b, pb
+        gc.collect()
+        self.assertIsNone(wpb())
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_ndarray_2d(self):
+        # C-contiguous
+        ndarray = import_helper.import_module("_testbuffer").ndarray
+        arr = ndarray(list(range(12)), shape=(4, 3), format='<i')
+        self.assertTrue(arr.c_contiguous)
+        self.assertFalse(arr.f_contiguous)
+        pb = PickleBuffer(arr)
+        self.check_memoryview(pb, arr)
+        # Non-contiguous
+        arr = arr[::2]
+        self.assertFalse(arr.c_contiguous)
+        self.assertFalse(arr.f_contiguous)
+        pb = PickleBuffer(arr)
+        self.check_memoryview(pb, arr)
+        # F-contiguous
+        arr = ndarray(list(range(12)), shape=(3, 4), strides=(4, 12), format='<i')
+        self.assertTrue(arr.f_contiguous)
+        self.assertFalse(arr.c_contiguous)
+        pb = PickleBuffer(arr)
+        self.check_memoryview(pb, arr)
+
+    # Tests for PickleBuffer.raw()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    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
+    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
+    def test_raw_ndarray(self):
+        # 1-D, contiguous
+        ndarray = import_helper.import_module("_testbuffer").ndarray
+        arr = ndarray(list(range(3)), shape=(3,), format='<h')
+        equiv = b"\x00\x00\x01\x00\x02\x00"
+        self.check_raw(arr, equiv)
+        # 2-D, C-contiguous
+        arr = ndarray(list(range(6)), shape=(2, 3), format='<h')
+        equiv = b"\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00"
+        self.check_raw(arr, equiv)
+        # 2-D, F-contiguous
+        arr = ndarray(list(range(6)), shape=(2, 3), strides=(2, 4),
+                      format='<h')
+        # Note this is different from arr.tobytes()
+        equiv = b"\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00"
+        self.check_raw(arr, equiv)
+        # 0-D
+        arr = ndarray(456, shape=(), format='<i')
+        equiv = b'\xc8\x01\x00\x00'
+        self.check_raw(arr, equiv)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def check_raw_non_contiguous(self, obj):
+        pb = PickleBuffer(obj)
+        with self.assertRaisesRegex(BufferError, "non-contiguous"):
+            pb.raw()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_raw_non_contiguous(self):
+        # 1-D
+        ndarray = import_helper.import_module("_testbuffer").ndarray
+        arr = ndarray(list(range(6)), shape=(6,), format='<i')[::2]
+        self.check_raw_non_contiguous(arr)
+        # 2-D
+        arr = ndarray(list(range(12)), shape=(4, 3), format='<i')[::2]
+        self.check_raw_non_contiguous(arr)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_raw_released(self):
+        pb = PickleBuffer(b"foo")
+        pb.release()
+        with self.assertRaises(ValueError) as raises:
+            pb.raw()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_pickletools.py b/Lib/test/test_pickletools.py
index f3b9dccb0d..42a20da00b 100644
--- a/Lib/test/test_pickletools.py
+++ b/Lib/test/test_pickletools.py
@@ -1,3 +1,4 @@
+import io
 import pickle
 import pickletools
 from test import support
@@ -7,52 +8,6 @@
 
 class OptimizedPickleTests(AbstractPickleTests, unittest.TestCase):
 
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_buffer_callback_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffer_callback_error()
-
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_buffers_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_buffers_error()
-
-    def test_compat_pickle(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_compat_pickle()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_complex_newobj_ex(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_complex_newobj_ex()
-
-    # TODO: RUSTPYTHON, TypeError: cannot pickle 'method' object
-    @unittest.expectedFailure
-    def test_in_band_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_in_band_buffers()
-
-    def test_notimplemented(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_notimplemented()
-
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_oob_buffers(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers()
-
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_oob_buffers_writable_to_readonly(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_oob_buffers_writable_to_readonly()
-
-    # TODO: RUSTPYTHON, TypeError: Expected type 'bytes', not 'bytearray'
-    @unittest.expectedFailure
-    def test_optional_frames(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_optional_frames()
-
-    # TODO: RUSTPYTHON, AttributeError: module 'pickle' has no attribute 'PickleBuffer'
-    @unittest.expectedFailure
-    def test_picklebuffer_error(self): # TODO: RUSTPYTHON, remove when this passes
-        super().test_picklebuffer_error()
-
     def dumps(self, arg, proto=None, **kwargs):
         return pickletools.optimize(pickle.dumps(arg, proto, **kwargs))
 
@@ -107,6 +62,438 @@ 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
+        return super().test_buffers_error()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_builtin_functions(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_builtin_functions()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bytearray_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytearray_memoization()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_bytes_memoization(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_bytes_memoization()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_in_band_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        return super().test_in_band_buffers()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_oob_buffers(self): # TODO(RUSTPYTHON): Remove this test when it passes
+        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
+        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):
+        self.data = data
+        self.pos = 0
+
+    def read(self, n):
+        data = self.data[self.pos: self.pos + n]
+        self.pos += n
+        return data
+
+    def readline(self):
+        nl = self.data.find(b'\n', self.pos) + 1
+        if not nl:
+            nl = len(self.data)
+        data = self.data[self.pos: nl]
+        self.pos = nl
+        return data
+
+
+class GenopsTests(unittest.TestCase):
+    def test_genops(self):
+        it = pickletools.genops(b'(I123\nK\x12J\x12\x34\x56\x78t.')
+        self.assertEqual([(item[0].name,) +  item[1:] for item in it], [
+            ('MARK', None, 0),
+            ('INT', 123, 1),
+            ('BININT1', 0x12, 6),
+            ('BININT', 0x78563412, 8),
+            ('TUPLE', None, 13),
+            ('STOP', None, 14),
+        ])
+
+    def test_from_file(self):
+        f = io.BytesIO(b'prefix(I123\nK\x12J\x12\x34\x56\x78t.suffix')
+        self.assertEqual(f.read(6), b'prefix')
+        it = pickletools.genops(f)
+        self.assertEqual([(item[0].name,) +  item[1:] for item in it], [
+            ('MARK', None, 6),
+            ('INT', 123, 7),
+            ('BININT1', 0x12, 12),
+            ('BININT', 0x78563412, 14),
+            ('TUPLE', None, 19),
+            ('STOP', None, 20),
+        ])
+        self.assertEqual(f.read(), b'suffix')
+
+    def test_without_pos(self):
+        f = SimpleReader(b'(I123\nK\x12J\x12\x34\x56\x78t.')
+        it = pickletools.genops(f)
+        self.assertEqual([(item[0].name,) +  item[1:] for item in it], [
+            ('MARK', None, None),
+            ('INT', 123, None),
+            ('BININT1', 0x12, None),
+            ('BININT', 0x78563412, None),
+            ('TUPLE', None, None),
+            ('STOP', None, None),
+        ])
+
+    def test_no_stop(self):
+        it = pickletools.genops(b'N')
+        item = next(it)
+        self.assertEqual(item[0].name, 'NONE')
+        with self.assertRaisesRegex(ValueError,
+                'pickle exhausted before seeing STOP'):
+            next(it)
+
+    def test_truncated_data(self):
+        it = pickletools.genops(b'I123')
+        with self.assertRaisesRegex(ValueError,
+                'no newline found when trying to read stringnl'):
+            next(it)
+        it = pickletools.genops(b'J\x12\x34')
+        with self.assertRaisesRegex(ValueError,
+                'not enough data in stream to read int4'):
+            next(it)
+
+    def test_unknown_opcode(self):
+        it = pickletools.genops(b'N\xff')
+        item = next(it)
+        self.assertEqual(item[0].name, 'NONE')
+        with self.assertRaisesRegex(ValueError,
+                r"at position 1, opcode b'\\xff' unknown"):
+            next(it)
+
+    def test_unknown_opcode_without_pos(self):
+        f = SimpleReader(b'N\xff')
+        it = pickletools.genops(f)
+        item = next(it)
+        self.assertEqual(item[0].name, 'NONE')
+        with self.assertRaisesRegex(ValueError,
+                r"at position <unknown>, opcode b'\\xff' unknown"):
+            next(it)
+
+
+class DisTests(unittest.TestCase):
+    maxDiff = None
+
+    def check_dis(self, data, expected, **kwargs):
+        out = io.StringIO()
+        pickletools.dis(data, out=out, **kwargs)
+        self.assertEqual(out.getvalue(), expected)
+
+    def check_dis_error(self, data, expected, expected_error, **kwargs):
+        out = io.StringIO()
+        with self.assertRaisesRegex(ValueError, expected_error):
+            pickletools.dis(data, out=out, **kwargs)
+        self.assertEqual(out.getvalue(), expected)
+
+    def test_mark(self):
+        self.check_dis(b'(N(tl.', '''\
+    0: (    MARK
+    1: N        NONE
+    2: (        MARK
+    3: t            TUPLE      (MARK at 2)
+    4: l        LIST       (MARK at 0)
+    5: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_indentlevel(self):
+        self.check_dis(b'(N(tl.', '''\
+    0: (    MARK
+    1: N      NONE
+    2: (      MARK
+    3: t        TUPLE      (MARK at 2)
+    4: l      LIST       (MARK at 0)
+    5: .    STOP
+highest protocol among opcodes = 0
+''', indentlevel=2)
+
+    def test_mark_without_pos(self):
+        self.check_dis(SimpleReader(b'(N(tl.'), '''\
+(    MARK
+N        NONE
+(        MARK
+t            TUPLE      (MARK at unknown opcode offset)
+l        LIST       (MARK at unknown opcode offset)
+.    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_no_mark(self):
+        self.check_dis_error(b'Nt.', '''\
+    0: N    NONE
+    1: t    TUPLE      no MARK exists on stack
+''', 'no MARK exists on stack')
+
+    def test_put(self):
+        self.check_dis(b'Np0\nq\x01r\x02\x00\x00\x00\x94.', '''\
+    0: N    NONE
+    1: p    PUT        0
+    4: q    BINPUT     1
+    6: r    LONG_BINPUT 2
+   11: \\x94 MEMOIZE    (as 3)
+   12: .    STOP
+highest protocol among opcodes = 4
+''')
+
+    def test_put_redefined(self):
+        self.check_dis_error(b'Np1\np1\n.', '''\
+    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')
+
+    def test_put_empty_stack(self):
+        self.check_dis_error(b'p0\n', '''\
+    0: p    PUT        0
+''', "stack is empty -- can't store into memo")
+
+    def test_put_markobject(self):
+        self.check_dis_error(b'(p0\n', '''\
+    0: (    MARK
+    1: p        PUT        0
+''', "can't store markobject in the memo")
+
+    def test_get(self):
+        self.check_dis(b'(Np1\ng1\nh\x01j\x01\x00\x00\x00t.', '''\
+    0: (    MARK
+    1: N        NONE
+    2: p        PUT        1
+    5: g        GET        1
+    8: h        BINGET     1
+   10: j        LONG_BINGET 1
+   15: t        TUPLE      (MARK at 0)
+   16: .    STOP
+highest protocol among opcodes = 1
+''')
+
+    def test_get_without_put(self):
+        self.check_dis_error(b'g1\n.', '''\
+    0: g    GET        1
+''', 'memo key 1 has never been stored into')
+        self.check_dis_error(b'h\x01.', '''\
+    0: h    BINGET     1
+''', 'memo key 1 has never been stored into')
+        self.check_dis_error(b'j\x01\x00\x00\x00.', '''\
+    0: j    LONG_BINGET 1
+''', 'memo key 1 has never been stored into')
+
+    def test_memo(self):
+        memo = {}
+        self.check_dis(b'Np1\n.', '''\
+    0: N    NONE
+    1: p    PUT        1
+    4: .    STOP
+highest protocol among opcodes = 0
+''', memo=memo)
+        self.check_dis(b'g1\n.', '''\
+    0: g    GET        1
+    3: .    STOP
+highest protocol among opcodes = 0
+''', memo=memo)
+
+    def test_mark_pop(self):
+        self.check_dis(b'(N00N.', '''\
+    0: (    MARK
+    1: N        NONE
+    2: 0        POP
+    3: 0        POP        (MARK at 0)
+    4: N    NONE
+    5: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_too_small_stack(self):
+        self.check_dis_error(b'a', '''\
+    0: a    APPEND
+''', 'tries to pop 2 items from stack with only 0 items')
+        self.check_dis_error(b']a', '''\
+    0: ]    EMPTY_LIST
+    1: a    APPEND
+''', 'tries to pop 2 items from stack with only 1 items')
+
+    def test_no_stop(self):
+        self.check_dis_error(b'N', '''\
+    0: N    NONE
+''', 'pickle exhausted before seeing STOP')
+
+    def test_truncated_data(self):
+        self.check_dis_error(b'NI123', '''\
+    0: N    NONE
+''', 'no newline found when trying to read stringnl')
+        self.check_dis_error(b'NJ\x12\x34', '''\
+    0: N    NONE
+''', 'not enough data in stream to read int4')
+
+    def test_unknown_opcode(self):
+        self.check_dis_error(b'N\xff', '''\
+    0: N    NONE
+''', r"at position 1, opcode b'\\xff' unknown")
+
+    def test_stop_not_empty_stack(self):
+        self.check_dis_error(b']N.', '''\
+    0: ]    EMPTY_LIST
+    1: N    NONE
+    2: .    STOP
+highest protocol among opcodes = 1
+''', r'stack not empty after STOP: \[list\]')
+
+    def test_annotate(self):
+        self.check_dis(b'(Nt.', '''\
+    0: (    MARK Push markobject onto the stack.
+    1: N        NONE Push None on the stack.
+    2: t        TUPLE      (MARK at 0) Build a tuple out of the topmost stack slice, after markobject.
+    3: .    STOP                       Stop the unpickling machine.
+highest protocol among opcodes = 0
+''', annotate=1)
+        self.check_dis(b'(Nt.', '''\
+    0: (    MARK            Push markobject onto the stack.
+    1: N        NONE        Push None on the stack.
+    2: t        TUPLE      (MARK at 0) Build a tuple out of the topmost stack slice, after markobject.
+    3: .    STOP                       Stop the unpickling machine.
+highest protocol among opcodes = 0
+''', annotate=20)
+        self.check_dis(b'(((((((ttttttt.', '''\
+    0: (    MARK            Push markobject onto the stack.
+    1: (        MARK        Push markobject onto the stack.
+    2: (            MARK    Push markobject onto the stack.
+    3: (                MARK Push markobject onto the stack.
+    4: (                    MARK Push markobject onto the stack.
+    5: (                        MARK Push markobject onto the stack.
+    6: (                            MARK Push markobject onto the stack.
+    7: t                                TUPLE      (MARK at 6) Build a tuple out of the topmost stack slice, after markobject.
+    8: t                            TUPLE      (MARK at 5) Build a tuple out of the topmost stack slice, after markobject.
+    9: t                        TUPLE      (MARK at 4) Build a tuple out of the topmost stack slice, after markobject.
+   10: t                    TUPLE      (MARK at 3)     Build a tuple out of the topmost stack slice, after markobject.
+   11: t                TUPLE      (MARK at 2)         Build a tuple out of the topmost stack slice, after markobject.
+   12: t            TUPLE      (MARK at 1)             Build a tuple out of the topmost stack slice, after markobject.
+   13: t        TUPLE      (MARK at 0)                 Build a tuple out of the topmost stack slice, after markobject.
+   14: .    STOP                                       Stop the unpickling machine.
+highest protocol among opcodes = 0
+''', annotate=20)
+
+    def test_string(self):
+        self.check_dis(b"S'abc'\n.", '''\
+    0: S    STRING     'abc'
+    7: .    STOP
+highest protocol among opcodes = 0
+''')
+        self.check_dis(b'S"abc"\n.', '''\
+    0: S    STRING     'abc'
+    7: .    STOP
+highest protocol among opcodes = 0
+''')
+        self.check_dis(b"S'\xc3\xb5'\n.", '''\
+    0: S    STRING     '\\xc3\\xb5'
+    6: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_string_without_quotes(self):
+        self.check_dis_error(b"Sabc'\n.", '',
+                             'no string quotes around b"abc\'"')
+        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"''')
+        self.check_dis_error(b'S"abc\n.', '',
+                             r"""strinq 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"'""")
+        self.check_dis_error(b"S\"abc'\n.", '',
+                             r"""strinq quote b'"' not found at both ends of b'"abc\\''""")
+
+    def test_binstring(self):
+        self.check_dis(b"T\x03\x00\x00\x00abc.", '''\
+    0: T    BINSTRING  'abc'
+    8: .    STOP
+highest protocol among opcodes = 1
+''')
+        self.check_dis(b"T\x02\x00\x00\x00\xc3\xb5.", '''\
+    0: T    BINSTRING  '\\xc3\\xb5'
+    7: .    STOP
+highest protocol among opcodes = 1
+''')
+
+    def test_short_binstring(self):
+        self.check_dis(b"U\x03abc.", '''\
+    0: U    SHORT_BINSTRING 'abc'
+    5: .    STOP
+highest protocol among opcodes = 1
+''')
+        self.check_dis(b"U\x02\xc3\xb5.", '''\
+    0: U    SHORT_BINSTRING '\\xc3\\xb5'
+    4: .    STOP
+highest protocol among opcodes = 1
+''')
+
+    def test_global(self):
+        self.check_dis(b"cmodule\nname\n.", '''\
+    0: c    GLOBAL     'module name'
+   13: .    STOP
+highest protocol among opcodes = 0
+''')
+        self.check_dis(b"cm\xc3\xb6dule\nn\xc3\xa4me\n.", '''\
+    0: c    GLOBAL     'm\xf6dule n\xe4me'
+   15: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_inst(self):
+        self.check_dis(b"(imodule\nname\n.", '''\
+    0: (    MARK
+    1: i        INST       'module name' (MARK at 0)
+   14: .    STOP
+highest protocol among opcodes = 0
+''')
+
+    def test_persid(self):
+        self.check_dis(b"Pabc\n.", '''\
+    0: P    PERSID     'abc'
+    5: .    STOP
+highest protocol among opcodes = 0
+''')
 
 class MiscTestCase(unittest.TestCase):
     def test__all__(self):
diff --git a/Lib/test/test_pkgutil.py b/Lib/test/test_pkgutil.py
index ece4cf2d05..0d44092dab 100644
--- a/Lib/test/test_pkgutil.py
+++ b/Lib/test/test_pkgutil.py
@@ -1,5 +1,6 @@
+from pathlib import Path
 from test.support.import_helper import unload, CleanImport
-from test.support.warnings_helper import check_warnings
+from test.support.warnings_helper import check_warnings, ignore_warnings
 import unittest
 import sys
 import importlib
@@ -11,6 +12,10 @@
 import shutil
 import zipfile
 
+from test.support.import_helper import DirsOnSysPath
+from test.support.os_helper import FakePath
+from test.test_importlib.util import uncache
+
 # Note: pkgutil.walk_packages is currently tested in test_runpy. This is
 # a hack to get a major issue resolved for 3.3b2. Longer term, it should
 # be moved back here, perhaps by factoring out the helper code for
@@ -91,6 +96,45 @@ def test_getdata_zipfile(self):
 
         del sys.modules[pkg]
 
+    def test_issue44061_iter_modules(self):
+        #see: issue44061
+        zip = 'test_getdata_zipfile.zip'
+        pkg = 'test_getdata_zipfile'
+
+        # Include a LF and a CRLF, to test that binary data is read back
+        RESOURCE_DATA = b'Hello, world!\nSecond line\r\nThird line'
+
+        # Make a package with some resources
+        zip_file = os.path.join(self.dirname, zip)
+        z = zipfile.ZipFile(zip_file, 'w')
+
+        # Empty init.py
+        z.writestr(pkg + '/__init__.py', "")
+        # Resource files, res.txt
+        z.writestr(pkg + '/res.txt', RESOURCE_DATA)
+        z.close()
+
+        # Check we can read the resources
+        sys.path.insert(0, zip_file)
+        try:
+            res = pkgutil.get_data(pkg, 'res.txt')
+            self.assertEqual(res, RESOURCE_DATA)
+
+            # make sure iter_modules accepts Path objects
+            names = []
+            for moduleinfo in pkgutil.iter_modules([FakePath(zip_file)]):
+                self.assertIsInstance(moduleinfo, pkgutil.ModuleInfo)
+                names.append(moduleinfo.name)
+            self.assertEqual(names, [pkg])
+        finally:
+            del sys.path[0]
+            sys.modules.pop(pkg, None)
+
+        # assert path must be None or list of paths
+        expected_msg = "path must be None or list of paths to look for modules in"
+        with self.assertRaisesRegex(ValueError, expected_msg):
+            list(pkgutil.iter_modules("invalid_path"))
+
     def test_unreadable_dir_on_syspath(self):
         # issue7367 - walk_packages failed if unreadable dir on sys.path
         package_name = "unreadable_package"
@@ -187,8 +231,7 @@ def test_walk_packages_raises_on_string_or_bytes_input(self):
         with self.assertRaises((TypeError, ValueError)):
             list(pkgutil.walk_packages(bytes_input))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_name_resolution(self):
         import logging
         import logging.handlers
@@ -280,6 +323,38 @@ def test_name_resolution(self):
                 with self.assertRaises(exc):
                     pkgutil.resolve_name(s)
 
+    def test_name_resolution_import_rebinding(self):
+        # The same data is also used for testing import in test_import and
+        # mock.patch in test_unittest.
+        path = os.path.join(os.path.dirname(__file__), 'test_import', 'data')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3.submodule.attr'), 'submodule')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3.submodule:attr'), 'submodule')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+            self.assertEqual(pkgutil.resolve_name('package3.submodule.attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+            self.assertEqual(pkgutil.resolve_name('package3.submodule:attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package3:submodule.attr'), 'rebound')
+
+    def test_name_resolution_import_rebinding2(self):
+        path = os.path.join(os.path.dirname(__file__), 'test_import', 'data')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4.submodule.attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4.submodule:attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'origin')
+            self.assertEqual(pkgutil.resolve_name('package4.submodule.attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'submodule')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'origin')
+            self.assertEqual(pkgutil.resolve_name('package4.submodule:attr'), 'submodule')
+            self.assertEqual(pkgutil.resolve_name('package4:submodule.attr'), 'submodule')
+
 
 class PkgutilPEP302Tests(unittest.TestCase):
 
@@ -391,7 +466,7 @@ def test_iter_importers(self):
             importers = list(iter_importers(fullname))
             expected_importer = get_importer(pathitem)
             for finder in importers:
-                spec = pkgutil._get_spec(finder, fullname)
+                spec = finder.find_spec(fullname)
                 loader = spec.loader
                 try:
                     loader = loader.loader
@@ -403,7 +478,7 @@ def test_iter_importers(self):
                 self.assertEqual(finder, expected_importer)
                 self.assertIsInstance(loader,
                                       importlib.machinery.SourceFileLoader)
-                self.assertIsNone(pkgutil._get_spec(finder, pkgname))
+                self.assertIsNone(finder.find_spec(pkgname))
 
             with self.assertRaises(ImportError):
                 list(iter_importers('invalid.module'))
@@ -448,7 +523,43 @@ def test_mixed_namespace(self):
         del sys.modules['foo.bar']
         del sys.modules['foo.baz']
 
-    # XXX: test .pkg files
+
+    def test_extend_path_argument_types(self):
+        pkgname = 'foo'
+        dirname_0 = self.create_init(pkgname)
+
+        # If the input path is not a list it is returned unchanged
+        self.assertEqual('notalist', pkgutil.extend_path('notalist', 'foo'))
+        self.assertEqual(('not', 'a', 'list'), pkgutil.extend_path(('not', 'a', 'list'), 'foo'))
+        self.assertEqual(123, pkgutil.extend_path(123, 'foo'))
+        self.assertEqual(None, pkgutil.extend_path(None, 'foo'))
+
+        # Cleanup
+        shutil.rmtree(dirname_0)
+        del sys.path[0]
+
+
+    def test_extend_path_pkg_files(self):
+        pkgname = 'foo'
+        dirname_0 = self.create_init(pkgname)
+
+        with open(os.path.join(dirname_0, 'bar.pkg'), 'w') as pkg_file:
+            pkg_file.write('\n'.join([
+                'baz',
+                '/foo/bar/baz',
+                '',
+                '#comment'
+            ]))
+
+        extended_paths = pkgutil.extend_path(sys.path, 'bar')
+
+        self.assertEqual(extended_paths[:-2], sys.path)
+        self.assertEqual(extended_paths[-2], 'baz')
+        self.assertEqual(extended_paths[-1], '/foo/bar/baz')
+
+        # Cleanup
+        shutil.rmtree(dirname_0)
+        del sys.path[0]
 
 
 class NestedNamespacePackageTest(unittest.TestCase):
@@ -491,36 +602,50 @@ def test_nested(self):
         self.assertEqual(c, 1)
         self.assertEqual(d, 2)
 
+
+class ImportlibMigrationTests(unittest.TestCase):
+    # With full PEP 302 support in the standard import machinery, the
+    # PEP 302 emulation in this module is in the process of being
+    # deprecated in favour of importlib proper
+
     @unittest.skipIf(__name__ == '__main__', 'not compatible with __main__')
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_missing_loader_attribute(self):
         global __loader__
         this_loader = __loader__
         del __loader__
         try:
-            with check_warnings() as w:
-                self.assertIsNotNone(pkgutil.get_loader(__name__))
-                self.assertEqual(len(w.warnings), 0)
+            self.assertIsNotNone(pkgutil.get_loader(__name__))
         finally:
             __loader__ = this_loader
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_missing_spec_attribute(self):
         name = 'spam'
         mod = type(sys)(name)
         del mod.__spec__
         with CleanImport(name):
-            sys.modules[name] = mod
-            loader = pkgutil.get_loader(name)
+            try:
+                sys.modules[name] = mod
+                loader = pkgutil.get_loader(name)
+            finally:
+                sys.modules.pop(name, None)
         self.assertIsNone(loader)
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_handles_spec_attribute_none(self):
         name = 'spam'
         mod = type(sys)(name)
         mod.__spec__ = None
         with CleanImport(name):
-            sys.modules[name] = mod
-            loader = pkgutil.get_loader(name)
+            try:
+                sys.modules[name] = mod
+                loader = pkgutil.get_loader(name)
+            finally:
+                sys.modules.pop(name, None)
         self.assertIsNone(loader)
 
+    @ignore_warnings(category=DeprecationWarning)
     def test_get_loader_None_in_sys_modules(self):
         name = 'totally bogus'
         sys.modules[name] = None
@@ -530,24 +655,38 @@ def test_get_loader_None_in_sys_modules(self):
             del sys.modules[name]
         self.assertIsNone(loader)
 
+    def test_get_loader_is_deprecated(self):
+        with check_warnings(
+            (r".*\bpkgutil.get_loader\b.*", DeprecationWarning),
+        ):
+            res = pkgutil.get_loader("sys")
+        self.assertIsNotNone(res)
+
+    def test_find_loader_is_deprecated(self):
+        with check_warnings(
+            (r".*\bpkgutil.find_loader\b.*", DeprecationWarning),
+        ):
+            res = pkgutil.find_loader("sys")
+        self.assertIsNotNone(res)
+
+    @ignore_warnings(category=DeprecationWarning)
     def test_find_loader_missing_module(self):
         name = 'totally bogus'
         loader = pkgutil.find_loader(name)
         self.assertIsNone(loader)
 
-    def test_find_loader_avoids_emulation(self):
-        with check_warnings() as w:
-            self.assertIsNotNone(pkgutil.find_loader("sys"))
-            self.assertIsNotNone(pkgutil.find_loader("os"))
-            self.assertIsNotNone(pkgutil.find_loader("test.support"))
-            self.assertEqual(len(w.warnings), 0)
-
     def test_get_importer_avoids_emulation(self):
         # We use an illegal path so *none* of the path hooks should fire
         with check_warnings() as w:
             self.assertIsNone(pkgutil.get_importer("*??"))
             self.assertEqual(len(w.warnings), 0)
 
+    def test_issue44061(self):
+        try:
+            pkgutil.get_importer(Path("/home"))
+        except AttributeError:
+            self.fail("Unexpected AttributeError when calling get_importer")
+
     def test_iter_importers_avoids_emulation(self):
         with check_warnings() as w:
             for importer in pkgutil.iter_importers(): pass
diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py
index c9f27575b5..ed277276b5 100644
--- a/Lib/test/test_platform.py
+++ b/Lib/test/test_platform.py
@@ -10,6 +10,14 @@
 from test import support
 from test.support import os_helper
 
+try:
+    # Some of the iOS tests need ctypes to operate.
+    # Confirm that the ctypes module is available
+    # is available.
+    import _ctypes
+except ImportError:
+    _ctypes = None
+
 FEDORA_OS_RELEASE = """\
 NAME=Fedora
 VERSION="32 (Thirty Two)"
@@ -123,10 +131,6 @@ def test_sys_version(self):
         for input, output in (
             ('2.4.3 (#1, Jun 21 2006, 13:54:21) \n[GCC 3.3.4 (pre 3.3.5 20040809)]',
              ('CPython', '2.4.3', '', '', '1', 'Jun 21 2006 13:54:21', 'GCC 3.3.4 (pre 3.3.5 20040809)')),
-            ('IronPython 1.0.60816 on .NET 2.0.50727.42',
-             ('IronPython', '1.0.60816', '', '', '', '', '.NET 2.0.50727.42')),
-            ('IronPython 1.0 (1.0.61005.1977) on .NET 2.0.50727.42',
-             ('IronPython', '1.0.0', '', '', '', '', '.NET 2.0.50727.42')),
             ('2.4.3 (truncation, date, t) \n[GCC]',
              ('CPython', '2.4.3', '', '', 'truncation', 'date t', 'GCC')),
             ('2.4.3 (truncation, date, ) \n[GCC]',
@@ -161,20 +165,11 @@ def test_sys_version(self):
                  ('r261:67515', 'Dec  6 2008 15:26:00'),
                  'GCC 4.0.1 (Apple Computer, Inc. build 5370)'),
 
-            ("IronPython 2.0 (2.0.0.0) on .NET 2.0.50727.3053", None, "cli")
-            :
-                ("IronPython", "2.0.0", "", "", ("", ""),
-                 ".NET 2.0.50727.3053"),
-
-            ("2.6.1 (IronPython 2.6.1 (2.6.10920.0) on .NET 2.0.50727.1433)", None, "cli")
+            ("3.10.8 (tags/v3.10.8:aaaf517424, Feb 14 2023, 16:28:12) [GCC 9.4.0]",
+             None, "linux")
             :
-                ("IronPython", "2.6.1", "", "", ("", ""),
-                 ".NET 2.0.50727.1433"),
-
-            ("2.7.4 (IronPython 2.7.4 (2.7.0.40) on Mono 4.0.30319.1 (32-bit))", None, "cli")
-            :
-                ("IronPython", "2.7.4", "", "", ("", ""),
-                 "Mono 4.0.30319.1 (32-bit)"),
+                ('CPython', '3.10.8', '', '',
+                ('tags/v3.10.8:aaaf517424', 'Feb 14 2023 16:28:12'), 'GCC 9.4.0'),
 
             ("2.5 (trunk:6107, Mar 26 2009, 13:02:18) \n[Java HotSpot(TM) Client VM (\"Apple Computer, Inc.\")]",
             ('Jython', 'trunk', '6107'), "java1.5.0_16")
@@ -205,6 +200,9 @@ def test_sys_version(self):
             self.assertEqual(platform.python_build(), info[4])
             self.assertEqual(platform.python_compiler(), info[5])
 
+        with self.assertRaises(ValueError):
+            platform._sys_version('2. 4.3 (truncation) \n[GCC]')
+
     def test_system_alias(self):
         res = platform.system_alias(
             platform.system(),
@@ -229,6 +227,38 @@ def test_uname(self):
         self.assertEqual(res[-1], res.processor)
         self.assertEqual(len(res), 6)
 
+        if os.name == "posix":
+            uname = os.uname()
+            self.assertEqual(res.node, uname.nodename)
+            self.assertEqual(res.version, uname.version)
+            self.assertEqual(res.machine, uname.machine)
+
+            if sys.platform == "android":
+                self.assertEqual(res.system, "Android")
+                self.assertEqual(res.release, platform.android_ver().release)
+            elif sys.platform == "ios":
+                # Platform module needs ctypes for full operation. If ctypes
+                # isn't available, there's no ObjC module, and dummy values are
+                # returned.
+                if _ctypes:
+                    self.assertIn(res.system, {"iOS", "iPadOS"})
+                    self.assertEqual(res.release, platform.ios_ver().release)
+                else:
+                    self.assertEqual(res.system, "")
+                    self.assertEqual(res.release, "")
+            else:
+                self.assertEqual(res.system, uname.sysname)
+                self.assertEqual(res.release, uname.release)
+
+
+    @unittest.skipUnless(sys.platform.startswith('win'), "windows only test")
+    def test_uname_win32_without_wmi(self):
+        def raises_oserror(*a):
+            raise OSError()
+
+        with support.swap_attr(platform, '_wmi_query', raises_oserror):
+            self.test_uname()
+
     def test_uname_cast_to_tuple(self):
         res = platform.uname()
         expected = (
@@ -297,28 +327,66 @@ def test_uname_win32_ARCHITEW6432(self):
         # on 64 bit Windows: if PROCESSOR_ARCHITEW6432 exists we should be
         # using it, per
         # http://blogs.msdn.com/david.wang/archive/2006/03/26/HOWTO-Detect-Process-Bitness.aspx
-        try:
+
+        # We also need to suppress WMI checks, as those are reliable and
+        # overrule the environment variables
+        def raises_oserror(*a):
+            raise OSError()
+
+        with support.swap_attr(platform, '_wmi_query', raises_oserror):
             with os_helper.EnvironmentVarGuard() as environ:
-                if 'PROCESSOR_ARCHITEW6432' in environ:
+                try:
                     del environ['PROCESSOR_ARCHITEW6432']
-                environ['PROCESSOR_ARCHITECTURE'] = 'foo'
-                platform._uname_cache = None
-                system, node, release, version, machine, processor = platform.uname()
-                self.assertEqual(machine, 'foo')
-                environ['PROCESSOR_ARCHITEW6432'] = 'bar'
-                platform._uname_cache = None
-                system, node, release, version, machine, processor = platform.uname()
-                self.assertEqual(machine, 'bar')
-        finally:
-            platform._uname_cache = None
+                    environ['PROCESSOR_ARCHITECTURE'] = 'foo'
+                    platform._uname_cache = None
+                    system, node, release, version, machine, processor = platform.uname()
+                    self.assertEqual(machine, 'foo')
+                    environ['PROCESSOR_ARCHITEW6432'] = 'bar'
+                    platform._uname_cache = None
+                    system, node, release, version, machine, processor = platform.uname()
+                    self.assertEqual(machine, 'bar')
+                finally:
+                    platform._uname_cache = None
 
     def test_java_ver(self):
-        res = platform.java_ver()
-        if sys.platform == 'java':
-            self.assertTrue(all(res))
+        import re
+        msg = re.escape(
+            "'java_ver' is deprecated and slated for removal in Python 3.15"
+        )
+        with self.assertWarnsRegex(DeprecationWarning, msg):
+            res = platform.java_ver()
+        self.assertEqual(len(res), 4)
 
+    @unittest.skipUnless(support.MS_WINDOWS, 'This test only makes sense on Windows')
     def test_win32_ver(self):
-        res = platform.win32_ver()
+        release1, version1, csd1, ptype1 = 'a', 'b', 'c', 'd'
+        res = platform.win32_ver(release1, version1, csd1, ptype1)
+        self.assertEqual(len(res), 4)
+        release, version, csd, ptype = res
+        if release:
+            # Currently, release names always come from internal dicts,
+            # but this could change over time. For now, we just check that
+            # release is something different from what we have passed.
+            self.assertNotEqual(release, release1)
+        if version:
+            # It is rather hard to test explicit version without
+            # going deep into the details.
+            self.assertIn('.', version)
+            for v in version.split('.'):
+                int(v)  # should not fail
+        if csd:
+            self.assertTrue(csd.startswith('SP'), msg=csd)
+        if ptype:
+            if os.cpu_count() > 1:
+                self.assertIn('Multiprocessor', ptype)
+            else:
+                self.assertIn('Uniprocessor', ptype)
+
+    @unittest.skipIf(support.MS_WINDOWS, 'This test only makes sense on non Windows')
+    def test_win32_ver_on_non_windows(self):
+        release, version, csd, ptype = 'a', '1.0', 'c', 'd'
+        res = platform.win32_ver(release, version, csd, ptype)
+        self.assertSequenceEqual(res, (release, version, csd, ptype), seq_type=tuple)
 
     def test_mac_ver(self):
         res = platform.mac_ver()
@@ -372,6 +440,56 @@ def test_mac_ver_with_fork(self):
             # parent
             support.wait_process(pid, exitcode=0)
 
+    def test_ios_ver(self):
+        result = platform.ios_ver()
+
+        # ios_ver is only fully available on iOS where ctypes is available.
+        if sys.platform == "ios" and _ctypes:
+            system, release, model, is_simulator = result
+            # Result is a namedtuple
+            self.assertEqual(result.system, system)
+            self.assertEqual(result.release, release)
+            self.assertEqual(result.model, model)
+            self.assertEqual(result.is_simulator, is_simulator)
+
+            # We can't assert specific values without reproducing the logic of
+            # ios_ver(), so we check that the values are broadly what we expect.
+
+            # System is either iOS or iPadOS, depending on the test device
+            self.assertIn(system, {"iOS", "iPadOS"})
+
+            # Release is a numeric version specifier with at least 2 parts
+            parts = release.split(".")
+            self.assertGreaterEqual(len(parts), 2)
+            self.assertTrue(all(part.isdigit() for part in parts))
+
+            # If this is a simulator, we get a high level device descriptor
+            # with no identifying model number. If this is a physical device,
+            # we get a model descriptor like "iPhone13,1"
+            if is_simulator:
+                self.assertIn(model, {"iPhone", "iPad"})
+            else:
+                self.assertTrue(
+                    (model.startswith("iPhone") or model.startswith("iPad"))
+                    and "," in model
+                )
+
+            self.assertEqual(type(is_simulator), bool)
+        else:
+            # On non-iOS platforms, calling ios_ver doesn't fail; you get
+            # default values
+            self.assertEqual(result.system, "")
+            self.assertEqual(result.release, "")
+            self.assertEqual(result.model, "")
+            self.assertFalse(result.is_simulator)
+
+            # Check the fallback values can be overridden by arguments
+            override = platform.ios_ver("Foo", "Bar", "Whiz", True)
+            self.assertEqual(override.system, "Foo")
+            self.assertEqual(override.release, "Bar")
+            self.assertEqual(override.model, "Whiz")
+            self.assertTrue(override.is_simulator)
+
     @unittest.skipIf(support.is_emscripten, "Does not apply to Emscripten")
     def test_libc_ver(self):
         # check that libc_ver(executable) doesn't raise an exception
@@ -421,6 +539,43 @@ def test_libc_ver(self):
         self.assertEqual(platform.libc_ver(filename, chunksize=chunksize),
                          ('glibc', '1.23.4'))
 
+    def test_android_ver(self):
+        res = platform.android_ver()
+        self.assertIsInstance(res, tuple)
+        self.assertEqual(res, (res.release, res.api_level, res.manufacturer,
+                               res.model, res.device, res.is_emulator))
+
+        if sys.platform == "android":
+            for name in ["release", "manufacturer", "model", "device"]:
+                with self.subTest(name):
+                    value = getattr(res, name)
+                    self.assertIsInstance(value, str)
+                    self.assertNotEqual(value, "")
+
+            self.assertIsInstance(res.api_level, int)
+            self.assertGreaterEqual(res.api_level, sys.getandroidapilevel())
+
+            self.assertIsInstance(res.is_emulator, bool)
+
+        # When not running on Android, it should return the default values.
+        else:
+            self.assertEqual(res.release, "")
+            self.assertEqual(res.api_level, 0)
+            self.assertEqual(res.manufacturer, "")
+            self.assertEqual(res.model, "")
+            self.assertEqual(res.device, "")
+            self.assertEqual(res.is_emulator, False)
+
+            # Default values may also be overridden using parameters.
+            res = platform.android_ver(
+                "alpha", 1, "bravo", "charlie", "delta", True)
+            self.assertEqual(res.release, "alpha")
+            self.assertEqual(res.api_level, 1)
+            self.assertEqual(res.manufacturer, "bravo")
+            self.assertEqual(res.model, "charlie")
+            self.assertEqual(res.device, "delta")
+            self.assertEqual(res.is_emulator, True)
+
     @support.cpython_only
     def test__comparable_version(self):
         from platform import _comparable_version as V
@@ -467,7 +622,8 @@ def test_macos(self):
                   'root:xnu-4570.71.2~1/RELEASE_X86_64'),
                  'x86_64', 'i386')
         arch = ('64bit', '')
-        with mock.patch.object(platform, 'uname', return_value=uname), \
+        with mock.patch.object(sys, "platform", "darwin"), \
+             mock.patch.object(platform, 'uname', return_value=uname), \
              mock.patch.object(platform, 'architecture', return_value=arch):
             for mac_ver, expected_terse, expected in [
                 # darwin: mac_ver() returns empty strings
diff --git a/Lib/test/test_plistlib.py b/Lib/test/test_plistlib.py
index c6d4cfe5c6..cad53c1783 100644
--- a/Lib/test/test_plistlib.py
+++ b/Lib/test/test_plistlib.py
@@ -6,10 +6,15 @@
 import unittest
 import plistlib
 import os
+import sys
+import json
 import datetime
 import codecs
+import subprocess
 import binascii
 import collections
+import time
+import zoneinfo
 from test import support
 from test.support import os_helper
 from io import BytesIO
@@ -505,6 +510,19 @@ def test_bytes(self):
         data2 = plistlib.dumps(pl2)
         self.assertEqual(data, data2)
 
+    def test_loads_str_with_xml_fmt(self):
+        pl = self._create()
+        b = plistlib.dumps(pl)
+        s = b.decode()
+        self.assertIsInstance(s, str)
+        pl2 = plistlib.loads(s)
+        self.assertEqual(pl, pl2)
+
+    def test_loads_str_with_binary_fmt(self):
+        msg = "value must be bytes-like object when fmt is FMT_BINARY"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.loads('test', fmt=plistlib.FMT_BINARY)
+
     def test_indentation_array(self):
         data = [[[[[[[[{'test': b'aaaaaa'}]]]]]]]]
         self.assertEqual(plistlib.loads(plistlib.dumps(data)), data)
@@ -734,8 +752,7 @@ def test_non_bmp_characters(self):
                 data = plistlib.dumps(pl, fmt=fmt)
                 self.assertEqual(plistlib.loads(data), pl)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lone_surrogates(self):
         for fmt in ALL_FORMATS:
             with self.subTest(fmt=fmt):
@@ -754,8 +771,7 @@ def test_nondictroot(self):
                 self.assertEqual(test1, result1)
                 self.assertEqual(test2, result2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidarray(self):
         for i in ["<key>key inside an array</key>",
                   "<key>key inside an array2</key><real>3</real>",
@@ -763,8 +779,7 @@ def test_invalidarray(self):
             self.assertRaises(ValueError, plistlib.loads,
                               ("<plist><array>%s</array></plist>"%i).encode())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invaliddict(self):
         for i in ["<key><true/>k</key><string>compound key</string>",
                   "<key>single key</key>",
@@ -776,14 +791,12 @@ def test_invaliddict(self):
             self.assertRaises(ValueError, plistlib.loads,
                               ("<plist><array><dict>%s</dict></array></plist>"%i).encode())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidinteger(self):
         self.assertRaises(ValueError, plistlib.loads,
                           b"<plist><integer>not integer</integer></plist>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalidreal(self):
         self.assertRaises(ValueError, plistlib.loads,
                           b"<plist><integer>not real</integer></plist>")
@@ -840,18 +853,64 @@ def test_modified_uid_huge(self):
         with self.assertRaises(OverflowError):
             plistlib.dumps(huge_uid, fmt=plistlib.FMT_BINARY)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xml_plist_with_entity_decl(self):
         with self.assertRaisesRegex(plistlib.InvalidFileException,
                                     "XML entity declarations are not supported"):
             plistlib.loads(XML_PLIST_WITH_ENTITY, fmt=plistlib.FMT_XML)
 
+    def test_load_aware_datetime(self):
+        dt = plistlib.loads(b"<plist><date>2023-12-10T08:03:30Z</date></plist>",
+                            aware_datetime=True)
+        self.assertEqual(dt.tzinfo, datetime.UTC)
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime(self):
+        dt = datetime.datetime(2345, 6, 7, 8, 9, 10,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            loaded_dt = plistlib.loads(s, fmt=fmt, aware_datetime=True)
+            self.assertEqual(loaded_dt.tzinfo, datetime.UTC)
+            self.assertEqual(loaded_dt, dt)
+
+    def test_dump_utc_aware_datetime(self):
+        dt = datetime.datetime(2345, 6, 7, 8, 9, 10, tzinfo=datetime.UTC)
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            loaded_dt = plistlib.loads(s, fmt=fmt, aware_datetime=True)
+            self.assertEqual(loaded_dt.tzinfo, datetime.UTC)
+            self.assertEqual(loaded_dt, dt)
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        s = plistlib.dumps(dt, fmt=plistlib.FMT_XML, aware_datetime=False)
+        self.assertIn(b"2345-06-07T08:00:00Z", s)
+
+    def test_dump_utc_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC)
+        s = plistlib.dumps(dt, fmt=plistlib.FMT_XML, aware_datetime=False)
+        self.assertIn(b"2345-06-07T08:00:00Z", s)
+
+    def test_dump_naive_datetime_with_aware_datetime_option(self):
+        # Save a naive datetime with aware_datetime set to true.  This will lead
+        # to having different time as compared to the current machine's
+        # timezone, which is UTC.
+        dt = datetime.datetime(2003, 6, 7, 8, tzinfo=None)
+        for fmt in ALL_FORMATS:
+            s = plistlib.dumps(dt, fmt=fmt, aware_datetime=True)
+            parsed = plistlib.loads(s, aware_datetime=False)
+            expected = dt.astimezone(datetime.UTC).replace(tzinfo=None)
+            self.assertEqual(parsed, expected)
+
 
 class TestBinaryPlistlib(unittest.TestCase):
 
-    @staticmethod
-    def decode(*objects, offset_size=1, ref_size=1):
+    def build(self, *objects, offset_size=1, ref_size=1):
         data = [b'bplist00']
         offset = 8
         offsets = []
@@ -863,7 +922,11 @@ def decode(*objects, offset_size=1, ref_size=1):
                            len(objects), 0, offset)
         data.extend(offsets)
         data.append(tail)
-        return plistlib.loads(b''.join(data), fmt=plistlib.FMT_BINARY)
+        return b''.join(data)
+
+    def decode(self, *objects, offset_size=1, ref_size=1):
+        data = self.build(*objects, offset_size=offset_size, ref_size=ref_size)
+        return plistlib.loads(data, fmt=plistlib.FMT_BINARY)
 
     def test_nonstandard_refs_size(self):
         # Issue #21538: Refs and offsets are 24-bit integers
@@ -917,12 +980,12 @@ def test_cycles(self):
         self.assertIs(b['x'], b)
 
     def test_deep_nesting(self):
-        for N in [300, 100000]:
+        for N in [50, 300, 100_000]:
             chunks = [b'\xa1' + (i + 1).to_bytes(4, 'big') for i in range(N)]
             try:
                 result = self.decode(*chunks, b'\x54seed', offset_size=4, ref_size=4)
             except RecursionError:
-                pass
+                self.assertGreater(N, sys.getrecursionlimit())
             else:
                 for i in range(N):
                     self.assertIsInstance(result, list)
@@ -934,7 +997,7 @@ def test_large_timestamp(self):
         # Issue #26709: 32-bit timestamp out of range
         for ts in -2**31-1, 2**31:
             with self.subTest(ts=ts):
-                d = (datetime.datetime.utcfromtimestamp(0) +
+                d = (datetime.datetime(1970, 1, 1, 0, 0) +
                      datetime.timedelta(seconds=ts))
                 data = plistlib.dumps(d, fmt=plistlib.FMT_BINARY)
                 self.assertEqual(plistlib.loads(data), d)
@@ -971,6 +1034,60 @@ def test_invalid_binary(self):
                 with self.assertRaises(plistlib.InvalidFileException):
                     plistlib.loads(b'bplist00' + data, fmt=plistlib.FMT_BINARY)
 
+    def test_truncated_large_data(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        def check(data):
+            with open(os_helper.TESTFN, 'wb') as f:
+                f.write(data)
+            # buffered file
+            with open(os_helper.TESTFN, 'rb') as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+            # unbuffered file
+            with open(os_helper.TESTFN, 'rb', buffering=0) as f:
+                with self.assertRaises(plistlib.InvalidFileException):
+                    plistlib.load(f, fmt=plistlib.FMT_BINARY)
+        for w in range(20, 64):
+            s = 1 << w
+            # data
+            check(self.build(b'\x4f\x13' + s.to_bytes(8, 'big')))
+            # ascii string
+            check(self.build(b'\x5f\x13' + s.to_bytes(8, 'big')))
+            # unicode string
+            check(self.build(b'\x6f\x13' + s.to_bytes(8, 'big')))
+            # array
+            check(self.build(b'\xaf\x13' + s.to_bytes(8, 'big')))
+            # dict
+            check(self.build(b'\xdf\x13' + s.to_bytes(8, 'big')))
+            # number of objects
+            check(b'bplist00' + struct.pack('>6xBBQQQ', 1, 1, s, 0, 8))
+
+    def test_load_aware_datetime(self):
+        data = (b'bplist003B\x04>\xd0d\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00'
+                b'\x01\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00'
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11')
+        self.assertEqual(plistlib.loads(data, aware_datetime=True),
+                         datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC))
+
+    @unittest.skipUnless("America/Los_Angeles" in zoneinfo.available_timezones(),
+                         "Can't find timezone datebase")
+    def test_dump_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8,
+                               tzinfo=zoneinfo.ZoneInfo("America/Los_Angeles"))
+        msg = "can't subtract offset-naive and offset-aware datetimes"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.dumps(dt, fmt=plistlib.FMT_BINARY, aware_datetime=False)
+
+    # TODO: RUSTPYTHON
+    # The error message is different
+    # In CPython, there is a separate .c file for datetime, which raises a different error message
+    @unittest.expectedFailure
+    def test_dump_utc_aware_datetime_without_aware_datetime_option(self):
+        dt = datetime.datetime(2345, 6, 7, 8, tzinfo=datetime.UTC)
+        msg = "can't subtract offset-naive and offset-aware datetimes"
+        with self.assertRaisesRegex(TypeError, msg):
+            plistlib.dumps(dt, fmt=plistlib.FMT_BINARY, aware_datetime=False)
+
 
 class TestKeyedArchive(unittest.TestCase):
     def test_keyed_archive_data(self):
@@ -1009,6 +1126,78 @@ def test__all__(self):
         not_exported = {"PlistFormat", "PLISTHEADER"}
         support.check__all__(self, plistlib, not_exported=not_exported)
 
+@unittest.skipUnless(sys.platform == "darwin", "plutil utility is for Mac os")
+class TestPlutil(unittest.TestCase):
+    file_name = "plutil_test.plist"
+    properties = {
+            "fname" : "H",
+            "lname":"A",
+            "marks" : {"a":100, "b":0x10}
+        }
+    exptected_properties = {
+        "fname" : "H",
+        "lname": "A",
+        "marks" : {"a":100, "b":16}
+    }
+    pl = {
+            "HexType" : 0x0100000c,
+            "IntType" : 0o123
+        }
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        ## Generate plist file with plistlib and parse with plutil
+        with open(cls.file_name,'wb') as f:
+            plistlib.dump(cls.properties, f, fmt=plistlib.FMT_BINARY)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        os.remove(cls.file_name)
+
+    def get_lint_status(self):
+        return subprocess.run(['plutil', "-lint", self.file_name], capture_output=True, text=True).stdout
+
+    def convert_to_json(self):
+        """Convert binary file to json using plutil
+        """
+        subprocess.run(['plutil', "-convert", 'json', self.file_name])
+
+    def convert_to_bin(self):
+        """Convert file to binary using plutil
+        """
+        subprocess.run(['plutil', "-convert", 'binary1', self.file_name])
+
+    def write_pl(self):
+        """Write Hex properties to file using writePlist
+        """
+        with open(self.file_name, 'wb') as f:
+            plistlib.dump(self.pl, f, fmt=plistlib.FMT_BINARY)
+
+    def test_lint_status(self):
+        # check lint status of file using plutil
+        self.assertEqual(f"{self.file_name}: OK\n", self.get_lint_status())
+
+    def check_content(self):
+        # check file content with plutil converting binary to json
+        self.convert_to_json()
+        with open(self.file_name) as f:
+            ff = json.loads(f.read())
+            self.assertEqual(ff, self.exptected_properties)
+
+    def check_plistlib_parse(self):
+        # Generate plist files with plutil and parse with plistlib
+        self.convert_to_bin()
+        with open(self.file_name, 'rb') as f:
+            self.assertEqual(plistlib.load(f), self.exptected_properties)
+
+    def test_octal_and_hex(self):
+        self.write_pl()
+        self.convert_to_json()
+        with open(self.file_name, 'r') as f:
+            p = json.loads(f.read())
+            self.assertEqual(p.get("HexType"), 16777228)
+            self.assertEqual(p.get("IntType"), 83)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_positional_only_arg.py b/Lib/test/test_positional_only_arg.py
index e0d784325b..4b27f4f4d3 100644
--- a/Lib/test/test_positional_only_arg.py
+++ b/Lib/test/test_positional_only_arg.py
@@ -152,8 +152,6 @@ def f(a, b, /, c):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes 3 positional arguments but 4 were given"):
             f(1, 2, 3, 4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positional_only_and_optional_arg_invalid_calls(self):
         def f(a, b, /, c=3):
             pass
@@ -198,8 +196,6 @@ def f(a, b, /):
         with self.assertRaisesRegex(TypeError, r"f\(\) takes 2 positional arguments but 3 were given"):
             f(1, 2, 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_positional_only_with_optional_invalid_calls(self):
         def f(a, b=2, /):
             pass
diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py
index 30d6b6d3c3..a4809a2379 100644
--- a/Lib/test/test_posix.py
+++ b/Lib/test/test_posix.py
@@ -1,17 +1,19 @@
 "Test posix functions"
 
 from test import support
-from test.support import import_helper
+from test.support import is_apple
 from test.support import os_helper
 from test.support import warnings_helper
 from test.support.script_helper import assert_python_ok
 
+import copy
 import errno
 import sys
 import signal
 import time
 import os
 import platform
+import pickle
 import stat
 import tempfile
 import unittest
@@ -411,8 +413,10 @@ def test_posix_fallocate(self):
             # issue33655: Also ignore EINVAL on *BSD since ZFS is also
             # often used there.
             if inst.errno == errno.EINVAL and sys.platform.startswith(
-                ('sunos', 'freebsd', 'netbsd', 'openbsd', 'gnukfreebsd')):
+                ('sunos', 'freebsd', 'openbsd', 'gnukfreebsd')):
                 raise unittest.SkipTest("test may fail on ZFS filesystems")
+            elif inst.errno == errno.EOPNOTSUPP and sys.platform.startswith("netbsd"):
+                raise unittest.SkipTest("test may fail on FFS filesystems")
             else:
                 raise
         finally:
@@ -565,8 +569,38 @@ def test_dup(self):
     @unittest.skipUnless(hasattr(posix, 'confstr'),
                          'test needs posix.confstr()')
     def test_confstr(self):
-        self.assertRaises(ValueError, posix.confstr, "CS_garbage")
-        self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
+        with self.assertRaisesRegex(
+            ValueError, "unrecognized configuration name"
+        ):
+            posix.confstr("CS_garbage")
+
+        with self.assertRaisesRegex(
+            TypeError, "configuration names must be strings or integers"
+        ):
+            posix.confstr(1.23)
+
+        path = posix.confstr("CS_PATH")
+        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):
+        with self.assertRaisesRegex(
+            ValueError, "unrecognized configuration name"
+        ):
+            posix.sysconf("SC_garbage")
+
+        with self.assertRaisesRegex(
+            TypeError, "configuration names must be strings or integers"
+        ):
+            posix.sysconf(1.23)
+
+        arg_max = posix.sysconf("SC_ARG_MAX")
+        self.assertGreater(arg_max, 0)
+        self.assertEqual(
+            posix.sysconf(posix.sysconf_names["SC_ARG_MAX"]), arg_max)
 
     @unittest.skipUnless(hasattr(posix, 'dup2'),
                          'test needs posix.dup2()')
@@ -703,7 +737,8 @@ def test_makedev(self):
         self.assertEqual(posix.major(dev), major)
         self.assertRaises(TypeError, posix.major, float(dev))
         self.assertRaises(TypeError, posix.major)
-        self.assertRaises((ValueError, OverflowError), posix.major, -1)
+        for x in -2, 2**64, -2**63-1:
+            self.assertRaises((ValueError, OverflowError), posix.major, x)
 
         minor = posix.minor(dev)
         self.assertIsInstance(minor, int)
@@ -711,13 +746,23 @@ def test_makedev(self):
         self.assertEqual(posix.minor(dev), minor)
         self.assertRaises(TypeError, posix.minor, float(dev))
         self.assertRaises(TypeError, posix.minor)
-        self.assertRaises((ValueError, OverflowError), posix.minor, -1)
+        for x in -2, 2**64, -2**63-1:
+            self.assertRaises((ValueError, OverflowError), posix.minor, x)
 
         self.assertEqual(posix.makedev(major, minor), dev)
         self.assertRaises(TypeError, posix.makedev, float(major), minor)
         self.assertRaises(TypeError, posix.makedev, major, float(minor))
         self.assertRaises(TypeError, posix.makedev, major)
         self.assertRaises(TypeError, posix.makedev)
+        for x in -2, 2**32, 2**64, -2**63-1:
+            self.assertRaises((ValueError, OverflowError), posix.makedev, x, minor)
+            self.assertRaises((ValueError, OverflowError), posix.makedev, major, x)
+
+        if sys.platform == 'linux' and not support.linked_to_musl():
+            NODEV = -1
+            self.assertEqual(posix.major(NODEV), NODEV)
+            self.assertEqual(posix.minor(NODEV), NODEV)
+            self.assertEqual(posix.makedev(NODEV, NODEV), NODEV)
 
     def _test_all_chown_common(self, chown_func, first_param, stat_func):
         """Common code for chown, fchown and lchown tests."""
@@ -781,9 +826,10 @@ def check_stat(uid, gid):
             check_stat(uid, gid)
             self.assertRaises(OSError, chown_func, first_param, 0, -1)
             check_stat(uid, gid)
-            if 0 not in os.getgroups():
-                self.assertRaises(OSError, chown_func, first_param, -1, 0)
-                check_stat(uid, gid)
+            if hasattr(os, 'getgroups'):
+                if 0 not in os.getgroups():
+                    self.assertRaises(OSError, chown_func, first_param, -1, 0)
+                    check_stat(uid, gid)
         # test illegal types
         for t in str, float:
             self.assertRaises(TypeError, chown_func, first_param, t(uid), gid)
@@ -936,6 +982,7 @@ def test_utime(self):
         posix.utime(os_helper.TESTFN, (now, now))
 
     def check_chmod(self, chmod_func, target, **kwargs):
+        closefd = not isinstance(target, int)
         mode = os.stat(target).st_mode
         try:
             new_mode = mode & ~(stat.S_IWOTH | stat.S_IWGRP | stat.S_IWUSR)
@@ -943,7 +990,7 @@ def check_chmod(self, chmod_func, target, **kwargs):
             self.assertEqual(os.stat(target).st_mode, new_mode)
             if stat.S_ISREG(mode):
                 try:
-                    with open(target, 'wb+'):
+                    with open(target, 'wb+', closefd=closefd):
                         pass
                 except PermissionError:
                     pass
@@ -951,10 +998,10 @@ def check_chmod(self, chmod_func, target, **kwargs):
             chmod_func(target, new_mode, **kwargs)
             self.assertEqual(os.stat(target).st_mode, new_mode)
             if stat.S_ISREG(mode):
-                with open(target, 'wb+'):
+                with open(target, 'wb+', closefd=closefd):
                     pass
         finally:
-            posix.chmod(target, mode)
+            chmod_func(target, mode)
 
     @os_helper.skip_unless_working_chmod
     def test_chmod_file(self):
@@ -971,6 +1018,13 @@ 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:
+            self.check_chmod(posix.fchmod, f.fileno())
+            self.check_chmod(posix.chmod, f.fileno())
+
     @unittest.skipUnless(hasattr(posix, 'lchmod'), 'test needs os.lchmod()')
     def test_lchmod_file(self):
         self.check_chmod(posix.lchmod, os_helper.TESTFN)
@@ -1019,8 +1073,9 @@ def test_chmod_file_symlink(self):
             self.check_lchmod_link(posix.chmod, target, link)
         else:
             self.check_chmod_link(posix.chmod, target, link)
-            self.check_chmod_link(posix.chmod, target, link, follow_symlinks=True)
+        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()
@@ -1031,7 +1086,7 @@ def test_chmod_dir_symlink(self):
             self.check_lchmod_link(posix.chmod, target, link)
         else:
             self.check_chmod_link(posix.chmod, target, link)
-            self.check_chmod_link(posix.chmod, target, link, follow_symlinks=True)
+        self.check_chmod_link(posix.chmod, target, link, follow_symlinks=True)
 
     @unittest.skipUnless(hasattr(posix, 'lchmod'), 'test needs os.lchmod()')
     @os_helper.skip_unless_symlink
@@ -1249,8 +1304,8 @@ def test_sched_priority(self):
         self.assertIsInstance(lo, int)
         self.assertIsInstance(hi, int)
         self.assertGreaterEqual(hi, lo)
-        # OSX evidently just returns 15 without checking the argument.
-        if sys.platform != "darwin":
+        # Apple platforms return 15 without checking the argument.
+        if not is_apple:
             self.assertRaises(OSError, posix.sched_get_priority_min, -23)
             self.assertRaises(OSError, posix.sched_get_priority_max, -23)
 
@@ -1262,9 +1317,10 @@ def test_get_and_set_scheduler_and_param(self):
         self.assertIn(mine, possible_schedulers)
         try:
             parent = posix.sched_getscheduler(os.getppid())
-        except OSError as e:
-            if e.errno != errno.EPERM:
-                raise
+        except PermissionError:
+            # POSIX specifies EPERM, but Android returns EACCES. Both errno
+            # values are mapped to PermissionError.
+            pass
         else:
             self.assertIn(parent, possible_schedulers)
         self.assertRaises(OSError, posix.sched_getscheduler, -1)
@@ -1279,9 +1335,8 @@ def test_get_and_set_scheduler_and_param(self):
             try:
                 posix.sched_setscheduler(0, mine, param)
                 posix.sched_setparam(0, param)
-            except OSError as e:
-                if e.errno != errno.EPERM:
-                    raise
+            except PermissionError:
+                pass
             self.assertRaises(OSError, posix.sched_setparam, -1, param)
 
         self.assertRaises(OSError, posix.sched_setscheduler, -1, mine, param)
@@ -1295,6 +1350,26 @@ 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)
+        for proto in range(pickle.HIGHEST_PROTOCOL+1):
+            newparam = pickle.loads(pickle.dumps(param, proto))
+            self.assertEqual(newparam, param)
+        newparam = copy.copy(param)
+        self.assertIsNot(newparam, param)
+        self.assertEqual(newparam, param)
+        newparam = copy.deepcopy(param)
+        self.assertIsNot(newparam, param)
+        self.assertEqual(newparam, param)
+        newparam = copy.replace(param)
+        self.assertIsNot(newparam, param)
+        self.assertEqual(newparam, param)
+        newparam = copy.replace(param, sched_priority=0)
+        self.assertNotEqual(newparam, param)
+        self.assertEqual(newparam.sched_priority, 0)
+
     @unittest.skipUnless(hasattr(posix, "sched_rr_get_interval"), "no function")
     def test_sched_rr_get_interval(self):
         try:
@@ -1495,6 +1570,7 @@ 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):
@@ -1515,6 +1591,13 @@ def test_stat_dir_fd(self):
             self.assertRaises(OverflowError,
                     posix.stat, name, dir_fd=10**20)
 
+            for fd in False, True:
+                with self.assertWarnsRegex(RuntimeWarning,
+                        'bool is used as a file descriptor') as cm:
+                    with self.assertRaises(OSError):
+                        posix.stat('nonexisting', dir_fd=fd)
+                self.assertEqual(cm.filename, __file__)
+
     @unittest.skipUnless(os.utime in os.supports_dir_fd, "test needs dir_fd support in os.utime()")
     def test_utime_dir_fd(self):
         with self.prepare_file() as (dir_fd, name, fullname):
@@ -1890,7 +1973,7 @@ def test_setsigdef_wrong_type(self):
                             [sys.executable, "-c", "pass"],
                             os.environ, setsigdef=[signal.NSIG, signal.NSIG+1])
 
-    @unittest.expectedFailure
+    @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")
@@ -1911,10 +1994,15 @@ def test_setscheduler_only_param(self):
         )
         support.wait_process(pid, exitcode=0)
 
-    @unittest.expectedFailure
+    @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],
+                     "Skip test due to glibc posix_spawn policy")
     def test_setscheduler_with_policy(self):
         policy = os.sched_getscheduler(0)
         priority = os.sched_get_priority_min(policy)
@@ -1993,8 +2081,7 @@ def test_open_file(self):
         with open(outfile, encoding="utf-8") as f:
             self.assertEqual(f.read(), 'hello')
 
-    # TODO: RUSTPYTHON: FileNotFoundError: [Errno 2] No such file or directory (os error 2): '@test_55144_tmp' -> 'None'
-    @unittest.expectedFailure
+    @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)
@@ -2034,11 +2121,13 @@ def test_dup2(self):
 
 
 @unittest.skipUnless(hasattr(os, 'posix_spawn'), "test needs os.posix_spawn")
+@support.requires_subprocess()
 class TestPosixSpawn(unittest.TestCase, _PosixSpawnMixin):
     spawn_func = getattr(posix, 'posix_spawn', None)
 
 
 @unittest.skipUnless(hasattr(os, 'posix_spawnp'), "test needs os.posix_spawnp")
+@support.requires_subprocess()
 class TestPosixSpawnP(unittest.TestCase, _PosixSpawnMixin):
     spawn_func = getattr(posix, 'posix_spawnp', None)
 
@@ -2115,6 +2204,13 @@ def test_stat(self):
             with self.assertRaisesRegex(NotImplementedError, "dir_fd unavailable"):
                 os.stat("file", dir_fd=0)
 
+    def test_ptsname_r(self):
+        self._verify_available("HAVE_PTSNAME_R")
+        if self.mac_ver >= (10, 13, 4):
+            self.assertIn("HAVE_PTSNAME_R", posix._have_functions)
+        else:
+            self.assertNotIn("HAVE_PTSNAME_R", posix._have_functions)
+
     def test_access(self):
         self._verify_available("HAVE_FACCESSAT")
         if self.mac_ver >= (10, 10):
diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py
index 4890bcc75e..0dc0211ead 100644
--- a/Lib/test/test_posixpath.py
+++ b/Lib/test/test_posixpath.py
@@ -1,12 +1,16 @@
+import inspect
 import os
 import posixpath
+import random
 import sys
 import unittest
-from posixpath import realpath, abspath, dirname, basename
+from functools import partial
+from posixpath import realpath, abspath, dirname, basename, ALLOW_MISSING
+from test import support
 from test import test_genericpath
 from test.support import import_helper
 from test.support import os_helper
-from test.support.os_helper import FakePath
+from test.support.os_helper import FakePath, TESTFN
 from unittest import mock
 
 try:
@@ -18,7 +22,7 @@
 # An absolute path to a temporary filename for testing. We can't rely on TESTFN
 # being an absolute path, so we need this.
 
-ABSTFN = abspath(os_helper.TESTFN)
+ABSTFN = abspath(TESTFN)
 
 def skip_if_ABSTFN_contains_backslash(test):
     """
@@ -30,35 +34,40 @@ def skip_if_ABSTFN_contains_backslash(test):
     msg = "ABSTFN is not a posix path - tests fail"
     return [test, unittest.skip(msg)(test)][found_backslash]
 
-def safe_rmdir(dirname):
-    try:
-        os.rmdir(dirname)
-    except OSError:
-        pass
+
+def _parameterize(*parameters):
+    return support.subTests('kwargs', parameters)
+
 
 class PosixPathTest(unittest.TestCase):
 
     def setUp(self):
-        self.tearDown()
-
-    def tearDown(self):
         for suffix in ["", "1", "2"]:
-            os_helper.unlink(os_helper.TESTFN + suffix)
-            safe_rmdir(os_helper.TESTFN + suffix)
+            self.assertFalse(posixpath.lexists(ABSTFN + suffix))
 
     def test_join(self):
-        self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"),
-                         "/bar/baz")
-        self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz")
-        self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"),
-                         "/foo/bar/baz/")
-
-        self.assertEqual(posixpath.join(b"/foo", b"bar", b"/bar", b"baz"),
-                         b"/bar/baz")
-        self.assertEqual(posixpath.join(b"/foo", b"bar", b"baz"),
-                         b"/foo/bar/baz")
-        self.assertEqual(posixpath.join(b"/foo/", b"bar/", b"baz/"),
-                         b"/foo/bar/baz/")
+        fn = posixpath.join
+        self.assertEqual(fn("/foo", "bar", "/bar", "baz"), "/bar/baz")
+        self.assertEqual(fn("/foo", "bar", "baz"),         "/foo/bar/baz")
+        self.assertEqual(fn("/foo/", "bar/", "baz/"),      "/foo/bar/baz/")
+
+        self.assertEqual(fn(b"/foo", b"bar", b"/bar", b"baz"), b"/bar/baz")
+        self.assertEqual(fn(b"/foo", b"bar", b"baz"),          b"/foo/bar/baz")
+        self.assertEqual(fn(b"/foo/", b"bar/", b"baz/"),       b"/foo/bar/baz/")
+
+        self.assertEqual(fn("a", ""),          "a/")
+        self.assertEqual(fn("a", "", ""),      "a/")
+        self.assertEqual(fn("a", "b"),         "a/b")
+        self.assertEqual(fn("a", "b/"),        "a/b/")
+        self.assertEqual(fn("a/", "b"),        "a/b")
+        self.assertEqual(fn("a/", "b/"),       "a/b/")
+        self.assertEqual(fn("a", "b/c", "d"),  "a/b/c/d")
+        self.assertEqual(fn("a", "b//c", "d"), "a/b//c/d")
+        self.assertEqual(fn("a", "b/c/", "d"), "a/b/c/d")
+        self.assertEqual(fn("/a", "b"),        "/a/b")
+        self.assertEqual(fn("/a/", "b"),       "/a/b")
+        self.assertEqual(fn("a", "/b", "c"),   "/b/c")
+        self.assertEqual(fn("a", "/b", "/c"),  "/c")
 
     def test_split(self):
         self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar"))
@@ -180,27 +189,29 @@ def test_dirname(self):
         self.assertEqual(posixpath.dirname(b"////foo"), b"////")
         self.assertEqual(posixpath.dirname(b"//foo//bar"), b"//foo")
 
-    @unittest.expectedFailureIf(os.name == "nt", "TODO: RUSTPYTHON")
     def test_islink(self):
-        self.assertIs(posixpath.islink(os_helper.TESTFN + "1"), False)
-        self.assertIs(posixpath.lexists(os_helper.TESTFN + "2"), False)
+        self.assertIs(posixpath.islink(TESTFN + "1"), False)
+        self.assertIs(posixpath.lexists(TESTFN + "2"), False)
 
-        with open(os_helper.TESTFN + "1", "wb") as f:
+        self.addCleanup(os_helper.unlink, TESTFN + "1")
+        with open(TESTFN + "1", "wb") as f:
             f.write(b"foo")
-        self.assertIs(posixpath.islink(os_helper.TESTFN + "1"), False)
+        self.assertIs(posixpath.islink(TESTFN + "1"), False)
 
         if os_helper.can_symlink():
-            os.symlink(os_helper.TESTFN + "1", os_helper.TESTFN + "2")
-            self.assertIs(posixpath.islink(os_helper.TESTFN + "2"), True)
-            os.remove(os_helper.TESTFN + "1")
-            self.assertIs(posixpath.islink(os_helper.TESTFN + "2"), True)
-            self.assertIs(posixpath.exists(os_helper.TESTFN + "2"), False)
-            self.assertIs(posixpath.lexists(os_helper.TESTFN + "2"), True)
-
-        self.assertIs(posixpath.islink(os_helper.TESTFN + "\udfff"), False)
-        self.assertIs(posixpath.islink(os.fsencode(os_helper.TESTFN) + b"\xff"), False)
-        self.assertIs(posixpath.islink(os_helper.TESTFN + "\x00"), False)
-        self.assertIs(posixpath.islink(os.fsencode(os_helper.TESTFN) + b"\x00"), False)
+            self.addCleanup(os_helper.unlink, TESTFN + "2")
+            os.symlink(TESTFN + "1", TESTFN + "2")
+            self.assertIs(posixpath.islink(TESTFN + "2"), True)
+            os.remove(TESTFN + "1")
+            self.assertIs(posixpath.islink(TESTFN + "2"), True)
+            self.assertIs(posixpath.exists(TESTFN + "2"), False)
+            self.assertIs(posixpath.lexists(TESTFN + "2"), True)
+
+    def test_islink_invalid_paths(self):
+        self.assertIs(posixpath.islink(TESTFN + "\udfff"), False)
+        self.assertIs(posixpath.islink(os.fsencode(TESTFN) + b"\xff"), False)
+        self.assertIs(posixpath.islink(TESTFN + "\x00"), False)
+        self.assertIs(posixpath.islink(os.fsencode(TESTFN) + b"\x00"), False)
 
     def test_ismount(self):
         self.assertIs(posixpath.ismount("/"), True)
@@ -215,14 +226,14 @@ def test_ismount_non_existent(self):
             os.mkdir(ABSTFN)
             self.assertIs(posixpath.ismount(ABSTFN), False)
         finally:
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN)
 
+    def test_ismount_invalid_paths(self):
         self.assertIs(posixpath.ismount('/\udfff'), False)
         self.assertIs(posixpath.ismount(b'/\xff'), False)
         self.assertIs(posixpath.ismount('/\x00'), False)
         self.assertIs(posixpath.ismount(b'/\x00'), False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_ismount_symlinks(self):
         # Symlinks are never mountpoints.
@@ -230,7 +241,7 @@ def test_ismount_symlinks(self):
             os.symlink("/", ABSTFN)
             self.assertIs(posixpath.ismount(ABSTFN), False)
         finally:
-            os.unlink(ABSTFN)
+            os_helper.unlink(ABSTFN)
 
     @unittest.skipIf(posix is None, "Test requires posix module")
     def test_ismount_different_device(self):
@@ -275,6 +286,16 @@ def fake_lstat(path):
     def test_isjunction(self):
         self.assertFalse(posixpath.isjunction(ABSTFN))
 
+    @unittest.skipIf(sys.platform == 'win32', "Fast paths are not for win32")
+    @support.cpython_only
+    def test_fast_paths_in_use(self):
+        # There are fast paths of these functions implemented in posixmodule.c.
+        # Confirm that they are being used, and not the Python fallbacks
+        self.assertTrue(os.path.splitroot is posix._path_splitroot_ex)
+        self.assertFalse(inspect.isfunction(os.path.splitroot))
+        self.assertTrue(os.path.normpath is posix._path_normpath)
+        self.assertFalse(inspect.isfunction(os.path.normpath))
+
     def test_expanduser(self):
         self.assertEqual(posixpath.expanduser("foo"), "foo")
         self.assertEqual(posixpath.expanduser(b"foo"), b"foo")
@@ -336,12 +357,38 @@ def test_expanduser_pwd(self):
                 for path in ('~', '~/.local', '~vstinner/'):
                     self.assertEqual(posixpath.expanduser(path), path)
 
+    @unittest.skipIf(sys.platform == "vxworks",
+                     "no home directory on VxWorks")
+    def test_expanduser_pwd2(self):
+        pwd = import_helper.import_module('pwd')
+        getpwall = support.get_attribute(pwd, 'getpwall')
+        names = [entry.pw_name for entry in getpwall()]
+        maxusers = 1000 if support.is_resource_enabled('cpu') else 100
+        if len(names) > maxusers:
+            # Select random names, half of them with non-ASCII name,
+            # if available.
+            random.shuffle(names)
+            names.sort(key=lambda name: name.isascii())
+            del names[maxusers//2:-maxusers//2]
+        for name in names:
+            # gh-121200: pw_dir can be different between getpwall() and
+            # getpwnam(), so use getpwnam() pw_dir as expanduser() does.
+            entry = pwd.getpwnam(name)
+            home = entry.pw_dir
+            home = home.rstrip('/') or '/'
+
+            with self.subTest(name=name, pw_dir=entry.pw_dir):
+                self.assertEqual(posixpath.expanduser('~' + name), home)
+                self.assertEqual(posixpath.expanduser(os.fsencode('~' + name)),
+                                 os.fsencode(home))
+
     NORMPATH_CASES = [
         ("", "."),
         ("/", "/"),
         ("/.", "/"),
         ("/./", "/"),
         ("/.//.", "/"),
+        ("/./foo/bar", "/foo/bar"),
         ("/foo", "/foo"),
         ("/foo/bar", "/foo/bar"),
         ("//", "//"),
@@ -351,6 +398,7 @@ def test_expanduser_pwd(self):
         ("///..//./foo/.//bar", "/foo/bar"),
         (".", "."),
         (".//.", "."),
+        ("./foo/bar", "foo/bar"),
         ("..", ".."),
         ("../", ".."),
         ("../foo", "../foo"),
@@ -400,32 +448,35 @@ def test_normpath(self):
                 self.assertEqual(result, expected)
 
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_curdir(self):
-        self.assertEqual(realpath('.'), os.getcwd())
-        self.assertEqual(realpath('./.'), os.getcwd())
-        self.assertEqual(realpath('/'.join(['.'] * 100)), os.getcwd())
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_curdir(self, kwargs):
+        self.assertEqual(realpath('.', **kwargs), os.getcwd())
+        self.assertEqual(realpath('./.', **kwargs), os.getcwd())
+        self.assertEqual(realpath('/'.join(['.'] * 100), **kwargs), os.getcwd())
 
-        self.assertEqual(realpath(b'.'), os.getcwdb())
-        self.assertEqual(realpath(b'./.'), os.getcwdb())
-        self.assertEqual(realpath(b'/'.join([b'.'] * 100)), os.getcwdb())
+        self.assertEqual(realpath(b'.', **kwargs), os.getcwdb())
+        self.assertEqual(realpath(b'./.', **kwargs), os.getcwdb())
+        self.assertEqual(realpath(b'/'.join([b'.'] * 100), **kwargs), os.getcwdb())
 
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_pardir(self):
-        self.assertEqual(realpath('..'), dirname(os.getcwd()))
-        self.assertEqual(realpath('../..'), dirname(dirname(os.getcwd())))
-        self.assertEqual(realpath('/'.join(['..'] * 100)), '/')
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_pardir(self, kwargs):
+        self.assertEqual(realpath('..', **kwargs), dirname(os.getcwd()))
+        self.assertEqual(realpath('../..', **kwargs), dirname(dirname(os.getcwd())))
+        self.assertEqual(realpath('/'.join(['..'] * 100), **kwargs), '/')
 
-        self.assertEqual(realpath(b'..'), dirname(os.getcwdb()))
-        self.assertEqual(realpath(b'../..'), dirname(dirname(os.getcwdb())))
-        self.assertEqual(realpath(b'/'.join([b'..'] * 100)), b'/')
+        self.assertEqual(realpath(b'..', **kwargs), dirname(os.getcwdb()))
+        self.assertEqual(realpath(b'../..', **kwargs), dirname(dirname(os.getcwdb())))
+        self.assertEqual(realpath(b'/'.join([b'..'] * 100), **kwargs), b'/')
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_basic(self):
+    @_parameterize({}, {'strict': ALLOW_MISSING})
+    def test_realpath_basic(self, kwargs):
         # Basic operation.
         try:
             os.symlink(ABSTFN+"1", ABSTFN)
-            self.assertEqual(realpath(ABSTFN), ABSTFN+"1")
+            self.assertEqual(realpath(ABSTFN, **kwargs), ABSTFN+"1")
         finally:
             os_helper.unlink(ABSTFN)
 
@@ -441,15 +492,122 @@ def test_realpath_strict(self):
         finally:
             os_helper.unlink(ABSTFN)
 
+    def test_realpath_invalid_paths(self):
+        path = '/\x00'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(ValueError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = b'/\x00'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(ValueError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = '/nonexistent/x\x00'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = b'/nonexistent/x\x00'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = '/\x00/..'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(ValueError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = b'/\x00/..'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(ValueError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+
+        path = '/nonexistent/x\x00/..'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+        path = b'/nonexistent/x\x00/..'
+        self.assertRaises(ValueError, realpath, path, strict=False)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+        self.assertRaises(ValueError, realpath, path, strict=ALLOW_MISSING)
+
+        path = '/\udfff'
+        if sys.platform == 'win32':
+            self.assertEqual(realpath(path, strict=False), path)
+            self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+            self.assertEqual(realpath(path, strict=ALLOW_MISSING), path)
+        else:
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=True)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=ALLOW_MISSING)
+        path = '/nonexistent/\udfff'
+        if sys.platform == 'win32':
+            self.assertEqual(realpath(path, strict=False), path)
+            self.assertEqual(realpath(path, strict=ALLOW_MISSING), path)
+        else:
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=ALLOW_MISSING)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+        path = '/\udfff/..'
+        if sys.platform == 'win32':
+            self.assertEqual(realpath(path, strict=False), '/')
+            self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+            self.assertEqual(realpath(path, strict=ALLOW_MISSING), '/')
+        else:
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=True)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=ALLOW_MISSING)
+        path = '/nonexistent/\udfff/..'
+        if sys.platform == 'win32':
+            self.assertEqual(realpath(path, strict=False), '/nonexistent')
+            self.assertEqual(realpath(path, strict=ALLOW_MISSING), '/nonexistent')
+        else:
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeEncodeError, realpath, path, strict=ALLOW_MISSING)
+        self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+
+        path = b'/\xff'
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeDecodeError, realpath, path, strict=True)
+            self.assertRaises(UnicodeDecodeError, realpath, path, strict=ALLOW_MISSING)
+        else:
+            self.assertEqual(realpath(path, strict=False), path)
+            if support.is_wasi:
+                self.assertRaises(OSError, realpath, path, strict=True)
+                self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+            else:
+                self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+                self.assertEqual(realpath(path, strict=ALLOW_MISSING), path)
+        path = b'/nonexistent/\xff'
+        if sys.platform == 'win32':
+            self.assertRaises(UnicodeDecodeError, realpath, path, strict=False)
+            self.assertRaises(UnicodeDecodeError, realpath, path, strict=ALLOW_MISSING)
+        else:
+            self.assertEqual(realpath(path, strict=False), path)
+        if support.is_wasi:
+            self.assertRaises(OSError, realpath, path, strict=True)
+            self.assertRaises(OSError, realpath, path, strict=ALLOW_MISSING)
+        else:
+            self.assertRaises(FileNotFoundError, realpath, path, strict=True)
+
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_relative(self):
+    @_parameterize({}, {'strict': ALLOW_MISSING})
+    def test_realpath_relative(self, kwargs):
         try:
             os.symlink(posixpath.relpath(ABSTFN+"1"), ABSTFN)
-            self.assertEqual(realpath(ABSTFN), ABSTFN+"1")
+            self.assertEqual(realpath(ABSTFN, **kwargs), ABSTFN+"1")
         finally:
             os_helper.unlink(ABSTFN)
 
+    @os_helper.skip_unless_symlink
+    @skip_if_ABSTFN_contains_backslash
+    @_parameterize({}, {'strict': ALLOW_MISSING})
+    def test_realpath_missing_pardir(self, kwargs):
+        try:
+            os.symlink(TESTFN + "1", TESTFN)
+            self.assertEqual(
+                realpath("nonexistent/../" + TESTFN, **kwargs), ABSTFN + "1")
+        finally:
+            os_helper.unlink(TESTFN)
+
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
     def test_realpath_symlink_loops(self):
@@ -469,7 +627,7 @@ def test_realpath_symlink_loops(self):
             self.assertEqual(realpath(ABSTFN+"1/../x"), dirname(ABSTFN) + "/x")
             os.symlink(ABSTFN+"x", ABSTFN+"y")
             self.assertEqual(realpath(ABSTFN+"1/../" + basename(ABSTFN) + "y"),
-                             ABSTFN + "y")
+                             ABSTFN + "x")
             self.assertEqual(realpath(ABSTFN+"1/../" + basename(ABSTFN) + "1"),
                              ABSTFN + "1")
 
@@ -493,37 +651,38 @@ def test_realpath_symlink_loops(self):
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_symlink_loops_strict(self):
+    @_parameterize({'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_symlink_loops_strict(self, kwargs):
         # Bug #43757, raise OSError if we get into an infinite symlink loop in
-        # strict mode.
+        # the strict modes.
         try:
             os.symlink(ABSTFN, ABSTFN)
-            self.assertRaises(OSError, realpath, ABSTFN, strict=True)
+            self.assertRaises(OSError, realpath, ABSTFN, **kwargs)
 
             os.symlink(ABSTFN+"1", ABSTFN+"2")
             os.symlink(ABSTFN+"2", ABSTFN+"1")
-            self.assertRaises(OSError, realpath, ABSTFN+"1", strict=True)
-            self.assertRaises(OSError, realpath, ABSTFN+"2", strict=True)
+            self.assertRaises(OSError, realpath, ABSTFN+"1", **kwargs)
+            self.assertRaises(OSError, realpath, ABSTFN+"2", **kwargs)
 
-            self.assertRaises(OSError, realpath, ABSTFN+"1/x", strict=True)
-            self.assertRaises(OSError, realpath, ABSTFN+"1/..", strict=True)
-            self.assertRaises(OSError, realpath, ABSTFN+"1/../x", strict=True)
+            self.assertRaises(OSError, realpath, ABSTFN+"1/x", **kwargs)
+            self.assertRaises(OSError, realpath, ABSTFN+"1/..", **kwargs)
+            self.assertRaises(OSError, realpath, ABSTFN+"1/../x", **kwargs)
             os.symlink(ABSTFN+"x", ABSTFN+"y")
             self.assertRaises(OSError, realpath,
-                              ABSTFN+"1/../" + basename(ABSTFN) + "y", strict=True)
+                              ABSTFN+"1/../" + basename(ABSTFN) + "y", **kwargs)
             self.assertRaises(OSError, realpath,
-                              ABSTFN+"1/../" + basename(ABSTFN) + "1", strict=True)
+                              ABSTFN+"1/../" + basename(ABSTFN) + "1", **kwargs)
 
             os.symlink(basename(ABSTFN) + "a/b", ABSTFN+"a")
-            self.assertRaises(OSError, realpath, ABSTFN+"a", strict=True)
+            self.assertRaises(OSError, realpath, ABSTFN+"a", **kwargs)
 
             os.symlink("../" + basename(dirname(ABSTFN)) + "/" +
                        basename(ABSTFN) + "c", ABSTFN+"c")
-            self.assertRaises(OSError, realpath, ABSTFN+"c", strict=True)
+            self.assertRaises(OSError, realpath, ABSTFN+"c", **kwargs)
 
             # Test using relative path as well.
             with os_helper.change_cwd(dirname(ABSTFN)):
-                self.assertRaises(OSError, realpath, basename(ABSTFN), strict=True)
+                self.assertRaises(OSError, realpath, basename(ABSTFN), **kwargs)
         finally:
             os_helper.unlink(ABSTFN)
             os_helper.unlink(ABSTFN+"1")
@@ -534,28 +693,30 @@ def test_realpath_symlink_loops_strict(self):
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_repeated_indirect_symlinks(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_repeated_indirect_symlinks(self, kwargs):
         # Issue #6975.
         try:
             os.mkdir(ABSTFN)
             os.symlink('../' + basename(ABSTFN), ABSTFN + '/self')
             os.symlink('self/self/self', ABSTFN + '/link')
-            self.assertEqual(realpath(ABSTFN + '/link'), ABSTFN)
+            self.assertEqual(realpath(ABSTFN + '/link', **kwargs), ABSTFN)
         finally:
             os_helper.unlink(ABSTFN + '/self')
             os_helper.unlink(ABSTFN + '/link')
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN)
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_deep_recursion(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_deep_recursion(self, kwargs):
         depth = 10
         try:
             os.mkdir(ABSTFN)
             for i in range(depth):
                 os.symlink('/'.join(['%d' % i] * 10), ABSTFN + '/%d' % (i + 1))
             os.symlink('.', ABSTFN + '/0')
-            self.assertEqual(realpath(ABSTFN + '/%d' % depth), ABSTFN)
+            self.assertEqual(realpath(ABSTFN + '/%d' % depth, **kwargs), ABSTFN)
 
             # Test using relative path as well.
             with os_helper.change_cwd(ABSTFN):
@@ -563,11 +724,12 @@ def test_realpath_deep_recursion(self):
         finally:
             for i in range(depth + 1):
                 os_helper.unlink(ABSTFN + '/%d' % i)
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN)
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_resolve_parents(self):
+    @_parameterize({}, {'strict': ALLOW_MISSING})
+    def test_realpath_resolve_parents(self, kwargs):
         # We also need to resolve any symlinks in the parents of a relative
         # path passed to realpath. E.g.: current working directory is
         # /usr/doc with 'doc' being a symlink to /usr/share/doc. We call
@@ -578,15 +740,17 @@ def test_realpath_resolve_parents(self):
             os.symlink(ABSTFN + "/y", ABSTFN + "/k")
 
             with os_helper.change_cwd(ABSTFN + "/k"):
-                self.assertEqual(realpath("a"), ABSTFN + "/y/a")
+                self.assertEqual(realpath("a", **kwargs),
+                                    ABSTFN + "/y/a")
         finally:
             os_helper.unlink(ABSTFN + "/k")
-            safe_rmdir(ABSTFN + "/y")
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN + "/y")
+            os_helper.rmdir(ABSTFN)
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_resolve_before_normalizing(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_resolve_before_normalizing(self, kwargs):
         # Bug #990669: Symbolic links should be resolved before we
         # normalize the path. E.g.: if we have directories 'a', 'k' and 'y'
         # in the following hierarchy:
@@ -601,20 +765,21 @@ def test_realpath_resolve_before_normalizing(self):
             os.symlink(ABSTFN + "/k/y", ABSTFN + "/link-y")
 
             # Absolute path.
-            self.assertEqual(realpath(ABSTFN + "/link-y/.."), ABSTFN + "/k")
+            self.assertEqual(realpath(ABSTFN + "/link-y/..", **kwargs), ABSTFN + "/k")
             # Relative path.
             with os_helper.change_cwd(dirname(ABSTFN)):
-                self.assertEqual(realpath(basename(ABSTFN) + "/link-y/.."),
+                self.assertEqual(realpath(basename(ABSTFN) + "/link-y/..", **kwargs),
                                  ABSTFN + "/k")
         finally:
             os_helper.unlink(ABSTFN + "/link-y")
-            safe_rmdir(ABSTFN + "/k/y")
-            safe_rmdir(ABSTFN + "/k")
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN + "/k/y")
+            os_helper.rmdir(ABSTFN + "/k")
+            os_helper.rmdir(ABSTFN)
 
     @os_helper.skip_unless_symlink
     @skip_if_ABSTFN_contains_backslash
-    def test_realpath_resolve_first(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_resolve_first(self, kwargs):
         # Bug #1213894: The first component of the path, if not absolute,
         # must be resolved too.
 
@@ -624,17 +789,192 @@ def test_realpath_resolve_first(self):
             os.symlink(ABSTFN, ABSTFN + "link")
             with os_helper.change_cwd(dirname(ABSTFN)):
                 base = basename(ABSTFN)
-                self.assertEqual(realpath(base + "link"), ABSTFN)
-                self.assertEqual(realpath(base + "link/k"), ABSTFN + "/k")
+                self.assertEqual(realpath(base + "link", **kwargs), ABSTFN)
+                self.assertEqual(realpath(base + "link/k", **kwargs), ABSTFN + "/k")
         finally:
             os_helper.unlink(ABSTFN + "link")
-            safe_rmdir(ABSTFN + "/k")
-            safe_rmdir(ABSTFN)
+            os_helper.rmdir(ABSTFN + "/k")
+            os_helper.rmdir(ABSTFN)
+
+    @os_helper.skip_unless_symlink
+    @skip_if_ABSTFN_contains_backslash
+    @unittest.skipIf(os.chmod not in os.supports_follow_symlinks, "Can't set symlink permissions")
+    @unittest.skipIf(sys.platform != "darwin", "only macOS requires read permission to readlink()")
+    def test_realpath_unreadable_symlink(self):
+        try:
+            os.symlink(ABSTFN+"1", ABSTFN)
+            os.chmod(ABSTFN, 0o000, follow_symlinks=False)
+            self.assertEqual(realpath(ABSTFN), ABSTFN)
+            self.assertEqual(realpath(ABSTFN + '/foo'), ABSTFN + '/foo')
+            self.assertEqual(realpath(ABSTFN + '/../foo'), dirname(ABSTFN) + '/foo')
+            self.assertEqual(realpath(ABSTFN + '/foo/..'), ABSTFN)
+        finally:
+            os.chmod(ABSTFN, 0o755, follow_symlinks=False)
+            os_helper.unlink(ABSTFN)
+
+    @os_helper.skip_unless_symlink
+    @skip_if_ABSTFN_contains_backslash
+    @unittest.skipIf(os.chmod not in os.supports_follow_symlinks, "Can't set symlink permissions")
+    @unittest.skipIf(sys.platform != "darwin", "only macOS requires read permission to readlink()")
+    @_parameterize({'strict': True}, {'strict': ALLOW_MISSING})
+    def test_realpath_unreadable_symlink_strict(self, kwargs):
+        try:
+            os.symlink(ABSTFN+"1", ABSTFN)
+            os.chmod(ABSTFN, 0o000, follow_symlinks=False)
+            with self.assertRaises(PermissionError):
+                realpath(ABSTFN, **kwargs)
+            with self.assertRaises(PermissionError):
+                realpath(ABSTFN + '/foo', **kwargs),
+            with self.assertRaises(PermissionError):
+                realpath(ABSTFN + '/../foo', **kwargs)
+            with self.assertRaises(PermissionError):
+                realpath(ABSTFN + '/foo/..', **kwargs)
+        finally:
+            os.chmod(ABSTFN, 0o755, follow_symlinks=False)
+            os.unlink(ABSTFN)
+
+    @skip_if_ABSTFN_contains_backslash
+    @os_helper.skip_unless_symlink
+    def test_realpath_unreadable_directory(self):
+        try:
+            os.mkdir(ABSTFN)
+            os.mkdir(ABSTFN + '/k')
+            os.chmod(ABSTFN, 0o000)
+            self.assertEqual(realpath(ABSTFN, strict=False), ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=True), ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=ALLOW_MISSING), ABSTFN)
+
+            try:
+                os.stat(ABSTFN)
+            except PermissionError:
+                pass
+            else:
+                self.skipTest('Cannot block permissions')
+
+            self.assertEqual(realpath(ABSTFN + '/k', strict=False),
+                             ABSTFN + '/k')
+            self.assertRaises(PermissionError, realpath, ABSTFN + '/k',
+                              strict=True)
+            self.assertRaises(PermissionError, realpath, ABSTFN + '/k',
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + '/missing', strict=False),
+                             ABSTFN + '/missing')
+            self.assertRaises(PermissionError, realpath, ABSTFN + '/missing',
+                              strict=True)
+            self.assertRaises(PermissionError, realpath, ABSTFN + '/missing',
+                              strict=ALLOW_MISSING)
+        finally:
+            os.chmod(ABSTFN, 0o755)
+            os_helper.rmdir(ABSTFN + '/k')
+            os_helper.rmdir(ABSTFN)
+
+    @skip_if_ABSTFN_contains_backslash
+    def test_realpath_nonterminal_file(self):
+        try:
+            with open(ABSTFN, 'w') as f:
+                f.write('test_posixpath wuz ere')
+            self.assertEqual(realpath(ABSTFN, strict=False), ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=True), ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=ALLOW_MISSING), ABSTFN)
+
+            self.assertEqual(realpath(ABSTFN + "/", strict=False), ABSTFN)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/.", strict=False), ABSTFN)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/..", strict=False), dirname(ABSTFN))
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/subdir", strict=False), ABSTFN + "/subdir")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir",
+                              strict=ALLOW_MISSING)
+        finally:
+            os_helper.unlink(ABSTFN)
+
+    @os_helper.skip_unless_symlink
+    @skip_if_ABSTFN_contains_backslash
+    def test_realpath_nonterminal_symlink_to_file(self):
+        try:
+            with open(ABSTFN + "1", 'w') as f:
+                f.write('test_posixpath wuz ere')
+            os.symlink(ABSTFN + "1", ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=False), ABSTFN + "1")
+            self.assertEqual(realpath(ABSTFN, strict=True), ABSTFN + "1")
+            self.assertEqual(realpath(ABSTFN, strict=ALLOW_MISSING), ABSTFN + "1")
+
+            self.assertEqual(realpath(ABSTFN + "/", strict=False), ABSTFN + "1")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/.", strict=False), ABSTFN + "1")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/..", strict=False), dirname(ABSTFN))
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/subdir", strict=False), ABSTFN + "1/subdir")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir",
+                              strict=ALLOW_MISSING)
+        finally:
+            os_helper.unlink(ABSTFN)
+            os_helper.unlink(ABSTFN + "1")
+
+    @os_helper.skip_unless_symlink
+    @skip_if_ABSTFN_contains_backslash
+    def test_realpath_nonterminal_symlink_to_symlinks_to_file(self):
+        try:
+            with open(ABSTFN + "2", 'w') as f:
+                f.write('test_posixpath wuz ere')
+            os.symlink(ABSTFN + "2", ABSTFN + "1")
+            os.symlink(ABSTFN + "1", ABSTFN)
+            self.assertEqual(realpath(ABSTFN, strict=False), ABSTFN + "2")
+            self.assertEqual(realpath(ABSTFN, strict=True), ABSTFN + "2")
+            self.assertEqual(realpath(ABSTFN, strict=True), ABSTFN + "2")
+
+            self.assertEqual(realpath(ABSTFN + "/", strict=False), ABSTFN + "2")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/.", strict=False), ABSTFN + "2")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/.",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/..", strict=False), dirname(ABSTFN))
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/..",
+                              strict=ALLOW_MISSING)
+
+            self.assertEqual(realpath(ABSTFN + "/subdir", strict=False), ABSTFN + "2/subdir")
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir", strict=True)
+            self.assertRaises(NotADirectoryError, realpath, ABSTFN + "/subdir",
+                              strict=ALLOW_MISSING)
+        finally:
+            os_helper.unlink(ABSTFN)
+            os_helper.unlink(ABSTFN + "1")
+            os_helper.unlink(ABSTFN + "2")
 
     def test_relpath(self):
         (real_getcwd, os.getcwd) = (os.getcwd, lambda: r"/home/user/bar")
         try:
             curdir = os.path.split(os.getcwd())[-1]
+            self.assertRaises(TypeError, posixpath.relpath, None)
             self.assertRaises(ValueError, posixpath.relpath, "")
             self.assertEqual(posixpath.relpath("a"), "a")
             self.assertEqual(posixpath.relpath(posixpath.abspath("a")), "a")
@@ -697,7 +1037,9 @@ def check_error(exc, paths):
             self.assertRaises(exc, posixpath.commonpath,
                               [os.fsencode(p) for p in paths])
 
+        self.assertRaises(TypeError, posixpath.commonpath, None)
         self.assertRaises(ValueError, posixpath.commonpath, [])
+        self.assertRaises(ValueError, posixpath.commonpath, iter([]))
         check_error(ValueError, ['/usr', 'usr'])
         check_error(ValueError, ['usr', '/usr'])
 
@@ -742,62 +1084,22 @@ 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
-    if os.name == "posix" and os.getenv("CI"):
-        @unittest.expectedFailure
-        def test_exists(self):
-            super().test_exists()
-
-    # TODO: RUSTPYTHON
-    import sys
-    @unittest.skipIf(sys.platform.startswith("linux") and os.getenv("CI"), "TODO: RUSTPYTHON, flaky test")
-    def test_filetime(self):
-        super().test_filetime()
-
-    # TODO: RUSTPYTHON
-    if sys.platform.startswith("linux"):
-        @unittest.expectedFailure
-        def test_nonascii_abspath(self):
-            super().test_nonascii_abspath()
-
-    # TODO: RUSTPYTHON
-    if os.name == "nt":
-        @unittest.expectedFailure
-        def test_samefile(self):
-            super().test_samefile()
-
-    # TODO: RUSTPYTHON
-    if os.name == "nt":
-        @unittest.expectedFailure
-        def test_samefile_on_link(self):
-            super().test_samefile_on_link()
-
-    # TODO: RUSTPYTHON
-    if os.name == "nt":
-        @unittest.expectedFailure
-        def test_samestat(self):
-            super().test_samestat()
-
-    # TODO: RUSTPYTHON
-    if os.name == "nt":
-        @unittest.expectedFailure
-        def test_samestat_on_link(self):
-            super().test_samestat_on_link()
-
 
+# TODO: RUSTPYTHON
 @unittest.skipIf(os.getenv("CI"), "TODO: RUSTPYTHON,  FileExistsError: (17, 'File exists (os error 17)')")
 class PathLikeTests(unittest.TestCase):
 
     path = posixpath
 
     def setUp(self):
-        self.file_name = os_helper.TESTFN
-        self.file_path = FakePath(os_helper.TESTFN)
+        self.file_name = TESTFN
+        self.file_path = FakePath(TESTFN)
         self.addCleanup(os_helper.unlink, self.file_name)
         with open(self.file_name, 'xb', 0) as file:
             file.write(b"test_posixpath.PathLikeTests")
@@ -854,9 +1156,12 @@ def test_path_normpath(self):
     def test_path_abspath(self):
         self.assertPathEqual(self.path.abspath)
 
-    def test_path_realpath(self):
+    @_parameterize({}, {'strict': True}, {'strict': ALLOW_MISSING})
+    def test_path_realpath(self, kwargs):
         self.assertPathEqual(self.path.realpath)
 
+        self.assertPathEqual(partial(self.path.realpath, **kwargs))
+
     def test_path_relpath(self):
         self.assertPathEqual(self.path.relpath)
 
diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py
index 5cea9ceb20..eeb482ec4b 100644
--- a/Lib/test/test_pow.py
+++ b/Lib/test/test_pow.py
@@ -19,12 +19,11 @@ def powtest(self, type):
                 self.assertEqual(pow(2, i), pow2)
                 if i != 30 : pow2 = pow2*2
 
-            for othertype in (int,):
-                for i in list(range(-10, 0)) + list(range(1, 10)):
-                    ii = type(i)
-                    for j in range(1, 11):
-                        jj = -othertype(j)
-                        pow(ii, jj)
+            for i in list(range(-10, 0)) + list(range(1, 10)):
+                ii = type(i)
+                inv = pow(ii, -1) # inverse of ii
+                for jj in range(-10, 0):
+                    self.assertAlmostEqual(pow(ii, jj), pow(inv, -jj))
 
         for othertype in int, float:
             for i in range(1, 100):
diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py
index 4e6fed1ab9..ace75561f2 100644
--- a/Lib/test/test_pprint.py
+++ b/Lib/test/test_pprint.py
@@ -374,7 +374,7 @@ def __new__(cls, celsius_degrees):
                 return super().__new__(Temperature, celsius_degrees)
             def __repr__(self):
                 kelvin_degrees = self + 273.15
-                return f"{kelvin_degrees}°K"
+                return f"{kelvin_degrees:.2f}°K"
         self.assertEqual(pprint.pformat(Temperature(1000)), '1273.15°K')
 
     def test_sorted_dict(self):
diff --git a/Lib/test/test_print.py b/Lib/test/test_print.py
index 8445a501cf..6107b7032f 100644
--- a/Lib/test/test_print.py
+++ b/Lib/test/test_print.py
@@ -129,14 +129,24 @@ def flush(self):
                 raise RuntimeError
         self.assertRaises(RuntimeError, print, 1, file=noflush(), flush=True)
 
+    def test_gh130163(self):
+        class X:
+            def __str__(self):
+                sys.stdout = StringIO()
+                support.gc_collect()
+                return 'foo'
+
+        with support.swap_attr(sys, 'stdout', None):
+            sys.stdout = StringIO()  # the only reference
+            print(X())  # should not crash
+
 
 class TestPy2MigrationHint(unittest.TestCase):
     """Test that correct hint is produced analogous to Python3 syntax,
     if print statement is executed as in Python 2.
     """
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_normal_string(self):
         python2_print_str = 'print "Hello World"'
         with self.assertRaises(SyntaxError) as context:
@@ -145,8 +155,7 @@ def test_normal_string(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_string_with_soft_space(self):
         python2_print_str = 'print "Hello World",'
         with self.assertRaises(SyntaxError) as context:
@@ -155,8 +164,7 @@ def test_string_with_soft_space(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_string_with_excessive_whitespace(self):
         python2_print_str = 'print  "Hello World", '
         with self.assertRaises(SyntaxError) as context:
@@ -165,8 +173,7 @@ def test_string_with_excessive_whitespace(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_string_with_leading_whitespace(self):
         python2_print_str = '''if 1:
             print "Hello World"
@@ -180,9 +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
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_string_with_semicolon(self):
         python2_print_str = 'print p;'
         with self.assertRaises(SyntaxError) as context:
@@ -191,8 +196,7 @@ def test_string_with_semicolon(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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:
@@ -201,8 +205,7 @@ def test_string_in_loop_on_same_line(self):
         self.assertIn("Missing parentheses in call to 'print'. Did you mean print(...)",
                 str(context.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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:
diff --git a/Lib/test/test_property.py b/Lib/test/test_property.py
index 8411e903b1..cea241b0f2 100644
--- a/Lib/test/test_property.py
+++ b/Lib/test/test_property.py
@@ -183,26 +183,76 @@ def test_refleaks_in___init__(self):
             fake_prop.__init__('fget', 'fset', 'fdel', 'doc')
         self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
 
-    @unittest.skipIf(sys.flags.optimize >= 2,
-                     "Docstrings are omitted with -O2 and above")
-    def test_class_property(self):
-        class A:
-            @classmethod
-            @property
-            def __doc__(cls):
-                return 'A doc for %r' % cls.__name__
-        self.assertEqual(A.__doc__, "A doc for 'A'")
+    @support.refcount_test
+    def test_gh_115618(self):
+        # Py_XDECREF() was improperly called for None argument
+        # in property methods.
+        gettotalrefcount = support.get_attribute(sys, 'gettotalrefcount')
+        prop = property()
+        refs_before = gettotalrefcount()
+        for i in range(100):
+            prop = prop.getter(None)
+        self.assertIsNone(prop.fget)
+        for i in range(100):
+            prop = prop.setter(None)
+        self.assertIsNone(prop.fset)
+        for i in range(100):
+            prop = prop.deleter(None)
+        self.assertIsNone(prop.fdel)
+        self.assertAlmostEqual(gettotalrefcount() - refs_before, 0, delta=10)
+
+    def test_property_name(self):
+        def getter(self):
+            return 42
+
+        def setter(self, value):
+            pass
 
-    @unittest.skipIf(sys.flags.optimize >= 2,
-                     "Docstrings are omitted with -O2 and above")
-    def test_class_property_override(self):
         class A:
-            """First"""
-            @classmethod
             @property
-            def __doc__(cls):
-                return 'Second'
-        self.assertEqual(A.__doc__, 'Second')
+            def foo(self):
+                return 1
+
+            @foo.setter
+            def oof(self, value):
+                pass
+
+            bar = property(getter)
+            baz = property(None, setter)
+
+        self.assertEqual(A.foo.__name__, 'foo')
+        self.assertEqual(A.oof.__name__, 'oof')
+        self.assertEqual(A.bar.__name__, 'bar')
+        self.assertEqual(A.baz.__name__, 'baz')
+
+        A.quux = property(getter)
+        self.assertEqual(A.quux.__name__, 'getter')
+        A.quux.__name__ = 'myquux'
+        self.assertEqual(A.quux.__name__, 'myquux')
+        self.assertEqual(A.bar.__name__, 'bar')  # not affected
+        A.quux.__name__ = None
+        self.assertIsNone(A.quux.__name__)
+
+        with self.assertRaisesRegex(
+            AttributeError, "'property' object has no attribute '__name__'"
+        ):
+            property(None, setter).__name__
+
+        with self.assertRaisesRegex(
+            AttributeError, "'property' object has no attribute '__name__'"
+        ):
+            property(1).__name__
+
+        class Err:
+            def __getattr__(self, attr):
+                raise RuntimeError('fail')
+
+        p = property(Err())
+        with self.assertRaisesRegex(RuntimeError, 'fail'):
+            p.__name__
+
+        p.__name__ = 'not_fail'
+        self.assertEqual(p.__name__, 'not_fail')
 
     def test_property_set_name_incorrect_args(self):
         p = property()
@@ -236,25 +286,110 @@ class A:
 class PropertySub(property):
     """This is a subclass of property"""
 
+class PropertySubWoDoc(property):
+    pass
+
 class PropertySubSlots(property):
     """This is a subclass of property that defines __slots__"""
     __slots__ = ()
 
 class PropertySubclassTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_docstrings
     def test_slots_docstring_copy_exception(self):
-        try:
+        # A special case error that we preserve despite the GH-98963 behavior
+        # that would otherwise silently ignore this error.
+        # This came from commit b18500d39d791c879e9904ebac293402b4a7cd34
+        # as part of https://bugs.python.org/issue5890 which allowed docs to
+        # be set via property subclasses in the first place.
+        with self.assertRaises(AttributeError):
             class Foo(object):
                 @PropertySubSlots
                 def spam(self):
                     """Trying to copy this docstring will raise an exception"""
                     return 1
-        except AttributeError:
+
+    def test_property_with_slots_no_docstring(self):
+        # https://github.com/python/cpython/issues/98963#issuecomment-1574413319
+        class slotted_prop(property):
+            __slots__ = ("foo",)
+
+        p = slotted_prop()  # no AttributeError
+        self.assertIsNone(getattr(p, "__doc__", None))
+
+        def undocumented_getter():
+            return 4
+
+        p = slotted_prop(undocumented_getter)  # New in 3.12: no AttributeError
+        self.assertIsNone(getattr(p, "__doc__", None))
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_property_with_slots_docstring_silently_dropped(self):
+        # https://github.com/python/cpython/issues/98963#issuecomment-1574413319
+        class slotted_prop(property):
+            __slots__ = ("foo",)
+
+        p = slotted_prop(doc="what's up")  # no AttributeError
+        self.assertIsNone(p.__doc__)
+
+        def documented_getter():
+            """getter doc."""
+            return 4
+
+        # Historical behavior: A docstring from a getter always raises.
+        # (matches test_slots_docstring_copy_exception above).
+        with self.assertRaises(AttributeError):
+            p = slotted_prop(documented_getter)
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_property_with_slots_and_doc_slot_docstring_present(self):
+        # https://github.com/python/cpython/issues/98963#issuecomment-1574413319
+        class slotted_prop(property):
+            __slots__ = ("foo", "__doc__")
+
+        p = slotted_prop(doc="what's up")
+        self.assertEqual("what's up", p.__doc__)  # new in 3.12: This gets set.
+
+        def documented_getter():
+            """what's up getter doc?"""
+            return 4
+
+        p = slotted_prop(documented_getter)
+        self.assertEqual("what's up getter doc?", p.__doc__)
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_issue41287(self):
+
+        self.assertEqual(PropertySub.__doc__, "This is a subclass of property",
+                         "Docstring of `property` subclass is ignored")
+
+        doc = PropertySub(None, None, None, "issue 41287 is fixed").__doc__
+        self.assertEqual(doc, "issue 41287 is fixed",
+                         "Subclasses of `property` ignores `doc` constructor argument")
+
+        def getter(x):
+            """Getter docstring"""
+
+        def getter_wo_doc(x):
             pass
-        else:
-            raise Exception("AttributeError not raised")
+
+        for ps in property, PropertySub, PropertySubWoDoc:
+            doc = ps(getter, None, None, "issue 41287 is fixed").__doc__
+            self.assertEqual(doc, "issue 41287 is fixed",
+                             "Getter overrides explicit property docstring (%s)" % ps.__name__)
+
+            doc = ps(getter, None, None, None).__doc__
+            self.assertEqual(doc, "Getter docstring", "Getter docstring is not picked-up (%s)" % ps.__name__)
+
+            doc = ps(getter_wo_doc, None, None, "issue 41287 is fixed").__doc__
+            self.assertEqual(doc, "issue 41287 is fixed",
+                             "Getter overrides explicit property docstring (%s)" % ps.__name__)
+
+            doc = ps(getter_wo_doc, None, None, None).__doc__
+            self.assertIsNone(doc, "Property class doc appears in instance __doc__ (%s)" % ps.__name__)
 
     @unittest.skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
@@ -268,6 +403,100 @@ def spam(self):
             Foo.spam.__doc__,
             "spam wrapped in property subclass")
 
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_docstring_copy2(self):
+        """
+        Property tries to provide the best docstring it finds for its instances.
+        If a user-provided docstring is available, it is preserved on copies.
+        If no docstring is available during property creation, the property
+        will utilize the docstring from the getter if available.
+        """
+        def getter1(self):
+            return 1
+        def getter2(self):
+            """doc 2"""
+            return 2
+        def getter3(self):
+            """doc 3"""
+            return 3
+
+        # Case-1: user-provided doc is preserved in copies
+        #         of property with undocumented getter
+        p = property(getter1, None, None, "doc-A")
+
+        p2 = p.getter(getter2)
+        self.assertEqual(p.__doc__, "doc-A")
+        self.assertEqual(p2.__doc__, "doc-A")
+
+        # Case-2: user-provided doc is preserved in copies
+        #         of property with documented getter
+        p = property(getter2, None, None, "doc-A")
+
+        p2 = p.getter(getter3)
+        self.assertEqual(p.__doc__, "doc-A")
+        self.assertEqual(p2.__doc__, "doc-A")
+
+        # Case-3: with no user-provided doc new getter doc
+        #         takes precedence
+        p = property(getter2, None, None, None)
+
+        p2 = p.getter(getter3)
+        self.assertEqual(p.__doc__, "doc 2")
+        self.assertEqual(p2.__doc__, "doc 3")
+
+        # Case-4: A user-provided doc is assigned after property construction
+        #         with documented getter. The doc IS NOT preserved.
+        #         It's an odd behaviour, but it's a strange enough
+        #         use case with no easy solution.
+        p = property(getter2, None, None, None)
+        p.__doc__ = "user"
+        p2 = p.getter(getter3)
+        self.assertEqual(p.__doc__, "user")
+        self.assertEqual(p2.__doc__, "doc 3")
+
+        # Case-5: A user-provided doc is assigned after property construction
+        #         with UNdocumented getter. The doc IS preserved.
+        p = property(getter1, None, None, None)
+        p.__doc__ = "user"
+        p2 = p.getter(getter2)
+        self.assertEqual(p.__doc__, "user")
+        self.assertEqual(p2.__doc__, "user")
+
+    @unittest.skipIf(sys.flags.optimize >= 2,
+                     "Docstrings are omitted with -O2 and above")
+    def test_prefer_explicit_doc(self):
+        # Issue 25757: subclasses of property lose docstring
+        self.assertEqual(property(doc="explicit doc").__doc__, "explicit doc")
+        self.assertEqual(PropertySub(doc="explicit doc").__doc__, "explicit doc")
+
+        class Foo:
+            spam = PropertySub(doc="spam explicit doc")
+
+            @spam.getter
+            def spam(self):
+                """ignored as doc already set"""
+                return 1
+
+            def _stuff_getter(self):
+                """ignored as doc set directly"""
+            stuff = PropertySub(doc="stuff doc argument", fget=_stuff_getter)
+
+        #self.assertEqual(Foo.spam.__doc__, "spam explicit doc")
+        self.assertEqual(Foo.stuff.__doc__, "stuff doc argument")
+
+    def test_property_no_doc_on_getter(self):
+        # If a property's getter has no __doc__ then the property's doc should
+        # be None; test that this is consistent with subclasses as well; see
+        # GH-2487
+        class NoDoc:
+            @property
+            def __doc__(self):
+                raise AttributeError
+
+        self.assertEqual(property(NoDoc()).__doc__, None)
+        self.assertEqual(PropertySub(NoDoc()).__doc__, None)
+
     @unittest.skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
     def test_property_setter_copies_getter_docstring(self):
@@ -360,7 +589,6 @@ class cls:
         foo = property()
 
 
-
 class PropertyUnreachableAttributeNoName(_PropertyUnreachableAttribute, unittest.TestCase):
     msg_format = r"^property of 'PropertyUnreachableAttributeNoName\.cls' object {}$"
 
diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py
index b1c1f6abff..6d3c47195c 100644
--- a/Lib/test/test_pty.py
+++ b/Lib/test/test_pty.py
@@ -1,10 +1,16 @@
-from test import support
-from test.support import verbose, reap_children
+import unittest
+from test.support import (
+    is_android, is_apple_mobile, is_emscripten, is_wasi, reap_children, verbose
+)
 from test.support.import_helper import import_module
+from test.support.os_helper import TESTFN, unlink
 
 # Skip these tests if termios is not available
 import_module('termios')
 
+if is_android or is_apple_mobile or is_emscripten or is_wasi:
+    raise unittest.SkipTest("pty is not available on this platform")
+
 import errno
 import os
 import pty
@@ -14,21 +20,12 @@
 import signal
 import socket
 import io # readline
-import unittest
-
-import struct
-import fcntl
 import warnings
 
 TEST_STRING_1 = b"I wish to buy a fish license.\n"
 TEST_STRING_2 = b"For my pet fish, Eric.\n"
 
-try:
-    _TIOCGWINSZ = tty.TIOCGWINSZ
-    _TIOCSWINSZ = tty.TIOCSWINSZ
-    _HAVE_WINSZ = True
-except AttributeError:
-    _HAVE_WINSZ = False
+_HAVE_WINSZ = hasattr(tty, "TIOCGWINSZ") and hasattr(tty, "TIOCSWINSZ")
 
 if verbose:
     def debug(msg):
@@ -82,90 +79,78 @@ def expectedFailureIfStdinIsTTY(fun):
         pass
     return fun
 
-def _get_term_winsz(fd):
-    s = struct.pack("HHHH", 0, 0, 0, 0)
-    return fcntl.ioctl(fd, _TIOCGWINSZ, s)
 
-def _set_term_winsz(fd, winsz):
-    fcntl.ioctl(fd, _TIOCSWINSZ, winsz)
+def write_all(fd, data):
+    written = os.write(fd, data)
+    if written != len(data):
+        # gh-73256, gh-110673: It should never happen, but check just in case
+        raise Exception(f"short write: os.write({fd}, {len(data)} bytes) "
+                        f"wrote {written} bytes")
 
 
 # Marginal testing of pty suite. Cannot do extensive 'do or fail' testing
 # because pty code is not too portable.
 class PtyTest(unittest.TestCase):
     def setUp(self):
-        old_alarm = signal.signal(signal.SIGALRM, self.handle_sig)
-        self.addCleanup(signal.signal, signal.SIGALRM, old_alarm)
-
         old_sighup = signal.signal(signal.SIGHUP, self.handle_sighup)
         self.addCleanup(signal.signal, signal.SIGHUP, old_sighup)
 
-        # isatty() and close() can hang on some platforms. Set an alarm
-        # before running the test to make sure we don't hang forever.
-        self.addCleanup(signal.alarm, 0)
-        signal.alarm(10)
-
-        # Save original stdin window size
-        self.stdin_rows = None
-        self.stdin_cols = None
+        # Save original stdin window size.
+        self.stdin_dim = None
         if _HAVE_WINSZ:
             try:
-                stdin_dim = os.get_terminal_size(pty.STDIN_FILENO)
-                self.stdin_rows = stdin_dim.lines
-                self.stdin_cols = stdin_dim.columns
-                old_stdin_winsz = struct.pack("HHHH", self.stdin_rows,
-                                              self.stdin_cols, 0, 0)
-                self.addCleanup(_set_term_winsz, pty.STDIN_FILENO, old_stdin_winsz)
-            except OSError:
+                self.stdin_dim = tty.tcgetwinsize(pty.STDIN_FILENO)
+                self.addCleanup(tty.tcsetwinsize, pty.STDIN_FILENO,
+                                self.stdin_dim)
+            except tty.error:
                 pass
 
-    def handle_sig(self, sig, frame):
-        self.fail("isatty hung")
-
     @staticmethod
     def handle_sighup(signum, frame):
         pass
 
     @expectedFailureIfStdinIsTTY
+    @unittest.skip('TODO: RUSTPYTHON; "Not runnable. tty.tcgetwinsize" is required to setUp')
     def test_openpty(self):
         try:
             mode = tty.tcgetattr(pty.STDIN_FILENO)
         except tty.error:
-            # not a tty or bad/closed fd
+            # Not a tty or bad/closed fd.
             debug("tty.tcgetattr(pty.STDIN_FILENO) failed")
             mode = None
 
-        new_stdin_winsz = None
-        if self.stdin_rows is not None and self.stdin_cols is not None:
+        new_dim = None
+        if self.stdin_dim:
             try:
                 # Modify pty.STDIN_FILENO window size; we need to
                 # check if pty.openpty() is able to set pty slave
                 # window size accordingly.
-                debug("Setting pty.STDIN_FILENO window size")
-                debug(f"original size: (rows={self.stdin_rows}, cols={self.stdin_cols})")
-                target_stdin_rows = self.stdin_rows + 1
-                target_stdin_cols = self.stdin_cols + 1
-                debug(f"target size: (rows={target_stdin_rows}, cols={target_stdin_cols})")
-                target_stdin_winsz = struct.pack("HHHH", target_stdin_rows,
-                                                 target_stdin_cols, 0, 0)
-                _set_term_winsz(pty.STDIN_FILENO, target_stdin_winsz)
+                debug("Setting pty.STDIN_FILENO window size.")
+                debug(f"original size: (row, col) = {self.stdin_dim}")
+                target_dim = (self.stdin_dim[0] + 1, self.stdin_dim[1] + 1)
+                debug(f"target size: (row, col) = {target_dim}")
+                tty.tcsetwinsize(pty.STDIN_FILENO, target_dim)
 
                 # Were we able to set the window size
                 # of pty.STDIN_FILENO successfully?
-                new_stdin_winsz = _get_term_winsz(pty.STDIN_FILENO)
-                self.assertEqual(new_stdin_winsz, target_stdin_winsz,
+                new_dim = tty.tcgetwinsize(pty.STDIN_FILENO)
+                self.assertEqual(new_dim, target_dim,
                                  "pty.STDIN_FILENO window size unchanged")
-            except OSError:
-                warnings.warn("Failed to set pty.STDIN_FILENO window size")
+            except OSError as e:
+                logging.getLogger(__name__).warning(
+                    "Failed to set pty.STDIN_FILENO window size.", exc_info=e,
+                )
                 pass
 
         try:
             debug("Calling pty.openpty()")
             try:
-                master_fd, slave_fd = pty.openpty(mode, new_stdin_winsz)
+                master_fd, slave_fd, slave_name = pty.openpty(mode, new_dim,
+                                                              True)
             except TypeError:
                 master_fd, slave_fd = pty.openpty()
-            debug(f"Got master_fd '{master_fd}', slave_fd '{slave_fd}'")
+                slave_name = None
+            debug(f"Got {master_fd=}, {slave_fd=}, {slave_name=}")
         except OSError:
             # " An optional feature could not be imported " ... ?
             raise unittest.SkipTest("Pseudo-terminals (seemingly) not functional.")
@@ -181,8 +166,8 @@ def test_openpty(self):
         if mode:
             self.assertEqual(tty.tcgetattr(slave_fd), mode,
                              "openpty() failed to set slave termios")
-        if new_stdin_winsz:
-            self.assertEqual(_get_term_winsz(slave_fd), new_stdin_winsz,
+        if new_dim:
+            self.assertEqual(tty.tcgetwinsize(slave_fd), new_dim,
                              "openpty() failed to set slave window size")
 
         # Ensure the fd is non-blocking in case there's nothing to read.
@@ -200,18 +185,18 @@ def test_openpty(self):
             os.set_blocking(master_fd, blocking)
 
         debug("Writing to slave_fd")
-        os.write(slave_fd, TEST_STRING_1)
+        write_all(slave_fd, TEST_STRING_1)
         s1 = _readline(master_fd)
         self.assertEqual(b'I wish to buy a fish license.\n',
                          normalize_output(s1))
 
         debug("Writing chunked output")
-        os.write(slave_fd, TEST_STRING_2[:5])
-        os.write(slave_fd, TEST_STRING_2[5:])
+        write_all(slave_fd, TEST_STRING_2[:5])
+        write_all(slave_fd, TEST_STRING_2[5:])
         s2 = _readline(master_fd)
         self.assertEqual(b'For my pet fish, Eric.\n', normalize_output(s2))
 
-    @support.requires_fork()
+    @unittest.skip('TODO: RUSTPYTHON; "Not runnable. tty.tcgetwinsize" is required to setUp')
     def test_fork(self):
         debug("calling pty.fork()")
         pid, master_fd = pty.fork()
@@ -294,6 +279,7 @@ def test_fork(self):
             ##else:
             ##    raise TestFailed("Read from master_fd did not raise exception")
 
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "tty" has no attribute "tcgetwinsize"')
     def test_master_read(self):
         # XXX(nnorwitz):  this test leaks fds when there is an error.
         debug("Calling pty.openpty()")
@@ -313,8 +299,28 @@ def test_master_read(self):
 
         self.assertEqual(data, b"")
 
+    @unittest.skip('TODO: RUSTPYTHON; AttributeError: module "tty" has no attribute "tcgetwinsize"')
     def test_spawn_doesnt_hang(self):
-        pty.spawn([sys.executable, '-c', 'print("hi there")'])
+        self.addCleanup(unlink, TESTFN)
+        with open(TESTFN, 'wb') as f:
+            STDOUT_FILENO = 1
+            dup_stdout = os.dup(STDOUT_FILENO)
+            os.dup2(f.fileno(), STDOUT_FILENO)
+            buf = b''
+            def master_read(fd):
+                nonlocal buf
+                data = os.read(fd, 1024)
+                buf += data
+                return data
+            try:
+                pty.spawn([sys.executable, '-c', 'print("hi there")'],
+                          master_read)
+            finally:
+                os.dup2(dup_stdout, STDOUT_FILENO)
+                os.close(dup_stdout)
+        self.assertEqual(buf, b'hi there\r\n')
+        with open(TESTFN, 'rb') as f:
+            self.assertEqual(f.read(), b'hi there\r\n')
 
 class SmallPtyTests(unittest.TestCase):
     """These tests don't spawn children or hang."""
@@ -332,8 +338,8 @@ def setUp(self):
         self.orig_pty_waitpid = pty.waitpid
         self.fds = []  # A list of file descriptors to close.
         self.files = []
-        self.select_rfds_lengths = []
-        self.select_rfds_results = []
+        self.select_input = []
+        self.select_output = []
         self.tcsetattr_mode_setting = None
 
     def tearDown(self):
@@ -368,11 +374,10 @@ def _socketpair(self):
         self.files.extend(socketpair)
         return socketpair
 
-    def _mock_select(self, rfds, wfds, xfds, timeout=0):
+    def _mock_select(self, rfds, wfds, xfds):
         # This will raise IndexError when no more expected calls exist.
-        # This ignores the timeout
-        self.assertEqual(self.select_rfds_lengths.pop(0), len(rfds))
-        return self.select_rfds_results.pop(0), [], []
+        self.assertEqual((rfds, wfds, xfds), self.select_input.pop(0))
+        return self.select_output.pop(0)
 
     def _make_mock_fork(self, pid):
         def mock_fork():
@@ -392,14 +397,16 @@ def test__copy_to_each(self):
         masters = [s.fileno() for s in socketpair]
 
         # Feed data.  Smaller than PIPEBUF.  These writes will not block.
-        os.write(masters[1], b'from master')
-        os.write(write_to_stdin_fd, b'from stdin')
+        write_all(masters[1], b'from master')
+        write_all(write_to_stdin_fd, b'from stdin')
 
-        # Expect two select calls, the last one will cause IndexError
+        # Expect three select calls, the last one will cause IndexError
         pty.select = self._mock_select
-        self.select_rfds_lengths.append(2)
-        self.select_rfds_results.append([mock_stdin_fd, masters[0]])
-        self.select_rfds_lengths.append(2)
+        self.select_input.append(([mock_stdin_fd, masters[0]], [], []))
+        self.select_output.append(([mock_stdin_fd, masters[0]], [], []))
+        self.select_input.append(([mock_stdin_fd, masters[0]], [mock_stdout_fd, masters[0]], []))
+        self.select_output.append(([], [mock_stdout_fd, masters[0]], []))
+        self.select_input.append(([mock_stdin_fd, masters[0]], [], []))
 
         with self.assertRaises(IndexError):
             pty._copy(masters[0])
@@ -410,28 +417,6 @@ def test__copy_to_each(self):
         self.assertEqual(os.read(read_from_stdout_fd, 20), b'from master')
         self.assertEqual(os.read(masters[1], 20), b'from stdin')
 
-    def test__copy_eof_on_all(self):
-        """Test the empty read EOF case on both master_fd and stdin."""
-        read_from_stdout_fd, mock_stdout_fd = self._pipe()
-        pty.STDOUT_FILENO = mock_stdout_fd
-        mock_stdin_fd, write_to_stdin_fd = self._pipe()
-        pty.STDIN_FILENO = mock_stdin_fd
-        socketpair = self._socketpair()
-        masters = [s.fileno() for s in socketpair]
-
-        socketpair[1].close()
-        os.close(write_to_stdin_fd)
-
-        pty.select = self._mock_select
-        self.select_rfds_lengths.append(2)
-        self.select_rfds_results.append([mock_stdin_fd, masters[0]])
-        # We expect that both fds were removed from the fds list as they
-        # both encountered an EOF before the second select call.
-        self.select_rfds_lengths.append(0)
-
-        # We expect the function to return without error.
-        self.assertEqual(pty._copy(masters[0]), None)
-
     def test__restore_tty_mode_normal_return(self):
         """Test that spawn resets the tty mode no when _copy returns normally."""
 
diff --git a/Lib/test/test_py_compile.py b/Lib/test/test_py_compile.py
index 750afc1de7..54302eba4d 100644
--- a/Lib/test/test_py_compile.py
+++ b/Lib/test/test_py_compile.py
@@ -78,7 +78,6 @@ def test_absolute_path(self):
         self.assertTrue(os.path.exists(self.pyc_path))
         self.assertFalse(os.path.exists(self.cache_path))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_do_not_overwrite_symlinks(self):
         # In the face of a cfile argument being a symlink, bail out.
         # Issue #17222
@@ -267,7 +266,6 @@ def test_bad_syntax_with_quiet(self):
         self.assertEqual(stdout, b'')
         self.assertEqual(stderr, b'')
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_file_not_exists(self):
         should_not_exists = os.path.join(os.path.dirname(__file__), 'should_not_exists.py')
         rc, stdout, stderr = self.pycompilecmd_failure(self.source_path, should_not_exists)
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
new file mode 100644
index 0000000000..ad26fe1dba
--- /dev/null
+++ b/Lib/test/test_pyclbr.py
@@ -0,0 +1,272 @@
+'''
+   Test cases for pyclbr.py
+   Nick Mathewson
+'''
+
+import sys
+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
+
+
+StaticMethodType = type(staticmethod(lambda: None))
+ClassMethodType = type(classmethod(lambda c: None))
+
+# Here we test the python class browser code.
+#
+# The main function in this suite, 'testModule', compares the output
+# of pyclbr with the introspected members of a module.  Because pyclbr
+# is imperfect (as designed), testModule is called with a set of
+# members to ignore.
+
+class PyclbrTest(TestCase, ExtraAssertions):
+
+    def assertListEq(self, l1, l2, ignore):
+        ''' succeed iff {l1} - {ignore} == {l2} - {ignore} '''
+        missing = (set(l1) ^ set(l2)) - set(ignore)
+        if missing:
+            print("l1=%r\nl2=%r\nignore=%r" % (l1, l2, ignore), file=sys.stderr)
+            self.fail("%r missing" % missing.pop())
+
+    def assertHaskey(self, obj, key, ignore):
+        ''' succeed iff key in obj or key in ignore. '''
+        if key in ignore: return
+        if key not in obj:
+            print("***",key, file=sys.stderr)
+        self.assertIn(key, obj)
+
+    def assertEqualsOrIgnored(self, a, b, ignore):
+        ''' succeed iff a == b or a in ignore or b in ignore '''
+        if a not in ignore and b not in ignore:
+            self.assertEqual(a, b)
+
+    def checkModule(self, moduleName, module=None, ignore=()):
+        ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds
+            to the actual module object, module.  Any identifiers in
+            ignore are ignored.   If no module is provided, the appropriate
+            module is loaded with __import__.'''
+
+        ignore = set(ignore) | set(['object'])
+
+        if module is None:
+            # Import it.
+            # ('<silly>' is to work around an API silliness in __import__)
+            module = __import__(moduleName, globals(), {}, ['<silly>'])
+
+        dict = pyclbr.readmodule_ex(moduleName)
+
+        def ismethod(oclass, obj, name):
+            classdict = oclass.__dict__
+            if isinstance(obj, MethodType):
+                # could be a classmethod
+                if (not isinstance(classdict[name], ClassMethodType) or
+                    obj.__self__ is not oclass):
+                    return False
+            elif not isinstance(obj, FunctionType):
+                return False
+
+            objname = obj.__name__
+            if objname.startswith("__") and not objname.endswith("__"):
+                if stripped_typename := oclass.__name__.lstrip('_'):
+                    objname = f"_{stripped_typename}{objname}"
+            return objname == name
+
+        # Make sure the toplevel functions and classes are the same.
+        for name, value in dict.items():
+            if name in ignore:
+                continue
+            self.assertHasAttr(module, name, ignore)
+            py_item = getattr(module, name)
+            if isinstance(value, pyclbr.Function):
+                self.assertIsInstance(py_item, (FunctionType, BuiltinFunctionType))
+                if py_item.__module__ != moduleName:
+                    continue   # skip functions that came from somewhere else
+                self.assertEqual(py_item.__module__, value.module)
+            else:
+                self.assertIsInstance(py_item, type)
+                if py_item.__module__ != moduleName:
+                    continue   # skip classes that came from somewhere else
+
+                real_bases = [base.__name__ for base in py_item.__bases__]
+                pyclbr_bases = [ getattr(base, 'name', base)
+                                 for base in value.super ]
+
+                try:
+                    self.assertListEq(real_bases, pyclbr_bases, ignore)
+                except:
+                    print("class=%s" % py_item, file=sys.stderr)
+                    raise
+
+                actualMethods = []
+                for m in py_item.__dict__.keys():
+                    if ismethod(py_item, getattr(py_item, m), m):
+                        actualMethods.append(m)
+
+                if stripped_typename := name.lstrip('_'):
+                    foundMethods = []
+                    for m in value.methods.keys():
+                        if m.startswith('__') and not m.endswith('__'):
+                            foundMethods.append(f"_{stripped_typename}{m}")
+                        else:
+                            foundMethods.append(m)
+                else:
+                    foundMethods = list(value.methods.keys())
+
+                try:
+                    self.assertListEq(foundMethods, actualMethods, ignore)
+                    self.assertEqual(py_item.__module__, value.module)
+
+                    self.assertEqualsOrIgnored(py_item.__name__, value.name,
+                                               ignore)
+                    # can't check file or lineno
+                except:
+                    print("class=%s" % py_item, file=sys.stderr)
+                    raise
+
+        # Now check for missing stuff.
+        def defined_in(item, module):
+            if isinstance(item, type):
+                return item.__module__ == module.__name__
+            if isinstance(item, FunctionType):
+                return item.__globals__ is module.__dict__
+            return False
+        for name in dir(module):
+            item = getattr(module, name)
+            if isinstance(item,  (type, FunctionType)):
+                if defined_in(item, module):
+                    self.assertHaskey(dict, name, ignore)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_easy(self):
+        self.checkModule('pyclbr')
+        # XXX: Metaclasses are not supported
+        # self.checkModule('ast')
+        self.checkModule('doctest', ignore=("TestResults", "_SpoofOut",
+                                            "DocTestCase", '_DocTestSuite'))
+        self.checkModule('difflib', ignore=("Match",))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_cases(self):
+        # see test.pyclbr_input for the rationale behind the ignored symbols
+        self.checkModule('test.pyclbr_input', ignore=['om', 'f'])
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_nested(self):
+        mb = pyclbr
+        # Set arguments for descriptor creation and _creat_tree call.
+        m, p, f, t, i = 'test', '', 'test.py', {}, None
+        source = dedent("""\
+        def f0():
+            def f1(a,b,c):
+                def f2(a=1, b=2, c=3): pass
+                return f1(a,b,d)
+            class c1: pass
+        class C0:
+            "Test class."
+            def F1():
+                "Method."
+                return 'return'
+            class C1():
+                class C2:
+                    "Class nested within nested class."
+                    def F3(): return 1+1
+
+        """)
+        actual = mb._create_tree(m, p, f, source, t, i)
+
+        # Create descriptors, linked together, and expected dict.
+        f0 = mb.Function(m, 'f0', f, 1, end_lineno=5)
+        f1 = mb._nest_function(f0, 'f1', 2, 4)
+        f2 = mb._nest_function(f1, 'f2', 3, 3)
+        c1 = mb._nest_class(f0, 'c1', 5, 5)
+        C0 = mb.Class(m, 'C0', None, f, 6, end_lineno=14)
+        F1 = mb._nest_function(C0, 'F1', 8, 10)
+        C1 = mb._nest_class(C0, 'C1', 11, 14)
+        C2 = mb._nest_class(C1, 'C2', 12, 14)
+        F3 = mb._nest_function(C2, 'F3', 14, 14)
+        expected = {'f0':f0, 'C0':C0}
+
+        def compare(parent1, children1, parent2, children2):
+            """Return equality of tree pairs.
+
+            Each parent,children pair define a tree.  The parents are
+            assumed equal.  Comparing the children dictionaries as such
+            does not work due to comparison by identity and double
+            linkage.  We separate comparing string and number attributes
+            from comparing the children of input children.
+            """
+            self.assertEqual(children1.keys(), children2.keys())
+            for ob in children1.values():
+                self.assertIs(ob.parent, parent1)
+            for ob in children2.values():
+                self.assertIs(ob.parent, parent2)
+            for key in children1.keys():
+                o1, o2 = children1[key], children2[key]
+                t1 = type(o1), o1.name, o1.file, o1.module, o1.lineno, o1.end_lineno
+                t2 = type(o2), o2.name, o2.file, o2.module, o2.lineno, o2.end_lineno
+                self.assertEqual(t1, t2)
+                if type(o1) is mb.Class:
+                    self.assertEqual(o1.methods, o2.methods)
+                # Skip superclasses for now as not part of example
+                compare(o1, o1.children, o2, o2.children)
+
+        compare(None, actual, None, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_others(self):
+        cm = self.checkModule
+
+        # These were once some of the longest modules.
+        cm('random', ignore=('Random',))  # from _random import Random as CoreGenerator
+        cm('pickle', ignore=('partial', 'PickleBuffer'))
+        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
+
+        # Tests for modules inside packages
+        cm('email.parser')
+        cm('test.test_pyclbr')
+
+
+class ReadmoduleTests(TestCase):
+
+    def setUp(self):
+        self._modules = pyclbr._modules.copy()
+
+    def tearDown(self):
+        pyclbr._modules = self._modules
+
+
+    def test_dotted_name_not_a_package(self):
+        # test ImportError is raised when the first part of a dotted name is
+        # not a package.
+        #
+        # Issue #14798.
+        self.assertRaises(ImportError, pyclbr.readmodule_ex, 'asyncio.foo')
+
+    def test_module_has_no_spec(self):
+        module_name = "doesnotexist"
+        assert module_name not in pyclbr._modules
+        with test_importlib_util.uncache(module_name):
+            with self.assertRaises(ModuleNotFoundError):
+                pyclbr.readmodule_ex(module_name)
+
+
+if __name__ == "__main__":
+    unittest_main()
diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index 33e1ffb836..d360e8cd65 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -1,13 +1,14 @@
 # XXX TypeErrors on calling handlers, or on bad return values from a
 # handler, are obscure and unhelpful.
 
-from io import BytesIO
 import os
-import platform
 import sys
 import sysconfig
 import unittest
 import traceback
+from io import BytesIO
+from test import support
+from test.support import os_helper
 
 from xml.parsers import expat
 from xml.parsers.expat import errors
@@ -19,32 +20,24 @@ class SetAttributeTest(unittest.TestCase):
     def setUp(self):
         self.parser = expat.ParserCreate(namespace_separator='!')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_buffer_text(self):
         self.assertIs(self.parser.buffer_text, False)
         for x in 0, 1, 2, 0:
             self.parser.buffer_text = x
             self.assertIs(self.parser.buffer_text, bool(x))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_namespace_prefixes(self):
         self.assertIs(self.parser.namespace_prefixes, False)
         for x in 0, 1, 2, 0:
             self.parser.namespace_prefixes = x
             self.assertIs(self.parser.namespace_prefixes, bool(x))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ordered_attributes(self):
         self.assertIs(self.parser.ordered_attributes, False)
         for x in 0, 1, 2, 0:
             self.parser.ordered_attributes = x
             self.assertIs(self.parser.ordered_attributes, bool(x))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_specified_attributes(self):
         self.assertIs(self.parser.specified_attributes, False)
         for x in 0, 1, 2, 0:
@@ -234,8 +227,6 @@ def _verify_parse_output(self, operations):
         for operation, expected_operation in zip(operations, expected_operations):
             self.assertEqual(operation, expected_operation)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parse_bytes(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -248,8 +239,6 @@ def test_parse_bytes(self):
         # Issue #6697.
         self.assertRaises(AttributeError, getattr, parser, '\uD800')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parse_str(self):
         out = self.Outputter()
         parser = expat.ParserCreate(namespace_separator='!')
@@ -260,8 +249,6 @@ def test_parse_str(self):
         operations = out.out
         self._verify_parse_output(operations)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parse_file(self):
         # Try parsing a file
         out = self.Outputter()
@@ -274,8 +261,7 @@ def test_parse_file(self):
         operations = out.out
         self._verify_parse_output(operations)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse_again(self):
         parser = expat.ParserCreate()
         file = BytesIO(data)
@@ -289,8 +275,6 @@ def test_parse_again(self):
                           expat.errors.XML_ERROR_FINISHED)
 
 class NamespaceSeparatorTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_legal(self):
         # Tests that make sure we get errors when the namespace_separator value
         # is illegal, and that we don't for good values:
@@ -298,15 +282,12 @@ def test_legal(self):
         expat.ParserCreate(namespace_separator=None)
         expat.ParserCreate(namespace_separator=' ')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_illegal(self):
-        try:
+        with self.assertRaisesRegex(TypeError,
+                r"ParserCreate\(\) argument (2|'namespace_separator') "
+                r"must be str or None, not int"):
             expat.ParserCreate(namespace_separator=42)
-            self.fail()
-        except TypeError as e:
-            self.assertEqual(str(e),
-                "ParserCreate() argument 'namespace_separator' must be str or None, not int")
 
         try:
             expat.ParserCreate(namespace_separator='too long')
@@ -328,9 +309,7 @@ def test_zero_length(self):
 
 
 class InterningTest(unittest.TestCase):
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test(self):
         # Test the interning machinery.
         p = expat.ParserCreate()
@@ -346,8 +325,7 @@ def collector(name, *args):
             # L should have the same string repeated over and over.
             self.assertTrue(tag is entry)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue9402(self):
         # create an ExternalEntityParserCreate with buffer text
         class ExternalOutputter:
@@ -405,8 +383,7 @@ def test_default_to_disabled(self):
         parser = expat.ParserCreate()
         self.assertFalse(parser.buffer_text)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_buffering_enabled(self):
         # Make sure buffering is turned on
         self.assertTrue(self.parser.buffer_text)
@@ -414,8 +391,7 @@ def test_buffering_enabled(self):
         self.assertEqual(self.stuff, ['123'],
                          "buffered text not properly collapsed")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -425,23 +401,18 @@ def test1(self):
                          ["<a>", "1", "<b>", "2", "\n", "3", "<c>", "4\n5"],
                          "buffering control not reacting as expected")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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"],
                          "buffered text not properly collapsed")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test3(self):
         self.setHandlers(["StartElementHandler"])
         self.parser.Parse(b"<a>1<b/>2<c/>3</a>", True)
         self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"],
                          "buffered text not properly split")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test4(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.CharacterDataHandler = None
@@ -449,16 +420,12 @@ def test4(self):
         self.assertEqual(self.stuff,
                          ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test5(self):
         self.setHandlers(["StartElementHandler", "EndElementHandler"])
         self.parser.Parse(b"<a>1<b></b>2<c/>3</a>", True)
         self.assertEqual(self.stuff,
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test6(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -467,8 +434,7 @@ def test6(self):
             ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"],
             "buffered text not properly split")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test7(self):
         self.setHandlers(["CommentHandler", "EndElementHandler",
                     "StartElementHandler"])
@@ -482,35 +448,59 @@ def test7(self):
 # Test handling of exception from callback:
 class HandlerExceptionTest(unittest.TestCase):
     def StartElementHandler(self, name, attrs):
-        raise RuntimeError(name)
+        raise RuntimeError(f'StartElementHandler: <{name}>')
 
     def check_traceback_entry(self, entry, filename, funcname):
-        self.assertEqual(os.path.basename(entry[0]), filename)
-        self.assertEqual(entry[2], funcname)
+        self.assertEqual(os.path.basename(entry.filename), filename)
+        self.assertEqual(entry.name, funcname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.cpython_only
     def test_exception(self):
+        # gh-66652: test _PyTraceback_Add() used by pyexpat.c to inject frames
+
+        # Change the current directory to the Python source code directory
+        # if it is available.
+        src_dir = sysconfig.get_config_var('abs_builddir')
+        if src_dir:
+            have_source = os.path.isdir(src_dir)
+        else:
+            have_source = False
+        if have_source:
+            with os_helper.change_cwd(src_dir):
+                self._test_exception(have_source)
+        else:
+            self._test_exception(have_source)
+
+    def _test_exception(self, have_source):
+        # Use path relative to the current directory which should be the Python
+        # source code directory (if it is available).
+        PYEXPAT_C = os.path.join('Modules', 'pyexpat.c')
+
         parser = expat.ParserCreate()
         parser.StartElementHandler = self.StartElementHandler
         try:
             parser.Parse(b"<a><b><c/></b></a>", True)
-            self.fail()
-        except RuntimeError as e:
-            self.assertEqual(e.args[0], 'a',
-                             "Expected RuntimeError for element 'a', but" + \
-                             " found %r" % e.args[0])
-            # Check that the traceback contains the relevant line in pyexpat.c
-            entries = traceback.extract_tb(e.__traceback__)
-            self.assertEqual(len(entries), 3)
-            self.check_traceback_entry(entries[0],
-                                       "test_pyexpat.py", "test_exception")
-            self.check_traceback_entry(entries[1],
-                                       "pyexpat.c", "StartElement")
-            self.check_traceback_entry(entries[2],
-                                       "test_pyexpat.py", "StartElementHandler")
-            if sysconfig.is_python_build() and not (sys.platform == 'win32' and platform.machine() == 'ARM'):
-                self.assertIn('call_with_frame("StartElement"', entries[1][3])
+
+            self.fail("the parser did not raise RuntimeError")
+        except RuntimeError as exc:
+            self.assertEqual(exc.args[0], 'StartElementHandler: <a>', exc)
+            entries = traceback.extract_tb(exc.__traceback__)
+
+        self.assertEqual(len(entries), 3, entries)
+        self.check_traceback_entry(entries[0],
+                                   "test_pyexpat.py", "_test_exception")
+        self.check_traceback_entry(entries[1],
+                                   os.path.basename(PYEXPAT_C),
+                                   "StartElement")
+        self.check_traceback_entry(entries[2],
+                                   "test_pyexpat.py", "StartElementHandler")
+
+        # Check that the traceback contains the relevant line in
+        # Modules/pyexpat.c. Skip the test if Modules/pyexpat.c is not
+        # available.
+        if have_source and os.path.exists(PYEXPAT_C):
+            self.assertIn('call_with_frame("StartElement"',
+                          entries[1].line)
 
 
 # Test Current* members:
@@ -533,8 +523,6 @@ def check_pos(self, event):
                 'Expected position %s, got position %s' %(pos, expected))
         self.upto += 1
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test(self):
         self.parser = expat.ParserCreate()
         self.parser.StartElementHandler = self.StartElementHandler
@@ -548,9 +536,9 @@ def test(self):
 
 
 class sf1296433Test(unittest.TestCase):
-
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: Expected type 'str' but 'bytes' found.
     def test_parse_only_xml_data(self):
-        # http://python.org/sf/1296433
+        # https://bugs.python.org/issue1296433
         #
         xml = "<?xml version='1.0' encoding='iso8859'?><s>%s</s>" % ('a' * 1025)
         # this one doesn't crash
@@ -565,25 +553,22 @@ def handler(text):
         parser = expat.ParserCreate()
         parser.CharacterDataHandler = handler
 
-        self.assertRaises(Exception, parser.Parse, xml.encode('iso8859'))
+        self.assertRaises(SpecificException, parser.Parse, xml.encode('iso8859'))
 
 class ChardataBufferTest(unittest.TestCase):
     """
     test setting of chardata buffer size
     """
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_1025_bytes(self):
         self.assertEqual(self.small_buffer_test(1025), 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_1000_bytes(self):
         self.assertEqual(self.small_buffer_test(1000), 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_wrong_size(self):
         parser = expat.ParserCreate()
         parser.buffer_text = 1
@@ -596,8 +581,7 @@ def test_wrong_size(self):
         with self.assertRaises(TypeError):
             parser.buffer_size = 512.0
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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>'
@@ -620,8 +604,8 @@ def test_unchanged_size(self):
         parser.Parse(xml2)
         self.assertEqual(self.n, 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+
+    @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
@@ -666,8 +650,7 @@ def small_buffer_test(self, buffer_len):
         parser.Parse(xml)
         return self.n
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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>'
@@ -684,8 +667,7 @@ def test_change_size_1(self):
         parser.Parse(xml2, True)
         self.assertEqual(self.n, 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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>'
@@ -703,9 +685,7 @@ def test_change_size_2(self):
         self.assertEqual(self.n, 4)
 
 class MalformedInputTest(unittest.TestCase):
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test1(self):
         xml = b"\0\r\n"
         parser = expat.ParserCreate()
@@ -715,8 +695,7 @@ def test1(self):
         except expat.ExpatError as e:
             self.assertEqual(str(e), 'unclosed token: line 2, column 0')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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"
@@ -726,16 +705,13 @@ def test2(self):
             parser.Parse(xml, True)
 
 class ErrorMessageTest(unittest.TestCase):
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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]])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expaterror(self):
         xml = b'<'
         parser = expat.ParserCreate()
@@ -751,9 +727,7 @@ class ForeignDTDTests(unittest.TestCase):
     """
     Tests for the UseForeignDTD method of expat parser objects.
     """
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document without an external
@@ -782,8 +756,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)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ignore_use_foreign_dtd(self):
         """
         If UseForeignDTD is passed True and a document with an external
@@ -804,5 +777,101 @@ def resolve_entity(context, base, system_id, public_id):
         self.assertEqual(handler_call_args, [("bar", "baz")])
 
 
+class ParentParserLifetimeTest(unittest.TestCase):
+    """
+    Subparsers make use of their parent XML_Parser inside of Expat.
+    As a result, parent parsers need to outlive subparsers.
+
+    See https://github.com/python/cpython/issues/139400.
+    """
+
+    @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)
+
+        # Now try to cause garbage collection of the parent parser
+        # while it's still being referenced by a related subparser.
+        del parser
+
+    @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)
+        subparser_two = parser.ExternalEntityParserCreate(None)
+
+        # Now try to cause garbage collection of the parent parser
+        # while it's still being referenced by a related subparser.
+        del parser
+
+    @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)
+        subsubparser = subparser.ExternalEntityParserCreate(None)
+
+        # Now try to cause garbage collection of the parent parsers
+        # while they are still being referenced by a related subparser.
+        del parser
+        del subparser
+
+
+class ReparseDeferralTest(unittest.TestCase):
+    @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))
+
+        self.assertIs(parser.GetReparseDeferralEnabled(), enabled)
+        parser.SetReparseDeferralEnabled(False)
+        self.assertIs(parser.GetReparseDeferralEnabled(), False)
+        parser.SetReparseDeferralEnabled(True)
+        self.assertIs(parser.GetReparseDeferralEnabled(), enabled)
+
+    @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 '
+                          'support reparse deferral')
+
+        started = []
+
+        def start_element(name, _):
+            started.append(name)
+
+        parser = expat.ParserCreate()
+        parser.StartElementHandler = start_element
+        self.assertTrue(parser.GetReparseDeferralEnabled())
+
+        for chunk in (b'<doc', b'/>'):
+            parser.Parse(chunk, False)
+
+        # The key test: Have handlers already fired?  Expecting: no.
+        self.assertEqual(started, [])
+
+        parser.Parse(b'', True)
+
+        self.assertEqual(started, ['doc'])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'xmlparser' object has no attribute 'SetReparseDeferralEnabled'
+    def test_reparse_deferral_disabled(self):
+        started = []
+
+        def start_element(name, _):
+            started.append(name)
+
+        parser = expat.ParserCreate()
+        parser.StartElementHandler = start_element
+        if expat.version_info >= (2, 6, 0):
+            parser.SetReparseDeferralEnabled(False)
+        self.assertFalse(parser.GetReparseDeferralEnabled())
+
+        for chunk in (b'<doc', b'/>'):
+            parser.Parse(chunk, False)
+
+        # The key test: Have handlers already fired?  Expecting: yes.
+        self.assertEqual(started, ['doc'])
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_quopri.py b/Lib/test/test_quopri.py
index 715544c8a9..152d1858dc 100644
--- a/Lib/test/test_quopri.py
+++ b/Lib/test/test_quopri.py
@@ -3,6 +3,7 @@
 import sys, io, subprocess
 import quopri
 
+from test import support
 
 
 ENCSAMPLE = b"""\
@@ -180,6 +181,7 @@ def test_decode_header(self):
         for p, e in self.HSTRINGS:
             self.assertEqual(quopri.decodestring(e, header=True), p)
 
+    @support.requires_subprocess()
     def test_scriptencode(self):
         (p, e) = self.STRINGS[-1]
         process = subprocess.Popen([sys.executable, "-mquopri"],
@@ -196,6 +198,7 @@ def test_scriptencode(self):
             self.assertEqual(cout[i], e[i])
         self.assertEqual(cout, e)
 
+    @support.requires_subprocess()
     def test_scriptdecode(self):
         (p, e) = self.STRINGS[-1]
         process = subprocess.Popen([sys.executable, "-mquopri", "-d"],
diff --git a/Lib/test/test_raise.py b/Lib/test/test_raise.py
index 94f42c84f1..605169f4b4 100644
--- a/Lib/test/test_raise.py
+++ b/Lib/test/test_raise.py
@@ -185,6 +185,17 @@ 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):
+            def __new__(*args, **kwargs):
+                return ["mortal value"]
+
+        msg = ".*should have returned an instance of BaseException.*"
+        with self.assertRaisesRegex(TypeError, msg):
+            raise IndexError from ConstructMortal
+
     def test_instance_cause(self):
         cause = KeyError()
         try:
@@ -233,8 +244,6 @@ class TestTracebackType(unittest.TestCase):
     def raiser(self):
         raise ValueError
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attrs(self):
         try:
             self.raiser()
@@ -270,8 +279,6 @@ def test_attrs(self):
         tb.tb_next = new_tb
         self.assertIs(tb.tb_next, new_tb)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_constructor(self):
         other_tb = get_tb()
         frame = sys._getframe()
diff --git a/Lib/test/test_re.py b/Lib/test/test_re.py
index 3c0b6af3c6..7c5bfba41b 100644
--- a/Lib/test/test_re.py
+++ b/Lib/test/test_re.py
@@ -1,7 +1,7 @@
 from test.support import (gc_collect, bigmemtest, _2G,
                           cpython_only, captured_stdout,
                           check_disallow_instantiation, is_emscripten, is_wasi,
-                          SHORT_TIMEOUT, requires_resource)
+                          warnings_helper, SHORT_TIMEOUT, CPUStopwatch, requires_resource)
 import locale
 import re
 import string
@@ -47,7 +47,7 @@ def recurse(actual, expect):
         recurse(actual, expect)
 
     def checkPatternError(self, pattern, errmsg, pos=None):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile(pattern)
         with self.subTest(pattern=pattern):
             err = cm.exception
@@ -56,7 +56,7 @@ def checkPatternError(self, pattern, errmsg, pos=None):
                 self.assertEqual(err.pos, pos)
 
     def checkTemplateError(self, pattern, repl, string, errmsg, pos=None):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.sub(pattern, repl, string)
         with self.subTest(pattern=pattern, repl=repl):
             err = cm.exception
@@ -64,8 +64,10 @@ def checkTemplateError(self, pattern, repl, string, errmsg, pos=None):
             if pos is not None:
                 self.assertEqual(err.pos, pos)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_error_is_PatternError_alias(self):
+        assert re.error is re.PatternError
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_keep_buffer(self):
         # See bug 14212
         b = bytearray(b'x')
@@ -129,8 +131,10 @@ def test_basic_re_sub(self):
         self.assertEqual(re.sub("(?i)b+", "x", "bbbb BBBB"), 'x x')
         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y'),
                          '9.3 -3 24x100y')
-        self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
-                         '9.3 -3 23x99y')
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', 3),
+                             '9.3 -3 23x99y')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.sub(r'\d+', self.bump_num, '08.2 -2 23x99y', count=3),
                          '9.3 -3 23x99y')
 
@@ -154,7 +158,7 @@ def test_basic_re_sub(self):
                          (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)+chr(8)))
         for c in 'cdehijklmopqsuwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ':
             with self.subTest(c):
-                with self.assertRaises(re.error):
+                with self.assertRaises(re.PatternError):
                     self.assertEqual(re.sub('a', '\\' + c, 'a'), '\\' + c)
 
         self.assertEqual(re.sub(r'^\s*', 'X', 'test'), 'Xtest')
@@ -237,9 +241,42 @@ def test_sub_template_numeric_escape(self):
 
     def test_qualified_re_sub(self):
         self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
-        self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.sub('a', 'b', 'aaaaa', count=1), 'baaaa')
 
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) got multiple values for argument 'count'"):
+            re.sub('a', 'b', 'aaaaa', 1, count=1)
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) got multiple values for argument 'flags'"):
+            re.sub('a', 'b', 'aaaaa', 1, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"sub\(\) takes from 3 to 5 positional arguments but 6 "
+                r"were given"):
+            re.sub('a', 'b', 'aaaaa', 1, 0, 0)
+
+    def test_misuse_flags(self):
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.sub('a', 'b', 'aaaaa', re.I)
+        self.assertEqual(result, re.sub('a', 'b', 'aaaaa', count=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'count' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.subn("b*", "x", "xyz", re.I)
+        self.assertEqual(result, re.subn("b*", "x", "xyz", count=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'count' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+        with self.assertWarns(DeprecationWarning) as w:
+            result = re.split(":", ":a:b::c", re.I)
+        self.assertEqual(result, re.split(":", ":a:b::c", maxsplit=int(re.I)))
+        self.assertEqual(str(w.warning),
+                         "'maxsplit' is passed as positional argument")
+        self.assertEqual(w.filename, __file__)
+
     def test_bug_114660(self):
         self.assertEqual(re.sub(r'(\S)\s+(\S)', r'\1 \2', 'hello  there'),
                          'hello there')
@@ -346,9 +383,22 @@ def test_re_subn(self):
         self.assertEqual(re.subn("b+", "x", "bbbb BBBB"), ('x BBBB', 1))
         self.assertEqual(re.subn("b+", "x", "xyz"), ('xyz', 0))
         self.assertEqual(re.subn("b*", "x", "xyz"), ('xxxyxzx', 4))
-        self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.subn("b*", "x", "xyz", 2), ('xxxyz', 2))
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.subn("b*", "x", "xyz", count=2), ('xxxyz', 2))
 
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) got multiple values for argument 'count'"):
+            re.subn('a', 'b', 'aaaaa', 1, count=1)
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) got multiple values for argument 'flags'"):
+            re.subn('a', 'b', 'aaaaa', 1, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"subn\(\) takes from 3 to 5 positional arguments but 6 "
+                r"were given"):
+            re.subn('a', 'b', 'aaaaa', 1, 0, 0)
+
     def test_re_split(self):
         for string in ":a:b::c", S(":a:b::c"):
             self.assertTypedEqual(re.split(":", string),
@@ -403,7 +453,9 @@ def test_re_split(self):
                 self.assertTypedEqual(re.split(sep, ':a:b::c'), expected)
 
     def test_qualified_re_split(self):
-        self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
+        with self.assertWarns(DeprecationWarning) as w:
+            self.assertEqual(re.split(":", ":a:b::c", 2), ['', 'a', 'b::c'])
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(re.split(":", ":a:b::c", maxsplit=2), ['', 'a', 'b::c'])
         self.assertEqual(re.split(':', 'a:b:c:d', maxsplit=2), ['a', 'b', 'c:d'])
         self.assertEqual(re.split("(:)", ":a:b::c", maxsplit=2),
@@ -413,6 +465,17 @@ def test_qualified_re_split(self):
         self.assertEqual(re.split("(:*)", ":a:b::c", maxsplit=2),
                          ['', ':', '', '', 'a:b::c'])
 
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) got multiple values for argument 'maxsplit'"):
+            re.split(":", ":a:b::c", 2, maxsplit=2)
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) got multiple values for argument 'flags'"):
+            re.split(":", ":a:b::c", 2, 0, flags=0)
+        with self.assertRaisesRegex(TypeError,
+                r"split\(\) takes from 2 to 4 positional arguments but 5 "
+                r"were given"):
+            re.split(":", ":a:b::c", 2, 0, 0)
+
     def test_re_findall(self):
         self.assertEqual(re.findall(":+", "abc"), [])
         for string in "a:b::c:::d", S("a:b::c:::d"):
@@ -663,8 +726,7 @@ def test_groupdict(self):
                                   'first second').groupdict(),
                          {'first':'first', 'second':'second'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expand(self):
         self.assertEqual(re.match("(?P<first>first) (?P<second>second)",
                                   "first second")
@@ -711,8 +773,7 @@ def test_repeat_minmax(self):
         self.checkPatternError(r'x{2,1}',
                                'min repeat greater than max repeat', 2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getattr(self):
         self.assertEqual(re.compile("(?i)(a)(b)").pattern, "(?i)(a)(b)")
         self.assertEqual(re.compile("(?i)(a)(b)").flags, re.I | re.U)
@@ -781,13 +842,12 @@ def test_other_escapes(self):
         re.purge()  # for warnings
         for c in 'ceghijklmopqyzCEFGHIJKLMNOPQRTVXY':
             with self.subTest(c):
-                self.assertRaises(re.error, re.compile, '\\%c' % c)
+                self.assertRaises(re.PatternError, re.compile, '\\%c' % c)
         for c in 'ceghijklmopqyzABCEFGHIJKLMNOPQRTVXYZ':
             with self.subTest(c):
-                self.assertRaises(re.error, re.compile, '[\\%c]' % c)
+                self.assertRaises(re.PatternError, re.compile, '[\\%c]' % c)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_unicode_escapes(self):
         # test individual Unicode named escapes
         self.assertTrue(re.match(r'\N{LESS-THAN SIGN}', '<'))
@@ -828,31 +888,137 @@ def test_named_unicode_escapes(self):
         self.checkPatternError(br'\N{LESS-THAN SIGN}', r'bad escape \N', 0)
         self.checkPatternError(br'[\N{LESS-THAN SIGN}]', r'bad escape \N', 1)
 
-    def test_string_boundaries(self):
+    def test_word_boundaries(self):
         # See http://bugs.python.org/issue10713
-        self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1),
-                         "abc")
+        self.assertEqual(re.search(r"\b(abc)\b", "abc").group(1), "abc")
+        self.assertEqual(re.search(r"\b(abc)\b", "abc", re.ASCII).group(1), "abc")
+        self.assertEqual(re.search(br"\b(abc)\b", b"abc").group(1), b"abc")
+        self.assertEqual(re.search(br"\b(abc)\b", b"abc", re.LOCALE).group(1), b"abc")
+        self.assertEqual(re.search(r"\b(ьюя)\b", "ьюя").group(1), "ьюя")
+        self.assertIsNone(re.search(r"\b(ьюя)\b", "ьюя", re.ASCII))
+        # There's a word boundary between a word and a non-word.
+        self.assertTrue(re.match(r".\b", "a="))
+        self.assertTrue(re.match(r".\b", "a=", re.ASCII))
+        self.assertTrue(re.match(br".\b", b"a="))
+        self.assertTrue(re.match(br".\b", b"a=", re.LOCALE))
+        self.assertTrue(re.match(r".\b", "я="))
+        self.assertIsNone(re.match(r".\b", "я=", re.ASCII))
+        # There's a word boundary between a non-word and a word.
+        self.assertTrue(re.match(r".\b", "=a"))
+        self.assertTrue(re.match(r".\b", "=a", re.ASCII))
+        self.assertTrue(re.match(br".\b", b"=a"))
+        self.assertTrue(re.match(br".\b", b"=a", re.LOCALE))
+        self.assertTrue(re.match(r".\b", "=я"))
+        self.assertIsNone(re.match(r".\b", "=я", re.ASCII))
+        # There is no word boundary inside a word.
+        self.assertIsNone(re.match(r".\b", "ab"))
+        self.assertIsNone(re.match(r".\b", "ab", re.ASCII))
+        self.assertIsNone(re.match(br".\b", b"ab"))
+        self.assertIsNone(re.match(br".\b", b"ab", re.LOCALE))
+        self.assertIsNone(re.match(r".\b", "юя"))
+        self.assertIsNone(re.match(r".\b", "юя", re.ASCII))
+        # There is no word boundary between a non-word characters.
+        self.assertIsNone(re.match(r".\b", "=-"))
+        self.assertIsNone(re.match(r".\b", "=-", re.ASCII))
+        self.assertIsNone(re.match(br".\b", b"=-"))
+        self.assertIsNone(re.match(br".\b", b"=-", re.LOCALE))
+        # There is no non-boundary match between a word and a non-word.
+        self.assertIsNone(re.match(r".\B", "a="))
+        self.assertIsNone(re.match(r".\B", "a=", re.ASCII))
+        self.assertIsNone(re.match(br".\B", b"a="))
+        self.assertIsNone(re.match(br".\B", b"a=", re.LOCALE))
+        self.assertIsNone(re.match(r".\B", "я="))
+        self.assertTrue(re.match(r".\B", "я=", re.ASCII))
+        # There is no non-boundary match between a non-word and a word.
+        self.assertIsNone(re.match(r".\B", "=a"))
+        self.assertIsNone(re.match(r".\B", "=a", re.ASCII))
+        self.assertIsNone(re.match(br".\B", b"=a"))
+        self.assertIsNone(re.match(br".\B", b"=a", re.LOCALE))
+        self.assertIsNone(re.match(r".\B", "=я"))
+        self.assertTrue(re.match(r".\B", "=я", re.ASCII))
+        # There's a non-boundary match inside a word.
+        self.assertTrue(re.match(r".\B", "ab"))
+        self.assertTrue(re.match(r".\B", "ab", re.ASCII))
+        self.assertTrue(re.match(br".\B", b"ab"))
+        self.assertTrue(re.match(br".\B", b"ab", re.LOCALE))
+        self.assertTrue(re.match(r".\B", "юя"))
+        self.assertTrue(re.match(r".\B", "юя", re.ASCII))
+        # There's a non-boundary match between a non-word characters.
+        self.assertTrue(re.match(r".\B", "=-"))
+        self.assertTrue(re.match(r".\B", "=-", re.ASCII))
+        self.assertTrue(re.match(br".\B", b"=-"))
+        self.assertTrue(re.match(br".\B", b"=-", re.LOCALE))
         # There's a word boundary at the start of a string.
         self.assertTrue(re.match(r"\b", "abc"))
+        self.assertTrue(re.match(r"\b", "abc", re.ASCII))
+        self.assertTrue(re.match(br"\b", b"abc"))
+        self.assertTrue(re.match(br"\b", b"abc", re.LOCALE))
+        self.assertTrue(re.match(r"\b", "ьюя"))
+        self.assertIsNone(re.match(r"\b", "ьюя", re.ASCII))
+        # There's a word boundary at the end of a string.
+        self.assertTrue(re.fullmatch(r".+\b", "abc"))
+        self.assertTrue(re.fullmatch(r".+\b", "abc", re.ASCII))
+        self.assertTrue(re.fullmatch(br".+\b", b"abc"))
+        self.assertTrue(re.fullmatch(br".+\b", b"abc", re.LOCALE))
+        self.assertTrue(re.fullmatch(r".+\b", "ьюя"))
+        self.assertIsNone(re.search(r"\b", "ьюя", re.ASCII))
         # A non-empty string includes a non-boundary zero-length match.
-        self.assertTrue(re.search(r"\B", "abc"))
+        self.assertEqual(re.search(r"\B", "abc").span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "abc", re.ASCII).span(), (1, 1))
+        self.assertEqual(re.search(br"\B", b"abc").span(), (1, 1))
+        self.assertEqual(re.search(br"\B", b"abc", re.LOCALE).span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "ьюя").span(), (1, 1))
+        self.assertEqual(re.search(r"\B", "ьюя", re.ASCII).span(), (0, 0))
         # There is no non-boundary match at the start of a string.
-        self.assertFalse(re.match(r"\B", "abc"))
+        self.assertIsNone(re.match(r"\B", "abc"))
+        self.assertIsNone(re.match(r"\B", "abc", re.ASCII))
+        self.assertIsNone(re.match(br"\B", b"abc"))
+        self.assertIsNone(re.match(br"\B", b"abc", re.LOCALE))
+        self.assertIsNone(re.match(r"\B", "ьюя"))
+        self.assertTrue(re.match(r"\B", "ьюя", re.ASCII))
+        # There is no non-boundary match at the end of a string.
+        self.assertIsNone(re.fullmatch(r".+\B", "abc"))
+        self.assertIsNone(re.fullmatch(r".+\B", "abc", re.ASCII))
+        self.assertIsNone(re.fullmatch(br".+\B", b"abc"))
+        self.assertIsNone(re.fullmatch(br".+\B", b"abc", re.LOCALE))
+        self.assertIsNone(re.fullmatch(r".+\B", "ьюя"))
+        self.assertTrue(re.fullmatch(r".+\B", "ьюя", re.ASCII))
         # However, an empty string contains no word boundaries, and also no
         # non-boundaries.
-        self.assertIsNone(re.search(r"\B", ""))
+        self.assertIsNone(re.search(r"\b", ""))
+        self.assertIsNone(re.search(r"\b", "", re.ASCII))
+        self.assertIsNone(re.search(br"\b", b""))
+        self.assertIsNone(re.search(br"\b", b"", re.LOCALE))
         # This one is questionable and different from the perlre behaviour,
         # but describes current behavior.
-        self.assertIsNone(re.search(r"\b", ""))
+        self.assertIsNone(re.search(r"\B", ""))
+        self.assertIsNone(re.search(r"\B", "", re.ASCII))
+        self.assertIsNone(re.search(br"\B", b""))
+        self.assertIsNone(re.search(br"\B", b"", re.LOCALE))
         # A single word-character string has two boundaries, but no
         # non-boundary gaps.
         self.assertEqual(len(re.findall(r"\b", "a")), 2)
+        self.assertEqual(len(re.findall(r"\b", "a", re.ASCII)), 2)
+        self.assertEqual(len(re.findall(br"\b", b"a")), 2)
+        self.assertEqual(len(re.findall(br"\b", b"a", re.LOCALE)), 2)
         self.assertEqual(len(re.findall(r"\B", "a")), 0)
+        self.assertEqual(len(re.findall(r"\B", "a", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\B", b"a")), 0)
+        self.assertEqual(len(re.findall(br"\B", b"a", re.LOCALE)), 0)
         # If there are no words, there are no boundaries
         self.assertEqual(len(re.findall(r"\b", " ")), 0)
+        self.assertEqual(len(re.findall(r"\b", " ", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\b", b" ")), 0)
+        self.assertEqual(len(re.findall(br"\b", b" ", re.LOCALE)), 0)
         self.assertEqual(len(re.findall(r"\b", "   ")), 0)
+        self.assertEqual(len(re.findall(r"\b", "   ", re.ASCII)), 0)
+        self.assertEqual(len(re.findall(br"\b", b"   ")), 0)
+        self.assertEqual(len(re.findall(br"\b", b"   ", re.LOCALE)), 0)
         # Can match around the whitespace.
         self.assertEqual(len(re.findall(r"\B", " ")), 2)
+        self.assertEqual(len(re.findall(r"\B", " ", re.ASCII)), 2)
+        self.assertEqual(len(re.findall(br"\B", b" ")), 2)
+        self.assertEqual(len(re.findall(br"\B", b" ", re.LOCALE)), 2)
 
     def test_bigcharset(self):
         self.assertEqual(re.match("([\u2222\u2223])",
@@ -917,14 +1083,14 @@ def test_lookbehind(self):
         self.assertIsNone(re.match(r'(?:(a)|(x))b(?<=(?(1)c|x))c', 'abc'))
         self.assertTrue(re.match(r'(?:(a)|(x))b(?<=(?(1)b|x))c', 'abc'))
         # Group used before defined.
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?(2)b|x))(c)')
         self.assertIsNone(re.match(r'(a)b(?<=(?(1)c|x))(c)', 'abc'))
         self.assertTrue(re.match(r'(a)b(?<=(?(1)b|x))(c)', 'abc'))
         # Group defined in the same lookbehind pattern
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)\2)(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
-        self.assertRaises(re.error, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)\2)(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(?P<a>.)(?P=a))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(a)(?(2)b|x))(c)')
+        self.assertRaises(re.PatternError, re.compile, r'(a)b(?<=(.)(?<=\2))(c)')
 
     def test_ignore_case(self):
         self.assertEqual(re.match("abc", "ABC", re.I).group(0), "ABC")
@@ -975,6 +1141,39 @@ def test_ignore_case_set(self):
         self.assertTrue(re.match(br'[19a]', b'a', re.I))
         self.assertTrue(re.match(br'[19a]', b'A', re.I))
         self.assertTrue(re.match(br'[19A]', b'a', re.I))
+        self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I))
+        self.assertTrue(re.match(r'[19\xc7]', '\xe7', re.I))
+        self.assertTrue(re.match(r'[19\xe7]', '\xc7', re.I))
+        self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0450', re.I))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0400', re.I))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010428', re.I))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010400', re.I))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I))
+
+        self.assertTrue(re.match(br'[19A]', b'A', re.I))
+        self.assertTrue(re.match(br'[19a]', b'a', re.I))
+        self.assertTrue(re.match(br'[19a]', b'A', re.I))
+        self.assertTrue(re.match(br'[19A]', b'a', re.I))
+        self.assertTrue(re.match(r'[19A]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[19a]', 'a', re.I|re.A))
+        self.assertTrue(re.match(r'[19a]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[19A]', 'a', re.I|re.A))
+        self.assertTrue(re.match(r'[19\xc7]', '\xc7', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\xc7]', '\xe7', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\xe7]', '\xc7', re.I|re.A))
+        self.assertTrue(re.match(r'[19\xe7]', '\xe7', re.I|re.A))
+        self.assertTrue(re.match(r'[19\u0400]', '\u0400', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\u0400]', '\u0450', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\u0450]', '\u0400', re.I|re.A))
+        self.assertTrue(re.match(r'[19\u0450]', '\u0450', re.I|re.A))
+        self.assertTrue(re.match(r'[19\U00010400]', '\U00010400', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\U00010400]', '\U00010428', re.I|re.A))
+        self.assertIsNone(re.match(r'[19\U00010428]', '\U00010400', re.I|re.A))
+        self.assertTrue(re.match(r'[19\U00010428]', '\U00010428', re.I|re.A))
 
         # Two different characters have the same lowercase.
         assert 'K'.lower() == '\u212a'.lower() == 'k' # 'K'
@@ -1011,8 +1210,10 @@ def test_ignore_case_range(self):
         self.assertTrue(re.match(br'[9-a]', b'_', re.I))
         self.assertIsNone(re.match(br'[9-A]', b'_', re.I))
         self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I))
+        self.assertTrue(re.match(r'[\xc0-\xde]', '\xe7', re.I))
         self.assertIsNone(re.match(r'[\xc0-\xde]', '\xf7', re.I))
         self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I))
+        self.assertTrue(re.match(r'[\xe0-\xfe]', '\xc7', re.I))
         self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xd7', re.I))
         self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I))
         self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0400', re.I))
@@ -1023,6 +1224,26 @@ def test_ignore_case_range(self):
         self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I))
         self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I))
 
+        self.assertTrue(re.match(r'[\xc0-\xde]', '\xd7', re.I|re.A))
+        self.assertIsNone(re.match(r'[\xc0-\xde]', '\xe7', re.I|re.A))
+        self.assertTrue(re.match(r'[\xe0-\xfe]', '\xf7', re.I|re.A))
+        self.assertIsNone(re.match(r'[\xe0-\xfe]', '\xc7', re.I|re.A))
+        self.assertTrue(re.match(r'[\u0430-\u045f]', '\u0450', re.I|re.A))
+        self.assertIsNone(re.match(r'[\u0430-\u045f]', '\u0400', re.I|re.A))
+        self.assertIsNone(re.match(r'[\u0400-\u042f]', '\u0450', re.I|re.A))
+        self.assertTrue(re.match(r'[\u0400-\u042f]', '\u0400', re.I|re.A))
+        self.assertTrue(re.match(r'[\U00010428-\U0001044f]', '\U00010428', re.I|re.A))
+        self.assertIsNone(re.match(r'[\U00010428-\U0001044f]', '\U00010400', re.I|re.A))
+        self.assertIsNone(re.match(r'[\U00010400-\U00010427]', '\U00010428', re.I|re.A))
+        self.assertTrue(re.match(r'[\U00010400-\U00010427]', '\U00010400', re.I|re.A))
+
+        self.assertTrue(re.match(r'[N-\x7f]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\x7f]', 'Z', re.I|re.A))
+        self.assertTrue(re.match(r'[N-\uffff]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\uffff]', 'Z', re.I|re.A))
+        self.assertTrue(re.match(r'[N-\U00010000]', 'A', re.I|re.A))
+        self.assertTrue(re.match(r'[n-\U00010000]', 'Z', re.I|re.A))
+
         # Two different characters have the same lowercase.
         assert 'K'.lower() == '\u212a'.lower() == 'k' # 'K'
         self.assertTrue(re.match(r'[J-M]', '\u212a', re.I))
@@ -1060,47 +1281,76 @@ def test_not_literal(self):
 
     def test_possible_set_operations(self):
         s = bytes(range(128)).decode()
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
             p = re.compile(r'[0-9--1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('-./0123456789'))
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
+            self.assertEqual(re.findall(r'[0-9--2]', s), list('-./0123456789'))
+        self.assertEqual(w.filename, __file__)
+
         self.assertEqual(re.findall(r'[--1]', s), list('-./01'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference') as w:
             p = re.compile(r'[%--1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list("%&'()*+,-1"))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set difference ') as w:
             p = re.compile(r'[%--]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list("%&'()*+,-"))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
             p = re.compile(r'[0-9&&1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('&0123456789'))
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
+            self.assertEqual(re.findall(r'[0-8&&1]', s), list('&012345678'))
+        self.assertEqual(w.filename, __file__)
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set intersection ') as w:
             p = re.compile(r'[\d&&1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('&0123456789'))
+
         self.assertEqual(re.findall(r'[&&1]', s), list('&1'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set union ') as w:
             p = re.compile(r'[0-9||a]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789a|'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set union ') as w:
             p = re.compile(r'[\d||a]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789a|'))
+
         self.assertEqual(re.findall(r'[||1]', s), list('1|'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible set symmetric difference ') as w:
             p = re.compile(r'[0-9~~1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789~'))
-        with self.assertWarns(FutureWarning):
+
+        with self.assertWarnsRegex(FutureWarning, 'Possible set symmetric difference ') as w:
             p = re.compile(r'[\d~~1]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789~'))
+
         self.assertEqual(re.findall(r'[~~1]', s), list('1~'))
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
             p = re.compile(r'[[0-9]|]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list('0123456789[]'))
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
+            self.assertEqual(re.findall(r'[[0-8]|]', s), list('012345678[]'))
+        self.assertEqual(w.filename, __file__)
 
-        with self.assertWarns(FutureWarning):
+        with self.assertWarnsRegex(FutureWarning, 'Possible nested set ') as w:
             p = re.compile(r'[[:digit:]|]')
+        self.assertEqual(w.filename, __file__)
         self.assertEqual(p.findall(s), list(':[]dgit'))
 
     def test_search_coverage(self):
@@ -1175,8 +1425,7 @@ def test_pickling(self):
         # current pickle expects the _compile() reconstructor in re module
         from re import _compile
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_copying(self):
         import copy
         p = re.compile(r'(?P<int>\d+)(?:\.(?P<frac>\d*))?')
@@ -1267,8 +1516,8 @@ def test_sre_byte_literals(self):
             self.assertTrue(re.match((r"\x%02x" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"\x%02x0" % i).encode(), bytes([i])+b"0"))
             self.assertTrue(re.match((r"\x%02xz" % i).encode(), bytes([i])+b"z"))
-        self.assertRaises(re.error, re.compile, br"\u1234")
-        self.assertRaises(re.error, re.compile, br"\U00012345")
+        self.assertRaises(re.PatternError, re.compile, br"\u1234")
+        self.assertRaises(re.PatternError, re.compile, br"\U00012345")
         self.assertTrue(re.match(br"\0", b"\000"))
         self.assertTrue(re.match(br"\08", b"\0008"))
         self.assertTrue(re.match(br"\01", b"\001"))
@@ -1290,8 +1539,8 @@ def test_sre_byte_class_literals(self):
             self.assertTrue(re.match((r"[\x%02x]" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"[\x%02x0]" % i).encode(), bytes([i])))
             self.assertTrue(re.match((r"[\x%02xz]" % i).encode(), bytes([i])))
-        self.assertRaises(re.error, re.compile, br"[\u1234]")
-        self.assertRaises(re.error, re.compile, br"[\U00012345]")
+        self.assertRaises(re.PatternError, re.compile, br"[\u1234]")
+        self.assertRaises(re.PatternError, re.compile, br"[\U00012345]")
         self.checkPatternError(br"[\567]",
                                r'octal escape value \567 outside of '
                                r'range 0-0o377', 1)
@@ -1484,8 +1733,7 @@ def test_bug_817234(self):
         self.assertEqual(next(iter).span(), (4, 4))
         self.assertRaises(StopIteration, next, iter)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_6561(self):
         # '\d' should match characters in Unicode category 'Nd'
         # (Number, Decimal Digit), but not those in 'Nl' (Number,
@@ -1507,10 +1755,12 @@ def test_bug_6561(self):
         for x in not_decimal_digits:
             self.assertIsNone(re.match(r'^\d$', x))
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON a = array.array(typecode)\n ValueError: bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)
+    @warnings_helper.ignore_warnings(category=DeprecationWarning)  # gh-80480 array('u')
     def test_empty_array(self):
         # SF buf 1647541
         import array
-        for typecode in 'bBuhHiIlLfd':
+        for typecode in 'bBhuwHiIlLfd':
             a = array.array(typecode)
             self.assertIsNone(re.compile(b"bla").match(a))
             self.assertEqual(re.compile(b"").match(a).groups(), ())
@@ -1625,11 +1875,11 @@ def test_ascii_and_unicode_flag(self):
             self.assertIsNone(pat.match(b'\xe0'))
         # Incompatibilities
         self.assertRaises(ValueError, re.compile, br'\w', re.UNICODE)
-        self.assertRaises(re.error, re.compile, br'(?u)\w')
+        self.assertRaises(re.PatternError, re.compile, br'(?u)\w')
         self.assertRaises(ValueError, re.compile, r'\w', re.UNICODE | re.ASCII)
         self.assertRaises(ValueError, re.compile, r'(?u)\w', re.ASCII)
         self.assertRaises(ValueError, re.compile, r'(?a)\w', re.UNICODE)
-        self.assertRaises(re.error, re.compile, r'(?au)\w')
+        self.assertRaises(re.PatternError, re.compile, r'(?au)\w')
 
     def test_locale_flag(self):
         enc = locale.getpreferredencoding()
@@ -1670,11 +1920,11 @@ def test_locale_flag(self):
             self.assertIsNone(pat.match(bletter))
         # Incompatibilities
         self.assertRaises(ValueError, re.compile, '', re.LOCALE)
-        self.assertRaises(re.error, re.compile, '(?L)')
+        self.assertRaises(re.PatternError, re.compile, '(?L)')
         self.assertRaises(ValueError, re.compile, b'', re.LOCALE | re.ASCII)
         self.assertRaises(ValueError, re.compile, b'(?L)', re.ASCII)
         self.assertRaises(ValueError, re.compile, b'(?a)', re.LOCALE)
-        self.assertRaises(re.error, re.compile, b'(?aL)')
+        self.assertRaises(re.PatternError, re.compile, b'(?aL)')
 
     def test_scoped_flags(self):
         self.assertTrue(re.match(r'(?i:a)b', 'Ab'))
@@ -1854,8 +2104,7 @@ def test_issue17998(self):
                 self.assertEqual(re.compile(pattern, re.S).findall(b'xyz'),
                                  [b'xyz'], msg=pattern)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_match_repr(self):
         for string in '[abracadabra]', S('[abracadabra]'):
             m = re.search(r'(.+)(.*?)\1', string)
@@ -1935,6 +2184,7 @@ def test_bug_20998(self):
         # with ignore case.
         self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertTrue(re.match(b'\xc5', b'\xe5', re.L|re.I))\n AssertionError: None is not true
     @unittest.skipIf(
         is_emscripten or is_wasi,
         "musl libc issue on Emscripten/WASI, bpo-46390"
@@ -2012,7 +2262,7 @@ def test_locale_compiled(self):
         self.assertIsNone(p4.match(b'\xc5\xc5'))
 
     def test_error(self):
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile('(\u20ac))')
         err = cm.exception
         self.assertIsInstance(err.pattern, str)
@@ -2024,14 +2274,14 @@ def test_error(self):
         self.assertIn(' at position 3', str(err))
         self.assertNotIn(' at position 3', err.msg)
         # Bytes pattern
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile(b'(\xa4))')
         err = cm.exception
         self.assertIsInstance(err.pattern, bytes)
         self.assertEqual(err.pattern, b'(\xa4))')
         self.assertEqual(err.pos, 3)
         # Multiline pattern
-        with self.assertRaises(re.error) as cm:
+        with self.assertRaises(re.PatternError) as cm:
             re.compile("""
                 (
                     abc
@@ -2231,24 +2481,24 @@ def test_bug_40736(self):
         with self.assertRaisesRegex(TypeError, "got 'type'"):
             re.search("x*", type)
 
-    @unittest.skip("TODO: RUSTPYTHON: flaky, improve perf")
+    # gh-117594: The test is not slow by itself, but it relies on
+    # the absolute computation time and can fail on very slow computers.
+    @unittest.skip('TODO: RUSTPYTHON; flaky, improve perf')
     @requires_resource('cpu')
     def test_search_anchor_at_beginning(self):
         s = 'x'*10**7
-        start = time.perf_counter()
-        for p in r'\Ay', r'^y':
-            self.assertIsNone(re.search(p, s))
-            self.assertEqual(re.split(p, s), [s])
-            self.assertEqual(re.findall(p, s), [])
-            self.assertEqual(list(re.finditer(p, s)), [])
-            self.assertEqual(re.sub(p, '', s), s)
-        t = time.perf_counter() - start
+        with CPUStopwatch() as stopwatch:
+            for p in r'\Ay', r'^y':
+                self.assertIsNone(re.search(p, s))
+                self.assertEqual(re.split(p, s), [s])
+                self.assertEqual(re.findall(p, s), [])
+                self.assertEqual(list(re.finditer(p, s)), [])
+                self.assertEqual(re.sub(p, '', s), s)
         # Without optimization it takes 1 second on my computer.
         # With optimization -- 0.0003 seconds.
-        self.assertLess(t, 0.2)
+        self.assertLess(stopwatch.seconds, 0.1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_possessive_quantifiers(self):
         """Test Possessive Quantifiers
         Test quantifiers of the form @+ for some repetition operator @,
@@ -2288,8 +2538,7 @@ def test_possessive_quantifiers(self):
         self.assertIsNone(re.match("^x{}+$", "xxx"))
         self.assertTrue(re.match("^x{}+$", "x{}"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_possessive_quantifiers(self):
         self.assertTrue(re.fullmatch(r'a++', 'a'))
         self.assertTrue(re.fullmatch(r'a*+', 'a'))
@@ -2342,8 +2591,7 @@ def test_atomic_grouping(self):
         self.assertIsNone(re.match(r'(?>x)++x', 'xxx'))
         self.assertIsNone(re.match(r'(?>x++)x', 'xxx'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_fullmatch_atomic_grouping(self):
         self.assertTrue(re.fullmatch(r'(?>a+)', 'a'))
         self.assertTrue(re.fullmatch(r'(?>a*)', 'a'))
@@ -2382,39 +2630,12 @@ def test_findall_atomic_grouping(self):
         self.assertEqual(re.findall(r'(?>(?:ab)?)', 'ababc'), ['ab', 'ab', '', ''])
         self.assertEqual(re.findall(r'(?>(?:ab){1,3})', 'ababc'), ['abab'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_gh91616(self):
         self.assertTrue(re.fullmatch(r'(?s:(?>.*?\.).*)\Z', "a.txt")) # reproducer
         self.assertTrue(re.fullmatch(r'(?s:(?=(?P<g0>.*?\.))(?P=g0).*)\Z', "a.txt"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_template_function_and_flag_is_deprecated(self):
-        with self.assertWarns(DeprecationWarning) as cm:
-            template_re1 = re.template(r'a')
-        self.assertIn('re.template()', str(cm.warning))
-        self.assertIn('is deprecated', str(cm.warning))
-        self.assertIn('function', str(cm.warning))
-        self.assertNotIn('flag', str(cm.warning))
-
-        with self.assertWarns(DeprecationWarning) as cm:
-            # we deliberately use more flags here to test that that still
-            # triggers the warning
-            # if paranoid, we could test multiple different combinations,
-            # but it's probably not worth it
-            template_re2 = re.compile(r'a', flags=re.TEMPLATE|re.UNICODE)
-        self.assertIn('re.TEMPLATE', str(cm.warning))
-        self.assertIn('is deprecated', str(cm.warning))
-        self.assertIn('flag', str(cm.warning))
-        self.assertNotIn('function', str(cm.warning))
-
-        # while deprecated, is should still function
-        self.assertEqual(template_re1, template_re2)
-        self.assertTrue(template_re1.match('ahoy'))
-        self.assertFalse(template_re1.match('nope'))
-
-    def test_bug_gh106052(self):
+    def test_bug_gh100061(self):
         # gh-100061
         self.assertEqual(re.match('(?>(?:.(?!D))+)', 'ABCDE').span(), (0, 2))
         self.assertEqual(re.match('(?:.(?!D))++', 'ABCDE').span(), (0, 2))
@@ -2434,8 +2655,13 @@ def test_bug_gh106052(self):
         self.assertEqual(re.match("(?>(?:ab?c){1,3})", "aca").span(), (0, 2))
         self.assertEqual(re.match("(?:ab?c){1,3}+", "aca").span(), (0, 2))
 
-    # TODO: RUSTPYTHON
-    @unittest.skipUnless(sys.platform == 'linux', 'multiprocessing related issue')
+    @unittest.expectedFailure  # TODO: RUSTPYTHON; self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))\n AssertionError: Tuples differ: ('x', 'x') != ('z', 'x')
+    def test_bug_gh101955(self):
+        # Possessive quantifier with nested alternative with capture groups
+        self.assertEqual(re.match('((x)|y|z)*+', 'xyz').groups(), ('z', 'x'))
+        self.assertEqual(re.match('((x)|y|z){3}+', 'xyz').groups(), ('z', 'x'))
+        self.assertEqual(re.match('((x)|y|z){3,}+', 'xyz').groups(), ('z', 'x'))
+
     @unittest.skipIf(multiprocessing is None, 'test requires multiprocessing')
     def test_regression_gh94675(self):
         pattern = re.compile(r'(?<=[({}])(((//[^\n]*)?[\n])([\000-\040])*)*'
@@ -2456,6 +2682,54 @@ def test_regression_gh94675(self):
                 p.terminate()
                 p.join()
 
+    def test_fail(self):
+        self.assertEqual(re.search(r'12(?!)|3', '123')[0], '3')
+
+    def test_character_set_any(self):
+        # The union of complementary character sets matches any character
+        # and is equivalent to "(?s:.)".
+        s = '1x\n'
+        for p in r'[\s\S]', r'[\d\D]', r'[\w\W]', r'[\S\s]', r'\s|\S':
+            with self.subTest(pattern=p):
+                self.assertEqual(re.findall(p, s), list(s))
+                self.assertEqual(re.fullmatch('(?:' + p + ')+', s).group(), s)
+
+    def test_character_set_none(self):
+        # Negation of the union of complementary character sets does not match
+        # any character.
+        s = '1x\n'
+        for p in r'[^\s\S]', r'[^\d\D]', r'[^\w\W]', r'[^\S\s]':
+            with self.subTest(pattern=p):
+                self.assertIsNone(re.search(p, s))
+                self.assertIsNone(re.search('(?s:.)' + p, s))
+
+    def check_interrupt(self, pattern, string, maxcount):
+        class Interrupt(Exception):
+            pass
+        p = re.compile(pattern)
+        for n in range(maxcount):
+            try:
+                p._fail_after(n, Interrupt)
+                p.match(string)
+                return n
+            except Interrupt:
+                pass
+            finally:
+                p._fail_after(-1, None)
+
+    @unittest.skipUnless(hasattr(re.Pattern, '_fail_after'), 'requires debug build')
+    def test_memory_leaks(self):
+        self.check_interrupt(r'(.)*:', 'abc:', 100)
+        self.check_interrupt(r'([^:])*?:', 'abc:', 100)
+        self.check_interrupt(r'([^:])*+:', 'abc:', 100)
+        self.check_interrupt(r'(.){2,4}:', 'abc:', 100)
+        self.check_interrupt(r'([^:]){2,4}?:', 'abc:', 100)
+        self.check_interrupt(r'([^:]){2,4}+:', 'abc:', 100)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_template_function_and_flag_is_deprecated(self):
+        return super().test_template_function_and_flag_is_deprecated()
+
 
 def get_debug_out(pat):
     with captured_stdout() as out:
@@ -2590,8 +2864,7 @@ def test_inline_flags(self):
         self.check('(?i)pattern',
                    "re.compile('(?i)pattern', re.IGNORECASE)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unknown_flags(self):
         self.check_flags('random pattern', 0x123000,
                          "re.compile('random pattern', 0x123000)")
@@ -2626,8 +2899,6 @@ def test_long_pattern(self):
         self.assertEqual(r[:30], "re.compile('Very long long lon")
         self.assertEqual(r[-16:], ", re.IGNORECASE)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_flags_repr(self):
         self.assertEqual(repr(re.I), "re.IGNORECASE")
         self.assertEqual(repr(re.I|re.S|re.X),
@@ -2636,11 +2907,11 @@ def test_flags_repr(self):
                          "re.IGNORECASE|re.DOTALL|re.VERBOSE|0x100000")
         self.assertEqual(
                 repr(~re.I),
-                "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.TEMPLATE|re.DEBUG")
+                "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DOTALL|re.VERBOSE|re.DEBUG|0x1")
         self.assertEqual(repr(~(re.I|re.S|re.X)),
-                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG")
+                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0x1")
         self.assertEqual(repr(~(re.I|re.S|re.X|(1<<20))),
-                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.TEMPLATE|re.DEBUG|0xffe00")
+                         "re.ASCII|re.LOCALE|re.UNICODE|re.MULTILINE|re.DEBUG|0xffe01")
 
 
 class ImplementationTest(unittest.TestCase):
@@ -2681,8 +2952,7 @@ def test_disallow_instantiation(self):
         pat = re.compile("")
         check_disallow_instantiation(self, type(pat.scanner("")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_deprecated_modules(self):
         deprecated = {
             'sre_compile': ['compile', 'error',
@@ -2813,7 +3083,7 @@ def test_re_tests(self):
 
             with self.subTest(pattern=pattern, string=s):
                 if outcome == SYNTAX_ERROR:  # Expected a syntax error
-                    with self.assertRaises(re.error):
+                    with self.assertRaises(re.PatternError):
                         re.compile(pattern)
                     continue
 
diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index fc56ec4afc..9f09413f59 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -5,28 +5,57 @@
 """
 
 import contextlib
-import faulthandler
+import dataclasses
 import glob
 import io
+import locale
 import os.path
 import platform
+import random
 import re
+import shlex
+import signal
 import subprocess
 import sys
 import sysconfig
 import tempfile
 import textwrap
 import unittest
-from test import libregrtest
+from xml.etree import ElementTree
+
 from test import support
-from test.support import os_helper
+from test.support import os_helper, without_optimizer
+from test.libregrtest import cmdline
+from test.libregrtest import main
+from test.libregrtest import setup
 from test.libregrtest import utils
+from test.libregrtest.filter import get_match_tests, set_match_tests, match_test
+from test.libregrtest.result import TestStats
+from test.libregrtest.utils import normalize_test_name
 
+if not support.has_subprocess_support:
+    raise unittest.SkipTest("test module requires subprocess")
 
-Py_DEBUG = hasattr(sys, 'gettotalrefcount')
 ROOT_DIR = os.path.join(os.path.dirname(__file__), '..', '..')
 ROOT_DIR = os.path.abspath(os.path.normpath(ROOT_DIR))
 LOG_PREFIX = r'[0-9]+:[0-9]+:[0-9]+ (?:load avg: [0-9]+\.[0-9]{2} )?'
+RESULT_REGEX = (
+    'passed',
+    'failed',
+    'skipped',
+    'interrupted',
+    'env changed',
+    'timed out',
+    'ran no tests',
+    'worker non-zero exit code',
+)
+RESULT_REGEX = fr'(?:{"|".join(RESULT_REGEX)})'
+
+EXITCODE_BAD_TEST = 2
+EXITCODE_ENV_CHANGED = 3
+EXITCODE_NO_TESTS_RAN = 4
+EXITCODE_RERUN_FAIL = 5
+EXITCODE_INTERRUPTED = 130
 
 TEST_INTERRUPTED = textwrap.dedent("""
     from signal import SIGINT, raise_signal
@@ -43,9 +72,13 @@ class ParseArgsTestCase(unittest.TestCase):
     Test regrtest's argument parsing, function _parse_args().
     """
 
+    @staticmethod
+    def parse_args(args):
+        return cmdline._parse_args(args)
+
     def checkError(self, args, msg):
         with support.captured_stderr() as err, self.assertRaises(SystemExit):
-            libregrtest._parse_args(args)
+            self.parse_args(args)
         self.assertIn(msg, err.getvalue())
 
     def test_help(self):
@@ -53,94 +86,130 @@ def test_help(self):
             with self.subTest(opt=opt):
                 with support.captured_stdout() as out, \
                      self.assertRaises(SystemExit):
-                    libregrtest._parse_args([opt])
+                    self.parse_args([opt])
                 self.assertIn('Run Python regression tests.', out.getvalue())
 
-    @unittest.skipUnless(hasattr(faulthandler, 'dump_traceback_later'),
-                         "faulthandler.dump_traceback_later() required")
     def test_timeout(self):
-        ns = libregrtest._parse_args(['--timeout', '4.2'])
+        ns = self.parse_args(['--timeout', '4.2'])
         self.assertEqual(ns.timeout, 4.2)
+
+        # negative, zero and empty string are treated as "no timeout"
+        for value in ('-1', '0', ''):
+            with self.subTest(value=value):
+                ns = self.parse_args([f'--timeout={value}'])
+                self.assertEqual(ns.timeout, None)
+
         self.checkError(['--timeout'], 'expected one argument')
-        self.checkError(['--timeout', 'foo'], 'invalid float value')
+        self.checkError(['--timeout', 'foo'], 'invalid timeout value:')
 
     def test_wait(self):
-        ns = libregrtest._parse_args(['--wait'])
+        ns = self.parse_args(['--wait'])
         self.assertTrue(ns.wait)
 
-    def test_worker_args(self):
-        ns = libregrtest._parse_args(['--worker-args', '[[], {}]'])
-        self.assertEqual(ns.worker_args, '[[], {}]')
-        self.checkError(['--worker-args'], 'expected one argument')
-
     def test_start(self):
         for opt in '-S', '--start':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.start, 'foo')
                 self.checkError([opt], 'expected one argument')
 
     def test_verbose(self):
-        ns = libregrtest._parse_args(['-v'])
+        ns = self.parse_args(['-v'])
         self.assertEqual(ns.verbose, 1)
-        ns = libregrtest._parse_args(['-vvv'])
+        ns = self.parse_args(['-vvv'])
         self.assertEqual(ns.verbose, 3)
-        ns = libregrtest._parse_args(['--verbose'])
+        ns = self.parse_args(['--verbose'])
         self.assertEqual(ns.verbose, 1)
-        ns = libregrtest._parse_args(['--verbose'] * 3)
+        ns = self.parse_args(['--verbose'] * 3)
         self.assertEqual(ns.verbose, 3)
-        ns = libregrtest._parse_args([])
+        ns = self.parse_args([])
         self.assertEqual(ns.verbose, 0)
 
-    def test_verbose2(self):
-        for opt in '-w', '--verbose2':
+    def test_rerun(self):
+        for opt in '-w', '--rerun', '--verbose2':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
-                self.assertTrue(ns.verbose2)
+                ns = self.parse_args([opt])
+                self.assertTrue(ns.rerun)
 
     def test_verbose3(self):
         for opt in '-W', '--verbose3':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.verbose3)
 
     def test_quiet(self):
         for opt in '-q', '--quiet':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.quiet)
                 self.assertEqual(ns.verbose, 0)
 
     def test_slowest(self):
         for opt in '-o', '--slowest':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.print_slow)
 
     def test_header(self):
-        ns = libregrtest._parse_args(['--header'])
+        ns = self.parse_args(['--header'])
         self.assertTrue(ns.header)
 
-        ns = libregrtest._parse_args(['--verbose'])
+        ns = self.parse_args(['--verbose'])
         self.assertTrue(ns.header)
 
     def test_randomize(self):
-        for opt in '-r', '--randomize':
+        for opt in ('-r', '--randomize'):
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.randomize)
 
+        with os_helper.EnvironmentVarGuard() as env:
+            # with SOURCE_DATE_EPOCH
+            env['SOURCE_DATE_EPOCH'] = '1697839080'
+            ns = self.parse_args(['--randomize'])
+            regrtest = main.Regrtest(ns)
+            self.assertFalse(regrtest.randomize)
+            self.assertIsInstance(regrtest.random_seed, str)
+            self.assertEqual(regrtest.random_seed, '1697839080')
+
+            # without SOURCE_DATE_EPOCH
+            del env['SOURCE_DATE_EPOCH']
+            ns = self.parse_args(['--randomize'])
+            regrtest = main.Regrtest(ns)
+            self.assertTrue(regrtest.randomize)
+            self.assertIsInstance(regrtest.random_seed, int)
+
+    def test_no_randomize(self):
+        ns = self.parse_args([])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--randomize"])
+        self.assertIs(ns.randomize, True)
+
+        ns = self.parse_args(["--no-randomize"])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--randomize", "--no-randomize"])
+        self.assertIs(ns.randomize, False)
+
+        ns = self.parse_args(["--no-randomize", "--randomize"])
+        self.assertIs(ns.randomize, False)
+
     def test_randseed(self):
-        ns = libregrtest._parse_args(['--randseed', '12345'])
+        ns = self.parse_args(['--randseed', '12345'])
         self.assertEqual(ns.random_seed, 12345)
         self.assertTrue(ns.randomize)
         self.checkError(['--randseed'], 'expected one argument')
         self.checkError(['--randseed', 'foo'], 'invalid int value')
 
+        ns = self.parse_args(['--randseed', '12345', '--no-randomize'])
+        self.assertEqual(ns.random_seed, 12345)
+        self.assertFalse(ns.randomize)
+
     def test_fromfile(self):
         for opt in '-f', '--fromfile':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.fromfile, 'foo')
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo', '-s'], "don't go together")
@@ -148,46 +217,37 @@ def test_fromfile(self):
     def test_exclude(self):
         for opt in '-x', '--exclude':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.exclude)
 
     def test_single(self):
         for opt in '-s', '--single':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.single)
                 self.checkError([opt, '-f', 'foo'], "don't go together")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_ignore(self):
-        for opt in '-i', '--ignore':
+    def test_match(self):
+        for opt in '-m', '--match':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'pattern'])
-                self.assertEqual(ns.ignore_tests, ['pattern'])
+                ns = self.parse_args([opt, 'pattern'])
+                self.assertEqual(ns.match_tests, [('pattern', True)])
                 self.checkError([opt], 'expected one argument')
 
-        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
-        with open(os_helper.TESTFN, "w") as fp:
-            print('matchfile1', file=fp)
-            print('matchfile2', file=fp)
-
-        filename = os.path.abspath(os_helper.TESTFN)
-        ns = libregrtest._parse_args(['-m', 'match',
-                                      '--ignorefile', filename])
-        self.assertEqual(ns.ignore_tests,
-                         ['matchfile1', 'matchfile2'])
-
-    def test_match(self):
-        for opt in '-m', '--match':
+        for opt in '-i', '--ignore':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'pattern'])
-                self.assertEqual(ns.match_tests, ['pattern'])
+                ns = self.parse_args([opt, 'pattern'])
+                self.assertEqual(ns.match_tests, [('pattern', False)])
                 self.checkError([opt], 'expected one argument')
 
-        ns = libregrtest._parse_args(['-m', 'pattern1',
-                                      '-m', 'pattern2'])
-        self.assertEqual(ns.match_tests, ['pattern1', 'pattern2'])
+        ns = self.parse_args(['-m', 'pattern1', '-m', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', True), ('pattern2', True)])
+
+        ns = self.parse_args(['-m', 'pattern1', '-i', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', True), ('pattern2', False)])
+
+        ns = self.parse_args(['-i', 'pattern1', '-m', 'pattern2'])
+        self.assertEqual(ns.match_tests, [('pattern1', False), ('pattern2', True)])
 
         self.addCleanup(os_helper.unlink, os_helper.TESTFN)
         with open(os_helper.TESTFN, "w") as fp:
@@ -195,73 +255,76 @@ def test_match(self):
             print('matchfile2', file=fp)
 
         filename = os.path.abspath(os_helper.TESTFN)
-        ns = libregrtest._parse_args(['-m', 'match',
-                                      '--matchfile', filename])
+        ns = self.parse_args(['-m', 'match', '--matchfile', filename])
+        self.assertEqual(ns.match_tests,
+                         [('match', True), ('matchfile1', True), ('matchfile2', True)])
+
+        ns = self.parse_args(['-i', 'match', '--ignorefile', filename])
         self.assertEqual(ns.match_tests,
-                         ['match', 'matchfile1', 'matchfile2'])
+                         [('match', False), ('matchfile1', False), ('matchfile2', False)])
 
     def test_failfast(self):
         for opt in '-G', '--failfast':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '-v'])
+                ns = self.parse_args([opt, '-v'])
                 self.assertTrue(ns.failfast)
-                ns = libregrtest._parse_args([opt, '-W'])
+                ns = self.parse_args([opt, '-W'])
                 self.assertTrue(ns.failfast)
                 self.checkError([opt], '-G/--failfast needs either -v or -W')
 
     def test_use(self):
         for opt in '-u', '--use':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'gui,network'])
+                ns = self.parse_args([opt, 'gui,network'])
                 self.assertEqual(ns.use_resources, ['gui', 'network'])
 
-                ns = libregrtest._parse_args([opt, 'gui,none,network'])
+                ns = self.parse_args([opt, 'gui,none,network'])
                 self.assertEqual(ns.use_resources, ['network'])
 
-                expected = list(libregrtest.ALL_RESOURCES)
+                expected = list(cmdline.ALL_RESOURCES)
                 expected.remove('gui')
-                ns = libregrtest._parse_args([opt, 'all,-gui'])
+                ns = self.parse_args([opt, 'all,-gui'])
                 self.assertEqual(ns.use_resources, expected)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid resource')
 
                 # all + a resource not part of "all"
-                ns = libregrtest._parse_args([opt, 'all,tzdata'])
+                ns = self.parse_args([opt, 'all,tzdata'])
                 self.assertEqual(ns.use_resources,
-                                 list(libregrtest.ALL_RESOURCES) + ['tzdata'])
+                                 list(cmdline.ALL_RESOURCES) + ['tzdata'])
 
                 # test another resource which is not part of "all"
-                ns = libregrtest._parse_args([opt, 'extralargefile'])
+                ns = self.parse_args([opt, 'extralargefile'])
                 self.assertEqual(ns.use_resources, ['extralargefile'])
 
     def test_memlimit(self):
         for opt in '-M', '--memlimit':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '4G'])
+                ns = self.parse_args([opt, '4G'])
                 self.assertEqual(ns.memlimit, '4G')
                 self.checkError([opt], 'expected one argument')
 
     def test_testdir(self):
-        ns = libregrtest._parse_args(['--testdir', 'foo'])
+        ns = self.parse_args(['--testdir', 'foo'])
         self.assertEqual(ns.testdir, os.path.join(os_helper.SAVEDCWD, 'foo'))
         self.checkError(['--testdir'], 'expected one argument')
 
     def test_runleaks(self):
         for opt in '-L', '--runleaks':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.runleaks)
 
     def test_huntrleaks(self):
         for opt in '-R', '--huntrleaks':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, ':'])
+                ns = self.parse_args([opt, ':'])
                 self.assertEqual(ns.huntrleaks, (5, 4, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, '6:'])
+                ns = self.parse_args([opt, '6:'])
                 self.assertEqual(ns.huntrleaks, (6, 4, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, ':3'])
+                ns = self.parse_args([opt, ':3'])
                 self.assertEqual(ns.huntrleaks, (5, 3, 'reflog.txt'))
-                ns = libregrtest._parse_args([opt, '6:3:leaks.log'])
+                ns = self.parse_args([opt, '6:3:leaks.log'])
                 self.assertEqual(ns.huntrleaks, (6, 3, 'leaks.log'))
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, '6'],
@@ -272,23 +335,33 @@ def test_huntrleaks(self):
     def test_multiprocess(self):
         for opt in '-j', '--multiprocess':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '2'])
+                ns = self.parse_args([opt, '2'])
                 self.assertEqual(ns.use_mp, 2)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
-                self.checkError([opt, '2', '-T'], "don't go together")
-                self.checkError([opt, '0', '-T'], "don't go together")
 
-    def test_coverage(self):
+    def test_coverage_sequential(self):
+        for opt in '-T', '--coverage':
+            with self.subTest(opt=opt):
+                with support.captured_stderr() as stderr:
+                    ns = self.parse_args([opt])
+                self.assertTrue(ns.trace)
+                self.assertIn(
+                    "collecting coverage without -j is imprecise",
+                    stderr.getvalue(),
+                )
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def test_coverage_mp(self):
         for opt in '-T', '--coverage':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt, '-j1'])
                 self.assertTrue(ns.trace)
 
     def test_coverdir(self):
         for opt in '-D', '--coverdir':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, 'foo'])
+                ns = self.parse_args([opt, 'foo'])
                 self.assertEqual(ns.coverdir,
                                  os.path.join(os_helper.SAVEDCWD, 'foo'))
                 self.checkError([opt], 'expected one argument')
@@ -296,13 +369,13 @@ def test_coverdir(self):
     def test_nocoverdir(self):
         for opt in '-N', '--nocoverdir':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertIsNone(ns.coverdir)
 
     def test_threshold(self):
         for opt in '-t', '--threshold':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt, '1000'])
+                ns = self.parse_args([opt, '1000'])
                 self.assertEqual(ns.threshold, 1000)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
@@ -311,7 +384,7 @@ def test_nowindows(self):
         for opt in '-n', '--nowindows':
             with self.subTest(opt=opt):
                 with contextlib.redirect_stderr(io.StringIO()) as stderr:
-                    ns = libregrtest._parse_args([opt])
+                    ns = self.parse_args([opt])
                 self.assertTrue(ns.nowindows)
                 err = stderr.getvalue()
                 self.assertIn('the --nowindows (-n) option is deprecated', err)
@@ -319,39 +392,39 @@ def test_nowindows(self):
     def test_forever(self):
         for opt in '-F', '--forever':
             with self.subTest(opt=opt):
-                ns = libregrtest._parse_args([opt])
+                ns = self.parse_args([opt])
                 self.assertTrue(ns.forever)
 
     def test_unrecognized_argument(self):
         self.checkError(['--xxx'], 'usage:')
 
     def test_long_option__partial(self):
-        ns = libregrtest._parse_args(['--qui'])
+        ns = self.parse_args(['--qui'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
 
     def test_two_options(self):
-        ns = libregrtest._parse_args(['--quiet', '--exclude'])
+        ns = self.parse_args(['--quiet', '--exclude'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertTrue(ns.exclude)
 
     def test_option_with_empty_string_value(self):
-        ns = libregrtest._parse_args(['--start', ''])
+        ns = self.parse_args(['--start', ''])
         self.assertEqual(ns.start, '')
 
     def test_arg(self):
-        ns = libregrtest._parse_args(['foo'])
+        ns = self.parse_args(['foo'])
         self.assertEqual(ns.args, ['foo'])
 
     def test_option_and_arg(self):
-        ns = libregrtest._parse_args(['--quiet', 'foo'])
+        ns = self.parse_args(['--quiet', 'foo'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertEqual(ns.args, ['foo'])
 
     def test_arg_option_arg(self):
-        ns = libregrtest._parse_args(['test_unaryop', '-v', 'test_binop'])
+        ns = self.parse_args(['test_unaryop', '-v', 'test_binop'])
         self.assertEqual(ns.verbose, 1)
         self.assertEqual(ns.args, ['test_unaryop', 'test_binop'])
 
@@ -359,6 +432,118 @@ def test_unknown_option(self):
         self.checkError(['--unknown-option'],
                         'unrecognized arguments: --unknown-option')
 
+    def create_regrtest(self, args):
+        ns = cmdline._parse_args(args)
+
+        # Check Regrtest attributes which are more reliable than Namespace
+        # which has an unclear API
+        with os_helper.EnvironmentVarGuard() as env:
+            # Ignore SOURCE_DATE_EPOCH env var if it's set
+            del env['SOURCE_DATE_EPOCH']
+
+            regrtest = main.Regrtest(ns)
+
+        return regrtest
+
+    def check_ci_mode(self, args, use_resources,
+                      *, rerun=True, randomize=True, output_on_failure=True):
+        regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, -1)
+        self.assertEqual(regrtest.want_rerun, rerun)
+        self.assertEqual(regrtest.fail_rerun, False)
+        self.assertEqual(regrtest.randomize, randomize)
+        self.assertIsInstance(regrtest.random_seed, int)
+        self.assertTrue(regrtest.fail_env_changed)
+        self.assertTrue(regrtest.print_slowest)
+        self.assertEqual(regrtest.output_on_failure, output_on_failure)
+        self.assertEqual(sorted(regrtest.use_resources), sorted(use_resources))
+        return regrtest
+
+    def test_fast_ci(self):
+        args = ['--fast-ci']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources)
+        self.assertEqual(regrtest.timeout, 10 * 60)
+
+    def test_fast_ci_python_cmd(self):
+        args = ['--fast-ci', '--python', 'python -X dev']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources, rerun=False)
+        self.assertEqual(regrtest.timeout, 10 * 60)
+        self.assertEqual(regrtest.python_cmd, ('python', '-X', 'dev'))
+
+    def test_fast_ci_resource(self):
+        # it should be possible to override resources individually
+        args = ['--fast-ci', '-u-network']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        use_resources.remove('network')
+        self.check_ci_mode(args, use_resources)
+
+    def test_fast_ci_verbose(self):
+        args = ['--fast-ci', '--verbose']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        use_resources.remove('cpu')
+        regrtest = self.check_ci_mode(args, use_resources,
+                                      output_on_failure=False)
+        self.assertEqual(regrtest.verbose, True)
+
+    def test_slow_ci(self):
+        args = ['--slow-ci']
+        use_resources = sorted(cmdline.ALL_RESOURCES)
+        regrtest = self.check_ci_mode(args, use_resources)
+        self.assertEqual(regrtest.timeout, 20 * 60)
+
+    def test_ci_no_randomize(self):
+        all_resources = set(cmdline.ALL_RESOURCES)
+        self.check_ci_mode(
+            ["--slow-ci", "--no-randomize"], all_resources, randomize=False
+        )
+        self.check_ci_mode(
+            ["--fast-ci", "--no-randomize"], all_resources - {'cpu'}, randomize=False
+        )
+
+    def test_dont_add_python_opts(self):
+        args = ['--dont-add-python-opts']
+        ns = cmdline._parse_args(args)
+        self.assertFalse(ns._add_python_opts)
+
+    def test_bisect(self):
+        args = ['--bisect']
+        regrtest = self.create_regrtest(args)
+        self.assertTrue(regrtest.want_bisect)
+
+    def test_verbose3_huntrleaks(self):
+        args = ['-R', '3:10', '--verbose3']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertIsNotNone(regrtest.hunt_refleak)
+        self.assertEqual(regrtest.hunt_refleak.warmups, 3)
+        self.assertEqual(regrtest.hunt_refleak.runs, 10)
+        self.assertFalse(regrtest.output_on_failure)
+
+    def test_single_process(self):
+        args = ['-j2', '--single-process']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, 0)
+        self.assertTrue(regrtest.single_process)
+
+        args = ['--fast-ci', '--single-process']
+        with support.captured_stderr():
+            regrtest = self.create_regrtest(args)
+        self.assertEqual(regrtest.num_workers, 0)
+        self.assertTrue(regrtest.single_process)
+
+
+@dataclasses.dataclass(slots=True)
+class Rerun:
+    name: str
+    match: str | None
+    success: bool
+
 
 class BaseTestCase(unittest.TestCase):
     TEST_UNIQUE_ID = 1
@@ -407,41 +592,61 @@ def regex_search(self, regex, output):
             self.fail("%r not found in %r" % (regex, output))
         return match
 
-    def check_line(self, output, regex):
-        regex = re.compile(r'^' + regex, re.MULTILINE)
+    def check_line(self, output, pattern, full=False, regex=True):
+        if not regex:
+            pattern = re.escape(pattern)
+        if full:
+            pattern += '\n'
+        regex = re.compile(r'^' + pattern, re.MULTILINE)
         self.assertRegex(output, regex)
 
     def parse_executed_tests(self, output):
-        regex = (r'^%s\[ *[0-9]+(?:/ *[0-9]+)*\] (%s)'
-                 % (LOG_PREFIX, self.TESTNAME_REGEX))
+        regex = (fr'^{LOG_PREFIX}\[ *[0-9]+(?:/ *[0-9]+)*\] '
+                 fr'({self.TESTNAME_REGEX}) {RESULT_REGEX}')
         parser = re.finditer(regex, output, re.MULTILINE)
         return list(match.group(1) for match in parser)
 
-    def check_executed_tests(self, output, tests, skipped=(), failed=(),
+    def check_executed_tests(self, output, tests, *, stats,
+                             skipped=(), failed=(),
                              env_changed=(), omitted=(),
-                             rerun=(), no_test_ran=(),
-                             randomize=False, interrupted=False,
-                             fail_env_changed=False):
+                             rerun=None, run_no_tests=(),
+                             resource_denied=(),
+                             randomize=False, parallel=False, interrupted=False,
+                             fail_env_changed=False,
+                             forever=False, filtered=False):
         if isinstance(tests, str):
             tests = [tests]
         if isinstance(skipped, str):
             skipped = [skipped]
+        if isinstance(resource_denied, str):
+            resource_denied = [resource_denied]
         if isinstance(failed, str):
             failed = [failed]
         if isinstance(env_changed, str):
             env_changed = [env_changed]
         if isinstance(omitted, str):
             omitted = [omitted]
-        if isinstance(rerun, str):
-            rerun = [rerun]
-        if isinstance(no_test_ran, str):
-            no_test_ran = [no_test_ran]
+        if isinstance(run_no_tests, str):
+            run_no_tests = [run_no_tests]
+        if isinstance(stats, int):
+            stats = TestStats(stats)
+        if parallel:
+            randomize = True
+
+        rerun_failed = []
+        if rerun is not None and not env_changed:
+            failed = [rerun.name]
+            if not rerun.success:
+                rerun_failed.append(rerun.name)
 
         executed = self.parse_executed_tests(output)
+        total_tests = list(tests)
+        if rerun is not None:
+            total_tests.append(rerun.name)
         if randomize:
-            self.assertEqual(set(executed), set(tests), output)
+            self.assertEqual(set(executed), set(total_tests), output)
         else:
-            self.assertEqual(executed, tests, output)
+            self.assertEqual(executed, total_tests, output)
 
         def plural(count):
             return 's' if count != 1 else ''
@@ -457,12 +662,17 @@ def list_regex(line_format, tests):
             regex = list_regex('%s test%s skipped', skipped)
             self.check_line(output, regex)
 
+        if resource_denied:
+            regex = list_regex(r'%s test%s skipped \(resource denied\)', resource_denied)
+            self.check_line(output, regex)
+
         if failed:
             regex = list_regex('%s test%s failed', failed)
             self.check_line(output, regex)
 
         if env_changed:
-            regex = list_regex('%s test%s altered the execution environment',
+            regex = list_regex(r'%s test%s altered the execution environment '
+                               r'\(env changed\)',
                                env_changed)
             self.check_line(output, regex)
 
@@ -470,73 +680,120 @@ def list_regex(line_format, tests):
             regex = list_regex('%s test%s omitted', omitted)
             self.check_line(output, regex)
 
-        if rerun:
-            regex = list_regex('%s re-run test%s', rerun)
+        if rerun is not None:
+            regex = list_regex('%s re-run test%s', [rerun.name])
             self.check_line(output, regex)
-            regex = LOG_PREFIX + r"Re-running failed tests in verbose mode"
+            regex = LOG_PREFIX + r"Re-running 1 failed tests in verbose mode"
+            self.check_line(output, regex)
+            regex = fr"Re-running {rerun.name} in verbose mode"
+            if rerun.match:
+                regex = fr"{regex} \(matching: {rerun.match}\)"
             self.check_line(output, regex)
-            for test_name in rerun:
-                regex = LOG_PREFIX + f"Re-running {test_name} in verbose mode"
-                self.check_line(output, regex)
 
-        if no_test_ran:
-            regex = list_regex('%s test%s run no tests', no_test_ran)
+        if run_no_tests:
+            regex = list_regex('%s test%s run no tests', run_no_tests)
             self.check_line(output, regex)
 
-        good = (len(tests) - len(skipped) - len(failed)
-                - len(omitted) - len(env_changed) - len(no_test_ran))
+        good = (len(tests) - len(skipped) - len(resource_denied) - len(failed)
+                - len(omitted) - len(env_changed) - len(run_no_tests))
         if good:
-            regex = r'%s test%s OK\.$' % (good, plural(good))
-            if not skipped and not failed and good > 1:
+            regex = r'%s test%s OK\.' % (good, plural(good))
+            if not skipped and not failed and (rerun is None or rerun.success) and good > 1:
                 regex = 'All %s' % regex
-            self.check_line(output, regex)
+            self.check_line(output, regex, full=True)
 
         if interrupted:
             self.check_line(output, 'Test suite interrupted by signal SIGINT.')
 
-        result = []
+        # Total tests
+        text = f'run={stats.tests_run:,}'
+        if filtered:
+            text = fr'{text} \(filtered\)'
+        parts = [text]
+        if stats.failures:
+            parts.append(f'failures={stats.failures:,}')
+        if stats.skipped:
+            parts.append(f'skipped={stats.skipped:,}')
+        line = fr'Total tests: {" ".join(parts)}'
+        self.check_line(output, line, full=True)
+
+        # Total test files
+        run = len(total_tests) - len(resource_denied)
+        if rerun is not None:
+            total_failed = len(rerun_failed)
+            total_rerun = 1
+        else:
+            total_failed = len(failed)
+            total_rerun = 0
+        if interrupted:
+            run = 0
+        text = f'run={run}'
+        if not forever:
+            text = f'{text}/{len(tests)}'
+        if filtered:
+            text = fr'{text} \(filtered\)'
+        report = [text]
+        for name, ntest in (
+            ('failed', total_failed),
+            ('env_changed', len(env_changed)),
+            ('skipped', len(skipped)),
+            ('resource_denied', len(resource_denied)),
+            ('rerun', total_rerun),
+            ('run_no_tests', len(run_no_tests)),
+        ):
+            if ntest:
+                report.append(f'{name}={ntest}')
+        line = fr'Total test files: {" ".join(report)}'
+        self.check_line(output, line, full=True)
+
+        # Result
+        state = []
         if failed:
-            result.append('FAILURE')
+            state.append('FAILURE')
         elif fail_env_changed and env_changed:
-            result.append('ENV CHANGED')
+            state.append('ENV CHANGED')
         if interrupted:
-            result.append('INTERRUPTED')
-        if not any((good, result, failed, interrupted, skipped,
+            state.append('INTERRUPTED')
+        if not any((good, failed, interrupted, skipped,
                     env_changed, fail_env_changed)):
-            result.append("NO TEST RUN")
-        elif not result:
-            result.append('SUCCESS')
-        result = ', '.join(result)
-        if rerun:
-            self.check_line(output, 'Tests result: FAILURE')
-            result = 'FAILURE then %s' % result
-
-        self.check_line(output, 'Tests result: %s' % result)
-
-    def parse_random_seed(self, output):
-        match = self.regex_search(r'Using random seed ([0-9]+)', output)
-        randseed = int(match.group(1))
-        self.assertTrue(0 <= randseed <= 10000000, randseed)
-        return randseed
+            state.append("NO TESTS RAN")
+        elif not state:
+            state.append('SUCCESS')
+        state = ', '.join(state)
+        if rerun is not None:
+            new_state = 'SUCCESS' if rerun.success else 'FAILURE'
+            state = f'{state} then {new_state}'
+        self.check_line(output, f'Result: {state}', full=True)
+
+    def parse_random_seed(self, output: str) -> str:
+        match = self.regex_search(r'Using random seed: (.*)', output)
+        return match.group(1)
 
     def run_command(self, args, input=None, exitcode=0, **kw):
         if not input:
             input = ''
         if 'stderr' not in kw:
-            kw['stderr'] = subprocess.PIPE
+            kw['stderr'] = subprocess.STDOUT
+
+        env = kw.pop('env', None)
+        if env is None:
+            env = dict(os.environ)
+            env.pop('SOURCE_DATE_EPOCH', None)
+
         proc = subprocess.run(args,
-                              universal_newlines=True,
+                              text=True,
                               input=input,
                               stdout=subprocess.PIPE,
+                              env=env,
                               **kw)
         if proc.returncode != exitcode:
-            msg = ("Command %s failed with exit code %s\n"
+            msg = ("Command %s failed with exit code %s, but exit code %s expected!\n"
                    "\n"
                    "stdout:\n"
                    "---\n"
                    "%s\n"
                    "---\n"
-                   % (str(args), proc.returncode, proc.stdout))
+                   % (str(args), proc.returncode, exitcode, proc.stdout))
             if proc.stderr:
                 msg += ("\n"
                         "stderr:\n"
@@ -547,18 +804,25 @@ def run_command(self, args, input=None, exitcode=0, **kw):
             self.fail(msg)
         return proc
 
-    def run_python(self, args, **kw):
-        args = [sys.executable, '-X', 'faulthandler', '-I', *args]
-        proc = self.run_command(args, **kw)
+    def run_python(self, args, isolated=True, **kw):
+        extraargs = []
+        if 'uops' in sys._xoptions:
+            # Pass -X uops along
+            extraargs.extend(['-X', 'uops'])
+        cmd = [sys.executable, *extraargs, '-X', 'faulthandler']
+        if isolated:
+            cmd.append('-I')
+        cmd.extend(args)
+        proc = self.run_command(cmd, **kw)
         return proc.stdout
 
 
 class CheckActualTests(BaseTestCase):
-    """
-    Check that regrtest appears to find the expected set of tests.
-    """
-
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_finds_expected_number_of_tests(self):
+        """
+        Check that regrtest appears to find the expected set of tests.
+        """
         args = ['-Wd', '-E', '-bb', '-m', 'test.regrtest', '--list-tests']
         output = self.run_python(args)
         rough_number_of_tests_found = len(output.splitlines())
@@ -578,6 +842,7 @@ def test_finds_expected_number_of_tests(self):
                            f'{", ".join(output.splitlines())}')
 
 
+@support.force_not_colorized_test_class
 class ProgramsTestCase(BaseTestCase):
     """
     Test various ways to run the Python test suite. Use options close
@@ -595,19 +860,22 @@ def setUp(self):
         self.python_args = ['-Wd', '-E', '-bb']
         self.regrtest_args = ['-uall', '-rwW',
                               '--testdir=%s' % self.tmptestdir]
-        if hasattr(faulthandler, 'dump_traceback_later'):
-            self.regrtest_args.extend(('--timeout', '3600', '-j4'))
+        self.regrtest_args.extend(('--timeout', '3600', '-j4'))
         if sys.platform == 'win32':
             self.regrtest_args.append('-n')
 
     def check_output(self, output):
-        self.parse_random_seed(output)
-        self.check_executed_tests(output, self.tests, randomize=True)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
 
-    def run_tests(self, args):
-        output = self.run_python(args)
+        self.check_executed_tests(output, self.tests,
+                                  randomize=True, stats=len(self.tests))
+
+    def run_tests(self, args, env=None, isolated=True):
+        output = self.run_python(args, env=env, isolated=isolated)
         self.check_output(output)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_script_regrtest(self):
         # Lib/test/regrtest.py
         script = os.path.join(self.testdir, 'regrtest.py')
@@ -615,28 +883,28 @@ def test_script_regrtest(self):
         args = [*self.python_args, script, *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_test(self):
         # -m test
         args = [*self.python_args, '-m', 'test',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_module_regrtest(self):
         # -m test.regrtest
         args = [*self.python_args, '-m', 'test.regrtest',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_autotest(self):
         # -m test.autotest
         args = [*self.python_args, '-m', 'test.autotest',
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_module_from_test_autotest(self):
         # from test import autotest
         code = 'from test import autotest'
@@ -644,24 +912,18 @@ def test_module_from_test_autotest(self):
                 *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip('TODO: RUSTPYTHON flaky')
     def test_script_autotest(self):
         # Lib/test/autotest.py
         script = os.path.join(self.testdir, 'autotest.py')
         args = [*self.python_args, script, *self.regrtest_args, *self.tests]
         self.run_tests(args)
 
-    @unittest.skipUnless(sysconfig.is_python_build(),
-                         'run_tests.py script is not installed')
-    def test_tools_script_run_tests(self):
-        # Tools/scripts/run_tests.py
-        script = os.path.join(ROOT_DIR, 'Tools', 'scripts', 'run_tests.py')
-        args = [script, *self.regrtest_args, *self.tests]
-        self.run_tests(args)
-
     def run_batch(self, *args):
-        proc = self.run_command(args)
+        proc = self.run_command(args,
+                                # gh-133711: cmd.exe uses the OEM code page
+                                # to display the non-ASCII current directory
+                                errors="backslashreplace")
         self.check_output(proc.stdout)
 
     @unittest.skipUnless(sysconfig.is_python_build(),
@@ -673,10 +935,14 @@ def test_tools_buildbot_test(self):
         test_args = ['--testdir=%s' % self.tmptestdir]
         if platform.machine() == 'ARM64':
             test_args.append('-arm64') # ARM 64-bit build
+        elif platform.machine() == 'ARM':
+            test_args.append('-arm32')   # 32-bit ARM build
         elif platform.architecture()[0] == '64bit':
             test_args.append('-x64')   # 64-bit build
-        if not Py_DEBUG:
+        if not support.Py_DEBUG:
             test_args.append('+d')     # Release build, use python.exe
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            test_args.append('--disable-gil')
         self.run_batch(script, *test_args, *self.tests)
 
     @unittest.skipUnless(sys.platform == 'win32', 'Windows only')
@@ -688,13 +954,18 @@ def test_pcbuild_rt(self):
         rt_args = ["-q"]             # Quick, don't run tests twice
         if platform.machine() == 'ARM64':
             rt_args.append('-arm64') # ARM 64-bit build
+        elif platform.machine() == 'ARM':
+            rt_args.append('-arm32')   # 32-bit ARM build
         elif platform.architecture()[0] == '64bit':
             rt_args.append('-x64')   # 64-bit build
-        if Py_DEBUG:
+        if support.Py_DEBUG:
             rt_args.append('-d')     # Debug build, use python_d.exe
+        if sysconfig.get_config_var("Py_GIL_DISABLED"):
+            rt_args.append('--disable-gil')
         self.run_batch(script, *rt_args, *self.regrtest_args, *self.tests)
 
 
+@support.force_not_colorized_test_class
 class ArgsTestCase(BaseTestCase):
     """
     Test arguments of the Python test suite.
@@ -704,6 +975,40 @@ def run_tests(self, *testargs, **kw):
         cmdargs = ['-m', 'test', '--testdir=%s' % self.tmptestdir, *testargs]
         return self.run_python(cmdargs, **kw)
 
+    def test_success(self):
+        code = textwrap.dedent("""
+            import unittest
+
+            class PassingTests(unittest.TestCase):
+                def test_test1(self):
+                    pass
+
+                def test_test2(self):
+                    pass
+
+                def test_test3(self):
+                    pass
+        """)
+        tests = [self.create_test(f'ok{i}', code=code) for i in range(1, 6)]
+
+        output = self.run_tests(*tests)
+        self.check_executed_tests(output, tests,
+                                  stats=3 * len(tests))
+
+    def test_skip(self):
+        code = textwrap.dedent("""
+            import unittest
+            raise unittest.SkipTest("nope")
+        """)
+        test_ok = self.create_test('ok')
+        test_skip = self.create_test('skip', code=code)
+        tests = [test_ok, test_skip]
+
+        output = self.run_tests(*tests)
+        self.check_executed_tests(output, tests,
+                                  skipped=[test_skip],
+                                  stats=1)
+
     def test_failing_test(self):
         # test a failing test
         code = textwrap.dedent("""
@@ -717,8 +1022,9 @@ def test_failing(self):
         test_failing = self.create_test('failing', code=code)
         tests = [test_ok, test_failing]
 
-        output = self.run_tests(*tests, exitcode=2)
-        self.check_executed_tests(output, tests, failed=test_failing)
+        output = self.run_tests(*tests, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, tests, failed=test_failing,
+                                  stats=TestStats(2, 1))
 
     def test_resources(self):
         # test -u command line option
@@ -737,17 +1043,19 @@ def test_pass(self):
 
         # -u all: 2 resources enabled
         output = self.run_tests('-u', 'all', *test_names)
-        self.check_executed_tests(output, test_names)
+        self.check_executed_tests(output, test_names, stats=2)
 
         # -u audio: 1 resource enabled
         output = self.run_tests('-uaudio', *test_names)
         self.check_executed_tests(output, test_names,
-                                  skipped=tests['network'])
+                                  resource_denied=tests['network'],
+                                  stats=1)
 
         # no option: 0 resources enabled
-        output = self.run_tests(*test_names)
+        output = self.run_tests(*test_names, exitcode=EXITCODE_NO_TESTS_RAN)
         self.check_executed_tests(output, test_names,
-                                  skipped=test_names)
+                                  resource_denied=test_names,
+                                  stats=0)
 
     def test_random(self):
         # test -r and --randseed command line option
@@ -758,13 +1066,14 @@ def test_random(self):
         test = self.create_test('random', code)
 
         # first run to get the output with the random seed
-        output = self.run_tests('-r', test)
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN)
         randseed = self.parse_random_seed(output)
         match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
         test_random = int(match.group(1))
 
         # try to reproduce with the random seed
-        output = self.run_tests('-r', '--randseed=%s' % randseed, test)
+        output = self.run_tests('-r', f'--randseed={randseed}', test,
+                                exitcode=EXITCODE_NO_TESTS_RAN)
         randseed2 = self.parse_random_seed(output)
         self.assertEqual(randseed2, randseed)
 
@@ -772,6 +1081,35 @@ def test_random(self):
         test_random2 = int(match.group(1))
         self.assertEqual(test_random2, test_random)
 
+        # check that random.seed is used by default
+        output = self.run_tests(test, exitcode=EXITCODE_NO_TESTS_RAN)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
+
+        # check SOURCE_DATE_EPOCH (integer)
+        timestamp = '1697839080'
+        env = dict(os.environ, SOURCE_DATE_EPOCH=timestamp)
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertEqual(randseed, timestamp)
+        self.check_line(output, 'TESTRANDOM: 520')
+
+        # check SOURCE_DATE_EPOCH (string)
+        env = dict(os.environ, SOURCE_DATE_EPOCH='XYZ')
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertEqual(randseed, 'XYZ')
+        self.check_line(output, 'TESTRANDOM: 22')
+
+        # check SOURCE_DATE_EPOCH (empty string): ignore the env var
+        env = dict(os.environ, SOURCE_DATE_EPOCH='')
+        output = self.run_tests('-r', test, exitcode=EXITCODE_NO_TESTS_RAN,
+                                env=env)
+        randseed = self.parse_random_seed(output)
+        self.assertTrue(randseed.isdigit(), randseed)
+
     def test_fromfile(self):
         # test --fromfile
         tests = [self.create_test() for index in range(5)]
@@ -794,7 +1132,8 @@ def test_fromfile(self):
                 previous = name
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        stats = len(tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format '[2/7] test_opcodes'
         with open(filename, "w") as fp:
@@ -802,7 +1141,7 @@ def test_fromfile(self):
                 print("[%s/%s] %s" % (index, len(tests), name), file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format 'test_opcodes'
         with open(filename, "w") as fp:
@@ -810,7 +1149,7 @@ def test_fromfile(self):
                 print(name, file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
         # test format 'Lib/test/test_opcodes.py'
         with open(filename, "w") as fp:
@@ -818,29 +1157,25 @@ def test_fromfile(self):
                 print('Lib/test/%s.py' % name, file=fp)
 
         output = self.run_tests('--fromfile', filename)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=stats)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_interrupted(self):
         code = TEST_INTERRUPTED
         test = self.create_test('sigint', code=code)
-        output = self.run_tests(test, exitcode=130)
+        output = self.run_tests(test, exitcode=EXITCODE_INTERRUPTED)
         self.check_executed_tests(output, test, omitted=test,
-                                  interrupted=True)
+                                  interrupted=True, stats=0)
 
     def test_slowest(self):
         # test --slowest
         tests = [self.create_test() for index in range(3)]
         output = self.run_tests("--slowest", *tests)
-        self.check_executed_tests(output, tests)
+        self.check_executed_tests(output, tests, stats=len(tests))
         regex = ('10 slowest tests:\n'
                  '(?:- %s: .*\n){%s}'
                  % (self.TESTNAME_REGEX, len(tests)))
         self.check_line(output, regex)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slowest_interrupted(self):
         # Issue #25373: test --slowest with an interrupted test
         code = TEST_INTERRUPTED
@@ -852,20 +1187,20 @@ def test_slowest_interrupted(self):
                     args = ("--slowest", "-j2", test)
                 else:
                     args = ("--slowest", test)
-                output = self.run_tests(*args, exitcode=130)
+                output = self.run_tests(*args, exitcode=EXITCODE_INTERRUPTED)
                 self.check_executed_tests(output, test,
-                                          omitted=test, interrupted=True)
+                                          omitted=test, interrupted=True,
+                                          stats=0)
 
                 regex = ('10 slowest tests:\n')
                 self.check_line(output, regex)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_coverage(self):
         # test --coverage
         test = self.create_test('coverage')
         output = self.run_tests("--coverage", test)
-        self.check_executed_tests(output, [test])
+        self.check_executed_tests(output, [test], stats=1)
         regex = (r'lines +cov% +module +\(path\)\n'
                  r'(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+')
         self.check_line(output, regex)
@@ -894,21 +1229,39 @@ def test_run(self):
                         builtins.__dict__['RUN'] = 1
         """)
         test = self.create_test('forever', code=code)
-        output = self.run_tests('--forever', test, exitcode=2)
-        self.check_executed_tests(output, [test]*3, failed=test)
 
-    def check_leak(self, code, what):
+        # --forever
+        output = self.run_tests('--forever', test, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, [test]*3, failed=test,
+                                  stats=TestStats(3, 1),
+                                  forever=True)
+
+        # --forever --rerun
+        output = self.run_tests('--forever', '--rerun', test, exitcode=0)
+        self.check_executed_tests(output, [test]*3,
+                                  rerun=Rerun(test,
+                                              match='test_run',
+                                              success=True),
+                                  stats=TestStats(4, 1),
+                                  forever=True)
+
+    @without_optimizer
+    def check_leak(self, code, what, *, run_workers=False):
         test = self.create_test('huntrleaks', code=code)
 
         filename = 'reflog.txt'
         self.addCleanup(os_helper.unlink, filename)
-        output = self.run_tests('--huntrleaks', '3:3:', test,
-                                exitcode=2,
+        cmd = ['--huntrleaks', '3:3:']
+        if run_workers:
+            cmd.append('-j1')
+        cmd.append(test)
+        output = self.run_tests(*cmd,
+                                exitcode=EXITCODE_BAD_TEST,
                                 stderr=subprocess.STDOUT)
-        self.check_executed_tests(output, [test], failed=test)
+        self.check_executed_tests(output, [test], failed=test, stats=1)
 
-        line = 'beginning 6 repetitions\n123456\n......\n'
-        self.check_line(output, re.escape(line))
+        line = r'beginning 6 repetitions. .*\n123:456\n[.0-9X]{3} 111\n'
+        self.check_line(output, line)
 
         line2 = '%s leaked [1, 1, 1] %s, sum=3\n' % (test, what)
         self.assertIn(line2, output)
@@ -917,8 +1270,8 @@ def check_leak(self, code, what):
             reflog = fp.read()
             self.assertIn(line2, reflog)
 
-    @unittest.skipUnless(Py_DEBUG, 'need a debug build')
-    def test_huntrleaks(self):
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def check_huntrleaks(self, *, run_workers: bool):
         # test --huntrleaks
         code = textwrap.dedent("""
             import unittest
@@ -929,9 +1282,56 @@ class RefLeakTest(unittest.TestCase):
                 def test_leak(self):
                     GLOBAL_LIST.append(object())
         """)
-        self.check_leak(code, 'references')
+        self.check_leak(code, 'references', run_workers=run_workers)
+
+    def test_huntrleaks(self):
+        self.check_huntrleaks(run_workers=False)
+
+    def test_huntrleaks_mp(self):
+        self.check_huntrleaks(run_workers=True)
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
+    def test_huntrleaks_bisect(self):
+        # test --huntrleaks --bisect
+        code = textwrap.dedent("""
+            import unittest
+
+            GLOBAL_LIST = []
+
+            class RefLeakTest(unittest.TestCase):
+                def test1(self):
+                    pass
+
+                def test2(self):
+                    pass
+
+                def test3(self):
+                    GLOBAL_LIST.append(object())
+
+                def test4(self):
+                    pass
+        """)
+
+        test = self.create_test('huntrleaks', code=code)
 
-    @unittest.skipUnless(Py_DEBUG, 'need a debug build')
+        filename = 'reflog.txt'
+        self.addCleanup(os_helper.unlink, filename)
+        cmd = ['--huntrleaks', '3:3:', '--bisect', test]
+        output = self.run_tests(*cmd,
+                                exitcode=EXITCODE_BAD_TEST,
+                                stderr=subprocess.STDOUT)
+
+        self.assertIn(f"Bisect {test}", output)
+        self.assertIn(f"Bisect {test}: exit code 0", output)
+
+        # test3 is the one which leaks
+        self.assertIn("Bisection completed in", output)
+        self.assertIn(
+            "Tests (1):\n"
+            f"* {test}.RefLeakTest.test3\n",
+            output)
+
+    @unittest.skipUnless(support.Py_DEBUG, 'need a debug build')
     def test_huntrleaks_fd_leak(self):
         # test --huntrleaks for file descriptor leak
         code = textwrap.dedent("""
@@ -985,16 +1385,14 @@ def test_crashed(self):
         crash_test = self.create_test(name="crash", code=code)
 
         tests = [crash_test]
-        output = self.run_tests("-j2", *tests, exitcode=2)
+        output = self.run_tests("-j2", *tests, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, tests, failed=crash_test,
-                                  randomize=True)
+                                  parallel=True, stats=0)
 
     def parse_methods(self, output):
         regex = re.compile("^(test[^ ]+).*ok$", flags=re.MULTILINE)
         return [match.group(1) for match in regex.finditer(output)]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_ignorefile(self):
         code = textwrap.dedent("""
             import unittest
@@ -1009,8 +1407,6 @@ def test_method3(self):
                 def test_method4(self):
                     pass
         """)
-        all_methods = ['test_method1', 'test_method2',
-                       'test_method3', 'test_method4']
         testname = self.create_test(code=code)
 
         # only run a subset
@@ -1072,8 +1468,6 @@ def test_method4(self):
         subset = ['test_method1', 'test_method3']
         self.assertEqual(methods, subset)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_env_changed(self):
         code = textwrap.dedent("""
             import unittest
@@ -1086,52 +1480,265 @@ def test_env_changed(self):
 
         # don't fail by default
         output = self.run_tests(testname)
-        self.check_executed_tests(output, [testname], env_changed=testname)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=testname, stats=1)
 
         # fail with --fail-env-changed
-        output = self.run_tests("--fail-env-changed", testname, exitcode=3)
+        output = self.run_tests("--fail-env-changed", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
         self.check_executed_tests(output, [testname], env_changed=testname,
-                                  fail_env_changed=True)
+                                  fail_env_changed=True, stats=1)
+
+        # rerun
+        output = self.run_tests("--rerun", testname)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=testname,
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=True),
+                                  stats=2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_rerun_fail(self):
         # FAILURE then FAILURE
         code = textwrap.dedent("""
             import unittest
 
             class Tests(unittest.TestCase):
-                def test_bug(self):
-                    # test always fail
+                def test_succeed(self):
+                    return
+
+                def test_fail_always(self):
+                    # test that always fails
                     self.fail("bug")
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-w", testname, exitcode=2)
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  failed=testname, rerun=testname)
+                                  rerun=Rerun(testname,
+                                              "test_fail_always",
+                                              success=False),
+                                  stats=TestStats(3, 2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_rerun_success(self):
         # FAILURE then SUCCESS
-        code = textwrap.dedent("""
-            import builtins
+        marker_filename = os.path.abspath("regrtest_marker_filename")
+        self.addCleanup(os_helper.unlink, marker_filename)
+        self.assertFalse(os.path.exists(marker_filename))
+
+        code = textwrap.dedent(f"""
+            import os.path
             import unittest
 
+            marker_filename = {marker_filename!r}
+
             class Tests(unittest.TestCase):
-                failed = False
+                def test_succeed(self):
+                    return
 
                 def test_fail_once(self):
-                    if not hasattr(builtins, '_test_failed'):
-                        builtins._test_failed = True
+                    if not os.path.exists(marker_filename):
+                        open(marker_filename, "w").close()
                         self.fail("bug")
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-w", testname, exitcode=0)
+        # FAILURE then SUCCESS => exit code 0
+        output = self.run_tests("--rerun", testname, exitcode=0)
+        self.check_executed_tests(output, [testname],
+                                  rerun=Rerun(testname,
+                                              match="test_fail_once",
+                                              success=True),
+                                  stats=TestStats(3, 1))
+        os_helper.unlink(marker_filename)
+
+        # with --fail-rerun, exit code EXITCODE_RERUN_FAIL
+        # on "FAILURE then SUCCESS" state.
+        output = self.run_tests("--rerun", "--fail-rerun", testname,
+                                exitcode=EXITCODE_RERUN_FAIL)
+        self.check_executed_tests(output, [testname],
+                                  rerun=Rerun(testname,
+                                              match="test_fail_once",
+                                              success=True),
+                                  stats=TestStats(3, 1))
+        os_helper.unlink(marker_filename)
+
+    def test_rerun_setup_class_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                @classmethod
+                def setUpClass(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="ExampleTests",
+                                              success=False),
+                                  stats=0)
+
+    def test_rerun_teardown_class_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                @classmethod
+                def tearDownClass(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="ExampleTests",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_setup_module_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            def setUpModule():
+                raise RuntimeError('Fail')
+
+            class ExampleTests(unittest.TestCase):
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=False),
+                                  stats=0)
+
+    def test_rerun_teardown_module_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            def tearDownModule():
+                raise RuntimeError('Fail')
+
+            class ExampleTests(unittest.TestCase):
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  rerun=testname)
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match=None,
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_setup_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                def setUp(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_teardown_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.TestCase):
+                def tearDown(self):
+                    raise RuntimeError('Fail')
+
+                def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_async_setup_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.IsolatedAsyncioTestCase):
+                async def asyncSetUp(self):
+                    raise RuntimeError('Fail')
+
+                async def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
+
+    def test_rerun_async_teardown_hook_failure(self):
+        # FAILURE then FAILURE
+        code = textwrap.dedent("""
+            import unittest
+
+            class ExampleTests(unittest.IsolatedAsyncioTestCase):
+                async def asyncTearDown(self):
+                    raise RuntimeError('Fail')
+
+                async def test_success(self):
+                    return
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--rerun", testname, exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  rerun=Rerun(testname,
+                                              match="test_success",
+                                              success=False),
+                                  stats=2)
 
     def test_no_tests_ran(self):
         code = textwrap.dedent("""
@@ -1143,8 +1750,11 @@ def test_bug(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests(testname, "-m", "nosuchtest", exitcode=0)
-        self.check_executed_tests(output, [testname], no_test_ran=testname)
+        output = self.run_tests(testname, "-m", "nosuchtest",
+                                exitcode=EXITCODE_NO_TESTS_RAN)
+        self.check_executed_tests(output, [testname],
+                                  run_no_tests=testname,
+                                  stats=0, filtered=True)
 
     def test_no_tests_ran_skip(self):
         code = textwrap.dedent("""
@@ -1156,8 +1766,9 @@ def test_skipped(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests(testname, exitcode=0)
-        self.check_executed_tests(output, [testname])
+        output = self.run_tests(testname)
+        self.check_executed_tests(output, [testname],
+                                  stats=TestStats(1, skipped=1))
 
     def test_no_tests_ran_multiple_tests_nonexistent(self):
         code = textwrap.dedent("""
@@ -1170,9 +1781,11 @@ def test_bug(self):
         testname = self.create_test(code=code)
         testname2 = self.create_test(code=code)
 
-        output = self.run_tests(testname, testname2, "-m", "nosuchtest", exitcode=0)
+        output = self.run_tests(testname, testname2, "-m", "nosuchtest",
+                                exitcode=EXITCODE_NO_TESTS_RAN)
         self.check_executed_tests(output, [testname, testname2],
-                                  no_test_ran=[testname, testname2])
+                                  run_no_tests=[testname, testname2],
+                                  stats=0, filtered=True)
 
     def test_no_test_ran_some_test_exist_some_not(self):
         code = textwrap.dedent("""
@@ -1195,10 +1808,15 @@ def test_other_bug(self):
         output = self.run_tests(testname, testname2, "-m", "nosuchtest",
                                 "-m", "test_other_bug", exitcode=0)
         self.check_executed_tests(output, [testname, testname2],
-                                  no_test_ran=[testname])
+                                  run_no_tests=[testname],
+                                  stats=1, filtered=True)
 
     @support.cpython_only
-    def test_findleaks(self):
+    def test_uncollectable(self):
+        try:
+            import _testcapi
+        except ImportError:
+            raise unittest.SkipTest("requires _testcapi")
         code = textwrap.dedent(r"""
             import _testcapi
             import gc
@@ -1218,19 +1836,13 @@ def test_garbage(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("--fail-env-changed", testname, exitcode=3)
-        self.check_executed_tests(output, [testname],
-                                  env_changed=[testname],
-                                  fail_env_changed=True)
-
-        # --findleaks is now basically an alias to --fail-env-changed
-        output = self.run_tests("--findleaks", testname, exitcode=3)
+        output = self.run_tests("--fail-env-changed", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
         self.check_executed_tests(output, [testname],
                                   env_changed=[testname],
-                                  fail_env_changed=True)
+                                  fail_env_changed=True,
+                                  stats=1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiprocessing_timeout(self):
         code = textwrap.dedent(r"""
             import time
@@ -1252,14 +1864,131 @@ def test_sleep(self):
         """)
         testname = self.create_test(code=code)
 
-        output = self.run_tests("-j2", "--timeout=1.0", testname, exitcode=2)
+        output = self.run_tests("-j2", "--timeout=1.0", testname,
+                                exitcode=EXITCODE_BAD_TEST)
         self.check_executed_tests(output, [testname],
-                                  failed=testname)
+                                  failed=testname, stats=0)
         self.assertRegex(output,
                          re.compile('%s timed out' % testname, re.MULTILINE))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unraisable_exc(self):
+        # --fail-env-changed must catch unraisable exception.
+        # The exception must be displayed even if sys.stderr is redirected.
+        code = textwrap.dedent(r"""
+            import unittest
+            import weakref
+            from test.support import captured_stderr
+
+            class MyObject:
+                pass
+
+            def weakref_callback(obj):
+                raise Exception("weakref callback bug")
+
+            class Tests(unittest.TestCase):
+                def test_unraisable_exc(self):
+                    obj = MyObject()
+                    ref = weakref.ref(obj, weakref_callback)
+                    with captured_stderr() as stderr:
+                        # call weakref_callback() which logs
+                        # an unraisable exception
+                        obj = None
+                    self.assertEqual(stderr.getvalue(), '')
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=[testname],
+                                  fail_env_changed=True,
+                                  stats=1)
+        self.assertIn("Warning -- Unraisable exception", output)
+        self.assertIn("Exception: weakref callback bug", output)
+
+    def test_threading_excepthook(self):
+        # --fail-env-changed must catch uncaught thread exception.
+        # The exception must be displayed even if sys.stderr is redirected.
+        code = textwrap.dedent(r"""
+            import threading
+            import unittest
+            from test.support import captured_stderr
+
+            class MyObject:
+                pass
+
+            def func_bug():
+                raise Exception("bug in thread")
+
+            class Tests(unittest.TestCase):
+                def test_threading_excepthook(self):
+                    with captured_stderr() as stderr:
+                        thread = threading.Thread(target=func_bug)
+                        thread.start()
+                        thread.join()
+                    self.assertEqual(stderr.getvalue(), '')
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", testname,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, [testname],
+                                  env_changed=[testname],
+                                  fail_env_changed=True,
+                                  stats=1)
+        self.assertIn("Warning -- Uncaught thread exception", output)
+        self.assertIn("Exception: bug in thread", output)
+
+    def test_print_warning(self):
+        # bpo-45410: The order of messages must be preserved when -W and
+        # support.print_warning() are used.
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+            from test import support
+
+            class MyObject:
+                pass
+
+            def func_bug():
+                raise Exception("bug in thread")
+
+            class Tests(unittest.TestCase):
+                def test_print_warning(self):
+                    print("msg1: stdout")
+                    support.print_warning("msg2: print_warning")
+                    # Fail with ENV CHANGED to see print_warning() log
+                    support.environment_altered = True
+        """)
+        testname = self.create_test(code=code)
+
+        # Expect an output like:
+        #
+        #   test_threading_excepthook (test.test_x.Tests) ... msg1: stdout
+        #   Warning -- msg2: print_warning
+        #   ok
+        regex = (r"test_print_warning.*msg1: stdout\n"
+                 r"Warning -- msg2: print_warning\n"
+                 r"ok\n")
+        for option in ("-v", "-W"):
+            with self.subTest(option=option):
+                cmd = ["--fail-env-changed", option, testname]
+                output = self.run_tests(*cmd, exitcode=EXITCODE_ENV_CHANGED)
+                self.check_executed_tests(output, [testname],
+                                          env_changed=[testname],
+                                          fail_env_changed=True,
+                                          stats=1)
+                self.assertRegex(output, regex)
+
+    def test_unicode_guard_env(self):
+        guard = os.environ.get(setup.UNICODE_GUARD_ENV)
+        self.assertIsNotNone(guard, f"{setup.UNICODE_GUARD_ENV} not set")
+        if guard.isascii():
+            # Skip to signify that the env var value was changed by the user;
+            # possibly to something ASCII to work around Unicode issues.
+            self.skipTest("Modified guard")
+
     def test_cleanup(self):
         dirname = os.path.join(self.tmptestdir, "test_python_123")
         os.mkdir(dirname)
@@ -1275,10 +2004,415 @@ def test_cleanup(self):
         for name in names:
             self.assertFalse(os.path.exists(name), name)
 
+    @unittest.skip('TODO: RUSTPYTHON flaky')
+    @unittest.skipIf(support.is_wasi,
+                     'checking temp files is not implemented on WASI')
+    def test_leak_tmp_file(self):
+        code = textwrap.dedent(r"""
+            import os.path
+            import tempfile
+            import unittest
+
+            class FileTests(unittest.TestCase):
+                def test_leak_tmp_file(self):
+                    filename = os.path.join(tempfile.gettempdir(), 'mytmpfile')
+                    with open(filename, "wb") as fp:
+                        fp.write(b'content')
+        """)
+        testnames = [self.create_test(code=code) for _ in range(3)]
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j2", *testnames,
+                                exitcode=EXITCODE_ENV_CHANGED)
+        self.check_executed_tests(output, testnames,
+                                  env_changed=testnames,
+                                  fail_env_changed=True,
+                                  parallel=True,
+                                  stats=len(testnames))
+        for testname in testnames:
+            self.assertIn(f"Warning -- {testname} leaked temporary "
+                          f"files (1): mytmpfile",
+                          output)
+
+    def test_worker_decode_error(self):
+        # gh-109425: Use "backslashreplace" error handler to decode stdout.
+        if sys.platform == 'win32':
+            encoding = locale.getencoding()
+        else:
+            encoding = sys.stdout.encoding
+            if encoding is None:
+                encoding = sys.__stdout__.encoding
+                if encoding is None:
+                    self.skipTest("cannot get regrtest worker encoding")
+
+        nonascii = bytes(ch for ch in range(128, 256))
+        corrupted_output = b"nonascii:%s\n" % (nonascii,)
+        # gh-108989: On Windows, assertion errors are written in UTF-16: when
+        # decoded each letter is follow by a NUL character.
+        assertion_failed = 'Assertion failed: tstate_is_alive(tstate)\n'
+        corrupted_output += assertion_failed.encode('utf-16-le')
+        try:
+            corrupted_output.decode(encoding)
+        except UnicodeDecodeError:
+            pass
+        else:
+            self.skipTest(f"{encoding} can decode non-ASCII bytes")
+
+        expected_line = corrupted_output.decode(encoding, 'backslashreplace')
+
+        code = textwrap.dedent(fr"""
+            import sys
+            import unittest
+
+            class Tests(unittest.TestCase):
+                def test_pass(self):
+                    pass
+
+            # bytes which cannot be decoded from UTF-8
+            corrupted_output = {corrupted_output!a}
+            sys.stdout.buffer.write(corrupted_output)
+            sys.stdout.buffer.flush()
+        """)
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j1", testname)
+        self.check_executed_tests(output, [testname],
+                                  parallel=True,
+                                  stats=1)
+        self.check_line(output, expected_line, regex=False)
+
+    def test_doctest(self):
+        code = textwrap.dedent(r'''
+            import doctest
+            import sys
+            from test import support
+
+            def my_function():
+                """
+                Pass:
+
+                >>> 1 + 1
+                2
+
+                Failure:
+
+                >>> 2 + 3
+                23
+                >>> 1 + 1
+                11
+
+                Skipped test (ignored):
+
+                >>> id(1.0)  # doctest: +SKIP
+                7948648
+                """
+
+            def load_tests(loader, tests, pattern):
+                tests.addTest(doctest.DocTestSuite())
+                return tests
+        ''')
+        testname = self.create_test(code=code)
+
+        output = self.run_tests("--fail-env-changed", "-v", "-j1", testname,
+                                exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, [testname],
+                                  failed=[testname],
+                                  parallel=True,
+                                  stats=TestStats(1, 1, 0))
+
+    def _check_random_seed(self, run_workers: bool):
+        # gh-109276: When -r/--randomize is used, random.seed() is called
+        # with the same random seed before running each test file.
+        code = textwrap.dedent(r'''
+            import random
+            import unittest
+
+            class RandomSeedTest(unittest.TestCase):
+                def test_randint(self):
+                    numbers = [random.randint(0, 1000) for _ in range(10)]
+                    print(f"Random numbers: {numbers}")
+        ''')
+        tests = [self.create_test(name=f'test_random{i}', code=code)
+                 for i in range(1, 3+1)]
+
+        random_seed = 856_656_202
+        cmd = ["--randomize", f"--randseed={random_seed}"]
+        if run_workers:
+            # run as many worker processes than the number of tests
+            cmd.append(f'-j{len(tests)}')
+        cmd.extend(tests)
+        output = self.run_tests(*cmd)
+
+        random.seed(random_seed)
+        # Make the assumption that nothing consume entropy between libregrest
+        # setup_tests() which calls random.seed() and RandomSeedTest calling
+        # random.randint().
+        numbers = [random.randint(0, 1000) for _ in range(10)]
+        expected = f"Random numbers: {numbers}"
+
+        regex = r'^Random numbers: .*$'
+        matches = re.findall(regex, output, flags=re.MULTILINE)
+        self.assertEqual(matches, [expected] * len(tests))
+
+    def test_random_seed(self):
+        self._check_random_seed(run_workers=False)
+
+    @unittest.skip('TODO: RUSTPYTHON flaky')
+    def test_random_seed_workers(self):
+        self._check_random_seed(run_workers=True)
+
+    @unittest.skip('TODO: RUSTPYTHON flaky')
+    def test_python_command(self):
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+
+            class WorkerTests(unittest.TestCase):
+                def test_dev_mode(self):
+                    self.assertTrue(sys.flags.dev_mode)
+        """)
+        tests = [self.create_test(code=code) for _ in range(3)]
+
+        # Custom Python command: "python -X dev"
+        python_cmd = [sys.executable, '-X', 'dev']
+        # test.libregrtest.cmdline uses shlex.split() to parse the Python
+        # command line string
+        python_cmd = shlex.join(python_cmd)
+
+        output = self.run_tests("--python", python_cmd, "-j0", *tests)
+        self.check_executed_tests(output, tests,
+                                  stats=len(tests), parallel=True)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_unload_tests(self):
+        # Test that unloading test modules does not break tests
+        # that import from other tests.
+        # The test execution order matters for this test.
+        # Both test_regrtest_a and test_regrtest_c which are executed before
+        # and after test_regrtest_b import a submodule from the test_regrtest_b
+        # package and use it in testing. test_regrtest_b itself does not import
+        # that submodule.
+        # Previously test_regrtest_c failed because test_regrtest_b.util in
+        # sys.modules was left after test_regrtest_a (making the import
+        # statement no-op), but new test_regrtest_b without the util attribute
+        # was imported for test_regrtest_b.
+        testdir = os.path.join(os.path.dirname(__file__),
+                               'regrtestdata', 'import_from_tests')
+        tests = [f'test_regrtest_{name}' for name in ('a', 'b', 'c')]
+        args = ['-Wd', '-E', '-bb', '-m', 'test', '--testdir=%s' % testdir, *tests]
+        output = self.run_python(args)
+        self.check_executed_tests(output, tests, stats=3)
+
+    def check_add_python_opts(self, option):
+        # --fast-ci and --slow-ci add "-u -W default -bb -E" options to Python
+        try:
+            import _testinternalcapi
+        except ImportError:
+            raise unittest.SkipTest("requires _testinternalcapi")
+        code = textwrap.dedent(r"""
+            import sys
+            import unittest
+            from test import support
+            try:
+                from _testinternalcapi import get_config
+            except ImportError:
+                get_config = None
+
+            # WASI/WASM buildbots don't use -E option
+            use_environment = (support.is_emscripten or support.is_wasi)
+
+            class WorkerTests(unittest.TestCase):
+                @unittest.skipUnless(get_config is None, 'need get_config()')
+                def test_config(self):
+                    config = get_config()['config']
+                    # -u option
+                    self.assertEqual(config['buffered_stdio'], 0)
+                    # -W default option
+                    self.assertTrue(config['warnoptions'], ['default'])
+                    # -bb option
+                    self.assertTrue(config['bytes_warning'], 2)
+                    # -E option
+                    self.assertTrue(config['use_environment'], use_environment)
+
+                def test_python_opts(self):
+                    # -u option
+                    self.assertTrue(sys.__stdout__.write_through)
+                    self.assertTrue(sys.__stderr__.write_through)
+
+                    # -W default option
+                    self.assertTrue(sys.warnoptions, ['default'])
+
+                    # -bb option
+                    self.assertEqual(sys.flags.bytes_warning, 2)
+
+                    # -E option
+                    self.assertEqual(not sys.flags.ignore_environment,
+                                     use_environment)
+        """)
+        testname = self.create_test(code=code)
+
+        # Use directly subprocess to control the exact command line
+        cmd = [sys.executable,
+               "-m", "test", option,
+               f'--testdir={self.tmptestdir}',
+               testname]
+        proc = subprocess.run(cmd,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.STDOUT,
+                              text=True)
+        self.assertEqual(proc.returncode, 0, proc)
+
+    def test_add_python_opts(self):
+        for opt in ("--fast-ci", "--slow-ci"):
+            with self.subTest(opt=opt):
+                self.check_add_python_opts(opt)
+
+    # gh-76319: Raising SIGSEGV on Android may not cause a crash.
+    @unittest.skipIf(support.is_android,
+                     'raising SIGSEGV on Android is unreliable')
+    def test_worker_output_on_failure(self):
+        try:
+            from faulthandler import _sigsegv
+        except ImportError:
+            self.skipTest("need faulthandler._sigsegv")
+
+        code = textwrap.dedent(r"""
+            import faulthandler
+            import unittest
+            from test import support
+
+            class CrashTests(unittest.TestCase):
+                def test_crash(self):
+                    print("just before crash!", flush=True)
+
+                    with support.SuppressCrashReport():
+                        faulthandler._sigsegv(True)
+        """)
+        testname = self.create_test(code=code)
+
+        # Sanitizers must not handle SIGSEGV (ex: for test_enable_fd())
+        env = dict(os.environ)
+        option = 'handle_segv=0'
+        support.set_sanitizer_env_var(env, option)
+
+        output = self.run_tests("-j1", testname,
+                                exitcode=EXITCODE_BAD_TEST,
+                                env=env)
+        self.check_executed_tests(output, testname,
+                                  failed=[testname],
+                                  stats=0, parallel=True)
+        if not support.MS_WINDOWS:
+            exitcode = -int(signal.SIGSEGV)
+            self.assertIn(f"Exit code {exitcode} (SIGSEGV)", output)
+        self.check_line(output, "just before crash!", full=True, regex=False)
+
+    def test_verbose3(self):
+        code = textwrap.dedent(r"""
+            import unittest
+            from test import support
+
+            class VerboseTests(unittest.TestCase):
+                def test_pass(self):
+                    print("SPAM SPAM SPAM")
+        """)
+        testname = self.create_test(code=code)
+
+        # Run sequentially
+        output = self.run_tests("--verbose3", testname)
+        self.check_executed_tests(output, testname, stats=1)
+        self.assertNotIn('SPAM SPAM SPAM', output)
+
+        # -R option needs a debug build
+        if support.Py_DEBUG:
+            # Check for reference leaks, run in parallel
+            output = self.run_tests("-R", "3:3", "-j1", "--verbose3", testname)
+            self.check_executed_tests(output, testname, stats=1, parallel=True)
+            self.assertNotIn('SPAM SPAM SPAM', output)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_xml(self):
+        code = textwrap.dedent(r"""
+            import unittest
+
+            class VerboseTests(unittest.TestCase):
+                def test_failed(self):
+                    print("abc \x1b def")
+                    self.fail()
+        """)
+        testname = self.create_test(code=code)
+
+        # Run sequentially
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+
+        output = self.run_tests(testname, "--junit-xml", filename,
+                                exitcode=EXITCODE_BAD_TEST)
+        self.check_executed_tests(output, testname,
+                                  failed=testname,
+                                  stats=TestStats(1, 1, 0))
+
+        # Test generated XML
+        with open(filename, encoding="utf8") as fp:
+            content = fp.read()
+
+        testsuite = ElementTree.fromstring(content)
+        self.assertEqual(int(testsuite.get('tests')), 1)
+        self.assertEqual(int(testsuite.get('errors')), 0)
+        self.assertEqual(int(testsuite.get('failures')), 1)
+
+        testcase = testsuite[0][0]
+        self.assertEqual(testcase.get('status'), 'run')
+        self.assertEqual(testcase.get('result'), 'completed')
+        self.assertGreater(float(testcase.get('time')), 0)
+        for out in testcase.iter('system-out'):
+            self.assertEqual(out.text, r"abc \x1b def")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_nonascii(self):
+        code = textwrap.dedent(r"""
+            import unittest
+
+            class NonASCIITests(unittest.TestCase):
+                def test_docstring(self):
+                    '''docstring:\u20ac'''
+
+                def test_subtest(self):
+                    with self.subTest(param='subtest:\u20ac'):
+                        pass
+
+                def test_skip(self):
+                    self.skipTest('skipped:\u20ac')
+        """)
+        testname = self.create_test(code=code)
+
+        env = dict(os.environ)
+        env['PYTHONIOENCODING'] = 'ascii'
+
+        def check(output):
+            self.check_executed_tests(output, testname, stats=TestStats(3, 0, 1))
+            self.assertIn(r'docstring:\u20ac', output)
+            self.assertIn(r'skipped:\u20ac', output)
+
+        # Run sequentially
+        output = self.run_tests('-v', testname, env=env, isolated=False)
+        check(output)
+
+        # Run in parallel
+        output = self.run_tests('-j1', '-v', testname, env=env, isolated=False)
+        check(output)
+
+    def test_pgo_exclude(self):
+        # Get PGO tests
+        output = self.run_tests('--pgo', '--list-tests')
+        pgo_tests = output.strip().split()
+
+        # Exclude test_re
+        output = self.run_tests('--pgo', '--list-tests', '-x', 'test_re')
+        tests = output.strip().split()
+        self.assertNotIn('test_re', tests)
+        self.assertEqual(len(tests), len(pgo_tests) - 1)
+
 
 class TestUtils(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_format_duration(self):
         self.assertEqual(utils.format_duration(0),
                          '0 ms')
@@ -1301,6 +2435,184 @@ def test_format_duration(self):
         self.assertEqual(utils.format_duration(3 * 3600 + 1),
                          '3 hour 1 sec')
 
+    def test_normalize_test_name(self):
+        normalize = normalize_test_name
+        self.assertEqual(normalize('test_access (test.test_os.FileTests.test_access)'),
+                         'test_access')
+        self.assertEqual(normalize('setUpClass (test.test_os.ChownFileTests)', is_error=True),
+                         'ChownFileTests')
+        self.assertEqual(normalize('test_success (test.test_bug.ExampleTests.test_success)', is_error=True),
+                         'test_success')
+        self.assertIsNone(normalize('setUpModule (test.test_x)', is_error=True))
+        self.assertIsNone(normalize('tearDownModule (test.test_module)', is_error=True))
+
+    def test_get_signal_name(self):
+        for exitcode, expected in (
+            (-int(signal.SIGINT), 'SIGINT'),
+            (-int(signal.SIGSEGV), 'SIGSEGV'),
+            (128 + int(signal.SIGABRT), 'SIGABRT'),
+            (3221225477, "STATUS_ACCESS_VIOLATION"),
+            (0xC00000FD, "STATUS_STACK_OVERFLOW"),
+        ):
+            self.assertEqual(utils.get_signal_name(exitcode), expected, exitcode)
+
+    def test_format_resources(self):
+        format_resources = utils.format_resources
+        ALL_RESOURCES = utils.ALL_RESOURCES
+        self.assertEqual(
+            format_resources(("network",)),
+            'resources (1): network')
+        self.assertEqual(
+            format_resources(("audio", "decimal", "network")),
+            'resources (3): audio,decimal,network')
+        self.assertEqual(
+            format_resources(ALL_RESOURCES),
+            'resources: all')
+        self.assertEqual(
+            format_resources(tuple(name for name in ALL_RESOURCES
+                                   if name != "cpu")),
+            'resources: all,-cpu')
+        self.assertEqual(
+            format_resources((*ALL_RESOURCES, "tzdata")),
+            'resources: all,tzdata')
+
+    def test_match_test(self):
+        class Test:
+            def __init__(self, test_id):
+                self.test_id = test_id
+
+            def id(self):
+                return self.test_id
+
+        # Restore patterns once the test completes
+        patterns = get_match_tests()
+        self.addCleanup(set_match_tests, patterns)
+
+        test_access = Test('test.test_os.FileTests.test_access')
+        test_chdir = Test('test.test_os.Win32ErrorTests.test_chdir')
+        test_copy = Test('test.test_shutil.TestCopy.test_copy')
+
+        # Test acceptance
+        with support.swap_attr(support, '_test_matchers', ()):
+            # match all
+            set_match_tests([])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match all using None
+            set_match_tests(None)
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match the full test identifier
+            set_match_tests([(test_access.id(), True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+            # match the module name
+            set_match_tests([('test_os', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            # Test '*' pattern
+            set_match_tests([('test_*', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # Test case sensitivity
+            set_match_tests([('filetests', True)])
+            self.assertFalse(match_test(test_access))
+            set_match_tests([('FileTests', True)])
+            self.assertTrue(match_test(test_access))
+
+            # Test pattern containing '.' and a '*' metacharacter
+            set_match_tests([('*test_os.*.test_*', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            # Multiple patterns
+            set_match_tests([(test_access.id(), True), (test_chdir.id(), True)])
+            self.assertTrue(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+            set_match_tests([('test_access', True), ('DONTMATCH', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+        # Test rejection
+        with support.swap_attr(support, '_test_matchers', ()):
+            # match the full test identifier
+            set_match_tests([(test_access.id(), False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+            # match the module name
+            set_match_tests([('test_os', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            # Test '*' pattern
+            set_match_tests([('test_*', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+
+            # Test case sensitivity
+            set_match_tests([('filetests', False)])
+            self.assertTrue(match_test(test_access))
+            set_match_tests([('FileTests', False)])
+            self.assertFalse(match_test(test_access))
+
+            # Test pattern containing '.' and a '*' metacharacter
+            set_match_tests([('*test_os.*.test_*', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            # Multiple patterns
+            set_match_tests([(test_access.id(), False), (test_chdir.id(), False)])
+            self.assertFalse(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            set_match_tests([('test_access', False), ('DONTMATCH', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+
+        # Test mixed filters
+        with support.swap_attr(support, '_test_matchers', ()):
+            set_match_tests([('*test_os', False), ('test_access', True)])
+            self.assertTrue(match_test(test_access))
+            self.assertFalse(match_test(test_chdir))
+            self.assertTrue(match_test(test_copy))
+
+            set_match_tests([('*test_os', True), ('test_access', False)])
+            self.assertFalse(match_test(test_access))
+            self.assertTrue(match_test(test_chdir))
+            self.assertFalse(match_test(test_copy))
+
+    def test_sanitize_xml(self):
+        sanitize_xml = utils.sanitize_xml
+
+        # escape invalid XML characters
+        self.assertEqual(sanitize_xml('abc \x1b\x1f def'),
+                         r'abc \x1b\x1f def')
+        self.assertEqual(sanitize_xml('nul:\x00, bell:\x07'),
+                         r'nul:\x00, bell:\x07')
+        self.assertEqual(sanitize_xml('surrogate:\uDC80'),
+                         r'surrogate:\udc80')
+        self.assertEqual(sanitize_xml('illegal \uFFFE and \uFFFF'),
+                         r'illegal \ufffe and \uffff')
+
+        # no escape for valid XML characters
+        self.assertEqual(sanitize_xml('a\n\tb'),
+                         'a\n\tb')
+        self.assertEqual(sanitize_xml('valid t\xe9xt \u20ac'),
+                         'valid t\xe9xt \u20ac')
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py
index 396be4b104..738b48f562 100644
--- a/Lib/test/test_reprlib.py
+++ b/Lib/test/test_reprlib.py
@@ -176,8 +176,6 @@ def test_instance(self):
         self.assertTrue(s.endswith(">"))
         self.assertIn(s.find("..."), [12, 13])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_lambda(self):
         r = repr(lambda x: x)
         self.assertTrue(r.startswith("<function ReprTests.test_lambda.<locals>.<lambda"), r)
diff --git a/Lib/test/test_richcmp.py b/Lib/test/test_richcmp.py
index 58729a9fea..5f449cdc05 100644
--- a/Lib/test/test_richcmp.py
+++ b/Lib/test/test_richcmp.py
@@ -221,6 +221,7 @@ def do(bad):
             self.assertRaises(Exc, func, Bad())
 
     @support.no_tracing
+    @support.infinite_recursion(25)
     def test_recursion(self):
         # Check that comparison for recursive objects fails gracefully
         from collections import UserList
diff --git a/Lib/test/test_rlcompleter.py b/Lib/test/test_rlcompleter.py
index 0dc1080ca3..ffadfee276 100644
--- a/Lib/test/test_rlcompleter.py
+++ b/Lib/test/test_rlcompleter.py
@@ -2,6 +2,7 @@
 from unittest.mock import patch
 import builtins
 import rlcompleter
+from test.support import MISSING_C_DOCSTRINGS
 
 class CompleteMe:
     """ Trivial class used in testing rlcompleter.Completer. """
@@ -40,21 +41,41 @@ def test_global_matches(self):
 
         # test with a customized namespace
         self.assertEqual(self.completer.global_matches('CompleteM'),
-                         ['CompleteMe('])
+                ['CompleteMe(' if MISSING_C_DOCSTRINGS else 'CompleteMe()'])
         self.assertEqual(self.completer.global_matches('eg'),
                          ['egg('])
         # XXX: see issue5256
         self.assertEqual(self.completer.global_matches('CompleteM'),
-                         ['CompleteMe('])
+                ['CompleteMe(' if MISSING_C_DOCSTRINGS else 'CompleteMe()'])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_attr_matches(self):
         # test with builtins namespace
         self.assertEqual(self.stdcompleter.attr_matches('str.s'),
                          ['str.{}('.format(x) for x in dir(str)
                           if x.startswith('s')])
         self.assertEqual(self.stdcompleter.attr_matches('tuple.foospamegg'), [])
-        expected = sorted({'None.%s%s' % (x, '(' if x != '__doc__' else '')
-                           for x in dir(None)})
+
+        def create_expected_for_none():
+            if not MISSING_C_DOCSTRINGS:
+                parentheses = ('__init_subclass__', '__class__')
+            else:
+                # When `--without-doc-strings` is used, `__class__`
+                # won't have a known signature.
+                parentheses = ('__init_subclass__',)
+
+            items = set()
+            for x in dir(None):
+                if x in parentheses:
+                    items.add(f'None.{x}()')
+                elif x == '__doc__':
+                    items.add(f'None.{x}')
+                else:
+                    items.add(f'None.{x}(')
+            return sorted(items)
+
+        expected = create_expected_for_none()
         self.assertEqual(self.stdcompleter.attr_matches('None.'), expected)
         self.assertEqual(self.stdcompleter.attr_matches('None._'), expected)
         self.assertEqual(self.stdcompleter.attr_matches('None.__'), expected)
@@ -64,7 +85,7 @@ def test_attr_matches(self):
                          ['CompleteMe.spam'])
         self.assertEqual(self.completer.attr_matches('Completeme.egg'), [])
         self.assertEqual(self.completer.attr_matches('CompleteMe.'),
-                         ['CompleteMe.mro(', 'CompleteMe.spam'])
+                         ['CompleteMe.mro()', 'CompleteMe.spam'])
         self.assertEqual(self.completer.attr_matches('CompleteMe._'),
                          ['CompleteMe._ham'])
         matches = self.completer.attr_matches('CompleteMe.__')
@@ -81,17 +102,41 @@ def test_attr_matches(self):
                               if x.startswith('s')])
 
     def test_excessive_getattr(self):
-        # Ensure getattr() is invoked no more than once per attribute
+        """Ensure getattr() is invoked no more than once per attribute"""
+
+        # note the special case for @property methods below; that is why
+        # we use __dir__ and __getattr__ in class Foo to create a "magic"
+        # class attribute 'bar'. This forces `getattr` to call __getattr__
+        # (which is doesn't necessarily do).
         class Foo:
             calls = 0
+            bar = ''
+            def __getattribute__(self, name):
+                if name == 'bar':
+                    self.calls += 1
+                    return None
+                return super().__getattribute__(name)
+
+        f = Foo()
+        completer = rlcompleter.Completer(dict(f=f))
+        self.assertEqual(completer.complete('f.b', 0), 'f.bar')
+        self.assertEqual(f.calls, 1)
+
+    def test_property_method_not_called(self):
+        class Foo:
+            _bar = 0
+            property_called = False
+
             @property
             def bar(self):
-                self.calls += 1
-                return None
+                self.property_called = True
+                return self._bar
+
         f = Foo()
         completer = rlcompleter.Completer(dict(f=f))
         self.assertEqual(completer.complete('f.b', 0), 'f.bar')
-        self.assertEqual(f.calls, 1)
+        self.assertFalse(f.property_called)
+
 
     def test_uncreated_attr(self):
         # Attributes like properties and slots should be completed even when
@@ -114,6 +159,9 @@ def test_complete(self):
         self.assertEqual(completer.complete('el', 0), 'elif ')
         self.assertEqual(completer.complete('el', 1), 'else')
         self.assertEqual(completer.complete('tr', 0), 'try:')
+        self.assertEqual(completer.complete('_', 0), '_')
+        self.assertEqual(completer.complete('match', 0), 'match ')
+        self.assertEqual(completer.complete('case', 0), 'case ')
 
     def test_duplicate_globals(self):
         namespace = {
@@ -134,7 +182,7 @@ def test_duplicate_globals(self):
         # No opening bracket "(" because we overrode the built-in class
         self.assertEqual(completer.complete('memoryview', 0), 'memoryview')
         self.assertIsNone(completer.complete('memoryview', 1))
-        self.assertEqual(completer.complete('Ellipsis', 0), 'Ellipsis(')
+        self.assertEqual(completer.complete('Ellipsis', 0), 'Ellipsis()')
         self.assertIsNone(completer.complete('Ellipsis', 1))
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_robotparser.py b/Lib/test/test_robotparser.py
index b0bed431d4..89cabfe008 100644
--- a/Lib/test/test_robotparser.py
+++ b/Lib/test/test_robotparser.py
@@ -259,6 +259,10 @@ class EmptyQueryStringTest(BaseRobotTest, unittest.TestCase):
     good = ['/some/path?']
     bad = ['/another/path?']
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; self.assertFalse(self.parser.can_fetch(agent, url))\nAssertionError: True is not false
+    def test_bad_urls(self):
+        super().test_bad_urls()
+
 
 class DefaultEntryTest(BaseRequestRateTest, unittest.TestCase):
     robots_txt = """\
diff --git a/Lib/test/test_runpy.py b/Lib/test/test_runpy.py
index b2fee6207b..c1e255e7af 100644
--- a/Lib/test/test_runpy.py
+++ b/Lib/test/test_runpy.py
@@ -12,9 +12,16 @@
 import textwrap
 import unittest
 import warnings
-from test.support import no_tracing, verbose
+from test.support import (
+    force_not_colorized_test_class,
+    infinite_recursion,
+    no_tracing,
+    requires_resource,
+    requires_subprocess,
+    verbose,
+)
 from test.support.import_helper import forget, make_legacy_pyc, unload
-from test.support.os_helper import create_empty_file, temp_dir
+from test.support.os_helper import create_empty_file, temp_dir, FakePath
 from test.support.script_helper import make_script, make_zip_script
 
 
@@ -656,13 +663,14 @@ def test_basic_script(self):
             self._check_script(script_name, "<run_path>", script_name,
                                script_name, expect_spec=False)
 
-    def test_basic_script_with_path_object(self):
+    def test_basic_script_with_pathlike_object(self):
         with temp_dir() as script_dir:
             mod_name = 'script'
-            script_name = pathlib.Path(self._make_test_script(script_dir,
-                                                              mod_name))
-            self._check_script(script_name, "<run_path>", script_name,
-                               script_name, expect_spec=False)
+            script_name = self._make_test_script(script_dir, mod_name)
+            self._check_script(FakePath(script_name), "<run_path>",
+                               script_name,
+                               script_name,
+                               expect_spec=False)
 
     def test_basic_script_no_suffix(self):
         with temp_dir() as script_dir:
@@ -734,6 +742,7 @@ def test_zipfile_error(self):
             self._check_import_error(zip_name, msg)
 
     @no_tracing
+    @requires_resource('cpu')
     def test_main_recursion_error(self):
         with temp_dir() as script_dir, temp_dir() as dummy_dir:
             mod_name = '__main__'
@@ -741,10 +750,10 @@ def test_main_recursion_error(self):
                       "runpy.run_path(%r)\n") % dummy_dir
             script_name = self._make_test_script(script_dir, mod_name, source)
             zip_name, fname = make_zip_script(script_dir, 'test_zip', script_name)
-            self.assertRaises(RecursionError, run_path, zip_name)
+            with infinite_recursion(25):
+                self.assertRaises(RecursionError, run_path, zip_name)
 
-    # TODO: RUSTPYTHON, detect encoding comments in files
-    @unittest.expectedFailure
+    @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')
@@ -757,6 +766,7 @@ def test_encoding(self):
             self.assertEqual(result['s'], "non-ASCII: h\xe9")
 
 
+@force_not_colorized_test_class
 class TestExit(unittest.TestCase):
     STATUS_CONTROL_C_EXIT = 0xC000013A
     EXPECTED_CODE = (
@@ -783,16 +793,17 @@ def run(self, *args, **kwargs):
             )
             super().run(*args, **kwargs)
 
-    def assertSigInt(self, *args, **kwargs):
-        proc = subprocess.run(*args, **kwargs, text=True, stderr=subprocess.PIPE)
-        self.assertTrue(proc.stderr.endswith("\nKeyboardInterrupt\n"))
+    @requires_subprocess()
+    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.assertEqual(proc.returncode, self.EXPECTED_CODE)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_file(self):
-        self.assertSigInt([sys.executable, self.ham])
+        self.assertSigInt([self.ham])
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_file_runpy_run_module(self):
         tmp = self.ham.parent
         run_module = tmp / "run_module.py"
@@ -804,9 +815,8 @@ def test_pymain_run_file_runpy_run_module(self):
                 """
             )
         )
-        self.assertSigInt([sys.executable, run_module], cwd=tmp)
+        self.assertSigInt([run_module], cwd=tmp)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_file_runpy_run_module_as_main(self):
         tmp = self.ham.parent
         run_module_as_main = tmp / "run_module_as_main.py"
@@ -818,28 +828,24 @@ def test_pymain_run_file_runpy_run_module_as_main(self):
                 """
             )
         )
-        self.assertSigInt([sys.executable, run_module_as_main], cwd=tmp)
+        self.assertSigInt([run_module_as_main], cwd=tmp)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_command_run_module(self):
         self.assertSigInt(
-            [sys.executable, "-c", "import runpy; runpy.run_module('ham')"],
+            ["-c", "import runpy; runpy.run_module('ham')"],
             cwd=self.ham.parent,
         )
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_command(self):
-        self.assertSigInt([sys.executable, "-c", "import ham"], cwd=self.ham.parent)
+        self.assertSigInt(["-c", "import ham"], cwd=self.ham.parent)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pymain_run_stdin(self):
-        self.assertSigInt([sys.executable], input="import ham", cwd=self.ham.parent)
+        self.assertSigInt([], input="import ham", cwd=self.ham.parent)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_pymain_run_module(self):
         ham = self.ham
-        self.assertSigInt([sys.executable, "-m", ham.stem], cwd=ham.parent)
+        self.assertSigInt(["-m", ham.stem], cwd=ham.parent)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 29a4ac3c16..662d8eefbc 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -177,6 +177,57 @@ def bar():
         self.assertEqual(foo(a=42), 50)
         self.assertEqual(foo(), 25)
 
+    def testCellIsArgAndEscapes(self):
+        # We need to be sure that a cell passed in as an arg still
+        # gets wrapped in a new cell if the arg escapes into an
+        # inner function (closure).
+
+        def external():
+            value = 42
+            def inner():
+                return value
+            cell, = inner.__closure__
+            return cell
+        cell_ext = external()
+
+        def spam(arg):
+            def eggs():
+                return arg
+            return eggs
+
+        eggs = spam(cell_ext)
+        cell_closure, = eggs.__closure__
+        cell_eggs = eggs()
+
+        self.assertIs(cell_eggs, cell_ext)
+        self.assertIsNot(cell_eggs, cell_closure)
+
+    def testCellIsLocalAndEscapes(self):
+        # We need to be sure that a cell bound to a local still
+        # gets wrapped in a new cell if the local escapes into an
+        # inner function (closure).
+
+        def external():
+            value = 42
+            def inner():
+                return value
+            cell, = inner.__closure__
+            return cell
+        cell_ext = external()
+
+        def spam(arg):
+            cell = arg
+            def eggs():
+                return cell
+            return eggs
+
+        eggs = spam(cell_ext)
+        cell_closure, = eggs.__closure__
+        cell_eggs = eggs()
+
+        self.assertIs(cell_eggs, cell_ext)
+        self.assertIsNot(cell_eggs, cell_closure)
+
     def testRecursion(self):
 
         def f(x):
@@ -641,10 +692,7 @@ def dec(self):
         self.assertEqual(c.dec(), 1)
         self.assertEqual(c.dec(), 0)
 
-    # 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
-    @unittest.expectedFailure
+    @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.
@@ -763,6 +811,30 @@ def dig(self):
         gc_collect()  # For PyPy or other GCs.
         self.assertIsNone(ref())
 
+    def test_multiple_nesting(self):
+        # Regression test for https://github.com/python/cpython/issues/121863
+        class MultiplyNested:
+            def f1(self):
+                __arg = 1
+                class D:
+                    def g(self, __arg):
+                        return __arg
+                return D().g(_MultiplyNested__arg=2)
+
+            def f2(self):
+                __arg = 1
+                class D:
+                    def g(self, __arg):
+                        return __arg
+                return D().g
+
+        inst = MultiplyNested()
+        with self.assertRaises(TypeError):
+            inst.f1()
+
+        closure = inst.f2()
+        with self.assertRaises(TypeError):
+            closure(_MultiplyNested__arg=2)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_selectors.py b/Lib/test/test_selectors.py
index af730a8dec..643775597c 100644
--- a/Lib/test/test_selectors.py
+++ b/Lib/test/test_selectors.py
@@ -6,8 +6,7 @@
 import socket
 import sys
 from test import support
-from test.support import os_helper
-from test.support import socket_helper
+from test.support import is_apple, os_helper, socket_helper
 from time import sleep
 import unittest
 import unittest.mock
@@ -132,7 +131,6 @@ def test_unregister_after_fd_close_and_reuse(self):
         s.unregister(r)
         s.unregister(w)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_unregister_after_socket_close(self):
         s = self.SELECTOR()
         self.addCleanup(s.close)
@@ -224,6 +222,8 @@ def test_close(self):
         self.assertRaises(RuntimeError, s.get_key, wr)
         self.assertRaises(KeyError, mapping.__getitem__, rd)
         self.assertRaises(KeyError, mapping.__getitem__, wr)
+        self.assertEqual(mapping.get(rd), None)
+        self.assertEqual(mapping.get(wr), None)
 
     def test_get_key(self):
         s = self.SELECTOR()
@@ -242,13 +242,17 @@ def test_get_map(self):
         self.addCleanup(s.close)
 
         rd, wr = self.make_socketpair()
+        sentinel = object()
 
         keys = s.get_map()
         self.assertFalse(keys)
         self.assertEqual(len(keys), 0)
         self.assertEqual(list(keys), [])
+        self.assertEqual(keys.get(rd), None)
+        self.assertEqual(keys.get(rd, sentinel), sentinel)
         key = s.register(rd, selectors.EVENT_READ, "data")
         self.assertIn(rd, keys)
+        self.assertEqual(key, keys.get(rd))
         self.assertEqual(key, keys[rd])
         self.assertEqual(len(keys), 1)
         self.assertEqual(list(keys), [rd.fileno()])
@@ -521,7 +525,7 @@ def test_above_fd_setsize(self):
         try:
             fds = s.select()
         except OSError as e:
-            if e.errno == errno.EINVAL and sys.platform == 'darwin':
+            if e.errno == errno.EINVAL and is_apple:
                 # unexplainable errors on macOS don't need to fail the test
                 self.skipTest("Invalid argument error calling poll()")
             raise
diff --git a/Lib/test/test_setcomps.py b/Lib/test/test_setcomps.py
index ecc4fffec0..e8c0c33e98 100644
--- a/Lib/test/test_setcomps.py
+++ b/Lib/test/test_setcomps.py
@@ -1,3 +1,10 @@
+import doctest
+import traceback
+import unittest
+
+from test.support import BrokenIter
+
+
 doctests = """
 ########### Tests mostly copied from test_listcomps.py ############
 
@@ -144,24 +151,50 @@
 
 """
 
+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
+
+        def init_raises():
+            try:
+                {x for x in BrokenIter(init_raises=True)}
+            except Exception as e:
+                return e
+
+        def next_raises():
+            try:
+                {x for x in BrokenIter(next_raises=True)}
+            except Exception as e:
+                return e
+
+        def iter_raises():
+            try:
+                {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)
 
 __test__ = {'doctests' : doctests}
 
-def test_main(verbose=None):
-    import sys
-    from test import support
-    from test import test_setcomps
-    support.run_doctest(test_setcomps, verbose)
-
-    # verify reference counting
-    if verbose and hasattr(sys, "gettotalrefcount"):
-        import gc
-        counts = [None] * 5
-        for i in range(len(counts)):
-            support.run_doctest(test_setcomps, verbose)
-            gc.collect()
-            counts[i] = sys.gettotalrefcount()
-        print(counts)
+def load_tests(loader, tests, pattern):
+    tests.addTest(doctest.DocTestSuite())
+    return tests
+
 
 if __name__ == "__main__":
-    test_main(verbose=True)
+    unittest.main()
diff --git a/Lib/test/test_shelve.py b/Lib/test/test_shelve.py
index ac25eee2e5..08c6562f2a 100644
--- a/Lib/test/test_shelve.py
+++ b/Lib/test/test_shelve.py
@@ -1,7 +1,9 @@
 import unittest
+import dbm
 import shelve
-import glob
-from test import support
+import pickle
+import os
+
 from test.support import os_helper
 from collections.abc import MutableMapping
 from test.test_dbm import dbm_iterator
@@ -41,12 +43,8 @@ def copy(self):
 
 
 class TestCase(unittest.TestCase):
-
-    fn = "shelftemp.db"
-
-    def tearDown(self):
-        for f in glob.glob(self.fn+"*"):
-            os_helper.unlink(f)
+    dirname = os_helper.TESTFN
+    fn = os.path.join(os_helper.TESTFN, "shelftemp.db")
 
     def test_close(self):
         d1 = {}
@@ -63,29 +61,34 @@ def test_close(self):
         else:
             self.fail('Closed shelf should not find a key')
 
-    def test_ascii_file_shelf(self):
-        s = shelve.open(self.fn, protocol=0)
+    def test_open_template(self, filename=None, protocol=None):
+        os.mkdir(self.dirname)
+        self.addCleanup(os_helper.rmtree, self.dirname)
+        s = shelve.open(filename=filename if filename is not None else self.fn,
+                        protocol=protocol)
         try:
             s['key1'] = (1,2,3,4)
             self.assertEqual(s['key1'], (1,2,3,4))
         finally:
             s.close()
 
+    def test_ascii_file_shelf(self):
+        self.test_open_template(protocol=0)
+
     def test_binary_file_shelf(self):
-        s = shelve.open(self.fn, protocol=1)
-        try:
-            s['key1'] = (1,2,3,4)
-            self.assertEqual(s['key1'], (1,2,3,4))
-        finally:
-            s.close()
+        self.test_open_template(protocol=1)
 
     def test_proto2_file_shelf(self):
-        s = shelve.open(self.fn, protocol=2)
-        try:
-            s['key1'] = (1,2,3,4)
-            self.assertEqual(s['key1'], (1,2,3,4))
-        finally:
-            s.close()
+        self.test_open_template(protocol=2)
+
+    def test_pathlib_path_file_shelf(self):
+        self.test_open_template(filename=os_helper.FakePath(self.fn))
+
+    def test_bytes_path_file_shelf(self):
+        self.test_open_template(filename=os.fsencode(self.fn))
+
+    def test_pathlib_bytes_path_file_shelf(self):
+        self.test_open_template(filename=os_helper.FakePath(os.fsencode(self.fn)))
 
     def test_in_memory_shelf(self):
         d1 = byteskeydict()
@@ -160,65 +163,54 @@ def test_with(self):
 
     def test_default_protocol(self):
         with shelve.Shelf({}) as s:
-            self.assertEqual(s._protocol, 3)
+            self.assertEqual(s._protocol, pickle.DEFAULT_PROTOCOL)
 
-from test import mapping_tests
 
-class TestShelveBase(mapping_tests.BasicTestMappingProtocol):
-    fn = "shelftemp.db"
-    counter = 0
-    def __init__(self, *args, **kw):
-        self._db = []
-        mapping_tests.BasicTestMappingProtocol.__init__(self, *args, **kw)
+class TestShelveBase:
     type2test = shelve.Shelf
+
     def _reference(self):
         return {"key1":"value1", "key2":2, "key3":(1,2,3)}
+
+
+class TestShelveInMemBase(TestShelveBase):
     def _empty_mapping(self):
-        if self._in_mem:
-            x= shelve.Shelf(byteskeydict(), **self._args)
-        else:
-            self.counter+=1
-            x= shelve.open(self.fn+str(self.counter), **self._args)
-        self._db.append(x)
+        return shelve.Shelf(byteskeydict(), **self._args)
+
+
+class TestShelveFileBase(TestShelveBase):
+    counter = 0
+
+    def _empty_mapping(self):
+        self.counter += 1
+        x = shelve.open(self.base_path + str(self.counter), **self._args)
+        self.addCleanup(x.close)
         return x
-    def tearDown(self):
-        for db in self._db:
-            db.close()
-        self._db = []
-        if not self._in_mem:
-            for f in glob.glob(self.fn+"*"):
-                os_helper.unlink(f)
-
-class TestAsciiFileShelve(TestShelveBase):
-    _args={'protocol':0}
-    _in_mem = False
-class TestBinaryFileShelve(TestShelveBase):
-    _args={'protocol':1}
-    _in_mem = False
-class TestProto2FileShelve(TestShelveBase):
-    _args={'protocol':2}
-    _in_mem = False
-class TestAsciiMemShelve(TestShelveBase):
-    _args={'protocol':0}
-    _in_mem = True
-class TestBinaryMemShelve(TestShelveBase):
-    _args={'protocol':1}
-    _in_mem = True
-class TestProto2MemShelve(TestShelveBase):
-    _args={'protocol':2}
-    _in_mem = True
-
-def test_main():
-    for module in dbm_iterator():
-        support.run_unittest(
-            TestAsciiFileShelve,
-            TestBinaryFileShelve,
-            TestProto2FileShelve,
-            TestAsciiMemShelve,
-            TestBinaryMemShelve,
-            TestProto2MemShelve,
-            TestCase
-        )
+
+    def setUp(self):
+        dirname = os_helper.TESTFN
+        os.mkdir(dirname)
+        self.addCleanup(os_helper.rmtree, dirname)
+        self.base_path = os.path.join(dirname, "shelftemp.db")
+        self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod)
+        dbm._defaultmod = self.dbm_mod
+
+
+from test import mapping_tests
+
+for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+    bases = (TestShelveInMemBase, mapping_tests.BasicTestMappingProtocol)
+    name = f'TestProto{proto}MemShelve'
+    globals()[name] = type(name, bases,
+                           {'_args': {'protocol': proto}})
+    bases = (TestShelveFileBase, mapping_tests.BasicTestMappingProtocol)
+    for dbm_mod in dbm_iterator():
+        assert dbm_mod.__name__.startswith('dbm.')
+        suffix = dbm_mod.__name__[4:]
+        name = f'TestProto{proto}File_{suffix}Shelve'
+        globals()[name] = type(name, bases,
+                               {'dbm_mod': dbm_mod, '_args': {'protocol': proto}})
+
 
 if __name__ == "__main__":
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_shlex.py b/Lib/test/test_shlex.py
index c3d632a64c..baabccf19f 100644
--- a/Lib/test/test_shlex.py
+++ b/Lib/test/test_shlex.py
@@ -3,7 +3,6 @@
 import shlex
 import string
 import unittest
-from unittest import mock
 
 
 # The original test data set was from shellwords, by Hartmut Goebel.
@@ -162,18 +161,17 @@ def oldSplit(self, s):
             tok = lex.get_token()
         return ret
 
-    @mock.patch('sys.stdin', io.StringIO())
-    def testSplitNoneDeprecation(self):
-        with self.assertWarns(DeprecationWarning):
+    def testSplitNone(self):
+        with self.assertRaises(ValueError):
             shlex.split(None)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     @unittest.expectedFailure
     def testSplitPosix(self):
         """Test data splitting with posix parser"""
         self.splitTest(self.posix_data, comments=True)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     @unittest.expectedFailure
     def testCompat(self):
         """Test compatibility interface"""
@@ -315,7 +313,7 @@ def testEmptyStringHandling(self):
         s = shlex.shlex("'')abc", punctuation_chars=True)
         self.assertEqual(list(s), expected)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     @unittest.expectedFailure
     def testUnicodeHandling(self):
         """Test punctuation_chars and whitespace_split handle unicode."""
@@ -356,7 +354,7 @@ def testJoin(self):
                 joined = shlex.join(split_command)
                 self.assertEqual(joined, command)
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; ValueError: Error Retrieving Value
     @unittest.expectedFailure
     def testJoinRoundtrip(self):
         all_data = self.data + self.posix_data
diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py
index b64ccb37a5..0e97325562 100644
--- a/Lib/test/test_shutil.py
+++ b/Lib/test/test_shutil.py
@@ -23,7 +23,6 @@
                     unregister_unpack_format, get_unpack_formats,
                     SameFileError, _GiveupOnFastCopy)
 import tarfile
-import warnings
 import zipfile
 try:
     import posix
@@ -71,18 +70,17 @@ def wrap(*args, **kwargs):
             os.rename = builtin_rename
     return wrap
 
-def write_file(path, content, binary=False):
+def create_file(path, content=b''):
     """Write *content* to a file located at *path*.
 
     If *path* is a tuple instead of a string, os.path.join will be used to
-    make a path.  If *binary* is true, the file will be opened in binary
-    mode.
+    make a path.
     """
     if isinstance(path, tuple):
         path = os.path.join(*path)
-    mode = 'wb' if binary else 'w'
-    encoding = None if binary else "utf-8"
-    with open(path, mode, encoding=encoding) as fp:
+    if isinstance(content, str):
+        content = content.encode()
+    with open(path, 'xb') as fp:
         fp.write(content)
 
 def write_test_file(path, size):
@@ -191,12 +189,11 @@ def test_rmtree_works_on_bytes(self):
         tmp = self.mkdtemp()
         victim = os.path.join(tmp, 'killme')
         os.mkdir(victim)
-        write_file(os.path.join(victim, 'somefile'), 'foo')
+        create_file(os.path.join(victim, 'somefile'), 'foo')
         victim = os.fsencode(victim)
         self.assertIsInstance(victim, bytes)
         shutil.rmtree(victim)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_rmtree_fails_on_symlink_onerror(self):
         tmp = self.mkdtemp()
@@ -216,7 +213,6 @@ def onerror(*args):
         self.assertEqual(errors[0][1], link)
         self.assertIsInstance(errors[0][2][1], OSError)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_rmtree_fails_on_symlink_onexc(self):
         tmp = self.mkdtemp()
@@ -236,7 +232,6 @@ def onexc(*args):
         self.assertEqual(errors[0][1], link)
         self.assertIsInstance(errors[0][2], OSError)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_rmtree_works_on_symlinks(self):
         tmp = self.mkdtemp()
@@ -246,7 +241,7 @@ def test_rmtree_works_on_symlinks(self):
         for d in dir1, dir2, dir3:
             os.mkdir(d)
         file1 = os.path.join(tmp, 'file1')
-        write_file(file1, 'foo')
+        create_file(file1, 'foo')
         link1 = os.path.join(dir1, 'link1')
         os.symlink(dir2, link1)
         link2 = os.path.join(dir1, 'link2')
@@ -259,7 +254,6 @@ def test_rmtree_works_on_symlinks(self):
         self.assertTrue(os.path.exists(dir3))
         self.assertTrue(os.path.exists(file1))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(_winapi, 'only relevant on Windows')
     def test_rmtree_fails_on_junctions_onerror(self):
         tmp = self.mkdtemp()
@@ -280,7 +274,6 @@ def onerror(*args):
         self.assertEqual(errors[0][1], link)
         self.assertIsInstance(errors[0][2][1], OSError)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(_winapi, 'only relevant on Windows')
     def test_rmtree_fails_on_junctions_onexc(self):
         tmp = self.mkdtemp()
@@ -301,7 +294,6 @@ def onexc(*args):
         self.assertEqual(errors[0][1], link)
         self.assertIsInstance(errors[0][2], OSError)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(_winapi, 'only relevant on Windows')
     def test_rmtree_works_on_junctions(self):
         tmp = self.mkdtemp()
@@ -311,7 +303,7 @@ def test_rmtree_works_on_junctions(self):
         for d in dir1, dir2, dir3:
             os.mkdir(d)
         file1 = os.path.join(tmp, 'file1')
-        write_file(file1, 'foo')
+        create_file(file1, 'foo')
         link1 = os.path.join(dir1, 'link1')
         _winapi.CreateJunction(dir2, link1)
         link2 = os.path.join(dir1, 'link2')
@@ -324,7 +316,7 @@ def test_rmtree_works_on_junctions(self):
         self.assertTrue(os.path.exists(dir3))
         self.assertTrue(os.path.exists(file1))
 
-    def test_rmtree_errors_onerror(self):
+    def test_rmtree_errors(self):
         # filename is guaranteed not to exist
         filename = tempfile.mktemp(dir=self.mkdtemp())
         self.assertRaises(FileNotFoundError, shutil.rmtree, filename)
@@ -333,8 +325,8 @@ def test_rmtree_errors_onerror(self):
 
         # existing file
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, "tstfile"), "")
         filename = os.path.join(tmpdir, "tstfile")
+        create_file(filename)
         with self.assertRaises(NotADirectoryError) as cm:
             shutil.rmtree(filename)
         self.assertEqual(cm.exception.filename, filename)
@@ -342,6 +334,19 @@ def test_rmtree_errors_onerror(self):
         # test that ignore_errors option is honored
         shutil.rmtree(filename, ignore_errors=True)
         self.assertTrue(os.path.exists(filename))
+
+        self.assertRaises(TypeError, shutil.rmtree, None)
+        self.assertRaises(TypeError, shutil.rmtree, None, ignore_errors=True)
+        exc = TypeError if shutil.rmtree.avoids_symlink_attacks else NotImplementedError
+        with self.assertRaises(exc):
+            shutil.rmtree(filename, dir_fd='invalid')
+        with self.assertRaises(exc):
+            shutil.rmtree(filename, dir_fd='invalid', ignore_errors=True)
+
+    def test_rmtree_errors_onerror(self):
+        tmpdir = self.mkdtemp()
+        filename = os.path.join(tmpdir, "tstfile")
+        create_file(filename)
         errors = []
         def onerror(*args):
             errors.append(args)
@@ -357,23 +362,9 @@ def onerror(*args):
         self.assertEqual(errors[1][2][1].filename, filename)
 
     def test_rmtree_errors_onexc(self):
-        # filename is guaranteed not to exist
-        filename = tempfile.mktemp(dir=self.mkdtemp())
-        self.assertRaises(FileNotFoundError, shutil.rmtree, filename)
-        # test that ignore_errors option is honored
-        shutil.rmtree(filename, ignore_errors=True)
-
-        # existing file
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, "tstfile"), "")
         filename = os.path.join(tmpdir, "tstfile")
-        with self.assertRaises(NotADirectoryError) as cm:
-            shutil.rmtree(filename)
-        self.assertEqual(cm.exception.filename, filename)
-        self.assertTrue(os.path.exists(filename))
-        # test that ignore_errors option is honored
-        shutil.rmtree(filename, ignore_errors=True)
-        self.assertTrue(os.path.exists(filename))
+        create_file(filename)
         errors = []
         def onexc(*args):
             errors.append(args)
@@ -555,7 +546,7 @@ def raiser(fn, *args, **kwargs):
             os.lstat = raiser
 
             os.mkdir(TESTFN)
-            write_file((TESTFN, 'foo'), 'foo')
+            create_file((TESTFN, 'foo'), 'foo')
             shutil.rmtree(TESTFN)
         finally:
             os.lstat = orig_lstat
@@ -628,7 +619,7 @@ def test_rmtree_with_dir_fd(self):
         self.addCleanup(os.close, dir_fd)
         os.mkdir(fullname)
         os.mkdir(os.path.join(fullname, 'subdir'))
-        write_file(os.path.join(fullname, 'subdir', 'somefile'), 'foo')
+        create_file(os.path.join(fullname, 'subdir', 'somefile'), 'foo')
         self.assertTrue(os.path.exists(fullname))
         shutil.rmtree(victim, dir_fd=dir_fd)
         self.assertFalse(os.path.exists(fullname))
@@ -661,7 +652,6 @@ def test_rmtree_on_symlink(self):
         finally:
             shutil.rmtree(TESTFN, ignore_errors=True)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(_winapi, 'only relevant on Windows')
     def test_rmtree_on_junction(self):
         os.mkdir(TESTFN)
@@ -669,7 +659,7 @@ def test_rmtree_on_junction(self):
             src = os.path.join(TESTFN, 'cheese')
             dst = os.path.join(TESTFN, 'shop')
             os.mkdir(src)
-            open(os.path.join(src, 'spam'), 'wb').close()
+            create_file(os.path.join(src, 'spam'))
             _winapi.CreateJunction(src, dst)
             self.assertRaises(OSError, shutil.rmtree, dst)
             shutil.rmtree(dst, ignore_errors=True)
@@ -693,6 +683,73 @@ def test_rmtree_on_named_pipe(self):
         shutil.rmtree(TESTFN)
         self.assertFalse(os.path.exists(TESTFN))
 
+    @unittest.skipIf(sys.platform[:6] == 'cygwin',
+                     "This test can't be run on Cygwin (issue #1071513).")
+    @os_helper.skip_if_dac_override
+    @os_helper.skip_unless_working_chmod
+    def test_rmtree_deleted_race_condition(self):
+        # bpo-37260
+        #
+        # Test that a file or a directory deleted after it is enumerated
+        # by scandir() but before unlink() or rmdr() is called doesn't
+        # generate any errors.
+        def _onexc(fn, path, exc):
+            assert fn in (os.rmdir, os.unlink)
+            if not isinstance(exc, PermissionError):
+                raise
+            # Make the parent and the children writeable.
+            for p, mode in zip(paths, old_modes):
+                os.chmod(p, mode)
+            # Remove other dirs except one.
+            keep = next(p for p in dirs if p != path)
+            for p in dirs:
+                if p != keep:
+                    os.rmdir(p)
+            # Remove other files except one.
+            keep = next(p for p in files if p != path)
+            for p in files:
+                if p != keep:
+                    os.unlink(p)
+
+        os.mkdir(TESTFN)
+        paths = [TESTFN] + [os.path.join(TESTFN, f'child{i}')
+                            for i in range(6)]
+        dirs = paths[1::2]
+        files = paths[2::2]
+        for path in dirs:
+            os.mkdir(path)
+        for path in files:
+            create_file(path)
+
+        old_modes = [os.stat(path).st_mode for path in paths]
+
+        # Make the parent and the children non-writeable.
+        new_mode = stat.S_IREAD|stat.S_IEXEC
+        for path in reversed(paths):
+            os.chmod(path, new_mode)
+
+        try:
+            shutil.rmtree(TESTFN, onexc=_onexc)
+        except:
+            # Test failed, so cleanup artifacts.
+            for path, mode in zip(paths, old_modes):
+                try:
+                    os.chmod(path, mode)
+                except OSError:
+                    pass
+            shutil.rmtree(TESTFN)
+            raise
+
+    def test_rmtree_above_recursion_limit(self):
+        recursion_limit = 40
+        # directory_depth > recursion_limit
+        directory_depth = recursion_limit + 10
+        base = os.path.join(TESTFN, *(['d'] * directory_depth))
+        os.makedirs(base)
+
+        with support.infinite_recursion(recursion_limit):
+            shutil.rmtree(TESTFN)
+
 
 class TestCopyTree(BaseTest, unittest.TestCase):
 
@@ -701,9 +758,9 @@ def test_copytree_simple(self):
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
         self.addCleanup(shutil.rmtree, src_dir)
         self.addCleanup(shutil.rmtree, os.path.dirname(dst_dir))
-        write_file((src_dir, 'test.txt'), '123')
+        create_file((src_dir, 'test.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'test_dir'))
-        write_file((src_dir, 'test_dir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'test.txt'), '456')
 
         shutil.copytree(src_dir, dst_dir)
         self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'test.txt')))
@@ -721,11 +778,11 @@ def test_copytree_dirs_exist_ok(self):
         self.addCleanup(shutil.rmtree, src_dir)
         self.addCleanup(shutil.rmtree, dst_dir)
 
-        write_file((src_dir, 'nonexisting.txt'), '123')
+        create_file((src_dir, 'nonexisting.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'existing_dir'))
         os.mkdir(os.path.join(dst_dir, 'existing_dir'))
-        write_file((dst_dir, 'existing_dir', 'existing.txt'), 'will be replaced')
-        write_file((src_dir, 'existing_dir', 'existing.txt'), 'has been replaced')
+        create_file((dst_dir, 'existing_dir', 'existing.txt'), 'will be replaced')
+        create_file((src_dir, 'existing_dir', 'existing.txt'), 'has been replaced')
 
         shutil.copytree(src_dir, dst_dir, dirs_exist_ok=True)
         self.assertTrue(os.path.isfile(os.path.join(dst_dir, 'nonexisting.txt')))
@@ -740,7 +797,6 @@ def test_copytree_dirs_exist_ok(self):
         with self.assertRaises(FileExistsError):
             shutil.copytree(src_dir, dst_dir, dirs_exist_ok=False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copytree_symlinks(self):
         tmp_dir = self.mkdtemp()
@@ -749,7 +805,7 @@ def test_copytree_symlinks(self):
         sub_dir = os.path.join(src_dir, 'sub')
         os.mkdir(src_dir)
         os.mkdir(sub_dir)
-        write_file((src_dir, 'file.txt'), 'foo')
+        create_file((src_dir, 'file.txt'), 'foo')
         src_link = os.path.join(sub_dir, 'link')
         dst_link = os.path.join(dst_dir, 'sub/link')
         os.symlink(os.path.join(src_dir, 'file.txt'),
@@ -780,16 +836,16 @@ def test_copytree_with_exclude(self):
         src_dir = self.mkdtemp()
         try:
             dst_dir = join(self.mkdtemp(), 'destination')
-            write_file((src_dir, 'test.txt'), '123')
-            write_file((src_dir, 'test.tmp'), '123')
+            create_file((src_dir, 'test.txt'), '123')
+            create_file((src_dir, 'test.tmp'), '123')
             os.mkdir(join(src_dir, 'test_dir'))
-            write_file((src_dir, 'test_dir', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir', 'test.txt'), '456')
             os.mkdir(join(src_dir, 'test_dir2'))
-            write_file((src_dir, 'test_dir2', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir2', 'test.txt'), '456')
             os.mkdir(join(src_dir, 'test_dir2', 'subdir'))
             os.mkdir(join(src_dir, 'test_dir2', 'subdir2'))
-            write_file((src_dir, 'test_dir2', 'subdir', 'test.txt'), '456')
-            write_file((src_dir, 'test_dir2', 'subdir2', 'test.py'), '456')
+            create_file((src_dir, 'test_dir2', 'subdir', 'test.txt'), '456')
+            create_file((src_dir, 'test_dir2', 'subdir2', 'test.py'), '456')
 
             # testing glob-like patterns
             try:
@@ -848,7 +904,7 @@ def test_copytree_arg_types_of_ignore(self):
         os.mkdir(join(src_dir))
         os.mkdir(join(src_dir, 'test_dir'))
         os.mkdir(os.path.join(src_dir, 'test_dir', 'subdir'))
-        write_file((src_dir, 'test_dir', 'subdir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'subdir', 'test.txt'), '456')
 
         invokations = []
 
@@ -867,7 +923,7 @@ def _ignore(src, names):
                                     'test.txt')))
 
         dst_dir = join(self.mkdtemp(), 'destination')
-        shutil.copytree(pathlib.Path(src_dir), dst_dir, ignore=_ignore)
+        shutil.copytree(FakePath(src_dir), dst_dir, ignore=_ignore)
         self.assertTrue(exists(join(dst_dir, 'test_dir', 'subdir',
                                     'test.txt')))
 
@@ -888,9 +944,9 @@ def test_copytree_retains_permissions(self):
         self.addCleanup(shutil.rmtree, tmp_dir)
 
         os.chmod(src_dir, 0o777)
-        write_file((src_dir, 'permissive.txt'), '123')
+        create_file((src_dir, 'permissive.txt'), '123')
         os.chmod(os.path.join(src_dir, 'permissive.txt'), 0o777)
-        write_file((src_dir, 'restrictive.txt'), '456')
+        create_file((src_dir, 'restrictive.txt'), '456')
         os.chmod(os.path.join(src_dir, 'restrictive.txt'), 0o600)
         restrictive_subdir = tempfile.mkdtemp(dir=src_dir)
         self.addCleanup(os_helper.rmtree, restrictive_subdir)
@@ -933,8 +989,7 @@ def custom_cpfun(a, b):
         flag = []
         src = self.mkdtemp()
         dst = tempfile.mktemp(dir=self.mkdtemp())
-        with open(os.path.join(src, 'foo'), 'w', encoding='utf-8') as f:
-            f.close()
+        create_file(os.path.join(src, 'foo'))
         shutil.copytree(src, dst, copy_function=custom_cpfun)
         self.assertEqual(len(flag), 1)
 
@@ -969,9 +1024,9 @@ def test_copytree_named_pipe(self):
     def test_copytree_special_func(self):
         src_dir = self.mkdtemp()
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
-        write_file((src_dir, 'test.txt'), '123')
+        create_file((src_dir, 'test.txt'), '123')
         os.mkdir(os.path.join(src_dir, 'test_dir'))
-        write_file((src_dir, 'test_dir', 'test.txt'), '456')
+        create_file((src_dir, 'test_dir', 'test.txt'), '456')
 
         copied = []
         def _copy(src, dst):
@@ -980,12 +1035,11 @@ def _copy(src, dst):
         shutil.copytree(src_dir, dst_dir, copy_function=_copy)
         self.assertEqual(len(copied), 2)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copytree_dangling_symlinks(self):
         src_dir = self.mkdtemp()
         valid_file = os.path.join(src_dir, 'test.txt')
-        write_file(valid_file, 'abc')
+        create_file(valid_file, 'abc')
         dir_a = os.path.join(src_dir, 'dir_a')
         os.mkdir(dir_a)
         for d in src_dir, dir_a:
@@ -1008,14 +1062,12 @@ def test_copytree_dangling_symlinks(self):
         shutil.copytree(src_dir, dst_dir, symlinks=True)
         self.assertIn('test.txt', os.listdir(dst_dir))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copytree_symlink_dir(self):
         src_dir = self.mkdtemp()
         dst_dir = os.path.join(self.mkdtemp(), 'destination')
         os.mkdir(os.path.join(src_dir, 'real_dir'))
-        with open(os.path.join(src_dir, 'real_dir', 'test.txt'), 'wb'):
-            pass
+        create_file(os.path.join(src_dir, 'real_dir', 'test.txt'))
         os.symlink(os.path.join(src_dir, 'real_dir'),
                    os.path.join(src_dir, 'link_to_dir'),
                    target_is_directory=True)
@@ -1035,7 +1087,7 @@ def test_copytree_return_value(self):
         dst_dir = src_dir + "dest"
         self.addCleanup(shutil.rmtree, dst_dir, True)
         src = os.path.join(src_dir, 'foo')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         rv = shutil.copytree(src_dir, dst_dir)
         self.assertEqual(['foo'], os.listdir(rv))
 
@@ -1047,7 +1099,7 @@ def test_copytree_subdirectory(self):
         dst_dir = os.path.join(src_dir, "somevendor", "1.0")
         os.makedirs(src_dir)
         src = os.path.join(src_dir, 'pol')
-        write_file(src, 'pol')
+        create_file(src, 'pol')
         rv = shutil.copytree(src_dir, dst_dir)
         self.assertEqual(['pol'], os.listdir(rv))
 
@@ -1055,7 +1107,6 @@ class TestCopy(BaseTest, unittest.TestCase):
 
     ### shutil.copymode
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copymode_follow_symlinks(self):
         tmp_dir = self.mkdtemp()
@@ -1063,8 +1114,8 @@ def test_copymode_follow_symlinks(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         os.chmod(src, stat.S_IRWXU|stat.S_IRWXG)
@@ -1087,36 +1138,34 @@ def test_copymode_follow_symlinks(self):
         shutil.copymode(src_link, dst_link)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
-    @unittest.skipUnless(hasattr(os, 'lchmod') or os.name == 'nt', 'requires os.lchmod')
+    @unittest.skipUnless(hasattr(os, 'lchmod'), 'requires os.lchmod')
     @os_helper.skip_unless_symlink
     def test_copymode_symlink_to_symlink(self):
-        _lchmod = os.chmod if os.name == 'nt' else os.lchmod
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         os.chmod(src, stat.S_IRWXU|stat.S_IRWXG)
         os.chmod(dst, stat.S_IRWXU)
-        _lchmod(src_link, stat.S_IRWXO|stat.S_IRWXG)
+        os.lchmod(src_link, stat.S_IRWXO|stat.S_IRWXG)
         # link to link
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         old_mode = os.stat(dst).st_mode
         shutil.copymode(src_link, dst_link, follow_symlinks=False)
         self.assertEqual(os.lstat(src_link).st_mode,
                          os.lstat(dst_link).st_mode)
         self.assertEqual(os.stat(dst).st_mode, old_mode)
         # src link - use chmod
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         shutil.copymode(src_link, dst, follow_symlinks=False)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
         # dst link - use chmod
-        _lchmod(dst_link, stat.S_IRWXO)
+        os.lchmod(dst_link, stat.S_IRWXO)
         shutil.copymode(src, dst_link, follow_symlinks=False)
         self.assertEqual(os.stat(src).st_mode, os.stat(dst).st_mode)
 
@@ -1128,15 +1177,14 @@ def test_copymode_symlink_to_symlink_wo_lchmod(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'quux')
-        write_file(src, 'foo')
-        write_file(dst, 'foo')
+        create_file(src, 'foo')
+        create_file(dst, 'foo')
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         shutil.copymode(src_link, dst_link, follow_symlinks=False)  # silent fail
 
     ### shutil.copystat
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copystat_symlinks(self):
         tmp_dir = self.mkdtemp()
@@ -1144,23 +1192,21 @@ def test_copystat_symlinks(self):
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
         dst_link = os.path.join(tmp_dir, 'qux')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         src_stat = os.stat(src)
         os.utime(src, (src_stat.st_atime,
                        src_stat.st_mtime - 42.0))  # ensure different mtimes
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         self.assertNotEqual(os.stat(src).st_mtime, os.stat(dst).st_mtime)
         os.symlink(src, src_link)
         os.symlink(dst, dst_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXO)
-        elif os.name == 'nt':
-            os.chmod(src_link, stat.S_IRWXO)
         if hasattr(os, 'lchflags') and hasattr(stat, 'UF_NODUMP'):
             os.lchflags(src_link, stat.UF_NODUMP)
         src_link_stat = os.lstat(src_link)
         # follow
-        if hasattr(os, 'lchmod') or os.name == 'nt':
+        if hasattr(os, 'lchmod'):
             shutil.copystat(src_link, dst_link, follow_symlinks=True)
             self.assertNotEqual(src_link_stat.st_mode, os.stat(dst).st_mode)
         # don't follow
@@ -1171,7 +1217,7 @@ def test_copystat_symlinks(self):
                 # The modification times may be truncated in the new file.
                 self.assertLessEqual(getattr(src_link_stat, attr),
                                      getattr(dst_link_stat, attr) + 1)
-        if hasattr(os, 'lchmod') or os.name == 'nt':
+        if hasattr(os, 'lchmod'):
             self.assertEqual(src_link_stat.st_mode, dst_link_stat.st_mode)
         if hasattr(os, 'lchflags') and hasattr(src_link_stat, 'st_flags'):
             self.assertEqual(src_link_stat.st_flags, dst_link_stat.st_flags)
@@ -1188,8 +1234,8 @@ def test_copystat_handles_harmless_chflags_errors(self):
         tmpdir = self.mkdtemp()
         file1 = os.path.join(tmpdir, 'file1')
         file2 = os.path.join(tmpdir, 'file2')
-        write_file(file1, 'xxx')
-        write_file(file2, 'xxx')
+        create_file(file1, 'xxx')
+        create_file(file2, 'xxx')
 
         def make_chflags_raiser(err):
             ex = OSError()
@@ -1215,9 +1261,9 @@ def _chflags_raiser(path, flags, *, follow_symlinks=True):
     def test_copyxattr(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
 
         # no xattr == no problem
         shutil._copyxattr(src, dst)
@@ -1231,7 +1277,7 @@ def test_copyxattr(self):
                 os.getxattr(dst, 'user.foo'))
         # check errors don't affect other attrs
         os.remove(dst)
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         os_error = OSError(errno.EPERM, 'EPERM')
 
         def _raise_on_user_foo(fname, attr, val, **kwargs):
@@ -1261,15 +1307,15 @@ def _raise_on_src(fname, *, follow_symlinks=True):
         # test that shutil.copystat copies xattrs
         src = os.path.join(tmp_dir, 'the_original')
         srcro = os.path.join(tmp_dir, 'the_original_ro')
-        write_file(src, src)
-        write_file(srcro, srcro)
+        create_file(src, src)
+        create_file(srcro, srcro)
         os.setxattr(src, 'user.the_value', b'fiddly')
         os.setxattr(srcro, 'user.the_value', b'fiddly')
         os.chmod(srcro, 0o444)
         dst = os.path.join(tmp_dir, 'the_copy')
         dstro = os.path.join(tmp_dir, 'the_copy_ro')
-        write_file(dst, dst)
-        write_file(dstro, dstro)
+        create_file(dst, dst)
+        create_file(dstro, dstro)
         shutil.copystat(src, dst)
         shutil.copystat(srcro, dstro)
         self.assertEqual(os.getxattr(dst, 'user.the_value'), b'fiddly')
@@ -1285,13 +1331,13 @@ def test_copyxattr_symlinks(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         os.setxattr(src, 'trusted.foo', b'42')
         os.setxattr(src_link, 'trusted.foo', b'43', follow_symlinks=False)
         dst = os.path.join(tmp_dir, 'bar')
         dst_link = os.path.join(tmp_dir, 'qux')
-        write_file(dst, 'bar')
+        create_file(dst, 'bar')
         os.symlink(dst, dst_link)
         shutil._copyxattr(src_link, dst_link, follow_symlinks=False)
         self.assertEqual(os.getxattr(dst_link, 'trusted.foo', follow_symlinks=False), b'43')
@@ -1304,7 +1350,7 @@ def test_copyxattr_symlinks(self):
     def _copy_file(self, method):
         fname = 'test.txt'
         tmpdir = self.mkdtemp()
-        write_file((tmpdir, fname), 'xxx')
+        create_file((tmpdir, fname), 'xxx')
         file1 = os.path.join(tmpdir, fname)
         tmpdir2 = self.mkdtemp()
         method(file1, tmpdir2)
@@ -1317,14 +1363,13 @@ def test_copy(self):
         self.assertTrue(os.path.exists(file2))
         self.assertEqual(os.stat(file1).st_mode, os.stat(file2).st_mode)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copy_symlinks(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
@@ -1360,14 +1405,13 @@ def test_copy2(self):
             self.assertEqual(getattr(file1_stat, 'st_flags'),
                              getattr(file2_stat, 'st_flags'))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copy2_symlinks(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
         src_link = os.path.join(tmp_dir, 'baz')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, src_link)
         if hasattr(os, 'lchmod'):
             os.lchmod(src_link, stat.S_IRWXU | stat.S_IRWXO)
@@ -1401,7 +1445,7 @@ def test_copy2_xattr(self):
         tmp_dir = self.mkdtemp()
         src = os.path.join(tmp_dir, 'foo')
         dst = os.path.join(tmp_dir, 'bar')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.setxattr(src, 'user.foo', b'42')
         shutil.copy2(src, dst)
         self.assertEqual(
@@ -1415,7 +1459,7 @@ def test_copy_return_value(self):
             src_dir = self.mkdtemp()
             dst_dir = self.mkdtemp()
             src = os.path.join(src_dir, 'foo')
-            write_file(src, 'foo')
+            create_file(src, 'foo')
             rv = fn(src, dst_dir)
             self.assertEqual(rv, os.path.join(dst_dir, 'foo'))
             rv = fn(src, os.path.join(dst_dir, 'bar'))
@@ -1432,7 +1476,7 @@ def _test_copy_dir(self, copy_func):
         src_file = os.path.join(src_dir, 'foo')
         dir2 = self.mkdtemp()
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         if sys.platform == "win32":
             err = PermissionError
         else:
@@ -1445,7 +1489,6 @@ def _test_copy_dir(self, copy_func):
 
     ### shutil.copyfile
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_copyfile_symlinks(self):
         tmp_dir = self.mkdtemp()
@@ -1453,7 +1496,7 @@ def test_copyfile_symlinks(self):
         dst = os.path.join(tmp_dir, 'dst')
         dst_link = os.path.join(tmp_dir, 'dst_link')
         link = os.path.join(tmp_dir, 'link')
-        write_file(src, 'foo')
+        create_file(src, 'foo')
         os.symlink(src, link)
         # don't follow
         shutil.copyfile(link, dst_link, follow_symlinks=False)
@@ -1470,8 +1513,7 @@ def test_dont_copy_file_onto_link_to_itself(self):
         src = os.path.join(TESTFN, 'cheese')
         dst = os.path.join(TESTFN, 'shop')
         try:
-            with open(src, 'w', encoding='utf-8') as f:
-                f.write('cheddar')
+            create_file(src, 'cheddar')
             try:
                 os.link(src, dst)
             except PermissionError as e:
@@ -1490,8 +1532,7 @@ def test_dont_copy_file_onto_symlink_to_itself(self):
         src = os.path.join(TESTFN, 'cheese')
         dst = os.path.join(TESTFN, 'shop')
         try:
-            with open(src, 'w', encoding='utf-8') as f:
-                f.write('cheddar')
+            create_file(src, 'cheddar')
             # Using `src` here would mean we end up with a symlink pointing
             # to TESTFN/TESTFN/cheese, while it should point at
             # TESTFN/cheese.
@@ -1526,7 +1567,7 @@ def test_copyfile_return_value(self):
         dst_dir = self.mkdtemp()
         dst_file = os.path.join(dst_dir, 'bar')
         src_file = os.path.join(src_dir, 'foo')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         rv = shutil.copyfile(src_file, dst_file)
         self.assertTrue(os.path.exists(rv))
         self.assertEqual(read_file(src_file), read_file(dst_file))
@@ -1536,7 +1577,7 @@ def test_copyfile_same_file(self):
         # are the same.
         src_dir = self.mkdtemp()
         src_file = os.path.join(src_dir, 'foo')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         self.assertRaises(SameFileError, shutil.copyfile, src_file, src_file)
         # But Error should work too, to stay backward compatible.
         self.assertRaises(Error, shutil.copyfile, src_file, src_file)
@@ -1553,7 +1594,7 @@ def test_copyfile_nonexistent_dir(self):
         src_dir = self.mkdtemp()
         src_file = os.path.join(src_dir, 'foo')
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         self.assertRaises(FileNotFoundError, shutil.copyfile, src_file, dst)
 
     def test_copyfile_copy_dir(self):
@@ -1564,7 +1605,7 @@ def test_copyfile_copy_dir(self):
         src_file = os.path.join(src_dir, 'foo')
         dir2 = self.mkdtemp()
         dst = os.path.join(src_dir, 'does_not_exist/')
-        write_file(src_file, 'foo')
+        create_file(src_file, 'foo')
         if sys.platform == "win32":
             err = PermissionError
         else:
@@ -1579,42 +1620,6 @@ class TestArchives(BaseTest, unittest.TestCase):
 
     ### shutil.make_archive
 
-    @support.requires_zlib()
-    def test_make_tarball(self):
-        # creating something to tar
-        root_dir, base_dir = self._create_files('')
-
-        tmpdir2 = self.mkdtemp()
-        # force shutil to create the directory
-        os.rmdir(tmpdir2)
-        # working with relative paths
-        work_dir = os.path.dirname(tmpdir2)
-        rel_base_name = os.path.join(os.path.basename(tmpdir2), 'archive')
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            tarball = make_archive(rel_base_name, 'gztar', root_dir, '.')
-
-        # check if the compressed tarball was created
-        self.assertEqual(tarball, base_name + '.tar.gz')
-        self.assertTrue(os.path.isfile(tarball))
-        self.assertTrue(tarfile.is_tarfile(tarball))
-        with tarfile.open(tarball, 'r:gz') as tf:
-            self.assertCountEqual(tf.getnames(),
-                                  ['.', './sub', './sub2',
-                                   './file1', './file2', './sub/file3'])
-
-        # trying an uncompressed one
-        with os_helper.change_cwd(work_dir), no_chdir:
-            tarball = make_archive(rel_base_name, 'tar', root_dir, '.')
-        self.assertEqual(tarball, base_name + '.tar')
-        self.assertTrue(os.path.isfile(tarball))
-        self.assertTrue(tarfile.is_tarfile(tarball))
-        with tarfile.open(tarball, 'r') as tf:
-            self.assertCountEqual(tf.getnames(),
-                                  ['.', './sub', './sub2',
-                                  './file1', './file2', './sub/file3'])
-
     def _tarinfo(self, path):
         with tarfile.open(path) as tar:
             names = tar.getnames()
@@ -1626,15 +1631,101 @@ def _create_files(self, base_dir='dist'):
         root_dir = self.mkdtemp()
         dist = os.path.join(root_dir, base_dir)
         os.makedirs(dist, exist_ok=True)
-        write_file((dist, 'file1'), 'xxx')
-        write_file((dist, 'file2'), 'xxx')
+        create_file((dist, 'file1'), 'xxx')
+        create_file((dist, 'file2'), 'xxx')
         os.mkdir(os.path.join(dist, 'sub'))
-        write_file((dist, 'sub', 'file3'), 'xxx')
+        create_file((dist, 'sub', 'file3'), 'xxx')
         os.mkdir(os.path.join(dist, 'sub2'))
         if base_dir:
-            write_file((root_dir, 'outer'), 'xxx')
+            create_file((root_dir, 'outer'), 'xxx')
         return root_dir, base_dir
 
+    @support.requires_zlib()
+    def test_make_tarfile(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir)
+            # check if the compressed tarball was created
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
+        # Test with base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst2', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir, base_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            # check if the uncompressed tarball was created
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist', 'dist/sub', 'dist/sub2',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+        # Test with multi-component base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst3', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir,
+                                   os.path.join(base_dir, 'sub'))
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist/sub', 'dist/sub/file3'])
+
+    @support.requires_zlib()
+    def test_make_tarfile_without_rootdir(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        base_name = os.path.join(self.mkdtemp(), 'dst', 'archive')
+        base_name = os.path.relpath(base_name, root_dir)
+        with os_helper.change_cwd(root_dir), no_chdir:
+            archive = make_archive(base_name, 'gztar')
+            self.assertEqual(archive, base_name + '.tar.gz')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r:gz') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
+        # Test with base_dir.
+        with os_helper.change_cwd(root_dir), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', base_dir=base_dir)
+            self.assertEqual(archive, base_name + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['dist', 'dist/sub', 'dist/sub2',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+    def test_make_tarfile_with_explicit_curdir(self):
+        # Test with base_dir=os.curdir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'tar', root_dir, os.curdir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.tar')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(tarfile.is_tarfile(archive))
+            with tarfile.open(archive, 'r') as tf:
+                self.assertCountEqual(tf.getnames(),
+                        ['.', './dist', './dist/sub', './dist/sub2',
+                         './dist/file1', './dist/file2', './dist/sub/file3',
+                         './outer'])
+
     @support.requires_zlib()
     @unittest.skipUnless(shutil.which('tar'),
                          'Need the tar command to run')
@@ -1684,40 +1775,89 @@ def test_tarfile_vs_tar(self):
 
     @support.requires_zlib()
     def test_make_zipfile(self):
-        # creating something to zip
         root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
+
+        # Test with base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst2', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir, base_dir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
+
+        # Test with multi-component base_dir.
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst3', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir,
+                                   os.path.join(base_dir, 'sub'))
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/sub/', 'dist/sub/file3'])
 
-        tmpdir2 = self.mkdtemp()
-        # force shutil to create the directory
-        os.rmdir(tmpdir2)
-        # working with relative paths
-        work_dir = os.path.dirname(tmpdir2)
-        rel_base_name = os.path.join(os.path.basename(tmpdir2), 'archive')
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            res = make_archive(rel_base_name, 'zip', root_dir)
+    @support.requires_zlib()
+    def test_make_zipfile_without_rootdir(self):
+        root_dir, base_dir = self._create_files()
+        # Test without base_dir.
+        base_name = os.path.join(self.mkdtemp(), 'dst', 'archive')
+        base_name = os.path.relpath(base_name, root_dir)
+        with os_helper.change_cwd(root_dir), no_chdir:
+            archive = make_archive(base_name, 'zip')
+            self.assertEqual(archive, base_name + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
+
+        # Test with base_dir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.change_cwd(root_dir), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', base_dir=base_dir)
+            self.assertEqual(archive, base_name + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3'])
 
-        self.assertEqual(res, base_name + '.zip')
-        self.assertTrue(os.path.isfile(res))
-        self.assertTrue(zipfile.is_zipfile(res))
-        with zipfile.ZipFile(res) as zf:
-            self.assertCountEqual(zf.namelist(),
-                    ['dist/', 'dist/sub/', 'dist/sub2/',
-                     'dist/file1', 'dist/file2', 'dist/sub/file3',
-                     'outer'])
-
-        with os_helper.change_cwd(work_dir), no_chdir:
-            base_name = os.path.abspath(rel_base_name)
-            res = make_archive(rel_base_name, 'zip', root_dir, base_dir)
-
-        self.assertEqual(res, base_name + '.zip')
-        self.assertTrue(os.path.isfile(res))
-        self.assertTrue(zipfile.is_zipfile(res))
-        with zipfile.ZipFile(res) as zf:
-            self.assertCountEqual(zf.namelist(),
-                    ['dist/', 'dist/sub/', 'dist/sub2/',
-                     'dist/file1', 'dist/file2', 'dist/sub/file3'])
+    @support.requires_zlib()
+    def test_make_zipfile_with_explicit_curdir(self):
+        # Test with base_dir=os.curdir.
+        root_dir, base_dir = self._create_files()
+        with os_helper.temp_cwd(), no_chdir:
+            base_name = os.path.join('dst', 'archive')
+            archive = make_archive(base_name, 'zip', root_dir, os.curdir)
+            self.assertEqual(archive, os.path.abspath(base_name) + '.zip')
+            self.assertTrue(os.path.isfile(archive))
+            self.assertTrue(zipfile.is_zipfile(archive))
+            with zipfile.ZipFile(archive) as zf:
+                self.assertCountEqual(zf.namelist(),
+                        ['dist/', 'dist/sub/', 'dist/sub2/',
+                         'dist/file1', 'dist/file2', 'dist/sub/file3',
+                         'outer'])
 
     @support.requires_zlib()
     @unittest.skipUnless(shutil.which('zip'),
@@ -1766,7 +1906,10 @@ def test_unzip_zipfile(self):
                 subprocess.check_output(zip_cmd, stderr=subprocess.STDOUT)
             except subprocess.CalledProcessError as exc:
                 details = exc.output.decode(errors="replace")
-                if 'unrecognized option: t' in details:
+                if any(message in details for message in [
+                    'unrecognized option: t',  # BusyBox
+                    'invalid option -- t',  # Android
+                ]):
                     self.skipTest("unzip doesn't support -t")
                 msg = "{}\n\n**Unzip Output**\n{}"
                 self.fail(msg.format(exc, details))
@@ -1887,17 +2030,19 @@ def archiver(base_name, base_dir, **kw):
             unregister_archive_format('xxx')
 
     def test_make_tarfile_in_curdir(self):
-        # Issue #21280
+        # Issue #21280: Test with the archive in the current directory.
         root_dir = self.mkdtemp()
         with os_helper.change_cwd(root_dir), no_chdir:
+            # root_dir must be None, so the archive path is relative.
             self.assertEqual(make_archive('test', 'tar'), 'test.tar')
             self.assertTrue(os.path.isfile('test.tar'))
 
     @support.requires_zlib()
     def test_make_zipfile_in_curdir(self):
-        # Issue #21280
+        # Issue #21280: Test with the archive in the current directory.
         root_dir = self.mkdtemp()
         with os_helper.change_cwd(root_dir), no_chdir:
+            # root_dir must be None, so the archive path is relative.
             self.assertEqual(make_archive('test', 'zip'), 'test.zip')
             self.assertTrue(os.path.isfile('test.zip'))
 
@@ -1918,10 +2063,11 @@ def test_register_archive_format(self):
         self.assertNotIn('xxx', formats)
 
     def test_make_tarfile_rootdir_nodir(self):
-        # GH-99203
+        # GH-99203: Test with root_dir is not a real directory.
         self.addCleanup(os_helper.unlink, f'{TESTFN}.tar')
         for dry_run in (False, True):
             with self.subTest(dry_run=dry_run):
+                # root_dir does not exist.
                 tmp_dir = self.mkdtemp()
                 nonexisting_file = os.path.join(tmp_dir, 'nonexisting')
                 with self.assertRaises(FileNotFoundError) as cm:
@@ -1930,6 +2076,7 @@ def test_make_tarfile_rootdir_nodir(self):
                 self.assertEqual(cm.exception.filename, nonexisting_file)
                 self.assertFalse(os.path.exists(f'{TESTFN}.tar'))
 
+                # root_dir is a file.
                 tmp_fd, tmp_file = tempfile.mkstemp(dir=tmp_dir)
                 os.close(tmp_fd)
                 with self.assertRaises(NotADirectoryError) as cm:
@@ -1940,10 +2087,11 @@ def test_make_tarfile_rootdir_nodir(self):
 
     @support.requires_zlib()
     def test_make_zipfile_rootdir_nodir(self):
-        # GH-99203
+        # GH-99203: Test with root_dir is not a real directory.
         self.addCleanup(os_helper.unlink, f'{TESTFN}.zip')
         for dry_run in (False, True):
             with self.subTest(dry_run=dry_run):
+                # root_dir does not exist.
                 tmp_dir = self.mkdtemp()
                 nonexisting_file = os.path.join(tmp_dir, 'nonexisting')
                 with self.assertRaises(FileNotFoundError) as cm:
@@ -1952,6 +2100,7 @@ def test_make_zipfile_rootdir_nodir(self):
                 self.assertEqual(cm.exception.filename, nonexisting_file)
                 self.assertFalse(os.path.exists(f'{TESTFN}.zip'))
 
+                # root_dir is a file.
                 tmp_fd, tmp_file = tempfile.mkstemp(dir=tmp_dir)
                 os.close(tmp_fd)
                 with self.assertRaises(NotADirectoryError) as cm:
@@ -1966,7 +2115,7 @@ def check_unpack_archive(self, format, **kwargs):
         self.check_unpack_archive_with_converter(
             format, lambda path: path, **kwargs)
         self.check_unpack_archive_with_converter(
-            format, pathlib.Path, **kwargs)
+            format, FakePath, **kwargs)
         self.check_unpack_archive_with_converter(format, FakePath, **kwargs)
 
     def check_unpack_archive_with_converter(self, format, converter, **kwargs):
@@ -2071,7 +2220,9 @@ def test_disk_usage(self):
     def test_chown(self):
         dirname = self.mkdtemp()
         filename = tempfile.mktemp(dir=dirname)
-        write_file(filename, 'testing chown function')
+        linkname = os.path.join(dirname, "chown_link")
+        create_file(filename, 'testing chown function')
+        os.symlink(filename, linkname)
 
         with self.assertRaises(ValueError):
             shutil.chown(filename)
@@ -2092,7 +2243,7 @@ def test_chown(self):
         gid = os.getgid()
 
         def check_chown(path, uid=None, gid=None):
-            s = os.stat(filename)
+            s = os.stat(path)
             if uid is not None:
                 self.assertEqual(uid, s.st_uid)
             if gid is not None:
@@ -2128,41 +2279,76 @@ def check_chown(path, uid=None, gid=None):
             shutil.chown(dirname, user, group)
             check_chown(dirname, uid, gid)
 
+        dirfd = os.open(dirname, os.O_RDONLY)
+        self.addCleanup(os.close, dirfd)
+        basename = os.path.basename(filename)
+        baselinkname = os.path.basename(linkname)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd)
+        check_chown(filename, uid, gid)
+        shutil.chown(basename, uid, dir_fd=dirfd)
+        check_chown(filename, uid)
+        shutil.chown(basename, group=gid, dir_fd=dirfd)
+        check_chown(filename, gid=gid)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd, follow_symlinks=True)
+        check_chown(filename, uid, gid)
+        shutil.chown(basename, uid, gid, dir_fd=dirfd, follow_symlinks=False)
+        check_chown(filename, uid, gid)
+        shutil.chown(linkname, uid, follow_symlinks=True)
+        check_chown(filename, uid)
+        shutil.chown(baselinkname, group=gid, dir_fd=dirfd, follow_symlinks=False)
+        check_chown(filename, gid=gid)
+        shutil.chown(baselinkname, uid, gid, dir_fd=dirfd, follow_symlinks=True)
+        check_chown(filename, uid, gid)
+
+        with self.assertRaises(TypeError):
+            shutil.chown(filename, uid, dir_fd=dirname)
+
+        with self.assertRaises(FileNotFoundError):
+            shutil.chown('missingfile', uid, gid, dir_fd=dirfd)
+
+        with self.assertRaises(ValueError):
+            shutil.chown(filename, dir_fd=dirfd)
+
 
+@support.requires_subprocess()
 class TestWhich(BaseTest, unittest.TestCase):
 
     def setUp(self):
-        self.temp_dir = self.mkdtemp(prefix="Tmp")
+        temp_dir = self.mkdtemp(prefix="Tmp")
+        base_dir = os.path.join(temp_dir, TESTFN + '-basedir')
+        os.mkdir(base_dir)
+        self.dir = os.path.join(base_dir, TESTFN + '-dir')
+        os.mkdir(self.dir)
+        self.other_dir = os.path.join(base_dir, TESTFN + '-dir2')
+        os.mkdir(self.other_dir)
         # Give the temp_file an ".exe" suffix for all.
         # It's needed on Windows and not harmful on other platforms.
-        self.temp_file = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                     prefix="Tmp",
-                                                     suffix=".Exe")
-        os.chmod(self.temp_file.name, stat.S_IXUSR)
-        self.addCleanup(self.temp_file.close)
-        self.dir, self.file = os.path.split(self.temp_file.name)
+        self.file = TESTFN + '.Exe'
+        self.filepath = os.path.join(self.dir, self.file)
+        self.create_file(self.filepath)
         self.env_path = self.dir
         self.curdir = os.curdir
         self.ext = ".EXE"
 
-    def to_text_type(self, s):
-        '''
-        In this class we're testing with str, so convert s to a str
-        '''
-        if isinstance(s, bytes):
-            return s.decode()
-        return s
+    to_text_type = staticmethod(os.fsdecode)
+
+    def create_file(self, path):
+        create_file(path)
+        os.chmod(path, 0o755)
+
+    def assertNormEqual(self, actual, expected):
+        self.assertEqual(os.path.normcase(actual), os.path.normcase(expected))
 
     def test_basic(self):
         # Given an EXE in a directory, it should be returned.
         rv = shutil.which(self.file, path=self.dir)
-        self.assertEqual(rv, self.temp_file.name)
+        self.assertEqual(rv, self.filepath)
 
     def test_absolute_cmd(self):
         # When given the fully qualified path to an executable that exists,
         # it should be returned.
-        rv = shutil.which(self.temp_file.name, path=self.temp_dir)
-        self.assertEqual(rv, self.temp_file.name)
+        rv = shutil.which(self.filepath, path=self.other_dir)
+        self.assertEqual(rv, self.filepath)
 
     def test_relative_cmd(self):
         # When given the relative path with a directory part to an executable
@@ -2170,7 +2356,7 @@ def test_relative_cmd(self):
         base_dir, tail_dir = os.path.split(self.dir)
         relpath = os.path.join(tail_dir, self.file)
         with os_helper.change_cwd(path=base_dir):
-            rv = shutil.which(relpath, path=self.temp_dir)
+            rv = shutil.which(relpath, path=self.other_dir)
             self.assertEqual(rv, relpath)
         # But it shouldn't be searched in PATH directories (issue #16957).
         with os_helper.change_cwd(path=self.dir):
@@ -2181,9 +2367,8 @@ def test_relative_cmd(self):
                          "test is for non win32")
     def test_cwd_non_win32(self):
         # Issue #16957
-        base_dir = os.path.dirname(self.dir)
         with os_helper.change_cwd(path=self.dir):
-            rv = shutil.which(self.file, path=base_dir)
+            rv = shutil.which(self.file, path=self.other_dir)
             # non-win32: shouldn't match in the current directory.
             self.assertIsNone(rv)
 
@@ -2193,57 +2378,32 @@ def test_cwd_win32(self):
         base_dir = os.path.dirname(self.dir)
         with os_helper.change_cwd(path=self.dir):
             with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
-                rv = shutil.which(self.file, path=base_dir)
+                rv = shutil.which(self.file, path=self.other_dir)
                 # Current directory implicitly on PATH
                 self.assertEqual(rv, os.path.join(self.curdir, self.file))
             with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=False):
-                rv = shutil.which(self.file, path=base_dir)
+                rv = shutil.which(self.file, path=self.other_dir)
                 # Current directory not on PATH
                 self.assertIsNone(rv)
 
     @unittest.skipUnless(sys.platform == "win32",
                          "test is for win32")
     def test_cwd_win32_added_before_all_other_path(self):
-        base_dir = pathlib.Path(os.fsdecode(self.dir))
-
-        elsewhere_in_path_dir = base_dir / 'dir1'
-        elsewhere_in_path_dir.mkdir()
-        match_elsewhere_in_path = elsewhere_in_path_dir / 'hello.exe'
-        match_elsewhere_in_path.touch()
-
-        exe_in_cwd = base_dir / 'hello.exe'
-        exe_in_cwd.touch()
-
-        with os_helper.change_cwd(path=base_dir):
-            with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
-                rv = shutil.which('hello.exe', path=elsewhere_in_path_dir)
-
-            self.assertEqual(os.path.abspath(rv), os.path.abspath(exe_in_cwd))
-
-    @unittest.skipUnless(sys.platform == "win32",
-                         "test is for win32")
-    def test_pathext_match_before_path_full_match(self):
-        base_dir = pathlib.Path(os.fsdecode(self.dir))
-        dir1 = base_dir / 'dir1'
-        dir2 = base_dir / 'dir2'
-        dir1.mkdir()
-        dir2.mkdir()
-
-        pathext_match = dir1 / 'hello.com.exe'
-        path_match = dir2 / 'hello.com'
-        pathext_match.touch()
-        path_match.touch()
-
-        test_path = os.pathsep.join([str(dir1), str(dir2)])
-        assert os.path.basename(shutil.which(
-            'hello.com', path=test_path, mode = os.F_OK
-        )).lower() == 'hello.com.exe'
+        other_file_path = os.path.join(self.other_dir, self.file)
+        self.create_file(other_file_path)
+        with unittest.mock.patch('shutil._win_path_needs_curdir', return_value=True):
+            with os_helper.change_cwd(path=self.dir):
+                rv = shutil.which(self.file, path=self.other_dir)
+                self.assertEqual(rv, os.path.join(self.curdir, self.file))
+            with os_helper.change_cwd(path=self.other_dir):
+                rv = shutil.which(self.file, path=self.dir)
+                self.assertEqual(rv, os.path.join(self.curdir, self.file))
 
     @os_helper.skip_if_dac_override
     def test_non_matching_mode(self):
         # Set the file read-only and ask for writeable files.
-        os.chmod(self.temp_file.name, stat.S_IREAD)
-        if os.access(self.temp_file.name, os.W_OK):
+        os.chmod(self.filepath, stat.S_IREAD)
+        if os.access(self.filepath, os.W_OK):
             self.skipTest("can't set the file read-only")
         rv = shutil.which(self.file, path=self.dir, mode=os.W_OK)
         self.assertIsNone(rv)
@@ -2265,13 +2425,13 @@ def test_pathext_checking(self):
         # Ask for the file without the ".exe" extension, then ensure that
         # it gets found properly with the extension.
         rv = shutil.which(self.file[:-4], path=self.dir)
-        self.assertEqual(rv, self.temp_file.name[:-4] + self.ext)
+        self.assertEqual(rv, self.filepath[:-4] + self.ext)
 
     def test_environ_path(self):
         with os_helper.EnvironmentVarGuard() as env:
             env['PATH'] = self.env_path
             rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
     def test_environ_path_empty(self):
         # PATH='': no match
@@ -2285,12 +2445,9 @@ def test_environ_path_empty(self):
                 self.assertIsNone(rv)
 
     def test_environ_path_cwd(self):
-        expected_cwd = os.path.basename(self.temp_file.name)
+        expected_cwd = self.file
         if sys.platform == "win32":
-            curdir = os.curdir
-            if isinstance(expected_cwd, bytes):
-                curdir = os.fsencode(curdir)
-            expected_cwd = os.path.join(curdir, expected_cwd)
+            expected_cwd = os.path.join(self.curdir, expected_cwd)
 
         # PATH=':': explicitly looks in the current directory
         with os_helper.EnvironmentVarGuard() as env:
@@ -2308,21 +2465,21 @@ def test_environ_path_cwd(self):
 
     def test_environ_path_missing(self):
         with os_helper.EnvironmentVarGuard() as env:
-            env.pop('PATH', None)
+            del env['PATH']
 
             # without confstr
             with unittest.mock.patch('os.confstr', side_effect=ValueError, \
                                      create=True), \
                  support.swap_attr(os, 'defpath', self.dir):
                 rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
             # with confstr
             with unittest.mock.patch('os.confstr', return_value=self.dir, \
                                      create=True), \
                  support.swap_attr(os, 'defpath', ''):
                 rv = shutil.which(self.file)
-            self.assertEqual(rv, self.temp_file.name)
+            self.assertEqual(rv, self.filepath)
 
     def test_empty_path(self):
         base_dir = os.path.dirname(self.dir)
@@ -2334,56 +2491,94 @@ def test_empty_path(self):
 
     def test_empty_path_no_PATH(self):
         with os_helper.EnvironmentVarGuard() as env:
-            env.pop('PATH', None)
+            del env['PATH']
             rv = shutil.which(self.file)
             self.assertIsNone(rv)
 
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext(self):
-        ext = self.to_text_type(".xyz")
-        temp_filexyz = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                   prefix=self.to_text_type("Tmp2"), suffix=ext)
-        os.chmod(temp_filexyz.name, stat.S_IXUSR)
-        self.addCleanup(temp_filexyz.close)
-
-        # strip path and extension
-        program = os.path.basename(temp_filexyz.name)
-        program = os.path.splitext(program)[0]
-
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env['PATHEXT'] = ext if isinstance(ext, str) else ext.decode()
-            rv = shutil.which(program, path=self.temp_dir)
-            self.assertEqual(rv, temp_filexyz.name)
+            env['PATHEXT'] = ext
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
 
     # Issue 40592: See https://bugs.python.org/issue40592
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext_with_empty_str(self):
-        ext = self.to_text_type(".xyz")
-        temp_filexyz = tempfile.NamedTemporaryFile(dir=self.temp_dir,
-                                                   prefix=self.to_text_type("Tmp2"), suffix=ext)
-        self.addCleanup(temp_filexyz.close)
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = ext + ';'  # note the ;
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
 
-        # strip path and extension
-        program = os.path.basename(temp_filexyz.name)
-        program = os.path.splitext(program)[0]
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_with_multidot_extension(self):
+        ext = '.foo.bar'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = ext
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
+
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_with_null_extension(self):
+        cmd = self.to_text_type(TESTFN2)
+        cmddot = cmd + self.to_text_type('.')
+        filepath = os.path.join(self.dir, cmd)
+        self.create_file(filepath)
+        with os_helper.EnvironmentVarGuard() as env:
+            env['PATHEXT'] = '.xyz'
+            self.assertIsNone(shutil.which(cmd, path=self.dir))
+            self.assertIsNone(shutil.which(cmddot, path=self.dir))
+            env['PATHEXT'] = '.xyz;.'  # note the .
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmddot, path=self.dir),
+                             filepath + self.to_text_type('.'))
+            env['PATHEXT'] = '.xyz;..'  # multiple dots
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)
+            self.assertEqual(shutil.which(cmddot, path=self.dir),
+                             filepath + self.to_text_type('.'))
 
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_pathext_extension_ends_with_dot(self):
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        dot = self.to_text_type('.')
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env['PATHEXT'] = f"{ext if isinstance(ext, str) else ext.decode()};"  # note the ;
-            rv = shutil.which(program, path=self.temp_dir)
-            self.assertEqual(rv, temp_filexyz.name)
+            env['PATHEXT'] = ext + '.'
+            self.assertEqual(shutil.which(cmd, path=self.dir), filepath)  # cmd.exe hangs here
+            self.assertEqual(shutil.which(cmdext, path=self.dir), filepath)
+            self.assertIsNone(shutil.which(cmd + dot, path=self.dir))
+            self.assertIsNone(shutil.which(cmdext + dot, path=self.dir))
 
     # See GH-75586
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
     def test_pathext_applied_on_files_in_path(self):
+        ext = '.xyz'
+        cmd = self.to_text_type(TESTFN2)
+        cmdext = cmd + self.to_text_type(ext)
+        filepath = os.path.join(self.dir, cmdext)
+        self.create_file(filepath)
         with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".test"
-
-            test_path = os.path.join(self.temp_dir, self.to_text_type("test_program.test"))
-            open(test_path, 'w').close()
-            os.chmod(test_path, 0o755)
-
-            self.assertEqual(shutil.which(self.to_text_type("test_program")), test_path)
+            env["PATH"] = os.fsdecode(self.dir)
+            env["PATHEXT"] = ext
+            self.assertEqual(shutil.which(cmd), filepath)
+            self.assertEqual(shutil.which(cmdext), filepath)
 
     # See GH-75586
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
@@ -2399,49 +2594,107 @@ def test_win_path_needs_curdir(self):
             self.assertFalse(shutil._win_path_needs_curdir('dontcare', os.X_OK))
             need_curdir_mock.assert_called_once_with('dontcare')
 
-    # See GH-109590
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
-    def test_pathext_preferred_for_execute(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".test"
-
-            exe = os.path.join(self.temp_dir, self.to_text_type("test.exe"))
-            open(exe, 'w').close()
-            os.chmod(exe, 0o755)
-
-            # default behavior allows a direct match if nothing in PATHEXT matches
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), exe)
-
-            dot_test = os.path.join(self.temp_dir, self.to_text_type("test.exe.test"))
-            open(dot_test, 'w').close()
-            os.chmod(dot_test, 0o755)
+    def test_same_dir_with_pathext_extension(self):
+        cmd = self.file  # with .exe extension
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+
+        cmd2 = cmd + self.to_text_type('.com')  # with .exe.com extension
+        other_file_path = os.path.join(self.dir, cmd2)
+        self.create_file(other_file_path)
+
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+        self.assertNormEqual(shutil.which(cmd2, path=self.dir), other_file_path)
+        self.assertNormEqual(shutil.which(cmd2, path=self.dir, mode=os.F_OK),
+                             other_file_path)
 
-            # now we have a PATHEXT match, so it take precedence
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), dot_test)
-
-            # but if we don't use os.X_OK we don't change the order based off PATHEXT
-            # and therefore get the direct match.
-            self.assertEqual(shutil.which(self.to_text_type("test.exe"), mode=os.F_OK), exe)
-
-    # See GH-109590
     @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
-    def test_pathext_given_extension_preferred(self):
-        with os_helper.EnvironmentVarGuard() as env:
-            env["PATH"] = self.temp_dir if isinstance(self.temp_dir, str) else self.temp_dir.decode()
-            env["PATHEXT"] = ".exe2;.exe"
-
-            exe = os.path.join(self.temp_dir, self.to_text_type("test.exe"))
-            open(exe, 'w').close()
-            os.chmod(exe, 0o755)
+    def test_same_dir_without_pathext_extension(self):
+        cmd = self.file[:-4]  # without .exe extension
+        # pathext match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             self.filepath)
+
+        # without extension
+        other_file_path = os.path.join(self.dir, cmd)
+        self.create_file(other_file_path)
+
+        # pathext match if mode contains X_OK
+        self.assertNormEqual(shutil.which(cmd, path=self.dir), self.filepath)
+        # full match
+        self.assertNormEqual(shutil.which(cmd, path=self.dir, mode=os.F_OK),
+                             other_file_path)
+        self.assertNormEqual(shutil.which(self.file, path=self.dir), self.filepath)
+        self.assertNormEqual(shutil.which(self.file, path=self.dir, mode=os.F_OK),
+                             self.filepath)
 
-            exe2 = os.path.join(self.temp_dir, self.to_text_type("test.exe2"))
-            open(exe2, 'w').close()
-            os.chmod(exe2, 0o755)
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_dir_order_with_pathext_extension(self):
+        cmd = self.file  # with .exe extension
+        search_path = os.pathsep.join([os.fsdecode(self.other_dir),
+                                       os.fsdecode(self.dir)])
+        # full match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        cmd2 = cmd + self.to_text_type('.com')  # with .exe.com extension
+        other_file_path = os.path.join(self.other_dir, cmd2)
+        self.create_file(other_file_path)
+
+        # pathext match in the first directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), other_file_path)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             other_file_path)
+        # full match in the first directory
+        self.assertNormEqual(shutil.which(cmd2, path=search_path), other_file_path)
+        self.assertNormEqual(shutil.which(cmd2, path=search_path, mode=os.F_OK),
+                             other_file_path)
+
+        # full match in the first directory
+        search_path = os.pathsep.join([os.fsdecode(self.dir),
+                                       os.fsdecode(self.other_dir)])
+        self.assertEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                         self.filepath)
 
-            # even though .exe2 is preferred in PATHEXT, we matched directly to test.exe
-            self.assertEqual(shutil.which(self.to_text_type("test.exe")), exe)
-            self.assertEqual(shutil.which(self.to_text_type("test")), exe2)
+    @unittest.skipUnless(sys.platform == "win32", 'test specific to Windows')
+    def test_dir_order_without_pathext_extension(self):
+        cmd = self.file[:-4]  # without .exe extension
+        search_path = os.pathsep.join([os.fsdecode(self.other_dir),
+                                       os.fsdecode(self.dir)])
+        # pathext match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        # without extension
+        other_file_path = os.path.join(self.other_dir, cmd)
+        self.create_file(other_file_path)
+
+        # pathext match in the second directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        # full match in the first directory
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             other_file_path)
+        # full match in the second directory
+        self.assertNormEqual(shutil.which(self.file, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(self.file, path=search_path, mode=os.F_OK),
+                             self.filepath)
+
+        # pathext match in the first directory
+        search_path = os.pathsep.join([os.fsdecode(self.dir),
+                                       os.fsdecode(self.other_dir)])
+        self.assertNormEqual(shutil.which(cmd, path=search_path), self.filepath)
+        self.assertNormEqual(shutil.which(cmd, path=search_path, mode=os.F_OK),
+                             self.filepath)
 
 
 class TestWhichBytes(TestWhich):
@@ -2449,18 +2702,12 @@ def setUp(self):
         TestWhich.setUp(self)
         self.dir = os.fsencode(self.dir)
         self.file = os.fsencode(self.file)
-        self.temp_file.name = os.fsencode(self.temp_file.name)
-        self.temp_dir = os.fsencode(self.temp_dir)
+        self.filepath = os.fsencode(self.filepath)
+        self.other_dir = os.fsencode(self.other_dir)
         self.curdir = os.fsencode(self.curdir)
         self.ext = os.fsencode(self.ext)
 
-    def to_text_type(self, s):
-        '''
-        In this class we're testing with bytes, so convert s to a bytes
-        '''
-        if isinstance(s, str):
-            return s.encode()
-        return s
+    to_text_type = staticmethod(os.fsencode)
 
 
 class TestMove(BaseTest, unittest.TestCase):
@@ -2471,8 +2718,7 @@ def setUp(self):
         self.dst_dir = self.mkdtemp()
         self.src_file = os.path.join(self.src_dir, filename)
         self.dst_file = os.path.join(self.dst_dir, filename)
-        with open(self.src_file, "wb") as f:
-            f.write(b"spam")
+        create_file(self.src_file, b"spam")
 
     def _check_move_file(self, src, dst, real_dst):
         with open(src, "rb") as f:
@@ -2498,12 +2744,12 @@ def test_move_file_to_dir(self):
 
     def test_move_file_to_dir_pathlike_src(self):
         # Move a pathlike file to another location on the same filesystem.
-        src = pathlib.Path(self.src_file)
+        src = FakePath(self.src_file)
         self._check_move_file(src, self.dst_dir, self.dst_file)
 
     def test_move_file_to_dir_pathlike_dst(self):
         # Move a file to another pathlike location on the same filesystem.
-        dst = pathlib.Path(self.dst_dir)
+        dst = FakePath(self.dst_dir)
         self._check_move_file(self.src_file, dst, self.dst_file)
 
     @mock_rename
@@ -2550,8 +2796,7 @@ def test_move_dir_altsep_to_dir(self):
 
     def test_existing_file_inside_dest_dir(self):
         # A file with the same name inside the destination dir already exists.
-        with open(self.dst_file, "wb"):
-            pass
+        create_file(self.dst_file)
         self.assertRaises(shutil.Error, shutil.move, self.src_file, self.dst_dir)
 
     def test_dont_move_dir_in_itself(self):
@@ -2583,7 +2828,6 @@ def test_destinsrc_false_positive(self):
         finally:
             os_helper.rmtree(TESTFN)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     @mock_rename
     def test_move_file_symlink(self):
@@ -2593,7 +2837,6 @@ def test_move_file_symlink(self):
         self.assertTrue(os.path.islink(self.dst_file))
         self.assertTrue(os.path.samefile(self.src_file, self.dst_file))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     @mock_rename
     def test_move_file_symlink_to_dir(self):
@@ -2605,7 +2848,6 @@ def test_move_file_symlink_to_dir(self):
         self.assertTrue(os.path.islink(final_link))
         self.assertTrue(os.path.samefile(self.src_file, final_link))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     @mock_rename
     def test_move_dangling_symlink(self):
@@ -2617,7 +2859,6 @@ def test_move_dangling_symlink(self):
         self.assertTrue(os.path.islink(dst_link))
         self.assertEqual(os.path.realpath(src), os.path.realpath(dst_link))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     @mock_rename
     def test_move_dir_symlink(self):
@@ -2693,12 +2934,10 @@ def _test_move_symlink_to_dir_into_dir(self, dst):
         self.assertTrue(os.path.samefile(self.dst_dir, dst_link))
         self.assertTrue(os.path.exists(src))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_move_symlink_to_dir_into_dir(self):
         self._test_move_symlink_to_dir_into_dir(self.dst_dir)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_move_symlink_to_dir_into_symlink_to_dir(self):
         dst = os.path.join(self.src_dir, 'otherlinktodir')
@@ -2972,8 +3211,7 @@ def test_empty_file(self):
         dstname = TESTFN + 'dst'
         self.addCleanup(lambda: os_helper.unlink(srcname))
         self.addCleanup(lambda: os_helper.unlink(dstname))
-        with open(srcname, "wb"):
-            pass
+        create_file(srcname)
 
         with open(srcname, "rb") as src:
             with open(dstname, "wb") as dst:
@@ -3096,7 +3334,7 @@ def test_blocksize_arg(self):
             self.assertEqual(blocksize, os.path.getsize(TESTFN))
             # ...unless we're dealing with a small file.
             os_helper.unlink(TESTFN2)
-            write_file(TESTFN2, b"hello", binary=True)
+            create_file(TESTFN2, b"hello")
             self.addCleanup(os_helper.unlink, TESTFN2 + '3')
             self.assertRaises(ZeroDivisionError,
                               shutil.copyfile, TESTFN2, TESTFN2 + '3')
@@ -3168,6 +3406,7 @@ def test_bad_environ(self):
         self.assertGreaterEqual(size.lines, 0)
 
     @unittest.skipUnless(os.isatty(sys.__stdout__.fileno()), "not on tty")
+    @support.requires_subprocess()
     @unittest.skipUnless(hasattr(os, 'get_terminal_size'),
                          'need os.get_terminal_size()')
     def test_stty_match(self):
@@ -3185,8 +3424,7 @@ def test_stty_match(self):
         expected = (int(size[1]), int(size[0])) # reversed order
 
         with os_helper.EnvironmentVarGuard() as env:
-            del env['LINES']
-            del env['COLUMNS']
+            env.unset('LINES', 'COLUMNS')
             actual = shutil.get_terminal_size()
 
         self.assertEqual(expected, actual)
@@ -3194,8 +3432,7 @@ def test_stty_match(self):
     @unittest.skipIf(support.is_wasi, "WASI has no /dev/null")
     def test_fallback(self):
         with os_helper.EnvironmentVarGuard() as env:
-            del env['LINES']
-            del env['COLUMNS']
+            env.unset('LINES', 'COLUMNS')
 
             # sys.__stdout__ has no fileno()
             with support.swap_attr(sys, '__stdout__', None):
diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py
index e05467f776..2c5cec803d 100644
--- a/Lib/test/test_signal.py
+++ b/Lib/test/test_signal.py
@@ -13,9 +13,10 @@
 import time
 import unittest
 from test import support
-from test.support import os_helper
+from test.support import (
+    is_apple, is_apple_mobile, os_helper, threading_helper
+)
 from test.support.script_helper import assert_python_ok, spawn_python
-from test.support import threading_helper
 try:
     import _testcapi
 except ImportError:
@@ -24,8 +25,6 @@
 
 class GenericTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_enums(self):
         for name in dir(signal):
             sig = getattr(signal, name)
@@ -82,8 +81,6 @@ def trivial_signal_handler(self, *args):
     def create_handler_with_partial(self, argument):
         return functools.partial(self.trivial_signal_handler, argument)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_out_of_range_signal_number_raises_error(self):
         self.assertRaises(ValueError, signal.getsignal, 4242)
 
@@ -126,23 +123,19 @@ def __repr__(self):
         self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
         self.assertEqual(0, argument.repr_count)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(sys.platform.startswith("netbsd"),
+                     "gh-124083: strsignal is not supported on NetBSD")
     def test_strsignal(self):
         self.assertIn("Interrupt", signal.strsignal(signal.SIGINT))
         self.assertIn("Terminated", signal.strsignal(signal.SIGTERM))
         self.assertIn("Hangup", signal.strsignal(signal.SIGHUP))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Issue 3864, unknown if this affects earlier versions of freebsd also
     def test_interprocess_signal(self):
         dirname = os.path.dirname(__file__)
         script = os.path.join(dirname, 'signalinterproctester.py')
         assert_python_ok(script)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(
         hasattr(signal, "valid_signals"),
         "requires signal.valid_signals"
@@ -190,8 +183,6 @@ def test_keyboard_interrupt_exit_code(self):
 @unittest.skipUnless(sys.platform == "win32", "Windows specific")
 class WindowsSignalTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_valid_signals(self):
         s = signal.valid_signals()
         self.assertIsInstance(s, set)
@@ -201,8 +192,7 @@ def test_valid_signals(self):
         self.assertNotIn(signal.NSIG, s)
         self.assertLess(len(s), signal.NSIG)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue9324(self):
         # Updated for issue #10003, adding SIGBREAK
         handler = lambda x, y: None
@@ -224,8 +214,6 @@ def test_issue9324(self):
         with self.assertRaises(ValueError):
             signal.signal(7, handler)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(sys.executable, "sys.executable required.")
     @support.requires_subprocess()
     def test_keyboard_interrupt_exit_code(self):
@@ -253,13 +241,11 @@ def test_invalid_call(self):
         with self.assertRaises(TypeError):
             signal.set_wakeup_fd(signal.SIGINT, False)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_invalid_fd(self):
         fd = os_helper.make_bad_fd()
         self.assertRaises((ValueError, OSError),
                           signal.set_wakeup_fd, fd)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(support.has_socket_support, "needs working sockets.")
     def test_invalid_socket(self):
         sock = socket.socket()
@@ -268,7 +254,6 @@ def test_invalid_socket(self):
         self.assertRaises((ValueError, OSError),
                           signal.set_wakeup_fd, fd)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     # 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.")
@@ -290,7 +275,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.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @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):
@@ -717,7 +701,7 @@ def handler(signum, frame):
 @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
 class SiginterruptTest(unittest.TestCase):
 
-    def readpipe_interrupted(self, interrupt):
+    def readpipe_interrupted(self, interrupt, timeout=support.SHORT_TIMEOUT):
         """Perform a read during which a signal will arrive.  Return True if the
         read is interrupted by the signal and raises an exception.  Return False
         if it returns normally.
@@ -765,7 +749,7 @@ def handler(signum, frame):
                 # wait until the child process is loaded and has started
                 first_line = process.stdout.readline()
 
-                stdout, stderr = process.communicate(timeout=support.SHORT_TIMEOUT)
+                stdout, stderr = process.communicate(timeout=timeout)
             except subprocess.TimeoutExpired:
                 process.kill()
                 return False
@@ -777,8 +761,6 @@ def handler(signum, frame):
                                     % (exitcode, stdout))
                 return (exitcode == 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_without_siginterrupt(self):
         # If a signal handler is installed and siginterrupt is not called
         # at all, when that signal arrives, it interrupts a syscall that's in
@@ -786,8 +768,6 @@ def test_without_siginterrupt(self):
         interrupted = self.readpipe_interrupted(None)
         self.assertTrue(interrupted)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_siginterrupt_on(self):
         # If a signal handler is installed and siginterrupt is called with
         # a true value for the second argument, when that signal arrives, it
@@ -800,7 +780,7 @@ def test_siginterrupt_off(self):
         # If a signal handler is installed and siginterrupt is called with
         # a false value for the second argument, when that signal arrives, it
         # does not interrupt a syscall that's in progress.
-        interrupted = self.readpipe_interrupted(False)
+        interrupted = self.readpipe_interrupted(False, timeout=2)
         self.assertFalse(interrupted)
 
 
@@ -840,8 +820,6 @@ def sig_prof(self, *args):
         self.hndl_called = True
         signal.setitimer(signal.ITIMER_PROF, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_exc(self):
         # XXX I'm assuming -1 is an invalid itimer, but maybe some platform
         # defines it ?
@@ -851,27 +829,23 @@ def test_itimer_exc(self):
             self.assertRaises(signal.ItimerError,
                               signal.setitimer, signal.ITIMER_REAL, -1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_real(self):
         self.itimer = signal.ITIMER_REAL
         signal.setitimer(self.itimer, 1.0)
         signal.pause()
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Issue 3864, unknown if this affects earlier versions of freebsd also
-    @unittest.skipIf(sys.platform in ('netbsd5',),
+    @unittest.skipIf(sys.platform in ('netbsd5',) or is_apple_mobile,
         'itimer not reliable (does not mix well with threading) on some BSDs.')
     def test_itimer_virtual(self):
         self.itimer = signal.ITIMER_VIRTUAL
         signal.signal(signal.SIGVTALRM, self.sig_vtalrm)
-        signal.setitimer(self.itimer, 0.3, 0.2)
+        signal.setitimer(self.itimer, 0.001, 0.001)
 
         for _ in support.busy_retry(support.LONG_TIMEOUT):
             # use up some virtual time by doing real work
-            _ = pow(12345, 67890, 10000019)
+            _ = sum(i * i for i in range(10**5))
             if signal.getitimer(self.itimer) == (0.0, 0.0):
                 # sig_vtalrm handler stopped this itimer
                 break
@@ -881,8 +855,6 @@ def test_itimer_virtual(self):
         # and the handler should have been called
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_itimer_prof(self):
         self.itimer = signal.ITIMER_PROF
         signal.signal(signal.SIGPROF, self.sig_prof)
@@ -890,7 +862,7 @@ def test_itimer_prof(self):
 
         for _ in support.busy_retry(support.LONG_TIMEOUT):
             # do some work
-            _ = pow(12345, 67890, 10000019)
+            _ = sum(i * i for i in range(10**5))
             if signal.getitimer(self.itimer) == (0.0, 0.0):
                 # sig_prof handler stopped this itimer
                 break
@@ -900,8 +872,6 @@ def test_itimer_prof(self):
         # and the handler should have been called
         self.assertEqual(self.hndl_called, True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_setitimer_tiny(self):
         # bpo-30807: C setitimer() takes a microsecond-resolution interval.
         # Check that float -> timeval conversion doesn't round
@@ -1358,15 +1328,18 @@ def test_stress_delivery_simultaneous(self):
         def handler(signum, frame):
             sigs.append(signum)
 
-        self.setsig(signal.SIGUSR1, handler)
+        # On Android, SIGUSR1 is unreliable when used in close proximity to
+        # another signal – see Android/testbed/app/src/main/python/main.py.
+        # So we use a different signal.
+        self.setsig(signal.SIGUSR2, handler)
         self.setsig(signal.SIGALRM, handler)  # for ITIMER_REAL
 
         expected_sigs = 0
         while expected_sigs < N:
             # Hopefully the SIGALRM will be received somewhere during
-            # initial processing of SIGUSR1.
+            # initial processing of SIGUSR2.
             signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
-            os.kill(os.getpid(), signal.SIGUSR1)
+            os.kill(os.getpid(), signal.SIGUSR2)
 
             expected_sigs += 2
             # Wait for handlers to run to avoid signal coalescing
@@ -1378,8 +1351,7 @@ def handler(signum, frame):
         # Python handler
         self.assertEqual(len(sigs), N, "Some signals were lost")
 
-    @unittest.skip("TODO: RUSTPYTHON; hang")
-    @unittest.skipIf(sys.platform == "darwin", "crashes due to system bug (FB13453490)")
+    @unittest.skipIf(is_apple, "crashes due to system bug (FB13453490)")
     @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
                          "test needs SIGUSR1")
     @threading_helper.requires_working_threading()
@@ -1442,14 +1414,11 @@ def cycle_handlers():
 
 class RaiseSignalTest(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_sigint(self):
         with self.assertRaises(KeyboardInterrupt):
             signal.raise_signal(signal.SIGINT)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.platform != "win32", "Windows specific test")
     def test_invalid_argument(self):
         try:
@@ -1462,8 +1431,6 @@ def test_invalid_argument(self):
             else:
                 raise
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_handler(self):
         is_ok = False
         def handler(a, b):
@@ -1475,8 +1442,7 @@ def handler(a, b):
         signal.raise_signal(signal.SIGINT)
         self.assertTrue(is_ok)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test__thread_interrupt_main(self):
         # See https://github.com/python/cpython/issues/102397
         code = """if 1:
diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py
index 4ff187674e..df279bd965 100644
--- a/Lib/test/test_site.py
+++ b/Lib/test/test_site.py
@@ -7,10 +7,12 @@
 import unittest
 import test.support
 from test import support
+from test.support.script_helper import assert_python_ok
 from test.support import os_helper
 from test.support import socket_helper
 from test.support import captured_stderr
 from test.support.os_helper import TESTFN, EnvironmentVarGuard
+from test.support.script_helper import spawn_python, kill_python
 import ast
 import builtins
 import glob
@@ -23,6 +25,7 @@
 import sys
 import sysconfig
 import tempfile
+from textwrap import dedent
 import urllib.error
 import urllib.request
 from unittest import mock
@@ -220,8 +223,6 @@ def test_addsitedir_hidden_flags(self):
         finally:
             pth_file.cleanup()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(sys.platform == 'win32', 'test needs Windows')
     @support.requires_subprocess()
     def test_addsitedir_hidden_file_attribute(self):
@@ -330,14 +331,14 @@ def test_getsitepackages(self):
                 self.assertEqual(len(dirs), 2)
                 wanted = os.path.join('xoxo', sys.platlibdir,
                                       # XXX: RUSTPYTHON
-                                      'rustpython%d.%d' % sys.version_info[:2],
+                                      f'rustpython{sysconfig._get_python_version_abi()}',
                                       'site-packages')
                 self.assertEqual(dirs[0], wanted)
             else:
                 self.assertEqual(len(dirs), 1)
             wanted = os.path.join('xoxo', 'lib',
                                   # XXX: RUSTPYTHON
-                                  'rustpython%d.%d' % sys.version_info[:2],
+                                  f'rustpython{sysconfig._get_python_version_abi()}',
                                   'site-packages')
             self.assertEqual(dirs[-1], wanted)
         else:
@@ -358,9 +359,7 @@ def test_no_home_directory(self):
 
         with EnvironmentVarGuard() as environ, \
              mock.patch('os.path.expanduser', lambda path: path):
-
-            del environ['PYTHONUSERBASE']
-            del environ['APPDATA']
+            environ.unset('PYTHONUSERBASE', 'APPDATA')
 
             user_base = site.getuserbase()
             self.assertTrue(user_base.startswith('~' + os.sep),
@@ -382,6 +381,19 @@ def test_no_home_directory(self):
             mock_addsitedir.assert_not_called()
             self.assertFalse(known_paths)
 
+    def test_gethistoryfile(self):
+        filename = 'file'
+        rc, out, err = assert_python_ok('-c',
+            f'import site; assert site.gethistoryfile() == "{filename}"',
+            PYTHON_HISTORY=filename)
+        self.assertEqual(rc, 0)
+
+        # Check that PYTHON_HISTORY is ignored in isolated mode.
+        rc, out, err = assert_python_ok('-I', '-c',
+            f'import site; assert site.gethistoryfile() != "{filename}"',
+            PYTHON_HISTORY=filename)
+        self.assertEqual(rc, 0)
+
     def test_trace(self):
         message = "bla-bla-bla"
         for verbose, out in (True, message + "\n"), (False, ""):
@@ -509,6 +521,44 @@ def test_sitecustomize_executed(self):
             else:
                 self.fail("sitecustomize not imported automatically")
 
+    @support.requires_subprocess()
+    def test_customization_modules_on_startup(self):
+        mod_names = [
+            'sitecustomize'
+        ]
+
+        if site.ENABLE_USER_SITE:
+            mod_names.append('usercustomize')
+
+        temp_dir = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, temp_dir)
+
+        with EnvironmentVarGuard() as environ:
+            environ['PYTHONPATH'] = temp_dir
+
+            for module_name in mod_names:
+                os_helper.rmtree(temp_dir)
+                os.mkdir(temp_dir)
+
+                customize_path = os.path.join(temp_dir, f'{module_name}.py')
+                eyecatcher = f'EXECUTED_{module_name}'
+
+                with open(customize_path, 'w') as f:
+                    f.write(f'print("{eyecatcher}")')
+
+                output = subprocess.check_output([sys.executable, '-c', '""'])
+                self.assertIn(eyecatcher, output.decode('utf-8'))
+
+                # -S blocks any site-packages
+                output = subprocess.check_output([sys.executable, '-S', '-c', '""'])
+                self.assertNotIn(eyecatcher, output.decode('utf-8'))
+
+                # -s blocks user site-packages
+                if 'usercustomize' == module_name:
+                    output = subprocess.check_output([sys.executable, '-s', '-c', '""'])
+                    self.assertNotIn(eyecatcher, output.decode('utf-8'))
+
+
     @unittest.skipUnless(hasattr(urllib.request, "HTTPSHandler"),
                          'need SSL support to download license')
     @test.support.requires_resource('network')
@@ -531,8 +581,7 @@ def test_license_exists_at_url(self):
 
 class StartupImportTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_startup_imports(self):
         # Get sys.path in isolated mode (python3 -I)
@@ -665,8 +714,7 @@ def _get_pth_lines(self, libpath: str, *, import_site: bool):
             pth_lines.append('import site')
         return pth_lines
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_underpth_basic(self):
         pth_lines = ['#.', '# ..', *sys.path, '.', '..']
@@ -686,8 +734,7 @@ def test_underpth_basic(self):
             "sys.path is incorrect"
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_underpth_nosite_file(self):
         libpath = test.support.STDLIB_DIR
@@ -712,8 +759,7 @@ def test_underpth_nosite_file(self):
             "sys.path is incorrect"
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_underpth_file(self):
         libpath = test.support.STDLIB_DIR
@@ -734,8 +780,7 @@ def test_underpth_file(self):
             )], env=env)
         self.assertTrue(rc, "sys.path is incorrect")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_underpth_dll_file(self):
         libpath = test.support.STDLIB_DIR
@@ -757,5 +802,107 @@ def test_underpth_dll_file(self):
         self.assertTrue(rc, "sys.path is incorrect")
 
 
+class CommandLineTests(unittest.TestCase):
+    def exists(self, path):
+        if path is not None and os.path.isdir(path):
+            return "exists"
+        else:
+            return "doesn't exist"
+
+    def get_excepted_output(self, *args):
+        if len(args) == 0:
+            user_base = site.getuserbase()
+            user_site = site.getusersitepackages()
+            output = io.StringIO()
+            output.write("sys.path = [\n")
+            for dir in sys.path:
+                output.write("    %r,\n" % (dir,))
+            output.write("]\n")
+            output.write(f"USER_BASE: {user_base} ({self.exists(user_base)})\n")
+            output.write(f"USER_SITE: {user_site} ({self.exists(user_site)})\n")
+            output.write(f"ENABLE_USER_SITE: {site.ENABLE_USER_SITE}\n")
+            return 0, dedent(output.getvalue()).strip()
+
+        buffer = []
+        if '--user-base' in args:
+            buffer.append(site.getuserbase())
+        if '--user-site' in args:
+            buffer.append(site.getusersitepackages())
+
+        if buffer:
+            return_code = 3
+            if site.ENABLE_USER_SITE:
+                return_code = 0
+            elif site.ENABLE_USER_SITE is False:
+                return_code = 1
+            elif site.ENABLE_USER_SITE is None:
+                return_code = 2
+            output = os.pathsep.join(buffer)
+            return return_code, os.path.normpath(dedent(output).strip())
+        else:
+            return 10, None
+
+    def invoke_command_line(self, *args):
+        args = ["-m", "site", *args]
+
+        with EnvironmentVarGuard() as env:
+            env["PYTHONUTF8"] = "1"
+            env["PYTHONIOENCODING"] = "utf-8"
+            proc = spawn_python(*args, text=True, env=env,
+                                encoding='utf-8', errors='replace')
+
+        output = kill_python(proc)
+        return_code = proc.returncode
+        return return_code, os.path.normpath(dedent(output).strip())
+
+    @support.requires_subprocess()
+    def test_no_args(self):
+        return_code, output = self.invoke_command_line()
+        excepted_return_code, _ = self.get_excepted_output()
+        self.assertEqual(return_code, excepted_return_code)
+        lines = output.splitlines()
+        self.assertEqual(lines[0], "sys.path = [")
+        self.assertEqual(lines[-4], "]")
+        excepted_base = f"USER_BASE: '{site.getuserbase()}'" +\
+            f" ({self.exists(site.getuserbase())})"
+        self.assertEqual(lines[-3], excepted_base)
+        excepted_site = f"USER_SITE: '{site.getusersitepackages()}'" +\
+            f" ({self.exists(site.getusersitepackages())})"
+        self.assertEqual(lines[-2], excepted_site)
+        self.assertEqual(lines[-1], f"ENABLE_USER_SITE: {site.ENABLE_USER_SITE}")
+
+    @support.requires_subprocess()
+    def test_unknown_args(self):
+        return_code, output = self.invoke_command_line("--unknown-arg")
+        excepted_return_code, _ = self.get_excepted_output("--unknown-arg")
+        self.assertEqual(return_code, excepted_return_code)
+        self.assertIn('[--user-base] [--user-site]', output)
+
+    @support.requires_subprocess()
+    def test_base_arg(self):
+        return_code, output = self.invoke_command_line("--user-base")
+        excepted = self.get_excepted_output("--user-base")
+        excepted_return_code, excepted_output = excepted
+        self.assertEqual(return_code, excepted_return_code)
+        self.assertEqual(output, excepted_output)
+
+    @support.requires_subprocess()
+    def test_site_arg(self):
+        return_code, output = self.invoke_command_line("--user-site")
+        excepted = self.get_excepted_output("--user-site")
+        excepted_return_code, excepted_output = excepted
+        self.assertEqual(return_code, excepted_return_code)
+        self.assertEqual(output, excepted_output)
+
+    @support.requires_subprocess()
+    def test_both_args(self):
+        return_code, output = self.invoke_command_line("--user-base",
+                                                       "--user-site")
+        excepted = self.get_excepted_output("--user-base", "--user-site")
+        excepted_return_code, excepted_output = excepted
+        self.assertEqual(return_code, excepted_return_code)
+        self.assertEqual(output, excepted_output)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index 53d4c77616..6de7e73c39 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -286,8 +286,7 @@ def test_deepcopy(self):
         self.assertIsNot(s.stop, c.stop)
         self.assertIsNot(s.step, c.step)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cycle(self):
         class myobj(): pass
         o = myobj()
diff --git a/Lib/test/test_smtplib.py b/Lib/test/test_smtplib.py
index 9b787950fc..ade0dc1308 100644
--- a/Lib/test/test_smtplib.py
+++ b/Lib/test/test_smtplib.py
@@ -17,6 +17,7 @@
 import threading
 
 import unittest
+import unittest.mock as mock
 from test import support, mock_socket
 from test.support import hashlib_helper
 from test.support import socket_helper
@@ -350,7 +351,7 @@ def testVRFY(self):
                             timeout=support.LOOPBACK_TIMEOUT)
         self.addCleanup(smtp.close)
         expected = (252, b'Cannot VRFY user, but will accept message ' + \
-                    b'and attempt delivery')
+                         b'and attempt delivery')
         self.assertEqual(smtp.vrfy('nobody@nowhere.com'), expected)
         self.assertEqual(smtp.verify('nobody@nowhere.com'), expected)
         smtp.quit()
@@ -371,7 +372,7 @@ def testHELP(self):
                             timeout=support.LOOPBACK_TIMEOUT)
         self.addCleanup(smtp.close)
         self.assertEqual(smtp.help(), b'Supported commands: EHLO HELO MAIL ' + \
-                         b'RCPT DATA RSET NOOP QUIT VRFY')
+                                      b'RCPT DATA RSET NOOP QUIT VRFY')
         smtp.quit()
 
     def testSend(self):
@@ -527,7 +528,7 @@ def testSendMessageWithAddresses(self):
         smtp.quit()
         # make sure the Bcc header is still in the message.
         self.assertEqual(m['Bcc'], 'John Root <root@localhost>, "Dinsdale" '
-                                   '<warped@silly.walks.com>')
+                                    '<warped@silly.walks.com>')
 
         self.client_evt.set()
         self.serv_evt.wait()
@@ -766,7 +767,7 @@ def tearDown(self):
 
     def testFailingHELO(self):
         self.assertRaises(smtplib.SMTPConnectError, smtplib.SMTP,
-                          HOST, self.port, 'localhost', 3)
+                            HOST, self.port, 'localhost', 3)
 
 
 class TooLongLineTests(unittest.TestCase):
@@ -804,14 +805,14 @@ def testLineTooLong(self):
 sim_users = {'Mr.A@somewhere.com':'John A',
              'Ms.B@xn--fo-fka.com':'Sally B',
              'Mrs.C@somewhereesle.com':'Ruth C',
-             }
+            }
 
 sim_auth = ('Mr.A@somewhere.com', 'somepassword')
 sim_cram_md5_challenge = ('PENCeUxFREJoU0NnbmhNWitOMjNGNn'
                           'dAZWx3b29kLmlubm9zb2Z0LmNvbT4=')
 sim_lists = {'list-1':['Mr.A@somewhere.com','Mrs.C@somewhereesle.com'],
              'list-2':['Ms.B@xn--fo-fka.com',],
-             }
+            }
 
 # Simulated SMTP channel & server
 class ResponseException(Exception): pass
@@ -830,6 +831,7 @@ class SimSMTPChannel(smtpd.SMTPChannel):
     def __init__(self, extra_features, *args, **kw):
         self._extrafeatures = ''.join(
             [ "250-{0}\r\n".format(x) for x in extra_features ])
+        self.all_received_lines = []
         super(SimSMTPChannel, self).__init__(*args, **kw)
 
     # AUTH related stuff.  It would be nice if support for this were in smtpd.
@@ -844,6 +846,7 @@ def found_terminator(self):
                 self.smtp_state = self.COMMAND
                 self.push('%s %s' % (e.smtp_code, e.smtp_error))
             return
+        self.all_received_lines.append(self.received_lines)
         super().found_terminator()
 
 
@@ -924,11 +927,14 @@ def _auth_cram_md5(self, arg=None):
             except ValueError as e:
                 self.push('535 Splitting response {!r} into user and password '
                           'failed: {}'.format(logpass, e))
-                return False
-            valid_hashed_pass = hmac.HMAC(
-                sim_auth[1].encode('ascii'),
-                self._decode_base64(sim_cram_md5_challenge).encode('ascii'),
-                'md5').hexdigest()
+                return
+            pwd = sim_auth[1].encode('ascii')
+            msg = self._decode_base64(sim_cram_md5_challenge).encode('ascii')
+            try:
+                valid_hashed_pass = hmac.HMAC(pwd, msg, 'md5').hexdigest()
+            except ValueError:
+                self.push('504 CRAM-MD5 is not supported')
+                return
             self._authenticated(user, hashed_pass == valid_hashed_pass)
     # end AUTH related stuff.
 
@@ -1170,8 +1176,7 @@ def auth_buggy(challenge=None):
         finally:
             smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @hashlib_helper.requires_hashdigest('md5', openssl=True)
     def testAUTH_CRAM_MD5(self):
         self.serv.add_feature("AUTH CRAM-MD5")
@@ -1181,8 +1186,39 @@ def testAUTH_CRAM_MD5(self):
         self.assertEqual(resp, (235, b'Authentication Succeeded'))
         smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @mock.patch("hmac.HMAC")
+    @mock.patch("smtplib._have_cram_md5_support", False)
+    def testAUTH_CRAM_MD5_blocked(self, hmac_constructor):
+        # CRAM-MD5 is the only "known" method by the server,
+        # but it is not supported by the client. In particular,
+        # no challenge will ever be sent.
+        self.serv.add_feature("AUTH CRAM-MD5")
+        smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost',
+                            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+        msg = re.escape("No suitable authentication method found.")
+        with self.assertRaisesRegex(smtplib.SMTPException, msg):
+            smtp.login(sim_auth[0], sim_auth[1])
+        hmac_constructor.assert_not_called()  # call has been bypassed
+
+    @mock.patch("smtplib._have_cram_md5_support", False)
+    def testAUTH_CRAM_MD5_blocked_and_fallback(self):
+        # Test that PLAIN is tried after CRAM-MD5 failed
+        self.serv.add_feature("AUTH CRAM-MD5 PLAIN")
+        smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost',
+                            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+        with (
+            mock.patch.object(smtp, "auth_cram_md5") as smtp_auth_cram_md5,
+            mock.patch.object(
+                smtp, "auth_plain", wraps=smtp.auth_plain
+            ) as smtp_auth_plain
+        ):
+            resp = smtp.login(sim_auth[0], sim_auth[1])
+        smtp_auth_plain.assert_called_once()
+        smtp_auth_cram_md5.assert_not_called()  # no call to HMAC constructor
+        self.assertEqual(resp, (235, b'Authentication Succeeded'))
+
     @hashlib_helper.requires_hashdigest('md5', openssl=True)
     def testAUTH_multiple(self):
         # Test that multiple authentication methods are tried.
@@ -1193,8 +1229,7 @@ def testAUTH_multiple(self):
         self.assertEqual(resp, (235, b'Authentication Succeeded'))
         smtp.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_auth_function(self):
         supported = {'PLAIN', 'LOGIN'}
         try:
@@ -1354,6 +1389,18 @@ def test_name_field_not_included_in_envelop_addresses(self):
         self.assertEqual(self.serv._addresses['from'], 'michael@example.com')
         self.assertEqual(self.serv._addresses['tos'], ['rene@example.com'])
 
+    def test_lowercase_mail_from_rcpt_to(self):
+        m = 'A test message'
+        smtp = smtplib.SMTP(
+            HOST, self.port, local_hostname='localhost',
+            timeout=support.LOOPBACK_TIMEOUT)
+        self.addCleanup(smtp.close)
+
+        smtp.sendmail('John', 'Sally', m)
+
+        self.assertIn(['mail from:<John> size=14'], self.serv._SMTPchannel.all_received_lines)
+        self.assertIn(['rcpt to:<Sally>'], self.serv._SMTPchannel.all_received_lines)
+
 
 class SimSMTPUTF8Server(SimSMTPServer):
 
@@ -1372,7 +1419,7 @@ def handle_accepted(self, conn, addr):
         )
 
     def process_message(self, peer, mailfrom, rcpttos, data, mail_options=None,
-                        rcpt_options=None):
+                                                             rcpt_options=None):
         self.last_peer = peer
         self.last_mailfrom = mailfrom
         self.last_rcpttos = rcpttos
diff --git a/Lib/test/test_smtpnet.py b/Lib/test/test_smtpnet.py
index be25e961f7..d765746987 100644
--- a/Lib/test/test_smtpnet.py
+++ b/Lib/test/test_smtpnet.py
@@ -2,6 +2,7 @@
 from test import support
 from test.support import import_helper
 from test.support import socket_helper
+import os
 import smtplib
 import socket
 
@@ -9,6 +10,8 @@
 
 support.requires("network")
 
+SMTP_TEST_SERVER = os.getenv('CPYTHON_TEST_SMTP_SERVER', 'smtp.gmail.com')
+
 def check_ssl_verifiy(host, port):
     context = ssl.create_default_context()
     with socket.create_connection((host, port)) as sock:
@@ -22,7 +25,7 @@ def check_ssl_verifiy(host, port):
 
 
 class SmtpTest(unittest.TestCase):
-    testServer = 'smtp.gmail.com'
+    testServer = SMTP_TEST_SERVER
     remotePort = 587
 
     def test_connect_starttls(self):
@@ -44,7 +47,7 @@ def test_connect_starttls(self):
 
 
 class SmtpSSLTest(unittest.TestCase):
-    testServer = 'smtp.gmail.com'
+    testServer = SMTP_TEST_SERVER
     remotePort = 465
 
     def test_connect(self):
@@ -87,4 +90,4 @@ def test_connect_using_sslcontext_verified(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
\ No newline at end of file
+    unittest.main()
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index ea544f6afa..57539a3862 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -1,9 +1,9 @@
 import unittest
+from unittest import mock
 from test import support
-from test.support import os_helper
-from test.support import socket_helper
-from test.support import threading_helper
-
+from test.support import (
+    is_apple, os_helper, refleak_helper, socket_helper, threading_helper
+)
 import _thread as thread
 import array
 import contextlib
@@ -28,6 +28,7 @@
 import threading
 import time
 import traceback
+import warnings
 from weakref import proxy
 try:
     import multiprocessing
@@ -37,6 +38,10 @@
     import fcntl
 except ImportError:
     fcntl = None
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
 
 support.requires_working_socket(module=True)
 
@@ -44,6 +49,7 @@
 # test unicode string and carriage return
 MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8')
 
+VMADDR_CID_LOCAL = 1
 VSOCKPORT = 1234
 AIX = platform.system() == "AIX"
 WSL = "microsoft-standard-WSL" in platform.release()
@@ -53,6 +59,35 @@
 except ImportError:
     _socket = None
 
+def skipForRefleakHuntinIf(condition, issueref):
+    if not condition:
+        def decorator(f):
+            f.client_skip = lambda f: f
+            return f
+
+    else:
+        def decorator(f):
+            @contextlib.wraps(f)
+            def wrapper(*args, **kwds):
+                if refleak_helper.hunting_for_refleaks():
+                    raise unittest.SkipTest(f"ignore while hunting for refleaks, see {issueref}")
+
+                return f(*args, **kwds)
+
+            def client_skip(f):
+                @contextlib.wraps(f)
+                def wrapper(*args, **kwds):
+                    if refleak_helper.hunting_for_refleaks():
+                        return
+
+                    return f(*args, **kwds)
+
+                return wrapper
+            wrapper.client_skip = client_skip
+            return wrapper
+
+    return decorator
+
 def get_cid():
     if fcntl is None:
         return None
@@ -128,8 +163,8 @@ def _have_socket_qipcrtr():
 
 def _have_socket_vsock():
     """Check whether AF_VSOCK sockets are supported on this host."""
-    ret = get_cid() is not None
-    return ret
+    cid = get_cid()
+    return (cid is not None)
 
 
 def _have_socket_bluetooth():
@@ -145,6 +180,17 @@ def _have_socket_bluetooth():
     return True
 
 
+def _have_socket_bluetooth_l2cap():
+    """Check whether BTPROTO_L2CAP sockets are supported on this host."""
+    try:
+        s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP)
+    except (AttributeError, OSError):
+        return False
+    else:
+        s.close()
+    return True
+
+
 def _have_socket_hyperv():
     """Check whether AF_HYPERV sockets are supported on this host."""
     try:
@@ -166,6 +212,24 @@ def socket_setdefaulttimeout(timeout):
         socket.setdefaulttimeout(old_timeout)
 
 
+@contextlib.contextmanager
+def downgrade_malformed_data_warning():
+    # This warning happens on macos and win, but does not always happen on linux.
+    if sys.platform not in {"win32", "darwin"}:
+        yield
+        return
+
+    with warnings.catch_warnings():
+        # TODO: gh-110012, we should investigate why this warning is happening
+        # and fix it properly.
+        warnings.filterwarnings(
+            action="always",
+            message="received malformed or improperly-truncated ancillary data",
+            category=RuntimeWarning,
+        )
+        yield
+
+
 HAVE_SOCKET_CAN = _have_socket_can()
 
 HAVE_SOCKET_CAN_ISOTP = _have_socket_can_isotp()
@@ -180,10 +244,15 @@ def socket_setdefaulttimeout(timeout):
 
 HAVE_SOCKET_VSOCK = _have_socket_vsock()
 
-HAVE_SOCKET_UDPLITE = hasattr(socket, "IPPROTO_UDPLITE")
+# Older Android versions block UDPLITE with SELinux.
+HAVE_SOCKET_UDPLITE = (
+    hasattr(socket, "IPPROTO_UDPLITE")
+    and not (support.is_android and platform.android_ver().api_level < 29))
 
 HAVE_SOCKET_BLUETOOTH = _have_socket_bluetooth()
 
+HAVE_SOCKET_BLUETOOTH_L2CAP = _have_socket_bluetooth_l2cap()
+
 HAVE_SOCKET_HYPERV = _have_socket_hyperv()
 
 # Size in bytes of the int type
@@ -485,8 +554,8 @@ def clientTearDown(self):
 @unittest.skipIf(WSL, 'VSOCK does not work on Microsoft WSL')
 @unittest.skipUnless(HAVE_SOCKET_VSOCK,
           'VSOCK sockets required for this test.')
-@unittest.skipUnless(get_cid() != 2,
-          "This test can only be run on a virtual guest.")
+@unittest.skipUnless(get_cid() != 2,  # VMADDR_CID_HOST
+                     "This test can only be run on a virtual guest.")
 class ThreadedVSOCKSocketStreamTest(unittest.TestCase, ThreadableTest):
 
     def __init__(self, methodName='runTest'):
@@ -508,10 +577,16 @@ def clientSetUp(self):
         self.cli = socket.socket(socket.AF_VSOCK, socket.SOCK_STREAM)
         self.addCleanup(self.cli.close)
         cid = get_cid()
+        if cid in (socket.VMADDR_CID_HOST, socket.VMADDR_CID_ANY):
+            # gh-119461: Use the local communication address (loopback)
+            cid = VMADDR_CID_LOCAL
         self.cli.connect((cid, VSOCKPORT))
 
     def testStream(self):
-        msg = self.conn.recv(1024)
+        try:
+            msg = self.conn.recv(1024)
+        except PermissionError as exc:
+            self.skipTest(repr(exc))
         self.assertEqual(msg, MSG)
 
     def _testStream(self):
@@ -556,19 +631,27 @@ class SocketPairTest(unittest.TestCase, ThreadableTest):
     def __init__(self, methodName='runTest'):
         unittest.TestCase.__init__(self, methodName=methodName)
         ThreadableTest.__init__(self)
+        self.cli = None
+        self.serv = None
+
+    def socketpair(self):
+        # To be overridden by some child classes.
+        return socket.socketpair()
 
     def setUp(self):
-        self.serv, self.cli = socket.socketpair()
+        self.serv, self.cli = self.socketpair()
 
     def tearDown(self):
-        self.serv.close()
+        if self.serv:
+            self.serv.close()
         self.serv = None
 
     def clientSetUp(self):
         pass
 
     def clientTearDown(self):
-        self.cli.close()
+        if self.cli:
+            self.cli.close()
         self.cli = None
         ThreadableTest.clientTearDown(self)
 
@@ -821,9 +904,9 @@ def requireSocket(*args):
 
 class GeneralModuleTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(_socket is not None, 'need _socket module')
+    # TODO: RUSTPYTHON; gc.is_tracked not implemented
+    @unittest.expectedFailure
     def test_socket_type(self):
         self.assertTrue(gc.is_tracked(_socket.socket))
         with self.assertRaisesRegex(TypeError, "immutable"):
@@ -886,7 +969,7 @@ def testSocketError(self):
         with self.assertRaises(OSError, msg=msg % 'socket.gaierror'):
             raise socket.gaierror
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON; error message format differs
     @unittest.expectedFailure
     def testSendtoErrors(self):
         # Testing that sendto doesn't mask failures. See #10169.
@@ -973,8 +1056,6 @@ def test_socket_methods(self):
             if not hasattr(socket.socket, name):
                 self.fail(f"socket method {name} is missing")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(sys.platform == 'darwin', 'macOS specific test')
     @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 required for this test')
     def test3542SocketOptions(self):
@@ -1090,7 +1171,10 @@ def testInterfaceNameIndex(self):
     @unittest.skipUnless(hasattr(socket, 'if_indextoname'),
                          'socket.if_indextoname() not available.')
     def testInvalidInterfaceIndexToName(self):
-        self.assertRaises(OSError, socket.if_indextoname, 0)
+        with self.assertRaises(OSError) as cm:
+            socket.if_indextoname(0)
+        self.assertIsNotNone(cm.exception.errno)
+
         self.assertRaises(OverflowError, socket.if_indextoname, -1)
         self.assertRaises(OverflowError, socket.if_indextoname, 2**1000)
         self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
@@ -1109,8 +1193,11 @@ def testInvalidInterfaceIndexToName(self):
     @unittest.skipUnless(hasattr(socket, 'if_nametoindex'),
                          'socket.if_nametoindex() not available.')
     def testInvalidInterfaceNameToIndex(self):
+        with self.assertRaises(OSError) as cm:
+            socket.if_nametoindex("_DEADBEEF")
+        self.assertIsNotNone(cm.exception.errno)
+
         self.assertRaises(TypeError, socket.if_nametoindex, 0)
-        self.assertRaises(OSError, socket.if_nametoindex, '_DEADBEEF')
 
     @unittest.skipUnless(hasattr(sys, 'getrefcount'),
                          'test needs sys.getrefcount()')
@@ -1147,6 +1234,7 @@ def testNtoH(self):
             self.assertRaises(OverflowError, func, 1<<34)
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def testNtoHErrors(self):
         import _testcapi
         s_good_values = [0, 1, 2, 0xffff]
@@ -1175,8 +1263,11 @@ def testGetServBy(self):
         # Find one service that exists, then check all the related interfaces.
         # I've ordered this by protocols that have both a tcp and udp
         # protocol, at least for modern Linuxes.
-        if (sys.platform.startswith(('freebsd', 'netbsd', 'gnukfreebsd'))
-            or sys.platform in ('linux', 'darwin')):
+        if (
+            sys.platform.startswith(
+                ('linux', 'android', 'freebsd', 'netbsd', 'gnukfreebsd'))
+            or is_apple
+        ):
             # avoid the 'echo' service on this platform, as there is an
             # assumption breaking non-standard port/protocol entry
             services = ('daytime', 'qotd', 'domain')
@@ -1191,9 +1282,8 @@ def testGetServBy(self):
         else:
             raise OSError
         # Try same call with optional protocol omitted
-        # Issue #26936: Android getservbyname() was broken before API 23.
-        if (not hasattr(sys, 'getandroidapilevel') or
-                sys.getandroidapilevel() >= 23):
+        # Issue gh-71123: this fails on Android before API level 23.
+        if not (support.is_android and platform.android_ver().api_level < 23):
             port2 = socket.getservbyname(service)
             eq(port, port2)
         # Try udp, but don't barf if it doesn't exist
@@ -1204,8 +1294,9 @@ def testGetServBy(self):
         else:
             eq(udpport, port)
         # Now make sure the lookup by port returns the same service name
-        # Issue #26936: Android getservbyport() is broken.
-        if not support.is_android:
+        # Issue #26936: when the protocol is omitted, this fails on Android
+        # before API level 28.
+        if not (support.is_android and platform.android_ver().api_level < 28):
             eq(socket.getservbyport(port2), service)
         eq(socket.getservbyport(port, 'tcp'), service)
         if udpport is not None:
@@ -1503,8 +1594,6 @@ def test_getsockaddrarg(self):
                 break
 
     @unittest.skipUnless(os.name == "nt", "Windows specific")
-    # TODO: RUSTPYTHON, windows ioctls
-    @unittest.expectedFailure
     def test_sock_ioctl(self):
         self.assertTrue(hasattr(socket.socket, 'ioctl'))
         self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
@@ -1519,8 +1608,6 @@ def test_sock_ioctl(self):
     @unittest.skipUnless(os.name == "nt", "Windows specific")
     @unittest.skipUnless(hasattr(socket, 'SIO_LOOPBACK_FAST_PATH'),
                          'Loopback fast path support required for this test')
-    # TODO: RUSTPYTHON, AttributeError: 'socket' object has no attribute 'ioctl'
-    @unittest.expectedFailure
     def test_sio_loopback_fast_path(self):
         s = socket.socket()
         self.addCleanup(s.close)
@@ -1554,9 +1641,8 @@ def testGetaddrinfo(self):
             socket.getaddrinfo('::1', 80)
         # port can be a string service name such as "http", a numeric
         # port number or None
-        # Issue #26936: Android getaddrinfo() was broken before API level 23.
-        if (not hasattr(sys, 'getandroidapilevel') or
-                sys.getandroidapilevel() >= 23):
+        # Issue #26936: this fails on Android before API level 23.
+        if not (support.is_android and platform.android_ver().api_level < 23):
             socket.getaddrinfo(HOST, "http")
         socket.getaddrinfo(HOST, 80)
         socket.getaddrinfo(HOST, None)
@@ -1602,8 +1688,7 @@ def testGetaddrinfo(self):
                                flags=socket.AI_PASSIVE)
         self.assertEqual(a, b)
         # Issue #6697.
-        # XXX RUSTPYTHON TODO: surrogates in str
-        # self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
+        self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
 
         # Issue 17269: test workaround for OS X platform bug segfault
         if hasattr(socket, 'AI_NUMERICSERV'):
@@ -1615,8 +1700,7 @@ def testGetaddrinfo(self):
             except socket.gaierror:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_getaddrinfo_int_port_overflow(self):
         # gh-74895: Test that getaddrinfo does not raise OverflowError on port.
         #
@@ -1634,7 +1718,7 @@ def test_getaddrinfo_int_port_overflow(self):
         try:
             socket.getaddrinfo(None, ULONG_MAX + 1, type=socket.SOCK_STREAM)
         except OverflowError:
-            # Platforms differ as to what values consitute a getaddrinfo() error
+            # Platforms differ as to what values constitute a getaddrinfo() error
             # return. Some fail for LONG_MAX+1, others ULONG_MAX+1, and Windows
             # silently accepts such huge "port" aka "service" numeric values.
             self.fail("Either no error or socket.gaierror expected.")
@@ -1669,7 +1753,6 @@ def test_getnameinfo(self):
         # only IP addresses are allowed
         self.assertRaises(OSError, socket.getnameinfo, ('mail.python.org',0), 0)
 
-    @unittest.skip("TODO: RUSTPYTHON: flaky on CI?")
     @unittest.skipUnless(support.is_resource_enabled('network'),
                          'network is not enabled')
     def test_idna(self):
@@ -1724,8 +1807,6 @@ def test_sendall_interrupted(self):
     def test_sendall_interrupted_with_timeout(self):
         self.check_sendall_interrupted(True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dealloc_warn(self):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         r = repr(sock)
@@ -1813,6 +1894,7 @@ def test_listen_backlog(self):
             srv.listen()
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def test_listen_backlog_overflow(self):
         # Issue 15989
         import _testcapi
@@ -1905,7 +1987,6 @@ def test_str_for_enums(self):
             self.assertEqual(str(s.family), str(s.family.value))
             self.assertEqual(str(s.type), str(s.type.value))
 
-    @unittest.expectedFailureIf(sys.platform.startswith("linux"), "TODO: RUSTPYTHON, AssertionError: 526337 != <SocketKind.SOCK_STREAM: 1>")
     def test_socket_consistent_sock_type(self):
         SOCK_NONBLOCK = getattr(socket, 'SOCK_NONBLOCK', 0)
         SOCK_CLOEXEC = getattr(socket, 'SOCK_CLOEXEC', 0)
@@ -2052,8 +2133,6 @@ def test_socket_fileno_requires_socket_fd(self):
                     fileno=afile.fileno())
             self.assertEqual(cm.exception.errno, errno.ENOTSOCK)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_addressfamily_enum(self):
         import _socket, enum
         CheckedAddressFamily = enum._old_convert_(
@@ -2063,8 +2142,6 @@ def test_addressfamily_enum(self):
                 )
         enum._test_simple_enum(CheckedAddressFamily, socket.AddressFamily)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_socketkind_enum(self):
         import _socket, enum
         CheckedSocketKind = enum._old_convert_(
@@ -2074,8 +2151,6 @@ def test_socketkind_enum(self):
                 )
         enum._test_simple_enum(CheckedSocketKind, socket.SocketKind)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_msgflag_enum(self):
         import _socket, enum
         CheckedMsgFlag = enum._old_convert_(
@@ -2085,8 +2160,6 @@ def test_msgflag_enum(self):
                 )
         enum._test_simple_enum(CheckedMsgFlag, socket.MsgFlag)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_addressinfo_enum(self):
         import _socket, enum
         CheckedAddressInfo = enum._old_convert_(
@@ -2106,8 +2179,6 @@ def testCrucialConstants(self):
 
     @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
                          'socket.CAN_BCM required for this test.')
-    # TODO: RUSTPYTHON, AttributeError: module 'socket' has no attribute 'CAN_BCM_TX_SETUP'
-    @unittest.expectedFailure
     def testBCMConstants(self):
         socket.CAN_BCM
 
@@ -2148,16 +2219,12 @@ def testCreateBCMSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM) as s:
             pass
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testBindAny(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             address = ('', )
             s.bind(address)
             self.assertEqual(s.getsockname(), address)
 
-    # TODO: RUSTPYTHON, AssertionError: "interface name too long" does not match "bind(): bad family"
-    @unittest.expectedFailure
     def testTooLongInterfaceName(self):
         # most systems limit IFNAMSIZ to 16, take 1024 to be sure
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
@@ -2300,16 +2367,12 @@ def testCreateISOTPSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
             pass
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testTooLongInterfaceName(self):
         # most systems limit IFNAMSIZ to 16, take 1024 to be sure
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
             with self.assertRaisesRegex(OSError, 'interface name too long'):
                 s.bind(('x' * 1024, 1, 2))
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def testBind(self):
         try:
             with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_ISOTP) as s:
@@ -2331,7 +2394,7 @@ def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.interface = "vcan0"
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - J1939 constants not fully implemented
     @unittest.expectedFailure
     @unittest.skipUnless(hasattr(socket, "CAN_J1939"),
                          'socket.CAN_J1939 required for this test.')
@@ -2374,7 +2437,7 @@ def testCreateJ1939Socket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_J1939) as s:
             pass
 
-    # TODO: RUSTPYTHON
+    # TODO: RUSTPYTHON - AF_CAN J1939 address format not fully implemented
     @unittest.expectedFailure
     def testBind(self):
         try:
@@ -2587,6 +2650,143 @@ def testCreateScoSocket(self):
         with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
             pass
 
+    @unittest.skipUnless(HAVE_SOCKET_BLUETOOTH_L2CAP, 'Bluetooth L2CAP sockets required for this test')
+    def testBindBrEdrL2capSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            # First user PSM in BR/EDR L2CAP
+            psm = 0x1001
+            f.bind((socket.BDADDR_ANY, psm))
+            addr = f.getsockname()
+            self.assertEqual(addr, (socket.BDADDR_ANY, psm))
+
+    @unittest.skipUnless(HAVE_SOCKET_BLUETOOTH_L2CAP, 'Bluetooth L2CAP sockets required for this test')
+    def testBadL2capAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_L2CAP) as f:
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY, 0, 0))
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                f.bind(socket.BDADDR_ANY)
+            with self.assertRaises(OSError):
+                f.bind((socket.BDADDR_ANY.encode(), 0x1001))
+            with self.assertRaises(OSError):
+                f.bind(('\ud812', 0x1001))
+
+    def testBindRfcommSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            channel = 0
+            try:
+                s.bind((socket.BDADDR_ANY, channel))
+            except OSError as err:
+                if sys.platform == 'win32' and err.winerror == 10050:
+                    self.skipTest(str(err))
+                raise
+            addr = s.getsockname()
+            self.assertEqual(addr, (mock.ANY, channel))
+            self.assertRegex(addr[0], r'(?i)[0-9a-f]{2}(?::[0-9a-f]{2}){4}')
+            if sys.platform != 'win32':
+                self.assertEqual(addr, (socket.BDADDR_ANY, channel))
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            s.bind(addr)
+            addr2 = s.getsockname()
+            self.assertEqual(addr2, addr)
+
+    def testBadRfcommAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_STREAM, socket.BTPROTO_RFCOMM) as s:
+            channel = 0
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY.encode(), channel))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY, channel, 0))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY + '\0', channel))
+            with self.assertRaises(OSError):
+                s.bind('\ud812')
+            with self.assertRaises(OSError):
+                s.bind(('invalid', channel))
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_HCI'), 'Bluetooth HCI sockets required for this test')
+    def testBindHciSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
+            if sys.platform.startswith(('netbsd', 'dragonfly', 'freebsd')):
+                s.bind(socket.BDADDR_ANY)
+                addr = s.getsockname()
+                self.assertEqual(addr, socket.BDADDR_ANY)
+            else:
+                dev = 0
+                try:
+                    s.bind((dev,))
+                except OSError as err:
+                    if err.errno in (errno.EINVAL, errno.ENODEV):
+                        self.skipTest(str(err))
+                    raise
+                addr = s.getsockname()
+                self.assertEqual(addr, dev)
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_HCI'), 'Bluetooth HCI sockets required for this test')
+    def testBadHciAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) as s:
+            if sys.platform.startswith(('netbsd', 'dragonfly', 'freebsd')):
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY.encode())
+                with self.assertRaises(OSError):
+                    s.bind((socket.BDADDR_ANY,))
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY + '\0')
+                with self.assertRaises((ValueError, OSError)):
+                    s.bind(socket.BDADDR_ANY + ' '*100)
+                with self.assertRaises(OSError):
+                    s.bind('\ud812')
+                with self.assertRaises(OSError):
+                    s.bind('invalid')
+                with self.assertRaises(OSError):
+                    s.bind(b'invalid')
+            else:
+                dev = 0
+                with self.assertRaises(OSError):
+                    s.bind(())
+                with self.assertRaises(OSError):
+                    s.bind((dev, 0))
+                with self.assertRaises(OSError):
+                    s.bind(dev)
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY)
+                with self.assertRaises(OSError):
+                    s.bind(socket.BDADDR_ANY.encode())
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_SCO'), 'Bluetooth SCO sockets required for this test')
+    def testBindScoSocket(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            s.bind(socket.BDADDR_ANY)
+            addr = s.getsockname()
+            self.assertEqual(addr, socket.BDADDR_ANY)
+
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            s.bind(socket.BDADDR_ANY.encode())
+            addr = s.getsockname()
+            self.assertEqual(addr, socket.BDADDR_ANY)
+
+    @unittest.skipUnless(hasattr(socket, 'BTPROTO_SCO'), 'Bluetooth SCO sockets required for this test')
+    def testBadScoAddr(self):
+        with socket.socket(socket.AF_BLUETOOTH, socket.SOCK_SEQPACKET, socket.BTPROTO_SCO) as s:
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY,))
+            with self.assertRaises(OSError):
+                s.bind((socket.BDADDR_ANY.encode(),))
+            with self.assertRaises(ValueError):
+                s.bind(socket.BDADDR_ANY + '\0')
+            with self.assertRaises(ValueError):
+                s.bind(socket.BDADDR_ANY.encode() + b'\0')
+            with self.assertRaises(UnicodeEncodeError):
+                s.bind('\ud812')
+            with self.assertRaises(OSError):
+                s.bind('invalid')
+            with self.assertRaises(OSError):
+                s.bind(b'invalid')
+
 
 @unittest.skipUnless(HAVE_SOCKET_HYPERV,
                      'Hyper-V sockets required for this test.')
@@ -2717,22 +2917,29 @@ def testDup(self):
     def _testDup(self):
         self.serv_conn.send(MSG)
 
-    def testShutdown(self):
-        # Testing shutdown()
+    def check_shutdown(self):
+        # Test shutdown() helper
         msg = self.cli_conn.recv(1024)
         self.assertEqual(msg, MSG)
-        # wait for _testShutdown to finish: on OS X, when the server
+        # wait for _testShutdown[_overflow] to finish: on OS X, when the server
         # closes the connection the client also becomes disconnected,
         # and the client's shutdown call will fail. (Issue #4397.)
         self.done.wait()
 
+    def testShutdown(self):
+        self.check_shutdown()
+
     def _testShutdown(self):
         self.serv_conn.send(MSG)
         self.serv_conn.shutdown(2)
 
-    testShutdown_overflow = support.cpython_only(testShutdown)
+    @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
+    def testShutdown_overflow(self):
+        self.check_shutdown()
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def _testShutdown_overflow(self):
         import _testcapi
         self.serv_conn.send(MSG)
@@ -3203,7 +3410,7 @@ def _testSendmsgTimeout(self):
     # Linux supports MSG_DONTWAIT when sending, but in general, it
     # only works when receiving.  Could add other platforms if they
     # support it too.
-    @skipWithClientIf(sys.platform not in {"linux"},
+    @skipWithClientIf(sys.platform not in {"linux", "android"},
                       "MSG_DONTWAIT not known to work on this platform when "
                       "sending")
     def testSendmsgDontWait(self):
@@ -3720,7 +3927,7 @@ def testFDPassCMSG_LEN(self):
     def _testFDPassCMSG_LEN(self):
         self.createAndSendFDs(1)
 
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparate(self):
@@ -3731,7 +3938,7 @@ def testFDPassSeparate(self):
                              maxcmsgs=2)
 
     @testFDPassSeparate.client_skip
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparate(self):
         fd0, fd1 = self.newFDs(2)
@@ -3744,7 +3951,7 @@ def _testFDPassSeparate(self):
                                           array.array("i", [fd1]))]),
             len(MSG))
 
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparateMinSpace(self):
@@ -3758,7 +3965,7 @@ def testFDPassSeparateMinSpace(self):
                              maxcmsgs=2, ignoreflags=socket.MSG_CTRUNC)
 
     @testFDPassSeparateMinSpace.client_skip
-    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     @unittest.skipIf(AIX, "skipping, see issue #22397")
     def _testFDPassSeparateMinSpace(self):
         fd0, fd1 = self.newFDs(2)
@@ -3782,7 +3989,7 @@ def sendAncillaryIfPossible(self, msg, ancdata):
             nbytes = self.sendmsgToServer([msg])
         self.assertEqual(nbytes, len(msg))
 
-    @unittest.skipIf(sys.platform == "darwin", "see issue #24725")
+    @unittest.skipIf(is_apple, "skipping, see issue #12958")
     def testFDPassEmpty(self):
         # Try to pass an empty FD array.  Can receive either no array
         # or an empty array.
@@ -3856,6 +4063,7 @@ def checkTruncatedHeader(self, result, ignoreflags=0):
         self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC,
                         ignore=ignoreflags)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncNoBufSize(self):
         # Check that no ancillary data is received when no buffer size
         # is specified.
@@ -3865,26 +4073,32 @@ def testCmsgTruncNoBufSize(self):
                                   # received.
                                   ignoreflags=socket.MSG_CTRUNC)
 
+    @testCmsgTruncNoBufSize.client_skip
     def _testCmsgTruncNoBufSize(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc0(self):
         # Check that no ancillary data is received when buffer size is 0.
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 0),
                                   ignoreflags=socket.MSG_CTRUNC)
 
+    @testCmsgTrunc0.client_skip
     def _testCmsgTrunc0(self):
         self.createAndSendFDs(1)
 
     # Check that no ancillary data is returned for various non-zero
     # (but still too small) buffer sizes.
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc1(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 1))
 
+    @testCmsgTrunc1.client_skip
     def _testCmsgTrunc1(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTrunc2Int(self):
         # The cmsghdr structure has at least three members, two of
         # which are ints, so we still shouldn't see any ancillary
@@ -3892,13 +4106,16 @@ def testCmsgTrunc2Int(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
                                                  SIZEOF_INT * 2))
 
+    @testCmsgTrunc2Int.client_skip
     def _testCmsgTrunc2Int(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0Minus1(self):
         self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
                                                  socket.CMSG_LEN(0) - 1))
 
+    @testCmsgTruncLen0Minus1.client_skip
     def _testCmsgTruncLen0Minus1(self):
         self.createAndSendFDs(1)
 
@@ -3910,8 +4127,9 @@ def checkTruncatedArray(self, ancbuf, maxdata, mindata=0):
         # mindata and maxdata bytes when received with buffer size
         # ancbuf, and that any complete file descriptor numbers are
         # valid.
-        msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
-                                                   len(MSG), ancbuf)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
+                                                       len(MSG), ancbuf)
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
         self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC)
@@ -3929,29 +4147,38 @@ def checkTruncatedArray(self, ancbuf, maxdata, mindata=0):
                 len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
         self.checkFDs(fds)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0), maxdata=0)
 
+    @testCmsgTruncLen0.client_skip
     def _testCmsgTruncLen0(self):
         self.createAndSendFDs(1)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen0Plus1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0) + 1, maxdata=1)
 
+    @testCmsgTruncLen0Plus1.client_skip
     def _testCmsgTruncLen0Plus1(self):
         self.createAndSendFDs(2)
 
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(SIZEOF_INT),
                                  maxdata=SIZEOF_INT)
 
+    @testCmsgTruncLen1.client_skip
     def _testCmsgTruncLen1(self):
         self.createAndSendFDs(2)
 
+
+    @skipForRefleakHuntinIf(sys.platform == "darwin", "#80931")
     def testCmsgTruncLen2Minus1(self):
         self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(2 * SIZEOF_INT) - 1,
                                  maxdata=(2 * SIZEOF_INT) - 1)
 
+    @testCmsgTruncLen2Minus1.client_skip
     def _testCmsgTruncLen2Minus1(self):
         self.createAndSendFDs(2)
 
@@ -4253,8 +4480,9 @@ def testSingleCmsgTruncInData(self):
         self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
                                   socket.IPV6_RECVHOPLIMIT, 1)
         self.misc_event.set()
-        msg, ancdata, flags, addr = self.doRecvmsg(
-            self.serv_sock, len(MSG), socket.CMSG_LEN(SIZEOF_INT) - 1)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(
+                self.serv_sock, len(MSG), socket.CMSG_LEN(SIZEOF_INT) - 1)
 
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
@@ -4357,9 +4585,10 @@ def testSecondCmsgTruncInData(self):
         self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
                                   socket.IPV6_RECVTCLASS, 1)
         self.misc_event.set()
-        msg, ancdata, flags, addr = self.doRecvmsg(
-            self.serv_sock, len(MSG),
-            socket.CMSG_SPACE(SIZEOF_INT) + socket.CMSG_LEN(SIZEOF_INT) - 1)
+        with downgrade_malformed_data_warning():  # TODO: gh-110012
+            msg, ancdata, flags, addr = self.doRecvmsg(
+                self.serv_sock, len(MSG),
+                socket.CMSG_SPACE(SIZEOF_INT) + socket.CMSG_LEN(SIZEOF_INT) - 1)
 
         self.assertEqual(msg, MSG)
         self.checkRecvmsgAddress(addr, self.cli_addr)
@@ -4601,7 +4830,6 @@ class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase,
                                     ConnectedStreamTestMixin, UnixStreamBase):
     pass
 
-@unittest.skipIf(sys.platform == "darwin", "flaky on macOS")
 @requireAttrs(socket.socket, "sendmsg")
 @requireAttrs(socket, "AF_UNIX")
 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
@@ -4824,6 +5052,112 @@ def _testSend(self):
         self.assertEqual(msg, MSG)
 
 
+class PurePythonSocketPairTest(SocketPairTest):
+    # Explicitly use socketpair AF_INET or AF_INET6 to ensure that is the
+    # code path we're using regardless platform is the pure python one where
+    # `_socket.socketpair` does not exist.  (AF_INET does not work with
+    # _socket.socketpair on many platforms).
+    def socketpair(self):
+        # called by super().setUp().
+        try:
+            return socket.socketpair(socket.AF_INET6)
+        except OSError:
+            return socket.socketpair(socket.AF_INET)
+
+    # Local imports in this class make for easy security fix backporting.
+
+    def setUp(self):
+        if hasattr(_socket, "socketpair"):
+            self._orig_sp = socket.socketpair
+            # This forces the version using the non-OS provided socketpair
+            # emulation via an AF_INET socket in Lib/socket.py.
+            socket.socketpair = socket._fallback_socketpair
+        else:
+            # This platform already uses the non-OS provided version.
+            self._orig_sp = None
+        super().setUp()
+
+    def tearDown(self):
+        super().tearDown()
+        if self._orig_sp is not None:
+            # Restore the default socket.socketpair definition.
+            socket.socketpair = self._orig_sp
+
+    def test_recv(self):
+        msg = self.serv.recv(1024)
+        self.assertEqual(msg, MSG)
+
+    def _test_recv(self):
+        self.cli.send(MSG)
+
+    def test_send(self):
+        self.serv.send(MSG)
+
+    def _test_send(self):
+        msg = self.cli.recv(1024)
+        self.assertEqual(msg, MSG)
+
+    def test_ipv4(self):
+        cli, srv = socket.socketpair(socket.AF_INET)
+        cli.close()
+        srv.close()
+
+    def _test_ipv4(self):
+        pass
+
+    @unittest.skipIf(not hasattr(_socket, 'IPPROTO_IPV6') or
+                     not hasattr(_socket, 'IPV6_V6ONLY'),
+                     "IPV6_V6ONLY option not supported")
+    @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'IPv6 required for this test')
+    def test_ipv6(self):
+        cli, srv = socket.socketpair(socket.AF_INET6)
+        cli.close()
+        srv.close()
+
+    def _test_ipv6(self):
+        pass
+
+    def test_injected_authentication_failure(self):
+        orig_getsockname = socket.socket.getsockname
+        inject_sock = None
+
+        def inject_getsocketname(self):
+            nonlocal inject_sock
+            sockname = orig_getsockname(self)
+            # Connect to the listening socket ahead of the
+            # client socket.
+            if inject_sock is None:
+                inject_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                inject_sock.setblocking(False)
+                try:
+                    inject_sock.connect(sockname[:2])
+                except (BlockingIOError, InterruptedError):
+                    pass
+                inject_sock.setblocking(True)
+            return sockname
+
+        sock1 = sock2 = None
+        try:
+            socket.socket.getsockname = inject_getsocketname
+            with self.assertRaises(OSError):
+                sock1, sock2 = socket.socketpair()
+        finally:
+            socket.socket.getsockname = orig_getsockname
+            if inject_sock:
+                inject_sock.close()
+            if sock1:  # This cleanup isn't needed on a successful test.
+                sock1.close()
+            if sock2:
+                sock2.close()
+
+    def _test_injected_authentication_failure(self):
+        # No-op.  Exists for base class threading infrastructure to call.
+        # We could refactor this test into its own lesser class along with the
+        # setUp and tearDown code to construct an ideal; it is simpler to keep
+        # it here and live with extra overhead one this _one_ failure test.
+        pass
+
+
 class NonBlockingTCPTests(ThreadedTCPSocketTest):
 
     def __init__(self, methodName='runTest'):
@@ -4871,6 +5205,7 @@ def _testSetBlocking(self):
         pass
 
     @support.cpython_only
+    @unittest.skipIf(_testcapi is None, "requires _testcapi")
     def testSetBlocking_overflow(self):
         # Issue 15989
         import _testcapi
@@ -4888,8 +5223,6 @@ def testSetBlocking_overflow(self):
     @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
                          'test needs socket.SOCK_NONBLOCK')
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: None != 0
-    @unittest.expectedFailure
     def testInitNonBlocking(self):
         # create a socket with SOCK_NONBLOCK
         self.serv.close()
@@ -4985,6 +5318,39 @@ def _testRecv(self):
         # send data: recv() will no longer block
         self.cli.sendall(MSG)
 
+    def testLargeTimeout(self):
+        # gh-126876: Check that a timeout larger than INT_MAX is replaced with
+        # INT_MAX in the poll() code path. The following assertion must not
+        # fail: assert(INT_MIN <= ms && ms <= INT_MAX).
+        if _testcapi is not None:
+            large_timeout = _testcapi.INT_MAX + 1
+        else:
+            large_timeout = 2147483648
+
+        # test recv() with large timeout
+        conn, addr = self.serv.accept()
+        self.addCleanup(conn.close)
+        try:
+            conn.settimeout(large_timeout)
+        except OverflowError:
+            # On Windows, settimeout() fails with OverflowError, whereas
+            # we want to test recv(). Just give up silently.
+            return
+        msg = conn.recv(len(MSG))
+
+    def _testLargeTimeout(self):
+        # test sendall() with large timeout
+        if _testcapi is not None:
+            large_timeout = _testcapi.INT_MAX + 1
+        else:
+            large_timeout = 2147483648
+        self.cli.connect((HOST, self.port))
+        try:
+            self.cli.settimeout(large_timeout)
+        except OverflowError:
+            return
+        self.cli.sendall(MSG)
+
 
 class FileObjectClassTestCase(SocketConnectedTest):
     """Unit tests for the object returned by socket.makefile()
@@ -5187,6 +5553,8 @@ def _testMakefileClose(self):
         self.write_file.write(self.write_msg)
         self.write_file.flush()
 
+    @unittest.skipUnless(hasattr(sys, 'getrefcount'),
+                         'test needs sys.getrefcount()')
     def testMakefileCloseSocketDestroy(self):
         refcount_before = sys.getrefcount(self.cli_conn)
         self.read_file.close()
@@ -5360,8 +5728,6 @@ def test_create_connection(self):
         expected_errnos = socket_helper.get_socket_conn_refused_errs()
         self.assertIn(cm.exception.errno, expected_errnos)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_create_connection_all_errors(self):
         port = socket_helper.find_unused_port()
         try:
@@ -5627,7 +5993,7 @@ def test_setblocking_invalidfd(self):
             sock.setblocking(False)
 
 
-@unittest.skipUnless(sys.platform == 'linux', 'Linux specific test')
+@unittest.skipUnless(sys.platform in ('linux', 'android'), 'Linux specific test')
 class TestLinuxAbstractNamespace(unittest.TestCase):
 
     UNIX_PATH_MAX = 108
@@ -5752,7 +6118,8 @@ def testUnencodableAddr(self):
         self.addCleanup(os_helper.unlink, path)
         self.assertEqual(self.sock.getsockname(), path)
 
-    @unittest.skipIf(sys.platform == 'linux', 'Linux specific test')
+    @unittest.skipIf(sys.platform in ('linux', 'android'),
+                     'Linux behavior is tested by TestLinuxAbstractNamespace')
     def testEmptyAddress(self):
         # Test that binding empty address fails.
         self.assertRaises(OSError, self.sock.bind, "")
@@ -5978,8 +6345,6 @@ class InheritanceTest(unittest.TestCase):
     @unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
                          "SOCK_CLOEXEC not defined")
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: 524289 != <SocketKind.SOCK_STREAM: 1>
-    @unittest.expectedFailure
     def test_SOCK_CLOEXEC(self):
         with socket.socket(socket.AF_INET,
                            socket.SOCK_STREAM | socket.SOCK_CLOEXEC) as s:
@@ -6072,8 +6437,6 @@ def checkNonblock(self, s, nonblock=True, timeout=0.0):
             self.assertTrue(s.getblocking())
 
     @support.requires_linux_version(2, 6, 28)
-    # TODO: RUSTPYTHON, AssertionError: 2049 != <SocketKind.SOCK_STREAM: 1>
-    @unittest.expectedFailure
     def test_SOCK_NONBLOCK(self):
         # a lot of it seems silly and redundant, but I wanted to test that
         # changing back and forth worked ok
@@ -6109,7 +6472,6 @@ def test_SOCK_NONBLOCK(self):
 
 @unittest.skipUnless(os.name == "nt", "Windows specific")
 @unittest.skipUnless(multiprocessing, "need multiprocessing")
-@unittest.skip("TODO: RUSTPYTHON, socket sharing")
 class TestSocketSharing(SocketTCPTest):
     # This must be classmethod and not staticmethod or multiprocessing
     # won't be able to bootstrap it.
@@ -6127,6 +6489,8 @@ def remoteProcessServer(cls, q):
         s2.close()
         s.close()
 
+    # TODO: RUSTPYTHON; multiprocessing.SemLock not implemented
+    @unittest.expectedFailure
     def testShare(self):
         # Transfer the listening server socket to another process
         # and service it from there.
@@ -6350,7 +6714,6 @@ def _testCount(self):
             self.assertEqual(sent, count)
             self.assertEqual(file.tell(), count)
 
-    @unittest.skipIf(sys.platform == "darwin", "TODO: RUSTPYTHON, killed (for OOM?)")
     def testCount(self):
         count = 5000007
         conn = self.accept_conn()
@@ -6426,7 +6789,6 @@ def _testWithTimeout(self):
             sent = meth(file)
             self.assertEqual(sent, self.FILESIZE)
 
-    @unittest.skip("TODO: RUSTPYTHON")
     def testWithTimeout(self):
         conn = self.accept_conn()
         data = self.recv_data(conn)
@@ -6487,6 +6849,13 @@ class SendfileUsingSendfileTest(SendfileUsingSendTest):
     def meth_from_sock(self, sock):
         return getattr(sock, "_sendfile_use_sendfile")
 
+    @unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly; flaky")
+    def testWithTimeout(self):
+        super().testWithTimeout()
+
+    @unittest.skip("TODO: RUSTPYTHON; os.sendfile count parameter not handled correctly; flaky")
+    def testCount(self):
+        super().testCount()
 
 @unittest.skipUnless(HAVE_SOCKET_ALG, 'AF_ALG required')
 class LinuxKernelCryptoAPI(unittest.TestCase):
@@ -6504,9 +6873,8 @@ 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
     @support.requires_linux_version(4, 5)
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_sha256(self):
         expected = bytes.fromhex("ba7816bf8f01cfea414140de5dae2223b00361a396"
                                  "177a9cb410ff61f20015ad")
@@ -6524,7 +6892,7 @@ def test_sha256(self):
                 op.send(b'')
                 self.assertEqual(op.recv(512), expected)
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
     @unittest.expectedFailure
     def test_hmac_sha1(self):
         # gh-109396: In FIPS mode, Linux 6.5 requires a key
@@ -6541,9 +6909,9 @@ def test_hmac_sha1(self):
 
     # Although it should work with 3.19 and newer the test blocks on
     # Ubuntu 15.10 with Kernel 4.2.0-19.
-    @support.requires_linux_version(4, 3)
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
     @unittest.expectedFailure
+    @support.requires_linux_version(4, 3)
     def test_aes_cbc(self):
         key = bytes.fromhex('06a9214036b8a15b512e03d534120006')
         iv = bytes.fromhex('3dafba429d9eb430b422da802c9fac41')
@@ -6584,10 +6952,16 @@ def test_aes_cbc(self):
             self.assertEqual(len(dec), msglen * multiplier)
             self.assertEqual(dec, msg * multiplier)
 
-    @support.requires_linux_version(4, 9)  # see issue29324
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
     @unittest.expectedFailure
+    @support.requires_linux_version(4, 9)  # see gh-73510
     def test_aead_aes_gcm(self):
+        kernel_version = support._get_kernel_version("Linux")
+        if kernel_version is not None:
+            if kernel_version >= (6, 16) and kernel_version < (6, 18):
+                # See https://github.com/python/cpython/issues/139310.
+                self.skipTest("upstream Linux kernel issue")
+
         key = bytes.fromhex('c939cc13397c1d37de6ae0e1cb7c423c')
         iv = bytes.fromhex('b3d8cc017cbb89b39e0f67e2')
         plain = bytes.fromhex('c3b3c41f113a31b73d9a5cd432103069')
@@ -6649,9 +7023,9 @@ def test_aead_aes_gcm(self):
                 res = op.recv(len(msg) - taglen)
                 self.assertEqual(plain, res[assoclen:])
 
-    @support.requires_linux_version(4, 3)  # see test_aes_cbc
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
+    # TODO: RUSTPYTHON - AF_ALG not fully implemented
     @unittest.expectedFailure
+    @support.requires_linux_version(4, 3)  # see test_aes_cbc
     def test_drbg_pr_sha256(self):
         # deterministic random bit generator, prediction resistance, sha256
         with self.create_alg('rng', 'drbg_pr_sha256') as algo:
@@ -6662,8 +7036,6 @@ def test_drbg_pr_sha256(self):
                 rn = op.recv(32)
                 self.assertEqual(len(rn), 32)
 
-    # TODO: RUSTPYTHON, AttributeError: 'socket' object has no attribute 'sendmsg_afalg'
-    @unittest.expectedFailure
     def test_sendmsg_afalg_args(self):
         sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
         with sock:
@@ -6682,8 +7054,6 @@ def test_sendmsg_afalg_args(self):
             with self.assertRaises(TypeError):
                 sock.sendmsg_afalg(op=socket.ALG_OP_ENCRYPT, assoclen=-1)
 
-    # TODO: RUSTPYTHON, OSError: bind(): bad family
-    @unittest.expectedFailure
     def test_length_restriction(self):
         # bpo-35050, off-by-one error in length check
         sock = socket.socket(socket.AF_ALG, socket.SOCK_SEQPACKET, 0)
diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py
index 113f959ff2..6235c8e74c 100644
--- a/Lib/test/test_socketserver.py
+++ b/Lib/test/test_socketserver.py
@@ -8,7 +8,6 @@
 import select
 import signal
 import socket
-import tempfile
 import threading
 import unittest
 import socketserver
@@ -21,6 +20,8 @@
 
 
 test.support.requires("network")
+test.support.requires_working_socket(module=True)
+
 
 TEST_STR = b"hello world\n"
 HOST = socket_helper.HOST
@@ -28,14 +29,9 @@
 HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX")
 requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS,
                                             'requires Unix sockets')
-HAVE_FORKING = hasattr(os, "fork")
+HAVE_FORKING = test.support.has_fork_support
 requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking')
 
-def signal_alarm(n):
-    """Call signal.alarm when it exists (i.e. not on Windows)."""
-    if hasattr(signal, 'alarm'):
-        signal.alarm(n)
-
 # Remember real select() to avoid interferences with mocking
 _real_select = select.select
 
@@ -46,14 +42,6 @@ def receive(sock, n, timeout=test.support.SHORT_TIMEOUT):
     else:
         raise RuntimeError("timed out on %r" % (sock,))
 
-if HAVE_UNIX_SOCKETS and HAVE_FORKING:
-    class ForkingUnixStreamServer(socketserver.ForkingMixIn,
-                                  socketserver.UnixStreamServer):
-        pass
-
-    class ForkingUnixDatagramServer(socketserver.ForkingMixIn,
-                                    socketserver.UnixDatagramServer):
-        pass
 
 @test.support.requires_fork() # TODO: RUSTPYTHON, os.fork is currently only supported on Unix-based systems
 @contextlib.contextmanager
@@ -75,12 +63,10 @@ class SocketServerTest(unittest.TestCase):
     """Test all socket servers."""
 
     def setUp(self):
-        signal_alarm(60)  # Kill deadlocks after 60 seconds.
         self.port_seed = 0
         self.test_files = []
 
     def tearDown(self):
-        signal_alarm(0)  # Didn't deadlock.
         reap_children()
 
         for fn in self.test_files:
@@ -96,8 +82,7 @@ def pickaddr(self, proto):
         else:
             # XXX: We need a way to tell AF_UNIX to pick its own name
             # like AF_INET provides port==0.
-            dir = None
-            fn = tempfile.mktemp(prefix='unix_socket.', dir=dir)
+            fn = socket_helper.create_unix_domain_name()
             self.test_files.append(fn)
             return fn
 
@@ -178,13 +163,11 @@ def dgram_examine(self, proto, addr):
                 buf += data
             self.assertEqual(buf, TEST_STR)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: -1 != 18446744073709551615")
     def test_TCPServer(self):
         self.run_server(socketserver.TCPServer,
                         socketserver.StreamRequestHandler,
                         self.stream_examine)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: -1 != 18446744073709551615")
     def test_ThreadingTCPServer(self):
         self.run_server(socketserver.ThreadingTCPServer,
                         socketserver.StreamRequestHandler,
@@ -213,17 +196,15 @@ def test_ThreadingUnixStreamServer(self):
     @requires_forking
     def test_ForkingUnixStreamServer(self):
         with simple_subprocess(self):
-            self.run_server(ForkingUnixStreamServer,
+            self.run_server(socketserver.ForkingUnixStreamServer,
                             socketserver.StreamRequestHandler,
                             self.stream_examine)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: -1 != 18446744073709551615")
     def test_UDPServer(self):
         self.run_server(socketserver.UDPServer,
                         socketserver.DatagramRequestHandler,
                         self.dgram_examine)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: -1 != 18446744073709551615")
     def test_ThreadingUDPServer(self):
         self.run_server(socketserver.ThreadingUDPServer,
                         socketserver.DatagramRequestHandler,
@@ -251,7 +232,7 @@ def test_ThreadingUnixDatagramServer(self):
     @requires_unix_sockets
     @requires_forking
     def test_ForkingUnixDatagramServer(self):
-        self.run_server(ForkingUnixDatagramServer,
+        self.run_server(socketserver.ForkingUnixDatagramServer,
                         socketserver.DatagramRequestHandler,
                         self.dgram_examine)
 
@@ -298,7 +279,6 @@ def test_tcpserver_bind_leak(self):
                 socketserver.TCPServer((HOST, -1),
                                        socketserver.StreamRequestHandler)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: -1 != 18446744073709551615")
     def test_context_manager(self):
         with socketserver.TCPServer((HOST, 0),
                                     socketserver.StreamRequestHandler) as server:
diff --git a/Lib/test/test_sort.py b/Lib/test/test_sort.py
index be3d4a8461..37ce489b79 100644
--- a/Lib/test/test_sort.py
+++ b/Lib/test/test_sort.py
@@ -149,7 +149,7 @@ def __lt__(self, other):
         L = [C() for i in range(50)]
         self.assertRaises(ValueError, L.sort)
 
-    @unittest.skip("TODO: RUSTPYTHON; figure out how to detect sort mutation that doesn't change list length")
+    @unittest.expectedFailure # TODO: RUSTPYTHON; figure out how to detect sort mutation that doesn't change list length
     def test_undetected_mutation(self):
         # Python 2.4a1 did not always detect mutation
         memorywaster = []
diff --git a/Lib/test/test_sqlite3/test_dbapi.py b/Lib/test/test_sqlite3/test_dbapi.py
index 56cd8f8a68..a3ddd660cc 100644
--- a/Lib/test/test_sqlite3/test_dbapi.py
+++ b/Lib/test/test_sqlite3/test_dbapi.py
@@ -346,8 +346,6 @@ def test_extended_error_code_on_exception(self):
                              sqlite.SQLITE_CONSTRAINT_CHECK)
             self.assertEqual(exc.sqlite_errorname, "SQLITE_CONSTRAINT_CHECK")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_disallow_instantiation(self):
         cx = sqlite.connect(":memory:")
         check_disallow_instantiation(self, type(cx("select 1")))
@@ -547,9 +545,6 @@ def test_connection_init_good_isolation_levels(self):
                     cx.isolation_level = level
                     self.assertEqual(cx.isolation_level, level)
 
-    # TODO: RUSTPYTHON
-    # @unittest.expectedFailure
-    @unittest.skip("TODO: RUSTPYTHON deadlock")
     def test_connection_reinit(self):
         db = ":memory:"
         cx = sqlite.connect(db)
@@ -575,8 +570,6 @@ def test_connection_reinit(self):
         self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
         self.assertEqual([r[0] for r in rows], ["2", "3"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_connection_bad_reinit(self):
         cx = sqlite.connect(":memory:")
         with cx:
@@ -591,11 +584,11 @@ def test_connection_bad_reinit(self):
                                    ((v,) for v in range(3)))
 
 
-@unittest.skip("TODO: RUSTPYTHON")
 class UninitialisedConnectionTests(unittest.TestCase):
     def setUp(self):
         self.cx = sqlite.Connection.__new__(sqlite.Connection)
 
+    @unittest.skip('TODO: RUSTPYTHON')
     def test_uninit_operations(self):
         funcs = (
             lambda: self.cx.isolation_level,
@@ -769,8 +762,6 @@ def test_execute_illegal_sql(self):
         with self.assertRaises(sqlite.OperationalError):
             self.cu.execute("select asdf")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_multiple_statements(self):
         msg = "You can only execute one statement at a time"
         dataset = (
@@ -793,8 +784,6 @@ def test_execute_multiple_statements(self):
                 with self.assertRaisesRegex(sqlite.ProgrammingError, msg):
                     self.cu.execute(query)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_with_appended_comments(self):
         dataset = (
             "select 1; -- foo bar",
@@ -842,15 +831,11 @@ def test_execute_wrong_no_of_args1(self):
         with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_wrong_no_of_args2(self):
         # too little parameters
         with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("insert into test(id) values (?)")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_wrong_no_of_args3(self):
         # no parameters, parameters are needed
         with self.assertRaises(sqlite.ProgrammingError):
@@ -912,15 +897,11 @@ def __missing__(self, key):
         row = self.cu.fetchone()
         self.assertEqual(row[0], "foo")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_dict_mapping_too_little_args(self):
         self.cu.execute("insert into test(name) values ('foo')")
         with self.assertRaises(sqlite.ProgrammingError):
             self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_execute_dict_mapping_no_args(self):
         self.cu.execute("insert into test(name) values ('foo')")
         with self.assertRaises(sqlite.ProgrammingError):
@@ -963,8 +944,6 @@ def test_rowcount_update_returning(self):
         self.assertEqual(self.cu.fetchone()[0], 1)
         self.assertEqual(self.cu.rowcount, 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_rowcount_prefixed_with_comment(self):
         # gh-79579: rowcount is updated even if query is prefixed with comments
         self.cu.execute("""
@@ -1085,8 +1064,6 @@ def test_fetchmany(self):
         res = self.cu.fetchmany(100)
         self.assertEqual(res, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_fetchmany_kw_arg(self):
         """Checks if fetchmany works with keyword arguments"""
         self.cu.execute("select name from test")
@@ -1330,8 +1307,6 @@ def test_blob_set_item_with_offset(self):
         expected = b"This blob data string is exactly fifty bytes long."
         self.assertEqual(self.blob.read(), expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_set_slice_buffer_object(self):
         from array import array
         self.blob[0:5] = memoryview(b"12345")
@@ -1359,22 +1334,16 @@ def test_blob_get_slice_negative_index(self):
     def test_blob_get_slice_with_skip(self):
         self.assertEqual(self.blob[0:10:2], b"ti lb")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_set_slice(self):
         self.blob[0:5] = b"12345"
         expected = b"12345" + self.data[5:]
         actual = self.cx.execute("select b from test").fetchone()[0]
         self.assertEqual(actual, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_set_empty_slice(self):
         self.blob[0:0] = b""
         self.assertEqual(self.blob[:], self.data)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_set_slice_with_skip(self):
         self.blob[0:10:2] = b"12345"
         actual = self.cx.execute("select b from test").fetchone()[0]
@@ -1427,8 +1396,6 @@ def test_blob_set_item_error(self):
         with self.assertRaisesRegex(ValueError, "must be in range"):
             self.blob[0] = 2**65
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_set_slice_error(self):
         with self.assertRaisesRegex(IndexError, "wrong size"):
             self.blob[5:10] = b"a"
@@ -1441,8 +1408,6 @@ def test_blob_set_slice_error(self):
         with self.assertRaises(BufferError):
             self.blob[5:10] = memoryview(b"abcde")[::2]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_sequence_not_supported(self):
         with self.assertRaisesRegex(TypeError, "unsupported operand"):
             self.blob + self.blob
@@ -1470,8 +1435,6 @@ class DummyException(Exception):
                 raise DummyException("reraised")
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_closed(self):
         with memory_database() as cx:
             cx.execute("create table test(b blob)")
@@ -1501,8 +1464,6 @@ def test_blob_closed(self):
             with self.assertRaisesRegex(sqlite.ProgrammingError, msg):
                 blob[0] = b""
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_blob_closed_db_read(self):
         with memory_database() as cx:
             cx.execute("create table test(b blob)")
@@ -1661,8 +1622,6 @@ def test_cursor_executescript_with_null_characters(self):
                 insert into a(i) values (5);
                 """)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cursor_executescript_with_surrogates(self):
         con = sqlite.connect(":memory:")
         cur = con.cursor()
@@ -1766,8 +1725,6 @@ def progress(): pass
         with self.assertRaises(sqlite.ProgrammingError):
             con.set_progress_handler(progress, 100)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_closed_call(self):
         con = sqlite.connect(":memory:")
         con.close()
@@ -1775,8 +1732,6 @@ def test_closed_call(self):
             con()
 
 class ClosedCurTests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_closed(self):
         con = sqlite.connect(":memory:")
         cur = con.cursor()
diff --git a/Lib/test/test_sqlite3/test_factory.py b/Lib/test/test_sqlite3/test_factory.py
index e52c10fe94..c13a748152 100644
--- a/Lib/test/test_sqlite3/test_factory.py
+++ b/Lib/test/test_sqlite3/test_factory.py
@@ -241,8 +241,6 @@ def test_sqlite_row_hash_cmp(self):
 
         self.assertEqual(hash(row_1), hash(row_2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_sqlite_row_as_sequence(self):
         """ Checks if the row object can act like a sequence """
         self.con.row_factory = sqlite.Row
diff --git a/Lib/test/test_sqlite3/test_regression.py b/Lib/test/test_sqlite3/test_regression.py
index dfcf3b11f5..d746be647c 100644
--- a/Lib/test/test_sqlite3/test_regression.py
+++ b/Lib/test/test_sqlite3/test_regression.py
@@ -150,8 +150,6 @@ def __conform__(self, protocol):
         with self.assertRaises(IndexError):
             con.execute("insert into foo(bar, baz) values (?, ?)", parameters)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_error_msg_decode_error(self):
         # When porting the module to Python 3.0, the error message about
         # decoding errors disappeared. This verifies they're back again.
@@ -197,8 +195,6 @@ def __del__(self):
                     con.isolation_level = value
                 self.assertEqual(con.isolation_level, "DEFERRED")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cursor_constructor_call_check(self):
         """
         Verifies that cursor methods check whether base class __init__ was
@@ -223,8 +219,6 @@ def test_str_subclass(self):
         class MyStr(str): pass
         self.con.execute("select ?", (MyStr("abc"),))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_connection_constructor_call_check(self):
         """
         Verifies that connection methods check whether base class __init__ was
@@ -265,8 +259,6 @@ def test_connection_call(self):
         """
         self.assertRaises(TypeError, self.con, b"select 1")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_collation(self):
         def collation_cb(a, b):
             return 1
@@ -329,8 +321,6 @@ def test_invalid_isolation_level_type(self):
                           sqlite.connect, ":memory:", isolation_level=123)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_null_character(self):
         # Issue #21147
         cur = self.con.cursor()
@@ -343,8 +333,6 @@ def test_null_character(self):
                 self.assertRaisesRegex(sqlite.ProgrammingError, "null char",
                                        cur.execute, query)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_surrogates(self):
         con = sqlite.connect(":memory:")
         self.assertRaises(UnicodeEncodeError, con, "select '\ud8ff'")
@@ -353,8 +341,6 @@ def test_surrogates(self):
         self.assertRaises(UnicodeEncodeError, cur.execute, "select '\ud8ff'")
         self.assertRaises(UnicodeEncodeError, cur.execute, "select '\udcff'")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_large_sql(self):
         msg = "query string is too large"
         with memory_database() as cx, cx_limit(cx) as lim:
@@ -415,8 +401,6 @@ def callback(*args):
         del ref
         support.gc_collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_del_isolation_level_segfault(self):
         with self.assertRaises(AttributeError):
             del self.con.isolation_level
diff --git a/Lib/test/test_sqlite3/test_types.py b/Lib/test/test_sqlite3/test_types.py
index 6cbf99d6ea..6231882351 100644
--- a/Lib/test/test_sqlite3/test_types.py
+++ b/Lib/test/test_sqlite3/test_types.py
@@ -433,14 +433,10 @@ def test_missing_adapter(self):
         with self.assertRaises(sqlite.ProgrammingError):
             sqlite.adapt(1.)  # No float adapter registered
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_missing_protocol(self):
         with self.assertRaises(sqlite.ProgrammingError):
             sqlite.adapt(1, None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_defect_proto(self):
         class DefectProto():
             def __adapt__(self):
@@ -448,8 +444,6 @@ def __adapt__(self):
         with self.assertRaises(sqlite.ProgrammingError):
             sqlite.adapt(1., DefectProto)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_defect_self_adapt(self):
         class DefectSelfAdapt(float):
             def __conform__(self, _):
diff --git a/Lib/test/test_sqlite3/test_userfunctions.py b/Lib/test/test_sqlite3/test_userfunctions.py
index 7b092365d4..e8b98a66a5 100644
--- a/Lib/test/test_sqlite3/test_userfunctions.py
+++ b/Lib/test/test_sqlite3/test_userfunctions.py
@@ -354,8 +354,6 @@ def test_return_non_contiguous_blob(self):
             cur = self.con.execute("select return_noncont_blob()")
             cur.fetchone()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_param_surrogates(self):
         self.assertRaisesRegex(UnicodeEncodeError, "surrogates not allowed",
                                self.con.execute, "select spam(?)",
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
new file mode 100644
index 0000000000..9798a4f59c
--- /dev/null
+++ b/Lib/test/test_ssl.py
@@ -0,0 +1,5565 @@
+# Test the support for SSL and sockets
+
+import sys
+import unittest
+import unittest.mock
+from ast import literal_eval
+from threading import Thread
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+from test.support import socket_helper
+from test.support import threading_helper
+from test.support import warnings_helper
+from test.support import asyncore
+import array
+import re
+import socket
+import select
+import struct
+import time
+import enum
+import gc
+import http.client
+import os
+import errno
+import pprint
+import urllib.request
+import threading
+import traceback
+import weakref
+import platform
+import sysconfig
+import functools
+from contextlib import nullcontext
+try:
+    import ctypes
+except ImportError:
+    ctypes = None
+
+
+ssl = import_helper.import_module("ssl")
+import _ssl
+
+from ssl import Purpose, TLSVersion, _TLSContentType, _TLSMessageType, _TLSAlertType
+
+Py_DEBUG_WIN32 = support.Py_DEBUG and sys.platform == 'win32'
+
+PROTOCOLS = sorted(ssl._PROTOCOL_NAMES)
+HOST = socket_helper.HOST
+IS_OPENSSL_3_0_0 = ssl.OPENSSL_VERSION_INFO >= (3, 0, 0)
+PY_SSL_DEFAULT_CIPHERS = sysconfig.get_config_var('PY_SSL_DEFAULT_CIPHERS')
+
+PROTOCOL_TO_TLS_VERSION = {}
+for proto, ver in (
+    ("PROTOCOL_SSLv3", "SSLv3"),
+    ("PROTOCOL_TLSv1", "TLSv1"),
+    ("PROTOCOL_TLSv1_1", "TLSv1_1"),
+):
+    try:
+        proto = getattr(ssl, proto)
+        ver = getattr(ssl.TLSVersion, ver)
+    except AttributeError:
+        continue
+    PROTOCOL_TO_TLS_VERSION[proto] = ver
+
+def data_file(*name):
+    return os.path.join(os.path.dirname(__file__), "certdata", *name)
+
+# The custom key and certificate files used in test_ssl are generated
+# using Lib/test/certdata/make_ssl_certs.py.
+# Other certificates are simply fetched from the internet servers they
+# are meant to authenticate.
+
+CERTFILE = data_file("keycert.pem")
+BYTES_CERTFILE = os.fsencode(CERTFILE)
+ONLYCERT = data_file("ssl_cert.pem")
+ONLYKEY = data_file("ssl_key.pem")
+BYTES_ONLYCERT = os.fsencode(ONLYCERT)
+BYTES_ONLYKEY = os.fsencode(ONLYKEY)
+CERTFILE_PROTECTED = data_file("keycert.passwd.pem")
+ONLYKEY_PROTECTED = data_file("ssl_key.passwd.pem")
+KEY_PASSWORD = "somepass"
+CAPATH = data_file("capath")
+BYTES_CAPATH = os.fsencode(CAPATH)
+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
+}
+
+# empty CRL
+CRLFILE = data_file("revocation.crl")
+
+# Two keys and certs signed by the same CA (for SNI tests)
+SIGNED_CERTFILE = data_file("keycert3.pem")
+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
+}
+
+SIGNED_CERTFILE2 = data_file("keycert4.pem")
+SIGNED_CERTFILE2_HOSTNAME = 'fakehostname'
+SIGNED_CERTFILE_ECC = data_file("keycertecc.pem")
+SIGNED_CERTFILE_ECC_HOSTNAME = 'localhost-ecc'
+
+# A custom testcase, extracted from `rfc5280::aki::leaf-missing-aki` in x509-limbo:
+# The leaf (server) certificate has no AKI, which is forbidden under RFC 5280.
+# See: https://x509-limbo.com/testcases/rfc5280/#rfc5280akileaf-missing-aki
+LEAF_MISSING_AKI_CERTFILE = data_file("leaf-missing-aki.keycert.pem")
+LEAF_MISSING_AKI_CERTFILE_HOSTNAME = "example.com"
+LEAF_MISSING_AKI_CA = data_file("leaf-missing-aki.ca.pem")
+
+# Same certificate as pycacert.pem, but without extra text in file
+SIGNING_CA = data_file("capath", "ceff1710.0")
+# cert with all kinds of subject alt names
+ALLSANFILE = data_file("allsans.pem")
+IDNSANSFILE = data_file("idnsans.pem")
+NOSANFILE = data_file("nosan.pem")
+NOSAN_HOSTNAME = 'localhost'
+
+REMOTE_HOST = "self-signed.pythontest.net"
+
+EMPTYCERT = data_file("nullcert.pem")
+BADCERT = data_file("badcert.pem")
+NONEXISTINGCERT = data_file("XXXnonexisting.pem")
+BADKEY = data_file("badkey.pem")
+NOKIACERT = data_file("nokia.pem")
+NULLBYTECERT = data_file("nullbytecert.pem")
+TALOS_INVALID_CRLDP = data_file("talos-2019-0758.pem")
+
+DHFILE = data_file("ffdh3072.pem")
+BYTES_DHFILE = os.fsencode(DHFILE)
+
+# Not defined in all versions of OpenSSL
+OP_NO_COMPRESSION = getattr(ssl, "OP_NO_COMPRESSION", 0)
+OP_SINGLE_DH_USE = getattr(ssl, "OP_SINGLE_DH_USE", 0)
+OP_SINGLE_ECDH_USE = getattr(ssl, "OP_SINGLE_ECDH_USE", 0)
+OP_CIPHER_SERVER_PREFERENCE = getattr(ssl, "OP_CIPHER_SERVER_PREFERENCE", 0)
+OP_ENABLE_MIDDLEBOX_COMPAT = getattr(ssl, "OP_ENABLE_MIDDLEBOX_COMPAT", 0)
+
+# Ubuntu has patched OpenSSL and changed behavior of security level 2
+# see https://bugs.python.org/issue41561#msg389003
+def is_ubuntu():
+    try:
+        # Assume that any references of "ubuntu" implies Ubuntu-like distro
+        # The workaround is not required for 18.04, but doesn't hurt either.
+        with open("/etc/os-release", encoding="utf-8") as f:
+            return "ubuntu" in f.read()
+    except FileNotFoundError:
+        return False
+
+if is_ubuntu():
+    def seclevel_workaround(*ctxs):
+        """"Lower security level to '1' and allow all ciphers for TLS 1.0/1"""
+        for ctx in ctxs:
+            if (
+                hasattr(ctx, "minimum_version") and
+                ctx.minimum_version <= ssl.TLSVersion.TLSv1_1 and
+                ctx.security_level > 1
+            ):
+                ctx.set_ciphers("@SECLEVEL=1:ALL")
+else:
+    def seclevel_workaround(*ctxs):
+        pass
+
+
+def has_tls_protocol(protocol):
+    """Check if a TLS protocol is available and enabled
+
+    :param protocol: enum ssl._SSLMethod member or name
+    :return: bool
+    """
+    if isinstance(protocol, str):
+        assert protocol.startswith('PROTOCOL_')
+        protocol = getattr(ssl, protocol, None)
+        if protocol is None:
+            return False
+    if protocol in {
+        ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS_SERVER,
+        ssl.PROTOCOL_TLS_CLIENT
+    }:
+        # auto-negotiate protocols are always available
+        return True
+    name = protocol.name
+    return has_tls_version(name[len('PROTOCOL_'):])
+
+
+@functools.lru_cache
+def has_tls_version(version):
+    """Check if a TLS/SSL version is enabled
+
+    :param version: TLS version name or ssl.TLSVersion member
+    :return: bool
+    """
+    if isinstance(version, str):
+        version = ssl.TLSVersion.__members__[version]
+
+    # check compile time flags like ssl.HAS_TLSv1_2
+    if not getattr(ssl, f'HAS_{version.name}'):
+        return False
+
+    if IS_OPENSSL_3_0_0 and version < ssl.TLSVersion.TLSv1_2:
+        # bpo43791: 3.0.0-alpha14 fails with TLSV1_ALERT_INTERNAL_ERROR
+        return False
+
+    # check runtime and dynamic crypto policy settings. A TLS version may
+    # be compiled in but disabled by a policy or config option.
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    if (
+            hasattr(ctx, 'minimum_version') and
+            ctx.minimum_version != ssl.TLSVersion.MINIMUM_SUPPORTED and
+            version < ctx.minimum_version
+    ):
+        return False
+    if (
+        hasattr(ctx, 'maximum_version') and
+        ctx.maximum_version != ssl.TLSVersion.MAXIMUM_SUPPORTED and
+        version > ctx.maximum_version
+    ):
+        return False
+
+    return True
+
+
+def requires_tls_version(version):
+    """Decorator to skip tests when a required TLS version is not available
+
+    :param version: TLS version name or ssl.TLSVersion member
+    :return:
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kw):
+            if not has_tls_version(version):
+                raise unittest.SkipTest(f"{version} is not available.")
+            else:
+                return func(*args, **kw)
+        return wrapper
+    return decorator
+
+
+def handle_error(prefix):
+    exc_format = ' '.join(traceback.format_exception(sys.exception()))
+    if support.verbose:
+        sys.stdout.write(prefix + exc_format)
+
+
+def utc_offset(): #NOTE: ignore issues like #1647654
+    # local time = utc time + utc offset
+    if time.daylight and time.localtime().tm_isdst > 0:
+        return -time.altzone  # seconds
+    return -time.timezone
+
+
+ignore_deprecation = warnings_helper.ignore_warnings(
+    category=DeprecationWarning
+)
+
+
+def test_wrap_socket(sock, *,
+                     cert_reqs=ssl.CERT_NONE, ca_certs=None,
+                     ciphers=None, certfile=None, keyfile=None,
+                     **kwargs):
+    if not kwargs.get("server_side"):
+        kwargs["server_hostname"] = SIGNED_CERTFILE_HOSTNAME
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    else:
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    if cert_reqs is not None:
+        if cert_reqs == ssl.CERT_NONE:
+            context.check_hostname = False
+        context.verify_mode = cert_reqs
+    if ca_certs is not None:
+        context.load_verify_locations(ca_certs)
+    if certfile is not None or keyfile is not None:
+        context.load_cert_chain(certfile, keyfile)
+    if ciphers is not None:
+        context.set_ciphers(ciphers)
+    return context.wrap_socket(sock, **kwargs)
+
+
+USE_SAME_TEST_CONTEXT = False
+_TEST_CONTEXT = None
+
+def testing_context(server_cert=SIGNED_CERTFILE, *, server_chain=True):
+    """Create context
+
+    client_context, server_context, hostname = testing_context()
+    """
+    global _TEST_CONTEXT
+    if USE_SAME_TEST_CONTEXT:
+        if _TEST_CONTEXT is not None:
+            return _TEST_CONTEXT
+
+    if server_cert == SIGNED_CERTFILE:
+        hostname = SIGNED_CERTFILE_HOSTNAME
+    elif server_cert == SIGNED_CERTFILE2:
+        hostname = SIGNED_CERTFILE2_HOSTNAME
+    elif server_cert == NOSANFILE:
+        hostname = NOSAN_HOSTNAME
+    else:
+        raise ValueError(server_cert)
+
+    client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    client_context.load_verify_locations(SIGNING_CA)
+
+    server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+    server_context.load_cert_chain(server_cert)
+    if server_chain:
+        server_context.load_verify_locations(SIGNING_CA)
+
+    if USE_SAME_TEST_CONTEXT:
+        if _TEST_CONTEXT is not None:
+            _TEST_CONTEXT = client_context, server_context, hostname
+
+    return client_context, server_context, hostname
+
+
+class BasicSocketTests(unittest.TestCase):
+
+    def test_constants(self):
+        ssl.CERT_NONE
+        ssl.CERT_OPTIONAL
+        ssl.CERT_REQUIRED
+        ssl.OP_CIPHER_SERVER_PREFERENCE
+        ssl.OP_SINGLE_DH_USE
+        ssl.OP_SINGLE_ECDH_USE
+        ssl.OP_NO_COMPRESSION
+        self.assertEqual(ssl.HAS_SNI, True)
+        self.assertEqual(ssl.HAS_ECDH, True)
+        self.assertEqual(ssl.HAS_TLSv1_2, True)
+        self.assertEqual(ssl.HAS_TLSv1_3, True)
+        ssl.OP_NO_SSLv2
+        ssl.OP_NO_SSLv3
+        ssl.OP_NO_TLSv1
+        ssl.OP_NO_TLSv1_3
+        ssl.OP_NO_TLSv1_1
+        ssl.OP_NO_TLSv1_2
+        self.assertEqual(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv23)
+
+    def test_options(self):
+        # gh-106687: SSL options values are unsigned integer (uint64_t)
+        for name in dir(ssl):
+            if not name.startswith('OP_'):
+                continue
+            with self.subTest(option=name):
+                value = getattr(ssl, name)
+                self.assertGreaterEqual(value, 0, f"ssl.{name}")
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_ssl_types(self):
+        ssl_types = [
+            _ssl._SSLContext,
+            _ssl._SSLSocket,
+            _ssl.MemoryBIO,
+            _ssl.Certificate,
+            _ssl.SSLSession,
+            _ssl.SSLError,
+        ]
+        for ssl_type in ssl_types:
+            with self.subTest(ssl_type=ssl_type):
+                with self.assertRaisesRegex(TypeError, "immutable type"):
+                    ssl_type.value = None
+        support.check_disallow_instantiation(self, _ssl.Certificate)
+
+    def test_private_init(self):
+        with self.assertRaisesRegex(TypeError, "public constructor"):
+            with socket.socket() as s:
+                ssl.SSLSocket(s)
+
+    def test_str_for_enums(self):
+        # Make sure that the PROTOCOL_* constants have enum-like string
+        # reprs.
+        proto = ssl.PROTOCOL_TLS_CLIENT
+        self.assertEqual(repr(proto), '<_SSLMethod.PROTOCOL_TLS_CLIENT: %r>' % proto.value)
+        self.assertEqual(str(proto), str(proto.value))
+        ctx = ssl.SSLContext(proto)
+        self.assertIs(ctx.protocol, proto)
+
+    def test_random(self):
+        v = ssl.RAND_status()
+        if support.verbose:
+            sys.stdout.write("\n RAND_status is %d (%s)\n"
+                             % (v, (v and "sufficient randomness") or
+                                "insufficient randomness"))
+
+        if v:
+            data = ssl.RAND_bytes(16)
+            self.assertEqual(len(data), 16)
+        else:
+            self.assertRaises(ssl.SSLError, ssl.RAND_bytes, 16)
+
+        # negative num is invalid
+        self.assertRaises(ValueError, ssl.RAND_bytes, -5)
+
+        ssl.RAND_add("this is a random string", 75.0)
+        ssl.RAND_add(b"this is a random bytes object", 75.0)
+        ssl.RAND_add(bytearray(b"this is a random bytearray object"), 75.0)
+
+    def test_parse_cert(self):
+        # note that this uses an 'unofficial' function in _ssl.c,
+        # provided solely for this test, to exercise the certificate
+        # parsing code
+        self.assertEqual(
+            ssl._ssl._test_decode_cert(CERTFILE),
+            CERTFILE_INFO
+        )
+        self.assertEqual(
+            ssl._ssl._test_decode_cert(SIGNED_CERTFILE),
+            SIGNED_CERTFILE_INFO
+        )
+
+        # Issue #13034: the subjectAltName in some certificates
+        # (notably projects.developer.nokia.com:443) wasn't parsed
+        p = ssl._ssl._test_decode_cert(NOKIACERT)
+        if support.verbose:
+            sys.stdout.write("\n" + pprint.pformat(p) + "\n")
+        self.assertEqual(p['subjectAltName'],
+                         (('DNS', 'projects.developer.nokia.com'),
+                          ('DNS', 'projects.forum.nokia.com'))
+                        )
+        # extra OCSP and AIA fields
+        self.assertEqual(p['OCSP'], ('http://ocsp.verisign.com',))
+        self.assertEqual(p['caIssuers'],
+                         ('http://SVRIntl-G3-aia.verisign.com/SVRIntlG3.cer',))
+        self.assertEqual(p['crlDistributionPoints'],
+                         ('http://SVRIntl-G3-crl.verisign.com/SVRIntlG3.crl',))
+
+    def test_parse_cert_CVE_2019_5010(self):
+        p = ssl._ssl._test_decode_cert(TALOS_INVALID_CRLDP)
+        if support.verbose:
+            sys.stdout.write("\n" + pprint.pformat(p) + "\n")
+        self.assertEqual(
+            p,
+            {
+                'issuer': (
+                    (('countryName', 'UK'),), (('commonName', 'cody-ca'),)),
+                'notAfter': 'Jun 14 18:00:58 2028 GMT',
+                'notBefore': 'Jun 18 18:00:58 2018 GMT',
+                'serialNumber': '02',
+                'subject': ((('countryName', 'UK'),),
+                            (('commonName',
+                              'codenomicon-vm-2.test.lal.cisco.com'),)),
+                'subjectAltName': (
+                    ('DNS', 'codenomicon-vm-2.test.lal.cisco.com'),),
+                'version': 3
+            }
+        )
+
+    def test_parse_cert_CVE_2013_4238(self):
+        p = ssl._ssl._test_decode_cert(NULLBYTECERT)
+        if support.verbose:
+            sys.stdout.write("\n" + pprint.pformat(p) + "\n")
+        subject = ((('countryName', 'US'),),
+                   (('stateOrProvinceName', 'Oregon'),),
+                   (('localityName', 'Beaverton'),),
+                   (('organizationName', 'Python Software Foundation'),),
+                   (('organizationalUnitName', 'Python Core Development'),),
+                   (('commonName', 'null.python.org\x00example.org'),),
+                   (('emailAddress', 'python-dev@python.org'),))
+        self.assertEqual(p['subject'], subject)
+        self.assertEqual(p['issuer'], subject)
+        if ssl._OPENSSL_API_VERSION >= (0, 9, 8):
+            san = (('DNS', 'altnull.python.org\x00example.com'),
+                   ('email', 'null@python.org\x00user@example.org'),
+                   ('URI', 'http://null.python.org\x00http://example.org'),
+                   ('IP Address', '192.0.2.1'),
+                   ('IP Address', '2001:DB8:0:0:0:0:0:1'))
+        else:
+            # OpenSSL 0.9.7 doesn't support IPv6 addresses in subjectAltName
+            san = (('DNS', 'altnull.python.org\x00example.com'),
+                   ('email', 'null@python.org\x00user@example.org'),
+                   ('URI', 'http://null.python.org\x00http://example.org'),
+                   ('IP Address', '192.0.2.1'),
+                   ('IP Address', '<invalid>'))
+
+        self.assertEqual(p['subjectAltName'], san)
+
+    def test_parse_all_sans(self):
+        p = ssl._ssl._test_decode_cert(ALLSANFILE)
+        self.assertEqual(p['subjectAltName'],
+            (
+                ('DNS', 'allsans'),
+                ('othername', '<unsupported>'),
+                ('othername', '<unsupported>'),
+                ('email', 'user@example.org'),
+                ('DNS', 'www.example.org'),
+                ('DirName',
+                    ((('countryName', 'XY'),),
+                    (('localityName', 'Castle Anthrax'),),
+                    (('organizationName', 'Python Software Foundation'),),
+                    (('commonName', 'dirname example'),))),
+                ('URI', 'https://www.python.org/'),
+                ('IP Address', '127.0.0.1'),
+                ('IP Address', '0:0:0:0:0:0:0:1'),
+                ('Registered ID', '1.2.3.4.5')
+            )
+        )
+
+    def test_DER_to_PEM(self):
+        with open(CAFILE_CACERT, 'r') as f:
+            pem = f.read()
+        d1 = ssl.PEM_cert_to_DER_cert(pem)
+        p2 = ssl.DER_cert_to_PEM_cert(d1)
+        d2 = ssl.PEM_cert_to_DER_cert(p2)
+        self.assertEqual(d1, d2)
+        if not p2.startswith(ssl.PEM_HEADER + '\n'):
+            self.fail("DER-to-PEM didn't include correct header:\n%r\n" % p2)
+        if not p2.endswith('\n' + ssl.PEM_FOOTER + '\n'):
+            self.fail("DER-to-PEM didn't include correct footer:\n%r\n" % p2)
+
+    def test_openssl_version(self):
+        n = ssl.OPENSSL_VERSION_NUMBER
+        t = ssl.OPENSSL_VERSION_INFO
+        s = ssl.OPENSSL_VERSION
+        self.assertIsInstance(n, int)
+        self.assertIsInstance(t, tuple)
+        self.assertIsInstance(s, str)
+        # Some sanity checks follow
+        # >= 1.1.1
+        self.assertGreaterEqual(n, 0x10101000)
+        # < 4.0
+        self.assertLess(n, 0x40000000)
+        major, minor, fix, patch, status = t
+        self.assertGreaterEqual(major, 1)
+        self.assertLess(major, 4)
+        self.assertGreaterEqual(minor, 0)
+        self.assertLess(minor, 256)
+        self.assertGreaterEqual(fix, 0)
+        self.assertLess(fix, 256)
+        self.assertGreaterEqual(patch, 0)
+        self.assertLessEqual(patch, 63)
+        self.assertGreaterEqual(status, 0)
+        self.assertLessEqual(status, 15)
+
+        libressl_ver = f"LibreSSL {major:d}"
+        if major >= 3:
+            # 3.x uses 0xMNN00PP0L
+            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))
+        )
+
+    @support.cpython_only
+    def test_refcycle(self):
+        # Issue #7943: an SSL object doesn't create reference cycles with
+        # itself.
+        s = socket.socket(socket.AF_INET)
+        ss = test_wrap_socket(s)
+        wr = weakref.ref(ss)
+        with warnings_helper.check_warnings(("", ResourceWarning)):
+            del ss
+        self.assertEqual(wr(), None)
+
+    def test_wrapped_unconnected(self):
+        # Methods on an unconnected SSLSocket propagate the original
+        # OSError raise by the underlying socket object.
+        s = socket.socket(socket.AF_INET)
+        with test_wrap_socket(s) as ss:
+            self.assertRaises(OSError, ss.recv, 1)
+            self.assertRaises(OSError, ss.recv_into, bytearray(b'x'))
+            self.assertRaises(OSError, ss.recvfrom, 1)
+            self.assertRaises(OSError, ss.recvfrom_into, bytearray(b'x'), 1)
+            self.assertRaises(OSError, ss.send, b'x')
+            self.assertRaises(OSError, ss.sendto, b'x', ('0.0.0.0', 0))
+            self.assertRaises(NotImplementedError, ss.dup)
+            self.assertRaises(NotImplementedError, ss.sendmsg,
+                              [b'x'], (), 0, ('0.0.0.0', 0))
+            self.assertRaises(NotImplementedError, ss.recvmsg, 100)
+            self.assertRaises(NotImplementedError, ss.recvmsg_into,
+                              [bytearray(100)])
+
+    def test_timeout(self):
+        # Issue #8524: when creating an SSL socket, the timeout of the
+        # original socket should be retained.
+        for timeout in (None, 0.0, 5.0):
+            s = socket.socket(socket.AF_INET)
+            s.settimeout(timeout)
+            with test_wrap_socket(s) as ss:
+                self.assertEqual(timeout, ss.gettimeout())
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_openssl111_deprecations(self):
+        options = [
+            ssl.OP_NO_TLSv1,
+            ssl.OP_NO_TLSv1_1,
+            ssl.OP_NO_TLSv1_2,
+            ssl.OP_NO_TLSv1_3
+        ]
+        protocols = [
+            ssl.PROTOCOL_TLSv1,
+            ssl.PROTOCOL_TLSv1_1,
+            ssl.PROTOCOL_TLSv1_2,
+            ssl.PROTOCOL_TLS
+        ]
+        versions = [
+            ssl.TLSVersion.SSLv3,
+            ssl.TLSVersion.TLSv1,
+            ssl.TLSVersion.TLSv1_1,
+        ]
+
+        for option in options:
+            with self.subTest(option=option):
+                ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+                with self.assertWarns(DeprecationWarning) as cm:
+                    ctx.options |= option
+                self.assertEqual(
+                    'ssl.OP_NO_SSL*/ssl.OP_NO_TLS* options are deprecated',
+                    str(cm.warning)
+                )
+
+        for protocol in protocols:
+            if not has_tls_protocol(protocol):
+                continue
+            with self.subTest(protocol=protocol):
+                with self.assertWarns(DeprecationWarning) as cm:
+                    ssl.SSLContext(protocol)
+                self.assertEqual(
+                    f'ssl.{protocol.name} is deprecated',
+                    str(cm.warning)
+                )
+
+        for version in versions:
+            if not has_tls_version(version):
+                continue
+            with self.subTest(version=version):
+                ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+                with self.assertWarns(DeprecationWarning) as cm:
+                    ctx.minimum_version = version
+                version_text = '%s.%s' % (version.__class__.__name__, version.name)
+                self.assertEqual(
+                    f'ssl.{version_text} is deprecated',
+                    str(cm.warning)
+                )
+
+    def bad_cert_test(self, certfile):
+        """Check that trying to use the given client certificate fails"""
+        certfile = os.path.join(os.path.dirname(__file__) or os.curdir,
+                                "certdata", certfile)
+        sock = socket.socket()
+        self.addCleanup(sock.close)
+        with self.assertRaises(ssl.SSLError):
+            test_wrap_socket(sock,
+                             certfile=certfile)
+
+    def test_empty_cert(self):
+        """Wrapping with an empty cert file"""
+        self.bad_cert_test("nullcert.pem")
+
+    def test_malformed_cert(self):
+        """Wrapping with a badly formatted certificate (syntax error)"""
+        self.bad_cert_test("badcert.pem")
+
+    def test_malformed_key(self):
+        """Wrapping with a badly formatted key (syntax error)"""
+        self.bad_cert_test("badkey.pem")
+
+    def test_server_side(self):
+        # server_hostname doesn't work for server sockets
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        with socket.socket() as sock:
+            self.assertRaises(ValueError, ctx.wrap_socket, sock, True,
+                              server_hostname="some.hostname")
+
+    def test_unknown_channel_binding(self):
+        # should raise ValueError for unknown type
+        s = socket.create_server(('127.0.0.1', 0))
+        c = socket.socket(socket.AF_INET)
+        c.connect(s.getsockname())
+        with test_wrap_socket(c, do_handshake_on_connect=False) as ss:
+            with self.assertRaises(ValueError):
+                ss.get_channel_binding("unknown-type")
+        s.close()
+
+    @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
+                         "'tls-unique' channel binding not available")
+    def test_tls_unique_channel_binding(self):
+        # unconnected should return None for known type
+        s = socket.socket(socket.AF_INET)
+        with test_wrap_socket(s) as ss:
+            self.assertIsNone(ss.get_channel_binding("tls-unique"))
+        # the same for server-side
+        s = socket.socket(socket.AF_INET)
+        with test_wrap_socket(s, server_side=True, certfile=CERTFILE) as ss:
+            self.assertIsNone(ss.get_channel_binding("tls-unique"))
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_dealloc_warn(self):
+        ss = test_wrap_socket(socket.socket(socket.AF_INET))
+        r = repr(ss)
+        with self.assertWarns(ResourceWarning) as cm:
+            ss = None
+            support.gc_collect()
+        self.assertIn(r, str(cm.warning.args[0]))
+
+    def test_get_default_verify_paths(self):
+        paths = ssl.get_default_verify_paths()
+        self.assertEqual(len(paths), 6)
+        self.assertIsInstance(paths, ssl.DefaultVerifyPaths)
+
+        with os_helper.EnvironmentVarGuard() as env:
+            env["SSL_CERT_DIR"] = CAPATH
+            env["SSL_CERT_FILE"] = CERTFILE
+            paths = ssl.get_default_verify_paths()
+            self.assertEqual(paths.cafile, CERTFILE)
+            self.assertEqual(paths.capath, CAPATH)
+
+    @unittest.skipUnless(sys.platform == "win32", "Windows specific")
+    def test_enum_certificates(self):
+        self.assertTrue(ssl.enum_certificates("CA"))
+        self.assertTrue(ssl.enum_certificates("ROOT"))
+
+        self.assertRaises(TypeError, ssl.enum_certificates)
+        self.assertRaises(WindowsError, ssl.enum_certificates, "")
+
+        trust_oids = set()
+        for storename in ("CA", "ROOT"):
+            store = ssl.enum_certificates(storename)
+            self.assertIsInstance(store, list)
+            for element in store:
+                self.assertIsInstance(element, tuple)
+                self.assertEqual(len(element), 3)
+                cert, enc, trust = element
+                self.assertIsInstance(cert, bytes)
+                self.assertIn(enc, {"x509_asn", "pkcs_7_asn"})
+                self.assertIsInstance(trust, (frozenset, set, bool))
+                if isinstance(trust, (frozenset, set)):
+                    trust_oids.update(trust)
+
+        serverAuth = "1.3.6.1.5.5.7.3.1"
+        self.assertIn(serverAuth, trust_oids)
+
+    @unittest.skipUnless(sys.platform == "win32", "Windows specific")
+    def test_enum_crls(self):
+        self.assertTrue(ssl.enum_crls("CA"))
+        self.assertRaises(TypeError, ssl.enum_crls)
+        self.assertRaises(WindowsError, ssl.enum_crls, "")
+
+        crls = ssl.enum_crls("CA")
+        self.assertIsInstance(crls, list)
+        for element in crls:
+            self.assertIsInstance(element, tuple)
+            self.assertEqual(len(element), 2)
+            self.assertIsInstance(element[0], bytes)
+            self.assertIn(element[1], {"x509_asn", "pkcs_7_asn"})
+
+
+    def test_asn1object(self):
+        expected = (129, 'serverAuth', 'TLS Web Server Authentication',
+                    '1.3.6.1.5.5.7.3.1')
+
+        val = ssl._ASN1Object('1.3.6.1.5.5.7.3.1')
+        self.assertEqual(val, expected)
+        self.assertEqual(val.nid, 129)
+        self.assertEqual(val.shortname, 'serverAuth')
+        self.assertEqual(val.longname, 'TLS Web Server Authentication')
+        self.assertEqual(val.oid, '1.3.6.1.5.5.7.3.1')
+        self.assertIsInstance(val, ssl._ASN1Object)
+        self.assertRaises(ValueError, ssl._ASN1Object, 'serverAuth')
+
+        val = ssl._ASN1Object.fromnid(129)
+        self.assertEqual(val, expected)
+        self.assertIsInstance(val, ssl._ASN1Object)
+        self.assertRaises(ValueError, ssl._ASN1Object.fromnid, -1)
+        with self.assertRaisesRegex(ValueError, "unknown NID 100000"):
+            ssl._ASN1Object.fromnid(100000)
+        for i in range(1000):
+            try:
+                obj = ssl._ASN1Object.fromnid(i)
+            except ValueError:
+                pass
+            else:
+                self.assertIsInstance(obj.nid, int)
+                self.assertIsInstance(obj.shortname, str)
+                self.assertIsInstance(obj.longname, str)
+                self.assertIsInstance(obj.oid, (str, type(None)))
+
+        val = ssl._ASN1Object.fromname('TLS Web Server Authentication')
+        self.assertEqual(val, expected)
+        self.assertIsInstance(val, ssl._ASN1Object)
+        self.assertEqual(ssl._ASN1Object.fromname('serverAuth'), expected)
+        self.assertEqual(ssl._ASN1Object.fromname('1.3.6.1.5.5.7.3.1'),
+                         expected)
+        with self.assertRaisesRegex(ValueError, "unknown object 'serverauth'"):
+            ssl._ASN1Object.fromname('serverauth')
+
+    def test_purpose_enum(self):
+        val = ssl._ASN1Object('1.3.6.1.5.5.7.3.1')
+        self.assertIsInstance(ssl.Purpose.SERVER_AUTH, ssl._ASN1Object)
+        self.assertEqual(ssl.Purpose.SERVER_AUTH, val)
+        self.assertEqual(ssl.Purpose.SERVER_AUTH.nid, 129)
+        self.assertEqual(ssl.Purpose.SERVER_AUTH.shortname, 'serverAuth')
+        self.assertEqual(ssl.Purpose.SERVER_AUTH.oid,
+                              '1.3.6.1.5.5.7.3.1')
+
+        val = ssl._ASN1Object('1.3.6.1.5.5.7.3.2')
+        self.assertIsInstance(ssl.Purpose.CLIENT_AUTH, ssl._ASN1Object)
+        self.assertEqual(ssl.Purpose.CLIENT_AUTH, val)
+        self.assertEqual(ssl.Purpose.CLIENT_AUTH.nid, 130)
+        self.assertEqual(ssl.Purpose.CLIENT_AUTH.shortname, 'clientAuth')
+        self.assertEqual(ssl.Purpose.CLIENT_AUTH.oid,
+                              '1.3.6.1.5.5.7.3.2')
+
+    def test_unsupported_dtls(self):
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.addCleanup(s.close)
+        with self.assertRaises(NotImplementedError) as cx:
+            test_wrap_socket(s, cert_reqs=ssl.CERT_NONE)
+        self.assertEqual(str(cx.exception), "only stream sockets are supported")
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        with self.assertRaises(NotImplementedError) as cx:
+            ctx.wrap_socket(s)
+        self.assertEqual(str(cx.exception), "only stream sockets are supported")
+
+    def cert_time_ok(self, timestring, timestamp):
+        self.assertEqual(ssl.cert_time_to_seconds(timestring), timestamp)
+
+    def cert_time_fail(self, timestring):
+        with self.assertRaises(ValueError):
+            ssl.cert_time_to_seconds(timestring)
+
+    @unittest.skipUnless(utc_offset(),
+                         'local time needs to be different from UTC')
+    def test_cert_time_to_seconds_timezone(self):
+        # Issue #19940: ssl.cert_time_to_seconds() returns wrong
+        #               results if local timezone is not UTC
+        self.cert_time_ok("May  9 00:00:00 2007 GMT", 1178668800.0)
+        self.cert_time_ok("Jan  5 09:34:43 2018 GMT", 1515144883.0)
+
+    def test_cert_time_to_seconds(self):
+        timestring = "Jan  5 09:34:43 2018 GMT"
+        ts = 1515144883.0
+        self.cert_time_ok(timestring, ts)
+        # accept keyword parameter, assert its name
+        self.assertEqual(ssl.cert_time_to_seconds(cert_time=timestring), ts)
+        # accept both %e and %d (space or zero generated by strftime)
+        self.cert_time_ok("Jan 05 09:34:43 2018 GMT", ts)
+        # case-insensitive
+        self.cert_time_ok("JaN  5 09:34:43 2018 GmT", ts)
+        self.cert_time_fail("Jan  5 09:34 2018 GMT")     # no seconds
+        self.cert_time_fail("Jan  5 09:34:43 2018")      # no GMT
+        self.cert_time_fail("Jan  5 09:34:43 2018 UTC")  # not GMT timezone
+        self.cert_time_fail("Jan 35 09:34:43 2018 GMT")  # invalid day
+        self.cert_time_fail("Jon  5 09:34:43 2018 GMT")  # invalid month
+        self.cert_time_fail("Jan  5 24:00:00 2018 GMT")  # invalid hour
+        self.cert_time_fail("Jan  5 09:60:43 2018 GMT")  # invalid minute
+
+        newyear_ts = 1230768000.0
+        # leap seconds
+        self.cert_time_ok("Dec 31 23:59:60 2008 GMT", newyear_ts)
+        # same timestamp
+        self.cert_time_ok("Jan  1 00:00:00 2009 GMT", newyear_ts)
+
+        self.cert_time_ok("Jan  5 09:34:59 2018 GMT", 1515144899)
+        #  allow 60th second (even if it is not a leap second)
+        self.cert_time_ok("Jan  5 09:34:60 2018 GMT", 1515144900)
+        #  allow 2nd leap second for compatibility with time.strptime()
+        self.cert_time_ok("Jan  5 09:34:61 2018 GMT", 1515144901)
+        self.cert_time_fail("Jan  5 09:34:62 2018 GMT")  # invalid seconds
+
+        # no special treatment for the special value:
+        #   99991231235959Z (rfc 5280)
+        self.cert_time_ok("Dec 31 23:59:59 9999 GMT", 253402300799.0)
+
+    @support.run_with_locale('LC_ALL', '')
+    def test_cert_time_to_seconds_locale(self):
+        # `cert_time_to_seconds()` should be locale independent
+
+        def local_february_name():
+            return time.strftime('%b', (1, 2, 3, 4, 5, 6, 0, 0, 0))
+
+        if local_february_name().lower() == 'feb':
+            self.skipTest("locale-specific month name needs to be "
+                          "different from C locale")
+
+        # locale-independent
+        self.cert_time_ok("Feb  9 00:00:00 2007 GMT", 1170979200.0)
+        self.cert_time_fail(local_february_name() + "  9 00:00:00 2007 GMT")
+
+    def test_connect_ex_error(self):
+        server = socket.socket(socket.AF_INET)
+        self.addCleanup(server.close)
+        port = socket_helper.bind_port(server)  # Reserve port but don't listen
+        s = test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_REQUIRED)
+        self.addCleanup(s.close)
+        rc = s.connect_ex((HOST, port))
+        # Issue #19919: Windows machines or VMs hosted on Windows
+        # machines sometimes return EWOULDBLOCK.
+        errors = (
+            errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
+            errno.EWOULDBLOCK,
+        )
+        self.assertIn(rc, errors)
+
+    def test_read_write_zero(self):
+        # empty reads and writes now work, bpo-42854, bpo-31711
+        client_context, server_context, hostname = testing_context()
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertEqual(s.recv(0), b"")
+                self.assertEqual(s.send(b""), 0)
+
+
+class ContextTests(unittest.TestCase):
+
+    def test_constructor(self):
+        for protocol in PROTOCOLS:
+            if has_tls_protocol(protocol):
+                with warnings_helper.check_warnings():
+                    ctx = ssl.SSLContext(protocol)
+                self.assertEqual(ctx.protocol, protocol)
+        with warnings_helper.check_warnings():
+            ctx = ssl.SSLContext()
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS)
+        self.assertRaises(ValueError, ssl.SSLContext, -1)
+        self.assertRaises(ValueError, ssl.SSLContext, 42)
+
+    def test_ciphers(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.set_ciphers("ALL")
+        ctx.set_ciphers("DEFAULT")
+        with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
+            ctx.set_ciphers("^$:,;?*'dorothyx")
+
+    @unittest.skipUnless(PY_SSL_DEFAULT_CIPHERS == 1,
+                         "Test applies only to Python default ciphers")
+    def test_python_ciphers(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ciphers = ctx.get_ciphers()
+        for suite in ciphers:
+            name = suite['name']
+            self.assertNotIn("PSK", name)
+            self.assertNotIn("SRP", name)
+            self.assertNotIn("MD5", name)
+            self.assertNotIn("RC4", name)
+            self.assertNotIn("3DES", name)
+
+    def test_get_ciphers(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.set_ciphers('AESGCM')
+        names = set(d['name'] for d in ctx.get_ciphers())
+        expected = {
+            'AES128-GCM-SHA256',
+            'ECDHE-ECDSA-AES128-GCM-SHA256',
+            'ECDHE-RSA-AES128-GCM-SHA256',
+            'DHE-RSA-AES128-GCM-SHA256',
+            'AES256-GCM-SHA384',
+            'ECDHE-ECDSA-AES256-GCM-SHA384',
+            'ECDHE-RSA-AES256-GCM-SHA384',
+            'DHE-RSA-AES256-GCM-SHA384',
+        }
+        intersection = names.intersection(expected)
+        self.assertGreaterEqual(
+            len(intersection), 2, f"\ngot: {sorted(names)}\nexpected: {sorted(expected)}"
+        )
+
+    def test_options(self):
+        # Test default SSLContext options
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        # OP_ALL | OP_NO_SSLv2 | OP_NO_SSLv3 is the default value
+        default = (ssl.OP_ALL | ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3)
+        # SSLContext also enables these by default
+        default |= (OP_NO_COMPRESSION | OP_CIPHER_SERVER_PREFERENCE |
+                    OP_SINGLE_DH_USE | OP_SINGLE_ECDH_USE |
+                    OP_ENABLE_MIDDLEBOX_COMPAT)
+        self.assertEqual(default, ctx.options)
+
+        # disallow TLSv1
+        with warnings_helper.check_warnings():
+            ctx.options |= ssl.OP_NO_TLSv1
+        self.assertEqual(default | ssl.OP_NO_TLSv1, ctx.options)
+
+        # allow TLSv1
+        with warnings_helper.check_warnings():
+            ctx.options = (ctx.options & ~ssl.OP_NO_TLSv1)
+        self.assertEqual(default, ctx.options)
+
+        # clear all options
+        ctx.options = 0
+        # Ubuntu has OP_NO_SSLv3 forced on by default
+        self.assertEqual(0, ctx.options & ~ssl.OP_NO_SSLv3)
+
+        # invalid options
+        with self.assertRaises(OverflowError):
+            ctx.options = -1
+        with self.assertRaises(OverflowError):
+            ctx.options = 2 ** 100
+        with self.assertRaises(TypeError):
+            ctx.options = "abc"
+
+    def test_verify_mode_protocol(self):
+        with warnings_helper.check_warnings():
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
+        # Default value
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        ctx.verify_mode = ssl.CERT_OPTIONAL
+        self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        ctx.verify_mode = ssl.CERT_NONE
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        with self.assertRaises(TypeError):
+            ctx.verify_mode = None
+        with self.assertRaises(ValueError):
+            ctx.verify_mode = 42
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        self.assertFalse(ctx.check_hostname)
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        self.assertTrue(ctx.check_hostname)
+
+    def test_hostname_checks_common_name(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertTrue(ctx.hostname_checks_common_name)
+        if ssl.HAS_NEVER_CHECK_COMMON_NAME:
+            ctx.hostname_checks_common_name = True
+            self.assertTrue(ctx.hostname_checks_common_name)
+            ctx.hostname_checks_common_name = False
+            self.assertFalse(ctx.hostname_checks_common_name)
+            ctx.hostname_checks_common_name = True
+            self.assertTrue(ctx.hostname_checks_common_name)
+        else:
+            with self.assertRaises(AttributeError):
+                ctx.hostname_checks_common_name = True
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @ignore_deprecation
+    def test_min_max_version(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # OpenSSL default is MINIMUM_SUPPORTED, however some vendors like
+        # Fedora override the setting to TLS 1.0.
+        minimum_range = {
+            # stock OpenSSL
+            ssl.TLSVersion.MINIMUM_SUPPORTED,
+            # Fedora 29 uses TLS 1.0 by default
+            ssl.TLSVersion.TLSv1,
+            # RHEL 8 uses TLS 1.2 by default
+            ssl.TLSVersion.TLSv1_2
+        }
+        maximum_range = {
+            # stock OpenSSL
+            ssl.TLSVersion.MAXIMUM_SUPPORTED,
+            # Fedora 32 uses TLS 1.3 by default
+            ssl.TLSVersion.TLSv1_3
+        }
+
+        self.assertIn(
+            ctx.minimum_version, minimum_range
+        )
+        self.assertIn(
+            ctx.maximum_version, maximum_range
+        )
+
+        ctx.minimum_version = ssl.TLSVersion.TLSv1_1
+        ctx.maximum_version = ssl.TLSVersion.TLSv1_2
+        self.assertEqual(
+            ctx.minimum_version, ssl.TLSVersion.TLSv1_1
+        )
+        self.assertEqual(
+            ctx.maximum_version, ssl.TLSVersion.TLSv1_2
+        )
+
+        ctx.minimum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
+        ctx.maximum_version = ssl.TLSVersion.TLSv1
+        self.assertEqual(
+            ctx.minimum_version, ssl.TLSVersion.MINIMUM_SUPPORTED
+        )
+        self.assertEqual(
+            ctx.maximum_version, ssl.TLSVersion.TLSv1
+        )
+
+        ctx.maximum_version = ssl.TLSVersion.MAXIMUM_SUPPORTED
+        self.assertEqual(
+            ctx.maximum_version, ssl.TLSVersion.MAXIMUM_SUPPORTED
+        )
+
+        ctx.maximum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
+        self.assertIn(
+            ctx.maximum_version,
+            {ssl.TLSVersion.TLSv1, ssl.TLSVersion.TLSv1_1, ssl.TLSVersion.SSLv3}
+        )
+
+        ctx.minimum_version = ssl.TLSVersion.MAXIMUM_SUPPORTED
+        self.assertIn(
+            ctx.minimum_version,
+            {ssl.TLSVersion.TLSv1_2, ssl.TLSVersion.TLSv1_3}
+        )
+
+        with self.assertRaises(ValueError):
+            ctx.minimum_version = 42
+
+        if has_tls_protocol(ssl.PROTOCOL_TLSv1_1):
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_1)
+
+            self.assertIn(
+                ctx.minimum_version, minimum_range
+            )
+            self.assertEqual(
+                ctx.maximum_version, ssl.TLSVersion.MAXIMUM_SUPPORTED
+            )
+            with self.assertRaises(ValueError):
+                ctx.minimum_version = ssl.TLSVersion.MINIMUM_SUPPORTED
+            with self.assertRaises(ValueError):
+                ctx.maximum_version = ssl.TLSVersion.TLSv1
+
+    @unittest.skipUnless(
+        hasattr(ssl.SSLContext, 'security_level'),
+        "requires OpenSSL >= 1.1.0"
+    )
+    def test_security_level(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        # The default security callback allows for levels between 0-5
+        # with OpenSSL defaulting to 1, however some vendors override the
+        # default value (e.g. Debian defaults to 2)
+        security_level_range = {
+            0,
+            1, # OpenSSL default
+            2, # Debian
+            3,
+            4,
+            5,
+        }
+        self.assertIn(ctx.security_level, security_level_range)
+
+    def test_verify_flags(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # default value
+        tf = getattr(ssl, "VERIFY_X509_TRUSTED_FIRST", 0)
+        self.assertEqual(ctx.verify_flags, ssl.VERIFY_DEFAULT | tf)
+        ctx.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF
+        self.assertEqual(ctx.verify_flags, ssl.VERIFY_CRL_CHECK_LEAF)
+        ctx.verify_flags = ssl.VERIFY_CRL_CHECK_CHAIN
+        self.assertEqual(ctx.verify_flags, ssl.VERIFY_CRL_CHECK_CHAIN)
+        ctx.verify_flags = ssl.VERIFY_DEFAULT
+        self.assertEqual(ctx.verify_flags, ssl.VERIFY_DEFAULT)
+        ctx.verify_flags = ssl.VERIFY_ALLOW_PROXY_CERTS
+        self.assertEqual(ctx.verify_flags, ssl.VERIFY_ALLOW_PROXY_CERTS)
+        # supports any value
+        ctx.verify_flags = ssl.VERIFY_CRL_CHECK_LEAF | ssl.VERIFY_X509_STRICT
+        self.assertEqual(ctx.verify_flags,
+                         ssl.VERIFY_CRL_CHECK_LEAF | ssl.VERIFY_X509_STRICT)
+        with self.assertRaises(TypeError):
+            ctx.verify_flags = None
+
+    def test_load_cert_chain(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # Combined key and cert in a single file
+        ctx.load_cert_chain(CERTFILE, keyfile=None)
+        ctx.load_cert_chain(CERTFILE, keyfile=CERTFILE)
+        self.assertRaises(TypeError, ctx.load_cert_chain, keyfile=CERTFILE)
+        with self.assertRaises(OSError) as cm:
+            ctx.load_cert_chain(NONEXISTINGCERT)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_cert_chain(BADCERT)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_cert_chain(EMPTYCERT)
+        # Separate key and cert
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        ctx.load_cert_chain(ONLYCERT, ONLYKEY)
+        ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
+        ctx.load_cert_chain(certfile=BYTES_ONLYCERT, keyfile=BYTES_ONLYKEY)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_cert_chain(ONLYCERT)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_cert_chain(ONLYKEY)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_cert_chain(certfile=ONLYKEY, keyfile=ONLYCERT)
+        # Mismatching key and cert
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            key values mismatch         # OpenSSL
+            |
+            KEY_VALUES_MISMATCH         # AWS-LC
+        )""", re.X)
+        with self.assertRaisesRegex(ssl.SSLError, regex):
+            ctx.load_cert_chain(CAFILE_CACERT, ONLYKEY)
+        # Password protected key and cert
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD)
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=KEY_PASSWORD.encode())
+        ctx.load_cert_chain(CERTFILE_PROTECTED,
+                            password=bytearray(KEY_PASSWORD.encode()))
+        ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD)
+        ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED, KEY_PASSWORD.encode())
+        ctx.load_cert_chain(ONLYCERT, ONLYKEY_PROTECTED,
+                            bytearray(KEY_PASSWORD.encode()))
+        with self.assertRaisesRegex(TypeError, "should be a string"):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=True)
+        with self.assertRaises(ssl.SSLError):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password="badpass")
+        with self.assertRaisesRegex(ValueError, "cannot be longer"):
+            # openssl has a fixed limit on the password buffer.
+            # PEM_BUFSIZE is generally set to 1kb.
+            # Return a string larger than this.
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=b'a' * 102400)
+        # Password callback
+        def getpass_unicode():
+            return KEY_PASSWORD
+        def getpass_bytes():
+            return KEY_PASSWORD.encode()
+        def getpass_bytearray():
+            return bytearray(KEY_PASSWORD.encode())
+        def getpass_badpass():
+            return "badpass"
+        def getpass_huge():
+            return b'a' * (1024 * 1024)
+        def getpass_bad_type():
+            return 9
+        def getpass_exception():
+            raise Exception('getpass error')
+        class GetPassCallable:
+            def __call__(self):
+                return KEY_PASSWORD
+            def getpass(self):
+                return KEY_PASSWORD
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_unicode)
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytes)
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bytearray)
+        ctx.load_cert_chain(CERTFILE_PROTECTED, password=GetPassCallable())
+        ctx.load_cert_chain(CERTFILE_PROTECTED,
+                            password=GetPassCallable().getpass)
+        with self.assertRaises(ssl.SSLError):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_badpass)
+        with self.assertRaisesRegex(ValueError, "cannot be longer"):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_huge)
+        with self.assertRaisesRegex(TypeError, "must return a string"):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_bad_type)
+        with self.assertRaisesRegex(Exception, "getpass error"):
+            ctx.load_cert_chain(CERTFILE_PROTECTED, password=getpass_exception)
+        # Make sure the password function isn't called if it isn't needed
+        ctx.load_cert_chain(CERTFILE, password=getpass_exception)
+
+    @threading_helper.requires_working_threading()
+    def test_load_cert_chain_thread_safety(self):
+        # gh-134698: _ssl detaches the thread state (and as such,
+        # releases the GIL and critical sections) around expensive
+        # OpenSSL calls. Unfortunately, OpenSSL structures aren't
+        # thread-safe, so executing these calls concurrently led
+        # to crashes.
+        ctx = ssl.create_default_context()
+
+        def race():
+            ctx.load_cert_chain(CERTFILE)
+
+        threads = [threading.Thread(target=race) for _ in range(8)]
+        with threading_helper.catch_threading_exception() as cm:
+            with threading_helper.start_threads(threads):
+                pass
+
+            self.assertIsNone(cm.exc_value)
+
+    def test_load_verify_locations(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        ctx.load_verify_locations(CERTFILE)
+        ctx.load_verify_locations(cafile=CERTFILE, capath=None)
+        ctx.load_verify_locations(BYTES_CERTFILE)
+        ctx.load_verify_locations(cafile=BYTES_CERTFILE, capath=None)
+        self.assertRaises(TypeError, ctx.load_verify_locations)
+        self.assertRaises(TypeError, ctx.load_verify_locations, None, None, None)
+        with self.assertRaises(OSError) as cm:
+            ctx.load_verify_locations(NONEXISTINGCERT)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        with self.assertRaisesRegex(ssl.SSLError, "PEM (lib|routines)"):
+            ctx.load_verify_locations(BADCERT)
+        ctx.load_verify_locations(CERTFILE, CAPATH)
+        ctx.load_verify_locations(CERTFILE, capath=BYTES_CAPATH)
+
+        # Issue #10989: crash if the second argument type is invalid
+        self.assertRaises(TypeError, ctx.load_verify_locations, None, True)
+
+    def test_load_verify_cadata(self):
+        # test cadata
+        with open(CAFILE_CACERT) as f:
+            cacert_pem = f.read()
+        cacert_der = ssl.PEM_cert_to_DER_cert(cacert_pem)
+        with open(CAFILE_NEURONIO) as f:
+            neuronio_pem = f.read()
+        neuronio_der = ssl.PEM_cert_to_DER_cert(neuronio_pem)
+
+        # test PEM
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 0)
+        ctx.load_verify_locations(cadata=cacert_pem)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 1)
+        ctx.load_verify_locations(cadata=neuronio_pem)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+        # cert already in hash table
+        ctx.load_verify_locations(cadata=neuronio_pem)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+
+        # combined
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        combined = "\n".join((cacert_pem, neuronio_pem))
+        ctx.load_verify_locations(cadata=combined)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+
+        # with junk around the certs
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        combined = ["head", cacert_pem, "other", neuronio_pem, "again",
+                    neuronio_pem, "tail"]
+        ctx.load_verify_locations(cadata="\n".join(combined))
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+
+        # test DER
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(cadata=cacert_der)
+        ctx.load_verify_locations(cadata=neuronio_der)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+        # cert already in hash table
+        ctx.load_verify_locations(cadata=cacert_der)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+
+        # combined
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        combined = b"".join((cacert_der, neuronio_der))
+        ctx.load_verify_locations(cadata=combined)
+        self.assertEqual(ctx.cert_store_stats()["x509_ca"], 2)
+
+        # error cases
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertRaises(TypeError, ctx.load_verify_locations, cadata=object)
+
+        with self.assertRaisesRegex(
+            ssl.SSLError,
+            "no start line: cadata does not contain a certificate"
+        ):
+            ctx.load_verify_locations(cadata="broken")
+        with self.assertRaisesRegex(
+            ssl.SSLError,
+            "not enough data: cadata does not contain a certificate"
+        ):
+            ctx.load_verify_locations(cadata=b"broken")
+        with self.assertRaises(ssl.SSLError):
+            ctx.load_verify_locations(cadata=cacert_der + b"A")
+
+    def test_load_dh_params(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        try:
+            ctx.load_dh_params(DHFILE)
+        except RuntimeError:
+            if Py_DEBUG_WIN32:
+                self.skipTest("not supported on Win32 debug build")
+            raise
+        if os.name != 'nt':
+            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:
+            ctx.load_dh_params(NONEXISTINGCERT)
+        self.assertEqual(cm.exception.errno, errno.ENOENT)
+        with self.assertRaises(ssl.SSLError) as cm:
+            ctx.load_dh_params(CERTFILE)
+
+    def test_session_stats(self):
+        for proto in {ssl.PROTOCOL_TLS_CLIENT, ssl.PROTOCOL_TLS_SERVER}:
+            ctx = ssl.SSLContext(proto)
+            self.assertEqual(ctx.session_stats(), {
+                'number': 0,
+                'connect': 0,
+                'connect_good': 0,
+                'connect_renegotiate': 0,
+                'accept': 0,
+                'accept_good': 0,
+                'accept_renegotiate': 0,
+                'hits': 0,
+                'misses': 0,
+                'timeouts': 0,
+                'cache_full': 0,
+            })
+
+    def test_set_default_verify_paths(self):
+        # There's not much we can do to test that it acts as expected,
+        # so just check it doesn't crash or raise an exception.
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.set_default_verify_paths()
+
+    @unittest.skipUnless(ssl.HAS_ECDH, "ECDH disabled on this OpenSSL build")
+    def test_set_ecdh_curve(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        ctx.set_ecdh_curve("prime256v1")
+        ctx.set_ecdh_curve(b"prime256v1")
+        self.assertRaises(TypeError, ctx.set_ecdh_curve)
+        self.assertRaises(TypeError, ctx.set_ecdh_curve, None)
+        self.assertRaises(ValueError, ctx.set_ecdh_curve, "foo")
+        self.assertRaises(ValueError, ctx.set_ecdh_curve, b"foo")
+
+    def test_sni_callback(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+
+        # set_servername_callback expects a callable, or None
+        self.assertRaises(TypeError, ctx.set_servername_callback)
+        self.assertRaises(TypeError, ctx.set_servername_callback, 4)
+        self.assertRaises(TypeError, ctx.set_servername_callback, "")
+        self.assertRaises(TypeError, ctx.set_servername_callback, ctx)
+
+        def dummycallback(sock, servername, ctx):
+            pass
+        ctx.set_servername_callback(None)
+        ctx.set_servername_callback(dummycallback)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_sni_callback_refcycle(self):
+        # Reference cycles through the servername callback are detected
+        # and cleared.
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        def dummycallback(sock, servername, ctx, cycle=ctx):
+            pass
+        ctx.set_servername_callback(dummycallback)
+        wr = weakref.ref(ctx)
+        del ctx, dummycallback
+        gc.collect()
+        self.assertIs(wr(), None)
+
+    def test_cert_store_stats(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.cert_store_stats(),
+            {'x509_ca': 0, 'crl': 0, 'x509': 0})
+        ctx.load_cert_chain(CERTFILE)
+        self.assertEqual(ctx.cert_store_stats(),
+            {'x509_ca': 0, 'crl': 0, 'x509': 0})
+        ctx.load_verify_locations(CERTFILE)
+        self.assertEqual(ctx.cert_store_stats(),
+            {'x509_ca': 0, 'crl': 0, 'x509': 1})
+        ctx.load_verify_locations(CAFILE_CACERT)
+        self.assertEqual(ctx.cert_store_stats(),
+            {'x509_ca': 1, 'crl': 0, 'x509': 2})
+
+    def test_get_ca_certs(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.get_ca_certs(), [])
+        # CERTFILE is not flagged as X509v3 Basic Constraints: CA:TRUE
+        ctx.load_verify_locations(CERTFILE)
+        self.assertEqual(ctx.get_ca_certs(), [])
+        # but CAFILE_CACERT is a CA cert
+        ctx.load_verify_locations(CAFILE_CACERT)
+        self.assertEqual(ctx.get_ca_certs(),
+            [{'issuer': ((('organizationName', 'Root CA'),),
+                         (('organizationalUnitName', 'http://www.cacert.org'),),
+                         (('commonName', 'CA Cert Signing Authority'),),
+                         (('emailAddress', 'support@cacert.org'),)),
+              'notAfter': 'Mar 29 12:29:49 2033 GMT',
+              'notBefore': 'Mar 30 12:29:49 2003 GMT',
+              'serialNumber': '00',
+              'crlDistributionPoints': ('https://www.cacert.org/revoke.crl',),
+              'subject': ((('organizationName', 'Root CA'),),
+                          (('organizationalUnitName', 'http://www.cacert.org'),),
+                          (('commonName', 'CA Cert Signing Authority'),),
+                          (('emailAddress', 'support@cacert.org'),)),
+              'version': 3}])
+
+        with open(CAFILE_CACERT) as f:
+            pem = f.read()
+        der = ssl.PEM_cert_to_DER_cert(pem)
+        self.assertEqual(ctx.get_ca_certs(True), [der])
+
+    def test_load_default_certs(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_default_certs()
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_default_certs(ssl.Purpose.SERVER_AUTH)
+        ctx.load_default_certs()
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_default_certs(ssl.Purpose.CLIENT_AUTH)
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertRaises(TypeError, ctx.load_default_certs, None)
+        self.assertRaises(TypeError, ctx.load_default_certs, 'SERVER_AUTH')
+
+    @unittest.skipIf(sys.platform == "win32", "not-Windows specific")
+    def test_load_default_certs_env(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        with os_helper.EnvironmentVarGuard() as env:
+            env["SSL_CERT_DIR"] = CAPATH
+            env["SSL_CERT_FILE"] = CERTFILE
+            ctx.load_default_certs()
+            self.assertEqual(ctx.cert_store_stats(), {"crl": 0, "x509": 1, "x509_ca": 0})
+
+    @unittest.skipUnless(sys.platform == "win32", "Windows specific")
+    @unittest.skipIf(support.Py_DEBUG,
+                     "Debug build does not share environment between CRTs")
+    def test_load_default_certs_env_windows(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_default_certs()
+        stats = ctx.cert_store_stats()
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        with os_helper.EnvironmentVarGuard() as env:
+            env["SSL_CERT_DIR"] = CAPATH
+            env["SSL_CERT_FILE"] = CERTFILE
+            ctx.load_default_certs()
+            stats["x509"] += 1
+            self.assertEqual(ctx.cert_store_stats(), stats)
+
+    def _assert_context_options(self, ctx):
+        self.assertEqual(ctx.options & ssl.OP_NO_SSLv2, ssl.OP_NO_SSLv2)
+        if OP_NO_COMPRESSION != 0:
+            self.assertEqual(ctx.options & OP_NO_COMPRESSION,
+                             OP_NO_COMPRESSION)
+        if OP_SINGLE_DH_USE != 0:
+            self.assertEqual(ctx.options & OP_SINGLE_DH_USE,
+                             OP_SINGLE_DH_USE)
+        if OP_SINGLE_ECDH_USE != 0:
+            self.assertEqual(ctx.options & OP_SINGLE_ECDH_USE,
+                             OP_SINGLE_ECDH_USE)
+        if OP_CIPHER_SERVER_PREFERENCE != 0:
+            self.assertEqual(ctx.options & OP_CIPHER_SERVER_PREFERENCE,
+                             OP_CIPHER_SERVER_PREFERENCE)
+        self.assertEqual(ctx.options & ssl.OP_LEGACY_SERVER_CONNECT,
+                         0 if IS_OPENSSL_3_0_0 else ssl.OP_LEGACY_SERVER_CONNECT)
+
+    def test_create_default_context(self):
+        ctx = ssl.create_default_context()
+
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        self.assertEqual(ctx.verify_flags & ssl.VERIFY_X509_PARTIAL_CHAIN,
+                         ssl.VERIFY_X509_PARTIAL_CHAIN)
+        self.assertEqual(ctx.verify_flags & ssl.VERIFY_X509_STRICT,
+                    ssl.VERIFY_X509_STRICT)
+        self.assertTrue(ctx.check_hostname)
+        self._assert_context_options(ctx)
+
+        with open(SIGNING_CA) as f:
+            cadata = f.read()
+        ctx = ssl.create_default_context(cafile=SIGNING_CA, capath=CAPATH,
+                                         cadata=cadata)
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        self._assert_context_options(ctx)
+
+        ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_SERVER)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        self._assert_context_options(ctx)
+
+    def test__create_stdlib_context(self):
+        ctx = ssl._create_stdlib_context()
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        self.assertFalse(ctx.check_hostname)
+        self._assert_context_options(ctx)
+
+        if has_tls_protocol(ssl.PROTOCOL_TLSv1):
+            with warnings_helper.check_warnings():
+                ctx = ssl._create_stdlib_context(ssl.PROTOCOL_TLSv1)
+            self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLSv1)
+            self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+            self._assert_context_options(ctx)
+
+        with warnings_helper.check_warnings():
+            ctx = ssl._create_stdlib_context(
+                ssl.PROTOCOL_TLSv1_2,
+                cert_reqs=ssl.CERT_REQUIRED,
+                check_hostname=True
+            )
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLSv1_2)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        self.assertTrue(ctx.check_hostname)
+        self._assert_context_options(ctx)
+
+        ctx = ssl._create_stdlib_context(purpose=ssl.Purpose.CLIENT_AUTH)
+        self.assertEqual(ctx.protocol, ssl.PROTOCOL_TLS_SERVER)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        self._assert_context_options(ctx)
+
+    def test_check_hostname(self):
+        with warnings_helper.check_warnings():
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS)
+        self.assertFalse(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+
+        # Auto set CERT_REQUIRED
+        ctx.check_hostname = True
+        self.assertTrue(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        self.assertFalse(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+
+        # Changing verify_mode does not affect check_hostname
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        ctx.check_hostname = False
+        self.assertFalse(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+        # Auto set
+        ctx.check_hostname = True
+        self.assertTrue(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_OPTIONAL
+        ctx.check_hostname = False
+        self.assertFalse(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
+        # keep CERT_OPTIONAL
+        ctx.check_hostname = True
+        self.assertTrue(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_OPTIONAL)
+
+        # Cannot set CERT_NONE with check_hostname enabled
+        with self.assertRaises(ValueError):
+            ctx.verify_mode = ssl.CERT_NONE
+        ctx.check_hostname = False
+        self.assertFalse(ctx.check_hostname)
+        ctx.verify_mode = ssl.CERT_NONE
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+
+    def test_context_client_server(self):
+        # PROTOCOL_TLS_CLIENT has sane defaults
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertTrue(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+
+        # PROTOCOL_TLS_SERVER has different but also sane defaults
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        self.assertFalse(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_NONE)
+
+    def test_context_custom_class(self):
+        class MySSLSocket(ssl.SSLSocket):
+            pass
+
+        class MySSLObject(ssl.SSLObject):
+            pass
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        ctx.sslsocket_class = MySSLSocket
+        ctx.sslobject_class = MySSLObject
+
+        with ctx.wrap_socket(socket.socket(), server_side=True) as sock:
+            self.assertIsInstance(sock, MySSLSocket)
+        obj = ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(), server_side=True)
+        self.assertIsInstance(obj, MySSLObject)
+
+    def test_num_tickest(self):
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        self.assertEqual(ctx.num_tickets, 2)
+        ctx.num_tickets = 1
+        self.assertEqual(ctx.num_tickets, 1)
+        ctx.num_tickets = 0
+        self.assertEqual(ctx.num_tickets, 0)
+        with self.assertRaises(ValueError):
+            ctx.num_tickets = -1
+        with self.assertRaises(TypeError):
+            ctx.num_tickets = None
+
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.num_tickets, 2)
+        with self.assertRaises(ValueError):
+            ctx.num_tickets = 1
+
+
+class SSLErrorTests(unittest.TestCase):
+
+    def test_str(self):
+        # The str() of a SSLError doesn't include the errno
+        e = ssl.SSLError(1, "foo")
+        self.assertEqual(str(e), "foo")
+        self.assertEqual(e.errno, 1)
+        # Same for a subclass
+        e = ssl.SSLZeroReturnError(1, "foo")
+        self.assertEqual(str(e), "foo")
+        self.assertEqual(e.errno, 1)
+
+    def test_lib_reason(self):
+        # Test the library and reason attributes
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        try:
+            with self.assertRaises(ssl.SSLError) as cm:
+                ctx.load_dh_params(CERTFILE)
+        except RuntimeError:
+            if Py_DEBUG_WIN32:
+                self.skipTest("not supported on Win32 debug build")
+            raise
+
+        self.assertEqual(cm.exception.library, 'PEM')
+        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)
+
+    def test_subclass(self):
+        # Check that the appropriate SSLError subclass is raised
+        # (this only tests one of them)
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        with socket.create_server(("127.0.0.1", 0)) as s:
+            c = socket.create_connection(s.getsockname())
+            c.setblocking(False)
+            with ctx.wrap_socket(c, False, do_handshake_on_connect=False) as c:
+                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)
+                # For compatibility
+                self.assertEqual(cm.exception.errno, ssl.SSL_ERROR_WANT_READ)
+
+
+    def test_bad_server_hostname(self):
+        ctx = ssl.create_default_context()
+        with self.assertRaises(ValueError):
+            ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
+                         server_hostname="")
+        with self.assertRaises(ValueError):
+            ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
+                         server_hostname=".example.org")
+        with self.assertRaises(TypeError):
+            ctx.wrap_bio(ssl.MemoryBIO(), ssl.MemoryBIO(),
+                         server_hostname="example.org\x00evil.com")
+
+
+class MemoryBIOTests(unittest.TestCase):
+
+    def test_read_write(self):
+        bio = ssl.MemoryBIO()
+        bio.write(b'foo')
+        self.assertEqual(bio.read(), b'foo')
+        self.assertEqual(bio.read(), b'')
+        bio.write(b'foo')
+        bio.write(b'bar')
+        self.assertEqual(bio.read(), b'foobar')
+        self.assertEqual(bio.read(), b'')
+        bio.write(b'baz')
+        self.assertEqual(bio.read(2), b'ba')
+        self.assertEqual(bio.read(1), b'z')
+        self.assertEqual(bio.read(1), b'')
+
+    def test_eof(self):
+        bio = ssl.MemoryBIO()
+        self.assertFalse(bio.eof)
+        self.assertEqual(bio.read(), b'')
+        self.assertFalse(bio.eof)
+        bio.write(b'foo')
+        self.assertFalse(bio.eof)
+        bio.write_eof()
+        self.assertFalse(bio.eof)
+        self.assertEqual(bio.read(2), b'fo')
+        self.assertFalse(bio.eof)
+        self.assertEqual(bio.read(1), b'o')
+        self.assertTrue(bio.eof)
+        self.assertEqual(bio.read(), b'')
+        self.assertTrue(bio.eof)
+
+    def test_pending(self):
+        bio = ssl.MemoryBIO()
+        self.assertEqual(bio.pending, 0)
+        bio.write(b'foo')
+        self.assertEqual(bio.pending, 3)
+        for i in range(3):
+            bio.read(1)
+            self.assertEqual(bio.pending, 3-i-1)
+        for i in range(3):
+            bio.write(b'x')
+            self.assertEqual(bio.pending, i+1)
+        bio.read()
+        self.assertEqual(bio.pending, 0)
+
+    def test_buffer_types(self):
+        bio = ssl.MemoryBIO()
+        bio.write(b'foo')
+        self.assertEqual(bio.read(), b'foo')
+        bio.write(bytearray(b'bar'))
+        self.assertEqual(bio.read(), b'bar')
+        bio.write(memoryview(b'baz'))
+        self.assertEqual(bio.read(), b'baz')
+        m = memoryview(bytearray(b'noncontig'))
+        noncontig_writable = m[::-2]
+        with self.assertRaises(BufferError):
+            bio.write(memoryview(noncontig_writable))
+
+    def test_error_types(self):
+        bio = ssl.MemoryBIO()
+        self.assertRaises(TypeError, bio.write, 'foo')
+        self.assertRaises(TypeError, bio.write, None)
+        self.assertRaises(TypeError, bio.write, True)
+        self.assertRaises(TypeError, bio.write, 1)
+
+
+class SSLObjectTests(unittest.TestCase):
+    def test_private_init(self):
+        bio = ssl.MemoryBIO()
+        with self.assertRaisesRegex(TypeError, "public constructor"):
+            ssl.SSLObject(bio, bio)
+
+    def test_unwrap(self):
+        client_ctx, server_ctx, hostname = testing_context()
+        c_in = ssl.MemoryBIO()
+        c_out = ssl.MemoryBIO()
+        s_in = ssl.MemoryBIO()
+        s_out = ssl.MemoryBIO()
+        client = client_ctx.wrap_bio(c_in, c_out, server_hostname=hostname)
+        server = server_ctx.wrap_bio(s_in, s_out, server_side=True)
+
+        # Loop on the handshake for a bit to get it settled
+        for _ in range(5):
+            try:
+                client.do_handshake()
+            except ssl.SSLWantReadError:
+                pass
+            if c_out.pending:
+                s_in.write(c_out.read())
+            try:
+                server.do_handshake()
+            except ssl.SSLWantReadError:
+                pass
+            if s_out.pending:
+                c_in.write(s_out.read())
+        # Now the handshakes should be complete (don't raise WantReadError)
+        client.do_handshake()
+        server.do_handshake()
+
+        # Now if we unwrap one side unilaterally, it should send close-notify
+        # and raise WantReadError:
+        with self.assertRaises(ssl.SSLWantReadError):
+            client.unwrap()
+
+        # But server.unwrap() does not raise, because it reads the client's
+        # close-notify:
+        s_in.write(c_out.read())
+        server.unwrap()
+
+        # And now that the client gets the server's close-notify, it doesn't
+        # raise either.
+        c_in.write(s_out.read())
+        client.unwrap()
+
+class SimpleBackgroundTests(unittest.TestCase):
+    """Tests that connect to a simple server running in the background"""
+
+    def setUp(self):
+        self.server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        self.server_context.load_cert_chain(SIGNED_CERTFILE)
+        server = ThreadedEchoServer(context=self.server_context)
+        self.enterContext(server)
+        self.server_addr = (HOST, server.port)
+
+    def test_connect(self):
+        with test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_NONE) as s:
+            s.connect(self.server_addr)
+            self.assertEqual({}, s.getpeercert())
+            self.assertFalse(s.server_side)
+
+        # this should succeed because we specify the root cert
+        with test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_REQUIRED,
+                            ca_certs=SIGNING_CA) as s:
+            s.connect(self.server_addr)
+            self.assertTrue(s.getpeercert())
+            self.assertFalse(s.server_side)
+
+    def test_connect_fail(self):
+        # This should fail because we have no verification certs. Connection
+        # failure crashes ThreadedEchoServer, so run this in an independent
+        # test method.
+        s = test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_REQUIRED)
+        self.addCleanup(s.close)
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            certificate verify failed   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED   # AWS-LC
+        )""", re.X)
+        self.assertRaisesRegex(ssl.SSLError, regex,
+                               s.connect, self.server_addr)
+
+    def test_connect_ex(self):
+        # Issue #11326: check connect_ex() implementation
+        s = test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_REQUIRED,
+                            ca_certs=SIGNING_CA)
+        self.addCleanup(s.close)
+        self.assertEqual(0, s.connect_ex(self.server_addr))
+        self.assertTrue(s.getpeercert())
+
+    def test_non_blocking_connect_ex(self):
+        # Issue #11326: non-blocking connect_ex() should allow handshake
+        # to proceed after the socket gets ready.
+        s = test_wrap_socket(socket.socket(socket.AF_INET),
+                            cert_reqs=ssl.CERT_REQUIRED,
+                            ca_certs=SIGNING_CA,
+                            do_handshake_on_connect=False)
+        self.addCleanup(s.close)
+        s.setblocking(False)
+        rc = s.connect_ex(self.server_addr)
+        # EWOULDBLOCK under Windows, EINPROGRESS elsewhere
+        self.assertIn(rc, (0, errno.EINPROGRESS, errno.EWOULDBLOCK))
+        # Wait for connect to finish
+        select.select([], [s], [], 5.0)
+        # Non-blocking handshake
+        while True:
+            try:
+                s.do_handshake()
+                break
+            except ssl.SSLWantReadError:
+                select.select([s], [], [], 5.0)
+            except ssl.SSLWantWriteError:
+                select.select([], [s], [], 5.0)
+        # SSL established
+        self.assertTrue(s.getpeercert())
+
+    def test_connect_with_context(self):
+        # Same as test_connect, but with a separately created context
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        with ctx.wrap_socket(socket.socket(socket.AF_INET)) as s:
+            s.connect(self.server_addr)
+            self.assertEqual({}, s.getpeercert())
+        # Same with a server hostname
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                            server_hostname="dummy") as s:
+            s.connect(self.server_addr)
+        ctx.verify_mode = ssl.CERT_REQUIRED
+        # This should succeed because we specify the root cert
+        ctx.load_verify_locations(SIGNING_CA)
+        with ctx.wrap_socket(socket.socket(socket.AF_INET)) as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+
+    def test_connect_with_context_fail(self):
+        # This should fail because we have no verification certs. Connection
+        # failure crashes ThreadedEchoServer, so run this in an independent
+        # test method.
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        s = ctx.wrap_socket(
+            socket.socket(socket.AF_INET),
+            server_hostname=SIGNED_CERTFILE_HOSTNAME
+        )
+        self.addCleanup(s.close)
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            certificate verify failed   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED   # AWS-LC
+        )""", re.X)
+        self.assertRaisesRegex(ssl.SSLError, regex,
+                                s.connect, self.server_addr)
+
+    def test_connect_capath(self):
+        # Verify server certificates using the `capath` argument
+        # NOTE: the subject hashing algorithm has been changed between
+        # OpenSSL 0.9.8n and 1.0.0, as a result the capath directory must
+        # contain both versions of each certificate (same content, different
+        # filename) for this test to be portable across OpenSSL releases.
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(capath=CAPATH)
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                             server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+
+        # Same with a bytes `capath` argument
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(capath=BYTES_CAPATH)
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                             server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+
+    def test_connect_cadata(self):
+        with open(SIGNING_CA) as f:
+            pem = f.read()
+        der = ssl.PEM_cert_to_DER_cert(pem)
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(cadata=pem)
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                             server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+
+        # same with DER
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(cadata=der)
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                             server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+
+    @unittest.skipIf(os.name == "nt", "Can't use a socket as a file under Windows")
+    def test_makefile_close(self):
+        # Issue #5238: creating a file-like object with makefile() shouldn't
+        # delay closing the underlying "real socket" (here tested with its
+        # file descriptor, hence skipping the test under Windows).
+        ss = test_wrap_socket(socket.socket(socket.AF_INET))
+        ss.connect(self.server_addr)
+        fd = ss.fileno()
+        f = ss.makefile()
+        f.close()
+        # The fd is still open
+        os.read(fd, 0)
+        # Closing the SSL socket should close the fd too
+        ss.close()
+        gc.collect()
+        with self.assertRaises(OSError) as e:
+            os.read(fd, 0)
+        self.assertEqual(e.exception.errno, errno.EBADF)
+
+    def test_non_blocking_handshake(self):
+        s = socket.socket(socket.AF_INET)
+        s.connect(self.server_addr)
+        s.setblocking(False)
+        s = test_wrap_socket(s,
+                            cert_reqs=ssl.CERT_NONE,
+                            do_handshake_on_connect=False)
+        self.addCleanup(s.close)
+        count = 0
+        while True:
+            try:
+                count += 1
+                s.do_handshake()
+                break
+            except ssl.SSLWantReadError:
+                select.select([s], [], [])
+            except ssl.SSLWantWriteError:
+                select.select([], [s], [])
+        if support.verbose:
+            sys.stdout.write("\nNeeded %d calls to do_handshake() to establish session.\n" % count)
+
+    def test_get_server_certificate(self):
+        _test_get_server_certificate(self, *self.server_addr, cert=SIGNING_CA)
+
+    def test_get_server_certificate_sni(self):
+        host, port = self.server_addr
+        server_names = []
+
+        # We store servername_cb arguments to make sure they match the host
+        def servername_cb(ssl_sock, server_name, initial_context):
+            server_names.append(server_name)
+        self.server_context.set_servername_callback(servername_cb)
+
+        pem = ssl.get_server_certificate((host, port))
+        if not pem:
+            self.fail("No server certificate on %s:%s!" % (host, port))
+
+        pem = ssl.get_server_certificate((host, port), ca_certs=SIGNING_CA)
+        if not pem:
+            self.fail("No server certificate on %s:%s!" % (host, port))
+        if support.verbose:
+            sys.stdout.write("\nVerified certificate for %s:%s is\n%s\n" % (host, port, pem))
+
+        self.assertEqual(server_names, [host, host])
+
+    def test_get_server_certificate_fail(self):
+        # Connection failure crashes ThreadedEchoServer, so run this in an
+        # independent test method
+        _test_get_server_certificate_fail(self, *self.server_addr)
+
+    def test_get_server_certificate_timeout(self):
+        def servername_cb(ssl_sock, server_name, initial_context):
+            time.sleep(0.2)
+        self.server_context.set_servername_callback(servername_cb)
+
+        with self.assertRaises(socket.timeout):
+            ssl.get_server_certificate(self.server_addr, ca_certs=SIGNING_CA,
+                                       timeout=0.1)
+
+    def test_ciphers(self):
+        with test_wrap_socket(socket.socket(socket.AF_INET),
+                             cert_reqs=ssl.CERT_NONE, ciphers="ALL") as s:
+            s.connect(self.server_addr)
+        with test_wrap_socket(socket.socket(socket.AF_INET),
+                             cert_reqs=ssl.CERT_NONE, ciphers="DEFAULT") as s:
+            s.connect(self.server_addr)
+        # Error checking can happen at instantiation or when connecting
+        with self.assertRaisesRegex(ssl.SSLError, "No cipher can be selected"):
+            with socket.socket(socket.AF_INET) as sock:
+                s = test_wrap_socket(sock,
+                                    cert_reqs=ssl.CERT_NONE, ciphers="^$:,;?*'dorothyx")
+                s.connect(self.server_addr)
+
+    def test_get_ca_certs_capath(self):
+        # capath certs are loaded on request
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.load_verify_locations(capath=CAPATH)
+        self.assertEqual(ctx.get_ca_certs(), [])
+        with ctx.wrap_socket(socket.socket(socket.AF_INET),
+                             server_hostname='localhost') as s:
+            s.connect(self.server_addr)
+            cert = s.getpeercert()
+            self.assertTrue(cert)
+        self.assertEqual(len(ctx.get_ca_certs()), 1)
+
+    def test_context_setget(self):
+        # Check that the context of a connected socket can be replaced.
+        ctx1 = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx1.load_verify_locations(capath=CAPATH)
+        ctx2 = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx2.load_verify_locations(capath=CAPATH)
+        s = socket.socket(socket.AF_INET)
+        with ctx1.wrap_socket(s, server_hostname='localhost') as ss:
+            ss.connect(self.server_addr)
+            self.assertIs(ss.context, ctx1)
+            self.assertIs(ss._sslobj.context, ctx1)
+            ss.context = ctx2
+            self.assertIs(ss.context, ctx2)
+            self.assertIs(ss._sslobj.context, ctx2)
+
+    def ssl_io_loop(self, sock, incoming, outgoing, func, *args, **kwargs):
+        # A simple IO loop. Call func(*args) depending on the error we get
+        # (WANT_READ or WANT_WRITE) move data between the socket and the BIOs.
+        timeout = kwargs.get('timeout', support.SHORT_TIMEOUT)
+        count = 0
+        for _ in support.busy_retry(timeout):
+            errno = None
+            count += 1
+            try:
+                ret = func(*args)
+            except ssl.SSLError as e:
+                if e.errno not in (ssl.SSL_ERROR_WANT_READ,
+                                   ssl.SSL_ERROR_WANT_WRITE):
+                    raise
+                errno = e.errno
+            # Get any data from the outgoing BIO irrespective of any error, and
+            # send it to the socket.
+            buf = outgoing.read()
+            sock.sendall(buf)
+            # If there's no error, we're done. For WANT_READ, we need to get
+            # data from the socket and put it in the incoming BIO.
+            if errno is None:
+                break
+            elif errno == ssl.SSL_ERROR_WANT_READ:
+                buf = sock.recv(32768)
+                if buf:
+                    incoming.write(buf)
+                else:
+                    incoming.write_eof()
+        if support.verbose:
+            sys.stdout.write("Needed %d calls to complete %s().\n"
+                             % (count, func.__name__))
+        return ret
+
+    def test_bio_handshake(self):
+        sock = socket.socket(socket.AF_INET)
+        self.addCleanup(sock.close)
+        sock.connect(self.server_addr)
+        incoming = ssl.MemoryBIO()
+        outgoing = ssl.MemoryBIO()
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertTrue(ctx.check_hostname)
+        self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+        ctx.load_verify_locations(SIGNING_CA)
+        sslobj = ctx.wrap_bio(incoming, outgoing, False,
+                              SIGNED_CERTFILE_HOSTNAME)
+        self.assertIs(sslobj._sslobj.owner, sslobj)
+        self.assertIsNone(sslobj.cipher())
+        self.assertIsNone(sslobj.version())
+        self.assertIsNone(sslobj.shared_ciphers())
+        self.assertRaises(ValueError, sslobj.getpeercert)
+        # tls-unique is not defined for TLSv1.3
+        # https://datatracker.ietf.org/doc/html/rfc8446#appendix-C.5
+        if 'tls-unique' in ssl.CHANNEL_BINDING_TYPES and sslobj.version() != "TLSv1.3":
+            self.assertIsNone(sslobj.get_channel_binding('tls-unique'))
+        self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
+        self.assertTrue(sslobj.cipher())
+        self.assertIsNone(sslobj.shared_ciphers())
+        self.assertIsNotNone(sslobj.version())
+        self.assertTrue(sslobj.getpeercert())
+        if 'tls-unique' in ssl.CHANNEL_BINDING_TYPES and sslobj.version() != "TLSv1.3":
+            self.assertTrue(sslobj.get_channel_binding('tls-unique'))
+        try:
+            self.ssl_io_loop(sock, incoming, outgoing, sslobj.unwrap)
+        except ssl.SSLSyscallError:
+            # If the server shuts down the TCP connection without sending a
+            # secure shutdown message, this is reported as SSL_ERROR_SYSCALL
+            pass
+        self.assertRaises(ssl.SSLError, sslobj.write, b'foo')
+
+    def test_bio_read_write_data(self):
+        sock = socket.socket(socket.AF_INET)
+        self.addCleanup(sock.close)
+        sock.connect(self.server_addr)
+        incoming = ssl.MemoryBIO()
+        outgoing = ssl.MemoryBIO()
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+        sslobj = ctx.wrap_bio(incoming, outgoing, False)
+        self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
+        req = b'FOO\n'
+        self.ssl_io_loop(sock, incoming, outgoing, sslobj.write, req)
+        buf = self.ssl_io_loop(sock, incoming, outgoing, sslobj.read, 1024)
+        self.assertEqual(buf, b'foo\n')
+        self.ssl_io_loop(sock, incoming, outgoing, sslobj.unwrap)
+
+    def test_transport_eof(self):
+        client_context, server_context, hostname = testing_context()
+        with socket.socket(socket.AF_INET) as sock:
+            sock.connect(self.server_addr)
+            incoming = ssl.MemoryBIO()
+            outgoing = ssl.MemoryBIO()
+            sslobj = client_context.wrap_bio(incoming, outgoing,
+                                             server_hostname=hostname)
+            self.ssl_io_loop(sock, incoming, outgoing, sslobj.do_handshake)
+
+            # Simulate EOF from the transport.
+            incoming.write_eof()
+            self.assertRaises(ssl.SSLEOFError, sslobj.read)
+
+
+@support.requires_resource('network')
+class NetworkedTests(unittest.TestCase):
+
+    def test_timeout_connect_ex(self):
+        # Issue #12065: on a timeout, connect_ex() should return the original
+        # errno (mimicking the behaviour of non-SSL sockets).
+        with socket_helper.transient_internet(REMOTE_HOST):
+            s = test_wrap_socket(socket.socket(socket.AF_INET),
+                                cert_reqs=ssl.CERT_REQUIRED,
+                                do_handshake_on_connect=False)
+            self.addCleanup(s.close)
+            s.settimeout(0.0000001)
+            rc = s.connect_ex((REMOTE_HOST, 443))
+            if rc == 0:
+                self.skipTest("REMOTE_HOST responded too quickly")
+            elif rc == errno.ENETUNREACH:
+                self.skipTest("Network unreachable.")
+            self.assertIn(rc, (errno.EAGAIN, errno.EWOULDBLOCK))
+
+    @unittest.skipUnless(socket_helper.IPV6_ENABLED, 'Needs IPv6')
+    @support.requires_resource('walltime')
+    def test_get_server_certificate_ipv6(self):
+        with socket_helper.transient_internet('ipv6.google.com'):
+            _test_get_server_certificate(self, 'ipv6.google.com', 443)
+            _test_get_server_certificate_fail(self, 'ipv6.google.com', 443)
+
+
+def _test_get_server_certificate(test, host, port, cert=None):
+    pem = ssl.get_server_certificate((host, port))
+    if not pem:
+        test.fail("No server certificate on %s:%s!" % (host, port))
+
+    pem = ssl.get_server_certificate((host, port), ca_certs=cert)
+    if not pem:
+        test.fail("No server certificate on %s:%s!" % (host, port))
+    if support.verbose:
+        sys.stdout.write("\nVerified certificate for %s:%s is\n%s\n" % (host, port ,pem))
+
+def _test_get_server_certificate_fail(test, host, port):
+    with warnings_helper.check_no_resource_warning(test):
+        try:
+            pem = ssl.get_server_certificate((host, port), ca_certs=CERTFILE)
+        except ssl.SSLError as x:
+            #should fail
+            if support.verbose:
+                sys.stdout.write("%s\n" % x)
+        else:
+            test.fail("Got server certificate %s for %s:%s!" % (pem, host, port))
+
+
+from test.ssl_servers import make_https_server
+
+class ThreadedEchoServer(threading.Thread):
+
+    class ConnectionHandler(threading.Thread):
+
+        """A mildly complicated class, because we want it to work both
+        with and without the SSL wrapper around the socket connection, so
+        that we can test the STARTTLS functionality."""
+
+        def __init__(self, server, connsock, addr):
+            self.server = server
+            self.running = False
+            self.sock = connsock
+            self.addr = addr
+            self.sock.setblocking(True)
+            self.sslconn = None
+            threading.Thread.__init__(self)
+            self.daemon = True
+
+        def wrap_conn(self):
+            try:
+                self.sslconn = self.server.context.wrap_socket(
+                    self.sock, server_side=True)
+                self.server.selected_alpn_protocols.append(self.sslconn.selected_alpn_protocol())
+            except (ConnectionResetError, BrokenPipeError, ConnectionAbortedError) as e:
+                # We treat ConnectionResetError as though it were an
+                # SSLError - OpenSSL on Ubuntu abruptly closes the
+                # connection when asked to use an unsupported protocol.
+                #
+                # BrokenPipeError is raised in TLS 1.3 mode, when OpenSSL
+                # tries to send session tickets after handshake.
+                # https://github.com/openssl/openssl/issues/6342
+                #
+                # ConnectionAbortedError is raised in TLS 1.3 mode, when OpenSSL
+                # tries to send session tickets after handshake when using WinSock.
+                self.server.conn_errors.append(str(e))
+                if self.server.chatty:
+                    handle_error("\n server:  bad connection attempt from " + repr(self.addr) + ":\n")
+                self.running = False
+                self.close()
+                return False
+            except (ssl.SSLError, OSError) as e:
+                # OSError may occur with wrong protocols, e.g. both
+                # sides use PROTOCOL_TLS_SERVER.
+                #
+                # XXX Various errors can have happened here, for example
+                # a mismatching protocol version, an invalid certificate,
+                # or a low-level bug. This should be made more discriminating.
+                #
+                # bpo-31323: Store the exception as string to prevent
+                # a reference leak: server -> conn_errors -> exception
+                # -> traceback -> self (ConnectionHandler) -> server
+                self.server.conn_errors.append(str(e))
+                if self.server.chatty:
+                    handle_error("\n server:  bad connection attempt from " + repr(self.addr) + ":\n")
+
+                # bpo-44229, bpo-43855, bpo-44237, and bpo-33450:
+                # Ignore spurious EPROTOTYPE returned by write() on macOS.
+                # See also http://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/
+                if e.errno != errno.EPROTOTYPE and sys.platform != "darwin":
+                    self.running = False
+                    self.close()
+                return False
+            else:
+                self.server.shared_ciphers.append(self.sslconn.shared_ciphers())
+                if self.server.context.verify_mode == ssl.CERT_REQUIRED:
+                    cert = self.sslconn.getpeercert()
+                    if support.verbose and self.server.chatty:
+                        sys.stdout.write(" client cert is " + pprint.pformat(cert) + "\n")
+                    cert_binary = self.sslconn.getpeercert(True)
+                    if support.verbose and self.server.chatty:
+                        if cert_binary is None:
+                            sys.stdout.write(" client did not provide a cert\n")
+                        else:
+                            sys.stdout.write(f" cert binary is {len(cert_binary)}b\n")
+                cipher = self.sslconn.cipher()
+                if support.verbose and self.server.chatty:
+                    sys.stdout.write(" server: connection cipher is now " + str(cipher) + "\n")
+                return True
+
+        def read(self):
+            if self.sslconn:
+                return self.sslconn.read()
+            else:
+                return self.sock.recv(1024)
+
+        def write(self, bytes):
+            if self.sslconn:
+                return self.sslconn.write(bytes)
+            else:
+                return self.sock.send(bytes)
+
+        def close(self):
+            if self.sslconn:
+                self.sslconn.close()
+            else:
+                self.sock.close()
+
+        def run(self):
+            self.running = True
+            if not self.server.starttls_server:
+                if not self.wrap_conn():
+                    return
+            while self.running:
+                try:
+                    msg = self.read()
+                    stripped = msg.strip()
+                    if not stripped:
+                        # eof, so quit this handler
+                        self.running = False
+                        try:
+                            self.sock = self.sslconn.unwrap()
+                        except OSError:
+                            # Many tests shut the TCP connection down
+                            # without an SSL shutdown. This causes
+                            # unwrap() to raise OSError with errno=0!
+                            pass
+                        else:
+                            self.sslconn = None
+                        self.close()
+                    elif stripped == b'over':
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: client closed connection\n")
+                        self.close()
+                        return
+                    elif (self.server.starttls_server and
+                          stripped == b'STARTTLS'):
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: read STARTTLS from client, sending OK...\n")
+                        self.write(b"OK\n")
+                        if not self.wrap_conn():
+                            return
+                    elif (self.server.starttls_server and self.sslconn
+                          and stripped == b'ENDTLS'):
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: read ENDTLS from client, sending OK...\n")
+                        self.write(b"OK\n")
+                        self.sock = self.sslconn.unwrap()
+                        self.sslconn = None
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: connection is now unencrypted...\n")
+                    elif stripped == b'CB tls-unique':
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: read CB tls-unique from client, sending our CB data...\n")
+                        data = self.sslconn.get_channel_binding("tls-unique")
+                        self.write(repr(data).encode("us-ascii") + b"\n")
+                    elif stripped == b'PHA':
+                        if support.verbose and self.server.connectionchatty:
+                            sys.stdout.write(" server: initiating post handshake auth\n")
+                        try:
+                            self.sslconn.verify_client_post_handshake()
+                        except ssl.SSLError as e:
+                            self.write(repr(e).encode("us-ascii") + b"\n")
+                        else:
+                            self.write(b"OK\n")
+                    elif stripped == b'HASCERT':
+                        if self.sslconn.getpeercert() is not None:
+                            self.write(b'TRUE\n')
+                        else:
+                            self.write(b'FALSE\n')
+                    elif stripped == b'GETCERT':
+                        cert = self.sslconn.getpeercert()
+                        self.write(repr(cert).encode("us-ascii") + b"\n")
+                    elif stripped == b'VERIFIEDCHAIN':
+                        certs = self.sslconn._sslobj.get_verified_chain()
+                        self.write(len(certs).to_bytes(1, "big") + b"\n")
+                    elif stripped == b'UNVERIFIEDCHAIN':
+                        certs = self.sslconn._sslobj.get_unverified_chain()
+                        self.write(len(certs).to_bytes(1, "big") + b"\n")
+                    else:
+                        if (support.verbose and
+                            self.server.connectionchatty):
+                            ctype = (self.sslconn and "encrypted") or "unencrypted"
+                            sys.stdout.write(" server: read %r (%s), sending back %r (%s)...\n"
+                                             % (msg, ctype, msg.lower(), ctype))
+                        self.write(msg.lower())
+                except OSError as e:
+                    # handles SSLError and socket errors
+                    if isinstance(e, ConnectionError):
+                        # OpenSSL 1.1.1 sometimes raises
+                        # ConnectionResetError when connection is not
+                        # shut down gracefully.
+                        if self.server.chatty and support.verbose:
+                            print(f" Connection reset by peer: {self.addr}")
+
+                        self.close()
+                        self.running = False
+                        return
+                    if self.server.chatty and support.verbose:
+                        handle_error("Test server failure:\n")
+                    try:
+                        self.write(b"ERROR\n")
+                    except OSError:
+                        pass
+                    self.close()
+                    self.running = False
+
+    def __init__(self, certificate=None, ssl_version=None,
+                 certreqs=None, cacerts=None,
+                 chatty=True, connectionchatty=False, starttls_server=False,
+                 alpn_protocols=None,
+                 ciphers=None, context=None):
+        if context:
+            self.context = context
+        else:
+            self.context = ssl.SSLContext(ssl_version
+                                          if ssl_version is not None
+                                          else ssl.PROTOCOL_TLS_SERVER)
+            self.context.verify_mode = (certreqs if certreqs is not None
+                                        else ssl.CERT_NONE)
+            if cacerts:
+                self.context.load_verify_locations(cacerts)
+            if certificate:
+                self.context.load_cert_chain(certificate)
+            if alpn_protocols:
+                self.context.set_alpn_protocols(alpn_protocols)
+            if ciphers:
+                self.context.set_ciphers(ciphers)
+        self.chatty = chatty
+        self.connectionchatty = connectionchatty
+        self.starttls_server = starttls_server
+        self.sock = socket.socket()
+        self.port = socket_helper.bind_port(self.sock)
+        self.flag = None
+        self.active = False
+        self.selected_alpn_protocols = []
+        self.shared_ciphers = []
+        self.conn_errors = []
+        threading.Thread.__init__(self)
+        self.daemon = True
+        self._in_context = False
+
+    def __enter__(self):
+        if self._in_context:
+            raise ValueError('Re-entering ThreadedEchoServer context')
+        self._in_context = True
+        self.start(threading.Event())
+        self.flag.wait()
+        return self
+
+    def __exit__(self, *args):
+        assert self._in_context
+        self._in_context = False
+        self.stop()
+        self.join()
+
+    def start(self, flag=None):
+        if not self._in_context:
+            raise ValueError(
+                'ThreadedEchoServer must be used as a context manager')
+        self.flag = flag
+        threading.Thread.start(self)
+
+    def run(self):
+        if not self._in_context:
+            raise ValueError(
+                'ThreadedEchoServer must be used as a context manager')
+        self.sock.settimeout(1.0)
+        self.sock.listen(5)
+        self.active = True
+        if self.flag:
+            # signal an event
+            self.flag.set()
+        while self.active:
+            try:
+                newconn, connaddr = self.sock.accept()
+                if support.verbose and self.chatty:
+                    sys.stdout.write(' server:  new connection from '
+                                     + repr(connaddr) + '\n')
+                handler = self.ConnectionHandler(self, newconn, connaddr)
+                handler.start()
+                handler.join()
+            except TimeoutError as e:
+                if support.verbose:
+                    sys.stdout.write(f' connection timeout {e!r}\n')
+            except KeyboardInterrupt:
+                self.stop()
+            except BaseException as e:
+                if support.verbose and self.chatty:
+                    sys.stdout.write(
+                        ' connection handling failed: ' + repr(e) + '\n')
+
+        self.close()
+
+    def close(self):
+        if self.sock is not None:
+            self.sock.close()
+            self.sock = None
+
+    def stop(self):
+        self.active = False
+
+class AsyncoreEchoServer(threading.Thread):
+
+    # this one's based on asyncore.dispatcher
+
+    class EchoServer (asyncore.dispatcher):
+
+        class ConnectionHandler(asyncore.dispatcher_with_send):
+
+            def __init__(self, conn, certfile):
+                self.socket = test_wrap_socket(conn, server_side=True,
+                                              certfile=certfile,
+                                              do_handshake_on_connect=False)
+                asyncore.dispatcher_with_send.__init__(self, self.socket)
+                self._ssl_accepting = True
+                self._do_ssl_handshake()
+
+            def readable(self):
+                if isinstance(self.socket, ssl.SSLSocket):
+                    while self.socket.pending() > 0:
+                        self.handle_read_event()
+                return True
+
+            def _do_ssl_handshake(self):
+                try:
+                    self.socket.do_handshake()
+                except (ssl.SSLWantReadError, ssl.SSLWantWriteError):
+                    return
+                except ssl.SSLEOFError:
+                    return self.handle_close()
+                except ssl.SSLError:
+                    raise
+                except OSError as err:
+                    if err.args[0] == errno.ECONNABORTED:
+                        return self.handle_close()
+                else:
+                    self._ssl_accepting = False
+
+            def handle_read(self):
+                if self._ssl_accepting:
+                    self._do_ssl_handshake()
+                else:
+                    data = self.recv(1024)
+                    if support.verbose:
+                        sys.stdout.write(" server:  read %s from client\n" % repr(data))
+                    if not data:
+                        self.close()
+                    else:
+                        self.send(data.lower())
+
+            def handle_close(self):
+                self.close()
+                if support.verbose:
+                    sys.stdout.write(" server:  closed connection %s\n" % self.socket)
+
+            def handle_error(self):
+                raise
+
+        def __init__(self, certfile):
+            self.certfile = certfile
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.port = socket_helper.bind_port(sock, '')
+            asyncore.dispatcher.__init__(self, sock)
+            self.listen(5)
+
+        def handle_accepted(self, sock_obj, addr):
+            if support.verbose:
+                sys.stdout.write(" server:  new connection from %s:%s\n" %addr)
+            self.ConnectionHandler(sock_obj, self.certfile)
+
+        def handle_error(self):
+            raise
+
+    def __init__(self, certfile):
+        self.flag = None
+        self.active = False
+        self.server = self.EchoServer(certfile)
+        self.port = self.server.port
+        threading.Thread.__init__(self)
+        self.daemon = True
+
+    def __str__(self):
+        return "<%s %s>" % (self.__class__.__name__, self.server)
+
+    def __enter__(self):
+        self.start(threading.Event())
+        self.flag.wait()
+        return self
+
+    def __exit__(self, *args):
+        if support.verbose:
+            sys.stdout.write(" cleanup: stopping server.\n")
+        self.stop()
+        if support.verbose:
+            sys.stdout.write(" cleanup: joining server thread.\n")
+        self.join()
+        if support.verbose:
+            sys.stdout.write(" cleanup: successfully joined.\n")
+        # make sure that ConnectionHandler is removed from socket_map
+        asyncore.close_all(ignore_all=True)
+
+    def start (self, flag=None):
+        self.flag = flag
+        threading.Thread.start(self)
+
+    def run(self):
+        self.active = True
+        if self.flag:
+            self.flag.set()
+        while self.active:
+            try:
+                asyncore.loop(1)
+            except:
+                pass
+
+    def stop(self):
+        self.active = False
+        self.server.close()
+
+def server_params_test(client_context, server_context, indata=b"FOO\n",
+                       chatty=True, connectionchatty=False, sni_name=None,
+                       session=None):
+    """
+    Launch a server, connect a client to it and try various reads
+    and writes.
+    """
+    stats = {}
+    server = ThreadedEchoServer(context=server_context,
+                                chatty=chatty,
+                                connectionchatty=False)
+    with server:
+        with client_context.wrap_socket(socket.socket(),
+                server_hostname=sni_name, session=session) as s:
+            s.connect((HOST, server.port))
+            for arg in [indata, bytearray(indata), memoryview(indata)]:
+                if connectionchatty:
+                    if support.verbose:
+                        sys.stdout.write(
+                            " client:  sending %r...\n" % indata)
+                s.write(arg)
+                outdata = s.read()
+                if connectionchatty:
+                    if support.verbose:
+                        sys.stdout.write(" client:  read %r\n" % outdata)
+                if outdata != indata.lower():
+                    raise AssertionError(
+                        "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
+                        % (outdata[:20], len(outdata),
+                           indata[:20].lower(), len(indata)))
+            s.write(b"over\n")
+            if connectionchatty:
+                if support.verbose:
+                    sys.stdout.write(" client:  closing connection.\n")
+            stats.update({
+                'compression': s.compression(),
+                'cipher': s.cipher(),
+                'peercert': s.getpeercert(),
+                'client_alpn_protocol': s.selected_alpn_protocol(),
+                'version': s.version(),
+                'session_reused': s.session_reused,
+                'session': s.session,
+            })
+            s.close()
+        stats['server_alpn_protocols'] = server.selected_alpn_protocols
+        stats['server_shared_ciphers'] = server.shared_ciphers
+    return stats
+
+def try_protocol_combo(server_protocol, client_protocol, expect_success,
+                       certsreqs=None, server_options=0, client_options=0):
+    """
+    Try to SSL-connect using *client_protocol* to *server_protocol*.
+    If *expect_success* is true, assert that the connection succeeds,
+    if it's false, assert that the connection fails.
+    Also, if *expect_success* is a string, assert that it is the protocol
+    version actually used by the connection.
+    """
+    if certsreqs is None:
+        certsreqs = ssl.CERT_NONE
+    certtype = {
+        ssl.CERT_NONE: "CERT_NONE",
+        ssl.CERT_OPTIONAL: "CERT_OPTIONAL",
+        ssl.CERT_REQUIRED: "CERT_REQUIRED",
+    }[certsreqs]
+    if support.verbose:
+        formatstr = (expect_success and " %s->%s %s\n") or " {%s->%s} %s\n"
+        sys.stdout.write(formatstr %
+                         (ssl.get_protocol_name(client_protocol),
+                          ssl.get_protocol_name(server_protocol),
+                          certtype))
+
+    with warnings_helper.check_warnings():
+        # ignore Deprecation warnings
+        client_context = ssl.SSLContext(client_protocol)
+        client_context.options |= client_options
+        server_context = ssl.SSLContext(server_protocol)
+        server_context.options |= server_options
+
+    min_version = PROTOCOL_TO_TLS_VERSION.get(client_protocol, None)
+    if (min_version is not None
+        # SSLContext.minimum_version is only available on recent OpenSSL
+        # (setter added in OpenSSL 1.1.0, getter added in OpenSSL 1.1.1)
+        and hasattr(server_context, 'minimum_version')
+        and server_protocol == ssl.PROTOCOL_TLS
+        and server_context.minimum_version > min_version
+    ):
+        # If OpenSSL configuration is strict and requires more recent TLS
+        # version, we have to change the minimum to test old TLS versions.
+        with warnings_helper.check_warnings():
+            server_context.minimum_version = min_version
+
+    # NOTE: we must enable "ALL" ciphers on the client, otherwise an
+    # SSLv23 client will send an SSLv3 hello (rather than SSLv2)
+    # starting from OpenSSL 1.0.0 (see issue #8322).
+    if client_context.protocol == ssl.PROTOCOL_TLS:
+        client_context.set_ciphers("ALL")
+
+    seclevel_workaround(server_context, client_context)
+
+    for ctx in (client_context, server_context):
+        ctx.verify_mode = certsreqs
+        ctx.load_cert_chain(SIGNED_CERTFILE)
+        ctx.load_verify_locations(SIGNING_CA)
+    try:
+        stats = server_params_test(client_context, server_context,
+                                   chatty=False, connectionchatty=False)
+    # Protocol mismatch can result in either an SSLError, or a
+    # "Connection reset by peer" error.
+    except ssl.SSLError:
+        if expect_success:
+            raise
+    except OSError as e:
+        if expect_success or e.errno != errno.ECONNRESET:
+            raise
+    else:
+        if not expect_success:
+            raise AssertionError(
+                "Client protocol %s succeeded with server protocol %s!"
+                % (ssl.get_protocol_name(client_protocol),
+                   ssl.get_protocol_name(server_protocol)))
+        elif (expect_success is not True
+              and expect_success != stats['version']):
+            raise AssertionError("version mismatch: expected %r, got %r"
+                                 % (expect_success, stats['version']))
+
+
+def supports_kx_alias(ctx, aliases):
+    for cipher in ctx.get_ciphers():
+        for alias in aliases:
+            if f"Kx={alias}" in cipher['description']:
+                return True
+    return False
+
+
+class ThreadedTests(unittest.TestCase):
+
+    @support.requires_resource('walltime')
+    def test_echo(self):
+        """Basic test of an SSL client connecting to a server"""
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+
+        with self.subTest(client=ssl.PROTOCOL_TLS_CLIENT, server=ssl.PROTOCOL_TLS_SERVER):
+            server_params_test(client_context=client_context,
+                               server_context=server_context,
+                               chatty=True, connectionchatty=True,
+                               sni_name=hostname)
+
+        client_context.check_hostname = False
+        with self.subTest(client=ssl.PROTOCOL_TLS_SERVER, server=ssl.PROTOCOL_TLS_CLIENT):
+            with self.assertRaises(ssl.SSLError) as e:
+                server_params_test(client_context=server_context,
+                                   server_context=client_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+            self.assertIn(
+                'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
+                str(e.exception)
+            )
+
+        with self.subTest(client=ssl.PROTOCOL_TLS_SERVER, server=ssl.PROTOCOL_TLS_SERVER):
+            with self.assertRaises(ssl.SSLError) as e:
+                server_params_test(client_context=server_context,
+                                   server_context=server_context,
+                                   chatty=True, connectionchatty=True)
+            self.assertIn(
+                'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
+                str(e.exception)
+            )
+
+        with self.subTest(client=ssl.PROTOCOL_TLS_CLIENT, server=ssl.PROTOCOL_TLS_CLIENT):
+            with self.assertRaises(ssl.SSLError) as e:
+                server_params_test(client_context=server_context,
+                                   server_context=client_context,
+                                   chatty=True, connectionchatty=True)
+            self.assertIn(
+                'Cannot create a client socket with a PROTOCOL_TLS_SERVER context',
+                str(e.exception))
+
+    @unittest.skip('TODO: RUSTPYTHON flaky')
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "test is only useful if the GIL is disabled")
+    def test_ssl_in_multiple_threads(self):
+        # See GH-124984: OpenSSL is not thread safe.
+        threads = []
+
+        global USE_SAME_TEST_CONTEXT
+        USE_SAME_TEST_CONTEXT = True
+        try:
+            for func in (
+                self.test_echo,
+                self.test_alpn_protocols,
+                self.test_getpeercert,
+                self.test_crl_check,
+                functools.partial(
+                    self.test_check_hostname_idn,
+                    warnings_filters=False,  # gh-126483
+                ),
+                self.test_wrong_cert_tls12,
+                self.test_wrong_cert_tls13,
+            ):
+                # Be careful with the number of threads here.
+                # Too many can result in failing tests.
+                for num in range(5):
+                    with self.subTest(func=func, num=num):
+                        threads.append(Thread(target=func))
+
+            with threading_helper.catch_threading_exception() as cm:
+                for thread in threads:
+                    with self.subTest(thread=thread):
+                        thread.start()
+
+                for thread in threads:
+                    with self.subTest(thread=thread):
+                        thread.join()
+                if cm.exc_value is not None:
+                    # Some threads can skip their test
+                    if not isinstance(cm.exc_value, unittest.SkipTest):
+                        raise cm.exc_value
+        finally:
+            USE_SAME_TEST_CONTEXT = False
+
+    def test_getpeercert(self):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            do_handshake_on_connect=False,
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                # getpeercert() raise ValueError while the handshake isn't
+                # done.
+                with self.assertRaises(ValueError):
+                    s.getpeercert()
+                s.do_handshake()
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+                cipher = s.cipher()
+                if support.verbose:
+                    sys.stdout.write(pprint.pformat(cert) + '\n')
+                    sys.stdout.write("Connection cipher is " + str(cipher) + '.\n')
+                if 'subject' not in cert:
+                    self.fail("No subject field in certificate: %s." %
+                              pprint.pformat(cert))
+                if ((('organizationName', 'Python Software Foundation'),)
+                    not in cert['subject']):
+                    self.fail(
+                        "Missing or invalid 'organizationName' field in certificate subject; "
+                        "should be 'Python Software Foundation'.")
+                self.assertIn('notBefore', cert)
+                self.assertIn('notAfter', cert)
+                before = ssl.cert_time_to_seconds(cert['notBefore'])
+                after = ssl.cert_time_to_seconds(cert['notAfter'])
+                self.assertLess(before, after)
+
+    def test_crl_check(self):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+
+        tf = getattr(ssl, "VERIFY_X509_TRUSTED_FIRST", 0)
+        self.assertEqual(client_context.verify_flags, ssl.VERIFY_DEFAULT | tf)
+
+        # VERIFY_DEFAULT should pass
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+
+        # VERIFY_CRL_CHECK_LEAF without a loaded CRL file fails
+        client_context.verify_flags |= ssl.VERIFY_CRL_CHECK_LEAF
+
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            certificate verify failed   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED   # AWS-LC
+        )""", re.X)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                with self.assertRaisesRegex(ssl.SSLError, regex):
+                    s.connect((HOST, server.port))
+
+        # now load a CRL file. The CRL file is signed by the CA.
+        client_context.load_verify_locations(CRLFILE)
+
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+
+    def test_check_hostname(self):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+
+        # correct hostname should verify
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+
+        # incorrect hostname should raise an exception
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        # Allow for flexible libssl error messages.
+        regex = re.compile(r"""(
+            certificate verify failed   # OpenSSL
+            |
+            CERTIFICATE_VERIFY_FAILED   # AWS-LC
+        )""", re.X)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname="invalid") as s:
+                with self.assertRaisesRegex(ssl.CertificateError, regex):
+                    s.connect((HOST, server.port))
+
+        # missing server_hostname arg should cause an exception, too
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with socket.socket() as s:
+                with self.assertRaisesRegex(ValueError,
+                                            "check_hostname requires server_hostname"):
+                    client_context.wrap_socket(s)
+
+    @unittest.skipUnless(
+        ssl.HAS_NEVER_CHECK_COMMON_NAME, "test requires hostname_checks_common_name"
+    )
+    def test_hostname_checks_common_name(self):
+        client_context, server_context, hostname = testing_context()
+        assert client_context.hostname_checks_common_name
+        client_context.hostname_checks_common_name = False
+
+        # default cert has a SAN
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+
+        client_context, server_context, hostname = testing_context(NOSANFILE)
+        client_context.hostname_checks_common_name = False
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                with self.assertRaises(ssl.SSLCertVerificationError):
+                    s.connect((HOST, server.port))
+
+    def test_ecc_cert(self):
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.load_verify_locations(SIGNING_CA)
+        client_context.set_ciphers('ECDHE:ECDSA:!NULL:!aRSA')
+        hostname = SIGNED_CERTFILE_ECC_HOSTNAME
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # load ECC cert
+        server_context.load_cert_chain(SIGNED_CERTFILE_ECC)
+
+        # correct hostname should verify
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+                cipher = s.cipher()[0].split('-')
+                self.assertTrue(cipher[:2], ('ECDHE', 'ECDSA'))
+
+    @unittest.skipUnless(IS_OPENSSL_3_0_0,
+                         "test requires RFC 5280 check added in OpenSSL 3.0+")
+    def test_verify_strict(self):
+        # verification fails by default, since the server cert is non-conforming
+        client_context = ssl.create_default_context()
+        client_context.load_verify_locations(LEAF_MISSING_AKI_CA)
+        hostname = LEAF_MISSING_AKI_CERTFILE_HOSTNAME
+
+        server_context = ssl.create_default_context(purpose=Purpose.CLIENT_AUTH)
+        server_context.load_cert_chain(LEAF_MISSING_AKI_CERTFILE)
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                with self.assertRaises(ssl.SSLError):
+                    s.connect((HOST, server.port))
+
+        # explicitly disabling VERIFY_X509_STRICT allows it to succeed
+        client_context = ssl.create_default_context()
+        client_context.load_verify_locations(LEAF_MISSING_AKI_CA)
+        client_context.verify_flags &= ~ssl.VERIFY_X509_STRICT
+
+        server_context = ssl.create_default_context(purpose=Purpose.CLIENT_AUTH)
+        server_context.load_cert_chain(LEAF_MISSING_AKI_CERTFILE)
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+
+    def test_dual_rsa_ecc(self):
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.load_verify_locations(SIGNING_CA)
+        # TODO: fix TLSv1.3 once SSLContext can restrict signature
+        #       algorithms.
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        # only ECDSA certs
+        client_context.set_ciphers('ECDHE:ECDSA:!NULL:!aRSA')
+        hostname = SIGNED_CERTFILE_ECC_HOSTNAME
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        # load ECC and RSA key/cert pairs
+        server_context.load_cert_chain(SIGNED_CERTFILE_ECC)
+        server_context.load_cert_chain(SIGNED_CERTFILE)
+
+        # correct hostname should verify
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                cert = s.getpeercert()
+                self.assertTrue(cert, "Can't get peer certificate.")
+                cipher = s.cipher()[0].split('-')
+                self.assertTrue(cipher[:2], ('ECDHE', 'ECDSA'))
+
+    def test_check_hostname_idn(self, warnings_filters=True):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.load_cert_chain(IDNSANSFILE)
+
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        context.verify_mode = ssl.CERT_REQUIRED
+        context.check_hostname = True
+        context.load_verify_locations(SIGNING_CA)
+
+        # correct hostname should verify, when specified in several
+        # different ways
+        idn_hostnames = [
+            ('könig.idn.pythontest.net',
+             'xn--knig-5qa.idn.pythontest.net'),
+            ('xn--knig-5qa.idn.pythontest.net',
+             'xn--knig-5qa.idn.pythontest.net'),
+            (b'xn--knig-5qa.idn.pythontest.net',
+             'xn--knig-5qa.idn.pythontest.net'),
+
+            ('königsgäßchen.idna2003.pythontest.net',
+             'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
+            ('xn--knigsgsschen-lcb0w.idna2003.pythontest.net',
+             'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
+            (b'xn--knigsgsschen-lcb0w.idna2003.pythontest.net',
+             'xn--knigsgsschen-lcb0w.idna2003.pythontest.net'),
+
+            # ('königsgäßchen.idna2008.pythontest.net',
+            #  'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
+            ('xn--knigsgchen-b4a3dun.idna2008.pythontest.net',
+             'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
+            (b'xn--knigsgchen-b4a3dun.idna2008.pythontest.net',
+             'xn--knigsgchen-b4a3dun.idna2008.pythontest.net'),
+
+        ]
+        for server_hostname, expected_hostname in idn_hostnames:
+            server = ThreadedEchoServer(context=server_context, chatty=True)
+            with server:
+                with context.wrap_socket(socket.socket(),
+                                         server_hostname=server_hostname) as s:
+                    self.assertEqual(s.server_hostname, expected_hostname)
+                    s.connect((HOST, server.port))
+                    cert = s.getpeercert()
+                    self.assertEqual(s.server_hostname, expected_hostname)
+                    self.assertTrue(cert, "Can't get peer certificate.")
+
+        # incorrect hostname should raise an exception
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with context.wrap_socket(socket.socket(),
+                                     server_hostname="python.example.org") as s:
+                with self.assertRaises(ssl.CertificateError):
+                    s.connect((HOST, server.port))
+        with (
+            ThreadedEchoServer(context=server_context, chatty=True) as server,
+            (
+                warnings_helper.check_no_resource_warning(self)
+                if warnings_filters
+                else nullcontext()
+            ),
+            self.assertRaises(UnicodeError),
+        ):
+            context.wrap_socket(socket.socket(), server_hostname='.pythontest.net')
+
+        with (
+            ThreadedEchoServer(context=server_context, chatty=True) as server,
+            (
+                warnings_helper.check_no_resource_warning(self)
+                if warnings_filters
+                else nullcontext()
+            ),
+            self.assertRaises(UnicodeDecodeError),
+        ):
+            context.wrap_socket(
+                socket.socket(),
+                server_hostname=b'k\xf6nig.idn.pythontest.net',
+            )
+
+    def test_wrong_cert_tls12(self):
+        """Connecting when the server rejects the client's certificate
+
+        Launch a server with CERT_REQUIRED, and check that trying to
+        connect to it with a wrong client certificate fails.
+        """
+        client_context, server_context, hostname = testing_context()
+        # load client cert that is not signed by trusted CA
+        client_context.load_cert_chain(CERTFILE)
+        # require TLS client authentication
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        # TLS 1.3 has different handshake
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        server = ThreadedEchoServer(
+            context=server_context, chatty=True, connectionchatty=True,
+        )
+
+        with server, \
+                client_context.wrap_socket(socket.socket(),
+                                           server_hostname=hostname) as s:
+            try:
+                # Expect either an SSL error about the server rejecting
+                # the connection, or a low-level connection reset (which
+                # sometimes happens on Windows)
+                s.connect((HOST, server.port))
+            except ssl.SSLError as e:
+                if support.verbose:
+                    sys.stdout.write("\nSSLError is %r\n" % e)
+            except OSError as e:
+                if e.errno != errno.ECONNRESET:
+                    raise
+                if support.verbose:
+                    sys.stdout.write("\nsocket.error is %r\n" % e)
+            else:
+                self.fail("Use of invalid cert should have failed!")
+
+    @requires_tls_version('TLSv1_3')
+    def test_wrong_cert_tls13(self):
+        client_context, server_context, hostname = testing_context()
+        # load client cert that is not signed by trusted CA
+        client_context.load_cert_chain(CERTFILE)
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_3
+        client_context.minimum_version = ssl.TLSVersion.TLSv1_3
+
+        server = ThreadedEchoServer(
+            context=server_context, chatty=True, connectionchatty=True,
+        )
+        with server, \
+             client_context.wrap_socket(socket.socket(),
+                                        server_hostname=hostname,
+                                        suppress_ragged_eofs=False) as s:
+            s.connect((HOST, server.port))
+            with self.assertRaisesRegex(
+                OSError,
+                'alert unknown ca|EOF occurred|TLSV1_ALERT_UNKNOWN_CA|'
+                'closed by the remote host|Connection reset by peer|'
+                'Broken pipe'
+            ):
+                # TLS 1.3 perform client cert exchange after handshake
+                s.write(b'data')
+                s.read(1000)
+                s.write(b'should have failed already')
+                s.read(1000)
+
+    def test_rude_shutdown(self):
+        """A brutal shutdown of an SSL server should raise an OSError
+        in the client when attempting handshake.
+        """
+        listener_ready = threading.Event()
+        listener_gone = threading.Event()
+
+        s = socket.socket()
+        port = socket_helper.bind_port(s, HOST)
+
+        # `listener` runs in a thread.  It sits in an accept() until
+        # the main thread connects.  Then it rudely closes the socket,
+        # and sets Event `listener_gone` to let the main thread know
+        # the socket is gone.
+        def listener():
+            s.listen()
+            listener_ready.set()
+            newsock, addr = s.accept()
+            newsock.close()
+            s.close()
+            listener_gone.set()
+
+        def connector():
+            listener_ready.wait()
+            with socket.socket() as c:
+                c.connect((HOST, port))
+                listener_gone.wait()
+                try:
+                    ssl_sock = test_wrap_socket(c)
+                except OSError:
+                    pass
+                else:
+                    self.fail('connecting to closed SSL socket should have failed')
+
+        t = threading.Thread(target=listener)
+        t.start()
+        try:
+            connector()
+        finally:
+            t.join()
+
+    def test_ssl_cert_verify_error(self):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.load_cert_chain(SIGNED_CERTFILE)
+
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with context.wrap_socket(socket.socket(),
+                                     server_hostname=SIGNED_CERTFILE_HOSTNAME) as s:
+                try:
+                    s.connect((HOST, server.port))
+                    self.fail("Expected connection failure")
+                except ssl.SSLError as e:
+                    msg = 'unable to get local issuer certificate'
+                    self.assertIsInstance(e, ssl.SSLCertVerificationError)
+                    self.assertEqual(e.verify_code, 20)
+                    self.assertEqual(e.verify_message, msg)
+                    # Allow for flexible libssl error messages.
+                    regex = f"({msg}|CERTIFICATE_VERIFY_FAILED)"
+                    self.assertRegex(repr(e), regex)
+                    regex = re.compile(r"""(
+                        certificate verify failed   # OpenSSL
+                        |
+                        CERTIFICATE_VERIFY_FAILED   # AWS-LC
+                    )""", re.X)
+                    self.assertRegex(repr(e), regex)
+
+    def test_PROTOCOL_TLS(self):
+        """Connecting to an SSLv23 server with various client options"""
+        if support.verbose:
+            sys.stdout.write("\n")
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False)
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True)
+        if has_tls_version('TLSv1'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1')
+
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False, ssl.CERT_OPTIONAL)
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True, ssl.CERT_OPTIONAL)
+        if has_tls_version('TLSv1'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_OPTIONAL)
+
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False, ssl.CERT_REQUIRED)
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True, ssl.CERT_REQUIRED)
+        if has_tls_version('TLSv1'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_REQUIRED)
+
+        # Server with specific SSL options
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_SSLv3, False,
+                           server_options=ssl.OP_NO_SSLv3)
+        # Will choose TLSv1
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLS, True,
+                           server_options=ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3)
+        if has_tls_version('TLSv1'):
+            try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1, False,
+                               server_options=ssl.OP_NO_TLSv1)
+
+    @requires_tls_version('SSLv3')
+    def test_protocol_sslv3(self):
+        """Connecting to an SSLv3 server with various client options"""
+        if support.verbose:
+            sys.stdout.write("\n")
+        try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3')
+        try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3', ssl.CERT_OPTIONAL)
+        try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_SSLv3, 'SSLv3', ssl.CERT_REQUIRED)
+        try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_TLS, False,
+                           client_options=ssl.OP_NO_SSLv3)
+        try_protocol_combo(ssl.PROTOCOL_SSLv3, ssl.PROTOCOL_TLSv1, False)
+
+    @requires_tls_version('TLSv1')
+    def test_protocol_tlsv1(self):
+        """Connecting to a TLSv1 server with various client options"""
+        if support.verbose:
+            sys.stdout.write("\n")
+        try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1')
+        try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_OPTIONAL)
+        try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1, 'TLSv1', ssl.CERT_REQUIRED)
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_SSLv3, False)
+        try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLS, False,
+                           client_options=ssl.OP_NO_TLSv1)
+
+    @requires_tls_version('TLSv1_1')
+    def test_protocol_tlsv1_1(self):
+        """Connecting to a TLSv1.1 server with various client options.
+           Testing against older TLS versions."""
+        if support.verbose:
+            sys.stdout.write("\n")
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_1, 'TLSv1.1')
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_SSLv3, False)
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLS, False,
+                           client_options=ssl.OP_NO_TLSv1_1)
+
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1_1, 'TLSv1.1')
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_2, False)
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_1, False)
+
+    @requires_tls_version('TLSv1_2')
+    def test_protocol_tlsv1_2(self):
+        """Connecting to a TLSv1.2 server with various client options.
+           Testing against older TLS versions."""
+        if support.verbose:
+            sys.stdout.write("\n")
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_2, 'TLSv1.2',
+                           server_options=ssl.OP_NO_SSLv3|ssl.OP_NO_SSLv2,
+                           client_options=ssl.OP_NO_SSLv3|ssl.OP_NO_SSLv2,)
+        if has_tls_version('SSLv3'):
+            try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_SSLv3, False)
+        try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLS, False,
+                           client_options=ssl.OP_NO_TLSv1_2)
+
+        try_protocol_combo(ssl.PROTOCOL_TLS, ssl.PROTOCOL_TLSv1_2, 'TLSv1.2')
+        if has_tls_protocol(ssl.PROTOCOL_TLSv1):
+            try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1, False)
+            try_protocol_combo(ssl.PROTOCOL_TLSv1, ssl.PROTOCOL_TLSv1_2, False)
+        if has_tls_protocol(ssl.PROTOCOL_TLSv1_1):
+            try_protocol_combo(ssl.PROTOCOL_TLSv1_2, ssl.PROTOCOL_TLSv1_1, False)
+            try_protocol_combo(ssl.PROTOCOL_TLSv1_1, ssl.PROTOCOL_TLSv1_2, False)
+
+    def test_starttls(self):
+        """Switching from clear text to encrypted and back again."""
+        msgs = (b"msg 1", b"MSG 2", b"STARTTLS", b"MSG 3", b"msg 4", b"ENDTLS", b"msg 5", b"msg 6")
+
+        server = ThreadedEchoServer(CERTFILE,
+                                    starttls_server=True,
+                                    chatty=True,
+                                    connectionchatty=True)
+        wrapped = False
+        with server:
+            s = socket.socket()
+            s.setblocking(True)
+            s.connect((HOST, server.port))
+            if support.verbose:
+                sys.stdout.write("\n")
+            for indata in msgs:
+                if support.verbose:
+                    sys.stdout.write(
+                        " client:  sending %r...\n" % indata)
+                if wrapped:
+                    conn.write(indata)
+                    outdata = conn.read()
+                else:
+                    s.send(indata)
+                    outdata = s.recv(1024)
+                msg = outdata.strip().lower()
+                if indata == b"STARTTLS" and msg.startswith(b"ok"):
+                    # STARTTLS ok, switch to secure mode
+                    if support.verbose:
+                        sys.stdout.write(
+                            " client:  read %r from server, starting TLS...\n"
+                            % msg)
+                    conn = test_wrap_socket(s)
+                    wrapped = True
+                elif indata == b"ENDTLS" and msg.startswith(b"ok"):
+                    # ENDTLS ok, switch back to clear text
+                    if support.verbose:
+                        sys.stdout.write(
+                            " client:  read %r from server, ending TLS...\n"
+                            % msg)
+                    s = conn.unwrap()
+                    wrapped = False
+                else:
+                    if support.verbose:
+                        sys.stdout.write(
+                            " client:  read %r from server\n" % msg)
+            if support.verbose:
+                sys.stdout.write(" client:  closing connection.\n")
+            if wrapped:
+                conn.write(b"over\n")
+            else:
+                s.send(b"over\n")
+            if wrapped:
+                conn.close()
+            else:
+                s.close()
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_socketserver(self):
+        """Using socketserver to create and manage SSL connections."""
+        server = make_https_server(self, certfile=SIGNED_CERTFILE)
+        # try to connect
+        if support.verbose:
+            sys.stdout.write('\n')
+        # Get this test file itself:
+        with open(__file__, 'rb') as f:
+            d1 = f.read()
+        d2 = ''
+        # now fetch the same data from the HTTPS server
+        url = f'https://localhost:{server.port}/test_ssl.py'
+        context = ssl.create_default_context(cafile=SIGNING_CA)
+        f = urllib.request.urlopen(url, context=context)
+        try:
+            dlen = f.info().get("content-length")
+            if dlen and (int(dlen) > 0):
+                d2 = f.read(int(dlen))
+                if support.verbose:
+                    sys.stdout.write(
+                        " client: read %d bytes from remote server '%s'\n"
+                        % (len(d2), server))
+        finally:
+            f.close()
+        self.assertEqual(d1, d2)
+
+    def test_asyncore_server(self):
+        """Check the example asyncore integration."""
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        indata = b"FOO\n"
+        server = AsyncoreEchoServer(CERTFILE)
+        with server:
+            s = test_wrap_socket(socket.socket())
+            s.connect(('127.0.0.1', server.port))
+            if support.verbose:
+                sys.stdout.write(
+                    " client:  sending %r...\n" % indata)
+            s.write(indata)
+            outdata = s.read()
+            if support.verbose:
+                sys.stdout.write(" client:  read %r\n" % outdata)
+            if outdata != indata.lower():
+                self.fail(
+                    "bad data <<%r>> (%d) received; expected <<%r>> (%d)\n"
+                    % (outdata[:20], len(outdata),
+                       indata[:20].lower(), len(indata)))
+            s.write(b"over\n")
+            if support.verbose:
+                sys.stdout.write(" client:  closing connection.\n")
+            s.close()
+            if support.verbose:
+                sys.stdout.write(" client:  connection closed.\n")
+
+    def test_recv_send(self):
+        """Test recv(), send() and friends."""
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        server = ThreadedEchoServer(CERTFILE,
+                                    certreqs=ssl.CERT_NONE,
+                                    ssl_version=ssl.PROTOCOL_TLS_SERVER,
+                                    cacerts=CERTFILE,
+                                    chatty=True,
+                                    connectionchatty=False)
+        with server:
+            s = test_wrap_socket(socket.socket(),
+                                server_side=False,
+                                certfile=CERTFILE,
+                                ca_certs=CERTFILE,
+                                cert_reqs=ssl.CERT_NONE)
+            s.connect((HOST, server.port))
+            # helper methods for standardising recv* method signatures
+            def _recv_into():
+                b = bytearray(b"\0"*100)
+                count = s.recv_into(b)
+                return b[:count]
+
+            def _recvfrom_into():
+                b = bytearray(b"\0"*100)
+                count, addr = s.recvfrom_into(b)
+                return b[:count]
+
+            # (name, method, expect success?, *args, return value func)
+            send_methods = [
+                ('send', s.send, True, [], len),
+                ('sendto', s.sendto, False, ["some.address"], len),
+                ('sendall', s.sendall, True, [], lambda x: None),
+            ]
+            # (name, method, whether to expect success, *args)
+            recv_methods = [
+                ('recv', s.recv, True, []),
+                ('recvfrom', s.recvfrom, False, ["some.address"]),
+                ('recv_into', _recv_into, True, []),
+                ('recvfrom_into', _recvfrom_into, False, []),
+            ]
+            data_prefix = "PREFIX_"
+
+            for (meth_name, send_meth, expect_success, args,
+                    ret_val_meth) in send_methods:
+                indata = (data_prefix + meth_name).encode('ascii')
+                try:
+                    ret = send_meth(indata, *args)
+                    msg = "sending with {}".format(meth_name)
+                    self.assertEqual(ret, ret_val_meth(indata), msg=msg)
+                    outdata = s.read()
+                    if outdata != indata.lower():
+                        self.fail(
+                            "While sending with <<{name:s}>> bad data "
+                            "<<{outdata:r}>> ({nout:d}) received; "
+                            "expected <<{indata:r}>> ({nin:d})\n".format(
+                                name=meth_name, outdata=outdata[:20],
+                                nout=len(outdata),
+                                indata=indata[:20], nin=len(indata)
+                            )
+                        )
+                except ValueError as e:
+                    if expect_success:
+                        self.fail(
+                            "Failed to send with method <<{name:s}>>; "
+                            "expected to succeed.\n".format(name=meth_name)
+                        )
+                    if not str(e).startswith(meth_name):
+                        self.fail(
+                            "Method <<{name:s}>> failed with unexpected "
+                            "exception message: {exp:s}\n".format(
+                                name=meth_name, exp=e
+                            )
+                        )
+
+            for meth_name, recv_meth, expect_success, args in recv_methods:
+                indata = (data_prefix + meth_name).encode('ascii')
+                try:
+                    s.send(indata)
+                    outdata = recv_meth(*args)
+                    if outdata != indata.lower():
+                        self.fail(
+                            "While receiving with <<{name:s}>> bad data "
+                            "<<{outdata:r}>> ({nout:d}) received; "
+                            "expected <<{indata:r}>> ({nin:d})\n".format(
+                                name=meth_name, outdata=outdata[:20],
+                                nout=len(outdata),
+                                indata=indata[:20], nin=len(indata)
+                            )
+                        )
+                except ValueError as e:
+                    if expect_success:
+                        self.fail(
+                            "Failed to receive with method <<{name:s}>>; "
+                            "expected to succeed.\n".format(name=meth_name)
+                        )
+                    if not str(e).startswith(meth_name):
+                        self.fail(
+                            "Method <<{name:s}>> failed with unexpected "
+                            "exception message: {exp:s}\n".format(
+                                name=meth_name, exp=e
+                            )
+                        )
+                    # consume data
+                    s.read()
+
+            # read(-1, buffer) is supported, even though read(-1) is not
+            data = b"data"
+            s.send(data)
+            buffer = bytearray(len(data))
+            self.assertEqual(s.read(-1, buffer), len(data))
+            self.assertEqual(buffer, data)
+
+            # sendall accepts bytes-like objects
+            if ctypes is not None:
+                ubyte = ctypes.c_ubyte * len(data)
+                byteslike = ubyte.from_buffer_copy(data)
+                s.sendall(byteslike)
+                self.assertEqual(s.read(), data)
+
+            # Make sure sendmsg et al are disallowed to avoid
+            # inadvertent disclosure of data and/or corruption
+            # of the encrypted data stream
+            self.assertRaises(NotImplementedError, s.dup)
+            self.assertRaises(NotImplementedError, s.sendmsg, [b"data"])
+            self.assertRaises(NotImplementedError, s.recvmsg, 100)
+            self.assertRaises(NotImplementedError,
+                              s.recvmsg_into, [bytearray(100)])
+            s.write(b"over\n")
+
+            self.assertRaises(ValueError, s.recv, -1)
+            self.assertRaises(ValueError, s.read, -1)
+
+            s.close()
+
+    def test_recv_zero(self):
+        server = ThreadedEchoServer(CERTFILE)
+        self.enterContext(server)
+        s = socket.create_connection((HOST, server.port))
+        self.addCleanup(s.close)
+        s = test_wrap_socket(s, suppress_ragged_eofs=False)
+        self.addCleanup(s.close)
+
+        # recv/read(0) should return no data
+        s.send(b"data")
+        self.assertEqual(s.recv(0), b"")
+        self.assertEqual(s.read(0), b"")
+        self.assertEqual(s.read(), b"data")
+
+        # Should not block if the other end sends no data
+        s.setblocking(False)
+        self.assertEqual(s.recv(0), b"")
+        self.assertEqual(s.recv_into(bytearray()), 0)
+
+    def test_recv_into_buffer_protocol_len(self):
+        server = ThreadedEchoServer(CERTFILE)
+        self.enterContext(server)
+        s = socket.create_connection((HOST, server.port))
+        self.addCleanup(s.close)
+        s = test_wrap_socket(s, suppress_ragged_eofs=False)
+        self.addCleanup(s.close)
+
+        s.send(b"data")
+        buf = array.array('I', [0, 0])
+        self.assertEqual(s.recv_into(buf), 4)
+        self.assertEqual(bytes(buf)[:4], b"data")
+
+        class B(bytearray):
+            def __len__(self):
+                1/0
+        s.send(b"data")
+        buf = B(6)
+        self.assertEqual(s.recv_into(buf), 4)
+        self.assertEqual(bytes(buf), b"data\0\0")
+
+    def test_nonblocking_send(self):
+        server = ThreadedEchoServer(CERTFILE,
+                                    certreqs=ssl.CERT_NONE,
+                                    ssl_version=ssl.PROTOCOL_TLS_SERVER,
+                                    cacerts=CERTFILE,
+                                    chatty=True,
+                                    connectionchatty=False)
+        with server:
+            s = test_wrap_socket(socket.socket(),
+                                server_side=False,
+                                certfile=CERTFILE,
+                                ca_certs=CERTFILE,
+                                cert_reqs=ssl.CERT_NONE)
+            s.connect((HOST, server.port))
+            s.setblocking(False)
+
+            # If we keep sending data, at some point the buffers
+            # will be full and the call will block
+            buf = bytearray(8192)
+            def fill_buffer():
+                while True:
+                    s.send(buf)
+            self.assertRaises((ssl.SSLWantWriteError,
+                               ssl.SSLWantReadError), fill_buffer)
+
+            # Now read all the output and discard it
+            s.setblocking(True)
+            s.close()
+
+    def test_handshake_timeout(self):
+        # Issue #5103: SSL handshake must respect the socket timeout
+        server = socket.socket(socket.AF_INET)
+        host = "127.0.0.1"
+        port = socket_helper.bind_port(server)
+        started = threading.Event()
+        finish = False
+
+        def serve():
+            server.listen()
+            started.set()
+            conns = []
+            while not finish:
+                r, w, e = select.select([server], [], [], 0.1)
+                if server in r:
+                    # Let the socket hang around rather than having
+                    # it closed by garbage collection.
+                    conns.append(server.accept()[0])
+            for sock in conns:
+                sock.close()
+
+        t = threading.Thread(target=serve)
+        t.start()
+        started.wait()
+
+        try:
+            try:
+                c = socket.socket(socket.AF_INET)
+                c.settimeout(0.2)
+                c.connect((host, port))
+                # Will attempt handshake and time out
+                self.assertRaisesRegex(TimeoutError, "timed out",
+                                       test_wrap_socket, c)
+            finally:
+                c.close()
+            try:
+                c = socket.socket(socket.AF_INET)
+                c = test_wrap_socket(c)
+                c.settimeout(0.2)
+                # Will attempt handshake and time out
+                self.assertRaisesRegex(TimeoutError, "timed out",
+                                       c.connect, (host, port))
+            finally:
+                c.close()
+        finally:
+            finish = True
+            t.join()
+            server.close()
+
+    def test_server_accept(self):
+        # Issue #16357: accept() on a SSLSocket created through
+        # SSLContext.wrap_socket().
+        client_ctx, server_ctx, hostname = testing_context()
+        server = socket.socket(socket.AF_INET)
+        host = "127.0.0.1"
+        port = socket_helper.bind_port(server)
+        server = server_ctx.wrap_socket(server, server_side=True)
+        self.assertTrue(server.server_side)
+
+        evt = threading.Event()
+        remote = None
+        peer = None
+        def serve():
+            nonlocal remote, peer
+            server.listen()
+            # Block on the accept and wait on the connection to close.
+            evt.set()
+            remote, peer = server.accept()
+            remote.send(remote.recv(4))
+
+        t = threading.Thread(target=serve)
+        t.start()
+        # Client wait until server setup and perform a connect.
+        evt.wait()
+        client = client_ctx.wrap_socket(
+            socket.socket(), server_hostname=hostname
+        )
+        client.connect((hostname, port))
+        client.send(b'data')
+        client.recv()
+        client_addr = client.getsockname()
+        client.close()
+        t.join()
+        remote.close()
+        server.close()
+        # Sanity checks.
+        self.assertIsInstance(remote, ssl.SSLSocket)
+        self.assertEqual(peer, client_addr)
+
+    def test_getpeercert_enotconn(self):
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        context.check_hostname = False
+        with context.wrap_socket(socket.socket()) as sock:
+            with self.assertRaises(OSError) as cm:
+                sock.getpeercert()
+            self.assertEqual(cm.exception.errno, errno.ENOTCONN)
+
+    def test_do_handshake_enotconn(self):
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        context.check_hostname = False
+        with context.wrap_socket(socket.socket()) as sock:
+            with self.assertRaises(OSError) as cm:
+                sock.do_handshake()
+            self.assertEqual(cm.exception.errno, errno.ENOTCONN)
+
+    def test_no_shared_ciphers(self):
+        client_context, server_context, hostname = testing_context()
+        # OpenSSL enables all TLS 1.3 ciphers, enforce TLS 1.2 for test
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        # Force different suites on client and server
+        client_context.set_ciphers("AES128")
+        server_context.set_ciphers("AES256")
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                with self.assertRaises(OSError):
+                    s.connect((HOST, server.port))
+        self.assertIn("NO_SHARED_CIPHER", server.conn_errors[0])
+
+    def test_version_basic(self):
+        """
+        Basic tests for SSLSocket.version().
+        More tests are done in the test_protocol_*() methods.
+        """
+        context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+        with ThreadedEchoServer(CERTFILE,
+                                ssl_version=ssl.PROTOCOL_TLS_SERVER,
+                                chatty=False) as server:
+            with context.wrap_socket(socket.socket()) as s:
+                self.assertIs(s.version(), None)
+                self.assertIs(s._sslobj, None)
+                s.connect((HOST, server.port))
+                self.assertEqual(s.version(), 'TLSv1.3')
+            self.assertIs(s._sslobj, None)
+            self.assertIs(s.version(), None)
+
+    @requires_tls_version('TLSv1_3')
+    def test_tls1_3(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.minimum_version = ssl.TLSVersion.TLSv1_3
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertIn(s.cipher()[0], {
+                    'TLS_AES_256_GCM_SHA384',
+                    'TLS_CHACHA20_POLY1305_SHA256',
+                    'TLS_AES_128_GCM_SHA256',
+                })
+                self.assertEqual(s.version(), 'TLSv1.3')
+
+    @requires_tls_version('TLSv1_2')
+    @requires_tls_version('TLSv1')
+    @ignore_deprecation
+    def test_min_max_version_tlsv1_2(self):
+        client_context, server_context, hostname = testing_context()
+        # client TLSv1.0 to 1.2
+        client_context.minimum_version = ssl.TLSVersion.TLSv1
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        # server only TLSv1.2
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertEqual(s.version(), 'TLSv1.2')
+
+    @requires_tls_version('TLSv1_1')
+    @ignore_deprecation
+    def test_min_max_version_tlsv1_1(self):
+        client_context, server_context, hostname = testing_context()
+        # client 1.0 to 1.2, server 1.0 to 1.1
+        client_context.minimum_version = ssl.TLSVersion.TLSv1
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        server_context.minimum_version = ssl.TLSVersion.TLSv1
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_1
+        seclevel_workaround(client_context, server_context)
+
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertEqual(s.version(), 'TLSv1.1')
+
+    @requires_tls_version('TLSv1_2')
+    @requires_tls_version('TLSv1')
+    @ignore_deprecation
+    def test_min_max_version_mismatch(self):
+        client_context, server_context, hostname = testing_context()
+        # client 1.0, server 1.2 (mismatch)
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        client_context.maximum_version = ssl.TLSVersion.TLSv1
+        client_context.minimum_version = ssl.TLSVersion.TLSv1
+        seclevel_workaround(client_context, server_context)
+
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                with self.assertRaises(ssl.SSLError) as e:
+                    s.connect((HOST, server.port))
+                self.assertRegex(str(e.exception), "(alert|ALERT)")
+
+    @requires_tls_version('SSLv3')
+    def test_min_max_version_sslv3(self):
+        client_context, server_context, hostname = testing_context()
+        server_context.minimum_version = ssl.TLSVersion.SSLv3
+        client_context.minimum_version = ssl.TLSVersion.SSLv3
+        client_context.maximum_version = ssl.TLSVersion.SSLv3
+        seclevel_workaround(client_context, server_context)
+
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertEqual(s.version(), 'SSLv3')
+
+    def test_default_ecdh_curve(self):
+        # Issue #21015: elliptic curve-based Diffie Hellman key exchange
+        # should be enabled by default on SSL contexts.
+        client_context, server_context, hostname = testing_context()
+        # TLSv1.3 defaults to PFS key agreement and no longer has KEA in
+        # cipher name.
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        # Prior to OpenSSL 1.0.0, ECDH ciphers have to be enabled
+        # explicitly using the 'ECCdraft' cipher alias.  Otherwise,
+        # our default cipher list should prefer ECDH-based ciphers
+        # automatically.
+        with ThreadedEchoServer(context=server_context) as server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                self.assertIn("ECDH", s.cipher()[0])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.skipUnless("tls-unique" in ssl.CHANNEL_BINDING_TYPES,
+                         "'tls-unique' channel binding not available")
+    def test_tls_unique_channel_binding(self):
+        """Test tls-unique channel binding."""
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+
+        # tls-unique is not defined for TLSv1.3
+        # https://datatracker.ietf.org/doc/html/rfc8446#appendix-C.5
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        server = ThreadedEchoServer(context=server_context,
+                                    chatty=True,
+                                    connectionchatty=False)
+
+        with server:
+            with client_context.wrap_socket(
+                    socket.socket(),
+                    server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                # get the data
+                cb_data = s.get_channel_binding("tls-unique")
+                if support.verbose:
+                    sys.stdout.write(
+                        " got channel binding data: {0!r}\n".format(cb_data))
+
+                # check if it is sane
+                self.assertIsNotNone(cb_data)
+                if s.version() == 'TLSv1.3':
+                    self.assertEqual(len(cb_data), 48)
+                else:
+                    self.assertEqual(len(cb_data), 12)  # True for TLSv1
+
+                # and compare with the peers version
+                s.write(b"CB tls-unique\n")
+                peer_data_repr = s.read().strip()
+                self.assertEqual(peer_data_repr,
+                                 repr(cb_data).encode("us-ascii"))
+
+            # now, again
+            with client_context.wrap_socket(
+                    socket.socket(),
+                    server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                new_cb_data = s.get_channel_binding("tls-unique")
+                if support.verbose:
+                    sys.stdout.write(
+                        "got another channel binding data: {0!r}\n".format(
+                            new_cb_data)
+                    )
+                # is it really unique
+                self.assertNotEqual(cb_data, new_cb_data)
+                self.assertIsNotNone(cb_data)
+                if s.version() == 'TLSv1.3':
+                    self.assertEqual(len(cb_data), 48)
+                else:
+                    self.assertEqual(len(cb_data), 12)  # True for TLSv1
+                s.write(b"CB tls-unique\n")
+                peer_data_repr = s.read().strip()
+                self.assertEqual(peer_data_repr,
+                                 repr(new_cb_data).encode("us-ascii"))
+
+    def test_compression(self):
+        client_context, server_context, hostname = testing_context()
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+        if support.verbose:
+            sys.stdout.write(" got compression: {!r}\n".format(stats['compression']))
+        self.assertIn(stats['compression'], { None, 'ZLIB', 'RLE' })
+
+    @unittest.skipUnless(hasattr(ssl, 'OP_NO_COMPRESSION'),
+                         "ssl.OP_NO_COMPRESSION needed for this test")
+    def test_compression_disabled(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.options |= ssl.OP_NO_COMPRESSION
+        server_context.options |= ssl.OP_NO_COMPRESSION
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+        self.assertIs(stats['compression'], None)
+
+    def test_legacy_server_connect(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.options |= ssl.OP_LEGACY_SERVER_CONNECT
+        server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+
+    def test_no_legacy_server_connect(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.options &= ~ssl.OP_LEGACY_SERVER_CONNECT
+        server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+
+    def test_dh_params(self):
+        # Check we can get a connection with ephemeral finite-field
+        # Diffie-Hellman (if supported).
+        client_context, server_context, hostname = testing_context()
+        dhe_aliases = {"ADH", "EDH", "DHE"}
+        if not (supports_kx_alias(client_context, dhe_aliases)
+                and supports_kx_alias(server_context, dhe_aliases)):
+            self.skipTest("libssl doesn't support ephemeral DH")
+        # test scenario needs TLS <= 1.2
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        try:
+            server_context.load_dh_params(DHFILE)
+        except RuntimeError:
+            if Py_DEBUG_WIN32:
+                self.skipTest("not supported on Win32 debug build")
+            raise
+        server_context.set_ciphers("kEDH")
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+        cipher = stats["cipher"][0]
+        parts = cipher.split("-")
+        if not dhe_aliases.intersection(parts):
+            self.fail("Non-DH key exchange: " + cipher[0])
+
+    def test_ecdh_curve(self):
+        # server secp384r1, client auto
+        client_context, server_context, hostname = testing_context()
+
+        server_context.set_ecdh_curve("secp384r1")
+        server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+
+        # server auto, client secp384r1
+        client_context, server_context, hostname = testing_context()
+        client_context.set_ecdh_curve("secp384r1")
+        server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+
+        # server / client curve mismatch
+        client_context, server_context, hostname = testing_context()
+        client_context.set_ecdh_curve("prime256v1")
+        server_context.set_ecdh_curve("secp384r1")
+        server_context.set_ciphers("ECDHE:!eNULL:!aNULL")
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        with self.assertRaises(ssl.SSLError):
+            server_params_test(client_context, server_context,
+                               chatty=True, connectionchatty=True,
+                               sni_name=hostname)
+
+    def test_selected_alpn_protocol(self):
+        # selected_alpn_protocol() is None unless ALPN is used.
+        client_context, server_context, hostname = testing_context()
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+        self.assertIs(stats['client_alpn_protocol'], None)
+
+    def test_selected_alpn_protocol_if_server_uses_alpn(self):
+        # selected_alpn_protocol() is None unless ALPN is used by the client.
+        client_context, server_context, hostname = testing_context()
+        server_context.set_alpn_protocols(['foo', 'bar'])
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True, connectionchatty=True,
+                                   sni_name=hostname)
+        self.assertIs(stats['client_alpn_protocol'], None)
+
+    def test_alpn_protocols(self):
+        server_protocols = ['foo', 'bar', 'milkshake']
+        protocol_tests = [
+            (['foo', 'bar'], 'foo'),
+            (['bar', 'foo'], 'foo'),
+            (['milkshake'], 'milkshake'),
+            (['http/3.0', 'http/4.0'], None)
+        ]
+        for client_protocols, expected in protocol_tests:
+            client_context, server_context, hostname = testing_context()
+            server_context.set_alpn_protocols(server_protocols)
+            client_context.set_alpn_protocols(client_protocols)
+
+            try:
+                stats = server_params_test(client_context,
+                                           server_context,
+                                           chatty=True,
+                                           connectionchatty=True,
+                                           sni_name=hostname)
+            except ssl.SSLError as e:
+                stats = e
+
+            msg = "failed trying %s (s) and %s (c).\n" \
+                "was expecting %s, but got %%s from the %%s" \
+                    % (str(server_protocols), str(client_protocols),
+                        str(expected))
+            client_result = stats['client_alpn_protocol']
+            self.assertEqual(client_result, expected,
+                             msg % (client_result, "client"))
+            server_result = stats['server_alpn_protocols'][-1] \
+                if len(stats['server_alpn_protocols']) else 'nothing'
+            self.assertEqual(server_result, expected,
+                             msg % (server_result, "server"))
+
+    def test_npn_protocols(self):
+        assert not ssl.HAS_NPN
+
+    def sni_contexts(self):
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.load_cert_chain(SIGNED_CERTFILE)
+        other_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        other_context.load_cert_chain(SIGNED_CERTFILE2)
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.load_verify_locations(SIGNING_CA)
+        return server_context, other_context, client_context
+
+    def check_common_name(self, stats, name):
+        cert = stats['peercert']
+        self.assertIn((('commonName', name),), cert['subject'])
+
+    def test_sni_callback(self):
+        calls = []
+        server_context, other_context, client_context = self.sni_contexts()
+
+        client_context.check_hostname = False
+
+        def servername_cb(ssl_sock, server_name, initial_context):
+            calls.append((server_name, initial_context))
+            if server_name is not None:
+                ssl_sock.context = other_context
+        server_context.set_servername_callback(servername_cb)
+
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True,
+                                   sni_name='supermessage')
+        # The hostname was fetched properly, and the certificate was
+        # changed for the connection.
+        self.assertEqual(calls, [("supermessage", server_context)])
+        # CERTFILE4 was selected
+        self.check_common_name(stats, 'fakehostname')
+
+        calls = []
+        # The callback is called with server_name=None
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True,
+                                   sni_name=None)
+        self.assertEqual(calls, [(None, server_context)])
+        self.check_common_name(stats, SIGNED_CERTFILE_HOSTNAME)
+
+        # Check disabling the callback
+        calls = []
+        server_context.set_servername_callback(None)
+
+        stats = server_params_test(client_context, server_context,
+                                   chatty=True,
+                                   sni_name='notfunny')
+        # Certificate didn't change
+        self.check_common_name(stats, SIGNED_CERTFILE_HOSTNAME)
+        self.assertEqual(calls, [])
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    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()
+
+        def cb_returning_alert(ssl_sock, server_name, initial_context):
+            return ssl.ALERT_DESCRIPTION_ACCESS_DENIED
+        server_context.set_servername_callback(cb_returning_alert)
+        with self.assertRaises(ssl.SSLError) as cm:
+            stats = server_params_test(client_context, server_context,
+                                       chatty=False,
+                                       sni_name='supermessage')
+        self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_ACCESS_DENIED')
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_sni_callback_raising(self):
+        # Raising fails the connection with a TLS handshake failure alert.
+        server_context, other_context, client_context = self.sni_contexts()
+
+        def cb_raising(ssl_sock, server_name, initial_context):
+            1/0
+        server_context.set_servername_callback(cb_raising)
+
+        with support.catch_unraisable_exception() as catch:
+            with self.assertRaises(ssl.SSLError) as cm:
+                stats = server_params_test(client_context, server_context,
+                                           chatty=False,
+                                           sni_name='supermessage')
+
+            # Allow for flexible libssl error messages.
+            regex = "(SSLV3_ALERT_HANDSHAKE_FAILURE|NO_PRIVATE_VALUE)"
+            self.assertRegex(cm.exception.reason, regex)
+            self.assertEqual(catch.unraisable.exc_type, ZeroDivisionError)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_sni_callback_wrong_return_type(self):
+        # Returning the wrong return type terminates the TLS connection
+        # with an internal error alert.
+        server_context, other_context, client_context = self.sni_contexts()
+
+        def cb_wrong_return_type(ssl_sock, server_name, initial_context):
+            return "foo"
+        server_context.set_servername_callback(cb_wrong_return_type)
+
+        with support.catch_unraisable_exception() as catch:
+            with self.assertRaises(ssl.SSLError) as cm:
+                stats = server_params_test(client_context, server_context,
+                                           chatty=False,
+                                           sni_name='supermessage')
+
+
+            self.assertEqual(cm.exception.reason, 'TLSV1_ALERT_INTERNAL_ERROR')
+            self.assertEqual(catch.unraisable.exc_type, TypeError)
+
+    def test_shared_ciphers(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.set_ciphers("AES128:AES256")
+        server_context.set_ciphers("AES256:eNULL")
+        expected_algs = [
+            "AES256", "AES-256",
+            # TLS 1.3 ciphers are always enabled
+            "TLS_CHACHA20", "TLS_AES",
+        ]
+
+        stats = server_params_test(client_context, server_context,
+                                   sni_name=hostname)
+        ciphers = stats['server_shared_ciphers'][0]
+        self.assertGreater(len(ciphers), 0)
+        for name, tls_version, bits in ciphers:
+            if not any(alg in name for alg in expected_algs):
+                self.fail(name)
+
+    def test_read_write_after_close_raises_valuerror(self):
+        client_context, server_context, hostname = testing_context()
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+
+        with server:
+            s = client_context.wrap_socket(socket.socket(),
+                                           server_hostname=hostname)
+            s.connect((HOST, server.port))
+            s.close()
+
+            self.assertRaises(ValueError, s.read, 1024)
+            self.assertRaises(ValueError, s.write, b'hello')
+
+    def test_sendfile(self):
+        TEST_DATA = b"x" * 512
+        with open(os_helper.TESTFN, 'wb') as f:
+            f.write(TEST_DATA)
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        client_context, server_context, hostname = testing_context()
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                with open(os_helper.TESTFN, 'rb') as file:
+                    s.sendfile(file)
+                    self.assertEqual(s.recv(1024), TEST_DATA)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_session(self):
+        client_context, server_context, hostname = testing_context()
+        # TODO: sessions aren't compatible with TLSv1.3 yet
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        # first connection without session
+        stats = server_params_test(client_context, server_context,
+                                   sni_name=hostname)
+        session = stats['session']
+        self.assertTrue(session.id)
+        self.assertGreater(session.time, 0)
+        self.assertGreater(session.timeout, 0)
+        self.assertTrue(session.has_ticket)
+        self.assertGreater(session.ticket_lifetime_hint, 0)
+        self.assertFalse(stats['session_reused'])
+        sess_stat = server_context.session_stats()
+        self.assertEqual(sess_stat['accept'], 1)
+        self.assertEqual(sess_stat['hits'], 0)
+
+        # reuse session
+        stats = server_params_test(client_context, server_context,
+                                   session=session, sni_name=hostname)
+        sess_stat = server_context.session_stats()
+        self.assertEqual(sess_stat['accept'], 2)
+        self.assertEqual(sess_stat['hits'], 1)
+        self.assertTrue(stats['session_reused'])
+        session2 = stats['session']
+        self.assertEqual(session2.id, session.id)
+        self.assertEqual(session2, session)
+        self.assertIsNot(session2, session)
+        self.assertGreaterEqual(session2.time, session.time)
+        self.assertGreaterEqual(session2.timeout, session.timeout)
+
+        # another one without session
+        stats = server_params_test(client_context, server_context,
+                                   sni_name=hostname)
+        self.assertFalse(stats['session_reused'])
+        session3 = stats['session']
+        self.assertNotEqual(session3.id, session.id)
+        self.assertNotEqual(session3, session)
+        sess_stat = server_context.session_stats()
+        self.assertEqual(sess_stat['accept'], 3)
+        self.assertEqual(sess_stat['hits'], 1)
+
+        # reuse session again
+        stats = server_params_test(client_context, server_context,
+                                   session=session, sni_name=hostname)
+        self.assertTrue(stats['session_reused'])
+        session4 = stats['session']
+        self.assertEqual(session4.id, session.id)
+        self.assertEqual(session4, session)
+        self.assertGreaterEqual(session4.time, session.time)
+        self.assertGreaterEqual(session4.timeout, session.timeout)
+        sess_stat = server_context.session_stats()
+        self.assertEqual(sess_stat['accept'], 4)
+        self.assertEqual(sess_stat['hits'], 2)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_session_handling(self):
+        client_context, server_context, hostname = testing_context()
+        client_context2, _, _ = testing_context()
+
+        # TODO: session reuse does not work with TLSv1.3
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        client_context2.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                # session is None before handshake
+                self.assertEqual(s.session, None)
+                self.assertEqual(s.session_reused, None)
+                s.connect((HOST, server.port))
+                session = s.session
+                self.assertTrue(session)
+                with self.assertRaises(TypeError) as e:
+                    s.session = object
+                self.assertEqual(str(e.exception), 'Value is not a SSLSession.')
+
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                # cannot set session after handshake
+                with self.assertRaises(ValueError) as e:
+                    s.session = session
+                self.assertEqual(str(e.exception),
+                                 'Cannot set session after handshake.')
+
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                # can set session before handshake and before the
+                # connection was established
+                s.session = session
+                s.connect((HOST, server.port))
+                self.assertEqual(s.session.id, session.id)
+                self.assertEqual(s.session, session)
+                self.assertEqual(s.session_reused, True)
+
+            with client_context2.wrap_socket(socket.socket(),
+                                             server_hostname=hostname) as s:
+                # cannot re-use session with a different SSLContext
+                with self.assertRaises(ValueError) as e:
+                    s.session = session
+                    s.connect((HOST, server.port))
+                self.assertEqual(str(e.exception),
+                                 'Session refers to a different SSLContext.')
+
+    @requires_tls_version('TLSv1_2')
+    @unittest.skipUnless(ssl.HAS_PSK, 'TLS-PSK disabled on this OpenSSL build')
+    def test_psk(self):
+        psk = bytes.fromhex('deadbeef')
+
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.check_hostname = False
+        client_context.verify_mode = ssl.CERT_NONE
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        client_context.set_ciphers('PSK')
+        client_context.set_psk_client_callback(lambda hint: (None, psk))
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        server_context.set_ciphers('PSK')
+        server_context.set_psk_server_callback(lambda identity: psk)
+
+        # correct PSK should connect
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket()) as s:
+                s.connect((HOST, server.port))
+
+        # incorrect PSK should fail
+        incorrect_psk = bytes.fromhex('cafebabe')
+        client_context.set_psk_client_callback(lambda hint: (None, incorrect_psk))
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket()) as s:
+                with self.assertRaises(ssl.SSLError):
+                    s.connect((HOST, server.port))
+
+        # identity_hint and client_identity should be sent to the other side
+        identity_hint = 'identity-hint'
+        client_identity = 'client-identity'
+
+        def client_callback(hint):
+            self.assertEqual(hint, identity_hint)
+            return client_identity, psk
+
+        def server_callback(identity):
+            self.assertEqual(identity, client_identity)
+            return psk
+
+        client_context.set_psk_client_callback(client_callback)
+        server_context.set_psk_server_callback(server_callback, identity_hint)
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket()) as s:
+                s.connect((HOST, server.port))
+
+        # adding client callback to server or vice versa raises an exception
+        with self.assertRaisesRegex(ssl.SSLError, 'Cannot add PSK server callback'):
+            client_context.set_psk_server_callback(server_callback, identity_hint)
+        with self.assertRaisesRegex(ssl.SSLError, 'Cannot add PSK client callback'):
+            server_context.set_psk_client_callback(client_callback)
+
+        # test with UTF-8 identities
+        identity_hint = '身份暗示'  # Translation: "Identity hint"
+        client_identity = '客户身份'  # Translation: "Customer identity"
+
+        client_context.set_psk_client_callback(client_callback)
+        server_context.set_psk_server_callback(server_callback, identity_hint)
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket()) as s:
+                s.connect((HOST, server.port))
+
+    @requires_tls_version('TLSv1_3')
+    @unittest.skipUnless(ssl.HAS_PSK, 'TLS-PSK disabled on this OpenSSL build')
+    def test_psk_tls1_3(self):
+        psk = bytes.fromhex('deadbeef')
+        identity_hint = 'identity-hint'
+        client_identity = 'client-identity'
+
+        def client_callback(hint):
+            # identity_hint is not sent to the client in TLS 1.3
+            self.assertIsNone(hint)
+            return client_identity, psk
+
+        def server_callback(identity):
+            self.assertEqual(identity, client_identity)
+            return psk
+
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.check_hostname = False
+        client_context.verify_mode = ssl.CERT_NONE
+        client_context.minimum_version = ssl.TLSVersion.TLSv1_3
+        client_context.set_ciphers('PSK')
+        client_context.set_psk_client_callback(client_callback)
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.minimum_version = ssl.TLSVersion.TLSv1_3
+        server_context.set_ciphers('PSK')
+        server_context.set_psk_server_callback(server_callback, identity_hint)
+
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket()) as s:
+                s.connect((HOST, server.port))
+
+    @unittest.skip("TODO: RUSTPYTHON; Hangs")
+    def test_thread_recv_while_main_thread_sends(self):
+        # GH-137583: Locking was added to calls to send() and recv() on SSL
+        # socket objects. This seemed fine at the surface level because those
+        # calls weren't re-entrant, but recv() calls would implicitly mimick
+        # holding a lock by blocking until it received data. This means that
+        # if a thread started to infinitely block until data was received, calls
+        # to send() would deadlock, because it would wait forever on the lock
+        # that the recv() call held.
+        data = b"1" * 1024
+        event = threading.Event()
+        def background(sock):
+            event.set()
+            received = sock.recv(len(data))
+            self.assertEqual(received, data)
+
+        client_context, server_context, hostname = testing_context()
+        server = ThreadedEchoServer(context=server_context)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as sock:
+                sock.connect((HOST, server.port))
+                sock.settimeout(1)
+                sock.setblocking(1)
+                # Ensure that the server is ready to accept requests
+                sock.sendall(b"123")
+                self.assertEqual(sock.recv(3), b"123")
+                with threading_helper.catch_threading_exception() as cm:
+                    thread = threading.Thread(target=background,
+                                              args=(sock,), daemon=True)
+                    thread.start()
+                    event.wait()
+                    sock.sendall(data)
+                    thread.join()
+                    if cm.exc_value is not None:
+                        raise cm.exc_value
+
+
+@unittest.skipUnless(has_tls_version('TLSv1_3'), "Test needs TLS 1.3")
+class TestPostHandshakeAuth(unittest.TestCase):
+    def test_pha_setter(self):
+        protocols = [
+            ssl.PROTOCOL_TLS_SERVER, ssl.PROTOCOL_TLS_CLIENT
+        ]
+        for protocol in protocols:
+            ctx = ssl.SSLContext(protocol)
+            self.assertEqual(ctx.post_handshake_auth, False)
+
+            ctx.post_handshake_auth = True
+            self.assertEqual(ctx.post_handshake_auth, True)
+
+            ctx.verify_mode = ssl.CERT_REQUIRED
+            self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+            self.assertEqual(ctx.post_handshake_auth, True)
+
+            ctx.post_handshake_auth = False
+            self.assertEqual(ctx.verify_mode, ssl.CERT_REQUIRED)
+            self.assertEqual(ctx.post_handshake_auth, False)
+
+            ctx.verify_mode = ssl.CERT_OPTIONAL
+            ctx.post_handshake_auth = True
+            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
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.post_handshake_auth = True
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'FALSE\n')
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'TRUE\n')
+                # PHA method just returns true when cert is already available
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                s.write(b'GETCERT')
+                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
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.post_handshake_auth = True
+
+        def msg_cb(conn, direction, version, content_type, msg_type, data):
+            if support.verbose and content_type == _TLSContentType.ALERT:
+                info = (conn, direction, version, content_type, msg_type, data)
+                sys.stdout.write(f"TLS: {info!r}\n")
+
+        server_context._msg_callback = msg_cb
+        client_context._msg_callback = msg_cb
+
+        server = ThreadedEchoServer(context=server_context, chatty=True)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname,
+                                            suppress_ragged_eofs=False) as s:
+                s.connect((HOST, server.port))
+                s.write(b'PHA')
+                # test sometimes fails with EOF error. Test passes as long as
+                # server aborts connection with an error.
+                with self.assertRaisesRegex(
+                    OSError,
+                    ('certificate required'
+                     '|EOF occurred'
+                     '|closed by the remote host'
+                     '|Connection reset by peer'
+                     '|Broken pipe')
+                ):
+                    # receive CertificateRequest
+                    data = s.recv(1024)
+                    self.assertEqual(data, b'OK\n')
+
+                    # send empty Certificate + Finish
+                    s.write(b'HASCERT')
+
+                    # receive alert
+                    s.recv(1024)
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_pha_optional(self):
+        if support.verbose:
+            sys.stdout.write("\n")
+
+        client_context, server_context, hostname = testing_context()
+        server_context.post_handshake_auth = True
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.post_handshake_auth = True
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+
+        # check CERT_OPTIONAL
+        server_context.verify_mode = ssl.CERT_OPTIONAL
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'FALSE\n')
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                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")
+
+        client_context, server_context, hostname = testing_context()
+        server_context.post_handshake_auth = True
+        server_context.verify_mode = ssl.CERT_OPTIONAL
+        client_context.post_handshake_auth = True
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'FALSE\n')
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                # optional doesn't fail when client does not have a cert
+                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
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                with self.assertRaisesRegex(ssl.SSLError, 'not server'):
+                    s.verify_client_post_handshake()
+                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()
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.post_handshake_auth = True
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'TRUE\n')
+                # PHA doesn't fail if there is already a cert
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'TRUE\n')
+
+    def test_pha_not_tls13(self):
+        # TLS 1.2
+        client_context, server_context, hostname = testing_context()
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+        client_context.post_handshake_auth = True
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                # PHA fails for TLS != 1.3
+                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.
+        hostname = SIGNED_CERTFILE_HOSTNAME
+        client_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        client_context.post_handshake_auth = True
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+        # no cert validation and CA on client side
+        client_context.check_hostname = False
+        client_context.verify_mode = ssl.CERT_NONE
+
+        server_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
+        server_context.load_cert_chain(SIGNED_CERTFILE)
+        server_context.load_verify_locations(SIGNING_CA)
+        server_context.post_handshake_auth = True
+        server_context.verify_mode = ssl.CERT_REQUIRED
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'FALSE\n')
+                s.write(b'PHA')
+                self.assertEqual(s.recv(1024), b'OK\n')
+                s.write(b'HASCERT')
+                self.assertEqual(s.recv(1024), b'TRUE\n')
+                # server cert has not been validated
+                self.assertEqual(s.getpeercert(), {})
+
+    def test_internal_chain_client(self):
+        client_context, server_context, hostname = testing_context(
+            server_chain=False
+        )
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(
+                socket.socket(),
+                server_hostname=hostname
+            ) as s:
+                s.connect((HOST, server.port))
+                vc = s._sslobj.get_verified_chain()
+                self.assertEqual(len(vc), 2)
+                ee, ca = vc
+                uvc = s._sslobj.get_unverified_chain()
+                self.assertEqual(len(uvc), 1)
+
+                self.assertEqual(ee, uvc[0])
+                self.assertEqual(hash(ee), hash(uvc[0]))
+                self.assertEqual(repr(ee), repr(uvc[0]))
+
+                self.assertNotEqual(ee, ca)
+                self.assertNotEqual(hash(ee), hash(ca))
+                self.assertNotEqual(repr(ee), repr(ca))
+                self.assertNotEqual(ee.get_info(), ca.get_info())
+                self.assertIn("CN=localhost", repr(ee))
+                self.assertIn("CN=our-ca-server", repr(ca))
+
+                pem = ee.public_bytes(_ssl.ENCODING_PEM)
+                der = ee.public_bytes(_ssl.ENCODING_DER)
+                self.assertIsInstance(pem, str)
+                self.assertIn("-----BEGIN CERTIFICATE-----", pem)
+                self.assertIsInstance(der, bytes)
+                self.assertEqual(
+                    ssl.PEM_cert_to_DER_cert(pem), der
+                )
+
+    def test_certificate_chain(self):
+        client_context, server_context, hostname = testing_context(
+            server_chain=False
+        )
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+
+        with open(SIGNING_CA) as f:
+            expected_ca_cert = ssl.PEM_cert_to_DER_cert(f.read())
+
+        with open(SINGED_CERTFILE_ONLY) as f:
+            expected_ee_cert = ssl.PEM_cert_to_DER_cert(f.read())
+
+        with server:
+            with client_context.wrap_socket(
+                socket.socket(),
+                server_hostname=hostname
+            ) as s:
+                s.connect((HOST, server.port))
+                vc = s.get_verified_chain()
+                self.assertEqual(len(vc), 2)
+
+                ee, ca = vc
+                self.assertIsInstance(ee, bytes)
+                self.assertIsInstance(ca, bytes)
+                self.assertEqual(expected_ca_cert, ca)
+                self.assertEqual(expected_ee_cert, ee)
+
+                uvc = s.get_unverified_chain()
+                self.assertEqual(len(uvc), 1)
+                self.assertIsInstance(uvc[0], bytes)
+
+                self.assertEqual(ee, uvc[0])
+                self.assertNotEqual(ee, ca)
+
+    def test_internal_chain_server(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.load_cert_chain(SIGNED_CERTFILE)
+        server_context.verify_mode = ssl.CERT_REQUIRED
+        server_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(
+                socket.socket(),
+                server_hostname=hostname
+            ) as s:
+                s.connect((HOST, server.port))
+                s.write(b'VERIFIEDCHAIN\n')
+                res = s.recv(1024)
+                self.assertEqual(res, b'\x02\n')
+                s.write(b'UNVERIFIEDCHAIN\n')
+                res = s.recv(1024)
+                self.assertEqual(res, b'\x02\n')
+
+
+HAS_KEYLOG = hasattr(ssl.SSLContext, 'keylog_filename')
+requires_keylog = unittest.skipUnless(
+    HAS_KEYLOG, 'test requires OpenSSL 1.1.1 with keylog callback')
+
+class TestSSLDebug(unittest.TestCase):
+
+    def keylog_lines(self, fname=os_helper.TESTFN):
+        with open(fname) as f:
+            return len(list(f))
+
+    @requires_keylog
+    def test_keylog_defaults(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.assertEqual(ctx.keylog_filename, None)
+
+        self.assertFalse(os.path.isfile(os_helper.TESTFN))
+        try:
+            ctx.keylog_filename = os_helper.TESTFN
+        except RuntimeError:
+            if Py_DEBUG_WIN32:
+                self.skipTest("not supported on Win32 debug build")
+            raise
+        self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
+        self.assertTrue(os.path.isfile(os_helper.TESTFN))
+        self.assertEqual(self.keylog_lines(), 1)
+
+        ctx.keylog_filename = None
+        self.assertEqual(ctx.keylog_filename, None)
+
+        with self.assertRaises((IsADirectoryError, PermissionError)):
+            # Windows raises PermissionError
+            ctx.keylog_filename = os.path.dirname(
+                os.path.abspath(os_helper.TESTFN))
+
+        with self.assertRaises(TypeError):
+            ctx.keylog_filename = 1
+
+    @requires_keylog
+    def test_keylog_filename(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        client_context, server_context, hostname = testing_context()
+
+        try:
+            client_context.keylog_filename = os_helper.TESTFN
+        except RuntimeError:
+            if Py_DEBUG_WIN32:
+                self.skipTest("not supported on Win32 debug build")
+            raise
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+        # header, 5 lines for TLS 1.3
+        self.assertEqual(self.keylog_lines(), 6)
+
+        client_context.keylog_filename = None
+        server_context.keylog_filename = os_helper.TESTFN
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+        self.assertGreaterEqual(self.keylog_lines(), 11)
+
+        client_context.keylog_filename = os_helper.TESTFN
+        server_context.keylog_filename = os_helper.TESTFN
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+        self.assertGreaterEqual(self.keylog_lines(), 21)
+
+        client_context.keylog_filename = None
+        server_context.keylog_filename = None
+
+    @requires_keylog
+    @unittest.skipIf(sys.flags.ignore_environment,
+                     "test is not compatible with ignore_environment")
+    def test_keylog_env(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+        with unittest.mock.patch.dict(os.environ):
+            os.environ['SSLKEYLOGFILE'] = os_helper.TESTFN
+            self.assertEqual(os.environ['SSLKEYLOGFILE'], os_helper.TESTFN)
+
+            ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            self.assertEqual(ctx.keylog_filename, None)
+
+            try:
+                ctx = ssl.create_default_context()
+            except RuntimeError:
+                if Py_DEBUG_WIN32:
+                    self.skipTest("not supported on Win32 debug build")
+                raise
+            self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
+
+            ctx = ssl._create_stdlib_context()
+            self.assertEqual(ctx.keylog_filename, os_helper.TESTFN)
+
+    def test_msg_callback(self):
+        client_context, server_context, hostname = testing_context()
+
+        def msg_cb(conn, direction, version, content_type, msg_type, data):
+            pass
+
+        self.assertIs(client_context._msg_callback, None)
+        client_context._msg_callback = msg_cb
+        self.assertIs(client_context._msg_callback, msg_cb)
+        with self.assertRaises(TypeError):
+            client_context._msg_callback = object()
+
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    def test_msg_callback_tls12(self):
+        client_context, server_context, hostname = testing_context()
+        client_context.maximum_version = ssl.TLSVersion.TLSv1_2
+
+        msg = []
+
+        def msg_cb(conn, direction, version, content_type, msg_type, data):
+            self.assertIsInstance(conn, ssl.SSLSocket)
+            self.assertIsInstance(data, bytes)
+            self.assertIn(direction, {'read', 'write'})
+            msg.append((direction, version, content_type, msg_type))
+
+        client_context._msg_callback = msg_cb
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+
+        self.assertIn(
+            ("read", TLSVersion.TLSv1_2, _TLSContentType.HANDSHAKE,
+             _TLSMessageType.SERVER_KEY_EXCHANGE),
+            msg
+        )
+        self.assertIn(
+            ("write", TLSVersion.TLSv1_2, _TLSContentType.CHANGE_CIPHER_SPEC,
+             _TLSMessageType.CHANGE_CIPHER_SPEC),
+            msg
+        )
+
+    def test_msg_callback_deadlock_bpo43577(self):
+        client_context, server_context, hostname = testing_context()
+        server_context2 = testing_context()[1]
+
+        def msg_cb(conn, direction, version, content_type, msg_type, data):
+            pass
+
+        def sni_cb(sock, servername, ctx):
+            sock.context = server_context2
+
+        server_context._msg_callback = msg_cb
+        server_context.sni_callback = sni_cb
+
+        server = ThreadedEchoServer(context=server_context, chatty=False)
+        with server:
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+            with client_context.wrap_socket(socket.socket(),
+                                            server_hostname=hostname) as s:
+                s.connect((HOST, server.port))
+
+
+def set_socket_so_linger_on_with_zero_timeout(sock):
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))
+
+
+class TestPreHandshakeClose(unittest.TestCase):
+    """Verify behavior of close sockets with received data before to the handshake.
+    """
+
+    class SingleConnectionTestServerThread(threading.Thread):
+
+        def __init__(self, *, name, call_after_accept, timeout=None):
+            self.call_after_accept = call_after_accept
+            self.received_data = b''  # set by .run()
+            self.wrap_error = None  # set by .run()
+            self.listener = None  # set by .start()
+            self.port = None  # set by .start()
+            if timeout is None:
+                self.timeout = support.SHORT_TIMEOUT
+            else:
+                self.timeout = timeout
+            super().__init__(name=name)
+
+        def __enter__(self):
+            self.start()
+            return self
+
+        def __exit__(self, *args):
+            try:
+                if self.listener:
+                    self.listener.close()
+            except OSError:
+                pass
+            self.join()
+            self.wrap_error = None  # avoid dangling references
+
+        def start(self):
+            self.ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            self.ssl_ctx.verify_mode = ssl.CERT_REQUIRED
+            self.ssl_ctx.load_verify_locations(cafile=ONLYCERT)
+            self.ssl_ctx.load_cert_chain(certfile=ONLYCERT, keyfile=ONLYKEY)
+            self.listener = socket.socket()
+            self.port = socket_helper.bind_port(self.listener)
+            self.listener.settimeout(self.timeout)
+            self.listener.listen(1)
+            super().start()
+
+        def run(self):
+            try:
+                conn, address = self.listener.accept()
+            except TimeoutError:
+                # on timeout, just close the listener
+                return
+            finally:
+                self.listener.close()
+
+            with conn:
+                if self.call_after_accept(conn):
+                    return
+                try:
+                    tls_socket = self.ssl_ctx.wrap_socket(conn, server_side=True)
+                except OSError as err:  # ssl.SSLError inherits from OSError
+                    self.wrap_error = err
+                else:
+                    try:
+                        self.received_data = tls_socket.recv(400)
+                    except OSError:
+                        pass  # closed, protocol error, etc.
+
+    def non_linux_skip_if_other_okay_error(self, err):
+        if sys.platform in ("linux", "android"):
+            return  # Expect the full test setup to always work on Linux.
+        if (isinstance(err, ConnectionResetError) or
+            (isinstance(err, OSError) and err.errno == errno.EINVAL) or
+            re.search('wrong.version.number', str(getattr(err, "reason", "")), re.I)):
+            # On Windows the TCP RST leads to a ConnectionResetError
+            # (ECONNRESET) which Linux doesn't appear to surface to userspace.
+            # If wrap_socket() winds up on the "if connected:" path and doing
+            # the actual wrapping... we get an SSLError from OpenSSL. Typically
+            # WRONG_VERSION_NUMBER. While appropriate, neither is the scenario
+            # we're specifically trying to test. The way this test is written
+            # is known to work on Linux. We'll skip it anywhere else that it
+            # does not present as doing so.
+            try:
+                self.skipTest(f"Could not recreate conditions on {sys.platform}:"
+                              f" {err=}")
+            finally:
+                # gh-108342: Explicitly break the reference cycle
+                err = None
+
+        # If maintaining this conditional winds up being a problem.
+        # just turn this into an unconditional skip anything but Linux.
+        # The important thing is that our CI has the logic covered.
+
+    def test_preauth_data_to_tls_server(self):
+        server_accept_called = threading.Event()
+        ready_for_server_wrap_socket = threading.Event()
+
+        def call_after_accept(unused):
+            server_accept_called.set()
+            if not ready_for_server_wrap_socket.wait(support.SHORT_TIMEOUT):
+                raise RuntimeError("wrap_socket event never set, test may fail.")
+            return False  # Tell the server thread to continue.
+
+        server = self.SingleConnectionTestServerThread(
+                call_after_accept=call_after_accept,
+                name="preauth_data_to_tls_server")
+        self.enterContext(server)  # starts it & unittest.TestCase stops it.
+
+        with socket.socket() as client:
+            client.connect(server.listener.getsockname())
+            # This forces an immediate connection close via RST on .close().
+            set_socket_so_linger_on_with_zero_timeout(client)
+            client.setblocking(False)
+
+            server_accept_called.wait()
+            client.send(b"DELETE /data HTTP/1.0\r\n\r\n")
+            client.close()  # RST
+
+        ready_for_server_wrap_socket.set()
+        server.join()
+
+        wrap_error = server.wrap_error
+        server.wrap_error = None
+        try:
+            self.assertEqual(b"", server.received_data)
+            self.assertIsInstance(wrap_error, OSError)  # All platforms.
+            self.non_linux_skip_if_other_okay_error(wrap_error)
+            self.assertIsInstance(wrap_error, ssl.SSLError)
+            self.assertIn("before TLS handshake with data", wrap_error.args[1])
+            self.assertIn("before TLS handshake with data", wrap_error.reason)
+            self.assertNotEqual(0, wrap_error.args[0])
+            self.assertIsNone(wrap_error.library, msg="attr must exist")
+        finally:
+            # gh-108342: Explicitly break the reference cycle
+            wrap_error = None
+            server = None
+
+    def test_preauth_data_to_tls_client(self):
+        server_can_continue_with_wrap_socket = threading.Event()
+        client_can_continue_with_wrap_socket = threading.Event()
+
+        def call_after_accept(conn_to_client):
+            if not server_can_continue_with_wrap_socket.wait(support.SHORT_TIMEOUT):
+                print("ERROR: test client took too long")
+
+            # This forces an immediate connection close via RST on .close().
+            set_socket_so_linger_on_with_zero_timeout(conn_to_client)
+            conn_to_client.send(
+                    b"HTTP/1.0 307 Temporary Redirect\r\n"
+                    b"Location: https://example.com/someone-elses-server\r\n"
+                    b"\r\n")
+            conn_to_client.close()  # RST
+            client_can_continue_with_wrap_socket.set()
+            return True  # Tell the server to stop.
+
+        server = self.SingleConnectionTestServerThread(
+                call_after_accept=call_after_accept,
+                name="preauth_data_to_tls_client")
+        self.enterContext(server)  # starts it & unittest.TestCase stops it.
+        # Redundant; call_after_accept sets SO_LINGER on the accepted conn.
+        set_socket_so_linger_on_with_zero_timeout(server.listener)
+
+        with socket.socket() as client:
+            client.connect(server.listener.getsockname())
+            server_can_continue_with_wrap_socket.set()
+
+            if not client_can_continue_with_wrap_socket.wait(support.SHORT_TIMEOUT):
+                self.fail("test server took too long")
+            ssl_ctx = ssl.create_default_context()
+            try:
+                tls_client = ssl_ctx.wrap_socket(
+                        client, server_hostname="localhost")
+            except OSError as err:  # SSLError inherits from OSError
+                wrap_error = err
+                received_data = b""
+            else:
+                wrap_error = None
+                received_data = tls_client.recv(400)
+                tls_client.close()
+
+        server.join()
+        try:
+            self.assertEqual(b"", received_data)
+            self.assertIsInstance(wrap_error, OSError)  # All platforms.
+            self.non_linux_skip_if_other_okay_error(wrap_error)
+            self.assertIsInstance(wrap_error, ssl.SSLError)
+            self.assertIn("before TLS handshake with data", wrap_error.args[1])
+            self.assertIn("before TLS handshake with data", wrap_error.reason)
+            self.assertNotEqual(0, wrap_error.args[0])
+            self.assertIsNone(wrap_error.library, msg="attr must exist")
+        finally:
+            # gh-108342: Explicitly break the reference cycle
+            with warnings_helper.check_no_resource_warning(self):
+                wrap_error = None
+            server = None
+
+    def test_https_client_non_tls_response_ignored(self):
+        server_responding = threading.Event()
+
+        class SynchronizedHTTPSConnection(http.client.HTTPSConnection):
+            def connect(self):
+                # Call clear text HTTP connect(), not the encrypted HTTPS (TLS)
+                # connect(): wrap_socket() is called manually below.
+                http.client.HTTPConnection.connect(self)
+
+                # Wait for our fault injection server to have done its thing.
+                if not server_responding.wait(support.SHORT_TIMEOUT) and support.verbose:
+                    sys.stdout.write("server_responding event never set.")
+                self.sock = self._context.wrap_socket(
+                        self.sock, server_hostname=self.host)
+
+        def call_after_accept(conn_to_client):
+            # This forces an immediate connection close via RST on .close().
+            set_socket_so_linger_on_with_zero_timeout(conn_to_client)
+            conn_to_client.send(
+                    b"HTTP/1.0 402 Payment Required\r\n"
+                    b"\r\n")
+            conn_to_client.close()  # RST
+            server_responding.set()
+            return True  # Tell the server to stop.
+
+        timeout = 2.0
+        server = self.SingleConnectionTestServerThread(
+                call_after_accept=call_after_accept,
+                name="non_tls_http_RST_responder",
+                timeout=timeout)
+        self.enterContext(server)  # starts it & unittest.TestCase stops it.
+        # Redundant; call_after_accept sets SO_LINGER on the accepted conn.
+        set_socket_so_linger_on_with_zero_timeout(server.listener)
+
+        connection = SynchronizedHTTPSConnection(
+                server.listener.getsockname()[0],
+                port=server.port,
+                context=ssl.create_default_context(),
+                timeout=timeout,
+        )
+
+        # There are lots of reasons this raises as desired, long before this
+        # test was added. Sending the request requires a successful TLS wrapped
+        # socket; that fails if the connection is broken. It may seem pointless
+        # to test this. It serves as an illustration of something that we never
+        # want to happen... properly not happening.
+        with warnings_helper.check_no_resource_warning(self), \
+                self.assertRaises(OSError):
+            connection.request("HEAD", "/test", headers={"Host": "localhost"})
+            response = connection.getresponse()
+
+        server.join()
+
+
+class TestEnumerations(unittest.TestCase):
+
+    def test_tlsversion(self):
+        class CheckedTLSVersion(enum.IntEnum):
+            MINIMUM_SUPPORTED = _ssl.PROTO_MINIMUM_SUPPORTED
+            SSLv3 = _ssl.PROTO_SSLv3
+            TLSv1 = _ssl.PROTO_TLSv1
+            TLSv1_1 = _ssl.PROTO_TLSv1_1
+            TLSv1_2 = _ssl.PROTO_TLSv1_2
+            TLSv1_3 = _ssl.PROTO_TLSv1_3
+            MAXIMUM_SUPPORTED = _ssl.PROTO_MAXIMUM_SUPPORTED
+        enum._test_simple_enum(CheckedTLSVersion, TLSVersion)
+
+    def test_tlscontenttype(self):
+        class Checked_TLSContentType(enum.IntEnum):
+            """Content types (record layer)
+
+            See RFC 8446, section B.1
+            """
+            CHANGE_CIPHER_SPEC = 20
+            ALERT = 21
+            HANDSHAKE = 22
+            APPLICATION_DATA = 23
+            # pseudo content types
+            HEADER = 0x100
+            INNER_CONTENT_TYPE = 0x101
+        enum._test_simple_enum(Checked_TLSContentType, _TLSContentType)
+
+    def test_tlsalerttype(self):
+        class Checked_TLSAlertType(enum.IntEnum):
+            """Alert types for TLSContentType.ALERT messages
+
+            See RFC 8466, section B.2
+            """
+            CLOSE_NOTIFY = 0
+            UNEXPECTED_MESSAGE = 10
+            BAD_RECORD_MAC = 20
+            DECRYPTION_FAILED = 21
+            RECORD_OVERFLOW = 22
+            DECOMPRESSION_FAILURE = 30
+            HANDSHAKE_FAILURE = 40
+            NO_CERTIFICATE = 41
+            BAD_CERTIFICATE = 42
+            UNSUPPORTED_CERTIFICATE = 43
+            CERTIFICATE_REVOKED = 44
+            CERTIFICATE_EXPIRED = 45
+            CERTIFICATE_UNKNOWN = 46
+            ILLEGAL_PARAMETER = 47
+            UNKNOWN_CA = 48
+            ACCESS_DENIED = 49
+            DECODE_ERROR = 50
+            DECRYPT_ERROR = 51
+            EXPORT_RESTRICTION = 60
+            PROTOCOL_VERSION = 70
+            INSUFFICIENT_SECURITY = 71
+            INTERNAL_ERROR = 80
+            INAPPROPRIATE_FALLBACK = 86
+            USER_CANCELED = 90
+            NO_RENEGOTIATION = 100
+            MISSING_EXTENSION = 109
+            UNSUPPORTED_EXTENSION = 110
+            CERTIFICATE_UNOBTAINABLE = 111
+            UNRECOGNIZED_NAME = 112
+            BAD_CERTIFICATE_STATUS_RESPONSE = 113
+            BAD_CERTIFICATE_HASH_VALUE = 114
+            UNKNOWN_PSK_IDENTITY = 115
+            CERTIFICATE_REQUIRED = 116
+            NO_APPLICATION_PROTOCOL = 120
+        enum._test_simple_enum(Checked_TLSAlertType, _TLSAlertType)
+
+    def test_tlsmessagetype(self):
+        class Checked_TLSMessageType(enum.IntEnum):
+            """Message types (handshake protocol)
+
+            See RFC 8446, section B.3
+            """
+            HELLO_REQUEST = 0
+            CLIENT_HELLO = 1
+            SERVER_HELLO = 2
+            HELLO_VERIFY_REQUEST = 3
+            NEWSESSION_TICKET = 4
+            END_OF_EARLY_DATA = 5
+            HELLO_RETRY_REQUEST = 6
+            ENCRYPTED_EXTENSIONS = 8
+            CERTIFICATE = 11
+            SERVER_KEY_EXCHANGE = 12
+            CERTIFICATE_REQUEST = 13
+            SERVER_DONE = 14
+            CERTIFICATE_VERIFY = 15
+            CLIENT_KEY_EXCHANGE = 16
+            FINISHED = 20
+            CERTIFICATE_URL = 21
+            CERTIFICATE_STATUS = 22
+            SUPPLEMENTAL_DATA = 23
+            KEY_UPDATE = 24
+            NEXT_PROTO = 67
+            MESSAGE_HASH = 254
+            CHANGE_CIPHER_SPEC = 0x0101
+        enum._test_simple_enum(Checked_TLSMessageType, _TLSMessageType)
+
+    def test_sslmethod(self):
+        Checked_SSLMethod = enum._old_convert_(
+                enum.IntEnum, '_SSLMethod', 'ssl',
+                lambda name: name.startswith('PROTOCOL_') and name != 'PROTOCOL_SSLv23',
+                source=ssl._ssl,
+                )
+        # This member is assigned dynamically in `ssl.py`:
+        Checked_SSLMethod.PROTOCOL_SSLv23 = Checked_SSLMethod.PROTOCOL_TLS
+        enum._test_simple_enum(Checked_SSLMethod, ssl._SSLMethod)
+
+    def test_options(self):
+        CheckedOptions = enum._old_convert_(
+                enum.IntFlag, 'Options', 'ssl',
+                lambda name: name.startswith('OP_'),
+                source=ssl._ssl,
+                )
+        enum._test_simple_enum(CheckedOptions, ssl.Options)
+
+    def test_alertdescription(self):
+        CheckedAlertDescription = enum._old_convert_(
+                enum.IntEnum, 'AlertDescription', 'ssl',
+                lambda name: name.startswith('ALERT_DESCRIPTION_'),
+                source=ssl._ssl,
+                )
+        enum._test_simple_enum(CheckedAlertDescription, ssl.AlertDescription)
+
+    def test_sslerrornumber(self):
+        Checked_SSLErrorNumber = enum._old_convert_(
+                enum.IntEnum, 'SSLErrorNumber', 'ssl',
+                lambda name: name.startswith('SSL_ERROR_'),
+                source=ssl._ssl,
+                )
+        enum._test_simple_enum(Checked_SSLErrorNumber, ssl.SSLErrorNumber)
+
+    def test_verifyflags(self):
+        CheckedVerifyFlags = enum._old_convert_(
+                enum.IntFlag, 'VerifyFlags', 'ssl',
+                lambda name: name.startswith('VERIFY_'),
+                source=ssl._ssl,
+                )
+        enum._test_simple_enum(CheckedVerifyFlags, ssl.VerifyFlags)
+
+    def test_verifymode(self):
+        CheckedVerifyMode = enum._old_convert_(
+                enum.IntEnum, 'VerifyMode', 'ssl',
+                lambda name: name.startswith('CERT_'),
+                source=ssl._ssl,
+                )
+        enum._test_simple_enum(CheckedVerifyMode, ssl.VerifyMode)
+
+
+def setUpModule():
+    if support.verbose:
+        plats = {
+            'Mac': platform.mac_ver,
+            'Windows': platform.win32_ver,
+        }
+        for name, func in plats.items():
+            plat = func()
+            if plat and plat[0]:
+                plat = '%s %r' % (name, plat)
+                break
+        else:
+            plat = repr(platform.platform())
+        print("test_ssl: testing with %r %r" %
+            (ssl.OPENSSL_VERSION, ssl.OPENSSL_VERSION_INFO))
+        print("          under %s" % plat)
+        print("          HAS_SNI = %r" % ssl.HAS_SNI)
+        print("          OP_ALL = 0x%8x" % ssl.OP_ALL)
+        try:
+            print("          OP_NO_TLSv1_1 = 0x%8x" % ssl.OP_NO_TLSv1_1)
+        except AttributeError:
+            pass
+
+    for filename in [
+        CERTFILE, BYTES_CERTFILE,
+        ONLYCERT, ONLYKEY, BYTES_ONLYCERT, BYTES_ONLYKEY,
+        SIGNED_CERTFILE, SIGNED_CERTFILE2, SIGNING_CA,
+        BADCERT, BADKEY, EMPTYCERT]:
+        if not os.path.exists(filename):
+            raise support.TestFailed("Can't read certificate file %r" % filename)
+
+    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_stat.py b/Lib/test/test_stat.py
index b6e9c24a80..49013a4bcd 100644
--- a/Lib/test/test_stat.py
+++ b/Lib/test/test_stat.py
@@ -2,8 +2,7 @@
 import os
 import socket
 import sys
-from test.support import os_helper
-from test.support import socket_helper
+from test.support import is_apple, os_helper, socket_helper
 from test.support.import_helper import import_fresh_module
 from test.support.os_helper import TESTFN
 
@@ -15,8 +14,10 @@ class TestFilemode:
     statmod = None
 
     file_flags = {'SF_APPEND', 'SF_ARCHIVED', 'SF_IMMUTABLE', 'SF_NOUNLINK',
-                  'SF_SNAPSHOT', 'UF_APPEND', 'UF_COMPRESSED', 'UF_HIDDEN',
-                  'UF_IMMUTABLE', 'UF_NODUMP', 'UF_NOUNLINK', 'UF_OPAQUE'}
+                  'SF_SNAPSHOT', 'SF_SETTABLE', 'SF_RESTRICTED', 'SF_FIRMLINK',
+                  'SF_DATALESS', 'UF_APPEND', 'UF_COMPRESSED', 'UF_HIDDEN',
+                  'UF_IMMUTABLE', 'UF_NODUMP', 'UF_NOUNLINK', 'UF_OPAQUE',
+                  'UF_SETTABLE', 'UF_TRACKED', 'UF_DATAVAULT'}
 
     formats = {'S_IFBLK', 'S_IFCHR', 'S_IFDIR', 'S_IFIFO', 'S_IFLNK',
                'S_IFREG', 'S_IFSOCK', 'S_IFDOOR', 'S_IFPORT', 'S_IFWHT'}
@@ -113,6 +114,7 @@ def assertS_IS(self, name, mode):
             else:
                 self.assertFalse(func(mode))
 
+    @os_helper.skip_unless_working_chmod
     def test_mode(self):
         with open(TESTFN, 'w'):
             pass
@@ -121,8 +123,11 @@ def test_mode(self):
             st_mode, modestr = self.get_mode()
             self.assertEqual(modestr, '-rwx------')
             self.assertS_IS("REG", st_mode)
-            self.assertEqual(self.statmod.S_IMODE(st_mode),
+            imode = self.statmod.S_IMODE(st_mode)
+            self.assertEqual(imode,
                              self.statmod.S_IRWXU)
+            self.assertEqual(self.statmod.filemode(imode),
+                             '?rwx------')
 
             os.chmod(TESTFN, 0o070)
             st_mode, modestr = self.get_mode()
@@ -144,13 +149,21 @@ def test_mode(self):
             self.assertEqual(modestr, '-r--r--r--')
             self.assertEqual(self.statmod.S_IMODE(st_mode), 0o444)
         else:
+            os.chmod(TESTFN, 0o500)
+            st_mode, modestr = self.get_mode()
+            self.assertEqual(modestr[:3], '-r-')
+            self.assertS_IS("REG", st_mode)
+            self.assertEqual(self.statmod.S_IMODE(st_mode), 0o444)
+
             os.chmod(TESTFN, 0o700)
             st_mode, modestr = self.get_mode()
             self.assertEqual(modestr[:3], '-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)
 
+    @os_helper.skip_unless_working_chmod
     def test_directory(self):
         os.mkdir(TESTFN)
         os.chmod(TESTFN, 0o700)
@@ -161,7 +174,7 @@ def test_directory(self):
         else:
             self.assertEqual(modestr[0], 'd')
 
-    @unittest.skipUnless(hasattr(os, 'symlink'), 'os.symlink not available')
+    @os_helper.skip_unless_symlink
     def test_link(self):
         try:
             os.symlink(os.getcwd(), TESTFN)
@@ -227,6 +240,18 @@ def test_module_attributes(self):
             self.assertTrue(callable(func))
             self.assertEqual(func(0), 0)
 
+    def test_flags_consistent(self):
+        self.assertFalse(self.statmod.UF_SETTABLE & self.statmod.SF_SETTABLE)
+
+        for flag in self.file_flags:
+            if flag.startswith("UF"):
+                self.assertTrue(getattr(self.statmod, flag) & self.statmod.UF_SETTABLE, f"{flag} not in UF_SETTABLE")
+            elif is_apple and self.statmod is c_stat and flag == 'SF_DATALESS':
+                self.assertTrue(self.statmod.SF_DATALESS & self.statmod.SF_SYNTHETIC, "SF_DATALESS not in SF_SYNTHETIC")
+                self.assertFalse(self.statmod.SF_DATALESS & self.statmod.SF_SETTABLE, "SF_DATALESS in SF_SETTABLE")
+            else:
+                self.assertTrue(getattr(self.statmod, flag) & self.statmod.SF_SETTABLE, f"{flag} notin SF_SETTABLE")
+
     @unittest.skipUnless(sys.platform == "win32",
                          "FILE_ATTRIBUTE_* constants are Win32 specific")
     def test_file_attribute_constants(self):
@@ -235,25 +260,75 @@ def test_file_attribute_constants(self):
             modvalue = getattr(self.statmod, key)
             self.assertEqual(value, modvalue, key)
 
+    @unittest.skipUnless(sys.platform == "darwin", "macOS system check")
+    def test_macosx_attribute_values(self):
+        self.assertEqual(self.statmod.UF_SETTABLE, 0x0000ffff)
+        self.assertEqual(self.statmod.UF_NODUMP, 0x00000001)
+        self.assertEqual(self.statmod.UF_IMMUTABLE, 0x00000002)
+        self.assertEqual(self.statmod.UF_APPEND, 0x00000004)
+        self.assertEqual(self.statmod.UF_OPAQUE, 0x00000008)
+        self.assertEqual(self.statmod.UF_COMPRESSED, 0x00000020)
+        self.assertEqual(self.statmod.UF_TRACKED, 0x00000040)
+        self.assertEqual(self.statmod.UF_DATAVAULT, 0x00000080)
+        self.assertEqual(self.statmod.UF_HIDDEN, 0x00008000)
 
+        if self.statmod is c_stat:
+            self.assertEqual(self.statmod.SF_SUPPORTED, 0x009f0000)
+            self.assertEqual(self.statmod.SF_SETTABLE, 0x3fff0000)
+            self.assertEqual(self.statmod.SF_SYNTHETIC, 0xc0000000)
+        else:
+            self.assertEqual(self.statmod.SF_SETTABLE, 0xffff0000)
+        self.assertEqual(self.statmod.SF_ARCHIVED, 0x00010000)
+        self.assertEqual(self.statmod.SF_IMMUTABLE, 0x00020000)
+        self.assertEqual(self.statmod.SF_APPEND, 0x00040000)
+        self.assertEqual(self.statmod.SF_RESTRICTED, 0x00080000)
+        self.assertEqual(self.statmod.SF_NOUNLINK, 0x00100000)
+        self.assertEqual(self.statmod.SF_FIRMLINK, 0x00800000)
+        self.assertEqual(self.statmod.SF_DATALESS, 0x40000000)
+
+        self.assertFalse(isinstance(self.statmod.S_IFMT, int))
+        self.assertEqual(self.statmod.S_IFIFO, 0o010000)
+        self.assertEqual(self.statmod.S_IFCHR, 0o020000)
+        self.assertEqual(self.statmod.S_IFDIR, 0o040000)
+        self.assertEqual(self.statmod.S_IFBLK, 0o060000)
+        self.assertEqual(self.statmod.S_IFREG, 0o100000)
+        self.assertEqual(self.statmod.S_IFLNK, 0o120000)
+        self.assertEqual(self.statmod.S_IFSOCK, 0o140000)
+
+        if self.statmod is c_stat:
+            self.assertEqual(self.statmod.S_IFWHT, 0o160000)
+
+        self.assertEqual(self.statmod.S_IRWXU, 0o000700)
+        self.assertEqual(self.statmod.S_IRUSR, 0o000400)
+        self.assertEqual(self.statmod.S_IWUSR, 0o000200)
+        self.assertEqual(self.statmod.S_IXUSR, 0o000100)
+        self.assertEqual(self.statmod.S_IRWXG, 0o000070)
+        self.assertEqual(self.statmod.S_IRGRP, 0o000040)
+        self.assertEqual(self.statmod.S_IWGRP, 0o000020)
+        self.assertEqual(self.statmod.S_IXGRP, 0o000010)
+        self.assertEqual(self.statmod.S_IRWXO, 0o000007)
+        self.assertEqual(self.statmod.S_IROTH, 0o000004)
+        self.assertEqual(self.statmod.S_IWOTH, 0o000002)
+        self.assertEqual(self.statmod.S_IXOTH, 0o000001)
+        self.assertEqual(self.statmod.S_ISUID, 0o004000)
+        self.assertEqual(self.statmod.S_ISGID, 0o002000)
+        self.assertEqual(self.statmod.S_ISVTX, 0o001000)
+
+        self.assertFalse(hasattr(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)
+
+
+
+@unittest.skipIf(c_stat is None, 'need _stat extension')
 class TestFilemodeCStat(TestFilemode, unittest.TestCase):
     statmod = c_stat
 
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @unittest.expectedFailure
-        def test_link(self):
-            super().test_link()
 
 class TestFilemodePyStat(TestFilemode, unittest.TestCase):
     statmod = py_stat
 
-    # TODO: RUSTPYTHON
-    if sys.platform == "win32":
-        @unittest.expectedFailure
-        def test_link(self):
-            super().test_link()
-
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_statistics.py b/Lib/test/test_statistics.py
index 8fcbcf3540..9c2714e99d 100644
--- a/Lib/test/test_statistics.py
+++ b/Lib/test/test_statistics.py
@@ -1,4 +1,4 @@
-"""Test suite for statistics module, including helper NumericTestCase and
+x = """Test suite for statistics module, including helper NumericTestCase and
 approx_equal function.
 
 """
@@ -9,13 +9,14 @@
 import copy
 import decimal
 import doctest
+import itertools
 import math
 import pickle
 import random
 import sys
 import unittest
 from test import support
-from test.support import import_helper
+from test.support import import_helper, requires_IEEE_754
 
 from decimal import Decimal
 from fractions import Fraction
@@ -27,6 +28,12 @@
 
 # === Helper functions and class ===
 
+# Test copied from Lib/test/test_math.py
+# detect evidence of double-rounding: fsum is not always correctly
+# rounded 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)
+
 def sign(x):
     """Return -1.0 for negatives, including -0.0, otherwise +1.0."""
     return math.copysign(1, x)
@@ -691,14 +698,6 @@ def test_check_all(self):
                             'missing name "%s" in __all__' % name)
 
 
-class DocTests(unittest.TestCase):
-    @unittest.skipIf(sys.flags.optimize >= 2,
-                     "Docstrings are omitted with -OO and above")
-    def test_doc_tests(self):
-        failed, tried = doctest.testmod(statistics, optionflags=doctest.ELLIPSIS)
-        self.assertGreater(tried, 0)
-        self.assertEqual(failed, 0)
-
 class StatisticsErrorTest(unittest.TestCase):
     def test_has_exception(self):
         errmsg = (
@@ -1039,50 +1038,6 @@ def test_error_msg(self):
         self.assertEqual(errmsg, msg)
 
 
-class FindLteqTest(unittest.TestCase):
-    # Test _find_lteq private function.
-
-    def test_invalid_input_values(self):
-        for a, x in [
-            ([], 1),
-            ([1, 2], 3),
-            ([1, 3], 2)
-        ]:
-            with self.subTest(a=a, x=x):
-                with self.assertRaises(ValueError):
-                    statistics._find_lteq(a, x)
-
-    def test_locate_successfully(self):
-        for a, x, expected_i in [
-            ([1, 1, 1, 2, 3], 1, 0),
-            ([0, 1, 1, 1, 2, 3], 1, 1),
-            ([1, 2, 3, 3, 3], 3, 2)
-        ]:
-            with self.subTest(a=a, x=x):
-                self.assertEqual(expected_i, statistics._find_lteq(a, x))
-
-
-class FindRteqTest(unittest.TestCase):
-    # Test _find_rteq private function.
-
-    def test_invalid_input_values(self):
-        for a, l, x in [
-            ([1], 2, 1),
-            ([1, 3], 0, 2)
-        ]:
-            with self.assertRaises(ValueError):
-                statistics._find_rteq(a, l, x)
-
-    def test_locate_successfully(self):
-        for a, l, x, expected_i in [
-            ([1, 1, 1, 2, 3], 0, 1, 2),
-            ([0, 1, 1, 1, 2, 3], 0, 1, 3),
-            ([1, 2, 3, 3, 3], 0, 3, 4)
-        ]:
-            with self.subTest(a=a, l=l, x=x):
-                self.assertEqual(expected_i, statistics._find_rteq(a, l, x))
-
-
 # === Tests for public functions ===
 
 class UnivariateCommonMixin:
@@ -1117,7 +1072,7 @@ def test_no_inplace_modifications(self):
     def test_order_doesnt_matter(self):
         # Test that the order of data points doesn't change the result.
 
-        # CAUTION: due to floating point rounding errors, the result actually
+        # CAUTION: due to floating-point rounding errors, the result actually
         # may depend on the order. Consider this test representing an ideal.
         # To avoid this test failing, only test with exact values such as ints
         # or Fractions.
@@ -1210,6 +1165,9 @@ def __pow__(self, other):
             def __add__(self, other):
                 return type(self)(super().__add__(other))
             __radd__ = __add__
+            def __mul__(self, other):
+                return type(self)(super().__mul__(other))
+            __rmul__ = __mul__
         return (float, Decimal, Fraction, MyFloat)
 
     def test_types_conserved(self):
@@ -1782,6 +1740,12 @@ def test_repeated_single_value(self):
                 data = [x]*count
                 self.assertEqual(self.func(data), float(x))
 
+    def test_single_value(self):
+        # Override method from AverageMixin.
+        # Average of a single value is the value as a float.
+        for x in (23, 42.5, 1.3e15, Fraction(15, 19), Decimal('0.28')):
+            self.assertEqual(self.func([x]), float(x))
+
     def test_odd_fractions(self):
         # Test median_grouped works with an odd number of Fractions.
         F = Fraction
@@ -1961,6 +1925,27 @@ def test_special_values(self):
         with self.assertRaises(ValueError):
             fmean([Inf, -Inf])
 
+    def test_weights(self):
+        fmean = statistics.fmean
+        StatisticsError = statistics.StatisticsError
+        self.assertEqual(
+            fmean([10, 10, 10, 50], [0.25] * 4),
+            fmean([10, 10, 10, 50]))
+        self.assertEqual(
+            fmean([10, 10, 20], [0.25, 0.25, 0.50]),
+            fmean([10, 10, 20, 20]))
+        self.assertEqual(                           # inputs are iterators
+            fmean(iter([10, 10, 20]), iter([0.25, 0.25, 0.50])),
+            fmean([10, 10, 20, 20]))
+        with self.assertRaises(StatisticsError):
+            fmean([10, 20, 30], [1, 2])             # unequal lengths
+        with self.assertRaises(StatisticsError):
+            fmean(iter([10, 20, 30]), iter([1, 2])) # unequal lengths
+        with self.assertRaises(StatisticsError):
+            fmean([10, 20], [-1, 1])                # sum of weights is zero
+        with self.assertRaises(StatisticsError):
+            fmean(iter([10, 20]), iter([-1, 1]))    # sum of weights is zero
+
 
 # === Tests for variances and standard deviations ===
 
@@ -2137,6 +2122,104 @@ def test_center_not_at_mean(self):
         self.assertEqual(self.func(data), 2.5)
         self.assertEqual(self.func(data, mu=0.5), 6.5)
 
+class TestSqrtHelpers(unittest.TestCase):
+
+    def test_integer_sqrt_of_frac_rto(self):
+        for n, m in itertools.product(range(100), range(1, 1000)):
+            r = statistics._integer_sqrt_of_frac_rto(n, m)
+            self.assertIsInstance(r, int)
+            if r*r*m == n:
+                # Root is exact
+                continue
+            # Inexact, so the root should be odd
+            self.assertEqual(r&1, 1)
+            # Verify correct rounding
+            self.assertTrue(m * (r - 1)**2 < n < m * (r + 1)**2)
+
+    @requires_IEEE_754
+    @support.requires_resource('cpu')
+    def test_float_sqrt_of_frac(self):
+
+        def is_root_correctly_rounded(x: Fraction, root: float) -> bool:
+            if not x:
+                return root == 0.0
+
+            # Extract adjacent representable floats
+            r_up: float = math.nextafter(root, math.inf)
+            r_down: float = math.nextafter(root, -math.inf)
+            assert r_down < root < r_up
+
+            # Convert to fractions for exact arithmetic
+            frac_root: Fraction = Fraction(root)
+            half_way_up: Fraction = (frac_root + Fraction(r_up)) / 2
+            half_way_down: Fraction = (frac_root + Fraction(r_down)) / 2
+
+            # Check a closed interval.
+            # Does not test for a midpoint rounding rule.
+            return half_way_down ** 2 <= x <= half_way_up ** 2
+
+        randrange = random.randrange
+
+        for i in range(60_000):
+            numerator: int = randrange(10 ** randrange(50))
+            denonimator: int = randrange(10 ** randrange(50)) + 1
+            with self.subTest(numerator=numerator, denonimator=denonimator):
+                x: Fraction = Fraction(numerator, denonimator)
+                root: float = statistics._float_sqrt_of_frac(numerator, denonimator)
+                self.assertTrue(is_root_correctly_rounded(x, root))
+
+        # Verify that corner cases and error handling match math.sqrt()
+        self.assertEqual(statistics._float_sqrt_of_frac(0, 1), 0.0)
+        with self.assertRaises(ValueError):
+            statistics._float_sqrt_of_frac(-1, 1)
+        with self.assertRaises(ValueError):
+            statistics._float_sqrt_of_frac(1, -1)
+
+        # Error handling for zero denominator matches that for Fraction(1, 0)
+        with self.assertRaises(ZeroDivisionError):
+            statistics._float_sqrt_of_frac(1, 0)
+
+        # The result is well defined if both inputs are negative
+        self.assertEqual(statistics._float_sqrt_of_frac(-2, -1), statistics._float_sqrt_of_frac(2, 1))
+
+    def test_decimal_sqrt_of_frac(self):
+        root: Decimal
+        numerator: int
+        denominator: int
+
+        for root, numerator, denominator in [
+            (Decimal('0.4481904599041192673635338663'), 200874688349065940678243576378, 1000000000000000000000000000000),  # No adj
+            (Decimal('0.7924949131383786609961759598'), 628048187350206338833590574929, 1000000000000000000000000000000),  # Adj up
+            (Decimal('0.8500554152289934068192208727'), 722594208960136395984391238251, 1000000000000000000000000000000),  # Adj down
+        ]:
+            with decimal.localcontext(decimal.DefaultContext):
+                self.assertEqual(statistics._decimal_sqrt_of_frac(numerator, denominator), root)
+
+            # Confirm expected root with a quad precision decimal computation
+            with decimal.localcontext(decimal.DefaultContext) as ctx:
+                ctx.prec *= 4
+                high_prec_ratio = Decimal(numerator) / Decimal(denominator)
+                ctx.rounding = decimal.ROUND_05UP
+                high_prec_root = high_prec_ratio.sqrt()
+            with decimal.localcontext(decimal.DefaultContext):
+                target_root = +high_prec_root
+            self.assertEqual(root, target_root)
+
+        # Verify that corner cases and error handling match Decimal.sqrt()
+        self.assertEqual(statistics._decimal_sqrt_of_frac(0, 1), 0.0)
+        with self.assertRaises(decimal.InvalidOperation):
+            statistics._decimal_sqrt_of_frac(-1, 1)
+        with self.assertRaises(decimal.InvalidOperation):
+            statistics._decimal_sqrt_of_frac(1, -1)
+
+        # Error handling for zero denominator matches that for Fraction(1, 0)
+        with self.assertRaises(ZeroDivisionError):
+            statistics._decimal_sqrt_of_frac(1, 0)
+
+        # The result is well defined if both inputs are negative
+        self.assertEqual(statistics._decimal_sqrt_of_frac(-2, -1), statistics._decimal_sqrt_of_frac(2, 1))
+
+
 class TestStdev(VarianceStdevMixin, NumericTestCase):
     # Tests for sample standard deviation.
     def setUp(self):
@@ -2151,7 +2234,7 @@ def test_compare_to_variance(self):
         # Test that stdev is, in fact, the square root of variance.
         data = [random.uniform(-2, 9) for _ in range(1000)]
         expected = math.sqrt(statistics.variance(data))
-        self.assertEqual(self.func(data), expected)
+        self.assertAlmostEqual(self.func(data), expected)
 
     def test_center_not_at_mean(self):
         data = (1.0, 2.0)
@@ -2219,10 +2302,12 @@ def test_error_cases(self):
         StatisticsError = statistics.StatisticsError
         with self.assertRaises(StatisticsError):
             geometric_mean([])                      # empty input
-        with self.assertRaises(StatisticsError):
-            geometric_mean([3.5, 0.0, 5.25])        # zero input
         with self.assertRaises(StatisticsError):
             geometric_mean([3.5, -4.0, 5.25])       # negative input
+        with self.assertRaises(StatisticsError):
+            geometric_mean([0.0, -4.0, 5.25])       # negative input with zero
+        with self.assertRaises(StatisticsError):
+            geometric_mean([3.5, -math.inf, 5.25])  # negative infinity
         with self.assertRaises(StatisticsError):
             geometric_mean(iter([]))                # empty iterator
         with self.assertRaises(TypeError):
@@ -2245,6 +2330,203 @@ def test_special_values(self):
         with self.assertRaises(ValueError):
             geometric_mean([Inf, -Inf])
 
+        # Cases with zero
+        self.assertEqual(geometric_mean([3, 0.0, 5]), 0.0)         # Any zero gives a zero
+        self.assertEqual(geometric_mean([3, -0.0, 5]), 0.0)        # Negative zero allowed
+        self.assertTrue(math.isnan(geometric_mean([0, NaN])))      # NaN beats zero
+        self.assertTrue(math.isnan(geometric_mean([0, Inf])))      # Because 0.0 * Inf -> NaN
+
+    def test_mixed_int_and_float(self):
+        # Regression test for b.p.o. issue #28327
+        geometric_mean = statistics.geometric_mean
+        expected_mean = 3.80675409583932
+        values = [
+            [2, 3, 5, 7],
+            [2, 3, 5, 7.0],
+            [2, 3, 5.0, 7.0],
+            [2, 3.0, 5.0, 7.0],
+            [2.0, 3.0, 5.0, 7.0],
+        ]
+        for v in values:
+            with self.subTest(v=v):
+                actual_mean = geometric_mean(v)
+                self.assertAlmostEqual(actual_mean, expected_mean, places=5)
+
+
+class TestKDE(unittest.TestCase):
+
+    @support.requires_resource('cpu')
+    def test_kde(self):
+        kde = statistics.kde
+        StatisticsError = statistics.StatisticsError
+
+        kernels = ['normal', 'gauss', 'logistic', 'sigmoid', 'rectangular',
+                   'uniform', 'triangular', 'parabolic', 'epanechnikov',
+                   'quartic', 'biweight', 'triweight', 'cosine']
+
+        sample = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2]
+
+        # The approximate integral of a PDF should be close to 1.0
+
+        def integrate(func, low, high, steps=10_000):
+            "Numeric approximation of a definite function integral."
+            dx = (high - low) / steps
+            midpoints = (low + (i + 1/2) * dx for i in range(steps))
+            return sum(map(func, midpoints)) * dx
+
+        for kernel in kernels:
+            with self.subTest(kernel=kernel):
+                f_hat = kde(sample, h=1.5, kernel=kernel)
+                area = integrate(f_hat, -20, 20)
+                self.assertAlmostEqual(area, 1.0, places=4)
+
+        # Check CDF against an integral of the PDF
+
+        data = [3, 5, 10, 12]
+        h = 2.3
+        x = 10.5
+        for kernel in kernels:
+            with self.subTest(kernel=kernel):
+                cdf = kde(data, h, kernel, cumulative=True)
+                f_hat = kde(data, h, kernel)
+                area = integrate(f_hat, -20, x, 100_000)
+                self.assertAlmostEqual(cdf(x), area, places=4)
+
+        # Check error cases
+
+        with self.assertRaises(StatisticsError):
+            kde([], h=1.0)                              # Empty dataset
+        with self.assertRaises(TypeError):
+            kde(['abc', 'def'], 1.5)                    # Non-numeric data
+        with self.assertRaises(TypeError):
+            kde(iter(sample), 1.5)                      # Data is not a sequence
+        with self.assertRaises(StatisticsError):
+            kde(sample, h=0.0)                          # Zero bandwidth
+        with self.assertRaises(StatisticsError):
+            kde(sample, h=-1.0)                         # Negative bandwidth
+        with self.assertRaises(TypeError):
+            kde(sample, h='str')                        # Wrong bandwidth type
+        with self.assertRaises(StatisticsError):
+            kde(sample, h=1.0, kernel='bogus')          # Invalid kernel
+        with self.assertRaises(TypeError):
+            kde(sample, 1.0, 'gauss', True)             # Positional cumulative argument
+
+        # Test name and docstring of the generated function
+
+        h = 1.5
+        kernel = 'cosine'
+        f_hat = kde(sample, h, kernel)
+        self.assertEqual(f_hat.__name__, 'pdf')
+        self.assertIn(kernel, f_hat.__doc__)
+        self.assertIn(repr(h), f_hat.__doc__)
+
+        # Test closed interval for the support boundaries.
+        # In particular, 'uniform' should non-zero at the boundaries.
+
+        f_hat = kde([0], 1.0, 'uniform')
+        self.assertEqual(f_hat(-1.0), 1/2)
+        self.assertEqual(f_hat(1.0), 1/2)
+
+        # Test online updates to data
+
+        data = [1, 2]
+        f_hat = kde(data, 5.0, 'triangular')
+        self.assertEqual(f_hat(100), 0.0)
+        data.append(100)
+        self.assertGreater(f_hat(100), 0.0)
+
+    def test_kde_kernel_invcdfs(self):
+        kernel_invcdfs = statistics._kernel_invcdfs
+        kde = statistics.kde
+
+        # Verify that cdf / invcdf will round trip
+        xarr = [i/100 for i in range(-100, 101)]
+        for kernel, invcdf in kernel_invcdfs.items():
+            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)
+
+    @support.requires_resource('cpu')
+    def test_kde_random(self):
+        kde_random = statistics.kde_random
+        StatisticsError = statistics.StatisticsError
+        kernels = ['normal', 'gauss', 'logistic', 'sigmoid', 'rectangular',
+                   'uniform', 'triangular', 'parabolic', 'epanechnikov',
+                   'quartic', 'biweight', 'triweight', 'cosine']
+        sample = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2]
+
+        # Smoke test
+
+        for kernel in kernels:
+            with self.subTest(kernel=kernel):
+                rand = kde_random(sample, h=1.5, kernel=kernel)
+                selections = [rand() for i in range(10)]
+
+        # Check error cases
+
+        with self.assertRaises(StatisticsError):
+            kde_random([], h=1.0)                       # Empty dataset
+        with self.assertRaises(TypeError):
+            kde_random(['abc', 'def'], 1.5)             # Non-numeric data
+        with self.assertRaises(TypeError):
+            kde_random(iter(sample), 1.5)               # Data is not a sequence
+        with self.assertRaises(StatisticsError):
+            kde_random(sample, h=-1.0)                  # Zero bandwidth
+        with self.assertRaises(StatisticsError):
+            kde_random(sample, h=0.0)                   # Negative bandwidth
+        with self.assertRaises(TypeError):
+            kde_random(sample, h='str')                 # Wrong bandwidth type
+        with self.assertRaises(StatisticsError):
+            kde_random(sample, h=1.0, kernel='bogus')   # Invalid kernel
+
+        # Test name and docstring of the generated function
+
+        h = 1.5
+        kernel = 'cosine'
+        rand = kde_random(sample, h, kernel)
+        self.assertEqual(rand.__name__, 'rand')
+        self.assertIn(kernel, rand.__doc__)
+        self.assertIn(repr(h), rand.__doc__)
+
+        # Approximate distribution test: Compare a random sample to the expected distribution
+
+        data = [-2.1, -1.3, -0.4, 1.9, 5.1, 6.2, 7.8, 14.3, 15.1, 15.3, 15.8, 17.0]
+        xarr = [x / 10 for x in range(-100, 250)]
+        # TODO: RUSTPYTHON - n originally 1_000_000 in CPython implementation but sorting is slow
+        n = 30_000
+        h = 1.75
+        dx = 0.1
+
+        def p_observed(x):
+            # P(x <= X < x+dx)
+            i = bisect.bisect_left(big_sample, x)
+            j = bisect.bisect_left(big_sample, x + dx)
+            return (j - i) / len(big_sample)
+
+        def p_expected(x):
+            # P(x <= X < x+dx)
+            return F_hat(x + dx) - F_hat(x)
+
+        for kernel in kernels:
+            with self.subTest(kernel=kernel):
+
+                rand = kde_random(data, h, kernel, seed=8675309**2)
+                big_sample = sorted([rand() for i in range(n)])
+                F_hat = statistics.kde(data, h, kernel, cumulative=True)
+
+                for x in xarr:
+                    # TODO : RUSTPYTHON - abs_tol=0.0005 in CPython implementation but smaller `n` increases variance
+                    self.assertTrue(math.isclose(p_observed(x), p_expected(x), abs_tol=0.005))
+
+        # Test online updates to data
+
+        data = [1, 2]
+        rand = kde_random(data, 5, 'triangular')
+        self.assertLess(max([rand() for i in range(5000)]), 10)
+        data.append(100)
+        self.assertGreater(max(rand() for i in range(5000)), 10)
+
 
 class TestQuantiles(unittest.TestCase):
 
@@ -2355,6 +2637,11 @@ def f(x):
             data = random.choices(range(100), k=k)
             q1, q2, q3 = quantiles(data, method='inclusive')
             self.assertEqual(q2, statistics.median(data))
+        # Base case with a single data point:  When estimating quantiles from
+        # a sample, we want to be able to add one sample point at a time,
+        # getting increasingly better estimates.
+        self.assertEqual(quantiles([10], n=4), [10.0, 10.0, 10.0])
+        self.assertEqual(quantiles([10], n=4, method='exclusive'), [10.0, 10.0, 10.0])
 
     def test_equal_inputs(self):
         quantiles = statistics.quantiles
@@ -2405,7 +2692,7 @@ def test_error_cases(self):
         with self.assertRaises(ValueError):
             quantiles([10, 20, 30], method='X') # method is unknown
         with self.assertRaises(StatisticsError):
-            quantiles([10], n=4)                # not enough data points
+            quantiles([], n=4)                  # not enough data points
         with self.assertRaises(TypeError):
             quantiles([10, None, 30], n=4)      # data is non-numeric
 
@@ -2464,6 +2751,95 @@ def test_different_scales(self):
         self.assertAlmostEqual(statistics.correlation(x, y), 1)
         self.assertAlmostEqual(statistics.covariance(x, y), 0.1)
 
+    def test_sqrtprod_helper_function_fundamentals(self):
+        # Verify that results are close to sqrt(x * y)
+        for i in range(100):
+            x = random.expovariate()
+            y = random.expovariate()
+            expected = math.sqrt(x * y)
+            actual = statistics._sqrtprod(x, y)
+            with self.subTest(x=x, y=y, expected=expected, actual=actual):
+                self.assertAlmostEqual(expected, actual)
+
+        x, y, target = 0.8035720646477457, 0.7957468097636939, 0.7996498651651661
+        self.assertEqual(statistics._sqrtprod(x, y), target)
+        self.assertNotEqual(math.sqrt(x * y), target)
+
+        # Test that range extremes avoid underflow and overflow
+        smallest = sys.float_info.min * sys.float_info.epsilon
+        self.assertEqual(statistics._sqrtprod(smallest, smallest), smallest)
+        biggest = sys.float_info.max
+        self.assertEqual(statistics._sqrtprod(biggest, biggest), biggest)
+
+        # Check special values and the sign of the result
+        special_values = [0.0, -0.0, 1.0, -1.0, 4.0, -4.0,
+                          math.nan, -math.nan, math.inf, -math.inf]
+        for x, y in itertools.product(special_values, repeat=2):
+            try:
+                expected = math.sqrt(x * y)
+            except ValueError:
+                expected = 'ValueError'
+            try:
+                actual = statistics._sqrtprod(x, y)
+            except ValueError:
+                actual = 'ValueError'
+            with self.subTest(x=x, y=y, expected=expected, actual=actual):
+                if isinstance(expected, str) and expected == 'ValueError':
+                    self.assertEqual(actual, 'ValueError')
+                    continue
+                self.assertIsInstance(actual, float)
+                if math.isnan(expected):
+                    self.assertTrue(math.isnan(actual))
+                    continue
+                self.assertEqual(actual, expected)
+                self.assertEqual(sign(actual), sign(expected))
+
+    @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
+    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
+        self.assertEqual(statistics._sqrtprod(x, y), target)
+        self.assertNotEqual(math.sqrt(x * y), target)
+
+        def reference_value(x: float, y: float) -> float:
+            x = decimal.Decimal(x)
+            y = decimal.Decimal(y)
+            with decimal.localcontext() as ctx:
+                ctx.prec = 200
+                return float((x * y).sqrt())
+
+        # Verify that the new function with improved accuracy
+        # agrees with a reference value more often than old version.
+        new_agreements = 0
+        old_agreements = 0
+        for i in range(10_000):
+            x = random.expovariate()
+            y = random.expovariate()
+            new = statistics._sqrtprod(x, y)
+            old = math.sqrt(x * y)
+            ref = reference_value(x, y)
+            new_agreements += (new == ref)
+            old_agreements += (old == ref)
+        self.assertGreater(new_agreements, old_agreements)
+
+    def test_correlation_spearman(self):
+        # https://statistics.laerd.com/statistical-guides/spearmans-rank-order-correlation-statistical-guide-2.php
+        # Compare with:
+        #     >>> import scipy.stats.mstats
+        #     >>> scipy.stats.mstats.spearmanr(reading, mathematics)
+        #     SpearmanrResult(correlation=0.6686960980480712, pvalue=0.03450954165178532)
+        # And Wolfram Alpha gives: 0.668696
+        #     https://www.wolframalpha.com/input?i=SpearmanRho%5B%7B56%2C+75%2C+45%2C+71%2C+61%2C+64%2C+58%2C+80%2C+76%2C+61%7D%2C+%7B66%2C+70%2C+40%2C+60%2C+65%2C+56%2C+59%2C+77%2C+67%2C+63%7D%5D
+        reading = [56, 75, 45, 71, 61, 64, 58, 80, 76, 61]
+        mathematics = [66, 70, 40, 60, 65, 56, 59, 77, 67, 63]
+        self.assertAlmostEqual(statistics.correlation(reading, mathematics, method='ranked'),
+                               0.6686960980480712)
+
+        with self.assertRaises(ValueError):
+            statistics.correlation(reading, mathematics, method='bad_method')
 
 class TestLinearRegression(unittest.TestCase):
 
@@ -2487,6 +2863,22 @@ def test_results(self):
             self.assertAlmostEqual(intercept, true_intercept)
             self.assertAlmostEqual(slope, true_slope)
 
+    def test_proportional(self):
+        x = [10, 20, 30, 40]
+        y = [180, 398, 610, 799]
+        slope, intercept = statistics.linear_regression(x, y, proportional=True)
+        self.assertAlmostEqual(slope, 20 + 1/150)
+        self.assertEqual(intercept, 0.0)
+
+    def test_float_output(self):
+        x = [Fraction(2, 3), Fraction(3, 4)]
+        y = [Fraction(4, 5), Fraction(5, 6)]
+        slope, intercept = statistics.linear_regression(x, y)
+        self.assertTrue(isinstance(slope, float))
+        self.assertTrue(isinstance(intercept, float))
+        slope, intercept = statistics.linear_regression(x, y, proportional=True)
+        self.assertTrue(isinstance(slope, float))
+        self.assertTrue(isinstance(intercept, float))
 
 class TestNormalDist:
 
@@ -2497,8 +2889,6 @@ class TestNormalDist:
     # inaccurate.  There isn't much we can do about this short of
     # implementing our own implementations from scratch.
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_slots(self):
         nd = self.module.NormalDist(300, 23)
         with self.assertRaises(TypeError):
@@ -2640,6 +3030,7 @@ def test_cdf(self):
         self.assertTrue(math.isnan(X.cdf(float('NaN'))))
 
     @support.skip_if_pgo_task
+    @support.requires_resource('cpu')
     def test_inv_cdf(self):
         NormalDist = self.module.NormalDist
 
@@ -2697,9 +3088,10 @@ def test_inv_cdf(self):
             iq.inv_cdf(1.0)                         # p is one
         with self.assertRaises(self.module.StatisticsError):
             iq.inv_cdf(1.1)                         # p over one
-        with self.assertRaises(self.module.StatisticsError):
-            iq = NormalDist(100, 0)                 # sigma is zero
-            iq.inv_cdf(0.5)
+
+        # Supported case:
+        iq = NormalDist(100, 0)                     # sigma is zero
+        self.assertEqual(iq.inv_cdf(0.5), 100)
 
         # Special values
         self.assertTrue(math.isnan(Z.inv_cdf(float('NaN'))))
@@ -2882,14 +3274,19 @@ def __init__(self, mu, sigma):
         nd = NormalDist(100, 15)
         self.assertNotEqual(nd, lnd)
 
-    def test_pickle_and_copy(self):
+    def test_copy(self):
         nd = self.module.NormalDist(37.5, 5.625)
         nd1 = copy.copy(nd)
         self.assertEqual(nd, nd1)
         nd2 = copy.deepcopy(nd)
         self.assertEqual(nd, nd2)
-        nd3 = pickle.loads(pickle.dumps(nd))
-        self.assertEqual(nd, nd3)
+
+    def test_pickle(self):
+        nd = self.module.NormalDist(37.5, 5.625)
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                pickled = pickle.loads(pickle.dumps(nd, protocol=proto))
+                self.assertEqual(nd, pickled)
 
     def test_hashability(self):
         ND = self.module.NormalDist
@@ -2911,7 +3308,7 @@ def setUp(self):
 
     def tearDown(self):
         sys.modules['statistics'] = statistics
- 
+
 
 @unittest.skipUnless(c_statistics, 'requires _statistics')
 class TestNormalDistC(unittest.TestCase, TestNormalDist):
@@ -2928,6 +3325,8 @@ def tearDown(self):
 def load_tests(loader, tests, ignore):
     """Used for doctest/unittest integration."""
     tests.addTests(doctest.DocTestSuite())
+    if sys.float_repr_style == 'short':
+        tests.addTests(doctest.DocTestSuite(statistics))
     return tests
 
 
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
new file mode 100644
index 0000000000..6b766272a3
--- /dev/null
+++ b/Lib/test/test_str.py
@@ -0,0 +1,2804 @@
+""" Test script for the Unicode implementation.
+
+Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""
+import _string
+import codecs
+import datetime
+import itertools
+import operator
+import pickle
+import struct
+import sys
+import textwrap
+import unicodedata
+import unittest
+import warnings
+from test.support import warnings_helper
+from test import support, string_tests
+from test.support.script_helper import assert_python_failure
+
+try:
+    import _testcapi
+except ImportError:
+    _testcapi = None
+
+# Error handling (bad decoder return)
+def search_function(encoding):
+    def decode1(input, errors="strict"):
+        return 42 # not a tuple
+    def encode1(input, errors="strict"):
+        return 42 # not a tuple
+    def encode2(input, errors="strict"):
+        return (42, 42) # no unicode
+    def decode2(input, errors="strict"):
+        return (42, 42) # no unicode
+    if encoding=="test.unicode1":
+        return (encode1, decode1, None, None)
+    elif encoding=="test.unicode2":
+        return (encode2, decode2, None, None)
+    else:
+        return None
+
+def duplicate_string(text):
+    """
+    Try to get a fresh clone of the specified text:
+    new object with a reference count of 1.
+
+    This is a best-effort: latin1 single letters and the empty
+    string ('') are singletons and cannot be cloned.
+    """
+    return text.encode().decode()
+
+class StrSubclass(str):
+    pass
+
+class OtherStrSubclass(str):
+    pass
+
+class WithStr:
+    def __init__(self, value):
+        self.value = value
+    def __str__(self):
+        return self.value
+
+class WithRepr:
+    def __init__(self, value):
+        self.value = value
+    def __repr__(self):
+        return self.value
+
+class StrTest(string_tests.StringLikeTest,
+        string_tests.MixinStrUnicodeTest,
+        unittest.TestCase):
+
+    type2test = str
+
+    def setUp(self):
+        codecs.register(search_function)
+        self.addCleanup(codecs.unregister, search_function)
+
+    def checkequalnofix(self, result, object, methodname, *args):
+        method = getattr(object, methodname)
+        realresult = method(*args)
+        self.assertEqual(realresult, result)
+        self.assertTrue(type(realresult) is type(result))
+
+        # if the original is returned make sure that
+        # this doesn't happen with subclasses
+        if realresult is object:
+            class usub(str):
+                def __repr__(self):
+                    return 'usub(%r)' % str.__repr__(self)
+            object = usub(object)
+            method = getattr(object, methodname)
+            realresult = method(*args)
+            self.assertEqual(realresult, result)
+            self.assertTrue(object is not realresult)
+
+    def assertTypedEqual(self, actual, expected):
+        self.assertIs(type(actual), type(expected))
+        self.assertEqual(actual, expected)
+
+    def test_literals(self):
+        self.assertEqual('\xff', '\u00ff')
+        self.assertEqual('\uffff', '\U0000ffff')
+        self.assertRaises(SyntaxError, eval, '\'\\Ufffffffe\'')
+        self.assertRaises(SyntaxError, eval, '\'\\Uffffffff\'')
+        self.assertRaises(SyntaxError, eval, '\'\\U%08x\'' % 0x110000)
+        # 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'")
+        self.assertEqual(ascii('ab\\'), "'ab\\\\'")
+        self.assertEqual(ascii('\\c'), "'\\\\c'")
+        self.assertEqual(ascii('\\'), "'\\\\'")
+        self.assertEqual(ascii('\n'), "'\\n'")
+        self.assertEqual(ascii('\r'), "'\\r'")
+        self.assertEqual(ascii('\t'), "'\\t'")
+        self.assertEqual(ascii('\b'), "'\\x08'")
+        self.assertEqual(ascii("'\""), """'\\'"'""")
+        self.assertEqual(ascii("'\""), """'\\'"'""")
+        self.assertEqual(ascii("'"), '''"'"''')
+        self.assertEqual(ascii('"'), """'"'""")
+        latin1repr = (
+            "'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"
+            "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"
+            "\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHI"
+            "JKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f"
+            "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d"
+            "\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b"
+            "\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9"
+            "\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7"
+            "\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5"
+            "\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3"
+            "\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1"
+            "\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef"
+            "\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd"
+            "\\xfe\\xff'")
+        testrepr = ascii(''.join(map(chr, range(256))))
+        self.assertEqual(testrepr, latin1repr)
+        # Test ascii works on wide unicode escapes without overflow.
+        self.assertEqual(ascii("\U00010000" * 39 + "\uffff" * 4096),
+                            ascii("\U00010000" * 39 + "\uffff" * 4096))
+
+        self.assertTypedEqual(ascii('\U0001f40d'), r"'\U0001f40d'")
+        self.assertTypedEqual(ascii(StrSubclass('abc')), "'abc'")
+        self.assertTypedEqual(ascii(WithRepr('<abc>')), '<abc>')
+        self.assertTypedEqual(ascii(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
+        self.assertTypedEqual(ascii(WithRepr('<\U0001f40d>')), r'<\U0001f40d>')
+        self.assertTypedEqual(ascii(WithRepr(StrSubclass('<\U0001f40d>'))), r'<\U0001f40d>')
+        self.assertRaises(TypeError, ascii, WithRepr(b'byte-repr'))
+
+    def test_repr(self):
+        # Test basic sanity of repr()
+        self.assertEqual(repr('abc'), "'abc'")
+        self.assertEqual(repr('ab\\c'), "'ab\\\\c'")
+        self.assertEqual(repr('ab\\'), "'ab\\\\'")
+        self.assertEqual(repr('\\c'), "'\\\\c'")
+        self.assertEqual(repr('\\'), "'\\\\'")
+        self.assertEqual(repr('\n'), "'\\n'")
+        self.assertEqual(repr('\r'), "'\\r'")
+        self.assertEqual(repr('\t'), "'\\t'")
+        self.assertEqual(repr('\b'), "'\\x08'")
+        self.assertEqual(repr("'\""), """'\\'"'""")
+        self.assertEqual(repr("'\""), """'\\'"'""")
+        self.assertEqual(repr("'"), '''"'"''')
+        self.assertEqual(repr('"'), """'"'""")
+        latin1repr = (
+            "'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"
+            "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"
+            "\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHI"
+            "JKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f"
+            "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d"
+            "\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b"
+            "\\x9c\\x9d\\x9e\\x9f\\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9"
+            "\xaa\xab\xac\\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7"
+            "\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5"
+            "\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3"
+            "\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1"
+            "\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
+            "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd"
+            "\xfe\xff'")
+        testrepr = repr(''.join(map(chr, range(256))))
+        self.assertEqual(testrepr, latin1repr)
+        # Test repr works on wide unicode escapes without overflow.
+        self.assertEqual(repr("\U00010000" * 39 + "\uffff" * 4096),
+                            repr("\U00010000" * 39 + "\uffff" * 4096))
+
+        self.assertTypedEqual(repr('\U0001f40d'), "'\U0001f40d'")
+        self.assertTypedEqual(repr(StrSubclass('abc')), "'abc'")
+        self.assertTypedEqual(repr(WithRepr('<abc>')), '<abc>')
+        self.assertTypedEqual(repr(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
+        self.assertTypedEqual(repr(WithRepr('<\U0001f40d>')), '<\U0001f40d>')
+        self.assertTypedEqual(repr(WithRepr(StrSubclass('<\U0001f40d>'))), StrSubclass('<\U0001f40d>'))
+        self.assertRaises(TypeError, repr, WithRepr(b'byte-repr'))
+
+    def test_iterators(self):
+        # Make sure unicode objects have an __iter__ method
+        it = "\u1111\u2222\u3333".__iter__()
+        self.assertEqual(next(it), "\u1111")
+        self.assertEqual(next(it), "\u2222")
+        self.assertEqual(next(it), "\u3333")
+        self.assertRaises(StopIteration, next, it)
+
+    def test_iterators_invocation(self):
+        cases = [type(iter('abc')), type(iter('🚀'))]
+        for cls in cases:
+            with self.subTest(cls=cls):
+                self.assertRaises(TypeError, cls)
+
+    def test_iteration(self):
+        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
+        for case in cases:
+            with self.subTest(string=case):
+                self.assertEqual(case, "".join(iter(case)))
+
+    def test_exhausted_iterator(self):
+        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
+        for case in cases:
+            with self.subTest(case=case):
+                iterator = iter(case)
+                tuple(iterator)
+                self.assertRaises(StopIteration, next, iterator)
+
+    def test_pickle_iterator(self):
+        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
+        for case in cases:
+            with self.subTest(case=case):
+                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+                    it = iter(case)
+                    with self.subTest(proto=proto):
+                        pickled = "".join(pickle.loads(pickle.dumps(it, proto)))
+                        self.assertEqual(case, pickled)
+
+    def test_count(self):
+        string_tests.StringLikeTest.test_count(self)
+        # check mixed argument types
+        self.checkequalnofix(3,  'aaa', 'count', 'a')
+        self.checkequalnofix(0,  'aaa', 'count', 'b')
+        self.checkequalnofix(3, 'aaa', 'count',  'a')
+        self.checkequalnofix(0, 'aaa', 'count',  'b')
+        self.checkequalnofix(0, 'aaa', 'count',  'b')
+        self.checkequalnofix(1, 'aaa', 'count',  'a', -1)
+        self.checkequalnofix(3, 'aaa', 'count',  'a', -10)
+        self.checkequalnofix(2, 'aaa', 'count',  'a', 0, -1)
+        self.checkequalnofix(0, 'aaa', 'count',  'a', 0, -10)
+        # test mixed kinds
+        self.checkequal(10, '\u0102' + 'a' * 10, 'count', 'a')
+        self.checkequal(10, '\U00100304' + 'a' * 10, 'count', 'a')
+        self.checkequal(10, '\U00100304' + '\u0102' * 10, 'count', '\u0102')
+        self.checkequal(0, 'a' * 10, 'count', '\u0102')
+        self.checkequal(0, 'a' * 10, 'count', '\U00100304')
+        self.checkequal(0, '\u0102' * 10, 'count', '\U00100304')
+        self.checkequal(10, '\u0102' + 'a_' * 10, 'count', 'a_')
+        self.checkequal(10, '\U00100304' + 'a_' * 10, 'count', 'a_')
+        self.checkequal(10, '\U00100304' + '\u0102_' * 10, 'count', '\u0102_')
+        self.checkequal(0, 'a' * 10, 'count', 'a\u0102')
+        self.checkequal(0, 'a' * 10, 'count', 'a\U00100304')
+        self.checkequal(0, '\u0102' * 10, 'count', '\u0102\U00100304')
+        # test subclass
+        class MyStr(str):
+            pass
+        self.checkequal(3, MyStr('aaa'), 'count', 'a')
+
+    def test_find(self):
+        string_tests.StringLikeTest.test_find(self)
+        # test implementation details of the memchr fast path
+        self.checkequal(100, 'a' * 100 + '\u0102', 'find', '\u0102')
+        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0201')
+        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0120')
+        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0220')
+        self.checkequal(100, 'a' * 100 + '\U00100304', 'find', '\U00100304')
+        self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00100204')
+        self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00102004')
+        # check mixed argument types
+        self.checkequalnofix(0,  'abcdefghiabc', 'find', 'abc')
+        self.checkequalnofix(9,  'abcdefghiabc', 'find', 'abc', 1)
+        self.checkequalnofix(-1, 'abcdefghiabc', 'find', 'def', 4)
+
+        # test utf-8 non-ascii char
+        self.checkequal(0, 'тест', 'find', 'т')
+        self.checkequal(3, 'тест', 'find', 'т', 1)
+        self.checkequal(-1, 'тест', 'find', 'т', 1, 3)
+        self.checkequal(-1, 'тест', 'find', 'e')  # english `e`
+        # test utf-8 non-ascii slice
+        self.checkequal(1, 'тест тест', 'find', 'ес')
+        self.checkequal(1, 'тест тест', 'find', 'ес', 1)
+        self.checkequal(1, 'тест тест', 'find', 'ес', 1, 3)
+        self.checkequal(6, 'тест тест', 'find', 'ес', 2)
+        self.checkequal(-1, 'тест тест', 'find', 'ес', 6, 7)
+        self.checkequal(-1, 'тест тест', 'find', 'ес', 7)
+        self.checkequal(-1, 'тест тест', 'find', 'ec')  # english `ec`
+
+        self.assertRaises(TypeError, 'hello'.find)
+        self.assertRaises(TypeError, 'hello'.find, 42)
+        # test mixed kinds
+        self.checkequal(100, '\u0102' * 100 + 'a', 'find', 'a')
+        self.checkequal(100, '\U00100304' * 100 + 'a', 'find', 'a')
+        self.checkequal(100, '\U00100304' * 100 + '\u0102', 'find', '\u0102')
+        self.checkequal(-1, 'a' * 100, 'find', '\u0102')
+        self.checkequal(-1, 'a' * 100, 'find', '\U00100304')
+        self.checkequal(-1, '\u0102' * 100, 'find', '\U00100304')
+        self.checkequal(100, '\u0102' * 100 + 'a_', 'find', 'a_')
+        self.checkequal(100, '\U00100304' * 100 + 'a_', 'find', 'a_')
+        self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'find', '\u0102_')
+        self.checkequal(-1, 'a' * 100, 'find', 'a\u0102')
+        self.checkequal(-1, 'a' * 100, 'find', 'a\U00100304')
+        self.checkequal(-1, '\u0102' * 100, 'find', '\u0102\U00100304')
+
+    def test_rfind(self):
+        string_tests.StringLikeTest.test_rfind(self)
+        # test implementation details of the memrchr fast path
+        self.checkequal(0, '\u0102' + 'a' * 100 , 'rfind', '\u0102')
+        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0201')
+        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0120')
+        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0220')
+        self.checkequal(0, '\U00100304' + 'a' * 100, 'rfind', '\U00100304')
+        self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00100204')
+        self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00102004')
+        # check mixed argument types
+        self.checkequalnofix(9,   'abcdefghiabc', 'rfind', 'abc')
+        self.checkequalnofix(12,  'abcdefghiabc', 'rfind', '')
+        self.checkequalnofix(12, 'abcdefghiabc', 'rfind',  '')
+        # test utf-8 non-ascii char
+        self.checkequal(1, 'тест', 'rfind', 'е')
+        self.checkequal(1, 'тест', 'rfind', 'е', 1)
+        self.checkequal(-1, 'тест', 'rfind', 'е', 2)
+        self.checkequal(-1, 'тест', 'rfind', 'e')  # english `e`
+        # test utf-8 non-ascii slice
+        self.checkequal(6, 'тест тест', 'rfind', 'ес')
+        self.checkequal(6, 'тест тест', 'rfind', 'ес', 1)
+        self.checkequal(1, 'тест тест', 'rfind', 'ес', 1, 3)
+        self.checkequal(6, 'тест тест', 'rfind', 'ес', 2)
+        self.checkequal(-1, 'тест тест', 'rfind', 'ес', 6, 7)
+        self.checkequal(-1, 'тест тест', 'rfind', 'ес', 7)
+        self.checkequal(-1, 'тест тест', 'rfind', 'ec')  # english `ec`
+        # test mixed kinds
+        self.checkequal(0, 'a' + '\u0102' * 100, 'rfind', 'a')
+        self.checkequal(0, 'a' + '\U00100304' * 100, 'rfind', 'a')
+        self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rfind', '\u0102')
+        self.checkequal(-1, 'a' * 100, 'rfind', '\u0102')
+        self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304')
+        self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304')
+        self.checkequal(0, '_a' + '\u0102' * 100, 'rfind', '_a')
+        self.checkequal(0, '_a' + '\U00100304' * 100, 'rfind', '_a')
+        self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rfind', '_\u0102')
+        self.checkequal(-1, 'a' * 100, 'rfind', '\u0102a')
+        self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304a')
+        self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304\u0102')
+
+    def test_index(self):
+        string_tests.StringLikeTest.test_index(self)
+        self.checkequalnofix(0, 'abcdefghiabc', 'index',  '')
+        self.checkequalnofix(3, 'abcdefghiabc', 'index',  'def')
+        self.checkequalnofix(0, 'abcdefghiabc', 'index',  'abc')
+        self.checkequalnofix(9, 'abcdefghiabc', 'index',  'abc', 1)
+        self.assertRaises(ValueError, 'abcdefghiabc'.index, 'hib')
+        self.assertRaises(ValueError, 'abcdefghiab'.index,  'abc', 1)
+        self.assertRaises(ValueError, 'abcdefghi'.index,  'ghi', 8)
+        self.assertRaises(ValueError, 'abcdefghi'.index,  'ghi', -1)
+        # test mixed kinds
+        self.checkequal(100, '\u0102' * 100 + 'a', 'index', 'a')
+        self.checkequal(100, '\U00100304' * 100 + 'a', 'index', 'a')
+        self.checkequal(100, '\U00100304' * 100 + '\u0102', 'index', '\u0102')
+        self.assertRaises(ValueError, ('a' * 100).index, '\u0102')
+        self.assertRaises(ValueError, ('a' * 100).index, '\U00100304')
+        self.assertRaises(ValueError, ('\u0102' * 100).index, '\U00100304')
+        self.checkequal(100, '\u0102' * 100 + 'a_', 'index', 'a_')
+        self.checkequal(100, '\U00100304' * 100 + 'a_', 'index', 'a_')
+        self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'index', '\u0102_')
+        self.assertRaises(ValueError, ('a' * 100).index, 'a\u0102')
+        self.assertRaises(ValueError, ('a' * 100).index, 'a\U00100304')
+        self.assertRaises(ValueError, ('\u0102' * 100).index, '\u0102\U00100304')
+
+    def test_rindex(self):
+        string_tests.StringLikeTest.test_rindex(self)
+        self.checkequalnofix(12, 'abcdefghiabc', 'rindex',  '')
+        self.checkequalnofix(3,  'abcdefghiabc', 'rindex',  'def')
+        self.checkequalnofix(9,  'abcdefghiabc', 'rindex',  'abc')
+        self.checkequalnofix(0,  'abcdefghiabc', 'rindex',  'abc', 0, -1)
+
+        self.assertRaises(ValueError, 'abcdefghiabc'.rindex,  'hib')
+        self.assertRaises(ValueError, 'defghiabc'.rindex,  'def', 1)
+        self.assertRaises(ValueError, 'defghiabc'.rindex,  'abc', 0, -1)
+        self.assertRaises(ValueError, 'abcdefghi'.rindex,  'ghi', 0, 8)
+        self.assertRaises(ValueError, 'abcdefghi'.rindex,  'ghi', 0, -1)
+        # test mixed kinds
+        self.checkequal(0, 'a' + '\u0102' * 100, 'rindex', 'a')
+        self.checkequal(0, 'a' + '\U00100304' * 100, 'rindex', 'a')
+        self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rindex', '\u0102')
+        self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102')
+        self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304')
+        self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304')
+        self.checkequal(0, '_a' + '\u0102' * 100, 'rindex', '_a')
+        self.checkequal(0, '_a' + '\U00100304' * 100, 'rindex', '_a')
+        self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rindex', '_\u0102')
+        self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102a')
+        self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304a')
+        self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304\u0102')
+
+    def test_maketrans_translate(self):
+        # these work with plain translate()
+        self.checkequalnofix('bbbc', 'abababc', 'translate',
+                             {ord('a'): None})
+        self.checkequalnofix('iiic', 'abababc', 'translate',
+                             {ord('a'): None, ord('b'): ord('i')})
+        self.checkequalnofix('iiix', 'abababc', 'translate',
+                             {ord('a'): None, ord('b'): ord('i'), ord('c'): 'x'})
+        self.checkequalnofix('c', 'abababc', 'translate',
+                             {ord('a'): None, ord('b'): ''})
+        self.checkequalnofix('xyyx', 'xzx', 'translate',
+                             {ord('z'): 'yy'})
+
+        # this needs maketrans()
+        self.checkequalnofix('abababc', 'abababc', 'translate',
+                             {'b': '<i>'})
+        tbl = self.type2test.maketrans({'a': None, 'b': '<i>'})
+        self.checkequalnofix('<i><i><i>c', 'abababc', 'translate', tbl)
+        # test alternative way of calling maketrans()
+        tbl = self.type2test.maketrans('abc', 'xyz', 'd')
+        self.checkequalnofix('xyzzy', 'abdcdcbdddd', 'translate', tbl)
+
+        # various tests switching from ASCII to latin1 or the opposite;
+        # same length, remove a letter, or replace with a longer string.
+        self.assertEqual("[a]".translate(str.maketrans('a', 'X')),
+                         "[X]")
+        self.assertEqual("[a]".translate(str.maketrans({'a': 'X'})),
+                         "[X]")
+        self.assertEqual("[a]".translate(str.maketrans({'a': None})),
+                         "[]")
+        self.assertEqual("[a]".translate(str.maketrans({'a': 'XXX'})),
+                         "[XXX]")
+        self.assertEqual("[a]".translate(str.maketrans({'a': '\xe9'})),
+                         "[\xe9]")
+        self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '123'})),
+                         "x123")
+        self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '\xe9'})),
+                         "x\xe9")
+
+        # test non-ASCII (don't take the fast-path)
+        self.assertEqual("[a]".translate(str.maketrans({'a': '<\xe9>'})),
+                         "[<\xe9>]")
+        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': 'a'})),
+                         "[a]")
+        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': None})),
+                         "[]")
+        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': '123'})),
+                         "[123]")
+        self.assertEqual("[a\xe9]".translate(str.maketrans({'a': '<\u20ac>'})),
+                         "[<\u20ac>\xe9]")
+
+        # invalid Unicode characters
+        invalid_char = 0x10ffff+1
+        for before in "a\xe9\u20ac\U0010ffff":
+            mapping = str.maketrans({before: invalid_char})
+            text = "[%s]" % before
+            self.assertRaises(ValueError, text.translate, mapping)
+
+        # errors
+        self.assertRaises(TypeError, self.type2test.maketrans)
+        self.assertRaises(ValueError, self.type2test.maketrans, 'abc', 'defg')
+        self.assertRaises(TypeError, self.type2test.maketrans, 2, 'def')
+        self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 2)
+        self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def', 2)
+        self.assertRaises(ValueError, self.type2test.maketrans, {'xy': 2})
+        self.assertRaises(TypeError, self.type2test.maketrans, {(1,): 2})
+
+        self.assertRaises(TypeError, 'hello'.translate)
+        self.assertRaises(TypeError, 'abababc'.translate, 'abc', 'xyz')
+
+    def test_split(self):
+        string_tests.StringLikeTest.test_split(self)
+
+        # test mixed kinds
+        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
+            left *= 9
+            right *= 9
+            for delim in ('c', '\u0102', '\U00010302'):
+                self.checkequal([left + right],
+                                left + right, 'split', delim)
+                self.checkequal([left, right],
+                                left + delim + right, 'split', delim)
+                self.checkequal([left + right],
+                                left + right, 'split', delim * 2)
+                self.checkequal([left, right],
+                                left + delim * 2 + right, 'split', delim *2)
+
+    def test_rsplit(self):
+        string_tests.StringLikeTest.test_rsplit(self)
+        # test mixed kinds
+        for left, right in ('ba', 'юё', '\u0101\u0100', '\U00010301\U00010300'):
+            left *= 9
+            right *= 9
+            for delim in ('c', 'ы', '\u0102', '\U00010302'):
+                self.checkequal([left + right],
+                                left + right, 'rsplit', delim)
+                self.checkequal([left, right],
+                                left + delim + right, 'rsplit', delim)
+                self.checkequal([left + right],
+                                left + right, 'rsplit', delim * 2)
+                self.checkequal([left, right],
+                                left + delim * 2 + right, 'rsplit', delim *2)
+
+            # Check `None` as well:
+            self.checkequal([left + right],
+                             left + right, 'rsplit', None)
+
+    def test_partition(self):
+        string_tests.StringLikeTest.test_partition(self)
+        # test mixed kinds
+        self.checkequal(('ABCDEFGH', '', ''), 'ABCDEFGH', 'partition', '\u4200')
+        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
+            left *= 9
+            right *= 9
+            for delim in ('c', '\u0102', '\U00010302'):
+                self.checkequal((left + right, '', ''),
+                                left + right, 'partition', delim)
+                self.checkequal((left, delim, right),
+                                left + delim + right, 'partition', delim)
+                self.checkequal((left + right, '', ''),
+                                left + right, 'partition', delim * 2)
+                self.checkequal((left, delim * 2, right),
+                                left + delim * 2 + right, 'partition', delim * 2)
+
+    def test_rpartition(self):
+        string_tests.StringLikeTest.test_rpartition(self)
+        # test mixed kinds
+        self.checkequal(('', '', 'ABCDEFGH'), 'ABCDEFGH', 'rpartition', '\u4200')
+        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
+            left *= 9
+            right *= 9
+            for delim in ('c', '\u0102', '\U00010302'):
+                self.checkequal(('', '', left + right),
+                                left + right, 'rpartition', delim)
+                self.checkequal((left, delim, right),
+                                left + delim + right, 'rpartition', delim)
+                self.checkequal(('', '', left + right),
+                                left + right, 'rpartition', delim * 2)
+                self.checkequal((left, delim * 2, right),
+                                left + delim * 2 + right, 'rpartition', delim * 2)
+
+    def test_join(self):
+        string_tests.StringLikeTest.test_join(self)
+
+        class MyWrapper:
+            def __init__(self, sval): self.sval = sval
+            def __str__(self): return self.sval
+
+        # mixed arguments
+        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
+        self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
+        self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
+        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
+        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
+        self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
+        self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
+        self.checkraises(TypeError, ' ', 'join', ['1', '2', MyWrapper('foo')])
+        self.checkraises(TypeError, ' ', 'join', ['1', '2', '3', bytes()])
+        self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
+        self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
+
+    @unittest.skipIf(sys.maxsize > 2**32,
+        'needs too much memory on a 64-bit platform')
+    def test_join_overflow(self):
+        size = int(sys.maxsize**0.5) + 1
+        seq = ('A' * size,) * size
+        self.assertRaises(OverflowError, ''.join, seq)
+
+    def test_replace(self):
+        string_tests.StringLikeTest.test_replace(self)
+
+        # method call forwarded from str implementation because of unicode argument
+        self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
+        self.assertRaises(TypeError, 'replace'.replace, "r", 42)
+        # test mixed kinds
+        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
+            left *= 9
+            right *= 9
+            for delim in ('c', '\u0102', '\U00010302'):
+                for repl in ('d', '\u0103', '\U00010303'):
+                    self.checkequal(left + right,
+                                    left + right, 'replace', delim, repl)
+                    self.checkequal(left + repl + right,
+                                    left + delim + right,
+                                    'replace', delim, repl)
+                    self.checkequal(left + right,
+                                    left + right, 'replace', delim * 2, repl)
+                    self.checkequal(left + repl + right,
+                                    left + delim * 2 + right,
+                                    'replace', delim * 2, repl)
+
+    @support.cpython_only
+    def test_replace_id(self):
+        pattern = 'abc'
+        text = 'abc def'
+        self.assertIs(text.replace(pattern, pattern), text)
+
+    def test_repeat_id_preserving(self):
+        a = '123abc1@'
+        b = '456zyx-+'
+        self.assertEqual(id(a), id(a))
+        self.assertNotEqual(id(a), id(b))
+        self.assertNotEqual(id(a), id(a * -4))
+        self.assertNotEqual(id(a), id(a * 0))
+        self.assertEqual(id(a), id(a * 1))
+        self.assertEqual(id(a), id(1 * a))
+        self.assertNotEqual(id(a), id(a * 2))
+
+        class SubStr(str):
+            pass
+
+        s = SubStr('qwerty()')
+        self.assertEqual(id(s), id(s))
+        self.assertNotEqual(id(s), id(s * -4))
+        self.assertNotEqual(id(s), id(s * 0))
+        self.assertNotEqual(id(s), id(s * 1))
+        self.assertNotEqual(id(s), id(1 * s))
+        self.assertNotEqual(id(s), id(s * 2))
+
+    def test_bytes_comparison(self):
+        with warnings_helper.check_warnings():
+            warnings.simplefilter('ignore', BytesWarning)
+            self.assertEqual('abc' == b'abc', False)
+            self.assertEqual('abc' != b'abc', True)
+            self.assertEqual('abc' == bytearray(b'abc'), False)
+            self.assertEqual('abc' != bytearray(b'abc'), True)
+
+    def test_comparison(self):
+        # Comparisons:
+        self.assertEqual('abc', 'abc')
+        self.assertTrue('abcd' > 'abc')
+        self.assertTrue('abc' < 'abcd')
+
+        if 0:
+            # Move these tests to a Unicode collation module test...
+            # Testing UTF-16 code point order comparisons...
+
+            # No surrogates, no fixup required.
+            self.assertTrue('\u0061' < '\u20ac')
+            # Non surrogate below surrogate value, no fixup required
+            self.assertTrue('\u0061' < '\ud800\udc02')
+
+            # Non surrogate above surrogate value, fixup required
+            def test_lecmp(s, s2):
+                self.assertTrue(s < s2)
+
+            def test_fixup(s):
+                s2 = '\ud800\udc01'
+                test_lecmp(s, s2)
+                s2 = '\ud900\udc01'
+                test_lecmp(s, s2)
+                s2 = '\uda00\udc01'
+                test_lecmp(s, s2)
+                s2 = '\udb00\udc01'
+                test_lecmp(s, s2)
+                s2 = '\ud800\udd01'
+                test_lecmp(s, s2)
+                s2 = '\ud900\udd01'
+                test_lecmp(s, s2)
+                s2 = '\uda00\udd01'
+                test_lecmp(s, s2)
+                s2 = '\udb00\udd01'
+                test_lecmp(s, s2)
+                s2 = '\ud800\ude01'
+                test_lecmp(s, s2)
+                s2 = '\ud900\ude01'
+                test_lecmp(s, s2)
+                s2 = '\uda00\ude01'
+                test_lecmp(s, s2)
+                s2 = '\udb00\ude01'
+                test_lecmp(s, s2)
+                s2 = '\ud800\udfff'
+                test_lecmp(s, s2)
+                s2 = '\ud900\udfff'
+                test_lecmp(s, s2)
+                s2 = '\uda00\udfff'
+                test_lecmp(s, s2)
+                s2 = '\udb00\udfff'
+                test_lecmp(s, s2)
+
+                test_fixup('\ue000')
+                test_fixup('\uff61')
+
+        # Surrogates on both sides, no fixup required
+        self.assertTrue('\ud800\udc02' < '\ud84d\udc56')
+
+    def test_islower(self):
+        super().test_islower()
+        self.checkequalnofix(False, '\u1FFc', 'islower')
+        self.assertFalse('\u2167'.islower())
+        self.assertTrue('\u2177'.islower())
+        # non-BMP, uppercase
+        self.assertFalse('\U00010401'.islower())
+        self.assertFalse('\U00010427'.islower())
+        # non-BMP, lowercase
+        self.assertTrue('\U00010429'.islower())
+        self.assertTrue('\U0001044E'.islower())
+        # non-BMP, non-cased
+        self.assertFalse('\U0001F40D'.islower())
+        self.assertFalse('\U0001F46F'.islower())
+
+    def test_isupper(self):
+        super().test_isupper()
+        self.checkequalnofix(False, '\u1FFc', 'isupper')
+        self.assertTrue('\u2167'.isupper())
+        self.assertFalse('\u2177'.isupper())
+        # non-BMP, uppercase
+        self.assertTrue('\U00010401'.isupper())
+        self.assertTrue('\U00010427'.isupper())
+        # non-BMP, lowercase
+        self.assertFalse('\U00010429'.isupper())
+        self.assertFalse('\U0001044E'.isupper())
+        # non-BMP, non-cased
+        self.assertFalse('\U0001F40D'.isupper())
+        self.assertFalse('\U0001F46F'.isupper())
+
+    def test_istitle(self):
+        super().test_istitle()
+        self.checkequalnofix(True, '\u1FFc', 'istitle')
+        self.checkequalnofix(True, 'Greek \u1FFcitlecases ...', 'istitle')
+
+        # non-BMP, uppercase + lowercase
+        self.assertTrue('\U00010401\U00010429'.istitle())
+        self.assertTrue('\U00010427\U0001044E'.istitle())
+        # apparently there are no titlecased (Lt) non-BMP chars in Unicode 6
+        for ch in ['\U00010429', '\U0001044E', '\U0001F40D', '\U0001F46F']:
+            self.assertFalse(ch.istitle(), '{!a} is not title'.format(ch))
+
+    def test_isspace(self):
+        super().test_isspace()
+        self.checkequalnofix(True, '\u2000', 'isspace')
+        self.checkequalnofix(True, '\u200a', 'isspace')
+        self.checkequalnofix(False, '\u2014', 'isspace')
+        # There are no non-BMP whitespace chars as of Unicode 12.
+        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
+                   '\U0001F40D', '\U0001F46F']:
+            self.assertFalse(ch.isspace(), '{!a} is not space.'.format(ch))
+
+    @support.requires_resource('cpu')
+    def test_isspace_invariant(self):
+        for codepoint in range(sys.maxunicode + 1):
+            char = chr(codepoint)
+            bidirectional = unicodedata.bidirectional(char)
+            category = unicodedata.category(char)
+            self.assertEqual(char.isspace(),
+                             (bidirectional in ('WS', 'B', 'S')
+                              or category == 'Zs'))
+
+    def test_isalnum(self):
+        super().test_isalnum()
+        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
+                   '\U0001D7F6', '\U00011066', '\U000104A0', '\U0001F107']:
+            self.assertTrue(ch.isalnum(), '{!a} is alnum.'.format(ch))
+
+    def test_isalpha(self):
+        super().test_isalpha()
+        self.checkequalnofix(True, '\u1FFc', 'isalpha')
+        # non-BMP, cased
+        self.assertTrue('\U00010401'.isalpha())
+        self.assertTrue('\U00010427'.isalpha())
+        self.assertTrue('\U00010429'.isalpha())
+        self.assertTrue('\U0001044E'.isalpha())
+        # non-BMP, non-cased
+        self.assertFalse('\U0001F40D'.isalpha())
+        self.assertFalse('\U0001F46F'.isalpha())
+
+    def test_isascii(self):
+        super().test_isascii()
+        self.assertFalse("\u20ac".isascii())
+        self.assertFalse("\U0010ffff".isascii())
+
+    def test_isdecimal(self):
+        self.checkequalnofix(False, '', 'isdecimal')
+        self.checkequalnofix(False, 'a', 'isdecimal')
+        self.checkequalnofix(True, '0', 'isdecimal')
+        self.checkequalnofix(False, '\u2460', 'isdecimal') # CIRCLED DIGIT ONE
+        self.checkequalnofix(False, '\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER
+        self.checkequalnofix(True, '\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO
+        self.checkequalnofix(True, '0123456789', 'isdecimal')
+        self.checkequalnofix(False, '0123456789a', 'isdecimal')
+
+        self.checkraises(TypeError, 'abc', 'isdecimal', 42)
+
+        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
+                   '\U0001F40D', '\U0001F46F', '\U00011065', '\U0001F107']:
+            self.assertFalse(ch.isdecimal(), '{!a} is not decimal.'.format(ch))
+        for ch in ['\U0001D7F6', '\U00011066', '\U000104A0']:
+            self.assertTrue(ch.isdecimal(), '{!a} is decimal.'.format(ch))
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_isdigit(self):
+        super().test_isdigit()
+        self.checkequalnofix(True, '\u2460', 'isdigit')
+        self.checkequalnofix(False, '\xbc', 'isdigit')
+        self.checkequalnofix(True, '\u0660', 'isdigit')
+
+        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
+                   '\U0001F40D', '\U0001F46F', '\U00011065']:
+            self.assertFalse(ch.isdigit(), '{!a} is not a digit.'.format(ch))
+        for ch in ['\U0001D7F6', '\U00011066', '\U000104A0', '\U0001F107']:
+            self.assertTrue(ch.isdigit(), '{!a} is a digit.'.format(ch))
+
+    def test_isnumeric(self):
+        self.checkequalnofix(False, '', 'isnumeric')
+        self.checkequalnofix(False, 'a', 'isnumeric')
+        self.checkequalnofix(True, '0', 'isnumeric')
+        self.checkequalnofix(True, '\u2460', 'isnumeric')
+        self.checkequalnofix(True, '\xbc', 'isnumeric')
+        self.checkequalnofix(True, '\u0660', 'isnumeric')
+        self.checkequalnofix(True, '0123456789', 'isnumeric')
+        self.checkequalnofix(False, '0123456789a', 'isnumeric')
+
+        self.assertRaises(TypeError, "abc".isnumeric, 42)
+
+        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
+                   '\U0001F40D', '\U0001F46F']:
+            self.assertFalse(ch.isnumeric(), '{!a} is not numeric.'.format(ch))
+        for ch in ['\U00011065', '\U0001D7F6', '\U00011066',
+                   '\U000104A0', '\U0001F107']:
+            self.assertTrue(ch.isnumeric(), '{!a} is numeric.'.format(ch))
+
+    def test_isidentifier(self):
+        self.assertTrue("a".isidentifier())
+        self.assertTrue("Z".isidentifier())
+        self.assertTrue("_".isidentifier())
+        self.assertTrue("b0".isidentifier())
+        self.assertTrue("bc".isidentifier())
+        self.assertTrue("b_".isidentifier())
+        self.assertTrue("µ".isidentifier())
+        self.assertTrue("𝔘𝔫𝔦𝔠𝔬𝔡𝔢".isidentifier())
+
+        self.assertFalse(" ".isidentifier())
+        self.assertFalse("[".isidentifier())
+        self.assertFalse("©".isidentifier())
+        self.assertFalse("0".isidentifier())
+
+    def test_isprintable(self):
+        self.assertTrue("".isprintable())
+        self.assertTrue(" ".isprintable())
+        self.assertTrue("abcdefg".isprintable())
+        self.assertFalse("abcdefg\n".isprintable())
+        # some defined Unicode character
+        self.assertTrue("\u0374".isprintable())
+        # undefined character
+        self.assertFalse("\u0378".isprintable())
+        # single surrogate character
+        self.assertFalse("\ud800".isprintable())
+
+        self.assertTrue('\U0001F46F'.isprintable())
+        self.assertFalse('\U000E0020'.isprintable())
+
+    @support.requires_resource('cpu')
+    def test_isprintable_invariant(self):
+        for codepoint in range(sys.maxunicode + 1):
+            char = chr(codepoint)
+            category = unicodedata.category(char)
+            self.assertEqual(char.isprintable(),
+                             category[0] not in ('C', 'Z')
+                             or char == ' ')
+
+    def test_surrogates(self):
+        for s in ('a\uD800b\uDFFF', 'a\uDFFFb\uD800',
+                  'a\uD800b\uDFFFa', 'a\uDFFFb\uD800a'):
+            self.assertTrue(s.islower())
+            self.assertFalse(s.isupper())
+            self.assertFalse(s.istitle())
+        for s in ('A\uD800B\uDFFF', 'A\uDFFFB\uD800',
+                  'A\uD800B\uDFFFA', 'A\uDFFFB\uD800A'):
+            self.assertFalse(s.islower())
+            self.assertTrue(s.isupper())
+            self.assertTrue(s.istitle())
+
+        for meth_name in ('islower', 'isupper', 'istitle'):
+            meth = getattr(str, meth_name)
+            for s in ('\uD800', '\uDFFF', '\uD800\uD800', '\uDFFF\uDFFF'):
+                self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
+
+        for meth_name in ('isalpha', 'isalnum', 'isdigit', 'isspace',
+                          'isdecimal', 'isnumeric',
+                          'isidentifier', 'isprintable'):
+            meth = getattr(str, meth_name)
+            for s in ('\uD800', '\uDFFF', '\uD800\uD800', '\uDFFF\uDFFF',
+                      'a\uD800b\uDFFF', 'a\uDFFFb\uD800',
+                      'a\uD800b\uDFFFa', 'a\uDFFFb\uD800a'):
+                self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
+
+
+    def test_lower(self):
+        string_tests.StringLikeTest.test_lower(self)
+        self.assertEqual('\U00010427'.lower(), '\U0001044F')
+        self.assertEqual('\U00010427\U00010427'.lower(),
+                         '\U0001044F\U0001044F')
+        self.assertEqual('\U00010427\U0001044F'.lower(),
+                         '\U0001044F\U0001044F')
+        self.assertEqual('X\U00010427x\U0001044F'.lower(),
+                         'x\U0001044Fx\U0001044F')
+        self.assertEqual('fi'.lower(), 'fi')
+        self.assertEqual('\u0130'.lower(), '\u0069\u0307')
+        # Special case for GREEK CAPITAL LETTER SIGMA U+03A3
+        self.assertEqual('\u03a3'.lower(), '\u03c3')
+        self.assertEqual('\u0345\u03a3'.lower(), '\u0345\u03c3')
+        self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
+        self.assertEqual('A\u0345\u03a3a'.lower(), 'a\u0345\u03c3a')
+        self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
+        self.assertEqual('A\u03a3\u0345'.lower(), 'a\u03c2\u0345')
+        self.assertEqual('\u03a3\u0345 '.lower(), '\u03c3\u0345 ')
+        self.assertEqual('\U0008fffe'.lower(), '\U0008fffe')
+        self.assertEqual('\u2177'.lower(), '\u2177')
+
+    def test_casefold(self):
+        self.assertEqual('hello'.casefold(), 'hello')
+        self.assertEqual('hELlo'.casefold(), 'hello')
+        self.assertEqual('ß'.casefold(), 'ss')
+        self.assertEqual('fi'.casefold(), 'fi')
+        self.assertEqual('\u03a3'.casefold(), '\u03c3')
+        self.assertEqual('A\u0345\u03a3'.casefold(), 'a\u03b9\u03c3')
+        self.assertEqual('\u00b5'.casefold(), '\u03bc')
+
+    def test_upper(self):
+        string_tests.StringLikeTest.test_upper(self)
+        self.assertEqual('\U0001044F'.upper(), '\U00010427')
+        self.assertEqual('\U0001044F\U0001044F'.upper(),
+                         '\U00010427\U00010427')
+        self.assertEqual('\U00010427\U0001044F'.upper(),
+                         '\U00010427\U00010427')
+        self.assertEqual('X\U00010427x\U0001044F'.upper(),
+                         'X\U00010427X\U00010427')
+        self.assertEqual('fi'.upper(), 'FI')
+        self.assertEqual('\u0130'.upper(), '\u0130')
+        self.assertEqual('\u03a3'.upper(), '\u03a3')
+        self.assertEqual('ß'.upper(), 'SS')
+        self.assertEqual('\u1fd2'.upper(), '\u0399\u0308\u0300')
+        self.assertEqual('\U0008fffe'.upper(), '\U0008fffe')
+        self.assertEqual('\u2177'.upper(), '\u2167')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_capitalize(self):
+        string_tests.StringLikeTest.test_capitalize(self)
+        self.assertEqual('\U0001044F'.capitalize(), '\U00010427')
+        self.assertEqual('\U0001044F\U0001044F'.capitalize(),
+                         '\U00010427\U0001044F')
+        self.assertEqual('\U00010427\U0001044F'.capitalize(),
+                         '\U00010427\U0001044F')
+        self.assertEqual('\U0001044F\U00010427'.capitalize(),
+                         '\U00010427\U0001044F')
+        self.assertEqual('X\U00010427x\U0001044F'.capitalize(),
+                         'X\U0001044Fx\U0001044F')
+        self.assertEqual('h\u0130'.capitalize(), 'H\u0069\u0307')
+        exp = '\u0399\u0308\u0300\u0069\u0307'
+        self.assertEqual('\u1fd2\u0130'.capitalize(), exp)
+        self.assertEqual('finnish'.capitalize(), 'Finnish')
+        self.assertEqual('A\u0345\u03a3'.capitalize(), 'A\u0345\u03c2')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_title(self):
+        super().test_title()
+        self.assertEqual('\U0001044F'.title(), '\U00010427')
+        self.assertEqual('\U0001044F\U0001044F'.title(),
+                         '\U00010427\U0001044F')
+        self.assertEqual('\U0001044F\U0001044F \U0001044F\U0001044F'.title(),
+                         '\U00010427\U0001044F \U00010427\U0001044F')
+        self.assertEqual('\U00010427\U0001044F \U00010427\U0001044F'.title(),
+                         '\U00010427\U0001044F \U00010427\U0001044F')
+        self.assertEqual('\U0001044F\U00010427 \U0001044F\U00010427'.title(),
+                         '\U00010427\U0001044F \U00010427\U0001044F')
+        self.assertEqual('X\U00010427x\U0001044F X\U00010427x\U0001044F'.title(),
+                         'X\U0001044Fx\U0001044F X\U0001044Fx\U0001044F')
+        self.assertEqual('fiNNISH'.title(), 'Finnish')
+        self.assertEqual('A\u03a3 \u1fa1xy'.title(), 'A\u03c2 \u1fa9xy')
+        self.assertEqual('A\u03a3A'.title(), 'A\u03c3a')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_swapcase(self):
+        string_tests.StringLikeTest.test_swapcase(self)
+        self.assertEqual('\U0001044F'.swapcase(), '\U00010427')
+        self.assertEqual('\U00010427'.swapcase(), '\U0001044F')
+        self.assertEqual('\U0001044F\U0001044F'.swapcase(),
+                         '\U00010427\U00010427')
+        self.assertEqual('\U00010427\U0001044F'.swapcase(),
+                         '\U0001044F\U00010427')
+        self.assertEqual('\U0001044F\U00010427'.swapcase(),
+                         '\U00010427\U0001044F')
+        self.assertEqual('X\U00010427x\U0001044F'.swapcase(),
+                         'x\U0001044FX\U00010427')
+        self.assertEqual('fi'.swapcase(), 'FI')
+        self.assertEqual('\u0130'.swapcase(), '\u0069\u0307')
+        # Special case for GREEK CAPITAL LETTER SIGMA U+03A3
+        self.assertEqual('\u03a3'.swapcase(), '\u03c3')
+        self.assertEqual('\u0345\u03a3'.swapcase(), '\u0399\u03c3')
+        self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
+        self.assertEqual('A\u0345\u03a3a'.swapcase(), 'a\u0399\u03c3A')
+        self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
+        self.assertEqual('A\u03a3\u0345'.swapcase(), 'a\u03c2\u0399')
+        self.assertEqual('\u03a3\u0345 '.swapcase(), '\u03c3\u0399 ')
+        self.assertEqual('\u03a3'.swapcase(), '\u03c3')
+        self.assertEqual('ß'.swapcase(), 'SS')
+        self.assertEqual('\u1fd2'.swapcase(), '\u0399\u0308\u0300')
+
+    def test_center(self):
+        string_tests.StringLikeTest.test_center(self)
+        self.assertEqual('x'.center(2, '\U0010FFFF'),
+                         'x\U0010FFFF')
+        self.assertEqual('x'.center(3, '\U0010FFFF'),
+                         '\U0010FFFFx\U0010FFFF')
+        self.assertEqual('x'.center(4, '\U0010FFFF'),
+                         '\U0010FFFFx\U0010FFFF\U0010FFFF')
+
+    @unittest.skipUnless(sys.maxsize == 2**31 - 1, "requires 32-bit system")
+    @support.cpython_only
+    def test_case_operation_overflow(self):
+        # Issue #22643
+        size = 2**32//12 + 1
+        try:
+            s = "ü" * size
+        except MemoryError:
+            self.skipTest('no enough memory (%.0f MiB required)' % (size / 2**20))
+        try:
+            self.assertRaises(OverflowError, s.upper)
+        finally:
+            del s
+
+    def test_contains(self):
+        # Testing Unicode contains method
+        self.assertIn('a', 'abdb')
+        self.assertIn('a', 'bdab')
+        self.assertIn('a', 'bdaba')
+        self.assertIn('a', 'bdba')
+        self.assertNotIn('a', 'bdb')
+        self.assertIn('a', 'bdba')
+        self.assertIn('a', ('a',1,None))
+        self.assertIn('a', (1,None,'a'))
+        self.assertIn('a', ('a',1,None))
+        self.assertIn('a', (1,None,'a'))
+        self.assertNotIn('a', ('x',1,'y'))
+        self.assertNotIn('a', ('x',1,None))
+        self.assertNotIn('abcd', 'abcxxxx')
+        self.assertIn('ab', 'abcd')
+        self.assertIn('ab', 'abc')
+        self.assertIn('ab', (1,None,'ab'))
+        self.assertIn('', 'abc')
+        self.assertIn('', '')
+        self.assertIn('', 'abc')
+        self.assertNotIn('\0', 'abc')
+        self.assertIn('\0', '\0abc')
+        self.assertIn('\0', 'abc\0')
+        self.assertIn('a', '\0abc')
+        self.assertIn('asdf', 'asdf')
+        self.assertNotIn('asdf', 'asd')
+        self.assertNotIn('asdf', '')
+
+        self.assertRaises(TypeError, "abc".__contains__)
+        # test mixed kinds
+        for fill in ('a', '\u0100', '\U00010300'):
+            fill *= 9
+            for delim in ('c', '\u0102', '\U00010302'):
+                self.assertNotIn(delim, fill)
+                self.assertIn(delim, fill + delim)
+                self.assertNotIn(delim * 2, fill)
+                self.assertIn(delim * 2, fill + delim * 2)
+
+    def test_issue18183(self):
+        '\U00010000\U00100000'.lower()
+        '\U00010000\U00100000'.casefold()
+        '\U00010000\U00100000'.upper()
+        '\U00010000\U00100000'.capitalize()
+        '\U00010000\U00100000'.title()
+        '\U00010000\U00100000'.swapcase()
+        '\U00100000'.center(3, '\U00010000')
+        '\U00100000'.ljust(3, '\U00010000')
+        '\U00100000'.rjust(3, '\U00010000')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_format(self):
+        self.assertEqual(''.format(), '')
+        self.assertEqual('a'.format(), 'a')
+        self.assertEqual('ab'.format(), 'ab')
+        self.assertEqual('a{{'.format(), 'a{')
+        self.assertEqual('a}}'.format(), 'a}')
+        self.assertEqual('{{b'.format(), '{b')
+        self.assertEqual('}}b'.format(), '}b')
+        self.assertEqual('a{{b'.format(), 'a{b')
+
+        # examples from the PEP:
+        import datetime
+        self.assertEqual("My name is {0}".format('Fred'), "My name is Fred")
+        self.assertEqual("My name is {0[name]}".format(dict(name='Fred')),
+                         "My name is Fred")
+        self.assertEqual("My name is {0} :-{{}}".format('Fred'),
+                         "My name is Fred :-{}")
+
+        d = datetime.date(2007, 8, 18)
+        self.assertEqual("The year is {0.year}".format(d),
+                         "The year is 2007")
+
+        # classes we'll use for testing
+        class C:
+            def __init__(self, x=100):
+                self._x = x
+            def __format__(self, spec):
+                return spec
+
+        class D:
+            def __init__(self, x):
+                self.x = x
+            def __format__(self, spec):
+                return str(self.x)
+
+        # class with __str__, but no __format__
+        class E:
+            def __init__(self, x):
+                self.x = x
+            def __str__(self):
+                return 'E(' + self.x + ')'
+
+        # class with __repr__, but no __format__ or __str__
+        class F:
+            def __init__(self, x):
+                self.x = x
+            def __repr__(self):
+                return 'F(' + self.x + ')'
+
+        # class with __format__ that forwards to string, for some format_spec's
+        class G:
+            def __init__(self, x):
+                self.x = x
+            def __str__(self):
+                return "string is " + self.x
+            def __format__(self, format_spec):
+                if format_spec == 'd':
+                    return 'G(' + self.x + ')'
+                return object.__format__(self, format_spec)
+
+        class I(datetime.date):
+            def __format__(self, format_spec):
+                return self.strftime(format_spec)
+
+        class J(int):
+            def __format__(self, format_spec):
+                return int.__format__(self * 2, format_spec)
+
+        class M:
+            def __init__(self, x):
+                self.x = x
+            def __repr__(self):
+                return 'M(' + self.x + ')'
+            __str__ = None
+
+        class N:
+            def __init__(self, x):
+                self.x = x
+            def __repr__(self):
+                return 'N(' + self.x + ')'
+            __format__ = None
+
+        self.assertEqual(''.format(), '')
+        self.assertEqual('abc'.format(), 'abc')
+        self.assertEqual('{0}'.format('abc'), 'abc')
+        self.assertEqual('{0:}'.format('abc'), 'abc')
+#        self.assertEqual('{ 0 }'.format('abc'), 'abc')
+        self.assertEqual('X{0}'.format('abc'), 'Xabc')
+        self.assertEqual('{0}X'.format('abc'), 'abcX')
+        self.assertEqual('X{0}Y'.format('abc'), 'XabcY')
+        self.assertEqual('{1}'.format(1, 'abc'), 'abc')
+        self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc')
+        self.assertEqual('{1}X'.format(1, 'abc'), 'abcX')
+        self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY')
+        self.assertEqual('{0}'.format(-15), '-15')
+        self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc')
+        self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc')
+        self.assertEqual('{{'.format(), '{')
+        self.assertEqual('}}'.format(), '}')
+        self.assertEqual('{{}}'.format(), '{}')
+        self.assertEqual('{{x}}'.format(), '{x}')
+        self.assertEqual('{{{0}}}'.format(123), '{123}')
+        self.assertEqual('{{{{0}}}}'.format(), '{{0}}')
+        self.assertEqual('}}{{'.format(), '}{')
+        self.assertEqual('}}x{{'.format(), '}x{')
+
+        # weird field names
+        self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz')
+        self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz')
+        self.assertEqual("{0[ ]}".format({' ':3}), '3')
+
+        self.assertEqual('{foo._x}'.format(foo=C(20)), '20')
+        self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010')
+        self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc')
+        self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc')
+        self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def')
+        self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def')
+        self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def')
+
+        # strings
+        self.assertEqual('{0:.3s}'.format('abc'), 'abc')
+        self.assertEqual('{0:.3s}'.format('ab'), 'ab')
+        self.assertEqual('{0:.3s}'.format('abcdef'), 'abc')
+        self.assertEqual('{0:.0s}'.format('abcdef'), '')
+        self.assertEqual('{0:3.3s}'.format('abc'), 'abc')
+        self.assertEqual('{0:2.3s}'.format('abc'), 'abc')
+        self.assertEqual('{0:2.2s}'.format('abc'), 'ab')
+        self.assertEqual('{0:3.2s}'.format('abc'), 'ab ')
+        self.assertEqual('{0:x<0s}'.format('result'), 'result')
+        self.assertEqual('{0:x<5s}'.format('result'), 'result')
+        self.assertEqual('{0:x<6s}'.format('result'), 'result')
+        self.assertEqual('{0:x<7s}'.format('result'), 'resultx')
+        self.assertEqual('{0:x<8s}'.format('result'), 'resultxx')
+        self.assertEqual('{0: <7s}'.format('result'), 'result ')
+        self.assertEqual('{0:<7s}'.format('result'), 'result ')
+        self.assertEqual('{0:>7s}'.format('result'), ' result')
+        self.assertEqual('{0:>8s}'.format('result'), '  result')
+        self.assertEqual('{0:^8s}'.format('result'), ' result ')
+        self.assertEqual('{0:^9s}'.format('result'), ' result  ')
+        self.assertEqual('{0:^10s}'.format('result'), '  result  ')
+        self.assertEqual('{0:8s}'.format('result'), 'result  ')
+        self.assertEqual('{0:0s}'.format('result'), 'result')
+        self.assertEqual('{0:08s}'.format('result'), 'result00')
+        self.assertEqual('{0:<08s}'.format('result'), 'result00')
+        self.assertEqual('{0:>08s}'.format('result'), '00result')
+        self.assertEqual('{0:^08s}'.format('result'), '0result0')
+        self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999)
+        self.assertEqual('{0:10000}'.format(''), ' ' * 10000)
+        self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000)
+
+        # issue 12546: use \x00 as a fill character
+        self.assertEqual('{0:\x00<6s}'.format('foo'), 'foo\x00\x00\x00')
+        self.assertEqual('{0:\x01<6s}'.format('foo'), 'foo\x01\x01\x01')
+        self.assertEqual('{0:\x00^6s}'.format('foo'), '\x00foo\x00\x00')
+        self.assertEqual('{0:^6s}'.format('foo'), ' foo  ')
+
+        self.assertEqual('{0:\x00<6}'.format(3), '3\x00\x00\x00\x00\x00')
+        self.assertEqual('{0:\x01<6}'.format(3), '3\x01\x01\x01\x01\x01')
+        self.assertEqual('{0:\x00^6}'.format(3), '\x00\x003\x00\x00\x00')
+        self.assertEqual('{0:<6}'.format(3), '3     ')
+
+        self.assertEqual('{0:\x00<6}'.format(3.25), '3.25\x00\x00')
+        self.assertEqual('{0:\x01<6}'.format(3.25), '3.25\x01\x01')
+        self.assertEqual('{0:\x00^6}'.format(3.25), '\x003.25\x00')
+        self.assertEqual('{0:^6}'.format(3.25), ' 3.25 ')
+
+        self.assertEqual('{0:\x00<12}'.format(3+2.0j), '(3+2j)\x00\x00\x00\x00\x00\x00')
+        self.assertEqual('{0:\x01<12}'.format(3+2.0j), '(3+2j)\x01\x01\x01\x01\x01\x01')
+        self.assertEqual('{0:\x00^12}'.format(3+2.0j), '\x00\x00\x00(3+2j)\x00\x00\x00')
+        self.assertEqual('{0:^12}'.format(3+2.0j), '   (3+2j)   ')
+
+        # format specifiers for user defined type
+        self.assertEqual('{0:abc}'.format(C()), 'abc')
+
+        # !r, !s and !a coercions
+        self.assertEqual('{0!s}'.format('Hello'), 'Hello')
+        self.assertEqual('{0!s:}'.format('Hello'), 'Hello')
+        self.assertEqual('{0!s:15}'.format('Hello'), 'Hello          ')
+        self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello          ')
+        self.assertEqual('{0!r}'.format('Hello'), "'Hello'")
+        self.assertEqual('{0!r:}'.format('Hello'), "'Hello'")
+        self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)')
+        self.assertEqual('{0!r}'.format('\u0378'), "'\\u0378'") # nonprintable
+        self.assertEqual('{0!r}'.format('\u0374'), "'\u0374'")  # printable
+        self.assertEqual('{0!r}'.format(F('\u0374')), 'F(\u0374)')
+        self.assertEqual('{0!a}'.format('Hello'), "'Hello'")
+        self.assertEqual('{0!a}'.format('\u0378'), "'\\u0378'") # nonprintable
+        self.assertEqual('{0!a}'.format('\u0374'), "'\\u0374'") # printable
+        self.assertEqual('{0!a:}'.format('Hello'), "'Hello'")
+        self.assertEqual('{0!a}'.format(F('Hello')), 'F(Hello)')
+        self.assertEqual('{0!a}'.format(F('\u0374')), 'F(\\u0374)')
+
+        # test fallback to object.__format__
+        self.assertEqual('{0}'.format({}), '{}')
+        self.assertEqual('{0}'.format([]), '[]')
+        self.assertEqual('{0}'.format([1]), '[1]')
+
+        self.assertEqual('{0:d}'.format(G('data')), 'G(data)')
+        self.assertEqual('{0!s}'.format(G('data')), 'string is data')
+
+        self.assertRaises(TypeError, '{0:^10}'.format, E('data'))
+        self.assertRaises(TypeError, '{0:^10s}'.format, E('data'))
+        self.assertRaises(TypeError, '{0:>15s}'.format, G('data'))
+
+        self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007,
+                                                       month=8,
+                                                       day=27)),
+                         "date: 2007-08-27")
+
+        # test deriving from a builtin type and overriding __format__
+        self.assertEqual("{0}".format(J(10)), "20")
+
+
+        # string format specifiers
+        self.assertEqual('{0:}'.format('a'), 'a')
+
+        # computed format specifiers
+        self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello')
+        self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello')
+        self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello')
+        self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello     ')
+        self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello     ')
+
+        # test various errors
+        self.assertRaises(ValueError, '{'.format)
+        self.assertRaises(ValueError, '}'.format)
+        self.assertRaises(ValueError, 'a{'.format)
+        self.assertRaises(ValueError, 'a}'.format)
+        self.assertRaises(ValueError, '{a'.format)
+        self.assertRaises(ValueError, '}a'.format)
+        self.assertRaises(IndexError, '{0}'.format)
+        self.assertRaises(IndexError, '{1}'.format, 'abc')
+        self.assertRaises(KeyError,   '{x}'.format)
+        self.assertRaises(ValueError, "}{".format)
+        self.assertRaises(ValueError, "abc{0:{}".format)
+        self.assertRaises(ValueError, "{0".format)
+        self.assertRaises(IndexError, "{0.}".format)
+        self.assertRaises(ValueError, "{0.}".format, 0)
+        self.assertRaises(ValueError, "{0[}".format)
+        self.assertRaises(ValueError, "{0[}".format, [])
+        self.assertRaises(KeyError,   "{0]}".format)
+        self.assertRaises(ValueError, "{0.[]}".format, 0)
+        self.assertRaises(ValueError, "{0..foo}".format, 0)
+        self.assertRaises(ValueError, "{0[0}".format, 0)
+        self.assertRaises(ValueError, "{0[0:foo}".format, 0)
+        self.assertRaises(KeyError,   "{c]}".format)
+        self.assertRaises(ValueError, "{{ {{{0}}".format, 0)
+        self.assertRaises(ValueError, "{0}}".format, 0)
+        self.assertRaises(KeyError,   "{foo}".format, bar=3)
+        self.assertRaises(ValueError, "{0!x}".format, 3)
+        self.assertRaises(ValueError, "{0!}".format, 0)
+        self.assertRaises(ValueError, "{0!rs}".format, 0)
+        self.assertRaises(ValueError, "{!}".format)
+        self.assertRaises(IndexError, "{:}".format)
+        self.assertRaises(IndexError, "{:s}".format)
+        self.assertRaises(IndexError, "{}".format)
+        big = "23098475029384702983476098230754973209482573"
+        self.assertRaises(ValueError, ("{" + big + "}").format)
+        self.assertRaises(ValueError, ("{[" + big + "]}").format, [0])
+
+        # test number formatter errors:
+        self.assertRaises(ValueError, '{0:x}'.format, 1j)
+        self.assertRaises(ValueError, '{0:x}'.format, 1.0)
+        self.assertRaises(ValueError, '{0:X}'.format, 1j)
+        self.assertRaises(ValueError, '{0:X}'.format, 1.0)
+        self.assertRaises(ValueError, '{0:o}'.format, 1j)
+        self.assertRaises(ValueError, '{0:o}'.format, 1.0)
+        self.assertRaises(ValueError, '{0:u}'.format, 1j)
+        self.assertRaises(ValueError, '{0:u}'.format, 1.0)
+        self.assertRaises(ValueError, '{0:i}'.format, 1j)
+        self.assertRaises(ValueError, '{0:i}'.format, 1.0)
+        self.assertRaises(ValueError, '{0:d}'.format, 1j)
+        self.assertRaises(ValueError, '{0:d}'.format, 1.0)
+
+        # issue 6089
+        self.assertRaises(ValueError, "{0[0]x}".format, [None])
+        self.assertRaises(ValueError, "{0[0](10)}".format, [None])
+
+        # can't have a replacement on the field name portion
+        self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4)
+
+        # exceed maximum recursion depth
+        self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '')
+        self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,
+                          0, 1, 2, 3, 4, 5, 6, 7)
+
+        # string format spec errors
+        sign_msg = "Sign not allowed in string format specifier"
+        self.assertRaisesRegex(ValueError, sign_msg, "{0:-s}".format, '')
+        self.assertRaisesRegex(ValueError, sign_msg, format, "", "-")
+        space_msg = "Space not allowed in string format specifier"
+        self.assertRaisesRegex(ValueError, space_msg, "{: }".format, '')
+        self.assertRaises(ValueError, "{0:=s}".format, '')
+
+        # Alternate formatting is not supported
+        self.assertRaises(ValueError, format, '', '#')
+        self.assertRaises(ValueError, format, '', '#20')
+
+        # Non-ASCII
+        self.assertEqual("{0:s}{1:s}".format("ABC", "\u0410\u0411\u0412"),
+                         'ABC\u0410\u0411\u0412')
+        self.assertEqual("{0:.3s}".format("ABC\u0410\u0411\u0412"),
+                         'ABC')
+        self.assertEqual("{0:.0s}".format("ABC\u0410\u0411\u0412"),
+                         '')
+
+        self.assertEqual("{[{}]}".format({"{}": 5}), "5")
+        self.assertEqual("{[{}]}".format({"{}" : "a"}), "a")
+        self.assertEqual("{[{]}".format({"{" : "a"}), "a")
+        self.assertEqual("{[}]}".format({"}" : "a"}), "a")
+        self.assertEqual("{[[]}".format({"[" : "a"}), "a")
+        self.assertEqual("{[!]}".format({"!" : "a"}), "a")
+        self.assertRaises(ValueError, "{a{}b}".format, 42)
+        self.assertRaises(ValueError, "{a{b}".format, 42)
+        self.assertRaises(ValueError, "{[}".format, 42)
+
+        self.assertEqual("0x{:0{:d}X}".format(0x0,16), "0x0000000000000000")
+
+        # Blocking fallback
+        m = M('data')
+        self.assertEqual("{!r}".format(m), 'M(data)')
+        self.assertRaises(TypeError, "{!s}".format, m)
+        self.assertRaises(TypeError, "{}".format, m)
+        n = N('data')
+        self.assertEqual("{!r}".format(n), 'N(data)')
+        self.assertEqual("{!s}".format(n), 'N(data)')
+        self.assertRaises(TypeError, "{}".format, n)
+
+    def test_format_map(self):
+        self.assertEqual(''.format_map({}), '')
+        self.assertEqual('a'.format_map({}), 'a')
+        self.assertEqual('ab'.format_map({}), 'ab')
+        self.assertEqual('a{{'.format_map({}), 'a{')
+        self.assertEqual('a}}'.format_map({}), 'a}')
+        self.assertEqual('{{b'.format_map({}), '{b')
+        self.assertEqual('}}b'.format_map({}), '}b')
+        self.assertEqual('a{{b'.format_map({}), 'a{b')
+
+        # using mappings
+        class Mapping(dict):
+            def __missing__(self, key):
+                return key
+        self.assertEqual('{hello}'.format_map(Mapping()), 'hello')
+        self.assertEqual('{a} {world}'.format_map(Mapping(a='hello')), 'hello world')
+
+        class InternalMapping:
+            def __init__(self):
+                self.mapping = {'a': 'hello'}
+            def __getitem__(self, key):
+                return self.mapping[key]
+        self.assertEqual('{a}'.format_map(InternalMapping()), 'hello')
+
+
+        class C:
+            def __init__(self, x=100):
+                self._x = x
+            def __format__(self, spec):
+                return spec
+        self.assertEqual('{foo._x}'.format_map({'foo': C(20)}), '20')
+
+        # test various errors
+        self.assertRaises(TypeError, ''.format_map)
+        self.assertRaises(TypeError, 'a'.format_map)
+
+        self.assertRaises(ValueError, '{'.format_map, {})
+        self.assertRaises(ValueError, '}'.format_map, {})
+        self.assertRaises(ValueError, 'a{'.format_map, {})
+        self.assertRaises(ValueError, 'a}'.format_map, {})
+        self.assertRaises(ValueError, '{a'.format_map, {})
+        self.assertRaises(ValueError, '}a'.format_map, {})
+
+        # issue #12579: can't supply positional params to format_map
+        self.assertRaises(ValueError, '{}'.format_map, {'a' : 2})
+        self.assertRaises(ValueError, '{}'.format_map, 'a')
+        self.assertRaises(ValueError, '{a} {}'.format_map, {"a" : 2, "b" : 1})
+
+        class BadMapping:
+            def __getitem__(self, key):
+                return 1/0
+        self.assertRaises(KeyError, '{a}'.format_map, {})
+        self.assertRaises(TypeError, '{a}'.format_map, [])
+        self.assertRaises(ZeroDivisionError, '{a}'.format_map, BadMapping())
+
+    def test_format_huge_precision(self):
+        format_string = ".{}f".format(sys.maxsize + 1)
+        with self.assertRaises(ValueError):
+            result = format(2.34, format_string)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    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
+    def test_format_huge_item_number(self):
+        format_string = "{{{}:.6f}}".format(sys.maxsize + 1)
+        with self.assertRaises(ValueError):
+            result = format_string.format(2.34)
+
+    def test_format_auto_numbering(self):
+        class C:
+            def __init__(self, x=100):
+                self._x = x
+            def __format__(self, spec):
+                return spec
+
+        self.assertEqual('{}'.format(10), '10')
+        self.assertEqual('{:5}'.format('s'), 's    ')
+        self.assertEqual('{!r}'.format('s'), "'s'")
+        self.assertEqual('{._x}'.format(C(10)), '10')
+        self.assertEqual('{[1]}'.format([1, 2]), '2')
+        self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4')
+        self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c')
+
+        self.assertEqual('a{:{}}b'.format('x', '^10'), 'a    x     b')
+        self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b')
+
+        # can't mix and match numbering and auto-numbering
+        self.assertRaises(ValueError, '{}{1}'.format, 1, 2)
+        self.assertRaises(ValueError, '{1}{}'.format, 1, 2)
+        self.assertRaises(ValueError, '{:{1}}'.format, 1, 2)
+        self.assertRaises(ValueError, '{0:{}}'.format, 1, 2)
+
+        # can mix and match auto-numbering and named
+        self.assertEqual('{f}{}'.format(4, f='test'), 'test4')
+        self.assertEqual('{}{f}'.format(4, f='test'), '4test')
+        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
+    def test_formatting(self):
+        string_tests.StringLikeTest.test_formatting(self)
+        # Testing Unicode formatting strings...
+        self.assertEqual("%s, %s" % ("abc", "abc"), 'abc, abc')
+        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, 2, 3), 'abc, abc, 1, 2.000000,  3.00')
+        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, -2, 3), 'abc, abc, 1, -2.000000,  3.00')
+        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.5), 'abc, abc, -1, -2.000000,  3.50')
+        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.57), 'abc, abc, -1, -2.000000,  3.57')
+        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 1003.57), 'abc, abc, -1, -2.000000, 1003.57')
+        self.assertEqual("%r, %r" % (b"abc", "abc"), "b'abc', 'abc'")
+        self.assertEqual("%r" % ("\u1234",), "'\u1234'")
+        self.assertEqual("%a" % ("\u1234",), "'\\u1234'")
+        self.assertEqual("%(x)s, %(y)s" % {'x':"abc", 'y':"def"}, 'abc, def')
+        self.assertEqual("%(x)s, %(\xfc)s" % {'x':"abc", '\xfc':"def"}, 'abc, def')
+
+        self.assertEqual('%c' % 0x1234, '\u1234')
+        self.assertEqual('%c' % 0x21483, '\U00021483')
+        self.assertRaises(OverflowError, "%c".__mod__, (0x110000,))
+        self.assertEqual('%c' % '\U00021483', '\U00021483')
+        self.assertRaises(TypeError, "%c".__mod__, "aa")
+        self.assertRaises(ValueError, "%.1\u1032f".__mod__, (1.0/3))
+        self.assertRaises(TypeError, "%i".__mod__, "aa")
+
+        # formatting jobs delegated from the string implementation:
+        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
+        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
+        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
+        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
+        self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123},  '...abc...')
+        self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123}, '...abc...')
+        self.assertEqual('...%s...%s...%s...%s...' % (1,2,3,"abc"), '...1...2...3...abc...')
+        self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,"abc"), '...%...%s...1...2...3...abc...')
+        self.assertEqual('...%s...' % "abc", '...abc...')
+        self.assertEqual('%*s' % (5,'abc',), '  abc')
+        self.assertEqual('%*s' % (-5,'abc',), 'abc  ')
+        self.assertEqual('%*.*s' % (5,2,'abc',), '   ab')
+        self.assertEqual('%*.*s' % (5,3,'abc',), '  abc')
+        self.assertEqual('%i %*.*s' % (10, 5,3,'abc',), '10   abc')
+        self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, 'abc',), '103   abc')
+        self.assertEqual('%c' % 'a', 'a')
+        class Wrapper:
+            def __str__(self):
+                return '\u1234'
+        self.assertEqual('%s' % Wrapper(), '\u1234')
+
+        # issue 3382
+        NAN = float('nan')
+        INF = float('inf')
+        self.assertEqual('%f' % NAN, 'nan')
+        self.assertEqual('%F' % NAN, 'NAN')
+        self.assertEqual('%f' % INF, 'inf')
+        self.assertEqual('%F' % INF, 'INF')
+
+        # PEP 393
+        self.assertEqual('%.1s' % "a\xe9\u20ac", 'a')
+        self.assertEqual('%.2s' % "a\xe9\u20ac", 'a\xe9')
+
+        #issue 19995
+        class PseudoInt:
+            def __init__(self, value):
+                self.value = int(value)
+            def __int__(self):
+                return self.value
+            def __index__(self):
+                return self.value
+        class PseudoFloat:
+            def __init__(self, value):
+                self.value = float(value)
+            def __int__(self):
+                return int(self.value)
+        pi = PseudoFloat(3.1415)
+        letter_m = PseudoInt(109)
+        self.assertEqual('%x' % 42, '2a')
+        self.assertEqual('%X' % 15, 'F')
+        self.assertEqual('%o' % 9, '11')
+        self.assertEqual('%c' % 109, 'm')
+        self.assertEqual('%x' % letter_m, '6d')
+        self.assertEqual('%X' % letter_m, '6D')
+        self.assertEqual('%o' % letter_m, '155')
+        self.assertEqual('%c' % letter_m, 'm')
+        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
+        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
+        self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
+        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
+        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
+        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
+        self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
+        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)
+
+        class RaisingNumber:
+            def __int__(self):
+                raise RuntimeError('int')  # should not be `TypeError`
+            def __index__(self):
+                raise RuntimeError('index')  # should not be `TypeError`
+
+        rn = RaisingNumber()
+        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%d', rn)
+        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%i', rn)
+        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%u', rn)
+        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%x', rn)
+        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%X', rn)
+        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%o', rn)
+
+    def test_formatting_with_enum(self):
+        # issue18780
+        import enum
+        class Float(float, enum.Enum):
+            # a mixed-in type will use the name for %s etc.
+            PI = 3.1415926
+        class Int(enum.IntEnum):
+            # IntEnum uses the value and not the name for %s etc.
+            IDES = 15
+        class Str(enum.StrEnum):
+            # StrEnum uses the value and not the name for %s etc.
+            ABC = 'abc'
+        # Testing Unicode formatting strings...
+        self.assertEqual("%s, %s" % (Str.ABC, Str.ABC),
+                         'abc, abc')
+        self.assertEqual("%s, %s, %d, %i, %u, %f, %5.2f" %
+                        (Str.ABC, Str.ABC,
+                         Int.IDES, Int.IDES, Int.IDES,
+                         Float.PI, Float.PI),
+                         'abc, abc, 15, 15, 15, 3.141593,  3.14')
+
+        # formatting jobs delegated from the string implementation:
+        self.assertEqual('...%(foo)s...' % {'foo':Str.ABC},
+                         '...abc...')
+        self.assertEqual('...%(foo)r...' % {'foo':Int.IDES},
+                         '...<Int.IDES: 15>...')
+        self.assertEqual('...%(foo)s...' % {'foo':Int.IDES},
+                         '...15...')
+        self.assertEqual('...%(foo)i...' % {'foo':Int.IDES},
+                         '...15...')
+        self.assertEqual('...%(foo)d...' % {'foo':Int.IDES},
+                         '...15...')
+        self.assertEqual('...%(foo)u...' % {'foo':Int.IDES, 'def':Float.PI},
+                         '...15...')
+        self.assertEqual('...%(foo)f...' % {'foo':Float.PI,'def':123},
+                         '...3.141593...')
+
+    def test_formatting_huge_precision(self):
+        format_string = "%.{}f".format(sys.maxsize + 1)
+        with self.assertRaises(ValueError):
+            result = format_string % 2.34
+
+    def test_issue28598_strsubclass_rhs(self):
+        # A subclass of str with an __rmod__ method should be able to hook
+        # into the % operator
+        class SubclassedStr(str):
+            def __rmod__(self, other):
+                return 'Success, self.__rmod__({!r}) was called'.format(other)
+        self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
+                         "Success, self.__rmod__('lhs %% %r') was called")
+
+    @support.cpython_only
+    @unittest.skipIf(_testcapi is None, 'need _testcapi module')
+    def test_formatting_huge_precision_c_limits(self):
+        format_string = "%.{}f".format(_testcapi.INT_MAX + 1)
+        with self.assertRaises(ValueError):
+            result = format_string % 2.34
+
+    def test_formatting_huge_width(self):
+        format_string = "%{}f".format(sys.maxsize + 1)
+        with self.assertRaises(ValueError):
+            result = format_string % 2.34
+
+    def test_startswith_endswith_errors(self):
+        for meth in ('foo'.startswith, 'foo'.endswith):
+            with self.assertRaises(TypeError) as cm:
+                meth(['f'])
+            exc = str(cm.exception)
+            self.assertIn('str', exc)
+            self.assertIn('tuple', exc)
+
+    @support.run_with_locale('LC_ALL', 'de_DE', 'fr_FR', '')
+    def test_format_float(self):
+        # should not format with a comma, but always with C locale
+        self.assertEqual('1.0', '%.1f' % 1.0)
+
+    def test_constructor(self):
+        # unicode(obj) tests (this maps to PyObject_Unicode() at C level)
+
+        self.assertEqual(
+            str('unicode remains unicode'),
+            'unicode remains unicode'
+        )
+
+        for text in ('ascii', '\xe9', '\u20ac', '\U0010FFFF'):
+            subclass = StrSubclass(text)
+            self.assertEqual(str(subclass), text)
+            self.assertEqual(len(subclass), len(text))
+            if text == 'ascii':
+                self.assertEqual(subclass.encode('ascii'), b'ascii')
+                self.assertEqual(subclass.encode('utf-8'), b'ascii')
+
+        self.assertEqual(
+            str('strings are converted to unicode'),
+            'strings are converted to unicode'
+        )
+
+        class StringCompat:
+            def __init__(self, x):
+                self.x = x
+            def __str__(self):
+                return self.x
+
+        self.assertEqual(
+            str(StringCompat('__str__ compatible objects are recognized')),
+            '__str__ compatible objects are recognized'
+        )
+
+        # unicode(obj) is compatible to str():
+
+        o = StringCompat('unicode(obj) is compatible to str()')
+        self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
+        self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
+
+        for obj in (123, 123.45, 123):
+            self.assertEqual(str(obj), str(str(obj)))
+
+        # unicode(obj, encoding, error) tests (this maps to
+        # PyUnicode_FromEncodedObject() at C level)
+
+        self.assertRaises(
+            TypeError,
+            str,
+            'decoding unicode is not supported',
+            'utf-8',
+            'strict'
+        )
+
+        self.assertEqual(
+            str(b'strings are decoded to unicode', 'utf-8', 'strict'),
+            'strings are decoded to unicode'
+        )
+
+        self.assertEqual(
+            str(
+                memoryview(b'character buffers are decoded to unicode'),
+                'utf-8',
+                'strict'
+            ),
+            'character buffers are decoded to unicode'
+        )
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_constructor_keyword_args(self):
+        """Pass various keyword argument combinations to the constructor."""
+        # The object argument can be passed as a keyword.
+        self.assertEqual(str(object='foo'), 'foo')
+        self.assertEqual(str(object=b'foo', encoding='utf-8'), 'foo')
+        # The errors argument without encoding triggers "decode" mode.
+        self.assertEqual(str(b'foo', errors='strict'), 'foo')  # not "b'foo'"
+        self.assertEqual(str(object=b'foo', errors='strict'), 'foo')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_constructor_defaults(self):
+        """Check the constructor argument defaults."""
+        # The object argument defaults to '' or b''.
+        self.assertEqual(str(), '')
+        self.assertEqual(str(errors='strict'), '')
+        utf8_cent = '¢'.encode('utf-8')
+        # The encoding argument defaults to utf-8.
+        self.assertEqual(str(utf8_cent, errors='strict'), '¢')
+        # 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
+            ('Hi Mom -\u263a-!', b'Hi Mom -+Jjo--!'),     # RFC2152 example
+            ('\u65E5\u672C\u8A9E', b'+ZeVnLIqe-'),        # RFC2152 example
+            ('Item 3 is \u00a31.', b'Item 3 is +AKM-1.'), # RFC2152 example
+            ('+', b'+-'),
+            ('+-', b'+--'),
+            ('+?', b'+-?'),
+            (r'\?', b'+AFw?'),
+            ('+?', b'+-?'),
+            (r'\\?', b'+AFwAXA?'),
+            (r'\\\?', b'+AFwAXABc?'),
+            (r'++--', b'+-+---'),
+            ('\U000abcde', b'+2m/c3g-'),                  # surrogate pairs
+            ('/', b'/'),
+        ]
+
+        for (x, y) in utfTests:
+            self.assertEqual(x.encode('utf-7'), y)
+
+        # Unpaired surrogates are passed through
+        self.assertEqual('\uD801'.encode('utf-7'), b'+2AE-')
+        self.assertEqual('\uD801x'.encode('utf-7'), b'+2AE-x')
+        self.assertEqual('\uDC01'.encode('utf-7'), b'+3AE-')
+        self.assertEqual('\uDC01x'.encode('utf-7'), b'+3AE-x')
+        self.assertEqual(b'+2AE-'.decode('utf-7'), '\uD801')
+        self.assertEqual(b'+2AE-x'.decode('utf-7'), '\uD801x')
+        self.assertEqual(b'+3AE-'.decode('utf-7'), '\uDC01')
+        self.assertEqual(b'+3AE-x'.decode('utf-7'), '\uDC01x')
+
+        self.assertEqual('\uD801\U000abcde'.encode('utf-7'), b'+2AHab9ze-')
+        self.assertEqual(b'+2AHab9ze-'.decode('utf-7'), '\uD801\U000abcde')
+
+        # Issue #2242: crash on some Windows/MSVC versions
+        self.assertEqual(b'+\xc1'.decode('utf-7', 'ignore'), '')
+
+        # Direct encoded characters
+        set_d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'(),-./:?"
+        # Optional direct characters
+        set_o = '!"#$%&*;<=>@[]^_`{|}'
+        for c in set_d:
+            self.assertEqual(c.encode('utf7'), c.encode('ascii'))
+            self.assertEqual(c.encode('ascii').decode('utf7'), c)
+        for c in set_o:
+            self.assertEqual(c.encode('ascii').decode('utf7'), c)
+
+        with self.assertRaisesRegex(UnicodeDecodeError,
+                                    'ill-formed sequence'):
+            b'+@'.decode('utf-7')
+
+    def test_codecs_utf8(self):
+        self.assertEqual(''.encode('utf-8'), b'')
+        self.assertEqual('\u20ac'.encode('utf-8'), b'\xe2\x82\xac')
+        self.assertEqual('\U00010002'.encode('utf-8'), b'\xf0\x90\x80\x82')
+        self.assertEqual('\U00023456'.encode('utf-8'), b'\xf0\xa3\x91\x96')
+        self.assertEqual('\ud800'.encode('utf-8', 'surrogatepass'), b'\xed\xa0\x80')
+        self.assertEqual('\udc00'.encode('utf-8', 'surrogatepass'), b'\xed\xb0\x80')
+        self.assertEqual(('\U00010002'*10).encode('utf-8'),
+                         b'\xf0\x90\x80\x82'*10)
+        self.assertEqual(
+            '\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
+            '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
+            '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
+            '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
+            '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das'
+            ' Nunstuck git und'.encode('utf-8'),
+            b'\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81'
+            b'\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3'
+            b'\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe'
+            b'\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'
+            b'\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8'
+            b'\xaa\x9e\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81'
+            b'\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81'
+            b'\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3'
+            b'\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf'
+            b'\xe3\x80\x8cWenn ist das Nunstuck git und'
+        )
+
+        # UTF-8 specific decoding tests
+        self.assertEqual(str(b'\xf0\xa3\x91\x96', 'utf-8'), '\U00023456' )
+        self.assertEqual(str(b'\xf0\x90\x80\x82', 'utf-8'), '\U00010002' )
+        self.assertEqual(str(b'\xe2\x82\xac', 'utf-8'), '\u20ac' )
+
+        # Other possible utf-8 test cases:
+        # * strict decoding testing for all of the
+        #   UTF8_ERROR cases in PyUnicode_DecodeUTF8
+
+    def test_utf8_decode_valid_sequences(self):
+        sequences = [
+            # single byte
+            (b'\x00', '\x00'), (b'a', 'a'), (b'\x7f', '\x7f'),
+            # 2 bytes
+            (b'\xc2\x80', '\x80'), (b'\xdf\xbf', '\u07ff'),
+            # 3 bytes
+            (b'\xe0\xa0\x80', '\u0800'), (b'\xed\x9f\xbf', '\ud7ff'),
+            (b'\xee\x80\x80', '\uE000'), (b'\xef\xbf\xbf', '\uffff'),
+            # 4 bytes
+            (b'\xF0\x90\x80\x80', '\U00010000'),
+            (b'\xf4\x8f\xbf\xbf', '\U0010FFFF')
+        ]
+        for seq, res in sequences:
+            self.assertEqual(seq.decode('utf-8'), res)
+
+
+    def test_utf8_decode_invalid_sequences(self):
+        # continuation bytes in a sequence of 2, 3, or 4 bytes
+        continuation_bytes = [bytes([x]) for x in range(0x80, 0xC0)]
+        # start bytes of a 2-byte sequence equivalent to code points < 0x7F
+        invalid_2B_seq_start_bytes = [bytes([x]) for x in range(0xC0, 0xC2)]
+        # start bytes of a 4-byte sequence equivalent to code points > 0x10FFFF
+        invalid_4B_seq_start_bytes = [bytes([x]) for x in range(0xF5, 0xF8)]
+        invalid_start_bytes = (
+            continuation_bytes + invalid_2B_seq_start_bytes +
+            invalid_4B_seq_start_bytes + [bytes([x]) for x in range(0xF7, 0x100)]
+        )
+
+        for byte in invalid_start_bytes:
+            self.assertRaises(UnicodeDecodeError, byte.decode, 'utf-8')
+
+        for sb in invalid_2B_seq_start_bytes:
+            for cb in continuation_bytes:
+                self.assertRaises(UnicodeDecodeError, (sb+cb).decode, 'utf-8')
+
+        for sb in invalid_4B_seq_start_bytes:
+            for cb1 in continuation_bytes[:3]:
+                for cb3 in continuation_bytes[:3]:
+                    self.assertRaises(UnicodeDecodeError,
+                                      (sb+cb1+b'\x80'+cb3).decode, 'utf-8')
+
+        for cb in [bytes([x]) for x in range(0x80, 0xA0)]:
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xE0'+cb+b'\x80').decode, 'utf-8')
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xE0'+cb+b'\xBF').decode, 'utf-8')
+        # surrogates
+        for cb in [bytes([x]) for x in range(0xA0, 0xC0)]:
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xED'+cb+b'\x80').decode, 'utf-8')
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xED'+cb+b'\xBF').decode, 'utf-8')
+        for cb in [bytes([x]) for x in range(0x80, 0x90)]:
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xF0'+cb+b'\x80\x80').decode, 'utf-8')
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xF0'+cb+b'\xBF\xBF').decode, 'utf-8')
+        for cb in [bytes([x]) for x in range(0x90, 0xC0)]:
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xF4'+cb+b'\x80\x80').decode, 'utf-8')
+            self.assertRaises(UnicodeDecodeError,
+                              (b'\xF4'+cb+b'\xBF\xBF').decode, 'utf-8')
+
+    def test_issue127903(self):
+        # gh-127903: ``_copy_characters`` crashes on DEBUG builds when
+        # there is nothing to copy.
+        d = datetime.datetime(2013, 11, 10, 14, 20, 59)
+        self.assertEqual(d.strftime('%z'), '')
+
+    def test_issue8271(self):
+        # Issue #8271: during the decoding of an invalid UTF-8 byte sequence,
+        # only the start byte and the continuation byte(s) are now considered
+        # invalid, instead of the number of bytes specified by the start byte.
+        # See https://www.unicode.org/versions/Unicode5.2.0/ch03.pdf (page 95,
+        # table 3-8, Row 2) for more information about the algorithm used.
+        FFFD = '\ufffd'
+        sequences = [
+            # invalid start bytes
+            (b'\x80', FFFD), # continuation byte
+            (b'\x80\x80', FFFD*2), # 2 continuation bytes
+            (b'\xc0', FFFD),
+            (b'\xc0\xc0', FFFD*2),
+            (b'\xc1', FFFD),
+            (b'\xc1\xc0', FFFD*2),
+            (b'\xc0\xc1', FFFD*2),
+            # with start byte of a 2-byte sequence
+            (b'\xc2', FFFD), # only the start byte
+            (b'\xc2\xc2', FFFD*2), # 2 start bytes
+            (b'\xc2\xc2\xc2', FFFD*3), # 3 start bytes
+            (b'\xc2\x41', FFFD+'A'), # invalid continuation byte
+            # with start byte of a 3-byte sequence
+            (b'\xe1', FFFD), # only the start byte
+            (b'\xe1\xe1', FFFD*2), # 2 start bytes
+            (b'\xe1\xe1\xe1', FFFD*3), # 3 start bytes
+            (b'\xe1\xe1\xe1\xe1', FFFD*4), # 4 start bytes
+            (b'\xe1\x80', FFFD), # only 1 continuation byte
+            (b'\xe1\x41', FFFD+'A'), # invalid continuation byte
+            (b'\xe1\x41\x80', FFFD+'A'+FFFD), # invalid cb followed by valid cb
+            (b'\xe1\x41\x41', FFFD+'AA'), # 2 invalid continuation bytes
+            (b'\xe1\x80\x41', FFFD+'A'), # only 1 valid continuation byte
+            (b'\xe1\x80\xe1\x41', FFFD*2+'A'), # 1 valid and the other invalid
+            (b'\xe1\x41\xe1\x80', FFFD+'A'+FFFD), # 1 invalid and the other valid
+            # with start byte of a 4-byte sequence
+            (b'\xf1', FFFD), # only the start byte
+            (b'\xf1\xf1', FFFD*2), # 2 start bytes
+            (b'\xf1\xf1\xf1', FFFD*3), # 3 start bytes
+            (b'\xf1\xf1\xf1\xf1', FFFD*4), # 4 start bytes
+            (b'\xf1\xf1\xf1\xf1\xf1', FFFD*5), # 5 start bytes
+            (b'\xf1\x80', FFFD), # only 1 continuation bytes
+            (b'\xf1\x80\x80', FFFD), # only 2 continuation bytes
+            (b'\xf1\x80\x41', FFFD+'A'), # 1 valid cb and 1 invalid
+            (b'\xf1\x80\x41\x41', FFFD+'AA'), # 1 valid cb and 1 invalid
+            (b'\xf1\x80\x80\x41', FFFD+'A'), # 2 valid cb and 1 invalid
+            (b'\xf1\x41\x80', FFFD+'A'+FFFD), # 1 invalid cv and 1 valid
+            (b'\xf1\x41\x80\x80', FFFD+'A'+FFFD*2), # 1 invalid cb and 2 invalid
+            (b'\xf1\x41\x80\x41', FFFD+'A'+FFFD+'A'), # 2 invalid cb and 1 invalid
+            (b'\xf1\x41\x41\x80', FFFD+'AA'+FFFD), # 1 valid cb and 1 invalid
+            (b'\xf1\x41\xf1\x80', FFFD+'A'+FFFD),
+            (b'\xf1\x41\x80\xf1', FFFD+'A'+FFFD*2),
+            (b'\xf1\xf1\x80\x41', FFFD*2+'A'),
+            (b'\xf1\x41\xf1\xf1', FFFD+'A'+FFFD*2),
+            # with invalid start byte of a 4-byte sequence (rfc2279)
+            (b'\xf5', FFFD), # only the start byte
+            (b'\xf5\xf5', FFFD*2), # 2 start bytes
+            (b'\xf5\x80', FFFD*2), # only 1 continuation byte
+            (b'\xf5\x80\x80', FFFD*3), # only 2 continuation byte
+            (b'\xf5\x80\x80\x80', FFFD*4), # 3 continuation bytes
+            (b'\xf5\x80\x41', FFFD*2+'A'), #  1 valid cb and 1 invalid
+            (b'\xf5\x80\x41\xf5', FFFD*2+'A'+FFFD),
+            (b'\xf5\x41\x80\x80\x41', FFFD+'A'+FFFD*2+'A'),
+            # with invalid start byte of a 5-byte sequence (rfc2279)
+            (b'\xf8', FFFD), # only the start byte
+            (b'\xf8\xf8', FFFD*2), # 2 start bytes
+            (b'\xf8\x80', FFFD*2), # only one continuation byte
+            (b'\xf8\x80\x41', FFFD*2 + 'A'), # 1 valid cb and 1 invalid
+            (b'\xf8\x80\x80\x80\x80', FFFD*5), # invalid 5 bytes seq with 5 bytes
+            # with invalid start byte of a 6-byte sequence (rfc2279)
+            (b'\xfc', FFFD), # only the start byte
+            (b'\xfc\xfc', FFFD*2), # 2 start bytes
+            (b'\xfc\x80\x80', FFFD*3), # only 2 continuation bytes
+            (b'\xfc\x80\x80\x80\x80\x80', FFFD*6), # 6 continuation bytes
+            # invalid start byte
+            (b'\xfe', FFFD),
+            (b'\xfe\x80\x80', FFFD*3),
+            # other sequences
+            (b'\xf1\x80\x41\x42\x43', '\ufffd\x41\x42\x43'),
+            (b'\xf1\x80\xff\x42\x43', '\ufffd\ufffd\x42\x43'),
+            (b'\xf1\x80\xc2\x81\x43', '\ufffd\x81\x43'),
+            (b'\x61\xF1\x80\x80\xE1\x80\xC2\x62\x80\x63\x80\xBF\x64',
+             '\x61\uFFFD\uFFFD\uFFFD\x62\uFFFD\x63\uFFFD\uFFFD\x64'),
+        ]
+        for n, (seq, res) in enumerate(sequences):
+            self.assertRaises(UnicodeDecodeError, seq.decode, 'utf-8', 'strict')
+            self.assertEqual(seq.decode('utf-8', 'replace'), res)
+            self.assertEqual((seq+b'b').decode('utf-8', 'replace'), res+'b')
+            self.assertEqual(seq.decode('utf-8', 'ignore'),
+                             res.replace('\uFFFD', ''))
+
+    def assertCorrectUTF8Decoding(self, seq, res, err):
+        """
+        Check that an invalid UTF-8 sequence raises a UnicodeDecodeError when
+        'strict' is used, returns res when 'replace' is used, and that doesn't
+        return anything when 'ignore' is used.
+        """
+        with self.assertRaises(UnicodeDecodeError) as cm:
+            seq.decode('utf-8')
+        exc = cm.exception
+
+        self.assertIn(err, str(exc))
+        self.assertEqual(seq.decode('utf-8', 'replace'), res)
+        self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'replace'),
+                         'aaaa' + res + 'bbbb')
+        res = res.replace('\ufffd', '')
+        self.assertEqual(seq.decode('utf-8', 'ignore'), res)
+        self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'ignore'),
+                          'aaaa' + res + 'bbbb')
+
+    def test_invalid_start_byte(self):
+        """
+        Test that an 'invalid start byte' error is raised when the first byte
+        is not in the ASCII range or is not a valid start byte of a 2-, 3-, or
+        4-bytes sequence. The invalid start byte is replaced with a single
+        U+FFFD when errors='replace'.
+        E.g. <80> is a continuation byte and can appear only after a start byte.
+        """
+        FFFD = '\ufffd'
+        for byte in b'\x80\xA0\x9F\xBF\xC0\xC1\xF5\xFF':
+            self.assertCorrectUTF8Decoding(bytes([byte]), '\ufffd',
+                                           'invalid start byte')
+
+    def test_unexpected_end_of_data(self):
+        """
+        Test that an 'unexpected end of data' error is raised when the string
+        ends after a start byte of a 2-, 3-, or 4-bytes sequence without having
+        enough continuation bytes.  The incomplete sequence is replaced with a
+        single U+FFFD when errors='replace'.
+        E.g. in the sequence <F3 80 80>, F3 is the start byte of a 4-bytes
+        sequence, but it's followed by only 2 valid continuation bytes and the
+        last continuation bytes is missing.
+        Note: the continuation bytes must be all valid, if one of them is
+        invalid another error will be raised.
+        """
+        sequences = [
+            'C2', 'DF',
+            'E0 A0', 'E0 BF', 'E1 80', 'E1 BF', 'EC 80', 'EC BF',
+            'ED 80', 'ED 9F', 'EE 80', 'EE BF', 'EF 80', 'EF BF',
+            'F0 90', 'F0 BF', 'F0 90 80', 'F0 90 BF', 'F0 BF 80', 'F0 BF BF',
+            'F1 80', 'F1 BF', 'F1 80 80', 'F1 80 BF', 'F1 BF 80', 'F1 BF BF',
+            'F3 80', 'F3 BF', 'F3 80 80', 'F3 80 BF', 'F3 BF 80', 'F3 BF BF',
+            'F4 80', 'F4 8F', 'F4 80 80', 'F4 80 BF', 'F4 8F 80', 'F4 8F BF'
+        ]
+        FFFD = '\ufffd'
+        for seq in sequences:
+            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), '\ufffd',
+                                           'unexpected end of data')
+
+    def test_invalid_cb_for_2bytes_seq(self):
+        """
+        Test that an 'invalid continuation byte' error is raised when the
+        continuation byte of a 2-bytes sequence is invalid.  The start byte
+        is replaced by a single U+FFFD and the second byte is handled
+        separately when errors='replace'.
+        E.g. in the sequence <C2 41>, C2 is the start byte of a 2-bytes
+        sequence, but 41 is not a valid continuation byte because it's the
+        ASCII letter 'A'.
+        """
+        FFFD = '\ufffd'
+        FFFDx2 = FFFD * 2
+        sequences = [
+            ('C2 00', FFFD+'\x00'), ('C2 7F', FFFD+'\x7f'),
+            ('C2 C0', FFFDx2), ('C2 FF', FFFDx2),
+            ('DF 00', FFFD+'\x00'), ('DF 7F', FFFD+'\x7f'),
+            ('DF C0', FFFDx2), ('DF FF', FFFDx2),
+        ]
+        for seq, res in sequences:
+            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
+                                           'invalid continuation byte')
+
+    def test_invalid_cb_for_3bytes_seq(self):
+        """
+        Test that an 'invalid continuation byte' error is raised when the
+        continuation byte(s) of a 3-bytes sequence are invalid.  When
+        errors='replace', if the first continuation byte is valid, the first
+        two bytes (start byte + 1st cb) are replaced by a single U+FFFD and the
+        third byte is handled separately, otherwise only the start byte is
+        replaced with a U+FFFD and the other continuation bytes are handled
+        separately.
+        E.g. in the sequence <E1 80 41>, E1 is the start byte of a 3-bytes
+        sequence, 80 is a valid continuation byte, but 41 is not a valid cb
+        because it's the ASCII letter 'A'.
+        Note: when the start byte is E0 or ED, the valid ranges for the first
+        continuation byte are limited to A0..BF and 80..9F respectively.
+        Python 2 used to consider all the bytes in range 80..BF valid when the
+        start byte was ED.  This is fixed in Python 3.
+        """
+        FFFD = '\ufffd'
+        FFFDx2 = FFFD * 2
+        sequences = [
+            ('E0 00', FFFD+'\x00'), ('E0 7F', FFFD+'\x7f'), ('E0 80', FFFDx2),
+            ('E0 9F', FFFDx2), ('E0 C0', FFFDx2), ('E0 FF', FFFDx2),
+            ('E0 A0 00', FFFD+'\x00'), ('E0 A0 7F', FFFD+'\x7f'),
+            ('E0 A0 C0', FFFDx2), ('E0 A0 FF', FFFDx2),
+            ('E0 BF 00', FFFD+'\x00'), ('E0 BF 7F', FFFD+'\x7f'),
+            ('E0 BF C0', FFFDx2), ('E0 BF FF', FFFDx2), ('E1 00', FFFD+'\x00'),
+            ('E1 7F', FFFD+'\x7f'), ('E1 C0', FFFDx2), ('E1 FF', FFFDx2),
+            ('E1 80 00', FFFD+'\x00'), ('E1 80 7F', FFFD+'\x7f'),
+            ('E1 80 C0', FFFDx2), ('E1 80 FF', FFFDx2),
+            ('E1 BF 00', FFFD+'\x00'), ('E1 BF 7F', FFFD+'\x7f'),
+            ('E1 BF C0', FFFDx2), ('E1 BF FF', FFFDx2), ('EC 00', FFFD+'\x00'),
+            ('EC 7F', FFFD+'\x7f'), ('EC C0', FFFDx2), ('EC FF', FFFDx2),
+            ('EC 80 00', FFFD+'\x00'), ('EC 80 7F', FFFD+'\x7f'),
+            ('EC 80 C0', FFFDx2), ('EC 80 FF', FFFDx2),
+            ('EC BF 00', FFFD+'\x00'), ('EC BF 7F', FFFD+'\x7f'),
+            ('EC BF C0', FFFDx2), ('EC BF FF', FFFDx2), ('ED 00', FFFD+'\x00'),
+            ('ED 7F', FFFD+'\x7f'),
+            ('ED A0', FFFDx2), ('ED BF', FFFDx2), # see note ^
+            ('ED C0', FFFDx2), ('ED FF', FFFDx2), ('ED 80 00', FFFD+'\x00'),
+            ('ED 80 7F', FFFD+'\x7f'), ('ED 80 C0', FFFDx2),
+            ('ED 80 FF', FFFDx2), ('ED 9F 00', FFFD+'\x00'),
+            ('ED 9F 7F', FFFD+'\x7f'), ('ED 9F C0', FFFDx2),
+            ('ED 9F FF', FFFDx2), ('EE 00', FFFD+'\x00'),
+            ('EE 7F', FFFD+'\x7f'), ('EE C0', FFFDx2), ('EE FF', FFFDx2),
+            ('EE 80 00', FFFD+'\x00'), ('EE 80 7F', FFFD+'\x7f'),
+            ('EE 80 C0', FFFDx2), ('EE 80 FF', FFFDx2),
+            ('EE BF 00', FFFD+'\x00'), ('EE BF 7F', FFFD+'\x7f'),
+            ('EE BF C0', FFFDx2), ('EE BF FF', FFFDx2), ('EF 00', FFFD+'\x00'),
+            ('EF 7F', FFFD+'\x7f'), ('EF C0', FFFDx2), ('EF FF', FFFDx2),
+            ('EF 80 00', FFFD+'\x00'), ('EF 80 7F', FFFD+'\x7f'),
+            ('EF 80 C0', FFFDx2), ('EF 80 FF', FFFDx2),
+            ('EF BF 00', FFFD+'\x00'), ('EF BF 7F', FFFD+'\x7f'),
+            ('EF BF C0', FFFDx2), ('EF BF FF', FFFDx2),
+        ]
+        for seq, res in sequences:
+            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
+                                           'invalid continuation byte')
+
+    def test_invalid_cb_for_4bytes_seq(self):
+        """
+        Test that an 'invalid continuation byte' error is raised when the
+        continuation byte(s) of a 4-bytes sequence are invalid.  When
+        errors='replace',the start byte and all the following valid
+        continuation bytes are replaced with a single U+FFFD, and all the bytes
+        starting from the first invalid continuation bytes (included) are
+        handled separately.
+        E.g. in the sequence <E1 80 41>, E1 is the start byte of a 3-bytes
+        sequence, 80 is a valid continuation byte, but 41 is not a valid cb
+        because it's the ASCII letter 'A'.
+        Note: when the start byte is E0 or ED, the valid ranges for the first
+        continuation byte are limited to A0..BF and 80..9F respectively.
+        However, when the start byte is ED, Python 2 considers all the bytes
+        in range 80..BF valid.  This is fixed in Python 3.
+        """
+        FFFD = '\ufffd'
+        FFFDx2 = FFFD * 2
+        sequences = [
+            ('F0 00', FFFD+'\x00'), ('F0 7F', FFFD+'\x7f'), ('F0 80', FFFDx2),
+            ('F0 8F', FFFDx2), ('F0 C0', FFFDx2), ('F0 FF', FFFDx2),
+            ('F0 90 00', FFFD+'\x00'), ('F0 90 7F', FFFD+'\x7f'),
+            ('F0 90 C0', FFFDx2), ('F0 90 FF', FFFDx2),
+            ('F0 BF 00', FFFD+'\x00'), ('F0 BF 7F', FFFD+'\x7f'),
+            ('F0 BF C0', FFFDx2), ('F0 BF FF', FFFDx2),
+            ('F0 90 80 00', FFFD+'\x00'), ('F0 90 80 7F', FFFD+'\x7f'),
+            ('F0 90 80 C0', FFFDx2), ('F0 90 80 FF', FFFDx2),
+            ('F0 90 BF 00', FFFD+'\x00'), ('F0 90 BF 7F', FFFD+'\x7f'),
+            ('F0 90 BF C0', FFFDx2), ('F0 90 BF FF', FFFDx2),
+            ('F0 BF 80 00', FFFD+'\x00'), ('F0 BF 80 7F', FFFD+'\x7f'),
+            ('F0 BF 80 C0', FFFDx2), ('F0 BF 80 FF', FFFDx2),
+            ('F0 BF BF 00', FFFD+'\x00'), ('F0 BF BF 7F', FFFD+'\x7f'),
+            ('F0 BF BF C0', FFFDx2), ('F0 BF BF FF', FFFDx2),
+            ('F1 00', FFFD+'\x00'), ('F1 7F', FFFD+'\x7f'), ('F1 C0', FFFDx2),
+            ('F1 FF', FFFDx2), ('F1 80 00', FFFD+'\x00'),
+            ('F1 80 7F', FFFD+'\x7f'), ('F1 80 C0', FFFDx2),
+            ('F1 80 FF', FFFDx2), ('F1 BF 00', FFFD+'\x00'),
+            ('F1 BF 7F', FFFD+'\x7f'), ('F1 BF C0', FFFDx2),
+            ('F1 BF FF', FFFDx2), ('F1 80 80 00', FFFD+'\x00'),
+            ('F1 80 80 7F', FFFD+'\x7f'), ('F1 80 80 C0', FFFDx2),
+            ('F1 80 80 FF', FFFDx2), ('F1 80 BF 00', FFFD+'\x00'),
+            ('F1 80 BF 7F', FFFD+'\x7f'), ('F1 80 BF C0', FFFDx2),
+            ('F1 80 BF FF', FFFDx2), ('F1 BF 80 00', FFFD+'\x00'),
+            ('F1 BF 80 7F', FFFD+'\x7f'), ('F1 BF 80 C0', FFFDx2),
+            ('F1 BF 80 FF', FFFDx2), ('F1 BF BF 00', FFFD+'\x00'),
+            ('F1 BF BF 7F', FFFD+'\x7f'), ('F1 BF BF C0', FFFDx2),
+            ('F1 BF BF FF', FFFDx2), ('F3 00', FFFD+'\x00'),
+            ('F3 7F', FFFD+'\x7f'), ('F3 C0', FFFDx2), ('F3 FF', FFFDx2),
+            ('F3 80 00', FFFD+'\x00'), ('F3 80 7F', FFFD+'\x7f'),
+            ('F3 80 C0', FFFDx2), ('F3 80 FF', FFFDx2),
+            ('F3 BF 00', FFFD+'\x00'), ('F3 BF 7F', FFFD+'\x7f'),
+            ('F3 BF C0', FFFDx2), ('F3 BF FF', FFFDx2),
+            ('F3 80 80 00', FFFD+'\x00'), ('F3 80 80 7F', FFFD+'\x7f'),
+            ('F3 80 80 C0', FFFDx2), ('F3 80 80 FF', FFFDx2),
+            ('F3 80 BF 00', FFFD+'\x00'), ('F3 80 BF 7F', FFFD+'\x7f'),
+            ('F3 80 BF C0', FFFDx2), ('F3 80 BF FF', FFFDx2),
+            ('F3 BF 80 00', FFFD+'\x00'), ('F3 BF 80 7F', FFFD+'\x7f'),
+            ('F3 BF 80 C0', FFFDx2), ('F3 BF 80 FF', FFFDx2),
+            ('F3 BF BF 00', FFFD+'\x00'), ('F3 BF BF 7F', FFFD+'\x7f'),
+            ('F3 BF BF C0', FFFDx2), ('F3 BF BF FF', FFFDx2),
+            ('F4 00', FFFD+'\x00'), ('F4 7F', FFFD+'\x7f'), ('F4 90', FFFDx2),
+            ('F4 BF', FFFDx2), ('F4 C0', FFFDx2), ('F4 FF', FFFDx2),
+            ('F4 80 00', FFFD+'\x00'), ('F4 80 7F', FFFD+'\x7f'),
+            ('F4 80 C0', FFFDx2), ('F4 80 FF', FFFDx2),
+            ('F4 8F 00', FFFD+'\x00'), ('F4 8F 7F', FFFD+'\x7f'),
+            ('F4 8F C0', FFFDx2), ('F4 8F FF', FFFDx2),
+            ('F4 80 80 00', FFFD+'\x00'), ('F4 80 80 7F', FFFD+'\x7f'),
+            ('F4 80 80 C0', FFFDx2), ('F4 80 80 FF', FFFDx2),
+            ('F4 80 BF 00', FFFD+'\x00'), ('F4 80 BF 7F', FFFD+'\x7f'),
+            ('F4 80 BF C0', FFFDx2), ('F4 80 BF FF', FFFDx2),
+            ('F4 8F 80 00', FFFD+'\x00'), ('F4 8F 80 7F', FFFD+'\x7f'),
+            ('F4 8F 80 C0', FFFDx2), ('F4 8F 80 FF', FFFDx2),
+            ('F4 8F BF 00', FFFD+'\x00'), ('F4 8F BF 7F', FFFD+'\x7f'),
+            ('F4 8F BF C0', FFFDx2), ('F4 8F BF FF', FFFDx2)
+        ]
+        for seq, res in sequences:
+            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
+                                           'invalid continuation byte')
+
+    def test_codecs_idna(self):
+        # Test whether trailing dot is preserved
+        self.assertEqual("www.python.org.".encode("idna"), b"www.python.org.")
+
+    def test_codecs_errors(self):
+        # Error handling (encoding)
+        self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii')
+        self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii','strict')
+        self.assertEqual('Andr\202 x'.encode('ascii','ignore'), b"Andr x")
+        self.assertEqual('Andr\202 x'.encode('ascii','replace'), b"Andr? x")
+        self.assertEqual('Andr\202 x'.encode('ascii', 'replace'),
+                         'Andr\202 x'.encode('ascii', errors='replace'))
+        self.assertEqual('Andr\202 x'.encode('ascii', 'ignore'),
+                         'Andr\202 x'.encode(encoding='ascii', errors='ignore'))
+
+        # Error handling (decoding)
+        self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii')
+        self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii', 'strict')
+        self.assertEqual(str(b'Andr\202 x', 'ascii', 'ignore'), "Andr x")
+        self.assertEqual(str(b'Andr\202 x', 'ascii', 'replace'), 'Andr\uFFFD x')
+        self.assertEqual(str(b'\202 x', 'ascii', 'replace'), '\uFFFD x')
+
+        # Error handling (unknown character names)
+        self.assertEqual(b"\\N{foo}xx".decode("unicode-escape", "ignore"), "xx")
+
+        # Error handling (truncated escape sequence)
+        self.assertRaises(UnicodeError, b"\\".decode, "unicode-escape")
+
+        self.assertRaises(TypeError, b"hello".decode, "test.unicode1")
+        self.assertRaises(TypeError, str, b"hello", "test.unicode2")
+        self.assertRaises(TypeError, "hello".encode, "test.unicode1")
+        self.assertRaises(TypeError, "hello".encode, "test.unicode2")
+
+        # Error handling (wrong arguments)
+        self.assertRaises(TypeError, "hello".encode, 42, 42, 42)
+
+        # Error handling (lone surrogate in
+        # _PyUnicode_TransformDecimalAndSpaceToASCII())
+        self.assertRaises(ValueError, int, "\ud800")
+        self.assertRaises(ValueError, int, "\udf00")
+        self.assertRaises(ValueError, float, "\ud800")
+        self.assertRaises(ValueError, float, "\udf00")
+        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')
+        self.assertEqual('hello'.encode('utf-7'), b'hello')
+        self.assertEqual('hello'.encode('utf-8'), b'hello')
+        self.assertEqual('hello'.encode('utf-8'), b'hello')
+        self.assertEqual('hello'.encode('utf-16-le'), b'h\000e\000l\000l\000o\000')
+        self.assertEqual('hello'.encode('utf-16-be'), b'\000h\000e\000l\000l\000o')
+        self.assertEqual('hello'.encode('latin-1'), b'hello')
+
+        # Default encoding is utf-8
+        self.assertEqual('\u2603'.encode(), b'\xe2\x98\x83')
+
+        # Roundtrip safety for BMP (just the first 1024 chars)
+        for c in range(1024):
+            u = chr(c)
+            for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le',
+                             'utf-16-be', 'raw_unicode_escape',
+                             'unicode_escape'):
+                self.assertEqual(str(u.encode(encoding),encoding), u)
+
+        # Roundtrip safety for BMP (just the first 256 chars)
+        for c in range(256):
+            u = chr(c)
+            for encoding in ('latin-1',):
+                self.assertEqual(str(u.encode(encoding),encoding), u)
+
+        # Roundtrip safety for BMP (just the first 128 chars)
+        for c in range(128):
+            u = chr(c)
+            for encoding in ('ascii',):
+                self.assertEqual(str(u.encode(encoding),encoding), u)
+
+        # Roundtrip safety for non-BMP (just a few chars)
+        with warnings.catch_warnings():
+            u = '\U00010001\U00020002\U00030003\U00040004\U00050005'
+            for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',
+                             'raw_unicode_escape', 'unicode_escape'):
+                self.assertEqual(str(u.encode(encoding),encoding), u)
+
+        # UTF-8 must be roundtrip safe for all code points
+        # (except surrogates, which are forbidden).
+        u = ''.join(map(chr, list(range(0, 0xd800)) +
+                             list(range(0xe000, 0x110000))))
+        for encoding in ('utf-8',):
+            self.assertEqual(str(u.encode(encoding),encoding), u)
+
+    def test_codecs_charmap(self):
+        # 0-127
+        s = bytes(range(128))
+        for encoding in (
+            'cp037', 'cp1026', 'cp273',
+            'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',
+            'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',
+            'cp863', 'cp865', 'cp866', 'cp1125',
+            'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
+            'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6',
+            'iso8859_7', 'iso8859_9',
+            'koi8_r', 'koi8_t', 'koi8_u', 'kz1048', 'latin_1',
+            'mac_cyrillic', 'mac_latin2',
+
+            'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
+            'cp1256', 'cp1257', 'cp1258',
+            'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
+
+            'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
+            'cp1006', 'iso8859_8',
+
+            ### These have undefined mappings:
+            #'cp424',
+
+            ### These fail the round-trip:
+            #'cp875'
+
+            ):
+            self.assertEqual(str(s, encoding).encode(encoding), s)
+
+        # 128-255
+        s = bytes(range(128, 256))
+        for encoding in (
+            'cp037', 'cp1026', 'cp273',
+            'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',
+            'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',
+            'cp863', 'cp865', 'cp866', 'cp1125',
+            'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
+            'iso8859_2', 'iso8859_4', 'iso8859_5',
+            'iso8859_9', 'koi8_r', 'koi8_u', 'latin_1',
+            'mac_cyrillic', 'mac_latin2',
+
+            ### These have undefined mappings:
+            #'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
+            #'cp1256', 'cp1257', 'cp1258',
+            #'cp424', 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
+            #'iso8859_3', 'iso8859_6', 'iso8859_7', 'koi8_t', 'kz1048',
+            #'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
+
+            ### These fail the round-trip:
+            #'cp1006', 'cp875', 'iso8859_8',
+
+            ):
+            self.assertEqual(str(s, encoding).encode(encoding), s)
+
+    def test_concatenation(self):
+        self.assertEqual(("abc" "def"), "abcdef")
+        self.assertEqual(("abc" "def"), "abcdef")
+        self.assertEqual(("abc" "def"), "abcdef")
+        self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
+        self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
+
+    def test_ucs4(self):
+        x = '\U00100000'
+        y = x.encode("raw-unicode-escape").decode("raw-unicode-escape")
+        self.assertEqual(x, y)
+
+        y = br'\U00100000'
+        x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")
+        self.assertEqual(x, y)
+        y = br'\U00010000'
+        x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")
+        self.assertEqual(x, y)
+
+        try:
+            br'\U11111111'.decode("raw-unicode-escape")
+        except UnicodeDecodeError as e:
+            self.assertEqual(e.start, 0)
+            self.assertEqual(e.end, 10)
+        else:
+            self.fail("Should have raised UnicodeDecodeError")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_conversion(self):
+        # Make sure __str__() works properly
+        class StrWithStr(str):
+            def __new__(cls, value):
+                self = str.__new__(cls, "")
+                self.value = value
+                return self
+            def __str__(self):
+                return self.value
+
+        self.assertTypedEqual(str(WithStr('abc')), 'abc')
+        self.assertTypedEqual(str(WithStr(StrSubclass('abc'))), StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(WithStr('abc')), StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(WithStr(StrSubclass('abc'))),
+                              StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(WithStr(OtherStrSubclass('abc'))),
+                              StrSubclass('abc'))
+
+        self.assertTypedEqual(str(StrWithStr('abc')), 'abc')
+        self.assertTypedEqual(str(StrWithStr(StrSubclass('abc'))), StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(StrWithStr('abc')), StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(StrWithStr(StrSubclass('abc'))),
+                              StrSubclass('abc'))
+        self.assertTypedEqual(StrSubclass(StrWithStr(OtherStrSubclass('abc'))),
+                              StrSubclass('abc'))
+
+        self.assertTypedEqual(str(WithRepr('<abc>')), '<abc>')
+        self.assertTypedEqual(str(WithRepr(StrSubclass('<abc>'))), StrSubclass('<abc>'))
+        self.assertTypedEqual(StrSubclass(WithRepr('<abc>')), StrSubclass('<abc>'))
+        self.assertTypedEqual(StrSubclass(WithRepr(StrSubclass('<abc>'))),
+                              StrSubclass('<abc>'))
+        self.assertTypedEqual(StrSubclass(WithRepr(OtherStrSubclass('<abc>'))),
+                              StrSubclass('<abc>'))
+
+    def test_unicode_repr(self):
+        class s1:
+            def __repr__(self):
+                return '\\n'
+
+        self.assertEqual(repr(s1()), '\\n')
+
+    def test_printable_repr(self):
+        self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,)) # printable
+        self.assertEqual(repr('\U00014000'), "'\\U00014000'")     # nonprintable
+
+    # This test only affects 32-bit platforms because expandtabs can only take
+    # an int as the max value, not a 64-bit C long.  If expandtabs is changed
+    # to take a 64-bit long, this test should apply to all platforms.
+    @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
+                     'only applies to 32-bit platforms')
+    def test_expandtabs_overflows_gracefully(self):
+        self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize)
+
+    @support.cpython_only
+    def test_expandtabs_optimization(self):
+        s = 'abc'
+        self.assertIs(s.expandtabs(), s)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_raiseMemError(self):
+        asciifields = "nnb"
+        compactfields = asciifields + "nP"
+        ascii_struct_size = support.calcobjsize(asciifields)
+        compact_struct_size = support.calcobjsize(compactfields)
+
+        for char in ('a', '\xe9', '\u20ac', '\U0010ffff'):
+            code = ord(char)
+            if code < 0x80:
+                char_size = 1  # sizeof(Py_UCS1)
+                struct_size = ascii_struct_size
+            elif code < 0x100:
+                char_size = 1  # sizeof(Py_UCS1)
+                struct_size = compact_struct_size
+            elif code < 0x10000:
+                char_size = 2  # sizeof(Py_UCS2)
+                struct_size = compact_struct_size
+            else:
+                char_size = 4  # sizeof(Py_UCS4)
+                struct_size = compact_struct_size
+            # Note: sys.maxsize is half of the actual max allocation because of
+            # the signedness of Py_ssize_t. Strings of maxlen-1 should in principle
+            # be allocatable, given enough memory.
+            maxlen = ((sys.maxsize - struct_size) // char_size)
+            alloc = lambda: char * maxlen
+            with self.subTest(
+                char=char,
+                struct_size=struct_size,
+                char_size=char_size
+            ):
+                # self-check
+                self.assertEqual(
+                    sys.getsizeof(char * 42),
+                    struct_size + (char_size * (42 + 1))
+                )
+                self.assertRaises(MemoryError, alloc)
+                self.assertRaises(MemoryError, alloc)
+
+    def test_format_subclass(self):
+        class S(str):
+            def __str__(self):
+                return '__str__ overridden'
+        s = S('xxx')
+        self.assertEqual("%s" % s, '__str__ overridden')
+        self.assertEqual("{}".format(s), '__str__ overridden')
+
+    def test_subclass_add(self):
+        class S(str):
+            def __add__(self, o):
+                return "3"
+        self.assertEqual(S("4") + S("5"), "3")
+        class S(str):
+            def __iadd__(self, o):
+                return "3"
+        s = S("1")
+        s += "4"
+        self.assertEqual(s, "3")
+
+    def test_getnewargs(self):
+        text = 'abc'
+        args = text.__getnewargs__()
+        self.assertIsNot(args[0], text)
+        self.assertEqual(args[0], text)
+        self.assertEqual(len(args), 1)
+
+    def test_compare(self):
+        # Issue #17615
+        N = 10
+        ascii = 'a' * N
+        ascii2 = 'z' * N
+        latin = '\x80' * N
+        latin2 = '\xff' * N
+        bmp = '\u0100' * N
+        bmp2 = '\uffff' * N
+        astral = '\U00100000' * N
+        astral2 = '\U0010ffff' * N
+        strings = (
+            ascii, ascii2,
+            latin, latin2,
+            bmp, bmp2,
+            astral, astral2)
+        for text1, text2 in itertools.combinations(strings, 2):
+            equal = (text1 is text2)
+            self.assertEqual(text1 == text2, equal)
+            self.assertEqual(text1 != text2, not equal)
+
+            if equal:
+                self.assertTrue(text1 <= text2)
+                self.assertTrue(text1 >= text2)
+
+                # text1 is text2: duplicate strings to skip the "str1 == str2"
+                # optimization in unicode_compare_eq() and really compare
+                # character per character
+                copy1 = duplicate_string(text1)
+                copy2 = duplicate_string(text2)
+                self.assertIsNot(copy1, copy2)
+
+                self.assertTrue(copy1 == copy2)
+                self.assertFalse(copy1 != copy2)
+
+                self.assertTrue(copy1 <= copy2)
+                self.assertTrue(copy2 >= copy2)
+
+        self.assertTrue(ascii < ascii2)
+        self.assertTrue(ascii < latin)
+        self.assertTrue(ascii < bmp)
+        self.assertTrue(ascii < astral)
+        self.assertFalse(ascii >= ascii2)
+        self.assertFalse(ascii >= latin)
+        self.assertFalse(ascii >= bmp)
+        self.assertFalse(ascii >= astral)
+
+        self.assertFalse(latin < ascii)
+        self.assertTrue(latin < latin2)
+        self.assertTrue(latin < bmp)
+        self.assertTrue(latin < astral)
+        self.assertTrue(latin >= ascii)
+        self.assertFalse(latin >= latin2)
+        self.assertFalse(latin >= bmp)
+        self.assertFalse(latin >= astral)
+
+        self.assertFalse(bmp < ascii)
+        self.assertFalse(bmp < latin)
+        self.assertTrue(bmp < bmp2)
+        self.assertTrue(bmp < astral)
+        self.assertTrue(bmp >= ascii)
+        self.assertTrue(bmp >= latin)
+        self.assertFalse(bmp >= bmp2)
+        self.assertFalse(bmp >= astral)
+
+        self.assertFalse(astral < ascii)
+        self.assertFalse(astral < latin)
+        self.assertFalse(astral < bmp2)
+        self.assertTrue(astral < astral2)
+        self.assertTrue(astral >= ascii)
+        self.assertTrue(astral >= latin)
+        self.assertTrue(astral >= bmp2)
+        self.assertFalse(astral >= astral2)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_free_after_iterating(self):
+        support.check_free_after_iterating(self, iter, str)
+        support.check_free_after_iterating(self, reversed, str)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_check_encoding_errors(self):
+        # bpo-37388: str(bytes) and str.decode() must check encoding and errors
+        # arguments in dev mode
+        encodings = ('ascii', 'utf8', 'latin1')
+        invalid = 'Boom, Shaka Laka, Boom!'
+        code = textwrap.dedent(f'''
+            import sys
+            encodings = {encodings!r}
+
+            for data in (b'', b'short string'):
+                try:
+                    str(data, encoding={invalid!r})
+                except LookupError:
+                    pass
+                else:
+                    sys.exit(21)
+
+                try:
+                    str(data, errors={invalid!r})
+                except LookupError:
+                    pass
+                else:
+                    sys.exit(22)
+
+                for encoding in encodings:
+                    try:
+                        str(data, encoding, errors={invalid!r})
+                    except LookupError:
+                        pass
+                    else:
+                        sys.exit(22)
+
+            for data in ('', 'short string'):
+                try:
+                    data.encode(encoding={invalid!r})
+                except LookupError:
+                    pass
+                else:
+                    sys.exit(23)
+
+                try:
+                    data.encode(errors={invalid!r})
+                except LookupError:
+                    pass
+                else:
+                    sys.exit(24)
+
+                for encoding in encodings:
+                    try:
+                        data.encode(encoding, errors={invalid!r})
+                    except LookupError:
+                        pass
+                    else:
+                        sys.exit(24)
+
+            sys.exit(10)
+        ''')
+        proc = assert_python_failure('-X', 'dev', '-c', code)
+        self.assertEqual(proc.rc, 10, proc)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_str_invalid_call(self):
+        # too many args
+        with self.assertRaisesRegex(TypeError, r"str expected at most 3 arguments, got 4"):
+            str("too", "many", "argu", "ments")
+        with self.assertRaisesRegex(TypeError, r"str expected at most 3 arguments, got 4"):
+            str(1, "", "", 1)
+
+        # no such kw arg
+        with self.assertRaisesRegex(TypeError, r"str\(\) got an unexpected keyword argument 'test'"):
+            str(test=1)
+
+        # 'encoding' must be str
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'encoding' must be str, not int"):
+            str(1, 1)
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'encoding' must be str, not int"):
+            str(1, encoding=1)
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'encoding' must be str, not bytes"):
+            str(b"x", b"ascii")
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'encoding' must be str, not bytes"):
+            str(b"x", encoding=b"ascii")
+
+        # 'errors' must be str
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'encoding' must be str, not int"):
+            str(1, 1, 1)
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'errors' must be str, not int"):
+            str(1, errors=1)
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'errors' must be str, not int"):
+            str(1, "", errors=1)
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'errors' must be str, not bytes"):
+            str(b"x", "ascii", b"strict")
+        with self.assertRaisesRegex(TypeError, r"str\(\) argument 'errors' must be str, not bytes"):
+            str(b"x", "ascii", errors=b"strict")
+
+        # both positional and kwarg
+        with self.assertRaisesRegex(TypeError, r"argument for str\(\) given by name \('encoding'\) and position \(2\)"):
+            str(b"x", "utf-8", encoding="ascii")
+        with self.assertRaisesRegex(TypeError, r"str\(\) takes at most 3 arguments \(4 given\)"):
+            str(b"x", "utf-8", "ignore", encoding="ascii")
+        with self.assertRaisesRegex(TypeError, r"str\(\) takes at most 3 arguments \(4 given\)"):
+            str(b"x", "utf-8", "strict", errors="ignore")
+
+
+class StringModuleTest(unittest.TestCase):
+    def test_formatter_parser(self):
+        def parse(format):
+            return list(_string.formatter_parser(format))
+
+        formatter = parse("prefix {2!s}xxx{0:^+10.3f}{obj.attr!s} {z[0]!s:10}")
+        self.assertEqual(formatter, [
+            ('prefix ', '2', '', 's'),
+            ('xxx', '0', '^+10.3f', None),
+            ('', 'obj.attr', '', 's'),
+            (' ', 'z[0]', '10', 's'),
+        ])
+
+        formatter = parse("prefix {} suffix")
+        self.assertEqual(formatter, [
+            ('prefix ', '', '', None),
+            (' suffix', None, None, None),
+        ])
+
+        formatter = parse("str")
+        self.assertEqual(formatter, [
+            ('str', None, None, None),
+        ])
+
+        formatter = parse("")
+        self.assertEqual(formatter, [])
+
+        formatter = parse("{0}")
+        self.assertEqual(formatter, [
+            ('', '0', '', None),
+        ])
+
+        self.assertRaises(TypeError, _string.formatter_parser, 1)
+
+    def test_formatter_field_name_split(self):
+        def split(name):
+            items = list(_string.formatter_field_name_split(name))
+            items[1] = list(items[1])
+            return items
+        self.assertEqual(split("obj"), ["obj", []])
+        self.assertEqual(split("obj.arg"), ["obj", [(True, 'arg')]])
+        self.assertEqual(split("obj[key]"), ["obj", [(False, 'key')]])
+        self.assertEqual(split("obj.arg[key1][key2]"), [
+            "obj",
+            [(True, 'arg'),
+             (False, 'key1'),
+             (False, 'key2'),
+            ]])
+        self.assertRaises(TypeError, _string.formatter_field_name_split, 1)
+
+    def test_str_subclass_attr(self):
+
+        name = StrSubclass("name")
+        name2 = StrSubclass("name2")
+        class Bag:
+            pass
+
+        o = Bag()
+        with self.assertRaises(AttributeError):
+            delattr(o, name)
+        setattr(o, name, 1)
+        self.assertEqual(o.name, 1)
+        o.name = 2
+        self.assertEqual(list(o.__dict__), [name])
+
+        with self.assertRaises(AttributeError):
+            delattr(o, name2)
+        with self.assertRaises(AttributeError):
+            del o.name2
+        setattr(o, name2, 3)
+        self.assertEqual(o.name2, 3)
+        o.name2 = 4
+        self.assertEqual(list(o.__dict__), [name, name2])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_strftime.py b/Lib/test/test_strftime.py
index f5024d8e6d..be43c49e40 100644
--- a/Lib/test/test_strftime.py
+++ b/Lib/test/test_strftime.py
@@ -184,7 +184,6 @@ class Y1900Tests(unittest.TestCase):
     a date before 1900 is passed with a format string containing "%y"
     """
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_y_before_1900(self):
         # Issue #13674, #19634
         t = (1899, 1, 1, 0, 0, 0, 0, 0, 0)
diff --git a/Lib/test/test_string_literals.py b/Lib/test/test_string_literals.py
index 537c8fc5c8..c6b2ffb9de 100644
--- a/Lib/test/test_string_literals.py
+++ b/Lib/test/test_string_literals.py
@@ -105,32 +105,95 @@ def test_eval_str_incomplete(self):
         self.assertRaises(SyntaxError, eval, r""" '\U000000' """)
         self.assertRaises(SyntaxError, eval, r""" '\U0000000' """)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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""":
                 continue
-            with self.assertWarns(DeprecationWarning):
+            with self.assertWarns(SyntaxWarning):
                 self.assertEqual(eval(r"'\%c'" % b), '\\' + chr(b))
 
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always', category=DeprecationWarning)
+            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(w[0].filename, '<string>')
-        self.assertEqual(w[0].lineno, 1)
+        self.assertEqual(w[0].lineno, 2)
 
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('error', category=DeprecationWarning)
+            warnings.simplefilter('error', category=SyntaxWarning)
             with self.assertRaises(SyntaxError) as cm:
                 eval("'''\n\\z'''")
             exc = cm.exception
         self.assertEqual(w, [])
+        self.assertEqual(exc.msg, r"invalid escape sequence '\z'")
         self.assertEqual(exc.filename, '<string>')
-        self.assertEqual(exc.lineno, 1)
+        self.assertEqual(exc.lineno, 2)
+        self.assertEqual(exc.offset, 1)
+
+        # Check that the warning is raised only once if there are syntax errors
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always', category=SyntaxWarning)
+            with self.assertRaises(SyntaxError) as cm:
+                eval("'\\e' $")
+            exc = cm.exception
+        self.assertEqual(len(w), 1)
+        self.assertEqual(w[0].category, SyntaxWarning)
+        self.assertRegex(str(w[0].message), 'invalid escape sequence')
+        self.assertEqual(w[0].filename, '<string>')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_eval_str_invalid_octal_escape(self):
+        for i in range(0o400, 0o1000):
+            with self.assertWarns(SyntaxWarning):
+                self.assertEqual(eval(r"'\%o'" % i), chr(i))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always', category=SyntaxWarning)
+            eval("'''\n\\407'''")
+        self.assertEqual(len(w), 1)
+        self.assertEqual(str(w[0].message),
+                         r"invalid octal escape sequence '\407'")
+        self.assertEqual(w[0].filename, '<string>')
+        self.assertEqual(w[0].lineno, 2)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('error', category=SyntaxWarning)
+            with self.assertRaises(SyntaxError) as cm:
+                eval("'''\n\\407'''")
+            exc = cm.exception
+        self.assertEqual(w, [])
+        self.assertEqual(exc.msg, r"invalid octal escape sequence '\407'")
+        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)
+
+        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)
+
     def test_eval_str_raw(self):
         self.assertEqual(eval(""" r'x' """), 'x')
         self.assertEqual(eval(r""" r'\x01' """), '\\' + 'x01')
@@ -157,30 +220,56 @@ def test_eval_bytes_incomplete(self):
         self.assertRaises(SyntaxError, eval, r""" b'\x' """)
         self.assertRaises(SyntaxError, eval, r""" b'\x0' """)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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""":
                 continue
-            with self.assertWarns(DeprecationWarning):
+            with self.assertWarns(SyntaxWarning):
                 self.assertEqual(eval(r"b'\%c'" % b), b'\\' + bytes([b]))
 
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always', category=DeprecationWarning)
+            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(w[0].filename, '<string>')
-        self.assertEqual(w[0].lineno, 1)
+        self.assertEqual(w[0].lineno, 2)
 
         with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('error', category=DeprecationWarning)
+            warnings.simplefilter('error', category=SyntaxWarning)
             with self.assertRaises(SyntaxError) as cm:
                 eval("b'''\n\\z'''")
             exc = cm.exception
         self.assertEqual(w, [])
+        self.assertEqual(exc.msg, r"invalid escape sequence '\z'")
         self.assertEqual(exc.filename, '<string>')
-        self.assertEqual(exc.lineno, 1)
+        self.assertEqual(exc.lineno, 2)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_eval_bytes_invalid_octal_escape(self):
+        for i in range(0o400, 0o1000):
+            with self.assertWarns(SyntaxWarning):
+                self.assertEqual(eval(r"b'\%o'" % i), bytes([i & 0o377]))
+
+        with warnings.catch_warnings(record=True) as w:
+            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(w[0].filename, '<string>')
+        self.assertEqual(w[0].lineno, 2)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('error', category=SyntaxWarning)
+            with self.assertRaises(SyntaxError) as cm:
+                eval("b'''\n\\407'''")
+            exc = cm.exception
+        self.assertEqual(w, [])
+        self.assertEqual(exc.msg, r"invalid octal escape sequence '\407'")
+        self.assertEqual(exc.filename, '<string>')
+        self.assertEqual(exc.lineno, 2)
 
     def test_eval_bytes_raw(self):
         self.assertEqual(eval(""" br'x' """), b'x')
@@ -217,6 +306,13 @@ def test_eval_str_u(self):
         self.assertRaises(SyntaxError, eval, """ bu'' """)
         self.assertRaises(SyntaxError, eval, """ ub'' """)
 
+    def test_uppercase_prefixes(self):
+        self.assertEqual(eval(""" B'x' """), b'x')
+        self.assertEqual(eval(r""" R'\x01' """), r'\x01')
+        self.assertEqual(eval(r""" BR'\x01' """), br'\x01')
+        self.assertEqual(eval(""" F'{1+1}' """), f'{1+1}')
+        self.assertEqual(eval(r""" U'\U0001d120' """), u'\U0001d120')
+
     def check_encoding(self, encoding, extra=""):
         modname = "xx_" + encoding.replace("-", "_")
         fn = os.path.join(self.tmpdir, modname + ".py")
diff --git a/Lib/test/test_strtod.py b/Lib/test/test_strtod.py
index b8b7a9d502..45fdcca92e 100644
--- a/Lib/test/test_strtod.py
+++ b/Lib/test/test_strtod.py
@@ -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,8 +173,7 @@ def test_halfway_cases(self):
             s = '{}e{}'.format(digits, exponent)
             self.check_strtod(s)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -195,8 +194,7 @@ def test_boundaries(self):
                 u *= 10
                 e -= 1
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -208,8 +206,7 @@ def test_underflow_boundary(self):
                 s = '{}e{}'.format(digits, exponent)
                 self.check_strtod(s)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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
@@ -219,8 +216,7 @@ def test_bigcomp(self):
                 s = '{}e{}'.format(digits, exponent)
                 self.check_strtod(s)
 
-    # TODO: RUSTPYTHON, Incorrectly rounded str->float conversion for -07e-321
-    @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'
@@ -288,8 +284,7 @@ def negative_exp(n):
         self.assertEqual(float(negative_exp(20000)), 1.0)
         self.assertEqual(float(negative_exp(30000)), 1.0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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_structseq.py b/Lib/test/test_structseq.py
index 41095f63ad..a9fe193028 100644
--- a/Lib/test/test_structseq.py
+++ b/Lib/test/test_structseq.py
@@ -75,8 +75,6 @@ def test_cmp(self):
         self.assertTrue(t1 >= t2)
         self.assertTrue(not (t1 != t2))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_fields(self):
         t = time.gmtime()
         self.assertEqual(len(t), t.n_sequence_fields)
@@ -129,8 +127,6 @@ def test_match_args(self):
                          'tm_sec', 'tm_wday', 'tm_yday', 'tm_isdst')
         self.assertEqual(time.struct_time.__match_args__, expected_args)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_match_args_with_unnamed_fields(self):
         expected_args = ('st_mode', 'st_ino', 'st_dev', 'st_nlink', 'st_uid',
                          'st_gid', 'st_size')
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 5a75971be6..4d05865272 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -25,7 +25,6 @@
 import gc
 import textwrap
 import json
-import pathlib
 from test.support.os_helper import FakePath
 
 try:
@@ -41,6 +40,10 @@
     import grp
 except ImportError:
     grp = None
+try:
+    import resource
+except ImportError:
+    resource = None
 
 try:
     import fcntl
@@ -158,6 +161,20 @@ def test_call_timeout(self):
                           [sys.executable, "-c", "while True: pass"],
                           timeout=0.1)
 
+    def test_timeout_exception(self):
+        try:
+            subprocess.run([sys.executable, '-c', 'import time;time.sleep(9)'], timeout = -1)
+        except subprocess.TimeoutExpired as e:
+            self.assertIn("-1 seconds", str(e))
+        else:
+            self.fail("Expected TimeoutExpired exception not raised")
+        try:
+            subprocess.run([sys.executable, '-c', 'import time;time.sleep(9)'], timeout = 0)
+        except subprocess.TimeoutExpired as e:
+            self.assertIn("0 seconds", str(e))
+        else:
+            self.fail("Expected TimeoutExpired exception not raised")
+
     def test_check_call_zero(self):
         # check_call() function with zero return code
         rc = subprocess.check_call(ZERO_RETURN_CMD)
@@ -269,21 +286,13 @@ def test_check_output_stdin_with_input_arg(self):
         self.assertIn('stdin', c.exception.args[0])
         self.assertIn('input', c.exception.args[0])
 
-    @support.requires_resource('walltime')
     def test_check_output_timeout(self):
         # check_output() function with timeout arg
         with self.assertRaises(subprocess.TimeoutExpired) as c:
             output = subprocess.check_output(
                     [sys.executable, "-c",
-                     "import sys, time\n"
-                     "sys.stdout.write('BDFL')\n"
-                     "sys.stdout.flush()\n"
-                     "time.sleep(3600)"],
-                    # Some heavily loaded buildbots (sparc Debian 3.x) require
-                    # this much time to start and print.
-                    timeout=3)
-            self.fail("Expected TimeoutExpired.")
-        self.assertEqual(c.exception.output, b'BDFL')
+                     "import time; time.sleep(3600)"],
+                    timeout=0.1)
 
     def test_call_kwargs(self):
         # call() function with keyword args
@@ -791,8 +800,7 @@ def test_env(self):
             stdout, stderr = p.communicate()
             self.assertEqual(stdout, b"orange")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(sys.platform == "win32", "Windows only issue")
     def test_win32_duplicate_envs(self):
         newenv = os.environ.copy()
@@ -857,7 +865,6 @@ def test_one_environment_variable(self):
             self.assertEqual(p.returncode, 0)
             self.assertEqual(stdout.strip(), b"fruit=orange")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON, null byte is not checked")
     def test_invalid_cmd(self):
         # null character in the command name
         cmd = sys.executable + '\0'
@@ -950,6 +957,48 @@ def test_communicate(self):
         self.assertEqual(stdout, b"banana")
         self.assertEqual(stderr, b"pineapple")
 
+    def test_communicate_memoryview_input(self):
+        # Test memoryview input with byte elements
+        test_data = b"Hello, memoryview!"
+        mv = memoryview(test_data)
+        p = subprocess.Popen([sys.executable, "-c",
+                              'import sys; sys.stdout.write(sys.stdin.read())'],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE)
+        self.addCleanup(p.stdout.close)
+        self.addCleanup(p.stdin.close)
+        (stdout, stderr) = p.communicate(mv)
+        self.assertEqual(stdout, test_data)
+        self.assertIsNone(stderr)
+
+    def test_communicate_memoryview_input_nonbyte(self):
+        # Test memoryview input with non-byte elements (e.g., int32)
+        # This tests the fix for gh-134453 where non-byte memoryviews
+        # had incorrect length tracking on POSIX
+        import array
+        # Create an array of 32-bit integers that's large enough to trigger
+        # the chunked writing behavior (> PIPE_BUF)
+        pipe_buf = getattr(select, 'PIPE_BUF', 512)
+        # Each 'i' element is 4 bytes, so we need more than pipe_buf/4 elements
+        # Add some extra to ensure we exceed the buffer size
+        num_elements = pipe_buf + 1
+        test_array = array.array('i', [0x64306f66 for _ in range(num_elements)])
+        expected_bytes = test_array.tobytes()
+        mv = memoryview(test_array)
+
+        p = subprocess.Popen([sys.executable, "-c",
+                              'import sys; '
+                              'data = sys.stdin.buffer.read(); '
+                              'sys.stdout.buffer.write(data)'],
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE)
+        self.addCleanup(p.stdout.close)
+        self.addCleanup(p.stdin.close)
+        (stdout, stderr) = p.communicate(mv)
+        self.assertEqual(stdout, expected_bytes,
+                         msg=f"{len(stdout)=} =? {len(expected_bytes)=}")
+        self.assertIsNone(stderr)
+
     def test_communicate_timeout(self):
         p = subprocess.Popen([sys.executable, "-c",
                               'import sys,os,time;'
@@ -985,6 +1034,62 @@ def test_communicate_timeout_large_output(self):
         (stdout, _) = p.communicate()
         self.assertEqual(len(stdout), 4 * 64 * 1024)
 
+    def test_communicate_timeout_large_input(self):
+        # Test that timeout is enforced when writing large input to a
+        # slow-to-read subprocess, and that partial input is preserved
+        # for continuation after timeout (gh-141473).
+        #
+        # This is a regression test for Windows matching POSIX behavior.
+        # On POSIX, select() is used to multiplex I/O with timeout checking.
+        # On Windows, stdin writing must also honor the timeout rather than
+        # blocking indefinitely when the pipe buffer fills.
+
+        # Input larger than typical pipe buffer (4-64KB on Windows)
+        input_data = b"x" * (128 * 1024)
+
+        p = subprocess.Popen(
+            [sys.executable, "-c",
+             "import sys, time; "
+             "time.sleep(30); "  # Don't read stdin for a long time
+             "sys.stdout.buffer.write(sys.stdin.buffer.read())"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE)
+
+        try:
+            timeout = 0.2
+            start = time.monotonic()
+            try:
+                p.communicate(input_data, timeout=timeout)
+                # If we get here without TimeoutExpired, the timeout was ignored
+                elapsed = time.monotonic() - start
+                self.fail(
+                    f"TimeoutExpired not raised. communicate() completed in "
+                    f"{elapsed:.2f}s, but subprocess sleeps for 30s. "
+                    "Stdin writing blocked without enforcing timeout.")
+            except subprocess.TimeoutExpired:
+                elapsed = time.monotonic() - start
+
+            # Timeout should occur close to the specified timeout value,
+            # not after waiting for the subprocess to finish sleeping.
+            # Allow generous margin for slow CI, but must be well under
+            # the subprocess sleep time.
+            self.assertLess(elapsed, 5.0,
+                f"TimeoutExpired raised after {elapsed:.2f}s; expected ~{timeout}s. "
+                "Stdin writing blocked without checking timeout.")
+
+            # After timeout, continue communication. The remaining input
+            # should be sent and we should receive all data back.
+            stdout, stderr = p.communicate()
+
+            # Verify all input was eventually received by the subprocess
+            self.assertEqual(len(stdout), len(input_data),
+                f"Expected {len(input_data)} bytes output but got {len(stdout)}")
+            self.assertEqual(stdout, input_data)
+        finally:
+            p.kill()
+            p.wait()
+
     # Test for the fd leak reported in http://bugs.python.org/issue2791.
     def test_communicate_pipe_fd_leak(self):
         for stdin_pipe in (False, True):
@@ -1016,7 +1121,6 @@ def test_communicate_returns(self):
         self.assertEqual(stdout, None)
         self.assertEqual(stderr, None)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_communicate_pipe_buf(self):
         # communicate() with writes larger than pipe_buf
         # This test will probably deadlock rather than fail, if
@@ -1056,6 +1160,19 @@ def test_writes_before_communicate(self):
         self.assertEqual(stdout, b"bananasplit")
         self.assertEqual(stderr, b"")
 
+    def test_communicate_stdin_closed_before_call(self):
+        # gh-70560, gh-74389: stdin.close() before communicate()
+        # should not raise ValueError from stdin.flush()
+        with subprocess.Popen([sys.executable, "-c",
+                               'import sys; sys.exit(0)'],
+                              stdin=subprocess.PIPE,
+                              stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE) as p:
+            p.stdin.close()  # Close stdin before communicate
+            # This should not raise ValueError
+            (stdout, stderr) = p.communicate()
+            self.assertEqual(p.returncode, 0)
+
     def test_universal_newlines_and_text(self):
         args = [
             sys.executable, "-c",
@@ -1174,8 +1291,7 @@ def test_universal_newlines_communicate_stdin_stdout_stderr(self):
         # to stderr at exit of subprocess.
         self.assertTrue(stderr.startswith("eline2\neline6\neline7\n"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_universal_newlines_communicate_encodings(self):
         # Check that universal newlines mode works for various encodings,
         # in particular for encodings in the UTF-16 and UTF-32 families.
@@ -1225,6 +1341,16 @@ def test_no_leaking(self):
             max_handles = 1026 # too much for most UNIX systems
         else:
             max_handles = 2050 # too much for (at least some) Windows setups
+        if resource:
+            # And if it is not too much, try to make it too much.
+            try:
+                soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
+                if soft > 1024:
+                    resource.setrlimit(resource.RLIMIT_NOFILE, (1024, hard))
+                    self.addCleanup(resource.setrlimit, resource.RLIMIT_NOFILE,
+                                    (soft, hard))
+            except (OSError, ValueError):
+                pass
         handles = []
         tmpdir = tempfile.mkdtemp()
         try:
@@ -1239,7 +1365,9 @@ def test_no_leaking(self):
             else:
                 self.skipTest("failed to reach the file descriptor limit "
                     "(tried %d)" % max_handles)
-            # Close a couple of them (should be enough for a subprocess)
+            # Close a couple of them (should be enough for a subprocess).
+            # Close lower file descriptors, so select() will work.
+            handles.reverse()
             for i in range(10):
                 os.close(handles.pop())
             # Loop creating some subprocesses. If one of them leaks some fds,
@@ -1337,15 +1465,12 @@ def _test_bufsize_equal_one(self, line, expected, universal_newlines):
         self.assertEqual(p.returncode, 0)
         self.assertEqual(read_line, expected)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_bufsize_equal_one_text_mode(self):
         # line is flushed in text mode with bufsize=1.
         # we should get the full line in return
         line = "line\n"
         self._test_bufsize_equal_one(line, line, universal_newlines=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bufsize_equal_one_binary_mode(self):
         # line is not flushed in binary mode with bufsize=1.
         # we should get empty response
@@ -1417,7 +1542,7 @@ def open_fds():
         t = threading.Thread(target=open_fds)
         t.start()
         try:
-            with self.assertRaises(EnvironmentError):
+            with self.assertRaises(OSError):
                 subprocess.Popen(NONEXISTING_CMD,
                                  stdin=subprocess.PIPE,
                                  stdout=subprocess.PIPE,
@@ -1531,9 +1656,6 @@ def test_communicate_epipe(self):
         p.communicate(b"x" * 2**20)
 
     def test_repr(self):
-        path_cmd = pathlib.Path("my-tool.py")
-        pathlib_cls = path_cmd.__class__.__name__
-
         cases = [
             ("ls", True, 123, "<Popen: returncode: 123 args: 'ls'>"),
             ('a' * 100, True, 0,
@@ -1541,7 +1663,8 @@ def test_repr(self):
             (["ls"], False, None, "<Popen: returncode: None args: ['ls']>"),
             (["ls", '--my-opts', 'a' * 100], False, None,
              "<Popen: returncode: None args: ['ls', '--my-opts', 'aaaaaaaaaaaaaaaaaaaaaaaa...>"),
-            (path_cmd, False, 7, f"<Popen: returncode: 7 args: {pathlib_cls}('my-tool.py')>")
+            (os_helper.FakePath("my-tool.py"), False, 7,
+             "<Popen: returncode: 7 args: <FakePath 'my-tool.py'>>")
         ]
         with unittest.mock.patch.object(subprocess.Popen, '_execute_child'):
             for cmd, shell, code, sx in cases:
@@ -1557,8 +1680,6 @@ def test_communicate_epipe_only_stdin(self):
         p.wait()
         p.communicate(b"x" * 2**20)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipUnless(hasattr(signal, 'SIGUSR1'),
                          "Requires signal.SIGUSR1")
     @unittest.skipUnless(hasattr(os, 'kill'),
@@ -1618,21 +1739,6 @@ def test_class_getitems(self):
         self.assertIsInstance(subprocess.Popen[bytes], types.GenericAlias)
         self.assertIsInstance(subprocess.CompletedProcess[str], types.GenericAlias)
 
-    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
-                     "vfork() not enabled by configure.")
-    @mock.patch("subprocess._fork_exec")
-    def test__use_vfork(self, mock_fork_exec):
-        self.assertTrue(subprocess._USE_VFORK)  # The default value regardless.
-        mock_fork_exec.side_effect = RuntimeError("just testing args")
-        with self.assertRaises(RuntimeError):
-            subprocess.run([sys.executable, "-c", "pass"])
-        mock_fork_exec.assert_called_once()
-        self.assertTrue(mock_fork_exec.call_args.args[-1])
-        with mock.patch.object(subprocess, '_USE_VFORK', False):
-            with self.assertRaises(RuntimeError):
-                subprocess.run([sys.executable, "-c", "pass"])
-            self.assertFalse(mock_fork_exec.call_args_list[-1].args[-1])
-
     @unittest.skipUnless(hasattr(subprocess, '_winapi'),
                          'need subprocess._winapi')
     def test_wait_negative_timeout(self):
@@ -1649,6 +1755,40 @@ def test_wait_negative_timeout(self):
 
             self.assertEqual(proc.wait(), 0)
 
+    def test_post_timeout_communicate_sends_input(self):
+        """GH-141473 regression test; the stdin pipe must close"""
+        with subprocess.Popen(
+                [sys.executable, "-uc", """\
+import sys
+while c := sys.stdin.read(512):
+    sys.stdout.write(c)
+print()
+"""],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+        ) as proc:
+            try:
+                data = f"spam{'#'*4096}beans"
+                proc.communicate(
+                    input=data,
+                    timeout=0,
+                )
+            except subprocess.TimeoutExpired as exc:
+                pass
+            # Prior to the bugfix, this would hang as the stdin
+            # pipe to the child had not been closed.
+            try:
+                stdout, stderr = proc.communicate(timeout=15)
+            except subprocess.TimeoutExpired as exc:
+                self.fail("communicate() hung waiting on child process that should have seen its stdin pipe close and exit")
+            self.assertEqual(
+                    proc.returncode, 0,
+                    msg=f"STDERR:\n{stderr}\nSTDOUT:\n{stdout}")
+            self.assertTrue(stdout.startswith("spam"), msg=stdout)
+            self.assertIn("beans", stdout)
+
 
 class RunFuncTestCase(BaseTestCase):
     def run_python(self, code, **kwargs):
@@ -1722,20 +1862,11 @@ def test_check_output_stdin_with_input_arg(self):
         self.assertIn('stdin', c.exception.args[0])
         self.assertIn('input', c.exception.args[0])
 
-    @support.requires_resource('walltime')
     def test_check_output_timeout(self):
         with self.assertRaises(subprocess.TimeoutExpired) as c:
-            cp = self.run_python((
-                     "import sys, time\n"
-                     "sys.stdout.write('BDFL')\n"
-                     "sys.stdout.flush()\n"
-                     "time.sleep(3600)"),
-                    # Some heavily loaded buildbots (sparc Debian 3.x) require
-                    # this much time to start and print.
-                    timeout=3, stdout=subprocess.PIPE)
-        self.assertEqual(c.exception.output, b'BDFL')
-        # output is aliased to stdout
-        self.assertEqual(c.exception.stdout, b'BDFL')
+            cp = self.run_python(
+                    "import time; time.sleep(3600)",
+                    timeout=0.1, stdout=subprocess.PIPE)
 
     def test_run_kwargs(self):
         newenv = os.environ.copy()
@@ -1773,8 +1904,7 @@ def test_run_with_pathlike_path_and_arguments(self):
         res = subprocess.run(args)
         self.assertEqual(res.returncode, 57)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skipIf(mswindows, 'TODO: RUSTPYTHON; Flakey')
     @unittest.skipUnless(mswindows, "Maybe test trigger a leak on Ubuntu")
     def test_run_with_an_empty_env(self):
         # gh-105436: fix subprocess.run(..., env={}) broken on Windows
@@ -1791,6 +1921,13 @@ def test_capture_output(self):
         self.assertIn(b'BDFL', cp.stdout)
         self.assertIn(b'FLUFL', cp.stderr)
 
+    def test_stdout_stdout(self):
+        # run() refuses to accept stdout=STDOUT
+        with self.assertRaises(ValueError,
+                msg=("STDOUT can only be used for stderr")):
+            self.run_python("print('will not be run')",
+                            stdout=subprocess.STDOUT)
+
     def test_stdout_with_capture_output_arg(self):
         # run() refuses to accept 'stdout' with 'capture_output'
         tf = tempfile.TemporaryFile()
@@ -1835,8 +1972,6 @@ def test_run_with_shell_timeout_and_capture_output(self):
                         msg="TimeoutExpired was delayed! Bad traceback:\n```\n"
                         f"{stacks}```")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_encoding_warning(self):
         code = textwrap.dedent("""\
             from subprocess import *
@@ -1883,8 +2018,6 @@ def _get_chdir_exception(self):
                       self._nonexistent_dir)
         return desired_exception
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_cwd(self):
         """Test error in the child raised in the parent for a bad cwd."""
         desired_exception = self._get_chdir_exception()
@@ -1900,8 +2033,6 @@ def test_exception_cwd(self):
         else:
             self.fail("Expected OSError: %s" % desired_exception)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_bad_executable(self):
         """Test error in the child raised in the parent for a bad executable."""
         desired_exception = self._get_chdir_exception()
@@ -1917,8 +2048,6 @@ def test_exception_bad_executable(self):
         else:
             self.fail("Expected OSError: %s" % desired_exception)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_exception_bad_args_0(self):
         """Test error in the child raised in the parent for a bad args[0]."""
         desired_exception = self._get_chdir_exception()
@@ -1983,8 +2112,6 @@ def bad_error(*args):
 
         self.assertIn(repr(error_data), str(e.exception))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(not os.path.exists('/proc/self/status'),
                      "need /proc/self/status")
     def test_restore_signals(self):
@@ -2147,16 +2274,14 @@ def test_group_error(self):
         with self.assertRaises(ValueError):
             subprocess.check_call(ZERO_RETURN_CMD, group=65535)
 
-    # TODO: RUSTPYTHON, observed gids do not match expected gids
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; observed gids do not match expected gids
     @unittest.skipUnless(hasattr(os, 'setgroups'), 'no setgroups() on platform')
     def test_extra_groups(self):
         gid = os.getegid()
         group_list = [65534 if gid != 65534 else 65533]
         self._test_extra_groups_impl(gid=gid, group_list=group_list)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipUnless(hasattr(os, 'setgroups'), 'no setgroups() on platform')
     def test_extra_groups_empty_list(self):
         self._test_extra_groups_impl(gid=os.getegid(), group_list=[])
@@ -2192,8 +2317,8 @@ def _test_extra_groups_impl(self, *, gid, group_list):
                 subprocess.check_call(ZERO_RETURN_CMD,
                                       extra_groups=[name_group])
 
-    @unittest.skip("TODO: RUSTPYTHON; clarify failure condition")
     # No skip necessary, this test won't make it to a setgroup() call.
+    @unittest.skip('TODO: RUSTPYTHON; clarify failure condition')
     def test_extra_groups_invalid_gid_t_values(self):
         with self.assertRaises(ValueError):
             subprocess.check_call(ZERO_RETURN_CMD, extra_groups=[-1])
@@ -2203,8 +2328,6 @@ def test_extra_groups_invalid_gid_t_values(self):
                                   cwd=os.curdir, env=os.environ,
                                   extra_groups=[2**64])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(mswindows or not hasattr(os, 'umask'),
                      'POSIX umask() is not available.')
     def test_umask(self):
@@ -2256,8 +2379,6 @@ def test_CalledProcessError_str_non_zero(self):
         error_string = str(err)
         self.assertIn("non-zero exit status 2.", error_string)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_preexec(self):
         # DISCLAIMER: Setting environment variables is *not* a good use
         # of a preexec_fn.  This is merely a test.
@@ -2269,8 +2390,6 @@ def test_preexec(self):
         with p:
             self.assertEqual(p.stdout.read(), b"apple")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_preexec_exception(self):
         def raise_it():
             raise ValueError("What if two swallows carried a coconut?")
@@ -2312,8 +2431,6 @@ def _execute_child(self, *args, **kwargs):
                     for fd in devzero_fds:
                         os.close(fd)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(not os.path.exists("/dev/zero"), "/dev/zero required.")
     def test_preexec_errpipe_does_not_double_close_pipes(self):
         """Issue16140: Don't double close pipes on preexec error."""
@@ -2328,8 +2445,7 @@ def raise_it():
                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE, preexec_fn=raise_it)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_preexec_gc_module_failure(self):
         # This tests the code that disables garbage collection if the child
         # process will execute any Python.
@@ -2351,8 +2467,6 @@ def test_preexec_gc_module_failure(self):
             if not enabled:
                 gc.disable()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(
         sys.platform == 'darwin', 'setrlimit() seems to fail on OS X')
     def test_preexec_fork_failure(self):
@@ -2763,8 +2877,6 @@ def test_swap_std_fds_with_one_closed(self):
             for to_fds in itertools.permutations(range(3), 2):
                 self._check_swap_std_fds_with_one_closed(from_fds, to_fds)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_surrogates_error_message(self):
         def prepare():
             raise ValueError("surrogate:\uDCff")
@@ -2904,7 +3016,7 @@ def kill_p2():
         p1.stdout.close()
         p2.stdout.close()
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_close_fds(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
 
@@ -3032,11 +3144,11 @@ def test_close_fds_when_max_fd_is_lowered(self):
                          msg="Some fds were left open.")
 
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
     # Mac OS X Tiger (10.4) has a kernel bug: sometimes, the file
     # descriptor of a pipe closed in the parent process is valid in the
     # child process according to fstat(), but the mode of the file
     # descriptor is invalid, and read or write raise an error.
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     @support.requires_mac_ver(10, 5)
     def test_pass_fds(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
@@ -3240,8 +3352,6 @@ def test_leak_fast_process_del_killed(self):
         else:
             self.assertNotIn(ident, [id(o) for o in subprocess._active])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_close_fds_after_preexec(self):
         fd_status = support.findfile("fd_status.py", subdir="subprocessdata")
 
@@ -3451,8 +3561,7 @@ def test_communicate_repeated_call_after_stdout_close(self):
             except subprocess.TimeoutExpired:
                 pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_preexec_at_exit(self):
         code = f"""if 1:
         import atexit
@@ -3472,6 +3581,94 @@ def __del__(self):
         self.assertEqual(out.strip(), b"OK")
         self.assertIn(b"preexec_fn not supported at interpreter shutdown", err)
 
+    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
+                     "vfork() not enabled by configure.")
+    @mock.patch("subprocess._fork_exec")
+    @mock.patch("subprocess._USE_POSIX_SPAWN", new=False)
+    def test__use_vfork(self, mock_fork_exec):
+        self.assertTrue(subprocess._USE_VFORK)  # The default value regardless.
+        mock_fork_exec.side_effect = RuntimeError("just testing args")
+        with self.assertRaises(RuntimeError):
+            subprocess.run([sys.executable, "-c", "pass"])
+        mock_fork_exec.assert_called_once()
+        # NOTE: These assertions are *ugly* as they require the last arg
+        # to remain the have_vfork boolean. We really need to refactor away
+        # from the giant "wall of args" internal C extension API.
+        self.assertTrue(mock_fork_exec.call_args.args[-1])
+        with mock.patch.object(subprocess, '_USE_VFORK', False):
+            with self.assertRaises(RuntimeError):
+                subprocess.run([sys.executable, "-c", "pass"])
+            self.assertFalse(mock_fork_exec.call_args_list[-1].args[-1])
+
+    @unittest.skipIf(not sysconfig.get_config_var("HAVE_VFORK"),
+                     "vfork() not enabled by configure.")
+    @unittest.skipIf(sys.platform != "linux", "Linux only, requires strace.")
+    @mock.patch("subprocess._USE_POSIX_SPAWN", new=False)
+    def test_vfork_used_when_expected(self):
+        # This is a performance regression test to ensure we default to using
+        # vfork() when possible.
+        # Technically this test could pass when posix_spawn is used as well
+        # because libc tends to implement that internally using vfork. But
+        # that'd just be testing a libc+kernel implementation detail.
+        strace_binary = "/usr/bin/strace"
+        # The only system calls we are interested in.
+        strace_filter = "--trace=clone,clone2,clone3,fork,vfork,exit,exit_group"
+        true_binary = "/bin/true"
+        strace_command = [strace_binary, strace_filter]
+
+        try:
+            does_strace_work_process = subprocess.run(
+                    strace_command + [true_binary],
+                    stderr=subprocess.PIPE,
+                    stdout=subprocess.DEVNULL,
+            )
+            rc = does_strace_work_process.returncode
+            stderr = does_strace_work_process.stderr
+        except OSError:
+            rc = -1
+            stderr = ""
+        if rc or (b"+++ exited with 0 +++" not in stderr):
+            self.skipTest("strace not found or not working as expected.")
+
+        with self.subTest(name="default_is_vfork"):
+            vfork_result = assert_python_ok(
+                    "-c",
+                    textwrap.dedent(f"""\
+                    import subprocess
+                    subprocess.check_call([{true_binary!r}])"""),
+                    __run_using_command=strace_command,
+            )
+            # Match both vfork() and clone(..., flags=...|CLONE_VFORK|...)
+            self.assertRegex(vfork_result.err, br"(?i)vfork")
+            # Do NOT check that fork() or other clones did not happen.
+            # If the OS denys the vfork it'll fallback to plain fork().
+
+        # Test that each individual thing that would disable the use of vfork
+        # actually disables it.
+        for sub_name, preamble, sp_kwarg, expect_permission_error in (
+                ("!use_vfork", "subprocess._USE_VFORK = False", "", False),
+                ("preexec", "", "preexec_fn=lambda: None", False),
+                ("setgid", "", f"group={os.getgid()}", True),
+                ("setuid", "", f"user={os.getuid()}", True),
+                ("setgroups", "", "extra_groups=[]", True),
+        ):
+            with self.subTest(name=sub_name):
+                non_vfork_result = assert_python_ok(
+                    "-c",
+                    textwrap.dedent(f"""\
+                    import subprocess
+                    {preamble}
+                    try:
+                        subprocess.check_call(
+                                [{true_binary!r}], **dict({sp_kwarg}))
+                    except PermissionError:
+                        if not {expect_permission_error}:
+                            raise"""),
+                    __run_using_command=strace_command,
+                )
+                # Ensure neither vfork() or clone(..., flags=...|CLONE_VFORK|...).
+                self.assertNotRegex(non_vfork_result.err, br"(?i)vfork")
+
 
 @unittest.skipUnless(mswindows, "Windows specific tests")
 class Win32ProcessTestCase(BaseTestCase):
@@ -3565,8 +3762,6 @@ def test_close_fds(self):
                               close_fds=True)
         self.assertEqual(rc, 47)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_close_fds_with_stdio(self):
         import msvcrt
 
@@ -3649,8 +3844,6 @@ def test_shell_string(self):
         with p:
             self.assertIn(b"physalis", p.stdout.read())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_shell_encodings(self):
         # Run command through the shell (string)
         for enc in ['ansi', 'oem']:
@@ -3869,28 +4062,20 @@ def with_spaces(self, *args, **kwargs):
               "2 [%r, 'ab cd']" % self.fname
             )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_shell_string_with_spaces(self):
         # call() function with string argument with spaces on Windows
         self.with_spaces('"%s" "%s" "%s"' % (sys.executable, self.fname,
                                              "ab cd"), shell=1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_shell_sequence_with_spaces(self):
         # call() function with sequence argument with spaces on Windows
         self.with_spaces([sys.executable, self.fname, "ab cd"], shell=1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_noshell_string_with_spaces(self):
         # call() function with string argument with spaces on Windows
         self.with_spaces('"%s" "%s" "%s"' % (sys.executable, self.fname,
                              "ab cd"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_noshell_sequence_with_spaces(self):
         # call() function with sequence argument with spaces on Windows
         self.with_spaces([sys.executable, self.fname, "ab cd"])
diff --git a/Lib/test/test_sundry.py b/Lib/test/test_sundry.py
index 90af9da8f9..f4a8d434ed 100644
--- a/Lib/test/test_sundry.py
+++ b/Lib/test/test_sundry.py
@@ -1,14 +1,11 @@
 """Do a minimal test of all the modules that aren't otherwise tested."""
 import importlib
-import platform
-import sys
 from test import support
 from test.support import import_helper
 from test.support import warnings_helper
 import unittest
 
 class TestUntestedModules(unittest.TestCase):
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_untested_modules_can_be_imported(self):
         untested = ('encodings',)
         with warnings_helper.check_warnings(quiet=True):
@@ -21,31 +18,6 @@ def test_untested_modules_can_be_imported(self):
                     self.fail('{} has tests even though test_sundry claims '
                               'otherwise'.format(name))
 
-            import distutils.bcppcompiler
-            import distutils.ccompiler
-            import distutils.cygwinccompiler
-            import distutils.filelist
-            import distutils.text_file
-            import distutils.unixccompiler
-
-            import distutils.command.bdist_dumb
-            if sys.platform.startswith('win') and not platform.win32_is_iot():
-                import distutils.command.bdist_msi
-            import distutils.command.bdist
-            import distutils.command.bdist_rpm
-            import distutils.command.build_clib
-            import distutils.command.build_ext
-            import distutils.command.build
-            import distutils.command.clean
-            import distutils.command.config
-            import distutils.command.install_data
-            import distutils.command.install_egg_info
-            import distutils.command.install_headers
-            import distutils.command.install_lib
-            import distutils.command.register
-            import distutils.command.sdist
-            import distutils.command.upload
-
             import html.entities
 
             try:
@@ -54,5 +26,6 @@ def test_untested_modules_can_be_imported(self):
                 if support.verbose:
                     print("skipping tty")
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_super.py b/Lib/test/test_super.py
index ca8dc6e869..5548f4c71a 100644
--- a/Lib/test/test_super.py
+++ b/Lib/test/test_super.py
@@ -1,6 +1,13 @@
 """Unit tests for zero-argument super() & related machinery."""
 
+import textwrap
+import threading
 import unittest
+from unittest.mock import patch
+from test.support import import_helper, threading_helper
+
+
+ADAPTIVE_WARMUP_DELAY = 2
 
 
 class A:
@@ -84,41 +91,43 @@ def nested():
 
         self.assertEqual(E().f(), 'AE')
 
-    # SyntaxError
-    # def test_various___class___pathologies(self):
-    #     # See issue #12370
-    #     class X(A):
-    #         def f(self):
-    #             return super().f()
-    #         __class__ = 413
-    #     x = X()
-    #     self.assertEqual(x.f(), 'A')
-    #     self.assertEqual(x.__class__, 413)
-    #     class X:
-    #         x = __class__
-    #         def f():
-    #             __class__
-    #     self.assertIs(X.x, type(self))
-    #     with self.assertRaises(NameError) as e:
-    #         exec("""class X:
-    #             __class__
-    #             def f():
-    #                 __class__""", globals(), {})
-    #     self.assertIs(type(e.exception), NameError) # Not UnboundLocalError
-    #     class X:
-    #         global __class__
-    #         __class__ = 42
-    #         def f():
-    #             __class__
-    #     self.assertEqual(globals()["__class__"], 42)
-    #     del globals()["__class__"]
-    #     self.assertNotIn("__class__", X.__dict__)
-    #     class X:
-    #         nonlocal __class__
-    #         __class__ = 42
-    #         def f():
-    #             __class__
-    #     self.assertEqual(__class__, 42)
+    # TODO: RUSTPYTHON; SyntaxError: name '__class__' is assigned to before global declaration
+    '''
+    def test_various___class___pathologies(self):
+        # See issue #12370
+        class X(A):
+            def f(self):
+                return super().f()
+            __class__ = 413
+        x = X()
+        self.assertEqual(x.f(), 'A')
+        self.assertEqual(x.__class__, 413)
+        class X:
+            x = __class__
+            def f():
+                __class__
+        self.assertIs(X.x, type(self))
+        with self.assertRaises(NameError) as e:
+            exec("""class X:
+                __class__
+                def f():
+                    __class__""", globals(), {})
+        self.assertIs(type(e.exception), NameError) # Not UnboundLocalError
+        class X:
+            global __class__
+            __class__ = 42
+            def f():
+                __class__
+        self.assertEqual(globals()["__class__"], 42)
+        del globals()["__class__"]
+        self.assertNotIn("__class__", X.__dict__)
+        class X:
+            nonlocal __class__
+            __class__ = 42
+            def f():
+                __class__
+        self.assertEqual(__class__, 42)
+    '''
 
     def test___class___instancemethod(self):
         # See issue #14857
@@ -162,8 +171,6 @@ def f():
 
         self.assertIs(test_class, A)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test___class___delayed(self):
         # See issue #23722
         test_namespace = None
@@ -184,8 +191,7 @@ def f():
         B = type("B", (), test_namespace)
         self.assertIs(B.f(), B)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test___class___mro(self):
         # See issue #23722
         test_class = None
@@ -203,8 +209,7 @@ def f():
 
         self.assertIs(test_class, A)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test___classcell___expected_behaviour(self):
         # See issue #23722
         class Meta(type):
@@ -236,8 +241,6 @@ def f(self):
         with self.assertRaises(AttributeError):
             WithClassRef.__classcell__
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test___classcell___missing(self):
         # See issue #23722
         # Some metaclasses may not pass the original namespace to type.__new__
@@ -292,17 +295,28 @@ def f(self):
     def test_obscure_super_errors(self):
         def f():
             super()
-        self.assertRaises(RuntimeError, f)
+        with self.assertRaisesRegex(RuntimeError, r"no arguments"):
+            f()
+
+        class C:
+            def f():
+                super()
+        with self.assertRaisesRegex(RuntimeError, r"no arguments"):
+            C.f()
+
         def f(x):
             del x
             super()
-        self.assertRaises(RuntimeError, f, None)
+        with self.assertRaisesRegex(RuntimeError, r"arg\[0\] deleted"):
+            f(None)
+
         class X:
             def f(x):
                 nonlocal __class__
                 del __class__
                 super()
-        self.assertRaises(RuntimeError, X().f)
+        with self.assertRaisesRegex(RuntimeError, r"empty __class__ cell"):
+            X().f()
 
     def test_cell_as_self(self):
         class X:
@@ -326,6 +340,211 @@ def test_super_init_leaks(self):
         for i in range(1000):
             super.__init__(sp, int, i)
 
+    def test_super_argcount(self):
+        with self.assertRaisesRegex(TypeError, "expected at most"):
+            super(int, int, int)
+
+    def test_super_argtype(self):
+        with self.assertRaisesRegex(TypeError, "argument 1 must be a type"):
+            super(1, int)
+
+    def test_shadowed_global(self):
+        source = textwrap.dedent(
+            """
+            class super:
+                msg = "truly super"
+
+            class C:
+                def method(self):
+                    return super().msg
+            """,
+        )
+        with import_helper.ready_to_import(name="shadowed_super", source=source):
+            import shadowed_super
+        self.assertEqual(shadowed_super.C().method(), "truly super")
+        import_helper.unload("shadowed_super")
+
+    def test_shadowed_local(self):
+        class super:
+            msg = "quite super"
+
+        class C:
+            def method(self):
+                return super().msg
+
+        self.assertEqual(C().method(), "quite super")
+
+    def test_shadowed_dynamic(self):
+        class MySuper:
+            msg = "super super"
+
+        class C:
+            def method(self):
+                return super().msg
+
+        with patch(f"{__name__}.super", MySuper) as m:
+            self.assertEqual(C().method(), "super super")
+
+    def test_shadowed_dynamic_two_arg(self):
+        call_args = []
+        class MySuper:
+            def __init__(self, *args):
+                call_args.append(args)
+            msg = "super super"
+
+        class C:
+            def method(self):
+                return super(1, 2).msg
+
+        with patch(f"{__name__}.super", MySuper) as m:
+            self.assertEqual(C().method(), "super super")
+            self.assertEqual(call_args, [(1, 2)])
+
+    def test_attribute_error(self):
+        class C:
+            def method(self):
+                return super().msg
+
+        with self.assertRaisesRegex(AttributeError, "'super' object has no attribute 'msg'"):
+            C().method()
+
+    def test_bad_first_arg(self):
+        class C:
+            def method(self):
+                return super(1, self).method()
+
+        with self.assertRaisesRegex(TypeError, "argument 1 must be a type"):
+            C().method()
+
+    def test_supercheck_fail(self):
+        class C:
+            def method(self, type_, obj):
+                return super(type_, obj).method()
+
+        c = C()
+        err_msg = (
+            r"super\(type, obj\): obj \({} {}\) is not "
+            r"an instance or subtype of type \({}\)."
+        )
+
+        cases = (
+            (int, c, int.__name__, C.__name__, "instance of"),
+            # obj is instance of type
+            (C, list(), C.__name__, list.__name__, "instance of"),
+            # obj is type itself
+            (C, list, C.__name__, list.__name__, "type"),
+        )
+
+        for case in cases:
+            with self.subTest(case=case):
+                type_, obj, type_str, obj_str, instance_or_type = case
+                regex = err_msg.format(instance_or_type, obj_str, type_str)
+
+                with self.assertRaisesRegex(TypeError, regex):
+                    c.method(type_, obj)
+
+    def test_super___class__(self):
+        class C:
+            def method(self):
+                return super().__class__
+
+        self.assertEqual(C().method(), super)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; TypeError: type 'super' is not an acceptable base type
+    def test_super_subclass___class__(self):
+        class mysuper(super):
+            pass
+
+        class C:
+            def method(self):
+                return mysuper(C, self).__class__
+
+        self.assertEqual(C().method(), mysuper)
+
+    def test_unusual_getattro(self):
+        class MyType(type):
+            pass
+
+        def test(name):
+            mytype = MyType(name, (MyType,), {})
+            super(MyType, type(mytype)).__setattr__(mytype, "bar", 1)
+            self.assertEqual(mytype.bar, 1)
+
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            test("foo1")
+
+    def test_reassigned_new(self):
+        class A:
+            def __new__(cls):
+                pass
+
+            def __init_subclass__(cls):
+                if "__new__" not in cls.__dict__:
+                    cls.__new__ = cls.__new__
+
+        class B(A):
+            pass
+
+        class C(B):
+            def __new__(cls):
+                return super().__new__(cls)
+
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            C()
+
+    def test_mixed_staticmethod_hierarchy(self):
+        # This test is just a desugared version of `test_reassigned_new`
+        class A:
+            @staticmethod
+            def some(cls, *args, **kwargs):
+                self.assertFalse(args)
+                self.assertFalse(kwargs)
+
+        class B(A):
+            def some(cls, *args, **kwargs):
+                return super().some(cls, *args, **kwargs)
+
+        class C(B):
+            @staticmethod
+            def some(cls):
+                return super().some(cls)
+
+        for _ in range(ADAPTIVE_WARMUP_DELAY):
+            C.some(C)
+
+    @threading_helper.requires_working_threading()
+    def test___class___modification_multithreaded(self):
+        """ Note: this test isn't actually testing anything on its own.
+        It requires a sys audithook to be set to crash on older Python.
+        This should be the case anyways as our test suite sets
+        an audit hook.
+        """
+
+        class Foo:
+            pass
+
+        class Bar:
+            pass
+
+        thing = Foo()
+        def work():
+            foo = thing
+            for _ in range(200):
+                foo.__class__ = Bar
+                type(foo)
+                foo.__class__ = Foo
+                type(foo)
+
+
+        threads = []
+        for _ in range(6):
+            thread = threading.Thread(target=work)
+            thread.start()
+            threads.append(thread)
+
+        for thread in threads:
+            thread.join()
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_support.py b/Lib/test/test_support.py
index 4381a82b6b..d66afdc833 100644
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@@ -1,12 +1,15 @@
+import contextlib
 import errno
 import importlib
 import io
+import logging
 import os
 import shutil
 import socket
 import stat
 import subprocess
 import sys
+import sysconfig
 import tempfile
 import textwrap
 import unittest
@@ -18,11 +21,37 @@
 from test.support import script_helper
 from test.support import socket_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
 TESTFN = os_helper.TESTFN
 
 
-class TestSupport(unittest.TestCase):
+class LogCaptureHandler(logging.StreamHandler):
+    # Inspired by pytest's caplog
+    def __init__(self):
+        super().__init__(io.StringIO())
+        self.records = []
+
+    def emit(self, record) -> None:
+        self.records.append(record)
+        super().emit(record)
+
+    def handleError(self, record):
+        raise
+
+
+@contextlib.contextmanager
+def _caplog():
+    handler = LogCaptureHandler()
+    root_logger = logging.getLogger()
+    root_logger.addHandler(handler)
+    try:
+        yield handler
+    finally:
+        root_logger.removeHandler(handler)
+
+
+class TestSupport(unittest.TestCase, ExtraAssertions):
     @classmethod
     def setUpClass(cls):
         orig_filter_len = len(warnings.filters)
@@ -185,7 +214,7 @@ def test_temp_dir__existing_dir__quiet_true(self):
         path = os.path.realpath(path)
 
         try:
-            with warnings_helper.check_warnings() as recorder:
+            with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
                 with os_helper.temp_dir(path, quiet=True) as temp_path:
                     self.assertEqual(path, temp_path)
                 warnings = [str(w.message) for w in recorder.warnings]
@@ -194,11 +223,14 @@ def test_temp_dir__existing_dir__quiet_true(self):
         finally:
             shutil.rmtree(path)
 
-        self.assertEqual(len(warnings), 1, warnings)
-        warn = warnings[0]
-        self.assertTrue(warn.startswith(f'tests may fail, unable to create '
-                                        f'temporary directory {path!r}: '),
-                        warn)
+        self.assertListEqual(warnings, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to create '
+            f'temporary directory {path!r}: '
+        )
 
     @support.requires_fork()
     def test_temp_dir__forked_child(self):
@@ -258,35 +290,41 @@ def test_change_cwd__non_existent_dir__quiet_true(self):
 
         with os_helper.temp_dir() as parent_dir:
             bad_dir = os.path.join(parent_dir, 'does_not_exist')
-            with warnings_helper.check_warnings() as recorder:
+            with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
                 with os_helper.change_cwd(bad_dir, quiet=True) as new_cwd:
                     self.assertEqual(new_cwd, original_cwd)
                     self.assertEqual(os.getcwd(), new_cwd)
                 warnings = [str(w.message) for w in recorder.warnings]
 
-        self.assertEqual(len(warnings), 1, warnings)
-        warn = warnings[0]
-        self.assertTrue(warn.startswith(f'tests may fail, unable to change '
-                                        f'the current working directory '
-                                        f'to {bad_dir!r}: '),
-                        warn)
+        self.assertListEqual(warnings, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to change '
+            f'the current working directory '
+            f'to {bad_dir!r}: '
+        )
 
     # Tests for change_cwd()
 
     def test_change_cwd__chdir_warning(self):
         """Check the warning message when os.chdir() fails."""
         path = TESTFN + '_does_not_exist'
-        with warnings_helper.check_warnings() as recorder:
+        with warnings_helper.check_warnings() as recorder, _caplog() as caplog:
             with os_helper.change_cwd(path=path, quiet=True):
                 pass
             messages = [str(w.message) for w in recorder.warnings]
 
-        self.assertEqual(len(messages), 1, messages)
-        msg = messages[0]
-        self.assertTrue(msg.startswith(f'tests may fail, unable to change '
-                                       f'the current working directory '
-                                       f'to {path!r}: '),
-                        msg)
+        self.assertListEqual(messages, [])
+        self.assertEqual(len(caplog.records), 1)
+        record = caplog.records[0]
+        self.assertStartsWith(
+            record.getMessage(),
+            f'tests may fail, unable to change '
+            f'the current working directory '
+            f'to {path!r}: ',
+        )
 
     # Tests for temp_cwd()
 
@@ -310,7 +348,6 @@ def test_temp_cwd__name_none(self):
     def test_sortdict(self):
         self.assertEqual(support.sortdict({3:3, 2:2, 1:1}), "{1: 1, 2: 2, 3: 3}")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; actual c fds on windows")
     def test_make_bad_fd(self):
         fd = os_helper.make_bad_fd()
         with self.assertRaises(OSError) as cm:
@@ -421,8 +458,6 @@ def test_detect_api_mismatch__ignore(self):
                 self.OtherClass, self.RefClass, ignore=ignore)
         self.assertEqual(set(), missing_items)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_check__all__(self):
         extra = {'tempdir'}
         not_exported = {'template'}
@@ -433,10 +468,8 @@ def test_check__all__(self):
 
         extra = {
             'TextTestResult',
-            'findTestCases',
-            'getTestCaseNames',
             'installHandler',
-            'makeSuite',
+            'IsolatedAsyncioTestCase',
         }
         not_exported = {'load_tests', "TestProgram", "BaseTestSuite"}
         support.check__all__(self,
@@ -552,119 +585,14 @@ def test_optim_args_from_interpreter_flags(self):
             with self.subTest(opts=opts):
                 self.check_options(opts, 'optim_args_from_interpreter_flags')
 
-    def test_match_test(self):
-        class Test:
-            def __init__(self, test_id):
-                self.test_id = test_id
-
-            def id(self):
-                return self.test_id
-
-        test_access = Test('test.test_os.FileTests.test_access')
-        test_chdir = Test('test.test_os.Win32ErrorTests.test_chdir')
-
-        # Test acceptance
-        with support.swap_attr(support, '_match_test_func', None):
-            # match all
-            support.set_match_tests([])
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match all using None
-            support.set_match_tests(None, None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the full test identifier
-            support.set_match_tests([test_access.id()], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # match the module name
-            support.set_match_tests(['test_os'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Test '*' pattern
-            support.set_match_tests(['test_*'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Test case sensitivity
-            support.set_match_tests(['filetests'], None)
-            self.assertFalse(support.match_test(test_access))
-            support.set_match_tests(['FileTests'], None)
-            self.assertTrue(support.match_test(test_access))
-
-            # Test pattern containing '.' and a '*' metacharacter
-            support.set_match_tests(['*test_os.*.test_*'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # Multiple patterns
-            support.set_match_tests([test_access.id(), test_chdir.id()], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            support.set_match_tests(['test_access', 'DONTMATCH'], None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-        # Test rejection
-        with support.swap_attr(support, '_match_test_func', None):
-            # match all
-            support.set_match_tests(ignore_patterns=[])
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match all using None
-            support.set_match_tests(None, None)
-            self.assertTrue(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the full test identifier
-            support.set_match_tests(None, [test_access.id()])
-            self.assertFalse(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-            # match the module name
-            support.set_match_tests(None, ['test_os'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Test '*' pattern
-            support.set_match_tests(None, ['test_*'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Test case sensitivity
-            support.set_match_tests(None, ['filetests'])
-            self.assertTrue(support.match_test(test_access))
-            support.set_match_tests(None, ['FileTests'])
-            self.assertFalse(support.match_test(test_access))
-
-            # Test pattern containing '.' and a '*' metacharacter
-            support.set_match_tests(None, ['*test_os.*.test_*'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            # Multiple patterns
-            support.set_match_tests(None, [test_access.id(), test_chdir.id()])
-            self.assertFalse(support.match_test(test_access))
-            self.assertFalse(support.match_test(test_chdir))
-
-            support.set_match_tests(None, ['test_access', 'DONTMATCH'])
-            self.assertFalse(support.match_test(test_access))
-            self.assertTrue(support.match_test(test_chdir))
-
-    @unittest.skipIf(sys.platform.startswith("win"), "TODO: RUSTPYTHON; os.dup on windows")
+    @unittest.skipIf(support.is_apple_mobile, "Unstable on Apple Mobile")
     @unittest.skipIf(support.is_emscripten, "Unstable in Emscripten")
     @unittest.skipIf(support.is_wasi, "Unavailable on WASI")
     def test_fd_count(self):
-        # We cannot test the absolute value of fd_count(): on old Linux
-        # kernel or glibc versions, os.urandom() keeps a FD open on
-        # /dev/urandom device and Python has 4 FD opens instead of 3.
-        # Test is unstable on Emscripten. The platform starts and stops
+        # We cannot test the absolute value of fd_count(): on old Linux kernel
+        # or glibc versions, os.urandom() keeps a FD open on /dev/urandom
+        # device and Python has 4 FD opens instead of 3. Test is unstable on
+        # Emscripten and Apple Mobile platforms; these platforms start and stop
         # background threads that use pipes and epoll fds.
         start = os_helper.fd_count()
         fd = os.open(__file__, os.O_RDONLY)
@@ -686,13 +614,16 @@ def test_print_warning(self):
         self.check_print_warning("a\nb",
                                  'Warning -- a\nWarning -- b\n')
 
-    @unittest.expectedFailureIf(sys.platform != "win32", "TODO: RUSTPYTHON")
+    # TODO: RUSTPYTHON - strftime extension not fully supported on non-Windows
+    @unittest.skipUnless(sys.platform == "win32" or support.is_emscripten,
+                         "strftime extension not fully supported on non-Windows")
     def test_has_strftime_extensions(self):
         if support.is_emscripten or sys.platform == "win32":
             self.assertFalse(support.has_strftime_extensions)
         else:
             self.assertTrue(support.has_strftime_extensions)
 
+    # TODO: RUSTPYTHON - _testinternalcapi module not available
     @unittest.expectedFailure
     def test_get_recursion_depth(self):
         # test support.get_recursion_depth()
@@ -737,13 +668,15 @@ def test_recursive(depth, limit):
         """)
         script_helper.assert_python_ok("-c", code)
 
+    # TODO: RUSTPYTHON - stack overflow in debug mode with deep recursion
+    @unittest.skip("TODO: RUSTPYTHON - causes segfault in debug builds")
     def test_recursion(self):
         # Test infinite_recursion() and get_recursion_available() functions.
         def recursive_function(depth):
             if depth:
                 recursive_function(depth - 1)
 
-        for max_depth in (5, 25, 250):
+        for max_depth in (5, 25, 250, 2500):
             with support.infinite_recursion(max_depth):
                 available = support.get_recursion_available()
 
@@ -769,7 +702,85 @@ def recursive_function(depth):
             else:
                 self.fail("RecursionError was not raised")
 
-        #self.assertEqual(available, 2)
+    def test_parse_memlimit(self):
+        parse = support._parse_memlimit
+        KiB = 1024
+        MiB = KiB * 1024
+        GiB = MiB * 1024
+        TiB = GiB * 1024
+        self.assertEqual(parse('0k'), 0)
+        self.assertEqual(parse('3k'), 3 * KiB)
+        self.assertEqual(parse('2.4m'), int(2.4 * MiB))
+        self.assertEqual(parse('4g'), int(4 * GiB))
+        self.assertEqual(parse('1t'), TiB)
+
+        for limit in ('', '3', '3.5.10k', '10x'):
+            with self.subTest(limit=limit):
+                with self.assertRaises(ValueError):
+                    parse(limit)
+
+    def test_set_memlimit(self):
+        _4GiB = 4 * 1024 ** 3
+        TiB = 1024 ** 4
+        old_max_memuse = support.max_memuse
+        old_real_max_memuse = support.real_max_memuse
+        try:
+            if sys.maxsize > 2**32:
+                support.set_memlimit('4g')
+                self.assertEqual(support.max_memuse, _4GiB)
+                self.assertEqual(support.real_max_memuse, _4GiB)
+
+                big = 2**100 // TiB
+                support.set_memlimit(f'{big}t')
+                self.assertEqual(support.max_memuse, sys.maxsize)
+                self.assertEqual(support.real_max_memuse, big * TiB)
+            else:
+                support.set_memlimit('4g')
+                self.assertEqual(support.max_memuse, sys.maxsize)
+                self.assertEqual(support.real_max_memuse, _4GiB)
+        finally:
+            support.max_memuse = old_max_memuse
+            support.real_max_memuse = old_real_max_memuse
+
+    def test_copy_python_src_ignore(self):
+        # Get source directory
+        src_dir = sysconfig.get_config_var('abs_srcdir')
+        if not src_dir:
+            src_dir = sysconfig.get_config_var('srcdir')
+        src_dir = os.path.abspath(src_dir)
+
+        # Check that the source code is available
+        if not os.path.exists(src_dir):
+            self.skipTest(f"cannot access Python source code directory:"
+                          f" {src_dir!r}")
+        # Check that the landmark copy_python_src_ignore() expects is available
+        # (Previously we looked for 'Lib\os.py', which is always present on Windows.)
+        landmark = os.path.join(src_dir, 'Modules')
+        if not os.path.exists(landmark):
+            self.skipTest(f"cannot access Python source code directory:"
+                          f" {landmark!r} landmark is missing")
+
+        # Test support.copy_python_src_ignore()
+
+        # Source code directory
+        ignored = {'.git', '__pycache__'}
+        names = os.listdir(src_dir)
+        self.assertEqual(support.copy_python_src_ignore(src_dir, names),
+                         ignored | {'build'})
+
+        # Doc/ directory
+        path = os.path.join(src_dir, 'Doc')
+        self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)),
+                         ignored | {'build', 'venv'})
+
+        # Another directory
+        path = os.path.join(src_dir, 'Objects')
+        self.assertEqual(support.copy_python_src_ignore(path, os.listdir(path)),
+                         ignored)
+
+    def test_linked_to_musl(self):
+        linked = support.linked_to_musl()
+        self.assertIsInstance(linked, bool)
 
     # XXX -follows a list of untested API
     # make_legacy_pyc
@@ -782,12 +793,10 @@ def recursive_function(depth):
     # EnvironmentVarGuard
     # transient_internet
     # run_with_locale
-    # set_memlimit
     # bigmemtest
     # precisionbigmemtest
     # bigaddrspacetest
     # requires_resource
-    # run_doctest
     # threading_cleanup
     # reap_threads
     # can_symlink
diff --git a/Lib/test/test_symtable.py b/Lib/test/test_symtable.py
index ca62b9d685..8f1a80a524 100644
--- a/Lib/test/test_symtable.py
+++ b/Lib/test/test_symtable.py
@@ -1,9 +1,13 @@
 """
 Test the API of the symtable module.
 """
+
+import textwrap
 import symtable
 import unittest
 
+from test import support
+from test.support import os_helper
 
 
 TEST_CODE = """
@@ -11,7 +15,7 @@
 
 glob = 42
 some_var = 12
-some_non_assigned_global_var = 11
+some_non_assigned_global_var: int
 some_assigned_global_var = 11
 
 class Mine:
@@ -40,6 +44,129 @@ def foo():
 
 def namespace_test(): pass
 def namespace_test(): pass
+
+type Alias = int
+type GenericAlias[T] = list[T]
+
+def generic_spam[T](a):
+    pass
+
+class GenericMine[T: int, U: (int, str) = int]:
+    pass
+"""
+
+TEST_COMPLEX_CLASS_CODE = """
+# The following symbols are defined in ComplexClass
+# without being introduced by a 'global' statement.
+glob_unassigned_meth: Any
+glob_unassigned_meth_pep_695: Any
+
+glob_unassigned_async_meth: Any
+glob_unassigned_async_meth_pep_695: Any
+
+def glob_assigned_meth(): pass
+def glob_assigned_meth_pep_695[T](): pass
+
+async def glob_assigned_async_meth(): pass
+async def glob_assigned_async_meth_pep_695[T](): pass
+
+# The following symbols are defined in ComplexClass after
+# being introduced by a 'global' statement (and therefore
+# are not considered as local symbols of ComplexClass).
+glob_unassigned_meth_ignore: Any
+glob_unassigned_meth_pep_695_ignore: Any
+
+glob_unassigned_async_meth_ignore: Any
+glob_unassigned_async_meth_pep_695_ignore: Any
+
+def glob_assigned_meth_ignore(): pass
+def glob_assigned_meth_pep_695_ignore[T](): pass
+
+async def glob_assigned_async_meth_ignore(): pass
+async def glob_assigned_async_meth_pep_695_ignore[T](): pass
+
+class ComplexClass:
+    a_var = 1234
+    a_genexpr = (x for x in [])
+    a_lambda = lambda x: x
+
+    type a_type_alias = int
+    type a_type_alias_pep_695[T] = list[T]
+
+    class a_class: pass
+    class a_class_pep_695[T]: pass
+
+    def a_method(self): pass
+    def a_method_pep_695[T](self): pass
+
+    async def an_async_method(self): pass
+    async def an_async_method_pep_695[T](self): pass
+
+    @classmethod
+    def a_classmethod(cls): pass
+    @classmethod
+    def a_classmethod_pep_695[T](self): pass
+
+    @classmethod
+    async def an_async_classmethod(cls): pass
+    @classmethod
+    async def an_async_classmethod_pep_695[T](self): pass
+
+    @staticmethod
+    def a_staticmethod(): pass
+    @staticmethod
+    def a_staticmethod_pep_695[T](self): pass
+
+    @staticmethod
+    async def an_async_staticmethod(): pass
+    @staticmethod
+    async def an_async_staticmethod_pep_695[T](self): pass
+
+    # These ones will be considered as methods because of the 'def' although
+    # they are *not* valid methods at runtime since they are not decorated
+    # with @staticmethod.
+    def a_fakemethod(): pass
+    def a_fakemethod_pep_695[T](): pass
+
+    async def an_async_fakemethod(): pass
+    async def an_async_fakemethod_pep_695[T](): pass
+
+    # Check that those are still considered as methods
+    # since they are not using the 'global' keyword.
+    def glob_unassigned_meth(): pass
+    def glob_unassigned_meth_pep_695[T](): pass
+
+    async def glob_unassigned_async_meth(): pass
+    async def glob_unassigned_async_meth_pep_695[T](): pass
+
+    def glob_assigned_meth(): pass
+    def glob_assigned_meth_pep_695[T](): pass
+
+    async def glob_assigned_async_meth(): pass
+    async def glob_assigned_async_meth_pep_695[T](): pass
+
+    # The following are not picked as local symbols because they are not
+    # visible by the class at runtime (this is equivalent to having the
+    # definitions outside of the class).
+    global glob_unassigned_meth_ignore
+    def glob_unassigned_meth_ignore(): pass
+    global glob_unassigned_meth_pep_695_ignore
+    def glob_unassigned_meth_pep_695_ignore[T](): pass
+
+    global glob_unassigned_async_meth_ignore
+    async def glob_unassigned_async_meth_ignore(): pass
+    global glob_unassigned_async_meth_pep_695_ignore
+    async def glob_unassigned_async_meth_pep_695_ignore[T](): pass
+
+    global glob_assigned_meth_ignore
+    def glob_assigned_meth_ignore(): pass
+    global glob_assigned_meth_pep_695_ignore
+    def glob_assigned_meth_pep_695_ignore[T](): pass
+
+    global glob_assigned_async_meth_ignore
+    async def glob_assigned_async_meth_ignore(): pass
+    global glob_assigned_async_meth_pep_695_ignore
+    async def glob_assigned_async_meth_pep_695_ignore[T](): pass
 """
 
 
@@ -54,18 +181,46 @@ class SymtableTest(unittest.TestCase):
     top = symtable.symtable(TEST_CODE, "?", "exec")
     # These correspond to scopes in TEST_CODE
     Mine = find_block(top, "Mine")
+
     a_method = find_block(Mine, "a_method")
     spam = find_block(top, "spam")
     internal = find_block(spam, "internal")
     other_internal = find_block(spam, "other_internal")
     foo = find_block(top, "foo")
+    Alias = find_block(top, "Alias")
+    GenericAlias = find_block(top, "GenericAlias")
+    # XXX: RUSTPYTHON
+    # GenericAlias_inner = find_block(GenericAlias, "GenericAlias")
+    generic_spam = find_block(top, "generic_spam")
+    # XXX: RUSTPYTHON
+    # generic_spam_inner = find_block(generic_spam, "generic_spam")
+    GenericMine = find_block(top, "GenericMine")
+    # XXX: RUSTPYTHON
+    # GenericMine_inner = find_block(GenericMine, "GenericMine")
+    # XXX: RUSTPYTHON
+    # T = find_block(GenericMine, "T")
+    # XXX: RUSTPYTHON
+    # U = find_block(GenericMine, "U")
 
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_type(self):
         self.assertEqual(self.top.get_type(), "module")
         self.assertEqual(self.Mine.get_type(), "class")
         self.assertEqual(self.a_method.get_type(), "function")
         self.assertEqual(self.spam.get_type(), "function")
         self.assertEqual(self.internal.get_type(), "function")
+        self.assertEqual(self.foo.get_type(), "function")
+        self.assertEqual(self.Alias.get_type(), "type alias")
+        self.assertEqual(self.GenericAlias.get_type(), "type parameters")
+        self.assertEqual(self.GenericAlias_inner.get_type(), "type alias")
+        self.assertEqual(self.generic_spam.get_type(), "type parameters")
+        self.assertEqual(self.generic_spam_inner.get_type(), "function")
+        self.assertEqual(self.GenericMine.get_type(), "type parameters")
+        self.assertEqual(self.GenericMine_inner.get_type(), "class")
+        self.assertEqual(self.T.get_type(), "type variable")
+        self.assertEqual(self.U.get_type(), "type variable")
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -75,6 +230,11 @@ def test_id(self):
         self.assertGreater(self.a_method.get_id(), 0)
         self.assertGreater(self.spam.get_id(), 0)
         self.assertGreater(self.internal.get_id(), 0)
+        self.assertGreater(self.foo.get_id(), 0)
+        self.assertGreater(self.Alias.get_id(), 0)
+        self.assertGreater(self.GenericAlias.get_id(), 0)
+        self.assertGreater(self.generic_spam.get_id(), 0)
+        self.assertGreater(self.GenericMine.get_id(), 0)
 
     def test_optimized(self):
         self.assertFalse(self.top.is_optimized())
@@ -106,6 +266,8 @@ 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
     def test_globals(self):
         self.assertTrue(self.spam.lookup("glob").is_global())
         self.assertFalse(self.spam.lookup("glob").is_declared_global())
@@ -126,6 +288,8 @@ def test_nonlocal(self):
         expected = ("some_var",)
         self.assertEqual(self.other_internal.get_nonlocals(), expected)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_local(self):
         self.assertTrue(self.spam.lookup("x").is_local())
         self.assertFalse(self.spam.lookup("bar").is_local())
@@ -133,9 +297,13 @@ 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
     def test_free(self):
         self.assertTrue(self.internal.lookup("x").is_free())
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_referenced(self):
         self.assertTrue(self.internal.lookup("x").is_referenced())
         self.assertTrue(self.spam.lookup("internal").is_referenced())
@@ -167,6 +335,10 @@ def test_namespaces(self):
         self.assertEqual(len(ns_test.get_namespaces()), 2)
         self.assertRaises(ValueError, ns_test.get_namespace)
 
+        ns_test_2 = self.top.lookup("glob")
+        self.assertEqual(len(ns_test_2.get_namespaces()), 0)
+        self.assertRaises(ValueError, ns_test_2.get_namespace)
+
     def test_assigned(self):
         self.assertTrue(self.spam.lookup("x").is_assigned())
         self.assertTrue(self.spam.lookup("bar").is_assigned())
@@ -174,6 +346,8 @@ 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
     def test_annotated(self):
         st1 = symtable.symtable('def f():\n    x: int\n', 'test', 'exec')
         st2 = st1.get_children()[0]
@@ -199,6 +373,8 @@ def test_annotated(self):
                                 '    x: int',
                                 'test', 'exec')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_imported(self):
         self.assertTrue(self.top.lookup("sys").is_imported())
 
@@ -210,9 +386,79 @@ def test_name(self):
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
-    def test_class_info(self):
+    def test_class_get_methods(self):
         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',
+        ))
+
+        # Test generator expressions that are of type TYPE_FUNCTION
+        # but will not be reported by get_methods() since they are
+        # not functions per se.
+        #
+        # Other kind of comprehensions such as list, set or dict
+        # expressions do not have the TYPE_FUNCTION type.
+
+        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)
+
+        # statements with 'genexpr' inside it
+        GENEXPRS = (
+            'x = (x for x in [])',
+            'x = (x async for x in [])',
+            'type x[genexpr = (x for x in [])] = (x for x in [])',
+            'type x[genexpr = (x async for x in [])] = (x async for x in [])',
+            'genexpr = (x for x in [])',
+            'genexpr = (x async for x in [])',
+            'type genexpr[genexpr = (x for x in [])] = (x for x in [])',
+            'type genexpr[genexpr = (x async for x in [])] = (x async for x in [])',
+        )
+
+        for gen in GENEXPRS:
+            # test generator expression
+            with self.subTest(gen=gen):
+                check_body(gen, ())
+
+            # test generator expression + variable named 'genexpr'
+            with self.subTest(gen=gen, isvar=True):
+                check_body('\n'.join((gen, 'genexpr = 1')), ())
+                check_body('\n'.join(('genexpr = 1', gen)), ())
+
+        for paramlist in ('()', '(x)', '(x, y)', '(z: T)'):
+            for func in (
+                f'def genexpr{paramlist}:pass',
+                f'async def genexpr{paramlist}:pass',
+                f'def genexpr[T]{paramlist}:pass',
+                f'async def genexpr[T]{paramlist}:pass',
+            ):
+                with self.subTest(func=func):
+                    # test function named 'genexpr'
+                    check_body(func, ('genexpr',))
+
+                for gen in GENEXPRS:
+                    with self.subTest(gen=gen, func=func):
+                        # test generator expression + function named 'genexpr'
+                        check_body('\n'.join((gen, func)), ('genexpr',))
+                        check_body('\n'.join((func, gen)), ('genexpr',))
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_filename_correct(self):
@@ -230,10 +476,9 @@ def checkfilename(brokencode, offset):
         checkfilename("def f(x): foo)(", 14)  # parse-time
         checkfilename("def f(x): global x", 11)  # symtable-build-time
         symtable.symtable("pass", b"spam", "exec")
-        with self.assertWarns(DeprecationWarning), \
-             self.assertRaises(TypeError):
+        with self.assertRaises(TypeError):
             symtable.symtable("pass", bytearray(b"spam"), "exec")
-        with self.assertWarns(DeprecationWarning):
+        with self.assertRaises(TypeError):
             symtable.symtable("pass", memoryview(b"spam"), "exec")
         with self.assertRaises(TypeError):
             symtable.symtable("pass", list(b"spam"), "exec")
@@ -258,12 +503,71 @@ def test_bytes(self):
         top = symtable.symtable(code, "?", "exec")
         self.assertIsNotNone(find_block(top, "\u017d"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     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
+    def test_symbol_repr(self):
+        self.assertEqual(repr(self.spam.lookup("glob")),
+                         "<symbol 'glob': GLOBAL_IMPLICIT, USE>")
+        self.assertEqual(repr(self.spam.lookup("bar")),
+                         "<symbol 'bar': GLOBAL_EXPLICIT, DEF_GLOBAL|DEF_LOCAL>")
+        self.assertEqual(repr(self.spam.lookup("a")),
+                         "<symbol 'a': LOCAL, DEF_PARAM>")
+        self.assertEqual(repr(self.spam.lookup("internal")),
+                         "<symbol 'internal': LOCAL, USE|DEF_LOCAL>")
+        self.assertEqual(repr(self.spam.lookup("other_internal")),
+                         "<symbol 'other_internal': LOCAL, DEF_LOCAL>")
+        self.assertEqual(repr(self.internal.lookup("x")),
+                         "<symbol 'x': FREE, USE>")
+        self.assertEqual(repr(self.other_internal.lookup("some_var")),
+                         "<symbol 'some_var': FREE, USE|DEF_NONLOCAL|DEF_LOCAL>")
+
+    # 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)
+
+
+class CommandLineTest(unittest.TestCase):
+    maxDiff = None
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_file(self):
+        filename = os_helper.TESTFN
+        self.addCleanup(os_helper.unlink, filename)
+        with open(filename, 'w') as f:
+            f.write(TEST_CODE)
+        with support.captured_stdout() as stdout:
+            symtable.main([filename])
+        out = stdout.getvalue()
+        self.assertIn('\n\n', out)
+        self.assertNotIn('\n\n\n', out)
+        lines = out.splitlines()
+        self.assertIn(f"symbol table for module from file {filename!r}:", lines)
+        self.assertIn("    local symbol 'glob': def_local", lines)
+        self.assertIn("        global_implicit symbol 'glob': use", lines)
+        self.assertIn("    local symbol 'spam': def_local", lines)
+        self.assertIn("    symbol table for function 'spam':", lines)
+
+    def test_stdin(self):
+        with support.captured_stdin() as stdin:
+            stdin.write(TEST_CODE)
+            stdin.seek(0)
+            with support.captured_stdout() as stdout:
+                symtable.main([])
+            out = stdout.getvalue()
+            stdin.seek(0)
+            with support.captured_stdout() as stdout:
+                symtable.main(['-'])
+            self.assertEqual(stdout.getvalue(), out)
+        lines = out.splitlines()
+        self.assertIn("symbol table for module from file '<stdin>':", lines)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py
index 7e46773047..5085798b81 100644
--- a/Lib/test/test_syntax.py
+++ b/Lib/test/test_syntax.py
@@ -259,6 +259,36 @@
 Traceback (most recent call last):
 SyntaxError: invalid syntax
 
+Comprehensions without 'in' keyword:
+
+>>> [x for x if range(1)]
+Traceback (most recent call last):
+SyntaxError: 'in' expected after for-loop variables
+
+>>> tuple(x for x if range(1))
+Traceback (most recent call last):
+SyntaxError: 'in' expected after for-loop variables
+
+>>> [x for x() in a]
+Traceback (most recent call last):
+SyntaxError: cannot assign to function call
+
+>>> [x for a, b, (c + 1, d()) in y]
+Traceback (most recent call last):
+SyntaxError: cannot assign to expression
+
+>>> [x for a, b, (c + 1, d()) if y]
+Traceback (most recent call last):
+SyntaxError: 'in' expected after for-loop variables
+
+>>> [x for x+1 in y]
+Traceback (most recent call last):
+SyntaxError: cannot assign to expression
+
+>>> [x for x+1, x() in y]
+Traceback (most recent call last):
+SyntaxError: cannot assign to expression
+
 Comprehensions creating tuples without parentheses
 should produce a specialized error message:
 
@@ -322,6 +352,13 @@
 Traceback (most recent call last):
 SyntaxError: invalid syntax
 
+# But prefixes of soft keywords should
+# still raise specialized errors
+
+>>> (mat x)
+Traceback (most recent call last):
+SyntaxError: invalid syntax. Perhaps you forgot a comma?
+
 From compiler_complex_args():
 
 >>> def f(None=1):
@@ -334,7 +371,12 @@
 >>> def f(x, y=1, z):
 ...     pass
 Traceback (most recent call last):
-SyntaxError: non-default argument follows default argument
+SyntaxError: parameter without a default follows parameter with a default
+
+>>> def f(x, /, y=1, z):
+...     pass
+Traceback (most recent call last):
+SyntaxError: parameter without a default follows parameter with a default
 
 >>> def f(x, None):
 ...     pass
@@ -555,8 +597,16 @@
 Traceback (most recent call last):
 SyntaxError: expected default value expression
 
-# TODO: RUSTPYTHON NameError: name 'PyCF_TYPE_COMMENTS' is not defined
->>> import ast; ast.parse('''  # doctest: +SKIP
+>>> lambda a,d=3,c: None
+Traceback (most recent call last):
+SyntaxError: parameter without a default follows parameter with a default
+
+>>> lambda a,/,d=3,c: None
+Traceback (most recent call last):
+SyntaxError: parameter without a default follows parameter with a default
+
+>>> # TODO: RUSTPYTHON
+>>> import ast; ast.parse(''' # doctest: +SKIP
 ... def f(
 ...     *, # type: int
 ...     a, # type: int
@@ -582,46 +632,31 @@
 >>> L = range(10)
 >>> f(x for x in L)
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L, 1)  # doctest: +SKIP
+>>> f(x for x in L, 1)
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L, y=1)  # doctest: +SKIP
+>>> f(x for x in L, y=1)
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L, *[])  # doctest: +SKIP
+>>> f(x for x in L, *[])
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L, **{})  # doctest: +SKIP
+>>> f(x for x in L, **{})
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(L, x for x in L)  # doctest: +SKIP
+>>> f(L, x for x in L)
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L, y for y in L)  # doctest: +SKIP
+>>> f(x for x in L, y for y in L)
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
-
-# TODO: RUSTPYTHON does not raise.
->>> f(x for x in L,)  # doctest: +SKIP
+>>> f(x for x in L,)
 Traceback (most recent call last):
 SyntaxError: Generator expression must be parenthesized
 >>> f((x for x in L), 1)
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-# TODO: RUSTPYTHON TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases
->>> class C(x for x in L):  # doctest: +SKIP
+>>> # TODO: RUSTPYTHON
+>>> class C(x for x in L): # doctest: +SKIP
 ...     pass
 Traceback (most recent call last):
 SyntaxError: invalid syntax
@@ -742,8 +777,8 @@
 >>> f(x.y=1)
 Traceback (most recent call last):
 SyntaxError: expression cannot contain assignment, perhaps you meant "=="?
-# TODO: RUSTPYTHON
->>> f((x)=2)  # doctest: +SKIP
+>>> # TODO: RUSTPYTHON
+>>> f((x)=2) # doctest: +SKIP
 Traceback (most recent call last):
 SyntaxError: expression cannot contain assignment, perhaps you meant "=="?
 >>> f(True=1)
@@ -758,11 +793,31 @@
 >>> f(__debug__=1)
 Traceback (most recent call last):
 SyntaxError: cannot assign to __debug__
-
-# TODO: RUSTPYTHON NameError: name '__annotations__' is not defined
->>> __debug__: int  # doctest: +SKIP
+>>> # TODO: RUSTPYTHON
+>>> __debug__: int # doctest: +SKIP
 Traceback (most recent call last):
 SyntaxError: cannot assign to __debug__
+>>> f(a=)
+Traceback (most recent call last):
+SyntaxError: expected argument value expression
+>>> f(a, b, c=)
+Traceback (most recent call last):
+SyntaxError: expected argument value expression
+>>> f(a, b, c=, d)
+Traceback (most recent call last):
+SyntaxError: expected argument value expression
+>>> f(*args=[0])
+Traceback (most recent call last):
+SyntaxError: cannot assign to iterable argument unpacking
+>>> f(a, b, *args=[0])
+Traceback (most recent call last):
+SyntaxError: cannot assign to iterable argument unpacking
+>>> f(**kwargs={'a': 1})
+Traceback (most recent call last):
+SyntaxError: cannot assign to keyword argument unpacking
+>>> f(a, b, *args, **kwargs={'a': 1})
+Traceback (most recent call last):
+SyntaxError: cannot assign to keyword argument unpacking
 
 
 More set_context():
@@ -990,11 +1045,26 @@
    Traceback (most recent call last):
    SyntaxError: expected ':'
 
+   >>> def f[T]()
+   ...     pass
+   Traceback (most recent call last):
+   SyntaxError: expected ':'
+
    >>> class A
    ...     pass
    Traceback (most recent call last):
    SyntaxError: expected ':'
 
+   >>> class A[T]
+   ...     pass
+   Traceback (most recent call last):
+   SyntaxError: expected ':'
+
+   >>> class A[T]()
+   ...     pass
+   Traceback (most recent call last):
+   SyntaxError: expected ':'
+
    >>> class R&D:
    ...     pass
    Traceback (most recent call last):
@@ -1154,6 +1224,22 @@
    Traceback (most recent call last):
    SyntaxError: expected '('
 
+   >>> def f -> int:
+   Traceback (most recent call last):
+   SyntaxError: expected '('
+
+   >>> async def f -> int:  # type: int
+   Traceback (most recent call last):
+   SyntaxError: expected '('
+
+   >>> async def f[T]:
+   Traceback (most recent call last):
+   SyntaxError: expected '('
+
+   >>> def f[T] -> str:
+   Traceback (most recent call last):
+   SyntaxError: expected '('
+
 Parenthesized arguments in function definitions
 
    >>> def f(x, (y, z), w):
@@ -1432,11 +1518,21 @@
    Traceback (most recent call last):
    IndentationError: expected an indented block after function definition on line 1
 
+   >>> def foo[T](x, /, y, *, z=2):
+   ... pass
+   Traceback (most recent call last):
+   IndentationError: expected an indented block after function definition on line 1
+
    >>> class Blech(A):
    ... pass
    Traceback (most recent call last):
    IndentationError: expected an indented block after class definition on line 1
 
+   >>> class Blech[T](A):
+   ... pass
+   Traceback (most recent call last):
+   IndentationError: expected an indented block after class definition on line 1
+
    >>> match something:
    ... pass
    Traceback (most recent call last):
@@ -1469,14 +1565,16 @@
 Check that an multiple exception types with missing parentheses
 raise a custom exception
 
-   >>> try:
+   >>> # TODO: RUSTPYTHON
+   >>> try: # doctest: +SKIP
    ...   pass
    ... except A, B:
    ...   pass
    Traceback (most recent call last):
    SyntaxError: multiple exception types must be parenthesized
 
-   >>> try:
+   >>> # TODO: RUSTPYTHON
+   >>> try: # doctest: +SKIP
    ...   pass
    ... except A, B, C:
    ...   pass
@@ -1591,30 +1689,113 @@
 Traceback (most recent call last):
 SyntaxError: trailing comma not allowed without surrounding parentheses
 
+>>> import a from b
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a.y.z from b.y.z
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a from b as bar
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a.y.z from b.y.z as bar
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a, b,c from b
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a.y.z, b.y.z, c.y.z from b.y.z
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a,b,c from b as bar
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
+>>> import a.y.z, b.y.z, c.y.z from b.y.z as bar
+Traceback (most recent call last):
+SyntaxError: Did you mean to use 'from ... import ...' instead?
+
 # Check that we dont raise the "trailing comma" error if there is more
 # input to the left of the valid part that we parsed.
 
->>> from t import x,y, and 3  
+>>> from t import x,y, and 3
 Traceback (most recent call last):
 SyntaxError: invalid syntax
 
-# TODO: RUSTPYTHON nothing raised.
->>> (): int  # doctest: +SKIP
+>>> from i import
+Traceback (most recent call last):
+SyntaxError: Expected one or more names after 'import'
+
+>>> from .. import
+Traceback (most recent call last):
+SyntaxError: Expected one or more names after 'import'
+
+>>> import
+Traceback (most recent call last):
+SyntaxError: Expected one or more names after 'import'
+
+>>> (): int
 Traceback (most recent call last):
 SyntaxError: only single target (not tuple) can be annotated
-# TODO: RUSTPYTHON nothing raised.
->>> []: int  # doctest: +SKIP
+>>> []: int
 Traceback (most recent call last):
 SyntaxError: only single target (not list) can be annotated
-# TODO: RUSTPYTHON nothing raised.
->>> (()): int  # doctest: +SKIP
+>>> (()): int
 Traceback (most recent call last):
 SyntaxError: only single target (not tuple) can be annotated
-# TODO: RUSTPYTHON nothing raised.
->>> ([]): int  # doctest: +SKIP
+>>> ([]): int
 Traceback (most recent call last):
 SyntaxError: only single target (not list) can be annotated
 
+# 'not' after operators:
+
+>>> 3 + not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> 3 * not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> + not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> - not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> ~ not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> 3 + - not 3
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+>>> 3 + not -1
+Traceback (most recent call last):
+SyntaxError: 'not' after an operator must be parenthesized
+
+# Check that we don't introduce misleading errors
+>>> not 1 */ 2
+Traceback (most recent call last):
+SyntaxError: invalid syntax
+
+>>> not 1 +
+Traceback (most recent call last):
+SyntaxError: invalid syntax
+
+>>> not + 1 +
+Traceback (most recent call last):
+SyntaxError: invalid syntax
+
 Corner-cases that used to fail to raise the correct error:
 
     >>> def f(*, x=lambda __debug__:0): pass
@@ -1635,8 +1816,7 @@
 
 Corner-cases that used to crash:
 
-    # TODO: RUSTPYTHON nothing raised.
-    >>> def f(**__debug__): pass  # doctest: +SKIP
+    >>> def f(**__debug__): pass
     Traceback (most recent call last):
     SyntaxError: cannot assign to __debug__
 
@@ -1650,8 +1830,8 @@
 
   Invalid pattern matching constructs:
 
-    # TODO: RUSTPYTHON nothing raised.
-    >>> match ...:  # doctest: +SKIP
+    >>> # TODO: RUSTPYTHON
+    >>> match ...: # doctest: +SKIP 
     ...   case 42 as _:
     ...     ...
     Traceback (most recent call last):
@@ -1751,22 +1931,22 @@
     >>> A[*(1:2)]
     Traceback (most recent call last):
         ...
-    SyntaxError: invalid syntax
+    SyntaxError: Invalid star expression
     >>> A[*(1:2)] = 1
     Traceback (most recent call last):
         ...
-    SyntaxError: invalid syntax
+    SyntaxError: Invalid star expression
     >>> del A[*(1:2)]
     Traceback (most recent call last):
         ...
-    SyntaxError: invalid syntax
+    SyntaxError: Invalid star expression
 
 A[*:] and A[:*]
 
     >>> A[*:]
     Traceback (most recent call last):
         ...
-    SyntaxError: invalid syntax
+    SyntaxError: Invalid star expression
     >>> A[:*]
     Traceback (most recent call last):
         ...
@@ -1777,7 +1957,7 @@
     >>> A[*]
     Traceback (most recent call last):
         ...
-    SyntaxError: invalid syntax
+    SyntaxError: Invalid star expression
 
 A[**]
 
@@ -1829,10 +2009,246 @@ def f(x: *b)
     Traceback (most recent call last):
         ...
     SyntaxError: invalid syntax
+
+Invalid bytes literals:
+
+   >>> b"Ā"
+   Traceback (most recent call last):
+      ...
+       b"Ā"
+        ^^^
+   SyntaxError: bytes can only contain ASCII literal characters
+
+   >>> b"абвгде"
+   Traceback (most recent call last):
+      ...
+       b"абвгде"
+        ^^^^^^^^
+   SyntaxError: bytes can only contain ASCII literal characters
+
+   >>> b"abc ъющый"  # first 3 letters are ascii
+   Traceback (most recent call last):
+      ...
+       b"abc ъющый"
+        ^^^^^^^^^^^
+   SyntaxError: bytes can only contain ASCII literal characters
+
+Invalid expressions in type scopes:
+
+   >>> type A[] = int
+   Traceback (most recent call last):
+   ...
+   SyntaxError: Type parameter list cannot be empty
+
+   >>> class A[]: ...
+   Traceback (most recent call last):
+   ...
+   SyntaxError: Type parameter list cannot be empty
+
+   >>> def some[](): ...
+   Traceback (most recent call last):
+   ...
+   SyntaxError: Type parameter list cannot be empty
+
+   >>> def some[]()
+   Traceback (most recent call last):
+   ...
+   SyntaxError: Type parameter list cannot be empty
+
+   >>> async def some[]:  # type: int
+   Traceback (most recent call last):
+   ...
+   SyntaxError: Type parameter list cannot be empty
+
+   >>> def f[T: (x:=3)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar bound
+
+   >>> def f[T: ((x:= 3), int)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar constraint
+
+   >>> def f[T = ((x:=3))](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar default
+
+   >>> async def f[T: (x:=3)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar bound
+
+   >>> async def f[T: ((x:= 3), int)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar constraint
+
+   >>> async def f[T = ((x:=3))](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar default
+
+   >>> type A[T: (x:=3)] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar bound
+
+   >>> type A[T: ((x:= 3), int)] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar constraint
+
+   >>> type A[T = ((x:=3))] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a TypeVar default
+
+   >>> def f[T: (yield)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar bound
+
+   >>> def f[T: (int, (yield))](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar constraint
+
+   >>> def f[T = (yield)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar default
+
+   >>> def f[*Ts = (yield)](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVarTuple default
+
+   >>> def f[**P = [(yield), int]](): pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a ParamSpec default
+
+   >>> type A[T: (yield 3)] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar bound
+
+   >>> type A[T: (int, (yield 3))] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar constraint
+
+   >>> type A[T = (yield 3)] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar default
+
+   >>> type A[T: (await 3)] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: await expression cannot be used within a TypeVar bound
+
+   >>> type A[T: (yield from [])] = int
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar bound
+
+   >>> class A[T: (yield 3)]: pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar bound
+
+   >>> class A[T: (int, (yield 3))]: pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar constraint
+
+   >>> class A[T = (yield)]: pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVar default
+
+   >>> class A[*Ts = (yield)]: pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a TypeVarTuple default
+
+   >>> class A[**P = [(yield), int]]: pass
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a ParamSpec default
+
+   >>> # TODO: RUSTPYTHON
+   >>> type A = (x := 3) # doctest: +SKIP
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within a type alias
+
+   >>> type A = (yield 3)
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a type alias
+
+   >>> type A = (await 3)
+   Traceback (most recent call last):
+      ...
+   SyntaxError: await expression cannot be used within a type alias
+
+   >>> type A = (yield from [])
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within a type alias
+
+   >>> class A[T]((x := 3)): ...
+   Traceback (most recent call last):
+      ...
+   SyntaxError: named expression cannot be used within the definition of a generic
+
+   >>> class A[T]((yield 3)): ...
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within the definition of a generic
+
+   >>> class A[T]((await 3)): ...
+   Traceback (most recent call last):
+      ...
+   SyntaxError: await expression cannot be used within the definition of a generic
+
+   >>> class A[T]((yield from [])): ...
+   Traceback (most recent call last):
+      ...
+   SyntaxError: yield expression cannot be used within the definition of a generic
+
+    >>> f(**x, *y)
+    Traceback (most recent call last):
+    SyntaxError: iterable argument unpacking follows keyword argument unpacking
+
+    >>> f(**x, *)
+    Traceback (most recent call last):
+    SyntaxError: Invalid star expression
+
+    >>> f(x, *:)
+    Traceback (most recent call last):
+    SyntaxError: Invalid star expression
+
+    >>> f(x, *)
+    Traceback (most recent call last):
+    SyntaxError: Invalid star expression
+
+    >>> f(x = 5, *)
+    Traceback (most recent call last):
+    SyntaxError: Invalid star expression
+
+    >>> f(x = 5, *:)
+    Traceback (most recent call last):
+    SyntaxError: Invalid star expression
 """
 
 import re
 import doctest
+import textwrap
 import unittest
 
 from test import support
@@ -1869,8 +2285,7 @@ def _check_error(self, code, errtext,
         else:
             self.fail("compile() did not raise SyntaxError")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expression_with_assignment(self):
         self._check_error(
             "print(end1 + end2 = ' ')",
@@ -1878,16 +2293,14 @@ def test_expression_with_assignment(self):
             offset=7
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_curly_brace_after_primary_raises_immediately(self):
         self._check_error("f{}", "invalid syntax", mode="single")
 
     def test_assign_call(self):
         self._check_error("f() = 1", "assign")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assign_del(self):
         self._check_error("del (,)", "invalid syntax")
         self._check_error("del 1", "cannot delete literal")
@@ -1939,9 +2352,6 @@ def error2():
             """
         self._check_error(source, "parameter and nonlocal", lineno=3)
 
-    def test_break_outside_loop(self):
-        self._check_error("break", "outside loop")
-
     def test_yield_outside_function(self):
         self._check_error("if 0: yield",                "outside function")
         self._check_error("if 0: yield\nelse:  x=1",    "outside function")
@@ -1970,22 +2380,28 @@ def test_return_outside_function(self):
                           "outside function")
 
     def test_break_outside_loop(self):
-        self._check_error("if 0: break",             "outside loop")
-        self._check_error("if 0: break\nelse:  x=1",  "outside loop")
-        self._check_error("if 1: pass\nelse: break", "outside loop")
-        self._check_error("class C:\n  if 0: break", "outside loop")
+        msg = "outside loop"
+        self._check_error("break", msg, lineno=1)
+        self._check_error("if 0: break", msg, lineno=1)
+        self._check_error("if 0: break\nelse:  x=1", msg, lineno=1)
+        self._check_error("if 1: pass\nelse: break", msg, lineno=2)
+        self._check_error("class C:\n  if 0: break", msg, lineno=2)
         self._check_error("class C:\n  if 1: pass\n  else: break",
-                          "outside loop")
+                          msg, lineno=3)
+        self._check_error("with object() as obj:\n break",
+                          msg, lineno=2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_continue_outside_loop(self):
-        self._check_error("if 0: continue",             "not properly in loop")
-        self._check_error("if 0: continue\nelse:  x=1", "not properly in loop")
-        self._check_error("if 1: pass\nelse: continue", "not properly in loop")
-        self._check_error("class C:\n  if 0: continue", "not properly in loop")
+        msg = "not properly in loop"
+        self._check_error("if 0: continue", msg, lineno=1)
+        self._check_error("if 0: continue\nelse:  x=1", msg, lineno=1)
+        self._check_error("if 1: pass\nelse: continue", msg, lineno=2)
+        self._check_error("class C:\n  if 0: continue", msg, lineno=2)
         self._check_error("class C:\n  if 1: pass\n  else: continue",
-                          "not properly in loop")
+                          msg, lineno=3)
+        self._check_error("with object() as obj:\n    continue",
+                          msg, lineno=2)
 
     def test_unexpected_indent(self):
         self._check_error("foo()\n bar()\n", "unexpected indent",
@@ -2000,35 +2416,42 @@ def test_bad_outdent(self):
                           "unindent does not match .* level",
                           subclass=IndentationError)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_kwargs_last(self):
         self._check_error("int(base=10, '2')",
                           "positional argument follows keyword argument")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_kwargs_last2(self):
         self._check_error("int(**{'base': 10}, '2')",
                           "positional argument follows "
                           "keyword argument unpacking")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_kwargs_last3(self):
         self._check_error("int(**{'base': 10}, *['2'])",
                           "iterable argument unpacking follows "
                           "keyword argument unpacking")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_generator_in_function_call(self):
         self._check_error("foo(x,    y for y in range(3) for z in range(2) if z    , p)",
                           "Generator expression must be parenthesized",
                           lineno=1, end_lineno=1, offset=11, end_offset=53)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_except_then_except_star(self):
+        self._check_error("try: pass\nexcept ValueError: pass\nexcept* TypeError: pass",
+                          r"cannot have both 'except' and 'except\*' on the same 'try'",
+                          lineno=3, end_lineno=3, offset=1, end_offset=8)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_except_star_then_except(self):
+        self._check_error("try: pass\nexcept* ValueError: pass\nexcept TypeError: pass",
+                          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"""\
@@ -2073,6 +2496,25 @@ def test_continuation_bad_indentation(self):
 
         self.assertRaises(IndentationError, exec, code)
 
+    @support.cpython_only
+    def test_disallowed_type_param_names(self):
+        # See gh-128632
+
+        self._check_error(f"class A[__classdict__]: pass",
+                        f"reserved name '__classdict__' cannot be used for type parameter")
+        self._check_error(f"def f[__classdict__](): pass",
+                        f"reserved name '__classdict__' cannot be used for type parameter")
+        self._check_error(f"type T[__classdict__] = tuple[__classdict__]",
+                        f"reserved name '__classdict__' cannot be used for type parameter")
+
+        # These compilations are here to make sure __class__, __classcell__ and __classdictcell__
+        # don't break in the future like __classdict__ did in this case.
+        for name in ('__class__', '__classcell__', '__classdictcell__'):
+            compile(f"""
+class A:
+    class B[{name}]: pass
+                """, "<testcase>", mode="exec")
+
     @support.cpython_only
     def test_nested_named_except_blocks(self):
         code = ""
@@ -2083,6 +2525,59 @@ def test_nested_named_except_blocks(self):
         code += f"{' '*4*12}pass"
         self._check_error(code, "too many statically nested blocks")
 
+    @support.cpython_only
+    def test_with_statement_many_context_managers(self):
+        # See gh-113297
+
+        def get_code(n):
+            code = textwrap.dedent("""
+                def bug():
+                    with (
+                    a
+                """)
+            for i in range(n):
+                code += f"    as a{i}, a\n"
+            code += "): yield a"
+            return code
+
+        CO_MAXBLOCKS = 21  # static nesting limit of the compiler
+        MAX_MANAGERS = CO_MAXBLOCKS - 1  # One for the StopIteration block
+
+        for n in range(MAX_MANAGERS):
+            with self.subTest(f"within range: {n=}"):
+                compile(get_code(n), "<string>", "exec")
+
+        for n in range(MAX_MANAGERS, MAX_MANAGERS + 5):
+            with self.subTest(f"out of range: {n=}"):
+                self._check_error(get_code(n), "too many statically nested blocks")
+
+    @support.cpython_only
+    def test_async_with_statement_many_context_managers(self):
+        # See gh-116767
+
+        def get_code(n):
+            code = [ textwrap.dedent("""
+                async def bug():
+                    async with (
+                    a
+                """) ]
+            for i in range(n):
+                code.append(f"    as a{i}, a\n")
+            code.append("): yield a")
+            return "".join(code)
+
+        CO_MAXBLOCKS = 21  # static nesting limit of the compiler
+        MAX_MANAGERS = CO_MAXBLOCKS - 1  # One for the StopIteration block
+
+        for n in range(MAX_MANAGERS):
+            with self.subTest(f"within range: {n=}"):
+                compile(get_code(n), "<string>", "exec")
+
+        for n in range(MAX_MANAGERS, MAX_MANAGERS + 5):
+            with self.subTest(f"out of range: {n=}"):
+                self._check_error(get_code(n), "too many statically nested blocks")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; Wrong error message
     def test_barry_as_flufl_with_syntax_errors(self):
         # The "barry_as_flufl" rule can produce some "bugs-at-a-distance" if
         # is reading the wrong token in the presence of syntax errors later
@@ -2100,8 +2595,7 @@ def func2():
 """
         self._check_error(code, "expected ':'")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_line_continuation_error_position(self):
         self._check_error(r"a = 3 \ 4",
                           "unexpected character after line continuation character",
@@ -2113,8 +2607,7 @@ def test_invalid_line_continuation_error_position(self):
                           "unexpected character after line continuation character",
                           lineno=3, offset=4)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invalid_line_continuation_left_recursive(self):
         # Check bpo-42218: SyntaxErrors following left-recursive rules
         # (t_primary_raw in this case) need to be tested explicitly
@@ -2123,8 +2616,7 @@ def test_invalid_line_continuation_left_recursive(self):
         self._check_error("A.\u03bc\\\n",
                           "unexpected EOF while parsing")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_error_parenthesis(self):
         for paren in "([{":
             self._check_error(paren + "1 + 2", f"\\{paren}' was never closed")
@@ -2135,10 +2627,39 @@ def test_error_parenthesis(self):
         for paren in ")]}":
             self._check_error(paren + "1 + 2", f"unmatched '\\{paren}'")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        # Some more complex examples:
+        code = """\
+func(
+    a=["unclosed], # Need a quote in this comment: "
+    b=2,
+)
+"""
+        self._check_error(code, "parenthesis '\\)' does not match opening parenthesis '\\['")
+
+        self._check_error("match y:\n case e(e=v,v,", " was never closed")
+
+        # Examples with dencodings
+        s = b'# coding=latin\n(aaaaaaaaaaaaaaaaa\naaaaaaaaaaa\xb5'
+        self._check_error(s, r"'\(' was never closed")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_error_string_literal(self):
+
+        self._check_error("'blech", r"unterminated string literal \(.*\)$")
+        self._check_error('"blech', r"unterminated string literal \(.*\)$")
+        self._check_error(
+            r'"blech\"', r"unterminated string literal \(.*\); perhaps you escaped the end quote"
+        )
+        self._check_error(
+            r'r"blech\"', r"unterminated string literal \(.*\); perhaps you escaped the end quote"
+        )
+        self._check_error("'''blech", "unterminated triple-quoted string literal")
+        self._check_error('"""blech', "unterminated triple-quoted string literal")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_invisible_characters(self):
         self._check_error('print\x17("Hello")', "invalid non-printable character")
+        self._check_error(b"with(0,,):\n\x01", "invalid non-printable character")
 
     def test_match_call_does_not_raise_syntax_error(self):
         code = """
@@ -2158,8 +2679,7 @@ def case(x):
 """
         compile(code, "<string>", "exec")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_multiline_compiler_error_points_to_the_end(self):
         self._check_error(
             "call(\na=1,\na=1\n)",
@@ -2198,7 +2718,8 @@ def test_syntax_error_on_deeply_nested_blocks(self):
                   while 20:
                    while 21:
                     while 22:
-                     break
+                     while 23:
+                      break
 """
         self._check_error(source, "too many statically nested blocks")
 
@@ -2207,7 +2728,7 @@ def test_error_on_parser_stack_overflow(self):
         source = "-" * 100000 + "4"
         for mode in ["exec", "eval", "single"]:
             with self.subTest(mode=mode):
-                with self.assertRaises(MemoryError):
+                with self.assertRaisesRegex(MemoryError, r"too complex"):
                     compile(source, "<string>", mode)
 
     @support.cpython_only
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 1ce2e9fc0f..e5f88b325e 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -1,9 +1,12 @@
 import builtins
 import codecs
+# import _datetime # TODO: RUSTPYTHON
 import gc
+import io
 import locale
 import operator
 import os
+import random
 import struct
 import subprocess
 import sys
@@ -14,14 +17,21 @@
 from test.support.script_helper import assert_python_ok, assert_python_failure
 from test.support import threading_helper
 from test.support import import_helper
+from test.support import force_not_colorized
+try:
+    from test.support import interpreters
+except ImportError:
+    interpreters = None
 import textwrap
 import unittest
 import warnings
 
 
-# count the number of test runs, used to create unique
-# strings to intern in test_intern()
-INTERN_NUMRUNS = 0
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(interpreters is None,
+                           'subinterpreters required')(meth)
+
 
 DICT_KEY_STRUCT_FORMAT = 'n2BI2n'
 
@@ -71,6 +81,18 @@ def baddisplayhook(obj):
             code = compile("42", "<string>", "single")
             self.assertRaises(ValueError, eval, code)
 
+    def test_gh130163(self):
+        class X:
+            def __repr__(self):
+                sys.stdout = io.StringIO()
+                support.gc_collect()
+                return 'foo'
+
+        with support.swap_attr(sys, 'stdout', None):
+            sys.stdout = io.StringIO()  # the only reference
+            sys.displayhook(X())  # should not crash
+
+
 class ActiveExceptionTests(unittest.TestCase):
     def test_exc_info_no_exception(self):
         self.assertEqual(sys.exc_info(), (None, None, None))
@@ -137,6 +159,7 @@ def f():
 
 class ExceptHookTest(unittest.TestCase):
 
+    @force_not_colorized
     def test_original_excepthook(self):
         try:
             raise ValueError(42)
@@ -148,8 +171,8 @@ def test_original_excepthook(self):
 
         self.assertRaises(TypeError, sys.__excepthook__)
 
-    # TODO: RUSTPYTHON, SyntaxError formatting in arbitrary tracebacks
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; SyntaxError formatting in arbitrary tracebacks
+    @force_not_colorized
     def test_excepthook_bytes_filename(self):
         # bpo-37467: sys.excepthook() must not crash if a filename
         # is a bytes string
@@ -169,7 +192,8 @@ def test_excepthook_bytes_filename(self):
 
     def test_excepthook(self):
         with test.support.captured_output("stderr") as stderr:
-            sys.excepthook(1, '1', 1)
+            with test.support.catch_unraisable_exception():
+                sys.excepthook(1, '1', 1)
         self.assertTrue("TypeError: print_exception(): Exception expected for " \
                          "value, str found" in stderr.getvalue())
 
@@ -182,6 +206,7 @@ class SysModuleTest(unittest.TestCase):
     def tearDown(self):
         test.support.reap_children()
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_exit(self):
         # call with two arguments
         self.assertRaises(TypeError, sys.exit, 42, 42)
@@ -196,6 +221,20 @@ def test_exit(self):
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+        # gh-125842: Windows uses 32-bit unsigned integers for exit codes
+        # so a -1 exit code is sometimes interpreted as 0xffff_ffff.
+        rc, out, err = assert_python_failure('-c', 'import sys; sys.exit(0xffff_ffff)')
+        self.assertIn(rc, (-1, 0xff, 0xffff_ffff))
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
+
+        # Overflow results in a -1 exit code, which may be converted to 0xff
+        # or 0xffff_ffff.
+        rc, out, err = assert_python_failure('-c', 'import sys; sys.exit(2**128)')
+        self.assertIn(rc, (-1, 0xff, 0xffff_ffff))
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
+
         # call with integer argument
         with self.assertRaises(SystemExit) as cm:
             sys.exit(42)
@@ -238,17 +277,36 @@ def check_exit_message(code, expected, **env_vars):
 
         # test that the exit message is written with backslashreplace error
         # handler to stderr
-        # TODO: RUSTPYTHON; allow surrogates in strings
-        # check_exit_message(
-        #     r'import sys; sys.exit("surrogates:\uDCFF")',
-        #     b"surrogates:\\udcff")
+        check_exit_message(
+            r'import sys; sys.exit("surrogates:\uDCFF")',
+            b"surrogates:\\udcff")
 
         # test that the unicode message is encoded to the stderr encoding
         # instead of the default encoding (utf8)
-        # TODO: RUSTPYTHON; handle PYTHONIOENCODING
-        # check_exit_message(
-        #     r'import sys; sys.exit("h\xe9")',
-        #     b"h\xe9", PYTHONIOENCODING='latin-1')
+        check_exit_message(
+            r'import sys; sys.exit("h\xe9")',
+            b"h\xe9", PYTHONIOENCODING='latin-1')
+
+    @support.requires_subprocess()
+    def test_exit_codes_under_repl(self):
+        # GH-129900: SystemExit, or things that raised it, didn't
+        # get their return code propagated by the REPL
+        import tempfile
+
+        exit_ways = [
+            "exit",
+            "__import__('sys').exit",
+            "raise SystemExit"
+        ]
+
+        for exitfunc in exit_ways:
+            for return_code in (0, 123):
+                with self.subTest(exitfunc=exitfunc, return_code=return_code):
+                    with tempfile.TemporaryFile("w+") as stdin:
+                        stdin.write(f"{exitfunc}({return_code})\n")
+                        stdin.seek(0)
+                        proc = subprocess.run([sys.executable], stdin=stdin)
+                        self.assertEqual(proc.returncode, return_code)
 
     def test_getdefaultencoding(self):
         self.assertRaises(TypeError, sys.getdefaultencoding, 42)
@@ -273,21 +331,30 @@ def test_switchinterval(self):
         finally:
             sys.setswitchinterval(orig)
 
-    def test_recursionlimit(self):
+    def test_getrecursionlimit(self):
+        limit = sys.getrecursionlimit()
+        self.assertIsInstance(limit, int)
+        self.assertGreater(limit, 1)
+
         self.assertRaises(TypeError, sys.getrecursionlimit, 42)
-        oldlimit = sys.getrecursionlimit()
-        self.assertRaises(TypeError, sys.setrecursionlimit)
-        self.assertRaises(ValueError, sys.setrecursionlimit, -42)
-        sys.setrecursionlimit(10000)
-        self.assertEqual(sys.getrecursionlimit(), 10000)
-        sys.setrecursionlimit(oldlimit)
-
-    @unittest.skipIf(getattr(sys, "_rustpython_debugbuild", False), "TODO: RUSTPYTHON, stack overflow on debug build")
+
+    def test_setrecursionlimit(self):
+        old_limit = sys.getrecursionlimit()
+        try:
+            sys.setrecursionlimit(10_005)
+            self.assertEqual(sys.getrecursionlimit(), 10_005)
+
+            self.assertRaises(TypeError, sys.setrecursionlimit)
+            self.assertRaises(ValueError, sys.setrecursionlimit, -42)
+        finally:
+            sys.setrecursionlimit(old_limit)
+
+    @unittest.skipIf(getattr(sys, '_rustpython_debugbuild', False), 'TODO: RUSTPYTHON; stack overflow on debug build')
     def test_recursionlimit_recovery(self):
         if hasattr(sys, 'gettrace') and sys.gettrace():
             self.skipTest('fatal error if run with a trace function')
 
-        oldlimit = sys.getrecursionlimit()
+        old_limit = sys.getrecursionlimit()
         def f():
             f()
         try:
@@ -306,38 +373,63 @@ def f():
                 with self.assertRaises(RecursionError):
                     f()
         finally:
-            sys.setrecursionlimit(oldlimit)
+            sys.setrecursionlimit(old_limit)
 
     @test.support.cpython_only
-    def test_setrecursionlimit_recursion_depth(self):
+    def test_setrecursionlimit_to_depth(self):
         # Issue #25274: Setting a low recursion limit must be blocked if the
         # current recursion depth is already higher than limit.
 
-        from _testinternalcapi import get_recursion_depth
-
-        def set_recursion_limit_at_depth(depth, limit):
-            recursion_depth = get_recursion_depth()
-            if recursion_depth >= depth:
+        old_limit = sys.getrecursionlimit()
+        try:
+            depth = support.get_recursion_depth()
+            with self.subTest(limit=sys.getrecursionlimit(), depth=depth):
+                # depth + 1 is OK
+                sys.setrecursionlimit(depth + 1)
+
+                # reset the limit to be able to call self.assertRaises()
+                # context manager
+                sys.setrecursionlimit(old_limit)
                 with self.assertRaises(RecursionError) as cm:
-                    sys.setrecursionlimit(limit)
-                self.assertRegex(str(cm.exception),
-                                 "cannot set the recursion limit to [0-9]+ "
-                                 "at the recursion depth [0-9]+: "
-                                 "the limit is too low")
-            else:
-                set_recursion_limit_at_depth(depth, limit)
+                    sys.setrecursionlimit(depth)
+            self.assertRegex(str(cm.exception),
+                             "cannot set the recursion limit to [0-9]+ "
+                             "at the recursion depth [0-9]+: "
+                             "the limit is too low")
+        finally:
+            sys.setrecursionlimit(old_limit)
 
-        oldlimit = sys.getrecursionlimit()
-        try:
-            sys.setrecursionlimit(1000)
+    @unittest.skipUnless(support.Py_GIL_DISABLED, "only meaningful if the GIL is disabled")
+    @threading_helper.requires_working_threading()
+    def test_racing_recursion_limit(self):
+        from threading import Thread
+        def something_recursive():
+            def count(n):
+                if n > 0:
+                    return count(n - 1) + 1
+                return 0
 
-            for limit in (10, 25, 50, 75, 100, 150, 200):
-                set_recursion_limit_at_depth(limit, limit)
-        finally:
-            sys.setrecursionlimit(oldlimit)
+            count(50)
+
+        def set_recursion_limit():
+            for limit in range(100, 200):
+                sys.setrecursionlimit(limit)
+
+        threads = []
+        for _ in range(5):
+            threads.append(Thread(target=set_recursion_limit))
+
+        for _ in range(5):
+            threads.append(Thread(target=something_recursive))
+
+        with threading_helper.catch_threading_exception() as cm:
+            with threading_helper.start_threads(threads):
+                pass
+
+            if cm.exc_value:
+                raise cm.exc_value
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_getwindowsversion(self):
         # Raise SkipTest if sys doesn't have getwindowsversion attribute
         test.support.get_attribute(sys, "getwindowsversion")
@@ -368,8 +460,7 @@ def test_getwindowsversion(self):
         #  still has 5 elements
         maj, min, buildno, plat, csd = sys.getwindowsversion()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'call_tracing'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute 'call_tracing'
     def test_call_tracing(self):
         self.assertRaises(TypeError, sys.call_tracing, type, 2)
 
@@ -386,15 +477,21 @@ def test_dlopenflags(self):
 
     @test.support.refcount_test
     def test_refcount(self):
-        # n here must be a global in order for this test to pass while
-        # tracing with a python function.  Tracing calls PyFrame_FastToLocals
-        # which will add a copy of any locals to the frame object, causing
-        # the reference count to increase by 2 instead of 1.
+        # n here originally had to be a global in order for this test to pass
+        # while tracing with a python function. Tracing used to call
+        # PyFrame_FastToLocals, which would add a copy of any locals to the
+        # frame object, causing the ref count to increase by 2 instead of 1.
+        # While that no longer happens (due to PEP 667), this test case retains
+        # its original global-based implementation
+        # PEP 683's immortal objects also made this point moot, since the
+        # refcount for None doesn't change anyway. Maybe this test should be
+        # using a different constant value? (e.g. an integer)
         global n
         self.assertRaises(TypeError, sys.getrefcount)
         c = sys.getrefcount(None)
         n = None
-        self.assertEqual(sys.getrefcount(None), c+1)
+        # Singleton refcnts don't change
+        self.assertEqual(sys.getrefcount(None), c)
         del n
         self.assertEqual(sys.getrefcount(None), c)
         if hasattr(sys, "gettotalrefcount"):
@@ -408,6 +505,26 @@ def test_getframe(self):
             is sys._getframe().f_code
         )
 
+    def test_getframemodulename(self):
+        # Default depth gets ourselves
+        self.assertEqual(__name__, sys._getframemodulename())
+        self.assertEqual("unittest.case", sys._getframemodulename(1))
+        i = 0
+        f = sys._getframe(i)
+        while f:
+            self.assertEqual(
+                f.f_globals['__name__'],
+                sys._getframemodulename(i) or '__main__'
+            )
+            i += 1
+            f2 = f.f_back
+            try:
+                f = sys._getframe(i)
+            except ValueError:
+                break
+            self.assertIs(f, f2)
+        self.assertIsNone(sys._getframemodulename(i))
+
     # sys._current_frames() is a CPython-only gimmick.
     # XXX RUSTPYTHON: above comment is from original cpython test; not sure why the cpython_only decorator wasn't added
     @test.support.cpython_only
@@ -436,49 +553,49 @@ def g456():
         t.start()
         entered_g.wait()
 
-        # At this point, t has finished its entered_g.set(), although it's
-        # impossible to guess whether it's still on that line or has moved on
-        # to its leave_g.wait().
-        self.assertEqual(len(thread_info), 1)
-        thread_id = thread_info[0]
-
-        d = sys._current_frames()
-        for tid in d:
-            self.assertIsInstance(tid, int)
-            self.assertGreater(tid, 0)
-
-        main_id = threading.get_ident()
-        self.assertIn(main_id, d)
-        self.assertIn(thread_id, d)
-
-        # Verify that the captured main-thread frame is _this_ frame.
-        frame = d.pop(main_id)
-        self.assertTrue(frame is sys._getframe())
-
-        # Verify that the captured thread frame is blocked in g456, called
-        # from f123.  This is a little tricky, since various bits of
-        # threading.py are also in the thread's call stack.
-        frame = d.pop(thread_id)
-        stack = traceback.extract_stack(frame)
-        for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
-            if funcname == "f123":
-                break
-        else:
-            self.fail("didn't find f123() on thread's call stack")
-
-        self.assertEqual(sourceline, "g456()")
+        try:
+            # At this point, t has finished its entered_g.set(), although it's
+            # impossible to guess whether it's still on that line or has moved on
+            # to its leave_g.wait().
+            self.assertEqual(len(thread_info), 1)
+            thread_id = thread_info[0]
+
+            d = sys._current_frames()
+            for tid in d:
+                self.assertIsInstance(tid, int)
+                self.assertGreater(tid, 0)
+
+            main_id = threading.get_ident()
+            self.assertIn(main_id, d)
+            self.assertIn(thread_id, d)
+
+            # Verify that the captured main-thread frame is _this_ frame.
+            frame = d.pop(main_id)
+            self.assertTrue(frame is sys._getframe())
+
+            # Verify that the captured thread frame is blocked in g456, called
+            # from f123.  This is a little tricky, since various bits of
+            # threading.py are also in the thread's call stack.
+            frame = d.pop(thread_id)
+            stack = traceback.extract_stack(frame)
+            for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
+                if funcname == "f123":
+                    break
+            else:
+                self.fail("didn't find f123() on thread's call stack")
 
-        # And the next record must be for g456().
-        filename, lineno, funcname, sourceline = stack[i+1]
-        self.assertEqual(funcname, "g456")
-        self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
+            self.assertEqual(sourceline, "g456()")
 
-        # Reap the spawned thread.
-        leave_g.set()
-        t.join()
+            # And the next record must be for g456().
+            filename, lineno, funcname, sourceline = stack[i+1]
+            self.assertEqual(funcname, "g456")
+            self.assertIn(sourceline, ["leave_g.wait()", "entered_g.set()"])
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute '_current_exceptions'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_current_exceptions'
     @threading_helper.reap_threads
     @threading_helper.requires_working_threading()
     def test_current_exceptions(self):
@@ -488,7 +605,7 @@ def test_current_exceptions(self):
         # Spawn a thread that blocks at a known place.  Then the main
         # thread does sys._current_frames(), and verifies that the frames
         # returned make sense.
-        entered_g = threading.Event()
+        g_raised = threading.Event()
         leave_g = threading.Event()
         thread_info = []  # the thread's id
 
@@ -497,55 +614,54 @@ def f123():
 
         def g456():
             thread_info.append(threading.get_ident())
-            entered_g.set()
             while True:
                 try:
                     raise ValueError("oops")
                 except ValueError:
+                    g_raised.set()
                     if leave_g.wait(timeout=support.LONG_TIMEOUT):
                         break
 
         t = threading.Thread(target=f123)
         t.start()
-        entered_g.wait()
+        g_raised.wait(timeout=support.LONG_TIMEOUT)
 
-        # At this point, t has finished its entered_g.set(), although it's
-        # impossible to guess whether it's still on that line or has moved on
-        # to its leave_g.wait().
-        self.assertEqual(len(thread_info), 1)
-        thread_id = thread_info[0]
-
-        d = sys._current_exceptions()
-        for tid in d:
-            self.assertIsInstance(tid, int)
-            self.assertGreater(tid, 0)
-
-        main_id = threading.get_ident()
-        self.assertIn(main_id, d)
-        self.assertIn(thread_id, d)
-        self.assertEqual((None, None, None), d.pop(main_id))
-
-        # Verify that the captured thread frame is blocked in g456, called
-        # from f123.  This is a little tricky, since various bits of
-        # threading.py are also in the thread's call stack.
-        exc_type, exc_value, exc_tb = d.pop(thread_id)
-        stack = traceback.extract_stack(exc_tb.tb_frame)
-        for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
-            if funcname == "f123":
-                break
-        else:
-            self.fail("didn't find f123() on thread's call stack")
-
-        self.assertEqual(sourceline, "g456()")
+        try:
+            self.assertEqual(len(thread_info), 1)
+            thread_id = thread_info[0]
+
+            d = sys._current_exceptions()
+            for tid in d:
+                self.assertIsInstance(tid, int)
+                self.assertGreater(tid, 0)
+
+            main_id = threading.get_ident()
+            self.assertIn(main_id, d)
+            self.assertIn(thread_id, d)
+            self.assertEqual(None, d.pop(main_id))
+
+            # Verify that the captured thread frame is blocked in g456, called
+            # from f123.  This is a little tricky, since various bits of
+            # threading.py are also in the thread's call stack.
+            exc_value = d.pop(thread_id)
+            stack = traceback.extract_stack(exc_value.__traceback__.tb_frame)
+            for i, (filename, lineno, funcname, sourceline) in enumerate(stack):
+                if funcname == "f123":
+                    break
+            else:
+                self.fail("didn't find f123() on thread's call stack")
 
-        # And the next record must be for g456().
-        filename, lineno, funcname, sourceline = stack[i+1]
-        self.assertEqual(funcname, "g456")
-        self.assertTrue(sourceline.startswith("if leave_g.wait("))
+            self.assertEqual(sourceline, "g456()")
 
-        # Reap the spawned thread.
-        leave_g.set()
-        t.join()
+            # And the next record must be for g456().
+            filename, lineno, funcname, sourceline = stack[i+1]
+            self.assertEqual(funcname, "g456")
+            self.assertTrue((sourceline.startswith("if leave_g.wait(") or
+                             sourceline.startswith("g_raised.set()")))
+        finally:
+            # Reap the spawned thread.
+            leave_g.set()
+            t.join()
 
     def test_attributes(self):
         self.assertIsInstance(sys.api_version, int)
@@ -647,7 +763,7 @@ def test_thread_info(self):
         self.assertEqual(len(info), 3)
         self.assertIn(info.name, ('nt', 'pthread', 'pthread-stubs', 'solaris', None))
         self.assertIn(info.lock, ('semaphore', 'mutex+cond', None))
-        if sys.platform.startswith(("linux", "freebsd")):
+        if sys.platform.startswith(("linux", "android", "freebsd")):
             self.assertEqual(info.name, "pthread")
         elif sys.platform == "win32":
             self.assertEqual(info.name, "nt")
@@ -670,13 +786,23 @@ def test_43581(self):
         self.assertEqual(sys.__stdout__.encoding, sys.__stderr__.encoding)
 
     def test_intern(self):
-        global INTERN_NUMRUNS
-        INTERN_NUMRUNS += 1
+        has_is_interned = (test.support.check_impl_detail(cpython=True)
+                           or hasattr(sys, '_is_interned'))
         self.assertRaises(TypeError, sys.intern)
-        s = "never interned before" + str(INTERN_NUMRUNS)
+        self.assertRaises(TypeError, sys.intern, b'abc')
+        if has_is_interned:
+            self.assertRaises(TypeError, sys._is_interned)
+            self.assertRaises(TypeError, sys._is_interned, b'abc')
+        s = "never interned before" + str(random.randrange(0, 10**9))
         self.assertTrue(sys.intern(s) is s)
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s), True)
         s2 = s.swapcase().swapcase()
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s2), False)
         self.assertTrue(sys.intern(s2) is s)
+        if has_is_interned:
+            self.assertIs(sys._is_interned(s2), False)
 
         # Subclasses of string can't be interned, because they
         # provide too much opportunity for insane things to happen.
@@ -688,6 +814,73 @@ def __hash__(self):
                 return 123
 
         self.assertRaises(TypeError, sys.intern, S("abc"))
+        if has_is_interned:
+            self.assertIs(sys._is_interned(S("abc")), False)
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_dynamically_allocated(self):
+        # Implementation detail: Dynamically allocated strings
+        # are distinct between interpreters
+        s = "never interned before" + str(random.randrange(0, 10**9))
+        t = sys.intern(s)
+        self.assertIs(t, s)
+
+        interp = interpreters.create()
+        interp.exec(textwrap.dedent(f'''
+            import sys
+
+            # set `s`, avoid parser interning & constant folding
+            s = str({s.encode()!r}, 'utf-8')
+
+            t = sys.intern(s)
+
+            assert id(t) != {id(s)}, (id(t), {id(s)})
+            assert id(t) != {id(t)}, (id(t), {id(t)})
+            '''))
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_statically_allocated(self):
+        # Implementation detail: Statically allocated strings are shared
+        # between interpreters.
+        # See Tools/build/generate_global_objects.py for the list
+        # of strings that are always statically allocated.
+        for s in ('__init__', 'CANCELLED', '<module>', 'utf-8',
+                  '{{', '', '\n', '_', 'x', '\0', '\N{CEDILLA}', '\xff',
+                  ):
+            with self.subTest(s=s):
+                t = sys.intern(s)
+
+                interp = interpreters.create()
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+
+                    # set `s`, avoid parser interning & constant folding
+                    s = str({s.encode()!r}, 'utf-8')
+
+                    t = sys.intern(s)
+                    assert id(t) == {id(t)}, (id(t), {id(t)})
+                    '''))
+
+    @support.cpython_only
+    @requires_subinterpreters
+    def test_subinterp_intern_singleton(self):
+        # Implementation detail: singletons are used for 0- and 1-character
+        # latin1 strings.
+        for s in '', '\n', '_', 'x', '\0', '\N{CEDILLA}', '\xff':
+            with self.subTest(s=s):
+                interp = interpreters.create()
+                interp.exec(textwrap.dedent(f'''
+                    import sys
+
+                    # set `s`, avoid parser interning & constant folding
+                    s = str({s.encode()!r}, 'utf-8')
+
+                    assert id(s) == {id(s)}
+                    t = sys.intern(s)
+                    '''))
+                self.assertTrue(sys._is_interned(s))
 
     def test_sys_flags(self):
         self.assertTrue(sys.flags)
@@ -709,12 +902,7 @@ def test_sys_flags(self):
     def assert_raise_on_new_sys_type(self, sys_attr):
         # Users are intentionally prevented from creating new instances of
         # sys.flags, sys.version_info, and sys.getwindowsversion.
-        arg = sys_attr
-        attr_type = type(sys_attr)
-        with self.assertRaises(TypeError):
-            attr_type(arg)
-        with self.assertRaises(TypeError):
-            attr_type.__new__(attr_type, arg)
+        support.check_disallow_instantiation(self, type(sys_attr), sys_attr)
 
     def test_sys_flags_no_instantiation(self):
         self.assert_raise_on_new_sys_type(sys.flags)
@@ -722,8 +910,7 @@ def test_sys_flags_no_instantiation(self):
     def test_sys_version_info_no_instantiation(self):
         self.assert_raise_on_new_sys_type(sys.version_info)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_sys_getwindowsversion_no_instantiation(self):
         # Skip if not being run on Windows.
         test.support.get_attribute(sys, "getwindowsversion")
@@ -733,8 +920,8 @@ def test_sys_getwindowsversion_no_instantiation(self):
     def test_clear_type_cache(self):
         sys._clear_type_cache()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.skip("TODO: RUSTPYTHON; cp424 encoding not supported, causes panic")
+    @force_not_colorized
     @support.requires_subprocess()
     def test_ioencoding(self):
         env = dict(os.environ)
@@ -898,14 +1085,12 @@ def check_locale_surrogateescape(self, locale):
                          'stdout: surrogateescape\n'
                          'stderr: backslashreplace\n')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_c_locale_surrogateescape(self):
         self.check_locale_surrogateescape('C')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @support.requires_subprocess()
     def test_posix_locale_surrogateescape(self):
         self.check_locale_surrogateescape('POSIX')
@@ -958,12 +1143,12 @@ def test_debugmallocstats(self):
                          "sys.getallocatedblocks unavailable on this build")
     def test_getallocatedblocks(self):
         try:
-            import _testcapi
+            import _testinternalcapi
         except ImportError:
             with_pymalloc = support.with_pymalloc()
         else:
             try:
-                alloc_name = _testcapi.pymem_getallocatorsname()
+                alloc_name = _testinternalcapi.pymem_getallocatorsname()
             except RuntimeError as exc:
                 # "cannot get allocators name" (ex: tracemalloc is used)
                 with_pymalloc = True
@@ -995,8 +1180,13 @@ def test_getallocatedblocks(self):
         c = sys.getallocatedblocks()
         self.assertIn(c, range(b - 50, b + 50))
 
-    # TODO: RUSTPYTHON, AtExit.__del__ is not invoked because module destruction is missing.
-    @unittest.expectedFailure
+    def test_is_gil_enabled(self):
+        if support.Py_GIL_DISABLED:
+            self.assertIs(type(sys._is_gil_enabled()), bool)
+        else:
+            self.assertTrue(sys._is_gil_enabled())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AtExit.__del__ is not invoked because module destruction is missing.
     def test_is_finalizing(self):
         self.assertIs(sys.is_finalizing(), False)
         # Don't use the atexit module because _Py_Finalizing is only set
@@ -1018,8 +1208,7 @@ def __del__(self):
         rc, stdout, stderr = assert_python_ok('-c', code)
         self.assertEqual(stdout.rstrip(), b'True')
 
-    # TODO: RUSTPYTHON, IndexError: list index out of range
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; IndexError: list index out of range
     def test_issue20602(self):
         # sys.flags and sys.float_info were wiped during shutdown.
         code = """if 1:
@@ -1052,15 +1241,15 @@ def __del__(self):
         self.assertEqual(stdout.rstrip(), b"")
         self.assertEqual(stderr.rstrip(), b"")
 
-    @unittest.skipUnless(hasattr(sys, 'getandroidapilevel'),
-                         'need sys.getandroidapilevel()')
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute 'getandroidapilevel'
+    @unittest.skipUnless(sys.platform == "android", "Android only")
     def test_getandroidapilevel(self):
         level = sys.getandroidapilevel()
         self.assertIsInstance(level, int)
         self.assertGreater(level, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @force_not_colorized
     @support.requires_subprocess()
     def test_sys_tracebacklimit(self):
         code = """if 1:
@@ -1081,14 +1270,20 @@ def check(tracebacklimit, expected):
         traceback = [
             b'Traceback (most recent call last):',
             b'  File "<string>", line 8, in <module>',
+            b'    f2()',
+            b'    ~~^^',
             b'  File "<string>", line 6, in f2',
+            b'    f1()',
+            b'    ~~^^',
             b'  File "<string>", line 4, in f1',
+            b'    1 / 0',
+            b'    ~~^~~',
             b'ZeroDivisionError: division by zero'
         ]
         check(10, traceback)
         check(3, traceback)
-        check(2, traceback[:1] + traceback[2:])
-        check(1, traceback[:1] + traceback[3:])
+        check(2, traceback[:1] + traceback[4:])
+        check(1, traceback[:1] + traceback[7:])
         check(0, [traceback[-1]])
         check(-1, [traceback[-1]])
         check(1<<1000, traceback)
@@ -1124,15 +1319,12 @@ def test_orig_argv(self):
         self.assertEqual(proc.stdout.rstrip().splitlines(), expected,
                          proc)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute 'stdlib_module_names'
-    @unittest.expectedFailure
     def test_module_names(self):
         self.assertIsInstance(sys.stdlib_module_names, frozenset)
         for name in sys.stdlib_module_names:
             self.assertIsInstance(name, str)
 
-    # TODO: RUSTPYTHON, AttributeError: module 'sys' has no attribute '_stdlib_dir'
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: module 'sys' has no attribute '_stdlib_dir'
     def test_stdlib_dir(self):
         os = import_helper.import_fresh_module('os')
         marker = getattr(os, '__file__', None)
@@ -1142,41 +1334,76 @@ def test_stdlib_dir(self):
         self.assertEqual(os.path.normpath(sys._stdlib_dir),
                          os.path.normpath(expected))
 
+    @unittest.skipUnless(hasattr(sys, 'getobjects'), 'need sys.getobjects()')
+    def test_getobjects(self):
+        # sys.getobjects(0)
+        all_objects = sys.getobjects(0)
+        self.assertIsInstance(all_objects, list)
+        self.assertGreater(len(all_objects), 0)
+
+        # sys.getobjects(0, MyType)
+        class MyType:
+            pass
+        size = 100
+        my_objects = [MyType() for _ in range(size)]
+        get_objects = sys.getobjects(0, MyType)
+        self.assertEqual(len(get_objects), size)
+        for obj in get_objects:
+            self.assertIsInstance(obj, MyType)
+
+        # sys.getobjects(3, MyType)
+        get_objects = sys.getobjects(3, MyType)
+        self.assertEqual(len(get_objects), 3)
+
+    @unittest.skipUnless(hasattr(sys, '_stats_on'), 'need Py_STATS build')
+    def test_pystats(self):
+        # Call the functions, just check that they don't crash
+        # Cannot save/restore state.
+        sys._stats_on()
+        sys._stats_off()
+        sys._stats_clear()
+        sys._stats_dump()
+
+    @test.support.cpython_only
+    @unittest.skipUnless(hasattr(sys, 'abiflags'), 'need sys.abiflags')
+    def test_disable_gil_abi(self):
+        self.assertEqual('t' in sys.abiflags, support.Py_GIL_DISABLED)
+
 
 @test.support.cpython_only
 class UnraisableHookTest(unittest.TestCase):
-    def write_unraisable_exc(self, exc, err_msg, obj):
-        import _testcapi
-        import types
-        err_msg2 = f"Exception ignored {err_msg}"
-        try:
-            _testcapi.write_unraisable_exc(exc, err_msg, obj)
-            return types.SimpleNamespace(exc_type=type(exc),
-                                         exc_value=exc,
-                                         exc_traceback=exc.__traceback__,
-                                         err_msg=err_msg2,
-                                         object=obj)
-        finally:
-            # Explicitly break any reference cycle
-            exc = None
-
     def test_original_unraisablehook(self):
-        for err_msg in (None, "original hook"):
-            with self.subTest(err_msg=err_msg):
-                obj = "an object"
-
-                with test.support.captured_output("stderr") as stderr:
-                    with test.support.swap_attr(sys, 'unraisablehook',
-                                                sys.__unraisablehook__):
-                        self.write_unraisable_exc(ValueError(42), err_msg, obj)
-
-                err = stderr.getvalue()
-                if err_msg is not None:
-                    self.assertIn(f'Exception ignored {err_msg}: {obj!r}\n', err)
-                else:
-                    self.assertIn(f'Exception ignored in: {obj!r}\n', err)
-                self.assertIn('Traceback (most recent call last):\n', err)
-                self.assertIn('ValueError: 42\n', err)
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable, err_formatunraisable
+        obj = hex
+
+        with support.swap_attr(sys, 'unraisablehook',
+                                    sys.__unraisablehook__):
+            with support.captured_stderr() as stderr:
+                err_writeunraisable(ValueError(42), obj)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], f'Exception ignored in: {obj!r}')
+            self.assertEqual(lines[1], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_writeunraisable(ValueError(42), None)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_formatunraisable(ValueError(42), 'Error in %R', obj)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], f'Error in {obj!r}:')
+            self.assertEqual(lines[1], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
+
+            with support.captured_stderr() as stderr:
+                err_formatunraisable(ValueError(42), None)
+            lines = stderr.getvalue().splitlines()
+            self.assertEqual(lines[0], 'Traceback (most recent call last):')
+            self.assertEqual(lines[-1], 'ValueError: 42')
 
     def test_original_unraisablehook_err(self):
         # bpo-22836: PyErr_WriteUnraisable() should give sensible reports
@@ -1223,6 +1450,8 @@ def test_original_unraisablehook_exception_qualname(self):
         # Check that the exception is printed with its qualified name
         # rather than just classname, and the module names appears
         # unless it is one of the hard-coded exclusions.
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable
         class A:
             class B:
                 class X(Exception):
@@ -1234,9 +1463,7 @@ class X(Exception):
                 with test.support.captured_stderr() as stderr, test.support.swap_attr(
                     sys, 'unraisablehook', sys.__unraisablehook__
                 ):
-                    expected = self.write_unraisable_exc(
-                        A.B.X(), "msg", "obj"
-                    )
+                    err_writeunraisable(A.B.X(), "obj")
                 report = stderr.getvalue()
                 self.assertIn(A.B.X.__qualname__, report)
                 if moduleName in ['builtins', '__main__']:
@@ -1252,34 +1479,45 @@ def test_original_unraisablehook_wrong_type(self):
                 sys.unraisablehook(exc)
 
     def test_custom_unraisablehook(self):
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable, err_formatunraisable
         hook_args = None
 
         def hook_func(args):
             nonlocal hook_args
             hook_args = args
 
-        obj = object()
+        obj = hex
         try:
             with test.support.swap_attr(sys, 'unraisablehook', hook_func):
-                expected = self.write_unraisable_exc(ValueError(42),
-                                                     "custom hook", obj)
-                for attr in "exc_type exc_value exc_traceback err_msg object".split():
-                    self.assertEqual(getattr(hook_args, attr),
-                                     getattr(expected, attr),
-                                     (hook_args, expected))
+                exc = ValueError(42)
+                err_writeunraisable(exc, obj)
+                self.assertIs(hook_args.exc_type, type(exc))
+                self.assertIs(hook_args.exc_value, exc)
+                self.assertIs(hook_args.exc_traceback, exc.__traceback__)
+                self.assertIsNone(hook_args.err_msg)
+                self.assertEqual(hook_args.object, obj)
+
+                err_formatunraisable(exc, "custom hook %R", obj)
+                self.assertIs(hook_args.exc_type, type(exc))
+                self.assertIs(hook_args.exc_value, exc)
+                self.assertIs(hook_args.exc_traceback, exc.__traceback__)
+                self.assertEqual(hook_args.err_msg, f'custom hook {obj!r}')
+                self.assertIsNone(hook_args.object)
         finally:
             # expected and hook_args contain an exception: break reference cycle
             expected = None
             hook_args = None
 
     def test_custom_unraisablehook_fail(self):
+        _testcapi = import_helper.import_module('_testcapi')
+        from _testcapi import err_writeunraisable
         def hook_func(*args):
             raise Exception("hook_func failed")
 
         with test.support.captured_output("stderr") as stderr:
             with test.support.swap_attr(sys, 'unraisablehook', hook_func):
-                self.write_unraisable_exc(ValueError(42),
-                                          "custom hook fail", None)
+                err_writeunraisable(ValueError(42), "custom hook fail")
 
         err = stderr.getvalue()
         self.assertIn(f'Exception ignored in sys.unraisablehook: '
@@ -1295,8 +1533,9 @@ class SizeofTest(unittest.TestCase):
     def setUp(self):
         self.P = struct.calcsize('P')
         self.longdigit = sys.int_info.sizeof_digit
-        import _testinternalcapi
+        _testinternalcapi = import_helper.import_module("_testinternalcapi")
         self.gc_headsize = _testinternalcapi.SIZEOF_PYGC_HEAD
+        self.managed_pre_header_size = _testinternalcapi.SIZEOF_MANAGED_PRE_HEADER
 
     check_sizeof = test.support.check_sizeof
 
@@ -1332,7 +1571,7 @@ class OverflowSizeof(int):
             def __sizeof__(self):
                 return int(self)
         self.assertEqual(sys.getsizeof(OverflowSizeof(sys.maxsize)),
-                         sys.maxsize + self.gc_headsize)
+                         sys.maxsize + self.gc_headsize + self.managed_pre_header_size)
         with self.assertRaises(OverflowError):
             sys.getsizeof(OverflowSizeof(sys.maxsize + 1))
         with self.assertRaises(ValueError):
@@ -1454,10 +1693,10 @@ class C(object): pass
         def func():
             return sys._getframe()
         x = func()
-        check(x, size('3Pi3c7P2ic??2P'))
+        check(x, size('3Pi2c2P7P2ic??2P'))
         # function
         def func(): pass
-        check(func, size('14Pi'))
+        check(func, size('15Pi'))
         class c():
             @staticmethod
             def foo():
@@ -1471,7 +1710,7 @@ def bar(cls):
             check(bar, size('PP'))
         # generator
         def get_gen(): yield 1
-        check(get_gen(), size('P2P4P4c7P2ic??P'))
+        check(get_gen(), size('PP4P4c7P2ic??2P'))
         # iterator
         check(iter('abc'), size('lP'))
         # callable-iterator
@@ -1499,7 +1738,10 @@ def get_gen(): yield 1
         check(int(PyLong_BASE**2-1), vsize('') + 2*self.longdigit)
         check(int(PyLong_BASE**2), vsize('') + 3*self.longdigit)
         # module
-        check(unittest, size('PnPPP'))
+        if support.Py_GIL_DISABLED:
+            check(unittest, size('PPPPPP'))
+        else:
+            check(unittest, size('PPPPP'))
         # None
         check(None, size(''))
         # NotImplementedType
@@ -1514,9 +1756,10 @@ def delx(self): del self.__x
             x = property(getx, setx, delx, "")
             check(x, size('5Pi'))
         # PyCapsule
-        # XXX
+        check(_datetime.datetime_CAPI, size('6P'))
         # rangeiterator
-        check(iter(range(1)), size('4l'))
+        check(iter(range(1)), size('3l'))
+        check(iter(range(2**65)), size('3P'))
         # reverse
         check(reversed(''), size('nP'))
         # range
@@ -1553,8 +1796,8 @@ def delx(self): del self.__x
         check((1,2,3), vsize('') + 3*self.P)
         # type
         # static type: PyTypeObject
-        fmt = 'P2nPI13Pl4Pn9Pn12PIP'
-        s = vsize('2P' + fmt)
+        fmt = 'P2nPI13Pl4Pn9Pn12PIPc'
+        s = vsize(fmt)
         check(int, s)
         # class
         s = vsize(fmt +                 # PyTypeObject
@@ -1564,7 +1807,7 @@ def delx(self): del self.__x
                   '10P'                 # PySequenceMethods
                   '2P'                  # PyBufferProcs
                   '6P'
-                  '1P'                  # Specializer cache
+                  '1PIP'                 # Specializer cache
                   )
         class newstyleclass(object): pass
         # Separate block for PyDictKeysObject with 8 keys and 5 entries
@@ -1586,8 +1829,8 @@ class newstyleclass(object): pass
                    '\u0100'*40, '\uffff'*100,
                    '\U00010000'*30, '\U0010ffff'*100]
         # also update field definitions in test_unicode.test_raiseMemError
-        asciifields = "nnbP"
-        compactfields = asciifields + "nPn"
+        asciifields = "nnb"
+        compactfields = asciifields + "nP"
         unicodefields = compactfields + "P"
         for s in samples:
             maxchar = ord(max(s))
@@ -1611,11 +1854,15 @@ class newstyleclass(object): pass
         # TODO: add check that forces layout of unicodefields
         # weakref
         import weakref
-        check(weakref.ref(int), size('2Pn3P'))
+        if support.Py_GIL_DISABLED:
+            expected = size('2Pn4P')
+        else:
+            expected = size('2Pn3P')
+        check(weakref.ref(int), expected)
         # weakproxy
         # XXX
         # weakcallableproxy
-        check(weakref.proxy(int), size('2Pn3P'))
+        check(weakref.proxy(int), expected)
 
     def check_slots(self, obj, base, extra):
         expected = sys.getsizeof(base) + struct.calcsize(extra)
@@ -1657,15 +1904,16 @@ def test_pythontypes(self):
         check(_ast.AST(), size('P'))
         try:
             raise TypeError
-        except TypeError:
-            tb = sys.exc_info()[2]
+        except TypeError as e:
+            tb = e.__traceback__
             # traceback
             if tb is not None:
                 check(tb, size('2P2i'))
         # symtable entry
         # XXX
         # sys.flags
-        check(sys.flags, vsize('') + self.P * len(sys.flags))
+        # FIXME: The +1 will not be necessary once gh-122575 is fixed
+        check(sys.flags, vsize('') + self.P * (1 + len(sys.flags)))
 
     def test_asyncgen_hooks(self):
         old = sys.get_asyncgen_hooks()
@@ -1673,6 +1921,21 @@ def test_asyncgen_hooks(self):
         self.assertIsNone(old.finalizer)
 
         firstiter = lambda *a: None
+        finalizer = lambda *a: None
+
+        with self.assertRaises(TypeError):
+            sys.set_asyncgen_hooks(firstiter=firstiter, finalizer="invalid")
+        cur = sys.get_asyncgen_hooks()
+        self.assertIsNone(cur.firstiter)
+        self.assertIsNone(cur.finalizer)
+
+        # gh-118473
+        with self.assertRaises(TypeError):
+            sys.set_asyncgen_hooks(firstiter="invalid", finalizer=finalizer)
+        cur = sys.get_asyncgen_hooks()
+        self.assertIsNone(cur.firstiter)
+        self.assertIsNone(cur.finalizer)
+
         sys.set_asyncgen_hooks(firstiter=firstiter)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
@@ -1680,7 +1943,6 @@ def test_asyncgen_hooks(self):
         self.assertIs(hooks.finalizer, None)
         self.assertIs(hooks[1], None)
 
-        finalizer = lambda *a: None
         sys.set_asyncgen_hooks(finalizer=finalizer)
         hooks = sys.get_asyncgen_hooks()
         self.assertIs(hooks.firstiter, firstiter)
diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py
index 6db1442980..82c11bdf7e 100644
--- a/Lib/test/test_sysconfig.py
+++ b/Lib/test/test_sysconfig.py
@@ -1,24 +1,35 @@
+import platform
+import re
 import unittest
 import sys
 import os
 import subprocess
 import shutil
+import json
+import textwrap
 from copy import copy
 
 from test.support import (
-    captured_stdout, PythonSymlink, requires_subprocess, is_wasi
+    captured_stdout,
+    is_apple_mobile,
+    is_wasi,
+    PythonSymlink,
+    requires_subprocess,
 )
 from test.support.import_helper import import_module
 from test.support.os_helper import (TESTFN, unlink, skip_unless_symlink,
                                     change_cwd)
-from test.support.warnings_helper import check_warnings
+from test.support.venv import VirtualEnvironment
 
 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, _main)
+                       _expand_vars, _get_preferred_schemes)
+from sysconfig.__main__ import _main, _parse_makefile
+import _imp
 import _osx_support
+import _sysconfig
 
 
 HAS_USER_BASE = sysconfig._HAS_USER_BASE
@@ -41,6 +52,7 @@ def setUp(self):
         self.name = os.name
         self.platform = sys.platform
         self.version = sys.version
+        self._framework = sys._framework
         self.sep = os.sep
         self.join = os.path.join
         self.isabs = os.path.isabs
@@ -64,6 +76,7 @@ def tearDown(self):
         os.name = self.name
         sys.platform = self.platform
         sys.version = self.version
+        sys._framework = self._framework
         os.sep = self.sep
         os.path.join = self.join
         os.path.isabs = self.isabs
@@ -91,6 +104,12 @@ 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)
 
@@ -137,35 +156,37 @@ def test_get_preferred_schemes(self):
         # Mac, framework build.
         os.name = 'posix'
         sys.platform = 'darwin'
-        sys._framework = True
+        sys._framework = "MyPython"
         self.assertIsInstance(schemes, dict)
         self.assertEqual(set(schemes), expected_schemes)
 
-    # NOTE: RUSTPYTHON this is hardcoded to 'python', we're set up for failure.
-    @unittest.expectedFailure
     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',
-                               'python%d.%d' % sys.version_info[:2],
+                               # XXX: RUSTPYTHON
+                               f'rustpython{sysconfig._get_python_version_abi()}',
                                'site-packages')
 
-        # Resolve the paths in prefix
-        binpath = os.path.join(sys.prefix, binpath)
-        incpath = os.path.join(sys.prefix, incpath)
-        libpath = os.path.join(sys.prefix, libpath)
+        # Resolve the paths in an imaginary venv/ directory
+        binpath = os.path.join('venv', binpath)
+        incpath = os.path.join('venv', incpath)
+        libpath = os.path.join('venv', libpath)
+
+        # Mimic the venv module, set all bases to the venv directory
+        bases = ('base', 'platbase', 'installed_base', 'installed_platbase')
+        vars = {base: 'venv' for base in bases}
 
-        self.assertEqual(binpath, sysconfig.get_path('scripts', scheme='posix_venv'))
-        self.assertEqual(libpath, sysconfig.get_path('purelib', scheme='posix_venv'))
+        self.assertEqual(binpath, sysconfig.get_path('scripts', scheme='posix_venv', vars=vars))
+        self.assertEqual(libpath, sysconfig.get_path('purelib', scheme='posix_venv', vars=vars))
 
         # 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')
+        sysconfig_includedir = sysconfig.get_path('include', scheme='posix_venv', vars=vars)
         self.assertTrue(sysconfig_includedir.startswith(incpath + os.sep))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_nt_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
@@ -173,14 +194,19 @@ def test_nt_venv_scheme(self):
         incpath = 'Include'
         libpath = os.path.join('Lib', 'site-packages')
 
-        # Resolve the paths in prefix
-        binpath = os.path.join(sys.prefix, binpath)
-        incpath = os.path.join(sys.prefix, incpath)
-        libpath = os.path.join(sys.prefix, libpath)
+        # Resolve the paths in an imaginary venv\ directory
+        venv = 'venv'
+        binpath = os.path.join(venv, binpath)
+        incpath = os.path.join(venv, incpath)
+        libpath = os.path.join(venv, libpath)
+
+        # Mimic the venv module, set all bases to the venv directory
+        bases = ('base', 'platbase', 'installed_base', 'installed_platbase')
+        vars = {base: 'venv' for base in bases}
 
-        self.assertEqual(binpath, sysconfig.get_path('scripts', scheme='nt_venv'))
-        self.assertEqual(incpath, sysconfig.get_path('include', scheme='nt_venv'))
-        self.assertEqual(libpath, sysconfig.get_path('purelib', scheme='nt_venv'))
+        self.assertEqual(binpath, sysconfig.get_path('scripts', scheme='nt_venv', vars=vars))
+        self.assertEqual(incpath, sysconfig.get_path('include', scheme='nt_venv', vars=vars))
+        self.assertEqual(libpath, sysconfig.get_path('purelib', scheme='nt_venv', vars=vars))
 
     def test_venv_scheme(self):
         if sys.platform == 'win32':
@@ -216,6 +242,11 @@ def test_get_config_vars(self):
         self.assertTrue(cvars)
 
     def test_get_platform(self):
+        # Check the actual platform returns something reasonable.
+        actual_platform = get_platform()
+        self.assertIsInstance(actual_platform, str)
+        self.assertTrue(actual_platform)
+
         # windows XP, 32bits
         os.name = 'nt'
         sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) '
@@ -321,6 +352,13 @@ def test_get_platform(self):
 
             self.assertEqual(get_platform(), 'macosx-10.4-%s' % arch)
 
+        for macver in range(11, 16):
+            _osx_support._remove_original_values(get_config_vars())
+            get_config_vars()['CFLAGS'] = ('-fno-strict-overflow -Wsign-compare -Wunreachable-code'
+                                        '-arch arm64 -fno-common -dynamic -DNDEBUG -g -O3 -Wall')
+            get_config_vars()['MACOSX_DEPLOYMENT_TARGET'] = f"{macver}.0"
+            self.assertEqual(get_platform(), 'macosx-%d.0-arm64' % macver)
+
         # linux debian sarge
         os.name = 'posix'
         sys.version = ('2.3.5 (#1, Jul  4 2007, 17:28:59) '
@@ -331,11 +369,27 @@ def test_get_platform(self):
 
         self.assertEqual(get_platform(), 'linux-i686')
 
+        # Android
+        os.name = 'posix'
+        sys.platform = 'android'
+        get_config_vars()['ANDROID_API_LEVEL'] = 9
+        for machine, abi in {
+            'x86_64': 'x86_64',
+            'i686': 'x86',
+            'aarch64': 'arm64_v8a',
+            'armv7l': 'armeabi_v7a',
+        }.items():
+            with self.subTest(machine):
+                self._set_uname(('Linux', 'localhost', '3.18.91+',
+                                '#1 Tue Jan 9 20:35:43 UTC 2018', machine))
+                self.assertEqual(get_platform(), f'android-9-{abi}')
+
         # XXX more platforms to tests here
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @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")
     def test_get_config_h_filename(self):
         config_h = sysconfig.get_config_h_filename()
         self.assertTrue(os.path.isfile(config_h), config_h)
@@ -381,8 +435,8 @@ def test_user_similar(self):
                 if name == 'platlib':
                     # Replace "/lib64/python3.11/site-packages" suffix
                     # with "/lib/python3.11/site-packages".
-                    py_version_short = sysconfig.get_python_version()
-                    suffix = f'python{py_version_short}/site-packages'
+                    py_version_abi = sysconfig._get_python_version_abi()
+                    suffix = f'python{py_version_abi}/site-packages'
                     expected = expected.replace(f'/{sys.platlibdir}/{suffix}',
                                                 f'/lib/{suffix}')
                 self.assertEqual(user_path, expected)
@@ -393,8 +447,6 @@ def test_main(self):
             _main()
         self.assertTrue(len(output.getvalue().split('\n')) > 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.platform == "win32", "Does not apply to Windows")
     def test_ldshared_value(self):
         ldflags = sysconfig.get_config_var('LDFLAGS')
@@ -402,6 +454,31 @@ def test_ldshared_value(self):
 
         self.assertIn(ldflags, ldshared)
 
+    @unittest.skipIf(not _imp.extension_suffixes(), "stub loader has no suffixes")
+    def test_soabi(self):
+        soabi = sysconfig.get_config_var('SOABI')
+        self.assertIn(soabi, _imp.extension_suffixes()[0])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    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'))
+            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'))
+            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}'))
+
     @unittest.skipUnless(sys.platform == "darwin", "test only relevant on MacOSX")
     @requires_subprocess()
     def test_platform_in_subprocess(self):
@@ -446,8 +523,10 @@ 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")
     def test_srcdir(self):
         # See Issues #15322, #15364.
         srcdir = sysconfig.get_config_var('srcdir')
@@ -460,11 +539,15 @@ def test_srcdir(self):
             # should be a full source checkout.
             Python_h = os.path.join(srcdir, 'Include', 'Python.h')
             self.assertTrue(os.path.exists(Python_h), Python_h)
-            # <srcdir>/PC/pyconfig.h always exists even if unused on POSIX.
-            pyconfig_h = os.path.join(srcdir, 'PC', 'pyconfig.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')
+                self.assertTrue(os.path.exists(pyconfig_h), pyconfig_h)
         elif os.name == 'posix':
             makefile_dir = os.path.dirname(sysconfig.get_makefile_filename())
             # Issue #19340: srcdir has been realpath'ed already
@@ -479,23 +562,16 @@ def test_srcdir_independent_of_cwd(self):
             srcdir2 = sysconfig.get_config_var('srcdir')
         self.assertEqual(srcdir, srcdir2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sysconfig.get_config_var('EXT_SUFFIX') is None,
                      'EXT_SUFFIX required for this test')
+    @unittest.skipIf(not _imp.extension_suffixes(), "stub loader has no suffixes")
     def test_EXT_SUFFIX_in_vars(self):
-        import _imp
-        if not _imp.extension_suffixes():
-            self.skipTest("stub loader has no suffixes")
         vars = sysconfig.get_config_vars()
         self.assertEqual(vars['EXT_SUFFIX'], _imp.extension_suffixes()[0])
 
-    @unittest.skipUnless(sys.platform == 'linux' and
-                         hasattr(sys.implementation, '_multiarch'),
-                         'multiarch-specific test')
-    def test_triplet_in_ext_suffix(self):
+    @unittest.skipUnless(sys.platform == 'linux', 'Linux-specific test')
+    def test_linux_ext_suffix(self):
         ctypes = import_module('ctypes')
-        import platform, re
         machine = platform.machine()
         suffix = sysconfig.get_config_var('EXT_SUFFIX')
         if re.match('(aarch64|arm|mips|ppc|powerpc|s390|sparc)', machine):
@@ -508,20 +584,102 @@ def test_triplet_in_ext_suffix(self):
             self.assertTrue(suffix.endswith(expected_suffixes),
                             f'unexpected suffix {suffix!r}')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipUnless(sys.platform == 'android', 'Android-specific test')
+    def test_android_ext_suffix(self):
+        machine = platform.machine()
+        suffix = sysconfig.get_config_var('EXT_SUFFIX')
+        expected_triplet = {
+            "x86_64": "x86_64-linux-android",
+            "i686": "i686-linux-android",
+            "aarch64": "aarch64-linux-android",
+            "armv7l": "arm-linux-androideabi",
+        }[machine]
+        self.assertTrue(suffix.endswith(f"-{expected_triplet}.so"),
+                        f"{machine=}, {suffix=}")
+
     @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)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @requires_subprocess()
+    def test_config_vars_depend_on_site_initialization(self):
+        script = textwrap.dedent("""
+            import sysconfig
+
+            config_vars = sysconfig.get_config_vars()
+
+            import json
+            print(json.dumps(config_vars, indent=2))
+        """)
+
+        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
+
+            before = sysconfig.get_config_vars()
+
+            import site
+            site.main()
+
+            after = sysconfig.get_config_vars()
+
+            import json
+            print(json.dumps({'before': before, 'after': after}, indent=2))
+        """)
+
+        with self.venv() as venv:
+            config_vars = json.loads(venv.run('-S', '-c', script).stdout)
+
+        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
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @requires_subprocess()
+    def test_paths_depend_on_site_initialization(self):
+        script = textwrap.dedent("""
+            import sysconfig
+
+            paths = sysconfig.get_paths()
+
+            import json
+            print(json.dumps(paths, indent=2))
+        """)
+
+        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)
+
+        self.assertNotEqual(site_paths, no_site_paths)
+
+
 class MakefileTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @unittest.skipIf(sys.platform.startswith('win'),
                      'Test is not Windows compatible')
     @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")
     def test_get_makefile_filename(self):
         makefile = sysconfig.get_makefile_filename()
         self.assertTrue(os.path.isfile(makefile), makefile)
@@ -536,7 +694,7 @@ def test_parse_makefile(self):
             print("var5=dollar$$5", file=makefile)
             print("var6=${var3}/lib/python3.5/config-$(VAR2)$(var5)"
                   "-x86_64-linux-gnu", file=makefile)
-        vars = sysconfig._parse_makefile(TESTFN)
+        vars = _parse_makefile(TESTFN)
         self.assertEqual(vars, {
             'var1': 'ab42',
             'VAR2': 'b42',
@@ -547,5 +705,26 @@ def test_parse_makefile(self):
         })
 
 
+class DeprecationTests(unittest.TestCase):
+    def deprecated(self, removal_version, deprecation_msg=None, error=Exception, error_msg=None):
+        if sys.version_info >= removal_version:
+            return self.assertRaises(error, msg=error_msg)
+        else:
+            return self.assertWarns(DeprecationWarning, msg=deprecation_msg)
+
+    def test_is_python_build_check_home(self):
+        with self.deprecated(
+            removal_version=(3, 15),
+            deprecation_msg=(
+                'The check_home argument of sysconfig.is_python_build is '
+                'deprecated and its value is ignored. '
+                'It will be removed in Python 3.15.'
+            ),
+            error=TypeError,
+            error_msg="is_python_build() takes 0 positional arguments but 1 were given",
+        ):
+            sysconfig.is_python_build('foo')
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_tabnanny.py b/Lib/test/test_tabnanny.py
index 74d3a71a35..aa71166a38 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  # XXX: RUSTPYTHON
+import unittest # TODO: RUSTPYTHON
 
 
 SOURCE_CODES = {
@@ -112,9 +112,10 @@ def test_errprint(self):
 
         for args, expected in tests:
             with self.subTest(arguments=args, expected=expected):
-                with captured_stderr() as stderr:
-                    tabnanny.errprint(*args)
-                self.assertEqual(stderr.getvalue() , expected)
+                with self.assertRaises(SystemExit):
+                    with captured_stderr() as stderr:
+                        tabnanny.errprint(*args)
+                    self.assertEqual(stderr.getvalue() , expected)
 
 
 class TestNannyNag(TestCase):
@@ -199,23 +200,25 @@ def test_correct_directory(self):
             with TemporaryPyFile(SOURCE_CODES["error_free"], directory=tmp_dir):
                 self.verify_tabnanny_check(tmp_dir)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_when_wrong_indented(self):
         """A python source code file eligible for raising `IndentationError`."""
         with TemporaryPyFile(SOURCE_CODES["wrong_indented"]) as file_path:
             err = ('unindent does not match any outer indentation level'
                 ' (<tokenize>, line 3)\n')
             err = f"{file_path!r}: Indentation Error: {err}"
-            self.verify_tabnanny_check(file_path, err=err)
+            with self.assertRaises(SystemExit):
+                self.verify_tabnanny_check(file_path, err=err)
 
     def test_when_tokenize_tokenerror(self):
         """A python source code file eligible for raising 'tokenize.TokenError'."""
         with TemporaryPyFile(SOURCE_CODES["incomplete_expression"]) as file_path:
             err = "('EOF in multi-line statement', (7, 0))\n"
             err = f"{file_path!r}: Token Error: {err}"
-            self.verify_tabnanny_check(file_path, err=err)
+            with self.assertRaises(SystemExit):
+                self.verify_tabnanny_check(file_path, err=err)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_when_nannynag_error_verbose(self):
         """A python source code file eligible for raising `tabnanny.NannyNag`.
 
@@ -223,29 +226,28 @@ def test_when_nannynag_error_verbose(self):
         """
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as file_path:
             out = f"{file_path!r}: *** Line 3: trouble in tab city! ***\n"
-            out += "offending line: '\\tprint(\"world\")\\n'\n"
-            out += "indent not equal e.g. at tab size 1\n"
+            out += "offending line: '\\tprint(\"world\")'\n"
+            out += "inconsistent use of tabs and spaces in indentation\n"
 
             tabnanny.verbose = 1
             self.verify_tabnanny_check(file_path, out=out)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     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:
-            out = f"{file_path} 3 '\\tprint(\"world\")\\n'\n"
+            out = f"{file_path} 3 '\\tprint(\"world\")'\n"
             self.verify_tabnanny_check(file_path, out=out)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_when_no_file(self):
         """A python file which does not exist actually in system."""
         path = 'no_file.py'
         err = (f"{path!r}: I/O Error: [Errno {errno.ENOENT}] "
               f"{os.strerror(errno.ENOENT)}: {path!r}\n")
-        self.verify_tabnanny_check(path, err=err)
+        with self.assertRaises(SystemExit):
+            self.verify_tabnanny_check(path, err=err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_errored_directory(self):
         """Directory containing wrongly indented python source code files."""
         with tempfile.TemporaryDirectory() as tmp_dir:
@@ -259,7 +261,8 @@ def test_errored_directory(self):
                 err = ('unindent does not match any outer indentation level'
                             ' (<tokenize>, line 3)\n')
                 err = f"{e_file!r}: Indentation Error: {err}"
-                self.verify_tabnanny_check(tmp_dir, err=err)
+                with self.assertRaises(SystemExit):
+                    self.verify_tabnanny_check(tmp_dir, err=err)
 
 
 class TestProcessTokens(TestCase):
@@ -295,9 +298,12 @@ def test_with_errored_codes_samples(self):
 class TestCommandLine(TestCase):
     """Tests command line interface of `tabnanny`."""
 
-    def validate_cmd(self, *args, stdout="", stderr="", partial=False):
+    def validate_cmd(self, *args, stdout="", stderr="", partial=False, expect_failure=False):
         """Common function to assert the behaviour of command line interface."""
-        _, out, err = script_helper.assert_python_ok('-m', 'tabnanny', *args)
+        if expect_failure:
+            _, out, err = script_helper.assert_python_failure('-m', 'tabnanny', *args)
+        else:
+            _, out, err = script_helper.assert_python_ok('-m', 'tabnanny', *args)
         # Note: The `splitlines()` will solve the problem of CRLF(\r) added
         # by OS Windows.
         out = os.fsdecode(out)
@@ -319,8 +325,8 @@ def test_with_errored_file(self):
         with TemporaryPyFile(SOURCE_CODES["wrong_indented"]) as file_path:
             stderr  = f"{file_path!r}: Indentation Error: "
             stderr += ('unindent does not match any outer indentation level'
-                    ' (<tokenize>, line 3)')
-            self.validate_cmd(file_path, stderr=stderr)
+                       ' (<string>, line 3)')
+            self.validate_cmd(file_path, stderr=stderr, expect_failure=True)
 
     def test_with_error_free_file(self):
         """Should not display anything if python file is correctly indented."""
@@ -331,7 +337,7 @@ def test_command_usage(self):
         """Should display usage on no arguments."""
         path = findfile('tabnanny.py')
         stderr = f"Usage: {path} [-v] file_or_directory ..."
-        self.validate_cmd(stderr=stderr)
+        self.validate_cmd(stderr=stderr, expect_failure=True)
 
     def test_quiet_flag(self):
         """Should display less when quite mode is on."""
@@ -339,18 +345,22 @@ def test_quiet_flag(self):
             stdout = f"{file_path}\n"
             self.validate_cmd("-q", file_path, stdout=stdout)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_verbose_mode(self):
         """Should display more error information if verbose mode is on."""
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
             stdout = textwrap.dedent(
-                "offending line: '\\tprint(\"world\")\\n'"
+                "offending line: '\\tprint(\"world\")'"
             ).strip()
             self.validate_cmd("-v", path, stdout=stdout, partial=True)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_double_verbose_mode(self):
         """Should display detailed error information if double verbose is on."""
         with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
             stdout = textwrap.dedent(
-                "offending line: '\\tprint(\"world\")\\n'"
+                "offending line: '\\tprint(\"world\")'"
             ).strip()
             self.validate_cmd("-vv", path, stdout=stdout, partial=True)
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index 0fed89c773..92ce7c32a0 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -258,8 +258,6 @@ class ListTest(ReadTest, unittest.TestCase):
     def setUp(self):
         self.tar = tarfile.open(self.tarname, mode=self.mode)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list(self):
         tio = io.TextIOWrapper(io.BytesIO(), 'ascii', newline='\n')
         with support.swap_attr(sys, 'stdout', tio):
@@ -297,8 +295,6 @@ def conv(b):
         self.assertNotIn(b'link to', out)
         self.assertNotIn(b'->', out)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_verbose(self):
         tio = io.TextIOWrapper(io.BytesIO(), 'ascii', newline='\n')
         with support.swap_attr(sys, 'stdout', tio):
@@ -323,8 +319,6 @@ def test_list_verbose(self):
         self.assertIn(b'pax' + (b'/123' * 125) + b'/longlink link to pax' +
                       (b'/123' * 125) + b'/longname', out)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_members(self):
         tio = io.TextIOWrapper(io.BytesIO(), 'ascii', newline='\n')
         def members(tar):
@@ -462,7 +456,6 @@ def test_premature_end_of_archive(self):
                 with self.assertRaisesRegex(tarfile.ReadError, "unexpected end of data"):
                     tar.extractfile(t).read()
 
-    @unittest.skip("TODO: RUSTPYTHON, infinite recursion")
     def test_length_zero_header(self):
         # bpo-39017 (CVE-2019-20907): reading a zero-length header should fail
         # with an exception
@@ -628,7 +621,6 @@ def test_extract_hardlink(self):
                 data = f.read()
             self.assertEqual(sha256sum(data), sha256_regtype)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_extractall(self):
         # Test if extractall() correctly restores directory permissions
         # and times (see issue1735).
@@ -659,7 +651,6 @@ def format_mtime(mtime):
             tar.close()
             os_helper.rmtree(DIR)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_extract_directory(self):
         dirtype = "ustar/dirtype"
         DIR = os.path.join(TEMPDIR, "extractdir")
@@ -675,7 +666,6 @@ def test_extract_directory(self):
         finally:
             os_helper.rmtree(DIR)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_extractall_pathlike_name(self):
         DIR = pathlib.Path(TEMPDIR) / "extractall"
         with os_helper.temp_dir(DIR), \
@@ -686,7 +676,6 @@ def test_extractall_pathlike_name(self):
                 path = DIR / tarinfo.name
                 self.assertEqual(os.path.getmtime(path), tarinfo.mtime)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_extract_pathlike_name(self):
         dirtype = "ustar/dirtype"
         DIR = pathlib.Path(TEMPDIR) / "extractall"
@@ -1060,19 +1049,15 @@ def _test_sparse_file(self, name):
             s = os.stat(filename)
             self.assertLess(s.st_blocks * 512, s.st_size)
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_old(self):
         self._test_sparse_file("gnu/sparse")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_00(self):
         self._test_sparse_file("gnu/sparse-0.0")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_01(self):
         self._test_sparse_file("gnu/sparse-0.1")
 
-    @unittest.expectedFailureIf(sys.platform == "linux", "TODO: RUSTPYTHON")
     def test_sparse_file_10(self):
         self._test_sparse_file("gnu/sparse-1.0")
 
@@ -1276,7 +1261,6 @@ def test_gettarinfo_pathlike_name(self):
             self.assertEqual(tarinfo.name, tarinfo2.name)
             self.assertEqual(tarinfo.size, 3)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @unittest.skipUnless(hasattr(os, "link"),
                          "Missing hardlink implementation")
     def test_link_size(self):
@@ -1301,7 +1285,6 @@ def test_link_size(self):
             os_helper.unlink(target)
             os_helper.unlink(link)
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     @os_helper.skip_unless_symlink
     def test_symlink_size(self):
         path = os.path.join(TEMPDIR, "symlink")
@@ -1849,7 +1832,6 @@ def test_add_twice(self):
         self.assertEqual(tarinfo.type, tarfile.REGTYPE,
                 "add file as regular failed")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def test_add_hardlink(self):
         tarinfo = self.tar.gettarinfo(self.bar)
         self.assertEqual(tarinfo.type, tarfile.LNKTYPE,
@@ -2511,8 +2493,6 @@ def test_test_command_invalid_file(self):
                 finally:
                     os_helper.unlink(tmpname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_command(self):
         for tar_name in testtarnames:
             with support.captured_stdout() as t:
@@ -2524,8 +2504,6 @@ def test_list_command(self):
                                       PYTHONIOENCODING='ascii')
                 self.assertEqual(out, expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_list_command_verbose(self):
         for tar_name in testtarnames:
             with support.captured_stdout() as t:
diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py
index 913897de40..d389529ca3 100644
--- a/Lib/test/test_tempfile.py
+++ b/Lib/test/test_tempfile.py
@@ -11,6 +11,9 @@
 import stat
 import types
 import weakref
+import gc
+import shutil
+import subprocess
 from unittest import mock
 
 import unittest
@@ -60,16 +63,10 @@ def test_infer_return_type_multiples_and_none(self):
             tempfile._infer_return_type(b'', None, '')
 
     def test_infer_return_type_pathlib(self):
-        self.assertIs(str, tempfile._infer_return_type(pathlib.Path('/')))
+        self.assertIs(str, tempfile._infer_return_type(os_helper.FakePath('/')))
 
     def test_infer_return_type_pathlike(self):
-        class Path:
-            def __init__(self, path):
-                self.path = path
-
-            def __fspath__(self):
-                return self.path
-
+        Path = os_helper.FakePath
         self.assertIs(str, tempfile._infer_return_type(Path('/')))
         self.assertIs(bytes, tempfile._infer_return_type(Path(b'/')))
         self.assertIs(str, tempfile._infer_return_type('', Path('')))
@@ -90,14 +87,10 @@ class BaseTestCase(unittest.TestCase):
     b_check = re.compile(br"^[a-z0-9_-]{8}$")
 
     def setUp(self):
-        self._warnings_manager = warnings_helper.check_warnings()
-        self._warnings_manager.__enter__()
+        self.enterContext(warnings_helper.check_warnings())
         warnings.filterwarnings("ignore", category=RuntimeWarning,
                                 message="mktemp", module=__name__)
 
-    def tearDown(self):
-        self._warnings_manager.__exit__(None, None, None)
-
     def nameCheck(self, name, dir, pre, suf):
         (ndir, nbase) = os.path.split(name)
         npre  = nbase[:len(pre)]
@@ -198,8 +191,7 @@ def supports_iter(self):
             if i == 20:
                 break
 
-    @unittest.skipUnless(hasattr(os, 'fork'),
-        "os.fork is required for this test")
+    @support.requires_fork()
     def test_process_awareness(self):
         # ensure that the random source differs between
         # child and parent.
@@ -290,19 +282,14 @@ def our_candidate_list():
                 def raise_OSError(*args, **kwargs):
                     raise OSError()
 
-                with support.swap_attr(io, "open", raise_OSError):
-                    # test again with failing io.open()
+                with support.swap_attr(os, "open", raise_OSError):
+                    # test again with failing os.open()
                     with self.assertRaises(FileNotFoundError):
                         tempfile._get_default_tempdir()
                     self.assertEqual(os.listdir(our_temp_directory), [])
 
-                def bad_writer(*args, **kwargs):
-                    fp = orig_open(*args, **kwargs)
-                    fp.write = raise_OSError
-                    return fp
-
-                with support.swap_attr(io, "open", bad_writer) as orig_open:
-                    # test again with failing write()
+                with support.swap_attr(os, "write", raise_OSError):
+                    # test again with failing os.write()
                     with self.assertRaises(FileNotFoundError):
                         tempfile._get_default_tempdir()
                     self.assertEqual(os.listdir(our_temp_directory), [])
@@ -342,6 +329,9 @@ def _mock_candidate_names(*names):
 
 class TestBadTempdir:
 
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot remove write bits."
+    )
     def test_read_only_directory(self):
         with _inside_empty_temp_dir():
             oldmode = mode = os.stat(tempfile.tempdir).st_mode
@@ -447,11 +437,12 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             self.do_create(dir=dir).write(b"blat")
-            self.do_create(dir=pathlib.Path(dir)).write(b"blat")
+            self.do_create(dir=os_helper.FakePath(dir)).write(b"blat")
         finally:
             support.gc_collect()  # For PyPy or other GCs.
             os.rmdir(dir)
 
+    @os_helper.skip_unless_working_chmod
     def test_file_mode(self):
         # _mkstemp_inner creates files with the proper mode
 
@@ -465,8 +456,8 @@ def test_file_mode(self):
             expected = user * (1 + 8 + 64)
         self.assertEqual(mode, expected)
 
-    @support.requires_fork()
     @unittest.skipUnless(has_spawnl, 'os.spawnl not available')
+    @support.requires_subprocess()
     def test_noinherit(self):
         # _mkstemp_inner file handles are not inherited by child processes
 
@@ -684,7 +675,7 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             self.do_create(dir=dir)
-            self.do_create(dir=pathlib.Path(dir))
+            self.do_create(dir=os_helper.FakePath(dir))
         finally:
             os.rmdir(dir)
 
@@ -785,10 +776,11 @@ def test_choose_directory(self):
         dir = tempfile.mkdtemp()
         try:
             os.rmdir(self.do_create(dir=dir))
-            os.rmdir(self.do_create(dir=pathlib.Path(dir)))
+            os.rmdir(self.do_create(dir=os_helper.FakePath(dir)))
         finally:
             os.rmdir(dir)
 
+    @os_helper.skip_unless_working_chmod
     def test_mode(self):
         # mkdtemp creates directories with the proper mode
 
@@ -806,6 +798,33 @@ def test_mode(self):
         finally:
             os.rmdir(dir)
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_mode_win32(self):
+        # Use icacls.exe to extract the users with some level of access
+        # Main thing we are testing is that the BUILTIN\Users group has
+        # no access. The exact ACL is going to vary based on which user
+        # is running the test.
+        dir = self.do_create()
+        try:
+            out = subprocess.check_output(["icacls.exe", dir], encoding="oem").casefold()
+        finally:
+            os.rmdir(dir)
+
+        dir = dir.casefold()
+        users = set()
+        found_user = False
+        for line in out.strip().splitlines():
+            acl = None
+            # First line of result includes our directory
+            if line.startswith(dir):
+                acl = line.removeprefix(dir).strip()
+            elif line and line[:1].isspace():
+                acl = line.strip()
+            if acl:
+                users.add(acl.partition(":")[0])
+
+        self.assertNotIn(r"BUILTIN\Users".casefold(), users)
+
     def test_collision_with_existing_file(self):
         # mkdtemp tries another name when a file with
         # the chosen name already exists
@@ -853,6 +872,15 @@ def test_for_tempdir_is_bytes_issue40701_api_warts(self):
         finally:
             tempfile.tempdir = orig_tempdir
 
+    def test_path_is_absolute(self):
+        # Test that the path returned by mkdtemp with a relative `dir`
+        # argument is absolute
+        try:
+            path = tempfile.mkdtemp(dir=".")
+            self.assertTrue(os.path.isabs(path))
+        finally:
+            os.rmdir(path)
+
 
 class TestMktemp(BaseTestCase):
     """Test mktemp()."""
@@ -978,6 +1006,7 @@ def test_del_on_close(self):
         try:
             with tempfile.NamedTemporaryFile(dir=dir) as f:
                 f.write(b'blat')
+            self.assertEqual(os.listdir(dir), [])
             self.assertFalse(os.path.exists(f.name),
                         "NamedTemporaryFile %s exists after close" % f.name)
         finally:
@@ -1017,18 +1046,101 @@ def use_closed():
                 pass
         self.assertRaises(ValueError, use_closed)
 
-    def test_no_leak_fd(self):
-        # Issue #21058: don't leak file descriptor when io.open() fails
-        closed = []
-        os_close = os.close
-        def close(fd):
-            closed.append(fd)
-            os_close(fd)
+    def test_context_man_not_del_on_close_if_delete_on_close_false(self):
+        # Issue gh-58451: tempfile.NamedTemporaryFile is not particularly useful
+        # on Windows
+        # A NamedTemporaryFile is NOT deleted when closed if
+        # delete_on_close=False, but is deleted on context manager exit
+        dir = tempfile.mkdtemp()
+        try:
+            with tempfile.NamedTemporaryFile(dir=dir,
+                                             delete=True,
+                                             delete_on_close=False) as f:
+                f.write(b'blat')
+                f_name = f.name
+                f.close()
+                with self.subTest():
+                    # Testing that file is not deleted on close
+                    self.assertTrue(os.path.exists(f.name),
+                            f"NamedTemporaryFile {f.name!r} is incorrectly "
+                            f"deleted on closure when delete_on_close=False")
+
+            with self.subTest():
+                # Testing that file is deleted on context manager exit
+                self.assertFalse(os.path.exists(f.name),
+                                 f"NamedTemporaryFile {f.name!r} exists "
+                                 f"after context manager exit")
+
+        finally:
+            os.rmdir(dir)
+
+    def test_context_man_ok_to_delete_manually(self):
+        # In the case of delete=True, a NamedTemporaryFile can be manually
+        # deleted in a with-statement context without causing an error.
+        dir = tempfile.mkdtemp()
+        try:
+            with tempfile.NamedTemporaryFile(dir=dir,
+                                             delete=True,
+                                             delete_on_close=False) as f:
+                f.write(b'blat')
+                f.close()
+                os.unlink(f.name)
+
+        finally:
+            os.rmdir(dir)
+
+    def test_context_man_not_del_if_delete_false(self):
+        # A NamedTemporaryFile is not deleted if delete = False
+        dir = tempfile.mkdtemp()
+        f_name = ""
+        try:
+            # Test that delete_on_close=True has no effect if delete=False.
+            with tempfile.NamedTemporaryFile(dir=dir, delete=False,
+                                             delete_on_close=True) as f:
+                f.write(b'blat')
+                f_name = f.name
+            self.assertTrue(os.path.exists(f.name),
+                        f"NamedTemporaryFile {f.name!r} exists after close")
+        finally:
+            os.unlink(f_name)
+            os.rmdir(dir)
+
+    def test_del_by_finalizer(self):
+        # A NamedTemporaryFile is deleted when finalized in the case of
+        # delete=True, delete_on_close=False, and no with-statement is used.
+        def my_func(dir):
+            f = tempfile.NamedTemporaryFile(dir=dir, delete=True,
+                                            delete_on_close=False)
+            tmp_name = f.name
+            f.write(b'blat')
+            # Testing extreme case, where the file is not explicitly closed
+            # f.close()
+            return tmp_name
+        # Make sure that the garbage collector has finalized the file object.
+        gc.collect()
+        dir = tempfile.mkdtemp()
+        try:
+            tmp_name = my_func(dir)
+            self.assertFalse(os.path.exists(tmp_name),
+                        f"NamedTemporaryFile {tmp_name!r} "
+                        f"exists after finalizer ")
+        finally:
+            os.rmdir(dir)
 
-        with mock.patch('os.close', side_effect=close):
-            with mock.patch('io.open', side_effect=ValueError):
-                self.assertRaises(ValueError, tempfile.NamedTemporaryFile)
-                self.assertEqual(len(closed), 1)
+    def test_correct_finalizer_work_if_already_deleted(self):
+        # There should be no error in the case of delete=True,
+        # delete_on_close=False, no with-statement is used, and the file is
+        # deleted manually.
+        def my_func(dir)->str:
+            f = tempfile.NamedTemporaryFile(dir=dir, delete=True,
+                                            delete_on_close=False)
+            tmp_name = f.name
+            f.write(b'blat')
+            f.close()
+            os.unlink(tmp_name)
+            return tmp_name
+        # Make sure that the garbage collector has finalized the file object.
+        gc.collect()
 
     def test_bad_mode(self):
         dir = tempfile.mkdtemp()
@@ -1039,6 +1151,24 @@ def test_bad_mode(self):
             tempfile.NamedTemporaryFile(mode=2, dir=dir)
         self.assertEqual(os.listdir(dir), [])
 
+    def test_bad_encoding(self):
+        dir = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, dir)
+        with self.assertRaises(LookupError):
+            tempfile.NamedTemporaryFile('w', encoding='bad-encoding', dir=dir)
+        self.assertEqual(os.listdir(dir), [])
+
+    def test_unexpected_error(self):
+        dir = tempfile.mkdtemp()
+        self.addCleanup(os_helper.rmtree, dir)
+        with mock.patch('tempfile._TemporaryFileWrapper') as mock_ntf, \
+             mock.patch('io.open', mock.mock_open()) as mock_open:
+            mock_ntf.side_effect = KeyboardInterrupt()
+            with self.assertRaises(KeyboardInterrupt):
+                tempfile.NamedTemporaryFile(dir=dir)
+        mock_open().close.assert_called()
+        self.assertEqual(os.listdir(dir), [])
+
     # How to test the mode and bufsize parameters?
 
 class TestSpooledTemporaryFile(BaseTestCase):
@@ -1059,6 +1189,31 @@ def test_basic(self):
         f = self.do_create(max_size=100, pre="a", suf=".txt")
         self.assertFalse(f._rolled)
 
+    def test_is_iobase(self):
+        # SpooledTemporaryFile should implement io.IOBase
+        self.assertIsInstance(self.do_create(), io.IOBase)
+
+    def test_iobase_interface(self):
+        # SpooledTemporaryFile should implement the io.IOBase interface.
+        # Ensure it has all the required methods and properties.
+        iobase_attrs = {
+            # From IOBase
+            'fileno', 'seek', 'truncate', 'close', 'closed', '__enter__',
+            '__exit__', 'flush', 'isatty', '__iter__', '__next__', 'readable',
+            'readline', 'readlines', 'seekable', 'tell', 'writable',
+            'writelines',
+            # From BufferedIOBase (binary mode) and TextIOBase (text mode)
+            'detach', 'read', 'read1', 'write', 'readinto', 'readinto1',
+            'encoding', 'errors', 'newlines',
+        }
+        spooledtempfile_attrs = set(dir(tempfile.SpooledTemporaryFile))
+        missing_attrs = iobase_attrs - spooledtempfile_attrs
+        self.assertFalse(
+            missing_attrs,
+            'SpooledTemporaryFile missing attributes from '
+            'IOBase/BufferedIOBase/TextIOBase'
+        )
+
     def test_del_on_close(self):
         # A SpooledTemporaryFile is deleted when closed
         dir = tempfile.mkdtemp()
@@ -1069,11 +1224,40 @@ def test_del_on_close(self):
             self.assertTrue(f._rolled)
             filename = f.name
             f.close()
-            self.assertFalse(isinstance(filename, str) and os.path.exists(filename),
-                        "SpooledTemporaryFile %s exists after close" % filename)
+            self.assertEqual(os.listdir(dir), [])
+            if not isinstance(filename, int):
+                self.assertFalse(os.path.exists(filename),
+                    "SpooledTemporaryFile %s exists after close" % filename)
         finally:
             os.rmdir(dir)
 
+    def test_del_unrolled_file(self):
+        # The unrolled SpooledTemporaryFile should raise a ResourceWarning
+        # when deleted since the file was not explicitly closed.
+        f = self.do_create(max_size=10)
+        f.write(b'foo')
+        self.assertEqual(f.name, None)  # Unrolled so no filename/fd
+        with self.assertWarns(ResourceWarning):
+            f.__del__()
+
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot fstat renamed files."
+    )
+    def test_del_rolled_file(self):
+        # The rolled file should be deleted when the SpooledTemporaryFile
+        # object is deleted. This should raise a ResourceWarning since the file
+        # was not explicitly closed.
+        f = self.do_create(max_size=2)
+        f.write(b'foo')
+        name = f.name  # This is a fd on posix+cygwin, a filename everywhere else
+        self.assertTrue(os.path.exists(name))
+        with self.assertWarns(ResourceWarning):
+            f.__del__()
+        self.assertFalse(
+            os.path.exists(name),
+            "Rolled SpooledTemporaryFile (name=%s) exists after delete" % name
+        )
+
     def test_rewrite_small(self):
         # A SpooledTemporaryFile can be written to multiple within the max_size
         f = self.do_create(max_size=30)
@@ -1104,6 +1288,34 @@ def test_writelines(self):
         buf = f.read()
         self.assertEqual(buf, b'xyz')
 
+    def test_writelines_rollover(self):
+        # Verify writelines rolls over before exhausting the iterator
+        f = self.do_create(max_size=2)
+
+        def it():
+            yield b'xy'
+            self.assertFalse(f._rolled)
+            yield b'z'
+            self.assertTrue(f._rolled)
+
+        f.writelines(it())
+        pos = f.seek(0)
+        self.assertEqual(pos, 0)
+        buf = f.read()
+        self.assertEqual(buf, b'xyz')
+
+    def test_writelines_fast_path(self):
+        f = self.do_create(max_size=2)
+        f.write(b'abc')
+        self.assertTrue(f._rolled)
+
+        f.writelines([b'd', b'e', b'f'])
+        pos = f.seek(0)
+        self.assertEqual(pos, 0)
+        buf = f.read()
+        self.assertEqual(buf, b'abcdef')
+
+
     def test_writelines_sequential(self):
         # A SpooledTemporaryFile should hold exactly max_size bytes, and roll
         # over afterward
@@ -1187,8 +1399,6 @@ def test_properties(self):
         with self.assertRaises(AttributeError):
             f.errors
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_text_mode(self):
         # Creating a SpooledTemporaryFile with a text mode should produce
         # a file object reading and writing (Unicode) text strings.
@@ -1221,8 +1431,6 @@ def test_text_mode(self):
         self.assertEqual(f.encoding, "utf-8")
         self.assertEqual(f.errors, "strict")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_text_newline_and_encoding(self):
         f = tempfile.SpooledTemporaryFile(mode='w+', max_size=10,
                                           newline='', encoding='utf-8',
@@ -1288,6 +1496,9 @@ def use_closed():
                 pass
         self.assertRaises(ValueError, use_closed)
 
+    @unittest.skipIf(
+        support.is_emscripten, "Emscripten cannot fstat renamed files."
+    )
     def test_truncate_with_size_parameter(self):
         # A SpooledTemporaryFile can be truncated to zero size
         f = tempfile.SpooledTemporaryFile(max_size=10)
@@ -1361,19 +1572,34 @@ def roundtrip(input, *args, **kwargs):
             roundtrip("\u039B", "w+", encoding="utf-16")
             roundtrip("foo\r\n", "w+", newline="")
 
-        def test_no_leak_fd(self):
-            # Issue #21058: don't leak file descriptor when io.open() fails
-            closed = []
-            os_close = os.close
-            def close(fd):
-                closed.append(fd)
-                os_close(fd)
-
-            with mock.patch('os.close', side_effect=close):
-                with mock.patch('io.open', side_effect=ValueError):
-                    self.assertRaises(ValueError, tempfile.TemporaryFile)
-                    self.assertEqual(len(closed), 1)
+        def test_bad_mode(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with self.assertRaises(ValueError):
+                tempfile.TemporaryFile(mode='wr', dir=dir)
+            with self.assertRaises(TypeError):
+                tempfile.TemporaryFile(mode=2, dir=dir)
+            self.assertEqual(os.listdir(dir), [])
+
+        def test_bad_encoding(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with self.assertRaises(LookupError):
+                tempfile.TemporaryFile('w', encoding='bad-encoding', dir=dir)
+            self.assertEqual(os.listdir(dir), [])
 
+        def test_unexpected_error(self):
+            dir = tempfile.mkdtemp()
+            self.addCleanup(os_helper.rmtree, dir)
+            with mock.patch('tempfile._O_TMPFILE_WORKS', False), \
+                 mock.patch('os.unlink') as mock_unlink, \
+                 mock.patch('os.open') as mock_open, \
+                 mock.patch('os.close') as mock_close:
+                mock_unlink.side_effect = KeyboardInterrupt()
+                with self.assertRaises(KeyboardInterrupt):
+                    tempfile.TemporaryFile(dir=dir)
+            mock_close.assert_called()
+            self.assertEqual(os.listdir(dir), [])
 
 
 # Helper for test_del_on_shutdown
@@ -1441,7 +1667,7 @@ def test_explicit_cleanup(self):
         finally:
             os.rmdir(dir)
 
-    def test_explict_cleanup_ignore_errors(self):
+    def test_explicit_cleanup_ignore_errors(self):
         """Test that cleanup doesn't return an error when ignoring them."""
         with tempfile.TemporaryDirectory() as working_dir:
             temp_dir = self.do_create(
@@ -1465,6 +1691,28 @@ def test_explict_cleanup_ignore_errors(self):
                 temp_path.exists(),
                 f"TemporaryDirectory {temp_path!s} exists after cleanup")
 
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_explicit_cleanup_correct_error(self):
+        with tempfile.TemporaryDirectory() as working_dir:
+            temp_dir = self.do_create(dir=working_dir)
+            with open(os.path.join(temp_dir.name, "example.txt"), 'wb'):
+                # Previously raised NotADirectoryError on some OSes
+                # (e.g. Windows). See bpo-43153.
+                with self.assertRaises(PermissionError):
+                    temp_dir.cleanup()
+
+    @unittest.skipUnless(os.name == "nt", "Only on Windows.")
+    def test_cleanup_with_used_directory(self):
+        with tempfile.TemporaryDirectory() as working_dir:
+            temp_dir = self.do_create(dir=working_dir)
+            subdir = os.path.join(temp_dir.name, "subdir")
+            os.mkdir(subdir)
+            with os_helper.change_cwd(subdir):
+                # Previously raised RecursionError on some OSes
+                # (e.g. Windows). See bpo-35144.
+                with self.assertRaises(PermissionError):
+                    temp_dir.cleanup()
+
     @os_helper.skip_unless_symlink
     def test_cleanup_with_symlink_to_a_directory(self):
         # cleanup() should not follow symlinks to directories (issue #12464)
@@ -1486,6 +1734,104 @@ def test_cleanup_with_symlink_to_a_directory(self):
                          "were deleted")
         d2.cleanup()
 
+    @os_helper.skip_unless_symlink
+    @unittest.skip('TODO: RUSTPYTHON; No such file or directory "..."')
+    def test_cleanup_with_symlink_modes(self):
+        # cleanup() should not follow symlinks when fixing mode bits (#91133)
+        with self.do_create(recurse=0) as d2:
+            file1 = os.path.join(d2, 'file1')
+            open(file1, 'wb').close()
+            dir1 = os.path.join(d2, 'dir1')
+            os.mkdir(dir1)
+            for mode in range(8):
+                mode <<= 6
+                with self.subTest(mode=format(mode, '03o')):
+                    def test(target, target_is_directory):
+                        d1 = self.do_create(recurse=0)
+                        symlink = os.path.join(d1.name, 'symlink')
+                        os.symlink(target, symlink,
+                                target_is_directory=target_is_directory)
+                        try:
+                            os.chmod(symlink, mode, follow_symlinks=False)
+                        except NotImplementedError:
+                            pass
+                        try:
+                            os.chmod(symlink, mode)
+                        except FileNotFoundError:
+                            pass
+                        os.chmod(d1.name, mode)
+                        d1.cleanup()
+                        self.assertFalse(os.path.exists(d1.name))
+
+                    with self.subTest('nonexisting file'):
+                        test('nonexisting', target_is_directory=False)
+                    with self.subTest('nonexisting dir'):
+                        test('nonexisting', target_is_directory=True)
+
+                    with self.subTest('existing file'):
+                        os.chmod(file1, mode)
+                        old_mode = os.stat(file1).st_mode
+                        test(file1, target_is_directory=False)
+                        new_mode = os.stat(file1).st_mode
+                        self.assertEqual(new_mode, old_mode,
+                                         '%03o != %03o' % (new_mode, old_mode))
+
+                    with self.subTest('existing dir'):
+                        os.chmod(dir1, mode)
+                        old_mode = os.stat(dir1).st_mode
+                        test(dir1, target_is_directory=True)
+                        new_mode = os.stat(dir1).st_mode
+                        self.assertEqual(new_mode, old_mode,
+                                         '%03o != %03o' % (new_mode, old_mode))
+
+    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.chflags')
+    @os_helper.skip_unless_symlink
+    def test_cleanup_with_symlink_flags(self):
+        # cleanup() should not follow symlinks when fixing flags (#91133)
+        flags = stat.UF_IMMUTABLE | stat.UF_NOUNLINK
+        self.check_flags(flags)
+
+        with self.do_create(recurse=0) as d2:
+            file1 = os.path.join(d2, 'file1')
+            open(file1, 'wb').close()
+            dir1 = os.path.join(d2, 'dir1')
+            os.mkdir(dir1)
+            def test(target, target_is_directory):
+                d1 = self.do_create(recurse=0)
+                symlink = os.path.join(d1.name, 'symlink')
+                os.symlink(target, symlink,
+                           target_is_directory=target_is_directory)
+                try:
+                    os.chflags(symlink, flags, follow_symlinks=False)
+                except NotImplementedError:
+                    pass
+                try:
+                    os.chflags(symlink, flags)
+                except FileNotFoundError:
+                    pass
+                os.chflags(d1.name, flags)
+                d1.cleanup()
+                self.assertFalse(os.path.exists(d1.name))
+
+            with self.subTest('nonexisting file'):
+                test('nonexisting', target_is_directory=False)
+            with self.subTest('nonexisting dir'):
+                test('nonexisting', target_is_directory=True)
+
+            with self.subTest('existing file'):
+                os.chflags(file1, flags)
+                old_flags = os.stat(file1).st_flags
+                test(file1, target_is_directory=False)
+                new_flags = os.stat(file1).st_flags
+                self.assertEqual(new_flags, old_flags)
+
+            with self.subTest('existing dir'):
+                os.chflags(dir1, flags)
+                old_flags = os.stat(dir1).st_flags
+                test(dir1, target_is_directory=True)
+                new_flags = os.stat(dir1).st_flags
+                self.assertEqual(new_flags, old_flags)
+
     @support.cpython_only
     def test_del_on_collection(self):
         # A TemporaryDirectory is deleted when garbage collected
@@ -1658,9 +2004,27 @@ def test_modes(self):
                     d.cleanup()
                 self.assertFalse(os.path.exists(d.name))
 
-    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.lchflags')
+    def check_flags(self, flags):
+        # skip the test if these flags are not supported (ex: FreeBSD 13)
+        filename = os_helper.TESTFN
+        try:
+            open(filename, "w").close()
+            try:
+                os.chflags(filename, flags)
+            except OSError as exc:
+                # "OSError: [Errno 45] Operation not supported"
+                self.skipTest(f"chflags() doesn't support flags "
+                              f"{flags:#b}: {exc}")
+            else:
+                os.chflags(filename, 0)
+        finally:
+            os_helper.unlink(filename)
+
+    @unittest.skipUnless(hasattr(os, 'chflags'), 'requires os.chflags')
     def test_flags(self):
         flags = stat.UF_IMMUTABLE | stat.UF_NOUNLINK
+        self.check_flags(flags)
+
         d = self.do_create(recurse=3, dirs=2, files=2)
         with d:
             # Change files and directories flags recursively.
@@ -1671,6 +2035,11 @@ def test_flags(self):
             d.cleanup()
         self.assertFalse(os.path.exists(d.name))
 
+    def test_delete_false(self):
+        with tempfile.TemporaryDirectory(delete=False) as working_dir:
+            pass
+        self.assertTrue(os.path.exists(working_dir))
+        shutil.rmtree(working_dir)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_thread.py b/Lib/test/test_thread.py
index f55cf3656e..4ae8a833b9 100644
--- a/Lib/test/test_thread.py
+++ b/Lib/test/test_thread.py
@@ -105,7 +105,6 @@ def test_nt_and_posix_stack_size(self):
 
         thread.stack_size(0)
 
-    @unittest.skip("TODO: RUSTPYTHON, weakref destructors")
     def test__count(self):
         # Test the _count() function.
         orig = thread._count()
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 94f21d1c38..e635a6f973 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -3,10 +3,11 @@
 """
 
 import test.support
-from test.support import threading_helper
+from test.support import threading_helper, requires_subprocess, requires_gil_enabled
 from test.support import verbose, cpython_only, os_helper
 from test.support.import_helper import import_module
 from test.support.script_helper import assert_python_ok, assert_python_failure
+from test.support import force_not_colorized
 
 import random
 import sys
@@ -20,11 +21,18 @@
 import signal
 import textwrap
 import traceback
+import warnings
 
 from unittest import mock
 from test import lock_tests
 from test import support
 
+try:
+    from test.support import interpreters
+except ImportError:
+    interpreters = None
+
+threading_helper.requires_working_threading(module=True)
 
 # Between fork() and exec(), only async-safe functions are allowed (issues
 # #12316 and #11870), and fork() from a worker thread is known to trigger
@@ -32,8 +40,23 @@
 # on platforms known to behave badly.
 platforms_to_skip = ('netbsd5', 'hp-ux11')
 
-# Is Python built with Py_DEBUG macro defined?
-Py_DEBUG = hasattr(sys, 'gettotalrefcount')
+
+def skip_unless_reliable_fork(test):
+    if not support.has_fork_support:
+        return unittest.skip("requires working os.fork()")(test)
+    if sys.platform in platforms_to_skip:
+        return unittest.skip("due to known OS bug related to thread+fork")(test)
+    if support.HAVE_ASAN_FORK_BUG:
+        return unittest.skip("libasan has a pthread_create() dead lock related to thread+fork")(test)
+    if support.check_sanitizer(thread=True):
+        return unittest.skip("TSAN doesn't support threads after fork")(test)
+    return test
+
+
+def requires_subinterpreters(meth):
+    """Decorator to skip a test if subinterpreters are not supported."""
+    return unittest.skipIf(interpreters is None,
+                           'subinterpreters required')(meth)
 
 
 def restore_default_excepthook(testcase):
@@ -95,6 +118,7 @@ def tearDown(self):
 
 
 class ThreadTests(BaseTestCase):
+    maxDiff = 9999
 
     @cpython_only
     def test_name(self):
@@ -123,11 +147,48 @@ def func(): pass
             thread = threading.Thread(target=func)
             self.assertEqual(thread.name, "Thread-5 (func)")
 
-    @cpython_only
-    def test_disallow_instantiation(self):
-        # Ensure that the type disallows instantiation (bpo-43916)
-        lock = threading.Lock()
-        test.support.check_disallow_instantiation(self, type(lock))
+    def test_args_argument(self):
+        # bpo-45735: Using list or tuple as *args* in constructor could
+        # achieve the same effect.
+        num_list = [1]
+        num_tuple = (1,)
+
+        str_list = ["str"]
+        str_tuple = ("str",)
+
+        list_in_tuple = ([1],)
+        tuple_in_list = [(1,)]
+
+        test_cases = (
+            (num_list, lambda arg: self.assertEqual(arg, 1)),
+            (num_tuple, lambda arg: self.assertEqual(arg, 1)),
+            (str_list, lambda arg: self.assertEqual(arg, "str")),
+            (str_tuple, lambda arg: self.assertEqual(arg, "str")),
+            (list_in_tuple, lambda arg: self.assertEqual(arg, [1])),
+            (tuple_in_list, lambda arg: self.assertEqual(arg, (1,)))
+        )
+
+        for args, target in test_cases:
+            with self.subTest(target=target, args=args):
+                t = threading.Thread(target=target, args=args)
+                t.start()
+                t.join()
+
+    def test_lock_no_args(self):
+        threading.Lock()  # works
+        self.assertRaises(TypeError, threading.Lock, 1)
+        self.assertRaises(TypeError, threading.Lock, a=1)
+        self.assertRaises(TypeError, threading.Lock, 1, 2, a=1, b=2)
+
+    def test_lock_no_subclass(self):
+        # Intentionally disallow subclasses of threading.Lock because they have
+        # never been allowed, so why start now just because the type is public?
+        with self.assertRaises(TypeError):
+            class MyLock(threading.Lock): pass
+
+    def test_lock_or_none(self):
+        import types
+        self.assertIsInstance(threading.Lock | None, types.UnionType)
 
     # Create a bunch of threads, let each do some work, wait until all are
     # done.
@@ -179,8 +240,6 @@ def f():
             tid = _thread.start_new_thread(f, ())
             done.wait()
             self.assertEqual(ident[0], tid)
-        # Kill the "immortal" _DummyThread
-        del threading._active[ident[0]]
 
     # run with a small(ish) thread stack size (256 KiB)
     def test_various_ops_small_stack(self):
@@ -208,11 +267,29 @@ def test_various_ops_large_stack(self):
 
     def test_foreign_thread(self):
         # Check that a "foreign" thread can use the threading module.
+        dummy_thread = None
+        error = None
         def f(mutex):
-            # Calling current_thread() forces an entry for the foreign
-            # thread to get made in the threading._active map.
-            threading.current_thread()
-            mutex.release()
+            try:
+                nonlocal dummy_thread
+                nonlocal error
+                # Calling current_thread() forces an entry for the foreign
+                # thread to get made in the threading._active map.
+                dummy_thread = threading.current_thread()
+                tid = dummy_thread.ident
+                self.assertIn(tid, threading._active)
+                self.assertIsInstance(dummy_thread, threading._DummyThread)
+                self.assertIs(threading._active.get(tid), dummy_thread)
+                # gh-29376
+                self.assertTrue(
+                    dummy_thread.is_alive(),
+                    'Expected _DummyThread to be considered alive.'
+                )
+                self.assertIn('_DummyThread', repr(dummy_thread))
+            except BaseException as e:
+                error = e
+            finally:
+                mutex.release()
 
         mutex = threading.Lock()
         mutex.acquire()
@@ -220,15 +297,29 @@ def f(mutex):
             tid = _thread.start_new_thread(f, (mutex,))
             # Wait for the thread to finish.
             mutex.acquire()
-        self.assertIn(tid, threading._active)
-        self.assertIsInstance(threading._active[tid], threading._DummyThread)
-        #Issue 29376
-        self.assertTrue(threading._active[tid].is_alive())
-        self.assertRegex(repr(threading._active[tid]), '_DummyThread')
-        del threading._active[tid]
+        if error is not None:
+            raise error
+        self.assertEqual(tid, dummy_thread.ident)
+        # Issue gh-106236:
+        with self.assertRaises(RuntimeError):
+            dummy_thread.join()
+        dummy_thread._started.clear()
+        with self.assertRaises(RuntimeError):
+            dummy_thread.is_alive()
+        # Busy wait for the following condition: after the thread dies, the
+        # related dummy thread must be removed from threading._active.
+        timeout = 5
+        timeout_at = time.monotonic() + timeout
+        while time.monotonic() < timeout_at:
+            if threading._active.get(dummy_thread.ident) is not dummy_thread:
+                break
+            time.sleep(.1)
+        else:
+            self.fail('It was expected that the created threading._DummyThread was removed from threading._active.')
 
     # PyThreadState_SetAsyncExc() is a CPython-only gimmick, not (currently)
     # exposed at the Python level.  This test relies on ctypes to get at it.
+    @cpython_only
     def test_PyThreadState_SetAsyncExc(self):
         ctypes = import_module("ctypes")
 
@@ -317,12 +408,13 @@ def run(self):
             t.join()
         # else the thread is still running, and we have no way to kill it
 
+    @unittest.skip('TODO: RUSTPYTHON; threading._start_new_thread not exposed')
     def test_limbo_cleanup(self):
         # Issue 7481: Failure to start thread should cleanup the limbo map.
-        def fail_new_thread(*args):
+        def fail_new_thread(*args, **kwargs):
             raise threading.ThreadError()
-        _start_new_thread = threading._start_new_thread
-        threading._start_new_thread = fail_new_thread
+        _start_joinable_thread = threading._start_joinable_thread
+        threading._start_joinable_thread = fail_new_thread
         try:
             t = threading.Thread(target=lambda: None)
             self.assertRaises(threading.ThreadError, t.start)
@@ -330,12 +422,17 @@ def fail_new_thread(*args):
                 t in threading._limbo,
                 "Failed to cleanup _limbo map on failure of Thread.start().")
         finally:
-            threading._start_new_thread = _start_new_thread
+            threading._start_joinable_thread = _start_joinable_thread
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; ctypes.pythonapi is not supported
     def test_finalize_running_thread(self):
         # Issue 1402: the PyGILState_Ensure / _Release functions may be called
         # very late on python exit: on deallocation of a running thread for
         # example.
+        if support.check_sanitizer(thread=True):
+            # the thread running `time.sleep(100)` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
         import_module("ctypes")
 
         rc, out, err = assert_python_failure("-c", """if 1:
@@ -368,6 +465,11 @@ def waitingThread():
     def test_finalize_with_trace(self):
         # Issue1733757
         # Avoid a deadlock when sys.settrace steps into threading._shutdown
+        if support.check_sanitizer(thread=True):
+            # the thread running `time.sleep(2)` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
+
         assert_python_ok("-c", """if 1:
             import sys, threading
 
@@ -390,8 +492,7 @@ def func(frame, event, arg):
             sys.settrace(func)
             """)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_join_nondaemon_on_shutdown(self):
         # Issue 1722344
         # Raising SystemExit skipped threading._shutdown
@@ -419,7 +520,7 @@ def test_enumerate_after_join(self):
         old_interval = sys.getswitchinterval()
         try:
             for i in range(1, 100):
-                sys.setswitchinterval(i * 0.0002)
+                support.setswitchinterval(i * 0.0002)
                 t = threading.Thread(target=lambda: None)
                 t.start()
                 t.join()
@@ -429,6 +530,48 @@ def test_enumerate_after_join(self):
         finally:
             sys.setswitchinterval(old_interval)
 
+    @support.bigmemtest(size=20, memuse=72*2**20, dry_run=False)
+    def test_join_from_multiple_threads(self, size):
+        # Thread.join() should be thread-safe
+        errors = []
+
+        def worker():
+            time.sleep(0.005)
+
+        def joiner(thread):
+            try:
+                thread.join()
+            except Exception as e:
+                errors.append(e)
+
+        for N in range(2, 20):
+            threads = [threading.Thread(target=worker)]
+            for i in range(N):
+                threads.append(threading.Thread(target=joiner,
+                                                args=(threads[0],)))
+            for t in threads:
+                t.start()
+            time.sleep(0.01)
+            for t in threads:
+                t.join()
+            if errors:
+                raise errors[0]
+
+    def test_join_with_timeout(self):
+        lock = _thread.allocate_lock()
+        lock.acquire()
+
+        def worker():
+            lock.acquire()
+
+        thread = threading.Thread(target=worker)
+        thread.start()
+        thread.join(timeout=0.01)
+        assert thread.is_alive()
+        lock.release()
+        thread.join()
+        assert not thread.is_alive()
+
     def test_no_refcycle_through_target(self):
         class RunSelfFunction(object):
             def __init__(self, should_raise):
@@ -507,41 +650,12 @@ def test_daemon_param(self):
         t = threading.Thread(daemon=True)
         self.assertTrue(t.daemon)
 
-    @unittest.skipUnless(hasattr(threading.Lock(), '_at_fork_reinit'), 'TODO: RUSTPYTHON, exit_handler needs lock._at_fork_reinit')
-    @unittest.skipUnless(hasattr(os, 'fork'), 'needs os.fork()')
-    def test_fork_at_exit(self):
-        # bpo-42350: Calling os.fork() after threading._shutdown() must
-        # not log an error.
-        code = textwrap.dedent("""
-            import atexit
-            import os
-            import sys
-            from test.support import wait_process
-
-            # Import the threading module to register its "at fork" callback
-            import threading
-
-            def exit_handler():
-                pid = os.fork()
-                if not pid:
-                    print("child process ok", file=sys.stderr, flush=True)
-                    # child process
-                else:
-                    wait_process(pid, exitcode=0)
-
-            # exit_handler() will be called after threading._shutdown()
-            atexit.register(exit_handler)
-        """)
-        _, out, err = assert_python_ok("-c", code)
-        self.assertEqual(out, b'')
-        self.assertEqual(err.rstrip(), b'child process ok')
-
-    @unittest.skipUnless(hasattr(os, 'fork'), 'test needs fork()')
+    @skip_unless_reliable_fork
     def test_dummy_thread_after_fork(self):
         # Issue #14308: a dummy thread in the active list doesn't mess up
         # the after-fork mechanism.
         code = """if 1:
-            import _thread, threading, os, time
+            import _thread, threading, os, time, warnings
 
             def background_thread(evt):
                 # Creates and registers the _DummyThread instance
@@ -553,18 +667,23 @@ def background_thread(evt):
             _thread.start_new_thread(background_thread, (evt,))
             evt.wait()
             assert threading.active_count() == 2, threading.active_count()
-            if os.fork() == 0:
-                assert threading.active_count() == 1, threading.active_count()
-                os._exit(0)
-            else:
-                os.wait()
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.filterwarnings(
+                        "always", category=DeprecationWarning)
+                if os.fork() == 0:
+                    assert threading.active_count() == 1, threading.active_count()
+                    os._exit(0)
+                else:
+                    assert ws[0].category == DeprecationWarning, ws[0]
+                    assert 'fork' in str(ws[0].message), ws[0]
+                    os.wait()
         """
         _, out, err = assert_python_ok("-c", code)
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
-    @unittest.skipUnless(hasattr(sys, 'getswitchinterval'), "TODO: RUSTPYTHON, needs sys.getswitchinterval()")
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @unittest.skip('TODO: RUSTPYTHON; flaky')
+    @skip_unless_reliable_fork
     def test_is_alive_after_fork(self):
         # Try hard to trigger #18418: is_alive() could sometimes be True on
         # threads that vanished after a fork.
@@ -577,13 +696,15 @@ def test_is_alive_after_fork(self):
         for i in range(20):
             t = threading.Thread(target=lambda: None)
             t.start()
-            pid = os.fork()
-            if pid == 0:
-                os._exit(11 if t.is_alive() else 10)
-            else:
-                t.join()
+            # Ignore the warning about fork with threads.
+            with warnings.catch_warnings(category=DeprecationWarning,
+                                         action="ignore"):
+                if (pid := os.fork()) == 0:
+                    os._exit(11 if t.is_alive() else 10)
+                else:
+                    t.join()
 
-                support.wait_process(pid, exitcode=10)
+                    support.wait_process(pid, exitcode=10)
 
     def test_main_thread(self):
         main = threading.main_thread()
@@ -598,48 +719,59 @@ def f():
         th.start()
         th.join()
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+    @skip_unless_reliable_fork
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
     def test_main_thread_after_fork(self):
         code = """if 1:
             import os, threading
             from test import support
 
+            ident = threading.get_ident()
             pid = os.fork()
             if pid == 0:
+                print("current ident", threading.get_ident() == ident)
                 main = threading.main_thread()
-                print(main.name)
-                print(main.ident == threading.current_thread().ident)
-                print(main.ident == threading.get_ident())
+                print("main", main.name)
+                print("main ident", main.ident == ident)
+                print("current is main", threading.current_thread() is main)
             else:
                 support.wait_process(pid, exitcode=0)
         """
         _, out, err = assert_python_ok("-c", code)
         data = out.decode().replace('\r', '')
         self.assertEqual(err, b"")
-        self.assertEqual(data, "MainThread\nTrue\nTrue\n")
+        self.assertEqual(data,
+                         "current ident True\n"
+                         "main MainThread\n"
+                         "main ident True\n"
+                         "current is main True\n")
 
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+    @skip_unless_reliable_fork
     @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
-    @unittest.skipIf(os.name != 'posix', "test needs POSIX semantics")
     def test_main_thread_after_fork_from_nonmain_thread(self):
         code = """if 1:
-            import os, threading, sys
+            import os, threading, sys, warnings
             from test import support
 
             def func():
-                pid = os.fork()
-                if pid == 0:
-                    main = threading.main_thread()
-                    print(main.name)
-                    print(main.ident == threading.current_thread().ident)
-                    print(main.ident == threading.get_ident())
-                    # stdout is fully buffered because not a tty,
-                    # we have to flush before exit.
-                    sys.stdout.flush()
-                else:
-                    support.wait_process(pid, exitcode=0)
+                ident = threading.get_ident()
+                with warnings.catch_warnings(record=True) as ws:
+                    warnings.filterwarnings(
+                            "always", category=DeprecationWarning)
+                    pid = os.fork()
+                    if pid == 0:
+                        print("current ident", threading.get_ident() == ident)
+                        main = threading.main_thread()
+                        print("main", main.name, type(main).__name__)
+                        print("main ident", main.ident == ident)
+                        print("current is main", threading.current_thread() is main)
+                        # stdout is fully buffered because not a tty,
+                        # we have to flush before exit.
+                        sys.stdout.flush()
+                    else:
+                        assert ws[0].category == DeprecationWarning, ws[0]
+                        assert 'fork' in str(ws[0].message), ws[0]
+                        support.wait_process(pid, exitcode=0)
 
             th = threading.Thread(target=func)
             th.start()
@@ -647,11 +779,82 @@ def func():
         """
         _, out, err = assert_python_ok("-c", code)
         data = out.decode().replace('\r', '')
-        self.assertEqual(err, b"")
-        self.assertEqual(data, "Thread-1 (func)\nTrue\nTrue\n")
+        self.assertEqual(err.decode('utf-8'), "")
+        self.assertEqual(data,
+                         "current ident True\n"
+                         "main Thread-1 (func) Thread\n"
+                         "main ident True\n"
+                         "current is main True\n"
+                         )
+
+    @skip_unless_reliable_fork
+    @unittest.skipUnless(hasattr(os, 'waitpid'), "test needs os.waitpid()")
+    def test_main_thread_after_fork_from_foreign_thread(self, create_dummy=False):
+        code = """if 1:
+            import os, threading, sys, traceback, _thread
+            from test import support
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+            def func(lock):
+                ident = threading.get_ident()
+                if %s:
+                    # call current_thread() before fork to allocate DummyThread
+                    current = threading.current_thread()
+                    print("current", current.name, type(current).__name__)
+                print("ident in _active", ident in threading._active)
+                # flush before fork, so child won't flush it again
+                sys.stdout.flush()
+                pid = os.fork()
+                if pid == 0:
+                    print("current ident", threading.get_ident() == ident)
+                    main = threading.main_thread()
+                    print("main", main.name, type(main).__name__)
+                    print("main ident", main.ident == ident)
+                    print("current is main", threading.current_thread() is main)
+                    print("_dangling", [t.name for t in list(threading._dangling)])
+                    # stdout is fully buffered because not a tty,
+                    # we have to flush before exit.
+                    sys.stdout.flush()
+                    try:
+                        threading._shutdown()
+                        os._exit(0)
+                    except:
+                        traceback.print_exc()
+                        sys.stderr.flush()
+                        os._exit(1)
+                else:
+                    try:
+                        support.wait_process(pid, exitcode=0)
+                    except Exception:
+                        # avoid 'could not acquire lock for
+                        # <_io.BufferedWriter name='<stderr>'> at interpreter shutdown,'
+                        traceback.print_exc()
+                        sys.stderr.flush()
+                    finally:
+                        lock.release()
+
+            join_lock = _thread.allocate_lock()
+            join_lock.acquire()
+            th = _thread.start_new_thread(func, (join_lock,))
+            join_lock.acquire()
+        """ % create_dummy
+        # "DeprecationWarning: This process is multi-threaded, use of fork()
+        # may lead to deadlocks in the child"
+        _, out, err = assert_python_ok("-W", "ignore::DeprecationWarning", "-c", code)
+        data = out.decode().replace('\r', '')
+        self.assertEqual(err.decode(), "")
+        self.assertEqual(data,
+                         ("current Dummy-1 _DummyThread\n" if create_dummy else "") +
+                         f"ident in _active {create_dummy!s}\n" +
+                         "current ident True\n"
+                         "main MainThread _MainThread\n"
+                         "main ident True\n"
+                         "current is main True\n"
+                         "_dangling ['MainThread']\n")
+
+    def test_main_thread_after_fork_from_dummy_thread(self, create_dummy=False):
+        self.test_main_thread_after_fork_from_foreign_thread(create_dummy=True)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_main_thread_during_shutdown(self):
         # bpo-31516: current_thread() should still point to the main thread
         # at shutdown
@@ -716,41 +919,6 @@ def f():
         rc, out, err = assert_python_ok("-c", code)
         self.assertEqual(err, b"")
 
-    def test_tstate_lock(self):
-        # Test an implementation detail of Thread objects.
-        started = _thread.allocate_lock()
-        finish = _thread.allocate_lock()
-        started.acquire()
-        finish.acquire()
-        def f():
-            started.release()
-            finish.acquire()
-            time.sleep(0.01)
-        # The tstate lock is None until the thread is started
-        t = threading.Thread(target=f)
-        self.assertIs(t._tstate_lock, None)
-        t.start()
-        started.acquire()
-        self.assertTrue(t.is_alive())
-        # The tstate lock can't be acquired when the thread is running
-        # (or suspended).
-        tstate_lock = t._tstate_lock
-        self.assertFalse(tstate_lock.acquire(timeout=0), False)
-        finish.release()
-        # When the thread ends, the state_lock can be successfully
-        # acquired.
-        self.assertTrue(tstate_lock.acquire(timeout=support.SHORT_TIMEOUT), False)
-        # But is_alive() is still True:  we hold _tstate_lock now, which
-        # prevents is_alive() from knowing the thread's end-of-life C code
-        # is done.
-        self.assertTrue(t.is_alive())
-        # Let is_alive() find out the C code is done.
-        tstate_lock.release()
-        self.assertFalse(t.is_alive())
-        # And verify the thread disposed of _tstate_lock.
-        self.assertIsNone(t._tstate_lock)
-        t.join()
-
     def test_repr_stopped(self):
         # Verify that "stopped" shows up in repr(Thread) appropriately.
         started = _thread.allocate_lock()
@@ -798,6 +966,7 @@ def test_BoundedSemaphore_limit(self):
 
     @cpython_only
     def test_frame_tstate_tracing(self):
+        _testcapi = import_module("_testcapi")
         # Issue #14432: Crash when a generator is created in a C thread that is
         # destroyed while the generator is still used. The issue was that a
         # generator contains a frame, and the frame kept a reference to the
@@ -825,7 +994,6 @@ def callback():
             threading.settrace(noop_trace)
 
             # Create a generator in a C thread which exits after the call
-            import _testcapi
             _testcapi.call_in_temporary_c_thread(callback)
 
             # Call the generator in a different Python thread, check that the
@@ -835,6 +1003,7 @@ def callback():
                 callback()
         finally:
             sys.settrace(old_trace)
+            threading.settrace(old_trace)
 
     def test_gettrace(self):
         def noop_trace(frame, event, arg):
@@ -848,6 +1017,36 @@ def noop_trace(frame, event, arg):
         finally:
             threading.settrace(old_trace)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_gettrace_all_threads(self):
+        def fn(*args): pass
+        old_trace = threading.gettrace()
+        first_check = threading.Event()
+        second_check = threading.Event()
+
+        trace_funcs = []
+        def checker():
+            trace_funcs.append(sys.gettrace())
+            first_check.set()
+            second_check.wait()
+            trace_funcs.append(sys.gettrace())
+
+        try:
+            t = threading.Thread(target=checker)
+            t.start()
+            first_check.wait()
+            threading.settrace_all_threads(fn)
+            second_check.set()
+            t.join()
+            self.assertEqual(trace_funcs, [None, fn])
+            self.assertEqual(threading.gettrace(), fn)
+            self.assertEqual(sys.gettrace(), fn)
+        finally:
+            threading.settrace_all_threads(old_trace)
+
+        self.assertEqual(threading.gettrace(), old_trace)
+        self.assertEqual(sys.gettrace(), old_trace)
+
     def test_getprofile(self):
         def fn(*args): pass
         old_profile = threading.getprofile()
@@ -857,32 +1056,37 @@ def fn(*args): pass
         finally:
             threading.setprofile(old_profile)
 
-    @cpython_only
-    def test_shutdown_locks(self):
-        for daemon in (False, True):
-            with self.subTest(daemon=daemon):
-                event = threading.Event()
-                thread = threading.Thread(target=event.wait, daemon=daemon)
-
-                # Thread.start() must add lock to _shutdown_locks,
-                # but only for non-daemon thread
-                thread.start()
-                tstate_lock = thread._tstate_lock
-                if not daemon:
-                    self.assertIn(tstate_lock, threading._shutdown_locks)
-                else:
-                    self.assertNotIn(tstate_lock, threading._shutdown_locks)
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_getprofile_all_threads(self):
+        def fn(*args): pass
+        old_profile = threading.getprofile()
+        first_check = threading.Event()
+        second_check = threading.Event()
 
-                # unblock the thread and join it
-                event.set()
-                thread.join()
+        profile_funcs = []
+        def checker():
+            profile_funcs.append(sys.getprofile())
+            first_check.set()
+            second_check.wait()
+            profile_funcs.append(sys.getprofile())
 
-                # Thread._stop() must remove tstate_lock from _shutdown_locks.
-                # Daemon threads must never add it to _shutdown_locks.
-                self.assertNotIn(tstate_lock, threading._shutdown_locks)
+        try:
+            t = threading.Thread(target=checker)
+            t.start()
+            first_check.wait()
+            threading.setprofile_all_threads(fn)
+            second_check.set()
+            t.join()
+            self.assertEqual(profile_funcs, [None, fn])
+            self.assertEqual(threading.getprofile(), fn)
+            self.assertEqual(sys.getprofile(), fn)
+        finally:
+            threading.setprofile_all_threads(old_profile)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        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
@@ -927,16 +1131,6 @@ def noop(): pass
             threading.Thread(target=noop).start()
             # Thread.join() is not called
 
-    @unittest.skipUnless(Py_DEBUG, 'need debug build (Py_DEBUG)')
-    def test_debug_deprecation(self):
-        # bpo-44584: The PYTHONTHREADDEBUG environment variable is deprecated
-        rc, out, err = assert_python_ok("-Wdefault", "-c", "pass",
-                                        PYTHONTHREADDEBUG="1")
-        msg = (b'DeprecationWarning: The threading debug '
-               b'(PYTHONTHREADDEBUG environment variable) '
-               b'is deprecated and will be removed in Python 3.12')
-        self.assertIn(msg, err)
-
     def test_import_from_another_thread(self):
         # bpo-1596321: If the threading module is first import from a thread
         # different than the main thread, threading._shutdown() must handle
@@ -970,6 +1164,164 @@ def import_threading():
         self.assertEqual(out, b'')
         self.assertEqual(err, b'')
 
+    # TODO: RUSTPYTHON - __del__ not called during interpreter finalization (no cyclic GC)
+    @unittest.expectedFailure
+    def test_start_new_thread_at_finalization(self):
+        code = """if 1:
+            import _thread
+
+            def f():
+                print("shouldn't be printed")
+
+            class AtFinalization:
+                def __del__(self):
+                    print("OK")
+                    _thread.start_new_thread(f, ())
+            at_finalization = AtFinalization()
+        """
+        _, out, err = assert_python_ok("-c", code)
+        self.assertEqual(out.strip(), b"OK")
+        self.assertIn(b"can't create new thread at interpreter shutdown", err)
+
+    def test_start_new_thread_failed(self):
+        # gh-109746: if Python fails to start newly created thread
+        # due to failure of underlying PyThread_start_new_thread() call,
+        # its state should be removed from interpreter' thread states list
+        # to avoid its double cleanup
+        try:
+            from resource import setrlimit, RLIMIT_NPROC
+        except ImportError as err:
+            self.skipTest(err)  # RLIMIT_NPROC is specific to Linux and BSD
+        code = """if 1:
+            import resource
+            import _thread
+
+            def f():
+                print("shouldn't be printed")
+
+            limits = resource.getrlimit(resource.RLIMIT_NPROC)
+            [_, hard] = limits
+            resource.setrlimit(resource.RLIMIT_NPROC, (0, hard))
+
+            try:
+                handle = _thread.start_joinable_thread(f)
+            except RuntimeError:
+                print('ok')
+            else:
+                print('!skip!')
+                handle.join()
+        """
+        _, out, err = assert_python_ok("-u", "-c", code)
+        out = out.strip()
+        if b'!skip!' in out:
+            self.skipTest('RLIMIT_NPROC had no effect; probably superuser')
+        self.assertEqual(out, b'ok')
+        self.assertEqual(err, b'')
+
+
+    @skip_unless_reliable_fork
+    @unittest.skipUnless(hasattr(threading, 'get_native_id'), "test needs threading.get_native_id()")
+    def test_native_id_after_fork(self):
+        script = """if True:
+            import threading
+            import os
+            from test import support
+
+            parent_thread_native_id = threading.current_thread().native_id
+            print(parent_thread_native_id, flush=True)
+            assert parent_thread_native_id == threading.get_native_id()
+            childpid = os.fork()
+            if childpid == 0:
+                print(threading.current_thread().native_id, flush=True)
+                assert threading.current_thread().native_id == threading.get_native_id()
+            else:
+                try:
+                    assert parent_thread_native_id == threading.current_thread().native_id
+                    assert parent_thread_native_id == threading.get_native_id()
+                finally:
+                    support.wait_process(childpid, exitcode=0)
+            """
+        rc, out, err = assert_python_ok('-c', script)
+        self.assertEqual(rc, 0)
+        self.assertEqual(err, b"")
+        native_ids = out.strip().splitlines()
+        self.assertEqual(len(native_ids), 2)
+        self.assertNotEqual(native_ids[0], native_ids[1])
+
+    @cpython_only
+    def test_finalize_daemon_thread_hang(self):
+        if support.check_sanitizer(thread=True, memory=True):
+            # the thread running `time.sleep(100)` below will still be alive
+            # at process exit
+            self.skipTest(
+                    "https://github.com/python/cpython/issues/124878 - Known"
+                    " race condition that TSAN identifies.")
+        # gh-87135: tests that daemon threads hang during finalization
+        script = textwrap.dedent('''
+            import os
+            import sys
+            import threading
+            import time
+            import _testcapi
+
+            lock = threading.Lock()
+            lock.acquire()
+            thread_started_event = threading.Event()
+            def thread_func():
+                try:
+                    thread_started_event.set()
+                    _testcapi.finalize_thread_hang(lock.acquire)
+                finally:
+                    # Control must not reach here.
+                    os._exit(2)
+
+            t = threading.Thread(target=thread_func)
+            t.daemon = True
+            t.start()
+            thread_started_event.wait()
+            # Sleep to ensure daemon thread is blocked on `lock.acquire`
+            #
+            # Note: This test is designed so that in the unlikely case that
+            # `0.1` seconds is not sufficient time for the thread to become
+            # blocked on `lock.acquire`, the test will still pass, it just
+            # won't be properly testing the thread behavior during
+            # finalization.
+            time.sleep(0.1)
+
+            def run_during_finalization():
+                # Wake up daemon thread
+                lock.release()
+                # Sleep to give the daemon thread time to crash if it is going
+                # to.
+                #
+                # Note: If due to an exceptionally slow execution this delay is
+                # insufficient, the test will still pass but will simply be
+                # ineffective as a test.
+                time.sleep(0.1)
+                # If control reaches here, the test succeeded.
+                os._exit(0)
+
+            # Replace sys.stderr.flush as a way to run code during finalization
+            orig_flush = sys.stderr.flush
+            def do_flush(*args, **kwargs):
+                orig_flush(*args, **kwargs)
+                if not sys.is_finalizing:
+                    return
+                sys.stderr.flush = orig_flush
+                run_during_finalization()
+
+            sys.stderr.flush = do_flush
+
+            # If the follow exit code is retained, `run_during_finalization`
+            # did not run.
+            sys.exit(1)
+        ''')
+        assert_python_ok("-c", script)
+
+    @unittest.skip('TODO: RUSTPYTHON; Thread._tstate_lock not implemented')
+    def test_tstate_lock(self):
+        return super().test_tstate_lock()
+
 
 class ThreadJoinOnShutdown(BaseTestCase):
 
@@ -990,8 +1342,6 @@ def joiningfunc(mainthread):
         data = out.decode().replace('\r', '')
         self.assertEqual(data, "end of main\nend of thread\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_1_join_on_shutdown(self):
         # The usual case: on exit, wait for a non-daemon thread
         script = """if 1:
@@ -1004,10 +1354,7 @@ def test_1_join_on_shutdown(self):
             """
         self._run_and_join(script)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    # TODO: RUSTPYTHON need to fix test_1_join_on_shutdown then this might work
-    @unittest.expectedFailure
+    @skip_unless_reliable_fork
     def test_2_join_in_forked_process(self):
         # Like the test above, but from a forked interpreter
         script = """if 1:
@@ -1027,9 +1374,8 @@ def test_2_join_in_forked_process(self):
             """
         self._run_and_join(script)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    @skip_unless_reliable_fork
     def test_3_join_in_forked_from_thread(self):
         # Like the test above, but fork() was called from a worker thread
         # In the forked process, the main Thread object must be marked as stopped.
@@ -1058,10 +1404,16 @@ def worker():
         self._run_and_join(script)
 
     @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
-    def test_4_daemon_threads(self):
+    @support.bigmemtest(size=40, memuse=70*2**20, dry_run=False)
+    def test_4_daemon_threads(self, size):
         # Check that a daemon thread cannot crash the interpreter on shutdown
         # by manipulating internal structures that are being disposed of in
         # the main thread.
+        if support.check_sanitizer(thread=True):
+            # some of the threads running `random_io` below will still be alive
+            # at process exit
+            self.skipTest("TSAN would report thread leak")
+
         script = """if True:
             import os
             import random
@@ -1073,8 +1425,9 @@ def test_4_daemon_threads(self):
 
             def random_io():
                 '''Loop for a while sleeping random tiny amounts and doing some I/O.'''
+                import test.test_threading as mod
                 while True:
-                    with open(os.__file__, 'rb') as in_f:
+                    with open(mod.__file__, 'rb') as in_f:
                         stuff = in_f.read(200)
                         with open(os.devnull, 'wb') as null_f:
                             null_f.write(stuff)
@@ -1098,8 +1451,33 @@ def main():
         rc, out, err = assert_python_ok('-c', script)
         self.assertFalse(err)
 
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
-    @unittest.skipIf(sys.platform in platforms_to_skip, "due to known OS bug")
+    def test_thread_from_thread(self):
+        script = """if True:
+            import threading
+            import time
+
+            def thread2():
+                time.sleep(0.05)
+                print("OK")
+
+            def thread1():
+                time.sleep(0.05)
+                t2 = threading.Thread(target=thread2)
+                t2.start()
+
+            t = threading.Thread(target=thread1)
+            t.start()
+            # do not join() -- the interpreter waits for non-daemon threads to
+            # finish.
+            """
+        rc, out, err = assert_python_ok('-c', script)
+        self.assertEqual(err, b"")
+        self.assertEqual(out.strip(), b"OK")
+        self.assertEqual(rc, 0)
+
+    # TODO: RUSTPYTHON - parking_lot mutex not fork-safe, child may SIGSEGV
+    @unittest.skip("TODO: RUSTPYTHON - flaky, parking_lot mutex not fork-safe")
+    @skip_unless_reliable_fork
     def test_reinit_tls_after_fork(self):
         # Issue #13817: fork() would deadlock in a multithreaded program with
         # the ad-hoc TLS implementation.
@@ -1112,18 +1490,20 @@ def do_fork_and_wait():
             else:
                 os._exit(50)
 
-        # start a bunch of threads that will fork() child processes
-        threads = []
-        for i in range(16):
-            t = threading.Thread(target=do_fork_and_wait)
-            threads.append(t)
-            t.start()
+        # Ignore the warning about fork with threads.
+        with warnings.catch_warnings(category=DeprecationWarning,
+                                     action="ignore"):
+            # start a bunch of threads that will fork() child processes
+            threads = []
+            for i in range(16):
+                t = threading.Thread(target=do_fork_and_wait)
+                threads.append(t)
+                t.start()
 
-        for t in threads:
-            t.join()
+            for t in threads:
+                t.join()
 
-    @unittest.skipUnless(hasattr(sys, '_current_frames'), "TODO: RUSTPYTHON, needs sys._current_frames()")
-    @unittest.skipUnless(hasattr(os, 'fork'), "needs os.fork()")
+    @skip_unless_reliable_fork
     def test_clear_threads_states_after_fork(self):
         # Issue #17094: check that threads states are cleared after fork()
 
@@ -1134,18 +1514,22 @@ def test_clear_threads_states_after_fork(self):
             threads.append(t)
             t.start()
 
-        pid = os.fork()
-        if pid == 0:
-            # check that threads states have been cleared
-            if len(sys._current_frames()) == 1:
-                os._exit(51)
-            else:
-                os._exit(52)
-        else:
-            support.wait_process(pid, exitcode=51)
-
-        for t in threads:
-            t.join()
+        try:
+            # Ignore the warning about fork with threads.
+            with warnings.catch_warnings(category=DeprecationWarning,
+                                         action="ignore"):
+                pid = os.fork()
+                if pid == 0:
+                    # check that threads states have been cleared
+                    if len(sys._current_frames()) == 1:
+                        os._exit(51)
+                    else:
+                        os._exit(52)
+                else:
+                    support.wait_process(pid, exitcode=51)
+        finally:
+            for t in threads:
+                t.join()
 
 
 class SubinterpThreadingTests(BaseTestCase):
@@ -1157,8 +1541,7 @@ def pipe(self):
             os.set_blocking(r, False)
         return (r, w)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_threads_join(self):
         # Non-daemon threads should be joined at subinterpreter shutdown
         # (issue #18808)
@@ -1187,8 +1570,7 @@ def f():
         # The thread was joined properly.
         self.assertEqual(os.read(r, 1), b"x")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_threads_join_2(self):
         # Same as above, but a delay gets introduced after the thread's
         # Python code returned but before the thread state is deleted.
@@ -1226,8 +1608,47 @@ def f():
         # The thread was joined properly.
         self.assertEqual(os.read(r, 1), b"x")
 
+    @requires_subinterpreters
+    def test_threads_join_with_no_main(self):
+        r_interp, w_interp = self.pipe()
+
+        INTERP = b'I'
+        FINI = b'F'
+        DONE = b'D'
+
+        interp = interpreters.create()
+        interp.exec(f"""if True:
+            import os
+            import threading
+            import time
+
+            done = False
+
+            def notify_fini():
+                global done
+                done = True
+                os.write({w_interp}, {FINI!r})
+                t.join()
+            threading._register_atexit(notify_fini)
+
+            def task():
+                while not done:
+                    time.sleep(0.1)
+                os.write({w_interp}, {DONE!r})
+            t = threading.Thread(target=task)
+            t.start()
+
+            os.write({w_interp}, {INTERP!r})
+            """)
+        interp.close()
+
+        self.assertEqual(os.read(r_interp, 1), INTERP)
+        self.assertEqual(os.read(r_interp, 1), FINI)
+        self.assertEqual(os.read(r_interp, 1), DONE)
+
     @cpython_only
     def test_daemon_threads_fatal_error(self):
+        import_module("_testcapi")
         subinterp_code = f"""if 1:
             import os
             import threading
@@ -1249,6 +1670,67 @@ def f():
         self.assertIn("Fatal Python error: Py_EndInterpreter: "
                       "not the last thread", err.decode())
 
+    def _check_allowed(self, before_start='', *,
+                       allowed=True,
+                       daemon_allowed=True,
+                       daemon=False,
+                       ):
+        import_module("_testinternalcapi")
+        subinterp_code = textwrap.dedent(f"""
+            import test.support
+            import threading
+            def func():
+                print('this should not have run!')
+            t = threading.Thread(target=func, daemon={daemon})
+            {before_start}
+            t.start()
+            """)
+        check_multi_interp_extensions = bool(support.Py_GIL_DISABLED)
+        script = textwrap.dedent(f"""
+            import test.support
+            test.support.run_in_subinterp_with_config(
+                {subinterp_code!r},
+                use_main_obmalloc=True,
+                allow_fork=True,
+                allow_exec=True,
+                allow_threads={allowed},
+                allow_daemon_threads={daemon_allowed},
+                check_multi_interp_extensions={check_multi_interp_extensions},
+                own_gil=False,
+            )
+            """)
+        with test.support.SuppressCrashReport():
+            _, _, err = assert_python_ok("-c", script)
+        return err.decode()
+
+    @cpython_only
+    def test_threads_not_allowed(self):
+        err = self._check_allowed(
+            allowed=False,
+            daemon_allowed=False,
+            daemon=False,
+        )
+        self.assertIn('RuntimeError', err)
+
+    @cpython_only
+    def test_daemon_threads_not_allowed(self):
+        with self.subTest('via Thread()'):
+            err = self._check_allowed(
+                allowed=True,
+                daemon_allowed=False,
+                daemon=True,
+            )
+            self.assertIn('RuntimeError', err)
+
+        with self.subTest('via Thread.daemon setter'):
+            err = self._check_allowed(
+                't.daemon = True',
+                allowed=True,
+                daemon_allowed=False,
+                daemon=False,
+            )
+            self.assertIn('RuntimeError', err)
+
 
 class ThreadingExceptionTests(BaseTestCase):
     # A RuntimeError should be raised if Thread.start() is called
@@ -1277,7 +1759,8 @@ def test_releasing_unacquired_lock(self):
         lock = threading.Lock()
         self.assertRaises(RuntimeError, lock.release)
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    @requires_subprocess()
     def test_recursion_limit(self):
         # Issue 9670
         # test that excessive recursion within a non-main thread causes
@@ -1286,13 +1769,6 @@ def test_recursion_limit(self):
         # for threads
         script = """if True:
             import threading
-            # TODO: RUSTPYTHON
-            # Following lines set the recursion limit to previous default of 512
-            # for the execution of this process. Without this, the test runners
-            # on Github fail. Ideally, at a future point this should be removed.
-            import os, sys
-            if os.getenv("CI"):
-                sys.setrecursionlimit(512)
 
             def recurse():
                 return recurse()
@@ -1397,6 +1873,37 @@ def run():
         self.assertEqual(out, b'')
         self.assertNotIn("Unhandled exception", err.decode())
 
+    def test_print_exception_gh_102056(self):
+        # This used to crash. See gh-102056.
+        script = r"""if True:
+            import time
+            import threading
+            import _thread
+
+            def f():
+                try:
+                    f()
+                except RecursionError:
+                    f()
+
+            def g():
+                try:
+                    raise ValueError()
+                except* ValueError:
+                    f()
+
+            def h():
+                time.sleep(1)
+                _thread.interrupt_main()
+
+            t = threading.Thread(target=h)
+            t.start()
+            g()
+            t.join()
+            """
+
+        assert_python_failure("-c", script)
+
     def test_bare_raise_in_brand_new_thread(self):
         def bare_raise():
             raise
@@ -1434,6 +1941,23 @@ def modify_file():
             t.start()
             t.join()
 
+    def test_dummy_thread_on_interpreter_shutdown(self):
+        # GH-130522: When `threading` held a reference to itself and then a
+        # _DummyThread() object was created, destruction of the dummy thread
+        # would emit an unraisable exception at shutdown, due to a lock being
+        # destroyed.
+        code = """if True:
+        import sys
+        import threading
+
+        threading.x = sys.modules[__name__]
+        x = threading._DummyThread()
+        """
+        rc, out, err = assert_python_ok("-c", code)
+        self.assertEqual(rc, 0)
+        self.assertEqual(out, b"")
+        self.assertEqual(err, b"")
+
 
 class ThreadRunFail(threading.Thread):
     def run(self):
@@ -1445,6 +1969,7 @@ def setUp(self):
         restore_default_excepthook(self)
         super().setUp()
 
+    @force_not_colorized
     def test_excepthook(self):
         with support.captured_output("stderr") as stderr:
             thread = ThreadRunFail(name="excepthook thread")
@@ -1458,6 +1983,7 @@ def test_excepthook(self):
         self.assertIn('ValueError: run failed', stderr)
 
     @support.cpython_only
+    @force_not_colorized
     def test_excepthook_thread_None(self):
         # threading.excepthook called with thread=None: log the thread
         # identifier in this case.
@@ -1593,32 +2119,51 @@ class PyRLockTests(lock_tests.RLockTests):
 class CRLockTests(lock_tests.RLockTests):
     locktype = staticmethod(threading._CRLock)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
-    def test_different_thread(self):
-        super().test_different_thread()
+    def test_signature(self):  # gh-102029
+        with warnings.catch_warnings(record=True) as warnings_log:
+            threading.RLock()
+        self.assertEqual(warnings_log, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        arg_types = [
+            ((1,), {}),
+            ((), {'a': 1}),
+            ((1, 2), {'a': 1}),
+        ]
+        for args, kwargs in arg_types:
+            with self.subTest(args=args, kwargs=kwargs):
+                with self.assertWarns(DeprecationWarning):
+                    threading.RLock(*args, **kwargs)
+
+        # Subtypes with custom `__init__` are allowed (but, not recommended):
+        class CustomRLock(self.locktype):
+            def __init__(self, a, *, b) -> None:
+                super().__init__()
+
+        with warnings.catch_warnings(record=True) as warnings_log:
+            CustomRLock(1, b=2)
+        self.assertEqual(warnings_log, [])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_release_save_unacquired(self):
-        super().test_release_save_unacquired()
+        return super().test_release_save_unacquired()
+
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
+    def test_different_thread(self):
+        return super().test_different_thread()
 
 class EventTests(lock_tests.EventTests):
     eventtype = staticmethod(threading.Event)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_reset_internal_locks():  # TODO: RUSTPYTHON; remove this when done
-        super().test_reset_internal_locks()
-
 class ConditionAsRLockTests(lock_tests.RLockTests):
     # Condition uses an RLock by default and exports its API.
     locktype = staticmethod(threading.Condition)
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    def test_recursion_count(self):
+        self.skipTest("Condition does not expose _recursion_count()")
+
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_different_thread(self):
-        super().test_different_thread()
+        return super().test_different_thread()
 
 class ConditionTests(lock_tests.ConditionTests):
     condtype = staticmethod(threading.Condition)
@@ -1634,8 +2179,6 @@ class BarrierTests(lock_tests.BarrierTests):
 
 
 class MiscTestCase(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test__all__(self):
         restore_default_excepthook(self)
 
@@ -1669,7 +2212,8 @@ def check_interrupt_main_noerror(self, signum):
             # Restore original handler
             signal.signal(signum, handler)
 
-    @unittest.skip("TODO: RUSTPYTHON; flaky")
+    @unittest.skip('TODO: RUSTPYTHON; flaky')
+    @requires_gil_enabled("gh-118433: Flaky due to a longstanding bug")
     def test_interrupt_main_subthread(self):
         # Calling start_new_thread with a function that executes interrupt_main
         # should raise KeyboardInterrupt upon completion.
@@ -1728,8 +2272,6 @@ def worker(started, cont, interrupted):
 
 class AtexitTests(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_atexit_output(self):
         rc, out, err = assert_python_ok("-c", """if True:
             import threading
@@ -1758,8 +2300,6 @@ def test_atexit_called_once(self):
 
         self.assertFalse(err)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_atexit_after_shutdown(self):
         # The only way to do this is by registering an atexit within
         # an atexit, which is intended to raise an exception.
diff --git a/Lib/test/test_threading_local.py b/Lib/test/test_threading_local.py
index 3443e3875d..99052de4c7 100644
--- a/Lib/test/test_threading_local.py
+++ b/Lib/test/test_threading_local.py
@@ -3,8 +3,8 @@
 from doctest import DocTestSuite
 from test import support
 from test.support import threading_helper
+from test.support.import_helper import import_module
 import weakref
-import gc
 
 # Modules under test
 import _thread
@@ -12,6 +12,9 @@
 import _threading_local
 
 
+threading_helper.requires_working_threading(module=True)
+
+
 class Weak(object):
     pass
 
@@ -23,7 +26,7 @@ def target(local, weaklist):
 
 class BaseLocalTest:
 
-    @unittest.skip("TODO: RUSTPYTHON, flaky test")
+    @unittest.skip('TODO: RUSTPYTHON; flaky test')
     def test_local_refs(self):
         self._local_refs(20)
         self._local_refs(50)
@@ -182,8 +185,7 @@ class LocalSubclass(self._local):
             """To test that subclasses behave properly."""
         self._test_dict_attribute(LocalSubclass)
 
-    # TODO: RUSTPYTHON, cycle detection/collection
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON; cycle detection/collection
     def test_cycle_collection(self):
         class X:
             pass
@@ -197,35 +199,57 @@ class X:
         self.assertIsNone(wr())
 
 
+    def test_threading_local_clear_race(self):
+        # See https://github.com/python/cpython/issues/100892
+
+        _testcapi = import_module('_testcapi')
+        _testcapi.call_in_temporary_c_thread(lambda: None, False)
+
+        for _ in range(1000):
+            _ = threading.local()
+
+        _testcapi.join_temporary_c_thread()
+
+    @support.cpython_only
+    def test_error(self):
+        class Loop(self._local):
+            attr = 1
+
+        # Trick the "if name == '__dict__':" test of __setattr__()
+        # to always be true
+        class NameCompareTrue:
+            def __eq__(self, other):
+                return True
+
+        loop = Loop()
+        with self.assertRaisesRegex(AttributeError, 'Loop.*read-only'):
+            loop.__setattr__(NameCompareTrue(), 2)
+
+
 class ThreadLocalTest(unittest.TestCase, BaseLocalTest):
     _local = _thread._local
 
-    # TODO: RUSTPYTHON, __new__ vs __init__ cooperation
-    @unittest.expectedFailure
-    def test_arguments():
-        super().test_arguments()
-
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: TypeError not raised by _local
+    def test_arguments(self):
+        return super().test_arguments()
 
 class PyThreadingLocalTest(unittest.TestCase, BaseLocalTest):
     _local = _threading_local.local
 
 
-def test_main():
-    suite = unittest.TestSuite()
-    suite.addTest(DocTestSuite('_threading_local'))
-    suite.addTest(unittest.makeSuite(ThreadLocalTest))
-    suite.addTest(unittest.makeSuite(PyThreadingLocalTest))
+def load_tests(loader, tests, pattern):
+    tests.addTest(DocTestSuite('_threading_local'))
 
     local_orig = _threading_local.local
     def setUp(test):
         _threading_local.local = _thread._local
     def tearDown(test):
         _threading_local.local = local_orig
-    suite.addTest(DocTestSuite('_threading_local',
-                               setUp=setUp, tearDown=tearDown)
-                  )
+    tests.addTests(DocTestSuite('_threading_local',
+                                setUp=setUp, tearDown=tearDown)
+                   )
+    return tests
 
-    support.run_unittest(suite)
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py
index 3886aae934..35055e03b8 100644
--- a/Lib/test/test_time.py
+++ b/Lib/test/test_time.py
@@ -53,8 +53,6 @@ class TimeTestCase(unittest.TestCase):
     def setUp(self):
         self.t = time.time()
 
-    # TODO: RUSTPYTHON, AttributeError: module 'time' has no attribute 'altzone'
-    @unittest.expectedFailure
     def test_data_attributes(self):
         time.altzone
         time.daylight
@@ -284,8 +282,6 @@ def test_strptime_bytes(self):
         self.assertRaises(TypeError, time.strptime, b'2009', "%Y")
         self.assertRaises(TypeError, time.strptime, '2009', b'%Y')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_strptime_exception_context(self):
         # check that this doesn't chain exceptions needlessly (see #17572)
         with self.assertRaises(ValueError) as e:
@@ -624,7 +620,6 @@ def test_large_year(self):
         self.assertEqual(self.yearstr(12345), '12345')
         self.assertEqual(self.yearstr(123456789), '123456789')
 
-@unittest.skip("TODO: RUSTPYTHON, ValueError: invalid struct_time parameter")
 class _TestStrftimeYear:
 
     # Issue 13305:  For years < 1000, the value is not always
diff --git a/Lib/test/test_timeout.py b/Lib/test/test_timeout.py
index f40c7ee48b..70a0175d77 100644
--- a/Lib/test/test_timeout.py
+++ b/Lib/test/test_timeout.py
@@ -71,7 +71,6 @@ def testTypeCheck(self):
         self.assertRaises(TypeError, self.sock.settimeout, {})
         self.assertRaises(TypeError, self.sock.settimeout, 0j)
 
-    @unittest.skip("TODO: RUSTPYTHON; crash")
     def testRangeCheck(self):
         # Test range checking by settimeout()
         self.assertRaises(ValueError, self.sock.settimeout, -1)
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index a551a17fc1..a90c9d0baa 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -1,11 +1,12 @@
 import os
 from pickle import dump
 import sys
-from test.support import captured_stdout
+from test.support import captured_stdout, requires_resource, requires_gil_enabled
 from test.support.os_helper import (TESTFN, rmtree, unlink)
 from test.support.script_helper import assert_python_ok, assert_python_failure
 import textwrap
 import unittest
+from types import FunctionType
 
 import trace
 from trace import Trace
@@ -197,9 +198,7 @@ def test_trace_list_comprehension(self):
         firstlineno_called = get_firstlineno(traced_doubler)
         expected = {
             (self.my_py_filename, firstlineno_calling + 1): 1,
-            # List comprehensions work differently in 3.x, so the count
-            # below changed compared to 2.x.
-            (self.my_py_filename, firstlineno_calling + 2): 12,
+            (self.my_py_filename, firstlineno_calling + 2): 11,
             (self.my_py_filename, firstlineno_calling + 3): 1,
             (self.my_py_filename, firstlineno_called + 1): 10,
         }
@@ -251,7 +250,7 @@ def setUp(self):
         self.my_py_filename = fix_ext_py(__file__)
         self.addCleanup(sys.settrace, sys.gettrace())
 
-    # TODO: RUSTPYTHON, KeyError: ('Lib/test/test_trace.py', 43)
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_exec_counts(self):
         self.tracer = Trace(count=1, trace=0, countfuncs=0, countcallers=0)
@@ -287,7 +286,7 @@ def tearDown(self):
         if self._saved_tracefunc is not None:
             sys.settrace(self._saved_tracefunc)
 
-    # TODO: RUSTPYTHON, gc
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_simple_caller(self):
         self.tracer.runfunc(traced_func_simple_caller, 1)
@@ -306,7 +305,7 @@ def test_arg_errors(self):
         with self.assertRaises(TypeError):
             self.tracer.runfunc()
 
-    # TODO: RUSTPYTHON, gc
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_loop_caller_importing(self):
         self.tracer.runfunc(traced_func_importing_caller, 1)
@@ -320,10 +319,11 @@ def test_loop_caller_importing(self):
         }
         self.assertEqual(self.tracer.results().calledfuncs, expected)
 
-    # TODO: RUSTPYTHON, gc
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
     @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,7 +335,7 @@ def test_inst_method_calling(self):
         }
         self.assertEqual(self.tracer.results().calledfuncs, expected)
 
-    # TODO: RUSTPYTHON, gc
+    # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_traced_decorated_function(self):
         self.tracer.runfunc(traced_decorated_function)
@@ -357,9 +357,11 @@ def setUp(self):
         self.tracer = Trace(count=0, trace=0, countcallers=1)
         self.filemod = my_file_and_modname()
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     @unittest.skipIf(hasattr(sys, 'gettrace') and sys.gettrace(),
                      'pre-existing trace function throws off measurements')
-    @unittest.skip("TODO: RUSTPYTHON, Error in atexit._run_exitfuncs")
+    @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)
 
@@ -387,15 +389,21 @@ def tearDown(self):
         rmtree(TESTFN)
         unlink(TESTFN)
 
-    def _coverage(self, tracer,
-                  cmd='import test.support, test.test_pprint;'
-                      'test.support.run_unittest(test.test_pprint.QueryTestCase)'):
+    DEFAULT_SCRIPT = '''if True:
+        import unittest
+        from test.test_pprint import QueryTestCase
+        loader = unittest.TestLoader()
+        tests = loader.loadTestsFromTestCase(QueryTestCase)
+        tests(unittest.TestResult())
+        '''
+    def _coverage(self, tracer, cmd=DEFAULT_SCRIPT):
         tracer.run(cmd)
         r = tracer.results()
         r.write_results(show_missing=True, summary=True, coverdir=TESTFN)
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
+    @requires_resource('cpu')
     def test_coverage(self):
         tracer = trace.Trace(trace=0, count=1)
         with captured_stdout() as stdout:
@@ -412,7 +420,7 @@ def test_coverage_ignore(self):
         libpath = os.path.normpath(os.path.dirname(os.path.dirname(__file__)))
         # sys.prefix does not work when running from a checkout
         tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,
-                             libpath], trace=0, count=1)
+                             libpath] + sys.path, trace=0, count=1)
         with captured_stdout() as stdout:
             self._coverage(tracer)
         if os.path.exists(TESTFN):
@@ -592,5 +600,31 @@ def test_run_as_module(self):
         assert_python_failure('-m', 'trace', '-l', '--module', 'not_a_module_zzz')
 
 
+class TestTrace(unittest.TestCase):
+    def setUp(self):
+        self.addCleanup(sys.settrace, sys.gettrace())
+        self.tracer = Trace(count=0, trace=1)
+        self.filemod = my_file_and_modname()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_no_source_file(self):
+        filename = "<unknown>"
+        co = traced_func_linear.__code__
+        co = co.replace(co_filename=filename)
+        f = FunctionType(co, globals())
+
+        with captured_stdout() as out:
+            self.tracer.runfunc(f, 2, 3)
+
+        out = out.getvalue().splitlines()
+        firstlineno = get_firstlineno(f)
+        self.assertIn(f" --- modulename: {self.filemod[1]}, funcname: {f.__code__.co_name}", out[0])
+        self.assertIn(f"{filename}({firstlineno + 1})", out[1])
+        self.assertIn(f"{filename}({firstlineno + 2})", out[2])
+        self.assertIn(f"{filename}({firstlineno + 3})", out[3])
+        self.assertIn(f"{filename}({firstlineno + 4})", out[4])
+
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index 30a13587a2..2ba7fbda5c 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -4,26 +4,54 @@
 from io import StringIO
 import linecache
 import sys
+import types
 import inspect
+import builtins
 import unittest
+import unittest.mock
 import re
+import tempfile
+import random
+import string
 from test import support
-from test.support import Error, captured_output, cpython_only, ALWAYS_EQ
+import shutil
+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
-import textwrap
+from test.support.script_helper import assert_python_ok, assert_python_failure
+from test.support.import_helper import forget
+from test.support import force_not_colorized, force_not_colorized_test_class
 
+import json
+import textwrap
 import traceback
+from functools import partial
+from pathlib import Path
+import _colorize
 
+MODULE_PREFIX = f'{__name__}.' if __name__ == '__main__' else ''
 
 test_code = namedtuple('code', ['co_filename', 'co_name'])
+test_code.co_positions = lambda _: iter([(6, 6, 0, 0)])
 test_frame = namedtuple('frame', ['f_code', 'f_globals', 'f_locals'])
-test_tb = namedtuple('tb', ['tb_frame', 'tb_lineno', 'tb_next'])
+test_tb = namedtuple('tb', ['tb_frame', 'tb_lineno', 'tb_next', 'tb_lasti'])
+
+
+LEVENSHTEIN_DATA_FILE = Path(__file__).parent / 'levenshtein_examples.json'
 
 
 class TracebackCases(unittest.TestCase):
     # For now, a very minimal set of tests.  I want to be sure that
     # formatting of SyntaxErrors works based on changes for 2.1.
+    def setUp(self):
+        super().setUp()
+        self.colorize = _colorize.COLORIZE
+        _colorize.COLORIZE = False
+
+    def tearDown(self):
+        super().tearDown()
+        _colorize.COLORIZE = self.colorize
 
     def get_exception_format(self, func, exc):
         try:
@@ -99,6 +127,75 @@ def test_nocaret(self):
         self.assertEqual(len(err), 3)
         self.assertEqual(err[1].strip(), "bad syntax")
 
+    @force_not_colorized
+    def test_no_caret_with_no_debug_ranges_flag(self):
+        # Make sure that if `-X no_debug_ranges` is used, there are no carets
+        # in the traceback.
+        try:
+            with open(TESTFN, 'w') as f:
+                f.write("x = 1 / 0\n")
+
+            _, _, stderr = assert_python_failure(
+                '-X', 'no_debug_ranges', TESTFN)
+
+            lines = stderr.splitlines()
+            self.assertEqual(len(lines), 4)
+            self.assertEqual(lines[0], b'Traceback (most recent call last):')
+            self.assertIn(b'line 1, in <module>', lines[1])
+            self.assertEqual(lines[2], b'    x = 1 / 0')
+            self.assertEqual(lines[3], b'ZeroDivisionError: division by zero')
+        finally:
+            unlink(TESTFN)
+
+    def test_no_caret_with_no_debug_ranges_flag_python_traceback(self):
+        code = textwrap.dedent("""
+            import traceback
+            try:
+                x = 1 / 0
+            except ZeroDivisionError:
+                traceback.print_exc()
+            """)
+        try:
+            with open(TESTFN, 'w') as f:
+                f.write(code)
+
+            _, _, stderr = assert_python_ok(
+                '-X', 'no_debug_ranges', TESTFN)
+
+            lines = stderr.splitlines()
+            self.assertEqual(len(lines), 4)
+            self.assertEqual(lines[0], b'Traceback (most recent call last):')
+            self.assertIn(b'line 4, in <module>', lines[1])
+            self.assertEqual(lines[2], b'    x = 1 / 0')
+            self.assertEqual(lines[3], b'ZeroDivisionError: division by zero')
+        finally:
+            unlink(TESTFN)
+
+    def test_recursion_error_during_traceback(self):
+        code = textwrap.dedent("""
+                import sys
+                from weakref import ref
+
+                sys.setrecursionlimit(15)
+
+                def f():
+                    ref(lambda: 0, [])
+                    f()
+
+                try:
+                    f()
+                except RecursionError:
+                    pass
+        """)
+        try:
+            with open(TESTFN, 'w') as f:
+                f.write(code)
+
+            rc, _, _ = assert_python_ok(TESTFN)
+            self.assertEqual(rc, 0)
+        finally:
+            unlink(TESTFN)
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_bad_indentation(self):
@@ -127,15 +224,190 @@ def __str__(self):
                 1/0
         err = traceback.format_exception_only(X, X())
         self.assertEqual(len(err), 1)
-        str_value = '<unprintable %s object>' % X.__name__
+        str_value = '<exception str() failed>'
         if X.__module__ in ('__main__', 'builtins'):
             str_name = X.__qualname__
         else:
             str_name = '.'.join([X.__module__, X.__qualname__])
         self.assertEqual(err[0], "%s: %s\n" % (str_name, str_value))
 
-    # TODO: RUSTPYTHON
+    def test_format_exception_group_without_show_group(self):
+        eg = ExceptionGroup('A', [ValueError('B')])
+        err = traceback.format_exception_only(eg)
+        self.assertEqual(err, ['ExceptionGroup: A (1 sub-exception)\n'])
+
+    def test_format_exception_group(self):
+        eg = ExceptionGroup('A', [ValueError('B')])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (1 sub-exception)\n',
+            '   ValueError: B\n',
+        ])
+
+    def test_format_base_exception_group(self):
+        eg = BaseExceptionGroup('A', [BaseException('B')])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'BaseExceptionGroup: A (1 sub-exception)\n',
+            '   BaseException: B\n',
+        ])
+
+    def test_format_exception_group_with_note(self):
+        exc = ValueError('B')
+        exc.add_note('Note')
+        eg = ExceptionGroup('A', [exc])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (1 sub-exception)\n',
+            '   ValueError: B\n',
+            '   Note\n',
+        ])
+
+    def test_format_exception_group_explicit_class(self):
+        eg = ExceptionGroup('A', [ValueError('B')])
+        err = traceback.format_exception_only(ExceptionGroup, eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (1 sub-exception)\n',
+            '   ValueError: B\n',
+        ])
+
+    def test_format_exception_group_multiple_exceptions(self):
+        eg = ExceptionGroup('A', [ValueError('B'), TypeError('C')])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (2 sub-exceptions)\n',
+            '   ValueError: B\n',
+            '   TypeError: C\n',
+        ])
+
+    def test_format_exception_group_multiline_messages(self):
+        eg = ExceptionGroup('A\n1', [ValueError('B\n2')])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A\n1 (1 sub-exception)\n',
+            '   ValueError: B\n',
+            '   2\n',
+        ])
+
+    def test_format_exception_group_multiline2_messages(self):
+        exc = ValueError('B\n\n2\n')
+        exc.add_note('\nC\n\n3')
+        eg = ExceptionGroup('A\n\n1\n', [exc, IndexError('D')])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A\n\n1\n (2 sub-exceptions)\n',
+            '   ValueError: B\n',
+            '   \n',
+            '   2\n',
+            '   \n',
+            '   \n',  # first char of `note`
+            '   C\n',
+            '   \n',
+            '   3\n', # note ends
+            '   IndexError: D\n',
+        ])
+
+    def test_format_exception_group_syntax_error(self):
+        exc = SyntaxError("error", ("x.py", 23, None, "bad syntax"))
+        eg = ExceptionGroup('A\n1', [exc])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A\n1 (1 sub-exception)\n',
+            '     File "x.py", line 23\n',
+            '       bad syntax\n',
+            '   SyntaxError: error\n',
+        ])
+
+    def test_format_exception_group_nested_with_notes(self):
+        exc = IndexError('D')
+        exc.add_note('Note\nmultiline')
+        eg = ExceptionGroup('A', [
+            ValueError('B'),
+            ExceptionGroup('C', [exc, LookupError('E')]),
+            TypeError('F'),
+        ])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (3 sub-exceptions)\n',
+            '   ValueError: B\n',
+            '   ExceptionGroup: C (2 sub-exceptions)\n',
+            '      IndexError: D\n',
+            '      Note\n',
+            '      multiline\n',
+            '      LookupError: E\n',
+            '   TypeError: F\n',
+        ])
+
+    def test_format_exception_group_with_tracebacks(self):
+        def f():
+            try:
+                1 / 0
+            except ZeroDivisionError as e:
+                return e
+
+        def g():
+            try:
+                raise TypeError('g')
+            except TypeError as e:
+                return e
+
+        eg = ExceptionGroup('A', [
+            f(),
+            ExceptionGroup('B', [g()]),
+        ])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (2 sub-exceptions)\n',
+            '   ZeroDivisionError: division by zero\n',
+            '   ExceptionGroup: B (1 sub-exception)\n',
+            '      TypeError: g\n',
+        ])
+
+    def test_format_exception_group_with_cause(self):
+        def f():
+            try:
+                try:
+                    1 / 0
+                except ZeroDivisionError:
+                    raise ValueError(0)
+            except Exception as e:
+                return e
+
+        eg = ExceptionGroup('A', [f()])
+        err = traceback.format_exception_only(eg, show_group=True)
+        self.assertEqual(err, [
+            'ExceptionGroup: A (1 sub-exception)\n',
+            '   ValueError: 0\n',
+        ])
+
+    def test_format_exception_group_syntax_error_with_custom_values(self):
+        # See https://github.com/python/cpython/issues/128894
+        for exc in [
+            SyntaxError('error', 'abcd'),
+            SyntaxError('error', [None] * 4),
+            SyntaxError('error', (1, 2, 3, 4)),
+            SyntaxError('error', (1, 2, 3, 4)),
+            SyntaxError('error', (1, 'a', 'b', 2)),
+            # with end_lineno and end_offset:
+            SyntaxError('error', 'abcdef'),
+            SyntaxError('error', [None] * 6),
+            SyntaxError('error', (1, 2, 3, 4, 5, 6)),
+            SyntaxError('error', (1, 'a', 'b', 2, 'c', 'd')),
+        ]:
+            with self.subTest(exc=exc):
+                err = traceback.format_exception_only(exc, show_group=True)
+                # Should not raise an exception:
+                if exc.lineno is not None:
+                    self.assertEqual(len(err), 2)
+                    self.assertTrue(err[0].startswith('  File'))
+                else:
+                    self.assertEqual(len(err), 1)
+                self.assertEqual(err[-1], 'SyntaxError: error\n')
+
+    # TODO: RUSTPYTHON; IndexError: index out of range
     @unittest.expectedFailure
+    @requires_subprocess()
+    @force_not_colorized
     def test_encoded_file(self):
         # Test that tracebacks are correctly printed for encoded source files:
         # - correct line number (Issue2384)
@@ -183,9 +455,10 @@ def do_test(firstlines, message, charset, lineno):
             self.assertTrue(stdout[2].endswith(err_line),
                 "Invalid traceback line: {0!r} instead of {1!r}".format(
                     stdout[2], err_line))
-            self.assertTrue(stdout[3] == err_msg,
+            actual_err_msg = stdout[3]
+            self.assertTrue(actual_err_msg == err_msg,
                 "Invalid error message: {0!r} instead of {1!r}".format(
-                    stdout[3], err_msg))
+                    actual_err_msg, err_msg))
 
         do_test("", "foo", "ascii", 3)
         for charset in ("ascii", "iso-8859-1", "utf-8", "GBK"):
@@ -217,15 +490,15 @@ class PrintExceptionAtExit(object):
                 def __init__(self):
                     try:
                         x = 1 / 0
-                    except Exception:
-                        self.exc_info = sys.exc_info()
-                        # self.exc_info[1] (traceback) contains frames:
+                    except Exception as e:
+                        self.exc = e
+                        # self.exc.__traceback__ contains frames:
                         # explicitly clear the reference to self in the current
                         # frame to break a reference cycle
                         self = None
 
                 def __del__(self):
-                    traceback.print_exception(*self.exc_info)
+                    traceback.print_exception(self.exc)
 
             # Keep a reference in the module namespace to call the destructor
             # when the module is unloaded
@@ -234,6 +507,8 @@ def __del__(self):
         rc, stdout, stderr = assert_python_ok('-c', code)
         expected = [b'Traceback (most recent call last):',
                     b'  File "<string>", line 8, in __init__',
+                    b'    x = 1 / 0',
+                    b'        ^^^^^',
                     b'ZeroDivisionError: division by zero']
         self.assertEqual(stderr.splitlines(), expected)
 
@@ -249,6 +524,12 @@ def test_print_exception_exc(self):
         traceback.print_exception(Exception("projector"), file=output)
         self.assertEqual(output.getvalue(), "Exception: projector\n")
 
+    def test_print_last(self):
+        with support.swap_attr(sys, 'last_exc', ValueError(42)):
+            output = StringIO()
+            traceback.print_last(file=output)
+            self.assertEqual(output.getvalue(), "ValueError: 42\n")
+
     def test_format_exception_exc(self):
         e = Exception("projector")
         output = traceback.format_exception(e)
@@ -257,7 +538,7 @@ def test_format_exception_exc(self):
             traceback.format_exception(e.__class__, e)
         with self.assertRaisesRegex(ValueError, 'Both or neither'):
             traceback.format_exception(e.__class__, tb=e.__traceback__)
-        with self.assertRaisesRegex(TypeError, 'positional-only'):
+        with self.assertRaisesRegex(TypeError, 'required positional argument'):
             traceback.format_exception(exc=e)
 
     def test_format_exception_only_exc(self):
@@ -291,35 +572,1333 @@ def test_signatures(self):
         self.assertEqual(
             str(inspect.signature(traceback.print_exception)),
             ('(exc, /, value=<implicit>, tb=<implicit>, '
-             'limit=None, file=None, chain=True)'))
+             'limit=None, file=None, chain=True, **kwargs)'))
 
         self.assertEqual(
             str(inspect.signature(traceback.format_exception)),
             ('(exc, /, value=<implicit>, tb=<implicit>, limit=None, '
-             'chain=True)'))
+             'chain=True, **kwargs)'))
 
         self.assertEqual(
             str(inspect.signature(traceback.format_exception_only)),
-            '(exc, /, value=<implicit>)')
+            '(exc, /, value=<implicit>, *, show_group=False, **kwargs)')
+
+
+class PurePythonExceptionFormattingMixin:
+    def get_exception(self, callable, slice_start=0, slice_end=-1):
+        try:
+            callable()
+        except BaseException:
+            return traceback.format_exc().splitlines()[slice_start:slice_end]
+        else:
+            self.fail("No exception thrown.")
+
+    callable_line = get_exception.__code__.co_firstlineno + 2
+
+
+class CAPIExceptionFormattingMixin:
+    LEGACY = 0
+
+    def get_exception(self, callable, slice_start=0, slice_end=-1):
+        from _testcapi import exception_print
+        try:
+            callable()
+            self.fail("No exception thrown.")
+        except Exception as e:
+            with captured_output("stderr") as tbstderr:
+                exception_print(e, self.LEGACY)
+            return tbstderr.getvalue().splitlines()[slice_start:slice_end]
+
+    callable_line = get_exception.__code__.co_firstlineno + 3
+
+class CAPIExceptionFormattingLegacyMixin(CAPIExceptionFormattingMixin):
+    LEGACY = 1
+
+# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+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.
+        def f():
+            if True: raise ValueError("basic caret tests")
+
+        lineno_f = f.__code__.co_firstlineno
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+1}, in f\n'
+            '    if True: raise ValueError("basic caret tests")\n'
+            '             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+        )
+        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.
+        def f_with_unicode():
+            if True: raise ValueError("Ĥellö Wörld")
+
+        lineno_f = f_with_unicode.__code__.co_firstlineno
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+1}, in f_with_unicode\n'
+            '    if True: raise ValueError("Ĥellö Wörld")\n'
+            '             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+        )
+        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
+
+        lineno_f = f_with_type.__code__.co_firstlineno
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            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'
+            '    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.
+        def f_with_multiline():
+            if True: raise ValueError(
+                "error over multiple lines"
+            )
+
+        lineno_f = f_with_multiline.__code__.co_firstlineno
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+1}, in f_with_multiline\n'
+            '    if True: raise ValueError(\n'
+            '             ^^^^^^^^^^^^^^^^^\n'
+            '        "error over multiple lines"\n'
+            '        ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+            '    )\n'
+            '    ^'
+        )
+        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.
+        code = textwrap.dedent("""
+        def foo(*args, **kwargs):
+            pass
+
+        a, b, c = 1, 2, 3
+
+        foo(a, z
+                for z in
+                    range(10), b, c)
+        """)
+
+        def f_with_multiline():
+            # Need to defer the compilation until in self.get_exception(..)
+            return compile(code, "?", "exec")
+
+        lineno_f = f_with_multiline.__code__.co_firstlineno
+
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'
+            '    return compile(code, "?", "exec")\n'
+            '  File "?", line 7\n'
+            '    foo(a, z\n'
+            '           ^'
+            )
+
+        result_lines = self.get_exception(f_with_multiline)
+        self.assertEqual(result_lines, expected_f.splitlines())
+
+        # Check custom error messages covering multiple lines
+        code = textwrap.dedent("""
+        dummy_call(
+            "dummy value"
+            foo="bar",
+        )
+        """)
+
+        def f_with_multiline():
+            # Need to defer the compilation until in self.get_exception(..)
+            return compile(code, "?", "exec")
+
+        lineno_f = f_with_multiline.__code__.co_firstlineno
+
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'
+            '    return compile(code, "?", "exec")\n'
+            '  File "?", line 3\n'
+            '    "dummy value"\n'
+            '    ^^^^^^^^^^^^^'
+            )
+
+        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.
+        def f_with_multiline():
+            return (
+                2 + 1 /
+                0
+            )
+
+        lineno_f = f_with_multiline.__code__.co_firstlineno
+        expected_f = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'
+            '    2 + 1 /\n'
+            '        ~~^\n'
+            '    0\n'
+            '    ~'
+        )
+        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
+            return 10 + divisor / 0 + 30
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
+            '    return 10 + divisor / 0 + 30\n'
+            '                ~~~~~~~~^~~\n'
+        )
+        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
+            return 10 + áóí / 0 + 30
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
+            '    return 10 + áóí / 0 + 30\n'
+            '                ~~~~^~~\n'
+        )
+        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
+            return 10 + divisor // 0 + 30
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
+            '    return 10 + divisor // 0 + 30\n'
+            '                ~~~~~~~~^^~~\n'
+        )
+        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
+            b = c = ""
+            return ( a   )   +b + c
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+            '    return ( a   )   +b + c\n'
+            '           ~~~~~~~~~~^~\n'
+        )
+        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
+            c = ""
+            a = b    \
+         +\
+               c  # test
+            return a
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+            '       a = b    \\\n'
+            '           ~~~~~~\n'
+            '    +\\\n'
+            '    ^~\n'
+            '          c  # test\n'
+            '          ~\n'
+        )
+        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
+            c = ""
+            a = (
+                (b  # test +
+                    )  \
+                # +
+            << (c  # test
+                \
+            )  # test
+            )
+            return a
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+4}, in f_with_binary_operator\n'
+            '        (b  # test +\n'
+            '        ~~~~~~~~~~~~\n'
+            '            )  \\\n'
+            '            ~~~~\n'
+            '        # +\n'
+            '        ~~~\n'
+            '    << (c  # test\n'
+            '    ^^~~~~~~~~~~~\n'
+            '        \\\n'
+            '        ~\n'
+            '    )  # test\n'
+            '    ~\n'
+        )
+        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
+            a = ("ááá" +
+                "áá") + b
+            return a
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'
+            '    a = ("ááá" +\n'
+            '        ~~~~~~~~\n'
+            '        "áá") + b\n'
+            '        ~~~~~~^~~\n'
+        )
+        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}}
+            return some_dict['x']['y']['z']
+
+        lineno_f = f_with_subscript.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
+            "    return some_dict['x']['y']['z']\n"
+            '           ~~~~~~~~~~~~~~~~~~~^^^^^\n'
+        )
+        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}}}}
+            return some_dict['ó']['á']['í']['beta']
+
+        lineno_f = f_with_subscript.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
+            "    return some_dict['ó']['á']['í']['beta']\n"
+            '           ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^\n'
+        )
+        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 = []
+            b = c = 1
+            return b     [    a  ] + c
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+            '    return b     [    a  ] + c\n'
+            '           ~~~~~~^^^^^^^^^\n'
+        )
+        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 = {}
+            ccc = 1
+            ddd = 2
+            b = bbbbb \
+                [  ccc # test
+
+                 + ddd  \
+
+                ] # test
+            return b
+
+        lineno_f = f_with_subscript.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+4}, in f_with_subscript\n'
+            '    b = bbbbb \\\n'
+            '        ~~~~~~~\n'
+            '        [  ccc # test\n'
+            '        ^^^^^^^^^^^^^\n'
+            '    \n'
+            '    \n'
+            '         + ddd  \\\n'
+            '         ^^^^^^^^\n'
+            '    \n'
+            '    \n'
+            '        ] # test\n'
+            '        ^\n'
+        )
+        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):
+                def f2(b):
+                    raise RuntimeError("fail")
+                return f2
+            return f1("x")("y")("z")
+
+        lineno_f = f_with_call.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+5}, in f_with_call\n'
+            '    return f1("x")("y")("z")\n'
+            '           ~~~~~~~^^^^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f2\n'
+            '    raise RuntimeError("fail")\n'
+        )
+        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):
+                def f2(b):
+                    raise RuntimeError("fail")
+                return f2
+            return f1("ó")("á")
+
+        lineno_f = f_with_call.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+5}, in f_with_call\n'
+            '    return f1("ó")("á")\n'
+            '           ~~~~~~~^^^^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f2\n'
+            '    raise RuntimeError("fail")\n'
+        )
+        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):
+                raise RuntimeError("fail")
+            return f     (    "x"  ) + 2
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+            '    return f     (    "x"  ) + 2\n'
+            '           ~~~~~~^^^^^^^^^^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f\n'
+            '    raise RuntimeError("fail")\n'
+        )
+        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:
+                def y(self, a):
+                    def f(b):
+                        raise RuntimeError("fail")
+                    return f
+            def g(x):
+                return C()
+            a = (g(1).y)(
+                2
+            )(3)(4)
+            return a
+
+        lineno_f = f_with_call.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+8}, in f_with_call\n'
+            '    a = (g(1).y)(\n'
+            '        ~~~~~~~~~\n'
+            '        2\n'
+            '        ~\n'
+            '    )(3)(4)\n'
+            '    ~^^^\n'
+            f'  File "{__file__}", line {lineno_f+4}, in f\n'
+            '    raise RuntimeError("fail")\n'
+        )
+        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
+            if True: x += (
+                "a" +
+                "a"
+            )  # test
+
+        lineno_f = f.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f\n'
+            '    if True: x += (\n'
+            '             ^^^^^^\n'
+            '    ...<2 lines>...\n'
+            '    )  # test\n'
+            '    ^\n'
+        )
+        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
+            x += (
+                "a" +
+                "a"
+            )
+
+        lineno_f = f.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f\n'
+            '    x += (\n'
+            '    ...<2 lines>...\n'
+            '    )\n'
+        )
+        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
+            c = "a"
+            a = (
+                b +
+                b
+            ) + (
+                c +
+                c +
+                c
+            )
+            return a
+
+        lineno_f = f_with_binary_operator.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'
+            '    a = (\n'
+            '        ~\n'
+            '        b +\n'
+            '        ~~~\n'
+            '        b\n'
+            '        ~\n'
+            '    ) + (\n'
+            '    ~~^~~\n'
+            '        c +\n'
+            '        ~~~\n'
+            '    ...<2 lines>...\n'
+            '    )\n'
+            '    ~\n'
+        )
+        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")
+
+        with open(TESTFN, "w") as file:
+            # make the file's contents invalid
+            file.write("1 $ 0 / 1 / 2\n")
+        self.addCleanup(unlink, TESTFN)
+
+        func = partial(exec, bytecode)
+        result_lines = self.get_exception(func)
+
+        lineno_f = bytecode.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{TESTFN}", line {lineno_f}, in <module>\n'
+            "    1 $ 0 / 1 / 2\n"
+            '    ^^^^^\n'
+        )
+        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")
+
+        with open(TESTFN, "w") as file:
+            file.write(source)
+        self.addCleanup(unlink, TESTFN)
+
+        func = partial(exec, bytecode)
+        result_lines = self.get_exception(func)
+
+        lineno_f = bytecode.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{TESTFN}", line {lineno_f}, in <module>\n'
+            f'    {source}\n'
+            f'    {" "*len("if True: ") + "^"*256}\n'
+        )
+        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():
+            some_dict = {'x': {'y': None}}
+            some_dict['x']['y']['z']
+
+        lineno_f = f_with_subscript.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_f+2}, in f_with_subscript\n'
+            "    some_dict['x']['y']['z']\n"
+            '    ~~~~~~~~~~~~~~~~~~~^^^^^\n'
+        )
+        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.)
+        # The implementation must account for both "indent" and "margin" offsets.
+
+        def exc():
+            if True: raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])
+
+        expected_error = (
+             f'  + Exception Group Traceback (most recent call last):\n'
+             f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+             f'  |     callable()\n'
+             f'  |     ~~~~~~~~^^\n'
+             f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n'
+             f'  |     if True: raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n'
+             f'  |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
+             f'  | ExceptionGroup: eg (2 sub-exceptions)\n'
+             f'  +-+---------------- 1 ----------------\n'
+             f'    | ValueError: 1\n'
+             f'    +---------------- 2 ----------------\n'
+             f'    | TypeError: 2\n')
+
+        result_lines = self.get_exception(exc)
+        self.assertEqual(result_lines, expected_error.splitlines())
+
+    def assertSpecialized(self, func, expected_specialization):
+        result_lines = self.get_exception(func)
+        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,
+                                      "~^~")
+        self.assertSpecialized(lambda: 1/0/3,
+                                      "~^~")
+        self.assertSpecialized(lambda: 1 / 0,
+                                      "~~^~~")
+        self.assertSpecialized(lambda: 1 / 0 / 3,
+                                      "~~^~~")
+        self.assertSpecialized(lambda: 1/ 0,
+                                      "~^~~")
+        self.assertSpecialized(lambda: 1/ 0/3,
+                                      "~^~~")
+        self.assertSpecialized(lambda: 1    /  0,
+                                      "~~~~~^~~~")
+        self.assertSpecialized(lambda: 1    /  0   / 5,
+                                      "~~~~~^~~~")
+        self.assertSpecialized(lambda: 1 /0,
+                                      "~~^~")
+        self.assertSpecialized(lambda: 1//0,
+                                      "~^^~")
+        self.assertSpecialized(lambda: 1//0//4,
+                                      "~^^~")
+        self.assertSpecialized(lambda: 1 // 0,
+                                      "~~^^~~")
+        self.assertSpecialized(lambda: 1 // 0 // 4,
+                                      "~~^^~~")
+        self.assertSpecialized(lambda: 1 //0,
+                                      "~~^^~")
+        self.assertSpecialized(lambda: 1// 0,
+                                      "~^^~~")
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_decorator_application_lineno_correct(self):
+        def dec_error(func):
+            raise TypeError
+        def dec_fine(func):
+            return func
+        def applydecs():
+            @dec_error
+            @dec_fine
+            def g(): pass
+        result_lines = self.get_exception(applydecs)
+        lineno_applydescs = applydecs.__code__.co_firstlineno
+        lineno_dec_error = dec_error.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_applydescs + 1}, in applydecs\n'
+            '    @dec_error\n'
+            '     ^^^^^^^^^\n'
+            f'  File "{__file__}", line {lineno_dec_error + 1}, in dec_error\n'
+            '    raise TypeError\n'
+        )
+        self.assertEqual(result_lines, expected_error.splitlines())
+
+        def applydecs_class():
+            @dec_error
+            @dec_fine
+            class A: pass
+        result_lines = self.get_exception(applydecs_class)
+        lineno_applydescs_class = applydecs_class.__code__.co_firstlineno
+        expected_error = (
+            'Traceback (most recent call last):\n'
+            f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+            '    callable()\n'
+            '    ~~~~~~~~^^\n'
+            f'  File "{__file__}", line {lineno_applydescs_class + 1}, in applydecs_class\n'
+            '    @dec_error\n'
+            '     ^^^^^^^^^\n'
+            f'  File "{__file__}", line {lineno_dec_error + 1}, in dec_error\n'
+            '    raise TypeError\n'
+        )
+        self.assertEqual(result_lines, expected_error.splitlines())
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_multiline_method_call_a(self):
+        def f():
+            (None
+                .method
+            )()
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
+            "    .method",
+            "     ^^^^^^",
+        ]
+        self.assertEqual(actual, expected)
 
-class TracebackFormatTests(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_multiline_method_call_b(self):
+        def f():
+            (None.
+                method
+            )()
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
+            "    method",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_multiline_method_call_c(self):
+        def f():
+            (None
+                . method
+            )()
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
+            "    . method",
+            "      ^^^^^^",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_wide_characters_unicode_with_problematic_byte_offset(self):
+        def f():
+            ｗｉｄｔｈ
+
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    ｗｉｄｔｈ",
+        ]
+        self.assertEqual(actual, expected)
+
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byte_offset_with_wide_characters_middle(self):
+        def f():
+            ｗｉｄｔｈ = 1
+            raise ValueError(ｗｉｄｔｈ)
+
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",
+            "    raise ValueError(ｗｉｄｔｈ)",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byte_offset_multiline(self):
+        def f():
+            ｗｗｗ = 1
+            ｔｈ = 0
+
+            print(1, ｗｗｗ(
+                    ｔｈ))
+
+        actual = self.get_exception(f)
+        expected = [
+            "Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 4}, in f",
+            f"    print(1, ｗｗｗ(",
+            f"             ~~~~~~^",
+            f"            ｔｈ))",
+            f"            ^^^^^",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byte_offset_with_wide_characters_term_highlight(self):
+        def f():
+            说明说明 = 1
+            şçöğıĤellö = 0 # not wide but still non-ascii
+            return 说明说明 / şçöğıĤellö
+
+        actual = self.get_exception(f)
+        expected = [
+            f"Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            f"    callable()",
+            f"    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 3}, in f",
+            f"    return 说明说明 / şçöğıĤellö",
+            f"           ~~~~~~~~~^~~~~~~~~~~~",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byte_offset_with_emojis_term_highlight(self):
+        def f():
+            return "✨🐍" + func_说明说明("📗🚛",
+                "📗🚛") + "🐍"
+
+        actual = self.get_exception(f)
+        expected = [
+            f"Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            f"    callable()",
+            f"    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            f'    return "✨🐍" + func_说明说明("📗🚛",',
+            f"                    ^^^^^^^^^^^^^",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_byte_offset_wide_chars_subscript(self):
+        def f():
+            my_dct = {
+                "✨🚛✨": {
+                    "说明": {
+                        "🐍🐍🐍": None
+                    }
+                }
+            }
+            return my_dct["✨🚛✨"]["说明"]["🐍"]["说明"]["🐍🐍"]
+
+        actual = self.get_exception(f)
+        expected = [
+            f"Traceback (most recent call last):",
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            f"    callable()",
+            f"    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 8}, in f",
+            f'    return my_dct["✨🚛✨"]["说明"]["🐍"]["说明"]["🐍🐍"]',
+            f"           ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^",
+        ]
+        self.assertEqual(actual, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_memory_error(self):
+        def f():
+            raise MemoryError()
+
+        actual = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f'  File "{__file__}", line {self.callable_line}, in get_exception',
+            '    callable()',
+            '    ~~~~~~~~^^',
+            f'  File "{__file__}", line {f.__code__.co_firstlineno + 1}, in 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
+
+        def f():
+            return g()
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    return g()",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g():
+            1/0
+
+        def f():
+            return g() + 1
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    return g() + 1",
+            "           ~^^",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g(*args):
+            1/0
+
+        def f():
+            return g(1,
+                     2, 4,
+                     5)
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    return g(1,",
+            "             2, 4,",
+            "             5)",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g(*args):
+            1/0
+
+        def f():
+            return g(1,
+                     2, 4,
+                     5) + 1
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    return g(1,",
+            "           ~^^^",
+            "             2, 4,",
+            "             ^^^^^",
+            "             5) + 1",
+            "             ^^",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_anchors_for_simple_assign_statements_are_elided(self):
+        def g():
+            1/0
+
+        def f():
+            x = g()
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    x = g()",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g(*args):
+            1/0
+
+        def f():
+            x = g(1,
+                  2, 3,
+                  4)
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    x = g(1,",
+            "          2, 3,",
+            "          4)",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g():
+            1/0
+
+        def f():
+            x = y = g()
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    x = y = g()",
+            "            ~^^",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+        def g(*args):
+            1/0
+
+        def f():
+            x = y = g(1,
+                      2, 3,
+                      4)
+
+        result_lines = self.get_exception(f)
+        expected = ['Traceback (most recent call last):',
+            f"  File \"{__file__}\", line {self.callable_line}, in get_exception",
+            "    callable()",
+            "    ~~~~~~~~^^",
+            f"  File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f",
+            "    x = y = g(1,",
+            "            ~^^^",
+            "              2, 3,",
+            "              ^^^^^",
+            "              4)",
+            "              ^^",
+            f"  File \"{__file__}\", line {g.__code__.co_firstlineno + 1}, in g",
+            "    1/0",
+            "    ~^~"
+        ]
+        self.assertEqual(result_lines, expected)
+
+
+# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@force_not_colorized_test_class
+class PurePythonTracebackErrorCaretTests(
+    PurePythonExceptionFormattingMixin,
+    TracebackErrorLocationCaretTestBase,
+    unittest.TestCase,
+):
+    """
+    Same set of tests as above using the pure Python implementation of
+    traceback printing in traceback.py.
+    """
+
+
+@cpython_only
+# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@force_not_colorized_test_class
+class CPythonTracebackErrorCaretTests(
+    CAPIExceptionFormattingMixin,
+    TracebackErrorLocationCaretTestBase,
+    unittest.TestCase,
+):
+    """
+    Same set of tests as above but with Python's internal traceback printing.
+    """
+
+@cpython_only
+# @requires_debug_ranges() # XXX: RUSTPYTHON patch
+@force_not_colorized_test_class
+class CPythonTracebackLegacyErrorCaretTests(
+    CAPIExceptionFormattingLegacyMixin,
+    TracebackErrorLocationCaretTestBase,
+    unittest.TestCase,
+):
+    """
+    Same set of tests as above but with Python's legacy internal traceback printing.
+    """
+
+
+class TracebackFormatMixin:
+    DEBUG_RANGES = True
 
     def some_exception(self):
         raise KeyError('blah')
 
+    def _filter_debug_ranges(self, expected):
+        return [line for line in expected if not set(line.strip()) <= set("^~")]
+
+    def _maybe_filter_debug_ranges(self, expected):
+        if not self.DEBUG_RANGES:
+            return self._filter_debug_ranges(expected)
+        return expected
+
     @cpython_only
     def check_traceback_format(self, cleanup_func=None):
         from _testcapi import traceback_print
         try:
             self.some_exception()
-        except KeyError:
-            type_, value, tb = sys.exc_info()
+        except KeyError as e:
+            tb = e.__traceback__
             if cleanup_func is not None:
                 # Clear the inner frames, not this one
                 cleanup_func(tb.tb_next)
             traceback_fmt = 'Traceback (most recent call last):\n' + \
                             ''.join(traceback.format_tb(tb))
+            # clear caret lines from traceback_fmt since internal API does
+            # not emit them
+            traceback_fmt = "\n".join(
+                self._filter_debug_ranges(traceback_fmt.splitlines())
+            ) + "\n"
             file_ = StringIO()
             traceback_print(tb, file_)
             python_fmt  = file_.getvalue()
@@ -346,9 +1925,9 @@ def check_traceback_format(self, cleanup_func=None):
 
         # Make sure that the traceback is properly indented.
         tb_lines = python_fmt.splitlines()
-        self.assertEqual(len(tb_lines), 5)
         banner = tb_lines[0]
-        location, source_line = tb_lines[-2:]
+        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'))
@@ -412,12 +1991,16 @@ def f():
             'Traceback (most recent call last):\n'
             f'  File "{__file__}", line {lineno_f+5}, in _check_recursive_traceback_display\n'
             '    f()\n'
+            '    ~^^\n'
             f'  File "{__file__}", line {lineno_f+1}, in f\n'
             '    f()\n'
+            '    ~^^\n'
             f'  File "{__file__}", line {lineno_f+1}, in f\n'
             '    f()\n'
+            '    ~^^\n'
             f'  File "{__file__}", line {lineno_f+1}, in f\n'
             '    f()\n'
+            '    ~^^\n'
             # XXX: The following line changes depending on whether the tests
             # are run through the interactive interpreter or with -m
             # It also varies depending on the platform (stack size)
@@ -426,7 +2009,7 @@ def f():
             'RecursionError: maximum recursion depth exceeded\n'
         )
 
-        expected = result_f.splitlines()
+        expected = self._maybe_filter_debug_ranges(result_f.splitlines())
         actual = stderr_f.getvalue().splitlines()
 
         # Check the output text matches expectations
@@ -443,7 +2026,7 @@ def f():
         # Check a known (limited) number of recursive invocations
         def g(count=10):
             if count:
-                return g(count-1)
+                return g(count-1) + 1
             raise ValueError
 
         with captured_output("stderr") as stderr_g:
@@ -457,11 +2040,14 @@ def g(count=10):
         lineno_g = g.__code__.co_firstlineno
         result_g = (
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             '  [Previous line repeated 7 more times]\n'
             f'  File "{__file__}", line {lineno_g+3}, in g\n'
             '    raise ValueError\n'
@@ -471,8 +2057,9 @@ def g(count=10):
             'Traceback (most recent call last):\n'
             f'  File "{__file__}", line {lineno_g+7}, in _check_recursive_traceback_display\n'
             '    g()\n'
+            '    ~^^\n'
         )
-        expected = (tb_line + result_g).splitlines()
+        expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
         actual = stderr_g.getvalue().splitlines()
         self.assertEqual(actual, expected)
 
@@ -495,6 +2082,7 @@ def h(count=10):
             'Traceback (most recent call last):\n'
             f'  File "{__file__}", line {lineno_h+7}, in _check_recursive_traceback_display\n'
             '    h()\n'
+            '    ~^^\n'
             f'  File "{__file__}", line {lineno_h+2}, in h\n'
             '    return h(count-1)\n'
             f'  File "{__file__}", line {lineno_h+2}, in h\n'
@@ -504,8 +2092,9 @@ def h(count=10):
             '  [Previous line repeated 7 more times]\n'
             f'  File "{__file__}", line {lineno_h+3}, in h\n'
             '    g()\n'
+            '    ~^^\n'
         )
-        expected = (result_h + result_g).splitlines()
+        expected = self._maybe_filter_debug_ranges((result_h + result_g).splitlines())
         actual = stderr_h.getvalue().splitlines()
         self.assertEqual(actual, expected)
 
@@ -519,21 +2108,25 @@ def h(count=10):
                 self.fail("no error raised")
         result_g = (
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+3}, in g\n'
             '    raise ValueError\n'
             'ValueError\n'
         )
         tb_line = (
             'Traceback (most recent call last):\n'
-            f'  File "{__file__}", line {lineno_g+71}, in _check_recursive_traceback_display\n'
+            f'  File "{__file__}", line {lineno_g+77}, in _check_recursive_traceback_display\n'
             '    g(traceback._RECURSIVE_CUTOFF)\n'
+            '    ~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
         )
-        expected = (tb_line + result_g).splitlines()
+        expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
         actual = stderr_g.getvalue().splitlines()
         self.assertEqual(actual, expected)
 
@@ -547,11 +2140,14 @@ def h(count=10):
                 self.fail("no error raised")
         result_g = (
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             f'  File "{__file__}", line {lineno_g+2}, in g\n'
-            '    return g(count-1)\n'
+            '    return g(count-1) + 1\n'
+            '           ~^^^^^^^^^\n'
             '  [Previous line repeated 1 more time]\n'
             f'  File "{__file__}", line {lineno_g+3}, in g\n'
             '    raise ValueError\n'
@@ -559,23 +2155,25 @@ def h(count=10):
         )
         tb_line = (
             'Traceback (most recent call last):\n'
-            f'  File "{__file__}", line {lineno_g+99}, in _check_recursive_traceback_display\n'
+            f'  File "{__file__}", line {lineno_g+109}, in _check_recursive_traceback_display\n'
             '    g(traceback._RECURSIVE_CUTOFF + 1)\n'
+            '    ~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'
         )
-        expected = (tb_line + result_g).splitlines()
+        expected = self._maybe_filter_debug_ranges((tb_line + result_g).splitlines())
         actual = stderr_g.getvalue().splitlines()
         self.assertEqual(actual, expected)
 
-    def test_recursive_traceback_python(self):
-        self._check_recursive_traceback_display(traceback.print_exc)
-
-    @cpython_only
-    def test_recursive_traceback_cpython_internal(self):
-        from _testcapi import exception_print
-        def render_exc():
-            exc_type, exc_value, exc_tb = sys.exc_info()
-            exception_print(exc_value)
-        self._check_recursive_traceback_display(render_exc)
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    # @requires_debug_ranges() # XXX: RUSTPYTHON patch
+    def test_recursive_traceback(self):
+        if self.DEBUG_RANGES:
+            self._check_recursive_traceback_display(traceback.print_exc)
+        else:
+            from _testcapi import exception_print
+            def render_exc():
+                exception_print(sys.exception())
+            self._check_recursive_traceback_display(render_exc)
 
     def test_format_stack(self):
         def fmt():
@@ -604,8 +2202,8 @@ def __eq__(self, other):
         except UnhashableException:
             try:
                 raise ex1
-            except UnhashableException:
-                exc_type, exc_val, exc_tb = sys.exc_info()
+            except UnhashableException as e:
+                exc_val = e
 
         with captured_output("stderr") as stderr_f:
             exception_print(exc_val)
@@ -616,6 +2214,51 @@ def __eq__(self, other):
         self.assertIn('UnhashableException: ex2', tb[3])
         self.assertIn('UnhashableException: ex1', tb[10])
 
+    def deep_eg(self):
+        e = TypeError(1)
+        for i in range(2000):
+            e = ExceptionGroup('eg', [e])
+        return e
+
+    @cpython_only
+    def test_exception_group_deep_recursion_capi(self):
+        from _testcapi import exception_print
+        LIMIT = 75
+        eg = self.deep_eg()
+        with captured_output("stderr") as stderr_f:
+            with support.infinite_recursion(max_depth=LIMIT):
+                exception_print(eg)
+        output = stderr_f.getvalue()
+        self.assertIn('ExceptionGroup', output)
+        self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
+
+    def test_exception_group_deep_recursion_traceback(self):
+        LIMIT = 75
+        eg = self.deep_eg()
+        with captured_output("stderr") as stderr_f:
+            with support.infinite_recursion(max_depth=LIMIT):
+                traceback.print_exception(type(eg), eg, eg.__traceback__)
+        output = stderr_f.getvalue()
+        self.assertIn('ExceptionGroup', output)
+        self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
+
+    @cpython_only
+    def test_print_exception_bad_type_capi(self):
+        from _testcapi import exception_print
+        with captured_output("stderr") as stderr:
+            with support.catch_unraisable_exception():
+                exception_print(42)
+        self.assertEqual(
+            stderr.getvalue(),
+            ('TypeError: print_exception(): '
+             'Exception expected for value, int found\n')
+        )
+
+    def test_print_exception_bad_type_python(self):
+        msg = "Exception expected for value, int found"
+        with self.assertRaisesRegex(TypeError, msg):
+            traceback.print_exception(42)
+
 
 cause_message = (
     "\nThe above exception was the direct cause "
@@ -628,24 +2271,49 @@ def __eq__(self, other):
 boundaries = re.compile(
     '(%s|%s)' % (re.escape(cause_message), re.escape(context_message)))
 
+@force_not_colorized_test_class
+class TestTracebackFormat(unittest.TestCase, TracebackFormatMixin):
+    pass
+
+@cpython_only
+@force_not_colorized_test_class
+class TestFallbackTracebackFormat(unittest.TestCase, TracebackFormatMixin):
+    DEBUG_RANGES = False
+    def setUp(self) -> None:
+        self.original_unraisable_hook = sys.unraisablehook
+        sys.unraisablehook = lambda *args: None
+        self.original_hook = traceback._print_exception_bltin
+        traceback._print_exception_bltin = lambda *args: 1/0
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        traceback._print_exception_bltin = self.original_hook
+        sys.unraisablehook = self.original_unraisable_hook
+        return super().tearDown()
 
 class BaseExceptionReportingTests:
 
     def get_exception(self, exception_or_callable):
-        if isinstance(exception_or_callable, Exception):
+        if isinstance(exception_or_callable, BaseException):
             return exception_or_callable
         try:
             exception_or_callable()
         except Exception as e:
             return e
 
+    callable_line = get_exception.__code__.co_firstlineno + 4
+
     def zero_div(self):
         1/0 # In zero_div
 
     def check_zero_div(self, msg):
         lines = msg.splitlines()
-        self.assertTrue(lines[-3].startswith('  File'))
-        self.assertIn('1/0 # In zero_div', lines[-2])
+        if has_no_debug_ranges():
+            self.assertTrue(lines[-3].startswith('  File'))
+            self.assertIn('1/0 # In zero_div', lines[-2])
+        else:
+            self.assertTrue(lines[-4].startswith('  File'))
+            self.assertIn('1/0 # In zero_div', lines[-3])
         self.assertTrue(lines[-1].startswith('ZeroDivisionError'), lines[-1])
 
     def test_simple(self):
@@ -654,11 +2322,15 @@ def test_simple(self):
         except ZeroDivisionError as _:
             e = _
         lines = self.get_report(e).splitlines()
-        self.assertEqual(len(lines), 4)
+        if has_no_debug_ranges():
+            self.assertEqual(len(lines), 4)
+            self.assertTrue(lines[3].startswith('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.assertIn('1/0 # Marker', lines[2])
-        self.assertTrue(lines[3].startswith('ZeroDivisionError'))
 
     def test_cause(self):
         def inner_raise():
@@ -692,16 +2364,16 @@ def test_context_suppression(self):
         try:
             try:
                 raise Exception
-            except:
+            except Exception:
                 raise ZeroDivisionError from None
         except ZeroDivisionError as _:
             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.assertIn('ZeroDivisionError from None', lines[2])
-        self.assertTrue(lines[3].startswith('ZeroDivisionError'))
 
     def test_cause_and_context(self):
         # When both a cause and a context are set, only the cause should be
@@ -793,50 +2465,647 @@ def test_message_none(self):
         err = self.get_report(Exception(''))
         self.assertIn('Exception\n', err)
 
-    def test_exception_modulename_not_unicode(self):
-        class X(Exception):
-            def __str__(self):
-                return "I am X"
-
-        X.__module__ = 42
-
-        err = self.get_report(X())
-        exp = f'<unknown>.{X.__qualname__}: I am X\n'
-        self.assertEqual(exp, err)
-
     def test_syntax_error_various_offsets(self):
         for offset in range(-5, 10):
             for add in [0, 2]:
-                text = " "*add + "text%d" % offset
+                text = " " * add + "text%d" % offset
                 expected = ['  File "file.py", line 1']
                 if offset < 1:
                     expected.append("    %s" % text.lstrip())
                 elif offset <= 6:
                     expected.append("    %s" % text.lstrip())
-                    expected.append("    %s^" % (" "*(offset-1)))
+                    # Set the caret length to match the length of the text minus the offset.
+                    caret_length = max(1, len(text.lstrip()) - offset + 1)
+                    expected.append("    %s%s" % (" " * (offset - 1), "^" * caret_length))
                 else:
+                    caret_length = max(1, len(text.lstrip()) - 4)
                     expected.append("    %s" % text.lstrip())
-                    expected.append("    %s^" % (" "*5))
+                    expected.append("    %s%s" % (" " * 5, "^" * caret_length))
                 expected.append("SyntaxError: msg")
                 expected.append("")
-                err = self.get_report(SyntaxError("msg", ("file.py", 1, offset+add, text)))
+                err = self.get_report(SyntaxError("msg", ("file.py", 1, offset + add, text)))
                 exp = "\n".join(expected)
                 self.assertEqual(exp, err)
 
-    def test_format_exception_only_qualname(self):
-        class A:
-            class B:
-                class X(Exception):
-                    def __str__(self):
-                        return "I am X"
-                    pass
-        err = self.get_report(A.B.X())
-        str_value = 'I am X'
-        str_name = '.'.join([A.B.X.__module__, A.B.X.__qualname__])
-        exp = "%s: %s\n" % (str_name, str_value)
-        self.assertEqual(exp, err)
+    def test_exception_with_note(self):
+        e = ValueError(123)
+        vanilla = self.get_report(e)
+
+        e.add_note('My Note')
+        self.assertEqual(self.get_report(e), vanilla + 'My Note\n')
+
+        del e.__notes__
+        e.add_note('')
+        self.assertEqual(self.get_report(e), vanilla + '\n')
+
+        del e.__notes__
+        e.add_note('Your Note')
+        self.assertEqual(self.get_report(e), vanilla + 'Your Note\n')
+
+        del e.__notes__
+        self.assertEqual(self.get_report(e), vanilla)
+
+    def test_exception_with_invalid_notes(self):
+        e = ValueError(123)
+        vanilla = self.get_report(e)
+
+        # non-sequence __notes__
+        class BadThing:
+            def __str__(self):
+                return 'bad str'
+
+            def __repr__(self):
+                return 'bad repr'
+
+        # unprintable, non-sequence __notes__
+        class Unprintable:
+            def __repr__(self):
+                raise ValueError('bad value')
+
+        e.__notes__ = BadThing()
+        notes_repr = 'bad repr'
+        self.assertEqual(self.get_report(e), vanilla + notes_repr + '\n')
+
+        e.__notes__ = Unprintable()
+        err_msg = '<__notes__ repr() failed>'
+        self.assertEqual(self.get_report(e), vanilla + err_msg + '\n')
+
+        # non-string item in the __notes__ sequence
+        e.__notes__  = [BadThing(), 'Final Note']
+        bad_note = 'bad str'
+        self.assertEqual(self.get_report(e), vanilla + bad_note + '\nFinal Note\n')
+
+        # unprintable, non-string item in the __notes__ sequence
+        e.__notes__  = [Unprintable(), 'Final Note']
+        err_msg = '<note str() failed>'
+        self.assertEqual(self.get_report(e), vanilla + err_msg + '\nFinal Note\n')
+
+        e.__notes__  = "please do not explode me"
+        err_msg = "'please do not explode me'"
+        self.assertEqual(self.get_report(e), vanilla + err_msg + '\n')
+
+        e.__notes__  = b"please do not show me as numbers"
+        err_msg = "b'please do not show me as numbers'"
+        self.assertEqual(self.get_report(e), vanilla + err_msg + '\n')
+
+        # an exception with a broken __getattr__ raising a non expected error
+        class BrokenException(Exception):
+            broken = False
+            def __getattr__(self, name):
+                if self.broken:
+                    raise ValueError(f'no {name}')
+
+        e = BrokenException(123)
+        vanilla = self.get_report(e)
+        e.broken = True
+        self.assertEqual(
+            self.get_report(e),
+            vanilla + "Ignored error getting __notes__: ValueError('no __notes__')\n")
+
+    def test_exception_with_multiple_notes(self):
+        for e in [ValueError(42), SyntaxError('bad syntax')]:
+            with self.subTest(e=e):
+                vanilla = self.get_report(e)
+
+                e.add_note('Note 1')
+                e.add_note('Note 2')
+                e.add_note('Note 3')
+
+                self.assertEqual(
+                    self.get_report(e),
+                    vanilla + 'Note 1\n' + 'Note 2\n' + 'Note 3\n')
+
+                del e.__notes__
+                e.add_note('Note 4')
+                del e.__notes__
+                e.add_note('Note 5')
+                e.add_note('Note 6')
+
+                self.assertEqual(
+                    self.get_report(e),
+                    vanilla + 'Note 5\n' + 'Note 6\n')
+
+    def test_exception_qualname(self):
+        class A:
+            class B:
+                class X(Exception):
+                    def __str__(self):
+                        return "I am X"
+
+        err = self.get_report(A.B.X())
+        str_value = 'I am X'
+        str_name = '.'.join([A.B.X.__module__, A.B.X.__qualname__])
+        exp = "%s: %s\n" % (str_name, str_value)
+        self.assertEqual(exp, MODULE_PREFIX + err)
+
+    def test_exception_modulename(self):
+        class X(Exception):
+            def __str__(self):
+                return "I am X"
+
+        for modulename in '__main__', 'builtins', 'some_module':
+            X.__module__ = modulename
+            with self.subTest(modulename=modulename):
+                err = self.get_report(X())
+                str_value = 'I am X'
+                if modulename in ['builtins', '__main__']:
+                    str_name = X.__qualname__
+                else:
+                    str_name = '.'.join([X.__module__, X.__qualname__])
+                exp = "%s: %s\n" % (str_name, str_value)
+                self.assertEqual(exp, err)
+
+    def test_exception_angle_bracketed_filename(self):
+        src = textwrap.dedent("""
+            try:
+                raise ValueError(42)
+            except Exception as e:
+                exc = e
+            """)
+
+        code = compile(src, "<does not exist>", "exec")
+        g, l = {}, {}
+        exec(code, g, l)
+        err = self.get_report(l['exc'])
+        exp = '  File "<does not exist>", line 3, in <module>\nValueError: 42\n'
+        self.assertIn(exp, err)
+
+    def test_exception_modulename_not_unicode(self):
+        class X(Exception):
+            def __str__(self):
+                return "I am X"
+
+        X.__module__ = 42
+
+        err = self.get_report(X())
+        exp = f'<unknown>.{X.__qualname__}: I am X\n'
+        self.assertEqual(exp, err)
+
+    def test_exception_bad__str__(self):
+        class X(Exception):
+            def __str__(self):
+                1/0
+        err = self.get_report(X())
+        str_value = '<exception str() failed>'
+        str_name = '.'.join([X.__module__, X.__qualname__])
+        self.assertEqual(MODULE_PREFIX + err, f"{str_name}: {str_value}\n")
+
+
+    # #### Exception Groups ####
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_basic(self):
+        def exc():
+            raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])
+
+        expected = (
+             f'  + Exception Group Traceback (most recent call last):\n'
+             f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+             f'  |     exception_or_callable()\n'
+             f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+             f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n'
+             f'  |     raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n'
+             f'  | ExceptionGroup: eg (2 sub-exceptions)\n'
+             f'  +-+---------------- 1 ----------------\n'
+             f'    | ValueError: 1\n'
+             f'    +---------------- 2 ----------------\n'
+             f'    | TypeError: 2\n'
+             f'    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_cause(self):
+        def exc():
+            EG = ExceptionGroup
+            try:
+                raise EG("eg1", [ValueError(1), TypeError(2)])
+            except Exception as e:
+                raise EG("eg2", [ValueError(3), TypeError(4)]) from e
+
+        expected = (f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 3}, in exc\n'
+                    f'  |     raise EG("eg1", [ValueError(1), TypeError(2)])\n'
+                    f'  | ExceptionGroup: eg1 (2 sub-exceptions)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | ValueError: 1\n'
+                    f'    +---------------- 2 ----------------\n'
+                    f'    | TypeError: 2\n'
+                    f'    +------------------------------------\n'
+                    f'\n'
+                    f'The above exception was the direct cause of the following exception:\n'
+                    f'\n'
+                    f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+                    f'  |     exception_or_callable()\n'
+                    f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
+                    f'  |     raise EG("eg2", [ValueError(3), TypeError(4)]) from e\n'
+                    f'  | ExceptionGroup: eg2 (2 sub-exceptions)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | ValueError: 3\n'
+                    f'    +---------------- 2 ----------------\n'
+                    f'    | TypeError: 4\n'
+                    f'    +------------------------------------\n')
+
+        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
+            try:
+                try:
+                    raise EG("eg1", [ValueError(1), TypeError(2)])
+                except EG:
+                    raise EG("eg2", [ValueError(3), TypeError(4)])
+            except EG:
+                raise ImportError(5)
+
+        expected = (
+             f'  + Exception Group Traceback (most recent call last):\n'
+             f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 4}, in exc\n'
+             f'  |     raise EG("eg1", [ValueError(1), TypeError(2)])\n'
+             f'  | ExceptionGroup: eg1 (2 sub-exceptions)\n'
+             f'  +-+---------------- 1 ----------------\n'
+             f'    | ValueError: 1\n'
+             f'    +---------------- 2 ----------------\n'
+             f'    | TypeError: 2\n'
+             f'    +------------------------------------\n'
+             f'\n'
+             f'During handling of the above exception, another exception occurred:\n'
+             f'\n'
+             f'  + Exception Group Traceback (most recent call last):\n'
+             f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 6}, in exc\n'
+             f'  |     raise EG("eg2", [ValueError(3), TypeError(4)])\n'
+             f'  | ExceptionGroup: eg2 (2 sub-exceptions)\n'
+             f'  +-+---------------- 1 ----------------\n'
+             f'    | ValueError: 3\n'
+             f'    +---------------- 2 ----------------\n'
+             f'    | TypeError: 4\n'
+             f'    +------------------------------------\n'
+             f'\n'
+             f'During handling of the above exception, another exception occurred:\n'
+             f'\n'
+             f'Traceback (most recent call last):\n'
+             f'  File "{__file__}", line {self.callable_line}, in get_exception\n'
+             f'    exception_or_callable()\n'
+             f'    ~~~~~~~~~~~~~~~~~~~~~^^\n'
+             f'  File "{__file__}", line {exc.__code__.co_firstlineno + 8}, in exc\n'
+             f'    raise ImportError(5)\n'
+             f'ImportError: 5\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_nested(self):
+        def exc():
+            EG = ExceptionGroup
+            VE = ValueError
+            TE = TypeError
+            try:
+                try:
+                    raise EG("nested", [TE(2), TE(3)])
+                except Exception as e:
+                    exc = e
+                raise EG("eg", [VE(1), exc, VE(4)])
+            except EG:
+                raise EG("top", [VE(5)])
+
+        expected = (f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 9}, in exc\n'
+                    f'  |     raise EG("eg", [VE(1), exc, VE(4)])\n'
+                    f'  | ExceptionGroup: eg (3 sub-exceptions)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | ValueError: 1\n'
+                    f'    +---------------- 2 ----------------\n'
+                    f'    | Exception Group Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 6}, in exc\n'
+                    f'    |     raise EG("nested", [TE(2), TE(3)])\n'
+                    f'    | ExceptionGroup: nested (2 sub-exceptions)\n'
+                    f'    +-+---------------- 1 ----------------\n'
+                    f'      | TypeError: 2\n'
+                    f'      +---------------- 2 ----------------\n'
+                    f'      | TypeError: 3\n'
+                    f'      +------------------------------------\n'
+                    f'    +---------------- 3 ----------------\n'
+                    f'    | ValueError: 4\n'
+                    f'    +------------------------------------\n'
+                    f'\n'
+                    f'During handling of the above exception, another exception occurred:\n'
+                    f'\n'
+                    f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+                    f'  |     exception_or_callable()\n'
+                    f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 11}, in exc\n'
+                    f'  |     raise EG("top", [VE(5)])\n'
+                    f'  | ExceptionGroup: top (1 sub-exception)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | ValueError: 5\n'
+                    f'    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    def test_exception_group_width_limit(self):
+        excs = []
+        for i in range(1000):
+            excs.append(ValueError(i))
+        eg = ExceptionGroup('eg', excs)
+
+        expected = ('  | ExceptionGroup: eg (1000 sub-exceptions)\n'
+                    '  +-+---------------- 1 ----------------\n'
+                    '    | ValueError: 0\n'
+                    '    +---------------- 2 ----------------\n'
+                    '    | ValueError: 1\n'
+                    '    +---------------- 3 ----------------\n'
+                    '    | ValueError: 2\n'
+                    '    +---------------- 4 ----------------\n'
+                    '    | ValueError: 3\n'
+                    '    +---------------- 5 ----------------\n'
+                    '    | ValueError: 4\n'
+                    '    +---------------- 6 ----------------\n'
+                    '    | ValueError: 5\n'
+                    '    +---------------- 7 ----------------\n'
+                    '    | ValueError: 6\n'
+                    '    +---------------- 8 ----------------\n'
+                    '    | ValueError: 7\n'
+                    '    +---------------- 9 ----------------\n'
+                    '    | ValueError: 8\n'
+                    '    +---------------- 10 ----------------\n'
+                    '    | ValueError: 9\n'
+                    '    +---------------- 11 ----------------\n'
+                    '    | ValueError: 10\n'
+                    '    +---------------- 12 ----------------\n'
+                    '    | ValueError: 11\n'
+                    '    +---------------- 13 ----------------\n'
+                    '    | ValueError: 12\n'
+                    '    +---------------- 14 ----------------\n'
+                    '    | ValueError: 13\n'
+                    '    +---------------- 15 ----------------\n'
+                    '    | ValueError: 14\n'
+                    '    +---------------- ... ----------------\n'
+                    '    | and 985 more exceptions\n'
+                    '    +------------------------------------\n')
+
+        report = self.get_report(eg)
+        self.assertEqual(report, expected)
+
+    def test_exception_group_depth_limit(self):
+        exc = TypeError('bad type')
+        for i in range(1000):
+            exc = ExceptionGroup(
+                f'eg{i}',
+                [ValueError(i), exc, ValueError(-i)])
+
+        expected = ('  | ExceptionGroup: eg999 (3 sub-exceptions)\n'
+                    '  +-+---------------- 1 ----------------\n'
+                    '    | ValueError: 999\n'
+                    '    +---------------- 2 ----------------\n'
+                    '    | ExceptionGroup: eg998 (3 sub-exceptions)\n'
+                    '    +-+---------------- 1 ----------------\n'
+                    '      | ValueError: 998\n'
+                    '      +---------------- 2 ----------------\n'
+                    '      | ExceptionGroup: eg997 (3 sub-exceptions)\n'
+                    '      +-+---------------- 1 ----------------\n'
+                    '        | ValueError: 997\n'
+                    '        +---------------- 2 ----------------\n'
+                    '        | ExceptionGroup: eg996 (3 sub-exceptions)\n'
+                    '        +-+---------------- 1 ----------------\n'
+                    '          | ValueError: 996\n'
+                    '          +---------------- 2 ----------------\n'
+                    '          | ExceptionGroup: eg995 (3 sub-exceptions)\n'
+                    '          +-+---------------- 1 ----------------\n'
+                    '            | ValueError: 995\n'
+                    '            +---------------- 2 ----------------\n'
+                    '            | ExceptionGroup: eg994 (3 sub-exceptions)\n'
+                    '            +-+---------------- 1 ----------------\n'
+                    '              | ValueError: 994\n'
+                    '              +---------------- 2 ----------------\n'
+                    '              | ExceptionGroup: eg993 (3 sub-exceptions)\n'
+                    '              +-+---------------- 1 ----------------\n'
+                    '                | ValueError: 993\n'
+                    '                +---------------- 2 ----------------\n'
+                    '                | ExceptionGroup: eg992 (3 sub-exceptions)\n'
+                    '                +-+---------------- 1 ----------------\n'
+                    '                  | ValueError: 992\n'
+                    '                  +---------------- 2 ----------------\n'
+                    '                  | ExceptionGroup: eg991 (3 sub-exceptions)\n'
+                    '                  +-+---------------- 1 ----------------\n'
+                    '                    | ValueError: 991\n'
+                    '                    +---------------- 2 ----------------\n'
+                    '                    | ExceptionGroup: eg990 (3 sub-exceptions)\n'
+                    '                    +-+---------------- 1 ----------------\n'
+                    '                      | ValueError: 990\n'
+                    '                      +---------------- 2 ----------------\n'
+                    '                      | ... (max_group_depth is 10)\n'
+                    '                      +---------------- 3 ----------------\n'
+                    '                      | ValueError: -990\n'
+                    '                      +------------------------------------\n'
+                    '                    +---------------- 3 ----------------\n'
+                    '                    | ValueError: -991\n'
+                    '                    +------------------------------------\n'
+                    '                  +---------------- 3 ----------------\n'
+                    '                  | ValueError: -992\n'
+                    '                  +------------------------------------\n'
+                    '                +---------------- 3 ----------------\n'
+                    '                | ValueError: -993\n'
+                    '                +------------------------------------\n'
+                    '              +---------------- 3 ----------------\n'
+                    '              | ValueError: -994\n'
+                    '              +------------------------------------\n'
+                    '            +---------------- 3 ----------------\n'
+                    '            | ValueError: -995\n'
+                    '            +------------------------------------\n'
+                    '          +---------------- 3 ----------------\n'
+                    '          | ValueError: -996\n'
+                    '          +------------------------------------\n'
+                    '        +---------------- 3 ----------------\n'
+                    '        | ValueError: -997\n'
+                    '        +------------------------------------\n'
+                    '      +---------------- 3 ----------------\n'
+                    '      | ValueError: -998\n'
+                    '      +------------------------------------\n'
+                    '    +---------------- 3 ----------------\n'
+                    '    | ValueError: -999\n'
+                    '    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_with_notes(self):
+        def exc():
+            try:
+                excs = []
+                for msg in ['bad value', 'terrible value']:
+                    try:
+                        raise ValueError(msg)
+                    except ValueError as e:
+                        e.add_note(f'the {msg}')
+                        excs.append(e)
+                raise ExceptionGroup("nested", excs)
+            except ExceptionGroup as e:
+                e.add_note(('>> Multi line note\n'
+                            '>> Because I am such\n'
+                            '>> an important exception.\n'
+                            '>> empty lines work too\n'
+                            '\n'
+                            '(that was an empty line)'))
+                raise
+
+        expected = (f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+                    f'  |     exception_or_callable()\n'
+                    f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 9}, in exc\n'
+                    f'  |     raise ExceptionGroup("nested", excs)\n'
+                    f'  | ExceptionGroup: nested (2 sub-exceptions)\n'
+                    f'  | >> Multi line note\n'
+                    f'  | >> Because I am such\n'
+                    f'  | >> an important exception.\n'
+                    f'  | >> empty lines work too\n'
+                    f'  | \n'
+                    f'  | (that was an empty line)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
+                    f'    |     raise ValueError(msg)\n'
+                    f'    | ValueError: bad value\n'
+                    f'    | the bad value\n'
+                    f'    +---------------- 2 ----------------\n'
+                    f'    | Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
+                    f'    |     raise ValueError(msg)\n'
+                    f'    | ValueError: terrible value\n'
+                    f'    | the terrible value\n'
+                    f'    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_with_multiple_notes(self):
+        def exc():
+            try:
+                excs = []
+                for msg in ['bad value', 'terrible value']:
+                    try:
+                        raise ValueError(msg)
+                    except ValueError as e:
+                        e.add_note(f'the {msg}')
+                        e.add_note(f'Goodbye {msg}')
+                        excs.append(e)
+                raise ExceptionGroup("nested", excs)
+            except ExceptionGroup as e:
+                e.add_note(('>> Multi line note\n'
+                            '>> Because I am such\n'
+                            '>> an important exception.\n'
+                            '>> empty lines work too\n'
+                            '\n'
+                            '(that was an empty line)'))
+                e.add_note('Goodbye!')
+                raise
+
+        expected = (f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+                    f'  |     exception_or_callable()\n'
+                    f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 10}, in exc\n'
+                    f'  |     raise ExceptionGroup("nested", excs)\n'
+                    f'  | ExceptionGroup: nested (2 sub-exceptions)\n'
+                    f'  | >> Multi line note\n'
+                    f'  | >> Because I am such\n'
+                    f'  | >> an important exception.\n'
+                    f'  | >> empty lines work too\n'
+                    f'  | \n'
+                    f'  | (that was an empty line)\n'
+                    f'  | Goodbye!\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
+                    f'    |     raise ValueError(msg)\n'
+                    f'    | ValueError: bad value\n'
+                    f'    | the bad value\n'
+                    f'    | Goodbye bad value\n'
+                    f'    +---------------- 2 ----------------\n'
+                    f'    | Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n'
+                    f'    |     raise ValueError(msg)\n'
+                    f'    | ValueError: terrible value\n'
+                    f'    | the terrible value\n'
+                    f'    | Goodbye terrible value\n'
+                    f'    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
 
+    # TODO: RUSTPYTHON
+    '''
+    def test_exception_group_wrapped_naked(self):
+        # See gh-128799
+
+        def exc():
+            try:
+                raise Exception(42)
+            except* Exception as e:
+                raise
 
+        expected = (f'  + Exception Group Traceback (most recent call last):\n'
+                    f'  |   File "{__file__}", line {self.callable_line}, in get_exception\n'
+                    f'  |     exception_or_callable()\n'
+                    f'  |     ~~~~~~~~~~~~~~~~~~~~~^^\n'
+                    f'  |   File "{__file__}", line {exc.__code__.co_firstlineno + 3}, in exc\n'
+                    f'  |     except* Exception as e:\n'
+                    f'  |         raise\n'
+                    f'  | ExceptionGroup:  (1 sub-exception)\n'
+                    f'  +-+---------------- 1 ----------------\n'
+                    f'    | Traceback (most recent call last):\n'
+                    f'    |   File "{__file__}", line {exc.__code__.co_firstlineno + 2}, in exc\n'
+                    f'    |     raise Exception(42)\n'
+                    f'    | Exception: 42\n'
+                    f'    +------------------------------------\n')
+
+        report = self.get_report(exc)
+        self.assertEqual(report, expected)
+
+    def test_KeyboardInterrupt_at_first_line_of_frame(self):
+        # see GH-93249
+        def f():
+            return sys._getframe()
+
+        tb_next = None
+        frame = f()
+        lasti = 0
+        lineno = f.__code__.co_firstlineno
+        tb = types.TracebackType(tb_next, frame, lasti, lineno)
+
+        exc = KeyboardInterrupt()
+        exc.__traceback__ = tb
+
+        expected = (f'Traceback (most recent call last):\n'
+                    f'  File "{__file__}", line {lineno}, in f\n'
+                    f'    def f():\n'
+                    f'\n'
+                    f'KeyboardInterrupt\n')
+
+        report = self.get_report(exc)
+        # 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):
     #
     # This checks reporting through the 'traceback' module, with both
@@ -853,6 +3122,7 @@ def get_report(self, e):
         return s
 
 
+@force_not_colorized_test_class
 class CExcReportingTests(BaseExceptionReportingTests, unittest.TestCase):
     #
     # This checks built-in reporting by the interpreter.
@@ -935,8 +3205,8 @@ def assertEqualExcept(actual, expected, ignore):
     def test_extract_tb(self):
         try:
             self.last_raises5()
-        except Exception:
-            exc_type, exc_value, tb = sys.exc_info()
+        except Exception as e:
+            tb = e.__traceback__
         def extract(**kwargs):
             return traceback.extract_tb(tb, **kwargs)
 
@@ -962,12 +3232,12 @@ def extract(**kwargs):
     def test_format_exception(self):
         try:
             self.last_raises5()
-        except Exception:
-            exc_type, exc_value, tb = sys.exc_info()
+        except Exception as e:
+            exc = e
         # [1:-1] to exclude "Traceback (...)" header and
         # exception type and value
         def extract(**kwargs):
-            return traceback.format_exception(exc_type, exc_value, tb, **kwargs)[1:-1]
+            return traceback.format_exception(exc, **kwargs)[1:-1]
 
         with support.swap_attr(sys, 'tracebacklimit', 1000):
             nolim = extract()
@@ -1007,8 +3277,8 @@ def inner():
 
         try:
             outer()
-        except:
-            type_, value, tb = sys.exc_info()
+        except BaseException as e:
+            tb = e.__traceback__
 
         # Initial assertion: there's one local in the inner frame.
         inner_frame = tb.tb_next.tb_next.tb_next.tb_frame
@@ -1054,7 +3324,7 @@ def test_basics(self):
     def test_lazy_lines(self):
         linecache.clearcache()
         f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False)
-        self.assertEqual(None, f._line)
+        self.assertEqual(None, f._lines)
         linecache.lazycache("f", globals())
         self.assertEqual(
             '"""Test cases for traceback module"""',
@@ -1086,8 +3356,8 @@ def deeper():
     def test_walk_tb(self):
         try:
             1/0
-        except Exception:
-            _, _, tb = sys.exc_info()
+        except Exception as e:
+            tb = e.__traceback__
         s = list(traceback.walk_tb(tb))
         self.assertEqual(len(s), 1)
 
@@ -1171,22 +3441,136 @@ def some_inner(k, v):
              '    v = 4\n' % (__file__, some_inner.__code__.co_firstlineno + 3)
             ], s.format())
 
-class TestTracebackException(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_custom_format_frame(self):
+        class CustomStackSummary(traceback.StackSummary):
+            def format_frame_summary(self, frame_summary, colorize=False):
+                return f'{frame_summary.filename}:{frame_summary.lineno}'
 
-    def test_smoke(self):
-        try:
+        def some_inner():
+            return CustomStackSummary.extract(
+                traceback.walk_stack(None), limit=1)
+
+        s = some_inner()
+        self.assertEqual(
+            s.format(),
+            [f'{__file__}:{some_inner.__code__.co_firstlineno + 1}'])
+
+    def test_dropping_frames(self):
+        def f():
             1/0
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info)
+
+        def g():
+            try:
+                f()
+            except Exception as e:
+                return e.__traceback__
+
+        tb = g()
+
+        class Skip_G(traceback.StackSummary):
+            def format_frame_summary(self, frame_summary, colorize=False):
+                if frame_summary.name == 'g':
+                    return None
+                return super().format_frame_summary(frame_summary)
+
+        stack = Skip_G.extract(
+            traceback.walk_tb(tb)).format()
+
+        self.assertEqual(len(stack), 1)
+        lno = f.__code__.co_firstlineno + 1
+        self.assertEqual(
+            stack[0],
+            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
+
+        # statement to execute and to get a ZeroDivisionError for a traceback
+        statement = "abcdef = 1 / 0 and 2.0"
+        colno = statement.index('1 / 0')
+        end_colno = colno + len('1 / 0')
+
+        # Actual line to use when rendering the traceback
+        # and whose AST will be extracted (it will be empty).
+        cached_line = '# this line will be used during rendering'
+        self.addCleanup(unlink, TESTFN)
+        with open(TESTFN, "w") as file:
+            file.write(cached_line)
+        linecache.updatecache(TESTFN, {})
+
+        try:
+            exec(compile(statement, TESTFN, "exec"))
+        except ZeroDivisionError as exc:
+            # This is the simplest way to create a StackSummary
+            # whose FrameSummary items have their column offsets.
+            s = traceback.TracebackException.from_exception(exc).stack
+            self.assertIsInstance(s, traceback.StackSummary)
+            with unittest.mock.patch.object(s, '_should_show_carets',
+                                            wraps=s._should_show_carets) as ff:
+                self.assertEqual(len(s), 2)
+                self.assertListEqual(
+                    s.format_frame_summary(s[1]).splitlines(),
+                    [
+                        f'  File "{TESTFN}", line 1, in <module>',
+                        f'    {cached_line}'
+                     ]
+                )
+                ff.assert_called_with(colno, end_colno, [cached_line], None)
+
+class Unrepresentable:
+    def __repr__(self) -> str:
+        raise Exception("Unrepresentable")
+
+
+# Used in test_dont_swallow_cause_or_context_of_falsey_exception and
+# test_dont_swallow_subexceptions_of_falsey_exceptiongroup.
+class FalseyException(Exception):
+    def __bool__(self):
+        return False
+
+
+class FalseyExceptionGroup(ExceptionGroup):
+    def __bool__(self):
+        return False
+
+
+class TestTracebackException(unittest.TestCase):
+    def do_test_smoke(self, exc, expected_type_str):
+        try:
+            raise exc
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(e)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]))
+                traceback.walk_tb(e.__traceback__))
         self.assertEqual(None, exc.__cause__)
         self.assertEqual(None, exc.__context__)
         self.assertEqual(False, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(expected_type_str, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
+
+    def test_smoke_builtin(self):
+        self.do_test_smoke(ValueError(42), 'ValueError')
+
+    def test_smoke_user_exception(self):
+        class MyException(Exception):
+            pass
+
+        if __name__ == '__main__':
+            expected = ('TestTracebackException.'
+                        'test_smoke_user_exception.<locals>.MyException')
+        else:
+            expected = ('test.test_traceback.TestTracebackException.'
+                        'test_smoke_user_exception.<locals>.MyException')
+        self.do_test_smoke(MyException('bad things happened'), expected)
 
     def test_from_exception(self):
         # Check all the parameters are accepted.
@@ -1195,9 +3579,10 @@ def foo():
         try:
             foo()
         except Exception as e:
-            exc_info = sys.exc_info()
+            exc_obj = e
+            tb = e.__traceback__
             self.expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]), limit=1, lookup_lines=False,
+                traceback.walk_tb(tb), limit=1, lookup_lines=False,
                 capture_locals=True)
             self.exc = traceback.TracebackException.from_exception(
                 e, limit=1, lookup_lines=False, capture_locals=True)
@@ -1207,50 +3592,56 @@ def foo():
         self.assertEqual(None, exc.__context__)
         self.assertEqual(False, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
 
     def test_cause(self):
         try:
             try:
                 1/0
             finally:
-                exc_info_context = sys.exc_info()
-                exc_context = traceback.TracebackException(*exc_info_context)
+                exc = sys.exception()
+                exc_context = traceback.TracebackException.from_exception(exc)
                 cause = Exception("cause")
                 raise Exception("uh oh") from cause
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info)
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(e)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]))
+                traceback.walk_tb(e.__traceback__))
         exc_cause = traceback.TracebackException(Exception, cause, None)
         self.assertEqual(exc_cause, exc.__cause__)
         self.assertEqual(exc_context, exc.__context__)
         self.assertEqual(True, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
 
     def test_context(self):
         try:
             try:
                 1/0
             finally:
-                exc_info_context = sys.exc_info()
-                exc_context = traceback.TracebackException(*exc_info_context)
+                exc = sys.exception()
+                exc_context = traceback.TracebackException.from_exception(exc)
                 raise Exception("uh oh")
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info)
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(e)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]))
+                traceback.walk_tb(e.__traceback__))
         self.assertEqual(None, exc.__cause__)
         self.assertEqual(exc_context, exc.__context__)
         self.assertEqual(False, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -1258,17 +3649,17 @@ def test_long_context_chain(self):
         def f():
             try:
                 1/0
-            except:
+            except ZeroDivisionError:
                 f()
 
         try:
             f()
-        except RecursionError:
-            exc_info = sys.exc_info()
+        except RecursionError as e:
+            exc_obj = e
         else:
             self.fail("Exception not raised")
 
-        te = traceback.TracebackException(*exc_info)
+        te = traceback.TracebackException.from_exception(exc_obj)
         res = list(te.format())
 
         # many ZeroDiv errors followed by the RecursionError
@@ -1286,70 +3677,83 @@ def test_compact_with_cause(self):
             finally:
                 cause = Exception("cause")
                 raise Exception("uh oh") from cause
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info, compact=True)
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(exc_obj, compact=True)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]))
+                traceback.walk_tb(exc_obj.__traceback__))
         exc_cause = traceback.TracebackException(Exception, cause, None)
         self.assertEqual(exc_cause, exc.__cause__)
         self.assertEqual(None, exc.__context__)
         self.assertEqual(True, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
 
     def test_compact_no_cause(self):
         try:
             try:
                 1/0
             finally:
-                exc_info_context = sys.exc_info()
-                exc_context = traceback.TracebackException(*exc_info_context)
+                exc = sys.exception()
+                exc_context = traceback.TracebackException.from_exception(exc)
                 raise Exception("uh oh")
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info, compact=True)
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(e, compact=True)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]))
+                traceback.walk_tb(exc_obj.__traceback__))
         self.assertEqual(None, exc.__cause__)
         self.assertEqual(exc_context, exc.__context__)
         self.assertEqual(False, exc.__suppress_context__)
         self.assertEqual(expected_stack, exc.stack)
-        self.assertEqual(exc_info[0], exc.exc_type)
-        self.assertEqual(str(exc_info[1]), str(exc))
+        with self.assertWarns(DeprecationWarning):
+            self.assertEqual(type(exc_obj), exc.exc_type)
+        self.assertEqual(type(exc_obj).__name__, exc.exc_type_str)
+        self.assertEqual(str(exc_obj), str(exc))
+
+    def test_no_save_exc_type(self):
+        try:
+            1/0
+        except Exception as e:
+            exc = e
+
+        te = traceback.TracebackException.from_exception(
+                 exc, save_exc_type=False)
+        with self.assertWarns(DeprecationWarning):
+            self.assertIsNone(te.exc_type)
 
     def test_no_refs_to_exception_and_traceback_objects(self):
         try:
             1/0
-        except Exception:
-            exc_info = sys.exc_info()
+        except Exception as e:
+            exc_obj = e
 
-        refcnt1 = sys.getrefcount(exc_info[1])
-        refcnt2 = sys.getrefcount(exc_info[2])
-        exc = traceback.TracebackException(*exc_info)
-        self.assertEqual(sys.getrefcount(exc_info[1]), refcnt1)
-        self.assertEqual(sys.getrefcount(exc_info[2]), refcnt2)
+        refcnt1 = sys.getrefcount(exc_obj)
+        refcnt2 = sys.getrefcount(exc_obj.__traceback__)
+        exc = traceback.TracebackException.from_exception(exc_obj)
+        self.assertEqual(sys.getrefcount(exc_obj), refcnt1)
+        self.assertEqual(sys.getrefcount(exc_obj.__traceback__), refcnt2)
 
     def test_comparison_basic(self):
         try:
             1/0
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info)
-            exc2 = traceback.TracebackException(*exc_info)
+        except Exception as e:
+            exc_obj = e
+            exc = traceback.TracebackException.from_exception(exc_obj)
+            exc2 = traceback.TracebackException.from_exception(exc_obj)
         self.assertIsNot(exc, exc2)
         self.assertEqual(exc, exc2)
         self.assertNotEqual(exc, object())
         self.assertEqual(exc, ALWAYS_EQ)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_comparison_params_variations(self):
         def raise_exc():
             try:
                 raise ValueError('bad value')
-            except:
+            except ValueError:
                 raise
 
         def raise_with_locals():
@@ -1358,28 +3762,28 @@ def raise_with_locals():
 
         try:
             raise_with_locals()
-        except Exception:
-            exc_info = sys.exc_info()
+        except Exception as e:
+            exc_obj = e
 
-        exc = traceback.TracebackException(*exc_info)
-        exc1 = traceback.TracebackException(*exc_info, limit=10)
-        exc2 = traceback.TracebackException(*exc_info, limit=2)
+        exc = traceback.TracebackException.from_exception(exc_obj)
+        exc1 = traceback.TracebackException.from_exception(exc_obj, limit=10)
+        exc2 = traceback.TracebackException.from_exception(exc_obj, limit=2)
 
         self.assertEqual(exc, exc1)      # limit=10 gets all frames
         self.assertNotEqual(exc, exc2)   # limit=2 truncates the output
 
         # locals change the output
-        exc3 = traceback.TracebackException(*exc_info, capture_locals=True)
+        exc3 = traceback.TracebackException.from_exception(exc_obj, capture_locals=True)
         self.assertNotEqual(exc, exc3)
 
         # there are no locals in the innermost frame
-        exc4 = traceback.TracebackException(*exc_info, limit=-1)
-        exc5 = traceback.TracebackException(*exc_info, limit=-1, capture_locals=True)
+        exc4 = traceback.TracebackException.from_exception(exc_obj, limit=-1)
+        exc5 = traceback.TracebackException.from_exception(exc_obj, limit=-1, capture_locals=True)
         self.assertEqual(exc4, exc5)
 
         # there are locals in the next-to-innermost frame
-        exc6 = traceback.TracebackException(*exc_info, limit=-2)
-        exc7 = traceback.TracebackException(*exc_info, limit=-2, capture_locals=True)
+        exc6 = traceback.TracebackException.from_exception(exc_obj, limit=-2)
+        exc7 = traceback.TracebackException.from_exception(exc_obj, limit=-2, capture_locals=True)
         self.assertNotEqual(exc6, exc7)
 
     def test_comparison_equivalent_exceptions_are_equal(self):
@@ -1387,8 +3791,8 @@ def test_comparison_equivalent_exceptions_are_equal(self):
         for _ in range(2):
             try:
                 1/0
-            except:
-                excs.append(traceback.TracebackException(*sys.exc_info()))
+            except Exception as e:
+                excs.append(traceback.TracebackException.from_exception(e))
         self.assertEqual(excs[0], excs[1])
         self.assertEqual(list(excs[0].format()), list(excs[1].format()))
 
@@ -1404,9 +3808,9 @@ def __eq__(self, other):
         except UnhashableException:
             try:
                 raise ex1
-            except UnhashableException:
-                exc_info = sys.exc_info()
-        exc = traceback.TracebackException(*exc_info)
+            except UnhashableException as e:
+                exc_obj = e
+        exc = traceback.TracebackException.from_exception(exc_obj)
         formatted = list(exc.format())
         self.assertIn('UnhashableException: ex2\n', formatted[2])
         self.assertIn('UnhashableException: ex1\n', formatted[6])
@@ -1419,11 +3823,10 @@ def recurse(n):
                 1/0
         try:
             recurse(10)
-        except Exception:
-            exc_info = sys.exc_info()
-            exc = traceback.TracebackException(*exc_info, limit=5)
+        except Exception as e:
+            exc = traceback.TracebackException.from_exception(e, limit=5)
             expected_stack = traceback.StackSummary.extract(
-                traceback.walk_tb(exc_info[2]), limit=5)
+                traceback.walk_tb(e.__traceback__), limit=5)
         self.assertEqual(expected_stack, exc.stack)
 
     def test_lookup_lines(self):
@@ -1431,7 +3834,7 @@ def test_lookup_lines(self):
         e = Exception("uh oh")
         c = test_code('/foo.py', 'method')
         f = test_frame(c, None, None)
-        tb = test_tb(f, 6, None)
+        tb = test_tb(f, 6, None, 0)
         exc = traceback.TracebackException(Exception, e, tb, lookup_lines=False)
         self.assertEqual(linecache.cache, {})
         linecache.updatecache('/foo.py', globals())
@@ -1441,19 +3844,20 @@ def test_locals(self):
         linecache.updatecache('/foo.py', globals())
         e = Exception("uh oh")
         c = test_code('/foo.py', 'method')
-        f = test_frame(c, globals(), {'something': 1, 'other': 'string'})
-        tb = test_tb(f, 6, None)
+        f = test_frame(c, globals(), {'something': 1, 'other': 'string', 'unrepresentable': Unrepresentable()})
+        tb = test_tb(f, 6, None, 0)
         exc = traceback.TracebackException(
             Exception, e, tb, capture_locals=True)
         self.assertEqual(
-            exc.stack[0].locals, {'something': '1', 'other': "'string'"})
+            exc.stack[0].locals,
+            {'something': '1', 'other': "'string'", 'unrepresentable': '<local repr() failed>'})
 
     def test_no_locals(self):
         linecache.updatecache('/foo.py', globals())
         e = Exception("uh oh")
         c = test_code('/foo.py', 'method')
         f = test_frame(c, globals(), {'something': 1})
-        tb = test_tb(f, 6, None)
+        tb = test_tb(f, 6, None, 0)
         exc = traceback.TracebackException(Exception, e, tb)
         self.assertEqual(exc.stack[0].locals, None)
 
@@ -1463,6 +3867,913 @@ 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
+    def test_print(self):
+        def f():
+            x = 12
+            try:
+                x/0
+            except Exception as e:
+                return e
+        exc = traceback.TracebackException.from_exception(f(), capture_locals=True)
+        output = StringIO()
+        exc.print(file=output)
+        self.assertEqual(
+            output.getvalue().split('\n')[-5:],
+            ['    x/0',
+             '    ~^~',
+             '    x = 12',
+             'ZeroDivisionError: division by zero',
+             ''])
+
+    def test_dont_swallow_cause_or_context_of_falsey_exception(self):
+        # see gh-132308: Ensure that __cause__ or __context__ attributes of exceptions
+        # that evaluate as falsey are included in the output. For falsey term,
+        # see https://docs.python.org/3/library/stdtypes.html#truth-value-testing.
+
+        try:
+            raise FalseyException from KeyError
+        except FalseyException as e:
+            self.assertIn(cause_message, traceback.format_exception(e))
+
+        try:
+            try:
+                1/0
+            except ZeroDivisionError:
+                raise FalseyException
+        except FalseyException as e:
+            self.assertIn(context_message, traceback.format_exception(e))
+
+
+class TestTracebackException_ExceptionGroups(unittest.TestCase):
+    def setUp(self):
+        super().setUp()
+        self.eg = self._get_exception_group()
+
+    def _get_exception_group(self):
+        def f():
+            1/0
+
+        def g(v):
+            raise ValueError(v)
+
+        self.lno_f = f.__code__.co_firstlineno
+        self.lno_g = g.__code__.co_firstlineno
+
+        try:
+            try:
+                try:
+                    f()
+                except Exception as e:
+                    exc1 = e
+                try:
+                    g(42)
+                except Exception as e:
+                    exc2 = e
+                raise ExceptionGroup("eg1", [exc1, exc2])
+            except ExceptionGroup as e:
+                exc3 = e
+            try:
+                g(24)
+            except Exception as e:
+                exc4 = e
+            raise ExceptionGroup("eg2", [exc3, exc4])
+        except ExceptionGroup as eg:
+            return eg
+        self.fail('Exception Not Raised')
+
+    def test_exception_group_construction(self):
+        eg = self.eg
+        teg1 = traceback.TracebackException(type(eg), eg, eg.__traceback__)
+        teg2 = traceback.TracebackException.from_exception(eg)
+        self.assertIsNot(teg1, teg2)
+        self.assertEqual(teg1, teg2)
+
+    def test_exception_group_format_exception_only(self):
+        teg = traceback.TracebackException.from_exception(self.eg)
+        formatted = ''.join(teg.format_exception_only()).split('\n')
+        expected = "ExceptionGroup: eg2 (2 sub-exceptions)\n".split('\n')
+
+        self.assertEqual(formatted, expected)
+
+    def test_exception_group_format_exception_onlyi_recursive(self):
+        teg = traceback.TracebackException.from_exception(self.eg)
+        formatted = ''.join(teg.format_exception_only(show_group=True)).split('\n')
+        expected = [
+                     'ExceptionGroup: eg2 (2 sub-exceptions)',
+                     '   ExceptionGroup: eg1 (2 sub-exceptions)',
+                     '      ZeroDivisionError: division by zero',
+                     '      ValueError: 42',
+                     '   ValueError: 24',
+                     ''
+                   ]
+
+        self.assertEqual(formatted, expected)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_exception_group_format(self):
+        teg = traceback.TracebackException.from_exception(self.eg)
+
+        formatted = ''.join(teg.format()).split('\n')
+        lno_f = self.lno_f
+        lno_g = self.lno_g
+
+        expected = [
+                    f'  + Exception Group Traceback (most recent call last):',
+                    f'  |   File "{__file__}", line {lno_g+23}, in _get_exception_group',
+                    f'  |     raise ExceptionGroup("eg2", [exc3, exc4])',
+                    f'  | ExceptionGroup: eg2 (2 sub-exceptions)',
+                    f'  +-+---------------- 1 ----------------',
+                    f'    | Exception Group Traceback (most recent call last):',
+                    f'    |   File "{__file__}", line {lno_g+16}, in _get_exception_group',
+                    f'    |     raise ExceptionGroup("eg1", [exc1, exc2])',
+                    f'    | ExceptionGroup: eg1 (2 sub-exceptions)',
+                    f'    +-+---------------- 1 ----------------',
+                    f'      | Traceback (most recent call last):',
+                    f'      |   File "{__file__}", line {lno_g+9}, in _get_exception_group',
+                    f'      |     f()',
+                    f'      |     ~^^',
+                    f'      |   File "{__file__}", line {lno_f+1}, in f',
+                    f'      |     1/0',
+                    f'      |     ~^~',
+                    f'      | ZeroDivisionError: division by zero',
+                    f'      +---------------- 2 ----------------',
+                    f'      | Traceback (most recent call last):',
+                    f'      |   File "{__file__}", line {lno_g+13}, in _get_exception_group',
+                    f'      |     g(42)',
+                    f'      |     ~^^^^',
+                    f'      |   File "{__file__}", line {lno_g+1}, in g',
+                    f'      |     raise ValueError(v)',
+                    f'      | ValueError: 42',
+                    f'      +------------------------------------',
+                    f'    +---------------- 2 ----------------',
+                    f'    | Traceback (most recent call last):',
+                    f'    |   File "{__file__}", line {lno_g+20}, in _get_exception_group',
+                    f'    |     g(24)',
+                    f'    |     ~^^^^',
+                    f'    |   File "{__file__}", line {lno_g+1}, in g',
+                    f'    |     raise ValueError(v)',
+                    f'    | ValueError: 24',
+                    f'    +------------------------------------',
+                    f'']
+
+        self.assertEqual(formatted, expected)
+
+    def test_max_group_width(self):
+        excs1 = []
+        excs2 = []
+        for i in range(3):
+            excs1.append(ValueError(i))
+        for i in range(10):
+            excs2.append(TypeError(i))
+
+        EG = ExceptionGroup
+        eg = EG('eg', [EG('eg1', excs1), EG('eg2', excs2)])
+
+        teg = traceback.TracebackException.from_exception(eg, max_group_width=2)
+        formatted = ''.join(teg.format()).split('\n')
+
+        expected = [
+                    '  | ExceptionGroup: eg (2 sub-exceptions)',
+                    '  +-+---------------- 1 ----------------',
+                    '    | ExceptionGroup: eg1 (3 sub-exceptions)',
+                    '    +-+---------------- 1 ----------------',
+                    '      | ValueError: 0',
+                    '      +---------------- 2 ----------------',
+                    '      | ValueError: 1',
+                    '      +---------------- ... ----------------',
+                    '      | and 1 more exception',
+                    '      +------------------------------------',
+                    '    +---------------- 2 ----------------',
+                    '    | ExceptionGroup: eg2 (10 sub-exceptions)',
+                    '    +-+---------------- 1 ----------------',
+                    '      | TypeError: 0',
+                    '      +---------------- 2 ----------------',
+                    '      | TypeError: 1',
+                    '      +---------------- ... ----------------',
+                    '      | and 8 more exceptions',
+                    '      +------------------------------------',
+                    '']
+
+        self.assertEqual(formatted, expected)
+
+    def test_max_group_depth(self):
+        exc = TypeError('bad type')
+        for i in range(3):
+            exc = ExceptionGroup('exc', [ValueError(-i), exc, ValueError(i)])
+
+        teg = traceback.TracebackException.from_exception(exc, max_group_depth=2)
+        formatted = ''.join(teg.format()).split('\n')
+
+        expected = [
+                    '  | ExceptionGroup: exc (3 sub-exceptions)',
+                    '  +-+---------------- 1 ----------------',
+                    '    | ValueError: -2',
+                    '    +---------------- 2 ----------------',
+                    '    | ExceptionGroup: exc (3 sub-exceptions)',
+                    '    +-+---------------- 1 ----------------',
+                    '      | ValueError: -1',
+                    '      +---------------- 2 ----------------',
+                    '      | ... (max_group_depth is 2)',
+                    '      +---------------- 3 ----------------',
+                    '      | ValueError: 1',
+                    '      +------------------------------------',
+                    '    +---------------- 3 ----------------',
+                    '    | ValueError: 2',
+                    '    +------------------------------------',
+                    '']
+
+        self.assertEqual(formatted, expected)
+
+    def test_comparison(self):
+        try:
+            raise self.eg
+        except ExceptionGroup as e:
+            exc = e
+        for _ in range(5):
+            try:
+                raise exc
+            except Exception as e:
+                exc_obj = e
+        exc = traceback.TracebackException.from_exception(exc_obj)
+        exc2 = traceback.TracebackException.from_exception(exc_obj)
+        exc3 = traceback.TracebackException.from_exception(exc_obj, limit=300)
+        ne = traceback.TracebackException.from_exception(exc_obj, limit=3)
+        self.assertIsNot(exc, exc2)
+        self.assertEqual(exc, exc2)
+        self.assertEqual(exc, exc3)
+        self.assertNotEqual(exc, ne)
+        self.assertNotEqual(exc, object())
+        self.assertEqual(exc, ALWAYS_EQ)
+
+    def test_dont_swallow_subexceptions_of_falsey_exceptiongroup(self):
+        # see gh-132308: Ensure that subexceptions of exception groups
+        # that evaluate as falsey are displayed in the output. For falsey term,
+        # see https://docs.python.org/3/library/stdtypes.html#truth-value-testing.
+
+        try:
+            raise FalseyExceptionGroup("Gih", (KeyError(), NameError()))
+        except Exception as ee:
+            str_exc = ''.join(traceback.format_exception(ee))
+            self.assertIn('+---------------- 1 ----------------', str_exc)
+            self.assertIn('+---------------- 2 ----------------', str_exc)
+
+        # Test with a falsey exception, in last position, as sub-exceptions.
+        msg = 'bool'
+        try:
+            raise FalseyExceptionGroup("Gah", (KeyError(), FalseyException(msg)))
+        except Exception as ee:
+            str_exc = traceback.format_exception(ee)
+            self.assertIn(f'{FalseyException.__name__}: {msg}', str_exc[-2])
+
+
+global_for_suggestions = None
+
+
+class SuggestionFormattingTestBase:
+    def get_suggestion(self, obj, attr_name=None):
+        if attr_name is not None:
+            def callable():
+                getattr(obj, attr_name)
+        else:
+            callable = obj
+
+        result_lines = self.get_exception(
+            callable, slice_start=-1, slice_end=None
+        )
+        return result_lines[0]
+
+    def test_getattr_suggestions(self):
+        class Substitution:
+            noise = more_noise = a = bc = None
+            blech = None
+
+        class Elimination:
+            noise = more_noise = a = bc = None
+            blch = None
+
+        class Addition:
+            noise = more_noise = a = bc = None
+            bluchin = None
+
+        class SubstitutionOverElimination:
+            blach = None
+            bluc = None
+
+        class SubstitutionOverAddition:
+            blach = None
+            bluchi = None
+
+        class EliminationOverAddition:
+            blucha = None
+            bluc = None
+
+        class CaseChangeOverSubstitution:
+            Luch = None
+            fluch = None
+            BLuch = None
+
+        for cls, suggestion in [
+            (Addition, "'bluchin'?"),
+            (Substitution, "'blech'?"),
+            (Elimination, "'blch'?"),
+            (Addition, "'bluchin'?"),
+            (SubstitutionOverElimination, "'blach'?"),
+            (SubstitutionOverAddition, "'blach'?"),
+            (EliminationOverAddition, "'bluc'?"),
+            (CaseChangeOverSubstitution, "'BLuch'?"),
+        ]:
+            actual = self.get_suggestion(cls(), 'bluch')
+            self.assertIn(suggestion, actual)
+
+    def test_getattr_suggestions_underscored(self):
+        class A:
+            bluch = None
+
+        self.assertIn("'bluch'", self.get_suggestion(A(), 'blach'))
+        self.assertIn("'bluch'", self.get_suggestion(A(), '_luch'))
+        self.assertIn("'bluch'", self.get_suggestion(A(), '_bluch'))
+
+        class B:
+            _bluch = None
+            def method(self, name):
+                getattr(self, name)
+
+        self.assertIn("'_bluch'", self.get_suggestion(B(), '_blach'))
+        self.assertIn("'_bluch'", self.get_suggestion(B(), '_luch'))
+        self.assertNotIn("'_bluch'", self.get_suggestion(B(), 'bluch'))
+
+        self.assertIn("'_bluch'", self.get_suggestion(partial(B().method, '_blach')))
+        self.assertIn("'_bluch'", self.get_suggestion(partial(B().method, '_luch')))
+        self.assertIn("'_bluch'", self.get_suggestion(partial(B().method, 'bluch')))
+
+    def test_getattr_suggestions_do_not_trigger_for_long_attributes(self):
+        class A:
+            blech = None
+
+        actual = self.get_suggestion(A(), 'somethingverywrong')
+        self.assertNotIn("blech", actual)
+
+    def test_getattr_error_bad_suggestions_do_not_trigger_for_small_names(self):
+        class MyClass:
+            vvv = mom = w = id = pytho = None
+
+        for name in ("b", "v", "m", "py"):
+            with self.subTest(name=name):
+                actual = self.get_suggestion(MyClass, name)
+                self.assertNotIn("Did you mean", actual)
+                self.assertNotIn("'vvv", actual)
+                self.assertNotIn("'mom'", actual)
+                self.assertNotIn("'id'", actual)
+                self.assertNotIn("'w'", actual)
+                self.assertNotIn("'pytho'", actual)
+
+    def test_getattr_suggestions_do_not_trigger_for_big_dicts(self):
+        class A:
+            blech = None
+        # A class with a very big __dict__ will not be considered
+        # for suggestions.
+        for index in range(2000):
+            setattr(A, f"index_{index}", None)
+
+        actual = self.get_suggestion(A(), 'bluch')
+        self.assertNotIn("blech", actual)
+
+    def test_getattr_suggestions_no_args(self):
+        class A:
+            blech = None
+            def __getattr__(self, attr):
+                raise AttributeError()
+
+        actual = self.get_suggestion(A(), 'bluch')
+        self.assertIn("blech", actual)
+
+        class A:
+            blech = None
+            def __getattr__(self, attr):
+                raise AttributeError
+
+        actual = self.get_suggestion(A(), 'bluch')
+        self.assertIn("blech", actual)
+
+    def test_getattr_suggestions_invalid_args(self):
+        class NonStringifyClass:
+            __str__ = None
+            __repr__ = None
+
+        class A:
+            blech = None
+            def __getattr__(self, attr):
+                raise AttributeError(NonStringifyClass())
+
+        class B:
+            blech = None
+            def __getattr__(self, attr):
+                raise AttributeError("Error", 23)
+
+        class C:
+            blech = None
+            def __getattr__(self, attr):
+                raise AttributeError(23)
+
+        for cls in [A, B, C]:
+            actual = self.get_suggestion(cls(), 'bluch')
+            self.assertIn("blech", actual)
+
+    def test_getattr_suggestions_for_same_name(self):
+        class A:
+            def __dir__(self):
+                return ['blech']
+        actual = self.get_suggestion(A(), 'blech')
+        self.assertNotIn("Did you mean", actual)
+
+    def test_attribute_error_with_failing_dict(self):
+        class T:
+            bluch = 1
+            def __dir__(self):
+                raise AttributeError("oh no!")
+
+        actual = self.get_suggestion(T(), 'blich')
+        self.assertNotIn("blech", actual)
+        self.assertNotIn("oh no!", actual)
+
+    def test_attribute_error_with_non_string_candidates(self):
+        class T:
+            bluch = 1
+
+        instance = T()
+        instance.__dict__[0] = 1
+        actual = self.get_suggestion(instance, 'blich')
+        self.assertIn("bluch", actual)
+
+    def test_attribute_error_with_bad_name(self):
+        def raise_attribute_error_with_bad_name():
+            raise AttributeError(name=12, obj=23)
+
+        result_lines = self.get_exception(
+            raise_attribute_error_with_bad_name, slice_start=-1, slice_end=None
+        )
+        self.assertNotIn("?", result_lines[-1])
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_attribute_error_inside_nested_getattr(self):
+        class A:
+            bluch = 1
+
+        class B:
+            def __getattribute__(self, attr):
+                a = A()
+                return a.blich
+
+        actual = self.get_suggestion(B(), 'something')
+        self.assertIn("Did you mean", actual)
+        self.assertIn("bluch", actual)
+
+    def make_module(self, code):
+        tmpdir = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, tmpdir)
+
+        sys.path.append(str(tmpdir))
+        self.addCleanup(sys.path.pop)
+
+        mod_name = ''.join(random.choices(string.ascii_letters, k=16))
+        module = tmpdir / (mod_name + ".py")
+        module.write_text(code)
+
+        return mod_name
+
+    def get_import_from_suggestion(self, code, name):
+        modname = self.make_module(code)
+
+        def callable():
+            try:
+                exec(f"from {modname} import {name}")
+            except ImportError as e:
+                raise e from None
+            except Exception as e:
+                self.fail(f"Expected ImportError but got {type(e)}")
+        self.addCleanup(forget, modname)
+
+        result_lines = self.get_exception(
+            callable, slice_start=-1, slice_end=None
+        )
+        return result_lines[0]
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_import_from_suggestions(self):
+        substitution = textwrap.dedent("""\
+            noise = more_noise = a = bc = None
+            blech = None
+        """)
+
+        elimination = textwrap.dedent("""
+            noise = more_noise = a = bc = None
+            blch = None
+        """)
+
+        addition = textwrap.dedent("""
+            noise = more_noise = a = bc = None
+            bluchin = None
+        """)
+
+        substitutionOverElimination = textwrap.dedent("""
+            blach = None
+            bluc = None
+        """)
+
+        substitutionOverAddition = textwrap.dedent("""
+            blach = None
+            bluchi = None
+        """)
+
+        eliminationOverAddition = textwrap.dedent("""
+            blucha = None
+            bluc = None
+        """)
+
+        caseChangeOverSubstitution = textwrap.dedent("""
+            Luch = None
+            fluch = None
+            BLuch = None
+        """)
+
+        for code, suggestion in [
+            (addition, "'bluchin'?"),
+            (substitution, "'blech'?"),
+            (elimination, "'blch'?"),
+            (addition, "'bluchin'?"),
+            (substitutionOverElimination, "'blach'?"),
+            (substitutionOverAddition, "'blach'?"),
+            (eliminationOverAddition, "'bluc'?"),
+            (caseChangeOverSubstitution, "'BLuch'?"),
+        ]:
+            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'))
+        self.assertIn("'bluch'", self.get_import_from_suggestion(code, '_luch'))
+        self.assertIn("'bluch'", self.get_import_from_suggestion(code, '_bluch'))
+
+        code = "_bluch = None"
+        self.assertIn("'_bluch'", self.get_import_from_suggestion(code, '_blach'))
+        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
+            bluch = 1
+        """)
+        self.assertIn("'bluch'", self.get_import_from_suggestion(modWithNonStringAttr, 'blech'))
+
+    def test_import_from_suggestions_do_not_trigger_for_long_attributes(self):
+        code = "blech = None"
+
+        actual = self.get_suggestion(code, 'somethingverywrong')
+        self.assertNotIn("blech", actual)
+
+    def test_import_from_error_bad_suggestions_do_not_trigger_for_small_names(self):
+        code = "vvv = mom = w = id = pytho = None"
+
+        for name in ("b", "v", "m", "py"):
+            with self.subTest(name=name):
+                actual = self.get_import_from_suggestion(code, name)
+                self.assertNotIn("Did you mean", actual)
+                self.assertNotIn("'vvv'", actual)
+                self.assertNotIn("'mom'", actual)
+                self.assertNotIn("'id'", actual)
+                self.assertNotIn("'w'", actual)
+                self.assertNotIn("'pytho'", actual)
+
+    def test_import_from_suggestions_do_not_trigger_for_big_namespaces(self):
+        # A module with lots of names will not be considered for suggestions.
+        chunks = [f"index_{index} = " for index in range(200)]
+        chunks.append(" None")
+        code = " ".join(chunks)
+        actual = self.get_import_from_suggestion(code, 'bluch')
+        self.assertNotIn("blech", actual)
+
+    def test_import_from_error_with_bad_name(self):
+        def raise_attribute_error_with_bad_name():
+            raise ImportError(name=12, obj=23, name_from=11)
+
+        result_lines = self.get_exception(
+            raise_attribute_error_with_bad_name, slice_start=-1, slice_end=None
+        )
+        self.assertNotIn("?", result_lines[-1])
+
+    def test_name_error_suggestions(self):
+        def Substitution():
+            noise = more_noise = a = bc = None
+            blech = None
+            print(bluch)
+
+        def Elimination():
+            noise = more_noise = a = bc = None
+            blch = None
+            print(bluch)
+
+        def Addition():
+            noise = more_noise = a = bc = None
+            bluchin = None
+            print(bluch)
+
+        def SubstitutionOverElimination():
+            blach = None
+            bluc = None
+            print(bluch)
+
+        def SubstitutionOverAddition():
+            blach = None
+            bluchi = None
+            print(bluch)
+
+        def EliminationOverAddition():
+            blucha = None
+            bluc = None
+            print(bluch)
+
+        for func, suggestion in [(Substitution, "'blech'?"),
+                                (Elimination, "'blch'?"),
+                                (Addition, "'bluchin'?"),
+                                (EliminationOverAddition, "'blucha'?"),
+                                (SubstitutionOverElimination, "'blach'?"),
+                                (SubstitutionOverAddition, "'blach'?")]:
+            actual = self.get_suggestion(func)
+            self.assertIn(suggestion, actual)
+
+    def test_name_error_suggestions_from_globals(self):
+        def func():
+            print(global_for_suggestio)
+        actual = self.get_suggestion(func)
+        self.assertIn("'global_for_suggestions'?", actual)
+
+    def test_name_error_suggestions_from_builtins(self):
+        def func():
+            print(ZeroDivisionErrrrr)
+        actual = self.get_suggestion(func)
+        self.assertIn("'ZeroDivisionError'?", actual)
+
+    def test_name_error_suggestions_from_builtins_when_builtins_is_module(self):
+        def func():
+            custom_globals = globals().copy()
+            custom_globals["__builtins__"] = builtins
+            print(eval("ZeroDivisionErrrrr", custom_globals))
+        actual = self.get_suggestion(func)
+        self.assertIn("'ZeroDivisionError'?", actual)
+
+    def test_name_error_suggestions_with_non_string_candidates(self):
+        def func():
+            abc = 1
+            custom_globals = globals().copy()
+            custom_globals[0] = 1
+            print(eval("abv", custom_globals, locals()))
+        actual = self.get_suggestion(func)
+        self.assertIn("abc", actual)
+
+    def test_name_error_suggestions_do_not_trigger_for_long_names(self):
+        def func():
+            somethingverywronghehehehehehe = None
+            print(somethingverywronghe)
+        actual = self.get_suggestion(func)
+        self.assertNotIn("somethingverywronghehe", actual)
+
+    def test_name_error_bad_suggestions_do_not_trigger_for_small_names(self):
+
+        def f_b():
+            vvv = mom = w = id = pytho = None
+            b
+
+        def f_v():
+            vvv = mom = w = id = pytho = None
+            v
+
+        def f_m():
+            vvv = mom = w = id = pytho = None
+            m
+
+        def f_py():
+            vvv = mom = w = id = pytho = None
+            py
+
+        for name, func in (("b", f_b), ("v", f_v), ("m", f_m), ("py", f_py)):
+            with self.subTest(name=name):
+                actual = self.get_suggestion(func)
+                self.assertNotIn("you mean", actual)
+                self.assertNotIn("vvv", actual)
+                self.assertNotIn("mom", actual)
+                self.assertNotIn("'id'", actual)
+                self.assertNotIn("'w'", actual)
+                self.assertNotIn("'pytho'", actual)
+
+    def test_name_error_suggestions_do_not_trigger_for_too_many_locals(self):
+        def func():
+            # Mutating locals() is unreliable, so we need to do it by hand
+            a1 = a2 = a3 = a4 = a5 = a6 = a7 = a8 = a9 = a10 = \
+            a11 = a12 = a13 = a14 = a15 = a16 = a17 = a18 = a19 = a20 = \
+            a21 = a22 = a23 = a24 = a25 = a26 = a27 = a28 = a29 = a30 = \
+            a31 = a32 = a33 = a34 = a35 = a36 = a37 = a38 = a39 = a40 = \
+            a41 = a42 = a43 = a44 = a45 = a46 = a47 = a48 = a49 = a50 = \
+            a51 = a52 = a53 = a54 = a55 = a56 = a57 = a58 = a59 = a60 = \
+            a61 = a62 = a63 = a64 = a65 = a66 = a67 = a68 = a69 = a70 = \
+            a71 = a72 = a73 = a74 = a75 = a76 = a77 = a78 = a79 = a80 = \
+            a81 = a82 = a83 = a84 = a85 = a86 = a87 = a88 = a89 = a90 = \
+            a91 = a92 = a93 = a94 = a95 = a96 = a97 = a98 = a99 = a100 = \
+            a101 = a102 = a103 = a104 = a105 = a106 = a107 = a108 = a109 = a110 = \
+            a111 = a112 = a113 = a114 = a115 = a116 = a117 = a118 = a119 = a120 = \
+            a121 = a122 = a123 = a124 = a125 = a126 = a127 = a128 = a129 = a130 = \
+            a131 = a132 = a133 = a134 = a135 = a136 = a137 = a138 = a139 = a140 = \
+            a141 = a142 = a143 = a144 = a145 = a146 = a147 = a148 = a149 = a150 = \
+            a151 = a152 = a153 = a154 = a155 = a156 = a157 = a158 = a159 = a160 = \
+            a161 = a162 = a163 = a164 = a165 = a166 = a167 = a168 = a169 = a170 = \
+            a171 = a172 = a173 = a174 = a175 = a176 = a177 = a178 = a179 = a180 = \
+            a181 = a182 = a183 = a184 = a185 = a186 = a187 = a188 = a189 = a190 = \
+            a191 = a192 = a193 = a194 = a195 = a196 = a197 = a198 = a199 = a200 = \
+            a201 = a202 = a203 = a204 = a205 = a206 = a207 = a208 = a209 = a210 = \
+            a211 = a212 = a213 = a214 = a215 = a216 = a217 = a218 = a219 = a220 = \
+            a221 = a222 = a223 = a224 = a225 = a226 = a227 = a228 = a229 = a230 = \
+            a231 = a232 = a233 = a234 = a235 = a236 = a237 = a238 = a239 = a240 = \
+            a241 = a242 = a243 = a244 = a245 = a246 = a247 = a248 = a249 = a250 = \
+            a251 = a252 = a253 = a254 = a255 = a256 = a257 = a258 = a259 = a260 = \
+            a261 = a262 = a263 = a264 = a265 = a266 = a267 = a268 = a269 = a270 = \
+            a271 = a272 = a273 = a274 = a275 = a276 = a277 = a278 = a279 = a280 = \
+            a281 = a282 = a283 = a284 = a285 = a286 = a287 = a288 = a289 = a290 = \
+            a291 = a292 = a293 = a294 = a295 = a296 = a297 = a298 = a299 = a300 = \
+            a301 = a302 = a303 = a304 = a305 = a306 = a307 = a308 = a309 = a310 = \
+            a311 = a312 = a313 = a314 = a315 = a316 = a317 = a318 = a319 = a320 = \
+            a321 = a322 = a323 = a324 = a325 = a326 = a327 = a328 = a329 = a330 = \
+            a331 = a332 = a333 = a334 = a335 = a336 = a337 = a338 = a339 = a340 = \
+            a341 = a342 = a343 = a344 = a345 = a346 = a347 = a348 = a349 = a350 = \
+            a351 = a352 = a353 = a354 = a355 = a356 = a357 = a358 = a359 = a360 = \
+            a361 = a362 = a363 = a364 = a365 = a366 = a367 = a368 = a369 = a370 = \
+            a371 = a372 = a373 = a374 = a375 = a376 = a377 = a378 = a379 = a380 = \
+            a381 = a382 = a383 = a384 = a385 = a386 = a387 = a388 = a389 = a390 = \
+            a391 = a392 = a393 = a394 = a395 = a396 = a397 = a398 = a399 = a400 = \
+            a401 = a402 = a403 = a404 = a405 = a406 = a407 = a408 = a409 = a410 = \
+            a411 = a412 = a413 = a414 = a415 = a416 = a417 = a418 = a419 = a420 = \
+            a421 = a422 = a423 = a424 = a425 = a426 = a427 = a428 = a429 = a430 = \
+            a431 = a432 = a433 = a434 = a435 = a436 = a437 = a438 = a439 = a440 = \
+            a441 = a442 = a443 = a444 = a445 = a446 = a447 = a448 = a449 = a450 = \
+            a451 = a452 = a453 = a454 = a455 = a456 = a457 = a458 = a459 = a460 = \
+            a461 = a462 = a463 = a464 = a465 = a466 = a467 = a468 = a469 = a470 = \
+            a471 = a472 = a473 = a474 = a475 = a476 = a477 = a478 = a479 = a480 = \
+            a481 = a482 = a483 = a484 = a485 = a486 = a487 = a488 = a489 = a490 = \
+            a491 = a492 = a493 = a494 = a495 = a496 = a497 = a498 = a499 = a500 = \
+            a501 = a502 = a503 = a504 = a505 = a506 = a507 = a508 = a509 = a510 = \
+            a511 = a512 = a513 = a514 = a515 = a516 = a517 = a518 = a519 = a520 = \
+            a521 = a522 = a523 = a524 = a525 = a526 = a527 = a528 = a529 = a530 = \
+            a531 = a532 = a533 = a534 = a535 = a536 = a537 = a538 = a539 = a540 = \
+            a541 = a542 = a543 = a544 = a545 = a546 = a547 = a548 = a549 = a550 = \
+            a551 = a552 = a553 = a554 = a555 = a556 = a557 = a558 = a559 = a560 = \
+            a561 = a562 = a563 = a564 = a565 = a566 = a567 = a568 = a569 = a570 = \
+            a571 = a572 = a573 = a574 = a575 = a576 = a577 = a578 = a579 = a580 = \
+            a581 = a582 = a583 = a584 = a585 = a586 = a587 = a588 = a589 = a590 = \
+            a591 = a592 = a593 = a594 = a595 = a596 = a597 = a598 = a599 = a600 = \
+            a601 = a602 = a603 = a604 = a605 = a606 = a607 = a608 = a609 = a610 = \
+            a611 = a612 = a613 = a614 = a615 = a616 = a617 = a618 = a619 = a620 = \
+            a621 = a622 = a623 = a624 = a625 = a626 = a627 = a628 = a629 = a630 = \
+            a631 = a632 = a633 = a634 = a635 = a636 = a637 = a638 = a639 = a640 = \
+            a641 = a642 = a643 = a644 = a645 = a646 = a647 = a648 = a649 = a650 = \
+            a651 = a652 = a653 = a654 = a655 = a656 = a657 = a658 = a659 = a660 = \
+            a661 = a662 = a663 = a664 = a665 = a666 = a667 = a668 = a669 = a670 = \
+            a671 = a672 = a673 = a674 = a675 = a676 = a677 = a678 = a679 = a680 = \
+            a681 = a682 = a683 = a684 = a685 = a686 = a687 = a688 = a689 = a690 = \
+            a691 = a692 = a693 = a694 = a695 = a696 = a697 = a698 = a699 = a700 = \
+            a701 = a702 = a703 = a704 = a705 = a706 = a707 = a708 = a709 = a710 = \
+            a711 = a712 = a713 = a714 = a715 = a716 = a717 = a718 = a719 = a720 = \
+            a721 = a722 = a723 = a724 = a725 = a726 = a727 = a728 = a729 = a730 = \
+            a731 = a732 = a733 = a734 = a735 = a736 = a737 = a738 = a739 = a740 = \
+            a741 = a742 = a743 = a744 = a745 = a746 = a747 = a748 = a749 = a750 = \
+            a751 = a752 = a753 = a754 = a755 = a756 = a757 = a758 = a759 = a760 = \
+            a761 = a762 = a763 = a764 = a765 = a766 = a767 = a768 = a769 = a770 = \
+            a771 = a772 = a773 = a774 = a775 = a776 = a777 = a778 = a779 = a780 = \
+            a781 = a782 = a783 = a784 = a785 = a786 = a787 = a788 = a789 = a790 = \
+            a791 = a792 = a793 = a794 = a795 = a796 = a797 = a798 = a799 = a800 \
+                = None
+            print(a0)
+
+        actual = self.get_suggestion(func)
+        self.assertNotRegex(actual, r"NameError.*a1")
+
+    def test_name_error_with_custom_exceptions(self):
+        def func():
+            blech = None
+            raise NameError()
+
+        actual = self.get_suggestion(func)
+        self.assertNotIn("blech", actual)
+
+        def func():
+            blech = None
+            raise NameError
+
+        actual = self.get_suggestion(func)
+        self.assertNotIn("blech", actual)
+
+    def test_name_error_with_instance(self):
+        class A:
+            def __init__(self):
+                self.blech = None
+            def foo(self):
+                blich = 1
+                x = blech
+
+        instance = A()
+        actual = self.get_suggestion(instance.foo)
+        self.assertIn("self.blech", actual)
+
+    def test_unbound_local_error_with_instance(self):
+        class A:
+            def __init__(self):
+                self.blech = None
+            def foo(self):
+                blich = 1
+                x = blech
+                blech = 1
+
+        instance = A()
+        actual = self.get_suggestion(instance.foo)
+        self.assertNotIn("self.blech", actual)
+
+    def test_unbound_local_error_with_side_effect(self):
+        # gh-132385
+        class A:
+            def __getattr__(self, key):
+                if key == 'foo':
+                    raise AttributeError('foo')
+                if key == 'spam':
+                    raise ValueError('spam')
+
+            def bar(self):
+                foo
+            def baz(self):
+                spam
+
+        suggestion = self.get_suggestion(A().bar)
+        self.assertNotIn('self.', suggestion)
+        self.assertIn("'foo'", suggestion)
+
+        suggestion = self.get_suggestion(A().baz)
+        self.assertNotIn('self.', suggestion)
+        self.assertIn("'spam'", suggestion)
+
+    def test_unbound_local_error_does_not_match(self):
+        def func():
+            something = 3
+            print(somethong)
+            somethong = 3
+
+        actual = self.get_suggestion(func)
+        self.assertNotIn("something", actual)
+
+    def test_name_error_for_stdlib_modules(self):
+        def func():
+            stream = io.StringIO()
+
+        actual = self.get_suggestion(func)
+        self.assertIn("forget to import 'io'", actual)
+
+    def test_name_error_for_private_stdlib_modules(self):
+        def func():
+            stream = _io.StringIO()
+
+        actual = self.get_suggestion(func)
+        self.assertIn("forget to import '_io'", actual)
+
+
+
+class PurePythonSuggestionFormattingTests(
+    PurePythonExceptionFormattingMixin,
+    SuggestionFormattingTestBase,
+    unittest.TestCase,
+):
+    """
+    Same set of tests as above using the pure Python implementation of
+    traceback printing in traceback.py.
+    """
+
+
+@cpython_only
+class CPythonSuggestionFormattingTests(
+    CAPIExceptionFormattingMixin,
+    SuggestionFormattingTestBase,
+    unittest.TestCase,
+):
+    """
+    Same set of tests as above but with Python's internal traceback printing.
+    """
+
 
 class MiscTest(unittest.TestCase):
 
@@ -1477,6 +4788,229 @@ def test_all(self):
                 expected.add(name)
         self.assertCountEqual(traceback.__all__, expected)
 
+    def test_levenshtein_distance(self):
+        # copied from _testinternalcapi.test_edit_cost
+        # to also exercise the Python implementation
+
+        def CHECK(a, b, expected):
+            actual = traceback._levenshtein_distance(a, b, 4044)
+            self.assertEqual(actual, expected)
+
+        CHECK("", "", 0)
+        CHECK("", "a", 2)
+        CHECK("a", "A", 1)
+        CHECK("Apple", "Aple", 2)
+        CHECK("Banana", "B@n@n@", 6)
+        CHECK("Cherry", "Cherry!", 2)
+        CHECK("---0---", "------", 2)
+        CHECK("abc", "y", 6)
+        CHECK("aa", "bb", 4)
+        CHECK("aaaaa", "AAAAA", 5)
+        CHECK("wxyz", "wXyZ", 2)
+        CHECK("wxyz", "wXyZ123", 8)
+        CHECK("Python", "Java", 12)
+        CHECK("Java", "C#", 8)
+        CHECK("AbstractFoobarManager", "abstract_foobar_manager", 3+2*2)
+        CHECK("CPython", "PyPy", 10)
+        CHECK("CPython", "pypy", 11)
+        CHECK("AttributeError", "AttributeErrop", 2)
+        CHECK("AttributeError", "AttributeErrorTests", 10)
+        CHECK("ABA", "AAB", 4)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    @support.requires_resource('cpu')
+    def test_levenshtein_distance_short_circuit(self):
+        if not LEVENSHTEIN_DATA_FILE.is_file():
+            self.fail(
+                f"{LEVENSHTEIN_DATA_FILE} is missing."
+                f" Run `make regen-test-levenshtein`"
+            )
+
+        with LEVENSHTEIN_DATA_FILE.open("r") as f:
+            examples = json.load(f)
+        for a, b, expected in examples:
+            res1 = traceback._levenshtein_distance(a, b, 1000)
+            self.assertEqual(res1, expected, msg=(a, b))
+
+            for threshold in [expected, expected + 1, expected + 2]:
+                # big enough thresholds shouldn't change the result
+                res2 = traceback._levenshtein_distance(a, b, threshold)
+                self.assertEqual(res2, expected, msg=(a, b, threshold))
+
+            for threshold in range(expected):
+                # for small thresholds, the only piece of information
+                # we receive is "strings not close enough".
+                res3 = traceback._levenshtein_distance(a, b, threshold)
+                self.assertGreater(res3, threshold, msg=(a, b, threshold))
+
+    @cpython_only
+    def test_suggestions_extension(self):
+        # Check that the C extension is available
+        import _suggestions
+
+        self.assertEqual(
+            _suggestions._generate_suggestions(
+                ["hello", "world"],
+                "hell"
+            ),
+            "hello"
+        )
+        self.assertEqual(
+            _suggestions._generate_suggestions(
+                ["hovercraft"],
+                "eels"
+            ),
+            None
+        )
+
+        # gh-131936: _generate_suggestions() doesn't accept list subclasses
+        class MyList(list):
+            pass
+
+        with self.assertRaises(TypeError):
+            _suggestions._generate_suggestions(MyList(), "")
+
+
+
+
+class TestColorizedTraceback(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_colorized_traceback(self):
+        def foo(*args):
+            x = {'a':{'b': None}}
+            y = x['a']['b']['c']
+
+        def baz2(*args):
+            return (lambda *args: foo(*args))(1,2,3,4)
+
+        def baz1(*args):
+            return baz2(1,2,3,4)
+
+        def bar():
+            return baz1(1,
+                    2,3
+                    ,4)
+        try:
+            bar()
+        except Exception as e:
+            exc = traceback.TracebackException.from_exception(
+                e, capture_locals=True
+            )
+        lines = "".join(exc.format(colorize=True))
+        red = _colorize.ANSIColors.RED
+        boldr = _colorize.ANSIColors.BOLD_RED
+        reset = _colorize.ANSIColors.RESET
+        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)
+        self.assertIn("return baz2(1,2,3,4)", lines)
+        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")
+        except SyntaxError as e:
+            exc = traceback.TracebackException.from_exception(
+                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)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_colorized_traceback_is_the_default(self):
+        def foo():
+            1/0
+
+        from _testcapi import exception_print
+        try:
+            foo()
+            self.fail("No exception thrown.")
+        except Exception as e:
+            with captured_output("stderr") as tbstderr:
+                with unittest.mock.patch('_colorize.can_colorize', return_value=True):
+                    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)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_colorized_traceback_from_exception_group(self):
+        def foo():
+            exceptions = []
+            try:
+                1 / 0
+            except ZeroDivisionError as inner_exc:
+                exceptions.append(inner_exc)
+            raise ExceptionGroup("test", exceptions)
+
+        try:
+            foo()
+        except Exception as e:
+            exc = traceback.TracebackException.from_exception(
+                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)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_tty.py b/Lib/test/test_tty.py
new file mode 100644
index 0000000000..681772fb51
--- /dev/null
+++ b/Lib/test/test_tty.py
@@ -0,0 +1,96 @@
+import os
+import unittest
+from test.support.import_helper import import_module
+
+termios = import_module('termios')
+tty = import_module('tty')
+
+
+@unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
+class TestTty(unittest.TestCase):
+
+    def setUp(self):
+        master_fd, self.fd = os.openpty()
+        self.addCleanup(os.close, master_fd)
+        self.stream = self.enterContext(open(self.fd, 'wb', buffering=0))
+        self.fd = self.stream.fileno()
+        self.mode = termios.tcgetattr(self.fd)
+        self.addCleanup(termios.tcsetattr, self.fd, termios.TCSANOW, self.mode)
+        self.addCleanup(termios.tcsetattr, self.fd, termios.TCSAFLUSH, self.mode)
+
+    def check_cbreak(self, mode):
+        self.assertEqual(mode[3] & termios.ECHO, 0)
+        self.assertEqual(mode[3] & termios.ICANON, 0)
+        self.assertEqual(mode[6][termios.VMIN], 1)
+        self.assertEqual(mode[6][termios.VTIME], 0)
+
+    def check_raw(self, mode):
+        self.check_cbreak(mode)
+        self.assertEqual(mode[0] & termios.ISTRIP, 0)
+        self.assertEqual(mode[0] & termios.ICRNL, 0)
+        self.assertEqual(mode[1] & termios.OPOST, 0)
+        self.assertEqual(mode[2] & termios.PARENB, termios.CS8 & termios.PARENB)
+        self.assertEqual(mode[2] & termios.CSIZE, termios.CS8 & termios.CSIZE)
+        self.assertEqual(mode[2] & termios.CS8, termios.CS8)
+        self.assertEqual(mode[3] & termios.ECHO, 0)
+        self.assertEqual(mode[3] & termios.ICANON, 0)
+        self.assertEqual(mode[3] & termios.ISIG, 0)
+        self.assertEqual(mode[6][termios.VMIN], 1)
+        self.assertEqual(mode[6][termios.VTIME], 0)
+
+    def test_cfmakeraw(self):
+        mode = termios.tcgetattr(self.fd)
+        self.assertEqual(mode, self.mode)
+        tty.cfmakeraw(mode)
+        self.check_raw(mode)
+        self.assertEqual(mode[4], self.mode[4])
+        self.assertEqual(mode[5], self.mode[5])
+
+    def test_cfmakecbreak(self):
+        mode = termios.tcgetattr(self.fd)
+        self.assertEqual(mode, self.mode)
+        tty.cfmakecbreak(mode)
+        self.check_cbreak(mode)
+        self.assertEqual(mode[1], self.mode[1])
+        self.assertEqual(mode[2], self.mode[2])
+        self.assertEqual(mode[4], self.mode[4])
+        self.assertEqual(mode[5], self.mode[5])
+        mode[tty.IFLAG] |= termios.ICRNL
+        tty.cfmakecbreak(mode)
+        self.assertEqual(mode[tty.IFLAG] & termios.ICRNL, termios.ICRNL,
+                         msg="ICRNL should not be cleared by cbreak")
+        mode[tty.IFLAG] &= ~termios.ICRNL
+        tty.cfmakecbreak(mode)
+        self.assertEqual(mode[tty.IFLAG] & termios.ICRNL, 0,
+                         msg="ICRNL should not be set by cbreak")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON TypeError: Expected type "int" but "FileIO" found.
+    def test_setraw(self):
+        mode0 = termios.tcgetattr(self.fd)
+        mode1 = tty.setraw(self.fd)
+        self.assertEqual(mode1, mode0)
+        mode2 = termios.tcgetattr(self.fd)
+        self.check_raw(mode2)
+        mode3 = tty.setraw(self.fd, termios.TCSANOW)
+        self.assertEqual(mode3, mode2)
+        tty.setraw(self.stream)
+        tty.setraw(fd=self.fd, when=termios.TCSANOW)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON TypeError: Expected type "int" but "FileIO" found.
+    def test_setcbreak(self):
+        mode0 = termios.tcgetattr(self.fd)
+        mode1 = tty.setcbreak(self.fd)
+        self.assertEqual(mode1, mode0)
+        mode2 = termios.tcgetattr(self.fd)
+        self.check_cbreak(mode2)
+        ICRNL = termios.ICRNL
+        self.assertEqual(mode2[tty.IFLAG] & ICRNL, mode0[tty.IFLAG] & ICRNL,
+                         msg="ICRNL should not be altered by cbreak")
+        mode3 = tty.setcbreak(self.fd, termios.TCSANOW)
+        self.assertEqual(mode3, mode2)
+        tty.setcbreak(self.stream)
+        tty.setcbreak(fd=self.fd, when=termios.TCSANOW)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_tuple.py b/Lib/test/test_tuple.py
index d2a2ed310b..153df0e52d 100644
--- a/Lib/test/test_tuple.py
+++ b/Lib/test/test_tuple.py
@@ -42,6 +42,35 @@ def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             tuple(sequence=())
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_keywords_in_subclass(self):
+        class subclass(tuple):
+            pass
+        u = subclass([1, 2])
+        self.assertIs(type(u), subclass)
+        self.assertEqual(list(u), [1, 2])
+        with self.assertRaises(TypeError):
+            subclass(sequence=())
+
+        class subclass_with_init(tuple):
+            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(list(u), [1, 2])
+        self.assertEqual(u.newarg, 3)
+
+        class subclass_with_new(tuple):
+            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(list(u), [1, 2])
+        self.assertEqual(u.newarg, 3)
+
     def test_truth(self):
         super().test_truth()
         self.assertTrue(not ())
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 59dc9814fb..b57fdf35fb 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -591,12 +591,11 @@ def test_format_spec_errors(self):
         for code in 'xXobns':
             self.assertRaises(ValueError, format, 0, ',' + code)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_internal_sizes(self):
         self.assertGreater(object.__basicsize__, 0)
         self.assertGreater(tuple.__itemsize__, 0)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_slot_wrapper_types(self):
         self.assertIsInstance(object.__init__, types.WrapperDescriptorType)
         self.assertIsInstance(object.__str__, types.WrapperDescriptorType)
@@ -611,6 +610,7 @@ def test_dunder_get_signature(self):
         # gh-93021: Second parameter is optional
         self.assertIs(sig.parameters["owner"].default, None)
 
+    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_method_wrapper_types(self):
         self.assertIsInstance(object().__init__, types.MethodWrapperType)
         self.assertIsInstance(object().__str__, types.MethodWrapperType)
@@ -836,8 +836,6 @@ def test_union_parameter_chaining(self):
         self.assertEqual((list[T] | list[S])[int, T], list[int] | list[T])
         self.assertEqual((list[T] | list[S])[int, int], list[int])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_union_parameter_substitution(self):
         def eq(actual, expected, typed=True):
             self.assertEqual(actual, expected)
@@ -2052,8 +2050,6 @@ async def corofunc():
         else:
             self.fail('StopIteration was expected')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gen(self):
         def gen_func():
             yield 1
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index a048c39cc9..17cbaa9221 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -25,6 +25,7 @@
 from typing import assert_type, cast, runtime_checkable
 from typing import get_type_hints
 from typing import get_origin, get_args, get_protocol_members
+from typing import override
 from typing import is_typeddict, is_protocol
 from typing import reveal_type
 from typing import dataclass_transform
@@ -48,8 +49,8 @@
 from test.support.testcase import ExtraAssertions
 from test.typinganndata import ann_module695, mod_generics_cache, _typed_dict_helper
 
-# TODO: RUSTPYTHON
-import unittest
+import unittest # XXX: RUSTPYTHON
+
 
 CANNOT_SUBCLASS_TYPE = 'Cannot subclass special typing classes'
 NOT_A_BASE_TYPE = "type 'typing.%s' is not an acceptable base type"
@@ -619,6 +620,7 @@ def test_constructor(self):
         self.assertIs(T.__contravariant__, False)
         self.assertIs(T.__infer_variance__, True)
 
+
 class TypeParameterDefaultsTests(BaseTestCase):
     def test_typevar(self):
         T = TypeVar('T', default=int)
@@ -804,13 +806,12 @@ def test_pickle(self):
                 self.assertEqual(z.__default__, typevar.__default__)
 
 
-
 def template_replace(templates: list[str], replacements: dict[str, list[str]]) -> list[tuple[str]]:
     """Renders templates with possible combinations of replacements.
 
     Example 1: Suppose that:
       templates = ["dog_breed are awesome", "dog_breed are cool"]
-      replacements = ["dog_breed": ["Huskies", "Beagles"]]
+      replacements = {"dog_breed": ["Huskies", "Beagles"]}
     Then we would return:
       [
           ("Huskies are awesome", "Huskies are cool"),
@@ -906,7 +907,6 @@ def test_no_duplicates_if_replacement_not_in_templates(self):
         self.assertEqual(actual, expected)
 
 
-
 class GenericAliasSubstitutionTests(BaseTestCase):
     """Tests for type variable substitution in generic aliases.
 
@@ -966,8 +966,7 @@ class C(Generic[T]): pass
                         )
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_two_parameters(self):
         T1 = TypeVar('T1')
         T2 = TypeVar('T2')
@@ -1065,13 +1064,14 @@ class C(Generic[T1, T2, T3]): pass
                             eval(expected_str)
                         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_variadic_parameters(self):
         T1 = TypeVar('T1')
         T2 = TypeVar('T2')
         Ts = TypeVarTuple('Ts')
 
+        class C(Generic[*Ts]): pass
+
         generics = ['C', 'tuple', 'Tuple']
         tuple_types = ['tuple', 'Tuple']
 
@@ -1169,12 +1169,10 @@ def test_variadic_parameters(self):
 
 
 
-
-
 class UnpackTests(BaseTestCase):
 
     def test_accepts_single_type(self):
-        # (*tuple[int],)
+        (*tuple[int],)
         Unpack[Tuple[int]]
 
     def test_dir(self):
@@ -1228,8 +1226,6 @@ class New[*Ts]: ...
         self.assertEqual(PartNew[Unpack[tuple[str]]].__args__, (int, str))
         self.assertEqual(PartNew[Unpack[Tuple[str]]].__args__, (int, str))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_unpack_wrong_type(self):
         Ts = TypeVarTuple("Ts")
         class Gen[*Ts]: ...
@@ -1241,6 +1237,7 @@ class Gen[*Ts]: ...
         with self.assertRaisesRegex(TypeError, bad_unpack_param):
             PartGen[Unpack[List[int]]]
 
+
 class TypeVarTupleTests(BaseTestCase):
 
     def test_name(self):
@@ -1627,7 +1624,6 @@ def func3(*args: '*CustomVariadic[int, str]'): pass
         self.assertEqual(gth(func3, localns={'CustomVariadic': CustomVariadic}),
                          {'args': Unpack[CustomVariadic[int, str]]})
 
-
     def test_tuple_args_are_correct(self):
         Ts = TypeVarTuple('Ts')
 
@@ -1807,7 +1803,6 @@ def g(*args: *Ts): pass
         self.assertEqual(f.__annotations__, {'args': Unpack[Ts]})
         self.assertEqual(g.__annotations__, {'args': (*Ts,)[0]})
 
-
     def test_variadic_args_with_ellipsis_annotations_are_correct(self):
         def a(*args: *tuple[int, ...]): pass
         self.assertEqual(a.__annotations__,
@@ -1817,7 +1812,6 @@ def b(*args: Unpack[Tuple[int, ...]]): pass
         self.assertEqual(b.__annotations__,
                          {'args': Unpack[Tuple[int, ...]]})
 
-
     def test_concatenation_in_variadic_args_annotations_are_correct(self):
         Ts = TypeVarTuple('Ts')
 
@@ -1948,13 +1942,13 @@ class D(Generic[Unpack[Ts]]): pass
         self.assertNotEqual(C[*Ts1], C[*Ts2])
         self.assertNotEqual(D[Unpack[Ts1]], D[Unpack[Ts2]])
 
+
 class TypeVarTuplePicklingTests(BaseTestCase):
     # These are slightly awkward tests to run, because TypeVarTuples are only
     # picklable if defined in the global scope. We therefore need to push
     # various things defined in these tests into the global scope with `global`
     # statements at the start of each test.
 
-    # TODO: RUSTPYTHON
     @all_pickle_protocols
     def test_pickling_then_unpickling_results_in_same_identity(self, proto):
         global global_Ts1  # See explanation at start of class.
@@ -1998,7 +1992,6 @@ def test_pickling_then_unpickling_tuple_with_typevartuple_equality(
             self.assertEqual(t, t2)
 
 
-
 class UnionTests(BaseTestCase):
 
     def test_basics(self):
@@ -2616,7 +2609,6 @@ def test_errors(self):
         with self.assertRaisesRegex(TypeError, "few arguments for"):
             C1[int]
 
-
 class TypingCallableTests(BaseCallableTests, BaseTestCase):
     Callable = typing.Callable
 
@@ -2885,8 +2877,6 @@ def method(self) -> int: ...
 
         self.assertNotIsSubclass(NotImpl, Foo)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pep695_generics_can_be_runtime_checkable(self):
         @runtime_checkable
         class HasX(Protocol):
@@ -2905,7 +2895,6 @@ def __init__(self, y):
         self.assertIsInstance(Bar(1), HasX)
         self.assertNotIsInstance(Capybara('a'), HasX)
 
-
     def test_everything_implements_empty_protocol(self):
         @runtime_checkable
         class Empty(Protocol):
@@ -2950,8 +2939,23 @@ class E(C, BP): pass
         self.assertNotIsInstance(D(), E)
         self.assertNotIsInstance(E(), D)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    def test_inheritance_from_object(self):
+        # Inheritance from object is specifically allowed, unlike other nominal classes
+        class P(Protocol, object):
+            x: int
+
+        self.assertEqual(typing.get_protocol_members(P), {'x'})
+
+        class OldGeneric(Protocol, Generic[T], object):
+            y: T
+
+        self.assertEqual(typing.get_protocol_members(OldGeneric), {'y'})
+
+        class NewGeneric[T](Protocol, object):
+            z: T
+
+        self.assertEqual(typing.get_protocol_members(NewGeneric), {'z'})
+
     def test_no_instantiation(self):
         class P(Protocol): pass
 
@@ -2995,7 +2999,6 @@ class C: pass
         P.__init__(c, 1)
         self.assertEqual(c.x, 1)
 
-
     def test_concrete_class_inheriting_init_from_protocol(self):
         class P(Protocol):
             x: int
@@ -3152,7 +3155,6 @@ def x(self): ...
         with self.assertRaisesRegex(TypeError, only_classes_allowed):
             issubclass(1, BadPG)
 
-
     def test_implicit_issubclass_between_two_protocols(self):
         @runtime_checkable
         class CallableMembersProto(Protocol):
@@ -3180,255 +3182,1364 @@ class MixedMembersProto1(Protocol):
             meth: Callable[[], None]
             def meth2(self): ...
 
-        class MixedMembersProto2(Protocol):
-            def meth(self): ...
-            meth2: Callable[[str, int], bool]
+        class MixedMembersProto2(Protocol):
+            def meth(self): ...
+            meth2: Callable[[str, int], bool]
+
+        for proto in (
+            IdenticalProto, SupersetProto, NonCallableMembersProto,
+            NonCallableMembersSupersetProto, MixedMembersProto1, MixedMembersProto2
+        ):
+            with self.subTest(proto=proto.__name__):
+                self.assertIsSubclass(proto, CallableMembersProto)
+
+        # These two shouldn't be considered subclasses of CallableMembersProto, however,
+        # since they don't have the `meth` protocol member
+
+        class EmptyProtocol(Protocol): ...
+        class UnrelatedProtocol(Protocol):
+            def wut(self): ...
+
+        self.assertNotIsSubclass(EmptyProtocol, CallableMembersProto)
+        self.assertNotIsSubclass(UnrelatedProtocol, CallableMembersProto)
+
+        # These aren't protocols at all (despite having annotations),
+        # so they should only be considered subclasses of CallableMembersProto
+        # if they *actually have an attribute* matching the `meth` member
+        # (just having an annotation is insufficient)
+
+        class AnnotatedButNotAProtocol:
+            meth: Callable[[], None]
+
+        class NotAProtocolButAnImplicitSubclass:
+            def meth(self): pass
+
+        class NotAProtocolButAnImplicitSubclass2:
+            meth: Callable[[], None]
+            def meth(self): pass
+
+        class NotAProtocolButAnImplicitSubclass3:
+            meth: Callable[[], None]
+            meth2: Callable[[int, str], bool]
+            def meth(self): pass
+            def meth2(self, x, y): return True
+
+        self.assertNotIsSubclass(AnnotatedButNotAProtocol, CallableMembersProto)
+        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass, CallableMembersProto)
+        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass2, CallableMembersProto)
+        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass3, CallableMembersProto)
+
+    @unittest.skip('TODO: RUSTPYTHON; (no gc)')
+    def test_isinstance_checks_not_at_whim_of_gc(self):
+        self.addCleanup(gc.enable)
+        gc.disable()
+
+        with self.assertRaisesRegex(
+            TypeError,
+            "Protocols can only inherit from other protocols"
+        ):
+            class Foo(collections.abc.Mapping, Protocol):
+                pass
+
+        self.assertNotIsInstance([], collections.abc.Mapping)
+
+    def test_issubclass_and_isinstance_on_Protocol_itself(self):
+        class C:
+            def x(self): pass
+
+        self.assertNotIsSubclass(object, Protocol)
+        self.assertNotIsInstance(object(), Protocol)
+
+        self.assertNotIsSubclass(str, Protocol)
+        self.assertNotIsInstance('foo', Protocol)
+
+        self.assertNotIsSubclass(C, Protocol)
+        self.assertNotIsInstance(C(), Protocol)
+
+        only_classes_allowed = r"issubclass\(\) arg 1 must be a class"
+
+        with self.assertRaisesRegex(TypeError, only_classes_allowed):
+            issubclass(1, Protocol)
+        with self.assertRaisesRegex(TypeError, only_classes_allowed):
+            issubclass('foo', Protocol)
+        with self.assertRaisesRegex(TypeError, only_classes_allowed):
+            issubclass(C(), Protocol)
+
+        T = TypeVar('T')
+
+        @runtime_checkable
+        class EmptyProtocol(Protocol): pass
+
+        @runtime_checkable
+        class SupportsStartsWith(Protocol):
+            def startswith(self, x: str) -> bool: ...
+
+        @runtime_checkable
+        class SupportsX(Protocol[T]):
+            def x(self): ...
+
+        for proto in EmptyProtocol, SupportsStartsWith, SupportsX:
+            with self.subTest(proto=proto.__name__):
+                self.assertIsSubclass(proto, Protocol)
+
+        # gh-105237 / PR #105239:
+        # check that the presence of Protocol subclasses
+        # where `issubclass(X, <subclass>)` evaluates to True
+        # doesn't influence the result of `issubclass(X, Protocol)`
+
+        self.assertIsSubclass(object, EmptyProtocol)
+        self.assertIsInstance(object(), EmptyProtocol)
+        self.assertNotIsSubclass(object, Protocol)
+        self.assertNotIsInstance(object(), Protocol)
+
+        self.assertIsSubclass(str, SupportsStartsWith)
+        self.assertIsInstance('foo', SupportsStartsWith)
+        self.assertNotIsSubclass(str, Protocol)
+        self.assertNotIsInstance('foo', Protocol)
+
+        self.assertIsSubclass(C, SupportsX)
+        self.assertIsInstance(C(), SupportsX)
+        self.assertNotIsSubclass(C, Protocol)
+        self.assertNotIsInstance(C(), Protocol)
+
+    def test_protocols_issubclass_non_callable(self):
+        class C:
+            x = 1
+
+        @runtime_checkable
+        class PNonCall(Protocol):
+            x = 1
+
+        non_callable_members_illegal = (
+            "Protocols with non-method members don't support issubclass()"
+        )
+
+        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
+            issubclass(C, PNonCall)
+
+        self.assertIsInstance(C(), PNonCall)
+        PNonCall.register(C)
+
+        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
+            issubclass(C, PNonCall)
+
+        self.assertIsInstance(C(), PNonCall)
+
+        # check that non-protocol subclasses are not affected
+        class D(PNonCall): ...
+
+        self.assertNotIsSubclass(C, D)
+        self.assertNotIsInstance(C(), D)
+        D.register(C)
+        self.assertIsSubclass(C, D)
+        self.assertIsInstance(C(), D)
+
+        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
+            issubclass(D, PNonCall)
+
+    def test_no_weird_caching_with_issubclass_after_isinstance(self):
+        @runtime_checkable
+        class Spam(Protocol):
+            x: int
+
+        class Eggs:
+            def __init__(self) -> None:
+                self.x = 42
+
+        self.assertIsInstance(Eggs(), Spam)
+
+        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
+        # TypeError wouldn't be raised here,
+        # as the cached result of the isinstance() check immediately above
+        # would mean the issubclass() call would short-circuit
+        # before we got to the "raise TypeError" line
+        with self.assertRaisesRegex(
+            TypeError,
+            "Protocols with non-method members don't support issubclass()"
+        ):
+            issubclass(Eggs, Spam)
+
+    def test_no_weird_caching_with_issubclass_after_isinstance_2(self):
+        @runtime_checkable
+        class Spam(Protocol):
+            x: int
+
+        class Eggs: ...
+
+        self.assertNotIsInstance(Eggs(), Spam)
+
+        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
+        # TypeError wouldn't be raised here,
+        # as the cached result of the isinstance() check immediately above
+        # would mean the issubclass() call would short-circuit
+        # before we got to the "raise TypeError" line
+        with self.assertRaisesRegex(
+            TypeError,
+            "Protocols with non-method members don't support issubclass()"
+        ):
+            issubclass(Eggs, Spam)
+
+    def test_no_weird_caching_with_issubclass_after_isinstance_3(self):
+        @runtime_checkable
+        class Spam(Protocol):
+            x: int
+
+        class Eggs:
+            def __getattr__(self, attr):
+                if attr == "x":
+                    return 42
+                raise AttributeError(attr)
+
+        self.assertNotIsInstance(Eggs(), Spam)
+
+        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
+        # TypeError wouldn't be raised here,
+        # as the cached result of the isinstance() check immediately above
+        # would mean the issubclass() call would short-circuit
+        # before we got to the "raise TypeError" line
+        with self.assertRaisesRegex(
+            TypeError,
+            "Protocols with non-method members don't support issubclass()"
+        ):
+            issubclass(Eggs, Spam)
+
+    def test_no_weird_caching_with_issubclass_after_isinstance_pep695(self):
+        @runtime_checkable
+        class Spam[T](Protocol):
+            x: T
+
+        class Eggs[T]:
+            def __init__(self, x: T) -> None:
+                self.x = x
+
+        self.assertIsInstance(Eggs(42), Spam)
+
+        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
+        # TypeError wouldn't be raised here,
+        # as the cached result of the isinstance() check immediately above
+        # would mean the issubclass() call would short-circuit
+        # before we got to the "raise TypeError" line
+        with self.assertRaisesRegex(
+            TypeError,
+            "Protocols with non-method members don't support issubclass()"
+        ):
+            issubclass(Eggs, Spam)
+
+    def test_protocols_isinstance(self):
+        T = TypeVar('T')
+
+        @runtime_checkable
+        class P(Protocol):
+            def meth(x): ...
+
+        @runtime_checkable
+        class PG(Protocol[T]):
+            def meth(x): ...
+
+        @runtime_checkable
+        class WeirdProto(Protocol):
+            meth = str.maketrans
+
+        @runtime_checkable
+        class WeirdProto2(Protocol):
+            meth = lambda *args, **kwargs: None
+
+        class CustomCallable:
+            def __call__(self, *args, **kwargs):
+                pass
+
+        @runtime_checkable
+        class WeirderProto(Protocol):
+            meth = CustomCallable()
+
+        class BadP(Protocol):
+            def meth(x): ...
+
+        class BadPG(Protocol[T]):
+            def meth(x): ...
+
+        class C:
+            def meth(x): ...
+
+        class C2:
+            def __init__(self):
+                self.meth = lambda: None
+
+        for klass in C, C2:
+            for proto in P, PG, WeirdProto, WeirdProto2, WeirderProto:
+                with self.subTest(klass=klass.__name__, proto=proto.__name__):
+                    self.assertIsInstance(klass(), proto)
+
+        no_subscripted_generics = "Subscripted generics cannot be used with class and instance checks"
+
+        with self.assertRaisesRegex(TypeError, no_subscripted_generics):
+            isinstance(C(), PG[T])
+        with self.assertRaisesRegex(TypeError, no_subscripted_generics):
+            isinstance(C(), PG[C])
+
+        only_runtime_checkable_msg = (
+            "Instance and class checks can only be used "
+            "with @runtime_checkable protocols"
+        )
+
+        with self.assertRaisesRegex(TypeError, only_runtime_checkable_msg):
+            isinstance(C(), BadP)
+        with self.assertRaisesRegex(TypeError, only_runtime_checkable_msg):
+            isinstance(C(), BadPG)
+
+    def test_protocols_isinstance_properties_and_descriptors(self):
+        class C:
+            @property
+            def attr(self):
+                return 42
+
+        class CustomDescriptor:
+            def __get__(self, obj, objtype=None):
+                return 42
+
+        class D:
+            attr = CustomDescriptor()
+
+        # Check that properties set on superclasses
+        # are still found by the isinstance() logic
+        class E(C): ...
+        class F(D): ...
+
+        class Empty: ...
+
+        T = TypeVar('T')
+
+        @runtime_checkable
+        class P(Protocol):
+            @property
+            def attr(self): ...
+
+        @runtime_checkable
+        class P1(Protocol):
+            attr: int
+
+        @runtime_checkable
+        class PG(Protocol[T]):
+            @property
+            def attr(self): ...
+
+        @runtime_checkable
+        class PG1(Protocol[T]):
+            attr: T
+
+        @runtime_checkable
+        class MethodP(Protocol):
+            def attr(self): ...
+
+        @runtime_checkable
+        class MethodPG(Protocol[T]):
+            def attr(self) -> T: ...
+
+        for protocol_class in P, P1, PG, PG1, MethodP, MethodPG:
+            for klass in C, D, E, F:
+                with self.subTest(
+                    klass=klass.__name__,
+                    protocol_class=protocol_class.__name__
+                ):
+                    self.assertIsInstance(klass(), protocol_class)
+
+            with self.subTest(klass="Empty", protocol_class=protocol_class.__name__):
+                self.assertNotIsInstance(Empty(), protocol_class)
+
+        class BadP(Protocol):
+            @property
+            def attr(self): ...
+
+        class BadP1(Protocol):
+            attr: int
+
+        class BadPG(Protocol[T]):
+            @property
+            def attr(self): ...
+
+        class BadPG1(Protocol[T]):
+            attr: T
+
+        cases = (
+            PG[T], PG[C], PG1[T], PG1[C], MethodPG[T],
+            MethodPG[C], BadP, BadP1, BadPG, BadPG1
+        )
+
+        for obj in cases:
+            for klass in C, D, E, F, Empty:
+                with self.subTest(klass=klass.__name__, obj=obj):
+                    with self.assertRaises(TypeError):
+                        isinstance(klass(), obj)
+
+    def test_protocols_isinstance_not_fooled_by_custom_dir(self):
+        @runtime_checkable
+        class HasX(Protocol):
+            x: int
+
+        class CustomDirWithX:
+            x = 10
+            def __dir__(self):
+                return []
+
+        class CustomDirWithoutX:
+            def __dir__(self):
+                return ["x"]
+
+        self.assertIsInstance(CustomDirWithX(), HasX)
+        self.assertNotIsInstance(CustomDirWithoutX(), HasX)
+
+    def test_protocols_isinstance_attribute_access_with_side_effects(self):
+        class C:
+            @property
+            def attr(self):
+                raise AttributeError('no')
+
+        class CustomDescriptor:
+            def __get__(self, obj, objtype=None):
+                raise RuntimeError("NO")
+
+        class D:
+            attr = CustomDescriptor()
+
+        # Check that properties set on superclasses
+        # are still found by the isinstance() logic
+        class E(C): ...
+        class F(D): ...
+
+        class WhyWouldYouDoThis:
+            def __getattr__(self, name):
+                raise RuntimeError("wut")
+
+        T = TypeVar('T')
+
+        @runtime_checkable
+        class P(Protocol):
+            @property
+            def attr(self): ...
+
+        @runtime_checkable
+        class P1(Protocol):
+            attr: int
+
+        @runtime_checkable
+        class PG(Protocol[T]):
+            @property
+            def attr(self): ...
+
+        @runtime_checkable
+        class PG1(Protocol[T]):
+            attr: T
+
+        @runtime_checkable
+        class MethodP(Protocol):
+            def attr(self): ...
+
+        @runtime_checkable
+        class MethodPG(Protocol[T]):
+            def attr(self) -> T: ...
+
+        for protocol_class in P, P1, PG, PG1, MethodP, MethodPG:
+            for klass in C, D, E, F:
+                with self.subTest(
+                    klass=klass.__name__,
+                    protocol_class=protocol_class.__name__
+                ):
+                    self.assertIsInstance(klass(), protocol_class)
+
+            with self.subTest(
+                klass="WhyWouldYouDoThis",
+                protocol_class=protocol_class.__name__
+            ):
+                self.assertNotIsInstance(WhyWouldYouDoThis(), protocol_class)
+
+    def test_protocols_isinstance___slots__(self):
+        # As per the consensus in https://github.com/python/typing/issues/1367,
+        # this is desirable behaviour
+        @runtime_checkable
+        class HasX(Protocol):
+            x: int
+
+        class HasNothingButSlots:
+            __slots__ = ("x",)
+
+        self.assertIsInstance(HasNothingButSlots(), HasX)
+
+    def test_protocols_isinstance_py36(self):
+        class APoint:
+            def __init__(self, x, y, label):
+                self.x = x
+                self.y = y
+                self.label = label
+
+        class BPoint:
+            label = 'B'
+
+            def __init__(self, x, y):
+                self.x = x
+                self.y = y
+
+        class C:
+            def __init__(self, attr):
+                self.attr = attr
+
+            def meth(self, arg):
+                return 0
+
+        class Bad: pass
+
+        self.assertIsInstance(APoint(1, 2, 'A'), Point)
+        self.assertIsInstance(BPoint(1, 2), Point)
+        self.assertNotIsInstance(MyPoint(), Point)
+        self.assertIsInstance(BPoint(1, 2), Position)
+        self.assertIsInstance(Other(), Proto)
+        self.assertIsInstance(Concrete(), Proto)
+        self.assertIsInstance(C(42), Proto)
+        self.assertNotIsInstance(Bad(), Proto)
+        self.assertNotIsInstance(Bad(), Point)
+        self.assertNotIsInstance(Bad(), Position)
+        self.assertNotIsInstance(Bad(), Concrete)
+        self.assertNotIsInstance(Other(), Concrete)
+        self.assertIsInstance(NT(1, 2), Position)
+
+    def test_protocols_isinstance_init(self):
+        T = TypeVar('T')
+
+        @runtime_checkable
+        class P(Protocol):
+            x = 1
+
+        @runtime_checkable
+        class PG(Protocol[T]):
+            x = 1
+
+        class C:
+            def __init__(self, x):
+                self.x = x
+
+        self.assertIsInstance(C(1), P)
+        self.assertIsInstance(C(1), PG)
+
+    def test_protocols_isinstance_monkeypatching(self):
+        @runtime_checkable
+        class HasX(Protocol):
+            x: int
+
+        class Foo: ...
+
+        f = Foo()
+        self.assertNotIsInstance(f, HasX)
+        f.x = 42
+        self.assertIsInstance(f, HasX)
+        del f.x
+        self.assertNotIsInstance(f, HasX)
+
+    def test_protocol_checks_after_subscript(self):
+        class P(Protocol[T]): pass
+        class C(P[T]): pass
+        class Other1: pass
+        class Other2: pass
+        CA = C[Any]
+
+        self.assertNotIsInstance(Other1(), C)
+        self.assertNotIsSubclass(Other2, C)
+
+        class D1(C[Any]): pass
+        class D2(C[Any]): pass
+        CI = C[int]
+
+        self.assertIsInstance(D1(), C)
+        self.assertIsSubclass(D2, C)
+
+    def test_protocols_support_register(self):
+        @runtime_checkable
+        class P(Protocol):
+            x = 1
+
+        class PM(Protocol):
+            def meth(self): pass
+
+        class D(PM): pass
+
+        class C: pass
+
+        D.register(C)
+        P.register(C)
+        self.assertIsInstance(C(), P)
+        self.assertIsInstance(C(), D)
+
+    def test_none_on_non_callable_doesnt_block_implementation(self):
+        @runtime_checkable
+        class P(Protocol):
+            x = 1
+
+        class A:
+            x = 1
+
+        class B(A):
+            x = None
+
+        class C:
+            def __init__(self):
+                self.x = None
+
+        self.assertIsInstance(B(), P)
+        self.assertIsInstance(C(), P)
+
+    def test_none_on_callable_blocks_implementation(self):
+        @runtime_checkable
+        class P(Protocol):
+            def x(self): ...
+
+        class A:
+            def x(self): ...
+
+        class B(A):
+            x = None
+
+        class C:
+            def __init__(self):
+                self.x = None
+
+        self.assertNotIsInstance(B(), P)
+        self.assertNotIsInstance(C(), P)
+
+    def test_non_protocol_subclasses(self):
+        class P(Protocol):
+            x = 1
+
+        @runtime_checkable
+        class PR(Protocol):
+            def meth(self): pass
+
+        class NonP(P):
+            x = 1
+
+        class NonPR(PR): pass
+
+        class C(metaclass=abc.ABCMeta):
+            x = 1
+
+        class D(metaclass=abc.ABCMeta):
+            def meth(self): pass
+
+        self.assertNotIsInstance(C(), NonP)
+        self.assertNotIsInstance(D(), NonPR)
+        self.assertNotIsSubclass(C, NonP)
+        self.assertNotIsSubclass(D, NonPR)
+        self.assertIsInstance(NonPR(), PR)
+        self.assertIsSubclass(NonPR, PR)
+
+        self.assertNotIn("__protocol_attrs__", vars(NonP))
+        self.assertNotIn("__protocol_attrs__", vars(NonPR))
+        self.assertNotIn("__non_callable_proto_members__", vars(NonP))
+        self.assertNotIn("__non_callable_proto_members__", vars(NonPR))
+
+        self.assertEqual(get_protocol_members(P), {"x"})
+        self.assertEqual(get_protocol_members(PR), {"meth"})
+
+        # the returned object should be immutable,
+        # and should be a different object to the original attribute
+        # to prevent users from (accidentally or deliberately)
+        # mutating the attribute on the original class
+        self.assertIsInstance(get_protocol_members(P), frozenset)
+        self.assertIsNot(get_protocol_members(P), P.__protocol_attrs__)
+        self.assertIsInstance(get_protocol_members(PR), frozenset)
+        self.assertIsNot(get_protocol_members(PR), P.__protocol_attrs__)
+
+        acceptable_extra_attrs = {
+            '_is_protocol', '_is_runtime_protocol', '__parameters__',
+            '__init__', '__annotations__', '__subclasshook__',
+        }
+        self.assertLessEqual(vars(NonP).keys(), vars(C).keys() | acceptable_extra_attrs)
+        self.assertLessEqual(
+            vars(NonPR).keys(), vars(D).keys() | acceptable_extra_attrs
+        )
+
+    def test_custom_subclasshook(self):
+        class P(Protocol):
+            x = 1
+
+        class OKClass: pass
+
+        class BadClass:
+            x = 1
+
+        class C(P):
+            @classmethod
+            def __subclasshook__(cls, other):
+                return other.__name__.startswith("OK")
+
+        self.assertIsInstance(OKClass(), C)
+        self.assertNotIsInstance(BadClass(), C)
+        self.assertIsSubclass(OKClass, C)
+        self.assertNotIsSubclass(BadClass, C)
+
+    def test_custom_subclasshook_2(self):
+        @runtime_checkable
+        class HasX(Protocol):
+            # The presence of a non-callable member
+            # would mean issubclass() checks would fail with TypeError
+            # if it weren't for the custom `__subclasshook__` method
+            x = 1
+
+            @classmethod
+            def __subclasshook__(cls, other):
+                return hasattr(other, 'x')
+
+        class Empty: pass
+
+        class ImplementsHasX:
+            x = 1
+
+        self.assertIsInstance(ImplementsHasX(), HasX)
+        self.assertNotIsInstance(Empty(), HasX)
+        self.assertIsSubclass(ImplementsHasX, HasX)
+        self.assertNotIsSubclass(Empty, HasX)
+
+        # isinstance() and issubclass() checks against this still raise TypeError,
+        # despite the presence of the custom __subclasshook__ method,
+        # as it's not decorated with @runtime_checkable
+        class NotRuntimeCheckable(Protocol):
+            @classmethod
+            def __subclasshook__(cls, other):
+                return hasattr(other, 'x')
+
+        must_be_runtime_checkable = (
+            "Instance and class checks can only be used "
+            "with @runtime_checkable protocols"
+        )
+
+        with self.assertRaisesRegex(TypeError, must_be_runtime_checkable):
+            issubclass(object, NotRuntimeCheckable)
+        with self.assertRaisesRegex(TypeError, must_be_runtime_checkable):
+            isinstance(object(), NotRuntimeCheckable)
+
+    def test_issubclass_fails_correctly(self):
+        @runtime_checkable
+        class NonCallableMembers(Protocol):
+            x = 1
+
+        class NotRuntimeCheckable(Protocol):
+            def callable_member(self) -> int: ...
+
+        @runtime_checkable
+        class RuntimeCheckable(Protocol):
+            def callable_member(self) -> int: ...
+
+        class C: pass
+
+        # These three all exercise different code paths,
+        # but should result in the same error message:
+        for protocol in NonCallableMembers, NotRuntimeCheckable, RuntimeCheckable:
+            with self.subTest(proto_name=protocol.__name__):
+                with self.assertRaisesRegex(
+                    TypeError, r"issubclass\(\) arg 1 must be a class"
+                ):
+                    issubclass(C(), protocol)
+
+    def test_defining_generic_protocols(self):
+        T = TypeVar('T')
+        S = TypeVar('S')
+
+        @runtime_checkable
+        class PR(Protocol[T, S]):
+            def meth(self): pass
+
+        class P(PR[int, T], Protocol[T]):
+            y = 1
+
+        with self.assertRaises(TypeError):
+            PR[int]
+        with self.assertRaises(TypeError):
+            P[int, str]
+
+        class C(PR[int, T]): pass
+
+        self.assertIsInstance(C[str](), C)
+
+    def test_defining_generic_protocols_old_style(self):
+        T = TypeVar('T')
+        S = TypeVar('S')
+
+        @runtime_checkable
+        class PR(Protocol, Generic[T, S]):
+            def meth(self): pass
+
+        class P(PR[int, str], Protocol):
+            y = 1
+
+        with self.assertRaises(TypeError):
+            issubclass(PR[int, str], PR)
+        self.assertIsSubclass(P, PR)
+        with self.assertRaises(TypeError):
+            PR[int]
+
+        class P1(Protocol, Generic[T]):
+            def bar(self, x: T) -> str: ...
+
+        class P2(Generic[T], Protocol):
+            def bar(self, x: T) -> str: ...
+
+        @runtime_checkable
+        class PSub(P1[str], Protocol):
+            x = 1
+
+        class Test:
+            x = 1
+
+            def bar(self, x: str) -> str:
+                return x
+
+        self.assertIsInstance(Test(), PSub)
+
+    def test_pep695_generic_protocol_callable_members(self):
+        @runtime_checkable
+        class Foo[T](Protocol):
+            def meth(self, x: T) -> None: ...
+
+        class Bar[T]:
+            def meth(self, x: T) -> None: ...
+
+        self.assertIsInstance(Bar(), Foo)
+        self.assertIsSubclass(Bar, Foo)
+
+        @runtime_checkable
+        class SupportsTrunc[T](Protocol):
+            def __trunc__(self) -> T: ...
+
+        self.assertIsInstance(0.0, SupportsTrunc)
+        self.assertIsSubclass(float, SupportsTrunc)
+
+    def test_init_called(self):
+        T = TypeVar('T')
+
+        class P(Protocol[T]): pass
+
+        class C(P[T]):
+            def __init__(self):
+                self.test = 'OK'
+
+        self.assertEqual(C[int]().test, 'OK')
+
+        class B:
+            def __init__(self):
+                self.test = 'OK'
+
+        class D1(B, P[T]):
+            pass
+
+        self.assertEqual(D1[int]().test, 'OK')
+
+        class D2(P[T], B):
+            pass
+
+        self.assertEqual(D2[int]().test, 'OK')
+
+    def test_new_called(self):
+        T = TypeVar('T')
+
+        class P(Protocol[T]): pass
+
+        class C(P[T]):
+            def __new__(cls, *args):
+                self = super().__new__(cls, *args)
+                self.test = 'OK'
+                return self
+
+        self.assertEqual(C[int]().test, 'OK')
+        with self.assertRaises(TypeError):
+            C[int](42)
+        with self.assertRaises(TypeError):
+            C[int](a=42)
+
+    def test_protocols_bad_subscripts(self):
+        T = TypeVar('T')
+        S = TypeVar('S')
+        with self.assertRaises(TypeError):
+            class P(Protocol[T, T]): pass
+        with self.assertRaises(TypeError):
+            class Q(Protocol[int]): pass
+        with self.assertRaises(TypeError):
+            class R(Protocol[T], Protocol[S]): pass
+        with self.assertRaises(TypeError):
+            class S(typing.Mapping[T, S], Protocol[T]): pass
+
+    def test_generic_protocols_repr(self):
+        T = TypeVar('T')
+        S = TypeVar('S')
+
+        class P(Protocol[T, S]): pass
+
+        self.assertTrue(repr(P[T, S]).endswith('P[~T, ~S]'))
+        self.assertTrue(repr(P[int, str]).endswith('P[int, str]'))
+
+    def test_generic_protocols_eq(self):
+        T = TypeVar('T')
+        S = TypeVar('S')
+
+        class P(Protocol[T, S]): pass
+
+        self.assertEqual(P, P)
+        self.assertEqual(P[int, T], P[int, T])
+        self.assertEqual(P[T, T][Tuple[T, S]][int, str],
+                         P[Tuple[int, str], Tuple[int, str]])
+
+    def test_generic_protocols_special_from_generic(self):
+        T = TypeVar('T')
+
+        class P(Protocol[T]): pass
+
+        self.assertEqual(P.__parameters__, (T,))
+        self.assertEqual(P[int].__parameters__, ())
+        self.assertEqual(P[int].__args__, (int,))
+        self.assertIs(P[int].__origin__, P)
+
+    def test_generic_protocols_special_from_protocol(self):
+        @runtime_checkable
+        class PR(Protocol):
+            x = 1
+
+        class P(Protocol):
+            def meth(self):
+                pass
+
+        T = TypeVar('T')
+
+        class PG(Protocol[T]):
+            x = 1
+
+            def meth(self):
+                pass
+
+        self.assertTrue(P._is_protocol)
+        self.assertTrue(PR._is_protocol)
+        self.assertTrue(PG._is_protocol)
+        self.assertFalse(P._is_runtime_protocol)
+        self.assertTrue(PR._is_runtime_protocol)
+        self.assertTrue(PG[int]._is_protocol)
+        self.assertEqual(typing._get_protocol_attrs(P), {'meth'})
+        self.assertEqual(typing._get_protocol_attrs(PR), {'x'})
+        self.assertEqual(frozenset(typing._get_protocol_attrs(PG)),
+                         frozenset({'x', 'meth'}))
+
+    def test_no_runtime_deco_on_nominal(self):
+        with self.assertRaises(TypeError):
+            @runtime_checkable
+            class C: pass
+
+        class Proto(Protocol):
+            x = 1
+
+        with self.assertRaises(TypeError):
+            @runtime_checkable
+            class Concrete(Proto):
+                pass
+
+    def test_none_treated_correctly(self):
+        @runtime_checkable
+        class P(Protocol):
+            x = None  # type: int
+
+        class B(object): pass
+
+        self.assertNotIsInstance(B(), P)
+
+        class C:
+            x = 1
+
+        class D:
+            x = None
+
+        self.assertIsInstance(C(), P)
+        self.assertIsInstance(D(), P)
+
+        class CI:
+            def __init__(self):
+                self.x = 1
+
+        class DI:
+            def __init__(self):
+                self.x = None
+
+        self.assertIsInstance(CI(), P)
+        self.assertIsInstance(DI(), P)
+
+    def test_protocols_in_unions(self):
+        class P(Protocol):
+            x = None  # type: int
+
+        Alias = typing.Union[typing.Iterable, P]
+        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')
+
+        @runtime_checkable
+        class P(Protocol[T]):
+            x = 1
+
+        class CP(P[int]):
+            pass
+
+        c = CP()
+        c.foo = 42
+        c.bar = 'abc'
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            z = pickle.dumps(c, proto)
+            x = pickle.loads(z)
+            self.assertEqual(x.foo, 42)
+            self.assertEqual(x.bar, 'abc')
+            self.assertEqual(x.x, 1)
+            self.assertEqual(x.__dict__, {'foo': 42, 'bar': 'abc'})
+            s = pickle.dumps(P, proto)
+            D = pickle.loads(s)
+
+            class E:
+                x = 1
+
+            self.assertIsInstance(E(), D)
+
+    def test_runtime_checkable_with_match_args(self):
+        @runtime_checkable
+        class P_regular(Protocol):
+            x: int
+            y: int
+
+        @runtime_checkable
+        class P_match(Protocol):
+            __match_args__ = ('x', 'y')
+            x: int
+            y: int
+
+        class Regular:
+            def __init__(self, x: int, y: int):
+                self.x = x
+                self.y = y
+
+        class WithMatch:
+            __match_args__ = ('x', 'y', 'z')
+            def __init__(self, x: int, y: int, z: int):
+                self.x = x
+                self.y = y
+                self.z = z
+
+        class Nope: ...
+
+        self.assertIsInstance(Regular(1, 2), P_regular)
+        self.assertIsInstance(Regular(1, 2), P_match)
+        self.assertIsInstance(WithMatch(1, 2, 3), P_regular)
+        self.assertIsInstance(WithMatch(1, 2, 3), P_match)
+        self.assertNotIsInstance(Nope(), P_regular)
+        self.assertNotIsInstance(Nope(), P_match)
+
+    def test_supports_int(self):
+        self.assertIsSubclass(int, typing.SupportsInt)
+        self.assertNotIsSubclass(str, typing.SupportsInt)
 
-        for proto in (
-            IdenticalProto, SupersetProto, NonCallableMembersProto,
-            NonCallableMembersSupersetProto, MixedMembersProto1, MixedMembersProto2
-        ):
-            with self.subTest(proto=proto.__name__):
-                self.assertIsSubclass(proto, CallableMembersProto)
+    def test_supports_float(self):
+        self.assertIsSubclass(float, typing.SupportsFloat)
+        self.assertNotIsSubclass(str, typing.SupportsFloat)
 
-        # These two shouldn't be considered subclasses of CallableMembersProto, however,
-        # since they don't have the `meth` protocol member
+    def test_supports_complex(self):
 
-        class EmptyProtocol(Protocol): ...
-        class UnrelatedProtocol(Protocol):
-            def wut(self): ...
+        class C:
+            def __complex__(self):
+                return 0j
 
-        self.assertNotIsSubclass(EmptyProtocol, CallableMembersProto)
-        self.assertNotIsSubclass(UnrelatedProtocol, CallableMembersProto)
+        self.assertIsSubclass(complex, typing.SupportsComplex)
+        self.assertIsSubclass(C, typing.SupportsComplex)
+        self.assertNotIsSubclass(str, typing.SupportsComplex)
 
-        # These aren't protocols at all (despite having annotations),
-        # so they should only be considered subclasses of CallableMembersProto
-        # if they *actually have an attribute* matching the `meth` member
-        # (just having an annotation is insufficient)
+    def test_supports_bytes(self):
 
-        class AnnotatedButNotAProtocol:
-            meth: Callable[[], None]
+        class B:
+            def __bytes__(self):
+                return b''
+
+        self.assertIsSubclass(bytes, typing.SupportsBytes)
+        self.assertIsSubclass(B, typing.SupportsBytes)
+        self.assertNotIsSubclass(str, typing.SupportsBytes)
+
+    def test_supports_abs(self):
+        self.assertIsSubclass(float, typing.SupportsAbs)
+        self.assertIsSubclass(int, typing.SupportsAbs)
+        self.assertNotIsSubclass(str, typing.SupportsAbs)
+
+    def test_supports_round(self):
+        issubclass(float, typing.SupportsRound)
+        self.assertIsSubclass(float, typing.SupportsRound)
+        self.assertIsSubclass(int, typing.SupportsRound)
+        self.assertNotIsSubclass(str, typing.SupportsRound)
+
+    def test_reversible(self):
+        self.assertIsSubclass(list, typing.Reversible)
+        self.assertNotIsSubclass(int, typing.Reversible)
+
+    def test_supports_index(self):
+        self.assertIsSubclass(int, typing.SupportsIndex)
+        self.assertNotIsSubclass(str, typing.SupportsIndex)
+
+    def test_bundled_protocol_instance_works(self):
+        self.assertIsInstance(0, typing.SupportsAbs)
+        class C1(typing.SupportsInt):
+            def __int__(self) -> int:
+                return 42
+        class C2(C1):
+            pass
+        c = C2()
+        self.assertIsInstance(c, C1)
 
-        class NotAProtocolButAnImplicitSubclass:
-            def meth(self): pass
+    def test_collections_protocols_allowed(self):
+        @runtime_checkable
+        class Custom(collections.abc.Iterable, Protocol):
+            def close(self): ...
 
-        class NotAProtocolButAnImplicitSubclass2:
-            meth: Callable[[], None]
-            def meth(self): pass
+        class A: pass
+        class B:
+            def __iter__(self):
+                return []
+            def close(self):
+                return 0
 
-        class NotAProtocolButAnImplicitSubclass3:
-            meth: Callable[[], None]
-            meth2: Callable[[int, str], bool]
-            def meth(self): pass
-            def meth2(self, x, y): return True
+        self.assertIsSubclass(B, Custom)
+        self.assertNotIsSubclass(A, Custom)
 
-        self.assertNotIsSubclass(AnnotatedButNotAProtocol, CallableMembersProto)
-        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass, CallableMembersProto)
-        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass2, CallableMembersProto)
-        self.assertIsSubclass(NotAProtocolButAnImplicitSubclass3, CallableMembersProto)
+        @runtime_checkable
+        class ReleasableBuffer(collections.abc.Buffer, Protocol):
+            def __release_buffer__(self, mv: memoryview) -> None: ...
 
-    # TODO: RUSTPYTHON
-    @unittest.skip("TODO: RUSTPYTHON (no gc)")
-    def test_isinstance_checks_not_at_whim_of_gc(self):
-        self.addCleanup(gc.enable)
-        gc.disable()
+        class C: pass
+        class D:
+            def __buffer__(self, flags: int) -> memoryview:
+                return memoryview(b'')
+            def __release_buffer__(self, mv: memoryview) -> None:
+                pass
 
-        with self.assertRaisesRegex(
-            TypeError,
-            "Protocols can only inherit from other protocols"
-        ):
-            class Foo(collections.abc.Mapping, Protocol):
+        self.assertIsSubclass(D, ReleasableBuffer)
+        self.assertIsInstance(D(), ReleasableBuffer)
+        self.assertNotIsSubclass(C, ReleasableBuffer)
+        self.assertNotIsInstance(C(), ReleasableBuffer)
+
+    def test_builtin_protocol_allowlist(self):
+        with self.assertRaises(TypeError):
+            class CustomProtocol(TestCase, Protocol):
                 pass
 
-        self.assertNotIsInstance([], collections.abc.Mapping)
+        class CustomContextManager(typing.ContextManager, Protocol):
+            pass
 
-    def test_issubclass_and_isinstance_on_Protocol_itself(self):
-        class C:
-            def x(self): pass
+        class CustomAsyncIterator(typing.AsyncIterator, Protocol):
+            pass
 
-        self.assertNotIsSubclass(object, Protocol)
-        self.assertNotIsInstance(object(), Protocol)
+    def test_non_runtime_protocol_isinstance_check(self):
+        class P(Protocol):
+            x: int
 
-        self.assertNotIsSubclass(str, Protocol)
-        self.assertNotIsInstance('foo', Protocol)
+        with self.assertRaisesRegex(TypeError, "@runtime_checkable"):
+            isinstance(1, P)
 
-        self.assertNotIsSubclass(C, Protocol)
-        self.assertNotIsInstance(C(), Protocol)
+    def test_super_call_init(self):
+        class P(Protocol):
+            x: int
 
-        only_classes_allowed = r"issubclass\(\) arg 1 must be a class"
+        class Foo(P):
+            def __init__(self):
+                super().__init__()
 
-        with self.assertRaisesRegex(TypeError, only_classes_allowed):
-            issubclass(1, Protocol)
-        with self.assertRaisesRegex(TypeError, only_classes_allowed):
-            issubclass('foo', Protocol)
-        with self.assertRaisesRegex(TypeError, only_classes_allowed):
-            issubclass(C(), Protocol)
+        Foo()  # Previously triggered RecursionError
 
-        T = TypeVar('T')
+    def test_get_protocol_members(self):
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(object)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(object())
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(Protocol)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(Generic)
 
-        @runtime_checkable
-        class EmptyProtocol(Protocol): pass
+        class P(Protocol):
+            a: int
+            def b(self) -> str: ...
+            @property
+            def c(self) -> int: ...
 
-        @runtime_checkable
-        class SupportsStartsWith(Protocol):
-            def startswith(self, x: str) -> bool: ...
+        self.assertEqual(get_protocol_members(P), {'a', 'b', 'c'})
+        self.assertIsInstance(get_protocol_members(P), frozenset)
+        self.assertIsNot(get_protocol_members(P), P.__protocol_attrs__)
 
-        @runtime_checkable
-        class SupportsX(Protocol[T]):
-            def x(self): ...
+        class Concrete:
+            a: int
+            def b(self) -> str: return "capybara"
+            @property
+            def c(self) -> int: return 5
 
-        for proto in EmptyProtocol, SupportsStartsWith, SupportsX:
-            with self.subTest(proto=proto.__name__):
-                self.assertIsSubclass(proto, Protocol)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(Concrete)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(Concrete())
 
-        # gh-105237 / PR #105239:
-        # check that the presence of Protocol subclasses
-        # where `issubclass(X, <subclass>)` evaluates to True
-        # doesn't influence the result of `issubclass(X, Protocol)`
+        class ConcreteInherit(P):
+            a: int = 42
+            def b(self) -> str: return "capybara"
+            @property
+            def c(self) -> int: return 5
 
-        self.assertIsSubclass(object, EmptyProtocol)
-        self.assertIsInstance(object(), EmptyProtocol)
-        self.assertNotIsSubclass(object, Protocol)
-        self.assertNotIsInstance(object(), Protocol)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(ConcreteInherit)
+        with self.assertRaisesRegex(TypeError, "not a Protocol"):
+            get_protocol_members(ConcreteInherit())
 
-        self.assertIsSubclass(str, SupportsStartsWith)
-        self.assertIsInstance('foo', SupportsStartsWith)
-        self.assertNotIsSubclass(str, Protocol)
-        self.assertNotIsInstance('foo', Protocol)
+    def test_is_protocol(self):
+        self.assertTrue(is_protocol(Proto))
+        self.assertTrue(is_protocol(Point))
+        self.assertFalse(is_protocol(Concrete))
+        self.assertFalse(is_protocol(Concrete()))
+        self.assertFalse(is_protocol(Generic))
+        self.assertFalse(is_protocol(object))
 
-        self.assertIsSubclass(C, SupportsX)
-        self.assertIsInstance(C(), SupportsX)
-        self.assertNotIsSubclass(C, Protocol)
-        self.assertNotIsInstance(C(), Protocol)
+        # Protocol is not itself a protocol
+        self.assertFalse(is_protocol(Protocol))
 
-    def test_protocols_issubclass_non_callable(self):
-        class C:
-            x = 1
+    def test_interaction_with_isinstance_checks_on_superclasses_with_ABCMeta(self):
+        # Ensure the cache is empty, or this test won't work correctly
+        collections.abc.Sized._abc_registry_clear()
 
-        @runtime_checkable
-        class PNonCall(Protocol):
-            x = 1
+        class Foo(collections.abc.Sized, Protocol): pass
 
-        non_callable_members_illegal = (
-            "Protocols with non-method members don't support issubclass()"
-        )
+        # gh-105144: this previously raised TypeError
+        # if a Protocol subclass of Sized had been created
+        # before any isinstance() checks against Sized
+        self.assertNotIsInstance(1, collections.abc.Sized)
 
-        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
-            issubclass(C, PNonCall)
+    def test_interaction_with_isinstance_checks_on_superclasses_with_ABCMeta_2(self):
+        # Ensure the cache is empty, or this test won't work correctly
+        collections.abc.Sized._abc_registry_clear()
 
-        self.assertIsInstance(C(), PNonCall)
-        PNonCall.register(C)
+        class Foo(typing.Sized, Protocol): pass
 
-        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
-            issubclass(C, PNonCall)
+        # gh-105144: this previously raised TypeError
+        # if a Protocol subclass of Sized had been created
+        # before any isinstance() checks against Sized
+        self.assertNotIsInstance(1, typing.Sized)
 
-        self.assertIsInstance(C(), PNonCall)
+    def test_empty_protocol_decorated_with_final(self):
+        @final
+        @runtime_checkable
+        class EmptyProtocol(Protocol): ...
 
-        # check that non-protocol subclasses are not affected
-        class D(PNonCall): ...
+        self.assertIsSubclass(object, EmptyProtocol)
+        self.assertIsInstance(object(), EmptyProtocol)
 
-        self.assertNotIsSubclass(C, D)
-        self.assertNotIsInstance(C(), D)
-        D.register(C)
-        self.assertIsSubclass(C, D)
-        self.assertIsInstance(C(), D)
+    def test_protocol_decorated_with_final_callable_members(self):
+        @final
+        @runtime_checkable
+        class ProtocolWithMethod(Protocol):
+            def startswith(self, string: str) -> bool: ...
 
-        with self.assertRaisesRegex(TypeError, non_callable_members_illegal):
-            issubclass(D, PNonCall)
+        self.assertIsSubclass(str, ProtocolWithMethod)
+        self.assertNotIsSubclass(int, ProtocolWithMethod)
+        self.assertIsInstance('foo', ProtocolWithMethod)
+        self.assertNotIsInstance(42, ProtocolWithMethod)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_no_weird_caching_with_issubclass_after_isinstance(self):
+    def test_protocol_decorated_with_final_noncallable_members(self):
+        @final
         @runtime_checkable
-        class Spam(Protocol):
+        class ProtocolWithNonCallableMember(Protocol):
             x: int
 
-        class Eggs:
-            def __init__(self) -> None:
-                self.x = 42
+        class Foo:
+            x = 42
 
-        self.assertIsInstance(Eggs(), Spam)
+        only_callable_members_please = (
+            r"Protocols with non-method members don't support issubclass()"
+        )
 
-        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
-        # TypeError wouldn't be raised here,
-        # as the cached result of the isinstance() check immediately above
-        # would mean the issubclass() call would short-circuit
-        # before we got to the "raise TypeError" line
-        with self.assertRaisesRegex(
-            TypeError,
-            "Protocols with non-method members don't support issubclass()"
-        ):
-            issubclass(Eggs, Spam)
+        with self.assertRaisesRegex(TypeError, only_callable_members_please):
+            issubclass(Foo, ProtocolWithNonCallableMember)
 
-    def test_no_weird_caching_with_issubclass_after_isinstance_2(self):
+        with self.assertRaisesRegex(TypeError, only_callable_members_please):
+            issubclass(int, ProtocolWithNonCallableMember)
+
+        self.assertIsInstance(Foo(), ProtocolWithNonCallableMember)
+        self.assertNotIsInstance(42, ProtocolWithNonCallableMember)
+
+    def test_protocol_decorated_with_final_mixed_members(self):
+        @final
         @runtime_checkable
-        class Spam(Protocol):
+        class ProtocolWithMixedMembers(Protocol):
             x: int
+            def method(self) -> None: ...
 
-        class Eggs: ...
+        class Foo:
+            x = 42
+            def method(self) -> None: ...
 
-        self.assertNotIsInstance(Eggs(), Spam)
+        only_callable_members_please = (
+            r"Protocols with non-method members don't support issubclass()"
+        )
 
-        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
-        # TypeError wouldn't be raised here,
-        # as the cached result of the isinstance() check immediately above
-        # would mean the issubclass() call would short-circuit
-        # before we got to the "raise TypeError" line
-        with self.assertRaisesRegex(
-            TypeError,
-            "Protocols with non-method members don't support issubclass()"
-        ):
-            issubclass(Eggs, Spam)
+        with self.assertRaisesRegex(TypeError, only_callable_members_please):
+            issubclass(Foo, ProtocolWithMixedMembers)
 
-    def test_no_weird_caching_with_issubclass_after_isinstance_3(self):
+        with self.assertRaisesRegex(TypeError, only_callable_members_please):
+            issubclass(int, ProtocolWithMixedMembers)
+
+        self.assertIsInstance(Foo(), ProtocolWithMixedMembers)
+        self.assertNotIsInstance(42, ProtocolWithMixedMembers)
+
+    def test_protocol_issubclass_error_message(self):
         @runtime_checkable
-        class Spam(Protocol):
-            x: int
+        class Vec2D(Protocol):
+            x: float
+            y: float
 
-        class Eggs:
-            def __getattr__(self, attr):
-                if attr == "x":
-                    return 42
-                raise AttributeError(attr)
+            def square_norm(self) -> float:
+                return self.x ** 2 + self.y ** 2
 
-        self.assertNotIsInstance(Eggs(), Spam)
+        self.assertEqual(Vec2D.__protocol_attrs__, {'x', 'y', 'square_norm'})
+        expected_error_message = (
+            "Protocols with non-method members don't support issubclass()."
+            " Non-method members: 'x', 'y'."
+        )
+        with self.assertRaisesRegex(TypeError, re.escape(expected_error_message)):
+            issubclass(int, Vec2D)
 
-        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
-        # TypeError wouldn't be raised here,
-        # as the cached result of the isinstance() check immediately above
-        # would mean the issubclass() call would short-circuit
-        # before we got to the "raise TypeError" line
-        with self.assertRaisesRegex(
-            TypeError,
-            "Protocols with non-method members don't support issubclass()"
-        ):
-            issubclass(Eggs, Spam)
+    def test_nonruntime_protocol_interaction_with_evil_classproperty(self):
+        class classproperty:
+            def __get__(self, instance, type):
+                raise RuntimeError("NO")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_no_weird_caching_with_issubclass_after_isinstance_pep695(self):
-        @runtime_checkable
-        class Spam[T](Protocol):
-            x: T
+        class Commentable(Protocol):
+            evil = classproperty()
 
-        class Eggs[T]:
-            def __init__(self, x: T) -> None:
-                self.x = x
+        # recognised as a protocol attr,
+        # but not actually accessed by the protocol metaclass
+        # (which would raise RuntimeError) for non-runtime protocols.
+        # See gh-113320
+        self.assertEqual(get_protocol_members(Commentable), {"evil"})
 
-        self.assertIsInstance(Eggs(42), Spam)
+    def test_runtime_protocol_interaction_with_evil_classproperty(self):
+        class CustomError(Exception): pass
 
-        # gh-104555: If we didn't override ABCMeta.__subclasscheck__ in _ProtocolMeta,
-        # TypeError wouldn't be raised here,
-        # as the cached result of the isinstance() check immediately above
-        # would mean the issubclass() call would short-circuit
-        # before we got to the "raise TypeError" line
-        with self.assertRaisesRegex(
-            TypeError,
-            "Protocols with non-method members don't support issubclass()"
-        ):
-            issubclass(Eggs, Spam)
-    
-    # FIXME(arihant2math): start more porting from test_protocols_isinstance
+        class classproperty:
+            def __get__(self, instance, type):
+                raise CustomError
+
+        with self.assertRaises(TypeError) as cm:
+            @runtime_checkable
+            class Commentable(Protocol):
+                evil = classproperty()
+
+        exc = cm.exception
+        self.assertEqual(
+            exc.args[0],
+            "Failed to determine whether protocol member 'evil' is a method member"
+        )
+        self.assertIs(type(exc.__cause__), CustomError)
 
 
 class GenericTests(BaseTestCase):
@@ -3888,8 +4999,6 @@ def test_pep695_generic_class_with_future_annotations(self):
         # should not have changed as a result of the get_type_hints() calls!
         self.assertEqual(ann_module695.__dict__, original_globals)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pep695_generic_class_with_future_annotations_and_local_shadowing(self):
         hints_for_B = get_type_hints(ann_module695.B)
         self.assertEqual(hints_for_B, {"x": int, "y": str, "z": bytes})
@@ -3935,8 +5044,6 @@ def test_pep_695_generic_method_with_future_annotations_name_clash_with_global_v
             set(ann_module695.D.generic_method_2.__type_params__)
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pep_695_generics_with_future_annotations_nested_in_function(self):
         results = ann_module695.nested()
 
@@ -4040,8 +5147,7 @@ def test_all_repr_eq_any(self):
                     self.assertNotEqual(repr(base), '')
                     self.assertEqual(base, base)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickle(self):
         global C  # pickle wants to reference the class by name
         T = TypeVar('T')
@@ -4163,8 +5269,6 @@ def test_weakref_all(self):
         for t in things:
             self.assertEqual(weakref.ref(t)(), t)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parameterized_slots(self):
         T = TypeVar('T')
         class C(Generic[T]):
@@ -4184,8 +5288,6 @@ def foo(x: C['C']): ...
         self.assertEqual(get_type_hints(foo, globals(), locals())['x'], C[C])
         self.assertEqual(copy(C[int]), deepcopy(C[int]))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_parameterized_slots_dict(self):
         T = TypeVar('T')
         class D(Generic[T]):
@@ -4506,8 +5608,6 @@ def __init__(self, arg):
         self.assertEqual(c.from_a, 'foo')
         self.assertEqual(c.from_c, 'foo')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_new_no_args(self):
 
         class A(Generic[T]):
@@ -4613,6 +5713,24 @@ class A:
                     with self.assertRaises(TypeError):
                         a[int]
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: ".+__typing_subst__.+tuple.+int.*" does not match "'TypeAliasType' object is not subscriptable"
+    def test_return_non_tuple_while_unpacking(self):
+        # GH-138497: GenericAlias objects didn't ensure that __typing_subst__ actually
+        # returned a tuple
+        class EvilTypeVar:
+            __typing_is_unpacked_typevartuple__ = True
+            def __typing_prepare_subst__(*_):
+                return None  # any value
+            def __typing_subst__(*_):
+                return 42  # not tuple
+
+        evil = EvilTypeVar()
+        # Create a dummy TypeAlias that will be given the evil generic from
+        # above.
+        type type_alias[*_] = 0
+        with self.assertRaisesRegex(TypeError, ".+__typing_subst__.+tuple.+int.*"):
+            type_alias[evil][0]
+
 
 class ClassVarTests(BaseTestCase):
 
@@ -4659,7 +5777,6 @@ def test_no_isinstance(self):
         with self.assertRaises(TypeError):
             issubclass(int, ClassVar)
 
-
 class FinalTests(BaseTestCase):
 
     def test_basics(self):
@@ -4716,8 +5833,7 @@ def test_final_unmodified(self):
         def func(x): ...
         self.assertIs(func, final(func))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dunder_final(self):
         @final
         def func(): ...
@@ -4788,8 +5904,6 @@ def cached(self): ...
 
 
 class OverrideDecoratorTests(BaseTestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_override(self):
         class Base:
             def normal_method(self): ...
@@ -4848,8 +5962,6 @@ def static_method_bad_order():
         self.assertIs(False, hasattr(Base.static_method_good_order, "__override__"))
         self.assertIs(False, hasattr(Base.static_method_bad_order, "__override__"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_property(self):
         class Base:
             @property
@@ -4876,8 +5988,6 @@ def wrong(self) -> int:
         self.assertFalse(hasattr(Child.wrong, "__override__"))
         self.assertFalse(hasattr(Child.wrong.fset, "__override__"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_silent_failure(self):
         class CustomProp:
             __slots__ = ('fget',)
@@ -4895,8 +6005,6 @@ def some(self):
         self.assertEqual(WithOverride.some, 1)
         self.assertFalse(hasattr(WithOverride.some, "__override__"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multiple_decorators(self):
         def with_wraps(f):  # similar to `lru_cache` definition
             @wraps(f)
@@ -4955,7 +6063,6 @@ def test_errors(self):
         self.assertIs(assert_type(arg, 'hello'), arg)
 
 
-
 # We need this to make sure that `@no_type_check` respects `__module__` attr:
 from test.typinganndata import ann_module8
 
@@ -4969,6 +6076,7 @@ class NoTypeCheck_WithFunction:
 
 
 class ForwardRefTests(BaseTestCase):
+
     def test_basics(self):
 
         class Node(Generic[T]):
@@ -5357,8 +6465,6 @@ class A:
             some.__no_type_check__
         self.assertEqual(get_type_hints(some), {'args': int, 'return': int})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_no_type_check_lambda(self):
         @no_type_check
         class A:
@@ -5579,11 +6685,11 @@ def test_overload_registry_repeated(self):
 
             self.assertEqual(list(get_overloads(impl)), overloads)
 
+
 from test.typinganndata import (
     ann_module, ann_module2, ann_module3, ann_module5, ann_module6,
 )
 
-
 T_a = TypeVar('T_a')
 
 class AwaitableWrapper(typing.Awaitable[T_a]):
@@ -5616,7 +6722,6 @@ async def __aenter__(self) -> int:
     async def __aexit__(self, etype, eval, tb):
         return None
 
-
 class A:
     y: float
 class B(A):
@@ -5710,10 +6815,9 @@ class WeirdlyQuotedMovie(TypedDict):
     title: Annotated['Annotated[Required[str], "foobar"]', "another level"]
     year: NotRequired['Annotated[int, 2000]']
 
-# TODO: RUSTPYTHON
-# class HasForeignBaseClass(mod_generics_cache.A):
-#     some_xrepr: 'XRepr'
-#     other_a: 'mod_generics_cache.A'
+class HasForeignBaseClass(mod_generics_cache.A):
+    some_xrepr: 'XRepr'
+    other_a: 'mod_generics_cache.A'
 
 async def g_with(am: typing.AsyncContextManager[int]):
     x: int
@@ -5727,7 +6831,6 @@ async def g_with(am: typing.AsyncContextManager[int]):
 
 gth = get_type_hints
 
-
 class ForRefExample:
     @ann_module.dec
     def func(self: 'ForRefExample'):
@@ -5749,8 +6852,7 @@ def test_get_type_hints_from_various_objects(self):
         with self.assertRaises(TypeError):
             gth(None)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get_type_hints_modules(self):
         ann_module_type_hints = {1: 2, 'f': Tuple[int, int], 'x': int, 'y': str, 'u': int | float}
         self.assertEqual(gth(ann_module), ann_module_type_hints)
@@ -5766,8 +6868,6 @@ def test_get_type_hints_modules_forwardref(self):
                      'default_b': Optional[mod_generics_cache.B]}
         self.assertEqual(gth(mod_generics_cache), mgc_hints)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_get_type_hints_classes(self):
         self.assertEqual(gth(ann_module.C),  # gth will find the right globalns
                          {'y': Optional[ann_module.C]})
@@ -6003,8 +7103,7 @@ def test_top_level_class_var(self):
         ):
             get_type_hints(ann_module6)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get_type_hints_typeddict(self):
         self.assertEqual(get_type_hints(TotalMovie), {'title': str, 'year': int})
         self.assertEqual(get_type_hints(TotalMovie, include_extras=True), {
@@ -6058,7 +7157,6 @@ def h(x: collections.abc.Callable[P, int]): ...
         self.assertEqual(get_type_hints(h), {'x': collections.abc.Callable[P, int]})
 
 
-
 class GetUtilitiesTestCase(TestCase):
     def test_get_origin(self):
         T = TypeVar('T')
@@ -6160,7 +7258,6 @@ class C(Generic[T]): pass
         self.assertEqual(get_args(Unpack[tuple[Unpack[Ts]]]), (tuple[Unpack[Ts]],))
 
 
-
 class CollectionsAbcTests(BaseTestCase):
 
     def test_hashable(self):
@@ -6653,8 +7750,6 @@ def manager():
         self.assertIsInstance(cm, typing.ContextManager)
         self.assertNotIsInstance(42, typing.ContextManager)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_contextmanager_type_params(self):
         cm1 = typing.ContextManager[int]
         self.assertEqual(get_args(cm1), (int, bool | None))
@@ -6820,7 +7915,6 @@ class ProUserId(UserId):
                 ...
 
 
-
 class NamedTupleTests(BaseTestCase):
     class NestedEmployee(NamedTuple):
         name: str
@@ -6940,8 +8034,6 @@ class Y(Generic[T], NamedTuple):
                 with self.assertRaises(TypeError):
                     G[int, str]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_generic_pep695(self):
         class X[T](NamedTuple):
             x: T
@@ -7052,8 +8144,6 @@ class CNT(NamedTuple):
                 self.assertEqual(struct.__annotations__, {})
                 self.assertIsInstance(struct(), struct)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_namedtuple_errors(self):
         with self.assertRaises(TypeError):
             NamedTuple.__new__()
@@ -7141,8 +8231,7 @@ class Bar(NamedTuple):
         self.assertIsInstance(bar.attr, Vanilla)
         self.assertEqual(bar.attr.name, "attr")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_setname_raises_the_same_as_on_other_classes(self):
         class CustomException(BaseException): pass
 
@@ -7313,6 +8402,22 @@ class TD2(TD1):
 
         self.assertIs(TD2.__total__, True)
 
+    def test_total_with_assigned_value(self):
+        class TD(TypedDict):
+            __total__ = "some_value"
+
+        self.assertIs(TD.__total__, True)
+
+        class TD2(TypedDict, total=True):
+            __total__ = "some_value"
+
+        self.assertIs(TD2.__total__, True)
+
+        class TD3(TypedDict, total=False):
+            __total__ = "some value"
+
+        self.assertIs(TD3.__total__, False)
+
     def test_optional_keys(self):
         class Point2Dor3D(Point2D, total=False):
             z: int
@@ -7542,16 +8647,14 @@ class NewGeneric[T](TypedDict):
         # The TypedDict constructor is not itself a TypedDict
         self.assertIs(is_typeddict(TypedDict), False)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get_type_hints(self):
         self.assertEqual(
             get_type_hints(Bar),
             {'a': typing.Optional[int], 'b': int}
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_get_type_hints_generic(self):
         self.assertEqual(
             get_type_hints(BarGeneric),
@@ -7566,8 +8669,6 @@ class FooBarGeneric(BarGeneric[int]):
             {'a': typing.Optional[T], 'b': int, 'c': str}
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pep695_generic_typeddict(self):
         class A[T](TypedDict):
             a: T
@@ -7686,8 +8787,7 @@ class WithImplicitAny(B):
         with self.assertRaises(TypeError):
             WithImplicitAny[str]
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_non_generic_subscript(self):
         # For backward compatibility, subscription works
         # on arbitrary TypedDict types.
@@ -7815,8 +8915,7 @@ class Child(Base):
         self.assertEqual(Child.__readonly_keys__, frozenset())
         self.assertEqual(Child.__mutable_keys__, frozenset({'a'}))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_combine_qualifiers(self):
         class AllTheThings(TypedDict):
             a: Annotated[Required[ReadOnly[int]], "why not"]
@@ -8010,8 +9109,7 @@ def test_repr(self):
         self.assertEqual(repr(Match[str]), 'typing.Match[str]')
         self.assertEqual(repr(Match[bytes]), 'typing.Match[bytes]')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cannot_subclass(self):
         with self.assertRaisesRegex(
             TypeError,
@@ -8027,7 +9125,6 @@ class B(typing.Pattern):
                 pass
 
 
-
 class AnnotatedTests(BaseTestCase):
 
     def test_new(self):
@@ -8535,7 +9632,6 @@ def test_cannot_subscript(self):
             TypeAlias[int]
 
 
-
 class ParamSpecTests(BaseTestCase):
 
     def test_basic_plain(self):
@@ -8570,8 +9666,6 @@ def test_valid_uses(self):
         self.assertEqual(C4.__args__, (P, T))
         self.assertEqual(C4.__parameters__, (P, T))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_args_kwargs(self):
         P = ParamSpec('P')
         P_2 = ParamSpec('P_2')
@@ -8591,7 +9685,6 @@ def test_args_kwargs(self):
         self.assertEqual(repr(P.args), "P.args")
         self.assertEqual(repr(P.kwargs), "P.kwargs")
 
-
     def test_stringized(self):
         P = ParamSpec('P')
         class C(Generic[P]):
@@ -8933,7 +10026,6 @@ class G(P.args): pass
             class H(P.kwargs): pass
 
 
-
 class ConcatenateTests(BaseTestCase):
     def test_basics(self):
         P = ParamSpec('P')
@@ -9000,7 +10092,6 @@ def test_var_substitution(self):
         self.assertEqual(C[Concatenate[str, P2]], Concatenate[int, str, P2])
         self.assertEqual(C[...], Concatenate[int, ...])
 
-
 class TypeGuardTests(BaseTestCase):
     def test_basics(self):
         TypeGuard[int]  # OK
@@ -9106,6 +10197,7 @@ def test_no_isinstance(self):
 
 
 class SpecialAttrsTests(BaseTestCase):
+
     def test_special_attrs(self):
         cls_to_check = {
             # ABC classes
@@ -9236,8 +10328,6 @@ def test_special_attrs(self):
 
     TypeName = typing.NewType('SpecialAttrsTests.TypeName', Any)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_special_attrs2(self):
         # Forward refs provide a different introspection API. __name__ and
         # __qualname__ make little sense for forward refs as they can store
@@ -9404,8 +10494,6 @@ class CustomerModel(ModelBase, init=False):
 
 
 class NoDefaultTests(BaseTestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             s = pickle.dumps(NoDefault, proto)
@@ -9431,8 +10519,7 @@ def test_no_call(self):
         with self.assertRaises(TypeError):
             NoDefault()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_no_attributes(self):
         with self.assertRaises(AttributeError):
             NoDefault.foo = 3
@@ -9508,8 +10595,7 @@ class TypeIterationTests(BaseTestCase):
         Annotated[T, ''],
     )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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 f6d69540b9..69b58da020 100644
--- a/Lib/test/test_ucn.py
+++ b/Lib/test/test_ucn.py
@@ -10,6 +10,7 @@
 import ast
 import unittest
 import unicodedata
+import urllib.error
 
 from test import support
 from http.client import HTTPException
@@ -115,8 +116,7 @@ def test_misc_symbols(self):
         self.checkletter("HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK", "\uFF9F")
         self.checkletter("FULLWIDTH LATIN SMALL LETTER A", "\uFF41")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_aliases(self):
         # Check that the aliases defined in the NameAliases.txt file work.
         # This should be updated when new aliases are added or the file
@@ -143,8 +143,6 @@ def test_aliases(self):
             with self.assertRaises(KeyError):
                 unicodedata.ucd_3_2_0.lookup(alias)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_aliases_names_in_pua_range(self):
         # We are storing aliases in the PUA 15, but their names shouldn't leak
         for cp in range(0xf0000, 0xf0100):
@@ -152,8 +150,6 @@ def test_aliases_names_in_pua_range(self):
                 unicodedata.name(chr(cp))
             self.assertEqual(str(cm.exception), 'no such name')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_named_sequences_names_in_pua_range(self):
         # We are storing named seq in the PUA 15, but their names shouldn't leak
         for cp in range(0xf0100, 0xf0fff):
@@ -161,8 +157,7 @@ def test_named_sequences_names_in_pua_range(self):
                 unicodedata.name(chr(cp))
             self.assertEqual(str(cm.exception), 'no such name')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_sequences_sample(self):
         # Check a few named sequences.  See #12753.
         sequences = [
@@ -179,6 +174,7 @@ def test_named_sequences_sample(self):
             with self.assertRaises(KeyError):
                 unicodedata.ucd_3_2_0.lookup(seqname)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_named_sequences_full(self):
         # Check all the named sequences
         def check_version(testfile):
@@ -189,23 +185,25 @@ def check_version(testfile):
         try:
             testdata = support.open_urlresource(url, encoding="utf-8",
                                                 check=check_version)
-        except (OSError, HTTPException):
-            self.skipTest("Could not retrieve " + url)
-        self.addCleanup(testdata.close)
-        for line in testdata:
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-            seqname, codepoints = line.split(';')
-            codepoints = ''.join(chr(int(cp, 16)) for cp in codepoints.split())
-            self.assertEqual(unicodedata.lookup(seqname), codepoints)
-            with self.assertRaises(SyntaxError):
-                self.checkletter(seqname, None)
-            with self.assertRaises(KeyError):
-                unicodedata.ucd_3_2_0.lookup(seqname)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+        except urllib.error.HTTPError as exc:
+            exc.close()
+            self.skipTest(f"Could not retrieve {url}: {exc!r}")
+        except (OSError, HTTPException) as exc:
+            self.skipTest(f"Could not retrieve {url}: {exc!r}")
+        with testdata:
+            for line in testdata:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                seqname, codepoints = line.split(';')
+                codepoints = ''.join(chr(int(cp, 16)) for cp in codepoints.split())
+                self.assertEqual(unicodedata.lookup(seqname), codepoints)
+                with self.assertRaises(SyntaxError):
+                    self.checkletter(seqname, None)
+                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_unicode.py b/Lib/test/test_unicode.py
deleted file mode 100644
index 1a8a8f7ee9..0000000000
--- a/Lib/test/test_unicode.py
+++ /dev/null
@@ -1,2732 +0,0 @@
-""" Test script for the Unicode implementation.
-
-Written by Marc-Andre Lemburg (mal@lemburg.com).
-
-(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
-
-"""
-import _string
-import codecs
-import itertools
-import operator
-import pickle
-import struct
-import sys
-import textwrap
-import unicodedata
-import unittest
-import warnings
-from test.support import warnings_helper
-from test import support, string_tests
-from test.support.script_helper import assert_python_failure
-
-try:
-    import _testcapi
-except ImportError:
-    _testcapi = None
-
-# Error handling (bad decoder return)
-def search_function(encoding):
-    def decode1(input, errors="strict"):
-        return 42 # not a tuple
-    def encode1(input, errors="strict"):
-        return 42 # not a tuple
-    def encode2(input, errors="strict"):
-        return (42, 42) # no unicode
-    def decode2(input, errors="strict"):
-        return (42, 42) # no unicode
-    if encoding=="test.unicode1":
-        return (encode1, decode1, None, None)
-    elif encoding=="test.unicode2":
-        return (encode2, decode2, None, None)
-    else:
-        return None
-
-def duplicate_string(text):
-    """
-    Try to get a fresh clone of the specified text:
-    new object with a reference count of 1.
-
-    This is a best-effort: latin1 single letters and the empty
-    string ('') are singletons and cannot be cloned.
-    """
-    return text.encode().decode()
-
-class StrSubclass(str):
-    pass
-
-class UnicodeTest(string_tests.CommonTest,
-        string_tests.MixinStrUnicodeUserStringTest,
-        string_tests.MixinStrUnicodeTest,
-        unittest.TestCase):
-
-    type2test = str
-
-    def setUp(self):
-        codecs.register(search_function)
-        self.addCleanup(codecs.unregister, search_function)
-
-    def checkequalnofix(self, result, object, methodname, *args):
-        method = getattr(object, methodname)
-        realresult = method(*args)
-        self.assertEqual(realresult, result)
-        self.assertTrue(type(realresult) is type(result))
-
-        # if the original is returned make sure that
-        # this doesn't happen with subclasses
-        if realresult is object:
-            class usub(str):
-                def __repr__(self):
-                    return 'usub(%r)' % str.__repr__(self)
-            object = usub(object)
-            method = getattr(object, methodname)
-            realresult = method(*args)
-            self.assertEqual(realresult, result)
-            self.assertTrue(object is not realresult)
-
-    def test_literals(self):
-        self.assertEqual('\xff', '\u00ff')
-        self.assertEqual('\uffff', '\U0000ffff')
-        self.assertRaises(SyntaxError, eval, '\'\\Ufffffffe\'')
-        self.assertRaises(SyntaxError, eval, '\'\\Uffffffff\'')
-        self.assertRaises(SyntaxError, eval, '\'\\U%08x\'' % 0x110000)
-        # raw strings should not have unicode escapes
-        self.assertNotEqual(r"\u0020", " ")
-
-    def test_ascii(self):
-        self.assertEqual(ascii('abc'), "'abc'")
-        self.assertEqual(ascii('ab\\c'), "'ab\\\\c'")
-        self.assertEqual(ascii('ab\\'), "'ab\\\\'")
-        self.assertEqual(ascii('\\c'), "'\\\\c'")
-        self.assertEqual(ascii('\\'), "'\\\\'")
-        self.assertEqual(ascii('\n'), "'\\n'")
-        self.assertEqual(ascii('\r'), "'\\r'")
-        self.assertEqual(ascii('\t'), "'\\t'")
-        self.assertEqual(ascii('\b'), "'\\x08'")
-        self.assertEqual(ascii("'\""), """'\\'"'""")
-        self.assertEqual(ascii("'\""), """'\\'"'""")
-        self.assertEqual(ascii("'"), '''"'"''')
-        self.assertEqual(ascii('"'), """'"'""")
-        latin1repr = (
-            "'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"
-            "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"
-            "\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHI"
-            "JKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f"
-            "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d"
-            "\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b"
-            "\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9"
-            "\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7"
-            "\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5"
-            "\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3"
-            "\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1"
-            "\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef"
-            "\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd"
-            "\\xfe\\xff'")
-        testrepr = ascii(''.join(map(chr, range(256))))
-        self.assertEqual(testrepr, latin1repr)
-        # Test ascii works on wide unicode escapes without overflow.
-        self.assertEqual(ascii("\U00010000" * 39 + "\uffff" * 4096),
-                            ascii("\U00010000" * 39 + "\uffff" * 4096))
-
-        class WrongRepr:
-            def __repr__(self):
-                return b'byte-repr'
-        self.assertRaises(TypeError, ascii, WrongRepr())
-
-    def test_repr(self):
-        # Test basic sanity of repr()
-        self.assertEqual(repr('abc'), "'abc'")
-        self.assertEqual(repr('ab\\c'), "'ab\\\\c'")
-        self.assertEqual(repr('ab\\'), "'ab\\\\'")
-        self.assertEqual(repr('\\c'), "'\\\\c'")
-        self.assertEqual(repr('\\'), "'\\\\'")
-        self.assertEqual(repr('\n'), "'\\n'")
-        self.assertEqual(repr('\r'), "'\\r'")
-        self.assertEqual(repr('\t'), "'\\t'")
-        self.assertEqual(repr('\b'), "'\\x08'")
-        self.assertEqual(repr("'\""), """'\\'"'""")
-        self.assertEqual(repr("'\""), """'\\'"'""")
-        self.assertEqual(repr("'"), '''"'"''')
-        self.assertEqual(repr('"'), """'"'""")
-        latin1repr = (
-            "'\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r"
-            "\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a"
-            "\\x1b\\x1c\\x1d\\x1e\\x1f !\"#$%&\\'()*+,-./0123456789:;<=>?@ABCDEFGHI"
-            "JKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f"
-            "\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d"
-            "\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b"
-            "\\x9c\\x9d\\x9e\\x9f\\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9"
-            "\xaa\xab\xac\\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7"
-            "\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5"
-            "\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3"
-            "\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1"
-            "\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
-            "\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd"
-            "\xfe\xff'")
-        testrepr = repr(''.join(map(chr, range(256))))
-        self.assertEqual(testrepr, latin1repr)
-        # Test repr works on wide unicode escapes without overflow.
-        self.assertEqual(repr("\U00010000" * 39 + "\uffff" * 4096),
-                            repr("\U00010000" * 39 + "\uffff" * 4096))
-
-        class WrongRepr:
-            def __repr__(self):
-                return b'byte-repr'
-        self.assertRaises(TypeError, repr, WrongRepr())
-
-    def test_iterators(self):
-        # Make sure unicode objects have an __iter__ method
-        it = "\u1111\u2222\u3333".__iter__()
-        self.assertEqual(next(it), "\u1111")
-        self.assertEqual(next(it), "\u2222")
-        self.assertEqual(next(it), "\u3333")
-        self.assertRaises(StopIteration, next, it)
-
-    def test_iterators_invocation(self):
-        cases = [type(iter('abc')), type(iter('🚀'))]
-        for cls in cases:
-            with self.subTest(cls=cls):
-                self.assertRaises(TypeError, cls)
-
-    def test_iteration(self):
-        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
-        for case in cases:
-            with self.subTest(string=case):
-                self.assertEqual(case, "".join(iter(case)))
-
-    def test_exhausted_iterator(self):
-        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
-        for case in cases:
-            with self.subTest(case=case):
-                iterator = iter(case)
-                tuple(iterator)
-                self.assertRaises(StopIteration, next, iterator)
-
-    def test_pickle_iterator(self):
-        cases = ['abc', '🚀🚀🚀', "\u1111\u2222\u3333"]
-        for case in cases:
-            with self.subTest(case=case):
-                for proto in range(pickle.HIGHEST_PROTOCOL + 1):
-                    it = iter(case)
-                    with self.subTest(proto=proto):
-                        pickled = "".join(pickle.loads(pickle.dumps(it, proto)))
-                        self.assertEqual(case, pickled)
-
-    def test_count(self):
-        string_tests.CommonTest.test_count(self)
-        # check mixed argument types
-        self.checkequalnofix(3,  'aaa', 'count', 'a')
-        self.checkequalnofix(0,  'aaa', 'count', 'b')
-        self.checkequalnofix(3, 'aaa', 'count',  'a')
-        self.checkequalnofix(0, 'aaa', 'count',  'b')
-        self.checkequalnofix(0, 'aaa', 'count',  'b')
-        self.checkequalnofix(1, 'aaa', 'count',  'a', -1)
-        self.checkequalnofix(3, 'aaa', 'count',  'a', -10)
-        self.checkequalnofix(2, 'aaa', 'count',  'a', 0, -1)
-        self.checkequalnofix(0, 'aaa', 'count',  'a', 0, -10)
-        # test mixed kinds
-        self.checkequal(10, '\u0102' + 'a' * 10, 'count', 'a')
-        self.checkequal(10, '\U00100304' + 'a' * 10, 'count', 'a')
-        self.checkequal(10, '\U00100304' + '\u0102' * 10, 'count', '\u0102')
-        self.checkequal(0, 'a' * 10, 'count', '\u0102')
-        self.checkequal(0, 'a' * 10, 'count', '\U00100304')
-        self.checkequal(0, '\u0102' * 10, 'count', '\U00100304')
-        self.checkequal(10, '\u0102' + 'a_' * 10, 'count', 'a_')
-        self.checkequal(10, '\U00100304' + 'a_' * 10, 'count', 'a_')
-        self.checkequal(10, '\U00100304' + '\u0102_' * 10, 'count', '\u0102_')
-        self.checkequal(0, 'a' * 10, 'count', 'a\u0102')
-        self.checkequal(0, 'a' * 10, 'count', 'a\U00100304')
-        self.checkequal(0, '\u0102' * 10, 'count', '\u0102\U00100304')
-        # test subclass
-        class MyStr(str):
-            pass
-        self.checkequal(3, MyStr('aaa'), 'count', 'a')
-
-    def test_find(self):
-        string_tests.CommonTest.test_find(self)
-        # test implementation details of the memchr fast path
-        self.checkequal(100, 'a' * 100 + '\u0102', 'find', '\u0102')
-        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0201')
-        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0120')
-        self.checkequal(-1, 'a' * 100 + '\u0102', 'find', '\u0220')
-        self.checkequal(100, 'a' * 100 + '\U00100304', 'find', '\U00100304')
-        self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00100204')
-        self.checkequal(-1, 'a' * 100 + '\U00100304', 'find', '\U00102004')
-        # check mixed argument types
-        self.checkequalnofix(0,  'abcdefghiabc', 'find', 'abc')
-        self.checkequalnofix(9,  'abcdefghiabc', 'find', 'abc', 1)
-        self.checkequalnofix(-1, 'abcdefghiabc', 'find', 'def', 4)
-
-        # test utf-8 non-ascii char
-        self.checkequal(0, 'тест', 'find', 'т')
-        self.checkequal(3, 'тест', 'find', 'т', 1)
-        self.checkequal(-1, 'тест', 'find', 'т', 1, 3)
-        self.checkequal(-1, 'тест', 'find', 'e')  # english `e`
-        # test utf-8 non-ascii slice
-        self.checkequal(1, 'тест тест', 'find', 'ес')
-        self.checkequal(1, 'тест тест', 'find', 'ес', 1)
-        self.checkequal(1, 'тест тест', 'find', 'ес', 1, 3)
-        self.checkequal(6, 'тест тест', 'find', 'ес', 2)
-        self.checkequal(-1, 'тест тест', 'find', 'ес', 6, 7)
-        self.checkequal(-1, 'тест тест', 'find', 'ес', 7)
-        self.checkequal(-1, 'тест тест', 'find', 'ec')  # english `ec`
-
-        self.assertRaises(TypeError, 'hello'.find)
-        self.assertRaises(TypeError, 'hello'.find, 42)
-        # test mixed kinds
-        self.checkequal(100, '\u0102' * 100 + 'a', 'find', 'a')
-        self.checkequal(100, '\U00100304' * 100 + 'a', 'find', 'a')
-        self.checkequal(100, '\U00100304' * 100 + '\u0102', 'find', '\u0102')
-        self.checkequal(-1, 'a' * 100, 'find', '\u0102')
-        self.checkequal(-1, 'a' * 100, 'find', '\U00100304')
-        self.checkequal(-1, '\u0102' * 100, 'find', '\U00100304')
-        self.checkequal(100, '\u0102' * 100 + 'a_', 'find', 'a_')
-        self.checkequal(100, '\U00100304' * 100 + 'a_', 'find', 'a_')
-        self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'find', '\u0102_')
-        self.checkequal(-1, 'a' * 100, 'find', 'a\u0102')
-        self.checkequal(-1, 'a' * 100, 'find', 'a\U00100304')
-        self.checkequal(-1, '\u0102' * 100, 'find', '\u0102\U00100304')
-
-    def test_rfind(self):
-        string_tests.CommonTest.test_rfind(self)
-        # test implementation details of the memrchr fast path
-        self.checkequal(0, '\u0102' + 'a' * 100 , 'rfind', '\u0102')
-        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0201')
-        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0120')
-        self.checkequal(-1, '\u0102' + 'a' * 100 , 'rfind', '\u0220')
-        self.checkequal(0, '\U00100304' + 'a' * 100, 'rfind', '\U00100304')
-        self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00100204')
-        self.checkequal(-1, '\U00100304' + 'a' * 100, 'rfind', '\U00102004')
-        # check mixed argument types
-        self.checkequalnofix(9,   'abcdefghiabc', 'rfind', 'abc')
-        self.checkequalnofix(12,  'abcdefghiabc', 'rfind', '')
-        self.checkequalnofix(12, 'abcdefghiabc', 'rfind',  '')
-        # test utf-8 non-ascii char
-        self.checkequal(1, 'тест', 'rfind', 'е')
-        self.checkequal(1, 'тест', 'rfind', 'е', 1)
-        self.checkequal(-1, 'тест', 'rfind', 'е', 2)
-        self.checkequal(-1, 'тест', 'rfind', 'e')  # english `e`
-        # test utf-8 non-ascii slice
-        self.checkequal(6, 'тест тест', 'rfind', 'ес')
-        self.checkequal(6, 'тест тест', 'rfind', 'ес', 1)
-        self.checkequal(1, 'тест тест', 'rfind', 'ес', 1, 3)
-        self.checkequal(6, 'тест тест', 'rfind', 'ес', 2)
-        self.checkequal(-1, 'тест тест', 'rfind', 'ес', 6, 7)
-        self.checkequal(-1, 'тест тест', 'rfind', 'ес', 7)
-        self.checkequal(-1, 'тест тест', 'rfind', 'ec')  # english `ec`
-        # test mixed kinds
-        self.checkequal(0, 'a' + '\u0102' * 100, 'rfind', 'a')
-        self.checkequal(0, 'a' + '\U00100304' * 100, 'rfind', 'a')
-        self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rfind', '\u0102')
-        self.checkequal(-1, 'a' * 100, 'rfind', '\u0102')
-        self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304')
-        self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304')
-        self.checkequal(0, '_a' + '\u0102' * 100, 'rfind', '_a')
-        self.checkequal(0, '_a' + '\U00100304' * 100, 'rfind', '_a')
-        self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rfind', '_\u0102')
-        self.checkequal(-1, 'a' * 100, 'rfind', '\u0102a')
-        self.checkequal(-1, 'a' * 100, 'rfind', '\U00100304a')
-        self.checkequal(-1, '\u0102' * 100, 'rfind', '\U00100304\u0102')
-
-    def test_index(self):
-        string_tests.CommonTest.test_index(self)
-        self.checkequalnofix(0, 'abcdefghiabc', 'index',  '')
-        self.checkequalnofix(3, 'abcdefghiabc', 'index',  'def')
-        self.checkequalnofix(0, 'abcdefghiabc', 'index',  'abc')
-        self.checkequalnofix(9, 'abcdefghiabc', 'index',  'abc', 1)
-        self.assertRaises(ValueError, 'abcdefghiabc'.index, 'hib')
-        self.assertRaises(ValueError, 'abcdefghiab'.index,  'abc', 1)
-        self.assertRaises(ValueError, 'abcdefghi'.index,  'ghi', 8)
-        self.assertRaises(ValueError, 'abcdefghi'.index,  'ghi', -1)
-        # test mixed kinds
-        self.checkequal(100, '\u0102' * 100 + 'a', 'index', 'a')
-        self.checkequal(100, '\U00100304' * 100 + 'a', 'index', 'a')
-        self.checkequal(100, '\U00100304' * 100 + '\u0102', 'index', '\u0102')
-        self.assertRaises(ValueError, ('a' * 100).index, '\u0102')
-        self.assertRaises(ValueError, ('a' * 100).index, '\U00100304')
-        self.assertRaises(ValueError, ('\u0102' * 100).index, '\U00100304')
-        self.checkequal(100, '\u0102' * 100 + 'a_', 'index', 'a_')
-        self.checkequal(100, '\U00100304' * 100 + 'a_', 'index', 'a_')
-        self.checkequal(100, '\U00100304' * 100 + '\u0102_', 'index', '\u0102_')
-        self.assertRaises(ValueError, ('a' * 100).index, 'a\u0102')
-        self.assertRaises(ValueError, ('a' * 100).index, 'a\U00100304')
-        self.assertRaises(ValueError, ('\u0102' * 100).index, '\u0102\U00100304')
-
-    def test_rindex(self):
-        string_tests.CommonTest.test_rindex(self)
-        self.checkequalnofix(12, 'abcdefghiabc', 'rindex',  '')
-        self.checkequalnofix(3,  'abcdefghiabc', 'rindex',  'def')
-        self.checkequalnofix(9,  'abcdefghiabc', 'rindex',  'abc')
-        self.checkequalnofix(0,  'abcdefghiabc', 'rindex',  'abc', 0, -1)
-
-        self.assertRaises(ValueError, 'abcdefghiabc'.rindex,  'hib')
-        self.assertRaises(ValueError, 'defghiabc'.rindex,  'def', 1)
-        self.assertRaises(ValueError, 'defghiabc'.rindex,  'abc', 0, -1)
-        self.assertRaises(ValueError, 'abcdefghi'.rindex,  'ghi', 0, 8)
-        self.assertRaises(ValueError, 'abcdefghi'.rindex,  'ghi', 0, -1)
-        # test mixed kinds
-        self.checkequal(0, 'a' + '\u0102' * 100, 'rindex', 'a')
-        self.checkequal(0, 'a' + '\U00100304' * 100, 'rindex', 'a')
-        self.checkequal(0, '\u0102' + '\U00100304' * 100, 'rindex', '\u0102')
-        self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102')
-        self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304')
-        self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304')
-        self.checkequal(0, '_a' + '\u0102' * 100, 'rindex', '_a')
-        self.checkequal(0, '_a' + '\U00100304' * 100, 'rindex', '_a')
-        self.checkequal(0, '_\u0102' + '\U00100304' * 100, 'rindex', '_\u0102')
-        self.assertRaises(ValueError, ('a' * 100).rindex, '\u0102a')
-        self.assertRaises(ValueError, ('a' * 100).rindex, '\U00100304a')
-        self.assertRaises(ValueError, ('\u0102' * 100).rindex, '\U00100304\u0102')
-
-    def test_maketrans_translate(self):
-        # these work with plain translate()
-        self.checkequalnofix('bbbc', 'abababc', 'translate',
-                             {ord('a'): None})
-        self.checkequalnofix('iiic', 'abababc', 'translate',
-                             {ord('a'): None, ord('b'): ord('i')})
-        self.checkequalnofix('iiix', 'abababc', 'translate',
-                             {ord('a'): None, ord('b'): ord('i'), ord('c'): 'x'})
-        self.checkequalnofix('c', 'abababc', 'translate',
-                             {ord('a'): None, ord('b'): ''})
-        self.checkequalnofix('xyyx', 'xzx', 'translate',
-                             {ord('z'): 'yy'})
-
-        # this needs maketrans()
-        self.checkequalnofix('abababc', 'abababc', 'translate',
-                             {'b': '<i>'})
-        tbl = self.type2test.maketrans({'a': None, 'b': '<i>'})
-        self.checkequalnofix('<i><i><i>c', 'abababc', 'translate', tbl)
-        # test alternative way of calling maketrans()
-        tbl = self.type2test.maketrans('abc', 'xyz', 'd')
-        self.checkequalnofix('xyzzy', 'abdcdcbdddd', 'translate', tbl)
-
-        # various tests switching from ASCII to latin1 or the opposite;
-        # same length, remove a letter, or replace with a longer string.
-        self.assertEqual("[a]".translate(str.maketrans('a', 'X')),
-                         "[X]")
-        self.assertEqual("[a]".translate(str.maketrans({'a': 'X'})),
-                         "[X]")
-        self.assertEqual("[a]".translate(str.maketrans({'a': None})),
-                         "[]")
-        self.assertEqual("[a]".translate(str.maketrans({'a': 'XXX'})),
-                         "[XXX]")
-        self.assertEqual("[a]".translate(str.maketrans({'a': '\xe9'})),
-                         "[\xe9]")
-        self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '123'})),
-                         "x123")
-        self.assertEqual('axb'.translate(str.maketrans({'a': None, 'b': '\xe9'})),
-                         "x\xe9")
-
-        # test non-ASCII (don't take the fast-path)
-        self.assertEqual("[a]".translate(str.maketrans({'a': '<\xe9>'})),
-                         "[<\xe9>]")
-        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': 'a'})),
-                         "[a]")
-        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': None})),
-                         "[]")
-        self.assertEqual("[\xe9]".translate(str.maketrans({'\xe9': '123'})),
-                         "[123]")
-        self.assertEqual("[a\xe9]".translate(str.maketrans({'a': '<\u20ac>'})),
-                         "[<\u20ac>\xe9]")
-
-        # invalid Unicode characters
-        invalid_char = 0x10ffff+1
-        for before in "a\xe9\u20ac\U0010ffff":
-            mapping = str.maketrans({before: invalid_char})
-            text = "[%s]" % before
-            self.assertRaises(ValueError, text.translate, mapping)
-
-        # errors
-        self.assertRaises(TypeError, self.type2test.maketrans)
-        self.assertRaises(ValueError, self.type2test.maketrans, 'abc', 'defg')
-        self.assertRaises(TypeError, self.type2test.maketrans, 2, 'def')
-        self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 2)
-        self.assertRaises(TypeError, self.type2test.maketrans, 'abc', 'def', 2)
-        self.assertRaises(ValueError, self.type2test.maketrans, {'xy': 2})
-        self.assertRaises(TypeError, self.type2test.maketrans, {(1,): 2})
-
-        self.assertRaises(TypeError, 'hello'.translate)
-        self.assertRaises(TypeError, 'abababc'.translate, 'abc', 'xyz')
-
-    def test_split(self):
-        string_tests.CommonTest.test_split(self)
-
-        # test mixed kinds
-        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
-            left *= 9
-            right *= 9
-            for delim in ('c', '\u0102', '\U00010302'):
-                self.checkequal([left + right],
-                                left + right, 'split', delim)
-                self.checkequal([left, right],
-                                left + delim + right, 'split', delim)
-                self.checkequal([left + right],
-                                left + right, 'split', delim * 2)
-                self.checkequal([left, right],
-                                left + delim * 2 + right, 'split', delim *2)
-
-    def test_rsplit(self):
-        string_tests.CommonTest.test_rsplit(self)
-        # test mixed kinds
-        for left, right in ('ba', 'юё', '\u0101\u0100', '\U00010301\U00010300'):
-            left *= 9
-            right *= 9
-            for delim in ('c', 'ы', '\u0102', '\U00010302'):
-                self.checkequal([left + right],
-                                left + right, 'rsplit', delim)
-                self.checkequal([left, right],
-                                left + delim + right, 'rsplit', delim)
-                self.checkequal([left + right],
-                                left + right, 'rsplit', delim * 2)
-                self.checkequal([left, right],
-                                left + delim * 2 + right, 'rsplit', delim *2)
-
-            # Check `None` as well:
-            self.checkequal([left + right],
-                             left + right, 'rsplit', None)
-
-    def test_partition(self):
-        string_tests.MixinStrUnicodeUserStringTest.test_partition(self)
-        # test mixed kinds
-        self.checkequal(('ABCDEFGH', '', ''), 'ABCDEFGH', 'partition', '\u4200')
-        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
-            left *= 9
-            right *= 9
-            for delim in ('c', '\u0102', '\U00010302'):
-                self.checkequal((left + right, '', ''),
-                                left + right, 'partition', delim)
-                self.checkequal((left, delim, right),
-                                left + delim + right, 'partition', delim)
-                self.checkequal((left + right, '', ''),
-                                left + right, 'partition', delim * 2)
-                self.checkequal((left, delim * 2, right),
-                                left + delim * 2 + right, 'partition', delim * 2)
-
-    def test_rpartition(self):
-        string_tests.MixinStrUnicodeUserStringTest.test_rpartition(self)
-        # test mixed kinds
-        self.checkequal(('', '', 'ABCDEFGH'), 'ABCDEFGH', 'rpartition', '\u4200')
-        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
-            left *= 9
-            right *= 9
-            for delim in ('c', '\u0102', '\U00010302'):
-                self.checkequal(('', '', left + right),
-                                left + right, 'rpartition', delim)
-                self.checkequal((left, delim, right),
-                                left + delim + right, 'rpartition', delim)
-                self.checkequal(('', '', left + right),
-                                left + right, 'rpartition', delim * 2)
-                self.checkequal((left, delim * 2, right),
-                                left + delim * 2 + right, 'rpartition', delim * 2)
-
-    def test_join(self):
-        string_tests.MixinStrUnicodeUserStringTest.test_join(self)
-
-        class MyWrapper:
-            def __init__(self, sval): self.sval = sval
-            def __str__(self): return self.sval
-
-        # mixed arguments
-        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
-        self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
-        self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
-        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
-        self.checkequalnofix('a b c d', ' ', 'join', ['a', 'b', 'c', 'd'])
-        self.checkequalnofix('abcd', '', 'join', ('a', 'b', 'c', 'd'))
-        self.checkequalnofix('w x y z', ' ', 'join', string_tests.Sequence('wxyz'))
-        self.checkraises(TypeError, ' ', 'join', ['1', '2', MyWrapper('foo')])
-        self.checkraises(TypeError, ' ', 'join', ['1', '2', '3', bytes()])
-        self.checkraises(TypeError, ' ', 'join', [1, 2, 3])
-        self.checkraises(TypeError, ' ', 'join', ['1', '2', 3])
-
-    @unittest.skip("TODO: RUSTPYTHON, oom handling")
-    @unittest.skipIf(sys.maxsize > 2**32,
-        'needs too much memory on a 64-bit platform')
-    def test_join_overflow(self):
-        size = int(sys.maxsize**0.5) + 1
-        seq = ('A' * size,) * size
-        self.assertRaises(OverflowError, ''.join, seq)
-
-    def test_replace(self):
-        string_tests.CommonTest.test_replace(self)
-
-        # method call forwarded from str implementation because of unicode argument
-        self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
-        self.assertRaises(TypeError, 'replace'.replace, "r", 42)
-        # test mixed kinds
-        for left, right in ('ba', '\u0101\u0100', '\U00010301\U00010300'):
-            left *= 9
-            right *= 9
-            for delim in ('c', '\u0102', '\U00010302'):
-                for repl in ('d', '\u0103', '\U00010303'):
-                    self.checkequal(left + right,
-                                    left + right, 'replace', delim, repl)
-                    self.checkequal(left + repl + right,
-                                    left + delim + right,
-                                    'replace', delim, repl)
-                    self.checkequal(left + right,
-                                    left + right, 'replace', delim * 2, repl)
-                    self.checkequal(left + repl + right,
-                                    left + delim * 2 + right,
-                                    'replace', delim * 2, repl)
-
-    @support.cpython_only
-    def test_replace_id(self):
-        pattern = 'abc'
-        text = 'abc def'
-        self.assertIs(text.replace(pattern, pattern), text)
-
-    def test_repeat_id_preserving(self):
-        a = '123abc1@'
-        b = '456zyx-+'
-        self.assertEqual(id(a), id(a))
-        self.assertNotEqual(id(a), id(b))
-        self.assertNotEqual(id(a), id(a * -4))
-        self.assertNotEqual(id(a), id(a * 0))
-        self.assertEqual(id(a), id(a * 1))
-        self.assertEqual(id(a), id(1 * a))
-        self.assertNotEqual(id(a), id(a * 2))
-
-        class SubStr(str):
-            pass
-
-        s = SubStr('qwerty()')
-        self.assertEqual(id(s), id(s))
-        self.assertNotEqual(id(s), id(s * -4))
-        self.assertNotEqual(id(s), id(s * 0))
-        self.assertNotEqual(id(s), id(s * 1))
-        self.assertNotEqual(id(s), id(1 * s))
-        self.assertNotEqual(id(s), id(s * 2))
-
-    def test_bytes_comparison(self):
-        with warnings_helper.check_warnings():
-            warnings.simplefilter('ignore', BytesWarning)
-            self.assertEqual('abc' == b'abc', False)
-            self.assertEqual('abc' != b'abc', True)
-            self.assertEqual('abc' == bytearray(b'abc'), False)
-            self.assertEqual('abc' != bytearray(b'abc'), True)
-
-    def test_comparison(self):
-        # Comparisons:
-        self.assertEqual('abc', 'abc')
-        self.assertTrue('abcd' > 'abc')
-        self.assertTrue('abc' < 'abcd')
-
-        if 0:
-            # Move these tests to a Unicode collation module test...
-            # Testing UTF-16 code point order comparisons...
-
-            # No surrogates, no fixup required.
-            self.assertTrue('\u0061' < '\u20ac')
-            # Non surrogate below surrogate value, no fixup required
-            self.assertTrue('\u0061' < '\ud800\udc02')
-
-            # Non surrogate above surrogate value, fixup required
-            def test_lecmp(s, s2):
-                self.assertTrue(s < s2)
-
-            def test_fixup(s):
-                s2 = '\ud800\udc01'
-                test_lecmp(s, s2)
-                s2 = '\ud900\udc01'
-                test_lecmp(s, s2)
-                s2 = '\uda00\udc01'
-                test_lecmp(s, s2)
-                s2 = '\udb00\udc01'
-                test_lecmp(s, s2)
-                s2 = '\ud800\udd01'
-                test_lecmp(s, s2)
-                s2 = '\ud900\udd01'
-                test_lecmp(s, s2)
-                s2 = '\uda00\udd01'
-                test_lecmp(s, s2)
-                s2 = '\udb00\udd01'
-                test_lecmp(s, s2)
-                s2 = '\ud800\ude01'
-                test_lecmp(s, s2)
-                s2 = '\ud900\ude01'
-                test_lecmp(s, s2)
-                s2 = '\uda00\ude01'
-                test_lecmp(s, s2)
-                s2 = '\udb00\ude01'
-                test_lecmp(s, s2)
-                s2 = '\ud800\udfff'
-                test_lecmp(s, s2)
-                s2 = '\ud900\udfff'
-                test_lecmp(s, s2)
-                s2 = '\uda00\udfff'
-                test_lecmp(s, s2)
-                s2 = '\udb00\udfff'
-                test_lecmp(s, s2)
-
-                test_fixup('\ue000')
-                test_fixup('\uff61')
-
-        # Surrogates on both sides, no fixup required
-        self.assertTrue('\ud800\udc02' < '\ud84d\udc56')
-
-    def test_islower(self):
-        super().test_islower()
-        self.checkequalnofix(False, '\u1FFc', 'islower')
-        self.assertFalse('\u2167'.islower())
-        self.assertTrue('\u2177'.islower())
-        # non-BMP, uppercase
-        self.assertFalse('\U00010401'.islower())
-        self.assertFalse('\U00010427'.islower())
-        # non-BMP, lowercase
-        self.assertTrue('\U00010429'.islower())
-        self.assertTrue('\U0001044E'.islower())
-        # non-BMP, non-cased
-        self.assertFalse('\U0001F40D'.islower())
-        self.assertFalse('\U0001F46F'.islower())
-
-    def test_isupper(self):
-        super().test_isupper()
-        self.checkequalnofix(False, '\u1FFc', 'isupper')
-        self.assertTrue('\u2167'.isupper())
-        self.assertFalse('\u2177'.isupper())
-        # non-BMP, uppercase
-        self.assertTrue('\U00010401'.isupper())
-        self.assertTrue('\U00010427'.isupper())
-        # non-BMP, lowercase
-        self.assertFalse('\U00010429'.isupper())
-        self.assertFalse('\U0001044E'.isupper())
-        # non-BMP, non-cased
-        self.assertFalse('\U0001F40D'.isupper())
-        self.assertFalse('\U0001F46F'.isupper())
-
-    def test_istitle(self):
-        super().test_istitle()
-        self.checkequalnofix(True, '\u1FFc', 'istitle')
-        self.checkequalnofix(True, 'Greek \u1FFcitlecases ...', 'istitle')
-
-        # non-BMP, uppercase + lowercase
-        self.assertTrue('\U00010401\U00010429'.istitle())
-        self.assertTrue('\U00010427\U0001044E'.istitle())
-        # apparently there are no titlecased (Lt) non-BMP chars in Unicode 6
-        for ch in ['\U00010429', '\U0001044E', '\U0001F40D', '\U0001F46F']:
-            self.assertFalse(ch.istitle(), '{!a} is not title'.format(ch))
-
-    def test_isspace(self):
-        super().test_isspace()
-        self.checkequalnofix(True, '\u2000', 'isspace')
-        self.checkequalnofix(True, '\u200a', 'isspace')
-        self.checkequalnofix(False, '\u2014', 'isspace')
-        # There are no non-BMP whitespace chars as of Unicode 12.
-        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
-                   '\U0001F40D', '\U0001F46F']:
-            self.assertFalse(ch.isspace(), '{!a} is not space.'.format(ch))
-
-    @support.requires_resource('cpu')
-    def test_isspace_invariant(self):
-        for codepoint in range(sys.maxunicode + 1):
-            char = chr(codepoint)
-            bidirectional = unicodedata.bidirectional(char)
-            category = unicodedata.category(char)
-            self.assertEqual(char.isspace(),
-                             (bidirectional in ('WS', 'B', 'S')
-                              or category == 'Zs'))
-
-    def test_isalnum(self):
-        super().test_isalnum()
-        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
-                   '\U0001D7F6', '\U00011066', '\U000104A0', '\U0001F107']:
-            self.assertTrue(ch.isalnum(), '{!a} is alnum.'.format(ch))
-
-    def test_isalpha(self):
-        super().test_isalpha()
-        self.checkequalnofix(True, '\u1FFc', 'isalpha')
-        # non-BMP, cased
-        self.assertTrue('\U00010401'.isalpha())
-        self.assertTrue('\U00010427'.isalpha())
-        self.assertTrue('\U00010429'.isalpha())
-        self.assertTrue('\U0001044E'.isalpha())
-        # non-BMP, non-cased
-        self.assertFalse('\U0001F40D'.isalpha())
-        self.assertFalse('\U0001F46F'.isalpha())
-
-    def test_isascii(self):
-        super().test_isascii()
-        self.assertFalse("\u20ac".isascii())
-        self.assertFalse("\U0010ffff".isascii())
-
-    def test_isdecimal(self):
-        self.checkequalnofix(False, '', 'isdecimal')
-        self.checkequalnofix(False, 'a', 'isdecimal')
-        self.checkequalnofix(True, '0', 'isdecimal')
-        self.checkequalnofix(False, '\u2460', 'isdecimal') # CIRCLED DIGIT ONE
-        self.checkequalnofix(False, '\xbc', 'isdecimal') # VULGAR FRACTION ONE QUARTER
-        self.checkequalnofix(True, '\u0660', 'isdecimal') # ARABIC-INDIC DIGIT ZERO
-        self.checkequalnofix(True, '0123456789', 'isdecimal')
-        self.checkequalnofix(False, '0123456789a', 'isdecimal')
-
-        self.checkraises(TypeError, 'abc', 'isdecimal', 42)
-
-        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
-                   '\U0001F40D', '\U0001F46F', '\U00011065', '\U0001F107']:
-            self.assertFalse(ch.isdecimal(), '{!a} is not decimal.'.format(ch))
-        for ch in ['\U0001D7F6', '\U00011066', '\U000104A0']:
-            self.assertTrue(ch.isdecimal(), '{!a} is decimal.'.format(ch))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_isdigit(self):
-        super().test_isdigit()
-        self.checkequalnofix(True, '\u2460', 'isdigit')
-        self.checkequalnofix(False, '\xbc', 'isdigit')
-        self.checkequalnofix(True, '\u0660', 'isdigit')
-
-        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
-                   '\U0001F40D', '\U0001F46F', '\U00011065']:
-            self.assertFalse(ch.isdigit(), '{!a} is not a digit.'.format(ch))
-        for ch in ['\U0001D7F6', '\U00011066', '\U000104A0', '\U0001F107']:
-            self.assertTrue(ch.isdigit(), '{!a} is a digit.'.format(ch))
-
-    def test_isnumeric(self):
-        self.checkequalnofix(False, '', 'isnumeric')
-        self.checkequalnofix(False, 'a', 'isnumeric')
-        self.checkequalnofix(True, '0', 'isnumeric')
-        self.checkequalnofix(True, '\u2460', 'isnumeric')
-        self.checkequalnofix(True, '\xbc', 'isnumeric')
-        self.checkequalnofix(True, '\u0660', 'isnumeric')
-        self.checkequalnofix(True, '0123456789', 'isnumeric')
-        self.checkequalnofix(False, '0123456789a', 'isnumeric')
-
-        self.assertRaises(TypeError, "abc".isnumeric, 42)
-
-        for ch in ['\U00010401', '\U00010427', '\U00010429', '\U0001044E',
-                   '\U0001F40D', '\U0001F46F']:
-            self.assertFalse(ch.isnumeric(), '{!a} is not numeric.'.format(ch))
-        for ch in ['\U00011065', '\U0001D7F6', '\U00011066',
-                   '\U000104A0', '\U0001F107']:
-            self.assertTrue(ch.isnumeric(), '{!a} is numeric.'.format(ch))
-
-    def test_isidentifier(self):
-        self.assertTrue("a".isidentifier())
-        self.assertTrue("Z".isidentifier())
-        self.assertTrue("_".isidentifier())
-        self.assertTrue("b0".isidentifier())
-        self.assertTrue("bc".isidentifier())
-        self.assertTrue("b_".isidentifier())
-        self.assertTrue("µ".isidentifier())
-        self.assertTrue("𝔘𝔫𝔦𝔠𝔬𝔡𝔢".isidentifier())
-
-        self.assertFalse(" ".isidentifier())
-        self.assertFalse("[".isidentifier())
-        self.assertFalse("©".isidentifier())
-        self.assertFalse("0".isidentifier())
-
-    def test_isprintable(self):
-        self.assertTrue("".isprintable())
-        self.assertTrue(" ".isprintable())
-        self.assertTrue("abcdefg".isprintable())
-        self.assertFalse("abcdefg\n".isprintable())
-        # some defined Unicode character
-        self.assertTrue("\u0374".isprintable())
-        # undefined character
-        self.assertFalse("\u0378".isprintable())
-        # single surrogate character
-        self.assertFalse("\ud800".isprintable())
-
-        self.assertTrue('\U0001F46F'.isprintable())
-        self.assertFalse('\U000E0020'.isprintable())
-
-    def test_surrogates(self):
-        for s in ('a\uD800b\uDFFF', 'a\uDFFFb\uD800',
-                  'a\uD800b\uDFFFa', 'a\uDFFFb\uD800a'):
-            self.assertTrue(s.islower())
-            self.assertFalse(s.isupper())
-            self.assertFalse(s.istitle())
-        for s in ('A\uD800B\uDFFF', 'A\uDFFFB\uD800',
-                  'A\uD800B\uDFFFA', 'A\uDFFFB\uD800A'):
-            self.assertFalse(s.islower())
-            self.assertTrue(s.isupper())
-            self.assertTrue(s.istitle())
-
-        for meth_name in ('islower', 'isupper', 'istitle'):
-            meth = getattr(str, meth_name)
-            for s in ('\uD800', '\uDFFF', '\uD800\uD800', '\uDFFF\uDFFF'):
-                self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
-
-        for meth_name in ('isalpha', 'isalnum', 'isdigit', 'isspace',
-                          'isdecimal', 'isnumeric',
-                          'isidentifier', 'isprintable'):
-            meth = getattr(str, meth_name)
-            for s in ('\uD800', '\uDFFF', '\uD800\uD800', '\uDFFF\uDFFF',
-                      'a\uD800b\uDFFF', 'a\uDFFFb\uD800',
-                      'a\uD800b\uDFFFa', 'a\uDFFFb\uD800a'):
-                self.assertFalse(meth(s), '%a.%s() is False' % (s, meth_name))
-
-
-    def test_lower(self):
-        string_tests.CommonTest.test_lower(self)
-        self.assertEqual('\U00010427'.lower(), '\U0001044F')
-        self.assertEqual('\U00010427\U00010427'.lower(),
-                         '\U0001044F\U0001044F')
-        self.assertEqual('\U00010427\U0001044F'.lower(),
-                         '\U0001044F\U0001044F')
-        self.assertEqual('X\U00010427x\U0001044F'.lower(),
-                         'x\U0001044Fx\U0001044F')
-        self.assertEqual('fi'.lower(), 'fi')
-        self.assertEqual('\u0130'.lower(), '\u0069\u0307')
-        # Special case for GREEK CAPITAL LETTER SIGMA U+03A3
-        self.assertEqual('\u03a3'.lower(), '\u03c3')
-        self.assertEqual('\u0345\u03a3'.lower(), '\u0345\u03c3')
-        self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
-        self.assertEqual('A\u0345\u03a3a'.lower(), 'a\u0345\u03c3a')
-        self.assertEqual('A\u0345\u03a3'.lower(), 'a\u0345\u03c2')
-        self.assertEqual('A\u03a3\u0345'.lower(), 'a\u03c2\u0345')
-        self.assertEqual('\u03a3\u0345 '.lower(), '\u03c3\u0345 ')
-        self.assertEqual('\U0008fffe'.lower(), '\U0008fffe')
-        self.assertEqual('\u2177'.lower(), '\u2177')
-
-    def test_casefold(self):
-        self.assertEqual('hello'.casefold(), 'hello')
-        self.assertEqual('hELlo'.casefold(), 'hello')
-        self.assertEqual('ß'.casefold(), 'ss')
-        self.assertEqual('fi'.casefold(), 'fi')
-        self.assertEqual('\u03a3'.casefold(), '\u03c3')
-        self.assertEqual('A\u0345\u03a3'.casefold(), 'a\u03b9\u03c3')
-        self.assertEqual('\u00b5'.casefold(), '\u03bc')
-
-    def test_upper(self):
-        string_tests.CommonTest.test_upper(self)
-        self.assertEqual('\U0001044F'.upper(), '\U00010427')
-        self.assertEqual('\U0001044F\U0001044F'.upper(),
-                         '\U00010427\U00010427')
-        self.assertEqual('\U00010427\U0001044F'.upper(),
-                         '\U00010427\U00010427')
-        self.assertEqual('X\U00010427x\U0001044F'.upper(),
-                         'X\U00010427X\U00010427')
-        self.assertEqual('fi'.upper(), 'FI')
-        self.assertEqual('\u0130'.upper(), '\u0130')
-        self.assertEqual('\u03a3'.upper(), '\u03a3')
-        self.assertEqual('ß'.upper(), 'SS')
-        self.assertEqual('\u1fd2'.upper(), '\u0399\u0308\u0300')
-        self.assertEqual('\U0008fffe'.upper(), '\U0008fffe')
-        self.assertEqual('\u2177'.upper(), '\u2167')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_capitalize(self):
-        string_tests.CommonTest.test_capitalize(self)
-        self.assertEqual('\U0001044F'.capitalize(), '\U00010427')
-        self.assertEqual('\U0001044F\U0001044F'.capitalize(),
-                         '\U00010427\U0001044F')
-        self.assertEqual('\U00010427\U0001044F'.capitalize(),
-                         '\U00010427\U0001044F')
-        self.assertEqual('\U0001044F\U00010427'.capitalize(),
-                         '\U00010427\U0001044F')
-        self.assertEqual('X\U00010427x\U0001044F'.capitalize(),
-                         'X\U0001044Fx\U0001044F')
-        self.assertEqual('h\u0130'.capitalize(), 'H\u0069\u0307')
-        exp = '\u0399\u0308\u0300\u0069\u0307'
-        self.assertEqual('\u1fd2\u0130'.capitalize(), exp)
-        self.assertEqual('finnish'.capitalize(), 'Finnish')
-        self.assertEqual('A\u0345\u03a3'.capitalize(), 'A\u0345\u03c2')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_title(self):
-        super().test_title()
-        self.assertEqual('\U0001044F'.title(), '\U00010427')
-        self.assertEqual('\U0001044F\U0001044F'.title(),
-                         '\U00010427\U0001044F')
-        self.assertEqual('\U0001044F\U0001044F \U0001044F\U0001044F'.title(),
-                         '\U00010427\U0001044F \U00010427\U0001044F')
-        self.assertEqual('\U00010427\U0001044F \U00010427\U0001044F'.title(),
-                         '\U00010427\U0001044F \U00010427\U0001044F')
-        self.assertEqual('\U0001044F\U00010427 \U0001044F\U00010427'.title(),
-                         '\U00010427\U0001044F \U00010427\U0001044F')
-        self.assertEqual('X\U00010427x\U0001044F X\U00010427x\U0001044F'.title(),
-                         'X\U0001044Fx\U0001044F X\U0001044Fx\U0001044F')
-        self.assertEqual('fiNNISH'.title(), 'Finnish')
-        self.assertEqual('A\u03a3 \u1fa1xy'.title(), 'A\u03c2 \u1fa9xy')
-        self.assertEqual('A\u03a3A'.title(), 'A\u03c3a')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_swapcase(self):
-        string_tests.CommonTest.test_swapcase(self)
-        self.assertEqual('\U0001044F'.swapcase(), '\U00010427')
-        self.assertEqual('\U00010427'.swapcase(), '\U0001044F')
-        self.assertEqual('\U0001044F\U0001044F'.swapcase(),
-                         '\U00010427\U00010427')
-        self.assertEqual('\U00010427\U0001044F'.swapcase(),
-                         '\U0001044F\U00010427')
-        self.assertEqual('\U0001044F\U00010427'.swapcase(),
-                         '\U00010427\U0001044F')
-        self.assertEqual('X\U00010427x\U0001044F'.swapcase(),
-                         'x\U0001044FX\U00010427')
-        self.assertEqual('fi'.swapcase(), 'FI')
-        self.assertEqual('\u0130'.swapcase(), '\u0069\u0307')
-        # Special case for GREEK CAPITAL LETTER SIGMA U+03A3
-        self.assertEqual('\u03a3'.swapcase(), '\u03c3')
-        self.assertEqual('\u0345\u03a3'.swapcase(), '\u0399\u03c3')
-        self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
-        self.assertEqual('A\u0345\u03a3a'.swapcase(), 'a\u0399\u03c3A')
-        self.assertEqual('A\u0345\u03a3'.swapcase(), 'a\u0399\u03c2')
-        self.assertEqual('A\u03a3\u0345'.swapcase(), 'a\u03c2\u0399')
-        self.assertEqual('\u03a3\u0345 '.swapcase(), '\u03c3\u0399 ')
-        self.assertEqual('\u03a3'.swapcase(), '\u03c3')
-        self.assertEqual('ß'.swapcase(), 'SS')
-        self.assertEqual('\u1fd2'.swapcase(), '\u0399\u0308\u0300')
-
-    def test_center(self):
-        string_tests.CommonTest.test_center(self)
-        self.assertEqual('x'.center(2, '\U0010FFFF'),
-                         'x\U0010FFFF')
-        self.assertEqual('x'.center(3, '\U0010FFFF'),
-                         '\U0010FFFFx\U0010FFFF')
-        self.assertEqual('x'.center(4, '\U0010FFFF'),
-                         '\U0010FFFFx\U0010FFFF\U0010FFFF')
-
-    @unittest.skipUnless(sys.maxsize == 2**31 - 1, "requires 32-bit system")
-    @support.cpython_only
-    def test_case_operation_overflow(self):
-        # Issue #22643
-        size = 2**32//12 + 1
-        try:
-            s = "ü" * size
-        except MemoryError:
-            self.skipTest('no enough memory (%.0f MiB required)' % (size / 2**20))
-        try:
-            self.assertRaises(OverflowError, s.upper)
-        finally:
-            del s
-
-    def test_contains(self):
-        # Testing Unicode contains method
-        self.assertIn('a', 'abdb')
-        self.assertIn('a', 'bdab')
-        self.assertIn('a', 'bdaba')
-        self.assertIn('a', 'bdba')
-        self.assertNotIn('a', 'bdb')
-        self.assertIn('a', 'bdba')
-        self.assertIn('a', ('a',1,None))
-        self.assertIn('a', (1,None,'a'))
-        self.assertIn('a', ('a',1,None))
-        self.assertIn('a', (1,None,'a'))
-        self.assertNotIn('a', ('x',1,'y'))
-        self.assertNotIn('a', ('x',1,None))
-        self.assertNotIn('abcd', 'abcxxxx')
-        self.assertIn('ab', 'abcd')
-        self.assertIn('ab', 'abc')
-        self.assertIn('ab', (1,None,'ab'))
-        self.assertIn('', 'abc')
-        self.assertIn('', '')
-        self.assertIn('', 'abc')
-        self.assertNotIn('\0', 'abc')
-        self.assertIn('\0', '\0abc')
-        self.assertIn('\0', 'abc\0')
-        self.assertIn('a', '\0abc')
-        self.assertIn('asdf', 'asdf')
-        self.assertNotIn('asdf', 'asd')
-        self.assertNotIn('asdf', '')
-
-        self.assertRaises(TypeError, "abc".__contains__)
-        # test mixed kinds
-        for fill in ('a', '\u0100', '\U00010300'):
-            fill *= 9
-            for delim in ('c', '\u0102', '\U00010302'):
-                self.assertNotIn(delim, fill)
-                self.assertIn(delim, fill + delim)
-                self.assertNotIn(delim * 2, fill)
-                self.assertIn(delim * 2, fill + delim * 2)
-
-    def test_issue18183(self):
-        '\U00010000\U00100000'.lower()
-        '\U00010000\U00100000'.casefold()
-        '\U00010000\U00100000'.upper()
-        '\U00010000\U00100000'.capitalize()
-        '\U00010000\U00100000'.title()
-        '\U00010000\U00100000'.swapcase()
-        '\U00100000'.center(3, '\U00010000')
-        '\U00100000'.ljust(3, '\U00010000')
-        '\U00100000'.rjust(3, '\U00010000')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_format(self):
-        self.assertEqual(''.format(), '')
-        self.assertEqual('a'.format(), 'a')
-        self.assertEqual('ab'.format(), 'ab')
-        self.assertEqual('a{{'.format(), 'a{')
-        self.assertEqual('a}}'.format(), 'a}')
-        self.assertEqual('{{b'.format(), '{b')
-        self.assertEqual('}}b'.format(), '}b')
-        self.assertEqual('a{{b'.format(), 'a{b')
-
-        # examples from the PEP:
-        import datetime
-        self.assertEqual("My name is {0}".format('Fred'), "My name is Fred")
-        self.assertEqual("My name is {0[name]}".format(dict(name='Fred')),
-                         "My name is Fred")
-        self.assertEqual("My name is {0} :-{{}}".format('Fred'),
-                         "My name is Fred :-{}")
-
-        d = datetime.date(2007, 8, 18)
-        self.assertEqual("The year is {0.year}".format(d),
-                         "The year is 2007")
-
-        # classes we'll use for testing
-        class C:
-            def __init__(self, x=100):
-                self._x = x
-            def __format__(self, spec):
-                return spec
-
-        class D:
-            def __init__(self, x):
-                self.x = x
-            def __format__(self, spec):
-                return str(self.x)
-
-        # class with __str__, but no __format__
-        class E:
-            def __init__(self, x):
-                self.x = x
-            def __str__(self):
-                return 'E(' + self.x + ')'
-
-        # class with __repr__, but no __format__ or __str__
-        class F:
-            def __init__(self, x):
-                self.x = x
-            def __repr__(self):
-                return 'F(' + self.x + ')'
-
-        # class with __format__ that forwards to string, for some format_spec's
-        class G:
-            def __init__(self, x):
-                self.x = x
-            def __str__(self):
-                return "string is " + self.x
-            def __format__(self, format_spec):
-                if format_spec == 'd':
-                    return 'G(' + self.x + ')'
-                return object.__format__(self, format_spec)
-
-        class I(datetime.date):
-            def __format__(self, format_spec):
-                return self.strftime(format_spec)
-
-        class J(int):
-            def __format__(self, format_spec):
-                return int.__format__(self * 2, format_spec)
-
-        class M:
-            def __init__(self, x):
-                self.x = x
-            def __repr__(self):
-                return 'M(' + self.x + ')'
-            __str__ = None
-
-        class N:
-            def __init__(self, x):
-                self.x = x
-            def __repr__(self):
-                return 'N(' + self.x + ')'
-            __format__ = None
-
-        self.assertEqual(''.format(), '')
-        self.assertEqual('abc'.format(), 'abc')
-        self.assertEqual('{0}'.format('abc'), 'abc')
-        self.assertEqual('{0:}'.format('abc'), 'abc')
-#        self.assertEqual('{ 0 }'.format('abc'), 'abc')
-        self.assertEqual('X{0}'.format('abc'), 'Xabc')
-        self.assertEqual('{0}X'.format('abc'), 'abcX')
-        self.assertEqual('X{0}Y'.format('abc'), 'XabcY')
-        self.assertEqual('{1}'.format(1, 'abc'), 'abc')
-        self.assertEqual('X{1}'.format(1, 'abc'), 'Xabc')
-        self.assertEqual('{1}X'.format(1, 'abc'), 'abcX')
-        self.assertEqual('X{1}Y'.format(1, 'abc'), 'XabcY')
-        self.assertEqual('{0}'.format(-15), '-15')
-        self.assertEqual('{0}{1}'.format(-15, 'abc'), '-15abc')
-        self.assertEqual('{0}X{1}'.format(-15, 'abc'), '-15Xabc')
-        self.assertEqual('{{'.format(), '{')
-        self.assertEqual('}}'.format(), '}')
-        self.assertEqual('{{}}'.format(), '{}')
-        self.assertEqual('{{x}}'.format(), '{x}')
-        self.assertEqual('{{{0}}}'.format(123), '{123}')
-        self.assertEqual('{{{{0}}}}'.format(), '{{0}}')
-        self.assertEqual('}}{{'.format(), '}{')
-        self.assertEqual('}}x{{'.format(), '}x{')
-
-        # weird field names
-        self.assertEqual("{0[foo-bar]}".format({'foo-bar':'baz'}), 'baz')
-        self.assertEqual("{0[foo bar]}".format({'foo bar':'baz'}), 'baz')
-        self.assertEqual("{0[ ]}".format({' ':3}), '3')
-
-        self.assertEqual('{foo._x}'.format(foo=C(20)), '20')
-        self.assertEqual('{1}{0}'.format(D(10), D(20)), '2010')
-        self.assertEqual('{0._x.x}'.format(C(D('abc'))), 'abc')
-        self.assertEqual('{0[0]}'.format(['abc', 'def']), 'abc')
-        self.assertEqual('{0[1]}'.format(['abc', 'def']), 'def')
-        self.assertEqual('{0[1][0]}'.format(['abc', ['def']]), 'def')
-        self.assertEqual('{0[1][0].x}'.format(['abc', [D('def')]]), 'def')
-
-        # strings
-        self.assertEqual('{0:.3s}'.format('abc'), 'abc')
-        self.assertEqual('{0:.3s}'.format('ab'), 'ab')
-        self.assertEqual('{0:.3s}'.format('abcdef'), 'abc')
-        self.assertEqual('{0:.0s}'.format('abcdef'), '')
-        self.assertEqual('{0:3.3s}'.format('abc'), 'abc')
-        self.assertEqual('{0:2.3s}'.format('abc'), 'abc')
-        self.assertEqual('{0:2.2s}'.format('abc'), 'ab')
-        self.assertEqual('{0:3.2s}'.format('abc'), 'ab ')
-        self.assertEqual('{0:x<0s}'.format('result'), 'result')
-        self.assertEqual('{0:x<5s}'.format('result'), 'result')
-        self.assertEqual('{0:x<6s}'.format('result'), 'result')
-        self.assertEqual('{0:x<7s}'.format('result'), 'resultx')
-        self.assertEqual('{0:x<8s}'.format('result'), 'resultxx')
-        self.assertEqual('{0: <7s}'.format('result'), 'result ')
-        self.assertEqual('{0:<7s}'.format('result'), 'result ')
-        self.assertEqual('{0:>7s}'.format('result'), ' result')
-        self.assertEqual('{0:>8s}'.format('result'), '  result')
-        self.assertEqual('{0:^8s}'.format('result'), ' result ')
-        self.assertEqual('{0:^9s}'.format('result'), ' result  ')
-        self.assertEqual('{0:^10s}'.format('result'), '  result  ')
-        self.assertEqual('{0:8s}'.format('result'), 'result  ')
-        self.assertEqual('{0:0s}'.format('result'), 'result')
-        self.assertEqual('{0:08s}'.format('result'), 'result00')
-        self.assertEqual('{0:<08s}'.format('result'), 'result00')
-        self.assertEqual('{0:>08s}'.format('result'), '00result')
-        self.assertEqual('{0:^08s}'.format('result'), '0result0')
-        self.assertEqual('{0:10000}'.format('a'), 'a' + ' ' * 9999)
-        self.assertEqual('{0:10000}'.format(''), ' ' * 10000)
-        self.assertEqual('{0:10000000}'.format(''), ' ' * 10000000)
-
-        # issue 12546: use \x00 as a fill character
-        self.assertEqual('{0:\x00<6s}'.format('foo'), 'foo\x00\x00\x00')
-        self.assertEqual('{0:\x01<6s}'.format('foo'), 'foo\x01\x01\x01')
-        self.assertEqual('{0:\x00^6s}'.format('foo'), '\x00foo\x00\x00')
-        self.assertEqual('{0:^6s}'.format('foo'), ' foo  ')
-
-        self.assertEqual('{0:\x00<6}'.format(3), '3\x00\x00\x00\x00\x00')
-        self.assertEqual('{0:\x01<6}'.format(3), '3\x01\x01\x01\x01\x01')
-        self.assertEqual('{0:\x00^6}'.format(3), '\x00\x003\x00\x00\x00')
-        self.assertEqual('{0:<6}'.format(3), '3     ')
-
-        self.assertEqual('{0:\x00<6}'.format(3.14), '3.14\x00\x00')
-        self.assertEqual('{0:\x01<6}'.format(3.14), '3.14\x01\x01')
-        self.assertEqual('{0:\x00^6}'.format(3.14), '\x003.14\x00')
-        self.assertEqual('{0:^6}'.format(3.14), ' 3.14 ')
-
-        self.assertEqual('{0:\x00<12}'.format(3+2.0j), '(3+2j)\x00\x00\x00\x00\x00\x00')
-        self.assertEqual('{0:\x01<12}'.format(3+2.0j), '(3+2j)\x01\x01\x01\x01\x01\x01')
-        self.assertEqual('{0:\x00^12}'.format(3+2.0j), '\x00\x00\x00(3+2j)\x00\x00\x00')
-        self.assertEqual('{0:^12}'.format(3+2.0j), '   (3+2j)   ')
-
-        # format specifiers for user defined type
-        self.assertEqual('{0:abc}'.format(C()), 'abc')
-
-        # !r, !s and !a coercions
-        self.assertEqual('{0!s}'.format('Hello'), 'Hello')
-        self.assertEqual('{0!s:}'.format('Hello'), 'Hello')
-        self.assertEqual('{0!s:15}'.format('Hello'), 'Hello          ')
-        self.assertEqual('{0!s:15s}'.format('Hello'), 'Hello          ')
-        self.assertEqual('{0!r}'.format('Hello'), "'Hello'")
-        self.assertEqual('{0!r:}'.format('Hello'), "'Hello'")
-        self.assertEqual('{0!r}'.format(F('Hello')), 'F(Hello)')
-        self.assertEqual('{0!r}'.format('\u0378'), "'\\u0378'") # nonprintable
-        self.assertEqual('{0!r}'.format('\u0374'), "'\u0374'")  # printable
-        self.assertEqual('{0!r}'.format(F('\u0374')), 'F(\u0374)')
-        self.assertEqual('{0!a}'.format('Hello'), "'Hello'")
-        self.assertEqual('{0!a}'.format('\u0378'), "'\\u0378'") # nonprintable
-        self.assertEqual('{0!a}'.format('\u0374'), "'\\u0374'") # printable
-        self.assertEqual('{0!a:}'.format('Hello'), "'Hello'")
-        self.assertEqual('{0!a}'.format(F('Hello')), 'F(Hello)')
-        self.assertEqual('{0!a}'.format(F('\u0374')), 'F(\\u0374)')
-
-        # test fallback to object.__format__
-        self.assertEqual('{0}'.format({}), '{}')
-        self.assertEqual('{0}'.format([]), '[]')
-        self.assertEqual('{0}'.format([1]), '[1]')
-
-        self.assertEqual('{0:d}'.format(G('data')), 'G(data)')
-        self.assertEqual('{0!s}'.format(G('data')), 'string is data')
-
-        self.assertRaises(TypeError, '{0:^10}'.format, E('data'))
-        self.assertRaises(TypeError, '{0:^10s}'.format, E('data'))
-        self.assertRaises(TypeError, '{0:>15s}'.format, G('data'))
-
-        self.assertEqual("{0:date: %Y-%m-%d}".format(I(year=2007,
-                                                       month=8,
-                                                       day=27)),
-                         "date: 2007-08-27")
-
-        # test deriving from a builtin type and overriding __format__
-        self.assertEqual("{0}".format(J(10)), "20")
-
-
-        # string format specifiers
-        self.assertEqual('{0:}'.format('a'), 'a')
-
-        # computed format specifiers
-        self.assertEqual("{0:.{1}}".format('hello world', 5), 'hello')
-        self.assertEqual("{0:.{1}s}".format('hello world', 5), 'hello')
-        self.assertEqual("{0:.{precision}s}".format('hello world', precision=5), 'hello')
-        self.assertEqual("{0:{width}.{precision}s}".format('hello world', width=10, precision=5), 'hello     ')
-        self.assertEqual("{0:{width}.{precision}s}".format('hello world', width='10', precision='5'), 'hello     ')
-
-        # test various errors
-        self.assertRaises(ValueError, '{'.format)
-        self.assertRaises(ValueError, '}'.format)
-        self.assertRaises(ValueError, 'a{'.format)
-        self.assertRaises(ValueError, 'a}'.format)
-        self.assertRaises(ValueError, '{a'.format)
-        self.assertRaises(ValueError, '}a'.format)
-        self.assertRaises(IndexError, '{0}'.format)
-        self.assertRaises(IndexError, '{1}'.format, 'abc')
-        self.assertRaises(KeyError,   '{x}'.format)
-        self.assertRaises(ValueError, "}{".format)
-        self.assertRaises(ValueError, "abc{0:{}".format)
-        self.assertRaises(ValueError, "{0".format)
-        self.assertRaises(IndexError, "{0.}".format)
-        self.assertRaises(ValueError, "{0.}".format, 0)
-        self.assertRaises(ValueError, "{0[}".format)
-        self.assertRaises(ValueError, "{0[}".format, [])
-        self.assertRaises(KeyError,   "{0]}".format)
-        self.assertRaises(ValueError, "{0.[]}".format, 0)
-        self.assertRaises(ValueError, "{0..foo}".format, 0)
-        self.assertRaises(ValueError, "{0[0}".format, 0)
-        self.assertRaises(ValueError, "{0[0:foo}".format, 0)
-        self.assertRaises(KeyError,   "{c]}".format)
-        self.assertRaises(ValueError, "{{ {{{0}}".format, 0)
-        self.assertRaises(ValueError, "{0}}".format, 0)
-        self.assertRaises(KeyError,   "{foo}".format, bar=3)
-        self.assertRaises(ValueError, "{0!x}".format, 3)
-        self.assertRaises(ValueError, "{0!}".format, 0)
-        self.assertRaises(ValueError, "{0!rs}".format, 0)
-        self.assertRaises(ValueError, "{!}".format)
-        self.assertRaises(IndexError, "{:}".format)
-        self.assertRaises(IndexError, "{:s}".format)
-        self.assertRaises(IndexError, "{}".format)
-        big = "23098475029384702983476098230754973209482573"
-        self.assertRaises(ValueError, ("{" + big + "}").format)
-        self.assertRaises(ValueError, ("{[" + big + "]}").format, [0])
-
-        # test number formatter errors:
-        self.assertRaises(ValueError, '{0:x}'.format, 1j)
-        self.assertRaises(ValueError, '{0:x}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:X}'.format, 1j)
-        self.assertRaises(ValueError, '{0:X}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:o}'.format, 1j)
-        self.assertRaises(ValueError, '{0:o}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:u}'.format, 1j)
-        self.assertRaises(ValueError, '{0:u}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:i}'.format, 1j)
-        self.assertRaises(ValueError, '{0:i}'.format, 1.0)
-        self.assertRaises(ValueError, '{0:d}'.format, 1j)
-        self.assertRaises(ValueError, '{0:d}'.format, 1.0)
-
-        # issue 6089
-        self.assertRaises(ValueError, "{0[0]x}".format, [None])
-        self.assertRaises(ValueError, "{0[0](10)}".format, [None])
-
-        # can't have a replacement on the field name portion
-        self.assertRaises(TypeError, '{0[{1}]}'.format, 'abcdefg', 4)
-
-        # exceed maximum recursion depth
-        self.assertRaises(ValueError, "{0:{1:{2}}}".format, 'abc', 's', '')
-        self.assertRaises(ValueError, "{0:{1:{2:{3:{4:{5:{6}}}}}}}".format,
-                          0, 1, 2, 3, 4, 5, 6, 7)
-
-        # string format spec errors
-        sign_msg = "Sign not allowed in string format specifier"
-        self.assertRaisesRegex(ValueError, sign_msg, "{0:-s}".format, '')
-        self.assertRaisesRegex(ValueError, sign_msg, format, "", "-")
-        space_msg = "Space not allowed in string format specifier"
-        self.assertRaisesRegex(ValueError, space_msg, "{: }".format, '')
-        self.assertRaises(ValueError, "{0:=s}".format, '')
-
-        # Alternate formatting is not supported
-        self.assertRaises(ValueError, format, '', '#')
-        self.assertRaises(ValueError, format, '', '#20')
-
-        # Non-ASCII
-        self.assertEqual("{0:s}{1:s}".format("ABC", "\u0410\u0411\u0412"),
-                         'ABC\u0410\u0411\u0412')
-        self.assertEqual("{0:.3s}".format("ABC\u0410\u0411\u0412"),
-                         'ABC')
-        self.assertEqual("{0:.0s}".format("ABC\u0410\u0411\u0412"),
-                         '')
-
-        self.assertEqual("{[{}]}".format({"{}": 5}), "5")
-        self.assertEqual("{[{}]}".format({"{}" : "a"}), "a")
-        self.assertEqual("{[{]}".format({"{" : "a"}), "a")
-        self.assertEqual("{[}]}".format({"}" : "a"}), "a")
-        self.assertEqual("{[[]}".format({"[" : "a"}), "a")
-        self.assertEqual("{[!]}".format({"!" : "a"}), "a")
-        self.assertRaises(ValueError, "{a{}b}".format, 42)
-        self.assertRaises(ValueError, "{a{b}".format, 42)
-        self.assertRaises(ValueError, "{[}".format, 42)
-
-        self.assertEqual("0x{:0{:d}X}".format(0x0,16), "0x0000000000000000")
-
-        # Blocking fallback
-        m = M('data')
-        self.assertEqual("{!r}".format(m), 'M(data)')
-        self.assertRaises(TypeError, "{!s}".format, m)
-        self.assertRaises(TypeError, "{}".format, m)
-        n = N('data')
-        self.assertEqual("{!r}".format(n), 'N(data)')
-        self.assertEqual("{!s}".format(n), 'N(data)')
-        self.assertRaises(TypeError, "{}".format, n)
-
-    def test_format_map(self):
-        self.assertEqual(''.format_map({}), '')
-        self.assertEqual('a'.format_map({}), 'a')
-        self.assertEqual('ab'.format_map({}), 'ab')
-        self.assertEqual('a{{'.format_map({}), 'a{')
-        self.assertEqual('a}}'.format_map({}), 'a}')
-        self.assertEqual('{{b'.format_map({}), '{b')
-        self.assertEqual('}}b'.format_map({}), '}b')
-        self.assertEqual('a{{b'.format_map({}), 'a{b')
-
-        # using mappings
-        class Mapping(dict):
-            def __missing__(self, key):
-                return key
-        self.assertEqual('{hello}'.format_map(Mapping()), 'hello')
-        self.assertEqual('{a} {world}'.format_map(Mapping(a='hello')), 'hello world')
-
-        class InternalMapping:
-            def __init__(self):
-                self.mapping = {'a': 'hello'}
-            def __getitem__(self, key):
-                return self.mapping[key]
-        self.assertEqual('{a}'.format_map(InternalMapping()), 'hello')
-
-
-        class C:
-            def __init__(self, x=100):
-                self._x = x
-            def __format__(self, spec):
-                return spec
-        self.assertEqual('{foo._x}'.format_map({'foo': C(20)}), '20')
-
-        # test various errors
-        self.assertRaises(TypeError, ''.format_map)
-        self.assertRaises(TypeError, 'a'.format_map)
-
-        self.assertRaises(ValueError, '{'.format_map, {})
-        self.assertRaises(ValueError, '}'.format_map, {})
-        self.assertRaises(ValueError, 'a{'.format_map, {})
-        self.assertRaises(ValueError, 'a}'.format_map, {})
-        self.assertRaises(ValueError, '{a'.format_map, {})
-        self.assertRaises(ValueError, '}a'.format_map, {})
-
-        # issue #12579: can't supply positional params to format_map
-        self.assertRaises(ValueError, '{}'.format_map, {'a' : 2})
-        self.assertRaises(ValueError, '{}'.format_map, 'a')
-        self.assertRaises(ValueError, '{a} {}'.format_map, {"a" : 2, "b" : 1})
-
-        class BadMapping:
-            def __getitem__(self, key):
-                return 1/0
-        self.assertRaises(KeyError, '{a}'.format_map, {})
-        self.assertRaises(TypeError, '{a}'.format_map, [])
-        self.assertRaises(ZeroDivisionError, '{a}'.format_map, BadMapping())
-
-    @unittest.skip("TODO: RUSTPYTHON, killed for chewing up RAM")
-    def test_format_huge_precision(self):
-        format_string = ".{}f".format(sys.maxsize + 1)
-        with self.assertRaises(ValueError):
-            result = format(2.34, format_string)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_format_huge_width(self):
-        format_string = "{}f".format(sys.maxsize + 1)
-        with self.assertRaises(ValueError):
-            result = format(2.34, format_string)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_format_huge_item_number(self):
-        format_string = "{{{}:.6f}}".format(sys.maxsize + 1)
-        with self.assertRaises(ValueError):
-            result = format_string.format(2.34)
-
-    def test_format_auto_numbering(self):
-        class C:
-            def __init__(self, x=100):
-                self._x = x
-            def __format__(self, spec):
-                return spec
-
-        self.assertEqual('{}'.format(10), '10')
-        self.assertEqual('{:5}'.format('s'), 's    ')
-        self.assertEqual('{!r}'.format('s'), "'s'")
-        self.assertEqual('{._x}'.format(C(10)), '10')
-        self.assertEqual('{[1]}'.format([1, 2]), '2')
-        self.assertEqual('{[a]}'.format({'a':4, 'b':2}), '4')
-        self.assertEqual('a{}b{}c'.format(0, 1), 'a0b1c')
-
-        self.assertEqual('a{:{}}b'.format('x', '^10'), 'a    x     b')
-        self.assertEqual('a{:{}x}b'.format(20, '#'), 'a0x14b')
-
-        # can't mix and match numbering and auto-numbering
-        self.assertRaises(ValueError, '{}{1}'.format, 1, 2)
-        self.assertRaises(ValueError, '{1}{}'.format, 1, 2)
-        self.assertRaises(ValueError, '{:{1}}'.format, 1, 2)
-        self.assertRaises(ValueError, '{0:{}}'.format, 1, 2)
-
-        # can mix and match auto-numbering and named
-        self.assertEqual('{f}{}'.format(4, f='test'), 'test4')
-        self.assertEqual('{}{f}'.format(4, f='test'), '4test')
-        self.assertEqual('{:{f}}{g}{}'.format(1, 3, g='g', f=2), ' 1g3')
-        self.assertEqual('{f:{}}{}{g}'.format(2, 4, f=1, g='g'), ' 14g')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_formatting(self):
-        string_tests.MixinStrUnicodeUserStringTest.test_formatting(self)
-        # Testing Unicode formatting strings...
-        self.assertEqual("%s, %s" % ("abc", "abc"), 'abc, abc')
-        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, 2, 3), 'abc, abc, 1, 2.000000,  3.00')
-        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", 1, -2, 3), 'abc, abc, 1, -2.000000,  3.00')
-        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.5), 'abc, abc, -1, -2.000000,  3.50')
-        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 3.57), 'abc, abc, -1, -2.000000,  3.57')
-        self.assertEqual("%s, %s, %i, %f, %5.2f" % ("abc", "abc", -1, -2, 1003.57), 'abc, abc, -1, -2.000000, 1003.57')
-        self.assertEqual("%r, %r" % (b"abc", "abc"), "b'abc', 'abc'")
-        self.assertEqual("%r" % ("\u1234",), "'\u1234'")
-        self.assertEqual("%a" % ("\u1234",), "'\\u1234'")
-        self.assertEqual("%(x)s, %(y)s" % {'x':"abc", 'y':"def"}, 'abc, def')
-        self.assertEqual("%(x)s, %(\xfc)s" % {'x':"abc", '\xfc':"def"}, 'abc, def')
-
-        self.assertEqual('%c' % 0x1234, '\u1234')
-        self.assertEqual('%c' % 0x21483, '\U00021483')
-        self.assertRaises(OverflowError, "%c".__mod__, (0x110000,))
-        self.assertEqual('%c' % '\U00021483', '\U00021483')
-        self.assertRaises(TypeError, "%c".__mod__, "aa")
-        self.assertRaises(ValueError, "%.1\u1032f".__mod__, (1.0/3))
-        self.assertRaises(TypeError, "%i".__mod__, "aa")
-
-        # formatting jobs delegated from the string implementation:
-        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
-        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
-        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
-        self.assertEqual('...%(foo)s...' % {'foo':"abc"}, '...abc...')
-        self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123},  '...abc...')
-        self.assertEqual('...%(foo)s...' % {'foo':"abc",'def':123}, '...abc...')
-        self.assertEqual('...%s...%s...%s...%s...' % (1,2,3,"abc"), '...1...2...3...abc...')
-        self.assertEqual('...%%...%%s...%s...%s...%s...%s...' % (1,2,3,"abc"), '...%...%s...1...2...3...abc...')
-        self.assertEqual('...%s...' % "abc", '...abc...')
-        self.assertEqual('%*s' % (5,'abc',), '  abc')
-        self.assertEqual('%*s' % (-5,'abc',), 'abc  ')
-        self.assertEqual('%*.*s' % (5,2,'abc',), '   ab')
-        self.assertEqual('%*.*s' % (5,3,'abc',), '  abc')
-        self.assertEqual('%i %*.*s' % (10, 5,3,'abc',), '10   abc')
-        self.assertEqual('%i%s %*.*s' % (10, 3, 5, 3, 'abc',), '103   abc')
-        self.assertEqual('%c' % 'a', 'a')
-        class Wrapper:
-            def __str__(self):
-                return '\u1234'
-        self.assertEqual('%s' % Wrapper(), '\u1234')
-
-        # issue 3382
-        NAN = float('nan')
-        INF = float('inf')
-        self.assertEqual('%f' % NAN, 'nan')
-        self.assertEqual('%F' % NAN, 'NAN')
-        self.assertEqual('%f' % INF, 'inf')
-        self.assertEqual('%F' % INF, 'INF')
-
-        # PEP 393
-        self.assertEqual('%.1s' % "a\xe9\u20ac", 'a')
-        self.assertEqual('%.2s' % "a\xe9\u20ac", 'a\xe9')
-
-        #issue 19995
-        class PseudoInt:
-            def __init__(self, value):
-                self.value = int(value)
-            def __int__(self):
-                return self.value
-            def __index__(self):
-                return self.value
-        class PseudoFloat:
-            def __init__(self, value):
-                self.value = float(value)
-            def __int__(self):
-                return int(self.value)
-        pi = PseudoFloat(3.1415)
-        letter_m = PseudoInt(109)
-        self.assertEqual('%x' % 42, '2a')
-        self.assertEqual('%X' % 15, 'F')
-        self.assertEqual('%o' % 9, '11')
-        self.assertEqual('%c' % 109, 'm')
-        self.assertEqual('%x' % letter_m, '6d')
-        self.assertEqual('%X' % letter_m, '6D')
-        self.assertEqual('%o' % letter_m, '155')
-        self.assertEqual('%c' % letter_m, 'm')
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not float', operator.mod, '%x', 3.14)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not float', operator.mod, '%X', 2.11)
-        self.assertRaisesRegex(TypeError, '%o format: an integer is required, not float', operator.mod, '%o', 1.79)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not PseudoFloat', operator.mod, '%x', pi)
-        self.assertRaisesRegex(TypeError, '%x format: an integer is required, not complex', operator.mod, '%x', 3j)
-        self.assertRaisesRegex(TypeError, '%X format: an integer is required, not complex', operator.mod, '%X', 2j)
-        self.assertRaisesRegex(TypeError, '%o format: an integer is required, not complex', operator.mod, '%o', 1j)
-        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)
-
-        class RaisingNumber:
-            def __int__(self):
-                raise RuntimeError('int')  # should not be `TypeError`
-            def __index__(self):
-                raise RuntimeError('index')  # should not be `TypeError`
-
-        rn = RaisingNumber()
-        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%d', rn)
-        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%i', rn)
-        self.assertRaisesRegex(RuntimeError, 'int', operator.mod, '%u', rn)
-        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%x', rn)
-        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%X', rn)
-        self.assertRaisesRegex(RuntimeError, 'index', operator.mod, '%o', rn)
-
-    def test_formatting_with_enum(self):
-        # issue18780
-        import enum
-        class Float(float, enum.Enum):
-            # a mixed-in type will use the name for %s etc.
-            PI = 3.1415926
-        class Int(enum.IntEnum):
-            # IntEnum uses the value and not the name for %s etc.
-            IDES = 15
-        class Str(enum.StrEnum):
-            # StrEnum uses the value and not the name for %s etc.
-            ABC = 'abc'
-        # Testing Unicode formatting strings...
-        self.assertEqual("%s, %s" % (Str.ABC, Str.ABC),
-                         'abc, abc')
-        self.assertEqual("%s, %s, %d, %i, %u, %f, %5.2f" %
-                        (Str.ABC, Str.ABC,
-                         Int.IDES, Int.IDES, Int.IDES,
-                         Float.PI, Float.PI),
-                         'abc, abc, 15, 15, 15, 3.141593,  3.14')
-
-        # formatting jobs delegated from the string implementation:
-        self.assertEqual('...%(foo)s...' % {'foo':Str.ABC},
-                         '...abc...')
-        self.assertEqual('...%(foo)r...' % {'foo':Int.IDES},
-                         '...<Int.IDES: 15>...')
-        self.assertEqual('...%(foo)s...' % {'foo':Int.IDES},
-                         '...15...')
-        self.assertEqual('...%(foo)i...' % {'foo':Int.IDES},
-                         '...15...')
-        self.assertEqual('...%(foo)d...' % {'foo':Int.IDES},
-                         '...15...')
-        self.assertEqual('...%(foo)u...' % {'foo':Int.IDES, 'def':Float.PI},
-                         '...15...')
-        self.assertEqual('...%(foo)f...' % {'foo':Float.PI,'def':123},
-                         '...3.141593...')
-
-    def test_formatting_huge_precision(self):
-        format_string = "%.{}f".format(sys.maxsize + 1)
-        with self.assertRaises(ValueError):
-            result = format_string % 2.34
-
-    def test_issue28598_strsubclass_rhs(self):
-        # A subclass of str with an __rmod__ method should be able to hook
-        # into the % operator
-        class SubclassedStr(str):
-            def __rmod__(self, other):
-                return 'Success, self.__rmod__({!r}) was called'.format(other)
-        self.assertEqual('lhs %% %r' % SubclassedStr('rhs'),
-                         "Success, self.__rmod__('lhs %% %r') was called")
-
-    @support.cpython_only
-    @unittest.skipIf(_testcapi is None, 'need _testcapi module')
-    def test_formatting_huge_precision_c_limits(self):
-        format_string = "%.{}f".format(_testcapi.INT_MAX + 1)
-        with self.assertRaises(ValueError):
-            result = format_string % 2.34
-
-    def test_formatting_huge_width(self):
-        format_string = "%{}f".format(sys.maxsize + 1)
-        with self.assertRaises(ValueError):
-            result = format_string % 2.34
-
-    def test_startswith_endswith_errors(self):
-        for meth in ('foo'.startswith, 'foo'.endswith):
-            with self.assertRaises(TypeError) as cm:
-                meth(['f'])
-            exc = str(cm.exception)
-            self.assertIn('str', exc)
-            self.assertIn('tuple', exc)
-
-    @support.run_with_locale('LC_ALL', 'de_DE', 'fr_FR')
-    def test_format_float(self):
-        # should not format with a comma, but always with C locale
-        self.assertEqual('1.0', '%.1f' % 1.0)
-
-    def test_constructor(self):
-        # unicode(obj) tests (this maps to PyObject_Unicode() at C level)
-
-        self.assertEqual(
-            str('unicode remains unicode'),
-            'unicode remains unicode'
-        )
-
-        for text in ('ascii', '\xe9', '\u20ac', '\U0010FFFF'):
-            subclass = StrSubclass(text)
-            self.assertEqual(str(subclass), text)
-            self.assertEqual(len(subclass), len(text))
-            if text == 'ascii':
-                self.assertEqual(subclass.encode('ascii'), b'ascii')
-                self.assertEqual(subclass.encode('utf-8'), b'ascii')
-
-        self.assertEqual(
-            str('strings are converted to unicode'),
-            'strings are converted to unicode'
-        )
-
-        class StringCompat:
-            def __init__(self, x):
-                self.x = x
-            def __str__(self):
-                return self.x
-
-        self.assertEqual(
-            str(StringCompat('__str__ compatible objects are recognized')),
-            '__str__ compatible objects are recognized'
-        )
-
-        # unicode(obj) is compatible to str():
-
-        o = StringCompat('unicode(obj) is compatible to str()')
-        self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
-        self.assertEqual(str(o), 'unicode(obj) is compatible to str()')
-
-        for obj in (123, 123.45, 123):
-            self.assertEqual(str(obj), str(str(obj)))
-
-        # unicode(obj, encoding, error) tests (this maps to
-        # PyUnicode_FromEncodedObject() at C level)
-
-        self.assertRaises(
-            TypeError,
-            str,
-            'decoding unicode is not supported',
-            'utf-8',
-            'strict'
-        )
-
-        self.assertEqual(
-            str(b'strings are decoded to unicode', 'utf-8', 'strict'),
-            'strings are decoded to unicode'
-        )
-
-        self.assertEqual(
-            str(
-                memoryview(b'character buffers are decoded to unicode'),
-                'utf-8',
-                'strict'
-            ),
-            'character buffers are decoded to unicode'
-        )
-
-        self.assertRaises(TypeError, str, 42, 42, 42)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_constructor_keyword_args(self):
-        """Pass various keyword argument combinations to the constructor."""
-        # The object argument can be passed as a keyword.
-        self.assertEqual(str(object='foo'), 'foo')
-        self.assertEqual(str(object=b'foo', encoding='utf-8'), 'foo')
-        # The errors argument without encoding triggers "decode" mode.
-        self.assertEqual(str(b'foo', errors='strict'), 'foo')  # not "b'foo'"
-        self.assertEqual(str(object=b'foo', errors='strict'), 'foo')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_constructor_defaults(self):
-        """Check the constructor argument defaults."""
-        # The object argument defaults to '' or b''.
-        self.assertEqual(str(), '')
-        self.assertEqual(str(errors='strict'), '')
-        utf8_cent = '¢'.encode('utf-8')
-        # The encoding argument defaults to utf-8.
-        self.assertEqual(str(utf8_cent, errors='strict'), '¢')
-        # The errors argument defaults to strict.
-        self.assertRaises(UnicodeDecodeError, str, utf8_cent, encoding='ascii')
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_codecs_utf7(self):
-        utfTests = [
-            ('A\u2262\u0391.', b'A+ImIDkQ.'),             # RFC2152 example
-            ('Hi Mom -\u263a-!', b'Hi Mom -+Jjo--!'),     # RFC2152 example
-            ('\u65E5\u672C\u8A9E', b'+ZeVnLIqe-'),        # RFC2152 example
-            ('Item 3 is \u00a31.', b'Item 3 is +AKM-1.'), # RFC2152 example
-            ('+', b'+-'),
-            ('+-', b'+--'),
-            ('+?', b'+-?'),
-            (r'\?', b'+AFw?'),
-            ('+?', b'+-?'),
-            (r'\\?', b'+AFwAXA?'),
-            (r'\\\?', b'+AFwAXABc?'),
-            (r'++--', b'+-+---'),
-            ('\U000abcde', b'+2m/c3g-'),                  # surrogate pairs
-            ('/', b'/'),
-        ]
-
-        for (x, y) in utfTests:
-            self.assertEqual(x.encode('utf-7'), y)
-
-        # Unpaired surrogates are passed through
-        self.assertEqual('\uD801'.encode('utf-7'), b'+2AE-')
-        self.assertEqual('\uD801x'.encode('utf-7'), b'+2AE-x')
-        self.assertEqual('\uDC01'.encode('utf-7'), b'+3AE-')
-        self.assertEqual('\uDC01x'.encode('utf-7'), b'+3AE-x')
-        self.assertEqual(b'+2AE-'.decode('utf-7'), '\uD801')
-        self.assertEqual(b'+2AE-x'.decode('utf-7'), '\uD801x')
-        self.assertEqual(b'+3AE-'.decode('utf-7'), '\uDC01')
-        self.assertEqual(b'+3AE-x'.decode('utf-7'), '\uDC01x')
-
-        self.assertEqual('\uD801\U000abcde'.encode('utf-7'), b'+2AHab9ze-')
-        self.assertEqual(b'+2AHab9ze-'.decode('utf-7'), '\uD801\U000abcde')
-
-        # Issue #2242: crash on some Windows/MSVC versions
-        self.assertEqual(b'+\xc1'.decode('utf-7', 'ignore'), '')
-
-        # Direct encoded characters
-        set_d = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'(),-./:?"
-        # Optional direct characters
-        set_o = '!"#$%&*;<=>@[]^_`{|}'
-        for c in set_d:
-            self.assertEqual(c.encode('utf7'), c.encode('ascii'))
-            self.assertEqual(c.encode('ascii').decode('utf7'), c)
-        for c in set_o:
-            self.assertEqual(c.encode('ascii').decode('utf7'), c)
-
-        with self.assertRaisesRegex(UnicodeDecodeError,
-                                    'ill-formed sequence'):
-            b'+@'.decode('utf-7')
-
-    def test_codecs_utf8(self):
-        self.assertEqual(''.encode('utf-8'), b'')
-        self.assertEqual('\u20ac'.encode('utf-8'), b'\xe2\x82\xac')
-        self.assertEqual('\U00010002'.encode('utf-8'), b'\xf0\x90\x80\x82')
-        self.assertEqual('\U00023456'.encode('utf-8'), b'\xf0\xa3\x91\x96')
-        self.assertEqual('\ud800'.encode('utf-8', 'surrogatepass'), b'\xed\xa0\x80')
-        self.assertEqual('\udc00'.encode('utf-8', 'surrogatepass'), b'\xed\xb0\x80')
-        self.assertEqual(('\U00010002'*10).encode('utf-8'),
-                         b'\xf0\x90\x80\x82'*10)
-        self.assertEqual(
-            '\u6b63\u78ba\u306b\u8a00\u3046\u3068\u7ffb\u8a33\u306f'
-            '\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002\u4e00'
-            '\u90e8\u306f\u30c9\u30a4\u30c4\u8a9e\u3067\u3059\u304c'
-            '\u3001\u3042\u3068\u306f\u3067\u305f\u3089\u3081\u3067'
-            '\u3059\u3002\u5b9f\u969b\u306b\u306f\u300cWenn ist das'
-            ' Nunstuck git und'.encode('utf-8'),
-            b'\xe6\xad\xa3\xe7\xa2\xba\xe3\x81\xab\xe8\xa8\x80\xe3\x81'
-            b'\x86\xe3\x81\xa8\xe7\xbf\xbb\xe8\xa8\xb3\xe3\x81\xaf\xe3'
-            b'\x81\x95\xe3\x82\x8c\xe3\x81\xa6\xe3\x81\x84\xe3\x81\xbe'
-            b'\xe3\x81\x9b\xe3\x82\x93\xe3\x80\x82\xe4\xb8\x80\xe9\x83'
-            b'\xa8\xe3\x81\xaf\xe3\x83\x89\xe3\x82\xa4\xe3\x83\x84\xe8'
-            b'\xaa\x9e\xe3\x81\xa7\xe3\x81\x99\xe3\x81\x8c\xe3\x80\x81'
-            b'\xe3\x81\x82\xe3\x81\xa8\xe3\x81\xaf\xe3\x81\xa7\xe3\x81'
-            b'\x9f\xe3\x82\x89\xe3\x82\x81\xe3\x81\xa7\xe3\x81\x99\xe3'
-            b'\x80\x82\xe5\xae\x9f\xe9\x9a\x9b\xe3\x81\xab\xe3\x81\xaf'
-            b'\xe3\x80\x8cWenn ist das Nunstuck git und'
-        )
-
-        # UTF-8 specific decoding tests
-        self.assertEqual(str(b'\xf0\xa3\x91\x96', 'utf-8'), '\U00023456' )
-        self.assertEqual(str(b'\xf0\x90\x80\x82', 'utf-8'), '\U00010002' )
-        self.assertEqual(str(b'\xe2\x82\xac', 'utf-8'), '\u20ac' )
-
-        # Other possible utf-8 test cases:
-        # * strict decoding testing for all of the
-        #   UTF8_ERROR cases in PyUnicode_DecodeUTF8
-
-    def test_utf8_decode_valid_sequences(self):
-        sequences = [
-            # single byte
-            (b'\x00', '\x00'), (b'a', 'a'), (b'\x7f', '\x7f'),
-            # 2 bytes
-            (b'\xc2\x80', '\x80'), (b'\xdf\xbf', '\u07ff'),
-            # 3 bytes
-            (b'\xe0\xa0\x80', '\u0800'), (b'\xed\x9f\xbf', '\ud7ff'),
-            (b'\xee\x80\x80', '\uE000'), (b'\xef\xbf\xbf', '\uffff'),
-            # 4 bytes
-            (b'\xF0\x90\x80\x80', '\U00010000'),
-            (b'\xf4\x8f\xbf\xbf', '\U0010FFFF')
-        ]
-        for seq, res in sequences:
-            self.assertEqual(seq.decode('utf-8'), res)
-
-
-    def test_utf8_decode_invalid_sequences(self):
-        # continuation bytes in a sequence of 2, 3, or 4 bytes
-        continuation_bytes = [bytes([x]) for x in range(0x80, 0xC0)]
-        # start bytes of a 2-byte sequence equivalent to code points < 0x7F
-        invalid_2B_seq_start_bytes = [bytes([x]) for x in range(0xC0, 0xC2)]
-        # start bytes of a 4-byte sequence equivalent to code points > 0x10FFFF
-        invalid_4B_seq_start_bytes = [bytes([x]) for x in range(0xF5, 0xF8)]
-        invalid_start_bytes = (
-            continuation_bytes + invalid_2B_seq_start_bytes +
-            invalid_4B_seq_start_bytes + [bytes([x]) for x in range(0xF7, 0x100)]
-        )
-
-        for byte in invalid_start_bytes:
-            self.assertRaises(UnicodeDecodeError, byte.decode, 'utf-8')
-
-        for sb in invalid_2B_seq_start_bytes:
-            for cb in continuation_bytes:
-                self.assertRaises(UnicodeDecodeError, (sb+cb).decode, 'utf-8')
-
-        for sb in invalid_4B_seq_start_bytes:
-            for cb1 in continuation_bytes[:3]:
-                for cb3 in continuation_bytes[:3]:
-                    self.assertRaises(UnicodeDecodeError,
-                                      (sb+cb1+b'\x80'+cb3).decode, 'utf-8')
-
-        for cb in [bytes([x]) for x in range(0x80, 0xA0)]:
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xE0'+cb+b'\x80').decode, 'utf-8')
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xE0'+cb+b'\xBF').decode, 'utf-8')
-        # surrogates
-        for cb in [bytes([x]) for x in range(0xA0, 0xC0)]:
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xED'+cb+b'\x80').decode, 'utf-8')
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xED'+cb+b'\xBF').decode, 'utf-8')
-        for cb in [bytes([x]) for x in range(0x80, 0x90)]:
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xF0'+cb+b'\x80\x80').decode, 'utf-8')
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xF0'+cb+b'\xBF\xBF').decode, 'utf-8')
-        for cb in [bytes([x]) for x in range(0x90, 0xC0)]:
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xF4'+cb+b'\x80\x80').decode, 'utf-8')
-            self.assertRaises(UnicodeDecodeError,
-                              (b'\xF4'+cb+b'\xBF\xBF').decode, 'utf-8')
-
-    def test_issue8271(self):
-        # Issue #8271: during the decoding of an invalid UTF-8 byte sequence,
-        # only the start byte and the continuation byte(s) are now considered
-        # invalid, instead of the number of bytes specified by the start byte.
-        # See https://www.unicode.org/versions/Unicode5.2.0/ch03.pdf (page 95,
-        # table 3-8, Row 2) for more information about the algorithm used.
-        FFFD = '\ufffd'
-        sequences = [
-            # invalid start bytes
-            (b'\x80', FFFD), # continuation byte
-            (b'\x80\x80', FFFD*2), # 2 continuation bytes
-            (b'\xc0', FFFD),
-            (b'\xc0\xc0', FFFD*2),
-            (b'\xc1', FFFD),
-            (b'\xc1\xc0', FFFD*2),
-            (b'\xc0\xc1', FFFD*2),
-            # with start byte of a 2-byte sequence
-            (b'\xc2', FFFD), # only the start byte
-            (b'\xc2\xc2', FFFD*2), # 2 start bytes
-            (b'\xc2\xc2\xc2', FFFD*3), # 3 start bytes
-            (b'\xc2\x41', FFFD+'A'), # invalid continuation byte
-            # with start byte of a 3-byte sequence
-            (b'\xe1', FFFD), # only the start byte
-            (b'\xe1\xe1', FFFD*2), # 2 start bytes
-            (b'\xe1\xe1\xe1', FFFD*3), # 3 start bytes
-            (b'\xe1\xe1\xe1\xe1', FFFD*4), # 4 start bytes
-            (b'\xe1\x80', FFFD), # only 1 continuation byte
-            (b'\xe1\x41', FFFD+'A'), # invalid continuation byte
-            (b'\xe1\x41\x80', FFFD+'A'+FFFD), # invalid cb followed by valid cb
-            (b'\xe1\x41\x41', FFFD+'AA'), # 2 invalid continuation bytes
-            (b'\xe1\x80\x41', FFFD+'A'), # only 1 valid continuation byte
-            (b'\xe1\x80\xe1\x41', FFFD*2+'A'), # 1 valid and the other invalid
-            (b'\xe1\x41\xe1\x80', FFFD+'A'+FFFD), # 1 invalid and the other valid
-            # with start byte of a 4-byte sequence
-            (b'\xf1', FFFD), # only the start byte
-            (b'\xf1\xf1', FFFD*2), # 2 start bytes
-            (b'\xf1\xf1\xf1', FFFD*3), # 3 start bytes
-            (b'\xf1\xf1\xf1\xf1', FFFD*4), # 4 start bytes
-            (b'\xf1\xf1\xf1\xf1\xf1', FFFD*5), # 5 start bytes
-            (b'\xf1\x80', FFFD), # only 1 continuation bytes
-            (b'\xf1\x80\x80', FFFD), # only 2 continuation bytes
-            (b'\xf1\x80\x41', FFFD+'A'), # 1 valid cb and 1 invalid
-            (b'\xf1\x80\x41\x41', FFFD+'AA'), # 1 valid cb and 1 invalid
-            (b'\xf1\x80\x80\x41', FFFD+'A'), # 2 valid cb and 1 invalid
-            (b'\xf1\x41\x80', FFFD+'A'+FFFD), # 1 invalid cv and 1 valid
-            (b'\xf1\x41\x80\x80', FFFD+'A'+FFFD*2), # 1 invalid cb and 2 invalid
-            (b'\xf1\x41\x80\x41', FFFD+'A'+FFFD+'A'), # 2 invalid cb and 1 invalid
-            (b'\xf1\x41\x41\x80', FFFD+'AA'+FFFD), # 1 valid cb and 1 invalid
-            (b'\xf1\x41\xf1\x80', FFFD+'A'+FFFD),
-            (b'\xf1\x41\x80\xf1', FFFD+'A'+FFFD*2),
-            (b'\xf1\xf1\x80\x41', FFFD*2+'A'),
-            (b'\xf1\x41\xf1\xf1', FFFD+'A'+FFFD*2),
-            # with invalid start byte of a 4-byte sequence (rfc2279)
-            (b'\xf5', FFFD), # only the start byte
-            (b'\xf5\xf5', FFFD*2), # 2 start bytes
-            (b'\xf5\x80', FFFD*2), # only 1 continuation byte
-            (b'\xf5\x80\x80', FFFD*3), # only 2 continuation byte
-            (b'\xf5\x80\x80\x80', FFFD*4), # 3 continuation bytes
-            (b'\xf5\x80\x41', FFFD*2+'A'), #  1 valid cb and 1 invalid
-            (b'\xf5\x80\x41\xf5', FFFD*2+'A'+FFFD),
-            (b'\xf5\x41\x80\x80\x41', FFFD+'A'+FFFD*2+'A'),
-            # with invalid start byte of a 5-byte sequence (rfc2279)
-            (b'\xf8', FFFD), # only the start byte
-            (b'\xf8\xf8', FFFD*2), # 2 start bytes
-            (b'\xf8\x80', FFFD*2), # only one continuation byte
-            (b'\xf8\x80\x41', FFFD*2 + 'A'), # 1 valid cb and 1 invalid
-            (b'\xf8\x80\x80\x80\x80', FFFD*5), # invalid 5 bytes seq with 5 bytes
-            # with invalid start byte of a 6-byte sequence (rfc2279)
-            (b'\xfc', FFFD), # only the start byte
-            (b'\xfc\xfc', FFFD*2), # 2 start bytes
-            (b'\xfc\x80\x80', FFFD*3), # only 2 continuation bytes
-            (b'\xfc\x80\x80\x80\x80\x80', FFFD*6), # 6 continuation bytes
-            # invalid start byte
-            (b'\xfe', FFFD),
-            (b'\xfe\x80\x80', FFFD*3),
-            # other sequences
-            (b'\xf1\x80\x41\x42\x43', '\ufffd\x41\x42\x43'),
-            (b'\xf1\x80\xff\x42\x43', '\ufffd\ufffd\x42\x43'),
-            (b'\xf1\x80\xc2\x81\x43', '\ufffd\x81\x43'),
-            (b'\x61\xF1\x80\x80\xE1\x80\xC2\x62\x80\x63\x80\xBF\x64',
-             '\x61\uFFFD\uFFFD\uFFFD\x62\uFFFD\x63\uFFFD\uFFFD\x64'),
-        ]
-        for n, (seq, res) in enumerate(sequences):
-            self.assertRaises(UnicodeDecodeError, seq.decode, 'utf-8', 'strict')
-            self.assertEqual(seq.decode('utf-8', 'replace'), res)
-            self.assertEqual((seq+b'b').decode('utf-8', 'replace'), res+'b')
-            self.assertEqual(seq.decode('utf-8', 'ignore'),
-                             res.replace('\uFFFD', ''))
-
-    def assertCorrectUTF8Decoding(self, seq, res, err):
-        """
-        Check that an invalid UTF-8 sequence raises a UnicodeDecodeError when
-        'strict' is used, returns res when 'replace' is used, and that doesn't
-        return anything when 'ignore' is used.
-        """
-        with self.assertRaises(UnicodeDecodeError) as cm:
-            seq.decode('utf-8')
-        exc = cm.exception
-
-        self.assertIn(err, str(exc))
-        self.assertEqual(seq.decode('utf-8', 'replace'), res)
-        self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'replace'),
-                         'aaaa' + res + 'bbbb')
-        res = res.replace('\ufffd', '')
-        self.assertEqual(seq.decode('utf-8', 'ignore'), res)
-        self.assertEqual((b'aaaa' + seq + b'bbbb').decode('utf-8', 'ignore'),
-                          'aaaa' + res + 'bbbb')
-
-    def test_invalid_start_byte(self):
-        """
-        Test that an 'invalid start byte' error is raised when the first byte
-        is not in the ASCII range or is not a valid start byte of a 2-, 3-, or
-        4-bytes sequence. The invalid start byte is replaced with a single
-        U+FFFD when errors='replace'.
-        E.g. <80> is a continuation byte and can appear only after a start byte.
-        """
-        FFFD = '\ufffd'
-        for byte in b'\x80\xA0\x9F\xBF\xC0\xC1\xF5\xFF':
-            self.assertCorrectUTF8Decoding(bytes([byte]), '\ufffd',
-                                           'invalid start byte')
-
-    def test_unexpected_end_of_data(self):
-        """
-        Test that an 'unexpected end of data' error is raised when the string
-        ends after a start byte of a 2-, 3-, or 4-bytes sequence without having
-        enough continuation bytes.  The incomplete sequence is replaced with a
-        single U+FFFD when errors='replace'.
-        E.g. in the sequence <F3 80 80>, F3 is the start byte of a 4-bytes
-        sequence, but it's followed by only 2 valid continuation bytes and the
-        last continuation bytes is missing.
-        Note: the continuation bytes must be all valid, if one of them is
-        invalid another error will be raised.
-        """
-        sequences = [
-            'C2', 'DF',
-            'E0 A0', 'E0 BF', 'E1 80', 'E1 BF', 'EC 80', 'EC BF',
-            'ED 80', 'ED 9F', 'EE 80', 'EE BF', 'EF 80', 'EF BF',
-            'F0 90', 'F0 BF', 'F0 90 80', 'F0 90 BF', 'F0 BF 80', 'F0 BF BF',
-            'F1 80', 'F1 BF', 'F1 80 80', 'F1 80 BF', 'F1 BF 80', 'F1 BF BF',
-            'F3 80', 'F3 BF', 'F3 80 80', 'F3 80 BF', 'F3 BF 80', 'F3 BF BF',
-            'F4 80', 'F4 8F', 'F4 80 80', 'F4 80 BF', 'F4 8F 80', 'F4 8F BF'
-        ]
-        FFFD = '\ufffd'
-        for seq in sequences:
-            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), '\ufffd',
-                                           'unexpected end of data')
-
-    def test_invalid_cb_for_2bytes_seq(self):
-        """
-        Test that an 'invalid continuation byte' error is raised when the
-        continuation byte of a 2-bytes sequence is invalid.  The start byte
-        is replaced by a single U+FFFD and the second byte is handled
-        separately when errors='replace'.
-        E.g. in the sequence <C2 41>, C2 is the start byte of a 2-bytes
-        sequence, but 41 is not a valid continuation byte because it's the
-        ASCII letter 'A'.
-        """
-        FFFD = '\ufffd'
-        FFFDx2 = FFFD * 2
-        sequences = [
-            ('C2 00', FFFD+'\x00'), ('C2 7F', FFFD+'\x7f'),
-            ('C2 C0', FFFDx2), ('C2 FF', FFFDx2),
-            ('DF 00', FFFD+'\x00'), ('DF 7F', FFFD+'\x7f'),
-            ('DF C0', FFFDx2), ('DF FF', FFFDx2),
-        ]
-        for seq, res in sequences:
-            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
-                                           'invalid continuation byte')
-
-    def test_invalid_cb_for_3bytes_seq(self):
-        """
-        Test that an 'invalid continuation byte' error is raised when the
-        continuation byte(s) of a 3-bytes sequence are invalid.  When
-        errors='replace', if the first continuation byte is valid, the first
-        two bytes (start byte + 1st cb) are replaced by a single U+FFFD and the
-        third byte is handled separately, otherwise only the start byte is
-        replaced with a U+FFFD and the other continuation bytes are handled
-        separately.
-        E.g. in the sequence <E1 80 41>, E1 is the start byte of a 3-bytes
-        sequence, 80 is a valid continuation byte, but 41 is not a valid cb
-        because it's the ASCII letter 'A'.
-        Note: when the start byte is E0 or ED, the valid ranges for the first
-        continuation byte are limited to A0..BF and 80..9F respectively.
-        Python 2 used to consider all the bytes in range 80..BF valid when the
-        start byte was ED.  This is fixed in Python 3.
-        """
-        FFFD = '\ufffd'
-        FFFDx2 = FFFD * 2
-        sequences = [
-            ('E0 00', FFFD+'\x00'), ('E0 7F', FFFD+'\x7f'), ('E0 80', FFFDx2),
-            ('E0 9F', FFFDx2), ('E0 C0', FFFDx2), ('E0 FF', FFFDx2),
-            ('E0 A0 00', FFFD+'\x00'), ('E0 A0 7F', FFFD+'\x7f'),
-            ('E0 A0 C0', FFFDx2), ('E0 A0 FF', FFFDx2),
-            ('E0 BF 00', FFFD+'\x00'), ('E0 BF 7F', FFFD+'\x7f'),
-            ('E0 BF C0', FFFDx2), ('E0 BF FF', FFFDx2), ('E1 00', FFFD+'\x00'),
-            ('E1 7F', FFFD+'\x7f'), ('E1 C0', FFFDx2), ('E1 FF', FFFDx2),
-            ('E1 80 00', FFFD+'\x00'), ('E1 80 7F', FFFD+'\x7f'),
-            ('E1 80 C0', FFFDx2), ('E1 80 FF', FFFDx2),
-            ('E1 BF 00', FFFD+'\x00'), ('E1 BF 7F', FFFD+'\x7f'),
-            ('E1 BF C0', FFFDx2), ('E1 BF FF', FFFDx2), ('EC 00', FFFD+'\x00'),
-            ('EC 7F', FFFD+'\x7f'), ('EC C0', FFFDx2), ('EC FF', FFFDx2),
-            ('EC 80 00', FFFD+'\x00'), ('EC 80 7F', FFFD+'\x7f'),
-            ('EC 80 C0', FFFDx2), ('EC 80 FF', FFFDx2),
-            ('EC BF 00', FFFD+'\x00'), ('EC BF 7F', FFFD+'\x7f'),
-            ('EC BF C0', FFFDx2), ('EC BF FF', FFFDx2), ('ED 00', FFFD+'\x00'),
-            ('ED 7F', FFFD+'\x7f'),
-            ('ED A0', FFFDx2), ('ED BF', FFFDx2), # see note ^
-            ('ED C0', FFFDx2), ('ED FF', FFFDx2), ('ED 80 00', FFFD+'\x00'),
-            ('ED 80 7F', FFFD+'\x7f'), ('ED 80 C0', FFFDx2),
-            ('ED 80 FF', FFFDx2), ('ED 9F 00', FFFD+'\x00'),
-            ('ED 9F 7F', FFFD+'\x7f'), ('ED 9F C0', FFFDx2),
-            ('ED 9F FF', FFFDx2), ('EE 00', FFFD+'\x00'),
-            ('EE 7F', FFFD+'\x7f'), ('EE C0', FFFDx2), ('EE FF', FFFDx2),
-            ('EE 80 00', FFFD+'\x00'), ('EE 80 7F', FFFD+'\x7f'),
-            ('EE 80 C0', FFFDx2), ('EE 80 FF', FFFDx2),
-            ('EE BF 00', FFFD+'\x00'), ('EE BF 7F', FFFD+'\x7f'),
-            ('EE BF C0', FFFDx2), ('EE BF FF', FFFDx2), ('EF 00', FFFD+'\x00'),
-            ('EF 7F', FFFD+'\x7f'), ('EF C0', FFFDx2), ('EF FF', FFFDx2),
-            ('EF 80 00', FFFD+'\x00'), ('EF 80 7F', FFFD+'\x7f'),
-            ('EF 80 C0', FFFDx2), ('EF 80 FF', FFFDx2),
-            ('EF BF 00', FFFD+'\x00'), ('EF BF 7F', FFFD+'\x7f'),
-            ('EF BF C0', FFFDx2), ('EF BF FF', FFFDx2),
-        ]
-        for seq, res in sequences:
-            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
-                                           'invalid continuation byte')
-
-    def test_invalid_cb_for_4bytes_seq(self):
-        """
-        Test that an 'invalid continuation byte' error is raised when the
-        continuation byte(s) of a 4-bytes sequence are invalid.  When
-        errors='replace',the start byte and all the following valid
-        continuation bytes are replaced with a single U+FFFD, and all the bytes
-        starting from the first invalid continuation bytes (included) are
-        handled separately.
-        E.g. in the sequence <E1 80 41>, E1 is the start byte of a 3-bytes
-        sequence, 80 is a valid continuation byte, but 41 is not a valid cb
-        because it's the ASCII letter 'A'.
-        Note: when the start byte is E0 or ED, the valid ranges for the first
-        continuation byte are limited to A0..BF and 80..9F respectively.
-        However, when the start byte is ED, Python 2 considers all the bytes
-        in range 80..BF valid.  This is fixed in Python 3.
-        """
-        FFFD = '\ufffd'
-        FFFDx2 = FFFD * 2
-        sequences = [
-            ('F0 00', FFFD+'\x00'), ('F0 7F', FFFD+'\x7f'), ('F0 80', FFFDx2),
-            ('F0 8F', FFFDx2), ('F0 C0', FFFDx2), ('F0 FF', FFFDx2),
-            ('F0 90 00', FFFD+'\x00'), ('F0 90 7F', FFFD+'\x7f'),
-            ('F0 90 C0', FFFDx2), ('F0 90 FF', FFFDx2),
-            ('F0 BF 00', FFFD+'\x00'), ('F0 BF 7F', FFFD+'\x7f'),
-            ('F0 BF C0', FFFDx2), ('F0 BF FF', FFFDx2),
-            ('F0 90 80 00', FFFD+'\x00'), ('F0 90 80 7F', FFFD+'\x7f'),
-            ('F0 90 80 C0', FFFDx2), ('F0 90 80 FF', FFFDx2),
-            ('F0 90 BF 00', FFFD+'\x00'), ('F0 90 BF 7F', FFFD+'\x7f'),
-            ('F0 90 BF C0', FFFDx2), ('F0 90 BF FF', FFFDx2),
-            ('F0 BF 80 00', FFFD+'\x00'), ('F0 BF 80 7F', FFFD+'\x7f'),
-            ('F0 BF 80 C0', FFFDx2), ('F0 BF 80 FF', FFFDx2),
-            ('F0 BF BF 00', FFFD+'\x00'), ('F0 BF BF 7F', FFFD+'\x7f'),
-            ('F0 BF BF C0', FFFDx2), ('F0 BF BF FF', FFFDx2),
-            ('F1 00', FFFD+'\x00'), ('F1 7F', FFFD+'\x7f'), ('F1 C0', FFFDx2),
-            ('F1 FF', FFFDx2), ('F1 80 00', FFFD+'\x00'),
-            ('F1 80 7F', FFFD+'\x7f'), ('F1 80 C0', FFFDx2),
-            ('F1 80 FF', FFFDx2), ('F1 BF 00', FFFD+'\x00'),
-            ('F1 BF 7F', FFFD+'\x7f'), ('F1 BF C0', FFFDx2),
-            ('F1 BF FF', FFFDx2), ('F1 80 80 00', FFFD+'\x00'),
-            ('F1 80 80 7F', FFFD+'\x7f'), ('F1 80 80 C0', FFFDx2),
-            ('F1 80 80 FF', FFFDx2), ('F1 80 BF 00', FFFD+'\x00'),
-            ('F1 80 BF 7F', FFFD+'\x7f'), ('F1 80 BF C0', FFFDx2),
-            ('F1 80 BF FF', FFFDx2), ('F1 BF 80 00', FFFD+'\x00'),
-            ('F1 BF 80 7F', FFFD+'\x7f'), ('F1 BF 80 C0', FFFDx2),
-            ('F1 BF 80 FF', FFFDx2), ('F1 BF BF 00', FFFD+'\x00'),
-            ('F1 BF BF 7F', FFFD+'\x7f'), ('F1 BF BF C0', FFFDx2),
-            ('F1 BF BF FF', FFFDx2), ('F3 00', FFFD+'\x00'),
-            ('F3 7F', FFFD+'\x7f'), ('F3 C0', FFFDx2), ('F3 FF', FFFDx2),
-            ('F3 80 00', FFFD+'\x00'), ('F3 80 7F', FFFD+'\x7f'),
-            ('F3 80 C0', FFFDx2), ('F3 80 FF', FFFDx2),
-            ('F3 BF 00', FFFD+'\x00'), ('F3 BF 7F', FFFD+'\x7f'),
-            ('F3 BF C0', FFFDx2), ('F3 BF FF', FFFDx2),
-            ('F3 80 80 00', FFFD+'\x00'), ('F3 80 80 7F', FFFD+'\x7f'),
-            ('F3 80 80 C0', FFFDx2), ('F3 80 80 FF', FFFDx2),
-            ('F3 80 BF 00', FFFD+'\x00'), ('F3 80 BF 7F', FFFD+'\x7f'),
-            ('F3 80 BF C0', FFFDx2), ('F3 80 BF FF', FFFDx2),
-            ('F3 BF 80 00', FFFD+'\x00'), ('F3 BF 80 7F', FFFD+'\x7f'),
-            ('F3 BF 80 C0', FFFDx2), ('F3 BF 80 FF', FFFDx2),
-            ('F3 BF BF 00', FFFD+'\x00'), ('F3 BF BF 7F', FFFD+'\x7f'),
-            ('F3 BF BF C0', FFFDx2), ('F3 BF BF FF', FFFDx2),
-            ('F4 00', FFFD+'\x00'), ('F4 7F', FFFD+'\x7f'), ('F4 90', FFFDx2),
-            ('F4 BF', FFFDx2), ('F4 C0', FFFDx2), ('F4 FF', FFFDx2),
-            ('F4 80 00', FFFD+'\x00'), ('F4 80 7F', FFFD+'\x7f'),
-            ('F4 80 C0', FFFDx2), ('F4 80 FF', FFFDx2),
-            ('F4 8F 00', FFFD+'\x00'), ('F4 8F 7F', FFFD+'\x7f'),
-            ('F4 8F C0', FFFDx2), ('F4 8F FF', FFFDx2),
-            ('F4 80 80 00', FFFD+'\x00'), ('F4 80 80 7F', FFFD+'\x7f'),
-            ('F4 80 80 C0', FFFDx2), ('F4 80 80 FF', FFFDx2),
-            ('F4 80 BF 00', FFFD+'\x00'), ('F4 80 BF 7F', FFFD+'\x7f'),
-            ('F4 80 BF C0', FFFDx2), ('F4 80 BF FF', FFFDx2),
-            ('F4 8F 80 00', FFFD+'\x00'), ('F4 8F 80 7F', FFFD+'\x7f'),
-            ('F4 8F 80 C0', FFFDx2), ('F4 8F 80 FF', FFFDx2),
-            ('F4 8F BF 00', FFFD+'\x00'), ('F4 8F BF 7F', FFFD+'\x7f'),
-            ('F4 8F BF C0', FFFDx2), ('F4 8F BF FF', FFFDx2)
-        ]
-        for seq, res in sequences:
-            self.assertCorrectUTF8Decoding(bytes.fromhex(seq), res,
-                                           'invalid continuation byte')
-
-    def test_codecs_idna(self):
-        # Test whether trailing dot is preserved
-        self.assertEqual("www.python.org.".encode("idna"), b"www.python.org.")
-
-    def test_codecs_errors(self):
-        # Error handling (encoding)
-        self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii')
-        self.assertRaises(UnicodeError, 'Andr\202 x'.encode, 'ascii','strict')
-        self.assertEqual('Andr\202 x'.encode('ascii','ignore'), b"Andr x")
-        self.assertEqual('Andr\202 x'.encode('ascii','replace'), b"Andr? x")
-        self.assertEqual('Andr\202 x'.encode('ascii', 'replace'),
-                         'Andr\202 x'.encode('ascii', errors='replace'))
-        self.assertEqual('Andr\202 x'.encode('ascii', 'ignore'),
-                         'Andr\202 x'.encode(encoding='ascii', errors='ignore'))
-
-        # Error handling (decoding)
-        self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii')
-        self.assertRaises(UnicodeError, str, b'Andr\202 x', 'ascii', 'strict')
-        self.assertEqual(str(b'Andr\202 x', 'ascii', 'ignore'), "Andr x")
-        self.assertEqual(str(b'Andr\202 x', 'ascii', 'replace'), 'Andr\uFFFD x')
-        self.assertEqual(str(b'\202 x', 'ascii', 'replace'), '\uFFFD x')
-
-        # Error handling (unknown character names)
-        self.assertEqual(b"\\N{foo}xx".decode("unicode-escape", "ignore"), "xx")
-
-        # Error handling (truncated escape sequence)
-        self.assertRaises(UnicodeError, b"\\".decode, "unicode-escape")
-
-        self.assertRaises(TypeError, b"hello".decode, "test.unicode1")
-        self.assertRaises(TypeError, str, b"hello", "test.unicode2")
-        self.assertRaises(TypeError, "hello".encode, "test.unicode1")
-        self.assertRaises(TypeError, "hello".encode, "test.unicode2")
-
-        # Error handling (wrong arguments)
-        self.assertRaises(TypeError, "hello".encode, 42, 42, 42)
-
-        # Error handling (lone surrogate in
-        # _PyUnicode_TransformDecimalAndSpaceToASCII())
-        self.assertRaises(ValueError, int, "\ud800")
-        self.assertRaises(ValueError, int, "\udf00")
-        self.assertRaises(ValueError, float, "\ud800")
-        self.assertRaises(ValueError, float, "\udf00")
-        self.assertRaises(ValueError, complex, "\ud800")
-        self.assertRaises(ValueError, complex, "\udf00")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_codecs(self):
-        # Encoding
-        self.assertEqual('hello'.encode('ascii'), b'hello')
-        self.assertEqual('hello'.encode('utf-7'), b'hello')
-        self.assertEqual('hello'.encode('utf-8'), b'hello')
-        self.assertEqual('hello'.encode('utf-8'), b'hello')
-        self.assertEqual('hello'.encode('utf-16-le'), b'h\000e\000l\000l\000o\000')
-        self.assertEqual('hello'.encode('utf-16-be'), b'\000h\000e\000l\000l\000o')
-        self.assertEqual('hello'.encode('latin-1'), b'hello')
-
-        # Default encoding is utf-8
-        self.assertEqual('\u2603'.encode(), b'\xe2\x98\x83')
-
-        # Roundtrip safety for BMP (just the first 1024 chars)
-        for c in range(1024):
-            u = chr(c)
-            for encoding in ('utf-7', 'utf-8', 'utf-16', 'utf-16-le',
-                             'utf-16-be', 'raw_unicode_escape',
-                             'unicode_escape'):
-                self.assertEqual(str(u.encode(encoding),encoding), u)
-
-        # Roundtrip safety for BMP (just the first 256 chars)
-        for c in range(256):
-            u = chr(c)
-            for encoding in ('latin-1',):
-                self.assertEqual(str(u.encode(encoding),encoding), u)
-
-        # Roundtrip safety for BMP (just the first 128 chars)
-        for c in range(128):
-            u = chr(c)
-            for encoding in ('ascii',):
-                self.assertEqual(str(u.encode(encoding),encoding), u)
-
-        # Roundtrip safety for non-BMP (just a few chars)
-        with warnings.catch_warnings():
-            u = '\U00010001\U00020002\U00030003\U00040004\U00050005'
-            for encoding in ('utf-8', 'utf-16', 'utf-16-le', 'utf-16-be',
-                             'raw_unicode_escape', 'unicode_escape'):
-                self.assertEqual(str(u.encode(encoding),encoding), u)
-
-        # UTF-8 must be roundtrip safe for all code points
-        # (except surrogates, which are forbidden).
-        u = ''.join(map(chr, list(range(0, 0xd800)) +
-                             list(range(0xe000, 0x110000))))
-        for encoding in ('utf-8',):
-            self.assertEqual(str(u.encode(encoding),encoding), u)
-
-    def test_codecs_charmap(self):
-        # 0-127
-        s = bytes(range(128))
-        for encoding in (
-            'cp037', 'cp1026', 'cp273',
-            'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',
-            'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',
-            'cp863', 'cp865', 'cp866', 'cp1125',
-            'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
-            'iso8859_2', 'iso8859_3', 'iso8859_4', 'iso8859_5', 'iso8859_6',
-            'iso8859_7', 'iso8859_9',
-            'koi8_r', 'koi8_t', 'koi8_u', 'kz1048', 'latin_1',
-            'mac_cyrillic', 'mac_latin2',
-
-            'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
-            'cp1256', 'cp1257', 'cp1258',
-            'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
-
-            'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
-            'cp1006', 'iso8859_8',
-
-            ### These have undefined mappings:
-            #'cp424',
-
-            ### These fail the round-trip:
-            #'cp875'
-
-            ):
-            self.assertEqual(str(s, encoding).encode(encoding), s)
-
-        # 128-255
-        s = bytes(range(128, 256))
-        for encoding in (
-            'cp037', 'cp1026', 'cp273',
-            'cp437', 'cp500', 'cp720', 'cp737', 'cp775', 'cp850',
-            'cp852', 'cp855', 'cp858', 'cp860', 'cp861', 'cp862',
-            'cp863', 'cp865', 'cp866', 'cp1125',
-            'iso8859_10', 'iso8859_13', 'iso8859_14', 'iso8859_15',
-            'iso8859_2', 'iso8859_4', 'iso8859_5',
-            'iso8859_9', 'koi8_r', 'koi8_u', 'latin_1',
-            'mac_cyrillic', 'mac_latin2',
-
-            ### These have undefined mappings:
-            #'cp1250', 'cp1251', 'cp1252', 'cp1253', 'cp1254', 'cp1255',
-            #'cp1256', 'cp1257', 'cp1258',
-            #'cp424', 'cp856', 'cp857', 'cp864', 'cp869', 'cp874',
-            #'iso8859_3', 'iso8859_6', 'iso8859_7', 'koi8_t', 'kz1048',
-            #'mac_greek', 'mac_iceland','mac_roman', 'mac_turkish',
-
-            ### These fail the round-trip:
-            #'cp1006', 'cp875', 'iso8859_8',
-
-            ):
-            self.assertEqual(str(s, encoding).encode(encoding), s)
-
-    def test_concatenation(self):
-        self.assertEqual(("abc" "def"), "abcdef")
-        self.assertEqual(("abc" "def"), "abcdef")
-        self.assertEqual(("abc" "def"), "abcdef")
-        self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
-        self.assertEqual(("abc" "def" "ghi"), "abcdefghi")
-
-    def test_ucs4(self):
-        x = '\U00100000'
-        y = x.encode("raw-unicode-escape").decode("raw-unicode-escape")
-        self.assertEqual(x, y)
-
-        y = br'\U00100000'
-        x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")
-        self.assertEqual(x, y)
-        y = br'\U00010000'
-        x = y.decode("raw-unicode-escape").encode("raw-unicode-escape")
-        self.assertEqual(x, y)
-
-        try:
-            br'\U11111111'.decode("raw-unicode-escape")
-        except UnicodeDecodeError as e:
-            self.assertEqual(e.start, 0)
-            self.assertEqual(e.end, 10)
-        else:
-            self.fail("Should have raised UnicodeDecodeError")
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_conversion(self):
-        # Make sure __str__() works properly
-        class ObjectToStr:
-            def __str__(self):
-                return "foo"
-
-        class StrSubclassToStr(str):
-            def __str__(self):
-                return "foo"
-
-        class StrSubclassToStrSubclass(str):
-            def __new__(cls, content=""):
-                return str.__new__(cls, 2*content)
-            def __str__(self):
-                return self
-
-        self.assertEqual(str(ObjectToStr()), "foo")
-        self.assertEqual(str(StrSubclassToStr("bar")), "foo")
-        s = str(StrSubclassToStrSubclass("foo"))
-        self.assertEqual(s, "foofoo")
-        self.assertIs(type(s), StrSubclassToStrSubclass)
-        s = StrSubclass(StrSubclassToStrSubclass("foo"))
-        self.assertEqual(s, "foofoo")
-        self.assertIs(type(s), StrSubclass)
-
-    def test_unicode_repr(self):
-        class s1:
-            def __repr__(self):
-                return '\\n'
-
-        self.assertEqual(repr(s1()), '\\n')
-
-    def test_printable_repr(self):
-        self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,)) # printable
-        self.assertEqual(repr('\U00014000'), "'\\U00014000'")     # nonprintable
-
-    # This test only affects 32-bit platforms because expandtabs can only take
-    # an int as the max value, not a 64-bit C long.  If expandtabs is changed
-    # to take a 64-bit long, this test should apply to all platforms.
-    @unittest.skip("TODO: RUSTPYTHON, oom handling")
-    @unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
-                     'only applies to 32-bit platforms')
-    def test_expandtabs_overflows_gracefully(self):
-        self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize)
-
-    @support.cpython_only
-    def test_expandtabs_optimization(self):
-        s = 'abc'
-        self.assertIs(s.expandtabs(), s)
-
-    @unittest.skip("TODO: RUSTPYTHON, aborted: memory allocation of 9223372036854775759 bytes failed")
-    def test_raiseMemError(self):
-        asciifields = "nnb"
-        compactfields = asciifields + "nP"
-        ascii_struct_size = support.calcobjsize(asciifields)
-        compact_struct_size = support.calcobjsize(compactfields)
-
-        for char in ('a', '\xe9', '\u20ac', '\U0010ffff'):
-            code = ord(char)
-            if code < 0x80:
-                char_size = 1  # sizeof(Py_UCS1)
-                struct_size = ascii_struct_size
-            elif code < 0x100:
-                char_size = 1  # sizeof(Py_UCS1)
-                struct_size = compact_struct_size
-            elif code < 0x10000:
-                char_size = 2  # sizeof(Py_UCS2)
-                struct_size = compact_struct_size
-            else:
-                char_size = 4  # sizeof(Py_UCS4)
-                struct_size = compact_struct_size
-            # Note: sys.maxsize is half of the actual max allocation because of
-            # the signedness of Py_ssize_t. Strings of maxlen-1 should in principle
-            # be allocatable, given enough memory.
-            maxlen = ((sys.maxsize - struct_size) // char_size)
-            alloc = lambda: char * maxlen
-            with self.subTest(
-                char=char,
-                struct_size=struct_size,
-                char_size=char_size
-            ):
-                # self-check
-                self.assertEqual(
-                    sys.getsizeof(char * 42),
-                    struct_size + (char_size * (42 + 1))
-                )
-                self.assertRaises(MemoryError, alloc)
-                self.assertRaises(MemoryError, alloc)
-
-    def test_format_subclass(self):
-        class S(str):
-            def __str__(self):
-                return '__str__ overridden'
-        s = S('xxx')
-        self.assertEqual("%s" % s, '__str__ overridden')
-        self.assertEqual("{}".format(s), '__str__ overridden')
-
-    def test_subclass_add(self):
-        class S(str):
-            def __add__(self, o):
-                return "3"
-        self.assertEqual(S("4") + S("5"), "3")
-        class S(str):
-            def __iadd__(self, o):
-                return "3"
-        s = S("1")
-        s += "4"
-        self.assertEqual(s, "3")
-
-    def test_getnewargs(self):
-        text = 'abc'
-        args = text.__getnewargs__()
-        self.assertIsNot(args[0], text)
-        self.assertEqual(args[0], text)
-        self.assertEqual(len(args), 1)
-
-    def test_compare(self):
-        # Issue #17615
-        N = 10
-        ascii = 'a' * N
-        ascii2 = 'z' * N
-        latin = '\x80' * N
-        latin2 = '\xff' * N
-        bmp = '\u0100' * N
-        bmp2 = '\uffff' * N
-        astral = '\U00100000' * N
-        astral2 = '\U0010ffff' * N
-        strings = (
-            ascii, ascii2,
-            latin, latin2,
-            bmp, bmp2,
-            astral, astral2)
-        for text1, text2 in itertools.combinations(strings, 2):
-            equal = (text1 is text2)
-            self.assertEqual(text1 == text2, equal)
-            self.assertEqual(text1 != text2, not equal)
-
-            if equal:
-                self.assertTrue(text1 <= text2)
-                self.assertTrue(text1 >= text2)
-
-                # text1 is text2: duplicate strings to skip the "str1 == str2"
-                # optimization in unicode_compare_eq() and really compare
-                # character per character
-                copy1 = duplicate_string(text1)
-                copy2 = duplicate_string(text2)
-                self.assertIsNot(copy1, copy2)
-
-                self.assertTrue(copy1 == copy2)
-                self.assertFalse(copy1 != copy2)
-
-                self.assertTrue(copy1 <= copy2)
-                self.assertTrue(copy2 >= copy2)
-
-        self.assertTrue(ascii < ascii2)
-        self.assertTrue(ascii < latin)
-        self.assertTrue(ascii < bmp)
-        self.assertTrue(ascii < astral)
-        self.assertFalse(ascii >= ascii2)
-        self.assertFalse(ascii >= latin)
-        self.assertFalse(ascii >= bmp)
-        self.assertFalse(ascii >= astral)
-
-        self.assertFalse(latin < ascii)
-        self.assertTrue(latin < latin2)
-        self.assertTrue(latin < bmp)
-        self.assertTrue(latin < astral)
-        self.assertTrue(latin >= ascii)
-        self.assertFalse(latin >= latin2)
-        self.assertFalse(latin >= bmp)
-        self.assertFalse(latin >= astral)
-
-        self.assertFalse(bmp < ascii)
-        self.assertFalse(bmp < latin)
-        self.assertTrue(bmp < bmp2)
-        self.assertTrue(bmp < astral)
-        self.assertTrue(bmp >= ascii)
-        self.assertTrue(bmp >= latin)
-        self.assertFalse(bmp >= bmp2)
-        self.assertFalse(bmp >= astral)
-
-        self.assertFalse(astral < ascii)
-        self.assertFalse(astral < latin)
-        self.assertFalse(astral < bmp2)
-        self.assertTrue(astral < astral2)
-        self.assertTrue(astral >= ascii)
-        self.assertTrue(astral >= latin)
-        self.assertTrue(astral >= bmp2)
-        self.assertFalse(astral >= astral2)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_free_after_iterating(self):
-        support.check_free_after_iterating(self, iter, str)
-        support.check_free_after_iterating(self, reversed, str)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_check_encoding_errors(self):
-        # bpo-37388: str(bytes) and str.decode() must check encoding and errors
-        # arguments in dev mode
-        encodings = ('ascii', 'utf8', 'latin1')
-        invalid = 'Boom, Shaka Laka, Boom!'
-        code = textwrap.dedent(f'''
-            import sys
-            encodings = {encodings!r}
-
-            for data in (b'', b'short string'):
-                try:
-                    str(data, encoding={invalid!r})
-                except LookupError:
-                    pass
-                else:
-                    sys.exit(21)
-
-                try:
-                    str(data, errors={invalid!r})
-                except LookupError:
-                    pass
-                else:
-                    sys.exit(22)
-
-                for encoding in encodings:
-                    try:
-                        str(data, encoding, errors={invalid!r})
-                    except LookupError:
-                        pass
-                    else:
-                        sys.exit(22)
-
-            for data in ('', 'short string'):
-                try:
-                    data.encode(encoding={invalid!r})
-                except LookupError:
-                    pass
-                else:
-                    sys.exit(23)
-
-                try:
-                    data.encode(errors={invalid!r})
-                except LookupError:
-                    pass
-                else:
-                    sys.exit(24)
-
-                for encoding in encodings:
-                    try:
-                        data.encode(encoding, errors={invalid!r})
-                    except LookupError:
-                        pass
-                    else:
-                        sys.exit(24)
-
-            sys.exit(10)
-        ''')
-        proc = assert_python_failure('-X', 'dev', '-c', code)
-        self.assertEqual(proc.rc, 10, proc)
-
-
-class StringModuleTest(unittest.TestCase):
-    def test_formatter_parser(self):
-        def parse(format):
-            return list(_string.formatter_parser(format))
-
-        formatter = parse("prefix {2!s}xxx{0:^+10.3f}{obj.attr!s} {z[0]!s:10}")
-        self.assertEqual(formatter, [
-            ('prefix ', '2', '', 's'),
-            ('xxx', '0', '^+10.3f', None),
-            ('', 'obj.attr', '', 's'),
-            (' ', 'z[0]', '10', 's'),
-        ])
-
-        formatter = parse("prefix {} suffix")
-        self.assertEqual(formatter, [
-            ('prefix ', '', '', None),
-            (' suffix', None, None, None),
-        ])
-
-        formatter = parse("str")
-        self.assertEqual(formatter, [
-            ('str', None, None, None),
-        ])
-
-        formatter = parse("")
-        self.assertEqual(formatter, [])
-
-        formatter = parse("{0}")
-        self.assertEqual(formatter, [
-            ('', '0', '', None),
-        ])
-
-        self.assertRaises(TypeError, _string.formatter_parser, 1)
-
-    def test_formatter_field_name_split(self):
-        def split(name):
-            items = list(_string.formatter_field_name_split(name))
-            items[1] = list(items[1])
-            return items
-        self.assertEqual(split("obj"), ["obj", []])
-        self.assertEqual(split("obj.arg"), ["obj", [(True, 'arg')]])
-        self.assertEqual(split("obj[key]"), ["obj", [(False, 'key')]])
-        self.assertEqual(split("obj.arg[key1][key2]"), [
-            "obj",
-            [(True, 'arg'),
-             (False, 'key1'),
-             (False, 'key2'),
-            ]])
-        self.assertRaises(TypeError, _string.formatter_field_name_split, 1)
-
-    def test_str_subclass_attr(self):
-
-        name = StrSubclass("name")
-        name2 = StrSubclass("name2")
-        class Bag:
-            pass
-
-        o = Bag()
-        with self.assertRaises(AttributeError):
-            delattr(o, name)
-        setattr(o, name, 1)
-        self.assertEqual(o.name, 1)
-        o.name = 2
-        self.assertEqual(list(o.__dict__), [name])
-
-        with self.assertRaises(AttributeError):
-            delattr(o, name2)
-        with self.assertRaises(AttributeError):
-            del o.name2
-        setattr(o, name2, 3)
-        self.assertEqual(o.name2, 3)
-        o.name2 = 4
-        self.assertEqual(list(o.__dict__), [name, name2])
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_unicode_file.py b/Lib/test/test_unicode_file.py
index 80c22c6cdd..fe25bfe9f8 100644
--- a/Lib/test/test_unicode_file.py
+++ b/Lib/test/test_unicode_file.py
@@ -110,7 +110,7 @@ def _test_single(self, filename):
             os.unlink(filename)
         self.assertTrue(not os.path.exists(filename))
         # and again with os.open.
-        f = os.open(filename, os.O_CREAT)
+        f = os.open(filename, os.O_CREAT | os.O_WRONLY)
         os.close(f)
         try:
             self._do_single(filename)
diff --git a/Lib/test/test_unicode_file_functions.py b/Lib/test/test_unicode_file_functions.py
index 47619c8807..25c16e3a0b 100644
--- a/Lib/test/test_unicode_file_functions.py
+++ b/Lib/test/test_unicode_file_functions.py
@@ -5,7 +5,7 @@
 import unittest
 import warnings
 from unicodedata import normalize
-from test.support import os_helper
+from test.support import is_apple, os_helper
 from test import support
 
 
@@ -23,13 +23,13 @@
     '10_\u1fee\u1ffd',
     ]
 
-# Mac OS X decomposes Unicode names, using Normal Form D.
+# Apple platforms decompose Unicode names, using Normal Form D.
 # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
 # "However, most volume formats do not follow the exact specification for
 # these normal forms.  For example, HFS Plus uses a variant of Normal Form D
 # in which U+2000 through U+2FFF, U+F900 through U+FAFF, and U+2F800 through
 # U+2FAFF are not decomposed."
-if sys.platform != 'darwin':
+if not is_apple:
     filenames.extend([
         # Specific code points: NFC(fn), NFD(fn), NFKC(fn) and NFKD(fn) all different
         '11_\u0385\u03d3\u03d4',
@@ -119,11 +119,11 @@ def test_open(self):
             os.stat(name)
             self._apply_failure(os.listdir, name, self._listdir_failure)
 
-    # Skip the test on darwin, because darwin does normalize the filename to
+    # Skip the test on Apple platforms, because they don't normalize the filename to
     # NFD (a variant of Unicode NFD form). Normalize the filename to NFC, NFKC,
     # NFKD in Python is useless, because darwin will normalize it later and so
     # open(), os.stat(), etc. don't raise any exception.
-    @unittest.skipIf(sys.platform == 'darwin', 'irrelevant test on Mac OS X')
+    @unittest.skipIf(is_apple, 'irrelevant test on Apple platforms')
     @unittest.skipIf(
         support.is_emscripten or support.is_wasi,
         "test fails on Emscripten/WASI when host platform is macOS."
@@ -142,10 +142,10 @@ def test_normalize(self):
             self._apply_failure(os.remove, name)
             self._apply_failure(os.listdir, name)
 
-    # Skip the test on darwin, because darwin uses a normalization different
+    # Skip the test on Apple platforms, because they use a normalization different
     # than Python NFD normalization: filenames are different even if we use
     # Python NFD normalization.
-    @unittest.skipIf(sys.platform == 'darwin', 'irrelevant test on Mac OS X')
+    @unittest.skipIf(is_apple, 'irrelevant test on Apple platforms')
     def test_listdir(self):
         sf0 = set(self.files)
         with warnings.catch_warnings():
diff --git a/Lib/test/test_unicode_identifiers.py b/Lib/test/test_unicode_identifiers.py
index d7a0ece253..60cfdaabe8 100644
--- a/Lib/test/test_unicode_identifiers.py
+++ b/Lib/test/test_unicode_identifiers.py
@@ -21,7 +21,7 @@ def test_non_bmp_normalized(self):
     @unittest.expectedFailure
     def test_invalid(self):
         try:
-            from test import badsyntax_3131
+            from test.tokenizedata import badsyntax_3131
         except SyntaxError as err:
             self.assertEqual(str(err),
               "invalid character '€' (U+20AC) (badsyntax_3131.py, line 2)")
diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py
index 29da4a25a3..e14123aaa6 100644
--- a/Lib/test/test_unicodedata.py
+++ b/Lib/test/test_unicodedata.py
@@ -11,15 +11,20 @@
 import sys
 import unicodedata
 import unittest
-from test.support import (open_urlresource, requires_resource, script_helper,
-                          cpython_only, check_disallow_instantiation,
-                          ResourceDenied)
+from test.support import (
+    open_urlresource,
+    requires_resource,
+    script_helper,
+    cpython_only,
+    check_disallow_instantiation,
+    force_not_colorized,
+)
 
 
 class UnicodeMethodsTest(unittest.TestCase):
 
     # update this, if the database changes
-    expectedchecksum = '4739770dd4d0e5f1b1677accfc3552ed3c8ef326'
+    expectedchecksum = '63aa77dcb36b0e1df082ee2a6071caeda7f0955e'
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
@@ -74,7 +79,8 @@ 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 = '98d602e1f69d5c5bb8a5910c40bbbad4e18e8370'
+    expectedchecksum = '232affd2a50ec4bd69d2482aa0291385cbdefaba'
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     @requires_resource('cpu')
@@ -94,6 +100,8 @@ def test_function_checksum(self):
                 self.db.decomposition(char),
                 str(self.db.mirrored(char)),
                 str(self.db.combining(char)),
+                unicodedata.east_asian_width(char),
+                self.db.name(char, ""),
             ]
             h.update(''.join(data).encode("ascii"))
         result = h.hexdigest()
@@ -106,6 +114,28 @@ def test_name_inverse_lookup(self):
             if looked_name := self.db.name(char, None):
                 self.assertEqual(self.db.lookup(looked_name), char)
 
+    def test_no_names_in_pua(self):
+        puas = [*range(0xe000, 0xf8ff),
+                *range(0xf0000, 0xfffff),
+                *range(0x100000, 0x10ffff)]
+        for i in puas:
+            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 [
+            "LATIN SMLL LETR A",
+            "OPEN HANDS SIGHS",
+            "DREGS",
+            "HANDBUG",
+            "MODIFIER LETTER CYRILLIC SMALL QUESTION MARK",
+            "???",
+        ]:
+            self.assertRaises(KeyError, self.db.lookup, nonexistant)
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_digit(self):
@@ -245,6 +275,25 @@ def test_east_asian_width(self):
         self.assertEqual(eaw('\u2010'), 'A')
         self.assertEqual(eaw('\U00020000'), 'W')
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_east_asian_width_unassigned(self):
+        eaw = self.db.east_asian_width
+        # unassigned
+        for char in '\u0530\u0ecf\u10c6\u20fc\uaaca\U000107bd\U000115f2':
+            self.assertEqual(eaw(char), 'N')
+            self.assertIs(self.db.name(char, None), None)
+
+        # unassigned but reserved for CJK
+        for char in '\uFA6E\uFADA\U0002A6E0\U0002FA20\U0003134B\U0003FFFD':
+            self.assertEqual(eaw(char), 'W')
+            self.assertIs(self.db.name(char, None), None)
+
+        # private use areas
+        for char in '\uE000\uF800\U000F0000\U000FFFEE\U00100000\U0010FFF0':
+            self.assertEqual(eaw(char), 'A')
+            self.assertIs(self.db.name(char, None), None)
+
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
     def test_east_asian_width_9_0_changes(self):
@@ -260,6 +309,7 @@ def test_disallow_instantiation(self):
 
     # TODO: RUSTPYTHON
     @unittest.expectedFailure
+    @force_not_colorized
     def test_failed_import_during_compiling(self):
         # Issue 4367
         # Decoding \N escapes requires the unicodedata module. If it can't be
@@ -322,6 +372,7 @@ def test_ucd_510(self):
         self.assertTrue("\u1d79".upper()=='\ua77d')
         self.assertTrue(".".upper()=='.')
 
+    @requires_resource('cpu')
     def test_bug_5828(self):
         self.assertEqual("\u1d79".lower(), "\u1d79")
         # Only U+0000 should have U+0000 as its upper/lower/titlecase variant
@@ -363,7 +414,9 @@ def unistr(data):
         data = [int(x, 16) for x in data.split(" ")]
         return "".join([chr(x) for x in data])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     @requires_resource('network')
+    @requires_resource('cpu')
     def test_normalization(self):
         TESTDATAFILE = "NormalizationTest.txt"
         TESTDATAURL = f"http://www.pythontest.net/unicode/{unicodedata.unidata_version}/{TESTDATAFILE}"
diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
deleted file mode 100644
index 1079c7df2e..0000000000
--- a/Lib/test/test_unittest.py
+++ /dev/null
@@ -1,16 +0,0 @@
-import unittest.test
-
-from test import support
-
-
-def load_tests(*_):
-    # used by unittest
-    return unittest.test.suite()
-
-
-def tearDownModule():
-    support.reap_children()
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_unittest/__init__.py b/Lib/test/test_unittest/__init__.py
new file mode 100644
index 0000000000..bc502ef32d
--- /dev/null
+++ b/Lib/test/test_unittest/__init__.py
@@ -0,0 +1,6 @@
+import os.path
+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_unittest/__main__.py b/Lib/test/test_unittest/__main__.py
new file mode 100644
index 0000000000..40a23a297e
--- /dev/null
+++ b/Lib/test/test_unittest/__main__.py
@@ -0,0 +1,4 @@
+from . import load_tests
+import unittest
+
+unittest.main()
diff --git a/Lib/unittest/test/_test_warnings.py b/Lib/test/test_unittest/_test_warnings.py
similarity index 84%
rename from Lib/unittest/test/_test_warnings.py
rename to Lib/test/test_unittest/_test_warnings.py
index 5cbfb532ad..08b846ee47 100644
--- a/Lib/unittest/test/_test_warnings.py
+++ b/Lib/test/test_unittest/_test_warnings.py
@@ -18,17 +18,6 @@ def warnfun():
     warnings.warn('rw', RuntimeWarning)
 
 class TestWarnings(unittest.TestCase):
-    # unittest warnings will be printed at most once per type (max one message
-    # for the fail* methods, and one for the assert* methods)
-    def test_assert(self):
-        self.assertEquals(2+2, 4)
-        self.assertEquals(2*2, 4)
-        self.assertEquals(2**2, 4)
-
-    def test_fail(self):
-        self.failUnless(1)
-        self.failUnless(True)
-
     def test_other_unittest(self):
         self.assertAlmostEqual(2+2, 4)
         self.assertNotAlmostEqual(4+4, 2)
diff --git a/Lib/unittest/test/dummy.py b/Lib/test/test_unittest/dummy.py
similarity index 100%
rename from Lib/unittest/test/dummy.py
rename to Lib/test/test_unittest/dummy.py
diff --git a/Lib/test/test_unittest/support.py b/Lib/test/test_unittest/support.py
new file mode 100644
index 0000000000..8c97bf5c72
--- /dev/null
+++ b/Lib/test/test_unittest/support.py
@@ -0,0 +1,154 @@
+import unittest
+
+
+class TestEquality(object):
+    """Used as a mixin for TestCase"""
+
+    # Check for a valid __eq__ implementation
+    def test_eq(self):
+        for obj_1, obj_2 in self.eq_pairs:
+            self.assertEqual(obj_1, obj_2)
+            self.assertEqual(obj_2, obj_1)
+
+    # Check for a valid __ne__ implementation
+    def test_ne(self):
+        for obj_1, obj_2 in self.ne_pairs:
+            self.assertNotEqual(obj_1, obj_2)
+            self.assertNotEqual(obj_2, obj_1)
+
+class TestHashing(object):
+    """Used as a mixin for TestCase"""
+
+    # Check for a valid __hash__ implementation
+    def test_hash(self):
+        for obj_1, obj_2 in self.eq_pairs:
+            try:
+                if not hash(obj_1) == hash(obj_2):
+                    self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
+            except Exception as e:
+                self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
+
+        for obj_1, obj_2 in self.ne_pairs:
+            try:
+                if hash(obj_1) == hash(obj_2):
+                    self.fail("%s and %s hash equal, but shouldn't" %
+                              (obj_1, obj_2))
+            except Exception as e:
+                self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
+
+
+class _BaseLoggingResult(unittest.TestResult):
+    def __init__(self, log):
+        self._events = log
+        super().__init__()
+
+    def startTest(self, test):
+        self._events.append('startTest')
+        super().startTest(test)
+
+    def startTestRun(self):
+        self._events.append('startTestRun')
+        super().startTestRun()
+
+    def stopTest(self, test):
+        self._events.append('stopTest')
+        super().stopTest(test)
+
+    def stopTestRun(self):
+        self._events.append('stopTestRun')
+        super().stopTestRun()
+
+    def addFailure(self, *args):
+        self._events.append('addFailure')
+        super().addFailure(*args)
+
+    def addSuccess(self, *args):
+        self._events.append('addSuccess')
+        super().addSuccess(*args)
+
+    def addError(self, *args):
+        self._events.append('addError')
+        super().addError(*args)
+
+    def addSkip(self, *args):
+        self._events.append('addSkip')
+        super().addSkip(*args)
+
+    def addExpectedFailure(self, *args):
+        self._events.append('addExpectedFailure')
+        super().addExpectedFailure(*args)
+
+    def addUnexpectedSuccess(self, *args):
+        self._events.append('addUnexpectedSuccess')
+        super().addUnexpectedSuccess(*args)
+
+
+class LegacyLoggingResult(_BaseLoggingResult):
+    """
+    A legacy TestResult implementation, without an addSubTest method,
+    which records its method calls.
+    """
+
+    @property
+    def addSubTest(self):
+        raise AttributeError
+
+
+class LoggingResult(_BaseLoggingResult):
+    """
+    A TestResult implementation which records its method calls.
+    """
+
+    def addSubTest(self, test, subtest, err):
+        if err is None:
+            self._events.append('addSubTestSuccess')
+        else:
+            self._events.append('addSubTestFailure')
+        super().addSubTest(test, subtest, err)
+
+
+class ResultWithNoStartTestRunStopTestRun(object):
+    """An object honouring TestResult before startTestRun/stopTestRun."""
+
+    def __init__(self):
+        self.failures = []
+        self.errors = []
+        self.testsRun = 0
+        self.skipped = []
+        self.expectedFailures = []
+        self.unexpectedSuccesses = []
+        self.shouldStop = False
+
+    def startTest(self, test):
+        pass
+
+    def stopTest(self, test):
+        pass
+
+    def addError(self, test):
+        pass
+
+    def addFailure(self, test):
+        pass
+
+    def addSuccess(self, test):
+        pass
+
+    def wasSuccessful(self):
+        return True
+
+
+class BufferedWriter:
+    def __init__(self):
+        self.result = ''
+        self.buffer = ''
+
+    def write(self, arg):
+        self.buffer += arg
+
+    def flush(self):
+        self.result += self.buffer
+        self.buffer = ''
+
+    def getvalue(self):
+        return self.result
diff --git a/Lib/unittest/test/test_assertions.py b/Lib/test/test_unittest/test_assertions.py
similarity index 96%
rename from Lib/unittest/test/test_assertions.py
rename to Lib/test/test_unittest/test_assertions.py
index a0db3423b8..1dec947ea7 100644
--- a/Lib/unittest/test/test_assertions.py
+++ b/Lib/test/test_unittest/test_assertions.py
@@ -271,20 +271,11 @@ def testAssertDictEqual(self):
                              r"\+ \{'key': 'value'\}$",
                              r"\+ \{'key': 'value'\} : oops$"])
 
-    def testAssertDictContainsSubset(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-
-            self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
-                                ["^Missing: 'key'$", "^oops$",
-                                 "^Missing: 'key'$",
-                                 "^Missing: 'key' : oops$"])
-
     def testAssertMultiLineEqual(self):
         self.assertMessages('assertMultiLineEqual', ("", "foo"),
-                            [r"\+ foo$", "^oops$",
-                             r"\+ foo$",
-                             r"\+ foo : oops$"])
+                            [r"\+ foo\n$", "^oops$",
+                             r"\+ foo\n$",
+                             r"\+ foo\n : oops$"])
 
     def testAssertLess(self):
         self.assertMessages('assertLess', (2, 1),
@@ -395,6 +386,16 @@ def testAssertWarns(self):
                                '^UserWarning not triggered$',
                                '^UserWarning not triggered : oops$'])
 
+    def test_assertNotWarns(self):
+        def warn_future():
+            warnings.warn('xyz', FutureWarning, stacklevel=2)
+        self.assertMessagesCM('_assertNotWarns', (FutureWarning,),
+                              warn_future,
+                              ['^FutureWarning triggered$',
+                               '^oops$',
+                               '^FutureWarning triggered$',
+                               '^FutureWarning triggered : oops$'])
+
     def testAssertWarnsRegex(self):
         # test error not raised
         self.assertMessagesCM('assertWarnsRegex', (UserWarning, 'unused regex'),
diff --git a/Lib/unittest/test/test_async_case.py b/Lib/test/test_unittest/test_async_case.py
similarity index 96%
rename from Lib/unittest/test/test_async_case.py
rename to Lib/test/test_unittest/test_async_case.py
index 98ec4f3345..8f73f46637 100644
--- a/Lib/unittest/test/test_async_case.py
+++ b/Lib/test/test_unittest/test_async_case.py
@@ -37,11 +37,9 @@ async def __aenter__(self):
         pass
 
 
-# TODO: RUSTPYTHON; used by following test suite
-# VAR = contextvars.ContextVar('VAR', default=())
+VAR = contextvars.ContextVar('VAR', default=())
 
 
-@unittest.skip("TODO: RUSTPYTHON; requires sys.get_coroutine_origin_tracking_depth()")
 class TestAsyncCase(unittest.TestCase):
     maxDiff = None
 
@@ -50,6 +48,7 @@ def setUp(self):
         # starting a new event loop
         self.addCleanup(support.gc_collect)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_full_cycle(self):
         expected = ['setUp',
                     'asyncSetUp',
@@ -296,6 +295,7 @@ async def on_cleanup2(self):
         test.doCleanups()
         self.assertEqual(events, ['asyncSetUp', 'test', 'asyncTearDown', 'cleanup2', 'cleanup1'])
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_deprecation_of_return_val_from_test(self):
         # Issue 41322 - deprecate return of value that is not None from a test
         class Nothing:
@@ -486,5 +486,19 @@ async def test_demo1(self):
         result = test.run()
         self.assertTrue(result.wasSuccessful())
 
+    def test_loop_factory(self):
+        asyncio.set_event_loop_policy(None)
+
+        class TestCase1(unittest.IsolatedAsyncioTestCase):
+            loop_factory = asyncio.EventLoop
+
+            async def test_demo1(self):
+                pass
+
+        test = TestCase1('test_demo1')
+        result = test.run()
+        self.assertTrue(result.wasSuccessful())
+        self.assertIsNone(support.maybe_get_event_loop_policy())
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/unittest/test/test_break.py b/Lib/test/test_unittest/test_break.py
similarity index 98%
rename from Lib/unittest/test/test_break.py
rename to Lib/test/test_unittest/test_break.py
index 33cbdd2661..1da98af3e7 100644
--- a/Lib/unittest/test/test_break.py
+++ b/Lib/test/test_unittest/test_break.py
@@ -236,6 +236,7 @@ def __init__(self, catchbreak):
                 self.testRunner = FakeRunner
                 self.test = test
                 self.result = None
+                self.durations = None
 
         p = Program(False)
         p.runTests()
@@ -244,7 +245,8 @@ def __init__(self, catchbreak):
                                                      'verbosity': verbosity,
                                                      'failfast': failfast,
                                                      'tb_locals': False,
-                                                     'warnings': None})])
+                                                     'warnings': None,
+                                                     'durations': None})])
         self.assertEqual(FakeRunner.runArgs, [test])
         self.assertEqual(p.result, result)
 
@@ -259,7 +261,8 @@ def __init__(self, catchbreak):
                                                      'verbosity': verbosity,
                                                      'failfast': failfast,
                                                      'tb_locals': False,
-                                                     'warnings': None})])
+                                                     'warnings': None,
+                                                     'durations': None})])
         self.assertEqual(FakeRunner.runArgs, [test])
         self.assertEqual(p.result, result)
 
diff --git a/Lib/unittest/test/test_case.py b/Lib/test/test_unittest/test_case.py
similarity index 96%
rename from Lib/unittest/test/test_case.py
rename to Lib/test/test_unittest/test_case.py
index e2547f4777..82a442a04e 100644
--- a/Lib/unittest/test/test_case.py
+++ b/Lib/test/test_unittest/test_case.py
@@ -15,7 +15,7 @@
 
 import unittest
 
-from unittest.test.support import (
+from test.test_unittest.support import (
     TestEquality, TestHashing, LoggingResult, LegacyLoggingResult,
     ResultWithNoStartTestRunStopTestRun
 )
@@ -304,7 +304,8 @@ def defaultTestResult(self):
             def test(self):
                 pass
 
-        Foo('test').run()
+        with self.assertWarns(RuntimeWarning):
+            Foo('test').run()
 
     def test_deprecation_of_return_val_from_test(self):
         # Issue 41322 - deprecate return of value that is not None from a test
@@ -709,36 +710,6 @@ def testAssertIn(self):
         self.assertRaises(self.failureException, self.assertNotIn, 'cow',
                           animals)
 
-    def testAssertDictContainsSubset(self):
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-
-            self.assertDictContainsSubset({}, {})
-            self.assertDictContainsSubset({}, {'a': 1})
-            self.assertDictContainsSubset({'a': 1}, {'a': 1})
-            self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
-            self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
-
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({1: "one"}, {})
-
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'a': 2}, {'a': 1})
-
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'c': 1}, {'a': 1})
-
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
-
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
-
-            one = ''.join(chr(i) for i in range(255))
-            # this used to cause a UnicodeDecodeError constructing the failure msg
-            with self.assertRaises(self.failureException):
-                self.assertDictContainsSubset({'foo': one}, {'foo': '\uFFFD'})
-
     def testAssertEqual(self):
         equal_pairs = [
                 ((), ()),
@@ -1161,6 +1132,8 @@ def testAssertMultiLineEqual(self):
             # need to remove the first line of the error message
             error = str(e).split('\n', 1)[1]
             self.assertEqual(sample_text_error, error)
+        else:
+            self.fail(f'{self.failureException} not raised')
 
     def testAssertEqualSingleLine(self):
         sample_text = "laden swallows fly slowly"
@@ -1177,6 +1150,74 @@ def testAssertEqualSingleLine(self):
             # need to remove the first line of the error message
             error = str(e).split('\n', 1)[1]
             self.assertEqual(sample_text_error, error)
+        else:
+            self.fail(f'{self.failureException} not raised')
+
+    def testAssertEqualwithEmptyString(self):
+        '''Verify when there is an empty string involved, the diff output
+         does not treat the empty string as a single empty line. It should
+         instead be handled as a non-line.
+        '''
+        sample_text = ''
+        revised_sample_text = 'unladen swallows fly quickly'
+        sample_text_error = '''\
++ unladen swallows fly quickly
+'''
+        try:
+            self.assertEqual(sample_text, revised_sample_text)
+        except self.failureException as e:
+            # need to remove the first line of the error message
+            error = str(e).split('\n', 1)[1]
+            self.assertEqual(sample_text_error, error)
+        else:
+            self.fail(f'{self.failureException} not raised')
+
+    def testAssertEqualMultipleLinesMissingNewlineTerminator(self):
+        '''Verifying format of diff output from assertEqual involving strings
+         with multiple lines, but missing the terminating newline on both.
+        '''
+        sample_text = 'laden swallows\nfly sloely'
+        revised_sample_text = 'laden swallows\nfly slowly'
+        sample_text_error = '''\
+  laden swallows
+- fly sloely
+?        ^
++ fly slowly
+?        ^
+'''
+        try:
+            self.assertEqual(sample_text, revised_sample_text)
+        except self.failureException as e:
+            # need to remove the first line of the error message
+            error = str(e).split('\n', 1)[1]
+            self.assertEqual(sample_text_error, error)
+        else:
+            self.fail(f'{self.failureException} not raised')
+
+    def testAssertEqualMultipleLinesMismatchedNewlinesTerminators(self):
+        '''Verifying format of diff output from assertEqual involving strings
+         with multiple lines and mismatched newlines. The output should
+         include a - on it's own line to indicate the newline difference
+         between the two strings
+        '''
+        sample_text = 'laden swallows\nfly sloely\n'
+        revised_sample_text = 'laden swallows\nfly slowly'
+        sample_text_error = '''\
+  laden swallows
+- fly sloely
+?        ^
++ fly slowly
+?        ^
+-\x20
+'''
+        try:
+            self.assertEqual(sample_text, revised_sample_text)
+        except self.failureException as e:
+            # need to remove the first line of the error message
+            error = str(e).split('\n', 1)[1]
+            self.assertEqual(sample_text_error, error)
+        else:
+            self.fail(f'{self.failureException} not raised')
 
     def testEqualityBytesWarning(self):
         if sys.flags.bytes_warning:
@@ -1801,45 +1842,18 @@ def testAssertNoLogsYieldsNone(self):
             pass
         self.assertIsNone(value)
 
-    def testDeprecatedMethodNames(self):
-        """
-        Test that the deprecated methods raise a DeprecationWarning. See #9424.
-        """
-        old = (
-            (self.failIfEqual, (3, 5)),
-            (self.assertNotEquals, (3, 5)),
-            (self.failUnlessEqual, (3, 3)),
-            (self.assertEquals, (3, 3)),
-            (self.failUnlessAlmostEqual, (2.0, 2.0)),
-            (self.assertAlmostEquals, (2.0, 2.0)),
-            (self.failIfAlmostEqual, (3.0, 5.0)),
-            (self.assertNotAlmostEquals, (3.0, 5.0)),
-            (self.failUnless, (True,)),
-            (self.assert_, (True,)),
-            (self.failUnlessRaises, (TypeError, lambda _: 3.14 + 'spam')),
-            (self.failIf, (False,)),
-            (self.assertDictContainsSubset, (dict(a=1, b=2), dict(a=1, b=2, c=3))),
-            (self.assertRaisesRegexp, (KeyError, 'foo', lambda: {}['foo'])),
-            (self.assertRegexpMatches, ('bar', 'bar')),
-        )
-        for meth, args in old:
-            with self.assertWarns(DeprecationWarning):
-                meth(*args)
-
-    # disable this test for now. When the version where the fail* methods will
-    # be removed is decided, re-enable it and update the version
-    def _testDeprecatedFailMethods(self):
-        """Test that the deprecated fail* methods get removed in 3.x"""
-        if sys.version_info[:2] < (3, 3):
-            return
+    def testDeprecatedFailMethods(self):
+        """Test that the deprecated fail* methods get removed in 3.12"""
         deprecated_names = [
             'failIfEqual', 'failUnlessEqual', 'failUnlessAlmostEqual',
             'failIfAlmostEqual', 'failUnless', 'failUnlessRaises', 'failIf',
-            'assertDictContainsSubset',
+            'assertNotEquals', 'assertEquals', 'assertAlmostEquals',
+            'assertNotAlmostEquals', 'assert_', 'assertDictContainsSubset',
+            'assertRaisesRegexp', 'assertRegexpMatches'
         ]
         for deprecated_name in deprecated_names:
             with self.assertRaises(AttributeError):
-                getattr(self, deprecated_name)  # remove these in 3.x
+                getattr(self, deprecated_name)
 
     def testDeepcopy(self):
         # Issue: 5660
@@ -1956,8 +1970,6 @@ def testNoCycles(self):
             del case
             self.assertFalse(wr())
 
-    # TODO: RUSTPYTHON; destructors
-    @unittest.expectedFailure
     def test_no_exception_leak(self):
         # Issue #19880: TestCase.run() should not keep a reference
         # to the exception
diff --git a/Lib/unittest/test/test_discovery.py b/Lib/test/test_unittest/test_discovery.py
similarity index 96%
rename from Lib/unittest/test/test_discovery.py
rename to Lib/test/test_unittest/test_discovery.py
index 3b58786ec1..a44b18406c 100644
--- a/Lib/unittest/test/test_discovery.py
+++ b/Lib/test/test_unittest/test_discovery.py
@@ -6,11 +6,10 @@
 import pickle
 from test import support
 from test.support import import_helper
-import test.test_importlib.util
 
 import unittest
 import unittest.mock
-import unittest.test
+import test.test_unittest
 
 
 class TestableTestProgram(unittest.TestProgram):
@@ -407,10 +406,34 @@ def _find_tests(start_dir, pattern):
         top_level_dir = os.path.abspath('/foo/bar')
         start_dir = os.path.abspath('/foo/bar/baz')
         self.assertEqual(suite, "['tests']")
-        self.assertEqual(loader._top_level_dir, top_level_dir)
+        self.assertEqual(loader._top_level_dir, os.path.abspath('/foo'))
         self.assertEqual(_find_tests_args, [(start_dir, 'pattern')])
         self.assertIn(top_level_dir, sys.path)
 
+    def test_discover_should_not_persist_top_level_dir_between_calls(self):
+        original_isfile = os.path.isfile
+        original_isdir = os.path.isdir
+        original_sys_path = sys.path[:]
+        def restore():
+            os.path.isfile = original_isfile
+            os.path.isdir = original_isdir
+            sys.path[:] = original_sys_path
+        self.addCleanup(restore)
+
+        os.path.isfile = lambda path: True
+        os.path.isdir = lambda path: True
+        loader = unittest.TestLoader()
+        loader.suiteClass = str
+        dir = '/foo/bar'
+        top_level_dir = '/foo'
+
+        loader.discover(dir, top_level_dir=top_level_dir)
+        self.assertEqual(loader._top_level_dir, None)
+
+        loader._top_level_dir = dir2 = '/previous/dir'
+        loader.discover(dir, top_level_dir=top_level_dir)
+        self.assertEqual(loader._top_level_dir, dir2)
+
     def test_discover_start_dir_is_package_calls_package_load_tests(self):
         # This test verifies that the package load_tests in a package is indeed
         # invoked when the start_dir is a package (and not the top level).
@@ -789,7 +812,7 @@ def test_discovery_from_dotted_path(self):
         loader = unittest.TestLoader()
 
         tests = [self]
-        expectedPath = os.path.abspath(os.path.dirname(unittest.test.__file__))
+        expectedPath = os.path.abspath(os.path.dirname(test.test_unittest.__file__))
 
         self.wasRun = False
         def _find_tests(start_dir, pattern):
@@ -797,7 +820,7 @@ def _find_tests(start_dir, pattern):
             self.assertEqual(start_dir, expectedPath)
             return tests
         loader._find_tests = _find_tests
-        suite = loader.discover('unittest.test')
+        suite = loader.discover('test.test_unittest')
         self.assertTrue(self.wasRun)
         self.assertEqual(suite._tests, tests)
 
@@ -826,6 +849,8 @@ def restore():
                          'as dotted module names')
 
     def test_discovery_failed_discovery(self):
+        from test.test_importlib import util
+
         loader = unittest.TestLoader()
         package = types.ModuleType('package')
 
@@ -837,7 +862,7 @@ def _import(packagename, *args, **kwargs):
             # Since loader.discover() can modify sys.path, restore it when done.
             with import_helper.DirsOnSysPath():
                 # Make sure to remove 'package' from sys.modules when done.
-                with test.test_importlib.util.uncache('package'):
+                with util.uncache('package'):
                     with self.assertRaises(TypeError) as cm:
                         loader.discover('package')
                     self.assertEqual(str(cm.exception),
diff --git a/Lib/unittest/test/test_functiontestcase.py b/Lib/test/test_unittest/test_functiontestcase.py
similarity index 99%
rename from Lib/unittest/test/test_functiontestcase.py
rename to Lib/test/test_unittest/test_functiontestcase.py
index 4971729880..2ebed9564a 100644
--- a/Lib/unittest/test/test_functiontestcase.py
+++ b/Lib/test/test_unittest/test_functiontestcase.py
@@ -1,6 +1,6 @@
 import unittest
 
-from unittest.test.support import LoggingResult
+from test.test_unittest.support import LoggingResult
 
 
 class Test_FunctionTestCase(unittest.TestCase):
diff --git a/Lib/unittest/test/test_loader.py b/Lib/test/test_unittest/test_loader.py
similarity index 88%
rename from Lib/unittest/test/test_loader.py
rename to Lib/test/test_unittest/test_loader.py
index de2268cda9..83dd25ca54 100644
--- a/Lib/unittest/test/test_loader.py
+++ b/Lib/test/test_unittest/test_loader.py
@@ -1,29 +1,9 @@
 import functools
 import sys
 import types
-import warnings
 
 import unittest
 
-# Decorator used in the deprecation tests to reset the warning registry for
-# test isolation and reproducibility.
-def warningregistry(func):
-    def wrapper(*args, **kws):
-        missing = []
-        saved = getattr(warnings, '__warningregistry__', missing).copy()
-        try:
-            return func(*args, **kws)
-        finally:
-            if saved is missing:
-                try:
-                    del warnings.__warningregistry__
-                except AttributeError:
-                    pass
-            else:
-                warnings.__warningregistry__ = saved
-    return wrapper
-
-
 class Test_TestLoader(unittest.TestCase):
 
     ### Basic object tests
@@ -102,6 +82,22 @@ def runTest(self):
         self.assertIsInstance(suite, loader.suiteClass)
         self.assertEqual(list(suite), [Foo('runTest')])
 
+    # "Do not load any tests from `TestCase` class itself."
+    def test_loadTestsFromTestCase__from_TestCase(self):
+        loader = unittest.TestLoader()
+
+        suite = loader.loadTestsFromTestCase(unittest.TestCase)
+        self.assertIsInstance(suite, loader.suiteClass)
+        self.assertEqual(list(suite), [])
+
+    # "Do not load any tests from `FunctionTestCase` class."
+    def test_loadTestsFromTestCase__from_FunctionTestCase(self):
+        loader = unittest.TestLoader()
+
+        suite = loader.loadTestsFromTestCase(unittest.FunctionTestCase)
+        self.assertIsInstance(suite, loader.suiteClass)
+        self.assertEqual(list(suite), [])
+
     ################################################################
     ### /Tests for TestLoader.loadTestsFromTestCase
 
@@ -123,6 +119,19 @@ def test(self):
         expected = [loader.suiteClass([MyTestCase('test')])]
         self.assertEqual(list(suite), expected)
 
+    # "This test ensures that internal `TestCase` subclasses are not loaded"
+    def test_loadTestsFromModule__TestCase_subclass_internals(self):
+        # See https://github.com/python/cpython/issues/84867
+        m = types.ModuleType('m')
+        # Simulate imported names:
+        m.TestCase = unittest.TestCase
+        m.FunctionTestCase = unittest.FunctionTestCase
+
+        loader = unittest.TestLoader()
+        suite = loader.loadTestsFromModule(m)
+        self.assertIsInstance(suite, loader.suiteClass)
+        self.assertEqual(list(suite), [])
+
     # "This method searches `module` for classes derived from TestCase"
     #
     # What happens if no tests are found (no TestCase instances)?
@@ -174,9 +183,8 @@ class NotAModule(object):
         self.assertEqual(list(suite), reference)
 
 
-    # Check that loadTestsFromModule honors (or not) a module
+    # Check that loadTestsFromModule honors a module
     # with a load_tests function.
-    @warningregistry
     def test_loadTestsFromModule__load_tests(self):
         m = types.ModuleType('m')
         class MyTestCase(unittest.TestCase):
@@ -195,126 +203,13 @@ def load_tests(loader, tests, pattern):
         suite = loader.loadTestsFromModule(m)
         self.assertIsInstance(suite, unittest.TestSuite)
         self.assertEqual(load_tests_args, [loader, suite, None])
-        # With Python 3.5, the undocumented and unofficial use_load_tests is
-        # ignored (and deprecated).
-        load_tests_args = []
-        with warnings.catch_warnings(record=False):
-            warnings.simplefilter('ignore')
-            suite = loader.loadTestsFromModule(m, use_load_tests=False)
-        self.assertEqual(load_tests_args, [loader, suite, None])
 
-    @warningregistry
-    def test_loadTestsFromModule__use_load_tests_deprecated_positional(self):
-        m = types.ModuleType('m')
-        class MyTestCase(unittest.TestCase):
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        load_tests_args = []
-        def load_tests(loader, tests, pattern):
-            self.assertIsInstance(tests, unittest.TestSuite)
-            load_tests_args.extend((loader, tests, pattern))
-            return tests
-        m.load_tests = load_tests
-        # The method still works.
-        loader = unittest.TestLoader()
-        # use_load_tests=True as a positional argument.
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always')
-            suite = loader.loadTestsFromModule(m, False)
-        self.assertIsInstance(suite, unittest.TestSuite)
-        # load_tests was still called because use_load_tests is deprecated
-        # and ignored.
-        self.assertEqual(load_tests_args, [loader, suite, None])
-        # We got a warning.
-        self.assertIs(w[-1].category, DeprecationWarning)
-        self.assertEqual(str(w[-1].message),
-                             'use_load_tests is deprecated and ignored')
-
-    @warningregistry
-    def test_loadTestsFromModule__use_load_tests_deprecated_keyword(self):
-        m = types.ModuleType('m')
-        class MyTestCase(unittest.TestCase):
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        load_tests_args = []
-        def load_tests(loader, tests, pattern):
-            self.assertIsInstance(tests, unittest.TestSuite)
-            load_tests_args.extend((loader, tests, pattern))
-            return tests
-        m.load_tests = load_tests
-        # The method still works.
-        loader = unittest.TestLoader()
-        with warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always')
-            suite = loader.loadTestsFromModule(m, use_load_tests=False)
-        self.assertIsInstance(suite, unittest.TestSuite)
-        # load_tests was still called because use_load_tests is deprecated
-        # and ignored.
-        self.assertEqual(load_tests_args, [loader, suite, None])
-        # We got a warning.
-        self.assertIs(w[-1].category, DeprecationWarning)
-        self.assertEqual(str(w[-1].message),
-                             'use_load_tests is deprecated and ignored')
-
-    @warningregistry
-    def test_loadTestsFromModule__too_many_positional_args(self):
-        m = types.ModuleType('m')
-        class MyTestCase(unittest.TestCase):
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        load_tests_args = []
-        def load_tests(loader, tests, pattern):
-            self.assertIsInstance(tests, unittest.TestSuite)
-            load_tests_args.extend((loader, tests, pattern))
-            return tests
-        m.load_tests = load_tests
-        loader = unittest.TestLoader()
-        with self.assertRaises(TypeError) as cm, \
-             warnings.catch_warnings(record=True) as w:
-            warnings.simplefilter('always')
-            loader.loadTestsFromModule(m, False, 'testme.*')
-        # We still got the deprecation warning.
-        self.assertIs(w[-1].category, DeprecationWarning)
-        self.assertEqual(str(w[-1].message),
-                                'use_load_tests is deprecated and ignored')
-        # We also got a TypeError for too many positional arguments.
-        self.assertEqual(type(cm.exception), TypeError)
-        self.assertEqual(
-            str(cm.exception),
-            'loadTestsFromModule() takes 1 positional argument but 3 were given')
-
-    @warningregistry
-    def test_loadTestsFromModule__use_load_tests_other_bad_keyword(self):
-        m = types.ModuleType('m')
-        class MyTestCase(unittest.TestCase):
-            def test(self):
-                pass
-        m.testcase_1 = MyTestCase
-
-        load_tests_args = []
-        def load_tests(loader, tests, pattern):
-            self.assertIsInstance(tests, unittest.TestSuite)
-            load_tests_args.extend((loader, tests, pattern))
-            return tests
-        m.load_tests = load_tests
-        loader = unittest.TestLoader()
-        with warnings.catch_warnings():
-            warnings.simplefilter('ignore')
-            with self.assertRaises(TypeError) as cm:
-                loader.loadTestsFromModule(
-                    m, use_load_tests=False, very_bad=True, worse=False)
-        self.assertEqual(type(cm.exception), TypeError)
-        # The error message names the first bad argument alphabetically,
-        # however use_load_tests (which sorts first) is ignored.
-        self.assertEqual(
-            str(cm.exception),
-            "loadTestsFromModule() got an unexpected keyword argument 'very_bad'")
+        # In Python 3.12, the undocumented and unofficial use_load_tests has
+        # been removed.
+        with self.assertRaises(TypeError):
+            loader.loadTestsFromModule(m, False)
+        with self.assertRaises(TypeError):
+            loader.loadTestsFromModule(m, use_load_tests=False)
 
     def test_loadTestsFromModule__pattern(self):
         m = types.ModuleType('m')
@@ -716,7 +611,7 @@ def test_loadTestsFromName__module_not_loaded(self):
         # We're going to try to load this module as a side-effect, so it
         # better not be loaded before we try.
         #
-        module_name = 'unittest.test.dummy'
+        module_name = 'test.test_unittest.dummy'
         sys.modules.pop(module_name, None)
 
         loader = unittest.TestLoader()
@@ -844,7 +739,7 @@ def test_loadTestsFromNames__unknown_attr_name(self):
         loader = unittest.TestLoader()
 
         suite = loader.loadTestsFromNames(
-            ['unittest.loader.sdasfasfasdf', 'unittest.test.dummy'])
+            ['unittest.loader.sdasfasfasdf', 'test.test_unittest.dummy'])
         error, test = self.check_deferred_error(loader, list(suite)[0])
         expected = "module 'unittest.loader' has no attribute 'sdasfasfasdf'"
         self.assertIn(
@@ -1141,7 +1036,7 @@ def test_loadTestsFromNames__module_not_loaded(self):
         # We're going to try to load this module as a side-effect, so it
         # better not be loaded before we try.
         #
-        module_name = 'unittest.test.dummy'
+        module_name = 'test.test_unittest.dummy'
         sys.modules.pop(module_name, None)
 
         loader = unittest.TestLoader()
@@ -1604,39 +1499,6 @@ def test(self): pass
     def reverse_three_way_cmp(a, b):
         return unittest.util.three_way_cmp(b, a)
 
-    def test_getTestCaseNames(self):
-        with self.assertWarns(DeprecationWarning) as w:
-            tests = unittest.getTestCaseNames(self.MyTestCase,
-                prefix='check', sortUsing=self.reverse_three_way_cmp,
-                testNamePatterns=None)
-        self.assertEqual(w.filename, __file__)
-        self.assertEqual(tests, ['check_2', 'check_1'])
-
-    def test_makeSuite(self):
-        with self.assertWarns(DeprecationWarning) as w:
-            suite = unittest.makeSuite(self.MyTestCase,
-                    prefix='check', sortUsing=self.reverse_three_way_cmp,
-                    suiteClass=self.MyTestSuite)
-        self.assertEqual(w.filename, __file__)
-        self.assertIsInstance(suite, self.MyTestSuite)
-        expected = self.MyTestSuite([self.MyTestCase('check_2'),
-                                     self.MyTestCase('check_1')])
-        self.assertEqual(suite, expected)
-
-    def test_findTestCases(self):
-        m = types.ModuleType('m')
-        m.testcase_1 = self.MyTestCase
-
-        with self.assertWarns(DeprecationWarning) as w:
-            suite = unittest.findTestCases(m,
-                prefix='check', sortUsing=self.reverse_three_way_cmp,
-                suiteClass=self.MyTestSuite)
-        self.assertEqual(w.filename, __file__)
-        self.assertIsInstance(suite, self.MyTestSuite)
-        expected = [self.MyTestSuite([self.MyTestCase('check_2'),
-                                      self.MyTestCase('check_1')])]
-        self.assertEqual(list(suite), expected)
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/unittest/test/test_program.py b/Lib/test/test_unittest/test_program.py
similarity index 77%
rename from Lib/unittest/test/test_program.py
rename to Lib/test/test_unittest/test_program.py
index 26a8550af8..2e3a750847 100644
--- a/Lib/unittest/test/test_program.py
+++ b/Lib/test/test_unittest/test_program.py
@@ -1,21 +1,20 @@
-import io
-
 import os
 import sys
 import subprocess
 from test import support
 import unittest
-import unittest.test
-from unittest.test.test_result import BufferedWriter
+import test.test_unittest
+from test.test_unittest.test_result import BufferedWriter
 
 
+@support.force_not_colorized_test_class
 class Test_TestProgram(unittest.TestCase):
 
     def test_discovery_from_dotted_path(self):
         loader = unittest.TestLoader()
 
         tests = [self]
-        expectedPath = os.path.abspath(os.path.dirname(unittest.test.__file__))
+        expectedPath = os.path.abspath(os.path.dirname(test.test_unittest.__file__))
 
         self.wasRun = False
         def _find_tests(start_dir, pattern):
@@ -23,7 +22,7 @@ def _find_tests(start_dir, pattern):
             self.assertEqual(start_dir, expectedPath)
             return tests
         loader._find_tests = _find_tests
-        suite = loader.discover('unittest.test')
+        suite = loader.discover('test.test_unittest')
         self.assertTrue(self.wasRun)
         self.assertEqual(suite._tests, tests)
 
@@ -73,15 +72,30 @@ def testExpectedFailure(self):
         def testUnexpectedSuccess(self):
             pass
 
-    class FooBarLoader(unittest.TestLoader):
-        """Test loader that returns a suite containing FooBar."""
+    class Empty(unittest.TestCase):
+        pass
+
+    class SetUpClassFailure(unittest.TestCase):
+        @classmethod
+        def setUpClass(cls):
+            super().setUpClass()
+            raise Exception
+        def testPass(self):
+            pass
+
+    class TestLoader(unittest.TestLoader):
+        """Test loader that returns a suite containing the supplied testcase."""
+
+        def __init__(self, testcase):
+            self.testcase = testcase
+
         def loadTestsFromModule(self, module):
             return self.suiteClass(
-                [self.loadTestsFromTestCase(Test_TestProgram.FooBar)])
+                [self.loadTestsFromTestCase(self.testcase)])
 
         def loadTestsFromNames(self, names, module):
             return self.suiteClass(
-                [self.loadTestsFromTestCase(Test_TestProgram.FooBar)])
+                [self.loadTestsFromTestCase(self.testcase)])
 
     def test_defaultTest_with_string(self):
         class FakeRunner(object):
@@ -93,10 +107,10 @@ def run(self, test):
         sys.argv = ['faketest']
         runner = FakeRunner()
         program = unittest.TestProgram(testRunner=runner, exit=False,
-                                       defaultTest='unittest.test',
-                                       testLoader=self.FooBarLoader())
+                                       defaultTest='test.test_unittest',
+                                       testLoader=self.TestLoader(self.FooBar))
         sys.argv = old_argv
-        self.assertEqual(('unittest.test',), program.testNames)
+        self.assertEqual(('test.test_unittest',), program.testNames)
 
     def test_defaultTest_with_iterable(self):
         class FakeRunner(object):
@@ -109,10 +123,10 @@ def run(self, test):
         runner = FakeRunner()
         program = unittest.TestProgram(
             testRunner=runner, exit=False,
-            defaultTest=['unittest.test', 'unittest.test2'],
-            testLoader=self.FooBarLoader())
+            defaultTest=['test.test_unittest', 'test.test_unittest2'],
+            testLoader=self.TestLoader(self.FooBar))
         sys.argv = old_argv
-        self.assertEqual(['unittest.test', 'unittest.test2'],
+        self.assertEqual(['test.test_unittest', 'test.test_unittest2'],
                           program.testNames)
 
     def test_NonExit(self):
@@ -120,7 +134,7 @@ def test_NonExit(self):
         program = unittest.main(exit=False,
                                 argv=["foobar"],
                                 testRunner=unittest.TextTestRunner(stream=stream),
-                                testLoader=self.FooBarLoader())
+                                testLoader=self.TestLoader(self.FooBar))
         self.assertTrue(hasattr(program, 'result'))
         out = stream.getvalue()
         self.assertIn('\nFAIL: testFail ', out)
@@ -132,13 +146,13 @@ def test_NonExit(self):
 
     def test_Exit(self):
         stream = BufferedWriter()
-        self.assertRaises(
-            SystemExit,
-            unittest.main,
-            argv=["foobar"],
-            testRunner=unittest.TextTestRunner(stream=stream),
-            exit=True,
-            testLoader=self.FooBarLoader())
+        with self.assertRaises(SystemExit) as cm:
+            unittest.main(
+                argv=["foobar"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                exit=True,
+                testLoader=self.TestLoader(self.FooBar))
+        self.assertEqual(cm.exception.code, 1)
         out = stream.getvalue()
         self.assertIn('\nFAIL: testFail ', out)
         self.assertIn('\nERROR: testError ', out)
@@ -149,12 +163,11 @@ def test_Exit(self):
 
     def test_ExitAsDefault(self):
         stream = BufferedWriter()
-        self.assertRaises(
-            SystemExit,
-            unittest.main,
-            argv=["foobar"],
-            testRunner=unittest.TextTestRunner(stream=stream),
-            testLoader=self.FooBarLoader())
+        with self.assertRaises(SystemExit):
+            unittest.main(
+                argv=["foobar"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                testLoader=self.TestLoader(self.FooBar))
         out = stream.getvalue()
         self.assertIn('\nFAIL: testFail ', out)
         self.assertIn('\nERROR: testError ', out)
@@ -163,6 +176,41 @@ def test_ExitAsDefault(self):
                     'expected failures=1, unexpected successes=1)\n')
         self.assertTrue(out.endswith(expected))
 
+    def test_ExitSkippedSuite(self):
+        stream = BufferedWriter()
+        with self.assertRaises(SystemExit) as cm:
+            unittest.main(
+                argv=["foobar", "-k", "testSkipped"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                testLoader=self.TestLoader(self.FooBar))
+        self.assertEqual(cm.exception.code, 0)
+        out = stream.getvalue()
+        expected = '\n\nOK (skipped=1)\n'
+        self.assertTrue(out.endswith(expected))
+
+    def test_ExitEmptySuite(self):
+        stream = BufferedWriter()
+        with self.assertRaises(SystemExit) as cm:
+            unittest.main(
+                argv=["empty"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                testLoader=self.TestLoader(self.Empty))
+        self.assertEqual(cm.exception.code, 5)
+        out = stream.getvalue()
+        self.assertIn('\nNO TESTS RAN\n', out)
+
+    def test_ExitSetUpClassFailureSuite(self):
+        stream = BufferedWriter()
+        with self.assertRaises(SystemExit) as cm:
+            unittest.main(
+                argv=["setup_class_failure"],
+                testRunner=unittest.TextTestRunner(stream=stream),
+                testLoader=self.TestLoader(self.SetUpClassFailure))
+        self.assertEqual(cm.exception.code, 1)
+        out = stream.getvalue()
+        self.assertIn("ERROR: setUpClass", out)
+        self.assertIn("SetUpClassFailure", out)
+
 
 class InitialisableProgram(unittest.TestProgram):
     exit = False
@@ -286,6 +334,7 @@ def testRunTestsRunnerClass(self):
         program.failfast = 'failfast'
         program.buffer = 'buffer'
         program.warnings = 'warnings'
+        program.durations = '5'
 
         program.runTests()
 
@@ -293,7 +342,8 @@ def testRunTestsRunnerClass(self):
                                                 'failfast': 'failfast',
                                                 'buffer': 'buffer',
                                                 'tb_locals': False,
-                                                'warnings': 'warnings'})
+                                                'warnings': 'warnings',
+                                                'durations': '5'})
         self.assertEqual(FakeRunner.test, 'test')
         self.assertIs(program.result, RESULT)
 
@@ -322,7 +372,8 @@ def test_locals(self):
                                                'failfast': False,
                                                'tb_locals': True,
                                                'verbosity': 1,
-                                               'warnings': None})
+                                               'warnings': None,
+                                               'durations': None})
 
     def testRunTestsOldRunnerClass(self):
         program = self.program
@@ -335,6 +386,7 @@ def testRunTestsOldRunnerClass(self):
         program.failfast = 'failfast'
         program.buffer = 'buffer'
         program.test = 'test'
+        program.durations = '0'
 
         program.runTests()
 
@@ -358,6 +410,7 @@ def fakeInstallHandler():
 
         program = self.program
         program.catchbreak = True
+        program.durations = None
 
         program.testRunner = FakeRunner
 
@@ -427,8 +480,8 @@ def _join(name):
 
     def testParseArgsAbsolutePathsThatCannotBeConverted(self):
         program = self.program
-        # even on Windows '/...' is considered absolute by os.path.abspath
-        argv = ['progname', '/foo/bar/baz.py', '/green/red.py']
+        drive = os.path.splitdrive(os.getcwd())[0]
+        argv = ['progname', f'{drive}/foo/bar/baz.py', f'{drive}/green/red.py']
         self._patch_isfile(argv)
 
         program.createTests = lambda: None
@@ -452,6 +505,8 @@ def testParseArgsSelectedTestNames(self):
 
         self.assertEqual(program.testNamePatterns, ['*foo*', '*bar*', '*pat*'])
 
+    @unittest.expectedFailureIf(sys.platform != 'win32', 'TODO: RUSTPYTHON')
+    
     def testSelectedTestNamesFunctionalTest(self):
         def run_unittest(args):
             # Use -E to ignore PYTHONSAFEPATH env var
@@ -463,14 +518,14 @@ def run_unittest(args):
             return stderr.decode()
 
         t = '_test_warnings'
-        self.assertIn('Ran 7 tests', run_unittest([t]))
-        self.assertIn('Ran 7 tests', run_unittest(['-k', 'TestWarnings', t]))
-        self.assertIn('Ran 7 tests', run_unittest(['discover', '-p', '*_test*', '-k', 'TestWarnings']))
-        self.assertIn('Ran 2 tests', run_unittest(['-k', 'f', t]))
-        self.assertIn('Ran 7 tests', run_unittest(['-k', 't', t]))
-        self.assertIn('Ran 3 tests', run_unittest(['-k', '*t', t]))
-        self.assertIn('Ran 7 tests', run_unittest(['-k', '*test_warnings.*Warning*', t]))
-        self.assertIn('Ran 1 test', run_unittest(['-k', '*test_warnings.*warning*', t]))
+        self.assertIn('Ran 5 tests', run_unittest([t]))
+        self.assertIn('Ran 5 tests', run_unittest(['-k', 'TestWarnings', t]))
+        self.assertIn('Ran 5 tests', run_unittest(['discover', '-p', '*_test*', '-k', 'TestWarnings']))
+        self.assertIn('Ran 1 test ', run_unittest(['-k', 'f', t]))
+        self.assertIn('Ran 5 tests', run_unittest(['-k', 't', t]))
+        self.assertIn('Ran 2 tests', run_unittest(['-k', '*t', t]))
+        self.assertIn('Ran 5 tests', run_unittest(['-k', '*test_warnings.*Warning*', t]))
+        self.assertIn('Ran 1 test ', run_unittest(['-k', '*test_warnings.*warning*', t]))
 
 
 if __name__ == '__main__':
diff --git a/Lib/unittest/test/test_result.py b/Lib/test/test_unittest/test_result.py
similarity index 98%
rename from Lib/unittest/test/test_result.py
rename to Lib/test/test_unittest/test_result.py
index 9320b0a44b..4d552d54e9 100644
--- a/Lib/unittest/test/test_result.py
+++ b/Lib/test/test_unittest/test_result.py
@@ -1,12 +1,12 @@
 import io
 import sys
 import textwrap
-
-from test.support import warnings_helper, captured_stdout, captured_stderr
-
 import traceback
 import unittest
 from unittest.util import strclass
+from test.support import warnings_helper
+from test.support import captured_stdout, force_not_colorized_test_class
+from test.test_unittest.support import BufferedWriter
 
 
 class MockTraceback(object):
@@ -33,22 +33,7 @@ def bad_cleanup2():
     raise ValueError('bad cleanup2')
 
 
-class BufferedWriter:
-    def __init__(self):
-        self.result = ''
-        self.buffer = ''
-
-    def write(self, arg):
-        self.buffer += arg
-
-    def flush(self):
-        self.result += self.buffer
-        self.buffer = ''
-
-    def getvalue(self):
-        return self.result
-
-
+@force_not_colorized_test_class
 class Test_TestResult(unittest.TestCase):
     # Note: there are not separate tests for TestResult.wasSuccessful(),
     # TestResult.errors, TestResult.failures, TestResult.testsRun or
@@ -465,12 +450,14 @@ def testFailFastSetByRunner(self):
         stream = BufferedWriter()
         runner = unittest.TextTestRunner(stream=stream, failfast=True)
         def test(result):
+            result.testsRun += 1
             self.assertTrue(result.failfast)
         result = runner.run(test)
         stream.flush()
         self.assertTrue(stream.getvalue().endswith('\n\nOK\n'))
 
 
+@force_not_colorized_test_class
 class Test_TextTestResult(unittest.TestCase):
     maxDiff = None
 
@@ -505,8 +492,8 @@ def testGetSubTestDescriptionWithoutDocstringAndParams(self):
                     '(' + __name__ + '.Test_TextTestResult.testGetSubTestDescriptionWithoutDocstringAndParams) '
                     '(<subtest>)')
 
-    def testGetSubTestDescriptionForFalsyValues(self):
-        expected = 'testGetSubTestDescriptionForFalsyValues (%s.Test_TextTestResult.testGetSubTestDescriptionForFalsyValues) [%s]'
+    def testGetSubTestDescriptionForFalseValues(self):
+        expected = 'testGetSubTestDescriptionForFalseValues (%s.Test_TextTestResult.testGetSubTestDescriptionForFalseValues) [%s]'
         result = unittest.TextTestResult(None, True, 1)
         for arg in [0, None, []]:
             with self.subTest(arg):
@@ -772,6 +759,7 @@ def testFoo(self):
         runner.run(Test('testFoo'))
 
 
+@force_not_colorized_test_class
 class TestOutputBuffering(unittest.TestCase):
 
     def setUp(self):
diff --git a/Lib/unittest/test/test_runner.py b/Lib/test/test_unittest/test_runner.py
similarity index 89%
rename from Lib/unittest/test/test_runner.py
rename to Lib/test/test_unittest/test_runner.py
index 50d9ed2fd3..4d3cfd60b8 100644
--- a/Lib/unittest/test/test_runner.py
+++ b/Lib/test/test_unittest/test_runner.py
@@ -8,8 +8,11 @@
 import unittest
 from unittest.case import _Outcome
 
-from unittest.test.support import (LoggingResult,
-                                   ResultWithNoStartTestRunStopTestRun)
+from test.test_unittest.support import (
+    BufferedWriter,
+    LoggingResult,
+    ResultWithNoStartTestRunStopTestRun,
+)
 
 
 def resultFactory(*_):
@@ -21,6 +24,13 @@ def getRunner():
                                    stream=io.StringIO())
 
 
+class CustomError(Exception):
+    pass
+
+# For test output compat:
+CustomErrorRepr = f"{__name__ + '.' if __name__ != '__main__' else ''}CustomError"
+
+
 def runTests(*cases):
     suite = unittest.TestSuite()
     for case in cases:
@@ -43,7 +53,7 @@ def cleanup(ordering, blowUp=False):
         ordering.append('cleanup_good')
     else:
         ordering.append('cleanup_exc')
-        raise Exception('CleanUpExc')
+        raise CustomError('CleanUpExc')
 
 
 class TestCM:
@@ -96,6 +106,7 @@ def cleanup2(*args, **kwargs):
         self.assertTrue(test.doCleanups())
         self.assertEqual(cleanups, [(2, (), {}), (1, (1, 2, 3), dict(four='hello', five='goodbye'))])
 
+    @support.force_not_colorized
     def testCleanUpWithErrors(self):
         class TestableTest(unittest.TestCase):
             def testNothing(self):
@@ -105,8 +116,8 @@ def testNothing(self):
         result = unittest.TestResult()
         outcome = test._outcome = _Outcome(result=result)
 
-        CleanUpExc = Exception('foo')
-        exc2 = Exception('bar')
+        CleanUpExc = CustomError('foo')
+        exc2 = CustomError('bar')
         def cleanup1():
             raise CleanUpExc
 
@@ -122,10 +133,10 @@ def cleanup2():
         (_, msg2), (_, msg1) = result.errors
         self.assertIn('in cleanup1', msg1)
         self.assertIn('raise CleanUpExc', msg1)
-        self.assertIn('Exception: foo', msg1)
+        self.assertIn(f'{CustomErrorRepr}: foo', msg1)
         self.assertIn('in cleanup2', msg2)
         self.assertIn('raise exc2', msg2)
-        self.assertIn('Exception: bar', msg2)
+        self.assertIn(f'{CustomErrorRepr}: bar', msg2)
 
     def testCleanupInRun(self):
         blowUp = False
@@ -136,7 +147,7 @@ def setUp(self):
                 ordering.append('setUp')
                 test.addCleanup(cleanup2)
                 if blowUp:
-                    raise Exception('foo')
+                    raise CustomError('foo')
 
             def testNothing(self):
                 ordering.append('test')
@@ -239,6 +250,7 @@ def testNothing(self):
         self.assertEqual(test._cleanups, [])
 
 
+@support.force_not_colorized_test_class
 class TestClassCleanup(unittest.TestCase):
     def test_addClassCleanUp(self):
         class TestableTest(unittest.TestCase):
@@ -277,7 +289,7 @@ def setUpClass(cls):
                 ordering.append('setUpClass')
                 cls.addClassCleanup(cleanup, ordering)
                 if blowUp:
-                    raise Exception()
+                    raise CustomError()
             def testNothing(self):
                 ordering.append('test')
             @classmethod
@@ -303,7 +315,7 @@ def setUpClass(cls):
                 ordering.append('setUpClass')
                 cls.addClassCleanup(cleanup, ordering)
                 if blowUp:
-                    raise Exception()
+                    raise CustomError()
             def testNothing(self):
                 ordering.append('test')
             @classmethod
@@ -343,7 +355,7 @@ def tearDownClass(cls):
         ordering = []
         blowUp = True
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'CleanUpExc')
         self.assertEqual(ordering,
@@ -363,10 +375,10 @@ def testNothing(self):
             @classmethod
             def tearDownClass(cls):
                 ordering.append('tearDownClass')
-                raise Exception('TearDownClassExc')
+                raise CustomError('TearDownClassExc')
 
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'TearDownClassExc')
         self.assertEqual(ordering, ['setUpClass', 'test', 'tearDownClass'])
@@ -376,7 +388,7 @@ def tearDownClass(cls):
         ordering = []
         blowUp = True
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'TearDownClassExc')
         self.assertEqual(ordering, ['setUpClass', 'test', 'tearDownClass'])
@@ -389,16 +401,22 @@ def testNothing(self):
                 pass
 
         def cleanup1():
-            raise Exception('cleanup1')
+            raise CustomError('cleanup1')
 
         def cleanup2():
-            raise Exception('cleanup2')
+            raise CustomError('cleanup2')
 
         TestableTest.addClassCleanup(cleanup1)
         TestableTest.addClassCleanup(cleanup2)
-        with self.assertRaises(Exception) as e:
-            TestableTest.doClassCleanups()
-            self.assertEqual(e, 'cleanup1')
+        TestableTest.doClassCleanups()
+
+        self.assertEqual(len(TestableTest.tearDown_exceptions), 2)
+
+        e1, e2 = TestableTest.tearDown_exceptions
+        self.assertIsInstance(e1[1], CustomError)
+        self.assertEqual(str(e1[1]), 'cleanup2')
+        self.assertIsInstance(e2[1], CustomError)
+        self.assertEqual(str(e2[1]), 'cleanup1')
 
     def test_with_errors_addCleanUp(self):
         ordering = []
@@ -418,7 +436,7 @@ def tearDownClass(cls):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'setUp', 'cleanup_exc',
                           'tearDownClass', 'cleanup_good'])
@@ -441,7 +459,7 @@ def tearDownClass(cls):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'setUp', 'test', 'cleanup_good',
                           'tearDownClass', 'cleanup_exc'])
@@ -457,11 +475,11 @@ def setUpClass(cls):
                 ordering.append('setUpClass')
                 cls.addClassCleanup(cleanup, ordering, blowUp=True)
                 if class_blow_up:
-                    raise Exception('ClassExc')
+                    raise CustomError('ClassExc')
             def setUp(self):
                 ordering.append('setUp')
                 if method_blow_up:
-                    raise Exception('MethodExc')
+                    raise CustomError('MethodExc')
             def testNothing(self):
                 ordering.append('test')
             @classmethod
@@ -470,7 +488,7 @@ def tearDownClass(cls):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'setUp', 'test',
                           'tearDownClass', 'cleanup_exc'])
@@ -480,9 +498,9 @@ def tearDownClass(cls):
         method_blow_up = False
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: ClassExc')
+                         f'{CustomErrorRepr}: ClassExc')
         self.assertEqual(result.errors[1][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'cleanup_exc'])
 
@@ -491,9 +509,9 @@ def tearDownClass(cls):
         method_blow_up = True
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: MethodExc')
+                         f'{CustomErrorRepr}: MethodExc')
         self.assertEqual(result.errors[1][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'setUp', 'tearDownClass',
                           'cleanup_exc'])
@@ -510,11 +528,11 @@ def testNothing(self):
             @classmethod
             def tearDownClass(cls):
                 ordering.append('tearDownClass')
-                raise Exception('TearDownExc')
+                raise CustomError('TearDownExc')
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: TearDownExc')
+                         f'{CustomErrorRepr}: TearDownExc')
         self.assertEqual(ordering,
                          ['setUpClass', 'test', 'tearDownClass', 'cleanup_good'])
 
@@ -574,7 +592,18 @@ def test(self):
                 'inner setup', 'inner test', 'inner cleanup',
                 'end outer test', 'outer cleanup'])
 
+    def test_run_empty_suite_error_message(self):
+        class EmptyTest(unittest.TestCase):
+            pass
 
+        suite = unittest.defaultTestLoader.loadTestsFromTestCase(EmptyTest)
+        runner = getRunner()
+        runner.run(suite)
+
+        self.assertIn("\nNO TESTS RAN\n", runner.stream.getvalue())
+
+
+@support.force_not_colorized_test_class
 class TestModuleCleanUp(unittest.TestCase):
     def test_add_and_do_ModuleCleanup(self):
         module_cleanups = []
@@ -607,7 +636,7 @@ def module_cleanup_good(*args, **kwargs):
             module_cleanups.append((3, args, kwargs))
 
         def module_cleanup_bad(*args, **kwargs):
-            raise Exception('CleanUpExc')
+            raise CustomError('CleanUpExc')
 
         class Module(object):
             unittest.addModuleCleanup(module_cleanup_good, 1, 2, 3,
@@ -617,7 +646,7 @@ class Module(object):
                          [(module_cleanup_good, (1, 2, 3),
                            dict(four='hello', five='goodbye')),
                           (module_cleanup_bad, (), {})])
-        with self.assertRaises(Exception) as e:
+        with self.assertRaises(CustomError) as e:
             unittest.case.doModuleCleanups()
         self.assertEqual(str(e.exception), 'CleanUpExc')
         self.assertEqual(unittest.case._module_cleanups, [])
@@ -646,7 +675,7 @@ def setUpModule():
                 ordering.append('setUpModule')
                 unittest.addModuleCleanup(cleanup, ordering)
                 if blowUp:
-                    raise Exception('setUpModule Exc')
+                    raise CustomError('setUpModule Exc')
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule')
@@ -666,7 +695,7 @@ def tearDownClass(cls):
         result = runTests(TestableTest)
         self.assertEqual(ordering, ['setUpModule', 'cleanup_good'])
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: setUpModule Exc')
+                         f'{CustomErrorRepr}: setUpModule Exc')
 
         ordering = []
         blowUp = False
@@ -686,7 +715,7 @@ def setUpModule():
                 ordering.append('setUpModule')
                 unittest.addModuleCleanup(cleanup, ordering)
                 if blowUp:
-                    raise Exception()
+                    raise CustomError()
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule')
@@ -697,7 +726,7 @@ def setUpModule():
                 ordering.append('setUpModule2')
                 unittest.addModuleCleanup(cleanup, ordering)
                 if blowUp2:
-                    raise Exception()
+                    raise CustomError()
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule2')
@@ -786,7 +815,7 @@ def setUpModule():
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule')
-                raise Exception('CleanUpExc')
+                raise CustomError('CleanUpExc')
 
         class TestableTest(unittest.TestCase):
             @classmethod
@@ -802,7 +831,7 @@ def tearDownClass(cls):
         sys.modules['Module'] = Module
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
                                     'tearDownClass', 'tearDownModule',
                                     'cleanup_good'])
@@ -842,7 +871,7 @@ def tearDownClass(cls):
         ordering = []
         blowUp = True
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'CleanUpExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
@@ -860,7 +889,7 @@ def setUpModule():
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule')
-                raise Exception('TearDownModuleExc')
+                raise CustomError('TearDownModuleExc')
 
         class TestableTest(unittest.TestCase):
             @classmethod
@@ -875,7 +904,7 @@ def tearDownClass(cls):
         TestableTest.__module__ = 'Module'
         sys.modules['Module'] = Module
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'TearDownModuleExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
@@ -886,7 +915,7 @@ def tearDownClass(cls):
         ordering = []
         blowUp = True
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestableTest)
-        with self.assertRaises(Exception) as cm:
+        with self.assertRaises(CustomError) as cm:
             suite.debug()
         self.assertEqual(str(cm.exception), 'TearDownModuleExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'test',
@@ -965,7 +994,7 @@ def tearDownClass(cls):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpModule', 'setUpClass', 'test', 'tearDownClass',
                           'cleanup_exc', 'tearDownModule', 'cleanup_good'])
@@ -995,7 +1024,7 @@ def tearDown(self):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpModule', 'setUp', 'test', 'tearDown',
                           'cleanup_exc', 'tearDownModule', 'cleanup_good'])
@@ -1011,7 +1040,7 @@ def setUpModule():
                 ordering.append('setUpModule')
                 unittest.addModuleCleanup(cleanup, ordering, blowUp=True)
                 if module_blow_up:
-                    raise Exception('ModuleExc')
+                    raise CustomError('ModuleExc')
             @staticmethod
             def tearDownModule():
                 ordering.append('tearDownModule')
@@ -1021,11 +1050,11 @@ class TestableTest(unittest.TestCase):
             def setUpClass(cls):
                 ordering.append('setUpClass')
                 if class_blow_up:
-                    raise Exception('ClassExc')
+                    raise CustomError('ClassExc')
             def setUp(self):
                 ordering.append('setUp')
                 if method_blow_up:
-                    raise Exception('MethodExc')
+                    raise CustomError('MethodExc')
             def testNothing(self):
                 ordering.append('test')
             @classmethod
@@ -1037,7 +1066,7 @@ def tearDownClass(cls):
 
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering,
                          ['setUpModule', 'setUpClass', 'setUp', 'test',
                           'tearDownClass', 'tearDownModule',
@@ -1049,9 +1078,9 @@ def tearDownClass(cls):
         method_blow_up = False
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: ModuleExc')
+                         f'{CustomErrorRepr}: ModuleExc')
         self.assertEqual(result.errors[1][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering, ['setUpModule', 'cleanup_exc'])
 
         ordering = []
@@ -1060,9 +1089,9 @@ def tearDownClass(cls):
         method_blow_up = False
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: ClassExc')
+                         f'{CustomErrorRepr}: ClassExc')
         self.assertEqual(result.errors[1][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass',
                                     'tearDownModule', 'cleanup_exc'])
 
@@ -1072,9 +1101,9 @@ def tearDownClass(cls):
         method_blow_up = True
         result = runTests(TestableTest)
         self.assertEqual(result.errors[0][1].splitlines()[-1],
-                         'Exception: MethodExc')
+                         f'{CustomErrorRepr}: MethodExc')
         self.assertEqual(result.errors[1][1].splitlines()[-1],
-                         'Exception: CleanUpExc')
+                         f'{CustomErrorRepr}: CleanUpExc')
         self.assertEqual(ordering, ['setUpModule', 'setUpClass', 'setUp',
                                     'tearDownClass', 'tearDownModule',
                                     'cleanup_exc'])
@@ -1176,6 +1205,7 @@ def test_init(self):
         self.assertTrue(runner.descriptions)
         self.assertEqual(runner.resultclass, unittest.TextTestResult)
         self.assertFalse(runner.tb_locals)
+        self.assertIsNone(runner.durations)
 
     def test_multiple_inheritance(self):
         class AResult(unittest.TestResult):
@@ -1267,8 +1297,6 @@ def _makeResult(self):
         expected = ['startTestRun', 'stopTestRun']
         self.assertEqual(events, expected)
 
-    # TODO: RUSTPYTHON; fix pickling with io objects
-    @unittest.expectedFailure
     def test_pickle_unpickle(self):
         # Issue #7197: a TextTestRunner should be (un)pickleable. This is
         # required by test_multiprocessing under Windows (in verbose mode).
@@ -1293,6 +1321,7 @@ def MockResultClass(*args):
         expectedresult = (runner.stream, DESCRIPTIONS, VERBOSITY)
         self.assertEqual(runner._makeResult(), expectedresult)
 
+    @support.force_not_colorized
     @support.requires_subprocess()
     def test_warnings(self):
         """
@@ -1305,8 +1334,6 @@ def get_parse_out_err(p):
             return [b.splitlines() for b in p.communicate()]
         opts = dict(stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                     cwd=os.path.dirname(__file__))
-        ae_msg = b'Please use assertEqual instead.'
-        at_msg = b'Please use assertTrue instead.'
 
         # no args -> all the warnings are printed, unittest warnings only once
         p = subprocess.Popen([sys.executable, '-E', '_test_warnings.py'], **opts)
@@ -1314,11 +1341,11 @@ def get_parse_out_err(p):
             out, err = get_parse_out_err(p)
         self.assertIn(b'OK', err)
         # check that the total number of warnings in the output is correct
-        self.assertEqual(len(out), 12)
+        self.assertEqual(len(out), 10)
         # check that the numbers of the different kind of warnings is correct
         for msg in [b'dw', b'iw', b'uw']:
             self.assertEqual(out.count(msg), 3)
-        for msg in [ae_msg, at_msg, b'rw']:
+        for msg in [b'rw']:
             self.assertEqual(out.count(msg), 1)
 
         args_list = (
@@ -1345,11 +1372,9 @@ def get_parse_out_err(p):
         with p:
             out, err = get_parse_out_err(p)
         self.assertIn(b'OK', err)
-        self.assertEqual(len(out), 14)
+        self.assertEqual(len(out), 12)
         for msg in [b'dw', b'iw', b'uw', b'rw']:
             self.assertEqual(out.count(msg), 3)
-        for msg in [ae_msg, at_msg]:
-            self.assertEqual(out.count(msg), 1)
 
     def testStdErrLookedUpAtInstantiationTime(self):
         # see issue 10786
@@ -1368,6 +1393,65 @@ def testSpecifiedStreamUsed(self):
         runner = unittest.TextTestRunner(f)
         self.assertTrue(runner.stream.stream is f)
 
+    def test_durations(self):
+        def run(test, *, expect_durations=True):
+            stream = BufferedWriter()
+            runner = unittest.TextTestRunner(stream=stream, durations=5, verbosity=2)
+            result = runner.run(test)
+            self.assertEqual(result.durations, 5)
+            stream.flush()
+            text = stream.getvalue()
+            regex = r"\n\d+.\d\d\ds"
+            if expect_durations:
+                self.assertEqual(len(result.collectedDurations), 1)
+                self.assertIn('Slowest test durations', text)
+                self.assertRegex(text, regex)
+            else:
+                self.assertEqual(len(result.collectedDurations), 0)
+                self.assertNotIn('Slowest test durations', text)
+                self.assertNotRegex(text, regex)
+
+        # success
+        class Foo(unittest.TestCase):
+            def test_1(self):
+                pass
+
+        run(Foo('test_1'), expect_durations=True)
+
+        # failure
+        class Foo(unittest.TestCase):
+            def test_1(self):
+                self.assertEqual(0, 1)
+
+        run(Foo('test_1'), expect_durations=True)
+
+        # error
+        class Foo(unittest.TestCase):
+            def test_1(self):
+                1 / 0
+
+        run(Foo('test_1'), expect_durations=True)
+
+
+        # error in setUp and tearDown
+        class Foo(unittest.TestCase):
+            def setUp(self):
+                1 / 0
+            tearDown = setUp
+            def test_1(self):
+                pass
+
+        run(Foo('test_1'), expect_durations=True)
+
+        # skip (expect no durations)
+        class Foo(unittest.TestCase):
+            @unittest.skip("reason")
+            def test_1(self):
+                pass
+
+        run(Foo('test_1'), expect_durations=False)
+
+
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/unittest/test/test_setups.py b/Lib/test/test_unittest/test_setups.py
similarity index 100%
rename from Lib/unittest/test/test_setups.py
rename to Lib/test/test_unittest/test_setups.py
diff --git a/Lib/unittest/test/test_skipping.py b/Lib/test/test_unittest/test_skipping.py
similarity index 99%
rename from Lib/unittest/test/test_skipping.py
rename to Lib/test/test_unittest/test_skipping.py
index 64ceeae37e..f146dcac18 100644
--- a/Lib/unittest/test/test_skipping.py
+++ b/Lib/test/test_unittest/test_skipping.py
@@ -1,6 +1,6 @@
 import unittest
 
-from unittest.test.support import LoggingResult
+from test.test_unittest.support import LoggingResult
 
 
 class Test_TestSkipping(unittest.TestCase):
diff --git a/Lib/unittest/test/test_suite.py b/Lib/test/test_unittest/test_suite.py
similarity index 99%
rename from Lib/unittest/test/test_suite.py
rename to Lib/test/test_unittest/test_suite.py
index 0551a16996..ca52ee9d9c 100644
--- a/Lib/unittest/test/test_suite.py
+++ b/Lib/test/test_unittest/test_suite.py
@@ -3,7 +3,7 @@
 import gc
 import sys
 import weakref
-from unittest.test.support import LoggingResult, TestEquality
+from test.test_unittest.support import LoggingResult, TestEquality
 
 
 ### Support code for Test_TestSuite
diff --git a/Lib/test/test_unittest/test_util.py b/Lib/test/test_unittest/test_util.py
new file mode 100644
index 0000000000..d590a33393
--- /dev/null
+++ b/Lib/test/test_unittest/test_util.py
@@ -0,0 +1,33 @@
+import unittest
+from unittest.util import safe_repr, sorted_list_difference, unorderable_list_difference
+
+
+class TestUtil(unittest.TestCase):
+    def test_safe_repr(self):
+        class RaisingRepr:
+            def __repr__(self):
+                raise ValueError("Invalid repr()")
+
+        class LongRepr:
+            def __repr__(self):
+                return 'x' * 100
+
+        safe_repr(RaisingRepr())
+        self.assertEqual(safe_repr('foo'), "'foo'")
+        self.assertEqual(safe_repr(LongRepr(), short=True), 'x'*80 + ' [truncated]...')
+
+    def test_sorted_list_difference(self):
+        self.assertEqual(sorted_list_difference([], []), ([], []))
+        self.assertEqual(sorted_list_difference([1, 2], [2, 3]), ([1], [3]))
+        self.assertEqual(sorted_list_difference([1, 2], [1, 3]), ([2], [3]))
+        self.assertEqual(sorted_list_difference([1, 1, 1], [1, 2, 3]), ([], [2, 3]))
+        self.assertEqual(sorted_list_difference([4], [1, 2, 3, 4]), ([], [1, 2, 3]))
+        self.assertEqual(sorted_list_difference([1, 1], [2]), ([1], [2]))
+        self.assertEqual(sorted_list_difference([2], [1, 1]), ([2], [1]))
+        self.assertEqual(sorted_list_difference([1, 2], [1, 1]), ([2], []))
+
+    def test_unorderable_list_difference(self):
+        self.assertEqual(unorderable_list_difference([], []), ([], []))
+        self.assertEqual(unorderable_list_difference([1, 2], []), ([2, 1], []))
+        self.assertEqual(unorderable_list_difference([], [1, 2]), ([], [1, 2]))
+        self.assertEqual(unorderable_list_difference([1, 2], [1, 3]), ([2], [3]))
diff --git a/Lib/test/test_unittest/testmock/__init__.py b/Lib/test/test_unittest/testmock/__init__.py
new file mode 100644
index 0000000000..bc502ef32d
--- /dev/null
+++ b/Lib/test/test_unittest/testmock/__init__.py
@@ -0,0 +1,6 @@
+import os.path
+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_unittest/testmock/__main__.py b/Lib/test/test_unittest/testmock/__main__.py
new file mode 100644
index 0000000000..1e3068b0dd
--- /dev/null
+++ b/Lib/test/test_unittest/testmock/__main__.py
@@ -0,0 +1,18 @@
+import os
+import unittest
+
+
+def load_tests(loader, standard_tests, pattern):
+    # top level directory cached on loader instance
+    this_dir = os.path.dirname(__file__)
+    pattern = pattern or "test*.py"
+    # We are inside test.test_unittest.testmock, so the top-level is three notches up
+    top_level_dir = os.path.dirname(os.path.dirname(os.path.dirname(this_dir)))
+    package_tests = loader.discover(start_dir=this_dir, pattern=pattern,
+                                    top_level_dir=top_level_dir)
+    standard_tests.addTests(package_tests)
+    return standard_tests
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_unittest/testmock/support.py b/Lib/test/test_unittest/testmock/support.py
new file mode 100644
index 0000000000..6c535b7944
--- /dev/null
+++ b/Lib/test/test_unittest/testmock/support.py
@@ -0,0 +1,27 @@
+target = {'foo': 'FOO'}
+
+
+def is_instance(obj, klass):
+    """Version of is_instance that doesn't access __class__"""
+    return issubclass(type(obj), klass)
+
+
+class SomeClass(object):
+    class_attribute = None
+
+    def wibble(self): pass
+
+
+class X(object):
+    pass
+
+# A standin for weurkzeug.local.LocalProxy - issue 119600
+def _inaccessible(*args, **kwargs):
+    raise AttributeError
+
+
+class OpaqueProxy:
+    __getattribute__ = _inaccessible
+
+
+g = OpaqueProxy()
diff --git a/Lib/unittest/test/testmock/testasync.py b/Lib/test/test_unittest/testmock/testasync.py
similarity index 94%
rename from Lib/unittest/test/testmock/testasync.py
rename to Lib/test/test_unittest/testmock/testasync.py
index 90ea72d82b..81d9c9c55f 100644
--- a/Lib/unittest/test/testmock/testasync.py
+++ b/Lib/test/test_unittest/testmock/testasync.py
@@ -218,10 +218,6 @@ def test_create_autospec_instance(self):
         with self.assertRaises(RuntimeError):
             create_autospec(async_func, instance=True)
 
-    @unittest.skip('Broken test from https://bugs.python.org/issue37251')
-    def test_create_autospec_awaitable_class(self):
-        self.assertIsInstance(create_autospec(AwaitableClass), AsyncMock)
-
     def test_create_autospec(self):
         spec = create_autospec(async_func_args)
         awaitable = spec(1, 2, c=3)
@@ -236,7 +232,9 @@ async def main():
         run(main())
 
         self.assertTrue(iscoroutinefunction(spec))
+        self.assertTrue(inspect.iscoroutinefunction(spec))
         self.assertTrue(asyncio.iscoroutine(awaitable))
+        self.assertTrue(inspect.iscoroutine(awaitable))
         self.assertEqual(spec.await_count, 1)
         self.assertEqual(spec.await_args, call(1, 2, c=3))
         self.assertEqual(spec.await_args_list, [call(1, 2, c=3)])
@@ -248,6 +246,25 @@ async def main():
         with self.assertRaises(AssertionError):
             spec.assert_any_await(e=1)
 
+    def test_autospec_checks_signature(self):
+        spec = create_autospec(async_func_args)
+        # signature is not checked when called
+        awaitable = spec()
+        self.assertListEqual(spec.mock_calls, [])
+
+        async def main():
+            await awaitable
+
+        # but it is checked when awaited
+        with self.assertRaises(TypeError):
+            run(main())
+
+        # _checksig_ raises before running or awaiting the mock
+        self.assertListEqual(spec.mock_calls, [])
+        self.assertEqual(spec.await_count, 0)
+        self.assertIsNone(spec.await_args)
+        self.assertEqual(spec.await_args_list, [])
+        spec.assert_not_awaited()
 
     def test_patch_with_autospec(self):
 
@@ -257,7 +274,9 @@ async def test_async():
                 self.assertIsInstance(mock_method.mock, AsyncMock)
 
                 self.assertTrue(iscoroutinefunction(mock_method))
+                self.assertTrue(inspect.iscoroutinefunction(mock_method))
                 self.assertTrue(asyncio.iscoroutine(awaitable))
+                self.assertTrue(inspect.iscoroutine(awaitable))
                 self.assertTrue(inspect.isawaitable(awaitable))
 
                 # Verify the default values during mock setup
@@ -308,6 +327,20 @@ def test_spec_normal_methods_on_class_with_mock_seal(self):
         with self.assertRaises(AttributeError):
             mock.async_method
 
+    def test_spec_async_attributes_instance(self):
+        async_instance = AsyncClass()
+        async_instance.async_func_attr = async_func
+        async_instance.later_async_func_attr = normal_func
+
+        mock_async_instance = Mock(spec_set=async_instance)
+
+        async_instance.later_async_func_attr = async_func
+
+        self.assertIsInstance(mock_async_instance.async_func_attr, AsyncMock)
+        # only the shape of the spec at the time of mock construction matters
+        self.assertNotIsInstance(mock_async_instance.later_async_func_attr, AsyncMock)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_spec_mock_type_kw(self):
         def inner_test(mock_type):
             async_mock = mock_type(spec=async_func)
@@ -322,6 +355,7 @@ def inner_test(mock_type):
             with self.subTest(f"test spec kwarg with {mock_type}"):
                 inner_test(mock_type)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_spec_mock_type_positional(self):
         def inner_test(mock_type):
             async_mock = mock_type(async_func)
@@ -427,9 +461,10 @@ async def addition(self, var): pass
         self.assertEqual(output, 10)
 
     async def test_add_side_effect_exception(self):
+        class CustomError(Exception): pass
         async def addition(var): pass
-        mock = AsyncMock(addition, side_effect=Exception('err'))
-        with self.assertRaises(Exception):
+        mock = AsyncMock(addition, side_effect=CustomError('side-effect'))
+        with self.assertRaisesRegex(CustomError, 'side-effect'):
             await mock(5)
 
     async def test_add_side_effect_coroutine(self):
@@ -699,8 +734,6 @@ def __aiter__(self): pass
 
         async def __anext__(self): pass
 
-    # TODO: RUSTPYTHON; async for
-    """
     def test_aiter_set_return_value(self):
         mock_iter = AsyncMock(name="tester")
         mock_iter.__aiter__.return_value = [1, 2, 3]
@@ -708,7 +741,6 @@ async def main():
             return [i async for i in mock_iter]
         result = run(main())
         self.assertEqual(result, [1, 2, 3])
-    """
 
     def test_mock_aiter_and_anext_asyncmock(self):
         def inner_test(mock_type):
@@ -726,8 +758,7 @@ def inner_test(mock_type):
             with self.subTest(f"test aiter and anext corourtine with {mock_type}"):
                 inner_test(mock_type)
 
-    # TODO: RUSTPYTHON; async for
-    """
+
     def test_mock_async_for(self):
         async def iterate(iterator):
             accumulator = []
@@ -761,7 +792,7 @@ def test_set_return_value_iter(mock_type):
 
             with self.subTest(f"set return_value iterator with {mock_type}"):
                 test_set_return_value_iter(mock_type)
-    """
+
 
 class AsyncMockAssert(unittest.TestCase):
     def setUp(self):
@@ -773,6 +804,7 @@ async def _runnable_test(self, *args, **kwargs):
     async def _await_coroutine(self, coroutine):
         return await coroutine
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_but_not_awaited(self):
         mock = AsyncMock(AsyncClass)
         with assertNeverAwaited(self):
@@ -813,6 +845,7 @@ def test_assert_called_and_awaited_at_same_time(self):
         self.mock.assert_called_once()
         self.mock.assert_awaited_once()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_twice_and_awaited_once(self):
         mock = AsyncMock(AsyncClass)
         coroutine = mock.async_method()
@@ -827,6 +860,7 @@ def test_assert_called_twice_and_awaited_once(self):
         mock.async_method.assert_awaited()
         mock.async_method.assert_awaited_once()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_called_once_and_awaited_twice(self):
         mock = AsyncMock(AsyncClass)
         coroutine = mock.async_method()
@@ -851,6 +885,7 @@ def test_assert_awaited_but_not_called(self):
         with self.assertRaises(AssertionError):
             self.mock.assert_called()
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_calls_not_awaits(self):
         kalls = [call('foo')]
         with assertNeverAwaited(self):
@@ -859,6 +894,7 @@ def test_assert_has_calls_not_awaits(self):
         with self.assertRaises(AssertionError):
             self.mock.assert_has_awaits(kalls)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_mock_calls_on_async_mock_no_spec(self):
         with assertNeverAwaited(self):
             self.mock()
@@ -872,6 +908,7 @@ def test_assert_has_mock_calls_on_async_mock_no_spec(self):
         mock_kalls = ([call(), call('foo'), call('baz')])
         self.assertEqual(self.mock.mock_calls, mock_kalls)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_assert_has_mock_calls_on_async_mock_with_spec(self):
         a_class_mock = AsyncMock(AsyncClass)
         with assertNeverAwaited(self):
@@ -887,6 +924,7 @@ def test_assert_has_mock_calls_on_async_mock_with_spec(self):
         self.assertEqual(a_class_mock.async_method.mock_calls, method_kalls)
         self.assertEqual(a_class_mock.mock_calls, mock_kalls)
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_async_method_calls_recorded(self):
         with assertNeverAwaited(self):
             self.mock.something(3, fish=None)
@@ -902,6 +940,7 @@ def test_async_method_calls_recorded(self):
                          [("something", (6,), {'cake': sentinel.Cake})],
                          "method calls not recorded correctly")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_async_arg_lists(self):
         def assert_attrs(mock):
             names = ('call_args_list', 'method_calls', 'mock_calls')
diff --git a/Lib/unittest/test/testmock/testcallable.py b/Lib/test/test_unittest/testmock/testcallable.py
similarity index 98%
rename from Lib/unittest/test/testmock/testcallable.py
rename to Lib/test/test_unittest/testmock/testcallable.py
index 5eadc00704..ca88511f63 100644
--- a/Lib/unittest/test/testmock/testcallable.py
+++ b/Lib/test/test_unittest/testmock/testcallable.py
@@ -3,7 +3,7 @@
 # http://www.voidspace.org.uk/python/mock/
 
 import unittest
-from unittest.test.testmock.support import is_instance, X, SomeClass
+from test.test_unittest.testmock.support import is_instance, X, SomeClass
 
 from unittest.mock import (
     Mock, MagicMock, NonCallableMagicMock,
diff --git a/Lib/unittest/test/testmock/testhelpers.py b/Lib/test/test_unittest/testmock/testhelpers.py
similarity index 96%
rename from Lib/unittest/test/testmock/testhelpers.py
rename to Lib/test/test_unittest/testmock/testhelpers.py
index 9e7ec5d62d..a19f04eb88 100644
--- a/Lib/unittest/test/testmock/testhelpers.py
+++ b/Lib/test/test_unittest/testmock/testhelpers.py
@@ -43,6 +43,7 @@ def test_any_and_datetime(self):
         mock.assert_called_with(ANY, foo=ANY)
 
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_any_mock_calls_comparison_order(self):
         mock = Mock()
         class Foo(object):
@@ -952,6 +953,24 @@ def __getattr__(self, attribute):
         self.assertFalse(hasattr(autospec, '__name__'))
 
 
+    def test_autospec_signature_staticmethod(self):
+        class Foo:
+            @staticmethod
+            def static_method(a, b=10, *, c): pass
+
+        mock = create_autospec(Foo.__dict__['static_method'])
+        self.assertEqual(inspect.signature(Foo.static_method), inspect.signature(mock))
+
+
+    def test_autospec_signature_classmethod(self):
+        class Foo:
+            @classmethod
+            def class_method(cls, a, b=10, *, c): pass
+
+        mock = create_autospec(Foo.__dict__['class_method'])
+        self.assertEqual(inspect.signature(Foo.class_method), inspect.signature(mock))
+
+
     def test_spec_inspect_signature(self):
 
         def myfunc(x, y): pass
@@ -1077,7 +1096,7 @@ def test_propertymock(self):
             p.stop()
 
 
-    def test_propertymock_returnvalue(self):
+    def test_propertymock_bare(self):
         m = MagicMock()
         p = PropertyMock()
         type(m).foo = p
@@ -1088,6 +1107,35 @@ def test_propertymock_returnvalue(self):
         self.assertNotIsInstance(returned, PropertyMock)
 
 
+    def test_propertymock_returnvalue(self):
+        m = MagicMock()
+        p = PropertyMock(return_value=42)
+        type(m).foo = p
+
+        returned = m.foo
+        p.assert_called_once_with()
+        self.assertEqual(returned, 42)
+        self.assertNotIsInstance(returned, PropertyMock)
+
+
+    def test_propertymock_side_effect(self):
+        m = MagicMock()
+        p = PropertyMock(side_effect=ValueError)
+        type(m).foo = p
+
+        with self.assertRaises(ValueError):
+            m.foo
+        p.assert_called_once_with()
+
+
+    def test_propertymock_attach(self):
+        m = Mock()
+        p = PropertyMock()
+        type(m).foo = p
+        m.attach_mock(p, 'foo')
+        self.assertEqual(m.mock_calls, [])
+
+
 class TestCallablePredicate(unittest.TestCase):
 
     def test_type(self):
diff --git a/Lib/unittest/test/testmock/testmagicmethods.py b/Lib/test/test_unittest/testmock/testmagicmethods.py
similarity index 91%
rename from Lib/unittest/test/testmock/testmagicmethods.py
rename to Lib/test/test_unittest/testmock/testmagicmethods.py
index a4feae7e9d..a8b52ce487 100644
--- a/Lib/unittest/test/testmock/testmagicmethods.py
+++ b/Lib/test/test_unittest/testmock/testmagicmethods.py
@@ -331,6 +331,45 @@ def test_magic_methods_fspath(self):
         self.assertEqual(os.fspath(mock), expected_path)
         mock.__fspath__.assert_called_once()
 
+    def test_magic_mock_does_not_reset_magic_returns(self):
+        # https://github.com/python/cpython/issues/123934
+        for reset in (True, False):
+            with self.subTest(reset=reset):
+                mm = MagicMock()
+                self.assertIs(type(mm.__str__()), str)
+                mm.__str__.assert_called_once()
+
+                self.assertIs(type(mm.__hash__()), int)
+                mm.__hash__.assert_called_once()
+
+                for _ in range(3):
+                    # Repeat reset several times to be sure:
+                    mm.reset_mock(return_value=reset)
+
+                    self.assertIs(type(mm.__str__()), str)
+                    mm.__str__.assert_called_once()
+
+                    self.assertIs(type(mm.__hash__()), int)
+                    mm.__hash__.assert_called_once()
+
+    def test_magic_mock_resets_manual_mocks(self):
+        mm = MagicMock()
+        mm.__iter__ = MagicMock(return_value=iter([1]))
+        mm.custom = MagicMock(return_value=2)
+        self.assertEqual(list(iter(mm)), [1])
+        self.assertEqual(mm.custom(), 2)
+
+        mm.reset_mock(return_value=True)
+        self.assertEqual(list(iter(mm)), [])
+        self.assertIsInstance(mm.custom(), MagicMock)
+
+    def test_magic_mock_resets_manual_mocks_empty_iter(self):
+        mm = MagicMock()
+        mm.__iter__.return_value = []
+        self.assertEqual(list(iter(mm)), [])
+
+        mm.reset_mock(return_value=True)
+        self.assertEqual(list(iter(mm)), [])
 
     def test_magic_methods_and_spec(self):
         class Iterable(object):
diff --git a/Lib/unittest/test/testmock/testmock.py b/Lib/test/test_unittest/testmock/testmock.py
similarity index 91%
rename from Lib/unittest/test/testmock/testmock.py
rename to Lib/test/test_unittest/testmock/testmock.py
index eaae22e854..e1b108f81e 100644
--- a/Lib/unittest/test/testmock/testmock.py
+++ b/Lib/test/test_unittest/testmock/testmock.py
@@ -5,7 +5,7 @@
 
 from test.support import ALWAYS_EQ
 import unittest
-from unittest.test.testmock.support import is_instance
+from test.test_unittest.testmock.support import is_instance
 from unittest import mock
 from unittest.mock import (
     call, DEFAULT, patch, sentinel,
@@ -38,6 +38,17 @@ def cmeth(cls, a, b, c, d=None): pass
     def smeth(a, b, c, d=None): pass
 
 
+class SomethingElse(object):
+    def __init__(self):
+        self._instance = None
+
+    @property
+    def instance(self):
+        if not self._instance:
+            self._instance = 'object'
+        return self._instance
+
+
 class Typos():
     autospect = None
     auto_spec = None
@@ -104,6 +115,24 @@ def f(): pass
         with self.assertRaises(TypeError):
             mock()
 
+    def test_create_autospec_should_be_configurable_by_kwargs(self):
+        """If kwargs are given to configure mock, the function must configure
+        the parent mock during initialization."""
+        mocked_result = 'mocked value'
+        class_mock = create_autospec(spec=Something, **{
+            'return_value.meth.side_effect': [ValueError, DEFAULT],
+            'return_value.meth.return_value': mocked_result})
+        with self.assertRaises(ValueError):
+            class_mock().meth(a=None, b=None, c=None)
+        self.assertEqual(class_mock().meth(a=None, b=None, c=None), mocked_result)
+        # Only the parent mock should be configurable because the user will
+        # pass kwargs with respect to the parent mock.
+        self.assertEqual(class_mock().return_value.meth.side_effect, None)
+
+    def test_create_autospec_correctly_handles_name(self):
+        class X: ...
+        mock = create_autospec(X, spec_set=True, name="Y")
+        self.assertEqual(mock._mock_name, "Y")
 
     def test_repr(self):
         mock = Mock(name='foo')
@@ -234,6 +263,73 @@ class B(object):
             with mock.patch('builtins.open', mock.mock_open()):
                 mock.mock_open()  # should still be valid with open() mocked
 
+    def test_create_autospec_wraps_class(self):
+        """Autospec a class with wraps & test if the call is passed to the
+        wrapped object."""
+        result = "real result"
+
+        class Result:
+            def get_result(self):
+                return result
+        class_mock = create_autospec(spec=Result, wraps=Result)
+        # Have to reassign the return_value to DEFAULT to return the real
+        # result (actual instance of "Result") when the mock is called.
+        class_mock.return_value = mock.DEFAULT
+        self.assertEqual(class_mock().get_result(), result)
+        # Autospec should also wrap child attributes of parent.
+        self.assertEqual(class_mock.get_result._mock_wraps, Result.get_result)
+
+    def test_create_autospec_instance_wraps_class(self):
+        """Autospec a class instance with wraps & test if the call is passed
+        to the wrapped object."""
+        result = "real result"
+
+        class Result:
+            @staticmethod
+            def get_result():
+                """This is a static method because when the mocked instance of
+                'Result' will call this method, it won't be able to consume
+                'self' argument."""
+                return result
+        instance_mock = create_autospec(spec=Result, instance=True, wraps=Result)
+        # Have to reassign the return_value to DEFAULT to return the real
+        # result from "Result.get_result" when the mocked instance of "Result"
+        # calls "get_result".
+        instance_mock.get_result.return_value = mock.DEFAULT
+        self.assertEqual(instance_mock.get_result(), result)
+        # Autospec should also wrap child attributes of the instance.
+        self.assertEqual(instance_mock.get_result._mock_wraps, Result.get_result)
+
+    def test_create_autospec_wraps_function_type(self):
+        """Autospec a function or a method with wraps & test if the call is
+        passed to the wrapped object."""
+        result = "real result"
+
+        class Result:
+            def get_result(self):
+                return result
+        func_mock = create_autospec(spec=Result.get_result, wraps=Result.get_result)
+        self.assertEqual(func_mock(Result()), result)
+
+    def test_explicit_return_value_even_if_mock_wraps_object(self):
+        """If the mock has an explicit return_value set then calls are not
+        passed to the wrapped object and the return_value is returned instead.
+        """
+        def my_func():
+            return None
+        func_mock = create_autospec(spec=my_func, wraps=my_func)
+        return_value = "explicit return value"
+        func_mock.return_value = return_value
+        self.assertEqual(func_mock(), return_value)
+
+    def test_explicit_parent(self):
+        parent = Mock()
+        mock1 = Mock(parent=parent, return_value=None)
+        mock1(1, 2, 3)
+        mock2 = Mock(parent=parent, return_value=None)
+        mock2(4, 5, 6)
+
+        self.assertEqual(parent.mock_calls, [call(1, 2, 3), call(4, 5, 6)])
 
     def test_reset_mock(self):
         parent = Mock()
@@ -603,6 +699,14 @@ def test_wraps_calls(self):
         real = Mock()
 
         mock = Mock(wraps=real)
+        # If "Mock" wraps an object, just accessing its
+        # "return_value" ("NonCallableMock.__get_return_value") should not
+        # trigger its descriptor ("NonCallableMock.__set_return_value") so
+        # the default "return_value" should always be "sentinel.DEFAULT".
+        self.assertEqual(mock.return_value, DEFAULT)
+        # It will not be "sentinel.DEFAULT" if the mock is not wrapping any
+        # object.
+        self.assertNotEqual(real.return_value, DEFAULT)
         self.assertEqual(mock(), real())
 
         real.reset_mock()
@@ -1039,7 +1143,7 @@ def test_assert_called_with_failure_message(self):
 
         actual = 'not called.'
         expected = "mock(1, '2', 3, bar='foo')"
-        message = 'expected call not found.\nExpected: %s\nActual: %s'
+        message = 'expected call not found.\nExpected: %s\n  Actual: %s'
         self.assertRaisesWithMsg(
             AssertionError, message % (expected, actual),
             mock.assert_called_with, 1, '2', 3, bar='foo'
@@ -1054,7 +1158,7 @@ def test_assert_called_with_failure_message(self):
         for meth in asserters:
             actual = "foo(1, '2', 3, foo='foo')"
             expected = "foo(1, '2', 3, bar='foo')"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
+            message = 'expected call not found.\nExpected: %s\n  Actual: %s'
             self.assertRaisesWithMsg(
                 AssertionError, message % (expected, actual),
                 meth, 1, '2', 3, bar='foo'
@@ -1064,7 +1168,7 @@ def test_assert_called_with_failure_message(self):
         for meth in asserters:
             actual = "foo(1, '2', 3, foo='foo')"
             expected = "foo(bar='foo')"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
+            message = 'expected call not found.\nExpected: %s\n  Actual: %s'
             self.assertRaisesWithMsg(
                 AssertionError, message % (expected, actual),
                 meth, bar='foo'
@@ -1074,7 +1178,7 @@ def test_assert_called_with_failure_message(self):
         for meth in asserters:
             actual = "foo(1, '2', 3, foo='foo')"
             expected = "foo(1, 2, 3)"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
+            message = 'expected call not found.\nExpected: %s\n  Actual: %s'
             self.assertRaisesWithMsg(
                 AssertionError, message % (expected, actual),
                 meth, 1, 2, 3
@@ -1084,7 +1188,7 @@ def test_assert_called_with_failure_message(self):
         for meth in asserters:
             actual = "foo(1, '2', 3, foo='foo')"
             expected = "foo()"
-            message = 'expected call not found.\nExpected: %s\nActual: %s'
+            message = 'expected call not found.\nExpected: %s\n  Actual: %s'
             self.assertRaisesWithMsg(
                 AssertionError, message % (expected, actual), meth
             )
@@ -1528,25 +1632,33 @@ def f(x=None): pass
         mock = Mock(spec=f)
         mock(1)
 
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape('Calls not found.\n'
-                              'Expected: [call()]\n'
-                              'Actual: [call(1)]'))) as cm:
+        with self.assertRaises(AssertionError) as cm:
             mock.assert_has_calls([call()])
+        self.assertEqual(str(cm.exception),
+            'Calls not found.\n'
+            'Expected: [call()]\n'
+            '  Actual: [call(1)]'
+        )
         self.assertIsNone(cm.exception.__cause__)
 
+        uncalled_mock = Mock()
+        with self.assertRaises(AssertionError) as cm:
+            uncalled_mock.assert_has_calls([call()])
+        self.assertEqual(str(cm.exception),
+            'Calls not found.\n'
+            'Expected: [call()]\n'
+            '  Actual: []'
+        )
+        self.assertIsNone(cm.exception.__cause__)
 
-        with self.assertRaisesRegex(
-                AssertionError,
-                '^{}$'.format(
-                    re.escape(
-                        'Error processing expected calls.\n'
-                        "Errors: [None, TypeError('too many positional arguments')]\n"
-                        "Expected: [call(), call(1, 2)]\n"
-                        'Actual: [call(1)]'))) as cm:
+        with self.assertRaises(AssertionError) as cm:
             mock.assert_has_calls([call(), call(1, 2)])
+        self.assertEqual(str(cm.exception),
+            'Error processing expected calls.\n'
+            "Errors: [None, TypeError('too many positional arguments')]\n"
+            'Expected: [call(), call(1, 2)]\n'
+            '  Actual: [call(1)]'
+        )
         self.assertIsInstance(cm.exception.__cause__, TypeError)
 
     def test_assert_any_call(self):
@@ -1645,21 +1757,41 @@ def test_mock_unsafe(self):
             m.aseert_foo_call()
         with self.assertRaisesRegex(AttributeError, msg):
             m.assrt_foo_call()
+        with self.assertRaisesRegex(AttributeError, msg):
+            m.called_once_with()
+        with self.assertRaisesRegex(AttributeError, msg):
+            m.called_once()
+        with self.assertRaisesRegex(AttributeError, msg):
+            m.has_calls()
+
+        class Foo(object):
+            def called_once(self): pass
+
+            def has_calls(self): pass
+
+        m = Mock(spec=Foo)
+        m.called_once()
+        m.has_calls()
+
+        m.called_once.assert_called_once()
+        m.has_calls.assert_called_once()
+
         m = Mock(unsafe=True)
         m.assert_foo_call()
         m.assret_foo_call()
         m.asert_foo_call()
         m.aseert_foo_call()
         m.assrt_foo_call()
+        m.called_once()
+        m.called_once_with()
+        m.has_calls()
 
     # gh-100739
     def test_mock_safe_with_spec(self):
         class Foo(object):
-            def assert_bar(self):
-                pass
+            def assert_bar(self): pass
 
-            def assertSome(self):
-                pass
+            def assertSome(self): pass
 
         m = Mock(spec=Foo)
         m.assert_bar()
@@ -2231,7 +2363,7 @@ def test_misspelled_arguments(self):
         class Foo():
             one = 'one'
         # patch, patch.object and create_autospec need to check for misspelled
-        # arguments explicitly and throw a RuntimError if found.
+        # arguments explicitly and throw a RuntimeError if found.
         with self.assertRaises(RuntimeError):
             with patch(f'{__name__}.Something.meth', autospect=True): pass
         with self.assertRaises(RuntimeError):
@@ -2273,6 +2405,26 @@ class Foo():
             f'{__name__}.Typos', autospect=True, set_spec=True, auto_spec=True):
             pass
 
+    def test_property_not_called_with_spec_mock(self):
+        obj = SomethingElse()
+        self.assertIsNone(obj._instance, msg='before mock')
+        mock = Mock(spec=obj)
+        self.assertIsNone(obj._instance, msg='after mock')
+        self.assertEqual('object', obj.instance)
+
+    def test_decorated_async_methods_with_spec_mock(self):
+        class Foo():
+            @classmethod
+            async def class_method(cls):
+                pass
+            @staticmethod
+            async def static_method():
+                pass
+            async def method(self):
+                pass
+        mock = Mock(spec=Foo)
+        for m in (mock.method, mock.class_method, mock.static_method):
+            self.assertIsInstance(m, AsyncMock)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/unittest/test/testmock/testpatch.py b/Lib/test/test_unittest/testmock/testpatch.py
similarity index 89%
rename from Lib/unittest/test/testmock/testpatch.py
rename to Lib/test/test_unittest/testmock/testpatch.py
index 8ab63a1317..87424e07e4 100644
--- a/Lib/unittest/test/testmock/testpatch.py
+++ b/Lib/test/test_unittest/testmock/testpatch.py
@@ -7,9 +7,11 @@
 from collections import OrderedDict
 
 import unittest
-from unittest.test.testmock import support
-from unittest.test.testmock.support import SomeClass, is_instance
+import test
+from test.test_unittest.testmock import support
+from test.test_unittest.testmock.support import SomeClass, is_instance
 
+from test.support.import_helper import DirsOnSysPath
 from test.test_importlib.util import uncache
 from unittest.mock import (
     NonCallableMock, CallableMixin, sentinel,
@@ -669,7 +671,7 @@ def test_patch_dict_decorator_resolution(self):
         # the new dictionary during function call
         original = support.target.copy()
 
-        @patch.dict('unittest.test.testmock.support.target', {'bar': 'BAR'})
+        @patch.dict('test.test_unittest.testmock.support.target', {'bar': 'BAR'})
         def test():
             self.assertEqual(support.target, {'foo': 'BAZ', 'bar': 'BAR'})
 
@@ -743,6 +745,54 @@ def test_stop_idempotent(self):
         self.assertIsNone(patcher.stop())
 
 
+    def test_exit_idempotent(self):
+        patcher = patch(foo_name, 'bar', 3)
+        with patcher:
+            patcher.stop()
+
+
+    def test_second_start_failure(self):
+        patcher = patch(foo_name, 'bar', 3)
+        patcher.start()
+        try:
+            self.assertRaises(RuntimeError, patcher.start)
+        finally:
+            patcher.stop()
+
+
+    def test_second_enter_failure(self):
+        patcher = patch(foo_name, 'bar', 3)
+        with patcher:
+            self.assertRaises(RuntimeError, patcher.start)
+
+
+    def test_second_start_after_stop(self):
+        patcher = patch(foo_name, 'bar', 3)
+        patcher.start()
+        patcher.stop()
+        patcher.start()
+        patcher.stop()
+
+
+    def test_property_setters(self):
+        mock_object = Mock()
+        mock_bar = mock_object.bar
+        patcher = patch.object(mock_object, 'bar', 'x')
+        with patcher:
+            self.assertEqual(patcher.is_local, False)
+            self.assertIs(patcher.target, mock_object)
+            self.assertEqual(patcher.temp_original, mock_bar)
+            patcher.is_local = True
+            patcher.target = mock_bar
+            patcher.temp_original = mock_object
+            self.assertEqual(patcher.is_local, True)
+            self.assertIs(patcher.target, mock_bar)
+            self.assertEqual(patcher.temp_original, mock_object)
+        # if changes are left intact, they may lead to disruption as shown below (it might be what someone needs though)
+        self.assertEqual(mock_bar.bar, mock_object)
+        self.assertEqual(mock_object.bar, 'x')
+
+
     def test_patchobject_start_stop(self):
         original = something
         patcher = patch.object(PTModule, 'something', 'foo')
@@ -996,6 +1046,36 @@ def test_autospec_classmethod(self):
             method.assert_called_once_with()
 
 
+    def test_autospec_staticmethod_signature(self):
+        # Patched methods which are decorated with @staticmethod should have the same signature
+        class Foo:
+            @staticmethod
+            def static_method(a, b=10, *, c): pass
+
+        Foo.static_method(1, 2, c=3)
+
+        with patch.object(Foo, 'static_method', autospec=True) as method:
+            method(1, 2, c=3)
+            self.assertRaises(TypeError, method)
+            self.assertRaises(TypeError, method, 1)
+            self.assertRaises(TypeError, method, 1, 2, 3, c=4)
+
+
+    def test_autospec_classmethod_signature(self):
+        # Patched methods which are decorated with @classmethod should have the same signature
+        class Foo:
+            @classmethod
+            def class_method(cls, a, b=10, *, c): pass
+
+        Foo.class_method(1, 2, c=3)
+
+        with patch.object(Foo, 'class_method', autospec=True) as method:
+            method(1, 2, c=3)
+            self.assertRaises(TypeError, method)
+            self.assertRaises(TypeError, method, 1)
+            self.assertRaises(TypeError, method, 1, 2, 3, c=4)
+
+
     def test_autospec_with_new(self):
         patcher = patch('%s.function' % __name__, new=3, autospec=True)
         self.assertRaises(TypeError, patcher.start)
@@ -1066,7 +1146,7 @@ def test_new_callable_patch(self):
 
         self.assertIsNot(m1, m2)
         for mock in m1, m2:
-            self.assertNotCallable(m1)
+            self.assertNotCallable(mock)
 
 
     def test_new_callable_patch_object(self):
@@ -1079,7 +1159,7 @@ def test_new_callable_patch_object(self):
 
         self.assertIsNot(m1, m2)
         for mock in m1, m2:
-            self.assertNotCallable(m1)
+            self.assertNotCallable(mock)
 
 
     def test_new_callable_keyword_arguments(self):
@@ -1614,7 +1694,7 @@ def test_patch_with_spec_mock_repr(self):
 
 
     def test_patch_nested_autospec_repr(self):
-        with patch('unittest.test.testmock.support', autospec=True) as m:
+        with patch('test.test_unittest.testmock.support', autospec=True) as m:
             self.assertIn(" name='support.SomeClass.wibble()'",
                           repr(m.SomeClass.wibble()))
             self.assertIn(" name='support.SomeClass().wibble()'",
@@ -1698,6 +1778,71 @@ def test(mock):
                             'exception traceback not propagated')
 
 
+    def test_name_resolution_import_rebinding(self):
+        # Currently mock.patch uses pkgutil.resolve_name(), but repeat
+        # similar tests just for the case.
+        # The same data is also used for testing import in test_import and
+        # pkgutil.resolve_name() in test_pkgutil.
+        path = os.path.join(os.path.dirname(test.__file__), 'test_import', 'data')
+        def check(name):
+            p = patch(name)
+            p.start()
+            p.stop()
+        def check_error(name):
+            p = patch(name)
+            self.assertRaises(AttributeError, p.start)
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            check('package3.submodule.A.attr')
+            check_error('package3.submodule.B.attr')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            check('package3.submodule:A.attr')
+            check_error('package3.submodule:B.attr')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            check('package3:submodule.B.attr')
+            check_error('package3:submodule.A.attr')
+            check('package3.submodule.A.attr')
+            check_error('package3.submodule.B.attr')
+            check('package3:submodule.B.attr')
+            check_error('package3:submodule.A.attr')
+        with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
+            check('package3:submodule.B.attr')
+            check_error('package3:submodule.A.attr')
+            check('package3.submodule:A.attr')
+            check_error('package3.submodule:B.attr')
+            check('package3:submodule.B.attr')
+            check_error('package3:submodule.A.attr')
+
+    def test_name_resolution_import_rebinding2(self):
+        path = os.path.join(os.path.dirname(test.__file__), 'test_import', 'data')
+        def check(name):
+            p = patch(name)
+            p.start()
+            p.stop()
+        def check_error(name):
+            p = patch(name)
+            self.assertRaises(AttributeError, p.start)
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            check('package4.submodule.A.attr')
+            check_error('package4.submodule.B.attr')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            check('package4.submodule:A.attr')
+            check_error('package4.submodule:B.attr')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            check('package4:submodule.B.attr')
+            check_error('package4:submodule.A.attr')
+            check('package4.submodule.A.attr')
+            check_error('package4.submodule.B.attr')
+            check('package4:submodule.A.attr')
+            check_error('package4:submodule.B.attr')
+        with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
+            check('package4:submodule.B.attr')
+            check_error('package4:submodule.A.attr')
+            check('package4.submodule:A.attr')
+            check_error('package4.submodule:B.attr')
+            check('package4:submodule.A.attr')
+            check_error('package4:submodule.B.attr')
+
+
     def test_create_and_specs(self):
         for kwarg in ('spec', 'spec_set', 'autospec'):
             p = patch('%s.doesnotexist' % __name__, create=True,
@@ -1867,6 +2012,7 @@ def test_patch_and_patch_dict_stopall(self):
         self.assertEqual(dic2, origdic2)
 
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_special_attrs(self):
         def foo(x=0):
             """TEST"""
@@ -1882,7 +2028,7 @@ def foo(x=0):
 
         with patch.object(foo, '__module__', "testpatch2"):
             self.assertEqual(foo.__module__, "testpatch2")
-        self.assertEqual(foo.__module__, 'unittest.test.testmock.testpatch')
+        self.assertEqual(foo.__module__, __name__)
 
         with patch.object(foo, '__annotations__', dict([('s', 1, )])):
             self.assertEqual(foo.__annotations__, dict([('s', 1, )]))
@@ -1917,16 +2063,16 @@ def test_dotted_but_module_not_loaded(self):
         # This exercises the AttributeError branch of _dot_lookup.
 
         # make sure it's there
-        import unittest.test.testmock.support
+        import test.test_unittest.testmock.support
         # now make sure it's not:
         with patch.dict('sys.modules'):
-            del sys.modules['unittest.test.testmock.support']
-            del sys.modules['unittest.test.testmock']
-            del sys.modules['unittest.test']
-            del sys.modules['unittest']
+            del sys.modules['test.test_unittest.testmock.support']
+            del sys.modules['test.test_unittest.testmock']
+            del sys.modules['test.test_unittest']
+            del sys.modules['test']
 
             # now make sure we can patch based on a dotted path:
-            @patch('unittest.test.testmock.support.X')
+            @patch('test.test_unittest.testmock.support.X')
             def test(mock):
                 pass
             test()
@@ -1943,11 +2089,18 @@ class Foo:
 
 
     def test_cant_set_kwargs_when_passing_a_mock(self):
-        @patch('unittest.test.testmock.support.X', new=object(), x=1)
+        @patch('test.test_unittest.testmock.support.X', new=object(), x=1)
         def test(): pass
         with self.assertRaises(TypeError):
             test()
 
+    def test_patch_proxy_object(self):
+        @patch("test.test_unittest.testmock.support.g", new_callable=MagicMock())
+        def test(_):
+            pass
+
+        test()
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/unittest/test/testmock/testsealable.py b/Lib/test/test_unittest/testmock/testsealable.py
similarity index 96%
rename from Lib/unittest/test/testmock/testsealable.py
rename to Lib/test/test_unittest/testmock/testsealable.py
index daba2b49b4..8bf98cfa56 100644
--- a/Lib/unittest/test/testmock/testsealable.py
+++ b/Lib/test/test_unittest/testmock/testsealable.py
@@ -175,15 +175,12 @@ def test_seal_with_autospec(self):
         # https://bugs.python.org/issue45156
         class Foo:
             foo = 0
-            def bar1(self):
-                return 1
-            def bar2(self):
-                return 2
+            def bar1(self): pass
+            def bar2(self): pass
 
             class Baz:
                 baz = 3
-                def ban(self):
-                    return 4
+                def ban(self): pass
 
         for spec_set in (True, False):
             with self.subTest(spec_set=spec_set):
@@ -200,6 +197,9 @@ def ban(self):
                 self.assertIsInstance(foo.Baz.baz, mock.NonCallableMagicMock)
                 self.assertIsInstance(foo.Baz.ban, mock.MagicMock)
 
+                # see gh-91803
+                self.assertIsInstance(foo.bar2(), mock.MagicMock)
+
                 self.assertEqual(foo.bar1(), 'a')
                 foo.bar1.return_value = 'new_a'
                 self.assertEqual(foo.bar1(), 'new_a')
@@ -212,7 +212,7 @@ def ban(self):
                 with self.assertRaises(AttributeError):
                     foo.bar = 1
                 with self.assertRaises(AttributeError):
-                    foo.bar2()
+                    foo.bar2().x
 
                 foo.bar2.return_value = 'bar2'
                 self.assertEqual(foo.bar2(), 'bar2')
diff --git a/Lib/unittest/test/testmock/testsentinel.py b/Lib/test/test_unittest/testmock/testsentinel.py
similarity index 100%
rename from Lib/unittest/test/testmock/testsentinel.py
rename to Lib/test/test_unittest/testmock/testsentinel.py
diff --git a/Lib/test/test_unittest/testmock/testthreadingmock.py b/Lib/test/test_unittest/testmock/testthreadingmock.py
new file mode 100644
index 0000000000..a02b532ed4
--- /dev/null
+++ b/Lib/test/test_unittest/testmock/testthreadingmock.py
@@ -0,0 +1,201 @@
+import time
+import unittest
+import concurrent.futures
+
+from test.support import threading_helper
+from unittest.mock import patch, ThreadingMock
+
+
+threading_helper.requires_working_threading(module=True)
+
+VERY_SHORT_TIMEOUT = 0.1
+
+
+class Something:
+    def method_1(self):
+        pass  # pragma: no cover
+
+    def method_2(self):
+        pass  # pragma: no cover
+
+
+class TestThreadingMock(unittest.TestCase):
+    def _call_after_delay(self, func, /, *args, **kwargs):
+        time.sleep(kwargs.pop("delay"))
+        func(*args, **kwargs)
+
+    def setUp(self):
+        self._executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
+
+    def tearDown(self):
+        self._executor.shutdown()
+
+    def run_async(self, func, /, *args, delay=0, **kwargs):
+        self._executor.submit(
+            self._call_after_delay, func, *args, **kwargs, delay=delay
+        )
+
+    def _make_mock(self, *args, **kwargs):
+        return ThreadingMock(*args, **kwargs)
+
+    def test_spec(self):
+        waitable_mock = self._make_mock(spec=Something)
+
+        with patch(f"{__name__}.Something", waitable_mock) as m:
+            something = m()
+
+            self.assertIsInstance(something.method_1, ThreadingMock)
+            self.assertIsInstance(something.method_1().method_2(), ThreadingMock)
+
+            with self.assertRaises(AttributeError):
+                m.test
+
+    def test_side_effect(self):
+        waitable_mock = self._make_mock()
+
+        with patch(f"{__name__}.Something", waitable_mock):
+            something = Something()
+            something.method_1.side_effect = [1]
+
+            self.assertEqual(something.method_1(), 1)
+
+    def test_instance_check(self):
+        waitable_mock = self._make_mock()
+
+        with patch(f"{__name__}.Something", waitable_mock):
+            something = Something()
+
+            self.assertIsInstance(something.method_1, ThreadingMock)
+            self.assertIsInstance(something.method_1().method_2(), ThreadingMock)
+
+    def test_dynamic_child_mocks_are_threading_mocks(self):
+        waitable_mock = self._make_mock()
+        self.assertIsInstance(waitable_mock.child, ThreadingMock)
+
+    def test_dynamic_child_mocks_inherit_timeout(self):
+        mock1 = self._make_mock()
+        self.assertIs(mock1._mock_wait_timeout, None)
+        mock2 = self._make_mock(timeout=2)
+        self.assertEqual(mock2._mock_wait_timeout, 2)
+        mock3 = self._make_mock(timeout=3)
+        self.assertEqual(mock3._mock_wait_timeout, 3)
+
+        self.assertIs(mock1.child._mock_wait_timeout, None)
+        self.assertEqual(mock2.child._mock_wait_timeout, 2)
+        self.assertEqual(mock3.child._mock_wait_timeout, 3)
+
+        self.assertEqual(mock2.really().__mul__().complex._mock_wait_timeout, 2)
+
+    def test_no_name_clash(self):
+        waitable_mock = self._make_mock()
+        waitable_mock._event = "myevent"
+        waitable_mock.event = "myevent"
+        waitable_mock.timeout = "mytimeout"
+        waitable_mock("works")
+        waitable_mock.wait_until_called()
+        waitable_mock.wait_until_any_call_with("works")
+
+    def test_patch(self):
+        waitable_mock = self._make_mock(spec=Something)
+
+        with patch(f"{__name__}.Something", waitable_mock):
+            something = Something()
+            something.method_1()
+            something.method_1.wait_until_called()
+
+    def test_wait_already_called_success(self):
+        waitable_mock = self._make_mock(spec=Something)
+        waitable_mock.method_1()
+        waitable_mock.method_1.wait_until_called()
+        waitable_mock.method_1.wait_until_any_call_with()
+        waitable_mock.method_1.assert_called()
+
+    def test_wait_until_called_success(self):
+        waitable_mock = self._make_mock(spec=Something)
+        self.run_async(waitable_mock.method_1, delay=VERY_SHORT_TIMEOUT)
+        waitable_mock.method_1.wait_until_called()
+
+    def test_wait_until_called_method_timeout(self):
+        waitable_mock = self._make_mock(spec=Something)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_called(timeout=VERY_SHORT_TIMEOUT)
+
+    def test_wait_until_called_instance_timeout(self):
+        waitable_mock = self._make_mock(spec=Something, timeout=VERY_SHORT_TIMEOUT)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_called()
+
+    def test_wait_until_called_global_timeout(self):
+        with patch.object(ThreadingMock, "DEFAULT_TIMEOUT"):
+            ThreadingMock.DEFAULT_TIMEOUT = VERY_SHORT_TIMEOUT
+            waitable_mock = self._make_mock(spec=Something)
+            with self.assertRaises(AssertionError):
+                waitable_mock.method_1.wait_until_called()
+
+    def test_wait_until_any_call_with_success(self):
+        waitable_mock = self._make_mock()
+        self.run_async(waitable_mock, delay=VERY_SHORT_TIMEOUT)
+        waitable_mock.wait_until_any_call_with()
+
+    def test_wait_until_any_call_with_instance_timeout(self):
+        waitable_mock = self._make_mock(timeout=VERY_SHORT_TIMEOUT)
+        with self.assertRaises(AssertionError):
+            waitable_mock.wait_until_any_call_with()
+
+    def test_wait_until_any_call_global_timeout(self):
+        with patch.object(ThreadingMock, "DEFAULT_TIMEOUT"):
+            ThreadingMock.DEFAULT_TIMEOUT = VERY_SHORT_TIMEOUT
+            waitable_mock = self._make_mock()
+            with self.assertRaises(AssertionError):
+                waitable_mock.wait_until_any_call_with()
+
+    def test_wait_until_any_call_positional(self):
+        waitable_mock = self._make_mock(timeout=VERY_SHORT_TIMEOUT)
+        waitable_mock.method_1(1, 2, 3)
+        waitable_mock.method_1.wait_until_any_call_with(1, 2, 3)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_any_call_with(2, 3, 1)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_any_call_with()
+
+    def test_wait_until_any_call_kw(self):
+        waitable_mock = self._make_mock(timeout=VERY_SHORT_TIMEOUT)
+        waitable_mock.method_1(a=1, b=2)
+        waitable_mock.method_1.wait_until_any_call_with(a=1, b=2)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_any_call_with(a=2, b=1)
+        with self.assertRaises(AssertionError):
+            waitable_mock.method_1.wait_until_any_call_with()
+
+    def test_magic_methods_success(self):
+        waitable_mock = self._make_mock()
+        str(waitable_mock)
+        waitable_mock.__str__.wait_until_called()
+        waitable_mock.__str__.assert_called()
+
+    def test_reset_mock_resets_wait(self):
+        m = self._make_mock(timeout=VERY_SHORT_TIMEOUT)
+
+        with self.assertRaises(AssertionError):
+            m.wait_until_called()
+        with self.assertRaises(AssertionError):
+            m.wait_until_any_call_with()
+        m()
+        m.wait_until_called()
+        m.wait_until_any_call_with()
+        m.assert_called_once()
+
+        m.reset_mock()
+
+        with self.assertRaises(AssertionError):
+            m.wait_until_called()
+        with self.assertRaises(AssertionError):
+            m.wait_until_any_call_with()
+        m()
+        m.wait_until_called()
+        m.wait_until_any_call_with()
+        m.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/unittest/test/testmock/testwith.py b/Lib/test/test_unittest/testmock/testwith.py
similarity index 97%
rename from Lib/unittest/test/testmock/testwith.py
rename to Lib/test/test_unittest/testmock/testwith.py
index c74d49a63c..56cb16394f 100644
--- a/Lib/unittest/test/testmock/testwith.py
+++ b/Lib/test/test_unittest/testmock/testwith.py
@@ -1,7 +1,7 @@
 import unittest
 from warnings import catch_warnings
 
-from unittest.test.testmock.support import is_instance
+from test.test_unittest.testmock.support import is_instance
 from unittest.mock import MagicMock, Mock, patch, sentinel, mock_open, call
 
 
@@ -158,7 +158,7 @@ def test_mock_open_context_manager(self):
                 f.read()
 
         expected_calls = [call('foo'), call().__enter__(), call().read(),
-                          call().__exit__(None, None, None)]
+                          call().__exit__(None, None, None), call().close()]
         self.assertEqual(mock.mock_calls, expected_calls)
         self.assertIs(f, handle)
 
@@ -172,9 +172,9 @@ def test_mock_open_context_manager_multiple_times(self):
 
         expected_calls = [
             call('foo'), call().__enter__(), call().read(),
-            call().__exit__(None, None, None),
+            call().__exit__(None, None, None), call().close(),
             call('bar'), call().__enter__(), call().read(),
-            call().__exit__(None, None, None)]
+            call().__exit__(None, None, None), call().close()]
         self.assertEqual(mock.mock_calls, expected_calls)
 
     def test_explicit_mock(self):
diff --git a/Lib/test/test_univnewlines.py b/Lib/test/test_univnewlines.py
index b905491878..ed2e0970ba 100644
--- a/Lib/test/test_univnewlines.py
+++ b/Lib/test/test_univnewlines.py
@@ -4,7 +4,6 @@
 import unittest
 import os
 import sys
-from test import support
 from test.support import os_helper
 
 
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index 82f1d9dc2e..7e3607842f 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -10,7 +10,9 @@
 from unittest.mock import patch
 from test import support
 from test.support import os_helper
+from test.support import socket_helper
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 import os
 try:
     import ssl
@@ -18,12 +20,15 @@
     ssl = None
 import sys
 import tempfile
-from nturl2path import url2pathname, pathname2url
 
 from base64 import b64encode
 import collections
 
 
+if not socket_helper.has_gethostname:
+    raise unittest.SkipTest("test requires gethostname()")
+
+
 def hexescape(char):
     """Escape char as RFC 2396 specifies"""
     hex_repr = hex(ord(char))[2:].upper()
@@ -135,7 +140,7 @@ def unfakeftp(self):
         urllib.request.ftpwrapper = self._ftpwrapper_class
 
 
-class urlopen_FileTests(unittest.TestCase):
+class urlopen_FileTests(unittest.TestCase, ExtraAssertions):
     """Test urlopen() opening a temporary file.
 
     Try to test as much functionality as possible so as to cut down on reliance
@@ -153,7 +158,7 @@ def setUp(self):
         finally:
             f.close()
         self.pathname = os_helper.TESTFN
-        self.quoted_pathname = urllib.parse.quote(self.pathname)
+        self.quoted_pathname = urllib.parse.quote(os.fsencode(self.pathname))
         self.returned_obj = urlopen("file:%s" % self.quoted_pathname)
 
     def tearDown(self):
@@ -165,9 +170,7 @@ def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines", "fileno",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertTrue(hasattr(self.returned_obj, attr),
-                         "object returned by urlopen() lacks %s attribute" %
-                         attr)
+            self.assertHasAttr(self.returned_obj, attr)
 
     def test_read(self):
         self.assertEqual(self.text, self.returned_obj.read())
@@ -232,17 +235,12 @@ class ProxyTests(unittest.TestCase):
 
     def setUp(self):
         # Records changes to env vars
-        self.env = os_helper.EnvironmentVarGuard()
+        self.env = self.enterContext(os_helper.EnvironmentVarGuard())
         # Delete all proxy related env vars
         for k in list(os.environ):
             if 'proxy' in k.lower():
                 self.env.unset(k)
 
-    def tearDown(self):
-        # Restore all proxy related env vars
-        self.env.__exit__()
-        del self.env
-
     def test_getproxies_environment_keep_no_proxies(self):
         self.env.set('NO_PROXY', 'localhost')
         proxies = urllib.request.getproxies_environment()
@@ -477,7 +475,9 @@ def test_read_bogus(self):
 Content-Type: text/html; charset=iso-8859-1
 ''', mock_close=True)
         try:
-            self.assertRaises(OSError, urlopen, "http://python.org/")
+            with self.assertRaises(urllib.error.HTTPError) as cm:
+                urllib.request.urlopen("http://python.org/")
+            cm.exception.close()
         finally:
             self.unfakehttp()
 
@@ -492,8 +492,9 @@ def test_invalid_redirect(self):
 ''', mock_close=True)
         try:
             msg = "Redirection to url 'file:"
-            with self.assertRaisesRegex(urllib.error.HTTPError, msg):
-                urlopen("http://python.org/")
+            with self.assertRaisesRegex(urllib.error.HTTPError, msg) as cm:
+                urllib.request.urlopen("http://python.org/")
+            cm.exception.close()
         finally:
             self.unfakehttp()
 
@@ -506,8 +507,9 @@ def test_redirect_limit_independent(self):
 Connection: close
 ''', mock_close=True)
             try:
-                self.assertRaises(urllib.error.HTTPError, urlopen,
-                    "http://something")
+                with self.assertRaises(urllib.error.HTTPError) as cm:
+                    urllib.request.urlopen("http://something")
+                cm.exception.close()
             finally:
                 self.unfakehttp()
 
@@ -597,17 +599,8 @@ def test_URLopener_deprecation(self):
         with warnings_helper.check_warnings(('',DeprecationWarning)):
             urllib.request.URLopener()
 
-    @unittest.skipUnless(ssl, "ssl module required")
-    def test_cafile_and_context(self):
-        context = ssl.create_default_context()
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            with self.assertRaises(ValueError):
-                urllib.request.urlopen(
-                    "https://localhost", cafile="/nonexistent/path", context=context
-                )
-
 
-class urlopen_DataTests(unittest.TestCase):
+class urlopen_DataTests(unittest.TestCase, ExtraAssertions):
     """Test urlopen() opening a data URL."""
 
     def setUp(self):
@@ -636,18 +629,17 @@ def setUp(self):
             "QOjdAAAAAXNSR0IArs4c6QAAAA9JREFUCNdj%0AYGBg%2BP//PwAGAQL%2BCm8 "
             "vHgAAAABJRU5ErkJggg%3D%3D%0A%20")
 
-        self.text_url_resp = urllib.request.urlopen(self.text_url)
-        self.text_url_base64_resp = urllib.request.urlopen(
-            self.text_url_base64)
-        self.image_url_resp = urllib.request.urlopen(self.image_url)
+        self.text_url_resp = self.enterContext(
+            urllib.request.urlopen(self.text_url))
+        self.text_url_base64_resp = self.enterContext(
+            urllib.request.urlopen(self.text_url_base64))
+        self.image_url_resp = self.enterContext(urllib.request.urlopen(self.image_url))
 
     def test_interface(self):
         # Make sure object returned by urlopen() has the specified methods
         for attr in ("read", "readline", "readlines",
                      "close", "info", "geturl", "getcode", "__iter__"):
-            self.assertTrue(hasattr(self.text_url_resp, attr),
-                         "object returned by urlopen() lacks %s attribute" %
-                         attr)
+            self.assertHasAttr(self.text_url_resp, attr)
 
     def test_info(self):
         self.assertIsInstance(self.text_url_resp.info(), email.message.Message)
@@ -655,8 +647,10 @@ def test_info(self):
             [('text/plain', ''), ('charset', 'ISO-8859-1')])
         self.assertEqual(self.image_url_resp.info()['content-length'],
             str(len(self.image)))
-        self.assertEqual(urllib.request.urlopen("data:,").info().get_params(),
+        r = urllib.request.urlopen("data:,")
+        self.assertEqual(r.info().get_params(),
             [('text/plain', ''), ('charset', 'US-ASCII')])
+        r.close()
 
     def test_geturl(self):
         self.assertEqual(self.text_url_resp.geturl(), self.text_url)
@@ -719,10 +713,6 @@ def tearDown(self):
 
     def constructLocalFileUrl(self, filePath):
         filePath = os.path.abspath(filePath)
-        try:
-            filePath.encode("utf-8")
-        except UnicodeEncodeError:
-            raise unittest.SkipTest("filePath is not encodable to utf8")
         return "file://%s" % urllib.request.pathname2url(filePath)
 
     def createNewTempFile(self, data=b""):
@@ -1104,6 +1094,8 @@ def test_unquoting(self):
         self.assertEqual(result.count('%'), 1,
                          "using unquote(): not all characters escaped: "
                          "%s" % result)
+
+    def test_unquote_rejects_none_and_tuple(self):
         self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, None)
         self.assertRaises((TypeError, AttributeError), urllib.parse.unquote, ())
 
@@ -1527,39 +1519,119 @@ def test_quoting(self):
                          (expect, result))
 
     @unittest.skipUnless(sys.platform == 'win32',
-                         'test specific to the nturl2path functions.')
-    def test_prefixes(self):
+                         'test specific to Windows pathnames.')
+    def test_pathname2url_win(self):
         # Test special prefixes are correctly handled in pathname2url()
-        given = '\\\\?\\C:\\dir'
-        expect = '///C:/dir'
-        result = urllib.request.pathname2url(given)
-        self.assertEqual(expect, result,
-                         "pathname2url() failed; %s != %s" %
-                         (expect, result))
-        given = '\\\\?\\unc\\server\\share\\dir'
-        expect = '/server/share/dir'
-        result = urllib.request.pathname2url(given)
-        self.assertEqual(expect, result,
-                         "pathname2url() failed; %s != %s" %
-                         (expect, result))
-
+        fn = urllib.request.pathname2url
+        self.assertEqual(fn('\\\\?\\C:\\dir'), '///C:/dir')
+        self.assertEqual(fn('\\\\?\\unc\\server\\share\\dir'), '//server/share/dir')
+        self.assertEqual(fn("C:"), '///C:')
+        self.assertEqual(fn("C:\\"), '///C:/')
+        self.assertEqual(fn('C:\\a\\b.c'), '///C:/a/b.c')
+        self.assertEqual(fn('C:\\a\\b.c\\'), '///C:/a/b.c/')
+        self.assertEqual(fn('C:\\a\\\\b.c'), '///C:/a//b.c')
+        self.assertEqual(fn('C:\\a\\b%#c'), '///C:/a/b%25%23c')
+        self.assertEqual(fn('C:\\a\\b\xe9'), '///C:/a/b%C3%A9')
+        self.assertEqual(fn('C:\\foo\\bar\\spam.foo'), "///C:/foo/bar/spam.foo")
+        # Long drive letter
+        self.assertRaises(IOError, fn, "XX:\\")
+        # No drive letter
+        self.assertEqual(fn("\\folder\\test\\"), '/folder/test/')
+        self.assertEqual(fn("\\\\folder\\test\\"), '//folder/test/')
+        self.assertEqual(fn("\\\\\\folder\\test\\"), '///folder/test/')
+        self.assertEqual(fn('\\\\some\\share\\'), '//some/share/')
+        self.assertEqual(fn('\\\\some\\share\\a\\b.c'), '//some/share/a/b.c')
+        self.assertEqual(fn('\\\\some\\share\\a\\b%#c\xe9'), '//some/share/a/b%25%23c%C3%A9')
+        # Alternate path separator
+        self.assertEqual(fn('C:/a/b.c'), '///C:/a/b.c')
+        self.assertEqual(fn('//some/share/a/b.c'), '//some/share/a/b.c')
+        self.assertEqual(fn('//?/C:/dir'), '///C:/dir')
+        self.assertEqual(fn('//?/unc/server/share/dir'), '//server/share/dir')
+        # Round-tripping
+        urls = ['///C:',
+                '/folder/test/',
+                '///C:/foo/bar/spam.foo']
+        for url in urls:
+            self.assertEqual(fn(urllib.request.url2pathname(url)), url)
+
+    @unittest.skipIf(sys.platform == 'win32',
+                     'test specific to POSIX pathnames')
+    def test_pathname2url_posix(self):
+        fn = urllib.request.pathname2url
+        self.assertEqual(fn('/'), '/')
+        self.assertEqual(fn('/a/b.c'), '/a/b.c')
+        self.assertEqual(fn('//a/b.c'), '////a/b.c')
+        self.assertEqual(fn('///a/b.c'), '/////a/b.c')
+        self.assertEqual(fn('////a/b.c'), '//////a/b.c')
+        self.assertEqual(fn('/a/b%#c'), '/a/b%25%23c')
+
+    @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
+    def test_pathname2url_nonascii(self):
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        url = urllib.parse.quote(os_helper.FS_NONASCII, encoding=encoding, errors=errors)
+        self.assertEqual(urllib.request.pathname2url(os_helper.FS_NONASCII), url)
 
     @unittest.skipUnless(sys.platform == 'win32',
-                         'test specific to the urllib.url2path function.')
-    def test_ntpath(self):
-        given = ('/C:/', '///C:/', '/C|//')
-        expect = 'C:\\'
-        for url in given:
-            result = urllib.request.url2pathname(url)
-            self.assertEqual(expect, result,
-                             'urllib.request..url2pathname() failed; %s != %s' %
-                             (expect, result))
-        given = '///C|/path'
-        expect = 'C:\\path'
-        result = urllib.request.url2pathname(given)
-        self.assertEqual(expect, result,
-                         'urllib.request.url2pathname() failed; %s != %s' %
-                         (expect, result))
+                         'test specific to Windows pathnames.')
+    def test_url2pathname_win(self):
+        fn = urllib.request.url2pathname
+        self.assertEqual(fn('/C:/'), 'C:\\')
+        self.assertEqual(fn("///C|"), 'C:')
+        self.assertEqual(fn("///C:"), 'C:')
+        self.assertEqual(fn('///C:/'), 'C:\\')
+        self.assertEqual(fn('/C|//'), 'C:\\\\')
+        self.assertEqual(fn('///C|/path'), 'C:\\path')
+        # No DOS drive
+        self.assertEqual(fn("///C/test/"), '\\C\\test\\')
+        self.assertEqual(fn("////C/test/"), '\\\\C\\test\\')
+        # DOS drive paths
+        self.assertEqual(fn('C:/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('C:/path/to/file/'), 'C:\\path\\to\\file\\')
+        self.assertEqual(fn('C:/path/to//file'), 'C:\\path\\to\\\\file')
+        self.assertEqual(fn('C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('/C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('///C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn("///C|/foo/bar/spam.foo"), 'C:\\foo\\bar\\spam.foo')
+        # Non-ASCII drive letter
+        self.assertRaises(IOError, fn, "///\u00e8|/")
+        # UNC paths
+        self.assertEqual(fn('//server/path/to/file'), '\\\\server\\path\\to\\file')
+        self.assertEqual(fn('////server/path/to/file'), '\\\\server\\path\\to\\file')
+        self.assertEqual(fn('/////server/path/to/file'), '\\\\server\\path\\to\\file')
+        # Localhost paths
+        self.assertEqual(fn('//localhost/C:/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('//localhost/C|/path/to/file'), 'C:\\path\\to\\file')
+        self.assertEqual(fn('//localhost/path/to/file'), '\\path\\to\\file')
+        self.assertEqual(fn('//localhost//server/path/to/file'), '\\\\server\\path\\to\\file')
+        # Percent-encoded forward slashes are preserved for backwards compatibility
+        self.assertEqual(fn('C:/foo%2fbar'), 'C:\\foo/bar')
+        self.assertEqual(fn('//server/share/foo%2fbar'), '\\\\server\\share\\foo/bar')
+        # Round-tripping
+        paths = ['C:',
+                 r'\C\test\\',
+                 r'C:\foo\bar\spam.foo']
+        for path in paths:
+            self.assertEqual(fn(urllib.request.pathname2url(path)), path)
+
+    @unittest.skipIf(sys.platform == 'win32',
+                     'test specific to POSIX pathnames')
+    def test_url2pathname_posix(self):
+        fn = urllib.request.url2pathname
+        self.assertEqual(fn('/foo/bar'), '/foo/bar')
+        self.assertEqual(fn('//foo/bar'), '//foo/bar')
+        self.assertEqual(fn('///foo/bar'), '/foo/bar')
+        self.assertEqual(fn('////foo/bar'), '//foo/bar')
+        self.assertEqual(fn('//localhost/foo/bar'), '/foo/bar')
+
+    @unittest.skipUnless(os_helper.FS_NONASCII, 'need os_helper.FS_NONASCII')
+    def test_url2pathname_nonascii(self):
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        url = os_helper.FS_NONASCII
+        self.assertEqual(urllib.request.url2pathname(url), os_helper.FS_NONASCII)
+        url = urllib.parse.quote(url, encoding=encoding, errors=errors)
+        self.assertEqual(urllib.request.url2pathname(url), os_helper.FS_NONASCII)
 
 class Utility_Tests(unittest.TestCase):
     """Testcase to test the various utility functions in the urllib."""
@@ -1643,60 +1715,5 @@ def test_with_method_arg(self):
         self.assertEqual(request.get_method(), 'HEAD')
 
 
-class URL2PathNameTests(unittest.TestCase):
-
-    def test_converting_drive_letter(self):
-        self.assertEqual(url2pathname("///C|"), 'C:')
-        self.assertEqual(url2pathname("///C:"), 'C:')
-        self.assertEqual(url2pathname("///C|/"), 'C:\\')
-
-    def test_converting_when_no_drive_letter(self):
-        # cannot end a raw string in \
-        self.assertEqual(url2pathname("///C/test/"), r'\\\C\test' '\\')
-        self.assertEqual(url2pathname("////C/test/"), r'\\C\test' '\\')
-
-    def test_simple_compare(self):
-        self.assertEqual(url2pathname("///C|/foo/bar/spam.foo"),
-                         r'C:\foo\bar\spam.foo')
-
-    def test_non_ascii_drive_letter(self):
-        self.assertRaises(IOError, url2pathname, "///\u00e8|/")
-
-    def test_roundtrip_url2pathname(self):
-        list_of_paths = ['C:',
-                         r'\\\C\test\\',
-                         r'C:\foo\bar\spam.foo'
-                         ]
-        for path in list_of_paths:
-            self.assertEqual(url2pathname(pathname2url(path)), path)
-
-class PathName2URLTests(unittest.TestCase):
-
-    def test_converting_drive_letter(self):
-        self.assertEqual(pathname2url("C:"), '///C:')
-        self.assertEqual(pathname2url("C:\\"), '///C:')
-
-    def test_converting_when_no_drive_letter(self):
-        self.assertEqual(pathname2url(r"\\\folder\test" "\\"),
-                         '/////folder/test/')
-        self.assertEqual(pathname2url(r"\\folder\test" "\\"),
-                         '////folder/test/')
-        self.assertEqual(pathname2url(r"\folder\test" "\\"),
-                         '/folder/test/')
-
-    def test_simple_compare(self):
-        self.assertEqual(pathname2url(r'C:\foo\bar\spam.foo'),
-                         "///C:/foo/bar/spam.foo" )
-
-    def test_long_drive_letter(self):
-        self.assertRaises(IOError, pathname2url, "XX:\\")
-
-    def test_roundtrip_pathname2url(self):
-        list_of_paths = ['///C:',
-                         '/////folder/test/',
-                         '///C:/foo/bar/spam.foo']
-        for path in list_of_paths:
-            self.assertEqual(pathname2url(url2pathname(path)), path)
-
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
index 5a02b5db8e..263472499d 100644
--- a/Lib/test/test_urllib2.py
+++ b/Lib/test/test_urllib2.py
@@ -1,9 +1,11 @@
 import unittest
 from test import support
 from test.support import os_helper
-from test.support import socket_helper
+from test.support import requires_subprocess
 from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 from test import test_urllib
+from unittest import mock
 
 import os
 import io
@@ -14,16 +16,19 @@
 import subprocess
 
 import urllib.request
-# The proxy bypass method imported below has logic specific to the OSX
-# proxy config data structure but is testable on all platforms.
+# The proxy bypass method imported below has logic specific to the
+# corresponding system but is testable on all platforms.
 from urllib.request import (Request, OpenerDirector, HTTPBasicAuthHandler,
                             HTTPPasswordMgrWithPriorAuth, _parse_proxy,
+                            _proxy_bypass_winreg_override,
                             _proxy_bypass_macosx_sysconf,
                             AbstractDigestAuthHandler)
 from urllib.parse import urlparse
 import urllib.error
 import http.client
 
+support.requires_working_socket(module=True)
+
 # XXX
 # Request
 # CacheFTPHandler (hard to write)
@@ -483,7 +488,18 @@ def build_test_opener(*handler_instances):
     return opener
 
 
-class MockHTTPHandler(urllib.request.BaseHandler):
+class MockHTTPHandler(urllib.request.HTTPHandler):
+    # Very simple mock HTTP handler with no special behavior other than using a mock HTTP connection
+
+    def __init__(self, debuglevel=None):
+        super(MockHTTPHandler, self).__init__(debuglevel=debuglevel)
+        self.httpconn = MockHTTPClass()
+
+    def http_open(self, req):
+        return self.do_open(self.httpconn, req)
+
+
+class MockHTTPHandlerRedirect(urllib.request.BaseHandler):
     # useful for testing redirections and auth
     # sends supplied headers and code as first response
     # sends 200 OK as second response
@@ -511,16 +527,17 @@ def http_open(self, req):
             return MockResponse(200, "OK", msg, "", req.get_full_url())
 
 
-class MockHTTPSHandler(urllib.request.AbstractHTTPHandler):
-    # Useful for testing the Proxy-Authorization request by verifying the
-    # properties of httpcon
+if hasattr(http.client, 'HTTPSConnection'):
+    class MockHTTPSHandler(urllib.request.HTTPSHandler):
+        # Useful for testing the Proxy-Authorization request by verifying the
+        # properties of httpcon
 
-    def __init__(self, debuglevel=0):
-        urllib.request.AbstractHTTPHandler.__init__(self, debuglevel=debuglevel)
-        self.httpconn = MockHTTPClass()
+        def __init__(self, debuglevel=None, context=None, check_hostname=None):
+            super(MockHTTPSHandler, self).__init__(debuglevel, context, check_hostname)
+            self.httpconn = MockHTTPClass()
 
-    def https_open(self, req):
-        return self.do_open(self.httpconn, req)
+        def https_open(self, req):
+            return self.do_open(self.httpconn, req)
 
 
 class MockHTTPHandlerCheckAuth(urllib.request.BaseHandler):
@@ -641,8 +658,6 @@ def test_raise(self):
         self.assertRaises(urllib.error.URLError, o.open, req)
         self.assertEqual(o.calls, [(handlers[0], "http_open", (req,), {})])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_http_error(self):
         # XXX http_error_default
         # http errors are a special case
@@ -666,8 +681,6 @@ def test_http_error(self):
             self.assertEqual((handler, method_name), got[:2])
             self.assertEqual(args, got[2])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_processors(self):
         # *_request / *_response methods get called appropriately
         o = OpenerDirector()
@@ -705,10 +718,6 @@ def test_processors(self):
 
 
 def sanepathname2url(path):
-    try:
-        path.encode("utf-8")
-    except UnicodeEncodeError:
-        raise unittest.SkipTest("path is not encodable to utf8")
     urlpath = urllib.request.pathname2url(path)
     if os.name == "nt" and urlpath.startswith("///"):
         urlpath = urlpath[2:]
@@ -716,8 +725,9 @@ def sanepathname2url(path):
     return urlpath
 
 
-class HandlerTests(unittest.TestCase):
+class HandlerTests(unittest.TestCase, ExtraAssertions):
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: None != 'image/gif'
     def test_ftp(self):
         class MockFTPWrapper:
             def __init__(self, data):
@@ -765,7 +775,7 @@ def connect_ftp(self, user, passwd, host, port, dirs,
              ["foo", "bar"], "", None),
             ("ftp://localhost/baz.gif;type=a",
              "localhost", ftplib.FTP_PORT, "", "", "A",
-             [], "baz.gif", None),  # XXX really this should guess image/gif
+             [], "baz.gif", "image/gif"),
             ]:
             req = Request(url)
             req.timeout = None
@@ -781,6 +791,7 @@ def connect_ftp(self, user, passwd, host, port, dirs,
             headers = r.info()
             self.assertEqual(headers.get("Content-type"), mimetype)
             self.assertEqual(int(headers["Content-length"]), len(data))
+            r.close()
 
     def test_file(self):
         import email.utils
@@ -874,8 +885,6 @@ def test_file(self):
                 self.assertEqual(req.type, "ftp")
             self.assertEqual(req.type == "ftp", ftp)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_http(self):
 
         h = urllib.request.AbstractHTTPHandler()
@@ -990,6 +999,7 @@ def test_http_body_fileobj(self):
 
         file_obj.close()
 
+    @requires_subprocess()
     def test_http_body_pipe(self):
         # A file reading from a pipe.
         # A pipe cannot be seek'ed.  There is no way to determine the
@@ -1053,12 +1063,37 @@ def test_http_body_array(self):
             newreq = h.do_request_(req)
             self.assertEqual(int(newreq.get_header('Content-length')),16)
 
-    def test_http_handler_debuglevel(self):
+    def test_http_handler_global_debuglevel(self):
+        with mock.patch.object(http.client.HTTPConnection, 'debuglevel', 6):
+            o = OpenerDirector()
+            h = MockHTTPHandler()
+            o.add_handler(h)
+            o.open("http://www.example.com")
+            self.assertEqual(h._debuglevel, 6)
+
+    def test_http_handler_local_debuglevel(self):
         o = OpenerDirector()
-        h = MockHTTPSHandler(debuglevel=1)
+        h = MockHTTPHandler(debuglevel=5)
+        o.add_handler(h)
+        o.open("http://www.example.com")
+        self.assertEqual(h._debuglevel, 5)
+
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
+    def test_https_handler_global_debuglevel(self):
+        with mock.patch.object(http.client.HTTPSConnection, 'debuglevel', 7):
+            o = OpenerDirector()
+            h = MockHTTPSHandler()
+            o.add_handler(h)
+            o.open("https://www.example.com")
+            self.assertEqual(h._debuglevel, 7)
+
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
+    def test_https_handler_local_debuglevel(self):
+        o = OpenerDirector()
+        h = MockHTTPSHandler(debuglevel=4)
         o.add_handler(h)
         o.open("https://www.example.com")
-        self.assertEqual(h._debuglevel, 1)
+        self.assertEqual(h._debuglevel, 4)
 
     def test_http_doubleslash(self):
         # Checks the presence of any unnecessary double slash in url does not
@@ -1136,8 +1171,6 @@ def test_fixpath_in_weirdurls(self):
         self.assertEqual(newreq.host, 'www.python.org')
         self.assertEqual(newreq.selector, '')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_errors(self):
         h = urllib.request.HTTPErrorProcessor()
         o = h.parent = MockOpener()
@@ -1148,23 +1181,21 @@ def test_errors(self):
         r = MockResponse(200, "OK", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         r = MockResponse(202, "Accepted", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         r = MockResponse(206, "Partial content", {}, "", url)
         newr = h.http_response(req, r)
         self.assertIs(r, newr)
-        self.assertFalse(hasattr(o, "proto"))  # o.error not called
+        self.assertNotHasAttr(o, "proto")  # o.error not called
         # anything else calls o.error (and MockOpener returns None, here)
         r = MockResponse(502, "Bad gateway", {}, "", url)
         self.assertIsNone(h.http_response(req, r))
         self.assertEqual(o.proto, "http")  # o.error called
         self.assertEqual(o.args, (req, r, 502, "Bad gateway", {}))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cookies(self):
         cj = MockCookieJar()
         h = urllib.request.HTTPCookieProcessor(cj)
@@ -1189,7 +1220,7 @@ def test_redirect(self):
         o = h.parent = MockOpener()
 
         # ordinary redirect behaviour
-        for code in 301, 302, 303, 307:
+        for code in 301, 302, 303, 307, 308:
             for data in None, "blah\nblah\n":
                 method = getattr(h, "http_error_%s" % code)
                 req = Request(from_url, data)
@@ -1201,10 +1232,11 @@ def test_redirect(self):
                 try:
                     method(req, MockFile(), code, "Blah",
                            MockHeaders({"location": to_url}))
-                except urllib.error.HTTPError:
-                    # 307 in response to POST requires user OK
-                    self.assertEqual(code, 307)
+                except urllib.error.HTTPError as err:
+                    # 307 and 308 in response to POST require user OK
+                    self.assertIn(code, (307, 308))
                     self.assertIsNotNone(data)
+                    err.close()
                 self.assertEqual(o.req.get_full_url(), to_url)
                 try:
                     self.assertEqual(o.req.get_method(), "GET")
@@ -1240,9 +1272,10 @@ def redirect(h, req, url=to_url):
             while 1:
                 redirect(h, req, "http://example.com/")
                 count = count + 1
-        except urllib.error.HTTPError:
+        except urllib.error.HTTPError as err:
             # don't stop until max_repeats, because cookies may introduce state
             self.assertEqual(count, urllib.request.HTTPRedirectHandler.max_repeats)
+            err.close()
 
         # detect endless non-repeating chain of redirects
         req = Request(from_url, origin_req_host="example.com")
@@ -1252,9 +1285,10 @@ def redirect(h, req, url=to_url):
             while 1:
                 redirect(h, req, "http://example.com/%d" % count)
                 count = count + 1
-        except urllib.error.HTTPError:
+        except urllib.error.HTTPError as err:
             self.assertEqual(count,
                              urllib.request.HTTPRedirectHandler.max_redirections)
+            err.close()
 
     def test_invalid_redirect(self):
         from_url = "http://example.com/a.html"
@@ -1268,9 +1302,11 @@ def test_invalid_redirect(self):
 
         for scheme in invalid_schemes:
             invalid_url = scheme + '://' + schemeless_url
-            self.assertRaises(urllib.error.HTTPError, h.http_error_302,
+            with self.assertRaises(urllib.error.HTTPError) as cm:
+                h.http_error_302(
                     req, MockFile(), 302, "Security Loophole",
                     MockHeaders({"location": invalid_url}))
+            cm.exception.close()
 
         for scheme in valid_schemes:
             valid_url = scheme + '://' + schemeless_url
@@ -1291,8 +1327,6 @@ def test_relative_redirect(self):
             MockHeaders({"location": valid_url}))
         self.assertEqual(o.req.get_full_url(), valid_url)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cookie_redirect(self):
         # cookies shouldn't leak into redirected requests
         from http.cookiejar import CookieJar
@@ -1300,7 +1334,7 @@ def test_cookie_redirect(self):
 
         cj = CookieJar()
         interact_netscape(cj, "http://www.example.com/", "spam=eggs")
-        hh = MockHTTPHandler(302, "Location: http://www.cracker.com/\r\n\r\n")
+        hh = MockHTTPHandlerRedirect(302, "Location: http://www.cracker.com/\r\n\r\n")
         hdeh = urllib.request.HTTPDefaultErrorHandler()
         hrh = urllib.request.HTTPRedirectHandler()
         cp = urllib.request.HTTPCookieProcessor(cj)
@@ -1308,11 +1342,9 @@ def test_cookie_redirect(self):
         o.open("http://www.example.com/")
         self.assertFalse(hh.req.has_header("Cookie"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_redirect_fragment(self):
         redirected_url = 'http://www.example.com/index.html#OK\r\n\r\n'
-        hh = MockHTTPHandler(302, 'Location: ' + redirected_url)
+        hh = MockHTTPHandlerRedirect(302, 'Location: ' + redirected_url)
         hdeh = urllib.request.HTTPDefaultErrorHandler()
         hrh = urllib.request.HTTPRedirectHandler()
         o = build_test_opener(hh, hdeh, hrh)
@@ -1372,10 +1404,17 @@ def http_open(self, req):
                 response = opener.open('http://example.com/')
                 expected = b'GET ' + result + b' '
                 request = handler.last_buf
-                self.assertTrue(request.startswith(expected), repr(request))
+                self.assertStartsWith(request, expected)
+
+    def test_redirect_head_request(self):
+        from_url = "http://example.com/a.html"
+        to_url = "http://example.com/b.html"
+        h = urllib.request.HTTPRedirectHandler()
+        req = Request(from_url, method="HEAD")
+        fp = MockFile()
+        new_req = h.redirect_request(req, fp, 302, "Found", {}, to_url)
+        self.assertEqual(new_req.get_method(), "HEAD")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy(self):
         u = "proxy.example.com:3128"
         for d in dict(http=u), dict(HTTP=u):
@@ -1395,7 +1434,8 @@ def test_proxy(self):
                              [tup[0:2] for tup in o.calls])
 
     def test_proxy_no_proxy(self):
-        os.environ['no_proxy'] = 'python.org'
+        env = self.enterContext(os_helper.EnvironmentVarGuard())
+        env['no_proxy'] = 'python.org'
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com"))
         o.add_handler(ph)
@@ -1407,10 +1447,10 @@ def test_proxy_no_proxy(self):
         self.assertEqual(req.host, "www.python.org")
         o.open(req)
         self.assertEqual(req.host, "www.python.org")
-        del os.environ['no_proxy']
 
     def test_proxy_no_proxy_all(self):
-        os.environ['no_proxy'] = '*'
+        env = self.enterContext(os_helper.EnvironmentVarGuard())
+        env['no_proxy'] = '*'
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com"))
         o.add_handler(ph)
@@ -1418,10 +1458,7 @@ def test_proxy_no_proxy_all(self):
         self.assertEqual(req.host, "www.python.org")
         o.open(req)
         self.assertEqual(req.host, "www.python.org")
-        del os.environ['no_proxy']
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy_https(self):
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(https="proxy.example.com:3128"))
@@ -1438,6 +1475,7 @@ def test_proxy_https(self):
         self.assertEqual([(handlers[0], "https_open")],
                          [tup[0:2] for tup in o.calls])
 
+    @unittest.skipUnless(hasattr(http.client, 'HTTPSConnection'), 'HTTPSConnection required for HTTPS tests.')
     def test_proxy_https_proxy_authorization(self):
         o = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(https='proxy.example.com:3128'))
@@ -1461,6 +1499,30 @@ def test_proxy_https_proxy_authorization(self):
         self.assertEqual(req.host, "proxy.example.com:3128")
         self.assertEqual(req.get_header("Proxy-authorization"), "FooBar")
 
+    @unittest.skipUnless(os.name == "nt", "only relevant for Windows")
+    def test_winreg_proxy_bypass(self):
+        proxy_override = "www.example.com;*.example.net; 192.168.0.1"
+        proxy_bypass = _proxy_bypass_winreg_override
+        for host in ("www.example.com", "www.example.net", "192.168.0.1"):
+            self.assertTrue(proxy_bypass(host, proxy_override),
+                            "expected bypass of %s to be true" % host)
+
+        for host in ("example.com", "www.example.org", "example.net",
+                     "192.168.0.2"):
+            self.assertFalse(proxy_bypass(host, proxy_override),
+                             "expected bypass of %s to be False" % host)
+
+        # check intranet address bypass
+        proxy_override = "example.com; <local>"
+        self.assertTrue(proxy_bypass("example.com", proxy_override),
+                        "expected bypass of %s to be true" % host)
+        self.assertFalse(proxy_bypass("example.net", proxy_override),
+                         "expected bypass of %s to be False" % host)
+        for host in ("test", "localhost"):
+            self.assertTrue(proxy_bypass(host, proxy_override),
+                            "expect <local> to bypass intranet address '%s'"
+                            % host)
+
     @unittest.skipUnless(sys.platform == 'darwin', "only relevant for OSX")
     def test_osx_proxy_bypass(self):
         bypass = {
@@ -1501,7 +1563,7 @@ def check_basic_auth(self, headers, realm):
             password_manager = MockPasswordManager()
             auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
             body = '\r\n'.join(headers) + '\r\n\r\n'
-            http_handler = MockHTTPHandler(401, body)
+            http_handler = MockHTTPHandlerRedirect(401, body)
             opener.add_handler(auth_handler)
             opener.add_handler(http_handler)
             self._test_basic_auth(opener, auth_handler, "Authorization",
@@ -1509,8 +1571,6 @@ def check_basic_auth(self, headers, realm):
                                   "http://acme.example.com/protected",
                                   "http://acme.example.com/protected")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_auth(self):
         realm = "realm2@example.com"
         realm2 = "realm2@example.com"
@@ -1556,8 +1616,6 @@ def test_basic_auth(self):
                        for challenge in challenges]
             self.check_basic_auth(headers, realm)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_proxy_basic_auth(self):
         opener = OpenerDirector()
         ph = urllib.request.ProxyHandler(dict(http="proxy.example.com:3128"))
@@ -1565,7 +1623,7 @@ def test_proxy_basic_auth(self):
         password_manager = MockPasswordManager()
         auth_handler = urllib.request.ProxyBasicAuthHandler(password_manager)
         realm = "ACME Networks"
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             407, 'Proxy-Authenticate: Basic realm="%s"\r\n\r\n' % realm)
         opener.add_handler(auth_handler)
         opener.add_handler(http_handler)
@@ -1575,15 +1633,13 @@ def test_proxy_basic_auth(self):
                               "proxy.example.com:3128",
                               )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_and_digest_auth_handlers(self):
         # HTTPDigestAuthHandler raised an exception if it couldn't handle a 40*
-        # response (http://python.org/sf/1479302), where it should instead
+        # response (https://bugs.python.org/issue1479302), where it should instead
         # return None to allow another handler (especially
         # HTTPBasicAuthHandler) to handle the response.
 
-        # Also (http://python.org/sf/14797027, RFC 2617 section 1.2), we must
+        # Also (https://bugs.python.org/issue14797027, RFC 2617 section 1.2), we must
         # try digest first (since it's the strongest auth scheme), so we record
         # order of calls here to check digest comes first:
         class RecordingOpenerDirector(OpenerDirector):
@@ -1611,7 +1667,7 @@ def http_error_401(self, *args, **kwds):
         digest_handler = TestDigestAuthHandler(password_manager)
         basic_handler = TestBasicAuthHandler(password_manager)
         realm = "ACME Networks"
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Basic realm="%s"\r\n\r\n' % realm)
         opener.add_handler(basic_handler)
         opener.add_handler(digest_handler)
@@ -1631,7 +1687,7 @@ def test_unsupported_auth_digest_handler(self):
         opener = OpenerDirector()
         # While using DigestAuthHandler
         digest_auth_handler = urllib.request.HTTPDigestAuthHandler(None)
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Kerberos\r\n\r\n')
         opener.add_handler(digest_auth_handler)
         opener.add_handler(http_handler)
@@ -1641,7 +1697,7 @@ def test_unsupported_auth_basic_handler(self):
         # While using BasicAuthHandler
         opener = OpenerDirector()
         basic_auth_handler = urllib.request.HTTPBasicAuthHandler(None)
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: NTLM\r\n\r\n')
         opener.add_handler(basic_auth_handler)
         opener.add_handler(http_handler)
@@ -1684,8 +1740,6 @@ def _test_basic_auth(self, opener, auth_handler, auth_header,
         self.assertEqual(len(http_handler.requests), 1)
         self.assertFalse(http_handler.requests[0].has_header(auth_header))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_prior_auth_auto_send(self):
         # Assume already authenticated if is_authenticated=True
         # for APIs like Github that don't return 401
@@ -1713,8 +1767,6 @@ def test_basic_prior_auth_auto_send(self):
         # expect request to be sent with auth header
         self.assertTrue(http_handler.has_auth_header)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic_prior_auth_send_after_first_success(self):
         # Auto send auth header after authentication is successful once
 
@@ -1732,7 +1784,7 @@ def test_basic_prior_auth_send_after_first_success(self):
         opener = OpenerDirector()
         opener.add_handler(auth_prior_handler)
 
-        http_handler = MockHTTPHandler(
+        http_handler = MockHTTPHandlerRedirect(
             401, 'WWW-Authenticate: Basic realm="%s"\r\n\r\n' % None)
         opener.add_handler(http_handler)
 
@@ -1783,7 +1835,7 @@ def test_invalid_closed(self):
         self.assertTrue(conn.fakesock.closed, "Connection not closed")
 
 
-class MiscTests(unittest.TestCase):
+class MiscTests(unittest.TestCase, ExtraAssertions):
 
     def opener_has_handler(self, opener, handler_class):
         self.assertTrue(any(h.__class__ == handler_class
@@ -1842,14 +1894,21 @@ def test_HTTPError_interface(self):
         url = code = fp = None
         hdrs = 'Content-Length: 42'
         err = urllib.error.HTTPError(url, code, msg, hdrs, fp)
-        self.assertTrue(hasattr(err, 'reason'))
+        self.assertHasAttr(err, 'reason')
         self.assertEqual(err.reason, 'something bad happened')
-        self.assertTrue(hasattr(err, 'headers'))
+        self.assertHasAttr(err, 'headers')
         self.assertEqual(err.headers, 'Content-Length: 42')
         expected_errmsg = 'HTTP Error %s: %s' % (err.code, err.msg)
         self.assertEqual(str(err), expected_errmsg)
         expected_errmsg = '<HTTPError %s: %r>' % (err.code, err.msg)
         self.assertEqual(repr(err), expected_errmsg)
+        err.close()
+
+    def test_gh_98778(self):
+        x = urllib.error.HTTPError("url", 405, "METHOD NOT ALLOWED", None, None)
+        self.assertEqual(getattr(x, "__notes__", ()), ())
+        self.assertIsInstance(x.fp.read(), bytes)
+        x.close()
 
     def test_parse_proxy(self):
         parse_proxy_test_cases = [
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
index 3d5ca2faab..9a89978511 100644
--- a/Lib/test/test_urllib2_localnet.py
+++ b/Lib/test/test_urllib2_localnet.py
@@ -8,20 +8,23 @@
 import unittest
 import hashlib
 
+from test import support
 from test.support import hashlib_helper
 from test.support import threading_helper
-from test.support import warnings_helper
+from test.support.testcase import ExtraAssertions
 
 try:
     import ssl
 except ImportError:
     ssl = None
 
+support.requires_working_socket(module=True)
+
 here = os.path.dirname(__file__)
 # Self-signed cert file for 'localhost'
-CERT_localhost = os.path.join(here, 'keycert.pem')
+CERT_localhost = os.path.join(here, 'certdata', 'keycert.pem')
 # Self-signed cert file for 'fakehostname'
-CERT_fakehostname = os.path.join(here, 'keycert2.pem')
+CERT_fakehostname = os.path.join(here, 'certdata', 'keycert2.pem')
 
 
 # Loopback http server infrastructure
@@ -314,7 +317,9 @@ def test_basic_auth_httperror(self):
         ah = urllib.request.HTTPBasicAuthHandler()
         ah.add_password(self.REALM, self.server_url, self.USER, self.INCORRECT_PASSWD)
         urllib.request.install_opener(urllib.request.build_opener(ah))
-        self.assertRaises(urllib.error.HTTPError, urllib.request.urlopen, self.server_url)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            urllib.request.urlopen(self.server_url)
+        cm.exception.close()
 
 
 @hashlib_helper.requires_hashdigest("md5", openssl=True)
@@ -356,23 +361,23 @@ def stop_server(self):
         self.server.stop()
         self.server = None
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_with_bad_password_raises_httperror(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD+"bad")
         self.digest_auth_handler.set_qop("auth")
-        self.assertRaises(urllib.error.HTTPError,
-                          self.opener.open,
-                          self.URL)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            self.opener.open(self.URL)
+        cm.exception.close()
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_with_no_password_raises_httperror(self):
         self.digest_auth_handler.set_qop("auth")
-        self.assertRaises(urllib.error.HTTPError,
-                          self.opener.open,
-                          self.URL)
+        with self.assertRaises(urllib.error.HTTPError) as cm:
+            self.opener.open(self.URL)
+        cm.exception.close()
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_qop_auth_works(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD)
@@ -381,7 +386,7 @@ def test_proxy_qop_auth_works(self):
             while result.read():
                 pass
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_proxy_qop_auth_int_works_or_throws_urlerror(self):
         self.proxy_digest_handler.add_password(self.REALM, self.URL,
                                                self.USER, self.PASSWD)
@@ -442,7 +447,7 @@ def log_message(self, *args):
     return FakeHTTPRequestHandler
 
 
-class TestUrlopen(unittest.TestCase):
+class TestUrlopen(unittest.TestCase, ExtraAssertions):
     """Tests urllib.request.urlopen using the network.
 
     These tests are not exhaustive.  Assuming that testing using files does a
@@ -506,7 +511,7 @@ def start_https_server(self, responses=None, **kwargs):
         handler.port = server.port
         return handler
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_redirection(self):
         expected_response = b"We got here..."
         responses = [
@@ -520,7 +525,7 @@ def test_redirection(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/", "/somewhere_else"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_chunked(self):
         expected_response = b"hello world"
         chunked_start = (
@@ -535,7 +540,7 @@ def test_chunked(self):
         data = self.urlopen("http://localhost:%s/" % handler.port)
         self.assertEqual(data, expected_response)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_404(self):
         expected_response = b"Bad bad bad..."
         handler = self.start_server([(404, [], expected_response)])
@@ -551,7 +556,7 @@ def test_404(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/weeble"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_200(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -559,7 +564,7 @@ def test_200(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/bizarre"])
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_200_with_parameters(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -568,47 +573,14 @@ def test_200_with_parameters(self):
         self.assertEqual(data, expected_response)
         self.assertEqual(handler.requests, ["/bizarre", b"get=with_feeling"])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_https(self):
         handler = self.start_https_server()
         context = ssl.create_default_context(cafile=CERT_localhost)
         data = self.urlopen("https://localhost:%s/bizarre" % handler.port, context=context)
         self.assertEqual(data, b"we care a bit")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
-    def test_https_with_cafile(self):
-        handler = self.start_https_server(certfile=CERT_localhost)
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            # Good cert
-            data = self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                                cafile=CERT_localhost)
-            self.assertEqual(data, b"we care a bit")
-            # Bad cert
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cafile=CERT_fakehostname)
-            # Good cert, but mismatching hostname
-            handler = self.start_https_server(certfile=CERT_fakehostname)
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cafile=CERT_fakehostname)
-
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
-    def test_https_with_cadefault(self):
-        handler = self.start_https_server(certfile=CERT_localhost)
-        # Self-signed cert should fail verification with system certificate store
-        with warnings_helper.check_warnings(('', DeprecationWarning)):
-            with self.assertRaises(urllib.error.URLError) as cm:
-                self.urlopen("https://localhost:%s/bizarre" % handler.port,
-                             cadefault=True)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_https_sni(self):
         if ssl is None:
             self.skipTest("ssl module required")
@@ -625,7 +597,7 @@ def cb_sni(ssl_sock, server_name, initial_context):
         self.urlopen("https://localhost:%s" % handler.port, context=context)
         self.assertEqual(sni_name, "localhost")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_sending_headers(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -634,7 +606,7 @@ def test_sending_headers(self):
             pass
         self.assertEqual(handler.headers_received["Range"], "bytes=20-39")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_sending_headers_camel(self):
         handler = self.start_server()
         req = urllib.request.Request("http://localhost:%s/" % handler.port,
@@ -644,16 +616,15 @@ def test_sending_headers_camel(self):
         self.assertIn("X-Some-Header", handler.headers_received.keys())
         self.assertNotIn("X-SoMe-hEader", handler.headers_received.keys())
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_basic(self):
         handler = self.start_server()
         with urllib.request.urlopen("http://localhost:%s" % handler.port) as open_url:
             for attr in ("read", "close", "info", "geturl"):
-                self.assertTrue(hasattr(open_url, attr), "object returned from "
-                             "urlopen lacks the %s attribute" % attr)
+                self.assertHasAttr(open_url, attr)
             self.assertTrue(open_url.read(), "calling 'read' failed")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_info(self):
         handler = self.start_server()
         open_url = urllib.request.urlopen(
@@ -665,7 +636,7 @@ def test_info(self):
                               "instance of email.message.Message")
         self.assertEqual(info_obj.get_content_subtype(), "plain")
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_geturl(self):
         # Make sure same URL as opened is returned by geturl.
         handler = self.start_server()
@@ -674,7 +645,7 @@ def test_geturl(self):
             url = open_url.geturl()
         self.assertEqual(url, "http://localhost:%s" % handler.port)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_iteration(self):
         expected_response = b"pycon 2008..."
         handler = self.start_server([(200, [], expected_response)])
@@ -682,7 +653,7 @@ def test_iteration(self):
         for line in data:
             self.assertEqual(line, expected_response)
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_line_iteration(self):
         lines = [b"We\n", b"got\n", b"here\n", b"verylong " * 8192 + b"\n"]
         expected_response = b"".join(lines)
@@ -695,7 +666,7 @@ def test_line_iteration(self):
                              (index, len(lines[index]), len(line)))
         self.assertEqual(index + 1, len(lines))
 
-    @unittest.skipIf(os.name == "nt", "TODO: RUSTPYTHON, ValueError: illegal environment variable name")
+    @unittest.skipIf(os.name == 'nt', 'TODO: RUSTPYTHON; ValueError: illegal environment variable name')
     def test_issue16464(self):
         # See https://bugs.python.org/issue16464
         # and https://bugs.python.org/issue46648
@@ -715,6 +686,7 @@ def test_issue16464(self):
         self.assertEqual(b"1234567890", request.data)
         self.assertEqual("10", request.get_header("Content-length"))
 
+
 def setUpModule():
     thread_info = threading_helper.threading_setup()
     unittest.addModuleCleanup(threading_helper.threading_cleanup, *thread_info)
diff --git a/Lib/test/test_urllib2net.py b/Lib/test/test_urllib2net.py
index a7e7c9f0b9..41f170a6ad 100644
--- a/Lib/test/test_urllib2net.py
+++ b/Lib/test/test_urllib2net.py
@@ -1,10 +1,14 @@
+import contextlib
 import errno
+import sysconfig
 import unittest
+from unittest import mock
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
 from test.support import ResourceDenied
 from test.test_urllib2 import sanepathname2url
+from test.support.warnings_helper import check_no_resource_warning
 
 import os
 import socket
@@ -29,13 +33,6 @@ def wrapped(*args, **kwargs):
         return _retry_thrice(func, exc, *args, **kwargs)
     return wrapped
 
-# bpo-35411: FTP tests of test_urllib2net randomly fail
-# with "425 Security: Bad IP connecting" on Travis CI
-skip_ftp_test_on_travis = unittest.skipIf('TRAVIS' in os.environ,
-                                          'bpo-35411: skip FTP test '
-                                          'on Travis CI')
-
-
 # Connecting to remote hosts is flaky.  Make it more robust by retrying
 # the connection several times.
 _urlopen_with_retry = _wrap_with_retry_thrice(urllib.request.urlopen,
@@ -140,15 +137,54 @@ def setUp(self):
     # XXX The rest of these tests aren't very good -- they don't check much.
     # They do sometimes catch some major disasters, though.
 
-    @skip_ftp_test_on_travis
+    @support.requires_resource('walltime')
     def test_ftp(self):
+        # Testing the same URL twice exercises the caching in CacheFTPHandler
         urls = [
+            'ftp://www.pythontest.net/README',
             'ftp://www.pythontest.net/README',
             ('ftp://www.pythontest.net/non-existent-file',
              None, urllib.error.URLError),
             ]
         self._test_urls(urls, self._extra_handlers())
 
+    @support.requires_resource('walltime')
+    @unittest.skipIf(sysconfig.get_platform() == 'linux-ppc64le',
+                     'leaks on PPC64LE (gh-140691)')
+    def test_ftp_no_leak(self):
+        # gh-140691: When the data connection (but not control connection)
+        # cannot be made established, we shouldn't leave an open socket object.
+
+        class MockError(OSError):
+            pass
+
+        orig_create_connection = socket.create_connection
+        def patched_create_connection(address, *args, **kwargs):
+            """Simulate REJECTing connections to ports other than 21"""
+            host, port = address
+            if port != 21:
+                raise MockError()
+            return orig_create_connection(address, *args, **kwargs)
+
+        url = 'ftp://www.pythontest.net/README'
+        entry = url, None, urllib.error.URLError
+        no_cache_handlers = [urllib.request.FTPHandler()]
+        cache_handlers = self._extra_handlers()
+        with mock.patch('socket.create_connection', patched_create_connection):
+            with check_no_resource_warning(self):
+                # Try without CacheFTPHandler
+                self._test_urls([entry], handlers=no_cache_handlers,
+                                retry=False)
+            with check_no_resource_warning(self):
+                # Try with CacheFTPHandler (uncached)
+                self._test_urls([entry], cache_handlers, retry=False)
+            with check_no_resource_warning(self):
+                # Try with CacheFTPHandler (cached)
+                self._test_urls([entry], cache_handlers, retry=False)
+        # Try without the mock: the handler should not use a closed connection
+        with check_no_resource_warning(self):
+            self._test_urls([url], cache_handlers, retry=False)
+
     def test_file(self):
         TESTFN = os_helper.TESTFN
         f = open(TESTFN, 'w')
@@ -202,6 +238,7 @@ def test_urlwithfrag(self):
             self.assertEqual(res.geturl(),
                     "http://www.pythontest.net/index.html#frag")
 
+    @support.requires_resource('walltime')
     def test_redirect_url_withfrag(self):
         redirect_url_with_frag = "http://www.pythontest.net/redir/with_frag/"
         with socket_helper.transient_internet(redirect_url_with_frag):
@@ -260,18 +297,16 @@ def _test_urls(self, urls, handlers, retry=True):
                 else:
                     req = expected_err = None
 
+                if expected_err:
+                    context = self.assertRaises(expected_err)
+                else:
+                    context = contextlib.nullcontext()
+
                 with socket_helper.transient_internet(url):
-                    try:
+                    f = None
+                    with context:
                         f = urlopen(url, req, support.INTERNET_TIMEOUT)
-                    # urllib.error.URLError is a subclass of OSError
-                    except OSError as err:
-                        if expected_err:
-                            msg = ("Didn't get expected error(s) %s for %s %s, got %s: %s" %
-                                   (expected_err, url, req, type(err), err))
-                            self.assertIsInstance(err, expected_err, msg)
-                        else:
-                            raise
-                    else:
+                    if f is not None:
                         try:
                             with time_out, \
                                  socket_peer_reset, \
@@ -340,7 +375,7 @@ def test_http_timeout(self):
 
     FTP_HOST = 'ftp://www.pythontest.net/'
 
-    @skip_ftp_test_on_travis
+    @support.requires_resource('walltime')
     def test_ftp_basic(self):
         self.assertIsNone(socket.getdefaulttimeout())
         with socket_helper.transient_internet(self.FTP_HOST, timeout=None):
@@ -348,7 +383,6 @@ def test_ftp_basic(self):
             self.addCleanup(u.close)
             self.assertIsNone(u.fp.fp.raw._sock.gettimeout())
 
-    @skip_ftp_test_on_travis
     def test_ftp_default_timeout(self):
         self.assertIsNone(socket.getdefaulttimeout())
         with socket_helper.transient_internet(self.FTP_HOST):
@@ -360,7 +394,7 @@ def test_ftp_default_timeout(self):
                 socket.setdefaulttimeout(None)
             self.assertEqual(u.fp.fp.raw._sock.gettimeout(), 60)
 
-    @skip_ftp_test_on_travis
+    @support.requires_resource('walltime')
     def test_ftp_no_timeout(self):
         self.assertIsNone(socket.getdefaulttimeout())
         with socket_helper.transient_internet(self.FTP_HOST):
@@ -372,7 +406,7 @@ def test_ftp_no_timeout(self):
                 socket.setdefaulttimeout(None)
             self.assertIsNone(u.fp.fp.raw._sock.gettimeout())
 
-    @skip_ftp_test_on_travis
+    @support.requires_resource('walltime')
     def test_ftp_timeout(self):
         with socket_helper.transient_internet(self.FTP_HOST):
             u = _urlopen_with_retry(self.FTP_HOST, timeout=60)
diff --git a/Lib/test/test_urllib_response.py b/Lib/test/test_urllib_response.py
index 73d2ef0424..d949fa38bf 100644
--- a/Lib/test/test_urllib_response.py
+++ b/Lib/test/test_urllib_response.py
@@ -4,6 +4,11 @@
 import tempfile
 import urllib.response
 import unittest
+from test import support
+
+if support.is_wasi:
+    raise unittest.SkipTest("Cannot create socket on WASI")
+
 
 class TestResponse(unittest.TestCase):
 
@@ -43,6 +48,7 @@ def test_addinfo(self):
         info = urllib.response.addinfo(self.fp, self.test_headers)
         self.assertEqual(info.info(), self.test_headers)
         self.assertEqual(info.headers, self.test_headers)
+        info.close()
 
     def test_addinfourl(self):
         url = "http://www.python.org"
@@ -55,6 +61,7 @@ def test_addinfourl(self):
         self.assertEqual(infourl.headers, self.test_headers)
         self.assertEqual(infourl.url, url)
         self.assertEqual(infourl.status, code)
+        infourl.close()
 
     def tearDown(self):
         self.sock.close()
diff --git a/Lib/test/test_urllibnet.py b/Lib/test/test_urllibnet.py
index 773101ce41..6733fe9c6e 100644
--- a/Lib/test/test_urllibnet.py
+++ b/Lib/test/test_urllibnet.py
@@ -2,6 +2,7 @@
 from test import support
 from test.support import os_helper
 from test.support import socket_helper
+from test.support.testcase import ExtraAssertions
 
 import contextlib
 import socket
@@ -34,7 +35,7 @@ def testURLread(self):
             f.read()
 
 
-class urlopenNetworkTests(unittest.TestCase):
+class urlopenNetworkTests(unittest.TestCase, ExtraAssertions):
     """Tests urllib.request.urlopen using the network.
 
     These tests are not exhaustive.  Assuming that testing using files does a
@@ -70,8 +71,7 @@ def test_basic(self):
         with self.urlopen(self.url) as open_url:
             for attr in ("read", "readline", "readlines", "fileno", "close",
                          "info", "geturl"):
-                self.assertTrue(hasattr(open_url, attr), "object returned from "
-                                "urlopen lacks the %s attribute" % attr)
+                self.assertHasAttr(open_url, attr)
             self.assertTrue(open_url.read(), "calling 'read' failed")
 
     def test_readlines(self):
@@ -109,6 +109,7 @@ def test_getcode(self):
                 open_url.close()
             self.assertEqual(code, 404)
 
+    @support.requires_resource('walltime')
     def test_bad_address(self):
         # Make sure proper exception is raised when connecting to a bogus
         # address.
@@ -191,6 +192,7 @@ def test_header(self):
 
     logo = "http://www.pythontest.net/"
 
+    @support.requires_resource('walltime')
     def test_data_header(self):
         with self.urlretrieve(self.logo) as (file_location, fileheaders):
             datevalue = fileheaders.get('Date')
diff --git a/Lib/test/test_userdict.py b/Lib/test/test_userdict.py
index 483910aaa4..61e79f553e 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
+from test import mapping_tests, support
 import unittest
 import collections
 
@@ -213,6 +213,11 @@ 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,
+    )
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_userlist.py b/Lib/test/test_userlist.py
index 1ed67dac80..312702c8e3 100644
--- a/Lib/test/test_userlist.py
+++ b/Lib/test/test_userlist.py
@@ -3,6 +3,8 @@
 from collections import UserList
 from test import list_tests
 import unittest
+from test import support
+
 
 class UserListTest(list_tests.CommonTest):
     type2test = UserList
@@ -65,5 +67,11 @@ def test_userlist_copy(self):
         self.assertEqual(u, v)
         self.assertEqual(type(u), type(v))
 
+    # 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,
+    )
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_userstring.py b/Lib/test/test_userstring.py
index 51b4f6041e..74df52f541 100644
--- a/Lib/test/test_userstring.py
+++ b/Lib/test/test_userstring.py
@@ -7,8 +7,7 @@
 from collections import UserString
 
 class UserStringTest(
-    string_tests.CommonTest,
-    string_tests.MixinStrUnicodeUserStringTest,
+    string_tests.StringLikeTest,
     unittest.TestCase
     ):
 
diff --git a/Lib/test/test_uuid.py b/Lib/test/test_uuid.py
index 069221ae47..ce396aa942 100644
--- a/Lib/test/test_uuid.py
+++ b/Lib/test/test_uuid.py
@@ -1,6 +1,7 @@
 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
@@ -32,8 +33,6 @@ def get_command_stdout(command, args):
 class BaseTestUUID:
     uuid = None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_safe_uuid_enum(self):
         class CheckedSafeUUID(enum.Enum):
             safe = 0
@@ -775,10 +774,37 @@ def test_cli_uuid5_ouputted_with_valid_namespace_and_name(self):
 class TestUUIDWithoutExtModule(BaseTestUUID, unittest.TestCase):
     uuid = py_uuid
 
+
 @unittest.skipUnless(c_uuid, 'requires the C _uuid module')
 class TestUUIDWithExtModule(BaseTestUUID, unittest.TestCase):
     uuid = c_uuid
 
+    def check_has_stable_libuuid_extractable_node(self):
+        if not self.uuid._has_stable_extractable_node:
+            self.skipTest("libuuid cannot deduce MAC address")
+
+    @unittest.skipUnless(os.name == 'posix', 'POSIX only')
+    def test_unix_getnode_from_libuuid(self):
+        self.check_has_stable_libuuid_extractable_node()
+        script = 'import uuid; print(uuid._unix_getnode())'
+        _, n_a, _ = assert_python_ok('-c', script)
+        _, n_b, _ = assert_python_ok('-c', script)
+        n_a, n_b = n_a.decode().strip(), n_b.decode().strip()
+        self.assertTrue(n_a.isdigit())
+        self.assertTrue(n_b.isdigit())
+        self.assertEqual(n_a, n_b)
+
+    @unittest.skipUnless(os.name == 'nt', 'Windows only')
+    def test_windows_getnode_from_libuuid(self):
+        self.check_has_stable_libuuid_extractable_node()
+        script = 'import uuid; print(uuid._windll_getnode())'
+        _, n_a, _ = assert_python_ok('-c', script)
+        _, n_b, _ = assert_python_ok('-c', script)
+        n_a, n_b = n_a.decode().strip(), n_b.decode().strip()
+        self.assertTrue(n_a.isdigit())
+        self.assertTrue(n_b.isdigit())
+        self.assertEqual(n_a, n_b)
+
 
 class BaseTestInternals:
     _uuid = py_uuid
diff --git a/Lib/test/test_venv.py b/Lib/test/test_venv.py
index 94d626598b..19b1207053 100644
--- a/Lib/test/test_venv.py
+++ b/Lib/test/test_venv.py
@@ -5,21 +5,31 @@
 Licensed to the PSF under a contributor agreement.
 """
 
+import contextlib
 import ensurepip
 import os
 import os.path
+import pathlib
 import re
 import shutil
 import struct
 import subprocess
 import sys
+import sysconfig
 import tempfile
-from test.support import (captured_stdout, captured_stderr, requires_zlib,
-                          skip_if_broken_multiprocessing_synchronize)
-from test.support.os_helper import (can_symlink, EnvironmentVarGuard, rmtree)
+import shlex
+from test.support import (captured_stdout, captured_stderr,
+                          skip_if_broken_multiprocessing_synchronize, verbose,
+                          requires_subprocess, is_android, is_apple_mobile,
+                          is_emscripten, is_wasi,
+                          requires_venv_with_pip, TEST_HOME_DIR,
+                          requires_resource, copy_python_src_ignore)
+from test.support.os_helper import (can_symlink, EnvironmentVarGuard, rmtree,
+                                    TESTFN, FakePath)
+from test.support.testcase import ExtraAssertions
 import unittest
 import venv
-from unittest.mock import patch
+from unittest.mock import patch, Mock
 
 try:
     import ctypes
@@ -33,18 +43,29 @@
     or sys._base_executable != sys.executable,
     'cannot run venv.create from within a venv on this platform')
 
+if is_android or is_apple_mobile or is_emscripten or is_wasi:
+    raise unittest.SkipTest("venv is not available on this platform")
+
+@requires_subprocess()
 def check_output(cmd, encoding=None):
     p = subprocess.Popen(cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
-        encoding=encoding)
+        env={**os.environ, "PYTHONHOME": ""})
     out, err = p.communicate()
     if p.returncode:
+        if verbose and err:
+            print(err.decode(encoding or 'utf-8', 'backslashreplace'))
         raise subprocess.CalledProcessError(
             p.returncode, cmd, out, err)
+    if encoding:
+        return (
+            out.decode(encoding, 'backslashreplace'),
+            err.decode(encoding, 'backslashreplace'),
+        )
     return out, err
 
-class BaseTest(unittest.TestCase):
+class BaseTest(unittest.TestCase, ExtraAssertions):
     """Base class for venv tests."""
     maxDiff = 80 * 50
 
@@ -56,7 +77,7 @@ def setUp(self):
             self.include = 'Include'
         else:
             self.bindir = 'bin'
-            self.lib = ('lib', 'python%d.%d' % sys.version_info[:2])
+            self.lib = ('lib', f'python{sysconfig._get_python_version_abi()}')
             self.include = 'include'
         executable = sys._base_executable
         self.exe = os.path.split(executable)[-1]
@@ -70,6 +91,13 @@ def setUp(self):
     def tearDown(self):
         rmtree(self.env_dir)
 
+    def envpy(self, *, real_env_dir=False):
+        if real_env_dir:
+            env_dir = os.path.realpath(self.env_dir)
+        else:
+            env_dir = self.env_dir
+        return os.path.join(env_dir, self.bindir, self.exe)
+
     def run_with_capture(self, func, *args, **kwargs):
         with captured_stdout() as output:
             with captured_stderr() as error:
@@ -91,12 +119,27 @@ def isdir(self, *args):
         fn = self.get_env_file(*args)
         self.assertTrue(os.path.isdir(fn))
 
-    def test_defaults(self):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_defaults_with_str_path(self):
         """
-        Test the create function with default arguments.
+        Test the create function with default arguments and a str path.
         """
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
+        self._check_output_of_default_create()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_defaults_with_pathlike(self):
+        """
+        Test the create function with default arguments and a path-like path.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, FakePath(self.env_dir))
+        self._check_output_of_default_create()
+
+    def _check_output_of_default_create(self):
         self.isdir(self.bindir)
         self.isdir(self.include)
         self.isdir(*self.lib)
@@ -112,6 +155,12 @@ def test_defaults(self):
         executable = sys._base_executable
         path = os.path.dirname(executable)
         self.assertIn('home = %s' % path, data)
+        self.assertIn('executable = %s' %
+                      os.path.realpath(sys.executable), data)
+        copies = '' if os.name=='nt' else ' --copies'
+        cmd = (f'command = {sys.executable} -m venv{copies} --without-pip '
+               f'--without-scm-ignore-files {self.env_dir}')
+        self.assertIn(cmd, data)
         fn = self.get_env_file(self.bindir, self.exe)
         if not os.path.exists(fn):  # diagnostics for Windows buildbot failures
             bd = self.get_env_file(self.bindir)
@@ -119,6 +168,39 @@ def test_defaults(self):
             print('    %r' % os.listdir(bd))
         self.assertTrue(os.path.exists(fn), 'File %r should exist.' % fn)
 
+    def test_config_file_command_key(self):
+        options = [
+            (None, None, None),  # Default case.
+            ('--copies', 'symlinks', False),
+            ('--without-pip', 'with_pip', False),
+            ('--system-site-packages', 'system_site_packages', True),
+            ('--clear', 'clear', True),
+            ('--upgrade', 'upgrade', True),
+            ('--upgrade-deps', 'upgrade_deps', True),
+            ('--prompt="foobar"', 'prompt', 'foobar'),
+            ('--without-scm-ignore-files', 'scm_ignore_files', frozenset()),
+        ]
+        for opt, attr, value in options:
+            with self.subTest(opt=opt, attr=attr, value=value):
+                rmtree(self.env_dir)
+                if not attr:
+                    kwargs = {}
+                else:
+                    kwargs = {attr: value}
+                b = venv.EnvBuilder(**kwargs)
+                b.upgrade_dependencies = Mock() # avoid pip command to upgrade deps
+                b._setup_pip = Mock() # avoid pip setup
+                self.run_with_capture(b.create, self.env_dir)
+                data = self.get_text_file_contents('pyvenv.cfg')
+                if not attr or opt.endswith('git'):
+                    for opt in ('--system-site-packages', '--clear', '--upgrade',
+                                '--upgrade-deps', '--prompt'):
+                        self.assertNotRegex(data, rf'command = .* {opt}')
+                elif os.name=='nt' and attr=='symlinks':
+                    pass
+                else:
+                    self.assertRegex(data, rf'command = .* {opt}')
+
     def test_prompt(self):
         env_name = os.path.split(self.env_dir)[1]
 
@@ -127,7 +209,7 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(%s) ' % env_name)
+        self.assertEqual(context.prompt, env_name)
         self.assertNotIn("prompt = ", data)
 
         rmtree(self.env_dir)
@@ -135,7 +217,7 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(My prompt) ')
+        self.assertEqual(context.prompt, 'My prompt')
         self.assertIn("prompt = 'My prompt'\n", data)
 
         rmtree(self.env_dir)
@@ -144,13 +226,19 @@ def test_prompt(self):
         self.run_with_capture(builder.create, self.env_dir)
         context = builder.ensure_directories(self.env_dir)
         data = self.get_text_file_contents('pyvenv.cfg')
-        self.assertEqual(context.prompt, '(%s) ' % cwd)
+        self.assertEqual(context.prompt, cwd)
         self.assertIn("prompt = '%s'\n" % cwd, data)
 
     def test_upgrade_dependencies(self):
         builder = venv.EnvBuilder()
-        bin_path = 'Scripts' if sys.platform == 'win32' else 'bin'
+        bin_path = 'bin'
         python_exe = os.path.split(sys.executable)[1]
+        if sys.platform == 'win32':
+            bin_path = 'Scripts'
+            if os.path.normcase(os.path.splitext(python_exe)[0]).endswith('_d'):
+                python_exe = 'python_d.exe'
+            else:
+                python_exe = 'python.exe'
         with tempfile.TemporaryDirectory() as fake_env_dir:
             expect_exe = os.path.normcase(
                 os.path.join(fake_env_dir, bin_path, python_exe)
@@ -158,7 +246,7 @@ def test_upgrade_dependencies(self):
             if sys.platform == 'win32':
                 expect_exe = os.path.normcase(os.path.realpath(expect_exe))
 
-            def pip_cmd_checker(cmd):
+            def pip_cmd_checker(cmd, **kwargs):
                 cmd[0] = os.path.normcase(cmd[0])
                 self.assertEqual(
                     cmd,
@@ -169,12 +257,11 @@ def pip_cmd_checker(cmd):
                         'install',
                         '--upgrade',
                         'pip',
-                        'setuptools'
                     ]
                 )
 
             fake_context = builder.ensure_directories(fake_env_dir)
-            with patch('venv.subprocess.check_call', pip_cmd_checker):
+            with patch('venv.subprocess.check_output', pip_cmd_checker):
                 builder.upgrade_dependencies(fake_context)
 
     @requireVenvCreate
@@ -185,8 +272,7 @@ def test_prefixes(self):
         # check a venv's prefixes
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(self.env_dir, self.bindir, self.exe)
-        cmd = [envpy, '-c', None]
+        cmd = [self.envpy(), '-c', None]
         for prefix, expected in (
             ('prefix', self.env_dir),
             ('exec_prefix', self.env_dir),
@@ -194,7 +280,76 @@ def test_prefixes(self):
             ('base_exec_prefix', sys.base_exec_prefix)):
             cmd[2] = 'import sys; print(sys.%s)' % prefix
             out, err = check_output(cmd)
-            self.assertEqual(out.strip(), expected.encode())
+            self.assertEqual(pathlib.Path(out.strip().decode()),
+                             pathlib.Path(expected), prefix)
+
+    @requireVenvCreate
+    def test_sysconfig(self):
+        """
+        Test that the sysconfig functions work in a virtual environment.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir, symlinks=False)
+        cmd = [self.envpy(), '-c', None]
+        for call, expected in (
+            # installation scheme
+            ('get_preferred_scheme("prefix")', 'venv'),
+            ('get_default_scheme()', 'venv'),
+            # build environment
+            ('is_python_build()', str(sysconfig.is_python_build())),
+            ('get_makefile_filename()', sysconfig.get_makefile_filename()),
+            ('get_config_h_filename()', sysconfig.get_config_h_filename()),
+            ('get_config_var("Py_GIL_DISABLED")',
+             str(sysconfig.get_config_var("Py_GIL_DISABLED")))):
+            with self.subTest(call):
+                cmd[2] = 'import sysconfig; print(sysconfig.%s)' % call
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+        for attr, expected in (
+            ('executable', self.envpy()),
+            # Usually compare to sys.executable, but if we're running in our own
+            # venv then we really need to compare to our base executable
+            ('_base_executable', sys._base_executable),
+        ):
+            with self.subTest(attr):
+                cmd[2] = f'import sys; print(sys.{attr})'
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+
+    @requireVenvCreate
+    @unittest.skipUnless(can_symlink(), 'Needs symlinks')
+    def test_sysconfig_symlinks(self):
+        """
+        Test that the sysconfig functions work in a virtual environment.
+        """
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir, symlinks=True)
+        cmd = [self.envpy(), '-c', None]
+        for call, expected in (
+            # installation scheme
+            ('get_preferred_scheme("prefix")', 'venv'),
+            ('get_default_scheme()', 'venv'),
+            # build environment
+            ('is_python_build()', str(sysconfig.is_python_build())),
+            ('get_makefile_filename()', sysconfig.get_makefile_filename()),
+            ('get_config_h_filename()', sysconfig.get_config_h_filename()),
+            ('get_config_var("Py_GIL_DISABLED")',
+             str(sysconfig.get_config_var("Py_GIL_DISABLED")))):
+            with self.subTest(call):
+                cmd[2] = 'import sysconfig; print(sysconfig.%s)' % call
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
+        for attr, expected in (
+            ('executable', self.envpy()),
+            # Usually compare to sys.executable, but if we're running in our own
+            # venv then we really need to compare to our base executable
+            # HACK: Test fails on POSIX with unversioned binary (PR gh-113033)
+            #('_base_executable', sys._base_executable),
+        ):
+            with self.subTest(attr):
+                cmd[2] = f'import sys; print(sys.{attr})'
+                out, err = check_output(cmd, encoding='utf-8')
+                self.assertEqual(out.strip(), expected, err)
 
     if sys.platform == 'win32':
         ENV_SUBDIRS = (
@@ -259,6 +414,8 @@ def test_unoverwritable_fails(self):
             self.assertRaises((ValueError, OSError), venv.create, self.env_dir)
             self.clear_directory(self.env_dir)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_upgrade(self):
         """
         Test upgrading an existing environment directory.
@@ -321,8 +478,7 @@ def test_executable(self):
         """
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
+        envpy = self.envpy(real_env_dir=True)
         out, err = check_output([envpy, '-c',
             'import sys; print(sys.executable)'])
         self.assertEqual(out.strip(), envpy.encode())
@@ -335,12 +491,89 @@ def test_executable_symlinks(self):
         rmtree(self.env_dir)
         builder = venv.EnvBuilder(clear=True, symlinks=True)
         builder.create(self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
+        envpy = self.envpy(real_env_dir=True)
         out, err = check_output([envpy, '-c',
             'import sys; print(sys.executable)'])
         self.assertEqual(out.strip(), envpy.encode())
 
+    # gh-124651: test quoted strings
+    @unittest.skipIf(os.name == 'nt', 'contains invalid characters on Windows')
+    def test_special_chars_bash(self):
+        """
+        Test that the template strings are quoted properly (bash)
+        """
+        rmtree(self.env_dir)
+        bash = shutil.which('bash')
+        if bash is None:
+            self.skipTest('bash required for this test')
+        env_name = '"\';&&$e|\'"'
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate')
+        test_script = os.path.join(self.env_dir, 'test_special_chars.sh')
+        with open(test_script, "w") as f:
+            f.write(f'source {shlex.quote(activate)}\n'
+                    'python -c \'import sys; print(sys.executable)\'\n'
+                    'python -c \'import os; print(os.environ["VIRTUAL_ENV"])\'\n'
+                    'deactivate\n')
+        out, err = check_output([bash, test_script])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
+    # gh-124651: test quoted strings
+    @unittest.skipIf(os.name == 'nt', 'contains invalid characters on Windows')
+    @unittest.skipIf(sys.platform.startswith('netbsd'),
+                     "NetBSD csh fails with quoted special chars; see gh-139308")
+    def test_special_chars_csh(self):
+        """
+        Test that the template strings are quoted properly (csh)
+        """
+        rmtree(self.env_dir)
+        csh = shutil.which('tcsh') or shutil.which('csh')
+        if csh is None:
+            self.skipTest('csh required for this test')
+        env_name = '"\';&&$e|\'"'
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate.csh')
+        test_script = os.path.join(self.env_dir, 'test_special_chars.csh')
+        with open(test_script, "w") as f:
+            f.write(f'source {shlex.quote(activate)}\n'
+                    'python -c \'import sys; print(sys.executable)\'\n'
+                    'python -c \'import os; print(os.environ["VIRTUAL_ENV"])\'\n'
+                    'deactivate\n')
+        out, err = check_output([csh, test_script])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
+    # gh-124651: test quoted strings on Windows
+    @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
+    def test_special_chars_windows(self):
+        """
+        Test that the template strings are quoted properly on Windows
+        """
+        rmtree(self.env_dir)
+        env_name = "'&&^$e"
+        env_dir = os.path.join(os.path.realpath(self.env_dir), env_name)
+        builder = venv.EnvBuilder(clear=True)
+        builder.create(env_dir)
+        activate = os.path.join(env_dir, self.bindir, 'activate.bat')
+        test_batch = os.path.join(self.env_dir, 'test_special_chars.bat')
+        with open(test_batch, "w") as f:
+            f.write('@echo off\n'
+                    f'"{activate}" & '
+                    f'{self.exe} -c "import sys; print(sys.executable)" & '
+                    f'{self.exe} -c "import os; print(os.environ[\'VIRTUAL_ENV\'])" & '
+                    'deactivate')
+        out, err = check_output([test_batch])
+        lines = out.splitlines()
+        self.assertTrue(env_name.encode() in lines[0])
+        self.assertEndsWith(lines[1], env_name.encode())
+
     @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
     def test_unicode_in_batch_file(self):
         """
@@ -351,13 +584,27 @@ def test_unicode_in_batch_file(self):
         builder = venv.EnvBuilder(clear=True)
         builder.create(env_dir)
         activate = os.path.join(env_dir, self.bindir, 'activate.bat')
-        envpy = os.path.join(env_dir, self.bindir, self.exe)
         out, err = check_output(
             [activate, '&', self.exe, '-c', 'print(0)'],
             encoding='oem',
         )
         self.assertEqual(out.strip(), '0')
 
+    @unittest.skipUnless(os.name == 'nt' and can_symlink(),
+                         'symlinks on Windows')
+    def test_failed_symlink(self):
+        """
+        Test handling of failed symlinks on Windows.
+        """
+        rmtree(self.env_dir)
+        env_dir = os.path.join(os.path.realpath(self.env_dir), 'venv')
+        with patch('os.symlink') as mock_symlink:
+            mock_symlink.side_effect = OSError()
+            builder = venv.EnvBuilder(clear=True, symlinks=True)
+            _, err = self.run_with_capture(builder.create, env_dir)
+            filepath_regex = r"'[A-Z]:\\\\(?:[^\\\\]+\\\\)*[^\\\\]+'"
+            self.assertRegex(err, rf"Unable to symlink {filepath_regex} to {filepath_regex}")
+
     @requireVenvCreate
     def test_multiprocessing(self):
         """
@@ -370,15 +617,25 @@ def test_multiprocessing(self):
 
         rmtree(self.env_dir)
         self.run_with_capture(venv.create, self.env_dir)
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'from multiprocessing import Pool; '
             'pool = Pool(1); '
             'print(pool.apply_async("Python".lower).get(3)); '
             'pool.terminate()'])
         self.assertEqual(out.strip(), "python".encode())
 
+    @requireVenvCreate
+    def test_multiprocessing_recursion(self):
+        """
+        Test that the multiprocessing is able to spawn itself
+        """
+        skip_if_broken_multiprocessing_synchronize()
+
+        rmtree(self.env_dir)
+        self.run_with_capture(venv.create, self.env_dir)
+        script = os.path.join(TEST_HOME_DIR, '_test_venv_multiprocessing.py')
+        subprocess.check_call([self.envpy(real_env_dir=True), "-I", script])
+
     @unittest.skipIf(os.name == 'nt', 'not relevant on Windows')
     def test_deactivate_with_strict_bash_opts(self):
         bash = shutil.which("bash")
@@ -404,19 +661,250 @@ def test_macos_env(self):
         builder = venv.EnvBuilder()
         builder.create(self.env_dir)
 
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'import os; print("__PYVENV_LAUNCHER__" in os.environ)'])
         self.assertEqual(out.strip(), 'False'.encode())
 
+    def test_pathsep_error(self):
+        """
+        Test that venv creation fails when the target directory contains
+        the path separator.
+        """
+        rmtree(self.env_dir)
+        bad_itempath = self.env_dir + os.pathsep
+        self.assertRaises(ValueError, venv.create, bad_itempath)
+        self.assertRaises(ValueError, venv.create, FakePath(bad_itempath))
+
+    @unittest.skipIf(os.name == 'nt', 'not relevant on Windows')
+    @requireVenvCreate
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_zippath_from_non_installed_posix(self):
+        """
+        Test that when create venv from non-installed python, the zip path
+        value is as expected.
+        """
+        rmtree(self.env_dir)
+        # First try to create a non-installed python. It's not a real full
+        # functional non-installed python, but enough for this test.
+        platlibdir = sys.platlibdir
+        non_installed_dir = os.path.realpath(tempfile.mkdtemp())
+        self.addCleanup(rmtree, non_installed_dir)
+        bindir = os.path.join(non_installed_dir, self.bindir)
+        os.mkdir(bindir)
+        shutil.copy2(sys.executable, bindir)
+        libdir = os.path.join(non_installed_dir, platlibdir, self.lib[1])
+        os.makedirs(libdir)
+        landmark = os.path.join(libdir, "os.py")
+        abi_thread = "t" if sysconfig.get_config_var("Py_GIL_DISABLED") else ""
+        stdlib_zip = f"python{sys.version_info.major}{sys.version_info.minor}{abi_thread}"
+        zip_landmark = os.path.join(non_installed_dir,
+                                    platlibdir,
+                                    stdlib_zip)
+        additional_pythonpath_for_non_installed = []
+
+        # Copy stdlib files to the non-installed python so venv can
+        # correctly calculate the prefix.
+        for eachpath in sys.path:
+            if eachpath.endswith(".zip"):
+                if os.path.isfile(eachpath):
+                    shutil.copyfile(
+                        eachpath,
+                        os.path.join(non_installed_dir, platlibdir))
+            elif os.path.isfile(os.path.join(eachpath, "os.py")):
+                names = os.listdir(eachpath)
+                ignored_names = copy_python_src_ignore(eachpath, names)
+                for name in names:
+                    if name in ignored_names:
+                        continue
+                    if name == "site-packages":
+                        continue
+                    fn = os.path.join(eachpath, name)
+                    if os.path.isfile(fn):
+                        shutil.copy(fn, libdir)
+                    elif os.path.isdir(fn):
+                        shutil.copytree(fn, os.path.join(libdir, name),
+                                        ignore=copy_python_src_ignore)
+            else:
+                additional_pythonpath_for_non_installed.append(
+                    eachpath)
+        cmd = [os.path.join(non_installed_dir, self.bindir, self.exe),
+               "-m",
+               "venv",
+               "--without-pip",
+               "--without-scm-ignore-files",
+               self.env_dir]
+        # Our fake non-installed python is not fully functional because
+        # it cannot find the extensions. Set PYTHONPATH so it can run the
+        # venv module correctly.
+        pythonpath = os.pathsep.join(
+            additional_pythonpath_for_non_installed)
+        # For python built with shared enabled. We need to set
+        # LD_LIBRARY_PATH so the non-installed python can find and link
+        # libpython.so
+        ld_library_path = sysconfig.get_config_var("LIBDIR")
+        if not ld_library_path or sysconfig.is_python_build():
+            ld_library_path = os.path.abspath(os.path.dirname(sys.executable))
+        if sys.platform == 'darwin':
+            ld_library_path_env = "DYLD_LIBRARY_PATH"
+        else:
+            ld_library_path_env = "LD_LIBRARY_PATH"
+        child_env = {
+                "PYTHONPATH": pythonpath,
+                ld_library_path_env: ld_library_path,
+        }
+        if asan_options := os.environ.get("ASAN_OPTIONS"):
+            # prevent https://github.com/python/cpython/issues/104839
+            child_env["ASAN_OPTIONS"] = asan_options
+        subprocess.check_call(cmd, env=child_env)
+        # Now check the venv created from the non-installed python has
+        # correct zip path in pythonpath.
+        cmd = [self.envpy(), '-S', '-c', 'import sys; print(sys.path)']
+        out, err = check_output(cmd)
+        self.assertTrue(zip_landmark.encode() in out)
+
+    @requireVenvCreate
+    def test_activate_shell_script_has_no_dos_newlines(self):
+        """
+        Test that the `activate` shell script contains no CR LF.
+        This is relevant for Cygwin, as the Windows build might have
+        converted line endings accidentally.
+        """
+        venv_dir = pathlib.Path(self.env_dir)
+        rmtree(venv_dir)
+        [[scripts_dir], *_] = self.ENV_SUBDIRS
+        script_path = venv_dir / scripts_dir / "activate"
+        venv.create(venv_dir)
+        with open(script_path, 'rb') as script:
+            for i, line in enumerate(script, 1):
+                error_message = f"CR LF found in line {i}"
+                self.assertFalse(line.endswith(b'\r\n'), error_message)
+
+    @requireVenvCreate
+    def test_scm_ignore_files_git(self):
+        """
+        Test that a .gitignore file is created when "git" is specified.
+        The file should contain a `*\n` line.
+        """
+        self.run_with_capture(venv.create, self.env_dir,
+                              scm_ignore_files={'git'})
+        file_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', file_lines)
+
+    @requireVenvCreate
+    def test_create_scm_ignore_files_multiple(self):
+        """
+        Test that ``scm_ignore_files`` can work with multiple SCMs.
+        """
+        bzrignore_name = ".bzrignore"
+        contents = "# For Bazaar.\n*\n"
+
+        class BzrEnvBuilder(venv.EnvBuilder):
+            def create_bzr_ignore_file(self, context):
+                gitignore_path = os.path.join(context.env_dir, bzrignore_name)
+                with open(gitignore_path, 'w', encoding='utf-8') as file:
+                    file.write(contents)
+
+        builder = BzrEnvBuilder(scm_ignore_files={'git', 'bzr'})
+        self.run_with_capture(builder.create, self.env_dir)
+
+        gitignore_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', gitignore_lines)
+
+        bzrignore = self.get_text_file_contents(bzrignore_name)
+        self.assertEqual(bzrignore, contents)
+
+    @requireVenvCreate
+    def test_create_scm_ignore_files_empty(self):
+        """
+        Test that no default ignore files are created when ``scm_ignore_files``
+        is empty.
+        """
+        # scm_ignore_files is set to frozenset() by default.
+        self.run_with_capture(venv.create, self.env_dir)
+        with self.assertRaises(FileNotFoundError):
+            self.get_text_file_contents('.gitignore')
+
+        self.assertIn("--without-scm-ignore-files",
+                      self.get_text_file_contents('pyvenv.cfg'))
+
+    @requireVenvCreate
+    def test_cli_with_scm_ignore_files(self):
+        """
+        Test that default SCM ignore files are created by default via the CLI.
+        """
+        self.run_with_capture(venv.main, ['--without-pip', self.env_dir])
+
+        gitignore_lines = self.get_text_file_contents('.gitignore').splitlines()
+        self.assertIn('*', gitignore_lines)
+
+    @requireVenvCreate
+    def test_cli_without_scm_ignore_files(self):
+        """
+        Test that ``--without-scm-ignore-files`` doesn't create SCM ignore files.
+        """
+        args = ['--without-pip', '--without-scm-ignore-files', self.env_dir]
+        self.run_with_capture(venv.main, args)
+
+        with self.assertRaises(FileNotFoundError):
+            self.get_text_file_contents('.gitignore')
+
+    def test_venv_same_path(self):
+        same_path = venv.EnvBuilder._same_path
+        if sys.platform == 'win32':
+            # Case-insensitive, and handles short/long names
+            tests = [
+                (True, TESTFN, TESTFN),
+                (True, TESTFN.lower(), TESTFN.upper()),
+            ]
+            import _winapi
+            # ProgramFiles is the most reliable path that will have short/long
+            progfiles = os.getenv('ProgramFiles')
+            if progfiles:
+                tests = [
+                    *tests,
+                    (True, progfiles, progfiles),
+                    (True, _winapi.GetShortPathName(progfiles), _winapi.GetLongPathName(progfiles)),
+                ]
+        else:
+            # Just a simple case-sensitive comparison
+            tests = [
+                (True, TESTFN, TESTFN),
+                (False, TESTFN.lower(), TESTFN.upper()),
+            ]
+        for r, path1, path2 in tests:
+            with self.subTest(f"{path1}-{path2}"):
+                if r:
+                    self.assertTrue(same_path(path1, path2))
+                else:
+                    self.assertFalse(same_path(path1, path2))
+
+    # gh-126084: venvwlauncher should run pythonw, not python
+    @requireVenvCreate
+    @unittest.skipUnless(os.name == 'nt', 'only relevant on Windows')
+    def test_venvwlauncher(self):
+        """
+        Test that the GUI launcher runs the GUI python.
+        """
+        rmtree(self.env_dir)
+        venv.create(self.env_dir)
+        exename = self.exe
+        # Retain the debug suffix if present
+        if "python" in exename and not "pythonw" in exename:
+            exename = exename.replace("python", "pythonw")
+        envpyw = os.path.join(self.env_dir, self.bindir, exename)
+        try:
+            subprocess.check_call([envpyw, "-c", "import sys; "
+                "assert sys._base_executable.endswith('%s')" % exename])
+        except subprocess.CalledProcessError:
+            self.fail("venvwlauncher.exe did not run %s" % exename)
+
+
 @requireVenvCreate
 class EnsurePipTest(BaseTest):
     """Test venv module installation of pip."""
     def assert_pip_not_installed(self):
-        envpy = os.path.join(os.path.realpath(self.env_dir),
-                             self.bindir, self.exe)
-        out, err = check_output([envpy, '-c',
+        out, err = check_output([self.envpy(real_env_dir=True), '-c',
             'try:\n import pip\nexcept ImportError:\n print("OK")'])
         # We force everything to text, so unittest gives the detailed diff
         # if we get unexpected results
@@ -478,20 +966,14 @@ def do_test_with_pip(self, system_site_packages):
 
                 # Actually run the create command with all that unhelpful
                 # config in place to ensure we ignore it
-                try:
+                with self.nicer_error():
                     self.run_with_capture(venv.create, self.env_dir,
                                           system_site_packages=system_site_packages,
                                           with_pip=True)
-                except subprocess.CalledProcessError as exc:
-                    # The output this produces can be a little hard to read,
-                    # but at least it has all the details
-                    details = exc.output.decode(errors="replace")
-                    msg = "{}\n\n**Subprocess Output**\n{}"
-                    self.fail(msg.format(exc, details))
         # Ensure pip is available in the virtual environment
-        envpy = os.path.join(os.path.realpath(self.env_dir), self.bindir, self.exe)
         # Ignore DeprecationWarning since pip code is not part of Python
-        out, err = check_output([envpy, '-W', 'ignore::DeprecationWarning',
+        out, err = check_output([self.envpy(real_env_dir=True),
+               '-W', 'ignore::DeprecationWarning',
                '-W', 'ignore::ImportWarning', '-I',
                '-m', 'pip', '--version'])
         # We force everything to text, so unittest gives the detailed diff
@@ -508,13 +990,14 @@ def do_test_with_pip(self, system_site_packages):
         # Check the private uninstall command provided for the Windows
         # installers works (at least in a virtual environment)
         with EnvironmentVarGuard() as envvars:
-            # It seems ensurepip._uninstall calls subprocesses which do not
-            # inherit the interpreter settings.
-            envvars["PYTHONWARNINGS"] = "ignore"
-            out, err = check_output([envpy,
-                '-W', 'ignore::DeprecationWarning',
-                '-W', 'ignore::ImportWarning', '-I',
-                '-m', 'ensurepip._uninstall'])
+            with self.nicer_error():
+                # It seems ensurepip._uninstall calls subprocesses which do not
+                # inherit the interpreter settings.
+                envvars["PYTHONWARNINGS"] = "ignore"
+                out, err = check_output([self.envpy(real_env_dir=True),
+                    '-W', 'ignore::DeprecationWarning',
+                    '-W', 'ignore::ImportWarning', '-I',
+                    '-m', 'ensurepip._uninstall'])
         # We force everything to text, so unittest gives the detailed diff
         # if we get unexpected results
         err = err.decode("latin-1") # Force to text, prevent decoding errors
@@ -527,25 +1010,51 @@ def do_test_with_pip(self, system_site_packages):
         err = re.sub("^(WARNING: )?The directory .* or its parent directory "
                      "is not owned or is not writable by the current user.*$", "",
                      err, flags=re.MULTILINE)
+        # Ignore warning about missing optional module:
+        try:
+            import ssl
+        except ImportError:
+            err = re.sub(
+                "^WARNING: Disabling truststore since ssl support is missing$",
+                "",
+                err, flags=re.MULTILINE)
         self.assertEqual(err.rstrip(), "")
         # Being fairly specific regarding the expected behaviour for the
         # initial bundling phase in Python 3.4. If the output changes in
         # future pip versions, this test can likely be relaxed further.
         out = out.decode("latin-1") # Force to text, prevent decoding errors
         self.assertIn("Successfully uninstalled pip", out)
-        self.assertIn("Successfully uninstalled setuptools", out)
         # Check pip is now gone from the virtual environment. This only
         # applies in the system_site_packages=False case, because in the
         # other case, pip may still be available in the system site-packages
         if not system_site_packages:
             self.assert_pip_not_installed()
 
-    # Issue #26610: pip/pep425tags.py requires ctypes
-    @unittest.skipUnless(ctypes, 'pip requires ctypes')
-    @requires_zlib()
+    @contextlib.contextmanager
+    def nicer_error(self):
+        """
+        Capture output from a failed subprocess for easier debugging.
+
+        The output this handler produces can be a little hard to read,
+        but at least it has all the details.
+        """
+        try:
+            yield
+        except subprocess.CalledProcessError as exc:
+            out = (exc.output or b'').decode(errors="replace")
+            err = (exc.stderr or b'').decode(errors="replace")
+            self.fail(
+                f"{exc}\n\n"
+                f"**Subprocess Output**\n{out}\n\n"
+                f"**Subprocess Error**\n{err}"
+            )
+
+    @requires_venv_with_pip()
+    @requires_resource('cpu')
     def test_with_pip(self):
         self.do_test_with_pip(False)
         self.do_test_with_pip(True)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_wait3.py b/Lib/test/test_wait3.py
new file mode 100644
index 0000000000..eae885a613
--- /dev/null
+++ b/Lib/test/test_wait3.py
@@ -0,0 +1,53 @@
+"""This test checks for correct wait3() behavior.
+"""
+
+import os
+import subprocess
+import sys
+import unittest
+from test.fork_wait import ForkWait
+from test import support
+
+if not support.has_fork_support:
+    raise unittest.SkipTest("requires working os.fork()")
+
+if not hasattr(os, 'wait3'):
+    raise unittest.SkipTest("os.wait3 not defined")
+
+class Wait3Test(ForkWait):
+    def wait_impl(self, cpid, *, exitcode):
+        # This many iterations can be required, since some previously run
+        # tests (e.g. test_ctypes) could have spawned a lot of children
+        # very quickly.
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            # wait3() shouldn't hang, but some of the buildbots seem to hang
+            # in the forking tests.  This is an attempt to fix the problem.
+            spid, status, rusage = os.wait3(os.WNOHANG)
+            if spid == cpid:
+                break
+
+        self.assertEqual(spid, cpid)
+        self.assertEqual(os.waitstatus_to_exitcode(status), exitcode)
+        self.assertTrue(rusage)
+
+    def test_wait3_rusage_initialized(self):
+        # Ensure a successful wait3() call where no child was ready to report
+        # its exit status does not return uninitialized memory in the rusage
+        # structure. See bpo-36279.
+        args = [sys.executable, '-c', 'import sys; sys.stdin.read()']
+        proc = subprocess.Popen(args, stdin=subprocess.PIPE)
+        try:
+            pid, status, rusage = os.wait3(os.WNOHANG)
+            self.assertEqual(0, pid)
+            self.assertEqual(0, status)
+            self.assertEqual(0, sum(rusage))
+        finally:
+            proc.stdin.close()
+            proc.wait()
+
+
+def tearDownModule():
+    support.reap_children()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_wait4.py b/Lib/test/test_wait4.py
new file mode 100644
index 0000000000..67afab1d6f
--- /dev/null
+++ b/Lib/test/test_wait4.py
@@ -0,0 +1,38 @@
+"""This test checks for correct wait4() behavior.
+"""
+
+import os
+import sys
+import unittest
+from test.fork_wait import ForkWait
+from test import support
+
+# If either of these do not exist, skip this test.
+if not support.has_fork_support:
+    raise unittest.SkipTest("requires working os.fork()")
+
+support.get_attribute(os, 'wait4')
+
+
+class Wait4Test(ForkWait):
+    def wait_impl(self, cpid, *, exitcode):
+        option = os.WNOHANG
+        if sys.platform.startswith('aix'):
+            # Issue #11185: wait4 is broken on AIX and will always return 0
+            # with WNOHANG.
+            option = 0
+        for _ in support.sleeping_retry(support.SHORT_TIMEOUT):
+            # wait4() shouldn't hang, but some of the buildbots seem to hang
+            # in the forking tests.  This is an attempt to fix the problem.
+            spid, status, rusage = os.wait4(cpid, option)
+            if spid == cpid:
+                break
+        self.assertEqual(spid, cpid)
+        self.assertEqual(os.waitstatus_to_exitcode(status), exitcode)
+        self.assertTrue(rusage)
+
+def tearDownModule():
+    support.reap_children()
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_warnings/__init__.py b/Lib/test/test_warnings/__init__.py
new file mode 100644
index 0000000000..123d51b77e
--- /dev/null
+++ b/Lib/test/test_warnings/__init__.py
@@ -0,0 +1,1979 @@
+from contextlib import contextmanager
+import linecache
+import os
+import importlib
+import inspect
+from io import StringIO
+import re
+import sys
+import textwrap
+import types
+from typing import overload, get_overloads
+import unittest
+from test import support
+from test.support import import_helper
+from test.support import os_helper
+from test.support import warnings_helper
+from test.support import force_not_colorized
+from test.support.script_helper import assert_python_ok, assert_python_failure
+
+from test.test_warnings.data import package_helper
+from test.test_warnings.data import stacklevel as warning_tests
+
+import warnings as original_warnings
+from warnings import deprecated
+
+
+py_warnings = import_helper.import_fresh_module('warnings',
+                                                blocked=['_warnings'])
+c_warnings = import_helper.import_fresh_module('warnings',
+                                               fresh=['_warnings'])
+
+@contextmanager
+def warnings_state(module):
+    """Use a specific warnings implementation in warning_tests."""
+    global __warningregistry__
+    for to_clear in (sys, warning_tests):
+        try:
+            to_clear.__warningregistry__.clear()
+        except AttributeError:
+            pass
+    try:
+        __warningregistry__.clear()
+    except NameError:
+        pass
+    original_warnings = warning_tests.warnings
+    original_filters = module.filters
+    try:
+        module.filters = original_filters[:]
+        module.simplefilter("once")
+        warning_tests.warnings = module
+        yield
+    finally:
+        warning_tests.warnings = original_warnings
+        module.filters = original_filters
+
+
+class TestWarning(Warning):
+    pass
+
+
+class BaseTest:
+
+    """Basic bookkeeping required for testing."""
+
+    def setUp(self):
+        self.old_unittest_module = unittest.case.warnings
+        # The __warningregistry__ needs to be in a pristine state for tests
+        # to work properly.
+        if '__warningregistry__' in globals():
+            del globals()['__warningregistry__']
+        if hasattr(warning_tests, '__warningregistry__'):
+            del warning_tests.__warningregistry__
+        if hasattr(sys, '__warningregistry__'):
+            del sys.__warningregistry__
+        # The 'warnings' module must be explicitly set so that the proper
+        # interaction between _warnings and 'warnings' can be controlled.
+        sys.modules['warnings'] = self.module
+        # Ensure that unittest.TestCase.assertWarns() uses the same warnings
+        # module than warnings.catch_warnings(). Otherwise,
+        # warnings.catch_warnings() will be unable to remove the added filter.
+        unittest.case.warnings = self.module
+        super(BaseTest, self).setUp()
+
+    def tearDown(self):
+        sys.modules['warnings'] = original_warnings
+        unittest.case.warnings = self.old_unittest_module
+        super(BaseTest, self).tearDown()
+
+class PublicAPITests(BaseTest):
+
+    """Ensures that the correct values are exposed in the
+    public API.
+    """
+
+    def test_module_all_attribute(self):
+        self.assertTrue(hasattr(self.module, '__all__'))
+        target_api = ["warn", "warn_explicit", "showwarning",
+                      "formatwarning", "filterwarnings", "simplefilter",
+                      "resetwarnings", "catch_warnings", "deprecated"]
+        self.assertSetEqual(set(self.module.__all__),
+                            set(target_api))
+
+class CPublicAPITests(PublicAPITests, unittest.TestCase):
+    module = c_warnings
+
+class PyPublicAPITests(PublicAPITests, unittest.TestCase):
+    module = py_warnings
+
+class FilterTests(BaseTest):
+
+    """Testing the filtering functionality."""
+
+    def test_error(self):
+        with original_warnings.catch_warnings(module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", category=UserWarning)
+            self.assertRaises(UserWarning, self.module.warn,
+                                "FilterTests.test_error")
+
+    def test_error_after_default(self):
+        with original_warnings.catch_warnings(module=self.module) as w:
+            self.module.resetwarnings()
+            message = "FilterTests.test_ignore_after_default"
+            def f():
+                self.module.warn(message, UserWarning)
+
+            with support.captured_stderr() as stderr:
+                f()
+            stderr = stderr.getvalue()
+            self.assertIn("UserWarning: FilterTests.test_ignore_after_default",
+                          stderr)
+            self.assertIn("self.module.warn(message, UserWarning)",
+                          stderr)
+
+            self.module.filterwarnings("error", category=UserWarning)
+            self.assertRaises(UserWarning, f)
+
+    def test_ignore(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("ignore", category=UserWarning)
+            self.module.warn("FilterTests.test_ignore", UserWarning)
+            self.assertEqual(len(w), 0)
+            self.assertEqual(list(__warningregistry__), ['version'])
+
+    def test_ignore_after_default(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            message = "FilterTests.test_ignore_after_default"
+            def f():
+                self.module.warn(message, UserWarning)
+            f()
+            self.module.filterwarnings("ignore", category=UserWarning)
+            f()
+            f()
+            self.assertEqual(len(w), 1)
+
+    def test_always(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("always", category=UserWarning)
+            message = "FilterTests.test_always"
+            def f():
+                self.module.warn(message, UserWarning)
+            f()
+            self.assertEqual(len(w), 1)
+            self.assertEqual(w[-1].message.args[0], message)
+            f()
+            self.assertEqual(len(w), 2)
+            self.assertEqual(w[-1].message.args[0], message)
+
+    def test_always_after_default(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            message = "FilterTests.test_always_after_ignore"
+            def f():
+                self.module.warn(message, UserWarning)
+            f()
+            self.assertEqual(len(w), 1)
+            self.assertEqual(w[-1].message.args[0], message)
+            f()
+            self.assertEqual(len(w), 1)
+            self.module.filterwarnings("always", category=UserWarning)
+            f()
+            self.assertEqual(len(w), 2)
+            self.assertEqual(w[-1].message.args[0], message)
+            f()
+            self.assertEqual(len(w), 3)
+            self.assertEqual(w[-1].message.args[0], message)
+
+    def test_default(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("default", category=UserWarning)
+            message = UserWarning("FilterTests.test_default")
+            for x in range(2):
+                self.module.warn(message, UserWarning)
+                if x == 0:
+                    self.assertEqual(w[-1].message, message)
+                    del w[:]
+                elif x == 1:
+                    self.assertEqual(len(w), 0)
+                else:
+                    raise ValueError("loop variant unhandled")
+
+    def test_module(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("module", category=UserWarning)
+            message = UserWarning("FilterTests.test_module")
+            self.module.warn(message, UserWarning)
+            self.assertEqual(w[-1].message, message)
+            del w[:]
+            self.module.warn(message, UserWarning)
+            self.assertEqual(len(w), 0)
+
+    def test_once(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("once", category=UserWarning)
+            message = UserWarning("FilterTests.test_once")
+            self.module.warn_explicit(message, UserWarning, "__init__.py",
+                                    42)
+            self.assertEqual(w[-1].message, message)
+            del w[:]
+            self.module.warn_explicit(message, UserWarning, "__init__.py",
+                                    13)
+            self.assertEqual(len(w), 0)
+            self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
+                                    42)
+            self.assertEqual(len(w), 0)
+
+    def test_module_globals(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.simplefilter("always", UserWarning)
+
+            # bpo-33509: module_globals=None must not crash
+            self.module.warn_explicit('msg', UserWarning, "filename", 42,
+                                      module_globals=None)
+            self.assertEqual(len(w), 1)
+
+            # Invalid module_globals type
+            with self.assertRaises(TypeError):
+                self.module.warn_explicit('msg', UserWarning, "filename", 42,
+                                          module_globals=True)
+            self.assertEqual(len(w), 1)
+
+            # Empty module_globals
+            self.module.warn_explicit('msg', UserWarning, "filename", 42,
+                                      module_globals={})
+            self.assertEqual(len(w), 2)
+
+    def test_inheritance(self):
+        with original_warnings.catch_warnings(module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", category=Warning)
+            self.assertRaises(UserWarning, self.module.warn,
+                                "FilterTests.test_inheritance", UserWarning)
+
+    def test_ordering(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("ignore", category=UserWarning)
+            self.module.filterwarnings("error", category=UserWarning,
+                                        append=True)
+            del w[:]
+            try:
+                self.module.warn("FilterTests.test_ordering", UserWarning)
+            except UserWarning:
+                self.fail("order handling for actions failed")
+            self.assertEqual(len(w), 0)
+
+    def test_filterwarnings(self):
+        # Test filterwarnings().
+        # Implicitly also tests resetwarnings().
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.filterwarnings("error", "", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn, 'convert to error')
+
+            self.module.resetwarnings()
+            text = 'handle normally'
+            self.module.warn(text)
+            self.assertEqual(str(w[-1].message), text)
+            self.assertIs(w[-1].category, UserWarning)
+
+            self.module.filterwarnings("ignore", "", Warning, "", 0)
+            text = 'filtered out'
+            self.module.warn(text)
+            self.assertNotEqual(str(w[-1].message), text)
+
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", "hex*", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn, 'hex/oct')
+            text = 'nonmatching text'
+            self.module.warn(text)
+            self.assertEqual(str(w[-1].message), text)
+            self.assertIs(w[-1].category, UserWarning)
+
+    def test_message_matching(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.simplefilter("ignore", UserWarning)
+            self.module.filterwarnings("error", "match", UserWarning)
+            self.assertRaises(UserWarning, self.module.warn, "match")
+            self.assertRaises(UserWarning, self.module.warn, "match prefix")
+            self.module.warn("suffix match")
+            self.assertEqual(w, [])
+            self.module.warn("something completely different")
+            self.assertEqual(w, [])
+
+    def test_mutate_filter_list(self):
+        class X:
+            def match(self, a):
+                L[:] = []
+
+        L = [("default",X(),UserWarning,X(),0) for i in range(2)]
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.filters = L
+            self.module.warn_explicit(UserWarning("b"), None, "f.py", 42)
+            self.assertEqual(str(w[-1].message), "b")
+
+    def test_filterwarnings_duplicate_filters(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.resetwarnings()
+            self.module.filterwarnings("error", category=UserWarning)
+            self.assertEqual(len(self.module.filters), 1)
+            self.module.filterwarnings("ignore", category=UserWarning)
+            self.module.filterwarnings("error", category=UserWarning)
+            self.assertEqual(
+                len(self.module.filters), 2,
+                "filterwarnings inserted duplicate filter"
+            )
+            self.assertEqual(
+                self.module.filters[0][0], "error",
+                "filterwarnings did not promote filter to "
+                "the beginning of list"
+            )
+
+    def test_simplefilter_duplicate_filters(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.resetwarnings()
+            self.module.simplefilter("error", category=UserWarning)
+            self.assertEqual(len(self.module.filters), 1)
+            self.module.simplefilter("ignore", category=UserWarning)
+            self.module.simplefilter("error", category=UserWarning)
+            self.assertEqual(
+                len(self.module.filters), 2,
+                "simplefilter inserted duplicate filter"
+            )
+            self.assertEqual(
+                self.module.filters[0][0], "error",
+                "simplefilter did not promote filter to the beginning of list"
+            )
+
+    def test_append_duplicate(self):
+        with original_warnings.catch_warnings(module=self.module,
+                record=True) as w:
+            self.module.resetwarnings()
+            self.module.simplefilter("ignore")
+            self.module.simplefilter("error", append=True)
+            self.module.simplefilter("ignore", append=True)
+            self.module.warn("test_append_duplicate", category=UserWarning)
+            self.assertEqual(len(self.module.filters), 2,
+                "simplefilter inserted duplicate filter"
+            )
+            self.assertEqual(len(w), 0,
+                "appended duplicate changed order of filters"
+            )
+
+    def test_argument_validation(self):
+        with self.assertRaises(ValueError):
+            self.module.filterwarnings(action='foo')
+        with self.assertRaises(TypeError):
+            self.module.filterwarnings('ignore', message=0)
+        with self.assertRaises(TypeError):
+            self.module.filterwarnings('ignore', category=0)
+        with self.assertRaises(TypeError):
+            self.module.filterwarnings('ignore', category=int)
+        with self.assertRaises(TypeError):
+            self.module.filterwarnings('ignore', module=0)
+        with self.assertRaises(TypeError):
+            self.module.filterwarnings('ignore', lineno=int)
+        with self.assertRaises(ValueError):
+            self.module.filterwarnings('ignore', lineno=-1)
+        with self.assertRaises(ValueError):
+            self.module.simplefilter(action='foo')
+        with self.assertRaises(TypeError):
+            self.module.simplefilter('ignore', lineno=int)
+        with self.assertRaises(ValueError):
+            self.module.simplefilter('ignore', lineno=-1)
+
+    def test_catchwarnings_with_simplefilter_ignore(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.resetwarnings()
+            self.module.simplefilter("error")
+            with self.module.catch_warnings(
+                module=self.module, action="ignore"
+            ):
+                self.module.warn("This will be ignored")
+
+    def test_catchwarnings_with_simplefilter_error(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.resetwarnings()
+            with self.module.catch_warnings(
+                module=self.module, action="error", category=FutureWarning
+            ):
+                with support.captured_stderr() as stderr:
+                    error_msg = "Other types of warnings are not errors"
+                    self.module.warn(error_msg)
+                    self.assertRaises(FutureWarning,
+                                      self.module.warn, FutureWarning("msg"))
+                    stderr = stderr.getvalue()
+                    self.assertIn(error_msg, stderr)
+
+class CFilterTests(FilterTests, unittest.TestCase):
+    module = c_warnings
+
+class PyFilterTests(FilterTests, unittest.TestCase):
+    module = py_warnings
+
+
+class WarnTests(BaseTest):
+
+    """Test warnings.warn() and warnings.warn_explicit()."""
+
+    def test_message(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.simplefilter("once")
+            for i in range(4):
+                text = 'multi %d' %i  # Different text on each call.
+                self.module.warn(text)
+                self.assertEqual(str(w[-1].message), text)
+                self.assertIs(w[-1].category, UserWarning)
+
+    # Issue 3639
+    def test_warn_nonstandard_types(self):
+        # warn() should handle non-standard types without issue.
+        for ob in (Warning, None, 42):
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                self.module.simplefilter("once")
+                self.module.warn(ob)
+                # Don't directly compare objects since
+                # ``Warning() != Warning()``.
+                self.assertEqual(str(w[-1].message), str(UserWarning(ob)))
+
+    def test_filename(self):
+        with warnings_state(self.module):
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                warning_tests.inner("spam1")
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "stacklevel.py")
+                warning_tests.outer("spam2")
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "stacklevel.py")
+
+    def test_stacklevel(self):
+        # Test stacklevel argument
+        # make sure all messages are different, so the warning won't be skipped
+        with warnings_state(self.module):
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                warning_tests.inner("spam3", stacklevel=1)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "stacklevel.py")
+                warning_tests.outer("spam4", stacklevel=1)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "stacklevel.py")
+
+                warning_tests.inner("spam5", stacklevel=2)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "__init__.py")
+                warning_tests.outer("spam6", stacklevel=2)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "stacklevel.py")
+                warning_tests.outer("spam6.5", stacklevel=3)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "__init__.py")
+
+                warning_tests.inner("spam7", stacklevel=9999)
+                self.assertEqual(os.path.basename(w[-1].filename),
+                                    "<sys>")
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_stacklevel_import(self):
+        # Issue #24305: With stacklevel=2, module-level warnings should work.
+        import_helper.unload('test.test_warnings.data.import_warning')
+        with warnings_state(self.module):
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                self.module.simplefilter('always')
+                import test.test_warnings.data.import_warning
+                self.assertEqual(len(w), 1)
+                self.assertEqual(w[0].filename, __file__)
+
+    def test_skip_file_prefixes(self):
+        with warnings_state(self.module):
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                self.module.simplefilter('always')
+
+                # Warning never attributed to the data/ package.
+                package_helper.inner_api(
+                        "inner_api", stacklevel=2,
+                        warnings_module=warning_tests.warnings)
+                self.assertEqual(w[-1].filename, __file__)
+                warning_tests.package("package api", stacklevel=2)
+                self.assertEqual(w[-1].filename, __file__)
+                self.assertEqual(w[-2].filename, w[-1].filename)
+                # Low stacklevels are overridden to 2 behavior.
+                warning_tests.package("package api 1", stacklevel=1)
+                self.assertEqual(w[-1].filename, __file__)
+                warning_tests.package("package api 0", stacklevel=0)
+                self.assertEqual(w[-1].filename, __file__)
+                warning_tests.package("package api -99", stacklevel=-99)
+                self.assertEqual(w[-1].filename, __file__)
+
+                # The stacklevel still goes up out of the package.
+                warning_tests.package("prefix02", stacklevel=3)
+                self.assertIn("unittest", w[-1].filename)
+
+    def test_skip_file_prefixes_type_errors(self):
+        with warnings_state(self.module):
+            warn = warning_tests.warnings.warn
+            with self.assertRaises(TypeError):
+                warn("msg", skip_file_prefixes=[])
+            with self.assertRaises(TypeError):
+                warn("msg", skip_file_prefixes=(b"bytes",))
+            with self.assertRaises(TypeError):
+                warn("msg", skip_file_prefixes="a sequence of strs")
+
+    def test_exec_filename(self):
+        filename = "<warnings-test>"
+        codeobj = compile(("import warnings\n"
+                           "warnings.warn('hello', UserWarning)"),
+                          filename, "exec")
+        with original_warnings.catch_warnings(record=True) as w:
+            self.module.simplefilter("always", category=UserWarning)
+            exec(codeobj)
+        self.assertEqual(w[0].filename, filename)
+
+    def test_warn_explicit_non_ascii_filename(self):
+        with original_warnings.catch_warnings(record=True,
+                module=self.module) as w:
+            self.module.resetwarnings()
+            self.module.filterwarnings("always", category=UserWarning)
+            filenames = ["nonascii\xe9\u20ac"]
+            if not support.is_emscripten:
+                # JavaScript does not like surrogates.
+                # Invalid UTF-8 leading byte 0x80 encountered when
+                # deserializing a UTF-8 string in wasm memory to a JS
+                # string!
+                filenames.append("surrogate\udc80")
+            for filename in filenames:
+                try:
+                    os.fsencode(filename)
+                except UnicodeEncodeError:
+                    continue
+                self.module.warn_explicit("text", UserWarning, filename, 1)
+                self.assertEqual(w[-1].filename, filename)
+
+    def test_warn_explicit_type_errors(self):
+        # warn_explicit() should error out gracefully if it is given objects
+        # of the wrong types.
+        # lineno is expected to be an integer.
+        self.assertRaises(TypeError, self.module.warn_explicit,
+                            None, UserWarning, None, None)
+        # Either 'message' needs to be an instance of Warning or 'category'
+        # needs to be a subclass.
+        self.assertRaises(TypeError, self.module.warn_explicit,
+                            None, None, None, 1)
+        # 'registry' must be a dict or None.
+        self.assertRaises((TypeError, AttributeError),
+                            self.module.warn_explicit,
+                            None, Warning, None, 1, registry=42)
+
+    def test_bad_str(self):
+        # issue 6415
+        # Warnings instance with a bad format string for __str__ should not
+        # trigger a bus error.
+        class BadStrWarning(Warning):
+            """Warning with a bad format string for __str__."""
+            def __str__(self):
+                return ("A bad formatted string %(err)" %
+                        {"err" : "there is no %(err)s"})
+
+        with self.assertRaises(ValueError):
+            self.module.warn(BadStrWarning())
+
+    def test_warning_classes(self):
+        class MyWarningClass(Warning):
+            pass
+
+        class NonWarningSubclass:
+            pass
+
+        # passing a non-subclass of Warning should raise a TypeError
+        with self.assertRaises(TypeError) as cm:
+            self.module.warn('bad warning category', '')
+        self.assertIn('category must be a Warning subclass, not ',
+                      str(cm.exception))
+
+        with self.assertRaises(TypeError) as cm:
+            self.module.warn('bad warning category', NonWarningSubclass)
+        self.assertIn('category must be a Warning subclass, not ',
+                      str(cm.exception))
+
+        # check that warning instances also raise a TypeError
+        with self.assertRaises(TypeError) as cm:
+            self.module.warn('bad warning category', MyWarningClass())
+        self.assertIn('category must be a Warning subclass, not ',
+                      str(cm.exception))
+
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.resetwarnings()
+            self.module.filterwarnings('default')
+            with self.assertWarns(MyWarningClass) as cm:
+                self.module.warn('good warning category', MyWarningClass)
+            self.assertEqual('good warning category', str(cm.warning))
+
+            with self.assertWarns(UserWarning) as cm:
+                self.module.warn('good warning category', None)
+            self.assertEqual('good warning category', str(cm.warning))
+
+            with self.assertWarns(MyWarningClass) as cm:
+                self.module.warn('good warning category', MyWarningClass)
+            self.assertIsInstance(cm.warning, Warning)
+
+    def check_module_globals(self, module_globals):
+        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+            self.module.filterwarnings('default')
+            self.module.warn_explicit(
+                'eggs', UserWarning, 'bar', 1,
+                module_globals=module_globals)
+        self.assertEqual(len(w), 1)
+        self.assertEqual(w[0].category, UserWarning)
+        self.assertEqual(str(w[0].message), 'eggs')
+
+    def check_module_globals_error(self, module_globals, errmsg, errtype=ValueError):
+        if self.module is py_warnings:
+            self.check_module_globals(module_globals)
+            return
+        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+            self.module.filterwarnings('always')
+            with self.assertRaisesRegex(errtype, re.escape(errmsg)):
+                self.module.warn_explicit(
+                    'eggs', UserWarning, 'bar', 1,
+                    module_globals=module_globals)
+        self.assertEqual(len(w), 0)
+
+    def check_module_globals_deprecated(self, module_globals, msg):
+        if self.module is py_warnings:
+            self.check_module_globals(module_globals)
+            return
+        with original_warnings.catch_warnings(module=self.module, record=True) as w:
+            self.module.filterwarnings('always')
+            self.module.warn_explicit(
+                'eggs', UserWarning, 'bar', 1,
+                module_globals=module_globals)
+        self.assertEqual(len(w), 2)
+        self.assertEqual(w[0].category, DeprecationWarning)
+        self.assertEqual(str(w[0].message), msg)
+        self.assertEqual(w[1].category, UserWarning)
+        self.assertEqual(str(w[1].message), 'eggs')
+
+    def test_gh86298_no_loader_and_no_spec(self):
+        self.check_module_globals({'__name__': 'bar'})
+
+    def test_gh86298_loader_is_none_and_no_spec(self):
+        self.check_module_globals({'__name__': 'bar', '__loader__': None})
+
+    def test_gh86298_no_loader_and_spec_is_none(self):
+        self.check_module_globals_error(
+            {'__name__': 'bar', '__spec__': None},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_loader_is_none_and_spec_is_none(self):
+        self.check_module_globals_error(
+            {'__name__': 'bar', '__loader__': None, '__spec__': None},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
+        self.check_module_globals_error(
+            {'__name__': 'bar', '__loader__': None,
+             '__spec__': types.SimpleNamespace(loader=None)},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_no_spec(self):
+        self.check_module_globals_deprecated(
+            {'__name__': 'bar', '__loader__': object()},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_spec_is_none(self):
+        self.check_module_globals_deprecated(
+            {'__name__': 'bar', '__loader__': object(), '__spec__': None},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_no_spec_loader(self):
+        self.check_module_globals_deprecated(
+            {'__name__': 'bar', '__loader__': object(),
+             '__spec__': types.SimpleNamespace()},
+            'Module globals is missing a __spec__.loader')
+
+    def test_gh86298_loader_and_spec_loader_disagree(self):
+        self.check_module_globals_deprecated(
+            {'__name__': 'bar', '__loader__': object(),
+             '__spec__': types.SimpleNamespace(loader=object())},
+            'Module globals; __loader__ != __spec__.loader')
+
+    def test_gh86298_no_loader_and_no_spec_loader(self):
+        self.check_module_globals_error(
+            {'__name__': 'bar', '__spec__': types.SimpleNamespace()},
+            'Module globals is missing a __spec__.loader', AttributeError)
+
+    def test_gh86298_no_loader_with_spec_loader_okay(self):
+        self.check_module_globals(
+            {'__name__': 'bar',
+             '__spec__': types.SimpleNamespace(loader=object())})
+
+class CWarnTests(WarnTests, unittest.TestCase):
+    module = c_warnings
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    # As an early adopter, we sanity check the
+    # test.import_helper.import_fresh_module utility function
+    def test_accelerated(self):
+        self.assertIsNot(original_warnings, self.module)
+        self.assertFalse(hasattr(self.module.warn, '__code__'))
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_no_loader_and_spec_is_none(self):
+        return super().test_gh86298_no_loader_and_spec_is_none()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_loader_is_none_and_spec_is_none(self):
+        return super().test_gh86298_loader_is_none_and_spec_is_none()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_loader_is_none_and_spec_loader_is_none(self):
+        return super().test_gh86298_loader_is_none_and_spec_loader_is_none()
+    
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_no_spec(self):
+        return super().test_gh86298_no_spec()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_spec_is_none(self):
+        return super().test_gh86298_spec_is_none()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_no_spec_loader(self):
+        return super().test_gh86298_no_spec_loader()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_loader_and_spec_loader_disagree(self):
+        return super().test_gh86298_loader_and_spec_loader_disagree()
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_gh86298_no_loader_and_no_spec_loader(self):
+        return super().test_gh86298_no_loader_and_no_spec_loader()
+
+class PyWarnTests(WarnTests, unittest.TestCase):
+    module = py_warnings
+
+    # As an early adopter, we sanity check the
+    # test.import_helper.import_fresh_module utility function
+    def test_pure_python(self):
+        self.assertIsNot(original_warnings, self.module)
+        self.assertTrue(hasattr(self.module.warn, '__code__'))
+
+
+class WCmdLineTests(BaseTest):
+
+    def test_improper_input(self):
+        # Uses the private _setoption() function to test the parsing
+        # of command-line warning arguments
+        with original_warnings.catch_warnings(module=self.module):
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, '1:2:3:4:5:6')
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, 'bogus::Warning')
+            self.assertRaises(self.module._OptionError,
+                              self.module._setoption, 'ignore:2::4:-5')
+            with self.assertRaises(self.module._OptionError):
+                self.module._setoption('ignore::123')
+            with self.assertRaises(self.module._OptionError):
+                self.module._setoption('ignore::123abc')
+            with self.assertRaises(self.module._OptionError):
+                self.module._setoption('ignore::===')
+            with self.assertRaisesRegex(self.module._OptionError, 'Wärning'):
+                self.module._setoption('ignore::Wärning')
+            self.module._setoption('error::Warning::0')
+            self.assertRaises(UserWarning, self.module.warn, 'convert to error')
+
+    def test_import_from_module(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module._setoption('ignore::Warning')
+            with self.assertRaises(self.module._OptionError):
+                self.module._setoption('ignore::TestWarning')
+            with self.assertRaises(self.module._OptionError):
+                self.module._setoption('ignore::test.test_warnings.bogus')
+            self.module._setoption('error::test.test_warnings.TestWarning')
+            with self.assertRaises(TestWarning):
+                self.module.warn('test warning', TestWarning)
+
+
+class CWCmdLineTests(WCmdLineTests, unittest.TestCase):
+    module = c_warnings
+
+
+class PyWCmdLineTests(WCmdLineTests, unittest.TestCase):
+    module = py_warnings
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_improper_option(self):
+        # Same as above, but check that the message is printed out when
+        # the interpreter is executed. This also checks that options are
+        # actually parsed at all.
+        rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")
+        self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_warnings_bootstrap(self):
+        # Check that the warnings module does get loaded when -W<some option>
+        # is used (see issue #10372 for an example of silent bootstrap failure).
+        rc, out, err = assert_python_ok("-Wi", "-c",
+            "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)")
+        # '-Wi' was observed
+        self.assertFalse(out.strip())
+        self.assertNotIn(b'RuntimeWarning', err)
+
+
+class _WarningsTests(BaseTest, unittest.TestCase):
+
+    """Tests specific to the _warnings module."""
+
+    module = c_warnings
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_filter(self):
+        # Everything should function even if 'filters' is not in warnings.
+        with original_warnings.catch_warnings(module=self.module) as w:
+            self.module.filterwarnings("error", "", Warning, "", 0)
+            self.assertRaises(UserWarning, self.module.warn,
+                                'convert to error')
+            del self.module.filters
+            self.assertRaises(UserWarning, self.module.warn,
+                                'convert to error')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_onceregistry(self):
+        # Replacing or removing the onceregistry should be okay.
+        global __warningregistry__
+        message = UserWarning('onceregistry test')
+        try:
+            original_registry = self.module.onceregistry
+            __warningregistry__ = {}
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                self.module.resetwarnings()
+                self.module.filterwarnings("once", category=UserWarning)
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.assertEqual(w[-1].message, message)
+                del w[:]
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.assertEqual(len(w), 0)
+                # Test the resetting of onceregistry.
+                self.module.onceregistry = {}
+                __warningregistry__ = {}
+                self.module.warn('onceregistry test')
+                self.assertEqual(w[-1].message.args, message.args)
+                # Removal of onceregistry is okay.
+                del w[:]
+                del self.module.onceregistry
+                __warningregistry__ = {}
+                self.module.warn_explicit(message, UserWarning, "file", 42)
+                self.assertEqual(len(w), 0)
+        finally:
+            self.module.onceregistry = original_registry
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_default_action(self):
+        # Replacing or removing defaultaction should be okay.
+        message = UserWarning("defaultaction test")
+        original = self.module.defaultaction
+        try:
+            with original_warnings.catch_warnings(record=True,
+                    module=self.module) as w:
+                self.module.resetwarnings()
+                registry = {}
+                self.module.warn_explicit(message, UserWarning, "<test>", 42,
+                                            registry=registry)
+                self.assertEqual(w[-1].message, message)
+                self.assertEqual(len(w), 1)
+                # One actual registry key plus the "version" key
+                self.assertEqual(len(registry), 2)
+                self.assertIn("version", registry)
+                del w[:]
+                # Test removal.
+                del self.module.defaultaction
+                __warningregistry__ = {}
+                registry = {}
+                self.module.warn_explicit(message, UserWarning, "<test>", 43,
+                                            registry=registry)
+                self.assertEqual(w[-1].message, message)
+                self.assertEqual(len(w), 1)
+                self.assertEqual(len(registry), 2)
+                del w[:]
+                # Test setting.
+                self.module.defaultaction = "ignore"
+                __warningregistry__ = {}
+                registry = {}
+                self.module.warn_explicit(message, UserWarning, "<test>", 44,
+                                            registry=registry)
+                self.assertEqual(len(w), 0)
+        finally:
+            self.module.defaultaction = original
+
+    def test_showwarning_missing(self):
+        # Test that showwarning() missing is okay.
+        text = 'del showwarning test'
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+            del self.module.showwarning
+            with support.captured_output('stderr') as stream:
+                self.module.warn(text)
+                result = stream.getvalue()
+        self.assertIn(text, result)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_showwarnmsg_missing(self):
+        # Test that _showwarnmsg() missing is okay.
+        text = 'del _showwarnmsg test'
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+
+            show = self.module._showwarnmsg
+            try:
+                del self.module._showwarnmsg
+                with support.captured_output('stderr') as stream:
+                    self.module.warn(text)
+                    result = stream.getvalue()
+            finally:
+                self.module._showwarnmsg = show
+        self.assertIn(text, result)
+
+    def test_showwarning_not_callable(self):
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+            self.module.showwarning = print
+            with support.captured_output('stdout'):
+                self.module.warn('Warning!')
+            self.module.showwarning = 23
+            self.assertRaises(TypeError, self.module.warn, "Warning!")
+
+    def test_show_warning_output(self):
+        # With showwarning() missing, make sure that output is okay.
+        text = 'test show_warning'
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.filterwarnings("always", category=UserWarning)
+            del self.module.showwarning
+            with support.captured_output('stderr') as stream:
+                warning_tests.inner(text)
+                result = stream.getvalue()
+        self.assertEqual(result.count('\n'), 2,
+                             "Too many newlines in %r" % result)
+        first_line, second_line = result.split('\n', 1)
+        expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
+        first_line_parts = first_line.rsplit(':', 3)
+        path, line, warning_class, message = first_line_parts
+        line = int(line)
+        self.assertEqual(expected_file, path)
+        self.assertEqual(warning_class, ' ' + UserWarning.__name__)
+        self.assertEqual(message, ' ' + text)
+        expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
+        assert expected_line
+        self.assertEqual(second_line, expected_line)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_filename_none(self):
+        # issue #12467: race condition if a warning is emitted at shutdown
+        globals_dict = globals()
+        oldfile = globals_dict['__file__']
+        try:
+            catch = original_warnings.catch_warnings(record=True,
+                                                     module=self.module)
+            with catch as w:
+                self.module.filterwarnings("always", category=UserWarning)
+                globals_dict['__file__'] = None
+                original_warnings.warn('test', UserWarning)
+                self.assertTrue(len(w))
+        finally:
+            globals_dict['__file__'] = oldfile
+
+    def test_stderr_none(self):
+        rc, stdout, stderr = assert_python_ok("-c",
+            "import sys; sys.stderr = None; "
+            "import warnings; warnings.simplefilter('always'); "
+            "warnings.warn('Warning!')")
+        self.assertEqual(stdout, b'')
+        self.assertNotIn(b'Warning!', stderr)
+        self.assertNotIn(b'Error', stderr)
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    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
+        # bad splitlines() method.
+        get_source_called = []
+        def get_module_globals(*, splitlines_ret_val):
+            class BadSource(str):
+                def splitlines(self):
+                    return splitlines_ret_val
+
+            class BadLoader:
+                def get_source(self, fullname):
+                    get_source_called.append(splitlines_ret_val)
+                    return BadSource('spam')
+
+            loader = BadLoader()
+            spec = importlib.machinery.ModuleSpec('foobar', loader)
+            return {'__loader__': loader,
+                    '__spec__': spec,
+                    '__name__': 'foobar'}
+
+
+        wmod = self.module
+        with original_warnings.catch_warnings(module=wmod):
+            wmod.filterwarnings('default', category=UserWarning)
+
+            linecache.clearcache()
+            with support.captured_stderr() as stderr:
+                wmod.warn_explicit(
+                    'foo', UserWarning, 'bar', 1,
+                    module_globals=get_module_globals(splitlines_ret_val=42))
+            self.assertIn('UserWarning: foo', stderr.getvalue())
+            self.assertEqual(get_source_called, [42])
+
+            linecache.clearcache()
+            with support.swap_attr(wmod, '_showwarnmsg', None):
+                del wmod._showwarnmsg
+                with support.captured_stderr() as stderr:
+                    wmod.warn_explicit(
+                        'eggs', UserWarning, 'bar', 1,
+                        module_globals=get_module_globals(splitlines_ret_val=[42]))
+                self.assertIn('UserWarning: eggs', stderr.getvalue())
+            self.assertEqual(get_source_called, [42, [42]])
+            linecache.clearcache()
+
+    @support.cpython_only
+    def test_issue31411(self):
+        # warn_explicit() shouldn't raise a SystemError in case
+        # warnings.onceregistry isn't a dictionary.
+        wmod = self.module
+        with original_warnings.catch_warnings(module=wmod):
+            wmod.filterwarnings('once')
+            with support.swap_attr(wmod, 'onceregistry', None):
+                with self.assertRaises(TypeError):
+                    wmod.warn_explicit('foo', Warning, 'bar', 1, registry=None)
+
+    @support.cpython_only
+    def test_issue31416(self):
+        # warn_explicit() shouldn't cause an assertion failure in case of a
+        # bad warnings.filters or warnings.defaultaction.
+        wmod = self.module
+        with original_warnings.catch_warnings(module=wmod):
+            wmod.filters = [(None, None, Warning, None, 0)]
+            with self.assertRaises(TypeError):
+                wmod.warn_explicit('foo', Warning, 'bar', 1)
+
+            wmod.filters = []
+            with support.swap_attr(wmod, 'defaultaction', None), \
+                 self.assertRaises(TypeError):
+                wmod.warn_explicit('foo', Warning, 'bar', 1)
+
+    @support.cpython_only
+    def test_issue31566(self):
+        # warn() shouldn't cause an assertion failure in case of a bad
+        # __name__ global.
+        with original_warnings.catch_warnings(module=self.module):
+            self.module.filterwarnings('error', category=UserWarning)
+            with support.swap_item(globals(), '__name__', b'foo'), \
+                 support.swap_item(globals(), '__file__', None):
+                self.assertRaises(UserWarning, self.module.warn, 'bar')
+
+
+class WarningsDisplayTests(BaseTest):
+
+    """Test the displaying of warnings and the ability to overload functions
+    related to displaying warnings."""
+
+    def test_formatwarning(self):
+        message = "msg"
+        category = Warning
+        file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
+        line_num = 5
+        file_line = linecache.getline(file_name, line_num).strip()
+        format = "%s:%s: %s: %s\n  %s\n"
+        expect = format % (file_name, line_num, category.__name__, message,
+                            file_line)
+        self.assertEqual(expect, self.module.formatwarning(message,
+                                                category, file_name, line_num))
+        # Test the 'line' argument.
+        file_line += " for the win!"
+        expect = format % (file_name, line_num, category.__name__, message,
+                            file_line)
+        self.assertEqual(expect, self.module.formatwarning(message,
+                                    category, file_name, line_num, file_line))
+
+    def test_showwarning(self):
+        file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
+        line_num = 3
+        expected_file_line = linecache.getline(file_name, line_num).strip()
+        message = 'msg'
+        category = Warning
+        file_object = StringIO()
+        expect = self.module.formatwarning(message, category, file_name,
+                                            line_num)
+        self.module.showwarning(message, category, file_name, line_num,
+                                file_object)
+        self.assertEqual(file_object.getvalue(), expect)
+        # Test 'line' argument.
+        expected_file_line += "for the win!"
+        expect = self.module.formatwarning(message, category, file_name,
+                                            line_num, expected_file_line)
+        file_object = StringIO()
+        self.module.showwarning(message, category, file_name, line_num,
+                                file_object, expected_file_line)
+        self.assertEqual(expect, file_object.getvalue())
+
+    def test_formatwarning_override(self):
+        # bpo-35178: Test that a custom formatwarning function gets the 'line'
+        # argument as a positional argument, and not only as a keyword argument
+        def myformatwarning(message, category, filename, lineno, text):
+            return f'm={message}:c={category}:f={filename}:l={lineno}:t={text}'
+
+        file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
+        line_num = 3
+        file_line = linecache.getline(file_name, line_num).strip()
+        message = 'msg'
+        category = Warning
+        file_object = StringIO()
+        expected = f'm={message}:c={category}:f={file_name}:l={line_num}' + \
+                   f':t={file_line}'
+        with support.swap_attr(self.module, 'formatwarning', myformatwarning):
+            self.module.showwarning(message, category, file_name, line_num,
+                                    file_object, file_line)
+            self.assertEqual(file_object.getvalue(), expected)
+
+
+class CWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
+    module = c_warnings
+
+class PyWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
+    module = py_warnings
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_tracemalloc(self):
+        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+
+        with open(os_helper.TESTFN, 'w', encoding="utf-8") as fp:
+            fp.write(textwrap.dedent("""
+                def func():
+                    f = open(__file__, "rb")
+                    # Emit ResourceWarning
+                    f = None
+
+                func()
+            """))
+
+        def run(*args):
+            res = assert_python_ok(*args, PYTHONIOENCODING='utf-8')
+            stderr = res.err.decode('utf-8', 'replace')
+            stderr = '\n'.join(stderr.splitlines())
+
+            # normalize newlines
+            stderr = re.sub('<.*>', '<...>', stderr)
+            return stderr
+
+        # tracemalloc disabled
+        filename = os.path.abspath(os_helper.TESTFN)
+        stderr = run('-Wd', os_helper.TESTFN)
+        expected = textwrap.dedent(f'''
+            {filename}:5: ResourceWarning: unclosed file <...>
+              f = None
+            ResourceWarning: Enable tracemalloc to get the object allocation traceback
+        ''').strip()
+        self.assertEqual(stderr, expected)
+
+        # tracemalloc enabled
+        stderr = run('-Wd', '-X', 'tracemalloc=2', os_helper.TESTFN)
+        expected = textwrap.dedent(f'''
+            {filename}:5: ResourceWarning: unclosed file <...>
+              f = None
+            Object allocated at (most recent call last):
+              File "{filename}", lineno 7
+                func()
+              File "{filename}", lineno 3
+                f = open(__file__, "rb")
+        ''').strip()
+        self.assertEqual(stderr, expected)
+
+
+class CatchWarningTests(BaseTest):
+
+    """Test catch_warnings()."""
+
+    def test_catch_warnings_restore(self):
+        wmod = self.module
+        orig_filters = wmod.filters
+        orig_showwarning = wmod.showwarning
+        # Ensure both showwarning and filters are restored when recording
+        with wmod.catch_warnings(module=wmod, record=True):
+            wmod.filters = wmod.showwarning = object()
+        self.assertIs(wmod.filters, orig_filters)
+        self.assertIs(wmod.showwarning, orig_showwarning)
+        # Same test, but with recording disabled
+        with wmod.catch_warnings(module=wmod, record=False):
+            wmod.filters = wmod.showwarning = object()
+        self.assertIs(wmod.filters, orig_filters)
+        self.assertIs(wmod.showwarning, orig_showwarning)
+
+    def test_catch_warnings_recording(self):
+        wmod = self.module
+        # Ensure warnings are recorded when requested
+        with wmod.catch_warnings(module=wmod, record=True) as w:
+            self.assertEqual(w, [])
+            self.assertIs(type(w), list)
+            wmod.simplefilter("always")
+            wmod.warn("foo")
+            self.assertEqual(str(w[-1].message), "foo")
+            wmod.warn("bar")
+            self.assertEqual(str(w[-1].message), "bar")
+            self.assertEqual(str(w[0].message), "foo")
+            self.assertEqual(str(w[1].message), "bar")
+            del w[:]
+            self.assertEqual(w, [])
+        # Ensure warnings are not recorded when not requested
+        orig_showwarning = wmod.showwarning
+        with wmod.catch_warnings(module=wmod, record=False) as w:
+            self.assertIsNone(w)
+            self.assertIs(wmod.showwarning, orig_showwarning)
+
+    def test_catch_warnings_reentry_guard(self):
+        wmod = self.module
+        # Ensure catch_warnings is protected against incorrect usage
+        x = wmod.catch_warnings(module=wmod, record=True)
+        self.assertRaises(RuntimeError, x.__exit__)
+        with x:
+            self.assertRaises(RuntimeError, x.__enter__)
+        # Same test, but with recording disabled
+        x = wmod.catch_warnings(module=wmod, record=False)
+        self.assertRaises(RuntimeError, x.__exit__)
+        with x:
+            self.assertRaises(RuntimeError, x.__enter__)
+
+    def test_catch_warnings_defaults(self):
+        wmod = self.module
+        orig_filters = wmod.filters
+        orig_showwarning = wmod.showwarning
+        # Ensure default behaviour is not to record warnings
+        with wmod.catch_warnings(module=wmod) as w:
+            self.assertIsNone(w)
+            self.assertIs(wmod.showwarning, orig_showwarning)
+            self.assertIsNot(wmod.filters, orig_filters)
+        self.assertIs(wmod.filters, orig_filters)
+        if wmod is sys.modules['warnings']:
+            # Ensure the default module is this one
+            with wmod.catch_warnings() as w:
+                self.assertIsNone(w)
+                self.assertIs(wmod.showwarning, orig_showwarning)
+                self.assertIsNot(wmod.filters, orig_filters)
+            self.assertIs(wmod.filters, orig_filters)
+
+    def test_record_override_showwarning_before(self):
+        # Issue #28835: If warnings.showwarning() was overridden, make sure
+        # that catch_warnings(record=True) overrides it again.
+        text = "This is a warning"
+        wmod = self.module
+        my_log = []
+
+        def my_logger(message, category, filename, lineno, file=None, line=None):
+            nonlocal my_log
+            my_log.append(message)
+
+        # Override warnings.showwarning() before calling catch_warnings()
+        with support.swap_attr(wmod, 'showwarning', my_logger):
+            with wmod.catch_warnings(module=wmod, record=True) as log:
+                self.assertIsNot(wmod.showwarning, my_logger)
+
+                wmod.simplefilter("always")
+                wmod.warn(text)
+
+            self.assertIs(wmod.showwarning, my_logger)
+
+        self.assertEqual(len(log), 1, log)
+        self.assertEqual(log[0].message.args[0], text)
+        self.assertEqual(my_log, [])
+
+    def test_record_override_showwarning_inside(self):
+        # Issue #28835: It is possible to override warnings.showwarning()
+        # in the catch_warnings(record=True) context manager.
+        text = "This is a warning"
+        wmod = self.module
+        my_log = []
+
+        def my_logger(message, category, filename, lineno, file=None, line=None):
+            nonlocal my_log
+            my_log.append(message)
+
+        with wmod.catch_warnings(module=wmod, record=True) as log:
+            wmod.simplefilter("always")
+            wmod.showwarning = my_logger
+            wmod.warn(text)
+
+        self.assertEqual(len(my_log), 1, my_log)
+        self.assertEqual(my_log[0].args[0], text)
+        self.assertEqual(log, [])
+
+    def test_check_warnings(self):
+        # Explicit tests for the test.support convenience wrapper
+        wmod = self.module
+        if wmod is not sys.modules['warnings']:
+            self.skipTest('module to test is not loaded warnings module')
+        with warnings_helper.check_warnings(quiet=False) as w:
+            self.assertEqual(w.warnings, [])
+            wmod.simplefilter("always")
+            wmod.warn("foo")
+            self.assertEqual(str(w.message), "foo")
+            wmod.warn("bar")
+            self.assertEqual(str(w.message), "bar")
+            self.assertEqual(str(w.warnings[0].message), "foo")
+            self.assertEqual(str(w.warnings[1].message), "bar")
+            w.reset()
+            self.assertEqual(w.warnings, [])
+
+        with warnings_helper.check_warnings():
+            # defaults to quiet=True without argument
+            pass
+        with warnings_helper.check_warnings(('foo', UserWarning)):
+            wmod.warn("foo")
+
+        with self.assertRaises(AssertionError):
+            with warnings_helper.check_warnings(('', RuntimeWarning)):
+                # defaults to quiet=False with argument
+                pass
+        with self.assertRaises(AssertionError):
+            with warnings_helper.check_warnings(('foo', RuntimeWarning)):
+                wmod.warn("foo")
+
+class CCatchWarningTests(CatchWarningTests, unittest.TestCase):
+    module = c_warnings
+
+class PyCatchWarningTests(CatchWarningTests, unittest.TestCase):
+    module = py_warnings
+
+
+class EnvironmentVariableTests(BaseTest):
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_single_warning(self):
+        rc, stdout, stderr = assert_python_ok("-c",
+            "import sys; sys.stdout.write(str(sys.warnoptions))",
+            PYTHONWARNINGS="ignore::DeprecationWarning",
+            PYTHONDEVMODE="")
+        self.assertEqual(stdout, b"['ignore::DeprecationWarning']")
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_comma_separated_warnings(self):
+        rc, stdout, stderr = assert_python_ok("-c",
+            "import sys; sys.stdout.write(str(sys.warnoptions))",
+            PYTHONWARNINGS="ignore::DeprecationWarning,ignore::UnicodeWarning",
+            PYTHONDEVMODE="")
+        self.assertEqual(stdout,
+            b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    @force_not_colorized
+    def test_envvar_and_command_line(self):
+        rc, stdout, stderr = assert_python_ok("-Wignore::UnicodeWarning", "-c",
+            "import sys; sys.stdout.write(str(sys.warnoptions))",
+            PYTHONWARNINGS="ignore::DeprecationWarning",
+            PYTHONDEVMODE="")
+        self.assertEqual(stdout,
+            b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    @force_not_colorized
+    def test_conflicting_envvar_and_command_line(self):
+        rc, stdout, stderr = assert_python_failure("-Werror::DeprecationWarning", "-c",
+            "import sys, warnings; sys.stdout.write(str(sys.warnoptions)); "
+            "warnings.warn('Message', DeprecationWarning)",
+            PYTHONWARNINGS="default::DeprecationWarning",
+            PYTHONDEVMODE="")
+        self.assertEqual(stdout,
+            b"['default::DeprecationWarning', 'error::DeprecationWarning']")
+        self.assertEqual(stderr.splitlines(),
+            [b"Traceback (most recent call last):",
+             b"  File \"<string>\", line 1, in <module>",
+             b'    import sys, warnings; sys.stdout.write(str(sys.warnoptions)); warnings.w'
+             b"arn('Message', DeprecationWarning)",
+             b'                                                                  ~~~~~~~~~~'
+             b'~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^',
+             b"DeprecationWarning: Message"])
+
+    def test_default_filter_configuration(self):
+        pure_python_api = self.module is py_warnings
+        if support.Py_DEBUG:
+            expected_default_filters = []
+        else:
+            if pure_python_api:
+                main_module_filter = re.compile("__main__")
+            else:
+                main_module_filter = "__main__"
+            expected_default_filters = [
+                ('default', None, DeprecationWarning, main_module_filter, 0),
+                ('ignore', None, DeprecationWarning, None, 0),
+                ('ignore', None, PendingDeprecationWarning, None, 0),
+                ('ignore', None, ImportWarning, None, 0),
+                ('ignore', None, ResourceWarning, None, 0),
+            ]
+        expected_output = [str(f).encode() for f in expected_default_filters]
+
+        if pure_python_api:
+            # Disable the warnings acceleration module in the subprocess
+            code = "import sys; sys.modules.pop('warnings', None); sys.modules['_warnings'] = None; "
+        else:
+            code = ""
+        code += "import warnings; [print(f) for f in warnings.filters]"
+
+        rc, stdout, stderr = assert_python_ok("-c", code, __isolated=True)
+        stdout_lines = [line.strip() for line in stdout.splitlines()]
+        self.maxDiff = None
+        self.assertEqual(stdout_lines, expected_output)
+
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii',
+                         'requires non-ascii filesystemencoding')
+    def test_nonascii(self):
+        PYTHONWARNINGS="ignore:DeprecationWarning" + os_helper.FS_NONASCII
+        rc, stdout, stderr = assert_python_ok("-c",
+            "import sys; sys.stdout.write(str(sys.warnoptions))",
+            PYTHONIOENCODING="utf-8",
+            PYTHONWARNINGS=PYTHONWARNINGS,
+            PYTHONDEVMODE="")
+        self.assertEqual(stdout, str([PYTHONWARNINGS]).encode())
+
+class CEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
+    module = c_warnings
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_default_filter_configuration(self):
+        # XXX: RUSTPYHTON; remove the entire function when fixed
+        super().test_default_filter_configuration()
+
+
+class PyEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
+    module = py_warnings
+
+
+class _DeprecatedTest(BaseTest, unittest.TestCase):
+
+    """Test _deprecated()."""
+
+    module = original_warnings
+
+    def test_warning(self):
+        version = (3, 11, 0, "final", 0)
+        test = [(4, 12), (4, 11), (4, 0), (3, 12)]
+        for remove in test:
+            msg = rf".*test_warnings.*{remove[0]}\.{remove[1]}"
+            filter = msg, DeprecationWarning
+            with self.subTest(remove=remove):
+                with warnings_helper.check_warnings(filter, quiet=False):
+                    self.module._deprecated("test_warnings", remove=remove,
+                                            _version=version)
+
+        version = (3, 11, 0, "alpha", 0)
+        msg = r".*test_warnings.*3\.11"
+        with warnings_helper.check_warnings((msg, DeprecationWarning), quiet=False):
+            self.module._deprecated("test_warnings", remove=(3, 11),
+                                    _version=version)
+
+    def test_RuntimeError(self):
+        version = (3, 11, 0, "final", 0)
+        test = [(2, 0), (2, 12), (3, 10)]
+        for remove in test:
+            with self.subTest(remove=remove):
+                with self.assertRaises(RuntimeError):
+                    self.module._deprecated("test_warnings", remove=remove,
+                                            _version=version)
+        for level in ["beta", "candidate", "final"]:
+            version = (3, 11, 0, level, 0)
+            with self.subTest(releaselevel=level):
+                with self.assertRaises(RuntimeError):
+                    self.module._deprecated("test_warnings", remove=(3, 11),
+                                            _version=version)
+
+
+class BootstrapTest(unittest.TestCase):
+
+    def test_issue_8766(self):
+        # "import encodings" emits a warning whereas the warnings is not loaded
+        # or not completely loaded (warnings imports indirectly encodings by
+        # importing linecache) yet
+        with os_helper.temp_cwd() as cwd, os_helper.temp_cwd('encodings'):
+            # encodings loaded by initfsencoding()
+            assert_python_ok('-c', 'pass', PYTHONPATH=cwd)
+
+            # Use -W to load warnings module at startup
+            assert_python_ok('-c', 'pass', '-W', 'always', PYTHONPATH=cwd)
+
+
+class FinalizationTest(unittest.TestCase):
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_finalization(self):
+        # Issue #19421: warnings.warn() should not crash
+        # during Python finalization
+        code = """
+import warnings
+warn = warnings.warn
+
+class A:
+    def __del__(self):
+        warn("test")
+
+a=A()
+        """
+        rc, out, err = assert_python_ok("-c", code)
+        self.assertEqual(err.decode().rstrip(),
+                         '<string>:7: UserWarning: test')
+
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
+    def test_late_resource_warning(self):
+        # Issue #21925: Emitting a ResourceWarning late during the Python
+        # shutdown must be logged.
+
+        expected = b"<sys>:0: ResourceWarning: unclosed file "
+
+        # don't import the warnings module
+        # (_warnings will try to import it)
+        code = "f = open(%a)" % __file__
+        rc, out, err = assert_python_ok("-Wd", "-c", code)
+        self.assertTrue(err.startswith(expected), ascii(err))
+
+        # import the warnings module
+        code = "import warnings; f = open(%a)" % __file__
+        rc, out, err = assert_python_ok("-Wd", "-c", code)
+        self.assertTrue(err.startswith(expected), ascii(err))
+
+
+class DeprecatedTests(unittest.TestCase):
+    def test_dunder_deprecated(self):
+        @deprecated("A will go away soon")
+        class A:
+            pass
+
+        self.assertEqual(A.__deprecated__, "A will go away soon")
+        self.assertIsInstance(A, type)
+
+        @deprecated("b will go away soon")
+        def b():
+            pass
+
+        self.assertEqual(b.__deprecated__, "b will go away soon")
+        self.assertIsInstance(b, types.FunctionType)
+
+        @overload
+        @deprecated("no more ints")
+        def h(x: int) -> int: ...
+        @overload
+        def h(x: str) -> str: ...
+        def h(x):
+            return x
+
+        overloads = get_overloads(h)
+        self.assertEqual(len(overloads), 2)
+        self.assertEqual(overloads[0].__deprecated__, "no more ints")
+
+    def test_class(self):
+        @deprecated("A will go away soon")
+        class A:
+            pass
+
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            A()
+        with self.assertWarnsRegex(DeprecationWarning, "A will go away soon"):
+            with self.assertRaises(TypeError):
+                A(42)
+
+    def test_class_with_init(self):
+        @deprecated("HasInit will go away soon")
+        class HasInit:
+            def __init__(self, x):
+                self.x = x
+
+        with self.assertWarnsRegex(DeprecationWarning, "HasInit will go away soon"):
+            instance = HasInit(42)
+        self.assertEqual(instance.x, 42)
+
+    def test_class_with_new(self):
+        has_new_called = False
+
+        @deprecated("HasNew will go away soon")
+        class HasNew:
+            def __new__(cls, x):
+                nonlocal has_new_called
+                has_new_called = True
+                return super().__new__(cls)
+
+            def __init__(self, x) -> None:
+                self.x = x
+
+        with self.assertWarnsRegex(DeprecationWarning, "HasNew will go away soon"):
+            instance = HasNew(42)
+        self.assertEqual(instance.x, 42)
+        self.assertTrue(has_new_called)
+
+    def test_class_with_inherited_new(self):
+        new_base_called = False
+
+        class NewBase:
+            def __new__(cls, x):
+                nonlocal new_base_called
+                new_base_called = True
+                return super().__new__(cls)
+
+            def __init__(self, x) -> None:
+                self.x = x
+
+        @deprecated("HasInheritedNew will go away soon")
+        class HasInheritedNew(NewBase):
+            pass
+
+        with self.assertWarnsRegex(DeprecationWarning, "HasInheritedNew will go away soon"):
+            instance = HasInheritedNew(42)
+        self.assertEqual(instance.x, 42)
+        self.assertTrue(new_base_called)
+
+    def test_class_with_new_but_no_init(self):
+        new_called = False
+
+        @deprecated("HasNewNoInit will go away soon")
+        class HasNewNoInit:
+            def __new__(cls, x):
+                nonlocal new_called
+                new_called = True
+                obj = super().__new__(cls)
+                obj.x = x
+                return obj
+
+        with self.assertWarnsRegex(DeprecationWarning, "HasNewNoInit will go away soon"):
+            instance = HasNewNoInit(42)
+        self.assertEqual(instance.x, 42)
+        self.assertTrue(new_called)
+
+    def test_mixin_class(self):
+        @deprecated("Mixin will go away soon")
+        class Mixin:
+            pass
+
+        class Base:
+            def __init__(self, a) -> None:
+                self.a = a
+
+        with self.assertWarnsRegex(DeprecationWarning, "Mixin will go away soon"):
+            class Child(Base, Mixin):
+                pass
+
+        instance = Child(42)
+        self.assertEqual(instance.a, 42)
+
+    def test_do_not_shadow_user_arguments(self):
+        new_called = False
+        new_called_cls = None
+
+        @deprecated("MyMeta will go away soon")
+        class MyMeta(type):
+            def __new__(mcs, name, bases, attrs, cls=None):
+                nonlocal new_called, new_called_cls
+                new_called = True
+                new_called_cls = cls
+                return super().__new__(mcs, name, bases, attrs)
+
+        with self.assertWarnsRegex(DeprecationWarning, "MyMeta will go away soon"):
+            class Foo(metaclass=MyMeta, cls='haha'):
+                pass
+
+        self.assertTrue(new_called)
+        self.assertEqual(new_called_cls, 'haha')
+
+    def test_existing_init_subclass(self):
+        @deprecated("C will go away soon")
+        class C:
+            def __init_subclass__(cls) -> None:
+                cls.inited = True
+
+        with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):
+            C()
+
+        with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):
+            class D(C):
+                pass
+
+        self.assertTrue(D.inited)
+        self.assertIsInstance(D(), D)  # no deprecation
+
+    def test_existing_init_subclass_in_base(self):
+        class Base:
+            def __init_subclass__(cls, x) -> None:
+                cls.inited = x
+
+        @deprecated("C will go away soon")
+        class C(Base, x=42):
+            pass
+
+        self.assertEqual(C.inited, 42)
+
+        with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):
+            C()
+
+        with self.assertWarnsRegex(DeprecationWarning, "C will go away soon"):
+            class D(C, x=3):
+                pass
+
+        self.assertEqual(D.inited, 3)
+
+    def test_init_subclass_has_correct_cls(self):
+        init_subclass_saw = None
+
+        @deprecated("Base will go away soon")
+        class Base:
+            def __init_subclass__(cls) -> None:
+                nonlocal init_subclass_saw
+                init_subclass_saw = cls
+
+        self.assertIsNone(init_subclass_saw)
+
+        with self.assertWarnsRegex(DeprecationWarning, "Base will go away soon"):
+            class C(Base):
+                pass
+
+        self.assertIs(init_subclass_saw, C)
+
+    def test_init_subclass_with_explicit_classmethod(self):
+        init_subclass_saw = None
+
+        @deprecated("Base will go away soon")
+        class Base:
+            @classmethod
+            def __init_subclass__(cls) -> None:
+                nonlocal init_subclass_saw
+                init_subclass_saw = cls
+
+        self.assertIsNone(init_subclass_saw)
+
+        with self.assertWarnsRegex(DeprecationWarning, "Base will go away soon"):
+            class C(Base):
+                pass
+
+        self.assertIs(init_subclass_saw, C)
+
+    def test_function(self):
+        @deprecated("b will go away soon")
+        def b():
+            pass
+
+        with self.assertWarnsRegex(DeprecationWarning, "b will go away soon"):
+            b()
+
+    def test_method(self):
+        class Capybara:
+            @deprecated("x will go away soon")
+            def x(self):
+                pass
+
+        instance = Capybara()
+        with self.assertWarnsRegex(DeprecationWarning, "x will go away soon"):
+            instance.x()
+
+    def test_property(self):
+        class Capybara:
+            @property
+            @deprecated("x will go away soon")
+            def x(self):
+                pass
+
+            @property
+            def no_more_setting(self):
+                return 42
+
+            @no_more_setting.setter
+            @deprecated("no more setting")
+            def no_more_setting(self, value):
+                pass
+
+        instance = Capybara()
+        with self.assertWarnsRegex(DeprecationWarning, "x will go away soon"):
+            instance.x
+
+        with py_warnings.catch_warnings():
+            py_warnings.simplefilter("error")
+            self.assertEqual(instance.no_more_setting, 42)
+
+        with self.assertWarnsRegex(DeprecationWarning, "no more setting"):
+            instance.no_more_setting = 42
+
+    def test_category(self):
+        @deprecated("c will go away soon", category=RuntimeWarning)
+        def c():
+            pass
+
+        with self.assertWarnsRegex(RuntimeWarning, "c will go away soon"):
+            c()
+
+    def test_turn_off_warnings(self):
+        @deprecated("d will go away soon", category=None)
+        def d():
+            pass
+
+        with py_warnings.catch_warnings():
+            py_warnings.simplefilter("error")
+            d()
+
+    def test_only_strings_allowed(self):
+        with self.assertRaisesRegex(
+            TypeError,
+            "Expected an object of type str for 'message', not 'type'"
+        ):
+            @deprecated
+            class Foo: ...
+
+        with self.assertRaisesRegex(
+            TypeError,
+            "Expected an object of type str for 'message', not 'function'"
+        ):
+            @deprecated
+            def foo(): ...
+
+    def test_no_retained_references_to_wrapper_instance(self):
+        @deprecated('depr')
+        def d(): pass
+
+        self.assertFalse(any(
+            isinstance(cell.cell_contents, deprecated) for cell in d.__closure__
+        ))
+
+    def test_inspect(self):
+        @deprecated("depr")
+        def sync():
+            pass
+
+        @deprecated("depr")
+        async def coro():
+            pass
+
+        class Cls:
+            @deprecated("depr")
+            def sync(self):
+                pass
+
+            @deprecated("depr")
+            async def coro(self):
+                pass
+
+        self.assertFalse(inspect.iscoroutinefunction(sync))
+        self.assertTrue(inspect.iscoroutinefunction(coro))
+        self.assertFalse(inspect.iscoroutinefunction(Cls.sync))
+        self.assertTrue(inspect.iscoroutinefunction(Cls.coro))
+
+    def test_inspect_class_signature(self):
+        class Cls1:  # no __init__ or __new__
+            pass
+
+        class Cls2:  # __new__ only
+            def __new__(cls, x, y):
+                return super().__new__(cls)
+
+        class Cls3:  # __init__ only
+            def __init__(self, x, y):
+                pass
+
+        class Cls4:  # __new__ and __init__
+            def __new__(cls, x, y):
+                return super().__new__(cls)
+
+            def __init__(self, x, y):
+                pass
+
+        class Cls5(Cls1):  # inherits no __init__ or __new__
+            pass
+
+        class Cls6(Cls2):  # inherits __new__ only
+            pass
+
+        class Cls7(Cls3):  # inherits __init__ only
+            pass
+
+        class Cls8(Cls4):  # inherits __new__ and __init__
+            pass
+
+        # The `@deprecated` decorator will update the class in-place.
+        # Test the child classes first.
+        for cls in reversed((Cls1, Cls2, Cls3, Cls4, Cls5, Cls6, Cls7, Cls8)):
+            with self.subTest(f'class {cls.__name__} signature'):
+                try:
+                    original_signature = inspect.signature(cls)
+                except ValueError:
+                    original_signature = None
+                try:
+                    original_new_signature = inspect.signature(cls.__new__)
+                except ValueError:
+                    original_new_signature = None
+
+                deprecated_cls = deprecated("depr")(cls)
+
+                try:
+                    deprecated_signature = inspect.signature(deprecated_cls)
+                except ValueError:
+                    deprecated_signature = None
+                self.assertEqual(original_signature, deprecated_signature)
+
+                try:
+                    deprecated_new_signature = inspect.signature(deprecated_cls.__new__)
+                except ValueError:
+                    deprecated_new_signature = None
+                self.assertEqual(original_new_signature, deprecated_new_signature)
+
+
+def setUpModule():
+    py_warnings.onceregistry.clear()
+    c_warnings.onceregistry.clear()
+
+
+tearDownModule = setUpModule
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_warnings/__main__.py b/Lib/test/test_warnings/__main__.py
new file mode 100644
index 0000000000..44e52ec070
--- /dev/null
+++ b/Lib/test/test_warnings/__main__.py
@@ -0,0 +1,3 @@
+import unittest
+
+unittest.main('test.test_warnings')
diff --git a/Lib/test/test_warnings/data/import_warning.py b/Lib/test/test_warnings/data/import_warning.py
new file mode 100644
index 0000000000..32daec1140
--- /dev/null
+++ b/Lib/test/test_warnings/data/import_warning.py
@@ -0,0 +1,3 @@
+import warnings
+
+warnings.warn('module-level warning', DeprecationWarning, stacklevel=2)
diff --git a/Lib/test/test_warnings/data/package_helper.py b/Lib/test/test_warnings/data/package_helper.py
new file mode 100644
index 0000000000..c22a4f6405
--- /dev/null
+++ b/Lib/test/test_warnings/data/package_helper.py
@@ -0,0 +1,10 @@
+# helper to the helper for testing skip_file_prefixes.
+
+import os
+
+package_path = os.path.dirname(__file__)
+
+def inner_api(message, *, stacklevel, warnings_module):
+    warnings_module.warn(
+            message, stacklevel=stacklevel,
+            skip_file_prefixes=(package_path,))
diff --git a/Lib/test/test_warnings/data/stacklevel.py b/Lib/test/test_warnings/data/stacklevel.py
new file mode 100644
index 0000000000..c6dd24733b
--- /dev/null
+++ b/Lib/test/test_warnings/data/stacklevel.py
@@ -0,0 +1,15 @@
+# Helper module for testing stacklevel and skip_file_prefixes arguments
+# of warnings.warn()
+
+import warnings
+from test.test_warnings.data import package_helper
+
+def outer(message, stacklevel=1):
+    inner(message, stacklevel)
+
+def inner(message, stacklevel=1):
+    warnings.warn(message, stacklevel=stacklevel)
+
+def package(message, *, stacklevel):
+    package_helper.inner_api(message, stacklevel=stacklevel,
+                             warnings_module=warnings)
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index 7d204f3c4c..c118987411 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -1,5 +1,6 @@
 import gc
 import sys
+import doctest
 import unittest
 import collections
 import weakref
@@ -9,10 +10,14 @@
 import threading
 import time
 import random
+import textwrap
 
 from test import support
-from test.support import script_helper, ALWAYS_EQ
+from test.support import script_helper, ALWAYS_EQ, suppress_immortalization
 from test.support import gc_collect
+from test.support import import_helper
+from test.support import threading_helper
+from test.support import is_wasi, Py_DEBUG
 
 # Used in ReferencesTestCase.test_ref_created_during_del() .
 ref_from_del = None
@@ -77,7 +82,7 @@ def callback(self, ref):
 
 
 @contextlib.contextmanager
-def collect_in_thread(period=0.0001):
+def collect_in_thread(period=0.005):
     """
     Ensure GC collections happen in a different thread, at a high frequency.
     """
@@ -114,6 +119,49 @@ def test_basic_ref(self):
         del o
         repr(wr)
 
+    @support.cpython_only
+    def test_ref_repr(self):
+        obj = C()
+        ref = weakref.ref(obj)
+        regex = (
+            rf"<weakref at 0x[0-9a-fA-F]+; "
+            rf"to '{'' if __name__ == '__main__' else C.__module__ + '.'}{C.__qualname__}' "
+            rf"at 0x[0-9a-fA-F]+>"
+        )
+        self.assertRegex(repr(ref), regex)
+
+        obj = None
+        gc_collect()
+        self.assertRegex(repr(ref),
+                         rf'<weakref at 0x[0-9a-fA-F]+; dead>')
+
+        # test type with __name__
+        class WithName:
+            @property
+            def __name__(self):
+                return "custom_name"
+
+        obj2 = WithName()
+        ref2 = weakref.ref(obj2)
+        regex = (
+            rf"<weakref at 0x[0-9a-fA-F]+; "
+            rf"to '{'' if __name__ == '__main__' else WithName.__module__ + '.'}"
+            rf"{WithName.__qualname__}' "
+            rf"at 0x[0-9a-fA-F]+ +\(custom_name\)>"
+        )
+        self.assertRegex(repr(ref2), regex)
+
+    def test_repr_failure_gh99184(self):
+        class MyConfig(dict):
+            def __getattr__(self, x):
+                return self[x]
+
+        obj = MyConfig(offset=5)
+        obj_weakref = weakref.ref(obj)
+
+        self.assertIn('MyConfig', repr(obj_weakref))
+        self.assertIn('MyConfig', str(obj_weakref))
+
     def test_basic_callback(self):
         self.check_basic_callback(C)
         self.check_basic_callback(create_function)
@@ -121,7 +169,7 @@ def test_basic_callback(self):
 
     @support.cpython_only
     def test_cfunction(self):
-        import _testcapi
+        _testcapi = import_helper.import_module("_testcapi")
         create_cfunction = _testcapi.create_cfunction
         f = create_cfunction()
         wr = weakref.ref(f)
@@ -182,6 +230,22 @@ def check(proxy):
         self.assertRaises(ReferenceError, bool, ref3)
         self.assertEqual(self.cbcalled, 2)
 
+    @support.cpython_only
+    def test_proxy_repr(self):
+        obj = C()
+        ref = weakref.proxy(obj, self.callback)
+        regex = (
+            rf"<weakproxy at 0x[0-9a-fA-F]+; "
+            rf"to '{'' if __name__ == '__main__' else C.__module__ + '.'}{C.__qualname__}' "
+            rf"at 0x[0-9a-fA-F]+>"
+        )
+        self.assertRegex(repr(ref), regex)
+
+        obj = None
+        gc_collect()
+        self.assertRegex(repr(ref),
+                         rf'<weakproxy at 0x[0-9a-fA-F]+; dead>')
+
     def check_basic_ref(self, factory):
         o = factory()
         ref = weakref.ref(o)
@@ -225,8 +289,7 @@ def test_ref_reuse(self):
         self.assertEqual(weakref.getweakrefcount(o), 1,
                      "wrong weak ref count for object after deleting proxy")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_reuse(self):
         o = C()
         proxy1 = weakref.proxy(o)
@@ -274,8 +337,7 @@ def __bytes__(self):
         self.assertIn("__bytes__", dir(weakref.proxy(instance)))
         self.assertEqual(bytes(weakref.proxy(instance)), b"bytes")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_index(self):
         class C:
             def __index__(self):
@@ -284,8 +346,7 @@ def __index__(self):
         p = weakref.proxy(o)
         self.assertEqual(operator.index(p), 10)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_div(self):
         class C:
             def __floordiv__(self, other):
@@ -298,8 +359,7 @@ def __ifloordiv__(self, other):
         p //= 5
         self.assertEqual(p, 21)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_matmul(self):
         class C:
             def __matmul__(self, other):
@@ -323,13 +383,11 @@ def __imatmul__(self, other):
     # was not honored, and was broken in different ways for
     # PyWeakref_NewRef() and PyWeakref_NewProxy().  (Two tests.)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_shared_ref_without_callback(self):
         self.check_shared_without_callback(weakref.ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_shared_proxy_without_callback(self):
         self.check_shared_without_callback(weakref.proxy)
 
@@ -351,8 +409,7 @@ def check_shared_without_callback(self, makeref):
         p2 = makeref(o)
         self.assertIs(p1, p2, "callbacks were None, NULL in the C API")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callable_proxy(self):
         o = Callable()
         ref1 = weakref.proxy(o)
@@ -447,8 +504,7 @@ def __iter__(self):
         # Calls proxy.__next__
         self.assertEqual(list(weak_it), [4, 5, 6])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_proxy_bad_next(self):
         # bpo-44720: PyIter_Next() shouldn't be called if the reference
         # isn't an iterator.
@@ -538,8 +594,7 @@ def test_getweakrefs(self):
         self.assertEqual(weakref.getweakrefs(1), [],
                      "list of refs does not match for int")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_newstyle_number_ops(self):
         class F(float):
             pass
@@ -613,7 +668,8 @@ class C(object):
         # deallocation of c2.
         del c2
 
-    def test_callback_in_cycle_1(self):
+    @suppress_immortalization()
+    def test_callback_in_cycle(self):
         import gc
 
         class J(object):
@@ -653,40 +709,11 @@ def acallback(self, ignore):
         del I, J, II
         gc.collect()
 
-    def test_callback_in_cycle_2(self):
+    def test_callback_reachable_one_way(self):
         import gc
 
-        # This is just like test_callback_in_cycle_1, except that II is an
-        # old-style class.  The symptom is different then:  an instance of an
-        # old-style class looks in its own __dict__ first.  'J' happens to
-        # get cleared from I.__dict__ before 'wr', and 'J' was never in II's
-        # __dict__, so the attribute isn't found.  The difference is that
-        # the old-style II doesn't have a NULL __mro__ (it doesn't have any
-        # __mro__), so no segfault occurs.  Instead it got:
-        #    test_callback_in_cycle_2 (__main__.ReferencesTestCase) ...
-        #    Exception exceptions.AttributeError:
-        #   "II instance has no attribute 'J'" in <bound method II.acallback
-        #       of <?.II instance at 0x00B9B4B8>> ignored
-
-        class J(object):
-            pass
-
-        class II:
-            def acallback(self, ignore):
-                self.J
-
-        I = II()
-        I.J = J
-        I.wr = weakref.ref(J, I.acallback)
-
-        del I, J, II
-        gc.collect()
-
-    def test_callback_in_cycle_3(self):
-        import gc
-
-        # This one broke the first patch that fixed the last two.  In this
-        # case, the objects reachable from the callback aren't also reachable
+        # This one broke the first patch that fixed the previous test. In this case,
+        # the objects reachable from the callback aren't also reachable
         # from the object (c1) *triggering* the callback:  you can get to
         # c1 from c2, but not vice-versa.  The result was that c2's __dict__
         # got tp_clear'ed by the time the c2.cb callback got invoked.
@@ -706,10 +733,10 @@ def cb(self, ignore):
         del c1, c2
         gc.collect()
 
-    def test_callback_in_cycle_4(self):
+    def test_callback_different_classes(self):
         import gc
 
-        # Like test_callback_in_cycle_3, except c2 and c1 have different
+        # Like test_callback_reachable_one_way, except c2 and c1 have different
         # classes.  c2's class (C) isn't reachable from c1 then, so protecting
         # objects reachable from the dying object (c1) isn't enough to stop
         # c2's class (C) from getting tp_clear'ed before c2.cb is invoked.
@@ -734,8 +761,8 @@ class D:
         del c1, c2, C, D
         gc.collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @suppress_immortalization()
     def test_callback_in_cycle_resurrection(self):
         import gc
 
@@ -782,8 +809,7 @@ def C_went_away(ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callbacks_on_callback(self):
         import gc
 
@@ -822,13 +848,11 @@ def cb(self, ignore):
         gc.collect()
         self.assertEqual(alist, [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_ref_creation(self):
         self.check_gc_during_creation(weakref.ref)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_gc_during_proxy_creation(self):
         self.check_gc_during_creation(weakref.proxy)
 
@@ -869,8 +893,6 @@ def __del__(self):
 
         w = Target()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_init(self):
         # Issue 3634
         # <weakref to class>.__init__() doesn't check errors correctly
@@ -879,6 +901,7 @@ 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):
@@ -958,6 +981,7 @@ def test_hashing(self):
         self.assertEqual(hash(a), hash(42))
         self.assertRaises(TypeError, hash, b)
 
+    @unittest.skipIf(is_wasi and Py_DEBUG, "requires deep stack")
     def test_trashcan_16602(self):
         # Issue #16602: when a weakref's target was part of a long
         # deallocation chain, the trashcan mechanism could delay clearing
@@ -979,8 +1003,7 @@ def cb(wparent):
         del root
         gc.collect()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callback_attribute(self):
         x = Object(1)
         callback = lambda ref: None
@@ -990,8 +1013,7 @@ def test_callback_attribute(self):
         ref2 = weakref.ref(x)
         self.assertIsNone(ref2.__callback__)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_callback_attribute_after_deletion(self):
         x = Object(1)
         ref = weakref.ref(x, self.callback)
@@ -1015,11 +1037,35 @@ def __del__(self): pass
         del x
         support.gc_collect()
 
+    @support.cpython_only
+    def test_no_memory_when_clearing(self):
+        # gh-118331: Make sure we do not raise an exception from the destructor
+        # when clearing weakrefs if allocating the intermediate tuple fails.
+        code = textwrap.dedent("""
+        import _testcapi
+        import weakref
+
+        class TestObj:
+            pass
+
+        def callback(obj):
+            pass
+
+        obj = TestObj()
+        # The choice of 50 is arbitrary, but must be large enough to ensure
+        # the allocation won't be serviced by the free list.
+        wrs = [weakref.ref(obj, callback) for _ in range(50)]
+        _testcapi.set_nomemory(0)
+        del obj
+        """).strip()
+        res, _ = script_helper.run_python_until_end("-c", code)
+        stderr = res.err.decode("ascii", "backslashreplace")
+        self.assertNotRegex(stderr, "_Py_Dealloc: Deallocator of type 'TestObj'")
+
 
 class SubclassableWeakrefTestCase(TestBase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs(self):
         class MyRef(weakref.ref):
             def __init__(self, ob, callback=None, value=42):
@@ -1038,8 +1084,7 @@ def __call__(self):
         self.assertIsNone(mr())
         self.assertTrue(mr.called)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_refs_dont_replace_standard_refs(self):
         class MyRef(weakref.ref):
             pass
@@ -1068,8 +1113,6 @@ class MyRef(weakref.ref):
         self.assertIn(r1, refs)
         self.assertIn(r2, refs)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_subclass_refs_with_slots(self):
         class MyRef(weakref.ref):
             __slots__ = "slot1", "slot2"
@@ -1267,6 +1310,12 @@ class MappingTestCase(TestBase):
 
     COUNT = 10
 
+    if support.check_sanitizer(thread=True) and support.Py_GIL_DISABLED:
+        # Reduce iteration count to get acceptable latency
+        NUM_THREADED_ITERATIONS = 1000
+    else:
+        NUM_THREADED_ITERATIONS = 100000
+
     def check_len_cycles(self, dict_type, cons):
         N = 20
         items = [RefCycle() for i in range(N)]
@@ -1287,13 +1336,11 @@ def check_len_cycles(self, dict_type, cons):
         self.assertIn(n1, (0, 1))
         self.assertEqual(n2, 0)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_cycles(self):
         self.check_len_cycles(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_cycles(self):
         self.check_len_cycles(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1321,13 +1368,11 @@ def check_len_race(self, dict_type, cons):
             self.assertGreaterEqual(n2, 0)
             self.assertLessEqual(n2, n1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_len_race(self):
         self.check_len_race(weakref.WeakKeyDictionary, lambda k: (k, 1))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_valued_len_race(self):
         self.check_len_race(weakref.WeakValueDictionary, lambda k: (1, k))
 
@@ -1828,8 +1873,7 @@ def test_weak_valued_delitem(self):
         self.assertEqual(len(d), 1)
         self.assertEqual(list(d.items()), [('something else', o2)])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_weak_keyed_bad_delitem(self):
         d = weakref.WeakKeyDictionary()
         o = Object('1')
@@ -1898,34 +1942,56 @@ def test_make_weak_keyed_dict_repr(self):
         dict = weakref.WeakKeyDictionary()
         self.assertRegex(repr(dict), '<WeakKeyDictionary at 0x.*>')
 
+    @threading_helper.requires_working_threading()
     def test_threaded_weak_valued_setdefault(self):
         d = weakref.WeakValueDictionary()
         with collect_in_thread():
-            for i in range(100000):
+            for i in range(self.NUM_THREADED_ITERATIONS):
                 x = d.setdefault(10, RefCycle())
                 self.assertIsNot(x, None)  # we never put None in there!
                 del x
 
+    @threading_helper.requires_working_threading()
     def test_threaded_weak_valued_pop(self):
         d = weakref.WeakValueDictionary()
         with collect_in_thread():
-            for i in range(100000):
+            for i in range(self.NUM_THREADED_ITERATIONS):
                 d[10] = RefCycle()
                 x = d.pop(10, 10)
                 self.assertIsNot(x, None)  # we never put None in there!
 
+    @threading_helper.requires_working_threading()
     def test_threaded_weak_valued_consistency(self):
         # Issue #28427: old keys should not remove new values from
         # WeakValueDictionary when collecting from another thread.
         d = weakref.WeakValueDictionary()
         with collect_in_thread():
-            for i in range(200000):
+            for i in range(2 * self.NUM_THREADED_ITERATIONS):
                 o = RefCycle()
                 d[10] = o
                 # o is still alive, so the dict can't be empty
                 self.assertEqual(len(d), 1)
                 o = None  # lose ref
 
+    @support.cpython_only
+    def test_weak_valued_consistency(self):
+        # A single-threaded, deterministic repro for issue #28427: old keys
+        # should not remove new values from WeakValueDictionary. This relies on
+        # an implementation detail of CPython's WeakValueDictionary (its
+        # underlying dictionary of KeyedRefs) to reproduce the issue.
+        d = weakref.WeakValueDictionary()
+        with support.disable_gc():
+            d[10] = RefCycle()
+            # Keep the KeyedRef alive after it's replaced so that GC will invoke
+            # the callback.
+            wr = d.data[10]
+            # Replace the value with something that isn't cyclic garbage
+            o = RefCycle()
+            d[10] = o
+            # Trigger GC, which will invoke the callback for `wr`
+            gc.collect()
+            self.assertEqual(len(d), 1)
+
     def check_threaded_weak_dict_copy(self, type_, deepcopy):
         # `type_` should be either WeakKeyDictionary or WeakValueDictionary.
         # `deepcopy` should be either True or False.
@@ -1987,22 +2053,28 @@ def pop_and_collect(lst):
         if exc:
             raise exc[0]
 
+    @threading_helper.requires_working_threading()
     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)
 
+    @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
     def test_threaded_weak_key_dict_deepcopy(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, True)
 
-    @unittest.skip("TODO: RUSTPYTHON; occasionally crash (Exit code -6)")
+    @unittest.skip('TODO: RUSTPYTHON; occasionally crash (Exit code -6)')
+    @threading_helper.requires_working_threading()
     def test_threaded_weak_value_dict_copy(self):
         # Issue #35615: Weakref keys or values getting GC'ed during dict
         # copying should not result in a crash.
         self.check_threaded_weak_dict_copy(weakref.WeakValueDictionary, False)
 
+    @threading_helper.requires_working_threading()
+    @support.requires_resource('cpu')
     def test_threaded_weak_value_dict_deepcopy(self):
         # Issue #35615: Weakref keys or values getting GC'ed during dict
         # copying should not result in a crash.
@@ -2185,7 +2257,7 @@ def error():
         assert f3.atexit == True
         assert f4.atexit == True
 
-    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON Windows')
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; Windows')
     def test_atexit(self):
         prog = ('from test.test_weakref import FinalizeTestCase;'+
                 'FinalizeTestCase.run_in_child()')
@@ -2195,6 +2267,18 @@ def test_atexit(self):
         self.assertTrue(b'ZeroDivisionError' in err)
 
 
+class ModuleTestCase(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_names(self):
+        for name in ('ReferenceType', 'ProxyType', 'CallableProxyType',
+                     'WeakMethod', 'WeakSet', 'WeakKeyDictionary', 'WeakValueDictionary'):
+            obj = getattr(weakref, name)
+            if name != 'WeakSet':
+                self.assertEqual(obj.__module__, 'weakref')
+            self.assertEqual(obj.__name__, name)
+            self.assertEqual(obj.__qualname__, name)
+
+
 libreftest = """ Doctest for examples in the library reference: weakref.rst
 
 >>> from test.support import gc_collect
@@ -2283,19 +2367,12 @@ def test_atexit(self):
 
 __test__ = {'libreftest' : libreftest}
 
-def test_main():
-    support.run_unittest(
-        ReferencesTestCase,
-        WeakMethodTestCase,
-        MappingTestCase,
-        WeakValueDictionaryTestCase,
-        WeakKeyDictionaryTestCase,
-        SubclassableWeakrefTestCase,
-        FinalizeTestCase,
-        )
+def load_tests(loader, tests, pattern):
     # TODO: RUSTPYTHON
-    # support.run_doctest(sys.modules[__name__])
+    # The doctest fails
+    # tests.addTest(doctest.DocTestSuite())
+    return tests
 
 
 if __name__ == "__main__":
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_weakset.py b/Lib/test/test_weakset.py
index 6c4cb05a5f..5e8cacc09d 100644
--- a/Lib/test/test_weakset.py
+++ b/Lib/test/test_weakset.py
@@ -44,7 +44,7 @@ def setUp(self):
     def test_methods(self):
         weaksetmethods = dir(WeakSet)
         for method in dir(set):
-            if method == 'test_c_api' or method.startswith('_'):
+            if method.startswith('_'):
                 continue
             self.assertIn(method, weaksetmethods,
                          "WeakSet missing method " + method)
@@ -458,8 +458,6 @@ def test_abc(self):
         self.assertIsInstance(self.s, Set)
         self.assertIsInstance(self.s, MutableSet)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_copying(self):
         for cls in WeakSet, WeakSetWithSlots:
             s = cls(self.items)
diff --git a/Lib/test/test_winapi.py b/Lib/test/test_winapi.py
index 7a33f90698..99b5a0dfd1 100644
--- a/Lib/test/test_winapi.py
+++ b/Lib/test/test_winapi.py
@@ -77,41 +77,27 @@ def _events_waitany_test(self, n):
                 evts[i] = old_evt
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_few_events_waitall(self):
         self._events_waitall_test(16)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_events_waitall(self):
         self._events_waitall_test(256)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_events_waitall(self):
         self._events_waitall_test(MAXIMUM_BATCHED_WAIT_OBJECTS)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_few_events_waitany(self):
         self._events_waitany_test(16)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_many_events_waitany(self):
         self._events_waitany_test(256)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_max_events_waitany(self):
         self._events_waitany_test(MAXIMUM_BATCHED_WAIT_OBJECTS)
 
 
 class WinAPITests(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getlongpathname(self):
         testfn = pathlib.Path(os.getenv("ProgramFiles")).parents[-1] / "PROGRA~1"
         if not os.path.isdir(testfn):
@@ -128,8 +114,6 @@ def test_getlongpathname(self):
         candidates = set(testfn.parent.glob("Progra*"))
         self.assertIn(pathlib.Path(actual), candidates)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_getshortpathname(self):
         testfn = pathlib.Path(os.getenv("ProgramFiles"))
         if not os.path.isdir(testfn):
@@ -144,8 +128,6 @@ def test_getshortpathname(self):
         # Should contain "PROGRA~" but we can't predict the number
         self.assertIsNotNone(re.match(r".\:\\PROGRA~\d", actual.upper()), actual)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_namedpipe(self):
         pipe_name = rf"\\.\pipe\LOCAL\{os_helper.TESTFN}"
 
diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py
new file mode 100644
index 0000000000..924a962781
--- /dev/null
+++ b/Lib/test/test_winreg.py
@@ -0,0 +1,525 @@
+# Test the windows specific win32reg module.
+# Only win32reg functions not hit here: FlushKey, LoadKey and SaveKey
+
+import gc
+import os, sys, errno
+import threading
+import unittest
+from platform import machine, win32_edition
+from test.support import cpython_only, import_helper
+
+# Do this first so test will be skipped if module doesn't exist
+import_helper.import_module('winreg', required_on=['win'])
+# Now import everything
+from winreg import *
+
+try:
+    REMOTE_NAME = sys.argv[sys.argv.index("--remote")+1]
+except (IndexError, ValueError):
+    REMOTE_NAME = None
+
+# tuple of (major, minor)
+WIN_VER = sys.getwindowsversion()[:2]
+# Some tests should only run on 64-bit architectures where WOW64 will be.
+WIN64_MACHINE = True if machine() == "AMD64" else False
+
+# Starting with Windows 7 and Windows Server 2008 R2, WOW64 no longer uses
+# registry reflection and formerly reflected keys are shared instead.
+# Windows 7 and Windows Server 2008 R2 are version 6.1. Due to this, some
+# tests are only valid up until 6.1
+HAS_REFLECTION = True if WIN_VER < (6, 1) else False
+
+# Use a per-process key to prevent concurrent test runs (buildbot!) from
+# stomping on each other.
+test_key_base = "Python Test Key [%d] - Delete Me" % (os.getpid(),)
+test_key_name = "SOFTWARE\\" + test_key_base
+# On OS'es that support reflection we should test with a reflected key
+test_reflect_key_name = "SOFTWARE\\Classes\\" + test_key_base
+
+test_data = [
+    ("Int Value",     45,                                      REG_DWORD),
+    ("Qword Value",   0x1122334455667788,                      REG_QWORD),
+    ("String Val",    "A string value",                        REG_SZ),
+    ("StringExpand",  "The path is %path%",                    REG_EXPAND_SZ),
+    ("Multi-string",  ["Lots", "of", "string", "values"],      REG_MULTI_SZ),
+    ("Multi-nul",     ["", "", "", ""],                        REG_MULTI_SZ),
+    ("Raw Data",      b"binary\x00data",                       REG_BINARY),
+    ("Big String",    "x"*(2**14-1),                           REG_SZ),
+    ("Big Binary",    b"x"*(2**14),                            REG_BINARY),
+    # Two and three kanjis, meaning: "Japan" and "Japanese".
+    ("Japanese 日本", "日本語", REG_SZ),
+]
+
+
+@cpython_only
+class HeapTypeTests(unittest.TestCase):
+    def test_have_gc(self):
+        self.assertTrue(gc.is_tracked(HKEYType))
+
+    def test_immutable(self):
+        with self.assertRaisesRegex(TypeError, "immutable"):
+            HKEYType.foo = "bar"
+
+
+class BaseWinregTests(unittest.TestCase):
+
+    def setUp(self):
+        # Make sure that the test key is absent when the test
+        # starts.
+        self.delete_tree(HKEY_CURRENT_USER, test_key_name)
+
+    def delete_tree(self, root, subkey):
+        try:
+            hkey = OpenKey(root, subkey, 0, KEY_ALL_ACCESS)
+        except OSError:
+            # subkey does not exist
+            return
+        while True:
+            try:
+                subsubkey = EnumKey(hkey, 0)
+            except OSError:
+                # no more subkeys
+                break
+            self.delete_tree(hkey, subsubkey)
+        CloseKey(hkey)
+        DeleteKey(root, subkey)
+
+    def _write_test_data(self, root_key, subkeystr="sub_key",
+                         CreateKey=CreateKey):
+        # Set the default value for this key.
+        SetValue(root_key, test_key_name, REG_SZ, "Default value")
+        key = CreateKey(root_key, test_key_name)
+        self.assertTrue(key.handle != 0)
+        # Create a sub-key
+        sub_key = CreateKey(key, subkeystr)
+        # Give the sub-key some named values
+
+        for value_name, value_data, value_type in test_data:
+            SetValueEx(sub_key, value_name, 0, value_type, value_data)
+
+        # Check we wrote as many items as we thought.
+        nkeys, nvalues, since_mod = QueryInfoKey(key)
+        self.assertEqual(nkeys, 1, "Not the correct number of sub keys")
+        self.assertEqual(nvalues, 1, "Not the correct number of values")
+        nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
+        self.assertEqual(nkeys, 0, "Not the correct number of sub keys")
+        self.assertEqual(nvalues, len(test_data),
+                         "Not the correct number of values")
+        # Close this key this way...
+        # (but before we do, copy the key as an integer - this allows
+        # us to test that the key really gets closed).
+        int_sub_key = int(sub_key)
+        CloseKey(sub_key)
+        try:
+            QueryInfoKey(int_sub_key)
+            self.fail("It appears the CloseKey() function does "
+                      "not close the actual key!")
+        except OSError:
+            pass
+        # ... and close that key that way :-)
+        int_key = int(key)
+        key.Close()
+        try:
+            QueryInfoKey(int_key)
+            self.fail("It appears the key.Close() function "
+                      "does not close the actual key!")
+        except OSError:
+            pass
+    def _read_test_data(self, root_key, subkeystr="sub_key", OpenKey=OpenKey):
+        # Check we can get default value for this key.
+        val = QueryValue(root_key, test_key_name)
+        self.assertEqual(val, "Default value",
+                         "Registry didn't give back the correct value")
+
+        key = OpenKey(root_key, test_key_name)
+        # Read the sub-keys
+        with OpenKey(key, subkeystr) as sub_key:
+            # Check I can enumerate over the values.
+            index = 0
+            while 1:
+                try:
+                    data = EnumValue(sub_key, index)
+                except OSError:
+                    break
+                self.assertEqual(data in test_data, True,
+                                 "Didn't read back the correct test data")
+                index = index + 1
+            self.assertEqual(index, len(test_data),
+                             "Didn't read the correct number of items")
+            # Check I can directly access each item
+            for value_name, value_data, value_type in test_data:
+                read_val, read_typ = QueryValueEx(sub_key, value_name)
+                self.assertEqual(read_val, value_data,
+                                 "Could not directly read the value")
+                self.assertEqual(read_typ, value_type,
+                                 "Could not directly read the value")
+        sub_key.Close()
+        # Enumerate our main key.
+        read_val = EnumKey(key, 0)
+        self.assertEqual(read_val, subkeystr, "Read subkey value wrong")
+        try:
+            EnumKey(key, 1)
+            self.fail("Was able to get a second key when I only have one!")
+        except OSError:
+            pass
+
+        key.Close()
+
+    def _delete_test_data(self, root_key, subkeystr="sub_key"):
+        key = OpenKey(root_key, test_key_name, 0, KEY_ALL_ACCESS)
+        sub_key = OpenKey(key, subkeystr, 0, KEY_ALL_ACCESS)
+        # It is not necessary to delete the values before deleting
+        # the key (although subkeys must not exist).  We delete them
+        # manually just to prove we can :-)
+        for value_name, value_data, value_type in test_data:
+            DeleteValue(sub_key, value_name)
+
+        nkeys, nvalues, since_mod = QueryInfoKey(sub_key)
+        self.assertEqual(nkeys, 0, "subkey not empty before delete")
+        self.assertEqual(nvalues, 0, "subkey not empty before delete")
+        sub_key.Close()
+        DeleteKey(key, subkeystr)
+
+        try:
+            # Shouldn't be able to delete it twice!
+            DeleteKey(key, subkeystr)
+            self.fail("Deleting the key twice succeeded")
+        except OSError:
+            pass
+        key.Close()
+        DeleteKey(root_key, test_key_name)
+        # Opening should now fail!
+        try:
+            key = OpenKey(root_key, test_key_name)
+            self.fail("Could open the non-existent key")
+        except OSError: # Use this error name this time
+            pass
+
+    def _test_all(self, root_key, subkeystr="sub_key"):
+        self._write_test_data(root_key, subkeystr)
+        self._read_test_data(root_key, subkeystr)
+        self._delete_test_data(root_key, subkeystr)
+
+    def _test_named_args(self, key, sub_key):
+        with CreateKeyEx(key=key, sub_key=sub_key, reserved=0,
+                         access=KEY_ALL_ACCESS) as ckey:
+            self.assertTrue(ckey.handle != 0)
+
+        with OpenKeyEx(key=key, sub_key=sub_key, reserved=0,
+                       access=KEY_ALL_ACCESS) as okey:
+            self.assertTrue(okey.handle != 0)
+
+
+class LocalWinregTests(BaseWinregTests):
+
+    def test_registry_works(self):
+        self._test_all(HKEY_CURRENT_USER)
+        self._test_all(HKEY_CURRENT_USER, "日本-subkey")
+
+    def test_registry_works_extended_functions(self):
+        # Substitute the regular CreateKey and OpenKey calls with their
+        # extended counterparts.
+        # Note: DeleteKeyEx is not used here because it is platform dependent
+        cke = lambda key, sub_key: CreateKeyEx(key, sub_key, 0, KEY_ALL_ACCESS)
+        self._write_test_data(HKEY_CURRENT_USER, CreateKey=cke)
+
+        oke = lambda key, sub_key: OpenKeyEx(key, sub_key, 0, KEY_READ)
+        self._read_test_data(HKEY_CURRENT_USER, OpenKey=oke)
+
+        self._delete_test_data(HKEY_CURRENT_USER)
+
+    def test_named_arguments(self):
+        self._test_named_args(HKEY_CURRENT_USER, test_key_name)
+        # Use the regular DeleteKey to clean up
+        # DeleteKeyEx takes named args and is tested separately
+        DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_connect_registry_to_local_machine_works(self):
+        # perform minimal ConnectRegistry test which just invokes it
+        h = ConnectRegistry(None, HKEY_LOCAL_MACHINE)
+        self.assertNotEqual(h.handle, 0)
+        h.Close()
+        self.assertEqual(h.handle, 0)
+
+    def test_nonexistent_remote_registry(self):
+        connect = lambda: ConnectRegistry("abcdefghijkl", HKEY_CURRENT_USER)
+        self.assertRaises(OSError, connect)
+
+    def testExpandEnvironmentStrings(self):
+        r = ExpandEnvironmentStrings("%windir%\\test")
+        self.assertEqual(type(r), str)
+        self.assertEqual(r, os.environ["windir"] + "\\test")
+
+    def test_context_manager(self):
+        # ensure that the handle is closed if an exception occurs
+        try:
+            with ConnectRegistry(None, HKEY_LOCAL_MACHINE) as h:
+                self.assertNotEqual(h.handle, 0)
+                raise OSError
+        except OSError:
+            self.assertEqual(h.handle, 0)
+
+    def test_changing_value(self):
+        # Issue2810: A race condition in 2.6 and 3.1 may cause
+        # EnumValue or QueryValue to raise "WindowsError: More data is
+        # available"
+        done = False
+
+        class VeryActiveThread(threading.Thread):
+            def run(self):
+                with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
+                    use_short = True
+                    long_string = 'x'*2000
+                    while not done:
+                        s = 'x' if use_short else long_string
+                        use_short = not use_short
+                        SetValue(key, 'changing_value', REG_SZ, s)
+
+        thread = VeryActiveThread()
+        thread.start()
+        try:
+            with CreateKey(HKEY_CURRENT_USER,
+                           test_key_name+'\\changing_value') as key:
+                for _ in range(1000):
+                    num_subkeys, num_values, t = QueryInfoKey(key)
+                    for i in range(num_values):
+                        name = EnumValue(key, i)
+                        QueryValue(key, name[0])
+        finally:
+            done = True
+            thread.join()
+            DeleteKey(HKEY_CURRENT_USER, test_key_name+'\\changing_value')
+            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
+        # available"
+        name = 'x'*256
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as key:
+                SetValue(key, name, REG_SZ, 'x')
+                num_subkeys, num_values, t = QueryInfoKey(key)
+                EnumKey(key, 0)
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, '\\'.join((test_key_name, name)))
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_dynamic_key(self):
+        # Issue2810, when the value is dynamically generated, these
+        # raise "WindowsError: More data is available" in 2.6 and 3.1
+        try:
+            EnumValue(HKEY_PERFORMANCE_DATA, 0)
+        except OSError as e:
+            if e.errno in (errno.EPERM, errno.EACCES):
+                self.skipTest("access denied to registry key "
+                              "(are you running in a non-interactive session?)")
+            raise
+        QueryValueEx(HKEY_PERFORMANCE_DATA, "")
+
+    # Reflection requires XP x64/Vista at a minimum. XP doesn't have this stuff
+    # or DeleteKeyEx so make sure their use raises NotImplementedError
+    @unittest.skipUnless(WIN_VER < (5, 2), "Requires Windows XP")
+    def test_reflection_unsupported(self):
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                self.assertNotEqual(ck.handle, 0)
+
+            key = OpenKey(HKEY_CURRENT_USER, test_key_name)
+            self.assertNotEqual(key.handle, 0)
+
+            with self.assertRaises(NotImplementedError):
+                DisableReflectionKey(key)
+            with self.assertRaises(NotImplementedError):
+                EnableReflectionKey(key)
+            with self.assertRaises(NotImplementedError):
+                QueryReflectionKey(key)
+            with self.assertRaises(NotImplementedError):
+                DeleteKeyEx(HKEY_CURRENT_USER, test_key_name)
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_setvalueex_value_range(self):
+        # Test for Issue #14420, accept proper ranges for SetValueEx.
+        # Py2Reg, which gets called by SetValueEx, was using PyLong_AsLong,
+        # thus raising OverflowError. The implementation now uses
+        # PyLong_AsUnsignedLong to match DWORD's size.
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                self.assertNotEqual(ck.handle, 0)
+                SetValueEx(ck, "test_name", None, REG_DWORD, 0x80000000)
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_setvalueex_negative_one_check(self):
+        # Test for Issue #43984, check -1 was not set by SetValueEx.
+        # Py2Reg, which gets called by SetValueEx, wasn't checking return
+        # value by PyLong_AsUnsignedLong, thus setting -1 as value in the registry.
+        # The implementation now checks PyLong_AsUnsignedLong return value to assure
+        # the value set was not -1.
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                with self.assertRaises(OverflowError):
+                    SetValueEx(ck, "test_name_dword", None, REG_DWORD, -1)
+                    SetValueEx(ck, "test_name_qword", None, REG_QWORD, -1)
+                self.assertRaises(FileNotFoundError, QueryValueEx, ck, "test_name_dword")
+                self.assertRaises(FileNotFoundError, QueryValueEx, ck, "test_name_qword")
+
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_queryvalueex_return_value(self):
+        # Test for Issue #16759, return unsigned int from QueryValueEx.
+        # Reg2Py, which gets called by QueryValueEx, was returning a value
+        # generated by PyLong_FromLong. The implementation now uses
+        # PyLong_FromUnsignedLong to match DWORD's size.
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                self.assertNotEqual(ck.handle, 0)
+                test_val = 0x80000000
+                SetValueEx(ck, "test_name", None, REG_DWORD, test_val)
+                ret_val, ret_type = QueryValueEx(ck, "test_name")
+                self.assertEqual(ret_type, REG_DWORD)
+                self.assertEqual(ret_val, test_val)
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_setvalueex_crash_with_none_arg(self):
+        # Test for Issue #21151, segfault when None is passed to SetValueEx
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                self.assertNotEqual(ck.handle, 0)
+                test_val = None
+                SetValueEx(ck, "test_name", 0, REG_BINARY, test_val)
+                ret_val, ret_type = QueryValueEx(ck, "test_name")
+                self.assertEqual(ret_type, REG_BINARY)
+                self.assertEqual(ret_val, test_val)
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+    def test_read_string_containing_null(self):
+        # Test for issue 25778: REG_SZ should not contain null characters
+        try:
+            with CreateKey(HKEY_CURRENT_USER, test_key_name) as ck:
+                self.assertNotEqual(ck.handle, 0)
+                test_val = "A string\x00 with a null"
+                SetValueEx(ck, "test_name", 0, REG_SZ, test_val)
+                ret_val, ret_type = QueryValueEx(ck, "test_name")
+                self.assertEqual(ret_type, REG_SZ)
+                self.assertEqual(ret_val, "A string")
+        finally:
+            DeleteKey(HKEY_CURRENT_USER, test_key_name)
+
+
+@unittest.skipUnless(REMOTE_NAME, "Skipping remote registry tests")
+class RemoteWinregTests(BaseWinregTests):
+
+    def test_remote_registry_works(self):
+        remote_key = ConnectRegistry(REMOTE_NAME, HKEY_CURRENT_USER)
+        self._test_all(remote_key)
+
+
+@unittest.skipUnless(WIN64_MACHINE, "x64 specific registry tests")
+class Win64WinregTests(BaseWinregTests):
+
+    def test_named_arguments(self):
+        self._test_named_args(HKEY_CURRENT_USER, test_key_name)
+        # Clean up and also exercise the named arguments
+        DeleteKeyEx(key=HKEY_CURRENT_USER, sub_key=test_key_name,
+                    access=KEY_ALL_ACCESS, reserved=0)
+
+    @unittest.skipIf(win32_edition() in ('WindowsCoreHeadless', 'IoTEdgeOS'), "APIs not available on WindowsCoreHeadless")
+    def test_reflection_functions(self):
+        # Test that we can call the query, enable, and disable functions
+        # on a key which isn't on the reflection list with no consequences.
+        with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key:
+            # HKLM\Software is redirected but not reflected in all OSes
+            self.assertTrue(QueryReflectionKey(key))
+            self.assertIsNone(EnableReflectionKey(key))
+            self.assertIsNone(DisableReflectionKey(key))
+            self.assertTrue(QueryReflectionKey(key))
+
+    @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection")
+    def test_reflection(self):
+        # Test that we can create, open, and delete keys in the 32-bit
+        # area. Because we are doing this in a key which gets reflected,
+        # test the differences of 32 and 64-bit keys before and after the
+        # reflection occurs (ie. when the created key is closed).
+        try:
+            with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                             KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key:
+                self.assertNotEqual(created_key.handle, 0)
+
+                # The key should now be available in the 32-bit area
+                with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                             KEY_ALL_ACCESS | KEY_WOW64_32KEY) as key:
+                    self.assertNotEqual(key.handle, 0)
+
+                # Write a value to what currently is only in the 32-bit area
+                SetValueEx(created_key, "", 0, REG_SZ, "32KEY")
+
+                # The key is not reflected until created_key is closed.
+                # The 64-bit version of the key should not be available yet.
+                open_fail = lambda: OpenKey(HKEY_CURRENT_USER,
+                                            test_reflect_key_name, 0,
+                                            KEY_READ | KEY_WOW64_64KEY)
+                self.assertRaises(OSError, open_fail)
+
+            # Now explicitly open the 64-bit version of the key
+            with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                         KEY_ALL_ACCESS | KEY_WOW64_64KEY) as key:
+                self.assertNotEqual(key.handle, 0)
+                # Make sure the original value we set is there
+                self.assertEqual("32KEY", QueryValue(key, ""))
+                # Set a new value, which will get reflected to 32-bit
+                SetValueEx(key, "", 0, REG_SZ, "64KEY")
+
+            # Reflection uses a "last-writer wins policy, so the value we set
+            # on the 64-bit key should be the same on 32-bit
+            with OpenKey(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                         KEY_READ | KEY_WOW64_32KEY) as key:
+                self.assertEqual("64KEY", QueryValue(key, ""))
+        finally:
+            DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name,
+                        KEY_WOW64_32KEY, 0)
+
+    @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection")
+    def test_disable_reflection(self):
+        # Make use of a key which gets redirected and reflected
+        try:
+            with CreateKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                             KEY_ALL_ACCESS | KEY_WOW64_32KEY) as created_key:
+                # QueryReflectionKey returns whether or not the key is disabled
+                disabled = QueryReflectionKey(created_key)
+                self.assertEqual(type(disabled), bool)
+                # HKCU\Software\Classes is reflected by default
+                self.assertFalse(disabled)
+
+                DisableReflectionKey(created_key)
+                self.assertTrue(QueryReflectionKey(created_key))
+
+            # The key is now closed and would normally be reflected to the
+            # 64-bit area, but let's make sure that didn't happen.
+            open_fail = lambda: OpenKeyEx(HKEY_CURRENT_USER,
+                                          test_reflect_key_name, 0,
+                                          KEY_READ | KEY_WOW64_64KEY)
+            self.assertRaises(OSError, open_fail)
+
+            # Make sure the 32-bit key is actually there
+            with OpenKeyEx(HKEY_CURRENT_USER, test_reflect_key_name, 0,
+                           KEY_READ | KEY_WOW64_32KEY) as key:
+                self.assertNotEqual(key.handle, 0)
+        finally:
+            DeleteKeyEx(HKEY_CURRENT_USER, test_reflect_key_name,
+                        KEY_WOW64_32KEY, 0)
+
+    def test_exception_numbers(self):
+        with self.assertRaises(FileNotFoundError) as ctx:
+            QueryValue(HKEY_CLASSES_ROOT, 'some_value_that_does_not_exist')
+
+
+if __name__ == "__main__":
+    if not REMOTE_NAME:
+        print("Remote registry calls can be tested using",
+              "'test_winreg.py --remote \\\\machine_name'")
+    unittest.main()
diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index 07522bda6a..b321dac6c6 100644
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -5,6 +5,7 @@
 __email__ = "mbland at acm dot org"
 
 import sys
+import traceback
 import unittest
 from collections import deque
 from contextlib import _GeneratorContextManager, contextmanager, nullcontext
@@ -79,11 +80,11 @@ def __exit__(self, *exc_info):
             try:
                 if mgr.__exit__(*ex):
                     ex = (None, None, None)
-            except:
-                ex = sys.exc_info()
+            except BaseException as e:
+                ex = (type(e), e, e.__traceback__)
         self.entered = None
         if ex is not exc_info:
-            raise ex[0](ex[1]).with_traceback(ex[2])
+            raise ex
 
 
 class MockNested(Nested):
@@ -170,7 +171,10 @@ def __exit__(self, *args):
         def shouldThrow():
             ct = EnterThrows()
             self.foo = None
-            with ct as self.foo:
+            # Ruff complains that we're redefining `self.foo` here,
+            # but the whole point of the test is to check that `self.foo`
+            # is *not* redefined (because `__enter__` raises)
+            with ct as self.foo:  # noqa: F811
                 pass
         self.assertRaises(RuntimeError, shouldThrow)
         self.assertEqual(self.foo, None)
@@ -251,7 +255,6 @@ def testInlineGeneratorBoundSyntax(self):
         self.assertAfterWithGeneratorInvariantsNoError(foo)
 
     def testInlineGeneratorBoundToExistingVariable(self):
-        foo = None
         with mock_contextmanager_generator() as foo:
             self.assertInWithGeneratorInvariants(foo)
         self.assertAfterWithGeneratorInvariantsNoError(foo)
@@ -749,5 +752,49 @@ def testEnterReturnsTuple(self):
             self.assertEqual(10, b1)
             self.assertEqual(20, b2)
 
+    @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
+        # manager should be just the context manager expression,
+        # pinpointing the precise context manager in case there
+        # is more than one.
+
+        def init_raises():
+            try:
+                with self.Dummy(), self.InitRaises() as cm, self.Dummy() as d:
+                    pass
+            except Exception as e:
+                return e
+
+        def enter_raises():
+            try:
+                with self.EnterRaises(), self.Dummy() as d:
+                    pass
+            except Exception as e:
+                return e
+
+        def exit_raises():
+            try:
+                with self.ExitRaises(), self.Dummy() as d:
+                    pass
+            except Exception as e:
+                return e
+
+        for func, expected in [(init_raises, "self.InitRaises()"),
+                               (enter_raises, "self.EnterRaises()"),
+                               (exit_raises, "self.ExitRaises()"),
+                              ]:
+            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_wsgiref.py b/Lib/test/test_wsgiref.py
index b89e181f9f..d546e3ef21 100644
--- a/Lib/test/test_wsgiref.py
+++ b/Lib/test/test_wsgiref.py
@@ -1,6 +1,6 @@
 from unittest import mock
 from test import support
-from test.support import warnings_helper
+from test.support import socket_helper
 from test.test_httpservers import NoLogRequestHandler
 from unittest import TestCase
 from wsgiref.util import setup_testing_defaults
@@ -80,41 +80,26 @@ def run_amock(app=hello_app, data=b"GET / HTTP/1.0\n\n"):
 
     return out.getvalue(), err.getvalue()
 
-def compare_generic_iter(make_it,match):
-    """Utility to compare a generic 2.1/2.2+ iterator with an iterable
 
-    If running under Python 2.2+, this tests the iterator using iter()/next(),
-    as well as __getitem__.  'make_it' must be a function returning a fresh
+def compare_generic_iter(make_it, match):
+    """Utility to compare a generic iterator with an iterable
+
+    This tests the iterator using iter()/next().
+    'make_it' must be a function returning a fresh
     iterator to be tested (since this may test the iterator twice)."""
 
     it = make_it()
-    n = 0
+    if not iter(it) is it:
+        raise AssertionError
     for item in match:
-        if not it[n]==item: raise AssertionError
-        n+=1
-    try:
-        it[n]
-    except IndexError:
-        pass
-    else:
-        raise AssertionError("Too many items from __getitem__",it)
-
+        if not next(it) == item:
+            raise AssertionError
     try:
-        iter, StopIteration
-    except NameError:
+        next(it)
+    except StopIteration:
         pass
     else:
-        # Only test iter mode under 2.2+
-        it = make_it()
-        if not iter(it) is it: raise AssertionError
-        for item in match:
-            if not next(it) == item: raise AssertionError
-        try:
-            next(it)
-        except StopIteration:
-            pass
-        else:
-            raise AssertionError("Too many items from .__next__()", it)
+        raise AssertionError("Too many items from .__next__()", it)
 
 
 class IntegrationTests(TestCase):
@@ -152,7 +137,7 @@ def test_environ(self):
     def test_request_length(self):
         out, err = run_amock(data=b"GET " + (b"x" * 65537) + b" HTTP/1.0\n\n")
         self.assertEqual(out.splitlines()[0],
-                         b"HTTP/1.0 414 Request-URI Too Long")
+                         b"HTTP/1.0 414 URI Too Long")
 
     def test_validated_hello(self):
         out, err = run_amock(validator(hello_app))
@@ -264,7 +249,7 @@ def app(environ, start_response):
         class WsgiHandler(NoLogRequestHandler, WSGIRequestHandler):
             pass
 
-        server = make_server(support.HOST, 0, app, handler_class=WsgiHandler)
+        server = make_server(socket_helper.HOST, 0, app, handler_class=WsgiHandler)
         self.addCleanup(server.server_close)
         interrupted = threading.Event()
 
@@ -339,7 +324,6 @@ def checkReqURI(self,uri,query=1,**kw):
         util.setup_testing_defaults(kw)
         self.assertEqual(util.request_uri(kw,query),uri)
 
-    @warnings_helper.ignore_warnings(category=DeprecationWarning)
     def checkFW(self,text,size,match):
 
         def make_it(text=text,size=size):
@@ -358,15 +342,6 @@ def make_it(text=text,size=size):
         it.close()
         self.assertTrue(it.filelike.closed)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_filewrapper_getitem_deprecation(self):
-        wrapper = util.FileWrapper(StringIO('foobar'), 3)
-        with self.assertWarnsRegex(DeprecationWarning,
-                                   r'Use iterator protocol instead'):
-            # This should have returned 'bar'.
-            self.assertEqual(wrapper[1], 'foo')
-
     def testSimpleShifts(self):
         self.checkShift('','/', '', '/', '')
         self.checkShift('','/x', 'x', '/x', '')
@@ -473,6 +448,10 @@ def testHopByHop(self):
             for alt in hop, hop.title(), hop.upper(), hop.lower():
                 self.assertFalse(util.is_hop_by_hop(alt))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_filewrapper_getitem_deprecation(self):
+        return super().test_filewrapper_getitem_deprecation()
+
 class HeaderTests(TestCase):
 
     def testMappingInterface(self):
@@ -581,7 +560,7 @@ def testEnviron(self):
         # Test handler.environ as a dict
         expected = {}
         setup_testing_defaults(expected)
-        # Handler inherits os_environ variables which are not overriden
+        # Handler inherits os_environ variables which are not overridden
         # by SimpleHandler.add_cgi_vars() (SimpleHandler.base_env)
         for key, value in os_environ.items():
             if key not in expected:
@@ -821,8 +800,6 @@ def flush(self):
             b"Hello, world!",
             written)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testClientConnectionTerminations(self):
         environ = {"SERVER_PROTOCOL": "HTTP/1.0"}
         for exception in (
@@ -841,8 +818,6 @@ def write(self, b):
 
                 self.assertFalse(stderr.getvalue())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testDontResetInternalStateOnException(self):
         class CustomException(ValueError):
             pass
diff --git a/Lib/test/test_xml_dom_xmlbuilder.py b/Lib/test/test_xml_dom_xmlbuilder.py
new file mode 100644
index 0000000000..5f5f2eb328
--- /dev/null
+++ b/Lib/test/test_xml_dom_xmlbuilder.py
@@ -0,0 +1,88 @@
+import io
+import unittest
+from http import client
+from test.test_httplib import FakeSocket
+from unittest import mock
+from xml.dom import getDOMImplementation, minidom, xmlbuilder
+
+SMALL_SAMPLE = b"""<?xml version="1.0"?>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:xdc="http://www.xml.com/books">
+<!-- A comment -->
+<title>Introduction to XSL</title>
+<hr/>
+<p><xdc:author xdc:attrib="prefixed attribute" attrib="other attrib">A. Namespace</xdc:author></p>
+</html>"""
+
+
+class XMLBuilderTest(unittest.TestCase):
+    def test_entity_resolver(self):
+        body = (
+            b"HTTP/1.1 200 OK\r\nContent-Type: text/xml; charset=utf-8\r\n\r\n"
+            + SMALL_SAMPLE
+        )
+
+        sock = FakeSocket(body)
+        response = client.HTTPResponse(sock)
+        response.begin()
+        attrs = {"open.return_value": response}
+        opener = mock.Mock(**attrs)
+
+        resolver = xmlbuilder.DOMEntityResolver()
+
+        with mock.patch("urllib.request.build_opener") as mock_build:
+            mock_build.return_value = opener
+            source = resolver.resolveEntity(None, "http://example.com/2000/svg")
+
+        self.assertIsInstance(source, xmlbuilder.DOMInputSource)
+        self.assertIsNone(source.publicId)
+        self.assertEqual(source.systemId, "http://example.com/2000/svg")
+        self.assertEqual(source.baseURI, "http://example.com/2000/")
+        self.assertEqual(source.encoding, "utf-8")
+        self.assertIs(source.byteStream, response)
+
+        self.assertIsNone(source.characterStream)
+        self.assertIsNone(source.stringData)
+
+    def test_builder(self):
+        imp = getDOMImplementation()
+        self.assertIsInstance(imp, xmlbuilder.DOMImplementationLS)
+
+        builder = imp.createDOMBuilder(imp.MODE_SYNCHRONOUS, None)
+        self.assertIsInstance(builder, xmlbuilder.DOMBuilder)
+
+    def test_parse_uri(self):
+        body = (
+            b"HTTP/1.1 200 OK\r\nContent-Type: text/xml; charset=utf-8\r\n\r\n"
+            + SMALL_SAMPLE
+        )
+
+        sock = FakeSocket(body)
+        response = client.HTTPResponse(sock)
+        response.begin()
+        attrs = {"open.return_value": response}
+        opener = mock.Mock(**attrs)
+
+        with mock.patch("urllib.request.build_opener") as mock_build:
+            mock_build.return_value = opener
+
+            imp = getDOMImplementation()
+            builder = imp.createDOMBuilder(imp.MODE_SYNCHRONOUS, None)
+            document = builder.parseURI("http://example.com/2000/svg")
+
+        self.assertIsInstance(document, minidom.Document)
+        self.assertEqual(len(document.childNodes), 1)
+
+    def test_parse_with_systemId(self):
+        response = io.BytesIO(SMALL_SAMPLE)
+
+        with mock.patch("urllib.request.urlopen") as mock_open:
+            mock_open.return_value = response
+
+            imp = getDOMImplementation()
+            source = imp.createDOMInputSource()
+            builder = imp.createDOMBuilder(imp.MODE_SYNCHRONOUS, None)
+            source.systemId = "http://example.com/2000/svg"
+            document = builder.parse(source)
+
+        self.assertIsInstance(document, minidom.Document)
+        self.assertEqual(len(document.childNodes), 1)
diff --git a/Lib/test/test_xml_etree.py b/Lib/test/test_xml_etree.py
index 1a681d5a7c..1489fb666e 100644
--- a/Lib/test/test_xml_etree.py
+++ b/Lib/test/test_xml_etree.py
@@ -13,13 +13,16 @@
 import operator
 import os
 import pickle
+import pyexpat
 import sys
 import textwrap
 import types
 import unittest
+import unittest.mock as mock
 import warnings
 import weakref
 
+from contextlib import nullcontext
 from functools import partial
 from itertools import product, islice
 from test import support
@@ -120,6 +123,21 @@
 </foo>
 """
 
+def is_python_implementation():
+    assert ET is not None, "ET must be initialized"
+    assert pyET is not None, "pyET must be initialized"
+    return ET is pyET
+
+
+def equal_wrapper(cls):
+    """Mock cls.__eq__ to check whether it has been called or not.
+
+    The behaviour of cls.__eq__ (side-effects included) is left as is.
+    """
+    eq = cls.__eq__
+    return mock.patch.object(cls, "__eq__", autospec=True, wraps=eq)
+
+
 def checkwarnings(*filters, quiet=False):
     def decorator(test):
         def newtest(*args, **kwargs):
@@ -200,28 +218,36 @@ class ElementTreeTest(unittest.TestCase):
     def serialize_check(self, elem, expected):
         self.assertEqual(serialize(elem), expected)
 
+    def test_constructor(self):
+        # Test constructor behavior.
+
+        with self.assertRaises(TypeError):
+            tree = ET.ElementTree("")
+        with self.assertRaises(TypeError):
+            tree = ET.ElementTree(ET.ElementTree())
+
+    def test_setroot(self):
+        # Test _setroot behavior.
+
+        tree = ET.ElementTree()
+        element = ET.Element("tag")
+        tree._setroot(element)
+        self.assertEqual(tree.getroot().tag, "tag")
+        self.assertEqual(tree.getroot(), element)
+
+        # Test behavior with an invalid root element
+
+        tree = ET.ElementTree()
+        with self.assertRaises(TypeError):
+            tree._setroot("")
+        with self.assertRaises(TypeError):
+            tree._setroot(ET.ElementTree())
+        with self.assertRaises(TypeError):
+            tree._setroot(None)
+
     def test_interface(self):
         # Test element tree interface.
 
-        def check_string(string):
-            len(string)
-            for char in string:
-                self.assertEqual(len(char), 1,
-                        msg="expected one-character string, got %r" % char)
-            new_string = string + ""
-            new_string = string + " "
-            string[:0]
-
-        def check_mapping(mapping):
-            len(mapping)
-            keys = mapping.keys()
-            items = mapping.items()
-            for key in keys:
-                item = mapping[key]
-            mapping["key"] = "value"
-            self.assertEqual(mapping["key"], "value",
-                    msg="expected value string, got %r" % mapping["key"])
-
         def check_element(element):
             self.assertTrue(ET.iselement(element), msg="not an element")
             direlem = dir(element)
@@ -231,12 +257,12 @@ def check_element(element):
                 self.assertIn(attr, direlem,
                         msg='no %s visible by dir' % attr)
 
-            check_string(element.tag)
-            check_mapping(element.attrib)
+            self.assertIsInstance(element.tag, str)
+            self.assertIsInstance(element.attrib, dict)
             if element.text is not None:
-                check_string(element.text)
+                self.assertIsInstance(element.text, str)
             if element.tail is not None:
-                check_string(element.tail)
+                self.assertIsInstance(element.tail, str)
             for elem in element:
                 check_element(elem)
 
@@ -313,8 +339,7 @@ def test_set_attribute(self):
         element.attrib = {'A': 'B', 'C': 'D'}
         self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simpleops(self):
         # Basic method sanity checks.
 
@@ -359,8 +384,7 @@ def test_simpleops(self):
         self.serialize_check(element,
                 '<tag key="value"><subtag /><subtag /></tag>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cdata(self):
         # Test CDATA handling (etc).
 
@@ -371,8 +395,7 @@ def test_cdata(self):
         self.serialize_check(ET.XML("<tag><![CDATA[hello]]></tag>"),
                 '<tag>hello</tag>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_file_init(self):
         stringfile = io.BytesIO(SAMPLE_XML.encode("utf-8"))
         tree = ET.ElementTree(file=stringfile)
@@ -384,14 +407,14 @@ def test_file_init(self):
         self.assertEqual(tree.find("element/../empty-element").tag,
                 'empty-element')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_path_cache(self):
         # Check that the path cache behaves sanely.
 
         from xml.etree import ElementPath
 
         elem = ET.XML(SAMPLE_XML)
+        ElementPath._cache.clear()
         for i in range(10): ET.ElementTree(elem).find('./'+str(i))
         cache_len_10 = len(ElementPath._cache)
         for i in range(10): ET.ElementTree(elem).find('./'+str(i))
@@ -401,8 +424,7 @@ def test_path_cache(self):
         for i in range(600): ET.ElementTree(elem).find('./'+str(i))
         self.assertLess(len(ElementPath._cache), 500)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_copy(self):
         # Test copy handling (etc).
 
@@ -415,8 +437,6 @@ def test_copy(self):
         self.serialize_check(e2, '<tag>hello<bar /></tag>')
         self.serialize_check(e3, '<tag>hello<foo /></tag>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_attrib(self):
         # Test attribute handling.
 
@@ -493,8 +513,7 @@ def test_makeelement(self):
         elem[:] = tuple([subelem])
         self.serialize_check(elem, '<tag><subtag key="value" /></tag>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parsefile(self):
         # Test parsing from file.
 
@@ -540,8 +559,7 @@ def test_parsefile(self):
                 '   <empty-element />\n'
                 '</root>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parseliteral(self):
         element = ET.XML("<html><body>text</body></html>")
         self.assertEqual(ET.tostring(element, encoding='unicode'),
@@ -564,15 +582,16 @@ def test_parseliteral(self):
         self.assertEqual(len(ids), 1)
         self.assertEqual(ids["body"].tag, 'body')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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'),
@@ -589,6 +608,17 @@ def test_iterparse(self):
                 ('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], [])
@@ -680,12 +710,82 @@ def test_iterparse(self):
 
         # Not exhausting the iterator still closes the resource (bpo-43292)
         with warnings_helper.check_no_resource_warning(self):
-            it = iterparse(TESTFN)
+            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"
@@ -703,8 +803,7 @@ def test_writefile(self):
         elem[0] = ET.PI("key", "value")
         self.serialize_check(elem, 'text<?key value?><subtag>subtext</subtag>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_custom_builder(self):
         # Test parser w. custom builder.
 
@@ -766,8 +865,7 @@ def end_ns(self, prefix):
                 ('end-ns', ''),
             ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_custom_builder_only_end_ns(self):
         class Builder(list):
             def end_ns(self, prefix):
@@ -790,8 +888,7 @@ def end_ns(self, prefix):
                 ('end-ns', ''),
             ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_initialize_parser_without_target(self):
         # Explicit None
         parser = ET.XMLParser(target=None)
@@ -801,8 +898,7 @@ def test_initialize_parser_without_target(self):
         parser2 = ET.XMLParser()
         self.assertIsInstance(parser2.target, ET.TreeBuilder)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_children(self):
         # Test Element children iteration
 
@@ -840,16 +936,14 @@ def test_children(self):
         elem.clear()
         self.assertEqual(list(elem), [])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_writestring(self):
         elem = ET.XML("<html><body>text</body></html>")
         self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
         elem = ET.fromstring("<html><body>text</body></html>")
         self.assertEqual(ET.tostring(elem), b'<html><body>text</body></html>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_indent(self):
         elem = ET.XML("<root></root>")
         ET.indent(elem)
@@ -894,8 +988,7 @@ def test_indent(self):
             b'</html>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_indent_space(self):
         elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
         ET.indent(elem, space='\t')
@@ -921,8 +1014,7 @@ def test_indent_space(self):
             b'</html>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_indent_space_caching(self):
         elem = ET.XML("<html><body><p>par</p><p>text</p><p><br/></p><p /></body></html>")
         ET.indent(elem)
@@ -939,8 +1031,7 @@ def test_indent_space_caching(self):
             len({id(el.tail) for el in elem.iter()}),
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_indent_level(self):
         elem = ET.XML("<html><body><p>pre<br/>post</p><p>text</p></body></html>")
         with self.assertRaises(ValueError):
@@ -973,8 +1064,7 @@ def test_indent_level(self):
             b' </html>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_default_namespace(self):
         elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
         self.assertEqual(
@@ -986,8 +1076,7 @@ def test_tostring_default_namespace(self):
             '<body xmlns="http://effbot.org/ns"><tag /></body>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_default_namespace_different_namespace(self):
         elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
         self.assertEqual(
@@ -995,16 +1084,14 @@ def test_tostring_default_namespace_different_namespace(self):
             '<ns1:body xmlns="foobar" xmlns:ns1="http://effbot.org/ns"><ns1:tag /></ns1:body>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_default_namespace_original_no_namespace(self):
         elem = ET.XML('<body><tag/></body>')
         EXPECTED_MSG = '^cannot use non-qualified names with default_namespace option$'
         with self.assertRaisesRegex(ValueError, EXPECTED_MSG):
             ET.tostring(elem, encoding='unicode', default_namespace='foobar')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_no_xml_declaration(self):
         elem = ET.XML('<body><tag/></body>')
         self.assertEqual(
@@ -1012,8 +1099,7 @@ def test_tostring_no_xml_declaration(self):
             '<body><tag /></body>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_xml_declaration(self):
         elem = ET.XML('<body><tag/></body>')
         self.assertEqual(
@@ -1021,8 +1107,7 @@ def test_tostring_xml_declaration(self):
             b"<?xml version='1.0' encoding='utf8'?>\n<body><tag /></body>"
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_xml_declaration_unicode_encoding(self):
         elem = ET.XML('<body><tag/></body>')
         self.assertEqual(
@@ -1030,8 +1115,7 @@ def test_tostring_xml_declaration_unicode_encoding(self):
             "<?xml version='1.0' encoding='utf-8'?>\n<body><tag /></body>"
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostring_xml_declaration_cases(self):
         elem = ET.XML('<body><tag>ø</tag></body>')
         TESTCASES = [
@@ -1076,8 +1160,7 @@ def test_tostring_xml_declaration_cases(self):
                     expected_retval
                 )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostringlist_default_namespace(self):
         elem = ET.XML('<body xmlns="http://effbot.org/ns"><tag/></body>')
         self.assertEqual(
@@ -1089,8 +1172,7 @@ def test_tostringlist_default_namespace(self):
             '<body xmlns="http://effbot.org/ns"><tag /></body>'
         )
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostringlist_xml_declaration(self):
         elem = ET.XML('<body><tag/></body>')
         self.assertEqual(
@@ -1110,8 +1192,7 @@ def test_tostringlist_xml_declaration(self):
         self.assertRegex(stringlist[0], r"^<\?xml version='1.0' encoding='.+'?>")
         self.assertEqual(['<body', '>', '<tag', ' />', '</body>'], stringlist[1:])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encoding(self):
         def check(encoding, body=''):
             xml = ("<?xml version='1.0' encoding='%s'?><xml>%s</xml>" %
@@ -1171,8 +1252,7 @@ def bxml(encoding):
         self.assertRaises(ValueError, ET.XML, xml('undefined').encode('ascii'))
         self.assertRaises(LookupError, ET.XML, xml('xxx').encode('ascii'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_methods(self):
         # Test serialization methods.
 
@@ -1188,8 +1268,7 @@ def test_methods(self):
                 '<html><link><script>1 < 2</script></html>\n')
         self.assertEqual(serialize(e, method="text"), '1 < 2\n')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue18347(self):
         e = ET.XML('<html><CamelCase>text</CamelCase></html>')
         self.assertEqual(serialize(e),
@@ -1197,8 +1276,7 @@ def test_issue18347(self):
         self.assertEqual(serialize(e, method="html"),
                 '<html><CamelCase>text</CamelCase></html>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_entity(self):
         # Test entity handling.
 
@@ -1236,8 +1314,7 @@ def test_entity(self):
         self.assertEqual(str(cm.exception),
                 'undefined entity &entity;: line 4, column 10')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_namespace(self):
         # Test namespace issues.
 
@@ -1336,8 +1413,7 @@ def test_qname(self):
         self.assertNotEqual(q1, 'ns:tag')
         self.assertEqual(q1, '{ns}tag')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_doctype_public(self):
         # Test PUBLIC doctype.
 
@@ -1404,8 +1480,6 @@ def check(p, expected, namespaces=None):
               {'': 'http://www.w3.org/2001/XMLSchema',
                'ns': 'http://www.w3.org/2001/XMLSchema'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_processinginstruction(self):
         # Test ProcessingInstruction directly
 
@@ -1422,13 +1496,13 @@ def test_processinginstruction(self):
                 b"<?xml version='1.0' encoding='latin-1'?>\n"
                 b"<?test <testing&>\xe3?>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_html_empty_elems_serialization(self):
         # issue 15970
         # from http://www.w3.org/TR/html401/index/elements.html
-        for element in ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'FRAME', 'HR',
-                        'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM']:
+        for element in ['AREA', 'BASE', 'BASEFONT', 'BR', 'COL', 'EMBED', 'FRAME',
+                        'HR', 'IMG', 'INPUT', 'ISINDEX', 'LINK', 'META', 'PARAM',
+                        'SOURCE', 'TRACK', 'WBR']:
             for elem in [element, element.lower()]:
                 expected = '<%s>' % elem
                 serialized = serialize(ET.XML('<%s />' % elem), method='html')
@@ -1453,8 +1527,7 @@ def test_tree_write_attribute_order(self):
         self.assertEqual(serialize(root, method='html'),
                 '<cirriculum status="public" company="example"></cirriculum>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_attlist_default(self):
         # Test default attribute values; See BPO 42151.
         root = ET.fromstring(ATTLIST_XML)
@@ -1464,12 +1537,14 @@ def test_attlist_default(self):
 
 class XMLPullParserTest(unittest.TestCase):
 
-    def _feed(self, parser, data, chunk_size=None):
+    def _feed(self, parser, data, chunk_size=None, flush=False):
         if chunk_size is None:
             parser.feed(data)
         else:
             for i in range(0, len(data), chunk_size):
                 parser.feed(data[i:i+chunk_size])
+        if flush:
+            parser.flush()
 
     def assert_events(self, parser, expected, max_events=None):
         self.assertEqual(
@@ -1487,33 +1562,41 @@ def assert_event_tags(self, parser, expected, max_events=None):
         self.assertEqual([(action, elem.tag) for action, elem in events],
                          expected)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_simple_xml(self):
-        for chunk_size in (None, 1, 5):
-            with self.subTest(chunk_size=chunk_size):
-                parser = ET.XMLPullParser()
-                self.assert_event_tags(parser, [])
-                self._feed(parser, "<!-- comment -->\n", chunk_size)
-                self.assert_event_tags(parser, [])
-                self._feed(parser,
-                           "<root>\n  <element key='value'>text</element",
-                           chunk_size)
-                self.assert_event_tags(parser, [])
-                self._feed(parser, ">\n", chunk_size)
-                self.assert_event_tags(parser, [('end', 'element')])
-                self._feed(parser, "<element>text</element>tail\n", chunk_size)
-                self._feed(parser, "<empty-element/>\n", chunk_size)
-                self.assert_event_tags(parser, [
-                    ('end', 'element'),
-                    ('end', 'empty-element'),
-                    ])
-                self._feed(parser, "</root>\n", chunk_size)
-                self.assert_event_tags(parser, [('end', 'root')])
-                self.assertIsNone(parser.close())
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_simple_xml(self, chunk_size=None, flush=False):
+        parser = ET.XMLPullParser()
+        self.assert_event_tags(parser, [])
+        self._feed(parser, "<!-- comment -->\n", chunk_size, flush)
+        self.assert_event_tags(parser, [])
+        self._feed(parser,
+                   "<root>\n  <element key='value'>text</element",
+                   chunk_size, flush)
+        self.assert_event_tags(parser, [])
+        self._feed(parser, ">\n", chunk_size, flush)
+        self.assert_event_tags(parser, [('end', 'element')])
+        self._feed(parser, "<element>text</element>tail\n", chunk_size, flush)
+        self._feed(parser, "<empty-element/>\n", chunk_size, flush)
+        self.assert_event_tags(parser, [
+            ('end', 'element'),
+            ('end', 'empty-element'),
+            ])
+        self._feed(parser, "</root>\n", chunk_size, flush)
+        self.assert_event_tags(parser, [('end', 'root')])
+        self.assertIsNone(parser.close())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_simple_xml_chunk_1(self):
+        self.test_simple_xml(chunk_size=1, flush=True)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_simple_xml_chunk_5(self):
+        self.test_simple_xml(chunk_size=5, flush=True)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_simple_xml_chunk_22(self):
+        self.test_simple_xml(chunk_size=22)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_feed_while_iterating(self):
         parser = ET.XMLPullParser()
         it = parser.read_events()
@@ -1526,8 +1609,7 @@ def test_feed_while_iterating(self):
         with self.assertRaises(StopIteration):
             next(it)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple_xml_with_ns(self):
         parser = ET.XMLPullParser()
         self.assert_event_tags(parser, [])
@@ -1549,8 +1631,7 @@ def test_simple_xml_with_ns(self):
         self.assert_event_tags(parser, [('end', '{namespace}root')])
         self.assertIsNone(parser.close())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_ns_events(self):
         parser = ET.XMLPullParser(events=('start-ns', 'end-ns'))
         self._feed(parser, "<!-- comment -->\n")
@@ -1566,8 +1647,7 @@ def test_ns_events(self):
         self.assertEqual(list(parser.read_events()), [('end-ns', None)])
         self.assertIsNone(parser.close())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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")
@@ -1591,8 +1671,7 @@ def test_ns_events_start(self):
             ('end', '{abc}tag'),
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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")
@@ -1620,8 +1699,7 @@ def test_ns_events_start_end(self):
             ('end-ns', None),
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_events(self):
         parser = ET.XMLPullParser(events=())
         self._feed(parser, "<root/>\n")
@@ -1668,8 +1746,7 @@ def test_events(self):
         self._feed(parser, "</root>")
         self.assertIsNone(parser.close())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_events_comment(self):
         parser = ET.XMLPullParser(events=('start', 'comment', 'end'))
         self._feed(parser, "<!-- text here -->\n")
@@ -1689,8 +1766,7 @@ def test_events_comment(self):
         self._feed(parser, "<!-- text here -->\n")
         self.assert_events(parser, [('comment', (ET.Comment, ' text here '))])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_events_pi(self):
         parser = ET.XMLPullParser(events=('start', 'pi', 'end'))
         self._feed(parser, "<?pitarget?>\n")
@@ -1699,8 +1775,7 @@ def test_events_pi(self):
         self._feed(parser, "<?pitarget some text ?>\n")
         self.assert_events(parser, [('pi', (ET.PI, 'pitarget some text '))])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_events_sequence(self):
         # Test that events can be some sequence that's not just a tuple or list
         eventset = {'end', 'start'}
@@ -1720,12 +1795,63 @@ def __next__(self):
         self._feed(parser, "<foo>bar</foo>")
         self.assert_event_tags(parser, [('start', 'foo'), ('end', 'foo')])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_unknown_event(self):
         with self.assertRaises(ValueError):
             ET.XMLPullParser(events=('start', 'end', 'bogus'))
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @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):
+        parser = ET.XMLPullParser(events=('start', 'end'))
+
+        for chunk in ("<doc", ">"):
+            parser.feed(chunk)
+
+        self.assert_event_tags(parser, [])  # i.e. no elements started
+        if ET is pyET:
+            self.assertTrue(parser._parser._parser.GetReparseDeferralEnabled())
+
+        parser.flush()
+
+        self.assert_event_tags(parser, [('start', 'doc')])
+        if ET is pyET:
+            self.assertTrue(parser._parser._parser.GetReparseDeferralEnabled())
+
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assert_event_tags(parser, [('end', 'doc')])
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_flush_reparse_deferral_disabled(self):
+        parser = ET.XMLPullParser(events=('start', 'end'))
+
+        for chunk in ("<doc", ">"):
+            parser.feed(chunk)
+
+        if pyexpat.version_info >= (2, 6, 0):
+            if not ET is pyET:
+                self.skipTest(f'XMLParser.(Get|Set)ReparseDeferralEnabled '
+                              'methods not available in C')
+            parser._parser._parser.SetReparseDeferralEnabled(False)
+            self.assert_event_tags(parser, [])  # i.e. no elements started
+
+        if ET is pyET:
+            self.assertFalse(parser._parser._parser.GetReparseDeferralEnabled())
+
+        parser.flush()
+
+        self.assert_event_tags(parser, [('start', 'doc')])
+        if ET is pyET:
+            self.assertFalse(parser._parser._parser.GetReparseDeferralEnabled())
+
+        parser.feed("</doc>")
+        parser.close()
+
+        self.assert_event_tags(parser, [('end', 'doc')])
 
 #
 # xinclude tests (samples from appendix C of the xinclude specification)
@@ -1882,8 +2008,7 @@ def _my_loader(self, href, parse):
         else:
             return None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xinclude_default(self):
         from xml.etree import ElementInclude
         doc = self.xinclude_loader('default.xml')
@@ -1898,8 +2023,7 @@ def test_xinclude_default(self):
             '</root>\n'
             '</document>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xinclude(self):
         from xml.etree import ElementInclude
 
@@ -1964,8 +2088,7 @@ def test_xinclude(self):
             '  </ns0:include>\n'
             '</div>') # C5
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xinclude_repeated(self):
         from xml.etree import ElementInclude
 
@@ -1973,8 +2096,7 @@ def test_xinclude_repeated(self):
         ElementInclude.include(document, self.xinclude_loader)
         self.assertEqual(1+4*2, len(document.findall(".//p")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xinclude_failures(self):
         from xml.etree import ElementInclude
 
@@ -2079,8 +2201,7 @@ def check(elem):
         elem.set("123", 123)
         check(elem) # attribute value
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit25(self):
         # typo in ElementTree.findtext
 
@@ -2089,8 +2210,7 @@ def test_bug_xmltoolkit25(self):
         self.assertEqual(tree.findtext("tag"), 'text')
         self.assertEqual(tree.findtext("section/tag"), 'subtext')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit28(self):
         # .//tag causes exceptions
 
@@ -2098,8 +2218,7 @@ def test_bug_xmltoolkit28(self):
         self.assertEqual(summarize_list(tree.findall(".//thead")), [])
         self.assertEqual(summarize_list(tree.findall(".//tbody")), ['tbody'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkitX1(self):
         # dump() doesn't flush the output buffer
 
@@ -2108,8 +2227,7 @@ def test_bug_xmltoolkitX1(self):
             ET.dump(tree)
             self.assertEqual(stdout.getvalue(), '<doc><table><tbody /></table></doc>\n')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit39(self):
         # non-ascii element and attribute names doesn't work
 
@@ -2135,8 +2253,7 @@ def test_bug_xmltoolkit39(self):
         self.assertEqual(ET.tostring(tree, "utf-8"),
                 b'<tag \xc3\xa4ttr="v\xc3\xa4lue" />')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit54(self):
         # problems handling internally defined entities
 
@@ -2146,8 +2263,7 @@ def test_bug_xmltoolkit54(self):
                 b'<doc>&#33328;</doc>')
         self.assertEqual(serialize(e), '<doc>\u8230</doc>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit55(self):
         # make sure we're reporting the first error, not the last
 
@@ -2157,8 +2273,7 @@ def test_bug_xmltoolkit55(self):
         self.assertEqual(str(cm.exception),
                 'undefined entity &ldots;: line 1, column 36')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit60(self):
         # Handle crash in stream source.
 
@@ -2168,8 +2283,7 @@ def read(self, x):
 
         self.assertRaises(OSError, ET.parse, ExceptionFile())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_xmltoolkit62(self):
         # Don't crash when using custom entities.
 
@@ -2187,8 +2301,6 @@ def test_bug_xmltoolkit62(self):
         self.assertEqual(t.find('.//paragraph').text,
             'A new cultivar of Begonia plant named \u2018BCT9801BEG\u2019.')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @unittest.skipIf(sys.gettrace(), "Skips under coverage.")
     def test_bug_xmltoolkit63(self):
         # Check reference leak.
@@ -2204,8 +2316,7 @@ def xmltoolkit63():
             xmltoolkit63()
         self.assertEqual(sys.getrefcount(None), count)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_200708_newline(self):
         # Preserve newlines in attributes.
 
@@ -2217,8 +2328,7 @@ def test_bug_200708_newline(self):
         self.assertEqual(ET.tostring(ET.XML(ET.tostring(e))),
                 b'<SomeTag text="def _f():&#10;  return 3&#10;" />')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bug_200708_close(self):
         # Test default builder.
         parser = ET.XMLParser() # default
@@ -2256,8 +2366,6 @@ def test_bug_200709_default_namespace(self):
         self.assertEqual(str(cm.exception),
                 'cannot use non-qualified names with default_namespace option')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bug_200709_register_namespace(self):
         e = ET.Element("{http://namespace.invalid/does/not/exist/}title")
         self.assertEqual(ET.tostring(e),
@@ -2313,8 +2421,7 @@ def test_bug_1534630(self):
         e = bob.close()
         self.assertEqual(serialize(e), '<tag />')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue6233(self):
         e = ET.XML(b"<?xml version='1.0' encoding='utf-8'?>"
                    b'<body>t\xc3\xa3g</body>')
@@ -2327,8 +2434,7 @@ def test_issue6233(self):
                 b"<?xml version='1.0' encoding='ascii'?>\n"
                 b'<body>t&#227;g</body>')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue6565(self):
         elem = ET.XML("<body><tag/></body>")
         self.assertEqual(summarize_list(elem), ['tag'])
@@ -2374,8 +2480,7 @@ def __bool__(self):
         self.assertIsInstance(e[0].tail, str)
         self.assertEqual(e[0].tail, 'changed')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_lost_elem(self):
         # Issue #25902: Borrowed element can disappear
         class Tag:
@@ -2401,8 +2506,7 @@ def check_expat224_utf8_bug(self, text):
         root = ET.XML(xml)
         self.assertEqual(root.get('b'), text.decode('utf-8'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -2415,8 +2519,7 @@ def test_expat224_utf8_bug(self):
         text = b'x' + b'\xc3\xa0' * 1024
         self.check_expat224_utf8_bug(text)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_expat224_utf8_bug_file(self):
         with open(UTF8_BUG_XMLFILE, 'rb') as fp:
             raw = fp.read()
@@ -2434,6 +2537,22 @@ def test_39495_treebuilder_start(self):
         self.assertRaises(TypeError, ET.TreeBuilder().start, "tag")
         self.assertRaises(TypeError, ET.TreeBuilder().start, "tag", None)
 
+    def test_issue123213_correct_extend_exception(self):
+        # Does not hide the internal exception when extending the element
+        self.assertRaises(ZeroDivisionError, ET.Element('tag').extend,
+                          (1/0 for i in range(2)))
+
+        # Still raises the TypeError when extending with a non-iterable
+        self.assertRaises(TypeError, ET.Element('tag').extend, None)
+
+        # Preserves the TypeError message when extending with a generator
+        def f():
+            raise TypeError("mymessage")
+
+        self.assertRaisesRegex(
+            TypeError, 'mymessage',
+            ET.Element('tag').extend, (f() for i in range(2)))
+
 
 
 # --------------------------------------------------------------------
@@ -2468,35 +2587,6 @@ def test___init__(self):
         self.assertIsNot(element_foo.attrib, attrib)
         self.assertNotEqual(element_foo.attrib, attrib)
 
-    def test_copy(self):
-        # Only run this test if Element.copy() is defined.
-        if "copy" not in dir(ET.Element):
-            raise unittest.SkipTest("Element.copy() not present")
-
-        element_foo = ET.Element("foo", { "zix": "wyp" })
-        element_foo.append(ET.Element("bar", { "baz": "qix" }))
-
-        with self.assertWarns(DeprecationWarning):
-            element_foo2 = element_foo.copy()
-
-        # elements are not the same
-        self.assertIsNot(element_foo2, element_foo)
-
-        # string attributes are equal
-        self.assertEqual(element_foo2.tag, element_foo.tag)
-        self.assertEqual(element_foo2.text, element_foo.text)
-        self.assertEqual(element_foo2.tail, element_foo.tail)
-
-        # number of children is the same
-        self.assertEqual(len(element_foo2), len(element_foo))
-
-        # children are the same
-        for (child1, child2) in itertools.zip_longest(element_foo, element_foo2):
-            self.assertIs(child1, child2)
-
-        # attrib is a copy
-        self.assertEqual(element_foo2.attrib, element_foo.attrib)
-
     def test___copy__(self):
         element_foo = ET.Element("foo", { "zix": "wyp" })
         element_foo.append(ET.Element("bar", { "baz": "qix" }))
@@ -2579,8 +2669,7 @@ def __deepcopy__(self, memo):
             e[:] = [E('bar')]
             self.assertRaises(TypeError, copy.deepcopy, e)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_cyclic_gc(self):
         class Dummy:
             pass
@@ -2653,8 +2742,7 @@ def test_pickle(self):
                 self.assertEqual(len(e2), 2)
                 self.assertEqualElements(e, e2)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_pickle_issue18997(self):
         for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
             for dumper, loader in product(self.modules, repeat=2):
@@ -2662,8 +2750,7 @@ def test_pickle_issue18997(self):
                     <group><dogs>4</dogs>
                     </group>"""
                 e1 = dumper.fromstring(XMLTEXT)
-                if hasattr(e1, '__getstate__'):
-                    self.assertEqual(e1.__getstate__()['tag'], 'group')
+                self.assertEqual(e1.__getstate__()['tag'], 'group')
                 e2 = self.pickleRoundTrip(e1, 'xml.etree.ElementTree',
                                           dumper, loader, proto)
                 self.assertEqual(e2.tag, 'group')
@@ -2671,6 +2758,7 @@ def test_pickle_issue18997(self):
 
 
 class BadElementTest(ElementTestCase, unittest.TestCase):
+
     def test_extend_mutable_list(self):
         class X:
             @property
@@ -2709,20 +2797,170 @@ class Y(X, ET.Element):
         e = ET.Element('foo')
         e.extend(L)
 
-    @unittest.skip("TODO: RUSTPYTHON, hangs")
-    def test_remove_with_mutating(self):
-        class X(ET.Element):
+    def test_remove_with_clear_assume_missing(self):
+        # gh-126033: Check that a concurrent clear() for an assumed-to-be
+        # missing element does not make the interpreter crash.
+        self.do_test_remove_with_clear(raises=True)
+
+    def test_remove_with_clear_assume_existing(self):
+        # gh-126033: Check that a concurrent clear() for an assumed-to-be
+        # existing element does not make the interpreter crash.
+        self.do_test_remove_with_clear(raises=False)
+
+    def do_test_remove_with_clear(self, *, raises):
+
+        # Until the discrepency between "del root[:]" and "root.clear()" is
+        # resolved, we need to keep two tests. Previously, using "del root[:]"
+        # did not crash with the reproducer of gh-126033 while "root.clear()"
+        # did.
+
+        class E(ET.Element):
+            """Local class to be able to mock E.__eq__ for introspection."""
+
+        class X(E):
             def __eq__(self, o):
-                del e[:]
-                return False
-        e = ET.Element('foo')
-        e.extend([X('bar')])
-        self.assertRaises(ValueError, e.remove, ET.Element('baz'))
+                del root[:]
+                return not raises
 
-        e = ET.Element('foo')
-        e.extend([ET.Element('bar')])
-        self.assertRaises(ValueError, e.remove, X('baz'))
+        class Y(E):
+            def __eq__(self, o):
+                root.clear()
+                return not raises
 
+        if raises:
+            get_checker_context = lambda: self.assertRaises(ValueError)
+        else:
+            get_checker_context = nullcontext
+
+        self.assertIs(E.__eq__, object.__eq__)
+
+        for Z, side_effect in [(X, 'del root[:]'), (Y, 'root.clear()')]:
+            self.enterContext(self.subTest(side_effect=side_effect))
+
+            # test removing R() from [U()]
+            for R, U, description in [
+                (E, Z, "remove missing E() from [Z()]"),
+                (Z, E, "remove missing Z() from [E()]"),
+                (Z, Z, "remove missing Z() from [Z()]"),
+            ]:
+                with self.subTest(description):
+                    root = E('top')
+                    root.extend([U('one')])
+                    with get_checker_context():
+                        root.remove(R('missing'))
+
+            # test removing R() from [U(), V()]
+            cases = self.cases_for_remove_missing_with_mutations(E, Z)
+            for R, U, V, description in cases:
+                with self.subTest(description):
+                    root = E('top')
+                    root.extend([U('one'), V('two')])
+                    with get_checker_context():
+                        root.remove(R('missing'))
+
+            # Test removing root[0] from [Z()].
+            #
+            # Since we call root.remove() with root[0], Z.__eq__()
+            # will not be called (we branch on the fast Py_EQ path).
+            with self.subTest("remove root[0] from [Z()]"):
+                root = E('top')
+                root.append(Z('rem'))
+                with equal_wrapper(E) as f, equal_wrapper(Z) as g:
+                    root.remove(root[0])
+                f.assert_not_called()
+                g.assert_not_called()
+
+            # Test removing root[1] (of type R) from [U(), R()].
+            is_special = is_python_implementation() and raises and Z is Y
+            if is_python_implementation() and raises and Z is Y:
+                # In pure Python, using root.clear() sets the children
+                # list to [] without calling list.clear().
+                #
+                # For this reason, the call to root.remove() first
+                # checks root[0] and sets the children list to []
+                # since either root[0] or root[1] is an evil element.
+                #
+                # Since checking root[1] still uses the old reference
+                # to the children list, PyObject_RichCompareBool() branches
+                # to the fast Py_EQ path and Y.__eq__() is called exactly
+                # once (when checking root[0]).
+                continue
+            else:
+                cases = self.cases_for_remove_existing_with_mutations(E, Z)
+                for R, U, description in cases:
+                    with self.subTest(description):
+                        root = E('top')
+                        root.extend([U('one'), R('rem')])
+                        with get_checker_context():
+                            root.remove(root[1])
+
+    def test_remove_with_mutate_root_assume_missing(self):
+        # gh-126033: Check that a concurrent mutation for an assumed-to-be
+        # missing element does not make the interpreter crash.
+        self.do_test_remove_with_mutate_root(raises=True)
+
+    def test_remove_with_mutate_root_assume_existing(self):
+        # gh-126033: Check that a concurrent mutation for an assumed-to-be
+        # existing element does not make the interpreter crash.
+        self.do_test_remove_with_mutate_root(raises=False)
+
+    def do_test_remove_with_mutate_root(self, *, raises):
+        E = ET.Element
+
+        class Z(E):
+            def __eq__(self, o):
+                del root[0]
+                return not raises
+
+        if raises:
+            get_checker_context = lambda: self.assertRaises(ValueError)
+        else:
+            get_checker_context = nullcontext
+
+        # test removing R() from [U(), V()]
+        cases = self.cases_for_remove_missing_with_mutations(E, Z)
+        for R, U, V, description in cases:
+            with self.subTest(description):
+                root = E('top')
+                root.extend([U('one'), V('two')])
+                with get_checker_context():
+                    root.remove(R('missing'))
+
+        # test removing root[1] (of type R) from [U(), R()]
+        cases = self.cases_for_remove_existing_with_mutations(E, Z)
+        for R, U, description in cases:
+            with self.subTest(description):
+                root = E('top')
+                root.extend([U('one'), R('rem')])
+                with get_checker_context():
+                    root.remove(root[1])
+
+    def cases_for_remove_missing_with_mutations(self, E, Z):
+        # Cases for removing R() from [U(), V()].
+        # The case U = V = R = E is not interesting as there is no mutation.
+        for U, V in [(E, Z), (Z, E), (Z, Z)]:
+            description = (f"remove missing {E.__name__}() from "
+                           f"[{U.__name__}(), {V.__name__}()]")
+            yield E, U, V, description
+
+        for U, V in [(E, E), (E, Z), (Z, E), (Z, Z)]:
+            description = (f"remove missing {Z.__name__}() from "
+                           f"[{U.__name__}(), {V.__name__}()]")
+            yield Z, U, V, description
+
+    def cases_for_remove_existing_with_mutations(self, E, Z):
+        # Cases for removing root[1] (of type R) from [U(), R()].
+        # The case U = R = E is not interesting as there is no mutation.
+        for U, R, description in [
+            (E, Z, "remove root[1] from [E(), Z()]"),
+            (Z, E, "remove root[1] from [Z(), E()]"),
+            (Z, Z, "remove root[1] from [Z(), Z()]"),
+        ]:
+            description = (f"remove root[1] (of type {R.__name__}) "
+                           f"from [{U.__name__}(), {R.__name__}()]")
+            yield R, U, description
+
+    @support.infinite_recursion(25)
     def test_recursive_repr(self):
         # Issue #25455
         e = ET.Element('foo')
@@ -2821,21 +3059,83 @@ def element_factory(x, y):
         del b
         gc_collect()
 
+    def test_deepcopy_clear(self):
+        # Prevent crashes when __deepcopy__() clears the children list.
+        # See https://github.com/python/cpython/issues/133009.
+        class X(ET.Element):
+            def __deepcopy__(self, memo):
+                root.clear()
+                return self
+
+        root = ET.Element('a')
+        evil = X('x')
+        root.extend([evil, ET.Element('y')])
+        if is_python_implementation():
+            # Mutating a list over which we iterate raises an error.
+            self.assertRaises(RuntimeError, copy.deepcopy, root)
+        else:
+            c = copy.deepcopy(root)
+            # In the C implementation, we can still copy the evil element.
+            self.assertListEqual(list(c), [evil])
+
+    def test_deepcopy_grow(self):
+        # Prevent crashes when __deepcopy__() mutates the children list.
+        # See https://github.com/python/cpython/issues/133009.
+        a = ET.Element('a')
+        b = ET.Element('b')
+        c = ET.Element('c')
+
+        class X(ET.Element):
+            def __deepcopy__(self, memo):
+                root.append(a)
+                root.append(b)
+                return self
+
+        root = ET.Element('top')
+        evil1, evil2 = X('1'), X('2')
+        root.extend([evil1, c, evil2])
+        children = list(copy.deepcopy(root))
+        # mock deep copies
+        self.assertIs(children[0], evil1)
+        self.assertIs(children[2], evil2)
+        # true deep copies
+        self.assertEqual(children[1].tag, c.tag)
+        self.assertEqual([c.tag for c in children[3:]],
+                         [a.tag, b.tag, a.tag, b.tag])
+
 
-class MutatingElementPath(str):
+class MutationDeleteElementPath(str):
     def __new__(cls, elem, *args):
         self = str.__new__(cls, *args)
         self.elem = elem
         return self
+
     def __eq__(self, o):
         del self.elem[:]
         return True
-MutatingElementPath.__hash__ = str.__hash__
+
+    __hash__ = str.__hash__
+
+
+class MutationClearElementPath(str):
+    def __new__(cls, elem, *args):
+        self = str.__new__(cls, *args)
+        self.elem = elem
+        return self
+
+    def __eq__(self, o):
+        self.elem.clear()
+        return True
+
+    __hash__ = str.__hash__
+
 
 class BadElementPath(str):
     def __eq__(self, o):
         raise 1/0
-BadElementPath.__hash__ = str.__hash__
+
+    __hash__ = str.__hash__
+
 
 class BadElementPathTest(ElementTestCase, unittest.TestCase):
     def setUp(self):
@@ -2850,9 +3150,11 @@ def tearDown(self):
         super().tearDown()
 
     def test_find_with_mutating(self):
-        e = ET.Element('foo')
-        e.extend([ET.Element('bar')])
-        e.find(MutatingElementPath(e, 'x'))
+        for cls in [MutationDeleteElementPath, MutationClearElementPath]:
+            with self.subTest(cls):
+                e = ET.Element('foo')
+                e.extend([ET.Element('bar')])
+                e.find(cls(e, 'x'))
 
     def test_find_with_error(self):
         e = ET.Element('foo')
@@ -2863,9 +3165,11 @@ def test_find_with_error(self):
             pass
 
     def test_findtext_with_mutating(self):
-        e = ET.Element('foo')
-        e.extend([ET.Element('bar')])
-        e.findtext(MutatingElementPath(e, 'x'))
+        for cls in [MutationDeleteElementPath, MutationClearElementPath]:
+            with self.subTest(cls):
+                e = ET.Element('foo')
+                e.extend([ET.Element('bar')])
+                e.findtext(cls(e, 'x'))
 
     def test_findtext_with_error(self):
         e = ET.Element('foo')
@@ -2875,10 +3179,26 @@ def test_findtext_with_error(self):
         except ZeroDivisionError:
             pass
 
+    def test_findtext_with_falsey_text_attribute(self):
+        root_elem = ET.Element('foo')
+        sub_elem = ET.SubElement(root_elem, 'bar')
+        falsey = ["", 0, False, [], (), {}]
+        for val in falsey:
+            sub_elem.text = val
+            self.assertEqual(root_elem.findtext('./bar'), val)
+
+    def test_findtext_with_none_text_attribute(self):
+        root_elem = ET.Element('foo')
+        sub_elem = ET.SubElement(root_elem, 'bar')
+        sub_elem.text = None
+        self.assertEqual(root_elem.findtext('./bar'), '')
+
     def test_findall_with_mutating(self):
-        e = ET.Element('foo')
-        e.extend([ET.Element('bar')])
-        e.findall(MutatingElementPath(e, 'x'))
+        for cls in [MutationDeleteElementPath, MutationClearElementPath]:
+            with self.subTest(cls):
+                e = ET.Element('foo')
+                e.extend([ET.Element('bar')])
+                e.findall(cls(e, 'x'))
 
     def test_findall_with_error(self):
         e = ET.Element('foo')
@@ -2946,8 +3266,7 @@ class MyElement(ET.Element):
 
 
 class ElementFindTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_find_simple(self):
         e = ET.XML(SAMPLE_XML)
         self.assertEqual(e.find('tag').tag, 'tag')
@@ -2971,8 +3290,7 @@ def test_find_simple(self):
         # Issue #16922
         self.assertEqual(ET.XML('<tag><empty /></tag>').findtext('empty'), '')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_find_xpath(self):
         LINEAR_XML = '''
         <body>
@@ -2995,8 +3313,7 @@ def test_find_xpath(self):
         self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()-0]')
         self.assertRaisesRegex(SyntaxError, 'XPath', e.find, './tag[last()+1]')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_findall(self):
         e = ET.XML(SAMPLE_XML)
         e[2] = ET.XML(SAMPLE_SECTION)
@@ -3109,8 +3426,7 @@ def test_findall(self):
         self.assertEqual(summarize_list(e.findall(".//tag[. = 'subtext']")),
                          ['tag', 'tag'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_test_find_with_ns(self):
         e = ET.XML(SAMPLE_XML_NS)
         self.assertEqual(summarize_list(e.findall('tag')), [])
@@ -3121,8 +3437,7 @@ def test_test_find_with_ns(self):
             summarize_list(e.findall(".//{http://effbot.org/ns}tag")),
             ['{http://effbot.org/ns}tag'] * 3)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_findall_different_nsmaps(self):
         root = ET.XML('''
             <a xmlns:x="X" xmlns:y="Y">
@@ -3140,8 +3455,7 @@ def test_findall_different_nsmaps(self):
         self.assertEqual(len(root.findall(".//xx:b", namespaces=nsmap)), 2)
         self.assertEqual(len(root.findall(".//b", namespaces=nsmap)), 1)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_findall_wildcard(self):
         root = ET.XML('''
             <a xmlns:x="X" xmlns:y="Y">
@@ -3186,15 +3500,13 @@ def test_findall_wildcard(self):
         self.assertEqual(summarize_list(root.findall(".//{}b")),
                          summarize_list(root.findall(".//b")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_bad_find(self):
         e = ET.XML(SAMPLE_XML)
         with self.assertRaisesRegex(SyntaxError, 'cannot use absolute path'):
             e.findall('/tag')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_find_through_ElementTree(self):
         e = ET.XML(SAMPLE_XML)
         self.assertEqual(ET.ElementTree(e).find('tag').tag, 'tag')
@@ -3214,8 +3526,7 @@ class ElementIterTest(unittest.TestCase):
     def _ilist(self, elem, tag=None):
         return summarize_list(elem.iter(tag))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_basic(self):
         doc = ET.XML("<html><body>this is a <i>paragraph</i>.</body>..</html>")
         self.assertEqual(self._ilist(doc), ['html', 'body', 'i'])
@@ -3233,8 +3544,7 @@ def test_basic(self):
         # With an explicit parser too (issue #9708)
         sourcefile = serialize(doc, to_string=False)
         parser = ET.XMLParser(target=ET.TreeBuilder())
-        self.assertEqual(next(ET.iterparse(sourcefile, parser=parser))[0],
-                         'end')
+        self.assertEqual(next(ET.iterparse(sourcefile, parser=parser))[0], 'end')
 
         tree = ET.ElementTree(None)
         self.assertRaises(AttributeError, tree.iter)
@@ -3265,8 +3575,7 @@ def test_corners(self):
         del a[1]
         self.assertEqual(self._ilist(a), ['a', 'd'])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_iter_by_tag(self):
         doc = ET.XML('''
             <document>
@@ -3331,8 +3640,7 @@ def _check_sample1_element(self, e):
         self.assertEqual(child.tail, 'tail')
         self.assertEqual(child.attrib, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dummy_builder(self):
         class BaseDummyBuilder:
             def close(self):
@@ -3380,8 +3688,7 @@ def test_treebuilder_pi(self):
         self.assertEqual(b.pi('target'), (len('target'), None))
         self.assertEqual(b.pi('pitarget', ' text '), (len('pitarget'), ' text '))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_late_tail(self):
         # Issue #37399: The tail of an ignored comment could overwrite the text before it.
         class TreeBuilderSubclass(ET.TreeBuilder):
@@ -3406,8 +3713,7 @@ class TreeBuilderSubclass(ET.TreeBuilder):
         a = parser.close()
         self.assertEqual(a.text, "texttail")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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.
@@ -3444,16 +3750,14 @@ class TreeBuilderSubclass(ET.TreeBuilder):
         self.assertEqual(a[0].tail, 'tail')
         self.assertEqual(a.text, "text\n")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_treebuilder_elementfactory_none(self):
         parser = ET.XMLParser(target=ET.TreeBuilder(element_factory=None))
         parser.feed(self.sample1)
         e = parser.close()
         self._check_sample1_element(e)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass(self):
         class MyTreeBuilder(ET.TreeBuilder):
             def foobar(self, x):
@@ -3468,8 +3772,7 @@ def foobar(self, x):
         e = parser.close()
         self._check_sample1_element(e)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_comment_pi(self):
         class MyTreeBuilder(ET.TreeBuilder):
             def foobar(self, x):
@@ -3485,8 +3788,7 @@ def foobar(self, x):
         e = parser.close()
         self._check_sample1_element(e)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_element_factory(self):
         lst = []
         def myfactory(tag, attrib):
@@ -3510,15 +3812,13 @@ def _check_element_factory_class(self, cls):
         self.assertIsInstance(e, cls)
         self._check_sample1_element(e)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_element_factory_subclass(self):
         class MyElement(ET.Element):
             pass
         self._check_element_factory_class(MyElement)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_element_factory_pure_python_subclass(self):
         # Mimic SimpleTAL's behaviour (issue #16089): both versions of
         # TreeBuilder should be able to cope with a subclass of the
@@ -3532,8 +3832,7 @@ class MyElement(base, ValueError):
             pass
         self._check_element_factory_class(MyElement)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_doctype(self):
         class DoctypeParser:
             _doctype = None
@@ -3551,8 +3850,7 @@ def close(self):
             ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
              'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_builder_lookup_errors(self):
         class RaisingBuilder:
             def __init__(self, raise_in=None, what=ValueError):
@@ -3593,16 +3891,14 @@ def _check_sample_element(self, e):
         self.assertEqual(e[0].tag, 'line')
         self.assertEqual(e[0].text, '22')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_constructor_args(self):
         parser2 = ET.XMLParser(encoding='utf-8',
                                target=ET.TreeBuilder())
         parser2.feed(self.sample1)
         self._check_sample_element(parser2.close())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass(self):
         class MyParser(ET.XMLParser):
             pass
@@ -3610,8 +3906,7 @@ class MyParser(ET.XMLParser):
         parser.feed(self.sample1)
         self._check_sample_element(parser.close())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_doctype_warning(self):
         with warnings.catch_warnings():
             warnings.simplefilter('error', DeprecationWarning)
@@ -3619,8 +3914,7 @@ def test_doctype_warning(self):
             parser.feed(self.sample2)
             parser.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_subclass_doctype(self):
         _doctype = None
         class MyParserWithDoctype(ET.XMLParser):
@@ -3651,8 +3945,7 @@ def doctype(self, name, pubid, system):
                 ('html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
                  'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_inherited_doctype(self):
         '''Ensure that ordinary usage is not deprecated (Issue 19176)'''
         with warnings.catch_warnings():
@@ -3664,8 +3957,7 @@ class MyParserWithoutDoctype(ET.XMLParser):
             parser.feed(self.sample2)
             parser.close()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_parse_string(self):
         parser = ET.XMLParser(target=ET.TreeBuilder())
         parser.feed(self.sample3)
@@ -3676,8 +3968,7 @@ def test_parse_string(self):
 
 
 class NamespaceParseTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_find_with_namespace(self):
         nsmap = {'h': 'hello', 'f': 'foo'}
         doc = ET.fromstring(SAMPLE_XML_NS_ELEMS)
@@ -3836,10 +4127,25 @@ def test_setslice_negative_steps(self):
         e[1::-sys.maxsize<<64] = [ET.Element('d')]
         self.assertEqual(self._subelem_tags(e), ['a0', 'd', 'a2', 'a3'])
 
+    def test_issue123213_setslice_exception(self):
+        e = ET.Element('tag')
+        # Does not hide the internal exception when assigning to the element
+        with self.assertRaises(ZeroDivisionError):
+            e[:1] = (1/0 for i in range(2))
+
+        # Still raises the TypeError when assigning with a non-iterable
+        with self.assertRaises(TypeError):
+            e[:1] = None
+
+        # Preserve the original TypeError message when assigning.
+        def f():
+            raise TypeError("mymessage")
+
+        with self.assertRaisesRegex(TypeError, 'mymessage'):
+            e[:1] = (f() for i in range(2))
 
 class IOTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_encoding(self):
         # Test encoding issues.
         elem = ET.Element("tag")
@@ -3909,8 +4215,7 @@ def test_encoding(self):
                     ("<?xml version='1.0' encoding='%s'?>\n"
                      "<tag key=\"åöö&lt;&gt;\" />" % enc).encode(enc))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_filename(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -3918,8 +4223,7 @@ def test_write_to_filename(self):
         with open(TESTFN, 'rb') as f:
             self.assertEqual(f.read(), b'''<site>&#248;</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_filename_with_encoding(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -3933,8 +4237,7 @@ def test_write_to_filename_with_encoding(self):
                              b'''<?xml version='1.0' encoding='ISO-8859-1'?>\n'''
                              b'''<site>\xf8</site>'''))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_filename_as_unicode(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         with open(TESTFN, 'w') as f:
@@ -3946,8 +4249,7 @@ def test_write_to_filename_as_unicode(self):
         with open(TESTFN, 'rb') as f:
             self.assertEqual(f.read(), b"<site>\xc3\xb8</site>")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_text_file(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -3969,8 +4271,7 @@ def test_write_to_text_file(self):
         with open(TESTFN, 'rb') as f:
             self.assertEqual(f.read(), b'''<site>\xf8</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_binary_file(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -3980,8 +4281,7 @@ def test_write_to_binary_file(self):
         with open(TESTFN, 'rb') as f:
             self.assertEqual(f.read(), b'''<site>&#248;</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_binary_file_with_encoding(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -3999,8 +4299,7 @@ def test_write_to_binary_file_with_encoding(self):
                              b'''<?xml version='1.0' encoding='ISO-8859-1'?>\n'''
                              b'''<site>\xf8</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_binary_file_with_bom(self):
         self.addCleanup(os_helper.unlink, TESTFN)
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
@@ -4021,32 +4320,28 @@ def test_write_to_binary_file_with_bom(self):
                     '''<?xml version='1.0' encoding='utf-16'?>\n'''
                     '''<site>\xf8</site>'''.encode("utf-16"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_from_stringio(self):
         tree = ET.ElementTree()
         stream = io.StringIO('''<?xml version="1.0"?><site></site>''')
         tree.parse(stream)
         self.assertEqual(tree.getroot().tag, 'site')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_stringio(self):
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
         stream = io.StringIO()
         tree.write(stream, encoding='unicode')
         self.assertEqual(stream.getvalue(), '''<site>\xf8</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_from_bytesio(self):
         tree = ET.ElementTree()
         raw = io.BytesIO(b'''<?xml version="1.0"?><site></site>''')
         tree.parse(raw)
         self.assertEqual(tree.getroot().tag, 'site')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_bytesio(self):
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
         raw = io.BytesIO()
@@ -4056,8 +4351,7 @@ def test_write_to_bytesio(self):
     class dummy:
         pass
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_from_user_text_reader(self):
         stream = io.StringIO('''<?xml version="1.0"?><site></site>''')
         reader = self.dummy()
@@ -4066,8 +4360,7 @@ def test_read_from_user_text_reader(self):
         tree.parse(reader)
         self.assertEqual(tree.getroot().tag, 'site')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_user_text_writer(self):
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
         stream = io.StringIO()
@@ -4076,8 +4369,7 @@ def test_write_to_user_text_writer(self):
         tree.write(writer, encoding='unicode')
         self.assertEqual(stream.getvalue(), '''<site>\xf8</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_read_from_user_binary_reader(self):
         raw = io.BytesIO(b'''<?xml version="1.0"?><site></site>''')
         reader = self.dummy()
@@ -4087,8 +4379,7 @@ def test_read_from_user_binary_reader(self):
         self.assertEqual(tree.getroot().tag, 'site')
         tree = ET.ElementTree()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_user_binary_writer(self):
         tree = ET.ElementTree(ET.XML('''<site>\xf8</site>'''))
         raw = io.BytesIO()
@@ -4097,8 +4388,7 @@ def test_write_to_user_binary_writer(self):
         tree.write(writer)
         self.assertEqual(raw.getvalue(), b'''<site>&#248;</site>''')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_write_to_user_binary_writer_with_bom(self):
         tree = ET.ElementTree(ET.XML('''<site />'''))
         raw = io.BytesIO()
@@ -4111,8 +4401,7 @@ def test_write_to_user_binary_writer_with_bom(self):
                 '''<?xml version='1.0' encoding='utf-16'?>\n'''
                 '''<site />'''.encode("utf-16"))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_tostringlist_invariant(self):
         root = ET.fromstring('<tag>foo</tag>')
         self.assertEqual(
@@ -4122,8 +4411,7 @@ def test_tostringlist_invariant(self):
             ET.tostring(root, 'utf-16'),
             b''.join(ET.tostringlist(root, 'utf-16')))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_short_empty_elements(self):
         root = ET.fromstring('<tag>a<x />b<y></y>c</tag>')
         self.assertEqual(
@@ -4147,15 +4435,13 @@ def _get_error(self, s):
         except ET.ParseError as e:
             return e
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @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))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_error_code(self):
         import xml.parsers.expat.errors as ERRORS
         self.assertEqual(self._get_error('foo').code,
@@ -4163,10 +4449,9 @@ def test_error_code(self):
 
 
 class KeywordArgsTest(unittest.TestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test various issues with keyword arguments passed to ET.Element
     # constructor and methods
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_issue14818(self):
         x = ET.XML("<a>foo</a>")
         self.assertEqual(x.find('a', None),
@@ -4201,12 +4486,11 @@ def test_issue14818(self):
 # --------------------------------------------------------------------
 
 class NoAcceleratorTest(unittest.TestCase):
-    def setUp(self):
-        if not pyET:
+    @classmethod
+    def setUpClass(cls):
+        if ET is not pyET:
             raise unittest.SkipTest('only for the Python version')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     # Test that the C accelerator was not imported for pyET
     def test_correct_import_pyET(self):
         # The type of methods defined in Python code is types.FunctionType,
@@ -4215,6 +4499,26 @@ def test_correct_import_pyET(self):
         self.assertIsInstance(pyET.Element.__init__, types.FunctionType)
         self.assertIsInstance(pyET.XMLParser.__init__, types.FunctionType)
 
+# --------------------------------------------------------------------
+
+class BoolTest(unittest.TestCase):
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_warning(self):
+        e = ET.fromstring('<a style="new"></a>')
+        msg = (
+            r"Testing an element's truth value will always return True in "
+            r"future versions.  "
+            r"Use specific 'len\(elem\)' or 'elem is not None' test instead.")
+        with self.assertWarnsRegex(DeprecationWarning, msg):
+            result = bool(e)
+        # Emulate prior behavior for now
+        self.assertIs(result, False)
+
+        # Element with children
+        ET.SubElement(e, 'b')
+        with self.assertWarnsRegex(DeprecationWarning, msg):
+            new_result = bool(e)
+        self.assertIs(new_result, True)
 
 # --------------------------------------------------------------------
 
@@ -4228,8 +4532,7 @@ class C14NTest(unittest.TestCase):
     #
     # simple roundtrip tests (from c14n.py)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_simple_roundtrip(self):
         # Basics
         self.assertEqual(c14n_roundtrip("<doc/>"), '<doc></doc>')
@@ -4270,8 +4573,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)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_c14n_exclusion(self):
         xml = textwrap.dedent("""\
         <root xmlns:x="http://example.com/x">
@@ -4352,8 +4654,7 @@ def test_c14n_exclusion(self):
     # note that this uses generated C14N versions of the standard ET.write
     # output, not roundtripped C14N (see above).
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_xml_c14n2(self):
         datadir = findfile("c14n-20", subdir="xmltestdata")
         full_path = partial(os.path.join, datadir)
@@ -4456,8 +4757,7 @@ def get_option(config, option_name, default=None):
 
 # --------------------------------------------------------------------
 
-
-def test_main(module=None):
+def setUpModule(module=None):
     # When invoked without a module, runs the Python ET tests by loading pyET.
     # Otherwise, uses the given module as the ET.
     global pyET
@@ -4469,62 +4769,30 @@ def test_main(module=None):
     global ET
     ET = module
 
-    test_classes = [
-        ModuleTest,
-        ElementSlicingTest,
-        BasicElementTest,
-        BadElementTest,
-        BadElementPathTest,
-        ElementTreeTest,
-        IOTest,
-        ParseErrorTest,
-        XIncludeTest,
-        ElementTreeTypeTest,
-        ElementFindTest,
-        ElementIterTest,
-        TreeBuilderTest,
-        XMLParserTest,
-        XMLPullParserTest,
-        BugsTest,
-        KeywordArgsTest,
-        C14NTest,
-        ]
-
-    # These tests will only run for the pure-Python version that doesn't import
-    # _elementtree. We can't use skipUnless here, because pyET is filled in only
-    # after the module is loaded.
-    if pyET is not ET:
-        test_classes.extend([
-            NoAcceleratorTest,
-            ])
+    # don't interfere with subsequent tests
+    def cleanup():
+        global ET, pyET
+        ET = pyET = None
+    unittest.addModuleCleanup(cleanup)
 
     # Provide default namespace mapping and path cache.
     from xml.etree import ElementPath
     nsmap = ET.register_namespace._namespace_map
     # Copy the default namespace mapping
     nsmap_copy = nsmap.copy()
+    unittest.addModuleCleanup(nsmap.update, nsmap_copy)
+    unittest.addModuleCleanup(nsmap.clear)
+
     # Copy the path cache (should be empty)
     path_cache = ElementPath._cache
+    unittest.addModuleCleanup(setattr, ElementPath, "_cache", path_cache)
     ElementPath._cache = path_cache.copy()
+
     # Align the Comment/PI factories.
     if hasattr(ET, '_set_factories'):
         old_factories = ET._set_factories(ET.Comment, ET.PI)
-    else:
-        old_factories = None
-
-    try:
-        support.run_unittest(*test_classes)
-    finally:
-        from xml.etree import ElementPath
-        # Restore mapping and path cache
-        nsmap.clear()
-        nsmap.update(nsmap_copy)
-        ElementPath._cache = path_cache
-        if old_factories is not None:
-            ET._set_factories(*old_factories)
-        # don't interfere with subsequent tests
-        ET = pyET = None
+        unittest.addModuleCleanup(ET._set_factories, *old_factories)
 
 
 if __name__ == '__main__':
-    test_main()
+    unittest.main()
diff --git a/Lib/test/test_xml_etree_c.py b/Lib/test/test_xml_etree_c.py
new file mode 100644
index 0000000000..3a0fc572f4
--- /dev/null
+++ b/Lib/test/test_xml_etree_c.py
@@ -0,0 +1,278 @@
+# xml.etree test for cElementTree
+import io
+import struct
+from test import support
+from test.support.import_helper import import_fresh_module
+import types
+import unittest
+
+cET = import_fresh_module('xml.etree.ElementTree',
+                          fresh=['_elementtree'])
+cET_alias = import_fresh_module('xml.etree.cElementTree',
+                                fresh=['_elementtree', 'xml.etree'],
+                                deprecated=True)
+
+
+@unittest.skipUnless(cET, 'requires _elementtree')
+class MiscTests(unittest.TestCase):
+    # Issue #8651.
+    @support.bigmemtest(size=support._2G + 100, memuse=1, dry_run=False)
+    def test_length_overflow(self, size):
+        data = b'x' * size
+        parser = cET.XMLParser()
+        try:
+            self.assertRaises(OverflowError, parser.feed, data)
+        finally:
+            data = None
+
+    def test_del_attribute(self):
+        element = cET.Element('tag')
+
+        element.tag = 'TAG'
+        with self.assertRaises(AttributeError):
+            del element.tag
+        self.assertEqual(element.tag, 'TAG')
+
+        with self.assertRaises(AttributeError):
+            del element.text
+        self.assertIsNone(element.text)
+        element.text = 'TEXT'
+        with self.assertRaises(AttributeError):
+            del element.text
+        self.assertEqual(element.text, 'TEXT')
+
+        with self.assertRaises(AttributeError):
+            del element.tail
+        self.assertIsNone(element.tail)
+        element.tail = 'TAIL'
+        with self.assertRaises(AttributeError):
+            del element.tail
+        self.assertEqual(element.tail, 'TAIL')
+
+        with self.assertRaises(AttributeError):
+            del element.attrib
+        self.assertEqual(element.attrib, {})
+        element.attrib = {'A': 'B', 'C': 'D'}
+        with self.assertRaises(AttributeError):
+            del element.attrib
+        self.assertEqual(element.attrib, {'A': 'B', 'C': 'D'})
+
+    def test_trashcan(self):
+        # If this test fails, it will most likely die via segfault.
+        e = root = cET.Element('root')
+        for i in range(200000):
+            e = cET.SubElement(e, 'x')
+        del e
+        del root
+        support.gc_collect()
+
+    def test_parser_ref_cycle(self):
+        # bpo-31499: xmlparser_dealloc() crashed with a segmentation fault when
+        # xmlparser_gc_clear() was called previously by the garbage collector,
+        # when the parser was part of a reference cycle.
+
+        def parser_ref_cycle():
+            parser = cET.XMLParser()
+            # Create a reference cycle using an exception to keep the frame
+            # alive, so the parser will be destroyed by the garbage collector
+            try:
+                raise ValueError
+            except ValueError as exc:
+                err = exc
+
+        # Create a parser part of reference cycle
+        parser_ref_cycle()
+        # Trigger an explicit garbage collection to break the reference cycle
+        # and so destroy the parser
+        support.gc_collect()
+
+    def test_bpo_31728(self):
+        # A crash or an assertion failure shouldn't happen, in case garbage
+        # collection triggers a call to clear() or a reading of text or tail,
+        # while a setter or clear() or __setstate__() is already running.
+        elem = cET.Element('elem')
+        class X:
+            def __del__(self):
+                elem.text
+                elem.tail
+                elem.clear()
+
+        elem.text = X()
+        elem.clear()  # shouldn't crash
+
+        elem.tail = X()
+        elem.clear()  # shouldn't crash
+
+        elem.text = X()
+        elem.text = X()  # shouldn't crash
+        elem.clear()
+
+        elem.tail = X()
+        elem.tail = X()  # shouldn't crash
+        elem.clear()
+
+        elem.text = X()
+        elem.__setstate__({'tag': 42})  # shouldn't cause an assertion failure
+        elem.clear()
+
+        elem.tail = X()
+        elem.__setstate__({'tag': 42})  # shouldn't cause an assertion failure
+
+    @support.cpython_only
+    def test_uninitialized_parser(self):
+        # The interpreter shouldn't crash in case of calling methods or
+        # accessing attributes of uninitialized XMLParser objects.
+        parser = cET.XMLParser.__new__(cET.XMLParser)
+        self.assertRaises(ValueError, parser.close)
+        self.assertRaises(ValueError, parser.feed, 'foo')
+        class MockFile:
+            def read(*args):
+                return ''
+        self.assertRaises(ValueError, parser._parse_whole, MockFile())
+        self.assertRaises(ValueError, parser._setevents, None)
+        self.assertIsNone(parser.entity)
+        self.assertIsNone(parser.target)
+
+    def test_setstate_leaks(self):
+        # Test reference leaks
+        elem = cET.Element.__new__(cET.Element)
+        for i in range(100):
+            elem.__setstate__({'tag': 'foo', 'attrib': {'bar': 42},
+                               '_children': [cET.Element('child')],
+                               'text': 'text goes here',
+                               'tail': 'opposite of head'})
+
+        self.assertEqual(elem.tag, 'foo')
+        self.assertEqual(elem.text, 'text goes here')
+        self.assertEqual(elem.tail, 'opposite of head')
+        self.assertEqual(list(elem.attrib.items()), [('bar', 42)])
+        self.assertEqual(len(elem), 1)
+        self.assertEqual(elem[0].tag, 'child')
+
+    def test_iterparse_leaks(self):
+        # Test reference leaks in TreeBuilder (issue #35502).
+        # The test is written to be executed in the hunting reference leaks
+        # mode.
+        XML = '<a></a></b>'
+        parser = cET.iterparse(io.StringIO(XML))
+        next(parser)
+        del parser
+        support.gc_collect()
+
+    def test_xmlpullparser_leaks(self):
+        # Test reference leaks in TreeBuilder (issue #35502).
+        # The test is written to be executed in the hunting reference leaks
+        # mode.
+        XML = '<a></a></b>'
+        parser = cET.XMLPullParser()
+        parser.feed(XML)
+        del parser
+        support.gc_collect()
+
+    def test_dict_disappearing_during_get_item(self):
+        # test fix for seg fault reported in issue 27946
+        class X:
+            def __hash__(self):
+                e.attrib = {} # this frees e->extra->attrib
+                [{i: i} for i in range(1000)] # exhaust the dict keys cache
+                return 13
+
+        e = cET.Element("elem", {1: 2})
+        r = e.get(X())
+        self.assertIsNone(r)
+
+    @support.cpython_only
+    def test_immutable_types(self):
+        root = cET.fromstring('<a></a>')
+        dataset = (
+            cET.Element,
+            cET.TreeBuilder,
+            cET.XMLParser,
+            type(root.iter()),
+        )
+        for tp in dataset:
+            with self.subTest(tp=tp):
+                with self.assertRaisesRegex(TypeError, "immutable"):
+                    tp.foo = 1
+
+    @support.cpython_only
+    def test_disallow_instantiation(self):
+        root = cET.fromstring('<a></a>')
+        iter_type = type(root.iter())
+        support.check_disallow_instantiation(self, iter_type)
+
+
+@unittest.skipUnless(cET, 'requires _elementtree')
+class TestAliasWorking(unittest.TestCase):
+    # Test that the cET alias module is alive
+    def test_alias_working(self):
+        e = cET_alias.Element('foo')
+        self.assertEqual(e.tag, 'foo')
+
+
+@unittest.skipUnless(cET, 'requires _elementtree')
+@support.cpython_only
+class TestAcceleratorImported(unittest.TestCase):
+    # Test that the C accelerator was imported, as expected
+    def test_correct_import_cET(self):
+        # SubElement is a function so it retains _elementtree as its module.
+        self.assertEqual(cET.SubElement.__module__, '_elementtree')
+
+    def test_correct_import_cET_alias(self):
+        self.assertEqual(cET_alias.SubElement.__module__, '_elementtree')
+
+    def test_parser_comes_from_C(self):
+        # The type of methods defined in Python code is types.FunctionType,
+        # while the type of methods defined inside _elementtree is
+        # <class 'wrapper_descriptor'>
+        self.assertNotIsInstance(cET.Element.__init__, types.FunctionType)
+
+
+@unittest.skipUnless(cET, 'requires _elementtree')
+@support.cpython_only
+class SizeofTest(unittest.TestCase):
+    def setUp(self):
+        self.elementsize = support.calcobjsize('5P')
+        # extra
+        self.extra = struct.calcsize('PnnP4P')
+
+    check_sizeof = support.check_sizeof
+
+    def test_element(self):
+        e = cET.Element('a')
+        self.check_sizeof(e, self.elementsize)
+
+    def test_element_with_attrib(self):
+        e = cET.Element('a', href='about:')
+        self.check_sizeof(e, self.elementsize + self.extra)
+
+    def test_element_with_children(self):
+        e = cET.Element('a')
+        for i in range(5):
+            cET.SubElement(e, 'span')
+        # should have space for 8 children now
+        self.check_sizeof(e, self.elementsize + self.extra +
+                             struct.calcsize('8P'))
+
+
+def install_tests():
+    # Test classes should have __module__ referring to this module.
+    from test import test_xml_etree
+    for name, base in vars(test_xml_etree).items():
+        if isinstance(base, type) and issubclass(base, unittest.TestCase):
+            class Temp(base):
+                pass
+            Temp.__name__ = Temp.__qualname__ = name
+            Temp.__module__ = __name__
+            assert name not in globals()
+            globals()[name] = Temp
+
+install_tests()
+
+def setUpModule():
+    from test import test_xml_etree
+    test_xml_etree.setUpModule(module=cET)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index 25a4be0e03..6b2e6c44ca 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -25,6 +25,8 @@
 except ImportError:
     gzip = None
 
+support.requires_working_socket(module=True)
+
 alist = [{'astring': 'foo@bar.baz.spam',
           'afloat': 7283.43,
           'anint': 2**20,
@@ -45,15 +47,11 @@
 
 class XMLRPCTestCase(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_load(self):
         dump = xmlrpclib.dumps((alist,))
         load = xmlrpclib.loads(dump)
         self.assertEqual(alist, load[0][0])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_bare_datetime(self):
         # This checks that an unwrapped datetime.date object can be handled
         # by the marshalling code.  This can't be done via test_dump_load()
@@ -88,8 +86,6 @@ def test_dump_bare_datetime(self):
         self.assertIsNone(m)
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_datetime_before_1900(self):
         # same as before but with a date before 1900
         dt = datetime.datetime(1,  2, 10, 11, 41, 23)
@@ -108,8 +104,6 @@ def test_datetime_before_1900(self):
         self.assertIs(type(newdt), xmlrpclib.DateTime)
         self.assertIsNone(m)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_bug_1164912 (self):
         d = xmlrpclib.DateTime()
         ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
@@ -120,8 +114,6 @@ def test_bug_1164912 (self):
         s = xmlrpclib.dumps((new_d,), methodresponse=True)
         self.assertIsInstance(s, str)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_newstyle_class(self):
         class T(object):
             pass
@@ -187,8 +179,6 @@ def dummy_write(s):
         m.dump_double(xmlrpclib.MAXINT + 42, dummy_write)
         m.dump_double(xmlrpclib.MININT - 42, dummy_write)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_none(self):
         value = alist + [None]
         arg1 = (alist + [None],)
@@ -197,8 +187,7 @@ def test_dump_none(self):
                           xmlrpclib.loads(strg)[0][0])
         self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_dump_encoding(self):
         value = {'key\u20ac\xa4':
                  'value\u20ac\xa4'}
@@ -220,8 +209,6 @@ def test_dump_encoding(self):
         self.assertEqual(xmlrpclib.loads(strg)[0][0], value)
         self.assertEqual(xmlrpclib.loads(strg)[1], methodname)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_bytes(self):
         sample = b"my dog has fleas"
         self.assertEqual(sample, xmlrpclib.Binary(sample))
@@ -241,8 +228,7 @@ def test_dump_bytes(self):
             self.assertIs(type(newvalue), xmlrpclib.Binary)
             self.assertIsNone(m)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_loads_unsupported(self):
         ResponseError = xmlrpclib.ResponseError
         data = '<params><param><value><spam/></value></param></params>'
@@ -265,8 +251,6 @@ def check_loads(self, s, value, **kwargs):
         self.assertIs(type(newvalue), type(value))
         self.assertIsNone(m)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_load_standard_types(self):
         check = self.check_loads
         check('string', 'string')
@@ -294,8 +278,7 @@ def test_load_standard_types(self):
               '<member><name>a</name><value><int>1</int></value></member>'
               '</struct>', {'a': 1, 'b': 2})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_load_extension_types(self):
         check = self.check_loads
         check('<nil/>', None)
@@ -309,6 +292,16 @@ def test_load_extension_types(self):
         check('<bigdecimal>9876543210.0123456789</bigdecimal>',
               decimal.Decimal('9876543210.0123456789'))
 
+    def test_limit_int(self):
+        check = self.check_loads
+        maxdigits = 5000
+        with support.adjust_int_max_str_digits(maxdigits):
+            s = '1' * (maxdigits + 1)
+            with self.assertRaises(ValueError):
+                check(f'<int>{s}</int>', None)
+            with self.assertRaises(ValueError):
+                check(f'<biginteger>{s}</biginteger>', None)
+
     def test_get_host_info(self):
         # see bug #3613, this raised a TypeError
         transp = xmlrpc.client.Transport()
@@ -330,8 +323,6 @@ def test_ssl_presence(self):
         except OSError:
             self.assertTrue(has_ssl)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_keepalive_disconnect(self):
         class RequestHandler(http.server.BaseHTTPRequestHandler):
             protocol_version = "HTTP/1.1"
@@ -471,8 +462,6 @@ def test_repr(self):
         self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
         self.assertEqual(repr(f), str(f))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dump_fault(self):
         f = xmlrpclib.Fault(42, 'Test Fault')
         s = xmlrpclib.dumps((f,))
@@ -518,10 +507,16 @@ def test_time_struct(self):
         self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
 
     def test_datetime_datetime(self):
+        # naive (no tzinfo)
         d = datetime.datetime(2007,1,2,3,4,5)
         t = xmlrpclib.DateTime(d)
         self.assertEqual(str(t), '20070102T03:04:05')
 
+        # aware (with tzinfo): the timezone is ignored
+        d = datetime.datetime(2023, 6, 12, 13, 30, tzinfo=datetime.UTC)
+        t = xmlrpclib.DateTime(d)
+        self.assertEqual(str(t), '20230612T13:30:00')
+
     def test_repr(self):
         d = datetime.datetime(2007,1,2,3,4,5)
         t = xmlrpclib.DateTime(d)
@@ -814,8 +809,6 @@ def tearDown(self):
         xmlrpc.server.SimpleXMLRPCServer._send_traceback_header = False
 
 class SimpleServerTestCase(BaseServerTestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_simple1(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -826,8 +819,6 @@ def test_simple1(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nonascii(self):
         start_string = 'P\N{LATIN SMALL LETTER Y WITH CIRCUMFLEX}t'
         end_string = 'h\N{LATIN SMALL LETTER O WITH HORN}n'
@@ -841,8 +832,7 @@ def test_nonascii(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_client_encoding(self):
         start_string = '\u20ac'
         end_string = '\xa4'
@@ -857,8 +847,6 @@ def test_client_encoding(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_nonascii_methodname(self):
         try:
             p = xmlrpclib.ServerProxy(URL, encoding='ascii')
@@ -879,8 +867,6 @@ def test_404(self):
         self.assertEqual(response.status, 404)
         self.assertEqual(response.reason, 'Not Found')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_introspection1(self):
         expected_methods = set(['pow', 'div', 'my_function', 'add', 'têšt',
                                 'system.listMethods', 'system.methodHelp',
@@ -897,8 +883,6 @@ def test_introspection1(self):
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_introspection2(self):
         try:
             # test _methodHelp()
@@ -911,8 +895,6 @@ def test_introspection2(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     @make_request_and_skipIf(sys.flags.optimize >= 2,
                      "Docstrings are omitted with -O2 and above")
     def test_introspection3(self):
@@ -927,8 +909,6 @@ def test_introspection3(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_introspection4(self):
         # the SimpleXMLRPCServer doesn't support signatures, but
         # at least check that we can try making the call
@@ -942,8 +922,6 @@ def test_introspection4(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_multicall(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -961,8 +939,6 @@ def test_multicall(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_non_existing_multicall(self):
         try:
             p = xmlrpclib.ServerProxy(URL)
@@ -984,8 +960,6 @@ def test_non_existing_multicall(self):
                 # protocol error; provide additional information in test output
                 self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_dotted_attribute(self):
         # Raises an AttributeError because private methods are not allowed.
         self.assertRaises(AttributeError,
@@ -996,16 +970,12 @@ def test_dotted_attribute(self):
         # This avoids waiting for the socket timeout.
         self.test_simple1()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_allow_dotted_names_true(self):
         # XXX also need allow_dotted_names_false test.
         server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
         data = server.Fixture.getData()
         self.assertEqual(data, '42')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_unicode_host(self):
         server = xmlrpclib.ServerProxy("http://%s:%d/RPC2" % (ADDR, PORT))
         self.assertEqual(server.add("a", "\xe9"), "a\xe9")
@@ -1020,8 +990,6 @@ def test_partial_post(self):
                       'Accept-Encoding: identity\r\n'
                       'Content-Length: 0\r\n\r\n'.encode('ascii'))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_context_manager(self):
         with xmlrpclib.ServerProxy(URL) as server:
             server.add(2, 3)
@@ -1030,8 +998,6 @@ def test_context_manager(self):
         self.assertEqual(server('transport')._connection,
                          (None, None))
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_context_manager_method_error(self):
         try:
             with xmlrpclib.ServerProxy(URL) as server:
@@ -1047,8 +1013,7 @@ class SimpleServerEncodingTestCase(BaseServerTestCase):
     def threadFunc(evt, numrequests, requestHandler=None, encoding=None):
         http_server(evt, numrequests, requestHandler, 'iso-8859-15')
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_server_encoding(self):
         start_string = '\u20ac'
         end_string = '\xa4'
@@ -1067,70 +1032,57 @@ def test_server_encoding(self):
 class MultiPathServerTestCase(BaseServerTestCase):
     threadFunc = staticmethod(http_multi_server)
     request_count = 2
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_path1(self):
         p = xmlrpclib.ServerProxy(URL+"/foo")
         self.assertEqual(p.pow(6,8), 6**8)
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_path2(self):
         p = xmlrpclib.ServerProxy(URL+"/foo/bar")
         self.assertEqual(p.add(6,8), 6+8)
         self.assertRaises(xmlrpclib.Fault, p.pow, 6, 8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_path3(self):
         p = xmlrpclib.ServerProxy(URL+"/is/broken")
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_invalid_path(self):
         p = xmlrpclib.ServerProxy(URL+"/invalid")
         self.assertRaises(xmlrpclib.Fault, p.add, 6, 8)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_path_query_fragment(self):
         p = xmlrpclib.ServerProxy(URL+"/foo?k=v#frag")
         self.assertEqual(p.test(), "/foo?k=v#frag")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_path_fragment(self):
         p = xmlrpclib.ServerProxy(URL+"/foo#frag")
         self.assertEqual(p.test(), "/foo#frag")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_path_query(self):
         p = xmlrpclib.ServerProxy(URL+"/foo?k=v")
         self.assertEqual(p.test(), "/foo?k=v")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_empty_path(self):
         p = xmlrpclib.ServerProxy(URL)
         self.assertEqual(p.test(), "/RPC2")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_root_path(self):
         p = xmlrpclib.ServerProxy(URL + "/")
         self.assertEqual(p.test(), "/")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_empty_path_query(self):
         p = xmlrpclib.ServerProxy(URL + "?k=v")
         self.assertEqual(p.test(), "?k=v")
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @support.requires_resource('walltime')
     def test_empty_path_fragment(self):
         p = xmlrpclib.ServerProxy(URL + "#frag")
         self.assertEqual(p.test(), "#frag")
@@ -1163,8 +1115,6 @@ def setUp(self):
 #A test case that verifies that a server using the HTTP/1.1 keep-alive mechanism
 #does indeed serve subsequent requests on the same connection
 class KeepaliveServerTestCase1(BaseKeepaliveServerTestCase):
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_two(self):
         p = xmlrpclib.ServerProxy(URL)
         #do three requests.
@@ -1181,7 +1131,6 @@ def test_two(self):
         self.assertGreaterEqual(len(self.RequestHandler.myRequests[-1]), 2)
 
 
-@unittest.skip("TODO: RUSTPYTHON, appears to hang")
 #test special attribute access on the serverproxy, through the __call__
 #function.
 class KeepaliveServerTestCase2(BaseKeepaliveServerTestCase):
@@ -1248,8 +1197,6 @@ def send_content(self, connection, body):
     def setUp(self):
         BaseServerTestCase.setUp(self)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gzip_request(self):
         t = self.Transport()
         t.encode_threshold = None
@@ -1273,8 +1220,6 @@ def test_bad_gzip_request(self):
             p.pow(6, 8)
         p("close")()
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_gzip_response(self):
         t = self.Transport()
         p = xmlrpclib.ServerProxy(URL, transport=t)
@@ -1333,8 +1278,6 @@ def assertContainsAdditionalHeaders(self, headers, additional):
         for key, value in additional.items():
             self.assertEqual(headers.get(key), value)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_header(self):
         p = xmlrpclib.ServerProxy(URL, headers=[('X-Test', 'foo')])
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1342,8 +1285,6 @@ def test_header(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_header_many(self):
         p = xmlrpclib.ServerProxy(
             URL, headers=[('X-Test', 'foo'), ('X-Test-Second', 'bar')])
@@ -1353,8 +1294,6 @@ def test_header_many(self):
         self.assertContainsAdditionalHeaders(
             headers, {'X-Test': 'foo', 'X-Test-Second': 'bar'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_header_empty(self):
         p = xmlrpclib.ServerProxy(URL, headers=[])
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1362,8 +1301,6 @@ def test_header_empty(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_header_tuple(self):
         p = xmlrpclib.ServerProxy(URL, headers=(('X-Test', 'foo'),))
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1371,8 +1308,6 @@ def test_header_tuple(self):
         headers = self.RequestHandler.test_headers
         self.assertContainsAdditionalHeaders(headers, {'X-Test': 'foo'})
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_header_items(self):
         p = xmlrpclib.ServerProxy(URL, headers={'X-Test': 'foo'}.items())
         self.assertEqual(p.pow(6, 8), 6**8)
@@ -1431,8 +1366,6 @@ def tearDown(self):
         default_class = http.client.HTTPMessage
         xmlrpc.server.SimpleXMLRPCRequestHandler.MessageClass = default_class
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_basic(self):
         # check that flag is false by default
         flagval = xmlrpc.server.SimpleXMLRPCServer._send_traceback_header
@@ -1527,8 +1460,6 @@ def test_cgi_get(self):
             self.assertEqual(message, 'Bad Request')
 
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_cgi_xmlrpc_response(self):
         data = """<?xml version='1.0'?>
         <methodCall>
@@ -1574,8 +1505,6 @@ def test_cgi_xmlrpc_response(self):
 
 class UseBuiltinTypesTestCase(unittest.TestCase):
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_use_builtin_types(self):
         # SimpleXMLRPCDispatcher.__init__ accepts use_builtin_types, which
         # makes all dispatch of binary data as bytes instances, and all
diff --git a/Lib/test/test_yield_from.py b/Lib/test/test_yield_from.py
index 97acfd5413..88fa1b88c9 100644
--- a/Lib/test/test_yield_from.py
+++ b/Lib/test/test_yield_from.py
@@ -538,8 +538,7 @@ def g():
             "finishing g",
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_broken_getattr_handling(self):
         """
         Test subiterator with a broken getattr implementation
@@ -787,8 +786,7 @@ def outer():
                 repr(value),
             ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_throwing_GeneratorExit_into_subgen_that_returns(self):
         """
         Test throwing GeneratorExit into a subgenerator that
@@ -819,8 +817,7 @@ def g():
             "Enter f",
         ])
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_throwing_GeneratorExit_into_subgenerator_that_yields(self):
         """
         Test throwing GeneratorExit into a subgenerator that
@@ -887,8 +884,7 @@ def g():
             yield from ()
         self.assertRaises(StopIteration, next, g())
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
+    @unittest.expectedFailure # TODO: RUSTPYTHON
     def test_delegating_generators_claim_to_be_running(self):
         # Check with basic iteration
         def one():
@@ -904,6 +900,7 @@ def two():
             yield 2
         g1 = one()
         self.assertEqual(list(g1), [0, 1, 2, 3])
+
         # Check with send
         g1 = one()
         res = [next(g1)]
@@ -913,6 +910,9 @@ def two():
         except StopIteration:
             pass
         self.assertEqual(res, [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):
             pass
@@ -949,8 +949,10 @@ def two():
         except:
             self.assertEqual(res, [0, 1, 2, 3])
             raise
+
+    def test_delegating_generators_claim_to_be_running_with_close(self):
         # Check with close
-        class MyIt(object):
+        class MyIt:
             def __iter__(self):
                 return self
             def __next__(self):
@@ -1057,6 +1059,538 @@ def outer():
         g.send((1, 2, 3, 4))
         self.assertEqual(v, (1, 2, 3, 4))
 
+class TestInterestingEdgeCases(unittest.TestCase):
+
+    def assert_stop_iteration(self, iterator):
+        with self.assertRaises(StopIteration) as caught:
+            next(iterator)
+        self.assertIsNone(caught.exception.value)
+        self.assertIsNone(caught.exception.__context__)
+
+    def assert_generator_raised_stop_iteration(self):
+        return self.assertRaisesRegex(RuntimeError, r"^generator raised StopIteration$")
+
+    def assert_generator_ignored_generator_exit(self):
+        return self.assertRaisesRegex(RuntimeError, r"^generator ignored GeneratorExit$")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_close_and_throw_work(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            yield yielded_first
+            yield yielded_second
+            return returned
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            g.close()
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = GeneratorExit()
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = StopIteration()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = BaseException()
+            with self.assertRaises(BaseException) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = Exception()
+            with self.assertRaises(Exception) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, thrown)
+            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()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+                yield yielded_second
+                return returned
+            finally:
+                raise raised
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = GeneratorExit()
+            # GeneratorExit is suppressed. This is consistent with PEP 342:
+            # https://peps.python.org/pep-0342/#new-generator-method-close
+            g.close()
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = GeneratorExit()
+            thrown = GeneratorExit()
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            # The raised GeneratorExit is suppressed, but the thrown one
+            # propagates. This is consistent with PEP 380:
+            # https://peps.python.org/pep-0380/#proposal
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = GeneratorExit()
+            thrown = StopIteration()
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = GeneratorExit()
+            thrown = BaseException()
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = GeneratorExit()
+            thrown = Exception()
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: RuntimeError not raised
+    def test_close_and_throw_raise_stop_iteration(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+                yield yielded_second
+                return returned
+            finally:
+                raise raised
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = StopIteration()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.close()
+            self.assertIs(caught.exception.__context__, raised)
+            self.assertIsInstance(caught.exception.__context__.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = StopIteration()
+            thrown = GeneratorExit()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.__context__, raised)
+            # This isn't the same GeneratorExit as thrown! It's the one created
+            # by calling inner.close():
+            self.assertIsInstance(caught.exception.__context__.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = StopIteration()
+            thrown = StopIteration()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.__context__, raised)
+            self.assertIs(caught.exception.__context__.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = StopIteration()
+            thrown = BaseException()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.__context__, raised)
+            self.assertIs(caught.exception.__context__.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = StopIteration()
+            thrown = Exception()
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.__context__, raised)
+            self.assertIs(caught.exception.__context__.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+    def test_close_and_throw_raise_base_exception(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+                yield yielded_second
+                return returned
+            finally:
+                raise raised
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = BaseException()
+            with self.assertRaises(BaseException) as caught:
+                g.close()
+            self.assertIs(caught.exception, raised)
+            self.assertIsInstance(caught.exception.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = BaseException()
+            thrown = GeneratorExit()
+            with self.assertRaises(BaseException) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            # This isn't the same GeneratorExit as thrown! It's the one created
+            # by calling inner.close():
+            self.assertIsInstance(caught.exception.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = BaseException()
+            thrown = StopIteration()
+            with self.assertRaises(BaseException) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = BaseException()
+            thrown = BaseException()
+            with self.assertRaises(BaseException) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = BaseException()
+            thrown = Exception()
+            with self.assertRaises(BaseException) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+    def test_close_and_throw_raise_exception(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+                yield yielded_second
+                return returned
+            finally:
+                raise raised
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = Exception()
+            with self.assertRaises(Exception) as caught:
+                g.close()
+            self.assertIs(caught.exception, raised)
+            self.assertIsInstance(caught.exception.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = Exception()
+            thrown = GeneratorExit()
+            with self.assertRaises(Exception) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            # This isn't the same GeneratorExit as thrown! It's the one created
+            # by calling inner.close():
+            self.assertIsInstance(caught.exception.__context__, GeneratorExit)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = Exception()
+            thrown = StopIteration()
+            with self.assertRaises(Exception) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = Exception()
+            thrown = BaseException()
+            with self.assertRaises(Exception) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            raised = Exception()
+            thrown = Exception()
+            with self.assertRaises(Exception) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, raised)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; AssertionError: None is not StopIteration()
+    def test_close_and_throw_yield(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+            finally:
+                yield yielded_second
+            return returned
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            # No chaining happens. This is consistent with PEP 342:
+            # https://peps.python.org/pep-0342/#new-generator-method-close
+            with self.assert_generator_ignored_generator_exit() as caught:
+                g.close()
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = GeneratorExit()
+            # No chaining happens. This is consistent with PEP 342:
+            # https://peps.python.org/pep-0342/#new-generator-method-close
+            with self.assert_generator_ignored_generator_exit() as caught:
+                g.throw(thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = StopIteration()
+            self.assertEqual(g.throw(thrown), yielded_second)
+            # PEP 479:
+            with self.assert_generator_raised_stop_iteration() as caught:
+                next(g)
+            self.assertIs(caught.exception.__context__, thrown)
+            self.assertIsNone(caught.exception.__context__.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = BaseException()
+            self.assertEqual(g.throw(thrown), yielded_second)
+            with self.assertRaises(BaseException) as caught:
+                next(g)
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = Exception()
+            self.assertEqual(g.throw(thrown), yielded_second)
+            with self.assertRaises(Exception) as caught:
+                next(g)
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_close_and_throw_return(self):
+
+        yielded_first = object()
+        yielded_second = object()
+        returned = object()
+
+        def inner():
+            try:
+                yield yielded_first
+                yield yielded_second
+            finally:
+                return returned
+
+        def outer():
+            return (yield from inner())
+
+        with self.subTest("close"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            # StopIteration is suppressed. This is consistent with PEP 342:
+            # https://peps.python.org/pep-0342/#new-generator-method-close
+            g.close()
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw GeneratorExit"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = GeneratorExit()
+            # StopIteration is suppressed. This is consistent with PEP 342:
+            # https://peps.python.org/pep-0342/#new-generator-method-close
+            with self.assertRaises(GeneratorExit) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception, thrown)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw StopIteration"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = StopIteration()
+            with self.assertRaises(StopIteration) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.value, returned)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw BaseException"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = BaseException()
+            with self.assertRaises(StopIteration) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.value, returned)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
+        with self.subTest("throw Exception"):
+            g = outer()
+            self.assertIs(next(g), yielded_first)
+            thrown = Exception()
+            with self.assertRaises(StopIteration) as caught:
+                g.throw(thrown)
+            self.assertIs(caught.exception.value, returned)
+            self.assertIsNone(caught.exception.__context__)
+            self.assert_stop_iteration(g)
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/Lib/test/test_zipapp.py b/Lib/test/test_zipapp.py
index 69f2e55d56..ad13283962 100644
--- a/Lib/test/test_zipapp.py
+++ b/Lib/test/test_zipapp.py
@@ -9,6 +9,7 @@
 import zipapp
 import zipfile
 from test.support import requires_zlib
+from test.support import os_helper
 
 from unittest.mock import patch
 
@@ -54,6 +55,22 @@ def test_create_archive_with_subdirs(self):
             self.assertIn('foo/', z.namelist())
             self.assertIn('bar/', z.namelist())
 
+    def test_create_sorted_archive(self):
+        # Test that zipapps order their files by name
+        source = self.tmpdir / 'source'
+        source.mkdir()
+        (source / 'zed.py').touch()
+        (source / 'bin').mkdir()
+        (source / 'bin' / 'qux').touch()
+        (source / 'bin' / 'baz').touch()
+        (source / '__main__.py').touch()
+        target = io.BytesIO()
+        zipapp.create_archive(str(source), target)
+        target.seek(0)
+        with zipfile.ZipFile(target, 'r') as zf:
+            self.assertEqual(zf.namelist(),
+                ["__main__.py", "bin/", "bin/baz", "bin/qux", "zed.py"])
+
     def test_create_archive_with_filter(self):
         # Test packing a directory and using filter to specify
         # which files to include.
@@ -72,6 +89,30 @@ def skip_pyc_files(path):
             self.assertIn('test.py', z.namelist())
             self.assertNotIn('test.pyc', z.namelist())
 
+    def test_create_archive_self_insertion(self):
+        # When creating an archive, we shouldn't
+        # include the archive in the list of files to add.
+        source = self.tmpdir
+        (source / '__main__.py').touch()
+        (source / 'test.py').touch()
+        target = self.tmpdir / 'target.pyz'
+
+        zipapp.create_archive(source, target)
+        with zipfile.ZipFile(target, 'r') as z:
+            self.assertEqual(len(z.namelist()), 2)
+            self.assertIn('__main__.py', z.namelist())
+            self.assertIn('test.py', z.namelist())
+
+    def test_target_overwrites_source_file(self):
+        # The target cannot be one of the files to add.
+        source = self.tmpdir
+        (source / '__main__.py').touch()
+        target = source / 'target.pyz'
+        target.touch()
+
+        with self.assertRaises(zipapp.ZipAppError):
+            zipapp.create_archive(source, target)
+
     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
@@ -248,14 +289,15 @@ def test_write_shebang_to_fileobj(self):
         zipapp.create_archive(str(target), new_target, interpreter='python2.7')
         self.assertTrue(new_target.getvalue().startswith(b'#!python2.7\n'))
 
-    def test_read_from_pathobj(self):
-        # Test that we can copy an archive using a pathlib.Path object
+    def test_read_from_pathlike_obj(self):
+        # Test that we can copy an archive using a path-like object
         # for the source.
         source = self.tmpdir / 'source'
         source.mkdir()
         (source / '__main__.py').touch()
-        target1 = self.tmpdir / 'target1.pyz'
-        target2 = self.tmpdir / 'target2.pyz'
+        source = os_helper.FakePath(str(source))
+        target1 = os_helper.FakePath(str(self.tmpdir / 'target1.pyz'))
+        target2 = os_helper.FakePath(str(self.tmpdir / 'target2.pyz'))
         zipapp.create_archive(source, target1, interpreter='python')
         zipapp.create_archive(target1, target2, interpreter='python2.7')
         self.assertEqual(zipapp.get_interpreter(target2), 'python2.7')
@@ -301,6 +343,7 @@ def test_content_of_copied_archive(self):
     # (Unix only) tests that archives with shebang lines are made executable
     @unittest.skipIf(sys.platform == 'win32',
                      'Windows does not support an executable bit')
+    @os_helper.skip_unless_working_chmod
     def test_shebang_is_executable(self):
         # Test that an archive with a shebang line is made executable.
         source = self.tmpdir / 'source'
diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile.py
deleted file mode 100644
index 43178ca26b..0000000000
--- a/Lib/test/test_zipfile.py
+++ /dev/null
@@ -1,3177 +0,0 @@
-import array
-import contextlib
-import importlib.util
-import io
-import itertools
-import os
-import pathlib
-import posixpath
-import string
-import struct
-import subprocess
-import sys
-import time
-import unittest
-import unittest.mock as mock
-import zipfile
-import functools
-
-
-from tempfile import TemporaryFile
-from random import randint, random, randbytes
-
-from test.support import script_helper
-from test.support import (findfile, requires_zlib, requires_bz2,
-                          requires_lzma, captured_stdout)
-from test.support.os_helper import TESTFN, unlink, rmtree, temp_dir, temp_cwd
-
-
-TESTFN2 = TESTFN + "2"
-TESTFNDIR = TESTFN + "d"
-FIXEDTEST_SIZE = 1000
-DATAFILES_DIR = 'zipfile_datafiles'
-
-SMALL_TEST_DATA = [('_ziptest1', '1q2w3e4r5t'),
-                   ('ziptest2dir/_ziptest2', 'qawsedrftg'),
-                   ('ziptest2dir/ziptest3dir/_ziptest3', 'azsxdcfvgb'),
-                   ('ziptest2dir/ziptest3dir/ziptest4dir/_ziptest3', '6y7u8i9o0p')]
-
-def get_files(test):
-    yield TESTFN2
-    with TemporaryFile() as f:
-        yield f
-        test.assertFalse(f.closed)
-    with io.BytesIO() as f:
-        yield f
-        test.assertFalse(f.closed)
-
-class AbstractTestsWithSourceFile:
-    @classmethod
-    def setUpClass(cls):
-        cls.line_gen = [bytes("Zipfile test line %d. random float: %f\n" %
-                              (i, random()), "ascii")
-                        for i in range(FIXEDTEST_SIZE)]
-        cls.data = b''.join(cls.line_gen)
-
-    def setUp(self):
-        # Make a source file with some lines
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-
-    def make_test_archive(self, f, compression, compresslevel=None):
-        kwargs = {'compression': compression, 'compresslevel': compresslevel}
-        # Create the ZIP archive
-        with zipfile.ZipFile(f, "w", **kwargs) as zipfp:
-            zipfp.write(TESTFN, "another.name")
-            zipfp.write(TESTFN, TESTFN)
-            zipfp.writestr("strfile", self.data)
-            with zipfp.open('written-open-w', mode='w') as f:
-                for line in self.line_gen:
-                    f.write(line)
-
-    def zip_test(self, f, compression, compresslevel=None):
-        self.make_test_archive(f, compression, compresslevel)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            self.assertEqual(zipfp.read(TESTFN), self.data)
-            self.assertEqual(zipfp.read("another.name"), self.data)
-            self.assertEqual(zipfp.read("strfile"), self.data)
-
-            # Print the ZIP directory
-            fp = io.StringIO()
-            zipfp.printdir(file=fp)
-            directory = fp.getvalue()
-            lines = directory.splitlines()
-            self.assertEqual(len(lines), 5) # Number of files + header
-
-            self.assertIn('File Name', lines[0])
-            self.assertIn('Modified', lines[0])
-            self.assertIn('Size', lines[0])
-
-            fn, date, time_, size = lines[1].split()
-            self.assertEqual(fn, 'another.name')
-            self.assertTrue(time.strptime(date, '%Y-%m-%d'))
-            self.assertTrue(time.strptime(time_, '%H:%M:%S'))
-            self.assertEqual(size, str(len(self.data)))
-
-            # Check the namelist
-            names = zipfp.namelist()
-            self.assertEqual(len(names), 4)
-            self.assertIn(TESTFN, names)
-            self.assertIn("another.name", names)
-            self.assertIn("strfile", names)
-            self.assertIn("written-open-w", names)
-
-            # Check infolist
-            infos = zipfp.infolist()
-            names = [i.filename for i in infos]
-            self.assertEqual(len(names), 4)
-            self.assertIn(TESTFN, names)
-            self.assertIn("another.name", names)
-            self.assertIn("strfile", names)
-            self.assertIn("written-open-w", names)
-            for i in infos:
-                self.assertEqual(i.file_size, len(self.data))
-
-            # check getinfo
-            for nm in (TESTFN, "another.name", "strfile", "written-open-w"):
-                info = zipfp.getinfo(nm)
-                self.assertEqual(info.filename, nm)
-                self.assertEqual(info.file_size, len(self.data))
-
-            # Check that testzip doesn't raise an exception
-            zipfp.testzip()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_basic(self):
-        for f in get_files(self):
-            self.zip_test(f, self.compression)
-
-    def zip_open_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            zipdata1 = []
-            with zipfp.open(TESTFN) as zipopen1:
-                while True:
-                    read_data = zipopen1.read(256)
-                    if not read_data:
-                        break
-                    zipdata1.append(read_data)
-
-            zipdata2 = []
-            with zipfp.open("another.name") as zipopen2:
-                while True:
-                    read_data = zipopen2.read(256)
-                    if not read_data:
-                        break
-                    zipdata2.append(read_data)
-
-            self.assertEqual(b''.join(zipdata1), self.data)
-            self.assertEqual(b''.join(zipdata2), self.data)
-
-    def test_open(self):
-        for f in get_files(self):
-            self.zip_open_test(f, self.compression)
-
-    def test_open_with_pathlike(self):
-        path = pathlib.Path(TESTFN2)
-        self.zip_open_test(path, self.compression)
-        with zipfile.ZipFile(path, "r", self.compression) as zipfp:
-            self.assertIsInstance(zipfp.filename, str)
-
-    def zip_random_open_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            zipdata1 = []
-            with zipfp.open(TESTFN) as zipopen1:
-                while True:
-                    read_data = zipopen1.read(randint(1, 1024))
-                    if not read_data:
-                        break
-                    zipdata1.append(read_data)
-
-            self.assertEqual(b''.join(zipdata1), self.data)
-
-    def test_random_open(self):
-        for f in get_files(self):
-            self.zip_random_open_test(f, self.compression)
-
-    def zip_read1_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp, \
-             zipfp.open(TESTFN) as zipopen:
-            zipdata = []
-            while True:
-                read_data = zipopen.read1(-1)
-                if not read_data:
-                    break
-                zipdata.append(read_data)
-
-        self.assertEqual(b''.join(zipdata), self.data)
-
-    def test_read1(self):
-        for f in get_files(self):
-            self.zip_read1_test(f, self.compression)
-
-    def zip_read1_10_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp, \
-             zipfp.open(TESTFN) as zipopen:
-            zipdata = []
-            while True:
-                read_data = zipopen.read1(10)
-                self.assertLessEqual(len(read_data), 10)
-                if not read_data:
-                    break
-                zipdata.append(read_data)
-
-        self.assertEqual(b''.join(zipdata), self.data)
-
-    def test_read1_10(self):
-        for f in get_files(self):
-            self.zip_read1_10_test(f, self.compression)
-
-    def zip_readline_read_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp, \
-             zipfp.open(TESTFN) as zipopen:
-            data = b''
-            while True:
-                read = zipopen.readline()
-                if not read:
-                    break
-                data += read
-
-                read = zipopen.read(100)
-                if not read:
-                    break
-                data += read
-
-        self.assertEqual(data, self.data)
-
-    def test_readline_read(self):
-        # Issue #7610: calls to readline() interleaved with calls to read().
-        for f in get_files(self):
-            self.zip_readline_read_test(f, self.compression)
-
-    def zip_readline_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp:
-            with zipfp.open(TESTFN) as zipopen:
-                for line in self.line_gen:
-                    linedata = zipopen.readline()
-                    self.assertEqual(linedata, line)
-
-    def test_readline(self):
-        for f in get_files(self):
-            self.zip_readline_test(f, self.compression)
-
-    def zip_readlines_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp:
-            with zipfp.open(TESTFN) as zipopen:
-                ziplines = zipopen.readlines()
-            for line, zipline in zip(self.line_gen, ziplines):
-                self.assertEqual(zipline, line)
-
-    def test_readlines(self):
-        for f in get_files(self):
-            self.zip_readlines_test(f, self.compression)
-
-    def zip_iterlines_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r") as zipfp:
-            with zipfp.open(TESTFN) as zipopen:
-                for line, zipline in zip(self.line_gen, zipopen):
-                    self.assertEqual(zipline, line)
-
-    def test_iterlines(self):
-        for f in get_files(self):
-            self.zip_iterlines_test(f, self.compression)
-
-    def test_low_compression(self):
-        """Check for cases where compressed data is larger than original."""
-        # Create the ZIP archive
-        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipfp:
-            zipfp.writestr("strfile", '12')
-
-        # Get an open object for strfile
-        with zipfile.ZipFile(TESTFN2, "r", self.compression) as zipfp:
-            with zipfp.open("strfile") as openobj:
-                self.assertEqual(openobj.read(1), b'1')
-                self.assertEqual(openobj.read(1), b'2')
-
-    def test_writestr_compression(self):
-        zipfp = zipfile.ZipFile(TESTFN2, "w")
-        zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
-        info = zipfp.getinfo('b.txt')
-        self.assertEqual(info.compress_type, self.compression)
-
-    def test_writestr_compresslevel(self):
-        zipfp = zipfile.ZipFile(TESTFN2, "w", compresslevel=1)
-        zipfp.writestr("a.txt", "hello world", compress_type=self.compression)
-        zipfp.writestr("b.txt", "hello world", compress_type=self.compression,
-                       compresslevel=2)
-
-        # Compression level follows the constructor.
-        a_info = zipfp.getinfo('a.txt')
-        self.assertEqual(a_info.compress_type, self.compression)
-        self.assertEqual(a_info._compresslevel, 1)
-
-        # Compression level is overridden.
-        b_info = zipfp.getinfo('b.txt')
-        self.assertEqual(b_info.compress_type, self.compression)
-        self.assertEqual(b_info._compresslevel, 2)
-
-    def test_read_return_size(self):
-        # Issue #9837: ZipExtFile.read() shouldn't return more bytes
-        # than requested.
-        for test_size in (1, 4095, 4096, 4097, 16384):
-            file_size = test_size + 1
-            junk = randbytes(file_size)
-            with zipfile.ZipFile(io.BytesIO(), "w", self.compression) as zipf:
-                zipf.writestr('foo', junk)
-                with zipf.open('foo', 'r') as fp:
-                    buf = fp.read(test_size)
-                    self.assertEqual(len(buf), test_size)
-
-    def test_truncated_zipfile(self):
-        fp = io.BytesIO()
-        with zipfile.ZipFile(fp, mode='w') as zipf:
-            zipf.writestr('strfile', self.data, compress_type=self.compression)
-            end_offset = fp.tell()
-        zipfiledata = fp.getvalue()
-
-        fp = io.BytesIO(zipfiledata)
-        with zipfile.ZipFile(fp) as zipf:
-            with zipf.open('strfile') as zipopen:
-                fp.truncate(end_offset - 20)
-                with self.assertRaises(EOFError):
-                    zipopen.read()
-
-        fp = io.BytesIO(zipfiledata)
-        with zipfile.ZipFile(fp) as zipf:
-            with zipf.open('strfile') as zipopen:
-                fp.truncate(end_offset - 20)
-                with self.assertRaises(EOFError):
-                    while zipopen.read(100):
-                        pass
-
-        fp = io.BytesIO(zipfiledata)
-        with zipfile.ZipFile(fp) as zipf:
-            with zipf.open('strfile') as zipopen:
-                fp.truncate(end_offset - 20)
-                with self.assertRaises(EOFError):
-                    while zipopen.read1(100):
-                        pass
-
-    def test_repr(self):
-        fname = 'file.name'
-        for f in get_files(self):
-            with zipfile.ZipFile(f, 'w', self.compression) as zipfp:
-                zipfp.write(TESTFN, fname)
-                r = repr(zipfp)
-                self.assertIn("mode='w'", r)
-
-            with zipfile.ZipFile(f, 'r') as zipfp:
-                r = repr(zipfp)
-                if isinstance(f, str):
-                    self.assertIn('filename=%r' % f, r)
-                else:
-                    self.assertIn('file=%r' % f, r)
-                self.assertIn("mode='r'", r)
-                r = repr(zipfp.getinfo(fname))
-                self.assertIn('filename=%r' % fname, r)
-                self.assertIn('filemode=', r)
-                self.assertIn('file_size=', r)
-                if self.compression != zipfile.ZIP_STORED:
-                    self.assertIn('compress_type=', r)
-                    self.assertIn('compress_size=', r)
-                with zipfp.open(fname) as zipopen:
-                    r = repr(zipopen)
-                    self.assertIn('name=%r' % fname, r)
-                    self.assertIn("mode='r'", r)
-                    if self.compression != zipfile.ZIP_STORED:
-                        self.assertIn('compress_type=', r)
-                self.assertIn('[closed]', repr(zipopen))
-            self.assertIn('[closed]', repr(zipfp))
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_compresslevel_basic(self):
-        for f in get_files(self):
-            self.zip_test(f, self.compression, compresslevel=9)
-
-    def test_per_file_compresslevel(self):
-        """Check that files within a Zip archive can have different
-        compression levels."""
-        with zipfile.ZipFile(TESTFN2, "w", compresslevel=1) as zipfp:
-            zipfp.write(TESTFN, 'compress_1')
-            zipfp.write(TESTFN, 'compress_9', compresslevel=9)
-            one_info = zipfp.getinfo('compress_1')
-            nine_info = zipfp.getinfo('compress_9')
-            self.assertEqual(one_info._compresslevel, 1)
-            self.assertEqual(nine_info._compresslevel, 9)
-
-    def test_writing_errors(self):
-        class BrokenFile(io.BytesIO):
-            def write(self, data):
-                nonlocal count
-                if count is not None:
-                    if count == stop:
-                        raise OSError
-                    count += 1
-                super().write(data)
-
-        stop = 0
-        while True:
-            testfile = BrokenFile()
-            count = None
-            with zipfile.ZipFile(testfile, 'w', self.compression) as zipfp:
-                with zipfp.open('file1', 'w') as f:
-                    f.write(b'data1')
-                count = 0
-                try:
-                    with zipfp.open('file2', 'w') as f:
-                        f.write(b'data2')
-                except OSError:
-                    stop += 1
-                else:
-                    break
-                finally:
-                    count = None
-            with zipfile.ZipFile(io.BytesIO(testfile.getvalue())) as zipfp:
-                self.assertEqual(zipfp.namelist(), ['file1'])
-                self.assertEqual(zipfp.read('file1'), b'data1')
-
-        with zipfile.ZipFile(io.BytesIO(testfile.getvalue())) as zipfp:
-            self.assertEqual(zipfp.namelist(), ['file1', 'file2'])
-            self.assertEqual(zipfp.read('file1'), b'data1')
-            self.assertEqual(zipfp.read('file2'), b'data2')
-
-
-    def tearDown(self):
-        unlink(TESTFN)
-        unlink(TESTFN2)
-
-
-class StoredTestsWithSourceFile(AbstractTestsWithSourceFile,
-                                unittest.TestCase):
-    compression = zipfile.ZIP_STORED
-    test_low_compression = None
-
-    def zip_test_writestr_permissions(self, f, compression):
-        # Make sure that writestr and open(... mode='w') create files with
-        # mode 0600, when they are passed a name rather than a ZipInfo
-        # instance.
-
-        self.make_test_archive(f, compression)
-        with zipfile.ZipFile(f, "r") as zipfp:
-            zinfo = zipfp.getinfo('strfile')
-            self.assertEqual(zinfo.external_attr, 0o600 << 16)
-
-            zinfo2 = zipfp.getinfo('written-open-w')
-            self.assertEqual(zinfo2.external_attr, 0o600 << 16)
-
-    def test_writestr_permissions(self):
-        for f in get_files(self):
-            self.zip_test_writestr_permissions(f, zipfile.ZIP_STORED)
-
-    def test_absolute_arcnames(self):
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            zipfp.write(TESTFN, "/absolute")
-
-        with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
-            self.assertEqual(zipfp.namelist(), ["absolute"])
-
-    def test_append_to_zip_file(self):
-        """Test appending to an existing zipfile."""
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            zipfp.write(TESTFN, TESTFN)
-
-        with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
-            zipfp.writestr("strfile", self.data)
-            self.assertEqual(zipfp.namelist(), [TESTFN, "strfile"])
-
-    def test_append_to_non_zip_file(self):
-        """Test appending to an existing file that is not a zipfile."""
-        # NOTE: this test fails if len(d) < 22 because of the first
-        # line "fpin.seek(-22, 2)" in _EndRecData
-        data = b'I am not a ZipFile!'*10
-        with open(TESTFN2, 'wb') as f:
-            f.write(data)
-
-        with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
-            zipfp.write(TESTFN, TESTFN)
-
-        with open(TESTFN2, 'rb') as f:
-            f.seek(len(data))
-            with zipfile.ZipFile(f, "r") as zipfp:
-                self.assertEqual(zipfp.namelist(), [TESTFN])
-                self.assertEqual(zipfp.read(TESTFN), self.data)
-        with open(TESTFN2, 'rb') as f:
-            self.assertEqual(f.read(len(data)), data)
-            zipfiledata = f.read()
-        with io.BytesIO(zipfiledata) as bio, zipfile.ZipFile(bio) as zipfp:
-            self.assertEqual(zipfp.namelist(), [TESTFN])
-            self.assertEqual(zipfp.read(TESTFN), self.data)
-
-    def test_read_concatenated_zip_file(self):
-        with io.BytesIO() as bio:
-            with zipfile.ZipFile(bio, 'w', zipfile.ZIP_STORED) as zipfp:
-                zipfp.write(TESTFN, TESTFN)
-            zipfiledata = bio.getvalue()
-        data = b'I am not a ZipFile!'*10
-        with open(TESTFN2, 'wb') as f:
-            f.write(data)
-            f.write(zipfiledata)
-
-        with zipfile.ZipFile(TESTFN2) as zipfp:
-            self.assertEqual(zipfp.namelist(), [TESTFN])
-            self.assertEqual(zipfp.read(TESTFN), self.data)
-
-    def test_append_to_concatenated_zip_file(self):
-        with io.BytesIO() as bio:
-            with zipfile.ZipFile(bio, 'w', zipfile.ZIP_STORED) as zipfp:
-                zipfp.write(TESTFN, TESTFN)
-            zipfiledata = bio.getvalue()
-        data = b'I am not a ZipFile!'*1000000
-        with open(TESTFN2, 'wb') as f:
-            f.write(data)
-            f.write(zipfiledata)
-
-        with zipfile.ZipFile(TESTFN2, 'a') as zipfp:
-            self.assertEqual(zipfp.namelist(), [TESTFN])
-            zipfp.writestr('strfile', self.data)
-
-        with open(TESTFN2, 'rb') as f:
-            self.assertEqual(f.read(len(data)), data)
-            zipfiledata = f.read()
-        with io.BytesIO(zipfiledata) as bio, zipfile.ZipFile(bio) as zipfp:
-            self.assertEqual(zipfp.namelist(), [TESTFN, 'strfile'])
-            self.assertEqual(zipfp.read(TESTFN), self.data)
-            self.assertEqual(zipfp.read('strfile'), self.data)
-
-    def test_ignores_newline_at_end(self):
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            zipfp.write(TESTFN, TESTFN)
-        with open(TESTFN2, 'a', encoding='utf-8') as f:
-            f.write("\r\n\00\00\00")
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            self.assertIsInstance(zipfp, zipfile.ZipFile)
-
-    def test_ignores_stuff_appended_past_comments(self):
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            zipfp.comment = b"this is a comment"
-            zipfp.write(TESTFN, TESTFN)
-        with open(TESTFN2, 'a', encoding='utf-8') as f:
-            f.write("abcdef\r\n")
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            self.assertIsInstance(zipfp, zipfile.ZipFile)
-            self.assertEqual(zipfp.comment, b"this is a comment")
-
-    def test_write_default_name(self):
-        """Check that calling ZipFile.write without arcname specified
-        produces the expected result."""
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            zipfp.write(TESTFN)
-            with open(TESTFN, "rb") as f:
-                self.assertEqual(zipfp.read(TESTFN), f.read())
-
-    def test_io_on_closed_zipextfile(self):
-        fname = "somefile.txt"
-        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
-            zipfp.writestr(fname, "bogus")
-
-        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
-            with zipfp.open(fname) as fid:
-                fid.close()
-                self.assertRaises(ValueError, fid.read)
-                self.assertRaises(ValueError, fid.seek, 0)
-                self.assertRaises(ValueError, fid.tell)
-                self.assertRaises(ValueError, fid.readable)
-                self.assertRaises(ValueError, fid.seekable)
-
-    def test_write_to_readonly(self):
-        """Check that trying to call write() on a readonly ZipFile object
-        raises a ValueError."""
-        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
-            zipfp.writestr("somefile.txt", "bogus")
-
-        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
-            self.assertRaises(ValueError, zipfp.write, TESTFN)
-
-        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
-            with self.assertRaises(ValueError):
-                zipfp.open(TESTFN, mode='w')
-
-    def test_add_file_before_1980(self):
-        # Set atime and mtime to 1970-01-01
-        os.utime(TESTFN, (0, 0))
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            self.assertRaises(ValueError, zipfp.write, TESTFN)
-
-        with zipfile.ZipFile(TESTFN2, "w", strict_timestamps=False) as zipfp:
-            zipfp.write(TESTFN)
-            zinfo = zipfp.getinfo(TESTFN)
-            self.assertEqual(zinfo.date_time, (1980, 1, 1, 0, 0, 0))
-
-    def test_add_file_after_2107(self):
-        # Set atime and mtime to 2108-12-30
-        ts = 4386268800
-        try:
-            time.localtime(ts)
-        except OverflowError:
-            self.skipTest(f'time.localtime({ts}) raises OverflowError')
-        try:
-            os.utime(TESTFN, (ts, ts))
-        except OverflowError:
-            self.skipTest('Host fs cannot set timestamp to required value.')
-
-        mtime_ns = os.stat(TESTFN).st_mtime_ns
-        if mtime_ns != (4386268800 * 10**9):
-            # XFS filesystem is limited to 32-bit timestamp, but the syscall
-            # didn't fail. Moreover, there is a VFS bug which returns
-            # a cached timestamp which is different than the value on disk.
-            #
-            # Test st_mtime_ns rather than st_mtime to avoid rounding issues.
-            #
-            # https://bugzilla.redhat.com/show_bug.cgi?id=1795576
-            # https://bugs.python.org/issue39460#msg360952
-            self.skipTest(f"Linux VFS/XFS kernel bug detected: {mtime_ns=}")
-
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            self.assertRaises(struct.error, zipfp.write, TESTFN)
-
-        with zipfile.ZipFile(TESTFN2, "w", strict_timestamps=False) as zipfp:
-            zipfp.write(TESTFN)
-            zinfo = zipfp.getinfo(TESTFN)
-            self.assertEqual(zinfo.date_time, (2107, 12, 31, 23, 59, 59))
-
-
-@requires_zlib()
-class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile,
-                                 unittest.TestCase):
-    compression = zipfile.ZIP_DEFLATED
-
-    def test_per_file_compression(self):
-        """Check that files within a Zip archive can have different
-        compression options."""
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            zipfp.write(TESTFN, 'storeme', zipfile.ZIP_STORED)
-            zipfp.write(TESTFN, 'deflateme', zipfile.ZIP_DEFLATED)
-            sinfo = zipfp.getinfo('storeme')
-            dinfo = zipfp.getinfo('deflateme')
-            self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
-            self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
-
-@requires_bz2()
-class Bzip2TestsWithSourceFile(AbstractTestsWithSourceFile,
-                               unittest.TestCase):
-    compression = zipfile.ZIP_BZIP2
-
-@requires_lzma()
-class LzmaTestsWithSourceFile(AbstractTestsWithSourceFile,
-                              unittest.TestCase):
-    compression = zipfile.ZIP_LZMA
-
-
-class AbstractTestZip64InSmallFiles:
-    # These tests test the ZIP64 functionality without using large files,
-    # see test_zipfile64 for proper tests.
-
-    @classmethod
-    def setUpClass(cls):
-        line_gen = (bytes("Test of zipfile line %d." % i, "ascii")
-                    for i in range(0, FIXEDTEST_SIZE))
-        cls.data = b'\n'.join(line_gen)
-
-    def setUp(self):
-        self._limit = zipfile.ZIP64_LIMIT
-        self._filecount_limit = zipfile.ZIP_FILECOUNT_LIMIT
-        zipfile.ZIP64_LIMIT = 1000
-        zipfile.ZIP_FILECOUNT_LIMIT = 9
-
-        # Make a source file with some lines
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-
-    def zip_test(self, f, compression):
-        # Create the ZIP archive
-        with zipfile.ZipFile(f, "w", compression, allowZip64=True) as zipfp:
-            zipfp.write(TESTFN, "another.name")
-            zipfp.write(TESTFN, TESTFN)
-            zipfp.writestr("strfile", self.data)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            self.assertEqual(zipfp.read(TESTFN), self.data)
-            self.assertEqual(zipfp.read("another.name"), self.data)
-            self.assertEqual(zipfp.read("strfile"), self.data)
-
-            # Print the ZIP directory
-            fp = io.StringIO()
-            zipfp.printdir(fp)
-
-            directory = fp.getvalue()
-            lines = directory.splitlines()
-            self.assertEqual(len(lines), 4) # Number of files + header
-
-            self.assertIn('File Name', lines[0])
-            self.assertIn('Modified', lines[0])
-            self.assertIn('Size', lines[0])
-
-            fn, date, time_, size = lines[1].split()
-            self.assertEqual(fn, 'another.name')
-            self.assertTrue(time.strptime(date, '%Y-%m-%d'))
-            self.assertTrue(time.strptime(time_, '%H:%M:%S'))
-            self.assertEqual(size, str(len(self.data)))
-
-            # Check the namelist
-            names = zipfp.namelist()
-            self.assertEqual(len(names), 3)
-            self.assertIn(TESTFN, names)
-            self.assertIn("another.name", names)
-            self.assertIn("strfile", names)
-
-            # Check infolist
-            infos = zipfp.infolist()
-            names = [i.filename for i in infos]
-            self.assertEqual(len(names), 3)
-            self.assertIn(TESTFN, names)
-            self.assertIn("another.name", names)
-            self.assertIn("strfile", names)
-            for i in infos:
-                self.assertEqual(i.file_size, len(self.data))
-
-            # check getinfo
-            for nm in (TESTFN, "another.name", "strfile"):
-                info = zipfp.getinfo(nm)
-                self.assertEqual(info.filename, nm)
-                self.assertEqual(info.file_size, len(self.data))
-
-            # Check that testzip doesn't raise an exception
-            zipfp.testzip()
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_basic(self):
-        for f in get_files(self):
-            self.zip_test(f, self.compression)
-
-    def test_too_many_files(self):
-        # This test checks that more than 64k files can be added to an archive,
-        # and that the resulting archive can be read properly by ZipFile
-        zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
-                               allowZip64=True)
-        zipf.debug = 100
-        numfiles = 15
-        for i in range(numfiles):
-            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        zipf.close()
-
-        zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
-        self.assertEqual(len(zipf2.namelist()), numfiles)
-        for i in range(numfiles):
-            content = zipf2.read("foo%08d" % i).decode('ascii')
-            self.assertEqual(content, "%d" % (i**3 % 57))
-        zipf2.close()
-
-    def test_too_many_files_append(self):
-        zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
-                               allowZip64=False)
-        zipf.debug = 100
-        numfiles = 9
-        for i in range(numfiles):
-            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        with self.assertRaises(zipfile.LargeZipFile):
-            zipf.writestr("foo%08d" % numfiles, b'')
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        zipf.close()
-
-        zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
-                               allowZip64=False)
-        zipf.debug = 100
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        with self.assertRaises(zipfile.LargeZipFile):
-            zipf.writestr("foo%08d" % numfiles, b'')
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        zipf.close()
-
-        zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
-                               allowZip64=True)
-        zipf.debug = 100
-        self.assertEqual(len(zipf.namelist()), numfiles)
-        numfiles2 = 15
-        for i in range(numfiles, numfiles2):
-            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
-        self.assertEqual(len(zipf.namelist()), numfiles2)
-        zipf.close()
-
-        zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
-        self.assertEqual(len(zipf2.namelist()), numfiles2)
-        for i in range(numfiles2):
-            content = zipf2.read("foo%08d" % i).decode('ascii')
-            self.assertEqual(content, "%d" % (i**3 % 57))
-        zipf2.close()
-
-    def tearDown(self):
-        zipfile.ZIP64_LIMIT = self._limit
-        zipfile.ZIP_FILECOUNT_LIMIT = self._filecount_limit
-        unlink(TESTFN)
-        unlink(TESTFN2)
-
-
-class StoredTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
-                                  unittest.TestCase):
-    compression = zipfile.ZIP_STORED
-
-    def large_file_exception_test(self, f, compression):
-        with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
-            self.assertRaises(zipfile.LargeZipFile,
-                              zipfp.write, TESTFN, "another.name")
-
-    def large_file_exception_test2(self, f, compression):
-        with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
-            self.assertRaises(zipfile.LargeZipFile,
-                              zipfp.writestr, "another.name", self.data)
-
-    def test_large_file_exception(self):
-        for f in get_files(self):
-            self.large_file_exception_test(f, zipfile.ZIP_STORED)
-            self.large_file_exception_test2(f, zipfile.ZIP_STORED)
-
-    def test_absolute_arcnames(self):
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED,
-                             allowZip64=True) as zipfp:
-            zipfp.write(TESTFN, "/absolute")
-
-        with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
-            self.assertEqual(zipfp.namelist(), ["absolute"])
-
-    def test_append(self):
-        # Test that appending to the Zip64 archive doesn't change
-        # extra fields of existing entries.
-        with zipfile.ZipFile(TESTFN2, "w", allowZip64=True) as zipfp:
-            zipfp.writestr("strfile", self.data)
-        with zipfile.ZipFile(TESTFN2, "r", allowZip64=True) as zipfp:
-            zinfo = zipfp.getinfo("strfile")
-            extra = zinfo.extra
-        with zipfile.ZipFile(TESTFN2, "a", allowZip64=True) as zipfp:
-            zipfp.writestr("strfile2", self.data)
-        with zipfile.ZipFile(TESTFN2, "r", allowZip64=True) as zipfp:
-            zinfo = zipfp.getinfo("strfile")
-            self.assertEqual(zinfo.extra, extra)
-
-    def make_zip64_file(
-        self, file_size_64_set=False, file_size_extra=False,
-        compress_size_64_set=False, compress_size_extra=False,
-        header_offset_64_set=False, header_offset_extra=False,
-    ):
-        """Generate bytes sequence for a zip with (incomplete) zip64 data.
-
-        The actual values (not the zip 64 0xffffffff values) stored in the file
-        are:
-        file_size: 8
-        compress_size: 8
-        header_offset: 0
-        """
-        actual_size = 8
-        actual_header_offset = 0
-        local_zip64_fields = []
-        central_zip64_fields = []
-
-        file_size = actual_size
-        if file_size_64_set:
-            file_size = 0xffffffff
-            if file_size_extra:
-                local_zip64_fields.append(actual_size)
-                central_zip64_fields.append(actual_size)
-        file_size = struct.pack("<L", file_size)
-
-        compress_size = actual_size
-        if compress_size_64_set:
-            compress_size = 0xffffffff
-            if compress_size_extra:
-                local_zip64_fields.append(actual_size)
-                central_zip64_fields.append(actual_size)
-        compress_size = struct.pack("<L", compress_size)
-
-        header_offset = actual_header_offset
-        if header_offset_64_set:
-            header_offset = 0xffffffff
-            if header_offset_extra:
-                central_zip64_fields.append(actual_header_offset)
-        header_offset = struct.pack("<L", header_offset)
-
-        local_extra = struct.pack(
-            '<HH' + 'Q'*len(local_zip64_fields),
-            0x0001,
-            8*len(local_zip64_fields),
-            *local_zip64_fields
-        )
-
-        central_extra = struct.pack(
-            '<HH' + 'Q'*len(central_zip64_fields),
-            0x0001,
-            8*len(central_zip64_fields),
-            *central_zip64_fields
-        )
-
-        central_dir_size = struct.pack('<Q', 58 + 8 * len(central_zip64_fields))
-        offset_to_central_dir = struct.pack('<Q', 50 + 8 * len(local_zip64_fields))
-
-        local_extra_length = struct.pack("<H", 4 + 8 * len(local_zip64_fields))
-        central_extra_length = struct.pack("<H", 4 + 8 * len(central_zip64_fields))
-
-        filename = b"test.txt"
-        content = b"test1234"
-        filename_length = struct.pack("<H", len(filename))
-        zip64_contents = (
-            # Local file header
-            b"PK\x03\x04\x14\x00\x00\x00\x00\x00\x00\x00!\x00\x9e%\xf5\xaf"
-            + compress_size
-            + file_size
-            + filename_length
-            + local_extra_length
-            + filename
-            + local_extra
-            + content
-            # Central directory:
-            + b"PK\x01\x02-\x03-\x00\x00\x00\x00\x00\x00\x00!\x00\x9e%\xf5\xaf"
-            + compress_size
-            + file_size
-            + filename_length
-            + central_extra_length
-            + b"\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01"
-            + header_offset
-            + filename
-            + central_extra
-            # Zip64 end of central directory
-            + b"PK\x06\x06,\x00\x00\x00\x00\x00\x00\x00-\x00-"
-            + b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00"
-            + b"\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
-            + central_dir_size
-            + offset_to_central_dir
-            # Zip64 end of central directory locator
-            + b"PK\x06\x07\x00\x00\x00\x00l\x00\x00\x00\x00\x00\x00\x00\x01"
-            + b"\x00\x00\x00"
-            # end of central directory
-            + b"PK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00:\x00\x00\x002\x00"
-            + b"\x00\x00\x00\x00"
-        )
-        return zip64_contents
-
-    def test_bad_zip64_extra(self):
-        """Missing zip64 extra records raises an exception.
-
-        There are 4 fields that the zip64 format handles (the disk number is
-        not used in this module and so is ignored here). According to the zip
-        spec:
-              The order of the fields in the zip64 extended
-              information record is fixed, but the fields MUST
-              only appear if the corresponding Local or Central
-              directory record field is set to 0xFFFF or 0xFFFFFFFF.
-
-        If the zip64 extra content doesn't contain enough entries for the
-        number of fields marked with 0xFFFF or 0xFFFFFFFF, we raise an error.
-        This test mismatches the length of the zip64 extra field and the number
-        of fields set to indicate the presence of zip64 data.
-        """
-        # zip64 file size present, no fields in extra, expecting one, equals
-        # missing file size.
-        missing_file_size_extra = self.make_zip64_file(
-            file_size_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_file_size_extra))
-        self.assertIn('file size', str(e.exception).lower())
-
-        # zip64 file size present, zip64 compress size present, one field in
-        # extra, expecting two, equals missing compress size.
-        missing_compress_size_extra = self.make_zip64_file(
-            file_size_64_set=True,
-            file_size_extra=True,
-            compress_size_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
-        self.assertIn('compress size', str(e.exception).lower())
-
-        # zip64 compress size present, no fields in extra, expecting one,
-        # equals missing compress size.
-        missing_compress_size_extra = self.make_zip64_file(
-            compress_size_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
-        self.assertIn('compress size', str(e.exception).lower())
-
-        # zip64 file size present, zip64 compress size present, zip64 header
-        # offset present, two fields in extra, expecting three, equals missing
-        # header offset
-        missing_header_offset_extra = self.make_zip64_file(
-            file_size_64_set=True,
-            file_size_extra=True,
-            compress_size_64_set=True,
-            compress_size_extra=True,
-            header_offset_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
-        self.assertIn('header offset', str(e.exception).lower())
-
-        # zip64 compress size present, zip64 header offset present, one field
-        # in extra, expecting two, equals missing header offset
-        missing_header_offset_extra = self.make_zip64_file(
-            file_size_64_set=False,
-            compress_size_64_set=True,
-            compress_size_extra=True,
-            header_offset_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
-        self.assertIn('header offset', str(e.exception).lower())
-
-        # zip64 file size present, zip64 header offset present, one field in
-        # extra, expecting two, equals missing header offset
-        missing_header_offset_extra = self.make_zip64_file(
-            file_size_64_set=True,
-            file_size_extra=True,
-            compress_size_64_set=False,
-            header_offset_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
-        self.assertIn('header offset', str(e.exception).lower())
-
-        # zip64 header offset present, no fields in extra, expecting one,
-        # equals missing header offset
-        missing_header_offset_extra = self.make_zip64_file(
-            file_size_64_set=False,
-            compress_size_64_set=False,
-            header_offset_64_set=True,
-        )
-        with self.assertRaises(zipfile.BadZipFile) as e:
-            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
-        self.assertIn('header offset', str(e.exception).lower())
-
-    def test_generated_valid_zip64_extra(self):
-        # These values are what is set in the make_zip64_file method.
-        expected_file_size = 8
-        expected_compress_size = 8
-        expected_header_offset = 0
-        expected_content = b"test1234"
-
-        # Loop through the various valid combinations of zip64 masks
-        # present and extra fields present.
-        params = (
-            {"file_size_64_set": True, "file_size_extra": True},
-            {"compress_size_64_set": True, "compress_size_extra": True},
-            {"header_offset_64_set": True, "header_offset_extra": True},
-        )
-
-        for r in range(1, len(params) + 1):
-            for combo in itertools.combinations(params, r):
-                kwargs = {}
-                for c in combo:
-                    kwargs.update(c)
-                with zipfile.ZipFile(io.BytesIO(self.make_zip64_file(**kwargs))) as zf:
-                    zinfo = zf.infolist()[0]
-                    self.assertEqual(zinfo.file_size, expected_file_size)
-                    self.assertEqual(zinfo.compress_size, expected_compress_size)
-                    self.assertEqual(zinfo.header_offset, expected_header_offset)
-                    self.assertEqual(zf.read(zinfo), expected_content)
-
-
-@requires_zlib()
-class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
-                                   unittest.TestCase):
-    compression = zipfile.ZIP_DEFLATED
-
-@requires_bz2()
-class Bzip2TestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
-                                 unittest.TestCase):
-    compression = zipfile.ZIP_BZIP2
-
-@requires_lzma()
-class LzmaTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
-                                unittest.TestCase):
-    compression = zipfile.ZIP_LZMA
-
-
-class AbstractWriterTests:
-
-    def tearDown(self):
-        unlink(TESTFN2)
-
-    def test_close_after_close(self):
-        data = b'content'
-        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
-            w = zipf.open('test', 'w')
-            w.write(data)
-            w.close()
-            self.assertTrue(w.closed)
-            w.close()
-            self.assertTrue(w.closed)
-            self.assertEqual(zipf.read('test'), data)
-
-    def test_write_after_close(self):
-        data = b'content'
-        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
-            w = zipf.open('test', 'w')
-            w.write(data)
-            w.close()
-            self.assertTrue(w.closed)
-            self.assertRaises(ValueError, w.write, b'')
-            self.assertEqual(zipf.read('test'), data)
-
-    def test_issue44439(self):
-        q = array.array('Q', [1, 2, 3, 4, 5])
-        LENGTH = len(q) * q.itemsize
-        with zipfile.ZipFile(io.BytesIO(), 'w', self.compression) as zip:
-            with zip.open('data', 'w') as data:
-                self.assertEqual(data.write(q), LENGTH)
-            self.assertEqual(zip.getinfo('data').file_size, LENGTH)
-
-class StoredWriterTests(AbstractWriterTests, unittest.TestCase):
-    compression = zipfile.ZIP_STORED
-
-@requires_zlib()
-class DeflateWriterTests(AbstractWriterTests, unittest.TestCase):
-    compression = zipfile.ZIP_DEFLATED
-
-@requires_bz2()
-class Bzip2WriterTests(AbstractWriterTests, unittest.TestCase):
-    compression = zipfile.ZIP_BZIP2
-
-@requires_lzma()
-class LzmaWriterTests(AbstractWriterTests, unittest.TestCase):
-    compression = zipfile.ZIP_LZMA
-
-
-class PyZipFileTests(unittest.TestCase):
-    def assertCompiledIn(self, name, namelist):
-        if name + 'o' not in namelist:
-            self.assertIn(name + 'c', namelist)
-
-    def requiresWriteAccess(self, path):
-        # effective_ids unavailable on windows
-        if not os.access(path, os.W_OK,
-                         effective_ids=os.access in os.supports_effective_ids):
-            self.skipTest('requires write access to the installed location')
-        filename = os.path.join(path, 'test_zipfile.try')
-        try:
-            fd = os.open(filename, os.O_WRONLY | os.O_CREAT)
-            os.close(fd)
-        except Exception:
-            self.skipTest('requires write access to the installed location')
-        unlink(filename)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_write_pyfile(self):
-        self.requiresWriteAccess(os.path.dirname(__file__))
-        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-            fn = __file__
-            if fn.endswith('.pyc'):
-                path_split = fn.split(os.sep)
-                if os.altsep is not None:
-                    path_split.extend(fn.split(os.altsep))
-                if '__pycache__' in path_split:
-                    fn = importlib.util.source_from_cache(fn)
-                else:
-                    fn = fn[:-1]
-
-            zipfp.writepy(fn)
-
-            bn = os.path.basename(fn)
-            self.assertNotIn(bn, zipfp.namelist())
-            self.assertCompiledIn(bn, zipfp.namelist())
-
-        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-            fn = __file__
-            if fn.endswith('.pyc'):
-                fn = fn[:-1]
-
-            zipfp.writepy(fn, "testpackage")
-
-            bn = "%s/%s" % ("testpackage", os.path.basename(fn))
-            self.assertNotIn(bn, zipfp.namelist())
-            self.assertCompiledIn(bn, zipfp.namelist())
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_write_python_package(self):
-        import email
-        packagedir = os.path.dirname(email.__file__)
-        self.requiresWriteAccess(packagedir)
-
-        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-            zipfp.writepy(packagedir)
-
-            # Check for a couple of modules at different levels of the
-            # hierarchy
-            names = zipfp.namelist()
-            self.assertCompiledIn('email/__init__.py', names)
-            self.assertCompiledIn('email/mime/text.py', names)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_write_filtered_python_package(self):
-        import test
-        packagedir = os.path.dirname(test.__file__)
-        self.requiresWriteAccess(packagedir)
-
-        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-
-            # first make sure that the test folder gives error messages
-            # (on the badsyntax_... files)
-            with captured_stdout() as reportSIO:
-                zipfp.writepy(packagedir)
-            reportStr = reportSIO.getvalue()
-            self.assertTrue('SyntaxError' in reportStr)
-
-            # then check that the filter works on the whole package
-            with captured_stdout() as reportSIO:
-                zipfp.writepy(packagedir, filterfunc=lambda whatever: False)
-            reportStr = reportSIO.getvalue()
-            self.assertTrue('SyntaxError' not in reportStr)
-
-            # then check that the filter works on individual files
-            def filter(path):
-                return not os.path.basename(path).startswith("bad")
-            with captured_stdout() as reportSIO, self.assertWarns(UserWarning):
-                zipfp.writepy(packagedir, filterfunc=filter)
-            reportStr = reportSIO.getvalue()
-            if reportStr:
-                print(reportStr)
-            self.assertTrue('SyntaxError' not in reportStr)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_write_with_optimization(self):
-        import email
-        packagedir = os.path.dirname(email.__file__)
-        self.requiresWriteAccess(packagedir)
-        optlevel = 1 if __debug__ else 0
-        ext = '.pyc'
-
-        with TemporaryFile() as t, \
-             zipfile.PyZipFile(t, "w", optimize=optlevel) as zipfp:
-            zipfp.writepy(packagedir)
-
-            names = zipfp.namelist()
-            self.assertIn('email/__init__' + ext, names)
-            self.assertIn('email/mime/text' + ext, names)
-
-    def test_write_python_directory(self):
-        os.mkdir(TESTFN2)
-        try:
-            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
-                fp.write("print(42)\n")
-
-            with open(os.path.join(TESTFN2, "mod2.py"), "w", encoding='utf-8') as fp:
-                fp.write("print(42 * 42)\n")
-
-            with open(os.path.join(TESTFN2, "mod2.txt"), "w", encoding='utf-8') as fp:
-                fp.write("bla bla bla\n")
-
-            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-                zipfp.writepy(TESTFN2)
-
-                names = zipfp.namelist()
-                self.assertCompiledIn('mod1.py', names)
-                self.assertCompiledIn('mod2.py', names)
-                self.assertNotIn('mod2.txt', names)
-
-        finally:
-            rmtree(TESTFN2)
-
-    def test_write_python_directory_filtered(self):
-        os.mkdir(TESTFN2)
-        try:
-            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
-                fp.write("print(42)\n")
-
-            with open(os.path.join(TESTFN2, "mod2.py"), "w", encoding='utf-8') as fp:
-                fp.write("print(42 * 42)\n")
-
-            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-                zipfp.writepy(TESTFN2, filterfunc=lambda fn:
-                                                  not fn.endswith('mod2.py'))
-
-                names = zipfp.namelist()
-                self.assertCompiledIn('mod1.py', names)
-                self.assertNotIn('mod2.py', names)
-
-        finally:
-            rmtree(TESTFN2)
-
-    def test_write_non_pyfile(self):
-        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-            with open(TESTFN, 'w', encoding='utf-8') as f:
-                f.write('most definitely not a python file')
-            self.assertRaises(RuntimeError, zipfp.writepy, TESTFN)
-            unlink(TESTFN)
-
-    def test_write_pyfile_bad_syntax(self):
-        os.mkdir(TESTFN2)
-        try:
-            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
-                fp.write("Bad syntax in python file\n")
-
-            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-                # syntax errors are printed to stdout
-                with captured_stdout() as s:
-                    zipfp.writepy(os.path.join(TESTFN2, "mod1.py"))
-
-                self.assertIn("SyntaxError", s.getvalue())
-
-                # as it will not have compiled the python file, it will
-                # include the .py file not .pyc
-                names = zipfp.namelist()
-                self.assertIn('mod1.py', names)
-                self.assertNotIn('mod1.pyc', names)
-
-        finally:
-            rmtree(TESTFN2)
-
-    def test_write_pathlike(self):
-        os.mkdir(TESTFN2)
-        try:
-            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
-                fp.write("print(42)\n")
-
-            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
-                zipfp.writepy(pathlib.Path(TESTFN2) / "mod1.py")
-                names = zipfp.namelist()
-                self.assertCompiledIn('mod1.py', names)
-        finally:
-            rmtree(TESTFN2)
-
-
-class ExtractTests(unittest.TestCase):
-
-    def make_test_file(self):
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            for fpath, fdata in SMALL_TEST_DATA:
-                zipfp.writestr(fpath, fdata)
-
-    def test_extract(self):
-        with temp_cwd():
-            self.make_test_file()
-            with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-                for fpath, fdata in SMALL_TEST_DATA:
-                    writtenfile = zipfp.extract(fpath)
-
-                    # make sure it was written to the right place
-                    correctfile = os.path.join(os.getcwd(), fpath)
-                    correctfile = os.path.normpath(correctfile)
-
-                    self.assertEqual(writtenfile, correctfile)
-
-                    # make sure correct data is in correct file
-                    with open(writtenfile, "rb") as f:
-                        self.assertEqual(fdata.encode(), f.read())
-
-                    unlink(writtenfile)
-
-    def _test_extract_with_target(self, target):
-        self.make_test_file()
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            for fpath, fdata in SMALL_TEST_DATA:
-                writtenfile = zipfp.extract(fpath, target)
-
-                # make sure it was written to the right place
-                correctfile = os.path.join(target, fpath)
-                correctfile = os.path.normpath(correctfile)
-                self.assertTrue(os.path.samefile(writtenfile, correctfile), (writtenfile, target))
-
-                # make sure correct data is in correct file
-                with open(writtenfile, "rb") as f:
-                    self.assertEqual(fdata.encode(), f.read())
-
-                unlink(writtenfile)
-
-        unlink(TESTFN2)
-
-    def test_extract_with_target(self):
-        with temp_dir() as extdir:
-            self._test_extract_with_target(extdir)
-
-    def test_extract_with_target_pathlike(self):
-        with temp_dir() as extdir:
-            self._test_extract_with_target(pathlib.Path(extdir))
-
-    def test_extract_all(self):
-        with temp_cwd():
-            self.make_test_file()
-            with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-                zipfp.extractall()
-                for fpath, fdata in SMALL_TEST_DATA:
-                    outfile = os.path.join(os.getcwd(), fpath)
-
-                    with open(outfile, "rb") as f:
-                        self.assertEqual(fdata.encode(), f.read())
-
-                    unlink(outfile)
-
-    def _test_extract_all_with_target(self, target):
-        self.make_test_file()
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            zipfp.extractall(target)
-            for fpath, fdata in SMALL_TEST_DATA:
-                outfile = os.path.join(target, fpath)
-
-                with open(outfile, "rb") as f:
-                    self.assertEqual(fdata.encode(), f.read())
-
-                unlink(outfile)
-
-        unlink(TESTFN2)
-
-    def test_extract_all_with_target(self):
-        with temp_dir() as extdir:
-            self._test_extract_all_with_target(extdir)
-
-    def test_extract_all_with_target_pathlike(self):
-        with temp_dir() as extdir:
-            self._test_extract_all_with_target(pathlib.Path(extdir))
-
-    def check_file(self, filename, content):
-        self.assertTrue(os.path.isfile(filename))
-        with open(filename, 'rb') as f:
-            self.assertEqual(f.read(), content)
-
-    def test_sanitize_windows_name(self):
-        san = zipfile.ZipFile._sanitize_windows_name
-        # Passing pathsep in allows this test to work regardless of platform.
-        self.assertEqual(san(r',,?,C:,foo,bar/z', ','), r'_,C_,foo,bar/z')
-        self.assertEqual(san(r'a\b,c<d>e|f"g?h*i', ','), r'a\b,c_d_e_f_g_h_i')
-        self.assertEqual(san('../../foo../../ba..r', '/'), r'foo/ba..r')
-
-    def test_extract_hackers_arcnames_common_cases(self):
-        common_hacknames = [
-            ('../foo/bar', 'foo/bar'),
-            ('foo/../bar', 'foo/bar'),
-            ('foo/../../bar', 'foo/bar'),
-            ('foo/bar/..', 'foo/bar'),
-            ('./../foo/bar', 'foo/bar'),
-            ('/foo/bar', 'foo/bar'),
-            ('/foo/../bar', 'foo/bar'),
-            ('/foo/../../bar', 'foo/bar'),
-        ]
-        self._test_extract_hackers_arcnames(common_hacknames)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipIf(os.path.sep != '\\', 'Requires \\ as path separator.')
-    def test_extract_hackers_arcnames_windows_only(self):
-        """Test combination of path fixing and windows name sanitization."""
-        windows_hacknames = [
-            (r'..\foo\bar', 'foo/bar'),
-            (r'..\/foo\/bar', 'foo/bar'),
-            (r'foo/\..\/bar', 'foo/bar'),
-            (r'foo\/../\bar', 'foo/bar'),
-            (r'C:foo/bar', 'foo/bar'),
-            (r'C:/foo/bar', 'foo/bar'),
-            (r'C://foo/bar', 'foo/bar'),
-            (r'C:\foo\bar', 'foo/bar'),
-            (r'//conky/mountpoint/foo/bar', 'foo/bar'),
-            (r'\\conky\mountpoint\foo\bar', 'foo/bar'),
-            (r'///conky/mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\\conky\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
-            (r'//conky//mountpoint/foo/bar', 'conky/mountpoint/foo/bar'),
-            (r'\\conky\\mountpoint\foo\bar', 'conky/mountpoint/foo/bar'),
-            (r'//?/C:/foo/bar', 'foo/bar'),
-            (r'\\?\C:\foo\bar', 'foo/bar'),
-            (r'C:/../C:/foo/bar', 'C_/foo/bar'),
-            (r'a:b\c<d>e|f"g?h*i', 'b/c_d_e_f_g_h_i'),
-            ('../../foo../../ba..r', 'foo/ba..r'),
-        ]
-        self._test_extract_hackers_arcnames(windows_hacknames)
-
-    @unittest.skipIf(os.path.sep != '/', r'Requires / as path separator.')
-    def test_extract_hackers_arcnames_posix_only(self):
-        posix_hacknames = [
-            ('//foo/bar', 'foo/bar'),
-            ('../../foo../../ba..r', 'foo../ba..r'),
-            (r'foo/..\bar', r'foo/..\bar'),
-        ]
-        self._test_extract_hackers_arcnames(posix_hacknames)
-
-    def _test_extract_hackers_arcnames(self, hacknames):
-        for arcname, fixedname in hacknames:
-            content = b'foobar' + arcname.encode()
-            with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_STORED) as zipfp:
-                zinfo = zipfile.ZipInfo()
-                # preserve backslashes
-                zinfo.filename = arcname
-                zinfo.external_attr = 0o600 << 16
-                zipfp.writestr(zinfo, content)
-
-            arcname = arcname.replace(os.sep, "/")
-            targetpath = os.path.join('target', 'subdir', 'subsub')
-            correctfile = os.path.join(targetpath, *fixedname.split('/'))
-
-            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
-                writtenfile = zipfp.extract(arcname, targetpath)
-                self.assertEqual(writtenfile, correctfile,
-                                 msg='extract %r: %r != %r' %
-                                 (arcname, writtenfile, correctfile))
-            self.check_file(correctfile, content)
-            rmtree('target')
-
-            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
-                zipfp.extractall(targetpath)
-            self.check_file(correctfile, content)
-            rmtree('target')
-
-            correctfile = os.path.join(os.getcwd(), *fixedname.split('/'))
-
-            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
-                writtenfile = zipfp.extract(arcname)
-                self.assertEqual(writtenfile, correctfile,
-                                 msg="extract %r" % arcname)
-            self.check_file(correctfile, content)
-            rmtree(fixedname.split('/')[0])
-
-            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
-                zipfp.extractall()
-            self.check_file(correctfile, content)
-            rmtree(fixedname.split('/')[0])
-
-            unlink(TESTFN2)
-
-
-class OtherTests(unittest.TestCase):
-    def test_open_via_zip_info(self):
-        # Create the ZIP archive
-        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
-            zipfp.writestr("name", "foo")
-            with self.assertWarns(UserWarning):
-                zipfp.writestr("name", "bar")
-            self.assertEqual(zipfp.namelist(), ["name"] * 2)
-
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            infos = zipfp.infolist()
-            data = b""
-            for info in infos:
-                with zipfp.open(info) as zipopen:
-                    data += zipopen.read()
-            self.assertIn(data, {b"foobar", b"barfoo"})
-            data = b""
-            for info in infos:
-                data += zipfp.read(info)
-            self.assertIn(data, {b"foobar", b"barfoo"})
-
-    def test_writestr_extended_local_header_issue1202(self):
-        with zipfile.ZipFile(TESTFN2, 'w') as orig_zip:
-            for data in 'abcdefghijklmnop':
-                zinfo = zipfile.ZipInfo(data)
-                zinfo.flag_bits |= 0x08  # Include an extended local header.
-                orig_zip.writestr(zinfo, data)
-
-    def test_close(self):
-        """Check that the zipfile is closed after the 'with' block."""
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            for fpath, fdata in SMALL_TEST_DATA:
-                zipfp.writestr(fpath, fdata)
-                self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
-        self.assertIsNone(zipfp.fp, 'zipfp is not closed')
-
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
-        self.assertIsNone(zipfp.fp, 'zipfp is not closed')
-
-    def test_close_on_exception(self):
-        """Check that the zipfile is closed if an exception is raised in the
-        'with' block."""
-        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
-            for fpath, fdata in SMALL_TEST_DATA:
-                zipfp.writestr(fpath, fdata)
-
-        try:
-            with zipfile.ZipFile(TESTFN2, "r") as zipfp2:
-                raise zipfile.BadZipFile()
-        except zipfile.BadZipFile:
-            self.assertIsNone(zipfp2.fp, 'zipfp is not closed')
-
-    def test_unsupported_version(self):
-        # File has an extract_version of 120
-        data = (b'PK\x03\x04x\x00\x00\x00\x00\x00!p\xa1@\x00\x00\x00\x00\x00\x00'
-                b'\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00xPK\x01\x02x\x03x\x00\x00\x00\x00'
-                b'\x00!p\xa1@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00'
-                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00xPK\x05\x06'
-                b'\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x1f\x00\x00\x00\x00\x00')
-
-        self.assertRaises(NotImplementedError, zipfile.ZipFile,
-                          io.BytesIO(data), 'r')
-
-    @requires_zlib()
-    def test_read_unicode_filenames(self):
-        # bug #10801
-        fname = findfile('zip_cp437_header.zip')
-        with zipfile.ZipFile(fname) as zipfp:
-            for name in zipfp.namelist():
-                zipfp.open(name).close()
-
-    def test_write_unicode_filenames(self):
-        with zipfile.ZipFile(TESTFN, "w") as zf:
-            zf.writestr("foo.txt", "Test for unicode filename")
-            zf.writestr("\xf6.txt", "Test for unicode filename")
-            self.assertIsInstance(zf.infolist()[0].filename, str)
-
-        with zipfile.ZipFile(TESTFN, "r") as zf:
-            self.assertEqual(zf.filelist[0].filename, "foo.txt")
-            self.assertEqual(zf.filelist[1].filename, "\xf6.txt")
-
-    def test_read_after_write_unicode_filenames(self):
-        with zipfile.ZipFile(TESTFN2, 'w') as zipfp:
-            zipfp.writestr('приклад', b'sample')
-            self.assertEqual(zipfp.read('приклад'), b'sample')
-
-    def test_exclusive_create_zip_file(self):
-        """Test exclusive creating a new zipfile."""
-        unlink(TESTFN2)
-        filename = 'testfile.txt'
-        content = b'hello, world. this is some content.'
-        with zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED) as zipfp:
-            zipfp.writestr(filename, content)
-        with self.assertRaises(FileExistsError):
-            zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED)
-        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
-            self.assertEqual(zipfp.namelist(), [filename])
-            self.assertEqual(zipfp.read(filename), content)
-
-    def test_create_non_existent_file_for_append(self):
-        if os.path.exists(TESTFN):
-            os.unlink(TESTFN)
-
-        filename = 'testfile.txt'
-        content = b'hello, world. this is some content.'
-
-        try:
-            with zipfile.ZipFile(TESTFN, 'a') as zf:
-                zf.writestr(filename, content)
-        except OSError:
-            self.fail('Could not append data to a non-existent zip file.')
-
-        self.assertTrue(os.path.exists(TESTFN))
-
-        with zipfile.ZipFile(TESTFN, 'r') as zf:
-            self.assertEqual(zf.read(filename), content)
-
-    def test_close_erroneous_file(self):
-        # This test checks that the ZipFile constructor closes the file object
-        # it opens if there's an error in the file.  If it doesn't, the
-        # traceback holds a reference to the ZipFile object and, indirectly,
-        # the file object.
-        # On Windows, this causes the os.unlink() call to fail because the
-        # underlying file is still open.  This is SF bug #412214.
-        #
-        with open(TESTFN, "w", encoding="utf-8") as fp:
-            fp.write("this is not a legal zip file\n")
-        try:
-            zf = zipfile.ZipFile(TESTFN)
-        except zipfile.BadZipFile:
-            pass
-
-    def test_is_zip_erroneous_file(self):
-        """Check that is_zipfile() correctly identifies non-zip files."""
-        # - passing a filename
-        with open(TESTFN, "w", encoding='utf-8') as fp:
-            fp.write("this is not a legal zip file\n")
-        self.assertFalse(zipfile.is_zipfile(TESTFN))
-        # - passing a path-like object
-        self.assertFalse(zipfile.is_zipfile(pathlib.Path(TESTFN)))
-        # - passing a file object
-        with open(TESTFN, "rb") as fp:
-            self.assertFalse(zipfile.is_zipfile(fp))
-        # - passing a file-like object
-        fp = io.BytesIO()
-        fp.write(b"this is not a legal zip file\n")
-        self.assertFalse(zipfile.is_zipfile(fp))
-        fp.seek(0, 0)
-        self.assertFalse(zipfile.is_zipfile(fp))
-
-    def test_damaged_zipfile(self):
-        """Check that zipfiles with missing bytes at the end raise BadZipFile."""
-        # - Create a valid zip file
-        fp = io.BytesIO()
-        with zipfile.ZipFile(fp, mode="w") as zipf:
-            zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
-        zipfiledata = fp.getvalue()
-
-        # - Now create copies of it missing the last N bytes and make sure
-        #   a BadZipFile exception is raised when we try to open it
-        for N in range(len(zipfiledata)):
-            fp = io.BytesIO(zipfiledata[:N])
-            self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, fp)
-
-    def test_is_zip_valid_file(self):
-        """Check that is_zipfile() correctly identifies zip files."""
-        # - passing a filename
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
-
-        self.assertTrue(zipfile.is_zipfile(TESTFN))
-        # - passing a file object
-        with open(TESTFN, "rb") as fp:
-            self.assertTrue(zipfile.is_zipfile(fp))
-            fp.seek(0, 0)
-            zip_contents = fp.read()
-        # - passing a file-like object
-        fp = io.BytesIO()
-        fp.write(zip_contents)
-        self.assertTrue(zipfile.is_zipfile(fp))
-        fp.seek(0, 0)
-        self.assertTrue(zipfile.is_zipfile(fp))
-
-    def test_non_existent_file_raises_OSError(self):
-        # make sure we don't raise an AttributeError when a partially-constructed
-        # ZipFile instance is finalized; this tests for regression on SF tracker
-        # bug #403871.
-
-        # The bug we're testing for caused an AttributeError to be raised
-        # when a ZipFile instance was created for a file that did not
-        # exist; the .fp member was not initialized but was needed by the
-        # __del__() method.  Since the AttributeError is in the __del__(),
-        # it is ignored, but the user should be sufficiently annoyed by
-        # the message on the output that regression will be noticed
-        # quickly.
-        self.assertRaises(OSError, zipfile.ZipFile, TESTFN)
-
-    def test_empty_file_raises_BadZipFile(self):
-        f = open(TESTFN, 'w', encoding='utf-8')
-        f.close()
-        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
-
-        with open(TESTFN, 'w', encoding='utf-8') as fp:
-            fp.write("short file")
-        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    def test_negative_central_directory_offset_raises_BadZipFile(self):
-        # Zip file containing an empty EOCD record
-        buffer = bytearray(b'PK\x05\x06' + b'\0'*18)
-
-        # Set the size of the central directory bytes to become 1,
-        # causing the central directory offset to become negative
-        for dirsize in 1, 2**32-1:
-            buffer[12:16] = struct.pack('<L', dirsize)
-            f = io.BytesIO(buffer)
-            self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, f)
-
-    def test_closed_zip_raises_ValueError(self):
-        """Verify that testzip() doesn't swallow inappropriate exceptions."""
-        data = io.BytesIO()
-        with zipfile.ZipFile(data, mode="w") as zipf:
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-
-        # This is correct; calling .read on a closed ZipFile should raise
-        # a ValueError, and so should calling .testzip.  An earlier
-        # version of .testzip would swallow this exception (and any other)
-        # and report that the first file in the archive was corrupt.
-        self.assertRaises(ValueError, zipf.read, "foo.txt")
-        self.assertRaises(ValueError, zipf.open, "foo.txt")
-        self.assertRaises(ValueError, zipf.testzip)
-        self.assertRaises(ValueError, zipf.writestr, "bogus.txt", "bogus")
-        with open(TESTFN, 'w', encoding='utf-8') as f:
-            f.write('zipfile test data')
-        self.assertRaises(ValueError, zipf.write, TESTFN)
-
-    def test_bad_constructor_mode(self):
-        """Check that bad modes passed to ZipFile constructor are caught."""
-        self.assertRaises(ValueError, zipfile.ZipFile, TESTFN, "q")
-
-    def test_bad_open_mode(self):
-        """Check that bad modes passed to ZipFile.open are caught."""
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-
-        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
-            # read the data to make sure the file is there
-            zipf.read("foo.txt")
-            self.assertRaises(ValueError, zipf.open, "foo.txt", "q")
-            # universal newlines support is removed
-            self.assertRaises(ValueError, zipf.open, "foo.txt", "U")
-            self.assertRaises(ValueError, zipf.open, "foo.txt", "rU")
-
-    def test_read0(self):
-        """Check that calling read(0) on a ZipExtFile object returns an empty
-        string and doesn't advance file pointer."""
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-            # read the data to make sure the file is there
-            with zipf.open("foo.txt") as f:
-                for i in range(FIXEDTEST_SIZE):
-                    self.assertEqual(f.read(0), b'')
-
-                self.assertEqual(f.read(), b"O, for a Muse of Fire!")
-
-    def test_open_non_existent_item(self):
-        """Check that attempting to call open() for an item that doesn't
-        exist in the archive raises a RuntimeError."""
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            self.assertRaises(KeyError, zipf.open, "foo.txt", "r")
-
-    def test_bad_compression_mode(self):
-        """Check that bad compression methods passed to ZipFile.open are
-        caught."""
-        self.assertRaises(NotImplementedError, zipfile.ZipFile, TESTFN, "w", -1)
-
-    def test_unsupported_compression(self):
-        # data is declared as shrunk, but actually deflated
-        data = (b'PK\x03\x04.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00'
-                b'\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00x\x03\x00PK\x01'
-                b'\x02.\x03.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00\x00\x02\x00\x00'
-                b'\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-                b'\x80\x01\x00\x00\x00\x00xPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00'
-                b'/\x00\x00\x00!\x00\x00\x00\x00\x00')
-        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
-            self.assertRaises(NotImplementedError, zipf.open, 'x')
-
-    def test_null_byte_in_filename(self):
-        """Check that a filename containing a null byte is properly
-        terminated."""
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.writestr("foo.txt\x00qqq", b"O, for a Muse of Fire!")
-            self.assertEqual(zipf.namelist(), ['foo.txt'])
-
-    def test_struct_sizes(self):
-        """Check that ZIP internal structure sizes are calculated correctly."""
-        self.assertEqual(zipfile.sizeEndCentDir, 22)
-        self.assertEqual(zipfile.sizeCentralDir, 46)
-        self.assertEqual(zipfile.sizeEndCentDir64, 56)
-        self.assertEqual(zipfile.sizeEndCentDir64Locator, 20)
-
-    def test_comments(self):
-        """Check that comments on the archive are handled properly."""
-
-        # check default comment is empty
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            self.assertEqual(zipf.comment, b'')
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-
-        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
-            self.assertEqual(zipfr.comment, b'')
-
-        # check a simple short comment
-        comment = b'Bravely taking to his feet, he beat a very brave retreat.'
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.comment = comment
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
-            self.assertEqual(zipf.comment, comment)
-
-        # check a comment of max length
-        comment2 = ''.join(['%d' % (i**3 % 10) for i in range((1 << 16)-1)])
-        comment2 = comment2.encode("ascii")
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            zipf.comment = comment2
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-
-        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
-            self.assertEqual(zipfr.comment, comment2)
-
-        # check a comment that is too long is truncated
-        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
-            with self.assertWarns(UserWarning):
-                zipf.comment = comment2 + b'oops'
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
-            self.assertEqual(zipfr.comment, comment2)
-
-        # check that comments are correctly modified in append mode
-        with zipfile.ZipFile(TESTFN,mode="w") as zipf:
-            zipf.comment = b"original comment"
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-        with zipfile.ZipFile(TESTFN,mode="a") as zipf:
-            zipf.comment = b"an updated comment"
-        with zipfile.ZipFile(TESTFN,mode="r") as zipf:
-            self.assertEqual(zipf.comment, b"an updated comment")
-
-        # check that comments are correctly shortened in append mode
-        # and the file is indeed truncated
-        with zipfile.ZipFile(TESTFN,mode="w") as zipf:
-            zipf.comment = b"original comment that's longer"
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-        original_zip_size = os.path.getsize(TESTFN)
-        with zipfile.ZipFile(TESTFN,mode="a") as zipf:
-            zipf.comment = b"shorter comment"
-        self.assertTrue(original_zip_size > os.path.getsize(TESTFN))
-        with zipfile.ZipFile(TESTFN,mode="r") as zipf:
-            self.assertEqual(zipf.comment, b"shorter comment")
-
-    def test_unicode_comment(self):
-        with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-            with self.assertRaises(TypeError):
-                zipf.comment = "this is an error"
-
-    def test_change_comment_in_empty_archive(self):
-        with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
-            self.assertFalse(zipf.filelist)
-            zipf.comment = b"this is a comment"
-        with zipfile.ZipFile(TESTFN, "r") as zipf:
-            self.assertEqual(zipf.comment, b"this is a comment")
-
-    def test_change_comment_in_nonempty_archive(self):
-        with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
-            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-        with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
-            self.assertTrue(zipf.filelist)
-            zipf.comment = b"this is a comment"
-        with zipfile.ZipFile(TESTFN, "r") as zipf:
-            self.assertEqual(zipf.comment, b"this is a comment")
-
-    def test_empty_zipfile(self):
-        # Check that creating a file in 'w' or 'a' mode and closing without
-        # adding any files to the archives creates a valid empty ZIP file
-        zipf = zipfile.ZipFile(TESTFN, mode="w")
-        zipf.close()
-        try:
-            zipf = zipfile.ZipFile(TESTFN, mode="r")
-        except zipfile.BadZipFile:
-            self.fail("Unable to create empty ZIP file in 'w' mode")
-
-        zipf = zipfile.ZipFile(TESTFN, mode="a")
-        zipf.close()
-        try:
-            zipf = zipfile.ZipFile(TESTFN, mode="r")
-        except:
-            self.fail("Unable to create empty ZIP file in 'a' mode")
-
-    def test_open_empty_file(self):
-        # Issue 1710703: Check that opening a file with less than 22 bytes
-        # raises a BadZipFile exception (rather than the previously unhelpful
-        # OSError)
-        f = open(TESTFN, 'w', encoding='utf-8')
-        f.close()
-        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN, 'r')
-
-    def test_create_zipinfo_before_1980(self):
-        self.assertRaises(ValueError,
-                          zipfile.ZipInfo, 'seventies', (1979, 1, 1, 0, 0, 0))
-
-    def test_create_empty_zipinfo_repr(self):
-        """Before bpo-26185, repr() on empty ZipInfo object was failing."""
-        zi = zipfile.ZipInfo(filename="empty")
-        self.assertEqual(repr(zi), "<ZipInfo filename='empty' file_size=0>")
-
-    def test_create_empty_zipinfo_default_attributes(self):
-        """Ensure all required attributes are set."""
-        zi = zipfile.ZipInfo()
-        self.assertEqual(zi.orig_filename, "NoName")
-        self.assertEqual(zi.filename, "NoName")
-        self.assertEqual(zi.date_time, (1980, 1, 1, 0, 0, 0))
-        self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
-        self.assertEqual(zi.comment, b"")
-        self.assertEqual(zi.extra, b"")
-        self.assertIn(zi.create_system, (0, 3))
-        self.assertEqual(zi.create_version, zipfile.DEFAULT_VERSION)
-        self.assertEqual(zi.extract_version, zipfile.DEFAULT_VERSION)
-        self.assertEqual(zi.reserved, 0)
-        self.assertEqual(zi.flag_bits, 0)
-        self.assertEqual(zi.volume, 0)
-        self.assertEqual(zi.internal_attr, 0)
-        self.assertEqual(zi.external_attr, 0)
-
-        # Before bpo-26185, both were missing
-        self.assertEqual(zi.file_size, 0)
-        self.assertEqual(zi.compress_size, 0)
-
-    def test_zipfile_with_short_extra_field(self):
-        """If an extra field in the header is less than 4 bytes, skip it."""
-        zipdata = (
-            b'PK\x03\x04\x14\x00\x00\x00\x00\x00\x93\x9b\xad@\x8b\x9e'
-            b'\xd9\xd3\x01\x00\x00\x00\x01\x00\x00\x00\x03\x00\x03\x00ab'
-            b'c\x00\x00\x00APK\x01\x02\x14\x03\x14\x00\x00\x00\x00'
-            b'\x00\x93\x9b\xad@\x8b\x9e\xd9\xd3\x01\x00\x00\x00\x01\x00\x00'
-            b'\x00\x03\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00'
-            b'\x00\x00\x00abc\x00\x00PK\x05\x06\x00\x00\x00\x00'
-            b'\x01\x00\x01\x003\x00\x00\x00%\x00\x00\x00\x00\x00'
-        )
-        with zipfile.ZipFile(io.BytesIO(zipdata), 'r') as zipf:
-            # testzip returns the name of the first corrupt file, or None
-            self.assertIsNone(zipf.testzip())
-
-    def test_open_conflicting_handles(self):
-        # It's only possible to open one writable file handle at a time
-        msg1 = b"It's fun to charter an accountant!"
-        msg2 = b"And sail the wide accountant sea"
-        msg3 = b"To find, explore the funds offshore"
-        with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_STORED) as zipf:
-            with zipf.open('foo', mode='w') as w2:
-                w2.write(msg1)
-            with zipf.open('bar', mode='w') as w1:
-                with self.assertRaises(ValueError):
-                    zipf.open('handle', mode='w')
-                with self.assertRaises(ValueError):
-                    zipf.open('foo', mode='r')
-                with self.assertRaises(ValueError):
-                    zipf.writestr('str', 'abcde')
-                with self.assertRaises(ValueError):
-                    zipf.write(__file__, 'file')
-                with self.assertRaises(ValueError):
-                    zipf.close()
-                w1.write(msg2)
-            with zipf.open('baz', mode='w') as w2:
-                w2.write(msg3)
-
-        with zipfile.ZipFile(TESTFN2, 'r') as zipf:
-            self.assertEqual(zipf.read('foo'), msg1)
-            self.assertEqual(zipf.read('bar'), msg2)
-            self.assertEqual(zipf.read('baz'), msg3)
-            self.assertEqual(zipf.namelist(), ['foo', 'bar', 'baz'])
-
-    def test_seek_tell(self):
-        # Test seek functionality
-        txt = b"Where's Bruce?"
-        bloc = txt.find(b"Bruce")
-        # Check seek on a file
-        with zipfile.ZipFile(TESTFN, "w") as zipf:
-            zipf.writestr("foo.txt", txt)
-        with zipfile.ZipFile(TESTFN, "r") as zipf:
-            with zipf.open("foo.txt", "r") as fp:
-                fp.seek(bloc, os.SEEK_SET)
-                self.assertEqual(fp.tell(), bloc)
-                fp.seek(-bloc, os.SEEK_CUR)
-                self.assertEqual(fp.tell(), 0)
-                fp.seek(bloc, os.SEEK_CUR)
-                self.assertEqual(fp.tell(), bloc)
-                self.assertEqual(fp.read(5), txt[bloc:bloc+5])
-                fp.seek(0, os.SEEK_END)
-                self.assertEqual(fp.tell(), len(txt))
-                fp.seek(0, os.SEEK_SET)
-                self.assertEqual(fp.tell(), 0)
-        # Check seek on memory file
-        data = io.BytesIO()
-        with zipfile.ZipFile(data, mode="w") as zipf:
-            zipf.writestr("foo.txt", txt)
-        with zipfile.ZipFile(data, mode="r") as zipf:
-            with zipf.open("foo.txt", "r") as fp:
-                fp.seek(bloc, os.SEEK_SET)
-                self.assertEqual(fp.tell(), bloc)
-                fp.seek(-bloc, os.SEEK_CUR)
-                self.assertEqual(fp.tell(), 0)
-                fp.seek(bloc, os.SEEK_CUR)
-                self.assertEqual(fp.tell(), bloc)
-                self.assertEqual(fp.read(5), txt[bloc:bloc+5])
-                fp.seek(0, os.SEEK_END)
-                self.assertEqual(fp.tell(), len(txt))
-                fp.seek(0, os.SEEK_SET)
-                self.assertEqual(fp.tell(), 0)
-
-    @requires_bz2()
-    def test_decompress_without_3rd_party_library(self):
-        data = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        zip_file = io.BytesIO(data)
-        with zipfile.ZipFile(zip_file, 'w', compression=zipfile.ZIP_BZIP2) as zf:
-            zf.writestr('a.txt', b'a')
-        with mock.patch('zipfile.bz2', None):
-            with zipfile.ZipFile(zip_file) as zf:
-                self.assertRaises(RuntimeError, zf.extract, 'a.txt')
-
-    def tearDown(self):
-        unlink(TESTFN)
-        unlink(TESTFN2)
-
-
-class AbstractBadCrcTests:
-    def test_testzip_with_bad_crc(self):
-        """Tests that files with bad CRCs return their name from testzip."""
-        zipdata = self.zip_with_bad_crc
-
-        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
-            # testzip returns the name of the first corrupt file, or None
-            self.assertEqual('afile', zipf.testzip())
-
-    def test_read_with_bad_crc(self):
-        """Tests that files with bad CRCs raise a BadZipFile exception when read."""
-        zipdata = self.zip_with_bad_crc
-
-        # Using ZipFile.read()
-        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
-            self.assertRaises(zipfile.BadZipFile, zipf.read, 'afile')
-
-        # Using ZipExtFile.read()
-        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
-            with zipf.open('afile', 'r') as corrupt_file:
-                self.assertRaises(zipfile.BadZipFile, corrupt_file.read)
-
-        # Same with small reads (in order to exercise the buffering logic)
-        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
-            with zipf.open('afile', 'r') as corrupt_file:
-                corrupt_file.MIN_READ_SIZE = 2
-                with self.assertRaises(zipfile.BadZipFile):
-                    while corrupt_file.read(2):
-                        pass
-
-
-class StoredBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
-    compression = zipfile.ZIP_STORED
-    zip_with_bad_crc = (
-        b'PK\003\004\024\0\0\0\0\0 \213\212;:r'
-        b'\253\377\f\0\0\0\f\0\0\0\005\0\0\000af'
-        b'ilehello,AworldP'
-        b'K\001\002\024\003\024\0\0\0\0\0 \213\212;:'
-        b'r\253\377\f\0\0\0\f\0\0\0\005\0\0\0\0'
-        b'\0\0\0\0\0\0\0\200\001\0\0\0\000afi'
-        b'lePK\005\006\0\0\0\0\001\0\001\0003\000'
-        b'\0\0/\0\0\0\0\0')
-
-@requires_zlib()
-class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
-    compression = zipfile.ZIP_DEFLATED
-    zip_with_bad_crc = (
-        b'PK\x03\x04\x14\x00\x00\x00\x08\x00n}\x0c=FA'
-        b'KE\x10\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
-        b'ile\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\xc9\xa0'
-        b'=\x13\x00PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00n'
-        b'}\x0c=FAKE\x10\x00\x00\x00n\x00\x00\x00\x05'
-        b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00'
-        b'\x00afilePK\x05\x06\x00\x00\x00\x00\x01\x00'
-        b'\x01\x003\x00\x00\x003\x00\x00\x00\x00\x00')
-
-@requires_bz2()
-class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase):
-    compression = zipfile.ZIP_BZIP2
-    zip_with_bad_crc = (
-        b'PK\x03\x04\x14\x03\x00\x00\x0c\x00nu\x0c=FA'
-        b'KE8\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
-        b'ileBZh91AY&SY\xd4\xa8\xca'
-        b'\x7f\x00\x00\x0f\x11\x80@\x00\x06D\x90\x80 \x00 \xa5'
-        b'P\xd9!\x03\x03\x13\x13\x13\x89\xa9\xa9\xc2u5:\x9f'
-        b'\x8b\xb9"\x9c(HjTe?\x80PK\x01\x02\x14'
-        b'\x03\x14\x03\x00\x00\x0c\x00nu\x0c=FAKE8'
-        b'\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00'
-        b'\x00 \x80\x80\x81\x00\x00\x00\x00afilePK'
-        b'\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00\x00[\x00'
-        b'\x00\x00\x00\x00')
-
-@requires_lzma()
-class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
-    compression = zipfile.ZIP_LZMA
-    zip_with_bad_crc = (
-        b'PK\x03\x04\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
-        b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
-        b'ile\t\x04\x05\x00]\x00\x00\x00\x04\x004\x19I'
-        b'\xee\x8d\xe9\x17\x89:3`\tq!.8\x00PK'
-        b'\x01\x02\x14\x03\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
-        b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00'
-        b'\x00\x00\x00\x00 \x80\x80\x81\x00\x00\x00\x00afil'
-        b'ePK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00'
-        b'\x00>\x00\x00\x00\x00\x00')
-
-
-class DecryptionTests(unittest.TestCase):
-    """Check that ZIP decryption works. Since the library does not
-    support encryption at the moment, we use a pre-generated encrypted
-    ZIP file."""
-
-    data = (
-        b'PK\x03\x04\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00\x1a\x00'
-        b'\x00\x00\x08\x00\x00\x00test.txt\xfa\x10\xa0gly|\xfa-\xc5\xc0=\xf9y'
-        b'\x18\xe0\xa8r\xb3Z}Lg\xbc\xae\xf9|\x9b\x19\xe4\x8b\xba\xbb)\x8c\xb0\xdbl'
-        b'PK\x01\x02\x14\x00\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00'
-        b'\x1a\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x01\x00 \x00\xb6\x81'
-        b'\x00\x00\x00\x00test.txtPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x006\x00'
-        b'\x00\x00L\x00\x00\x00\x00\x00' )
-    data2 = (
-        b'PK\x03\x04\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02'
-        b'\x00\x00\x04\x00\x15\x00zeroUT\t\x00\x03\xd6\x8b\x92G\xda\x8b\x92GUx\x04'
-        b'\x00\xe8\x03\xe8\x03\xc7<M\xb5a\xceX\xa3Y&\x8b{oE\xd7\x9d\x8c\x98\x02\xc0'
-        b'PK\x07\x08xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00PK\x01\x02\x17\x03'
-        b'\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00'
-        b'\x04\x00\r\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00ze'
-        b'roUT\x05\x00\x03\xd6\x8b\x92GUx\x00\x00PK\x05\x06\x00\x00\x00\x00\x01'
-        b'\x00\x01\x00?\x00\x00\x00[\x00\x00\x00\x00\x00' )
-
-    plain = b'zipfile.py encryption test'
-    plain2 = b'\x00'*512
-
-    def setUp(self):
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-        self.zip = zipfile.ZipFile(TESTFN, "r")
-        with open(TESTFN2, "wb") as fp:
-            fp.write(self.data2)
-        self.zip2 = zipfile.ZipFile(TESTFN2, "r")
-
-    def tearDown(self):
-        self.zip.close()
-        os.unlink(TESTFN)
-        self.zip2.close()
-        os.unlink(TESTFN2)
-
-    def test_no_password(self):
-        # Reading the encrypted file without password
-        # must generate a RunTime exception
-        self.assertRaises(RuntimeError, self.zip.read, "test.txt")
-        self.assertRaises(RuntimeError, self.zip2.read, "zero")
-
-    def test_bad_password(self):
-        self.zip.setpassword(b"perl")
-        self.assertRaises(RuntimeError, self.zip.read, "test.txt")
-        self.zip2.setpassword(b"perl")
-        self.assertRaises(RuntimeError, self.zip2.read, "zero")
-
-    @requires_zlib()
-    def test_good_password(self):
-        self.zip.setpassword(b"python")
-        self.assertEqual(self.zip.read("test.txt"), self.plain)
-        self.zip2.setpassword(b"12345")
-        self.assertEqual(self.zip2.read("zero"), self.plain2)
-
-    def test_unicode_password(self):
-        self.assertRaises(TypeError, self.zip.setpassword, "unicode")
-        self.assertRaises(TypeError, self.zip.read, "test.txt", "python")
-        self.assertRaises(TypeError, self.zip.open, "test.txt", pwd="python")
-        self.assertRaises(TypeError, self.zip.extract, "test.txt", pwd="python")
-
-    def test_seek_tell(self):
-        self.zip.setpassword(b"python")
-        txt = self.plain
-        test_word = b'encryption'
-        bloc = txt.find(test_word)
-        bloc_len = len(test_word)
-        with self.zip.open("test.txt", "r") as fp:
-            fp.seek(bloc, os.SEEK_SET)
-            self.assertEqual(fp.tell(), bloc)
-            fp.seek(-bloc, os.SEEK_CUR)
-            self.assertEqual(fp.tell(), 0)
-            fp.seek(bloc, os.SEEK_CUR)
-            self.assertEqual(fp.tell(), bloc)
-            self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
-
-            # Make sure that the second read after seeking back beyond
-            # _readbuffer returns the same content (ie. rewind to the start of
-            # the file to read forward to the required position).
-            old_read_size = fp.MIN_READ_SIZE
-            fp.MIN_READ_SIZE = 1
-            fp._readbuffer = b''
-            fp._offset = 0
-            fp.seek(0, os.SEEK_SET)
-            self.assertEqual(fp.tell(), 0)
-            fp.seek(bloc, os.SEEK_CUR)
-            self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
-            fp.MIN_READ_SIZE = old_read_size
-
-            fp.seek(0, os.SEEK_END)
-            self.assertEqual(fp.tell(), len(txt))
-            fp.seek(0, os.SEEK_SET)
-            self.assertEqual(fp.tell(), 0)
-
-            # Read the file completely to definitely call any eof integrity
-            # checks (crc) and make sure they still pass.
-            fp.read()
-
-
-class AbstractTestsWithRandomBinaryFiles:
-    @classmethod
-    def setUpClass(cls):
-        datacount = randint(16, 64)*1024 + randint(1, 1024)
-        cls.data = b''.join(struct.pack('<f', random()*randint(-1000, 1000))
-                            for i in range(datacount))
-
-    def setUp(self):
-        # Make a source file with some lines
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-
-    def tearDown(self):
-        unlink(TESTFN)
-        unlink(TESTFN2)
-
-    def make_test_archive(self, f, compression):
-        # Create the ZIP archive
-        with zipfile.ZipFile(f, "w", compression) as zipfp:
-            zipfp.write(TESTFN, "another.name")
-            zipfp.write(TESTFN, TESTFN)
-
-    def zip_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            testdata = zipfp.read(TESTFN)
-            self.assertEqual(len(testdata), len(self.data))
-            self.assertEqual(testdata, self.data)
-            self.assertEqual(zipfp.read("another.name"), self.data)
-
-    def test_read(self):
-        for f in get_files(self):
-            self.zip_test(f, self.compression)
-
-    def zip_open_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            zipdata1 = []
-            with zipfp.open(TESTFN) as zipopen1:
-                while True:
-                    read_data = zipopen1.read(256)
-                    if not read_data:
-                        break
-                    zipdata1.append(read_data)
-
-            zipdata2 = []
-            with zipfp.open("another.name") as zipopen2:
-                while True:
-                    read_data = zipopen2.read(256)
-                    if not read_data:
-                        break
-                    zipdata2.append(read_data)
-
-            testdata1 = b''.join(zipdata1)
-            self.assertEqual(len(testdata1), len(self.data))
-            self.assertEqual(testdata1, self.data)
-
-            testdata2 = b''.join(zipdata2)
-            self.assertEqual(len(testdata2), len(self.data))
-            self.assertEqual(testdata2, self.data)
-
-    def test_open(self):
-        for f in get_files(self):
-            self.zip_open_test(f, self.compression)
-
-    def zip_random_open_test(self, f, compression):
-        self.make_test_archive(f, compression)
-
-        # Read the ZIP archive
-        with zipfile.ZipFile(f, "r", compression) as zipfp:
-            zipdata1 = []
-            with zipfp.open(TESTFN) as zipopen1:
-                while True:
-                    read_data = zipopen1.read(randint(1, 1024))
-                    if not read_data:
-                        break
-                    zipdata1.append(read_data)
-
-            testdata = b''.join(zipdata1)
-            self.assertEqual(len(testdata), len(self.data))
-            self.assertEqual(testdata, self.data)
-
-    def test_random_open(self):
-        for f in get_files(self):
-            self.zip_random_open_test(f, self.compression)
-
-
-class StoredTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
-                                       unittest.TestCase):
-    compression = zipfile.ZIP_STORED
-
-@requires_zlib()
-class DeflateTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
-                                        unittest.TestCase):
-    compression = zipfile.ZIP_DEFLATED
-
-@requires_bz2()
-class Bzip2TestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
-                                      unittest.TestCase):
-    compression = zipfile.ZIP_BZIP2
-
-@requires_lzma()
-class LzmaTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
-                                     unittest.TestCase):
-    compression = zipfile.ZIP_LZMA
-
-
-# Provide the tell() method but not seek()
-class Tellable:
-    def __init__(self, fp):
-        self.fp = fp
-        self.offset = 0
-
-    def write(self, data):
-        n = self.fp.write(data)
-        self.offset += n
-        return n
-
-    def tell(self):
-        return self.offset
-
-    def flush(self):
-        self.fp.flush()
-
-class Unseekable:
-    def __init__(self, fp):
-        self.fp = fp
-
-    def write(self, data):
-        return self.fp.write(data)
-
-    def flush(self):
-        self.fp.flush()
-
-class UnseekableTests(unittest.TestCase):
-    def test_writestr(self):
-        for wrapper in (lambda f: f), Tellable, Unseekable:
-            with self.subTest(wrapper=wrapper):
-                f = io.BytesIO()
-                f.write(b'abc')
-                bf = io.BufferedWriter(f)
-                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
-                    zipfp.writestr('ones', b'111')
-                    zipfp.writestr('twos', b'222')
-                self.assertEqual(f.getvalue()[:5], b'abcPK')
-                with zipfile.ZipFile(f, mode='r') as zipf:
-                    with zipf.open('ones') as zopen:
-                        self.assertEqual(zopen.read(), b'111')
-                    with zipf.open('twos') as zopen:
-                        self.assertEqual(zopen.read(), b'222')
-
-    def test_write(self):
-        for wrapper in (lambda f: f), Tellable, Unseekable:
-            with self.subTest(wrapper=wrapper):
-                f = io.BytesIO()
-                f.write(b'abc')
-                bf = io.BufferedWriter(f)
-                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
-                    self.addCleanup(unlink, TESTFN)
-                    with open(TESTFN, 'wb') as f2:
-                        f2.write(b'111')
-                    zipfp.write(TESTFN, 'ones')
-                    with open(TESTFN, 'wb') as f2:
-                        f2.write(b'222')
-                    zipfp.write(TESTFN, 'twos')
-                self.assertEqual(f.getvalue()[:5], b'abcPK')
-                with zipfile.ZipFile(f, mode='r') as zipf:
-                    with zipf.open('ones') as zopen:
-                        self.assertEqual(zopen.read(), b'111')
-                    with zipf.open('twos') as zopen:
-                        self.assertEqual(zopen.read(), b'222')
-
-    def test_open_write(self):
-        for wrapper in (lambda f: f), Tellable, Unseekable:
-            with self.subTest(wrapper=wrapper):
-                f = io.BytesIO()
-                f.write(b'abc')
-                bf = io.BufferedWriter(f)
-                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipf:
-                    with zipf.open('ones', 'w') as zopen:
-                        zopen.write(b'111')
-                    with zipf.open('twos', 'w') as zopen:
-                        zopen.write(b'222')
-                self.assertEqual(f.getvalue()[:5], b'abcPK')
-                with zipfile.ZipFile(f) as zipf:
-                    self.assertEqual(zipf.read('ones'), b'111')
-                    self.assertEqual(zipf.read('twos'), b'222')
-
-
-@requires_zlib()
-class TestsWithMultipleOpens(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.data1 = b'111' + randbytes(10000)
-        cls.data2 = b'222' + randbytes(10000)
-
-    def make_test_archive(self, f):
-        # Create the ZIP archive
-        with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipfp:
-            zipfp.writestr('ones', self.data1)
-            zipfp.writestr('twos', self.data2)
-
-    def test_same_file(self):
-        # Verify that (when the ZipFile is in control of creating file objects)
-        # multiple open() calls can be made without interfering with each other.
-        for f in get_files(self):
-            self.make_test_archive(f)
-            with zipfile.ZipFile(f, mode="r") as zipf:
-                with zipf.open('ones') as zopen1, zipf.open('ones') as zopen2:
-                    data1 = zopen1.read(500)
-                    data2 = zopen2.read(500)
-                    data1 += zopen1.read()
-                    data2 += zopen2.read()
-                self.assertEqual(data1, data2)
-                self.assertEqual(data1, self.data1)
-
-    def test_different_file(self):
-        # Verify that (when the ZipFile is in control of creating file objects)
-        # multiple open() calls can be made without interfering with each other.
-        for f in get_files(self):
-            self.make_test_archive(f)
-            with zipfile.ZipFile(f, mode="r") as zipf:
-                with zipf.open('ones') as zopen1, zipf.open('twos') as zopen2:
-                    data1 = zopen1.read(500)
-                    data2 = zopen2.read(500)
-                    data1 += zopen1.read()
-                    data2 += zopen2.read()
-                self.assertEqual(data1, self.data1)
-                self.assertEqual(data2, self.data2)
-
-    def test_interleaved(self):
-        # Verify that (when the ZipFile is in control of creating file objects)
-        # multiple open() calls can be made without interfering with each other.
-        for f in get_files(self):
-            self.make_test_archive(f)
-            with zipfile.ZipFile(f, mode="r") as zipf:
-                with zipf.open('ones') as zopen1:
-                    data1 = zopen1.read(500)
-                    with zipf.open('twos') as zopen2:
-                        data2 = zopen2.read(500)
-                        data1 += zopen1.read()
-                        data2 += zopen2.read()
-                self.assertEqual(data1, self.data1)
-                self.assertEqual(data2, self.data2)
-
-    def test_read_after_close(self):
-        for f in get_files(self):
-            self.make_test_archive(f)
-            with contextlib.ExitStack() as stack:
-                with zipfile.ZipFile(f, 'r') as zipf:
-                    zopen1 = stack.enter_context(zipf.open('ones'))
-                    zopen2 = stack.enter_context(zipf.open('twos'))
-                data1 = zopen1.read(500)
-                data2 = zopen2.read(500)
-                data1 += zopen1.read()
-                data2 += zopen2.read()
-            self.assertEqual(data1, self.data1)
-            self.assertEqual(data2, self.data2)
-
-    def test_read_after_write(self):
-        for f in get_files(self):
-            with zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED) as zipf:
-                zipf.writestr('ones', self.data1)
-                zipf.writestr('twos', self.data2)
-                with zipf.open('ones') as zopen1:
-                    data1 = zopen1.read(500)
-            self.assertEqual(data1, self.data1[:500])
-            with zipfile.ZipFile(f, 'r') as zipf:
-                data1 = zipf.read('ones')
-                data2 = zipf.read('twos')
-            self.assertEqual(data1, self.data1)
-            self.assertEqual(data2, self.data2)
-
-    def test_write_after_read(self):
-        for f in get_files(self):
-            with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipf:
-                zipf.writestr('ones', self.data1)
-                with zipf.open('ones') as zopen1:
-                    zopen1.read(500)
-                    zipf.writestr('twos', self.data2)
-            with zipfile.ZipFile(f, 'r') as zipf:
-                data1 = zipf.read('ones')
-                data2 = zipf.read('twos')
-            self.assertEqual(data1, self.data1)
-            self.assertEqual(data2, self.data2)
-
-    # TODO: RUSTPYTHON other tests can impact the file descriptor incrementor
-    # by leaving file handles unclosed. If there are more than 100 files in
-    # TESTFN and references to them are left unclosed and ungarbage collected
-    # in another test, then fileno() will always be too high for this test to
-    # pass. The solution is to increase the number of files from 100 to 200
-    def test_many_opens(self):
-        # Verify that read() and open() promptly close the file descriptor,
-        # and don't rely on the garbage collector to free resources.
-        self.make_test_archive(TESTFN2)
-        with zipfile.ZipFile(TESTFN2, mode="r") as zipf:
-            for x in range(200):
-                zipf.read('ones')
-                with zipf.open('ones') as zopen1:
-                    pass
-        with open(os.devnull, "rb") as f:
-            self.assertLess(f.fileno(), 200)
-
-    def test_write_while_reading(self):
-        with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_DEFLATED) as zipf:
-            zipf.writestr('ones', self.data1)
-        with zipfile.ZipFile(TESTFN2, 'a', zipfile.ZIP_DEFLATED) as zipf:
-            with zipf.open('ones', 'r') as r1:
-                data1 = r1.read(500)
-                with zipf.open('twos', 'w') as w1:
-                    w1.write(self.data2)
-                data1 += r1.read()
-        self.assertEqual(data1, self.data1)
-        with zipfile.ZipFile(TESTFN2) as zipf:
-            self.assertEqual(zipf.read('twos'), self.data2)
-
-    def tearDown(self):
-        unlink(TESTFN2)
-
-
-class TestWithDirectory(unittest.TestCase):
-    def setUp(self):
-        os.mkdir(TESTFN2)
-
-    def test_extract_dir(self):
-        with zipfile.ZipFile(findfile("zipdir.zip")) as zipf:
-            zipf.extractall(TESTFN2)
-        self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
-        self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
-        self.assertTrue(os.path.exists(os.path.join(TESTFN2, "a", "b", "c")))
-
-    def test_bug_6050(self):
-        # Extraction should succeed if directories already exist
-        os.mkdir(os.path.join(TESTFN2, "a"))
-        self.test_extract_dir()
-
-    def test_write_dir(self):
-        dirpath = os.path.join(TESTFN2, "x")
-        os.mkdir(dirpath)
-        mode = os.stat(dirpath).st_mode & 0xFFFF
-        with zipfile.ZipFile(TESTFN, "w") as zipf:
-            zipf.write(dirpath)
-            zinfo = zipf.filelist[0]
-            self.assertTrue(zinfo.filename.endswith("/x/"))
-            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
-            zipf.write(dirpath, "y")
-            zinfo = zipf.filelist[1]
-            self.assertTrue(zinfo.filename, "y/")
-            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
-        with zipfile.ZipFile(TESTFN, "r") as zipf:
-            zinfo = zipf.filelist[0]
-            self.assertTrue(zinfo.filename.endswith("/x/"))
-            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
-            zinfo = zipf.filelist[1]
-            self.assertTrue(zinfo.filename, "y/")
-            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
-            target = os.path.join(TESTFN2, "target")
-            os.mkdir(target)
-            zipf.extractall(target)
-            self.assertTrue(os.path.isdir(os.path.join(target, "y")))
-            self.assertEqual(len(os.listdir(target)), 2)
-
-    def test_writestr_dir(self):
-        os.mkdir(os.path.join(TESTFN2, "x"))
-        with zipfile.ZipFile(TESTFN, "w") as zipf:
-            zipf.writestr("x/", b'')
-            zinfo = zipf.filelist[0]
-            self.assertEqual(zinfo.filename, "x/")
-            self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
-        with zipfile.ZipFile(TESTFN, "r") as zipf:
-            zinfo = zipf.filelist[0]
-            self.assertTrue(zinfo.filename.endswith("x/"))
-            self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
-            target = os.path.join(TESTFN2, "target")
-            os.mkdir(target)
-            zipf.extractall(target)
-            self.assertTrue(os.path.isdir(os.path.join(target, "x")))
-            self.assertEqual(os.listdir(target), ["x"])
-
-    def tearDown(self):
-        rmtree(TESTFN2)
-        if os.path.exists(TESTFN):
-            unlink(TESTFN)
-
-
-class ZipInfoTests(unittest.TestCase):
-    def test_from_file(self):
-        zi = zipfile.ZipInfo.from_file(__file__)
-        self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
-        self.assertFalse(zi.is_dir())
-        self.assertEqual(zi.file_size, os.path.getsize(__file__))
-
-    def test_from_file_pathlike(self):
-        zi = zipfile.ZipInfo.from_file(pathlib.Path(__file__))
-        self.assertEqual(posixpath.basename(zi.filename), 'test_zipfile.py')
-        self.assertFalse(zi.is_dir())
-        self.assertEqual(zi.file_size, os.path.getsize(__file__))
-
-    def test_from_file_bytes(self):
-        zi = zipfile.ZipInfo.from_file(os.fsencode(__file__), 'test')
-        self.assertEqual(posixpath.basename(zi.filename), 'test')
-        self.assertFalse(zi.is_dir())
-        self.assertEqual(zi.file_size, os.path.getsize(__file__))
-
-    def test_from_file_fileno(self):
-        with open(__file__, 'rb') as f:
-            zi = zipfile.ZipInfo.from_file(f.fileno(), 'test')
-            self.assertEqual(posixpath.basename(zi.filename), 'test')
-            self.assertFalse(zi.is_dir())
-            self.assertEqual(zi.file_size, os.path.getsize(__file__))
-
-    def test_from_dir(self):
-        dirpath = os.path.dirname(os.path.abspath(__file__))
-        zi = zipfile.ZipInfo.from_file(dirpath, 'stdlib_tests')
-        self.assertEqual(zi.filename, 'stdlib_tests/')
-        self.assertTrue(zi.is_dir())
-        self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
-        self.assertEqual(zi.file_size, 0)
-
-
-class CommandLineTest(unittest.TestCase):
-
-    def zipfilecmd(self, *args, **kwargs):
-        rc, out, err = script_helper.assert_python_ok('-m', 'zipfile', *args,
-                                                      **kwargs)
-        return out.replace(os.linesep.encode(), b'\n')
-
-    def zipfilecmd_failure(self, *args):
-        return script_helper.assert_python_failure('-m', 'zipfile', *args)
-
-    def test_bad_use(self):
-        rc, out, err = self.zipfilecmd_failure()
-        self.assertEqual(out, b'')
-        self.assertIn(b'usage', err.lower())
-        self.assertIn(b'error', err.lower())
-        self.assertIn(b'required', err.lower())
-        rc, out, err = self.zipfilecmd_failure('-l', '')
-        self.assertEqual(out, b'')
-        self.assertNotEqual(err.strip(), b'')
-
-    def test_test_command(self):
-        zip_name = findfile('zipdir.zip')
-        for opt in '-t', '--test':
-            out = self.zipfilecmd(opt, zip_name)
-            self.assertEqual(out.rstrip(), b'Done testing')
-        zip_name = findfile('testtar.tar')
-        rc, out, err = self.zipfilecmd_failure('-t', zip_name)
-        self.assertEqual(out, b'')
-
-    def test_list_command(self):
-        zip_name = findfile('zipdir.zip')
-        t = io.StringIO()
-        with zipfile.ZipFile(zip_name, 'r') as tf:
-            tf.printdir(t)
-        expected = t.getvalue().encode('ascii', 'backslashreplace')
-        for opt in '-l', '--list':
-            out = self.zipfilecmd(opt, zip_name,
-                                  PYTHONIOENCODING='ascii:backslashreplace')
-            self.assertEqual(out, expected)
-
-    @requires_zlib()
-    def test_create_command(self):
-        self.addCleanup(unlink, TESTFN)
-        with open(TESTFN, 'w', encoding='utf-8') as f:
-            f.write('test 1')
-        os.mkdir(TESTFNDIR)
-        self.addCleanup(rmtree, TESTFNDIR)
-        with open(os.path.join(TESTFNDIR, 'file.txt'), 'w', encoding='utf-8') as f:
-            f.write('test 2')
-        files = [TESTFN, TESTFNDIR]
-        namelist = [TESTFN, TESTFNDIR + '/', TESTFNDIR + '/file.txt']
-        for opt in '-c', '--create':
-            try:
-                out = self.zipfilecmd(opt, TESTFN2, *files)
-                self.assertEqual(out, b'')
-                with zipfile.ZipFile(TESTFN2) as zf:
-                    self.assertEqual(zf.namelist(), namelist)
-                    self.assertEqual(zf.read(namelist[0]), b'test 1')
-                    self.assertEqual(zf.read(namelist[2]), b'test 2')
-            finally:
-                unlink(TESTFN2)
-
-    def test_extract_command(self):
-        zip_name = findfile('zipdir.zip')
-        for opt in '-e', '--extract':
-            with temp_dir() as extdir:
-                out = self.zipfilecmd(opt, zip_name, extdir)
-                self.assertEqual(out, b'')
-                with zipfile.ZipFile(zip_name) as zf:
-                    for zi in zf.infolist():
-                        path = os.path.join(extdir,
-                                    zi.filename.replace('/', os.sep))
-                        if zi.is_dir():
-                            self.assertTrue(os.path.isdir(path))
-                        else:
-                            self.assertTrue(os.path.isfile(path))
-                            with open(path, 'rb') as f:
-                                self.assertEqual(f.read(), zf.read(zi))
-
-
-class TestExecutablePrependedZip(unittest.TestCase):
-    """Test our ability to open zip files with an executable prepended."""
-
-    def setUp(self):
-        self.exe_zip = findfile('exe_with_zip', subdir='ziptestdata')
-        self.exe_zip64 = findfile('exe_with_z64', subdir='ziptestdata')
-
-    def _test_zip_works(self, name):
-        # bpo28494 sanity check: ensure is_zipfile works on these.
-        self.assertTrue(zipfile.is_zipfile(name),
-                        f'is_zipfile failed on {name}')
-        # Ensure we can operate on these via ZipFile.
-        with zipfile.ZipFile(name) as zipfp:
-            for n in zipfp.namelist():
-                data = zipfp.read(n)
-                self.assertIn(b'FAVORITE_NUMBER', data)
-
-    def test_read_zip_with_exe_prepended(self):
-        self._test_zip_works(self.exe_zip)
-
-    def test_read_zip64_with_exe_prepended(self):
-        self._test_zip_works(self.exe_zip64)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipUnless(sys.executable, 'sys.executable required.')
-    @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
-                         'Test relies on #!/bin/bash working.')
-    def test_execute_zip2(self):
-        output = subprocess.check_output([self.exe_zip, sys.executable])
-        self.assertIn(b'number in executable: 5', output)
-
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
-    @unittest.skipUnless(sys.executable, 'sys.executable required.')
-    @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
-                         'Test relies on #!/bin/bash working.')
-    def test_execute_zip64(self):
-        output = subprocess.check_output([self.exe_zip64, sys.executable])
-        self.assertIn(b'number in executable: 5', output)
-
-
-# Poor man's technique to consume a (smallish) iterable.
-consume = tuple
-
-
-# from jaraco.itertools 5.0
-class jaraco:
-    class itertools:
-        class Counter:
-            def __init__(self, i):
-                self.count = 0
-                self._orig_iter = iter(i)
-
-            def __iter__(self):
-                return self
-
-            def __next__(self):
-                result = next(self._orig_iter)
-                self.count += 1
-                return result
-
-
-def add_dirs(zf):
-    """
-    Given a writable zip file zf, inject directory entries for
-    any directories implied by the presence of children.
-    """
-    for name in zipfile.CompleteDirs._implied_dirs(zf.namelist()):
-        zf.writestr(name, b"")
-    return zf
-
-
-def build_alpharep_fixture():
-    """
-    Create a zip file with this structure:
-
-    .
-    ├── a.txt
-    ├── b
-    │   ├── c.txt
-    │   ├── d
-    │   │   └── e.txt
-    │   └── f.txt
-    └── g
-        └── h
-            └── i.txt
-
-    This fixture has the following key characteristics:
-
-    - a file at the root (a)
-    - a file two levels deep (b/d/e)
-    - multiple files in a directory (b/c, b/f)
-    - a directory containing only a directory (g/h)
-
-    "alpha" because it uses alphabet
-    "rep" because it's a representative example
-    """
-    data = io.BytesIO()
-    zf = zipfile.ZipFile(data, "w")
-    zf.writestr("a.txt", b"content of a")
-    zf.writestr("b/c.txt", b"content of c")
-    zf.writestr("b/d/e.txt", b"content of e")
-    zf.writestr("b/f.txt", b"content of f")
-    zf.writestr("g/h/i.txt", b"content of i")
-    zf.filename = "alpharep.zip"
-    return zf
-
-
-def pass_alpharep(meth):
-    """
-    Given a method, wrap it in a for loop that invokes method
-    with each subtest.
-    """
-
-    @functools.wraps(meth)
-    def wrapper(self):
-        for alpharep in self.zipfile_alpharep():
-            meth(self, alpharep=alpharep)
-
-    return wrapper
-
-
-class TestPath(unittest.TestCase):
-    def setUp(self):
-        self.fixtures = contextlib.ExitStack()
-        self.addCleanup(self.fixtures.close)
-
-    def zipfile_alpharep(self):
-        with self.subTest():
-            yield build_alpharep_fixture()
-        with self.subTest():
-            yield add_dirs(build_alpharep_fixture())
-
-    def zipfile_ondisk(self, alpharep):
-        tmpdir = pathlib.Path(self.fixtures.enter_context(temp_dir()))
-        buffer = alpharep.fp
-        alpharep.close()
-        path = tmpdir / alpharep.filename
-        with path.open("wb") as strm:
-            strm.write(buffer.getvalue())
-        return path
-
-    @pass_alpharep
-    def test_iterdir_and_types(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.is_dir()
-        a, b, g = root.iterdir()
-        assert a.is_file()
-        assert b.is_dir()
-        assert g.is_dir()
-        c, f, d = b.iterdir()
-        assert c.is_file() and f.is_file()
-        (e,) = d.iterdir()
-        assert e.is_file()
-        (h,) = g.iterdir()
-        (i,) = h.iterdir()
-        assert i.is_file()
-
-    @pass_alpharep
-    def test_is_file_missing(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert not root.joinpath('missing.txt').is_file()
-
-    @pass_alpharep
-    def test_iterdir_on_file(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        with self.assertRaises(ValueError):
-            a.iterdir()
-
-    @pass_alpharep
-    def test_subdir_is_dir(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'b').is_dir()
-        assert (root / 'b/').is_dir()
-        assert (root / 'g').is_dir()
-        assert (root / 'g/').is_dir()
-
-    @pass_alpharep
-    def test_open(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        with a.open(encoding="utf-8") as strm:
-            data = strm.read()
-        assert data == "content of a"
-
-    def test_open_write(self):
-        """
-        If the zipfile is open for write, it should be possible to
-        write bytes or text to it.
-        """
-        zf = zipfile.Path(zipfile.ZipFile(io.BytesIO(), mode='w'))
-        with zf.joinpath('file.bin').open('wb') as strm:
-            strm.write(b'binary contents')
-        with zf.joinpath('file.txt').open('w', encoding="utf-8") as strm:
-            strm.write('text file')
-
-    def test_open_extant_directory(self):
-        """
-        Attempting to open a directory raises IsADirectoryError.
-        """
-        zf = zipfile.Path(add_dirs(build_alpharep_fixture()))
-        with self.assertRaises(IsADirectoryError):
-            zf.joinpath('b').open()
-
-    @pass_alpharep
-    def test_open_binary_invalid_args(self, alpharep):
-        root = zipfile.Path(alpharep)
-        with self.assertRaises(ValueError):
-            root.joinpath('a.txt').open('rb', encoding='utf-8')
-        with self.assertRaises(ValueError):
-            root.joinpath('a.txt').open('rb', 'utf-8')
-
-    def test_open_missing_directory(self):
-        """
-        Attempting to open a missing directory raises FileNotFoundError.
-        """
-        zf = zipfile.Path(add_dirs(build_alpharep_fixture()))
-        with self.assertRaises(FileNotFoundError):
-            zf.joinpath('z').open()
-
-    @pass_alpharep
-    def test_read(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        assert a.read_text(encoding="utf-8") == "content of a"
-        assert a.read_bytes() == b"content of a"
-
-    @pass_alpharep
-    def test_joinpath(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a = root.joinpath("a.txt")
-        assert a.is_file()
-        e = root.joinpath("b").joinpath("d").joinpath("e.txt")
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_joinpath_multiple(self, alpharep):
-        root = zipfile.Path(alpharep)
-        e = root.joinpath("b", "d", "e.txt")
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_traverse_truediv(self, alpharep):
-        root = zipfile.Path(alpharep)
-        a = root / "a.txt"
-        assert a.is_file()
-        e = root / "b" / "d" / "e.txt"
-        assert e.read_text(encoding="utf-8") == "content of e"
-
-    @pass_alpharep
-    def test_traverse_simplediv(self, alpharep):
-        """
-        Disable the __future__.division when testing traversal.
-        """
-        code = compile(
-            source="zipfile.Path(alpharep) / 'a'",
-            filename="(test)",
-            mode="eval",
-            dont_inherit=True,
-        )
-        eval(code)
-
-    @pass_alpharep
-    def test_pathlike_construction(self, alpharep):
-        """
-        zipfile.Path should be constructable from a path-like object
-        """
-        zipfile_ondisk = self.zipfile_ondisk(alpharep)
-        pathlike = pathlib.Path(str(zipfile_ondisk))
-        zipfile.Path(pathlike)
-
-    @pass_alpharep
-    def test_traverse_pathlike(self, alpharep):
-        root = zipfile.Path(alpharep)
-        root / pathlib.Path("a")
-
-    @pass_alpharep
-    def test_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'a').parent.at == ''
-        assert (root / 'a' / 'b').parent.at == 'a/'
-
-    @pass_alpharep
-    def test_dir_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'b').parent.at == ''
-        assert (root / 'b/').parent.at == ''
-
-    @pass_alpharep
-    def test_missing_dir_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert (root / 'missing dir/').parent.at == ''
-
-    @pass_alpharep
-    def test_mutability(self, alpharep):
-        """
-        If the underlying zipfile is changed, the Path object should
-        reflect that change.
-        """
-        root = zipfile.Path(alpharep)
-        a, b, g = root.iterdir()
-        alpharep.writestr('foo.txt', 'foo')
-        alpharep.writestr('bar/baz.txt', 'baz')
-        assert any(child.name == 'foo.txt' for child in root.iterdir())
-        assert (root / 'foo.txt').read_text(encoding="utf-8") == 'foo'
-        (baz,) = (root / 'bar').iterdir()
-        assert baz.read_text(encoding="utf-8") == 'baz'
-
-    HUGE_ZIPFILE_NUM_ENTRIES = 2 ** 13
-
-    def huge_zipfile(self):
-        """Create a read-only zipfile with a huge number of entries entries."""
-        strm = io.BytesIO()
-        zf = zipfile.ZipFile(strm, "w")
-        for entry in map(str, range(self.HUGE_ZIPFILE_NUM_ENTRIES)):
-            zf.writestr(entry, entry)
-        zf.mode = 'r'
-        return zf
-
-    def test_joinpath_constant_time(self):
-        """
-        Ensure joinpath on items in zipfile is linear time.
-        """
-        root = zipfile.Path(self.huge_zipfile())
-        entries = jaraco.itertools.Counter(root.iterdir())
-        for entry in entries:
-            entry.joinpath('suffix')
-        # Check the file iterated all items
-        assert entries.count == self.HUGE_ZIPFILE_NUM_ENTRIES
-
-    # @func_timeout.func_set_timeout(3)
-    def test_implied_dirs_performance(self):
-        data = ['/'.join(string.ascii_lowercase + str(n)) for n in range(10000)]
-        zipfile.CompleteDirs._implied_dirs(data)
-
-    @pass_alpharep
-    def test_read_does_not_close(self, alpharep):
-        alpharep = self.zipfile_ondisk(alpharep)
-        with zipfile.ZipFile(alpharep) as file:
-            for rep in range(2):
-                zipfile.Path(file, 'a.txt').read_text(encoding="utf-8")
-
-    @pass_alpharep
-    def test_subclass(self, alpharep):
-        class Subclass(zipfile.Path):
-            pass
-
-        root = Subclass(alpharep)
-        assert isinstance(root / 'b', Subclass)
-
-    @pass_alpharep
-    def test_filename(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.filename == pathlib.Path('alpharep.zip')
-
-    @pass_alpharep
-    def test_root_name(self, alpharep):
-        """
-        The name of the root should be the name of the zipfile
-        """
-        root = zipfile.Path(alpharep)
-        assert root.name == 'alpharep.zip' == root.filename.name
-
-    @pass_alpharep
-    def test_root_parent(self, alpharep):
-        root = zipfile.Path(alpharep)
-        assert root.parent == pathlib.Path('.')
-        root.root.filename = 'foo/bar.zip'
-        assert root.parent == pathlib.Path('foo')
-
-    @pass_alpharep
-    def test_root_unnamed(self, alpharep):
-        """
-        It is an error to attempt to get the name
-        or parent of an unnamed zipfile.
-        """
-        alpharep.filename = None
-        root = zipfile.Path(alpharep)
-        with self.assertRaises(TypeError):
-            root.name
-        with self.assertRaises(TypeError):
-            root.parent
-
-        # .name and .parent should still work on subs
-        sub = root / "b"
-        assert sub.name == "b"
-        assert sub.parent
-
-    @pass_alpharep
-    def test_inheritance(self, alpharep):
-        cls = type('PathChild', (zipfile.Path,), {})
-        for alpharep in self.zipfile_alpharep():
-            file = cls(alpharep).joinpath('some dir').parent
-            assert isinstance(file, cls)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/Lib/test/test_zipfile/__init__.py b/Lib/test/test_zipfile/__init__.py
new file mode 100644
index 0000000000..4b16ecc311
--- /dev/null
+++ b/Lib/test/test_zipfile/__init__.py
@@ -0,0 +1,5 @@
+import os
+from test.support import load_package_tests
+
+def load_tests(*args):
+    return load_package_tests(os.path.dirname(__file__), *args)
diff --git a/Lib/test/test_zipfile/__main__.py b/Lib/test/test_zipfile/__main__.py
new file mode 100644
index 0000000000..e25ac946ed
--- /dev/null
+++ b/Lib/test/test_zipfile/__main__.py
@@ -0,0 +1,7 @@
+import unittest
+
+from . import load_tests  # noqa: F401
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_zipfile/_path/__init__.py b/Lib/test/test_zipfile/_path/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/Lib/test/test_zipfile/_path/_functools.py b/Lib/test/test_zipfile/_path/_functools.py
new file mode 100644
index 0000000000..75f2b20e06
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_functools.py
@@ -0,0 +1,9 @@
+import functools
+
+
+# from jaraco.functools 3.5.2
+def compose(*funcs):
+    def compose_two(f1, f2):
+        return lambda *args, **kwargs: f1(f2(*args, **kwargs))
+
+    return functools.reduce(compose_two, funcs)
diff --git a/Lib/test/test_zipfile/_path/_itertools.py b/Lib/test/test_zipfile/_path/_itertools.py
new file mode 100644
index 0000000000..f735dd2173
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_itertools.py
@@ -0,0 +1,79 @@
+import itertools
+from collections import deque
+from itertools import islice
+
+
+# from jaraco.itertools 6.3.0
+class Counter:
+    """
+    Wrap an iterable in an object that stores the count of items
+    that pass through it.
+
+    >>> items = Counter(range(20))
+    >>> items.count
+    0
+    >>> values = list(items)
+    >>> items.count
+    20
+    """
+
+    def __init__(self, i):
+        self.count = 0
+        self.iter = zip(itertools.count(1), i)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        self.count, result = next(self.iter)
+        return result
+
+
+# from more_itertools v8.13.0
+def always_iterable(obj, base_type=(str, bytes)):
+    if obj is None:
+        return iter(())
+
+    if (base_type is not None) and isinstance(obj, base_type):
+        return iter((obj,))
+
+    try:
+        return iter(obj)
+    except TypeError:
+        return iter((obj,))
+
+
+# from more_itertools v9.0.0
+def consume(iterator, n=None):
+    """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
+    entirely.
+    Efficiently exhausts an iterator without returning values. Defaults to
+    consuming the whole iterator, but an optional second argument may be
+    provided to limit consumption.
+        >>> i = (x for x in range(10))
+        >>> next(i)
+        0
+        >>> consume(i, 3)
+        >>> next(i)
+        4
+        >>> consume(i)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+    If the iterator has fewer items remaining than the provided limit, the
+    whole iterator will be consumed.
+        >>> i = (x for x in range(3))
+        >>> consume(i, 5)
+        >>> next(i)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+        StopIteration
+    """
+    # Use functions that consume iterators at C speed.
+    if n is None:
+        # feed the entire iterator into a zero-length deque
+        deque(iterator, maxlen=0)
+    else:
+        # advance to the empty slice starting at position n
+        next(islice(iterator, n, n), None)
diff --git a/Lib/test/test_zipfile/_path/_support.py b/Lib/test/test_zipfile/_path/_support.py
new file mode 100644
index 0000000000..1afdf3b3a7
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_support.py
@@ -0,0 +1,9 @@
+import importlib
+import unittest
+
+
+def import_or_skip(name):
+    try:
+        return importlib.import_module(name)
+    except ImportError:  # pragma: no cover
+        raise unittest.SkipTest(f'Unable to import {name}')
diff --git a/Lib/test/test_zipfile/_path/_test_params.py b/Lib/test/test_zipfile/_path/_test_params.py
new file mode 100644
index 0000000000..00a9eaf2f9
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/_test_params.py
@@ -0,0 +1,39 @@
+import functools
+import types
+
+from ._itertools import always_iterable
+
+
+def parameterize(names, value_groups):
+    """
+    Decorate a test method to run it as a set of subtests.
+
+    Modeled after pytest.parametrize.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapped(self):
+            for values in value_groups:
+                resolved = map(Invoked.eval, always_iterable(values))
+                params = dict(zip(always_iterable(names), resolved))
+                with self.subTest(**params):
+                    func(self, **params)
+
+        return wrapped
+
+    return decorator
+
+
+class Invoked(types.SimpleNamespace):
+    """
+    Wrap a function to be invoked for each usage.
+    """
+
+    @classmethod
+    def wrap(cls, func):
+        return cls(func=func)
+
+    @classmethod
+    def eval(cls, cand):
+        return cand.func() if isinstance(cand, cls) else cand
diff --git a/Lib/test/test_zipfile/_path/test_complexity.py b/Lib/test/test_zipfile/_path/test_complexity.py
new file mode 100644
index 0000000000..7c108fc6ab
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/test_complexity.py
@@ -0,0 +1,105 @@
+import io
+import itertools
+import math
+import re
+import string
+import unittest
+import zipfile
+
+from ._functools import compose
+from ._itertools import consume
+from ._support import import_or_skip
+
+big_o = import_or_skip('big_o')
+pytest = import_or_skip('pytest')
+
+
+class TestComplexity(unittest.TestCase):
+    @pytest.mark.flaky
+    def test_implied_dirs_performance(self):
+        best, others = big_o.big_o(
+            compose(consume, zipfile._path.CompleteDirs._implied_dirs),
+            lambda size: [
+                '/'.join(string.ascii_lowercase + str(n)) for n in range(size)
+            ],
+            max_n=1000,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    def make_zip_path(self, depth=1, width=1) -> zipfile.Path:
+        """
+        Construct a Path with width files at every level of depth.
+        """
+        zf = zipfile.ZipFile(io.BytesIO(), mode='w')
+        pairs = itertools.product(self.make_deep_paths(depth), self.make_names(width))
+        for path, name in pairs:
+            zf.writestr(f"{path}{name}.txt", b'')
+        zf.filename = "big un.zip"
+        return zipfile.Path(zf)
+
+    @classmethod
+    def make_names(cls, width, letters=string.ascii_lowercase):
+        """
+        >>> list(TestComplexity.make_names(1))
+        ['a']
+        >>> list(TestComplexity.make_names(2))
+        ['a', 'b']
+        >>> list(TestComplexity.make_names(30))
+        ['aa', 'ab', ..., 'bd']
+        >>> list(TestComplexity.make_names(17124))
+        ['aaa', 'aab', ..., 'zip']
+        """
+        # determine how many products are needed to produce width
+        n_products = max(1, math.ceil(math.log(width, len(letters))))
+        inputs = (letters,) * n_products
+        combinations = itertools.product(*inputs)
+        names = map(''.join, combinations)
+        return itertools.islice(names, width)
+
+    @classmethod
+    def make_deep_paths(cls, depth):
+        return map(cls.make_deep_path, range(depth))
+
+    @classmethod
+    def make_deep_path(cls, depth):
+        return ''.join(('d/',) * depth)
+
+    def test_baseline_regex_complexity(self):
+        best, others = big_o.big_o(
+            lambda path: re.fullmatch(r'[^/]*\\.txt', path),
+            self.make_deep_path,
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Constant
+
+    @pytest.mark.flaky
+    def test_glob_depth(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            self.make_zip_path,
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    @pytest.mark.flaky
+    def test_glob_width(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            lambda size: self.make_zip_path(width=size),
+            max_n=100,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
+
+    @pytest.mark.flaky
+    def test_glob_width_and_depth(self):
+        best, others = big_o.big_o(
+            lambda path: consume(path.glob('*.txt')),
+            lambda size: self.make_zip_path(depth=size, width=size),
+            max_n=10,
+            min_n=1,
+        )
+        assert best <= big_o.complexities.Linear
diff --git a/Lib/test/test_zipfile/_path/test_path.py b/Lib/test/test_zipfile/_path/test_path.py
new file mode 100644
index 0000000000..5c69c77f7d
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/test_path.py
@@ -0,0 +1,692 @@
+import contextlib
+import io
+import itertools
+import pathlib
+import pickle
+import stat
+import sys
+import time
+import unittest
+import zipfile
+import zipfile._path
+
+from test.support.os_helper import FakePath, temp_dir
+
+from ._functools import compose
+from ._itertools import Counter
+from ._test_params import Invoked, parameterize
+
+
+class jaraco:
+    class itertools:
+        Counter = Counter
+
+
+def _make_link(info: zipfile.ZipInfo):  # type: ignore[name-defined]
+    info.external_attr |= stat.S_IFLNK << 16
+
+
+def build_alpharep_fixture():
+    """
+    Create a zip file with this structure:
+
+    .
+    ├── a.txt
+    ├── n.txt (-> a.txt)
+    ├── b
+    │   ├── c.txt
+    │   ├── d
+    │   │   └── e.txt
+    │   └── f.txt
+    ├── g
+    │   └── h
+    │       └── i.txt
+    └── j
+        ├── k.bin
+        ├── l.baz
+        └── m.bar
+
+    This fixture has the following key characteristics:
+
+    - a file at the root (a)
+    - a file two levels deep (b/d/e)
+    - multiple files in a directory (b/c, b/f)
+    - a directory containing only a directory (g/h)
+    - a directory with files of different extensions (j/klm)
+    - a symlink (n) pointing to (a)
+
+    "alpha" because it uses alphabet
+    "rep" because it's a representative example
+    """
+    data = io.BytesIO()
+    zf = zipfile.ZipFile(data, "w")
+    zf.writestr("a.txt", b"content of a")
+    zf.writestr("b/c.txt", b"content of c")
+    zf.writestr("b/d/e.txt", b"content of e")
+    zf.writestr("b/f.txt", b"content of f")
+    zf.writestr("g/h/i.txt", b"content of i")
+    zf.writestr("j/k.bin", b"content of k")
+    zf.writestr("j/l.baz", b"content of l")
+    zf.writestr("j/m.bar", b"content of m")
+    zf.writestr("n.txt", b"a.txt")
+    _make_link(zf.infolist()[-1])
+
+    zf.filename = "alpharep.zip"
+    return zf
+
+
+alpharep_generators = [
+    Invoked.wrap(build_alpharep_fixture),
+    Invoked.wrap(compose(zipfile._path.CompleteDirs.inject, build_alpharep_fixture)),
+]
+
+pass_alpharep = parameterize(['alpharep'], alpharep_generators)
+
+
+class TestPath(unittest.TestCase):
+    def setUp(self):
+        self.fixtures = contextlib.ExitStack()
+        self.addCleanup(self.fixtures.close)
+
+    def zipfile_ondisk(self, alpharep):
+        tmpdir = pathlib.Path(self.fixtures.enter_context(temp_dir()))
+        buffer = alpharep.fp
+        alpharep.close()
+        path = tmpdir / alpharep.filename
+        with path.open("wb") as strm:
+            strm.write(buffer.getvalue())
+        return path
+
+    @pass_alpharep
+    def test_iterdir_and_types(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.is_dir()
+        a, n, b, g, j = root.iterdir()
+        assert a.is_file()
+        assert b.is_dir()
+        assert g.is_dir()
+        c, f, d = b.iterdir()
+        assert c.is_file() and f.is_file()
+        (e,) = d.iterdir()
+        assert e.is_file()
+        (h,) = g.iterdir()
+        (i,) = h.iterdir()
+        assert i.is_file()
+
+    @pass_alpharep
+    def test_is_file_missing(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.joinpath('missing.txt').is_file()
+
+    @pass_alpharep
+    def test_iterdir_on_file(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        with self.assertRaises(ValueError):
+            a.iterdir()
+
+    @pass_alpharep
+    def test_subdir_is_dir(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'b').is_dir()
+        assert (root / 'b/').is_dir()
+        assert (root / 'g').is_dir()
+        assert (root / 'g/').is_dir()
+
+    @pass_alpharep
+    def test_open(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        with a.open(encoding="utf-8") as strm:
+            data = strm.read()
+        self.assertEqual(data, "content of a")
+        with a.open('r', "utf-8") as strm:  # not a kw, no gh-101144 TypeError
+            data = strm.read()
+        self.assertEqual(data, "content of a")
+
+    def test_open_encoding_utf16(self):
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.writestr("path/16.txt", "This was utf-16".encode("utf-16"))
+        zf.filename = "test_open_utf16.zip"
+        root = zipfile.Path(zf)
+        (path,) = root.iterdir()
+        u16 = path.joinpath("16.txt")
+        with u16.open('r', "utf-16") as strm:
+            data = strm.read()
+        assert data == "This was utf-16"
+        with u16.open(encoding="utf-16") as strm:
+            data = strm.read()
+        assert data == "This was utf-16"
+
+    def test_open_encoding_errors(self):
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.writestr("path/bad-utf8.bin", b"invalid utf-8: \xff\xff.")
+        zf.filename = "test_read_text_encoding_errors.zip"
+        root = zipfile.Path(zf)
+        (path,) = root.iterdir()
+        u16 = path.joinpath("bad-utf8.bin")
+
+        # encoding= as a positional argument for gh-101144.
+        data = u16.read_text("utf-8", errors="ignore")
+        assert data == "invalid utf-8: ."
+        with u16.open("r", "utf-8", errors="surrogateescape") as f:
+            assert f.read() == "invalid utf-8: \udcff\udcff."
+
+        # encoding= both positional and keyword is an error; gh-101144.
+        with self.assertRaisesRegex(TypeError, "encoding"):
+            data = u16.read_text("utf-8", encoding="utf-8")
+
+        # both keyword arguments work.
+        with u16.open("r", encoding="utf-8", errors="strict") as f:
+            # error during decoding with wrong codec.
+            with self.assertRaises(UnicodeDecodeError):
+                f.read()
+
+    @unittest.skipIf(
+        not getattr(sys.flags, 'warn_default_encoding', 0),
+        "Requires warn_default_encoding",
+    )
+    @pass_alpharep
+    def test_encoding_warnings(self, alpharep):
+        """EncodingWarning must blame the read_text and open calls."""
+        assert sys.flags.warn_default_encoding
+        root = zipfile.Path(alpharep)
+        with self.assertWarns(EncodingWarning) as wc:  # noqa: F821 (astral-sh/ruff#13296)
+            root.joinpath("a.txt").read_text()
+        assert __file__ == wc.filename
+        with self.assertWarns(EncodingWarning) as wc:  # noqa: F821 (astral-sh/ruff#13296)
+            root.joinpath("a.txt").open("r").close()
+        assert __file__ == wc.filename
+
+    def test_open_write(self):
+        """
+        If the zipfile is open for write, it should be possible to
+        write bytes or text to it.
+        """
+        zf = zipfile.Path(zipfile.ZipFile(io.BytesIO(), mode='w'))
+        with zf.joinpath('file.bin').open('wb') as strm:
+            strm.write(b'binary contents')
+        with zf.joinpath('file.txt').open('w', encoding="utf-8") as strm:
+            strm.write('text file')
+
+    @pass_alpharep
+    def test_open_extant_directory(self, alpharep):
+        """
+        Attempting to open a directory raises IsADirectoryError.
+        """
+        zf = zipfile.Path(alpharep)
+        with self.assertRaises(IsADirectoryError):
+            zf.joinpath('b').open()
+
+    @pass_alpharep
+    def test_open_binary_invalid_args(self, alpharep):
+        root = zipfile.Path(alpharep)
+        with self.assertRaises(ValueError):
+            root.joinpath('a.txt').open('rb', encoding='utf-8')
+        with self.assertRaises(ValueError):
+            root.joinpath('a.txt').open('rb', 'utf-8')
+
+    @pass_alpharep
+    def test_open_missing_directory(self, alpharep):
+        """
+        Attempting to open a missing directory raises FileNotFoundError.
+        """
+        zf = zipfile.Path(alpharep)
+        with self.assertRaises(FileNotFoundError):
+            zf.joinpath('z').open()
+
+    @pass_alpharep
+    def test_read(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        assert a.read_text(encoding="utf-8") == "content of a"
+        # Also check positional encoding arg (gh-101144).
+        assert a.read_text("utf-8") == "content of a"
+        assert a.read_bytes() == b"content of a"
+
+    @pass_alpharep
+    def test_joinpath(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a = root.joinpath("a.txt")
+        assert a.is_file()
+        e = root.joinpath("b").joinpath("d").joinpath("e.txt")
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_joinpath_multiple(self, alpharep):
+        root = zipfile.Path(alpharep)
+        e = root.joinpath("b", "d", "e.txt")
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_traverse_truediv(self, alpharep):
+        root = zipfile.Path(alpharep)
+        a = root / "a.txt"
+        assert a.is_file()
+        e = root / "b" / "d" / "e.txt"
+        assert e.read_text(encoding="utf-8") == "content of e"
+
+    @pass_alpharep
+    def test_pathlike_construction(self, alpharep):
+        """
+        zipfile.Path should be constructable from a path-like object
+        """
+        zipfile_ondisk = self.zipfile_ondisk(alpharep)
+        pathlike = FakePath(str(zipfile_ondisk))
+        root = zipfile.Path(pathlike)
+        root.root.close()
+
+    @pass_alpharep
+    def test_traverse_pathlike(self, alpharep):
+        root = zipfile.Path(alpharep)
+        root / FakePath("a")
+
+    @pass_alpharep
+    def test_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'a').parent.at == ''
+        assert (root / 'a' / 'b').parent.at == 'a/'
+
+    @pass_alpharep
+    def test_dir_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'b').parent.at == ''
+        assert (root / 'b/').parent.at == ''
+
+    @pass_alpharep
+    def test_missing_dir_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert (root / 'missing dir/').parent.at == ''
+
+    @pass_alpharep
+    def test_mutability(self, alpharep):
+        """
+        If the underlying zipfile is changed, the Path object should
+        reflect that change.
+        """
+        root = zipfile.Path(alpharep)
+        a, n, b, g, j = root.iterdir()
+        alpharep.writestr('foo.txt', 'foo')
+        alpharep.writestr('bar/baz.txt', 'baz')
+        assert any(child.name == 'foo.txt' for child in root.iterdir())
+        assert (root / 'foo.txt').read_text(encoding="utf-8") == 'foo'
+        (baz,) = (root / 'bar').iterdir()
+        assert baz.read_text(encoding="utf-8") == 'baz'
+
+    HUGE_ZIPFILE_NUM_ENTRIES = 2**13
+
+    def huge_zipfile(self):
+        """Create a read-only zipfile with a huge number of entries entries."""
+        strm = io.BytesIO()
+        zf = zipfile.ZipFile(strm, "w")
+        for entry in map(str, range(self.HUGE_ZIPFILE_NUM_ENTRIES)):
+            zf.writestr(entry, entry)
+        zf.mode = 'r'
+        return zf
+
+    def test_joinpath_constant_time(self):
+        """
+        Ensure joinpath on items in zipfile is linear time.
+        """
+        root = zipfile.Path(self.huge_zipfile())
+        entries = jaraco.itertools.Counter(root.iterdir())
+        for entry in entries:
+            entry.joinpath('suffix')
+        # Check the file iterated all items
+        assert entries.count == self.HUGE_ZIPFILE_NUM_ENTRIES
+
+    @pass_alpharep
+    def test_read_does_not_close(self, alpharep):
+        alpharep = self.zipfile_ondisk(alpharep)
+        with zipfile.ZipFile(alpharep) as file:
+            for rep in range(2):
+                zipfile.Path(file, 'a.txt').read_text(encoding="utf-8")
+
+    @pass_alpharep
+    def test_subclass(self, alpharep):
+        class Subclass(zipfile.Path):
+            pass
+
+        root = Subclass(alpharep)
+        assert isinstance(root / 'b', Subclass)
+
+    @pass_alpharep
+    def test_filename(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.filename == pathlib.Path('alpharep.zip')
+
+    @pass_alpharep
+    def test_root_name(self, alpharep):
+        """
+        The name of the root should be the name of the zipfile
+        """
+        root = zipfile.Path(alpharep)
+        assert root.name == 'alpharep.zip' == root.filename.name
+
+    @pass_alpharep
+    def test_root_on_disk(self, alpharep):
+        """
+        The name/stem of the root should match the zipfile on disk.
+
+        This condition must hold across platforms.
+        """
+        root = zipfile.Path(self.zipfile_ondisk(alpharep))
+        assert root.name == 'alpharep.zip' == root.filename.name
+        assert root.stem == 'alpharep' == root.filename.stem
+        root.root.close()
+
+    @pass_alpharep
+    def test_suffix(self, alpharep):
+        """
+        The suffix of the root should be the suffix of the zipfile.
+        The suffix of each nested file is the final component's last suffix, if any.
+        Includes the leading period, just like pathlib.Path.
+        """
+        root = zipfile.Path(alpharep)
+        assert root.suffix == '.zip' == root.filename.suffix
+
+        b = root / "b.txt"
+        assert b.suffix == ".txt"
+
+        c = root / "c" / "filename.tar.gz"
+        assert c.suffix == ".gz"
+
+        d = root / "d"
+        assert d.suffix == ""
+
+    @pass_alpharep
+    def test_suffixes(self, alpharep):
+        """
+        The suffix of the root should be the suffix of the zipfile.
+        The suffix of each nested file is the final component's last suffix, if any.
+        Includes the leading period, just like pathlib.Path.
+        """
+        root = zipfile.Path(alpharep)
+        assert root.suffixes == ['.zip'] == root.filename.suffixes
+
+        b = root / 'b.txt'
+        assert b.suffixes == ['.txt']
+
+        c = root / 'c' / 'filename.tar.gz'
+        assert c.suffixes == ['.tar', '.gz']
+
+        d = root / 'd'
+        assert d.suffixes == []
+
+        e = root / '.hgrc'
+        assert e.suffixes == []
+
+    @pass_alpharep
+    def test_suffix_no_filename(self, alpharep):
+        alpharep.filename = None
+        root = zipfile.Path(alpharep)
+        assert root.joinpath('example').suffix == ""
+        assert root.joinpath('example').suffixes == []
+
+    @pass_alpharep
+    def test_stem(self, alpharep):
+        """
+        The final path component, without its suffix
+        """
+        root = zipfile.Path(alpharep)
+        assert root.stem == 'alpharep' == root.filename.stem
+
+        b = root / "b.txt"
+        assert b.stem == "b"
+
+        c = root / "c" / "filename.tar.gz"
+        assert c.stem == "filename.tar"
+
+        d = root / "d"
+        assert d.stem == "d"
+
+        assert (root / ".gitignore").stem == ".gitignore"
+
+    @pass_alpharep
+    def test_root_parent(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root.parent == pathlib.Path('.')
+        root.root.filename = 'foo/bar.zip'
+        assert root.parent == pathlib.Path('foo')
+
+    @pass_alpharep
+    def test_root_unnamed(self, alpharep):
+        """
+        It is an error to attempt to get the name
+        or parent of an unnamed zipfile.
+        """
+        alpharep.filename = None
+        root = zipfile.Path(alpharep)
+        with self.assertRaises(TypeError):
+            root.name
+        with self.assertRaises(TypeError):
+            root.parent
+
+        # .name and .parent should still work on subs
+        sub = root / "b"
+        assert sub.name == "b"
+        assert sub.parent
+
+    @pass_alpharep
+    def test_match_and_glob(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.match("*.txt")
+
+        assert list(root.glob("b/c.*")) == [zipfile.Path(alpharep, "b/c.txt")]
+        assert list(root.glob("b/*.txt")) == [
+            zipfile.Path(alpharep, "b/c.txt"),
+            zipfile.Path(alpharep, "b/f.txt"),
+        ]
+
+    @pass_alpharep
+    def test_glob_recursive(self, alpharep):
+        root = zipfile.Path(alpharep)
+        files = root.glob("**/*.txt")
+        assert all(each.match("*.txt") for each in files)
+
+        assert list(root.glob("**/*.txt")) == list(root.rglob("*.txt"))
+
+    @pass_alpharep
+    def test_glob_dirs(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert list(root.glob('b')) == [zipfile.Path(alpharep, "b/")]
+        assert list(root.glob('b*')) == [zipfile.Path(alpharep, "b/")]
+
+    @pass_alpharep
+    def test_glob_subdir(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert list(root.glob('g/h')) == [zipfile.Path(alpharep, "g/h/")]
+        assert list(root.glob('g*/h*')) == [zipfile.Path(alpharep, "g/h/")]
+
+    @pass_alpharep
+    def test_glob_subdirs(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("*/i.txt")) == []
+        assert list(root.rglob("*/i.txt")) == [zipfile.Path(alpharep, "g/h/i.txt")]
+
+    @pass_alpharep
+    def test_glob_does_not_overmatch_dot(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("*.xt")) == []
+
+    @pass_alpharep
+    def test_glob_single_char(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("a?txt")) == [zipfile.Path(alpharep, "a.txt")]
+        assert list(root.glob("a[.]txt")) == [zipfile.Path(alpharep, "a.txt")]
+        assert list(root.glob("a[?]txt")) == []
+
+    @pass_alpharep
+    def test_glob_chars(self, alpharep):
+        root = zipfile.Path(alpharep)
+
+        assert list(root.glob("j/?.b[ai][nz]")) == [
+            zipfile.Path(alpharep, "j/k.bin"),
+            zipfile.Path(alpharep, "j/l.baz"),
+        ]
+
+    def test_glob_empty(self):
+        root = zipfile.Path(zipfile.ZipFile(io.BytesIO(), 'w'))
+        with self.assertRaises(ValueError):
+            root.glob('')
+
+    @pass_alpharep
+    def test_eq_hash(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert root == zipfile.Path(alpharep)
+
+        assert root != (root / "a.txt")
+        assert (root / "a.txt") == (root / "a.txt")
+
+        root = zipfile.Path(alpharep)
+        assert root in {root}
+
+    @pass_alpharep
+    def test_is_symlink(self, alpharep):
+        root = zipfile.Path(alpharep)
+        assert not root.joinpath('a.txt').is_symlink()
+        assert root.joinpath('n.txt').is_symlink()
+
+    @pass_alpharep
+    def test_relative_to(self, alpharep):
+        root = zipfile.Path(alpharep)
+        relative = root.joinpath("b", "c.txt").relative_to(root / "b")
+        assert str(relative) == "c.txt"
+
+        relative = root.joinpath("b", "d", "e.txt").relative_to(root / "b")
+        assert str(relative) == "d/e.txt"
+
+    @pass_alpharep
+    def test_inheritance(self, alpharep):
+        cls = type('PathChild', (zipfile.Path,), {})
+        file = cls(alpharep).joinpath('some dir').parent
+        assert isinstance(file, cls)
+
+    @unittest.skipIf(sys.platform == 'win32', 'TODO: RUSTPYTHON; fails on Windows')
+    @parameterize(
+        ['alpharep', 'path_type', 'subpath'],
+        itertools.product(
+            alpharep_generators,
+            [str, FakePath],
+            ['', 'b/'],
+        ),
+    )
+    def test_pickle(self, alpharep, path_type, subpath):
+        zipfile_ondisk = path_type(str(self.zipfile_ondisk(alpharep)))
+        root = zipfile.Path(zipfile_ondisk, at=subpath)
+        saved_1 = pickle.dumps(root)
+        root.root.close()
+        restored_1 = pickle.loads(saved_1)
+        first, *rest = restored_1.iterdir()
+        assert first.read_text(encoding='utf-8').startswith('content of ')
+        restored_1.root.close()
+
+    @pass_alpharep
+    def test_extract_orig_with_implied_dirs(self, alpharep):
+        """
+        A zip file wrapped in a Path should extract even with implied dirs.
+        """
+        source_path = self.zipfile_ondisk(alpharep)
+        zf = zipfile.ZipFile(source_path)
+        # wrap the zipfile for its side effect
+        zipfile.Path(zf)
+        zf.extractall(source_path.parent)
+        zf.close()
+
+    @pass_alpharep
+    def test_getinfo_missing(self, alpharep):
+        """
+        Validate behavior of getinfo on original zipfile after wrapping.
+        """
+        zipfile.Path(alpharep)
+        with self.assertRaises(KeyError):
+            alpharep.getinfo('does-not-exist')
+
+    def test_malformed_paths(self):
+        """
+        Path should handle malformed paths gracefully.
+
+        Paths with leading slashes are not visible.
+
+        Paths with dots are treated like regular files.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr("/one-slash.txt", b"content")
+        zf.writestr("//two-slash.txt", b"content")
+        zf.writestr("../parent.txt", b"content")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        assert list(map(str, root.iterdir())) == ['../']
+        assert root.joinpath('..').joinpath('parent.txt').read_bytes() == b'content'
+
+    def test_unsupported_names(self):
+        """
+        Path segments with special characters are readable.
+
+        On some platforms or file systems, characters like
+        ``:`` and ``?`` are not allowed, but they are valid
+        in the zip file.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr("path?", b"content")
+        zf.writestr("V: NMS.flac", b"fLaC...")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        contents = root.iterdir()
+        assert next(contents).name == 'path?'
+        assert next(contents).name == 'V: NMS.flac'
+        assert root.joinpath('V: NMS.flac').read_bytes() == b"fLaC..."
+
+    def test_backslash_not_separator(self):
+        """
+        In a zip file, backslashes are not separators.
+        """
+        data = io.BytesIO()
+        zf = zipfile.ZipFile(data, "w")
+        zf.writestr(DirtyZipInfo.for_name("foo\\bar", zf), b"content")
+        zf.filename = ''
+        root = zipfile.Path(zf)
+        (first,) = root.iterdir()
+        assert not first.is_dir()
+        assert first.name == 'foo\\bar'
+
+    @pass_alpharep
+    def test_interface(self, alpharep):
+        from importlib.resources.abc import Traversable
+
+        zf = zipfile.Path(alpharep)
+        assert isinstance(zf, Traversable)
+
+
+class DirtyZipInfo(zipfile.ZipInfo):
+    """
+    Bypass name sanitization.
+    """
+
+    def __init__(self, filename, *args, **kwargs):
+        super().__init__(filename, *args, **kwargs)
+        self.filename = filename
+
+    @classmethod
+    def for_name(cls, name, archive):
+        """
+        Construct the same way that ZipFile.writestr does.
+
+        TODO: extract this functionality and re-use
+        """
+        self = cls(filename=name, date_time=time.localtime(time.time())[:6])
+        self.compress_type = archive.compression
+        self.compress_level = archive.compresslevel
+        if self.filename.endswith('/'):  # pragma: no cover
+            self.external_attr = 0o40775 << 16  # drwxrwxr-x
+            self.external_attr |= 0x10  # MS-DOS directory flag
+        else:
+            self.external_attr = 0o600 << 16  # ?rw-------
+        return self
diff --git a/Lib/test/test_zipfile/_path/write-alpharep.py b/Lib/test/test_zipfile/_path/write-alpharep.py
new file mode 100644
index 0000000000..7418391aba
--- /dev/null
+++ b/Lib/test/test_zipfile/_path/write-alpharep.py
@@ -0,0 +1,3 @@
+from . import test_path
+
+__name__ == '__main__' and test_path.build_alpharep_fixture().extractall('alpharep')
diff --git a/Lib/test/test_zipfile/test_core.py b/Lib/test/test_zipfile/test_core.py
new file mode 100644
index 0000000000..63413d7b94
--- /dev/null
+++ b/Lib/test/test_zipfile/test_core.py
@@ -0,0 +1,3738 @@
+import _pyio
+import array
+import contextlib
+import importlib.util
+import io
+import itertools
+import os
+import posixpath
+import struct
+import subprocess
+import sys
+import time
+import unittest
+import unittest.mock as mock
+import zipfile
+
+
+from tempfile import TemporaryFile
+from random import randint, random, randbytes
+
+from test import archiver_tests
+from test.support import script_helper
+from test.support import (
+    findfile, requires_zlib, requires_bz2, requires_lzma,
+    captured_stdout, captured_stderr, requires_subprocess
+)
+from test.support.os_helper import (
+    TESTFN, unlink, rmtree, temp_dir, temp_cwd, fd_count, FakePath
+)
+
+
+TESTFN2 = TESTFN + "2"
+TESTFNDIR = TESTFN + "d"
+FIXEDTEST_SIZE = 1000
+DATAFILES_DIR = 'zipfile_datafiles'
+
+SMALL_TEST_DATA = [('_ziptest1', '1q2w3e4r5t'),
+                   ('ziptest2dir/_ziptest2', 'qawsedrftg'),
+                   ('ziptest2dir/ziptest3dir/_ziptest3', 'azsxdcfvgb'),
+                   ('ziptest2dir/ziptest3dir/ziptest4dir/_ziptest3', '6y7u8i9o0p')]
+
+def get_files(test):
+    yield TESTFN2
+    with TemporaryFile() as f:
+        yield f
+        test.assertFalse(f.closed)
+    with io.BytesIO() as f:
+        yield f
+        test.assertFalse(f.closed)
+
+class AbstractTestsWithSourceFile:
+    @classmethod
+    def setUpClass(cls):
+        cls.line_gen = [bytes("Zipfile test line %d. random float: %f\n" %
+                              (i, random()), "ascii")
+                        for i in range(FIXEDTEST_SIZE)]
+        cls.data = b''.join(cls.line_gen)
+
+    def setUp(self):
+        # Make a source file with some lines
+        with open(TESTFN, "wb") as fp:
+            fp.write(self.data)
+
+    def make_test_archive(self, f, compression, compresslevel=None):
+        kwargs = {'compression': compression, 'compresslevel': compresslevel}
+        # Create the ZIP archive
+        with zipfile.ZipFile(f, "w", **kwargs) as zipfp:
+            zipfp.write(TESTFN, "another.name")
+            zipfp.write(TESTFN, TESTFN)
+            zipfp.writestr("strfile", self.data)
+            with zipfp.open('written-open-w', mode='w') as f:
+                for line in self.line_gen:
+                    f.write(line)
+
+    def zip_test(self, f, compression, compresslevel=None):
+        self.make_test_archive(f, compression, compresslevel)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            self.assertEqual(zipfp.read(TESTFN), self.data)
+            self.assertEqual(zipfp.read("another.name"), self.data)
+            self.assertEqual(zipfp.read("strfile"), self.data)
+
+            # Print the ZIP directory
+            fp = io.StringIO()
+            zipfp.printdir(file=fp)
+            directory = fp.getvalue()
+            lines = directory.splitlines()
+            self.assertEqual(len(lines), 5) # Number of files + header
+
+            self.assertIn('File Name', lines[0])
+            self.assertIn('Modified', lines[0])
+            self.assertIn('Size', lines[0])
+
+            fn, date, time_, size = lines[1].split()
+            self.assertEqual(fn, 'another.name')
+            self.assertTrue(time.strptime(date, '%Y-%m-%d'))
+            self.assertTrue(time.strptime(time_, '%H:%M:%S'))
+            self.assertEqual(size, str(len(self.data)))
+
+            # Check the namelist
+            names = zipfp.namelist()
+            self.assertEqual(len(names), 4)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
+            self.assertIn("written-open-w", names)
+
+            # Check infolist
+            infos = zipfp.infolist()
+            names = [i.filename for i in infos]
+            self.assertEqual(len(names), 4)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
+            self.assertIn("written-open-w", names)
+            for i in infos:
+                self.assertEqual(i.file_size, len(self.data))
+
+            # check getinfo
+            for nm in (TESTFN, "another.name", "strfile", "written-open-w"):
+                info = zipfp.getinfo(nm)
+                self.assertEqual(info.filename, nm)
+                self.assertEqual(info.file_size, len(self.data))
+
+            # Check that testzip thinks the archive is ok
+            # (it returns None if all contents could be read properly)
+            self.assertIsNone(zipfp.testzip())
+
+    def test_basic(self):
+        for f in get_files(self):
+            self.zip_test(f, self.compression)
+
+    def zip_open_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            zipdata1 = []
+            with zipfp.open(TESTFN) as zipopen1:
+                while True:
+                    read_data = zipopen1.read(256)
+                    if not read_data:
+                        break
+                    zipdata1.append(read_data)
+
+            zipdata2 = []
+            with zipfp.open("another.name") as zipopen2:
+                while True:
+                    read_data = zipopen2.read(256)
+                    if not read_data:
+                        break
+                    zipdata2.append(read_data)
+
+            self.assertEqual(b''.join(zipdata1), self.data)
+            self.assertEqual(b''.join(zipdata2), self.data)
+
+    def test_open(self):
+        for f in get_files(self):
+            self.zip_open_test(f, self.compression)
+
+    def test_open_with_pathlike(self):
+        path = FakePath(TESTFN2)
+        self.zip_open_test(path, self.compression)
+        with zipfile.ZipFile(path, "r", self.compression) as zipfp:
+            self.assertIsInstance(zipfp.filename, str)
+
+    def zip_random_open_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            zipdata1 = []
+            with zipfp.open(TESTFN) as zipopen1:
+                while True:
+                    read_data = zipopen1.read(randint(1, 1024))
+                    if not read_data:
+                        break
+                    zipdata1.append(read_data)
+
+            self.assertEqual(b''.join(zipdata1), self.data)
+
+    def test_random_open(self):
+        for f in get_files(self):
+            self.zip_random_open_test(f, self.compression)
+
+    def zip_read1_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp, \
+             zipfp.open(TESTFN) as zipopen:
+            zipdata = []
+            while True:
+                read_data = zipopen.read1(-1)
+                if not read_data:
+                    break
+                zipdata.append(read_data)
+
+        self.assertEqual(b''.join(zipdata), self.data)
+
+    def test_read1(self):
+        for f in get_files(self):
+            self.zip_read1_test(f, self.compression)
+
+    def zip_read1_10_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp, \
+             zipfp.open(TESTFN) as zipopen:
+            zipdata = []
+            while True:
+                read_data = zipopen.read1(10)
+                self.assertLessEqual(len(read_data), 10)
+                if not read_data:
+                    break
+                zipdata.append(read_data)
+
+        self.assertEqual(b''.join(zipdata), self.data)
+
+    def test_read1_10(self):
+        for f in get_files(self):
+            self.zip_read1_10_test(f, self.compression)
+
+    def zip_readline_read_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp, \
+             zipfp.open(TESTFN) as zipopen:
+            data = b''
+            while True:
+                read = zipopen.readline()
+                if not read:
+                    break
+                data += read
+
+                read = zipopen.read(100)
+                if not read:
+                    break
+                data += read
+
+        self.assertEqual(data, self.data)
+
+    def test_readline_read(self):
+        # Issue #7610: calls to readline() interleaved with calls to read().
+        for f in get_files(self):
+            self.zip_readline_read_test(f, self.compression)
+
+    def zip_readline_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp:
+            with zipfp.open(TESTFN) as zipopen:
+                for line in self.line_gen:
+                    linedata = zipopen.readline()
+                    self.assertEqual(linedata, line)
+
+    def test_readline(self):
+        for f in get_files(self):
+            self.zip_readline_test(f, self.compression)
+
+    def zip_readlines_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp:
+            with zipfp.open(TESTFN) as zipopen:
+                ziplines = zipopen.readlines()
+            for line, zipline in zip(self.line_gen, ziplines):
+                self.assertEqual(zipline, line)
+
+    def test_readlines(self):
+        for f in get_files(self):
+            self.zip_readlines_test(f, self.compression)
+
+    def zip_iterlines_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r") as zipfp:
+            with zipfp.open(TESTFN) as zipopen:
+                for line, zipline in zip(self.line_gen, zipopen):
+                    self.assertEqual(zipline, line)
+
+    def test_iterlines(self):
+        for f in get_files(self):
+            self.zip_iterlines_test(f, self.compression)
+
+    def test_low_compression(self):
+        """Check for cases where compressed data is larger than original."""
+        # Create the ZIP archive
+        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipfp:
+            zipfp.writestr("strfile", '12')
+
+        # Get an open object for strfile
+        with zipfile.ZipFile(TESTFN2, "r", self.compression) as zipfp:
+            with zipfp.open("strfile") as openobj:
+                self.assertEqual(openobj.read(1), b'1')
+                self.assertEqual(openobj.read(1), b'2')
+
+    def test_writestr_compression(self):
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            zipfp.writestr("b.txt", "hello world", compress_type=self.compression)
+            info = zipfp.getinfo('b.txt')
+            self.assertEqual(info.compress_type, self.compression)
+
+    def test_writestr_compresslevel(self):
+        with zipfile.ZipFile(TESTFN2, "w", compresslevel=1) as zipfp:
+            zipfp.writestr("a.txt", "hello world", compress_type=self.compression)
+            zipfp.writestr("b.txt", "hello world", compress_type=self.compression,
+                           compresslevel=2)
+
+            # Compression level follows the constructor.
+            a_info = zipfp.getinfo('a.txt')
+            self.assertEqual(a_info.compress_type, self.compression)
+            self.assertEqual(a_info.compress_level, 1)
+
+            # Compression level is overridden.
+            b_info = zipfp.getinfo('b.txt')
+            self.assertEqual(b_info.compress_type, self.compression)
+            self.assertEqual(b_info._compresslevel, 2)
+
+    def test_read_return_size(self):
+        # Issue #9837: ZipExtFile.read() shouldn't return more bytes
+        # than requested.
+        for test_size in (1, 4095, 4096, 4097, 16384):
+            file_size = test_size + 1
+            junk = randbytes(file_size)
+            with zipfile.ZipFile(io.BytesIO(), "w", self.compression) as zipf:
+                zipf.writestr('foo', junk)
+                with zipf.open('foo', 'r') as fp:
+                    buf = fp.read(test_size)
+                    self.assertEqual(len(buf), test_size)
+
+    def test_truncated_zipfile(self):
+        fp = io.BytesIO()
+        with zipfile.ZipFile(fp, mode='w') as zipf:
+            zipf.writestr('strfile', self.data, compress_type=self.compression)
+            end_offset = fp.tell()
+        zipfiledata = fp.getvalue()
+
+        fp = io.BytesIO(zipfiledata)
+        with zipfile.ZipFile(fp) as zipf:
+            with zipf.open('strfile') as zipopen:
+                fp.truncate(end_offset - 20)
+                with self.assertRaises(EOFError):
+                    zipopen.read()
+
+        fp = io.BytesIO(zipfiledata)
+        with zipfile.ZipFile(fp) as zipf:
+            with zipf.open('strfile') as zipopen:
+                fp.truncate(end_offset - 20)
+                with self.assertRaises(EOFError):
+                    while zipopen.read(100):
+                        pass
+
+        fp = io.BytesIO(zipfiledata)
+        with zipfile.ZipFile(fp) as zipf:
+            with zipf.open('strfile') as zipopen:
+                fp.truncate(end_offset - 20)
+                with self.assertRaises(EOFError):
+                    while zipopen.read1(100):
+                        pass
+
+    def test_repr(self):
+        fname = 'file.name'
+        for f in get_files(self):
+            with zipfile.ZipFile(f, 'w', self.compression) as zipfp:
+                zipfp.write(TESTFN, fname)
+                r = repr(zipfp)
+                self.assertIn("mode='w'", r)
+
+            with zipfile.ZipFile(f, 'r') as zipfp:
+                r = repr(zipfp)
+                if isinstance(f, str):
+                    self.assertIn('filename=%r' % f, r)
+                else:
+                    self.assertIn('file=%r' % f, r)
+                self.assertIn("mode='r'", r)
+                r = repr(zipfp.getinfo(fname))
+                self.assertIn('filename=%r' % fname, r)
+                self.assertIn('filemode=', r)
+                self.assertIn('file_size=', r)
+                if self.compression != zipfile.ZIP_STORED:
+                    self.assertIn('compress_type=', r)
+                    self.assertIn('compress_size=', r)
+                with zipfp.open(fname) as zipopen:
+                    r = repr(zipopen)
+                    self.assertIn('name=%r' % fname, r)
+                    if self.compression != zipfile.ZIP_STORED:
+                        self.assertIn('compress_type=', r)
+                self.assertIn('[closed]', repr(zipopen))
+            self.assertIn('[closed]', repr(zipfp))
+
+    def test_compresslevel_basic(self):
+        for f in get_files(self):
+            self.zip_test(f, self.compression, compresslevel=9)
+
+    def test_per_file_compresslevel(self):
+        """Check that files within a Zip archive can have different
+        compression levels."""
+        with zipfile.ZipFile(TESTFN2, "w", compresslevel=1) as zipfp:
+            zipfp.write(TESTFN, 'compress_1')
+            zipfp.write(TESTFN, 'compress_9', compresslevel=9)
+            one_info = zipfp.getinfo('compress_1')
+            nine_info = zipfp.getinfo('compress_9')
+            self.assertEqual(one_info._compresslevel, 1)
+            self.assertEqual(nine_info.compress_level, 9)
+
+    def test_writing_errors(self):
+        class BrokenFile(io.BytesIO):
+            def write(self, data):
+                nonlocal count
+                if count is not None:
+                    if count == stop:
+                        raise OSError
+                    count += 1
+                super().write(data)
+
+        stop = 0
+        while True:
+            testfile = BrokenFile()
+            count = None
+            with zipfile.ZipFile(testfile, 'w', self.compression) as zipfp:
+                with zipfp.open('file1', 'w') as f:
+                    f.write(b'data1')
+                count = 0
+                try:
+                    with zipfp.open('file2', 'w') as f:
+                        f.write(b'data2')
+                except OSError:
+                    stop += 1
+                else:
+                    break
+                finally:
+                    count = None
+            with zipfile.ZipFile(io.BytesIO(testfile.getvalue())) as zipfp:
+                self.assertEqual(zipfp.namelist(), ['file1'])
+                self.assertEqual(zipfp.read('file1'), b'data1')
+
+        with zipfile.ZipFile(io.BytesIO(testfile.getvalue())) as zipfp:
+            self.assertEqual(zipfp.namelist(), ['file1', 'file2'])
+            self.assertEqual(zipfp.read('file1'), b'data1')
+            self.assertEqual(zipfp.read('file2'), b'data2')
+
+    def test_zipextfile_attrs(self):
+        fname = "somefile.txt"
+        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
+            zipfp.writestr(fname, "bogus")
+
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
+            with zipfp.open(fname) as fid:
+                self.assertEqual(fid.name, fname)
+                self.assertRaises(io.UnsupportedOperation, fid.fileno)
+                self.assertEqual(fid.mode, 'rb')
+                self.assertIs(fid.readable(), True)
+                self.assertIs(fid.writable(), False)
+                self.assertIs(fid.seekable(), True)
+                self.assertIs(fid.closed, False)
+            self.assertIs(fid.closed, True)
+            self.assertEqual(fid.name, fname)
+            self.assertEqual(fid.mode, 'rb')
+            self.assertRaises(io.UnsupportedOperation, fid.fileno)
+            self.assertRaises(ValueError, fid.readable)
+            self.assertIs(fid.writable(), False)
+            self.assertRaises(ValueError, fid.seekable)
+
+    def tearDown(self):
+        unlink(TESTFN)
+        unlink(TESTFN2)
+
+
+class StoredTestsWithSourceFile(AbstractTestsWithSourceFile,
+                                unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+    test_low_compression = None
+
+    def zip_test_writestr_permissions(self, f, compression):
+        # Make sure that writestr and open(... mode='w') create files with
+        # mode 0600, when they are passed a name rather than a ZipInfo
+        # instance.
+
+        self.make_test_archive(f, compression)
+        with zipfile.ZipFile(f, "r") as zipfp:
+            zinfo = zipfp.getinfo('strfile')
+            self.assertEqual(zinfo.external_attr, 0o600 << 16)
+
+            zinfo2 = zipfp.getinfo('written-open-w')
+            self.assertEqual(zinfo2.external_attr, 0o600 << 16)
+
+    def test_writestr_permissions(self):
+        for f in get_files(self):
+            self.zip_test_writestr_permissions(f, zipfile.ZIP_STORED)
+
+    def test_absolute_arcnames(self):
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            zipfp.write(TESTFN, "/absolute")
+
+        with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
+            self.assertEqual(zipfp.namelist(), ["absolute"])
+
+    def test_append_to_zip_file(self):
+        """Test appending to an existing zipfile."""
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            zipfp.write(TESTFN, TESTFN)
+
+        with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
+            zipfp.writestr("strfile", self.data)
+            self.assertEqual(zipfp.namelist(), [TESTFN, "strfile"])
+
+    def test_append_to_non_zip_file(self):
+        """Test appending to an existing file that is not a zipfile."""
+        # NOTE: this test fails if len(d) < 22 because of the first
+        # line "fpin.seek(-22, 2)" in _EndRecData
+        data = b'I am not a ZipFile!'*10
+        with open(TESTFN2, 'wb') as f:
+            f.write(data)
+
+        with zipfile.ZipFile(TESTFN2, "a", zipfile.ZIP_STORED) as zipfp:
+            zipfp.write(TESTFN, TESTFN)
+
+        with open(TESTFN2, 'rb') as f:
+            f.seek(len(data))
+            with zipfile.ZipFile(f, "r") as zipfp:
+                self.assertEqual(zipfp.namelist(), [TESTFN])
+                self.assertEqual(zipfp.read(TESTFN), self.data)
+        with open(TESTFN2, 'rb') as f:
+            self.assertEqual(f.read(len(data)), data)
+            zipfiledata = f.read()
+        with io.BytesIO(zipfiledata) as bio, zipfile.ZipFile(bio) as zipfp:
+            self.assertEqual(zipfp.namelist(), [TESTFN])
+            self.assertEqual(zipfp.read(TESTFN), self.data)
+
+    def test_read_concatenated_zip_file(self):
+        with io.BytesIO() as bio:
+            with zipfile.ZipFile(bio, 'w', zipfile.ZIP_STORED) as zipfp:
+                zipfp.write(TESTFN, TESTFN)
+            zipfiledata = bio.getvalue()
+        data = b'I am not a ZipFile!'*10
+        with open(TESTFN2, 'wb') as f:
+            f.write(data)
+            f.write(zipfiledata)
+
+        with zipfile.ZipFile(TESTFN2) as zipfp:
+            self.assertEqual(zipfp.namelist(), [TESTFN])
+            self.assertEqual(zipfp.read(TESTFN), self.data)
+
+    def test_append_to_concatenated_zip_file(self):
+        with io.BytesIO() as bio:
+            with zipfile.ZipFile(bio, 'w', zipfile.ZIP_STORED) as zipfp:
+                zipfp.write(TESTFN, TESTFN)
+            zipfiledata = bio.getvalue()
+        data = b'I am not a ZipFile!'*1000000
+        with open(TESTFN2, 'wb') as f:
+            f.write(data)
+            f.write(zipfiledata)
+
+        with zipfile.ZipFile(TESTFN2, 'a') as zipfp:
+            self.assertEqual(zipfp.namelist(), [TESTFN])
+            zipfp.writestr('strfile', self.data)
+
+        with open(TESTFN2, 'rb') as f:
+            self.assertEqual(f.read(len(data)), data)
+            zipfiledata = f.read()
+        with io.BytesIO(zipfiledata) as bio, zipfile.ZipFile(bio) as zipfp:
+            self.assertEqual(zipfp.namelist(), [TESTFN, 'strfile'])
+            self.assertEqual(zipfp.read(TESTFN), self.data)
+            self.assertEqual(zipfp.read('strfile'), self.data)
+
+    def test_ignores_newline_at_end(self):
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            zipfp.write(TESTFN, TESTFN)
+        with open(TESTFN2, 'a', encoding='utf-8') as f:
+            f.write("\r\n\00\00\00")
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            self.assertIsInstance(zipfp, zipfile.ZipFile)
+
+    def test_ignores_stuff_appended_past_comments(self):
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            zipfp.comment = b"this is a comment"
+            zipfp.write(TESTFN, TESTFN)
+        with open(TESTFN2, 'a', encoding='utf-8') as f:
+            f.write("abcdef\r\n")
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            self.assertIsInstance(zipfp, zipfile.ZipFile)
+            self.assertEqual(zipfp.comment, b"this is a comment")
+
+    def test_write_default_name(self):
+        """Check that calling ZipFile.write without arcname specified
+        produces the expected result."""
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            zipfp.write(TESTFN)
+            with open(TESTFN, "rb") as f:
+                self.assertEqual(zipfp.read(TESTFN), f.read())
+
+    def test_io_on_closed_zipextfile(self):
+        fname = "somefile.txt"
+        with zipfile.ZipFile(TESTFN2, mode="w", compression=self.compression) as zipfp:
+            zipfp.writestr(fname, "bogus")
+
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
+            with zipfp.open(fname) as fid:
+                fid.close()
+                self.assertIs(fid.closed, True)
+                self.assertRaises(ValueError, fid.read)
+                self.assertRaises(ValueError, fid.seek, 0)
+                self.assertRaises(ValueError, fid.tell)
+
+    def test_write_to_readonly(self):
+        """Check that trying to call write() on a readonly ZipFile object
+        raises a ValueError."""
+        with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
+            zipfp.writestr("somefile.txt", "bogus")
+
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
+            self.assertRaises(ValueError, zipfp.write, TESTFN)
+
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
+            with self.assertRaises(ValueError):
+                zipfp.open(TESTFN, mode='w')
+
+    def test_add_file_before_1980(self):
+        # Set atime and mtime to 1970-01-01
+        os.utime(TESTFN, (0, 0))
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            self.assertRaises(ValueError, zipfp.write, TESTFN)
+
+        with zipfile.ZipFile(TESTFN2, "w", strict_timestamps=False) as zipfp:
+            zipfp.write(TESTFN)
+            zinfo = zipfp.getinfo(TESTFN)
+            self.assertEqual(zinfo.date_time, (1980, 1, 1, 0, 0, 0))
+
+    def test_add_file_after_2107(self):
+        # Set atime and mtime to 2108-12-30
+        ts = 4386268800
+        try:
+            time.localtime(ts)
+        except OverflowError:
+            self.skipTest(f'time.localtime({ts}) raises OverflowError')
+        try:
+            os.utime(TESTFN, (ts, ts))
+        except OverflowError:
+            self.skipTest('Host fs cannot set timestamp to required value.')
+
+        mtime_ns = os.stat(TESTFN).st_mtime_ns
+        if mtime_ns != (4386268800 * 10**9):
+            # XFS filesystem is limited to 32-bit timestamp, but the syscall
+            # didn't fail. Moreover, there is a VFS bug which returns
+            # a cached timestamp which is different than the value on disk.
+            #
+            # Test st_mtime_ns rather than st_mtime to avoid rounding issues.
+            #
+            # https://bugzilla.redhat.com/show_bug.cgi?id=1795576
+            # https://bugs.python.org/issue39460#msg360952
+            self.skipTest(f"Linux VFS/XFS kernel bug detected: {mtime_ns=}")
+
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            self.assertRaises(struct.error, zipfp.write, TESTFN)
+
+        with zipfile.ZipFile(TESTFN2, "w", strict_timestamps=False) as zipfp:
+            zipfp.write(TESTFN)
+            zinfo = zipfp.getinfo(TESTFN)
+            self.assertEqual(zinfo.date_time, (2107, 12, 31, 23, 59, 59))
+
+
+@requires_zlib()
+class DeflateTestsWithSourceFile(AbstractTestsWithSourceFile,
+                                 unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+
+    def test_per_file_compression(self):
+        """Check that files within a Zip archive can have different
+        compression options."""
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            zipfp.write(TESTFN, 'storeme', zipfile.ZIP_STORED)
+            zipfp.write(TESTFN, 'deflateme', zipfile.ZIP_DEFLATED)
+            sinfo = zipfp.getinfo('storeme')
+            dinfo = zipfp.getinfo('deflateme')
+            self.assertEqual(sinfo.compress_type, zipfile.ZIP_STORED)
+            self.assertEqual(dinfo.compress_type, zipfile.ZIP_DEFLATED)
+
+@requires_bz2()
+class Bzip2TestsWithSourceFile(AbstractTestsWithSourceFile,
+                               unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+
+@requires_lzma()
+class LzmaTestsWithSourceFile(AbstractTestsWithSourceFile,
+                              unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+
+
+class AbstractTestZip64InSmallFiles:
+    # These tests test the ZIP64 functionality without using large files,
+    # see test_zipfile64 for proper tests.
+
+    @classmethod
+    def setUpClass(cls):
+        line_gen = (bytes("Test of zipfile line %d." % i, "ascii")
+                    for i in range(0, FIXEDTEST_SIZE))
+        cls.data = b'\n'.join(line_gen)
+
+    def setUp(self):
+        self._limit = zipfile.ZIP64_LIMIT
+        self._filecount_limit = zipfile.ZIP_FILECOUNT_LIMIT
+        zipfile.ZIP64_LIMIT = 1000
+        zipfile.ZIP_FILECOUNT_LIMIT = 9
+
+        # Make a source file with some lines
+        with open(TESTFN, "wb") as fp:
+            fp.write(self.data)
+
+    def zip_test(self, f, compression):
+        # Create the ZIP archive
+        with zipfile.ZipFile(f, "w", compression, allowZip64=True) as zipfp:
+            zipfp.write(TESTFN, "another.name")
+            zipfp.write(TESTFN, TESTFN)
+            zipfp.writestr("strfile", self.data)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            self.assertEqual(zipfp.read(TESTFN), self.data)
+            self.assertEqual(zipfp.read("another.name"), self.data)
+            self.assertEqual(zipfp.read("strfile"), self.data)
+
+            # Print the ZIP directory
+            fp = io.StringIO()
+            zipfp.printdir(fp)
+
+            directory = fp.getvalue()
+            lines = directory.splitlines()
+            self.assertEqual(len(lines), 4) # Number of files + header
+
+            self.assertIn('File Name', lines[0])
+            self.assertIn('Modified', lines[0])
+            self.assertIn('Size', lines[0])
+
+            fn, date, time_, size = lines[1].split()
+            self.assertEqual(fn, 'another.name')
+            self.assertTrue(time.strptime(date, '%Y-%m-%d'))
+            self.assertTrue(time.strptime(time_, '%H:%M:%S'))
+            self.assertEqual(size, str(len(self.data)))
+
+            # Check the namelist
+            names = zipfp.namelist()
+            self.assertEqual(len(names), 3)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
+
+            # Check infolist
+            infos = zipfp.infolist()
+            names = [i.filename for i in infos]
+            self.assertEqual(len(names), 3)
+            self.assertIn(TESTFN, names)
+            self.assertIn("another.name", names)
+            self.assertIn("strfile", names)
+            for i in infos:
+                self.assertEqual(i.file_size, len(self.data))
+
+            # check getinfo
+            for nm in (TESTFN, "another.name", "strfile"):
+                info = zipfp.getinfo(nm)
+                self.assertEqual(info.filename, nm)
+                self.assertEqual(info.file_size, len(self.data))
+
+            # Check that testzip thinks the archive is valid
+            self.assertIsNone(zipfp.testzip())
+
+    def test_basic(self):
+        for f in get_files(self):
+            self.zip_test(f, self.compression)
+
+    def test_too_many_files(self):
+        # This test checks that more than 64k files can be added to an archive,
+        # and that the resulting archive can be read properly by ZipFile
+        zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
+                               allowZip64=True)
+        zipf.debug = 100
+        numfiles = 15
+        for i in range(numfiles):
+            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        zipf.close()
+
+        zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
+        self.assertEqual(len(zipf2.namelist()), numfiles)
+        for i in range(numfiles):
+            content = zipf2.read("foo%08d" % i).decode('ascii')
+            self.assertEqual(content, "%d" % (i**3 % 57))
+        zipf2.close()
+
+    def test_too_many_files_append(self):
+        zipf = zipfile.ZipFile(TESTFN, "w", self.compression,
+                               allowZip64=False)
+        zipf.debug = 100
+        numfiles = 9
+        for i in range(numfiles):
+            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        with self.assertRaises(zipfile.LargeZipFile):
+            zipf.writestr("foo%08d" % numfiles, b'')
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        zipf.close()
+
+        zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
+                               allowZip64=False)
+        zipf.debug = 100
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        with self.assertRaises(zipfile.LargeZipFile):
+            zipf.writestr("foo%08d" % numfiles, b'')
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        zipf.close()
+
+        zipf = zipfile.ZipFile(TESTFN, "a", self.compression,
+                               allowZip64=True)
+        zipf.debug = 100
+        self.assertEqual(len(zipf.namelist()), numfiles)
+        numfiles2 = 15
+        for i in range(numfiles, numfiles2):
+            zipf.writestr("foo%08d" % i, "%d" % (i**3 % 57))
+        self.assertEqual(len(zipf.namelist()), numfiles2)
+        zipf.close()
+
+        zipf2 = zipfile.ZipFile(TESTFN, "r", self.compression)
+        self.assertEqual(len(zipf2.namelist()), numfiles2)
+        for i in range(numfiles2):
+            content = zipf2.read("foo%08d" % i).decode('ascii')
+            self.assertEqual(content, "%d" % (i**3 % 57))
+        zipf2.close()
+
+    def tearDown(self):
+        zipfile.ZIP64_LIMIT = self._limit
+        zipfile.ZIP_FILECOUNT_LIMIT = self._filecount_limit
+        unlink(TESTFN)
+        unlink(TESTFN2)
+
+
+class StoredTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
+                                  unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+
+    def large_file_exception_test(self, f, compression):
+        with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
+            self.assertRaises(zipfile.LargeZipFile,
+                              zipfp.write, TESTFN, "another.name")
+
+    def large_file_exception_test2(self, f, compression):
+        with zipfile.ZipFile(f, "w", compression, allowZip64=False) as zipfp:
+            self.assertRaises(zipfile.LargeZipFile,
+                              zipfp.writestr, "another.name", self.data)
+
+    def test_large_file_exception(self):
+        for f in get_files(self):
+            self.large_file_exception_test(f, zipfile.ZIP_STORED)
+            self.large_file_exception_test2(f, zipfile.ZIP_STORED)
+
+    def test_absolute_arcnames(self):
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED,
+                             allowZip64=True) as zipfp:
+            zipfp.write(TESTFN, "/absolute")
+
+        with zipfile.ZipFile(TESTFN2, "r", zipfile.ZIP_STORED) as zipfp:
+            self.assertEqual(zipfp.namelist(), ["absolute"])
+
+    def test_append(self):
+        # Test that appending to the Zip64 archive doesn't change
+        # extra fields of existing entries.
+        with zipfile.ZipFile(TESTFN2, "w", allowZip64=True) as zipfp:
+            zipfp.writestr("strfile", self.data)
+        with zipfile.ZipFile(TESTFN2, "r", allowZip64=True) as zipfp:
+            zinfo = zipfp.getinfo("strfile")
+            extra = zinfo.extra
+        with zipfile.ZipFile(TESTFN2, "a", allowZip64=True) as zipfp:
+            zipfp.writestr("strfile2", self.data)
+        with zipfile.ZipFile(TESTFN2, "r", allowZip64=True) as zipfp:
+            zinfo = zipfp.getinfo("strfile")
+            self.assertEqual(zinfo.extra, extra)
+
+    def make_zip64_file(
+        self, file_size_64_set=False, file_size_extra=False,
+        compress_size_64_set=False, compress_size_extra=False,
+        header_offset_64_set=False, header_offset_extra=False,
+        extensible_data=b'',
+        end_of_central_dir_size=None, offset_to_end_of_central_dir=None,
+    ):
+        """Generate bytes sequence for a zip with (incomplete) zip64 data.
+
+        The actual values (not the zip 64 0xffffffff values) stored in the file
+        are:
+        file_size: 8
+        compress_size: 8
+        header_offset: 0
+        """
+        actual_size = 8
+        actual_header_offset = 0
+        local_zip64_fields = []
+        central_zip64_fields = []
+
+        file_size = actual_size
+        if file_size_64_set:
+            file_size = 0xffffffff
+            if file_size_extra:
+                local_zip64_fields.append(actual_size)
+                central_zip64_fields.append(actual_size)
+        file_size = struct.pack("<L", file_size)
+
+        compress_size = actual_size
+        if compress_size_64_set:
+            compress_size = 0xffffffff
+            if compress_size_extra:
+                local_zip64_fields.append(actual_size)
+                central_zip64_fields.append(actual_size)
+        compress_size = struct.pack("<L", compress_size)
+
+        header_offset = actual_header_offset
+        if header_offset_64_set:
+            header_offset = 0xffffffff
+            if header_offset_extra:
+                central_zip64_fields.append(actual_header_offset)
+        header_offset = struct.pack("<L", header_offset)
+
+        local_extra = struct.pack(
+            '<HH' + 'Q'*len(local_zip64_fields),
+            0x0001,
+            8*len(local_zip64_fields),
+            *local_zip64_fields
+        )
+
+        central_extra = struct.pack(
+            '<HH' + 'Q'*len(central_zip64_fields),
+            0x0001,
+            8*len(central_zip64_fields),
+            *central_zip64_fields
+        )
+
+        central_dir_size = struct.pack('<Q', 58 + 8 * len(central_zip64_fields))
+        offset_to_central_dir = struct.pack('<Q', 50 + 8 * len(local_zip64_fields))
+        if end_of_central_dir_size is None:
+            end_of_central_dir_size = 44 + len(extensible_data)
+        if offset_to_end_of_central_dir is None:
+            offset_to_end_of_central_dir = (108
+                                            + 8 * len(local_zip64_fields)
+                                            + 8 * len(central_zip64_fields))
+
+        local_extra_length = struct.pack("<H", 4 + 8 * len(local_zip64_fields))
+        central_extra_length = struct.pack("<H", 4 + 8 * len(central_zip64_fields))
+
+        filename = b"test.txt"
+        content = b"test1234"
+        filename_length = struct.pack("<H", len(filename))
+        zip64_contents = (
+            # Local file header
+            b"PK\x03\x04\x14\x00\x00\x00\x00\x00\x00\x00!\x00\x9e%\xf5\xaf"
+            + compress_size
+            + file_size
+            + filename_length
+            + local_extra_length
+            + filename
+            + local_extra
+            + content
+            # Central directory:
+            + b"PK\x01\x02-\x03-\x00\x00\x00\x00\x00\x00\x00!\x00\x9e%\xf5\xaf"
+            + compress_size
+            + file_size
+            + filename_length
+            + central_extra_length
+            + b"\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01"
+            + header_offset
+            + filename
+            + central_extra
+            # Zip64 end of central directory
+            + b"PK\x06\x06"
+            + struct.pack('<Q', end_of_central_dir_size)
+            + b"-\x00-\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00"
+            + b"\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00"
+            + central_dir_size
+            + offset_to_central_dir
+            + extensible_data
+            # Zip64 end of central directory locator
+            + b"PK\x06\x07\x00\x00\x00\x00"
+            + struct.pack('<Q', offset_to_end_of_central_dir)
+            + b"\x01\x00\x00\x00"
+            # end of central directory
+            + b"PK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00:\x00\x00\x002\x00"
+            + b"\x00\x00\x00\x00"
+        )
+        return zip64_contents
+
+    def test_bad_zip64_extra(self):
+        """Missing zip64 extra records raises an exception.
+
+        There are 4 fields that the zip64 format handles (the disk number is
+        not used in this module and so is ignored here). According to the zip
+        spec:
+              The order of the fields in the zip64 extended
+              information record is fixed, but the fields MUST
+              only appear if the corresponding Local or Central
+              directory record field is set to 0xFFFF or 0xFFFFFFFF.
+
+        If the zip64 extra content doesn't contain enough entries for the
+        number of fields marked with 0xFFFF or 0xFFFFFFFF, we raise an error.
+        This test mismatches the length of the zip64 extra field and the number
+        of fields set to indicate the presence of zip64 data.
+        """
+        # zip64 file size present, no fields in extra, expecting one, equals
+        # missing file size.
+        missing_file_size_extra = self.make_zip64_file(
+            file_size_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_file_size_extra))
+        self.assertIn('file size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_file_size_extra)))
+
+        # zip64 file size present, zip64 compress size present, one field in
+        # extra, expecting two, equals missing compress size.
+        missing_compress_size_extra = self.make_zip64_file(
+            file_size_64_set=True,
+            file_size_extra=True,
+            compress_size_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
+        self.assertIn('compress size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_compress_size_extra)))
+
+        # zip64 compress size present, no fields in extra, expecting one,
+        # equals missing compress size.
+        missing_compress_size_extra = self.make_zip64_file(
+            compress_size_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_compress_size_extra))
+        self.assertIn('compress size', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_compress_size_extra)))
+
+        # zip64 file size present, zip64 compress size present, zip64 header
+        # offset present, two fields in extra, expecting three, equals missing
+        # header offset
+        missing_header_offset_extra = self.make_zip64_file(
+            file_size_64_set=True,
+            file_size_extra=True,
+            compress_size_64_set=True,
+            compress_size_extra=True,
+            header_offset_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
+        self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
+
+        # zip64 compress size present, zip64 header offset present, one field
+        # in extra, expecting two, equals missing header offset
+        missing_header_offset_extra = self.make_zip64_file(
+            file_size_64_set=False,
+            compress_size_64_set=True,
+            compress_size_extra=True,
+            header_offset_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
+        self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
+
+        # zip64 file size present, zip64 header offset present, one field in
+        # extra, expecting two, equals missing header offset
+        missing_header_offset_extra = self.make_zip64_file(
+            file_size_64_set=True,
+            file_size_extra=True,
+            compress_size_64_set=False,
+            header_offset_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
+        self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
+
+        # zip64 header offset present, no fields in extra, expecting one,
+        # equals missing header offset
+        missing_header_offset_extra = self.make_zip64_file(
+            file_size_64_set=False,
+            compress_size_64_set=False,
+            header_offset_64_set=True,
+        )
+        with self.assertRaises(zipfile.BadZipFile) as e:
+            zipfile.ZipFile(io.BytesIO(missing_header_offset_extra))
+        self.assertIn('header offset', str(e.exception).lower())
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(missing_header_offset_extra)))
+
+    def test_bad_zip64_end_of_central_dir(self):
+        zipdata = self.make_zip64_file(end_of_central_dir_size=0)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(end_of_central_dir_size=100)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(offset_to_end_of_central_dir=0)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*record'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(offset_to_end_of_central_dir=1000)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'Corrupt.*locator'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+    def test_zip64_end_of_central_dir_record_not_found(self):
+        zipdata = self.make_zip64_file()
+        zipdata = zipdata.replace(b"PK\x06\x06", b'\x00'*4)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        zipdata = self.make_zip64_file(
+            extensible_data=b'\xca\xfe\x04\x00\x00\x00data')
+        zipdata = zipdata.replace(b"PK\x06\x06", b'\x00'*4)
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+    def test_zip64_extensible_data(self):
+        # These values are what is set in the make_zip64_file method.
+        expected_file_size = 8
+        expected_compress_size = 8
+        expected_header_offset = 0
+        expected_content = b"test1234"
+
+        zipdata = self.make_zip64_file(
+            extensible_data=b'\xca\xfe\x04\x00\x00\x00data')
+        with zipfile.ZipFile(io.BytesIO(zipdata)) as zf:
+            zinfo = zf.infolist()[0]
+            self.assertEqual(zinfo.file_size, expected_file_size)
+            self.assertEqual(zinfo.compress_size, expected_compress_size)
+            self.assertEqual(zinfo.header_offset, expected_header_offset)
+            self.assertEqual(zf.read(zinfo), expected_content)
+        self.assertTrue(zipfile.is_zipfile(io.BytesIO(zipdata)))
+
+        with self.assertRaisesRegex(zipfile.BadZipFile, 'record not found'):
+            zipfile.ZipFile(io.BytesIO(b'prepended' + zipdata))
+        self.assertFalse(zipfile.is_zipfile(io.BytesIO(b'prepended' + zipdata)))
+
+    def test_generated_valid_zip64_extra(self):
+        # These values are what is set in the make_zip64_file method.
+        expected_file_size = 8
+        expected_compress_size = 8
+        expected_header_offset = 0
+        expected_content = b"test1234"
+
+        # Loop through the various valid combinations of zip64 masks
+        # present and extra fields present.
+        params = (
+            {"file_size_64_set": True, "file_size_extra": True},
+            {"compress_size_64_set": True, "compress_size_extra": True},
+            {"header_offset_64_set": True, "header_offset_extra": True},
+        )
+
+        for r in range(1, len(params) + 1):
+            for combo in itertools.combinations(params, r):
+                kwargs = {}
+                for c in combo:
+                    kwargs.update(c)
+                with zipfile.ZipFile(io.BytesIO(self.make_zip64_file(**kwargs))) as zf:
+                    zinfo = zf.infolist()[0]
+                    self.assertEqual(zinfo.file_size, expected_file_size)
+                    self.assertEqual(zinfo.compress_size, expected_compress_size)
+                    self.assertEqual(zinfo.header_offset, expected_header_offset)
+                    self.assertEqual(zf.read(zinfo), expected_content)
+
+    def test_force_zip64(self):
+        """Test that forcing zip64 extensions correctly notes this in the zip file"""
+
+        # GH-103861 describes an issue where forcing a small file to use zip64
+        # extensions would add a zip64 extra record, but not change the data
+        # sizes to 0xFFFFFFFF to indicate to the extractor that the zip64
+        # record should be read. Additionally, it would not set the required
+        # version to indicate that zip64 extensions are required to extract it.
+        # This test replicates the situation and reads the raw data to specifically ensure:
+        #  - The required extract version is always >= ZIP64_VERSION
+        #  - The compressed and uncompressed size in the file headers are both
+        #     0xFFFFFFFF (ie. point to zip64 record)
+        #  - The zip64 record is provided and has the correct sizes in it
+        # Other aspects of the zip are checked as well, but verifying the above is the main goal.
+        # Because this is hard to verify by parsing the data as a zip, the raw
+        # bytes are checked to ensure that they line up with the zip spec.
+        # The spec for this can be found at: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+        # The relevant sections for this test are:
+        #  - 4.3.7 for local file header
+        #  - 4.5.3 for zip64 extra field
+
+        data = io.BytesIO()
+        with zipfile.ZipFile(data, mode="w", allowZip64=True) as zf:
+            with zf.open("text.txt", mode="w", force_zip64=True) as zi:
+                zi.write(b"_")
+
+        zipdata = data.getvalue()
+
+        # pull out and check zip information
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize, cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQx4s", zipdata[:63])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual(flags, 0)  # no flags
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, 1)  # uncompressed size
+        self.assertEqual(ex_csize, 1)  # compressed size
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
+        z = zipfile.ZipFile(io.BytesIO(zipdata))
+        zinfos = z.infolist()
+        self.assertEqual(len(zinfos), 1)
+        self.assertGreaterEqual(zinfos[0].extract_version, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+
+    def test_unseekable_zip_unknown_filesize(self):
+        """Test that creating a zip with/without seeking will raise a RuntimeError if zip64 was required but not used"""
+
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=True) as zf:
+                with zf.open("text.txt", mode="w", force_zip64=False) as zi:
+                    zi.write(b"_" * (zipfile.ZIP64_LIMIT + 1))
+
+        self.assertRaises(RuntimeError, make_zip, io.BytesIO())
+        self.assertRaises(RuntimeError, make_zip, Unseekable(io.BytesIO()))
+
+    def test_zip64_required_not_allowed_fail(self):
+        """Test that trying to add a large file to a zip that doesn't allow zip64 extensions fails on add"""
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=False) as zf:
+                # pretend zipfile.ZipInfo.from_file was used to get the name and filesize
+                info = zipfile.ZipInfo("text.txt")
+                info.file_size = zipfile.ZIP64_LIMIT + 1
+                zf.open(info, mode="w")
+
+        self.assertRaises(zipfile.LargeZipFile, make_zip, io.BytesIO())
+        self.assertRaises(zipfile.LargeZipFile, make_zip, Unseekable(io.BytesIO()))
+
+    def test_unseekable_zip_known_filesize(self):
+        """Test that creating a zip without seeking will use zip64 extensions if the file size is provided up-front"""
+
+        # This test ensures that the zip will use a zip64 data descriptor (same
+        # as a regular data descriptor except the sizes are 8 bytes instead of
+        # 4) record to communicate the size of a file if the zip is being
+        # written to an unseekable stream.
+        # Because this sort of thing is hard to verify by parsing the data back
+        # in as a zip, this test looks at the raw bytes created to ensure that
+        # the correct data has been generated.
+        # The spec for this can be found at: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
+        # The relevant sections for this test are:
+        #  - 4.3.7 for local file header
+        #  - 4.3.9 for the data descriptor
+        #  - 4.5.3 for zip64 extra field
+
+        file_size = zipfile.ZIP64_LIMIT + 1
+
+        def make_zip(fp):
+            with zipfile.ZipFile(fp, mode="w", allowZip64=True) as zf:
+                # pretend zipfile.ZipInfo.from_file was used to get the name and filesize
+                info = zipfile.ZipInfo("text.txt")
+                info.file_size = file_size
+                with zf.open(info, mode="w", force_zip64=False) as zi:
+                    zi.write(b"_" * file_size)
+            return fp
+
+        # check seekable file information
+        seekable_data = make_zip(io.BytesIO()).getvalue()
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize,
+            cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQ{}x4s".format(file_size), seekable_data[:62 + file_size])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual(flags, 0)  # no flags set
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, file_size)  # uncompressed size
+        self.assertEqual(ex_csize, file_size)  # compressed size
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
+        # check unseekable file information
+        unseekable_data = make_zip(Unseekable(io.BytesIO())).fp.getvalue()
+        (
+            header, vers, os, flags, comp, csize, usize, fn_len,
+            ex_total_len, filename, ex_id, ex_len, ex_usize, ex_csize,
+            dd_header, dd_usize, dd_csize, cd_sig
+        ) = struct.unpack("<4sBBHH8xIIHH8shhQQ{}x4s4xQQ4s".format(file_size), unseekable_data[:86 + file_size])
+
+        self.assertEqual(header, b"PK\x03\x04")  # local file header
+        self.assertGreaterEqual(vers, zipfile.ZIP64_VERSION)  # requires zip64 to extract
+        self.assertEqual(os, 0)  # compatible with MS-DOS
+        self.assertEqual("{:b}".format(flags), "1000")  # streaming flag set
+        self.assertEqual(comp, 0)  # compression method = stored
+        self.assertEqual(csize, 0xFFFFFFFF)  # sizes are in zip64 extra
+        self.assertEqual(usize, 0xFFFFFFFF)
+        self.assertEqual(fn_len, 8)  # filename len
+        self.assertEqual(ex_total_len, 20)  # size of extra records
+        self.assertEqual(ex_id, 1)  # Zip64 extra record
+        self.assertEqual(ex_len, 16)  # 16 bytes of data
+        self.assertEqual(ex_usize, 0)  # uncompressed size - 0 to defer to data descriptor
+        self.assertEqual(ex_csize, 0)  # compressed size - 0 to defer to data descriptor
+        self.assertEqual(dd_header, b"PK\07\x08")  # data descriptor
+        self.assertEqual(dd_usize, file_size)  # file size (8 bytes because zip64)
+        self.assertEqual(dd_csize, file_size)  # compressed size (8 bytes because zip64)
+        self.assertEqual(cd_sig, b"PK\x01\x02") # ensure the central directory header is next
+
+
+@requires_zlib()
+class DeflateTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
+                                   unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+
+@requires_bz2()
+class Bzip2TestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
+                                 unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+
+@requires_lzma()
+class LzmaTestZip64InSmallFiles(AbstractTestZip64InSmallFiles,
+                                unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+
+
+class AbstractWriterTests:
+
+    def tearDown(self):
+        unlink(TESTFN2)
+
+    def test_close_after_close(self):
+        data = b'content'
+        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
+            w = zipf.open('test', 'w')
+            w.write(data)
+            w.close()
+            self.assertTrue(w.closed)
+            w.close()
+            self.assertTrue(w.closed)
+            self.assertEqual(zipf.read('test'), data)
+
+    def test_write_after_close(self):
+        data = b'content'
+        with zipfile.ZipFile(TESTFN2, "w", self.compression) as zipf:
+            w = zipf.open('test', 'w')
+            w.write(data)
+            w.close()
+            self.assertTrue(w.closed)
+            self.assertRaises(ValueError, w.write, b'')
+            self.assertEqual(zipf.read('test'), data)
+
+    def test_issue44439(self):
+        q = array.array('Q', [1, 2, 3, 4, 5])
+        LENGTH = len(q) * q.itemsize
+        with zipfile.ZipFile(io.BytesIO(), 'w', self.compression) as zip:
+            with zip.open('data', 'w') as data:
+                self.assertEqual(data.write(q), LENGTH)
+            self.assertEqual(zip.getinfo('data').file_size, LENGTH)
+
+    def test_zipwritefile_attrs(self):
+        fname = "somefile.txt"
+        with zipfile.ZipFile(TESTFN2, mode="w", compression=self.compression) as zipfp:
+            with zipfp.open(fname, 'w') as fid:
+                self.assertEqual(fid.name, fname)
+                self.assertRaises(io.UnsupportedOperation, fid.fileno)
+                self.assertEqual(fid.mode, 'wb')
+                self.assertIs(fid.readable(), False)
+                self.assertIs(fid.writable(), True)
+                self.assertIs(fid.seekable(), False)
+                self.assertIs(fid.closed, False)
+            self.assertIs(fid.closed, True)
+            self.assertEqual(fid.name, fname)
+            self.assertEqual(fid.mode, 'wb')
+            self.assertRaises(io.UnsupportedOperation, fid.fileno)
+            self.assertIs(fid.readable(), False)
+            self.assertIs(fid.writable(), True)
+            self.assertIs(fid.seekable(), False)
+
+class StoredWriterTests(AbstractWriterTests, unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+
+@requires_zlib()
+class DeflateWriterTests(AbstractWriterTests, unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+
+@requires_bz2()
+class Bzip2WriterTests(AbstractWriterTests, unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+
+@requires_lzma()
+class LzmaWriterTests(AbstractWriterTests, unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+
+
+class PyZipFileTests(unittest.TestCase):
+    def assertCompiledIn(self, name, namelist):
+        if name + 'o' not in namelist:
+            self.assertIn(name + 'c', namelist)
+
+    def requiresWriteAccess(self, path):
+        # effective_ids unavailable on windows
+        if not os.access(path, os.W_OK,
+                         effective_ids=os.access in os.supports_effective_ids):
+            self.skipTest('requires write access to the installed location')
+        filename = os.path.join(path, 'test_zipfile.try')
+        try:
+            fd = os.open(filename, os.O_WRONLY | os.O_CREAT)
+            os.close(fd)
+        except Exception:
+            self.skipTest('requires write access to the installed location')
+        unlink(filename)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_write_pyfile(self):
+        self.requiresWriteAccess(os.path.dirname(__file__))
+        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+            fn = __file__
+            if fn.endswith('.pyc'):
+                path_split = fn.split(os.sep)
+                if os.altsep is not None:
+                    path_split.extend(fn.split(os.altsep))
+                if '__pycache__' in path_split:
+                    fn = importlib.util.source_from_cache(fn)
+                else:
+                    fn = fn[:-1]
+
+            zipfp.writepy(fn)
+
+            bn = os.path.basename(fn)
+            self.assertNotIn(bn, zipfp.namelist())
+            self.assertCompiledIn(bn, zipfp.namelist())
+
+        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+            fn = __file__
+            if fn.endswith('.pyc'):
+                fn = fn[:-1]
+
+            zipfp.writepy(fn, "testpackage")
+
+            bn = "%s/%s" % ("testpackage", os.path.basename(fn))
+            self.assertNotIn(bn, zipfp.namelist())
+            self.assertCompiledIn(bn, zipfp.namelist())
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_write_python_package(self):
+        import email
+        packagedir = os.path.dirname(email.__file__)
+        self.requiresWriteAccess(packagedir)
+
+        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+            zipfp.writepy(packagedir)
+
+            # Check for a couple of modules at different levels of the
+            # hierarchy
+            names = zipfp.namelist()
+            self.assertCompiledIn('email/__init__.py', names)
+            self.assertCompiledIn('email/mime/text.py', names)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; - AttributeError: module 'os' has no attribute 'supports_effective_ids'
+    def test_write_filtered_python_package(self):
+        import test
+        packagedir = os.path.dirname(test.__file__)
+        self.requiresWriteAccess(packagedir)
+
+        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+
+            # first make sure that the test folder gives error messages
+            # (on the badsyntax_... files)
+            with captured_stdout() as reportSIO:
+                zipfp.writepy(packagedir)
+            reportStr = reportSIO.getvalue()
+            self.assertTrue('SyntaxError' in reportStr)
+
+            # then check that the filter works on the whole package
+            with captured_stdout() as reportSIO:
+                zipfp.writepy(packagedir, filterfunc=lambda whatever: False)
+            reportStr = reportSIO.getvalue()
+            self.assertTrue('SyntaxError' not in reportStr)
+
+            # then check that the filter works on individual files
+            def filter(path):
+                return not os.path.basename(path).startswith("bad")
+            with captured_stdout() as reportSIO, self.assertWarns(UserWarning):
+                zipfp.writepy(packagedir, filterfunc=filter)
+            reportStr = reportSIO.getvalue()
+            if reportStr:
+                print(reportStr)
+            self.assertTrue('SyntaxError' not in reportStr)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    def test_write_with_optimization(self):
+        import email
+        packagedir = os.path.dirname(email.__file__)
+        self.requiresWriteAccess(packagedir)
+        optlevel = 1 if __debug__ else 0
+        ext = '.pyc'
+
+        with TemporaryFile() as t, \
+             zipfile.PyZipFile(t, "w", optimize=optlevel) as zipfp:
+            zipfp.writepy(packagedir)
+
+            names = zipfp.namelist()
+            self.assertIn('email/__init__' + ext, names)
+            self.assertIn('email/mime/text' + ext, names)
+
+    def test_write_python_directory(self):
+        os.mkdir(TESTFN2)
+        try:
+            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
+                fp.write("print(42)\n")
+
+            with open(os.path.join(TESTFN2, "mod2.py"), "w", encoding='utf-8') as fp:
+                fp.write("print(42 * 42)\n")
+
+            with open(os.path.join(TESTFN2, "mod2.txt"), "w", encoding='utf-8') as fp:
+                fp.write("bla bla bla\n")
+
+            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+                zipfp.writepy(TESTFN2)
+
+                names = zipfp.namelist()
+                self.assertCompiledIn('mod1.py', names)
+                self.assertCompiledIn('mod2.py', names)
+                self.assertNotIn('mod2.txt', names)
+
+        finally:
+            rmtree(TESTFN2)
+
+    def test_write_python_directory_filtered(self):
+        os.mkdir(TESTFN2)
+        try:
+            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
+                fp.write("print(42)\n")
+
+            with open(os.path.join(TESTFN2, "mod2.py"), "w", encoding='utf-8') as fp:
+                fp.write("print(42 * 42)\n")
+
+            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+                zipfp.writepy(TESTFN2, filterfunc=lambda fn:
+                                                  not fn.endswith('mod2.py'))
+
+                names = zipfp.namelist()
+                self.assertCompiledIn('mod1.py', names)
+                self.assertNotIn('mod2.py', names)
+
+        finally:
+            rmtree(TESTFN2)
+
+    def test_write_non_pyfile(self):
+        with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+            with open(TESTFN, 'w', encoding='utf-8') as f:
+                f.write('most definitely not a python file')
+            self.assertRaises(RuntimeError, zipfp.writepy, TESTFN)
+            unlink(TESTFN)
+
+    def test_write_pyfile_bad_syntax(self):
+        os.mkdir(TESTFN2)
+        try:
+            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
+                fp.write("Bad syntax in python file\n")
+
+            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+                # syntax errors are printed to stdout
+                with captured_stdout() as s:
+                    zipfp.writepy(os.path.join(TESTFN2, "mod1.py"))
+
+                self.assertIn("SyntaxError", s.getvalue())
+
+                # as it will not have compiled the python file, it will
+                # include the .py file not .pyc
+                names = zipfp.namelist()
+                self.assertIn('mod1.py', names)
+                self.assertNotIn('mod1.pyc', names)
+
+        finally:
+            rmtree(TESTFN2)
+
+    def test_write_pathlike(self):
+        os.mkdir(TESTFN2)
+        try:
+            with open(os.path.join(TESTFN2, "mod1.py"), "w", encoding='utf-8') as fp:
+                fp.write("print(42)\n")
+
+            with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
+                zipfp.writepy(FakePath(os.path.join(TESTFN2, "mod1.py")))
+                names = zipfp.namelist()
+                self.assertCompiledIn('mod1.py', names)
+        finally:
+            rmtree(TESTFN2)
+
+
+class ExtractTests(unittest.TestCase):
+
+    def make_test_file(self):
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            for fpath, fdata in SMALL_TEST_DATA:
+                zipfp.writestr(fpath, fdata)
+
+    def test_extract(self):
+        with temp_cwd():
+            self.make_test_file()
+            with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+                for fpath, fdata in SMALL_TEST_DATA:
+                    writtenfile = zipfp.extract(fpath)
+
+                    # make sure it was written to the right place
+                    correctfile = os.path.join(os.getcwd(), fpath)
+                    correctfile = os.path.normpath(correctfile)
+
+                    self.assertEqual(writtenfile, correctfile)
+
+                    # make sure correct data is in correct file
+                    with open(writtenfile, "rb") as f:
+                        self.assertEqual(fdata.encode(), f.read())
+
+                    unlink(writtenfile)
+
+    def _test_extract_with_target(self, target):
+        self.make_test_file()
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            for fpath, fdata in SMALL_TEST_DATA:
+                writtenfile = zipfp.extract(fpath, target)
+
+                # make sure it was written to the right place
+                correctfile = os.path.join(target, fpath)
+                correctfile = os.path.normpath(correctfile)
+                self.assertTrue(os.path.samefile(writtenfile, correctfile), (writtenfile, target))
+
+                # make sure correct data is in correct file
+                with open(writtenfile, "rb") as f:
+                    self.assertEqual(fdata.encode(), f.read())
+
+                unlink(writtenfile)
+
+        unlink(TESTFN2)
+
+    def test_extract_with_target(self):
+        with temp_dir() as extdir:
+            self._test_extract_with_target(extdir)
+
+    def test_extract_with_target_pathlike(self):
+        with temp_dir() as extdir:
+            self._test_extract_with_target(FakePath(extdir))
+
+    def test_extract_all(self):
+        with temp_cwd():
+            self.make_test_file()
+            with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+                zipfp.extractall()
+                for fpath, fdata in SMALL_TEST_DATA:
+                    outfile = os.path.join(os.getcwd(), fpath)
+
+                    with open(outfile, "rb") as f:
+                        self.assertEqual(fdata.encode(), f.read())
+
+                    unlink(outfile)
+
+    def _test_extract_all_with_target(self, target):
+        self.make_test_file()
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            zipfp.extractall(target)
+            for fpath, fdata in SMALL_TEST_DATA:
+                outfile = os.path.join(target, fpath)
+
+                with open(outfile, "rb") as f:
+                    self.assertEqual(fdata.encode(), f.read())
+
+                unlink(outfile)
+
+        unlink(TESTFN2)
+
+    def test_extract_all_with_target(self):
+        with temp_dir() as extdir:
+            self._test_extract_all_with_target(extdir)
+
+    def test_extract_all_with_target_pathlike(self):
+        with temp_dir() as extdir:
+            self._test_extract_all_with_target(FakePath(extdir))
+
+    def check_file(self, filename, content):
+        self.assertTrue(os.path.isfile(filename))
+        with open(filename, 'rb') as f:
+            self.assertEqual(f.read(), content)
+
+    def test_sanitize_windows_name(self):
+        san = zipfile.ZipFile._sanitize_windows_name
+        # Passing pathsep in allows this test to work regardless of platform.
+        self.assertEqual(san(r',,?,C:,foo,bar/z', ','), r'_,C_,foo,bar/z')
+        self.assertEqual(san(r'a\b,c<d>e|f"g?h*i', ','), r'a\b,c_d_e_f_g_h_i')
+        self.assertEqual(san('../../foo../../ba..r', '/'), r'foo/ba..r')
+        self.assertEqual(san('  /  /foo  /  /ba  r', '/'), r'foo/ba  r')
+        self.assertEqual(san(' . /. /foo ./ . /. ./ba .r', '/'), r'foo/ba .r')
+
+    def test_extract_hackers_arcnames_common_cases(self):
+        common_hacknames = [
+            ('../foo/bar', 'foo/bar'),
+            ('foo/../bar', 'foo/bar'),
+            ('foo/../../bar', 'foo/bar'),
+            ('foo/bar/..', 'foo/bar'),
+            ('./../foo/bar', 'foo/bar'),
+            ('/foo/bar', 'foo/bar'),
+            ('/foo/../bar', 'foo/bar'),
+            ('/foo/../../bar', 'foo/bar'),
+        ]
+        self._test_extract_hackers_arcnames(common_hacknames)
+
+    @unittest.skipIf(os.path.sep != '\\', 'Requires \\ as path separator.')
+    def test_extract_hackers_arcnames_windows_only(self):
+        """Test combination of path fixing and windows name sanitization."""
+        windows_hacknames = [
+            (r'..\foo\bar', 'foo/bar'),
+            (r'..\/foo\/bar', 'foo/bar'),
+            (r'foo/\..\/bar', 'foo/bar'),
+            (r'foo\/../\bar', 'foo/bar'),
+            (r'C:foo/bar', 'foo/bar'),
+            (r'C:/foo/bar', 'foo/bar'),
+            (r'C://foo/bar', 'foo/bar'),
+            (r'C:\foo\bar', 'foo/bar'),
+            (r'//conky/mountpoint/foo/bar', 'foo/bar'),
+            (r'\\conky\mountpoint\foo\bar', 'foo/bar'),
+            (r'///conky/mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\\conky\mountpoint\foo\bar', 'mountpoint/foo/bar'),
+            (r'//conky//mountpoint/foo/bar', 'mountpoint/foo/bar'),
+            (r'\\conky\\mountpoint\foo\bar', 'mountpoint/foo/bar'),
+            (r'//?/C:/foo/bar', 'foo/bar'),
+            (r'\\?\C:\foo\bar', 'foo/bar'),
+            (r'C:/../C:/foo/bar', 'C_/foo/bar'),
+            (r'a:b\c<d>e|f"g?h*i', 'b/c_d_e_f_g_h_i'),
+            ('../../foo../../ba..r', 'foo/ba..r'),
+        ]
+        self._test_extract_hackers_arcnames(windows_hacknames)
+
+    @unittest.skipIf(os.path.sep != '/', r'Requires / as path separator.')
+    def test_extract_hackers_arcnames_posix_only(self):
+        posix_hacknames = [
+            ('//foo/bar', 'foo/bar'),
+            ('../../foo../../ba..r', 'foo../ba..r'),
+            (r'foo/..\bar', r'foo/..\bar'),
+        ]
+        self._test_extract_hackers_arcnames(posix_hacknames)
+
+    def _test_extract_hackers_arcnames(self, hacknames):
+        for arcname, fixedname in hacknames:
+            content = b'foobar' + arcname.encode()
+            with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_STORED) as zipfp:
+                zinfo = zipfile.ZipInfo()
+                # preserve backslashes
+                zinfo.filename = arcname
+                zinfo.external_attr = 0o600 << 16
+                zipfp.writestr(zinfo, content)
+
+            arcname = arcname.replace(os.sep, "/")
+            targetpath = os.path.join('target', 'subdir', 'subsub')
+            correctfile = os.path.join(targetpath, *fixedname.split('/'))
+
+            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
+                writtenfile = zipfp.extract(arcname, targetpath)
+                self.assertEqual(writtenfile, correctfile,
+                                 msg='extract %r: %r != %r' %
+                                 (arcname, writtenfile, correctfile))
+            self.check_file(correctfile, content)
+            rmtree('target')
+
+            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
+                zipfp.extractall(targetpath)
+            self.check_file(correctfile, content)
+            rmtree('target')
+
+            correctfile = os.path.join(os.getcwd(), *fixedname.split('/'))
+
+            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
+                writtenfile = zipfp.extract(arcname)
+                self.assertEqual(writtenfile, correctfile,
+                                 msg="extract %r" % arcname)
+            self.check_file(correctfile, content)
+            rmtree(fixedname.split('/')[0])
+
+            with zipfile.ZipFile(TESTFN2, 'r') as zipfp:
+                zipfp.extractall()
+            self.check_file(correctfile, content)
+            rmtree(fixedname.split('/')[0])
+
+            unlink(TESTFN2)
+
+
+class OverwriteTests(archiver_tests.OverwriteTests, unittest.TestCase):
+    testdir = TESTFN
+
+    @classmethod
+    def setUpClass(cls):
+        p = cls.ar_with_file = TESTFN + '-with-file.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.writestr('test', b'newcontent')
+
+        p = cls.ar_with_dir = TESTFN + '-with-dir.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.mkdir('test')
+
+        p = cls.ar_with_implicit_dir = TESTFN + '-with-implicit-dir.zip'
+        cls.addClassCleanup(unlink, p)
+        with zipfile.ZipFile(p, 'w') as zipfp:
+            zipfp.writestr('test/file', b'newcontent')
+
+    def open(self, path):
+        return zipfile.ZipFile(path, 'r')
+
+    def extractall(self, ar):
+        ar.extractall(self.testdir)
+
+
+class OtherTests(unittest.TestCase):
+    def test_open_via_zip_info(self):
+        # Create the ZIP archive
+        with zipfile.ZipFile(TESTFN2, "w", zipfile.ZIP_STORED) as zipfp:
+            zipfp.writestr("name", "foo")
+            with self.assertWarns(UserWarning):
+                zipfp.writestr("name", "bar")
+            self.assertEqual(zipfp.namelist(), ["name"] * 2)
+
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            infos = zipfp.infolist()
+            data = b""
+            for info in infos:
+                with zipfp.open(info) as zipopen:
+                    data += zipopen.read()
+            self.assertIn(data, {b"foobar", b"barfoo"})
+            data = b""
+            for info in infos:
+                data += zipfp.read(info)
+            self.assertIn(data, {b"foobar", b"barfoo"})
+
+    def test_writestr_extended_local_header_issue1202(self):
+        with zipfile.ZipFile(TESTFN2, 'w') as orig_zip:
+            for data in 'abcdefghijklmnop':
+                zinfo = zipfile.ZipInfo(data)
+                zinfo.flag_bits |= zipfile._MASK_USE_DATA_DESCRIPTOR  # Include an extended local header.
+                orig_zip.writestr(zinfo, data)
+
+    def test_close(self):
+        """Check that the zipfile is closed after the 'with' block."""
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            for fpath, fdata in SMALL_TEST_DATA:
+                zipfp.writestr(fpath, fdata)
+                self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
+        self.assertIsNone(zipfp.fp, 'zipfp is not closed')
+
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            self.assertIsNotNone(zipfp.fp, 'zipfp is not open')
+        self.assertIsNone(zipfp.fp, 'zipfp is not closed')
+
+    def test_close_on_exception(self):
+        """Check that the zipfile is closed if an exception is raised in the
+        'with' block."""
+        with zipfile.ZipFile(TESTFN2, "w") as zipfp:
+            for fpath, fdata in SMALL_TEST_DATA:
+                zipfp.writestr(fpath, fdata)
+
+        try:
+            with zipfile.ZipFile(TESTFN2, "r") as zipfp2:
+                raise zipfile.BadZipFile()
+        except zipfile.BadZipFile:
+            self.assertIsNone(zipfp2.fp, 'zipfp is not closed')
+
+    def test_unsupported_version(self):
+        # File has an extract_version of 120
+        data = (b'PK\x03\x04x\x00\x00\x00\x00\x00!p\xa1@\x00\x00\x00\x00\x00\x00'
+                b'\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00xPK\x01\x02x\x03x\x00\x00\x00\x00'
+                b'\x00!p\xa1@\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00'
+                b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00xPK\x05\x06'
+                b'\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x1f\x00\x00\x00\x00\x00')
+
+        self.assertRaises(NotImplementedError, zipfile.ZipFile,
+                          io.BytesIO(data), 'r')
+
+    @requires_zlib()
+    def test_read_unicode_filenames(self):
+        # bug #10801
+        fname = findfile('zip_cp437_header.zip', subdir='archivetestdata')
+        with zipfile.ZipFile(fname) as zipfp:
+            for name in zipfp.namelist():
+                zipfp.open(name).close()
+
+    def test_write_unicode_filenames(self):
+        with zipfile.ZipFile(TESTFN, "w") as zf:
+            zf.writestr("foo.txt", "Test for unicode filename")
+            zf.writestr("\xf6.txt", "Test for unicode filename")
+            self.assertIsInstance(zf.infolist()[0].filename, str)
+
+        with zipfile.ZipFile(TESTFN, "r") as zf:
+            self.assertEqual(zf.filelist[0].filename, "foo.txt")
+            self.assertEqual(zf.filelist[1].filename, "\xf6.txt")
+
+    def create_zipfile_with_extra_data(self, filename, extra_data_name):
+        with zipfile.ZipFile(TESTFN, mode='w') as zf:
+            filename_encoded = filename.encode("utf-8")
+            # create a ZipInfo object with Unicode path extra field
+            zip_info = zipfile.ZipInfo(filename)
+
+            tag_for_unicode_path = b'\x75\x70'
+            version_of_unicode_path = b'\x01'
+
+            import zlib
+            filename_crc = struct.pack('<L', zlib.crc32(filename_encoded))
+
+            extra_data = version_of_unicode_path + filename_crc + extra_data_name
+            tsize = len(extra_data).to_bytes(2, 'little')
+
+            zip_info.extra = tag_for_unicode_path + tsize + extra_data
+
+            # add the file to the ZIP archive
+            zf.writestr(zip_info, b'Hello World!')
+
+    @requires_zlib()
+    def test_read_zipfile_containing_unicode_path_extra_field(self):
+        self.create_zipfile_with_extra_data("이름.txt", "이름.txt".encode("utf-8"))
+        with zipfile.ZipFile(TESTFN, "r") as zf:
+            self.assertEqual(zf.filelist[0].filename, "이름.txt")
+
+    @requires_zlib()
+    def test_read_zipfile_warning(self):
+        self.create_zipfile_with_extra_data("이름.txt", b"")
+        with self.assertWarns(UserWarning):
+            zipfile.ZipFile(TESTFN, "r").close()
+
+    @requires_zlib()
+    def test_read_zipfile_error(self):
+        self.create_zipfile_with_extra_data("이름.txt", b"\xff")
+        with self.assertRaises(zipfile.BadZipfile):
+            zipfile.ZipFile(TESTFN, "r").close()
+
+    def test_read_after_write_unicode_filenames(self):
+        with zipfile.ZipFile(TESTFN2, 'w') as zipfp:
+            zipfp.writestr('приклад', b'sample')
+            self.assertEqual(zipfp.read('приклад'), b'sample')
+
+    def test_exclusive_create_zip_file(self):
+        """Test exclusive creating a new zipfile."""
+        unlink(TESTFN2)
+        filename = 'testfile.txt'
+        content = b'hello, world. this is some content.'
+        with zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED) as zipfp:
+            zipfp.writestr(filename, content)
+        with self.assertRaises(FileExistsError):
+            zipfile.ZipFile(TESTFN2, "x", zipfile.ZIP_STORED)
+        with zipfile.ZipFile(TESTFN2, "r") as zipfp:
+            self.assertEqual(zipfp.namelist(), [filename])
+            self.assertEqual(zipfp.read(filename), content)
+
+    def test_create_non_existent_file_for_append(self):
+        if os.path.exists(TESTFN):
+            os.unlink(TESTFN)
+
+        filename = 'testfile.txt'
+        content = b'hello, world. this is some content.'
+
+        try:
+            with zipfile.ZipFile(TESTFN, 'a') as zf:
+                zf.writestr(filename, content)
+        except OSError:
+            self.fail('Could not append data to a non-existent zip file.')
+
+        self.assertTrue(os.path.exists(TESTFN))
+
+        with zipfile.ZipFile(TESTFN, 'r') as zf:
+            self.assertEqual(zf.read(filename), content)
+
+    def test_close_erroneous_file(self):
+        # This test checks that the ZipFile constructor closes the file object
+        # it opens if there's an error in the file.  If it doesn't, the
+        # traceback holds a reference to the ZipFile object and, indirectly,
+        # the file object.
+        # On Windows, this causes the os.unlink() call to fail because the
+        # underlying file is still open.  This is SF bug #412214.
+        #
+        with open(TESTFN, "w", encoding="utf-8") as fp:
+            fp.write("this is not a legal zip file\n")
+        try:
+            zf = zipfile.ZipFile(TESTFN)
+        except zipfile.BadZipFile:
+            pass
+
+    def test_is_zip_erroneous_file(self):
+        """Check that is_zipfile() correctly identifies non-zip files."""
+        # - passing a filename
+        with open(TESTFN, "w", encoding='utf-8') as fp:
+            fp.write("this is not a legal zip file\n")
+        self.assertFalse(zipfile.is_zipfile(TESTFN))
+        # - passing a path-like object
+        self.assertFalse(zipfile.is_zipfile(FakePath(TESTFN)))
+        # - passing a file object
+        with open(TESTFN, "rb") as fp:
+            self.assertFalse(zipfile.is_zipfile(fp))
+        # - passing a file-like object
+        fp = io.BytesIO()
+        fp.write(b"this is not a legal zip file\n")
+        self.assertFalse(zipfile.is_zipfile(fp))
+        fp.seek(0, 0)
+        self.assertFalse(zipfile.is_zipfile(fp))
+
+    def test_damaged_zipfile(self):
+        """Check that zipfiles with missing bytes at the end raise BadZipFile."""
+        # - Create a valid zip file
+        fp = io.BytesIO()
+        with zipfile.ZipFile(fp, mode="w") as zipf:
+            zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
+        zipfiledata = fp.getvalue()
+
+        # - Now create copies of it missing the last N bytes and make sure
+        #   a BadZipFile exception is raised when we try to open it
+        for N in range(len(zipfiledata)):
+            fp = io.BytesIO(zipfiledata[:N])
+            self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, fp)
+
+    def test_is_zip_valid_file(self):
+        """Check that is_zipfile() correctly identifies zip files."""
+        # - passing a filename
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.writestr("foo.txt", b"O, for a Muse of Fire!")
+
+        self.assertTrue(zipfile.is_zipfile(TESTFN))
+        # - passing a file object
+        with open(TESTFN, "rb") as fp:
+            self.assertTrue(zipfile.is_zipfile(fp))
+            fp.seek(0, 0)
+            zip_contents = fp.read()
+        # - passing a file-like object
+        fp = io.BytesIO()
+        fp.write(zip_contents)
+        self.assertTrue(zipfile.is_zipfile(fp))
+        fp.seek(0, 0)
+        self.assertTrue(zipfile.is_zipfile(fp))
+
+    def test_non_existent_file_raises_OSError(self):
+        # make sure we don't raise an AttributeError when a partially-constructed
+        # ZipFile instance is finalized; this tests for regression on SF tracker
+        # bug #403871.
+
+        # The bug we're testing for caused an AttributeError to be raised
+        # when a ZipFile instance was created for a file that did not
+        # exist; the .fp member was not initialized but was needed by the
+        # __del__() method.  Since the AttributeError is in the __del__(),
+        # it is ignored, but the user should be sufficiently annoyed by
+        # the message on the output that regression will be noticed
+        # quickly.
+        self.assertRaises(OSError, zipfile.ZipFile, TESTFN)
+
+    def test_empty_file_raises_BadZipFile(self):
+        f = open(TESTFN, 'w', encoding='utf-8')
+        f.close()
+        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
+
+        with open(TESTFN, 'w', encoding='utf-8') as fp:
+            fp.write("short file")
+        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN)
+
+    def test_negative_central_directory_offset_raises_BadZipFile(self):
+        # Zip file containing an empty EOCD record
+        buffer = bytearray(b'PK\x05\x06' + b'\0'*18)
+
+        # Set the size of the central directory bytes to become 1,
+        # causing the central directory offset to become negative
+        for dirsize in 1, 2**32-1:
+            buffer[12:16] = struct.pack('<L', dirsize)
+            f = io.BytesIO(buffer)
+            self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, f)
+
+    def test_closed_zip_raises_ValueError(self):
+        """Verify that testzip() doesn't swallow inappropriate exceptions."""
+        data = io.BytesIO()
+        with zipfile.ZipFile(data, mode="w") as zipf:
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+
+        # This is correct; calling .read on a closed ZipFile should raise
+        # a ValueError, and so should calling .testzip.  An earlier
+        # version of .testzip would swallow this exception (and any other)
+        # and report that the first file in the archive was corrupt.
+        self.assertRaises(ValueError, zipf.read, "foo.txt")
+        self.assertRaises(ValueError, zipf.open, "foo.txt")
+        self.assertRaises(ValueError, zipf.testzip)
+        self.assertRaises(ValueError, zipf.writestr, "bogus.txt", "bogus")
+        with open(TESTFN, 'w', encoding='utf-8') as f:
+            f.write('zipfile test data')
+        self.assertRaises(ValueError, zipf.write, TESTFN)
+
+    def test_bad_constructor_mode(self):
+        """Check that bad modes passed to ZipFile constructor are caught."""
+        self.assertRaises(ValueError, zipfile.ZipFile, TESTFN, "q")
+
+    def test_bad_open_mode(self):
+        """Check that bad modes passed to ZipFile.open are caught."""
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+
+        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
+            # read the data to make sure the file is there
+            zipf.read("foo.txt")
+            self.assertRaises(ValueError, zipf.open, "foo.txt", "q")
+            # universal newlines support is removed
+            self.assertRaises(ValueError, zipf.open, "foo.txt", "U")
+            self.assertRaises(ValueError, zipf.open, "foo.txt", "rU")
+
+    def test_read0(self):
+        """Check that calling read(0) on a ZipExtFile object returns an empty
+        string and doesn't advance file pointer."""
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+            # read the data to make sure the file is there
+            with zipf.open("foo.txt") as f:
+                for i in range(FIXEDTEST_SIZE):
+                    self.assertEqual(f.read(0), b'')
+
+                self.assertEqual(f.read(), b"O, for a Muse of Fire!")
+
+    def test_open_non_existent_item(self):
+        """Check that attempting to call open() for an item that doesn't
+        exist in the archive raises a RuntimeError."""
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            self.assertRaises(KeyError, zipf.open, "foo.txt", "r")
+
+    def test_bad_compression_mode(self):
+        """Check that bad compression methods passed to ZipFile.open are
+        caught."""
+        self.assertRaises(NotImplementedError, zipfile.ZipFile, TESTFN, "w", -1)
+
+    def test_unsupported_compression(self):
+        # data is declared as shrunk, but actually deflated
+        data = (b'PK\x03\x04.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00'
+                b'\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00x\x03\x00PK\x01'
+                b'\x02.\x03.\x00\x00\x00\x01\x00\xe4C\xa1@\x00\x00\x00\x00\x02\x00\x00'
+                b'\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+                b'\x80\x01\x00\x00\x00\x00xPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00'
+                b'/\x00\x00\x00!\x00\x00\x00\x00\x00')
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertRaises(NotImplementedError, zipf.open, 'x')
+
+    def test_null_byte_in_filename(self):
+        """Check that a filename containing a null byte is properly
+        terminated."""
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.writestr("foo.txt\x00qqq", b"O, for a Muse of Fire!")
+            self.assertEqual(zipf.namelist(), ['foo.txt'])
+
+    def test_struct_sizes(self):
+        """Check that ZIP internal structure sizes are calculated correctly."""
+        self.assertEqual(zipfile.sizeEndCentDir, 22)
+        self.assertEqual(zipfile.sizeCentralDir, 46)
+        self.assertEqual(zipfile.sizeEndCentDir64, 56)
+        self.assertEqual(zipfile.sizeEndCentDir64Locator, 20)
+
+    def test_comments(self):
+        """Check that comments on the archive are handled properly."""
+
+        # check default comment is empty
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            self.assertEqual(zipf.comment, b'')
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+
+        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
+            self.assertEqual(zipfr.comment, b'')
+
+        # check a simple short comment
+        comment = b'Bravely taking to his feet, he beat a very brave retreat.'
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.comment = comment
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
+            self.assertEqual(zipf.comment, comment)
+
+        # check a comment of max length
+        comment2 = ''.join(['%d' % (i**3 % 10) for i in range((1 << 16)-1)])
+        comment2 = comment2.encode("ascii")
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            zipf.comment = comment2
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+
+        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
+            self.assertEqual(zipfr.comment, comment2)
+
+        # check a comment that is too long is truncated
+        with zipfile.ZipFile(TESTFN, mode="w") as zipf:
+            with self.assertWarns(UserWarning):
+                zipf.comment = comment2 + b'oops'
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        with zipfile.ZipFile(TESTFN, mode="r") as zipfr:
+            self.assertEqual(zipfr.comment, comment2)
+
+        # check that comments are correctly modified in append mode
+        with zipfile.ZipFile(TESTFN,mode="w") as zipf:
+            zipf.comment = b"original comment"
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        with zipfile.ZipFile(TESTFN,mode="a") as zipf:
+            zipf.comment = b"an updated comment"
+        with zipfile.ZipFile(TESTFN,mode="r") as zipf:
+            self.assertEqual(zipf.comment, b"an updated comment")
+
+        # check that comments are correctly shortened in append mode
+        # and the file is indeed truncated
+        with zipfile.ZipFile(TESTFN,mode="w") as zipf:
+            zipf.comment = b"original comment that's longer"
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        original_zip_size = os.path.getsize(TESTFN)
+        with zipfile.ZipFile(TESTFN,mode="a") as zipf:
+            zipf.comment = b"shorter comment"
+        self.assertTrue(original_zip_size > os.path.getsize(TESTFN))
+        with zipfile.ZipFile(TESTFN,mode="r") as zipf:
+            self.assertEqual(zipf.comment, b"shorter comment")
+
+    def test_unicode_comment(self):
+        with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+            with self.assertRaises(TypeError):
+                zipf.comment = "this is an error"
+
+    def test_change_comment_in_empty_archive(self):
+        with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
+            self.assertFalse(zipf.filelist)
+            zipf.comment = b"this is a comment"
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            self.assertEqual(zipf.comment, b"this is a comment")
+
+    def test_change_comment_in_nonempty_archive(self):
+        with zipfile.ZipFile(TESTFN, "w", zipfile.ZIP_STORED) as zipf:
+            zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        with zipfile.ZipFile(TESTFN, "a", zipfile.ZIP_STORED) as zipf:
+            self.assertTrue(zipf.filelist)
+            zipf.comment = b"this is a comment"
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            self.assertEqual(zipf.comment, b"this is a comment")
+
+    def test_empty_zipfile(self):
+        # Check that creating a file in 'w' or 'a' mode and closing without
+        # adding any files to the archives creates a valid empty ZIP file
+        zipf = zipfile.ZipFile(TESTFN, mode="w")
+        zipf.close()
+        try:
+            zipf = zipfile.ZipFile(TESTFN, mode="r")
+        except zipfile.BadZipFile:
+            self.fail("Unable to create empty ZIP file in 'w' mode")
+        zipf.close()
+
+        zipf = zipfile.ZipFile(TESTFN, mode="a")
+        zipf.close()
+        try:
+            zipf = zipfile.ZipFile(TESTFN, mode="r")
+        except:
+            self.fail("Unable to create empty ZIP file in 'a' mode")
+        zipf.close()
+
+    def test_open_empty_file(self):
+        # Issue 1710703: Check that opening a file with less than 22 bytes
+        # raises a BadZipFile exception (rather than the previously unhelpful
+        # OSError)
+        f = open(TESTFN, 'w', encoding='utf-8')
+        f.close()
+        self.assertRaises(zipfile.BadZipFile, zipfile.ZipFile, TESTFN, 'r')
+
+    def test_create_zipinfo_before_1980(self):
+        self.assertRaises(ValueError,
+                          zipfile.ZipInfo, 'seventies', (1979, 1, 1, 0, 0, 0))
+
+    def test_create_empty_zipinfo_repr(self):
+        """Before bpo-26185, repr() on empty ZipInfo object was failing."""
+        zi = zipfile.ZipInfo(filename="empty")
+        self.assertEqual(repr(zi), "<ZipInfo filename='empty' file_size=0>")
+
+    def test_create_empty_zipinfo_default_attributes(self):
+        """Ensure all required attributes are set."""
+        zi = zipfile.ZipInfo()
+        self.assertEqual(zi.orig_filename, "NoName")
+        self.assertEqual(zi.filename, "NoName")
+        self.assertEqual(zi.date_time, (1980, 1, 1, 0, 0, 0))
+        self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
+        self.assertEqual(zi.comment, b"")
+        self.assertEqual(zi.extra, b"")
+        self.assertIn(zi.create_system, (0, 3))
+        self.assertEqual(zi.create_version, zipfile.DEFAULT_VERSION)
+        self.assertEqual(zi.extract_version, zipfile.DEFAULT_VERSION)
+        self.assertEqual(zi.reserved, 0)
+        self.assertEqual(zi.flag_bits, 0)
+        self.assertEqual(zi.volume, 0)
+        self.assertEqual(zi.internal_attr, 0)
+        self.assertEqual(zi.external_attr, 0)
+
+        # Before bpo-26185, both were missing
+        self.assertEqual(zi.file_size, 0)
+        self.assertEqual(zi.compress_size, 0)
+
+    def test_zipfile_with_short_extra_field(self):
+        """If an extra field in the header is less than 4 bytes, skip it."""
+        zipdata = (
+            b'PK\x03\x04\x14\x00\x00\x00\x00\x00\x93\x9b\xad@\x8b\x9e'
+            b'\xd9\xd3\x01\x00\x00\x00\x01\x00\x00\x00\x03\x00\x03\x00ab'
+            b'c\x00\x00\x00APK\x01\x02\x14\x03\x14\x00\x00\x00\x00'
+            b'\x00\x93\x9b\xad@\x8b\x9e\xd9\xd3\x01\x00\x00\x00\x01\x00\x00'
+            b'\x00\x03\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00'
+            b'\x00\x00\x00abc\x00\x00PK\x05\x06\x00\x00\x00\x00'
+            b'\x01\x00\x01\x003\x00\x00\x00%\x00\x00\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(zipdata), 'r') as zipf:
+            # testzip returns the name of the first corrupt file, or None
+            self.assertIsNone(zipf.testzip())
+
+    def test_open_conflicting_handles(self):
+        # It's only possible to open one writable file handle at a time
+        msg1 = b"It's fun to charter an accountant!"
+        msg2 = b"And sail the wide accountant sea"
+        msg3 = b"To find, explore the funds offshore"
+        with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_STORED) as zipf:
+            with zipf.open('foo', mode='w') as w2:
+                w2.write(msg1)
+            with zipf.open('bar', mode='w') as w1:
+                with self.assertRaises(ValueError):
+                    zipf.open('handle', mode='w')
+                with self.assertRaises(ValueError):
+                    zipf.open('foo', mode='r')
+                with self.assertRaises(ValueError):
+                    zipf.writestr('str', 'abcde')
+                with self.assertRaises(ValueError):
+                    zipf.write(__file__, 'file')
+                with self.assertRaises(ValueError):
+                    zipf.close()
+                w1.write(msg2)
+            with zipf.open('baz', mode='w') as w2:
+                w2.write(msg3)
+
+        with zipfile.ZipFile(TESTFN2, 'r') as zipf:
+            self.assertEqual(zipf.read('foo'), msg1)
+            self.assertEqual(zipf.read('bar'), msg2)
+            self.assertEqual(zipf.read('baz'), msg3)
+            self.assertEqual(zipf.namelist(), ['foo', 'bar', 'baz'])
+
+    def test_seek_tell(self):
+        # Test seek functionality
+        txt = b"Where's Bruce?"
+        bloc = txt.find(b"Bruce")
+        # Check seek on a file
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("foo.txt", txt)
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.seek(bloc, os.SEEK_SET)
+                self.assertEqual(fp.tell(), bloc)
+                fp.seek(-bloc, os.SEEK_CUR)
+                self.assertEqual(fp.tell(), 0)
+                fp.seek(bloc, os.SEEK_CUR)
+                self.assertEqual(fp.tell(), bloc)
+                self.assertEqual(fp.read(5), txt[bloc:bloc+5])
+                self.assertEqual(fp.tell(), bloc + 5)
+                fp.seek(0, os.SEEK_END)
+                self.assertEqual(fp.tell(), len(txt))
+                fp.seek(0, os.SEEK_SET)
+                self.assertEqual(fp.tell(), 0)
+        # Check seek on memory file
+        data = io.BytesIO()
+        with zipfile.ZipFile(data, mode="w") as zipf:
+            zipf.writestr("foo.txt", txt)
+        with zipfile.ZipFile(data, mode="r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.seek(bloc, os.SEEK_SET)
+                self.assertEqual(fp.tell(), bloc)
+                fp.seek(-bloc, os.SEEK_CUR)
+                self.assertEqual(fp.tell(), 0)
+                fp.seek(bloc, os.SEEK_CUR)
+                self.assertEqual(fp.tell(), bloc)
+                self.assertEqual(fp.read(5), txt[bloc:bloc+5])
+                self.assertEqual(fp.tell(), bloc + 5)
+                fp.seek(0, os.SEEK_END)
+                self.assertEqual(fp.tell(), len(txt))
+                fp.seek(0, os.SEEK_SET)
+                self.assertEqual(fp.tell(), 0)
+
+    def test_read_after_seek(self):
+        # Issue 102956: Make sure seek(x, os.SEEK_CUR) doesn't break read()
+        txt = b"Charge men!"
+        bloc = txt.find(b"men")
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("foo.txt", txt)
+        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.seek(bloc, os.SEEK_CUR)
+                self.assertEqual(fp.read(-1), b'men!')
+        with zipfile.ZipFile(TESTFN, mode="r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                fp.read(6)
+                fp.seek(1, os.SEEK_CUR)
+                self.assertEqual(fp.read(-1), b'men!')
+
+    def test_uncompressed_interleaved_seek_read(self):
+        # gh-127847: Make sure the position in the archive is correct
+        # in the special case of seeking in a ZIP_STORED entry.
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("a.txt", "123")
+            zipf.writestr("b.txt", "456")
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            with zipf.open("a.txt", "r") as a, zipf.open("b.txt", "r") as b:
+                self.assertEqual(a.read(1), b"1")
+                self.assertEqual(b.seek(1), 1)
+                self.assertEqual(b.read(1), b"5")
+
+    @requires_bz2()
+    def test_decompress_without_3rd_party_library(self):
+        data = b'PK\x05\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+        zip_file = io.BytesIO(data)
+        with zipfile.ZipFile(zip_file, 'w', compression=zipfile.ZIP_BZIP2) as zf:
+            zf.writestr('a.txt', b'a')
+        with mock.patch('zipfile.bz2', None):
+            with zipfile.ZipFile(zip_file) as zf:
+                self.assertRaises(RuntimeError, zf.extract, 'a.txt')
+
+    @requires_zlib()
+    def test_full_overlap_different_names(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00b\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00bPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            self.assertEqual(len(zipf.read('b')), 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'File name.*differ'):
+                zipf.read('a')
+
+    @requires_zlib()
+    def test_full_overlap_different_names2(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00a\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00bPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'File name.*differ'):
+                zipf.read('b')
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                self.assertEqual(len(zipf.read('a')), 1033)
+            self.assertEqual(cm.filename, __file__)
+
+    @requires_zlib()
+    def test_full_overlap_same_name(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00a\xed'
+            b'\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\d\x0b`P'
+            b'K\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2'
+            b'\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK'
+            b'\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0lH\x05\xe2\x1e'
+            b'8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00aPK\x05'
+            b'\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00\x00/\x00\x00'
+            b'\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'a'])
+            self.assertEqual(len(zipf.infolist()), 2)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            self.assertEqual(len(zipf.read('a')), 1033)
+            self.assertEqual(len(zipf.read(zi)), 1033)
+            self.assertEqual(len(zipf.read(zipf.infolist()[1])), 1033)
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                self.assertEqual(len(zipf.read(zipf.infolist()[0])), 1033)
+            self.assertEqual(cm.filename, __file__)
+            with self.assertWarnsRegex(UserWarning, 'Overlapped entries') as cm:
+                zipf.open(zipf.infolist()[0]).close()
+            self.assertEqual(cm.filename, __file__)
+
+    @requires_zlib()
+    def test_quoted_overlap(self):
+        data = (
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00\xa0lH\x05Y\xfc'
+            b'8\x044\x00\x00\x00(\x04\x00\x00\x01\x00\x00\x00a\x00'
+            b'\x1f\x00\xe0\xffPK\x03\x04\x14\x00\x00\x00\x08\x00\xa0l'
+            b'H\x05\xe2\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00'
+            b'\x00\x00b\xed\xc0\x81\x08\x00\x00\x00\xc00\xd6\xfbK\\'
+            b'd\x0b`PK\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0'
+            b'lH\x05Y\xfc8\x044\x00\x00\x00(\x04\x00\x00\x01'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+            b'\x00aPK\x01\x02\x14\x00\x14\x00\x00\x00\x08\x00\xa0l'
+            b'H\x05\xe2\x1e8\xbb\x10\x00\x00\x00\t\x04\x00\x00\x01\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00$\x00\x00\x00'
+            b'bPK\x05\x06\x00\x00\x00\x00\x02\x00\x02\x00^\x00\x00'
+            b'\x00S\x00\x00\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a', 'b'])
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 52)
+            self.assertEqual(zi.file_size, 1064)
+            zi = zipf.getinfo('b')
+            self.assertEqual(zi.header_offset, 36)
+            self.assertEqual(zi.compress_size, 16)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Overlapped entries'):
+                zipf.read('a')
+            self.assertEqual(len(zipf.read('b')), 1033)
+
+    @requires_zlib()
+    def test_overlap_with_central_dir(self):
+        data = (
+            b'PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00G_|Z'
+            b'\xe2\x1e8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x81\x00\x00\x00\x00aP'
+            b'K\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a'])
+            self.assertEqual(len(zipf.infolist()), 1)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 0)
+            self.assertEqual(zi.compress_size, 11)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Bad magic number'):
+                zipf.read('a')
+
+    @requires_zlib()
+    def test_overlap_with_archive_comment(self):
+        data = (
+            b'PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00G_|Z'
+            b'\xe2\x1e8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00'
+            b'\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x81E\x00\x00\x00aP'
+            b'K\x05\x06\x00\x00\x00\x00\x01\x00\x01\x00/\x00\x00\x00\x00'
+            b'\x00\x00\x00*\x00'
+            b'PK\x03\x04\x14\x00\x00\x00\x08\x00G_|Z\xe2\x1e'
+            b'8\xbb\x0b\x00\x00\x00\t\x04\x00\x00\x01\x00\x00\x00aK'
+            b'L\x1c\x05\xa3`\x14\x8cx\x00\x00'
+        )
+        with zipfile.ZipFile(io.BytesIO(data), 'r') as zipf:
+            self.assertEqual(zipf.namelist(), ['a'])
+            self.assertEqual(len(zipf.infolist()), 1)
+            zi = zipf.getinfo('a')
+            self.assertEqual(zi.header_offset, 69)
+            self.assertEqual(zi.compress_size, 11)
+            self.assertEqual(zi.file_size, 1033)
+            with self.assertRaisesRegex(zipfile.BadZipFile, 'Overlapped entries'):
+                zipf.read('a')
+
+    def tearDown(self):
+        unlink(TESTFN)
+        unlink(TESTFN2)
+
+
+class AbstractBadCrcTests:
+    def test_testzip_with_bad_crc(self):
+        """Tests that files with bad CRCs return their name from testzip."""
+        zipdata = self.zip_with_bad_crc
+
+        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
+            # testzip returns the name of the first corrupt file, or None
+            self.assertEqual('afile', zipf.testzip())
+
+    def test_read_with_bad_crc(self):
+        """Tests that files with bad CRCs raise a BadZipFile exception when read."""
+        zipdata = self.zip_with_bad_crc
+
+        # Using ZipFile.read()
+        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
+            self.assertRaises(zipfile.BadZipFile, zipf.read, 'afile')
+
+        # Using ZipExtFile.read()
+        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
+            with zipf.open('afile', 'r') as corrupt_file:
+                self.assertRaises(zipfile.BadZipFile, corrupt_file.read)
+
+        # Same with small reads (in order to exercise the buffering logic)
+        with zipfile.ZipFile(io.BytesIO(zipdata), mode="r") as zipf:
+            with zipf.open('afile', 'r') as corrupt_file:
+                corrupt_file.MIN_READ_SIZE = 2
+                with self.assertRaises(zipfile.BadZipFile):
+                    while corrupt_file.read(2):
+                        pass
+
+
+class StoredBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+    zip_with_bad_crc = (
+        b'PK\003\004\024\0\0\0\0\0 \213\212;:r'
+        b'\253\377\f\0\0\0\f\0\0\0\005\0\0\000af'
+        b'ilehello,AworldP'
+        b'K\001\002\024\003\024\0\0\0\0\0 \213\212;:'
+        b'r\253\377\f\0\0\0\f\0\0\0\005\0\0\0\0'
+        b'\0\0\0\0\0\0\0\200\001\0\0\0\000afi'
+        b'lePK\005\006\0\0\0\0\001\0\001\0003\000'
+        b'\0\0/\0\0\0\0\0')
+
+@requires_zlib()
+class DeflateBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+    zip_with_bad_crc = (
+        b'PK\x03\x04\x14\x00\x00\x00\x08\x00n}\x0c=FA'
+        b'KE\x10\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
+        b'ile\xcbH\xcd\xc9\xc9W(\xcf/\xcaI\xc9\xa0'
+        b'=\x13\x00PK\x01\x02\x14\x03\x14\x00\x00\x00\x08\x00n'
+        b'}\x0c=FAKE\x10\x00\x00\x00n\x00\x00\x00\x05'
+        b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00'
+        b'\x00afilePK\x05\x06\x00\x00\x00\x00\x01\x00'
+        b'\x01\x003\x00\x00\x003\x00\x00\x00\x00\x00')
+
+@requires_bz2()
+class Bzip2BadCrcTests(AbstractBadCrcTests, unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+    zip_with_bad_crc = (
+        b'PK\x03\x04\x14\x03\x00\x00\x0c\x00nu\x0c=FA'
+        b'KE8\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
+        b'ileBZh91AY&SY\xd4\xa8\xca'
+        b'\x7f\x00\x00\x0f\x11\x80@\x00\x06D\x90\x80 \x00 \xa5'
+        b'P\xd9!\x03\x03\x13\x13\x13\x89\xa9\xa9\xc2u5:\x9f'
+        b'\x8b\xb9"\x9c(HjTe?\x80PK\x01\x02\x14'
+        b'\x03\x14\x03\x00\x00\x0c\x00nu\x0c=FAKE8'
+        b'\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00'
+        b'\x00 \x80\x80\x81\x00\x00\x00\x00afilePK'
+        b'\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00\x00[\x00'
+        b'\x00\x00\x00\x00')
+
+@requires_lzma()
+class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+    zip_with_bad_crc = (
+        b'PK\x03\x04\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
+        b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00af'
+        b'ile\t\x04\x05\x00]\x00\x00\x00\x04\x004\x19I'
+        b'\xee\x8d\xe9\x17\x89:3`\tq!.8\x00PK'
+        b'\x01\x02\x14\x03\x14\x03\x00\x00\x0e\x00nu\x0c=FA'
+        b'KE\x1b\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x00\x00'
+        b'\x00\x00\x00\x00 \x80\x80\x81\x00\x00\x00\x00afil'
+        b'ePK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x003\x00\x00'
+        b'\x00>\x00\x00\x00\x00\x00')
+
+
+class DecryptionTests(unittest.TestCase):
+    """Check that ZIP decryption works. Since the library does not
+    support encryption at the moment, we use a pre-generated encrypted
+    ZIP file."""
+
+    data = (
+        b'PK\x03\x04\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00\x1a\x00'
+        b'\x00\x00\x08\x00\x00\x00test.txt\xfa\x10\xa0gly|\xfa-\xc5\xc0=\xf9y'
+        b'\x18\xe0\xa8r\xb3Z}Lg\xbc\xae\xf9|\x9b\x19\xe4\x8b\xba\xbb)\x8c\xb0\xdbl'
+        b'PK\x01\x02\x14\x00\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00'
+        b'\x1a\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x01\x00 \x00\xb6\x81'
+        b'\x00\x00\x00\x00test.txtPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x006\x00'
+        b'\x00\x00L\x00\x00\x00\x00\x00' )
+    data2 = (
+        b'PK\x03\x04\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02'
+        b'\x00\x00\x04\x00\x15\x00zeroUT\t\x00\x03\xd6\x8b\x92G\xda\x8b\x92GUx\x04'
+        b'\x00\xe8\x03\xe8\x03\xc7<M\xb5a\xceX\xa3Y&\x8b{oE\xd7\x9d\x8c\x98\x02\xc0'
+        b'PK\x07\x08xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00PK\x01\x02\x17\x03'
+        b'\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02\x00\x00'
+        b'\x04\x00\r\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00ze'
+        b'roUT\x05\x00\x03\xd6\x8b\x92GUx\x00\x00PK\x05\x06\x00\x00\x00\x00\x01'
+        b'\x00\x01\x00?\x00\x00\x00[\x00\x00\x00\x00\x00' )
+
+    plain = b'zipfile.py encryption test'
+    plain2 = b'\x00'*512
+
+    def setUp(self):
+        with open(TESTFN, "wb") as fp:
+            fp.write(self.data)
+        self.zip = zipfile.ZipFile(TESTFN, "r")
+        with open(TESTFN2, "wb") as fp:
+            fp.write(self.data2)
+        self.zip2 = zipfile.ZipFile(TESTFN2, "r")
+
+    def tearDown(self):
+        self.zip.close()
+        os.unlink(TESTFN)
+        self.zip2.close()
+        os.unlink(TESTFN2)
+
+    def test_no_password(self):
+        # Reading the encrypted file without password
+        # must generate a RunTime exception
+        self.assertRaises(RuntimeError, self.zip.read, "test.txt")
+        self.assertRaises(RuntimeError, self.zip2.read, "zero")
+
+    def test_bad_password(self):
+        self.zip.setpassword(b"perl")
+        self.assertRaises(RuntimeError, self.zip.read, "test.txt")
+        self.zip2.setpassword(b"perl")
+        self.assertRaises(RuntimeError, self.zip2.read, "zero")
+
+    @requires_zlib()
+    def test_good_password(self):
+        self.zip.setpassword(b"python")
+        self.assertEqual(self.zip.read("test.txt"), self.plain)
+        self.zip2.setpassword(b"12345")
+        self.assertEqual(self.zip2.read("zero"), self.plain2)
+
+    def test_unicode_password(self):
+        expected_msg = "pwd: expected bytes, got str"
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.setpassword("unicode")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.read("test.txt", "python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.open("test.txt", pwd="python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.extract("test.txt", pwd="python")
+
+        with self.assertRaisesRegex(TypeError, expected_msg):
+            self.zip.pwd = "python"
+            self.zip.open("test.txt")
+
+    def test_seek_tell(self):
+        self.zip.setpassword(b"python")
+        txt = self.plain
+        test_word = b'encryption'
+        bloc = txt.find(test_word)
+        bloc_len = len(test_word)
+        with self.zip.open("test.txt", "r") as fp:
+            fp.seek(bloc, os.SEEK_SET)
+            self.assertEqual(fp.tell(), bloc)
+            fp.seek(-bloc, os.SEEK_CUR)
+            self.assertEqual(fp.tell(), 0)
+            fp.seek(bloc, os.SEEK_CUR)
+            self.assertEqual(fp.tell(), bloc)
+            self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
+
+            # Make sure that the second read after seeking back beyond
+            # _readbuffer returns the same content (ie. rewind to the start of
+            # the file to read forward to the required position).
+            old_read_size = fp.MIN_READ_SIZE
+            fp.MIN_READ_SIZE = 1
+            fp._readbuffer = b''
+            fp._offset = 0
+            fp.seek(0, os.SEEK_SET)
+            self.assertEqual(fp.tell(), 0)
+            fp.seek(bloc, os.SEEK_CUR)
+            self.assertEqual(fp.read(bloc_len), txt[bloc:bloc+bloc_len])
+            fp.MIN_READ_SIZE = old_read_size
+
+            fp.seek(0, os.SEEK_END)
+            self.assertEqual(fp.tell(), len(txt))
+            fp.seek(0, os.SEEK_SET)
+            self.assertEqual(fp.tell(), 0)
+
+            # Read the file completely to definitely call any eof integrity
+            # checks (crc) and make sure they still pass.
+            fp.read()
+
+
+class AbstractTestsWithRandomBinaryFiles:
+    @classmethod
+    def setUpClass(cls):
+        datacount = randint(16, 64)*1024 + randint(1, 1024)
+        cls.data = b''.join(struct.pack('<f', random()*randint(-1000, 1000))
+                            for i in range(datacount))
+
+    def setUp(self):
+        # Make a source file with some lines
+        with open(TESTFN, "wb") as fp:
+            fp.write(self.data)
+
+    def tearDown(self):
+        unlink(TESTFN)
+        unlink(TESTFN2)
+
+    def make_test_archive(self, f, compression):
+        # Create the ZIP archive
+        with zipfile.ZipFile(f, "w", compression) as zipfp:
+            zipfp.write(TESTFN, "another.name")
+            zipfp.write(TESTFN, TESTFN)
+
+    def zip_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            testdata = zipfp.read(TESTFN)
+            self.assertEqual(len(testdata), len(self.data))
+            self.assertEqual(testdata, self.data)
+            self.assertEqual(zipfp.read("another.name"), self.data)
+
+    def test_read(self):
+        for f in get_files(self):
+            self.zip_test(f, self.compression)
+
+    def zip_open_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            zipdata1 = []
+            with zipfp.open(TESTFN) as zipopen1:
+                while True:
+                    read_data = zipopen1.read(256)
+                    if not read_data:
+                        break
+                    zipdata1.append(read_data)
+
+            zipdata2 = []
+            with zipfp.open("another.name") as zipopen2:
+                while True:
+                    read_data = zipopen2.read(256)
+                    if not read_data:
+                        break
+                    zipdata2.append(read_data)
+
+            testdata1 = b''.join(zipdata1)
+            self.assertEqual(len(testdata1), len(self.data))
+            self.assertEqual(testdata1, self.data)
+
+            testdata2 = b''.join(zipdata2)
+            self.assertEqual(len(testdata2), len(self.data))
+            self.assertEqual(testdata2, self.data)
+
+    def test_open(self):
+        for f in get_files(self):
+            self.zip_open_test(f, self.compression)
+
+    def zip_random_open_test(self, f, compression):
+        self.make_test_archive(f, compression)
+
+        # Read the ZIP archive
+        with zipfile.ZipFile(f, "r", compression) as zipfp:
+            zipdata1 = []
+            with zipfp.open(TESTFN) as zipopen1:
+                while True:
+                    read_data = zipopen1.read(randint(1, 1024))
+                    if not read_data:
+                        break
+                    zipdata1.append(read_data)
+
+            testdata = b''.join(zipdata1)
+            self.assertEqual(len(testdata), len(self.data))
+            self.assertEqual(testdata, self.data)
+
+    def test_random_open(self):
+        for f in get_files(self):
+            self.zip_random_open_test(f, self.compression)
+
+
+class StoredTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
+                                       unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+
+@requires_zlib()
+class DeflateTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
+                                        unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+
+@requires_bz2()
+class Bzip2TestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
+                                      unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+
+@requires_lzma()
+class LzmaTestsWithRandomBinaryFiles(AbstractTestsWithRandomBinaryFiles,
+                                     unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+
+
+# Provide the tell() method but not seek()
+class Tellable:
+    def __init__(self, fp):
+        self.fp = fp
+        self.offset = 0
+
+    def write(self, data):
+        n = self.fp.write(data)
+        self.offset += n
+        return n
+
+    def tell(self):
+        return self.offset
+
+    def flush(self):
+        self.fp.flush()
+
+class Unseekable:
+    def __init__(self, fp):
+        self.fp = fp
+
+    def write(self, data):
+        return self.fp.write(data)
+
+    def flush(self):
+        self.fp.flush()
+
+class UnseekableTests(unittest.TestCase):
+    def test_writestr(self):
+        for wrapper in (lambda f: f), Tellable, Unseekable:
+            with self.subTest(wrapper=wrapper):
+                f = io.BytesIO()
+                f.write(b'abc')
+                bf = io.BufferedWriter(f)
+                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
+                    zipfp.writestr('ones', b'111')
+                    zipfp.writestr('twos', b'222')
+                self.assertEqual(f.getvalue()[:5], b'abcPK')
+                with zipfile.ZipFile(f, mode='r') as zipf:
+                    with zipf.open('ones') as zopen:
+                        self.assertEqual(zopen.read(), b'111')
+                    with zipf.open('twos') as zopen:
+                        self.assertEqual(zopen.read(), b'222')
+
+    def test_write(self):
+        for wrapper in (lambda f: f), Tellable, Unseekable:
+            with self.subTest(wrapper=wrapper):
+                f = io.BytesIO()
+                f.write(b'abc')
+                bf = io.BufferedWriter(f)
+                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipfp:
+                    self.addCleanup(unlink, TESTFN)
+                    with open(TESTFN, 'wb') as f2:
+                        f2.write(b'111')
+                    zipfp.write(TESTFN, 'ones')
+                    with open(TESTFN, 'wb') as f2:
+                        f2.write(b'222')
+                    zipfp.write(TESTFN, 'twos')
+                self.assertEqual(f.getvalue()[:5], b'abcPK')
+                with zipfile.ZipFile(f, mode='r') as zipf:
+                    with zipf.open('ones') as zopen:
+                        self.assertEqual(zopen.read(), b'111')
+                    with zipf.open('twos') as zopen:
+                        self.assertEqual(zopen.read(), b'222')
+
+    def test_open_write(self):
+        for wrapper in (lambda f: f), Tellable, Unseekable:
+            with self.subTest(wrapper=wrapper):
+                f = io.BytesIO()
+                f.write(b'abc')
+                bf = io.BufferedWriter(f)
+                with zipfile.ZipFile(wrapper(bf), 'w', zipfile.ZIP_STORED) as zipf:
+                    with zipf.open('ones', 'w') as zopen:
+                        zopen.write(b'111')
+                    with zipf.open('twos', 'w') as zopen:
+                        zopen.write(b'222')
+                self.assertEqual(f.getvalue()[:5], b'abcPK')
+                with zipfile.ZipFile(f) as zipf:
+                    self.assertEqual(zipf.read('ones'), b'111')
+                    self.assertEqual(zipf.read('twos'), b'222')
+
+
+@requires_zlib()
+class TestsWithMultipleOpens(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.data1 = b'111' + randbytes(10000)
+        cls.data2 = b'222' + randbytes(10000)
+
+    def make_test_archive(self, f):
+        # Create the ZIP archive
+        with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipfp:
+            zipfp.writestr('ones', self.data1)
+            zipfp.writestr('twos', self.data2)
+
+    def test_same_file(self):
+        # Verify that (when the ZipFile is in control of creating file objects)
+        # multiple open() calls can be made without interfering with each other.
+        for f in get_files(self):
+            self.make_test_archive(f)
+            with zipfile.ZipFile(f, mode="r") as zipf:
+                with zipf.open('ones') as zopen1, zipf.open('ones') as zopen2:
+                    data1 = zopen1.read(500)
+                    data2 = zopen2.read(500)
+                    data1 += zopen1.read()
+                    data2 += zopen2.read()
+                self.assertEqual(data1, data2)
+                self.assertEqual(data1, self.data1)
+
+    def test_different_file(self):
+        # Verify that (when the ZipFile is in control of creating file objects)
+        # multiple open() calls can be made without interfering with each other.
+        for f in get_files(self):
+            self.make_test_archive(f)
+            with zipfile.ZipFile(f, mode="r") as zipf:
+                with zipf.open('ones') as zopen1, zipf.open('twos') as zopen2:
+                    data1 = zopen1.read(500)
+                    data2 = zopen2.read(500)
+                    data1 += zopen1.read()
+                    data2 += zopen2.read()
+                self.assertEqual(data1, self.data1)
+                self.assertEqual(data2, self.data2)
+
+    def test_interleaved(self):
+        # Verify that (when the ZipFile is in control of creating file objects)
+        # multiple open() calls can be made without interfering with each other.
+        for f in get_files(self):
+            self.make_test_archive(f)
+            with zipfile.ZipFile(f, mode="r") as zipf:
+                with zipf.open('ones') as zopen1:
+                    data1 = zopen1.read(500)
+                    with zipf.open('twos') as zopen2:
+                        data2 = zopen2.read(500)
+                        data1 += zopen1.read()
+                        data2 += zopen2.read()
+                self.assertEqual(data1, self.data1)
+                self.assertEqual(data2, self.data2)
+
+    def test_read_after_close(self):
+        for f in get_files(self):
+            self.make_test_archive(f)
+            with contextlib.ExitStack() as stack:
+                with zipfile.ZipFile(f, 'r') as zipf:
+                    zopen1 = stack.enter_context(zipf.open('ones'))
+                    zopen2 = stack.enter_context(zipf.open('twos'))
+                data1 = zopen1.read(500)
+                data2 = zopen2.read(500)
+                data1 += zopen1.read()
+                data2 += zopen2.read()
+            self.assertEqual(data1, self.data1)
+            self.assertEqual(data2, self.data2)
+
+    def test_read_after_write(self):
+        for f in get_files(self):
+            with zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                zipf.writestr('ones', self.data1)
+                zipf.writestr('twos', self.data2)
+                with zipf.open('ones') as zopen1:
+                    data1 = zopen1.read(500)
+            self.assertEqual(data1, self.data1[:500])
+            with zipfile.ZipFile(f, 'r') as zipf:
+                data1 = zipf.read('ones')
+                data2 = zipf.read('twos')
+            self.assertEqual(data1, self.data1)
+            self.assertEqual(data2, self.data2)
+
+    def test_write_after_read(self):
+        for f in get_files(self):
+            with zipfile.ZipFile(f, "w", zipfile.ZIP_DEFLATED) as zipf:
+                zipf.writestr('ones', self.data1)
+                with zipf.open('ones') as zopen1:
+                    zopen1.read(500)
+                    zipf.writestr('twos', self.data2)
+            with zipfile.ZipFile(f, 'r') as zipf:
+                data1 = zipf.read('ones')
+                data2 = zipf.read('twos')
+            self.assertEqual(data1, self.data1)
+            self.assertEqual(data2, self.data2)
+
+    def test_many_opens(self):
+        # Verify that read() and open() promptly close the file descriptor,
+        # and don't rely on the garbage collector to free resources.
+        startcount = fd_count()
+        self.make_test_archive(TESTFN2)
+        with zipfile.ZipFile(TESTFN2, mode="r") as zipf:
+            for x in range(100):
+                zipf.read('ones')
+                with zipf.open('ones') as zopen1:
+                    pass
+        self.assertEqual(startcount, fd_count())
+
+    def test_write_while_reading(self):
+        with zipfile.ZipFile(TESTFN2, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            zipf.writestr('ones', self.data1)
+        with zipfile.ZipFile(TESTFN2, 'a', zipfile.ZIP_DEFLATED) as zipf:
+            with zipf.open('ones', 'r') as r1:
+                data1 = r1.read(500)
+                with zipf.open('twos', 'w') as w1:
+                    w1.write(self.data2)
+                data1 += r1.read()
+        self.assertEqual(data1, self.data1)
+        with zipfile.ZipFile(TESTFN2) as zipf:
+            self.assertEqual(zipf.read('twos'), self.data2)
+
+    def tearDown(self):
+        unlink(TESTFN2)
+
+
+class TestWithDirectory(unittest.TestCase):
+    def setUp(self):
+        os.mkdir(TESTFN2)
+
+    def test_extract_dir(self):
+        with zipfile.ZipFile(findfile("zipdir.zip", subdir="archivetestdata")) as zipf:
+            zipf.extractall(TESTFN2)
+        self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
+        self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
+        self.assertTrue(os.path.exists(os.path.join(TESTFN2, "a", "b", "c")))
+
+    def test_bug_6050(self):
+        # Extraction should succeed if directories already exist
+        os.mkdir(os.path.join(TESTFN2, "a"))
+        self.test_extract_dir()
+
+    def test_extract_dir_backslash(self):
+        zfname = findfile("zipdir_backslash.zip", subdir="archivetestdata")
+        with zipfile.ZipFile(zfname) as zipf:
+            zipf.extractall(TESTFN2)
+        if os.name == 'nt':
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "a", "b")))
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "a", "b", "c")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "d")))
+            self.assertTrue(os.path.isdir(os.path.join(TESTFN2, "d", "e")))
+        else:
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "a\\b\\c")))
+            self.assertTrue(os.path.isfile(os.path.join(TESTFN2, "d\\e\\")))
+            self.assertFalse(os.path.exists(os.path.join(TESTFN2, "a")))
+            self.assertFalse(os.path.exists(os.path.join(TESTFN2, "d")))
+
+    def test_write_dir(self):
+        dirpath = os.path.join(TESTFN2, "x")
+        os.mkdir(dirpath)
+        mode = os.stat(dirpath).st_mode & 0xFFFF
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.write(dirpath)
+            zinfo = zipf.filelist[0]
+            self.assertTrue(zinfo.filename.endswith("/x/"))
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+            zipf.write(dirpath, "y")
+            zinfo = zipf.filelist[1]
+            self.assertTrue(zinfo.filename, "y/")
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            zinfo = zipf.filelist[0]
+            self.assertTrue(zinfo.filename.endswith("/x/"))
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+            zinfo = zipf.filelist[1]
+            self.assertTrue(zinfo.filename, "y/")
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zipf.extractall(target)
+            self.assertTrue(os.path.isdir(os.path.join(target, "y")))
+            self.assertEqual(len(os.listdir(target)), 2)
+
+    def test_writestr_dir(self):
+        os.mkdir(os.path.join(TESTFN2, "x"))
+        with zipfile.ZipFile(TESTFN, "w") as zipf:
+            zipf.writestr("x/", b'')
+            zinfo = zipf.filelist[0]
+            self.assertEqual(zinfo.filename, "x/")
+            self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
+        with zipfile.ZipFile(TESTFN, "r") as zipf:
+            zinfo = zipf.filelist[0]
+            self.assertTrue(zinfo.filename.endswith("x/"))
+            self.assertEqual(zinfo.external_attr, (0o40775 << 16) | 0x10)
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zipf.extractall(target)
+            self.assertTrue(os.path.isdir(os.path.join(target, "x")))
+            self.assertEqual(os.listdir(target), ["x"])
+
+    def test_mkdir(self):
+        with zipfile.ZipFile(TESTFN, "w") as zf:
+            zf.mkdir("directory")
+            zinfo = zf.filelist[0]
+            self.assertEqual(zinfo.filename, "directory/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            zf.mkdir("directory2/")
+            zinfo = zf.filelist[1]
+            self.assertEqual(zinfo.filename, "directory2/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            zf.mkdir("directory3", mode=0o777)
+            zinfo = zf.filelist[2]
+            self.assertEqual(zinfo.filename, "directory3/")
+            self.assertEqual(zinfo.external_attr, (0o40777 << 16) | 0x10)
+
+            old_zinfo = zipfile.ZipInfo("directory4/")
+            old_zinfo.external_attr = (0o40777 << 16) | 0x10
+            old_zinfo.CRC = 0
+            old_zinfo.file_size = 0
+            old_zinfo.compress_size = 0
+            zf.mkdir(old_zinfo)
+            new_zinfo = zf.filelist[3]
+            self.assertEqual(old_zinfo.filename, "directory4/")
+            self.assertEqual(old_zinfo.external_attr, new_zinfo.external_attr)
+
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zf.extractall(target)
+            self.assertEqual(set(os.listdir(target)), {"directory", "directory2", "directory3", "directory4"})
+
+    def test_create_directory_with_write(self):
+        with zipfile.ZipFile(TESTFN, "w") as zf:
+            zf.writestr(zipfile.ZipInfo('directory/'), '')
+
+            zinfo = zf.filelist[0]
+            self.assertEqual(zinfo.filename, "directory/")
+
+            directory = os.path.join(TESTFN2, "directory2")
+            os.mkdir(directory)
+            mode = os.stat(directory).st_mode & 0xFFFF
+            zf.write(directory, arcname="directory2/")
+            zinfo = zf.filelist[1]
+            self.assertEqual(zinfo.filename, "directory2/")
+            self.assertEqual(zinfo.external_attr, (mode << 16) | 0x10)
+
+            target = os.path.join(TESTFN2, "target")
+            os.mkdir(target)
+            zf.extractall(target)
+
+            self.assertEqual(set(os.listdir(target)), {"directory", "directory2"})
+
+    def test_root_folder_in_zipfile(self):
+        """
+        gh-112795: Some tools or self constructed codes will add '/' folder to
+        the zip file, this is a strange behavior, but we should support it.
+        """
+        in_memory_file = io.BytesIO()
+        zf = zipfile.ZipFile(in_memory_file, "w")
+        zf.mkdir('/')
+        zf.writestr('./a.txt', 'aaa')
+        zf.extractall(TESTFN2)
+
+    def tearDown(self):
+        rmtree(TESTFN2)
+        if os.path.exists(TESTFN):
+            unlink(TESTFN)
+
+
+class ZipInfoTests(unittest.TestCase):
+    def test_from_file(self):
+        zi = zipfile.ZipInfo.from_file(__file__)
+        self.assertEqual(posixpath.basename(zi.filename), 'test_core.py')
+        self.assertFalse(zi.is_dir())
+        self.assertEqual(zi.file_size, os.path.getsize(__file__))
+
+    def test_from_file_pathlike(self):
+        zi = zipfile.ZipInfo.from_file(FakePath(__file__))
+        self.assertEqual(posixpath.basename(zi.filename), 'test_core.py')
+        self.assertFalse(zi.is_dir())
+        self.assertEqual(zi.file_size, os.path.getsize(__file__))
+
+    def test_from_file_bytes(self):
+        zi = zipfile.ZipInfo.from_file(os.fsencode(__file__), 'test')
+        self.assertEqual(posixpath.basename(zi.filename), 'test')
+        self.assertFalse(zi.is_dir())
+        self.assertEqual(zi.file_size, os.path.getsize(__file__))
+
+    def test_from_file_fileno(self):
+        with open(__file__, 'rb') as f:
+            zi = zipfile.ZipInfo.from_file(f.fileno(), 'test')
+            self.assertEqual(posixpath.basename(zi.filename), 'test')
+            self.assertFalse(zi.is_dir())
+            self.assertEqual(zi.file_size, os.path.getsize(__file__))
+
+    def test_from_dir(self):
+        dirpath = os.path.dirname(os.path.abspath(__file__))
+        zi = zipfile.ZipInfo.from_file(dirpath, 'stdlib_tests')
+        self.assertEqual(zi.filename, 'stdlib_tests/')
+        self.assertTrue(zi.is_dir())
+        self.assertEqual(zi.compress_type, zipfile.ZIP_STORED)
+        self.assertEqual(zi.file_size, 0)
+
+    def test_compresslevel_property(self):
+        zinfo = zipfile.ZipInfo("xxx")
+        self.assertFalse(zinfo._compresslevel)
+        self.assertFalse(zinfo.compress_level)
+        zinfo._compresslevel = 99  # test the legacy @property.setter
+        self.assertEqual(zinfo.compress_level, 99)
+        self.assertEqual(zinfo._compresslevel, 99)
+        zinfo.compress_level = 8
+        self.assertEqual(zinfo.compress_level, 8)
+        self.assertEqual(zinfo._compresslevel, 8)
+
+
+class CommandLineTest(unittest.TestCase):
+
+    def zipfilecmd(self, *args, **kwargs):
+        rc, out, err = script_helper.assert_python_ok('-m', 'zipfile', *args,
+                                                      **kwargs)
+        return out.replace(os.linesep.encode(), b'\n')
+
+    def zipfilecmd_failure(self, *args):
+        return script_helper.assert_python_failure('-m', 'zipfile', *args)
+
+    def test_bad_use(self):
+        rc, out, err = self.zipfilecmd_failure()
+        self.assertEqual(out, b'')
+        self.assertIn(b'usage', err.lower())
+        self.assertIn(b'error', err.lower())
+        self.assertIn(b'required', err.lower())
+        rc, out, err = self.zipfilecmd_failure('-l', '')
+        self.assertEqual(out, b'')
+        self.assertNotEqual(err.strip(), b'')
+
+    def test_test_command(self):
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
+        for opt in '-t', '--test':
+            out = self.zipfilecmd(opt, zip_name)
+            self.assertEqual(out.rstrip(), b'Done testing')
+        zip_name = findfile('testtar.tar')
+        rc, out, err = self.zipfilecmd_failure('-t', zip_name)
+        self.assertEqual(out, b'')
+
+    def test_list_command(self):
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
+        t = io.StringIO()
+        with zipfile.ZipFile(zip_name, 'r') as tf:
+            tf.printdir(t)
+        expected = t.getvalue().encode('ascii', 'backslashreplace')
+        for opt in '-l', '--list':
+            out = self.zipfilecmd(opt, zip_name,
+                                  PYTHONIOENCODING='ascii:backslashreplace')
+            self.assertEqual(out, expected)
+
+    @requires_zlib()
+    def test_create_command(self):
+        self.addCleanup(unlink, TESTFN)
+        with open(TESTFN, 'w', encoding='utf-8') as f:
+            f.write('test 1')
+        os.mkdir(TESTFNDIR)
+        self.addCleanup(rmtree, TESTFNDIR)
+        with open(os.path.join(TESTFNDIR, 'file.txt'), 'w', encoding='utf-8') as f:
+            f.write('test 2')
+        files = [TESTFN, TESTFNDIR]
+        namelist = [TESTFN, TESTFNDIR + '/', TESTFNDIR + '/file.txt']
+        for opt in '-c', '--create':
+            try:
+                out = self.zipfilecmd(opt, TESTFN2, *files)
+                self.assertEqual(out, b'')
+                with zipfile.ZipFile(TESTFN2) as zf:
+                    self.assertEqual(zf.namelist(), namelist)
+                    self.assertEqual(zf.read(namelist[0]), b'test 1')
+                    self.assertEqual(zf.read(namelist[2]), b'test 2')
+            finally:
+                unlink(TESTFN2)
+
+    def test_extract_command(self):
+        zip_name = findfile('zipdir.zip', subdir='archivetestdata')
+        for opt in '-e', '--extract':
+            with temp_dir() as extdir:
+                out = self.zipfilecmd(opt, zip_name, extdir)
+                self.assertEqual(out, b'')
+                with zipfile.ZipFile(zip_name) as zf:
+                    for zi in zf.infolist():
+                        path = os.path.join(extdir,
+                                    zi.filename.replace('/', os.sep))
+                        if zi.is_dir():
+                            self.assertTrue(os.path.isdir(path))
+                        else:
+                            self.assertTrue(os.path.isfile(path))
+                            with open(path, 'rb') as f:
+                                self.assertEqual(f.read(), zf.read(zi))
+
+
+class TestExecutablePrependedZip(unittest.TestCase):
+    """Test our ability to open zip files with an executable prepended."""
+
+    def setUp(self):
+        self.exe_zip = findfile('exe_with_zip', subdir='archivetestdata')
+        self.exe_zip64 = findfile('exe_with_z64', subdir='archivetestdata')
+
+    def _test_zip_works(self, name):
+        # bpo28494 sanity check: ensure is_zipfile works on these.
+        self.assertTrue(zipfile.is_zipfile(name),
+                        f'is_zipfile failed on {name}')
+        # Ensure we can operate on these via ZipFile.
+        with zipfile.ZipFile(name) as zipfp:
+            for n in zipfp.namelist():
+                data = zipfp.read(n)
+                self.assertIn(b'FAVORITE_NUMBER', data)
+
+    def test_read_zip_with_exe_prepended(self):
+        self._test_zip_works(self.exe_zip)
+
+    def test_read_zip64_with_exe_prepended(self):
+        self._test_zip_works(self.exe_zip64)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipUnless(sys.executable, 'sys.executable required.')
+    @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
+                         'Test relies on #!/bin/bash working.')
+    @requires_subprocess()
+    def test_execute_zip2(self):
+        output = subprocess.check_output([self.exe_zip, sys.executable])
+        self.assertIn(b'number in executable: 5', output)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON
+    @unittest.skipUnless(sys.executable, 'sys.executable required.')
+    @unittest.skipUnless(os.access('/bin/bash', os.X_OK),
+                         'Test relies on #!/bin/bash working.')
+    @requires_subprocess()
+    def test_execute_zip64(self):
+        output = subprocess.check_output([self.exe_zip64, sys.executable])
+        self.assertIn(b'number in executable: 5', output)
+
+
+@unittest.skip("TODO: RUSTPYTHON shift_jis encoding unsupported")
+class EncodedMetadataTests(unittest.TestCase):
+    file_names = ['\u4e00', '\u4e8c', '\u4e09']  # Han 'one', 'two', 'three'
+    file_content = [
+        "This is pure ASCII.\n".encode('ascii'),
+        # This is modern Japanese. (UTF-8)
+        "\u3053\u308c\u306f\u73fe\u4ee3\u7684\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('utf-8'),
+        # TODO RUSTPYTHON
+        # Uncomment when Shift JIS is supported
+        # This is obsolete Japanese. (Shift JIS)
+        # "\u3053\u308c\u306f\u53e4\u3044\u65e5\u672c\u8a9e\u3067\u3059\u3002\n".encode('shift_jis'),
+    ]
+
+    def setUp(self):
+        self.addCleanup(unlink, TESTFN)
+        # Create .zip of 3 members with Han names encoded in Shift JIS.
+        # Each name is 1 Han character encoding to 2 bytes in Shift JIS.
+        # The ASCII names are arbitrary as long as they are length 2 and
+        # not otherwise contained in the zip file.
+        # Data elements are encoded bytes (ascii, utf-8, shift_jis).
+        placeholders = ["n1", "n2"] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, mode="w") as tf:
+            for temp, content in zip(placeholders, self.file_content):
+                tf.writestr(temp, content, zipfile.ZIP_STORED)
+        # Hack in the Shift JIS names with flag bit 11 (UTF-8) unset.
+        with open(TESTFN, "rb") as tf:
+            data = tf.read()
+        for name, temp in zip(self.file_names, placeholders[:2]):
+            data = data.replace(temp.encode('ascii'),
+                                name.encode('shift_jis'))
+        with open(TESTFN, "wb") as tf:
+            tf.write(data)
+
+    def _test_read(self, zipfp, expected_names, expected_content):
+        # Check the namelist
+        names = zipfp.namelist()
+        self.assertEqual(sorted(names), sorted(expected_names))
+
+        # Check infolist
+        infos = zipfp.infolist()
+        names = [zi.filename for zi in infos]
+        self.assertEqual(sorted(names), sorted(expected_names))
+
+        # check getinfo
+        for name, content in zip(expected_names, expected_content):
+            info = zipfp.getinfo(name)
+            self.assertEqual(info.filename, name)
+            self.assertEqual(info.file_size, len(content))
+            self.assertEqual(zipfp.read(name), content)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_read_with_metadata_encoding(self):
+        # Read the ZIP archive with correct metadata_encoding
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='shift_jis') as zipfp:
+            self._test_read(zipfp, self.file_names, self.file_content)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_read_without_metadata_encoding(self):
+        # Read the ZIP archive without metadata_encoding
+        expected_names = [name.encode('shift_jis').decode('cp437')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, "r") as zipfp:
+            self._test_read(zipfp, expected_names, self.file_content)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_read_with_incorrect_metadata_encoding(self):
+        # Read the ZIP archive with incorrect metadata_encoding
+        expected_names = [name.encode('shift_jis').decode('koi8-u')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='koi8-u') as zipfp:
+            self._test_read(zipfp, expected_names, self.file_content)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_read_with_unsuitable_metadata_encoding(self):
+        # Read the ZIP archive with metadata_encoding unsuitable for
+        # decoding metadata
+        with self.assertRaises(UnicodeDecodeError):
+            zipfile.ZipFile(TESTFN, "r", metadata_encoding='ascii')
+        with self.assertRaises(UnicodeDecodeError):
+            zipfile.ZipFile(TESTFN, "r", metadata_encoding='utf-8')
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_read_after_append(self):
+        newname = '\u56db'  # Han 'four'
+        expected_names = [name.encode('shift_jis').decode('cp437')
+                          for name in self.file_names[:2]] + self.file_names[2:]
+        expected_names.append(newname)
+        expected_content = (*self.file_content, b"newcontent")
+
+        with zipfile.ZipFile(TESTFN, "a") as zipfp:
+            zipfp.writestr(newname, "newcontent")
+            self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
+
+        with zipfile.ZipFile(TESTFN, "r") as zipfp:
+            self._test_read(zipfp, expected_names, expected_content)
+
+        with zipfile.ZipFile(TESTFN, "r", metadata_encoding='shift_jis') as zipfp:
+            self.assertEqual(sorted(zipfp.namelist()), sorted(expected_names))
+            for i, (name, content) in enumerate(zip(expected_names, expected_content)):
+                info = zipfp.getinfo(name)
+                self.assertEqual(info.filename, name)
+                self.assertEqual(info.file_size, len(content))
+                if i < 2:
+                    with self.assertRaises(zipfile.BadZipFile):
+                        zipfp.read(name)
+                else:
+                    self.assertEqual(zipfp.read(name), content)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_write_with_metadata_encoding(self):
+        ZF = zipfile.ZipFile
+        for mode in ("w", "x", "a"):
+            with self.assertRaisesRegex(ValueError,
+                                        "^metadata_encoding is only"):
+                ZF("nonesuch.zip", mode, metadata_encoding="shift_jis")
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_cli_with_metadata_encoding(self):
+        errmsg = "Non-conforming encodings not supported with -c."
+        args = ["--metadata-encoding=shift_jis", "-c", "nonesuch", "nonesuch"]
+        with captured_stdout() as stdout:
+            with captured_stderr() as stderr:
+                self.assertRaises(SystemExit, zipfile.main, args)
+        self.assertEqual(stdout.getvalue(), "")
+        self.assertIn(errmsg, stderr.getvalue())
+
+        with captured_stdout() as stdout:
+            zipfile.main(["--metadata-encoding=shift_jis", "-t", TESTFN])
+        listing = stdout.getvalue()
+
+        with captured_stdout() as stdout:
+            zipfile.main(["--metadata-encoding=shift_jis", "-l", TESTFN])
+        listing = stdout.getvalue()
+        for name in self.file_names:
+            self.assertIn(name, listing)
+
+    @unittest.expectedFailure # TODO: RUSTPYTHON; 
+    def test_cli_with_metadata_encoding_extract(self):
+        os.mkdir(TESTFN2)
+        self.addCleanup(rmtree, TESTFN2)
+        # Depending on locale, extracted file names can be not encodable
+        # with the filesystem encoding.
+        for fn in self.file_names:
+            try:
+                os.stat(os.path.join(TESTFN2, fn))
+            except OSError:
+                pass
+            except UnicodeEncodeError:
+                self.skipTest(f'cannot encode file name {fn!a}')
+
+        zipfile.main(["--metadata-encoding=shift_jis", "-e", TESTFN, TESTFN2])
+        listing = os.listdir(TESTFN2)
+        for name in self.file_names:
+            self.assertIn(name, listing)
+
+
+class StripExtraTests(unittest.TestCase):
+    # Note: all of the "z" characters are technically invalid, but up
+    # to 3 bytes at the end of the extra will be passed through as they
+    # are too short to encode a valid extra.
+
+    ZIP64_EXTRA = 1
+
+    def test_no_data(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 0)
+        b = s.pack(2, 0)
+        c = s.pack(3, 0)
+
+        self.assertEqual(b'', zipfile._Extra.strip(a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b+c, zipfile._Extra.strip(a+b+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+a+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+c+a, (self.ZIP64_EXTRA,)))
+
+    def test_with_data(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
+        b = s.pack(2, 2) + b"bb"
+        c = s.pack(3, 3) + b"ccc"
+
+        self.assertEqual(b"", zipfile._Extra.strip(a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b+c, zipfile._Extra.strip(a+b+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+a+c, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b+c, zipfile._Extra.strip(b+c+a, (self.ZIP64_EXTRA,)))
+
+    def test_multiples(self):
+        s = struct.Struct("<HH")
+        a = s.pack(self.ZIP64_EXTRA, 1) + b"a"
+        b = s.pack(2, 2) + b"bb"
+
+        self.assertEqual(b"", zipfile._Extra.strip(a+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b"", zipfile._Extra.strip(a+a+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"z", zipfile._Extra.strip(a+a+b"z", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b+b"z", zipfile._Extra.strip(a+a+b+b"z", (self.ZIP64_EXTRA,)))
+
+        self.assertEqual(b, zipfile._Extra.strip(a+a+b, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(a+b+a, (self.ZIP64_EXTRA,)))
+        self.assertEqual(b, zipfile._Extra.strip(b+a+a, (self.ZIP64_EXTRA,)))
+
+    def test_too_short(self):
+        self.assertEqual(b"", zipfile._Extra.strip(b"", (self.ZIP64_EXTRA,)))
+        self.assertEqual(b"z", zipfile._Extra.strip(b"z", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"zz", zipfile._Extra.strip(b"zz", (self.ZIP64_EXTRA,)))
+        self.assertEqual(
+            b"zzz", zipfile._Extra.strip(b"zzz", (self.ZIP64_EXTRA,)))
+
+
+class StatIO(_pyio.BytesIO):
+    """Buffer which remembers the number of bytes that were read."""
+
+    def __init__(self):
+        super().__init__()
+        self.bytes_read = 0
+
+    def read(self, size=-1):
+        bs = super().read(size)
+        self.bytes_read += len(bs)
+        return bs
+
+
+class StoredZipExtFileRandomReadTest(unittest.TestCase):
+    """Tests whether an uncompressed, unencrypted zip entry can be randomly
+    seek and read without reading redundant bytes."""
+    def test_stored_seek_and_read(self):
+
+        sio = StatIO()
+        # 20000 bytes
+        txt = b'0123456789' * 2000
+
+        # The seek length must be greater than ZipExtFile.MIN_READ_SIZE
+        # as `ZipExtFile._read2()` reads in blocks of this size and we
+        # need to seek out of the buffered data
+        read_buffer_size = zipfile.ZipExtFile.MIN_READ_SIZE
+        self.assertGreaterEqual(10002, read_buffer_size)  # for forward seek test
+        self.assertGreaterEqual(5003, read_buffer_size)  # for backward seek test
+        # The read length must be less than MIN_READ_SIZE, since we assume that
+        # only 1 block is read in the test.
+        read_length = 100
+        self.assertGreaterEqual(read_buffer_size, read_length)  # for read() calls
+
+        with zipfile.ZipFile(sio, "w", compression=zipfile.ZIP_STORED) as zipf:
+            zipf.writestr("foo.txt", txt)
+
+        # check random seek and read on a file
+        with zipfile.ZipFile(sio, "r") as zipf:
+            with zipf.open("foo.txt", "r") as fp:
+                # Test this optimized read hasn't rewound and read from the
+                # start of the file (as in the case of the unoptimized path)
+
+                # forward seek
+                old_count = sio.bytes_read
+                forward_seek_len = 10002
+                current_pos = 0
+                fp.seek(forward_seek_len, os.SEEK_CUR)
+                current_pos += forward_seek_len
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(fp._left, fp._compress_left)
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
+                self.assertEqual(fp._left, fp._compress_left)
+                read_count = sio.bytes_read - old_count
+                self.assertLessEqual(read_count, read_buffer_size)
+
+                # backward seek
+                old_count = sio.bytes_read
+                backward_seek_len = 5003
+                fp.seek(-backward_seek_len, os.SEEK_CUR)
+                current_pos -= backward_seek_len
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(fp._left, fp._compress_left)
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(fp.tell(), current_pos)
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
+                self.assertEqual(fp._left, fp._compress_left)
+                read_count = sio.bytes_read - old_count
+                self.assertLessEqual(read_count, read_buffer_size)
+
+                # eof flags test
+                fp.seek(0, os.SEEK_END)
+                fp.seek(12345, os.SEEK_SET)
+                current_pos = 12345
+                arr = fp.read(read_length)
+                current_pos += read_length
+                self.assertEqual(arr, txt[current_pos - read_length:current_pos])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_zipfile64.py b/Lib/test/test_zipfile64.py
index 0947013afb..2e1affe025 100644
--- a/Lib/test/test_zipfile64.py
+++ b/Lib/test/test_zipfile64.py
@@ -11,7 +11,7 @@
         'test requires loads of disk-space bytes and a long time to run'
     )
 
-import zipfile, os, unittest
+import zipfile, unittest
 import time
 import sys
 
@@ -32,10 +32,6 @@ def setUp(self):
         line_gen = ("Test of zipfile line %d." % i for i in range(1000000))
         self.data = '\n'.join(line_gen).encode('ascii')
 
-        # And write it to a file.
-        with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
-
     def zipTest(self, f, compression):
         # Create the ZIP archive.
         with zipfile.ZipFile(f, "w", compression) as zipfp:
@@ -67,6 +63,9 @@ def zipTest(self, f, compression):
                     (num, filecount)), file=sys.__stdout__)
                     sys.__stdout__.flush()
 
+            # Check that testzip thinks the archive is valid
+            self.assertIsNone(zipfp.testzip())
+
     def testStored(self):
         # Try the temp file first.  If we do TESTFN2 first, then it hogs
         # gigabytes of disk space for the duration of the test.
@@ -85,9 +84,7 @@ def testDeflated(self):
         self.zipTest(TESTFN2, zipfile.ZIP_DEFLATED)
 
     def tearDown(self):
-        for fname in TESTFN, TESTFN2:
-            if os.path.exists(fname):
-                os.remove(fname)
+        os_helper.unlink(TESTFN2)
 
 
 class OtherTests(unittest.TestCase):
diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py
index 488a67e80f..a6898e9182 100644
--- a/Lib/test/test_zipimport.py
+++ b/Lib/test/test_zipimport.py
@@ -1,8 +1,10 @@
 import sys
 import os
 import marshal
+import glob
 import importlib
 import importlib.util
+import re
 import struct
 import time
 import unittest
@@ -50,10 +52,14 @@ def module_path_to_dotted_name(path):
 
 
 TESTMOD = "ziptestmodule"
+TESTMOD2 = "ziptestmodule2"
+TESTMOD3 = "ziptestmodule3"
 TESTPACK = "ziptestpackage"
 TESTPACK2 = "ziptestpackage2"
+TESTPACK3 = "ziptestpackage3"
 TEMP_DIR = os.path.abspath("junk95142")
 TEMP_ZIP = os.path.abspath("junk95142.zip")
+TEST_DATA_DIR = os.path.join(os.path.dirname(__file__), "zipimport_data")
 
 pyc_file = importlib.util.cache_from_source(TESTMOD + '.py')
 pyc_ext = '.pyc'
@@ -92,8 +98,10 @@ def makeTree(self, files, dirName=TEMP_DIR):
         # defined by files under the directory dirName.
         self.addCleanup(os_helper.rmtree, dirName)
 
-        for name, (mtime, data) in files.items():
-            path = os.path.join(dirName, name)
+        for name, data in files.items():
+            if isinstance(data, tuple):
+                mtime, data = data
+            path = os.path.join(dirName, *name.split('/'))
             if path[-1] == os.sep:
                 if not os.path.isdir(path):
                     os.makedirs(path)
@@ -104,22 +112,18 @@ def makeTree(self, files, dirName=TEMP_DIR):
                 with open(path, 'wb') as fp:
                     fp.write(data)
 
-    def makeZip(self, files, zipName=TEMP_ZIP, **kw):
+    def makeZip(self, files, zipName=TEMP_ZIP, *,
+                comment=None, file_comment=None, stuff=None, prefix='', **kw):
         # Create a zip archive based set of modules/packages
-        # defined by files in the zip file zipName.  If the
-        # key 'stuff' exists in kw it is prepended to the archive.
+        # defined by files in the zip file zipName.
+        # If stuff is not None, it is prepended to the archive.
         self.addCleanup(os_helper.unlink, zipName)
 
-        with ZipFile(zipName, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                z.writestr(zinfo, data)
-            comment = kw.get("comment", None)
+        with ZipFile(zipName, "w", compression=self.compression) as z:
+            self.writeZip(z, files, file_comment=file_comment, prefix=prefix)
             if comment is not None:
                 z.comment = comment
 
-        stuff = kw.get("stuff", None)
         if stuff is not None:
             # Prepend 'stuff' to the start of the zipfile
             with open(zipName, "rb") as f:
@@ -128,20 +132,47 @@ def makeZip(self, files, zipName=TEMP_ZIP, **kw):
                 f.write(stuff)
                 f.write(data)
 
+    def writeZip(self, z, files, *, file_comment=None, prefix=''):
+        for name, data in files.items():
+            if isinstance(data, tuple):
+                mtime, data = data
+            else:
+                mtime = NOW
+            name = name.replace(os.sep, '/')
+            zinfo = ZipInfo(prefix + name, time.localtime(mtime))
+            zinfo.compress_type = self.compression
+            if file_comment is not None:
+                zinfo.comment = file_comment
+            if data is None:
+                zinfo.CRC = 0
+                z.mkdir(zinfo)
+            else:
+                assert name[-1] != '/'
+                z.writestr(zinfo, data)
+
+    def getZip64Files(self):
+        # This is the simplest way to make zipfile generate the zip64 EOCD block
+        return {f"f{n}.py": test_src for n in range(65537)}
+
     def doTest(self, expected_ext, files, *modules, **kw):
+        if 'prefix' not in kw:
+            kw['prefix'] = 'pre/fix/'
         self.makeZip(files, **kw)
+        self.doTestWithPreBuiltZip(expected_ext, *modules, **kw)
 
-        sys.path.insert(0, TEMP_ZIP)
+    def doTestWithPreBuiltZip(self, expected_ext, *modules,
+                              call=None, prefix='', **kw):
+        zip_path = os.path.join(TEMP_ZIP, *prefix.split('/')[:-1])
+        sys.path.insert(0, zip_path)
 
         mod = importlib.import_module(".".join(modules))
 
-        call = kw.get('call')
         if call is not None:
             call(mod)
 
         if expected_ext:
             file = mod.get_file()
-            self.assertEqual(file, os.path.join(TEMP_ZIP,
+            self.assertEqual(file, os.path.join(zip_path,
                                  *modules) + expected_ext)
 
     def testAFakeZlib(self):
@@ -155,7 +186,8 @@ def testAFakeZlib(self):
         # zlib.decompress function object, after which the problem being
         # tested here wouldn't be a problem anymore...
         # (Hence the 'A' in the test method name: to make it the first
-        # item in a list sorted by name, like unittest.makeSuite() does.)
+        # item in a list sorted by name, like
+        # unittest.TestLoader.getTestCaseNames() does.)
         #
         # This test fails on platforms on which the zlib module is
         # statically linked, but the problem it tests for can't
@@ -166,7 +198,7 @@ def testAFakeZlib(self):
             self.skipTest('zlib is a builtin module')
         if "zlib" in sys.modules:
             del sys.modules["zlib"]
-        files = {"zlib.py": (NOW, test_src)}
+        files = {"zlib.py": test_src}
         try:
             self.doTest(".py", files, "zlib")
         except ImportError:
@@ -177,16 +209,16 @@ def testAFakeZlib(self):
                 self.fail("expected test to raise ImportError")
 
     def testPy(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD)
 
     def testPyc(self):
-        files = {TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTMOD)
 
     def testBoth(self):
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTMOD)
 
     def testUncheckedHashBasedPyc(self):
@@ -219,22 +251,22 @@ def check(mod):
         self.doTest(None, files, TESTMOD, call=check)
 
     def testEmptyPy(self):
-        files = {TESTMOD + ".py": (NOW, "")}
+        files = {TESTMOD + ".py": ""}
         self.doTest(None, files, TESTMOD)
 
     def testBadMagic(self):
         # make pyc magic word invalid, forcing loading from .py
         badmagic_pyc = bytearray(test_pyc)
         badmagic_pyc[0] ^= 0x04  # flip an arbitrary bit
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: badmagic_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def testBadMagic2(self):
         # make pyc magic word invalid, causing an ImportError
         badmagic_pyc = bytearray(test_pyc)
         badmagic_pyc[0] ^= 0x04  # flip an arbitrary bit
-        files = {TESTMOD + pyc_ext: (NOW, badmagic_pyc)}
+        files = {TESTMOD + pyc_ext: badmagic_pyc}
         try:
             self.doTest(".py", files, TESTMOD)
             self.fail("This should not be reached")
@@ -247,22 +279,22 @@ def testBadMTime(self):
         # flip the second bit -- not the first as that one isn't stored in the
         # .py's mtime in the zip archive.
         badtime_pyc[11] ^= 0x02
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, badtime_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: badtime_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def test2038MTime(self):
         # Make sure we can handle mtimes larger than what a 32-bit signed number
         # can hold.
         twenty_thirty_eight_pyc = make_pyc(test_co, 2**32 - 1, len(test_src))
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, twenty_thirty_eight_pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: twenty_thirty_eight_pyc}
         self.doTest(".py", files, TESTMOD)
 
     def testPackage(self):
         packdir = TESTPACK + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTMOD)
 
     def testSubPackage(self):
@@ -270,9 +302,9 @@ def testSubPackage(self):
         # archives.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTPACK2, TESTMOD)
 
     def testSubNamespacePackage(self):
@@ -281,9 +313,9 @@ def testSubNamespacePackage(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
         # The first two files are just directory entries (so have no data).
-        files = {packdir: (NOW, ""),
-                 packdir2: (NOW, ""),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir: None,
+                 packdir2: None,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
         self.doTest(pyc_ext, files, TESTPACK, TESTPACK2, TESTMOD)
 
     def testMixedNamespacePackage(self):
@@ -291,19 +323,19 @@ def testMixedNamespacePackage(self):
         # real filesystem and a zip archive.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        packdir3 = packdir2 + TESTPACK + '3' + os.sep
-        files1 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir3: (NOW, ""),
-                  packdir3 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + '3' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
-        files2 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir2 + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        packdir3 = packdir2 + TESTPACK3 + os.sep
+        files1 = {packdir: None,
+                  packdir + TESTMOD + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir3: None,
+                  packdir3 + TESTMOD + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD3 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
+        files2 = {packdir: None,
+                  packdir + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir2 + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
 
         zip1 = os.path.abspath("path1.zip")
         self.makeZip(files1, zip1)
@@ -336,8 +368,8 @@ def testMixedNamespacePackage(self):
         mod = importlib.import_module('.'.join((TESTPACK, TESTMOD)))
         self.assertEqual("path1.zip", mod.__file__.split(os.sep)[-3])
 
-        # And TESTPACK/(TESTMOD + '2') only exists in path2.
-        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD + '2')))
+        # And TESTPACK/(TESTMOD2) only exists in path2.
+        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD2)))
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-3])
 
@@ -354,13 +386,13 @@ def testMixedNamespacePackage(self):
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-4])
 
-        # subpkg.TESTMOD + '2' only exists in zip2.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '2')))
+        # subpkg.TESTMOD2 only exists in zip2.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD2)))
         self.assertEqual(os.path.basename(TEMP_DIR),
                          mod.__file__.split(os.sep)[-4])
 
-        # Finally subpkg.TESTMOD + '3' only exists in zip1.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '3')))
+        # Finally subpkg.TESTMOD3 only exists in zip1.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD3)))
         self.assertEqual('path1.zip', mod.__file__.split(os.sep)[-4])
 
     def testNamespacePackage(self):
@@ -368,22 +400,22 @@ def testNamespacePackage(self):
         # archives.
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        packdir3 = packdir2 + TESTPACK + '3' + os.sep
-        files1 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir3: (NOW, ""),
-                  packdir3 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + '3' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        packdir3 = packdir2 + TESTPACK3 + os.sep
+        files1 = {packdir: None,
+                  packdir + TESTMOD + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir3: None,
+                  packdir3 + TESTMOD + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD3 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
         zip1 = os.path.abspath("path1.zip")
         self.makeZip(files1, zip1)
 
-        files2 = {packdir: (NOW, ""),
-                  packdir + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2: (NOW, ""),
-                  packdir2 + TESTMOD + '2' + pyc_ext: (NOW, test_pyc),
-                  packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files2 = {packdir: None,
+                  packdir + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2: None,
+                  packdir2 + TESTMOD2 + pyc_ext: test_pyc,
+                  packdir2 + TESTMOD + pyc_ext: test_pyc}
         zip2 = os.path.abspath("path2.zip")
         self.makeZip(files2, zip2)
 
@@ -412,8 +444,8 @@ def testNamespacePackage(self):
         mod = importlib.import_module('.'.join((TESTPACK, TESTMOD)))
         self.assertEqual("path1.zip", mod.__file__.split(os.sep)[-3])
 
-        # And TESTPACK/(TESTMOD + '2') only exists in path2.
-        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD + '2')))
+        # And TESTPACK/(TESTMOD2) only exists in path2.
+        mod = importlib.import_module('.'.join((TESTPACK, TESTMOD2)))
         self.assertEqual("path2.zip", mod.__file__.split(os.sep)[-3])
 
         # One level deeper...
@@ -428,29 +460,22 @@ def testNamespacePackage(self):
         mod = importlib.import_module('.'.join((subpkg, TESTMOD)))
         self.assertEqual('path2.zip', mod.__file__.split(os.sep)[-4])
 
-        # subpkg.TESTMOD + '2' only exists in zip2.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '2')))
+        # subpkg.TESTMOD2 only exists in zip2.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD2)))
         self.assertEqual('path2.zip', mod.__file__.split(os.sep)[-4])
 
-        # Finally subpkg.TESTMOD + '3' only exists in zip1.
-        mod = importlib.import_module('.'.join((subpkg, TESTMOD + '3')))
+        # Finally subpkg.TESTMOD3 only exists in zip1.
+        mod = importlib.import_module('.'.join((subpkg, TESTMOD3)))
         self.assertEqual('path1.zip', mod.__file__.split(os.sep)[-4])
 
     def testZipImporterMethods(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                 "spam" + pyc_ext: (NOW, test_pyc)}
-
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
         zi = zipimport.zipimporter(TEMP_ZIP)
         self.assertEqual(zi.archive, TEMP_ZIP)
@@ -459,12 +484,6 @@ def testZipImporterMethods(self):
         # PEP 302
         with warnings.catch_warnings():
             warnings.simplefilter("ignore", DeprecationWarning)
-            find_mod = zi.find_module('spam')
-            self.assertIsNotNone(find_mod)
-            self.assertIsInstance(find_mod, zipimport.zipimporter)
-            self.assertFalse(find_mod.is_package('spam'))
-            load_mod = find_mod.load_module('spam')
-            self.assertEqual(find_mod.get_filename('spam'), load_mod.__file__)
 
             mod = zi.load_module(TESTPACK)
             self.assertEqual(zi.get_filename(TESTPACK), mod.__file__)
@@ -512,58 +531,68 @@ def testZipImporterMethods(self):
     def testInvalidateCaches(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc),
-                 "spam" + pyc_ext: (NOW, test_pyc)}
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
         zi = zipimport.zipimporter(TEMP_ZIP)
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         # Check that the file information remains accurate after reloading
         zi.invalidate_caches()
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         # Add a new file to the ZIP archive
-        newfile = {"spam2" + pyc_ext: (NOW, test_pyc)}
+        newfile = {"spam2" + pyc_ext: test_pyc}
         files.update(newfile)
-        with ZipFile(TEMP_ZIP, "a") as z:
-            for name, (mtime, data) in newfile.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"spam"
-                z.writestr(zinfo, data)
+        with ZipFile(TEMP_ZIP, "a", compression=self.compression) as z:
+            self.writeZip(z, newfile, file_comment=b"spam")
         # Check that we can detect the new file after invalidating the cache
         zi.invalidate_caches()
-        self.assertEqual(zi._files.keys(), files.keys())
+        self.assertEqual(zi._get_files().keys(), files.keys())
         spec = zi.find_spec('spam2')
         self.assertIsNotNone(spec)
         self.assertIsInstance(spec.loader, zipimport.zipimporter)
         # Check that the cached data is removed if the file is deleted
         os.remove(TEMP_ZIP)
         zi.invalidate_caches()
-        self.assertFalse(zi._files)
+        self.assertFalse(zi._get_files())
         self.assertIsNone(zipimport._zip_directory_cache.get(zi.archive))
         self.assertIsNone(zi.find_spec("name_does_not_matter"))
 
-    def testZipImporterMethodsInSubDirectory(self):
+    def testInvalidateCachesWithMultipleZipimports(self):
         packdir = TESTPACK + os.sep
         packdir2 = packdir + TESTPACK2 + os.sep
-        files = {packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
-                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}
+        files = {packdir + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc,
+                 "spam" + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"spam")
 
-        self.addCleanup(os_helper.unlink, TEMP_ZIP)
-        with ZipFile(TEMP_ZIP, "w") as z:
-            for name, (mtime, data) in files.items():
-                zinfo = ZipInfo(name, time.localtime(mtime))
-                zinfo.compress_type = self.compression
-                zinfo.comment = b"eggs"
-                z.writestr(zinfo, data)
+        zi = zipimport.zipimporter(TEMP_ZIP)
+        self.assertEqual(zi._get_files().keys(), files.keys())
+        # Zipimporter for the same path.
+        zi2 = zipimport.zipimporter(TEMP_ZIP)
+        self.assertEqual(zi2._get_files().keys(), files.keys())
+        # Add a new file to the ZIP archive to make the cache wrong.
+        newfile = {"spam2" + pyc_ext: test_pyc}
+        files.update(newfile)
+        with ZipFile(TEMP_ZIP, "a", compression=self.compression) as z:
+            self.writeZip(z, newfile, file_comment=b"spam")
+        # Invalidate the cache of the first zipimporter.
+        zi.invalidate_caches()
+        # Check that the second zipimporter detects the new file and isn't using a stale cache.
+        self.assertEqual(zi2._get_files().keys(), files.keys())
+        spec = zi2.find_spec('spam2')
+        self.assertIsNotNone(spec)
+        self.assertIsInstance(spec.loader, zipimport.zipimporter)
+
+    def testZipImporterMethodsInSubDirectory(self):
+        packdir = TESTPACK + os.sep
+        packdir2 = packdir + TESTPACK2 + os.sep
+        files = {packdir2 + "__init__" + pyc_ext: test_pyc,
+                 packdir2 + TESTMOD + pyc_ext: test_pyc}
+        self.makeZip(files, file_comment=b"eggs")
 
         zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir)
         self.assertEqual(zi.archive, TEMP_ZIP)
@@ -585,16 +614,6 @@ def testZipImporterMethodsInSubDirectory(self):
 
         pkg_path = TEMP_ZIP + os.sep + packdir + TESTPACK2
         zi2 = zipimport.zipimporter(pkg_path)
-        # PEP 302
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            find_mod_dotted = zi2.find_module(TESTMOD)
-            self.assertIsNotNone(find_mod_dotted)
-            self.assertIsInstance(find_mod_dotted, zipimport.zipimporter)
-            self.assertFalse(zi2.is_package(TESTMOD))
-            load_mod = find_mod_dotted.load_module(TESTMOD)
-            self.assertEqual(
-                find_mod_dotted.get_filename(TESTMOD), load_mod.__file__)
 
         # PEP 451
         spec = zi2.find_spec(TESTMOD)
@@ -638,9 +657,9 @@ def get_file():
         if __loader__.get_data("some.data") != b"some data":
             raise AssertionError("bad data")\n"""
         pyc = make_pyc(compile(src, "<???>", "exec"), NOW, len(src))
-        files = {TESTMOD + pyc_ext: (NOW, pyc),
-                 "some.data": (NOW, "some data")}
-        self.doTest(pyc_ext, files, TESTMOD)
+        files = {TESTMOD + pyc_ext: pyc,
+                 "some.data": "some data"}
+        self.doTest(pyc_ext, files, TESTMOD, prefix='')
 
     def testDefaultOptimizationLevel(self):
         # zipimport should use the default optimization level (#28131)
@@ -648,17 +667,20 @@ def testDefaultOptimizationLevel(self):
         def test(val):
             assert(val)
             return val\n"""
-        files = {TESTMOD + '.py': (NOW, src)}
+        files = {TESTMOD + '.py': src}
         self.makeZip(files)
         sys.path.insert(0, TEMP_ZIP)
         mod = importlib.import_module(TESTMOD)
         self.assertEqual(mod.test(1), 1)
-        self.assertRaises(AssertionError, mod.test, False)
+        if __debug__:
+            self.assertRaises(AssertionError, mod.test, False)
+        else:
+            self.assertEqual(mod.test(0), 0)
 
     def testImport_WithStuff(self):
         # try importing from a zipfile which contains additional
         # stuff at the beginning of the file
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD,
                     stuff=b"Some Stuff"*31)
 
@@ -666,18 +688,18 @@ def assertModuleSource(self, module):
         self.assertEqual(inspect.getsource(module), test_src)
 
     def testGetSource(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, call=self.assertModuleSource)
 
     def testGetCompiledSource(self):
         pyc = make_pyc(compile(test_src, "<???>", "exec"), NOW, len(test_src))
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 TESTMOD + pyc_ext: (NOW, pyc)}
+        files = {TESTMOD + ".py": test_src,
+                 TESTMOD + pyc_ext: pyc}
         self.doTest(pyc_ext, files, TESTMOD, call=self.assertModuleSource)
 
     def runDoctest(self, callback):
-        files = {TESTMOD + ".py": (NOW, test_src),
-                 "xyz.txt": (NOW, ">>> log.append(True)\n")}
+        files = {TESTMOD + ".py": test_src,
+                 "xyz.txt": ">>> log.append(True)\n"}
         self.doTest(".py", files, TESTMOD, call=callback)
 
     def doDoctestFile(self, module):
@@ -720,55 +742,177 @@ def doTraceback(self, module):
 
             s = io.StringIO()
             print_tb(tb, 1, s)
-            self.assertTrue(s.getvalue().endswith(raise_src))
+            self.assertTrue(s.getvalue().endswith(
+                '    def do_raise(): raise TypeError\n'
+                '' if support.has_no_debug_ranges() else
+                '                    ^^^^^^^^^^^^^^^\n'
+            ))
         else:
             raise AssertionError("This ought to be impossible")
 
+    @unittest.expectedFailure # TODO: RUSTPYTHON; empty caret lines from equal col/end_col
     def testTraceback(self):
-        files = {TESTMOD + ".py": (NOW, raise_src)}
+        files = {TESTMOD + ".py": raise_src}
         self.doTest(None, files, TESTMOD, call=self.doTraceback)
 
     @unittest.skipIf(os_helper.TESTFN_UNENCODABLE is None,
                      "need an unencodable filename")
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON")
     def testUnencodable(self):
         filename = os_helper.TESTFN_UNENCODABLE + ".zip"
-        self.addCleanup(os_helper.unlink, filename)
-        with ZipFile(filename, "w") as z:
-            zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
-            zinfo.compress_type = self.compression
-            z.writestr(zinfo, test_src)
+        self.makeZip({TESTMOD + ".py": test_src}, filename)
         spec = zipimport.zipimporter(filename).find_spec(TESTMOD)
         mod = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(mod)
 
     def testBytesPath(self):
         filename = os_helper.TESTFN + ".zip"
-        self.addCleanup(os_helper.unlink, filename)
-        with ZipFile(filename, "w") as z:
-            zinfo = ZipInfo(TESTMOD + ".py", time.localtime(NOW))
-            zinfo.compress_type = self.compression
-            z.writestr(zinfo, test_src)
+        self.makeZip({TESTMOD + ".py": test_src}, filename)
 
         zipimport.zipimporter(filename)
-        zipimport.zipimporter(os.fsencode(filename))
+        with self.assertRaises(TypeError):
+            zipimport.zipimporter(os.fsencode(filename))
         with self.assertRaises(TypeError):
             zipimport.zipimporter(bytearray(os.fsencode(filename)))
         with self.assertRaises(TypeError):
             zipimport.zipimporter(memoryview(os.fsencode(filename)))
 
     def testComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, comment=b"comment")
 
     def testBeginningCruftAndComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, stuff=b"cruft" * 64, comment=b"hi")
 
     def testLargestPossibleComment(self):
-        files = {TESTMOD + ".py": (NOW, test_src)}
+        files = {TESTMOD + ".py": test_src}
         self.doTest(".py", files, TESTMOD, comment=b"c" * ((1 << 16) - 1))
 
+    def testZip64(self):
+        files = self.getZip64Files()
+        self.doTest(".py", files, "f6")
+
+    def testZip64CruftAndComment(self):
+        files = self.getZip64Files()
+        self.doTest(".py", files, "f65536", comment=b"c" * ((1 << 16) - 1))
+
+    @unittest.skip('TODO: RUSTPYTHON; (intermittent success/failures); ValueError: name="RustPython/crates/pylib/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part" does not fit expected pattern.')
+    def testZip64LargeFile(self):
+        support.requires(
+            "largefile",
+            f"test generates files >{0xFFFFFFFF} bytes and takes a long time "
+            "to run"
+        )
+
+        # N.B.: We do a lot of gymnastics below in the ZIP_STORED case to save
+        # and reconstruct a sparse zip on systems that support sparse files.
+        # Instead of creating a ~8GB zip file mainly consisting of null bytes
+        # for every run of the test, we create the zip once and save off the
+        # non-null portions of the resulting file as data blobs with offsets
+        # that allow re-creating the zip file sparsely. This drops disk space
+        # usage to ~9KB for the ZIP_STORED case and drops that test time by ~2
+        # orders of magnitude. For the ZIP_DEFLATED case, however, we bite the
+        # bullet. The resulting zip file is ~8MB of non-null data; so the sparse
+        # trick doesn't work and would result in that full ~8MB zip data file
+        # being checked in to source control.
+        parts_glob = f"sparse-zip64-c{self.compression:d}-0x*.part"
+        full_parts_glob = os.path.join(TEST_DATA_DIR, parts_glob)
+        pre_built_zip_parts = glob.glob(full_parts_glob)
+
+        self.addCleanup(os_helper.unlink, TEMP_ZIP)
+        if not pre_built_zip_parts:
+            if self.compression != ZIP_STORED:
+                support.requires(
+                    "cpu",
+                    "test requires a lot of CPU for compression."
+                )
+            self.addCleanup(os_helper.unlink, os_helper.TESTFN)
+            with open(os_helper.TESTFN, "wb") as f:
+                f.write(b"data")
+                f.write(os.linesep.encode())
+                f.seek(0xffff_ffff, os.SEEK_CUR)
+                f.write(os.linesep.encode())
+            os.utime(os_helper.TESTFN, (0.0, 0.0))
+            with ZipFile(
+                TEMP_ZIP,
+                "w",
+                compression=self.compression,
+                strict_timestamps=False
+            ) as z:
+                z.write(os_helper.TESTFN, "data1")
+                z.writestr(
+                    ZipInfo("module.py", (1980, 1, 1, 0, 0, 0)), test_src
+                )
+                z.write(os_helper.TESTFN, "data2")
+
+            # This "works" but relies on the zip format having a non-empty
+            # final page due to the trailing central directory to wind up with
+            # the correct length file.
+            def make_sparse_zip_parts(name):
+                empty_page = b"\0" * 4096
+                with open(name, "rb") as f:
+                    part = None
+                    try:
+                        while True:
+                            offset = f.tell()
+                            data = f.read(len(empty_page))
+                            if not data:
+                                break
+                            if data != empty_page:
+                                if not part:
+                                    part_fullname = os.path.join(
+                                        TEST_DATA_DIR,
+                                        f"sparse-zip64-c{self.compression:d}-"
+                                        f"{offset:#011x}.part",
+                                    )
+                                    os.makedirs(
+                                        os.path.dirname(part_fullname),
+                                        exist_ok=True
+                                    )
+                                    part = open(part_fullname, "wb")
+                                    print("Created", part_fullname)
+                                part.write(data)
+                            else:
+                                if part:
+                                    part.close()
+                                part = None
+                    finally:
+                        if part:
+                            part.close()
+
+            if self.compression == ZIP_STORED:
+                print(f"Creating sparse parts to check in into {TEST_DATA_DIR}:")
+                make_sparse_zip_parts(TEMP_ZIP)
+
+        else:
+            def extract_offset(name):
+                if m := re.search(r"-(0x[0-9a-f]{9})\.part$", name):
+                    return int(m.group(1), base=16)
+                raise ValueError(f"{name=} does not fit expected pattern.")
+            offset_parts = [(extract_offset(n), n) for n in pre_built_zip_parts]
+            with open(TEMP_ZIP, "wb") as f:
+                for offset, part_fn in sorted(offset_parts):
+                    with open(part_fn, "rb") as part:
+                        f.seek(offset, os.SEEK_SET)
+                        f.write(part.read())
+            # Confirm that the reconstructed zip file works and looks right.
+            with ZipFile(TEMP_ZIP, "r") as z:
+                self.assertEqual(
+                    z.getinfo("module.py").date_time, (1980, 1, 1, 0, 0, 0)
+                )
+                self.assertEqual(
+                    z.read("module.py"), test_src.encode(),
+                    msg=f"Recreate {full_parts_glob}, unexpected contents."
+                )
+                def assertDataEntry(name):
+                    zinfo = z.getinfo(name)
+                    self.assertEqual(zinfo.date_time, (1980, 1, 1, 0, 0, 0))
+                    self.assertGreater(zinfo.file_size, 0xffff_ffff)
+                assertDataEntry("data1")
+                assertDataEntry("data2")
+
+        self.doTestWithPreBuiltZip(".py", "module")
+
 
 @support.requires_zlib()
 class CompressedZipImportTestCase(UncompressedZipImportTestCase):
@@ -800,6 +944,7 @@ def testEmptyFile(self):
         os_helper.create_empty_file(TESTMOD)
         self.assertZipFailure(TESTMOD)
 
+    @unittest.skipIf(support.is_wasi, "mode 000 not supported.")
     def testFileUnreadable(self):
         os_helper.unlink(TESTMOD)
         fd = os.open(TESTMOD, os.O_CREAT, 000)
@@ -843,7 +988,6 @@ def _testBogusZipFile(self):
             self.assertRaises(TypeError, z.get_source, None)
 
             error = zipimport.ZipImportError
-            self.assertIsNone(z.find_module('abc'))
             self.assertIsNone(z.find_spec('abc'))
 
             with warnings.catch_warnings():
diff --git a/Lib/test/test_zlib.py b/Lib/test/test_zlib.py
index 0a75457ad8..c9f7b18340 100644
--- a/Lib/test/test_zlib.py
+++ b/Lib/test/test_zlib.py
@@ -747,15 +747,11 @@ def test_baddecompresscopy(self):
         self.assertRaises(ValueError, copy.copy, d)
         self.assertRaises(ValueError, copy.deepcopy, d)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_compresspickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises((TypeError, pickle.PicklingError)):
                 pickle.dumps(zlib.compressobj(zlib.Z_BEST_COMPRESSION), proto)
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def test_decompresspickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises((TypeError, pickle.PicklingError)):
@@ -1006,8 +1002,6 @@ def testDecompress4G(self, size):
             compressed = None
             decompressed = None
 
-    # TODO: RUSTPYTHON
-    @unittest.expectedFailure
     def testPickle(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             with self.assertRaises(TypeError):
diff --git a/Lib/test/translationdata/argparse/msgids.txt b/Lib/test/translationdata/argparse/msgids.txt
new file mode 100644
index 0000000000..97416aad52
--- /dev/null
+++ b/Lib/test/translationdata/argparse/msgids.txt
@@ -0,0 +1,40 @@
+ (default: %(default)s)
+%(heading)s:
+%(prog)s: error: %(message)s\n
+%(prog)s: warning: %(message)s\n
+%r is not callable
+'required' is an invalid argument for positionals
+.__call__() not defined
+ambiguous option: %(option)s could match %(matches)s
+argument "-" with mode %r
+argument %(argument_name)s: %(message)s
+argument '%(argument_name)s' is deprecated
+can't open '%(filename)s': %(error)s
+cannot have multiple subparser arguments
+cannot merge actions - two groups are named %r
+command '%(parser_name)s' is deprecated
+conflicting subparser alias: %s
+conflicting subparser: %s
+dest= is required for options like %r
+expected at least one argument
+expected at most one argument
+expected one argument
+ignored explicit argument %r
+invalid %(type)s value: %(value)r
+invalid choice: %(value)r (choose from %(choices)s)
+invalid conflict_resolution value: %r
+invalid option string %(option)r: must start with a character %(prefix_chars)r
+mutually exclusive arguments must be optional
+not allowed with argument %s
+one of the arguments %s is required
+option '%(option)s' is deprecated
+options
+positional arguments
+show program's version number and exit
+show this help message and exit
+subcommands
+the following arguments are required: %s
+unexpected option string: %s
+unknown parser %(parser_name)r (choices: %(choices)s)
+unrecognized arguments: %s
+usage: 
\ No newline at end of file
diff --git a/Lib/test/translationdata/getopt/msgids.txt b/Lib/test/translationdata/getopt/msgids.txt
new file mode 100644
index 0000000000..1ffab1f31a
--- /dev/null
+++ b/Lib/test/translationdata/getopt/msgids.txt
@@ -0,0 +1,6 @@
+option -%s not recognized
+option -%s requires argument
+option --%s must not have an argument
+option --%s not a unique prefix
+option --%s not recognized
+option --%s requires argument
\ No newline at end of file
diff --git a/Lib/test/translationdata/optparse/msgids.txt b/Lib/test/translationdata/optparse/msgids.txt
new file mode 100644
index 0000000000..ac5317c736
--- /dev/null
+++ b/Lib/test/translationdata/optparse/msgids.txt
@@ -0,0 +1,14 @@
+%prog [options]
+%s option does not take a value
+Options
+Usage
+Usage: %s\n
+ambiguous option: %s (%s?)
+complex
+floating-point
+integer
+no such option: %s
+option %s: invalid %s value: %r
+option %s: invalid choice: %r (choose from %s)
+show program's version number and exit
+show this help message and exit
\ No newline at end of file
diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part
new file mode 100644
index 0000000000..c6beae8e25
Binary files /dev/null and b/Lib/test/zipimport_data/sparse-zip64-c0-0x000000000.part differ
diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part
new file mode 100644
index 0000000000..74ab03b464
Binary files /dev/null and b/Lib/test/zipimport_data/sparse-zip64-c0-0x100000000.part differ
diff --git a/Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part b/Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part
new file mode 100644
index 0000000000..9769a404f6
Binary files /dev/null and b/Lib/test/zipimport_data/sparse-zip64-c0-0x200000000.part differ
diff --git a/Lib/textwrap.py b/Lib/textwrap.py
index 841de9baec..7ca393d1c3 100644
--- a/Lib/textwrap.py
+++ b/Lib/textwrap.py
@@ -63,10 +63,7 @@ class TextWrapper:
         Append to the last line of truncated text.
     """
 
-    unicode_whitespace_trans = {}
-    uspace = ord(' ')
-    for x in _whitespace:
-        unicode_whitespace_trans[ord(x)] = uspace
+    unicode_whitespace_trans = dict.fromkeys(map(ord, _whitespace), ord(' '))
 
     # This funky little regex is just the trick for splitting
     # text up into word-wrappable chunks.  E.g.
@@ -479,13 +476,19 @@ def indent(text, prefix, predicate=None):
     consist solely of whitespace characters.
     """
     if predicate is None:
-        def predicate(line):
-            return line.strip()
-
-    def prefixed_lines():
-        for line in text.splitlines(True):
-            yield (prefix + line if predicate(line) else line)
-    return ''.join(prefixed_lines())
+        # 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)
+
+    return ''.join(prefixed_lines)
 
 
 if __name__ == "__main__":
diff --git a/Lib/threading.py b/Lib/threading.py
index 668126523d..15bf786a6a 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -3,11 +3,11 @@
 import os as _os
 import sys as _sys
 import _thread
-import functools
+import warnings
 
 from time import monotonic as _time
 from _weakrefset import WeakSet
-from itertools import islice as _islice, count as _count
+from itertools import count as _count
 try:
     from _collections import deque as _deque
 except ImportError:
@@ -28,13 +28,20 @@
            'Event', 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
            'Barrier', 'BrokenBarrierError', 'Timer', 'ThreadError',
            'setprofile', 'settrace', 'local', 'stack_size',
-           'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile']
+           'excepthook', 'ExceptHookArgs', 'gettrace', 'getprofile',
+           'setprofile_all_threads','settrace_all_threads']
 
 # Rename some stuff so "from threading import *" is safe
-_start_new_thread = _thread.start_new_thread
+_start_joinable_thread = _thread.start_joinable_thread
+_daemon_threads_allowed = _thread.daemon_threads_allowed
 _allocate_lock = _thread.allocate_lock
-_set_sentinel = _thread._set_sentinel
+_LockType = _thread.LockType
+_thread_shutdown = _thread._shutdown
+_make_thread_handle = _thread._make_thread_handle
+_ThreadHandle = _thread._ThreadHandle
 get_ident = _thread.get_ident
+_get_main_thread_ident = _thread._get_main_thread_ident
+_is_main_interpreter = _thread._is_main_interpreter
 try:
     get_native_id = _thread.get_native_id
     _HAVE_THREAD_NATIVE_ID = True
@@ -49,6 +56,13 @@
 TIMEOUT_MAX = _thread.TIMEOUT_MAX
 del _thread
 
+# get thread-local implementation, either from the thread
+# module, or from the python fallback
+
+try:
+    from _thread import _local as local
+except ImportError:
+    from _threading_local import local
 
 # Support for profile and trace hooks
 
@@ -60,11 +74,20 @@ def setprofile(func):
 
     The func will be passed to sys.setprofile() for each thread, before its
     run() method is called.
-
     """
     global _profile_hook
     _profile_hook = func
 
+def setprofile_all_threads(func):
+    """Set a profile function for all threads started from the threading module
+    and all Python threads that are currently executing.
+
+    The func will be passed to sys.setprofile() for each thread, before its
+    run() method is called.
+    """
+    setprofile(func)
+    _sys._setprofileallthreads(func)
+
 def getprofile():
     """Get the profiler function as set by threading.setprofile()."""
     return _profile_hook
@@ -74,18 +97,27 @@ def settrace(func):
 
     The func will be passed to sys.settrace() for each thread, before its run()
     method is called.
-
     """
     global _trace_hook
     _trace_hook = func
 
+def settrace_all_threads(func):
+    """Set a trace function for all threads started from the threading module
+    and all Python threads that are currently executing.
+
+    The func will be passed to sys.settrace() for each thread, before its run()
+    method is called.
+    """
+    settrace(func)
+    _sys._settraceallthreads(func)
+
 def gettrace():
     """Get the trace function as set by threading.settrace()."""
     return _trace_hook
 
 # Synchronization classes
 
-Lock = _allocate_lock
+Lock = _LockType
 
 def RLock(*args, **kwargs):
     """Factory function that returns a new reentrant lock.
@@ -96,6 +128,12 @@ def RLock(*args, **kwargs):
     acquired it.
 
     """
+    if args or kwargs:
+        warnings.warn(
+            'Passing arguments to RLock is deprecated and will be removed in 3.15',
+            DeprecationWarning,
+            stacklevel=2,
+        )
     if _CRLock is None:
         return _PyRLock(*args, **kwargs)
     return _CRLock(*args, **kwargs)
@@ -218,6 +256,13 @@ def _release_save(self):
     def _is_owned(self):
         return self._owner == get_ident()
 
+    # Internal method used for reentrancy checks
+
+    def _recursion_count(self):
+        if self._owner != get_ident():
+            return 0
+        return self._count
+
 _PyRLock = _RLock
 
 
@@ -243,18 +288,12 @@ def __init__(self, lock=None):
         # If the lock defines _release_save() and/or _acquire_restore(),
         # these override the default implementations (which just call
         # release() and acquire() on the lock).  Ditto for _is_owned().
-        try:
+        if hasattr(lock, '_release_save'):
             self._release_save = lock._release_save
-        except AttributeError:
-            pass
-        try:
+        if hasattr(lock, '_acquire_restore'):
             self._acquire_restore = lock._acquire_restore
-        except AttributeError:
-            pass
-        try:
+        if hasattr(lock, '_is_owned'):
             self._is_owned = lock._is_owned
-        except AttributeError:
-            pass
         self._waiters = _deque()
 
     def _at_fork_reinit(self):
@@ -297,7 +336,7 @@ def wait(self, timeout=None):
         awakened or timed out, it re-acquires the lock and returns.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof).
 
         When the underlying lock is an RLock, it is not released using its
@@ -425,6 +464,11 @@ def __init__(self, value=1):
         self._cond = Condition(Lock())
         self._value = value
 
+    def __repr__(self):
+        cls = self.__class__
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" value={self._value}>")
+
     def acquire(self, blocking=True, timeout=None):
         """Acquire a semaphore, decrementing the internal counter by one.
 
@@ -483,8 +527,7 @@ def release(self, n=1):
             raise ValueError('n must be one or more')
         with self._cond:
             self._value += n
-            for i in range(n):
-                self._cond.notify()
+            self._cond.notify(n)
 
     def __exit__(self, t, v, tb):
         self.release()
@@ -508,9 +551,14 @@ class BoundedSemaphore(Semaphore):
     """
 
     def __init__(self, value=1):
-        Semaphore.__init__(self, value)
+        super().__init__(value)
         self._initial_value = value
 
+    def __repr__(self):
+        cls = self.__class__
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" value={self._value}/{self._initial_value}>")
+
     def release(self, n=1):
         """Release a semaphore, incrementing the internal counter by one or more.
 
@@ -527,8 +575,7 @@ def release(self, n=1):
             if self._value + n > self._initial_value:
                 raise ValueError("Semaphore released too many times")
             self._value += n
-            for i in range(n):
-                self._cond.notify()
+            self._cond.notify(n)
 
 
 class Event:
@@ -546,8 +593,13 @@ def __init__(self):
         self._cond = Condition(Lock())
         self._flag = False
 
+    def __repr__(self):
+        cls = self.__class__
+        status = 'set' if self._flag else 'unset'
+        return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: {status}>"
+
     def _at_fork_reinit(self):
-        # Private method called by Thread._reset_internal_locks()
+        # Private method called by Thread._after_fork()
         self._cond._at_fork_reinit()
 
     def is_set(self):
@@ -557,7 +609,7 @@ def is_set(self):
     def isSet(self):
         """Return true if and only if the internal flag is true.
 
-        This method is deprecated, use notify_all() instead.
+        This method is deprecated, use is_set() instead.
 
         """
         import warnings
@@ -594,11 +646,12 @@ def wait(self, timeout=None):
         the optional timeout occurs.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof).
 
         This method returns the internal flag on exit, so it will always return
-        True except if a timeout is given and the operation times out.
+        ``True`` except if a timeout is given and the operation times out, when
+        it will return ``False``.
 
         """
         with self._cond:
@@ -637,6 +690,8 @@ def __init__(self, parties, action=None, timeout=None):
         default for all subsequent 'wait()' calls.
 
         """
+        if parties < 1:
+            raise ValueError("parties must be >= 1")
         self._cond = Condition(Lock())
         self._action = action
         self._timeout = timeout
@@ -644,6 +699,13 @@ def __init__(self, parties, action=None, timeout=None):
         self._state = 0  # 0 filling, 1 draining, -1 resetting, -2 broken
         self._count = 0
 
+    def __repr__(self):
+        cls = self.__class__
+        if self.broken:
+            return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: broken>"
+        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+                f" waiters={self.n_waiting}/{self.parties}>")
+
     def wait(self, timeout=None):
         """Wait for the barrier.
 
@@ -791,25 +853,6 @@ def _newname(name_template):
 _limbo = {}
 _dangling = WeakSet()
 
-# Set of Thread._tstate_lock locks of non-daemon threads used by _shutdown()
-# to wait until all Python thread states get deleted:
-# see Thread._set_tstate_lock().
-_shutdown_locks_lock = _allocate_lock()
-_shutdown_locks = set()
-
-def _maintain_shutdown_locks():
-    """
-    Drop any shutdown locks that don't correspond to running threads anymore.
-
-    Calling this from time to time avoids an ever-growing _shutdown_locks
-    set when Thread objects are not joined explicitly. See bpo-37788.
-
-    This must be called with _shutdown_locks_lock acquired.
-    """
-    # If a lock was released, the corresponding thread has exited
-    to_remove = [lock for lock in _shutdown_locks if not lock.locked()]
-    _shutdown_locks.difference_update(to_remove)
-
 
 # Main class for threads
 
@@ -837,7 +880,7 @@ class is implemented.
         *name* is the thread name. By default, a unique name is constructed of
         the form "Thread-N" where N is a small decimal number.
 
-        *args* is the argument tuple for the target invocation. Defaults to ().
+        *args* is a list or tuple of arguments for the target invocation. Defaults to ().
 
         *kwargs* is a dictionary of keyword arguments for the target
         invocation. Defaults to {}.
@@ -866,15 +909,16 @@ class is implemented.
         self._args = args
         self._kwargs = kwargs
         if daemon is not None:
+            if daemon and not _daemon_threads_allowed():
+                raise RuntimeError('daemon threads are disabled in this (sub)interpreter')
             self._daemonic = daemon
         else:
             self._daemonic = current_thread().daemon
         self._ident = None
         if _HAVE_THREAD_NATIVE_ID:
             self._native_id = None
-        self._tstate_lock = None
+        self._handle = _ThreadHandle()
         self._started = Event()
-        self._is_stopped = False
         self._initialized = True
         # Copy of sys.stderr used by self._invoke_excepthook()
         self._stderr = _sys.stderr
@@ -882,30 +926,26 @@ class is implemented.
         # For debugging and _after_fork()
         _dangling.add(self)
 
-    def _reset_internal_locks(self, is_alive):
-        # private!  Called by _after_fork() to reset our internal locks as
-        # they may be in an invalid state leading to a deadlock or crash.
+    def _after_fork(self, new_ident=None):
+        # Private!  Called by threading._after_fork().
         self._started._at_fork_reinit()
-        if is_alive:
-            # bpo-42350: If the fork happens when the thread is already stopped
-            # (ex: after threading._shutdown() has been called), _tstate_lock
-            # is None. Do nothing in this case.
-            if self._tstate_lock is not None:
-                self._tstate_lock._at_fork_reinit()
-                self._tstate_lock.acquire()
+        if new_ident is not None:
+            # This thread is alive.
+            self._ident = new_ident
+            assert self._handle.ident == new_ident
+            if _HAVE_THREAD_NATIVE_ID:
+                self._set_native_id()
         else:
-            # The thread isn't alive after fork: it doesn't have a tstate
-            # anymore.
-            self._is_stopped = True
-            self._tstate_lock = None
+            # Otherwise, the thread is dead, Jim.  _PyThread_AfterFork()
+            # already marked our handle done.
+            pass
 
     def __repr__(self):
         assert self._initialized, "Thread.__init__() was not called"
         status = "initial"
         if self._started.is_set():
             status = "started"
-        self.is_alive() # easy way to get ._is_stopped set when appropriate
-        if self._is_stopped:
+        if self._handle.is_done():
             status = "stopped"
         if self._daemonic:
             status += " daemon"
@@ -932,12 +972,14 @@ def start(self):
         with _active_limbo_lock:
             _limbo[self] = self
         try:
-            _start_new_thread(self._bootstrap, ())
+            # Start joinable thread
+            _start_joinable_thread(self._bootstrap, handle=self._handle,
+                                   daemon=self.daemon)
         except Exception:
             with _active_limbo_lock:
                 del _limbo[self]
             raise
-        self._started.wait()
+        self._started.wait()  # Will set ident and native_id
 
     def run(self):
         """Method representing the thread's activity.
@@ -983,23 +1025,9 @@ def _set_ident(self):
         def _set_native_id(self):
             self._native_id = get_native_id()
 
-    def _set_tstate_lock(self):
-        """
-        Set a lock object which will be released by the interpreter when
-        the underlying thread state (see pystate.h) gets deleted.
-        """
-        self._tstate_lock = _set_sentinel()
-        self._tstate_lock.acquire()
-
-        if not self.daemon:
-            with _shutdown_locks_lock:
-                _maintain_shutdown_locks()
-                _shutdown_locks.add(self._tstate_lock)
-
     def _bootstrap_inner(self):
         try:
             self._set_ident()
-            self._set_tstate_lock()
             if _HAVE_THREAD_NATIVE_ID:
                 self._set_native_id()
             self._started.set()
@@ -1017,40 +1045,7 @@ def _bootstrap_inner(self):
             except:
                 self._invoke_excepthook(self)
         finally:
-            with _active_limbo_lock:
-                try:
-                    # We don't call self._delete() because it also
-                    # grabs _active_limbo_lock.
-                    del _active[get_ident()]
-                except:
-                    pass
-
-    def _stop(self):
-        # After calling ._stop(), .is_alive() returns False and .join() returns
-        # immediately.  ._tstate_lock must be released before calling ._stop().
-        #
-        # Normal case:  C code at the end of the thread's life
-        # (release_sentinel in _threadmodule.c) releases ._tstate_lock, and
-        # that's detected by our ._wait_for_tstate_lock(), called by .join()
-        # and .is_alive().  Any number of threads _may_ call ._stop()
-        # simultaneously (for example, if multiple threads are blocked in
-        # .join() calls), and they're not serialized.  That's harmless -
-        # they'll just make redundant rebindings of ._is_stopped and
-        # ._tstate_lock.  Obscure:  we rebind ._tstate_lock last so that the
-        # "assert self._is_stopped" in ._wait_for_tstate_lock() always works
-        # (the assert is executed only if ._tstate_lock is None).
-        #
-        # Special case:  _main_thread releases ._tstate_lock via this
-        # module's _shutdown() function.
-        lock = self._tstate_lock
-        if lock is not None:
-            assert not lock.locked()
-        self._is_stopped = True
-        self._tstate_lock = None
-        if not self.daemon:
-            with _shutdown_locks_lock:
-                # Remove our lock and other released locks from _shutdown_locks
-                _maintain_shutdown_locks()
+            self._delete()
 
     def _delete(self):
         "Remove current thread from the dict of currently running threads."
@@ -1069,7 +1064,7 @@ def join(self, timeout=None):
         or until the optional timeout occurs.
 
         When the timeout argument is present and not None, it should be a
-        floating point number specifying a timeout for the operation in seconds
+        floating-point number specifying a timeout for the operation in seconds
         (or fractions thereof). As join() always returns None, you must call
         is_alive() after join() to decide whether a timeout happened -- if the
         thread is still alive, the join() call timed out.
@@ -1092,39 +1087,12 @@ def join(self, timeout=None):
         if self is current_thread():
             raise RuntimeError("cannot join current thread")
 
-        if timeout is None:
-            self._wait_for_tstate_lock()
-        else:
-            # the behavior of a negative timeout isn't documented, but
-            # historically .join(timeout=x) for x<0 has acted as if timeout=0
-            self._wait_for_tstate_lock(timeout=max(timeout, 0))
-
-    def _wait_for_tstate_lock(self, block=True, timeout=-1):
-        # Issue #18808: wait for the thread state to be gone.
-        # At the end of the thread's life, after all knowledge of the thread
-        # is removed from C data structures, C code releases our _tstate_lock.
-        # This method passes its arguments to _tstate_lock.acquire().
-        # If the lock is acquired, the C code is done, and self._stop() is
-        # called.  That sets ._is_stopped to True, and ._tstate_lock to None.
-        lock = self._tstate_lock
-        if lock is None:
-            # already determined that the C code is done
-            assert self._is_stopped
-            return
+        # the behavior of a negative timeout isn't documented, but
+        # historically .join(timeout=x) for x<0 has acted as if timeout=0
+        if timeout is not None:
+            timeout = max(timeout, 0)
 
-        try:
-            if lock.acquire(block, timeout):
-                lock.release()
-                self._stop()
-        except:
-            if lock.locked():
-                # bpo-45274: lock.acquire() acquired the lock, but the function
-                # was interrupted with an exception before reaching the
-                # lock.release(). It can happen if a signal handler raises an
-                # exception, like CTRL+C which raises KeyboardInterrupt.
-                lock.release()
-                self._stop()
-            raise
+        self._handle.join(timeout)
 
     @property
     def name(self):
@@ -1175,10 +1143,7 @@ def is_alive(self):
 
         """
         assert self._initialized, "Thread.__init__() not called"
-        if self._is_stopped or not self._started.is_set():
-            return False
-        self._wait_for_tstate_lock(False)
-        return not self._is_stopped
+        return self._started.is_set() and not self._handle.is_done()
 
     @property
     def daemon(self):
@@ -1199,6 +1164,8 @@ def daemon(self):
     def daemon(self, daemonic):
         if not self._initialized:
             raise RuntimeError("Thread.__init__() not called")
+        if daemonic and not _daemon_threads_allowed():
+            raise RuntimeError('daemon threads are disabled in this interpreter')
         if self._started.is_set():
             raise RuntimeError("cannot set daemon status of active thread")
         self._daemonic = daemonic
@@ -1385,19 +1352,45 @@ class _MainThread(Thread):
 
     def __init__(self):
         Thread.__init__(self, name="MainThread", daemon=False)
-        self._set_tstate_lock()
         self._started.set()
-        self._set_ident()
+        self._ident = _get_main_thread_ident()
+        self._handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
             _active[self._ident] = self
 
 
+# Helper thread-local instance to detect when a _DummyThread
+# is collected. Not a part of the public API.
+_thread_local_info = local()
+
+
+class _DeleteDummyThreadOnDel:
+    '''
+    Helper class to remove a dummy thread from threading._active on __del__.
+    '''
+
+    def __init__(self, dummy_thread):
+        self._dummy_thread = dummy_thread
+        self._tident = dummy_thread.ident
+        # Put the thread on a thread local variable so that when
+        # the related thread finishes this instance is collected.
+        #
+        # Note: no other references to this instance may be created.
+        # If any client code creates a reference to this instance,
+        # the related _DummyThread will be kept forever!
+        _thread_local_info._track_dummy_thread_ref = self
+
+    def __del__(self, _active_limbo_lock=_active_limbo_lock, _active=_active):
+        with _active_limbo_lock:
+            if _active.get(self._tident) is self._dummy_thread:
+                _active.pop(self._tident, None)
+
+
 # Dummy thread class to represent threads not started here.
-# These aren't garbage collected when they die, nor can they be waited for.
-# If they invoke anything in threading.py that calls current_thread(), they
-# leave an entry in the _active dict forever after.
+# These should be added to `_active` and removed automatically
+# when they die, although they can't be waited for.
 # Their purpose is to return *something* from current_thread().
 # They are marked as daemon threads so we won't wait for them
 # when we exit (conform previous semantics).
@@ -1405,24 +1398,31 @@ def __init__(self):
 class _DummyThread(Thread):
 
     def __init__(self):
-        Thread.__init__(self, name=_newname("Dummy-%d"), daemon=True)
-
+        Thread.__init__(self, name=_newname("Dummy-%d"),
+                        daemon=_daemon_threads_allowed())
         self._started.set()
         self._set_ident()
+        self._handle = _make_thread_handle(self._ident)
         if _HAVE_THREAD_NATIVE_ID:
             self._set_native_id()
         with _active_limbo_lock:
             _active[self._ident] = self
-
-    def _stop(self):
-        pass
+        _DeleteDummyThreadOnDel(self)
 
     def is_alive(self):
-        assert not self._is_stopped and self._started.is_set()
-        return True
+        if not self._handle.is_done() and self._started.is_set():
+            return True
+        raise RuntimeError("thread is not alive")
 
     def join(self, timeout=None):
-        assert False, "cannot join a dummy thread"
+        raise RuntimeError("cannot join a dummy thread")
+
+    def _after_fork(self, new_ident=None):
+        if new_ident is not None:
+            self.__class__ = _MainThread
+            self._name = 'MainThread'
+            self._daemonic = False
+        Thread._after_fork(self, new_ident=new_ident)
 
 
 # Global API functions
@@ -1457,6 +1457,8 @@ def active_count():
     enumerate().
 
     """
+    # NOTE: if the logic in here ever changes, update Modules/posixmodule.c
+    # warn_about_fork_with_threads() to match.
     with _active_limbo_lock:
         return len(_active) + len(_limbo)
 
@@ -1503,8 +1505,7 @@ def _register_atexit(func, *arg, **kwargs):
     if _SHUTTING_DOWN:
         raise RuntimeError("can't register atexit after shutdown")
 
-    call = functools.partial(func, *arg, **kwargs)
-    _threading_atexits.append(call)
+    _threading_atexits.append(lambda: func(*arg, **kwargs))
 
 
 from _thread import stack_size
@@ -1519,12 +1520,11 @@ def _shutdown():
     """
     Wait until the Python thread state of all non-daemon threads get deleted.
     """
-    # Obscure:  other threads may be waiting to join _main_thread.  That's
-    # dubious, but some code does it.  We can't wait for C code to release
-    # the main thread's tstate_lock - that won't happen until the interpreter
-    # is nearly dead.  So we release it here.  Note that just calling _stop()
-    # isn't enough:  other threads may already be waiting on _tstate_lock.
-    if _main_thread._is_stopped:
+    # Obscure: other threads may be waiting to join _main_thread.  That's
+    # dubious, but some code does it. We can't wait for it to be marked as done
+    # normally - that won't happen until the interpreter is nearly dead. So
+    # mark it done here.
+    if _main_thread._handle.is_done() and _is_main_interpreter():
         # _shutdown() was already called
         return
 
@@ -1536,39 +1536,11 @@ def _shutdown():
     for atexit_call in reversed(_threading_atexits):
         atexit_call()
 
-    # Main thread
-    if _main_thread.ident == get_ident():
-        tlock = _main_thread._tstate_lock
-        # The main thread isn't finished yet, so its thread state lock can't
-        # have been released.
-        assert tlock is not None
-        assert tlock.locked()
-        tlock.release()
-        _main_thread._stop()
-    else:
-        # bpo-1596321: _shutdown() must be called in the main thread.
-        # If the threading module was not imported by the main thread,
-        # _main_thread is the thread which imported the threading module.
-        # In this case, ignore _main_thread, similar behavior than for threads
-        # spawned by C libraries or using _thread.start_new_thread().
-        pass
-
-    # Join all non-deamon threads
-    while True:
-        with _shutdown_locks_lock:
-            locks = list(_shutdown_locks)
-            _shutdown_locks.clear()
-
-        if not locks:
-            break
-
-        for lock in locks:
-            # mimic Thread.join()
-            lock.acquire()
-            lock.release()
-
-        # new threads can be spawned while we were waiting for the other
-        # threads to complete
+    if _is_main_interpreter():
+        _main_thread._handle._set_done()
+
+    # Wait for all non-daemon threads to exit.
+    _thread_shutdown()
 
 
 def main_thread():
@@ -1577,16 +1549,9 @@ def main_thread():
     In normal conditions, the main thread is the thread from which the
     Python interpreter was started.
     """
+    # XXX Figure this out for subinterpreters.  (See gh-75698.)
     return _main_thread
 
-# get thread-local implementation, either from the thread
-# module, or from the python fallback
-
-try:
-    from _thread import _local as local
-except ImportError:
-    from _threading_local import local
-
 
 def _after_fork():
     """
@@ -1595,7 +1560,6 @@ def _after_fork():
     # Reset _active_limbo_lock, in case we forked while the lock was held
     # by another (non-forked) thread.  http://bugs.python.org/issue874900
     global _active_limbo_lock, _main_thread
-    global _shutdown_locks_lock, _shutdown_locks
     _active_limbo_lock = RLock()
 
     # fork() only copied the current thread; clear references to others.
@@ -1611,10 +1575,6 @@ def _after_fork():
 
     _main_thread = current
 
-    # reset _shutdown() locks: threads re-register their _tstate_lock below
-    _shutdown_locks_lock = _allocate_lock()
-    _shutdown_locks = set()
-
     with _active_limbo_lock:
         # Dangling thread instances must still have their locks reset,
         # because someone may join() them.
@@ -1624,16 +1584,13 @@ def _after_fork():
             # Any lock/condition variable may be currently locked or in an
             # invalid state, so we reinitialize them.
             if thread is current:
-                # There is only one active thread. We reset the ident to
-                # its new value since it can have changed.
-                thread._reset_internal_locks(True)
+                # This is the one and only active thread.
                 ident = get_ident()
-                thread._ident = ident
+                thread._after_fork(new_ident=ident)
                 new_active[ident] = thread
             else:
                 # All the others are already stopped.
-                thread._reset_internal_locks(False)
-                thread._stop()
+                thread._after_fork()
 
         _limbo.clear()
         _active.clear()
diff --git a/Lib/token.py b/Lib/token.py
index 493bf04265..54d7cdccad 100644
--- a/Lib/token.py
+++ b/Lib/token.py
@@ -1,7 +1,8 @@
 """Token constants."""
-# Auto-generated by Tools/scripts/generate_token.py
+# Auto-generated by Tools/build/generate_token.py
 
-__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF']
+__all__ = ['tok_name', 'ISTERMINAL', 'ISNONTERMINAL', 'ISEOF',
+           'EXACT_TOKEN_TYPES']
 
 ENDMARKER = 0
 NAME = 1
@@ -57,17 +58,20 @@
 RARROW = 51
 ELLIPSIS = 52
 COLONEQUAL = 53
-OP = 54
-AWAIT = 55
-ASYNC = 56
-TYPE_IGNORE = 57
-TYPE_COMMENT = 58
+EXCLAMATION = 54
+OP = 55
+TYPE_IGNORE = 56
+TYPE_COMMENT = 57
+SOFT_KEYWORD = 58
+FSTRING_START = 59
+FSTRING_MIDDLE = 60
+FSTRING_END = 61
+COMMENT = 62
+NL = 63
 # These aren't used by the C tokenizer but are needed for tokenize.py
-ERRORTOKEN = 59
-COMMENT = 60
-NL = 61
-ENCODING = 62
-N_TOKENS = 63
+ERRORTOKEN = 64
+ENCODING = 65
+N_TOKENS = 66
 # Special definitions for cooperation with parser
 NT_OFFSET = 256
 
@@ -77,6 +81,7 @@
 __all__.extend(tok_name.values())
 
 EXACT_TOKEN_TYPES = {
+    '!': EXCLAMATION,
     '!=': NOTEQUAL,
     '%': PERCENT,
     '%=': PERCENTEQUAL,
diff --git a/Lib/trace.py b/Lib/trace.py
index 213e46517d..64fc8037e3 100755
--- a/Lib/trace.py
+++ b/Lib/trace.py
@@ -49,6 +49,7 @@
 """
 __all__ = ['Trace', 'CoverageResults']
 
+import io
 import linecache
 import os
 import sys
@@ -201,7 +202,8 @@ def update(self, other):
         for key in other_callers:
             callers[key] = 1
 
-    def write_results(self, show_missing=True, summary=False, coverdir=None):
+    def write_results(self, show_missing=True, summary=False, coverdir=None, *,
+                      ignore_missing_files=False):
         """
         Write the coverage results.
 
@@ -210,6 +212,9 @@ def write_results(self, show_missing=True, summary=False, coverdir=None):
         :param coverdir: If None, the results of each module are placed in its
                          directory, otherwise it is included in the directory
                          specified.
+        :param ignore_missing_files: If True, counts for files that no longer
+                         exist are silently ignored. Otherwise, a missing file
+                         will raise a FileNotFoundError.
         """
         if self.calledfuncs:
             print()
@@ -252,13 +257,15 @@ def write_results(self, show_missing=True, summary=False, coverdir=None):
             if filename.endswith(".pyc"):
                 filename = filename[:-1]
 
+            if ignore_missing_files and not os.path.isfile(filename):
+                continue
+
             if coverdir is None:
                 dir = os.path.dirname(os.path.abspath(filename))
                 modulename = _modname(filename)
             else:
                 dir = coverdir
-                if not os.path.exists(dir):
-                    os.makedirs(dir)
+                os.makedirs(dir, exist_ok=True)
                 modulename = _fullmodname(filename)
 
             # If desired, get a list of the line numbers which represent
@@ -277,7 +284,6 @@ def write_results(self, show_missing=True, summary=False, coverdir=None):
                 percent = int(100 * n_hits / n_lines)
                 sums[modulename] = n_lines, percent, modulename, filename
 
-
         if summary and sums:
             print("lines   cov%   module   (path)")
             for m in sorted(sums):
@@ -559,8 +565,12 @@ def localtrace_trace_and_count(self, frame, why, arg):
             if self.start_time:
                 print('%.2f' % (_time() - self.start_time), end=' ')
             bname = os.path.basename(filename)
-            print("%s(%d): %s" % (bname, lineno,
-                                  linecache.getline(filename, lineno)), end='')
+            line = linecache.getline(filename, lineno)
+            print("%s(%d)" % (bname, lineno), end='')
+            if line:
+                print(": ", line, end='')
+            else:
+                print()
         return self.localtrace
 
     def localtrace_trace(self, frame, why, arg):
@@ -572,8 +582,12 @@ def localtrace_trace(self, frame, why, arg):
             if self.start_time:
                 print('%.2f' % (_time() - self.start_time), end=' ')
             bname = os.path.basename(filename)
-            print("%s(%d): %s" % (bname, lineno,
-                                  linecache.getline(filename, lineno)), end='')
+            line = linecache.getline(filename, lineno)
+            print("%s(%d)" % (bname, lineno), end='')
+            if line:
+                print(": ", line, end='')
+            else:
+                print()
         return self.localtrace
 
     def localtrace_count(self, frame, why, arg):
@@ -716,7 +730,7 @@ def parse_ignore_dir(s):
             sys.argv = [opts.progname, *opts.arguments]
             sys.path[0] = os.path.dirname(opts.progname)
 
-            with open(opts.progname, 'rb') as fp:
+            with io.open_code(opts.progname) as fp:
                 code = compile(fp.read(), opts.progname, 'exec')
             # try to emulate __main__ namespace as much as possible
             globs = {
diff --git a/Lib/traceback.py b/Lib/traceback.py
index d6a010f415..572a3177cb 100644
--- a/Lib/traceback.py
+++ b/Lib/traceback.py
@@ -1,9 +1,14 @@
 """Extract, format and print information about Python stack traces."""
 
-import collections
+import collections.abc
 import itertools
 import linecache
 import sys
+import textwrap
+import warnings
+from contextlib import suppress
+import _colorize
+from _colorize import ANSIColors
 
 __all__ = ['extract_stack', 'extract_tb', 'format_exception',
            'format_exception_only', 'format_list', 'format_stack',
@@ -16,6 +21,7 @@
 # Formatting and printing lists of traceback lines.
 #
 
+
 def print_list(extracted_list, file=None):
     """Print the list of tuples as returned by extract_tb() or
     extract_stack() as a formatted stack trace to the given file."""
@@ -69,7 +75,8 @@ def extract_tb(tb, limit=None):
     trace.  The line is a string with leading and trailing
     whitespace stripped; if the source is not available it is None.
     """
-    return StackSummary.extract(walk_tb(tb), limit=limit)
+    return StackSummary._extract_from_extended_frame_gen(
+        _walk_tb_with_full_positions(tb), limit=limit)
 
 #
 # Exception formatting and output.
@@ -95,14 +102,18 @@ def _parse_value_tb(exc, value, tb):
         raise ValueError("Both or neither of value and tb must be given")
     if value is tb is _sentinel:
         if exc is not None:
-            return exc, exc.__traceback__
+            if isinstance(exc, BaseException):
+                return exc, exc.__traceback__
+
+            raise TypeError(f'Exception expected for value, '
+                            f'{type(exc).__name__} found')
         else:
             return None, None
     return value, tb
 
 
 def print_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
-                    file=None, chain=True):
+                    file=None, chain=True, **kwargs):
     """Print exception up to 'limit' stack trace entries from 'tb' to 'file'.
 
     This differs from print_tb() in the following ways: (1) if
@@ -113,16 +124,23 @@ def print_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
     occurred with a caret on the next line indicating the approximate
     position of the error.
     """
+    colorize = kwargs.get("colorize", False)
     value, tb = _parse_value_tb(exc, value, tb)
-    if file is None:
-        file = sys.stderr
     te = TracebackException(type(value), value, tb, limit=limit, compact=True)
-    for line in te.format(chain=chain):
-        print(line, file=file, end="")
+    te.print(file=file, chain=chain, colorize=colorize)
+
+
+BUILTIN_EXCEPTION_LIMIT = object()
+
+
+def _print_exception_bltin(exc, /):
+    file = sys.stderr if sys.stderr is not None else sys.__stderr__
+    colorize = _colorize.can_colorize(file=file)
+    return print_exception(exc, limit=BUILTIN_EXCEPTION_LIMIT, file=file, colorize=colorize)
 
 
 def format_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
-                     chain=True):
+                     chain=True, **kwargs):
     """Format a stack trace and the exception information.
 
     The arguments have the same meaning as the corresponding arguments
@@ -131,64 +149,79 @@ def format_exception(exc, /, value=_sentinel, tb=_sentinel, limit=None, \
     these lines are concatenated and printed, exactly the same text is
     printed as does print_exception().
     """
+    colorize = kwargs.get("colorize", False)
     value, tb = _parse_value_tb(exc, value, tb)
     te = TracebackException(type(value), value, tb, limit=limit, compact=True)
-    return list(te.format(chain=chain))
+    return list(te.format(chain=chain, colorize=colorize))
 
 
-def format_exception_only(exc, /, value=_sentinel):
+def format_exception_only(exc, /, value=_sentinel, *, show_group=False, **kwargs):
     """Format the exception part of a traceback.
 
     The return value is a list of strings, each ending in a newline.
 
-    Normally, the list contains a single string; however, for
-    SyntaxError exceptions, it contains several lines that (when
-    printed) display detailed information about where the syntax
-    error occurred.
-
-    The message indicating which exception occurred is always the last
-    string in the list.
+    The list contains the exception's message, which is
+    normally a single string; however, for :exc:`SyntaxError` exceptions, it
+    contains several lines that (when printed) display detailed information
+    about where the syntax error occurred. Following the message, the list
+    contains the exception's ``__notes__``.
 
+    When *show_group* is ``True``, and the exception is an instance of
+    :exc:`BaseExceptionGroup`, the nested exceptions are included as
+    well, recursively, with indentation relative to their nesting depth.
     """
+    colorize = kwargs.get("colorize", False)
     if value is _sentinel:
         value = exc
     te = TracebackException(type(value), value, None, compact=True)
-    return list(te.format_exception_only())
+    return list(te.format_exception_only(show_group=show_group, colorize=colorize))
 
 
 # -- not official API but folk probably use these two functions.
 
-def _format_final_exc_line(etype, value):
-    valuestr = _some_str(value)
-    if value is None or not valuestr:
-        line = "%s\n" % etype
+def _format_final_exc_line(etype, value, *, insert_final_newline=True, colorize=False):
+    valuestr = _safe_string(value, 'exception')
+    end_char = "\n" if insert_final_newline else ""
+    if colorize:
+        if value is None or not valuestr:
+            line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}{end_char}"
+        else:
+            line = f"{ANSIColors.BOLD_MAGENTA}{etype}{ANSIColors.RESET}: {ANSIColors.MAGENTA}{valuestr}{ANSIColors.RESET}{end_char}"
     else:
-        line = "%s: %s\n" % (etype, valuestr)
+        if value is None or not valuestr:
+            line = f"{etype}{end_char}"
+        else:
+            line = f"{etype}: {valuestr}{end_char}"
     return line
 
-def _some_str(value):
+
+def _safe_string(value, what, func=str):
     try:
-        return str(value)
+        return func(value)
     except:
-        return '<unprintable %s object>' % type(value).__name__
+        return f'<{what} {func.__name__}() failed>'
 
 # --
 
 def print_exc(limit=None, file=None, chain=True):
-    """Shorthand for 'print_exception(*sys.exc_info(), limit, file)'."""
-    print_exception(*sys.exc_info(), limit=limit, file=file, chain=chain)
+    """Shorthand for 'print_exception(sys.exception(), limit=limit, file=file, chain=chain)'."""
+    print_exception(sys.exception(), limit=limit, file=file, chain=chain)
 
 def format_exc(limit=None, chain=True):
     """Like print_exc() but return a string."""
-    return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain))
+    return "".join(format_exception(sys.exception(), limit=limit, chain=chain))
 
 def print_last(limit=None, file=None, chain=True):
-    """This is a shorthand for 'print_exception(sys.last_type,
-    sys.last_value, sys.last_traceback, limit, file)'."""
-    if not hasattr(sys, "last_type"):
+    """This is a shorthand for 'print_exception(sys.last_exc, limit=limit, file=file, chain=chain)'."""
+    if not hasattr(sys, "last_exc") and not hasattr(sys, "last_type"):
         raise ValueError("no last exception")
-    print_exception(sys.last_type, sys.last_value, sys.last_traceback,
-                    limit, file, chain)
+
+    if hasattr(sys, "last_exc"):
+        print_exception(sys.last_exc, limit=limit, file=file, chain=chain)
+    else:
+        print_exception(sys.last_type, sys.last_value, sys.last_traceback,
+                        limit=limit, file=file, chain=chain)
+
 
 #
 # Printing and Extracting Stacks.
@@ -241,7 +274,7 @@ def clear_frames(tb):
 
 
 class FrameSummary:
-    """A single frame from a traceback.
+    """Information about a single frame from a traceback.
 
     - :attr:`filename` The filename for the frame.
     - :attr:`lineno` The line within filename for the frame that was
@@ -254,10 +287,12 @@ class FrameSummary:
       mapping the name to the repr() of the variable.
     """
 
-    __slots__ = ('filename', 'lineno', 'name', '_line', 'locals')
+    __slots__ = ('filename', 'lineno', 'end_lineno', 'colno', 'end_colno',
+                 'name', '_lines', '_lines_dedented', 'locals', '_code')
 
     def __init__(self, filename, lineno, name, *, lookup_line=True,
-            locals=None, line=None):
+            locals=None, line=None,
+            end_lineno=None, colno=None, end_colno=None, **kwargs):
         """Construct a FrameSummary.
 
         :param lookup_line: If True, `linecache` is consulted for the source
@@ -269,11 +304,17 @@ def __init__(self, filename, lineno, name, *, lookup_line=True,
         """
         self.filename = filename
         self.lineno = lineno
+        self.end_lineno = lineno if end_lineno is None else end_lineno
+        self.colno = colno
+        self.end_colno = end_colno
         self.name = name
-        self._line = line
+        self._code = kwargs.get("_code")
+        self._lines = line
+        self._lines_dedented = None
         if lookup_line:
             self.line
-        self.locals = {k: repr(v) for k, v in locals.items()} if locals else None
+        self.locals = {k: _safe_string(v, 'local', func=repr)
+            for k, v in locals.items()} if locals else None
 
     def __eq__(self, other):
         if isinstance(other, FrameSummary):
@@ -298,13 +339,43 @@ def __repr__(self):
     def __len__(self):
         return 4
 
+    def _set_lines(self):
+        if (
+            self._lines is None
+            and self.lineno is not None
+            and self.end_lineno is not None
+        ):
+            lines = []
+            for lineno in range(self.lineno, self.end_lineno + 1):
+                # treat errors (empty string) and empty lines (newline) as the same
+                line = linecache.getline(self.filename, lineno).rstrip()
+                if not line and self._code is not None and self.filename.startswith("<"):
+                    line = linecache._getline_from_code(self._code, lineno).rstrip()
+                lines.append(line)
+            self._lines = "\n".join(lines) + "\n"
+
+    @property
+    def _original_lines(self):
+        # Returns the line as-is from the source, without modifying whitespace.
+        self._set_lines()
+        return self._lines
+
+    @property
+    def _dedented_lines(self):
+        # Returns _original_lines, but dedented
+        self._set_lines()
+        if self._lines_dedented is None and self._lines is not None:
+            self._lines_dedented = textwrap.dedent(self._lines)
+        return self._lines_dedented
+
     @property
     def line(self):
-        if self._line is None:
-            if self.lineno is None:
-                return None
-            self._line = linecache.getline(self.filename, self.lineno)
-        return self._line.strip()
+        self._set_lines()
+        if self._lines is None:
+            return None
+        # return only the first line, stripped
+        return self._lines.partition("\n")[0].strip()
+
 
 def walk_stack(f):
     """Walk a stack yielding the frame and line number for each frame.
@@ -313,7 +384,7 @@ def walk_stack(f):
     current stack is used. Usually used with StackSummary.extract.
     """
     if f is None:
-        f = sys._getframe().f_back.f_back
+        f = sys._getframe().f_back.f_back.f_back.f_back
     while f is not None:
         yield f, f.f_lineno
         f = f.f_back
@@ -330,18 +401,40 @@ def walk_tb(tb):
         tb = tb.tb_next
 
 
+def _walk_tb_with_full_positions(tb):
+    # Internal version of walk_tb that yields full code positions including
+    # end line and column information.
+    while tb is not None:
+        positions = _get_code_position(tb.tb_frame.f_code, tb.tb_lasti)
+        # Yield tb_lineno when co_positions does not have a line number to
+        # maintain behavior with walk_tb.
+        if positions[0] is None:
+            yield tb.tb_frame, (tb.tb_lineno, ) + positions[1:]
+        else:
+            yield tb.tb_frame, positions
+        tb = tb.tb_next
+
+
+def _get_code_position(code, instruction_index):
+    if instruction_index < 0:
+        return (None, None, None, None)
+    positions_gen = code.co_positions()
+    return next(itertools.islice(positions_gen, instruction_index // 2, None))
+
+
 _RECURSIVE_CUTOFF = 3 # Also hardcoded in traceback.c.
 
+
 class StackSummary(list):
-    """A stack of frames."""
+    """A list of FrameSummary objects, representing a stack of frames."""
 
     @classmethod
     def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
             capture_locals=False):
         """Create a StackSummary from a traceback or stack object.
 
-        :param frame_gen: A generator that yields (frame, lineno) tuples to
-            include in the stack.
+        :param frame_gen: A generator that yields (frame, lineno) tuples
+            whose summaries are to be included in the stack.
         :param limit: None to include all frames or the number of frames to
             include.
         :param lookup_lines: If True, lookup lines for each frame immediately,
@@ -349,23 +442,41 @@ def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
         :param capture_locals: If True, the local variables from each frame will
             be captured as object representations into the FrameSummary.
         """
-        if limit is None:
+        def extended_frame_gen():
+            for f, lineno in frame_gen:
+                yield f, (lineno, None, None, None)
+
+        return klass._extract_from_extended_frame_gen(
+            extended_frame_gen(), limit=limit, lookup_lines=lookup_lines,
+            capture_locals=capture_locals)
+
+    @classmethod
+    def _extract_from_extended_frame_gen(klass, frame_gen, *, limit=None,
+            lookup_lines=True, capture_locals=False):
+        # Same as extract but operates on a frame generator that yields
+        # (frame, (lineno, end_lineno, colno, end_colno)) in the stack.
+        # Only lineno is required, the remaining fields can be None if the
+        # information is not available.
+        builtin_limit = limit is BUILTIN_EXCEPTION_LIMIT
+        if limit is None or builtin_limit:
             limit = getattr(sys, 'tracebacklimit', None)
             if limit is not None and limit < 0:
                 limit = 0
         if limit is not None:
-            if limit >= 0:
+            if builtin_limit:
+                frame_gen = tuple(frame_gen)
+                frame_gen = frame_gen[len(frame_gen) - limit:]
+            elif limit >= 0:
                 frame_gen = itertools.islice(frame_gen, limit)
             else:
                 frame_gen = collections.deque(frame_gen, maxlen=-limit)
 
         result = klass()
         fnames = set()
-        for f, lineno in frame_gen:
+        for f, (lineno, end_lineno, colno, end_colno) in frame_gen:
             co = f.f_code
             filename = co.co_filename
             name = co.co_name
-
             fnames.add(filename)
             linecache.lazycache(filename, f.f_globals)
             # Must defer line lookups until we have called checkcache.
@@ -373,10 +484,16 @@ def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
                 f_locals = f.f_locals
             else:
                 f_locals = None
-            result.append(FrameSummary(
-                filename, lineno, name, lookup_line=False, locals=f_locals))
+            result.append(
+                FrameSummary(filename, lineno, name,
+                    lookup_line=False, locals=f_locals,
+                    end_lineno=end_lineno, colno=colno, end_colno=end_colno,
+                    _code=f.f_code,
+                )
+            )
         for filename in fnames:
             linecache.checkcache(filename)
+
         # If immediate lookup was desired, trigger lookups now.
         if lookup_lines:
             for f in result:
@@ -402,7 +519,223 @@ def from_list(klass, a_list):
                 result.append(FrameSummary(filename, lineno, name, line=line))
         return result
 
-    def format(self):
+    def format_frame_summary(self, frame_summary, **kwargs):
+        """Format the lines for a single FrameSummary.
+
+        Returns a string representing one frame involved in the stack. This
+        gets called for every frame to be printed in the stack summary.
+        """
+        colorize = kwargs.get("colorize", False)
+        row = []
+        filename = frame_summary.filename
+        if frame_summary.filename.startswith("<stdin-") and frame_summary.filename.endswith('>'):
+            filename = "<stdin>"
+        if colorize:
+            row.append('  File {}"{}"{}, line {}{}{}, in {}{}{}\n'.format(
+                    ANSIColors.MAGENTA,
+                    filename,
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    frame_summary.lineno,
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    frame_summary.name,
+                    ANSIColors.RESET,
+                    )
+            )
+        else:
+            row.append('  File "{}", line {}, in {}\n'.format(
+                filename, frame_summary.lineno, frame_summary.name))
+        if frame_summary._dedented_lines and frame_summary._dedented_lines.strip():
+            if (
+                frame_summary.colno is None or
+                frame_summary.end_colno is None
+            ):
+                # only output first line if column information is missing
+                row.append(textwrap.indent(frame_summary.line, '    ') + "\n")
+            else:
+                # get first and last line
+                all_lines_original = frame_summary._original_lines.splitlines()
+                first_line = all_lines_original[0]
+                # assume all_lines_original has enough lines (since we constructed it)
+                last_line = all_lines_original[frame_summary.end_lineno - frame_summary.lineno]
+
+                # character index of the start/end of the instruction
+                start_offset = _byte_offset_to_character_offset(first_line, frame_summary.colno)
+                end_offset = _byte_offset_to_character_offset(last_line, frame_summary.end_colno)
+
+                all_lines = frame_summary._dedented_lines.splitlines()[
+                    :frame_summary.end_lineno - frame_summary.lineno + 1
+                ]
+
+                # adjust start/end offset based on dedent
+                dedent_characters = len(first_line) - len(all_lines[0])
+                start_offset = max(0, start_offset - dedent_characters)
+                end_offset = max(0, end_offset - dedent_characters)
+
+                # When showing this on a terminal, some of the non-ASCII characters
+                # might be rendered as double-width characters, so we need to take
+                # that into account when calculating the length of the line.
+                dp_start_offset = _display_width(all_lines[0], offset=start_offset)
+                dp_end_offset = _display_width(all_lines[-1], offset=end_offset)
+
+                # get exact code segment corresponding to the instruction
+                segment = "\n".join(all_lines)
+                segment = segment[start_offset:len(segment) - (len(all_lines[-1]) - end_offset)]
+
+                # attempt to parse for anchors
+                anchors = None
+                show_carets = False
+                with suppress(Exception):
+                    anchors = _extract_caret_anchors_from_line_segment(segment)
+                show_carets = self._should_show_carets(start_offset, end_offset, all_lines, anchors)
+
+                result = []
+
+                # only display first line, last line, and lines around anchor start/end
+                significant_lines = {0, len(all_lines) - 1}
+
+                anchors_left_end_offset = 0
+                anchors_right_start_offset = 0
+                primary_char = "^"
+                secondary_char = "^"
+                if anchors:
+                    anchors_left_end_offset = anchors.left_end_offset
+                    anchors_right_start_offset = anchors.right_start_offset
+                    # computed anchor positions do not take start_offset into account,
+                    # so account for it here
+                    if anchors.left_end_lineno == 0:
+                        anchors_left_end_offset += start_offset
+                    if anchors.right_start_lineno == 0:
+                        anchors_right_start_offset += start_offset
+
+                    # account for display width
+                    anchors_left_end_offset = _display_width(
+                        all_lines[anchors.left_end_lineno], offset=anchors_left_end_offset
+                    )
+                    anchors_right_start_offset = _display_width(
+                        all_lines[anchors.right_start_lineno], offset=anchors_right_start_offset
+                    )
+
+                    primary_char = anchors.primary_char
+                    secondary_char = anchors.secondary_char
+                    significant_lines.update(
+                        range(anchors.left_end_lineno - 1, anchors.left_end_lineno + 2)
+                    )
+                    significant_lines.update(
+                        range(anchors.right_start_lineno - 1, anchors.right_start_lineno + 2)
+                    )
+
+                # remove bad line numbers
+                significant_lines.discard(-1)
+                significant_lines.discard(len(all_lines))
+
+                def output_line(lineno):
+                    """output all_lines[lineno] along with carets"""
+                    result.append(all_lines[lineno] + "\n")
+                    if not show_carets:
+                        return
+                    num_spaces = len(all_lines[lineno]) - len(all_lines[lineno].lstrip())
+                    carets = []
+                    num_carets = dp_end_offset if lineno == len(all_lines) - 1 else _display_width(all_lines[lineno])
+                    # compute caret character for each position
+                    for col in range(num_carets):
+                        if col < num_spaces or (lineno == 0 and col < dp_start_offset):
+                            # before first non-ws char of the line, or before start of instruction
+                            carets.append(' ')
+                        elif anchors and (
+                            lineno > anchors.left_end_lineno or
+                            (lineno == anchors.left_end_lineno and col >= anchors_left_end_offset)
+                        ) and (
+                            lineno < anchors.right_start_lineno or
+                            (lineno == anchors.right_start_lineno and col < anchors_right_start_offset)
+                        ):
+                            # within anchors
+                            carets.append(secondary_char)
+                        else:
+                            carets.append(primary_char)
+                    if colorize:
+                        # Replace the previous line with a red version of it only in the parts covered
+                        # by the carets.
+                        line = result[-1]
+                        colorized_line_parts = []
+                        colorized_carets_parts = []
+
+                        for color, group in itertools.groupby(itertools.zip_longest(line, carets, fillvalue=""), key=lambda x: x[1]):
+                            caret_group = list(group)
+                            if color == "^":
+                                colorized_line_parts.append(ANSIColors.BOLD_RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+                                colorized_carets_parts.append(ANSIColors.BOLD_RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
+                            elif color == "~":
+                                colorized_line_parts.append(ANSIColors.RED + "".join(char for char, _ in caret_group) + ANSIColors.RESET)
+                                colorized_carets_parts.append(ANSIColors.RED + "".join(caret for _, caret in caret_group) + ANSIColors.RESET)
+                            else:
+                                colorized_line_parts.append("".join(char for char, _ in caret_group))
+                                colorized_carets_parts.append("".join(caret for _, caret in caret_group))
+
+                        colorized_line = "".join(colorized_line_parts)
+                        colorized_carets = "".join(colorized_carets_parts)
+                        result[-1] = colorized_line
+                        result.append(colorized_carets + "\n")
+                    else:
+                        result.append("".join(carets) + "\n")
+
+                # display significant lines
+                sig_lines_list = sorted(significant_lines)
+                for i, lineno in enumerate(sig_lines_list):
+                    if i:
+                        linediff = lineno - sig_lines_list[i - 1]
+                        if linediff == 2:
+                            # 1 line in between - just output it
+                            output_line(lineno - 1)
+                        elif linediff > 2:
+                            # > 1 line in between - abbreviate
+                            result.append(f"...<{linediff - 1} lines>...\n")
+                    output_line(lineno)
+
+                row.append(
+                    textwrap.indent(textwrap.dedent("".join(result)), '    ', lambda line: True)
+                )
+        if frame_summary.locals:
+            for name, value in sorted(frame_summary.locals.items()):
+                row.append('    {name} = {value}\n'.format(name=name, value=value))
+
+        return ''.join(row)
+
+    def _should_show_carets(self, start_offset, end_offset, all_lines, anchors):
+        with suppress(SyntaxError, ImportError):
+            import ast
+            tree = ast.parse('\n'.join(all_lines))
+            if not tree.body:
+                return False
+            statement = tree.body[0]
+            value = None
+            def _spawns_full_line(value):
+                return (
+                    value.lineno == 1
+                    and value.end_lineno == len(all_lines)
+                    and value.col_offset == start_offset
+                    and value.end_col_offset == end_offset
+                )
+            match statement:
+                case ast.Return(value=ast.Call()):
+                    if isinstance(statement.value.func, ast.Name):
+                        value = statement.value
+                case ast.Assign(value=ast.Call()):
+                    if (
+                        len(statement.targets) == 1 and
+                        isinstance(statement.targets[0], ast.Name)
+                    ):
+                        value = statement.value
+            if value is not None and _spawns_full_line(value):
+                return False
+        if anchors:
+            return True
+        if all_lines[0][:start_offset].lstrip() or all_lines[-1][end_offset:].rstrip():
+            return True
+        return False
+
+    def format(self, **kwargs):
         """Format the stack ready for printing.
 
         Returns a list of strings ready for printing.  Each string in the
@@ -414,37 +747,34 @@ def format(self):
         repetitions are shown, followed by a summary line stating the exact
         number of further repetitions.
         """
+        colorize = kwargs.get("colorize", False)
         result = []
         last_file = None
         last_line = None
         last_name = None
         count = 0
-        for frame in self:
-            if (last_file is None or last_file != frame.filename or
-                last_line is None or last_line != frame.lineno or
-                last_name is None or last_name != frame.name):
+        for frame_summary in self:
+            formatted_frame = self.format_frame_summary(frame_summary, colorize=colorize)
+            if formatted_frame is None:
+                continue
+            if (last_file is None or last_file != frame_summary.filename or
+                last_line is None or last_line != frame_summary.lineno or
+                last_name is None or last_name != frame_summary.name):
                 if count > _RECURSIVE_CUTOFF:
                     count -= _RECURSIVE_CUTOFF
                     result.append(
                         f'  [Previous line repeated {count} more '
                         f'time{"s" if count > 1 else ""}]\n'
                     )
-                last_file = frame.filename
-                last_line = frame.lineno
-                last_name = frame.name
+                last_file = frame_summary.filename
+                last_line = frame_summary.lineno
+                last_name = frame_summary.name
                 count = 0
             count += 1
             if count > _RECURSIVE_CUTOFF:
                 continue
-            row = []
-            row.append('  File "{}", line {}, in {}\n'.format(
-                frame.filename, frame.lineno, frame.name))
-            if frame.line:
-                row.append('    {}\n'.format(frame.line.strip()))
-            if frame.locals:
-                for name, value in sorted(frame.locals.items()):
-                    row.append('    {name} = {value}\n'.format(name=name, value=value))
-            result.append(''.join(row))
+            result.append(formatted_frame)
+
         if count > _RECURSIVE_CUTOFF:
             count -= _RECURSIVE_CUTOFF
             result.append(
@@ -454,6 +784,216 @@ def format(self):
         return result
 
 
+def _byte_offset_to_character_offset(str, offset):
+    as_utf8 = str.encode('utf-8')
+    return len(as_utf8[:offset].decode("utf-8", errors="replace"))
+
+
+_Anchors = collections.namedtuple(
+    "_Anchors",
+    [
+        "left_end_lineno",
+        "left_end_offset",
+        "right_start_lineno",
+        "right_start_offset",
+        "primary_char",
+        "secondary_char",
+    ],
+    defaults=["~", "^"]
+)
+
+def _extract_caret_anchors_from_line_segment(segment):
+    """
+    Given source code `segment` corresponding to a FrameSummary, determine:
+        - for binary ops, the location of the binary op
+        - for indexing and function calls, the location of the brackets.
+    `segment` is expected to be a valid Python expression.
+    """
+    import ast
+
+    try:
+        # Without parentheses, `segment` is parsed as a statement.
+        # Binary ops, subscripts, and calls are expressions, so
+        # we can wrap them with parentheses to parse them as
+        # (possibly multi-line) expressions.
+        # e.g. if we try to highlight the addition in
+        # x = (
+        #     a +
+        #     b
+        # )
+        # then we would ast.parse
+        #     a +
+        #     b
+        # which is not a valid statement because of the newline.
+        # Adding brackets makes it a valid expression.
+        # (
+        #     a +
+        #     b
+        # )
+        # Line locations will be different than the original,
+        # which is taken into account later on.
+        tree = ast.parse(f"(\n{segment}\n)")
+    except SyntaxError:
+        return None
+
+    if len(tree.body) != 1:
+        return None
+
+    lines = segment.splitlines()
+
+    def normalize(lineno, offset):
+        """Get character index given byte offset"""
+        return _byte_offset_to_character_offset(lines[lineno], offset)
+
+    def next_valid_char(lineno, col):
+        """Gets the next valid character index in `lines`, if
+        the current location is not valid. Handles empty lines.
+        """
+        while lineno < len(lines) and col >= len(lines[lineno]):
+            col = 0
+            lineno += 1
+        assert lineno < len(lines) and col < len(lines[lineno])
+        return lineno, col
+
+    def increment(lineno, col):
+        """Get the next valid character index in `lines`."""
+        col += 1
+        lineno, col = next_valid_char(lineno, col)
+        return lineno, col
+
+    def nextline(lineno, col):
+        """Get the next valid character at least on the next line"""
+        col = 0
+        lineno += 1
+        lineno, col = next_valid_char(lineno, col)
+        return lineno, col
+
+    def increment_until(lineno, col, stop):
+        """Get the next valid non-"\\#" character that satisfies the `stop` predicate"""
+        while True:
+            ch = lines[lineno][col]
+            if ch in "\\#":
+                lineno, col = nextline(lineno, col)
+            elif not stop(ch):
+                lineno, col = increment(lineno, col)
+            else:
+                break
+        return lineno, col
+
+    def setup_positions(expr, force_valid=True):
+        """Get the lineno/col position of the end of `expr`. If `force_valid` is True,
+        forces the position to be a valid character (e.g. if the position is beyond the
+        end of the line, move to the next line)
+        """
+        # -2 since end_lineno is 1-indexed and because we added an extra
+        # bracket + newline to `segment` when calling ast.parse
+        lineno = expr.end_lineno - 2
+        col = normalize(lineno, expr.end_col_offset)
+        return next_valid_char(lineno, col) if force_valid else (lineno, col)
+
+    statement = tree.body[0]
+    match statement:
+        case ast.Expr(expr):
+            match expr:
+                case ast.BinOp():
+                    # ast gives these locations for BinOp subexpressions
+                    # ( left_expr ) + ( right_expr )
+                    #   left^^^^^       right^^^^^
+                    lineno, col = setup_positions(expr.left)
+
+                    # First operator character is the first non-space/')' character
+                    lineno, col = increment_until(lineno, col, lambda x: not x.isspace() and x != ')')
+
+                    # binary op is 1 or 2 characters long, on the same line,
+                    # before the right subexpression
+                    right_col = col + 1
+                    if (
+                        right_col < len(lines[lineno])
+                        and (
+                            # operator char should not be in the right subexpression
+                            expr.right.lineno - 2 > lineno or
+                            right_col < normalize(expr.right.lineno - 2, expr.right.col_offset)
+                        )
+                        and not (ch := lines[lineno][right_col]).isspace()
+                        and ch not in "\\#"
+                    ):
+                        right_col += 1
+
+                    # right_col can be invalid since it is exclusive
+                    return _Anchors(lineno, col, lineno, right_col)
+                case ast.Subscript():
+                    # ast gives these locations for value and slice subexpressions
+                    # ( value_expr ) [ slice_expr ]
+                    #   value^^^^^     slice^^^^^
+                    # subscript^^^^^^^^^^^^^^^^^^^^
+
+                    # find left bracket
+                    left_lineno, left_col = setup_positions(expr.value)
+                    left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '[')
+                    # find right bracket (final character of expression)
+                    right_lineno, right_col = setup_positions(expr, force_valid=False)
+                    return _Anchors(left_lineno, left_col, right_lineno, right_col)
+                case ast.Call():
+                    # ast gives these locations for function call expressions
+                    # ( func_expr ) (args, kwargs)
+                    #   func^^^^^
+                    # call^^^^^^^^^^^^^^^^^^^^^^^^
+
+                    # find left bracket
+                    left_lineno, left_col = setup_positions(expr.func)
+                    left_lineno, left_col = increment_until(left_lineno, left_col, lambda x: x == '(')
+                    # find right bracket (final character of expression)
+                    right_lineno, right_col = setup_positions(expr, force_valid=False)
+                    return _Anchors(left_lineno, left_col, right_lineno, right_col)
+
+    return None
+
+_WIDE_CHAR_SPECIFIERS = "WF"
+
+def _display_width(line, offset=None):
+    """Calculate the extra amount of width space the given source
+    code segment might take if it were to be displayed on a fixed
+    width output device. Supports wide unicode characters and emojis."""
+
+    if offset is None:
+        offset = len(line)
+
+    # Fast track for ASCII-only strings
+    if line.isascii():
+        return offset
+
+    import unicodedata
+
+    return sum(
+        2 if unicodedata.east_asian_width(char) in _WIDE_CHAR_SPECIFIERS else 1
+        for char in line[:offset]
+    )
+
+
+
+class _ExceptionPrintContext:
+    def __init__(self):
+        self.seen = set()
+        self.exception_group_depth = 0
+        self.need_close = False
+
+    def indent(self):
+        return ' ' * (2 * self.exception_group_depth)
+
+    def emit(self, text_gen, margin_char=None):
+        if margin_char is None:
+            margin_char = '|'
+        indent_str = self.indent()
+        if self.exception_group_depth:
+            indent_str += margin_char + ' '
+
+        if isinstance(text_gen, str):
+            yield textwrap.indent(text_gen, indent_str, lambda line: True)
+        else:
+            for text in text_gen:
+                yield textwrap.indent(text, indent_str, lambda line: True)
+
+
 class TracebackException:
     """An exception ready for rendering.
 
@@ -461,16 +1001,24 @@ class TracebackException:
     to this intermediary form to ensure that no references are held, while
     still being able to fully print or format it.
 
+    max_group_width and max_group_depth control the formatting of exception
+    groups. The depth refers to the nesting level of the group, and the width
+    refers to the size of a single exception group's exceptions array. The
+    formatted output is truncated when either limit is exceeded.
+
     Use `from_exception` to create TracebackException instances from exception
     objects, or the constructor to create TracebackException instances from
     individual components.
 
     - :attr:`__cause__` A TracebackException of the original *__cause__*.
     - :attr:`__context__` A TracebackException of the original *__context__*.
+    - :attr:`exceptions` For exception groups - a list of TracebackException
+      instances for the nested *exceptions*.  ``None`` for other exceptions.
     - :attr:`__suppress_context__` The *__suppress_context__* value from the
       original exception.
     - :attr:`stack` A `StackSummary` representing the traceback.
-    - :attr:`exc_type` The class of the original traceback.
+    - :attr:`exc_type` (deprecated) The class of the original traceback.
+    - :attr:`exc_type_str` String display of exc_type
     - :attr:`filename` For syntax errors - the filename where the error
       occurred.
     - :attr:`lineno` For syntax errors - the linenumber where the error
@@ -481,14 +1029,14 @@ class TracebackException:
       occurred.
     - :attr:`offset` For syntax errors - the offset into the text where the
       error occurred.
-    - :attr:`end_offset` For syntax errors - the offset into the text where the
-      error occurred. Can be `None` if not present.
+    - :attr:`end_offset` For syntax errors - the end offset into the text where
+      the error occurred. Can be `None` if not present.
     - :attr:`msg` For syntax errors - the compiler error message.
     """
 
     def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             lookup_lines=True, capture_locals=False, compact=False,
-            _seen=None):
+            max_group_width=15, max_group_depth=10, save_exc_type=True, _seen=None):
         # NB: we need to accept exc_traceback, exc_value, exc_traceback to
         # permit backwards compat with the existing API, otherwise we
         # need stub thunk objects just to glue it together.
@@ -498,14 +1046,34 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             _seen = set()
         _seen.add(id(exc_value))
 
-        # TODO: locals.
-        self.stack = StackSummary.extract(
-            walk_tb(exc_traceback), limit=limit, lookup_lines=lookup_lines,
+        self.max_group_width = max_group_width
+        self.max_group_depth = max_group_depth
+
+        self.stack = StackSummary._extract_from_extended_frame_gen(
+            _walk_tb_with_full_positions(exc_traceback),
+            limit=limit, lookup_lines=lookup_lines,
             capture_locals=capture_locals)
-        self.exc_type = exc_type
+
+        self._exc_type = exc_type if save_exc_type else None
+
         # Capture now to permit freeing resources: only complication is in the
         # unofficial API _format_final_exc_line
-        self._str = _some_str(exc_value)
+        self._str = _safe_string(exc_value, 'exception')
+        try:
+            self.__notes__ = getattr(exc_value, '__notes__', None)
+        except Exception as e:
+            self.__notes__ = [
+                f'Ignored error getting __notes__: {_safe_string(e, '__notes__', repr)}']
+
+        self._is_syntax_error = False
+        self._have_exc_type = exc_type is not None
+        if exc_type is not None:
+            self.exc_type_qualname = exc_type.__qualname__
+            self.exc_type_module = exc_type.__module__
+        else:
+            self.exc_type_qualname = None
+            self.exc_type_module = None
+
         if exc_type and issubclass(exc_type, SyntaxError):
             # Handle SyntaxError's specially
             self.filename = exc_value.filename
@@ -517,6 +1085,26 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             self.offset = exc_value.offset
             self.end_offset = exc_value.end_offset
             self.msg = exc_value.msg
+            self._is_syntax_error = True
+        elif exc_type and issubclass(exc_type, ImportError) and \
+                getattr(exc_value, "name_from", None) is not None:
+            wrong_name = getattr(exc_value, "name_from", None)
+            suggestion = _compute_suggestion_error(exc_value, exc_traceback, wrong_name)
+            if suggestion:
+                self._str += f". Did you mean: '{suggestion}'?"
+        elif exc_type and issubclass(exc_type, (NameError, AttributeError)) and \
+                getattr(exc_value, "name", None) is not None:
+            wrong_name = getattr(exc_value, "name", None)
+            suggestion = _compute_suggestion_error(exc_value, exc_traceback, wrong_name)
+            if suggestion:
+                self._str += f". Did you mean: '{suggestion}'?"
+            if issubclass(exc_type, NameError):
+                wrong_name = getattr(exc_value, "name", None)
+                if wrong_name is not None and wrong_name in sys.stdlib_module_names:
+                    if suggestion:
+                        self._str += f" Or did you forget to import '{wrong_name}'?"
+                    else:
+                        self._str += f". Did you forget to import '{wrong_name}'?"
         if lookup_lines:
             self._load_lines()
         self.__suppress_context__ = \
@@ -528,7 +1116,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
             queue = [(self, exc_value)]
             while queue:
                 te, e = queue.pop()
-                if (e and e.__cause__ is not None
+                if (e is not None and e.__cause__ is not None
                     and id(e.__cause__) not in _seen):
                     cause = TracebackException(
                         type(e.__cause__),
@@ -537,6 +1125,8 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                         limit=limit,
                         lookup_lines=lookup_lines,
                         capture_locals=capture_locals,
+                        max_group_width=max_group_width,
+                        max_group_depth=max_group_depth,
                         _seen=_seen)
                 else:
                     cause = None
@@ -547,7 +1137,7 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                                     not e.__suppress_context__)
                 else:
                     need_context = True
-                if (e and e.__context__ is not None
+                if (e is not None and e.__context__ is not None
                     and need_context and id(e.__context__) not in _seen):
                     context = TracebackException(
                         type(e.__context__),
@@ -556,21 +1146,62 @@ def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
                         limit=limit,
                         lookup_lines=lookup_lines,
                         capture_locals=capture_locals,
+                        max_group_width=max_group_width,
+                        max_group_depth=max_group_depth,
                         _seen=_seen)
                 else:
                     context = None
+
+                if e is not None and isinstance(e, BaseExceptionGroup):
+                    exceptions = []
+                    for exc in e.exceptions:
+                        texc = TracebackException(
+                            type(exc),
+                            exc,
+                            exc.__traceback__,
+                            limit=limit,
+                            lookup_lines=lookup_lines,
+                            capture_locals=capture_locals,
+                            max_group_width=max_group_width,
+                            max_group_depth=max_group_depth,
+                            _seen=_seen)
+                        exceptions.append(texc)
+                else:
+                    exceptions = None
+
                 te.__cause__ = cause
                 te.__context__ = context
+                te.exceptions = exceptions
                 if cause:
                     queue.append((te.__cause__, e.__cause__))
                 if context:
                     queue.append((te.__context__, e.__context__))
+                if exceptions:
+                    queue.extend(zip(te.exceptions, e.exceptions))
 
     @classmethod
     def from_exception(cls, exc, *args, **kwargs):
         """Create a TracebackException from an exception."""
         return cls(type(exc), exc, exc.__traceback__, *args, **kwargs)
 
+    @property
+    def exc_type(self):
+        warnings.warn('Deprecated in 3.13. Use exc_type_str instead.',
+                      DeprecationWarning, stacklevel=2)
+        return self._exc_type
+
+    @property
+    def exc_type_str(self):
+        if not self._have_exc_type:
+            return None
+        stype = self.exc_type_qualname
+        smod = self.exc_type_module
+        if smod not in ("__main__", "builtins"):
+            if not isinstance(smod, str):
+                smod = "<unknown>"
+            stype = smod + '.' + stype
+        return stype
+
     def _load_lines(self):
         """Private API. force all lines in the stack to be loaded."""
         for frame in self.stack:
@@ -584,72 +1215,152 @@ def __eq__(self, other):
     def __str__(self):
         return self._str
 
-    def format_exception_only(self):
+    def format_exception_only(self, *, show_group=False, _depth=0, **kwargs):
         """Format the exception part of the traceback.
 
         The return value is a generator of strings, each ending in a newline.
 
-        Normally, the generator emits a single string; however, for
-        SyntaxError exceptions, it emits several lines that (when
-        printed) display detailed information about where the syntax
-        error occurred.
-
-        The message indicating which exception occurred is always the last
-        string in the output.
+        Generator yields the exception message.
+        For :exc:`SyntaxError` exceptions, it
+        also yields (before the exception message)
+        several lines that (when printed)
+        display detailed information about where the syntax error occurred.
+        Following the message, generator also yields
+        all the exception's ``__notes__``.
+
+        When *show_group* is ``True``, and the exception is an instance of
+        :exc:`BaseExceptionGroup`, the nested exceptions are included as
+        well, recursively, with indentation relative to their nesting depth.
         """
-        if self.exc_type is None:
-            yield _format_final_exc_line(None, self._str)
-            return
+        colorize = kwargs.get("colorize", False)
 
-        stype = self.exc_type.__qualname__
-        smod = self.exc_type.__module__
-        if smod not in ("__main__", "builtins"):
-            if not isinstance(smod, str):
-                smod = "<unknown>"
-            stype = smod + '.' + stype
+        indent = 3 * _depth * ' '
+        if not self._have_exc_type:
+            yield indent + _format_final_exc_line(None, self._str, colorize=colorize)
+            return
 
-        if not issubclass(self.exc_type, SyntaxError):
-            yield _format_final_exc_line(stype, self._str)
+        stype = self.exc_type_str
+        if not self._is_syntax_error:
+            if _depth > 0:
+                # Nested exceptions needs correct handling of multiline messages.
+                formatted = _format_final_exc_line(
+                    stype, self._str, insert_final_newline=False, colorize=colorize
+                ).split('\n')
+                yield from [
+                    indent + l + '\n'
+                    for l in formatted
+                ]
+            else:
+                yield _format_final_exc_line(stype, self._str, colorize=colorize)
         else:
-            yield from self._format_syntax_error(stype)
-
-    def _format_syntax_error(self, stype):
+            yield from [indent + l for l in self._format_syntax_error(stype, colorize=colorize)]
+
+        if (
+            isinstance(self.__notes__, collections.abc.Sequence)
+            and not isinstance(self.__notes__, (str, bytes))
+        ):
+            for note in self.__notes__:
+                note = _safe_string(note, 'note')
+                yield from [indent + l + '\n' for l in note.split('\n')]
+        elif self.__notes__ is not None:
+            yield indent + "{}\n".format(_safe_string(self.__notes__, '__notes__', func=repr))
+
+        if self.exceptions and show_group:
+            for ex in self.exceptions:
+                yield from ex.format_exception_only(show_group=show_group, _depth=_depth+1, colorize=colorize)
+
+    def _format_syntax_error(self, stype, **kwargs):
         """Format SyntaxError exceptions (internal helper)."""
         # Show exactly where the problem was found.
+        colorize = kwargs.get("colorize", False)
         filename_suffix = ''
         if self.lineno is not None:
-            yield '  File "{}", line {}\n'.format(
-                self.filename or "<string>", self.lineno)
+            if colorize:
+                yield '  File {}"{}"{}, line {}{}{}\n'.format(
+                    ANSIColors.MAGENTA,
+                    self.filename or "<string>",
+                    ANSIColors.RESET,
+                    ANSIColors.MAGENTA,
+                    self.lineno,
+                    ANSIColors.RESET,
+                    )
+            else:
+                yield '  File "{}", line {}\n'.format(
+                    self.filename or "<string>", self.lineno)
         elif self.filename is not None:
             filename_suffix = ' ({})'.format(self.filename)
 
         text = self.text
-        if text is not None:
+        if isinstance(text, str):
             # text  = "   foo\n"
             # rtext = "   foo"
             # ltext =    "foo"
             rtext = text.rstrip('\n')
             ltext = rtext.lstrip(' \n\f')
             spaces = len(rtext) - len(ltext)
-            yield '    {}\n'.format(ltext)
-
-            if self.offset is not None:
+            if self.offset is None:
+                yield '    {}\n'.format(ltext)
+            elif isinstance(self.offset, int):
                 offset = self.offset
-                end_offset = self.end_offset if self.end_offset not in {None, 0} else offset
-                if offset == end_offset or end_offset == -1:
+                if self.lineno == self.end_lineno:
+                    end_offset = (
+                        self.end_offset
+                        if (
+                            isinstance(self.end_offset, int)
+                            and self.end_offset != 0
+                        )
+                        else offset
+                    )
+                else:
+                    end_offset = len(rtext) + 1
+
+                if self.text and offset > len(self.text):
+                    offset = len(rtext) + 1
+                if self.text and end_offset > len(self.text):
+                    end_offset = len(rtext) + 1
+                if offset >= end_offset or end_offset < 0:
                     end_offset = offset + 1
 
                 # Convert 1-based column offset to 0-based index into stripped text
                 colno = offset - 1 - spaces
                 end_colno = end_offset - 1 - spaces
+                caretspace = ' '
                 if colno >= 0:
                     # non-space whitespace (likes tabs) must be kept for alignment
                     caretspace = ((c if c.isspace() else ' ') for c in ltext[:colno])
-                    yield '    {}{}'.format("".join(caretspace), ('^' * (end_colno - colno) + "\n"))
+                    start_color = end_color = ""
+                    if colorize:
+                        # colorize from colno to end_colno
+                        ltext = (
+                            ltext[:colno] +
+                            ANSIColors.BOLD_RED + ltext[colno:end_colno] + ANSIColors.RESET +
+                            ltext[end_colno:]
+                        )
+                        start_color = ANSIColors.BOLD_RED
+                        end_color = ANSIColors.RESET
+                    yield '    {}\n'.format(ltext)
+                    yield '    {}{}{}{}\n'.format(
+                        "".join(caretspace),
+                        start_color,
+                        ('^' * (end_colno - colno)),
+                        end_color,
+                    )
+                else:
+                    yield '    {}\n'.format(ltext)
         msg = self.msg or "<no detail available>"
-        yield "{}: {}{}\n".format(stype, msg, filename_suffix)
+        if colorize:
+            yield "{}{}{}: {}{}{}{}\n".format(
+                ANSIColors.BOLD_MAGENTA,
+                stype,
+                ANSIColors.RESET,
+                ANSIColors.MAGENTA,
+                msg,
+                ANSIColors.RESET,
+                filename_suffix)
+        else:
+            yield "{}: {}{}\n".format(stype, msg, filename_suffix)
 
-    def format(self, *, chain=True):
+    def format(self, *, chain=True, _ctx=None, **kwargs):
         """Format the exception.
 
         If chain is not *True*, *__cause__* and *__context__* will not be formatted.
@@ -661,11 +1372,14 @@ def format(self, *, chain=True):
         The message indicating which exception occurred is always the last
         string in the output.
         """
+        colorize = kwargs.get("colorize", False)
+        if _ctx is None:
+            _ctx = _ExceptionPrintContext()
 
         output = []
         exc = self
-        while exc:
-            if chain:
+        if chain:
+            while exc:
                 if exc.__cause__ is not None:
                     chained_msg = _cause_message
                     chained_exc = exc.__cause__
@@ -679,14 +1393,246 @@ def format(self, *, chain=True):
 
                 output.append((chained_msg, exc))
                 exc = chained_exc
-            else:
-                output.append((None, exc))
-                exc = None
+        else:
+            output.append((None, exc))
 
         for msg, exc in reversed(output):
             if msg is not None:
-                yield msg
-            if exc.stack:
-                yield 'Traceback (most recent call last):\n'
-                yield from exc.stack.format()
-            yield from exc.format_exception_only()
+                yield from _ctx.emit(msg)
+            if exc.exceptions is None:
+                if exc.stack:
+                    yield from _ctx.emit('Traceback (most recent call last):\n')
+                    yield from _ctx.emit(exc.stack.format(colorize=colorize))
+                yield from _ctx.emit(exc.format_exception_only(colorize=colorize))
+            elif _ctx.exception_group_depth > self.max_group_depth:
+                # exception group, but depth exceeds limit
+                yield from _ctx.emit(
+                    f"... (max_group_depth is {self.max_group_depth})\n")
+            else:
+                # format exception group
+                is_toplevel = (_ctx.exception_group_depth == 0)
+                if is_toplevel:
+                    _ctx.exception_group_depth += 1
+
+                if exc.stack:
+                    yield from _ctx.emit(
+                        'Exception Group Traceback (most recent call last):\n',
+                        margin_char = '+' if is_toplevel else None)
+                    yield from _ctx.emit(exc.stack.format(colorize=colorize))
+
+                yield from _ctx.emit(exc.format_exception_only(colorize=colorize))
+                num_excs = len(exc.exceptions)
+                if num_excs <= self.max_group_width:
+                    n = num_excs
+                else:
+                    n = self.max_group_width + 1
+                _ctx.need_close = False
+                for i in range(n):
+                    last_exc = (i == n-1)
+                    if last_exc:
+                        # The closing frame may be added by a recursive call
+                        _ctx.need_close = True
+
+                    if self.max_group_width is not None:
+                        truncated = (i >= self.max_group_width)
+                    else:
+                        truncated = False
+                    title = f'{i+1}' if not truncated else '...'
+                    yield (_ctx.indent() +
+                           ('+-' if i==0 else '  ') +
+                           f'+---------------- {title} ----------------\n')
+                    _ctx.exception_group_depth += 1
+                    if not truncated:
+                        yield from exc.exceptions[i].format(chain=chain, _ctx=_ctx, colorize=colorize)
+                    else:
+                        remaining = num_excs - self.max_group_width
+                        plural = 's' if remaining > 1 else ''
+                        yield from _ctx.emit(
+                            f"and {remaining} more exception{plural}\n")
+
+                    if last_exc and _ctx.need_close:
+                        yield (_ctx.indent() +
+                               "+------------------------------------\n")
+                        _ctx.need_close = False
+                    _ctx.exception_group_depth -= 1
+
+                if is_toplevel:
+                    assert _ctx.exception_group_depth == 1
+                    _ctx.exception_group_depth = 0
+
+
+    def print(self, *, file=None, chain=True, **kwargs):
+        """Print the result of self.format(chain=chain) to 'file'."""
+        colorize = kwargs.get("colorize", False)
+        if file is None:
+            file = sys.stderr
+        for line in self.format(chain=chain, colorize=colorize):
+            print(line, file=file, end="")
+
+
+_MAX_CANDIDATE_ITEMS = 750
+_MAX_STRING_SIZE = 40
+_MOVE_COST = 2
+_CASE_COST = 1
+
+
+def _substitution_cost(ch_a, ch_b):
+    if ch_a == ch_b:
+        return 0
+    if ch_a.lower() == ch_b.lower():
+        return _CASE_COST
+    return _MOVE_COST
+
+
+def _compute_suggestion_error(exc_value, tb, wrong_name):
+    if wrong_name is None or not isinstance(wrong_name, str):
+        return None
+    if isinstance(exc_value, AttributeError):
+        obj = exc_value.obj
+        try:
+            try:
+                d = dir(obj)
+            except TypeError:  # Attributes are unsortable, e.g. int and str
+                d = list(obj.__class__.__dict__.keys()) + list(obj.__dict__.keys())
+            d = sorted([x for x in d if isinstance(x, str)])
+            hide_underscored = (wrong_name[:1] != '_')
+            if hide_underscored and tb is not None:
+                while tb.tb_next is not None:
+                    tb = tb.tb_next
+                frame = tb.tb_frame
+                if 'self' in frame.f_locals and frame.f_locals['self'] is obj:
+                    hide_underscored = False
+            if hide_underscored:
+                d = [x for x in d if x[:1] != '_']
+        except Exception:
+            return None
+    elif isinstance(exc_value, ImportError):
+        try:
+            mod = __import__(exc_value.name)
+            try:
+                d = dir(mod)
+            except TypeError:  # Attributes are unsortable, e.g. int and str
+                d = list(mod.__dict__.keys())
+            d = sorted([x for x in d if isinstance(x, str)])
+            if wrong_name[:1] != '_':
+                d = [x for x in d if x[:1] != '_']
+        except Exception:
+            return None
+    else:
+        assert isinstance(exc_value, NameError)
+        # find most recent frame
+        if tb is None:
+            return None
+        while tb.tb_next is not None:
+            tb = tb.tb_next
+        frame = tb.tb_frame
+        d = (
+            list(frame.f_locals)
+            + list(frame.f_globals)
+            + list(frame.f_builtins)
+        )
+        d = [x for x in d if isinstance(x, str)]
+
+        # Check first if we are in a method and the instance
+        # has the wrong name as attribute
+        if 'self' in frame.f_locals:
+            self = frame.f_locals['self']
+            try:
+                has_wrong_name = hasattr(self, wrong_name)
+            except Exception:
+                has_wrong_name = False
+            if has_wrong_name:
+                return f"self.{wrong_name}"
+
+    try:
+        import _suggestions
+    except ImportError:
+        pass
+    else:
+        return _suggestions._generate_suggestions(d, wrong_name)
+
+    # Compute closest match
+
+    if len(d) > _MAX_CANDIDATE_ITEMS:
+        return None
+    wrong_name_len = len(wrong_name)
+    if wrong_name_len > _MAX_STRING_SIZE:
+        return None
+    best_distance = wrong_name_len
+    suggestion = None
+    for possible_name in d:
+        if possible_name == wrong_name:
+            # A missing attribute is "found". Don't suggest it (see GH-88821).
+            continue
+        # No more than 1/3 of the involved characters should need changed.
+        max_distance = (len(possible_name) + wrong_name_len + 3) * _MOVE_COST // 6
+        # Don't take matches we've already beaten.
+        max_distance = min(max_distance, best_distance - 1)
+        current_distance = _levenshtein_distance(wrong_name, possible_name, max_distance)
+        if current_distance > max_distance:
+            continue
+        if not suggestion or current_distance < best_distance:
+            suggestion = possible_name
+            best_distance = current_distance
+    return suggestion
+
+
+def _levenshtein_distance(a, b, max_cost):
+    # A Python implementation of Python/suggestions.c:levenshtein_distance.
+
+    # Both strings are the same
+    if a == b:
+        return 0
+
+    # Trim away common affixes
+    pre = 0
+    while a[pre:] and b[pre:] and a[pre] == b[pre]:
+        pre += 1
+    a = a[pre:]
+    b = b[pre:]
+    post = 0
+    while a[:post or None] and b[:post or None] and a[post-1] == b[post-1]:
+        post -= 1
+    a = a[:post or None]
+    b = b[:post or None]
+    if not a or not b:
+        return _MOVE_COST * (len(a) + len(b))
+    if len(a) > _MAX_STRING_SIZE or len(b) > _MAX_STRING_SIZE:
+        return max_cost + 1
+
+    # Prefer shorter buffer
+    if len(b) < len(a):
+        a, b = b, a
+
+    # Quick fail when a match is impossible
+    if (len(b) - len(a)) * _MOVE_COST > max_cost:
+        return max_cost + 1
+
+    # Instead of producing the whole traditional len(a)-by-len(b)
+    # matrix, we can update just one row in place.
+    # Initialize the buffer row
+    row = list(range(_MOVE_COST, _MOVE_COST * (len(a) + 1), _MOVE_COST))
+
+    result = 0
+    for bindex in range(len(b)):
+        bchar = b[bindex]
+        distance = result = bindex * _MOVE_COST
+        minimum = sys.maxsize
+        for index in range(len(a)):
+            # 1) Previous distance in this row is cost(b[:b_index], a[:index])
+            substitute = distance + _substitution_cost(bchar, a[index])
+            # 2) cost(b[:b_index], a[:index+1]) from previous row
+            distance = row[index]
+            # 3) existing result is cost(b[:b_index+1], a[index])
+
+            insert_delete = min(result, distance) + _MOVE_COST
+            result = min(insert_delete, substitute)
+
+            # cost(b[:b_index+1], a[:index+1])
+            row[index] = result
+            if result < minimum:
+                minimum = result
+        if minimum > max_cost:
+            # Everything in this row is too big, so bail early.
+            return max_cost + 1
+    return result
diff --git a/Lib/tty.py b/Lib/tty.py
index a72eb67554..5a49e04004 100644
--- a/Lib/tty.py
+++ b/Lib/tty.py
@@ -4,9 +4,9 @@
 
 from termios import *
 
-__all__ = ["setraw", "setcbreak"]
+__all__ = ["cfmakeraw", "cfmakecbreak", "setraw", "setcbreak"]
 
-# Indexes for termios list.
+# Indices for termios list.
 IFLAG = 0
 OFLAG = 1
 CFLAG = 2
@@ -15,22 +15,59 @@
 OSPEED = 5
 CC = 6
 
-def setraw(fd, when=TCSAFLUSH):
-    """Put terminal into a raw mode."""
-    mode = tcgetattr(fd)
-    mode[IFLAG] = mode[IFLAG] & ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON)
-    mode[OFLAG] = mode[OFLAG] & ~(OPOST)
-    mode[CFLAG] = mode[CFLAG] & ~(CSIZE | PARENB)
-    mode[CFLAG] = mode[CFLAG] | CS8
-    mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON | IEXTEN | ISIG)
+def cfmakeraw(mode):
+    """Make termios mode raw."""
+    # Clear all POSIX.1-2017 input mode flags.
+    # See chapter 11 "General Terminal Interface"
+    # of POSIX.1-2017 Base Definitions.
+    mode[IFLAG] &= ~(IGNBRK | BRKINT | IGNPAR | PARMRK | INPCK | ISTRIP |
+                     INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF)
+
+    # Do not post-process output.
+    mode[OFLAG] &= ~OPOST
+
+    # Disable parity generation and detection; clear character size mask;
+    # let character size be 8 bits.
+    mode[CFLAG] &= ~(PARENB | CSIZE)
+    mode[CFLAG] |= CS8
+
+    # Clear all POSIX.1-2017 local mode flags.
+    mode[LFLAG] &= ~(ECHO | ECHOE | ECHOK | ECHONL | ICANON |
+                     IEXTEN | ISIG | NOFLSH | TOSTOP)
+
+    # POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+    # Case B: MIN>0, TIME=0
+    # A pending read shall block until MIN (here 1) bytes are received,
+    # or a signal is received.
+    mode[CC] = list(mode[CC])
     mode[CC][VMIN] = 1
     mode[CC][VTIME] = 0
-    tcsetattr(fd, when, mode)
 
-def setcbreak(fd, when=TCSAFLUSH):
-    """Put terminal into a cbreak mode."""
-    mode = tcgetattr(fd)
-    mode[LFLAG] = mode[LFLAG] & ~(ECHO | ICANON)
+def cfmakecbreak(mode):
+    """Make termios mode cbreak."""
+    # Do not echo characters; disable canonical input.
+    mode[LFLAG] &= ~(ECHO | ICANON)
+
+    # POSIX.1-2017, 11.1.7 Non-Canonical Mode Input Processing,
+    # Case B: MIN>0, TIME=0
+    # A pending read shall block until MIN (here 1) bytes are received,
+    # or a signal is received.
+    mode[CC] = list(mode[CC])
     mode[CC][VMIN] = 1
     mode[CC][VTIME] = 0
-    tcsetattr(fd, when, mode)
+
+def setraw(fd, when=TCSAFLUSH):
+    """Put terminal into raw mode."""
+    mode = tcgetattr(fd)
+    new = list(mode)
+    cfmakeraw(new)
+    tcsetattr(fd, when, new)
+    return mode
+
+def setcbreak(fd, when=TCSAFLUSH):
+    """Put terminal into cbreak mode."""
+    mode = tcgetattr(fd)
+    new = list(mode)
+    cfmakecbreak(new)
+    tcsetattr(fd, when, new)
+    return mode
diff --git a/Lib/types.py b/Lib/types.py
index 4dab6ddce0..b036a85068 100644
--- a/Lib/types.py
+++ b/Lib/types.py
@@ -1,6 +1,7 @@
 """
 Define names for built-in types that aren't directly accessible as a builtin.
 """
+
 import sys
 
 # Iterators in Python aren't a matter of type but of protocol.  A large
@@ -52,17 +53,14 @@ def _m(self): pass
 
 try:
     raise TypeError
-except TypeError:
-    tb = sys.exc_info()[2]
-    TracebackType = type(tb)
-    FrameType = type(tb.tb_frame)
-    tb = None; del tb
+except TypeError as exc:
+    TracebackType = type(exc.__traceback__)
+    FrameType = type(exc.__traceback__.tb_frame)
 
-# For Jython, the following two types are identical
 GetSetDescriptorType = type(FunctionType.__code__)
 MemberDescriptorType = type(FunctionType.__globals__)
 
-del sys, _f, _g, _C, _c, _ag  # Not for export
+del sys, _f, _g, _C, _c, _ag, _cell_factory  # Not for export
 
 
 # Provide a PEP 3115 compliant mechanism for class creation
@@ -82,7 +80,7 @@ def resolve_bases(bases):
     updated = False
     shift = 0
     for i, base in enumerate(bases):
-        if isinstance(base, type) and not isinstance(base, GenericAlias):
+        if isinstance(base, type):
             continue
         if not hasattr(base, "__mro_entries__"):
             continue
@@ -146,6 +144,35 @@ def _calculate_meta(meta, bases):
                         "of the metaclasses of all its bases")
     return winner
 
+
+def get_original_bases(cls, /):
+    """Return the class's "original" bases prior to modification by `__mro_entries__`.
+
+    Examples::
+
+        from typing import TypeVar, Generic, NamedTuple, TypedDict
+
+        T = TypeVar("T")
+        class Foo(Generic[T]): ...
+        class Bar(Foo[int], float): ...
+        class Baz(list[str]): ...
+        Eggs = NamedTuple("Eggs", [("a", int), ("b", str)])
+        Spam = TypedDict("Spam", {"a": int, "b": str})
+
+        assert get_original_bases(Bar) == (Foo[int], float)
+        assert get_original_bases(Baz) == (list[str],)
+        assert get_original_bases(Eggs) == (NamedTuple,)
+        assert get_original_bases(Spam) == (TypedDict,)
+        assert get_original_bases(int) == (object,)
+    """
+    try:
+        return cls.__dict__.get("__orig_bases__", cls.__bases__)
+    except AttributeError:
+        raise TypeError(
+            f"Expected an instance of type, not {type(cls).__name__!r}"
+        ) from None
+
+
 class DynamicClassAttribute:
     """Route attribute access on a class to __getattr__.
 
@@ -158,7 +185,7 @@ class DynamicClassAttribute:
     attributes on the class with the same name.  (Enum used this between Python
     versions 3.4 - 3.9 .)
 
-    Subclass from this to use a different method of accessing virtual atributes
+    Subclass from this to use a different method of accessing virtual attributes
     and still be treated properly by the inspect module. (Enum uses this since
     Python 3.10 .)
 
@@ -305,4 +332,11 @@ def wrapped(*args, **kwargs):
 NoneType = type(None)
 NotImplementedType = type(NotImplemented)
 
+def __getattr__(name):
+    if name == 'CapsuleType':
+        import _socket
+        return type(_socket.CAPI)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 __all__ = [n for n in globals() if n[:1] != '_']
+__all__ += ['CapsuleType']
diff --git a/Lib/unittest/__init__.py b/Lib/unittest/__init__.py
index 7ab3f5e87b..6878c2a8f5 100644
--- a/Lib/unittest/__init__.py
+++ b/Lib/unittest/__init__.py
@@ -51,10 +51,6 @@ def testMultiply(self):
            'registerResult', 'removeResult', 'removeHandler',
            'addModuleCleanup', 'doModuleCleanups', 'enterModuleContext']
 
-# Expose obsolete functions for backwards compatibility
-# bpo-5846: Deprecated in Python 3.11, scheduled for removal in Python 3.13.
-__all__.extend(['getTestCaseNames', 'makeSuite', 'findTestCases'])
-
 __unittest = True
 
 from .result import TestResult
@@ -67,20 +63,6 @@ def testMultiply(self):
 from .runner import TextTestRunner, TextTestResult
 from .signals import installHandler, registerResult, removeResult, removeHandler
 # IsolatedAsyncioTestCase will be imported lazily.
-from .loader import makeSuite, getTestCaseNames, findTestCases
-
-# deprecated
-_TextTestResult = TextTestResult
-
-
-# There are no tests here, so don't try to run anything discovered from
-# introspecting the symbols (e.g. FunctionTestCase). Instead, all our
-# tests come from within unittest.test.
-def load_tests(loader, tests, pattern):
-    import os.path
-    # top level directory cached on loader instance
-    this_dir = os.path.dirname(__file__)
-    return loader.discover(start_dir=this_dir, pattern=pattern)
 
 
 # Lazy import of IsolatedAsyncioTestCase from .async_case
@@ -98,6 +80,7 @@ def __getattr__(name):
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 
+
 # XXX: RUSTPYTHON
 # This is very useful to reduce platform difference boilerplates in tests.
 def expectedFailureIf(condition, reason):
@@ -111,4 +94,4 @@ def expectedFailureIf(condition, reason):
 # Even more useful because most of them are windows only.
 def expectedFailureIfWindows(reason):
     import sys
-    return expectedFailureIf(sys.platform == 'win32', reason)
+    return expectedFailureIf(sys.platform == 'win32', reason)
\ No newline at end of file
diff --git a/Lib/unittest/async_case.py b/Lib/unittest/async_case.py
index bd2a471156..e761ba7e53 100644
--- a/Lib/unittest/async_case.py
+++ b/Lib/unittest/async_case.py
@@ -5,6 +5,7 @@
 
 from .case import TestCase
 
+__unittest = True
 
 class IsolatedAsyncioTestCase(TestCase):
     # Names intentionally have a long prefix
@@ -25,12 +26,15 @@ class IsolatedAsyncioTestCase(TestCase):
     # them inside the same task.
 
     # Note: the test case modifies event loop policy if the policy was not instantiated
-    # yet.
+    # yet, unless loop_factory=asyncio.EventLoop is set.
     # asyncio.get_event_loop_policy() creates a default policy on demand but never
     # returns None
     # I believe this is not an issue in user level tests but python itself for testing
     # should reset a policy in every test module
     # by calling asyncio.set_event_loop_policy(None) in tearDownModule()
+    # or set loop_factory=asyncio.EventLoop
+
+    loop_factory = None
 
     def __init__(self, methodName='runTest'):
         super().__init__(methodName)
@@ -118,7 +122,7 @@ def _callMaybeAsync(self, func, /, *args, **kwargs):
 
     def _setupAsyncioRunner(self):
         assert self._asyncioRunner is None, 'asyncio runner is already initialized'
-        runner = asyncio.Runner(debug=True)
+        runner = asyncio.Runner(debug=True, loop_factory=self.loop_factory)
         self._asyncioRunner = runner
 
     def _tearDownAsyncioRunner(self):
diff --git a/Lib/unittest/case.py b/Lib/unittest/case.py
index c4aa2d7721..36daa61fa3 100644
--- a/Lib/unittest/case.py
+++ b/Lib/unittest/case.py
@@ -9,6 +9,7 @@
 import collections
 import contextlib
 import traceback
+import time
 import types
 
 from . import result
@@ -331,6 +332,23 @@ def __exit__(self, exc_type, exc_value, tb):
             self._raiseFailure("{} not triggered".format(exc_name))
 
 
+class _AssertNotWarnsContext(_AssertWarnsContext):
+
+    def __exit__(self, exc_type, exc_value, tb):
+        self.warnings_manager.__exit__(exc_type, exc_value, tb)
+        if exc_type is not None:
+            # let unexpected exceptions pass through
+            return
+        try:
+            exc_name = self.expected.__name__
+        except AttributeError:
+            exc_name = str(self.expected)
+        for m in self.warnings:
+            w = m.message
+            if isinstance(w, self.expected):
+                self._raiseFailure(f"{exc_name} triggered")
+
+
 class _OrderedChainMap(collections.ChainMap):
     def __iter__(self):
         seen = set()
@@ -572,6 +590,15 @@ def _addUnexpectedSuccess(self, result):
         else:
             addUnexpectedSuccess(self)
 
+    def _addDuration(self, result, elapsed):
+        try:
+            addDuration = result.addDuration
+        except AttributeError:
+            warnings.warn("TestResult has no addDuration method",
+                          RuntimeWarning)
+        else:
+            addDuration(self, elapsed)
+
     def _callSetUp(self):
         self.setUp()
 
@@ -612,6 +639,7 @@ def run(self, result=None):
                 getattr(testMethod, "__unittest_expecting_failure__", False)
             )
             outcome = _Outcome(result)
+            start_time = time.perf_counter()
             try:
                 self._outcome = outcome
 
@@ -625,6 +653,7 @@ def run(self, result=None):
                     with outcome.testPartExecutor(self):
                         self._callTearDown()
                 self.doCleanups()
+                self._addDuration(result, (time.perf_counter() - start_time))
 
                 if outcome.success:
                     if expecting_failure:
@@ -799,6 +828,11 @@ def assertWarns(self, expected_warning, *args, **kwargs):
         context = _AssertWarnsContext(expected_warning, self)
         return context.handle('assertWarns', args, kwargs)
 
+    def _assertNotWarns(self, expected_warning, *args, **kwargs):
+        """The opposite of assertWarns. Private due to low demand."""
+        context = _AssertNotWarnsContext(expected_warning, self)
+        return context.handle('_assertNotWarns', args, kwargs)
+
     def assertLogs(self, logger=None, level=None):
         """Fail unless a log message of level *level* or higher is emitted
         on *logger_name* or its children.  If omitted, *level* defaults to
@@ -1171,35 +1205,6 @@ def assertDictEqual(self, d1, d2, msg=None):
             standardMsg = self._truncateMessage(standardMsg, diff)
             self.fail(self._formatMessage(msg, standardMsg))
 
-    def assertDictContainsSubset(self, subset, dictionary, msg=None):
-        """Checks whether dictionary is a superset of subset."""
-        warnings.warn('assertDictContainsSubset is deprecated',
-                      DeprecationWarning)
-        missing = []
-        mismatched = []
-        for key, value in subset.items():
-            if key not in dictionary:
-                missing.append(key)
-            elif value != dictionary[key]:
-                mismatched.append('%s, expected: %s, actual: %s' %
-                                  (safe_repr(key), safe_repr(value),
-                                   safe_repr(dictionary[key])))
-
-        if not (missing or mismatched):
-            return
-
-        standardMsg = ''
-        if missing:
-            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in
-                                                    missing)
-        if mismatched:
-            if standardMsg:
-                standardMsg += '; '
-            standardMsg += 'Mismatched values: %s' % ','.join(mismatched)
-
-        self.fail(self._formatMessage(msg, standardMsg))
-
-
     def assertCountEqual(self, first, second, msg=None):
         """Asserts that two iterables have the same elements, the same number of
         times, without regard to order.
@@ -1234,19 +1239,34 @@ def assertCountEqual(self, first, second, msg=None):
 
     def assertMultiLineEqual(self, first, second, msg=None):
         """Assert that two multi-line strings are equal."""
-        self.assertIsInstance(first, str, 'First argument is not a string')
-        self.assertIsInstance(second, str, 'Second argument is not a string')
+        self.assertIsInstance(first, str, "First argument is not a string")
+        self.assertIsInstance(second, str, "Second argument is not a string")
 
         if first != second:
-            # don't use difflib if the strings are too long
+            # Don't use difflib if the strings are too long
             if (len(first) > self._diffThreshold or
                 len(second) > self._diffThreshold):
                 self._baseAssertEqual(first, second, msg)
-            firstlines = first.splitlines(keepends=True)
-            secondlines = second.splitlines(keepends=True)
-            if len(firstlines) == 1 and first.strip('\r\n') == first:
-                firstlines = [first + '\n']
-                secondlines = [second + '\n']
+
+            # Append \n to both strings if either is missing the \n.
+            # This allows the final ndiff to show the \n difference. The
+            # exception here is if the string is empty, in which case no
+            # \n should be added
+            first_presplit = first
+            second_presplit = second
+            if first and second:
+                if first[-1] != '\n' or second[-1] != '\n':
+                    first_presplit += '\n'
+                    second_presplit += '\n'
+            elif second and second[-1] != '\n':
+                second_presplit += '\n'
+            elif first and first[-1] != '\n':
+                first_presplit += '\n'
+
+            firstlines = first_presplit.splitlines(keepends=True)
+            secondlines = second_presplit.splitlines(keepends=True)
+
+            # Generate the message and diff, then raise the exception
             standardMsg = '%s != %s' % _common_shorten_repr(first, second)
             diff = '\n' + ''.join(difflib.ndiff(firstlines, secondlines))
             standardMsg = self._truncateMessage(standardMsg, diff)
@@ -1363,27 +1383,6 @@ def assertNotRegex(self, text, unexpected_regex, msg=None):
             raise self.failureException(msg)
 
 
-    def _deprecate(original_func):
-        def deprecated_func(*args, **kwargs):
-            warnings.warn(
-                'Please use {0} instead.'.format(original_func.__name__),
-                DeprecationWarning, 2)
-            return original_func(*args, **kwargs)
-        return deprecated_func
-
-    # see #9424
-    failUnlessEqual = assertEquals = _deprecate(assertEqual)
-    failIfEqual = assertNotEquals = _deprecate(assertNotEqual)
-    failUnlessAlmostEqual = assertAlmostEquals = _deprecate(assertAlmostEqual)
-    failIfAlmostEqual = assertNotAlmostEquals = _deprecate(assertNotAlmostEqual)
-    failUnless = assert_ = _deprecate(assertTrue)
-    failUnlessRaises = _deprecate(assertRaises)
-    failIf = _deprecate(assertFalse)
-    assertRaisesRegexp = _deprecate(assertRaisesRegex)
-    assertRegexpMatches = _deprecate(assertRegex)
-    assertNotRegexpMatches = _deprecate(assertNotRegex)
-
-
 
 class FunctionTestCase(TestCase):
     """A test case that wraps a test function.
diff --git a/Lib/unittest/loader.py b/Lib/unittest/loader.py
index 7e6ce2f224..22797b83a6 100644
--- a/Lib/unittest/loader.py
+++ b/Lib/unittest/loader.py
@@ -6,7 +6,6 @@
 import traceback
 import types
 import functools
-import warnings
 
 from fnmatch import fnmatch, fnmatchcase
 
@@ -57,9 +56,7 @@ def testSkipped(self):
     TestClass = type("ModuleSkipped", (case.TestCase,), attrs)
     return suiteClass((TestClass(methodname),))
 
-def _jython_aware_splitext(path):
-    if path.lower().endswith('$py.class'):
-        return path[:-9]
+def _splitext(path):
     return os.path.splitext(path)[0]
 
 
@@ -87,40 +84,26 @@ def loadTestsFromTestCase(self, testCaseClass):
             raise TypeError("Test cases should not be derived from "
                             "TestSuite. Maybe you meant to derive from "
                             "TestCase?")
-        testCaseNames = self.getTestCaseNames(testCaseClass)
-        if not testCaseNames and hasattr(testCaseClass, 'runTest'):
-            testCaseNames = ['runTest']
+        if testCaseClass in (case.TestCase, case.FunctionTestCase):
+            # We don't load any tests from base types that should not be loaded.
+            testCaseNames = []
+        else:
+            testCaseNames = self.getTestCaseNames(testCaseClass)
+            if not testCaseNames and hasattr(testCaseClass, 'runTest'):
+                testCaseNames = ['runTest']
         loaded_suite = self.suiteClass(map(testCaseClass, testCaseNames))
         return loaded_suite
 
-    # XXX After Python 3.5, remove backward compatibility hacks for
-    # use_load_tests deprecation via *args and **kws.  See issue 16662.
-    def loadTestsFromModule(self, module, *args, pattern=None, **kws):
+    def loadTestsFromModule(self, module, *, pattern=None):
         """Return a suite of all test cases contained in the given module"""
-        # This method used to take an undocumented and unofficial
-        # use_load_tests argument.  For backward compatibility, we still
-        # accept the argument (which can also be the first position) but we
-        # ignore it and issue a deprecation warning if it's present.
-        if len(args) > 0 or 'use_load_tests' in kws:
-            warnings.warn('use_load_tests is deprecated and ignored',
-                          DeprecationWarning)
-            kws.pop('use_load_tests', None)
-        if len(args) > 1:
-            # Complain about the number of arguments, but don't forget the
-            # required `module` argument.
-            complaint = len(args) + 1
-            raise TypeError('loadTestsFromModule() takes 1 positional argument but {} were given'.format(complaint))
-        if len(kws) != 0:
-            # Since the keyword arguments are unsorted (see PEP 468), just
-            # pick the alphabetically sorted first argument to complain about,
-            # if multiple were given.  At least the error message will be
-            # predictable.
-            complaint = sorted(kws)[0]
-            raise TypeError("loadTestsFromModule() got an unexpected keyword argument '{}'".format(complaint))
         tests = []
         for name in dir(module):
             obj = getattr(module, name)
-            if isinstance(obj, type) and issubclass(obj, case.TestCase):
+            if (
+                isinstance(obj, type)
+                and issubclass(obj, case.TestCase)
+                and obj not in (case.TestCase, case.FunctionTestCase)
+            ):
                 tests.append(self.loadTestsFromTestCase(obj))
 
         load_tests = getattr(module, 'load_tests', None)
@@ -189,7 +172,11 @@ def loadTestsFromName(self, name, module=None):
 
         if isinstance(obj, types.ModuleType):
             return self.loadTestsFromModule(obj)
-        elif isinstance(obj, type) and issubclass(obj, case.TestCase):
+        elif (
+            isinstance(obj, type)
+            and issubclass(obj, case.TestCase)
+            and obj not in (case.TestCase, case.FunctionTestCase)
+        ):
             return self.loadTestsFromTestCase(obj)
         elif (isinstance(obj, types.FunctionType) and
               isinstance(parent, type) and
@@ -267,6 +254,7 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
         Paths are sorted before being imported to ensure reproducible execution
         order even on filesystems with non-alphabetical ordering like ext3/4.
         """
+        original_top_level_dir = self._top_level_dir
         set_implicit_top = False
         if top_level_dir is None and self._top_level_dir is not None:
             # make top_level_dir optional if called from load_tests in a package
@@ -320,6 +308,7 @@ def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
             raise ImportError('Start directory is not importable: %r' % start_dir)
 
         tests = list(self._find_tests(start_dir, pattern))
+        self._top_level_dir = original_top_level_dir
         return self.suiteClass(tests)
 
     def _get_directory_containing_module(self, module_name):
@@ -337,7 +326,7 @@ def _get_directory_containing_module(self, module_name):
     def _get_name_from_path(self, path):
         if path == self._top_level_dir:
             return '.'
-        path = _jython_aware_splitext(os.path.normpath(path))
+        path = _splitext(os.path.normpath(path))
 
         _relpath = os.path.relpath(path, self._top_level_dir)
         assert not os.path.isabs(_relpath), "Path must be within the project"
@@ -415,13 +404,13 @@ def _find_test_path(self, full_path, pattern):
             else:
                 mod_file = os.path.abspath(
                     getattr(module, '__file__', full_path))
-                realpath = _jython_aware_splitext(
+                realpath = _splitext(
                     os.path.realpath(mod_file))
-                fullpath_noext = _jython_aware_splitext(
+                fullpath_noext = _splitext(
                     os.path.realpath(full_path))
                 if realpath.lower() != fullpath_noext.lower():
                     module_dir = os.path.dirname(realpath)
-                    mod_name = _jython_aware_splitext(
+                    mod_name = _splitext(
                         os.path.basename(full_path))
                     expected_dir = os.path.dirname(full_path)
                     msg = ("%r module incorrectly imported from %r. Expected "
@@ -462,47 +451,3 @@ def _find_test_path(self, full_path, pattern):
 
 
 defaultTestLoader = TestLoader()
-
-
-# These functions are considered obsolete for long time.
-# They will be removed in Python 3.13.
-
-def _makeLoader(prefix, sortUsing, suiteClass=None, testNamePatterns=None):
-    loader = TestLoader()
-    loader.sortTestMethodsUsing = sortUsing
-    loader.testMethodPrefix = prefix
-    loader.testNamePatterns = testNamePatterns
-    if suiteClass:
-        loader.suiteClass = suiteClass
-    return loader
-
-def getTestCaseNames(testCaseClass, prefix, sortUsing=util.three_way_cmp, testNamePatterns=None):
-    import warnings
-    warnings.warn(
-        "unittest.getTestCaseNames() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.getTestCaseNames() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, testNamePatterns=testNamePatterns).getTestCaseNames(testCaseClass)
-
-def makeSuite(testCaseClass, prefix='test', sortUsing=util.three_way_cmp,
-              suiteClass=suite.TestSuite):
-    import warnings
-    warnings.warn(
-        "unittest.makeSuite() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.loadTestsFromTestCase() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromTestCase(
-        testCaseClass)
-
-def findTestCases(module, prefix='test', sortUsing=util.three_way_cmp,
-                  suiteClass=suite.TestSuite):
-    import warnings
-    warnings.warn(
-        "unittest.findTestCases() is deprecated and will be removed in Python 3.13. "
-        "Please use unittest.TestLoader.loadTestsFromModule() instead.",
-        DeprecationWarning, stacklevel=2
-    )
-    return _makeLoader(prefix, sortUsing, suiteClass).loadTestsFromModule(\
-        module)
diff --git a/Lib/unittest/main.py b/Lib/unittest/main.py
index 046fbd3a45..a0cd8a9f7e 100644
--- a/Lib/unittest/main.py
+++ b/Lib/unittest/main.py
@@ -3,12 +3,12 @@
 import sys
 import argparse
 import os
-import warnings
 
 from . import loader, runner
 from .signals import installHandler
 
 __unittest = True
+_NO_TESTS_EXITCODE = 5
 
 MAIN_EXAMPLES = """\
 Examples:
@@ -66,7 +66,8 @@ class TestProgram(object):
     def __init__(self, module='__main__', defaultTest=None, argv=None,
                     testRunner=None, testLoader=loader.defaultTestLoader,
                     exit=True, verbosity=1, failfast=None, catchbreak=None,
-                    buffer=None, warnings=None, *, tb_locals=False):
+                    buffer=None, warnings=None, *, tb_locals=False,
+                    durations=None):
         if isinstance(module, str):
             self.module = __import__(module)
             for part in module.split('.')[1:]:
@@ -82,6 +83,7 @@ def __init__(self, module='__main__', defaultTest=None, argv=None,
         self.verbosity = verbosity
         self.buffer = buffer
         self.tb_locals = tb_locals
+        self.durations = durations
         if warnings is None and not sys.warnoptions:
             # even if DeprecationWarnings are ignored by default
             # print them anyway unless other warnings settings are
@@ -101,16 +103,6 @@ def __init__(self, module='__main__', defaultTest=None, argv=None,
         self.parseArgs(argv)
         self.runTests()
 
-    def usageExit(self, msg=None):
-        warnings.warn("TestProgram.usageExit() is deprecated and will be"
-                      " removed in Python 3.13", DeprecationWarning)
-        if msg:
-            print(msg)
-        if self._discovery_parser is None:
-            self._initArgParsers()
-        self._print_help()
-        sys.exit(2)
-
     def _print_help(self, *args, **kwargs):
         if self.module is None:
             print(self._main_parser.format_help())
@@ -178,6 +170,9 @@ def _getParentArgParser(self):
         parser.add_argument('--locals', dest='tb_locals',
                             action='store_true',
                             help='Show local variables in tracebacks')
+        parser.add_argument('--durations', dest='durations', type=int,
+                            default=None, metavar="N",
+                            help='Show the N slowest test cases (N=0 for all)')
         if self.failfast is None:
             parser.add_argument('-f', '--failfast', dest='failfast',
                                 action='store_true',
@@ -258,9 +253,10 @@ def runTests(self):
                                                  failfast=self.failfast,
                                                  buffer=self.buffer,
                                                  warnings=self.warnings,
-                                                 tb_locals=self.tb_locals)
+                                                 tb_locals=self.tb_locals,
+                                                 durations=self.durations)
                 except TypeError:
-                    # didn't accept the tb_locals argument
+                    # didn't accept the tb_locals or durations argument
                     testRunner = self.testRunner(verbosity=self.verbosity,
                                                  failfast=self.failfast,
                                                  buffer=self.buffer,
@@ -273,6 +269,12 @@ def runTests(self):
             testRunner = self.testRunner
         self.result = testRunner.run(self.test)
         if self.exit:
-            sys.exit(not self.result.wasSuccessful())
+            if not self.result.wasSuccessful():
+                sys.exit(1)
+            elif self.result.testsRun == 0 and len(self.result.skipped) == 0:
+                sys.exit(_NO_TESTS_EXITCODE)
+            else:
+                sys.exit(0)
+
 
 main = TestProgram
diff --git a/Lib/unittest/mock.py b/Lib/unittest/mock.py
index fa0bd9131a..6cec61ff35 100644
--- a/Lib/unittest/mock.py
+++ b/Lib/unittest/mock.py
@@ -14,6 +14,7 @@
     'call',
     'create_autospec',
     'AsyncMock',
+    'ThreadingMock',
     'FILTER_DIR',
     'NonCallableMock',
     'NonCallableMagicMock',
@@ -32,6 +33,7 @@
 import builtins
 import pkgutil
 from asyncio import iscoroutinefunction
+import threading
 from types import CodeType, ModuleType, MethodType
 from unittest.util import safe_repr
 from functools import wraps, partial
@@ -98,6 +100,12 @@ def _get_signature_object(func, as_instance, eat_self):
         func = func.__init__
         # Skip the `self` argument in __init__
         eat_self = True
+    elif isinstance(func, (classmethod, staticmethod)):
+        if isinstance(func, classmethod):
+            # Skip the `cls` argument of a class method
+            eat_self = True
+        # Use the original decorated method to extract the correct function signature
+        func = func.__func__
     elif not isinstance(func, FunctionTypes):
         # If we really want to model an instance of the passed type,
         # __call__ should be looked up, not __init__.
@@ -198,6 +206,28 @@ def checksig(*args, **kwargs):
     _setup_func(funcopy, mock, sig)
     return funcopy
 
+def _set_async_signature(mock, original, instance=False, is_async_mock=False):
+    # creates an async function with signature (*args, **kwargs) that delegates to a
+    # mock. It still does signature checking by calling a lambda with the same
+    # signature as the original.
+
+    skipfirst = isinstance(original, type)
+    func, sig = _get_signature_object(original, instance, skipfirst)
+    def checksig(*args, **kwargs):
+        sig.bind(*args, **kwargs)
+    _copy_func_details(func, checksig)
+
+    name = original.__name__
+    context = {'_checksig_': checksig, 'mock': mock}
+    src = """async def %s(*args, **kwargs):
+    _checksig_(*args, **kwargs)
+    return await mock(*args, **kwargs)""" % name
+    exec (src, context)
+    funcopy = context[name]
+    _setup_func(funcopy, mock, sig)
+    _setup_async_mock(funcopy)
+    return funcopy
+
 
 def _setup_func(funcopy, mock, sig):
     funcopy.mock = mock
@@ -411,15 +441,18 @@ class NonCallableMock(Base):
     # necessary.
     _lock = RLock()
 
-    def __new__(cls, /, *args, **kw):
+    def __new__(
+            cls, spec=None, wraps=None, name=None, spec_set=None,
+            parent=None, _spec_state=None, _new_name='', _new_parent=None,
+            _spec_as_instance=False, _eat_self=None, unsafe=False, **kwargs
+        ):
         # every instance has its own class
         # so we can create magic methods on the
         # class without stomping on other mocks
         bases = (cls,)
         if not issubclass(cls, AsyncMockMixin):
             # Check if spec is an async object or function
-            bound_args = _MOCK_SIG.bind_partial(cls, *args, **kw).arguments
-            spec_arg = bound_args.get('spec_set', bound_args.get('spec'))
+            spec_arg = spec_set or spec
             if spec_arg is not None and _is_async_obj(spec_arg):
                 bases = (AsyncMockMixin, cls)
         new = type(cls.__name__, bases, {'__doc__': cls.__doc__})
@@ -505,10 +538,6 @@ def _mock_add_spec(self, spec, spec_set, _spec_as_instance=False,
         _spec_signature = None
         _spec_asyncs = []
 
-        for attr in dir(spec):
-            if iscoroutinefunction(getattr(spec, attr, None)):
-                _spec_asyncs.append(attr)
-
         if spec is not None and not _is_list(spec):
             if isinstance(spec, type):
                 _spec_class = spec
@@ -518,7 +547,19 @@ def _mock_add_spec(self, spec, spec_set, _spec_as_instance=False,
                                         _spec_as_instance, _eat_self)
             _spec_signature = res and res[1]
 
-            spec = dir(spec)
+            spec_list = dir(spec)
+
+            for attr in spec_list:
+                static_attr = inspect.getattr_static(spec, attr, None)
+                unwrapped_attr = static_attr
+                try:
+                    unwrapped_attr = inspect.unwrap(unwrapped_attr)
+                except ValueError:
+                    pass
+                if iscoroutinefunction(unwrapped_attr):
+                    _spec_asyncs.append(attr)
+
+            spec = spec_list
 
         __dict__ = self.__dict__
         __dict__['_spec_class'] = _spec_class
@@ -532,7 +573,7 @@ def __get_return_value(self):
         if self._mock_delegate is not None:
             ret = self._mock_delegate.return_value
 
-        if ret is DEFAULT:
+        if ret is DEFAULT and self._mock_wraps is None:
             ret = self._get_child_mock(
                 _new_parent=self, _new_name='()'
             )
@@ -587,7 +628,9 @@ def __set_side_effect(self, value):
     side_effect = property(__get_side_effect, __set_side_effect)
 
 
-    def reset_mock(self,  visited=None,*, return_value=False, side_effect=False):
+    def reset_mock(self, visited=None, *,
+                   return_value: bool = False,
+                   side_effect: bool = False):
         "Restore the mock object to its initial state."
         if visited is None:
             visited = []
@@ -648,7 +691,7 @@ def __getattr__(self, name):
         elif _is_magic(name):
             raise AttributeError(name)
         if not self._mock_unsafe and (not self._mock_methods or name not in self._mock_methods):
-            if name.startswith(('assert', 'assret', 'asert', 'aseert', 'assrt')):
+            if name.startswith(('assert', 'assret', 'asert', 'aseert', 'assrt')) or name in _ATTRIB_DENY_LIST:
                 raise AttributeError(
                     f"{name!r} is not a valid assertion. Use a spec "
                     f"for the mock if {name!r} is meant to be an attribute.")
@@ -789,6 +832,9 @@ def __setattr__(self, name, value):
             mock_name = f'{self._extract_mock_name()}.{name}'
             raise AttributeError(f'Cannot set {mock_name}')
 
+        if isinstance(value, PropertyMock):
+            self.__dict__[name] = value
+            return
         return object.__setattr__(self, name, value)
 
 
@@ -816,7 +862,7 @@ def _format_mock_call_signature(self, args, kwargs):
 
 
     def _format_mock_failure_message(self, args, kwargs, action='call'):
-        message = 'expected %s not found.\nExpected: %s\nActual: %s'
+        message = 'expected %s not found.\nExpected: %s\n  Actual: %s'
         expected_string = self._format_mock_call_signature(args, kwargs)
         call_args = self.call_args
         actual_string = self._format_mock_call_signature(*call_args)
@@ -919,7 +965,7 @@ def assert_called_with(self, /, *args, **kwargs):
         if self.call_args is None:
             expected = self._format_mock_call_signature(args, kwargs)
             actual = 'not called.'
-            error_message = ('expected call not found.\nExpected: %s\nActual: %s'
+            error_message = ('expected call not found.\nExpected: %s\n  Actual: %s'
                     % (expected, actual))
             raise AssertionError(error_message)
 
@@ -969,8 +1015,8 @@ def assert_has_calls(self, calls, any_order=False):
                                     for e in expected])
                 raise AssertionError(
                     f'{problem}\n'
-                    f'Expected: {_CallList(calls)}'
-                    f'{self._calls_repr(prefix="Actual").rstrip(".")}'
+                    f'Expected: {_CallList(calls)}\n'
+                    f'  Actual: {safe_repr(self.mock_calls)}'
                 ) from cause
             return
 
@@ -1044,7 +1090,7 @@ def _get_child_mock(self, /, **kw):
         return klass(**kw)
 
 
-    def _calls_repr(self, prefix="Calls"):
+    def _calls_repr(self):
         """Renders self.mock_calls as a string.
 
         Example: "\nCalls: [call(1), call(2)]."
@@ -1054,10 +1100,15 @@ def _calls_repr(self, prefix="Calls"):
         """
         if not self.mock_calls:
             return ""
-        return f"\n{prefix}: {safe_repr(self.mock_calls)}."
+        return f"\nCalls: {safe_repr(self.mock_calls)}."
 
 
-_MOCK_SIG = inspect.signature(NonCallableMock.__init__)
+# Denylist for forbidden attribute names in safe mode
+_ATTRIB_DENY_LIST = frozenset({
+    name.removeprefix("assert_")
+    for name in dir(NonCallableMock)
+    if name.startswith("assert_")
+})
 
 
 class _AnyComparer(list):
@@ -1188,6 +1239,9 @@ def _execute_mock_call(self, /, *args, **kwargs):
         if self._mock_return_value is not DEFAULT:
             return self.return_value
 
+        if self._mock_delegate and self._mock_delegate.return_value is not DEFAULT:
+            return self.return_value
+
         if self._mock_wraps is not None:
             return self._mock_wraps(*args, **kwargs)
 
@@ -1229,9 +1283,11 @@ class or instance) that acts as the specification for the mock object. If
       `return_value` attribute.
 
     * `unsafe`: By default, accessing any attribute whose name starts with
-      *assert*, *assret*, *asert*, *aseert* or *assrt* will raise an
-       AttributeError. Passing `unsafe=True` will allow access to
-      these attributes.
+      *assert*, *assret*, *asert*, *aseert*, or *assrt* raises an AttributeError.
+      Additionally, an AttributeError is raised when accessing
+      attributes that match the name of an assertion method without the prefix
+      `assert_`, e.g. accessing `called_once` instead of `assert_called_once`.
+      Passing `unsafe=True` will allow access to these attributes.
 
     * `wraps`: Item for the mock object to wrap. If `wraps` is not None then
       calling the Mock will pass the call through to the wrapped object
@@ -1303,6 +1359,7 @@ def __init__(
         self.autospec = autospec
         self.kwargs = kwargs
         self.additional_patchers = []
+        self.is_started = False
 
 
     def copy(self):
@@ -1415,6 +1472,9 @@ def get_original(self):
 
     def __enter__(self):
         """Perform the patch."""
+        if self.is_started:
+            raise RuntimeError("Patch is already started")
+
         new, spec, spec_set = self.new, self.spec, self.spec_set
         autospec, kwargs = self.autospec, self.kwargs
         new_callable = self.new_callable
@@ -1457,13 +1517,12 @@ def __enter__(self):
                 if isinstance(original, type):
                     # If we're patching out a class and there is a spec
                     inherit = True
-            if spec is None and _is_async_obj(original):
-                Klass = AsyncMock
-            else:
-                Klass = MagicMock
-            _kwargs = {}
+
+            # Determine the Klass to use
             if new_callable is not None:
                 Klass = new_callable
+            elif spec is None and _is_async_obj(original):
+                Klass = AsyncMock
             elif spec is not None or spec_set is not None:
                 this_spec = spec
                 if spec_set is not None:
@@ -1476,7 +1535,12 @@ def __enter__(self):
                     Klass = AsyncMock
                 elif not_callable:
                     Klass = NonCallableMagicMock
+                else:
+                    Klass = MagicMock
+            else:
+                Klass = MagicMock
 
+            _kwargs = {}
             if spec is not None:
                 _kwargs['spec'] = spec
             if spec_set is not None:
@@ -1542,6 +1606,7 @@ def __enter__(self):
         self.temp_original = original
         self.is_local = local
         self._exit_stack = contextlib.ExitStack()
+        self.is_started = True
         try:
             setattr(self.target, self.attribute, new_attr)
             if self.attribute_name is not None:
@@ -1561,6 +1626,9 @@ def __enter__(self):
 
     def __exit__(self, *exc_info):
         """Undo the patch."""
+        if not self.is_started:
+            return
+
         if self.is_local and self.temp_original is not DEFAULT:
             setattr(self.target, self.attribute, self.temp_original)
         else:
@@ -1577,6 +1645,7 @@ def __exit__(self, *exc_info):
         del self.target
         exit_stack = self._exit_stack
         del self._exit_stack
+        self.is_started = False
         return exit_stack.__exit__(*exc_info)
 
 
@@ -2138,10 +2207,8 @@ def mock_add_spec(self, spec, spec_set=False):
 
 
 class AsyncMagicMixin(MagicMixin):
-    def __init__(self, /, *args, **kw):
-        self._mock_set_magics()  # make magic work for kwargs in init
-        _safe_super(AsyncMagicMixin, self).__init__(*args, **kw)
-        self._mock_set_magics()  # fix magic broken by upper level init
+    pass
+
 
 class MagicMock(MagicMixin, Mock):
     """
@@ -2163,6 +2230,17 @@ def mock_add_spec(self, spec, spec_set=False):
         self._mock_add_spec(spec, spec_set)
         self._mock_set_magics()
 
+    def reset_mock(self, /, *args, return_value: bool = False, **kwargs):
+        if (
+            return_value
+            and self._mock_name
+            and _is_magic(self._mock_name)
+        ):
+            # Don't reset return values for magic methods,
+            # otherwise `m.__str__` will start
+            # to return `MagicMock` instances, instead of `str` instances.
+            return_value = False
+        super().reset_mock(*args, return_value=return_value, **kwargs)
 
 
 class MagicProxy(Base):
@@ -2183,6 +2261,13 @@ def __get__(self, obj, _type=None):
         return self.create_mock()
 
 
+try:
+    _CODE_SIG = inspect.signature(partial(CodeType.__init__, None))
+    _CODE_ATTRS = dir(CodeType)
+except ValueError:
+    _CODE_SIG = None
+
+
 class AsyncMockMixin(Base):
     await_count = _delegating_property('await_count')
     await_args = _delegating_property('await_args')
@@ -2200,8 +2285,21 @@ def __init__(self, /, *args, **kwargs):
         self.__dict__['_mock_await_count'] = 0
         self.__dict__['_mock_await_args'] = None
         self.__dict__['_mock_await_args_list'] = _CallList()
-        code_mock = NonCallableMock(spec_set=CodeType)
-        code_mock.co_flags = inspect.CO_COROUTINE
+        if _CODE_SIG:
+            code_mock = NonCallableMock(spec_set=_CODE_ATTRS)
+            code_mock.__dict__["_spec_class"] = CodeType
+            code_mock.__dict__["_spec_signature"] = _CODE_SIG
+        else:
+            code_mock = NonCallableMock(spec_set=CodeType)
+        code_mock.co_flags = (
+            inspect.CO_COROUTINE
+            + inspect.CO_VARARGS
+            + inspect.CO_VARKEYWORDS
+        )
+        code_mock.co_argcount = 0
+        code_mock.co_varnames = ('args', 'kwargs')
+        code_mock.co_posonlyargcount = 0
+        code_mock.co_kwonlyargcount = 0
         self.__dict__['__code__'] = code_mock
         self.__dict__['__name__'] = 'AsyncMock'
         self.__dict__['__defaults__'] = tuple()
@@ -2679,6 +2777,12 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
     if not unsafe:
         _check_spec_arg_typos(kwargs)
 
+    _name = kwargs.pop('name', _name)
+    _new_name = _name
+    if _parent is None:
+        # for a top level object no _new_name should be set
+        _new_name = ''
+
     _kwargs.update(kwargs)
 
     Klass = MagicMock
@@ -2696,31 +2800,28 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
     elif is_type and instance and not _instance_callable(spec):
         Klass = NonCallableMagicMock
 
-    _name = _kwargs.pop('name', _name)
-
-    _new_name = _name
-    if _parent is None:
-        # for a top level object no _new_name should be set
-        _new_name = ''
-
     mock = Klass(parent=_parent, _new_parent=_parent, _new_name=_new_name,
                  name=_name, **_kwargs)
 
     if isinstance(spec, FunctionTypes):
         # should only happen at the top level because we don't
         # recurse for functions
-        mock = _set_signature(mock, spec)
         if is_async_func:
-            _setup_async_mock(mock)
+            mock = _set_async_signature(mock, spec)
+        else:
+            mock = _set_signature(mock, spec)
     else:
         _check_signature(spec, mock, is_type, instance)
 
     if _parent is not None and not instance:
         _parent._mock_children[_name] = mock
 
+    # Pop wraps from kwargs because it must not be passed to configure_mock.
+    wrapped = kwargs.pop('wraps', None)
     if is_type and not instance and 'return_value' not in kwargs:
         mock.return_value = create_autospec(spec, spec_set, instance=True,
-                                            _name='()', _parent=mock)
+                                            _name='()', _parent=mock,
+                                            wraps=wrapped)
 
     for entry in dir(spec):
         if _is_magic(entry):
@@ -2741,9 +2842,12 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         except AttributeError:
             continue
 
-        kwargs = {'spec': original}
+        child_kwargs = {'spec': original}
+        # Wrap child attributes also.
+        if wrapped and hasattr(wrapped, entry):
+            child_kwargs.update(wraps=original)
         if spec_set:
-            kwargs = {'spec_set': original}
+            child_kwargs = {'spec_set': original}
 
         if not isinstance(original, FunctionTypes):
             new = _SpecState(original, spec_set, mock, entry, instance)
@@ -2754,15 +2858,15 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
                 parent = mock.mock
 
             skipfirst = _must_skip(spec, entry, is_type)
-            kwargs['_eat_self'] = skipfirst
+            child_kwargs['_eat_self'] = skipfirst
             if iscoroutinefunction(original):
                 child_klass = AsyncMock
             else:
                 child_klass = MagicMock
             new = child_klass(parent=parent, name=entry, _new_name=entry,
-                              _new_parent=parent,
-                              **kwargs)
+                              _new_parent=parent, **child_kwargs)
             mock._mock_children[entry] = new
+            new.return_value = child_klass()
             _check_signature(original, new, skipfirst=skipfirst)
 
         # so functions created with _set_signature become instance attributes,
@@ -2771,6 +2875,11 @@ def create_autospec(spec, spec_set=False, instance=False, _parent=None,
         # setting as an instance attribute?
         if isinstance(new, FunctionTypes):
             setattr(mock, entry, new)
+    # kwargs are passed with respect to the parent mock so, they are not used
+    # for creating return_value of the parent mock. So, this condition
+    # should be true only for the parent mock if kwargs are given.
+    if _is_instance_mock(mock) and kwargs:
+        mock.configure_mock(**kwargs)
 
     return mock
 
@@ -2876,6 +2985,9 @@ def _next_side_effect():
             return handle.readline.return_value
         return next(_state[0])
 
+    def _exit_side_effect(exctype, excinst, exctb):
+        handle.close()
+
     global file_spec
     if file_spec is None:
         import _io
@@ -2902,6 +3014,7 @@ def _next_side_effect():
     handle.readlines.side_effect = _readlines_side_effect
     handle.__iter__.side_effect = _iter_side_effect
     handle.__next__.side_effect = _next_side_effect
+    handle.__exit__.side_effect = _exit_side_effect
 
     def reset_data(*args, **kwargs):
         _state[0] = _to_stream(read_data)
@@ -2934,6 +3047,96 @@ def __set__(self, obj, val):
         self(val)
 
 
+_timeout_unset = sentinel.TIMEOUT_UNSET
+
+class ThreadingMixin(Base):
+
+    DEFAULT_TIMEOUT = None
+
+    def _get_child_mock(self, /, **kw):
+        if isinstance(kw.get("parent"), ThreadingMixin):
+            kw["timeout"] = kw["parent"]._mock_wait_timeout
+        elif isinstance(kw.get("_new_parent"), ThreadingMixin):
+            kw["timeout"] = kw["_new_parent"]._mock_wait_timeout
+        return super()._get_child_mock(**kw)
+
+    def __init__(self, *args, timeout=_timeout_unset, **kwargs):
+        super().__init__(*args, **kwargs)
+        if timeout is _timeout_unset:
+            timeout = self.DEFAULT_TIMEOUT
+        self.__dict__["_mock_event"] = threading.Event()  # Event for any call
+        self.__dict__["_mock_calls_events"] = []  # Events for each of the calls
+        self.__dict__["_mock_calls_events_lock"] = threading.Lock()
+        self.__dict__["_mock_wait_timeout"] = timeout
+
+    def reset_mock(self, /, *args, **kwargs):
+        """
+        See :func:`.Mock.reset_mock()`
+        """
+        super().reset_mock(*args, **kwargs)
+        self.__dict__["_mock_event"] = threading.Event()
+        self.__dict__["_mock_calls_events"] = []
+
+    def __get_event(self, expected_args, expected_kwargs):
+        with self._mock_calls_events_lock:
+            for args, kwargs, event in self._mock_calls_events:
+                if (args, kwargs) == (expected_args, expected_kwargs):
+                    return event
+            new_event = threading.Event()
+            self._mock_calls_events.append((expected_args, expected_kwargs, new_event))
+        return new_event
+
+    def _mock_call(self, *args, **kwargs):
+        ret_value = super()._mock_call(*args, **kwargs)
+
+        call_event = self.__get_event(args, kwargs)
+        call_event.set()
+
+        self._mock_event.set()
+
+        return ret_value
+
+    def wait_until_called(self, *, timeout=_timeout_unset):
+        """Wait until the mock object is called.
+
+        `timeout` - time to wait for in seconds, waits forever otherwise.
+        Defaults to the constructor provided timeout.
+        Use None to block undefinetively.
+        """
+        if timeout is _timeout_unset:
+            timeout = self._mock_wait_timeout
+        if not self._mock_event.wait(timeout=timeout):
+            msg = (f"{self._mock_name or 'mock'} was not called before"
+                   f" timeout({timeout}).")
+            raise AssertionError(msg)
+
+    def wait_until_any_call_with(self, *args, **kwargs):
+        """Wait until the mock object is called with given args.
+
+        Waits for the timeout in seconds provided in the constructor.
+        """
+        event = self.__get_event(args, kwargs)
+        if not event.wait(timeout=self._mock_wait_timeout):
+            expected_string = self._format_mock_call_signature(args, kwargs)
+            raise AssertionError(f'{expected_string} call not found')
+
+
+class ThreadingMock(ThreadingMixin, MagicMixin, Mock):
+    """
+    A mock that can be used to wait until on calls happening
+    in a different thread.
+
+    The constructor can take a `timeout` argument which
+    controls the timeout in seconds for all `wait` calls of the mock.
+
+    You can change the default timeout of all instances via the
+    `ThreadingMock.DEFAULT_TIMEOUT` attribute.
+
+    If no timeout is set, it will block undefinetively.
+    """
+    pass
+
+
 def seal(mock):
     """Disable the automatic generation of child mocks.
 
diff --git a/Lib/unittest/result.py b/Lib/unittest/result.py
index 5ca4c23238..3ace0a5b7b 100644
--- a/Lib/unittest/result.py
+++ b/Lib/unittest/result.py
@@ -43,6 +43,7 @@ def __init__(self, stream=None, descriptions=None, verbosity=None):
         self.skipped = []
         self.expectedFailures = []
         self.unexpectedSuccesses = []
+        self.collectedDurations = []
         self.shouldStop = False
         self.buffer = False
         self.tb_locals = False
@@ -157,6 +158,17 @@ def addUnexpectedSuccess(self, test):
         """Called when a test was expected to fail, but succeed."""
         self.unexpectedSuccesses.append(test)
 
+    def addDuration(self, test, elapsed):
+        """Called when a test finished to run, regardless of its outcome.
+        *test* is the test case corresponding to the test method.
+        *elapsed* is the time represented in seconds, and it includes the
+        execution of cleanup functions.
+        """
+        # support for a TextTestRunner using an old TestResult class
+        if hasattr(self, "collectedDurations"):
+            # Pass test repr and not the test object itself to avoid resources leak
+            self.collectedDurations.append((str(test), elapsed))
+
     def wasSuccessful(self):
         """Tells whether or not this result was a success."""
         # The hasattr check is for test_result's OldResult test.  That
diff --git a/Lib/unittest/runner.py b/Lib/unittest/runner.py
index cb452c7ade..2bcadf0c99 100644
--- a/Lib/unittest/runner.py
+++ b/Lib/unittest/runner.py
@@ -35,13 +35,16 @@ class TextTestResult(result.TestResult):
     separator1 = '=' * 70
     separator2 = '-' * 70
 
-    def __init__(self, stream, descriptions, verbosity):
+    def __init__(self, stream, descriptions, verbosity, *, durations=None):
+        """Construct a TextTestResult. Subclasses should accept **kwargs
+        to ensure compatibility as the interface changes."""
         super(TextTestResult, self).__init__(stream, descriptions, verbosity)
         self.stream = stream
         self.showAll = verbosity > 1
         self.dots = verbosity == 1
         self.descriptions = descriptions
         self._newline = True
+        self.durations = durations
 
     def getDescription(self, test):
         doc_first_line = test.shortDescription()
@@ -168,7 +171,7 @@ class TextTestRunner(object):
 
     def __init__(self, stream=None, descriptions=True, verbosity=1,
                  failfast=False, buffer=False, resultclass=None, warnings=None,
-                 *, tb_locals=False):
+                 *, tb_locals=False, durations=None):
         """Construct a TextTestRunner.
 
         Subclasses should accept **kwargs to ensure compatibility as the
@@ -182,12 +185,41 @@ def __init__(self, stream=None, descriptions=True, verbosity=1,
         self.failfast = failfast
         self.buffer = buffer
         self.tb_locals = tb_locals
+        self.durations = durations
         self.warnings = warnings
         if resultclass is not None:
             self.resultclass = resultclass
 
     def _makeResult(self):
-        return self.resultclass(self.stream, self.descriptions, self.verbosity)
+        try:
+            return self.resultclass(self.stream, self.descriptions,
+                                    self.verbosity, durations=self.durations)
+        except TypeError:
+            # didn't accept the durations argument
+            return self.resultclass(self.stream, self.descriptions,
+                                    self.verbosity)
+
+    def _printDurations(self, result):
+        if not result.collectedDurations:
+            return
+        ls = sorted(result.collectedDurations, key=lambda x: x[1],
+                    reverse=True)
+        if self.durations > 0:
+            ls = ls[:self.durations]
+        self.stream.writeln("Slowest test durations")
+        if hasattr(result, 'separator2'):
+            self.stream.writeln(result.separator2)
+        hidden = False
+        for test, elapsed in ls:
+            if self.verbosity < 2 and elapsed < 0.001:
+                hidden = True
+                continue
+            self.stream.writeln("%-10s %s" % ("%.3fs" % elapsed, test))
+        if hidden:
+            self.stream.writeln("\n(durations < 0.001s were hidden; "
+                                "use -v to show these durations)")
+        else:
+            self.stream.writeln("")
 
     def run(self, test):
         "Run the given test case or test suite."
@@ -200,15 +232,6 @@ def run(self, test):
             if self.warnings:
                 # if self.warnings is set, use it to filter all the warnings
                 warnings.simplefilter(self.warnings)
-                # if the filter is 'default' or 'always', special-case the
-                # warnings from the deprecated unittest methods to show them
-                # no more than once per module, because they can be fairly
-                # noisy.  The -Wd and -Wa flags can be used to bypass this
-                # only when self.warnings is None.
-                if self.warnings in ['default', 'always']:
-                    warnings.filterwarnings('module',
-                            category=DeprecationWarning,
-                            message=r'Please use assert\w+ instead.')
             startTime = time.perf_counter()
             startTestRun = getattr(result, 'startTestRun', None)
             if startTestRun is not None:
@@ -222,8 +245,12 @@ def run(self, test):
             stopTime = time.perf_counter()
         timeTaken = stopTime - startTime
         result.printErrors()
+        if self.durations is not None:
+            self._printDurations(result)
+
         if hasattr(result, 'separator2'):
             self.stream.writeln(result.separator2)
+
         run = result.testsRun
         self.stream.writeln("Ran %d test%s in %.3fs" %
                             (run, run != 1 and "s" or "", timeTaken))
@@ -247,6 +274,8 @@ def run(self, test):
                 infos.append("failures=%d" % failed)
             if errored:
                 infos.append("errors=%d" % errored)
+        elif run == 0 and not skipped:
+            self.stream.write("NO TESTS RAN")
         else:
             self.stream.write("OK")
         if skipped:
diff --git a/Lib/unittest/test/__init__.py b/Lib/unittest/test/__init__.py
deleted file mode 100644
index 143f4ab5a3..0000000000
--- a/Lib/unittest/test/__init__.py
+++ /dev/null
@@ -1,25 +0,0 @@
-import os
-import sys
-import unittest
-
-
-here = os.path.dirname(__file__)
-loader = unittest.defaultTestLoader
-
-def suite():
-    suite = unittest.TestSuite()
-    for fn in os.listdir(here):
-        if fn.startswith("test") and fn.endswith(".py"):
-            modname = "unittest.test." + fn[:-3]
-            try:
-                __import__(modname)
-            except unittest.SkipTest:
-                continue
-            module = sys.modules[modname]
-            suite.addTest(loader.loadTestsFromModule(module))
-    suite.addTest(loader.loadTestsFromName('unittest.test.testmock'))
-    return suite
-
-
-if __name__ == "__main__":
-    unittest.main(defaultTest="suite")
diff --git a/Lib/unittest/test/__main__.py b/Lib/unittest/test/__main__.py
deleted file mode 100644
index 44d0591e84..0000000000
--- a/Lib/unittest/test/__main__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-import os
-import unittest
-
-
-def load_tests(loader, standard_tests, pattern):
-    # top level directory cached on loader instance
-    this_dir = os.path.dirname(__file__)
-    pattern = pattern or "test_*.py"
-    # We are inside unittest.test, so the top-level is two notches up
-    top_level_dir = os.path.dirname(os.path.dirname(this_dir))
-    package_tests = loader.discover(start_dir=this_dir, pattern=pattern,
-                                    top_level_dir=top_level_dir)
-    standard_tests.addTests(package_tests)
-    return standard_tests
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/unittest/test/support.py b/Lib/unittest/test/support.py
deleted file mode 100644
index 529265304f..0000000000
--- a/Lib/unittest/test/support.py
+++ /dev/null
@@ -1,138 +0,0 @@
-import unittest
-
-
-class TestEquality(object):
-    """Used as a mixin for TestCase"""
-
-    # Check for a valid __eq__ implementation
-    def test_eq(self):
-        for obj_1, obj_2 in self.eq_pairs:
-            self.assertEqual(obj_1, obj_2)
-            self.assertEqual(obj_2, obj_1)
-
-    # Check for a valid __ne__ implementation
-    def test_ne(self):
-        for obj_1, obj_2 in self.ne_pairs:
-            self.assertNotEqual(obj_1, obj_2)
-            self.assertNotEqual(obj_2, obj_1)
-
-class TestHashing(object):
-    """Used as a mixin for TestCase"""
-
-    # Check for a valid __hash__ implementation
-    def test_hash(self):
-        for obj_1, obj_2 in self.eq_pairs:
-            try:
-                if not hash(obj_1) == hash(obj_2):
-                    self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
-            except Exception as e:
-                self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
-
-        for obj_1, obj_2 in self.ne_pairs:
-            try:
-                if hash(obj_1) == hash(obj_2):
-                    self.fail("%s and %s hash equal, but shouldn't" %
-                              (obj_1, obj_2))
-            except Exception as e:
-                self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
-
-
-class _BaseLoggingResult(unittest.TestResult):
-    def __init__(self, log):
-        self._events = log
-        super().__init__()
-
-    def startTest(self, test):
-        self._events.append('startTest')
-        super().startTest(test)
-
-    def startTestRun(self):
-        self._events.append('startTestRun')
-        super().startTestRun()
-
-    def stopTest(self, test):
-        self._events.append('stopTest')
-        super().stopTest(test)
-
-    def stopTestRun(self):
-        self._events.append('stopTestRun')
-        super().stopTestRun()
-
-    def addFailure(self, *args):
-        self._events.append('addFailure')
-        super().addFailure(*args)
-
-    def addSuccess(self, *args):
-        self._events.append('addSuccess')
-        super().addSuccess(*args)
-
-    def addError(self, *args):
-        self._events.append('addError')
-        super().addError(*args)
-
-    def addSkip(self, *args):
-        self._events.append('addSkip')
-        super().addSkip(*args)
-
-    def addExpectedFailure(self, *args):
-        self._events.append('addExpectedFailure')
-        super().addExpectedFailure(*args)
-
-    def addUnexpectedSuccess(self, *args):
-        self._events.append('addUnexpectedSuccess')
-        super().addUnexpectedSuccess(*args)
-
-
-class LegacyLoggingResult(_BaseLoggingResult):
-    """
-    A legacy TestResult implementation, without an addSubTest method,
-    which records its method calls.
-    """
-
-    @property
-    def addSubTest(self):
-        raise AttributeError
-
-
-class LoggingResult(_BaseLoggingResult):
-    """
-    A TestResult implementation which records its method calls.
-    """
-
-    def addSubTest(self, test, subtest, err):
-        if err is None:
-            self._events.append('addSubTestSuccess')
-        else:
-            self._events.append('addSubTestFailure')
-        super().addSubTest(test, subtest, err)
-
-
-class ResultWithNoStartTestRunStopTestRun(object):
-    """An object honouring TestResult before startTestRun/stopTestRun."""
-
-    def __init__(self):
-        self.failures = []
-        self.errors = []
-        self.testsRun = 0
-        self.skipped = []
-        self.expectedFailures = []
-        self.unexpectedSuccesses = []
-        self.shouldStop = False
-
-    def startTest(self, test):
-        pass
-
-    def stopTest(self, test):
-        pass
-
-    def addError(self, test):
-        pass
-
-    def addFailure(self, test):
-        pass
-
-    def addSuccess(self, test):
-        pass
-
-    def wasSuccessful(self):
-        return True
diff --git a/Lib/unittest/test/testmock/__init__.py b/Lib/unittest/test/testmock/__init__.py
deleted file mode 100644
index 661b577259..0000000000
--- a/Lib/unittest/test/testmock/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import os
-import sys
-import unittest
-
-
-here = os.path.dirname(__file__)
-loader = unittest.defaultTestLoader
-
-def load_tests(*args):
-    suite = unittest.TestSuite()
-    # TODO: RUSTPYTHON; allow objects to be mocked better
-    return suite
-    for fn in os.listdir(here):
-        if fn.startswith("test") and fn.endswith(".py"):
-            modname = "unittest.test.testmock." + fn[:-3]
-            __import__(modname)
-            module = sys.modules[modname]
-            suite.addTest(loader.loadTestsFromModule(module))
-    return suite
diff --git a/Lib/unittest/test/testmock/__main__.py b/Lib/unittest/test/testmock/__main__.py
deleted file mode 100644
index 45c633a4ee..0000000000
--- a/Lib/unittest/test/testmock/__main__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-import os
-import unittest
-
-
-def load_tests(loader, standard_tests, pattern):
-    # top level directory cached on loader instance
-    this_dir = os.path.dirname(__file__)
-    pattern = pattern or "test*.py"
-    # We are inside unittest.test.testmock, so the top-level is three notches up
-    top_level_dir = os.path.dirname(os.path.dirname(os.path.dirname(this_dir)))
-    package_tests = loader.discover(start_dir=this_dir, pattern=pattern,
-                                    top_level_dir=top_level_dir)
-    standard_tests.addTests(package_tests)
-    return standard_tests
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/unittest/test/testmock/support.py b/Lib/unittest/test/testmock/support.py
deleted file mode 100644
index 49986d65dc..0000000000
--- a/Lib/unittest/test/testmock/support.py
+++ /dev/null
@@ -1,16 +0,0 @@
-target = {'foo': 'FOO'}
-
-
-def is_instance(obj, klass):
-    """Version of is_instance that doesn't access __class__"""
-    return issubclass(type(obj), klass)
-
-
-class SomeClass(object):
-    class_attribute = None
-
-    def wibble(self): pass
-
-
-class X(object):
-    pass
diff --git a/Lib/urllib/error.py b/Lib/urllib/error.py
index 8cd901f13f..a9cd1ecadd 100644
--- a/Lib/urllib/error.py
+++ b/Lib/urllib/error.py
@@ -10,7 +10,7 @@
 an application may want to handle an exception like a regular
 response.
 """
-
+import io
 import urllib.response
 
 __all__ = ['URLError', 'HTTPError', 'ContentTooShortError']
@@ -42,12 +42,9 @@ def __init__(self, url, code, msg, hdrs, fp):
         self.hdrs = hdrs
         self.fp = fp
         self.filename = url
-        # The addinfourl classes depend on fp being a valid file
-        # object.  In some cases, the HTTPError may not have a valid
-        # file object.  If this happens, the simplest workaround is to
-        # not initialize the base classes.
-        if fp is not None:
-            self.__super_init(fp, hdrs, url, code)
+        if fp is None:
+            fp = io.BytesIO()
+        self.__super_init(fp, hdrs, url, code)
 
     def __str__(self):
         return 'HTTP Error %s: %s' % (self.code, self.msg)
diff --git a/Lib/urllib/parse.py b/Lib/urllib/parse.py
index b35997bc00..c72138a33c 100644
--- a/Lib/urllib/parse.py
+++ b/Lib/urllib/parse.py
@@ -25,13 +25,19 @@
 scenarios for parsing, and for backward compatibility purposes, some
 parsing quirks from older RFCs are retained. The testcases in
 test_urlparse.py provides a good indicator of parsing behavior.
+
+The WHATWG URL Parser spec should also be considered.  We are not compliant with
+it either due to existing user code API behavior expectations (Hyrum's Law).
+It serves as a useful guide when making changes.
 """
 
+from collections import namedtuple
+import functools
+import math
 import re
-import sys
 import types
-import collections
 import warnings
+import ipaddress
 
 __all__ = ["urlparse", "urlunparse", "urljoin", "urldefrag",
            "urlsplit", "urlunsplit", "urlencode", "parse_qs",
@@ -46,18 +52,18 @@
 
 uses_relative = ['', 'ftp', 'http', 'gopher', 'nntp', 'imap',
                  'wais', 'file', 'https', 'shttp', 'mms',
-                 'prospero', 'rtsp', 'rtspu', 'sftp',
+                 'prospero', 'rtsp', 'rtsps', 'rtspu', 'sftp',
                  'svn', 'svn+ssh', 'ws', 'wss']
 
 uses_netloc = ['', 'ftp', 'http', 'gopher', 'nntp', 'telnet',
                'imap', 'wais', 'file', 'mms', 'https', 'shttp',
-               'snews', 'prospero', 'rtsp', 'rtspu', 'rsync',
+               'snews', 'prospero', 'rtsp', 'rtsps', 'rtspu', 'rsync',
                'svn', 'svn+ssh', 'sftp', 'nfs', 'git', 'git+ssh',
-               'ws', 'wss']
+               'ws', 'wss', 'itms-services']
 
 uses_params = ['', 'ftp', 'hdl', 'prospero', 'http', 'imap',
-               'https', 'shttp', 'rtsp', 'rtspu', 'sip', 'sips',
-               'mms', 'sftp', 'tel']
+               'https', 'shttp', 'rtsp', 'rtsps', 'rtspu', 'sip',
+               'sips', 'mms', 'sftp', 'tel']
 
 # These are not actually used anymore, but should stay for backwards
 # compatibility.  (They are undocumented, but have a public-looking name.)
@@ -66,7 +72,7 @@
                     'telnet', 'wais', 'imap', 'snews', 'sip', 'sips']
 
 uses_query = ['', 'http', 'wais', 'imap', 'https', 'shttp', 'mms',
-              'gopher', 'rtsp', 'rtspu', 'sip', 'sips']
+              'gopher', 'rtsp', 'rtsps', 'rtspu', 'sip', 'sips']
 
 uses_fragment = ['', 'ftp', 'hdl', 'http', 'gopher', 'news',
                  'nntp', 'wais', 'https', 'shttp', 'snews',
@@ -78,18 +84,17 @@
                 '0123456789'
                 '+-.')
 
+# Leading and trailing C0 control and space to be stripped per WHATWG spec.
+# == "".join([chr(i) for i in range(0, 0x20 + 1)])
+_WHATWG_C0_CONTROL_OR_SPACE = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f '
+
 # Unsafe bytes to be removed per WHATWG spec
 _UNSAFE_URL_BYTES_TO_REMOVE = ['\t', '\r', '\n']
 
-# XXX: Consider replacing with functools.lru_cache
-MAX_CACHE_SIZE = 20
-_parse_cache = {}
-
 def clear_cache():
-    """Clear the parse cache and the quoters cache."""
-    _parse_cache.clear()
-    _safe_quoters.clear()
-
+    """Clear internal performance caches. Undocumented; some tests want it."""
+    urlsplit.cache_clear()
+    _byte_quoter_factory.cache_clear()
 
 # Helpers for bytes handling
 # For 3.2, we deliberately require applications that
@@ -171,12 +176,11 @@ def hostname(self):
     def port(self):
         port = self._hostinfo[1]
         if port is not None:
-            try:
-                port = int(port, 10)
-            except ValueError:
-                message = f'Port could not be cast to integer value as {port!r}'
-                raise ValueError(message) from None
-            if not ( 0 <= port <= 65535):
+            if port.isdigit() and port.isascii():
+                port = int(port)
+            else:
+                raise ValueError(f"Port could not be cast to integer value as {port!r}")
+            if not (0 <= port <= 65535):
                 raise ValueError("Port out of range 0-65535")
         return port
 
@@ -243,8 +247,6 @@ def _hostinfo(self):
         return hostname, port
 
 
-from collections import namedtuple
-
 _DefragResultBase = namedtuple('DefragResult', 'url fragment')
 _SplitResultBase = namedtuple(
     'SplitResult', 'scheme netloc path query fragment')
@@ -434,6 +436,37 @@ def _checknetloc(netloc):
             raise ValueError("netloc '" + netloc + "' contains invalid " +
                              "characters under NFKC normalization")
 
+def _check_bracketed_netloc(netloc):
+    # Note that this function must mirror the splitting
+    # done in NetlocResultMixins._hostinfo().
+    hostname_and_port = netloc.rpartition('@')[2]
+    before_bracket, have_open_br, bracketed = hostname_and_port.partition('[')
+    if have_open_br:
+        # No data is allowed before a bracket.
+        if before_bracket:
+            raise ValueError("Invalid IPv6 URL")
+        hostname, _, port = bracketed.partition(']')
+        # No data is allowed after the bracket but before the port delimiter.
+        if port and not port.startswith(":"):
+            raise ValueError("Invalid IPv6 URL")
+    else:
+        hostname, _, port = hostname_and_port.partition(':')
+    _check_bracketed_host(hostname)
+
+# Valid bracketed hosts are defined in
+# https://www.rfc-editor.org/rfc/rfc3986#page-49 and https://url.spec.whatwg.org/
+def _check_bracketed_host(hostname):
+    if hostname.startswith('v'):
+        if not re.match(r"\Av[a-fA-F0-9]+\..+\Z", hostname):
+            raise ValueError(f"IPvFuture address is invalid")
+    else:
+        ip = ipaddress.ip_address(hostname) # Throws Value Error if not IPv6 or IPv4
+        if isinstance(ip, ipaddress.IPv4Address):
+            raise ValueError(f"An IPv4 address cannot be in brackets")
+
+# typed=True avoids BytesWarnings being emitted during cache key
+# comparison since this API supports both bytes and str input.
+@functools.lru_cache(typed=True)
 def urlsplit(url, scheme='', allow_fragments=True):
     """Parse a URL into 5 components:
     <scheme>://<netloc>/<path>?<query>#<fragment>
@@ -456,39 +489,37 @@ def urlsplit(url, scheme='', allow_fragments=True):
     """
 
     url, scheme, _coerce_result = _coerce_args(url, scheme)
+    # Only lstrip url as some applications rely on preserving trailing space.
+    # (https://url.spec.whatwg.org/#concept-basic-url-parser would strip both)
+    url = url.lstrip(_WHATWG_C0_CONTROL_OR_SPACE)
+    scheme = scheme.strip(_WHATWG_C0_CONTROL_OR_SPACE)
 
     for b in _UNSAFE_URL_BYTES_TO_REMOVE:
         url = url.replace(b, "")
         scheme = scheme.replace(b, "")
 
     allow_fragments = bool(allow_fragments)
-    key = url, scheme, allow_fragments, type(url), type(scheme)
-    cached = _parse_cache.get(key, None)
-    if cached:
-        return _coerce_result(cached)
-    if len(_parse_cache) >= MAX_CACHE_SIZE: # avoid runaway growth
-        clear_cache()
     netloc = query = fragment = ''
     i = url.find(':')
-    if i > 0:
+    if i > 0 and url[0].isascii() and url[0].isalpha():
         for c in url[:i]:
             if c not in scheme_chars:
                 break
         else:
             scheme, url = url[:i].lower(), url[i+1:]
-
     if url[:2] == '//':
         netloc, url = _splitnetloc(url, 2)
         if (('[' in netloc and ']' not in netloc) or
                 (']' in netloc and '[' not in netloc)):
             raise ValueError("Invalid IPv6 URL")
+        if '[' in netloc and ']' in netloc:
+            _check_bracketed_netloc(netloc)
     if allow_fragments and '#' in url:
         url, fragment = url.split('#', 1)
     if '?' in url:
         url, query = url.split('?', 1)
     _checknetloc(netloc)
     v = SplitResult(scheme, netloc, url, query, fragment)
-    _parse_cache[key] = v
     return _coerce_result(v)
 
 def urlunparse(components):
@@ -510,9 +541,13 @@ def urlunsplit(components):
     empty query; the RFC states that these are equivalent)."""
     scheme, netloc, url, query, fragment, _coerce_result = (
                                           _coerce_args(*components))
-    if netloc or (scheme and scheme in uses_netloc and url[:2] != '//'):
+    if netloc:
         if url and url[:1] != '/': url = '/' + url
-        url = '//' + (netloc or '') + url
+        url = '//' + netloc + url
+    elif url[:2] == '//':
+        url = '//' + url
+    elif scheme and scheme in uses_netloc and (not url or url[:1] == '/'):
+        url = '//' + url
     if scheme:
         url = scheme + ':' + url
     if query:
@@ -611,6 +646,9 @@ def urldefrag(url):
 
 def unquote_to_bytes(string):
     """unquote_to_bytes('abc%20def') -> b'abc def'."""
+    return bytes(_unquote_impl(string))
+
+def _unquote_impl(string: bytes | bytearray | str) -> bytes | bytearray:
     # Note: strings are encoded as UTF-8. This is only an issue if it contains
     # unescaped non-ASCII characters, which URIs should not.
     if not string:
@@ -622,8 +660,8 @@ def unquote_to_bytes(string):
     bits = string.split(b'%')
     if len(bits) == 1:
         return string
-    res = [bits[0]]
-    append = res.append
+    res = bytearray(bits[0])
+    append = res.extend
     # Delay the initialization of the table to not waste memory
     # if the function is never called
     global _hextobyte
@@ -637,10 +675,20 @@ def unquote_to_bytes(string):
         except KeyError:
             append(b'%')
             append(item)
-    return b''.join(res)
+    return res
 
 _asciire = re.compile('([\x00-\x7f]+)')
 
+def _generate_unquoted_parts(string, encoding, errors):
+    previous_match_end = 0
+    for ascii_match in _asciire.finditer(string):
+        start, end = ascii_match.span()
+        yield string[previous_match_end:start]  # Non-ASCII
+        # The ascii_match[1] group == string[start:end].
+        yield _unquote_impl(ascii_match[1]).decode(encoding, errors)
+        previous_match_end = end
+    yield string[previous_match_end:]  # Non-ASCII tail
+
 def unquote(string, encoding='utf-8', errors='replace'):
     """Replace %xx escapes by their single-character equivalent. The optional
     encoding and errors parameters specify how to decode percent-encoded
@@ -652,21 +700,16 @@ def unquote(string, encoding='utf-8', errors='replace'):
     unquote('abc%20def') -> 'abc def'.
     """
     if isinstance(string, bytes):
-        return unquote_to_bytes(string).decode(encoding, errors)
+        return _unquote_impl(string).decode(encoding, errors)
     if '%' not in string:
+        # Is it a string-like object?
         string.split
         return string
     if encoding is None:
         encoding = 'utf-8'
     if errors is None:
         errors = 'replace'
-    bits = _asciire.split(string)
-    res = [bits[0]]
-    append = res.append
-    for i in range(1, len(bits), 2):
-        append(unquote_to_bytes(bits[i]).decode(encoding, errors))
-        append(bits[i + 1])
-    return ''.join(res)
+    return ''.join(_generate_unquoted_parts(string, encoding, errors))
 
 
 def parse_qs(qs, keep_blank_values=False, strict_parsing=False,
@@ -740,11 +783,29 @@ def parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 
         Returns a list, as G-d intended.
     """
-    qs, _coerce_result = _coerce_args(qs)
-    separator, _ = _coerce_args(separator)
 
-    if not separator or (not isinstance(separator, (str, bytes))):
+    if not separator or not isinstance(separator, (str, bytes)):
         raise ValueError("Separator must be of type string or bytes.")
+    if isinstance(qs, str):
+        if not isinstance(separator, str):
+            separator = str(separator, 'ascii')
+        eq = '='
+        def _unquote(s):
+            return unquote_plus(s, encoding=encoding, errors=errors)
+    else:
+        if not qs:
+            return []
+        # Use memoryview() to reject integers and iterables,
+        # acceptable by the bytes constructor.
+        qs = bytes(memoryview(qs))
+        if isinstance(separator, str):
+            separator = bytes(separator, 'ascii')
+        eq = b'='
+        def _unquote(s):
+            return unquote_to_bytes(s.replace(b'+', b' '))
+
+    if not qs:
+        return []
 
     # If max_num_fields is defined then check that the number of fields
     # is less than max_num_fields. This prevents a memory exhaustion DOS
@@ -756,25 +817,14 @@ def parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
 
     r = []
     for name_value in qs.split(separator):
-        if not name_value and not strict_parsing:
-            continue
-        nv = name_value.split('=', 1)
-        if len(nv) != 2:
-            if strict_parsing:
+        if name_value or strict_parsing:
+            name, has_eq, value = name_value.partition(eq)
+            if not has_eq and strict_parsing:
                 raise ValueError("bad query field: %r" % (name_value,))
-            # Handle case of a control-name with no equal sign
-            if keep_blank_values:
-                nv.append('')
-            else:
-                continue
-        if len(nv[1]) or keep_blank_values:
-            name = nv[0].replace('+', ' ')
-            name = unquote(name, encoding=encoding, errors=errors)
-            name = _coerce_result(name)
-            value = nv[1].replace('+', ' ')
-            value = unquote(value, encoding=encoding, errors=errors)
-            value = _coerce_result(value)
-            r.append((name, value))
+            if value or keep_blank_values:
+                name = _unquote(name)
+                value = _unquote(value)
+                r.append((name, value))
     return r
 
 def unquote_plus(string, encoding='utf-8', errors='replace'):
@@ -791,23 +841,30 @@ def unquote_plus(string, encoding='utf-8', errors='replace'):
                          b'0123456789'
                          b'_.-~')
 _ALWAYS_SAFE_BYTES = bytes(_ALWAYS_SAFE)
-_safe_quoters = {}
 
-class Quoter(collections.defaultdict):
-    """A mapping from bytes (in range(0,256)) to strings.
+def __getattr__(name):
+    if name == 'Quoter':
+        warnings.warn('Deprecated in 3.11. '
+                      'urllib.parse.Quoter will be removed in Python 3.14. '
+                      'It was not intended to be a public API.',
+                      DeprecationWarning, stacklevel=2)
+        return _Quoter
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+
+class _Quoter(dict):
+    """A mapping from bytes numbers (in range(0,256)) to strings.
 
     String values are percent-encoded byte values, unless the key < 128, and
-    in the "safe" set (either the specified safe set, or default set).
+    in either of the specified safe set, or the always safe set.
     """
-    # Keeps a cache internally, using defaultdict, for efficiency (lookups
+    # Keeps a cache internally, via __missing__, for efficiency (lookups
     # of cached keys don't call Python code at all).
     def __init__(self, safe):
         """safe: bytes object."""
         self.safe = _ALWAYS_SAFE.union(safe)
 
     def __repr__(self):
-        # Without this, will just display as a defaultdict
-        return "<%s %r>" % (self.__class__.__name__, dict(self))
+        return f"<Quoter {dict(self)!r}>"
 
     def __missing__(self, b):
         # Handle a cache miss. Store quoted string in cache and return.
@@ -886,6 +943,11 @@ def quote_plus(string, safe='', encoding=None, errors=None):
     string = quote(string, safe + space, encoding, errors)
     return string.replace(' ', '+')
 
+# Expectation: A typical program is unlikely to create more than 5 of these.
+@functools.lru_cache
+def _byte_quoter_factory(safe):
+    return _Quoter(safe).__getitem__
+
 def quote_from_bytes(bs, safe='/'):
     """Like quote(), but accepts a bytes object rather than a str, and does
     not perform string-to-bytes encoding.  It always returns an ASCII string.
@@ -899,14 +961,19 @@ def quote_from_bytes(bs, safe='/'):
         # Normalize 'safe' by converting to bytes and removing non-ASCII chars
         safe = safe.encode('ascii', 'ignore')
     else:
+        # List comprehensions are faster than generator expressions.
         safe = bytes([c for c in safe if c < 128])
     if not bs.rstrip(_ALWAYS_SAFE_BYTES + safe):
         return bs.decode()
-    try:
-        quoter = _safe_quoters[safe]
-    except KeyError:
-        _safe_quoters[safe] = quoter = Quoter(safe).__getitem__
-    return ''.join([quoter(char) for char in bs])
+    quoter = _byte_quoter_factory(safe)
+    if (bs_len := len(bs)) < 200_000:
+        return ''.join(map(quoter, bs))
+    else:
+        # This saves memory - https://github.com/python/cpython/issues/95865
+        chunk_size = math.isqrt(bs_len)
+        chunks = [''.join(map(quoter, bs[i:i+chunk_size]))
+                  for i in range(0, bs_len, chunk_size)]
+        return ''.join(chunks)
 
 def urlencode(query, doseq=False, safe='', encoding=None, errors=None,
               quote_via=quote_plus):
@@ -939,10 +1006,9 @@ def urlencode(query, doseq=False, safe='', encoding=None, errors=None,
             # but that's a minor nit.  Since the original implementation
             # allowed empty dicts that type of behavior probably should be
             # preserved for consistency
-        except TypeError:
-            ty, va, tb = sys.exc_info()
+        except TypeError as err:
             raise TypeError("not a valid non-string sequence "
-                            "or mapping object").with_traceback(tb)
+                            "or mapping object") from err
 
     l = []
     if not doseq:
@@ -1125,15 +1191,15 @@ def splitnport(host, defport=-1):
 def _splitnport(host, defport=-1):
     """Split host and port, returning numeric port.
     Return given default port if no ':' found; defaults to -1.
-    Return numerical port if a valid number are found after ':'.
+    Return numerical port if a valid number is found after ':'.
     Return None if ':' but not a valid number."""
     host, delim, port = host.rpartition(':')
     if not delim:
         host = port
     elif port:
-        try:
+        if port.isdigit() and port.isascii():
             nport = int(port)
-        except ValueError:
+        else:
             nport = None
         return host, nport
     return host, defport
diff --git a/Lib/urllib/request.py b/Lib/urllib/request.py
index a0ef60b30d..21d76913fe 100644
--- a/Lib/urllib/request.py
+++ b/Lib/urllib/request.py
@@ -11,8 +11,8 @@
 Handlers needed to open the requested URL.  For example, the
 HTTPHandler performs HTTP GET and POST requests and deals with
 non-error returns.  The HTTPRedirectHandler automatically deals with
-HTTP 301, 302, 303 and 307 redirect errors, and the HTTPDigestAuthHandler
-deals with digest authentication.
+HTTP 301, 302, 303, 307, and 308 redirect errors, and the
+HTTPDigestAuthHandler deals with digest authentication.
 
 urlopen(url, data=None) -- Basic usage is the same as original
 urllib.  pass the url and optionally data to post to an HTTP URL, and
@@ -88,7 +88,6 @@
 import http.client
 import io
 import os
-import posixpath
 import re
 import socket
 import string
@@ -137,7 +136,7 @@
 
 _opener = None
 def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
-            *, cafile=None, capath=None, cadefault=False, context=None):
+            *, context=None):
     '''Open the URL url, which can be either a string or a Request object.
 
     *data* must be an object specifying additional data to be sent to
@@ -155,14 +154,6 @@ def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
     If *context* is specified, it must be a ssl.SSLContext instance describing
     the various SSL options. See HTTPSConnection for more details.
 
-    The optional *cafile* and *capath* parameters specify a set of trusted CA
-    certificates for HTTPS requests. cafile should point to a single file
-    containing a bundle of CA certificates, whereas capath should point to a
-    directory of hashed certificate files. More information can be found in
-    ssl.SSLContext.load_verify_locations().
-
-    The *cadefault* parameter is ignored.
-
 
     This function always returns an object which can work as a
     context manager and has the properties url, headers, and status.
@@ -188,25 +179,7 @@ def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
 
     '''
     global _opener
-    if cafile or capath or cadefault:
-        import warnings
-        warnings.warn("cafile, capath and cadefault are deprecated, use a "
-                      "custom context instead.", DeprecationWarning, 2)
-        if context is not None:
-            raise ValueError(
-                "You can't pass both context and any of cafile, capath, and "
-                "cadefault"
-            )
-        if not _have_ssl:
-            raise ValueError('SSL support not available')
-        context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH,
-                                             cafile=cafile,
-                                             capath=capath)
-        # send ALPN extension to indicate HTTP/1.1 protocol
-        context.set_alpn_protocols(['http/1.1'])
-        https_handler = HTTPSHandler(context=context)
-        opener = build_opener(https_handler)
-    elif context:
+    if context:
         https_handler = HTTPSHandler(context=context)
         opener = build_opener(https_handler)
     elif _opener is None:
@@ -266,10 +239,7 @@ def urlretrieve(url, filename=None, reporthook=None, data=None):
             if reporthook:
                 reporthook(blocknum, bs, size)
 
-            while True:
-                block = fp.read(bs)
-                if not block:
-                    break
+            while block := fp.read(bs):
                 read += len(block)
                 tfp.write(block)
                 blocknum += 1
@@ -661,7 +631,7 @@ def redirect_request(self, req, fp, code, msg, headers, newurl):
         but another Handler might.
         """
         m = req.get_method()
-        if (not (code in (301, 302, 303, 307) and m in ("GET", "HEAD")
+        if (not (code in (301, 302, 303, 307, 308) and m in ("GET", "HEAD")
             or code in (301, 302, 303) and m == "POST")):
             raise HTTPError(req.full_url, code, msg, headers, fp)
 
@@ -680,6 +650,7 @@ def redirect_request(self, req, fp, code, msg, headers, newurl):
         newheaders = {k: v for k, v in req.headers.items()
                       if k.lower() not in CONTENT_HEADERS}
         return Request(newurl,
+                       method="HEAD" if m == "HEAD" else "GET",
                        headers=newheaders,
                        origin_req_host=req.origin_req_host,
                        unverifiable=True)
@@ -748,7 +719,7 @@ def http_error_302(self, req, fp, code, msg, headers):
 
         return self.parent.open(new, timeout=req.timeout)
 
-    http_error_301 = http_error_303 = http_error_307 = http_error_302
+    http_error_301 = http_error_303 = http_error_307 = http_error_308 = http_error_302
 
     inf_msg = "The HTTP server returned a redirect error that would " \
               "lead to an infinite loop.\n" \
@@ -907,9 +878,9 @@ def find_user_password(self, realm, authuri):
 
 class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm):
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self):
         self.authenticated = {}
-        super().__init__(*args, **kwargs)
+        super().__init__()
 
     def add_password(self, realm, uri, user, passwd, is_authenticated=False):
         self.update_authenticated(uri, is_authenticated)
@@ -1255,8 +1226,8 @@ def http_error_407(self, req, fp, code, msg, headers):
 
 class AbstractHTTPHandler(BaseHandler):
 
-    def __init__(self, debuglevel=0):
-        self._debuglevel = debuglevel
+    def __init__(self, debuglevel=None):
+        self._debuglevel = debuglevel if debuglevel is not None else http.client.HTTPConnection.debuglevel
 
     def set_http_debuglevel(self, level):
         self._debuglevel = level
@@ -1382,14 +1353,19 @@ def http_open(self, req):
 
     class HTTPSHandler(AbstractHTTPHandler):
 
-        def __init__(self, debuglevel=0, context=None, check_hostname=None):
+        def __init__(self, debuglevel=None, context=None, check_hostname=None):
+            debuglevel = debuglevel if debuglevel is not None else http.client.HTTPSConnection.debuglevel
             AbstractHTTPHandler.__init__(self, debuglevel)
+            if context is None:
+                http_version = http.client.HTTPSConnection._http_vsn
+                context = http.client._create_https_context(http_version)
+            if check_hostname is not None:
+                context.check_hostname = check_hostname
             self._context = context
-            self._check_hostname = check_hostname
 
         def https_open(self, req):
             return self.do_open(http.client.HTTPSConnection, req,
-                context=self._context, check_hostname=self._check_hostname)
+                                context=self._context)
 
         https_request = AbstractHTTPHandler.do_request_
 
@@ -1561,6 +1537,7 @@ def ftp_open(self, req):
         dirs, file = dirs[:-1], dirs[-1]
         if dirs and not dirs[0]:
             dirs = dirs[1:]
+        fw = None
         try:
             fw = self.connect_ftp(user, passwd, host, port, dirs, req.timeout)
             type = file and 'I' or 'D'
@@ -1578,9 +1555,12 @@ def ftp_open(self, req):
                 headers += "Content-length: %d\n" % retrlen
             headers = email.message_from_string(headers)
             return addinfourl(fp, headers, req.full_url)
-        except ftplib.all_errors as exp:
-            exc = URLError('ftp error: %r' % exp)
-            raise exc.with_traceback(sys.exc_info()[2])
+        except Exception as exp:
+            if fw is not None and not fw.keepalive:
+                fw.close()
+            if isinstance(exp, ftplib.all_errors):
+                raise URLError(exp) from exp
+            raise
 
     def connect_ftp(self, user, passwd, host, port, dirs, timeout):
         return ftpwrapper(user, passwd, host, port, dirs, timeout,
@@ -1604,14 +1584,15 @@ def setMaxConns(self, m):
 
     def connect_ftp(self, user, passwd, host, port, dirs, timeout):
         key = user, host, port, '/'.join(dirs), timeout
-        if key in self.cache:
-            self.timeout[key] = time.time() + self.delay
-        else:
-            self.cache[key] = ftpwrapper(user, passwd, host, port,
-                                         dirs, timeout)
-            self.timeout[key] = time.time() + self.delay
+        conn = self.cache.get(key)
+        if conn is None or not conn.keepalive:
+            if conn is not None:
+                conn.close()
+            conn = self.cache[key] = ftpwrapper(user, passwd, host, port,
+                                                dirs, timeout)
+        self.timeout[key] = time.time() + self.delay
         self.check_cache()
-        return self.cache[key]
+        return conn
 
     def check_cache(self):
         # first check for old ones
@@ -1681,12 +1662,27 @@ def data_open(self, req):
     def url2pathname(pathname):
         """OS-specific conversion from a relative URL of the 'file' scheme
         to a file system path; not recommended for general use."""
-        return unquote(pathname)
+        if pathname[:3] == '///':
+            # URL has an empty authority section, so the path begins on the
+            # third character.
+            pathname = pathname[2:]
+        elif pathname[:12] == '//localhost/':
+            # Skip past 'localhost' authority.
+            pathname = pathname[11:]
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        return unquote(pathname, encoding=encoding, errors=errors)
 
     def pathname2url(pathname):
         """OS-specific conversion from a file system path to a relative URL
         of the 'file' scheme; not recommended for general use."""
-        return quote(pathname)
+        if pathname[:2] == '//':
+            # Add explicitly empty authority to avoid interpreting the path
+            # as authority.
+            pathname = '//' + pathname
+        encoding = sys.getfilesystemencoding()
+        errors = sys.getfilesystemencodeerrors()
+        return quote(pathname, encoding=encoding, errors=errors)
 
 
 ftpcache = {}
@@ -1791,7 +1787,7 @@ def open(self, fullurl, data=None):
         except (HTTPError, URLError):
             raise
         except OSError as msg:
-            raise OSError('socket error', msg).with_traceback(sys.exc_info()[2])
+            raise OSError('socket error', msg) from msg
 
     def open_unknown(self, fullurl, data=None):
         """Overridable interface to open unknown URL type."""
@@ -1845,10 +1841,7 @@ def retrieve(self, url, filename=None, reporthook=None, data=None):
                     size = int(headers["Content-Length"])
                 if reporthook:
                     reporthook(blocknum, bs, size)
-                while 1:
-                    block = fp.read(bs)
-                    if not block:
-                        break
+                while block := fp.read(bs):
                     read += len(block)
                     tfp.write(block)
                     blocknum += 1
@@ -1988,9 +1981,17 @@ def http_error_default(self, url, fp, errcode, errmsg, headers):
 
     if _have_ssl:
         def _https_connection(self, host):
-            return http.client.HTTPSConnection(host,
-                                           key_file=self.key_file,
-                                           cert_file=self.cert_file)
+            if self.key_file or self.cert_file:
+                http_version = http.client.HTTPSConnection._http_vsn
+                context = http.client._create_https_context(http_version)
+                context.load_cert_chain(self.cert_file, self.key_file)
+                # cert and key file means the user wants to authenticate.
+                # enable TLS 1.3 PHA implicitly even for custom contexts.
+                if context.post_handshake_auth is not None:
+                    context.post_handshake_auth = True
+            else:
+                context = None
+            return http.client.HTTPSConnection(host, context=context)
 
         def open_https(self, url, data=None):
             """Use HTTPS protocol."""
@@ -2093,7 +2094,7 @@ def open_ftp(self, url):
             headers = email.message_from_string(headers)
             return addinfourl(fp, headers, "ftp:" + url)
         except ftperrors() as exp:
-            raise URLError('ftp error %r' % exp).with_traceback(sys.exc_info()[2])
+            raise URLError(f'ftp error: {exp}') from exp
 
     def open_data(self, url, data=None):
         """Use "data" URL."""
@@ -2211,6 +2212,13 @@ def http_error_307(self, url, fp, errcode, errmsg, headers, data=None):
         else:
             return self.http_error_default(url, fp, errcode, errmsg, headers)
 
+    def http_error_308(self, url, fp, errcode, errmsg, headers, data=None):
+        """Error 308 -- relocated, but turn POST into error."""
+        if data is None:
+            return self.http_error_301(url, fp, errcode, errmsg, headers, data)
+        else:
+            return self.http_error_default(url, fp, errcode, errmsg, headers)
+
     def http_error_401(self, url, fp, errcode, errmsg, headers, data=None,
             retry=False):
         """Error 401 -- authentication required.
@@ -2436,8 +2444,7 @@ def retrfile(self, file, type):
                 conn, retrlen = self.ftp.ntransfercmd(cmd)
             except ftplib.error_perm as reason:
                 if str(reason)[:3] != '550':
-                    raise URLError('ftp error: %r' % reason).with_traceback(
-                        sys.exc_info()[2])
+                    raise URLError(f'ftp error: {reason}') from reason
         if not conn:
             # Set transfer mode to ASCII!
             self.ftp.voidcmd('TYPE A')
@@ -2464,7 +2471,13 @@ def retrfile(self, file, type):
         return (ftpobj, retrlen)
 
     def endtransfer(self):
+        if not self.busy:
+            return
         self.busy = 0
+        try:
+            self.ftp.voidresp()
+        except ftperrors():
+            pass
 
     def close(self):
         self.keepalive = False
@@ -2492,28 +2505,34 @@ def getproxies_environment():
     this seems to be the standard convention.  If you need a
     different way, you can pass a proxies dictionary to the
     [Fancy]URLopener constructor.
-
     """
-    proxies = {}
     # in order to prefer lowercase variables, process environment in
     # two passes: first matches any, second pass matches lowercase only
-    for name, value in os.environ.items():
-        name = name.lower()
-        if value and name[-6:] == '_proxy':
-            proxies[name[:-6]] = value
+
+    # select only environment variables which end in (after making lowercase) _proxy
+    proxies = {}
+    environment = []
+    for name in os.environ:
+        # fast screen underscore position before more expensive case-folding
+        if len(name) > 5 and name[-6] == "_" and name[-5:].lower() == "proxy":
+            value = os.environ[name]
+            proxy_name = name[:-6].lower()
+            environment.append((name, value, proxy_name))
+            if value:
+                proxies[proxy_name] = value
     # CVE-2016-1000110 - If we are running as CGI script, forget HTTP_PROXY
     # (non-all-lowercase) as it may be set from the web server by a "Proxy:"
     # header from the client
     # If "proxy" is lowercase, it will still be used thanks to the next block
     if 'REQUEST_METHOD' in os.environ:
         proxies.pop('http', None)
-    for name, value in os.environ.items():
+    for name, value, proxy_name in environment:
+        # not case-folded, checking here for lower-case env vars only
         if name[-6:] == '_proxy':
-            name = name.lower()
             if value:
-                proxies[name[:-6]] = value
+                proxies[proxy_name] = value
             else:
-                proxies.pop(name[:-6], None)
+                proxies.pop(proxy_name, None)
     return proxies
 
 def proxy_bypass_environment(host, proxies=None):
@@ -2566,6 +2585,7 @@ def _proxy_bypass_macosx_sysconf(host, proxy_settings):
     }
     """
     from fnmatch import fnmatch
+    from ipaddress import AddressValueError, IPv4Address
 
     hostonly, port = _splitport(host)
 
@@ -2582,20 +2602,17 @@ def ip2num(ipAddr):
             return True
 
     hostIP = None
+    try:
+        hostIP = int(IPv4Address(hostonly))
+    except AddressValueError:
+        pass
 
     for value in proxy_settings.get('exceptions', ()):
         # Items in the list are strings like these: *.local, 169.254/16
         if not value: continue
 
         m = re.match(r"(\d+(?:\.\d+)*)(/\d+)?", value)
-        if m is not None:
-            if hostIP is None:
-                try:
-                    hostIP = socket.gethostbyname(hostonly)
-                    hostIP = ip2num(hostIP)
-                except OSError:
-                    continue
-
+        if m is not None and hostIP is not None:
             base = ip2num(m.group(1))
             mask = m.group(2)
             if mask is None:
@@ -2618,6 +2635,31 @@ def ip2num(ipAddr):
     return False
 
 
+# Same as _proxy_bypass_macosx_sysconf, testable on all platforms
+def _proxy_bypass_winreg_override(host, override):
+    """Return True if the host should bypass the proxy server.
+
+    The proxy override list is obtained from the Windows
+    Internet settings proxy override registry value.
+
+    An example of a proxy override value is:
+    "www.example.com;*.example.net; 192.168.0.1"
+    """
+    from fnmatch import fnmatch
+
+    host, _ = _splitport(host)
+    proxy_override = override.split(';')
+    for test in proxy_override:
+        test = test.strip()
+        # "<local>" should bypass the proxy server for all intranet addresses
+        if test == '<local>':
+            if '.' not in host:
+                return True
+        elif fnmatch(host, test):
+            return True
+    return False
+
+
 if sys.platform == 'darwin':
     from _scproxy import _get_proxy_settings, _get_proxies
 
@@ -2716,7 +2758,7 @@ def proxy_bypass_registry(host):
             import winreg
         except ImportError:
             # Std modules, so should be around - but you never know!
-            return 0
+            return False
         try:
             internetSettings = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                 r'Software\Microsoft\Windows\CurrentVersion\Internet Settings')
@@ -2726,40 +2768,10 @@ def proxy_bypass_registry(host):
                                                      'ProxyOverride')[0])
             # ^^^^ Returned as Unicode but problems if not converted to ASCII
         except OSError:
-            return 0
+            return False
         if not proxyEnable or not proxyOverride:
-            return 0
-        # try to make a host list from name and IP address.
-        rawHost, port = _splitport(host)
-        host = [rawHost]
-        try:
-            addr = socket.gethostbyname(rawHost)
-            if addr != rawHost:
-                host.append(addr)
-        except OSError:
-            pass
-        try:
-            fqdn = socket.getfqdn(rawHost)
-            if fqdn != rawHost:
-                host.append(fqdn)
-        except OSError:
-            pass
-        # make a check value list from the registry entry: replace the
-        # '<local>' string by the localhost entry and the corresponding
-        # canonical entry.
-        proxyOverride = proxyOverride.split(';')
-        # now check if we match one of the registry values.
-        for test in proxyOverride:
-            if test == '<local>':
-                if '.' not in rawHost:
-                    return 1
-            test = test.replace(".", r"\.")     # mask dots
-            test = test.replace("*", r".*")     # change glob sequence
-            test = test.replace("?", r".")      # change glob char
-            for val in host:
-                if re.match(test, val, re.I):
-                    return 1
-        return 0
+            return False
+        return _proxy_bypass_winreg_override(host, proxyOverride)
 
     def proxy_bypass(host):
         """Return True, if host should be bypassed.
diff --git a/Lib/urllib/robotparser.py b/Lib/urllib/robotparser.py
index c58565e394..63689816f3 100644
--- a/Lib/urllib/robotparser.py
+++ b/Lib/urllib/robotparser.py
@@ -11,6 +11,8 @@
 """
 
 import collections
+import re
+import urllib.error
 import urllib.parse
 import urllib.request
 
@@ -19,6 +21,19 @@
 RequestRate = collections.namedtuple("RequestRate", "requests seconds")
 
 
+def normalize(path):
+    unquoted = urllib.parse.unquote(path, errors='surrogateescape')
+    return urllib.parse.quote(unquoted, errors='surrogateescape')
+
+def normalize_path(path):
+    path, sep, query = path.partition('?')
+    path = normalize(path)
+    if sep:
+        query = re.sub(r'[^=&]+', lambda m: normalize(m[0]), query)
+        path += '?' + query
+    return path
+
+
 class RobotFileParser:
     """ This class provides a set of methods to read, parse and answer
     questions about a single robots.txt file.
@@ -54,7 +69,7 @@ def modified(self):
     def set_url(self, url):
         """Sets the URL referring to a robots.txt file."""
         self.url = url
-        self.host, self.path = urllib.parse.urlparse(url)[1:3]
+        self.host, self.path = urllib.parse.urlsplit(url)[1:3]
 
     def read(self):
         """Reads the robots.txt URL and feeds it to the parser."""
@@ -65,9 +80,10 @@ def read(self):
                 self.disallow_all = True
             elif err.code >= 400 and err.code < 500:
                 self.allow_all = True
+            err.close()
         else:
             raw = f.read()
-            self.parse(raw.decode("utf-8").splitlines())
+            self.parse(raw.decode("utf-8", "surrogateescape").splitlines())
 
     def _add_entry(self, entry):
         if "*" in entry.useragents:
@@ -111,7 +127,7 @@ def parse(self, lines):
             line = line.split(':', 1)
             if len(line) == 2:
                 line[0] = line[0].strip().lower()
-                line[1] = urllib.parse.unquote(line[1].strip())
+                line[1] = line[1].strip()
                 if line[0] == "user-agent":
                     if state == 2:
                         self._add_entry(entry)
@@ -165,10 +181,9 @@ def can_fetch(self, useragent, url):
             return False
         # search for given user agent matches
         # the first match counts
-        parsed_url = urllib.parse.urlparse(urllib.parse.unquote(url))
-        url = urllib.parse.urlunparse(('','',parsed_url.path,
-            parsed_url.params,parsed_url.query, parsed_url.fragment))
-        url = urllib.parse.quote(url)
+        parsed_url = urllib.parse.urlsplit(url)
+        url = urllib.parse.urlunsplit(('', '', *parsed_url[2:]))
+        url = normalize_path(url)
         if not url:
             url = "/"
         for entry in self.entries:
@@ -211,7 +226,6 @@ def __str__(self):
             entries = entries + [self.default_entry]
         return '\n\n'.join(map(str, entries))
 
-
 class RuleLine:
     """A rule line is a single "Allow:" (allowance==True) or "Disallow:"
        (allowance==False) followed by a path."""
@@ -219,8 +233,7 @@ def __init__(self, path, allowance):
         if path == '' and not allowance:
             # an empty value means allow all
             allowance = True
-        path = urllib.parse.urlunparse(urllib.parse.urlparse(path))
-        self.path = urllib.parse.quote(path)
+        self.path = normalize_path(path)
         self.allowance = allowance
 
     def applies_to(self, filename):
@@ -266,7 +279,7 @@ def applies_to(self, useragent):
     def allowance(self, filename):
         """Preconditions:
         - our agent applies to this entry
-        - filename is URL decoded"""
+        - filename is URL encoded"""
         for line in self.rulelines:
             if line.applies_to(filename):
                 return line.allowance
diff --git a/Lib/uuid.py b/Lib/uuid.py
index c286eac38e..55f46eb510 100644
--- a/Lib/uuid.py
+++ b/Lib/uuid.py
@@ -572,39 +572,43 @@ 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)
     _UuidCreate = getattr(_uuid, "UuidCreate", None)
 except ImportError:
     _uuid = None
     _generate_time_safe = None
+    _has_stable_extractable_node = False
     _UuidCreate = None
 
 
 def _unix_getnode():
     """Get the hardware address on Unix using the _uuid extension module."""
-    if _generate_time_safe:
+    if _generate_time_safe and _has_stable_extractable_node:
         uuid_time, _ = _generate_time_safe()
         return UUID(bytes=uuid_time).node
 
 def _windll_getnode():
     """Get the hardware address on Windows using the _uuid extension module."""
-    if _UuidCreate:
+    if _UuidCreate and _has_stable_extractable_node:
         uuid_bytes = _UuidCreate()
         return UUID(bytes_le=uuid_bytes).node
 
 def _random_getnode():
     """Get a random node ID."""
-    # RFC 4122, $4.1.6 says "For systems with no IEEE address, a randomly or
-    # pseudo-randomly generated value may be used; see Section 4.5.  The
-    # multicast bit must be set in such addresses, in order that they will
-    # never conflict with addresses obtained from network cards."
+    # RFC 9562, §6.10-3 says that
+    #
+    #   Implementations MAY elect to obtain a 48-bit cryptographic-quality
+    #   random number as per Section 6.9 to use as the Node ID. [...] [and]
+    #   implementations MUST set the least significant bit of the first octet
+    #   of the Node ID to 1. This bit is the unicast or multicast bit, which
+    #   will never be set in IEEE 802 addresses obtained from network cards.
     #
     # The "multicast bit" of a MAC address is defined to be "the least
     # significant bit of the first octet".  This works out to be the 41st bit
     # counting from 1 being the least significant bit, or 1<<40.
     #
     # See https://en.wikipedia.org/w/index.php?title=MAC_address&oldid=1128764812#Universal_vs._local_(U/L_bit)
-    import random
-    return random.getrandbits(48) | (1 << 40)
+    return int.from_bytes(os.urandom(6)) | (1 << 40)
 
 
 # _OS_GETTERS, when known, are targeted for a specific OS or platform.
diff --git a/Lib/venv/__init__.py b/Lib/venv/__init__.py
index 6f1af294ae..f7a6d26140 100644
--- a/Lib/venv/__init__.py
+++ b/Lib/venv/__init__.py
@@ -11,9 +11,10 @@
 import sys
 import sysconfig
 import types
+import shlex
 
 
-CORE_VENV_DEPS = ('pip', 'setuptools')
+CORE_VENV_DEPS = ('pip',)
 logger = logging.getLogger(__name__)
 
 
@@ -41,20 +42,24 @@ class EnvBuilder:
                      environment
     :param prompt: Alternative terminal prefix for the environment.
     :param upgrade_deps: Update the base venv modules to the latest on PyPI
+    :param scm_ignore_files: Create ignore files for the SCMs specified by the
+                             iterable.
     """
 
     def __init__(self, system_site_packages=False, clear=False,
                  symlinks=False, upgrade=False, with_pip=False, prompt=None,
-                 upgrade_deps=False):
+                 upgrade_deps=False, *, scm_ignore_files=frozenset()):
         self.system_site_packages = system_site_packages
         self.clear = clear
         self.symlinks = symlinks
         self.upgrade = upgrade
         self.with_pip = with_pip
+        self.orig_prompt = prompt
         if prompt == '.':  # see bpo-38901
             prompt = os.path.basename(os.getcwd())
         self.prompt = prompt
         self.upgrade_deps = upgrade_deps
+        self.scm_ignore_files = frozenset(map(str.lower, scm_ignore_files))
 
     def create(self, env_dir):
         """
@@ -65,6 +70,8 @@ def create(self, env_dir):
         """
         env_dir = os.path.abspath(env_dir)
         context = self.ensure_directories(env_dir)
+        for scm in self.scm_ignore_files:
+            getattr(self, f"create_{scm}_ignore_file")(context)
         # See issue 24875. We need system_site_packages to be False
         # until after pip is installed.
         true_system_site_packages = self.system_site_packages
@@ -92,6 +99,42 @@ def clear_directory(self, path):
             elif os.path.isdir(fn):
                 shutil.rmtree(fn)
 
+    def _venv_path(self, env_dir, name):
+        vars = {
+            'base': env_dir,
+            'platbase': env_dir,
+            'installed_base': env_dir,
+            'installed_platbase': env_dir,
+        }
+        return sysconfig.get_path(name, scheme='venv', vars=vars)
+
+    @classmethod
+    def _same_path(cls, path1, path2):
+        """Check whether two paths appear the same.
+
+        Whether they refer to the same file is irrelevant; we're testing for
+        whether a human reader would look at the path string and easily tell
+        that they're the same file.
+        """
+        if sys.platform == 'win32':
+            if os.path.normcase(path1) == os.path.normcase(path2):
+                return True
+            # gh-90329: Don't display a warning for short/long names
+            import _winapi
+            try:
+                path1 = _winapi.GetLongPathName(os.fsdecode(path1))
+            except OSError:
+                pass
+            try:
+                path2 = _winapi.GetLongPathName(os.fsdecode(path2))
+            except OSError:
+                pass
+            if os.path.normcase(path1) == os.path.normcase(path2):
+                return True
+            return False
+        else:
+            return path1 == path2
+
     def ensure_directories(self, env_dir):
         """
         Create the directories for the environment.
@@ -106,31 +149,38 @@ def create_if_needed(d):
             elif os.path.islink(d) or os.path.isfile(d):
                 raise ValueError('Unable to create directory %r' % d)
 
+        if os.pathsep in os.fspath(env_dir):
+            raise ValueError(f'Refusing to create a venv in {env_dir} because '
+                             f'it contains the PATH separator {os.pathsep}.')
         if os.path.exists(env_dir) and self.clear:
             self.clear_directory(env_dir)
         context = types.SimpleNamespace()
         context.env_dir = env_dir
         context.env_name = os.path.split(env_dir)[1]
-        prompt = self.prompt if self.prompt is not None else context.env_name
-        context.prompt = '(%s) ' % prompt
+        context.prompt = self.prompt if self.prompt is not None else context.env_name
         create_if_needed(env_dir)
         executable = sys._base_executable
+        if not executable:  # see gh-96861
+            raise ValueError('Unable to determine path to the running '
+                             'Python interpreter. Provide an explicit path or '
+                             'check that your PATH environment variable is '
+                             'correctly set.')
         dirname, exename = os.path.split(os.path.abspath(executable))
+        if sys.platform == 'win32':
+            # Always create the simplest name in the venv. It will either be a
+            # link back to executable, or a copy of the appropriate launcher
+            _d = '_d' if os.path.splitext(exename)[0].endswith('_d') else ''
+            exename = f'python{_d}.exe'
         context.executable = executable
         context.python_dir = dirname
         context.python_exe = exename
-        if sys.platform == 'win32':
-            binname = 'Scripts'
-            incpath = 'Include'
-            libpath = os.path.join(env_dir, 'Lib', 'site-packages')
-        else:
-            binname = 'bin'
-            incpath = 'include'
-            libpath = os.path.join(env_dir, 'lib',
-                                   'python%d.%d' % sys.version_info[:2],
-                                   'site-packages')
-        context.inc_path = path = os.path.join(env_dir, incpath)
-        create_if_needed(path)
+        binpath = self._venv_path(env_dir, 'scripts')
+        incpath = self._venv_path(env_dir, 'include')
+        libpath = self._venv_path(env_dir, 'purelib')
+
+        context.inc_path = incpath
+        create_if_needed(incpath)
+        context.lib_path = libpath
         create_if_needed(libpath)
         # Issue 21197: create lib64 as a symlink to lib on 64-bit non-OS X POSIX
         if ((sys.maxsize > 2**32) and (os.name == 'posix') and
@@ -138,8 +188,8 @@ def create_if_needed(d):
             link_path = os.path.join(env_dir, 'lib64')
             if not os.path.exists(link_path):   # Issue #21643
                 os.symlink('lib', link_path)
-        context.bin_path = binpath = os.path.join(env_dir, binname)
-        context.bin_name = binname
+        context.bin_path = binpath
+        context.bin_name = os.path.relpath(binpath, env_dir)
         context.env_exe = os.path.join(binpath, exename)
         create_if_needed(binpath)
         # Assign and update the command to use when launching the newly created
@@ -149,7 +199,7 @@ def create_if_needed(d):
             # bpo-45337: Fix up env_exec_cmd to account for file system redirections.
             # Some redirects only apply to CreateFile and not CreateProcess
             real_env_exe = os.path.realpath(context.env_exe)
-            if os.path.normcase(real_env_exe) != os.path.normcase(context.env_exe):
+            if not self._same_path(real_env_exe, context.env_exe):
                 logger.warning('Actual environment location may have moved due to '
                                'redirects, links or junctions.\n'
                                '  Requested location: "%s"\n'
@@ -178,86 +228,84 @@ def create_configuration(self, context):
             f.write('version = %d.%d.%d\n' % sys.version_info[:3])
             if self.prompt is not None:
                 f.write(f'prompt = {self.prompt!r}\n')
-
-    if os.name != 'nt':
-        def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
-            """
-            Try symlinking a file, and if that fails, fall back to copying.
-            """
-            force_copy = not self.symlinks
-            if not force_copy:
-                try:
-                    if not os.path.islink(dst): # can't link to itself!
-                        if relative_symlinks_ok:
-                            assert os.path.dirname(src) == os.path.dirname(dst)
-                            os.symlink(os.path.basename(src), dst)
-                        else:
-                            os.symlink(src, dst)
-                except Exception:   # may need to use a more specific exception
-                    logger.warning('Unable to symlink %r to %r', src, dst)
-                    force_copy = True
-            if force_copy:
-                shutil.copyfile(src, dst)
-    else:
-        def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
-            """
-            Try symlinking a file, and if that fails, fall back to copying.
-            """
-            bad_src = os.path.lexists(src) and not os.path.exists(src)
-            if self.symlinks and not bad_src and not os.path.islink(dst):
-                try:
+            f.write('executable = %s\n' % os.path.realpath(sys.executable))
+            args = []
+            nt = os.name == 'nt'
+            if nt and self.symlinks:
+                args.append('--symlinks')
+            if not nt and not self.symlinks:
+                args.append('--copies')
+            if not self.with_pip:
+                args.append('--without-pip')
+            if self.system_site_packages:
+                args.append('--system-site-packages')
+            if self.clear:
+                args.append('--clear')
+            if self.upgrade:
+                args.append('--upgrade')
+            if self.upgrade_deps:
+                args.append('--upgrade-deps')
+            if self.orig_prompt is not None:
+                args.append(f'--prompt="{self.orig_prompt}"')
+            if not self.scm_ignore_files:
+                args.append('--without-scm-ignore-files')
+
+            args.append(context.env_dir)
+            args = ' '.join(args)
+            f.write(f'command = {sys.executable} -m venv {args}\n')
+
+    def symlink_or_copy(self, src, dst, relative_symlinks_ok=False):
+        """
+        Try symlinking a file, and if that fails, fall back to copying.
+        (Unused on Windows, because we can't just copy a failed symlink file: we
+        switch to a different set of files instead.)
+        """
+        assert os.name != 'nt'
+        force_copy = not self.symlinks
+        if not force_copy:
+            try:
+                if not os.path.islink(dst):  # can't link to itself!
                     if relative_symlinks_ok:
                         assert os.path.dirname(src) == os.path.dirname(dst)
                         os.symlink(os.path.basename(src), dst)
                     else:
                         os.symlink(src, dst)
-                    return
-                except Exception:   # may need to use a more specific exception
-                    logger.warning('Unable to symlink %r to %r', src, dst)
-
-            # On Windows, we rewrite symlinks to our base python.exe into
-            # copies of venvlauncher.exe
-            basename, ext = os.path.splitext(os.path.basename(src))
-            srcfn = os.path.join(os.path.dirname(__file__),
-                                 "scripts",
-                                 "nt",
-                                 basename + ext)
-            # Builds or venv's from builds need to remap source file
-            # locations, as we do not put them into Lib/venv/scripts
-            if sysconfig.is_python_build(True) or not os.path.isfile(srcfn):
-                if basename.endswith('_d'):
-                    ext = '_d' + ext
-                    basename = basename[:-2]
-                if basename == 'python':
-                    basename = 'venvlauncher'
-                elif basename == 'pythonw':
-                    basename = 'venvwlauncher'
-                src = os.path.join(os.path.dirname(src), basename + ext)
-            else:
-                src = srcfn
-            if not os.path.exists(src):
-                if not bad_src:
-                    logger.warning('Unable to copy %r', src)
-                return
-
+            except Exception:   # may need to use a more specific exception
+                logger.warning('Unable to symlink %r to %r', src, dst)
+                force_copy = True
+        if force_copy:
             shutil.copyfile(src, dst)
 
-    def setup_python(self, context):
+    def create_git_ignore_file(self, context):
         """
-        Set up a Python executable in the environment.
+        Create a .gitignore file in the environment directory.
 
-        :param context: The information for the environment creation request
-                        being processed.
+        The contents of the file cause the entire environment directory to be
+        ignored by git.
         """
-        binpath = context.bin_path
-        path = context.env_exe
-        copier = self.symlink_or_copy
-        dirname = context.python_dir
-        if os.name != 'nt':
+        gitignore_path = os.path.join(context.env_dir, '.gitignore')
+        with open(gitignore_path, 'w', encoding='utf-8') as file:
+            file.write('# Created by venv; '
+                       'see https://docs.python.org/3/library/venv.html\n')
+            file.write('*\n')
+
+    if os.name != 'nt':
+        def setup_python(self, context):
+            """
+            Set up a Python executable in the environment.
+
+            :param context: The information for the environment creation request
+                            being processed.
+            """
+            binpath = context.bin_path
+            path = context.env_exe
+            copier = self.symlink_or_copy
+            dirname = context.python_dir
             copier(context.executable, path)
             if not os.path.islink(path):
                 os.chmod(path, 0o755)
-            for suffix in ('python', 'python3', f'python3.{sys.version_info[1]}'):
+            for suffix in ('python', 'python3',
+                           f'python3.{sys.version_info[1]}'):
                 path = os.path.join(binpath, suffix)
                 if not os.path.exists(path):
                     # Issue 18807: make copies if
@@ -265,32 +313,107 @@ def setup_python(self, context):
                     copier(context.env_exe, path, relative_symlinks_ok=True)
                     if not os.path.islink(path):
                         os.chmod(path, 0o755)
-        else:
-            if self.symlinks:
-                # For symlinking, we need a complete copy of the root directory
-                # If symlinks fail, you'll get unnecessary copies of files, but
-                # we assume that if you've opted into symlinks on Windows then
-                # you know what you're doing.
-                suffixes = [
-                    f for f in os.listdir(dirname) if
-                    os.path.normcase(os.path.splitext(f)[1]) in ('.exe', '.dll')
-                ]
-                if sysconfig.is_python_build(True):
-                    suffixes = [
-                        f for f in suffixes if
-                        os.path.normcase(f).startswith(('python', 'vcruntime'))
-                    ]
+
+    else:
+        def setup_python(self, context):
+            """
+            Set up a Python executable in the environment.
+
+            :param context: The information for the environment creation request
+                            being processed.
+            """
+            binpath = context.bin_path
+            dirname = context.python_dir
+            exename = os.path.basename(context.env_exe)
+            exe_stem = os.path.splitext(exename)[0]
+            exe_d = '_d' if os.path.normcase(exe_stem).endswith('_d') else ''
+            if sysconfig.is_python_build():
+                scripts = dirname
             else:
-                suffixes = {'python.exe', 'python_d.exe', 'pythonw.exe', 'pythonw_d.exe'}
-                base_exe = os.path.basename(context.env_exe)
-                suffixes.add(base_exe)
+                scripts = os.path.join(os.path.dirname(__file__),
+                                       'scripts', 'nt')
+            if not sysconfig.get_config_var("Py_GIL_DISABLED"):
+                python_exe = os.path.join(dirname, f'python{exe_d}.exe')
+                pythonw_exe = os.path.join(dirname, f'pythonw{exe_d}.exe')
+                link_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                }
+                python_exe = os.path.join(scripts, f'venvlauncher{exe_d}.exe')
+                pythonw_exe = os.path.join(scripts, f'venvwlauncher{exe_d}.exe')
+                copy_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                }
+            else:
+                exe_t = f'3.{sys.version_info[1]}t'
+                python_exe = os.path.join(dirname, f'python{exe_t}{exe_d}.exe')
+                pythonw_exe = os.path.join(dirname, f'pythonw{exe_t}{exe_d}.exe')
+                link_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    f'python{exe_t}.exe': python_exe,
+                    f'python{exe_t}{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                    f'pythonw{exe_t}.exe': pythonw_exe,
+                    f'pythonw{exe_t}{exe_d}.exe': pythonw_exe,
+                }
+                python_exe = os.path.join(scripts, f'venvlaunchert{exe_d}.exe')
+                pythonw_exe = os.path.join(scripts, f'venvwlaunchert{exe_d}.exe')
+                copy_sources = {
+                    'python.exe': python_exe,
+                    f'python{exe_d}.exe': python_exe,
+                    f'python{exe_t}.exe': python_exe,
+                    f'python{exe_t}{exe_d}.exe': python_exe,
+                    'pythonw.exe': pythonw_exe,
+                    f'pythonw{exe_d}.exe': pythonw_exe,
+                    f'pythonw{exe_t}.exe': pythonw_exe,
+                    f'pythonw{exe_t}{exe_d}.exe': pythonw_exe,
+                }
+
+            do_copies = True
+            if self.symlinks:
+                do_copies = False
+                # For symlinking, we need all the DLLs to be available alongside
+                # the executables.
+                link_sources.update({
+                    f: os.path.join(dirname, f) for f in os.listdir(dirname)
+                    if os.path.normcase(f).startswith(('python', 'vcruntime'))
+                    and os.path.normcase(os.path.splitext(f)[1]) == '.dll'
+                })
+
+                to_unlink = []
+                for dest, src in link_sources.items():
+                    dest = os.path.join(binpath, dest)
+                    try:
+                        os.symlink(src, dest)
+                        to_unlink.append(dest)
+                    except OSError:
+                        logger.warning('Unable to symlink %r to %r', src, dest)
+                        do_copies = True
+                        for f in to_unlink:
+                            try:
+                                os.unlink(f)
+                            except OSError:
+                                logger.warning('Failed to clean up symlink %r',
+                                               f)
+                        logger.warning('Retrying with copies')
+                        break
 
-            for suffix in suffixes:
-                src = os.path.join(dirname, suffix)
-                if os.path.lexists(src):
-                    copier(src, os.path.join(binpath, suffix))
+            if do_copies:
+                for dest, src in copy_sources.items():
+                    dest = os.path.join(binpath, dest)
+                    try:
+                        shutil.copy2(src, dest)
+                    except OSError:
+                        logger.warning('Unable to copy %r to %r', src, dest)
 
-            if sysconfig.is_python_build(True):
+            if sysconfig.is_python_build():
                 # copy init.tcl
                 for root, dirs, files in os.walk(context.python_dir):
                     if 'init.tcl' in files:
@@ -303,14 +426,25 @@ def setup_python(self, context):
                         shutil.copyfile(src, dst)
                         break
 
+    def _call_new_python(self, context, *py_args, **kwargs):
+        """Executes the newly created Python using safe-ish options"""
+        # gh-98251: We do not want to just use '-I' because that masks
+        # legitimate user preferences (such as not writing bytecode). All we
+        # really need is to ensure that the path variables do not overrule
+        # normal venv handling.
+        args = [context.env_exec_cmd, *py_args]
+        kwargs['env'] = env = os.environ.copy()
+        env['VIRTUAL_ENV'] = context.env_dir
+        env.pop('PYTHONHOME', None)
+        env.pop('PYTHONPATH', None)
+        kwargs['cwd'] = context.env_dir
+        kwargs['executable'] = context.env_exec_cmd
+        subprocess.check_output(args, **kwargs)
+
     def _setup_pip(self, context):
         """Installs or upgrades pip in a virtual environment"""
-        # We run ensurepip in isolated mode to avoid side effects from
-        # environment vars, the current directory and anything else
-        # intended for the global Python environment
-        cmd = [context.env_exec_cmd, '-Im', 'ensurepip', '--upgrade',
-                                                         '--default-pip']
-        subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        self._call_new_python(context, '-m', 'ensurepip', '--upgrade',
+                              '--default-pip', stderr=subprocess.STDOUT)
 
     def setup_scripts(self, context):
         """
@@ -348,11 +482,41 @@ def replace_variables(self, text, context):
         :param context: The information for the environment creation request
                         being processed.
         """
-        text = text.replace('__VENV_DIR__', context.env_dir)
-        text = text.replace('__VENV_NAME__', context.env_name)
-        text = text.replace('__VENV_PROMPT__', context.prompt)
-        text = text.replace('__VENV_BIN_NAME__', context.bin_name)
-        text = text.replace('__VENV_PYTHON__', context.env_exe)
+        replacements = {
+            '__VENV_DIR__': context.env_dir,
+            '__VENV_NAME__': context.env_name,
+            '__VENV_PROMPT__': context.prompt,
+            '__VENV_BIN_NAME__': context.bin_name,
+            '__VENV_PYTHON__': context.env_exe,
+        }
+
+        def quote_ps1(s):
+            """
+            This should satisfy PowerShell quoting rules [1], unless the quoted
+            string is passed directly to Windows native commands [2].
+            [1]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules
+            [2]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing#passing-arguments-that-contain-quote-characters
+            """
+            s = s.replace("'", "''")
+            return f"'{s}'"
+
+        def quote_bat(s):
+            return s
+
+        # gh-124651: need to quote the template strings properly
+        quote = shlex.quote
+        script_path = context.script_path
+        if script_path.endswith('.ps1'):
+            quote = quote_ps1
+        elif script_path.endswith('.bat'):
+            quote = quote_bat
+        else:
+            # fallbacks to POSIX shell compliant quote
+            quote = shlex.quote
+
+        replacements = {key: quote(s) for key, s in replacements.items()}
+        for key, quoted in replacements.items():
+            text = text.replace(key, quoted)
         return text
 
     def install_scripts(self, context, path):
@@ -370,15 +534,22 @@ def install_scripts(self, context, path):
         """
         binpath = context.bin_path
         plen = len(path)
+        if os.name == 'nt':
+            def skip_file(f):
+                f = os.path.normcase(f)
+                return (f.startswith(('python', 'venv'))
+                        and f.endswith(('.exe', '.pdb')))
+        else:
+            def skip_file(f):
+                return False
         for root, dirs, files in os.walk(path):
-            if root == path: # at top-level, remove irrelevant dirs
+            if root == path:  # at top-level, remove irrelevant dirs
                 for d in dirs[:]:
                     if d not in ('common', os.name):
                         dirs.remove(d)
-                continue # ignore files in top level
+                continue  # ignore files in top level
             for f in files:
-                if (os.name == 'nt' and f.startswith('python')
-                        and f.endswith(('.exe', '.pdb'))):
+                if skip_file(f):
                     continue
                 srcfile = os.path.join(root, f)
                 suffix = root[plen:].split(os.sep)[2:]
@@ -389,116 +560,122 @@ def install_scripts(self, context, path):
                 if not os.path.exists(dstdir):
                     os.makedirs(dstdir)
                 dstfile = os.path.join(dstdir, f)
+                if os.name == 'nt' and srcfile.endswith(('.exe', '.pdb')):
+                    shutil.copy2(srcfile, dstfile)
+                    continue
                 with open(srcfile, 'rb') as f:
                     data = f.read()
-                if not srcfile.endswith(('.exe', '.pdb')):
-                    try:
-                        data = data.decode('utf-8')
-                        data = self.replace_variables(data, context)
-                        data = data.encode('utf-8')
-                    except UnicodeError as e:
-                        data = None
-                        logger.warning('unable to copy script %r, '
-                                       'may be binary: %s', srcfile, e)
-                if data is not None:
+                try:
+                    context.script_path = srcfile
+                    new_data = (
+                        self.replace_variables(data.decode('utf-8'), context)
+                            .encode('utf-8')
+                    )
+                except UnicodeError as e:
+                    logger.warning('unable to copy script %r, '
+                                   'may be binary: %s', srcfile, e)
+                    continue
+                if new_data == data:
+                    shutil.copy2(srcfile, dstfile)
+                else:
                     with open(dstfile, 'wb') as f:
-                        f.write(data)
+                        f.write(new_data)
                     shutil.copymode(srcfile, dstfile)
 
     def upgrade_dependencies(self, context):
         logger.debug(
             f'Upgrading {CORE_VENV_DEPS} packages in {context.bin_path}'
         )
-        cmd = [context.env_exec_cmd, '-m', 'pip', 'install', '--upgrade']
-        cmd.extend(CORE_VENV_DEPS)
-        subprocess.check_call(cmd)
+        self._call_new_python(context, '-m', 'pip', 'install', '--upgrade',
+                              *CORE_VENV_DEPS)
 
 
 def create(env_dir, system_site_packages=False, clear=False,
-           symlinks=False, with_pip=False, prompt=None, upgrade_deps=False):
+           symlinks=False, with_pip=False, prompt=None, upgrade_deps=False,
+           *, scm_ignore_files=frozenset()):
     """Create a virtual environment in a directory."""
     builder = EnvBuilder(system_site_packages=system_site_packages,
                          clear=clear, symlinks=symlinks, with_pip=with_pip,
-                         prompt=prompt, upgrade_deps=upgrade_deps)
+                         prompt=prompt, upgrade_deps=upgrade_deps,
+                         scm_ignore_files=scm_ignore_files)
     builder.create(env_dir)
 
+
 def main(args=None):
-    compatible = True
-    if sys.version_info < (3, 3):
-        compatible = False
-    elif not hasattr(sys, 'base_prefix'):
-        compatible = False
-    if not compatible:
-        raise ValueError('This script is only for use with Python >= 3.3')
+    import argparse
+
+    parser = argparse.ArgumentParser(prog=__name__,
+                                     description='Creates virtual Python '
+                                                 'environments in one or '
+                                                 'more target '
+                                                 'directories.',
+                                     epilog='Once an environment has been '
+                                            'created, you may wish to '
+                                            'activate it, e.g. by '
+                                            'sourcing an activate script '
+                                            'in its bin directory.')
+    parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
+                        help='A directory to create the environment in.')
+    parser.add_argument('--system-site-packages', default=False,
+                        action='store_true', dest='system_site',
+                        help='Give the virtual environment access to the '
+                             'system site-packages dir.')
+    if os.name == 'nt':
+        use_symlinks = False
     else:
-        import argparse
-
-        parser = argparse.ArgumentParser(prog=__name__,
-                                         description='Creates virtual Python '
-                                                     'environments in one or '
-                                                     'more target '
-                                                     'directories.',
-                                         epilog='Once an environment has been '
-                                                'created, you may wish to '
-                                                'activate it, e.g. by '
-                                                'sourcing an activate script '
-                                                'in its bin directory.')
-        parser.add_argument('dirs', metavar='ENV_DIR', nargs='+',
-                            help='A directory to create the environment in.')
-        parser.add_argument('--system-site-packages', default=False,
-                            action='store_true', dest='system_site',
-                            help='Give the virtual environment access to the '
-                                 'system site-packages dir.')
-        if os.name == 'nt':
-            use_symlinks = False
-        else:
-            use_symlinks = True
-        group = parser.add_mutually_exclusive_group()
-        group.add_argument('--symlinks', default=use_symlinks,
-                           action='store_true', dest='symlinks',
-                           help='Try to use symlinks rather than copies, '
-                                'when symlinks are not the default for '
-                                'the platform.')
-        group.add_argument('--copies', default=not use_symlinks,
-                           action='store_false', dest='symlinks',
-                           help='Try to use copies rather than symlinks, '
-                                'even when symlinks are the default for '
-                                'the platform.')
-        parser.add_argument('--clear', default=False, action='store_true',
-                            dest='clear', help='Delete the contents of the '
-                                               'environment directory if it '
-                                               'already exists, before '
-                                               'environment creation.')
-        parser.add_argument('--upgrade', default=False, action='store_true',
-                            dest='upgrade', help='Upgrade the environment '
-                                               'directory to use this version '
-                                               'of Python, assuming Python '
-                                               'has been upgraded in-place.')
-        parser.add_argument('--without-pip', dest='with_pip',
-                            default=True, action='store_false',
-                            help='Skips installing or upgrading pip in the '
-                                 'virtual environment (pip is bootstrapped '
-                                 'by default)')
-        parser.add_argument('--prompt',
-                            help='Provides an alternative prompt prefix for '
-                                 'this environment.')
-        parser.add_argument('--upgrade-deps', default=False, action='store_true',
-                            dest='upgrade_deps',
-                            help='Upgrade core dependencies: {} to the latest '
-                                 'version in PyPI'.format(
-                                 ' '.join(CORE_VENV_DEPS)))
-        options = parser.parse_args(args)
-        if options.upgrade and options.clear:
-            raise ValueError('you cannot supply --upgrade and --clear together.')
-        builder = EnvBuilder(system_site_packages=options.system_site,
-                             clear=options.clear,
-                             symlinks=options.symlinks,
-                             upgrade=options.upgrade,
-                             with_pip=options.with_pip,
-                             prompt=options.prompt,
-                             upgrade_deps=options.upgrade_deps)
-        for d in options.dirs:
-            builder.create(d)
+        use_symlinks = True
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--symlinks', default=use_symlinks,
+                       action='store_true', dest='symlinks',
+                       help='Try to use symlinks rather than copies, '
+                            'when symlinks are not the default for '
+                            'the platform.')
+    group.add_argument('--copies', default=not use_symlinks,
+                       action='store_false', dest='symlinks',
+                       help='Try to use copies rather than symlinks, '
+                            'even when symlinks are the default for '
+                            'the platform.')
+    parser.add_argument('--clear', default=False, action='store_true',
+                        dest='clear', help='Delete the contents of the '
+                                           'environment directory if it '
+                                           'already exists, before '
+                                           'environment creation.')
+    parser.add_argument('--upgrade', default=False, action='store_true',
+                        dest='upgrade', help='Upgrade the environment '
+                                             'directory to use this version '
+                                             'of Python, assuming Python '
+                                             'has been upgraded in-place.')
+    parser.add_argument('--without-pip', dest='with_pip',
+                        default=True, action='store_false',
+                        help='Skips installing or upgrading pip in the '
+                             'virtual environment (pip is bootstrapped '
+                             'by default)')
+    parser.add_argument('--prompt',
+                        help='Provides an alternative prompt prefix for '
+                             'this environment.')
+    parser.add_argument('--upgrade-deps', default=False, action='store_true',
+                        dest='upgrade_deps',
+                        help=f'Upgrade core dependencies ({", ".join(CORE_VENV_DEPS)}) '
+                             'to the latest version in PyPI')
+    parser.add_argument('--without-scm-ignore-files', dest='scm_ignore_files',
+                        action='store_const', const=frozenset(),
+                        default=frozenset(['git']),
+                        help='Skips adding SCM ignore files to the environment '
+                             'directory (Git is supported by default).')
+    options = parser.parse_args(args)
+    if options.upgrade and options.clear:
+        raise ValueError('you cannot supply --upgrade and --clear together.')
+    builder = EnvBuilder(system_site_packages=options.system_site,
+                         clear=options.clear,
+                         symlinks=options.symlinks,
+                         upgrade=options.upgrade,
+                         with_pip=options.with_pip,
+                         prompt=options.prompt,
+                         upgrade_deps=options.upgrade_deps,
+                         scm_ignore_files=options.scm_ignore_files)
+    for d in options.dirs:
+        builder.create(d)
+
 
 if __name__ == '__main__':
     rc = 1
diff --git a/Lib/venv/__main__.py b/Lib/venv/__main__.py
index 912423e4a7..88f55439dc 100644
--- a/Lib/venv/__main__.py
+++ b/Lib/venv/__main__.py
@@ -6,5 +6,5 @@
     main()
     rc = 0
 except Exception as e:
-    print('Error: %s' % e, file=sys.stderr)
+    print('Error:', e, file=sys.stderr)
 sys.exit(rc)
diff --git a/Lib/venv/scripts/common/Activate.ps1 b/Lib/venv/scripts/common/Activate.ps1
index b49d77ba44..16ba5290fa 100644
--- a/Lib/venv/scripts/common/Activate.ps1
+++ b/Lib/venv/scripts/common/Activate.ps1
@@ -219,6 +219,8 @@ deactivate -nondestructive
 # that there is an activated venv.
 $env:VIRTUAL_ENV = $VenvDir
 
+$env:VIRTUAL_ENV_PROMPT = $Prompt
+
 if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
 
     Write-Verbose "Setting prompt to '$Prompt'"
@@ -233,7 +235,6 @@ if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
         Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
         _OLD_VIRTUAL_PROMPT
     }
-    $env:VIRTUAL_ENV_PROMPT = $Prompt
 }
 
 # Clear PYTHONHOME
diff --git a/Lib/venv/scripts/common/activate b/Lib/venv/scripts/common/activate
index 6fbc2b8801..70673a265d 100644
--- a/Lib/venv/scripts/common/activate
+++ b/Lib/venv/scripts/common/activate
@@ -1,5 +1,5 @@
 # This file must be used with "source bin/activate" *from bash*
-# you cannot run it directly
+# You cannot run it directly
 
 deactivate () {
     # reset old environment variables
@@ -14,12 +14,10 @@ deactivate () {
         unset _OLD_VIRTUAL_PYTHONHOME
     fi
 
-    # This should detect bash and zsh, which have a hash command that must
-    # be called to get it to forget past commands.  Without forgetting
-    # past commands the $PATH changes we made may not be respected
-    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
-        hash -r 2> /dev/null
-    fi
+    # Call hash to forget past locations. Without forgetting
+    # past locations the $PATH changes we made may not be respected.
+    # See "man bash" for more details. hash is usually a builtin of your shell
+    hash -r 2> /dev/null
 
     if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
         PS1="${_OLD_VIRTUAL_PS1:-}"
@@ -38,13 +36,27 @@ deactivate () {
 # unset irrelevant variables
 deactivate nondestructive
 
-VIRTUAL_ENV="__VENV_DIR__"
-export VIRTUAL_ENV
+# on Windows, a path can contain colons and backslashes and has to be converted:
+case "$(uname)" in
+    CYGWIN*|MSYS*|MINGW*)
+        # transform D:\path\to\venv to /d/path/to/venv on MSYS and MINGW
+        # and to /cygdrive/d/path/to/venv on Cygwin
+        VIRTUAL_ENV=$(cygpath __VENV_DIR__)
+        export VIRTUAL_ENV
+        ;;
+    *)
+        # use the path as-is
+        export VIRTUAL_ENV=__VENV_DIR__
+        ;;
+esac
 
 _OLD_VIRTUAL_PATH="$PATH"
-PATH="$VIRTUAL_ENV/__VENV_BIN_NAME__:$PATH"
+PATH="$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH"
 export PATH
 
+VIRTUAL_ENV_PROMPT=__VENV_PROMPT__
+export VIRTUAL_ENV_PROMPT
+
 # unset PYTHONHOME if set
 # this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
 # could use `if (set -u; : $PYTHONHOME) ;` in bash
@@ -55,15 +67,10 @@ fi
 
 if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
     _OLD_VIRTUAL_PS1="${PS1:-}"
-    PS1="__VENV_PROMPT__${PS1:-}"
+    PS1="("__VENV_PROMPT__") ${PS1:-}"
     export PS1
-    VIRTUAL_ENV_PROMPT="__VENV_PROMPT__"
-    export VIRTUAL_ENV_PROMPT
 fi
 
-# This should detect bash and zsh, which have a hash command that must
-# be called to get it to forget past commands.  Without forgetting
+# Call hash to forget past commands. Without forgetting
 # past commands the $PATH changes we made may not be respected
-if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
-    hash -r 2> /dev/null
-fi
+hash -r 2> /dev/null
diff --git a/Lib/venv/scripts/posix/activate.fish b/Lib/venv/scripts/common/activate.fish
similarity index 76%
rename from Lib/venv/scripts/posix/activate.fish
rename to Lib/venv/scripts/common/activate.fish
index e40a1d7148..284a7469c9 100644
--- a/Lib/venv/scripts/posix/activate.fish
+++ b/Lib/venv/scripts/common/activate.fish
@@ -1,5 +1,5 @@
 # This file must be used with "source <venv>/bin/activate.fish" *from fish*
-# (https://fishshell.com/); you cannot run it directly.
+# (https://fishshell.com/). You cannot run it directly.
 
 function deactivate  -d "Exit virtual environment and return to normal shell environment"
     # reset old environment variables
@@ -13,10 +13,13 @@ function deactivate  -d "Exit virtual environment and return to normal shell env
     end
 
     if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
-        functions -e fish_prompt
         set -e _OLD_FISH_PROMPT_OVERRIDE
-        functions -c _old_fish_prompt fish_prompt
-        functions -e _old_fish_prompt
+        # prevents error when using nested fish instances (Issue #93858)
+        if functions -q _old_fish_prompt
+            functions -e fish_prompt
+            functions -c _old_fish_prompt fish_prompt
+            functions -e _old_fish_prompt
+        end
     end
 
     set -e VIRTUAL_ENV
@@ -30,10 +33,11 @@ end
 # Unset irrelevant variables.
 deactivate nondestructive
 
-set -gx VIRTUAL_ENV "__VENV_DIR__"
+set -gx VIRTUAL_ENV __VENV_DIR__
 
 set -gx _OLD_VIRTUAL_PATH $PATH
-set -gx PATH "$VIRTUAL_ENV/__VENV_BIN_NAME__" $PATH
+set -gx PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__ $PATH
+set -gx VIRTUAL_ENV_PROMPT __VENV_PROMPT__
 
 # Unset PYTHONHOME if set.
 if set -q PYTHONHOME
@@ -53,7 +57,7 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
         set -l old_status $status
 
         # Output the venv prompt; color taken from the blue of the Python logo.
-        printf "%s%s%s" (set_color 4B8BBE) "__VENV_PROMPT__" (set_color normal)
+        printf "%s(%s)%s " (set_color 4B8BBE) __VENV_PROMPT__ (set_color normal)
 
         # Restore the return status of the previous command.
         echo "exit $old_status" | .
@@ -62,5 +66,4 @@ if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
     end
 
     set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
-    set -gx VIRTUAL_ENV_PROMPT "__VENV_PROMPT__"
 end
diff --git a/Lib/venv/scripts/nt/activate.bat b/Lib/venv/scripts/nt/activate.bat
index 5daa45afc9..9ac5c20b47 100644
--- a/Lib/venv/scripts/nt/activate.bat
+++ b/Lib/venv/scripts/nt/activate.bat
@@ -8,15 +8,15 @@ if defined _OLD_CODEPAGE (
     "%SystemRoot%\System32\chcp.com" 65001 > nul
 )
 
-set VIRTUAL_ENV=__VENV_DIR__
+set "VIRTUAL_ENV=__VENV_DIR__"
 
 if not defined PROMPT set PROMPT=$P$G
 
 if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT%
 if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%
 
-set _OLD_VIRTUAL_PROMPT=%PROMPT%
-set PROMPT=__VENV_PROMPT__%PROMPT%
+set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+set "PROMPT=(__VENV_PROMPT__) %PROMPT%"
 
 if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%
 set PYTHONHOME=
@@ -24,8 +24,8 @@ set PYTHONHOME=
 if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH%
 if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH%
 
-set PATH=%VIRTUAL_ENV%\__VENV_BIN_NAME__;%PATH%
-set VIRTUAL_ENV_PROMPT=__VENV_PROMPT__
+set "PATH=%VIRTUAL_ENV%\__VENV_BIN_NAME__;%PATH%"
+set "VIRTUAL_ENV_PROMPT=__VENV_PROMPT__"
 
 :END
 if defined _OLD_CODEPAGE (
diff --git a/Lib/venv/scripts/nt/venvlauncher.exe b/Lib/venv/scripts/nt/venvlauncher.exe
new file mode 100644
index 0000000000..2439c22aa9
Binary files /dev/null and b/Lib/venv/scripts/nt/venvlauncher.exe differ
diff --git a/Lib/venv/scripts/nt/venvlaunchert.exe b/Lib/venv/scripts/nt/venvlaunchert.exe
new file mode 100644
index 0000000000..99f5f5e9fc
Binary files /dev/null and b/Lib/venv/scripts/nt/venvlaunchert.exe differ
diff --git a/Lib/venv/scripts/nt/venvwlauncher.exe b/Lib/venv/scripts/nt/venvwlauncher.exe
new file mode 100644
index 0000000000..6c43c2e9d9
Binary files /dev/null and b/Lib/venv/scripts/nt/venvwlauncher.exe differ
diff --git a/Lib/venv/scripts/nt/venvwlaunchert.exe b/Lib/venv/scripts/nt/venvwlaunchert.exe
new file mode 100644
index 0000000000..74f40deb04
Binary files /dev/null and b/Lib/venv/scripts/nt/venvwlaunchert.exe differ
diff --git a/Lib/venv/scripts/posix/activate.csh b/Lib/venv/scripts/posix/activate.csh
index d6f697c55e..2a3fa83547 100644
--- a/Lib/venv/scripts/posix/activate.csh
+++ b/Lib/venv/scripts/posix/activate.csh
@@ -1,5 +1,6 @@
 # This file must be used with "source bin/activate.csh" *from csh*.
 # You cannot run it directly.
+
 # Created by Davide Di Blasi <davidedb@gmail.com>.
 # Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
 
@@ -8,17 +9,17 @@ alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PA
 # Unset irrelevant variables.
 deactivate nondestructive
 
-setenv VIRTUAL_ENV "__VENV_DIR__"
+setenv VIRTUAL_ENV __VENV_DIR__
 
 set _OLD_VIRTUAL_PATH="$PATH"
-setenv PATH "$VIRTUAL_ENV/__VENV_BIN_NAME__:$PATH"
+setenv PATH "$VIRTUAL_ENV/"__VENV_BIN_NAME__":$PATH"
+setenv VIRTUAL_ENV_PROMPT __VENV_PROMPT__
 
 
 set _OLD_VIRTUAL_PROMPT="$prompt"
 
 if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
-    set prompt = "__VENV_PROMPT__$prompt"
-    setenv VIRTUAL_ENV_PROMPT "__VENV_PROMPT__"
+    set prompt = "("__VENV_PROMPT__") $prompt:q"
 endif
 
 alias pydoc python -m pydoc
diff --git a/Lib/warnings.py b/Lib/warnings.py
index 7d8c440012..f83aaf231e 100644
--- a/Lib/warnings.py
+++ b/Lib/warnings.py
@@ -5,7 +5,7 @@
 
 __all__ = ["warn", "warn_explicit", "showwarning",
            "formatwarning", "filterwarnings", "simplefilter",
-           "resetwarnings", "catch_warnings"]
+           "resetwarnings", "catch_warnings", "deprecated"]
 
 def showwarning(message, category, filename, lineno, file=None, line=None):
     """Hook to write a warning to a file; replace if you like."""
@@ -58,15 +58,16 @@ def _formatwarnmsg_impl(msg):
         # catch Exception, not only ImportError and RecursionError.
         except Exception:
             # don't suggest to enable tracemalloc if it's not available
-            tracing = True
+            suggest_tracemalloc = False
             tb = None
         else:
-            tracing = tracemalloc.is_tracing()
             try:
+                suggest_tracemalloc = not tracemalloc.is_tracing()
                 tb = tracemalloc.get_object_traceback(msg.source)
             except Exception:
                 # When a warning is logged during Python shutdown, tracemalloc
                 # and the import machinery don't work anymore
+                suggest_tracemalloc = False
                 tb = None
 
         if tb is not None:
@@ -85,7 +86,7 @@ def _formatwarnmsg_impl(msg):
                 if line:
                     line = line.strip()
                     s += '    %s\n' % line
-        elif not tracing:
+        elif suggest_tracemalloc:
             s += (f'{category}: Enable tracemalloc to get the object '
                   f'allocation traceback\n')
     return s
@@ -139,14 +140,18 @@ def filterwarnings(action, message="", category=Warning, module="", lineno=0,
     'lineno' -- an integer line number, 0 matches all warnings
     'append' -- if true, append to the list of filters
     """
-    assert action in ("error", "ignore", "always", "default", "module",
-                      "once"), "invalid action: %r" % (action,)
-    assert isinstance(message, str), "message must be a string"
-    assert isinstance(category, type), "category must be a class"
-    assert issubclass(category, Warning), "category must be a Warning subclass"
-    assert isinstance(module, str), "module must be a string"
-    assert isinstance(lineno, int) and lineno >= 0, \
-           "lineno must be an int >= 0"
+    if action not in {"error", "ignore", "always", "default", "module", "once"}:
+        raise ValueError(f"invalid action: {action!r}")
+    if not isinstance(message, str):
+        raise TypeError("message must be a string")
+    if not isinstance(category, type) or not issubclass(category, Warning):
+        raise TypeError("category must be a Warning subclass")
+    if not isinstance(module, str):
+        raise TypeError("module must be a string")
+    if not isinstance(lineno, int):
+        raise TypeError("lineno must be an int")
+    if lineno < 0:
+        raise ValueError("lineno must be an int >= 0")
 
     if message or module:
         import re
@@ -172,10 +177,12 @@ def simplefilter(action, category=Warning, lineno=0, append=False):
     'lineno' -- an integer line number, 0 matches all warnings
     'append' -- if true, append to the list of filters
     """
-    assert action in ("error", "ignore", "always", "default", "module",
-                      "once"), "invalid action: %r" % (action,)
-    assert isinstance(lineno, int) and lineno >= 0, \
-           "lineno must be an int >= 0"
+    if action not in {"error", "ignore", "always", "default", "module", "once"}:
+        raise ValueError(f"invalid action: {action!r}")
+    if not isinstance(lineno, int):
+        raise TypeError("lineno must be an int")
+    if lineno < 0:
+        raise ValueError("lineno must be an int >= 0")
     _add_filter(action, None, category, None, lineno, append=append)
 
 def _add_filter(*item, append):
@@ -269,22 +276,32 @@ def _getcategory(category):
     return cat
 
 
+def _is_internal_filename(filename):
+    return 'importlib' in filename and '_bootstrap' in filename
+
+
+def _is_filename_to_skip(filename, skip_file_prefixes):
+    return any(filename.startswith(prefix) for prefix in skip_file_prefixes)
+
+
 def _is_internal_frame(frame):
     """Signal whether the frame is an internal CPython implementation detail."""
-    filename = frame.f_code.co_filename
-    return 'importlib' in filename and '_bootstrap' in filename
+    return _is_internal_filename(frame.f_code.co_filename)
 
 
-def _next_external_frame(frame):
-    """Find the next frame that doesn't involve CPython internals."""
+def _next_external_frame(frame, skip_file_prefixes):
+    """Find the next frame that doesn't involve Python or user internals."""
     frame = frame.f_back
-    while frame is not None and _is_internal_frame(frame):
+    while frame is not None and (
+            _is_internal_filename(filename := frame.f_code.co_filename) or
+            _is_filename_to_skip(filename, skip_file_prefixes)):
         frame = frame.f_back
     return frame
 
 
 # Code typically replaced by _warnings
-def warn(message, category=None, stacklevel=1, source=None):
+def warn(message, category=None, stacklevel=1, source=None,
+         *, skip_file_prefixes=()):
     """Issue a warning, or maybe ignore it or raise an exception."""
     # Check if message is already a Warning object
     if isinstance(message, Warning):
@@ -295,6 +312,11 @@ def warn(message, category=None, stacklevel=1, source=None):
     if not (isinstance(category, type) and issubclass(category, Warning)):
         raise TypeError("category must be a Warning subclass, "
                         "not '{:s}'".format(type(category).__name__))
+    if not isinstance(skip_file_prefixes, tuple):
+        # The C version demands a tuple for implementation performance.
+        raise TypeError('skip_file_prefixes must be a tuple of strs.')
+    if skip_file_prefixes:
+        stacklevel = max(2, stacklevel)
     # Get context information
     try:
         if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)):
@@ -305,13 +327,13 @@ def warn(message, category=None, stacklevel=1, source=None):
             frame = sys._getframe(1)
             # Look for one frame less since the above line starts us off.
             for x in range(stacklevel-1):
-                frame = _next_external_frame(frame)
+                frame = _next_external_frame(frame, skip_file_prefixes)
                 if frame is None:
                     raise ValueError
     except ValueError:
         globals = sys.__dict__
-        filename = "sys"
-        lineno = 1
+        filename = "<sys>"
+        lineno = 0
     else:
         globals = frame.f_globals
         filename = frame.f_code.co_filename
@@ -391,7 +413,7 @@ def warn_explicit(message, category, filename, lineno,
               "Unrecognized action (%r) in warnings.filters:\n %s" %
               (action, item))
     # Print message and context
-    msg = WarningMessage(message, category, filename, lineno, source)
+    msg = WarningMessage(message, category, filename, lineno, source=source)
     _showwarnmsg(msg)
 
 
@@ -493,6 +515,139 @@ def __exit__(self, *exc_info):
         self._module._showwarnmsg_impl = self._showwarnmsg_impl
 
 
+class deprecated:
+    """Indicate that a class, function or overload is deprecated.
+
+    When this decorator is applied to an object, the type checker
+    will generate a diagnostic on usage of the deprecated object.
+
+    Usage:
+
+        @deprecated("Use B instead")
+        class A:
+            pass
+
+        @deprecated("Use g instead")
+        def f():
+            pass
+
+        @overload
+        @deprecated("int support is deprecated")
+        def g(x: int) -> int: ...
+        @overload
+        def g(x: str) -> int: ...
+
+    The warning specified by *category* will be emitted at runtime
+    on use of deprecated objects. For functions, that happens on calls;
+    for classes, on instantiation and on creation of subclasses.
+    If the *category* is ``None``, no warning is emitted at runtime.
+    The *stacklevel* determines where the
+    warning is emitted. If it is ``1`` (the default), the warning
+    is emitted at the direct caller of the deprecated object; if it
+    is higher, it is emitted further up the stack.
+    Static type checker behavior is not affected by the *category*
+    and *stacklevel* arguments.
+
+    The deprecation message passed to the decorator is saved in the
+    ``__deprecated__`` attribute on the decorated object.
+    If applied to an overload, the decorator
+    must be after the ``@overload`` decorator for the attribute to
+    exist on the overload as returned by ``get_overloads()``.
+
+    See PEP 702 for details.
+
+    """
+    def __init__(
+        self,
+        message: str,
+        /,
+        *,
+        category: type[Warning] | None = DeprecationWarning,
+        stacklevel: int = 1,
+    ) -> None:
+        if not isinstance(message, str):
+            raise TypeError(
+                f"Expected an object of type str for 'message', not {type(message).__name__!r}"
+            )
+        self.message = message
+        self.category = category
+        self.stacklevel = stacklevel
+
+    def __call__(self, arg, /):
+        # Make sure the inner functions created below don't
+        # retain a reference to self.
+        msg = self.message
+        category = self.category
+        stacklevel = self.stacklevel
+        if category is None:
+            arg.__deprecated__ = msg
+            return arg
+        elif isinstance(arg, type):
+            import functools
+            from types import MethodType
+
+            original_new = arg.__new__
+
+            @functools.wraps(original_new)
+            def __new__(cls, /, *args, **kwargs):
+                if cls is arg:
+                    warn(msg, category=category, stacklevel=stacklevel + 1)
+                if original_new is not object.__new__:
+                    return original_new(cls, *args, **kwargs)
+                # Mirrors a similar check in object.__new__.
+                elif cls.__init__ is object.__init__ and (args or kwargs):
+                    raise TypeError(f"{cls.__name__}() takes no arguments")
+                else:
+                    return original_new(cls)
+
+            arg.__new__ = staticmethod(__new__)
+
+            original_init_subclass = arg.__init_subclass__
+            # We need slightly different behavior if __init_subclass__
+            # is a bound method (likely if it was implemented in Python)
+            if isinstance(original_init_subclass, MethodType):
+                original_init_subclass = original_init_subclass.__func__
+
+                @functools.wraps(original_init_subclass)
+                def __init_subclass__(*args, **kwargs):
+                    warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return original_init_subclass(*args, **kwargs)
+
+                arg.__init_subclass__ = classmethod(__init_subclass__)
+            # Or otherwise, which likely means it's a builtin such as
+            # object's implementation of __init_subclass__.
+            else:
+                @functools.wraps(original_init_subclass)
+                def __init_subclass__(*args, **kwargs):
+                    warn(msg, category=category, stacklevel=stacklevel + 1)
+                    return original_init_subclass(*args, **kwargs)
+
+                arg.__init_subclass__ = __init_subclass__
+
+            arg.__deprecated__ = __new__.__deprecated__ = msg
+            __init_subclass__.__deprecated__ = msg
+            return arg
+        elif callable(arg):
+            import functools
+            import inspect
+
+            @functools.wraps(arg)
+            def wrapper(*args, **kwargs):
+                warn(msg, category=category, stacklevel=stacklevel + 1)
+                return arg(*args, **kwargs)
+
+            if inspect.iscoroutinefunction(arg):
+                wrapper = inspect.markcoroutinefunction(wrapper)
+
+            arg.__deprecated__ = wrapper.__deprecated__ = msg
+            return wrapper
+        else:
+            raise TypeError(
+                "@deprecated decorator with non-None category must be applied to "
+                f"a class or callable, not {arg!r}"
+            )
+
+
 _DEPRECATED_MSG = "{name!r} is deprecated and slated for removal in Python {remove}"
 
 def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_info):
@@ -502,7 +657,7 @@ def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_i
     the current Python version or the same version but past the alpha.
 
     The *message* argument is formatted with *name* and *remove* as a Python
-    version (e.g. "3.11").
+    version tuple (e.g. (3, 11)).
 
     """
     remove_formatted = f"{remove[0]}.{remove[1]}"
diff --git a/Lib/weakref.py b/Lib/weakref.py
index 994ea8aa37..25b70927e2 100644
--- a/Lib/weakref.py
+++ b/Lib/weakref.py
@@ -2,7 +2,7 @@
 
 This module is an implementation of PEP 205:
 
-https://www.python.org/dev/peps/pep-0205/
+https://peps.python.org/pep-0205/
 """
 
 # Naming convention: Variables named "wr" are weak reference objects;
@@ -33,7 +33,6 @@
            "WeakSet", "WeakMethod", "finalize"]
 
 
-_collections_abc.Set.register(WeakSet)
 _collections_abc.MutableSet.register(WeakSet)
 
 class WeakMethod(ref):
diff --git a/Lib/wsgiref/__init__.py b/Lib/wsgiref/__init__.py
index 1efbba01a3..59ee48fdde 100644
--- a/Lib/wsgiref/__init__.py
+++ b/Lib/wsgiref/__init__.py
@@ -13,6 +13,8 @@
 * validate -- validation wrapper that sits between an app and a server
   to detect errors in either
 
+* types -- collection of WSGI-related types for static type checking
+
 To-Do:
 
 * cgi_gateway -- Run WSGI apps under CGI (pending a deployment standard)
diff --git a/Lib/wsgiref/handlers.py b/Lib/wsgiref/handlers.py
index f4300b831a..cafe872c7a 100644
--- a/Lib/wsgiref/handlers.py
+++ b/Lib/wsgiref/handlers.py
@@ -136,6 +136,10 @@ def run(self, application):
             self.setup_environ()
             self.result = application(self.environ, self.start_response)
             self.finish_response()
+        except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
+            # We expect the client to close the connection abruptly from time
+            # to time.
+            return
         except:
             try:
                 self.handle_error()
@@ -179,7 +183,16 @@ def finish_response(self):
                 for data in self.result:
                     self.write(data)
                 self.finish_content()
-        finally:
+        except:
+            # Call close() on the iterable returned by the WSGI application
+            # in case of an exception.
+            if hasattr(self.result, 'close'):
+                self.result.close()
+            raise
+        else:
+            # We only call close() when no exception is raised, because it
+            # will set status, result, headers, and environ fields to None.
+            # See bpo-29183 for more details.
             self.close()
 
 
@@ -215,8 +228,7 @@ def start_response(self, status, headers,exc_info=None):
         if exc_info:
             try:
                 if self.headers_sent:
-                    # Re-raise original exception if headers sent
-                    raise exc_info[0](exc_info[1]).with_traceback(exc_info[2])
+                    raise
             finally:
                 exc_info = None        # avoid dangling circular ref
         elif self.headers is not None:
@@ -225,18 +237,25 @@ def start_response(self, status, headers,exc_info=None):
         self.status = status
         self.headers = self.headers_class(headers)
         status = self._convert_string_type(status, "Status")
-        assert len(status)>=4,"Status must be at least 4 characters"
-        assert status[:3].isdigit(), "Status message must begin w/3-digit code"
-        assert status[3]==" ", "Status message must have a space after code"
+        self._validate_status(status)
 
         if __debug__:
             for name, val in headers:
                 name = self._convert_string_type(name, "Header name")
                 val = self._convert_string_type(val, "Header value")
-                assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed"
+                assert not is_hop_by_hop(name),\
+                       f"Hop-by-hop header, '{name}: {val}', not allowed"
 
         return self.write
 
+    def _validate_status(self, status):
+        if len(status) < 4:
+            raise AssertionError("Status must be at least 4 characters")
+        if not status[:3].isdigit():
+            raise AssertionError("Status message must begin w/3-digit code")
+        if status[3] != " ":
+            raise AssertionError("Status message must have a space after code")
+
     def _convert_string_type(self, value, title):
         """Convert/check value type."""
         if type(value) is str:
@@ -456,10 +475,7 @@ def _write(self,data):
         from warnings import warn
         warn("SimpleHandler.stdout.write() should not do partial writes",
             DeprecationWarning)
-        while True:
-            data = data[result:]
-            if not data:
-                break
+        while data := data[result:]:
             result = self.stdout.write(data)
 
     def _flush(self):
diff --git a/Lib/wsgiref/simple_server.py b/Lib/wsgiref/simple_server.py
index f71563a5ae..a0f2397fcf 100644
--- a/Lib/wsgiref/simple_server.py
+++ b/Lib/wsgiref/simple_server.py
@@ -84,10 +84,6 @@ def get_environ(self):
 
         env['PATH_INFO'] = urllib.parse.unquote(path, 'iso-8859-1')
         env['QUERY_STRING'] = query
-
-        host = self.address_string()
-        if host != self.client_address[0]:
-            env['REMOTE_HOST'] = host
         env['REMOTE_ADDR'] = self.client_address[0]
 
         if self.headers.get('content-type') is None:
@@ -127,7 +123,8 @@ def handle(self):
             return
 
         handler = ServerHandler(
-            self.rfile, self.wfile, self.get_stderr(), self.get_environ()
+            self.rfile, self.wfile, self.get_stderr(), self.get_environ(),
+            multithread=False,
         )
         handler.request_handler = self      # backpointer for logging
         handler.run(self.server.get_app())
diff --git a/Lib/wsgiref/types.py b/Lib/wsgiref/types.py
new file mode 100644
index 0000000000..ef0aead5b2
--- /dev/null
+++ b/Lib/wsgiref/types.py
@@ -0,0 +1,54 @@
+"""WSGI-related types for static type checking"""
+
+from collections.abc import Callable, Iterable, Iterator
+from types import TracebackType
+from typing import Any, Protocol, TypeAlias
+
+__all__ = [
+    "StartResponse",
+    "WSGIEnvironment",
+    "WSGIApplication",
+    "InputStream",
+    "ErrorStream",
+    "FileWrapper",
+]
+
+_ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
+_OptExcInfo: TypeAlias = _ExcInfo | tuple[None, None, None]
+
+class StartResponse(Protocol):
+    """start_response() callable as defined in PEP 3333"""
+    def __call__(
+        self,
+        status: str,
+        headers: list[tuple[str, str]],
+        exc_info: _OptExcInfo | None = ...,
+        /,
+    ) -> Callable[[bytes], object]: ...
+
+WSGIEnvironment: TypeAlias = dict[str, Any]
+WSGIApplication: TypeAlias = Callable[[WSGIEnvironment, StartResponse],
+    Iterable[bytes]]
+
+class InputStream(Protocol):
+    """WSGI input stream as defined in PEP 3333"""
+    def read(self, size: int = ..., /) -> bytes: ...
+    def readline(self, size: int = ..., /) -> bytes: ...
+    def readlines(self, hint: int = ..., /) -> list[bytes]: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+
+class ErrorStream(Protocol):
+    """WSGI error stream as defined in PEP 3333"""
+    def flush(self) -> object: ...
+    def write(self, s: str, /) -> object: ...
+    def writelines(self, seq: list[str], /) -> object: ...
+
+class _Readable(Protocol):
+    def read(self, size: int = ..., /) -> bytes: ...
+    # Optional: def close(self) -> object: ...
+
+class FileWrapper(Protocol):
+    """WSGI file wrapper as defined in PEP 3333"""
+    def __call__(
+        self, file: _Readable, block_size: int = ..., /,
+    ) -> Iterable[bytes]: ...
diff --git a/Lib/wsgiref/util.py b/Lib/wsgiref/util.py
index 516fe898d0..63b9233173 100644
--- a/Lib/wsgiref/util.py
+++ b/Lib/wsgiref/util.py
@@ -4,7 +4,7 @@
 
 __all__ = [
     'FileWrapper', 'guess_scheme', 'application_uri', 'request_uri',
-    'shift_path_info', 'setup_testing_defaults',
+    'shift_path_info', 'setup_testing_defaults', 'is_hop_by_hop',
 ]
 
 
@@ -17,12 +17,6 @@ def __init__(self, filelike, blksize=8192):
         if hasattr(filelike,'close'):
             self.close = filelike.close
 
-    def __getitem__(self,key):
-        data = self.filelike.read(self.blksize)
-        if data:
-            return data
-        raise IndexError
-
     def __iter__(self):
         return self
 
@@ -155,9 +149,9 @@ def setup_testing_defaults(environ):
 
 
 _hoppish = {
-    'connection':1, 'keep-alive':1, 'proxy-authenticate':1,
-    'proxy-authorization':1, 'te':1, 'trailers':1, 'transfer-encoding':1,
-    'upgrade':1
+    'connection', 'keep-alive', 'proxy-authenticate',
+    'proxy-authorization', 'te', 'trailers', 'transfer-encoding',
+    'upgrade'
 }.__contains__
 
 def is_hop_by_hop(header_name):
diff --git a/Lib/wsgiref/validate.py b/Lib/wsgiref/validate.py
index 6107dcd7a4..1a1853cd63 100644
--- a/Lib/wsgiref/validate.py
+++ b/Lib/wsgiref/validate.py
@@ -1,6 +1,6 @@
 # (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
-# Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
-# Also licenced under the Apache License, 2.0: http://opensource.org/licenses/apache2.0.php
+# Licensed under the MIT license: https://opensource.org/licenses/mit-license.php
+# Also licenced under the Apache License, 2.0: https://opensource.org/licenses/apache2.0.php
 # Licensed to PSF under a Contributor Agreement
 """
 Middleware to check for obedience to the WSGI specification.
@@ -77,7 +77,7 @@
 
 * That wsgi.input is used properly:
 
-  - .read() is called with zero or one argument
+  - .read() is called with exactly one argument
 
   - That it returns a string
 
@@ -137,7 +137,7 @@ def validator(application):
 
     """
     When applied between a WSGI server and a WSGI application, this
-    middleware will check for WSGI compliancy on a number of levels.
+    middleware will check for WSGI compliance on a number of levels.
     This middleware does not modify the request or response in any
     way, but will raise an AssertionError if anything seems off
     (except for a failure to close the application iterator, which
@@ -214,10 +214,7 @@ def readlines(self, *args):
         return lines
 
     def __iter__(self):
-        while 1:
-            line = self.readline()
-            if not line:
-                return
+        while line := self.readline():
             yield line
 
     def close(self):
@@ -390,7 +387,6 @@ def check_headers(headers):
     assert_(type(headers) is list,
         "Headers (%r) must be of type list: %r"
         % (headers, type(headers)))
-    header_names = {}
     for item in headers:
         assert_(type(item) is tuple,
             "Individual headers (%r) must be of type tuple: %r"
@@ -403,7 +399,6 @@ def check_headers(headers):
             "The Status header cannot be used; it conflicts with CGI "
             "script, and HTTP status is not given through headers "
             "(value: %r)." % value)
-        header_names[name.lower()] = None
         assert_('\n' not in name and ':' not in name,
             "Header names may not contain ':' or '\\n': %r" % name)
         assert_(header_re.search(name), "Bad header name: %r" % name)
diff --git a/Lib/xml/dom/expatbuilder.py b/Lib/xml/dom/expatbuilder.py
index 199c22d0af..7dd667bf3f 100644
--- a/Lib/xml/dom/expatbuilder.py
+++ b/Lib/xml/dom/expatbuilder.py
@@ -200,10 +200,7 @@ def parseFile(self, file):
         parser = self.getParser()
         first_buffer = True
         try:
-            while 1:
-                buffer = file.read(16*1024)
-                if not buffer:
-                    break
+            while buffer := file.read(16*1024):
                 parser.Parse(buffer, False)
                 if first_buffer and self.document.documentElement:
                     self._setup_subset(buffer)
diff --git a/Lib/xml/dom/minidom.py b/Lib/xml/dom/minidom.py
index d09ef5e7d0..db51f350ea 100644
--- a/Lib/xml/dom/minidom.py
+++ b/Lib/xml/dom/minidom.py
@@ -300,12 +300,28 @@ def _in_document(node):
         node = node.parentNode
     return False
 
-def _write_data(writer, data):
+def _write_data(writer, text, attr):
     "Writes datachars to writer."
-    if data:
-        data = data.replace("&", "&amp;").replace("<", "&lt;"). \
-                    replace("\"", "&quot;").replace(">", "&gt;")
-        writer.write(data)
+    if not text:
+        return
+    # See the comments in ElementTree.py for behavior and
+    # implementation details.
+    if "&" in text:
+        text = text.replace("&", "&amp;")
+    if "<" in text:
+        text = text.replace("<", "&lt;")
+    if ">" in text:
+        text = text.replace(">", "&gt;")
+    if attr:
+        if '"' in text:
+            text = text.replace('"', "&quot;")
+        if "\r" in text:
+            text = text.replace("\r", "&#13;")
+        if "\n" in text:
+            text = text.replace("\n", "&#10;")
+        if "\t" in text:
+            text = text.replace("\t", "&#9;")
+    writer.write(text)
 
 def _get_elements_by_tagName_helper(parent, name, rc):
     for node in parent.childNodes:
@@ -358,6 +374,8 @@ def __init__(self, qName, namespaceURI=EMPTY_NAMESPACE, localName=None,
         self._name = qName
         self.namespaceURI = namespaceURI
         self._prefix = prefix
+        if localName is not None:
+            self._localName = localName
         self.childNodes = NodeList()
 
         # Add the single child node that represents the value of the attr
@@ -881,7 +899,7 @@ def writexml(self, writer, indent="", addindent="", newl=""):
 
         for a_name in attrs.keys():
             writer.write(" %s=\"" % a_name)
-            _write_data(writer, attrs[a_name].value)
+            _write_data(writer, attrs[a_name].value, True)
             writer.write("\"")
         if self.childNodes:
             writer.write(">")
@@ -1110,7 +1128,7 @@ def splitText(self, offset):
         return newText
 
     def writexml(self, writer, indent="", addindent="", newl=""):
-        _write_data(writer, "%s%s%s" % (indent, self.data, newl))
+        _write_data(writer, "%s%s%s" % (indent, self.data, newl), False)
 
     # DOM Level 3 (WD 9 April 2002)
 
diff --git a/Lib/xml/dom/xmlbuilder.py b/Lib/xml/dom/xmlbuilder.py
index 8a20026349..a8852625a2 100644
--- a/Lib/xml/dom/xmlbuilder.py
+++ b/Lib/xml/dom/xmlbuilder.py
@@ -189,7 +189,7 @@ def parse(self, input):
         options.filter = self.filter
         options.errorHandler = self.errorHandler
         fp = input.byteStream
-        if fp is None and options.systemId:
+        if fp is None and input.systemId:
             import urllib.request
             fp = urllib.request.urlopen(input.systemId)
         return self._parse_bytestream(fp, options)
@@ -247,10 +247,12 @@ def _create_opener(self):
 
     def _guess_media_encoding(self, source):
         info = source.byteStream.info()
-        if "Content-Type" in info:
-            for param in info.getplist():
-                if param.startswith("charset="):
-                    return param.split("=", 1)[1].lower()
+        # import email.message
+        # assert isinstance(info, email.message.Message)
+        charset = info.get_param('charset')
+        if charset is not None:
+            return charset.lower()
+        return None
 
 
 class DOMInputSource(object):
diff --git a/Lib/xml/etree/ElementInclude.py b/Lib/xml/etree/ElementInclude.py
index 40a9b22292..986e6c3bbe 100644
--- a/Lib/xml/etree/ElementInclude.py
+++ b/Lib/xml/etree/ElementInclude.py
@@ -79,8 +79,8 @@ class LimitedRecursiveIncludeError(FatalIncludeError):
 # @param parse Parse mode.  Either "xml" or "text".
 # @param encoding Optional text encoding (UTF-8 by default for "text").
 # @return The expanded resource.  If the parse mode is "xml", this
-#    is an ElementTree instance.  If the parse mode is "text", this
-#    is a Unicode string.  If the loader fails, it can return None
+#    is an Element instance.  If the parse mode is "text", this
+#    is a string.  If the loader fails, it can return None
 #    or raise an OSError exception.
 # @throws OSError If the loader fails to load the resource.
 
@@ -98,7 +98,7 @@ def default_loader(href, parse, encoding=None):
 ##
 # Expand XInclude directives.
 #
-# @param elem Root element.
+# @param elem Root Element or any ElementTree of a tree to be expanded
 # @param loader Optional resource loader.  If omitted, it defaults
 #     to {@link default_loader}.  If given, it should be a callable
 #     that implements the same interface as <b>default_loader</b>.
@@ -106,12 +106,13 @@ def default_loader(href, parse, encoding=None):
 #     relative include file references.
 # @param max_depth The maximum number of recursive inclusions.
 #     Limited to reduce the risk of malicious content explosion.
-#     Pass a negative value to disable the limitation.
+#     Pass None to disable the limitation.
 # @throws LimitedRecursiveIncludeError If the {@link max_depth} was exceeded.
 # @throws FatalIncludeError If the function fails to include a given
 #     resource, or if the tree contains malformed XInclude elements.
-# @throws IOError If the function fails to load a given resource.
-# @returns the node or its replacement if it was an XInclude node
+# @throws OSError If the function fails to load a given resource.
+# @throws ValueError If negative {@link max_depth} is passed.
+# @returns None. Modifies tree pointed by {@link elem}
 
 def include(elem, loader=None, base_url=None,
             max_depth=DEFAULT_MAX_INCLUSION_DEPTH):
diff --git a/Lib/xml/etree/ElementPath.py b/Lib/xml/etree/ElementPath.py
index cd3c354d08..dc6bd28c03 100644
--- a/Lib/xml/etree/ElementPath.py
+++ b/Lib/xml/etree/ElementPath.py
@@ -416,6 +416,8 @@ def findall(elem, path, namespaces=None):
 def findtext(elem, path, default=None, namespaces=None):
     try:
         elem = next(iterfind(elem, path, namespaces))
-        return elem.text or ""
+        if elem.text is None:
+            return ""
+        return elem.text
     except StopIteration:
         return default
diff --git a/Lib/xml/etree/ElementTree.py b/Lib/xml/etree/ElementTree.py
index 2503d9ee76..9bb09ab540 100644
--- a/Lib/xml/etree/ElementTree.py
+++ b/Lib/xml/etree/ElementTree.py
@@ -99,6 +99,7 @@
 import collections
 import collections.abc
 import contextlib
+import weakref
 
 from . import ElementPath
 
@@ -188,19 +189,6 @@ def makeelement(self, tag, attrib):
         """
         return self.__class__(tag, attrib)
 
-    def copy(self):
-        """Return copy of current element.
-
-        This creates a shallow copy. Subelements will be shared with the
-        original tree.
-
-        """
-        warnings.warn(
-            "elem.copy() is deprecated. Use copy.copy(elem) instead.",
-            DeprecationWarning
-            )
-        return self.__copy__()
-
     def __copy__(self):
         elem = self.makeelement(self.tag, self.attrib)
         elem.text = self.text
@@ -213,9 +201,10 @@ def __len__(self):
 
     def __bool__(self):
         warnings.warn(
-            "The behavior of this method will change in future versions.  "
+            "Testing an element's truth value will always return True in "
+            "future versions.  "
             "Use specific 'len(elem)' or 'elem is not None' test instead.",
-            FutureWarning, stacklevel=2
+            DeprecationWarning, stacklevel=2
             )
         return len(self._children) != 0 # emulate old behaviour, for now
 
@@ -534,7 +523,9 @@ class ElementTree:
 
     """
     def __init__(self, element=None, file=None):
-        # assert element is None or iselement(element)
+        if element is not None and not iselement(element):
+            raise TypeError('expected an Element, not %s' %
+                            type(element).__name__)
         self._root = element # first node
         if file:
             self.parse(file)
@@ -550,7 +541,9 @@ def _setroot(self, element):
         with the given element.  Use with care!
 
         """
-        # assert iselement(element)
+        if not iselement(element):
+            raise TypeError('expected an Element, not %s'
+                            % type(element).__name__)
         self._root = element
 
     def parse(self, source, parser=None):
@@ -579,10 +572,7 @@ def parse(self, source, parser=None):
                     # it with chunks.
                     self._root = parser._parse_whole(source)
                     return self._root
-            while True:
-                data = source.read(65536)
-                if not data:
-                    break
+            while data := source.read(65536):
                 parser.feed(data)
             self._root = parser.close()
             return self._root
@@ -719,6 +709,8 @@ def write(self, file_or_filename,
                                     of start/end tags
 
         """
+        if self._root is None:
+            raise TypeError('ElementTree not initialized')
         if not method:
             method = "xml"
         elif method not in _serialize:
@@ -911,13 +903,9 @@ def _serialize_xml(write, elem, qnames, namespaces,
     if elem.tail:
         write(_escape_cdata(elem.tail))
 
-HTML_EMPTY = ("area", "base", "basefont", "br", "col", "frame", "hr",
-              "img", "input", "isindex", "link", "meta", "param")
-
-try:
-    HTML_EMPTY = set(HTML_EMPTY)
-except NameError:
-    pass
+HTML_EMPTY = {"area", "base", "basefont", "br", "col", "embed", "frame", "hr",
+              "img", "input", "isindex", "link", "meta", "param", "source",
+              "track", "wbr"}
 
 def _serialize_html(write, elem, qnames, namespaces, **kwargs):
     tag = elem.tag
@@ -1242,13 +1230,14 @@ def iterparse(source, events=None, parser=None):
     # parser argument of iterparse is removed, this can be killed.
     pullparser = XMLPullParser(events=events, _parser=parser)
 
-    def iterator(source):
+    if not hasattr(source, "read"):
+        source = open(source, "rb")
+        close_source = True
+    else:
         close_source = False
+
+    def iterator(source):
         try:
-            if not hasattr(source, "read"):
-                source = open(source, "rb")
-                close_source = True
-            yield None
             while True:
                 yield from pullparser.read_events()
                 # load event buffer
@@ -1258,18 +1247,30 @@ def iterator(source):
                 pullparser.feed(data)
             root = pullparser._close_and_return_root()
             yield from pullparser.read_events()
-            it.root = root
+            it = wr()
+            if it is not None:
+                it.root = root
         finally:
             if close_source:
                 source.close()
 
+    gen = iterator(source)
     class IterParseIterator(collections.abc.Iterator):
-        __next__ = iterator(source).__next__
+        __next__ = gen.__next__
+        def close(self):
+            if close_source:
+                source.close()
+            gen.close()
+
+        def __del__(self):
+            # TODO: Emit a ResourceWarning if it was not explicitly closed.
+            # (When the close() method will be supported in all maintained Python versions.)
+            if close_source:
+                source.close()
+
     it = IterParseIterator()
     it.root = None
-    del iterator, IterParseIterator
-
-    next(it)
+    wr = weakref.ref(it)
     return it
 
 
@@ -1325,6 +1326,11 @@ def read_events(self):
             else:
                 yield event
 
+    def flush(self):
+        if self._parser is None:
+            raise ValueError("flush() called after end of stream")
+        self._parser.flush()
+
 
 def XML(text, parser=None):
     """Parse XML document from string constant.
@@ -1731,6 +1737,15 @@ def close(self):
             del self.parser, self._parser
             del self.target, self._target
 
+    def flush(self):
+        was_enabled = self.parser.GetReparseDeferralEnabled()
+        try:
+            self.parser.SetReparseDeferralEnabled(False)
+            self.parser.Parse(b"", False)
+        except self._error as v:
+            self._raiseerror(v)
+        finally:
+            self.parser.SetReparseDeferralEnabled(was_enabled)
 
 # --------------------------------------------------------------------
 # C14N 2.0
diff --git a/Lib/xml/sax/__init__.py b/Lib/xml/sax/__init__.py
index 17b75879eb..b657310207 100644
--- a/Lib/xml/sax/__init__.py
+++ b/Lib/xml/sax/__init__.py
@@ -60,11 +60,7 @@ def parseString(string, handler, errorHandler=ErrorHandler()):
 import os, sys
 if not sys.flags.ignore_environment and "PY_SAX_PARSER" in os.environ:
     default_parser_list = os.environ["PY_SAX_PARSER"].split(",")
-del os
-
-_key = "python.xml.sax.parser"
-if sys.platform[:4] == "java" and sys.registry.containsKey(_key):
-    default_parser_list = sys.registry.getProperty(_key).split(",")
+del os, sys
 
 
 def make_parser(parser_list=()):
@@ -93,15 +89,6 @@ def make_parser(parser_list=()):
 
 # --- Internal utility methods used by make_parser
 
-if sys.platform[ : 4] == "java":
-    def _create_parser(parser_name):
-        from org.python.core import imp
-        drv_module = imp.importName(parser_name, 0, globals())
-        return drv_module.create_parser()
-
-else:
-    def _create_parser(parser_name):
-        drv_module = __import__(parser_name,{},{},['create_parser'])
-        return drv_module.create_parser()
-
-del sys
+def _create_parser(parser_name):
+    drv_module = __import__(parser_name,{},{},['create_parser'])
+    return drv_module.create_parser()
diff --git a/Lib/xml/sax/_exceptions.py b/Lib/xml/sax/_exceptions.py
index a9b2ba35c6..f292dc3a8e 100644
--- a/Lib/xml/sax/_exceptions.py
+++ b/Lib/xml/sax/_exceptions.py
@@ -1,8 +1,4 @@
 """Different kinds of SAX Exceptions"""
-import sys
-if sys.platform[:4] == "java":
-    from java.lang import Exception
-del sys
 
 # ===== SAXEXCEPTION =====
 
diff --git a/Lib/xml/sax/expatreader.py b/Lib/xml/sax/expatreader.py
index e334ac9fea..ba3c1e9851 100644
--- a/Lib/xml/sax/expatreader.py
+++ b/Lib/xml/sax/expatreader.py
@@ -12,12 +12,6 @@
 from xml.sax.handler import feature_string_interning
 from xml.sax.handler import property_xml_string, property_interning_dict
 
-# xml.parsers.expat does not raise ImportError in Jython
-import sys
-if sys.platform[:4] == "java":
-    raise SAXReaderNotAvailable("expat not available in Java", None)
-del sys
-
 try:
     from xml.parsers import expat
 except ImportError:
@@ -220,6 +214,20 @@ def feed(self, data, isFinal=False):
             # FIXME: when to invoke error()?
             self._err_handler.fatalError(exc)
 
+    def flush(self):
+        if self._parser is None:
+            return
+
+        was_enabled = self._parser.GetReparseDeferralEnabled()
+        try:
+            self._parser.SetReparseDeferralEnabled(False)
+            self._parser.Parse(b"", False)
+        except expat.error as e:
+            exc = SAXParseException(expat.ErrorString(e.code), e, self)
+            self._err_handler.fatalError(exc)
+        finally:
+            self._parser.SetReparseDeferralEnabled(was_enabled)
+
     def _close_source(self):
         source = self._source
         try:
diff --git a/Lib/xml/sax/xmlreader.py b/Lib/xml/sax/xmlreader.py
index 716f228404..e906121d23 100644
--- a/Lib/xml/sax/xmlreader.py
+++ b/Lib/xml/sax/xmlreader.py
@@ -120,10 +120,8 @@ def parse(self, source):
         file = source.getCharacterStream()
         if file is None:
             file = source.getByteStream()
-        buffer = file.read(self._bufsize)
-        while buffer:
+        while buffer := file.read(self._bufsize):
             self.feed(buffer)
-            buffer = file.read(self._bufsize)
         self.close()
 
     def feed(self, data):
diff --git a/Lib/xmlrpc/client.py b/Lib/xmlrpc/client.py
index 121e44023c..f441376d09 100644
--- a/Lib/xmlrpc/client.py
+++ b/Lib/xmlrpc/client.py
@@ -135,8 +135,7 @@
 from decimal import Decimal
 import http.client
 import urllib.parse
-# XXX RUSTPYTHON TODO: pyexpat
-# from xml.parsers import expat
+from xml.parsers import expat
 import errno
 from io import BytesIO
 try:
@@ -246,41 +245,15 @@ def __repr__(self):
 
 ##
 # Backwards compatibility
-
 boolean = Boolean = bool
 
-##
-# Wrapper for XML-RPC DateTime values.  This converts a time value to
-# the format used by XML-RPC.
-# <p>
-# The value can be given as a datetime object, as a string in the
-# format "yyyymmddThh:mm:ss", as a 9-item time tuple (as returned by
-# time.localtime()), or an integer value (as returned by time.time()).
-# The wrapper uses time.localtime() to convert an integer to a time
-# tuple.
-#
-# @param value The time, given as a datetime object, an ISO 8601 string,
-#              a time tuple, or an integer time value.
-
 
-# Issue #13305: different format codes across platforms
-_day0 = datetime(1, 1, 1)
-def _try(fmt):
-    try:
-        return _day0.strftime(fmt) == '0001'
-    except ValueError:
-        return False
-if _try('%Y'):      # Mac OS X
-    def _iso8601_format(value):
-        return value.strftime("%Y%m%dT%H:%M:%S")
-elif _try('%4Y'):   # Linux
-    def _iso8601_format(value):
-        return value.strftime("%4Y%m%dT%H:%M:%S")
-else:
-    def _iso8601_format(value):
-        return value.strftime("%Y%m%dT%H:%M:%S").zfill(17)
-del _day0
-del _try
+def _iso8601_format(value):
+    if value.tzinfo is not None:
+        # XML-RPC only uses the naive portion of the datetime
+        value = value.replace(tzinfo=None)
+    # XML-RPC doesn't use '-' separator in the date part
+    return value.isoformat(timespec='seconds').replace('-', '')
 
 
 def _strftime(value):
@@ -851,9 +824,9 @@ def __init__(self, results):
 
     def __getitem__(self, i):
         item = self.results[i]
-        if type(item) == type({}):
+        if isinstance(item, dict):
             raise Fault(item['faultCode'], item['faultString'])
-        elif type(item) == type([]):
+        elif isinstance(item, list):
             return item[0]
         else:
             raise ValueError("unexpected type in multicall result")
@@ -1340,10 +1313,7 @@ def parse_response(self, response):
 
         p, u = self.getparser()
 
-        while 1:
-            data = stream.read(1024)
-            if not data:
-                break
+        while data := stream.read(1024):
             if self.verbose:
                 print("body:", repr(data))
             p.feed(data)
diff --git a/Lib/xmlrpc/server.py b/Lib/xmlrpc/server.py
index 69a260f5b1..4dddb1d10e 100644
--- a/Lib/xmlrpc/server.py
+++ b/Lib/xmlrpc/server.py
@@ -268,17 +268,11 @@ def _marshaled_dispatch(self, data, dispatch_method = None, path = None):
         except Fault as fault:
             response = dumps(fault, allow_none=self.allow_none,
                              encoding=self.encoding)
-        except:
-            # report exception back to server
-            exc_type, exc_value, exc_tb = sys.exc_info()
-            try:
-                response = dumps(
-                    Fault(1, "%s:%s" % (exc_type, exc_value)),
-                    encoding=self.encoding, allow_none=self.allow_none,
-                    )
-            finally:
-                # Break reference cycle
-                exc_type = exc_value = exc_tb = None
+        except BaseException as exc:
+            response = dumps(
+                Fault(1, "%s:%s" % (type(exc), exc)),
+                encoding=self.encoding, allow_none=self.allow_none,
+                )
 
         return response.encode(self.encoding, 'xmlcharrefreplace')
 
@@ -368,16 +362,11 @@ def system_multicall(self, call_list):
                     {'faultCode' : fault.faultCode,
                      'faultString' : fault.faultString}
                     )
-            except:
-                exc_type, exc_value, exc_tb = sys.exc_info()
-                try:
-                    results.append(
-                        {'faultCode' : 1,
-                         'faultString' : "%s:%s" % (exc_type, exc_value)}
-                        )
-                finally:
-                    # Break reference cycle
-                    exc_type = exc_value = exc_tb = None
+            except BaseException as exc:
+                results.append(
+                    {'faultCode' : 1,
+                     'faultString' : "%s:%s" % (type(exc), exc)}
+                    )
         return results
 
     def _dispatch(self, method, params):
@@ -440,7 +429,7 @@ class SimpleXMLRPCRequestHandler(BaseHTTPRequestHandler):
 
     # Class attribute listing the accessible path components;
     # paths not on this list will result in a 404 error.
-    rpc_paths = ('/', '/RPC2')
+    rpc_paths = ('/', '/RPC2', '/pydoc.css')
 
     #if not None, encode responses larger than this, if possible
     encode_threshold = 1400 #a common MTU
@@ -634,19 +623,14 @@ def _marshaled_dispatch(self, data, dispatch_method = None, path = None):
         try:
             response = self.dispatchers[path]._marshaled_dispatch(
                data, dispatch_method, path)
-        except:
+        except BaseException as exc:
             # report low level exception back to server
             # (each dispatcher should have handled their own
             # exceptions)
-            exc_type, exc_value = sys.exc_info()[:2]
-            try:
-                response = dumps(
-                    Fault(1, "%s:%s" % (exc_type, exc_value)),
-                    encoding=self.encoding, allow_none=self.allow_none)
-                response = response.encode(self.encoding, 'xmlcharrefreplace')
-            finally:
-                # Break reference cycle
-                exc_type = exc_value = None
+            response = dumps(
+                Fault(1, "%s:%s" % (type(exc), exc)),
+                encoding=self.encoding, allow_none=self.allow_none)
+            response = response.encode(self.encoding, 'xmlcharrefreplace')
         return response
 
 class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher):
@@ -736,9 +720,7 @@ def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
                                 r'RFC[- ]?(\d+)|'
                                 r'PEP[- ]?(\d+)|'
                                 r'(self\.)?((?:\w|\.)+))\b')
-        while 1:
-            match = pattern.search(text, here)
-            if not match: break
+        while match := pattern.search(text, here):
             start, end = match.span()
             results.append(escape(text[here:start]))
 
@@ -747,10 +729,10 @@ def markup(self, text, escape=None, funcs={}, classes={}, methods={}):
                 url = escape(all).replace('"', '&quot;')
                 results.append('<a href="%s">%s</a>' % (url, url))
             elif rfc:
-                url = 'http://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
+                url = 'https://www.rfc-editor.org/rfc/rfc%d.txt' % int(rfc)
                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
             elif pep:
-                url = 'https://www.python.org/dev/peps/pep-%04d/' % int(pep)
+                url = 'https://peps.python.org/pep-%04d/' % int(pep)
                 results.append('<a href="%s">%s</a>' % (url, escape(all)))
             elif text[end:end+1] == '(':
                 results.append(self.namelink(name, methods, funcs, classes))
@@ -801,7 +783,7 @@ def docserver(self, server_name, package_documentation, methods):
 
         server_name = self.escape(server_name)
         head = '<big><big><strong>%s</strong></big></big>' % server_name
-        result = self.heading(head, '#ffffff', '#7799ee')
+        result = self.heading(head)
 
         doc = self.markup(package_documentation, self.preformat, fdict)
         doc = doc and '<tt>%s</tt>' % doc
@@ -812,10 +794,25 @@ def docserver(self, server_name, package_documentation, methods):
         for key, value in method_items:
             contents.append(self.docroutine(value, key, funcs=fdict))
         result = result + self.bigsection(
-            'Methods', '#ffffff', '#eeaa77', ''.join(contents))
+            'Methods', 'functions', ''.join(contents))
 
         return result
 
+
+    def page(self, title, contents):
+        """Format an HTML page."""
+        css_path = "/pydoc.css"
+        css_link = (
+            '<link rel="stylesheet" type="text/css" href="%s">' %
+            css_path)
+        return '''\
+<!DOCTYPE>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Python: %s</title>
+%s</head><body>%s</body></html>''' % (title, css_link, contents)
+
 class XMLRPCDocGenerator:
     """Generates documentation for an XML-RPC server.
 
@@ -907,6 +904,12 @@ class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
     for documentation.
     """
 
+    def _get_css(self, url):
+        path_here = os.path.dirname(os.path.realpath(__file__))
+        css_path = os.path.join(path_here, "..", "pydoc_data", "_pydoc.css")
+        with open(css_path, mode="rb") as fp:
+            return fp.read()
+
     def do_GET(self):
         """Handles the HTTP GET request.
 
@@ -918,9 +921,15 @@ def do_GET(self):
             self.report_404()
             return
 
-        response = self.server.generate_html_documentation().encode('utf-8')
+        if self.path.endswith('.css'):
+            content_type = 'text/css'
+            response = self._get_css(self.path)
+        else:
+            content_type = 'text/html'
+            response = self.server.generate_html_documentation().encode('utf-8')
+
         self.send_response(200)
-        self.send_header("Content-type", "text/html")
+        self.send_header('Content-Type', '%s; charset=UTF-8' % content_type)
         self.send_header("Content-length", str(len(response)))
         self.end_headers()
         self.wfile.write(response)
diff --git a/Lib/zipapp.py b/Lib/zipapp.py
index ce77632516..4ffacc49fa 100644
--- a/Lib/zipapp.py
+++ b/Lib/zipapp.py
@@ -131,12 +131,35 @@ def create_archive(source, target=None, interpreter=None, main=None,
     elif not hasattr(target, 'write'):
         target = pathlib.Path(target)
 
+    # 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('*'))
+
+    # 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
+    # itself, which is an error. We therefore check for that case and
+    # provide a helpful message for the user.
+
+    # Note that we only do a simple path equality check. This won't
+    # catch every case, but it will catch the common case where the
+    # source is the CWD and the target is a file in the CWD. More
+    # thorough checks don't provide enough value to justify the extra
+    # cost.
+
+    # If target is a file-like object, it will simply fail to compare
+    # equal to any of the entries in files_to_add, so there's no need
+    # to add a special check for that.
+    if target in files_to_add:
+        raise ZipAppError(
+            f"The target archive {target} overwrites one of the source files.")
+
     with _maybe_open(target, 'wb') as fd:
         _write_file_prefix(fd, interpreter)
         compression = (zipfile.ZIP_DEFLATED if compressed else
                        zipfile.ZIP_STORED)
         with zipfile.ZipFile(fd, 'w', compression=compression) as z:
-            for child in source.rglob('*'):
+            for child in files_to_add:
                 arcname = child.relative_to(source)
                 if filter is None or filter(arcname):
                     z.write(child, arcname.as_posix())
diff --git a/Lib/zipfile.py b/Lib/zipfile.py
deleted file mode 100644
index ef1eb47f9f..0000000000
--- a/Lib/zipfile.py
+++ /dev/null
@@ -1,2483 +0,0 @@
-"""
-Read and write ZIP files.
-
-XXX references to utf-8 need further investigation.
-"""
-import binascii
-import importlib.util
-import io
-import itertools
-try:
-    import os
-except ImportError:
-    import _dummy_os as os
-import posixpath
-try:
-    import shutil
-except ImportError:
-    pass
-import stat
-import struct
-import sys
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-import time
-import contextlib
-import pathlib
-
-try:
-    import zlib # We may need its compression method
-    crc32 = zlib.crc32
-except ImportError:
-    zlib = None
-    crc32 = binascii.crc32
-
-try:
-    import bz2 # We may need its compression method
-except ImportError:
-    bz2 = None
-
-try:
-    import lzma # We may need its compression method
-except ImportError:
-    lzma = None
-
-__all__ = ["BadZipFile", "BadZipfile", "error",
-           "ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA",
-           "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile",
-           "Path"]
-
-class BadZipFile(Exception):
-    pass
-
-
-class LargeZipFile(Exception):
-    """
-    Raised when writing a zipfile, the zipfile requires ZIP64 extensions
-    and those extensions are disabled.
-    """
-
-error = BadZipfile = BadZipFile      # Pre-3.2 compatibility names
-
-
-ZIP64_LIMIT = (1 << 31) - 1
-ZIP_FILECOUNT_LIMIT = (1 << 16) - 1
-ZIP_MAX_COMMENT = (1 << 16) - 1
-
-# constants for Zip file compression methods
-ZIP_STORED = 0
-ZIP_DEFLATED = 8
-ZIP_BZIP2 = 12
-ZIP_LZMA = 14
-# Other ZIP compression methods not supported
-
-DEFAULT_VERSION = 20
-ZIP64_VERSION = 45
-BZIP2_VERSION = 46
-LZMA_VERSION = 63
-# we recognize (but not necessarily support) all features up to that version
-MAX_EXTRACT_VERSION = 63
-
-# Below are some formats and associated data for reading/writing headers using
-# the struct module.  The names and structures of headers/records are those used
-# in the PKWARE description of the ZIP file format:
-#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
-# (URL valid as of January 2008)
-
-# The "end of central directory" structure, magic number, size, and indices
-# (section V.I in the format document)
-structEndArchive = b"<4s4H2LH"
-stringEndArchive = b"PK\005\006"
-sizeEndCentDir = struct.calcsize(structEndArchive)
-
-_ECD_SIGNATURE = 0
-_ECD_DISK_NUMBER = 1
-_ECD_DISK_START = 2
-_ECD_ENTRIES_THIS_DISK = 3
-_ECD_ENTRIES_TOTAL = 4
-_ECD_SIZE = 5
-_ECD_OFFSET = 6
-_ECD_COMMENT_SIZE = 7
-# These last two indices are not part of the structure as defined in the
-# spec, but they are used internally by this module as a convenience
-_ECD_COMMENT = 8
-_ECD_LOCATION = 9
-
-# The "central directory" structure, magic number, size, and indices
-# of entries in the structure (section V.F in the format document)
-structCentralDir = "<4s4B4HL2L5H2L"
-stringCentralDir = b"PK\001\002"
-sizeCentralDir = struct.calcsize(structCentralDir)
-
-# indexes of entries in the central directory structure
-_CD_SIGNATURE = 0
-_CD_CREATE_VERSION = 1
-_CD_CREATE_SYSTEM = 2
-_CD_EXTRACT_VERSION = 3
-_CD_EXTRACT_SYSTEM = 4
-_CD_FLAG_BITS = 5
-_CD_COMPRESS_TYPE = 6
-_CD_TIME = 7
-_CD_DATE = 8
-_CD_CRC = 9
-_CD_COMPRESSED_SIZE = 10
-_CD_UNCOMPRESSED_SIZE = 11
-_CD_FILENAME_LENGTH = 12
-_CD_EXTRA_FIELD_LENGTH = 13
-_CD_COMMENT_LENGTH = 14
-_CD_DISK_NUMBER_START = 15
-_CD_INTERNAL_FILE_ATTRIBUTES = 16
-_CD_EXTERNAL_FILE_ATTRIBUTES = 17
-_CD_LOCAL_HEADER_OFFSET = 18
-
-# The "local file header" structure, magic number, size, and indices
-# (section V.A in the format document)
-structFileHeader = "<4s2B4HL2L2H"
-stringFileHeader = b"PK\003\004"
-sizeFileHeader = struct.calcsize(structFileHeader)
-
-_FH_SIGNATURE = 0
-_FH_EXTRACT_VERSION = 1
-_FH_EXTRACT_SYSTEM = 2
-_FH_GENERAL_PURPOSE_FLAG_BITS = 3
-_FH_COMPRESSION_METHOD = 4
-_FH_LAST_MOD_TIME = 5
-_FH_LAST_MOD_DATE = 6
-_FH_CRC = 7
-_FH_COMPRESSED_SIZE = 8
-_FH_UNCOMPRESSED_SIZE = 9
-_FH_FILENAME_LENGTH = 10
-_FH_EXTRA_FIELD_LENGTH = 11
-
-# The "Zip64 end of central directory locator" structure, magic number, and size
-structEndArchive64Locator = "<4sLQL"
-stringEndArchive64Locator = b"PK\x06\x07"
-sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)
-
-# The "Zip64 end of central directory" record, magic number, size, and indices
-# (section V.G in the format document)
-structEndArchive64 = "<4sQ2H2L4Q"
-stringEndArchive64 = b"PK\x06\x06"
-sizeEndCentDir64 = struct.calcsize(structEndArchive64)
-
-_CD64_SIGNATURE = 0
-_CD64_DIRECTORY_RECSIZE = 1
-_CD64_CREATE_VERSION = 2
-_CD64_EXTRACT_VERSION = 3
-_CD64_DISK_NUMBER = 4
-_CD64_DISK_NUMBER_START = 5
-_CD64_NUMBER_ENTRIES_THIS_DISK = 6
-_CD64_NUMBER_ENTRIES_TOTAL = 7
-_CD64_DIRECTORY_SIZE = 8
-_CD64_OFFSET_START_CENTDIR = 9
-
-_DD_SIGNATURE = 0x08074b50
-
-_EXTRA_FIELD_STRUCT = struct.Struct('<HH')
-
-def _strip_extra(extra, xids):
-    # Remove Extra Fields with specified IDs.
-    unpack = _EXTRA_FIELD_STRUCT.unpack
-    modified = False
-    buffer = []
-    start = i = 0
-    while i + 4 <= len(extra):
-        xid, xlen = unpack(extra[i : i + 4])
-        j = i + 4 + xlen
-        if xid in xids:
-            if i != start:
-                buffer.append(extra[start : i])
-            start = j
-            modified = True
-        i = j
-    if not modified:
-        return extra
-    return b''.join(buffer)
-
-def _check_zipfile(fp):
-    try:
-        if _EndRecData(fp):
-            return True         # file has correct magic number
-    except OSError:
-        pass
-    return False
-
-def is_zipfile(filename):
-    """Quickly see if a file is a ZIP file by checking the magic number.
-
-    The filename argument may be a file or file-like object too.
-    """
-    result = False
-    try:
-        if hasattr(filename, "read"):
-            result = _check_zipfile(fp=filename)
-        else:
-            with open(filename, "rb") as fp:
-                result = _check_zipfile(fp)
-    except OSError:
-        pass
-    return result
-
-def _EndRecData64(fpin, offset, endrec):
-    """
-    Read the ZIP64 end-of-archive records and use that to update endrec
-    """
-    try:
-        fpin.seek(offset - sizeEndCentDir64Locator, 2)
-    except OSError:
-        # If the seek fails, the file is not large enough to contain a ZIP64
-        # end-of-archive record, so just return the end record we were given.
-        return endrec
-
-    data = fpin.read(sizeEndCentDir64Locator)
-    if len(data) != sizeEndCentDir64Locator:
-        return endrec
-    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
-    if sig != stringEndArchive64Locator:
-        return endrec
-
-    if diskno != 0 or disks > 1:
-        raise BadZipFile("zipfiles that span multiple disks are not supported")
-
-    # Assume no 'zip64 extensible data'
-    fpin.seek(offset - sizeEndCentDir64Locator - sizeEndCentDir64, 2)
-    data = fpin.read(sizeEndCentDir64)
-    if len(data) != sizeEndCentDir64:
-        return endrec
-    sig, sz, create_version, read_version, disk_num, disk_dir, \
-        dircount, dircount2, dirsize, diroffset = \
-        struct.unpack(structEndArchive64, data)
-    if sig != stringEndArchive64:
-        return endrec
-
-    # Update the original endrec using data from the ZIP64 record
-    endrec[_ECD_SIGNATURE] = sig
-    endrec[_ECD_DISK_NUMBER] = disk_num
-    endrec[_ECD_DISK_START] = disk_dir
-    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
-    endrec[_ECD_ENTRIES_TOTAL] = dircount2
-    endrec[_ECD_SIZE] = dirsize
-    endrec[_ECD_OFFSET] = diroffset
-    return endrec
-
-
-def _EndRecData(fpin):
-    """Return data from the "End of Central Directory" record, or None.
-
-    The data is a list of the nine items in the ZIP "End of central dir"
-    record followed by a tenth item, the file seek offset of this record."""
-
-    # Determine file size
-    fpin.seek(0, 2)
-    filesize = fpin.tell()
-
-    # Check to see if this is ZIP file with no archive comment (the
-    # "end of central directory" structure should be the last item in the
-    # file if this is the case).
-    try:
-        fpin.seek(-sizeEndCentDir, 2)
-    except OSError:
-        return None
-    data = fpin.read()
-    if (len(data) == sizeEndCentDir and
-        data[0:4] == stringEndArchive and
-        data[-2:] == b"\000\000"):
-        # the signature is correct and there's no comment, unpack structure
-        endrec = struct.unpack(structEndArchive, data)
-        endrec=list(endrec)
-
-        # Append a blank comment and record start offset
-        endrec.append(b"")
-        endrec.append(filesize - sizeEndCentDir)
-
-        # Try to read the "Zip64 end of central directory" structure
-        return _EndRecData64(fpin, -sizeEndCentDir, endrec)
-
-    # Either this is not a ZIP file, or it is a ZIP file with an archive
-    # comment.  Search the end of the file for the "end of central directory"
-    # record signature. The comment is the last item in the ZIP file and may be
-    # up to 64K long.  It is assumed that the "end of central directory" magic
-    # number does not appear in the comment.
-    maxCommentStart = max(filesize - (1 << 16) - sizeEndCentDir, 0)
-    fpin.seek(maxCommentStart, 0)
-    data = fpin.read()
-    start = data.rfind(stringEndArchive)
-    if start >= 0:
-        # found the magic number; attempt to unpack and interpret
-        recData = data[start:start+sizeEndCentDir]
-        if len(recData) != sizeEndCentDir:
-            # Zip file is corrupted.
-            return None
-        endrec = list(struct.unpack(structEndArchive, recData))
-        commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file
-        comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize]
-        endrec.append(comment)
-        endrec.append(maxCommentStart + start)
-
-        # Try to read the "Zip64 end of central directory" structure
-        return _EndRecData64(fpin, maxCommentStart + start - filesize,
-                             endrec)
-
-    # Unable to find a valid end of central directory structure
-    return None
-
-
-class ZipInfo (object):
-    """Class with attributes describing each file in the ZIP archive."""
-
-    __slots__ = (
-        'orig_filename',
-        'filename',
-        'date_time',
-        'compress_type',
-        '_compresslevel',
-        'comment',
-        'extra',
-        'create_system',
-        'create_version',
-        'extract_version',
-        'reserved',
-        'flag_bits',
-        'volume',
-        'internal_attr',
-        'external_attr',
-        'header_offset',
-        'CRC',
-        'compress_size',
-        'file_size',
-        '_raw_time',
-    )
-
-    def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
-        self.orig_filename = filename   # Original file name in archive
-
-        # Terminate the file name at the first null byte.  Null bytes in file
-        # names are used as tricks by viruses in archives.
-        null_byte = filename.find(chr(0))
-        if null_byte >= 0:
-            filename = filename[0:null_byte]
-        # This is used to ensure paths in generated ZIP files always use
-        # forward slashes as the directory separator, as required by the
-        # ZIP format specification.
-        if os.sep != "/" and os.sep in filename:
-            filename = filename.replace(os.sep, "/")
-
-        self.filename = filename        # Normalized file name
-        self.date_time = date_time      # year, month, day, hour, min, sec
-
-        if date_time[0] < 1980:
-            raise ValueError('ZIP does not support timestamps before 1980')
-
-        # Standard values:
-        self.compress_type = ZIP_STORED # Type of compression for the file
-        self._compresslevel = None      # Level for the compressor
-        self.comment = b""              # Comment for each file
-        self.extra = b""                # ZIP extra data
-        if sys.platform == 'win32':
-            self.create_system = 0          # System which created ZIP archive
-        else:
-            # Assume everything else is unix-y
-            self.create_system = 3          # System which created ZIP archive
-        self.create_version = DEFAULT_VERSION  # Version which created ZIP archive
-        self.extract_version = DEFAULT_VERSION # Version needed to extract archive
-        self.reserved = 0               # Must be zero
-        self.flag_bits = 0              # ZIP flag bits
-        self.volume = 0                 # Volume number of file header
-        self.internal_attr = 0          # Internal attributes
-        self.external_attr = 0          # External file attributes
-        self.compress_size = 0          # Size of the compressed file
-        self.file_size = 0              # Size of the uncompressed file
-        # Other attributes are set by class ZipFile:
-        # header_offset         Byte offset to the file header
-        # CRC                   CRC-32 of the uncompressed file
-
-    def __repr__(self):
-        result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)]
-        if self.compress_type != ZIP_STORED:
-            result.append(' compress_type=%s' %
-                          compressor_names.get(self.compress_type,
-                                               self.compress_type))
-        hi = self.external_attr >> 16
-        lo = self.external_attr & 0xFFFF
-        if hi:
-            result.append(' filemode=%r' % stat.filemode(hi))
-        if lo:
-            result.append(' external_attr=%#x' % lo)
-        isdir = self.is_dir()
-        if not isdir or self.file_size:
-            result.append(' file_size=%r' % self.file_size)
-        if ((not isdir or self.compress_size) and
-            (self.compress_type != ZIP_STORED or
-             self.file_size != self.compress_size)):
-            result.append(' compress_size=%r' % self.compress_size)
-        result.append('>')
-        return ''.join(result)
-
-    def FileHeader(self, zip64=None):
-        """Return the per-file header as a bytes object."""
-        dt = self.date_time
-        dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
-        dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
-        if self.flag_bits & 0x08:
-            # Set these to zero because we write them after the file data
-            CRC = compress_size = file_size = 0
-        else:
-            CRC = self.CRC
-            compress_size = self.compress_size
-            file_size = self.file_size
-
-        extra = self.extra
-
-        min_version = 0
-        if zip64 is None:
-            zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT
-        if zip64:
-            fmt = '<HHQQ'
-            extra = extra + struct.pack(fmt,
-                                        1, struct.calcsize(fmt)-4, file_size, compress_size)
-        if file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT:
-            if not zip64:
-                raise LargeZipFile("Filesize would require ZIP64 extensions")
-            # File is larger than what fits into a 4 byte integer,
-            # fall back to the ZIP64 extension
-            file_size = 0xffffffff
-            compress_size = 0xffffffff
-            min_version = ZIP64_VERSION
-
-        if self.compress_type == ZIP_BZIP2:
-            min_version = max(BZIP2_VERSION, min_version)
-        elif self.compress_type == ZIP_LZMA:
-            min_version = max(LZMA_VERSION, min_version)
-
-        self.extract_version = max(min_version, self.extract_version)
-        self.create_version = max(min_version, self.create_version)
-        filename, flag_bits = self._encodeFilenameFlags()
-        header = struct.pack(structFileHeader, stringFileHeader,
-                             self.extract_version, self.reserved, flag_bits,
-                             self.compress_type, dostime, dosdate, CRC,
-                             compress_size, file_size,
-                             len(filename), len(extra))
-        return header + filename + extra
-
-    def _encodeFilenameFlags(self):
-        try:
-            return self.filename.encode('ascii'), self.flag_bits
-        except UnicodeEncodeError:
-            return self.filename.encode('utf-8'), self.flag_bits | 0x800
-
-    def _decodeExtra(self):
-        # Try to decode the extra field.
-        extra = self.extra
-        unpack = struct.unpack
-        while len(extra) >= 4:
-            tp, ln = unpack('<HH', extra[:4])
-            if ln+4 > len(extra):
-                raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln))
-            if tp == 0x0001:
-                data = extra[4:ln+4]
-                # ZIP64 extension (large files and/or large archives)
-                try:
-                    if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
-                        field = "File size"
-                        self.file_size, = unpack('<Q', data[:8])
-                        data = data[8:]
-                    if self.compress_size == 0xFFFF_FFFF:
-                        field = "Compress size"
-                        self.compress_size, = unpack('<Q', data[:8])
-                        data = data[8:]
-                    if self.header_offset == 0xFFFF_FFFF:
-                        field = "Header offset"
-                        self.header_offset, = unpack('<Q', data[:8])
-                except struct.error:
-                    raise BadZipFile(f"Corrupt zip64 extra field. "
-                                     f"{field} not found.") from None
-
-            extra = extra[ln+4:]
-
-    @classmethod
-    def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
-        """Construct an appropriate ZipInfo for a file on the filesystem.
-
-        filename should be the path to a file or directory on the filesystem.
-
-        arcname is the name which it will have within the archive (by default,
-        this will be the same as filename, but without a drive letter and with
-        leading path separators removed).
-        """
-        if isinstance(filename, os.PathLike):
-            filename = os.fspath(filename)
-        st = os.stat(filename)
-        isdir = stat.S_ISDIR(st.st_mode)
-        mtime = time.localtime(st.st_mtime)
-        date_time = mtime[0:6]
-        if not strict_timestamps and date_time[0] < 1980:
-            date_time = (1980, 1, 1, 0, 0, 0)
-        elif not strict_timestamps and date_time[0] > 2107:
-            date_time = (2107, 12, 31, 23, 59, 59)
-        # Create ZipInfo instance to store file information
-        if arcname is None:
-            arcname = filename
-        arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
-        while arcname[0] in (os.sep, os.altsep):
-            arcname = arcname[1:]
-        if isdir:
-            arcname += '/'
-        zinfo = cls(arcname, date_time)
-        zinfo.external_attr = (st.st_mode & 0xFFFF) << 16  # Unix attributes
-        if isdir:
-            zinfo.file_size = 0
-            zinfo.external_attr |= 0x10  # MS-DOS directory flag
-        else:
-            zinfo.file_size = st.st_size
-
-        return zinfo
-
-    def is_dir(self):
-        """Return True if this archive member is a directory."""
-        return self.filename[-1] == '/'
-
-
-# ZIP encryption uses the CRC32 one-byte primitive for scrambling some
-# internal keys. We noticed that a direct implementation is faster than
-# relying on binascii.crc32().
-
-_crctable = None
-def _gen_crc(crc):
-    for j in range(8):
-        if crc & 1:
-            crc = (crc >> 1) ^ 0xEDB88320
-        else:
-            crc >>= 1
-    return crc
-
-# ZIP supports a password-based form of encryption. Even though known
-# plaintext attacks have been found against it, it is still useful
-# to be able to get data out of such a file.
-#
-# Usage:
-#     zd = _ZipDecrypter(mypwd)
-#     plain_bytes = zd(cypher_bytes)
-
-def _ZipDecrypter(pwd):
-    key0 = 305419896
-    key1 = 591751049
-    key2 = 878082192
-
-    global _crctable
-    if _crctable is None:
-        _crctable = list(map(_gen_crc, range(256)))
-    crctable = _crctable
-
-    def crc32(ch, crc):
-        """Compute the CRC32 primitive on one byte."""
-        return (crc >> 8) ^ crctable[(crc ^ ch) & 0xFF]
-
-    def update_keys(c):
-        nonlocal key0, key1, key2
-        key0 = crc32(c, key0)
-        key1 = (key1 + (key0 & 0xFF)) & 0xFFFFFFFF
-        key1 = (key1 * 134775813 + 1) & 0xFFFFFFFF
-        key2 = crc32(key1 >> 24, key2)
-
-    for p in pwd:
-        update_keys(p)
-
-    def decrypter(data):
-        """Decrypt a bytes object."""
-        result = bytearray()
-        append = result.append
-        for c in data:
-            k = key2 | 2
-            c ^= ((k * (k^1)) >> 8) & 0xFF
-            update_keys(c)
-            append(c)
-        return bytes(result)
-
-    return decrypter
-
-
-class LZMACompressor:
-
-    def __init__(self):
-        self._comp = None
-
-    def _init(self):
-        props = lzma._encode_filter_properties({'id': lzma.FILTER_LZMA1})
-        self._comp = lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[
-            lzma._decode_filter_properties(lzma.FILTER_LZMA1, props)
-        ])
-        return struct.pack('<BBH', 9, 4, len(props)) + props
-
-    def compress(self, data):
-        if self._comp is None:
-            return self._init() + self._comp.compress(data)
-        return self._comp.compress(data)
-
-    def flush(self):
-        if self._comp is None:
-            return self._init() + self._comp.flush()
-        return self._comp.flush()
-
-
-class LZMADecompressor:
-
-    def __init__(self):
-        self._decomp = None
-        self._unconsumed = b''
-        self.eof = False
-
-    def decompress(self, data):
-        if self._decomp is None:
-            self._unconsumed += data
-            if len(self._unconsumed) <= 4:
-                return b''
-            psize, = struct.unpack('<H', self._unconsumed[2:4])
-            if len(self._unconsumed) <= 4 + psize:
-                return b''
-
-            self._decomp = lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[
-                lzma._decode_filter_properties(lzma.FILTER_LZMA1,
-                                               self._unconsumed[4:4 + psize])
-            ])
-            data = self._unconsumed[4 + psize:]
-            del self._unconsumed
-
-        result = self._decomp.decompress(data)
-        self.eof = self._decomp.eof
-        return result
-
-
-compressor_names = {
-    0: 'store',
-    1: 'shrink',
-    2: 'reduce',
-    3: 'reduce',
-    4: 'reduce',
-    5: 'reduce',
-    6: 'implode',
-    7: 'tokenize',
-    8: 'deflate',
-    9: 'deflate64',
-    10: 'implode',
-    12: 'bzip2',
-    14: 'lzma',
-    18: 'terse',
-    19: 'lz77',
-    97: 'wavpack',
-    98: 'ppmd',
-}
-
-def _check_compression(compression):
-    if compression == ZIP_STORED:
-        pass
-    elif compression == ZIP_DEFLATED:
-        if not zlib:
-            raise RuntimeError(
-                "Compression requires the (missing) zlib module")
-    elif compression == ZIP_BZIP2:
-        if not bz2:
-            raise RuntimeError(
-                "Compression requires the (missing) bz2 module")
-    elif compression == ZIP_LZMA:
-        if not lzma:
-            raise RuntimeError(
-                "Compression requires the (missing) lzma module")
-    else:
-        raise NotImplementedError("That compression method is not supported")
-
-
-def _get_compressor(compress_type, compresslevel=None):
-    if compress_type == ZIP_DEFLATED:
-        if compresslevel is not None:
-            return zlib.compressobj(compresslevel, zlib.DEFLATED, -15)
-        return zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
-    elif compress_type == ZIP_BZIP2:
-        if compresslevel is not None:
-            return bz2.BZ2Compressor(compresslevel)
-        return bz2.BZ2Compressor()
-    # compresslevel is ignored for ZIP_LZMA
-    elif compress_type == ZIP_LZMA:
-        return LZMACompressor()
-    else:
-        return None
-
-
-def _get_decompressor(compress_type):
-    _check_compression(compress_type)
-    if compress_type == ZIP_STORED:
-        return None
-    elif compress_type == ZIP_DEFLATED:
-        return zlib.decompressobj(-15)
-    elif compress_type == ZIP_BZIP2:
-        return bz2.BZ2Decompressor()
-    elif compress_type == ZIP_LZMA:
-        return LZMADecompressor()
-    else:
-        descr = compressor_names.get(compress_type)
-        if descr:
-            raise NotImplementedError("compression type %d (%s)" % (compress_type, descr))
-        else:
-            raise NotImplementedError("compression type %d" % (compress_type,))
-
-
-class _SharedFile:
-    def __init__(self, file, pos, close, lock, writing):
-        self._file = file
-        self._pos = pos
-        self._close = close
-        self._lock = lock
-        self._writing = writing
-        self.seekable = file.seekable
-
-    def tell(self):
-        return self._pos
-
-    def seek(self, offset, whence=0):
-        with self._lock:
-            if self._writing():
-                raise ValueError("Can't reposition in the ZIP file while "
-                        "there is an open writing handle on it. "
-                        "Close the writing handle before trying to read.")
-            self._file.seek(offset, whence)
-            self._pos = self._file.tell()
-            return self._pos
-
-    def read(self, n=-1):
-        with self._lock:
-            if self._writing():
-                raise ValueError("Can't read from the ZIP file while there "
-                        "is an open writing handle on it. "
-                        "Close the writing handle before trying to read.")
-            self._file.seek(self._pos)
-            data = self._file.read(n)
-            self._pos = self._file.tell()
-            return data
-
-    def close(self):
-        if self._file is not None:
-            fileobj = self._file
-            self._file = None
-            self._close(fileobj)
-
-# Provide the tell method for unseekable stream
-class _Tellable:
-    def __init__(self, fp):
-        self.fp = fp
-        self.offset = 0
-
-    def write(self, data):
-        n = self.fp.write(data)
-        self.offset += n
-        return n
-
-    def tell(self):
-        return self.offset
-
-    def flush(self):
-        self.fp.flush()
-
-    def close(self):
-        self.fp.close()
-
-
-class ZipExtFile(io.BufferedIOBase):
-    """File-like object for reading an archive member.
-       Is returned by ZipFile.open().
-    """
-
-    # Max size supported by decompressor.
-    MAX_N = 1 << 31 - 1
-
-    # Read from compressed files in 4k blocks.
-    MIN_READ_SIZE = 4096
-
-    # Chunk size to read during seek
-    MAX_SEEK_READ = 1 << 24
-
-    def __init__(self, fileobj, mode, zipinfo, pwd=None,
-                 close_fileobj=False):
-        self._fileobj = fileobj
-        self._pwd = pwd
-        self._close_fileobj = close_fileobj
-
-        self._compress_type = zipinfo.compress_type
-        self._compress_left = zipinfo.compress_size
-        self._left = zipinfo.file_size
-
-        self._decompressor = _get_decompressor(self._compress_type)
-
-        self._eof = False
-        self._readbuffer = b''
-        self._offset = 0
-
-        self.newlines = None
-
-        self.mode = mode
-        self.name = zipinfo.filename
-
-        if hasattr(zipinfo, 'CRC'):
-            self._expected_crc = zipinfo.CRC
-            self._running_crc = crc32(b'')
-        else:
-            self._expected_crc = None
-
-        self._seekable = False
-        try:
-            if fileobj.seekable():
-                self._orig_compress_start = fileobj.tell()
-                self._orig_compress_size = zipinfo.compress_size
-                self._orig_file_size = zipinfo.file_size
-                self._orig_start_crc = self._running_crc
-                self._seekable = True
-        except AttributeError:
-            pass
-
-        self._decrypter = None
-        if pwd:
-            if zipinfo.flag_bits & 0x8:
-                # compare against the file type from extended local headers
-                check_byte = (zipinfo._raw_time >> 8) & 0xff
-            else:
-                # compare against the CRC otherwise
-                check_byte = (zipinfo.CRC >> 24) & 0xff
-            h = self._init_decrypter()
-            if h != check_byte:
-                raise RuntimeError("Bad password for file %r" % zipinfo.orig_filename)
-
-
-    def _init_decrypter(self):
-        self._decrypter = _ZipDecrypter(self._pwd)
-        # The first 12 bytes in the cypher stream is an encryption header
-        #  used to strengthen the algorithm. The first 11 bytes are
-        #  completely random, while the 12th contains the MSB of the CRC,
-        #  or the MSB of the file time depending on the header type
-        #  and is used to check the correctness of the password.
-        header = self._fileobj.read(12)
-        self._compress_left -= 12
-        return self._decrypter(header)[11]
-
-    def __repr__(self):
-        result = ['<%s.%s' % (self.__class__.__module__,
-                              self.__class__.__qualname__)]
-        if not self.closed:
-            result.append(' name=%r mode=%r' % (self.name, self.mode))
-            if self._compress_type != ZIP_STORED:
-                result.append(' compress_type=%s' %
-                              compressor_names.get(self._compress_type,
-                                                   self._compress_type))
-        else:
-            result.append(' [closed]')
-        result.append('>')
-        return ''.join(result)
-
-    def readline(self, limit=-1):
-        """Read and return a line from the stream.
-
-        If limit is specified, at most limit bytes will be read.
-        """
-
-        if limit < 0:
-            # Shortcut common case - newline found in buffer.
-            i = self._readbuffer.find(b'\n', self._offset) + 1
-            if i > 0:
-                line = self._readbuffer[self._offset: i]
-                self._offset = i
-                return line
-
-        return io.BufferedIOBase.readline(self, limit)
-
-    def peek(self, n=1):
-        """Returns buffered bytes without advancing the position."""
-        if n > len(self._readbuffer) - self._offset:
-            chunk = self.read(n)
-            if len(chunk) > self._offset:
-                self._readbuffer = chunk + self._readbuffer[self._offset:]
-                self._offset = 0
-            else:
-                self._offset -= len(chunk)
-
-        # Return up to 512 bytes to reduce allocation overhead for tight loops.
-        return self._readbuffer[self._offset: self._offset + 512]
-
-    def readable(self):
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        return True
-
-    def read(self, n=-1):
-        """Read and return up to n bytes.
-        If the argument is omitted, None, or negative, data is read and returned until EOF is reached.
-        """
-        if self.closed:
-            raise ValueError("read from closed file.")
-        if n is None or n < 0:
-            buf = self._readbuffer[self._offset:]
-            self._readbuffer = b''
-            self._offset = 0
-            while not self._eof:
-                buf += self._read1(self.MAX_N)
-            return buf
-
-        end = n + self._offset
-        if end < len(self._readbuffer):
-            buf = self._readbuffer[self._offset:end]
-            self._offset = end
-            return buf
-
-        n = end - len(self._readbuffer)
-        buf = self._readbuffer[self._offset:]
-        self._readbuffer = b''
-        self._offset = 0
-        while n > 0 and not self._eof:
-            data = self._read1(n)
-            if n < len(data):
-                self._readbuffer = data
-                self._offset = n
-                buf += data[:n]
-                break
-            buf += data
-            n -= len(data)
-        return buf
-
-    def _update_crc(self, newdata):
-        # Update the CRC using the given data.
-        if self._expected_crc is None:
-            # No need to compute the CRC if we don't have a reference value
-            return
-        self._running_crc = crc32(newdata, self._running_crc)
-        # Check the CRC if we're at the end of the file
-        if self._eof and self._running_crc != self._expected_crc:
-            raise BadZipFile("Bad CRC-32 for file %r" % self.name)
-
-    def read1(self, n):
-        """Read up to n bytes with at most one read() system call."""
-
-        if n is None or n < 0:
-            buf = self._readbuffer[self._offset:]
-            self._readbuffer = b''
-            self._offset = 0
-            while not self._eof:
-                data = self._read1(self.MAX_N)
-                if data:
-                    buf += data
-                    break
-            return buf
-
-        end = n + self._offset
-        if end < len(self._readbuffer):
-            buf = self._readbuffer[self._offset:end]
-            self._offset = end
-            return buf
-
-        n = end - len(self._readbuffer)
-        buf = self._readbuffer[self._offset:]
-        self._readbuffer = b''
-        self._offset = 0
-        if n > 0:
-            while not self._eof:
-                data = self._read1(n)
-                if n < len(data):
-                    self._readbuffer = data
-                    self._offset = n
-                    buf += data[:n]
-                    break
-                if data:
-                    buf += data
-                    break
-        return buf
-
-    def _read1(self, n):
-        # Read up to n compressed bytes with at most one read() system call,
-        # decrypt and decompress them.
-        if self._eof or n <= 0:
-            return b''
-
-        # Read from file.
-        if self._compress_type == ZIP_DEFLATED:
-            ## Handle unconsumed data.
-            data = self._decompressor.unconsumed_tail
-            if n > len(data):
-                data += self._read2(n - len(data))
-        else:
-            data = self._read2(n)
-
-        if self._compress_type == ZIP_STORED:
-            self._eof = self._compress_left <= 0
-        elif self._compress_type == ZIP_DEFLATED:
-            n = max(n, self.MIN_READ_SIZE)
-            data = self._decompressor.decompress(data, n)
-            self._eof = (self._decompressor.eof or
-                         self._compress_left <= 0 and
-                         not self._decompressor.unconsumed_tail)
-            if self._eof:
-                data += self._decompressor.flush()
-        else:
-            data = self._decompressor.decompress(data)
-            self._eof = self._decompressor.eof or self._compress_left <= 0
-
-        data = data[:self._left]
-        self._left -= len(data)
-        if self._left <= 0:
-            self._eof = True
-        self._update_crc(data)
-        return data
-
-    def _read2(self, n):
-        if self._compress_left <= 0:
-            return b''
-
-        n = max(n, self.MIN_READ_SIZE)
-        n = min(n, self._compress_left)
-
-        data = self._fileobj.read(n)
-        self._compress_left -= len(data)
-        if not data:
-            raise EOFError
-
-        if self._decrypter is not None:
-            data = self._decrypter(data)
-        return data
-
-    def close(self):
-        try:
-            if self._close_fileobj:
-                self._fileobj.close()
-        finally:
-            super().close()
-
-    def seekable(self):
-        if self.closed:
-            raise ValueError("I/O operation on closed file.")
-        return self._seekable
-
-    def seek(self, offset, whence=0):
-        if self.closed:
-            raise ValueError("seek on closed file.")
-        if not self._seekable:
-            raise io.UnsupportedOperation("underlying stream is not seekable")
-        curr_pos = self.tell()
-        if whence == 0: # Seek from start of file
-            new_pos = offset
-        elif whence == 1: # Seek from current position
-            new_pos = curr_pos + offset
-        elif whence == 2: # Seek from EOF
-            new_pos = self._orig_file_size + offset
-        else:
-            raise ValueError("whence must be os.SEEK_SET (0), "
-                             "os.SEEK_CUR (1), or os.SEEK_END (2)")
-
-        if new_pos > self._orig_file_size:
-            new_pos = self._orig_file_size
-
-        if new_pos < 0:
-            new_pos = 0
-
-        read_offset = new_pos - curr_pos
-        buff_offset = read_offset + self._offset
-
-        if buff_offset >= 0 and buff_offset < len(self._readbuffer):
-            # Just move the _offset index if the new position is in the _readbuffer
-            self._offset = buff_offset
-            read_offset = 0
-        elif read_offset < 0:
-            # Position is before the current position. Reset the ZipExtFile
-            self._fileobj.seek(self._orig_compress_start)
-            self._running_crc = self._orig_start_crc
-            self._compress_left = self._orig_compress_size
-            self._left = self._orig_file_size
-            self._readbuffer = b''
-            self._offset = 0
-            self._decompressor = _get_decompressor(self._compress_type)
-            self._eof = False
-            read_offset = new_pos
-            if self._decrypter is not None:
-                self._init_decrypter()
-
-        while read_offset > 0:
-            read_len = min(self.MAX_SEEK_READ, read_offset)
-            self.read(read_len)
-            read_offset -= read_len
-
-        return self.tell()
-
-    def tell(self):
-        if self.closed:
-            raise ValueError("tell on closed file.")
-        if not self._seekable:
-            raise io.UnsupportedOperation("underlying stream is not seekable")
-        filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset
-        return filepos
-
-
-class _ZipWriteFile(io.BufferedIOBase):
-    def __init__(self, zf, zinfo, zip64):
-        self._zinfo = zinfo
-        self._zip64 = zip64
-        self._zipfile = zf
-        self._compressor = _get_compressor(zinfo.compress_type,
-                                           zinfo._compresslevel)
-        self._file_size = 0
-        self._compress_size = 0
-        self._crc = 0
-
-    @property
-    def _fileobj(self):
-        return self._zipfile.fp
-
-    def writable(self):
-        return True
-
-    def write(self, data):
-        if self.closed:
-            raise ValueError('I/O operation on closed file.')
-
-        # Accept any data that supports the buffer protocol
-        if isinstance(data, (bytes, bytearray)):
-            nbytes = len(data)
-        else:
-            data = memoryview(data)
-            nbytes = data.nbytes
-        self._file_size += nbytes
-
-        self._crc = crc32(data, self._crc)
-        if self._compressor:
-            data = self._compressor.compress(data)
-            self._compress_size += len(data)
-        self._fileobj.write(data)
-        return nbytes
-
-    def close(self):
-        if self.closed:
-            return
-        try:
-            super().close()
-            # Flush any data from the compressor, and update header info
-            if self._compressor:
-                buf = self._compressor.flush()
-                self._compress_size += len(buf)
-                self._fileobj.write(buf)
-                self._zinfo.compress_size = self._compress_size
-            else:
-                self._zinfo.compress_size = self._file_size
-            self._zinfo.CRC = self._crc
-            self._zinfo.file_size = self._file_size
-
-            # Write updated header info
-            if self._zinfo.flag_bits & 0x08:
-                # Write CRC and file sizes after the file data
-                fmt = '<LLQQ' if self._zip64 else '<LLLL'
-                self._fileobj.write(struct.pack(fmt, _DD_SIGNATURE, self._zinfo.CRC,
-                    self._zinfo.compress_size, self._zinfo.file_size))
-                self._zipfile.start_dir = self._fileobj.tell()
-            else:
-                if not self._zip64:
-                    if self._file_size > ZIP64_LIMIT:
-                        raise RuntimeError(
-                            'File size unexpectedly exceeded ZIP64 limit')
-                    if self._compress_size > ZIP64_LIMIT:
-                        raise RuntimeError(
-                            'Compressed size unexpectedly exceeded ZIP64 limit')
-                # Seek backwards and write file header (which will now include
-                # correct CRC and file sizes)
-
-                # Preserve current position in file
-                self._zipfile.start_dir = self._fileobj.tell()
-                self._fileobj.seek(self._zinfo.header_offset)
-                self._fileobj.write(self._zinfo.FileHeader(self._zip64))
-                self._fileobj.seek(self._zipfile.start_dir)
-
-            # Successfully written: Add file to our caches
-            self._zipfile.filelist.append(self._zinfo)
-            self._zipfile.NameToInfo[self._zinfo.filename] = self._zinfo
-        finally:
-            self._zipfile._writing = False
-
-
-
-class ZipFile:
-    """ Class with methods to open, read, write, close, list zip files.
-
-    z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=True,
-                compresslevel=None)
-
-    file: Either the path to the file, or a file-like object.
-          If it is a path, the file will be opened and closed by 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).
-    allowZip64: if True ZipFile will create files with ZIP64 extensions when
-                needed, otherwise it will raise an exception when this would
-                be necessary.
-    compresslevel: None (default for the given compression type) or an integer
-                   specifying the level to pass to the compressor.
-                   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.
-
-    """
-
-    fp = None                   # Set here since __del__ checks it
-    _windows_illegal_name_trans_table = None
-
-    def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
-                 compresslevel=None, *, strict_timestamps=True):
-        """Open the ZIP file with mode read 'r', write 'w', exclusive create 'x',
-        or append 'a'."""
-        if mode not in ('r', 'w', 'x', 'a'):
-            raise ValueError("ZipFile requires mode 'r', 'w', 'x', or 'a'")
-
-        _check_compression(compression)
-
-        self._allowZip64 = allowZip64
-        self._didModify = False
-        self.debug = 0  # Level of printing: 0 through 3
-        self.NameToInfo = {}    # Find file info given name
-        self.filelist = []      # List of ZipInfo instances for archive
-        self.compression = compression  # Method of compression
-        self.compresslevel = compresslevel
-        self.mode = mode
-        self.pwd = None
-        self._comment = b''
-        self._strict_timestamps = strict_timestamps
-
-        # Check if we were passed a file-like object
-        if isinstance(file, os.PathLike):
-            file = os.fspath(file)
-        if isinstance(file, str):
-            # No, it's a filename
-            self._filePassed = 0
-            self.filename = file
-            modeDict = {'r' : 'rb', 'w': 'w+b', 'x': 'x+b', 'a' : 'r+b',
-                        'r+b': 'w+b', 'w+b': 'wb', 'x+b': 'xb'}
-            filemode = modeDict[mode]
-            while True:
-                try:
-                    self.fp = io.open(file, filemode)
-                except OSError:
-                    if filemode in modeDict:
-                        filemode = modeDict[filemode]
-                        continue
-                    raise
-                break
-        else:
-            self._filePassed = 1
-            self.fp = file
-            self.filename = getattr(file, 'name', None)
-        self._fileRefCnt = 1
-        self._lock = threading.RLock()
-        self._seekable = True
-        self._writing = False
-
-        try:
-            if mode == 'r':
-                self._RealGetContents()
-            elif mode in ('w', 'x'):
-                # set the modified flag so central directory gets written
-                # even if no files are added to the archive
-                self._didModify = True
-                try:
-                    self.start_dir = self.fp.tell()
-                except (AttributeError, OSError):
-                    self.fp = _Tellable(self.fp)
-                    self.start_dir = 0
-                    self._seekable = False
-                else:
-                    # Some file-like objects can provide tell() but not seek()
-                    try:
-                        self.fp.seek(self.start_dir)
-                    except (AttributeError, OSError):
-                        self._seekable = False
-            elif mode == 'a':
-                try:
-                    # See if file is a zip file
-                    self._RealGetContents()
-                    # seek to start of directory and overwrite
-                    self.fp.seek(self.start_dir)
-                except BadZipFile:
-                    # file is not a zip file, just append
-                    self.fp.seek(0, 2)
-
-                    # set the modified flag so central directory gets written
-                    # even if no files are added to the archive
-                    self._didModify = True
-                    self.start_dir = self.fp.tell()
-            else:
-                raise ValueError("Mode must be 'r', 'w', 'x', or 'a'")
-        except:
-            fp = self.fp
-            self.fp = None
-            self._fpclose(fp)
-            raise
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, type, value, traceback):
-        self.close()
-
-    def __repr__(self):
-        result = ['<%s.%s' % (self.__class__.__module__,
-                              self.__class__.__qualname__)]
-        if self.fp is not None:
-            if self._filePassed:
-                result.append(' file=%r' % self.fp)
-            elif self.filename is not None:
-                result.append(' filename=%r' % self.filename)
-            result.append(' mode=%r' % self.mode)
-        else:
-            result.append(' [closed]')
-        result.append('>')
-        return ''.join(result)
-
-    def _RealGetContents(self):
-        """Read in the table of contents for the ZIP file."""
-        fp = self.fp
-        try:
-            endrec = _EndRecData(fp)
-        except OSError:
-            raise BadZipFile("File is not a zip file")
-        if not endrec:
-            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
-        if endrec[_ECD_SIGNATURE] == stringEndArchive64:
-            # If Zip64 extension structures are present, account for them
-            concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
-
-        if self.debug > 2:
-            inferred = concat + offset_cd
-            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)
-        data = fp.read(size_cd)
-        fp = io.BytesIO(data)
-        total = 0
-        while total < size_cd:
-            centdir = fp.read(sizeCentralDir)
-            if len(centdir) != sizeCentralDir:
-                raise BadZipFile("Truncated central directory")
-            centdir = struct.unpack(structCentralDir, centdir)
-            if centdir[_CD_SIGNATURE] != stringCentralDir:
-                raise BadZipFile("Bad magic number for central directory")
-            if self.debug > 2:
-                print(centdir)
-            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
-            flags = centdir[5]
-            if flags & 0x800:
-                # UTF-8 file names extension
-                filename = filename.decode('utf-8')
-            else:
-                # Historical ZIP filename encoding
-                filename = filename.decode('cp437')
-            # Create ZipInfo instance to store file information
-            x = ZipInfo(filename)
-            x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
-            x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
-            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
-            (x.create_version, x.create_system, x.extract_version, x.reserved,
-             x.flag_bits, x.compress_type, t, d,
-             x.CRC, x.compress_size, x.file_size) = centdir[1:12]
-            if x.extract_version > MAX_EXTRACT_VERSION:
-                raise NotImplementedError("zip file version %.1f" %
-                                          (x.extract_version / 10))
-            x.volume, x.internal_attr, x.external_attr = centdir[15:18]
-            # Convert date/time code to (year, month, day, hour, min, sec)
-            x._raw_time = t
-            x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
-                            t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
-
-            x._decodeExtra()
-            x.header_offset = x.header_offset + concat
-            self.filelist.append(x)
-            self.NameToInfo[x.filename] = x
-
-            # update total bytes read from central directory
-            total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
-                     + centdir[_CD_EXTRA_FIELD_LENGTH]
-                     + centdir[_CD_COMMENT_LENGTH])
-
-            if self.debug > 2:
-                print("total", total)
-
-
-    def namelist(self):
-        """Return a list of file names in the archive."""
-        return [data.filename for data in self.filelist]
-
-    def infolist(self):
-        """Return a list of class ZipInfo instances for files in the
-        archive."""
-        return self.filelist
-
-    def printdir(self, file=None):
-        """Print a table of contents for the zip file."""
-        print("%-46s %19s %12s" % ("File Name", "Modified    ", "Size"),
-              file=file)
-        for zinfo in self.filelist:
-            date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
-            print("%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size),
-                  file=file)
-
-    def testzip(self):
-        """Read all the files and check the CRC."""
-        chunk_size = 2 ** 20
-        for zinfo in self.filelist:
-            try:
-                # Read by chunks, to avoid an OverflowError or a
-                # MemoryError with very large embedded files.
-                with self.open(zinfo.filename, "r") as f:
-                    while f.read(chunk_size):     # Check CRC-32
-                        pass
-            except BadZipFile:
-                return zinfo.filename
-
-    def getinfo(self, name):
-        """Return the instance of ZipInfo given 'name'."""
-        info = self.NameToInfo.get(name)
-        if info is None:
-            raise KeyError(
-                'There is no item named %r in the archive' % name)
-
-        return info
-
-    def setpassword(self, pwd):
-        """Set default password for encrypted files."""
-        if pwd and not isinstance(pwd, bytes):
-            raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
-        if pwd:
-            self.pwd = pwd
-        else:
-            self.pwd = None
-
-    @property
-    def comment(self):
-        """The comment text associated with the ZIP file."""
-        return self._comment
-
-    @comment.setter
-    def comment(self, comment):
-        if not isinstance(comment, bytes):
-            raise TypeError("comment: expected bytes, got %s" % type(comment).__name__)
-        # check for valid comment length
-        if len(comment) > ZIP_MAX_COMMENT:
-            import warnings
-            warnings.warn('Archive comment is too long; truncating to %d bytes'
-                          % ZIP_MAX_COMMENT, stacklevel=2)
-            comment = comment[:ZIP_MAX_COMMENT]
-        self._comment = comment
-        self._didModify = True
-
-    def read(self, name, pwd=None):
-        """Return file bytes for name."""
-        with self.open(name, "r", pwd) as fp:
-            return fp.read()
-
-    def open(self, name, mode="r", pwd=None, *, force_zip64=False):
-        """Return file-like object for 'name'.
-
-        name is a string for the file name within the ZIP file, or a ZipInfo
-        object.
-
-        mode should be 'r' to read a file already in the ZIP file, or 'w' to
-        write to a file newly added to the archive.
-
-        pwd is the password to decrypt files (only used for reading).
-
-        When writing, if the file size is not known in advance but may exceed
-        2 GiB, pass force_zip64 to use the ZIP64 format, which can handle large
-        files.  If the size is known in advance, it is best to pass a ZipInfo
-        instance for name, with zinfo.file_size set.
-        """
-        if mode not in {"r", "w"}:
-            raise ValueError('open() requires mode "r" or "w"')
-        if pwd and not isinstance(pwd, bytes):
-            raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
-        if pwd and (mode == "w"):
-            raise ValueError("pwd is only supported for reading files")
-        if not self.fp:
-            raise ValueError(
-                "Attempt to use ZIP archive that was already closed")
-
-        # Make sure we have an info object
-        if isinstance(name, ZipInfo):
-            # 'name' is already an info object
-            zinfo = name
-        elif mode == 'w':
-            zinfo = ZipInfo(name)
-            zinfo.compress_type = self.compression
-            zinfo._compresslevel = self.compresslevel
-        else:
-            # Get info object for name
-            zinfo = self.getinfo(name)
-
-        if mode == 'w':
-            return self._open_to_write(zinfo, force_zip64=force_zip64)
-
-        if self._writing:
-            raise ValueError("Can't read from the ZIP file while there "
-                    "is an open writing handle on it. "
-                    "Close the writing handle before trying to read.")
-
-        # Open for reading:
-        self._fileRefCnt += 1
-        zef_file = _SharedFile(self.fp, zinfo.header_offset,
-                               self._fpclose, self._lock, lambda: self._writing)
-        try:
-            # Skip the file header:
-            fheader = zef_file.read(sizeFileHeader)
-            if len(fheader) != sizeFileHeader:
-                raise BadZipFile("Truncated file header")
-            fheader = struct.unpack(structFileHeader, fheader)
-            if fheader[_FH_SIGNATURE] != stringFileHeader:
-                raise BadZipFile("Bad magic number for file header")
-
-            fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
-            if fheader[_FH_EXTRA_FIELD_LENGTH]:
-                zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])
-
-            if zinfo.flag_bits & 0x20:
-                # Zip 2.7: compressed patched data
-                raise NotImplementedError("compressed patched data (flag bit 5)")
-
-            if zinfo.flag_bits & 0x40:
-                # strong encryption
-                raise NotImplementedError("strong encryption (flag bit 6)")
-
-            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & 0x800:
-                # UTF-8 filename
-                fname_str = fname.decode("utf-8")
-            else:
-                fname_str = fname.decode("cp437")
-
-            if fname_str != zinfo.orig_filename:
-                raise BadZipFile(
-                    'File name in directory %r and header %r differ.'
-                    % (zinfo.orig_filename, fname))
-
-            # check for encrypted flag & handle password
-            is_encrypted = zinfo.flag_bits & 0x1
-            if is_encrypted:
-                if not pwd:
-                    pwd = self.pwd
-                if not pwd:
-                    raise RuntimeError("File %r is encrypted, password "
-                                       "required for extraction" % name)
-            else:
-                pwd = None
-
-            return ZipExtFile(zef_file, mode, zinfo, pwd, True)
-        except:
-            zef_file.close()
-            raise
-
-    def _open_to_write(self, zinfo, force_zip64=False):
-        if force_zip64 and not self._allowZip64:
-            raise ValueError(
-                "force_zip64 is True, but allowZip64 was False when opening "
-                "the ZIP file."
-            )
-        if self._writing:
-            raise ValueError("Can't write to the ZIP file while there is "
-                             "another write handle open on it. "
-                             "Close the first handle before opening another.")
-
-        # Size and CRC are overwritten with correct data after processing the file
-        zinfo.compress_size = 0
-        zinfo.CRC = 0
-
-        zinfo.flag_bits = 0x00
-        if zinfo.compress_type == ZIP_LZMA:
-            # Compressed data includes an end-of-stream (EOS) marker
-            zinfo.flag_bits |= 0x02
-        if not self._seekable:
-            zinfo.flag_bits |= 0x08
-
-        if not zinfo.external_attr:
-            zinfo.external_attr = 0o600 << 16  # permissions: ?rw-------
-
-        # Compressed size can be larger than uncompressed size
-        zip64 = self._allowZip64 and \
-                (force_zip64 or zinfo.file_size * 1.05 > ZIP64_LIMIT)
-
-        if self._seekable:
-            self.fp.seek(self.start_dir)
-        zinfo.header_offset = self.fp.tell()
-
-        self._writecheck(zinfo)
-        self._didModify = True
-
-        self.fp.write(zinfo.FileHeader(zip64))
-
-        self._writing = True
-        return _ZipWriteFile(self, zinfo, zip64)
-
-    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'.
-        """
-        if path is None:
-            path = os.getcwd()
-        else:
-            path = os.fspath(path)
-
-        return self._extract_member(member, path, pwd)
-
-    def extractall(self, path=None, members=None, pwd=None):
-        """Extract all members from the archive to the current working
-           directory. `path' specifies a different directory to extract to.
-           `members' is optional and must be a subset of the list returned
-           by namelist().
-        """
-        if members is None:
-            members = self.namelist()
-
-        if path is None:
-            path = os.getcwd()
-        else:
-            path = os.fspath(path)
-
-        for zipinfo in members:
-            self._extract_member(zipinfo, path, pwd)
-
-    @classmethod
-    def _sanitize_windows_name(cls, arcname, pathsep):
-        """Replace bad characters and remove trailing dots from parts."""
-        table = cls._windows_illegal_name_trans_table
-        if not table:
-            illegal = ':<>|"?*'
-            table = str.maketrans(illegal, '_' * len(illegal))
-            cls._windows_illegal_name_trans_table = table
-        arcname = arcname.translate(table)
-        # remove trailing dots
-        arcname = (x.rstrip('.') for x in arcname.split(pathsep))
-        # rejoin, removing empty parts.
-        arcname = pathsep.join(x for x in arcname if x)
-        return arcname
-
-    def _extract_member(self, member, targetpath, pwd):
-        """Extract the ZipInfo object 'member' to a physical
-           file on the path targetpath.
-        """
-        if not isinstance(member, ZipInfo):
-            member = self.getinfo(member)
-
-        # build the destination pathname, replacing
-        # forward slashes to platform specific separators.
-        arcname = member.filename.replace('/', os.path.sep)
-
-        if os.path.altsep:
-            arcname = arcname.replace(os.path.altsep, os.path.sep)
-        # interpret absolute pathname as relative, remove drive letter or
-        # UNC path, redundant separators, "." and ".." components.
-        arcname = os.path.splitdrive(arcname)[1]
-        invalid_path_parts = ('', os.path.curdir, os.path.pardir)
-        arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
-                                   if x not in invalid_path_parts)
-        if os.path.sep == '\\':
-            # filter illegal characters on Windows
-            arcname = self._sanitize_windows_name(arcname, os.path.sep)
-
-        targetpath = os.path.join(targetpath, arcname)
-        targetpath = os.path.normpath(targetpath)
-
-        # Create all upper directories if necessary.
-        upperdirs = os.path.dirname(targetpath)
-        if upperdirs and not os.path.exists(upperdirs):
-            os.makedirs(upperdirs)
-
-        if member.is_dir():
-            if not os.path.isdir(targetpath):
-                os.mkdir(targetpath)
-            return targetpath
-
-        with self.open(member, pwd=pwd) as source, \
-             open(targetpath, "wb") as target:
-            shutil.copyfileobj(source, target)
-
-        return targetpath
-
-    def _writecheck(self, zinfo):
-        """Check for errors before writing a file to the archive."""
-        if zinfo.filename in self.NameToInfo:
-            import warnings
-            warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3)
-        if self.mode not in ('w', 'x', 'a'):
-            raise ValueError("write() requires mode 'w', 'x', or 'a'")
-        if not self.fp:
-            raise ValueError(
-                "Attempt to write ZIP archive that was already closed")
-        _check_compression(zinfo.compress_type)
-        if not self._allowZip64:
-            requires_zip64 = None
-            if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
-                requires_zip64 = "Files count"
-            elif zinfo.file_size > ZIP64_LIMIT:
-                requires_zip64 = "Filesize"
-            elif zinfo.header_offset > ZIP64_LIMIT:
-                requires_zip64 = "Zipfile size"
-            if requires_zip64:
-                raise LargeZipFile(requires_zip64 +
-                                   " would require ZIP64 extensions")
-
-    def write(self, filename, arcname=None,
-              compress_type=None, compresslevel=None):
-        """Put the bytes from filename into the archive under the name
-        arcname."""
-        if not self.fp:
-            raise ValueError(
-                "Attempt to write to ZIP archive that was already closed")
-        if self._writing:
-            raise ValueError(
-                "Can't write to ZIP archive while an open writing handle exists"
-            )
-
-        zinfo = ZipInfo.from_file(filename, arcname,
-                                  strict_timestamps=self._strict_timestamps)
-
-        if zinfo.is_dir():
-            zinfo.compress_size = 0
-            zinfo.CRC = 0
-        else:
-            if compress_type is not None:
-                zinfo.compress_type = compress_type
-            else:
-                zinfo.compress_type = self.compression
-
-            if compresslevel is not None:
-                zinfo._compresslevel = compresslevel
-            else:
-                zinfo._compresslevel = self.compresslevel
-
-        if zinfo.is_dir():
-            with self._lock:
-                if self._seekable:
-                    self.fp.seek(self.start_dir)
-                zinfo.header_offset = self.fp.tell()  # Start of header bytes
-                if zinfo.compress_type == ZIP_LZMA:
-                # Compressed data includes an end-of-stream (EOS) marker
-                    zinfo.flag_bits |= 0x02
-
-                self._writecheck(zinfo)
-                self._didModify = True
-
-                self.filelist.append(zinfo)
-                self.NameToInfo[zinfo.filename] = zinfo
-                self.fp.write(zinfo.FileHeader(False))
-                self.start_dir = self.fp.tell()
-        else:
-            with open(filename, "rb") as src, self.open(zinfo, 'w') as dest:
-                shutil.copyfileobj(src, dest, 1024*8)
-
-    def writestr(self, zinfo_or_arcname, data,
-                 compress_type=None, compresslevel=None):
-        """Write a file into the archive.  The contents is 'data', which
-        may be either a 'str' or a 'bytes' instance; if it is a 'str',
-        it is encoded as UTF-8 first.
-        'zinfo_or_arcname' is either a ZipInfo instance or
-        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._compresslevel = self.compresslevel
-            if zinfo.filename[-1] == '/':
-                zinfo.external_attr = 0o40775 << 16   # drwxrwxr-x
-                zinfo.external_attr |= 0x10           # MS-DOS directory flag
-            else:
-                zinfo.external_attr = 0o600 << 16     # ?rw-------
-        else:
-            zinfo = zinfo_or_arcname
-
-        if not self.fp:
-            raise ValueError(
-                "Attempt to write to ZIP archive that was already closed")
-        if self._writing:
-            raise ValueError(
-                "Can't write to ZIP archive while an open writing handle exists."
-            )
-
-        if compress_type is not None:
-            zinfo.compress_type = compress_type
-
-        if compresslevel is not None:
-            zinfo._compresslevel = compresslevel
-
-        zinfo.file_size = len(data)            # Uncompressed size
-        with self._lock:
-            with self.open(zinfo, mode='w') as dest:
-                dest.write(data)
-
-    def __del__(self):
-        """Call the "close()" method in case the user forgot."""
-        self.close()
-
-    def close(self):
-        """Close the file, and for mode 'w', 'x' and 'a' write the ending
-        records."""
-        if self.fp is None:
-            return
-
-        if self._writing:
-            raise ValueError("Can't close the ZIP file while there is "
-                             "an open writing handle on it. "
-                             "Close the writing handle before closing the zip.")
-
-        try:
-            if self.mode in ('w', 'x', 'a') and self._didModify: # write ending records
-                with self._lock:
-                    if self._seekable:
-                        self.fp.seek(self.start_dir)
-                    self._write_end_record()
-        finally:
-            fp = self.fp
-            self.fp = None
-            self._fpclose(fp)
-
-    def _write_end_record(self):
-        for zinfo in self.filelist:         # write central directory
-            dt = zinfo.date_time
-            dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
-            dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
-            extra = []
-            if zinfo.file_size > ZIP64_LIMIT \
-               or zinfo.compress_size > ZIP64_LIMIT:
-                extra.append(zinfo.file_size)
-                extra.append(zinfo.compress_size)
-                file_size = 0xffffffff
-                compress_size = 0xffffffff
-            else:
-                file_size = zinfo.file_size
-                compress_size = zinfo.compress_size
-
-            if zinfo.header_offset > ZIP64_LIMIT:
-                extra.append(zinfo.header_offset)
-                header_offset = 0xffffffff
-            else:
-                header_offset = zinfo.header_offset
-
-            extra_data = zinfo.extra
-            min_version = 0
-            if extra:
-                # Append a ZIP64 field to the extra's
-                extra_data = _strip_extra(extra_data, (1,))
-                extra_data = struct.pack(
-                    '<HH' + 'Q'*len(extra),
-                    1, 8*len(extra), *extra) + extra_data
-
-                min_version = ZIP64_VERSION
-
-            if zinfo.compress_type == ZIP_BZIP2:
-                min_version = max(BZIP2_VERSION, min_version)
-            elif zinfo.compress_type == ZIP_LZMA:
-                min_version = max(LZMA_VERSION, min_version)
-
-            extract_version = max(min_version, zinfo.extract_version)
-            create_version = max(min_version, zinfo.create_version)
-            filename, flag_bits = zinfo._encodeFilenameFlags()
-            centdir = struct.pack(structCentralDir,
-                                  stringCentralDir, create_version,
-                                  zinfo.create_system, extract_version, zinfo.reserved,
-                                  flag_bits, zinfo.compress_type, dostime, dosdate,
-                                  zinfo.CRC, compress_size, file_size,
-                                  len(filename), len(extra_data), len(zinfo.comment),
-                                  0, zinfo.internal_attr, zinfo.external_attr,
-                                  header_offset)
-            self.fp.write(centdir)
-            self.fp.write(filename)
-            self.fp.write(extra_data)
-            self.fp.write(zinfo.comment)
-
-        pos2 = self.fp.tell()
-        # Write end-of-zip-archive record
-        centDirCount = len(self.filelist)
-        centDirSize = pos2 - self.start_dir
-        centDirOffset = self.start_dir
-        requires_zip64 = None
-        if centDirCount > ZIP_FILECOUNT_LIMIT:
-            requires_zip64 = "Files count"
-        elif centDirOffset > ZIP64_LIMIT:
-            requires_zip64 = "Central directory offset"
-        elif centDirSize > ZIP64_LIMIT:
-            requires_zip64 = "Central directory size"
-        if requires_zip64:
-            # Need to write the ZIP64 end-of-archive records
-            if not self._allowZip64:
-                raise LargeZipFile(requires_zip64 +
-                                   " would require ZIP64 extensions")
-            zip64endrec = struct.pack(
-                structEndArchive64, stringEndArchive64,
-                44, 45, 45, 0, 0, centDirCount, centDirCount,
-                centDirSize, centDirOffset)
-            self.fp.write(zip64endrec)
-
-            zip64locrec = struct.pack(
-                structEndArchive64Locator,
-                stringEndArchive64Locator, 0, pos2, 1)
-            self.fp.write(zip64locrec)
-            centDirCount = min(centDirCount, 0xFFFF)
-            centDirSize = min(centDirSize, 0xFFFFFFFF)
-            centDirOffset = min(centDirOffset, 0xFFFFFFFF)
-
-        endrec = struct.pack(structEndArchive, stringEndArchive,
-                             0, 0, centDirCount, centDirCount,
-                             centDirSize, centDirOffset, len(self._comment))
-        self.fp.write(endrec)
-        self.fp.write(self._comment)
-        if self.mode == "a":
-            self.fp.truncate()
-        self.fp.flush()
-
-    def _fpclose(self, fp):
-        assert self._fileRefCnt > 0
-        self._fileRefCnt -= 1
-        if not self._fileRefCnt and not self._filePassed:
-            fp.close()
-
-
-class PyZipFile(ZipFile):
-    """Class to create ZIP archives with Python library files and packages."""
-
-    def __init__(self, file, mode="r", compression=ZIP_STORED,
-                 allowZip64=True, optimize=-1):
-        ZipFile.__init__(self, file, mode=mode, compression=compression,
-                         allowZip64=allowZip64)
-        self._optimize = optimize
-
-    def writepy(self, pathname, basename="", filterfunc=None):
-        """Add all files from "pathname" to the ZIP archive.
-
-        If pathname is a package directory, search the directory and
-        all package subdirectories recursively for all *.py and enter
-        the modules into the archive.  If pathname is a plain
-        directory, listdir *.py and enter all modules.  Else, pathname
-        must be a Python *.py file and the module will be put into the
-        archive.  Added modules are always module.pyc.
-        This method will compile the module.py into module.pyc if
-        necessary.
-        If filterfunc(pathname) is given, it is called with every argument.
-        When it is False, the file or directory is skipped.
-        """
-        pathname = os.fspath(pathname)
-        if filterfunc and not filterfunc(pathname):
-            if self.debug:
-                label = 'path' if os.path.isdir(pathname) else 'file'
-                print('%s %r skipped by filterfunc' % (label, pathname))
-            return
-        dir, name = os.path.split(pathname)
-        if os.path.isdir(pathname):
-            initname = os.path.join(pathname, "__init__.py")
-            if os.path.isfile(initname):
-                # This is a package directory, add it
-                if basename:
-                    basename = "%s/%s" % (basename, name)
-                else:
-                    basename = name
-                if self.debug:
-                    print("Adding package in", pathname, "as", basename)
-                fname, arcname = self._get_codename(initname[0:-3], basename)
-                if self.debug:
-                    print("Adding", arcname)
-                self.write(fname, arcname)
-                dirlist = sorted(os.listdir(pathname))
-                dirlist.remove("__init__.py")
-                # Add all *.py files and package subdirectories
-                for filename in dirlist:
-                    path = os.path.join(pathname, filename)
-                    root, ext = os.path.splitext(filename)
-                    if os.path.isdir(path):
-                        if os.path.isfile(os.path.join(path, "__init__.py")):
-                            # This is a package directory, add it
-                            self.writepy(path, basename,
-                                         filterfunc=filterfunc)  # Recursive call
-                    elif ext == ".py":
-                        if filterfunc and not filterfunc(path):
-                            if self.debug:
-                                print('file %r skipped by filterfunc' % path)
-                            continue
-                        fname, arcname = self._get_codename(path[0:-3],
-                                                            basename)
-                        if self.debug:
-                            print("Adding", arcname)
-                        self.write(fname, arcname)
-            else:
-                # This is NOT a package directory, add its files at top level
-                if self.debug:
-                    print("Adding files from directory", pathname)
-                for filename in sorted(os.listdir(pathname)):
-                    path = os.path.join(pathname, filename)
-                    root, ext = os.path.splitext(filename)
-                    if ext == ".py":
-                        if filterfunc and not filterfunc(path):
-                            if self.debug:
-                                print('file %r skipped by filterfunc' % path)
-                            continue
-                        fname, arcname = self._get_codename(path[0:-3],
-                                                            basename)
-                        if self.debug:
-                            print("Adding", arcname)
-                        self.write(fname, arcname)
-        else:
-            if pathname[-3:] != ".py":
-                raise RuntimeError(
-                    'Files added with writepy() must end with ".py"')
-            fname, arcname = self._get_codename(pathname[0:-3], basename)
-            if self.debug:
-                print("Adding file", arcname)
-            self.write(fname, arcname)
-
-    def _get_codename(self, pathname, basename):
-        """Return (filename, archivename) for the path.
-
-        Given a module name path, return the correct file path and
-        archive name, compiling if necessary.  For example, given
-        /python/lib/string, return (/python/lib/string.pyc, string).
-        """
-        def _compile(file, optimize=-1):
-            import py_compile
-            if self.debug:
-                print("Compiling", file)
-            try:
-                py_compile.compile(file, doraise=True, optimize=optimize)
-            except py_compile.PyCompileError as err:
-                print(err.msg)
-                return False
-            return True
-
-        file_py  = pathname + ".py"
-        file_pyc = pathname + ".pyc"
-        pycache_opt0 = importlib.util.cache_from_source(file_py, optimization='')
-        pycache_opt1 = importlib.util.cache_from_source(file_py, optimization=1)
-        pycache_opt2 = importlib.util.cache_from_source(file_py, optimization=2)
-        if self._optimize == -1:
-            # legacy mode: use whatever file is present
-            if (os.path.isfile(file_pyc) and
-                  os.stat(file_pyc).st_mtime >= os.stat(file_py).st_mtime):
-                # Use .pyc file.
-                arcname = fname = file_pyc
-            elif (os.path.isfile(pycache_opt0) and
-                  os.stat(pycache_opt0).st_mtime >= os.stat(file_py).st_mtime):
-                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
-                # file name in the archive.
-                fname = pycache_opt0
-                arcname = file_pyc
-            elif (os.path.isfile(pycache_opt1) and
-                  os.stat(pycache_opt1).st_mtime >= os.stat(file_py).st_mtime):
-                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
-                # file name in the archive.
-                fname = pycache_opt1
-                arcname = file_pyc
-            elif (os.path.isfile(pycache_opt2) and
-                  os.stat(pycache_opt2).st_mtime >= os.stat(file_py).st_mtime):
-                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
-                # file name in the archive.
-                fname = pycache_opt2
-                arcname = file_pyc
-            else:
-                # Compile py into PEP 3147 pyc file.
-                if _compile(file_py):
-                    if sys.flags.optimize == 0:
-                        fname = pycache_opt0
-                    elif sys.flags.optimize == 1:
-                        fname = pycache_opt1
-                    else:
-                        fname = pycache_opt2
-                    arcname = file_pyc
-                else:
-                    fname = arcname = file_py
-        else:
-            # new mode: use given optimization level
-            if self._optimize == 0:
-                fname = pycache_opt0
-                arcname = file_pyc
-            else:
-                arcname = file_pyc
-                if self._optimize == 1:
-                    fname = pycache_opt1
-                elif self._optimize == 2:
-                    fname = pycache_opt2
-                else:
-                    msg = "invalid value for 'optimize': {!r}".format(self._optimize)
-                    raise ValueError(msg)
-            if not (os.path.isfile(fname) and
-                    os.stat(fname).st_mtime >= os.stat(file_py).st_mtime):
-                if not _compile(file_py, optimize=self._optimize):
-                    fname = arcname = file_py
-        archivename = os.path.split(arcname)[1]
-        if basename:
-            archivename = "%s/%s" % (basename, archivename)
-        return (fname, archivename)
-
-
-def _parents(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all parents of that path.
-
-    >>> list(_parents('b/d'))
-    ['b']
-    >>> list(_parents('/b/d/'))
-    ['/b']
-    >>> list(_parents('b/d/f/'))
-    ['b/d', 'b']
-    >>> list(_parents('b'))
-    []
-    >>> list(_parents(''))
-    []
-    """
-    return itertools.islice(_ancestry(path), 1, None)
-
-
-def _ancestry(path):
-    """
-    Given a path with elements separated by
-    posixpath.sep, generate all elements of that path
-
-    >>> list(_ancestry('b/d'))
-    ['b/d', 'b']
-    >>> list(_ancestry('/b/d/'))
-    ['/b/d', '/b']
-    >>> list(_ancestry('b/d/f/'))
-    ['b/d/f', 'b/d', 'b']
-    >>> list(_ancestry('b'))
-    ['b']
-    >>> list(_ancestry(''))
-    []
-    """
-    path = path.rstrip(posixpath.sep)
-    while path and path != posixpath.sep:
-        yield path
-        path, tail = posixpath.split(path)
-
-
-_dedupe = dict.fromkeys
-"""Deduplicate an iterable in original order"""
-
-
-def _difference(minuend, subtrahend):
-    """
-    Return items in minuend not in subtrahend, retaining order
-    with O(1) lookup.
-    """
-    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
-
-
-class CompleteDirs(ZipFile):
-    """
-    A ZipFile subclass that ensures that implied directories
-    are always included in the namelist.
-    """
-
-    @staticmethod
-    def _implied_dirs(names):
-        parents = itertools.chain.from_iterable(map(_parents, names))
-        as_dirs = (p + posixpath.sep for p in parents)
-        return _dedupe(_difference(as_dirs, names))
-
-    def namelist(self):
-        names = super(CompleteDirs, self).namelist()
-        return names + list(self._implied_dirs(names))
-
-    def _name_set(self):
-        return set(self.namelist())
-
-    def resolve_dir(self, name):
-        """
-        If the name represents a directory, return that name
-        as a directory (with the trailing slash).
-        """
-        names = self._name_set()
-        dirname = name + '/'
-        dir_match = name not in names and dirname in names
-        return dirname if dir_match else name
-
-    @classmethod
-    def make(cls, source):
-        """
-        Given a source (filename or zipfile), return an
-        appropriate CompleteDirs subclass.
-        """
-        if isinstance(source, CompleteDirs):
-            return source
-
-        if not isinstance(source, ZipFile):
-            return cls(source)
-
-        # Only allow for FastLookup when supplied zipfile is read-only
-        if 'r' not in source.mode:
-            cls = CompleteDirs
-
-        source.__class__ = cls
-        return source
-
-
-class FastLookup(CompleteDirs):
-    """
-    ZipFile subclass to ensure implicit
-    dirs exist and are resolved rapidly.
-    """
-
-    def namelist(self):
-        with contextlib.suppress(AttributeError):
-            return self.__names
-        self.__names = super(FastLookup, self).namelist()
-        return self.__names
-
-    def _name_set(self):
-        with contextlib.suppress(AttributeError):
-            return self.__lookup
-        self.__lookup = super(FastLookup, self)._name_set()
-        return self.__lookup
-
-
-class Path:
-    """
-    A pathlib-compatible interface for zip files.
-
-    Consider a zip file with this structure::
-
-        .
-        ├── a.txt
-        └── b
-            ├── c.txt
-            └── d
-                └── e.txt
-
-    >>> data = io.BytesIO()
-    >>> zf = ZipFile(data, 'w')
-    >>> zf.writestr('a.txt', 'content of a')
-    >>> zf.writestr('b/c.txt', 'content of c')
-    >>> zf.writestr('b/d/e.txt', 'content of e')
-    >>> zf.filename = 'mem/abcde.zip'
-
-    Path accepts the zipfile object itself or a filename
-
-    >>> root = Path(zf)
-
-    From there, several path operations are available.
-
-    Directory iteration (including the zip file itself):
-
-    >>> a, b = root.iterdir()
-    >>> a
-    Path('mem/abcde.zip', 'a.txt')
-    >>> b
-    Path('mem/abcde.zip', 'b/')
-
-    name property:
-
-    >>> b.name
-    'b'
-
-    join with divide operator:
-
-    >>> c = b / 'c.txt'
-    >>> c
-    Path('mem/abcde.zip', 'b/c.txt')
-    >>> c.name
-    'c.txt'
-
-    Read text:
-
-    >>> c.read_text()
-    'content of c'
-
-    existence:
-
-    >>> c.exists()
-    True
-    >>> (b / 'missing.txt').exists()
-    False
-
-    Coercion to string:
-
-    >>> import os
-    >>> str(c).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip/b/c.txt'
-
-    At the root, ``name``, ``filename``, and ``parent``
-    resolve to the zipfile. Note these attributes are not
-    valid and will raise a ``ValueError`` if the zipfile
-    has no filename.
-
-    >>> root.name
-    'abcde.zip'
-    >>> str(root.filename).replace(os.sep, posixpath.sep)
-    'mem/abcde.zip'
-    >>> str(root.parent)
-    'mem'
-    """
-
-    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
-
-    def __init__(self, root, at=""):
-        """
-        Construct a Path from a ZipFile or filename.
-
-        Note: When the source is an existing ZipFile object,
-        its type (__class__) will be mutated to a
-        specialized type. If the caller wishes to retain the
-        original type, the caller should either create a
-        separate ZipFile object or pass a filename.
-        """
-        self.root = FastLookup.make(root)
-        self.at = at
-
-    def open(self, mode='r', *args, pwd=None, **kwargs):
-        """
-        Open this entry as text or binary following the semantics
-        of ``pathlib.Path.open()`` by passing arguments through
-        to io.TextIOWrapper().
-        """
-        if self.is_dir():
-            raise IsADirectoryError(self)
-        zip_mode = mode[0]
-        if not self.exists() and zip_mode == 'r':
-            raise FileNotFoundError(self)
-        stream = self.root.open(self.at, zip_mode, pwd=pwd)
-        if 'b' in mode:
-            if args or kwargs:
-                raise ValueError("encoding args invalid for binary operation")
-            return stream
-        else:
-            kwargs["encoding"] = io.text_encoding(kwargs.get("encoding"))
-        return io.TextIOWrapper(stream, *args, **kwargs)
-
-    @property
-    def name(self):
-        return pathlib.Path(self.at).name or self.filename.name
-
-    @property
-    def filename(self):
-        return pathlib.Path(self.root.filename).joinpath(self.at)
-
-    def read_text(self, *args, **kwargs):
-        kwargs["encoding"] = io.text_encoding(kwargs.get("encoding"))
-        with self.open('r', *args, **kwargs) as strm:
-            return strm.read()
-
-    def read_bytes(self):
-        with self.open('rb') as strm:
-            return strm.read()
-
-    def _is_child(self, path):
-        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
-
-    def _next(self, at):
-        return self.__class__(self.root, at)
-
-    def is_dir(self):
-        return not self.at or self.at.endswith("/")
-
-    def is_file(self):
-        return self.exists() and not self.is_dir()
-
-    def exists(self):
-        return self.at in self.root._name_set()
-
-    def iterdir(self):
-        if not self.is_dir():
-            raise ValueError("Can't listdir a file")
-        subs = map(self._next, self.root.namelist())
-        return filter(self._is_child, subs)
-
-    def __str__(self):
-        return posixpath.join(self.root.filename, self.at)
-
-    def __repr__(self):
-        return self.__repr.format(self=self)
-
-    def joinpath(self, *other):
-        next = posixpath.join(self.at, *other)
-        return self._next(self.root.resolve_dir(next))
-
-    __truediv__ = joinpath
-
-    @property
-    def parent(self):
-        if not self.at:
-            return self.filename.parent
-        parent_at = posixpath.dirname(self.at.rstrip('/'))
-        if parent_at:
-            parent_at += '/'
-        return self._next(parent_at)
-
-
-def main(args=None):
-    import argparse
-
-    description = 'A simple command-line interface for zipfile module.'
-    parser = argparse.ArgumentParser(description=description)
-    group = parser.add_mutually_exclusive_group(required=True)
-    group.add_argument('-l', '--list', metavar='<zipfile>',
-                       help='Show listing of a zipfile')
-    group.add_argument('-e', '--extract', nargs=2,
-                       metavar=('<zipfile>', '<output_dir>'),
-                       help='Extract zipfile into target dir')
-    group.add_argument('-c', '--create', nargs='+',
-                       metavar=('<name>', '<file>'),
-                       help='Create zipfile from sources')
-    group.add_argument('-t', '--test', metavar='<zipfile>',
-                       help='Test if a zipfile is valid')
-    args = parser.parse_args(args)
-
-    if args.test is not None:
-        src = args.test
-        with ZipFile(src, 'r') as zf:
-            badfile = zf.testzip()
-        if badfile:
-            print("The following enclosed file is corrupted: {!r}".format(badfile))
-        print("Done testing")
-
-    elif args.list is not None:
-        src = args.list
-        with ZipFile(src, 'r') as zf:
-            zf.printdir()
-
-    elif args.extract is not None:
-        src, curdir = args.extract
-        with ZipFile(src, 'r') as zf:
-            zf.extractall(curdir)
-
-    elif args.create is not None:
-        zip_name = args.create.pop(0)
-        files = args.create
-
-        def addToZip(zf, path, zippath):
-            if os.path.isfile(path):
-                zf.write(path, zippath, ZIP_DEFLATED)
-            elif os.path.isdir(path):
-                if zippath:
-                    zf.write(path, zippath)
-                for nm in sorted(os.listdir(path)):
-                    addToZip(zf,
-                             os.path.join(path, nm), os.path.join(zippath, nm))
-            # else: ignore
-
-        with ZipFile(zip_name, 'w') as zf:
-            for path in files:
-                zippath = os.path.basename(path)
-                if not zippath:
-                    zippath = os.path.basename(os.path.dirname(path))
-                if zippath in ('', os.curdir, os.pardir):
-                    zippath = ''
-                addToZip(zf, path, zippath)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/Lib/zipfile/__init__.py b/Lib/zipfile/__init__.py
new file mode 100644
index 0000000000..c01f13729e
--- /dev/null
+++ b/Lib/zipfile/__init__.py
@@ -0,0 +1,2375 @@
+"""
+Read and write ZIP files.
+
+XXX references to utf-8 need further investigation.
+"""
+import binascii
+import importlib.util
+import io
+import os
+import shutil
+import stat
+import struct
+import sys
+import threading
+import time
+
+try:
+    import zlib # We may need its compression method
+    crc32 = zlib.crc32
+except ImportError:
+    zlib = None
+    crc32 = binascii.crc32
+
+try:
+    import bz2 # We may need its compression method
+except ImportError:
+    bz2 = None
+
+try:
+    import lzma # We may need its compression method
+except ImportError:
+    lzma = None
+
+__all__ = ["BadZipFile", "BadZipfile", "error",
+           "ZIP_STORED", "ZIP_DEFLATED", "ZIP_BZIP2", "ZIP_LZMA",
+           "is_zipfile", "ZipInfo", "ZipFile", "PyZipFile", "LargeZipFile",
+           "Path"]
+
+class BadZipFile(Exception):
+    pass
+
+
+class LargeZipFile(Exception):
+    """
+    Raised when writing a zipfile, the zipfile requires ZIP64 extensions
+    and those extensions are disabled.
+    """
+
+error = BadZipfile = BadZipFile      # Pre-3.2 compatibility names
+
+
+ZIP64_LIMIT = (1 << 31) - 1
+ZIP_FILECOUNT_LIMIT = (1 << 16) - 1
+ZIP_MAX_COMMENT = (1 << 16) - 1
+
+# constants for Zip file compression methods
+ZIP_STORED = 0
+ZIP_DEFLATED = 8
+ZIP_BZIP2 = 12
+ZIP_LZMA = 14
+# Other ZIP compression methods not supported
+
+DEFAULT_VERSION = 20
+ZIP64_VERSION = 45
+BZIP2_VERSION = 46
+LZMA_VERSION = 63
+# we recognize (but not necessarily support) all features up to that version
+MAX_EXTRACT_VERSION = 63
+
+# Below are some formats and associated data for reading/writing headers using
+# the struct module.  The names and structures of headers/records are those used
+# in the PKWARE description of the ZIP file format:
+#     http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+# (URL valid as of January 2008)
+
+# The "end of central directory" structure, magic number, size, and indices
+# (section V.I in the format document)
+structEndArchive = b"<4s4H2LH"
+stringEndArchive = b"PK\005\006"
+sizeEndCentDir = struct.calcsize(structEndArchive)
+
+_ECD_SIGNATURE = 0
+_ECD_DISK_NUMBER = 1
+_ECD_DISK_START = 2
+_ECD_ENTRIES_THIS_DISK = 3
+_ECD_ENTRIES_TOTAL = 4
+_ECD_SIZE = 5
+_ECD_OFFSET = 6
+_ECD_COMMENT_SIZE = 7
+# These last two indices are not part of the structure as defined in the
+# spec, but they are used internally by this module as a convenience
+_ECD_COMMENT = 8
+_ECD_LOCATION = 9
+
+# The "central directory" structure, magic number, size, and indices
+# of entries in the structure (section V.F in the format document)
+structCentralDir = "<4s4B4HL2L5H2L"
+stringCentralDir = b"PK\001\002"
+sizeCentralDir = struct.calcsize(structCentralDir)
+
+# indexes of entries in the central directory structure
+_CD_SIGNATURE = 0
+_CD_CREATE_VERSION = 1
+_CD_CREATE_SYSTEM = 2
+_CD_EXTRACT_VERSION = 3
+_CD_EXTRACT_SYSTEM = 4
+_CD_FLAG_BITS = 5
+_CD_COMPRESS_TYPE = 6
+_CD_TIME = 7
+_CD_DATE = 8
+_CD_CRC = 9
+_CD_COMPRESSED_SIZE = 10
+_CD_UNCOMPRESSED_SIZE = 11
+_CD_FILENAME_LENGTH = 12
+_CD_EXTRA_FIELD_LENGTH = 13
+_CD_COMMENT_LENGTH = 14
+_CD_DISK_NUMBER_START = 15
+_CD_INTERNAL_FILE_ATTRIBUTES = 16
+_CD_EXTERNAL_FILE_ATTRIBUTES = 17
+_CD_LOCAL_HEADER_OFFSET = 18
+
+# General purpose bit flags
+# Zip Appnote: 4.4.4 general purpose bit flag: (2 bytes)
+_MASK_ENCRYPTED = 1 << 0
+# Bits 1 and 2 have different meanings depending on the compression used.
+_MASK_COMPRESS_OPTION_1 = 1 << 1
+# _MASK_COMPRESS_OPTION_2 = 1 << 2
+# _MASK_USE_DATA_DESCRIPTOR: If set, crc-32, compressed size and uncompressed
+# size are zero in the local header and the real values are written in the data
+# descriptor immediately following the compressed data.
+_MASK_USE_DATA_DESCRIPTOR = 1 << 3
+# Bit 4: Reserved for use with compression method 8, for enhanced deflating.
+# _MASK_RESERVED_BIT_4 = 1 << 4
+_MASK_COMPRESSED_PATCH = 1 << 5
+_MASK_STRONG_ENCRYPTION = 1 << 6
+# _MASK_UNUSED_BIT_7 = 1 << 7
+# _MASK_UNUSED_BIT_8 = 1 << 8
+# _MASK_UNUSED_BIT_9 = 1 << 9
+# _MASK_UNUSED_BIT_10 = 1 << 10
+_MASK_UTF_FILENAME = 1 << 11
+# Bit 12: Reserved by PKWARE for enhanced compression.
+# _MASK_RESERVED_BIT_12 = 1 << 12
+# _MASK_ENCRYPTED_CENTRAL_DIR = 1 << 13
+# Bit 14, 15: Reserved by PKWARE
+# _MASK_RESERVED_BIT_14 = 1 << 14
+# _MASK_RESERVED_BIT_15 = 1 << 15
+
+# The "local file header" structure, magic number, size, and indices
+# (section V.A in the format document)
+structFileHeader = "<4s2B4HL2L2H"
+stringFileHeader = b"PK\003\004"
+sizeFileHeader = struct.calcsize(structFileHeader)
+
+_FH_SIGNATURE = 0
+_FH_EXTRACT_VERSION = 1
+_FH_EXTRACT_SYSTEM = 2
+_FH_GENERAL_PURPOSE_FLAG_BITS = 3
+_FH_COMPRESSION_METHOD = 4
+_FH_LAST_MOD_TIME = 5
+_FH_LAST_MOD_DATE = 6
+_FH_CRC = 7
+_FH_COMPRESSED_SIZE = 8
+_FH_UNCOMPRESSED_SIZE = 9
+_FH_FILENAME_LENGTH = 10
+_FH_EXTRA_FIELD_LENGTH = 11
+
+# The "Zip64 end of central directory locator" structure, magic number, and size
+structEndArchive64Locator = "<4sLQL"
+stringEndArchive64Locator = b"PK\x06\x07"
+sizeEndCentDir64Locator = struct.calcsize(structEndArchive64Locator)
+
+# The "Zip64 end of central directory" record, magic number, size, and indices
+# (section V.G in the format document)
+structEndArchive64 = "<4sQ2H2L4Q"
+stringEndArchive64 = b"PK\x06\x06"
+sizeEndCentDir64 = struct.calcsize(structEndArchive64)
+
+_CD64_SIGNATURE = 0
+_CD64_DIRECTORY_RECSIZE = 1
+_CD64_CREATE_VERSION = 2
+_CD64_EXTRACT_VERSION = 3
+_CD64_DISK_NUMBER = 4
+_CD64_DISK_NUMBER_START = 5
+_CD64_NUMBER_ENTRIES_THIS_DISK = 6
+_CD64_NUMBER_ENTRIES_TOTAL = 7
+_CD64_DIRECTORY_SIZE = 8
+_CD64_OFFSET_START_CENTDIR = 9
+
+_DD_SIGNATURE = 0x08074b50
+
+
+class _Extra(bytes):
+    FIELD_STRUCT = struct.Struct('<HH')
+
+    def __new__(cls, val, id=None):
+        return super().__new__(cls, val)
+
+    def __init__(self, val, id=None):
+        self.id = id
+
+    @classmethod
+    def read_one(cls, raw):
+        try:
+            xid, xlen = cls.FIELD_STRUCT.unpack(raw[:4])
+        except struct.error:
+            xid = None
+            xlen = 0
+        return cls(raw[:4+xlen], xid), raw[4+xlen:]
+
+    @classmethod
+    def split(cls, data):
+        # use memoryview for zero-copy slices
+        rest = memoryview(data)
+        while rest:
+            extra, rest = _Extra.read_one(rest)
+            yield extra
+
+    @classmethod
+    def strip(cls, data, xids):
+        """Remove Extra fields with specified IDs."""
+        return b''.join(
+            ex
+            for ex in cls.split(data)
+            if ex.id not in xids
+        )
+
+
+def _check_zipfile(fp):
+    try:
+        if _EndRecData(fp):
+            return True         # file has correct magic number
+    except OSError:
+        pass
+    return False
+
+def is_zipfile(filename):
+    """Quickly see if a file is a ZIP file by checking the magic number.
+
+    The filename argument may be a file or file-like object too.
+    """
+    result = False
+    try:
+        if hasattr(filename, "read"):
+            result = _check_zipfile(fp=filename)
+        else:
+            with open(filename, "rb") as fp:
+                result = _check_zipfile(fp)
+    except (OSError, BadZipFile):
+        pass
+    return result
+
+def _EndRecData64(fpin, offset, endrec):
+    """
+    Read the ZIP64 end-of-archive records and use that to update endrec
+    """
+    offset -= sizeEndCentDir64Locator
+    if offset < 0:
+        # The file is not large enough to contain a ZIP64
+        # end-of-archive record, so just return the end record we were given.
+        return endrec
+    fpin.seek(offset)
+    data = fpin.read(sizeEndCentDir64Locator)
+    if len(data) != sizeEndCentDir64Locator:
+        raise OSError("Unknown I/O error")
+    sig, diskno, reloff, disks = struct.unpack(structEndArchive64Locator, data)
+    if sig != stringEndArchive64Locator:
+        return endrec
+
+    if diskno != 0 or disks > 1:
+        raise BadZipFile("zipfiles that span multiple disks are not supported")
+
+    offset -= sizeEndCentDir64
+    if reloff > offset:
+        raise BadZipFile("Corrupt zip64 end of central directory locator")
+    # First, check the assumption that there is no prepended data.
+    fpin.seek(reloff)
+    extrasz = offset - reloff
+    data = fpin.read(sizeEndCentDir64)
+    if len(data) != sizeEndCentDir64:
+        raise OSError("Unknown I/O error")
+    if not data.startswith(stringEndArchive64) and reloff != offset:
+        # Since we already have seen the Zip64 EOCD Locator, it's
+        # possible we got here because there is prepended data.
+        # Assume no 'zip64 extensible data'
+        fpin.seek(offset)
+        extrasz = 0
+        data = fpin.read(sizeEndCentDir64)
+        if len(data) != sizeEndCentDir64:
+            raise OSError("Unknown I/O error")
+    if not data.startswith(stringEndArchive64):
+        raise BadZipFile("Zip64 end of central directory record not found")
+
+    sig, sz, create_version, read_version, disk_num, disk_dir, \
+        dircount, dircount2, dirsize, diroffset = \
+        struct.unpack(structEndArchive64, data)
+    if (diroffset + dirsize != reloff or
+        sz + 12 != sizeEndCentDir64 + extrasz):
+        raise BadZipFile("Corrupt zip64 end of central directory record")
+
+    # Update the original endrec using data from the ZIP64 record
+    endrec[_ECD_SIGNATURE] = sig
+    endrec[_ECD_DISK_NUMBER] = disk_num
+    endrec[_ECD_DISK_START] = disk_dir
+    endrec[_ECD_ENTRIES_THIS_DISK] = dircount
+    endrec[_ECD_ENTRIES_TOTAL] = dircount2
+    endrec[_ECD_SIZE] = dirsize
+    endrec[_ECD_OFFSET] = diroffset
+    endrec[_ECD_LOCATION] = offset - extrasz
+    return endrec
+
+
+def _EndRecData(fpin):
+    """Return data from the "End of Central Directory" record, or None.
+
+    The data is a list of the nine items in the ZIP "End of central dir"
+    record followed by a tenth item, the file seek offset of this record."""
+
+    # Determine file size
+    fpin.seek(0, 2)
+    filesize = fpin.tell()
+
+    # Check to see if this is ZIP file with no archive comment (the
+    # "end of central directory" structure should be the last item in the
+    # file if this is the case).
+    try:
+        fpin.seek(-sizeEndCentDir, 2)
+    except OSError:
+        return None
+    data = fpin.read(sizeEndCentDir)
+    if (len(data) == sizeEndCentDir and
+        data[0:4] == stringEndArchive and
+        data[-2:] == b"\000\000"):
+        # the signature is correct and there's no comment, unpack structure
+        endrec = struct.unpack(structEndArchive, data)
+        endrec=list(endrec)
+
+        # Append a blank comment and record start offset
+        endrec.append(b"")
+        endrec.append(filesize - sizeEndCentDir)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, filesize - sizeEndCentDir, endrec)
+
+    # Either this is not a ZIP file, or it is a ZIP file with an archive
+    # comment.  Search the end of the file for the "end of central directory"
+    # record signature. The comment is the last item in the ZIP file and may be
+    # up to 64K long.  It is assumed that the "end of central directory" magic
+    # number does not appear in the comment.
+    maxCommentStart = max(filesize - ZIP_MAX_COMMENT - sizeEndCentDir, 0)
+    fpin.seek(maxCommentStart, 0)
+    data = fpin.read(ZIP_MAX_COMMENT + sizeEndCentDir)
+    start = data.rfind(stringEndArchive)
+    if start >= 0:
+        # found the magic number; attempt to unpack and interpret
+        recData = data[start:start+sizeEndCentDir]
+        if len(recData) != sizeEndCentDir:
+            # Zip file is corrupted.
+            return None
+        endrec = list(struct.unpack(structEndArchive, recData))
+        commentSize = endrec[_ECD_COMMENT_SIZE] #as claimed by the zip file
+        comment = data[start+sizeEndCentDir:start+sizeEndCentDir+commentSize]
+        endrec.append(comment)
+        endrec.append(maxCommentStart + start)
+
+        # Try to read the "Zip64 end of central directory" structure
+        return _EndRecData64(fpin, maxCommentStart + start, endrec)
+
+    # Unable to find a valid end of central directory structure
+    return None
+
+def _sanitize_filename(filename):
+    """Terminate the file name at the first null byte and
+    ensure paths always use forward slashes as the directory separator."""
+
+    # Terminate the file name at the first null byte.  Null bytes in file
+    # names are used as tricks by viruses in archives.
+    null_byte = filename.find(chr(0))
+    if null_byte >= 0:
+        filename = filename[0:null_byte]
+    # This is used to ensure paths in generated ZIP files always use
+    # forward slashes as the directory separator, as required by the
+    # ZIP format specification.
+    if os.sep != "/" and os.sep in filename:
+        filename = filename.replace(os.sep, "/")
+    if os.altsep and os.altsep != "/" and os.altsep in filename:
+        filename = filename.replace(os.altsep, "/")
+    return filename
+
+
+class ZipInfo:
+    """Class with attributes describing each file in the ZIP archive."""
+
+    __slots__ = (
+        'orig_filename',
+        'filename',
+        'date_time',
+        'compress_type',
+        'compress_level',
+        'comment',
+        'extra',
+        'create_system',
+        'create_version',
+        'extract_version',
+        'reserved',
+        'flag_bits',
+        'volume',
+        'internal_attr',
+        'external_attr',
+        'header_offset',
+        'CRC',
+        'compress_size',
+        'file_size',
+        '_raw_time',
+        '_end_offset',
+    )
+
+    def __init__(self, filename="NoName", date_time=(1980,1,1,0,0,0)):
+        self.orig_filename = filename   # Original file name in archive
+
+        # Terminate the file name at the first null byte and
+        # ensure paths always use forward slashes as the directory separator.
+        filename = _sanitize_filename(filename)
+
+        self.filename = filename        # Normalized file name
+        self.date_time = date_time      # year, month, day, hour, min, sec
+
+        if date_time[0] < 1980:
+            raise ValueError('ZIP does not support timestamps before 1980')
+
+        # Standard values:
+        self.compress_type = ZIP_STORED # Type of compression for the file
+        self.compress_level = None      # Level for the compressor
+        self.comment = b""              # Comment for each file
+        self.extra = b""                # ZIP extra data
+        if sys.platform == 'win32':
+            self.create_system = 0          # System which created ZIP archive
+        else:
+            # Assume everything else is unix-y
+            self.create_system = 3          # System which created ZIP archive
+        self.create_version = DEFAULT_VERSION  # Version which created ZIP archive
+        self.extract_version = DEFAULT_VERSION # Version needed to extract archive
+        self.reserved = 0               # Must be zero
+        self.flag_bits = 0              # ZIP flag bits
+        self.volume = 0                 # Volume number of file header
+        self.internal_attr = 0          # Internal attributes
+        self.external_attr = 0          # External file attributes
+        self.compress_size = 0          # Size of the compressed file
+        self.file_size = 0              # Size of the uncompressed file
+        self._end_offset = None         # Start of the next local header or central directory
+        # Other attributes are set by class ZipFile:
+        # header_offset         Byte offset to the file header
+        # CRC                   CRC-32 of the uncompressed file
+
+    # Maintain backward compatibility with the old protected attribute name.
+    @property
+    def _compresslevel(self):
+        return self.compress_level
+
+    @_compresslevel.setter
+    def _compresslevel(self, value):
+        self.compress_level = value
+
+    def __repr__(self):
+        result = ['<%s filename=%r' % (self.__class__.__name__, self.filename)]
+        if self.compress_type != ZIP_STORED:
+            result.append(' compress_type=%s' %
+                          compressor_names.get(self.compress_type,
+                                               self.compress_type))
+        hi = self.external_attr >> 16
+        lo = self.external_attr & 0xFFFF
+        if hi:
+            result.append(' filemode=%r' % stat.filemode(hi))
+        if lo:
+            result.append(' external_attr=%#x' % lo)
+        isdir = self.is_dir()
+        if not isdir or self.file_size:
+            result.append(' file_size=%r' % self.file_size)
+        if ((not isdir or self.compress_size) and
+            (self.compress_type != ZIP_STORED or
+             self.file_size != self.compress_size)):
+            result.append(' compress_size=%r' % self.compress_size)
+        result.append('>')
+        return ''.join(result)
+
+    def FileHeader(self, zip64=None):
+        """Return the per-file header as a bytes object.
+
+        When the optional zip64 arg is None rather than a bool, we will
+        decide based upon the file_size and compress_size, if known,
+        False otherwise.
+        """
+        dt = self.date_time
+        dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
+        dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
+        if self.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
+            # Set these to zero because we write them after the file data
+            CRC = compress_size = file_size = 0
+        else:
+            CRC = self.CRC
+            compress_size = self.compress_size
+            file_size = self.file_size
+
+        extra = self.extra
+
+        min_version = 0
+        if zip64 is None:
+            # We always explicitly pass zip64 within this module.... This
+            # remains for anyone using ZipInfo.FileHeader as a public API.
+            zip64 = file_size > ZIP64_LIMIT or compress_size > ZIP64_LIMIT
+        if zip64:
+            fmt = '<HHQQ'
+            extra = extra + struct.pack(fmt,
+                                        1, struct.calcsize(fmt)-4, file_size, compress_size)
+            file_size = 0xffffffff
+            compress_size = 0xffffffff
+            min_version = ZIP64_VERSION
+
+        if self.compress_type == ZIP_BZIP2:
+            min_version = max(BZIP2_VERSION, min_version)
+        elif self.compress_type == ZIP_LZMA:
+            min_version = max(LZMA_VERSION, min_version)
+
+        self.extract_version = max(min_version, self.extract_version)
+        self.create_version = max(min_version, self.create_version)
+        filename, flag_bits = self._encodeFilenameFlags()
+        header = struct.pack(structFileHeader, stringFileHeader,
+                             self.extract_version, self.reserved, flag_bits,
+                             self.compress_type, dostime, dosdate, CRC,
+                             compress_size, file_size,
+                             len(filename), len(extra))
+        return header + filename + extra
+
+    def _encodeFilenameFlags(self):
+        try:
+            return self.filename.encode('ascii'), self.flag_bits
+        except UnicodeEncodeError:
+            return self.filename.encode('utf-8'), self.flag_bits | _MASK_UTF_FILENAME
+
+    def _decodeExtra(self, filename_crc):
+        # Try to decode the extra field.
+        extra = self.extra
+        unpack = struct.unpack
+        while len(extra) >= 4:
+            tp, ln = unpack('<HH', extra[:4])
+            if ln+4 > len(extra):
+                raise BadZipFile("Corrupt extra field %04x (size=%d)" % (tp, ln))
+            if tp == 0x0001:
+                data = extra[4:ln+4]
+                # ZIP64 extension (large files and/or large archives)
+                try:
+                    if self.file_size in (0xFFFF_FFFF_FFFF_FFFF, 0xFFFF_FFFF):
+                        field = "File size"
+                        self.file_size, = unpack('<Q', data[:8])
+                        data = data[8:]
+                    if self.compress_size == 0xFFFF_FFFF:
+                        field = "Compress size"
+                        self.compress_size, = unpack('<Q', data[:8])
+                        data = data[8:]
+                    if self.header_offset == 0xFFFF_FFFF:
+                        field = "Header offset"
+                        self.header_offset, = unpack('<Q', data[:8])
+                except struct.error:
+                    raise BadZipFile(f"Corrupt zip64 extra field. "
+                                     f"{field} not found.") from None
+            elif tp == 0x7075:
+                data = extra[4:ln+4]
+                # Unicode Path Extra Field
+                try:
+                    up_version, up_name_crc = unpack('<BL', data[:5])
+                    if up_version == 1 and up_name_crc == filename_crc:
+                        up_unicode_name = data[5:].decode('utf-8')
+                        if up_unicode_name:
+                            self.filename = _sanitize_filename(up_unicode_name)
+                        else:
+                            import warnings
+                            warnings.warn("Empty unicode path extra field (0x7075)", stacklevel=2)
+                except struct.error as e:
+                    raise BadZipFile("Corrupt unicode path extra field (0x7075)") from e
+                except UnicodeDecodeError as e:
+                    raise BadZipFile('Corrupt unicode path extra field (0x7075): invalid utf-8 bytes') from e
+
+            extra = extra[ln+4:]
+
+    @classmethod
+    def from_file(cls, filename, arcname=None, *, strict_timestamps=True):
+        """Construct an appropriate ZipInfo for a file on the filesystem.
+
+        filename should be the path to a file or directory on the filesystem.
+
+        arcname is the name which it will have within the archive (by default,
+        this will be the same as filename, but without a drive letter and with
+        leading path separators removed).
+        """
+        if isinstance(filename, os.PathLike):
+            filename = os.fspath(filename)
+        st = os.stat(filename)
+        isdir = stat.S_ISDIR(st.st_mode)
+        mtime = time.localtime(st.st_mtime)
+        date_time = mtime[0:6]
+        if not strict_timestamps and date_time[0] < 1980:
+            date_time = (1980, 1, 1, 0, 0, 0)
+        elif not strict_timestamps and date_time[0] > 2107:
+            date_time = (2107, 12, 31, 23, 59, 59)
+        # Create ZipInfo instance to store file information
+        if arcname is None:
+            arcname = filename
+        arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
+        while arcname[0] in (os.sep, os.altsep):
+            arcname = arcname[1:]
+        if isdir:
+            arcname += '/'
+        zinfo = cls(arcname, date_time)
+        zinfo.external_attr = (st.st_mode & 0xFFFF) << 16  # Unix attributes
+        if isdir:
+            zinfo.file_size = 0
+            zinfo.external_attr |= 0x10  # MS-DOS directory flag
+        else:
+            zinfo.file_size = st.st_size
+
+        return zinfo
+
+    def is_dir(self):
+        """Return True if this archive member is a directory."""
+        if self.filename.endswith('/'):
+            return True
+        # The ZIP format specification requires to use forward slashes
+        # as the directory separator, but in practice some ZIP files
+        # created on Windows can use backward slashes.  For compatibility
+        # with the extraction code which already handles this:
+        if os.path.altsep:
+            return self.filename.endswith((os.path.sep, os.path.altsep))
+        return False
+
+
+# ZIP encryption uses the CRC32 one-byte primitive for scrambling some
+# internal keys. We noticed that a direct implementation is faster than
+# relying on binascii.crc32().
+
+_crctable = None
+def _gen_crc(crc):
+    for j in range(8):
+        if crc & 1:
+            crc = (crc >> 1) ^ 0xEDB88320
+        else:
+            crc >>= 1
+    return crc
+
+# ZIP supports a password-based form of encryption. Even though known
+# plaintext attacks have been found against it, it is still useful
+# to be able to get data out of such a file.
+#
+# Usage:
+#     zd = _ZipDecrypter(mypwd)
+#     plain_bytes = zd(cypher_bytes)
+
+def _ZipDecrypter(pwd):
+    key0 = 305419896
+    key1 = 591751049
+    key2 = 878082192
+
+    global _crctable
+    if _crctable is None:
+        _crctable = list(map(_gen_crc, range(256)))
+    crctable = _crctable
+
+    def crc32(ch, crc):
+        """Compute the CRC32 primitive on one byte."""
+        return (crc >> 8) ^ crctable[(crc ^ ch) & 0xFF]
+
+    def update_keys(c):
+        nonlocal key0, key1, key2
+        key0 = crc32(c, key0)
+        key1 = (key1 + (key0 & 0xFF)) & 0xFFFFFFFF
+        key1 = (key1 * 134775813 + 1) & 0xFFFFFFFF
+        key2 = crc32(key1 >> 24, key2)
+
+    for p in pwd:
+        update_keys(p)
+
+    def decrypter(data):
+        """Decrypt a bytes object."""
+        result = bytearray()
+        append = result.append
+        for c in data:
+            k = key2 | 2
+            c ^= ((k * (k^1)) >> 8) & 0xFF
+            update_keys(c)
+            append(c)
+        return bytes(result)
+
+    return decrypter
+
+
+class LZMACompressor:
+
+    def __init__(self):
+        self._comp = None
+
+    def _init(self):
+        props = lzma._encode_filter_properties({'id': lzma.FILTER_LZMA1})
+        self._comp = lzma.LZMACompressor(lzma.FORMAT_RAW, filters=[
+            lzma._decode_filter_properties(lzma.FILTER_LZMA1, props)
+        ])
+        return struct.pack('<BBH', 9, 4, len(props)) + props
+
+    def compress(self, data):
+        if self._comp is None:
+            return self._init() + self._comp.compress(data)
+        return self._comp.compress(data)
+
+    def flush(self):
+        if self._comp is None:
+            return self._init() + self._comp.flush()
+        return self._comp.flush()
+
+
+class LZMADecompressor:
+
+    def __init__(self):
+        self._decomp = None
+        self._unconsumed = b''
+        self.eof = False
+
+    def decompress(self, data):
+        if self._decomp is None:
+            self._unconsumed += data
+            if len(self._unconsumed) <= 4:
+                return b''
+            psize, = struct.unpack('<H', self._unconsumed[2:4])
+            if len(self._unconsumed) <= 4 + psize:
+                return b''
+
+            self._decomp = lzma.LZMADecompressor(lzma.FORMAT_RAW, filters=[
+                lzma._decode_filter_properties(lzma.FILTER_LZMA1,
+                                               self._unconsumed[4:4 + psize])
+            ])
+            data = self._unconsumed[4 + psize:]
+            del self._unconsumed
+
+        result = self._decomp.decompress(data)
+        self.eof = self._decomp.eof
+        return result
+
+
+compressor_names = {
+    0: 'store',
+    1: 'shrink',
+    2: 'reduce',
+    3: 'reduce',
+    4: 'reduce',
+    5: 'reduce',
+    6: 'implode',
+    7: 'tokenize',
+    8: 'deflate',
+    9: 'deflate64',
+    10: 'implode',
+    12: 'bzip2',
+    14: 'lzma',
+    18: 'terse',
+    19: 'lz77',
+    97: 'wavpack',
+    98: 'ppmd',
+}
+
+def _check_compression(compression):
+    if compression == ZIP_STORED:
+        pass
+    elif compression == ZIP_DEFLATED:
+        if not zlib:
+            raise RuntimeError(
+                "Compression requires the (missing) zlib module")
+    elif compression == ZIP_BZIP2:
+        if not bz2:
+            raise RuntimeError(
+                "Compression requires the (missing) bz2 module")
+    elif compression == ZIP_LZMA:
+        if not lzma:
+            raise RuntimeError(
+                "Compression requires the (missing) lzma module")
+    else:
+        raise NotImplementedError("That compression method is not supported")
+
+
+def _get_compressor(compress_type, compresslevel=None):
+    if compress_type == ZIP_DEFLATED:
+        if compresslevel is not None:
+            return zlib.compressobj(compresslevel, zlib.DEFLATED, -15)
+        return zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
+    elif compress_type == ZIP_BZIP2:
+        if compresslevel is not None:
+            return bz2.BZ2Compressor(compresslevel)
+        return bz2.BZ2Compressor()
+    # compresslevel is ignored for ZIP_LZMA
+    elif compress_type == ZIP_LZMA:
+        return LZMACompressor()
+    else:
+        return None
+
+
+def _get_decompressor(compress_type):
+    _check_compression(compress_type)
+    if compress_type == ZIP_STORED:
+        return None
+    elif compress_type == ZIP_DEFLATED:
+        return zlib.decompressobj(-15)
+    elif compress_type == ZIP_BZIP2:
+        return bz2.BZ2Decompressor()
+    elif compress_type == ZIP_LZMA:
+        return LZMADecompressor()
+    else:
+        descr = compressor_names.get(compress_type)
+        if descr:
+            raise NotImplementedError("compression type %d (%s)" % (compress_type, descr))
+        else:
+            raise NotImplementedError("compression type %d" % (compress_type,))
+
+
+class _SharedFile:
+    def __init__(self, file, pos, close, lock, writing):
+        self._file = file
+        self._pos = pos
+        self._close = close
+        self._lock = lock
+        self._writing = writing
+        self.seekable = file.seekable
+
+    def tell(self):
+        return self._pos
+
+    def seek(self, offset, whence=0):
+        with self._lock:
+            if self._writing():
+                raise ValueError("Can't reposition in the ZIP file while "
+                        "there is an open writing handle on it. "
+                        "Close the writing handle before trying to read.")
+            if whence == os.SEEK_CUR:
+                self._file.seek(self._pos + offset)
+            else:
+                self._file.seek(offset, whence)
+            self._pos = self._file.tell()
+            return self._pos
+
+    def read(self, n=-1):
+        with self._lock:
+            if self._writing():
+                raise ValueError("Can't read from the ZIP file while there "
+                        "is an open writing handle on it. "
+                        "Close the writing handle before trying to read.")
+            self._file.seek(self._pos)
+            data = self._file.read(n)
+            self._pos = self._file.tell()
+            return data
+
+    def close(self):
+        if self._file is not None:
+            fileobj = self._file
+            self._file = None
+            self._close(fileobj)
+
+# Provide the tell method for unseekable stream
+class _Tellable:
+    def __init__(self, fp):
+        self.fp = fp
+        self.offset = 0
+
+    def write(self, data):
+        n = self.fp.write(data)
+        self.offset += n
+        return n
+
+    def tell(self):
+        return self.offset
+
+    def flush(self):
+        self.fp.flush()
+
+    def close(self):
+        self.fp.close()
+
+
+class ZipExtFile(io.BufferedIOBase):
+    """File-like object for reading an archive member.
+       Is returned by ZipFile.open().
+    """
+
+    # Max size supported by decompressor.
+    MAX_N = 1 << 31 - 1
+
+    # Read from compressed files in 4k blocks.
+    MIN_READ_SIZE = 4096
+
+    # Chunk size to read during seek
+    MAX_SEEK_READ = 1 << 24
+
+    def __init__(self, fileobj, mode, zipinfo, pwd=None,
+                 close_fileobj=False):
+        self._fileobj = fileobj
+        self._pwd = pwd
+        self._close_fileobj = close_fileobj
+
+        self._compress_type = zipinfo.compress_type
+        self._compress_left = zipinfo.compress_size
+        self._left = zipinfo.file_size
+
+        self._decompressor = _get_decompressor(self._compress_type)
+
+        self._eof = False
+        self._readbuffer = b''
+        self._offset = 0
+
+        self.newlines = None
+
+        self.mode = mode
+        self.name = zipinfo.filename
+
+        if hasattr(zipinfo, 'CRC'):
+            self._expected_crc = zipinfo.CRC
+            self._running_crc = crc32(b'')
+        else:
+            self._expected_crc = None
+
+        self._seekable = False
+        try:
+            if fileobj.seekable():
+                self._orig_compress_start = fileobj.tell()
+                self._orig_compress_size = zipinfo.compress_size
+                self._orig_file_size = zipinfo.file_size
+                self._orig_start_crc = self._running_crc
+                self._orig_crc = self._expected_crc
+                self._seekable = True
+        except AttributeError:
+            pass
+
+        self._decrypter = None
+        if pwd:
+            if zipinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
+                # compare against the file type from extended local headers
+                check_byte = (zipinfo._raw_time >> 8) & 0xff
+            else:
+                # compare against the CRC otherwise
+                check_byte = (zipinfo.CRC >> 24) & 0xff
+            h = self._init_decrypter()
+            if h != check_byte:
+                raise RuntimeError("Bad password for file %r" % zipinfo.orig_filename)
+
+
+    def _init_decrypter(self):
+        self._decrypter = _ZipDecrypter(self._pwd)
+        # The first 12 bytes in the cypher stream is an encryption header
+        #  used to strengthen the algorithm. The first 11 bytes are
+        #  completely random, while the 12th contains the MSB of the CRC,
+        #  or the MSB of the file time depending on the header type
+        #  and is used to check the correctness of the password.
+        header = self._fileobj.read(12)
+        self._compress_left -= 12
+        return self._decrypter(header)[11]
+
+    def __repr__(self):
+        result = ['<%s.%s' % (self.__class__.__module__,
+                              self.__class__.__qualname__)]
+        if not self.closed:
+            result.append(' name=%r' % (self.name,))
+            if self._compress_type != ZIP_STORED:
+                result.append(' compress_type=%s' %
+                              compressor_names.get(self._compress_type,
+                                                   self._compress_type))
+        else:
+            result.append(' [closed]')
+        result.append('>')
+        return ''.join(result)
+
+    def readline(self, limit=-1):
+        """Read and return a line from the stream.
+
+        If limit is specified, at most limit bytes will be read.
+        """
+
+        if limit < 0:
+            # Shortcut common case - newline found in buffer.
+            i = self._readbuffer.find(b'\n', self._offset) + 1
+            if i > 0:
+                line = self._readbuffer[self._offset: i]
+                self._offset = i
+                return line
+
+        return io.BufferedIOBase.readline(self, limit)
+
+    def peek(self, n=1):
+        """Returns buffered bytes without advancing the position."""
+        if n > len(self._readbuffer) - self._offset:
+            chunk = self.read(n)
+            if len(chunk) > self._offset:
+                self._readbuffer = chunk + self._readbuffer[self._offset:]
+                self._offset = 0
+            else:
+                self._offset -= len(chunk)
+
+        # Return up to 512 bytes to reduce allocation overhead for tight loops.
+        return self._readbuffer[self._offset: self._offset + 512]
+
+    def readable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return True
+
+    def read(self, n=-1):
+        """Read and return up to n bytes.
+        If the argument is omitted, None, or negative, data is read and returned until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("read from closed file.")
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset:]
+            self._readbuffer = b''
+            self._offset = 0
+            while not self._eof:
+                buf += self._read1(self.MAX_N)
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset:end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset:]
+        self._readbuffer = b''
+        self._offset = 0
+        while n > 0 and not self._eof:
+            data = self._read1(n)
+            if n < len(data):
+                self._readbuffer = data
+                self._offset = n
+                buf += data[:n]
+                break
+            buf += data
+            n -= len(data)
+        return buf
+
+    def _update_crc(self, newdata):
+        # Update the CRC using the given data.
+        if self._expected_crc is None:
+            # No need to compute the CRC if we don't have a reference value
+            return
+        self._running_crc = crc32(newdata, self._running_crc)
+        # Check the CRC if we're at the end of the file
+        if self._eof and self._running_crc != self._expected_crc:
+            raise BadZipFile("Bad CRC-32 for file %r" % self.name)
+
+    def read1(self, n):
+        """Read up to n bytes with at most one read() system call."""
+
+        if n is None or n < 0:
+            buf = self._readbuffer[self._offset:]
+            self._readbuffer = b''
+            self._offset = 0
+            while not self._eof:
+                data = self._read1(self.MAX_N)
+                if data:
+                    buf += data
+                    break
+            return buf
+
+        end = n + self._offset
+        if end < len(self._readbuffer):
+            buf = self._readbuffer[self._offset:end]
+            self._offset = end
+            return buf
+
+        n = end - len(self._readbuffer)
+        buf = self._readbuffer[self._offset:]
+        self._readbuffer = b''
+        self._offset = 0
+        if n > 0:
+            while not self._eof:
+                data = self._read1(n)
+                if n < len(data):
+                    self._readbuffer = data
+                    self._offset = n
+                    buf += data[:n]
+                    break
+                if data:
+                    buf += data
+                    break
+        return buf
+
+    def _read1(self, n):
+        # Read up to n compressed bytes with at most one read() system call,
+        # decrypt and decompress them.
+        if self._eof or n <= 0:
+            return b''
+
+        # Read from file.
+        if self._compress_type == ZIP_DEFLATED:
+            ## Handle unconsumed data.
+            data = self._decompressor.unconsumed_tail
+            if n > len(data):
+                data += self._read2(n - len(data))
+        else:
+            data = self._read2(n)
+
+        if self._compress_type == ZIP_STORED:
+            self._eof = self._compress_left <= 0
+        elif self._compress_type == ZIP_DEFLATED:
+            n = max(n, self.MIN_READ_SIZE)
+            data = self._decompressor.decompress(data, n)
+            self._eof = (self._decompressor.eof or
+                         self._compress_left <= 0 and
+                         not self._decompressor.unconsumed_tail)
+            if self._eof:
+                data += self._decompressor.flush()
+        else:
+            data = self._decompressor.decompress(data)
+            self._eof = self._decompressor.eof or self._compress_left <= 0
+
+        data = data[:self._left]
+        self._left -= len(data)
+        if self._left <= 0:
+            self._eof = True
+        self._update_crc(data)
+        return data
+
+    def _read2(self, n):
+        if self._compress_left <= 0:
+            return b''
+
+        n = max(n, self.MIN_READ_SIZE)
+        n = min(n, self._compress_left)
+
+        data = self._fileobj.read(n)
+        self._compress_left -= len(data)
+        if not data:
+            raise EOFError
+
+        if self._decrypter is not None:
+            data = self._decrypter(data)
+        return data
+
+    def close(self):
+        try:
+            if self._close_fileobj:
+                self._fileobj.close()
+        finally:
+            super().close()
+
+    def seekable(self):
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        return self._seekable
+
+    def seek(self, offset, whence=os.SEEK_SET):
+        if self.closed:
+            raise ValueError("seek on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        curr_pos = self.tell()
+        if whence == os.SEEK_SET:
+            new_pos = offset
+        elif whence == os.SEEK_CUR:
+            new_pos = curr_pos + offset
+        elif whence == os.SEEK_END:
+            new_pos = self._orig_file_size + offset
+        else:
+            raise ValueError("whence must be os.SEEK_SET (0), "
+                             "os.SEEK_CUR (1), or os.SEEK_END (2)")
+
+        if new_pos > self._orig_file_size:
+            new_pos = self._orig_file_size
+
+        if new_pos < 0:
+            new_pos = 0
+
+        read_offset = new_pos - curr_pos
+        buff_offset = read_offset + self._offset
+
+        if buff_offset >= 0 and buff_offset < len(self._readbuffer):
+            # Just move the _offset index if the new position is in the _readbuffer
+            self._offset = buff_offset
+            read_offset = 0
+        # Fast seek uncompressed unencrypted file
+        elif self._compress_type == ZIP_STORED and self._decrypter is None and read_offset != 0:
+            # disable CRC checking after first seeking - it would be invalid
+            self._expected_crc = None
+            # seek actual file taking already buffered data into account
+            read_offset -= len(self._readbuffer) - self._offset
+            self._fileobj.seek(read_offset, os.SEEK_CUR)
+            self._left -= read_offset
+            self._compress_left -= read_offset
+            self._eof = self._left <= 0
+            read_offset = 0
+            # flush read buffer
+            self._readbuffer = b''
+            self._offset = 0
+        elif read_offset < 0:
+            # Position is before the current position. Reset the ZipExtFile
+            self._fileobj.seek(self._orig_compress_start)
+            self._running_crc = self._orig_start_crc
+            self._expected_crc = self._orig_crc
+            self._compress_left = self._orig_compress_size
+            self._left = self._orig_file_size
+            self._readbuffer = b''
+            self._offset = 0
+            self._decompressor = _get_decompressor(self._compress_type)
+            self._eof = False
+            read_offset = new_pos
+            if self._decrypter is not None:
+                self._init_decrypter()
+
+        while read_offset > 0:
+            read_len = min(self.MAX_SEEK_READ, read_offset)
+            self.read(read_len)
+            read_offset -= read_len
+
+        return self.tell()
+
+    def tell(self):
+        if self.closed:
+            raise ValueError("tell on closed file.")
+        if not self._seekable:
+            raise io.UnsupportedOperation("underlying stream is not seekable")
+        filepos = self._orig_file_size - self._left - len(self._readbuffer) + self._offset
+        return filepos
+
+
+class _ZipWriteFile(io.BufferedIOBase):
+    def __init__(self, zf, zinfo, zip64):
+        self._zinfo = zinfo
+        self._zip64 = zip64
+        self._zipfile = zf
+        self._compressor = _get_compressor(zinfo.compress_type,
+                                           zinfo.compress_level)
+        self._file_size = 0
+        self._compress_size = 0
+        self._crc = 0
+
+    @property
+    def _fileobj(self):
+        return self._zipfile.fp
+
+    @property
+    def name(self):
+        return self._zinfo.filename
+
+    @property
+    def mode(self):
+        return 'wb'
+
+    def writable(self):
+        return True
+
+    def write(self, data):
+        if self.closed:
+            raise ValueError('I/O operation on closed file.')
+
+        # Accept any data that supports the buffer protocol
+        if isinstance(data, (bytes, bytearray)):
+            nbytes = len(data)
+        else:
+            data = memoryview(data)
+            nbytes = data.nbytes
+        self._file_size += nbytes
+
+        self._crc = crc32(data, self._crc)
+        if self._compressor:
+            data = self._compressor.compress(data)
+            self._compress_size += len(data)
+        self._fileobj.write(data)
+        return nbytes
+
+    def close(self):
+        if self.closed:
+            return
+        try:
+            super().close()
+            # Flush any data from the compressor, and update header info
+            if self._compressor:
+                buf = self._compressor.flush()
+                self._compress_size += len(buf)
+                self._fileobj.write(buf)
+                self._zinfo.compress_size = self._compress_size
+            else:
+                self._zinfo.compress_size = self._file_size
+            self._zinfo.CRC = self._crc
+            self._zinfo.file_size = self._file_size
+
+            if not self._zip64:
+                if self._file_size > ZIP64_LIMIT:
+                    raise RuntimeError("File size too large, try using force_zip64")
+                if self._compress_size > ZIP64_LIMIT:
+                    raise RuntimeError("Compressed size too large, try using force_zip64")
+
+            # Write updated header info
+            if self._zinfo.flag_bits & _MASK_USE_DATA_DESCRIPTOR:
+                # Write CRC and file sizes after the file data
+                fmt = '<LLQQ' if self._zip64 else '<LLLL'
+                self._fileobj.write(struct.pack(fmt, _DD_SIGNATURE, self._zinfo.CRC,
+                    self._zinfo.compress_size, self._zinfo.file_size))
+                self._zipfile.start_dir = self._fileobj.tell()
+            else:
+                # Seek backwards and write file header (which will now include
+                # correct CRC and file sizes)
+
+                # Preserve current position in file
+                self._zipfile.start_dir = self._fileobj.tell()
+                self._fileobj.seek(self._zinfo.header_offset)
+                self._fileobj.write(self._zinfo.FileHeader(self._zip64))
+                self._fileobj.seek(self._zipfile.start_dir)
+
+            # Successfully written: Add file to our caches
+            self._zipfile.filelist.append(self._zinfo)
+            self._zipfile.NameToInfo[self._zinfo.filename] = self._zinfo
+        finally:
+            self._zipfile._writing = False
+
+
+
+class ZipFile:
+    """ Class with methods to open, read, write, close, list zip files.
+
+    z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=True,
+                compresslevel=None)
+
+    file: Either the path to the file, or a file-like object.
+          If it is a path, the file will be opened and closed by 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).
+    allowZip64: if True ZipFile will create files with ZIP64 extensions when
+                needed, otherwise it will raise an exception when this would
+                be necessary.
+    compresslevel: None (default for the given compression type) or an integer
+                   specifying the level to pass to the compressor.
+                   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.
+
+    """
+
+    fp = None                   # Set here since __del__ checks it
+    _windows_illegal_name_trans_table = None
+
+    def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=True,
+                 compresslevel=None, *, strict_timestamps=True, metadata_encoding=None):
+        """Open the ZIP file with mode read 'r', write 'w', exclusive create 'x',
+        or append 'a'."""
+        if mode not in ('r', 'w', 'x', 'a'):
+            raise ValueError("ZipFile requires mode 'r', 'w', 'x', or 'a'")
+
+        _check_compression(compression)
+
+        self._allowZip64 = allowZip64
+        self._didModify = False
+        self.debug = 0  # Level of printing: 0 through 3
+        self.NameToInfo = {}    # Find file info given name
+        self.filelist = []      # List of ZipInfo instances for archive
+        self.compression = compression  # Method of compression
+        self.compresslevel = compresslevel
+        self.mode = mode
+        self.pwd = None
+        self._comment = b''
+        self._strict_timestamps = strict_timestamps
+        self.metadata_encoding = metadata_encoding
+
+        # Check that we don't try to write with nonconforming codecs
+        if self.metadata_encoding and mode != 'r':
+            raise ValueError(
+                "metadata_encoding is only supported for reading files")
+
+        # Check if we were passed a file-like object
+        if isinstance(file, os.PathLike):
+            file = os.fspath(file)
+        if isinstance(file, str):
+            # No, it's a filename
+            self._filePassed = 0
+            self.filename = file
+            modeDict = {'r' : 'rb', 'w': 'w+b', 'x': 'x+b', 'a' : 'r+b',
+                        'r+b': 'w+b', 'w+b': 'wb', 'x+b': 'xb'}
+            filemode = modeDict[mode]
+            while True:
+                try:
+                    self.fp = io.open(file, filemode)
+                except OSError:
+                    if filemode in modeDict:
+                        filemode = modeDict[filemode]
+                        continue
+                    raise
+                break
+        else:
+            self._filePassed = 1
+            self.fp = file
+            self.filename = getattr(file, 'name', None)
+        self._fileRefCnt = 1
+        self._lock = threading.RLock()
+        self._seekable = True
+        self._writing = False
+
+        try:
+            if mode == 'r':
+                self._RealGetContents()
+            elif mode in ('w', 'x'):
+                # set the modified flag so central directory gets written
+                # even if no files are added to the archive
+                self._didModify = True
+                try:
+                    self.start_dir = self.fp.tell()
+                except (AttributeError, OSError):
+                    self.fp = _Tellable(self.fp)
+                    self.start_dir = 0
+                    self._seekable = False
+                else:
+                    # Some file-like objects can provide tell() but not seek()
+                    try:
+                        self.fp.seek(self.start_dir)
+                    except (AttributeError, OSError):
+                        self._seekable = False
+            elif mode == 'a':
+                try:
+                    # See if file is a zip file
+                    self._RealGetContents()
+                    # seek to start of directory and overwrite
+                    self.fp.seek(self.start_dir)
+                except BadZipFile:
+                    # file is not a zip file, just append
+                    self.fp.seek(0, 2)
+
+                    # set the modified flag so central directory gets written
+                    # even if no files are added to the archive
+                    self._didModify = True
+                    self.start_dir = self.fp.tell()
+            else:
+                raise ValueError("Mode must be 'r', 'w', 'x', or 'a'")
+        except:
+            fp = self.fp
+            self.fp = None
+            self._fpclose(fp)
+            raise
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def __repr__(self):
+        result = ['<%s.%s' % (self.__class__.__module__,
+                              self.__class__.__qualname__)]
+        if self.fp is not None:
+            if self._filePassed:
+                result.append(' file=%r' % self.fp)
+            elif self.filename is not None:
+                result.append(' filename=%r' % self.filename)
+            result.append(' mode=%r' % self.mode)
+        else:
+            result.append(' [closed]')
+        result.append('>')
+        return ''.join(result)
+
+    def _RealGetContents(self):
+        """Read in the table of contents for the ZIP file."""
+        fp = self.fp
+        try:
+            endrec = _EndRecData(fp)
+        except OSError:
+            raise BadZipFile("File is not a zip file")
+        if not endrec:
+            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
+
+        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)
+        data = fp.read(size_cd)
+        fp = io.BytesIO(data)
+        total = 0
+        while total < size_cd:
+            centdir = fp.read(sizeCentralDir)
+            if len(centdir) != sizeCentralDir:
+                raise BadZipFile("Truncated central directory")
+            centdir = struct.unpack(structCentralDir, centdir)
+            if centdir[_CD_SIGNATURE] != stringCentralDir:
+                raise BadZipFile("Bad magic number for central directory")
+            if self.debug > 2:
+                print(centdir)
+            filename = fp.read(centdir[_CD_FILENAME_LENGTH])
+            orig_filename_crc = crc32(filename)
+            flags = centdir[_CD_FLAG_BITS]
+            if flags & _MASK_UTF_FILENAME:
+                # UTF-8 file names extension
+                filename = filename.decode('utf-8')
+            else:
+                # Historical ZIP filename encoding
+                filename = filename.decode(self.metadata_encoding or 'cp437')
+            # Create ZipInfo instance to store file information
+            x = ZipInfo(filename)
+            x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
+            x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
+            x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
+            (x.create_version, x.create_system, x.extract_version, x.reserved,
+             x.flag_bits, x.compress_type, t, d,
+             x.CRC, x.compress_size, x.file_size) = centdir[1:12]
+            if x.extract_version > MAX_EXTRACT_VERSION:
+                raise NotImplementedError("zip file version %.1f" %
+                                          (x.extract_version / 10))
+            x.volume, x.internal_attr, x.external_attr = centdir[15:18]
+            # Convert date/time code to (year, month, day, hour, min, sec)
+            x._raw_time = t
+            x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
+                            t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
+            x._decodeExtra(orig_filename_crc)
+            x.header_offset = x.header_offset + concat
+            self.filelist.append(x)
+            self.NameToInfo[x.filename] = x
+
+            # update total bytes read from central directory
+            total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
+                     + centdir[_CD_EXTRA_FIELD_LENGTH]
+                     + centdir[_CD_COMMENT_LENGTH])
+
+            if self.debug > 2:
+                print("total", total)
+
+        end_offset = self.start_dir
+        for zinfo in reversed(sorted(self.filelist,
+                                     key=lambda zinfo: zinfo.header_offset)):
+            zinfo._end_offset = end_offset
+            end_offset = zinfo.header_offset
+
+    def namelist(self):
+        """Return a list of file names in the archive."""
+        return [data.filename for data in self.filelist]
+
+    def infolist(self):
+        """Return a list of class ZipInfo instances for files in the
+        archive."""
+        return self.filelist
+
+    def printdir(self, file=None):
+        """Print a table of contents for the zip file."""
+        print("%-46s %19s %12s" % ("File Name", "Modified    ", "Size"),
+              file=file)
+        for zinfo in self.filelist:
+            date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
+            print("%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size),
+                  file=file)
+
+    def testzip(self):
+        """Read all the files and check the CRC.
+
+        Return None if all files could be read successfully, or the name
+        of the offending file otherwise."""
+        chunk_size = 2 ** 20
+        for zinfo in self.filelist:
+            try:
+                # Read by chunks, to avoid an OverflowError or a
+                # MemoryError with very large embedded files.
+                with self.open(zinfo.filename, "r") as f:
+                    while f.read(chunk_size):     # Check CRC-32
+                        pass
+            except BadZipFile:
+                return zinfo.filename
+
+    def getinfo(self, name):
+        """Return the instance of ZipInfo given 'name'."""
+        info = self.NameToInfo.get(name)
+        if info is None:
+            raise KeyError(
+                'There is no item named %r in the archive' % name)
+
+        return info
+
+    def setpassword(self, pwd):
+        """Set default password for encrypted files."""
+        if pwd and not isinstance(pwd, bytes):
+            raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
+        if pwd:
+            self.pwd = pwd
+        else:
+            self.pwd = None
+
+    @property
+    def comment(self):
+        """The comment text associated with the ZIP file."""
+        return self._comment
+
+    @comment.setter
+    def comment(self, comment):
+        if not isinstance(comment, bytes):
+            raise TypeError("comment: expected bytes, got %s" % type(comment).__name__)
+        # check for valid comment length
+        if len(comment) > ZIP_MAX_COMMENT:
+            import warnings
+            warnings.warn('Archive comment is too long; truncating to %d bytes'
+                          % ZIP_MAX_COMMENT, stacklevel=2)
+            comment = comment[:ZIP_MAX_COMMENT]
+        self._comment = comment
+        self._didModify = True
+
+    def read(self, name, pwd=None):
+        """Return file bytes for name. 'pwd' is the password to decrypt
+        encrypted files."""
+        with self.open(name, "r", pwd) as fp:
+            return fp.read()
+
+    def open(self, name, mode="r", pwd=None, *, force_zip64=False):
+        """Return file-like object for 'name'.
+
+        name is a string for the file name within the ZIP file, or a ZipInfo
+        object.
+
+        mode should be 'r' to read a file already in the ZIP file, or 'w' to
+        write to a file newly added to the archive.
+
+        pwd is the password to decrypt files (only used for reading).
+
+        When writing, if the file size is not known in advance but may exceed
+        2 GiB, pass force_zip64 to use the ZIP64 format, which can handle large
+        files.  If the size is known in advance, it is best to pass a ZipInfo
+        instance for name, with zinfo.file_size set.
+        """
+        if mode not in {"r", "w"}:
+            raise ValueError('open() requires mode "r" or "w"')
+        if pwd and (mode == "w"):
+            raise ValueError("pwd is only supported for reading files")
+        if not self.fp:
+            raise ValueError(
+                "Attempt to use ZIP archive that was already closed")
+
+        # Make sure we have an info object
+        if isinstance(name, ZipInfo):
+            # 'name' is already an info object
+            zinfo = name
+        elif mode == 'w':
+            zinfo = ZipInfo(name)
+            zinfo.compress_type = self.compression
+            zinfo.compress_level = self.compresslevel
+        else:
+            # Get info object for name
+            zinfo = self.getinfo(name)
+
+        if mode == 'w':
+            return self._open_to_write(zinfo, force_zip64=force_zip64)
+
+        if self._writing:
+            raise ValueError("Can't read from the ZIP file while there "
+                    "is an open writing handle on it. "
+                    "Close the writing handle before trying to read.")
+
+        # Open for reading:
+        self._fileRefCnt += 1
+        zef_file = _SharedFile(self.fp, zinfo.header_offset,
+                               self._fpclose, self._lock, lambda: self._writing)
+        try:
+            # Skip the file header:
+            fheader = zef_file.read(sizeFileHeader)
+            if len(fheader) != sizeFileHeader:
+                raise BadZipFile("Truncated file header")
+            fheader = struct.unpack(structFileHeader, fheader)
+            if fheader[_FH_SIGNATURE] != stringFileHeader:
+                raise BadZipFile("Bad magic number for file header")
+
+            fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
+            if fheader[_FH_EXTRA_FIELD_LENGTH]:
+                zef_file.seek(fheader[_FH_EXTRA_FIELD_LENGTH], whence=1)
+
+            if zinfo.flag_bits & _MASK_COMPRESSED_PATCH:
+                # Zip 2.7: compressed patched data
+                raise NotImplementedError("compressed patched data (flag bit 5)")
+
+            if zinfo.flag_bits & _MASK_STRONG_ENCRYPTION:
+                # strong encryption
+                raise NotImplementedError("strong encryption (flag bit 6)")
+
+            if fheader[_FH_GENERAL_PURPOSE_FLAG_BITS] & _MASK_UTF_FILENAME:
+                # UTF-8 filename
+                fname_str = fname.decode("utf-8")
+            else:
+                fname_str = fname.decode(self.metadata_encoding or "cp437")
+
+            if fname_str != zinfo.orig_filename:
+                raise BadZipFile(
+                    'File name in directory %r and header %r differ.'
+                    % (zinfo.orig_filename, fname))
+
+            if (zinfo._end_offset is not None and
+                zef_file.tell() + zinfo.compress_size > zinfo._end_offset):
+                if zinfo._end_offset == zinfo.header_offset:
+                    import warnings
+                    warnings.warn(
+                        f"Overlapped entries: {zinfo.orig_filename!r} "
+                        f"(possible zip bomb)",
+                        skip_file_prefixes=(os.path.dirname(__file__),))
+                else:
+                    raise BadZipFile(
+                        f"Overlapped entries: {zinfo.orig_filename!r} "
+                        f"(possible zip bomb)")
+
+            # check for encrypted flag & handle password
+            is_encrypted = zinfo.flag_bits & _MASK_ENCRYPTED
+            if is_encrypted:
+                if not pwd:
+                    pwd = self.pwd
+                if pwd and not isinstance(pwd, bytes):
+                    raise TypeError("pwd: expected bytes, got %s" % type(pwd).__name__)
+                if not pwd:
+                    raise RuntimeError("File %r is encrypted, password "
+                                       "required for extraction" % name)
+            else:
+                pwd = None
+
+            return ZipExtFile(zef_file, mode + 'b', zinfo, pwd, True)
+        except:
+            zef_file.close()
+            raise
+
+    def _open_to_write(self, zinfo, force_zip64=False):
+        if force_zip64 and not self._allowZip64:
+            raise ValueError(
+                "force_zip64 is True, but allowZip64 was False when opening "
+                "the ZIP file."
+            )
+        if self._writing:
+            raise ValueError("Can't write to the ZIP file while there is "
+                             "another write handle open on it. "
+                             "Close the first handle before opening another.")
+
+        # Size and CRC are overwritten with correct data after processing the file
+        zinfo.compress_size = 0
+        zinfo.CRC = 0
+
+        zinfo.flag_bits = 0x00
+        if zinfo.compress_type == ZIP_LZMA:
+            # Compressed data includes an end-of-stream (EOS) marker
+            zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1
+        if not self._seekable:
+            zinfo.flag_bits |= _MASK_USE_DATA_DESCRIPTOR
+
+        if not zinfo.external_attr:
+            zinfo.external_attr = 0o600 << 16  # permissions: ?rw-------
+
+        # Compressed size can be larger than uncompressed size
+        zip64 = force_zip64 or (zinfo.file_size * 1.05 > ZIP64_LIMIT)
+        if not self._allowZip64 and zip64:
+            raise LargeZipFile("Filesize would require ZIP64 extensions")
+
+        if self._seekable:
+            self.fp.seek(self.start_dir)
+        zinfo.header_offset = self.fp.tell()
+
+        self._writecheck(zinfo)
+        self._didModify = True
+
+        self.fp.write(zinfo.FileHeader(zip64))
+
+        self._writing = True
+        return _ZipWriteFile(self, zinfo, zip64)
+
+    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
+           password to decrypt the file using 'pwd'.
+        """
+        if path is None:
+            path = os.getcwd()
+        else:
+            path = os.fspath(path)
+
+        return self._extract_member(member, path, pwd)
+
+    def extractall(self, path=None, members=None, pwd=None):
+        """Extract all members from the archive to the current working
+           directory. `path' specifies a different directory to extract to.
+           `members' is optional and must be a subset of the list returned
+           by namelist(). You can specify the password to decrypt all files
+           using 'pwd'.
+        """
+        if members is None:
+            members = self.namelist()
+
+        if path is None:
+            path = os.getcwd()
+        else:
+            path = os.fspath(path)
+
+        for zipinfo in members:
+            self._extract_member(zipinfo, path, pwd)
+
+    @classmethod
+    def _sanitize_windows_name(cls, arcname, pathsep):
+        """Replace bad characters and remove trailing dots from parts."""
+        table = cls._windows_illegal_name_trans_table
+        if not table:
+            illegal = ':<>|"?*'
+            table = str.maketrans(illegal, '_' * len(illegal))
+            cls._windows_illegal_name_trans_table = table
+        arcname = arcname.translate(table)
+        # remove trailing dots and spaces
+        arcname = (x.rstrip(' .') for x in arcname.split(pathsep))
+        # rejoin, removing empty parts.
+        arcname = pathsep.join(x for x in arcname if x)
+        return arcname
+
+    def _extract_member(self, member, targetpath, pwd):
+        """Extract the ZipInfo object 'member' to a physical
+           file on the path targetpath.
+        """
+        if not isinstance(member, ZipInfo):
+            member = self.getinfo(member)
+
+        # build the destination pathname, replacing
+        # forward slashes to platform specific separators.
+        arcname = member.filename.replace('/', os.path.sep)
+
+        if os.path.altsep:
+            arcname = arcname.replace(os.path.altsep, os.path.sep)
+        # interpret absolute pathname as relative, remove drive letter or
+        # UNC path, redundant separators, "." and ".." components.
+        arcname = os.path.splitdrive(arcname)[1]
+        invalid_path_parts = ('', os.path.curdir, os.path.pardir)
+        arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
+                                   if x not in invalid_path_parts)
+        if os.path.sep == '\\':
+            # filter illegal characters on Windows
+            arcname = self._sanitize_windows_name(arcname, os.path.sep)
+
+        if not arcname and not member.is_dir():
+            raise ValueError("Empty filename.")
+
+        targetpath = os.path.join(targetpath, arcname)
+        targetpath = os.path.normpath(targetpath)
+
+        # Create all upper directories if necessary.
+        upperdirs = os.path.dirname(targetpath)
+        if upperdirs and not os.path.exists(upperdirs):
+            os.makedirs(upperdirs, exist_ok=True)
+
+        if member.is_dir():
+            if not os.path.isdir(targetpath):
+                try:
+                    os.mkdir(targetpath)
+                except FileExistsError:
+                    if not os.path.isdir(targetpath):
+                        raise
+            return targetpath
+
+        with self.open(member, pwd=pwd) as source, \
+             open(targetpath, "wb") as target:
+            shutil.copyfileobj(source, target)
+
+        return targetpath
+
+    def _writecheck(self, zinfo):
+        """Check for errors before writing a file to the archive."""
+        if zinfo.filename in self.NameToInfo:
+            import warnings
+            warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3)
+        if self.mode not in ('w', 'x', 'a'):
+            raise ValueError("write() requires mode 'w', 'x', or 'a'")
+        if not self.fp:
+            raise ValueError(
+                "Attempt to write ZIP archive that was already closed")
+        _check_compression(zinfo.compress_type)
+        if not self._allowZip64:
+            requires_zip64 = None
+            if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
+                requires_zip64 = "Files count"
+            elif zinfo.file_size > ZIP64_LIMIT:
+                requires_zip64 = "Filesize"
+            elif zinfo.header_offset > ZIP64_LIMIT:
+                requires_zip64 = "Zipfile size"
+            if requires_zip64:
+                raise LargeZipFile(requires_zip64 +
+                                   " would require ZIP64 extensions")
+
+    def write(self, filename, arcname=None,
+              compress_type=None, compresslevel=None):
+        """Put the bytes from filename into the archive under the name
+        arcname."""
+        if not self.fp:
+            raise ValueError(
+                "Attempt to write to ZIP archive that was already closed")
+        if self._writing:
+            raise ValueError(
+                "Can't write to ZIP archive while an open writing handle exists"
+            )
+
+        zinfo = ZipInfo.from_file(filename, arcname,
+                                  strict_timestamps=self._strict_timestamps)
+
+        if zinfo.is_dir():
+            zinfo.compress_size = 0
+            zinfo.CRC = 0
+            self.mkdir(zinfo)
+        else:
+            if compress_type is not None:
+                zinfo.compress_type = compress_type
+            else:
+                zinfo.compress_type = self.compression
+
+            if compresslevel is not None:
+                zinfo.compress_level = compresslevel
+            else:
+                zinfo.compress_level = self.compresslevel
+
+            with open(filename, "rb") as src, self.open(zinfo, 'w') as dest:
+                shutil.copyfileobj(src, dest, 1024*8)
+
+    def writestr(self, zinfo_or_arcname, data,
+                 compress_type=None, compresslevel=None):
+        """Write a file into the archive.  The contents is 'data', which
+        may be either a 'str' or a 'bytes' instance; if it is a 'str',
+        it is encoded as UTF-8 first.
+        'zinfo_or_arcname' is either a ZipInfo instance or
+        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:
+            zinfo = zinfo_or_arcname
+
+        if not self.fp:
+            raise ValueError(
+                "Attempt to write to ZIP archive that was already closed")
+        if self._writing:
+            raise ValueError(
+                "Can't write to ZIP archive while an open writing handle exists."
+            )
+
+        if compress_type is not None:
+            zinfo.compress_type = compress_type
+
+        if compresslevel is not None:
+            zinfo.compress_level = compresslevel
+
+        zinfo.file_size = len(data)            # Uncompressed size
+        with self._lock:
+            with self.open(zinfo, mode='w') as dest:
+                dest.write(data)
+
+    def mkdir(self, zinfo_or_directory_name, mode=511):
+        """Creates a directory inside the zip archive."""
+        if isinstance(zinfo_or_directory_name, ZipInfo):
+            zinfo = zinfo_or_directory_name
+            if not zinfo.is_dir():
+                raise ValueError("The given ZipInfo does not describe a directory")
+        elif isinstance(zinfo_or_directory_name, str):
+            directory_name = zinfo_or_directory_name
+            if not directory_name.endswith("/"):
+                directory_name += "/"
+            zinfo = ZipInfo(directory_name)
+            zinfo.compress_size = 0
+            zinfo.CRC = 0
+            zinfo.external_attr = ((0o40000 | mode) & 0xFFFF) << 16
+            zinfo.file_size = 0
+            zinfo.external_attr |= 0x10
+        else:
+            raise TypeError("Expected type str or ZipInfo")
+
+        with self._lock:
+            if self._seekable:
+                self.fp.seek(self.start_dir)
+            zinfo.header_offset = self.fp.tell()  # Start of header bytes
+            if zinfo.compress_type == ZIP_LZMA:
+            # Compressed data includes an end-of-stream (EOS) marker
+                zinfo.flag_bits |= _MASK_COMPRESS_OPTION_1
+
+            self._writecheck(zinfo)
+            self._didModify = True
+
+            self.filelist.append(zinfo)
+            self.NameToInfo[zinfo.filename] = zinfo
+            self.fp.write(zinfo.FileHeader(False))
+            self.start_dir = self.fp.tell()
+
+    def __del__(self):
+        """Call the "close()" method in case the user forgot."""
+        self.close()
+
+    def close(self):
+        """Close the file, and for mode 'w', 'x' and 'a' write the ending
+        records."""
+        if self.fp is None:
+            return
+
+        if self._writing:
+            raise ValueError("Can't close the ZIP file while there is "
+                             "an open writing handle on it. "
+                             "Close the writing handle before closing the zip.")
+
+        try:
+            if self.mode in ('w', 'x', 'a') and self._didModify: # write ending records
+                with self._lock:
+                    if self._seekable:
+                        self.fp.seek(self.start_dir)
+                    self._write_end_record()
+        finally:
+            fp = self.fp
+            self.fp = None
+            self._fpclose(fp)
+
+    def _write_end_record(self):
+        for zinfo in self.filelist:         # write central directory
+            dt = zinfo.date_time
+            dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
+            dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
+            extra = []
+            if zinfo.file_size > ZIP64_LIMIT \
+               or zinfo.compress_size > ZIP64_LIMIT:
+                extra.append(zinfo.file_size)
+                extra.append(zinfo.compress_size)
+                file_size = 0xffffffff
+                compress_size = 0xffffffff
+            else:
+                file_size = zinfo.file_size
+                compress_size = zinfo.compress_size
+
+            if zinfo.header_offset > ZIP64_LIMIT:
+                extra.append(zinfo.header_offset)
+                header_offset = 0xffffffff
+            else:
+                header_offset = zinfo.header_offset
+
+            extra_data = zinfo.extra
+            min_version = 0
+            if extra:
+                # Append a ZIP64 field to the extra's
+                extra_data = _Extra.strip(extra_data, (1,))
+                extra_data = struct.pack(
+                    '<HH' + 'Q'*len(extra),
+                    1, 8*len(extra), *extra) + extra_data
+
+                min_version = ZIP64_VERSION
+
+            if zinfo.compress_type == ZIP_BZIP2:
+                min_version = max(BZIP2_VERSION, min_version)
+            elif zinfo.compress_type == ZIP_LZMA:
+                min_version = max(LZMA_VERSION, min_version)
+
+            extract_version = max(min_version, zinfo.extract_version)
+            create_version = max(min_version, zinfo.create_version)
+            filename, flag_bits = zinfo._encodeFilenameFlags()
+            centdir = struct.pack(structCentralDir,
+                                  stringCentralDir, create_version,
+                                  zinfo.create_system, extract_version, zinfo.reserved,
+                                  flag_bits, zinfo.compress_type, dostime, dosdate,
+                                  zinfo.CRC, compress_size, file_size,
+                                  len(filename), len(extra_data), len(zinfo.comment),
+                                  0, zinfo.internal_attr, zinfo.external_attr,
+                                  header_offset)
+            self.fp.write(centdir)
+            self.fp.write(filename)
+            self.fp.write(extra_data)
+            self.fp.write(zinfo.comment)
+
+        pos2 = self.fp.tell()
+        # Write end-of-zip-archive record
+        centDirCount = len(self.filelist)
+        centDirSize = pos2 - self.start_dir
+        centDirOffset = self.start_dir
+        requires_zip64 = None
+        if centDirCount > ZIP_FILECOUNT_LIMIT:
+            requires_zip64 = "Files count"
+        elif centDirOffset > ZIP64_LIMIT:
+            requires_zip64 = "Central directory offset"
+        elif centDirSize > ZIP64_LIMIT:
+            requires_zip64 = "Central directory size"
+        if requires_zip64:
+            # Need to write the ZIP64 end-of-archive records
+            if not self._allowZip64:
+                raise LargeZipFile(requires_zip64 +
+                                   " would require ZIP64 extensions")
+            zip64endrec = struct.pack(
+                structEndArchive64, stringEndArchive64,
+                sizeEndCentDir64 - 12, 45, 45, 0, 0, centDirCount, centDirCount,
+                centDirSize, centDirOffset)
+            self.fp.write(zip64endrec)
+
+            zip64locrec = struct.pack(
+                structEndArchive64Locator,
+                stringEndArchive64Locator, 0, pos2, 1)
+            self.fp.write(zip64locrec)
+            centDirCount = min(centDirCount, 0xFFFF)
+            centDirSize = min(centDirSize, 0xFFFFFFFF)
+            centDirOffset = min(centDirOffset, 0xFFFFFFFF)
+
+        endrec = struct.pack(structEndArchive, stringEndArchive,
+                             0, 0, centDirCount, centDirCount,
+                             centDirSize, centDirOffset, len(self._comment))
+        self.fp.write(endrec)
+        self.fp.write(self._comment)
+        if self.mode == "a":
+            self.fp.truncate()
+        self.fp.flush()
+
+    def _fpclose(self, fp):
+        assert self._fileRefCnt > 0
+        self._fileRefCnt -= 1
+        if not self._fileRefCnt and not self._filePassed:
+            fp.close()
+
+
+class PyZipFile(ZipFile):
+    """Class to create ZIP archives with Python library files and packages."""
+
+    def __init__(self, file, mode="r", compression=ZIP_STORED,
+                 allowZip64=True, optimize=-1):
+        ZipFile.__init__(self, file, mode=mode, compression=compression,
+                         allowZip64=allowZip64)
+        self._optimize = optimize
+
+    def writepy(self, pathname, basename="", filterfunc=None):
+        """Add all files from "pathname" to the ZIP archive.
+
+        If pathname is a package directory, search the directory and
+        all package subdirectories recursively for all *.py and enter
+        the modules into the archive.  If pathname is a plain
+        directory, listdir *.py and enter all modules.  Else, pathname
+        must be a Python *.py file and the module will be put into the
+        archive.  Added modules are always module.pyc.
+        This method will compile the module.py into module.pyc if
+        necessary.
+        If filterfunc(pathname) is given, it is called with every argument.
+        When it is False, the file or directory is skipped.
+        """
+        pathname = os.fspath(pathname)
+        if filterfunc and not filterfunc(pathname):
+            if self.debug:
+                label = 'path' if os.path.isdir(pathname) else 'file'
+                print('%s %r skipped by filterfunc' % (label, pathname))
+            return
+        dir, name = os.path.split(pathname)
+        if os.path.isdir(pathname):
+            initname = os.path.join(pathname, "__init__.py")
+            if os.path.isfile(initname):
+                # This is a package directory, add it
+                if basename:
+                    basename = "%s/%s" % (basename, name)
+                else:
+                    basename = name
+                if self.debug:
+                    print("Adding package in", pathname, "as", basename)
+                fname, arcname = self._get_codename(initname[0:-3], basename)
+                if self.debug:
+                    print("Adding", arcname)
+                self.write(fname, arcname)
+                dirlist = sorted(os.listdir(pathname))
+                dirlist.remove("__init__.py")
+                # Add all *.py files and package subdirectories
+                for filename in dirlist:
+                    path = os.path.join(pathname, filename)
+                    root, ext = os.path.splitext(filename)
+                    if os.path.isdir(path):
+                        if os.path.isfile(os.path.join(path, "__init__.py")):
+                            # This is a package directory, add it
+                            self.writepy(path, basename,
+                                         filterfunc=filterfunc)  # Recursive call
+                    elif ext == ".py":
+                        if filterfunc and not filterfunc(path):
+                            if self.debug:
+                                print('file %r skipped by filterfunc' % path)
+                            continue
+                        fname, arcname = self._get_codename(path[0:-3],
+                                                            basename)
+                        if self.debug:
+                            print("Adding", arcname)
+                        self.write(fname, arcname)
+            else:
+                # This is NOT a package directory, add its files at top level
+                if self.debug:
+                    print("Adding files from directory", pathname)
+                for filename in sorted(os.listdir(pathname)):
+                    path = os.path.join(pathname, filename)
+                    root, ext = os.path.splitext(filename)
+                    if ext == ".py":
+                        if filterfunc and not filterfunc(path):
+                            if self.debug:
+                                print('file %r skipped by filterfunc' % path)
+                            continue
+                        fname, arcname = self._get_codename(path[0:-3],
+                                                            basename)
+                        if self.debug:
+                            print("Adding", arcname)
+                        self.write(fname, arcname)
+        else:
+            if pathname[-3:] != ".py":
+                raise RuntimeError(
+                    'Files added with writepy() must end with ".py"')
+            fname, arcname = self._get_codename(pathname[0:-3], basename)
+            if self.debug:
+                print("Adding file", arcname)
+            self.write(fname, arcname)
+
+    def _get_codename(self, pathname, basename):
+        """Return (filename, archivename) for the path.
+
+        Given a module name path, return the correct file path and
+        archive name, compiling if necessary.  For example, given
+        /python/lib/string, return (/python/lib/string.pyc, string).
+        """
+        def _compile(file, optimize=-1):
+            import py_compile
+            if self.debug:
+                print("Compiling", file)
+            try:
+                py_compile.compile(file, doraise=True, optimize=optimize)
+            except py_compile.PyCompileError as err:
+                print(err.msg)
+                return False
+            return True
+
+        file_py  = pathname + ".py"
+        file_pyc = pathname + ".pyc"
+        pycache_opt0 = importlib.util.cache_from_source(file_py, optimization='')
+        pycache_opt1 = importlib.util.cache_from_source(file_py, optimization=1)
+        pycache_opt2 = importlib.util.cache_from_source(file_py, optimization=2)
+        if self._optimize == -1:
+            # legacy mode: use whatever file is present
+            if (os.path.isfile(file_pyc) and
+                  os.stat(file_pyc).st_mtime >= os.stat(file_py).st_mtime):
+                # Use .pyc file.
+                arcname = fname = file_pyc
+            elif (os.path.isfile(pycache_opt0) and
+                  os.stat(pycache_opt0).st_mtime >= os.stat(file_py).st_mtime):
+                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
+                # file name in the archive.
+                fname = pycache_opt0
+                arcname = file_pyc
+            elif (os.path.isfile(pycache_opt1) and
+                  os.stat(pycache_opt1).st_mtime >= os.stat(file_py).st_mtime):
+                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
+                # file name in the archive.
+                fname = pycache_opt1
+                arcname = file_pyc
+            elif (os.path.isfile(pycache_opt2) and
+                  os.stat(pycache_opt2).st_mtime >= os.stat(file_py).st_mtime):
+                # Use the __pycache__/*.pyc file, but write it to the legacy pyc
+                # file name in the archive.
+                fname = pycache_opt2
+                arcname = file_pyc
+            else:
+                # Compile py into PEP 3147 pyc file.
+                if _compile(file_py):
+                    if sys.flags.optimize == 0:
+                        fname = pycache_opt0
+                    elif sys.flags.optimize == 1:
+                        fname = pycache_opt1
+                    else:
+                        fname = pycache_opt2
+                    arcname = file_pyc
+                else:
+                    fname = arcname = file_py
+        else:
+            # new mode: use given optimization level
+            if self._optimize == 0:
+                fname = pycache_opt0
+                arcname = file_pyc
+            else:
+                arcname = file_pyc
+                if self._optimize == 1:
+                    fname = pycache_opt1
+                elif self._optimize == 2:
+                    fname = pycache_opt2
+                else:
+                    msg = "invalid value for 'optimize': {!r}".format(self._optimize)
+                    raise ValueError(msg)
+            if not (os.path.isfile(fname) and
+                    os.stat(fname).st_mtime >= os.stat(file_py).st_mtime):
+                if not _compile(file_py, optimize=self._optimize):
+                    fname = arcname = file_py
+        archivename = os.path.split(arcname)[1]
+        if basename:
+            archivename = "%s/%s" % (basename, archivename)
+        return (fname, archivename)
+
+
+def main(args=None):
+    import argparse
+
+    description = 'A simple command-line interface for zipfile module.'
+    parser = argparse.ArgumentParser(description=description)
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument('-l', '--list', metavar='<zipfile>',
+                       help='Show listing of a zipfile')
+    group.add_argument('-e', '--extract', nargs=2,
+                       metavar=('<zipfile>', '<output_dir>'),
+                       help='Extract zipfile into target dir')
+    group.add_argument('-c', '--create', nargs='+',
+                       metavar=('<name>', '<file>'),
+                       help='Create zipfile from sources')
+    group.add_argument('-t', '--test', metavar='<zipfile>',
+                       help='Test if a zipfile is valid')
+    parser.add_argument('--metadata-encoding', metavar='<encoding>',
+                        help='Specify encoding of member names for -l, -e and -t')
+    args = parser.parse_args(args)
+
+    encoding = args.metadata_encoding
+
+    if args.test is not None:
+        src = args.test
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
+            badfile = zf.testzip()
+        if badfile:
+            print("The following enclosed file is corrupted: {!r}".format(badfile))
+        print("Done testing")
+
+    elif args.list is not None:
+        src = args.list
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
+            zf.printdir()
+
+    elif args.extract is not None:
+        src, curdir = args.extract
+        with ZipFile(src, 'r', metadata_encoding=encoding) as zf:
+            zf.extractall(curdir)
+
+    elif args.create is not None:
+        if encoding:
+            print("Non-conforming encodings not supported with -c.",
+                  file=sys.stderr)
+            sys.exit(1)
+
+        zip_name = args.create.pop(0)
+        files = args.create
+
+        def addToZip(zf, path, zippath):
+            if os.path.isfile(path):
+                zf.write(path, zippath, ZIP_DEFLATED)
+            elif os.path.isdir(path):
+                if zippath:
+                    zf.write(path, zippath)
+                for nm in sorted(os.listdir(path)):
+                    addToZip(zf,
+                             os.path.join(path, nm), os.path.join(zippath, nm))
+            # else: ignore
+
+        with ZipFile(zip_name, 'w') as zf:
+            for path in files:
+                zippath = os.path.basename(path)
+                if not zippath:
+                    zippath = os.path.basename(os.path.dirname(path))
+                if zippath in ('', os.curdir, os.pardir):
+                    zippath = ''
+                addToZip(zf, path, zippath)
+
+
+from ._path import (  # noqa: E402
+    Path,
+
+    # used privately for tests
+    CompleteDirs,  # noqa: F401
+)
diff --git a/Lib/zipfile/__main__.py b/Lib/zipfile/__main__.py
new file mode 100644
index 0000000000..868d99efc3
--- /dev/null
+++ b/Lib/zipfile/__main__.py
@@ -0,0 +1,4 @@
+from . import main
+
+if __name__ == "__main__":
+    main()
diff --git a/Lib/zipfile/_path/__init__.py b/Lib/zipfile/_path/__init__.py
new file mode 100644
index 0000000000..02f81171b4
--- /dev/null
+++ b/Lib/zipfile/_path/__init__.py
@@ -0,0 +1,452 @@
+"""
+A Path-like interface for zipfiles.
+
+This codebase is shared between zipfile.Path in the stdlib
+and zipp in PyPI. See
+https://github.com/python/importlib_metadata/wiki/Development-Methodology
+for more detail.
+"""
+
+import contextlib
+import io
+import itertools
+import pathlib
+import posixpath
+import re
+import stat
+import sys
+import zipfile
+
+from .glob import Translator
+
+__all__ = ['Path']
+
+
+def _parents(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all parents of that path.
+
+    >>> list(_parents('b/d'))
+    ['b']
+    >>> list(_parents('/b/d/'))
+    ['/b']
+    >>> list(_parents('b/d/f/'))
+    ['b/d', 'b']
+    >>> list(_parents('b'))
+    []
+    >>> list(_parents(''))
+    []
+    """
+    return itertools.islice(_ancestry(path), 1, None)
+
+
+def _ancestry(path):
+    """
+    Given a path with elements separated by
+    posixpath.sep, generate all elements of that path.
+
+    >>> list(_ancestry('b/d'))
+    ['b/d', 'b']
+    >>> list(_ancestry('/b/d/'))
+    ['/b/d', '/b']
+    >>> list(_ancestry('b/d/f/'))
+    ['b/d/f', 'b/d', 'b']
+    >>> list(_ancestry('b'))
+    ['b']
+    >>> list(_ancestry(''))
+    []
+
+    Multiple separators are treated like a single.
+
+    >>> list(_ancestry('//b//d///f//'))
+    ['//b//d///f', '//b//d', '//b']
+    """
+    path = path.rstrip(posixpath.sep)
+    while path.rstrip(posixpath.sep):
+        yield path
+        path, tail = posixpath.split(path)
+
+
+_dedupe = dict.fromkeys
+"""Deduplicate an iterable in original order"""
+
+
+def _difference(minuend, subtrahend):
+    """
+    Return items in minuend not in subtrahend, retaining order
+    with O(1) lookup.
+    """
+    return itertools.filterfalse(set(subtrahend).__contains__, minuend)
+
+
+class InitializedState:
+    """
+    Mix-in to save the initialization state for pickling.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__args = args
+        self.__kwargs = kwargs
+        super().__init__(*args, **kwargs)
+
+    def __getstate__(self):
+        return self.__args, self.__kwargs
+
+    def __setstate__(self, state):
+        args, kwargs = state
+        super().__init__(*args, **kwargs)
+
+
+class CompleteDirs(InitializedState, zipfile.ZipFile):
+    """
+    A ZipFile subclass that ensures that implied directories
+    are always included in the namelist.
+
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt']))
+    ['foo/', 'foo/bar/']
+    >>> list(CompleteDirs._implied_dirs(['foo/bar.txt', 'foo/bar/baz.txt', 'foo/bar/']))
+    ['foo/']
+    """
+
+    @staticmethod
+    def _implied_dirs(names):
+        parents = itertools.chain.from_iterable(map(_parents, names))
+        as_dirs = (p + posixpath.sep for p in parents)
+        return _dedupe(_difference(as_dirs, names))
+
+    def namelist(self):
+        names = super().namelist()
+        return names + list(self._implied_dirs(names))
+
+    def _name_set(self):
+        return set(self.namelist())
+
+    def resolve_dir(self, name):
+        """
+        If the name represents a directory, return that name
+        as a directory (with the trailing slash).
+        """
+        names = self._name_set()
+        dirname = name + '/'
+        dir_match = name not in names and dirname in names
+        return dirname if dir_match else name
+
+    def getinfo(self, name):
+        """
+        Supplement getinfo for implied dirs.
+        """
+        try:
+            return super().getinfo(name)
+        except KeyError:
+            if not name.endswith('/') or name not in self._name_set():
+                raise
+            return zipfile.ZipInfo(filename=name)
+
+    @classmethod
+    def make(cls, source):
+        """
+        Given a source (filename or zipfile), return an
+        appropriate CompleteDirs subclass.
+        """
+        if isinstance(source, CompleteDirs):
+            return source
+
+        if not isinstance(source, zipfile.ZipFile):
+            return cls(source)
+
+        # Only allow for FastLookup when supplied zipfile is read-only
+        if 'r' not in source.mode:
+            cls = CompleteDirs
+
+        source.__class__ = cls
+        return source
+
+    @classmethod
+    def inject(cls, zf: zipfile.ZipFile) -> zipfile.ZipFile:
+        """
+        Given a writable zip file zf, inject directory entries for
+        any directories implied by the presence of children.
+        """
+        for name in cls._implied_dirs(zf.namelist()):
+            zf.writestr(name, b"")
+        return zf
+
+
+class FastLookup(CompleteDirs):
+    """
+    ZipFile subclass to ensure implicit
+    dirs exist and are resolved rapidly.
+    """
+
+    def namelist(self):
+        with contextlib.suppress(AttributeError):
+            return self.__names
+        self.__names = super().namelist()
+        return self.__names
+
+    def _name_set(self):
+        with contextlib.suppress(AttributeError):
+            return self.__lookup
+        self.__lookup = super()._name_set()
+        return self.__lookup
+
+def _extract_text_encoding(encoding=None, *args, **kwargs):
+    # compute stack level so that the caller of the caller sees any warning.
+    is_pypy = sys.implementation.name == 'pypy'
+    # PyPy no longer special cased after 7.3.19 (or maybe 7.3.18)
+    # See jaraco/zipp#143
+    is_old_pypi = is_pypy and sys.pypy_version_info < (7, 3, 19)
+    stack_level = 3 + is_old_pypi
+    return io.text_encoding(encoding, stack_level), args, kwargs
+
+
+class Path:
+    """
+    A :class:`importlib.resources.abc.Traversable` interface for zip files.
+
+    Implements many of the features users enjoy from
+    :class:`pathlib.Path`.
+
+    Consider a zip file with this structure::
+
+        .
+        ├── a.txt
+        └── b
+            ├── c.txt
+            └── d
+                └── e.txt
+
+    >>> data = io.BytesIO()
+    >>> zf = ZipFile(data, 'w')
+    >>> zf.writestr('a.txt', 'content of a')
+    >>> zf.writestr('b/c.txt', 'content of c')
+    >>> zf.writestr('b/d/e.txt', 'content of e')
+    >>> zf.filename = 'mem/abcde.zip'
+
+    Path accepts the zipfile object itself or a filename
+
+    >>> path = Path(zf)
+
+    From there, several path operations are available.
+
+    Directory iteration (including the zip file itself):
+
+    >>> a, b = path.iterdir()
+    >>> a
+    Path('mem/abcde.zip', 'a.txt')
+    >>> b
+    Path('mem/abcde.zip', 'b/')
+
+    name property:
+
+    >>> b.name
+    'b'
+
+    join with divide operator:
+
+    >>> c = b / 'c.txt'
+    >>> c
+    Path('mem/abcde.zip', 'b/c.txt')
+    >>> c.name
+    'c.txt'
+
+    Read text:
+
+    >>> c.read_text(encoding='utf-8')
+    'content of c'
+
+    existence:
+
+    >>> c.exists()
+    True
+    >>> (b / 'missing.txt').exists()
+    False
+
+    Coercion to string:
+
+    >>> import os
+    >>> str(c).replace(os.sep, posixpath.sep)
+    'mem/abcde.zip/b/c.txt'
+
+    At the root, ``name``, ``filename``, and ``parent``
+    resolve to the zipfile.
+
+    >>> str(path)
+    'mem/abcde.zip/'
+    >>> path.name
+    'abcde.zip'
+    >>> path.filename == pathlib.Path('mem/abcde.zip')
+    True
+    >>> str(path.parent)
+    'mem'
+
+    If the zipfile has no filename, such attributes are not
+    valid and accessing them will raise an Exception.
+
+    >>> zf.filename = None
+    >>> path.name
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.filename
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    >>> path.parent
+    Traceback (most recent call last):
+    ...
+    TypeError: ...
+
+    # workaround python/cpython#106763
+    >>> pass
+    """
+
+    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"
+
+    def __init__(self, root, at=""):
+        """
+        Construct a Path from a ZipFile or filename.
+
+        Note: When the source is an existing ZipFile object,
+        its type (__class__) will be mutated to a
+        specialized type. If the caller wishes to retain the
+        original type, the caller should either create a
+        separate ZipFile object or pass a filename.
+        """
+        self.root = FastLookup.make(root)
+        self.at = at
+
+    def __eq__(self, other):
+        """
+        >>> Path(zipfile.ZipFile(io.BytesIO(), 'w')) == 'foo'
+        False
+        """
+        if self.__class__ is not other.__class__:
+            return NotImplemented
+        return (self.root, self.at) == (other.root, other.at)
+
+    def __hash__(self):
+        return hash((self.root, self.at))
+
+    def open(self, mode='r', *args, pwd=None, **kwargs):
+        """
+        Open this entry as text or binary following the semantics
+        of ``pathlib.Path.open()`` by passing arguments through
+        to io.TextIOWrapper().
+        """
+        if self.is_dir():
+            raise IsADirectoryError(self)
+        zip_mode = mode[0]
+        if zip_mode == 'r' and not self.exists():
+            raise FileNotFoundError(self)
+        stream = self.root.open(self.at, zip_mode, pwd=pwd)
+        if 'b' in mode:
+            if args or kwargs:
+                raise ValueError("encoding args invalid for binary operation")
+            return stream
+        # Text mode:
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        return io.TextIOWrapper(stream, encoding, *args, **kwargs)
+
+    def _base(self):
+        return pathlib.PurePosixPath(self.at) if self.at else self.filename
+
+    @property
+    def name(self):
+        return self._base().name
+
+    @property
+    def suffix(self):
+        return self._base().suffix
+
+    @property
+    def suffixes(self):
+        return self._base().suffixes
+
+    @property
+    def stem(self):
+        return self._base().stem
+
+    @property
+    def filename(self):
+        return pathlib.Path(self.root.filename).joinpath(self.at)
+
+    def read_text(self, *args, **kwargs):
+        encoding, args, kwargs = _extract_text_encoding(*args, **kwargs)
+        with self.open('r', encoding, *args, **kwargs) as strm:
+            return strm.read()
+
+    def read_bytes(self):
+        with self.open('rb') as strm:
+            return strm.read()
+
+    def _is_child(self, path):
+        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")
+
+    def _next(self, at):
+        return self.__class__(self.root, at)
+
+    def is_dir(self):
+        return not self.at or self.at.endswith("/")
+
+    def is_file(self):
+        return self.exists() and not self.is_dir()
+
+    def exists(self):
+        return self.at in self.root._name_set()
+
+    def iterdir(self):
+        if not self.is_dir():
+            raise ValueError("Can't listdir a file")
+        subs = map(self._next, self.root.namelist())
+        return filter(self._is_child, subs)
+
+    def match(self, path_pattern):
+        return pathlib.PurePosixPath(self.at).match(path_pattern)
+
+    def is_symlink(self):
+        """
+        Return whether this path is a symlink.
+        """
+        info = self.root.getinfo(self.at)
+        mode = info.external_attr >> 16
+        return stat.S_ISLNK(mode)
+
+    def glob(self, pattern):
+        if not pattern:
+            raise ValueError(f"Unacceptable pattern: {pattern!r}")
+
+        prefix = re.escape(self.at)
+        tr = Translator(seps='/')
+        matches = re.compile(prefix + tr.translate(pattern)).fullmatch
+        return map(self._next, filter(matches, self.root.namelist()))
+
+    def rglob(self, pattern):
+        return self.glob(f'**/{pattern}')
+
+    def relative_to(self, other, *extra):
+        return posixpath.relpath(str(self), str(other.joinpath(*extra)))
+
+    def __str__(self):
+        return posixpath.join(self.root.filename, self.at)
+
+    def __repr__(self):
+        return self.__repr.format(self=self)
+
+    def joinpath(self, *other):
+        next = posixpath.join(self.at, *other)
+        return self._next(self.root.resolve_dir(next))
+
+    __truediv__ = joinpath
+
+    @property
+    def parent(self):
+        if not self.at:
+            return self.filename.parent
+        parent_at = posixpath.dirname(self.at.rstrip('/'))
+        if parent_at:
+            parent_at += '/'
+        return self._next(parent_at)
diff --git a/Lib/zipfile/_path/glob.py b/Lib/zipfile/_path/glob.py
new file mode 100644
index 0000000000..4ed74cc48d
--- /dev/null
+++ b/Lib/zipfile/_path/glob.py
@@ -0,0 +1,113 @@
+import os
+import re
+
+_default_seps = os.sep + str(os.altsep) * bool(os.altsep)
+
+
+class Translator:
+    """
+    >>> Translator('xyz')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+
+    >>> Translator('')
+    Traceback (most recent call last):
+    ...
+    AssertionError: Invalid separators
+    """
+
+    seps: str
+
+    def __init__(self, seps: str = _default_seps):
+        assert seps and set(seps) <= set(_default_seps), "Invalid separators"
+        self.seps = seps
+
+    def translate(self, pattern):
+        """
+        Given a glob pattern, produce a regex that matches it.
+        """
+        return self.extend(self.match_dirs(self.translate_core(pattern)))
+
+    def extend(self, pattern):
+        r"""
+        Extend regex for pattern-wide concerns.
+
+        Apply '(?s:)' to create a non-matching group that
+        matches newlines (valid on Unix).
+
+        Append '\Z' to imply fullmatch even when match is used.
+        """
+        return rf'(?s:{pattern})\Z'
+
+    def match_dirs(self, pattern):
+        """
+        Ensure that zipfile.Path directory names are matched.
+
+        zipfile.Path directory names always end in a slash.
+        """
+        return rf'{pattern}[/]?'
+
+    def translate_core(self, pattern):
+        r"""
+        Given a glob pattern, produce a regex that matches it.
+
+        >>> t = Translator()
+        >>> t.translate_core('*.txt').replace('\\\\', '')
+        '[^/]*\\.txt'
+        >>> t.translate_core('a?txt')
+        'a[^/]txt'
+        >>> t.translate_core('**/*').replace('\\\\', '')
+        '.*/[^/][^/]*'
+        """
+        self.restrict_rglob(pattern)
+        return ''.join(map(self.replace, separate(self.star_not_empty(pattern))))
+
+    def replace(self, match):
+        """
+        Perform the replacements for a match from :func:`separate`.
+        """
+        return match.group('set') or (
+            re.escape(match.group(0))
+            .replace('\\*\\*', r'.*')
+            .replace('\\*', rf'[^{re.escape(self.seps)}]*')
+            .replace('\\?', r'[^/]')
+        )
+
+    def restrict_rglob(self, pattern):
+        """
+        Raise ValueError if ** appears in anything but a full path segment.
+
+        >>> Translator().translate('**foo')
+        Traceback (most recent call last):
+        ...
+        ValueError: ** must appear alone in a path segment
+        """
+        seps_pattern = rf'[{re.escape(self.seps)}]+'
+        segments = re.split(seps_pattern, pattern)
+        if any('**' in segment and segment != '**' for segment in segments):
+            raise ValueError("** must appear alone in a path segment")
+
+    def star_not_empty(self, pattern):
+        """
+        Ensure that * will not match an empty segment.
+        """
+
+        def handle_segment(match):
+            segment = match.group(0)
+            return '?*' if segment == '*' else segment
+
+        not_seps_pattern = rf'[^{re.escape(self.seps)}]+'
+        return re.sub(not_seps_pattern, handle_segment, pattern)
+
+
+def separate(pattern):
+    """
+    Separate out character sets to avoid translating their contents.
+
+    >>> [m.group(0) for m in separate('*.txt')]
+    ['*.txt']
+    >>> [m.group(0) for m in separate('a[?]txt')]
+    ['a', '[?]', 'txt']
+    """
+    return re.finditer(r'([^\[]+)|(?P<set>[\[].*?[\]])|([\[][^\]]*$)', pattern)
diff --git a/Lib/zipimport.py b/Lib/zipimport.py
index 25eaee9c0f..fb312be115 100644
--- a/Lib/zipimport.py
+++ b/Lib/zipimport.py
@@ -1,11 +1,9 @@
 """zipimport provides support for importing Python modules from Zip archives.
 
-This module exports three objects:
+This module exports two objects:
 - zipimporter: a class; its constructor takes a path to a Zip archive.
 - ZipImportError: exception raised by zipimporter objects. It's a
   subclass of ImportError, so it can be caught as ImportError, too.
-- _zip_directory_cache: a dict, mapping archive paths to zip directory
-  info dicts, as used in zipimporter._files.
 
 It is usually not needed to use the zipimport module explicitly; it is
 used by the builtin import mechanism for sys.path items that are paths
@@ -15,7 +13,7 @@
 #from importlib import _bootstrap_external
 #from importlib import _bootstrap  # for _verbose_message
 import _frozen_importlib_external as _bootstrap_external
-from _frozen_importlib_external import _unpack_uint16, _unpack_uint32
+from _frozen_importlib_external import _unpack_uint16, _unpack_uint32, _unpack_uint64
 import _frozen_importlib as _bootstrap  # for _verbose_message
 import _imp  # for check_hash_based_pycs
 import _io  # for open
@@ -40,8 +38,14 @@ class ZipImportError(ImportError):
 _module_type = type(sys)
 
 END_CENTRAL_DIR_SIZE = 22
-STRING_END_ARCHIVE = b'PK\x05\x06'
+END_CENTRAL_DIR_SIZE_64 = 56
+END_CENTRAL_DIR_LOCATOR_SIZE_64 = 20
+STRING_END_ARCHIVE = b'PK\x05\x06'  # standard EOCD signature
+STRING_END_LOCATOR_64 = b'PK\x06\x07'  # Zip64 EOCD Locator signature
+STRING_END_ZIP_64 = b'PK\x06\x06'  # Zip64 EOCD signature
 MAX_COMMENT_LEN = (1 << 16) - 1
+MAX_UINT32 = 0xffffffff
+ZIP64_EXTRA_TAG = 0x1
 
 class zipimporter(_bootstrap_external._LoaderBasics):
     """zipimporter(archivepath) -> zipimporter object
@@ -63,8 +67,7 @@ class zipimporter(_bootstrap_external._LoaderBasics):
     # if found, or else read it from the archive.
     def __init__(self, path):
         if not isinstance(path, str):
-            import os
-            path = os.fsdecode(path)
+            raise TypeError(f"expected str, not {type(path)!r}")
         if not path:
             raise ZipImportError('archive path is empty', path=path)
         if alt_path_sep:
@@ -89,12 +92,8 @@ def __init__(self, path):
                     raise ZipImportError('not a Zip file', path=path)
                 break
 
-        try:
-            files = _zip_directory_cache[path]
-        except KeyError:
-            files = _read_directory(path)
-            _zip_directory_cache[path] = files
-        self._files = files
+        if path not in _zip_directory_cache:
+            _zip_directory_cache[path] = _read_directory(path)
         self.archive = path
         # a prefix directory following the ZIP file path.
         self.prefix = _bootstrap_external._path_join(*prefix[::-1])
@@ -102,64 +101,6 @@ def __init__(self, path):
             self.prefix += path_sep
 
 
-    # Check whether we can satisfy the import of the module named by
-    # 'fullname', or whether it could be a portion of a namespace
-    # package. Return self if we can load it, a string containing the
-    # full path if it's a possible namespace portion, None if we
-    # can't load it.
-    def find_loader(self, fullname, path=None):
-        """find_loader(fullname, path=None) -> self, str or None.
-
-        Search for a module specified by 'fullname'. 'fullname' must be the
-        fully qualified (dotted) module name. It returns the zipimporter
-        instance itself if the module was found, a string containing the
-        full path name if it's possibly a portion of a namespace package,
-        or None otherwise. The optional 'path' argument is ignored -- it's
-        there for compatibility with the importer protocol.
-
-        Deprecated since Python 3.10. Use find_spec() instead.
-        """
-        _warnings.warn("zipimporter.find_loader() is deprecated and slated for "
-                       "removal in Python 3.12; use find_spec() instead",
-                       DeprecationWarning)
-        mi = _get_module_info(self, fullname)
-        if mi is not None:
-            # This is a module or package.
-            return self, []
-
-        # Not a module or regular package. See if this is a directory, and
-        # therefore possibly a portion of a namespace package.
-
-        # We're only interested in the last path component of fullname
-        # earlier components are recorded in self.prefix.
-        modpath = _get_module_path(self, fullname)
-        if _is_dir(self, modpath):
-            # This is possibly a portion of a namespace
-            # package. Return the string representing its path,
-            # without a trailing separator.
-            return None, [f'{self.archive}{path_sep}{modpath}']
-
-        return None, []
-
-
-    # Check whether we can satisfy the import of the module named by
-    # 'fullname'. Return self if we can, None if we can't.
-    def find_module(self, fullname, path=None):
-        """find_module(fullname, path=None) -> self or None.
-
-        Search for a module specified by 'fullname'. 'fullname' must be the
-        fully qualified (dotted) module name. It returns the zipimporter
-        instance itself if the module was found, or None if it wasn't.
-        The optional 'path' argument is ignored -- it's there for compatibility
-        with the importer protocol.
-
-        Deprecated since Python 3.10. Use find_spec() instead.
-        """
-        _warnings.warn("zipimporter.find_module() is deprecated and slated for "
-                       "removal in Python 3.12; use find_spec() instead",
-                       DeprecationWarning)
-        return self.find_loader(fullname, path)[0]
-
     def find_spec(self, fullname, target=None):
         """Create a ModuleSpec for the specified module.
 
@@ -211,7 +152,7 @@ def get_data(self, pathname):
             key = pathname[len(self.archive + path_sep):]
 
         try:
-            toc_entry = self._files[key]
+            toc_entry = self._get_files()[key]
         except KeyError:
             raise OSError(0, '', key)
         return _get_data(self.archive, toc_entry)
@@ -248,7 +189,7 @@ def get_source(self, fullname):
             fullpath = f'{path}.py'
 
         try:
-            toc_entry = self._files[fullpath]
+            toc_entry = self._get_files()[fullpath]
         except KeyError:
             # we have the module, but no source
             return None
@@ -313,28 +254,28 @@ def load_module(self, fullname):
 
 
     def get_resource_reader(self, fullname):
-        """Return the ResourceReader for a package in a zip file.
-
-        If 'fullname' is a package within the zip file, return the
-        'ResourceReader' object for the package.  Otherwise return None.
-        """
-        try:
-            if not self.is_package(fullname):
-                return None
-        except ZipImportError:
-            return None
+        """Return the ResourceReader for a module in a zip file."""
         from importlib.readers import ZipReader
+
         return ZipReader(self, fullname)
 
 
-    def invalidate_caches(self):
-        """Reload the file data of the archive path."""
+    def _get_files(self):
+        """Return the files within the archive path."""
         try:
-            self._files = _read_directory(self.archive)
-            _zip_directory_cache[self.archive] = self._files
-        except ZipImportError:
-            _zip_directory_cache.pop(self.archive, None)
-            self._files = {}
+            files = _zip_directory_cache[self.archive]
+        except KeyError:
+            try:
+                files = _zip_directory_cache[self.archive] = _read_directory(self.archive)
+            except ZipImportError:
+                files = {}
+
+        return files
+
+
+    def invalidate_caches(self):
+        """Invalidates the cache of file data of the archive path."""
+        _zip_directory_cache.pop(self.archive, None)
 
 
     def __repr__(self):
@@ -364,15 +305,15 @@ def _is_dir(self, path):
     # of a namespace package. We test by seeing if the name, with an
     # appended path separator, exists.
     dirpath = path + path_sep
-    # If dirpath is present in self._files, we have a directory.
-    return dirpath in self._files
+    # If dirpath is present in self._get_files(), we have a directory.
+    return dirpath in self._get_files()
 
 # Return some information about a module.
 def _get_module_info(self, fullname):
     path = _get_module_path(self, fullname)
     for suffix, isbytecode, ispackage in _zip_searchorder:
         fullpath = path + suffix
-        if fullpath in self._files:
+        if fullpath in self._get_files():
             return ispackage
     return None
 
@@ -406,16 +347,11 @@ def _read_directory(archive):
         raise ZipImportError(f"can't open Zip file: {archive!r}", path=archive)
 
     with fp:
+        # GH-87235: On macOS all file descriptors for /dev/fd/N share the same
+        # file offset, reset the file offset after scanning the zipfile directory
+        # to not cause problems when some runs 'python3 /dev/fd/9 9<some_script'
+        start_offset = fp.tell()
         try:
-            fp.seek(-END_CENTRAL_DIR_SIZE, 2)
-            header_position = fp.tell()
-            buffer = fp.read(END_CENTRAL_DIR_SIZE)
-        except OSError:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        if len(buffer) != END_CENTRAL_DIR_SIZE:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        if buffer[:4] != STRING_END_ARCHIVE:
-            # Bad: End of Central Dir signature
             # Check if there's a comment.
             try:
                 fp.seek(0, 2)
@@ -423,97 +359,192 @@ def _read_directory(archive):
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}",
                                      path=archive)
-            max_comment_start = max(file_size - MAX_COMMENT_LEN -
-                                    END_CENTRAL_DIR_SIZE, 0)
+            max_comment_plus_dirs_size = (
+                MAX_COMMENT_LEN + END_CENTRAL_DIR_SIZE +
+                END_CENTRAL_DIR_SIZE_64 + END_CENTRAL_DIR_LOCATOR_SIZE_64)
+            max_comment_start = max(file_size - max_comment_plus_dirs_size, 0)
             try:
                 fp.seek(max_comment_start)
-                data = fp.read()
+                data = fp.read(max_comment_plus_dirs_size)
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}",
                                      path=archive)
             pos = data.rfind(STRING_END_ARCHIVE)
-            if pos < 0:
+            pos64 = data.rfind(STRING_END_ZIP_64)
+
+            if (pos64 >= 0 and pos64+END_CENTRAL_DIR_SIZE_64+END_CENTRAL_DIR_LOCATOR_SIZE_64==pos):
+                # Zip64 at "correct" offset from standard EOCD
+                buffer = data[pos64:pos64 + END_CENTRAL_DIR_SIZE_64]
+                if len(buffer) != END_CENTRAL_DIR_SIZE_64:
+                    raise ZipImportError(
+                        f"corrupt Zip64 file: Expected {END_CENTRAL_DIR_SIZE_64} byte "
+                        f"zip64 central directory, but read {len(buffer)} bytes.",
+                        path=archive)
+                header_position = file_size - len(data) + pos64
+
+                central_directory_size = _unpack_uint64(buffer[40:48])
+                central_directory_position = _unpack_uint64(buffer[48:56])
+                num_entries = _unpack_uint64(buffer[24:32])
+            elif pos >= 0:
+                buffer = data[pos:pos+END_CENTRAL_DIR_SIZE]
+                if len(buffer) != END_CENTRAL_DIR_SIZE:
+                    raise ZipImportError(f"corrupt Zip file: {archive!r}",
+                                         path=archive)
+
+                header_position = file_size - len(data) + pos
+
+                # Buffer now contains a valid EOCD, and header_position gives the
+                # starting position of it.
+                central_directory_size = _unpack_uint32(buffer[12:16])
+                central_directory_position = _unpack_uint32(buffer[16:20])
+                num_entries = _unpack_uint16(buffer[8:10])
+
+                # N.b. if someday you want to prefer the standard (non-zip64) EOCD,
+                # you need to adjust position by 76 for arc to be 0.
+            else:
                 raise ZipImportError(f'not a Zip file: {archive!r}',
                                      path=archive)
-            buffer = data[pos:pos+END_CENTRAL_DIR_SIZE]
-            if len(buffer) != END_CENTRAL_DIR_SIZE:
-                raise ZipImportError(f"corrupt Zip file: {archive!r}",
-                                     path=archive)
-            header_position = file_size - len(data) + pos
-
-        header_size = _unpack_uint32(buffer[12:16])
-        header_offset = _unpack_uint32(buffer[16:20])
-        if header_position < header_size:
-            raise ZipImportError(f'bad central directory size: {archive!r}', path=archive)
-        if header_position < header_offset:
-            raise ZipImportError(f'bad central directory offset: {archive!r}', path=archive)
-        header_position -= header_size
-        arc_offset = header_position - header_offset
-        if arc_offset < 0:
-            raise ZipImportError(f'bad central directory size or offset: {archive!r}', path=archive)
-
-        files = {}
-        # Start of Central Directory
-        count = 0
-        try:
-            fp.seek(header_position)
-        except OSError:
-            raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-        while True:
-            buffer = fp.read(46)
-            if len(buffer) < 4:
-                raise EOFError('EOF read where not expected')
-            # Start of file header
-            if buffer[:4] != b'PK\x01\x02':
-                break                                # Bad: Central Dir File Header
-            if len(buffer) != 46:
-                raise EOFError('EOF read where not expected')
-            flags = _unpack_uint16(buffer[8:10])
-            compress = _unpack_uint16(buffer[10:12])
-            time = _unpack_uint16(buffer[12:14])
-            date = _unpack_uint16(buffer[14:16])
-            crc = _unpack_uint32(buffer[16:20])
-            data_size = _unpack_uint32(buffer[20:24])
-            file_size = _unpack_uint32(buffer[24:28])
-            name_size = _unpack_uint16(buffer[28:30])
-            extra_size = _unpack_uint16(buffer[30:32])
-            comment_size = _unpack_uint16(buffer[32:34])
-            file_offset = _unpack_uint32(buffer[42:46])
-            header_size = name_size + extra_size + comment_size
-            if file_offset > header_offset:
-                raise ZipImportError(f'bad local header offset: {archive!r}', path=archive)
-            file_offset += arc_offset
 
+            # Buffer now contains a valid EOCD, and header_position gives the
+            # starting position of it.
+            # XXX: These are cursory checks but are not as exact or strict as they
+            # could be.  Checking the arc-adjusted value is probably good too.
+            if header_position < central_directory_size:
+                raise ZipImportError(f'bad central directory size: {archive!r}', path=archive)
+            if header_position < central_directory_position:
+                raise ZipImportError(f'bad central directory offset: {archive!r}', path=archive)
+            header_position -= central_directory_size
+            # On just-a-zipfile these values are the same and arc_offset is zero; if
+            # the file has some bytes prepended, `arc_offset` is the number of such
+            # bytes.  This is used for pex as well as self-extracting .exe.
+            arc_offset = header_position - central_directory_position
+            if arc_offset < 0:
+                raise ZipImportError(f'bad central directory size or offset: {archive!r}', path=archive)
+
+            files = {}
+            # Start of Central Directory
+            count = 0
             try:
-                name = fp.read(name_size)
-            except OSError:
-                raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-            if len(name) != name_size:
-                raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
-            # On Windows, calling fseek to skip over the fields we don't use is
-            # slower than reading the data because fseek flushes stdio's
-            # internal buffers.    See issue #8745.
-            try:
-                if len(fp.read(header_size - name_size)) != header_size - name_size:
-                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                fp.seek(header_position)
             except OSError:
                 raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+            while True:
+                buffer = fp.read(46)
+                if len(buffer) < 4:
+                    raise EOFError('EOF read where not expected')
+                # Start of file header
+                if buffer[:4] != b'PK\x01\x02':
+                    if count != num_entries:
+                        raise ZipImportError(
+                            f"mismatched num_entries: {count} should be {num_entries} in {archive!r}",
+                            path=archive,
+                        )
+                    break                                # Bad: Central Dir File Header
+                if len(buffer) != 46:
+                    raise EOFError('EOF read where not expected')
+                flags = _unpack_uint16(buffer[8:10])
+                compress = _unpack_uint16(buffer[10:12])
+                time = _unpack_uint16(buffer[12:14])
+                date = _unpack_uint16(buffer[14:16])
+                crc = _unpack_uint32(buffer[16:20])
+                data_size = _unpack_uint32(buffer[20:24])
+                file_size = _unpack_uint32(buffer[24:28])
+                name_size = _unpack_uint16(buffer[28:30])
+                extra_size = _unpack_uint16(buffer[30:32])
+                comment_size = _unpack_uint16(buffer[32:34])
+                file_offset = _unpack_uint32(buffer[42:46])
+                header_size = name_size + extra_size + comment_size
 
-            if flags & 0x800:
-                # UTF-8 file names extension
-                name = name.decode()
-            else:
-                # Historical ZIP filename encoding
                 try:
-                    name = name.decode('ascii')
-                except UnicodeDecodeError:
-                    name = name.decode('latin1').translate(cp437_table)
-
-            name = name.replace('/', path_sep)
-            path = _bootstrap_external._path_join(archive, name)
-            t = (path, compress, data_size, file_size, file_offset, time, date, crc)
-            files[name] = t
-            count += 1
+                    name = fp.read(name_size)
+                except OSError:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                if len(name) != name_size:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                # On Windows, calling fseek to skip over the fields we don't use is
+                # slower than reading the data because fseek flushes stdio's
+                # internal buffers.    See issue #8745.
+                try:
+                    extra_data_len = header_size - name_size
+                    extra_data = memoryview(fp.read(extra_data_len))
+
+                    if len(extra_data) != extra_data_len:
+                        raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+                except OSError:
+                    raise ZipImportError(f"can't read Zip file: {archive!r}", path=archive)
+
+                if flags & 0x800:
+                    # UTF-8 file names extension
+                    name = name.decode()
+                else:
+                    # Historical ZIP filename encoding
+                    try:
+                        name = name.decode('ascii')
+                    except UnicodeDecodeError:
+                        name = name.decode('latin1').translate(cp437_table)
+
+                name = name.replace('/', path_sep)
+                path = _bootstrap_external._path_join(archive, name)
+
+                # Ordering matches unpacking below.
+                if (
+                    file_size == MAX_UINT32 or
+                    data_size == MAX_UINT32 or
+                    file_offset == MAX_UINT32
+                ):
+                    # need to decode extra_data looking for a zip64 extra (which might not
+                    # be present)
+                    while extra_data:
+                        if len(extra_data) < 4:
+                            raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                        tag = _unpack_uint16(extra_data[:2])
+                        size = _unpack_uint16(extra_data[2:4])
+                        if len(extra_data) < 4 + size:
+                            raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                        if tag == ZIP64_EXTRA_TAG:
+                            if (len(extra_data) - 4) % 8 != 0:
+                                raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                            num_extra_values = (len(extra_data) - 4) // 8
+                            if num_extra_values > 3:
+                                raise ZipImportError(f"can't read header extra: {archive!r}", path=archive)
+                            import struct
+                            values = list(struct.unpack_from(f"<{min(num_extra_values, 3)}Q",
+                                                             extra_data, offset=4))
+
+                            # N.b. Here be dragons: the ordering of these is different than
+                            # the header fields, and it's really easy to get it wrong since
+                            # naturally-occuring zips that use all 3 are >4GB
+                            if file_size == MAX_UINT32:
+                                file_size = values.pop(0)
+                            if data_size == MAX_UINT32:
+                                data_size = values.pop(0)
+                            if file_offset == MAX_UINT32:
+                                file_offset = values.pop(0)
+
+                            break
+
+                        # For a typical zip, this bytes-slicing only happens 2-3 times, on
+                        # small data like timestamps and filesizes.
+                        extra_data = extra_data[4+size:]
+                    else:
+                        _bootstrap._verbose_message(
+                            "zipimport: suspected zip64 but no zip64 extra for {!r}",
+                            path,
+                        )
+                # XXX These two statements seem swapped because `central_directory_position`
+                # is a position within the actual file, but `file_offset` (when compared) is
+                # as encoded in the entry, not adjusted for this file.
+                # N.b. this must be after we've potentially read the zip64 extra which can
+                # change `file_offset`.
+                if file_offset > central_directory_position:
+                    raise ZipImportError(f'bad local header offset: {archive!r}', path=archive)
+                file_offset += arc_offset
+
+                t = (path, compress, data_size, file_size, file_offset, time, date, crc)
+                files[name] = t
+                count += 1
+        finally:
+            fp.seek(start_offset)
     _bootstrap._verbose_message('zipimport: found {} names in {!r}', count, archive)
     return files
 
@@ -708,7 +739,7 @@ def _get_mtime_and_size_of_source(self, path):
         # strip 'c' or 'o' from *.py[co]
         assert path[-1:] in ('c', 'o')
         path = path[:-1]
-        toc_entry = self._files[path]
+        toc_entry = self._get_files()[path]
         # fetch the time stamp of the .py file for comparison
         # with an embedded pyc time stamp
         time = toc_entry[5]
@@ -728,7 +759,7 @@ def _get_pyc_source(self, path):
     path = path[:-1]
 
     try:
-        toc_entry = self._files[path]
+        toc_entry = self._get_files()[path]
     except KeyError:
         return None
     else:
@@ -744,7 +775,7 @@ def _get_module_code(self, fullname):
         fullpath = path + suffix
         _bootstrap._verbose_message('trying {}{}{}', self.archive, path_sep, fullpath, verbosity=2)
         try:
-            toc_entry = self._files[fullpath]
+            toc_entry = self._get_files()[fullpath]
         except KeyError:
             pass
         else:
diff --git a/Lib/zoneinfo/_common.py b/Lib/zoneinfo/_common.py
index 98cdfe37ca..03cc42149f 100644
--- a/Lib/zoneinfo/_common.py
+++ b/Lib/zoneinfo/_common.py
@@ -9,9 +9,13 @@ def load_tzdata(key):
     resource_name = components[-1]
 
     try:
-        return resources.files(package_name).joinpath(resource_name).open("rb")
-    except (ImportError, FileNotFoundError, UnicodeEncodeError):
-        # There are three types of exception that can be raised that all amount
+        path = resources.files(package_name).joinpath(resource_name)
+        # gh-85702: Prevent PermissionError on Windows
+        if path.is_dir():
+            raise IsADirectoryError
+        return path.open("rb")
+    except (ImportError, FileNotFoundError, UnicodeEncodeError, IsADirectoryError):
+        # There are four types of exception that can be raised that all amount
         # to "we cannot find this key":
         #
         # ImportError: If package_name doesn't exist (e.g. if tzdata is not
@@ -21,6 +25,7 @@ def load_tzdata(key):
         #   (e.g. Europe/Krasnoy)
         # UnicodeEncodeError: If package_name or resource_name are not UTF-8,
         #   such as keys containing a surrogate character.
+        # IsADirectoryError: If package_name without a resource_name specified.
         raise ZoneInfoNotFoundError(f"No time zone found with key {key}")
 
 
diff --git a/Lib/zoneinfo/_zoneinfo.py b/Lib/zoneinfo/_zoneinfo.py
index b77dc0ed39..3ffdb4c837 100644
--- a/Lib/zoneinfo/_zoneinfo.py
+++ b/Lib/zoneinfo/_zoneinfo.py
@@ -75,12 +75,12 @@ def _new_instance(cls, key):
         return obj
 
     @classmethod
-    def from_file(cls, fobj, /, key=None):
+    def from_file(cls, file_obj, /, key=None):
         obj = super().__new__(cls)
         obj._key = key
         obj._file_path = None
-        obj._load_file(fobj)
-        obj._file_repr = repr(fobj)
+        obj._load_file(file_obj)
+        obj._file_repr = repr(file_obj)
 
         # Disable pickling for objects created from files
         obj.__reduce__ = obj._file_reduce
diff --git a/README.md b/README.md
index ce5f02bee2..b3ddbe4e7c 100644
--- a/README.md
+++ b/README.md
@@ -66,6 +66,18 @@ Welcome to the magnificent Rust Python interpreter
 >>>>>
 ```
 
+### venv
+
+Because RustPython currently doesn't provide a well-packaged installation, using venv helps to use pip easier.
+
+```sh
+$ rustpython -m venv <your_env_name>
+$ . <your_env_name>/bin/activate
+$ python # now `python` is the alias of the RustPython for the new env
+```
+
+### PIP
+
 If you'd like to make https requests, you can enable the `ssl` feature, which
 also lets you install the `pip` package manager. Note that on Windows, you may
 need to install OpenSSL, or you can enable the `ssl-vendor` feature instead,
@@ -76,7 +88,7 @@ Once you've installed rustpython with SSL support, you can install pip by
 running:
 
 ```bash
-cargo install --git https://github.com/RustPython/RustPython --features ssl
+cargo install --git https://github.com/RustPython/RustPython
 rustpython --install-pip
 ```
 
@@ -88,6 +100,13 @@ conda install rustpython -c conda-forge
 rustpython
 ```
 
+### SSL provider
+
+For HTTPS requests, `ssl-rustls` feature is enabled by default. You can replace it with `ssl-openssl` feature if your environment requires OpenSSL.
+Note that to use OpenSSL on Windows, you may need to install OpenSSL, or you can enable the `ssl-vendor` feature instead,
+which compiles OpenSSL for you but requires a C compiler, perl, and `make`.
+OpenSSL version 3 is expected and tested in CI. Older versions may not work.
+
 ### WASI
 
 You can compile RustPython to a standalone WebAssembly WASI module so it can run anywhere.
diff --git a/architecture/architecture.md b/architecture/architecture.md
index a59b6498bf..4b4110ee89 100644
--- a/architecture/architecture.md
+++ b/architecture/architecture.md
@@ -20,7 +20,43 @@ If, after reading this, you want to contribute to RustPython, take a look at the
 
 A high-level overview of the workings of RustPython is visible in the figure below, showing how Python source files are interpreted.
 
-![overview.png](overview.png)
+```mermaid
+flowchart TB
+  SourceCode["🐍 Source code"]
+
+  subgraph Interpreter["RustPython Interpreter"]
+    direction TB
+
+    subgraph Parser["Parser"]
+        ParserBox["• Tokenize source code<br/>• Validate tokens<br/>• Create AST"]
+    end
+
+    AST[["AST"]]
+
+    subgraph Compiler["Compiler"]
+        CompilerBox["• Converts AST to bytecode"]
+    end
+
+    Bytecode[["Bytecode"]]
+
+    subgraph VM["VM"]
+        VMBox["• Executes bytecode given input"]
+    end
+
+    Parser --> AST
+    AST --> Compiler
+    Compiler --> Bytecode
+    Bytecode --> VM
+  end
+
+  SourceCode -------> Interpreter
+
+  Input[["Input"]]
+  Output["Code gets executed"]
+
+  Input --> VM
+  VM --> Output
+```
 
 Main architecture of RustPython.
 
@@ -36,9 +72,9 @@ The main entry point of RustPython is located in `src/main.rs` and simply forwar
 
 For each of the three components, the entry point is as follows:
 
-- Parser: The Parser is located in a separate project, [RustPython/Parser][10]. See the documentation there for more information.
-- Compiler: `compile`, located in [`vm/src/vm/compile.rs`][11], this eventually forwards a call to [`compiler::compile`][12].
-- VM: `run_code_obj`, located in [`vm/src/vm/mod.rs`][13]. This creates a new frame in which the bytecode is executed.
+- Parser: The Parser is located in a separate project, [ruff_python_parser][10]. See the documentation there for more information.
+- Compiler: `compile`, located in [`crates/vm/src/vm/compile.rs`][11], this eventually forwards a call to [`compiler::compile`][12].
+- VM: `run_code_obj`, located in [`crates/vm/src/vm/mod.rs`][13]. This creates a new frame in which the bytecode is executed.
 
 ## Components
 
@@ -46,7 +82,7 @@ Here we give a brief overview of each component and its function. For more detai
 
 ### Compiler
 
-This component, implemented as the `rustpython-compiler/` package, is responsible for translating a Python source file into its equivalent bytecode representation. As an example, the following Python file:
+This component, implemented as the `rustpython-compiler` package, is responsible for translating a Python source file into its equivalent bytecode representation. As an example, the following Python file:
 
 ```python
 def f(x):
@@ -71,11 +107,11 @@ The Parser is the main sub-component of the compiler. All the functionality requ
 1. Lexical Analysis
 2. Parsing
 
-The functionality for parsing resides in the RustPython/Parser project. See the documentation there for more information.
+The functionality for parsing resides in the ruff_python_parser project in the astral-sh/ruff repository. See the documentation there for more information.
 
 ### VM
 
-The Virtual Machine (VM) is responsible for executing the bytecode generated by the compiler. It is implemented in the `rustpython-vm/` package. The VM is currently implemented as a stack machine, meaning that it uses a stack to store intermediate results. In the `rustpython-vm/` package, additional sub-components are present, for example:
+The Virtual Machine (VM) is responsible for executing the bytecode generated by the compiler. It is implemented in the `rustpython-vm` package. The VM is currently implemented as a stack machine, meaning that it uses a stack to store intermediate results. In the `rustpython-vm` package, additional sub-components are present, for example:
 
 - builtins: the built in objects of Python, such as `int` and `str`.
 - stdlib: parts of the standard library that contains built-in modules needed for the VM to function, such as `sys`.
@@ -122,7 +158,7 @@ The RustPython executable/REPL (Read-Eval-Print-Loop) is implemented here, which
 Some things to note:
 
 - The CLI is defined in the [`run` function of `src/lib.rs`][16].
-- The interface and helper for the REPL are defined in this package, but the actual REPL can be found in `vm/src/readline.rs`
+- The interface and helper for the REPL are defined in this package, but the actual REPL can be found in `crates/vm/src/readline.rs`
 
 ### WASM
 
@@ -133,18 +169,18 @@ Crate for WebAssembly build, which compiles the RustPython package to a format t
 Integration and snippets that test for additional edge-cases, implementation specific functionality and bug report snippets.
 
 [1]: https://github.com/RustPython/RustPython
-[2]: https://2021.desosa.nl/projects/rustpython/posts/vision/
+[2]: https://web.archive.org/web/20240723122357/https://2021.desosa.nl/projects/rustpython/posts/vision/
 [3]: https://www.youtube.com/watch?v=nJDY9ASuiLc&t=213s
 [4]: https://rustpython.github.io/2020/04/02/thing-explainer-parser.html
 [5]: https://rustpython.github.io/demo/
 [6]: https://rustpython.github.io/demo/notebook/
-[7]: https://github.com/RustPython/RustPython/blob/master/DEVELOPMENT.md
+[7]: https://github.com/RustPython/RustPython/blob/main/DEVELOPMENT.md
 [8]: https://rustpython.github.io/guideline/2020/04/04/how-to-contribute-by-cpython-unittest.html
-[9]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/src/lib.rs#L63
-[10]: https://github.com/RustPython/Parser
-[11]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/vm/src/vm/compile.rs#LL10C17-L10C17
-[12]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/vm/src/vm/compile.rs#L26
-[13]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/vm/src/vm/mod.rs#L356
-[14]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/common/src/float_ops.rs
+[9]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/src/lib.rs#L72
+[10]: https://github.com/astral-sh/ruff/tree/2bffef59665ce7d2630dfd72ee99846663660db8/crates/ruff_python_parser
+[11]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/crates/vm/src/vm/compile.rs#L10
+[12]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/crates/vm/src/vm/compile.rs#L26
+[13]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/crates/vm/src/vm/mod.rs#L433
+[14]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/crates/common/src/float_ops.rs
 [15]: https://rustpython.github.io/guideline/2020/04/04/how-to-contribute-by-cpython-unittest.html
-[16]: https://github.com/RustPython/RustPython/blob/0e24cf48c63ae4ca9f829e88142a987cab3a9966/src/lib.rs#L63
+[16]: https://github.com/RustPython/RustPython/blob/d36a2cffdef2218f3264cef9145a1f781d474ea3/src/lib.rs#L72
diff --git a/architecture/overview.png b/architecture/overview.png
deleted file mode 100644
index ce66706f3c..0000000000
Binary files a/architecture/overview.png and /dev/null differ
diff --git a/benches/README.md b/benches/README.md
index f6e5129617..4823751fd1 100644
--- a/benches/README.md
+++ b/benches/README.md
@@ -4,19 +4,26 @@ These are some files to determine performance of rustpython.
 
 ## Usage
 
-Running `cargo bench` from the root of the repository will start the benchmarks. Once done there will be a graphical 
+Running `cargo bench` from the root of the repository will start the benchmarks. Once done there will be a graphical
 report under `target/criterion/report/index.html` that you can use use to view the results.
 
-To view Python tracebacks during benchmarks, run `RUST_BACKTRACE=1 cargo bench`. You can also bench against a 
+`cargo bench` supports name matching to run a subset of the benchmarks. To
+run only the sorted microbenchmark, you can run:
+
+```shell
+cargo bench sorted
+```
+
+To view Python tracebacks during benchmarks, run `RUST_BACKTRACE=1 cargo bench`. You can also bench against a
 specific installed Python version by running:
 
 ```shell
-$ PYTHON_SYS_EXECUTABLE=python3.7 cargo bench
+PYTHON_SYS_EXECUTABLE=python3.13 cargo bench
 ```
 
 ### Adding a benchmark
 
-Simply adding a file to the `benchmarks/` directory will add it to the set of files benchmarked. Each file is tested 
+Simply adding a file to the `benchmarks/` directory will add it to the set of files benchmarked. Each file is tested
 in two ways:
 
 1. The time to parse the file to AST
@@ -24,8 +31,9 @@ in two ways:
 
 ### Adding a micro benchmark
 
-Micro benchmarks are small snippets of code added under the `microbenchmarks/` directory. A microbenchmark file has 
+Micro benchmarks are small snippets of code added under the `microbenchmarks/` directory. A microbenchmark file has
 two sections:
+
 1. Optional setup code
 2. The code to be benchmarked
 
@@ -39,8 +47,8 @@ a_list = [1,2,3]
 len(a_list)
 ```
 
-Only `len(a_list)` will be timed. Setup or benchmarked code can optionally reference a variable called `ITERATIONS`. If 
-present then the benchmark code will be invoked 5 times with `ITERATIONS` set to a value between 100 and 1,000. For 
+Only `len(a_list)` will be timed. Setup or benchmarked code can optionally reference a variable called `ITERATIONS`. If
+present then the benchmark code will be invoked 5 times with `ITERATIONS` set to a value between 100 and 1,000. For
 example:
 
 ```python
@@ -49,7 +57,7 @@ obj = [i for i in range(ITERATIONS)]
 
 `ITERATIONS` can appear in both the setup code and the benchmark code.
 
-## MacOS setup 
+## MacOS setup
 
 On MacOS you will need to add the following to a `.cargo/config` file:
 
@@ -63,4 +71,4 @@ rustflags = [
 
 ## Benchmark source
 
-- https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/nbody-python3-2.html
+- <https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/nbody-python3-2.html>
diff --git a/benches/_data/pypi_org__simple__psutil.json b/benches/_data/pypi_org__simple__psutil.json
new file mode 100644
index 0000000000..91e2ff6b39
--- /dev/null
+++ b/benches/_data/pypi_org__simple__psutil.json
@@ -0,0 +1 @@
+{"alternate-locations":[],"files":[{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.1.tar.gz","hashes":{"sha256":"25c6caffbf00d8be77489391a784654e99fcbaf2a5278e80f748be4112ee0188"},"provenance":null,"requires-python":null,"size":44485,"upload-time":"2014-02-06T02:06:57.249874Z","url":"https://files.pythonhosted.org/packages/69/e4/7e36e3e6cbc83b76f1c93a63d4c053a03ca99f1c99b106835cb175b5932a/psutil-0.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.2.tar.gz","hashes":{"sha256":"4a13d7f760b043b263346e48823b1dfd4c202e97b23483e481e5ff696e74509e"},"provenance":null,"requires-python":null,"size":61640,"upload-time":"2014-02-06T02:06:51.674389Z","url":"https://files.pythonhosted.org/packages/6e/51/56198d83577106bf89cb23bffcb273f923aea8d5ffe03e3fce55f830c323/psutil-0.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.1.3.tar.gz","hashes":{"sha256":"43e327934b4a273da20d3a5797d6abcaab37914f61499d96fcf9e8e1ae75442b"},"provenance":null,"requires-python":null,"size":85749,"upload-time":"2014-02-06T02:06:45.294070Z","url":"https://files.pythonhosted.org/packages/1d/4f/dcfe500fd43e3d6b26d253cb0d7e6e3a7d80224b5059bd50c482aff62eef/psutil-0.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.tar.gz","hashes":{"sha256":"8de8efa92162c94f623297f522e440e818dc7b832f421f9f490324bc7d5d0d92"},"provenance":null,"requires-python":null,"size":129382,"upload-time":"2014-02-06T02:03:03.376283Z","url":"https://files.pythonhosted.org/packages/58/20/3457e441edc1625c6e1dbfcf780d2b22f2e9caa8606c3fd8ce6c48104e87/psutil-0.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"4ce48cbbe3c915a9b720ce6465da34ce79465ffde63de8254cc9c8235fef824d"},"provenance":null,"requires-python":null,"size":291186,"upload-time":"2014-02-06T16:48:27.727869Z","url":"https://files.pythonhosted.org/packages/e6/1d/9a90eec0aec7e015d16f3922328336b4f8cd783f782e9ab81146b47ffee3/psutil-0.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"eeba1fa1f2455219a05775044f7a76741252ea0bd4c762e7b652d281843c79ff"},"provenance":null,"requires-python":null,"size":289973,"upload-time":"2014-02-06T16:48:36.482056Z","url":"https://files.pythonhosted.org/packages/1d/75/7c67bc2c8304b137a8ff709d21cb2dd7f600bc5ee76ecc88f77ec008e69e/psutil-0.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"919dabb5d47dc769a198a5d015c6765ef39b3b920c2ab6d04d05d9aa3ae6bb67"},"provenance":null,"requires-python":null,"size":289890,"upload-time":"2014-02-06T16:48:46.485205Z","url":"https://files.pythonhosted.org/packages/e0/e4/2ec24cecccf111a4dbda892b484bdfd8c00d3da5f99c1a0a79c469c62fb2/psutil-0.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.5.exe","hashes":{"sha256":"92f51445439f1082dab7733b9150b594b3797f4c96578457768c3e761f86c240"},"provenance":null,"requires-python":null,"size":129555,"upload-time":"2014-02-06T16:47:42.630117Z","url":"https://files.pythonhosted.org/packages/04/4f/478408899102af1d0d877be0b67e302fada1bdd8c8faaa4adc0e19550e53/psutil-0.2.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.6.exe","hashes":{"sha256":"c3e3dc863834d03485f6c48a735f76ab9a7cff2911d101c8cbd1e553c03f0fae"},"provenance":null,"requires-python":null,"size":262087,"upload-time":"2014-02-06T16:47:50.995531Z","url":"https://files.pythonhosted.org/packages/d7/f9/984326888f6c519cc813a96640cc9a2900dad85e15b9d368fe1f12a9bd11/psutil-0.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py2.7.exe","hashes":{"sha256":"08c6f16ac00babe2c54067dbc305c0587cb896a8eb64383290cdafdba74ea123"},"provenance":null,"requires-python":null,"size":261605,"upload-time":"2014-02-06T16:47:58.286157Z","url":"https://files.pythonhosted.org/packages/69/5c/be56c645a254ad83a9aa3055564aae543fdf23186aa5ec9c495a3937300b/psutil-0.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py3.3.exe","hashes":{"sha256":"e1f7cf0158a94e6b50f9a4b6f4258dec1bd89c9485c65d54b89ba2a09f0d51a3"},"provenance":null,"requires-python":null,"size":256763,"upload-time":"2014-02-06T16:48:06.663656Z","url":"https://files.pythonhosted.org/packages/76/42/d6813ce55af42553b2a3136e5159bd71e544bda5fdaed04c72759514e375/psutil-0.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.0.win32-py3.4.exe","hashes":{"sha256":"e49d818a4a49fd1ced40dac31076af622a40407234f717bc6a5c39b3f2335e81"},"provenance":null,"requires-python":null,"size":256718,"upload-time":"2014-02-06T16:48:16.971617Z","url":"https://files.pythonhosted.org/packages/f5/83/45b721a52001c1ba1f196e6b2ba3b12d99cbc03bf3f508f1fe56b4e25c66/psutil-0.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.tar.gz","hashes":{"sha256":"bd33f5f9e04b7677a932cc90d541ceec0050080d1b053ed39488ef39cb0fb4f4"},"provenance":null,"requires-python":null,"size":144657,"upload-time":"2014-02-06T02:06:37.338565Z","url":"https://files.pythonhosted.org/packages/9b/62/03133a1b4d1439227bc9b27389fc7d1137d111cbb15197094225967e21cf/psutil-0.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"ab9d06c0c2a7baadebf66fbc74a2532520b3b6d4a58ba3c1f04311a175ed9e7f"},"provenance":null,"requires-python":null,"size":294651,"upload-time":"2014-02-06T16:46:46.406386Z","url":"https://files.pythonhosted.org/packages/55/3e/e49b7929b9daf9c3dcf31668a43ba669d22bb8606deca52e6f92cb67324d/psutil-0.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"076c9914d8aadccd459e3efedc49c10f14d16918d0af5735c22a2bdcc3f90cac"},"provenance":null,"requires-python":null,"size":293431,"upload-time":"2014-02-06T16:46:54.986513Z","url":"https://files.pythonhosted.org/packages/34/f5/f471c56be91d10c9b83d22aa9f6f29006437f2196c89156f00f56f6e4661/psutil-0.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"2679f8f9f20e61d85177f3fc6ee10bfbd6c4bd122b3f5774ba36d0035cac4f7a"},"provenance":null,"requires-python":null,"size":293352,"upload-time":"2014-02-06T16:47:04.453988Z","url":"https://files.pythonhosted.org/packages/68/ee/fc85a707394d1b374da61c071dee12299e779d87c09a86c727b6f30ad9a6/psutil-0.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.5.exe","hashes":{"sha256":"a8345934d7585c75d500098491f2a434dbba9e378fd908d76fbeb0bc20b8a3d3"},"provenance":null,"requires-python":null,"size":132806,"upload-time":"2014-02-06T16:46:02.328109Z","url":"https://files.pythonhosted.org/packages/ca/6e/5c0a87e2c1bac5e32471eb84b349f0808f6d6ed49b9118784af9d0e71baa/psutil-0.2.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.6.exe","hashes":{"sha256":"9b6294c3327625839fdbe92dca4093ab55e422fb348790b2ffc5c6cde163fe5b"},"provenance":null,"requires-python":null,"size":265263,"upload-time":"2014-02-06T16:46:11.006069Z","url":"https://files.pythonhosted.org/packages/e5/13/b358b509d4996df82ef77758c14c0999c443df537eefacc7bb24b6339758/psutil-0.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py2.7.exe","hashes":{"sha256":"ac4d86abc4c850141cd1e054a64f1fcb6977c4ccbbd65c5bac9bf9c8c5950cb1"},"provenance":null,"requires-python":null,"size":264780,"upload-time":"2014-02-06T16:46:19.079623Z","url":"https://files.pythonhosted.org/packages/a9/1e/8ad399f44f63de6de262fc503b1d3f091f6a9b22feaf3c273ee8bb7a7c38/psutil-0.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py3.3.exe","hashes":{"sha256":"60048c47698aa20936b7593636dd88454bae6c436852aef95fb9774b0551d06c"},"provenance":null,"requires-python":null,"size":259950,"upload-time":"2014-02-06T16:46:28.163437Z","url":"https://files.pythonhosted.org/packages/75/f3/296f43c033c0453ebfdf125dc9b8907193e31ffb92256e4b702d16ef8ac1/psutil-0.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.2.1.win32-py3.4.exe","hashes":{"sha256":"4aad401c1a45848107d395f97fc9cdb783acf120553ca1761dd77a7d52adb585"},"provenance":null,"requires-python":null,"size":259910,"upload-time":"2014-02-06T16:46:37.546918Z","url":"https://files.pythonhosted.org/packages/ae/8c/751f1e2fdcaa0ea817a8529468dca052b5de55033ee8539b996497b5be0e/psutil-0.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.tar.gz","hashes":{"sha256":"d70e16e60a575637f9d75a1005a8987d239700c0955134d4c8666a5aefbe16b8"},"provenance":null,"requires-python":null,"size":153990,"upload-time":"2014-02-06T02:06:31.022178Z","url":"https://files.pythonhosted.org/packages/f2/5c/4e74b08905dab9474a53534507e463fe8eec98b2fc0d29964b0c6a7f959d/psutil-0.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"a554abcd10534ff32e3cbc4bd80b3c76a73d0bbb50739ee59482f0151703828b"},"provenance":null,"requires-python":null,"size":297305,"upload-time":"2014-02-06T16:45:05.336122Z","url":"https://files.pythonhosted.org/packages/78/91/21944fbddafa1bdf7c0c0ed7d9f4043cd8470e36a1f7a9f6e8b4406a8e39/psutil-0.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"b33444731c63361ac316657bb305642e562097e870793bc57203cd9a4e4819a4"},"provenance":null,"requires-python":null,"size":296059,"upload-time":"2014-02-06T16:45:13.056233Z","url":"https://files.pythonhosted.org/packages/88/bd/5e9d566e941e165987b8c9bd61583c58242ef4da12b7d9fbb07494580aff/psutil-0.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"89419f0cab4dd3ef4b32933237e34f58799069930fd25ed7f69deb9c64106c85"},"provenance":null,"requires-python":null,"size":296960,"upload-time":"2014-02-06T16:45:22.608830Z","url":"https://files.pythonhosted.org/packages/1f/06/c827177a80996d00f8f46ec99292e9d03fdf230a6e4fcea25ed9d19f3dcf/psutil-0.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.5.exe","hashes":{"sha256":"515b12e23581730c47e181fa163b457b90b6e848de0637d78b7fa8ca84ec2bc6"},"provenance":null,"requires-python":null,"size":135440,"upload-time":"2014-02-06T16:44:20.300778Z","url":"https://files.pythonhosted.org/packages/e5/55/6a353c646e6d15ee618348ed68cf79800f1275ade127f665779b6be0ed19/psutil-0.3.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.6.exe","hashes":{"sha256":"5bc91423ff25ad8dffb3c9979abdafb1ecd2e9a7ef4b9287bb731e76ea2c4b91"},"provenance":null,"requires-python":null,"size":267782,"upload-time":"2014-02-06T16:44:30.319267Z","url":"https://files.pythonhosted.org/packages/61/04/c447b4d468402bfb10d21995b0eae219c8397c00d9e8a2b209fb032ac1aa/psutil-0.3.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py2.7.exe","hashes":{"sha256":"4b7fbaca98b72f69561d593ef18b5254a8f98482b561db3d906aac4dd307bbcc"},"provenance":null,"requires-python":null,"size":267308,"upload-time":"2014-02-06T16:44:39.895580Z","url":"https://files.pythonhosted.org/packages/e4/2f/b060e631686e6455ff483ea5b6333382c6dddb5727edbfc9dcca1a8f024c/psutil-0.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py3.3.exe","hashes":{"sha256":"005217c21551618085e3323d653d75f9ad8f7418bff4fd5109850fba11950d6e"},"provenance":null,"requires-python":null,"size":262514,"upload-time":"2014-02-06T16:44:47.866655Z","url":"https://files.pythonhosted.org/packages/50/34/7bfc452cb2cd0069a81064db51b484ef135125cf1d246d0ff82c65653c81/psutil-0.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.3.0.win32-py3.4.exe","hashes":{"sha256":"331ac97b50def25e41bae637642d0131d5c4223b52ab55281d002549632ed5e0"},"provenance":null,"requires-python":null,"size":262479,"upload-time":"2014-02-06T16:44:56.381135Z","url":"https://files.pythonhosted.org/packages/b0/08/1944d2281986237cdaeabfa36195f44dc4c847d5c4fda3523b44c6823e19/psutil-0.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.tar.gz","hashes":{"sha256":"4b0ecc77d6c503449af3d2f0a41ad4cb8338e173f5d655a8239e41b1a49bc278"},"provenance":null,"requires-python":null,"size":167796,"upload-time":"2014-02-06T02:06:24.041544Z","url":"https://files.pythonhosted.org/packages/88/46/a933ab20c6d9b0ca5704b60307b9e80bdc119b759e89b74a2609b4c10eb6/psutil-0.4.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py2.7.exe","hashes":{"sha256":"9689512e5a32508216bd6cc7cb2fbe938e4a47b483cd345b5bec6dda790a9210"},"provenance":null,"requires-python":null,"size":302844,"upload-time":"2014-02-06T16:43:18.853340Z","url":"https://files.pythonhosted.org/packages/a5/06/3ca1c85b733ceaced144cb211c1fc40a6b3b1c4f7a109bbb8e19fe09eac0/psutil-0.4.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py3.3.exe","hashes":{"sha256":"9ee193dec84c2c91ac8712760eaaae0488dee92db37134dfcddc889ecd4f578d"},"provenance":null,"requires-python":null,"size":301654,"upload-time":"2014-02-06T16:43:28.863005Z","url":"https://files.pythonhosted.org/packages/ac/eb/f6923ea1b46803251f2bb42ad9b8ed90f4b8d04cdb2384c9ea535193e4f7/psutil-0.4.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win-amd64-py3.4.exe","hashes":{"sha256":"94d2d0a24fa62f5655e9e21dd558592bf1d3d515d944eee70e9cd2e2bf2bf244"},"provenance":null,"requires-python":null,"size":302558,"upload-time":"2014-02-06T16:43:38.802980Z","url":"https://files.pythonhosted.org/packages/7c/5b/d9057a158b09c377eab80dae60928f8fe29bdd11635ca725098587981eeb/psutil-0.4.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.5.exe","hashes":{"sha256":"fab822fb8968b45695174a2c9b4d40e9ae81126343e24d38b627036579f1ee5e"},"provenance":null,"requires-python":null,"size":140768,"upload-time":"2014-02-06T16:42:35.663297Z","url":"https://files.pythonhosted.org/packages/07/1e/7827d1271248ddef694681747297aeb3f77dafe5c93ff707a625e3947082/psutil-0.4.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.6.exe","hashes":{"sha256":"ca511f56db8f1586612851a2eedbf80e38cf29f4a98f133410a74da284822747"},"provenance":null,"requires-python":null,"size":273280,"upload-time":"2014-02-06T16:42:44.697290Z","url":"https://files.pythonhosted.org/packages/b4/56/78f182bf9c81a978067ba5447eca2ea70ef2bc9ac94228adfae5428cd108/psutil-0.4.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py2.7.exe","hashes":{"sha256":"5b6cbf5aaeab55db1d9657fc75e4b54fa94d17d03ca97c94aa150e1bfdc8fb2e"},"provenance":null,"requires-python":null,"size":272807,"upload-time":"2014-02-06T16:42:52.281617Z","url":"https://files.pythonhosted.org/packages/7d/38/b719c8867699a71a98e92e61fd1b0f12bad997a9de60bf8f6215184692e8/psutil-0.4.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py3.3.exe","hashes":{"sha256":"dfe18b8eb9ee6dbbd49e28f245794c2fc22b56d770038668cb6e112935c49927"},"provenance":null,"requires-python":null,"size":268022,"upload-time":"2014-02-06T16:43:01.185161Z","url":"https://files.pythonhosted.org/packages/f4/2b/13be095a72c83fdbe11d519310cb34ff8e442d72ab52691218a83c216ac4/psutil-0.4.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.0.win32-py3.4.exe","hashes":{"sha256":"5b63e0e83dde30d62206497320c06b27c489ffb261e95ac1267b7a1b8d4ce72d"},"provenance":null,"requires-python":null,"size":267989,"upload-time":"2014-02-06T16:43:09.528893Z","url":"https://files.pythonhosted.org/packages/b4/8e/028b849600447c45c20582d7ddae1e39d31b83799289f54f1b79af664295/psutil-0.4.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.tar.gz","hashes":{"sha256":"33002c38f916835c949ae39a84f3f6d09ce01818ed805dfd61f8f3844c395c9d"},"provenance":null,"requires-python":null,"size":171549,"upload-time":"2014-02-06T02:06:17.394021Z","url":"https://files.pythonhosted.org/packages/a0/cd/00550e16a2a0357a9c24946160e60fc947bbe23bc276aff1b4d3e7b90345/psutil-0.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"3e408028898b4ad09c207659c1b6cb8e6a74fb39ab3157b761e057a629118fec"},"provenance":null,"requires-python":null,"size":310414,"upload-time":"2014-02-06T16:41:41.640755Z","url":"https://files.pythonhosted.org/packages/06/75/3dc33773b1a1f7055b24245a0c8bec4d5776f1e1125329a13e82449007be/psutil-0.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"457cfdecbf63f813bf86e2f736ab3b20447e8d8c2c516dd2a13a7463177f8bc6"},"provenance":null,"requires-python":null,"size":309169,"upload-time":"2014-02-06T16:41:50.926907Z","url":"https://files.pythonhosted.org/packages/6e/9e/6c7f5baf2529d9bba563cdff0b81413b5870b0681739318112adecd99ad0/psutil-0.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"fc75e094cf573a7b9977be2a9d3a9d94671bc0ab098d52c391dd63227309cbea"},"provenance":null,"requires-python":null,"size":310087,"upload-time":"2014-02-06T16:42:00.068444Z","url":"https://files.pythonhosted.org/packages/cd/e6/9f963b32ab254b8c2bbedf5ce543cace8b08054924fd26fa233f99863ecc/psutil-0.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.5.exe","hashes":{"sha256":"ef4ed886b4d2d664fab5c369543690cda04e04a3b7496d72e369ef5240a8af6b"},"provenance":null,"requires-python":null,"size":148474,"upload-time":"2014-02-06T16:40:57.772154Z","url":"https://files.pythonhosted.org/packages/65/ad/e7828797558dd5f209694b02ce079cd3b6beacf6a5175f38c1973c688494/psutil-0.4.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.6.exe","hashes":{"sha256":"aafe9e328ffc173b26c78897c168858da335c85d4a02d666ad68fe2fe14601d1"},"provenance":null,"requires-python":null,"size":280897,"upload-time":"2014-02-06T16:41:07.265101Z","url":"https://files.pythonhosted.org/packages/1e/a1/594bf54e7c4056bc5284023be97f67c930175b3329e086a4ed8966cb067a/psutil-0.4.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py2.7.exe","hashes":{"sha256":"cefad502010c78425190498efc54541ae7bbe9eaa73ef4000cf11b032d32a8bb"},"provenance":null,"requires-python":null,"size":280445,"upload-time":"2014-02-06T16:41:15.492817Z","url":"https://files.pythonhosted.org/packages/c6/c4/14807de009a1beab2426b537379a8b05b1d69fef1fde7e23581cc332cdb3/psutil-0.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py3.3.exe","hashes":{"sha256":"a35ce124b2dec01d7632627c9370f5202978fce89ae59235cf4d5e05bbd0e02b"},"provenance":null,"requires-python":null,"size":275668,"upload-time":"2014-02-06T16:41:23.498162Z","url":"https://files.pythonhosted.org/packages/38/7d/407f7586bccdeb80f5da82d8ebb98712bfcc7217e3d7c3fc61b3bba893f2/psutil-0.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.4.1.win32-py3.4.exe","hashes":{"sha256":"860a039b67ee015a6304e8d05e6dc5c2a447eca331b7d6c9d04f41d7f2fc3a66"},"provenance":null,"requires-python":null,"size":275635,"upload-time":"2014-02-06T16:41:33.515203Z","url":"https://files.pythonhosted.org/packages/c5/b7/d2662ebf114961766c9eb3d9b737cb5541060d35e65b542b0acef470221a/psutil-0.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.tar.gz","hashes":{"sha256":"b10d1c19b9d334bea9f025f3b82b5664d642d26ba32ae0e71e7e20c5a6b4164f"},"provenance":null,"requires-python":null,"size":118411,"upload-time":"2014-02-06T02:06:09.471218Z","url":"https://files.pythonhosted.org/packages/3f/eb/e4115c3ecc189fd345b9a50d521e2ff76990bfb12a91921e93ea6398feef/psutil-0.5.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py2.7.exe","hashes":{"sha256":"5bf7a91fd57be3a63c6b9fa78da63c185b9be909ca49032f3ceda662628be74d"},"provenance":null,"requires-python":null,"size":319335,"upload-time":"2014-02-06T15:53:45.976879Z","url":"https://files.pythonhosted.org/packages/c5/cc/9bb29fdd60e347617c3a09f51a595941ddb4777fc1608068d174ced5bfdd/psutil-0.5.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py3.3.exe","hashes":{"sha256":"0cd9872d0d675b0314d2d15513e8ff3693a417e4ebaa158fc1f8780cc611574c"},"provenance":null,"requires-python":null,"size":317930,"upload-time":"2014-02-06T15:53:57.230392Z","url":"https://files.pythonhosted.org/packages/37/d8/276629523e0477639b33a606f93c2fc2e9c4cafba76b3a4cd1ddc42dd307/psutil-0.5.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win-amd64-py3.4.exe","hashes":{"sha256":"13f71acf1d2fe08db072d890280e985e8414080bcd525c13c66e0e8fbc917710"},"provenance":null,"requires-python":null,"size":318790,"upload-time":"2014-02-06T15:54:08.039630Z","url":"https://files.pythonhosted.org/packages/5f/bc/a026bbb10a4df4cf458b5d6feabc72a0017e6a4f472898280442ff3f9393/psutil-0.5.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.5.exe","hashes":{"sha256":"d6839532038b97792d90341465430520e58ea3d0956a1df710b3fdd733dde587"},"provenance":null,"requires-python":null,"size":156923,"upload-time":"2014-02-06T16:39:37.158716Z","url":"https://files.pythonhosted.org/packages/26/83/d1aed38bad84576e48b9ca6501edcf829ca3b48631c823736c36fa2b24de/psutil-0.5.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.6.exe","hashes":{"sha256":"be79349ecf091470ea4920e45b78914b67f17bec9c23e4bea4ec0ca5fee1feab"},"provenance":null,"requires-python":null,"size":289457,"upload-time":"2014-02-06T15:53:07.782148Z","url":"https://files.pythonhosted.org/packages/4e/b2/bfdeae58283e0fb09e2c6725c01b9429acbd15917c7ead91c96f2df37d05/psutil-0.5.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py2.7.exe","hashes":{"sha256":"e4fa8e965eb58a885e65a360f1a7ffc7ed476e9227a2de3726091d7560c694a8"},"provenance":null,"requires-python":null,"size":289002,"upload-time":"2014-02-06T15:53:16.212429Z","url":"https://files.pythonhosted.org/packages/2d/62/ed3c23fb8648a916460e95306d58f5ba42b3b20c68f2a55d1fc6396190a5/psutil-0.5.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py3.3.exe","hashes":{"sha256":"0380ece3eeb6f170ba156c58eab2fa36508600b1c7e10bc9b7c651f721236f38"},"provenance":null,"requires-python":null,"size":284089,"upload-time":"2014-02-06T15:53:25.963338Z","url":"https://files.pythonhosted.org/packages/59/3d/25912eb67f01af306d8ec035041c07daa7f783aafa5f4e1dd90de91c4849/psutil-0.5.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.0.win32-py3.4.exe","hashes":{"sha256":"d6a9e67de81fc0fc58c790e1355ddfbb8a0760963868a538f217ac2325a81581"},"provenance":null,"requires-python":null,"size":284045,"upload-time":"2014-02-06T15:53:35.675392Z","url":"https://files.pythonhosted.org/packages/38/74/e6c5bfb482f011d19bb1366cecf7d4f0b5c9c9b7664ef31e951cc4d0757b/psutil-0.5.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.tar.gz","hashes":{"sha256":"f660d244a08373f5e89633650970819a59463b37af1c9d205699fb0d0608986d"},"provenance":null,"requires-python":null,"size":118781,"upload-time":"2014-02-06T02:06:02.078066Z","url":"https://files.pythonhosted.org/packages/aa/06/6ebc13a14c0961d7bb8184da530448d8fc198465eb5ecd1ad36c761807d2/psutil-0.5.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py2.7.exe","hashes":{"sha256":"eff5ed677b6bdb5d75f1de925df774d8029582eea17abc3bbd31b9885d3c649d"},"provenance":null,"requires-python":null,"size":319512,"upload-time":"2014-02-06T16:36:10.664265Z","url":"https://files.pythonhosted.org/packages/8a/26/15751b500afdd0aea141905d5ba5319c38be41e0ca55a374c02827d1a79c/psutil-0.5.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py3.3.exe","hashes":{"sha256":"8a12d8e368bfccfe2074616cae2472dfb1e136a2aaaea5b7dbafdb390166b202"},"provenance":null,"requires-python":null,"size":318245,"upload-time":"2014-02-06T16:36:21.268821Z","url":"https://files.pythonhosted.org/packages/13/9d/49f6fb5e1f75b3d6815bbdbbeb1630f7299d6ff96f85836dbd27989780ae/psutil-0.5.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win-amd64-py3.4.exe","hashes":{"sha256":"9d991aae6b993ac58b540f27b2dff71137db62253f5d7acc5ede1ec845fd6b0b"},"provenance":null,"requires-python":null,"size":319083,"upload-time":"2014-02-06T16:36:31.287414Z","url":"https://files.pythonhosted.org/packages/2c/fa/a0469c75acedccc5006b655434e96a8a6a490725a9ae8208faaf39c043f6/psutil-0.5.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.5.exe","hashes":{"sha256":"ee32be6667bb69ebefc2fb5e23d115d98e307b5246c01ef50e45cfd8ad824d07"},"provenance":null,"requires-python":null,"size":157149,"upload-time":"2014-02-06T16:35:24.026975Z","url":"https://files.pythonhosted.org/packages/2e/30/9ed6283c7f1a716a3bf76a063b278ace2f89d1a8b2af9d35080dc2a0319b/psutil-0.5.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.6.exe","hashes":{"sha256":"f434f546d73366bff6283db907105b2607976ff9be67f2b5a7b35533e5f27219"},"provenance":null,"requires-python":null,"size":289555,"upload-time":"2014-02-06T16:35:32.000842Z","url":"https://files.pythonhosted.org/packages/eb/d9/55f5d02e42dc6c73f66c7cfc99bc3bf97cf10e9f259dbea69e123e0ef459/psutil-0.5.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py2.7.exe","hashes":{"sha256":"45acf090d65f2f47f3b1444b056cafb1b1ca70a8e266ddf10422734fb0ada897"},"provenance":null,"requires-python":null,"size":289095,"upload-time":"2014-02-06T16:35:40.182115Z","url":"https://files.pythonhosted.org/packages/81/25/cbbb80d1957c28dffb9f20c1eaf349d5642215d7ca15ec5b7015b6a510c8/psutil-0.5.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py3.3.exe","hashes":{"sha256":"9a20a99b6727334c8cc3a10ecc556d2f15a1e92efef97670ed022b86e09df36b"},"provenance":null,"requires-python":null,"size":284290,"upload-time":"2014-02-06T16:35:50.441013Z","url":"https://files.pythonhosted.org/packages/73/a2/ab4f2fa7ba6f8fc51d9cc9a0bb5ec269860a34574d391e39d20c2dca7b56/psutil-0.5.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.5.1.win32-py3.4.exe","hashes":{"sha256":"d547e164013a4d78909cbac0c176d65aa51c06de2fb888c63b738906f5ccc105"},"provenance":null,"requires-python":null,"size":284247,"upload-time":"2014-02-06T16:36:00.155604Z","url":"https://files.pythonhosted.org/packages/7f/8b/c9abd21cdc79b70744e169b98be06f0828687dfcac6468ed87455099f88d/psutil-0.5.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.tar.gz","hashes":{"sha256":"e918763243371f69bc98b601769df7337e196029dcdb797224f0ede474e17b94"},"provenance":null,"requires-python":null,"size":130803,"upload-time":"2014-02-06T02:05:55.032752Z","url":"https://files.pythonhosted.org/packages/3c/9f/0de622fc62e74f4c154656440c02c8a24a01a997d605a744272eb0d93742/psutil-0.6.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py2.7.exe","hashes":{"sha256":"1792be8fca4b3f88553e1c5cc197e18932c3da9b969ce7f545b741913597d600"},"provenance":null,"requires-python":null,"size":322153,"upload-time":"2014-02-06T16:34:24.006415Z","url":"https://files.pythonhosted.org/packages/5f/fd/fc06aaf69ad438d1354312c728791a1f571b2c59a49b411128911abf647e/psutil-0.6.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py3.3.exe","hashes":{"sha256":"084a1cbeca8e10f0cbba4b9d3f7d3136cb1d03997a868eea334401f82105207a"},"provenance":null,"requires-python":null,"size":320646,"upload-time":"2014-02-06T16:34:33.535927Z","url":"https://files.pythonhosted.org/packages/70/5e/b1d4a1d5238497d48112bc27e3448d05a0acb6c8fcd537565724d916e7c2/psutil-0.6.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win-amd64-py3.4.exe","hashes":{"sha256":"e7233e45ed7505efe46309978edd3e8a1cb4160400c3535512be2e4114615bb9"},"provenance":null,"requires-python":null,"size":321547,"upload-time":"2014-02-06T16:34:44.543150Z","url":"https://files.pythonhosted.org/packages/47/ad/4139c3eaa2ee1da71d071c9b49e8a04ff23f2c71f6fdecc11850b0e7343e/psutil-0.6.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.5.exe","hashes":{"sha256":"469628dea02a7d91837e05777cb66bfcdc2e1639cc8607ed93f19679c4e42cef"},"provenance":null,"requires-python":null,"size":160485,"upload-time":"2014-02-06T16:33:39.286987Z","url":"https://files.pythonhosted.org/packages/10/3a/a0136c299b74224be3b0735812a1544e6962d7c61af41adfcc400791c684/psutil-0.6.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.6.exe","hashes":{"sha256":"a628ad11fefc16d6dd144a8d29a03ac379debcf6c2e4b576e6ee2b2677c15836"},"provenance":null,"requires-python":null,"size":292261,"upload-time":"2014-02-06T16:33:47.696744Z","url":"https://files.pythonhosted.org/packages/2b/79/eec1c63d3ea968cc9754871a1b9d17d50bfc24136ecac415f701b1d240ea/psutil-0.6.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py2.7.exe","hashes":{"sha256":"71197523bf8acb49e3e909ea945cc6e77a21693428db2f169e33348988c1bb11"},"provenance":null,"requires-python":null,"size":291811,"upload-time":"2014-02-06T16:33:56.338977Z","url":"https://files.pythonhosted.org/packages/e9/64/fe90d0f1ba2dff8ad2511423720aed3569cfe7b5dbb95ede64af25b77e84/psutil-0.6.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py3.3.exe","hashes":{"sha256":"1d7df98f4532e76685fabbd82e9502c91be9a60e4dfdfd5a19c2152936b7d198"},"provenance":null,"requires-python":null,"size":286963,"upload-time":"2014-02-06T16:34:04.390605Z","url":"https://files.pythonhosted.org/packages/d6/d7/91226f8635d3850917b64e94ca4903910a60739ee7c930ef9678d93638eb/psutil-0.6.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.0.win32-py3.4.exe","hashes":{"sha256":"da568edc3b8ec4be5b8cee54851289eb4c24cbaa8ea165858e9bfc279269bf22"},"provenance":null,"requires-python":null,"size":286905,"upload-time":"2014-02-06T16:34:14.322283Z","url":"https://files.pythonhosted.org/packages/56/67/533833832596e5f8c1fb51d3f94cd110d688579be7af46996cf96ad890e7/psutil-0.6.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.tar.gz","hashes":{"sha256":"52eba795281cdd1079f13ded6a851f6d029551ddf552eadc9a2ee3eb26fe994d"},"provenance":null,"requires-python":null,"size":131473,"upload-time":"2014-02-06T02:05:47.971617Z","url":"https://files.pythonhosted.org/packages/4f/e6/989cb0b2f7f0ebe3ab0e7144b78db17387810f1526e98498be96fb755fa9/psutil-0.6.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py2.7.exe","hashes":{"sha256":"566bcec389a77279e10335eb5d0021eb968445720496b70b46d208dbbf8e49a1"},"provenance":null,"requires-python":null,"size":322415,"upload-time":"2014-02-06T16:32:41.593785Z","url":"https://files.pythonhosted.org/packages/9a/bb/cb19a41fa75a2205ac2d337be45183f879aa77e60bbb19387c872c81d451/psutil-0.6.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py3.3.exe","hashes":{"sha256":"fde5e57f9b51057998cce5a030ad481f826832b26cc2a6490d60317c9024724c"},"provenance":null,"requires-python":null,"size":320911,"upload-time":"2014-02-06T16:32:50.930654Z","url":"https://files.pythonhosted.org/packages/7d/d1/9e75848da16a5d165e3918540418f3052e6409357bcce91a7342b22d674f/psutil-0.6.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win-amd64-py3.4.exe","hashes":{"sha256":"402475d1a93306ac025070da9628a0ca0e0d253b0755bf13131318a39aaeea8e"},"provenance":null,"requires-python":null,"size":321810,"upload-time":"2014-02-06T16:33:01.995635Z","url":"https://files.pythonhosted.org/packages/95/82/1f52f8aaa37e07da54da4468c031f59717d3f40cd82b6faaf8f203d84bd7/psutil-0.6.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.5.exe","hashes":{"sha256":"3f5b8afde564c563cd6fa28ac14ed020d91d654ef1efd6c0e1672282fcde8e65"},"provenance":null,"requires-python":null,"size":160754,"upload-time":"2014-02-06T16:31:55.533884Z","url":"https://files.pythonhosted.org/packages/5b/3f/10449a8a3dfb809fbeae3d853453aafb36376d51f33c46e02b5f0723c620/psutil-0.6.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.6.exe","hashes":{"sha256":"1c1763ff214042e7be75fd6eb336322a47193342cddfc70b8547f086968e024c"},"provenance":null,"requires-python":null,"size":292530,"upload-time":"2014-02-06T16:32:04.859349Z","url":"https://files.pythonhosted.org/packages/3e/7a/5d53c99ec66ea86548d95acaf98b32f1cbb761cf2e1fc8ee62d0838f8e24/psutil-0.6.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py2.7.exe","hashes":{"sha256":"e411f2374994663ad35bc21afe4ff9003e3675e23b07a2a60b57c760da0c5f3f"},"provenance":null,"requires-python":null,"size":292082,"upload-time":"2014-02-06T16:32:13.267526Z","url":"https://files.pythonhosted.org/packages/4a/40/e43e412c55f66b57aee3a418f47b05e7bb92db83df93c0c93b00f11f1357/psutil-0.6.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py3.3.exe","hashes":{"sha256":"03ea1f851920d6ddc286c1940ebd167ed92c1cb7a870f1789510c21c6fa6b7bc"},"provenance":null,"requires-python":null,"size":287227,"upload-time":"2014-02-06T16:32:22.314264Z","url":"https://files.pythonhosted.org/packages/07/12/1ce6196592e01965a375b307a57f68e90488a49a56a647f17ba027382448/psutil-0.6.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.6.1.win32-py3.4.exe","hashes":{"sha256":"095107d63b176fed2f4a44de3a4d19e8aa6291de0c3ee5e398272c9b72bf2254"},"provenance":null,"requires-python":null,"size":287169,"upload-time":"2014-02-06T16:32:32.819904Z","url":"https://files.pythonhosted.org/packages/f4/88/d20f7eefa6b8cc59f9320c52bf561ba52baea2b9b36568b198bca0b3548d/psutil-0.6.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.tar.gz","hashes":{"sha256":"95089802017ee629b84332deeb367f7f775b42e827ee283d46b7e99d05120d71"},"provenance":null,"requires-python":null,"size":138681,"upload-time":"2014-02-06T02:05:40.485455Z","url":"https://files.pythonhosted.org/packages/0b/8c/aeb6acf5a4610f8d5bb29ade04081d8672c2294c3cefa1f0422c6398bc66/psutil-0.7.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py2.7.exe","hashes":{"sha256":"add60c89c13443617c83116fab34a3c6e4f32ee8b102ff6ffb4cd20ef6f511c3"},"provenance":null,"requires-python":null,"size":325666,"upload-time":"2014-02-06T16:30:51.588803Z","url":"https://files.pythonhosted.org/packages/38/8e/f3023be1a2268b5ee3a20e05ec8997a95c987f6f2b7dadad837674d562e8/psutil-0.7.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py3.3.exe","hashes":{"sha256":"520a43be7fcd21d63c02039cdd7ebfe959b9fa9a865ba9aab6b0194a85184250"},"provenance":null,"requires-python":null,"size":324143,"upload-time":"2014-02-06T16:31:01.226228Z","url":"https://files.pythonhosted.org/packages/7b/03/d6bff7ff8570f3521a1d7949f03741210f11ba5ba807789d37e185a0a780/psutil-0.7.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win-amd64-py3.4.exe","hashes":{"sha256":"0e78c6b441e659d922c5fddd5d5a36a368a61192873a0600ba23171c14dc2a6d"},"provenance":null,"requires-python":null,"size":325001,"upload-time":"2014-02-06T16:31:12.826305Z","url":"https://files.pythonhosted.org/packages/ce/8a/95e7c8b343a92137d82e4635fcb3f5c69c29e2a84ce4d51f2d5d86020b1e/psutil-0.7.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.5.exe","hashes":{"sha256":"532b918d8d2df60c20c69c1f764b9b16373ea22c32595fe801e3cc9b1aa5adfb"},"provenance":null,"requires-python":null,"size":163763,"upload-time":"2014-02-06T16:30:02.815062Z","url":"https://files.pythonhosted.org/packages/9e/6f/a946eeb3c6b8848fcf6d21c52884e2639e7d4393b51f330d4555ec177e83/psutil-0.7.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.6.exe","hashes":{"sha256":"21e1d7880579ef7eea28547c737923eaeee53389d51fa971d9f70bf89e9759ee"},"provenance":null,"requires-python":null,"size":295425,"upload-time":"2014-02-06T16:30:11.405843Z","url":"https://files.pythonhosted.org/packages/14/e9/ac4865772c55a3c09c85d987ac2a0e679c31e897d536f389485019c29450/psutil-0.7.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py2.7.exe","hashes":{"sha256":"bc36a7350b89e2ada06691583f4c4c2f99988fe6fa710d4f8e4143bed9f9f8bf"},"provenance":null,"requires-python":null,"size":294933,"upload-time":"2014-02-06T16:30:20.866887Z","url":"https://files.pythonhosted.org/packages/12/1c/053e0d5485a39c055e92b845b6311ab54887a091836a3985369cfffa9e53/psutil-0.7.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py3.3.exe","hashes":{"sha256":"9ce0d7a8cedde996eaae1eda3db9b473d441bd6c797b36a166d7b7a70dd4650e"},"provenance":null,"requires-python":null,"size":290006,"upload-time":"2014-02-06T16:30:29.860768Z","url":"https://files.pythonhosted.org/packages/73/19/8009828f3cfcf529570822e52988b95ac1c25c90ba4fb96ae570b5c25e66/psutil-0.7.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.0.win32-py3.4.exe","hashes":{"sha256":"6fdeca414a470d156ebdf1b6e4e9ca0fd9eb1b53e8d9a0cbb7d4a69d31f68bdc"},"provenance":null,"requires-python":null,"size":289986,"upload-time":"2014-02-06T16:30:39.817575Z","url":"https://files.pythonhosted.org/packages/42/7d/8e159acbf98eed98b778c244287b295f06411ac9e1903d2d358ba48b1d36/psutil-0.7.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.tar.gz","hashes":{"sha256":"5236f649318a06dcff8b86947c888d4510abce1783923aa5455b2d62df7204c7"},"provenance":null,"requires-python":null,"size":138525,"upload-time":"2014-02-06T02:05:32.811951Z","url":"https://files.pythonhosted.org/packages/8c/75/1eeb93df943b70c2e18bf412b32d18af3577da831f2bfe8c7d29f8853a67/psutil-0.7.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py2.7.exe","hashes":{"sha256":"47fc6887ec86bd7a422326dfc77e2b43fcbc71e498194f86088bb2268c2372b7"},"provenance":null,"requires-python":null,"size":325663,"upload-time":"2014-02-06T16:29:31.935519Z","url":"https://files.pythonhosted.org/packages/2d/ab/8fde8a7358a21bc2488a5d21a24879ce3cc162d2a99c56f9599c7d759c75/psutil-0.7.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py3.3.exe","hashes":{"sha256":"c00ec6a0e061e31687851c06d542500fd47b0ed415818e0da61c294f2796572b"},"provenance":null,"requires-python":null,"size":324140,"upload-time":"2014-02-06T16:29:41.403650Z","url":"https://files.pythonhosted.org/packages/35/b1/8506f2e78974da833b20b162d70b7e38ac3ab722adf18c03a3e428c9d9c4/psutil-0.7.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win-amd64-py3.4.exe","hashes":{"sha256":"a5238a16cd85d4f3240dfca8ad94cb0bfe8643acb5c21d839a53caa86d8a23ab"},"provenance":null,"requires-python":null,"size":324998,"upload-time":"2014-02-06T16:29:50.929853Z","url":"https://files.pythonhosted.org/packages/cc/29/d00e1011e6db097ffac31c2876fdba51fd1fc251ee472ad6219095739a86/psutil-0.7.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.5.exe","hashes":{"sha256":"facf21db78120afb79ec51685043a5f84e897a84a7678db4381c0e377a481364"},"provenance":null,"requires-python":null,"size":163764,"upload-time":"2014-02-06T16:28:44.337888Z","url":"https://files.pythonhosted.org/packages/06/d8/a34c090687fa4c09bee5b5a06a762eb1af134d847b907d3e63c58e5d2cba/psutil-0.7.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.6.exe","hashes":{"sha256":"709d2e851c161f1ffad6bd7ed925ee90229dbd2067fbc26126c11d473075d7b7"},"provenance":null,"requires-python":null,"size":295427,"upload-time":"2014-02-06T16:28:53.964081Z","url":"https://files.pythonhosted.org/packages/4d/8a/d51e550aa0928ab02e4f6b2531453b2e63c8877e30543e342c8a35c90d4d/psutil-0.7.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py2.7.exe","hashes":{"sha256":"ee218aa12ee3af563833cf0bf109b15382261a0760a1ce636bf9e26e630f833e"},"provenance":null,"requires-python":null,"size":294930,"upload-time":"2014-02-06T16:29:03.098211Z","url":"https://files.pythonhosted.org/packages/3c/4c/d46a8bc865e58b30dcb160772667abf42f854ec4910ee1100e79961035ce/psutil-0.7.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py3.3.exe","hashes":{"sha256":"fdf22a72f891a45b8a9ebca85b50a055a4ba7a8c05b98f93e1387b8ee88a4562"},"provenance":null,"requires-python":null,"size":290003,"upload-time":"2014-02-06T16:29:12.556491Z","url":"https://files.pythonhosted.org/packages/1a/cf/98fdaf08279cd754414ab6723bbb6bd55d890624b766d64b21c35379d865/psutil-0.7.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-0.7.1.win32-py3.4.exe","hashes":{"sha256":"f675a6346e5bd02469b043afff2db1b8e0b180e8a6d1ca94d44d23f26f60e68f"},"provenance":null,"requires-python":null,"size":289983,"upload-time":"2014-02-06T16:29:21.732021Z","url":"https://files.pythonhosted.org/packages/f4/f9/79ac18809795f53197fb5b6bd452d2b52f62e5bff6a66d9b813077a85eb9/psutil-0.7.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.tar.gz","hashes":{"sha256":"af776ebeaf2420709b1ab741f664c048dcfc2890e3e7d151ae868fbdc3d47920"},"provenance":null,"requires-python":null,"size":156516,"upload-time":"2014-02-06T02:05:25.754044Z","url":"https://files.pythonhosted.org/packages/ed/7e/dd4062bfbe9b735793a5e63a38d83ba37292c4ada3615fe54403c54e3260/psutil-1.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"7868ef2ecc1d847620d99b40f8105b6d5303784abbde34da2388b2c18e73a3d2"},"provenance":null,"requires-python":null,"size":327529,"upload-time":"2014-02-06T16:25:06.308578Z","url":"https://files.pythonhosted.org/packages/11/46/8a6581c14d644f747ea66a12c60ffebebd4f8a77af62192aeb20cc16ae17/psutil-1.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"cdced3409a241b9d357b82c72d00ece49602cdc3f694ed988a952761367df560"},"provenance":null,"requires-python":null,"size":326023,"upload-time":"2014-02-06T16:25:15.281576Z","url":"https://files.pythonhosted.org/packages/03/a4/aa6592e676f75705b77df8e319f6aa35cf08a662fb0cfaa34434d273d7c9/psutil-1.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"ef6974ac18407fb15430cd7b81aecc2f3666e75ca83fe3a66848c4c5c086e0a3"},"provenance":null,"requires-python":null,"size":326915,"upload-time":"2014-02-06T16:25:27.390929Z","url":"https://files.pythonhosted.org/packages/5b/c1/003f0071d1e2a4dfe12ac2d66ac14f5a5a93049544c11ac9c78d83d85318/psutil-1.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.5.exe","hashes":{"sha256":"d8213feaa4c560c61514cea4e6a7eec83f6df83694bb97b06d009e919f60c48f"},"provenance":null,"requires-python":null,"size":165576,"upload-time":"2014-02-06T16:24:22.454259Z","url":"https://files.pythonhosted.org/packages/d6/28/5753ba13863c26d8a8fef685690b539a4652f1c4929d13d482eb4d691d99/psutil-1.0.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.6.exe","hashes":{"sha256":"7571d74d351bba723b28666a13da43c07bb3568543be3f9f7404af2b8c1ecf3a"},"provenance":null,"requires-python":null,"size":297205,"upload-time":"2014-02-06T16:24:31.483662Z","url":"https://files.pythonhosted.org/packages/ad/8c/37599876ea078c7c2db10d746f0e0aa805abcacbab96d1cf5dfb0465c40b/psutil-1.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py2.7.exe","hashes":{"sha256":"3f311d4f060b83d7cd0068dbad867ad17e699d3c335e494dc31db5380154fdf4"},"provenance":null,"requires-python":null,"size":296787,"upload-time":"2014-02-06T16:24:39.921427Z","url":"https://files.pythonhosted.org/packages/99/4e/8c1f5db3e90dbdbde891c34fd2496805a93aa279433bac716098efad1b4c/psutil-1.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py3.3.exe","hashes":{"sha256":"acf6cbc2408869b2843d406a802b6895969a358c762b5ab3e6f5afdd0c918faf"},"provenance":null,"requires-python":null,"size":291856,"upload-time":"2014-02-06T16:24:48.963293Z","url":"https://files.pythonhosted.org/packages/5b/f7/0bad3fc8ff5f226fa933a847b5fb3355562421f0456348747cf18f7137f5/psutil-1.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.0.win32-py3.4.exe","hashes":{"sha256":"191c2e6953426c861d7e100d48a5b522307ffc3de7d9e7bc8509aa45fb3de60c"},"provenance":null,"requires-python":null,"size":291810,"upload-time":"2014-02-06T16:24:57.589702Z","url":"https://files.pythonhosted.org/packages/0a/50/18ebd254b6662c98a8310983fff6795c7ac303d25188fd727888ca1c5211/psutil-1.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.tar.gz","hashes":{"sha256":"ba4c81622434836f6645e8d04e221ca5b22a9bd508c29989407f116b917be5b3"},"provenance":null,"requires-python":null,"size":156516,"upload-time":"2014-02-06T02:05:16.665325Z","url":"https://files.pythonhosted.org/packages/94/50/7c9e94cf6cdbf4e4e41d2e318094c2b0d58d3bb9196017fb6e4897adf277/psutil-1.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"2d6705cf53a7474b992d0d5beac4697cdd37f2c24098d4e1b5bb35a83b70b27e"},"provenance":null,"requires-python":null,"size":327529,"upload-time":"2014-02-06T16:20:20.120751Z","url":"https://files.pythonhosted.org/packages/a9/28/ac3c9da11fbe1ae3ddefb2cb6b410c8ad701f39d86489931e87c871cc4d1/psutil-1.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"6194670fcbddec715846fa9beca4450b4419423b2d466894da2fa1915fc7b712"},"provenance":null,"requires-python":null,"size":326023,"upload-time":"2014-02-06T16:20:43.401705Z","url":"https://files.pythonhosted.org/packages/97/30/094bb08295e15e05a266fcb15c116912f643fbb4dd8090ec64aca801ea72/psutil-1.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"5cf4ddea8dd21b99b90656dafa2d28c32fa9c159ab30580782b65b3b615c62a7"},"provenance":null,"requires-python":null,"size":326915,"upload-time":"2014-02-06T16:20:52.673334Z","url":"https://files.pythonhosted.org/packages/e8/86/e72c22699491573508e85b226f1782eab840b713cd6b8d42655c5329324c/psutil-1.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.5.exe","hashes":{"sha256":"fadf7625c309bc5f6e6d3b9d42836491efabbfda1834db7166775d705db420bf"},"provenance":null,"requires-python":null,"size":165580,"upload-time":"2014-02-06T16:04:23.085098Z","url":"https://files.pythonhosted.org/packages/a5/40/d307abd2ee3015e38cbeeac18c6b0f091cdcac496688f4d2c286145fdc5f/psutil-1.0.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.6.exe","hashes":{"sha256":"84a257b4adea431473089ea4b798bea98ce64452587ba7b71856e150d88e9213"},"provenance":null,"requires-python":null,"size":297208,"upload-time":"2014-02-06T15:59:31.669293Z","url":"https://files.pythonhosted.org/packages/75/3f/c10ca801aff50ce6ea84f71ce69a32de1b4a1f0439ada94adeccd36e1afd/psutil-1.0.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py2.7.exe","hashes":{"sha256":"4b5047bb4055d48f718bbb5a457c9b1c1c06776ca6353cb310b471c38d51324d"},"provenance":null,"requires-python":null,"size":296787,"upload-time":"2014-02-06T15:59:41.621679Z","url":"https://files.pythonhosted.org/packages/15/6c/944089b8dd730314a8eec9faa4d7d383f31490130e9e0534c882173e2eb6/psutil-1.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py3.3.exe","hashes":{"sha256":"3553a27b4d0e7552d0d863c017e152a88cb689d2090b39e2bca68db7fc27e8b2"},"provenance":null,"requires-python":null,"size":291856,"upload-time":"2014-02-06T15:59:51.241604Z","url":"https://files.pythonhosted.org/packages/4c/51/eb8b12a0124050492faad7fe3e695cb44e4ec5495a64a8570abf6e7cddc3/psutil-1.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.0.1.win32-py3.4.exe","hashes":{"sha256":"d3ab1b882647d66099adefa8ff780c4144bf8df1bb97bc31c55cbd999807cae8"},"provenance":null,"requires-python":null,"size":291810,"upload-time":"2014-02-06T16:00:00.814707Z","url":"https://files.pythonhosted.org/packages/4d/2a/33063e4a674e3be38d77fbc6e5e988f0e0323cd000cb7eb60f9300493631/psutil-1.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.tar.gz","hashes":{"sha256":"31b4b411d3f6960d26dac1f075709ff6d36f60216bf1f2b47fc4dc62a2d0aa6f"},"provenance":null,"requires-python":null,"size":163785,"upload-time":"2013-09-28T09:48:01.746815Z","url":"https://files.pythonhosted.org/packages/f6/71/1f9049fc7936f7f48f0553abd8bf8394f4ad2d9fb63a881b3a653b67abd6/psutil-1.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"ef250fbe783c0b31d9574d06324abd78ebf23c75981a8d0f9319d080435aa056"},"provenance":null,"requires-python":null,"size":305459,"upload-time":"2013-09-28T09:55:10.368138Z","url":"https://files.pythonhosted.org/packages/28/ff/e0dcc8e0194817191817ff02926a734a51d24a91e1cfc5c47be8c1e8508c/psutil-1.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win-amd64-py3.2.exe","hashes":{"sha256":"a95bf68f2189b7cd3f22558b12a989f368335c905cbd3045ca315514538b3115"},"provenance":null,"requires-python":null,"size":306085,"upload-time":"2013-09-28T09:55:36.198407Z","url":"https://files.pythonhosted.org/packages/a5/be/6f3b8f8ff89eaf480f59bbcd3d18c10ee0206891aa5fb4a25280c031801c/psutil-1.1.0.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.4.exe","hashes":{"sha256":"bc53be7f65ccb8a530e0c496a8db3ecd78b57b1faa443e43e228df327cf26899"},"provenance":null,"requires-python":null,"size":142269,"upload-time":"2013-09-28T09:51:43.685077Z","url":"https://files.pythonhosted.org/packages/ec/60/0a9a96611c77866a2c4140159a57c2702523ebc5371eaa24e0353d88ac2c/psutil-1.1.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.5.exe","hashes":{"sha256":"4a587008d6aae91fd1d3fee21141a27b4a2978fff75c80e57a37678a63a1cfcc"},"provenance":null,"requires-python":null,"size":142249,"upload-time":"2013-09-28T09:52:12.373832Z","url":"https://files.pythonhosted.org/packages/b5/16/dd5a768773cb017c4a66d69ec49abdd33df831215418e4c116639ed41afb/psutil-1.1.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py2.6.exe","hashes":{"sha256":"be853a268f0f3c3336c9bb648253db85ef2024213b6fc199f84b89643b74b130"},"provenance":null,"requires-python":null,"size":276570,"upload-time":"2013-09-28T09:53:51.099422Z","url":"https://files.pythonhosted.org/packages/cc/e0/adb41ece0bb2c27d75a41d98bd8f9802475d5d488df7d4905229596c0a70/psutil-1.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py3.2.exe","hashes":{"sha256":"dfdce701cfc7799dc1964debb486907b447fbdb361e06be786a9a5e11a1d5309"},"provenance":null,"requires-python":null,"size":275628,"upload-time":"2013-09-28T09:54:16.430842Z","url":"https://files.pythonhosted.org/packages/8f/c9/231df338b0cef518dbde2f98c1e0bb81142dc7dbec4a39267bb60dde1462/psutil-1.1.0.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.0.win32-py3.3.exe","hashes":{"sha256":"b4106508ea96ad24e1102de2a31a99c557ee608abab15d978bfe8d0f626e518c"},"provenance":null,"requires-python":null,"size":270259,"upload-time":"2013-09-28T09:54:43.666687Z","url":"https://files.pythonhosted.org/packages/a7/03/80f426e186dfdb202128c78b421b3ba34de461c32f6ed2c04041fc548d7b/psutil-1.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.tar.gz","hashes":{"sha256":"a5201e4c2a9b57e9e5d8de92b3a4006d093eedd9b56915b8279f365aaedd0f48"},"provenance":null,"requires-python":null,"size":165467,"upload-time":"2013-10-07T22:38:06.357263Z","url":"https://files.pythonhosted.org/packages/8d/0d/1a4bfc94f9cc783a510b3fc7efd5a2ef39858b3a2b6ab40a094a1ca8a54d/psutil-1.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"b8ccaef0a96d7ef40eda7493ffcaa3c5e2d63f531e090c3567e4198b38ca8e33"},"provenance":null,"requires-python":null,"size":305937,"upload-time":"2013-10-07T22:43:47.570605Z","url":"https://files.pythonhosted.org/packages/5a/b8/66489689c8751acd67bdbc8f37534176a14b63f74e74a229c30b230c8a18/psutil-1.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win-amd64-py3.2.exe","hashes":{"sha256":"fdabf11b316b0c406709aabb76f6c3cfdeb448c10ed38193786110f13e5c1248"},"provenance":null,"requires-python":null,"size":306563,"upload-time":"2013-10-07T22:44:09.209012Z","url":"https://files.pythonhosted.org/packages/e3/2d/cd5c620f9e5cb090eea573b2dc16574e746529347b6133b2f0b6e686d917/psutil-1.1.1.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.4.exe","hashes":{"sha256":"74bb1ccf0b28a914bb9d303642c08450ea6c5876851eb71e17f24b3d8672ca7d"},"provenance":null,"requires-python":null,"size":142751,"upload-time":"2013-10-07T22:45:21.036212Z","url":"https://files.pythonhosted.org/packages/28/9a/b83f884add09296894a1223c9c404cb57155c1c4317d318abf8c170e07b5/psutil-1.1.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.5.exe","hashes":{"sha256":"8e52d5b6af64e3eefbda30e0b16c9f29434ef6f79ea10b6fbd4520a6fbdb2481"},"provenance":null,"requires-python":null,"size":142731,"upload-time":"2013-10-07T22:41:32.428090Z","url":"https://files.pythonhosted.org/packages/8b/80/c41382a4f650f47a37300411169b7b248acf0b0925eb92cb22286362c3df/psutil-1.1.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.6.exe","hashes":{"sha256":"1e3a17b2a2f2bc138774f9b4b5ff52767f65ffb6349f9e05eb24f243c550ce1b"},"provenance":null,"requires-python":null,"size":277048,"upload-time":"2013-10-07T22:41:54.149373Z","url":"https://files.pythonhosted.org/packages/16/cd/25a3b9af88d130dd1084acab467b30996884219afc0a1e989d2a015ea54b/psutil-1.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py2.7.exe","hashes":{"sha256":"2e7691ddbde94b1ec7bb5b4cd986b2f763efc6be5b122dd499e156c9802a195b"},"provenance":null,"requires-python":null,"size":276822,"upload-time":"2013-10-07T22:42:18.407145Z","url":"https://files.pythonhosted.org/packages/42/78/eeacb1210abbe15cf06b9810e84afeabae1f9362abe389e8d5ca2c19df43/psutil-1.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py3.2.exe","hashes":{"sha256":"01276bd695b5cebc7bea7c97814713b0f3030861e30be88a60d40c9daf3d529c"},"provenance":null,"requires-python":null,"size":276106,"upload-time":"2013-10-07T22:42:41.551135Z","url":"https://files.pythonhosted.org/packages/92/14/90b9a4690f04ef1aab89a97a7b5407708f56785ccc264d9f9ce372feaea4/psutil-1.1.1.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.1.win32-py3.3.exe","hashes":{"sha256":"86ce0cfa7a95c7c1bc3e2f5358e446b01fc2be5f0c879c8def21e7ede9dc77de"},"provenance":null,"requires-python":null,"size":270733,"upload-time":"2013-10-07T22:43:07.069809Z","url":"https://files.pythonhosted.org/packages/a7/64/ba4601de7df6130c27f42bcec9f11da4ea905eda26d2f5a41efdb481f377/psutil-1.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.tar.gz","hashes":{"sha256":"adeb1afcb46327bed6603aa8981dce863f052043a52f003e2742ec7c3739677a"},"provenance":null,"requires-python":null,"size":165709,"upload-time":"2013-10-22T18:13:09.038583Z","url":"https://files.pythonhosted.org/packages/e4/b1/34a4bd75027d08c8db4f6301d6562e333c8d9131dca08b7f76f05aeae00a/psutil-1.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"4c9e952a7faf50f11fb8bcd6c12c952b063664d9327957c9f6abd498e6ef3bc8"},"provenance":null,"requires-python":null,"size":306157,"upload-time":"2013-10-22T18:16:38.181306Z","url":"https://files.pythonhosted.org/packages/f9/df/437db01296118d668cf654f097ad2b1c341291ba5dc4b5eb80f0a0a40c52/psutil-1.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win-amd64-py3.2.exe","hashes":{"sha256":"6e8ed376b63b15b09a94eff7998dae1f8506bd174d795e509cc735f875fddabe"},"provenance":null,"requires-python":null,"size":306782,"upload-time":"2013-10-22T18:17:05.663884Z","url":"https://files.pythonhosted.org/packages/c9/d0/1e413f0258d02bf77bc1d94002d041b8853584369e4af039cd5cf89e3270/psutil-1.1.2.win-amd64-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.4.exe","hashes":{"sha256":"ecc5ab4537259db7254c6f6dc7b7cb5a7f398c322a01612c272a8222696334a8"},"provenance":null,"requires-python":null,"size":142969,"upload-time":"2013-10-22T18:13:39.868851Z","url":"https://files.pythonhosted.org/packages/a7/63/fd5770ec4fe87d30bd836989d314b85662c775a52dbd017747fc69fe8f0e/psutil-1.1.2.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.5.exe","hashes":{"sha256":"e05d83d6b53ea24333c8b04d329e28ff11ecad75945f371ff5ce7f785df36aee"},"provenance":null,"requires-python":null,"size":142950,"upload-time":"2013-10-22T18:14:00.511107Z","url":"https://files.pythonhosted.org/packages/8d/e1/22650079452725e44ec790c3e75282f4d341f359b213b2afc7f2ada46930/psutil-1.1.2.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.6.exe","hashes":{"sha256":"f06ee6e1508a12afcfed04a4022ded9f872e2a964a62bd86617ece943d89ab01"},"provenance":null,"requires-python":null,"size":277266,"upload-time":"2013-10-22T18:14:33.903116Z","url":"https://files.pythonhosted.org/packages/3e/a4/5177488368f230acd4708a117c0820fb16843521e2a7a492078a2335bb9f/psutil-1.1.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py2.7.exe","hashes":{"sha256":"6c5be5538202ed7419911178ded41c65e118104fa634109f528a6d2d3e50a7d0"},"provenance":null,"requires-python":null,"size":277039,"upload-time":"2013-10-22T18:14:56.072979Z","url":"https://files.pythonhosted.org/packages/5e/d6/56f2891f6dd56f950866cc39892e5a56e85331d97c39e2634cfc4014f0df/psutil-1.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py3.2.exe","hashes":{"sha256":"5cfa97b52fb48dbb8255c120b567be4f06802afa7d2fe71b8fe7c7c4ee53ad88"},"provenance":null,"requires-python":null,"size":276327,"upload-time":"2013-10-22T18:15:25.393310Z","url":"https://files.pythonhosted.org/packages/dd/be/1aea1e7a1a3fb44f4c8d887a1d55e960de283d86875f15457a284268e197/psutil-1.1.2.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.2.win32-py3.3.exe","hashes":{"sha256":"f7dc7507fb9d4edb42709b356eb2e4b3da356efa54d83900e4cef59f3adebfbf"},"provenance":null,"requires-python":null,"size":270952,"upload-time":"2013-10-22T18:15:51.874969Z","url":"https://files.pythonhosted.org/packages/f5/7c/1a33b78a66a96e740e197ae55719496ba57bb9cee32f710a5a6affa68cc8/psutil-1.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.tar.gz","hashes":{"sha256":"5e1164086a7ed3b863ebd12315d35086e22252b328401fce901a0862050ef98c"},"provenance":null,"requires-python":null,"size":165550,"upload-time":"2013-11-07T20:47:17.039714Z","url":"https://files.pythonhosted.org/packages/93/fa/1f70b7fcdff77348f4e79d84cc9b568596874ca34940ede78c63d503a095/psutil-1.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"43cbf089cbe160d193e1658fe4eec4a719430432e866334b25dc3acef73c3e61"},"provenance":null,"requires-python":null,"size":306145,"upload-time":"2013-11-07T21:05:00.986042Z","url":"https://files.pythonhosted.org/packages/03/ec/f05db404504d67a19397e17e64f0276cc610a9dc450eb51ed70436f37c43/psutil-1.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.4.exe","hashes":{"sha256":"ef7445e1b0449af34ff51a9e1d3f030b8794c9fcd2b99d072b2e815d00e8a783"},"provenance":null,"requires-python":null,"size":142958,"upload-time":"2013-11-07T21:16:11.539460Z","url":"https://files.pythonhosted.org/packages/37/c2/5d40dd0a36f0280c1dea0f651cfde79b5e99a0e6fab92273fa3ac41055f0/psutil-1.1.3.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.5.exe","hashes":{"sha256":"b7f4103b1058d2ee597f88902ff50f19421b95c18ac9b82ea9e8a00091786131"},"provenance":null,"requires-python":null,"size":142940,"upload-time":"2013-11-07T21:15:50.256574Z","url":"https://files.pythonhosted.org/packages/ee/cb/7d42052f4057c6233ba3f4b7afade92117f58c5d7544ee6ab16e82c515c7/psutil-1.1.3.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.6.exe","hashes":{"sha256":"e21b9c5a26ad3328b6f5b629e30944a9b7e56ea6ac0aa051455c8a352e67fbca"},"provenance":null,"requires-python":null,"size":277254,"upload-time":"2013-11-07T20:58:49.794773Z","url":"https://files.pythonhosted.org/packages/b2/7e/c42d752b333c5846d88a8b56bbab23325b247766c100dc6f68c6bc56019d/psutil-1.1.3.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py2.7.exe","hashes":{"sha256":"fc9732a4dea2a3f73f9320472aa54e1cfae45d324bea24bd207d88d3a0a281b0"},"provenance":null,"requires-python":null,"size":277028,"upload-time":"2013-11-07T21:16:56.712839Z","url":"https://files.pythonhosted.org/packages/2b/76/eec917b6f74ea9bd20a55dd8b4b01e69689278235335dbedc2b9be212815/psutil-1.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py3.2.exe","hashes":{"sha256":"a141d59c03a28bdd32dfce11a5d51b9a63a8e6c6c4245e416eeffcc1c43f1de9"},"provenance":null,"requires-python":null,"size":276315,"upload-time":"2013-11-07T21:02:04.504719Z","url":"https://files.pythonhosted.org/packages/3a/b9/748bbd0c53c74c682051137830048abd0126ae50e3bf4d5854a0188da143/psutil-1.1.3.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.1.3.win32-py3.3.exe","hashes":{"sha256":"36e855ea7c872beb04f22d968c55f1ef897df0261ea993ecf5ae6e8216939a55"},"provenance":null,"requires-python":null,"size":270942,"upload-time":"2013-11-07T21:04:24.025560Z","url":"https://files.pythonhosted.org/packages/e6/7b/655e08abdf19d06c8a3fd6fba35932867c80fcff05c97cf909b5d364603c/psutil-1.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.tar.gz","hashes":{"sha256":"c3a2b02e92363837499680760b674b3bf3bd03dd9528a5dc41392625a61b162a"},"provenance":null,"requires-python":null,"size":166747,"upload-time":"2013-11-20T20:02:56.854747Z","url":"https://files.pythonhosted.org/packages/77/89/8ee72ae2b5e3c749e43a9c1e95d61eceff022ab7c929cdde8a3b7539a707/psutil-1.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"2bedcda55618f71bc98d6669bd190e2b51b940e3a3af2512dd77745cb1ebc101"},"provenance":null,"requires-python":null,"size":307021,"upload-time":"2013-11-20T20:08:29.733072Z","url":"https://files.pythonhosted.org/packages/9c/d1/598bcaa9701e06561cb8823a7a04ee44e702b0e327ef0a65bdd97b019613/psutil-1.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.4.exe","hashes":{"sha256":"417695f66562a22ac4f92bf7df1e9dda6264579eb308badd2c3e85df88ab9436"},"provenance":null,"requires-python":null,"size":143831,"upload-time":"2013-11-20T20:18:44.725428Z","url":"https://files.pythonhosted.org/packages/a4/ba/4b54baace7b49b73df74b54815337878137d25fda506e518f2d8dd2472fc/psutil-1.2.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.5.exe","hashes":{"sha256":"40747c59cf92cef26d595a9cefaac9c1a4bc0290abff6004bb092ee2ddec7d7b"},"provenance":null,"requires-python":null,"size":143812,"upload-time":"2013-11-20T20:18:35.170091Z","url":"https://files.pythonhosted.org/packages/88/17/3ba1b45ec63d666c2631f16679adb819564feb775cfd9e774d23e5774a44/psutil-1.2.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.6.exe","hashes":{"sha256":"fb0c3942a48fde9c52828dae4074381556eff8eb5651bdc9c4c107b40dc8318e"},"provenance":null,"requires-python":null,"size":278130,"upload-time":"2013-11-20T20:07:34.211552Z","url":"https://files.pythonhosted.org/packages/ae/4a/e62000dbe462270c30f1e2f2dcc913596f70e264d9a656f881bb9f487283/psutil-1.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py2.7.exe","hashes":{"sha256":"1024eff34ff14f2899186549ca8f8e461403e5700910e52eb013ffffb078cda3"},"provenance":null,"requires-python":null,"size":277905,"upload-time":"2013-11-20T20:18:07.310116Z","url":"https://files.pythonhosted.org/packages/9d/1a/b8e679a7e47229d07e41439a43fc1be48c0d34774e5e35ad6730398485bd/psutil-1.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py3.2.exe","hashes":{"sha256":"2b588673530d67f45287c31b6dfef02ee4e753aee7e7216448e6dbcb95b482e1"},"provenance":null,"requires-python":null,"size":277189,"upload-time":"2013-11-20T20:05:01.902941Z","url":"https://files.pythonhosted.org/packages/05/10/20a2364e4e69206d66da106288b65bf5bbde0d648aad5bb829f3eb08fabb/psutil-1.2.0.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.0.win32-py3.3.exe","hashes":{"sha256":"3e23d3b1ef5f20a458092887d1df32f55eaf4fc86f2ed49cc68cf164537128d6"},"provenance":null,"requires-python":null,"size":271857,"upload-time":"2013-11-20T20:05:28.007235Z","url":"https://files.pythonhosted.org/packages/24/39/4630dff3d0fa4896db905a118877fce5b72ced6629ca9958e207f7a0b198/psutil-1.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.tar.gz","hashes":{"sha256":"508e4a44c8253a386a0f86d9c9bd4a1b4cbb2f94e88d49a19c1513653ca66c45"},"provenance":null,"requires-python":null,"size":167397,"upload-time":"2013-11-25T20:06:20.566209Z","url":"https://files.pythonhosted.org/packages/8a/45/3b9dbd7a58482018927f756de098388ee252dd230143ddf486b3017117b1/psutil-1.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"f3af7b44925554531dff038e0401976a6b92b089ecca51d50be903420d7a262d"},"provenance":null,"requires-python":null,"size":307074,"upload-time":"2013-11-25T20:09:25.387664Z","url":"https://files.pythonhosted.org/packages/40/47/665755b95ad75e6223af96f2d7c04667f663a53dede0315df9832c38b60d/psutil-1.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"26fd84571ac026861d806a9f64e3bbfd38d619a8195c1edfd31c0a9ee2295b03"},"provenance":null,"requires-python":null,"size":329716,"upload-time":"2014-02-06T00:57:26.931878Z","url":"https://files.pythonhosted.org/packages/d8/65/2e9941492b3d001a87d87b5e5827b1f3cec42e30b7110fa82d24be8c4526/psutil-1.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.4.exe","hashes":{"sha256":"84a4e7e2de1ca6f45359cfd7fd60c807f494385a6d97804bd58759a94b9c5e2d"},"provenance":null,"requires-python":null,"size":143888,"upload-time":"2013-11-25T20:07:25.331363Z","url":"https://files.pythonhosted.org/packages/5c/99/d9147b76eea8c185b6cefbb46de73ae880e5ef0ff36d93cb3f6084e50d59/psutil-1.2.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.5.exe","hashes":{"sha256":"aad7d81607b3ad740fee47b27a9f1434a05fe35dc68abefb1f961f74bae3c3f9"},"provenance":null,"requires-python":null,"size":143868,"upload-time":"2013-11-25T20:07:40.595942Z","url":"https://files.pythonhosted.org/packages/bd/a0/5087d4a5145326a5a07a53ed4f9cd5c09bf5dad4f8d7b9850e6aaa13caa2/psutil-1.2.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.6.exe","hashes":{"sha256":"3ad3a40afd859cf0217a2d643c74be3a12ed2f54ebd4a91c40fa7b13084573c6"},"provenance":null,"requires-python":null,"size":278185,"upload-time":"2013-11-25T20:07:59.926444Z","url":"https://files.pythonhosted.org/packages/c6/e0/67810b602a598488d1f2982451655427effe7c7062184fe036c2b5bc928f/psutil-1.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py2.7.exe","hashes":{"sha256":"02fb79b9e5336ff179c44ce2017308cf46316e19bea70abb8855afd808db2a0f"},"provenance":null,"requires-python":null,"size":277955,"upload-time":"2013-11-25T20:08:20.641779Z","url":"https://files.pythonhosted.org/packages/5b/7f/9334b57597acabaaf2261c93bb9b1f9f02cdfef5c1b1aa808b262f770adb/psutil-1.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py3.2.exe","hashes":{"sha256":"7e64d065f12e8f941f2dbb2f3df0887b2677fee7b2b4c50ed91e490e094c7273"},"provenance":null,"requires-python":null,"size":277243,"upload-time":"2013-11-25T20:08:40.628203Z","url":"https://files.pythonhosted.org/packages/ae/c5/2842c69c67ae171f219efa8bb11bddc2fcec2cea059721e716fe4d48b50c/psutil-1.2.1.win32-py3.2.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-1.2.1.win32-py3.3.exe","hashes":{"sha256":"1a1c8e6635949a698b6ade3d5d2a8368daff916d8122cf13286c79a52ec8d7a1"},"provenance":null,"requires-python":null,"size":271900,"upload-time":"2013-11-25T20:09:05.464640Z","url":"https://files.pythonhosted.org/packages/86/df/007ca575da6ee7cbb015dc00122028ee0c97fc6a0c9e8bc02333753bfd2f/psutil-1.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.tar.gz","hashes":{"sha256":"38af34b0f40a4f50988a7401b7111ae4468beb5bcce0fbae409504dd3d5f2e8d"},"provenance":null,"requires-python":null,"size":207168,"upload-time":"2014-03-10T11:23:38.510743Z","url":"https://files.pythonhosted.org/packages/9c/2c/d4380234ddc21ecfb03691a982f5f26b03061e165658ac455b61886fe3ff/psutil-2.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"32f27f9be7c03f60f61dc27af2464cfb1edd64525d05b81478e80dc12913fe3b"},"provenance":null,"requires-python":null,"size":310569,"upload-time":"2014-03-10T11:16:14.555076Z","url":"https://files.pythonhosted.org/packages/c3/10/c0e1b505d7d2b4a7f3294c1b4b2bc2644a4629462d777fe2cdcd57b1debe/psutil-2.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"219cf2e5832cf68798e522e815d79a7307dea1f6b1d9b2372704f6e7fea085f3"},"provenance":null,"requires-python":null,"size":309024,"upload-time":"2014-03-10T11:16:29.122028Z","url":"https://files.pythonhosted.org/packages/eb/db/ab023b5ce09f314ee58ee4b9e73e85172dd06272501570a34a1afe6115c2/psutil-2.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"12b9c02e108e887a43e0ed44e3a8e9968e65236d6d0b79c45891471ea2b9e14d"},"provenance":null,"requires-python":null,"size":310130,"upload-time":"2014-03-10T11:16:49.562585Z","url":"https://files.pythonhosted.org/packages/67/94/0dded4aab9c4992bddb311d2ae8fd9a638df5f6039d12a4fe66481f3ea1c/psutil-2.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.4.exe","hashes":{"sha256":"54d8636623a4f676a9a38b0afe3dfad5f1b90f710f2cb6c55e1a0803813d76a5"},"provenance":null,"requires-python":null,"size":143691,"upload-time":"2014-03-10T11:20:46.107824Z","url":"https://files.pythonhosted.org/packages/76/a3/48c0984c0b65be53a9e3e090df0cd5f3e6bddd767c3f8e62cf286be240e1/psutil-2.0.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.5.exe","hashes":{"sha256":"f669fe7e7cab107fb738362366cc9e0ecda532269ac3a9815a28930b474edf0b"},"provenance":null,"requires-python":null,"size":147735,"upload-time":"2014-03-10T11:15:02.487295Z","url":"https://files.pythonhosted.org/packages/f8/ba/346cc719249b9a5281dab059cb8796aff6faf487142f50966fc08330ad79/psutil-2.0.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.6.exe","hashes":{"sha256":"33b580008e0c65073198472da81d0d0c50d2a30e3e82c269713b1e3bdf14c2c6"},"provenance":null,"requires-python":null,"size":280920,"upload-time":"2014-03-10T11:15:17.132174Z","url":"https://files.pythonhosted.org/packages/2f/6f/7326e900c5333d59aa96a574d13321c94a9357ab56b0dd489b8f24ebab78/psutil-2.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py2.7.exe","hashes":{"sha256":"4f9c78cdd57e1c83242096f8343617ae038efd1c23af3864c25992335eabed3f"},"provenance":null,"requires-python":null,"size":280693,"upload-time":"2014-03-10T11:15:31.704968Z","url":"https://files.pythonhosted.org/packages/18/dd/c81485b54894c35fd8b62822563293db7c4dd17a05ea4eade169cf383266/psutil-2.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py3.3.exe","hashes":{"sha256":"380f8ff680ce3c8fdd7b31a3fe42d697b15a0c8677559691ed90b755051a5acf"},"provenance":null,"requires-python":null,"size":275631,"upload-time":"2014-03-10T11:15:45.735326Z","url":"https://files.pythonhosted.org/packages/77/5a/e87efff3e46862421a9c87847e63ebecd3bb332031305b476399918fea4f/psutil-2.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.0.0.win32-py3.4.exe","hashes":{"sha256":"4239b2431c825db2ad98e404a96320f0c78fb1c7d5bdf52a49a00d36bedfa0df"},"provenance":null,"requires-python":null,"size":275638,"upload-time":"2014-03-10T11:16:00.263121Z","url":"https://files.pythonhosted.org/packages/c4/80/35eb7f189482d25e3669871e7dcd295ec38f792dc4670b8635d72b4f949a/psutil-2.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.tar.gz","hashes":{"sha256":"d1e3ce46736d86164b6d72070f2cbaf86dcf9db03066b7f36a7b302e334a8d01"},"provenance":null,"requires-python":null,"size":211640,"upload-time":"2014-04-08T14:59:37.598513Z","url":"https://files.pythonhosted.org/packages/6c/d1/69431c4fab9b5cecaf28f2f2e0abee21805c5783c47143db5f0f7d42dbec/psutil-2.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"9dc35f899946d58baf5b805ebed2f723f75d93f6b6bce212f79581d40f7276db"},"provenance":null,"requires-python":null,"size":312139,"upload-time":"2014-04-08T15:13:59.193442Z","url":"https://files.pythonhosted.org/packages/7a/3c/ce6a447030cdb50cf68a3988337df0c42e52abf45c3adfea3b225760eb70/psutil-2.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"46232b7b0eb48c6ec1f12d17b2cc15ec3cc70ed952f2c98edb50aaa405dafa5d"},"provenance":null,"requires-python":null,"size":310591,"upload-time":"2014-04-08T15:14:05.019441Z","url":"https://files.pythonhosted.org/packages/cd/60/7134a7f812ef1eba9373c86b95ce6254f5f58928baba04af161f0066629f/psutil-2.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"fa770a2c9e384924df021aed9aa5a6f92db8062a7f700113ba3943e262028454"},"provenance":null,"requires-python":null,"size":311682,"upload-time":"2014-04-08T15:14:24.701683Z","url":"https://files.pythonhosted.org/packages/45/56/3ac0a63799d54cb9b1914214944aed71e49297fb90de92b8d1fe20de3bd8/psutil-2.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.4.exe","hashes":{"sha256":"15d0d10bbd60e461690188cdd209d6688a1112648589bf291b17cc84e99cb6e7"},"provenance":null,"requires-python":null,"size":145275,"upload-time":"2014-04-08T15:12:04.809516Z","url":"https://files.pythonhosted.org/packages/09/e8/f6e4209b3d6373ea11fa340c2e6e4640a7ee53ef4697c49d610ffdf86674/psutil-2.1.0.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.5.exe","hashes":{"sha256":"381ac1027a270c04cf6decdc011a28a4270105d009f213d62daec4b3116b92b6"},"provenance":null,"requires-python":null,"size":149378,"upload-time":"2014-04-08T15:12:25.638187Z","url":"https://files.pythonhosted.org/packages/6d/05/0e7213e6f0dc71490a523a70e6ab5e7cd5140d87dc93a4447da58c440d6b/psutil-2.1.0.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.6.exe","hashes":{"sha256":"7eda949fbdf89548b0e52e7d666e096ea66b30b65bcbe04d305e036a24a76d11"},"provenance":null,"requires-python":null,"size":282509,"upload-time":"2014-04-08T15:12:57.055047Z","url":"https://files.pythonhosted.org/packages/f2/88/a856c5ed36d15b8ad74597f380baa29891ec284e7a1be4cb2f91f8453bd8/psutil-2.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py2.7.exe","hashes":{"sha256":"f1ec06db1b0d27681a1bea4c9f0b33705bc5a00035c32f168da0ea193883bb91"},"provenance":null,"requires-python":null,"size":282317,"upload-time":"2014-04-08T15:13:11.798772Z","url":"https://files.pythonhosted.org/packages/d0/17/ec99e9252dae834f4a012e13c804c86907fcb1cb474f7b1bc767562bfa7b/psutil-2.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py3.3.exe","hashes":{"sha256":"feccef3ccf09785c6f81e67223cf2d8736a90c8994623dd75f683dd2bf849235"},"provenance":null,"requires-python":null,"size":277268,"upload-time":"2014-04-08T15:13:26.711424Z","url":"https://files.pythonhosted.org/packages/f0/0a/32abfd9b965c9a433b5011574c904372b954330c170c6f92b637d661ecd2/psutil-2.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.0.win32-py3.4.exe","hashes":{"sha256":"4719134be984b0f2ba072ff761f334c2f3dbb8ca6af70ba43d8ca31b7e13c3db"},"provenance":null,"requires-python":null,"size":277279,"upload-time":"2014-04-08T15:13:41.834397Z","url":"https://files.pythonhosted.org/packages/f5/3b/eab6a8d832d805c7a00d0f2398c12a32bea7e8b6eb7d5fbdf869e4bcc9e0/psutil-2.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.tar.gz","hashes":{"sha256":"bf812a4aa6a41147d0e96e63d826eb7582fda6b54ad8f22534354b7f8ac45593"},"provenance":null,"requires-python":null,"size":216796,"upload-time":"2014-04-30T14:27:01.651394Z","url":"https://files.pythonhosted.org/packages/64/4b/70601d39b8e445265ed148affc49f7bfbd246940637785be5c80e007fa6e/psutil-2.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"1b5ee64306535a625b77648e32f1b064c31bf58bfc7a37cde6c7bb3fa4abb6bd"},"provenance":null,"requires-python":null,"size":312763,"upload-time":"2014-04-30T14:31:09.411365Z","url":"https://files.pythonhosted.org/packages/e6/50/df05e0cbfcf20f022756d5e2da32b4f4f37d5bca6f5bd6965b4ef0460e8b/psutil-2.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"9e28fe35e1185d59ba55313d90efc122d45b7a2e3fa304869024d26b0a809bc5"},"provenance":null,"requires-python":null,"size":311262,"upload-time":"2014-04-30T14:31:28.733500Z","url":"https://files.pythonhosted.org/packages/a3/a9/b3f114141a49244739321f221f35c300ac7f34ec9e3a352ea70c9fae41f8/psutil-2.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"3afa327284a218d6a25b2f3520135337cfa4a47eaea030273ad8eb02894d60fe"},"provenance":null,"requires-python":null,"size":312365,"upload-time":"2014-04-30T14:31:47.981590Z","url":"https://files.pythonhosted.org/packages/c7/67/2aae3f66090c2e06fa60c29a2e554fd2a718949aca53bca78d640212cb34/psutil-2.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.4.exe","hashes":{"sha256":"7c76d99bfaeafbcf66096c69b8fca1f7269603d66cad1b14cd8dd93b14bceeb0"},"provenance":null,"requires-python":null,"size":145848,"upload-time":"2014-04-30T14:37:26.909225Z","url":"https://files.pythonhosted.org/packages/27/4e/c9b4802420d6b5d0a844208c9b8a4e25b3c37305428e40bc1da6f5076891/psutil-2.1.1.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.5.exe","hashes":{"sha256":"6aeb358b66cc4367378edadb928c77e82646f36858b2a516298d1917aa6aca25"},"provenance":null,"requires-python":null,"size":149998,"upload-time":"2014-04-30T14:28:49.630619Z","url":"https://files.pythonhosted.org/packages/5d/e9/69dee6454940bb102fbbcaa1e44b46bfefc4c0bf53e5e3835d3de3ebc9ae/psutil-2.1.1.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.6.exe","hashes":{"sha256":"a53546550067773920e1f7e6e3f1fad2f2befe45c6ff6c94e22b67f4b54c321a"},"provenance":null,"requires-python":null,"size":283143,"upload-time":"2014-04-30T14:29:06.869445Z","url":"https://files.pythonhosted.org/packages/9f/45/d2dfa6bdd9b64bfd46ad35af774c3819e0d5abf23a99d51adf11984ca658/psutil-2.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py2.7.exe","hashes":{"sha256":"37ce747f9042c375f62e861d627b5eb7bace24767303f5d0c4c03d17173a551c"},"provenance":null,"requires-python":null,"size":282941,"upload-time":"2014-04-30T14:29:27.059188Z","url":"https://files.pythonhosted.org/packages/78/47/14db8651f9863d301c0673d25fa22b87d13fde2974f94854502886a21fd1/psutil-2.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py3.3.exe","hashes":{"sha256":"8f0f88752e1e9bfeced78daf29d90e0028d17f39b805bb0acf70fefe77ba5ccb"},"provenance":null,"requires-python":null,"size":277944,"upload-time":"2014-04-30T14:29:49.405456Z","url":"https://files.pythonhosted.org/packages/f1/63/2fcaa58b101dce55a12f768508a7f0a0028ccc5a90633d86dd4cc0bcdb52/psutil-2.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.1.win32-py3.4.exe","hashes":{"sha256":"bc353df13a6ea40651cba82810a38590e2439c158cf6f130cd0876d0dda53118"},"provenance":null,"requires-python":null,"size":279092,"upload-time":"2014-04-30T14:30:08.449338Z","url":"https://files.pythonhosted.org/packages/5f/26/0be35c7f3dc9e78d405ed6be3aa76a9ce97b51e0076db98408a6f2c288fb/psutil-2.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp26-none-win32.whl","hashes":{"sha256":"ccb5e28357a4b6c572b97e710a070f349e9b45172315eaed6e0b72e86d333b68"},"provenance":null,"requires-python":null,"size":83869,"upload-time":"2014-09-21T13:47:09.164866Z","url":"https://files.pythonhosted.org/packages/c7/22/811ac7c641191e3b65c053c95eb34f6567bbc5155912630464271ab6f3df/psutil-2.1.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp27-none-win32.whl","hashes":{"sha256":"41992126c0281c2f5f279a0e8583382a3b840bd0d48262dfb7bc3cb67bdc6587"},"provenance":null,"requires-python":null,"size":83672,"upload-time":"2014-09-21T13:47:14.034296Z","url":"https://files.pythonhosted.org/packages/79/9d/154b179a73695ae605856c2d77ab5da2a66ef4819c3c4f97e4ab297a2902/psutil-2.1.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"data-dist-info-metadata":{"sha256":"32ea7aa3898a3a77f4d45a211e8c96889ec6e5f933ea2ef9e4249d53fc41e4a1"},"filename":"psutil-2.1.2-cp27-none-win_amd64.whl","hashes":{"sha256":"79cb57bba4cbeebb7e445d19c531107493458a47d0f4c888ce49fc8dec670c32"},"provenance":null,"requires-python":null,"size":85848,"upload-time":"2014-09-21T13:47:30.044802Z","url":"https://files.pythonhosted.org/packages/00/ae/567c30ff44c263cc78dfe50197184e58b62ca9fcfebad144cd235f5d8d2d/psutil-2.1.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp33-none-win32.whl","hashes":{"sha256":"c5e6424833620f0d0a70ebc1305260bfad4b5c73989b8a2e8bd01bf39b4b600c"},"provenance":null,"requires-python":null,"size":83742,"upload-time":"2014-09-21T13:47:18.481401Z","url":"https://files.pythonhosted.org/packages/62/4d/be87c318274ade9d6589e8545dd5d5bb4bcc42e92334d88d948cf8daa36b/psutil-2.1.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp33-none-win_amd64.whl","hashes":{"sha256":"b4c69627c245025b9209acbffc066ff8ac1237d13e2eddd0461f3149969b7da3"},"provenance":null,"requires-python":null,"size":85822,"upload-time":"2014-09-21T13:47:33.681070Z","url":"https://files.pythonhosted.org/packages/bc/52/ab3c88a0574275ec33d9de0fe7dc9b1a32c573de0e468502876bc1df6f84/psutil-2.1.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp34-none-win32.whl","hashes":{"sha256":"97a1d0ddbb028a20feffaf7fa3d0c451004abc74ef7ea1e492d039f8b7278399"},"provenance":null,"requires-python":null,"size":83748,"upload-time":"2014-09-21T13:47:25.367914Z","url":"https://files.pythonhosted.org/packages/ef/4a/c956675314e4a50b319d9894c2ee2d48ce83df4d639d9c2fc06a99415dec/psutil-2.1.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"data-dist-info-metadata":{"sha256":"e9eb9bc1a4851e5f154ad139504894781ffa9f0ee16ea77f8c17f4aee9d5aa50"},"filename":"psutil-2.1.2-cp34-none-win_amd64.whl","hashes":{"sha256":"a78226f9236c674d43b206e7da06478cf2bcf10e5aee647f671878ea2434805f"},"provenance":null,"requires-python":null,"size":85789,"upload-time":"2014-09-21T13:47:38.760178Z","url":"https://files.pythonhosted.org/packages/b9/41/68b5fc38b97e037ef55e6475d618c079fe2b5d148f5e3fda795c21d888a7/psutil-2.1.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.tar.gz","hashes":{"sha256":"897e5163e0669001bf8bcb0557362f14703356336519082a93c38d54e5b392e4"},"provenance":null,"requires-python":null,"size":223595,"upload-time":"2014-09-21T13:50:56.650693Z","url":"https://files.pythonhosted.org/packages/53/6a/8051b913b2f94eb00fd045fe9e14a7182b6e7f088b12c308edd7616a559b/psutil-2.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"3ed7ef4ab59894e6eb94adae0b656733c91906af169b55443329315322cd63b3"},"provenance":null,"requires-python":null,"size":319335,"upload-time":"2014-09-21T13:48:15.057062Z","url":"https://files.pythonhosted.org/packages/a6/88/cc912d38640ddf3441db1f85f8ff8a87f906056554239a4a211970cf6446/psutil-2.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py3.3.exe","hashes":{"sha256":"e20f317187a7186e13dc6fdd6960083c227db86fffbb145fe000e8c167a854a6"},"provenance":null,"requires-python":null,"size":317817,"upload-time":"2014-09-21T13:48:20.665047Z","url":"https://files.pythonhosted.org/packages/d2/b4/887323eb2b0b5becb5a7b77ab04167741346fddffe27bc6ae5deeffcc3c1/psutil-2.1.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win-amd64-py3.4.exe","hashes":{"sha256":"f7f2a61be7a828656dceffdf0d2fa304a144db6ab5ec4e2b033108f3822df6ff"},"provenance":null,"requires-python":null,"size":317804,"upload-time":"2014-09-21T13:48:33.226186Z","url":"https://files.pythonhosted.org/packages/57/e5/c041b08bea32246f53b7cf27b897e882a695f3ea95eb632b384dd35cf41f/psutil-2.1.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.4.exe","hashes":{"sha256":"77aac0179fe0e8b39c9b25ea732285d307bb941e715075366dc467b8609ebf09"},"provenance":null,"requires-python":null,"size":155426,"upload-time":"2014-09-21T13:54:03.017765Z","url":"https://files.pythonhosted.org/packages/ce/3f/7c434baec7ca47e65fb1e3bcbc8fe1c9f504d93c750a7fa4f98b16635920/psutil-2.1.2.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.5.exe","hashes":{"sha256":"982f4568876d10881f9c90fe992d1d9af353a59b5de7771cc4766d7432aee7ab"},"provenance":null,"requires-python":null,"size":155414,"upload-time":"2014-09-21T13:47:47.970150Z","url":"https://files.pythonhosted.org/packages/46/86/2971b31e2637ddc53adce2d997472cee8d4dec366d5a1e140945b95860d5/psutil-2.1.2.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.6.exe","hashes":{"sha256":"f35d91b5fc2b52472c0766fa411ac22f7a5ed8b1ececd96c1486380bdad0bb41"},"provenance":null,"requires-python":null,"size":289714,"upload-time":"2014-09-21T13:47:52.391726Z","url":"https://files.pythonhosted.org/packages/dd/3e/cdc3d4f343e6edc583d0686d1d20d98f9e11de35c51dc7990525ab2ca332/psutil-2.1.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py2.7.exe","hashes":{"sha256":"dbd9e4fbe08c0ff6d4a87a4d6dfae16fccd03346f980cffa105941de8801d00b"},"provenance":null,"requires-python":null,"size":289515,"upload-time":"2014-09-21T13:47:57.624310Z","url":"https://files.pythonhosted.org/packages/fb/01/73753147113f6db19734db6e7ac994cee5cce0f0935e12320d7aa1b56a14/psutil-2.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py3.3.exe","hashes":{"sha256":"73428e7b695e5889f07f1b37c5ec0cc0f49d3808dc40986050f1b13fd7c4c71e"},"provenance":null,"requires-python":null,"size":284506,"upload-time":"2014-09-21T13:48:02.428235Z","url":"https://files.pythonhosted.org/packages/b0/97/ba13c3915aba7776bb0d23819c04255230c46df1f8582752f7e0382c0b67/psutil-2.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.2.win32-py3.4.exe","hashes":{"sha256":"e2326c7b9f64a0f22891d3b362efcd92389e641023b07bc54567280c0c2e160d"},"provenance":null,"requires-python":null,"size":284538,"upload-time":"2014-09-21T13:48:08.358281Z","url":"https://files.pythonhosted.org/packages/88/bd/843fadc578d62f2888d5a7b4e2a418a28140ac239a5a5039c0d3678df647/psutil-2.1.2.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp26-none-win32.whl","hashes":{"sha256":"331a3b0b6688f95acebe87c02efca53003e613f1c7892a09063a9d3c0af33656"},"provenance":null,"requires-python":null,"size":83927,"upload-time":"2014-09-26T20:26:46.078909Z","url":"https://files.pythonhosted.org/packages/72/4c/f93448dfe2dec286b6eae91a00c32f1fbf65506e089354c51db76f4efdaf/psutil-2.1.3-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp27-none-win32.whl","hashes":{"sha256":"5ee9e17f6e92aaec7c53f6483c6708eec22124060a52ac339d104effcb4af37f"},"provenance":null,"requires-python":null,"size":83731,"upload-time":"2014-09-26T20:26:51.215134Z","url":"https://files.pythonhosted.org/packages/27/c5/a644b5df545c467569c7b8e768717fad6758eab8e2544b7d412d07c30ffe/psutil-2.1.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"data-dist-info-metadata":{"sha256":"69a75d24381600fdb642efa3827cf0c4e9c1c94273f2866e017a7017816167f8"},"filename":"psutil-2.1.3-cp27-none-win_amd64.whl","hashes":{"sha256":"47ea728de15c16a7cb476eb4f348be57e9daebfa730b9a4a104e9086da2cf6cd"},"provenance":null,"requires-python":null,"size":85906,"upload-time":"2014-09-26T20:27:07.470817Z","url":"https://files.pythonhosted.org/packages/89/82/1070ecb59d83967ddb2ea58b41ba2b9ffa8f3f686a3f49b8d33dc5684964/psutil-2.1.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp33-none-win32.whl","hashes":{"sha256":"ae0aac37af1d7d6821bb11dcffb12bb885b44773858bd40703e9dcb14325369c"},"provenance":null,"requires-python":null,"size":83804,"upload-time":"2014-09-26T20:26:56.233644Z","url":"https://files.pythonhosted.org/packages/b6/fc/7f2ceac523bb5ce9ea93bd85806ebb2d5327f0e430cbb6e70d32e4306e1d/psutil-2.1.3-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp33-none-win_amd64.whl","hashes":{"sha256":"45ebaf679050a6d64a32a91d901791868a29574f6961629997dcd4661edb4ece"},"provenance":null,"requires-python":null,"size":85884,"upload-time":"2014-09-26T20:27:12.800416Z","url":"https://files.pythonhosted.org/packages/45/33/a50ed3def836cd8fc53ce04d09e50df67a6816fd24a819e8e9c45b93fc74/psutil-2.1.3-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp34-none-win32.whl","hashes":{"sha256":"0ae7d503fc458181af7dd9a2bbf43c4b5fc7cd6e6797ef4a6d58bb8046026d76"},"provenance":null,"requires-python":null,"size":83804,"upload-time":"2014-09-26T20:27:02.155242Z","url":"https://files.pythonhosted.org/packages/55/e9/c122a9d2528cc36ff4f2824a714ee6d5da5462e4b6725e6b1c7098142c4a/psutil-2.1.3-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"data-dist-info-metadata":{"sha256":"6ddf7c489626ecf2cd274a5d66e5785193f3eb6b2d596efff52afc15b251e25f"},"filename":"psutil-2.1.3-cp34-none-win_amd64.whl","hashes":{"sha256":"da0961ba9a6d97c137381cd59b7d330894dd4f7deb5a8291bc3251375fd6d6ec"},"provenance":null,"requires-python":null,"size":85840,"upload-time":"2014-09-26T20:27:18.296315Z","url":"https://files.pythonhosted.org/packages/6f/97/5e01561cde882306c28e462b427f67d549add65f5fca324bf0bbdf831d21/psutil-2.1.3-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.tar.gz","hashes":{"sha256":"b434c75f01715777391f10f456002e33d0ca14633f96fdbd9ff9139b42d9452c"},"provenance":null,"requires-python":null,"size":224008,"upload-time":"2014-09-30T18:10:37.283557Z","url":"https://files.pythonhosted.org/packages/fe/a3/7cf43f28bbb52c4d680378f99e900ced201ade5073ee3a7b30e7f09e3c66/psutil-2.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"449d07df8f8b9700cfae4ee67f0a73e4f96b55697428ae92cab29e33db4c3102"},"provenance":null,"requires-python":null,"size":319620,"upload-time":"2014-09-26T20:24:42.575161Z","url":"https://files.pythonhosted.org/packages/0e/66/bf4346c9ada08acee7e8f87d270fb4d4e6c86a477630adcfa3caa69aa5bb/psutil-2.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py3.3.exe","hashes":{"sha256":"5b444e5c1f3d3ee7a19a5720c62d6462fe81dd1d1bbb8aa955546ead509b3c4a"},"provenance":null,"requires-python":null,"size":318101,"upload-time":"2014-09-26T20:24:47.973672Z","url":"https://files.pythonhosted.org/packages/bd/a7/888e9fa42c8d475de7b467b9635bb18ed360cb1c261bcf59f5f932d624ea/psutil-2.1.3.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win-amd64-py3.4.exe","hashes":{"sha256":"3d25b4b20aabd360b7eda3dcbf4a14d2b256c2f61a8a569028e1c4b65b4d585a"},"provenance":null,"requires-python":null,"size":318089,"upload-time":"2014-09-26T20:24:55.536742Z","url":"https://files.pythonhosted.org/packages/b1/15/3f657d395213ad90efed423c88f1cb2f3b0a429d12bdea98a28c26de7ff4/psutil-2.1.3.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.4.exe","hashes":{"sha256":"36424b4e683d640291a1723f46a3949ebea37e43492f61027c168fb9dfe2055f"},"provenance":null,"requires-python":null,"size":155710,"upload-time":"2014-09-26T20:29:01.901009Z","url":"https://files.pythonhosted.org/packages/31/2e/d5448240fed09e88bbb59de194e1f2d3ba29f936a3231d718e5373736299/psutil-2.1.3.win32-py2.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.5.exe","hashes":{"sha256":"baa1803aaa4505fcf48bbd50d038d1f686d9e290defeecde41770d8fe876812b"},"provenance":null,"requires-python":null,"size":155699,"upload-time":"2014-09-26T20:24:13.810499Z","url":"https://files.pythonhosted.org/packages/2a/45/10d7b5057b3f941f803ca8ee690e651d2778e731f15ef3eee83c3f05f82f/psutil-2.1.3.win32-py2.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.6.exe","hashes":{"sha256":"55811a125d8a79bed0a65ed855fafc34f7d59cde162542a30cfa518da9e015bc"},"provenance":null,"requires-python":null,"size":289998,"upload-time":"2014-09-26T20:24:18.935804Z","url":"https://files.pythonhosted.org/packages/f3/4d/7f105269ece54ad7344c2a24b42ecb216b2746460f349c0ed1577b5ab8fa/psutil-2.1.3.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py2.7.exe","hashes":{"sha256":"6a1c8f1884f1983f8b74fda5dc89da07a69e3972fc022c3205f4964e1b01d235"},"provenance":null,"requires-python":null,"size":289802,"upload-time":"2014-09-26T20:24:24.112924Z","url":"https://files.pythonhosted.org/packages/93/64/1432ca27dfd7102a6726161b79b15a2997f461d3835867271a6c1e3353f7/psutil-2.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py3.3.exe","hashes":{"sha256":"8df72fcd30436e78bf8c5c6c796bb6815966511fa0bc8e3065e1aabbe4a2cf3d"},"provenance":null,"requires-python":null,"size":284794,"upload-time":"2014-09-26T20:24:30.110864Z","url":"https://files.pythonhosted.org/packages/0a/bb/d6cc7133624e3532e1d99f6cece35be7bd8d95ff7c82ca28cd502388c225/psutil-2.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.1.3.win32-py3.4.exe","hashes":{"sha256":"1f353ab0bbe0216e3a1636bfefb70ed366a2b1d95c95689f97e95d603626ef70"},"provenance":null,"requires-python":null,"size":284824,"upload-time":"2014-09-26T20:24:36.842776Z","url":"https://files.pythonhosted.org/packages/4a/66/9b1acf05dba9b9cb012ab3b8ed3d0fd7b01e1620808977fa6f1efe05dee2/psutil-2.1.3.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp26-none-win32.whl","hashes":{"sha256":"c92d2853ac52d5aaf8c2366435fb74892f7503daf2cf56b785f1ecadbf68e712"},"provenance":null,"requires-python":null,"size":82092,"upload-time":"2015-01-06T15:36:18.243917Z","url":"https://files.pythonhosted.org/packages/3c/65/f5bd2f8b54f14d950596c0c63d7b0f98b6dc779f7c61ac0dd2e9fc7e5e74/psutil-2.2.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp27-none-win32.whl","hashes":{"sha256":"6ad0e79b95f57a20f0cace08a063b0fc33fd83da1e5e501bc800bc69329a4501"},"provenance":null,"requires-python":null,"size":81891,"upload-time":"2015-01-06T15:36:28.466138Z","url":"https://files.pythonhosted.org/packages/6a/e6/96a4b4976f0eca169715d975b8c669b78b9afca58f9aadf261915694b73e/psutil-2.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"data-dist-info-metadata":{"sha256":"30ed17dae0fd30cf429cfd022f7c9e5e8d675d87901927dda94ded45c224eb33"},"filename":"psutil-2.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"bbe719046986568ed3e84ce66ed617eebc46251ea8193566b3707abdf635afe6"},"provenance":null,"requires-python":null,"size":84072,"upload-time":"2015-01-06T15:36:58.206788Z","url":"https://files.pythonhosted.org/packages/28/28/4e4f94c9778ed16163f6c3dd696ce5e331121ac1600308830a3e98fa979a/psutil-2.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp33-none-win32.whl","hashes":{"sha256":"73013822a953fc4e3fb269256ec01b261752c590e23851e666201d1bfd32a3a9"},"provenance":null,"requires-python":null,"size":81885,"upload-time":"2015-01-06T15:36:38.776238Z","url":"https://files.pythonhosted.org/packages/66/8d/3143623c2f5bc264197727854040fdc02e3175b4ad991490586db7a512ed/psutil-2.2.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp33-none-win_amd64.whl","hashes":{"sha256":"d664a896feb10ec5bf4c43f4df8b6c7fceeb94677004cc9cf8c9f35b52c0e4fc"},"provenance":null,"requires-python":null,"size":84002,"upload-time":"2015-01-06T15:37:08.775842Z","url":"https://files.pythonhosted.org/packages/bd/08/112807380b8e7b76de8c84f920234a0ebed35e6511271f93f900f691a10c/psutil-2.2.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp34-none-win32.whl","hashes":{"sha256":"84299c41b251bef2a8b0812d651f4715209b3c4dfebe4a5df0f103bbdec78221"},"provenance":null,"requires-python":null,"size":81886,"upload-time":"2015-01-06T15:36:49.808417Z","url":"https://files.pythonhosted.org/packages/ef/0e/0cf2fea8f6e2e5ef84797eefc2c5ce561123e2417d7b931a6c54f9f8d413/psutil-2.2.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"data-dist-info-metadata":{"sha256":"ac33f92c3e235fbeaf7e70b46e7b2d1503467bd420fac08e570cd9cfc3d3b738"},"filename":"psutil-2.2.0-cp34-none-win_amd64.whl","hashes":{"sha256":"3636879fcbde2b0b63db08abd0e3673c2cc72bb14075e46e15f98774b0c78236"},"provenance":null,"requires-python":null,"size":83954,"upload-time":"2015-01-06T15:37:18.558007Z","url":"https://files.pythonhosted.org/packages/82/ed/ce9c4281fd8a944a725c0f9a5d77f32295777ab22f54b4f706a51d59edd3/psutil-2.2.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.tar.gz","hashes":{"sha256":"b15cc9e7cad0991bd1cb806fa90ea85ba3a95d0f1226625ecef993294ad61521"},"provenance":null,"requires-python":null,"size":223676,"upload-time":"2015-01-06T15:38:45.979998Z","url":"https://files.pythonhosted.org/packages/ba/e4/760f64a8a5a5f1b95f3ce17c0d51134952f930caf1218e6ce21902f6c4ab/psutil-2.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"623baf2a213adc99cbc067e1db04b9e578eb4c38d9535c903e04b6d1ded10cab"},"provenance":null,"requires-python":null,"size":317990,"upload-time":"2015-01-06T15:34:57.187611Z","url":"https://files.pythonhosted.org/packages/30/a8/d1754e9e5492717d1c1afb30970f0677056052859f1af935b48c72c6cd68/psutil-2.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"fc6d348f603ae8465992a7edbc7c62cc16f0493bdd43aa609dcb7437992cac96"},"provenance":null,"requires-python":null,"size":316424,"upload-time":"2015-01-06T15:35:20.860940Z","url":"https://files.pythonhosted.org/packages/32/f1/e98caa1f6be7ba49dfafa0fbb63f50ffa191d316a1b2b3ec431d97ebf494/psutil-2.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"5e4508ca6822839f25310bfc14c050e60362dc29ddea6f5eac91de2c7423a471"},"provenance":null,"requires-python":null,"size":316403,"upload-time":"2015-01-06T15:35:42.094623Z","url":"https://files.pythonhosted.org/packages/dd/46/31505418bd950b09d28c6c21be76a4a51d593ec06b412539797080c0aa6b/psutil-2.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py2.6.exe","hashes":{"sha256":"1f93ccdf415da40f15a84ab6d9d32ddda61bb1b20079dae602356e087f408d28"},"provenance":null,"requires-python":null,"size":288364,"upload-time":"2015-01-06T15:33:25.830661Z","url":"https://files.pythonhosted.org/packages/9c/0d/f360da29c906dafd825edccc219e70dab73370ad2c287fa5baa9f7fa370b/psutil-2.2.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py2.7.exe","hashes":{"sha256":"83eb1739b7c87a21a65224d77217325e582199bedd0141b29dac81b4e4144c62"},"provenance":null,"requires-python":null,"size":288166,"upload-time":"2015-01-06T15:33:46.994076Z","url":"https://files.pythonhosted.org/packages/7a/30/5bb6644318f2279caf5d334f32df19fe4b2bce11ef418af32124e16f8e98/psutil-2.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py3.3.exe","hashes":{"sha256":"9db585f37d56381c37738e03aa8beb0b501b26adc7c70660ff182e0473f2cb0a"},"provenance":null,"requires-python":null,"size":283089,"upload-time":"2015-01-06T15:34:11.431221Z","url":"https://files.pythonhosted.org/packages/12/c4/cb75d51edb425ff77e2af5bb32e405ed41beb124ad062fb927bbe135c709/psutil-2.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.0.win32-py3.4.exe","hashes":{"sha256":"4a0d8a192d1523a3f02a4028bf4ac296f7da92c935464d302618bd639c03a2c6"},"provenance":null,"requires-python":null,"size":283110,"upload-time":"2015-01-06T15:34:33.472476Z","url":"https://files.pythonhosted.org/packages/17/fb/ae589efdfd076d1961e1f858c969d234a63e26f648a79b3fac0409e95c2f/psutil-2.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp26-none-win32.whl","hashes":{"sha256":"610f08fc0df646e4997b52f2bf2e40118a560738422d540883297c6f4e38be8c"},"provenance":null,"requires-python":null,"size":82104,"upload-time":"2015-02-02T13:08:03.993201Z","url":"https://files.pythonhosted.org/packages/0a/a7/b6323d30a8dde3f6a139809898e4bdcabcae3129314621aa24eb5ca4468e/psutil-2.2.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp27-none-win32.whl","hashes":{"sha256":"84ec9e77cab1d9ecf2d93bf43eba255a11b26d480966ee542bc846be1e272ea5"},"provenance":null,"requires-python":null,"size":81907,"upload-time":"2015-02-02T13:08:14.963426Z","url":"https://files.pythonhosted.org/packages/40/b6/a94c6d00ac18f779c72973639b78519de0c488e8e8e8d00b65cf4287bec3/psutil-2.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"data-dist-info-metadata":{"sha256":"ff83c284ef44f26c82b6ebdf69d521137b95a89dc815e363bc49eedb63a04c98"},"filename":"psutil-2.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"81a6ab277886f233f230c46073fa6fc97ca2a95a44a14b80c6f6054acb7a644b"},"provenance":null,"requires-python":null,"size":84086,"upload-time":"2015-02-02T13:08:42.917519Z","url":"https://files.pythonhosted.org/packages/1c/ff/6b00405e4eeb3c40d4fc07142ef7bdc3a7a7aa2a1640b65e654bdb7682d1/psutil-2.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp33-none-win32.whl","hashes":{"sha256":"f5e0d247b09c9460b896ff89098015b7687a2934d4ed6165a5c3a662fad7ab6b"},"provenance":null,"requires-python":null,"size":81896,"upload-time":"2015-02-02T13:08:24.437138Z","url":"https://files.pythonhosted.org/packages/a2/fe/40b7d42057c5e68ff4c733b5689e9ae9d8785f13576326ba44371689eff7/psutil-2.2.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp33-none-win_amd64.whl","hashes":{"sha256":"07f31cbe5fc1183c8efb52bab9a5382ebd001a6e11b5a5df827f69456219d514"},"provenance":null,"requires-python":null,"size":84011,"upload-time":"2015-02-02T13:08:53.420801Z","url":"https://files.pythonhosted.org/packages/fe/8d/ffc94f092a12fc3cb837b9bda93abd88fb12219bcc6684b9bffea5e1f385/psutil-2.2.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp34-none-win32.whl","hashes":{"sha256":"a98b350251df2658c9be6bf0b6ebbab10fe88ccb513079c2c56fb53330530ee6"},"provenance":null,"requires-python":null,"size":81896,"upload-time":"2015-02-02T13:08:34.116542Z","url":"https://files.pythonhosted.org/packages/7f/3a/4bb24092c3de0a44f2fc1afb7bcaf898f1daba67cba5b9188b0ae6527102/psutil-2.2.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"data-dist-info-metadata":{"sha256":"85bb3fab01138e16635be140adec7d7fd83c5150a93731deb5a4020ec9d569b1"},"filename":"psutil-2.2.1-cp34-none-win_amd64.whl","hashes":{"sha256":"f49d3ca9150f20269eae79d6efac98f0bbe4e5ceac46fe418d881560a04b6d8e"},"provenance":null,"requires-python":null,"size":83963,"upload-time":"2015-02-02T13:09:03.990685Z","url":"https://files.pythonhosted.org/packages/64/f7/c385e9350abbbb082364596fd4b0066fcb0c51ebc103a7ebf6eb9bc837e9/psutil-2.2.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.tar.gz","hashes":{"sha256":"a0e9b96f1946975064724e242ac159f3260db24ffa591c3da0a355361a3a337f"},"provenance":null,"requires-python":null,"size":223688,"upload-time":"2015-02-02T13:10:14.673714Z","url":"https://files.pythonhosted.org/packages/df/47/ee54ef14dd40f8ce831a7581001a5096494dc99fe71586260ca6b531fe86/psutil-2.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"552eaba2dbc9a49af2da64fc00cedf8847c7c9c2559cc620d9c8855583105764"},"provenance":null,"requires-python":null,"size":317995,"upload-time":"2015-02-02T13:06:42.422390Z","url":"https://files.pythonhosted.org/packages/97/27/e64014166df9efc3d00f987a251938d534d3897d62ef21486559a697a770/psutil-2.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"d25746746f2680d6174c9eb0e2793cb73304ca200d5ec7334000fdb575cd6577"},"provenance":null,"requires-python":null,"size":316429,"upload-time":"2015-02-02T13:07:07.458895Z","url":"https://files.pythonhosted.org/packages/c2/dd/5fdd5fd6102ae546452a5f32a6f75ec44c11d6b84c188dd33cfe1e2809e1/psutil-2.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"298ed760a365a846337750c5089adcec2a87014c61132ae39db671982750f35a"},"provenance":null,"requires-python":null,"size":316409,"upload-time":"2015-02-02T13:07:29.047577Z","url":"https://files.pythonhosted.org/packages/d9/59/0f14daf5797c61db2fec25bca49b49aa0a5d57dec57b4e58ae4652dadb95/psutil-2.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py2.6.exe","hashes":{"sha256":"6e49f72a1cd57918b275fdf7dd041618696fc39d5705ac722fdfccaf0b784a93"},"provenance":null,"requires-python":null,"size":288372,"upload-time":"2015-02-02T13:05:10.073479Z","url":"https://files.pythonhosted.org/packages/0c/a2/63967c61fbfc3f60c1b17e652a52d1afeb3c56403990c5a8f2fb801e2aa1/psutil-2.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py2.7.exe","hashes":{"sha256":"9227949290983df92bb3bb57c5b25605ebbc0e61a3f9baa394f752ed7abc914c"},"provenance":null,"requires-python":null,"size":288171,"upload-time":"2015-02-02T13:05:31.604222Z","url":"https://files.pythonhosted.org/packages/46/f3/d50f059d7d297db7335e340333124eac9441c5897bb29223c85ebaa64e7d/psutil-2.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py3.3.exe","hashes":{"sha256":"f8d94c8228011d1b658c39783596d95244e01950413bfc41fd44e78129ef7075"},"provenance":null,"requires-python":null,"size":283095,"upload-time":"2015-02-02T13:05:54.134208Z","url":"https://files.pythonhosted.org/packages/4a/d6/341767cdc6890adfb19ad60683e66dab3cdde605bc226427c8ec17dbd3f5/psutil-2.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-2.2.1.win32-py3.4.exe","hashes":{"sha256":"1e1df017bfa14c0edc87a124b11ca6e7fd8b6b5c9692eb06c1b72077bcca3845"},"provenance":null,"requires-python":null,"size":283115,"upload-time":"2015-02-02T13:06:12.827127Z","url":"https://files.pythonhosted.org/packages/8c/c1/24179e79ab74bde86ee766c4c0d2bb90b98e4e4d14017efeec024caba268/psutil-2.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"data-dist-info-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"filename":"psutil-3.0.0-cp27-none-win32.whl","hashes":{"sha256":"9641677de91769127c82aa032b70a8d9aa75369d0a9965aba880ac335b02eccb"},"provenance":null,"requires-python":null,"size":85709,"upload-time":"2015-06-13T19:16:33.857911Z","url":"https://files.pythonhosted.org/packages/bb/cf/f893fa2fb0888384b5d668e22b6e3652c9ce187e749604027a64a6bd6646/psutil-3.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"data-dist-info-metadata":{"sha256":"e61eb67de1755dd6d2917f81bb9ee7a0ae6dc5cda2948621b91794f7c5348033"},"filename":"psutil-3.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"11c6b17b37ab1ea04f6a1365bc4598637490819d6b744f3947fd3b8b425366b3"},"provenance":null,"requires-python":null,"size":88043,"upload-time":"2015-06-13T19:16:52.139563Z","url":"https://files.pythonhosted.org/packages/f1/26/a0904455b550f7fd5baa069ca10889825cc22440147813713998cd0676a0/psutil-3.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp33-none-win32.whl","hashes":{"sha256":"8333d2a496fe5d24171360ab1f78468db7a9691d61fd26bf15ca62336c699bac"},"provenance":null,"requires-python":null,"size":85737,"upload-time":"2015-06-13T19:16:39.871421Z","url":"https://files.pythonhosted.org/packages/ea/45/defb71d5009e178ef13e2474627a1070ae291b2dee64ae00e8f2b1a2aec2/psutil-3.0.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp33-none-win_amd64.whl","hashes":{"sha256":"44711a1a683369056d99fd08a05789d217205d72b6dbbe75c0b3743c5e1e3768"},"provenance":null,"requires-python":null,"size":87943,"upload-time":"2015-06-13T19:16:58.439865Z","url":"https://files.pythonhosted.org/packages/3c/0b/648fbaef2a037cc0c05388c0416ba3ca9244c22c4156dba73e4a900540a6/psutil-3.0.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp34-none-win32.whl","hashes":{"sha256":"9036f9c57a8c8a571f36c7d3b2c9a15a22dc9a95137fa60191e2eaa9527209d5"},"provenance":null,"requires-python":null,"size":85695,"upload-time":"2015-06-13T19:16:46.286646Z","url":"https://files.pythonhosted.org/packages/6d/ca/1d5dafae4d7396a825531296b6837b45129b63463b4eb221ac3429eb157d/psutil-3.0.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"data-dist-info-metadata":{"sha256":"adc9c5e259a9c63a9ebd7ef296c4a895baa01701f7d8127d1f989e968fa497aa"},"filename":"psutil-3.0.0-cp34-none-win_amd64.whl","hashes":{"sha256":"18e53256390b299ff03bd58dc134d070bde4871d8c93baf08faea316e87544c8"},"provenance":null,"requires-python":null,"size":87893,"upload-time":"2015-06-13T19:17:05.116909Z","url":"https://files.pythonhosted.org/packages/59/82/51ab7cecaf03c8cbe7eff3b341f6564c3fa80baaa5a37643096cb526cae2/psutil-3.0.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.tar.gz","hashes":{"sha256":"a43cc84c6a2406e8f23785c68a52b792d95eb91e2b43be40f7c814bf80dc5979"},"provenance":null,"requires-python":null,"size":240872,"upload-time":"2015-06-13T19:14:46.063288Z","url":"https://files.pythonhosted.org/packages/ba/18/c5bb52abb67194aabadfd61286b538ee8856c7cb9c0e92dd64c1b132bf5e/psutil-3.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"26b2cf4456e039f490f79457100564ff34718f4257b68dee53b42d17493f0187"},"provenance":null,"requires-python":null,"size":323299,"upload-time":"2015-06-13T19:15:53.089846Z","url":"https://files.pythonhosted.org/packages/0c/b1/fa44dd6ed19e8be6f9f05f776e824ce202822f5d6237093c54d6c5102888/psutil-3.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"32808b29473e788487ee28a65caaab1c9fbd44c2d654ce6d563a89f20e106996"},"provenance":null,"requires-python":null,"size":321705,"upload-time":"2015-06-13T19:16:01.370127Z","url":"https://files.pythonhosted.org/packages/62/4f/89c6ac53e424109639f42033d0e87c4de4ddb610060007c6d5f6081a0fba/psutil-3.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"37a9869ef17680e768bf32d7556252a04f426e5b1e6fa51d5af16305c8a701b6"},"provenance":null,"requires-python":null,"size":321688,"upload-time":"2015-06-13T19:16:11.540515Z","url":"https://files.pythonhosted.org/packages/d2/67/9c988331d40c445ebc9d29d95534ce3908f3949f6a84d640a6c125bc56e2/psutil-3.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py2.6.exe","hashes":{"sha256":"f29ee1aafa452cce77667e75f5e0345b678b8c091b288d0118840df30f303bed"},"provenance":null,"requires-python":null,"size":293522,"upload-time":"2015-06-13T19:15:19.130222Z","url":"https://files.pythonhosted.org/packages/10/19/9e2f8a305f5a6c01feee59dfeb38a73dc1ea4f4af0133cef9a36708f4111/psutil-3.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py2.7.exe","hashes":{"sha256":"7cbcf866faa23e5229ecfe44ff562f406b4806caae66cb255dbb327247e540aa"},"provenance":null,"requires-python":null,"size":293319,"upload-time":"2015-06-13T19:15:27.353152Z","url":"https://files.pythonhosted.org/packages/fc/0f/92e595cd2f2a80cead241d45b4ce4961e2515deff101644f3812c75e9bc7/psutil-3.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py3.3.exe","hashes":{"sha256":"b968771d3db5eef0c17ef6bed2d7756b8ac3cce40e11d5493824863d195dd8e3"},"provenance":null,"requires-python":null,"size":288278,"upload-time":"2015-06-13T19:15:35.880360Z","url":"https://files.pythonhosted.org/packages/fc/29/387c555f9dc38c6bb084a8df8936e607848de9e2e984dbf7eb2a298c1ceb/psutil-3.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.0.win32-py3.4.exe","hashes":{"sha256":"81ac6f54a27d091c75333f7c90082d028db45a1e78de59d28ca9f38cf6186395"},"provenance":null,"requires-python":null,"size":288253,"upload-time":"2015-06-13T19:15:44.871254Z","url":"https://files.pythonhosted.org/packages/fb/29/25ac80b589c0e56214ac64fdd8216992be162a2b2290f9b88b9a5c517cfd/psutil-3.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"data-dist-info-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"filename":"psutil-3.0.1-cp27-none-win32.whl","hashes":{"sha256":"bcb8d23121848953ed295f7e3c0875b0164ee98d3245060beb3623c59ff2a1bc"},"provenance":null,"requires-python":null,"size":85793,"upload-time":"2015-06-18T02:36:50.974286Z","url":"https://files.pythonhosted.org/packages/17/05/b2c807b470464fbe3d357734b68199451574fcd75431fd3e5c77be24b6e0/psutil-3.0.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"data-dist-info-metadata":{"sha256":"986bdfc454536c2a940c955834882e01a25de324bf458054673b43d6b47a00ee"},"filename":"psutil-3.0.1-cp27-none-win_amd64.whl","hashes":{"sha256":"ba56ec5c052489b7a7015c26ed3f917f2df4ffa9799266e86be41815bc358b80"},"provenance":null,"requires-python":null,"size":88128,"upload-time":"2015-06-18T02:37:08.778852Z","url":"https://files.pythonhosted.org/packages/38/bf/0b743c8a07265f2ecb203f8e60310571dcae33036aa6ba7aa16e2641ac7a/psutil-3.0.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp33-none-win32.whl","hashes":{"sha256":"23606e9b42760a8fdeada33281d0c3ce88df220949746e0ddf54d5db7974b4c6"},"provenance":null,"requires-python":null,"size":85819,"upload-time":"2015-06-18T02:36:56.905878Z","url":"https://files.pythonhosted.org/packages/b2/9c/b2c4373b9406eaf33654c4be828d9316ee780f4b3c19d0fa56f55eb64d61/psutil-3.0.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp33-none-win_amd64.whl","hashes":{"sha256":"ae4a7f51f40154d02ab1576e94377171a28cc83fc89c077c152f16ba3dae72f3"},"provenance":null,"requires-python":null,"size":88028,"upload-time":"2015-06-18T02:37:14.406512Z","url":"https://files.pythonhosted.org/packages/7a/59/1a9a10238226dbaed24b8d978e9cc743ac143504b3f4ad8f5e3a169e263a/psutil-3.0.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp34-none-win32.whl","hashes":{"sha256":"b7520db52c7c4e38cdd50bb11be02a826372d8002bf92bbe955823cac32c7f9d"},"provenance":null,"requires-python":null,"size":85783,"upload-time":"2015-06-18T02:37:03.210308Z","url":"https://files.pythonhosted.org/packages/ed/85/1d4d97ce4c9a8c6dd479f5f717694016651170d3731cdecf740db0e4eae3/psutil-3.0.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"data-dist-info-metadata":{"sha256":"98502550423dd5cf7f5bcfaed4c1d92354cc0353b2b9bf673992e42fa246dce5"},"filename":"psutil-3.0.1-cp34-none-win_amd64.whl","hashes":{"sha256":"1754d4118eaab16f299a37dafaf7d34111e9a8e5ac2a799e2bd9b1a5d9d1122b"},"provenance":null,"requires-python":null,"size":87982,"upload-time":"2015-06-18T02:37:20.490529Z","url":"https://files.pythonhosted.org/packages/1e/e6/0af7e190f74d6f959dfb87f2b56f4711271729952691f843fb91c5e06712/psutil-3.0.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.tar.gz","hashes":{"sha256":"3f213b9ceed3c3068a973e04d7a8b2a29d1076abcb5ef45382517bfc6b808801"},"provenance":null,"requires-python":null,"size":241539,"upload-time":"2015-06-18T02:33:52.119548Z","url":"https://files.pythonhosted.org/packages/aa/5d/cbd3b7227fe7a4c2c77e4031b6c43961563a3ecde2981190e5afe959be51/psutil-3.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"b0a2ed567b31f71ae2e893768f0da0d51d51d12714471d4b7431e70ff5e36577"},"provenance":null,"requires-python":null,"size":323471,"upload-time":"2015-06-18T02:36:04.537383Z","url":"https://files.pythonhosted.org/packages/9d/a4/815181cacd33f0ce62a3c3aa188af65bd3945888aa2f6c16a925837ca517/psutil-3.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"99c593cb459b54209cdb4aed4a607fa8b2920fbd4f3c5a9219a0ede114975758"},"provenance":null,"requires-python":null,"size":321879,"upload-time":"2015-06-18T02:36:14.693044Z","url":"https://files.pythonhosted.org/packages/08/b2/278ac09b03db15b9e51c3ae7f678b3fbf050e895a2eccab66d05017bdef9/psutil-3.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"8f803bfe00a763254581bb6a3d788b3332492fbc67dbf46ad5068b663e44f309"},"provenance":null,"requires-python":null,"size":321861,"upload-time":"2015-06-18T02:36:23.687685Z","url":"https://files.pythonhosted.org/packages/d8/66/d21041db114938ae22d4994ea31f2d8f1353aa61e5f0d0c6c4e185b016a7/psutil-3.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py2.6.exe","hashes":{"sha256":"4a19475c1d6071c685b38f85837f6e6daa2c6ccd4d0132ab840123deb8ea2372"},"provenance":null,"requires-python":null,"size":293700,"upload-time":"2015-06-18T02:35:31.083110Z","url":"https://files.pythonhosted.org/packages/99/67/980b4a9257abaa3f53a60a3441f759301a0aca2922d60e18a05d23fb1b0e/psutil-3.0.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py2.7.exe","hashes":{"sha256":"363d3dbd610ce7bcf7f13b0a31133ee231d0990e99315142ed37f6ba2c1a84e6"},"provenance":null,"requires-python":null,"size":293492,"upload-time":"2015-06-18T02:35:39.030138Z","url":"https://files.pythonhosted.org/packages/5f/64/b994ed73ab49d5c847d97c47600b539603ebf0d6cfd8d3575b80db7aefb5/psutil-3.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py3.3.exe","hashes":{"sha256":"fc7cfe1d6919cb67f4144947acfcefc099d7d8299dd88bb4d863e62c44d041b4"},"provenance":null,"requires-python":null,"size":288451,"upload-time":"2015-06-18T02:35:47.145538Z","url":"https://files.pythonhosted.org/packages/1f/11/4871e823ff0d5a302a7f8ece60358d20ba7fc1620c4c9e2d94e826e1ff0e/psutil-3.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.0.1.win32-py3.4.exe","hashes":{"sha256":"73091a80ed295f990ab377dfd8cd4f7f00e3abfffb5e500192f1ea9fa58de158"},"provenance":null,"requires-python":null,"size":288427,"upload-time":"2015-06-18T02:35:55.768442Z","url":"https://files.pythonhosted.org/packages/08/af/c78ef8dc09ac61a479968b0c912677d0a0cb138c5ea7813b2a196fa32c53/psutil-3.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp26-none-win32.whl","hashes":{"sha256":"399916a016503c9ae99fd6aafbba4628b86ebdee52d67034e8c3f26e88a3504b"},"provenance":null,"requires-python":null,"size":87753,"upload-time":"2015-07-15T00:41:13.293562Z","url":"https://files.pythonhosted.org/packages/4e/0a/ab710541d02ff3ce4169a0922e4412952332991c4c39a0ea9df20e9279b0/psutil-3.1.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp27-none-win32.whl","hashes":{"sha256":"71af7a30eb6ed694a3624330334bd12da28bffdbe813f4b1080fadeb86f5970f"},"provenance":null,"requires-python":null,"size":87559,"upload-time":"2015-07-15T00:41:27.810047Z","url":"https://files.pythonhosted.org/packages/db/87/34b52811b755db94a7dd123e5c0f1d257885535f08f5f185c17810214d55/psutil-3.1.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"data-dist-info-metadata":{"sha256":"74e797fa9b89ed58d856034a0b901f68c1d317dd41713af1d4e9bd93e2e19b2c"},"filename":"psutil-3.1.0-cp27-none-win_amd64.whl","hashes":{"sha256":"ada1cf324e6aba0affcb23c6fd959dae9f72de6ec135530788cbf17153d4fd3c"},"provenance":null,"requires-python":null,"size":90071,"upload-time":"2015-07-15T00:42:15.297263Z","url":"https://files.pythonhosted.org/packages/0b/7c/90869233a3e4056ddfdd1040d0e7722d3bb023c74b48bf10c09380c26eae/psutil-3.1.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp33-none-win32.whl","hashes":{"sha256":"0a313ebe14b9e277dfd151f4ad021012fb344dd51248e6de2aa1e7062d678541"},"provenance":null,"requires-python":null,"size":87569,"upload-time":"2015-07-15T00:41:43.765697Z","url":"https://files.pythonhosted.org/packages/f4/7c/56b718693e4c41b32af8bbe39160e8a3ea0ca12d3eece3dbbb8d4c046855/psutil-3.1.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp33-none-win_amd64.whl","hashes":{"sha256":"92a7f420bc97f899b5abab30392c23ba652304aec18415f2d1167da04dae9913"},"provenance":null,"requires-python":null,"size":89918,"upload-time":"2015-07-15T00:42:29.864336Z","url":"https://files.pythonhosted.org/packages/c7/5a/4046949e207b72b93540f3e19d699813fd35e290ccdf48080f332226b912/psutil-3.1.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp34-none-win32.whl","hashes":{"sha256":"8f5a0e859ae6dcc349914fb9ea0acc21cfd82a321d1c1b02d3d92c195f523ccd"},"provenance":null,"requires-python":null,"size":87592,"upload-time":"2015-07-15T00:42:00.678342Z","url":"https://files.pythonhosted.org/packages/09/34/09d53d29318a5fea88bd30d629595805064a0e3776e706eca2d79ceaebac/psutil-3.1.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"data-dist-info-metadata":{"sha256":"e5e4b772973543fffe4b2ffb66ad397284be77c3b6886db90b1fca8245b0d0b1"},"filename":"psutil-3.1.0-cp34-none-win_amd64.whl","hashes":{"sha256":"dcb4f208ec28fb72b35d1edf49aa51f2cc116b439aa40c4c415cbfe1fee54078"},"provenance":null,"requires-python":null,"size":89877,"upload-time":"2015-07-15T00:42:45.261251Z","url":"https://files.pythonhosted.org/packages/0b/f6/62592864eb064763989aa5830706034f9ad3c6ae2255fb7cae0c66b336a1/psutil-3.1.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.tar.gz","hashes":{"sha256":"4cdfeb2a328b6f8a2937f9b21f513c8aeda96dc076ecafda424f5c401dbad876"},"provenance":null,"requires-python":null,"size":246767,"upload-time":"2015-07-15T00:40:47.134419Z","url":"https://files.pythonhosted.org/packages/ce/d2/ab7f80718b4eafb2e474b8b410274d2c0d65341b963d730e653be9ed0ec8/psutil-3.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"6570fb3ddde83597e11c062e20ab86210ff84a1fa97e54bc8bda05e4cd34670a"},"provenance":null,"requires-python":null,"size":326179,"upload-time":"2015-07-15T00:42:09.118162Z","url":"https://files.pythonhosted.org/packages/26/f5/c76bf7ef62736913146b0482879705d1d877c9334092a0739f2b3bbae162/psutil-3.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"578a52f4b108857273d1e32de4d9bebf9b8f842f8c53ab3e242252cfc9bde295"},"provenance":null,"requires-python":null,"size":324540,"upload-time":"2015-07-15T00:42:24.223021Z","url":"https://files.pythonhosted.org/packages/00/51/2dc07e5618adb4a3676ab6c9c1759a3f268eda91808d58f45eb4dfd3d2c5/psutil-3.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"2aea29ca2a5ea318155fb856f24e6c7563c8741ccfeec862f0fd9af0f2d8ae87"},"provenance":null,"requires-python":null,"size":324490,"upload-time":"2015-07-15T00:42:38.312454Z","url":"https://files.pythonhosted.org/packages/da/76/dcefdcf88fd51becaff6c1ec0ba7566ca654a207fe6d69662723c645e3b0/psutil-3.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py2.6.exe","hashes":{"sha256":"271f1b6fcb4861d1b0fc7f612b2abaacb36c0f878fcc2908f1cf673337c3472c"},"provenance":null,"requires-python":null,"size":296215,"upload-time":"2015-07-15T00:41:08.168047Z","url":"https://files.pythonhosted.org/packages/3f/c2/f7ec0a70bc58c1918f814001682cca30f4b168f5b46dce913220e625dee6/psutil-3.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py2.7.exe","hashes":{"sha256":"1bde1cea6b7f9bd66202feee289c282b076c00419dc6404db357b05125f4d692"},"provenance":null,"requires-python":null,"size":296024,"upload-time":"2015-07-15T00:41:21.733811Z","url":"https://files.pythonhosted.org/packages/56/2f/c97adcba8f119a23d3580a3a95939c1a37d37d514b304d90912585a85521/psutil-3.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py3.3.exe","hashes":{"sha256":"667fa795ca5ccde216b769fc8572398598f1e0e2619f78605df1a4c75a475174"},"provenance":null,"requires-python":null,"size":290958,"upload-time":"2015-07-15T00:41:37.038168Z","url":"https://files.pythonhosted.org/packages/37/89/a949b02d66d600c45230a3a622f0d5f491182dbbc96fff9ffbcd869431bd/psutil-3.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.0.win32-py3.4.exe","hashes":{"sha256":"8e637fe2a23fad4f4ea8ae11402b593e09fc587b86a6ced40b6bc1017be8d978"},"provenance":null,"requires-python":null,"size":290975,"upload-time":"2015-07-15T00:41:53.144204Z","url":"https://files.pythonhosted.org/packages/53/3f/249ff2e418313f30a6dcc4995966725f72b00493848ffddeb72b506e8e50/psutil-3.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp26-none-win32.whl","hashes":{"sha256":"13a6377cc8d2859f846058170830127822877e05229c4a43aea893cdcb504d65"},"provenance":null,"requires-python":null,"size":87749,"upload-time":"2015-07-15T12:34:56.810625Z","url":"https://files.pythonhosted.org/packages/e1/9e/721afc99b6fe467b47fa2cad6899acc19b45dee32d30b498dc731b6c09ef/psutil-3.1.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp27-none-win32.whl","hashes":{"sha256":"5b7228cb69fdaea5aeb901704f5ecd21b7846aa60c2c8d408f22573fcbaa7e6f"},"provenance":null,"requires-python":null,"size":87554,"upload-time":"2015-07-15T12:35:15.647007Z","url":"https://files.pythonhosted.org/packages/07/60/c88366202816ba42b3d8e93e793c14d1ac5e71be30dd53c2d0117c106eec/psutil-3.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"data-dist-info-metadata":{"sha256":"cb2a855afe0d2280f15e0904acf47929db7a22fcf8be740f65cecf46586d4ca5"},"filename":"psutil-3.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"da7650e2f3fcf06419d5ad75123e6c68b9bf5ff2a6c91d4c77aaed8e6f444fc4"},"provenance":null,"requires-python":null,"size":90065,"upload-time":"2015-07-15T12:36:14.571710Z","url":"https://files.pythonhosted.org/packages/fa/5b/8834e22cc22b6b0e9c2c68e240ab69754bed7c4c5388fb65abfa716f4a67/psutil-3.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp33-none-win32.whl","hashes":{"sha256":"f3d68eb44ba49e24a18d6f7934463478294a49152f97fea2eefe1e1e1ee957f3"},"provenance":null,"requires-python":null,"size":87562,"upload-time":"2015-07-15T12:35:34.924344Z","url":"https://files.pythonhosted.org/packages/cb/96/0eb8eb289681364d2cda2a22a7d1abeb0196b321ab95694335dd178a5b35/psutil-3.1.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp33-none-win_amd64.whl","hashes":{"sha256":"f9be0ae975b55a3b5d5a8b769560096d76184b60a56c6e88ff6b7ebecf1bc684"},"provenance":null,"requires-python":null,"size":89916,"upload-time":"2015-07-15T12:36:34.374903Z","url":"https://files.pythonhosted.org/packages/eb/13/a38bc1e0ac6f7c42dddd9c17a206877befb822ba3af9c3b0dab9e85911a6/psutil-3.1.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp34-none-win32.whl","hashes":{"sha256":"8f25aad572bde88d5ee0b3a11a75ff2ae3c8b0a334c4128d6f8eb4fc95172734"},"provenance":null,"requires-python":null,"size":87574,"upload-time":"2015-07-15T12:35:55.507642Z","url":"https://files.pythonhosted.org/packages/02/10/439ec497e3e38a8c493d0c67c56e23d106b85c8b9f616e8df9ec6ce1e606/psutil-3.1.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"data-dist-info-metadata":{"sha256":"19405a3f0d3e28d54384ce148334aeef185226341d9cc2a81c2d2933432a1de3"},"filename":"psutil-3.1.1-cp34-none-win_amd64.whl","hashes":{"sha256":"4be182c273758dcdbd30827fdeecd889e27cb6a30238798e91bddeebc29cdc4f"},"provenance":null,"requires-python":null,"size":89865,"upload-time":"2015-07-15T12:36:55.016343Z","url":"https://files.pythonhosted.org/packages/ec/2e/8d98579399bc1979904455df182a063dd584b285ee8c141f3c94e7814c47/psutil-3.1.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.tar.gz","hashes":{"sha256":"d3290bd4a027fa0b3a2e2ee87728056fe49d4112640e2b8c2ea4dd94ba0cf057"},"provenance":null,"requires-python":null,"size":247284,"upload-time":"2015-07-15T12:33:47.020532Z","url":"https://files.pythonhosted.org/packages/8d/b3/954de176aa8e3a7782bae52ce938f24726c2c68d0f4c60d159271b6b293d/psutil-3.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"9c4fd3cc19bbc04eaa7ef3c61e3db26a41ac5e056f770977211d4569d0bf0086"},"provenance":null,"requires-python":null,"size":326261,"upload-time":"2015-07-15T12:36:07.064169Z","url":"https://files.pythonhosted.org/packages/e8/ac/7fb95ccc69ced76d0920e411b2fdfd3d38398c4bce53ec1dae92800df88a/psutil-3.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"e7cc26f661c9eaa9b32d0543dd7838daea72aad6e9f02fe73715ffd0dcb65170"},"provenance":null,"requires-python":null,"size":324622,"upload-time":"2015-07-15T12:36:27.201153Z","url":"https://files.pythonhosted.org/packages/2f/84/ae41f6bb61d4a93399c621218f99b761171a69a0c9163b9a72db1d53d62a/psutil-3.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"46cbfd86d6762e63c7df4ab0df889f6f2fffa9b5781ea3fc0431237f2a408382"},"provenance":null,"requires-python":null,"size":324571,"upload-time":"2015-07-15T12:36:47.165677Z","url":"https://files.pythonhosted.org/packages/88/d4/ca15a913ab43222e308774845317544e765718a9e56bd4efe5b3cedf1fbd/psutil-3.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py2.6.exe","hashes":{"sha256":"9efbd578d2f400dfe0ecab123b58d8af105854fdbb6222f841151e010e820b75"},"provenance":null,"requires-python":null,"size":296306,"upload-time":"2015-07-15T12:34:49.442980Z","url":"https://files.pythonhosted.org/packages/0c/f6/e81385c7ec989157eb68688a64a69c5a7477ff93d544893a9e1f251588b1/psutil-3.1.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py2.7.exe","hashes":{"sha256":"e0065e7cade4ac5ac70411674bc32326dee8d11c44469012a2b5164bf6dea97a"},"provenance":null,"requires-python":null,"size":296106,"upload-time":"2015-07-15T12:35:08.277861Z","url":"https://files.pythonhosted.org/packages/6b/fe/51596968f5a6a0970d9424021989f542d5aa715fe21d1a9c6bbbb0e377a9/psutil-3.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py3.3.exe","hashes":{"sha256":"c8ab17e07ea4907d2f9129254e82b6765ae08e61f0ce6dc8e2fc1faf145b166c"},"provenance":null,"requires-python":null,"size":291039,"upload-time":"2015-07-15T12:35:27.250487Z","url":"https://files.pythonhosted.org/packages/83/49/ff116fb9981ef04a5aed1c091ace117c214ed752d37be267ea4e2f28efad/psutil-3.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.1.1.win32-py3.4.exe","hashes":{"sha256":"3003d8be6e86eb6beb990863a88950f9b9fe53ccaae92edcd8efcd152d7451ea"},"provenance":null,"requires-python":null,"size":291056,"upload-time":"2015-07-15T12:35:47.023807Z","url":"https://files.pythonhosted.org/packages/7b/cd/accf3d7e37006bffe7a569e4fc587eb686d275a19a4e8a37a12930a1e2db/psutil-3.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"data-dist-info-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"filename":"psutil-3.2.0-cp27-none-win32.whl","hashes":{"sha256":"1493041336a591f22c77bcb815a399faf9bdac32f79f4de354eda3507a0d6d6b"},"provenance":null,"requires-python":null,"size":88077,"upload-time":"2015-09-02T11:56:33.437905Z","url":"https://files.pythonhosted.org/packages/5f/fc/5f317fd548909b1bbb111d462c072faf8af3938268f3e7dd3ab2f9181461/psutil-3.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"data-dist-info-metadata":{"sha256":"e8c3ed176a6ecb754b5289ef149667a6343dc0380cb33db608d4d556be0650f4"},"filename":"psutil-3.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"3744ee760dff697f45731a71e7902514aa043c99800cc8fabeb6bebc9dad973d"},"provenance":null,"requires-python":null,"size":90526,"upload-time":"2015-09-02T11:57:23.745435Z","url":"https://files.pythonhosted.org/packages/84/6c/7efbe64b42748125e7113a90e48c0da9859b7f0363ac85ca5617decbafee/psutil-3.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp33-none-win32.whl","hashes":{"sha256":"8836f77d2c4ae2935431ca66e445435b87b53b4db637fcceb438b78843239210"},"provenance":null,"requires-python":null,"size":88080,"upload-time":"2015-09-02T11:56:48.988091Z","url":"https://files.pythonhosted.org/packages/64/8e/0a06028a1ac093402885febf2aeb18093f1d28ae2110c7eb10b43e7554c1/psutil-3.2.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp33-none-win_amd64.whl","hashes":{"sha256":"b16eb62d9c21efaa2c9ac8a9f8b23bb7a695cb799b597edf4b1289ce8e6973ac"},"provenance":null,"requires-python":null,"size":90372,"upload-time":"2015-09-02T12:03:01.254324Z","url":"https://files.pythonhosted.org/packages/cd/29/a8383040200a3ebe0e985f54f35691cc078a1deb632abb5340d3deb5b7b7/psutil-3.2.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp34-none-win32.whl","hashes":{"sha256":"0ac1d68ab3c5a65641cbbb23d19deda466f73226f9d967f91436851995281777"},"provenance":null,"requires-python":null,"size":88096,"upload-time":"2015-09-02T11:57:08.035697Z","url":"https://files.pythonhosted.org/packages/07/c3/76a50982a82c0e9d93d9614a0cd06644c1d3406c9bb80a43f95abdd4ab97/psutil-3.2.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"data-dist-info-metadata":{"sha256":"86ea3a30e605b64b3e8a93353520057387c9224bf456a532eb4f25799e27b050"},"filename":"psutil-3.2.0-cp34-none-win_amd64.whl","hashes":{"sha256":"0b26ef262fe2d10185ab562cd0530af7f6d9a6744c631c44e64be94796f4ba2d"},"provenance":null,"requires-python":null,"size":90354,"upload-time":"2015-09-02T12:07:12.010031Z","url":"https://files.pythonhosted.org/packages/58/2d/8b7abb9b6f8956d9a6dfc3b1dffce27efab8c7c0497a6366e7fee444ae53/psutil-3.2.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.tar.gz","hashes":{"sha256":"06f9d255f8b12a6a04aa2b468ec453c539f54a464d110b3458c32b0152a5c943"},"provenance":null,"requires-python":null,"size":251988,"upload-time":"2015-09-02T11:59:23.849318Z","url":"https://files.pythonhosted.org/packages/1d/3a/d396274e6f086e342dd43401d4012973af98c00b3aabdb5cc4a432df660e/psutil-3.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"71fd8712715f8e6acc5bee5719a83a61a396067cf2bfb15b4d8f1f2955648637"},"provenance":null,"requires-python":null,"size":326895,"upload-time":"2015-09-02T11:57:17.538160Z","url":"https://files.pythonhosted.org/packages/e1/49/990073ab7e010965a7d0df5e48181d07c212edd7fafb890feda664ea9b3c/psutil-3.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py2.7.exe","hashes":{"sha256":"2a8b5878d4e787d81a1eeddcc09ff28d501a3ceb320c7fffa7e207da5d61d01c"},"provenance":null,"requires-python":null,"size":296802,"upload-time":"2015-09-02T11:56:26.879142Z","url":"https://files.pythonhosted.org/packages/0b/c5/d6ad511c3c17afa9837d08fc26d76e85dc83ebc304c6c7bec3970e74f240/psutil-3.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py3.3.exe","hashes":{"sha256":"adfc63ceede4e8f6bf21e4bdf6fc91f70f9612ec2b1bf9ad306828909bb71c52"},"provenance":null,"requires-python":null,"size":291738,"upload-time":"2015-09-02T11:56:41.826609Z","url":"https://files.pythonhosted.org/packages/e3/35/81842c6c4366d19c87d1a1fb4ad4e4d22a18aa9facaea8b6f12ccd4c1212/psutil-3.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.0.win32-py3.4.exe","hashes":{"sha256":"4098e0ed7930003ef15feb852e64f73180c17a651c4170fb5573f8c44622d068"},"provenance":null,"requires-python":null,"size":291748,"upload-time":"2015-09-02T11:56:58.479934Z","url":"https://files.pythonhosted.org/packages/e9/e8/5b432a0490328cfff86605b574d2aa31b1fac4e61587dff5a7f76d4cb95e/psutil-3.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp26-none-win32.whl","hashes":{"sha256":"a77230ecd6f42d0b549f8eb6aa105f14e4bc5908c754d6e10ff979c900934481"},"provenance":null,"requires-python":null,"size":88306,"upload-time":"2015-09-03T15:37:28.878155Z","url":"https://files.pythonhosted.org/packages/37/46/f348f7728dea66436abdfc9fa14ef017e0148c6bca08a822ee4dd7cb6d75/psutil-3.2.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp27-none-win32.whl","hashes":{"sha256":"9453b8ceb249d4d9ddc69153729761be340dfef9c99509390e4fb0f1fcbb3853"},"provenance":null,"requires-python":null,"size":88111,"upload-time":"2015-09-03T15:30:11.278302Z","url":"https://files.pythonhosted.org/packages/ba/27/f55ca7d15af50e731e9bbbff9b22fc31a40b786c02f85d173568e5084152/psutil-3.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"data-dist-info-metadata":{"sha256":"c06dad4d23110956ffef0ab97d2845cb62aba9d194019b18cf8e24cbd88c0781"},"filename":"psutil-3.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"014714beed46a66370834cebe0bbb53799bddc164f7f0149a4a70e2051f7bc1a"},"provenance":null,"requires-python":null,"size":90561,"upload-time":"2015-09-03T15:35:05.710499Z","url":"https://files.pythonhosted.org/packages/6b/ac/5da840018ce300a258925d4535a55a32b75236d5d777a8de6c3de18e71f3/psutil-3.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp33-none-win32.whl","hashes":{"sha256":"5c0daf045fd7d7f105863a5f9508d1698559ebbdfd70d7d8b6fe6fedde575735"},"provenance":null,"requires-python":null,"size":88117,"upload-time":"2015-09-03T15:32:19.746087Z","url":"https://files.pythonhosted.org/packages/c7/96/3ae14e4bf81f18f404bb5285fcda28e50ae6df87e91ad6bf45a9a4f51ac3/psutil-3.2.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp33-none-win_amd64.whl","hashes":{"sha256":"452622592564cd67f86808c8176720c1443d43e248cfd242d71cff559ed1424c"},"provenance":null,"requires-python":null,"size":90410,"upload-time":"2015-09-03T15:36:13.351055Z","url":"https://files.pythonhosted.org/packages/76/62/fe6f705cb331be5fcc97b268987527dcdb3f3aa104bf830b0ec8bf1e2ad4/psutil-3.2.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp34-none-win32.whl","hashes":{"sha256":"96379bee09d4c6b4d57d72cb7347dbc51b6847977f2fad01cdfefef3b53e44e3"},"provenance":null,"requires-python":null,"size":88131,"upload-time":"2015-09-03T15:33:36.571683Z","url":"https://files.pythonhosted.org/packages/31/ec/1a54f23c767e27dac09d2372f3522f88ef34f3a0ddd44c16122970259f6f/psutil-3.2.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"data-dist-info-metadata":{"sha256":"51cd3e3b33e3b710f799f247a23955f942e6e11d4882ee5e3f3af539eee619c8"},"filename":"psutil-3.2.1-cp34-none-win_amd64.whl","hashes":{"sha256":"7a7f4f2ed6d2835c48c24a81b251ba4f9b21f6bba2323291f8205c9ecb6f659d"},"provenance":null,"requires-python":null,"size":90387,"upload-time":"2015-09-03T15:36:29.262691Z","url":"https://files.pythonhosted.org/packages/2e/10/f1590ae942a6b8dd2bdeef6088e30e89b30161a264881b14134f3c4a3a0e/psutil-3.2.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.tar.gz","hashes":{"sha256":"7f6bea8bfe2e5cfffd0f411aa316e837daadced1893b44254bb9a38a654340f7"},"provenance":null,"requires-python":null,"size":251653,"upload-time":"2015-09-03T15:30:34.118573Z","url":"https://files.pythonhosted.org/packages/cd/5f/4fae1036903c01929c48ded6800a8705106ee20f9e39e3f2ad5d1824e210/psutil-3.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"e9a8a44f3847a0e20a54d321ed62de4e9cee5bc4e880e25fe88ae20cfa4e32b2"},"provenance":null,"requires-python":null,"size":327122,"upload-time":"2015-09-03T15:34:58.714500Z","url":"https://files.pythonhosted.org/packages/c5/af/4ab069ba93a037a4acf9bb84248daa44204a46687abc6a9f3a82ad8c5ee2/psutil-3.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"5a62c38852de4513f1816b9c431a94f02531619c1edc60a2cc163c8754f51c50"},"provenance":null,"requires-python":null,"size":325481,"upload-time":"2015-09-03T15:36:01.424492Z","url":"https://files.pythonhosted.org/packages/32/87/82e449ff9573dde3c78685b64ac3d17b5d19db11e976eab27c4dc5dca942/psutil-3.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"da898c0708b99b3892bfb7d5caebb447d14d03c7a655c55e484eb5fcc741c3ca"},"provenance":null,"requires-python":null,"size":325465,"upload-time":"2015-09-03T15:36:22.916532Z","url":"https://files.pythonhosted.org/packages/4b/11/f18b29033a0b383e67f664576eca59fbe8552a9fd97f9f22d6d0ff1c4951/psutil-3.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py2.6.exe","hashes":{"sha256":"0e5fe3d50f9f8d9a5216cfa23f56890aa0c6a6163869434001f4f2ba463dace5"},"provenance":null,"requires-python":null,"size":297224,"upload-time":"2015-09-03T15:37:22.791161Z","url":"https://files.pythonhosted.org/packages/c0/bb/ed28c191c4d9f27b60d9ea6bd7774b44d78778f0b1fb507ee1e789a490d7/psutil-3.2.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py2.7.exe","hashes":{"sha256":"9fb6f11bdd3fdbe1e611ae02b3ad3dff8f70ef6eaa694d13e8ad0906fd7a7261"},"provenance":null,"requires-python":null,"size":297025,"upload-time":"2015-09-03T15:30:14.327211Z","url":"https://files.pythonhosted.org/packages/9a/c1/075598067efefe25f6a2b0cf1b3eb896322597ee64ba097cc6611b89ada7/psutil-3.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py3.3.exe","hashes":{"sha256":"605cc7dbe2170e89f2f6709cf1577c8a02f89951fe4a0eb48e72530f605141ca"},"provenance":null,"requires-python":null,"size":291964,"upload-time":"2015-09-03T15:32:12.890526Z","url":"https://files.pythonhosted.org/packages/e0/ce/ff1db37cbdf6b3071e89afe4fced6f73d2cdf9c3a87696e7754d207e0ec5/psutil-3.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.1.win32-py3.4.exe","hashes":{"sha256":"0cd127239f527eae6c0f778dd41bb3ced84e6049b919713022c9b72e5f22a1c1"},"provenance":null,"requires-python":null,"size":291976,"upload-time":"2015-09-03T15:33:29.509014Z","url":"https://files.pythonhosted.org/packages/5d/a0/d624d4f5660a476821fe0d920a4c2e995a23151928b15cc3383379228f15/psutil-3.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp26-none-win32.whl","hashes":{"sha256":"5a8ce70327c0da578a31ebbf0042671ed9be6f4b6b022c02f03302b690074966"},"provenance":null,"requires-python":null,"size":88377,"upload-time":"2015-10-04T16:38:11.705751Z","url":"https://files.pythonhosted.org/packages/4d/af/5b8c2471ea942a4b6ee85706e9279284ae9dc86ee30b6f97db2d84a95433/psutil-3.2.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp27-none-win32.whl","hashes":{"sha256":"6c5809582d3d165511d2319401bd0f6c0e825d7853e49da59027c1fb8aa8f897"},"provenance":null,"requires-python":null,"size":88183,"upload-time":"2015-10-04T16:38:39.878475Z","url":"https://files.pythonhosted.org/packages/63/1e/a510f3f310b5f530336fbc708fb1456bf3e49e3b3d85c31d151b6e389c4f/psutil-3.2.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"data-dist-info-metadata":{"sha256":"7115f58a06724cf8a31f365d5561fc59f6d68d8e55e20b3d75bf373a45007f7d"},"filename":"psutil-3.2.2-cp27-none-win_amd64.whl","hashes":{"sha256":"37f1cc8fc7586cc930ea3737533d6d79c1f761d577fd1bb1bb5798ccd1543b53"},"provenance":null,"requires-python":null,"size":90637,"upload-time":"2015-10-04T16:40:05.379646Z","url":"https://files.pythonhosted.org/packages/e7/b7/f04d64a692159733ed383b4638abd9d3dc4538d4aacb5e193af02a3840a2/psutil-3.2.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp33-none-win32.whl","hashes":{"sha256":"f8fb145f8fa9e223696ff2f99924ea42538f3ad6b9738707292d840acbde528f"},"provenance":null,"requires-python":null,"size":88189,"upload-time":"2015-10-04T16:39:00.887284Z","url":"https://files.pythonhosted.org/packages/77/f3/6b3742040b634692393faf3a81e6c0e40366c22bc338ad3fc62ed21b157a/psutil-3.2.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp33-none-win_amd64.whl","hashes":{"sha256":"65c78ba625cf9761d5966603838cc959f396bd03536c480db69f8cf37bdf9994"},"provenance":null,"requires-python":null,"size":90471,"upload-time":"2015-10-04T16:40:27.009383Z","url":"https://files.pythonhosted.org/packages/59/33/3ccdbec4ef1452758ba80f711af46736717f63d73786744d6251afb68624/psutil-3.2.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp34-none-win32.whl","hashes":{"sha256":"3df8d3e32e2b4f7c2ea91014294844670eddb125ba76c24152c0a155a1f73b5b"},"provenance":null,"requires-python":null,"size":88202,"upload-time":"2015-10-04T16:39:39.989654Z","url":"https://files.pythonhosted.org/packages/62/6e/ee3597f32c650f744359e57fd18bcede773dd7465d392dabbb008bc79b48/psutil-3.2.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"data-dist-info-metadata":{"sha256":"93db84a195bf6aa1de88b86ddb7fc98d3600b0ecf0ff4ab69e447ca200c3a4b0"},"filename":"psutil-3.2.2-cp34-none-win_amd64.whl","hashes":{"sha256":"e321d3f029268bc8442a7ff214da43fe91041924898f5e23d88bfda7ecb81acc"},"provenance":null,"requires-python":null,"size":90463,"upload-time":"2015-10-04T16:40:56.120875Z","url":"https://files.pythonhosted.org/packages/ed/fe/f31bb708dfdecfbc59b946ecb9ee3379fe7a8183c37ea6c43d6f4da5117d/psutil-3.2.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"data-dist-info-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"filename":"psutil-3.2.2-cp35-none-win32.whl","hashes":{"sha256":"76c68c9005a2aa983fce440ef98b66e6f200f740f52064a90fdcc30d11771bc2"},"provenance":null,"requires-python":null,"size":90363,"upload-time":"2015-11-06T10:48:59.454097Z","url":"https://files.pythonhosted.org/packages/cb/79/fcedcf009ab9f8c605f2f345b1797b72134ecc6c9c9f786575e34b3471bc/psutil-3.2.2-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"data-dist-info-metadata":{"sha256":"826e3762fc7145422d64b4a51bb0f8ca6b3a05baed01f7ef3c10b391a0a6c865"},"filename":"psutil-3.2.2-cp35-none-win_amd64.whl","hashes":{"sha256":"d3ac8ad04a509819d7b5d58e453749a3ceb37253267dac6e8856ea7953e22ca0"},"provenance":null,"requires-python":null,"size":93288,"upload-time":"2015-11-06T10:50:14.699381Z","url":"https://files.pythonhosted.org/packages/03/c5/15e44d590afc788228e93cdacf55f98828f326de985242bbf03b3545b129/psutil-3.2.2-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.tar.gz","hashes":{"sha256":"f9d848e5bd475ffe7fa3ab1c20d249807e648568af64bb0058412296ec990a0c"},"provenance":null,"requires-python":null,"size":253502,"upload-time":"2015-10-04T16:39:43.138939Z","url":"https://files.pythonhosted.org/packages/dc/b2/ab65a2209b996c891209b8a7444a0c825125fba850efaec07b95bccb3ff5/psutil-3.2.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py2.7.exe","hashes":{"sha256":"1fca15005063b401cbf94cebe3c01ef6ba3d86ba563730d5d5d6be962a637cf4"},"provenance":null,"requires-python":null,"size":327220,"upload-time":"2015-10-04T16:39:56.198669Z","url":"https://files.pythonhosted.org/packages/01/7c/47b7ac498c9dd6ac9f9b4489d3bd9cea8158e774592661a7c956a815dc78/psutil-3.2.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py3.3.exe","hashes":{"sha256":"01a1f55819019ad13c288c41cb233e17a6ee648baf19591a70f6c2c2295dde6c"},"provenance":null,"requires-python":null,"size":325577,"upload-time":"2015-10-04T16:40:17.960471Z","url":"https://files.pythonhosted.org/packages/5d/89/b3bfca24d038b16af09055912e3a5bc35347ebeb0e6af322959b68dbf237/psutil-3.2.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win-amd64-py3.5.exe","hashes":{"sha256":"9afc68c02717fb4416f91b3c2da4c407756f683804383d1499cdc9e1512e7942"},"provenance":null,"requires-python":null,"size":242452,"upload-time":"2015-11-06T10:49:50.288504Z","url":"https://files.pythonhosted.org/packages/1d/0b/9582cadcba005f4eb0207107baeae7eb2382431fea5e4bc0ea7ce683430f/psutil-3.2.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py2.6.exe","hashes":{"sha256":"c7c516a83d072d1a375ed3a0b5a1b1b9307ad839011e8d30aa16b0f932f6c481"},"provenance":null,"requires-python":null,"size":297317,"upload-time":"2015-10-04T16:38:04.476936Z","url":"https://files.pythonhosted.org/packages/66/e4/bb85391bb46b607be0578e0a091bc064daeb2d1c2e80aa2dab89260dff00/psutil-3.2.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.3.exe","hashes":{"sha256":"5168f99f065f6116ad1e8529bd5dd5309815198c6250c9180ff6058c6a3641d9"},"provenance":null,"requires-python":null,"size":292060,"upload-time":"2015-10-04T16:38:46.104177Z","url":"https://files.pythonhosted.org/packages/8e/86/8f1e1c0ffc0530dca5e71777f04fb90833c92d3ffc1d075b8b546874eae5/psutil-3.2.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.4.exe","hashes":{"sha256":"d5c96aa591ba711dfdadb1ab7a0adf08c5e637644a21437f3a39a9e427aa969b"},"provenance":null,"requires-python":null,"size":292515,"upload-time":"2015-11-06T01:39:51.263901Z","url":"https://files.pythonhosted.org/packages/28/fc/08f1098976de5416cd15967d88e03297569e9a34ca875e7dee38ff9150f0/psutil-3.2.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.2.2.win32-py3.5.exe","hashes":{"sha256":"f0e88f94f9822fd34bcd927aba4bb606bcb0ad0dda1543c9333e8175d5c05822"},"provenance":null,"requires-python":null,"size":232367,"upload-time":"2015-11-06T10:48:42.065794Z","url":"https://files.pythonhosted.org/packages/1d/b8/b725f9bd884f75ce141a9e871a79b2bdd1b5f31e814fc4e396d9ff7c98a2/psutil-3.2.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp26-none-win32.whl","hashes":{"sha256":"584f0b29fcc5d523b433cb8918b2fc74d67e30ee0b44a95baf031528f424619f"},"provenance":null,"requires-python":null,"size":90099,"upload-time":"2015-11-25T18:49:50.211423Z","url":"https://files.pythonhosted.org/packages/91/75/c20c3b9f4d3feb3436d607f498744e46dd28b265b8a72509812322198c7c/psutil-3.3.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp26-none-win_amd64.whl","hashes":{"sha256":"28ca0b6e9d99aa8dc286e8747a4471362b69812a25291de29b6a8d70a1545a0d"},"provenance":null,"requires-python":null,"size":92645,"upload-time":"2015-11-25T18:50:32.375134Z","url":"https://files.pythonhosted.org/packages/6a/d1/0ce316e4346bcae9dd23911366d894eda65875b88ff447ec8f0402ce556b/psutil-3.3.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp27-none-win32.whl","hashes":{"sha256":"167ad5fff52a672c4ddc1c1a0b25146d6813ebb08a9aab0a3ac45f8a5b669c3b"},"provenance":null,"requires-python":null,"size":90131,"upload-time":"2015-11-25T01:20:43.015358Z","url":"https://files.pythonhosted.org/packages/91/73/1f55b4a19db535759fec5fdbdd0653d7192336557078e3ac9085d7d77cd1/psutil-3.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"data-dist-info-metadata":{"sha256":"5977c4a46aa367cb1f96ab1a6c70f8c803d8194d6a6440a31450ac202114431f"},"filename":"psutil-3.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"e6dea6173a988727bb223d3497349ad5cdef5c0b282eff2d83e5f9065c53f85f"},"provenance":null,"requires-python":null,"size":92586,"upload-time":"2015-11-25T01:22:19.444688Z","url":"https://files.pythonhosted.org/packages/a2/ab/d15a34c6b9090d58601541f8f5564f5b48d01e82f56e07593be969d529e7/psutil-3.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp33-none-win32.whl","hashes":{"sha256":"2af5e0a4aad66049955d0734aa4e3dc8caa17a9eaf8b4c1a27a5f1ee6e40f6fc"},"provenance":null,"requires-python":null,"size":90141,"upload-time":"2015-11-25T01:21:10.374023Z","url":"https://files.pythonhosted.org/packages/c5/1f/5038a2567f5853ea1e0fb55f795c30b339a318717573c5b0c85b8814d733/psutil-3.3.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp33-none-win_amd64.whl","hashes":{"sha256":"d9884dc0dc2e55e2448e495778dc9899c1c8bf37aeb2f434c1bea74af93c2683"},"provenance":null,"requires-python":null,"size":92432,"upload-time":"2015-11-25T01:22:39.035467Z","url":"https://files.pythonhosted.org/packages/b1/9c/a9cd75c8cfbac44397a2ca76430229c5496b21e0ab93cba5987d80e3f262/psutil-3.3.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp34-none-win32.whl","hashes":{"sha256":"e27c2fe6dfcc8738be3d2c5a022f785eb72971057e1a9e1e34fba73bce8a71a6"},"provenance":null,"requires-python":null,"size":90151,"upload-time":"2015-11-25T01:21:33.616930Z","url":"https://files.pythonhosted.org/packages/23/57/6a7c3ab4d04d055cada3b5511c40e0e699d8dd5d8217cae6fb68ae61dff6/psutil-3.3.0-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp34-none-win_amd64.whl","hashes":{"sha256":"65afd6fecc8f3aed09ee4be63583bc8eb472f06ceaa4fe24c4d1d5a1a3c0e13f"},"provenance":null,"requires-python":null,"size":92416,"upload-time":"2015-11-25T01:23:04.575877Z","url":"https://files.pythonhosted.org/packages/5d/a8/e62ec8105350c1e615ac84b084c7c8799d09e0d1b4530d3e68291dca8976/psutil-3.3.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp35-none-win32.whl","hashes":{"sha256":"ba1c558fbfcdf94515c2394b1155c1dc56e2bc2a9c17d30349827c9ed8a67e46"},"provenance":null,"requires-python":null,"size":91965,"upload-time":"2015-11-25T01:21:52.452732Z","url":"https://files.pythonhosted.org/packages/6e/6d/cf51e672eef1f1fbf9efce429d5411d4a2f3aa239e079b82531389562cd2/psutil-3.3.0-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"data-dist-info-metadata":{"sha256":"60f0487057f863a2f4cee79fc120f02b60168ae677fac14ba9ccc63127b37514"},"filename":"psutil-3.3.0-cp35-none-win_amd64.whl","hashes":{"sha256":"ba95ea0022dcb64d36f0c1335c0605fae35bdf3e0fea8d92f5d0f6456a35e55b"},"provenance":null,"requires-python":null,"size":94891,"upload-time":"2015-11-25T01:23:25.107121Z","url":"https://files.pythonhosted.org/packages/90/49/3726db12f0fa7ff8f7e5493cc128ee6b40f5720f7397a4ef01db9e28dd7b/psutil-3.3.0-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.tar.gz","hashes":{"sha256":"421b6591d16b509aaa8d8c15821d66bb94cb4a8dc4385cad5c51b85d4a096d85"},"provenance":null,"requires-python":null,"size":261983,"upload-time":"2015-11-25T01:20:55.681846Z","url":"https://files.pythonhosted.org/packages/fe/69/c0d8e9b9f8a58cbf71aa4cf7f27c27ee0ab05abe32d9157ec22e223edef4/psutil-3.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py2.6.exe","hashes":{"sha256":"326b305cbdb6f94dafbfe2c26b11da88b0ab07b8a07f8188ab9d75ff0c6e841a"},"provenance":null,"requires-python":null,"size":329214,"upload-time":"2015-11-25T18:50:19.881553Z","url":"https://files.pythonhosted.org/packages/a9/c1/7642d44312cffaa1b3efc6ac5252b7f1ab1c528903b55d56d7bd46805d92/psutil-3.3.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"9aede5b2b6fe46b3748ea8e5214443890d1634027bef3d33b7dad16556830278"},"provenance":null,"requires-python":null,"size":329153,"upload-time":"2015-11-25T01:22:03.853435Z","url":"https://files.pythonhosted.org/packages/bb/e0/f8e4e286bf9c075f0e9fb3c0b17cecef04cda5e91f4c54982b91b3baf338/psutil-3.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"73bed1db894d1aa9c3c7e611d302cdeab7ae8a0dc0eeaf76727878db1ac5cd87"},"provenance":null,"requires-python":null,"size":327512,"upload-time":"2015-11-25T01:22:31.545622Z","url":"https://files.pythonhosted.org/packages/fb/20/9438b78a3155b1eb480a4ea09dab6370f06e0a003cf43c3975743e0c9e8d/psutil-3.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"935b5dd6d558af512f42501a7c08f41d7aff139af1bb3959daa3abb859234d6c"},"provenance":null,"requires-python":null,"size":327497,"upload-time":"2015-11-25T01:22:51.620885Z","url":"https://files.pythonhosted.org/packages/ae/71/c68af8e9b05144de969da58e1bf5ebfe0859b1c83b827e05ae3116178bb1/psutil-3.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"4ca0111cf157dcc0f2f69a323c5b5478718d68d45fc9435d84be0ec0f186215b"},"provenance":null,"requires-python":null,"size":243943,"upload-time":"2015-11-25T01:23:16.182734Z","url":"https://files.pythonhosted.org/packages/bd/14/a67db75c827761bf55a50c6ce455cdf0fd7e75d1c7c395b7283359676288/psutil-3.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py2.6.exe","hashes":{"sha256":"b6f13c95398a3fcf0226c4dcfa448560ba5865259cd96ec2810658651e932189"},"provenance":null,"requires-python":null,"size":299025,"upload-time":"2015-11-25T18:49:29.675333Z","url":"https://files.pythonhosted.org/packages/ad/ea/d7c41ad9fab6e89263225c66971f9807a0396925dddf7c20901b637b99e2/psutil-3.3.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py2.7.exe","hashes":{"sha256":"ee6be30d1635bbdea4c4325d507dc8a0dbbde7e1c198bd62ddb9f43198b9e214"},"provenance":null,"requires-python":null,"size":299056,"upload-time":"2015-11-25T01:20:34.764583Z","url":"https://files.pythonhosted.org/packages/15/f7/a34370848c11d7d7933c0c107763ee470b54a7e48aa90a301919a3ad6757/psutil-3.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.3.exe","hashes":{"sha256":"dfa786858c268d7fbbe1b6175e001ec02738d7cfae0a7ce77bf9b651af676729"},"provenance":null,"requires-python":null,"size":293994,"upload-time":"2015-11-25T01:20:57.318743Z","url":"https://files.pythonhosted.org/packages/71/1e/af5675d52b426857441c29ad88d4fccfd55d300867ad02531d77991ab661/psutil-3.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.4.exe","hashes":{"sha256":"aa77f9de72af9c16cc288cd4a24cf58824388f57d7a81e400c4616457629870e"},"provenance":null,"requires-python":null,"size":294006,"upload-time":"2015-11-25T01:21:23.806352Z","url":"https://files.pythonhosted.org/packages/6d/41/cf5b54535ea052a32a76a8e8e56af817deb95f4ffde49277a52ded29763b/psutil-3.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.3.0.win32-py3.5.exe","hashes":{"sha256":"f500093357d04da8140d87932cac2e54ef592a54ca8a743abb2850f60c2c22eb"},"provenance":null,"requires-python":null,"size":233858,"upload-time":"2015-11-25T01:21:44.041656Z","url":"https://files.pythonhosted.org/packages/1e/1d/151535e51338efebe453a28d2f14d4d5b1e1f3ce54ccc63866c96dc7e1bd/psutil-3.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp26-none-win32.whl","hashes":{"sha256":"0b1382db1cf76d53fb1d6e5619b5f3c86126e11a933b200c21ed4fa7fe5037aa"},"provenance":null,"requires-python":null,"size":91763,"upload-time":"2016-01-15T12:34:15.511699Z","url":"https://files.pythonhosted.org/packages/8a/a4/6dfd46e45d06da1a4d42814dbbdcffe3a4fc7f9b655e1c2919ac960512c2/psutil-3.4.1-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp26-none-win_amd64.whl","hashes":{"sha256":"bcf212a926e8cffd3bec2acaeb584bf59a536e569d404bd8ea306f1752fbfc41"},"provenance":null,"requires-python":null,"size":94311,"upload-time":"2016-01-15T12:34:35.252561Z","url":"https://files.pythonhosted.org/packages/85/38/d9882d4e37f4b791bd949a1f45c620e0f2573bb4048eb16d59d469e97ec6/psutil-3.4.1-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp27-none-win32.whl","hashes":{"sha256":"1b8424eaa712fef7da41fc7f391b452e8991a641a54e49c4f46eb72ca2585577"},"provenance":null,"requires-python":null,"size":91570,"upload-time":"2016-01-15T12:25:47.323665Z","url":"https://files.pythonhosted.org/packages/cd/2d/760f774b1325037ea4ef85972f45fc9dee417da33ba225b21a0a8e512f5d/psutil-3.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"data-dist-info-metadata":{"sha256":"5fd1ef4aa7b3f11f37a72bb6da5e9ae73e666b2a5580c3bf58fe259cac90c4e8"},"filename":"psutil-3.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"46d7429bae3703a0f2980c0299d4d49ada733c7ebd2cfa4e29fa3e31b5b16014"},"provenance":null,"requires-python":null,"size":94024,"upload-time":"2016-01-15T12:29:47.181880Z","url":"https://files.pythonhosted.org/packages/13/06/0104f224dd52bf9e3fb3ef14f6b6b93e9fac72f562842d54445af041f3f0/psutil-3.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp33-none-win32.whl","hashes":{"sha256":"08f4ab9b720310890fa9337321a6e1e8aa525538636526be77e82653588df46b"},"provenance":null,"requires-python":null,"size":91580,"upload-time":"2016-01-15T12:26:59.466185Z","url":"https://files.pythonhosted.org/packages/65/22/f7121341bc75bff65000ecc0c5aad4f2a6d129506c26d5533ade2ca67349/psutil-3.4.1-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp33-none-win_amd64.whl","hashes":{"sha256":"9e52230373076d0ecdb4aec373afd342c576ab52e11c382e058ed0188181a352"},"provenance":null,"requires-python":null,"size":93869,"upload-time":"2016-01-15T12:30:39.415707Z","url":"https://files.pythonhosted.org/packages/b0/84/a9edadc49ef3dbb89298855ae069b18ec534ca9f79a9294de417b8e46571/psutil-3.4.1-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp34-none-win32.whl","hashes":{"sha256":"e658cd0e0ad7a2971b2eeb6ee4b1a0ad14245003ea47425846bc8c3e892fd567"},"provenance":null,"requires-python":null,"size":91584,"upload-time":"2016-01-15T12:28:02.007581Z","url":"https://files.pythonhosted.org/packages/b6/cd/59a87e4f10181ee228c4edc7d4927e3d62f652cff9f25f95a7e7e9ab3df0/psutil-3.4.1-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp34-none-win_amd64.whl","hashes":{"sha256":"9c3e1146003df43aec9274be4741371a06896d70d7d590eb882ad59de2c06120"},"provenance":null,"requires-python":null,"size":93858,"upload-time":"2016-01-15T12:31:25.406165Z","url":"https://files.pythonhosted.org/packages/30/06/cf0559d12ca5ded37e6a32b1671be57fad3bade7f24536b943851aa6393e/psutil-3.4.1-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp35-none-win32.whl","hashes":{"sha256":"3d3b2df184a31646a7e66cc48304f900a82c18ab3dc69d2d5f693ea97fca0572"},"provenance":null,"requires-python":null,"size":93406,"upload-time":"2016-01-15T12:28:48.357070Z","url":"https://files.pythonhosted.org/packages/c9/57/6e65ff27fa567cd9a7bfbc0a435e33293451b80865bc3a3a7b13c9bf7799/psutil-3.4.1-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"data-dist-info-metadata":{"sha256":"ea21e4b91d38833326191bf60eb600b6764ba491e5b44843eced5c91fcf75a03"},"filename":"psutil-3.4.1-cp35-none-win_amd64.whl","hashes":{"sha256":"820ed01d84ffcda1c613be80c09318d7560dd3505299c65bb99f101963bfc3dd"},"provenance":null,"requires-python":null,"size":96333,"upload-time":"2016-01-15T12:31:50.145506Z","url":"https://files.pythonhosted.org/packages/f0/f6/ccf16168a627d10ffbd80120cd2c521c4c9ecdb4545e402b7deca79f93ac/psutil-3.4.1-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.tar.gz","hashes":{"sha256":"c7443659674c87d1f9feecee0dfeea765da02181c58d532e0633337e42180c89"},"provenance":null,"requires-python":null,"size":271657,"upload-time":"2016-01-15T12:22:39.420430Z","url":"https://files.pythonhosted.org/packages/a5/56/c64187a9a6889e622f7ec687254cdb3cc3c706e11bba9244e6ac781ecf38/psutil-3.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py2.6.exe","hashes":{"sha256":"e88e43423af984d7f2ecf8babf9d861ff59436794b0fdd2f85e9ea6bf7af6627"},"provenance":null,"requires-python":null,"size":331136,"upload-time":"2016-01-15T12:34:26.229804Z","url":"https://files.pythonhosted.org/packages/f7/90/53adfe2804c9cde062eb5014d88f0d067690fe1457ad2f49a2a553767689/psutil-3.4.1.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"3c08e2c200b222a92a4ecaa8055a48e27e7cfe82d9bf6402b52dd82413a786ed"},"provenance":null,"requires-python":null,"size":330798,"upload-time":"2016-01-15T12:29:26.473954Z","url":"https://files.pythonhosted.org/packages/66/9b/2b58fdab300e5f2a20c3999c485692cfa73cc9d4e50770a19cc871f92743/psutil-3.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"d03b8d081a281ebaa2122f259f7c0b3a464b2b98a3c221b9a54bfb0840355a9f"},"provenance":null,"requires-python":null,"size":329156,"upload-time":"2016-01-15T12:30:04.062459Z","url":"https://files.pythonhosted.org/packages/4c/26/695fa5b3578248f424d9a8e5bf2aafc6f706aeb7ec21ee31a5ebc2f79660/psutil-3.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"66a243c4b9ad93059be391a18e3f75e015ad70b220df4f7f30f9f578b89f27ad"},"provenance":null,"requires-python":null,"size":329140,"upload-time":"2016-01-15T12:31:00.945171Z","url":"https://files.pythonhosted.org/packages/25/63/54f2ba7cf31bb936b9c2cd7a77fd40a698fb232cd7c95c1ce997295a5954/psutil-3.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win-amd64-py3.5.exe","hashes":{"sha256":"4ee8641803d68a2e48952951336f9474a8914854da088fca673d67a91da7f9a4"},"provenance":null,"requires-python":null,"size":245586,"upload-time":"2016-01-15T12:31:39.398299Z","url":"https://files.pythonhosted.org/packages/43/54/f2d3b8845105fe5f55d5f0fde36773ab94fe1e35a0f4a5219adc818d586b/psutil-3.4.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py2.6.exe","hashes":{"sha256":"a4de0daf0dc7aeff6d45c6a1c782ef30d2b4fc6495196acabcb5cde2fb9b5a74"},"provenance":null,"requires-python":null,"size":300946,"upload-time":"2016-01-15T12:33:59.097771Z","url":"https://files.pythonhosted.org/packages/9e/34/53e1e85df97508df1b3eea711ab2809cc8f01b20e3b2341645673eb5d835/psutil-3.4.1.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py2.7.exe","hashes":{"sha256":"0efcecb6fcc21d83e9d4354754c6b8a8deb47a5fa06ec5d09fcf9799719eeac2"},"provenance":null,"requires-python":null,"size":300700,"upload-time":"2016-01-15T12:25:12.391548Z","url":"https://files.pythonhosted.org/packages/2f/4c/a07a53ff938e3bbc2ba73e4a484af8d1e02054b0bfcaf0f6d30117187d9f/psutil-3.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.3.exe","hashes":{"sha256":"62d0b529e40262293f39d7455db24f7ee297a1a3fe7f0e3e5923ae8168bd865c"},"provenance":null,"requires-python":null,"size":295638,"upload-time":"2016-01-15T12:26:24.412799Z","url":"https://files.pythonhosted.org/packages/39/6c/03ade7ba131b3952d916ed26c277418234bec0c9a5dfad513b9a5bb51046/psutil-3.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.4.exe","hashes":{"sha256":"6102294d6150f2c072dbc0166348389e8fa5d14a769ad118b697cda5b31c3381"},"provenance":null,"requires-python":null,"size":295651,"upload-time":"2016-01-15T12:27:36.577070Z","url":"https://files.pythonhosted.org/packages/52/d7/c2e9e0cb21482304e39a7681066c32c50e984f109bcda5929a84af926d70/psutil-3.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.1.win32-py3.5.exe","hashes":{"sha256":"0ffd99167272bb80c6ecf68f4c3d3176bef0f8c2a68f7e2787cab32413830023"},"provenance":null,"requires-python":null,"size":235502,"upload-time":"2016-01-15T12:28:24.463783Z","url":"https://files.pythonhosted.org/packages/1c/06/4d0ec9a6427db9c3b9885c4d724ca299746519b2ee61b724665d49e352c6/psutil-3.4.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp26-none-win32.whl","hashes":{"sha256":"2ac75c13657ab18eac0014e3f4c80def16978507b30e7719e46042ec93316bb0"},"provenance":null,"requires-python":null,"size":91920,"upload-time":"2016-01-20T16:25:20.303966Z","url":"https://files.pythonhosted.org/packages/be/b7/999dcbee8cc5ae32e64b2d0c9d588a3f5a441a07404772af83e86f3c8bc7/psutil-3.4.2-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp26-none-win_amd64.whl","hashes":{"sha256":"162f76140ca09490b9d218840bd641cbd1439245dcc2a9dd41f86224ed19490c"},"provenance":null,"requires-python":null,"size":94467,"upload-time":"2016-01-20T16:27:40.461506Z","url":"https://files.pythonhosted.org/packages/60/97/f9ea4fa7a4914350d15347a6a583c8a185643bb6bd5dc76d13e9d7dfc150/psutil-3.4.2-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp27-none-win32.whl","hashes":{"sha256":"b5f4bfdaa6389552501253b13b6022b7e3d715e4dca4b5cc1808f58cca181359"},"provenance":null,"requires-python":null,"size":91721,"upload-time":"2016-01-20T16:25:38.512050Z","url":"https://files.pythonhosted.org/packages/d4/19/4e5c376587076c969784762de8024bb30168a548b402e1b432221c5b97b1/psutil-3.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"data-dist-info-metadata":{"sha256":"13402cacd1df223d4b15886666e72dc0e55f16091f011fc3f0c83e49b8034134"},"filename":"psutil-3.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"9267e9bccb5c8b1c5ca872eb1caf88ba0ae47e336eb200be138f51d9f75e1113"},"provenance":null,"requires-python":null,"size":94177,"upload-time":"2016-01-20T16:27:58.779061Z","url":"https://files.pythonhosted.org/packages/d3/19/39f42cdfba58ab593d24f49ffc073c07b9b34ff7d5ba079b975018002e51/psutil-3.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp33-none-win32.whl","hashes":{"sha256":"413800a94815e6bf3e3227823e4d46b06c63bd22ab9e5af112b9220af9a9c9d8"},"provenance":null,"requires-python":null,"size":91738,"upload-time":"2016-01-20T16:25:59.987045Z","url":"https://files.pythonhosted.org/packages/8e/7a/8ba0c9da039b5733edbe17321f0546f08a7066861ffcdb83c31eb061e8f1/psutil-3.4.2-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp33-none-win_amd64.whl","hashes":{"sha256":"45535c18a0f261f90ff1ebb7d74c5e88d582cfb2006e4588498b9c0c9da5acb3"},"provenance":null,"requires-python":null,"size":94024,"upload-time":"2016-01-20T16:28:42.605657Z","url":"https://files.pythonhosted.org/packages/34/a7/94fc00a023ede02c3a7f525c63997a23c22434cbed65738ee3ef8939e084/psutil-3.4.2-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp34-none-win32.whl","hashes":{"sha256":"c9ef9a08254c251858cf747703e6fd75fe6e9549b1e040bb4a501feaf44a5a75"},"provenance":null,"requires-python":null,"size":91749,"upload-time":"2016-01-20T16:26:31.788083Z","url":"https://files.pythonhosted.org/packages/dc/8b/df5d7dcfe8fc5db0c303e518ce12b7117cb70e1cbb29c0396ea6e36fc7a2/psutil-3.4.2-cp34-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp34-none-win_amd64.whl","hashes":{"sha256":"0bf8925c3d252178c47bd8f29aff99c57a56f94513354b60069b457ca04bc25b"},"provenance":null,"requires-python":null,"size":94004,"upload-time":"2016-01-20T16:29:27.043903Z","url":"https://files.pythonhosted.org/packages/1c/cf/c9ce0014f43f74b1ce72c004c8f2eda68339cbc19117d9f090ee14afce3e/psutil-3.4.2-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp35-none-win32.whl","hashes":{"sha256":"461d1431a14e4da5e687cfdc2a8576b1f0e3bc658694ab9c6ef2fa1e4c1a4871"},"provenance":null,"requires-python":null,"size":93563,"upload-time":"2016-01-20T16:27:20.576920Z","url":"https://files.pythonhosted.org/packages/de/51/d1ab564dfe98d5fcbccfcab0afdedb269f7266192721e94688ab3956b123/psutil-3.4.2-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"data-dist-info-metadata":{"sha256":"23ac4ea4417292cac0684989ffba547b75ac89f3a6ef7965183ec9e389edaa89"},"filename":"psutil-3.4.2-cp35-none-win_amd64.whl","hashes":{"sha256":"23d4ea79fea3de81daf9460662e49ff718555779b2f5e5e3610648c0a8cafecc"},"provenance":null,"requires-python":null,"size":96484,"upload-time":"2016-01-20T16:29:53.151921Z","url":"https://files.pythonhosted.org/packages/89/d8/dc9ce7b8862ab2d86975dd5199791b0ab2b2168fc2389223a216c2da1d45/psutil-3.4.2-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.tar.gz","hashes":{"sha256":"b17fa01aa766daa388362d0eda5c215d77e03a8d37676b68971f37bf3913b725"},"provenance":null,"requires-python":null,"size":274361,"upload-time":"2016-01-20T16:26:46.533423Z","url":"https://files.pythonhosted.org/packages/7b/58/2675697b6831e6ac4b7b7bc4e5dcdb24a2f39f8411186573eb0de16eb6d5/psutil-3.4.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py2.6.exe","hashes":{"sha256":"3716cb36373ecfd033c148c8e8e22d815a9b682c87538c5bde2a3faca1a44705"},"provenance":null,"requires-python":null,"size":331279,"upload-time":"2016-01-20T16:27:30.129391Z","url":"https://files.pythonhosted.org/packages/6f/52/26cefb84d714ecdf39f6d4ea62af49af731cf55d8937a252226de41d3fb0/psutil-3.4.2.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py2.7.exe","hashes":{"sha256":"9eba153441fabd6677f9dec95eedbfdcf4fe832a43b91c18f2c15bfd0a12b6c0"},"provenance":null,"requires-python":null,"size":330991,"upload-time":"2016-01-20T16:27:49.025596Z","url":"https://files.pythonhosted.org/packages/1f/85/817b298f6865d7a140897882015096ab25514e113c98ba3896b2e2c0425c/psutil-3.4.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.3.exe","hashes":{"sha256":"2ffc77ec7452675db45174f77e65bfc9abd5780e696c4dd486fff89e18ef104a"},"provenance":null,"requires-python":null,"size":329349,"upload-time":"2016-01-20T16:28:23.729829Z","url":"https://files.pythonhosted.org/packages/2b/05/ccb8e8dc272a6aa126a6066583102b78df8939aeffd910a3ea28a51d48af/psutil-3.4.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.4.exe","hashes":{"sha256":"6b576ea8faa312700953de30b92ff49dcd966dcdbf2e039c3655077826b59812"},"provenance":null,"requires-python":null,"size":329334,"upload-time":"2016-01-20T16:29:12.322779Z","url":"https://files.pythonhosted.org/packages/8f/0e/9b3eedad9ea2aa8e51c3ca6aa6485c0ec85bfc73925fbd4d82bbe03ead18/psutil-3.4.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win-amd64-py3.5.exe","hashes":{"sha256":"2a987c57ddb06a1e67f75a4dd34d2962f8675c3d60b2104da2d60fdaa378b50f"},"provenance":null,"requires-python":null,"size":245779,"upload-time":"2016-01-20T16:29:45.537968Z","url":"https://files.pythonhosted.org/packages/2f/bb/5483a7a54dfaedcd5bc6d0f9f8beef21d96785589e10d09e246f7092cfe1/psutil-3.4.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py2.6.exe","hashes":{"sha256":"87b657f1021ab4155669f77baf9557657a015b0762854702d64ee7cfa19d5ae2"},"provenance":null,"requires-python":null,"size":301089,"upload-time":"2016-01-20T16:25:11.034218Z","url":"https://files.pythonhosted.org/packages/2e/9b/2bb0317a5113b4a3d597a9bcb94cafacb52f15a10631b1f0eb781ceb8e7a/psutil-3.4.2.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py2.7.exe","hashes":{"sha256":"d837d654a78fcc6cf7338fc3c3f025e5a43cf646d4d6cf180f0f3573ef255844"},"provenance":null,"requires-python":null,"size":300894,"upload-time":"2016-01-20T16:25:29.293012Z","url":"https://files.pythonhosted.org/packages/8c/3b/bf4d0698153784231768aa79255f1641efde680c4d178ba327546eba69df/psutil-3.4.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.3.exe","hashes":{"sha256":"ef756512c86cf24916f47b2209ff5dc69ef4d5ff8b3b0229863aab3537af58a1"},"provenance":null,"requires-python":null,"size":295833,"upload-time":"2016-01-20T16:25:50.417672Z","url":"https://files.pythonhosted.org/packages/50/be/c4911ae27c944e12183d9ba844ff0eee706b5208f92e4929d8120b79448e/psutil-3.4.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.4.exe","hashes":{"sha256":"13917c61de33518fcdca94a8f1005c4bb0be1f106af773de8c12d6a5a3f349ae"},"provenance":null,"requires-python":null,"size":295845,"upload-time":"2016-01-20T16:26:17.574774Z","url":"https://files.pythonhosted.org/packages/b5/d9/9a15af2703d8a0d7b685511df811fc4930b12d7b85b96573e843a0ba1067/psutil-3.4.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-3.4.2.win32-py3.5.exe","hashes":{"sha256":"75c4484f0e1038c1a37ae37fc80f5b59b456e363c696ed889027e79a831853ec"},"provenance":null,"requires-python":null,"size":235696,"upload-time":"2016-01-20T16:27:12.935221Z","url":"https://files.pythonhosted.org/packages/2c/74/46cf554a4a8d7d2367f058e6c90ba26a66e52e818812ec6de53a5013bd87/psutil-3.4.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp26-none-win32.whl","hashes":{"sha256":"0661261b634f01ec2568136fedf29382f5c94678c34f56b4137b1d019085ca6f"},"provenance":null,"requires-python":null,"size":154479,"upload-time":"2016-02-17T16:42:58.173240Z","url":"https://files.pythonhosted.org/packages/72/e2/24700d1a099dcd824ca7305cf439625a457221459494e677e7649a2f228b/psutil-4.0.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp26-none-win_amd64.whl","hashes":{"sha256":"b613a9fb5c3d2b16c65df3121aa369a28caed83391883bc24918cf16c5de495b"},"provenance":null,"requires-python":null,"size":156749,"upload-time":"2016-02-17T16:45:09.428253Z","url":"https://files.pythonhosted.org/packages/62/c0/1adb11a832d5aab8a984702a4f6fc08e5698fa4bbc8dc6eddac1c711c7ab/psutil-4.0.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-cp27m-win32.whl","hashes":{"sha256":"3eb6bc7e8d92777deb4288178c25455e21109033bb54ec475485b611e92d3b42"},"provenance":null,"requires-python":null,"size":154302,"upload-time":"2016-02-17T16:43:23.863441Z","url":"https://files.pythonhosted.org/packages/e8/c3/542bc833b743e952cbf99017ecb60add0ad3725a82e942b25aa5de523f8c/psutil-4.0.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"c94193f38aa3bc35fd5dbcd24653d1f683c88ec8030997d1d56f92207ba7c523"},"provenance":null,"requires-python":null,"size":156487,"upload-time":"2016-02-24T17:23:02.172281Z","url":"https://files.pythonhosted.org/packages/32/1b/5f3cc96374c4eac441e96bb8698556c6c48eacfdcf843093bebcfd8ce56b/psutil-4.0.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"data-dist-info-metadata":{"sha256":"f4174370ba76a8fc971e342367fb6df5d587165b15b69cf652d5870ad0386329"},"filename":"psutil-4.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"cb969d3c77db8810aba45e8a04e0b2851cd088e338be2430e1ff452f4e06007c"},"provenance":null,"requires-python":null,"size":156486,"upload-time":"2016-02-17T16:45:40.145586Z","url":"https://files.pythonhosted.org/packages/94/37/dc09e24aa80016ddeaff235d2f724d8aac9813b73cc3bf8a7fe3d1878315/psutil-4.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-cp33m-win32.whl","hashes":{"sha256":"6a372681382b523bc837ee2eff6a84ded0f85b013b7c29ea6211bc928c7cc656"},"provenance":null,"requires-python":null,"size":154244,"upload-time":"2016-02-24T17:21:40.946801Z","url":"https://files.pythonhosted.org/packages/a0/8a/b9352e0daf69b501296715e0fca1b49d861130eb66156ce3b12aeeb039e4/psutil-4.0.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"2bbb75fc2549965b457f313cbdfb98a00624f25fcb36e075322bb8b8912d83b5"},"provenance":null,"requires-python":null,"size":156393,"upload-time":"2016-02-24T17:23:25.807132Z","url":"https://files.pythonhosted.org/packages/4b/77/0fefa732947da69cba7f2580285eff553fe4a416314234f809901bede361/psutil-4.0.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-none-win32.whl","hashes":{"sha256":"d6219c89940d745b614716be7c906660f2108a1d84b8ffc720922596b8306e23"},"provenance":null,"requires-python":null,"size":154245,"upload-time":"2016-02-17T16:43:48.027623Z","url":"https://files.pythonhosted.org/packages/1f/d9/34fb4fab5f1bbfeddc76675b1b5ca00b45ef490e63295af33542cedcd26b/psutil-4.0.0-cp33-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp33-none-win_amd64.whl","hashes":{"sha256":"a64bb22e264f91a6d80cf8fdd813bd4fdd349dc367b363d517cf8ae1bc2c5db0"},"provenance":null,"requires-python":null,"size":156399,"upload-time":"2016-02-17T16:46:09.673427Z","url":"https://files.pythonhosted.org/packages/97/03/b9485635cb38dfad854754625422a49f434f53f214bff4885580f0fb21e6/psutil-4.0.0-cp33-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-cp34m-win32.whl","hashes":{"sha256":"a521266ac13485772987f00342b53cb230cde98ce91d61154860ba4109fe2ebe"},"provenance":null,"requires-python":null,"size":154269,"upload-time":"2016-02-17T16:44:14.936699Z","url":"https://files.pythonhosted.org/packages/73/32/6399071b097f1251f6fa12770b30a67d5b3c9c0c76e81eacbb6139e1bf6d/psutil-4.0.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"b559b8e8a85cde929e01e94e9635649e8641a88b2d077714933dc7723a967020"},"provenance":null,"requires-python":null,"size":156390,"upload-time":"2016-02-24T17:23:50.194021Z","url":"https://files.pythonhosted.org/packages/71/d7/878b77bad61bd94f4454536e823b6a48cd0af0f23b1506a2c8a49b2578cd/psutil-4.0.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp34-none-win_amd64.whl","hashes":{"sha256":"02d7291f81e78c506ac2b5481aa9dc6d3888195484ac114ac984b37477f60929"},"provenance":null,"requires-python":null,"size":156397,"upload-time":"2016-02-17T16:46:44.626238Z","url":"https://files.pythonhosted.org/packages/ea/22/5f44e6eaa1e82f5a1497f3dfcf045e1998fca36d70de8a370ec96ce0f789/psutil-4.0.0-cp34-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-cp35m-win32.whl","hashes":{"sha256":"7906302696960a6a788bb8fe1165b4ccd0156553b8a2f61640fd45a836d39024"},"provenance":null,"requires-python":null,"size":156177,"upload-time":"2016-02-24T17:22:25.142667Z","url":"https://files.pythonhosted.org/packages/e2/fe/a5ec73e62878cc2d0451b7029f4406647435dd8036ab15d6ed2fd42558bf/psutil-4.0.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f4214bdb2e96374b4c4a3a818bd8c7867f94571d33b91867b6dfd5f9b328c8ac"},"provenance":null,"requires-python":null,"size":158783,"upload-time":"2016-02-24T17:24:26.439061Z","url":"https://files.pythonhosted.org/packages/1d/a7/9300ad3d4071c191894073a94217ed5c0ca9604c782bdbf083bbedfa9cb1/psutil-4.0.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-none-win32.whl","hashes":{"sha256":"4a1631cb8c4de2b6c9b4b16f8800d43de23c683805f7b6a5aec1c268a73df270"},"provenance":null,"requires-python":null,"size":156183,"upload-time":"2016-02-17T16:44:42.458015Z","url":"https://files.pythonhosted.org/packages/14/f0/a2436cb642ecfec0bfb6338e5fa26581d4dbcf1a00f7d9fe99380eb6779f/psutil-4.0.0-cp35-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"data-dist-info-metadata":{"sha256":"d2287fe3ce0e3872765b52193af0ec6f19279df57903b85d13961ca84449ba60"},"filename":"psutil-4.0.0-cp35-none-win_amd64.whl","hashes":{"sha256":"994839b6d99acbf90914fddf2e2817aaffb67ceca5d10134319267e3ffe97258"},"provenance":null,"requires-python":null,"size":158787,"upload-time":"2016-02-17T16:47:18.920483Z","url":"https://files.pythonhosted.org/packages/e8/2a/e215824c785d77119af61802bbb4d16dacc26ec0687709274afa3ac039fa/psutil-4.0.0-cp35-none-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.tar.gz","hashes":{"sha256":"1a7c672f9ee79c84ff16b8de6f6040080f0e25002ac47f115f4a54aa88e5cfcd"},"provenance":null,"requires-python":null,"size":293800,"upload-time":"2016-02-17T16:41:45.938066Z","url":"https://files.pythonhosted.org/packages/c4/3b/44bcae6c0fc53362bb7325fde25a73b7fd46541b57c89b7556ca81b08e7e/psutil-4.0.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py2.6.exe","hashes":{"sha256":"61bf81cbe84e679a5b619e65775b0674b2c463885e49ddab73778198608198c5"},"provenance":null,"requires-python":null,"size":394157,"upload-time":"2016-02-17T16:45:00.666953Z","url":"https://files.pythonhosted.org/packages/86/50/6303a28a4ab5c9b6b9ef74eef70b141d5bd743ab096c58d225b6212fa057/psutil-4.0.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"23618cbc04e2431d9c4d97f56ab8b4e2e35366c9a9a6e1ef89a3a7287d359864"},"provenance":null,"requires-python":null,"size":393901,"upload-time":"2016-02-17T16:45:21.822412Z","url":"https://files.pythonhosted.org/packages/59/82/93052d6359addea338c528ebd50254806d62bc2b2d1ad1303c49d85162f9/psutil-4.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"b6f16c71be03495eeb4772c1f3f926213e3ea82ea7779bd1143229e6b419760b"},"provenance":null,"requires-python":null,"size":392318,"upload-time":"2016-02-17T16:45:57.189438Z","url":"https://files.pythonhosted.org/packages/e6/14/9ac37705e0753732c7707b000d1e076daac95ee02f35fd43ce906235ea1f/psutil-4.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"24b41e436afbcecb07e485e58a52effdbd7b8065ad8a2e4d555b6d88907f19b7"},"provenance":null,"requires-python":null,"size":392315,"upload-time":"2016-02-17T16:46:29.967466Z","url":"https://files.pythonhosted.org/packages/77/a9/ff7c29d2e244f5bdc7654a626cbfcccd401e78df6e9388713f322c7aa7c7/psutil-4.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win-amd64-py3.5.exe","hashes":{"sha256":"88edc0e7bfa672c245df74b1ac3b59db432cd75e5704beccc268e177ac2ffbbc"},"provenance":null,"requires-python":null,"size":308678,"upload-time":"2016-02-17T16:47:07.280714Z","url":"https://files.pythonhosted.org/packages/cc/1b/863bee07da70fe61cae804333d64242d9001b54288e8ff54e770225bbc0a/psutil-4.0.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py2.6.exe","hashes":{"sha256":"882a8ac29b63f256f76465d8fcd6e9eaeb9c929acdac26af102da97d66b2b619"},"provenance":null,"requires-python":null,"size":364245,"upload-time":"2016-02-17T16:42:49.267819Z","url":"https://files.pythonhosted.org/packages/41/39/6ea85cb0c748aae2943144118f1696004f5a99c54dab1fc635cffbb0d06c/psutil-4.0.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py2.7.exe","hashes":{"sha256":"bf3b2e305ca7408df40156c9aa6261c7baaff831441f0c018d0682bd820286f2"},"provenance":null,"requires-python":null,"size":364072,"upload-time":"2016-02-17T16:43:14.467612Z","url":"https://files.pythonhosted.org/packages/8f/0d/3e9cf8abb62d7241531019d78abaa87a19f3fcc017bfb9c2058ba61e8cf1/psutil-4.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.3.exe","hashes":{"sha256":"38d38211bba35c705a007e62b9dcc9be1d222acfcbee812612d4a48f9d8f0230"},"provenance":null,"requires-python":null,"size":358940,"upload-time":"2016-02-17T16:43:38.439349Z","url":"https://files.pythonhosted.org/packages/57/eb/514a71eab624b381473a3df9c3e3a02f5bb15707b12daf02c137271dfd26/psutil-4.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.4.exe","hashes":{"sha256":"bc868653a6502c3a01da32b3a598a8575674975f5586ac0bf9181349588925b9"},"provenance":null,"requires-python":null,"size":358966,"upload-time":"2016-02-17T16:44:02.873748Z","url":"https://files.pythonhosted.org/packages/25/f6/ef4b802658c21d5b79a0e038db941f4b08a7cc2de78df1949ad709542682/psutil-4.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.0.0.win32-py3.5.exe","hashes":{"sha256":"38244b0d07d3bece481a6f1c049e6101fdd26f2ee63dadcb63ce993283032fdc"},"provenance":null,"requires-python":null,"size":298915,"upload-time":"2016-02-17T16:44:31.772075Z","url":"https://files.pythonhosted.org/packages/b9/be/b8938c409231dab07d2954ff7b4d1129e725e0e8ab1b016d7f471f3285e9/psutil-4.0.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp26-none-win32.whl","hashes":{"sha256":"13aed96ad945db5c6b3d5fbe92be65330a3f2f757a300c7d1578a16efa0ece7f"},"provenance":null,"requires-python":null,"size":159498,"upload-time":"2016-03-12T17:13:58.069685Z","url":"https://files.pythonhosted.org/packages/77/04/d5a92cb5c0e79b84294f6c99b9725806921d1d88032e9d056ca8a7ba31c1/psutil-4.1.0-cp26-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp26-none-win_amd64.whl","hashes":{"sha256":"90b58cf88e80a4af52b79678df474679d231ed22200e6c25605a42ca71708a47"},"provenance":null,"requires-python":null,"size":161924,"upload-time":"2016-03-12T17:17:01.346400Z","url":"https://files.pythonhosted.org/packages/b5/a5/cf96f9f13f9e20bdb4cd2ca1af2ddd74f76fea4bbfb8505c31a5900b38d2/psutil-4.1.0-cp26-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp27-cp27m-win32.whl","hashes":{"sha256":"ac141a44a5c145e9006bc7081c714b2c317077d158b65fe4624c9cbf2b8ac7bf"},"provenance":null,"requires-python":null,"size":159318,"upload-time":"2016-03-12T17:14:48.199436Z","url":"https://files.pythonhosted.org/packages/8a/31/439614cc2ccd6f3ce1d173c0d7c7a9e45be17cd2bf3ae1f8feaaf0a90cee/psutil-4.1.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"data-dist-info-metadata":{"sha256":"9a907b7ac326dc42e1ba74d263d9a38c07d0929a2a9f91960d9961923d796b2d"},"filename":"psutil-4.1.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"3605b6b9f23f3e186b157b03a95e0158559eb74bcef5d51920b8ddb48cc3a7e7"},"provenance":null,"requires-python":null,"size":161579,"upload-time":"2016-03-12T17:17:24.047978Z","url":"https://files.pythonhosted.org/packages/90/97/0a34c0e98bb794f0fc19f0eae13d26fbf39583c768a9a6c614c917135c00/psutil-4.1.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp33-cp33m-win32.whl","hashes":{"sha256":"5568e21c8eb9de0e56c8a4a38982b725bf42117bca7ac75c7b079e5214aea5c4"},"provenance":null,"requires-python":null,"size":159241,"upload-time":"2016-03-12T17:15:16.355951Z","url":"https://files.pythonhosted.org/packages/bb/de/8e1f8c4ea6035d08e3c87a0cfc8af6f2862da21697c16d1d17311e095117/psutil-4.1.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"3d3f8ae20b04b68e65b46dc2eedf15f32925655dacbb11cb7afe56ac562e112a"},"provenance":null,"requires-python":null,"size":161458,"upload-time":"2016-03-12T17:17:51.825112Z","url":"https://files.pythonhosted.org/packages/ac/cf/6241dd597ef4f995ab8e29746c54890c1acbb322484afed05aa8988118e1/psutil-4.1.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp34-cp34m-win32.whl","hashes":{"sha256":"faafb81bf7717fa8c44bb0f2e826768f561c0311fd0568090c59c9b253b65238"},"provenance":null,"requires-python":null,"size":159266,"upload-time":"2016-03-12T17:15:48.577644Z","url":"https://files.pythonhosted.org/packages/48/2d/46ba91df965d4f0af5fd4252ac249ff408f6cb966fe1208396933275246f/psutil-4.1.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"4ab1ee4152dbb790a37291149b73b1918ab4398c8edb3af7847fa6c884024c93"},"provenance":null,"requires-python":null,"size":161466,"upload-time":"2016-03-12T17:18:23.409579Z","url":"https://files.pythonhosted.org/packages/c0/b1/70868328ddf2cfcde201136bdaf4c9f7fabf868890bc91694fd5fa0fbc19/psutil-4.1.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp35-cp35m-win32.whl","hashes":{"sha256":"2fa06b7ba58e870fdaa1427e82ed427a785493c7a998e059e0806b2c48bdbfaf"},"provenance":null,"requires-python":null,"size":161345,"upload-time":"2016-03-12T17:16:33.062364Z","url":"https://files.pythonhosted.org/packages/dc/f7/5d3f84507c057af85bc70da10b51a827766999f221b42cdf9621ca756e80/psutil-4.1.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"data-dist-info-metadata":{"sha256":"28328dafba00a0d87523ceca7f8bb23231019819caf14ec9eeddc3c4c8104338"},"filename":"psutil-4.1.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"1ca460fea3822d04f332f5dde144accc5ca4610e5bbce53f15d09cd985f30385"},"provenance":null,"requires-python":null,"size":164147,"upload-time":"2016-03-12T17:18:49.483687Z","url":"https://files.pythonhosted.org/packages/f1/65/040624aab6ca646af0c8b68ac54d08e0a33a672feb9405581cd509741367/psutil-4.1.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.tar.gz","hashes":{"sha256":"c6abebec9c8833baaf1c51dd1b0259246d1d50b9b50e9a4aa66f33b1e98b8d17"},"provenance":null,"requires-python":null,"size":301330,"upload-time":"2016-03-12T17:12:53.032151Z","url":"https://files.pythonhosted.org/packages/71/9b/6b6f630ad4262572839033b69905d415ef152d7701ef40aa98941ba75b38/psutil-4.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py2.6.exe","hashes":{"sha256":"30a97a9c3ace92001e419a6bb039b2e899c5ab24cab6ad8bc249506475c84a0c"},"provenance":null,"requires-python":null,"size":399511,"upload-time":"2016-03-12T17:16:48.833953Z","url":"https://files.pythonhosted.org/packages/28/bd/c389af84b684d36010a634834f76932ff60f33505c54413c50eceb720a5d/psutil-4.1.0.win-amd64-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"3ba9236c38fe85088b9d79bd5871e07f253d225b357ce82db9240e5807f147b6"},"provenance":null,"requires-python":null,"size":399168,"upload-time":"2016-03-12T17:17:14.518227Z","url":"https://files.pythonhosted.org/packages/6c/e8/49ff1b33e9fa6f7ea1232d40bbef9a453424fbf0421a7c53d9ecb9a896e7/psutil-4.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"99a902d1bf5beb13cca4d7a3dc82efb6eaf40aafe916a5b632d47393313bfcfd"},"provenance":null,"requires-python":null,"size":397557,"upload-time":"2016-03-12T17:17:40.792655Z","url":"https://files.pythonhosted.org/packages/c5/3e/47adda552a79480e2a5d38a2f90144ab4e7ea34eba2b707523cdd1c65fc6/psutil-4.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"ecf8b83e038acdda9102aebadb1525f89231463772cbe89e3e8a2cf5a5c6065d"},"provenance":null,"requires-python":null,"size":397564,"upload-time":"2016-03-12T17:18:11.514028Z","url":"https://files.pythonhosted.org/packages/52/9f/5874f391a300feead5519872395cbb4d4588eace24962150a03cd9b6ffdf/psutil-4.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win-amd64-py3.5.exe","hashes":{"sha256":"448db9bf9db5d162f0282af70688e03d67d756b93d5bed94b0790a27a96af75b"},"provenance":null,"requires-python":null,"size":314216,"upload-time":"2016-03-12T17:18:36.745340Z","url":"https://files.pythonhosted.org/packages/32/34/6588580a1775a0741e14946003bf2722c493c7956c7dcc9a40c85dbe19f5/psutil-4.1.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py2.6.exe","hashes":{"sha256":"11b48d7ec00061960ffbef33a42e919f188e10a6a54c4161692d77a3ac37f1e2"},"provenance":null,"requires-python":null,"size":369441,"upload-time":"2016-03-12T17:13:47.639393Z","url":"https://files.pythonhosted.org/packages/5d/cc/7bf8593a60ed54b47def9a49a60b8bc3517d6fef6ee52a229583a5bc9046/psutil-4.1.0.win32-py2.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py2.7.exe","hashes":{"sha256":"c15ddba9f4c278f7d1bbbadc34df89d993171bb328fa1117cbecf68bcc1a01e5"},"provenance":null,"requires-python":null,"size":369263,"upload-time":"2016-03-12T17:14:25.482243Z","url":"https://files.pythonhosted.org/packages/bf/fa/7f0eda490dd5480bb8e6358f9e893fe7f824ec3a5b275b069708272d2260/psutil-4.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.3.exe","hashes":{"sha256":"8f97a836b89b09718b00aedbfd11d8468bbfcb821feadd65e338bd0b972dac54"},"provenance":null,"requires-python":null,"size":364112,"upload-time":"2016-03-12T17:15:06.252090Z","url":"https://files.pythonhosted.org/packages/e8/1c/e7d17500c0f5899f0fd3fd3b6d93c92254aff6de00cabc9c08de5a3803a2/psutil-4.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.4.exe","hashes":{"sha256":"fef37f4e2964043a58b6aa3b3be05ef9b3c7a58feb806d7e49dc91702bac52fa"},"provenance":null,"requires-python":null,"size":364136,"upload-time":"2016-03-12T17:15:29.468205Z","url":"https://files.pythonhosted.org/packages/6d/8e/7acd4079567fc64e1df12be6faeddf0ee19432445210293594444ea980a6/psutil-4.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.1.0.win32-py3.5.exe","hashes":{"sha256":"1a9409d2204d397b1ed10528065e45020e0b1c2ee5204bf5a1bc6fdff3f6ab91"},"provenance":null,"requires-python":null,"size":304255,"upload-time":"2016-03-12T17:16:06.024724Z","url":"https://files.pythonhosted.org/packages/5b/30/10f3bef7fa284167a3f9bd3862bcba5cc14fb8509f146a2f696ea5265b93/psutil-4.1.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"data-dist-info-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"filename":"psutil-4.2.0-cp27-cp27m-win32.whl","hashes":{"sha256":"19f6c8bd30d7827ce4d4bbcfe23fe7158fea3d72f59505850c5afa12985184bb"},"provenance":null,"requires-python":null,"size":165248,"upload-time":"2016-05-15T06:36:58.089018Z","url":"https://files.pythonhosted.org/packages/58/a5/2ccc9f6180ea769005405381f6b0d01fe1268f20cc85877b02c04c27d306/psutil-4.2.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"data-dist-info-metadata":{"sha256":"5eaefa5c21411ed0414953f28eef77176307e672d668daf95d91e18ad3dc36f7"},"filename":"psutil-4.2.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"92bc2351bb4bc7672b3d0e251a449ac2234bbe4fac11f708614bdc0a8ebffe3b"},"provenance":null,"requires-python":null,"size":167782,"upload-time":"2016-05-15T06:37:06.221707Z","url":"https://files.pythonhosted.org/packages/c8/e5/5d0a1b2e182e41888fc4e9f4f657f37f126f9fdcd431b592442311c2db98/psutil-4.2.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp33-cp33m-win32.whl","hashes":{"sha256":"2e16f792deceb1d33320981aaff7f139561cf6195ee3f1b21256d7f214162517"},"provenance":null,"requires-python":null,"size":165259,"upload-time":"2016-05-15T06:37:12.236981Z","url":"https://files.pythonhosted.org/packages/dd/94/8aeb332d07530b552099eaf207db13d859e09facfa8162892b4f9ef302dd/psutil-4.2.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"3c57a6731b3bd4c4af834b0137493a388b76192f5adc2399825015b777e0b02b"},"provenance":null,"requires-python":null,"size":167667,"upload-time":"2016-05-15T06:37:17.736147Z","url":"https://files.pythonhosted.org/packages/d5/6b/c10a228ef2cdbc077171be3b273cd2f49e4f814bf7dc2deb3a464cc126de/psutil-4.2.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp34-cp34m-win32.whl","hashes":{"sha256":"0cda72a1efacd2b028c9dbf0731111041e6cf9e7be938162811ab32ab3e88254"},"provenance":null,"requires-python":null,"size":165272,"upload-time":"2016-05-15T06:37:23.488252Z","url":"https://files.pythonhosted.org/packages/35/3e/3db756e014fe3e6e22e35c8394057dcf1eef58076d84fdf83ac00a053182/psutil-4.2.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"ce208e1c416e143697a1ee9dd86ae9720c740c11764a1fda88eb28a2ecc0b510"},"provenance":null,"requires-python":null,"size":167627,"upload-time":"2016-05-15T06:37:28.596251Z","url":"https://files.pythonhosted.org/packages/c7/7d/cfb299960cf6923cca782f331b034c09239e9015dedf530dd206177dd6e4/psutil-4.2.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp35-cp35m-win32.whl","hashes":{"sha256":"375b0acad448e49c8bc62e036f948af610b4e0cbe2a9a28eebc06357f20f67ea"},"provenance":null,"requires-python":null,"size":167370,"upload-time":"2016-05-15T06:37:34.104073Z","url":"https://files.pythonhosted.org/packages/4d/bc/f49882e8935f147b8922fc8bb0f430fe0e7b0d3231a601cd12e1c0272f77/psutil-4.2.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"data-dist-info-metadata":{"sha256":"467235151a7ca9506acf3ca52432d5a215f42e2fe44c043d0a0068e133a957dd"},"filename":"psutil-4.2.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bd4b535996d06728b50bc7cd8777c402bf7294ad05229c843701bd1e63583c2c"},"provenance":null,"requires-python":null,"size":170689,"upload-time":"2016-05-15T06:37:39.395642Z","url":"https://files.pythonhosted.org/packages/7b/e2/2e1078a38189d51409f50af50b598309a2bd84ebe8ca71b79515da915c82/psutil-4.2.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.tar.gz","hashes":{"sha256":"544f013a0aea7199e07e3efe5627f5d4165179a04c66050b234cc3be2eca1ace"},"provenance":null,"requires-python":null,"size":311767,"upload-time":"2016-05-15T06:35:49.367304Z","url":"https://files.pythonhosted.org/packages/a6/bf/5ce23dc9f50de662af3b4bf54812438c298634224924c4e18b7c3b57a2aa/psutil-4.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"1329160e09a86029ef4e07f47dbcc39d511c343257a53acf1af429c537caae57"},"provenance":null,"requires-python":null,"size":406095,"upload-time":"2016-05-15T06:37:44.994723Z","url":"https://files.pythonhosted.org/packages/6b/af/9e43a4a4976f1d1291de8be40c848c591c6e48d7e4053a7b26ad88ba750c/psutil-4.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"12623a1e2e264eac8c899b89d78648e241c12eec754a879453b2e0a4a78b10dd"},"provenance":null,"requires-python":null,"size":404495,"upload-time":"2016-05-15T06:37:50.698273Z","url":"https://files.pythonhosted.org/packages/36/85/64244b1e930aa276205f079ba3e2996e8492bd173af019bbdaee47336a6a/psutil-4.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"66a4a7793dc543a3c7413cda3187e3ced45acf302f95c4d596ebcfc663c01b40"},"provenance":null,"requires-python":null,"size":404456,"upload-time":"2016-05-15T06:37:56.103096Z","url":"https://files.pythonhosted.org/packages/30/fa/a734058699f351ef90b757e0fd8d67a6145c8272bbed85c498276acacd2e/psutil-4.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win-amd64-py3.5.exe","hashes":{"sha256":"c2b7aa0a99b06967fb76e83e7e9c7153a2d9a5df073986a99a4e9656cfaabe28"},"provenance":null,"requires-python":null,"size":321489,"upload-time":"2016-05-15T06:38:02.113109Z","url":"https://files.pythonhosted.org/packages/a9/1b/c90c802a6db438aeebac412ac3ecf389022f4fd93abef9c0441358f46a71/psutil-4.2.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py2.7.exe","hashes":{"sha256":"856480ce003ecd1601bcb83d97e25bfe79f5b08c430ee9f139a5e768173b06ef"},"provenance":null,"requires-python":null,"size":375917,"upload-time":"2016-05-15T06:38:09.945181Z","url":"https://files.pythonhosted.org/packages/e4/63/267b0977027c8a4a2f98a1ffbc2ecc7c0689d12adabee591a1ac99b4c14e/psutil-4.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.3.exe","hashes":{"sha256":"ab83fefffa495813d36300cd3ad3f232cf7c86a5e5a02d8e8ea7ab7dba5a1a90"},"provenance":null,"requires-python":null,"size":370860,"upload-time":"2016-05-15T06:38:16.360218Z","url":"https://files.pythonhosted.org/packages/c0/96/8197557cbebb16be1cfd3c87f1d0972bd2e5b0733b21d0e5d890541634e8/psutil-4.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.4.exe","hashes":{"sha256":"44c9f0e26b93c2cc9437eb88c31df32bd4337c394a959e0c31bf006da6e0f073"},"provenance":null,"requires-python":null,"size":370872,"upload-time":"2016-05-15T06:38:22.312293Z","url":"https://files.pythonhosted.org/packages/22/c9/01646a50e3c52dda4b591aae411e85afc83952107f9906ec8a5806c9fcc0/psutil-4.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.2.0.win32-py3.5.exe","hashes":{"sha256":"c0013a6663b794fbe18284e06d4d553a9e2135b5489a2ac6982ad53641966a55"},"provenance":null,"requires-python":null,"size":311007,"upload-time":"2016-05-15T06:38:28.533757Z","url":"https://files.pythonhosted.org/packages/48/6f/2259000fa07a4efcdc843034810eb2f8675ef5b97845912f2265589483f4/psutil-4.2.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"data-dist-info-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"filename":"psutil-4.3.0-cp27-none-win32.whl","hashes":{"sha256":"99c2ab6c8f0d60e0c86775f8e5844e266af48cc1d9ecd1be209cd407a3e9c9a1"},"provenance":null,"requires-python":null,"size":167400,"upload-time":"2016-06-18T17:56:45.275403Z","url":"https://files.pythonhosted.org/packages/7a/a5/002caeac2ff88526cf0788315bad93be61e66477acd54209fb01cc874745/psutil-4.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"data-dist-info-metadata":{"sha256":"e4d7d684395672838b7bb0e9173a41bda97a9a103de6473eecda8beed8de23f6"},"filename":"psutil-4.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"a91474d34bf1bc86a0d95e2c198a70723208f9dc9e50258c2060a1bab3796f81"},"provenance":null,"requires-python":null,"size":169895,"upload-time":"2016-06-18T17:56:51.386191Z","url":"https://files.pythonhosted.org/packages/e1/77/fae92fff4ca7092555c7c8fc6e02c5dfc2a9af7e15762b7354d436adeb06/psutil-4.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp33-cp33m-win32.whl","hashes":{"sha256":"c987f0691c01cbe81813b0c895208c474240c96e26f7d1e945e8dabee5c85437"},"provenance":null,"requires-python":null,"size":167414,"upload-time":"2016-06-18T17:56:57.419709Z","url":"https://files.pythonhosted.org/packages/73/46/224a6a3c05df4e282240826f6bef0bd51da5ca283ffe34ed53f5601fbca1/psutil-4.3.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"233a943d3e6636d648f05515a4d21b4dda63499d8ca38d6890a57a3f78a9cceb"},"provenance":null,"requires-python":null,"size":169791,"upload-time":"2016-06-18T17:57:03.096187Z","url":"https://files.pythonhosted.org/packages/6b/4d/29b3d73c27cd8f348bb313376dd98a2e97cc8a075862cf483dea4c27e4bf/psutil-4.3.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp34-cp34m-win32.whl","hashes":{"sha256":"1893fe42b0fb5f11bf84ffe770be5b2e27fb7ec959ba8bf620b704552b738c72"},"provenance":null,"requires-python":null,"size":167396,"upload-time":"2016-06-18T17:57:09.859528Z","url":"https://files.pythonhosted.org/packages/dc/f5/34070d328a578c38131d96c4fe539ebbabf1c31128012755e344c030bb34/psutil-4.3.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"1345217075dd5bb4fecbf7cb0fe4c0c170e93ec57d48494756f4b617cd21b449"},"provenance":null,"requires-python":null,"size":169759,"upload-time":"2016-06-18T17:57:15.923623Z","url":"https://files.pythonhosted.org/packages/8d/91/7ae0835ae1a4bc1043b565dec9c6468d56c80a4f199472a7d005ddcd48e1/psutil-4.3.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp35-cp35m-win32.whl","hashes":{"sha256":"c9c4274f5f95a171437c90f65c3e9b71a871753f0a827f930e1b14aa43041eab"},"provenance":null,"requires-python":null,"size":169508,"upload-time":"2016-06-18T17:57:21.072109Z","url":"https://files.pythonhosted.org/packages/e4/40/801cd906da337a5e7a0afaaa1ce5919d9834c50d804d31ee4a1d2120a51c/psutil-4.3.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"data-dist-info-metadata":{"sha256":"21e625db3c2ab1770665e4dd336de5c07e12cfa6636d671163b7e4021a1a4341"},"filename":"psutil-4.3.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"5984ee7b2880abcdaa0819315f69a5f37da963863495c2294392cb3e98141a95"},"provenance":null,"requires-python":null,"size":172803,"upload-time":"2016-06-18T17:57:26.746663Z","url":"https://files.pythonhosted.org/packages/35/54/ddb6e8e583abf2f5a2be52a2223ba4935b382214b696fe334af54fb03dad/psutil-4.3.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.tar.gz","hashes":{"sha256":"86197ae5978f216d33bfff4383d5cc0b80f079d09cf45a2a406d1abb5d0299f0"},"provenance":null,"requires-python":null,"size":316470,"upload-time":"2016-06-18T17:54:55.929749Z","url":"https://files.pythonhosted.org/packages/22/a8/6ab3f0b3b74a36104785808ec874d24203c6a511ffd2732dd215cf32d689/psutil-4.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"1ad0075b6c86c0ea5076149ec39dcecf0c692711c34317d43d73a4d8c4d4ec30"},"provenance":null,"requires-python":null,"size":408495,"upload-time":"2016-06-18T17:57:33.655137Z","url":"https://files.pythonhosted.org/packages/d5/1f/638b17eab913d19203ebd721c4e5c726b57bc50def33ab1ec0070fe2ddc2/psutil-4.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"02c042e1f6c68c807de5caf45547971cf02977abf4cd92c8961186af9c91c488"},"provenance":null,"requires-python":null,"size":406900,"upload-time":"2016-06-18T17:57:40.580278Z","url":"https://files.pythonhosted.org/packages/a6/9b/94598ec4041ee2834f7ca21c9f1ff67e8f8cef4376ee9d9b9e3ff6950d05/psutil-4.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"2bcfeff969f3718bb31effea752d92511f375547d337687db1bd99ccd85b7ad7"},"provenance":null,"requires-python":null,"size":406871,"upload-time":"2016-06-18T17:57:47.827133Z","url":"https://files.pythonhosted.org/packages/79/2a/abe407e5b594b2a7c0432f5605579d33ce21e0049e3dc2e5c4f37402f760/psutil-4.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"34736b91c9785ede9d859a79e28129390f609339014f904c276ad46d0a440730"},"provenance":null,"requires-python":null,"size":323883,"upload-time":"2016-06-18T17:57:54.043353Z","url":"https://files.pythonhosted.org/packages/14/5e/072b19d913b3fc1f86b871c2869d19db3b5fa50c2e9f4980ae8646e189e0/psutil-4.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py2.7.exe","hashes":{"sha256":"da6ee62fb5ffda188c39aacb0499d401c131046e922ba53fb4b908937e771f94"},"provenance":null,"requires-python":null,"size":378354,"upload-time":"2016-06-18T17:58:00.735354Z","url":"https://files.pythonhosted.org/packages/7e/85/a60111c14eb80aa7a74e1a0086c1a1bbc62282df0c913730e558d16e6a8c/psutil-4.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.3.exe","hashes":{"sha256":"6f36fa29aa9ca935405a3cebe03cfbc6dde27088f9ad3d9b2d3baa47d4b89914"},"provenance":null,"requires-python":null,"size":373297,"upload-time":"2016-06-18T17:58:08.504160Z","url":"https://files.pythonhosted.org/packages/8e/6e/744b98493947a11625a4c63adb9a148c69c2a6e0cf7ef2afd6212804df1d/psutil-4.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.4.exe","hashes":{"sha256":"63b75c5374fafdaf3f389229b592f19b88a8c7951d1b973b9113df649ade5cb9"},"provenance":null,"requires-python":null,"size":373279,"upload-time":"2016-06-18T17:58:15.187200Z","url":"https://files.pythonhosted.org/packages/87/ce/a3cfd0e1b7d34fccff488a6a2283e5b947841465f81960bd87eee5f78828/psutil-4.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.0.win32-py3.5.exe","hashes":{"sha256":"6d0e1e9bbdab5a7d40b57d8f0841eb9e11c2395ac7ec0ddd396116240d733f46"},"provenance":null,"requires-python":null,"size":313430,"upload-time":"2016-06-18T17:58:22.261628Z","url":"https://files.pythonhosted.org/packages/eb/23/d01e7eccd76a096b0675ab9d07c8fd2de9fd31bc8f4c92f1a150bc612ad4/psutil-4.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"data-dist-info-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"filename":"psutil-4.3.1-cp27-none-win32.whl","hashes":{"sha256":"b0c5bf0d2a29a6f18ac22e2d24210730dca458c9f961914289c9e027ccb5ae43"},"provenance":null,"requires-python":null,"size":168476,"upload-time":"2016-09-02T13:58:43.429910Z","url":"https://files.pythonhosted.org/packages/2d/70/0b24c7272efbb1d8cac1be1768aabfb8ddb37bdc9ab8a176f6afc7e52b0d/psutil-4.3.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"data-dist-info-metadata":{"sha256":"f2eb91a4c96ace2af993ac8587ddb20d3ed535289e9c5a0fde7a8c3d67ae0e12"},"filename":"psutil-4.3.1-cp27-none-win_amd64.whl","hashes":{"sha256":"fc78c29075e623b6ea1c4a1620a120a1534ee05370b76c0ec96f6d161d79e7a1"},"provenance":null,"requires-python":null,"size":170725,"upload-time":"2016-09-02T13:58:47.944701Z","url":"https://files.pythonhosted.org/packages/67/d4/0403e6bd1cf78bd597ac960a3a6ad36cea6c12e3b413c0a1d43361128fb5/psutil-4.3.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp33-cp33m-win32.whl","hashes":{"sha256":"aa05f44a77ef83773af39446f99e461aa3b6edb7fdabeefdcf06e913d8884d3a"},"provenance":null,"requires-python":null,"size":168384,"upload-time":"2016-09-02T13:58:52.479199Z","url":"https://files.pythonhosted.org/packages/9c/ec/5f3f06012c54de3b4443a6948fc75fe1e348ca3de408b00815b5976b8877/psutil-4.3.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"6b3882eb16f2f40f1da6208a051800abadb1f82a675d9ef6ca7386e1a208b1ad"},"provenance":null,"requires-python":null,"size":170566,"upload-time":"2016-09-02T13:58:56.870812Z","url":"https://files.pythonhosted.org/packages/de/c6/74f8b4d460d89811b4c8fd426b63530222456bad767fe372ebb4f5f207be/psutil-4.3.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp34-cp34m-win32.whl","hashes":{"sha256":"cf1be0b16b38f0e2081ff0c81a1a4321c206a824ba6bd51903fdd440abb370b6"},"provenance":null,"requires-python":null,"size":168375,"upload-time":"2016-09-02T13:59:01.079445Z","url":"https://files.pythonhosted.org/packages/75/ff/d02c907869d5e4cc260ce72eb253f5007a7cdf0b47326d19693f8f937eb0/psutil-4.3.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"afa94bed972722882264a4df06176f6b6e6acc6bcebcc3f1db5428c7271dacba"},"provenance":null,"requires-python":null,"size":170529,"upload-time":"2016-09-02T13:59:05.507453Z","url":"https://files.pythonhosted.org/packages/c9/72/07da416b1dcf258a0cb0587c823e3611392fe29b1fcae6e078b1c254dce5/psutil-4.3.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp35-cp35m-win32.whl","hashes":{"sha256":"d2254f518624e6b2262f0f878931faa4bdbe8a77d1f8826564bc4576c6a4f85e"},"provenance":null,"requires-python":null,"size":170124,"upload-time":"2016-09-02T13:59:09.837050Z","url":"https://files.pythonhosted.org/packages/cd/b0/07b7083a134c43b58515d59f271734034f8ba06840b1f371eaa6b3ab85b2/psutil-4.3.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"data-dist-info-metadata":{"sha256":"2bf14b2dd8f24b0dedf17492f736d534043ed69d60a0cf1d5a8925a8a351061a"},"filename":"psutil-4.3.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"3b377bc8ba5e62adbc709a90ea07dce2d4addbd6e1cc7acede61ddfa1c66e00a"},"provenance":null,"requires-python":null,"size":173545,"upload-time":"2016-09-02T13:59:14.368908Z","url":"https://files.pythonhosted.org/packages/7e/7e/17c1467158ccac5dc54986a657420fc194686653cfb6feddb6717a60d17f/psutil-4.3.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.tar.gz","hashes":{"sha256":"38f74182fb9e15cafd0cdf0821098a95cc17301807aed25634a18b66537ba51b"},"provenance":null,"requires-python":null,"size":315878,"upload-time":"2016-09-01T20:56:06.777431Z","url":"https://files.pythonhosted.org/packages/78/cc/f267a1371f229bf16db6a4e604428c3b032b823b83155bd33cef45e49a53/psutil-4.3.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py2.7.exe","hashes":{"sha256":"733210f39e95744da26f2256bc36035fc463b0ae88e91496e97486ba21c63cab"},"provenance":null,"requires-python":null,"size":408715,"upload-time":"2016-09-01T21:31:30.452539Z","url":"https://files.pythonhosted.org/packages/57/44/09ec7b6a3fc1216ecc2182a64f8b6c2eaf8dd0d983fb98ecbf9cecbf54b4/psutil-4.3.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.3.exe","hashes":{"sha256":"4690f720054beff4fc66551a6a34512faff328588dca8e2dbed94398b6941112"},"provenance":null,"requires-python":null,"size":407063,"upload-time":"2016-09-01T21:31:37.405818Z","url":"https://files.pythonhosted.org/packages/f2/b5/2921abbf7779d2f7bb210aa819dd2d86ecd004430c59aef9cc52c2d4057b/psutil-4.3.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.4.exe","hashes":{"sha256":"fd9b66edb9f8943eda6b39e7bb9bff8b14aa8d785f5b417d7a0bfa53d4781a7a"},"provenance":null,"requires-python":null,"size":407028,"upload-time":"2016-09-01T21:31:44.758391Z","url":"https://files.pythonhosted.org/packages/91/ea/d5fb1ef4615c0febab3a347ffbc98d50177878546c22b3291892f41de8f4/psutil-4.3.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win-amd64-py3.5.exe","hashes":{"sha256":"9ab5b62c6571ce545b1c40b9740af81276bd5d94439fd54de07ed59be0ce3f4f"},"provenance":null,"requires-python":null,"size":777648,"upload-time":"2016-09-01T21:31:56.074229Z","url":"https://files.pythonhosted.org/packages/0d/d9/626030b223140d88176b5dda42ea081b843249af11fa71d9e36a465b4b18/psutil-4.3.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py2.7.exe","hashes":{"sha256":"ad8857923e9bc5802d5559ab5d70c1abc1a7be8e74e779adde883c5391e2061c"},"provenance":null,"requires-python":null,"size":378819,"upload-time":"2016-09-01T21:30:59.795815Z","url":"https://files.pythonhosted.org/packages/02/99/2cc2981b30b2b1fb5b393c921ad17e4baaa1f95d7de527fe54ee222e5663/psutil-4.3.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.3.exe","hashes":{"sha256":"ae20b76cddb3391ea37de5d2aaa1656d6373161bbc8fd868a0ca055194a46e45"},"provenance":null,"requires-python":null,"size":373653,"upload-time":"2016-09-01T21:31:06.076800Z","url":"https://files.pythonhosted.org/packages/06/2f/bbcae933425945d2c9ca3e30e2f35728827e87cedad113808d3f527fe2ea/psutil-4.3.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.4.exe","hashes":{"sha256":"0613437cc28b8721de92c582d5baf742dfa6dd824c84b578f8c49a60077e969a"},"provenance":null,"requires-python":null,"size":373650,"upload-time":"2016-09-01T21:31:12.717399Z","url":"https://files.pythonhosted.org/packages/fb/a6/28bca55c499426202341f8224f66fcd69e6577211201b02605be779f44b1/psutil-4.3.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.3.1.win32-py3.5.exe","hashes":{"sha256":"c2031732cd0fb7536af491bb8d8119c9263020a52450f9999c884fd49d346b26"},"provenance":null,"requires-python":null,"size":644701,"upload-time":"2016-09-01T21:31:22.237380Z","url":"https://files.pythonhosted.org/packages/f3/c7/f5da6e76f69c97ecfabe684f4d9e179ceaf9f7c1a74d6148480b1a6c41a8/psutil-4.3.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"data-dist-info-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"filename":"psutil-4.4.0-cp27-none-win32.whl","hashes":{"sha256":"4b907a0bed62a76422eae4e1ed8c8eca25fc21e57a31fc080158b8a300e21dad"},"provenance":null,"requires-python":null,"size":172746,"upload-time":"2016-10-23T14:08:37.739179Z","url":"https://files.pythonhosted.org/packages/8b/00/f7203827a3b2576bf8162ea3ba41e39c3307651218ab08e22e1433d8dc36/psutil-4.4.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"data-dist-info-metadata":{"sha256":"73b13e96cdf0d35ce81d30eb0c2e6b9cbfea41ee45b898f54d9e832e8e3ddd92"},"filename":"psutil-4.4.0-cp27-none-win_amd64.whl","hashes":{"sha256":"f60ab95f5e65c420743d5dd5285bda2a6bba6712e9380fb9a5903ea539507326"},"provenance":null,"requires-python":null,"size":175102,"upload-time":"2016-10-23T14:08:40.758084Z","url":"https://files.pythonhosted.org/packages/61/5c/d1f89100973829813e485e7bfc2f203e0d11937f958109819b62e8995b51/psutil-4.4.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp33-cp33m-win32.whl","hashes":{"sha256":"d45919d8b900a9ae03f3d43c489323842d4051cf7a728169f01a3889f50d24ad"},"provenance":null,"requires-python":null,"size":172612,"upload-time":"2016-10-23T14:08:44.422307Z","url":"https://files.pythonhosted.org/packages/34/16/ecc7366a7d023731b8b051cff64d3bb4bed2efa4947b125a3c9031e3d799/psutil-4.4.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"df706e4a8533b43c1a083c2c94e816c7a605487db49e5d49fc64329e0147c0f5"},"provenance":null,"requires-python":null,"size":174980,"upload-time":"2016-10-23T14:08:48.077823Z","url":"https://files.pythonhosted.org/packages/f7/17/6fc596007c243a12cf8c9e81b150f1e7a49c7c85c0544771398f257d5608/psutil-4.4.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp34-cp34m-win32.whl","hashes":{"sha256":"d119281d253bbcc44b491b7b7e5c38802f0933179af97ab228cfd8d072ad1503"},"provenance":null,"requires-python":null,"size":172623,"upload-time":"2016-10-23T14:08:50.867277Z","url":"https://files.pythonhosted.org/packages/50/8f/e8fcfb1bacd02c743545d58514004978318d8476c8bffeee9fecfc9f1f79/psutil-4.4.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"ff8a22a40bf884f52cf8dd86872b5199e7ed58eef1575e837d1d9b668fb2416a"},"provenance":null,"requires-python":null,"size":174974,"upload-time":"2016-10-23T14:08:53.576968Z","url":"https://files.pythonhosted.org/packages/41/8f/31f1fb4bb639ccaff2192b0b2a760118a05fb108e156d4966c81a246071b/psutil-4.4.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp35-cp35m-win32.whl","hashes":{"sha256":"7b7c850b3afe6c7895cfd3ee630492c4aabe644a6723a583cd56bac0222d7cd8"},"provenance":null,"requires-python":null,"size":174516,"upload-time":"2016-10-23T14:08:56.521588Z","url":"https://files.pythonhosted.org/packages/18/9e/702b1da450a13448f9d96f2d9e2f69eed901c56adb01e173d8307278c883/psutil-4.4.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"data-dist-info-metadata":{"sha256":"ee9b7c8ec564a66dc6543830d64d32a37387ea58517feba35aa4eefeb15ce5de"},"filename":"psutil-4.4.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"321d09e39bb4641c98544e51fba598f894d09355a18d14367468723632cb149e"},"provenance":null,"requires-python":null,"size":178046,"upload-time":"2016-10-23T14:08:59.346105Z","url":"https://files.pythonhosted.org/packages/8a/87/a22b95d91fb1a07591ebf373d1c286a16037bf2e321577a083156d7f6a13/psutil-4.4.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.tar.gz","hashes":{"sha256":"f4da111f473dbf7e813e6610aec1329000536aea5e7d7e73ed20bc42cfda7ecc"},"provenance":null,"requires-python":null,"size":1831734,"upload-time":"2016-10-23T14:09:04.179623Z","url":"https://files.pythonhosted.org/packages/fc/63/af9c6a4f2ab48293f60ec204cc1336f6f17c1cb782ffb0275982ac08d663/psutil-4.4.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py2.7.exe","hashes":{"sha256":"184132916ceb845f12f7cced3a2cf5273097d314f44be8357bdc435a6dee49cd"},"provenance":null,"requires-python":null,"size":413868,"upload-time":"2016-10-23T14:09:10.236158Z","url":"https://files.pythonhosted.org/packages/98/d9/407ee7d17b4e78c45b92639bfbd9b376b6a6022b0c63965946bfd74af6f4/psutil-4.4.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.3.exe","hashes":{"sha256":"7bb1c69a062aaff4a1773cca6bbe33b261293318d72246b9519357260b67be1e"},"provenance":null,"requires-python":null,"size":412259,"upload-time":"2016-10-23T14:09:15.072697Z","url":"https://files.pythonhosted.org/packages/3f/cc/b31fbc28247722ae7ece86f8911459e29a08f5075e3d4e794cef20f920b2/psutil-4.4.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.4.exe","hashes":{"sha256":"887eca39665d3de362693d66db9c15bf93313cde261de93908452241ee439e56"},"provenance":null,"requires-python":null,"size":412252,"upload-time":"2016-10-23T14:09:19.006281Z","url":"https://files.pythonhosted.org/packages/32/72/88e9e57964144ac3868f817f77e269f987c74fa51e503eb0fe8040523d28/psutil-4.4.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win-amd64-py3.5.exe","hashes":{"sha256":"a289ed4f7be6c535aa4c59c997baf327788d564881c8bf08fee502fab0cdc7cb"},"provenance":null,"requires-python":null,"size":782926,"upload-time":"2016-10-23T14:09:24.493051Z","url":"https://files.pythonhosted.org/packages/45/09/8908f5931a78c90bf2ef7f91a37a752a13d4017347ac2765d0cbb89e82f6/psutil-4.4.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py2.7.exe","hashes":{"sha256":"8a18d0527ac339f5501f0bd5471040d5fb83052453eedf13106feaf99ddef6cb"},"provenance":null,"requires-python":null,"size":383869,"upload-time":"2016-10-23T14:09:28.382095Z","url":"https://files.pythonhosted.org/packages/4a/eb/a131c438621822833e3131c4998741c3b68fb6ff67786d25e9398439a640/psutil-4.4.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.3.exe","hashes":{"sha256":"8700a0373fd0c95c79ad79bc08e0a7b76cabc0c463658cbe398600c69d57293d"},"provenance":null,"requires-python":null,"size":378663,"upload-time":"2016-10-23T14:09:32.358639Z","url":"https://files.pythonhosted.org/packages/be/c8/fd76b7ba3e1cc61d586c5779d9b0a45d1ad020e1de677eb344d2583bd0f1/psutil-4.4.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.4.exe","hashes":{"sha256":"ddd3f76486a366f1dc7adc8a9e8a285ec24b3b213912b8dce0cbbb629f954b8c"},"provenance":null,"requires-python":null,"size":378674,"upload-time":"2016-10-23T14:09:35.849351Z","url":"https://files.pythonhosted.org/packages/ce/0c/efbe5aefdd136bb3e2fc292b0506761a9b04c215d295be07e11263a90923/psutil-4.4.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.0.win32-py3.5.exe","hashes":{"sha256":"28963853709f6e0958edd8d6d7469152098680800deb98a759a67745d65b164b"},"provenance":null,"requires-python":null,"size":649869,"upload-time":"2016-10-23T14:09:40.045794Z","url":"https://files.pythonhosted.org/packages/fa/b6/b97b6d4dcbc87b91db9fd2753a0c3b999b734595a97155a38003be475a6d/psutil-4.4.0.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"data-dist-info-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"filename":"psutil-4.4.1-cp27-none-win32.whl","hashes":{"sha256":"7e77ec1a9c75a858781c1fb46fe81c999e1ae0e711198b4aaf59e5f5bd373b11"},"provenance":null,"requires-python":null,"size":172150,"upload-time":"2016-10-25T15:16:10.656877Z","url":"https://files.pythonhosted.org/packages/a9/aa/ff4e5602420cda42e9ff12949eae95abf7d6838fc79d7892b29af416f4c2/psutil-4.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"data-dist-info-metadata":{"sha256":"b5aa70030cb34744d7b8b2639183dd13ebd01c60f592c3b0c5e6fd6d8086bcd3"},"filename":"psutil-4.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"0f7f830db35c1baeb0131b2bba458b77f7db98944b2fedafc34922168e467d09"},"provenance":null,"requires-python":null,"size":174507,"upload-time":"2016-10-25T15:16:16.530462Z","url":"https://files.pythonhosted.org/packages/62/e8/c3d3e4161e29bd86d6b06d16456defcb114fd74693b15e5692df9e2b611e/psutil-4.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp33-cp33m-win32.whl","hashes":{"sha256":"fa4ad0533adef033bbcbac5e20d06e77f9aadf5d9c1596317d1b668f94b01b99"},"provenance":null,"requires-python":null,"size":172015,"upload-time":"2016-10-25T15:16:19.320410Z","url":"https://files.pythonhosted.org/packages/2c/da/0428f61f2c5eda7c5053ae35a2d57b097e4eb15e48f9d222319df7f4cbd3/psutil-4.4.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"af337d186b07249b86f00a71b4cf6fcfa1964484fe5fb8a7b623f4559c2859c9"},"provenance":null,"requires-python":null,"size":174384,"upload-time":"2016-10-25T15:16:22.634310Z","url":"https://files.pythonhosted.org/packages/da/ce/d36c39da6d387fbfaea68f382319887315e9201e885ef93c418b89209b31/psutil-4.4.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp34-cp34m-win32.whl","hashes":{"sha256":"4e5cb45c9616dd855c07e538f523c838705ce7c24e021e645cdce4c7894e7209"},"provenance":null,"requires-python":null,"size":172026,"upload-time":"2016-10-25T15:16:28.801885Z","url":"https://files.pythonhosted.org/packages/64/63/49aeca2d1a20f5c5203302a25c825be9262f81d8bf74d7d9e0bf0789b189/psutil-4.4.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"0876646748f3db5e1678a94ae3f68dcef3bd51e82b34f06109e6a28bcddc266c"},"provenance":null,"requires-python":null,"size":174374,"upload-time":"2016-10-25T15:16:32.462229Z","url":"https://files.pythonhosted.org/packages/e0/b2/48a62d3204a714b6354105ed540d54d1e272d5b230bc35eddc14a1494dd1/psutil-4.4.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp35-cp35m-win32.whl","hashes":{"sha256":"e4e9033ef5d775ef8a522750688161241e79c7d4669a05784a0a1a8d37dc8c3c"},"provenance":null,"requires-python":null,"size":173920,"upload-time":"2016-10-25T15:16:38.218083Z","url":"https://files.pythonhosted.org/packages/95/e6/d6bad966efeb674bb3357c94f3e89bbd3477a24f2635c3cadc1d0f2aea76/psutil-4.4.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"data-dist-info-metadata":{"sha256":"979b8a1231ad076b4475296c0795b1310188d8e8fda89e2785b4da3efbf4ad52"},"filename":"psutil-4.4.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d8464100c62932eeeacce2be0a1041f68b3bfcc7be261cf9486c11ee98eaedd2"},"provenance":null,"requires-python":null,"size":177448,"upload-time":"2016-10-25T15:16:42.121191Z","url":"https://files.pythonhosted.org/packages/00/58/6845a2a2f6fbbc56a58f0605744368164bf68889299f134684cc1478baf6/psutil-4.4.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.tar.gz","hashes":{"sha256":"9da43dbf7c08f5c2a8e5e2c8792f5c438f52435677b1334e9653d23ea028f4f7"},"provenance":null,"requires-python":null,"size":1831794,"upload-time":"2016-10-25T15:16:47.508715Z","url":"https://files.pythonhosted.org/packages/e5/f3/b816daefa9a6757f867f81903f40849dcf0887f588793236b476e6a30ded/psutil-4.4.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py2.7.exe","hashes":{"sha256":"23ac3e7b6784751ceeb4338d54b0e683c955cd22b86acbc089696aeb0717ab75"},"provenance":null,"requires-python":null,"size":408863,"upload-time":"2016-10-25T15:16:52.293269Z","url":"https://files.pythonhosted.org/packages/88/93/3c8434bd64a5f89f6b0cc58e1394e88dc3c272f83f1877afac9ede222c63/psutil-4.4.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.3.exe","hashes":{"sha256":"8b97ece77d2dce49dd6adbfc0c9bfb7820be4460d00732bb8cf18b77b9ffb07f"},"provenance":null,"requires-python":null,"size":407253,"upload-time":"2016-10-25T15:16:57.006499Z","url":"https://files.pythonhosted.org/packages/50/21/6b462342ab2f091bed70898894322c107493d69e24a834b9f2ab93a1e876/psutil-4.4.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.4.exe","hashes":{"sha256":"a0b5976a5b5a781754b6cebe89f4e21413b04b7f4005f5713f65257bee29be5f"},"provenance":null,"requires-python":null,"size":407244,"upload-time":"2016-10-25T15:17:01.612657Z","url":"https://files.pythonhosted.org/packages/09/94/a7c3c875884adef49f52c19faff68bfd2b04160a5eb0489dbffa60b5c2dc/psutil-4.4.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win-amd64-py3.5.exe","hashes":{"sha256":"b0bfe16b9bd095e56b8ec481328ba64094ccd615ee1f789a12a13cfd7bc5e34a"},"provenance":null,"requires-python":null,"size":777920,"upload-time":"2016-10-25T15:17:05.774786Z","url":"https://files.pythonhosted.org/packages/09/bf/3d850244db8e6aa94116db6787edee352692bbb9647e31c056189e6742cc/psutil-4.4.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py2.7.exe","hashes":{"sha256":"392877b5f86977b4a747fb61968e3b44df62c1d6d87536f021c4979b601c68f5"},"provenance":null,"requires-python":null,"size":378863,"upload-time":"2016-10-25T15:17:10.258103Z","url":"https://files.pythonhosted.org/packages/ed/f9/ed4cc19c84086149067d03de7cfb9f3213cf02d58b6f75c2ac16f85e0baf/psutil-4.4.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.3.exe","hashes":{"sha256":"a571f179f29215f0aa710ec495573a3522f24e8a8ba0be67d094ad6f593fba05"},"provenance":null,"requires-python":null,"size":373657,"upload-time":"2016-10-25T15:17:17.117641Z","url":"https://files.pythonhosted.org/packages/e6/ad/d8ec058821191334cf17db08c32c0308252d7b3c7490417690061dd12096/psutil-4.4.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.4.exe","hashes":{"sha256":"c2614dc6194cafd74c147e4b95febe8778430c2ecb91197ad140bf45e3e3ada7"},"provenance":null,"requires-python":null,"size":373668,"upload-time":"2016-10-25T15:17:20.392896Z","url":"https://files.pythonhosted.org/packages/26/15/6d03a2171262a1be565d06c87d584c10daa51e787c7cdd2ff932a433419e/psutil-4.4.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.1.win32-py3.5.exe","hashes":{"sha256":"5915da802a1648d0baeeee06b0d1a87eb0e4e20654f65b8428a6f4cc8cd32caf"},"provenance":null,"requires-python":null,"size":644863,"upload-time":"2016-10-25T15:17:24.141533Z","url":"https://files.pythonhosted.org/packages/d1/91/89db11eaa91c1de34d77600c47d657fce7b60e847bcf6457dddfc23b387c/psutil-4.4.1.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"data-dist-info-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"filename":"psutil-4.4.2-cp27-none-win32.whl","hashes":{"sha256":"15aba78f0262d7839702913f5d2ce1e97c89e31456bb26da1a5f9f7d7fe6d336"},"provenance":null,"requires-python":null,"size":172169,"upload-time":"2016-10-26T11:01:25.916580Z","url":"https://files.pythonhosted.org/packages/d7/da/b7895f01868977c9205bf1c8ff6a88290ec443535084e206b7db7f33918f/psutil-4.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"data-dist-info-metadata":{"sha256":"5a3e00c7b872d8d4c7c640b7cfec9ede44850d18f5d050b57037614e2ec90c72"},"filename":"psutil-4.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"69e30d789c495b781f7cd47c13ee64452c58abfc7132d6dd1b389af312a78239"},"provenance":null,"requires-python":null,"size":174525,"upload-time":"2016-10-26T11:01:29.001553Z","url":"https://files.pythonhosted.org/packages/0c/76/f50742570195a9a13e26ee3e3e32575a9315df90408056c991af85d23792/psutil-4.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp33-cp33m-win32.whl","hashes":{"sha256":"e44d6b758a96539e3e02336430d3f85263d43c470c5bad93572e9b6a86c67f76"},"provenance":null,"requires-python":null,"size":172034,"upload-time":"2016-10-26T11:01:31.931360Z","url":"https://files.pythonhosted.org/packages/f1/58/64db332e3a665d0d0260fcfe39ff8609871a1203ed11afcff0e5991db724/psutil-4.4.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"c2b0d8d1d8b5669b9884d0dd49ccb4094d163858d672d3d13a3fa817bc8a3197"},"provenance":null,"requires-python":null,"size":174401,"upload-time":"2016-10-26T11:01:35.879864Z","url":"https://files.pythonhosted.org/packages/39/31/4b5a2ab9d20d14fa6c821b7fbbf69ae93708e1a4ba335d4e2ead549b2f59/psutil-4.4.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp34-cp34m-win32.whl","hashes":{"sha256":"10fbb631142a3200623f4ab49f8bf82c32b79b8fe179f6056d01da3dfc589da1"},"provenance":null,"requires-python":null,"size":172044,"upload-time":"2016-10-26T11:01:38.950793Z","url":"https://files.pythonhosted.org/packages/67/f6/f034ad76faa7b9bd24d70a663b5dca8d71b6b7ddb4a3ceecd6a0a63afe92/psutil-4.4.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"e423dd9cb12256c742d1d56ec38bc7d2a7fa09287c82c41e475e68b9f932c2af"},"provenance":null,"requires-python":null,"size":174393,"upload-time":"2016-10-26T11:01:41.933150Z","url":"https://files.pythonhosted.org/packages/f8/f2/df2d8de978236067d0fce847e3734c6e78bfd57df9db5a2786cc544ca85f/psutil-4.4.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp35-cp35m-win32.whl","hashes":{"sha256":"7481f299ae0e966a10cb8dd93a327efd8f51995d9bdc8810dcc65d3b12d856ee"},"provenance":null,"requires-python":null,"size":173938,"upload-time":"2016-10-26T11:01:44.870925Z","url":"https://files.pythonhosted.org/packages/57/2d/0cdc3fdb9853ec1d815e0948104f1c51894f47c8ee2152c019ba754ce678/psutil-4.4.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"data-dist-info-metadata":{"sha256":"34c5de5faa22e5cdae426206704ec3a7d177ec1d34a20e3ad2d072136ac17b84"},"filename":"psutil-4.4.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d96d31d83781c7f3d0df8ccb1cc50650ca84d4722c5070b71ce8f1cc112e02e0"},"provenance":null,"requires-python":null,"size":177465,"upload-time":"2016-10-26T11:01:47.925426Z","url":"https://files.pythonhosted.org/packages/cd/50/3c238d67e025701fa18cc37ed445327efcf14ea4d06e357eef92d1a250bf/psutil-4.4.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.tar.gz","hashes":{"sha256":"1c37e6428f7fe3aeea607f9249986d9bb933bb98133c7919837fd9aac4996b07"},"provenance":null,"requires-python":null,"size":1832052,"upload-time":"2016-10-26T11:01:53.029413Z","url":"https://files.pythonhosted.org/packages/6c/49/0f784a247868e167389f6ac76b8699b2f3d6f4e8e85685dfec43e58d1ed1/psutil-4.4.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py2.7.exe","hashes":{"sha256":"11a20c0328206dce68f8da771461aeaef9c44811e639216fd935837e758632dc"},"provenance":null,"requires-python":null,"size":408884,"upload-time":"2016-10-26T11:01:57.830427Z","url":"https://files.pythonhosted.org/packages/58/bc/ac2a052035e945153f0bdc23d7c169e7e64e0729af6ff96f85d960962def/psutil-4.4.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.3.exe","hashes":{"sha256":"642194ebefa573de62406883eb33868917bab2cc2e21b68d551248e194dd0b0a"},"provenance":null,"requires-python":null,"size":407275,"upload-time":"2016-10-26T11:02:00.968973Z","url":"https://files.pythonhosted.org/packages/38/b3/c8244a4858de5f9525f176d72cb06584433446a5b9d7272d5eec7a435f81/psutil-4.4.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.4.exe","hashes":{"sha256":"c02b9fb5f1f3c857938b26a73b1ca92007e8b0b2fd64693b29300fae0ceaf679"},"provenance":null,"requires-python":null,"size":407267,"upload-time":"2016-10-26T11:02:04.291434Z","url":"https://files.pythonhosted.org/packages/cd/4d/8f447ecba1a3d5cae9f3bdd8395b45e2e6d07834a05fa3ce58c766ffcea6/psutil-4.4.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win-amd64-py3.5.exe","hashes":{"sha256":"6c40dc16b579f645e1804341322364203d0b21045747e62e360fae843d945e20"},"provenance":null,"requires-python":null,"size":777940,"upload-time":"2016-10-26T11:02:10.124058Z","url":"https://files.pythonhosted.org/packages/73/6e/1c58cbdedcf4e2226f8ca182c947e29f29dba6965fdae0aa8e6a361365ce/psutil-4.4.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py2.7.exe","hashes":{"sha256":"c353ecc62e67bf7c7051c087670d49eae9472f1b30bb1623d667b0cd137e8934"},"provenance":null,"requires-python":null,"size":378885,"upload-time":"2016-10-26T11:02:16.586357Z","url":"https://files.pythonhosted.org/packages/37/27/9eba3e29f8291be103a8e5e44c06eefe5357217e9d8d294ff154dc3bff90/psutil-4.4.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.3.exe","hashes":{"sha256":"7106cb3722235ccb6fe4b18c51f60a548d4b111ec2d209abdcd3998661f4593a"},"provenance":null,"requires-python":null,"size":373678,"upload-time":"2016-10-26T11:02:20.035049Z","url":"https://files.pythonhosted.org/packages/62/25/189e73856fa3172d5e785404eb9cf4561b01094363cc39ec267399e401c4/psutil-4.4.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.4.exe","hashes":{"sha256":"de1f53fe955dfba562f7791f72517935010a2e88f9caad36917e8c5c03de9051"},"provenance":null,"requires-python":null,"size":373689,"upload-time":"2016-10-26T11:02:23.073976Z","url":"https://files.pythonhosted.org/packages/10/4a/e50ca35162538645c4d98816757763e4aaaac1ccaf055b39265acb8739e1/psutil-4.4.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-4.4.2.win32-py3.5.exe","hashes":{"sha256":"2eb123ca86057ed4f31cfc9880e098ee7a8e19c7ec02b068c45e7559ae7539a6"},"provenance":null,"requires-python":null,"size":644886,"upload-time":"2016-10-26T11:02:26.650470Z","url":"https://files.pythonhosted.org/packages/c5/97/018f0580bc3d3d85f1e084e683e904bc33cd58ca96e0ecb5ae6f346d6452/psutil-4.4.2.win32-py3.5.exe","yanked":false},{"core-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"data-dist-info-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"filename":"psutil-5.0.0-cp27-none-win32.whl","hashes":{"sha256":"cc2560b527cd88a9bc062ee4bd055c40b9fc107e37db01997422c75a3f94efe9"},"provenance":null,"requires-python":null,"size":175039,"upload-time":"2016-11-06T18:28:50.896397Z","url":"https://files.pythonhosted.org/packages/bb/82/efee0c83eab6ad3dd4a70b2b91013a50776ff6253f9b71d825914e693dfa/psutil-5.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"data-dist-info-metadata":{"sha256":"3db8fbdc9c0693e219a15e49b871dc421e85735214638b6e31d68aee5b78c550"},"filename":"psutil-5.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"8a6cbc7165a476d08a89ee3078a74d111729cf515fd831db9f635012e56f9759"},"provenance":null,"requires-python":null,"size":177395,"upload-time":"2016-11-06T18:28:54.500906Z","url":"https://files.pythonhosted.org/packages/16/bf/09cb9f5286e5037eba1d5fe347c0f622b325e068757f1072c56f9b130cc3/psutil-5.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp33-cp33m-win32.whl","hashes":{"sha256":"9b0f13e325f007a0fd04e9d44cfdb5187c0b3e144f89533324dd9f74c25bd9ec"},"provenance":null,"requires-python":null,"size":174954,"upload-time":"2016-11-06T18:28:57.539707Z","url":"https://files.pythonhosted.org/packages/a2/5d/82b85eb4c24c82064c5c216f52df92f7861ff0a02d3cbcfebfacadc2b28f/psutil-5.0.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"ade8924028b2c23cc9ffe4a0737de38c668d50be5ce19495790154f530ce5389"},"provenance":null,"requires-python":null,"size":177229,"upload-time":"2016-11-06T18:29:00.558809Z","url":"https://files.pythonhosted.org/packages/14/5b/00b74d0ada625090dfaba6244860a9ec4df2e79a6c8440dd490e46c65543/psutil-5.0.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp34-cp34m-win32.whl","hashes":{"sha256":"af01b73fd66f138e06f804508fd33118823fd2abb89f105ae2b99efa4c8fd1a3"},"provenance":null,"requires-python":null,"size":174957,"upload-time":"2016-11-06T18:29:04.527838Z","url":"https://files.pythonhosted.org/packages/fd/e6/5a08cd23cefadd22b8e74d0bd1c525897c9db4dc1d2f44716dee848b8fe3/psutil-5.0.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"846925435e69cc7b802cd7d1a4bd640e180d0db15277c24e196d3a5799bf6760"},"provenance":null,"requires-python":null,"size":177189,"upload-time":"2016-11-06T18:29:08.003063Z","url":"https://files.pythonhosted.org/packages/b4/11/f68bad0d5fc08800006d2355c941e186315987456158a9b06f40e483d4e7/psutil-5.0.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp35-cp35m-win32.whl","hashes":{"sha256":"d7885ff254425c64bcc2dbff256ec1367515c15218bfda0fd3d799092437d908"},"provenance":null,"requires-python":null,"size":176812,"upload-time":"2016-11-06T18:29:11.700563Z","url":"https://files.pythonhosted.org/packages/c4/16/84213b90c78e437eff09285138947d12105ea982cb6f8fda4ab2855014e6/psutil-5.0.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"data-dist-info-metadata":{"sha256":"48627687813fd477d371c4588c61dc9da3e42f22546da21c80f273e30c587f1b"},"filename":"psutil-5.0.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e35cb38037973ff05bc52dac4f382d17028104d77f0bb51792de93f359046902"},"provenance":null,"requires-python":null,"size":180171,"upload-time":"2016-11-06T18:29:15.915700Z","url":"https://files.pythonhosted.org/packages/98/ef/40582d2d3e39fdcc202a33ba6aab15f6ccb36cdcd04f6756cc9afe30df30/psutil-5.0.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py2.7.exe","hashes":{"sha256":"964e9db2641e3be6a80b5a3135f7a9425f87d8416342b4d967202e4854f3eeba"},"provenance":null,"requires-python":null,"size":411778,"upload-time":"2016-11-06T18:29:32.458135Z","url":"https://files.pythonhosted.org/packages/74/f0/e8964d58e12c7716775157821de2e758fece2581bc9f3b7c333a4de29b90/psutil-5.0.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.3.exe","hashes":{"sha256":"d7b933193322523314b0b2d699a43e43a70f43016f73782dfd892bc7ee95ecd1"},"provenance":null,"requires-python":null,"size":410125,"upload-time":"2016-11-06T18:29:37.513499Z","url":"https://files.pythonhosted.org/packages/6e/a9/4438ec3289e3925a638cb079039b748ee4fb7e3ba18a93baed39f4fcd11e/psutil-5.0.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.4.exe","hashes":{"sha256":"8709a5057d42d5e55f3940bb1e70370316defb3da03ad869342755b5a2c17c78"},"provenance":null,"requires-python":null,"size":410086,"upload-time":"2016-11-06T18:29:41.067409Z","url":"https://files.pythonhosted.org/packages/db/85/c2e27aab6db3c4d404f0e81762f5a962b7213caed0a789cb5df2990ac489/psutil-5.0.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win-amd64-py3.5.exe","hashes":{"sha256":"c065eaf76a5423341f511e732f1a17e75a55dc4aceee9a321a619a5892aec18f"},"provenance":null,"requires-python":null,"size":780670,"upload-time":"2016-11-06T18:29:45.597507Z","url":"https://files.pythonhosted.org/packages/27/fd/12a4ef4a9940331a5521216e839444dcab0addd3a49fb90c940bdc40e46e/psutil-5.0.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py2.7.exe","hashes":{"sha256":"8eca28511d493209f59fe99cebfb8ecc65b8d6691f8a80fa3ab50dbb4994c81b"},"provenance":null,"requires-python":null,"size":381779,"upload-time":"2016-11-06T18:29:49.728094Z","url":"https://files.pythonhosted.org/packages/bc/77/457ddeac355fe88c8d4ee8062ce66ab5dd142f5c9423d1bfd10a568c7884/psutil-5.0.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.3.exe","hashes":{"sha256":"7a8e7654789c468d2a6c32508638563741046f138405fea2a4427a9228ac86f4"},"provenance":null,"requires-python":null,"size":376623,"upload-time":"2016-11-06T18:29:53.256127Z","url":"https://files.pythonhosted.org/packages/8d/1a/2f61de7f89602dfd975f961bf057522ff53ef3bdc48610dbdcf306b542df/psutil-5.0.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.4.exe","hashes":{"sha256":"4db1f1d8655a63832c9ab85d77c969ab95b740128ca9053b5c108a1e5efe6a7c"},"provenance":null,"requires-python":null,"size":376624,"upload-time":"2016-11-06T18:29:56.669027Z","url":"https://files.pythonhosted.org/packages/c1/3f/d8921d1a8672545a390fd874b77c9a30444b64ab5f8c48e2e9d971f4e98f/psutil-5.0.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.win32-py3.5.exe","hashes":{"sha256":"10f05841e3bf7b060b3779367b9cd953a6c97303c08a0e2630a9e461ce124412"},"provenance":null,"requires-python":null,"size":647782,"upload-time":"2016-11-06T18:30:00.475783Z","url":"https://files.pythonhosted.org/packages/ec/53/dc7d9e33e77efd26f7c4a9ba8d1e23ba9ce432077e16a55f1f755970e7f7/psutil-5.0.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.0.zip","hashes":{"sha256":"5411e22c63168220f4b8cc42fd05ea96f5b5e65e08b93b675ca50653aea482f8"},"provenance":null,"requires-python":null,"size":374074,"upload-time":"2016-11-06T18:41:47.892123Z","url":"https://files.pythonhosted.org/packages/93/7f/347309562d30c688299727e65f4d76ef34180c406dfb6f2c7b6c8d746e13/psutil-5.0.0.zip","yanked":false},{"core-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"data-dist-info-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"filename":"psutil-5.0.1-cp27-none-win32.whl","hashes":{"sha256":"1f2379809f2182652fc740faefa511f78b5975e6471e5fa419882dd9e082f245"},"provenance":null,"requires-python":null,"size":176737,"upload-time":"2016-12-21T01:35:18.007609Z","url":"https://files.pythonhosted.org/packages/cd/2d/ecb32ce765c52780768e4078d4d2916bdaa790b313c454f52aebe27d559d/psutil-5.0.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"data-dist-info-metadata":{"sha256":"3c16b5cea3c7592513b1491a7696e113d3ba33a4a94d74841ee2340fb4081106"},"filename":"psutil-5.0.1-cp27-none-win_amd64.whl","hashes":{"sha256":"86d67da7bfed474b5b0d545b29211f16d622e87c4089de5ea41a3fbcfc4872c7"},"provenance":null,"requires-python":null,"size":179100,"upload-time":"2016-12-21T01:35:20.364405Z","url":"https://files.pythonhosted.org/packages/6b/7e/68835630dcc765452b76b61936f75c1ef71fceae8ebaa7ecb27e42bf3f28/psutil-5.0.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp33-cp33m-win32.whl","hashes":{"sha256":"6a95283fd048810811cf971bec5cec3998e1e62e66237ef7a41a42dd0da29f8c"},"provenance":null,"requires-python":null,"size":176612,"upload-time":"2016-12-21T01:35:22.141278Z","url":"https://files.pythonhosted.org/packages/43/46/3fad73a8c581f63f08fb1f93ef5651e939caa5601a50baca7f2af3c54e2b/psutil-5.0.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"8f492b531c4321c7c43ef82b60421f4bcf5ded4ba4e13f534c064ad6c2d910ed"},"provenance":null,"requires-python":null,"size":178930,"upload-time":"2016-12-21T01:35:23.896324Z","url":"https://files.pythonhosted.org/packages/b0/d0/6d9e39115aaab0d8d52422b909e365938a6dcebe5fa04fac3a6b70398aee/psutil-5.0.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp34-cp34m-win32.whl","hashes":{"sha256":"5cc1b91d4848453b74ad8e63275a19e784ef3acd943c3627134a607b602bc31d"},"provenance":null,"requires-python":null,"size":176623,"upload-time":"2016-12-21T01:35:26.391755Z","url":"https://files.pythonhosted.org/packages/31/21/d836f37c8fde1760e889b0ace67e151c6e56f2ce819b227715a5f291452f/psutil-5.0.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"55874a1814faceaa090b7fa7addbf350603fd7042562adaae13eb6e46d3ec907"},"provenance":null,"requires-python":null,"size":178917,"upload-time":"2016-12-21T01:35:28.280103Z","url":"https://files.pythonhosted.org/packages/a1/9c/cb3f68be56ab366dbf4c901002d281e30c50cf951377ca8155c0ad304394/psutil-5.0.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp35-cp35m-win32.whl","hashes":{"sha256":"7f2d7b97faa524f75736dfde418680eff332f4be66d6217b67d09c630c90d02e"},"provenance":null,"requires-python":null,"size":178514,"upload-time":"2016-12-21T01:35:30.152277Z","url":"https://files.pythonhosted.org/packages/f7/f1/dd823eab436db1eac1ca2c8364918786584db996dc4d2bef5a3b0ebd7619/psutil-5.0.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bf4072d4d188802505b9229ec00e141083c127bb19a6c5636c62b0daabda4bd5"},"provenance":null,"requires-python":null,"size":181835,"upload-time":"2016-12-21T01:35:32.091445Z","url":"https://files.pythonhosted.org/packages/2a/3a/107a964dc66cb4f22af9e919dde846b73c0b4ff735b10ede680895ed296c/psutil-5.0.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp36-cp36m-win32.whl","hashes":{"sha256":"786bbbeb3ea98d82ff5cedc86b640bad97bff435c819f26bddaa388da58d47da"},"provenance":null,"requires-python":null,"size":178650,"upload-time":"2017-01-15T18:27:34.549244Z","url":"https://files.pythonhosted.org/packages/c0/a1/c5d0aa766323b150dce5e51a5360542ccb75c109723d2d95e70d8cb248b8/psutil-5.0.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"data-dist-info-metadata":{"sha256":"b03798768de1ae02a3387726d3bb1c881c70cdee8bea158f236b08758379017e"},"filename":"psutil-5.0.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"544c0803760995fe42a2b7050cfd6ed32379b09ce6cd7a1eaf89c221d8669cc3"},"provenance":null,"requires-python":null,"size":181970,"upload-time":"2017-01-15T18:27:39.376642Z","url":"https://files.pythonhosted.org/packages/c0/e4/bf1059c5dd55abf65fe2ac92a0b24a92d09644a9bbc17f1ad2b497ae9d7d/psutil-5.0.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.tar.gz","hashes":{"sha256":"9d8b7f8353a2b2eb6eb7271d42ec99d0d264a9338a37be46424d56b4e473b39e"},"provenance":null,"requires-python":null,"size":326693,"upload-time":"2016-12-21T01:35:34.145966Z","url":"https://files.pythonhosted.org/packages/d9/c8/8c7a2ab8ec108ba9ab9a4762c5a0d67c283d41b13b5ce46be81fdcae3656/psutil-5.0.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py2.7.exe","hashes":{"sha256":"0c54e3b7cdc0dbb8a19b58c3eb3845a5f9f48d3be2b06ed9aa1e553db8f9db74"},"provenance":null,"requires-python":null,"size":414521,"upload-time":"2016-12-21T01:35:36.513939Z","url":"https://files.pythonhosted.org/packages/3d/90/61f2860cd2c39a4381e415897b7ff94aab21c9aca38690d0c99c1c83b85f/psutil-5.0.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.3.exe","hashes":{"sha256":"0fccb19631d555998fc8c98840c83678244f873486d20d5f24ebb0ac8e19d2f1"},"provenance":null,"requires-python":null,"size":412871,"upload-time":"2016-12-21T01:35:38.959549Z","url":"https://files.pythonhosted.org/packages/05/f7/6ba6efe79620bcaa9af41e0a8501e477815edccc0cad4bd379a8e8bea89c/psutil-5.0.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.4.exe","hashes":{"sha256":"77fde4936f26080aa14b89d292b3ebefabb80be69ef407352cbad6d2ff6882d4"},"provenance":null,"requires-python":null,"size":412858,"upload-time":"2016-12-21T01:35:42.062765Z","url":"https://files.pythonhosted.org/packages/c7/b3/3b83e69b5d96ed052b45f1fe88882b3976a3a066c0497597d3ce1407f17f/psutil-5.0.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.5.exe","hashes":{"sha256":"a9125b7bc12127174cf7974444ca2b39a3722f59ead1d985053e7358a3d29acd"},"provenance":null,"requires-python":null,"size":783380,"upload-time":"2016-12-21T01:35:44.660601Z","url":"https://files.pythonhosted.org/packages/4e/cf/d1004fa0617f6d6e39adf48d242f76d5d43ecd497f46add2abb513b6ffcd/psutil-5.0.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win-amd64-py3.6.exe","hashes":{"sha256":"9a3f1413b24b6751e97e51284761e1778ec0cd0a456595edad6c2f7c115b3368"},"provenance":null,"requires-python":null,"size":783511,"upload-time":"2017-01-15T18:25:42.785800Z","url":"https://files.pythonhosted.org/packages/a0/94/1f29e03230504dafeb128a4c6e381606b038ce5d4dc9b8731632eb6b0928/psutil-5.0.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py2.7.exe","hashes":{"sha256":"671c7b2d3fa8deffb879e9cb6cc00d83d1d990bc81f0c487576b70e811f102bf"},"provenance":null,"requires-python":null,"size":384515,"upload-time":"2016-12-21T01:35:47.208014Z","url":"https://files.pythonhosted.org/packages/2d/7c/85aa8efb36c4fcac4a845b9cfc0744c502620394cdb81db574dd20f7dda0/psutil-5.0.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.3.exe","hashes":{"sha256":"603bd19426b59762ad55ba5a0b8237282868addf2d0930e21b4dca79fc188787"},"provenance":null,"requires-python":null,"size":379325,"upload-time":"2016-12-21T01:35:49.642792Z","url":"https://files.pythonhosted.org/packages/1c/06/201f913389b920c24153fbfdc07c7a451653b00688d6c2ba92428b9a2c23/psutil-5.0.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.4.exe","hashes":{"sha256":"08e28b4dba54dd6b0d84718c988239c305e58c7f93160496661955de4f6cfe13"},"provenance":null,"requires-python":null,"size":379338,"upload-time":"2016-12-21T01:35:52.592934Z","url":"https://files.pythonhosted.org/packages/58/27/a42b1d12c201880822fd92588321e489c869f4b72eb906f8f79745bee6cb/psutil-5.0.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.5.exe","hashes":{"sha256":"1e71dd9aa041a7fa55f3bcc78b578e84f31004e6ce9df97229f05c60529fedb1"},"provenance":null,"requires-python":null,"size":650529,"upload-time":"2016-12-21T01:35:55.051616Z","url":"https://files.pythonhosted.org/packages/fb/c6/c60717f25c8ccfddabd57109d03580d24542eedde8d23a673328876b4137/psutil-5.0.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.0.1.win32-py3.6.exe","hashes":{"sha256":"c879310328c0c248331dffeea4adbe691fad7b7095cf9c2ac0a4d78a09cd8a17"},"provenance":null,"requires-python":null,"size":650663,"upload-time":"2017-01-15T18:25:51.768008Z","url":"https://files.pythonhosted.org/packages/00/09/04898f2ce604af89d7ca6866632c05a1fb0fbd7b5ea0c7e84a62570c2678/psutil-5.0.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"data-dist-info-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"filename":"psutil-5.1.0-cp27-cp27m-win32.whl","hashes":{"sha256":"85524e46a1c0c7f5274640809deb96c7cdb5133a0eb805bbed0a1f825c8de77e"},"provenance":null,"requires-python":null,"size":183880,"upload-time":"2017-02-01T18:27:27.314031Z","url":"https://files.pythonhosted.org/packages/d9/bf/eae1c0aa2a5a01456e78d5df4c7cefc512854a24f43103034180ff5ea92f/psutil-5.1.0-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"data-dist-info-metadata":{"sha256":"45f08e36846b408dfbda38b60b36dd8b6430d6fbd955f5945dc985a85eac6068"},"filename":"psutil-5.1.0-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"0a64f395295aafe7c22d6cde81076151bf80f26e180e50c00c1cde5857cad224"},"provenance":null,"requires-python":null,"size":186335,"upload-time":"2017-02-01T18:27:35.043588Z","url":"https://files.pythonhosted.org/packages/f6/5d/67120bb4cea2432d333cdf0ab406336ef62122caacb2379e73a88a9cde82/psutil-5.1.0-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp33-cp33m-win32.whl","hashes":{"sha256":"bd432606d09722220f8f492223e8b69343d30f21e7ed193712632e4fdcf87af2"},"provenance":null,"requires-python":null,"size":183793,"upload-time":"2017-02-01T18:27:43.056910Z","url":"https://files.pythonhosted.org/packages/26/35/ec223413c9301d8eeecf3d319d71a117dbd2847b628b079f3757d5ec693d/psutil-5.1.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"f98c37506e5abfeb2c857794ccfbce86b376cf6344210ea55f41b0ced5fd8d98"},"provenance":null,"requires-python":null,"size":186185,"upload-time":"2017-02-01T18:27:49.896261Z","url":"https://files.pythonhosted.org/packages/9f/20/bb95f30c99837f3c41a8a595752d9cc1afe595f160d0612eea6e4a905de9/psutil-5.1.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp34-cp34m-win32.whl","hashes":{"sha256":"8760214ce01f71cd6766527396607cf2b3b41e6f8a34aaa9f716090750fd9925"},"provenance":null,"requires-python":null,"size":183803,"upload-time":"2017-02-01T18:27:56.955786Z","url":"https://files.pythonhosted.org/packages/0b/f2/90a7288b36a18fb522e00116f7f5c657df9dba3a12636d2fc9bcef97f524/psutil-5.1.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"2309cf46f5db0a78f52e56e06cbb258fe76d3d54cf8ab9fa067b4c26cd722541"},"provenance":null,"requires-python":null,"size":186156,"upload-time":"2017-02-01T18:28:03.790958Z","url":"https://files.pythonhosted.org/packages/51/c6/3757b2bea37edc9889fe85e2ca9b8a2c47b3b758d35f65704f2a5ac5c13e/psutil-5.1.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp35-cp35m-win32.whl","hashes":{"sha256":"6d89d5f68433afe6755bd26ae3ea4587f395c7613d7be5bc4f0f97b1e299228a"},"provenance":null,"requires-python":null,"size":185696,"upload-time":"2017-02-01T18:28:10.369149Z","url":"https://files.pythonhosted.org/packages/30/9c/322df29c490ceb97d8cbbc663424fad94e900a1921d03cc9c61e36f17444/psutil-5.1.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b3c15965b2dfad34ea79494f82007e71b02e1c5352b551d00647fb2be9deabe1"},"provenance":null,"requires-python":null,"size":189130,"upload-time":"2017-02-01T18:28:17.197543Z","url":"https://files.pythonhosted.org/packages/b3/3a/37d6bf7dedf263e1119b03aaee8565182bf2577ed5ecd7975e253e242bd9/psutil-5.1.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp36-cp36m-win32.whl","hashes":{"sha256":"d32551c242c041b0506d13cfd271db56ba57323283b1f952b858505824f3e82a"},"provenance":null,"requires-python":null,"size":185695,"upload-time":"2017-02-01T18:28:25.059542Z","url":"https://files.pythonhosted.org/packages/42/0b/5ee6feda28c2895b0e8cae4d828d356e13e29bf88bc614065e490bfc8b51/psutil-5.1.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"data-dist-info-metadata":{"sha256":"f1cc4b1bb4982cfc6e8259dbc0fd96789e31eff9b65d8e5a44401e11d9926c55"},"filename":"psutil-5.1.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"3b821bb59911afdba5c0c28b1e6e7511cfb0869dd8827c3ab6916ead508c9155"},"provenance":null,"requires-python":null,"size":189127,"upload-time":"2017-02-01T18:28:32.228516Z","url":"https://files.pythonhosted.org/packages/af/6f/ef0799221597f367171c0bb8b3f1b22865e6b7507ee26e1a6a16f408a058/psutil-5.1.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.tar.gz","hashes":{"sha256":"7570e1d82345fab3a0adce24baf993adbca4c87a1be2fa6ee79babdaafa817fb"},"provenance":null,"requires-python":null,"size":339603,"upload-time":"2017-02-01T18:29:04.029583Z","url":"https://files.pythonhosted.org/packages/ba/5f/87b151dd53f8790408adf5096fc81c3061313c36a089d9f7ec9e916da0c1/psutil-5.1.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py2.7.exe","hashes":{"sha256":"07aab3a12c00315a144b2a61d384364e64077c08c0a79966f18b744d867f9727"},"provenance":null,"requires-python":null,"size":422485,"upload-time":"2017-02-01T18:24:47.444024Z","url":"https://files.pythonhosted.org/packages/8c/1c/8bf1c2f6f2b4f012449bd9781d55397e85e30487c2879ed35569c7f616de/psutil-5.1.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.3.exe","hashes":{"sha256":"b78de627c157b4889e055fd00a635ad0fbe107ae4b3059f419738edbfb15b3f4"},"provenance":null,"requires-python":null,"size":420852,"upload-time":"2017-02-01T18:25:00.582537Z","url":"https://files.pythonhosted.org/packages/de/5a/3041f7d07d9699ef148291721ee167608761e223bc26bbe33483cbe90517/psutil-5.1.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.4.exe","hashes":{"sha256":"48fc3945219f6577b61a76f81fbbaa3ce6bdccf0e87650597c88aac38e63904b"},"provenance":null,"requires-python":null,"size":420825,"upload-time":"2017-02-01T18:25:14.404878Z","url":"https://files.pythonhosted.org/packages/d0/83/4e03c76cd202d4a4ead9b468cf2afa611d689b1ae17e4f152b67c05d2a27/psutil-5.1.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.5.exe","hashes":{"sha256":"98180376d2f0a3b0d24dbd8ef64da4aac46f98ccc84d2e3ebc3a486b97a75915"},"provenance":null,"requires-python":null,"size":791399,"upload-time":"2017-02-01T18:25:37.374511Z","url":"https://files.pythonhosted.org/packages/ff/86/328005e07308a87f4d86108a51f940fba1fb1c4f60d4676f80fc66a9dd7a/psutil-5.1.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win-amd64-py3.6.exe","hashes":{"sha256":"a574d3fb56514ae98f2836a218b0dcf6daeb31b9945cec9b7daa9b619ad3005a"},"provenance":null,"requires-python":null,"size":791396,"upload-time":"2017-02-01T18:26:00.310591Z","url":"https://files.pythonhosted.org/packages/83/86/88c20e9ebb1565598401b23ece21367bd059d569cb0ce797509ebdc429be/psutil-5.1.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py2.7.exe","hashes":{"sha256":"b014a8df14f00054762a2ef6f9a449ccde18d9c4de48dc8cb1809343f328f83d"},"provenance":null,"requires-python":null,"size":392388,"upload-time":"2017-02-01T18:26:13.878537Z","url":"https://files.pythonhosted.org/packages/a5/e8/1032177e5af2300b39aa50623e0df4d9a91a9b316803aab8f597e6c855e2/psutil-5.1.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.3.exe","hashes":{"sha256":"01e68d047f5023d4cb55b3a2653e296d86f53abc7e63e74c8abeefa627d9307f"},"provenance":null,"requires-python":null,"size":387232,"upload-time":"2017-02-01T18:26:25.910876Z","url":"https://files.pythonhosted.org/packages/cc/b8/24bf07e83d063f552132e7808d7029663466ebed945c532ba05068c65ae3/psutil-5.1.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.4.exe","hashes":{"sha256":"bfd279124512ee1b744eb7efa269be2096e0ce7075204daccd6f4b73c359316c"},"provenance":null,"requires-python":null,"size":387243,"upload-time":"2017-02-01T18:26:38.999172Z","url":"https://files.pythonhosted.org/packages/2a/ad/40d39c8911ca0783df9684649038241913fa3119c74030b9d1a02eb28da3/psutil-5.1.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.5.exe","hashes":{"sha256":"518356f5384a8996eb4056b6fd01a28bb502476e5d0ab9bd112d8e1dc9ce041a"},"provenance":null,"requires-python":null,"size":658437,"upload-time":"2017-02-01T18:26:58.991042Z","url":"https://files.pythonhosted.org/packages/db/b1/023fa6a995356c4a4ae68ba53e1269d693ad66783ee2c0c4ac1d6e556226/psutil-5.1.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.0.win32-py3.6.exe","hashes":{"sha256":"23670901cfa4308cc6c442e08efcd93c6a2adb3bfdbbf51d4c120fc2a1595899"},"provenance":null,"requires-python":null,"size":658436,"upload-time":"2017-02-01T18:27:18.934060Z","url":"https://files.pythonhosted.org/packages/f8/ee/be644cdded3a5761f22cd0255534f04ad89a6fabdfb85f58100d25b6bf1a/psutil-5.1.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"data-dist-info-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"filename":"psutil-5.1.1-cp27-none-win32.whl","hashes":{"sha256":"b9cc631c31794f8150a034a15448ecbde6c65ab078437eb01e0a71103bced297"},"provenance":null,"requires-python":null,"size":184444,"upload-time":"2017-02-03T12:00:02.925645Z","url":"https://files.pythonhosted.org/packages/e3/6f/3546783d70949aff150555cafb1cdd51cfddbb2fea042ed3d5b930232233/psutil-5.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"data-dist-info-metadata":{"sha256":"b880ef4983d10a0a227170484a19bf585b91f8d2cf0238488b8a0e39337acdad"},"filename":"psutil-5.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"d723be81a8db76ad6d78b04effd33e73813567eb1b1b7669c6926da033cb9774"},"provenance":null,"requires-python":null,"size":186898,"upload-time":"2017-02-03T12:00:10.481992Z","url":"https://files.pythonhosted.org/packages/48/98/9f3277e1d4a6d6fbc501146b9f5e8547c793df038dfa7037816edbf90325/psutil-5.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp33-cp33m-win32.whl","hashes":{"sha256":"5fc6d4fe04f014ea68392d1e7ab7103637b9dcbfd7bf3bc6d9d482177bf82777"},"provenance":null,"requires-python":null,"size":184356,"upload-time":"2017-02-03T12:00:18.015691Z","url":"https://files.pythonhosted.org/packages/98/fa/c43ce8992690d3b674259f21c897dab254b3fbbb2758254787e4b0f5aee8/psutil-5.1.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"7d0c6f77ebeb248ee62383340a8bd5a9b067e64618c9056d701eefdccf27f9f4"},"provenance":null,"requires-python":null,"size":186735,"upload-time":"2017-02-03T12:00:25.248665Z","url":"https://files.pythonhosted.org/packages/e1/4f/7d16da2b82d615a7fc57f159e5e7c8776c7b794ca6330a9318ca93eb735b/psutil-5.1.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp34-cp34m-win32.whl","hashes":{"sha256":"d31859dae480bc1a0be48f239bcf3caa26447fae177549a30c4b1a2a2776f299"},"provenance":null,"requires-python":null,"size":184362,"upload-time":"2017-02-03T12:00:31.866390Z","url":"https://files.pythonhosted.org/packages/bc/a8/3f3e69227217d1e7355e6de1980f357f6151ce1543bd520652b47823f93e/psutil-5.1.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"857a3620b12a33ed4169aee959e1640e7323f18dd7726035cc057e1d39639df2"},"provenance":null,"requires-python":null,"size":186740,"upload-time":"2017-02-03T12:00:39.950524Z","url":"https://files.pythonhosted.org/packages/d3/2c/974ced45441b7adf476f1b32ac3f7840f0d7ae295dd4512de21997e2049b/psutil-5.1.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp35-cp35m-win32.whl","hashes":{"sha256":"4ed11e8caff64c452a2eee8c1bea614b717a8e66e97fc88ce272d98a6499cb9a"},"provenance":null,"requires-python":null,"size":186257,"upload-time":"2017-02-03T12:00:46.799733Z","url":"https://files.pythonhosted.org/packages/2f/17/cb34ac2f50ff6499e6b64837a2d34b92696ff1dc14e57933363d94b7301c/psutil-5.1.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"3115d7acbf3cc81345fd7252946a59c3730f7baba546361a535f0a8f00d862c9"},"provenance":null,"requires-python":null,"size":189715,"upload-time":"2017-02-03T12:00:55.165186Z","url":"https://files.pythonhosted.org/packages/09/da/f9f435d53711859d41ee8a0fb87177e8b30b5dbca5bd06dd05b5c4b46ef3/psutil-5.1.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp36-cp36m-win32.whl","hashes":{"sha256":"9f6cb84d0f8e0c993c91d10ef86c637b7f1c1d4d4ca63ec0a73545cc13e9656a"},"provenance":null,"requires-python":null,"size":186256,"upload-time":"2017-02-03T12:01:01.728292Z","url":"https://files.pythonhosted.org/packages/24/19/20a4a33db5d005959458f68816fbb725791ee7843ba4f8a40dfd38e8e840/psutil-5.1.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"data-dist-info-metadata":{"sha256":"9de4440590e9d06325c73aa9a0f85d5e2beb77f570187d8aa12add76025de520"},"filename":"psutil-5.1.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"35311e26f7138276fa3e7af86bcb8ecbaee945c3549e690a481379075de386ba"},"provenance":null,"requires-python":null,"size":189711,"upload-time":"2017-02-03T12:01:08.476075Z","url":"https://files.pythonhosted.org/packages/6e/2b/44aea26dc3a304285e8eb91af628c9722ba4e1f44f7969cc24fded4aa744/psutil-5.1.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.tar.gz","hashes":{"sha256":"ece06401d719050a84cca97764ff5b0e41aafe6b6a2ec8a1d0bb89ca5e206d0f"},"provenance":null,"requires-python":null,"size":341006,"upload-time":"2017-02-03T12:01:19.347630Z","url":"https://files.pythonhosted.org/packages/49/ed/2a0b13f890e798b6f1f3625f0e87e5b712471d2c1c625bdcd396d36c56dc/psutil-5.1.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py2.7.exe","hashes":{"sha256":"e75edc462005475da019f82c8a13b215e2e48db8f284d8be14308b611505d185"},"provenance":null,"requires-python":null,"size":423004,"upload-time":"2017-02-03T12:01:32.247678Z","url":"https://files.pythonhosted.org/packages/99/35/96acf109f463ce31cd29ec327d9b3b1c3eb13afbc5635e54c75e1e22c924/psutil-5.1.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.3.exe","hashes":{"sha256":"e18274b77e61b3774bcf11a4aa368032fe3bbc21e4217ca903c77541fbe00eef"},"provenance":null,"requires-python":null,"size":421360,"upload-time":"2017-02-03T12:01:46.775449Z","url":"https://files.pythonhosted.org/packages/b7/56/70fc2173d34f0ee73215a0e88e2702933cf1549e3ff3d8f2d757b9e1351c/psutil-5.1.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.4.exe","hashes":{"sha256":"76307f8ac94adc87509df43bba28706c27d6c5e4b7429fb658dd5905adae4dc3"},"provenance":null,"requires-python":null,"size":421366,"upload-time":"2017-02-03T12:02:01.021939Z","url":"https://files.pythonhosted.org/packages/f1/9b/961442950e039c65938665dcbe6e72bff1a2dbbd6c6c08c55e3e10db38ed/psutil-5.1.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.5.exe","hashes":{"sha256":"8101a2b83fa3b93fbf5d5edca7169a4289f34ace2ee25d0f758cec5ae553190f"},"provenance":null,"requires-python":null,"size":791943,"upload-time":"2017-02-03T12:02:23.633303Z","url":"https://files.pythonhosted.org/packages/bb/69/95fdd45b2c1cc4735760b81d826a62433d6726ab6e8e6e2e982fb1264c20/psutil-5.1.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win-amd64-py3.6.exe","hashes":{"sha256":"b16b48868a58322edd240cf55a0855e1b6fead3e5f02a41b73503d5c47acf330"},"provenance":null,"requires-python":null,"size":791938,"upload-time":"2017-02-03T12:02:48.386069Z","url":"https://files.pythonhosted.org/packages/15/b4/1ba8944aaae568f8f4acd7fd3ca46a95077f07b005774f212226c99a82d8/psutil-5.1.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py2.7.exe","hashes":{"sha256":"12aeeaf5269bc75ed605ffc4979cb95c889989b40d307adf067f04f93f6d3365"},"provenance":null,"requires-python":null,"size":392908,"upload-time":"2017-02-03T12:03:01.259012Z","url":"https://files.pythonhosted.org/packages/d0/38/c274e67564aed7475fba4e0f9eaac3235797226df0b68abce7f3fc96bffa/psutil-5.1.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.3.exe","hashes":{"sha256":"2f51c669bd528982fc5397d9c84b8b389a56611c111159b1710570db33fc9750"},"provenance":null,"requires-python":null,"size":387752,"upload-time":"2017-02-03T12:03:13.897990Z","url":"https://files.pythonhosted.org/packages/d9/51/52e109c7884a6fa931882081e94dfd0e1b6adb054d4fc82943e1c9b691d2/psutil-5.1.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.4.exe","hashes":{"sha256":"f68ce5d80db909ee655ac8a322cda3abf47f41c134e7cf61b25565f116fce33f"},"provenance":null,"requires-python":null,"size":387758,"upload-time":"2017-02-03T12:03:26.769319Z","url":"https://files.pythonhosted.org/packages/5e/ee/ff6d626da64a799db055bab9f69ff9a50612a645781d14c24078bca418cb/psutil-5.1.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.5.exe","hashes":{"sha256":"380aa69aa529e4a4e35579d3e0320617e112473240c95b815d3b421c86e2ab6c"},"provenance":null,"requires-python":null,"size":658955,"upload-time":"2017-02-03T12:03:45.921701Z","url":"https://files.pythonhosted.org/packages/62/9b/847c9c6b1c053a15b44ccf809fce54bbd71e466fd8c1b8eecb0f8bbeb2ce/psutil-5.1.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.1.win32-py3.6.exe","hashes":{"sha256":"bd3b881faa071a5f6f999d036cfc0d744eed223390fde05ae2a74f0f514f8bd0"},"provenance":null,"requires-python":null,"size":658953,"upload-time":"2017-02-03T12:04:04.770301Z","url":"https://files.pythonhosted.org/packages/80/ef/c23e653bbc1a523217d676fac3ac4050e9fe4d673c84680498c02ff89d23/psutil-5.1.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"data-dist-info-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"filename":"psutil-5.1.2-cp27-none-win32.whl","hashes":{"sha256":"caa870244015bb547eeab7377d9fe41c44319fda6862aa56974108a224c04b1a"},"provenance":null,"requires-python":null,"size":185018,"upload-time":"2017-02-03T19:13:24.939112Z","url":"https://files.pythonhosted.org/packages/57/bc/e0a5e35a9b7f407e229db75b24c46bef012609450d7eac6b5e596a604acb/psutil-5.1.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"data-dist-info-metadata":{"sha256":"40c22031c3c1f82a2758dbd44797eade645ac30207e45f42cb9da4fd1dd3808f"},"filename":"psutil-5.1.2-cp27-none-win_amd64.whl","hashes":{"sha256":"d60d978f5a9b4bc9bb22c5c4bbeb50043db6fb70e3270c08f51e81357f8ca556"},"provenance":null,"requires-python":null,"size":187473,"upload-time":"2017-02-03T19:13:32.487659Z","url":"https://files.pythonhosted.org/packages/84/bd/49681360ca11a1aeba5e48b80b6bd576695a67fe15baca144c6bfcbc9285/psutil-5.1.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp33-cp33m-win32.whl","hashes":{"sha256":"61b9104157df03790fae3b138afb64ad3ecb663669ee3548e609306e0b35ca61"},"provenance":null,"requires-python":null,"size":184928,"upload-time":"2017-02-03T19:13:39.838419Z","url":"https://files.pythonhosted.org/packages/59/c7/7f31631d96ba58e81ad03b4f7cee234a35c67edc44b2fe5936e41e7d1e9e/psutil-5.1.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"11bfc49cd680dec42c9a7200f8b0cc4d89a9d5dbad7f3b027cfac3a305343a2a"},"provenance":null,"requires-python":null,"size":187306,"upload-time":"2017-02-03T19:13:47.199966Z","url":"https://files.pythonhosted.org/packages/a3/dc/0c87a42dbff252ab68263f88e3bd8ffaa02d766e56f743cc9074bb28c0e1/psutil-5.1.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp34-cp34m-win32.whl","hashes":{"sha256":"75b27bac9e91e9868723d8964e73a157799c26190978029b0ef294ad7727d91d"},"provenance":null,"requires-python":null,"size":184936,"upload-time":"2017-02-03T19:13:54.487932Z","url":"https://files.pythonhosted.org/packages/e6/2c/fa2d3770ea68f7f7577bfcf3fc00a2a68760e7d78b8ccb4a323fb44b27fa/psutil-5.1.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"abcfbf43eb47372e961278ee7da9a4757d59999462225b358f49c8e69a393f32"},"provenance":null,"requires-python":null,"size":187315,"upload-time":"2017-02-03T19:14:02.683013Z","url":"https://files.pythonhosted.org/packages/ed/bf/cc8cdbfc7e10518e2e1141e0724623f52bc2f41e7bdd327f8ed63e0edc01/psutil-5.1.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp35-cp35m-win32.whl","hashes":{"sha256":"3fd346acebeb84d9d351cabc02ea1bee1536fb7e165e7e5ead0e0912ce40cbb1"},"provenance":null,"requires-python":null,"size":186829,"upload-time":"2017-02-03T19:14:10.158362Z","url":"https://files.pythonhosted.org/packages/bf/60/e78e3455085393ab4902ef9b1c82e52d89f7b212582c58b76407a7078ad6/psutil-5.1.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"69644ed20c08bd257039733c71a47d871f5bdd481d63f8408e28f03f491e2a03"},"provenance":null,"requires-python":null,"size":190288,"upload-time":"2017-02-03T19:14:17.352480Z","url":"https://files.pythonhosted.org/packages/55/0a/46eba44208248da5aaeadeeab57aac3ee172df8a7291ad5d62efbed566ee/psutil-5.1.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp36-cp36m-win32.whl","hashes":{"sha256":"006ea083c66aa2a2be18bce84e35d0f3301d4ee3c869cb9d475fecce68470a71"},"provenance":null,"requires-python":null,"size":186826,"upload-time":"2017-02-03T19:14:24.235507Z","url":"https://files.pythonhosted.org/packages/26/e4/f5316795a709397e911eca478d547a3bb51b8dca447b7ed62d328cafa570/psutil-5.1.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"data-dist-info-metadata":{"sha256":"0f6bf0464a251593159b71879d6e05ca05190e53d209a32229b793365d8de056"},"filename":"psutil-5.1.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"b64fa3a1ec7e74689b093ee6b3a487979157f81915677b9145585a2babe1b9f5"},"provenance":null,"requires-python":null,"size":190282,"upload-time":"2017-02-03T19:14:31.621854Z","url":"https://files.pythonhosted.org/packages/c0/e2/2c758b825b48eb9ae30676499a862b8475efdf683952efbb63f531413489/psutil-5.1.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.tar.gz","hashes":{"sha256":"43f32b0a392c80cff0f480bd0792763333e46d7062285dd1226b70473c55e8ac"},"provenance":null,"requires-python":null,"size":341325,"upload-time":"2017-02-03T19:14:42.976980Z","url":"https://files.pythonhosted.org/packages/19/2c/41c601cdd5586f601663d6985ff2cf1c5322f1ffd32d67d3001035d9f81d/psutil-5.1.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py2.7.exe","hashes":{"sha256":"a44f1735f8464b5cde862d76a78843869da02e1454278a38b1026c9cfa172daf"},"provenance":null,"requires-python":null,"size":423677,"upload-time":"2017-02-03T19:14:56.817144Z","url":"https://files.pythonhosted.org/packages/f2/0e/f26bd5b5e0293f715e18b1de0e46eb3378c8b2a2f54ce67bb48ee47dff44/psutil-5.1.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.3.exe","hashes":{"sha256":"e8bb29ba0e1526de8932025e07c13f6e26ab43a4cc2861b849ab2daf83ef4c3a"},"provenance":null,"requires-python":null,"size":422033,"upload-time":"2017-02-03T19:15:12.278688Z","url":"https://files.pythonhosted.org/packages/82/d1/e86d5892bfeb5b8439a96b39b2acc892aa54b9df9feb75ef7384673fe883/psutil-5.1.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.4.exe","hashes":{"sha256":"71cd26331eb0c26ba19d5acb67716741666a581f90bce35cc5cb733eb6bbb087"},"provenance":null,"requires-python":null,"size":422041,"upload-time":"2017-02-03T19:15:27.020838Z","url":"https://files.pythonhosted.org/packages/9f/75/f9232734ab6cdf3d656a4ef65fbe5440948c38db910002a4570b01e233d2/psutil-5.1.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.5.exe","hashes":{"sha256":"e3ea19ac2c6e1d54cb3de5919040018af2b5a0d846f7f9dc0cc4e2a125725015"},"provenance":null,"requires-python":null,"size":792618,"upload-time":"2017-02-03T19:15:52.787383Z","url":"https://files.pythonhosted.org/packages/e9/3d/cb2444851956cc4c1fe62bc4b266881e07f16b4be3cdc7b5c1ead5d99b76/psutil-5.1.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win-amd64-py3.6.exe","hashes":{"sha256":"18ad3e6d3b46dc56eda32674e9da77527bb4ac98503e45c89837fba641a2cc16"},"provenance":null,"requires-python":null,"size":792613,"upload-time":"2017-02-03T19:16:17.350579Z","url":"https://files.pythonhosted.org/packages/36/a5/803a7fdb45924ee69221259184bb2766a1a2819d91e806912f53c6dccc6d/psutil-5.1.2.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py2.7.exe","hashes":{"sha256":"1f8e54923b5d80b880d0dbc2ec5bcf51cbf1db7d54e4d2acdeeb02f42a21735a"},"provenance":null,"requires-python":null,"size":393580,"upload-time":"2017-02-03T19:16:30.238524Z","url":"https://files.pythonhosted.org/packages/b6/89/191e13e1ba569fd143c66fe340e820b909fef8599f78237cc505dd59552b/psutil-5.1.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.3.exe","hashes":{"sha256":"99a77884670999cf6c589539f1af3af66d8f59d9b8a9697b60398434933f56a8"},"provenance":null,"requires-python":null,"size":388425,"upload-time":"2017-02-03T19:16:43.231178Z","url":"https://files.pythonhosted.org/packages/45/ba/764a926681d90302a54494d59665ea906676b974c2ae0af7b44d5d6d9f24/psutil-5.1.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.4.exe","hashes":{"sha256":"2a7874d2d2718a4648cfaa4ab731f7de4867230bdcd543bf1c1fda05bc34e068"},"provenance":null,"requires-python":null,"size":388433,"upload-time":"2017-02-03T19:16:58.697184Z","url":"https://files.pythonhosted.org/packages/eb/91/98584bf6f6934c5d02b116634d6e00eddb2ec6b057556d77fdda2fe72ab0/psutil-5.1.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.5.exe","hashes":{"sha256":"42cbf7db0ce76431676da30e792b80e1228857e50afe859518b999125b5da673"},"provenance":null,"requires-python":null,"size":659629,"upload-time":"2017-02-03T19:17:19.107384Z","url":"https://files.pythonhosted.org/packages/80/b9/b17a77e77be75640594fba23837490a1dc425c9d6a9fc0b4997f5bfce984/psutil-5.1.2.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.2.win32-py3.6.exe","hashes":{"sha256":"cfd6bddd0db750b606454791432023a4260184204f4462b2a4206b7802546ead"},"provenance":null,"requires-python":null,"size":659626,"upload-time":"2017-02-03T19:17:39.500599Z","url":"https://files.pythonhosted.org/packages/8b/bd/af0e5d889818caa35fc8dc5157363c38bdb6fcb7fa1389c5daec24857a63/psutil-5.1.2.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"data-dist-info-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"filename":"psutil-5.1.3-cp27-none-win32.whl","hashes":{"sha256":"359a66879068ce609f8c034b3c575e357a92c033357f398490fc77cf8af46bf7"},"provenance":null,"requires-python":null,"size":185714,"upload-time":"2017-02-07T21:33:17.748014Z","url":"https://files.pythonhosted.org/packages/6f/c0/82c15d73633fdee59b5bd064396038a63a8920359c86460cd01d6ddcedfc/psutil-5.1.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"data-dist-info-metadata":{"sha256":"f3276ad95ad14e59ea78a4da9482d49f8096583e96beedc6b0261259c3d8e39e"},"filename":"psutil-5.1.3-cp27-none-win_amd64.whl","hashes":{"sha256":"a0becbbe09bed44f8f5dc3909c7eb383315f932faeb0029abe8d5c737e8dcc7e"},"provenance":null,"requires-python":null,"size":188166,"upload-time":"2017-02-07T21:33:23.089530Z","url":"https://files.pythonhosted.org/packages/80/92/c5136bbade8ba85d0aa2f5d5cbe8af80bac6ea1ef77c5445aa625a8caefb/psutil-5.1.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp33-cp33m-win32.whl","hashes":{"sha256":"5b2cc379287ded7f9a22521318bf010429234c2864b4146fe518f11729821771"},"provenance":null,"requires-python":null,"size":185622,"upload-time":"2017-02-07T21:33:27.925426Z","url":"https://files.pythonhosted.org/packages/b2/fb/8ad6ff1a9169b35a001ea089ab8657156df1b9b9903e218f1839fba0aae3/psutil-5.1.3-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"d0e88d2e8ac9ede745f589049a74ac1e3e614c4e5eed69e507d58bda8fa3c958"},"provenance":null,"requires-python":null,"size":188003,"upload-time":"2017-02-07T21:33:33.107156Z","url":"https://files.pythonhosted.org/packages/a7/8c/8a8bca010487f008ca026e69e76c53a025905a7bd1759567ec70d85d89a0/psutil-5.1.3-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp34-cp34m-win32.whl","hashes":{"sha256":"72b67b988c0a42825a8ca76000fc385dde85652310278cca807db7dfbcba5e7e"},"provenance":null,"requires-python":null,"size":185627,"upload-time":"2017-02-07T21:33:37.199567Z","url":"https://files.pythonhosted.org/packages/81/69/0ea7d353a82df8d8251842c71131f24b8a5cfa6982f7b89e809c37819c0b/psutil-5.1.3-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"474ab9a6abc05fcd7bb5c32cb828f3f9fc54a2cd349d63c94dff0af3b3ba7e64"},"provenance":null,"requires-python":null,"size":188011,"upload-time":"2017-02-07T21:33:41.528046Z","url":"https://files.pythonhosted.org/packages/93/82/2172e0a319e4c1387898b588e4dc9b8f2283fd9eda0a486ebe03ece2bff7/psutil-5.1.3-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp35-cp35m-win32.whl","hashes":{"sha256":"92bfc1f1929593ab7793ddce512295336e3e788b86a1bbf32701aa67c5ce27f4"},"provenance":null,"requires-python":null,"size":187522,"upload-time":"2017-02-07T21:33:45.934959Z","url":"https://files.pythonhosted.org/packages/43/74/08fc07b34eeb8e357dbe6bca02b844cf76cef15b36098611a50720bf7786/psutil-5.1.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7be50561ed0060c86385c2ef4dd8a383298f29728eb6e30955ae2ebbd4554e1a"},"provenance":null,"requires-python":null,"size":190983,"upload-time":"2017-02-07T21:33:51.074513Z","url":"https://files.pythonhosted.org/packages/fa/42/42e547764bf65617077b696c4c49bed6109b00696882a196008de5f8917b/psutil-5.1.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp36-cp36m-win32.whl","hashes":{"sha256":"4de5566d9d8c3695726f9ec3324cd56d3eb363365508ea39854d2ebe5d57b945"},"provenance":null,"requires-python":null,"size":187516,"upload-time":"2017-02-07T21:33:56.040728Z","url":"https://files.pythonhosted.org/packages/c5/5f/71b89c9dede1da356dbbe321ae410786b94e0b516791191c008864844733/psutil-5.1.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"data-dist-info-metadata":{"sha256":"ca962e552341e254e428a5583893983bb026161e7253c100c751493866519e08"},"filename":"psutil-5.1.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"678ef7b4e38281ff16dbdac98fc1d0679d46fed3fadd5d4648096fbb6d6b1b95"},"provenance":null,"requires-python":null,"size":190979,"upload-time":"2017-02-07T21:34:01.058372Z","url":"https://files.pythonhosted.org/packages/bc/21/1823e2349b1f6ec526a55d21497e5d627ac26a6c5a3d49a07b4afad45547/psutil-5.1.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.tar.gz","hashes":{"sha256":"959bd58bdc8152b0a143cb3bd822d4a1b8f7230617b0e3eb2ff6e63812120f2b"},"provenance":null,"requires-python":null,"size":341980,"upload-time":"2017-02-07T21:34:07.636785Z","url":"https://files.pythonhosted.org/packages/78/0a/aa90434c6337dd50d182a81fe4ae4822c953e166a163d1bf5f06abb1ac0b/psutil-5.1.3.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py2.7.exe","hashes":{"sha256":"6c288b7a639f341391ba474d4c8fb495a19220015284b46e7b23f626afafc810"},"provenance":null,"requires-python":null,"size":424369,"upload-time":"2017-02-07T21:34:15.354723Z","url":"https://files.pythonhosted.org/packages/07/bb/aac12b9c56722cf8b6ed0c89eccf1e3db75795576b7e3575001248802c0d/psutil-5.1.3.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.3.exe","hashes":{"sha256":"c4b53e0630b83c784f807170ae2d12f1cf1e45e3913f35f9784e5556ba4a0786"},"provenance":null,"requires-python":null,"size":422726,"upload-time":"2017-02-07T21:34:24.113585Z","url":"https://files.pythonhosted.org/packages/1e/5d/4804b1d23e0e8c442876c02438c4f89b3512806b034dea5807ca1ddd6535/psutil-5.1.3.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.4.exe","hashes":{"sha256":"57a4e51a0f2fd8f361fcf545eeff54932a29b716ad01e60247d1abaffbc1b954"},"provenance":null,"requires-python":null,"size":422733,"upload-time":"2017-02-07T21:34:32.211085Z","url":"https://files.pythonhosted.org/packages/51/70/34ea430cf5c21540e30b805f0740d81f75c5766c2f68af9207ae18e147dc/psutil-5.1.3.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.5.exe","hashes":{"sha256":"4b26f56f09ad206d9fb8b2fa29926a696419b26e2c5d461afe477481cec1105c"},"provenance":null,"requires-python":null,"size":793310,"upload-time":"2017-02-07T21:34:46.367507Z","url":"https://files.pythonhosted.org/packages/a2/8c/004fabd6406879fd1caa1ed4ea7ab850afad6e27e3c5b8e8a4d0d134de3e/psutil-5.1.3.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win-amd64-py3.6.exe","hashes":{"sha256":"94ed102897b8c7103ff51e2b2953caf56bb80c3343523fd3013db3ec91bd8c4b"},"provenance":null,"requires-python":null,"size":793304,"upload-time":"2017-02-07T21:35:00.329688Z","url":"https://files.pythonhosted.org/packages/55/18/6a48a9b9dad56c54236260c1e0e2313497b3af176b053a110ea134b9bb9f/psutil-5.1.3.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py2.7.exe","hashes":{"sha256":"9fcac25e01c0f9f1b6d86c860c6d4da627e458f277f24415f15b1b29cce35f60"},"provenance":null,"requires-python":null,"size":394272,"upload-time":"2017-02-07T21:35:07.791551Z","url":"https://files.pythonhosted.org/packages/33/97/442e6eefe2a12cd00d09721fb24ddf726dd62c1073579a860682919cc640/psutil-5.1.3.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.3.exe","hashes":{"sha256":"8349494ee9405a31f4f9d9d3564663c870fed5dd62efd2edfdf64c5841bb838f"},"provenance":null,"requires-python":null,"size":389117,"upload-time":"2017-02-07T21:35:16.679190Z","url":"https://files.pythonhosted.org/packages/ca/46/6d9a5c657298d1363cb37ab0f84eb1fd54639fa4b2729523a68cd6a1b043/psutil-5.1.3.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.4.exe","hashes":{"sha256":"c8dc71de8ba61604a5cae5dee5330229dc71538c82ef13458cee838b6c0f6435"},"provenance":null,"requires-python":null,"size":389124,"upload-time":"2017-02-07T21:35:24.590876Z","url":"https://files.pythonhosted.org/packages/5b/c4/7056b6c602ff5be0095fe403617cded940a75a80db49bb51846bc235a0bb/psutil-5.1.3.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.5.exe","hashes":{"sha256":"38c1e88f3a8a548d9caa7f56db1cc7d508eda48eb2c4aa484a908bc5d06f87bd"},"provenance":null,"requires-python":null,"size":660318,"upload-time":"2017-02-07T21:35:36.604103Z","url":"https://files.pythonhosted.org/packages/5f/b3/966c2979172a46f9fe42f34ce7321a59102054e26cdf9b26e3d604807953/psutil-5.1.3.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.1.3.win32-py3.6.exe","hashes":{"sha256":"0961ebc2ba4b1c811ef164612d0d963532ad0a9af1755e022a99648a9027b065"},"provenance":null,"requires-python":null,"size":660315,"upload-time":"2017-02-07T21:35:48.440270Z","url":"https://files.pythonhosted.org/packages/be/43/8f0099425146c01c2d77e3ac90b28a7f42d69ccb2af6e161f059db132d99/psutil-5.1.3.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"data-dist-info-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"filename":"psutil-5.2.0-cp27-none-win32.whl","hashes":{"sha256":"6eb2f6fb976152f320ee48a90ab732d694b2ae0c835260ce4f5af3907584448a"},"provenance":null,"requires-python":null,"size":187506,"upload-time":"2017-03-05T04:50:46.045903Z","url":"https://files.pythonhosted.org/packages/d2/56/56a15e285c7cf0104ed9fc569b2c75a24f97e7ab5c34567956b266d23ba3/psutil-5.2.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"data-dist-info-metadata":{"sha256":"1b02bec8364ab9ba69161e6031bf88699daaa9da96dcfa6527b452f562d8d646"},"filename":"psutil-5.2.0-cp27-none-win_amd64.whl","hashes":{"sha256":"35898b80a3f393a7ace8ad5da9a26800676b7fc40628a3a334902b9d0e444c8d"},"provenance":null,"requires-python":null,"size":189973,"upload-time":"2017-03-05T04:50:49.198757Z","url":"https://files.pythonhosted.org/packages/a5/a5/1039829542b856ca4d3d40bb4978fbb679b7f0bb684ece6340ce655aedc9/psutil-5.2.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp33-cp33m-win32.whl","hashes":{"sha256":"5626533fc459ce1ac4bd017f7a38b99947c039d79175a10a2a6b6246e3a82fc8"},"provenance":null,"requires-python":null,"size":187442,"upload-time":"2017-03-05T04:50:52.517268Z","url":"https://files.pythonhosted.org/packages/8c/1e/7e6ac521b3c393b2f312f1c3795d702f3267dca23d603827d673b8170920/psutil-5.2.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"d34cc4d48245873492e4befc5c58a146f0f6c98038ffa2430e191a6752717c61"},"provenance":null,"requires-python":null,"size":189849,"upload-time":"2017-03-05T04:50:55.188058Z","url":"https://files.pythonhosted.org/packages/b6/d0/6edd271e3ca150104c818ec0f4b2affc447fe79ec1504506cecb2900d391/psutil-5.2.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp34-cp34m-win32.whl","hashes":{"sha256":"5834168071a92037736142616b33691ec4786f8806e28355e74b2e1a037cad4c"},"provenance":null,"requires-python":null,"size":187450,"upload-time":"2017-03-05T04:50:58.524346Z","url":"https://files.pythonhosted.org/packages/89/88/8fb4ce470a2022c33ab3cd16b3f2152f544e264c9db0f2f7159a93e0d2a3/psutil-5.2.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"d29c24bc7c14ecb4e64b3b748814ebe0e3ac049802ea7f129edbfcb068e75c16"},"provenance":null,"requires-python":null,"size":189841,"upload-time":"2017-03-05T04:51:03.287652Z","url":"https://files.pythonhosted.org/packages/43/9b/35cae8c56d3ee2e9a02599fba6a2e1f3fcf3553fe55f70c0ea723f9a9522/psutil-5.2.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp35-cp35m-win32.whl","hashes":{"sha256":"8353692da46bc6024b4001a9ed8849beb863fbb1d022553dd4ed8348745540bb"},"provenance":null,"requires-python":null,"size":189373,"upload-time":"2017-03-05T04:51:07.095988Z","url":"https://files.pythonhosted.org/packages/65/35/fff62f84dc6c165e8a9f7646e2c106bd223a3967a0a3f471979b38b5a5c0/psutil-5.2.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"1e00f5684fb335dacfa750e5e01f83bb79d521eb5f0805b798de0a29a1fb25d4"},"provenance":null,"requires-python":null,"size":192813,"upload-time":"2017-03-05T04:51:10.595180Z","url":"https://files.pythonhosted.org/packages/94/d2/f78b5a0ded0993f4c5127bf17427e4bc10b183dc102a5e469d7f6725ecb9/psutil-5.2.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp36-cp36m-win32.whl","hashes":{"sha256":"55d546333f1423ad219a0798867a9bbf9a90e1912c3336ad275476473624c071"},"provenance":null,"requires-python":null,"size":189376,"upload-time":"2017-03-05T04:51:15.088897Z","url":"https://files.pythonhosted.org/packages/91/8e/bd4f794b9f092d82a5b63b17da95ebd864f544ff62fb70bb1bce0687b013/psutil-5.2.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"data-dist-info-metadata":{"sha256":"49ff4351990c237dc58c60a958925eef7156ce86008b0f5cfef7af0e197da80e"},"filename":"psutil-5.2.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"548f14e3e21225884904e3ab228a769a73f886a3394399c591ec5f31fedc48ac"},"provenance":null,"requires-python":null,"size":192808,"upload-time":"2017-03-05T04:51:18.018177Z","url":"https://files.pythonhosted.org/packages/75/65/8499f256dc203b94f8a439f52b092742247668365dcb0997aee7349d530d/psutil-5.2.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.tar.gz","hashes":{"sha256":"2fc91d068faa5613c093335f0e758673ef8c722ad4bfa4aded64c13ae69089eb"},"provenance":null,"requires-python":null,"size":345519,"upload-time":"2017-03-05T04:51:23.230758Z","url":"https://files.pythonhosted.org/packages/3c/2f/f3ab91349c666f009077157b12057e613a3152a46a6c3be883777546b6de/psutil-5.2.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py2.7.exe","hashes":{"sha256":"7cd5dd38e08d74112c68a8f4e9b9e12fac6c6f6270792604c79a9bbd574053fa"},"provenance":null,"requires-python":null,"size":426460,"upload-time":"2017-03-05T04:51:28.726871Z","url":"https://files.pythonhosted.org/packages/ca/6f/6289db524b6aae542fa36d539524e74f25d7f9296aabadb3b5a9f17746e8/psutil-5.2.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.3.exe","hashes":{"sha256":"e5f1688d9bfd9e122edd35adcd8a0050430397094d08d95c380bd9c7dae48da3"},"provenance":null,"requires-python":null,"size":424854,"upload-time":"2017-03-05T04:51:34.189840Z","url":"https://files.pythonhosted.org/packages/93/7c/e92a80f5803be3febbcb40807d5d2bfe66dfe20b256c07616599c14ba2aa/psutil-5.2.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.4.exe","hashes":{"sha256":"11e684bf163821bd73843ebf9a27b7cb6f8a8325b943954b49b1f622264b6e80"},"provenance":null,"requires-python":null,"size":424846,"upload-time":"2017-03-05T04:51:38.965015Z","url":"https://files.pythonhosted.org/packages/4a/82/5a78b9d40c17dc4d01a06345596ac1e3f7ba590f7329d83e80b817d47f9b/psutil-5.2.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.5.exe","hashes":{"sha256":"9eeae9bef0875432b9aea9504ed4f7c72f8ee3e8d7ded63e484a453ee82d4a98"},"provenance":null,"requires-python":null,"size":793372,"upload-time":"2017-03-05T04:51:43.517651Z","url":"https://files.pythonhosted.org/packages/dd/f1/4bf05d2b34198954b5fd6455ebe06dd08cae5357354f6f142ef4321e41ab/psutil-5.2.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win-amd64-py3.6.exe","hashes":{"sha256":"461445afc35f98d4b7781ea2f67d0ca4ae6cf36c065ee0f4be61ace59045a2a5"},"provenance":null,"requires-python":null,"size":795416,"upload-time":"2017-03-05T04:51:53.165366Z","url":"https://files.pythonhosted.org/packages/94/59/c54e7f853586561ae42c9bcf1aa0644e8c0298479e4654b4ca36fa9eafe6/psutil-5.2.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py2.7.exe","hashes":{"sha256":"8bbbd02eb474045d201f6617d16dc8ee1d9903d5cec94f7f39cce610fc1e924b"},"provenance":null,"requires-python":null,"size":396349,"upload-time":"2017-03-05T04:51:59.453206Z","url":"https://files.pythonhosted.org/packages/21/79/40ea4e11ef6ca2b044d0aeb28d829a716a565b34c7786f779e99c005b80a/psutil-5.2.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.3.exe","hashes":{"sha256":"63d4320b0f3498da3551028a6ab9ee1c5aebabe0d23a7c38600c35333953ef6c"},"provenance":null,"requires-python":null,"size":391219,"upload-time":"2017-03-05T04:52:03.289639Z","url":"https://files.pythonhosted.org/packages/2e/9d/def6a3fb8150adfd71889f3e3d48160a1ba6210911baf12ce3ebd294307c/psutil-5.2.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.4.exe","hashes":{"sha256":"3c06b0162192db85e04846674a55915fca80f728cf626228a6b31684fc6930da"},"provenance":null,"requires-python":null,"size":391229,"upload-time":"2017-03-05T04:52:10.103932Z","url":"https://files.pythonhosted.org/packages/2c/ae/8616ac1eb00a7770d837b15ebb9ae759c43623c182f32fd43d2e6fed8649/psutil-5.2.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.5.exe","hashes":{"sha256":"0ba082468d6b45fb15cc1c4488aaf3ffcf0616a674c46393bf04eccc8d7c2196"},"provenance":null,"requires-python":null,"size":660405,"upload-time":"2017-03-05T04:52:18.130601Z","url":"https://files.pythonhosted.org/packages/f7/b6/c8cb94fd6696414a66021aa2229747d71612551eade262e9ab52eeb54ee2/psutil-5.2.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.0.win32-py3.6.exe","hashes":{"sha256":"6ed1cb1c9339493e1f3c379de0155c543a4c8de18224bda894190843f9509cad"},"provenance":null,"requires-python":null,"size":662455,"upload-time":"2017-03-05T04:52:27.540851Z","url":"https://files.pythonhosted.org/packages/5d/9d/8b552e9d4c2a5c3baa00d1baa1468f2a8128acd3eba79ef39e59c182676a/psutil-5.2.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"data-dist-info-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"filename":"psutil-5.2.1-cp27-none-win32.whl","hashes":{"sha256":"4e236c4ec6b0b20171c2477ded7a5b4402e4a877530640f814df839af0a40e30"},"provenance":null,"requires-python":null,"size":187855,"upload-time":"2017-03-24T15:42:20.835636Z","url":"https://files.pythonhosted.org/packages/3d/14/1242a70873873e92732dc35162317df448503a7a32e29c8bdbe30d4fa175/psutil-5.2.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"data-dist-info-metadata":{"sha256":"84b8c9735984f276c69b5871ce5635af6381a960dd516077459ef1ded0e0580a"},"filename":"psutil-5.2.1-cp27-none-win_amd64.whl","hashes":{"sha256":"e88fe0d0ca5a9623f0d8d6be05a82e33984f27b067f08806bf8a548ba4361b40"},"provenance":null,"requires-python":null,"size":190301,"upload-time":"2017-03-24T15:42:26.623783Z","url":"https://files.pythonhosted.org/packages/4c/03/fffda9f6e1ca56ce989362969b709bf7a7ade16abf7d82661bbec96580f5/psutil-5.2.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp33-cp33m-win32.whl","hashes":{"sha256":"54275bdbfbd20909d37ed7a2570cf9dd373ac702a89bac4814249cbc10503c03"},"provenance":null,"requires-python":null,"size":187792,"upload-time":"2017-03-24T15:42:30.952153Z","url":"https://files.pythonhosted.org/packages/d7/e0/4fde7667fad4271c06ed5e533a156bd600cdad1b69d8e6f278fe425452d2/psutil-5.2.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"316c3e334b046dc12b4f0a3dafa1d1c394e38106ac519003694fc8aeb672eafd"},"provenance":null,"requires-python":null,"size":190190,"upload-time":"2017-03-24T15:42:35.956721Z","url":"https://files.pythonhosted.org/packages/a8/c5/63453c20ac576ccb58ee56f88388434380f5e2a729aa08885d2655eb83b7/psutil-5.2.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp34-cp34m-win32.whl","hashes":{"sha256":"2249c687088145dcce87ecb90221258f9c0e7b7cea830886656cf07351e50e1b"},"provenance":null,"requires-python":null,"size":187785,"upload-time":"2017-03-24T15:42:40.746327Z","url":"https://files.pythonhosted.org/packages/59/8b/8ebb86ae5c0ba81e95bae8263de81038d3d7ee8a050f31b2b58f1a330198/psutil-5.2.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"f74532c2037fac87b76737798c74102e17f8594ea9de07aa3cb19027a630bdb0"},"provenance":null,"requires-python":null,"size":190213,"upload-time":"2017-03-24T15:42:45.196850Z","url":"https://files.pythonhosted.org/packages/e7/81/c4dd47453864984d1bd5ad0c387efc11aa6791b5abb5b369ebe2e81f7ada/psutil-5.2.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp35-cp35m-win32.whl","hashes":{"sha256":"c7c8ed864a9ef04d4736a998273e3ba0f95f22300f1e082c13a7c824b514f411"},"provenance":null,"requires-python":null,"size":189737,"upload-time":"2017-03-24T15:42:50.097781Z","url":"https://files.pythonhosted.org/packages/76/3b/2e6b3306dd2927fef9c81fdc29bc450beeb6f4bfe4cddec80260ab042900/psutil-5.2.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7a21b9d908a3bf381cc160c157a06bfcea3c6402362b26a2489566914cea9cc5"},"provenance":null,"requires-python":null,"size":193175,"upload-time":"2017-03-24T15:42:55.344665Z","url":"https://files.pythonhosted.org/packages/de/ee/cf9ecf7cea0a984a360bc889bb0bf11335755d5b7d2be9d8399fe5dc01fb/psutil-5.2.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp36-cp36m-win32.whl","hashes":{"sha256":"d1efbfc743555e7fd366956d8fe39690a3ae87e8e9e9ac06cc80bd7e2ca3059b"},"provenance":null,"requires-python":null,"size":189738,"upload-time":"2017-03-24T15:43:00.448274Z","url":"https://files.pythonhosted.org/packages/15/18/e6b1b4288d885218c845f9a340e236f03352358fc83675b9b8ef96e26227/psutil-5.2.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"data-dist-info-metadata":{"sha256":"187f675b1b9bc62e2ffab1ba395e87ae25e1679d8867bd305462e360a04fd386"},"filename":"psutil-5.2.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"cf40e944f47000375320ce0e712585321ec624a0ef67e8259f522e51bcb35a35"},"provenance":null,"requires-python":null,"size":193175,"upload-time":"2017-03-24T15:43:06.043078Z","url":"https://files.pythonhosted.org/packages/e8/7c/240fd3dfcec8d839a9a48dd2f88ba5f6e687263adc8b2452ed973b66b862/psutil-5.2.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.tar.gz","hashes":{"sha256":"fe0ea53b302f68fca1c2a3bac289e11344456786141b73391ed4022b412d5455"},"provenance":null,"requires-python":null,"size":347241,"upload-time":"2017-03-24T15:43:12.551784Z","url":"https://files.pythonhosted.org/packages/b8/47/c85fbcd23f40892db6ecc88782beb6ee66d22008c2f9821d777cb1984240/psutil-5.2.1.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py2.7.exe","hashes":{"sha256":"60e9bd558d640eaf9c7a4fbb0627b423b1e58fce95b41b8a24fda9145b753471"},"provenance":null,"requires-python":null,"size":426778,"upload-time":"2017-03-24T15:43:20.982480Z","url":"https://files.pythonhosted.org/packages/88/e8/40e20ea582157c81e55e1765139a5f6e969d8c01e47c016d90946b495531/psutil-5.2.1.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.3.exe","hashes":{"sha256":"318cf7bf546a23564fe4f049eae0bf205895a0524120bd549de3e46599a7f265"},"provenance":null,"requires-python":null,"size":425186,"upload-time":"2017-03-24T15:43:29.554448Z","url":"https://files.pythonhosted.org/packages/dd/55/2a74e973eb217fa5006c910a24abbd720efb7720beae9659be14fe96a413/psutil-5.2.1.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.4.exe","hashes":{"sha256":"3bcfbe8b8141c8145f1d54c3f9c2c86597508bb7cc2552e333de770a3c9b9368"},"provenance":null,"requires-python":null,"size":425211,"upload-time":"2017-03-24T15:43:39.017569Z","url":"https://files.pythonhosted.org/packages/9d/12/92575d652d33d28e6f8b0f858f3db326db5ffc4c8d55b09ac411b021d86d/psutil-5.2.1.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.5.exe","hashes":{"sha256":"979a5804366b47acd0ebf28923ee645e9fc29f4c54cbc44c41d112a1cd36e9ba"},"provenance":null,"requires-python":null,"size":793725,"upload-time":"2017-03-24T15:43:54.421574Z","url":"https://files.pythonhosted.org/packages/7f/58/de0b10442e2f277de4de0ecfae277576a6bfac1a3137fe547a4085dafa32/psutil-5.2.1.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win-amd64-py3.6.exe","hashes":{"sha256":"bf7d2cff21e3262d2b3e33a4b9dc27bbae81e851d694667d68dc7405c67ff31f"},"provenance":null,"requires-python":null,"size":795772,"upload-time":"2017-03-24T15:44:09.051326Z","url":"https://files.pythonhosted.org/packages/33/c0/7094de6644330b8dcdfefb0bae0a00379238588a6cf6cc9cd71c69e0cdce/psutil-5.2.1.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py2.7.exe","hashes":{"sha256":"ad8b603d7cc6d070cf07d39276869683474dace4da51d8050f29893ac2e22baf"},"provenance":null,"requires-python":null,"size":396688,"upload-time":"2017-03-24T15:44:17.148742Z","url":"https://files.pythonhosted.org/packages/a9/7a/5d19102362c28b6a478f9a7f3262f3ca301f8c5fed12e8d0af9e9e82e6a2/psutil-5.2.1.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.3.exe","hashes":{"sha256":"71fbaa3649aa8fa92edb1ad2b45de1e9caa7ffc63f448be951d43d6b5c6263b1"},"provenance":null,"requires-python":null,"size":391560,"upload-time":"2017-03-24T15:44:25.069190Z","url":"https://files.pythonhosted.org/packages/0b/01/f2963d84b439b0802c2354d0f777b5ed4bd0c2c11161ba81e7057a0d0523/psutil-5.2.1.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.4.exe","hashes":{"sha256":"cab6e8cfab49511f34e7ae40885792d7e655bb107f6f3c89440d5061cb19ad2f"},"provenance":null,"requires-python":null,"size":391554,"upload-time":"2017-03-24T15:44:33.671369Z","url":"https://files.pythonhosted.org/packages/d5/46/b36ff70ba0ba3b92bb5088be595fdb5641ffd982bac8e206e7c4936b2dc5/psutil-5.2.1.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.5.exe","hashes":{"sha256":"0e9e3d74f6ee1a6cac503c0bba08563dc3954e723b8392a4c74ce36f46e119ea"},"provenance":null,"requires-python":null,"size":660759,"upload-time":"2017-03-24T15:44:45.335659Z","url":"https://files.pythonhosted.org/packages/62/81/e7431ad75f9d9ae1524ee886c1aff25ec3714058de6568d305de2e0c8373/psutil-5.2.1.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.1.win32-py3.6.exe","hashes":{"sha256":"03e419618c3c715489ca5073cbdac6a0b12da41def69d3e4ee83f18fbb5798e5"},"provenance":null,"requires-python":null,"size":662807,"upload-time":"2017-03-24T15:44:56.446939Z","url":"https://files.pythonhosted.org/packages/77/c8/e256a28a63d06fe028f8837b860b7f6440c6ef9a475fb8c4490e1e08498b/psutil-5.2.1.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"data-dist-info-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"filename":"psutil-5.2.2-cp27-none-win32.whl","hashes":{"sha256":"db473f0d45a56d422502043f3755385fcfd83f5bb0947bc807fcad689230f37f"},"provenance":null,"requires-python":null,"size":187988,"upload-time":"2017-04-10T17:19:35.132698Z","url":"https://files.pythonhosted.org/packages/9c/31/c651e4c475a4d0df9609024a86fcb358a21b7a01872f7c69c7cf501a2896/psutil-5.2.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"data-dist-info-metadata":{"sha256":"0414f56fbdc05bdf6b0f2659c3f90672e666ae73ba46b3281e07291af1d58219"},"filename":"psutil-5.2.2-cp27-none-win_amd64.whl","hashes":{"sha256":"dcd9d3131f83480648da40d2c39403657c63a81e56e4e8d8e905bf65c133d59c"},"provenance":null,"requires-python":null,"size":190432,"upload-time":"2017-04-10T17:19:39.867178Z","url":"https://files.pythonhosted.org/packages/6e/5c/15f41041a321ffd4058ae67aade067924489acba6d277e10571b59b3127c/psutil-5.2.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp33-cp33m-win32.whl","hashes":{"sha256":"3f79a044db0aae96592ef42be459e37095d0c2cebcae4fd7baf486d37a85a8cd"},"provenance":null,"requires-python":null,"size":187924,"upload-time":"2017-04-10T17:19:44.464637Z","url":"https://files.pythonhosted.org/packages/04/a5/a027a8584208fa2cb6a88e6337b06b11388edf7d39feb0a897c9c2024639/psutil-5.2.2-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"838c66c123cb024bf8c8d2fec902b38c51f75b27988f4487d81383d1d3d8a8ce"},"provenance":null,"requires-python":null,"size":190325,"upload-time":"2017-04-10T17:19:49.563017Z","url":"https://files.pythonhosted.org/packages/bc/95/385e0f7e0299295401d41dd4cb6e568bf50c884af336b92a69d16981f71c/psutil-5.2.2-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp34-cp34m-win32.whl","hashes":{"sha256":"a155875d2fedb614c2cd687fe47953d03a47f76eb39bd5756931b288b685655f"},"provenance":null,"requires-python":null,"size":187918,"upload-time":"2017-04-10T17:19:54.252736Z","url":"https://files.pythonhosted.org/packages/12/ad/aca0f4f146b25fb2b7e9e0735287ba3ebcc02eb2bf84d49916aef730d860/psutil-5.2.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"a989876ac0cc7942ef9481b96d3bfc02777dc798d4a7a1b4e8f0f284228f3434"},"provenance":null,"requires-python":null,"size":190345,"upload-time":"2017-04-10T17:19:59.043821Z","url":"https://files.pythonhosted.org/packages/f4/45/6cbf2b7a55375f6aafc68f33581aa143f86ae1be9112546f04d8e9ee34da/psutil-5.2.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp35-cp35m-win32.whl","hashes":{"sha256":"32616c5736f1de446e77865305e7f56905c718991f820c8286436adea8192f32"},"provenance":null,"requires-python":null,"size":189869,"upload-time":"2017-04-10T17:20:03.832890Z","url":"https://files.pythonhosted.org/packages/7b/1d/8cef4ee6c1a49b1204dcdca1231ac773e27f2ed0abbbf42deb14aaf2b5cc/psutil-5.2.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"50c8ddc3a6d1cda1de6d7aaf1af10896832c6d686fc7d0fe3d01c1eb51e6f521"},"provenance":null,"requires-python":null,"size":193304,"upload-time":"2017-04-10T17:20:09.444679Z","url":"https://files.pythonhosted.org/packages/82/f4/9d4cb35c5e1c84f93718d1851adf0b4147b253111cb89f1996a08d14dba5/psutil-5.2.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp36-cp36m-win32.whl","hashes":{"sha256":"e8b65a80e978af9bf10be423442155032c589b7042b4a26edc410dc36819d65e"},"provenance":null,"requires-python":null,"size":189868,"upload-time":"2017-04-10T17:20:16.876191Z","url":"https://files.pythonhosted.org/packages/72/9f/5ff6e45db392bc9dad642dffcca44eeee552289595c087a4f1d245fdb4f9/psutil-5.2.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"data-dist-info-metadata":{"sha256":"4c73be3d0927068fd96000b5591a3206eb03f1decaf76929c5e5cd06d004e214"},"filename":"psutil-5.2.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"7a5c0973bd4c1de98d9b225bd4303a0718d31e31d6e2342e825c3e656f7056df"},"provenance":null,"requires-python":null,"size":193305,"upload-time":"2017-04-10T17:20:21.983057Z","url":"https://files.pythonhosted.org/packages/eb/c6/29c695be774c52cca9bb68b94ae4dc866a42ddf29dcd19b7ab4c0d97bdda/psutil-5.2.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.tar.gz","hashes":{"sha256":"44746540c0fab5b95401520d29eb9ffe84b3b4a235bd1d1971cbe36e1f38dd13"},"provenance":null,"requires-python":null,"size":348413,"upload-time":"2017-04-10T17:20:29.132011Z","url":"https://files.pythonhosted.org/packages/57/93/47a2e3befaf194ccc3d05ffbcba2cdcdd22a231100ef7e4cf63f085c900b/psutil-5.2.2.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py2.7.exe","hashes":{"sha256":"70732850abd11f4d9fa46f0e110af21030e0a6088204f332d335921b36e66305"},"provenance":null,"requires-python":null,"size":427159,"upload-time":"2017-04-10T17:20:36.896101Z","url":"https://files.pythonhosted.org/packages/56/bb/d03fa2260839abbcdd4d323e83c2e91ffaedcb1975b88d5d0bc71c95c1fb/psutil-5.2.2.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.3.exe","hashes":{"sha256":"5d2f076788d71d2e1c7276f1e5a1bc255f29c2e80eb8879a9ffc633c5bf69481"},"provenance":null,"requires-python":null,"size":425568,"upload-time":"2017-04-10T17:20:45.676662Z","url":"https://files.pythonhosted.org/packages/79/fd/3d2626e6a9fd4d99859fd8eac7d52ff9850d5e4ea62611a1e3ffe6f3d257/psutil-5.2.2.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.4.exe","hashes":{"sha256":"fecda42b274dc618278bd9139e8493c9459d2174376f82b65ba929557f10e880"},"provenance":null,"requires-python":null,"size":425592,"upload-time":"2017-04-10T17:20:54.334109Z","url":"https://files.pythonhosted.org/packages/24/56/637ef0dfac83cd3e51096436faf7ea030f780aff3da98a79b7e7ac98a8bb/psutil-5.2.2.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.5.exe","hashes":{"sha256":"92e3500dfaf7a5502ebaf4a7472e2afb9ff0cb36b4e5dc1977b3c774f58332db"},"provenance":null,"requires-python":null,"size":794103,"upload-time":"2017-04-10T17:21:08.107023Z","url":"https://files.pythonhosted.org/packages/09/4d/9cf34797696c0a75fd76606c362ddfbbc0f87d2c19c95ae26e61120241ad/psutil-5.2.2.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win-amd64-py3.6.exe","hashes":{"sha256":"ed09521d49ee177f1205ed9791ad62263feacd2fe1cc20d1d33cf37923f240ea"},"provenance":null,"requires-python":null,"size":796151,"upload-time":"2017-04-10T17:21:22.493104Z","url":"https://files.pythonhosted.org/packages/04/74/5ea4412f31c9652335c03537ff4608ff6a12895fb3a34a187578d693b865/psutil-5.2.2.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py2.7.exe","hashes":{"sha256":"147093b75b8874e55e6b26c540544d40e98845bc4ee74dc6054c881fd2a3eed9"},"provenance":null,"requires-python":null,"size":397069,"upload-time":"2017-04-10T17:21:30.834225Z","url":"https://files.pythonhosted.org/packages/b9/aa/b779310ee8a120b5bb90880d22e7b3869f98f7a30381a71188c6fb7ff4a6/psutil-5.2.2.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.3.exe","hashes":{"sha256":"3d3c5c117e55c486a53ef796cc715035bf4f56419cc32dbd124fe26e9289ad1e"},"provenance":null,"requires-python":null,"size":391941,"upload-time":"2017-04-10T17:21:38.680258Z","url":"https://files.pythonhosted.org/packages/e0/3f/fd40d4edbfac1d7996b6ecb3bfa5f923662e21686727eb070490ab6dcca8/psutil-5.2.2.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.4.exe","hashes":{"sha256":"0c74c6a494b650966b88da256cab4e507f483c53e85b9b10d3ff9c38f059330b"},"provenance":null,"requires-python":null,"size":391936,"upload-time":"2017-04-10T17:21:46.576288Z","url":"https://files.pythonhosted.org/packages/c7/59/f7aa53e3f72d6dcfce7c60d80e74853a1444a8a4d7fef788441435c645bf/psutil-5.2.2.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.5.exe","hashes":{"sha256":"b5583d1c2c858056d39bd148ed25839c4f1b76fec8fb2cb9b564c82997a21266"},"provenance":null,"requires-python":null,"size":661141,"upload-time":"2017-04-10T17:21:57.551743Z","url":"https://files.pythonhosted.org/packages/f2/62/0fc0c5459bcc04171ea3bf5603622db6815ddd92a472db06bcd69612177d/psutil-5.2.2.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.2.2.win32-py3.6.exe","hashes":{"sha256":"1da0aa70d66612588d77daed7784e623aac1fd038681c3acd0e1c76b2b2f0819"},"provenance":null,"requires-python":null,"size":663188,"upload-time":"2017-04-10T17:22:09.360293Z","url":"https://files.pythonhosted.org/packages/a0/7f/494b600e45a8a25a76658a45747f232d38538d1c177f5b80123902d2b8da/psutil-5.2.2.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"data-dist-info-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"filename":"psutil-5.3.0-cp27-none-win32.whl","hashes":{"sha256":"6f8f858cdb79397509ee067ae9d25bee8f4b4902453ac8d155fa1629f03aa39d"},"provenance":null,"requires-python":null,"size":210071,"upload-time":"2017-09-01T10:50:37.295614Z","url":"https://files.pythonhosted.org/packages/db/36/71afb537f3718a00a9e63b75e8534bf14fee38b67fb7cb72eb60a3378162/psutil-5.3.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"data-dist-info-metadata":{"sha256":"d331b301ac1684996cf5629df9922a8709a7bf9243a73151f9aa72cf620ac815"},"filename":"psutil-5.3.0-cp27-none-win_amd64.whl","hashes":{"sha256":"b31d6d19e445b56559abaa21703a6bc4b162aaf9ab99867b6f2bbbdb2c7fce66"},"provenance":null,"requires-python":null,"size":212901,"upload-time":"2017-09-01T10:50:41.892260Z","url":"https://files.pythonhosted.org/packages/c8/2b/9bc89bb0d8a2ac49ab29954017e65a9c28b83b13453418c8166938281458/psutil-5.3.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"data-dist-info-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"filename":"psutil-5.3.0-cp33-cp33m-win32.whl","hashes":{"sha256":"7f1ba5011095e39b3f543e9c87008409dd8a57a3e48ea1022c348244b5af77bf"},"provenance":null,"requires-python":null,"size":209934,"upload-time":"2017-09-01T10:50:46.901965Z","url":"https://files.pythonhosted.org/packages/3c/5b/b020c5f5b6fbe69bfe77072a6d35a6c6d68f7ec7fe8b148223d9365bf8b4/psutil-5.3.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"data-dist-info-metadata":{"sha256":"47a95c843a21d16ad147a795cf6dc0395740dd91d643d06e100a63f2bb9f4d08"},"filename":"psutil-5.3.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"853f68a85cec0137acf0504d8ca6d40d899e48ecbe931130f593a072a35b812e"},"provenance":null,"requires-python":null,"size":212722,"upload-time":"2017-09-01T10:50:51.125180Z","url":"https://files.pythonhosted.org/packages/ad/f8/4d7f713241f1786097faf48afb51e6cb9f7966d2fc36656098e182056704/psutil-5.3.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp34-cp34m-win32.whl","hashes":{"sha256":"01d9cb9473eee0e7e88319f9a5205a69e6e160b3ab2bd430a05b93bfae1528c2"},"provenance":null,"requires-python":null,"size":209879,"upload-time":"2017-09-01T10:50:55.651560Z","url":"https://files.pythonhosted.org/packages/d6/77/01a752e6d05061decf570acc800cd490766ea4534eccbe8c523b84fe5cc1/psutil-5.3.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"91d37262095c1a0f97a78f5034e10e0108e3fa326c85baa17f8cdd63fa5f81b9"},"provenance":null,"requires-python":null,"size":212614,"upload-time":"2017-09-01T10:50:59.871475Z","url":"https://files.pythonhosted.org/packages/0f/cf/fd1d752d428c5845fed4904e7bcdbb89ea3327aa063247fddcdca319c615/psutil-5.3.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp35-cp35m-win32.whl","hashes":{"sha256":"bd1776dc14b197388d728db72c103c0ebec834690ef1ce138035abf0123e2268"},"provenance":null,"requires-python":null,"size":212062,"upload-time":"2017-09-01T10:51:04.687879Z","url":"https://files.pythonhosted.org/packages/68/05/6d097706fd9cb43eda36a02a5feaee085aeac21f5bc6ea0b557109bc2eca/psutil-5.3.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"7fadb1b1357ef58821b3f1fc2afb6e1601609b0daa3b55c2fabf765e0ea98901"},"provenance":null,"requires-python":null,"size":215734,"upload-time":"2017-09-01T10:51:09.110127Z","url":"https://files.pythonhosted.org/packages/6e/5a/7c688b472ff5b6cb5413acfa5a178b5e8140ffbdf0011b6d0469e97af3b1/psutil-5.3.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp36-cp36m-win32.whl","hashes":{"sha256":"d5f4634a19e7d4692f37d8d67f8418f85f2bc1e2129914ec0e4208bf7838bf63"},"provenance":null,"requires-python":null,"size":212060,"upload-time":"2017-09-01T10:51:14.595884Z","url":"https://files.pythonhosted.org/packages/28/30/4ab277d7e37cd5ee1c47a89d21465c3eec3435b973ca86cd986efdd0aeac/psutil-5.3.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"data-dist-info-metadata":{"sha256":"70af37a6bd4674f8be60cec24e58ebdb4493432961ecc67d471a1739f1bf5d12"},"filename":"psutil-5.3.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"31505ee459913ef63fa4c1c0d9a11a4da60b5c5ec6a92d6d7f5d12b9653fc61b"},"provenance":null,"requires-python":null,"size":215731,"upload-time":"2017-09-01T10:51:18.736362Z","url":"https://files.pythonhosted.org/packages/c3/e6/98fd6259d8ed834d9a81567d4f41dd3645e12a9aea9d38563efaf245610a/psutil-5.3.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.tar.gz","hashes":{"sha256":"a3940e06e92c84ab6e82b95dad056241beea93c3c9b1d07ddf96485079855185"},"provenance":null,"requires-python":null,"size":397265,"upload-time":"2017-09-01T12:31:14.428985Z","url":"https://files.pythonhosted.org/packages/1c/da/555e3ad3cad30f30bcf0d539cdeae5c8e7ef9e2a6078af645c70aa81e418/psutil-5.3.0.tar.gz","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py2.7.exe","hashes":{"sha256":"ba94f021942d6cc27e18dcdccd2c1a0976f0596765ef412316ecb887d4fd3db2"},"provenance":null,"requires-python":null,"size":450426,"upload-time":"2017-09-01T10:51:26.068723Z","url":"https://files.pythonhosted.org/packages/e3/d6/238a22e898d0a3703d5fd486487108bf57d8fab1137bf085d3602d04894a/psutil-5.3.0.win-amd64-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.3.exe","hashes":{"sha256":"0f2fccf98bc25e8d6d61e24b2cc6350b8dfe8fa7f5251c817e977d8c61146e5d"},"provenance":null,"requires-python":null,"size":448781,"upload-time":"2017-09-01T10:51:33.193333Z","url":"https://files.pythonhosted.org/packages/91/d6/4ccff87a9f93f4837c97c3eb105c4cd1ccd544091658ba1938feca366b59/psutil-5.3.0.win-amd64-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.4.exe","hashes":{"sha256":"d06f02c53260d16fb445e426410263b2d271cea19136b1bb715cf10b76960359"},"provenance":null,"requires-python":null,"size":448549,"upload-time":"2017-09-01T10:51:40.339200Z","url":"https://files.pythonhosted.org/packages/74/29/91f18e7798a150c922c7da5c2153edecd7af0292332ef4f46e8ebd7184d3/psutil-5.3.0.win-amd64-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.5.exe","hashes":{"sha256":"724439fb20d083c943a2c62db1aa240fa15fe23644c4d4a1e9f573ffaf0bbddd"},"provenance":null,"requires-python":null,"size":817222,"upload-time":"2017-09-01T10:51:52.173626Z","url":"https://files.pythonhosted.org/packages/41/fe/5081186ce35c0def7db2f8531ccac908b83edf735c2b8b78241633853b34/psutil-5.3.0.win-amd64-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win-amd64-py3.6.exe","hashes":{"sha256":"a58708f3f6f74897450babb012cd8067f8911e7c8a1f2991643ec9937a8f6c15"},"provenance":null,"requires-python":null,"size":817218,"upload-time":"2017-09-01T10:52:03.695382Z","url":"https://files.pythonhosted.org/packages/aa/49/2076044f5f8554232eb5f8fb69b4a59c8f96da6d107d6f6a35aea2fb0344/psutil-5.3.0.win-amd64-py3.6.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py2.7.exe","hashes":{"sha256":"108dae5ecb68f6e6212bf0553be055a2a0eec210227d8e14c3a26368b118624a"},"provenance":null,"requires-python":null,"size":419952,"upload-time":"2017-09-01T10:52:12.411324Z","url":"https://files.pythonhosted.org/packages/d1/18/7e1a418aff3f65c3072eb765b0e51445df6309be3da25c5a4cb9f1d1d18b/psutil-5.3.0.win32-py2.7.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.3.exe","hashes":{"sha256":"9832124af1e9ec0f298f17ab11c3bb91164f8068ec9429c39a7f7a0eae637a94"},"provenance":null,"requires-python":null,"size":414764,"upload-time":"2017-09-01T10:52:32.286415Z","url":"https://files.pythonhosted.org/packages/de/46/0ec33721564e235fab9112fecb836eb084d0475ab97d5a6d5c462656e715/psutil-5.3.0.win32-py3.3.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.4.exe","hashes":{"sha256":"7b8d10e7d72862d1e97caba546b60ce263b3fcecd6176e4c94efebef87ee68d3"},"provenance":null,"requires-python":null,"size":414582,"upload-time":"2017-09-01T10:52:41.243220Z","url":"https://files.pythonhosted.org/packages/86/82/254439b29eea5670633a947ec3f67c5ec33b88322a1a443f121d21dc2714/psutil-5.3.0.win32-py3.4.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.5.exe","hashes":{"sha256":"ed1f7cbbbf778a6ed98e25d48fdbdc098e66b360427661712610d72c1b4cf5f5"},"provenance":null,"requires-python":null,"size":684021,"upload-time":"2017-09-01T10:52:51.603711Z","url":"https://files.pythonhosted.org/packages/20/9c/2d84e2926e1a89c4d1ea8fc315e05145e6b10af79459727ebb688b22dab8/psutil-5.3.0.win32-py3.5.exe","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.0.win32-py3.6.exe","hashes":{"sha256":"3d8d62f3da0b38dbfaf4756a32e18c866530b9066c298da3fc293cfefae22f0a"},"provenance":null,"requires-python":null,"size":684018,"upload-time":"2017-09-01T10:53:02.878374Z","url":"https://files.pythonhosted.org/packages/61/c7/bbcc29ba03d59f1add008245edf0d56d45434b137dde0c0d6b8441ae3be6/psutil-5.3.0.win32-py3.6.exe","yanked":false},{"core-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"data-dist-info-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"filename":"psutil-5.3.1-cp27-none-win32.whl","hashes":{"sha256":"7a669b1897b8cdce1cea79defdf3a10fd6e4f0a8e42ac2a971dfe74bc1ce5679"},"provenance":null,"requires-python":null,"size":210168,"upload-time":"2017-09-10T05:26:42.273181Z","url":"https://files.pythonhosted.org/packages/34/90/145ff234428b4bd519c20d460d6d51db7820e8120879ca9cdc88602c57f4/psutil-5.3.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"data-dist-info-metadata":{"sha256":"efaa364a2342964849b527ba97bfad9c165b3524ee431b8e5ff9d3b6bd3b4047"},"filename":"psutil-5.3.1-cp27-none-win_amd64.whl","hashes":{"sha256":"57be53c045f2085e28d5371eedfce804f5e49e7b35fa79bcf63e271046058002"},"provenance":null,"requires-python":null,"size":212998,"upload-time":"2017-09-10T05:27:13.646528Z","url":"https://files.pythonhosted.org/packages/c8/c9/d8cbfc3844e1a3e8b648fcca317ad8589283a7cbbc232c2c5d29cae88352/psutil-5.3.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"data-dist-info-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"filename":"psutil-5.3.1-cp33-cp33m-win32.whl","hashes":{"sha256":"27d4c5ff3ab97389a9372d246e1aa27e5f02e4709fede48a0599f89d2873ca88"},"provenance":null,"requires-python":null,"size":210025,"upload-time":"2017-09-10T05:27:19.363106Z","url":"https://files.pythonhosted.org/packages/c4/82/7e412884fcf9ae538b1d96e31688b804377803e34f4e3e86bba869eaa9f7/psutil-5.3.1-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"data-dist-info-metadata":{"sha256":"411e80cfca140c76586e1f0d89c1c6d7b1ff79f31751e6780aee2632e60c3996"},"filename":"psutil-5.3.1-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"72ba7e4c82879b3781ccced1eeb901f07725a36fab66270e7555e484a460760d"},"provenance":null,"requires-python":null,"size":212814,"upload-time":"2017-09-10T05:27:24.067035Z","url":"https://files.pythonhosted.org/packages/8a/1b/e185f211c9a959739c6789872458b78f6424466819afc5c420af09b222af/psutil-5.3.1-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp34-cp34m-win32.whl","hashes":{"sha256":"fc11c3a52990ec44064cbe026338dedcfff0e0027ca7516416eaa7d4f206c5af"},"provenance":null,"requires-python":null,"size":209976,"upload-time":"2017-09-10T05:27:29.519738Z","url":"https://files.pythonhosted.org/packages/ae/a9/ba609de04d2350878c6c3d641997dd37fa362775bf79aca3e6d542aae89e/psutil-5.3.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"7b1f9856c2fc9503a8a687db85e4f419ad1a10bfcab92ba786a7d43a6aa8cea0"},"provenance":null,"requires-python":null,"size":212710,"upload-time":"2017-09-10T05:27:34.832459Z","url":"https://files.pythonhosted.org/packages/9e/4e/e35f4e9b3f5dfb8eb88be75ccbc6e6a6428443afa4d641ff5e9e29a8991f/psutil-5.3.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp35-cp35m-win32.whl","hashes":{"sha256":"54781e463d9b9aa8c143033ee0d6a3149f9f143e6cc63099a95d4078f433dd56"},"provenance":null,"requires-python":null,"size":212159,"upload-time":"2017-09-10T05:27:39.270103Z","url":"https://files.pythonhosted.org/packages/79/4b/4531d21a7e428f3f25dc1b05be7e2024d9c2d45845ba005193dd9420e6b7/psutil-5.3.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e9ef8d265298268cad784dfece103ab06bd726512d57fc6ed9f94b55452e4571"},"provenance":null,"requires-python":null,"size":215831,"upload-time":"2017-09-10T05:27:43.869238Z","url":"https://files.pythonhosted.org/packages/aa/a7/1bc0baaea0798c1b29bfb6cec05f18f6a4cbaaf96646818429d998feb2f5/psutil-5.3.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp36-cp36m-win32.whl","hashes":{"sha256":"f5d55618cd5b9270355fb52c0430ff30c4c84c5caf5b1254eec27f80d48e7a12"},"provenance":null,"requires-python":null,"size":212160,"upload-time":"2017-09-10T05:27:51.405015Z","url":"https://files.pythonhosted.org/packages/ba/03/1946dc720fec2083148b1d7b579e789bde85cebad67b22e05d5189871114/psutil-5.3.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"data-dist-info-metadata":{"sha256":"c340877ca68a4b72ce8f93ad0b6c48c15a2eeb72742c08998e478251efec5a92"},"filename":"psutil-5.3.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"773ba33fe365cb8b0998eedcbe494dc92ce7428998f07dca652a1360a9e2bce8"},"provenance":null,"requires-python":null,"size":215831,"upload-time":"2017-09-10T05:27:56.438641Z","url":"https://files.pythonhosted.org/packages/9b/de/5bd7038f8bb68516eedafc8bba9daf6740011db8afc1bb25cdcc8d654771/psutil-5.3.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.3.1.tar.gz","hashes":{"sha256":"12dd9c8abbad15f055e9579130035b38617020ce176f4a498b7870e6321ffa67"},"provenance":null,"requires-python":null,"size":397075,"upload-time":"2017-09-10T05:28:34.436466Z","url":"https://files.pythonhosted.org/packages/d3/0a/74dcbb162554909b208e5dbe9f4e7278d78cc27470993e05177005e627d0/psutil-5.3.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"data-dist-info-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"filename":"psutil-5.4.0-cp27-none-win32.whl","hashes":{"sha256":"8121039d2280275ac82f99a0a48110450cbf5b356a11c842c8f5cdeafdf105e1"},"provenance":null,"requires-python":null,"size":218177,"upload-time":"2017-10-12T07:26:59.429237Z","url":"https://files.pythonhosted.org/packages/4c/89/08a536124b4ee1fd850982f59ab7268a359e4160a6bcc1d473f6971fbdd4/psutil-5.4.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"data-dist-info-metadata":{"sha256":"dc4ac37cc269cb56f6fd4292649312b61d28d4970d9dce30eebae6899076846a"},"filename":"psutil-5.4.0-cp27-none-win_amd64.whl","hashes":{"sha256":"fcd93acb2602d01b86e0cfa4c2db689a81badae98d9c572348c94f1b2ea4b30d"},"provenance":null,"requires-python":null,"size":220988,"upload-time":"2017-10-12T07:27:04.404602Z","url":"https://files.pythonhosted.org/packages/c9/3d/0cd95044d1245166ddf24144e1b3e7a6b6a81933de3ff48c1851664109fc/psutil-5.4.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"data-dist-info-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"filename":"psutil-5.4.0-cp33-cp33m-win32.whl","hashes":{"sha256":"60a58bfdda1fc6e86ecf95c6eef71252d9049694df9aa0a16c2841a425fc9deb"},"provenance":null,"requires-python":null,"size":218040,"upload-time":"2017-10-12T07:27:13.087638Z","url":"https://files.pythonhosted.org/packages/e5/1a/0f27898ad585d924e768b0c7029c7d7ac429994a3a032419c51f1c1f3e41/psutil-5.4.0-cp33-cp33m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"data-dist-info-metadata":{"sha256":"b165c036e28aeff5aef41800231918509ab9366f5817be37e7123de4bd7ce3a2"},"filename":"psutil-5.4.0-cp33-cp33m-win_amd64.whl","hashes":{"sha256":"9956b370243005d5561a94efa44b0cddb826d1f14d21958003925b008d3b9eb1"},"provenance":null,"requires-python":null,"size":220796,"upload-time":"2017-10-12T07:27:19.356245Z","url":"https://files.pythonhosted.org/packages/19/8e/b42236e04fbd03ffa2a08a393c8800fd7d51b11823c0e18723f0780d9b6a/psutil-5.4.0-cp33-cp33m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp34-cp34m-win32.whl","hashes":{"sha256":"104fec73d9ed573351f3efbf1b7ee19eb3b4097e2b3d9ff26b1ac5bca52b6f9e"},"provenance":null,"requires-python":null,"size":217969,"upload-time":"2017-10-12T07:27:24.486998Z","url":"https://files.pythonhosted.org/packages/11/42/0711b59b7f2f2f7de7912d30bc599950011d25401bda8a3330f878ff1e56/psutil-5.4.0-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"64b2814b30452d854d5f7a7c9c0d77423388b44eb2a8bcab3b84feeceaba8ffb"},"provenance":null,"requires-python":null,"size":220696,"upload-time":"2017-10-12T07:27:29.623184Z","url":"https://files.pythonhosted.org/packages/e6/67/e19ccc78646810cbc432c429e2993315cf50a126379b83b0f8b3eb9172b9/psutil-5.4.0-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp35-cp35m-win32.whl","hashes":{"sha256":"1a89ba967d4b9a3d5f19ea2c63b09e5ffb3a81de3116ead7bfb67b9c308e8dba"},"provenance":null,"requires-python":null,"size":220150,"upload-time":"2017-10-12T07:27:34.351564Z","url":"https://files.pythonhosted.org/packages/cc/c1/47edb3fccbb1354499297702ca55aec41ff7aab67b4df69aba9db4e52a7c/psutil-5.4.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c8362902d4d94640c61960c18d8aa1af074822a549c3d4f137be3aa62c17f4b9"},"provenance":null,"requires-python":null,"size":223827,"upload-time":"2017-10-12T07:27:46.430105Z","url":"https://files.pythonhosted.org/packages/a9/e4/d399d060bbf40c1480ce2bfbc429edbd42769b048c4c7fdc51a49d74c9cf/psutil-5.4.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp36-cp36m-win32.whl","hashes":{"sha256":"04ed7548dfe61ab2561a94ac848a5b79239bb23e9015596ffd0644efd22461ba"},"provenance":null,"requires-python":null,"size":220151,"upload-time":"2017-10-12T07:27:51.153048Z","url":"https://files.pythonhosted.org/packages/2b/46/88fdd6206f01b04547bb89a6d2ff7eec380e5c59bda56ee03a0759ed397c/psutil-5.4.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"data-dist-info-metadata":{"sha256":"eed08ae034f087bf660376ef37f75441a8f3d124c69a4be6089c1e755219a000"},"filename":"psutil-5.4.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"346555603ea903a5524bb37a49b0e0f90960c6c9973ebf794ae0802a4aa875eb"},"provenance":null,"requires-python":null,"size":223825,"upload-time":"2017-10-12T07:27:57.513929Z","url":"https://files.pythonhosted.org/packages/34/e2/8421ca5b99209fa43e48d2f76a21d5d86d7346838053abf7a4d2aa37255e/psutil-5.4.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.0.tar.gz","hashes":{"sha256":"8e6397ec24a2ec09751447d9f169486b68b37ac7a8d794dca003ace4efaafc6a"},"provenance":null,"requires-python":null,"size":406945,"upload-time":"2017-10-12T07:22:51.321681Z","url":"https://files.pythonhosted.org/packages/8d/96/1fc6468be91521192861966c40bd73fdf8b065eae6d82dd0f870b9825a65/psutil-5.4.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"data-dist-info-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"filename":"psutil-5.4.1-cp27-none-win32.whl","hashes":{"sha256":"7ef26ebe728ac821de17df23820e6ffcfd37c409fc865380e4d5ae1388f274a1"},"provenance":null,"requires-python":null,"size":218627,"upload-time":"2017-11-08T13:50:32.260924Z","url":"https://files.pythonhosted.org/packages/dd/dd/1811a99faefd2b5947b4e68bd70767b525fdbad65481a4bd2ee7e6408749/psutil-5.4.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"data-dist-info-metadata":{"sha256":"e0b722d181bbe7aba5016d4d14c510f34b0ceccccc534c1324af4b5bb619046f"},"filename":"psutil-5.4.1-cp27-none-win_amd64.whl","hashes":{"sha256":"692dc72817d157aae522231dd334ea2524c6b07d844db0e7a2d6897820083427"},"provenance":null,"requires-python":null,"size":221450,"upload-time":"2017-11-08T13:50:37.542045Z","url":"https://files.pythonhosted.org/packages/51/c1/eec6a42a9f5fcd564c3fe3c6435c2c00e4e951a37f3ea3d324b04503ca6f/psutil-5.4.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp34-cp34m-win32.whl","hashes":{"sha256":"92342777d46e4630cf17d437412dc7fce0a8561217e074d36a35eb911ffd570e"},"provenance":null,"requires-python":null,"size":218421,"upload-time":"2017-11-08T13:50:42.728570Z","url":"https://files.pythonhosted.org/packages/e1/bd/d34935cd39f893d6e9ed46df5245aa71b29d2408b98f23755f234d517f80/psutil-5.4.1-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"f8f2f47a987c32ed3ca2068f3dfa9060dc9ff6cbed023d627d3f27060f4e59c4"},"provenance":null,"requires-python":null,"size":221144,"upload-time":"2017-11-08T13:50:47.928399Z","url":"https://files.pythonhosted.org/packages/24/ae/dcb7394e75b23b71f46742ffdab21d864a7ae74124b7930e5ea4f47b9049/psutil-5.4.1-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp35-cp35m-win32.whl","hashes":{"sha256":"1fce45549618d1930afefe322834ba91758331725bfdaec73ba6abcc83f6dc11"},"provenance":null,"requires-python":null,"size":220611,"upload-time":"2017-11-08T13:50:52.754745Z","url":"https://files.pythonhosted.org/packages/e8/58/c60fbf66c58d1e4b18902d601a294cb6ee993f3d051b44fdf397b6166852/psutil-5.4.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f8a88553b2b5916f3bd814a91942215822a1dabae6db033cbb019095d6a24bc2"},"provenance":null,"requires-python":null,"size":224288,"upload-time":"2017-11-08T13:50:58.405900Z","url":"https://files.pythonhosted.org/packages/4f/f8/0e4e80114bc58267199c932f9227d09a00dea952b37400f76aa2a3bb9492/psutil-5.4.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp36-cp36m-win32.whl","hashes":{"sha256":"4139f76baa59142b907dd581d7ff3506a5163cb8ef69e8e92060df330bbf5788"},"provenance":null,"requires-python":null,"size":220610,"upload-time":"2017-11-08T13:51:03.361290Z","url":"https://files.pythonhosted.org/packages/8e/16/02eb53ea087776d9f219973e7b52c7d729929a2727c15894842f9b3629e6/psutil-5.4.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"data-dist-info-metadata":{"sha256":"bea16c7d13fd463723ac0b38f421db313ae19443becf2ea91b0a77f6f3d8d8f2"},"filename":"psutil-5.4.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d61bc04401ce938576e4c6ec201e812ed4114bfb9712202b87003619116c90c6"},"provenance":null,"requires-python":null,"size":224287,"upload-time":"2017-11-08T13:51:07.991086Z","url":"https://files.pythonhosted.org/packages/4a/89/0610a20ab3d1546fbe288001fb79ec4818ef6de29f89259c39daea85984f/psutil-5.4.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.1.tar.gz","hashes":{"sha256":"42e2de159e3c987435cb3b47d6f37035db190a1499f3af714ba7af5c379b6ba2"},"provenance":null,"requires-python":null,"size":408489,"upload-time":"2017-11-08T13:51:15.716367Z","url":"https://files.pythonhosted.org/packages/fe/17/0f0bf5792b2dfe6003efc5175c76225f7d3426f88e2bf8d360cfab870cd8/psutil-5.4.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"data-dist-info-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"filename":"psutil-5.4.2-cp27-none-win32.whl","hashes":{"sha256":"2fbbc7dce43c5240b9dc6d56302d57412f1c5a0d665d1f04eb05a6b7279f4e9b"},"provenance":null,"requires-python":null,"size":221114,"upload-time":"2017-12-07T12:03:17.419322Z","url":"https://files.pythonhosted.org/packages/e6/e2/09d55a6e899cf1a7b6a22d0cc2a75d45553df5b63d7c9f2eb2553c7207bc/psutil-5.4.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"data-dist-info-metadata":{"sha256":"3e4ef4cfed824c06d6acaff8f28af76203e0c1238133c71c6de75c654e9c89b1"},"filename":"psutil-5.4.2-cp27-none-win_amd64.whl","hashes":{"sha256":"259ec8578d19643179eb2377348c63b650b51ba40f58f2620a3d9732b8a0b557"},"provenance":null,"requires-python":null,"size":223996,"upload-time":"2017-12-07T12:03:22.758210Z","url":"https://files.pythonhosted.org/packages/47/fc/e2199322f422e4bb6e25808a335132235fb0f3fabb0ea71ec3442719fdaf/psutil-5.4.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp34-cp34m-win32.whl","hashes":{"sha256":"d3808be8241433db17fa955566c3b8be61dac8ba8f221dcbb202a9daba918db5"},"provenance":null,"requires-python":null,"size":220935,"upload-time":"2017-12-07T12:03:27.058880Z","url":"https://files.pythonhosted.org/packages/d5/50/044ad4b47bf0e992a11ae7cb060e8c7dd52eb6983c2c4b6fdd5314fcc3b2/psutil-5.4.2-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"449747f638c221f8ce6ca3548aefef13339aa05b453cc1f233f4d6c31c206198"},"provenance":null,"requires-python":null,"size":223749,"upload-time":"2017-12-07T12:03:31.671187Z","url":"https://files.pythonhosted.org/packages/b5/77/6f8b4c7c6e9e8fa60b0e0627853ba7182f1a2459ad0b557fe3257bbe014b/psutil-5.4.2-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp35-cp35m-win32.whl","hashes":{"sha256":"f6c2d54abd59ed8691882de7fd6b248f5808a567885f20f50b3b4b9eedaebb1f"},"provenance":null,"requires-python":null,"size":223260,"upload-time":"2017-12-07T12:03:36.139696Z","url":"https://files.pythonhosted.org/packages/ad/fa/ac5b6bc2b25817509fc2e44f910f39b3385d1575262f7802b9c113ab786a/psutil-5.4.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e3d00d8fc3d4217f05d07af45390f072c04cb7c7dddd70b86b728e5fbe485c81"},"provenance":null,"requires-python":null,"size":226950,"upload-time":"2017-12-07T12:03:40.889125Z","url":"https://files.pythonhosted.org/packages/0e/5c/67b33328d4f307608006c3630838b272719125b36e5456a4dd8f4e76eca9/psutil-5.4.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp36-cp36m-win32.whl","hashes":{"sha256":"3473d6abad9d6ec7b8a97f4dc55f0b3483ecf470d85f08f5e23c1c07592b914f"},"provenance":null,"requires-python":null,"size":223259,"upload-time":"2017-12-07T12:03:45.502272Z","url":"https://files.pythonhosted.org/packages/59/75/97862069d3fa20f1f2897fecd5b6822a3c06ee2af1161f1beb320cc4f5f8/psutil-5.4.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"data-dist-info-metadata":{"sha256":"aee7fd8368b69d2c7b666317dd0c8e73e7af18ef863dabadfb44e8f46ffef9d5"},"filename":"psutil-5.4.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"7dc6c3bbb5d28487f791f195d6abfdef295d34c44ce6cb5f2d178613fb3338ab"},"provenance":null,"requires-python":null,"size":226952,"upload-time":"2017-12-07T12:03:51.257182Z","url":"https://files.pythonhosted.org/packages/8f/9a/5dea138e49addd68d8e65d08103dd28428f1ea0b8d4e8beef9b24f069a16/psutil-5.4.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.2.tar.gz","hashes":{"sha256":"00a1f9ff8d1e035fba7bfdd6977fa8ea7937afdb4477339e5df3dba78194fe11"},"provenance":null,"requires-python":null,"size":411888,"upload-time":"2017-12-07T12:03:58.583601Z","url":"https://files.pythonhosted.org/packages/54/24/aa854703715fa161110daa001afce75d21d1840e9ab5eb28708d6a5058b0/psutil-5.4.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"data-dist-info-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"filename":"psutil-5.4.3-cp27-none-win32.whl","hashes":{"sha256":"82a06785db8eeb637b349006cc28a92e40cd190fefae9875246d18d0de7ccac8"},"provenance":null,"requires-python":null,"size":220984,"upload-time":"2018-01-01T20:33:16.515515Z","url":"https://files.pythonhosted.org/packages/e5/cc/6dd427e738a8db6d0b66525856da43d2ef12c4c19269863927f7cf0e2aaf/psutil-5.4.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"data-dist-info-metadata":{"sha256":"9de2e14fb34c7d6a6d1b3692c6e7830d8a950ce4740bd70dbc4f2900ad780b67"},"filename":"psutil-5.4.3-cp27-none-win_amd64.whl","hashes":{"sha256":"4152ae231709e3e8b80e26b6da20dc965a1a589959c48af1ed024eca6473f60d"},"provenance":null,"requires-python":null,"size":223871,"upload-time":"2018-01-01T20:33:24.887595Z","url":"https://files.pythonhosted.org/packages/b9/e4/6867765edcab8d12a52c84c9b0af492ecb99f8cc565ad552341bcf73ebd9/psutil-5.4.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp34-cp34m-win32.whl","hashes":{"sha256":"230eeb3aeb077814f3a2cd036ddb6e0f571960d327298cc914c02385c3e02a63"},"provenance":null,"requires-python":null,"size":220823,"upload-time":"2018-01-01T20:33:31.019909Z","url":"https://files.pythonhosted.org/packages/5b/fc/745a864190a4221cdb984e666f4218e98d9a53a64b4dcf2eb7a71c1bf693/psutil-5.4.3-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"a3286556d4d2f341108db65d8e20d0cd3fcb9a91741cb5eb496832d7daf2a97c"},"provenance":null,"requires-python":null,"size":223605,"upload-time":"2018-01-01T20:33:38.392793Z","url":"https://files.pythonhosted.org/packages/b0/25/414738d5e8e75418e560a36651d1e1b09c9df05440a2a808d999a5548b1e/psutil-5.4.3-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp35-cp35m-win32.whl","hashes":{"sha256":"94d4e63189f2593960e73acaaf96be235dd8a455fe2bcb37d8ad6f0e87f61556"},"provenance":null,"requires-python":null,"size":223167,"upload-time":"2018-01-01T20:33:43.796884Z","url":"https://files.pythonhosted.org/packages/e9/80/8da216f42050220f37f7133d2accfcd001a1bd0f31d7cdb8660acb46b8fe/psutil-5.4.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c91eee73eea00df5e62c741b380b7e5b6fdd553891bee5669817a3a38d036f13"},"provenance":null,"requires-python":null,"size":226810,"upload-time":"2018-01-01T20:33:50.884798Z","url":"https://files.pythonhosted.org/packages/23/34/b3de39502c2c34899f9e7ae3c8d1050c9317997ab1fe6c647e7a789571a8/psutil-5.4.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp36-cp36m-win32.whl","hashes":{"sha256":"779ec7e7621758ca11a8d99a1064996454b3570154277cc21342a01148a49c28"},"provenance":null,"requires-python":null,"size":223168,"upload-time":"2018-01-01T20:33:56.458784Z","url":"https://files.pythonhosted.org/packages/da/c1/caadba7c64f72118b02f019c60ad85a5668ddf0a32836230b71692b0cbfa/psutil-5.4.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"data-dist-info-metadata":{"sha256":"7a6c999b9c5b0661b0db22bb84f2ef4f1cf396a3f1ed6311aad005f3bee574e8"},"filename":"psutil-5.4.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"8a15d773203a1277e57b1d11a7ccdf70804744ef4a9518a87ab8436995c31a4b"},"provenance":null,"requires-python":null,"size":226804,"upload-time":"2018-01-01T20:34:03.130620Z","url":"https://files.pythonhosted.org/packages/71/80/90799d3dc6e33e650ee03f96fa18157faed885593eabea3a6560ebff7de0/psutil-5.4.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.3.tar.gz","hashes":{"sha256":"e2467e9312c2fa191687b89ff4bc2ad8843be4af6fb4dc95a7cc5f7d7a327b18"},"provenance":null,"requires-python":null,"size":412550,"upload-time":"2018-01-01T20:34:13.285899Z","url":"https://files.pythonhosted.org/packages/e2/e1/600326635f97fee89bf8426fef14c5c29f4849c79f68fd79f433d8c1bd96/psutil-5.4.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"data-dist-info-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"filename":"psutil-5.4.4-cp27-none-win32.whl","hashes":{"sha256":"8f208867d41eb3b6de416df098a9a28d08d40b432467d821b8ef5bb589a394ce"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216647,"upload-time":"2018-04-13T09:10:24.220147Z","url":"https://files.pythonhosted.org/packages/e8/cd/dbf537e32de1c9f06a0069bf0ef13c8707f653e9af2b0ea0ed7040b73083/psutil-5.4.4-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"data-dist-info-metadata":{"sha256":"485b43e92c234e987a6b5a9be22665d46ab26940b08a2edad8583aa4743c0439"},"filename":"psutil-5.4.4-cp27-none-win_amd64.whl","hashes":{"sha256":"77b5e310de17085346ef2c4c21b64d5e39616ab4559b8ef6fea9f6f2ab0de66f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219668,"upload-time":"2018-04-13T09:10:29.328807Z","url":"https://files.pythonhosted.org/packages/7f/37/538bb4275d8a26ec369944878a681000e827e72cab9b4f27f4b1b5932446/psutil-5.4.4-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp34-cp34m-win32.whl","hashes":{"sha256":"fec0e59dacbe91db7e063f038301f49da7e9361732fc31d28338ecaa4719520e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216642,"upload-time":"2018-04-13T09:10:33.842941Z","url":"https://files.pythonhosted.org/packages/92/e9/c9c4ec1a0ac55ee1514c1a249d017dd2f7a89e727d236ed6862b493de154/psutil-5.4.4-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"1268fb6959cd8d761c30e13e79908ae73ba5a69c3c3a5d09a7a27278446f9800"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219513,"upload-time":"2018-04-13T09:10:38.041575Z","url":"https://files.pythonhosted.org/packages/83/49/c903f446d28bfb6e92fa08b710f68cd5d17cc2ccfc4a13fe607f8b20f6dd/psutil-5.4.4-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp35-cp35m-win32.whl","hashes":{"sha256":"7eb2d80ef79d90474a03eead13b32e541d1fdeb47468cf04c881f0a7392ddbc5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219220,"upload-time":"2018-04-13T09:10:42.685382Z","url":"https://files.pythonhosted.org/packages/bb/63/c9b3e9ff8d23409896a7e9e7356a730fdfb5a45a1edc0e6d4ca5ce655f29/psutil-5.4.4-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"69f1db4d13f362ce11a6246b20c752c31b87a6fd77452170fd03c26a8a20a4f2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222757,"upload-time":"2018-04-13T09:10:47.950981Z","url":"https://files.pythonhosted.org/packages/72/22/a5ce34af1285679e02d7fd701ff6389f579a17e623dd89236ea1873ce12b/psutil-5.4.4-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp36-cp36m-win32.whl","hashes":{"sha256":"6eb59bcfd48eade8889bae67a16e0d8c7b18af0732ba64dead61206fd7cb4e45"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219224,"upload-time":"2018-04-13T09:10:52.291473Z","url":"https://files.pythonhosted.org/packages/3c/6d/5e9a3683d4532997525aa20d1d9ce0ca1201271d30aad9e5f18c34459478/psutil-5.4.4-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"data-dist-info-metadata":{"sha256":"893713cd1f34926704c2e5f844b554a79ad42ce1c20046651dad28613eb2d0bc"},"filename":"psutil-5.4.4-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"a4af5d4fcf6022886a30fb3b4fff71ff25f645865a68506680d43a3e634764af"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222759,"upload-time":"2018-04-13T09:10:56.584621Z","url":"https://files.pythonhosted.org/packages/b6/61/eeeab30fa737b8b95b790d3eb8f49ebedeb783e43aef2d8d851687592d6c/psutil-5.4.4-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.4.tar.gz","hashes":{"sha256":"5959e33e0fc69742dd22e88bfc7789a1f2e1fc2297794b543119e10cdac8dfb1"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":417890,"upload-time":"2018-04-13T09:11:03.199870Z","url":"https://files.pythonhosted.org/packages/35/35/7da482448cd9ee3555faa9c5e541e37b18a849fb961e55d6fda6ca936ddb/psutil-5.4.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"data-dist-info-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"filename":"psutil-5.4.5-cp27-none-win32.whl","hashes":{"sha256":"33384065f0014351fa70187548e3e95952c4df4bc5c38648bd0e647d21eaaf01"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216630,"upload-time":"2018-04-13T17:59:43.195295Z","url":"https://files.pythonhosted.org/packages/63/9f/529a599db3057602114a30aa5e3641e78bce6c6e195adb75309c9286cb88/psutil-5.4.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"data-dist-info-metadata":{"sha256":"c8af77aa4cab9fad5f3310c13c633fb6bb0f5a44421d0e8662a9f16b38ca9aec"},"filename":"psutil-5.4.5-cp27-none-win_amd64.whl","hashes":{"sha256":"f24cd52bafa06917935fe1b68c5a45593abe1f3097dc35b2dfc4718236795890"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219650,"upload-time":"2018-04-13T17:59:53.389911Z","url":"https://files.pythonhosted.org/packages/b6/ca/2d23b37e9b30908174d2cb596f60f06b3858856a2e595c931f7d4d640c03/psutil-5.4.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp34-cp34m-win32.whl","hashes":{"sha256":"99029b6af386b22882f0b6d537ffed5a9c3d5ff31782974aeaa1d683262d8543"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216589,"upload-time":"2018-04-13T18:00:04.166075Z","url":"https://files.pythonhosted.org/packages/bf/bc/f687dfa4679aad782fb78c43fed2626cb0157567a5b06790997e5aa0f166/psutil-5.4.5-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"51e12aa74509832443862373a2655052b20c83cad7322f49d217452500b9a405"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219462,"upload-time":"2018-04-13T18:00:14.637120Z","url":"https://files.pythonhosted.org/packages/32/b5/545953316dd9cb053e4c7d4f70d88aba5362dbbe58422ca6bbec1bbf8956/psutil-5.4.5-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp35-cp35m-win32.whl","hashes":{"sha256":"325c334596ad2d8a178d0e7b4eecc91748096a87489b3701ee16986173000aaa"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219172,"upload-time":"2018-04-13T18:00:28.230677Z","url":"https://files.pythonhosted.org/packages/00/ed/fdf2930c41e76e3a8bc59bf998062ee5ad0c393170a7d2c273dd3b259794/psutil-5.4.5-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"52a91ba928a5e86e0249b4932d6e36972a72d1ad8dcc5b7f753a2ae14825a4ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222706,"upload-time":"2018-04-13T18:00:38.180085Z","url":"https://files.pythonhosted.org/packages/c6/bf/09b13c17f54f0004ccb43cc1c2d36bab2eb75f471564b7856749dcaf62c3/psutil-5.4.5-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp36-cp36m-win32.whl","hashes":{"sha256":"b10703a109cc9225cd588c207f7f93480a420ade35c13515ea8f20063b42a392"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219171,"upload-time":"2018-04-13T18:00:52.610707Z","url":"https://files.pythonhosted.org/packages/3c/ae/34952007b4d64f88a03510866b9cd90207e391f6b2b59b6301ad96fa0fb5/psutil-5.4.5-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"data-dist-info-metadata":{"sha256":"4fb804f1abb5eb53785449da8e1201c9af34b09face243251213fa79878f9142"},"filename":"psutil-5.4.5-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ddba952ed256151844d82fb13c8fb1019fe11ecaeacbd659d67ba5661ae73d0d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222710,"upload-time":"2018-04-13T18:01:02.457641Z","url":"https://files.pythonhosted.org/packages/4c/bb/303f15f4a47b96ff0ae5025d89b330e2be314085c418c0b726877476e937/psutil-5.4.5-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.5.tar.gz","hashes":{"sha256":"ebe293be36bb24b95cdefc5131635496e88b17fabbcf1e4bc9b5c01f5e489cfe"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":418003,"upload-time":"2018-04-13T18:01:19.381491Z","url":"https://files.pythonhosted.org/packages/14/a2/8ac7dda36eac03950ec2668ab1b466314403031c83a95c5efc81d2acf163/psutil-5.4.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"data-dist-info-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"filename":"psutil-5.4.6-cp27-none-win32.whl","hashes":{"sha256":"319e12f6bae4d4d988fbff3bed792953fa3b44c791f085b0a1a230f755671ef7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216468,"upload-time":"2018-06-07T15:39:23.967375Z","url":"https://files.pythonhosted.org/packages/b4/00/82c9fb4ffca22f2f6d0d883469584cd0cff71a604a19809015045b1fbab6/psutil-5.4.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"data-dist-info-metadata":{"sha256":"aa807ba097a31687e416722680ba225449cb087946d4db7e62db8c1659a43a5d"},"filename":"psutil-5.4.6-cp27-none-win_amd64.whl","hashes":{"sha256":"7789885a72aa3075d28d028236eb3f2b84d908f81d38ad41769a6ddc2fd81b7c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219532,"upload-time":"2018-06-07T15:39:26.297791Z","url":"https://files.pythonhosted.org/packages/c2/23/22df1d36dc8ae002e9f646f9ed06b4f6bfbc7a22b67804c3a497be21d002/psutil-5.4.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp34-cp34m-win32.whl","hashes":{"sha256":"0ff2b16e9045d01edb1dd10d7fbcc184012e37f6cd38029e959f2be9c6223f50"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":216464,"upload-time":"2018-06-07T15:39:28.563215Z","url":"https://files.pythonhosted.org/packages/f9/fa/966988e350306e1a1a9024e77ad5f118cbfe11318e8bdfc258c3d5a1c68b/psutil-5.4.6-cp34-cp34m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp34-cp34m-win_amd64.whl","hashes":{"sha256":"dc85fad15ef98103ecc047a0d81b55bbf5fe1b03313b96e883acc2e2fa87ed5c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219331,"upload-time":"2018-06-07T15:39:31.250304Z","url":"https://files.pythonhosted.org/packages/a5/0d/40b552c2c089523df1f7ab5a0249fbf90cb2e80e89177b0189e41e367adc/psutil-5.4.6-cp34-cp34m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp35-cp35m-win32.whl","hashes":{"sha256":"7f4616bcb44a6afda930cfc40215e5e9fa7c6896e683b287c771c937712fbe2f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219052,"upload-time":"2018-06-07T15:39:33.732713Z","url":"https://files.pythonhosted.org/packages/00/4d/194ec701de80c704f679bf78495c054994cc403884ffec816787813c4fde/psutil-5.4.6-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"529ae235896efb99a6f77653a7138273ab701ec9f0343a1f5030945108dee3c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222533,"upload-time":"2018-06-07T15:39:36.224840Z","url":"https://files.pythonhosted.org/packages/e3/21/f82f270326e098f211bcc36cbb2ae7100732dcad03bd324e6af8c9d7e407/psutil-5.4.6-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp36-cp36m-win32.whl","hashes":{"sha256":"254adb6a27c888f141d2a6032ae231d8ed4fc5f7583b4c825e5f7d7c78d26d2e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219048,"upload-time":"2018-06-07T15:39:38.273913Z","url":"https://files.pythonhosted.org/packages/d6/e0/0f1b4f61246c4e2b540898b1ca0fa51ee2f52f0366956974f1039e00ed67/psutil-5.4.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"a9b85b335b40a528a8e2a6b549592138de8429c6296e7361892958956e6a73cf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222534,"upload-time":"2018-06-07T15:39:40.675791Z","url":"https://files.pythonhosted.org/packages/36/4b/80d9eb5d39ec4b4d8aec8b098b5097a7291de20bbbe6c2ab233b9d8fe245/psutil-5.4.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp37-cp37m-win32.whl","hashes":{"sha256":"6d981b4d863b20c8ceed98b8ac3d1ca7f96d28707a80845d360fa69c8fc2c44b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":219860,"upload-time":"2018-06-28T22:47:57.979619Z","url":"https://files.pythonhosted.org/packages/7a/62/28923c44954b6cf8aee637f3a2f30e0e1ff39ec0f74a4f98069d37f00751/psutil-5.4.6-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"data-dist-info-metadata":{"sha256":"b7bbbf54e7767a4dcfada805607a533828d7e74794bf64ea1ae76700fc24d495"},"filename":"psutil-5.4.6-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"7fdb3d02bfd68f508e6745021311a4a4dbfec53fca03721474e985f310e249ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224296,"upload-time":"2018-06-28T22:48:01.565801Z","url":"https://files.pythonhosted.org/packages/b1/be/78f9d786bddc190c4b394a01531741a11b95f1522cf2759958f13b46407f/psutil-5.4.6-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.6.tar.gz","hashes":{"sha256":"686e5a35fe4c0acc25f3466c32e716f2d498aaae7b7edc03e2305b682226bcf6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":418059,"upload-time":"2018-06-07T15:39:42.364107Z","url":"https://files.pythonhosted.org/packages/51/9e/0f8f5423ce28c9109807024f7bdde776ed0b1161de20b408875de7e030c3/psutil-5.4.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"data-dist-info-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"filename":"psutil-5.4.7-cp27-none-win32.whl","hashes":{"sha256":"b34611280a2d0697f1c499e15e936d88109170194b390599c98bab8072a71f05"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":217777,"upload-time":"2018-08-14T21:01:10.586697Z","url":"https://files.pythonhosted.org/packages/b7/e9/bedbdfecef9d708489cfcd8b9aeada8d8f014fc14644c7129c7177e80d32/psutil-5.4.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"data-dist-info-metadata":{"sha256":"94ef062f36609f64cc686f1930bf277790b85ced443769e242d41eb7a2588bec"},"filename":"psutil-5.4.7-cp27-none-win_amd64.whl","hashes":{"sha256":"a890c3e490493f21da2817ffc92822693bc0d6bcac9999caa04ffce8dd4e7132"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220989,"upload-time":"2018-08-14T21:01:13.273922Z","url":"https://files.pythonhosted.org/packages/50/6a/34525bc4e6e153bf6e849a4c4e936742b365f6819c0462cebfa4f082a3c4/psutil-5.4.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp35-cp35m-win32.whl","hashes":{"sha256":"1914bacbd2fc2af8f795daa44b9d2e0649a147460cfd21b1a70a124472f66d40"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220344,"upload-time":"2018-08-14T21:01:15.659359Z","url":"https://files.pythonhosted.org/packages/36/32/5b10d7c3940c64fe92620c368ede8a10016d51aa36079a5cd69944da5a74/psutil-5.4.7-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d081707ef0081920533db30200a2d30d5c0ea9cf6afa7cf8881ae4516cc69c48"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224081,"upload-time":"2018-08-14T21:01:18.052521Z","url":"https://files.pythonhosted.org/packages/ef/fc/8dc7731df7de2f4c65378a7147ecc977221093eee90d9777ca501c2790c5/psutil-5.4.7-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp36-cp36m-win32.whl","hashes":{"sha256":"0d8da7333549a998556c18eb2af3ce902c28d66ceb947505c008f91e9f988abd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220342,"upload-time":"2018-08-14T21:01:20.870660Z","url":"https://files.pythonhosted.org/packages/20/6e/a9a0f84bc3efe970b4c8688b7e7f14ee8342497de8a88cffd35bb485cdcc/psutil-5.4.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"cea2557ee6a9faa2c100947637ded68414e12b851633c4ce26e0311b2a2ed539"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224085,"upload-time":"2018-08-14T21:01:22.891149Z","url":"https://files.pythonhosted.org/packages/97/9e/c056abafcf0fc7ca5bddbc21ad1bb7c67889e16c088b9759f00b95fefcb4/psutil-5.4.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp37-cp37m-win32.whl","hashes":{"sha256":"215d61a901e67b1a35e14c6aedef317f7fa7e6075a20c150fd11bd2c906d2c83"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220347,"upload-time":"2018-08-14T21:01:25.157286Z","url":"https://files.pythonhosted.org/packages/2e/33/5cef36162d94cf0adce428729adeb18b8548ff060781854f3aca71e6b0f0/psutil-5.4.7-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"data-dist-info-metadata":{"sha256":"77861491100106f950300f1104d6fcb309d103d34e379a69c8780e9edefa6710"},"filename":"psutil-5.4.7-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"51057c03aea251ad6667c2bba259bc7ed3210222d3a74152c84e3ab06e1da0ba"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224087,"upload-time":"2018-08-14T21:01:27.563142Z","url":"https://files.pythonhosted.org/packages/bb/15/aa3d11ae8bf04b7683224f7d3b8f2dd4d3f8a918dcce59bb1f987fca9c6e/psutil-5.4.7-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.7.tar.gz","hashes":{"sha256":"5b6322b167a5ba0c5463b4d30dfd379cd4ce245a1162ebf8fc7ab5c5ffae4f3b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":420300,"upload-time":"2018-08-14T21:01:30.063470Z","url":"https://files.pythonhosted.org/packages/7d/9a/1e93d41708f8ed2b564395edfa3389f0fd6d567597401c2e5e2775118d8b/psutil-5.4.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"data-dist-info-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"filename":"psutil-5.4.8-cp27-none-win32.whl","hashes":{"sha256":"809c9cef0402e3e48b5a1dddc390a8a6ff58b15362ea5714494073fa46c3d293"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":220106,"upload-time":"2018-10-30T09:57:34.685390Z","url":"https://files.pythonhosted.org/packages/5a/3f/3f0920df352dae7f824e0e612ff02591378f78405d6c7663dcac023005c4/psutil-5.4.8-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"data-dist-info-metadata":{"sha256":"000e5f1178f3b76020f7866397e41f07c1f4564da730a45c24894e3aebebb7cb"},"filename":"psutil-5.4.8-cp27-none-win_amd64.whl","hashes":{"sha256":"3b7a4daf4223dae171a67a89314ac5ca0738e94064a78d99cfd751c55d05f315"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":223347,"upload-time":"2018-10-30T09:57:37.065973Z","url":"https://files.pythonhosted.org/packages/0f/fb/6aecd2c8c9d0ac83d789eaf9f9ec052dd61dd5aea2b47ffa4704175d7a2a/psutil-5.4.8-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp35-cp35m-win32.whl","hashes":{"sha256":"bbffac64cfd01c6bcf90eb1bedc6c80501c4dae8aef4ad6d6dd49f8f05f6fc5a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222713,"upload-time":"2018-10-30T09:57:39.214229Z","url":"https://files.pythonhosted.org/packages/46/2e/ce4ec4b60decc23e0e4d148b6f44c7ddd06ba0ab207dfaee21958bd669df/psutil-5.4.8-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b4d1b735bf5b120813f4c89db8ac22d89162c558cbd7fdd298866125fe906219"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226441,"upload-time":"2018-10-30T09:57:41.411069Z","url":"https://files.pythonhosted.org/packages/7f/28/5ccdb98eff12e7741cc2a6d9dcfdd5d9e06f6d363c2c019d5bfa0e0c1282/psutil-5.4.8-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp36-cp36m-win32.whl","hashes":{"sha256":"3e19be3441134445347af3767fa7770137d472a484070840eee6653b94ac5576"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222711,"upload-time":"2018-10-30T09:57:43.901154Z","url":"https://files.pythonhosted.org/packages/b5/31/8ac896ca77a6aa75ee900698f96ddce46e96bb2484a92457c359a4e4bae6/psutil-5.4.8-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1c19957883e0b93d081d41687089ad630e370e26dc49fd9df6951d6c891c4736"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226440,"upload-time":"2018-10-30T09:57:46.331527Z","url":"https://files.pythonhosted.org/packages/3b/15/62d1eeb4c015e20295e0197f7de0202bd9e5bcb5529b9503932decde2505/psutil-5.4.8-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp37-cp37m-win32.whl","hashes":{"sha256":"bfcea4f189177b2d2ce4a34b03c4ac32c5b4c22e21f5b093d9d315e6e253cd81"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222709,"upload-time":"2018-10-30T09:57:48.860424Z","url":"https://files.pythonhosted.org/packages/21/1e/fe6731e5f03ddf2e57d5b307f25bba294262bc88e27a0fbefdb3515d1727/psutil-5.4.8-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"data-dist-info-metadata":{"sha256":"edcd0deabcf9a4ae02acef42bf31c36db6ad085b36a3cc549cfded47de1f1e8f"},"filename":"psutil-5.4.8-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"1c71b9716790e202a00ab0931a6d1e25db1aa1198bcacaea2f5329f75d257fff"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226447,"upload-time":"2018-10-30T09:57:50.676641Z","url":"https://files.pythonhosted.org/packages/50/00/ae52663b879333aa5c65fc9a87ddc24169f8fdd1831762a1ba9c9be7740d/psutil-5.4.8-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.4.8.tar.gz","hashes":{"sha256":"6e265c8f3da00b015d24b842bfeb111f856b13d24f2c57036582568dc650d6c3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":422742,"upload-time":"2018-10-30T09:57:52.770639Z","url":"https://files.pythonhosted.org/packages/e3/58/0eae6e4466e5abf779d7e2b71fac7fba5f59e00ea36ddb3ed690419ccb0f/psutil-5.4.8.tar.gz","yanked":false},{"core-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"data-dist-info-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"filename":"psutil-5.5.0-cp27-none-win32.whl","hashes":{"sha256":"96f3fdb4ef7467854d46ad5a7e28eb4c6dc6d455d751ddf9640cd6d52bdb03d7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":221314,"upload-time":"2019-01-23T18:23:33.526811Z","url":"https://files.pythonhosted.org/packages/fa/53/53f8c4f1af6f81b169ce76bfd0f56698bc1705da498a47d2ce701f7d7fe3/psutil-5.5.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"data-dist-info-metadata":{"sha256":"1d8c3b2819c1de19ccc23f8de068eab529322b6df33673da0ec45a41f785bdcc"},"filename":"psutil-5.5.0-cp27-none-win_amd64.whl","hashes":{"sha256":"d23f7025bac9b3e38adc6bd032cdaac648ac0074d18e36950a04af35458342e8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224546,"upload-time":"2019-01-23T18:23:36.443393Z","url":"https://files.pythonhosted.org/packages/86/96/a7bfcc3aebedd7112ff353204901db6a1a0c1f3555b2788c68842bb78005/psutil-5.5.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp35-cp35m-win32.whl","hashes":{"sha256":"04d2071100aaad59f9bcbb801be2125d53b2e03b1517d9fed90b45eea51d297e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224084,"upload-time":"2019-01-23T18:23:39.132334Z","url":"https://files.pythonhosted.org/packages/c6/ca/f5d3841ca35e3e3607ed64fe61d2c392054692f05f35e807335299a7952b/psutil-5.5.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"d0c4230d60376aee0757d934020b14899f6020cd70ef8d2cb4f228b6ffc43e8f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227536,"upload-time":"2019-01-23T18:23:42.027389Z","url":"https://files.pythonhosted.org/packages/86/0d/a13c15ddccd8e2ccabe63f6d4f139f5a94150b758026e030310e87dded80/psutil-5.5.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp36-cp36m-win32.whl","hashes":{"sha256":"3ac48568f5b85fee44cd8002a15a7733deca056a191d313dbf24c11519c0c4a8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224085,"upload-time":"2019-01-23T18:23:44.450649Z","url":"https://files.pythonhosted.org/packages/45/00/7cdd50ded02e18e50667e2f76ceb645ecdfce59deb39422485f198c7be37/psutil-5.5.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"f0fcb7d3006dd4d9ccf3ccd0595d44c6abbfd433ec31b6ca177300ee3f19e54e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227537,"upload-time":"2019-01-23T18:23:46.937101Z","url":"https://files.pythonhosted.org/packages/48/d1/c9105512328c7f9800c51992b912df6f945eac696dfcd850f719541f67f3/psutil-5.5.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp37-cp37m-win32.whl","hashes":{"sha256":"c8ee08ad1b716911c86f12dc753eb1879006224fd51509f077987bb6493be615"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224078,"upload-time":"2019-01-23T18:23:49.451606Z","url":"https://files.pythonhosted.org/packages/3f/14/5adcad73f22ae0c8fba8b054c0bb7c33c906121b588cc6cbdd686f098947/psutil-5.5.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"data-dist-info-metadata":{"sha256":"053bd08cfadac2a889dd4c4d2e10bd70c7d11e50fa66c23c145303639bb537b1"},"filename":"psutil-5.5.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"b755be689d6fc8ebc401e1d5ce5bac867e35788f10229e166338484eead51b12"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227542,"upload-time":"2019-01-23T18:23:52.035332Z","url":"https://files.pythonhosted.org/packages/38/f1/a822d2b3d973c1ddd9d8a81d269e36987bab20e7bb28ecaa55aef66e8df5/psutil-5.5.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.5.0.tar.gz","hashes":{"sha256":"1aba93430050270750d046a179c5f3d6e1f5f8b96c20399ba38c596b28fc4d37"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":425058,"upload-time":"2019-01-23T18:23:54.951599Z","url":"https://files.pythonhosted.org/packages/6e/a0/833bcbcede5141cc5615e50c7cc5b960ce93d9c9b885fbe3b7d36e48a2d4/psutil-5.5.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"data-dist-info-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"filename":"psutil-5.5.1-cp27-none-win32.whl","hashes":{"sha256":"77c231b4dff8c1c329a4cd1c22b96c8976c597017ff5b09993cd148d6a94500c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":221914,"upload-time":"2019-02-15T19:34:04.528250Z","url":"https://files.pythonhosted.org/packages/cc/cd/64aaf20c945662260026a128a08e46b93a49953224c0dccfdc6f37495d45/psutil-5.5.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"data-dist-info-metadata":{"sha256":"0fa640ac67268845bdf0ad87325deaf6caae5372bf3703f282c5340f9af1f8c2"},"filename":"psutil-5.5.1-cp27-none-win_amd64.whl","hashes":{"sha256":"5ce6b5eb0267233459f4d3980c205828482f450999b8f5b684d9629fea98782a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":225325,"upload-time":"2019-02-15T19:34:07.193210Z","url":"https://files.pythonhosted.org/packages/08/92/97b011d665ade1caf05dd02a3af4ede751c7b80f34812bc81479ec867d85/psutil-5.5.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp35-cp35m-win32.whl","hashes":{"sha256":"a013b4250ccbddc9d22feca0f986a1afc71717ad026c0f2109bbffd007351191"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224822,"upload-time":"2019-02-15T19:34:09.528347Z","url":"https://files.pythonhosted.org/packages/6f/05/70f033e35cd34bc23a08793eaf713347c615674585ccfc7628b40eac4094/psutil-5.5.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"ef3e5e02b3c5d1df366abe7b4820400d5c427579668ad4465ff189d28ded5ebd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228328,"upload-time":"2019-02-15T19:34:12.035704Z","url":"https://files.pythonhosted.org/packages/8e/8d/1854ed30b9f69f4b2cc04ef4364ae8a52ad2988a3223bf6314d2d47f0f04/psutil-5.5.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp36-cp36m-win32.whl","hashes":{"sha256":"ad43b83119eeea6d5751023298cd331637e542cbd332196464799e25a5519f8f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224831,"upload-time":"2019-02-15T19:34:15.031823Z","url":"https://files.pythonhosted.org/packages/e8/c1/32fe16cb90192a9413f3ba303021047c158cbdde5aabd7e26ace8b54f69e/psutil-5.5.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ec1ef313530a9457e48d25e3fdb1723dfa636008bf1b970027462d46f2555d59"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228328,"upload-time":"2019-02-15T19:34:17.494390Z","url":"https://files.pythonhosted.org/packages/3e/6e/c0af4900f18811f09b93064588e53f3997abc051ae43f717d1ba610de3b7/psutil-5.5.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp37-cp37m-win32.whl","hashes":{"sha256":"c177777c787d247d02dae6c855330f9ed3e1abf8ca1744c26dd5ff968949999a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":224832,"upload-time":"2019-02-15T19:34:19.685175Z","url":"https://files.pythonhosted.org/packages/00/e6/561fed27453add44af41a52e13e1dfca4d1e35705d698769edea6292339a/psutil-5.5.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"data-dist-info-metadata":{"sha256":"2aea42bc7128a735bd3dd530e3776b5c46cfb57362fa41b02ed50e6275148b66"},"filename":"psutil-5.5.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"8846ab0be0cdccd6cc92ecd1246a16e2f2e49f53bd73e522c3a75ac291e1b51d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228327,"upload-time":"2019-02-15T19:34:22.218113Z","url":"https://files.pythonhosted.org/packages/3d/22/ed4fa46c5bfd95b4dc57d6544c3fe6568abe398aef3990f6011777f1a3f3/psutil-5.5.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.5.1.tar.gz","hashes":{"sha256":"72cebfaa422b7978a1d3632b65ff734a34c6b34f4578b68a5c204d633756b810"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":426750,"upload-time":"2019-02-15T19:34:24.841527Z","url":"https://files.pythonhosted.org/packages/c7/01/7c30b247cdc5ba29623faa5c8cf1f1bbf7e041783c340414b0ed7e067c64/psutil-5.5.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"data-dist-info-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"filename":"psutil-5.6.0-cp27-none-win32.whl","hashes":{"sha256":"1020a37214c4138e34962881372b40f390582b5c8245680c04349c2afb785a25"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":222534,"upload-time":"2019-03-05T12:00:59.141291Z","url":"https://files.pythonhosted.org/packages/04/f5/11b1c93a8882615fdaf6222aaf9d3197f250ab3036d7ecf6b6c8594ddf61/psutil-5.6.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"data-dist-info-metadata":{"sha256":"254b7bff05e4525511dae40a6fde55a8c45855ad1f6f2e1bc7dc4a50d7c0caf6"},"filename":"psutil-5.6.0-cp27-none-win_amd64.whl","hashes":{"sha256":"d9cdc2e82aeb82200fff3640f375fac39d88b1bed27ce08377cd7fb0e3621cb7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":225803,"upload-time":"2019-03-05T12:01:01.831664Z","url":"https://files.pythonhosted.org/packages/11/88/ed94a7c091fb6ad8fbf545f0f20e140c47286712d6d85dd8cfc40b34fe72/psutil-5.6.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp35-cp35m-win32.whl","hashes":{"sha256":"c4a2f42abee709ed97b4498c21aa608ac31fc1f7cc8aa60ebdcd3c80757a038d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226153,"upload-time":"2019-03-05T12:01:04.695139Z","url":"https://files.pythonhosted.org/packages/ab/5c/dacbb4b6623dc390939e1785a818e6e816eb42c8c96c1f2d30a2fc22a773/psutil-5.6.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"722dc0dcce5272f3c5c41609fdc2c8f0ee3f976550c2d2f2057e26ba760be9c0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230078,"upload-time":"2019-03-05T12:01:07.429607Z","url":"https://files.pythonhosted.org/packages/41/27/9e6d39ae822387ced9a77da904e24e8796c1fa55c5f637cd35221b170980/psutil-5.6.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp36-cp36m-win32.whl","hashes":{"sha256":"1c8e6444ca1cee9a60a1a35913b8409722f7474616e0e21004e4ffadba59964b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226154,"upload-time":"2019-03-05T12:01:10.226359Z","url":"https://files.pythonhosted.org/packages/fb/d0/14b83939ed41c5a80dca6fa072b1a99cd576e33810f691e73a08a7c045b4/psutil-5.6.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"151c9858c268a1523e16fab33e3bc3bae8a0e57b57cf7fcad85fb409cbac6baf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230083,"upload-time":"2019-03-05T12:01:12.681476Z","url":"https://files.pythonhosted.org/packages/ce/3a/ff53c0ee59a864c3614fcaea45f4246e670934ea0d30b632c6e3905533c9/psutil-5.6.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp37-cp37m-win32.whl","hashes":{"sha256":"86f61a1438c026c980a4c3e2dd88a5774a3a0f00d6d0954d6c5cf8d1921b804e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226154,"upload-time":"2019-03-05T12:01:15.084497Z","url":"https://files.pythonhosted.org/packages/17/15/bf444a07aae2200f7b4e786c73bfe959201cb9ab63f737be12d21b5f252e/psutil-5.6.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"data-dist-info-metadata":{"sha256":"4587b1b69c3d6666cbea0b1ac5ab97e537ce98c5c4986439eec64421d1b2baeb"},"filename":"psutil-5.6.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"da6676a484adec2fdd3e1ce1b70799881ffcb958e40208dd4c5beba0011f3589"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230081,"upload-time":"2019-03-05T12:01:17.936041Z","url":"https://files.pythonhosted.org/packages/88/fd/a32491e77b37ffc00faf79c864975cfd720ae0ac867d93c90640d44adf43/psutil-5.6.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.0.tar.gz","hashes":{"sha256":"dca71c08335fbfc6929438fe3a502f169ba96dd20e50b3544053d6be5cb19d82"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":426596,"upload-time":"2019-03-05T12:01:20.833448Z","url":"https://files.pythonhosted.org/packages/79/e6/a4e3c92fe19d386dcc6149dbf0b76f1c93c5491ae9d9ecf866f6769b45a4/psutil-5.6.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"data-dist-info-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"filename":"psutil-5.6.1-cp27-none-win32.whl","hashes":{"sha256":"23e9cd90db94fbced5151eaaf9033ae9667c033dffe9e709da761c20138d25b6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":223000,"upload-time":"2019-03-11T17:24:48.368476Z","url":"https://files.pythonhosted.org/packages/9d/f2/a84e650af7f04940709466384e94a0894cfe736e7cf43f48fb3bfb01be1b/psutil-5.6.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"data-dist-info-metadata":{"sha256":"36d6733a6cb331fb0a7acb6d901557574835b038d157bc2fc11404d520fe4b92"},"filename":"psutil-5.6.1-cp27-none-win_amd64.whl","hashes":{"sha256":"e1494d20ffe7891d07d8cb9a8b306c1a38d48b13575265d090fc08910c56d474"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226302,"upload-time":"2019-03-11T17:24:51.027456Z","url":"https://files.pythonhosted.org/packages/46/51/4007e6188b6d6b68c8b4195d6755bd76585cffd4d286d9f1815ff9f1af01/psutil-5.6.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp35-cp35m-win32.whl","hashes":{"sha256":"ec4b4b638b84d42fc48139f9352f6c6587ee1018d55253542ee28db7480cc653"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226675,"upload-time":"2019-03-11T17:24:53.625833Z","url":"https://files.pythonhosted.org/packages/55/f4/2dc147b66111116f5cb6a85fe42519b2cbfdbf6138562f8b0427bc754fc8/psutil-5.6.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"c1fd45931889dc1812ba61a517630d126f6185f688eac1693171c6524901b7de"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230613,"upload-time":"2019-03-11T17:24:56.387303Z","url":"https://files.pythonhosted.org/packages/af/dd/f3bdafb37af7bf417f984db5381a5a27899f93fd2f87d5fd10fb6f3f4087/psutil-5.6.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp36-cp36m-win32.whl","hashes":{"sha256":"d463a142298112426ebd57351b45c39adb41341b91f033aa903fa4c6f76abecc"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226672,"upload-time":"2019-03-11T17:24:58.629155Z","url":"https://files.pythonhosted.org/packages/d5/cc/e3fe388fe3c987973e929cb17cceb33bcd2ff7f8b754cd354826fbb7dfe7/psutil-5.6.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"9c3a768486194b4592c7ae9374faa55b37b9877fd9746fb4028cb0ac38fd4c60"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230621,"upload-time":"2019-03-11T17:25:01.330880Z","url":"https://files.pythonhosted.org/packages/16/6a/cc5ba8d7e3ada0d4621d493dbdcb43ed38f3549642916a14c9e070add21a/psutil-5.6.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp37-cp37m-win32.whl","hashes":{"sha256":"27858d688a58cbfdd4434e1c40f6c79eb5014b709e725c180488ccdf2f721729"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226673,"upload-time":"2019-03-11T17:25:03.865746Z","url":"https://files.pythonhosted.org/packages/a8/8e/3e04eefe955ed94f93c3cde5dc1f1ccd99e2b9a56697fa804ea9f54f7baa/psutil-5.6.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"data-dist-info-metadata":{"sha256":"ea349a2dffe50e05b14983a2cf8238d799954fa7f79adc264520315279fa3b54"},"filename":"psutil-5.6.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"354601a1d1a1322ae5920ba397c58d06c29728a15113598d1a8158647aaa5385"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230621,"upload-time":"2019-03-11T17:25:06.996226Z","url":"https://files.pythonhosted.org/packages/6a/48/dbcda6d136da319e8bee8196e6c52ff7febf56bd241435cf6a516341a4b1/psutil-5.6.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.1.tar.gz","hashes":{"sha256":"fa0a570e0a30b9dd618bffbece590ae15726b47f9f1eaf7518dfb35f4d7dcd21"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":427472,"upload-time":"2019-03-11T17:25:09.802408Z","url":"https://files.pythonhosted.org/packages/2f/b8/11ec5006d2ec2998cb68349b8d1317c24c284cf918ecd6729739388e4c56/psutil-5.6.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"data-dist-info-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"filename":"psutil-5.6.2-cp27-none-win32.whl","hashes":{"sha256":"76fb0956d6d50e68e3f22e7cc983acf4e243dc0fcc32fd693d398cb21c928802"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226692,"upload-time":"2019-04-26T02:43:03.614779Z","url":"https://files.pythonhosted.org/packages/56/8f/1bfb7e563e413f110ee06ac0cf12bb4b27f78e9cf277892d97ba08de4eac/psutil-5.6.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"data-dist-info-metadata":{"sha256":"34922aac8bd27ca8268d8103c8b443cb013543dbfb0b3b7cf9f18d802b4fc760"},"filename":"psutil-5.6.2-cp27-none-win_amd64.whl","hashes":{"sha256":"753c5988edc07da00dafd6d3d279d41f98c62cd4d3a548c4d05741a023b0c2e7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230225,"upload-time":"2019-04-26T02:43:08.318806Z","url":"https://files.pythonhosted.org/packages/91/3f/2ae9cd04b2ccc5340838383ba638839a498d2613936b7830079f77de2bf1/psutil-5.6.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp35-cp35m-win32.whl","hashes":{"sha256":"a4c62319ec6bf2b3570487dd72d471307ae5495ce3802c1be81b8a22e438b4bc"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230751,"upload-time":"2019-04-26T02:43:12.014098Z","url":"https://files.pythonhosted.org/packages/ec/39/33a7d6c4e347ffff7784ec4967c04d6319886c5a77c208d29a0980045bc8/psutil-5.6.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"ef342cb7d9b60e6100364f50c57fa3a77d02ff8665d5b956746ac01901247ac4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234724,"upload-time":"2019-04-26T02:43:15.850786Z","url":"https://files.pythonhosted.org/packages/a9/43/87e610adacc3f8e51d61c27a9d48db2c0e7fbac783764fefca4d4ec71dbe/psutil-5.6.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp36-cp36m-win32.whl","hashes":{"sha256":"acba1df9da3983ec3c9c963adaaf530fcb4be0cd400a8294f1ecc2db56499ddd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230749,"upload-time":"2019-04-26T02:43:19.804035Z","url":"https://files.pythonhosted.org/packages/23/2a/0f14e964507adc1732ade6eea3abd92afe34305614515ab856cbccca489a/psutil-5.6.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"206eb909aa8878101d0eca07f4b31889c748f34ed6820a12eb3168c7aa17478e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234728,"upload-time":"2019-04-26T02:43:23.354778Z","url":"https://files.pythonhosted.org/packages/62/b0/54effe77128bdd8b62ca10edf38c22dbe5594ad8b34ce31836011949ac0a/psutil-5.6.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp37-cp37m-win32.whl","hashes":{"sha256":"649f7ffc02114dced8fbd08afcd021af75f5f5b2311bc0e69e53e8f100fe296f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230750,"upload-time":"2019-04-26T02:43:26.831308Z","url":"https://files.pythonhosted.org/packages/86/90/ea3d046bb26aebcbf25fba32cf9ec7d0954ea6b8e4e9d9c87a31633dd96b/psutil-5.6.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"data-dist-info-metadata":{"sha256":"11c017c8a57096625072309b7badf4a1f677690026dbfc728de5f3dfd4ae2936"},"filename":"psutil-5.6.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"6ebf2b9c996bb8c7198b385bade468ac8068ad8b78c54a58ff288cd5f61992c7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234731,"upload-time":"2019-04-26T02:43:30.698781Z","url":"https://files.pythonhosted.org/packages/98/3c/65f28f78848730c18dfa3ff3a107e3911b6d51d1442cfce8db53356179c3/psutil-5.6.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.2.tar.gz","hashes":{"sha256":"828e1c3ca6756c54ac00f1427fdac8b12e21b8a068c3bb9b631a1734cada25ed"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":432907,"upload-time":"2019-04-26T02:43:34.455685Z","url":"https://files.pythonhosted.org/packages/c6/c1/beed5e4eaa1345901b595048fab1c85aee647ea0fc02d9e8bf9aceb81078/psutil-5.6.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"data-dist-info-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"filename":"psutil-5.6.3-cp27-none-win32.whl","hashes":{"sha256":"d5350cb66690915d60f8b233180f1e49938756fb2d501c93c44f8fb5b970cc63"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":226847,"upload-time":"2019-06-11T04:24:07.412816Z","url":"https://files.pythonhosted.org/packages/da/76/7e445566f2c4363691a98f16df0072c6ba92c7c29b4410ef2df6514c9861/psutil-5.6.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"data-dist-info-metadata":{"sha256":"b5acb81452f4830e88ff6014732a59e7fc4839457f7950deab90c8eed0d4e6b8"},"filename":"psutil-5.6.3-cp27-none-win_amd64.whl","hashes":{"sha256":"b6e08f965a305cd84c2d07409bc16fbef4417d67b70c53b299116c5b895e3f45"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230406,"upload-time":"2019-06-11T04:24:10.852056Z","url":"https://files.pythonhosted.org/packages/72/75/43047d7df3ea2af2bcd072e63420b8fa240b729c052295f8c4b964335d36/psutil-5.6.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp35-cp35m-win32.whl","hashes":{"sha256":"cf49178021075d47c61c03c0229ac0c60d5e2830f8cab19e2d88e579b18cdb76"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230912,"upload-time":"2019-06-11T04:24:14.533883Z","url":"https://files.pythonhosted.org/packages/c2/f2/d99eaeefb2c0b1f7f9aca679db17f4072d4cc362f40f809157d4e2d273dd/psutil-5.6.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"bc96d437dfbb8865fc8828cf363450001cb04056bbdcdd6fc152c436c8a74c61"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234942,"upload-time":"2019-06-11T04:24:18.128893Z","url":"https://files.pythonhosted.org/packages/90/86/d5ae0eb79cab6acc00d3640a45243e3e0602dc2f7abca29fc2fe6b4819ca/psutil-5.6.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp36-cp36m-win32.whl","hashes":{"sha256":"eba238cf1989dfff7d483c029acb0ac4fcbfc15de295d682901f0e2497e6781a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230914,"upload-time":"2019-06-11T04:24:21.735106Z","url":"https://files.pythonhosted.org/packages/28/0c/e41fd3020662487cf92f0c47b09285d7e53c42ee56cdc3ddb03a147cfa5d/psutil-5.6.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"954f782608bfef9ae9f78e660e065bd8ffcfaea780f9f2c8a133bb7cb9e826d7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234945,"upload-time":"2019-06-11T04:24:26.649579Z","url":"https://files.pythonhosted.org/packages/86/91/f15a3aae2af13f008ed95e02292d1a2e84615ff42b7203357c1c0bbe0651/psutil-5.6.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp37-cp37m-win32.whl","hashes":{"sha256":"503e4b20fa9d3342bcf58191bbc20a4a5ef79ca7df8972e6197cc14c5513e73d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230914,"upload-time":"2019-06-11T04:24:30.881936Z","url":"https://files.pythonhosted.org/packages/3b/92/2a7fb18054ac12483fb72f281c285d21642ca3d29fc6a06f0e44d4b36d83/psutil-5.6.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"data-dist-info-metadata":{"sha256":"2df22107b0d2ddaa4d080521f6dd4f4139500bf928eeee6cbbfd64b2abb197fb"},"filename":"psutil-5.6.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"028a1ec3c6197eadd11e7b46e8cc2f0720dc18ac6d7aabdb8e8c0d6c9704f000"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234949,"upload-time":"2019-06-11T04:24:34.722512Z","url":"https://files.pythonhosted.org/packages/7c/58/f5d68ddca37480d8557b8566a20bf6108d7e1c6c9b9208ee0786e0cd012b/psutil-5.6.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"991ea9c126c59fb12521c83a1676786ad9a7ea2af4f3985b1e8086af3eda4156"},"data-dist-info-metadata":{"sha256":"991ea9c126c59fb12521c83a1676786ad9a7ea2af4f3985b1e8086af3eda4156"},"filename":"psutil-5.6.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"12542c3642909f4cd1928a2fba59e16fa27e47cbeea60928ebb62a8cbd1ce123"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238041,"upload-time":"2019-10-24T10:11:31.818649Z","url":"https://files.pythonhosted.org/packages/a7/7f/0761489b5467af4e97ae3c5a25f24f8662d69a25692d85490c8ea5d52e45/psutil-5.6.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.3.tar.gz","hashes":{"sha256":"863a85c1c0a5103a12c05a35e59d336e1d665747e531256e061213e2e90f63f3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":435374,"upload-time":"2019-06-11T04:24:39.293855Z","url":"https://files.pythonhosted.org/packages/1c/ca/5b8c1fe032a458c2c4bcbe509d1401dca9dda35c7fc46b36bb81c2834740/psutil-5.6.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"data-dist-info-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"filename":"psutil-5.6.4-cp27-none-win32.whl","hashes":{"sha256":"75d50d1138b2476a11dca33ab1ad2b78707d428418b581966ccedac768358f72"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228290,"upload-time":"2019-11-04T08:38:28.711265Z","url":"https://files.pythonhosted.org/packages/8a/63/0273163f0197ff2d8f026ae0f9c7cac371f8819f6451e6cfd2e1e7132b90/psutil-5.6.4-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"data-dist-info-metadata":{"sha256":"2625785be98a15c8fa27587a95cae17a6673efa1e3bc2154856b9af05aaac32a"},"filename":"psutil-5.6.4-cp27-none-win_amd64.whl","hashes":{"sha256":"0ff1f630ee0df7c048ef53e50196437d2c9cebab8ccca0e3078d9300c4b7da47"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231797,"upload-time":"2019-11-04T08:38:33.155488Z","url":"https://files.pythonhosted.org/packages/db/d0/17a47a1876cf408d0dd679f78ba18a206228fdb95928137dd85538a51298/psutil-5.6.4-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp35-cp35m-win32.whl","hashes":{"sha256":"10175ea15b7e4a1bf1a0863da7e17042862b3ea3e7d24285c96fa4cc65ab9788"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232325,"upload-time":"2019-11-04T08:38:37.308918Z","url":"https://files.pythonhosted.org/packages/cb/22/e2ce6539342fb0ebd65fb9e2a0a168585eb5cae9bd5dca7977735f8d430e/psutil-5.6.4-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"f6b66a5663700b71bac3d8ecf6533a1550a679823e63b2c92dc4c3c8c244c52e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236342,"upload-time":"2019-11-04T08:38:41.583480Z","url":"https://files.pythonhosted.org/packages/32/9a/beaf5df1f8b38d3ec7ec737f873515813586aa26926738896957c3af0a9d/psutil-5.6.4-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp36-cp36m-win32.whl","hashes":{"sha256":"4f637dd25d3bce4879d0b4032d13f4120ba18ed2d028e85d911d429f447c251c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232330,"upload-time":"2019-11-04T08:38:46.049782Z","url":"https://files.pythonhosted.org/packages/74/3c/61d46eccf9fca27fc11f30d27af11c3886609d5eb52475926a1ad12d6ebd/psutil-5.6.4-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"43f0d7536a98c20a538242ce2bd8c64dbc1f6c396e97f2bdceb496d7583b9b80"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236347,"upload-time":"2019-11-04T08:38:50.265170Z","url":"https://files.pythonhosted.org/packages/2c/59/beae1392ad5188b419709d3e04641cbe93e36184b7b8686af825a2232b2b/psutil-5.6.4-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp37-cp37m-win32.whl","hashes":{"sha256":"f0ec1a3ea56503f4facc1dca364cf3dd66dc39169c4603000d3d34270e05fbb3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-04T08:38:54.615037Z","url":"https://files.pythonhosted.org/packages/e6/2e/e0c14d0fa46afb15b1467daa792f143e675034f8c544d03a2b7365d4926c/psutil-5.6.4-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"512e77ac987105e2d7aa2386d9f260434ad8b71e41484f8d84bfecd4ae3764ca"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236347,"upload-time":"2019-11-04T08:38:58.188759Z","url":"https://files.pythonhosted.org/packages/a3/59/fe32a3ec677990a5ed6b1a44dc2e372c9ee40693890814e8b6d96c290c4d/psutil-5.6.4-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp38-cp38-win32.whl","hashes":{"sha256":"41d645f100c6b4c995ff342ef7d79a936f3f48e9a816d7d655c69b352460341d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234629,"upload-time":"2019-11-04T08:46:40.809419Z","url":"https://files.pythonhosted.org/packages/50/0c/7b2fa0baedd36147beb820f662844b1079e168c06e9fe62d78a4d2666375/psutil-5.6.4-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"data-dist-info-metadata":{"sha256":"f16d89990a0e49264d1393eb1ee021563470e55f511d8518008f85c41d8ff3b0"},"filename":"psutil-5.6.4-cp38-cp38-win_amd64.whl","hashes":{"sha256":"fb58e87c29ec0fb99937b95c5d473bb786d263aaa767d017a6bd4ad52d694e79"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239057,"upload-time":"2019-11-04T08:46:45.192939Z","url":"https://files.pythonhosted.org/packages/e3/28/fa3a597ed798a5a2cb9c9e53c2d8b6bc1310c4a147c2aaa65c5d3afdb6ed/psutil-5.6.4-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.4.tar.gz","hashes":{"sha256":"512e854d68f8b42f79b2c7864d997b39125baff9bcff00028ce43543867de7c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447564,"upload-time":"2019-11-04T08:39:02.419203Z","url":"https://files.pythonhosted.org/packages/47/ea/d3b6d6fd0b4a6c12984df652525f394e68c8678d2b05075219144eb3a1cf/psutil-5.6.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"data-dist-info-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"filename":"psutil-5.6.5-cp27-none-win32.whl","hashes":{"sha256":"145e0f3ab9138165f9e156c307100905fd5d9b7227504b8a9d3417351052dc3d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228289,"upload-time":"2019-11-06T10:07:27.672551Z","url":"https://files.pythonhosted.org/packages/97/52/9a44db00d4400814384d574f3a2c2b588259c212e457f542c2589dbdac58/psutil-5.6.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"data-dist-info-metadata":{"sha256":"3ccf04696d9a6c2c81c586788345860eb9fc45feada6313ab8d40865c7a9ec78"},"filename":"psutil-5.6.5-cp27-none-win_amd64.whl","hashes":{"sha256":"3feea46fbd634a93437b718518d15b5dd49599dfb59a30c739e201cc79bb759d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231796,"upload-time":"2019-11-06T10:07:31.973662Z","url":"https://files.pythonhosted.org/packages/c4/35/4422a966d304faa401d55dc45caf342722a14c0a9b56d57ecf208f9bb6a3/psutil-5.6.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp35-cp35m-win32.whl","hashes":{"sha256":"348ad4179938c965a27d29cbda4a81a1b2c778ecd330a221aadc7bd33681afbd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232325,"upload-time":"2019-11-06T10:07:36.463607Z","url":"https://files.pythonhosted.org/packages/4c/2f/93ac7f065f8c4c361e422dffff21dea1803cb40f2449e6ea52800caddf9f/psutil-5.6.5-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"474e10a92eeb4100c276d4cc67687adeb9d280bbca01031a3e41fb35dfc1d131"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236340,"upload-time":"2019-11-06T10:07:41.723247Z","url":"https://files.pythonhosted.org/packages/9f/49/fddf3b6138a5d47668e2daf98ac9a6eeea4c28e3eb68b56580f18e8fe6af/psutil-5.6.5-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp36-cp36m-win32.whl","hashes":{"sha256":"e3f5f9278867e95970854e92d0f5fe53af742a7fc4f2eba986943345bcaed05d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-06T10:07:45.647021Z","url":"https://files.pythonhosted.org/packages/ae/5d/11bb7fb7cc004bdf1325c0b40827e67e479ababe47c553ee871494353acf/psutil-5.6.5-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"dfb8c5c78579c226841908b539c2374da54da648ee5a837a731aa6a105a54c00"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236344,"upload-time":"2019-11-06T10:07:49.683064Z","url":"https://files.pythonhosted.org/packages/c6/18/221e8a5084585c6a2550894fb0617dc4691b5216f4aa6bb82c330aa5d99c/psutil-5.6.5-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp37-cp37m-win32.whl","hashes":{"sha256":"021d361439586a0fd8e64f8392eb7da27135db980f249329f1a347b9de99c695"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232327,"upload-time":"2019-11-06T10:07:53.427002Z","url":"https://files.pythonhosted.org/packages/31/f8/d612f18fed1422a016bb641d3ce1922904a2aa0cc3472ce4abf2716cf542/psutil-5.6.5-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"e9649bb8fc5cea1f7723af53e4212056a6f984ee31784c10632607f472dec5ee"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236346,"upload-time":"2019-11-06T10:07:57.218779Z","url":"https://files.pythonhosted.org/packages/97/c7/9b18c3b429c987796d74647c61030c7029518ac223d1a664951417781fe4/psutil-5.6.5-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp38-cp38-win32.whl","hashes":{"sha256":"47aeb4280e80f27878caae4b572b29f0ec7967554b701ba33cd3720b17ba1b07"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234627,"upload-time":"2019-11-06T10:08:50.811061Z","url":"https://files.pythonhosted.org/packages/03/94/e4ee514cfbc4cca176fcc6b4b1118a724848b570941e90f0b98a9bd234e1/psutil-5.6.5-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"data-dist-info-metadata":{"sha256":"98b3da0b296c70a30e4e371a72ba5d3205dc455f09fe824464a824ad9b4fd6ad"},"filename":"psutil-5.6.5-cp38-cp38-win_amd64.whl","hashes":{"sha256":"73a7e002781bc42fd014dfebb3fc0e45f8d92a4fb9da18baea6fb279fbc1d966"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239056,"upload-time":"2019-11-06T10:08:55.334494Z","url":"https://files.pythonhosted.org/packages/cd/3b/de8a1f1692de2f16716a108a63366aa66692e5a087b6e0458eef9739e652/psutil-5.6.5-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.5.tar.gz","hashes":{"sha256":"d051532ac944f1be0179e0506f6889833cf96e466262523e57a871de65a15147"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447489,"upload-time":"2019-11-06T10:08:01.639000Z","url":"https://files.pythonhosted.org/packages/03/9a/95c4b3d0424426e5fd94b5302ff74cea44d5d4f53466e1228ac8e73e14b4/psutil-5.6.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"data-dist-info-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"filename":"psutil-5.6.6-cp27-none-win32.whl","hashes":{"sha256":"06660136ab88762309775fd47290d7da14094422d915f0466e0adf8e4b22214e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228564,"upload-time":"2019-11-25T12:30:48.823010Z","url":"https://files.pythonhosted.org/packages/c9/c2/4d703fcb5aacd4cb8d472d3c1d0e7d8c21e17f37b515016a7ee34ff3f4a0/psutil-5.6.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"data-dist-info-metadata":{"sha256":"0ee5221d5d9af774f9490843a768567a29b9f7ace20754cf0822d80eb298fdd1"},"filename":"psutil-5.6.6-cp27-none-win_amd64.whl","hashes":{"sha256":"f21a7bb4b207e4e7c60b3c40ffa89d790997619f04bbecec9db8e3696122bc78"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232093,"upload-time":"2019-11-25T12:30:53.306595Z","url":"https://files.pythonhosted.org/packages/76/4d/6452c4791f9d95b48cca084b7cc6aa8a72b2f4c8d3d8bd38e7f3abfaf364/psutil-5.6.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp35-cp35m-win32.whl","hashes":{"sha256":"5e8dbf31871b0072bcba8d1f2861c0ec6c84c78f13c723bb6e981bce51b58f12"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232818,"upload-time":"2019-11-25T12:30:58.414546Z","url":"https://files.pythonhosted.org/packages/f3/b3/e585b9b0c5a40e6a778e32e8d3040ab2363433990417202bf6cc0261ed77/psutil-5.6.6-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"724390895cff80add7a1c4e7e0a04d9c94f3ee61423a2dcafd83784fabbd1ee9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236751,"upload-time":"2019-11-25T12:31:03.059024Z","url":"https://files.pythonhosted.org/packages/73/38/a8ebf6dc6ada2257591284be45a52dcd19479163b8d3575186333a79a18e/psutil-5.6.6-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp36-cp36m-win32.whl","hashes":{"sha256":"6d81b9714791ef9a3a00b2ca846ee547fc5e53d259e2a6258c3d2054928039ff"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232821,"upload-time":"2019-11-25T12:31:08.161481Z","url":"https://files.pythonhosted.org/packages/5b/04/2223b4fe61d3e5962c08ce5062b09633fcfdd8c3bb08c31b76306f748431/psutil-5.6.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"3004361c6b93dbad71330d992c1ae409cb8314a6041a0b67507cc882357f583e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236759,"upload-time":"2019-11-25T12:31:13.077581Z","url":"https://files.pythonhosted.org/packages/33/6c/6eb959bca82064d42e725dddd3aeeb39d9bed34eed7b513880bcfd8a3d59/psutil-5.6.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp37-cp37m-win32.whl","hashes":{"sha256":"0fc7a5619b47f74331add476fbc6022d7ca801c22865c7069ec0867920858963"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232820,"upload-time":"2019-11-25T12:31:17.411233Z","url":"https://files.pythonhosted.org/packages/76/46/3a8dc20eb9d7d2c44178e71c2412dcc2c6476ab71c05a2cf2f77247c6e53/psutil-5.6.6-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"f60042bef7dc50a78c06334ca8e25580455948ba2fa98f240d034a4fed9141a5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236757,"upload-time":"2019-11-25T12:31:21.816790Z","url":"https://files.pythonhosted.org/packages/40/48/5debf9783077ac71f0d715c1171fde9ef287909f61672ed9a3e5fdca63cc/psutil-5.6.6-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp38-cp38-win32.whl","hashes":{"sha256":"0c11adde31011a286197630ba2671e34651f004cc418d30ae06d2033a43c9e20"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233147,"upload-time":"2019-11-25T12:31:26.294340Z","url":"https://files.pythonhosted.org/packages/c6/10/035c432a15bec90d51f3625d4b70b7d12f1b363062d0d8815213229f69ca/psutil-5.6.6-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"data-dist-info-metadata":{"sha256":"29b50729d8b20274ad25b9f22deb812c81cdc56e61cba32bbf7c5423b9c1ef5d"},"filename":"psutil-5.6.6-cp38-cp38-win_amd64.whl","hashes":{"sha256":"0c211eec4185725847cb6c28409646c7cfa56fdb531014b35f97b5dc7fe04ff9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":237165,"upload-time":"2019-11-25T12:31:30.835876Z","url":"https://files.pythonhosted.org/packages/95/81/fb02ea8de73eca26cfa347f5ce81a7963b9dee6e038e0a7389ccbc971093/psutil-5.6.6-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.6.tar.gz","hashes":{"sha256":"ad21281f7bd6c57578dd53913d2d44218e9e29fd25128d10ff7819ef16fa46e7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":447805,"upload-time":"2019-11-25T12:31:36.347718Z","url":"https://files.pythonhosted.org/packages/5f/dc/edf6758183afc7591a16bd4b8a44d8eea80aca1327ea60161dd3bad9ad22/psutil-5.6.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"data-dist-info-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"filename":"psutil-5.6.7-cp27-none-win32.whl","hashes":{"sha256":"1b1575240ca9a90b437e5a40db662acd87bbf181f6aa02f0204978737b913c6b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":228449,"upload-time":"2019-11-26T07:25:43.864472Z","url":"https://files.pythonhosted.org/packages/13/a7/626f257d22168c954fd3ad69760c02bdec27c0648a62f6ea5060c4d40672/psutil-5.6.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"data-dist-info-metadata":{"sha256":"943b5895bc5955d1ab23e61bd0a4a6c4a4be1be625fd6bb204033b5d93574bf6"},"filename":"psutil-5.6.7-cp27-none-win_amd64.whl","hashes":{"sha256":"28f771129bfee9fc6b63d83a15d857663bbdcae3828e1cb926e91320a9b5b5cd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231969,"upload-time":"2019-11-26T07:25:50.426501Z","url":"https://files.pythonhosted.org/packages/52/44/e1e1954da522ea8640e035c8b101c116a9f8a0e94e04e108e56911064de5/psutil-5.6.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp35-cp35m-win32.whl","hashes":{"sha256":"21231ef1c1a89728e29b98a885b8e0a8e00d09018f6da5cdc1f43f988471a995"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232644,"upload-time":"2019-11-26T07:25:56.230501Z","url":"https://files.pythonhosted.org/packages/d8/39/bf74da6282d9521fe3987b2d67f581b3464e635e6cb56660d0315d1bf1ed/psutil-5.6.7-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"b74b43fecce384a57094a83d2778cdfc2e2d9a6afaadd1ebecb2e75e0d34e10d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236538,"upload-time":"2019-11-26T07:26:01.396655Z","url":"https://files.pythonhosted.org/packages/b3/84/0a899c6fac13aedfb4734413a2357a504c4f21cbf8acd7ad4caa6712d8cf/psutil-5.6.7-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp36-cp36m-win32.whl","hashes":{"sha256":"e85f727ffb21539849e6012f47b12f6dd4c44965e56591d8dec6e8bc9ab96f4a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232649,"upload-time":"2019-11-26T07:26:06.727306Z","url":"https://files.pythonhosted.org/packages/7c/d7/be2b607abfab4a98f04dd2155d6a7a40a666618d69c079897f09ce776a34/psutil-5.6.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"b560f5cd86cf8df7bcd258a851ca1ad98f0d5b8b98748e877a0aec4e9032b465"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236541,"upload-time":"2019-11-26T07:26:11.229459Z","url":"https://files.pythonhosted.org/packages/78/e6/ce8a91afd605f254342f1294790f2a77c76202386d6927eb5ff0e36e4449/psutil-5.6.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp37-cp37m-win32.whl","hashes":{"sha256":"094f899ac3ef72422b7e00411b4ed174e3c5a2e04c267db6643937ddba67a05b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232645,"upload-time":"2019-11-26T07:26:15.814275Z","url":"https://files.pythonhosted.org/packages/c4/e1/80c7840db569ad5b1b60987893e066a5536779c0d2402363cbf1230613a2/psutil-5.6.7-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"fd2e09bb593ad9bdd7429e779699d2d47c1268cbde4dda95fcd1bd17544a0217"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236539,"upload-time":"2019-11-26T07:26:20.217732Z","url":"https://files.pythonhosted.org/packages/9d/84/0a2006cc263e9f5b6dfbb2301fbcce5558f0d6d17d0c11c7c6749a45c79e/psutil-5.6.7-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp38-cp38-win32.whl","hashes":{"sha256":"70387772f84fa5c3bb6a106915a2445e20ac8f9821c5914d7cbde148f4d7ff73"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232983,"upload-time":"2019-11-26T07:26:24.615122Z","url":"https://files.pythonhosted.org/packages/55/9d/9a6df5f730a1e2a3938fad0ccf541b30fad34706128b43ed3f965eaf7550/psutil-5.6.7-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"data-dist-info-metadata":{"sha256":"15f7352602bc6ef07ec1f8cc5816d4cee0171e750a5d38106a7277f703882211"},"filename":"psutil-5.6.7-cp38-cp38-win_amd64.whl","hashes":{"sha256":"10b7f75cc8bd676cfc6fa40cd7d5c25b3f45a0e06d43becd7c2d2871cbb5e806"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236965,"upload-time":"2019-11-26T07:26:28.827408Z","url":"https://files.pythonhosted.org/packages/8a/fa/b573850e912d6ffdad4aef3f5f705f94a64d098a83eec15d1cd3e1223f5e/psutil-5.6.7-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.6.7.tar.gz","hashes":{"sha256":"ffad8eb2ac614518bbe3c0b8eb9dffdb3a8d2e3a7d5da51c5b974fb723a5c5aa"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":448321,"upload-time":"2019-11-26T07:26:34.515073Z","url":"https://files.pythonhosted.org/packages/73/93/4f8213fbe66fc20cb904f35e6e04e20b47b85bee39845cc66a0bcf5ccdcb/psutil-5.6.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"data-dist-info-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"filename":"psutil-5.7.0-cp27-none-win32.whl","hashes":{"sha256":"298af2f14b635c3c7118fd9183843f4e73e681bb6f01e12284d4d70d48a60953"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":227641,"upload-time":"2020-02-18T18:02:31.085536Z","url":"https://files.pythonhosted.org/packages/0b/6b/f613593812c5f379c6d609bf5eca36a409812f508e13c704acd25712a73e/psutil-5.7.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"data-dist-info-metadata":{"sha256":"4665f6ffe5781ebc50d69efc5363ace07e50d1916f179a1cd2e51352df7eb11a"},"filename":"psutil-5.7.0-cp27-none-win_amd64.whl","hashes":{"sha256":"75e22717d4dbc7ca529ec5063000b2b294fc9a367f9c9ede1f65846c7955fd38"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":230741,"upload-time":"2020-02-18T18:02:35.453910Z","url":"https://files.pythonhosted.org/packages/79/b1/377fa0f28630d855cb6b5bfb2ee4c1bf0df3bc2603c691ceefce59a95181/psutil-5.7.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp35-cp35m-win32.whl","hashes":{"sha256":"f344ca230dd8e8d5eee16827596f1c22ec0876127c28e800d7ae20ed44c4b310"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231151,"upload-time":"2020-02-18T18:02:39.410543Z","url":"https://files.pythonhosted.org/packages/74/e6/4a0ef10b1a4ca43954cd8fd9eac02cc8606f9d2a5a66859a283f5f95452b/psutil-5.7.0-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"e2d0c5b07c6fe5a87fa27b7855017edb0d52ee73b71e6ee368fae268605cc3f5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235435,"upload-time":"2020-02-18T18:02:43.014979Z","url":"https://files.pythonhosted.org/packages/65/c2/0aeb9f0cc7e4be2807aa052b3fd017e59439ed6d830b461f8ecb35b2f367/psutil-5.7.0-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp36-cp36m-win32.whl","hashes":{"sha256":"a02f4ac50d4a23253b68233b07e7cdb567bd025b982d5cf0ee78296990c22d9e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231156,"upload-time":"2020-02-18T18:02:46.432233Z","url":"https://files.pythonhosted.org/packages/c9/37/b94930ae428b2d67d505aecc5ba84c53a0b75479a8a87cd35cc9a2c6eb7e/psutil-5.7.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1413f4158eb50e110777c4f15d7c759521703bd6beb58926f1d562da40180058"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235439,"upload-time":"2020-02-18T18:02:49.890797Z","url":"https://files.pythonhosted.org/packages/4f/3c/205850b172a14a8b9fdc9b1e84a2c055d6b9aea226431da7685bea644f04/psutil-5.7.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp37-cp37m-win32.whl","hashes":{"sha256":"d008ddc00c6906ec80040d26dc2d3e3962109e40ad07fd8a12d0284ce5e0e4f8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231153,"upload-time":"2020-02-18T18:02:53.653943Z","url":"https://files.pythonhosted.org/packages/54/25/7825fefd62635f7ca556c8e0d44369ce4674aa2ca0eca50b8ae4ff49954b/psutil-5.7.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"73f35ab66c6c7a9ce82ba44b1e9b1050be2a80cd4dcc3352cc108656b115c74f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235439,"upload-time":"2020-02-18T18:02:57.139440Z","url":"https://files.pythonhosted.org/packages/86/f7/385040b90dd190edc28908c4a26af99b00ae37564ee5f5c4526dc1d80c27/psutil-5.7.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp38-cp38-win32.whl","hashes":{"sha256":"60b86f327c198561f101a92be1995f9ae0399736b6eced8f24af41ec64fb88d4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":231789,"upload-time":"2020-02-18T18:03:00.808478Z","url":"https://files.pythonhosted.org/packages/63/d5/f34a9433a0299d944605fb5a970306a89e076f5412164179dc59ebf70fa9/psutil-5.7.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"data-dist-info-metadata":{"sha256":"9743d37444bb906e26ad0d76922bd72314c8385e19a68cb8a763a3e70859b867"},"filename":"psutil-5.7.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"d84029b190c8a66a946e28b4d3934d2ca1528ec94764b180f7d6ea57b0e75e26"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235952,"upload-time":"2020-02-18T18:03:04.130414Z","url":"https://files.pythonhosted.org/packages/86/fe/9f1d1f8c1c8138d42fc0e7c06ca5004e01f38e86e61342374d8e0fa919e4/psutil-5.7.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.0.tar.gz","hashes":{"sha256":"685ec16ca14d079455892f25bd124df26ff9137664af445563c1bd36629b5e0e"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":449628,"upload-time":"2020-02-18T18:03:07.566242Z","url":"https://files.pythonhosted.org/packages/c4/b8/3512f0e93e0db23a71d82485ba256071ebef99b227351f0f5540f744af41/psutil-5.7.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"2dfb7b5638ffaa33602a86b39cca60cded2324dabbe2617b1b5e65250e448769"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233646,"upload-time":"2020-07-15T11:14:11.635539Z","url":"https://files.pythonhosted.org/packages/79/e4/cbaa3ecc458c2dd8da64073de983473543b8b6ef4ca21159cea9069d53dd/psutil-5.7.1-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-macosx_10_9_x86_64.whl","hashes":{"sha256":"36c5e6882caf3d385c6c3a0d2f3b302b4cc337c808ea589d9a8c563b545beb8b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233862,"upload-time":"2020-07-15T11:14:27.607855Z","url":"https://files.pythonhosted.org/packages/4d/d9/48c3d16c1dfbbf528bd69254b5a604c9f6860f12169b1b73a5005723c6bf/psutil-5.7.1-cp35-cp35m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-win32.whl","hashes":{"sha256":"3c5ffd00bc1ee809350dca97613985d387a7e13dff61d62fc1bdf4dc10892ddd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238370,"upload-time":"2020-07-15T11:14:34.746888Z","url":"https://files.pythonhosted.org/packages/d0/e2/d4cdadda6a9fba79026ab628fc2b4da5e2e48dcfc6beada0a39363732ba1/psutil-5.7.1-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"4975c33aebe7de191d745ee3c545e907edd14d65c850a0b185c05024aa77cbcd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242862,"upload-time":"2020-07-15T11:14:37.084757Z","url":"https://files.pythonhosted.org/packages/a0/6b/cdb41805a6bb62c051cfbb1b65a9cb40767e0144b3d40fdd7082d8271701/psutil-5.7.1-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"436a6e99098eba14b54a149f921c9d4e1df729f02645876af0c828396d36c46a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233861,"upload-time":"2020-07-15T11:14:39.242780Z","url":"https://files.pythonhosted.org/packages/1f/fb/097aeed40c361225cb69d6d04202421f2c172d7e42753130d1b619f68956/psutil-5.7.1-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-win32.whl","hashes":{"sha256":"630ceda48c16b24ffd981fe06ae1a43684af1a3a837d6a3496a1be3dd3c7d332"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238378,"upload-time":"2020-07-15T11:14:45.606142Z","url":"https://files.pythonhosted.org/packages/ae/49/cba9353fd9946eac95031c85763daaf7904d3c3e8b0b4f2801199586b413/psutil-5.7.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d3bb7f65199595a72a3ec53e4d05c159857ab832fadaae9d85e68db467d2d191"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242864,"upload-time":"2020-07-15T11:14:47.861971Z","url":"https://files.pythonhosted.org/packages/7b/38/f27fc6a30f81be1ee657bd4c355c2dc03a5fbb49f304a37c79c0bed05821/psutil-5.7.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"66d085317599684f70d995dd4a770894f518fb34d027d7f742b579bf47732858"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":233863,"upload-time":"2020-07-15T11:14:49.991128Z","url":"https://files.pythonhosted.org/packages/23/cb/410a516385c8cd69f090f98c8014636c51d124c96e4d6ab51e1bb2d04232/psutil-5.7.1-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-win32.whl","hashes":{"sha256":"fb442b912fe28d80e0f966adcc3df4e394fbb7ef7575ae21fd171aeb06c8b0df"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238369,"upload-time":"2020-07-15T11:14:57.383010Z","url":"https://files.pythonhosted.org/packages/59/44/e9cfa470dd2790b5475ceb590949842a5f2feb52445e898576b721033f04/psutil-5.7.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"425d6c95ca3ece7ff4da7e67af2954b8eb56b0f15743b237dc84ad975f51c2a4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242865,"upload-time":"2020-07-15T11:14:59.839217Z","url":"https://files.pythonhosted.org/packages/06/76/b4607e0eaf36369ad86f7ac73bde19aeaf32c82fb22675cb8f8dd975c692/psutil-5.7.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"f2817a763c33c19fdefbb832c790bc85b3de90b51fb69dae43097a9885be0332"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234129,"upload-time":"2020-07-15T11:15:01.982258Z","url":"https://files.pythonhosted.org/packages/ba/f7/64bf7fd7a12a40c50408b7d90cdf3addc28071e5463af1dbb7f3884a32d2/psutil-5.7.1-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-win32.whl","hashes":{"sha256":"3cf43d2265ee03fcf70f0f574487ed19435c92a330e15a3e773144811c1275f0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239004,"upload-time":"2020-07-15T11:15:08.125783Z","url":"https://files.pythonhosted.org/packages/7e/64/c3bd24d53f6056ded095e8d147c0ca269bb6d858aea903561bd660d67035/psutil-5.7.1-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"data-dist-info-metadata":{"sha256":"5cfd93088b3a9182d5543595d138ec1f3a9f0fee62e4e1dcbc3332900a0871ea"},"filename":"psutil-5.7.1-cp38-cp38-win_amd64.whl","hashes":{"sha256":"006b720a67881037c8b02b1de012a39a2f007bd2b1b244b58fabef8eff0ad6d2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243418,"upload-time":"2020-07-15T11:15:10.044651Z","url":"https://files.pythonhosted.org/packages/ff/5a/1e990cf86f47721225143ed4a903a226685fa1ba0b43500f52d71500b1be/psutil-5.7.1-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"621e2f3b573aa563717ee39c3f052b4cd3cda5e1f25e5973fa77e727433c6ce1"},"data-dist-info-metadata":{"sha256":"621e2f3b573aa563717ee39c3f052b4cd3cda5e1f25e5973fa77e727433c6ce1"},"filename":"psutil-5.7.1-pp27-pypy_73-macosx_10_9_x86_64.whl","hashes":{"sha256":"0c9187ec0c314a128362c3409afea2b80c6d6d2c2cb1d661fe20631a2ff8ad77"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":232076,"upload-time":"2020-07-15T11:15:12.408818Z","url":"https://files.pythonhosted.org/packages/80/fd/d91ff7582513d093097678eedd141a4879698da26e6163fbae16905aa75b/psutil-5.7.1-pp27-pypy_73-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.1.tar.gz","hashes":{"sha256":"4ef6845b35e152e6937d4f28388c2440ca89a0089ced0a30a116fa3ceefdfa3a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":460148,"upload-time":"2020-07-15T11:15:21.985314Z","url":"https://files.pythonhosted.org/packages/2c/5c/cb95a715fb635e1ca858ffb8c50a523a16e2dc06aa3e207ab73cb93516af/psutil-5.7.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"data-dist-info-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"filename":"psutil-5.7.2-cp27-none-win32.whl","hashes":{"sha256":"f2018461733b23f308c298653c8903d32aaad7873d25e1d228765e91ae42c3f2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":234782,"upload-time":"2020-07-15T13:19:05.321836Z","url":"https://files.pythonhosted.org/packages/d0/da/d7da0365f690e7555f6dda34bcb5bde10266379c9a23ee6a0735c3a7fdfd/psutil-5.7.2-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"data-dist-info-metadata":{"sha256":"91f2a99bfe758ed3b22b8fc235d7bfa5b885bb5cdd7bd1a38cccff1e9756d183"},"filename":"psutil-5.7.2-cp27-none-win_amd64.whl","hashes":{"sha256":"66c18ca7680a31bf16ee22b1d21b6397869dda8059dbdb57d9f27efa6615f195"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238050,"upload-time":"2020-07-15T13:19:07.922423Z","url":"https://files.pythonhosted.org/packages/7d/9d/30a053a06d598cee4bdbc6ba69df44ced9e6d2ebb16e2de401a2a3bc6d63/psutil-5.7.2-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp35-cp35m-win32.whl","hashes":{"sha256":"5e9d0f26d4194479a13d5f4b3798260c20cecf9ac9a461e718eb59ea520a360c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238373,"upload-time":"2020-07-15T13:19:10.146779Z","url":"https://files.pythonhosted.org/packages/df/27/e5cf14b0894b4f06c23dc4f58288c60b17e71d8bef9af463f0b32ee46773/psutil-5.7.2-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"4080869ed93cce662905b029a1770fe89c98787e543fa7347f075ade761b19d6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242862,"upload-time":"2020-07-15T13:19:12.906781Z","url":"https://files.pythonhosted.org/packages/0a/4c/d31d58992314664e69bda6d575c1fd47b86ed5d67e00e300fc909040a9aa/psutil-5.7.2-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp36-cp36m-win32.whl","hashes":{"sha256":"d8a82162f23c53b8525cf5f14a355f5d1eea86fa8edde27287dd3a98399e4fdf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238380,"upload-time":"2020-07-15T13:19:15.247084Z","url":"https://files.pythonhosted.org/packages/57/c5/0aa3b1513b914a417db7ee149b60579a139111f81f79f5f1d38ae440cebf/psutil-5.7.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"0ee3c36428f160d2d8fce3c583a0353e848abb7de9732c50cf3356dd49ad63f8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242866,"upload-time":"2020-07-15T13:19:17.782781Z","url":"https://files.pythonhosted.org/packages/22/f8/7be159475303a508347efc82c0d5858b1786fe73fc2a6b21d82891791920/psutil-5.7.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp37-cp37m-win32.whl","hashes":{"sha256":"ff1977ba1a5f71f89166d5145c3da1cea89a0fdb044075a12c720ee9123ec818"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238375,"upload-time":"2020-07-15T13:19:20.591814Z","url":"https://files.pythonhosted.org/packages/56/de/6f07749f275d0ba7f9b985cd6a4526e2fa47ad63b5179948c6650117f7d9/psutil-5.7.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"a5b120bb3c0c71dfe27551f9da2f3209a8257a178ed6c628a819037a8df487f1"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242863,"upload-time":"2020-07-15T13:19:23.022907Z","url":"https://files.pythonhosted.org/packages/f8/9b/1d7df5e1747e047abef4ec877d895b642f3a796ab8bd2e0f682516740dfe/psutil-5.7.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp38-cp38-win32.whl","hashes":{"sha256":"10512b46c95b02842c225f58fa00385c08fa00c68bac7da2d9a58ebe2c517498"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239003,"upload-time":"2020-07-15T13:19:25.770960Z","url":"https://files.pythonhosted.org/packages/da/d6/f66bbdbc8831a5cc78ba0e9bf69d924e68eac1a7b4191de93cf4e3643c54/psutil-5.7.2-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"data-dist-info-metadata":{"sha256":"4ece4267ea2940759bedb71b133199d6c5b33ccc17f4c3060d08d56f5697ca45"},"filename":"psutil-5.7.2-cp38-cp38-win_amd64.whl","hashes":{"sha256":"68d36986ded5dac7c2dcd42f2682af1db80d4bce3faa126a6145c1637e1b559f"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243419,"upload-time":"2020-07-15T13:19:28.240707Z","url":"https://files.pythonhosted.org/packages/6c/e6/f963547a36a96f74244cbe5e4046a02f140e3b7cbc5e5176035b38e2deb2/psutil-5.7.2-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.2.tar.gz","hashes":{"sha256":"90990af1c3c67195c44c9a889184f84f5b2320dce3ee3acbd054e3ba0b4a7beb"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":460198,"upload-time":"2020-07-15T13:19:30.438785Z","url":"https://files.pythonhosted.org/packages/aa/3e/d18f2c04cf2b528e18515999b0c8e698c136db78f62df34eee89cee205f1/psutil-5.7.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"data-dist-info-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"filename":"psutil-5.7.3-cp27-none-win32.whl","hashes":{"sha256":"1cd6a0c9fb35ece2ccf2d1dd733c1e165b342604c67454fd56a4c12e0a106787"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235225,"upload-time":"2020-10-24T14:00:54.139761Z","url":"https://files.pythonhosted.org/packages/1d/a2/b732590561ef9d7dbc078ed0e2635e282115604a478911fef97ddaa3ad43/psutil-5.7.3-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"data-dist-info-metadata":{"sha256":"6032661358cee4f792940fdac32ebc65bab2fa2463828785b8a8f0fb6c2c210b"},"filename":"psutil-5.7.3-cp27-none-win_amd64.whl","hashes":{"sha256":"e02c31b2990dcd2431f4524b93491941df39f99619b0d312dfe1d4d530b08b4b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238499,"upload-time":"2020-10-24T14:00:57.724543Z","url":"https://files.pythonhosted.org/packages/b4/4c/c14a9485957b00c20f70e208a03663e81ddc8dafdf5137fee2d50aa1ee5e/psutil-5.7.3-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp35-cp35m-win32.whl","hashes":{"sha256":"56c85120fa173a5d2ad1d15a0c6e0ae62b388bfb956bb036ac231fbdaf9e4c22"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238813,"upload-time":"2020-10-24T15:02:21.678008Z","url":"https://files.pythonhosted.org/packages/e0/ba/a7c1096470e11c449019690ee9e7fd3adca1a4b9cfa6e5a13b60db3187b4/psutil-5.7.3-cp35-cp35m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp35-cp35m-win_amd64.whl","hashes":{"sha256":"fa38ac15dbf161ab1e941ff4ce39abd64b53fec5ddf60c23290daed2bc7d1157"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243298,"upload-time":"2020-10-24T15:02:24.823245Z","url":"https://files.pythonhosted.org/packages/3f/7c/98aada1208462c841788712383f4288b3c31e45504570a818c0c303d78e7/psutil-5.7.3-cp35-cp35m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp36-cp36m-win32.whl","hashes":{"sha256":"01bc82813fbc3ea304914581954979e637bcc7084e59ac904d870d6eb8bb2bc7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238821,"upload-time":"2020-10-24T15:02:27.844759Z","url":"https://files.pythonhosted.org/packages/44/a8/ebfcbb4967e74a27049ea6e13b3027ae05c0cb73d1a2b71c2f0519c6d5f2/psutil-5.7.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"6a3e1fd2800ca45083d976b5478a2402dd62afdfb719b30ca46cd28bb25a2eb4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243300,"upload-time":"2020-10-24T15:02:31.552663Z","url":"https://files.pythonhosted.org/packages/9a/c3/3b0023b46fc038eff02fbb69a0e6e50d15a7dce25e717d8469e8eaa837a7/psutil-5.7.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp37-cp37m-win32.whl","hashes":{"sha256":"fbcac492cb082fa38d88587d75feb90785d05d7e12d4565cbf1ecc727aff71b7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238814,"upload-time":"2020-10-24T15:02:34.703606Z","url":"https://files.pythonhosted.org/packages/e1/f0/d4f58ddf077d970440b82b92e909e8e9b2f50e39a2dc2aa716b1e2fde5ef/psutil-5.7.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"5d9106ff5ec2712e2f659ebbd112967f44e7d33f40ba40530c485cc5904360b8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243302,"upload-time":"2020-10-24T15:02:38.016752Z","url":"https://files.pythonhosted.org/packages/f1/a0/094a6e32185bd1288a4681d91ebe362d5b41aa64413bbbd96ed547051f17/psutil-5.7.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp38-cp38-win32.whl","hashes":{"sha256":"ade6af32eb80a536eff162d799e31b7ef92ddcda707c27bbd077238065018df4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239426,"upload-time":"2020-10-24T15:02:41.250786Z","url":"https://files.pythonhosted.org/packages/bd/95/394485321a128f5ddb23f0a559f940309280f57bd6117580868fb2d5a246/psutil-5.7.3-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"data-dist-info-metadata":{"sha256":"9f3f41a734ced0a9775d53996e940b0d2411f0f5105b0cdcac5e8e3ffd8da0e9"},"filename":"psutil-5.7.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"2cb55ef9591b03ef0104bedf67cc4edb38a3edf015cf8cf24007b99cb8497542"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243849,"upload-time":"2020-10-24T15:02:44.162783Z","url":"https://files.pythonhosted.org/packages/df/64/8d7b55ac87e67398ffc260d43a5fb327f1e230b09758b7d8caaecf917dd6/psutil-5.7.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.7.3.tar.gz","hashes":{"sha256":"af73f7bcebdc538eda9cc81d19db1db7bf26f103f91081d780bbacfcb620dee2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":465556,"upload-time":"2020-10-24T14:02:15.604830Z","url":"https://files.pythonhosted.org/packages/33/e0/82d459af36bda999f82c7ea86c67610591cf5556168f48fd6509e5fa154d/psutil-5.7.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"0066a82f7b1b37d334e68697faba68e5ad5e858279fd6351c8ca6024e8d6ba64"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":235772,"upload-time":"2020-12-19T01:19:27.017908Z","url":"https://files.pythonhosted.org/packages/f5/7f/a2559a514bdeb2a33e4bf3dc3d2bb17d5acded718893869a82536130cfb3/psutil-5.8.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"0ae6f386d8d297177fd288be6e8d1afc05966878704dad9847719650e44fc49c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284461,"upload-time":"2020-12-19T01:19:30.158384Z","url":"https://files.pythonhosted.org/packages/19/2c/9f1bad783faee4e9704868f381913e68dbb69f0de3fcdc71ee7071c47847/psutil-5.8.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"12d844996d6c2b1d3881cfa6fa201fd635971869a9da945cf6756105af73d2df"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287768,"upload-time":"2020-12-19T01:19:33.394809Z","url":"https://files.pythonhosted.org/packages/82/0a/eddb9a51ba5055cc7c242da07c1643a6b146070740c5eb5540277a0f01f4/psutil-5.8.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"02b8292609b1f7fcb34173b25e48d0da8667bc85f81d7476584d889c6e0f2131"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284476,"upload-time":"2020-12-19T01:19:36.479406Z","url":"https://files.pythonhosted.org/packages/15/28/47c28171fd7eeb83df74f78ccac090211f4a49408f376eb8e78a7bb47dc0/psutil-5.8.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"6ffe81843131ee0ffa02c317186ed1e759a145267d54fdef1bc4ea5f5931ab60"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287754,"upload-time":"2020-12-19T01:19:39.219693Z","url":"https://files.pythonhosted.org/packages/26/ef/461e9eec56fba7fa66692c4af00cbd6547b788a7ca818d9b8b5f1951f228/psutil-5.8.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"data-dist-info-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"filename":"psutil-5.8.0-cp27-none-win32.whl","hashes":{"sha256":"ea313bb02e5e25224e518e4352af4bf5e062755160f77e4b1767dd5ccb65f876"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236561,"upload-time":"2020-12-19T01:19:41.916204Z","url":"https://files.pythonhosted.org/packages/a8/b3/6a21c5b7e4f600bd6eaaecd4a5e76230fa34876e48cbc87b2cef0ab91c0a/psutil-5.8.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"data-dist-info-metadata":{"sha256":"91c5c4b49dc8b3365ce65ca99e7cee1cf8d862d4379fcc384b1711d4600dd869"},"filename":"psutil-5.8.0-cp27-none-win_amd64.whl","hashes":{"sha256":"5da29e394bdedd9144c7331192e20c1f79283fb03b06e6abd3a8ae45ffecee65"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239900,"upload-time":"2020-12-19T01:19:45.046259Z","url":"https://files.pythonhosted.org/packages/b2/3d/01ef1f4bf71413078bf2ce2aae04d47bc132cfede58738183a9de41aa122/psutil-5.8.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"74fb2557d1430fff18ff0d72613c5ca30c45cdbfcddd6a5773e9fc1fe9364be8"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236013,"upload-time":"2020-12-19T01:19:47.734642Z","url":"https://files.pythonhosted.org/packages/30/81/37ebe0ba2840b76681072e786bae3319cade8a6861029d0ae885c274fa0b/psutil-5.8.0-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-manylinux2010_i686.whl","hashes":{"sha256":"74f2d0be88db96ada78756cb3a3e1b107ce8ab79f65aa885f76d7664e56928f6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289247,"upload-time":"2020-12-19T01:19:50.429849Z","url":"https://files.pythonhosted.org/packages/2e/7c/13a6c3f068aa39ffafd99ae159c1a345521e7dd0074ccadb917e5670dbdc/psutil-5.8.0-cp36-cp36m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-manylinux2010_x86_64.whl","hashes":{"sha256":"99de3e8739258b3c3e8669cb9757c9a861b2a25ad0955f8e53ac662d66de61ac"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291875,"upload-time":"2020-12-19T01:19:53.450222Z","url":"https://files.pythonhosted.org/packages/da/82/56cd16a4c5f53e3e5dd7b2c30d5c803e124f218ebb644ca9c30bc907eadd/psutil-5.8.0-cp36-cp36m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-win32.whl","hashes":{"sha256":"36b3b6c9e2a34b7d7fbae330a85bf72c30b1c827a4366a07443fc4b6270449e2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240337,"upload-time":"2020-12-19T01:19:56.748668Z","url":"https://files.pythonhosted.org/packages/19/29/f7a38ee30083f2caa14cc77a6d34c4d5cfd1a69641e87bf1b3d6ba90d0ba/psutil-5.8.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"52de075468cd394ac98c66f9ca33b2f54ae1d9bff1ef6b67a212ee8f639ec06d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244835,"upload-time":"2020-12-19T01:19:59.102544Z","url":"https://files.pythonhosted.org/packages/44/ed/49d75a29007727d44937ed4d233f116be346bc4657a83b5a9e2f423bca57/psutil-5.8.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"c6a5fd10ce6b6344e616cf01cc5b849fa8103fbb5ba507b6b2dee4c11e84c935"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236013,"upload-time":"2020-12-19T01:20:02.260367Z","url":"https://files.pythonhosted.org/packages/fe/19/83ab423a7b69cafe4078dea751acdff7377e4b59c71e3718125ba3c341f9/psutil-5.8.0-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-manylinux2010_i686.whl","hashes":{"sha256":"61f05864b42fedc0771d6d8e49c35f07efd209ade09a5afe6a5059e7bb7bf83d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":290299,"upload-time":"2020-12-19T01:20:04.653817Z","url":"https://files.pythonhosted.org/packages/cc/5f/2a1967092086acc647962168d0e6fd1c22e14a973f03e3ffb1e2f0da5de9/psutil-5.8.0-cp37-cp37m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-manylinux2010_x86_64.whl","hashes":{"sha256":"0dd4465a039d343925cdc29023bb6960ccf4e74a65ad53e768403746a9207023"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296329,"upload-time":"2020-12-19T01:20:07.174230Z","url":"https://files.pythonhosted.org/packages/84/da/f7efdcf012b51506938553dbe302aecc22f3f43abd5cffa8320e8e0588d5/psutil-5.8.0-cp37-cp37m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-win32.whl","hashes":{"sha256":"1bff0d07e76114ec24ee32e7f7f8d0c4b0514b3fae93e3d2aaafd65d22502394"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240337,"upload-time":"2020-12-19T01:20:10.138302Z","url":"https://files.pythonhosted.org/packages/18/c9/1db6aa0d28831f60408a6aab9d108c2edbd5a9ed11e5957a91d9d8023898/psutil-5.8.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"fcc01e900c1d7bee2a37e5d6e4f9194760a93597c97fee89c4ae51701de03563"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244834,"upload-time":"2020-12-19T01:20:12.840200Z","url":"https://files.pythonhosted.org/packages/71/ce/35107e81e7eae55c847313f872d4258a71d2640fa04f57c5520fc81473ce/psutil-5.8.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"6223d07a1ae93f86451d0198a0c361032c4c93ebd4bf6d25e2fb3edfad9571ef"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236297,"upload-time":"2020-12-19T01:20:15.489742Z","url":"https://files.pythonhosted.org/packages/10/d6/c5c19e40bb05e2cb5f053f480dfe47e9543a8322f1a5985d7352bf689611/psutil-5.8.0-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-manylinux2010_i686.whl","hashes":{"sha256":"d225cd8319aa1d3c85bf195c4e07d17d3cd68636b8fc97e6cf198f782f99af28"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293809,"upload-time":"2020-12-19T01:20:18.539919Z","url":"https://files.pythonhosted.org/packages/e9/d6/7d0bcf272923f6b3433e22effd31860b63ab580d65fb2d8f5cb443a9e6fc/psutil-5.8.0-cp38-cp38-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-manylinux2010_x86_64.whl","hashes":{"sha256":"28ff7c95293ae74bf1ca1a79e8805fcde005c18a122ca983abf676ea3466362b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296040,"upload-time":"2020-12-19T01:20:21.423284Z","url":"https://files.pythonhosted.org/packages/3b/c2/78109a12da9febb2f965abf29da6f81b0a3f2b89a7b59d88b759e68dc6db/psutil-5.8.0-cp38-cp38-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-win32.whl","hashes":{"sha256":"ce8b867423291cb65cfc6d9c4955ee9bfc1e21fe03bb50e177f2b957f1c2469d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240950,"upload-time":"2020-12-19T01:20:24.359373Z","url":"https://files.pythonhosted.org/packages/87/be/6511e1341c203608fe2553249216c40b92cd8a72d8b35fa3c1decee9a616/psutil-5.8.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"90f31c34d25b1b3ed6c40cdd34ff122b1887a825297c017e4cbd6796dd8b672d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245386,"upload-time":"2020-12-19T01:20:26.799194Z","url":"https://files.pythonhosted.org/packages/8e/5c/c4b32c2024daeac35e126b90a1ff7a0209ef8b32675d1d50e55d58e78c81/psutil-5.8.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"6323d5d845c2785efb20aded4726636546b26d3b577aded22492908f7c1bdda7"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":236274,"upload-time":"2020-12-19T01:20:29.615503Z","url":"https://files.pythonhosted.org/packages/12/80/8d09c345f19af2b29a309f8f9284e3ba1ae1ebd9438419080c14630f743a/psutil-5.8.0-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-manylinux2010_i686.whl","hashes":{"sha256":"245b5509968ac0bd179287d91210cd3f37add77dad385ef238b275bad35fa1c4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291032,"upload-time":"2020-12-19T01:20:32.422979Z","url":"https://files.pythonhosted.org/packages/b6/2f/118e23a8f4e59d2c4ffe03a921cc72f364966e25548dc6c5a3011a334dc5/psutil-5.8.0-cp39-cp39-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-manylinux2010_x86_64.whl","hashes":{"sha256":"90d4091c2d30ddd0a03e0b97e6a33a48628469b99585e2ad6bf21f17423b112b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293491,"upload-time":"2020-12-19T01:20:34.915141Z","url":"https://files.pythonhosted.org/packages/91/4d/033cc02ae3a47197d0ced818814e4bb8d9d29ebed4f1eb55badedec160f7/psutil-5.8.0-cp39-cp39-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-win32.whl","hashes":{"sha256":"ea372bcc129394485824ae3e3ddabe67dc0b118d262c568b4d2602a7070afdb0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241508,"upload-time":"2020-12-19T01:20:37.527554Z","url":"https://files.pythonhosted.org/packages/a7/13/7285b74e061da21dfc4f15c8307eb2da1d2137367502d6598f03f4a5b5e7/psutil-5.8.0-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"data-dist-info-metadata":{"sha256":"069863fda59a3742371c9f60ad268b0b04c760a595c7d1a1de557d590bf205e6"},"filename":"psutil-5.8.0-cp39-cp39-win_amd64.whl","hashes":{"sha256":"f4634b033faf0d968bb9220dd1c793b897ab7f1189956e1aa9eae752527127d3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246139,"upload-time":"2020-12-19T01:20:39.890196Z","url":"https://files.pythonhosted.org/packages/21/71/33cb528381c443df1ee25cbb451da975421bddb5099b11e7f2eb3fc90d6d/psutil-5.8.0-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.8.0.tar.gz","hashes":{"sha256":"0c9ccb99ab76025f2f0bbecf341d4656e9c1351db8cc8a03ccd62e318ab4b5c6"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":470886,"upload-time":"2020-12-19T01:20:42.916847Z","url":"https://files.pythonhosted.org/packages/e1/b0/7276de53321c12981717490516b7e612364f2cb372ee8901bd4a66a000d7/psutil-5.8.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"55ce319452e3d139e25d6c3f85a1acf12d1607ddedea5e35fb47a552c051161b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285348,"upload-time":"2021-12-29T21:26:19.591062Z","url":"https://files.pythonhosted.org/packages/c9/62/5cfcb69c256d469236d4bddeb7ad4ee6a8b37d604dcfc82b7c938fd8ee37/psutil-5.9.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"7336292a13a80eb93c21f36bde4328aa748a04b68c13d01dfddd67fc13fd0618"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288125,"upload-time":"2021-12-29T21:26:24.644701Z","url":"https://files.pythonhosted.org/packages/eb/0d/c19872c9121208bbbb4335bb13a4a2f2b95661fd69d24f26e32f94e5a8a1/psutil-5.9.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"cb8d10461c1ceee0c25a64f2dd54872b70b89c26419e147a05a10b753ad36ec2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285364,"upload-time":"2021-12-29T21:26:28.242468Z","url":"https://files.pythonhosted.org/packages/1a/3e/ff287d01bca130b72cf53a9b20bbc31bf566d503ee63adf8c7dcfd9315e2/psutil-5.9.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"data-dist-info-metadata":{"sha256":"146a681ce7fa3f640f9204e5391309605d72b0f4ddaaf9927df9b73319a4490e"},"filename":"psutil-5.9.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"7641300de73e4909e5d148e90cc3142fb890079e1525a840cf0dfd39195239fd"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288110,"upload-time":"2021-12-29T21:26:31.963660Z","url":"https://files.pythonhosted.org/packages/d8/49/fbce284331d482703decdc8dec9bfd910fa00a3acd5b974e8efa8c30104a/psutil-5.9.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"data-dist-info-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"filename":"psutil-5.9.0-cp27-none-win32.whl","hashes":{"sha256":"ea42d747c5f71b5ccaa6897b216a7dadb9f52c72a0fe2b872ef7d3e1eacf3ba3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239056,"upload-time":"2021-12-29T21:26:35.738857Z","url":"https://files.pythonhosted.org/packages/ab/d7/a8b076603943ebce7872ca7d4e012f6dcdc33e86eabb117921a6fe6e1f8a/psutil-5.9.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"data-dist-info-metadata":{"sha256":"e84069ba77055def96d865c3845efa434ef6204d61f576071bac882eb98e785c"},"filename":"psutil-5.9.0-cp27-none-win_amd64.whl","hashes":{"sha256":"ef216cc9feb60634bda2f341a9559ac594e2eeaadd0ba187a4c2eb5b5d40b91c"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242517,"upload-time":"2021-12-29T21:26:39.603955Z","url":"https://files.pythonhosted.org/packages/2d/7a/ee32fa2c5712fa0bc6a9f376ffe9d2e1dc856e2e011d2bab4e12293dcd88/psutil-5.9.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"90a58b9fcae2dbfe4ba852b57bd4a1dded6b990a33d6428c7614b7d48eccb492"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238624,"upload-time":"2021-12-29T21:26:42.964503Z","url":"https://files.pythonhosted.org/packages/89/48/2c6f566d35a38fb9f882e51d75425a6f1d097cb946e05b6aff98d450a151/psutil-5.9.0-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"ff0d41f8b3e9ebb6b6110057e40019a432e96aae2008951121ba4e56040b84f3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279343,"upload-time":"2021-12-29T21:26:46.859457Z","url":"https://files.pythonhosted.org/packages/11/46/e790221e8281af5163517a17a20c88b10a75a5642d9c5106a868f2879edd/psutil-5.9.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"742c34fff804f34f62659279ed5c5b723bb0195e9d7bd9907591de9f8f6558e2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281400,"upload-time":"2021-12-29T21:26:51.801761Z","url":"https://files.pythonhosted.org/packages/6f/8a/d1810472a4950a31df385eafbc9bd20cde971814ff6533021dc565bf14ae/psutil-5.9.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-win32.whl","hashes":{"sha256":"8293942e4ce0c5689821f65ce6522ce4786d02af57f13c0195b40e1edb1db61d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241383,"upload-time":"2021-12-29T21:26:55.364799Z","url":"https://files.pythonhosted.org/packages/61/93/4251cfa58e5bbd7f92e1bfb965a0c41376cbcbc83c524a8b60d2678f0edd/psutil-5.9.0-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp310-cp310-win_amd64.whl","hashes":{"sha256":"9b51917c1af3fa35a3f2dabd7ba96a2a4f19df3dec911da73875e1edaf22a40b"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245540,"upload-time":"2021-12-29T21:26:59.088538Z","url":"https://files.pythonhosted.org/packages/9f/c9/7fb339d6a04db3b4ab94671536d11e03b23c056d1604e50e564075a96cd8/psutil-5.9.0-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"e9805fed4f2a81de98ae5fe38b75a74c6e6ad2df8a5c479594c7629a1fe35f56"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238331,"upload-time":"2022-01-07T14:28:07.566595Z","url":"https://files.pythonhosted.org/packages/48/cb/6841d4f39b5711652a93359748879f2977ede55c1020f69d038891073592/psutil-5.9.0-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"c51f1af02334e4b516ec221ee26b8fdf105032418ca5a5ab9737e8c87dafe203"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":277267,"upload-time":"2022-01-07T14:28:12.318473Z","url":"https://files.pythonhosted.org/packages/1f/2d/e6640979580db1b51220d3165e256a1d0a31847944a3e2622800a737fe86/psutil-5.9.0-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"32acf55cb9a8cbfb29167cd005951df81b567099295291bcfd1027365b36591d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279702,"upload-time":"2022-01-07T14:28:16.706587Z","url":"https://files.pythonhosted.org/packages/64/87/461555057b080e1996427098a6c51c64a8a9025ec18571dabfe5be07eeec/psutil-5.9.0-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-win32.whl","hashes":{"sha256":"e5c783d0b1ad6ca8a5d3e7b680468c9c926b804be83a3a8e95141b05c39c9f64"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243193,"upload-time":"2022-01-07T14:28:20.695929Z","url":"https://files.pythonhosted.org/packages/2b/a3/24d36239a7bfa30b0eb4302b045417796e9f2c7c21b296d2405735e8949e/psutil-5.9.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"d62a2796e08dd024b8179bd441cb714e0f81226c352c802fca0fd3f89eeacd94"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247862,"upload-time":"2022-01-07T14:28:23.774803Z","url":"https://files.pythonhosted.org/packages/14/c9/f0bccd60a25197d63a02688ea8f5c5cd5a8b1baf1a7d6bf493d3291132d2/psutil-5.9.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"3d00a664e31921009a84367266b35ba0aac04a2a6cad09c550a89041034d19a0"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238334,"upload-time":"2021-12-29T21:27:03.461413Z","url":"https://files.pythonhosted.org/packages/70/40/0a6ca5641f7574b6ea38cdb561c30065659734755a1779db67b56e225f84/psutil-5.9.0-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7779be4025c540d1d65a2de3f30caeacc49ae7a2152108adeaf42c7534a115ce"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278077,"upload-time":"2021-12-29T21:27:07.864433Z","url":"https://files.pythonhosted.org/packages/6b/c0/0f233f87e816c20e5489bca749798255a464282cdd5911d62bb8344c4b5a/psutil-5.9.0-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"072664401ae6e7c1bfb878c65d7282d4b4391f1bc9a56d5e03b5a490403271b5"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280736,"upload-time":"2021-12-29T21:27:11.252493Z","url":"https://files.pythonhosted.org/packages/60/f9/b78291ed21146ece2417bd1ba715564c6d3bdf2f1e9297ed67709bb36eeb/psutil-5.9.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-win32.whl","hashes":{"sha256":"df2c8bd48fb83a8408c8390b143c6a6fa10cb1a674ca664954de193fdcab36a9"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241810,"upload-time":"2021-12-29T21:27:14.020326Z","url":"https://files.pythonhosted.org/packages/47/3f/0475146306d02270243e55cad8167d5185c8918933953c90eda846d72ff3/psutil-5.9.0-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"1d7b433519b9a38192dfda962dd8f44446668c009833e1429a52424624f408b4"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246380,"upload-time":"2021-12-29T21:27:17.444889Z","url":"https://files.pythonhosted.org/packages/7c/d6/4ade7cebfe04710a89e2dc5638f712f09dc5e402a8fea95c3d16dc7f64bf/psutil-5.9.0-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"c3400cae15bdb449d518545cbd5b649117de54e3596ded84aacabfbb3297ead2"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238620,"upload-time":"2021-12-29T21:27:21.799788Z","url":"https://files.pythonhosted.org/packages/89/8e/2a8814f903bc06471621f6e0cd3fc1a7085868656106f31aacf2f844eea2/psutil-5.9.0-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b2237f35c4bbae932ee98902a08050a27821f8f6dfa880a47195e5993af4702d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281246,"upload-time":"2021-12-29T21:27:24.591382Z","url":"https://files.pythonhosted.org/packages/4c/95/3c0858c62ec02106cf5f3e79d74223264a6269a16996f31d5ab43abcec86/psutil-5.9.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"1070a9b287846a21a5d572d6dddd369517510b68710fca56b0e9e02fd24bed9a"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":283823,"upload-time":"2021-12-29T21:27:27.809766Z","url":"https://files.pythonhosted.org/packages/0a/66/b2188d8e738ee52206a4ee804907f6eab5bcc9fc0e8486e7ab973a8323b7/psutil-5.9.0-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-win32.whl","hashes":{"sha256":"76cebf84aac1d6da5b63df11fe0d377b46b7b500d892284068bacccf12f20666"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242160,"upload-time":"2021-12-29T21:27:31.512894Z","url":"https://files.pythonhosted.org/packages/d0/cf/7a86fc08f821d66c528939f155079df7d0945678fc474c6a6455c909f6eb/psutil-5.9.0-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp38-cp38-win_amd64.whl","hashes":{"sha256":"3151a58f0fbd8942ba94f7c31c7e6b310d2989f4da74fcbf28b934374e9bf841"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246488,"upload-time":"2021-12-29T21:27:36.422809Z","url":"https://files.pythonhosted.org/packages/62/d4/72fc44dfd9939851bd672e94e43d12848a98b1d2c3f6f794d54a220fe4a7/psutil-5.9.0-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"539e429da49c5d27d5a58e3563886057f8fc3868a5547b4f1876d9c0f007bccf"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238613,"upload-time":"2021-12-29T21:27:39.813718Z","url":"https://files.pythonhosted.org/packages/48/6a/c6e88a5584544033dbb8318c380e7e1e3796e5ac336577eb91dc75bdecd7/psutil-5.9.0-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"58c7d923dc209225600aec73aa2c4ae8ea33b1ab31bc11ef8a5933b027476f07"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278536,"upload-time":"2021-12-29T21:27:43.204962Z","url":"https://files.pythonhosted.org/packages/f7/b1/82e95f6368dbde6b7e54ea6b18cf8ac3958223540d0bcbde23ba7be19478/psutil-5.9.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"3611e87eea393f779a35b192b46a164b1d01167c9d323dda9b1e527ea69d697d"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280415,"upload-time":"2021-12-29T21:27:47.616041Z","url":"https://files.pythonhosted.org/packages/c4/35/7cec9647be077784d20913404f914fffd8fe6dfd0673e29f7bd822ac1331/psutil-5.9.0-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-win32.whl","hashes":{"sha256":"4e2fb92e3aeae3ec3b7b66c528981fd327fb93fd906a77215200404444ec1845"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241428,"upload-time":"2021-12-29T21:27:52.616449Z","url":"https://files.pythonhosted.org/packages/5a/c6/923aed22f6c9c5197998fa6907c983e884975a0ae3430ccd8514f5fd0d6a/psutil-5.9.0-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"data-dist-info-metadata":{"sha256":"ad269c4c58fadbf100c6116eb3ebed5d77878f0c43b9314d18addc011b2b2b80"},"filename":"psutil-5.9.0-cp39-cp39-win_amd64.whl","hashes":{"sha256":"7d190ee2eaef7831163f254dc58f6d2e2a22e27382b936aab51c835fc080c3d3"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245606,"upload-time":"2021-12-29T21:27:56.202709Z","url":"https://files.pythonhosted.org/packages/9e/9e/3a48f15a1539505e2f3058a709eee56acfb379f2b0ff409d6291099e2a7e/psutil-5.9.0-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.0.tar.gz","hashes":{"sha256":"869842dbd66bb80c3217158e629d6fceaecc3a3166d3d1faee515b05dd26ca25"},"provenance":null,"requires-python":">=2.6, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":478322,"upload-time":"2021-12-29T21:27:59.163343Z","url":"https://files.pythonhosted.org/packages/47/b6/ea8a7728f096a597f0032564e8013b705aa992a0990becd773dcc4d7b4a7/psutil-5.9.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"799759d809c31aab5fe4579e50addf84565e71c1dc9f1c31258f159ff70d3f87"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286186,"upload-time":"2022-05-20T20:09:47.558524Z","url":"https://files.pythonhosted.org/packages/77/06/f9fd79449440d7217d6bf2c90998d540e125cfeffe39d214a328dadc46f4/psutil-5.9.1-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"9272167b5f5fbfe16945be3db475b3ce8d792386907e673a209da686176552af"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288858,"upload-time":"2022-05-20T20:09:52.956913Z","url":"https://files.pythonhosted.org/packages/cf/29/ad704a45960bfb52ef8bf0beb9c41c09ce92d61c40333f03e9a03f246c22/psutil-5.9.1-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"data-dist-info-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"filename":"psutil-5.9.1-cp27-cp27m-win32.whl","hashes":{"sha256":"0904727e0b0a038830b019551cf3204dd48ef5c6868adc776e06e93d615fc5fc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239479,"upload-time":"2022-05-20T20:09:57.166474Z","url":"https://files.pythonhosted.org/packages/7e/8d/e0a66123fa98e309597815de518b47a7a6c571a8f886fc8d4db2331fd2ab/psutil-5.9.1-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"data-dist-info-metadata":{"sha256":"e6c8d739b32cc31942a1726ba4e33d58fe5d46a1400a2526e858888d58324393"},"filename":"psutil-5.9.1-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"e7e10454cb1ab62cc6ce776e1c135a64045a11ec4c6d254d3f7689c16eb3efd2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242812,"upload-time":"2022-05-20T20:10:01.868774Z","url":"https://files.pythonhosted.org/packages/1b/53/8f0772df0a6d593bc2fcdf12f4f790bab5c4f6a77bb61a8ddaad2cbba7f8/psutil-5.9.1-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"56960b9e8edcca1456f8c86a196f0c3d8e3e361320071c93378d41445ffd28b0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286184,"upload-time":"2022-05-20T20:10:05.575313Z","url":"https://files.pythonhosted.org/packages/2d/56/54b4ed8102ce5a2f5367b4e766c1873c18f9c32cde321435d0e0ee2abcc5/psutil-5.9.1-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"data-dist-info-metadata":{"sha256":"ac1d788a80e2f59751f3eb37a186124618aa8bafbbe6cd2ad03985f508e49a67"},"filename":"psutil-5.9.1-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"44d1826150d49ffd62035785a9e2c56afcea66e55b43b8b630d7706276e87f22"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288863,"upload-time":"2022-05-20T20:10:09.032899Z","url":"https://files.pythonhosted.org/packages/2c/9d/dc329b7da284677ea843f3ff4b35b8ab3b96b65a58a544b3c3f86d9d032f/psutil-5.9.1-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"c7be9d7f5b0d206f0bbc3794b8e16fb7dbc53ec9e40bbe8787c6f2d38efcf6c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239266,"upload-time":"2022-05-20T20:10:12.541628Z","url":"https://files.pythonhosted.org/packages/d1/16/6239e76ab5d990dc7866bc22a80585f73421588d63b42884d607f5f815e2/psutil-5.9.1-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"abd9246e4cdd5b554a2ddd97c157e292ac11ef3e7af25ac56b08b455c829dca8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280127,"upload-time":"2022-05-20T20:10:16.449769Z","url":"https://files.pythonhosted.org/packages/14/06/39d7e963a6a8bbf26519de208593cdb0ddfe22918b8989f4b2363d4ab49f/psutil-5.9.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"29a442e25fab1f4d05e2655bb1b8ab6887981838d22effa2396d584b740194de"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282049,"upload-time":"2022-05-20T20:10:19.914788Z","url":"https://files.pythonhosted.org/packages/6d/c6/6a4e46802e8690d50ba6a56c7f79ac283e703fcfa0fdae8e41909c8cef1f/psutil-5.9.1-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp310-cp310-win32.whl","hashes":{"sha256":"20b27771b077dcaa0de1de3ad52d22538fe101f9946d6dc7869e6f694f079329"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241699,"upload-time":"2022-05-20T20:10:23.278390Z","url":"https://files.pythonhosted.org/packages/26/b4/a58cf15ea649faa92c54f00c627aef1d50b9f1abf207485f10c967a50c95/psutil-5.9.1-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp310-cp310-win_amd64.whl","hashes":{"sha256":"58678bbadae12e0db55186dc58f2888839228ac9f41cc7848853539b70490021"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245843,"upload-time":"2022-05-20T20:10:26.856840Z","url":"https://files.pythonhosted.org/packages/c0/5a/2ac88d5265b711c8aa4e786825b38d5d0b1e5ecbdd0ce78e9b04a820d247/psutil-5.9.1-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"3a76ad658641172d9c6e593de6fe248ddde825b5866464c3b2ee26c35da9d237"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239007,"upload-time":"2022-05-20T20:10:30.191299Z","url":"https://files.pythonhosted.org/packages/65/1d/6a112f146faee6292a6c3ee2a7f24a8e572697adb7e1c5de3d8508f647cc/psutil-5.9.1-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"a6a11e48cb93a5fa606306493f439b4aa7c56cb03fc9ace7f6bfa21aaf07c453"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278074,"upload-time":"2022-05-20T20:10:33.843171Z","url":"https://files.pythonhosted.org/packages/7e/52/a02dc53e26714a339c8b4972d8e3f268e4db8905f5d1a3a100f1e40b6fa7/psutil-5.9.1-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"068935df39055bf27a29824b95c801c7a5130f118b806eee663cad28dca97685"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280402,"upload-time":"2022-05-20T20:10:38.665061Z","url":"https://files.pythonhosted.org/packages/6b/76/a8cb69ed3566877dcbccf408f5f9d6055227ad4fed694e88809fa8506b0b/psutil-5.9.1-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-win32.whl","hashes":{"sha256":"0f15a19a05f39a09327345bc279c1ba4a8cfb0172cc0d3c7f7d16c813b2e7d36"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243501,"upload-time":"2022-05-20T20:10:42.164047Z","url":"https://files.pythonhosted.org/packages/85/4d/78173e3dffb74c5fa87914908f143473d0b8b9183f9d275333679a4e4649/psutil-5.9.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"db417f0865f90bdc07fa30e1aadc69b6f4cad7f86324b02aa842034efe8d8c4d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248156,"upload-time":"2022-05-20T20:10:45.327961Z","url":"https://files.pythonhosted.org/packages/73/1a/d78f2f2de2aad6628415d2a48917cabc2c7fb0c3a31c7cdf187cffa4eb36/psutil-5.9.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"91c7ff2a40c373d0cc9121d54bc5f31c4fa09c346528e6a08d1845bce5771ffc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238960,"upload-time":"2022-05-20T20:10:48.678116Z","url":"https://files.pythonhosted.org/packages/d6/ef/fd4dc9085e3879c3af63fe60667dd3b71adf50d030b5549315f4a619271b/psutil-5.9.1-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"fea896b54f3a4ae6f790ac1d017101252c93f6fe075d0e7571543510f11d2676"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278553,"upload-time":"2022-05-20T20:10:52.019471Z","url":"https://files.pythonhosted.org/packages/97/f6/0180e58dd1359da7d6fbc27d04dac6fb500dc758b6f4b65407608bb13170/psutil-5.9.1-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"3054e923204b8e9c23a55b23b6df73a8089ae1d075cb0bf711d3e9da1724ded4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281356,"upload-time":"2022-05-20T20:10:55.963864Z","url":"https://files.pythonhosted.org/packages/13/71/c25adbd9b33a2e27edbe1fc84b3111a5ad97611885d7abcbdd8d1f2bb7ca/psutil-5.9.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp37-cp37m-win32.whl","hashes":{"sha256":"d2d006286fbcb60f0b391741f520862e9b69f4019b4d738a2a45728c7e952f1b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242105,"upload-time":"2022-05-20T20:10:59.100543Z","url":"https://files.pythonhosted.org/packages/2a/32/136cd5bf55728ea64a22b1d817890e35fc17314c46a24ee3268b65f9076f/psutil-5.9.1-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"b14ee12da9338f5e5b3a3ef7ca58b3cba30f5b66f7662159762932e6d0b8f680"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246671,"upload-time":"2022-05-20T20:11:02.513602Z","url":"https://files.pythonhosted.org/packages/df/88/427f3959855fcb3ab04891e00c026a246892feb11b20433db814b7a24405/psutil-5.9.1-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"19f36c16012ba9cfc742604df189f2f28d2720e23ff7d1e81602dbe066be9fd1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239250,"upload-time":"2022-05-20T20:11:06.292977Z","url":"https://files.pythonhosted.org/packages/46/80/1de3a9bac336b5c8e4f7b0ff2e80c85ba237f18f2703be68884ee6798432/psutil-5.9.1-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"944c4b4b82dc4a1b805329c980f270f170fdc9945464223f2ec8e57563139cf4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281678,"upload-time":"2022-05-20T20:11:09.990719Z","url":"https://files.pythonhosted.org/packages/fd/ba/c5a3f46f351ab609cc0be6a563e492900c57e3d5c9bda0b79b84d8c3eae9/psutil-5.9.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4b6750a73a9c4a4e689490ccb862d53c7b976a2a35c4e1846d049dcc3f17d83b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284665,"upload-time":"2022-05-20T20:11:13.584309Z","url":"https://files.pythonhosted.org/packages/9d/41/d5f2db2ab7f5dff2fa795993a0cd6fa8a8f39ca197c3a86857875333ec10/psutil-5.9.1-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp38-cp38-win32.whl","hashes":{"sha256":"a8746bfe4e8f659528c5c7e9af5090c5a7d252f32b2e859c584ef7d8efb1e689"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242461,"upload-time":"2022-05-20T20:11:16.942263Z","url":"https://files.pythonhosted.org/packages/41/ec/5fd3e9388d0ed1edfdeae71799df374f4a117932646a63413fa95a121e9f/psutil-5.9.1-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp38-cp38-win_amd64.whl","hashes":{"sha256":"79c9108d9aa7fa6fba6e668b61b82facc067a6b81517cab34d07a84aa89f3df0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246804,"upload-time":"2022-05-20T20:11:20.322459Z","url":"https://files.pythonhosted.org/packages/b2/ad/65e2b2b97677f98d718388dc11b2a9d7f177ebbae5eef72547a32bc28911/psutil-5.9.1-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"28976df6c64ddd6320d281128817f32c29b539a52bdae5e192537bc338a9ec81"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239248,"upload-time":"2022-05-20T20:11:23.352312Z","url":"https://files.pythonhosted.org/packages/9f/ca/84ce3e48b3ca2f0f74314d89929b3a523220f3f4a8dff395d6ef74dadef3/psutil-5.9.1-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b88f75005586131276634027f4219d06e0561292be8bd6bc7f2f00bdabd63c4e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279320,"upload-time":"2022-05-20T20:11:27.310813Z","url":"https://files.pythonhosted.org/packages/a9/97/b7e3532d97d527349701d2143c3f868733b94e2db6f531b07811b698f549/psutil-5.9.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"data-dist-info-metadata":{"sha256":"1f39ef2570a850c4cbdb8430a13b995343050494e85d316030a206bd7da4c63b"},"filename":"psutil-5.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"645bd4f7bb5b8633803e0b6746ff1628724668681a434482546887d22c7a9537"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281065,"upload-time":"2022-05-20T20:11:30.617653Z","url":"https://files.pythonhosted.org/packages/62/1f/f14225bda76417ab9bd808ff21d5cd59d5435a9796ca09b34d4cb0edcd88/psutil-5.9.1-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp39-cp39-win32.whl","hashes":{"sha256":"32c52611756096ae91f5d1499fe6c53b86f4a9ada147ee42db4991ba1520e574"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241748,"upload-time":"2022-05-20T20:11:34.374569Z","url":"https://files.pythonhosted.org/packages/b1/d2/c5374a784567c1e42ee8a589b1b42e2bd6e14c7be3c234d84360ab3a0a39/psutil-5.9.1-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"data-dist-info-metadata":{"sha256":"b48f9beb61d032244f4c239867a736641369484a967d3ac29eeab577ce127229"},"filename":"psutil-5.9.1-cp39-cp39-win_amd64.whl","hashes":{"sha256":"f65f9a46d984b8cd9b3750c2bdb419b2996895b005aefa6cbaba9a143b1ce2c5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245883,"upload-time":"2022-05-20T20:11:37.840887Z","url":"https://files.pythonhosted.org/packages/e0/ac/fd6f098969d49f046083ac032e6788d9f861903596fb9555a02bf50a1238/psutil-5.9.1-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.1.tar.gz","hashes":{"sha256":"57f1819b5d9e95cdfb0c881a8a5b7d542ed0b7c522d575706a80bedc848c8954"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":479090,"upload-time":"2022-05-20T20:11:41.043143Z","url":"https://files.pythonhosted.org/packages/d6/de/0999ea2562b96d7165812606b18f7169307b60cd378bc29cf3673322c7e9/psutil-5.9.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"8f024fbb26c8daf5d70287bb3edfafa22283c255287cf523c5d81721e8e5d82c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285739,"upload-time":"2022-09-04T20:15:28.668835Z","url":"https://files.pythonhosted.org/packages/37/a4/cb10e4c0faa3091de22eb78fa1c332566e60b9b59001bef326a4c1070417/psutil-5.9.2-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"b2f248ffc346f4f4f0d747ee1947963613216b06688be0be2e393986fe20dbbb"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289461,"upload-time":"2022-09-04T20:15:32.802519Z","url":"https://files.pythonhosted.org/packages/93/40/58dfcab15435b6fedf5385bc7e88a4c162cc6af0056f5d9d97f5ebfd7fa0/psutil-5.9.2-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"data-dist-info-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"filename":"psutil-5.9.2-cp27-cp27m-win32.whl","hashes":{"sha256":"b1928b9bf478d31fdffdb57101d18f9b70ed4e9b0e41af751851813547b2a9ab"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240036,"upload-time":"2022-09-04T20:15:36.698093Z","url":"https://files.pythonhosted.org/packages/42/eb/83470960f2c13a026b07051456ad834f5fea0c80e8cb83fc65005f5f18d5/psutil-5.9.2-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"data-dist-info-metadata":{"sha256":"5f8d323cf6b24ee1e72553da21c2f9124f45da854ffd5befab575ceb9733c773"},"filename":"psutil-5.9.2-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"404f4816c16a2fcc4eaa36d7eb49a66df2d083e829d3e39ee8759a411dbc9ecf"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243378,"upload-time":"2022-09-04T20:15:40.746927Z","url":"https://files.pythonhosted.org/packages/d1/5b/b9d6ac192d3108e1dc7875ab1579b7f65eb7bf0ef799dadd3f3798d0af2e/psutil-5.9.2-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"94e621c6a4ddb2573d4d30cba074f6d1aa0186645917df42c811c473dd22b339"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":285740,"upload-time":"2022-09-04T20:15:44.420732Z","url":"https://files.pythonhosted.org/packages/b6/96/ddf877440f2686eb17933531507fe4822ff1ed76d85df4a093a605b91db8/psutil-5.9.2-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"data-dist-info-metadata":{"sha256":"fcf26ce4e0d8482a82643f948df7370a2afab20a048f7563ee3fb420705fcf07"},"filename":"psutil-5.9.2-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"256098b4f6ffea6441eb54ab3eb64db9ecef18f6a80d7ba91549195d55420f84"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289451,"upload-time":"2022-09-04T20:15:47.573981Z","url":"https://files.pythonhosted.org/packages/d7/df/ff5c766b50350f2a4555d5068127d372bb26201a2a5eeda9efc8dbf570b4/psutil-5.9.2-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"614337922702e9be37a39954d67fdb9e855981624d8011a9927b8f2d3c9625d9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239273,"upload-time":"2022-09-04T20:15:52.215984Z","url":"https://files.pythonhosted.org/packages/04/5d/d52473097582db5d3094bc34acf9874de726327a3166426e22ed0806de6a/psutil-5.9.2-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"39ec06dc6c934fb53df10c1672e299145ce609ff0611b569e75a88f313634969"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280571,"upload-time":"2022-09-04T20:15:55.608887Z","url":"https://files.pythonhosted.org/packages/47/2b/bd12c4f2d1bd3024fe7c5d8388f8a5627cc02fbe11d62bd451aff356415d/psutil-5.9.2-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"e3ac2c0375ef498e74b9b4ec56df3c88be43fe56cac465627572dbfb21c4be34"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282777,"upload-time":"2022-09-04T20:15:59.840541Z","url":"https://files.pythonhosted.org/packages/4c/85/7a112fb6a8c598a6f5d079228bbc03ae84c472397be79c075e7514b6ed36/psutil-5.9.2-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-win32.whl","hashes":{"sha256":"e4c4a7636ffc47b7141864f1c5e7d649f42c54e49da2dd3cceb1c5f5d29bfc85"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241713,"upload-time":"2022-09-05T14:16:44.931542Z","url":"https://files.pythonhosted.org/packages/39/07/5cbcf3322031fcf8dcbfa431b1c145f193c96b18964ef374a88d6a83f2c9/psutil-5.9.2-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp310-cp310-win_amd64.whl","hashes":{"sha256":"f4cb67215c10d4657e320037109939b1c1d2fd70ca3d76301992f89fe2edb1f1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245853,"upload-time":"2022-09-05T14:16:48.388734Z","url":"https://files.pythonhosted.org/packages/ae/9c/d29dd82d5fda2c6c6d959d57101c78ddbac8325defe94e1b9f983e7cfff3/psutil-5.9.2-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"dc9bda7d5ced744622f157cc8d8bdd51735dafcecff807e928ff26bdb0ff097d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238998,"upload-time":"2022-09-04T20:16:03.484887Z","url":"https://files.pythonhosted.org/packages/df/aa/8268eee572fb9bdf3486d384e3973ad9d635403841c6e7f2af7781e5525b/psutil-5.9.2-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"d75291912b945a7351d45df682f9644540d564d62115d4a20d45fa17dc2d48f8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":278226,"upload-time":"2022-09-04T20:16:07.134877Z","url":"https://files.pythonhosted.org/packages/f0/43/bcb92221f5dd45e155337aae37e412fe02a3e5d99e936156a4dcff89fa55/psutil-5.9.2-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"b4018d5f9b6651f9896c7a7c2c9f4652e4eea53f10751c4e7d08a9093ab587ec"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280489,"upload-time":"2022-09-04T20:16:10.463113Z","url":"https://files.pythonhosted.org/packages/a4/eb/d841d5bc526641aad65373b0a4850e98284580df967daff5288779090ea3/psutil-5.9.2-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-win32.whl","hashes":{"sha256":"f40ba362fefc11d6bea4403f070078d60053ed422255bd838cd86a40674364c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243511,"upload-time":"2022-09-05T14:16:51.624881Z","url":"https://files.pythonhosted.org/packages/54/5f/3619e7d22ded096fa6dbd329fc057bfcf53e998b1e2c1ecc07a4155175b1/psutil-5.9.2-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"data-dist-info-metadata":{"sha256":"c9979ffe6f0cae3b896ebf06f4e0fa63198d968c57d0df7bb3405936e7b9eb5f"},"filename":"psutil-5.9.2-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"9770c1d25aee91417eba7869139d629d6328a9422ce1cdd112bd56377ca98444"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248164,"upload-time":"2022-09-05T14:16:55.091982Z","url":"https://files.pythonhosted.org/packages/53/ac/7c4ff994b1ea7d46a84932f0c8d49e28e36a668173975876353f4ea38588/psutil-5.9.2-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"42638876b7f5ef43cef8dcf640d3401b27a51ee3fa137cb2aa2e72e188414c32"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":238970,"upload-time":"2022-09-04T20:16:14.127339Z","url":"https://files.pythonhosted.org/packages/55/c5/fd2c45a0845e7bae07c8112ed67c21163742cc116732ac2702d9139a9a92/psutil-5.9.2-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"91aa0dac0c64688667b4285fa29354acfb3e834e1fd98b535b9986c883c2ce1d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279452,"upload-time":"2022-09-04T20:16:18.609472Z","url":"https://files.pythonhosted.org/packages/89/cf/b228a7554eda5e72fd8c33b89c628a86336e5cdbd62fe8b8d2a61a099b2d/psutil-5.9.2-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4fb54941aac044a61db9d8eb56fc5bee207db3bc58645d657249030e15ba3727"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281281,"upload-time":"2022-09-04T20:16:22.476894Z","url":"https://files.pythonhosted.org/packages/3d/73/d8c87b5612c58d1e6c6d91997c1590771d34e4ee27d9c11eb1e64ecbf365/psutil-5.9.2-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-win32.whl","hashes":{"sha256":"7cbb795dcd8ed8fd238bc9e9f64ab188f3f4096d2e811b5a82da53d164b84c3f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242115,"upload-time":"2022-09-05T14:16:58.770138Z","url":"https://files.pythonhosted.org/packages/98/42/62470fae4e1e9c0f4336acf74af9d4a6d5c6b5788c8435ec387e987a7ebe/psutil-5.9.2-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"5d39e3a2d5c40efa977c9a8dd4f679763c43c6c255b1340a56489955dbca767c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246680,"upload-time":"2022-09-05T14:17:03.836879Z","url":"https://files.pythonhosted.org/packages/5e/a2/4025f29069010f118eba4bcd681167d547525d40d2c45029db2f64606f86/psutil-5.9.2-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"fd331866628d18223a4265371fd255774affd86244fc307ef66eaf00de0633d5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239258,"upload-time":"2022-09-04T20:16:26.490949Z","url":"https://files.pythonhosted.org/packages/2b/52/c69f5d0acc4bbd3cf44178f025e498666d2eebc216f5f5725d9142244365/psutil-5.9.2-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b315febaebae813326296872fdb4be92ad3ce10d1d742a6b0c49fb619481ed0b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282623,"upload-time":"2022-09-04T20:16:29.707162Z","url":"https://files.pythonhosted.org/packages/c4/02/5fc4419f47f141ec0dd28db36fb8bcf1eb6e9df332690617b052c8bec76d/psutil-5.9.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"f7929a516125f62399d6e8e026129c8835f6c5a3aab88c3fff1a05ee8feb840d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":284813,"upload-time":"2022-09-04T20:16:33.456488Z","url":"https://files.pythonhosted.org/packages/79/61/a8d6d649996494672d8a86fe8be6c81b2880ee30881709d84435f2505b47/psutil-5.9.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-win32.whl","hashes":{"sha256":"561dec454853846d1dd0247b44c2e66a0a0c490f937086930ec4b8f83bf44f06"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242471,"upload-time":"2022-09-05T14:17:07.677347Z","url":"https://files.pythonhosted.org/packages/6f/8d/41c402ae33b1ce3f8e37a0dec691d753cbe66e6784e7fd26ed0cd16d99ab/psutil-5.9.2-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp38-cp38-win_amd64.whl","hashes":{"sha256":"67b33f27fc0427483b61563a16c90d9f3b547eeb7af0ef1b9fe024cdc9b3a6ea"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246816,"upload-time":"2022-09-05T14:17:11.540699Z","url":"https://files.pythonhosted.org/packages/29/07/a35c4127942cce6899d447cb54f9926d33cf1800a37c09192dd9b5a08744/psutil-5.9.2-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"b3591616fa07b15050b2f87e1cdefd06a554382e72866fcc0ab2be9d116486c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":239256,"upload-time":"2022-09-04T20:16:37.181485Z","url":"https://files.pythonhosted.org/packages/65/74/0ad485d753b2f0d00ee4ec933da1e169bc4c8f4f58db88132e886efed14b/psutil-5.9.2-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"14b29f581b5edab1f133563272a6011925401804d52d603c5c606936b49c8b97"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279700,"upload-time":"2022-09-04T20:16:40.816901Z","url":"https://files.pythonhosted.org/packages/bb/df/0819b9aed416b0dedf668cc6b3f291899c276cb2b566c4aa0dc212a03d55/psutil-5.9.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4642fd93785a29353d6917a23e2ac6177308ef5e8be5cc17008d885cb9f70f12"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":281896,"upload-time":"2022-09-04T20:16:45.773716Z","url":"https://files.pythonhosted.org/packages/b3/61/54822666fbbdd4ae1825f7a0b0cf8925a96fac1f778b4a0d5c9c066cf4b2/psutil-5.9.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-win32.whl","hashes":{"sha256":"ed29ea0b9a372c5188cdb2ad39f937900a10fb5478dc077283bf86eeac678ef1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241759,"upload-time":"2022-09-05T14:17:15.034289Z","url":"https://files.pythonhosted.org/packages/67/cf/f620f740da5bb5895b441248e08b0cd167fb545ecaa3e74ea06f3551975e/psutil-5.9.2-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"data-dist-info-metadata":{"sha256":"9318f57df027edece05c45114c189721cfbe0a56aa2ada92fe2b21340be7af15"},"filename":"psutil-5.9.2-cp39-cp39-win_amd64.whl","hashes":{"sha256":"68b35cbff92d1f7103d8f1db77c977e72f49fcefae3d3d2b91c76b0e7aef48b8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245892,"upload-time":"2022-09-05T14:17:18.376384Z","url":"https://files.pythonhosted.org/packages/10/cf/7595896a7487937c171f53bae2eeb0adcc1690ebeef684ac180a77910639/psutil-5.9.2-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.2.tar.gz","hashes":{"sha256":"feb861a10b6c3bb00701063b37e4afc754f8217f0f09c42280586bd6ac712b5c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":479757,"upload-time":"2022-09-04T20:16:49.093359Z","url":"https://files.pythonhosted.org/packages/8f/57/828ac1f70badc691a716e77bfae258ef5db76bb7830109bf4bcf882de020/psutil-5.9.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"b4a247cd3feaae39bb6085fcebf35b3b8ecd9b022db796d89c8f05067ca28e71"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":241919,"upload-time":"2022-10-18T20:12:47.255096Z","url":"https://files.pythonhosted.org/packages/74/42/6268344958236744962c711664de259598fe2005e5818c7d6bc77ae12690/psutil-5.9.3-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"5fa88e3d5d0b480602553d362c4b33a63e0c40bfea7312a7bf78799e01e0810b"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293266,"upload-time":"2022-10-18T20:12:51.216028Z","url":"https://files.pythonhosted.org/packages/79/6a/7bb45dddeb348cdb9d91d7bc78e903026870ef7f257c35de250392719cf8/psutil-5.9.3-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"767ef4fa33acda16703725c0473a91e1832d296c37c63896c7153ba81698f1ab"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":297585,"upload-time":"2022-10-18T20:12:54.920684Z","url":"https://files.pythonhosted.org/packages/02/c7/d5a6106cf31cc58f4a8a9d88b1ab8405b645b02c482353dd59f5ef19926f/psutil-5.9.3-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"data-dist-info-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"filename":"psutil-5.9.3-cp27-cp27m-win32.whl","hashes":{"sha256":"9a4af6ed1094f867834f5f07acd1250605a0874169a5fcadbcec864aec2496a6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":240677,"upload-time":"2022-10-18T20:12:58.145019Z","url":"https://files.pythonhosted.org/packages/62/0a/27aa8d95995fe97a944939f8fff7183f151814a1052b76d125812bed4800/psutil-5.9.3-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"data-dist-info-metadata":{"sha256":"3a494c9ef6c9e0802bc0a2f0d176ca6b72ed9e8ba229b930c23d38f5f92be462"},"filename":"psutil-5.9.3-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"fa5e32c7d9b60b2528108ade2929b115167fe98d59f89555574715054f50fa31"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244019,"upload-time":"2022-10-18T20:13:01.999625Z","url":"https://files.pythonhosted.org/packages/2b/0a/36951d279e1d716ab264b04e8ddb12e0c08cc1c7cbd44f2d22c84dc61e33/psutil-5.9.3-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"fe79b4ad4836e3da6c4650cb85a663b3a51aef22e1a829c384e18fae87e5e727"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":293262,"upload-time":"2022-10-18T20:13:05.579750Z","url":"https://files.pythonhosted.org/packages/5b/9c/5412473100e3213d970c8b9291371816e57f1e4a74296b2e3b8a5c8ebb47/psutil-5.9.3-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"data-dist-info-metadata":{"sha256":"eecee58b65701e8da473f7e6142a96da3fac24d305218d11c887ca28bcd6cd61"},"filename":"psutil-5.9.3-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"db8e62016add2235cc87fb7ea000ede9e4ca0aa1f221b40cef049d02d5d2593d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":297584,"upload-time":"2022-10-18T20:13:09.701506Z","url":"https://files.pythonhosted.org/packages/8f/5a/e9e98bb3ade26bc7847d5722d0e4a6d437621fa8fc02269d9cba78f6f241/psutil-5.9.3-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-macosx_10_9_x86_64.whl","hashes":{"sha256":"941a6c2c591da455d760121b44097781bc970be40e0e43081b9139da485ad5b7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242575,"upload-time":"2022-10-18T20:13:13.343655Z","url":"https://files.pythonhosted.org/packages/95/90/822c926e170e8a5769ff11edb92ac59dd523df505b5d56cad0ef3f15c325/psutil-5.9.3-cp310-cp310-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-macosx_11_0_arm64.whl","hashes":{"sha256":"71b1206e7909792d16933a0d2c1c7f04ae196186c51ba8567abae1d041f06dcb"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243240,"upload-time":"2022-10-18T20:13:17.345095Z","url":"https://files.pythonhosted.org/packages/42/9e/243aa51c3d71355913dafc27c5cb7ffdbe9a42c939a5aace526906bfc721/psutil-5.9.3-cp310-cp310-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"f57d63a2b5beaf797b87024d018772439f9d3103a395627b77d17a8d72009543"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":289285,"upload-time":"2022-10-18T20:13:20.535587Z","url":"https://files.pythonhosted.org/packages/f7/b0/6925fbfac4c342cb2f8bad1571b48e12802ac8031e1d4453a31e9a12b64d/psutil-5.9.3-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"e7507f6c7b0262d3e7b0eeda15045bf5881f4ada70473b87bc7b7c93b992a7d7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":292339,"upload-time":"2022-10-18T20:13:26.635784Z","url":"https://files.pythonhosted.org/packages/ed/2c/483ed7332d74b3fef0f5ba13c192d33f21fe95df5468a7ca040f02bd7af9/psutil-5.9.3-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp310-cp310-win32.whl","hashes":{"sha256":"1b540599481c73408f6b392cdffef5b01e8ff7a2ac8caae0a91b8222e88e8f1e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242906,"upload-time":"2022-10-18T20:13:30.051727Z","url":"https://files.pythonhosted.org/packages/55/07/94730401200098b1119dc9f5d3a271e3bf865b31bfa64a2b58a0bbd9d222/psutil-5.9.3-cp310-cp310-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp310-cp310-win_amd64.whl","hashes":{"sha256":"547ebb02031fdada635452250ff39942db8310b5c4a8102dfe9384ee5791e650"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247045,"upload-time":"2022-10-18T20:13:34.024950Z","url":"https://files.pythonhosted.org/packages/37/c0/8a102d4ce45dbc5d04932b52327c4385b88023635e57af9d457ca5ea6bb3/psutil-5.9.3-cp310-cp310-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-macosx_10_9_x86_64.whl","hashes":{"sha256":"d8c3cc6bb76492133474e130a12351a325336c01c96a24aae731abf5a47fe088"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242147,"upload-time":"2022-10-18T20:13:37.172733Z","url":"https://files.pythonhosted.org/packages/61/f2/74908ddbe57863007e3b3a76f39b509bbab9892d0949f1e9d5a888f8ec60/psutil-5.9.3-cp36-cp36m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"07d880053c6461c9b89cd5d4808f3b8336665fa3acdefd6777662c5ed73a851a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":286758,"upload-time":"2022-10-18T20:13:40.932526Z","url":"https://files.pythonhosted.org/packages/30/2f/696c4459864385cc5c63a21f30584dfd99d2130c21c8b3084ffbaa0edd82/psutil-5.9.3-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"data-dist-info-metadata":{"sha256":"0815ae21fa21e764d04c42f06a34a9f89e9b720a9d80f565b7943a08cf8e10ad"},"filename":"psutil-5.9.3-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"5e8b50241dd3c2ed498507f87a6602825073c07f3b7e9560c58411c14fe1e1c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":290363,"upload-time":"2022-10-18T20:13:43.847649Z","url":"https://files.pythonhosted.org/packages/2c/80/2f3072492a7f14faf4f4565dd26fe1baf4b3fd28557f1427b6708064a622/psutil-5.9.3-cp36-cp36m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"data-dist-info-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"filename":"psutil-5.9.3-cp36-cp36m-win32.whl","hashes":{"sha256":"828c9dc9478b34ab96be75c81942d8df0c2bb49edbb481f597314d92b6441d89"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244701,"upload-time":"2022-10-18T20:13:47.431806Z","url":"https://files.pythonhosted.org/packages/db/e3/10363d747d900f89f7920b8e4060b42cd862b580a69a2b9c9788c4de9035/psutil-5.9.3-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"data-dist-info-metadata":{"sha256":"2ef63858bce55082c5fb7e0b7dabc2fd37fc333286a4d4e5b64df61afb5235de"},"filename":"psutil-5.9.3-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ed15edb14f52925869250b1375f0ff58ca5c4fa8adefe4883cfb0737d32f5c02"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":249356,"upload-time":"2022-10-18T20:13:51.794050Z","url":"https://files.pythonhosted.org/packages/ac/cc/092ca7ae0c5f270bb14720cd8ac86a3fafda25fae31d08d2465eed4498b3/psutil-5.9.3-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-macosx_10_9_x86_64.whl","hashes":{"sha256":"d266cd05bd4a95ca1c2b9b5aac50d249cf7c94a542f47e0b22928ddf8b80d1ef"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242154,"upload-time":"2022-10-18T20:14:12.425822Z","url":"https://files.pythonhosted.org/packages/16/51/d431f7db3a3a44d9c03ec1681835a5de52d2f0bb7e28f29ecd806ccc46ec/psutil-5.9.3-cp37-cp37m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7e4939ff75149b67aef77980409f156f0082fa36accc475d45c705bb00c6c16a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":287383,"upload-time":"2022-10-18T20:14:15.962130Z","url":"https://files.pythonhosted.org/packages/94/b0/cd3be14dc74a6f262b1de296841a5141a794cc485d4e3af5c1c0ffc9b886/psutil-5.9.3-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"68fa227c32240c52982cb931801c5707a7f96dd8927f9102d6c7771ea1ff5698"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291396,"upload-time":"2022-10-18T20:14:19.855473Z","url":"https://files.pythonhosted.org/packages/5e/86/856aa554ec7eb843fb006ef125cf4543ee9058cb39ad09d131dd820c71f7/psutil-5.9.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp37-cp37m-win32.whl","hashes":{"sha256":"beb57d8a1ca0ae0eb3d08ccaceb77e1a6d93606f0e1754f0d60a6ebd5c288837"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243306,"upload-time":"2022-10-18T20:14:23.302434Z","url":"https://files.pythonhosted.org/packages/ab/10/547feeec01275dd544a389ba05ecb3c316015d4b402cc7b440ca2d98ebcd/psutil-5.9.3-cp37-cp37m-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp37-cp37m-win_amd64.whl","hashes":{"sha256":"12500d761ac091f2426567f19f95fd3f15a197d96befb44a5c1e3cbe6db5752c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247870,"upload-time":"2022-10-18T20:14:26.971453Z","url":"https://files.pythonhosted.org/packages/0c/f1/50e71c11ef14c592686dfc60e2b42a381fe57af2d22713e66a72c07cf9d1/psutil-5.9.3-cp37-cp37m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-macosx_10_9_x86_64.whl","hashes":{"sha256":"ba38cf9984d5462b506e239cf4bc24e84ead4b1d71a3be35e66dad0d13ded7c1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242611,"upload-time":"2022-10-18T20:14:30.842925Z","url":"https://files.pythonhosted.org/packages/01/d6/9ca99b416dddf4a49855a9ebf4af3a2db9526e94e9693da169fa5ed61788/psutil-5.9.3-cp38-cp38-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-macosx_11_0_arm64.whl","hashes":{"sha256":"46907fa62acaac364fff0b8a9da7b360265d217e4fdeaca0a2397a6883dffba2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243235,"upload-time":"2022-10-18T20:14:34.363643Z","url":"https://files.pythonhosted.org/packages/2c/ce/daf28e50305fdbba0754ba58ab0346ec6cfa41293110412f4c6bf74738bb/psutil-5.9.3-cp38-cp38-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"a04a1836894c8279e5e0a0127c0db8e198ca133d28be8a2a72b4db16f6cf99c1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291620,"upload-time":"2022-10-18T20:14:38.179697Z","url":"https://files.pythonhosted.org/packages/b9/cf/56278ae450741b6390491aecaa5f6152ff491bf00544799830e98340ff48/psutil-5.9.3-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"8a4e07611997acf178ad13b842377e3d8e9d0a5bac43ece9bfc22a96735d9a4f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":295598,"upload-time":"2022-10-18T20:14:41.691453Z","url":"https://files.pythonhosted.org/packages/af/5d/9c03a47af929fc12699fcf5174313744eef33a7b9e106e8111f57427b7d7/psutil-5.9.3-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp38-cp38-win32.whl","hashes":{"sha256":"6ced1ad823ecfa7d3ce26fe8aa4996e2e53fb49b7fed8ad81c80958501ec0619"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243663,"upload-time":"2022-10-18T20:14:45.084651Z","url":"https://files.pythonhosted.org/packages/69/3d/e1a12f505eb0171912b94e4689453639bb0deeb70ab4eddbc7b9266f819e/psutil-5.9.3-cp38-cp38-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp38-cp38-win_amd64.whl","hashes":{"sha256":"35feafe232d1aaf35d51bd42790cbccb882456f9f18cdc411532902370d660df"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":248005,"upload-time":"2022-10-18T20:14:48.240035Z","url":"https://files.pythonhosted.org/packages/69/cf/47a028bbb4589fdc0494bc60f134c73e319ec78c86c37e2dc66fd118e4db/psutil-5.9.3-cp38-cp38-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-macosx_10_9_x86_64.whl","hashes":{"sha256":"538fcf6ae856b5e12d13d7da25ad67f02113c96f5989e6ad44422cb5994ca7fc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242570,"upload-time":"2022-10-18T20:14:51.709705Z","url":"https://files.pythonhosted.org/packages/e5/64/ced1461fd5ebc944d90f9e471149991893bd7ede05b5a88069c1953738dc/psutil-5.9.3-cp39-cp39-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-macosx_11_0_arm64.whl","hashes":{"sha256":"a3d81165b8474087bb90ec4f333a638ccfd1d69d34a9b4a1a7eaac06648f9fbe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243242,"upload-time":"2022-10-18T20:14:54.641746Z","url":"https://files.pythonhosted.org/packages/ac/55/c108e74f22905382aeeef56110bd6c4b89b5fc64944d21cb83acb66faa4c/psutil-5.9.3-cp39-cp39-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"3a7826e68b0cf4ce2c1ee385d64eab7d70e3133171376cac53d7c1790357ec8f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":288533,"upload-time":"2022-10-18T20:14:57.902650Z","url":"https://files.pythonhosted.org/packages/db/6f/2441388c48306f9b9d561080c6ba652b4ebd1199faac237069ec8983c8ef/psutil-5.9.3-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"data-dist-info-metadata":{"sha256":"235e00601e80ff0d0cb06ce872f02a457343187ed6fdfb79f6f9f1302b209409"},"filename":"psutil-5.9.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"9ec296f565191f89c48f33d9544d8d82b0d2af7dd7d2d4e6319f27a818f8d1cc"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":291401,"upload-time":"2022-10-18T20:15:01.503982Z","url":"https://files.pythonhosted.org/packages/03/47/15604dd812b1b860e81cabaf8c930474c549773389170cd03a093ecf54b6/psutil-5.9.3-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp39-cp39-win32.whl","hashes":{"sha256":"9ec95df684583b5596c82bb380c53a603bb051cf019d5c849c47e117c5064395"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242954,"upload-time":"2022-10-18T20:15:04.992990Z","url":"https://files.pythonhosted.org/packages/2f/5e/c74dab9858ca67a68a543ad8fefac2aec107383c171019b45ba9ac5223c1/psutil-5.9.3-cp39-cp39-win32.whl","yanked":false},{"core-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"data-dist-info-metadata":{"sha256":"ddacf95a106563420486b913e49d19570b225ee95ad876d657e72d3df9c09536"},"filename":"psutil-5.9.3-cp39-cp39-win_amd64.whl","hashes":{"sha256":"4bd4854f0c83aa84a5a40d3b5d0eb1f3c128f4146371e03baed4589fe4f3c931"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247081,"upload-time":"2022-10-18T20:15:08.131670Z","url":"https://files.pythonhosted.org/packages/34/31/9aa19bf0fb0cecae904c9e1ac400c5704d935252515da605aa08fca2be86/psutil-5.9.3-cp39-cp39-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.3.tar.gz","hashes":{"sha256":"7ccfcdfea4fc4b0a02ca2c31de7fcd186beb9cff8207800e14ab66f79c773af6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":483579,"upload-time":"2022-10-18T20:15:11.635566Z","url":"https://files.pythonhosted.org/packages/de/eb/1c01a34c86ee3b058c556e407ce5b07cb7d186ebe47b3e69d6f152ca5cc5/psutil-5.9.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"c1ca331af862803a42677c120aff8a814a804e09832f166f226bfd22b56feee8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242993,"upload-time":"2022-11-07T18:44:23.237667Z","url":"https://files.pythonhosted.org/packages/60/f8/b92fecd5297edcecda825a04dfde7cb0a2ecd178eb976cb5a7956e375c6a/psutil-5.9.4-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"68908971daf802203f3d37e78d3f8831b6d1014864d7a85937941bb35f09aefe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":294126,"upload-time":"2022-11-07T18:44:28.809923Z","url":"https://files.pythonhosted.org/packages/8e/6b/9a3a5471b74d92dc85bfd71a7f7a55e013b258d86b4c3826ace9d49f7b8c/psutil-5.9.4-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"3ff89f9b835100a825b14c2808a106b6fdcc4b15483141482a12c725e7f78549"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":298394,"upload-time":"2022-11-07T18:44:34.503099Z","url":"https://files.pythonhosted.org/packages/1d/80/e1502ba4ff65390bd17b4612010762075f64f5a0e7c28e889c4820bd95a9/psutil-5.9.4-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"data-dist-info-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"filename":"psutil-5.9.4-cp27-cp27m-win32.whl","hashes":{"sha256":"852dd5d9f8a47169fe62fd4a971aa07859476c2ba22c2254d4a1baa4e10b95ad"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":242001,"upload-time":"2022-11-07T18:44:39.844844Z","url":"https://files.pythonhosted.org/packages/53/ae/536719016fe9399187dbf52cdc65aef942f82b75924495918a2f701bcb77/psutil-5.9.4-cp27-cp27m-win32.whl","yanked":false},{"core-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"data-dist-info-metadata":{"sha256":"8fc2f52ee81f3c31e5cf1d7031e3122056d1ec9de55bbc714417091f2e0c5d34"},"filename":"psutil-5.9.4-cp27-cp27m-win_amd64.whl","hashes":{"sha256":"9120cd39dca5c5e1c54b59a41d205023d436799b1c8c4d3ff71af18535728e94"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245334,"upload-time":"2022-11-07T18:44:44.877461Z","url":"https://files.pythonhosted.org/packages/99/9c/7a5761f9d2e79e6f781db5b25eeb9e74c2dc533bc52ee4749cb055a32ce9/psutil-5.9.4-cp27-cp27m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"6b92c532979bafc2df23ddc785ed116fced1f492ad90a6830cf24f4d1ea27d24"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":294138,"upload-time":"2022-11-07T18:44:49.025560Z","url":"https://files.pythonhosted.org/packages/ec/be/b8df2071eda861e65a1b2cec35770bb1f4523737e84a10aa41c53e39e9bc/psutil-5.9.4-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"data-dist-info-metadata":{"sha256":"2123949a577021ace561405ef01228f83e4c6d7ccd4ec38ded6fd271e4243960"},"filename":"psutil-5.9.4-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"efeae04f9516907be44904cc7ce08defb6b665128992a56957abc9b61dca94b7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":298409,"upload-time":"2022-11-07T18:44:56.505271Z","url":"https://files.pythonhosted.org/packages/89/a8/dd2f0866a7e87de751fb5f7c6eca99cbb953c81be76e1814ab3c8c3b0908/psutil-5.9.4-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"54d5b184728298f2ca8567bf83c422b706200bcbbfafdc06718264f9393cfeb7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243468,"upload-time":"2022-11-07T18:45:00.474371Z","url":"https://files.pythonhosted.org/packages/a5/73/35cea01aad1baf901c915dc95ea33a2f271c8ff8cf2f1c73b7f591f1bdf1/psutil-5.9.4-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"16653106f3b59386ffe10e0bad3bb6299e169d5327d3f187614b1cb8f24cf2e1"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":277515,"upload-time":"2022-11-07T18:45:05.428752Z","url":"https://files.pythonhosted.org/packages/5a/37/ef88eed265d93bc28c681316f68762c5e04167519e5627a0187c8878b409/psutil-5.9.4-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"data-dist-info-metadata":{"sha256":"fa7c88f96167219220d13bcc9fd94ae254e582adb547fdbb756d356aa9a18739"},"filename":"psutil-5.9.4-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"54c0d3d8e0078b7666984e11b12b88af2db11d11249a8ac8920dd5ef68a66e08"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":280218,"upload-time":"2022-11-07T18:45:11.831087Z","url":"https://files.pythonhosted.org/packages/6e/c8/784968329c1c67c28cce91991ef9af8a8913aa5a3399a6a8954b1380572f/psutil-5.9.4-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"data-dist-info-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"filename":"psutil-5.9.4-cp36-abi3-win32.whl","hashes":{"sha256":"149555f59a69b33f056ba1c4eb22bb7bf24332ce631c44a319cec09f876aaeff"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247217,"upload-time":"2022-11-08T11:50:03.989781Z","url":"https://files.pythonhosted.org/packages/3e/af/fe14b984e8b0f778d502d387b789d846cb2fcc3989f63be942741266d8c8/psutil-5.9.4-cp36-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"data-dist-info-metadata":{"sha256":"bca9c896f97136a7e608898e18955f0413786b5391cd3140eec51917f648c864"},"filename":"psutil-5.9.4-cp36-abi3-win_amd64.whl","hashes":{"sha256":"fd8522436a6ada7b4aad6638662966de0d61d241cb821239b2ae7013d41a43d4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":252462,"upload-time":"2022-11-08T11:50:07.829565Z","url":"https://files.pythonhosted.org/packages/25/6e/ba97809175c90cbdcd33b470e466ebf0854d15d1506e605cc0ddd284d5b6/psutil-5.9.4-cp36-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"3c3c1d22a00986e9736611ca6121b0926aba1c13b75f0b3509aebf5f95b0d409"},"data-dist-info-metadata":{"sha256":"3c3c1d22a00986e9736611ca6121b0926aba1c13b75f0b3509aebf5f95b0d409"},"filename":"psutil-5.9.4-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"6001c809253a29599bc0dfd5179d9f8a5779f9dffea1da0f13c53ee568115e1e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244234,"upload-time":"2022-11-07T19:53:20.872251Z","url":"https://files.pythonhosted.org/packages/79/26/f026804298b933b11640cc2d15155a545805df732e5ead3a2ad7cf45a38b/psutil-5.9.4-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.4.tar.gz","hashes":{"sha256":"3d7f9739eb435d4b1338944abe23f49584bde5395f27487d2ee25ad9a8774a62"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":485825,"upload-time":"2022-11-07T19:53:36.245577Z","url":"https://files.pythonhosted.org/packages/3d/7d/d05864a69e452f003c0d77e728e155a89a2a26b09e64860ddd70ad64fb26/psutil-5.9.4.tar.gz","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"be8929ce4313f9f8146caad4272f6abb8bf99fc6cf59344a3167ecd74f4f203f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":244852,"upload-time":"2023-04-17T18:24:26.646150Z","url":"https://files.pythonhosted.org/packages/3b/e4/fee119c206545fd37be1e5fa4eeb0c729a52ec2ade4f728ae1fd1acb2a3a/psutil-5.9.5-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"ab8ed1a1d77c95453db1ae00a3f9c50227ebd955437bcf2a574ba8adbf6a74d5"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":296014,"upload-time":"2023-04-17T18:24:31.346064Z","url":"https://files.pythonhosted.org/packages/8d/24/ed6b6506f187def39887a91a68e58336eff4cf3e3d5a163ded58bee98624/psutil-5.9.5-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"4aef137f3345082a3d3232187aeb4ac4ef959ba3d7c10c33dd73763fbc063da4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":300274,"upload-time":"2023-04-17T18:24:35.244779Z","url":"https://files.pythonhosted.org/packages/89/fa/ab117fa86195050802207639f5daee857791daaabe9a996935b5b77dbe10/psutil-5.9.5-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"ea8518d152174e1249c4f2a1c89e3e6065941df2fa13a1ab45327716a23c2b48"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":295979,"upload-time":"2023-04-17T18:24:38.850555Z","url":"https://files.pythonhosted.org/packages/99/f5/ec768e107445f18baa907509aaa0562a4d148a602bd97e8114d79bd6c84d/psutil-5.9.5-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"data-dist-info-metadata":{"sha256":"950f52c16a7bc656305be0171e1d567927034839d8c5af80880070db4ba278be"},"filename":"psutil-5.9.5-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"acf2aef9391710afded549ff602b5887d7a2349831ae4c26be7c807c0a39fac4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":300257,"upload-time":"2023-04-17T18:24:42.928863Z","url":"https://files.pythonhosted.org/packages/5f/da/de9d2342db0b7a96863ef84ab94ef1022eec78ece05aac253cddc494e1a7/psutil-5.9.5-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"data-dist-info-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"filename":"psutil-5.9.5-cp27-none-win32.whl","hashes":{"sha256":"5b9b8cb93f507e8dbaf22af6a2fd0ccbe8244bf30b1baad6b3954e935157ae3f"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":243956,"upload-time":"2023-04-17T18:24:46.410452Z","url":"https://files.pythonhosted.org/packages/cf/e3/6af6ec0cbe72f63e9a16d8b53590489e40ed0ff0c99b6a6f05d6af3bb80e/psutil-5.9.5-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"data-dist-info-metadata":{"sha256":"b8327a43c6d94aba442f903852217084687e619e3d853297d6743f1cd1a4fada"},"filename":"psutil-5.9.5-cp27-none-win_amd64.whl","hashes":{"sha256":"8c5f7c5a052d1d567db4ddd231a9d27a74e8e4a9c3f44b1032762bd7b9fdcd42"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":247338,"upload-time":"2023-04-17T18:24:49.089552Z","url":"https://files.pythonhosted.org/packages/26/f2/dcd8a3cc9c9b1fcd7576a54e3603ce4d1f85672f2687a44050340f7d47b0/psutil-5.9.5-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"3c6f686f4225553615612f6d9bc21f1c0e305f75d7d8454f9b46e901778e7217"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":245316,"upload-time":"2023-04-17T18:24:52.864585Z","url":"https://files.pythonhosted.org/packages/9a/76/c0195c3443a725c24b3a479f57636dec89efe53d19d435d1752c5188f7de/psutil-5.9.5-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"7a7dd9997128a0d928ed4fb2c2d57e5102bb6089027939f3b722f3a210f9a8da"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":279398,"upload-time":"2023-04-17T18:24:56.977087Z","url":"https://files.pythonhosted.org/packages/e5/2e/56db2b45508ad484b3f22888b3e1adaaf09b8766eaa058ed0e4486c1abae/psutil-5.9.5-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"89518112647f1276b03ca97b65cc7f64ca587b1eb0278383017c2a0dcc26cbe4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":282082,"upload-time":"2023-04-17T18:25:00.863664Z","url":"https://files.pythonhosted.org/packages/af/4d/389441079ecef400e2551a3933224885a7bde6b8a4810091d628cdd75afe/psutil-5.9.5-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-win32.whl","hashes":{"sha256":"104a5cc0e31baa2bcf67900be36acde157756b9c44017b86b2c049f11957887d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":249834,"upload-time":"2023-04-17T18:25:05.571829Z","url":"https://files.pythonhosted.org/packages/fa/e0/e91277b1cabf5c3f2995c22314553f1be68b17444260101f365c5a5b6ba1/psutil-5.9.5-cp36-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"data-dist-info-metadata":{"sha256":"612932ce0d3ae556043e5e9a609d33777fe6fb88556dd92d0e07cb53270d1db6"},"filename":"psutil-5.9.5-cp36-abi3-win_amd64.whl","hashes":{"sha256":"b258c0c1c9d145a1d5ceffab1134441c4c5113b2417fafff7315a917a026c3c9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":255148,"upload-time":"2023-04-17T18:25:09.779955Z","url":"https://files.pythonhosted.org/packages/86/f3/23e4e4e7ec7855d506ed928756b04735c246b14d9f778ed7ffaae18d8043/psutil-5.9.5-cp36-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2ae643bfca9fa3b942bf775226368a8ef859018ea312be94e137a8511ba0da07"},"data-dist-info-metadata":{"sha256":"2ae643bfca9fa3b942bf775226368a8ef859018ea312be94e137a8511ba0da07"},"filename":"psutil-5.9.5-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"c607bb3b57dc779d55e1554846352b4e358c10fff3abf3514a7a6601beebdb30"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":246094,"upload-time":"2023-04-17T18:25:14.584295Z","url":"https://files.pythonhosted.org/packages/ed/98/2624954f83489ab13fde2b544baa337d5578c07eee304d320d9ba56e1b1f/psutil-5.9.5-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.5.tar.gz","hashes":{"sha256":"5410638e4df39c54d957fc51ce03048acd8e6d60abc0f5107af51e5fb566eb3c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*","size":493489,"upload-time":"2023-04-17T18:25:18.787463Z","url":"https://files.pythonhosted.org/packages/d6/0f/96b7309212a926c1448366e9ce69b081ea79d63265bde33f11cc9cfc2c07/psutil-5.9.5.tar.gz","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"fb8a697f11b0f5994550555fcfe3e69799e5b060c8ecf9e2f75c69302cc35c0d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245665,"upload-time":"2023-10-15T09:08:50.362285Z","url":"https://files.pythonhosted.org/packages/84/d6/7e23b2b208db3953f630934bc0e9c1736a0a831a781acf8c5891c27b29cf/psutil-5.9.6-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"91ecd2d9c00db9817a4b4192107cf6954addb5d9d67a969a4f436dbc9200f88c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":297167,"upload-time":"2023-10-15T09:08:52.370112Z","url":"https://files.pythonhosted.org/packages/d2/76/f154e5169756f3d18da160359a404f49f476756809ef21a79afdd0d5b552/psutil-5.9.6-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"10e8c17b4f898d64b121149afb136c53ea8b68c7531155147867b7b1ac9e7e28"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":301338,"upload-time":"2023-10-15T09:08:55.187829Z","url":"https://files.pythonhosted.org/packages/35/e8/5cc0e149ec32a91d459fbe51d0ce3c2dd7f8d67bc1400803ff810247d6dc/psutil-5.9.6-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"18cd22c5db486f33998f37e2bb054cc62fd06646995285e02a51b1e08da97017"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":297167,"upload-time":"2023-10-15T09:08:57.863175Z","url":"https://files.pythonhosted.org/packages/8d/f7/074071fa91dab747c8d1fe2eb74da439b3712248d6b254ba0136ada8694f/psutil-5.9.6-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"data-dist-info-metadata":{"sha256":"03f47dbf7a696dbe30acaf142fc193530fe197d70ea954e60b2a6279946aca36"},"filename":"psutil-5.9.6-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"ca2780f5e038379e520281e4c032dddd086906ddff9ef0d1b9dcf00710e5071c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":301350,"upload-time":"2023-10-15T09:09:00.411072Z","url":"https://files.pythonhosted.org/packages/4a/65/557545149422a7845248641c1c35a0c8ea940c838896320f774072e16523/psutil-5.9.6-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"data-dist-info-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"filename":"psutil-5.9.6-cp27-none-win32.whl","hashes":{"sha256":"70cb3beb98bc3fd5ac9ac617a327af7e7f826373ee64c80efd4eb2856e5051e9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":244900,"upload-time":"2023-10-15T09:09:03.051464Z","url":"https://files.pythonhosted.org/packages/b8/23/d5d9e20c4ae7374abe1f826c69ecf2ab52f93827ca2b92c2c51f9aeb9226/psutil-5.9.6-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"data-dist-info-metadata":{"sha256":"cbf967d735616b8f7384d1cb095719fdf508b6e794f91eda3c559b9eff000943"},"filename":"psutil-5.9.6-cp27-none-win_amd64.whl","hashes":{"sha256":"51dc3d54607c73148f63732c727856f5febec1c7c336f8f41fcbd6315cce76ac"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248205,"upload-time":"2023-10-15T09:09:05.456917Z","url":"https://files.pythonhosted.org/packages/7a/5e/db765b94cb620c04aaea0cb03d8b589905e50ec278130d25646eead8dff0/psutil-5.9.6-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c69596f9fc2f8acd574a12d5f8b7b1ba3765a641ea5d60fb4736bf3c08a8214a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246101,"upload-time":"2023-10-15T09:09:08.012635Z","url":"https://files.pythonhosted.org/packages/f8/36/35b12441ba1bc6684c9215191f955415196ca57ca85d88e313bec7f2cf8e/psutil-5.9.6-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"92e0cc43c524834af53e9d3369245e6cc3b130e78e26100d1f63cdb0abeb3d3c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":280854,"upload-time":"2023-10-15T09:09:09.832401Z","url":"https://files.pythonhosted.org/packages/61/c8/e684dea1912943347922ab5c05efc94b4ff3d7470038e8afbe3941ef9efe/psutil-5.9.6-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"748c9dd2583ed86347ed65d0035f45fa8c851e8d90354c122ab72319b5f366f4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":283614,"upload-time":"2023-10-15T09:09:12.314910Z","url":"https://files.pythonhosted.org/packages/19/06/4e3fa3c1b79271e933c5ddbad3a48aa2c3d5f592a0fb7c037f3e0f619f4d/psutil-5.9.6-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-cp36m-win32.whl","hashes":{"sha256":"3ebf2158c16cc69db777e3c7decb3c0f43a7af94a60d72e87b2823aebac3d602"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":250445,"upload-time":"2023-10-15T09:09:14.942143Z","url":"https://files.pythonhosted.org/packages/3f/63/d4a8dace1756b9c84b94683aa80ed0ba8fc7a4421904933b472d59268976/psutil-5.9.6-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"data-dist-info-metadata":{"sha256":"2e9d8110f5906489070a50d523dc29d42ccde7cff56677d3b49eae7ac8f23006"},"filename":"psutil-5.9.6-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"ff18b8d1a784b810df0b0fff3bcb50ab941c3b8e2c8de5726f9c71c601c611aa"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255893,"upload-time":"2023-10-15T09:09:17.467925Z","url":"https://files.pythonhosted.org/packages/ad/00/c87d449746f8962eb9203554b46ab7dcf243be236dcf007372902791b374/psutil-5.9.6-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"data-dist-info-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"filename":"psutil-5.9.6-cp37-abi3-win32.whl","hashes":{"sha256":"a6f01f03bf1843280f4ad16f4bde26b817847b4c1a0db59bf6419807bc5ce05c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248489,"upload-time":"2023-10-15T09:09:19.912001Z","url":"https://files.pythonhosted.org/packages/06/ac/f31a0faf98267e63fc6ed046ad2aca68bd79521380026e92fd4921c869aa/psutil-5.9.6-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"data-dist-info-metadata":{"sha256":"3eb79e7ee359462d9b616150575b67510adf8a297f3b4c2b93aeb95daef17fb8"},"filename":"psutil-5.9.6-cp37-abi3-win_amd64.whl","hashes":{"sha256":"6e5fb8dc711a514da83098bc5234264e551ad980cec5f85dabf4d38ed6f15e9a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":252327,"upload-time":"2023-10-15T09:09:32.052033Z","url":"https://files.pythonhosted.org/packages/c5/b2/699c50fe0b0402a1ccb64ad71313bcb740e735008dd3ab9abeddbe148e45/psutil-5.9.6-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7298b90db12439da117e2817e35cbbb00312edeb4f885274cd1135a533903d6c"},"data-dist-info-metadata":{"sha256":"7298b90db12439da117e2817e35cbbb00312edeb4f885274cd1135a533903d6c"},"filename":"psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"daecbcbd29b289aac14ece28eca6a3e60aa361754cf6da3dfb20d4d32b6c7f57"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246859,"upload-time":"2023-10-15T09:09:34.494297Z","url":"https://files.pythonhosted.org/packages/9e/cb/e4b83c27eea66bc255effc967053f6fce7c14906dd9b43a348ead9f0cfea/psutil-5.9.6-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.6.tar.gz","hashes":{"sha256":"e4b92ddcd7dd4cdd3f900180ea1e104932c7bce234fb88976e2a3b296441225a"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":496866,"upload-time":"2023-10-15T09:08:46.623978Z","url":"https://files.pythonhosted.org/packages/2d/01/beb7331fc6c8d1c49dd051e3611379bfe379e915c808e1301506027fce9d/psutil-5.9.6.tar.gz","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"0bd41bf2d1463dfa535942b2a8f0e958acf6607ac0be52265ab31f7923bcd5e6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245542,"upload-time":"2023-12-17T11:25:25.875219Z","url":"https://files.pythonhosted.org/packages/3e/16/c86fcf73f02bd0a3d49b0dcabc8ebd4020647be2ea40ff668f717587af97/psutil-5.9.7-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"5794944462509e49d4d458f4dbfb92c47539e7d8d15c796f141f474010084056"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312042,"upload-time":"2023-12-17T11:25:29.439835Z","url":"https://files.pythonhosted.org/packages/93/fc/e45a8e9b2acd54fe80ededa2f7b19de21e776f64e00437417c16c3e139d9/psutil-5.9.7-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"fe361f743cb3389b8efda21980d93eb55c1f1e3898269bc9a2a1d0bb7b1f6508"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312681,"upload-time":"2023-12-17T11:25:33.024609Z","url":"https://files.pythonhosted.org/packages/d7/43/dd7034a3a3a900e95b9dcf47ee710680cfd11a224ab18b31c34370da36a8/psutil-5.9.7-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"e469990e28f1ad738f65a42dcfc17adaed9d0f325d55047593cb9033a0ab63df"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312066,"upload-time":"2023-12-17T11:25:37.010306Z","url":"https://files.pythonhosted.org/packages/ff/ea/a47eecddcd97d65b496ac655c9f9ba8af270c203d5ea1630273cfc5ec740/psutil-5.9.7-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"data-dist-info-metadata":{"sha256":"bee12356aebb79b07f3adec05e4a7e1cad1a4e76f3cbf8f7617b97d7598ed4e8"},"filename":"psutil-5.9.7-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"3c4747a3e2ead1589e647e64aad601981f01b68f9398ddf94d01e3dc0d1e57c7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":312684,"upload-time":"2023-12-17T11:25:39.891899Z","url":"https://files.pythonhosted.org/packages/cd/ee/d946d0b758120e724d9cdd9607c304ff1eedb9380bf60597c295dc7def6b/psutil-5.9.7-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"data-dist-info-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"filename":"psutil-5.9.7-cp27-none-win32.whl","hashes":{"sha256":"1d4bc4a0148fdd7fd8f38e0498639ae128e64538faa507df25a20f8f7fb2341c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":244785,"upload-time":"2023-12-17T11:25:42.761256Z","url":"https://files.pythonhosted.org/packages/98/c5/6773a3f1c384ac4863665e167cd4da72433b3020580c0b7c6a7b497e11e2/psutil-5.9.7-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"data-dist-info-metadata":{"sha256":"e17b0155d6125da908d40f364ab8665d24296d45f194128d7d4fee06adf24366"},"filename":"psutil-5.9.7-cp27-none-win_amd64.whl","hashes":{"sha256":"4c03362e280d06bbbfcd52f29acd79c733e0af33d707c54255d21029b8b32ba6"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248087,"upload-time":"2023-12-17T11:25:45.316036Z","url":"https://files.pythonhosted.org/packages/2d/91/40ac017db38c9f7f325385dd0dab1be3d4c65e3291100e74d5d7b6a213e8/psutil-5.9.7-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"ea36cc62e69a13ec52b2f625c27527f6e4479bca2b340b7a452af55b34fcbe2e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":245972,"upload-time":"2023-12-17T11:25:48.202730Z","url":"https://files.pythonhosted.org/packages/6c/63/86a4ccc640b4ee1193800f57bbd20b766853c0cdbdbb248a27cdfafe6cbf/psutil-5.9.7-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"1132704b876e58d277168cd729d64750633d5ff0183acf5b3c986b8466cd0284"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":282514,"upload-time":"2023-12-17T11:25:51.371460Z","url":"https://files.pythonhosted.org/packages/58/80/cc6666b3968646f2d94de66bbc63d701d501f4aa04de43dd7d1f5dc477dd/psutil-5.9.7-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"fe8b7f07948f1304497ce4f4684881250cd859b16d06a1dc4d7941eeb6233bfe"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":285469,"upload-time":"2023-12-17T11:25:54.250669Z","url":"https://files.pythonhosted.org/packages/be/fa/f1f626620e3b47e6237dcc64cb8cc1472f139e99422e5b9fa5bbcf457f48/psutil-5.9.7-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-cp36m-win32.whl","hashes":{"sha256":"b27f8fdb190c8c03914f908a4555159327d7481dac2f01008d483137ef3311a9"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":250357,"upload-time":"2023-12-17T12:38:23.681291Z","url":"https://files.pythonhosted.org/packages/63/16/11dfb52cdccd561da711ee2c127b4c0bd2baf4736d10828c707694f31b90/psutil-5.9.7-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"data-dist-info-metadata":{"sha256":"75f8cc7702054674e6edcb7c6c070053f879e044c73942a152279c8d35fec61c"},"filename":"psutil-5.9.7-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"44969859757f4d8f2a9bd5b76eba8c3099a2c8cf3992ff62144061e39ba8568e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255808,"upload-time":"2023-12-17T12:38:34.170079Z","url":"https://files.pythonhosted.org/packages/0e/88/9b74b25c63b91ff0403a1b89e258238380b4a88e4116cbae4eaadbb4c17a/psutil-5.9.7-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"data-dist-info-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"filename":"psutil-5.9.7-cp37-abi3-win32.whl","hashes":{"sha256":"c727ca5a9b2dd5193b8644b9f0c883d54f1248310023b5ad3e92036c5e2ada68"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248406,"upload-time":"2023-12-17T12:38:50.326952Z","url":"https://files.pythonhosted.org/packages/7c/b8/dc6ebfc030b47cccc5f5229eeb15e64142b4782796c3ce169ccd60b4d511/psutil-5.9.7-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"data-dist-info-metadata":{"sha256":"8eee389ea25ebe96edb28822645ab1709ede8c32315d59c0c91214e32d607b8e"},"filename":"psutil-5.9.7-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f37f87e4d73b79e6c5e749440c3113b81d1ee7d26f21c19c47371ddea834f414"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":252245,"upload-time":"2023-12-17T12:39:00.686632Z","url":"https://files.pythonhosted.org/packages/50/28/92b74d95dd991c837813ffac0c79a581a3d129eb0fa7c1dd616d9901e0f3/psutil-5.9.7-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c6272489f71a5b9474dff03296e3f8e100ef6f8ed990f7e4ef444ac6e6a3d6fb"},"data-dist-info-metadata":{"sha256":"c6272489f71a5b9474dff03296e3f8e100ef6f8ed990f7e4ef444ac6e6a3d6fb"},"filename":"psutil-5.9.7-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"032f4f2c909818c86cea4fe2cc407f1c0f0cde8e6c6d702b28b8ce0c0d143340"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":246739,"upload-time":"2023-12-17T11:25:57.305436Z","url":"https://files.pythonhosted.org/packages/ba/8a/000d0e80156f0b96c55bda6c60f5ed6543d7b5e893ccab83117e50de1400/psutil-5.9.7-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.7.tar.gz","hashes":{"sha256":"3f02134e82cfb5d089fddf20bb2e03fd5cd52395321d1c8458a9e58500ff417c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":498429,"upload-time":"2023-12-17T11:25:21.220127Z","url":"https://files.pythonhosted.org/packages/a0/d0/c9ae661a302931735237791f04cb7086ac244377f78692ba3b3eae3a9619/psutil-5.9.7.tar.gz","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248274,"upload-time":"2024-01-19T20:47:14.006890Z","url":"https://files.pythonhosted.org/packages/15/9a/c3e2922e2d672bafd37cf3b9681097c350463cdcf0e286e907ddd6cfb014/psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":314796,"upload-time":"2024-01-19T20:47:17.872998Z","url":"https://files.pythonhosted.org/packages/62/e6/6d62285989d53a83def28ea49b46d3e00462d1273c7c47d9678ee28a0a39/psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":315422,"upload-time":"2024-01-19T20:47:21.442877Z","url":"https://files.pythonhosted.org/packages/38/ba/41815f353f79374c1ad82aba998c666c7209793daf12f4799cfaa7302f29/psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":314802,"upload-time":"2024-01-19T20:47:24.219052Z","url":"https://files.pythonhosted.org/packages/a8/2f/ad80cc502c452e1f207307a7d53533505ca47c503ec6e9f7e2c9fbb367e8/psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"data-dist-info-metadata":{"sha256":"8da6995843b9daa47e0867912881271ea684ac8d0bcb3aee77791084ee8c0be4"},"filename":"psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":315420,"upload-time":"2024-01-19T20:47:26.828052Z","url":"https://files.pythonhosted.org/packages/e4/c3/357a292dee683282f7a46b752a76c5d56c78bf8f5d9def0ca0d39073344a/psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"data-dist-info-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"filename":"psutil-5.9.8-cp27-none-win32.whl","hashes":{"sha256":"36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248660,"upload-time":"2024-01-19T20:47:29.706532Z","url":"https://files.pythonhosted.org/packages/fe/5f/c26deb822fd3daf8fde4bdb658bf87d9ab1ffd3fca483816e89a9a9a9084/psutil-5.9.8-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"data-dist-info-metadata":{"sha256":"bcd64b1f8b81a5a0ea3cff661abf5d6e3a937f442bb982b9bdcddbfd8608aa9c"},"filename":"psutil-5.9.8-cp27-none-win_amd64.whl","hashes":{"sha256":"bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":251966,"upload-time":"2024-01-19T20:47:33.134054Z","url":"https://files.pythonhosted.org/packages/32/1d/cf66073d74d6146187e2d0081a7616df4437214afa294ee4f16f80a2f96a/psutil-5.9.8-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":248702,"upload-time":"2024-01-19T20:47:36.303498Z","url":"https://files.pythonhosted.org/packages/e7/e3/07ae864a636d70a8a6f58da27cb1179192f1140d5d1da10886ade9405797/psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":285242,"upload-time":"2024-01-19T20:47:39.650099Z","url":"https://files.pythonhosted.org/packages/b3/bd/28c5f553667116b2598b9cc55908ec435cb7f77a34f2bff3e3ca765b0f78/psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":288191,"upload-time":"2024-01-19T20:47:43.078208Z","url":"https://files.pythonhosted.org/packages/c5/4f/0e22aaa246f96d6ac87fe5ebb9c5a693fbe8877f537a1022527c47ca43c5/psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-cp36m-win32.whl","hashes":{"sha256":"7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":253203,"upload-time":"2024-01-19T20:47:46.133427Z","url":"https://files.pythonhosted.org/packages/dd/9e/85c3bd5b466d96c091bbd6339881e99106adb43d5d60bde32ac181ab6fef/psutil-5.9.8-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"data-dist-info-metadata":{"sha256":"19f679f9f89daead325ce0a0c8de1fba70a554793a47fcdf273fb714ac742a35"},"filename":"psutil-5.9.8-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":258655,"upload-time":"2024-01-19T20:47:48.804624Z","url":"https://files.pythonhosted.org/packages/0b/58/bcffb5ab03ec558e565d2871c01215dde74e11f583fb71e7d2b107200caa/psutil-5.9.8-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"data-dist-info-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"filename":"psutil-5.9.8-cp37-abi3-win32.whl","hashes":{"sha256":"bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":251252,"upload-time":"2024-01-19T20:47:52.880124Z","url":"https://files.pythonhosted.org/packages/6e/f5/2aa3a4acdc1e5940b59d421742356f133185667dd190b166dbcfcf5d7b43/psutil-5.9.8-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"data-dist-info-metadata":{"sha256":"949401d7571a13b3b43062a6c13b80a2a1361c3da4af20751f844e6ee3750021"},"filename":"psutil-5.9.8-cp37-abi3-win_amd64.whl","hashes":{"sha256":"8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":255090,"upload-time":"2024-01-19T20:47:56.019799Z","url":"https://files.pythonhosted.org/packages/93/52/3e39d26feae7df0aa0fd510b14012c3678b36ed068f7d78b8d8784d61f0e/psutil-5.9.8-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"1526b4912f0f04a9c6523b41c128f4d1c6c666fbbdccb62c6705d7e5747c95cc"},"data-dist-info-metadata":{"sha256":"1526b4912f0f04a9c6523b41c128f4d1c6c666fbbdccb62c6705d7e5747c95cc"},"filename":"psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":249898,"upload-time":"2024-01-19T20:47:59.238740Z","url":"https://files.pythonhosted.org/packages/05/33/2d74d588408caedd065c2497bdb5ef83ce6082db01289a1e1147f6639802/psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-5.9.8.tar.gz","hashes":{"sha256":"6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"},"provenance":null,"requires-python":">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*","size":503247,"upload-time":"2024-01-19T20:47:09.517227Z","url":"https://files.pythonhosted.org/packages/90/c7/6dc0a455d111f68ee43f27793971cf03fe29b6ef972042549db29eec39a2/psutil-5.9.8.tar.gz","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250527,"upload-time":"2024-06-18T21:40:17.061973Z","url":"https://files.pythonhosted.org/packages/13/e5/35ebd7169008752be5561cafdba3f1634be98193b85fe3d22e883f9fe2e1/psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":316838,"upload-time":"2024-06-18T21:40:32.679396Z","url":"https://files.pythonhosted.org/packages/92/a7/083388ef0964a6d74df51c677b3d761e0866d823d37e3a8823551c0d375d/psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":317493,"upload-time":"2024-06-18T21:40:41.710402Z","url":"https://files.pythonhosted.org/packages/52/2f/44b7005f306ea8bfd24aa662b5d0ba6ea1daf29dbd0b6c7bbcd3606373ad/psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":316855,"upload-time":"2024-06-18T21:40:47.752750Z","url":"https://files.pythonhosted.org/packages/81/c9/8cb36769b6636d817be3414ebbb27a9ab3fbe6d13835d00f31e77e1fccce/psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"data-dist-info-metadata":{"sha256":"c8301b547ede1d12db293b91c2eda41064442de769d8466cfdb34279587226a9"},"filename":"psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":317519,"upload-time":"2024-06-18T21:40:53.708954Z","url":"https://files.pythonhosted.org/packages/14/c0/024ac5369ca160e9ed45ed09247d9d779c460017fbd9aa801fd6eb0f060c/psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"data-dist-info-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"filename":"psutil-6.0.0-cp27-none-win32.whl","hashes":{"sha256":"02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":249766,"upload-time":"2024-06-18T21:40:58.381272Z","url":"https://files.pythonhosted.org/packages/c5/66/78c9c3020f573c58101dc43a44f6855d01bbbd747e24da2f0c4491200ea3/psutil-6.0.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"data-dist-info-metadata":{"sha256":"30df484959758f1144d54b7788b34cc3dde563aa4d6853a6e549f2f022b23c5e"},"filename":"psutil-6.0.0-cp27-none-win_amd64.whl","hashes":{"sha256":"21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":253024,"upload-time":"2024-06-18T21:41:04.548455Z","url":"https://files.pythonhosted.org/packages/e1/3f/2403aa9558bea4d3854b0e5e567bc3dd8e9fbc1fc4453c0aa9aafeb75467/psutil-6.0.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250961,"upload-time":"2024-06-18T21:41:11.662513Z","url":"https://files.pythonhosted.org/packages/0b/37/f8da2fbd29690b3557cca414c1949f92162981920699cd62095a984983bf/psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287478,"upload-time":"2024-06-18T21:41:16.180526Z","url":"https://files.pythonhosted.org/packages/35/56/72f86175e81c656a01c4401cd3b1c923f891b31fbcebe98985894176d7c9/psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":290455,"upload-time":"2024-06-18T21:41:29.048203Z","url":"https://files.pythonhosted.org/packages/19/74/f59e7e0d392bc1070e9a70e2f9190d652487ac115bb16e2eff6b22ad1d24/psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":292046,"upload-time":"2024-06-18T21:41:33.530555Z","url":"https://files.pythonhosted.org/packages/cd/5f/60038e277ff0a9cc8f0c9ea3d0c5eb6ee1d2470ea3f9389d776432888e47/psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-cp36m-win32.whl","hashes":{"sha256":"fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":255537,"upload-time":"2024-06-18T21:41:38.034852Z","url":"https://files.pythonhosted.org/packages/cd/ff/39c38910cdb8f02fc9965afb520967a1e9307d53d14879dddd0a4f41f6f8/psutil-6.0.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"data-dist-info-metadata":{"sha256":"cce2895e87556b6152233398a38cd33b9b0712906393b6834b1448aec0a505ca"},"filename":"psutil-6.0.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":260973,"upload-time":"2024-06-18T21:41:41.566213Z","url":"https://files.pythonhosted.org/packages/08/88/16dd53af4a84e719e27a5ad7db040231415d8caeb48f019bacafbb4d0002/psutil-6.0.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"data-dist-info-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"filename":"psutil-6.0.0-cp37-abi3-win32.whl","hashes":{"sha256":"a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":253560,"upload-time":"2024-06-18T21:41:46.067057Z","url":"https://files.pythonhosted.org/packages/8b/20/2ff69ad9c35c3df1858ac4e094f20bd2374d33c8643cf41da8fd7cdcb78b/psutil-6.0.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"data-dist-info-metadata":{"sha256":"9e9a9bbc68eaa4d9f9716cef6b0d5f90d4d57007c2008e7301c292c7714a6abc"},"filename":"psutil-6.0.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":257399,"upload-time":"2024-06-18T21:41:52.100137Z","url":"https://files.pythonhosted.org/packages/73/44/561092313ae925f3acfaace6f9ddc4f6a9c748704317bad9c8c8f8a36a79/psutil-6.0.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"c0710bf31d8e9160c90747acceb7692596b32d632efd784e22990fc01fad42dd"},"data-dist-info-metadata":{"sha256":"c0710bf31d8e9160c90747acceb7692596b32d632efd784e22990fc01fad42dd"},"filename":"psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":251988,"upload-time":"2024-06-18T21:41:57.337231Z","url":"https://files.pythonhosted.org/packages/7c/06/63872a64c312a24fb9b4af123ee7007a306617da63ff13bcc1432386ead7/psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.0.0.tar.gz","hashes":{"sha256":"8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508067,"upload-time":"2024-06-18T21:40:10.559591Z","url":"https://files.pythonhosted.org/packages/18/c7/8c6872f7372eb6a6b2e4708b88419fb46b857f7a2e1892966b851cc79fc9/psutil-6.0.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"ff34df86226c0227c52f38b919213157588a678d049688eded74c76c8ba4a5d0"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247385,"upload-time":"2024-10-17T21:31:49.162372Z","url":"https://files.pythonhosted.org/packages/cd/8e/87b51bedb52f0fa02a6c9399702912a5059b24c7242fa8ea4fd027cb5238/psutil-6.1.0-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"c0e0c00aa18ca2d3b2b991643b799a15fc8f0563d2ebb6040f64ce8dc027b942"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312067,"upload-time":"2024-10-17T21:31:51.572046Z","url":"https://files.pythonhosted.org/packages/2c/56/99304ecbf1f25a2aa336c66e43a8f9462de70d089d3fbb487991dfd96b37/psutil-6.1.0-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"000d1d1ebd634b4efb383f4034437384e44a6d455260aaee2eca1e9c1b55f047"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312345,"upload-time":"2024-10-17T21:31:53.950865Z","url":"https://files.pythonhosted.org/packages/24/87/7c1eeb2fd86a8eb792b15438a3d25eda05c970924df3457669b50e0c022b/psutil-6.1.0-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"5cd2bcdc75b452ba2e10f0e8ecc0b57b827dd5d7aaffbc6821b2a9a242823a76"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312058,"upload-time":"2024-10-17T21:31:55.843636Z","url":"https://files.pythonhosted.org/packages/aa/fe/c94a914040c74b2bbe2ddb2c82b3f9a74d8a40401bb1239b0e949331c957/psutil-6.1.0-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"data-dist-info-metadata":{"sha256":"c1b2df70b2192969ac8cec0847acb78d7ddd669a788780aad80d1133c89c4a43"},"filename":"psutil-6.1.0-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"045f00a43c737f960d273a83973b2511430d61f283a44c96bf13a6e829ba8fdc"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312330,"upload-time":"2024-10-17T21:31:57.551704Z","url":"https://files.pythonhosted.org/packages/44/8c/624823d5a5a9ec8635d63b273c3ab1554a4fcc3513f4d0236ff9706f1025/psutil-6.1.0-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"data-dist-info-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"filename":"psutil-6.1.0-cp27-none-win32.whl","hashes":{"sha256":"9118f27452b70bb1d9ab3198c1f626c2499384935aaf55388211ad982611407e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":246648,"upload-time":"2024-10-17T21:31:59.369185Z","url":"https://files.pythonhosted.org/packages/da/2b/f4dea5d993d9cd22ad958eea828a41d5d225556123d372f02547c29c4f97/psutil-6.1.0-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"data-dist-info-metadata":{"sha256":"6449e5b027e55d1dc345bb3b5089a60a968abd4f30577107504c292168ff86ea"},"filename":"psutil-6.1.0-cp27-none-win_amd64.whl","hashes":{"sha256":"a8506f6119cff7015678e2bce904a4da21025cc70ad283a53b099e7620061d85"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":249905,"upload-time":"2024-10-17T21:32:01.974050Z","url":"https://files.pythonhosted.org/packages/9f/14/4aa97a7f2e0ac33a050d990ab31686d651ae4ef8c86661fef067f00437b9/psutil-6.1.0-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"6e2dcd475ce8b80522e51d923d10c7871e45f20918e027ab682f94f1c6351688"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247762,"upload-time":"2024-10-17T21:32:05.991637Z","url":"https://files.pythonhosted.org/packages/01/9e/8be43078a171381953cfee33c07c0d628594b5dbfc5157847b85022c2c1b/psutil-6.1.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"31aa42573bd48a390acf1e517f08ce9f05a4954542dc8afb9a8805655df7aa18"},"data-dist-info-metadata":{"sha256":"31aa42573bd48a390acf1e517f08ce9f05a4954542dc8afb9a8805655df7aa18"},"filename":"psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"0895b8414afafc526712c498bd9de2b063deaac4021a3b3c34566283464aff8e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":248777,"upload-time":"2024-10-17T21:32:07.872442Z","url":"https://files.pythonhosted.org/packages/1d/cb/313e80644ea407f04f6602a9e23096540d9dc1878755f3952ea8d3d104be/psutil-6.1.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"9dcbfce5d89f1d1f2546a2090f4fcf87c7f669d1d90aacb7d7582addece9fb38"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":284259,"upload-time":"2024-10-17T21:32:10.177301Z","url":"https://files.pythonhosted.org/packages/65/8e/bcbe2025c587b5d703369b6a75b65d41d1367553da6e3f788aff91eaf5bd/psutil-6.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"498c6979f9c6637ebc3a73b3f87f9eb1ec24e1ce53a7c5173b8508981614a90b"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287255,"upload-time":"2024-10-17T21:32:11.964687Z","url":"https://files.pythonhosted.org/packages/58/4d/8245e6f76a93c98aab285a43ea71ff1b171bcd90c9d238bf81f7021fb233/psutil-6.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"data-dist-info-metadata":{"sha256":"f6ba356ca54ff4137597ca1c9c55cca6c6ccfd672a0c976cc370711d0a2652e8"},"filename":"psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"d905186d647b16755a800e7263d43df08b790d709d575105d419f8b6ef65423a"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":288804,"upload-time":"2024-10-17T21:32:13.785068Z","url":"https://files.pythonhosted.org/packages/27/c2/d034856ac47e3b3cdfa9720d0e113902e615f4190d5d1bdb8df4b2015fb2/psutil-6.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"data-dist-info-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"filename":"psutil-6.1.0-cp36-cp36m-win32.whl","hashes":{"sha256":"6d3fbbc8d23fcdcb500d2c9f94e07b1342df8ed71b948a2649b5cb060a7c94ca"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":252360,"upload-time":"2024-10-17T21:32:16.434334Z","url":"https://files.pythonhosted.org/packages/43/39/414d7b67f4df35bb9c373d0fb9a75dd40b223d9bd6d02ebdc7658fd461a3/psutil-6.1.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"data-dist-info-metadata":{"sha256":"4a33e7577c0dd3577291121b5beb777de2767238e7d66ad068c92fd37d3f3d6a"},"filename":"psutil-6.1.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1209036fbd0421afde505a4879dee3b2fd7b1e14fee81c0069807adcbbcca747"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":257797,"upload-time":"2024-10-17T21:32:18.946615Z","url":"https://files.pythonhosted.org/packages/ca/da/ef86c99e33be4aa888570e79350caca8c4819b62f84a6d9274c88c40e331/psutil-6.1.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"data-dist-info-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"filename":"psutil-6.1.0-cp37-abi3-win32.whl","hashes":{"sha256":"1ad45a1f5d0b608253b11508f80940985d1d0c8f6111b5cb637533a0e6ddc13e"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250386,"upload-time":"2024-10-17T21:32:21.399329Z","url":"https://files.pythonhosted.org/packages/ea/55/5389ed243c878725feffc0d6a3bc5ef6764312b6fc7c081faaa2cfa7ef37/psutil-6.1.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"data-dist-info-metadata":{"sha256":"7fdb0cc933f96b13edc5fc4b2255851b3a0222e29777763dd064aaeacaed9cb6"},"filename":"psutil-6.1.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"a8fb3752b491d246034fa4d279ff076501588ce8cbcdbb62c32fd7a377d996be"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":254228,"upload-time":"2024-10-17T21:32:23.880601Z","url":"https://files.pythonhosted.org/packages/11/91/87fa6f060e649b1e1a7b19a4f5869709fbf750b7c8c262ee776ec32f3028/psutil-6.1.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.1.0.tar.gz","hashes":{"sha256":"353815f59a7f64cdaca1c0307ee13558a0512f6db064e92fe833784f08539c7a"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508565,"upload-time":"2024-10-17T21:31:45.680545Z","url":"https://files.pythonhosted.org/packages/26/10/2a30b13c61e7cf937f4adf90710776b7918ed0a9c434e2c38224732af310/psutil-6.1.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl","hashes":{"sha256":"9ccc4316f24409159897799b83004cb1e24f9819b0dcf9c0b68bdcb6cefee6a8"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247226,"upload-time":"2024-12-19T18:21:25.276122Z","url":"https://files.pythonhosted.org/packages/09/ea/f8844afff4c8c11d1d0586b737d8d579fd7cb13f1fa3eea599c71877b526/psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl","hashes":{"sha256":"ca9609c77ea3b8481ab005da74ed894035936223422dc591d6772b147421f777"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312292,"upload-time":"2024-12-19T18:21:30.930117Z","url":"https://files.pythonhosted.org/packages/51/f8/e376f9410beb915bbf64cb4ae8ce5cf2d03e9a661a2519ebc6a63045a1ca/psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27m-manylinux2010_x86_64.whl","hashes":{"sha256":"8df0178ba8a9e5bc84fed9cfa61d54601b371fbec5c8eebad27575f1e105c0d4"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312542,"upload-time":"2024-12-19T18:21:34.735400Z","url":"https://files.pythonhosted.org/packages/a7/3a/069d6c1e4a7af3cdb162c9ba0737ff9baed1d05cbab6f082f49e3b9ab0a5/psutil-6.1.1-cp27-cp27m-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27mu-manylinux2010_i686.whl","hashes":{"sha256":"1924e659d6c19c647e763e78670a05dbb7feaf44a0e9c94bf9e14dfc6ba50468"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312279,"upload-time":"2024-12-19T18:21:37.897094Z","url":"https://files.pythonhosted.org/packages/81/d5/ee5de2cb8d0c938bb07dcccd4ff7e950359bd6ddbd2fe3118552f863bb52/psutil-6.1.1-cp27-cp27mu-manylinux2010_i686.whl","yanked":false},{"core-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"data-dist-info-metadata":{"sha256":"b63844c7465e7a965b315aaeaab5c82b781f31476c21c62e1c9a135bceff2115"},"filename":"psutil-6.1.1-cp27-cp27mu-manylinux2010_x86_64.whl","hashes":{"sha256":"018aeae2af92d943fdf1da6b58665124897cfc94faa2ca92098838f83e1b1bca"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":312521,"upload-time":"2024-12-19T18:21:40.651860Z","url":"https://files.pythonhosted.org/packages/37/98/443eff82762b3f2c6a4bd0cdf3bc5c9f62245376c5486b39ee194e920794/psutil-6.1.1-cp27-cp27mu-manylinux2010_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"data-dist-info-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"filename":"psutil-6.1.1-cp27-none-win32.whl","hashes":{"sha256":"6d4281f5bbca041e2292be3380ec56a9413b790579b8e593b1784499d0005dac"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":246855,"upload-time":"2024-12-19T18:54:12.657947Z","url":"https://files.pythonhosted.org/packages/d2/d4/8095b53c4950f44dc99b8d983b796f405ae1f58d80978fcc0421491b4201/psutil-6.1.1-cp27-none-win32.whl","yanked":false},{"core-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"data-dist-info-metadata":{"sha256":"55f120e7e066d74e328c2e0d559aa667c611e9e63f5a1bc5cae3d034db0be644"},"filename":"psutil-6.1.1-cp27-none-win_amd64.whl","hashes":{"sha256":"c777eb75bb33c47377c9af68f30e9f11bc78e0f07fbf907be4a5d70b2fe5f030"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250110,"upload-time":"2024-12-19T18:54:16.635901Z","url":"https://files.pythonhosted.org/packages/b1/63/0b6425ea4f2375988209a9934c90d6079cc7537847ed58a28fbe30f4277e/psutil-6.1.1-cp27-none-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"fc0ed7fe2231a444fc219b9c42d0376e0a9a1a72f16c5cfa0f68d19f1a0663e8"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":247511,"upload-time":"2024-12-19T18:21:45.163741Z","url":"https://files.pythonhosted.org/packages/61/99/ca79d302be46f7bdd8321089762dd4476ee725fce16fc2b2e1dbba8cac17/psutil-6.1.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"f53aa914fe0e63af2de701b5d7b1c28a494b1852f4eddac6bec1c1d8eecc00d7"},"data-dist-info-metadata":{"sha256":"f53aa914fe0e63af2de701b5d7b1c28a494b1852f4eddac6bec1c1d8eecc00d7"},"filename":"psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"0bdd4eab935276290ad3cb718e9809412895ca6b5b334f5a9111ee6d9aff9377"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":248985,"upload-time":"2024-12-19T18:21:49.254078Z","url":"https://files.pythonhosted.org/packages/0b/6b/73dbde0dd38f3782905d4587049b9be64d76671042fdcaf60e2430c6796d/psutil-6.1.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"b6e06c20c05fe95a3d7302d74e7097756d4ba1247975ad6905441ae1b5b66003"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":284488,"upload-time":"2024-12-19T18:21:51.638630Z","url":"https://files.pythonhosted.org/packages/17/38/c319d31a1d3f88c5b79c68b3116c129e5133f1822157dd6da34043e32ed6/psutil-6.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"97f7cb9921fbec4904f522d972f0c0e1f4fabbdd4e0287813b21215074a0f160"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":287477,"upload-time":"2024-12-19T18:21:55.306984Z","url":"https://files.pythonhosted.org/packages/9c/39/0f88a830a1c8a3aba27fededc642da37613c57cbff143412e3536f89784f/psutil-6.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"data-dist-info-metadata":{"sha256":"06627f791c3970710891bde5c145df9bac4b643a1529e21d25a8c1c679aca404"},"filename":"psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"33431e84fee02bc84ea36d9e2c4a6d395d479c9dd9bba2376c1f6ee8f3a4e0b3"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":289017,"upload-time":"2024-12-19T18:21:57.875754Z","url":"https://files.pythonhosted.org/packages/47/da/99f4345d4ddf2845cb5b5bd0d93d554e84542d116934fde07a0c50bd4e9f/psutil-6.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"data-dist-info-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"filename":"psutil-6.1.1-cp36-cp36m-win32.whl","hashes":{"sha256":"384636b1a64b47814437d1173be1427a7c83681b17a450bfc309a1953e329603"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":252576,"upload-time":"2024-12-19T18:22:01.852822Z","url":"https://files.pythonhosted.org/packages/8e/1f/1aebe4dd5914ccba6f7d6cc6d11fb79f6f23f95b858a7f631446bdc5d67f/psutil-6.1.1-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"data-dist-info-metadata":{"sha256":"4899522d2eb9cfd3ec5a1a377c43fb70f9e3963a8989dd7f84c20d6d00083470"},"filename":"psutil-6.1.1-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"8be07491f6ebe1a693f17d4f11e69d0dc1811fa082736500f649f79df7735303"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":258012,"upload-time":"2024-12-19T18:22:04.204308Z","url":"https://files.pythonhosted.org/packages/f4/de/fb4561e59611c19a2d7377c2b2534d11274b8a7df9bb7b7e7f1de5be3641/psutil-6.1.1-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"data-dist-info-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"filename":"psutil-6.1.1-cp37-abi3-win32.whl","hashes":{"sha256":"eaa912e0b11848c4d9279a93d7e2783df352b082f40111e078388701fd479e53"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":250602,"upload-time":"2024-12-19T18:22:08.808295Z","url":"https://files.pythonhosted.org/packages/38/53/bd755c2896f4461fd4f36fa6a6dcb66a88a9e4b9fd4e5b66a77cf9d4a584/psutil-6.1.1-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"data-dist-info-metadata":{"sha256":"492e1282d630b4482b89e0c91cd388cea83f8efa851c6c2ffc46a6875c62b52d"},"filename":"psutil-6.1.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f35cfccb065fff93529d2afb4a2e89e363fe63ca1e4a5da22b603a85833c2649"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":254444,"upload-time":"2024-12-19T18:22:11.335598Z","url":"https://files.pythonhosted.org/packages/7b/d7/7831438e6c3ebbfa6e01a927127a6cb42ad3ab844247f3c5b96bea25d73d/psutil-6.1.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-6.1.1.tar.gz","hashes":{"sha256":"cf8496728c18f2d0b45198f06895be52f36611711746b7f30c464b422b50e2f5"},"provenance":null,"requires-python":"!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7","size":508502,"upload-time":"2024-12-19T18:21:20.568966Z","url":"https://files.pythonhosted.org/packages/1f/5a/07871137bb752428aa4b659f910b399ba6f291156bdea939be3e96cae7cb/psutil-6.1.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25"},"provenance":null,"requires-python":">=3.6","size":238051,"upload-time":"2025-02-13T21:54:12.360451Z","url":"https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"65f64bcd26d7284f4f07568c343ced6641bf8235c8c5a09a4986dd2ec5f68de7"},"data-dist-info-metadata":{"sha256":"65f64bcd26d7284f4f07568c343ced6641bf8235c8c5a09a4986dd2ec5f68de7"},"filename":"psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da"},"provenance":null,"requires-python":">=3.6","size":239535,"upload-time":"2025-02-13T21:54:16.070769Z","url":"https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91"},"provenance":null,"requires-python":">=3.6","size":275004,"upload-time":"2025-02-13T21:54:18.662603Z","url":"https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34"},"provenance":null,"requires-python":">=3.6","size":277986,"upload-time":"2025-02-13T21:54:21.811145Z","url":"https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"data-dist-info-metadata":{"sha256":"0453e4553a618524d8001e2f64a83b1c24419826cab87bf6b734e6723d383c89"},"filename":"psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993"},"provenance":null,"requires-python":">=3.6","size":279544,"upload-time":"2025-02-13T21:54:24.680762Z","url":"https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"data-dist-info-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"filename":"psutil-7.0.0-cp36-cp36m-win32.whl","hashes":{"sha256":"84df4eb63e16849689f76b1ffcb36db7b8de703d1bc1fe41773db487621b6c17"},"provenance":null,"requires-python":">=3.6","size":243024,"upload-time":"2025-02-13T21:54:27.767214Z","url":"https://files.pythonhosted.org/packages/98/04/9e7b8afdad85824dec17de92c121d0fb1907ded624f486b86cd5e8189ebe/psutil-7.0.0-cp36-cp36m-win32.whl","yanked":false},{"core-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"data-dist-info-metadata":{"sha256":"1326531887a042b91e9db0d6e74bd66dde0a4fd27151ed4b8baeca1fad635542"},"filename":"psutil-7.0.0-cp36-cp36m-win_amd64.whl","hashes":{"sha256":"1e744154a6580bc968a0195fd25e80432d3afec619daf145b9e5ba16cc1d688e"},"provenance":null,"requires-python":">=3.6","size":248462,"upload-time":"2025-02-13T21:54:31.148496Z","url":"https://files.pythonhosted.org/packages/25/9b/43f2c5f7794a3eba3fc0bb47020d1da44d43ff41c95637c5d760c3ef33eb/psutil-7.0.0-cp36-cp36m-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"data-dist-info-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"filename":"psutil-7.0.0-cp37-abi3-win32.whl","hashes":{"sha256":"ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99"},"provenance":null,"requires-python":">=3.6","size":241053,"upload-time":"2025-02-13T21:54:34.310916Z","url":"https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"data-dist-info-metadata":{"sha256":"8c4198dfca297dfee074ee46394207f317965c25dc1af8ad38862b954795a7c1"},"filename":"psutil-7.0.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553"},"provenance":null,"requires-python":">=3.6","size":244885,"upload-time":"2025-02-13T21:54:37.486453Z","url":"https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.0.0.tar.gz","hashes":{"sha256":"7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456"},"provenance":null,"requires-python":">=3.6","size":497003,"upload-time":"2025-02-13T21:54:07.946974Z","url":"https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"76168cef4397494250e9f4e73eb3752b146de1dd950040b29186d0cce1d5ca13"},"provenance":null,"requires-python":">=3.6","size":245242,"upload-time":"2025-09-17T20:14:56.126572Z","url":"https://files.pythonhosted.org/packages/46/62/ce4051019ee20ce0ed74432dd73a5bb087a6704284a470bb8adff69a0932/psutil-7.1.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"5d007560c8c372efdff9e4579c2846d71de737e4605f611437255e81efcca2c5"},"provenance":null,"requires-python":">=3.6","size":246682,"upload-time":"2025-09-17T20:14:58.250040Z","url":"https://files.pythonhosted.org/packages/38/61/f76959fba841bf5b61123fbf4b650886dc4094c6858008b5bf73d9057216/psutil-7.1.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"22e4454970b32472ce7deaa45d045b34d3648ce478e26a04c7e858a0a6e75ff3"},"provenance":null,"requires-python":">=3.6","size":287994,"upload-time":"2025-09-17T20:14:59.901485Z","url":"https://files.pythonhosted.org/packages/88/7a/37c99d2e77ec30d63398ffa6a660450b8a62517cabe44b3e9bae97696e8d/psutil-7.1.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"8c70e113920d51e89f212dd7be06219a9b88014e63a4cec69b684c327bc474e3"},"provenance":null,"requires-python":">=3.6","size":291163,"upload-time":"2025-09-17T20:15:01.481447Z","url":"https://files.pythonhosted.org/packages/9d/de/04c8c61232f7244aa0a4b9a9fbd63a89d5aeaf94b2fc9d1d16e2faa5cbb0/psutil-7.1.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"data-dist-info-metadata":{"sha256":"ac00a0bcd2510cbd355745e1742a41ef2eadd59546c28788d6122a57d329c6b6"},"filename":"psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"7d4a113425c037300de3ac8b331637293da9be9713855c4fc9d2d97436d7259d"},"provenance":null,"requires-python":">=3.6","size":293625,"upload-time":"2025-09-17T20:15:04.492789Z","url":"https://files.pythonhosted.org/packages/f4/58/c4f976234bf6d4737bc8c02a81192f045c307b72cf39c9e5c5a2d78927f6/psutil-7.1.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"data-dist-info-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"filename":"psutil-7.1.0-cp37-abi3-win32.whl","hashes":{"sha256":"09ad740870c8d219ed8daae0ad3b726d3bf9a028a198e7f3080f6a1888b99bca"},"provenance":null,"requires-python":">=3.6","size":244812,"upload-time":"2025-09-17T20:15:07.462276Z","url":"https://files.pythonhosted.org/packages/79/87/157c8e7959ec39ced1b11cc93c730c4fb7f9d408569a6c59dbd92ceb35db/psutil-7.1.0-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"data-dist-info-metadata":{"sha256":"24dfa33010cf11743d32bccef7c6bf186df383e24c75c8f904a21dc21061932a"},"filename":"psutil-7.1.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"57f5e987c36d3146c0dd2528cd42151cf96cd359b9d67cfff836995cc5df9a3d"},"provenance":null,"requires-python":">=3.6","size":247965,"upload-time":"2025-09-17T20:15:09.673366Z","url":"https://files.pythonhosted.org/packages/bf/e9/b44c4f697276a7a95b8e94d0e320a7bf7f3318521b23de69035540b39838/psutil-7.1.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"24a51389a00af9d96fada7f4a79aed176d3a74f0ae399a5305d12ce9784f2635"},"data-dist-info-metadata":{"sha256":"24a51389a00af9d96fada7f4a79aed176d3a74f0ae399a5305d12ce9784f2635"},"filename":"psutil-7.1.0-cp37-abi3-win_arm64.whl","hashes":{"sha256":"6937cb68133e7c97b6cc9649a570c9a18ba0efebed46d8c5dae4c07fa1b67a07"},"provenance":null,"requires-python":">=3.6","size":244971,"upload-time":"2025-09-17T20:15:12.262753Z","url":"https://files.pythonhosted.org/packages/26/65/1070a6e3c036f39142c2820c4b52e9243246fcfc3f96239ac84472ba361e/psutil-7.1.0-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.0.tar.gz","hashes":{"sha256":"655708b3c069387c8b77b072fc429a57d0e214221d01c0a772df7dfedcb3bcd2"},"provenance":null,"requires-python":">=3.6","size":497660,"upload-time":"2025-09-17T20:14:52.902036Z","url":"https://files.pythonhosted.org/packages/b3/31/4723d756b59344b643542936e37a31d1d3204bcdc42a7daa8ee9eb06fb50/psutil-7.1.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"8fa59d7b1f01f0337f12cd10dbd76e4312a4d3c730a4fedcbdd4e5447a8b8460"},"provenance":null,"requires-python":">=3.6","size":244221,"upload-time":"2025-10-19T15:44:03.145914Z","url":"https://files.pythonhosted.org/packages/51/30/f97f8fb1f9ecfbeae4b5ca738dcae66ab28323b5cfbc96cb5565f3754056/psutil-7.1.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"2a95104eae85d088891716db676f780c1404fc15d47fde48a46a5d61e8f5ad2c"},"provenance":null,"requires-python":">=3.6","size":245660,"upload-time":"2025-10-19T15:44:05.657308Z","url":"https://files.pythonhosted.org/packages/7b/98/b8d1f61ebf35f4dbdbaabadf9208282d8adc820562f0257e5e6e79e67bf2/psutil-7.1.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","hashes":{"sha256":"98629cd8567acefcc45afe2f4ba1e9290f579eacf490a917967decce4b74ee9b"},"provenance":null,"requires-python":">=3.6","size":286963,"upload-time":"2025-10-19T15:44:08.877299Z","url":"https://files.pythonhosted.org/packages/f0/4a/b8015d7357fefdfe34bc4a3db48a107bae4bad0b94fb6eb0613f09a08ada/psutil-7.1.1-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","hashes":{"sha256":"92ebc58030fb054fa0f26c3206ef01c31c29d67aee1367e3483c16665c25c8d2"},"provenance":null,"requires-python":">=3.6","size":290118,"upload-time":"2025-10-19T15:44:11.897889Z","url":"https://files.pythonhosted.org/packages/3d/3c/b56076bb35303d0733fc47b110a1c9cce081a05ae2e886575a3587c1ee76/psutil-7.1.1-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"data-dist-info-metadata":{"sha256":"d94db19e208334cc22bb81d2d0102f837a1101c98a0d350fa3d257181ae1ef09"},"filename":"psutil-7.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","hashes":{"sha256":"146a704f224fb2ded2be3da5ac67fc32b9ea90c45b51676f9114a6ac45616967"},"provenance":null,"requires-python":">=3.6","size":292587,"upload-time":"2025-10-19T15:44:14.670833Z","url":"https://files.pythonhosted.org/packages/dc/af/c13d360c0adc6f6218bf9e2873480393d0f729c8dd0507d171f53061c0d3/psutil-7.1.1-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"data-dist-info-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"filename":"psutil-7.1.1-cp37-abi3-win32.whl","hashes":{"sha256":"295c4025b5cd880f7445e4379e6826f7307e3d488947bf9834e865e7847dc5f7"},"provenance":null,"requires-python":">=3.6","size":243772,"upload-time":"2025-10-19T15:44:16.938205Z","url":"https://files.pythonhosted.org/packages/90/2d/c933e7071ba60c7862813f2c7108ec4cf8304f1c79660efeefd0de982258/psutil-7.1.1-cp37-abi3-win32.whl","yanked":false},{"core-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"data-dist-info-metadata":{"sha256":"b46a0b2c74ca7acef22d45a6a1b88ac5c5a55793782e1b66e08e8ac56f33ddb1"},"filename":"psutil-7.1.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"9b4f17c5f65e44f69bd3a3406071a47b79df45cf2236d1f717970afcb526bcd3"},"provenance":null,"requires-python":">=3.6","size":246936,"upload-time":"2025-10-19T15:44:18.663465Z","url":"https://files.pythonhosted.org/packages/be/f3/11fd213fff15427bc2853552138760c720fd65032d99edfb161910d04127/psutil-7.1.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"41f2736f936aaaa81486aad04717acc54669b33ae5ad93df72d7a7b26aa50fa7"},"data-dist-info-metadata":{"sha256":"41f2736f936aaaa81486aad04717acc54669b33ae5ad93df72d7a7b26aa50fa7"},"filename":"psutil-7.1.1-cp37-abi3-win_arm64.whl","hashes":{"sha256":"5457cf741ca13da54624126cd5d333871b454ab133999a9a103fb097a7d7d21a"},"provenance":null,"requires-python":">=3.6","size":243944,"upload-time":"2025-10-19T15:44:20.666512Z","url":"https://files.pythonhosted.org/packages/0a/8d/8a9a45c8b655851f216c1d44f68e3533dc8d2c752ccd0f61f1aa73be4893/psutil-7.1.1-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.1.tar.gz","hashes":{"sha256":"092b6350145007389c1cfe5716050f02030a05219d90057ea867d18fe8d372fc"},"provenance":null,"requires-python":">=3.6","size":487067,"upload-time":"2025-10-19T15:43:59.373160Z","url":"https://files.pythonhosted.org/packages/89/fc/889242351a932d6183eec5df1fc6539b6f36b6a88444f1e63f18668253aa/psutil-7.1.1.tar.gz","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"0cc5c6889b9871f231ed5455a9a02149e388fffcb30b607fb7a8896a6d95f22e"},"provenance":null,"requires-python":">=3.6","size":238575,"upload-time":"2025-10-25T10:46:38.728747Z","url":"https://files.pythonhosted.org/packages/b8/d9/b56cc9f883140ac10021a8c9b0f4e16eed1ba675c22513cdcbce3ba64014/psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"8e9e77a977208d84aa363a4a12e0f72189d58bbf4e46b49aae29a2c6e93ef206"},"provenance":null,"requires-python":">=3.6","size":239297,"upload-time":"2025-10-25T10:46:41.347184Z","url":"https://files.pythonhosted.org/packages/36/eb/28d22de383888deb252c818622196e709da98816e296ef95afda33f1c0a2/psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"7d9623a5e4164d2220ecceb071f4b333b3c78866141e8887c072129185f41278"},"provenance":null,"requires-python":">=3.6","size":280420,"upload-time":"2025-10-25T10:46:44.122205Z","url":"https://files.pythonhosted.org/packages/89/5d/220039e2f28cc129626e54d63892ab05c0d56a29818bfe7268dcb5008932/psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"364b1c10fe4ed59c89ec49e5f1a70da353b27986fa8233b4b999df4742a5ee2f"},"provenance":null,"requires-python":">=3.6","size":283049,"upload-time":"2025-10-25T10:46:47.095973Z","url":"https://files.pythonhosted.org/packages/ba/7a/286f0e1c167445b2ef4a6cbdfc8c59fdb45a5a493788950cf8467201dc73/psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"f101ef84de7e05d41310e3ccbdd65a6dd1d9eed85e8aaf0758405d022308e204"},"provenance":null,"requires-python":">=3.6","size":248713,"upload-time":"2025-10-25T10:46:49.573269Z","url":"https://files.pythonhosted.org/packages/aa/cc/7eb93260794a42e39b976f3a4dde89725800b9f573b014fac142002a5c98/psutil-7.1.2-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"20c00824048a95de67f00afedc7b08b282aa08638585b0206a9fb51f28f1a165"},"provenance":null,"requires-python":">=3.6","size":244644,"upload-time":"2025-10-25T10:46:51.924062Z","url":"https://files.pythonhosted.org/packages/ab/1a/0681a92b53366e01f0a099f5237d0c8a2f79d322ac589cccde5e30c8a4e2/psutil-7.1.2-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"e09cfe92aa8e22b1ec5e2d394820cf86c5dff6367ac3242366485dfa874d43bc"},"provenance":null,"requires-python":">=3.6","size":238640,"upload-time":"2025-10-25T10:46:54.089898Z","url":"https://files.pythonhosted.org/packages/56/9e/f1c5c746b4ed5320952acd3002d3962fe36f30524c00ea79fdf954cc6779/psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"fa6342cf859c48b19df3e4aa170e4cfb64aadc50b11e06bb569c6c777b089c9e"},"provenance":null,"requires-python":">=3.6","size":239303,"upload-time":"2025-10-25T10:46:56.932071Z","url":"https://files.pythonhosted.org/packages/32/ee/fd26216a735395cc25c3899634e34aeb41fb1f3dbb44acc67d9e594be562/psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"625977443498ee7d6c1e63e93bacca893fd759a66c5f635d05e05811d23fb5ee"},"provenance":null,"requires-python":">=3.6","size":281717,"upload-time":"2025-10-25T10:46:59.116890Z","url":"https://files.pythonhosted.org/packages/3c/cd/7d96eaec4ef7742b845a9ce2759a2769ecce4ab7a99133da24abacbc9e41/psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"data-dist-info-metadata":{"sha256":"e7b235bb0ba92037ddba6bcb227d0db55f64a7d54b2302a64ee7d8ba78b81c44"},"filename":"psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"4a24bcd7b7f2918d934af0fb91859f621b873d6aa81267575e3655cd387572a7"},"provenance":null,"requires-python":">=3.6","size":284575,"upload-time":"2025-10-25T10:47:00.944625Z","url":"https://files.pythonhosted.org/packages/bc/1a/7f0b84bdb067d35fe7fade5fff888408688caf989806ce2d6dae08c72dd5/psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"329f05610da6380982e6078b9d0881d9ab1e9a7eb7c02d833bfb7340aa634e31"},"provenance":null,"requires-python":">=3.6","size":249491,"upload-time":"2025-10-25T10:47:03.174087Z","url":"https://files.pythonhosted.org/packages/de/05/7820ef8f7b275268917e0c750eada5834581206d9024ca88edce93c4b762/psutil-7.1.2-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"7b04c29e3c0c888e83ed4762b70f31e65c42673ea956cefa8ced0e31e185f582"},"provenance":null,"requires-python":">=3.6","size":244880,"upload-time":"2025-10-25T10:47:05.228789Z","url":"https://files.pythonhosted.org/packages/db/9a/58de399c7cb58489f08498459ff096cd76b3f1ddc4f224ec2c5ef729c7d0/psutil-7.1.2-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"c9ba5c19f2d46203ee8c152c7b01df6eec87d883cfd8ee1af2ef2727f6b0f814"},"provenance":null,"requires-python":">=3.6","size":237244,"upload-time":"2025-10-25T10:47:07.086631Z","url":"https://files.pythonhosted.org/packages/ae/89/b9f8d47ddbc52d7301fc868e8224e5f44ed3c7f55e6d0f54ecaf5dd9ff5e/psutil-7.1.2-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"2a486030d2fe81bec023f703d3d155f4823a10a47c36784c84f1cc7f8d39bedb"},"provenance":null,"requires-python":">=3.6","size":238101,"upload-time":"2025-10-25T10:47:09.523680Z","url":"https://files.pythonhosted.org/packages/c8/7a/8628c2f6b240680a67d73d8742bb9ff39b1820a693740e43096d5dcb01e5/psutil-7.1.2-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"3efd8fc791492e7808a51cb2b94889db7578bfaea22df931424f874468e389e3"},"provenance":null,"requires-python":">=3.6","size":258675,"upload-time":"2025-10-25T10:47:11.082823Z","url":"https://files.pythonhosted.org/packages/30/28/5e27f4d5a0e347f8e3cc16cd7d35533dbce086c95807f1f0e9cd77e26c10/psutil-7.1.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"data-dist-info-metadata":{"sha256":"9060d8b9832fb047375c7eeac0d3ca41668a9f56cea96f12e30ce72cc4acea8b"},"filename":"psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"e2aeb9b64f481b8eabfc633bd39e0016d4d8bbcd590d984af764d80bf0851b8a"},"provenance":null,"requires-python":">=3.6","size":260203,"upload-time":"2025-10-25T10:47:13.226564Z","url":"https://files.pythonhosted.org/packages/e5/5c/79cf60c9acf36d087f0db0f82066fca4a780e97e5b3a2e4c38209c03d170/psutil-7.1.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"4e0958cd1551f981a3d0063faf8314b741cd97cb43d1e58934800cb4da537f64"},"data-dist-info-metadata":{"sha256":"4e0958cd1551f981a3d0063faf8314b741cd97cb43d1e58934800cb4da537f64"},"filename":"psutil-7.1.2-cp37-abi3-win_amd64.whl","hashes":{"sha256":"8e17852114c4e7996fe9da4745c2bdef001ebbf2f260dec406290e66628bdb91"},"provenance":null,"requires-python":">=3.6","size":246714,"upload-time":"2025-10-25T10:47:15.093571Z","url":"https://files.pythonhosted.org/packages/f7/03/0a464404c51685dcb9329fdd660b1721e076ccd7b3d97dee066bcc9ffb15/psutil-7.1.2-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"data-dist-info-metadata":{"sha256":"b27a63f31491a49efc9ff48050f5fdcca4606a487fac91e6cc46853031038b01"},"filename":"psutil-7.1.2-cp37-abi3-win_arm64.whl","hashes":{"sha256":"3e988455e61c240cc879cb62a008c2699231bf3e3d061d7fce4234463fd2abb4"},"provenance":null,"requires-python":">=3.6","size":243742,"upload-time":"2025-10-25T10:47:17.302139Z","url":"https://files.pythonhosted.org/packages/6a/32/97ca2090f2f1b45b01b6aa7ae161cfe50671de097311975ca6eea3e7aabc/psutil-7.1.2-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.2.tar.gz","hashes":{"sha256":"aa225cdde1335ff9684708ee8c72650f6598d5ed2114b9a7c5802030b1785018"},"provenance":null,"requires-python":">=3.6","size":487424,"upload-time":"2025-10-25T10:46:34.931002Z","url":"https://files.pythonhosted.org/packages/cd/ec/7b8e6b9b1d22708138630ef34c53ab2b61032c04f16adfdbb96791c8c70c/psutil-7.1.2.tar.gz","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc"},"provenance":null,"requires-python":">=3.6","size":239751,"upload-time":"2025-11-02T12:25:58.161404Z","url":"https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0"},"provenance":null,"requires-python":">=3.6","size":240368,"upload-time":"2025-11-02T12:26:00.491685Z","url":"https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7"},"provenance":null,"requires-python":">=3.6","size":287134,"upload-time":"2025-11-02T12:26:02.613574Z","url":"https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251"},"provenance":null,"requires-python":">=3.6","size":289904,"upload-time":"2025-11-02T12:26:05.207933Z","url":"https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa"},"provenance":null,"requires-python":">=3.6","size":249642,"upload-time":"2025-11-02T12:26:07.447774Z","url":"https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee"},"provenance":null,"requires-python":">=3.6","size":245518,"upload-time":"2025-11-02T12:26:09.719155Z","url":"https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353"},"provenance":null,"requires-python":">=3.6","size":239843,"upload-time":"2025-11-02T12:26:11.968073Z","url":"https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b"},"provenance":null,"requires-python":">=3.6","size":240369,"upload-time":"2025-11-02T12:26:14.358801Z","url":"https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9"},"provenance":null,"requires-python":">=3.6","size":288210,"upload-time":"2025-11-02T12:26:16.699739Z","url":"https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"data-dist-info-metadata":{"sha256":"fee2408ed83d5d231935e659a072f72e41c592bc880496074a506e9d6b3eada7"},"filename":"psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f"},"provenance":null,"requires-python":">=3.6","size":291182,"upload-time":"2025-11-02T12:26:18.848963Z","url":"https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7"},"provenance":null,"requires-python":">=3.6","size":250466,"upload-time":"2025-11-02T12:26:21.183069Z","url":"https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264"},"provenance":null,"requires-python":">=3.6","size":245756,"upload-time":"2025-11-02T12:26:23.148427Z","url":"https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab"},"provenance":null,"requires-python":">=3.6","size":238359,"upload-time":"2025-11-02T12:26:25.284599Z","url":"https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880"},"provenance":null,"requires-python":">=3.6","size":239171,"upload-time":"2025-11-02T12:26:27.230751Z","url":"https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3"},"provenance":null,"requires-python":">=3.6","size":263261,"upload-time":"2025-11-02T12:26:29.480632Z","url":"https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"data-dist-info-metadata":{"sha256":"3578dc4ee5f43e542d29839741b9e3d8760c3c0e5d8c388ec2b0b980bd8c66a1"},"filename":"psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b"},"provenance":null,"requires-python":">=3.6","size":264635,"upload-time":"2025-11-02T12:26:31.740762Z","url":"https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"89db7acafbe66cd8b6a060ae993afda9c8f50aa4342c34c92a284be2c8c8534f"},"data-dist-info-metadata":{"sha256":"89db7acafbe66cd8b6a060ae993afda9c8f50aa4342c34c92a284be2c8c8534f"},"filename":"psutil-7.1.3-cp37-abi3-win_amd64.whl","hashes":{"sha256":"f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd"},"provenance":null,"requires-python":">=3.6","size":247633,"upload-time":"2025-11-02T12:26:33.887174Z","url":"https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"data-dist-info-metadata":{"sha256":"a690b24adf2968fc63d76d10c2e8052107d0af31da1588424d365c1ff08c9fd1"},"filename":"psutil-7.1.3-cp37-abi3-win_arm64.whl","hashes":{"sha256":"bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1"},"provenance":null,"requires-python":">=3.6","size":244608,"upload-time":"2025-11-02T12:26:36.136434Z","url":"https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.1.3.tar.gz","hashes":{"sha256":"6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74"},"provenance":null,"requires-python":">=3.6","size":489059,"upload-time":"2025-11-02T12:25:54.619294Z","url":"https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"c31e927555539132a00380c971816ea43d089bf4bd5f3e918ed8c16776d68474"},"provenance":null,"requires-python":">=3.6","size":129593,"upload-time":"2025-12-23T20:26:28.019569Z","url":"https://files.pythonhosted.org/packages/a8/8e/b35aae6ed19bc4e2286cac4832e4d522fcf00571867b0a85a3f77ef96a80/psutil-7.2.0-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"db8e44e766cef86dea47d9a1fa535d38dc76449e5878a92f33683b7dba5bfcb2"},"provenance":null,"requires-python":">=3.6","size":130104,"upload-time":"2025-12-23T20:26:30.270800Z","url":"https://files.pythonhosted.org/packages/61/a2/773d17d74e122bbffe08b97f73f2d4a01ef53fb03b98e61b8e4f64a9c6b9/psutil-7.2.0-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"85ef849ac92169dedc59a7ac2fb565f47b3468fbe1524bf748746bc21afb94c7"},"provenance":null,"requires-python":">=3.6","size":180579,"upload-time":"2025-12-23T20:26:32.628357Z","url":"https://files.pythonhosted.org/packages/0d/e3/d3a9b3f4bd231abbd70a988beb2e3edd15306051bccbfc4472bd34a56e01/psutil-7.2.0-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"26782bdbae2f5c14ce9ebe8ad2411dc2ca870495e0cd90f8910ede7fa5e27117"},"provenance":null,"requires-python":">=3.6","size":183171,"upload-time":"2025-12-23T20:26:34.972726Z","url":"https://files.pythonhosted.org/packages/66/f8/6c73044424aabe1b7824d4d4504029d406648286d8fe7ba8c4682e0d3042/psutil-7.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"b7665f612d3b38a583391b95969667a53aaf6c5706dc27a602c9a4874fbf09e4"},"provenance":null,"requires-python":">=3.6","size":139055,"upload-time":"2025-12-23T20:26:36.848832Z","url":"https://files.pythonhosted.org/packages/48/7d/76d7a863340885d41826562225a566683e653ee6c9ba03c9f3856afa7d80/psutil-7.2.0-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"4413373c174520ae28a24a8974ad8ce6b21f060d27dde94e25f8c73a7effe57a"},"provenance":null,"requires-python":">=3.6","size":134737,"upload-time":"2025-12-23T20:26:38.784066Z","url":"https://files.pythonhosted.org/packages/a0/48/200054ada0ae4872c8a71db54f3eb6a9af4101680ee6830d373b7fda526b/psutil-7.2.0-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"2f2f53fd114e7946dfba3afb98c9b7c7f376009447360ca15bfb73f2066f84c7"},"provenance":null,"requires-python":">=3.6","size":129692,"upload-time":"2025-12-23T20:26:40.623176Z","url":"https://files.pythonhosted.org/packages/44/86/98da45dff471b93ef5ce5bcaefa00e3038295a7880a77cf74018243d37fb/psutil-7.2.0-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"e65c41d7e60068f60ce43b31a3a7fc90deb0dfd34ffc824a2574c2e5279b377e"},"provenance":null,"requires-python":">=3.6","size":130110,"upload-time":"2025-12-23T20:26:42.569228Z","url":"https://files.pythonhosted.org/packages/50/ee/10eae91ba4ad071c92db3c178ba861f30406342de9f0ddbe6d51fd741236/psutil-7.2.0-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"cc66d21366850a4261412ce994ae9976bba9852dafb4f2fa60db68ed17ff5281"},"provenance":null,"requires-python":">=3.6","size":181487,"upload-time":"2025-12-23T20:26:44.633020Z","url":"https://files.pythonhosted.org/packages/87/3a/2b2897443d56fedbbc34ac68a0dc7d55faa05d555372a2f989109052f86d/psutil-7.2.0-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"data-dist-info-metadata":{"sha256":"2170dd4480c057291a293d121c10bf5228540dd58ab43945d29672ec02a0a23a"},"filename":"psutil-7.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"e025d67b42b8f22b096d5d20f5171de0e0fefb2f0ce983a13c5a1b5ed9872706"},"provenance":null,"requires-python":">=3.6","size":184320,"upload-time":"2025-12-23T20:26:46.830615Z","url":"https://files.pythonhosted.org/packages/11/66/44308428f7333db42c5ea7390c52af1b38f59b80b80c437291f58b5dfdad/psutil-7.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"45f6b91f7ad63414d6454fd609e5e3556d0e1038d5d9c75a1368513bdf763f57"},"provenance":null,"requires-python":">=3.6","size":140372,"upload-time":"2025-12-23T20:26:49.334377Z","url":"https://files.pythonhosted.org/packages/18/28/d2feadc7f18e501c5ce687c377db7dca924585418fd694272b8e488ea99f/psutil-7.2.0-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"87b18a19574139d60a546e88b5f5b9cbad598e26cdc790d204ab95d7024f03ee"},"provenance":null,"requires-python":">=3.6","size":135400,"upload-time":"2025-12-23T20:26:51.585604Z","url":"https://files.pythonhosted.org/packages/b2/1d/48381f5fd0425aa054c4ee3de24f50de3d6c347019f3aec75f357377d447/psutil-7.2.0-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"977a2fcd132d15cb05b32b2d85b98d087cad039b0ce435731670ba74da9e6133"},"provenance":null,"requires-python":">=3.6","size":128116,"upload-time":"2025-12-23T20:26:53.516520Z","url":"https://files.pythonhosted.org/packages/40/c5/a49160bf3e165b7b93a60579a353cf5d939d7f878fe5fd369110f1d18043/psutil-7.2.0-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"24151011c21fadd94214d7139d7c6c54569290d7e553989bdf0eab73b13beb8c"},"provenance":null,"requires-python":">=3.6","size":128925,"upload-time":"2025-12-23T20:26:55.573324Z","url":"https://files.pythonhosted.org/packages/10/a1/c75feb480f60cd768fb6ed00ac362a16a33e5076ec8475a22d8162fb2659/psutil-7.2.0-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"91f211ba9279e7c61d9d8f84b713cfc38fa161cb0597d5cb3f1ca742f6848254"},"provenance":null,"requires-python":">=3.6","size":154666,"upload-time":"2025-12-23T20:26:57.312776Z","url":"https://files.pythonhosted.org/packages/12/ff/e93136587c00a543f4bc768b157fac2c47cd77b180d4f4e5c6efb6ea53a2/psutil-7.2.0-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"f37415188b7ea98faf90fed51131181646c59098b077550246e2e092e127418b"},"provenance":null,"requires-python":">=3.6","size":156109,"upload-time":"2025-12-23T20:26:58.851353Z","url":"https://files.pythonhosted.org/packages/b8/dd/4c2de9c3827c892599d277a69d2224136800870a8a88a80981de905de28d/psutil-7.2.0-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-musllinux_1_2_aarch64.whl","hashes":{"sha256":"0d12c7ce6ed1128cd81fd54606afa054ac7dbb9773469ebb58cf2f171c49f2ac"},"provenance":null,"requires-python":">=3.6","size":148081,"upload-time":"2025-12-23T20:27:01.318270Z","url":"https://files.pythonhosted.org/packages/81/3f/090943c682d3629968dd0b04826ddcbc760ee1379021dbe316e2ddfcd01b/psutil-7.2.0-cp36-abi3-musllinux_1_2_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"data-dist-info-metadata":{"sha256":"78cbedc39a964b930e33a3c9bd2f10aaa72c827cfcce30c4074dffd544c24a58"},"filename":"psutil-7.2.0-cp36-abi3-musllinux_1_2_x86_64.whl","hashes":{"sha256":"ca0faef7976530940dcd39bc5382d0d0d5eb023b186a4901ca341bd8d8684151"},"provenance":null,"requires-python":">=3.6","size":147376,"upload-time":"2025-12-23T20:27:03.347816Z","url":"https://files.pythonhosted.org/packages/c4/88/c39648ebb8ec182d0364af53cdefe6eddb5f3872ba718b5855a8ff65d6d4/psutil-7.2.0-cp36-abi3-musllinux_1_2_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"758019d458979edff64acde45968217765d5828ba125593a164a985cdc0754bd"},"data-dist-info-metadata":{"sha256":"758019d458979edff64acde45968217765d5828ba125593a164a985cdc0754bd"},"filename":"psutil-7.2.0-cp37-abi3-win_amd64.whl","hashes":{"sha256":"abdb74137ca232d20250e9ad471f58d500e7743bc8253ba0bfbf26e570c0e437"},"provenance":null,"requires-python":">=3.6","size":136910,"upload-time":"2025-12-23T20:27:05.289344Z","url":"https://files.pythonhosted.org/packages/01/a2/5b39e08bd9b27476bc7cce7e21c71a481ad60b81ffac49baf02687a50d7f/psutil-7.2.0-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"data-dist-info-metadata":{"sha256":"795be0019027992887b63578f61759602599118117e81710fb28c5b7fb5023d6"},"filename":"psutil-7.2.0-cp37-abi3-win_arm64.whl","hashes":{"sha256":"284e71038b3139e7ab3834b63b3eb5aa5565fcd61a681ec746ef9a0a8c457fd2"},"provenance":null,"requires-python":">=3.6","size":133807,"upload-time":"2025-12-23T20:27:06.825130Z","url":"https://files.pythonhosted.org/packages/59/54/53839db1258c1eaeb4ded57ff202144ebc75b23facc05a74fd98d338b0c6/psutil-7.2.0-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.2.0.tar.gz","hashes":{"sha256":"2e4f8e1552f77d14dc96fb0f6240c5b34a37081c0889f0853b3b29a496e5ef64"},"provenance":null,"requires-python":">=3.6","size":489863,"upload-time":"2025-12-23T20:26:24.616214Z","url":"https://files.pythonhosted.org/packages/be/7c/31d1c3ceb1260301f87565f50689dc6da3db427ece1e1e012af22abca54e/psutil-7.2.0.tar.gz","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl","hashes":{"sha256":"ba9f33bb525b14c3ea563b2fd521a84d2fa214ec59e3e6a2858f78d0844dd60d"},"provenance":null,"requires-python":">=3.6","size":129624,"upload-time":"2025-12-29T08:26:04.255517Z","url":"https://files.pythonhosted.org/packages/77/8e/f0c242053a368c2aa89584ecd1b054a18683f13d6e5a318fc9ec36582c94/psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl","hashes":{"sha256":"81442dac7abfc2f4f4385ea9e12ddf5a796721c0f6133260687fec5c3780fa49"},"provenance":null,"requires-python":">=3.6","size":130132,"upload-time":"2025-12-29T08:26:06.228150Z","url":"https://files.pythonhosted.org/packages/26/97/a58a4968f8990617decee234258a2b4fc7cd9e35668387646c1963e69f26/psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"ea46c0d060491051d39f0d2cff4f98d5c72b288289f57a21556cc7d504db37fc"},"provenance":null,"requires-python":">=3.6","size":180612,"upload-time":"2025-12-29T08:26:08.276538Z","url":"https://files.pythonhosted.org/packages/db/6d/ed44901e830739af5f72a85fa7ec5ff1edea7f81bfbf4875e409007149bd/psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"35630d5af80d5d0d49cfc4d64c1c13838baf6717a13effb35869a5919b854cdf"},"provenance":null,"requires-python":">=3.6","size":183201,"upload-time":"2025-12-29T08:26:10.622093Z","url":"https://files.pythonhosted.org/packages/c7/65/b628f8459bca4efbfae50d4bf3feaab803de9a160b9d5f3bd9295a33f0c2/psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp313-cp313t-win_amd64.whl","hashes":{"sha256":"923f8653416604e356073e6e0bccbe7c09990acef442def2f5640dd0faa9689f"},"provenance":null,"requires-python":">=3.6","size":139081,"upload-time":"2025-12-29T08:26:12.483257Z","url":"https://files.pythonhosted.org/packages/fb/23/851cadc9764edcc18f0effe7d0bf69f727d4cf2442deb4a9f78d4e4f30f2/psutil-7.2.1-cp313-cp313t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp313-cp313t-win_arm64.whl","hashes":{"sha256":"cfbe6b40ca48019a51827f20d830887b3107a74a79b01ceb8cc8de4ccb17b672"},"provenance":null,"requires-python":">=3.6","size":134767,"upload-time":"2025-12-29T08:26:14.528248Z","url":"https://files.pythonhosted.org/packages/59/82/d63e8494ec5758029f31c6cb06d7d161175d8281e91d011a4a441c8a43b5/psutil-7.2.1-cp313-cp313t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl","hashes":{"sha256":"494c513ccc53225ae23eec7fe6e1482f1b8a44674241b54561f755a898650679"},"provenance":null,"requires-python":">=3.6","size":129716,"upload-time":"2025-12-29T08:26:16.017500Z","url":"https://files.pythonhosted.org/packages/05/c2/5fb764bd61e40e1fe756a44bd4c21827228394c17414ade348e28f83cd79/psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl","hashes":{"sha256":"3fce5f92c22b00cdefd1645aa58ab4877a01679e901555067b1bd77039aa589f"},"provenance":null,"requires-python":">=3.6","size":130133,"upload-time":"2025-12-29T08:26:18.009017Z","url":"https://files.pythonhosted.org/packages/c9/d2/935039c20e06f615d9ca6ca0ab756cf8408a19d298ffaa08666bc18dc805/psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"93f3f7b0bb07711b49626e7940d6fe52aa9940ad86e8f7e74842e73189712129"},"provenance":null,"requires-python":">=3.6","size":181518,"upload-time":"2025-12-29T08:26:20.241501Z","url":"https://files.pythonhosted.org/packages/77/69/19f1eb0e01d24c2b3eacbc2f78d3b5add8a89bf0bb69465bc8d563cc33de/psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"data-dist-info-metadata":{"sha256":"23740d4f8fcd640f5d191b7b232f6a393e1df6bf023302f619c701f995dff02d"},"filename":"psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"d34d2ca888208eea2b5c68186841336a7f5e0b990edec929be909353a202768a"},"provenance":null,"requires-python":">=3.6","size":184348,"upload-time":"2025-12-29T08:26:22.215886Z","url":"https://files.pythonhosted.org/packages/e1/6d/7e18b1b4fa13ad370787626c95887b027656ad4829c156bb6569d02f3262/psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp314-cp314t-win_amd64.whl","hashes":{"sha256":"2ceae842a78d1603753561132d5ad1b2f8a7979cb0c283f5b52fb4e6e14b1a79"},"provenance":null,"requires-python":">=3.6","size":140400,"upload-time":"2025-12-29T08:26:23.993885Z","url":"https://files.pythonhosted.org/packages/98/60/1672114392dd879586d60dd97896325df47d9a130ac7401318005aab28ec/psutil-7.2.1-cp314-cp314t-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp314-cp314t-win_arm64.whl","hashes":{"sha256":"08a2f175e48a898c8eb8eace45ce01777f4785bc744c90aa2cc7f2fa5462a266"},"provenance":null,"requires-python":">=3.6","size":135430,"upload-time":"2025-12-29T08:26:25.999852Z","url":"https://files.pythonhosted.org/packages/fb/7b/d0e9d4513c46e46897b46bcfc410d51fc65735837ea57a25170f298326e6/psutil-7.2.1-cp314-cp314t-win_arm64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl","hashes":{"sha256":"b2e953fcfaedcfbc952b44744f22d16575d3aa78eb4f51ae74165b4e96e55f42"},"provenance":null,"requires-python":">=3.6","size":128137,"upload-time":"2025-12-29T08:26:27.759659Z","url":"https://files.pythonhosted.org/packages/c5/cf/5180eb8c8bdf6a503c6919f1da28328bd1e6b3b1b5b9d5b01ae64f019616/psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl","hashes":{"sha256":"05cc68dbb8c174828624062e73078e7e35406f4ca2d0866c272c2410d8ef06d1"},"provenance":null,"requires-python":">=3.6","size":128947,"upload-time":"2025-12-29T08:26:29.548034Z","url":"https://files.pythonhosted.org/packages/c5/2c/78e4a789306a92ade5000da4f5de3255202c534acdadc3aac7b5458fadef/psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","hashes":{"sha256":"5e38404ca2bb30ed7267a46c02f06ff842e92da3bb8c5bfdadbd35a5722314d8"},"provenance":null,"requires-python":">=3.6","size":154694,"upload-time":"2025-12-29T08:26:32.147774Z","url":"https://files.pythonhosted.org/packages/29/f8/40e01c350ad9a2b3cb4e6adbcc8a83b17ee50dd5792102b6142385937db5/psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","hashes":{"sha256":"ab2b98c9fc19f13f59628d94df5cc4cc4844bc572467d113a8b517d634e362c6"},"provenance":null,"requires-python":">=3.6","size":156136,"upload-time":"2025-12-29T08:26:34.079911Z","url":"https://files.pythonhosted.org/packages/06/e4/b751cdf839c011a9714a783f120e6a86b7494eb70044d7d81a25a5cd295f/psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl","hashes":{"sha256":"f78baafb38436d5a128f837fab2d92c276dfb48af01a240b861ae02b2413ada8"},"provenance":null,"requires-python":">=3.6","size":148108,"upload-time":"2025-12-29T08:26:36.225796Z","url":"https://files.pythonhosted.org/packages/44/ad/bbf6595a8134ee1e94a4487af3f132cef7fce43aef4a93b49912a48c3af7/psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl","yanked":false},{"core-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"data-dist-info-metadata":{"sha256":"c340b0dbe2145d45dac650326d0f34f3ee664206d3bcd32785393b3476525944"},"filename":"psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl","hashes":{"sha256":"99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67"},"provenance":null,"requires-python":">=3.6","size":147402,"upload-time":"2025-12-29T08:26:39.210698Z","url":"https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl","yanked":false},{"core-metadata":{"sha256":"54955c981ab8a8b2b87efc900b6916c908a315660b0c3c5d205c910565bb3261"},"data-dist-info-metadata":{"sha256":"54955c981ab8a8b2b87efc900b6916c908a315660b0c3c5d205c910565bb3261"},"filename":"psutil-7.2.1-cp37-abi3-win_amd64.whl","hashes":{"sha256":"b1b0671619343aa71c20ff9767eced0483e4fc9e1f489d50923738caf6a03c17"},"provenance":null,"requires-python":">=3.6","size":136938,"upload-time":"2025-12-29T08:26:41.036253Z","url":"https://files.pythonhosted.org/packages/34/68/d9317542e3f2b180c4306e3f45d3c922d7e86d8ce39f941bb9e2e9d8599e/psutil-7.2.1-cp37-abi3-win_amd64.whl","yanked":false},{"core-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"data-dist-info-metadata":{"sha256":"08f1da19e657e59de5e9a94e4295fa686697c5c4e76447bd048138c2227e8293"},"filename":"psutil-7.2.1-cp37-abi3-win_arm64.whl","hashes":{"sha256":"0d67c1822c355aa6f7314d92018fb4268a76668a536f133599b91edd48759442"},"provenance":null,"requires-python":">=3.6","size":133836,"upload-time":"2025-12-29T08:26:43.086974Z","url":"https://files.pythonhosted.org/packages/3e/73/2ce007f4198c80fcf2cb24c169884f833fe93fbc03d55d302627b094ee91/psutil-7.2.1-cp37-abi3-win_arm64.whl","yanked":false},{"core-metadata":false,"data-dist-info-metadata":false,"filename":"psutil-7.2.1.tar.gz","hashes":{"sha256":"f7583aec590485b43ca601dd9cea0dcd65bd7bb21d30ef4ddbf4ea6b5ed1bdd3"},"provenance":null,"requires-python":">=3.6","size":490253,"upload-time":"2025-12-29T08:26:00.169622Z","url":"https://files.pythonhosted.org/packages/73/cb/09e5184fb5fc0358d110fc3ca7f6b1d033800734d34cac10f4136cfac10e/psutil-7.2.1.tar.gz","yanked":false}],"meta":{"_last-serial":33241970,"api-version":"1.4"},"name":"psutil","project-status":{"status":"active"},"versions":["0.1.1","0.1.2","0.1.3","0.2.0","0.2.1","0.3.0","0.4.0","0.4.1","0.5.0","0.5.1","0.6.0","0.6.1","0.7.0","0.7.1","1.0.0","1.0.1","1.1.0","1.1.1","1.1.2","1.1.3","1.2.0","1.2.1","2.0.0","2.1.0","2.1.1","2.1.2","2.1.3","2.2.0","2.2.1","3.0.0","3.0.1","3.1.0","3.1.1","3.2.0","3.2.1","3.2.2","3.3.0","3.4.1","3.4.2","4.0.0","4.1.0","4.2.0","4.3.0","4.3.1","4.4.0","4.4.1","4.4.2","5.0.0","5.0.1","5.1.0","5.1.1","5.1.2","5.1.3","5.2.0","5.2.1","5.2.2","5.3.0","5.3.1","5.4.0","5.4.1","5.4.2","5.4.3","5.4.4","5.4.5","5.4.6","5.4.7","5.4.8","5.5.0","5.5.1","5.6.0","5.6.1","5.6.2","5.6.3","5.6.4","5.6.5","5.6.6","5.6.7","5.7.0","5.7.1","5.7.2","5.7.3","5.8.0","5.9.0","5.9.1","5.9.2","5.9.3","5.9.4","5.9.5","5.9.6","5.9.7","5.9.8","6.0.0","6.1.0","6.1.1","7.0.0","7.1.0","7.1.1","7.1.2","7.1.3","7.2.0","7.2.1"]}
diff --git a/benches/benchmarks/json_loads.py b/benches/benchmarks/json_loads.py
new file mode 100644
index 0000000000..f67f14d2d9
--- /dev/null
+++ b/benches/benchmarks/json_loads.py
@@ -0,0 +1,7 @@
+import json
+
+with open('benches/_data/pypi_org__simple__psutil.json') as f:
+    data = f.read()
+
+
+loaded = json.loads(data)
diff --git a/benches/execution.rs b/benches/execution.rs
index 7a7ba247e5..c2239b59d1 100644
--- a/benches/execution.rs
+++ b/benches/execution.rs
@@ -1,17 +1,15 @@
-use criterion::measurement::WallTime;
 use criterion::{
-    Bencher, BenchmarkGroup, BenchmarkId, Criterion, Throughput, black_box, criterion_group,
-    criterion_main,
+    Bencher, BenchmarkGroup, BenchmarkId, Criterion, Throughput, criterion_group, criterion_main,
+    measurement::WallTime,
 };
 use rustpython_compiler::Mode;
 use rustpython_vm::{Interpreter, PyResult, Settings};
-use std::collections::HashMap;
-use std::path::Path;
+use std::{collections::HashMap, hint::black_box, path::Path};
 
 fn bench_cpython_code(b: &mut Bencher, source: &str) {
     let c_str_source_head = std::ffi::CString::new(source).unwrap();
     let c_str_source = c_str_source_head.as_c_str();
-    pyo3::Python::with_gil(|py| {
+    pyo3::Python::attach(|py| {
         b.iter(|| {
             let module = pyo3::types::PyModule::from_code(py, c_str_source, c"", c"")
                 .expect("Error running source");
@@ -54,7 +52,7 @@ pub fn benchmark_file_parsing(group: &mut BenchmarkGroup<WallTime>, name: &str,
     });
     group.bench_function(BenchmarkId::new("cpython", name), |b| {
         use pyo3::types::PyAnyMethods;
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::attach(|py| {
             let builtins =
                 pyo3::types::PyModule::import(py, "builtins").expect("Failed to import builtins");
             let compile = builtins.getattr("compile").expect("no compile in builtins");
diff --git a/benches/microbenchmarks.rs b/benches/microbenchmarks.rs
index 5f04f4bbf8..98993b4154 100644
--- a/benches/microbenchmarks.rs
+++ b/benches/microbenchmarks.rs
@@ -37,7 +37,7 @@ pub struct MicroBenchmark {
 }
 
 fn bench_cpython_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmark) {
-    pyo3::Python::with_gil(|py| {
+    pyo3::Python::attach(|py| {
         let setup_name = format!("{}_setup", bench.name);
         let setup_code = cpy_compile_code(py, &bench.setup, &setup_name).unwrap();
 
@@ -101,7 +101,10 @@ fn cpy_compile_code<'a>(
     let builtins =
         pyo3::types::PyModule::import(py, "builtins").expect("Failed to import builtins");
     let compile = builtins.getattr("compile").expect("no compile in builtins");
-    compile.call1((code, name, "exec"))?.extract()
+    Ok(compile
+        .call1((code, name, "exec"))?
+        .cast_into()
+        .expect("compile() should return a code object"))
 }
 
 fn bench_rustpython_code(group: &mut BenchmarkGroup<WallTime>, bench: &MicroBenchmark) {
diff --git a/benches/microbenchmarks/sorted.py b/benches/microbenchmarks/sorted.py
new file mode 100644
index 0000000000..8e5e0beeb1
--- /dev/null
+++ b/benches/microbenchmarks/sorted.py
@@ -0,0 +1,9 @@
+from random import random, seed
+seed(0)
+
+unsorted_list = [random() for _ in range(5 * ITERATIONS)]
+
+# ---
+
+# Setup code only runs once so do not modify in-place
+sorted(unsorted_list)
diff --git a/common/Cargo.toml b/common/Cargo.toml
deleted file mode 100644
index 94704d18c9..0000000000
--- a/common/Cargo.toml
+++ /dev/null
@@ -1,51 +0,0 @@
-[package]
-name = "rustpython-common"
-description = "General python functions and algorithms for use in RustPython"
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[features]
-threading = ["parking_lot"]
-
-[dependencies]
-rustpython-literal = { workspace = true }
-rustpython-wtf8 = { workspace = true }
-
-ascii = { workspace = true }
-bitflags = { workspace = true }
-bstr = { workspace = true }
-cfg-if = { workspace = true }
-getrandom = { workspace = true }
-itertools = { workspace = true }
-libc = { workspace = true }
-malachite-bigint = { workspace = true }
-malachite-q = { workspace = true }
-malachite-base = { workspace = true }
-memchr = { workspace = true }
-num-traits = { workspace = true }
-once_cell = { workspace = true }
-parking_lot = { workspace = true, optional = true }
-unicode_names2 = { workspace = true }
-radium = { workspace = true }
-
-lock_api = "0.4"
-siphasher = "1"
-num-complex.workspace = true
-
-[target.'cfg(windows)'.dependencies]
-widestring = { workspace = true }
-windows-sys = { workspace = true, features = [
-    "Win32_Foundation",
-    "Win32_Networking_WinSock",
-    "Win32_Storage_FileSystem",
-    "Win32_System_Ioctl",
-    "Win32_System_LibraryLoader",
-    "Win32_System_SystemServices",
-] }
-
-[lints]
-workspace = true
diff --git a/common/src/cformat.rs b/common/src/cformat.rs
deleted file mode 100644
index b553f0b6b1..0000000000
--- a/common/src/cformat.rs
+++ /dev/null
@@ -1,1163 +0,0 @@
-//! Implementation of Printf-Style string formatting
-//! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
-use bitflags::bitflags;
-use itertools::Itertools;
-use malachite_bigint::{BigInt, Sign};
-use num_traits::Signed;
-use rustpython_literal::{float, format::Case};
-use std::{
-    cmp, fmt,
-    iter::{Enumerate, Peekable},
-    str::FromStr,
-};
-
-use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-
-#[derive(Debug, PartialEq)]
-pub enum CFormatErrorType {
-    UnmatchedKeyParentheses,
-    MissingModuloSign,
-    UnsupportedFormatChar(CodePoint),
-    IncompleteFormat,
-    IntTooBig,
-    // Unimplemented,
-}
-
-// also contains how many chars the parsing function consumed
-pub type ParsingError = (CFormatErrorType, usize);
-
-#[derive(Debug, PartialEq)]
-pub struct CFormatError {
-    pub typ: CFormatErrorType, // FIXME
-    pub index: usize,
-}
-
-impl fmt::Display for CFormatError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CFormatErrorType::*;
-        match self.typ {
-            UnmatchedKeyParentheses => write!(f, "incomplete format key"),
-            IncompleteFormat => write!(f, "incomplete format"),
-            UnsupportedFormatChar(c) => write!(
-                f,
-                "unsupported format character '{}' ({:#x}) at index {}",
-                c,
-                c.to_u32(),
-                self.index
-            ),
-            IntTooBig => write!(f, "width/precision too big"),
-            _ => write!(f, "unexpected error parsing format string"),
-        }
-    }
-}
-
-pub type CFormatConversion = super::format::FormatConversion;
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[repr(u8)]
-pub enum CNumberType {
-    DecimalD = b'd',
-    DecimalI = b'i',
-    DecimalU = b'u',
-    Octal = b'o',
-    HexLower = b'x',
-    HexUpper = b'X',
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[repr(u8)]
-pub enum CFloatType {
-    ExponentLower = b'e',
-    ExponentUpper = b'E',
-    PointDecimalLower = b'f',
-    PointDecimalUpper = b'F',
-    GeneralLower = b'g',
-    GeneralUpper = b'G',
-}
-
-impl CFloatType {
-    const fn case(self) -> Case {
-        use CFloatType::*;
-
-        match self {
-            ExponentLower | PointDecimalLower | GeneralLower => Case::Lower,
-            ExponentUpper | PointDecimalUpper | GeneralUpper => Case::Upper,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-#[repr(u8)]
-pub enum CCharacterType {
-    Character = b'c',
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum CFormatType {
-    Number(CNumberType),
-    Float(CFloatType),
-    Character(CCharacterType),
-    String(CFormatConversion),
-}
-
-impl CFormatType {
-    pub const fn to_char(self) -> char {
-        match self {
-            Self::Number(x) => x as u8 as char,
-            Self::Float(x) => x as u8 as char,
-            Self::Character(x) => x as u8 as char,
-            Self::String(x) => x as u8 as char,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum CFormatPrecision {
-    Quantity(CFormatQuantity),
-    Dot,
-}
-
-impl From<CFormatQuantity> for CFormatPrecision {
-    fn from(quantity: CFormatQuantity) -> Self {
-        Self::Quantity(quantity)
-    }
-}
-
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct CConversionFlags: u32 {
-        const ALTERNATE_FORM = 0b0000_0001;
-        const ZERO_PAD = 0b0000_0010;
-        const LEFT_ADJUST = 0b0000_0100;
-        const BLANK_SIGN = 0b0000_1000;
-        const SIGN_CHAR = 0b0001_0000;
-    }
-}
-
-impl CConversionFlags {
-    #[inline]
-    pub const fn sign_string(&self) -> &'static str {
-        if self.contains(Self::SIGN_CHAR) {
-            "+"
-        } else if self.contains(Self::BLANK_SIGN) {
-            " "
-        } else {
-            ""
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub enum CFormatQuantity {
-    Amount(usize),
-    FromValuesTuple,
-}
-
-pub trait FormatBuf:
-    Extend<Self::Char> + Default + FromIterator<Self::Char> + From<String>
-{
-    type Char: FormatChar;
-    fn chars(&self) -> impl Iterator<Item = Self::Char>;
-    fn len(&self) -> usize;
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-    fn concat(self, other: Self) -> Self;
-}
-
-pub trait FormatChar: Copy + Into<CodePoint> + From<u8> {
-    fn to_char_lossy(self) -> char;
-    fn eq_char(self, c: char) -> bool;
-}
-
-impl FormatBuf for String {
-    type Char = char;
-
-    fn chars(&self) -> impl Iterator<Item = Self::Char> {
-        (**self).chars()
-    }
-
-    fn len(&self) -> usize {
-        self.len()
-    }
-
-    fn concat(mut self, other: Self) -> Self {
-        self.extend([other]);
-        self
-    }
-}
-
-impl FormatChar for char {
-    fn to_char_lossy(self) -> char {
-        self
-    }
-
-    fn eq_char(self, c: char) -> bool {
-        self == c
-    }
-}
-
-impl FormatBuf for Wtf8Buf {
-    type Char = CodePoint;
-
-    fn chars(&self) -> impl Iterator<Item = Self::Char> {
-        self.code_points()
-    }
-
-    fn len(&self) -> usize {
-        (**self).len()
-    }
-
-    fn concat(mut self, other: Self) -> Self {
-        self.extend([other]);
-        self
-    }
-}
-
-impl FormatChar for CodePoint {
-    fn to_char_lossy(self) -> char {
-        self.to_char_lossy()
-    }
-
-    fn eq_char(self, c: char) -> bool {
-        self == c
-    }
-}
-
-impl FormatBuf for Vec<u8> {
-    type Char = u8;
-
-    fn chars(&self) -> impl Iterator<Item = Self::Char> {
-        self.iter().copied()
-    }
-
-    fn len(&self) -> usize {
-        self.len()
-    }
-
-    fn concat(mut self, other: Self) -> Self {
-        self.extend(other);
-        self
-    }
-}
-
-impl FormatChar for u8 {
-    fn to_char_lossy(self) -> char {
-        self.into()
-    }
-
-    fn eq_char(self, c: char) -> bool {
-        char::from(self) == c
-    }
-}
-
-#[derive(Debug, PartialEq, Clone, Copy)]
-pub struct CFormatSpec {
-    pub flags: CConversionFlags,
-    pub min_field_width: Option<CFormatQuantity>,
-    pub precision: Option<CFormatPrecision>,
-    pub format_type: CFormatType,
-    // chars_consumed: usize,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct CFormatSpecKeyed<T> {
-    pub mapping_key: Option<T>,
-    pub spec: CFormatSpec,
-}
-
-#[cfg(test)]
-impl FromStr for CFormatSpec {
-    type Err = ParsingError;
-
-    fn from_str(text: &str) -> Result<Self, Self::Err> {
-        text.parse::<CFormatSpecKeyed<String>>()
-            .map(|CFormatSpecKeyed { mapping_key, spec }| {
-                assert!(mapping_key.is_none());
-                spec
-            })
-    }
-}
-
-impl FromStr for CFormatSpecKeyed<String> {
-    type Err = ParsingError;
-
-    fn from_str(text: &str) -> Result<Self, Self::Err> {
-        let mut chars = text.chars().enumerate().peekable();
-        if chars.next().map(|x| x.1) != Some('%') {
-            return Err((CFormatErrorType::MissingModuloSign, 1));
-        }
-
-        Self::parse(&mut chars)
-    }
-}
-
-pub type ParseIter<I> = Peekable<Enumerate<I>>;
-
-impl<T: FormatBuf> CFormatSpecKeyed<T> {
-    pub fn parse<I>(iter: &mut ParseIter<I>) -> Result<Self, ParsingError>
-    where
-        I: Iterator<Item = T::Char>,
-    {
-        let mapping_key = parse_spec_mapping_key(iter)?;
-        let flags = parse_flags(iter);
-        let min_field_width = parse_quantity(iter)?;
-        let precision = parse_precision(iter)?;
-        consume_length(iter);
-        let format_type = parse_format_type(iter)?;
-
-        let spec = CFormatSpec {
-            flags,
-            min_field_width,
-            precision,
-            format_type,
-        };
-        Ok(Self { mapping_key, spec })
-    }
-}
-
-impl CFormatSpec {
-    fn compute_fill_string<T: FormatBuf>(fill_char: T::Char, fill_chars_needed: usize) -> T {
-        (0..fill_chars_needed).map(|_| fill_char).collect()
-    }
-
-    fn fill_string<T: FormatBuf>(
-        &self,
-        string: T,
-        fill_char: T::Char,
-        num_prefix_chars: Option<usize>,
-    ) -> T {
-        let mut num_chars = string.chars().count();
-        if let Some(num_prefix_chars) = num_prefix_chars {
-            num_chars += num_prefix_chars;
-        }
-        let num_chars = num_chars;
-
-        let width = match &self.min_field_width {
-            Some(CFormatQuantity::Amount(width)) => cmp::max(width, &num_chars),
-            _ => &num_chars,
-        };
-        let fill_chars_needed = width.saturating_sub(num_chars);
-        let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
-
-        if !fill_string.is_empty() {
-            if self.flags.contains(CConversionFlags::LEFT_ADJUST) {
-                string.concat(fill_string)
-            } else {
-                fill_string.concat(string)
-            }
-        } else {
-            string
-        }
-    }
-
-    fn fill_string_with_precision<T: FormatBuf>(&self, string: T, fill_char: T::Char) -> T {
-        let num_chars = string.chars().count();
-
-        let width = match &self.precision {
-            Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(width))) => {
-                cmp::max(width, &num_chars)
-            }
-            _ => &num_chars,
-        };
-        let fill_chars_needed = width.saturating_sub(num_chars);
-        let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
-
-        if !fill_string.is_empty() {
-            // Don't left-adjust if precision-filling: that will always be prepending 0s to %d
-            // arguments, the LEFT_ADJUST flag will be used by a later call to fill_string with
-            // the 0-filled string as the string param.
-            fill_string.concat(string)
-        } else {
-            string
-        }
-    }
-
-    fn format_string_with_precision<T: FormatBuf>(
-        &self,
-        string: T,
-        precision: Option<&CFormatPrecision>,
-    ) -> T {
-        // truncate if needed
-        let string = match precision {
-            Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(precision)))
-                if string.chars().count() > *precision =>
-            {
-                string.chars().take(*precision).collect::<T>()
-            }
-            Some(CFormatPrecision::Dot) => {
-                // truncate to 0
-                T::default()
-            }
-            _ => string,
-        };
-        self.fill_string(string, b' '.into(), None)
-    }
-
-    #[inline]
-    pub fn format_string<T: FormatBuf>(&self, string: T) -> T {
-        self.format_string_with_precision(string, self.precision.as_ref())
-    }
-
-    #[inline]
-    pub fn format_char<T: FormatBuf>(&self, ch: T::Char) -> T {
-        self.format_string_with_precision(
-            T::from_iter([ch]),
-            Some(&(CFormatQuantity::Amount(1).into())),
-        )
-    }
-
-    pub fn format_bytes(&self, bytes: &[u8]) -> Vec<u8> {
-        let bytes = if let Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(precision))) =
-            self.precision
-        {
-            &bytes[..cmp::min(bytes.len(), precision)]
-        } else {
-            bytes
-        };
-        if let Some(CFormatQuantity::Amount(width)) = self.min_field_width {
-            let fill = cmp::max(0, width - bytes.len());
-            let mut v = Vec::with_capacity(bytes.len() + fill);
-            if self.flags.contains(CConversionFlags::LEFT_ADJUST) {
-                v.extend_from_slice(bytes);
-                v.append(&mut vec![b' '; fill]);
-            } else {
-                v.append(&mut vec![b' '; fill]);
-                v.extend_from_slice(bytes);
-            }
-            v
-        } else {
-            bytes.to_vec()
-        }
-    }
-
-    pub fn format_number(&self, num: &BigInt) -> String {
-        use CNumberType::*;
-        let CFormatType::Number(format_type) = self.format_type else {
-            unreachable!()
-        };
-        let magnitude = num.abs();
-        let prefix = if self.flags.contains(CConversionFlags::ALTERNATE_FORM) {
-            match format_type {
-                Octal => "0o",
-                HexLower => "0x",
-                HexUpper => "0X",
-                _ => "",
-            }
-        } else {
-            ""
-        };
-
-        let magnitude_string: String = match format_type {
-            DecimalD | DecimalI | DecimalU => magnitude.to_str_radix(10),
-            Octal => magnitude.to_str_radix(8),
-            HexLower => magnitude.to_str_radix(16),
-            HexUpper => {
-                let mut result = magnitude.to_str_radix(16);
-                result.make_ascii_uppercase();
-                result
-            }
-        };
-
-        let sign_string = match num.sign() {
-            Sign::Minus => "-",
-            _ => self.flags.sign_string(),
-        };
-
-        let padded_magnitude_string = self.fill_string_with_precision(magnitude_string, '0');
-
-        if self.flags.contains(CConversionFlags::ZERO_PAD) {
-            let fill_char = if !self.flags.contains(CConversionFlags::LEFT_ADJUST) {
-                '0'
-            } else {
-                ' ' // '-' overrides the '0' conversion if both are given
-            };
-            let signed_prefix = format!("{sign_string}{prefix}");
-            format!(
-                "{}{}",
-                signed_prefix,
-                self.fill_string(
-                    padded_magnitude_string,
-                    fill_char,
-                    Some(signed_prefix.chars().count()),
-                ),
-            )
-        } else {
-            self.fill_string(
-                format!("{sign_string}{prefix}{padded_magnitude_string}"),
-                ' ',
-                None,
-            )
-        }
-    }
-
-    pub fn format_float(&self, num: f64) -> String {
-        let sign_string = if num.is_sign_negative() && !num.is_nan() {
-            "-"
-        } else {
-            self.flags.sign_string()
-        };
-
-        let precision = match &self.precision {
-            Some(CFormatPrecision::Quantity(quantity)) => match quantity {
-                CFormatQuantity::Amount(amount) => *amount,
-                CFormatQuantity::FromValuesTuple => 6,
-            },
-            Some(CFormatPrecision::Dot) => 0,
-            None => 6,
-        };
-
-        let CFormatType::Float(format_type) = self.format_type else {
-            unreachable!()
-        };
-
-        let magnitude = num.abs();
-        let case = format_type.case();
-
-        let magnitude_string = match format_type {
-            CFloatType::PointDecimalLower | CFloatType::PointDecimalUpper => float::format_fixed(
-                precision,
-                magnitude,
-                case,
-                self.flags.contains(CConversionFlags::ALTERNATE_FORM),
-            ),
-            CFloatType::ExponentLower | CFloatType::ExponentUpper => float::format_exponent(
-                precision,
-                magnitude,
-                case,
-                self.flags.contains(CConversionFlags::ALTERNATE_FORM),
-            ),
-            CFloatType::GeneralLower | CFloatType::GeneralUpper => {
-                let precision = if precision == 0 { 1 } else { precision };
-                float::format_general(
-                    precision,
-                    magnitude,
-                    case,
-                    self.flags.contains(CConversionFlags::ALTERNATE_FORM),
-                    false,
-                )
-            }
-        };
-
-        if self.flags.contains(CConversionFlags::ZERO_PAD) {
-            let fill_char = if !self.flags.contains(CConversionFlags::LEFT_ADJUST) {
-                '0'
-            } else {
-                ' '
-            };
-            format!(
-                "{}{}",
-                sign_string,
-                self.fill_string(
-                    magnitude_string,
-                    fill_char,
-                    Some(sign_string.chars().count()),
-                )
-            )
-        } else {
-            self.fill_string(format!("{sign_string}{magnitude_string}"), ' ', None)
-        }
-    }
-}
-
-fn parse_spec_mapping_key<T, I>(iter: &mut ParseIter<I>) -> Result<Option<T>, ParsingError>
-where
-    T: FormatBuf,
-    I: Iterator<Item = T::Char>,
-{
-    if let Some((index, _)) = iter.next_if(|(_, c)| c.eq_char('(')) {
-        return match parse_text_inside_parentheses(iter) {
-            Some(key) => Ok(Some(key)),
-            None => Err((CFormatErrorType::UnmatchedKeyParentheses, index)),
-        };
-    }
-    Ok(None)
-}
-
-fn parse_flags<C, I>(iter: &mut ParseIter<I>) -> CConversionFlags
-where
-    C: FormatChar,
-    I: Iterator<Item = C>,
-{
-    let mut flags = CConversionFlags::empty();
-    iter.peeking_take_while(|(_, c)| {
-        let flag = match c.to_char_lossy() {
-            '#' => CConversionFlags::ALTERNATE_FORM,
-            '0' => CConversionFlags::ZERO_PAD,
-            '-' => CConversionFlags::LEFT_ADJUST,
-            ' ' => CConversionFlags::BLANK_SIGN,
-            '+' => CConversionFlags::SIGN_CHAR,
-            _ => return false,
-        };
-        flags |= flag;
-        true
-    })
-    .for_each(drop);
-    flags
-}
-
-fn consume_length<C, I>(iter: &mut ParseIter<I>)
-where
-    C: FormatChar,
-    I: Iterator<Item = C>,
-{
-    iter.next_if(|(_, c)| matches!(c.to_char_lossy(), 'h' | 'l' | 'L'));
-}
-
-fn parse_format_type<C, I>(iter: &mut ParseIter<I>) -> Result<CFormatType, ParsingError>
-where
-    C: FormatChar,
-    I: Iterator<Item = C>,
-{
-    use CFloatType::*;
-    use CNumberType::*;
-    let (index, c) = iter.next().ok_or_else(|| {
-        (
-            CFormatErrorType::IncompleteFormat,
-            iter.peek().map(|x| x.0).unwrap_or(0),
-        )
-    })?;
-    let format_type = match c.to_char_lossy() {
-        'd' => CFormatType::Number(DecimalD),
-        'i' => CFormatType::Number(DecimalI),
-        'u' => CFormatType::Number(DecimalU),
-        'o' => CFormatType::Number(Octal),
-        'x' => CFormatType::Number(HexLower),
-        'X' => CFormatType::Number(HexUpper),
-        'e' => CFormatType::Float(ExponentLower),
-        'E' => CFormatType::Float(ExponentUpper),
-        'f' => CFormatType::Float(PointDecimalLower),
-        'F' => CFormatType::Float(PointDecimalUpper),
-        'g' => CFormatType::Float(GeneralLower),
-        'G' => CFormatType::Float(GeneralUpper),
-        'c' => CFormatType::Character(CCharacterType::Character),
-        'r' => CFormatType::String(CFormatConversion::Repr),
-        's' => CFormatType::String(CFormatConversion::Str),
-        'b' => CFormatType::String(CFormatConversion::Bytes),
-        'a' => CFormatType::String(CFormatConversion::Ascii),
-        _ => return Err((CFormatErrorType::UnsupportedFormatChar(c.into()), index)),
-    };
-    Ok(format_type)
-}
-
-fn parse_quantity<C, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatQuantity>, ParsingError>
-where
-    C: FormatChar,
-    I: Iterator<Item = C>,
-{
-    if let Some(&(_, c)) = iter.peek() {
-        if c.eq_char('*') {
-            iter.next().unwrap();
-            return Ok(Some(CFormatQuantity::FromValuesTuple));
-        }
-        if let Some(i) = c.to_char_lossy().to_digit(10) {
-            let mut num = i as i32;
-            iter.next().unwrap();
-            while let Some(&(index, c)) = iter.peek() {
-                if let Some(i) = c.to_char_lossy().to_digit(10) {
-                    num = num
-                        .checked_mul(10)
-                        .and_then(|num| num.checked_add(i as i32))
-                        .ok_or((CFormatErrorType::IntTooBig, index))?;
-                    iter.next().unwrap();
-                } else {
-                    break;
-                }
-            }
-            return Ok(Some(CFormatQuantity::Amount(num.unsigned_abs() as usize)));
-        }
-    }
-    Ok(None)
-}
-
-fn parse_precision<C, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatPrecision>, ParsingError>
-where
-    C: FormatChar,
-    I: Iterator<Item = C>,
-{
-    if iter.next_if(|(_, c)| c.eq_char('.')).is_some() {
-        let quantity = parse_quantity(iter)?;
-        let precision = quantity.map_or(CFormatPrecision::Dot, CFormatPrecision::Quantity);
-        return Ok(Some(precision));
-    }
-    Ok(None)
-}
-
-fn parse_text_inside_parentheses<T, I>(iter: &mut ParseIter<I>) -> Option<T>
-where
-    T: FormatBuf,
-    I: Iterator<Item = T::Char>,
-{
-    let mut counter: i32 = 1;
-    let mut contained_text = T::default();
-    loop {
-        let (_, c) = iter.next()?;
-        match c.to_char_lossy() {
-            '(' => {
-                counter += 1;
-            }
-            ')' => {
-                counter -= 1;
-            }
-            _ => (),
-        }
-
-        if counter > 0 {
-            contained_text.extend([c]);
-        } else {
-            break;
-        }
-    }
-
-    Some(contained_text)
-}
-
-#[derive(Debug, PartialEq)]
-pub enum CFormatPart<T> {
-    Literal(T),
-    Spec(CFormatSpecKeyed<T>),
-}
-
-impl<T> CFormatPart<T> {
-    #[inline]
-    pub const fn is_specifier(&self) -> bool {
-        matches!(self, Self::Spec { .. })
-    }
-
-    #[inline]
-    pub const fn has_key(&self) -> bool {
-        match self {
-            Self::Spec(s) => s.mapping_key.is_some(),
-            _ => false,
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct CFormatStrOrBytes<S> {
-    parts: Vec<(usize, CFormatPart<S>)>,
-}
-
-impl<S> CFormatStrOrBytes<S> {
-    pub fn check_specifiers(&self) -> Option<(usize, bool)> {
-        let mut count = 0;
-        let mut mapping_required = false;
-        for (_, part) in &self.parts {
-            if part.is_specifier() {
-                let has_key = part.has_key();
-                if count == 0 {
-                    mapping_required = has_key;
-                } else if mapping_required != has_key {
-                    return None;
-                }
-                count += 1;
-            }
-        }
-        Some((count, mapping_required))
-    }
-
-    #[inline]
-    pub fn iter(&self) -> impl Iterator<Item = &(usize, CFormatPart<S>)> {
-        self.parts.iter()
-    }
-
-    #[inline]
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (usize, CFormatPart<S>)> {
-        self.parts.iter_mut()
-    }
-
-    pub fn parse<I>(iter: &mut ParseIter<I>) -> Result<Self, CFormatError>
-    where
-        S: FormatBuf,
-        I: Iterator<Item = S::Char>,
-    {
-        let mut parts = vec![];
-        let mut literal = S::default();
-        let mut part_index = 0;
-        while let Some((index, c)) = iter.next() {
-            if c.eq_char('%') {
-                if let Some(&(_, second)) = iter.peek() {
-                    if second.eq_char('%') {
-                        iter.next().unwrap();
-                        literal.extend([second]);
-                        continue;
-                    } else {
-                        if !literal.is_empty() {
-                            parts.push((
-                                part_index,
-                                CFormatPart::Literal(std::mem::take(&mut literal)),
-                            ));
-                        }
-                        let spec = CFormatSpecKeyed::parse(iter).map_err(|err| CFormatError {
-                            typ: err.0,
-                            index: err.1,
-                        })?;
-                        parts.push((index, CFormatPart::Spec(spec)));
-                        if let Some(&(index, _)) = iter.peek() {
-                            part_index = index;
-                        }
-                    }
-                } else {
-                    return Err(CFormatError {
-                        typ: CFormatErrorType::IncompleteFormat,
-                        index: index + 1,
-                    });
-                }
-            } else {
-                literal.extend([c]);
-            }
-        }
-        if !literal.is_empty() {
-            parts.push((part_index, CFormatPart::Literal(literal)));
-        }
-        Ok(Self { parts })
-    }
-}
-
-impl<S> IntoIterator for CFormatStrOrBytes<S> {
-    type Item = (usize, CFormatPart<S>);
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.parts.into_iter()
-    }
-}
-
-pub type CFormatBytes = CFormatStrOrBytes<Vec<u8>>;
-
-impl CFormatBytes {
-    pub fn parse_from_bytes(bytes: &[u8]) -> Result<Self, CFormatError> {
-        let mut iter = bytes.iter().cloned().enumerate().peekable();
-        Self::parse(&mut iter)
-    }
-}
-
-pub type CFormatString = CFormatStrOrBytes<String>;
-
-impl FromStr for CFormatString {
-    type Err = CFormatError;
-
-    fn from_str(text: &str) -> Result<Self, Self::Err> {
-        let mut iter = text.chars().enumerate().peekable();
-        Self::parse(&mut iter)
-    }
-}
-
-pub type CFormatWtf8 = CFormatStrOrBytes<Wtf8Buf>;
-
-impl CFormatWtf8 {
-    pub fn parse_from_wtf8(s: &Wtf8) -> Result<Self, CFormatError> {
-        let mut iter = s.code_points().enumerate().peekable();
-        Self::parse(&mut iter)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_fill_and_align() {
-        assert_eq!(
-            "%10s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("test".to_owned()),
-            "      test".to_owned()
-        );
-        assert_eq!(
-            "%-10s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("test".to_owned()),
-            "test      ".to_owned()
-        );
-        assert_eq!(
-            "%#10x"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(0x1337)),
-            "    0x1337".to_owned()
-        );
-        assert_eq!(
-            "%-#10x"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(0x1337)),
-            "0x1337    ".to_owned()
-        );
-    }
-
-    #[test]
-    fn test_parse_key() {
-        let expected = Ok(CFormatSpecKeyed {
-            mapping_key: Some("amount".to_owned()),
-            spec: CFormatSpec {
-                format_type: CFormatType::Number(CNumberType::DecimalD),
-                min_field_width: None,
-                precision: None,
-                flags: CConversionFlags::empty(),
-            },
-        });
-        assert_eq!("%(amount)d".parse::<CFormatSpecKeyed<String>>(), expected);
-
-        let expected = Ok(CFormatSpecKeyed {
-            mapping_key: Some("m((u(((l((((ti))))p)))l))e".to_owned()),
-            spec: CFormatSpec {
-                format_type: CFormatType::Number(CNumberType::DecimalD),
-                min_field_width: None,
-                precision: None,
-                flags: CConversionFlags::empty(),
-            },
-        });
-        assert_eq!(
-            "%(m((u(((l((((ti))))p)))l))e)d".parse::<CFormatSpecKeyed<String>>(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_format_parse_key_fail() {
-        assert_eq!(
-            "%(aged".parse::<CFormatString>(),
-            Err(CFormatError {
-                typ: CFormatErrorType::UnmatchedKeyParentheses,
-                index: 1
-            })
-        );
-    }
-
-    #[test]
-    fn test_format_parse_type_fail() {
-        assert_eq!(
-            "Hello %n".parse::<CFormatString>(),
-            Err(CFormatError {
-                typ: CFormatErrorType::UnsupportedFormatChar('n'.into()),
-                index: 7
-            })
-        );
-    }
-
-    #[test]
-    fn test_incomplete_format_fail() {
-        assert_eq!(
-            "Hello %".parse::<CFormatString>(),
-            Err(CFormatError {
-                typ: CFormatErrorType::IncompleteFormat,
-                index: 7
-            })
-        );
-    }
-
-    #[test]
-    fn test_parse_flags() {
-        let expected = Ok(CFormatSpec {
-            format_type: CFormatType::Number(CNumberType::DecimalD),
-            min_field_width: Some(CFormatQuantity::Amount(10)),
-            precision: None,
-            flags: CConversionFlags::all(),
-        });
-        let parsed = "%  0   -+++###10d".parse::<CFormatSpec>();
-        assert_eq!(parsed, expected);
-        assert_eq!(
-            parsed.unwrap().format_number(&BigInt::from(12)),
-            "+12       ".to_owned()
-        );
-    }
-
-    #[test]
-    fn test_parse_and_format_string() {
-        assert_eq!(
-            "%5.4s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("Hello, World!".to_owned()),
-            " Hell".to_owned()
-        );
-        assert_eq!(
-            "%-5.4s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("Hello, World!".to_owned()),
-            "Hell ".to_owned()
-        );
-        assert_eq!(
-            "%.s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("Hello, World!".to_owned()),
-            "".to_owned()
-        );
-        assert_eq!(
-            "%5.s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("Hello, World!".to_owned()),
-            "     ".to_owned()
-        );
-    }
-
-    #[test]
-    fn test_parse_and_format_unicode_string() {
-        assert_eq!(
-            "%.2s"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_string("❤❤❤❤❤❤❤❤".to_owned()),
-            "❤❤".to_owned()
-        );
-    }
-
-    #[test]
-    fn test_parse_and_format_number() {
-        assert_eq!(
-            "%5d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(27)),
-            "   27".to_owned()
-        );
-        assert_eq!(
-            "%05d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(27)),
-            "00027".to_owned()
-        );
-        assert_eq!(
-            "%.5d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(27)),
-            "00027".to_owned()
-        );
-        assert_eq!(
-            "%+05d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(27)),
-            "+0027".to_owned()
-        );
-        assert_eq!(
-            "%-d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(-27)),
-            "-27".to_owned()
-        );
-        assert_eq!(
-            "% d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(27)),
-            " 27".to_owned()
-        );
-        assert_eq!(
-            "% d"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(-27)),
-            "-27".to_owned()
-        );
-        assert_eq!(
-            "%08x"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(0x1337)),
-            "00001337".to_owned()
-        );
-        assert_eq!(
-            "%#010x"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(0x1337)),
-            "0x00001337".to_owned()
-        );
-        assert_eq!(
-            "%-#010x"
-                .parse::<CFormatSpec>()
-                .unwrap()
-                .format_number(&BigInt::from(0x1337)),
-            "0x1337    ".to_owned()
-        );
-    }
-
-    #[test]
-    fn test_parse_and_format_float() {
-        assert_eq!(
-            "%f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            "1.234500"
-        );
-        assert_eq!(
-            "%.2f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            "1.23"
-        );
-        assert_eq!(
-            "%.f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            "1"
-        );
-        assert_eq!(
-            "%+.f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            "+1"
-        );
-        assert_eq!(
-            "%+f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            "+1.234500"
-        );
-        assert_eq!(
-            "% f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
-            " 1.234500"
-        );
-        assert_eq!(
-            "%f".parse::<CFormatSpec>().unwrap().format_float(-1.2345),
-            "-1.234500"
-        );
-        assert_eq!(
-            "%f".parse::<CFormatSpec>()
-                .unwrap()
-                .format_float(1.2345678901),
-            "1.234568"
-        );
-    }
-
-    #[test]
-    fn test_format_parse() {
-        let fmt = "Hello, my name is %s and I'm %d years old";
-        let expected = Ok(CFormatString {
-            parts: vec![
-                (0, CFormatPart::Literal("Hello, my name is ".to_owned())),
-                (
-                    18,
-                    CFormatPart::Spec(CFormatSpecKeyed {
-                        mapping_key: None,
-                        spec: CFormatSpec {
-                            format_type: CFormatType::String(CFormatConversion::Str),
-                            min_field_width: None,
-                            precision: None,
-                            flags: CConversionFlags::empty(),
-                        },
-                    }),
-                ),
-                (20, CFormatPart::Literal(" and I'm ".to_owned())),
-                (
-                    29,
-                    CFormatPart::Spec(CFormatSpecKeyed {
-                        mapping_key: None,
-                        spec: CFormatSpec {
-                            format_type: CFormatType::Number(CNumberType::DecimalD),
-                            min_field_width: None,
-                            precision: None,
-                            flags: CConversionFlags::empty(),
-                        },
-                    }),
-                ),
-                (31, CFormatPart::Literal(" years old".to_owned())),
-            ],
-        });
-        let result = fmt.parse::<CFormatString>();
-        assert_eq!(
-            result, expected,
-            "left = {result:#?} \n\n\n right = {expected:#?}"
-        );
-    }
-}
diff --git a/common/src/crt_fd.rs b/common/src/crt_fd.rs
deleted file mode 100644
index 64d4df98a5..0000000000
--- a/common/src/crt_fd.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-//! A module implementing an io type backed by the C runtime's file descriptors, i.e. what's
-//! returned from libc::open, even on windows.
-
-use std::{cmp, ffi, io};
-
-#[cfg(windows)]
-use libc::commit as fsync;
-#[cfg(windows)]
-unsafe extern "C" {
-    #[link_name = "_chsize_s"]
-    fn ftruncate(fd: i32, len: i64) -> i32;
-}
-#[cfg(not(windows))]
-use libc::{fsync, ftruncate};
-
-// this is basically what CPython has for Py_off_t; windows uses long long
-// for offsets, other platforms just use off_t
-#[cfg(not(windows))]
-pub type Offset = libc::off_t;
-#[cfg(windows)]
-pub type Offset = libc::c_longlong;
-
-#[inline]
-fn cvt<T, I: num_traits::PrimInt>(ret: I, f: impl FnOnce(I) -> T) -> io::Result<T> {
-    if ret < I::zero() {
-        Err(crate::os::last_os_error())
-    } else {
-        Ok(f(ret))
-    }
-}
-
-const MAX_RW: usize = if cfg!(any(windows, target_vendor = "apple")) {
-    i32::MAX as usize
-} else {
-    isize::MAX as usize
-};
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct Fd(pub i32);
-
-impl Fd {
-    pub fn open(path: &ffi::CStr, flags: i32, mode: i32) -> io::Result<Self> {
-        cvt(unsafe { libc::open(path.as_ptr(), flags, mode) }, Fd)
-    }
-
-    #[cfg(windows)]
-    pub fn wopen(path: &widestring::WideCStr, flags: i32, mode: i32) -> io::Result<Self> {
-        cvt(
-            unsafe { suppress_iph!(libc::wopen(path.as_ptr(), flags, mode)) },
-            Fd,
-        )
-    }
-
-    #[cfg(all(any(unix, target_os = "wasi"), not(target_os = "redox")))]
-    pub fn openat(&self, path: &ffi::CStr, flags: i32, mode: i32) -> io::Result<Self> {
-        cvt(
-            unsafe { libc::openat(self.0, path.as_ptr(), flags, mode) },
-            Fd,
-        )
-    }
-
-    pub fn fsync(&self) -> io::Result<()> {
-        cvt(unsafe { suppress_iph!(fsync(self.0)) }, drop)
-    }
-
-    pub fn close(&self) -> io::Result<()> {
-        cvt(unsafe { suppress_iph!(libc::close(self.0)) }, drop)
-    }
-
-    pub fn ftruncate(&self, len: Offset) -> io::Result<()> {
-        cvt(unsafe { suppress_iph!(ftruncate(self.0, len)) }, drop)
-    }
-
-    #[cfg(windows)]
-    pub fn to_raw_handle(&self) -> io::Result<std::os::windows::io::RawHandle> {
-        unsafe extern "C" {
-            fn _get_osfhandle(fd: i32) -> libc::intptr_t;
-        }
-        let handle = unsafe { suppress_iph!(_get_osfhandle(self.0)) };
-        if handle == -1 {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(handle as _)
-        }
-    }
-}
-
-impl io::Write for Fd {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let count = cmp::min(buf.len(), MAX_RW);
-        cvt(
-            unsafe { suppress_iph!(libc::write(self.0, buf.as_ptr() as _, count as _)) },
-            |i| i as usize,
-        )
-    }
-
-    #[inline]
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl io::Read for Fd {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let count = cmp::min(buf.len(), MAX_RW);
-        cvt(
-            unsafe { suppress_iph!(libc::read(self.0, buf.as_mut_ptr() as _, count as _)) },
-            |i| i as usize,
-        )
-    }
-}
diff --git a/common/src/format.rs b/common/src/format.rs
deleted file mode 100644
index 92ab99a571..0000000000
--- a/common/src/format.rs
+++ /dev/null
@@ -1,1477 +0,0 @@
-// spell-checker:ignore ddfe
-use itertools::{Itertools, PeekingNext};
-use malachite_base::num::basic::floats::PrimitiveFloat;
-use malachite_bigint::{BigInt, Sign};
-use num_complex::Complex64;
-use num_traits::FromPrimitive;
-use num_traits::{Signed, cast::ToPrimitive};
-use rustpython_literal::float;
-use rustpython_literal::format::Case;
-use std::ops::Deref;
-use std::{cmp, str::FromStr};
-
-use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-
-trait FormatParse {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8)
-    where
-        Self: Sized;
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-#[repr(u8)]
-pub enum FormatConversion {
-    Str = b's',
-    Repr = b'r',
-    Ascii = b'b',
-    Bytes = b'a',
-}
-
-impl FormatParse for FormatConversion {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
-        let Some(conversion) = Self::from_string(text) else {
-            return (None, text);
-        };
-        let mut chars = text.code_points();
-        chars.next(); // Consume the bang
-        chars.next(); // Consume one r,s,a char
-        (Some(conversion), chars.as_wtf8())
-    }
-}
-
-impl FormatConversion {
-    pub fn from_char(c: CodePoint) -> Option<Self> {
-        match c.to_char_lossy() {
-            's' => Some(Self::Str),
-            'r' => Some(Self::Repr),
-            'a' => Some(Self::Ascii),
-            'b' => Some(Self::Bytes),
-            _ => None,
-        }
-    }
-
-    fn from_string(text: &Wtf8) -> Option<Self> {
-        let mut chars = text.code_points();
-        if chars.next()? != '!' {
-            return None;
-        }
-
-        Self::from_char(chars.next()?)
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum FormatAlign {
-    Left,
-    Right,
-    AfterSign,
-    Center,
-}
-
-impl FormatAlign {
-    fn from_char(c: CodePoint) -> Option<Self> {
-        match c.to_char_lossy() {
-            '<' => Some(Self::Left),
-            '>' => Some(Self::Right),
-            '=' => Some(Self::AfterSign),
-            '^' => Some(Self::Center),
-            _ => None,
-        }
-    }
-}
-
-impl FormatParse for FormatAlign {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
-        let mut chars = text.code_points();
-        if let Some(maybe_align) = chars.next().and_then(Self::from_char) {
-            (Some(maybe_align), chars.as_wtf8())
-        } else {
-            (None, text)
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum FormatSign {
-    Plus,
-    Minus,
-    MinusOrSpace,
-}
-
-impl FormatParse for FormatSign {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
-        let mut chars = text.code_points();
-        match chars.next().and_then(CodePoint::to_char) {
-            Some('-') => (Some(Self::Minus), chars.as_wtf8()),
-            Some('+') => (Some(Self::Plus), chars.as_wtf8()),
-            Some(' ') => (Some(Self::MinusOrSpace), chars.as_wtf8()),
-            _ => (None, text),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FormatGrouping {
-    Comma,
-    Underscore,
-}
-
-impl FormatParse for FormatGrouping {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
-        let mut chars = text.code_points();
-        match chars.next().and_then(CodePoint::to_char) {
-            Some('_') => (Some(Self::Underscore), chars.as_wtf8()),
-            Some(',') => (Some(Self::Comma), chars.as_wtf8()),
-            _ => (None, text),
-        }
-    }
-}
-
-impl From<&FormatGrouping> for char {
-    fn from(fg: &FormatGrouping) -> Self {
-        match fg {
-            FormatGrouping::Comma => ',',
-            FormatGrouping::Underscore => '_',
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FormatType {
-    String,
-    Binary,
-    Character,
-    Decimal,
-    Octal,
-    Number(Case),
-    Hex(Case),
-    Exponent(Case),
-    GeneralFormat(Case),
-    FixedPoint(Case),
-    Percentage,
-}
-
-impl From<&FormatType> for char {
-    fn from(from: &FormatType) -> Self {
-        match from {
-            FormatType::String => 's',
-            FormatType::Binary => 'b',
-            FormatType::Character => 'c',
-            FormatType::Decimal => 'd',
-            FormatType::Octal => 'o',
-            FormatType::Number(Case::Lower) => 'n',
-            FormatType::Number(Case::Upper) => 'N',
-            FormatType::Hex(Case::Lower) => 'x',
-            FormatType::Hex(Case::Upper) => 'X',
-            FormatType::Exponent(Case::Lower) => 'e',
-            FormatType::Exponent(Case::Upper) => 'E',
-            FormatType::GeneralFormat(Case::Lower) => 'g',
-            FormatType::GeneralFormat(Case::Upper) => 'G',
-            FormatType::FixedPoint(Case::Lower) => 'f',
-            FormatType::FixedPoint(Case::Upper) => 'F',
-            FormatType::Percentage => '%',
-        }
-    }
-}
-
-impl FormatParse for FormatType {
-    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
-        let mut chars = text.code_points();
-        match chars.next().and_then(CodePoint::to_char) {
-            Some('s') => (Some(Self::String), chars.as_wtf8()),
-            Some('b') => (Some(Self::Binary), chars.as_wtf8()),
-            Some('c') => (Some(Self::Character), chars.as_wtf8()),
-            Some('d') => (Some(Self::Decimal), chars.as_wtf8()),
-            Some('o') => (Some(Self::Octal), chars.as_wtf8()),
-            Some('n') => (Some(Self::Number(Case::Lower)), chars.as_wtf8()),
-            Some('N') => (Some(Self::Number(Case::Upper)), chars.as_wtf8()),
-            Some('x') => (Some(Self::Hex(Case::Lower)), chars.as_wtf8()),
-            Some('X') => (Some(Self::Hex(Case::Upper)), chars.as_wtf8()),
-            Some('e') => (Some(Self::Exponent(Case::Lower)), chars.as_wtf8()),
-            Some('E') => (Some(Self::Exponent(Case::Upper)), chars.as_wtf8()),
-            Some('f') => (Some(Self::FixedPoint(Case::Lower)), chars.as_wtf8()),
-            Some('F') => (Some(Self::FixedPoint(Case::Upper)), chars.as_wtf8()),
-            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()),
-            _ => (None, text),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub struct FormatSpec {
-    conversion: Option<FormatConversion>,
-    fill: Option<CodePoint>,
-    align: Option<FormatAlign>,
-    sign: Option<FormatSign>,
-    alternate_form: bool,
-    width: Option<usize>,
-    grouping_option: Option<FormatGrouping>,
-    precision: Option<usize>,
-    format_type: Option<FormatType>,
-}
-
-fn get_num_digits(text: &Wtf8) -> usize {
-    for (index, character) in text.code_point_indices() {
-        if !character.is_char_and(|c| c.is_ascii_digit()) {
-            return index;
-        }
-    }
-    text.len()
-}
-
-fn parse_fill_and_align(text: &Wtf8) -> (Option<CodePoint>, Option<FormatAlign>, &Wtf8) {
-    let char_indices: Vec<(usize, CodePoint)> = text.code_point_indices().take(3).collect();
-    if char_indices.is_empty() {
-        (None, None, text)
-    } else if char_indices.len() == 1 {
-        let (maybe_align, remaining) = FormatAlign::parse(text);
-        (None, maybe_align, remaining)
-    } else {
-        let (maybe_align, remaining) = FormatAlign::parse(&text[char_indices[1].0..]);
-        if maybe_align.is_some() {
-            (Some(char_indices[0].1), maybe_align, remaining)
-        } else {
-            let (only_align, only_align_remaining) = FormatAlign::parse(text);
-            (None, only_align, only_align_remaining)
-        }
-    }
-}
-
-fn parse_number(text: &Wtf8) -> Result<(Option<usize>, &Wtf8), FormatSpecError> {
-    let num_digits: usize = get_num_digits(text);
-    if num_digits == 0 {
-        return Ok((None, text));
-    }
-    if let Some(num) = parse_usize(&text[..num_digits]) {
-        Ok((Some(num), &text[num_digits..]))
-    } else {
-        // NOTE: this condition is different from CPython
-        Err(FormatSpecError::DecimalDigitsTooMany)
-    }
-}
-
-fn parse_alternate_form(text: &Wtf8) -> (bool, &Wtf8) {
-    let mut chars = text.code_points();
-    match chars.next().and_then(CodePoint::to_char) {
-        Some('#') => (true, chars.as_wtf8()),
-        _ => (false, text),
-    }
-}
-
-fn parse_zero(text: &Wtf8) -> (bool, &Wtf8) {
-    let mut chars = text.code_points();
-    match chars.next().and_then(CodePoint::to_char) {
-        Some('0') => (true, chars.as_wtf8()),
-        _ => (false, text),
-    }
-}
-
-fn parse_precision(text: &Wtf8) -> Result<(Option<usize>, &Wtf8), FormatSpecError> {
-    let mut chars = text.code_points();
-    Ok(match chars.next().and_then(CodePoint::to_char) {
-        Some('.') => {
-            let (size, remaining) = parse_number(chars.as_wtf8())?;
-            if let Some(size) = size {
-                if size > i32::MAX as usize {
-                    return Err(FormatSpecError::PrecisionTooBig);
-                }
-                (Some(size), remaining)
-            } else {
-                (None, text)
-            }
-        }
-        _ => (None, text),
-    })
-}
-
-impl FormatSpec {
-    pub fn parse(text: impl AsRef<Wtf8>) -> Result<Self, FormatSpecError> {
-        Self::_parse(text.as_ref())
-    }
-
-    fn _parse(text: &Wtf8) -> Result<Self, FormatSpecError> {
-        // get_integer in CPython
-        let (conversion, text) = FormatConversion::parse(text);
-        let (mut fill, mut align, text) = parse_fill_and_align(text);
-        let (sign, text) = FormatSign::parse(text);
-        let (alternate_form, text) = parse_alternate_form(text);
-        let (zero, text) = parse_zero(text);
-        let (width, text) = parse_number(text)?;
-        let (grouping_option, text) = FormatGrouping::parse(text);
-        if let Some(grouping) = &grouping_option {
-            Self::validate_separator(grouping, text)?;
-        }
-        let (precision, text) = parse_precision(text)?;
-        let (format_type, text) = FormatType::parse(text);
-        if !text.is_empty() {
-            return Err(FormatSpecError::InvalidFormatSpecifier);
-        }
-
-        if zero && fill.is_none() {
-            fill.replace('0'.into());
-            align = align.or(Some(FormatAlign::AfterSign));
-        }
-
-        Ok(Self {
-            conversion,
-            fill,
-            align,
-            sign,
-            alternate_form,
-            width,
-            grouping_option,
-            precision,
-            format_type,
-        })
-    }
-
-    fn validate_separator(grouping: &FormatGrouping, text: &Wtf8) -> Result<(), FormatSpecError> {
-        let mut chars = text.code_points().peekable();
-        match chars.peek().and_then(|cp| CodePoint::to_char(*cp)) {
-            Some(c) if c == ',' || c == '_' => {
-                if c == char::from(grouping) {
-                    Err(FormatSpecError::UnspecifiedFormat(c, c))
-                } else {
-                    Err(FormatSpecError::ExclusiveFormat(',', '_'))
-                }
-            }
-            _ => Ok(()),
-        }
-    }
-
-    fn compute_fill_string(fill_char: CodePoint, fill_chars_needed: i32) -> Wtf8Buf {
-        (0..fill_chars_needed).map(|_| fill_char).collect()
-    }
-
-    fn add_magnitude_separators_for_char(
-        magnitude_str: String,
-        inter: i32,
-        sep: char,
-        disp_digit_cnt: i32,
-    ) -> String {
-        // Don't add separators to the floating decimal point of numbers
-        let mut parts = magnitude_str.splitn(2, '.');
-        let magnitude_int_str = parts.next().unwrap().to_string();
-        let dec_digit_cnt = magnitude_str.len() as i32 - magnitude_int_str.len() as i32;
-        let int_digit_cnt = disp_digit_cnt - dec_digit_cnt;
-        let mut result = Self::separate_integer(magnitude_int_str, inter, sep, int_digit_cnt);
-        if let Some(part) = parts.next() {
-            result.push_str(&format!(".{part}"))
-        }
-        result
-    }
-
-    fn separate_integer(
-        magnitude_str: String,
-        inter: i32,
-        sep: char,
-        disp_digit_cnt: i32,
-    ) -> String {
-        let magnitude_len = magnitude_str.len() as i32;
-        let offset = (disp_digit_cnt % (inter + 1) == 0) as i32;
-        let disp_digit_cnt = disp_digit_cnt + offset;
-        let pad_cnt = disp_digit_cnt - magnitude_len;
-        let sep_cnt = disp_digit_cnt / (inter + 1);
-        let diff = pad_cnt - sep_cnt;
-        if pad_cnt > 0 && diff > 0 {
-            // separate with 0 padding
-            let padding = "0".repeat(diff as usize);
-            let padded_num = format!("{padding}{magnitude_str}");
-            Self::insert_separator(padded_num, inter, sep, sep_cnt)
-        } else {
-            // separate without padding
-            let sep_cnt = (magnitude_len - 1) / inter;
-            Self::insert_separator(magnitude_str, inter, sep, sep_cnt)
-        }
-    }
-
-    fn insert_separator(mut magnitude_str: String, inter: i32, sep: char, sep_cnt: i32) -> String {
-        let magnitude_len = magnitude_str.len() as i32;
-        for i in 1..sep_cnt + 1 {
-            magnitude_str.insert((magnitude_len - inter * i) as usize, sep);
-        }
-        magnitude_str
-    }
-
-    fn validate_format(&self, default_format_type: FormatType) -> Result<(), FormatSpecError> {
-        let format_type = self.format_type.as_ref().unwrap_or(&default_format_type);
-        match (&self.grouping_option, format_type) {
-            (
-                Some(FormatGrouping::Comma),
-                FormatType::String
-                | FormatType::Character
-                | FormatType::Binary
-                | FormatType::Octal
-                | FormatType::Hex(_)
-                | FormatType::Number(_),
-            ) => {
-                let ch = char::from(format_type);
-                Err(FormatSpecError::UnspecifiedFormat(',', ch))
-            }
-            (
-                Some(FormatGrouping::Underscore),
-                FormatType::String | FormatType::Character | FormatType::Number(_),
-            ) => {
-                let ch = char::from(format_type);
-                Err(FormatSpecError::UnspecifiedFormat('_', ch))
-            }
-            _ => Ok(()),
-        }
-    }
-
-    const fn get_separator_interval(&self) -> usize {
-        match self.format_type {
-            Some(FormatType::Binary | FormatType::Octal | FormatType::Hex(_)) => 4,
-            Some(FormatType::Decimal | FormatType::Number(_) | FormatType::FixedPoint(_)) => 3,
-            None => 3,
-            _ => panic!("Separators only valid for numbers!"),
-        }
-    }
-
-    fn add_magnitude_separators(&self, magnitude_str: String, prefix: &str) -> String {
-        match &self.grouping_option {
-            Some(fg) => {
-                let sep = char::from(fg);
-                let inter = self.get_separator_interval().try_into().unwrap();
-                let magnitude_len = magnitude_str.len();
-                let width = self.width.unwrap_or(magnitude_len) as i32 - prefix.len() as i32;
-                let disp_digit_cnt = cmp::max(width, magnitude_len as i32);
-                Self::add_magnitude_separators_for_char(magnitude_str, inter, sep, disp_digit_cnt)
-            }
-            None => magnitude_str,
-        }
-    }
-
-    pub fn format_bool(&self, input: bool) -> Result<String, FormatSpecError> {
-        let x = u8::from(input);
-        match &self.format_type {
-            Some(
-                FormatType::Binary
-                | FormatType::Decimal
-                | FormatType::Octal
-                | FormatType::Number(Case::Lower)
-                | FormatType::Hex(_)
-                | FormatType::GeneralFormat(_)
-                | FormatType::Character,
-            ) => self.format_int(&BigInt::from_u8(x).unwrap()),
-            Some(FormatType::Exponent(_) | FormatType::FixedPoint(_) | FormatType::Percentage) => {
-                self.format_float(x as f64)
-            }
-            None => {
-                let first_letter = (input.to_string().as_bytes()[0] as char).to_uppercase();
-                Ok(first_letter.collect::<String>() + &input.to_string()[1..])
-            }
-            _ => Err(FormatSpecError::InvalidFormatSpecifier),
-        }
-    }
-
-    pub fn format_float(&self, num: f64) -> 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: Result<String, FormatSpecError> = match &self.format_type {
-            Some(FormatType::FixedPoint(case)) => Ok(float::format_fixed(
-                precision,
-                magnitude,
-                *case,
-                self.alternate_form,
-            )),
-            Some(FormatType::Decimal)
-            | Some(FormatType::Binary)
-            | Some(FormatType::Octal)
-            | Some(FormatType::Hex(_))
-            | Some(FormatType::String)
-            | Some(FormatType::Character)
-            | Some(FormatType::Number(Case::Upper)) => {
-                let ch = char::from(self.format_type.as_ref().unwrap());
-                Err(FormatSpecError::UnknownFormatCode(ch, "float"))
-            }
-            Some(FormatType::GeneralFormat(case)) | Some(FormatType::Number(case)) => {
-                let precision = if precision == 0 { 1 } else { precision };
-                Ok(float::format_general(
-                    precision,
-                    magnitude,
-                    *case,
-                    self.alternate_form,
-                    false,
-                ))
-            }
-            Some(FormatType::Exponent(case)) => Ok(float::format_exponent(
-                precision,
-                magnitude,
-                *case,
-                self.alternate_form,
-            )),
-            Some(FormatType::Percentage) => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("nan%".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("inf%".to_owned()),
-                _ => {
-                    let result = format!("{:.*}", precision, magnitude * 100.0);
-                    let point = float::decimal_point_or_empty(precision, self.alternate_form);
-                    Ok(format!("{result}{point}%"))
-                }
-            },
-            None => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
-                _ => match self.precision {
-                    Some(precision) => Ok(float::format_general(
-                        precision,
-                        magnitude,
-                        Case::Lower,
-                        self.alternate_form,
-                        true,
-                    )),
-                    None => Ok(float::to_string(magnitude)),
-                },
-            },
-        };
-        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 => " ",
-            }
-        };
-        let magnitude_str = self.add_magnitude_separators(raw_magnitude_str?, sign_str);
-        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
-    }
-
-    #[inline]
-    fn format_int_radix(&self, magnitude: BigInt, radix: u32) -> Result<String, FormatSpecError> {
-        match self.precision {
-            Some(_) => Err(FormatSpecError::PrecisionNotAllowed),
-            None => Ok(magnitude.to_str_radix(radix)),
-        }
-    }
-
-    pub fn format_int(&self, num: &BigInt) -> Result<String, FormatSpecError> {
-        self.validate_format(FormatType::Decimal)?;
-        let magnitude = num.abs();
-        let prefix = if self.alternate_form {
-            match self.format_type {
-                Some(FormatType::Binary) => "0b",
-                Some(FormatType::Octal) => "0o",
-                Some(FormatType::Hex(Case::Lower)) => "0x",
-                Some(FormatType::Hex(Case::Upper)) => "0X",
-                _ => "",
-            }
-        } else {
-            ""
-        };
-        let raw_magnitude_str = match self.format_type {
-            Some(FormatType::Binary) => self.format_int_radix(magnitude, 2),
-            Some(FormatType::Decimal) => self.format_int_radix(magnitude, 10),
-            Some(FormatType::Octal) => self.format_int_radix(magnitude, 8),
-            Some(FormatType::Hex(Case::Lower)) => self.format_int_radix(magnitude, 16),
-            Some(FormatType::Hex(Case::Upper)) => match self.precision {
-                Some(_) => Err(FormatSpecError::PrecisionNotAllowed),
-                None => {
-                    let mut result = magnitude.to_str_radix(16);
-                    result.make_ascii_uppercase();
-                    Ok(result)
-                }
-            },
-            Some(FormatType::Number(Case::Lower)) => self.format_int_radix(magnitude, 10),
-            Some(FormatType::Number(Case::Upper)) => {
-                Err(FormatSpecError::UnknownFormatCode('N', "int"))
-            }
-            Some(FormatType::String) => Err(FormatSpecError::UnknownFormatCode('s', "int")),
-            Some(FormatType::Character) => match (self.sign, self.alternate_form) {
-                (Some(_), _) => Err(FormatSpecError::NotAllowed("Sign")),
-                (_, true) => Err(FormatSpecError::NotAllowed("Alternate form (#)")),
-                (_, _) => match num.to_u32() {
-                    Some(n) if n <= 0x10ffff => Ok(std::char::from_u32(n).unwrap().to_string()),
-                    Some(_) | None => Err(FormatSpecError::CodeNotInRange),
-                },
-            },
-            Some(FormatType::GeneralFormat(_))
-            | Some(FormatType::FixedPoint(_))
-            | Some(FormatType::Exponent(_))
-            | Some(FormatType::Percentage) => match num.to_f64() {
-                Some(float) => return self.format_float(float),
-                _ => Err(FormatSpecError::UnableToConvert),
-            },
-            None => self.format_int_radix(magnitude, 10),
-        }?;
-        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 => " ",
-            },
-        };
-        let sign_prefix = format!("{sign_str}{prefix}");
-        let magnitude_str = self.add_magnitude_separators(raw_magnitude_str, &sign_prefix);
-        self.format_sign_and_align(
-            &AsciiStr::new(&magnitude_str),
-            &sign_prefix,
-            FormatAlign::Right,
-        )
-    }
-
-    pub fn format_string<T>(&self, s: &T) -> Result<String, FormatSpecError>
-    where
-        T: CharLen + Deref<Target = str>,
-    {
-        self.validate_format(FormatType::String)?;
-        match self.format_type {
-            Some(FormatType::String) | None => self
-                .format_sign_and_align(s, "", FormatAlign::Left)
-                .map(|mut value| {
-                    if let Some(precision) = self.precision {
-                        value.truncate(precision);
-                    }
-                    value
-                }),
-            _ => {
-                let ch = char::from(self.format_type.as_ref().unwrap());
-                Err(FormatSpecError::UnknownFormatCode(ch, "str"))
-            }
-        }
-    }
-
-    pub fn format_complex(&self, num: &Complex64) -> Result<String, FormatSpecError> {
-        let (formatted_re, formatted_im) = self.format_complex_re_im(num)?;
-        // Enclose in parentheses if there is no format type and formatted_re is not empty
-        let magnitude_str = if self.format_type.is_none() && !formatted_re.is_empty() {
-            format!("({formatted_re}{formatted_im})")
-        } else {
-            format!("{formatted_re}{formatted_im}")
-        };
-        if let Some(FormatAlign::AfterSign) = &self.align {
-            return Err(FormatSpecError::AlignmentFlag);
-        }
-        match &self.fill.unwrap_or(' '.into()).to_char() {
-            Some('0') => Err(FormatSpecError::ZeroPadding),
-            _ => self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right),
-        }
-    }
-
-    fn format_complex_re_im(&self, num: &Complex64) -> Result<(String, String), FormatSpecError> {
-        // Format real part
-        let mut formatted_re = String::new();
-        if num.re != 0.0 || num.re.is_negative_zero() || self.format_type.is_some() {
-            let sign_re = if num.re.is_sign_negative() && !num.is_nan() {
-                "-"
-            } else {
-                match self.sign.unwrap_or(FormatSign::Minus) {
-                    FormatSign::Plus => "+",
-                    FormatSign::Minus => "",
-                    FormatSign::MinusOrSpace => " ",
-                }
-            };
-            let re = self.format_complex_float(num.re)?;
-            formatted_re = format!("{sign_re}{re}");
-        }
-        // Format imaginary part
-        let sign_im = if num.im.is_sign_negative() && !num.im.is_nan() {
-            "-"
-        } else if formatted_re.is_empty() {
-            ""
-        } else {
-            "+"
-        };
-        let im = self.format_complex_float(num.im)?;
-        Ok((formatted_re, format!("{sign_im}{im}j")))
-    }
-
-    fn format_complex_float(&self, num: f64) -> Result<String, FormatSpecError> {
-        self.validate_format(FormatType::FixedPoint(Case::Lower))?;
-        let precision = self.precision.unwrap_or(6);
-        let magnitude = num.abs();
-        let magnitude_str = match &self.format_type {
-            Some(FormatType::Decimal)
-            | Some(FormatType::Binary)
-            | Some(FormatType::Octal)
-            | Some(FormatType::Hex(_))
-            | Some(FormatType::String)
-            | Some(FormatType::Character)
-            | Some(FormatType::Number(Case::Upper))
-            | Some(FormatType::Percentage) => {
-                let ch = char::from(self.format_type.as_ref().unwrap());
-                Err(FormatSpecError::UnknownFormatCode(ch, "complex"))
-            }
-            Some(FormatType::FixedPoint(case)) => Ok(float::format_fixed(
-                precision,
-                magnitude,
-                *case,
-                self.alternate_form,
-            )),
-            Some(FormatType::GeneralFormat(case)) | Some(FormatType::Number(case)) => {
-                let precision = if precision == 0 { 1 } else { precision };
-                Ok(float::format_general(
-                    precision,
-                    magnitude,
-                    *case,
-                    self.alternate_form,
-                    false,
-                ))
-            }
-            Some(FormatType::Exponent(case)) => Ok(float::format_exponent(
-                precision,
-                magnitude,
-                *case,
-                self.alternate_form,
-            )),
-            None => match magnitude {
-                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
-                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
-                _ => match self.precision {
-                    Some(precision) => Ok(float::format_general(
-                        precision,
-                        magnitude,
-                        Case::Lower,
-                        self.alternate_form,
-                        true,
-                    )),
-                    None => {
-                        if magnitude.fract() == 0.0 {
-                            Ok(magnitude.trunc().to_string())
-                        } else {
-                            Ok(magnitude.to_string())
-                        }
-                    }
-                },
-            },
-        }?;
-        match &self.grouping_option {
-            Some(fg) => {
-                let sep = char::from(fg);
-                let inter = self.get_separator_interval().try_into().unwrap();
-                let len = magnitude_str.len() as i32;
-                let separated_magnitude =
-                    FormatSpec::add_magnitude_separators_for_char(magnitude_str, inter, sep, len);
-                Ok(separated_magnitude)
-            }
-            None => Ok(magnitude_str),
-        }
-    }
-
-    fn format_sign_and_align<T>(
-        &self,
-        magnitude_str: &T,
-        sign_str: &str,
-        default_align: FormatAlign,
-    ) -> Result<String, FormatSpecError>
-    where
-        T: CharLen + Deref<Target = str>,
-    {
-        let align = self.align.unwrap_or(default_align);
-
-        let num_chars = magnitude_str.char_len();
-        let fill_char = self.fill.unwrap_or(' '.into());
-        let fill_chars_needed: i32 = self.width.map_or(0, |w| {
-            cmp::max(0, (w as i32) - (num_chars as i32) - (sign_str.len() as i32))
-        });
-
-        let magnitude_str = magnitude_str.deref();
-        Ok(match align {
-            FormatAlign::Left => format!(
-                "{}{}{}",
-                sign_str,
-                magnitude_str,
-                Self::compute_fill_string(fill_char, fill_chars_needed)
-            ),
-            FormatAlign::Right => format!(
-                "{}{}{}",
-                Self::compute_fill_string(fill_char, fill_chars_needed),
-                sign_str,
-                magnitude_str
-            ),
-            FormatAlign::AfterSign => format!(
-                "{}{}{}",
-                sign_str,
-                Self::compute_fill_string(fill_char, fill_chars_needed),
-                magnitude_str
-            ),
-            FormatAlign::Center => {
-                let left_fill_chars_needed = fill_chars_needed / 2;
-                let right_fill_chars_needed = fill_chars_needed - left_fill_chars_needed;
-                let left_fill_string = Self::compute_fill_string(fill_char, left_fill_chars_needed);
-                let right_fill_string =
-                    Self::compute_fill_string(fill_char, right_fill_chars_needed);
-                format!("{left_fill_string}{sign_str}{magnitude_str}{right_fill_string}")
-            }
-        })
-    }
-}
-
-pub trait CharLen {
-    /// Returns the number of characters in the text
-    fn char_len(&self) -> usize;
-}
-
-struct AsciiStr<'a> {
-    inner: &'a str,
-}
-
-impl<'a> AsciiStr<'a> {
-    const fn new(inner: &'a str) -> Self {
-        Self { inner }
-    }
-}
-
-impl CharLen for AsciiStr<'_> {
-    fn char_len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-impl Deref for AsciiStr<'_> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        self.inner
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FormatSpecError {
-    DecimalDigitsTooMany,
-    PrecisionTooBig,
-    InvalidFormatSpecifier,
-    UnspecifiedFormat(char, char),
-    ExclusiveFormat(char, char),
-    UnknownFormatCode(char, &'static str),
-    PrecisionNotAllowed,
-    NotAllowed(&'static str),
-    UnableToConvert,
-    CodeNotInRange,
-    ZeroPadding,
-    AlignmentFlag,
-    NotImplemented(char, &'static str),
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FormatParseError {
-    UnmatchedBracket,
-    MissingStartBracket,
-    UnescapedStartBracketInLiteral,
-    InvalidFormatSpecifier,
-    UnknownConversion,
-    EmptyAttribute,
-    MissingRightBracket,
-    InvalidCharacterAfterRightBracket,
-}
-
-impl FromStr for FormatSpec {
-    type Err = FormatSpecError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::parse(s)
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FieldNamePart {
-    Attribute(Wtf8Buf),
-    Index(usize),
-    StringIndex(Wtf8Buf),
-}
-
-impl FieldNamePart {
-    fn parse_part(
-        chars: &mut impl PeekingNext<Item = CodePoint>,
-    ) -> Result<Option<Self>, FormatParseError> {
-        chars
-            .next()
-            .map(|ch| match ch.to_char_lossy() {
-                '.' => {
-                    let mut attribute = Wtf8Buf::new();
-                    for ch in chars.peeking_take_while(|ch| *ch != '.' && *ch != '[') {
-                        attribute.push(ch);
-                    }
-                    if attribute.is_empty() {
-                        Err(FormatParseError::EmptyAttribute)
-                    } else {
-                        Ok(Self::Attribute(attribute))
-                    }
-                }
-                '[' => {
-                    let mut index = Wtf8Buf::new();
-                    for ch in chars {
-                        if ch == ']' {
-                            return if index.is_empty() {
-                                Err(FormatParseError::EmptyAttribute)
-                            } else if let Some(index) = parse_usize(&index) {
-                                Ok(Self::Index(index))
-                            } else {
-                                Ok(Self::StringIndex(index))
-                            };
-                        }
-                        index.push(ch);
-                    }
-                    Err(FormatParseError::MissingRightBracket)
-                }
-                _ => Err(FormatParseError::InvalidCharacterAfterRightBracket),
-            })
-            .transpose()
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FieldType {
-    Auto,
-    Index(usize),
-    Keyword(Wtf8Buf),
-}
-
-#[derive(Debug, PartialEq)]
-pub struct FieldName {
-    pub field_type: FieldType,
-    pub parts: Vec<FieldNamePart>,
-}
-
-fn parse_usize(s: &Wtf8) -> Option<usize> {
-    s.as_str().ok().and_then(|s| s.parse().ok())
-}
-
-impl FieldName {
-    pub fn parse(text: &Wtf8) -> Result<Self, FormatParseError> {
-        let mut chars = text.code_points().peekable();
-        let first: Wtf8Buf = chars
-            .peeking_take_while(|ch| *ch != '.' && *ch != '[')
-            .collect();
-
-        let field_type = if first.is_empty() {
-            FieldType::Auto
-        } else if let Some(index) = parse_usize(&first) {
-            FieldType::Index(index)
-        } else {
-            FieldType::Keyword(first)
-        };
-
-        let mut parts = Vec::new();
-        while let Some(part) = FieldNamePart::parse_part(&mut chars)? {
-            parts.push(part)
-        }
-
-        Ok(Self { field_type, parts })
-    }
-}
-
-#[derive(Debug, PartialEq)]
-pub enum FormatPart {
-    Field {
-        field_name: Wtf8Buf,
-        conversion_spec: Option<CodePoint>,
-        format_spec: Wtf8Buf,
-    },
-    Literal(Wtf8Buf),
-}
-
-#[derive(Debug, PartialEq)]
-pub struct FormatString {
-    pub format_parts: Vec<FormatPart>,
-}
-
-impl FormatString {
-    fn parse_literal_single(text: &Wtf8) -> Result<(CodePoint, &Wtf8), FormatParseError> {
-        let mut chars = text.code_points();
-        // This should never be called with an empty str
-        let first_char = chars.next().unwrap();
-        // isn't this detectable only with bytes operation?
-        if first_char == '{' || first_char == '}' {
-            let maybe_next_char = chars.next();
-            // if we see a bracket, it has to be escaped by doubling up to be in a literal
-            return if maybe_next_char.is_none() || maybe_next_char.unwrap() != first_char {
-                Err(FormatParseError::UnescapedStartBracketInLiteral)
-            } else {
-                Ok((first_char, chars.as_wtf8()))
-            };
-        }
-        Ok((first_char, chars.as_wtf8()))
-    }
-
-    fn parse_literal(text: &Wtf8) -> Result<(FormatPart, &Wtf8), FormatParseError> {
-        let mut cur_text = text;
-        let mut result_string = Wtf8Buf::new();
-        while !cur_text.is_empty() {
-            match Self::parse_literal_single(cur_text) {
-                Ok((next_char, remaining)) => {
-                    result_string.push(next_char);
-                    cur_text = remaining;
-                }
-                Err(err) => {
-                    return if !result_string.is_empty() {
-                        Ok((FormatPart::Literal(result_string), cur_text))
-                    } else {
-                        Err(err)
-                    };
-                }
-            }
-        }
-        Ok((FormatPart::Literal(result_string), "".as_ref()))
-    }
-
-    fn parse_part_in_brackets(text: &Wtf8) -> Result<FormatPart, FormatParseError> {
-        let mut chars = text.code_points().peekable();
-
-        let mut left = Wtf8Buf::new();
-        let mut right = Wtf8Buf::new();
-
-        let mut split = false;
-        let mut selected = &mut left;
-        let mut inside_brackets = false;
-
-        while let Some(char) = chars.next() {
-            if char == '[' {
-                inside_brackets = true;
-
-                selected.push(char);
-
-                while let Some(next_char) = chars.next() {
-                    selected.push(next_char);
-
-                    if next_char == ']' {
-                        inside_brackets = false;
-                        break;
-                    }
-                    if chars.peek().is_none() {
-                        return Err(FormatParseError::MissingRightBracket);
-                    }
-                }
-            } else if char == ':' && !split && !inside_brackets {
-                split = true;
-                selected = &mut right;
-            } else {
-                selected.push(char);
-            }
-        }
-
-        // before the comma is a keyword or arg index, after the comma is maybe a spec.
-        let arg_part: &Wtf8 = &left;
-
-        let format_spec = if split { right } else { Wtf8Buf::new() };
-
-        // left can still be the conversion (!r, !s, !a)
-        let parts: Vec<&Wtf8> = arg_part.splitn(2, "!".as_ref()).collect();
-        // before the bang is a keyword or arg index, after the comma is maybe a conversion spec.
-        let arg_part = parts[0];
-
-        let conversion_spec = parts
-            .get(1)
-            .map(|conversion| {
-                // conversions are only every one character
-                conversion
-                    .code_points()
-                    .exactly_one()
-                    .map_err(|_| FormatParseError::UnknownConversion)
-            })
-            .transpose()?;
-
-        Ok(FormatPart::Field {
-            field_name: arg_part.to_owned(),
-            conversion_spec,
-            format_spec,
-        })
-    }
-
-    fn parse_spec(text: &Wtf8) -> Result<(FormatPart, &Wtf8), FormatParseError> {
-        let mut nested = false;
-        let mut end_bracket_pos = None;
-        let mut left = Wtf8Buf::new();
-
-        // There may be one layer nesting brackets in spec
-        for (idx, c) in text.code_point_indices() {
-            if idx == 0 {
-                if c != '{' {
-                    return Err(FormatParseError::MissingStartBracket);
-                }
-            } else if c == '{' {
-                if nested {
-                    return Err(FormatParseError::InvalidFormatSpecifier);
-                } else {
-                    nested = true;
-                    left.push(c);
-                    continue;
-                }
-            } else if c == '}' {
-                if nested {
-                    nested = false;
-                    left.push(c);
-                    continue;
-                } else {
-                    end_bracket_pos = Some(idx);
-                    break;
-                }
-            } else {
-                left.push(c);
-            }
-        }
-        if let Some(pos) = end_bracket_pos {
-            let right = &text[pos..];
-            let format_part = Self::parse_part_in_brackets(&left)?;
-            Ok((format_part, &right[1..]))
-        } else {
-            Err(FormatParseError::UnmatchedBracket)
-        }
-    }
-}
-
-pub trait FromTemplate<'a>: Sized {
-    type Err;
-    fn from_str(s: &'a Wtf8) -> Result<Self, Self::Err>;
-}
-
-impl<'a> FromTemplate<'a> for FormatString {
-    type Err = FormatParseError;
-
-    fn from_str(text: &'a Wtf8) -> Result<Self, Self::Err> {
-        let mut cur_text: &Wtf8 = text;
-        let mut parts: Vec<FormatPart> = Vec::new();
-        while !cur_text.is_empty() {
-            // Try to parse both literals and bracketed format parts until we
-            // run out of text
-            cur_text = Self::parse_literal(cur_text)
-                .or_else(|_| Self::parse_spec(cur_text))
-                .map(|(part, new_text)| {
-                    parts.push(part);
-                    new_text
-                })?;
-        }
-        Ok(Self {
-            format_parts: parts,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_fill_and_align() {
-        let parse_fill_and_align = |text| {
-            let (fill, align, rest) = parse_fill_and_align(str::as_ref(text));
-            (
-                fill.and_then(CodePoint::to_char),
-                align,
-                rest.as_str().unwrap(),
-            )
-        };
-        assert_eq!(
-            parse_fill_and_align(" <"),
-            (Some(' '), Some(FormatAlign::Left), "")
-        );
-        assert_eq!(
-            parse_fill_and_align(" <22"),
-            (Some(' '), Some(FormatAlign::Left), "22")
-        );
-        assert_eq!(
-            parse_fill_and_align("<22"),
-            (None, Some(FormatAlign::Left), "22")
-        );
-        assert_eq!(
-            parse_fill_and_align(" ^^"),
-            (Some(' '), Some(FormatAlign::Center), "^")
-        );
-        assert_eq!(
-            parse_fill_and_align("==="),
-            (Some('='), Some(FormatAlign::AfterSign), "=")
-        );
-    }
-
-    #[test]
-    fn test_width_only() {
-        let expected = Ok(FormatSpec {
-            conversion: None,
-            fill: None,
-            align: None,
-            sign: None,
-            alternate_form: false,
-            width: Some(33),
-            grouping_option: None,
-            precision: None,
-            format_type: None,
-        });
-        assert_eq!(FormatSpec::parse("33"), expected);
-    }
-
-    #[test]
-    fn test_fill_and_width() {
-        let expected = Ok(FormatSpec {
-            conversion: None,
-            fill: Some('<'.into()),
-            align: Some(FormatAlign::Right),
-            sign: None,
-            alternate_form: false,
-            width: Some(33),
-            grouping_option: None,
-            precision: None,
-            format_type: None,
-        });
-        assert_eq!(FormatSpec::parse("<>33"), expected);
-    }
-
-    #[test]
-    fn test_all() {
-        let expected = Ok(FormatSpec {
-            conversion: None,
-            fill: Some('<'.into()),
-            align: Some(FormatAlign::Right),
-            sign: Some(FormatSign::Minus),
-            alternate_form: true,
-            width: Some(23),
-            grouping_option: Some(FormatGrouping::Comma),
-            precision: Some(11),
-            format_type: Some(FormatType::Binary),
-        });
-        assert_eq!(FormatSpec::parse("<>-#23,.11b"), expected);
-    }
-
-    fn format_bool(text: &str, value: bool) -> Result<String, FormatSpecError> {
-        FormatSpec::parse(text).and_then(|spec| spec.format_bool(value))
-    }
-
-    #[test]
-    fn test_format_bool() {
-        assert_eq!(format_bool("b", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("b", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("d", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("d", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("o", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("o", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("n", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("n", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("x", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("x", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("X", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("X", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("g", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("g", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("G", true), Ok("1".to_owned()));
-        assert_eq!(format_bool("G", false), Ok("0".to_owned()));
-        assert_eq!(format_bool("c", true), Ok("\x01".to_owned()));
-        assert_eq!(format_bool("c", false), Ok("\x00".to_owned()));
-        assert_eq!(format_bool("e", true), Ok("1.000000e+00".to_owned()));
-        assert_eq!(format_bool("e", false), Ok("0.000000e+00".to_owned()));
-        assert_eq!(format_bool("E", true), Ok("1.000000E+00".to_owned()));
-        assert_eq!(format_bool("E", false), Ok("0.000000E+00".to_owned()));
-        assert_eq!(format_bool("f", true), Ok("1.000000".to_owned()));
-        assert_eq!(format_bool("f", false), Ok("0.000000".to_owned()));
-        assert_eq!(format_bool("F", true), Ok("1.000000".to_owned()));
-        assert_eq!(format_bool("F", false), Ok("0.000000".to_owned()));
-        assert_eq!(format_bool("%", true), Ok("100.000000%".to_owned()));
-        assert_eq!(format_bool("%", false), Ok("0.000000%".to_owned()));
-    }
-
-    #[test]
-    fn test_format_int() {
-        assert_eq!(
-            FormatSpec::parse("d")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("16".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("x")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("10".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("b")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("10000".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("o")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("20".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("+d")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("+16".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("^ 5d")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Minus, b"\x10")),
-            Ok(" -16 ".to_owned())
-        );
-        assert_eq!(
-            FormatSpec::parse("0>+#10x")
-                .unwrap()
-                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
-            Ok("00000+0x10".to_owned())
-        );
-    }
-
-    #[test]
-    fn test_format_int_sep() {
-        let spec = FormatSpec::parse(",").expect("");
-        assert_eq!(spec.grouping_option, Some(FormatGrouping::Comma));
-        assert_eq!(
-            spec.format_int(&BigInt::from_str("1234567890123456789012345678").unwrap()),
-            Ok("1,234,567,890,123,456,789,012,345,678".to_owned())
-        );
-    }
-
-    #[test]
-    fn test_format_parse() {
-        let expected = Ok(FormatString {
-            format_parts: vec![
-                FormatPart::Literal("abcd".into()),
-                FormatPart::Field {
-                    field_name: "1".into(),
-                    conversion_spec: None,
-                    format_spec: "".into(),
-                },
-                FormatPart::Literal(":".into()),
-                FormatPart::Field {
-                    field_name: "key".into(),
-                    conversion_spec: None,
-                    format_spec: "".into(),
-                },
-            ],
-        });
-
-        assert_eq!(FormatString::from_str("abcd{1}:{key}".as_ref()), expected);
-    }
-
-    #[test]
-    fn test_format_parse_multi_byte_char() {
-        assert!(FormatString::from_str("{a:%ЫйЯЧ}".as_ref()).is_ok());
-    }
-
-    #[test]
-    fn test_format_parse_fail() {
-        assert_eq!(
-            FormatString::from_str("{s".as_ref()),
-            Err(FormatParseError::UnmatchedBracket)
-        );
-    }
-
-    #[test]
-    fn test_square_brackets_inside_format() {
-        assert_eq!(
-            FormatString::from_str("{[:123]}".as_ref()),
-            Ok(FormatString {
-                format_parts: vec![FormatPart::Field {
-                    field_name: "[:123]".into(),
-                    conversion_spec: None,
-                    format_spec: "".into(),
-                }],
-            }),
-        );
-
-        assert_eq!(FormatString::from_str("{asdf[:123]asdf}".as_ref()), {
-            Ok(FormatString {
-                format_parts: vec![FormatPart::Field {
-                    field_name: "asdf[:123]asdf".into(),
-                    conversion_spec: None,
-                    format_spec: "".into(),
-                }],
-            })
-        });
-
-        assert_eq!(FormatString::from_str("{[1234}".as_ref()), {
-            Err(FormatParseError::MissingRightBracket)
-        });
-    }
-
-    #[test]
-    fn test_format_parse_escape() {
-        let expected = Ok(FormatString {
-            format_parts: vec![
-                FormatPart::Literal("{".into()),
-                FormatPart::Field {
-                    field_name: "key".into(),
-                    conversion_spec: None,
-                    format_spec: "".into(),
-                },
-                FormatPart::Literal("}ddfe".into()),
-            ],
-        });
-
-        assert_eq!(FormatString::from_str("{{{key}}}ddfe".as_ref()), expected);
-    }
-
-    #[test]
-    fn test_format_invalid_specification() {
-        assert_eq!(
-            FormatSpec::parse("%3"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse(".2fa"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse("ds"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse("x+"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse("b4"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse("o!"),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-        assert_eq!(
-            FormatSpec::parse("d "),
-            Err(FormatSpecError::InvalidFormatSpecifier)
-        );
-    }
-
-    #[test]
-    fn test_parse_field_name() {
-        let parse = |s: &str| FieldName::parse(s.as_ref());
-        assert_eq!(
-            parse(""),
-            Ok(FieldName {
-                field_type: FieldType::Auto,
-                parts: Vec::new(),
-            })
-        );
-        assert_eq!(
-            parse("0"),
-            Ok(FieldName {
-                field_type: FieldType::Index(0),
-                parts: Vec::new(),
-            })
-        );
-        assert_eq!(
-            parse("key"),
-            Ok(FieldName {
-                field_type: FieldType::Keyword("key".into()),
-                parts: Vec::new(),
-            })
-        );
-        assert_eq!(
-            parse("key.attr[0][string]"),
-            Ok(FieldName {
-                field_type: FieldType::Keyword("key".into()),
-                parts: vec![
-                    FieldNamePart::Attribute("attr".into()),
-                    FieldNamePart::Index(0),
-                    FieldNamePart::StringIndex("string".into())
-                ],
-            })
-        );
-        assert_eq!(parse("key.."), Err(FormatParseError::EmptyAttribute));
-        assert_eq!(parse("key[]"), Err(FormatParseError::EmptyAttribute));
-        assert_eq!(parse("key["), Err(FormatParseError::MissingRightBracket));
-        assert_eq!(
-            parse("key[0]after"),
-            Err(FormatParseError::InvalidCharacterAfterRightBracket)
-        );
-    }
-}
diff --git a/common/src/int.rs b/common/src/int.rs
deleted file mode 100644
index 9ec9e01498..0000000000
--- a/common/src/int.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use malachite_base::{num::conversion::traits::RoundingInto, rounding_modes::RoundingMode};
-use malachite_bigint::{BigInt, BigUint, Sign};
-use malachite_q::Rational;
-use num_traits::{One, ToPrimitive, Zero};
-
-pub fn true_div(numerator: &BigInt, denominator: &BigInt) -> f64 {
-    let rational = Rational::from_integers_ref(numerator.into(), denominator.into());
-    match rational.rounding_into(RoundingMode::Nearest) {
-        // returned value is $t::MAX but still less than the original
-        (val, std::cmp::Ordering::Less) if val == f64::MAX => f64::INFINITY,
-        // returned value is $t::MIN but still greater than the original
-        (val, std::cmp::Ordering::Greater) if val == f64::MIN => f64::NEG_INFINITY,
-        (val, _) => val,
-    }
-}
-
-pub fn float_to_ratio(value: f64) -> Option<(BigInt, BigInt)> {
-    let sign = match std::cmp::PartialOrd::partial_cmp(&value, &0.0)? {
-        std::cmp::Ordering::Less => Sign::Minus,
-        std::cmp::Ordering::Equal => return Some((BigInt::zero(), BigInt::one())),
-        std::cmp::Ordering::Greater => Sign::Plus,
-    };
-    Rational::try_from(value).ok().map(|x| {
-        let (numer, denom) = x.into_numerator_and_denominator();
-        (
-            BigInt::from_biguint(sign, numer.into()),
-            BigUint::from(denom).into(),
-        )
-    })
-}
-
-pub fn bytes_to_int(lit: &[u8], mut base: u32) -> Option<BigInt> {
-    // split sign
-    let mut lit = lit.trim_ascii();
-    let sign = match lit.first()? {
-        b'+' => Some(Sign::Plus),
-        b'-' => Some(Sign::Minus),
-        _ => None,
-    };
-    if sign.is_some() {
-        lit = &lit[1..];
-    }
-
-    // split radix
-    let first = *lit.first()?;
-    let has_radix = if first == b'0' {
-        match base {
-            0 => {
-                if let Some(parsed) = lit.get(1).and_then(detect_base) {
-                    base = parsed;
-                    true
-                } else {
-                    if let [_first, others @ .., last] = lit {
-                        let is_zero =
-                            others.iter().all(|&c| c == b'0' || c == b'_') && *last == b'0';
-                        if !is_zero {
-                            return None;
-                        }
-                    }
-                    return Some(BigInt::zero());
-                }
-            }
-            16 => lit.get(1).is_some_and(|&b| matches!(b, b'x' | b'X')),
-            2 => lit.get(1).is_some_and(|&b| matches!(b, b'b' | b'B')),
-            8 => lit.get(1).is_some_and(|&b| matches!(b, b'o' | b'O')),
-            _ => false,
-        }
-    } else {
-        if base == 0 {
-            base = 10;
-        }
-        false
-    };
-    if has_radix {
-        lit = &lit[2..];
-        if lit.first()? == &b'_' {
-            lit = &lit[1..];
-        }
-    }
-
-    // remove zeroes
-    let mut last = *lit.first()?;
-    if last == b'0' {
-        let mut count = 0;
-        for &cur in &lit[1..] {
-            if cur == b'_' {
-                if last == b'_' {
-                    return None;
-                }
-            } else if cur != b'0' {
-                break;
-            };
-            count += 1;
-            last = cur;
-        }
-        let prefix_last = lit[count];
-        lit = &lit[count + 1..];
-        if lit.is_empty() && prefix_last == b'_' {
-            return None;
-        }
-    }
-
-    // validate
-    for c in lit {
-        let c = *c;
-        if !(c.is_ascii_alphanumeric() || c == b'_') {
-            return None;
-        }
-
-        if c == b'_' && last == b'_' {
-            return None;
-        }
-
-        last = c;
-    }
-    if last == b'_' {
-        return None;
-    }
-
-    // parse
-    let number = if lit.is_empty() {
-        BigInt::zero()
-    } else {
-        let uint = BigUint::parse_bytes(lit, base)?;
-        BigInt::from_biguint(sign.unwrap_or(Sign::Plus), uint)
-    };
-    Some(number)
-}
-
-#[inline]
-pub const fn detect_base(c: &u8) -> Option<u32> {
-    let base = match c {
-        b'x' | b'X' => 16,
-        b'b' | b'B' => 2,
-        b'o' | b'O' => 8,
-        _ => return None,
-    };
-    Some(base)
-}
-
-// num-bigint now returns Some(inf) for to_f64() in some cases, so just keep that the same for now
-#[inline(always)]
-pub fn bigint_to_finite_float(int: &BigInt) -> Option<f64> {
-    int.to_f64().filter(|f| f.is_finite())
-}
-
-#[test]
-fn test_bytes_to_int() {
-    assert_eq!(bytes_to_int(&b"0b101"[..], 2).unwrap(), BigInt::from(5));
-    assert_eq!(bytes_to_int(&b"0x_10"[..], 16).unwrap(), BigInt::from(16));
-    assert_eq!(bytes_to_int(&b"0b"[..], 16).unwrap(), BigInt::from(11));
-    assert_eq!(bytes_to_int(&b"+0b101"[..], 2).unwrap(), BigInt::from(5));
-    assert_eq!(bytes_to_int(&b"0_0_0"[..], 10).unwrap(), BigInt::from(0));
-    assert_eq!(bytes_to_int(&b"09_99"[..], 0), None);
-    assert_eq!(bytes_to_int(&b"000"[..], 0).unwrap(), BigInt::from(0));
-    assert_eq!(bytes_to_int(&b"0_"[..], 0), None);
-    assert_eq!(bytes_to_int(&b"0_100"[..], 10).unwrap(), BigInt::from(100));
-}
diff --git a/common/src/lib.rs b/common/src/lib.rs
deleted file mode 100644
index c99ba0286a..0000000000
--- a/common/src/lib.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! A crate to hold types and functions common to all rustpython components.
-
-#![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
-
-#[macro_use]
-mod macros;
-pub use macros::*;
-
-pub mod atomic;
-pub mod borrow;
-pub mod boxvec;
-pub mod cformat;
-#[cfg(any(unix, windows, target_os = "wasi"))]
-pub mod crt_fd;
-pub mod encodings;
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-pub mod fileutils;
-pub mod float_ops;
-pub mod format;
-pub mod hash;
-pub mod int;
-pub mod linked_list;
-pub mod lock;
-pub mod os;
-pub mod rand;
-pub mod rc;
-pub mod refcount;
-pub mod static_cell;
-pub mod str;
-#[cfg(windows)]
-pub mod windows;
-
-pub use rustpython_wtf8 as wtf8;
-
-pub mod vendored {
-    pub use ascii;
-}
diff --git a/common/src/os.rs b/common/src/os.rs
deleted file mode 100644
index e298db462a..0000000000
--- a/common/src/os.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-// spell-checker:disable
-// TODO: we can move more os-specific bindings/interfaces from stdlib::{os, posix, nt} to here
-
-use std::{io, str::Utf8Error};
-
-pub trait ErrorExt {
-    fn posix_errno(&self) -> i32;
-}
-
-impl ErrorExt for io::Error {
-    #[cfg(not(windows))]
-    fn posix_errno(&self) -> i32 {
-        self.raw_os_error().unwrap_or(0)
-    }
-    #[cfg(windows)]
-    fn posix_errno(&self) -> i32 {
-        let winerror = self.raw_os_error().unwrap_or(0);
-        winerror_to_errno(winerror)
-    }
-}
-
-#[cfg(windows)]
-pub fn last_os_error() -> io::Error {
-    let err = io::Error::last_os_error();
-    // FIXME: probably not ideal, we need a bigger dichotomy between GetLastError and errno
-    if err.raw_os_error() == Some(0) {
-        unsafe extern "C" {
-            fn _get_errno(pValue: *mut i32) -> i32;
-        }
-        let mut errno = 0;
-        unsafe { suppress_iph!(_get_errno(&mut errno)) };
-        let errno = errno_to_winerror(errno);
-        io::Error::from_raw_os_error(errno)
-    } else {
-        err
-    }
-}
-
-#[cfg(not(windows))]
-pub fn last_os_error() -> io::Error {
-    io::Error::last_os_error()
-}
-
-#[cfg(windows)]
-pub fn last_posix_errno() -> i32 {
-    let err = io::Error::last_os_error();
-    if err.raw_os_error() == Some(0) {
-        unsafe extern "C" {
-            fn _get_errno(pValue: *mut i32) -> i32;
-        }
-        let mut errno = 0;
-        unsafe { suppress_iph!(_get_errno(&mut errno)) };
-        errno
-    } else {
-        err.posix_errno()
-    }
-}
-
-#[cfg(not(windows))]
-pub fn last_posix_errno() -> i32 {
-    last_os_error().posix_errno()
-}
-
-#[cfg(unix)]
-pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
-    use std::os::unix::ffi::OsStrExt;
-    Ok(std::ffi::OsStr::from_bytes(b))
-}
-
-#[cfg(not(unix))]
-pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
-    Ok(std::str::from_utf8(b)?.as_ref())
-}
-
-#[cfg(unix)]
-pub use std::os::unix::ffi;
-#[cfg(target_os = "wasi")]
-pub use std::os::wasi::ffi;
-
-#[cfg(windows)]
-pub fn errno_to_winerror(errno: i32) -> i32 {
-    use libc::*;
-    use windows_sys::Win32::Foundation::*;
-    let winerror = match errno {
-        ENOENT => ERROR_FILE_NOT_FOUND,
-        E2BIG => ERROR_BAD_ENVIRONMENT,
-        ENOEXEC => ERROR_BAD_FORMAT,
-        EBADF => ERROR_INVALID_HANDLE,
-        ECHILD => ERROR_WAIT_NO_CHILDREN,
-        EAGAIN => ERROR_NO_PROC_SLOTS,
-        ENOMEM => ERROR_NOT_ENOUGH_MEMORY,
-        EACCES => ERROR_ACCESS_DENIED,
-        EEXIST => ERROR_FILE_EXISTS,
-        EXDEV => ERROR_NOT_SAME_DEVICE,
-        ENOTDIR => ERROR_DIRECTORY,
-        EMFILE => ERROR_TOO_MANY_OPEN_FILES,
-        ENOSPC => ERROR_DISK_FULL,
-        EPIPE => ERROR_BROKEN_PIPE,
-        ENOTEMPTY => ERROR_DIR_NOT_EMPTY,
-        EILSEQ => ERROR_NO_UNICODE_TRANSLATION,
-        EINVAL => ERROR_INVALID_FUNCTION,
-        _ => ERROR_INVALID_FUNCTION,
-    };
-    winerror as _
-}
-
-// winerror: https://learn.microsoft.com/windows/win32/debug/system-error-codes--0-499-
-// errno: https://learn.microsoft.com/cpp/c-runtime-library/errno-constants?view=msvc-170
-#[cfg(windows)]
-pub fn winerror_to_errno(winerror: i32) -> i32 {
-    use libc::*;
-    use windows_sys::Win32::{
-        Foundation::*,
-        Networking::WinSock::{WSAEACCES, WSAEBADF, WSAEFAULT, WSAEINTR, WSAEINVAL, WSAEMFILE},
-    };
-    // Unwrap FACILITY_WIN32 HRESULT errors.
-    // if ((winerror & 0xFFFF0000) == 0x80070000) {
-    //     winerror &= 0x0000FFFF;
-    // }
-
-    // Winsock error codes (10000-11999) are errno values.
-    if (10000..12000).contains(&winerror) {
-        match winerror {
-            WSAEINTR | WSAEBADF | WSAEACCES | WSAEFAULT | WSAEINVAL | WSAEMFILE => {
-                // Winsock definitions of errno values. See WinSock2.h
-                return winerror - 10000;
-            }
-            _ => return winerror as _,
-        }
-    }
-
-    #[allow(non_upper_case_globals)]
-    match winerror as u32 {
-        ERROR_FILE_NOT_FOUND
-        | ERROR_PATH_NOT_FOUND
-        | ERROR_INVALID_DRIVE
-        | ERROR_NO_MORE_FILES
-        | ERROR_BAD_NETPATH
-        | ERROR_BAD_NET_NAME
-        | ERROR_BAD_PATHNAME
-        | ERROR_FILENAME_EXCED_RANGE => ENOENT,
-        ERROR_BAD_ENVIRONMENT => E2BIG,
-        ERROR_BAD_FORMAT
-        | ERROR_INVALID_STARTING_CODESEG
-        | ERROR_INVALID_STACKSEG
-        | ERROR_INVALID_MODULETYPE
-        | ERROR_INVALID_EXE_SIGNATURE
-        | ERROR_EXE_MARKED_INVALID
-        | ERROR_BAD_EXE_FORMAT
-        | ERROR_ITERATED_DATA_EXCEEDS_64k
-        | ERROR_INVALID_MINALLOCSIZE
-        | ERROR_DYNLINK_FROM_INVALID_RING
-        | ERROR_IOPL_NOT_ENABLED
-        | ERROR_INVALID_SEGDPL
-        | ERROR_AUTODATASEG_EXCEEDS_64k
-        | ERROR_RING2SEG_MUST_BE_MOVABLE
-        | ERROR_RELOC_CHAIN_XEEDS_SEGLIM
-        | ERROR_INFLOOP_IN_RELOC_CHAIN => ENOEXEC,
-        ERROR_INVALID_HANDLE | ERROR_INVALID_TARGET_HANDLE | ERROR_DIRECT_ACCESS_HANDLE => EBADF,
-        ERROR_WAIT_NO_CHILDREN | ERROR_CHILD_NOT_COMPLETE => ECHILD,
-        ERROR_NO_PROC_SLOTS | ERROR_MAX_THRDS_REACHED | ERROR_NESTING_NOT_ALLOWED => EAGAIN,
-        ERROR_ARENA_TRASHED
-        | ERROR_NOT_ENOUGH_MEMORY
-        | ERROR_INVALID_BLOCK
-        | ERROR_NOT_ENOUGH_QUOTA => ENOMEM,
-        ERROR_ACCESS_DENIED
-        | ERROR_CURRENT_DIRECTORY
-        | ERROR_WRITE_PROTECT
-        | ERROR_BAD_UNIT
-        | ERROR_NOT_READY
-        | ERROR_BAD_COMMAND
-        | ERROR_CRC
-        | ERROR_BAD_LENGTH
-        | ERROR_SEEK
-        | ERROR_NOT_DOS_DISK
-        | ERROR_SECTOR_NOT_FOUND
-        | ERROR_OUT_OF_PAPER
-        | ERROR_WRITE_FAULT
-        | ERROR_READ_FAULT
-        | ERROR_GEN_FAILURE
-        | ERROR_SHARING_VIOLATION
-        | ERROR_LOCK_VIOLATION
-        | ERROR_WRONG_DISK
-        | ERROR_SHARING_BUFFER_EXCEEDED
-        | ERROR_NETWORK_ACCESS_DENIED
-        | ERROR_CANNOT_MAKE
-        | ERROR_FAIL_I24
-        | ERROR_DRIVE_LOCKED
-        | ERROR_SEEK_ON_DEVICE
-        | ERROR_NOT_LOCKED
-        | ERROR_LOCK_FAILED
-        | 35 => EACCES,
-        ERROR_FILE_EXISTS | ERROR_ALREADY_EXISTS => EEXIST,
-        ERROR_NOT_SAME_DEVICE => EXDEV,
-        ERROR_DIRECTORY => ENOTDIR,
-        ERROR_TOO_MANY_OPEN_FILES => EMFILE,
-        ERROR_DISK_FULL => ENOSPC,
-        ERROR_BROKEN_PIPE | ERROR_NO_DATA => EPIPE,
-        ERROR_DIR_NOT_EMPTY => ENOTEMPTY,
-        ERROR_NO_UNICODE_TRANSLATION => EILSEQ,
-        ERROR_INVALID_FUNCTION
-        | ERROR_INVALID_ACCESS
-        | ERROR_INVALID_DATA
-        | ERROR_INVALID_PARAMETER
-        | ERROR_NEGATIVE_SEEK => EINVAL,
-        _ => EINVAL,
-    }
-}
diff --git a/common/src/str.rs b/common/src/str.rs
deleted file mode 100644
index af30ed6dec..0000000000
--- a/common/src/str.rs
+++ /dev/null
@@ -1,677 +0,0 @@
-// spell-checker:ignore uncomputed
-use crate::atomic::{PyAtomic, Radium};
-use crate::format::CharLen;
-use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-use ascii::{AsciiChar, AsciiStr, AsciiString};
-use core::fmt;
-use core::sync::atomic::Ordering::Relaxed;
-use std::ops::{Bound, RangeBounds};
-
-#[cfg(not(target_arch = "wasm32"))]
-#[allow(non_camel_case_types)]
-pub type wchar_t = libc::wchar_t;
-#[cfg(target_arch = "wasm32")]
-#[allow(non_camel_case_types)]
-pub type wchar_t = u32;
-
-/// Utf8 + state.ascii (+ PyUnicode_Kind in future)
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum StrKind {
-    Ascii,
-    Utf8,
-    Wtf8,
-}
-
-impl std::ops::BitOr for StrKind {
-    type Output = Self;
-
-    fn bitor(self, other: Self) -> Self {
-        use StrKind::*;
-        match (self, other) {
-            (Wtf8, _) | (_, Wtf8) => Wtf8,
-            (Utf8, _) | (_, Utf8) => Utf8,
-            (Ascii, Ascii) => Ascii,
-        }
-    }
-}
-
-impl StrKind {
-    pub const fn is_ascii(&self) -> bool {
-        matches!(self, Self::Ascii)
-    }
-
-    pub const fn is_utf8(&self) -> bool {
-        matches!(self, Self::Ascii | Self::Utf8)
-    }
-
-    #[inline(always)]
-    pub fn can_encode(&self, code: CodePoint) -> bool {
-        match self {
-            Self::Ascii => code.is_ascii(),
-            Self::Utf8 => code.to_char().is_some(),
-            Self::Wtf8 => true,
-        }
-    }
-}
-
-pub trait DeduceStrKind {
-    fn str_kind(&self) -> StrKind;
-}
-
-impl DeduceStrKind for str {
-    fn str_kind(&self) -> StrKind {
-        if self.is_ascii() {
-            StrKind::Ascii
-        } else {
-            StrKind::Utf8
-        }
-    }
-}
-
-impl DeduceStrKind for Wtf8 {
-    fn str_kind(&self) -> StrKind {
-        if self.is_ascii() {
-            StrKind::Ascii
-        } else if self.is_utf8() {
-            StrKind::Utf8
-        } else {
-            StrKind::Wtf8
-        }
-    }
-}
-
-impl DeduceStrKind for String {
-    fn str_kind(&self) -> StrKind {
-        (**self).str_kind()
-    }
-}
-
-impl DeduceStrKind for Wtf8Buf {
-    fn str_kind(&self) -> StrKind {
-        (**self).str_kind()
-    }
-}
-
-impl<T: DeduceStrKind + ?Sized> DeduceStrKind for &T {
-    fn str_kind(&self) -> StrKind {
-        (**self).str_kind()
-    }
-}
-
-impl<T: DeduceStrKind + ?Sized> DeduceStrKind for Box<T> {
-    fn str_kind(&self) -> StrKind {
-        (**self).str_kind()
-    }
-}
-
-#[derive(Debug)]
-pub enum PyKindStr<'a> {
-    Ascii(&'a AsciiStr),
-    Utf8(&'a str),
-    Wtf8(&'a Wtf8),
-}
-
-#[derive(Debug, Clone)]
-pub struct StrData {
-    data: Box<Wtf8>,
-    kind: StrKind,
-    len: StrLen,
-}
-
-struct StrLen(PyAtomic<usize>);
-
-impl From<usize> for StrLen {
-    #[inline(always)]
-    fn from(value: usize) -> Self {
-        Self(Radium::new(value))
-    }
-}
-
-impl fmt::Debug for StrLen {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let len = self.0.load(Relaxed);
-        if len == usize::MAX {
-            f.write_str("<uncomputed>")
-        } else {
-            len.fmt(f)
-        }
-    }
-}
-
-impl StrLen {
-    #[inline(always)]
-    fn zero() -> Self {
-        0usize.into()
-    }
-
-    #[inline(always)]
-    fn uncomputed() -> Self {
-        usize::MAX.into()
-    }
-}
-
-impl Clone for StrLen {
-    fn clone(&self) -> Self {
-        Self(self.0.load(Relaxed).into())
-    }
-}
-
-impl Default for StrData {
-    fn default() -> Self {
-        Self {
-            data: <Box<Wtf8>>::default(),
-            kind: StrKind::Ascii,
-            len: StrLen::zero(),
-        }
-    }
-}
-
-impl From<Box<Wtf8>> for StrData {
-    fn from(value: Box<Wtf8>) -> Self {
-        // doing the check is ~10x faster for ascii, and is actually only 2% slower worst case for
-        // non-ascii; see https://github.com/RustPython/RustPython/pull/2586#issuecomment-844611532
-        let kind = value.str_kind();
-        unsafe { Self::new_str_unchecked(value, kind) }
-    }
-}
-
-impl From<Box<str>> for StrData {
-    #[inline]
-    fn from(value: Box<str>) -> Self {
-        // doing the check is ~10x faster for ascii, and is actually only 2% slower worst case for
-        // non-ascii; see https://github.com/RustPython/RustPython/pull/2586#issuecomment-844611532
-        let kind = value.str_kind();
-        unsafe { Self::new_str_unchecked(value.into(), kind) }
-    }
-}
-
-impl From<Box<AsciiStr>> for StrData {
-    #[inline]
-    fn from(value: Box<AsciiStr>) -> Self {
-        Self {
-            len: value.len().into(),
-            data: value.into(),
-            kind: StrKind::Ascii,
-        }
-    }
-}
-
-impl From<AsciiChar> for StrData {
-    fn from(ch: AsciiChar) -> Self {
-        AsciiString::from(ch).into_boxed_ascii_str().into()
-    }
-}
-
-impl From<char> for StrData {
-    fn from(ch: char) -> Self {
-        if let Ok(ch) = ascii::AsciiChar::from_ascii(ch) {
-            ch.into()
-        } else {
-            Self {
-                data: ch.to_string().into(),
-                kind: StrKind::Utf8,
-                len: 1.into(),
-            }
-        }
-    }
-}
-
-impl From<CodePoint> for StrData {
-    fn from(ch: CodePoint) -> Self {
-        if let Some(ch) = ch.to_char() {
-            ch.into()
-        } else {
-            Self {
-                data: Wtf8Buf::from(ch).into(),
-                kind: StrKind::Wtf8,
-                len: 1.into(),
-            }
-        }
-    }
-}
-
-impl StrData {
-    /// # Safety
-    ///
-    /// Given `bytes` must be valid data for given `kind`
-    pub unsafe fn new_str_unchecked(data: Box<Wtf8>, kind: StrKind) -> Self {
-        let len = match kind {
-            StrKind::Ascii => data.len().into(),
-            _ => StrLen::uncomputed(),
-        };
-        Self { data, kind, len }
-    }
-
-    /// # Safety
-    ///
-    /// `char_len` must be accurate.
-    pub unsafe fn new_with_char_len(data: Box<Wtf8>, kind: StrKind, char_len: usize) -> Self {
-        Self {
-            data,
-            kind,
-            len: char_len.into(),
-        }
-    }
-
-    #[inline]
-    pub const fn as_wtf8(&self) -> &Wtf8 {
-        &self.data
-    }
-
-    #[inline]
-    pub fn as_str(&self) -> Option<&str> {
-        self.kind
-            .is_utf8()
-            .then(|| unsafe { std::str::from_utf8_unchecked(self.data.as_bytes()) })
-    }
-
-    pub fn as_ascii(&self) -> Option<&AsciiStr> {
-        self.kind
-            .is_ascii()
-            .then(|| unsafe { AsciiStr::from_ascii_unchecked(self.data.as_bytes()) })
-    }
-
-    pub const fn kind(&self) -> StrKind {
-        self.kind
-    }
-
-    #[inline]
-    pub fn as_str_kind(&self) -> PyKindStr<'_> {
-        match self.kind {
-            StrKind::Ascii => {
-                PyKindStr::Ascii(unsafe { AsciiStr::from_ascii_unchecked(self.data.as_bytes()) })
-            }
-            StrKind::Utf8 => {
-                PyKindStr::Utf8(unsafe { std::str::from_utf8_unchecked(self.data.as_bytes()) })
-            }
-            StrKind::Wtf8 => PyKindStr::Wtf8(&self.data),
-        }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    #[inline]
-    pub fn char_len(&self) -> usize {
-        match self.len.0.load(Relaxed) {
-            usize::MAX => self._compute_char_len(),
-            len => len,
-        }
-    }
-
-    #[cold]
-    fn _compute_char_len(&self) -> usize {
-        let len = if let Some(s) = self.as_str() {
-            // utf8 chars().count() is optimized
-            s.chars().count()
-        } else {
-            self.data.code_points().count()
-        };
-        // len cannot be usize::MAX, since vec.capacity() < sys.maxsize
-        self.len.0.store(len, Relaxed);
-        len
-    }
-
-    pub fn nth_char(&self, index: usize) -> CodePoint {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s[index].into(),
-            PyKindStr::Utf8(s) => s.chars().nth(index).unwrap().into(),
-            PyKindStr::Wtf8(w) => w.code_points().nth(index).unwrap(),
-        }
-    }
-}
-
-impl std::fmt::Display for StrData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.data.fmt(f)
-    }
-}
-
-impl CharLen for StrData {
-    fn char_len(&self) -> usize {
-        self.char_len()
-    }
-}
-
-pub fn try_get_chars(s: &str, range: impl RangeBounds<usize>) -> Option<&str> {
-    let mut chars = s.chars();
-    let start = match range.start_bound() {
-        Bound::Included(&i) => i,
-        Bound::Excluded(&i) => i + 1,
-        Bound::Unbounded => 0,
-    };
-    for _ in 0..start {
-        chars.next()?;
-    }
-    let s = chars.as_str();
-    let range_len = match range.end_bound() {
-        Bound::Included(&i) => i + 1 - start,
-        Bound::Excluded(&i) => i - start,
-        Bound::Unbounded => return Some(s),
-    };
-    char_range_end(s, range_len).map(|end| &s[..end])
-}
-
-pub fn get_chars(s: &str, range: impl RangeBounds<usize>) -> &str {
-    try_get_chars(s, range).unwrap()
-}
-
-#[inline]
-pub fn char_range_end(s: &str, n_chars: usize) -> Option<usize> {
-    let i = match n_chars.checked_sub(1) {
-        Some(last_char_index) => {
-            let (index, c) = s.char_indices().nth(last_char_index)?;
-            index + c.len_utf8()
-        }
-        None => 0,
-    };
-    Some(i)
-}
-
-pub fn try_get_codepoints(w: &Wtf8, range: impl RangeBounds<usize>) -> Option<&Wtf8> {
-    let mut chars = w.code_points();
-    let start = match range.start_bound() {
-        Bound::Included(&i) => i,
-        Bound::Excluded(&i) => i + 1,
-        Bound::Unbounded => 0,
-    };
-    for _ in 0..start {
-        chars.next()?;
-    }
-    let s = chars.as_wtf8();
-    let range_len = match range.end_bound() {
-        Bound::Included(&i) => i + 1 - start,
-        Bound::Excluded(&i) => i - start,
-        Bound::Unbounded => return Some(s),
-    };
-    codepoint_range_end(s, range_len).map(|end| &s[..end])
-}
-
-pub fn get_codepoints(w: &Wtf8, range: impl RangeBounds<usize>) -> &Wtf8 {
-    try_get_codepoints(w, range).unwrap()
-}
-
-#[inline]
-pub fn codepoint_range_end(s: &Wtf8, n_chars: usize) -> Option<usize> {
-    let i = match n_chars.checked_sub(1) {
-        Some(last_char_index) => {
-            let (index, c) = s.code_point_indices().nth(last_char_index)?;
-            index + c.len_wtf8()
-        }
-        None => 0,
-    };
-    Some(i)
-}
-
-pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
-    if width <= bytes.len() {
-        bytes.to_vec()
-    } else {
-        let (sign, s) = match bytes.first() {
-            Some(_sign @ b'+') | Some(_sign @ b'-') => {
-                (unsafe { bytes.get_unchecked(..1) }, &bytes[1..])
-            }
-            _ => (&b""[..], bytes),
-        };
-        let mut filled = Vec::new();
-        filled.extend_from_slice(sign);
-        filled.extend(std::iter::repeat_n(b'0', width - bytes.len()));
-        filled.extend_from_slice(s);
-        filled
-    }
-}
-
-/// Convert a string to ascii compatible, escaping unicode-s into escape
-/// sequences.
-pub fn to_ascii(value: &str) -> AsciiString {
-    let mut ascii = Vec::new();
-    for c in value.chars() {
-        if c.is_ascii() {
-            ascii.push(c as u8);
-        } else {
-            let c = c as i64;
-            let hex = if c < 0x100 {
-                format!("\\x{c:02x}")
-            } else if c < 0x10000 {
-                format!("\\u{c:04x}")
-            } else {
-                format!("\\U{c:08x}")
-            };
-            ascii.append(&mut hex.into_bytes());
-        }
-    }
-    unsafe { AsciiString::from_ascii_unchecked(ascii) }
-}
-
-pub struct UnicodeEscapeCodepoint(pub CodePoint);
-
-impl fmt::Display for UnicodeEscapeCodepoint {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let c = self.0.to_u32();
-        if c >= 0x10000 {
-            write!(f, "\\U{c:08x}")
-        } else if c >= 0x100 {
-            write!(f, "\\u{c:04x}")
-        } else {
-            write!(f, "\\x{c:02x}")
-        }
-    }
-}
-
-pub mod levenshtein {
-    use std::{cell::RefCell, thread_local};
-
-    pub const MOVE_COST: usize = 2;
-    const CASE_COST: usize = 1;
-    const MAX_STRING_SIZE: usize = 40;
-
-    const fn substitution_cost(mut a: u8, mut b: u8) -> usize {
-        if (a & 31) != (b & 31) {
-            return MOVE_COST;
-        }
-        if a == b {
-            return 0;
-        }
-        if a.is_ascii_uppercase() {
-            a += b'a' - b'A';
-        }
-        if b.is_ascii_uppercase() {
-            b += b'a' - b'A';
-        }
-        if a == b { CASE_COST } else { MOVE_COST }
-    }
-
-    pub fn levenshtein_distance(a: &str, b: &str, 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;
-        }
-
-        let (mut a_bytes, mut b_bytes) = (a.as_bytes(), b.as_bytes());
-        let (mut a_begin, mut a_end) = (0usize, a.len());
-        let (mut b_begin, mut b_end) = (0usize, b.len());
-
-        while a_end > 0 && b_end > 0 && (a_bytes[a_begin] == b_bytes[b_begin]) {
-            a_begin += 1;
-            b_begin += 1;
-            a_end -= 1;
-            b_end -= 1;
-        }
-        while a_end > 0
-            && b_end > 0
-            && (a_bytes[a_begin + a_end - 1] == b_bytes[b_begin + b_end - 1])
-        {
-            a_end -= 1;
-            b_end -= 1;
-        }
-        if a_end == 0 || b_end == 0 {
-            return (a_end + b_end) * MOVE_COST;
-        }
-        if a_end > MAX_STRING_SIZE || b_end > MAX_STRING_SIZE {
-            return max_cost + 1;
-        }
-
-        if b_end < a_end {
-            std::mem::swap(&mut a_bytes, &mut b_bytes);
-            std::mem::swap(&mut a_begin, &mut b_begin);
-            std::mem::swap(&mut a_end, &mut b_end);
-        }
-
-        if (b_end - a_end) * MOVE_COST > max_cost {
-            return max_cost + 1;
-        }
-
-        BUFFER.with(|buffer| {
-            let mut buffer = buffer.borrow_mut();
-            for i in 0..a_end {
-                buffer[i] = (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;
-                    }
-                }
-                if minimum > max_cost {
-                    return max_cost + 1;
-                }
-            }
-            result
-        })
-    }
-}
-
-/// Replace all tabs in a string with spaces, using the given tab size.
-pub fn expandtabs(input: &str, tab_size: usize) -> String {
-    let tab_stop = tab_size;
-    let mut expanded_str = String::with_capacity(input.len());
-    let mut tab_size = tab_stop;
-    let mut col_count = 0usize;
-    for ch in input.chars() {
-        match ch {
-            '\t' => {
-                let num_spaces = tab_size - col_count;
-                col_count += num_spaces;
-                let expand = " ".repeat(num_spaces);
-                expanded_str.push_str(&expand);
-            }
-            '\r' | '\n' => {
-                expanded_str.push(ch);
-                col_count = 0;
-                tab_size = 0;
-            }
-            _ => {
-                expanded_str.push(ch);
-                col_count += 1;
-            }
-        }
-        if col_count >= tab_size {
-            tab_size += tab_stop;
-        }
-    }
-    expanded_str
-}
-
-/// Creates an [`AsciiStr`][ascii::AsciiStr] from a string literal, throwing a compile error if the
-/// literal isn't actually ascii.
-///
-/// ```compile_fail
-/// # use rustpython_common::str::ascii;
-/// ascii!("I ❤️ Rust & Python");
-/// ```
-#[macro_export]
-macro_rules! ascii {
-    ($x:expr $(,)?) => {{
-        let s = const {
-            let s: &str = $x;
-            assert!(s.is_ascii(), "ascii!() argument is not an ascii string");
-            s
-        };
-        unsafe { $crate::vendored::ascii::AsciiStr::from_ascii_unchecked(s.as_bytes()) }
-    }};
-}
-pub use ascii;
-
-// TODO: this should probably live in a crate like unic or unicode-properties
-const UNICODE_DECIMAL_VALUES: &[char] = &[
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨',
-    '٩', '۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹', '߀', '߁', '߂', '߃', '߄', '߅', '߆', '߇',
-    '߈', '߉', '०', '१', '२', '३', '४', '५', '६', '७', '८', '९', '০', '১', '২', '৩', '৪', '৫', '৬',
-    '৭', '৮', '৯', '੦', '੧', '੨', '੩', '੪', '੫', '੬', '੭', '੮', '੯', '૦', '૧', '૨', '૩', '૪', '૫',
-    '૬', '૭', '૮', '૯', '୦', '୧', '୨', '୩', '୪', '୫', '୬', '୭', '୮', '୯', '௦', '௧', '௨', '௩', '௪',
-    '௫', '௬', '௭', '௮', '௯', '౦', '౧', '౨', '౩', '౪', '౫', '౬', '౭', '౮', '౯', '೦', '೧', '೨', '೩',
-    '೪', '೫', '೬', '೭', '೮', '೯', '൦', '൧', '൨', '൩', '൪', '൫', '൬', '൭', '൮', '൯', '෦', '෧', '෨',
-    '෩', '෪', '෫', '෬', '෭', '෮', '෯', '๐', '๑', '๒', '๓', '๔', '๕', '๖', '๗', '๘', '๙', '໐', '໑',
-    '໒', '໓', '໔', '໕', '໖', '໗', '໘', '໙', '༠', '༡', '༢', '༣', '༤', '༥', '༦', '༧', '༨', '༩', '၀',
-    '၁', '၂', '၃', '၄', '၅', '၆', '၇', '၈', '၉', '႐', '႑', '႒', '႓', '႔', '႕', '႖', '႗', '႘', '႙',
-    '០', '១', '២', '៣', '៤', '៥', '៦', '៧', '៨', '៩', '᠐', '᠑', '᠒', '᠓', '᠔', '᠕', '᠖', '᠗', '᠘',
-    '᠙', '᥆', '᥇', '᥈', '᥉', '᥊', '᥋', '᥌', '᥍', '᥎', '᥏', '᧐', '᧑', '᧒', '᧓', '᧔', '᧕', '᧖', '᧗',
-    '᧘', '᧙', '᪀', '᪁', '᪂', '᪃', '᪄', '᪅', '᪆', '᪇', '᪈', '᪉', '᪐', '᪑', '᪒', '᪓', '᪔', '᪕', '᪖',
-    '᪗', '᪘', '᪙', '᭐', '᭑', '᭒', '᭓', '᭔', '᭕', '᭖', '᭗', '᭘', '᭙', '᮰', '᮱', '᮲', '᮳', '᮴', '᮵',
-    '᮶', '᮷', '᮸', '᮹', '᱀', '᱁', '᱂', '᱃', '᱄', '᱅', '᱆', '᱇', '᱈', '᱉', '᱐', '᱑', '᱒', '᱓', '᱔',
-    '᱕', '᱖', '᱗', '᱘', '᱙', '꘠', '꘡', '꘢', '꘣', '꘤', '꘥', '꘦', '꘧', '꘨', '꘩', '꣐', '꣑', '꣒', '꣓',
-    '꣔', '꣕', '꣖', '꣗', '꣘', '꣙', '꤀', '꤁', '꤂', '꤃', '꤄', '꤅', '꤆', '꤇', '꤈', '꤉', '꧐', '꧑', '꧒',
-    '꧓', '꧔', '꧕', '꧖', '꧗', '꧘', '꧙', '꧰', '꧱', '꧲', '꧳', '꧴', '꧵', '꧶', '꧷', '꧸', '꧹', '꩐', '꩑',
-    '꩒', '꩓', '꩔', '꩕', '꩖', '꩗', '꩘', '꩙', '꯰', '꯱', '꯲', '꯳', '꯴', '꯵', '꯶', '꯷', '꯸', '꯹', '０',
-    '１', '２', '３', '４', '５', '６', '７', '８', '９', '𐒠', '𐒡', '𐒢', '𐒣', '𐒤', '𐒥', '𐒦', '𐒧',
-    '𐒨', '𐒩', '𑁦', '𑁧', '𑁨', '𑁩', '𑁪', '𑁫', '𑁬', '𑁭', '𑁮', '𑁯', '𑃰', '𑃱', '𑃲', '𑃳', '𑃴', '𑃵', '𑃶',
-    '𑃷', '𑃸', '𑃹', '𑄶', '𑄷', '𑄸', '𑄹', '𑄺', '𑄻', '𑄼', '𑄽', '𑄾', '𑄿', '𑇐', '𑇑', '𑇒', '𑇓', '𑇔', '𑇕',
-    '𑇖', '𑇗', '𑇘', '𑇙', '𑋰', '𑋱', '𑋲', '𑋳', '𑋴', '𑋵', '𑋶', '𑋷', '𑋸', '𑋹', '𑑐', '𑑑', '𑑒', '𑑓', '𑑔',
-    '𑑕', '𑑖', '𑑗', '𑑘', '𑑙', '𑓐', '𑓑', '𑓒', '𑓓', '𑓔', '𑓕', '𑓖', '𑓗', '𑓘', '𑓙', '𑙐', '𑙑', '𑙒', '𑙓',
-    '𑙔', '𑙕', '𑙖', '𑙗', '𑙘', '𑙙', '𑛀', '𑛁', '𑛂', '𑛃', '𑛄', '𑛅', '𑛆', '𑛇', '𑛈', '𑛉', '𑜰', '𑜱', '𑜲',
-    '𑜳', '𑜴', '𑜵', '𑜶', '𑜷', '𑜸', '𑜹', '𑣠', '𑣡', '𑣢', '𑣣', '𑣤', '𑣥', '𑣦', '𑣧', '𑣨', '𑣩', '𑱐', '𑱑',
-    '𑱒', '𑱓', '𑱔', '𑱕', '𑱖', '𑱗', '𑱘', '𑱙', '𑵐', '𑵑', '𑵒', '𑵓', '𑵔', '𑵕', '𑵖', '𑵗', '𑵘', '𑵙', '𖩠',
-    '𖩡', '𖩢', '𖩣', '𖩤', '𖩥', '𖩦', '𖩧', '𖩨', '𖩩', '𖭐', '𖭑', '𖭒', '𖭓', '𖭔', '𖭕', '𖭖', '𖭗', '𖭘', '𖭙',
-    '𝟎', '𝟏', '𝟐', '𝟑', '𝟒', '𝟓', '𝟔', '𝟕', '𝟖', '𝟗', '𝟘', '𝟙', '𝟚', '𝟛', '𝟜', '𝟝', '𝟞', '𝟟', '𝟠',
-    '𝟡', '𝟢', '𝟣', '𝟤', '𝟥', '𝟦', '𝟧', '𝟨', '𝟩', '𝟪', '𝟫', '𝟬', '𝟭', '𝟮', '𝟯', '𝟰', '𝟱', '𝟲', '𝟳',
-    '𝟴', '𝟵', '𝟶', '𝟷', '𝟸', '𝟹', '𝟺', '𝟻', '𝟼', '𝟽', '𝟾', '𝟿', '𞥐', '𞥑', '𞥒', '𞥓', '𞥔', '𞥕', '𞥖',
-    '𞥗', '𞥘', '𞥙',
-];
-
-pub fn char_to_decimal(ch: char) -> Option<u8> {
-    UNICODE_DECIMAL_VALUES
-        .binary_search(&ch)
-        .ok()
-        .map(|i| (i % 10) as u8)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_chars() {
-        let s = "0123456789";
-        assert_eq!(get_chars(s, 3..7), "3456");
-        assert_eq!(get_chars(s, 3..7), &s[3..7]);
-
-        let s = "0유니코드 문자열9";
-        assert_eq!(get_chars(s, 3..7), "코드 문");
-
-        let s = "0😀😃😄😁😆😅😂🤣9";
-        assert_eq!(get_chars(s, 3..7), "😄😁😆😅");
-    }
-}
diff --git a/common/src/windows.rs b/common/src/windows.rs
deleted file mode 100644
index 4a922ce435..0000000000
--- a/common/src/windows.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use std::{
-    ffi::{OsStr, OsString},
-    os::windows::ffi::{OsStrExt, OsStringExt},
-};
-
-pub trait ToWideString {
-    fn to_wide(&self) -> Vec<u16>;
-    fn to_wide_with_nul(&self) -> Vec<u16>;
-}
-impl<T> ToWideString for T
-where
-    T: AsRef<OsStr>,
-{
-    fn to_wide(&self) -> Vec<u16> {
-        self.as_ref().encode_wide().collect()
-    }
-    fn to_wide_with_nul(&self) -> Vec<u16> {
-        self.as_ref().encode_wide().chain(Some(0)).collect()
-    }
-}
-
-pub trait FromWideString
-where
-    Self: Sized,
-{
-    fn from_wides_until_nul(wide: &[u16]) -> Self;
-}
-impl FromWideString for OsString {
-    fn from_wides_until_nul(wide: &[u16]) -> OsString {
-        let len = wide.iter().take_while(|&&c| c != 0).count();
-        OsString::from_wide(&wide[..len])
-    }
-}
diff --git a/compiler/Cargo.toml b/compiler/Cargo.toml
deleted file mode 100644
index 39b7c54beb..0000000000
--- a/compiler/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "rustpython-compiler"
-description = "A usability wrapper around rustpython-parser and rustpython-compiler-core"
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-rustpython-codegen = { workspace = true }
-rustpython-compiler-core = { workspace = true }
-rustpython-compiler-source = { workspace = true }
-# rustpython-parser = { workspace = true }
-ruff_python_parser = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_source_file = { workspace = true }
-ruff_text_size = { workspace = true }
-thiserror = { workspace = true }
-
-[dev-dependencies]
-rand = { workspace = true }
-
-[lints]
-workspace = true
\ No newline at end of file
diff --git a/compiler/codegen/Cargo.toml b/compiler/codegen/Cargo.toml
deleted file mode 100644
index 479b0b29f6..0000000000
--- a/compiler/codegen/Cargo.toml
+++ /dev/null
@@ -1,40 +0,0 @@
-[package]
-name = "rustpython-codegen"
-description = "Compiler for python code into bytecode for the rustpython VM."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-
-[dependencies]
-# rustpython-ast = { workspace = true, features=["unparse", "constant-optimization"] }
-# rustpython-parser-core = { workspace = true }
-rustpython-compiler-core = { workspace = true }
-rustpython-compiler-source = {workspace = true }
-rustpython-literal = {workspace = true }
-rustpython-wtf8 = { workspace = true }
-ruff_python_ast = { workspace = true }
-ruff_text_size = { workspace = true }
-ruff_source_file = { workspace = true }
-
-ahash = { workspace = true }
-bitflags = { workspace = true }
-indexmap = { workspace = true }
-itertools = { workspace = true }
-log = { workspace = true }
-num-complex = { workspace = true }
-num-traits = { workspace = true }
-thiserror = { workspace = true }
-malachite-bigint = { workspace = true }
-memchr = { workspace = true }
-unicode_names2 = { workspace = true }
-
-[dev-dependencies]
-ruff_python_parser = { workspace = true }
-insta = { workspace = true }
-
-[lints]
-workspace = true
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
deleted file mode 100644
index 4180b79712..0000000000
--- a/compiler/codegen/src/compile.rs
+++ /dev/null
@@ -1,4804 +0,0 @@
-//!
-//! Take an AST and transform it into bytecode
-//!
-//! Inspirational code:
-//!   <https://github.com/python/cpython/blob/main/Python/compile.c>
-//!   <https://github.com/micropython/micropython/blob/master/py/compile.c>
-
-#![deny(clippy::cast_possible_truncation)]
-
-use crate::{
-    IndexSet, ToPythonName,
-    error::{CodegenError, CodegenErrorType, PatternUnreachableReason},
-    ir::{self, BlockIdx},
-    symboltable::{self, SymbolFlags, SymbolScope, SymbolTable},
-    unparse::unparse_expr,
-};
-use itertools::Itertools;
-use malachite_bigint::BigInt;
-use num_complex::Complex;
-use num_traits::{Num, ToPrimitive};
-use ruff_python_ast::{
-    Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem,
-    ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprFString,
-    ExprList, ExprName, ExprStarred, ExprSubscript, ExprTuple, ExprUnaryOp, FString,
-    FStringElement, FStringElements, FStringFlags, FStringPart, Identifier, Int, Keyword,
-    MatchCase, ModExpression, ModModule, Operator, Parameters, Pattern, PatternMatchAs,
-    PatternMatchClass, PatternMatchOr, PatternMatchSequence, PatternMatchSingleton,
-    PatternMatchStar, PatternMatchValue, Singleton, Stmt, StmtExpr, TypeParam, TypeParamParamSpec,
-    TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
-};
-use ruff_source_file::OneIndexed;
-use ruff_text_size::{Ranged, TextRange};
-use rustpython_wtf8::Wtf8Buf;
-// use rustpython_ast::located::{self as located_ast, Located};
-use rustpython_compiler_core::{
-    Mode,
-    bytecode::{
-        self, Arg as OpArgMarker, BinaryOperator, CodeObject, ComparisonOperator, ConstantData,
-        Instruction, OpArg, OpArgType, UnpackExArgs,
-    },
-};
-use rustpython_compiler_source::SourceCode;
-// use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
-use crate::error::InternalError;
-use std::borrow::Cow;
-
-pub(crate) type InternalResult<T> = Result<T, InternalError>;
-type CompileResult<T> = Result<T, CodegenError>;
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-enum NameUsage {
-    Load,
-    Store,
-    Delete,
-}
-
-enum CallType {
-    Positional { nargs: u32 },
-    Keyword { nargs: u32 },
-    Ex { has_kwargs: bool },
-}
-
-fn is_forbidden_name(name: &str) -> bool {
-    // See https://docs.python.org/3/library/constants.html#built-in-constants
-    const BUILTIN_CONSTANTS: &[&str] = &["__debug__"];
-
-    BUILTIN_CONSTANTS.contains(&name)
-}
-
-/// Main structure holding the state of compilation.
-struct Compiler<'src> {
-    code_stack: Vec<ir::CodeInfo>,
-    symbol_table_stack: Vec<SymbolTable>,
-    source_code: SourceCode<'src>,
-    // current_source_location: SourceLocation,
-    current_source_range: TextRange,
-    qualified_path: Vec<String>,
-    done_with_future_stmts: DoneWithFuture,
-    future_annotations: bool,
-    ctx: CompileContext,
-    class_name: Option<String>,
-    opts: CompileOpts,
-    in_annotation: bool,
-}
-
-enum DoneWithFuture {
-    No,
-    DoneWithDoc,
-    Yes,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct CompileOpts {
-    /// How optimized the bytecode output should be; any optimize > 0 does
-    /// not emit assert statements
-    pub optimize: u8,
-}
-
-#[derive(Debug, Clone, Copy)]
-struct CompileContext {
-    loop_data: Option<(ir::BlockIdx, ir::BlockIdx)>,
-    in_class: bool,
-    func: FunctionContext,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-enum FunctionContext {
-    NoFunction,
-    Function,
-    AsyncFunction,
-}
-
-impl CompileContext {
-    fn in_func(self) -> bool {
-        self.func != FunctionContext::NoFunction
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-enum ComprehensionType {
-    Generator,
-    List,
-    Set,
-    Dict,
-}
-
-/// Compile an Mod produced from ruff parser
-pub fn compile_top(
-    ast: ruff_python_ast::Mod,
-    source_code: SourceCode<'_>,
-    mode: Mode,
-    opts: CompileOpts,
-) -> CompileResult<CodeObject> {
-    match ast {
-        ruff_python_ast::Mod::Module(module) => match mode {
-            Mode::Exec | Mode::Eval => compile_program(&module, source_code, opts),
-            Mode::Single => compile_program_single(&module, source_code, opts),
-            Mode::BlockExpr => compile_block_expression(&module, source_code, opts),
-        },
-        ruff_python_ast::Mod::Expression(expr) => compile_expression(&expr, source_code, opts),
-    }
-}
-
-/// Compile a standard Python program to bytecode
-pub fn compile_program(
-    ast: &ModModule,
-    source_code: SourceCode<'_>,
-    opts: CompileOpts,
-) -> CompileResult<CodeObject> {
-    let symbol_table = SymbolTable::scan_program(ast, source_code.clone())
-        .map_err(|e| e.into_codegen_error(source_code.path.to_owned()))?;
-    let mut compiler = Compiler::new(opts, source_code, "<module>".to_owned());
-    compiler.compile_program(ast, symbol_table)?;
-    let code = compiler.pop_code_object();
-    trace!("Compilation completed: {code:?}");
-    Ok(code)
-}
-
-/// Compile a Python program to bytecode for the context of a REPL
-pub fn compile_program_single(
-    ast: &ModModule,
-    source_code: SourceCode<'_>,
-    opts: CompileOpts,
-) -> CompileResult<CodeObject> {
-    let symbol_table = SymbolTable::scan_program(ast, source_code.clone())
-        .map_err(|e| e.into_codegen_error(source_code.path.to_owned()))?;
-    let mut compiler = Compiler::new(opts, source_code, "<module>".to_owned());
-    compiler.compile_program_single(&ast.body, symbol_table)?;
-    let code = compiler.pop_code_object();
-    trace!("Compilation completed: {code:?}");
-    Ok(code)
-}
-
-pub fn compile_block_expression(
-    ast: &ModModule,
-    source_code: SourceCode<'_>,
-    opts: CompileOpts,
-) -> CompileResult<CodeObject> {
-    let symbol_table = SymbolTable::scan_program(ast, source_code.clone())
-        .map_err(|e| e.into_codegen_error(source_code.path.to_owned()))?;
-    let mut compiler = Compiler::new(opts, source_code, "<module>".to_owned());
-    compiler.compile_block_expr(&ast.body, symbol_table)?;
-    let code = compiler.pop_code_object();
-    trace!("Compilation completed: {code:?}");
-    Ok(code)
-}
-
-pub fn compile_expression(
-    ast: &ModExpression,
-    source_code: SourceCode<'_>,
-    opts: CompileOpts,
-) -> CompileResult<CodeObject> {
-    let symbol_table = SymbolTable::scan_expr(ast, source_code.clone())
-        .map_err(|e| e.into_codegen_error(source_code.path.to_owned()))?;
-    let mut compiler = Compiler::new(opts, source_code, "<module>".to_owned());
-    compiler.compile_eval(ast, symbol_table)?;
-    let code = compiler.pop_code_object();
-    Ok(code)
-}
-
-macro_rules! emit {
-    ($c:expr, Instruction::$op:ident { $arg:ident$(,)? }$(,)?) => {
-        $c.emit_arg($arg, |x| Instruction::$op { $arg: x })
-    };
-    ($c:expr, Instruction::$op:ident { $arg:ident : $arg_val:expr $(,)? }$(,)?) => {
-        $c.emit_arg($arg_val, |x| Instruction::$op { $arg: x })
-    };
-    ($c:expr, Instruction::$op:ident( $arg_val:expr $(,)? )$(,)?) => {
-        $c.emit_arg($arg_val, Instruction::$op)
-    };
-    ($c:expr, Instruction::$op:ident$(,)?) => {
-        $c.emit_no_arg(Instruction::$op)
-    };
-}
-
-fn eprint_location(zelf: &Compiler<'_>) {
-    let start = zelf
-        .source_code
-        .source_location(zelf.current_source_range.start());
-    let end = zelf
-        .source_code
-        .source_location(zelf.current_source_range.end());
-    eprintln!(
-        "LOCATION: {} from {}:{} to {}:{}",
-        zelf.source_code.path.to_owned(),
-        start.row,
-        start.column,
-        end.row,
-        end.column
-    );
-}
-
-/// Better traceback for internal error
-#[track_caller]
-fn unwrap_internal<T>(zelf: &Compiler<'_>, r: InternalResult<T>) -> T {
-    if let Err(ref r_err) = r {
-        eprintln!("=== CODEGEN PANIC INFO ===");
-        eprintln!("This IS an internal error: {r_err}");
-        eprint_location(zelf);
-        eprintln!("=== END PANIC INFO ===");
-    }
-    r.unwrap()
-}
-
-fn compiler_unwrap_option<T>(zelf: &Compiler<'_>, o: Option<T>) -> T {
-    if o.is_none() {
-        eprintln!("=== CODEGEN PANIC INFO ===");
-        eprintln!("This IS an internal error, an option was unwrapped during codegen");
-        eprint_location(zelf);
-        eprintln!("=== END PANIC INFO ===");
-    }
-    o.unwrap()
-}
-
-// fn compiler_result_unwrap<T, E: std::fmt::Debug>(zelf: &Compiler<'_>, result: Result<T, E>) -> T {
-//     if result.is_err() {
-//         eprintln!("=== CODEGEN PANIC INFO ===");
-//         eprintln!("This IS an internal error, an result was unwrapped during codegen");
-//         eprint_location(zelf);
-//         eprintln!("=== END PANIC INFO ===");
-//     }
-//     result.unwrap()
-// }
-
-/// The pattern context holds information about captured names and jump targets.
-#[derive(Clone)]
-pub struct PatternContext {
-    /// A list of names captured by the pattern.
-    pub stores: Vec<String>,
-    /// If false, then any name captures against our subject will raise.
-    pub allow_irrefutable: bool,
-    /// A list of jump target labels used on pattern failure.
-    pub fail_pop: Vec<BlockIdx>,
-    /// The number of items on top of the stack that should remain.
-    pub on_top: usize,
-}
-
-impl Default for PatternContext {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl PatternContext {
-    pub const fn new() -> Self {
-        Self {
-            stores: Vec::new(),
-            allow_irrefutable: false,
-            fail_pop: Vec::new(),
-            on_top: 0,
-        }
-    }
-
-    pub fn fail_pop_size(&self) -> usize {
-        self.fail_pop.len()
-    }
-}
-
-enum JumpOp {
-    Jump,
-    PopJumpIfFalse,
-}
-
-impl<'src> Compiler<'src> {
-    fn new(opts: CompileOpts, source_code: SourceCode<'src>, code_name: String) -> Self {
-        let module_code = ir::CodeInfo {
-            flags: bytecode::CodeFlags::NEW_LOCALS,
-            posonlyarg_count: 0,
-            arg_count: 0,
-            kwonlyarg_count: 0,
-            source_path: source_code.path.to_owned(),
-            first_line_number: OneIndexed::MIN,
-            obj_name: code_name,
-
-            blocks: vec![ir::Block::default()],
-            current_block: ir::BlockIdx(0),
-            constants: IndexSet::default(),
-            name_cache: IndexSet::default(),
-            varname_cache: IndexSet::default(),
-            cellvar_cache: IndexSet::default(),
-            freevar_cache: IndexSet::default(),
-        };
-        Compiler {
-            code_stack: vec![module_code],
-            symbol_table_stack: Vec::new(),
-            source_code,
-            // current_source_location: SourceLocation::default(),
-            current_source_range: TextRange::default(),
-            qualified_path: Vec::new(),
-            done_with_future_stmts: DoneWithFuture::No,
-            future_annotations: false,
-            ctx: CompileContext {
-                loop_data: None,
-                in_class: false,
-                func: FunctionContext::NoFunction,
-            },
-            class_name: None,
-            opts,
-            in_annotation: false,
-        }
-    }
-}
-
-impl Compiler<'_> {
-    fn error(&mut self, error: CodegenErrorType) -> CodegenError {
-        self.error_ranged(error, self.current_source_range)
-    }
-    fn error_ranged(&mut self, error: CodegenErrorType, range: TextRange) -> CodegenError {
-        let location = self.source_code.source_location(range.start());
-        CodegenError {
-            error,
-            location: Some(location),
-            source_path: self.source_code.path.to_owned(),
-        }
-    }
-
-    /// Push the next symbol table on to the stack
-    fn push_symbol_table(&mut self) -> &SymbolTable {
-        // Look up the next table contained in the scope of the current table
-        let table = self
-            .symbol_table_stack
-            .last_mut()
-            .expect("no next symbol table")
-            .sub_tables
-            .remove(0);
-        // Push the next table onto the stack
-        let last_idx = self.symbol_table_stack.len();
-        self.symbol_table_stack.push(table);
-        &self.symbol_table_stack[last_idx]
-    }
-
-    /// Pop the current symbol table off the stack
-    fn pop_symbol_table(&mut self) -> SymbolTable {
-        self.symbol_table_stack.pop().expect("compiler bug")
-    }
-
-    fn push_output(
-        &mut self,
-        flags: bytecode::CodeFlags,
-        posonlyarg_count: u32,
-        arg_count: u32,
-        kwonlyarg_count: u32,
-        obj_name: String,
-    ) {
-        let source_path = self.source_code.path.to_owned();
-        let first_line_number = self.get_source_line_number();
-
-        let table = self.push_symbol_table();
-
-        let cellvar_cache = table
-            .symbols
-            .iter()
-            .filter(|(_, s)| s.scope == SymbolScope::Cell)
-            .map(|(var, _)| var.clone())
-            .collect();
-        let freevar_cache = table
-            .symbols
-            .iter()
-            .filter(|(_, s)| {
-                s.scope == SymbolScope::Free || s.flags.contains(SymbolFlags::FREE_CLASS)
-            })
-            .map(|(var, _)| var.clone())
-            .collect();
-
-        let info = ir::CodeInfo {
-            flags,
-            posonlyarg_count,
-            arg_count,
-            kwonlyarg_count,
-            source_path,
-            first_line_number,
-            obj_name,
-
-            blocks: vec![ir::Block::default()],
-            current_block: ir::BlockIdx(0),
-            constants: IndexSet::default(),
-            name_cache: IndexSet::default(),
-            varname_cache: IndexSet::default(),
-            cellvar_cache,
-            freevar_cache,
-        };
-        self.code_stack.push(info);
-    }
-
-    fn pop_code_object(&mut self) -> CodeObject {
-        let table = self.pop_symbol_table();
-        assert!(table.sub_tables.is_empty());
-        let pop = self.code_stack.pop();
-        let stack_top = compiler_unwrap_option(self, pop);
-        unwrap_internal(self, stack_top.finalize_code(self.opts.optimize))
-    }
-
-    // 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.name_cache)
-    }
-    fn varname(&mut self, name: &str) -> CompileResult<bytecode::NameIdx> {
-        if Compiler::is_forbidden_arg_name(name) {
-            return Err(self.error(CodegenErrorType::SyntaxError(format!(
-                "cannot assign to {name}",
-            ))));
-        }
-        Ok(self._name_inner(name, |i| &mut i.varname_cache))
-    }
-    fn _name_inner(
-        &mut self,
-        name: &str,
-        cache: impl FnOnce(&mut ir::CodeInfo) -> &mut IndexSet<String>,
-    ) -> bytecode::NameIdx {
-        let name = self.mangle(name);
-        let cache = cache(self.current_code_info());
-        cache
-            .get_index_of(name.as_ref())
-            .unwrap_or_else(|| cache.insert_full(name.into_owned()).0)
-            .to_u32()
-    }
-
-    fn compile_program(
-        &mut self,
-        body: &ModModule,
-        symbol_table: SymbolTable,
-    ) -> CompileResult<()> {
-        let size_before = self.code_stack.len();
-        self.symbol_table_stack.push(symbol_table);
-
-        let (doc, statements) = split_doc(&body.body, &self.opts);
-        if let Some(value) = doc {
-            self.emit_load_const(ConstantData::Str {
-                value: value.into(),
-            });
-            let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreGlobal(doc))
-        }
-
-        if Self::find_ann(statements) {
-            emit!(self, Instruction::SetupAnnotation);
-        }
-
-        self.compile_statements(statements)?;
-
-        assert_eq!(self.code_stack.len(), size_before);
-
-        // Emit None at end:
-        self.emit_return_const(ConstantData::None);
-        Ok(())
-    }
-
-    fn compile_program_single(
-        &mut self,
-        body: &[Stmt],
-        symbol_table: SymbolTable,
-    ) -> CompileResult<()> {
-        self.symbol_table_stack.push(symbol_table);
-
-        if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotation);
-        }
-
-        if let Some((last, body)) = body.split_last() {
-            for statement in body {
-                if let Stmt::Expr(StmtExpr { value, .. }) = &statement {
-                    self.compile_expression(value)?;
-                    emit!(self, Instruction::PrintExpr);
-                } else {
-                    self.compile_statement(statement)?;
-                }
-            }
-
-            if let Stmt::Expr(StmtExpr { value, .. }) = &last {
-                self.compile_expression(value)?;
-                emit!(self, Instruction::Duplicate);
-                emit!(self, Instruction::PrintExpr);
-            } else {
-                self.compile_statement(last)?;
-                self.emit_load_const(ConstantData::None);
-            }
-        } else {
-            self.emit_load_const(ConstantData::None);
-        };
-
-        self.emit_return_value();
-        Ok(())
-    }
-
-    fn compile_block_expr(
-        &mut self,
-        body: &[Stmt],
-        symbol_table: SymbolTable,
-    ) -> CompileResult<()> {
-        self.symbol_table_stack.push(symbol_table);
-
-        self.compile_statements(body)?;
-
-        if let Some(last_statement) = body.last() {
-            match last_statement {
-                Stmt::Expr(_) => {
-                    self.current_block().instructions.pop(); // pop Instruction::Pop
-                }
-                Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
-                    let pop_instructions = self.current_block().instructions.pop();
-                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
-                    emit!(self, Instruction::Duplicate);
-                    self.current_block().instructions.push(store_inst);
-                }
-                _ => self.emit_load_const(ConstantData::None),
-            }
-        }
-        self.emit_return_value();
-
-        Ok(())
-    }
-
-    // Compile statement in eval mode:
-    fn compile_eval(
-        &mut self,
-        expression: &ModExpression,
-        symbol_table: SymbolTable,
-    ) -> CompileResult<()> {
-        self.symbol_table_stack.push(symbol_table);
-        self.compile_expression(&expression.body)?;
-        self.emit_return_value();
-        Ok(())
-    }
-
-    fn compile_statements(&mut self, statements: &[Stmt]) -> CompileResult<()> {
-        for statement in statements {
-            self.compile_statement(statement)?
-        }
-        Ok(())
-    }
-
-    fn load_name(&mut self, name: &str) -> CompileResult<()> {
-        self.compile_name(name, NameUsage::Load)
-    }
-
-    fn store_name(&mut self, name: &str) -> CompileResult<()> {
-        self.compile_name(name, NameUsage::Store)
-    }
-
-    fn mangle<'a>(&self, name: &'a str) -> Cow<'a, str> {
-        symboltable::mangle_name(self.class_name.as_deref(), name)
-    }
-
-    fn check_forbidden_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
-        let msg = match usage {
-            NameUsage::Store if is_forbidden_name(name) => "cannot assign to",
-            NameUsage::Delete if is_forbidden_name(name) => "cannot delete",
-            _ => return Ok(()),
-        };
-        Err(self.error(CodegenErrorType::SyntaxError(format!("{msg} {name}"))))
-    }
-
-    fn compile_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
-        let name = self.mangle(name);
-
-        self.check_forbidden_name(&name, usage)?;
-
-        let symbol_table = self.symbol_table_stack.last().unwrap();
-        let symbol = unwrap_internal(
-            self,
-            symbol_table
-                .lookup(name.as_ref())
-                .ok_or_else(|| InternalError::MissingSymbol(name.to_string())),
-        );
-        let info = self.code_stack.last_mut().unwrap();
-        let mut cache = &mut info.name_cache;
-        enum NameOpType {
-            Fast,
-            Global,
-            Deref,
-            Local,
-        }
-        let op_typ = match symbol.scope {
-            SymbolScope::Local if self.ctx.in_func() => {
-                cache = &mut info.varname_cache;
-                NameOpType::Fast
-            }
-            SymbolScope::GlobalExplicit => NameOpType::Global,
-            SymbolScope::GlobalImplicit | SymbolScope::Unknown if self.ctx.in_func() => {
-                NameOpType::Global
-            }
-            SymbolScope::GlobalImplicit | SymbolScope::Unknown => NameOpType::Local,
-            SymbolScope::Local => NameOpType::Local,
-            SymbolScope::Free => {
-                cache = &mut info.freevar_cache;
-                NameOpType::Deref
-            }
-            SymbolScope::Cell => {
-                cache = &mut info.cellvar_cache;
-                NameOpType::Deref
-            } // TODO: is this right?
-              // SymbolScope::Unknown => NameOpType::Global,
-        };
-
-        if NameUsage::Load == usage && name == "__debug__" {
-            self.emit_load_const(ConstantData::Boolean {
-                value: self.opts.optimize == 0,
-            });
-            return Ok(());
-        }
-
-        let mut idx = cache
-            .get_index_of(name.as_ref())
-            .unwrap_or_else(|| cache.insert_full(name.into_owned()).0);
-        if let SymbolScope::Free = symbol.scope {
-            idx += info.cellvar_cache.len();
-        }
-        let op = match op_typ {
-            NameOpType::Fast => match usage {
-                NameUsage::Load => Instruction::LoadFast,
-                NameUsage::Store => Instruction::StoreFast,
-                NameUsage::Delete => Instruction::DeleteFast,
-            },
-            NameOpType::Global => match usage {
-                NameUsage::Load => Instruction::LoadGlobal,
-                NameUsage::Store => Instruction::StoreGlobal,
-                NameUsage::Delete => Instruction::DeleteGlobal,
-            },
-            NameOpType::Deref => match usage {
-                NameUsage::Load if !self.ctx.in_func() && self.ctx.in_class => {
-                    Instruction::LoadClassDeref
-                }
-                NameUsage::Load => Instruction::LoadDeref,
-                NameUsage::Store => Instruction::StoreDeref,
-                NameUsage::Delete => Instruction::DeleteDeref,
-            },
-            NameOpType::Local => match usage {
-                NameUsage::Load => Instruction::LoadNameAny,
-                NameUsage::Store => Instruction::StoreLocal,
-                NameUsage::Delete => Instruction::DeleteLocal,
-            },
-        };
-        self.emit_arg(idx.to_u32(), op);
-
-        Ok(())
-    }
-
-    fn compile_statement(&mut self, statement: &Stmt) -> CompileResult<()> {
-        use ruff_python_ast::*;
-        trace!("Compiling {statement:?}");
-        self.set_source_range(statement.range());
-
-        match &statement {
-            // we do this here because `from __future__` still executes that `from` statement at runtime,
-            // we still need to compile the ImportFrom down below
-            Stmt::ImportFrom(StmtImportFrom { module, names, .. })
-                if module.as_ref().map(|id| id.as_str()) == Some("__future__") =>
-            {
-                self.compile_future_features(names)?
-            }
-            // ignore module-level doc comments
-            Stmt::Expr(StmtExpr { value, .. })
-                if matches!(&**value, Expr::StringLiteral(..))
-                    && matches!(self.done_with_future_stmts, DoneWithFuture::No) =>
-            {
-                self.done_with_future_stmts = DoneWithFuture::DoneWithDoc
-            }
-            // if we find any other statement, stop accepting future statements
-            _ => self.done_with_future_stmts = DoneWithFuture::Yes,
-        }
-
-        match &statement {
-            Stmt::Import(StmtImport { names, .. }) => {
-                // import a, b, c as d
-                for name in names {
-                    let name = &name;
-                    self.emit_load_const(ConstantData::Integer {
-                        value: num_traits::Zero::zero(),
-                    });
-                    self.emit_load_const(ConstantData::None);
-                    let idx = self.name(&name.name);
-                    emit!(self, Instruction::ImportName { idx });
-                    if let Some(alias) = &name.asname {
-                        for part in name.name.split('.').skip(1) {
-                            let idx = self.name(part);
-                            emit!(self, Instruction::LoadAttr { idx });
-                        }
-                        self.store_name(alias.as_str())?
-                    } else {
-                        self.store_name(name.name.split('.').next().unwrap())?
-                    }
-                }
-            }
-            Stmt::ImportFrom(StmtImportFrom {
-                level,
-                module,
-                names,
-                ..
-            }) => {
-                let import_star = names.iter().any(|n| &n.name == "*");
-
-                let from_list = if import_star {
-                    if self.ctx.in_func() {
-                        return Err(self.error_ranged(
-                            CodegenErrorType::FunctionImportStar,
-                            statement.range(),
-                        ));
-                    }
-                    vec![ConstantData::Str { value: "*".into() }]
-                } else {
-                    names
-                        .iter()
-                        .map(|n| ConstantData::Str {
-                            value: n.name.as_str().into(),
-                        })
-                        .collect()
-                };
-
-                let module_idx = module.as_ref().map(|s| self.name(s.as_str()));
-
-                // from .... import (*fromlist)
-                self.emit_load_const(ConstantData::Integer {
-                    value: (*level).into(),
-                });
-                self.emit_load_const(ConstantData::Tuple {
-                    elements: from_list,
-                });
-                if let Some(idx) = module_idx {
-                    emit!(self, Instruction::ImportName { idx });
-                } else {
-                    emit!(self, Instruction::ImportNameless);
-                }
-
-                if import_star {
-                    // from .... import *
-                    emit!(self, Instruction::ImportStar);
-                } else {
-                    // from mod import a, b as c
-
-                    for name in names {
-                        let name = &name;
-                        let idx = self.name(name.name.as_str());
-                        // import symbol from module:
-                        emit!(self, Instruction::ImportFrom { idx });
-
-                        // Store module under proper name:
-                        if let Some(alias) = &name.asname {
-                            self.store_name(alias.as_str())?
-                        } else {
-                            self.store_name(name.name.as_str())?
-                        }
-                    }
-
-                    // Pop module from stack:
-                    emit!(self, Instruction::Pop);
-                }
-            }
-            Stmt::Expr(StmtExpr { value, .. }) => {
-                self.compile_expression(value)?;
-
-                // Pop result of stack, since we not use it:
-                emit!(self, Instruction::Pop);
-            }
-            Stmt::Global(_) | Stmt::Nonlocal(_) => {
-                // Handled during symbol table construction.
-            }
-            Stmt::If(StmtIf {
-                test,
-                body,
-                elif_else_clauses,
-                ..
-            }) => {
-                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,
-                            Instruction::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,
-                                Instruction::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);
-                    }
-                }
-            }
-            Stmt::While(StmtWhile {
-                test, body, orelse, ..
-            }) => self.compile_while(test, body, orelse)?,
-            Stmt::With(StmtWith {
-                items,
-                body,
-                is_async,
-                ..
-            }) => self.compile_with(items, body, *is_async)?,
-            Stmt::For(StmtFor {
-                target,
-                iter,
-                body,
-                orelse,
-                is_async,
-                ..
-            }) => self.compile_for(target, iter, body, orelse, *is_async)?,
-            Stmt::Match(StmtMatch { subject, cases, .. }) => self.compile_match(subject, cases)?,
-            Stmt::Raise(StmtRaise { exc, cause, .. }) => {
-                let kind = match exc {
-                    Some(value) => {
-                        self.compile_expression(value)?;
-                        match cause {
-                            Some(cause) => {
-                                self.compile_expression(cause)?;
-                                bytecode::RaiseKind::RaiseCause
-                            }
-                            None => bytecode::RaiseKind::Raise,
-                        }
-                    }
-                    None => bytecode::RaiseKind::Reraise,
-                };
-                emit!(self, Instruction::Raise { kind });
-            }
-            Stmt::Try(StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                is_star,
-                ..
-            }) => {
-                if *is_star {
-                    self.compile_try_star_statement(body, handlers, orelse, finalbody)?
-                } else {
-                    self.compile_try_statement(body, handlers, orelse, finalbody)?
-                }
-            }
-            Stmt::FunctionDef(StmtFunctionDef {
-                name,
-                parameters,
-                body,
-                decorator_list,
-                returns,
-                type_params,
-                is_async,
-                ..
-            }) => self.compile_function_def(
-                name.as_str(),
-                parameters,
-                body,
-                decorator_list,
-                returns.as_deref(),
-                *is_async,
-                type_params.as_deref(),
-            )?,
-            Stmt::ClassDef(StmtClassDef {
-                name,
-                body,
-                decorator_list,
-                type_params,
-                arguments,
-                ..
-            }) => self.compile_class_def(
-                name.as_str(),
-                body,
-                decorator_list,
-                type_params.as_deref(),
-                arguments.as_deref(),
-            )?,
-            Stmt::Assert(StmtAssert { test, msg, .. }) => {
-                // if some flag, ignore all assert statements!
-                if self.opts.optimize == 0 {
-                    let after_block = self.new_block();
-                    self.compile_jump_if(test, true, after_block)?;
-
-                    let assertion_error = self.name("AssertionError");
-                    emit!(self, Instruction::LoadGlobal(assertion_error));
-                    match msg {
-                        Some(e) => {
-                            self.compile_expression(e)?;
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
-                        }
-                        None => {
-                            emit!(self, Instruction::CallFunctionPositional { nargs: 0 });
-                        }
-                    }
-                    emit!(
-                        self,
-                        Instruction::Raise {
-                            kind: bytecode::RaiseKind::Raise,
-                        }
-                    );
-
-                    self.switch_to_block(after_block);
-                }
-            }
-            Stmt::Break(_) => match self.ctx.loop_data {
-                Some((_, end)) => {
-                    emit!(self, Instruction::Break { target: end });
-                }
-                None => {
-                    return Err(
-                        self.error_ranged(CodegenErrorType::InvalidBreak, statement.range())
-                    );
-                }
-            },
-            Stmt::Continue(_) => match self.ctx.loop_data {
-                Some((start, _)) => {
-                    emit!(self, Instruction::Continue { target: start });
-                }
-                None => {
-                    return Err(
-                        self.error_ranged(CodegenErrorType::InvalidContinue, statement.range())
-                    );
-                }
-            },
-            Stmt::Return(StmtReturn { value, .. }) => {
-                if !self.ctx.in_func() {
-                    return Err(
-                        self.error_ranged(CodegenErrorType::InvalidReturn, statement.range())
-                    );
-                }
-                match value {
-                    Some(v) => {
-                        if self.ctx.func == FunctionContext::AsyncFunction
-                            && self
-                                .current_code_info()
-                                .flags
-                                .contains(bytecode::CodeFlags::IS_GENERATOR)
-                        {
-                            return Err(self.error_ranged(
-                                CodegenErrorType::AsyncReturnValue,
-                                statement.range(),
-                            ));
-                        }
-                        self.compile_expression(v)?;
-                        self.emit_return_value();
-                    }
-                    None => {
-                        self.emit_return_const(ConstantData::None);
-                    }
-                }
-            }
-            Stmt::Assign(StmtAssign { targets, value, .. }) => {
-                self.compile_expression(value)?;
-
-                for (i, target) in targets.iter().enumerate() {
-                    if i + 1 != targets.len() {
-                        emit!(self, Instruction::Duplicate);
-                    }
-                    self.compile_store(target)?;
-                }
-            }
-            Stmt::AugAssign(StmtAugAssign {
-                target, op, value, ..
-            }) => self.compile_augassign(target, op, value)?,
-            Stmt::AnnAssign(StmtAnnAssign {
-                target,
-                annotation,
-                value,
-                ..
-            }) => self.compile_annotated_assign(target, annotation, value.as_deref())?,
-            Stmt::Delete(StmtDelete { targets, .. }) => {
-                for target in targets {
-                    self.compile_delete(target)?;
-                }
-            }
-            Stmt::Pass(_) => {
-                // No need to emit any code here :)
-            }
-            Stmt::TypeAlias(StmtTypeAlias {
-                name,
-                type_params,
-                value,
-                ..
-            }) => {
-                // let name_string = name.to_string();
-                let Some(name) = name.as_name_expr() else {
-                    // FIXME: is error here?
-                    return Err(self.error(CodegenErrorType::SyntaxError(
-                        "type alias expect name".to_owned(),
-                    )));
-                };
-                let name_string = name.id.to_string();
-
-                // For PEP 695 syntax, we need to compile type_params first
-                // so that they're available when compiling the value expression
-                if let Some(type_params) = type_params {
-                    self.push_symbol_table();
-
-                    // Compile type params first to define T1, T2, etc.
-                    self.compile_type_params(type_params)?;
-                    // Stack now has type_params tuple at top
-
-                    // Compile value expression (can now see T1, T2)
-                    self.compile_expression(value)?;
-                    // Stack: [type_params_tuple, value]
-
-                    // We need [value, type_params_tuple] for TypeAlias instruction
-                    emit!(self, Instruction::Rotate2);
-
-                    self.pop_symbol_table();
-                } else {
-                    // No type params - push value first, then None (not empty tuple)
-                    self.compile_expression(value)?;
-                    // Push None for type_params (matching CPython)
-                    self.emit_load_const(ConstantData::None);
-                }
-
-                // Push name last
-                self.emit_load_const(ConstantData::Str {
-                    value: name_string.clone().into(),
-                });
-                emit!(self, Instruction::TypeAlias);
-                self.store_name(&name_string)?;
-            }
-            Stmt::IpyEscapeCommand(_) => todo!(),
-        }
-        Ok(())
-    }
-
-    fn compile_delete(&mut self, expression: &Expr) -> CompileResult<()> {
-        use ruff_python_ast::*;
-        match &expression {
-            Expr::Name(ExprName { id, .. }) => self.compile_name(id.as_str(), NameUsage::Delete)?,
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
-                self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::DeleteAttr { idx });
-            }
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                self.compile_expression(value)?;
-                self.compile_expression(slice)?;
-                emit!(self, Instruction::DeleteSubscript);
-            }
-            Expr::Tuple(ExprTuple { elts, .. }) | Expr::List(ExprList { elts, .. }) => {
-                for element in elts {
-                    self.compile_delete(element)?;
-                }
-            }
-            Expr::BinOp(_) | Expr::UnaryOp(_) => {
-                return Err(self.error(CodegenErrorType::Delete("expression")));
-            }
-            _ => return Err(self.error(CodegenErrorType::Delete(expression.python_name()))),
-        }
-        Ok(())
-    }
-
-    fn enter_function(
-        &mut self,
-        name: &str,
-        parameters: &Parameters,
-    ) -> CompileResult<bytecode::MakeFunctionFlags> {
-        let defaults: Vec<_> = std::iter::empty()
-            .chain(&parameters.posonlyargs)
-            .chain(&parameters.args)
-            .filter_map(|x| x.default.as_deref())
-            .collect();
-        let have_defaults = !defaults.is_empty();
-        if have_defaults {
-            // Construct a tuple:
-            let size = defaults.len().to_u32();
-            for element in &defaults {
-                self.compile_expression(element)?;
-            }
-            emit!(self, Instruction::BuildTuple { size });
-        }
-
-        // TODO: partition_in_place
-        let mut kw_without_defaults = vec![];
-        let mut kw_with_defaults = vec![];
-        for kwonlyarg in &parameters.kwonlyargs {
-            if let Some(default) = &kwonlyarg.default {
-                kw_with_defaults.push((&kwonlyarg.parameter, default));
-            } else {
-                kw_without_defaults.push(&kwonlyarg.parameter);
-            }
-        }
-
-        // let (kw_without_defaults, kw_with_defaults) = args.split_kwonlyargs();
-        if !kw_with_defaults.is_empty() {
-            let default_kw_count = kw_with_defaults.len();
-            for (arg, default) in kw_with_defaults.iter() {
-                self.emit_load_const(ConstantData::Str {
-                    value: arg.name.as_str().into(),
-                });
-                self.compile_expression(default)?;
-            }
-            emit!(
-                self,
-                Instruction::BuildMap {
-                    size: default_kw_count.to_u32(),
-                }
-            );
-        }
-
-        let mut func_flags = bytecode::MakeFunctionFlags::empty();
-        if have_defaults {
-            func_flags |= bytecode::MakeFunctionFlags::DEFAULTS;
-        }
-        if !kw_with_defaults.is_empty() {
-            func_flags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
-        }
-
-        self.push_output(
-            bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED,
-            parameters.posonlyargs.len().to_u32(),
-            (parameters.posonlyargs.len() + parameters.args.len()).to_u32(),
-            parameters.kwonlyargs.len().to_u32(),
-            name.to_owned(),
-        );
-
-        let args_iter = std::iter::empty()
-            .chain(&parameters.posonlyargs)
-            .chain(&parameters.args)
-            .map(|arg| &arg.parameter)
-            .chain(kw_without_defaults)
-            .chain(kw_with_defaults.into_iter().map(|(arg, _)| arg));
-        for name in args_iter {
-            self.varname(name.name.as_str())?;
-        }
-
-        if let Some(name) = parameters.vararg.as_deref() {
-            self.current_code_info().flags |= bytecode::CodeFlags::HAS_VARARGS;
-            self.varname(name.name.as_str())?;
-        }
-        if let Some(name) = parameters.kwarg.as_deref() {
-            self.current_code_info().flags |= bytecode::CodeFlags::HAS_VARKEYWORDS;
-            self.varname(name.name.as_str())?;
-        }
-
-        Ok(func_flags)
-    }
-
-    fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
-        for decorator in decorator_list {
-            self.compile_expression(&decorator.expression)?;
-        }
-        Ok(())
-    }
-
-    fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
-        // Apply decorators:
-        for _ in decorator_list {
-            emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
-        }
-    }
-
-    /// Store each type parameter so it is accessible to the current scope, and leave a tuple of
-    /// all the type parameters on the stack.
-    fn compile_type_params(&mut self, type_params: &TypeParams) -> CompileResult<()> {
-        // First, compile each type parameter and store it
-        for type_param in &type_params.type_params {
-            match type_param {
-                TypeParam::TypeVar(TypeParamTypeVar {
-                    name,
-                    bound,
-                    default,
-                    ..
-                }) => {
-                    if let Some(expr) = &bound {
-                        self.compile_expression(expr)?;
-                        self.emit_load_const(ConstantData::Str {
-                            value: name.as_str().into(),
-                        });
-                        emit!(self, Instruction::TypeVarWithBound);
-                    } else {
-                        self.emit_load_const(ConstantData::Str {
-                            value: name.as_str().into(),
-                        });
-                        emit!(self, Instruction::TypeVar);
-                    }
-
-                    // Handle default value if present (PEP 695)
-                    if let Some(default_expr) = default {
-                        // Compile the default expression
-                        self.compile_expression(default_expr)?;
-
-                        emit!(
-                            self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
-                        );
-                    }
-
-                    emit!(self, Instruction::Duplicate);
-                    self.store_name(name.as_ref())?;
-                }
-                TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
-                    self.emit_load_const(ConstantData::Str {
-                        value: name.as_str().into(),
-                    });
-                    emit!(self, Instruction::ParamSpec);
-
-                    // Handle default value if present (PEP 695)
-                    if let Some(default_expr) = default {
-                        // Compile the default expression
-                        self.compile_expression(default_expr)?;
-
-                        emit!(
-                            self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
-                        );
-                    }
-
-                    emit!(self, Instruction::Duplicate);
-                    self.store_name(name.as_ref())?;
-                }
-                TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
-                    self.emit_load_const(ConstantData::Str {
-                        value: name.as_str().into(),
-                    });
-                    emit!(self, Instruction::TypeVarTuple);
-
-                    // Handle default value if present (PEP 695)
-                    if let Some(default_expr) = default {
-                        // Compile the default expression
-                        self.compile_expression(default_expr)?;
-
-                        // Handle starred expression (*default)
-                        emit!(
-                            self,
-                            Instruction::CallIntrinsic2 {
-                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
-                            }
-                        );
-                    }
-
-                    emit!(self, Instruction::Duplicate);
-                    self.store_name(name.as_ref())?;
-                }
-            };
-        }
-        emit!(
-            self,
-            Instruction::BuildTuple {
-                size: u32::try_from(type_params.len()).unwrap(),
-            }
-        );
-        Ok(())
-    }
-
-    fn compile_try_statement(
-        &mut self,
-        body: &[Stmt],
-        handlers: &[ExceptHandler],
-        orelse: &[Stmt],
-        finalbody: &[Stmt],
-    ) -> CompileResult<()> {
-        let handler_block = self.new_block();
-        let finally_block = self.new_block();
-
-        // Setup a finally block if we have a finally statement.
-        if !finalbody.is_empty() {
-            emit!(
-                self,
-                Instruction::SetupFinally {
-                    handler: finally_block,
-                }
-            );
-        }
-
-        let else_block = self.new_block();
-
-        // try:
-        emit!(
-            self,
-            Instruction::SetupExcept {
-                handler: handler_block,
-            }
-        );
-        self.compile_statements(body)?;
-        emit!(self, Instruction::PopBlock);
-        emit!(self, Instruction::Jump { target: else_block });
-
-        // except handlers:
-        self.switch_to_block(handler_block);
-        // Exception is on top of stack now
-        for handler in handlers {
-            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
-                type_, name, body, ..
-            }) = &handler;
-            let next_handler = self.new_block();
-
-            // If we gave a typ,
-            // check if this handler can handle the exception:
-            if let Some(exc_type) = type_ {
-                // Duplicate exception for test:
-                emit!(self, Instruction::Duplicate);
-
-                // Check exception type:
-                self.compile_expression(exc_type)?;
-                emit!(
-                    self,
-                    Instruction::TestOperation {
-                        op: bytecode::TestOperator::ExceptionMatch,
-                    }
-                );
-
-                // We cannot handle this exception type:
-                emit!(
-                    self,
-                    Instruction::JumpIfFalse {
-                        target: next_handler,
-                    }
-                );
-
-                // We have a match, store in name (except x as y)
-                if let Some(alias) = name {
-                    self.store_name(alias.as_str())?
-                } else {
-                    // Drop exception from top of stack:
-                    emit!(self, Instruction::Pop);
-                }
-            } else {
-                // Catch all!
-                // Drop exception from top of stack:
-                emit!(self, Instruction::Pop);
-            }
-
-            // Handler code:
-            self.compile_statements(body)?;
-            emit!(self, Instruction::PopException);
-
-            // Delete the exception variable if it was bound
-            if let Some(alias) = name {
-                // Set the variable to None before deleting (as CPython does)
-                self.emit_load_const(ConstantData::None);
-                self.store_name(alias.as_str())?;
-                self.compile_name(alias.as_str(), NameUsage::Delete)?;
-            }
-
-            if !finalbody.is_empty() {
-                emit!(self, Instruction::PopBlock); // pop excepthandler block
-                // We enter the finally block, without exception.
-                emit!(self, Instruction::EnterFinally);
-            }
-
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: finally_block,
-                }
-            );
-
-            // Emit a new label for the next handler
-            self.switch_to_block(next_handler);
-        }
-
-        // If code flows here, we have an unhandled exception,
-        // raise the exception again!
-        emit!(
-            self,
-            Instruction::Raise {
-                kind: bytecode::RaiseKind::Reraise,
-            }
-        );
-
-        // We successfully ran the try block:
-        // else:
-        self.switch_to_block(else_block);
-        self.compile_statements(orelse)?;
-
-        if !finalbody.is_empty() {
-            emit!(self, Instruction::PopBlock); // pop finally block
-
-            // We enter the finallyhandler block, without return / exception.
-            emit!(self, Instruction::EnterFinally);
-        }
-
-        // finally:
-        self.switch_to_block(finally_block);
-        if !finalbody.is_empty() {
-            self.compile_statements(finalbody)?;
-            emit!(self, Instruction::EndFinally);
-        }
-
-        Ok(())
-    }
-
-    fn compile_try_star_statement(
-        &mut self,
-        _body: &[Stmt],
-        _handlers: &[ExceptHandler],
-        _orelse: &[Stmt],
-        _finalbody: &[Stmt],
-    ) -> CompileResult<()> {
-        Err(self.error(CodegenErrorType::NotImplementedYet))
-    }
-
-    fn is_forbidden_arg_name(name: &str) -> bool {
-        is_forbidden_name(name)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn compile_function_def(
-        &mut self,
-        name: &str,
-        parameters: &Parameters,
-        body: &[Stmt],
-        decorator_list: &[Decorator],
-        returns: Option<&Expr>, // TODO: use type hint somehow..
-        is_async: bool,
-        type_params: Option<&TypeParams>,
-    ) -> CompileResult<()> {
-        self.prepare_decorators(decorator_list)?;
-
-        // If there are type params, we need to push a special symbol table just for them
-        if type_params.is_some() {
-            self.push_symbol_table();
-        }
-
-        let mut func_flags = self.enter_function(name, parameters)?;
-        self.current_code_info()
-            .flags
-            .set(bytecode::CodeFlags::IS_COROUTINE, is_async);
-
-        // remember to restore self.ctx.in_loop to the original after the function is compiled
-        let prev_ctx = self.ctx;
-
-        self.ctx = CompileContext {
-            loop_data: None,
-            in_class: prev_ctx.in_class,
-            func: if is_async {
-                FunctionContext::AsyncFunction
-            } else {
-                FunctionContext::Function
-            },
-        };
-
-        self.push_qualified_path(name);
-        let qualified_name = self.qualified_path.join(".");
-        self.push_qualified_path("<locals>");
-
-        let (doc_str, body) = split_doc(body, &self.opts);
-
-        self.current_code_info()
-            .constants
-            .insert_full(ConstantData::None);
-
-        self.compile_statements(body)?;
-
-        // Emit None at end:
-        match body.last() {
-            Some(Stmt::Return(_)) => {
-                // the last instruction is a ReturnValue already, we don't need to emit it
-            }
-            _ => {
-                self.emit_return_const(ConstantData::None);
-            }
-        }
-
-        let code = self.pop_code_object();
-        self.qualified_path.pop();
-        self.qualified_path.pop();
-        self.ctx = prev_ctx;
-
-        // Prepare generic type parameters:
-        if let Some(type_params) = type_params {
-            self.compile_type_params(type_params)?;
-            func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
-        }
-
-        // Prepare type annotations:
-        let mut num_annotations = 0;
-
-        // Return annotation:
-        if let Some(annotation) = returns {
-            // key:
-            self.emit_load_const(ConstantData::Str {
-                value: "return".into(),
-            });
-            // value:
-            self.compile_annotation(annotation)?;
-            num_annotations += 1;
-        }
-
-        let parameters_iter = std::iter::empty()
-            .chain(&parameters.posonlyargs)
-            .chain(&parameters.args)
-            .chain(&parameters.kwonlyargs)
-            .map(|x| &x.parameter)
-            .chain(parameters.vararg.as_deref())
-            .chain(parameters.kwarg.as_deref());
-        for param in parameters_iter {
-            if let Some(annotation) = &param.annotation {
-                self.emit_load_const(ConstantData::Str {
-                    value: self.mangle(param.name.as_str()).into_owned().into(),
-                });
-                self.compile_annotation(annotation)?;
-                num_annotations += 1;
-            }
-        }
-
-        if num_annotations > 0 {
-            func_flags |= bytecode::MakeFunctionFlags::ANNOTATIONS;
-            emit!(
-                self,
-                Instruction::BuildMap {
-                    size: num_annotations,
-                }
-            );
-        }
-
-        if self.build_closure(&code) {
-            func_flags |= bytecode::MakeFunctionFlags::CLOSURE;
-        }
-
-        // Pop the special type params symbol table
-        if type_params.is_some() {
-            self.pop_symbol_table();
-        }
-
-        self.emit_load_const(ConstantData::Code {
-            code: Box::new(code),
-        });
-        self.emit_load_const(ConstantData::Str {
-            value: qualified_name.into(),
-        });
-
-        // Turn code object into function object:
-        emit!(self, Instruction::MakeFunction(func_flags));
-
-        if let Some(value) = doc_str {
-            emit!(self, Instruction::Duplicate);
-            self.emit_load_const(ConstantData::Str {
-                value: value.into(),
-            });
-            emit!(self, Instruction::Rotate2);
-            let doc = self.name("__doc__");
-            emit!(self, Instruction::StoreAttr { idx: doc });
-        }
-
-        self.apply_decorators(decorator_list);
-
-        self.store_name(name)
-    }
-
-    fn build_closure(&mut self, code: &CodeObject) -> bool {
-        if code.freevars.is_empty() {
-            return false;
-        }
-        for var in &*code.freevars {
-            let table = self.symbol_table_stack.last().unwrap();
-            let symbol = unwrap_internal(
-                self,
-                table
-                    .lookup(var)
-                    .ok_or_else(|| InternalError::MissingSymbol(var.to_owned())),
-            );
-            let parent_code = self.code_stack.last().unwrap();
-            let vars = match symbol.scope {
-                SymbolScope::Free => &parent_code.freevar_cache,
-                SymbolScope::Cell => &parent_code.cellvar_cache,
-                _ if symbol.flags.contains(SymbolFlags::FREE_CLASS) => &parent_code.freevar_cache,
-                x => unreachable!(
-                    "var {} in a {:?} should be free or cell but it's {:?}",
-                    var, table.typ, x
-                ),
-            };
-            let mut idx = vars.get_index_of(var).unwrap();
-            if let SymbolScope::Free = symbol.scope {
-                idx += parent_code.cellvar_cache.len();
-            }
-            emit!(self, Instruction::LoadClosure(idx.to_u32()))
-        }
-        emit!(
-            self,
-            Instruction::BuildTuple {
-                size: code.freevars.len().to_u32(),
-            }
-        );
-        true
-    }
-
-    // Python/compile.c find_ann
-    fn find_ann(body: &[Stmt]) -> bool {
-        use ruff_python_ast::*;
-        for statement in body {
-            let res = match &statement {
-                Stmt::AnnAssign(_) => true,
-                Stmt::For(StmtFor { body, orelse, .. }) => {
-                    Self::find_ann(body) || Self::find_ann(orelse)
-                }
-                Stmt::If(StmtIf {
-                    body,
-                    elif_else_clauses,
-                    ..
-                }) => {
-                    Self::find_ann(body)
-                        || elif_else_clauses.iter().any(|x| Self::find_ann(&x.body))
-                }
-                Stmt::While(StmtWhile { body, orelse, .. }) => {
-                    Self::find_ann(body) || Self::find_ann(orelse)
-                }
-                Stmt::With(StmtWith { body, .. }) => Self::find_ann(body),
-                Stmt::Try(StmtTry {
-                    body,
-                    orelse,
-                    finalbody,
-                    ..
-                }) => Self::find_ann(body) || Self::find_ann(orelse) || Self::find_ann(finalbody),
-                _ => false,
-            };
-            if res {
-                return true;
-            }
-        }
-        false
-    }
-
-    fn compile_class_def(
-        &mut self,
-        name: &str,
-        body: &[Stmt],
-        decorator_list: &[Decorator],
-        type_params: Option<&TypeParams>,
-        arguments: Option<&Arguments>,
-    ) -> CompileResult<()> {
-        self.prepare_decorators(decorator_list)?;
-
-        let prev_ctx = self.ctx;
-        self.ctx = CompileContext {
-            func: FunctionContext::NoFunction,
-            in_class: true,
-            loop_data: None,
-        };
-
-        let prev_class_name = self.class_name.replace(name.to_owned());
-
-        // Check if the class is declared global
-        let symbol_table = self.symbol_table_stack.last().unwrap();
-        let symbol = unwrap_internal(
-            self,
-            symbol_table
-                .lookup(name.as_ref())
-                .ok_or_else(|| InternalError::MissingSymbol(name.to_owned())),
-        );
-        let mut global_path_prefix = Vec::new();
-        if symbol.scope == SymbolScope::GlobalExplicit {
-            global_path_prefix.append(&mut self.qualified_path);
-        }
-        self.push_qualified_path(name);
-        let qualified_name = self.qualified_path.join(".");
-
-        // If there are type params, we need to push a special symbol table just for them
-        if let Some(type_params) = type_params {
-            self.push_symbol_table();
-            // Compile type parameters and store as .type_params
-            self.compile_type_params(type_params)?;
-            let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::StoreLocal(dot_type_params));
-        }
-
-        self.push_output(bytecode::CodeFlags::empty(), 0, 0, 0, name.to_owned());
-
-        let (doc_str, body) = split_doc(body, &self.opts);
-
-        let dunder_name = self.name("__name__");
-        emit!(self, Instruction::LoadGlobal(dunder_name));
-        let dunder_module = self.name("__module__");
-        emit!(self, Instruction::StoreLocal(dunder_module));
-        self.emit_load_const(ConstantData::Str {
-            value: qualified_name.into(),
-        });
-        let qualname = self.name("__qualname__");
-        emit!(self, Instruction::StoreLocal(qualname));
-        self.load_docstring(doc_str);
-        let doc = self.name("__doc__");
-        emit!(self, Instruction::StoreLocal(doc));
-        // setup annotations
-        if Self::find_ann(body) {
-            emit!(self, Instruction::SetupAnnotation);
-        }
-
-        // Set __type_params__ from .type_params if we have type parameters (PEP 695)
-        if type_params.is_some() {
-            // Load .type_params from enclosing scope
-            let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::LoadNameAny(dot_type_params));
-
-            // Store as __type_params__
-            let dunder_type_params = self.name("__type_params__");
-            emit!(self, Instruction::StoreLocal(dunder_type_params));
-        }
-
-        self.compile_statements(body)?;
-
-        let classcell_idx = self
-            .code_stack
-            .last_mut()
-            .unwrap()
-            .cellvar_cache
-            .iter()
-            .position(|var| *var == "__class__");
-
-        if let Some(classcell_idx) = classcell_idx {
-            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
-            emit!(self, Instruction::Duplicate);
-            let classcell = self.name("__classcell__");
-            emit!(self, Instruction::StoreLocal(classcell));
-        } else {
-            self.emit_load_const(ConstantData::None);
-        }
-
-        self.emit_return_value();
-
-        let code = self.pop_code_object();
-
-        self.class_name = prev_class_name;
-        self.qualified_path.pop();
-        self.qualified_path.append(global_path_prefix.as_mut());
-        self.ctx = prev_ctx;
-
-        emit!(self, Instruction::LoadBuildClass);
-
-        let mut func_flags = bytecode::MakeFunctionFlags::empty();
-
-        // Prepare generic type parameters:
-        if type_params.is_some() {
-            // Load .type_params from the type params scope
-            let dot_type_params = self.name(".type_params");
-            emit!(self, Instruction::LoadNameAny(dot_type_params));
-            func_flags |= bytecode::MakeFunctionFlags::TYPE_PARAMS;
-        }
-
-        if self.build_closure(&code) {
-            func_flags |= bytecode::MakeFunctionFlags::CLOSURE;
-        }
-
-        self.emit_load_const(ConstantData::Code {
-            code: Box::new(code),
-        });
-        self.emit_load_const(ConstantData::Str { value: name.into() });
-
-        // Turn code object into function object:
-        emit!(self, Instruction::MakeFunction(func_flags));
-
-        self.emit_load_const(ConstantData::Str { value: name.into() });
-
-        // For PEP 695 classes: handle Generic base creation
-        if type_params.is_some() {
-            if let Some(arguments) = arguments {
-                // Has explicit bases - use them as is, don't add Generic
-                // CPython doesn't add Generic when explicit bases are present
-                let call = self.compile_call_inner(2, arguments)?;
-                self.compile_normal_call(call);
-            } else {
-                // No explicit bases, add Generic[*type_params] as the only base
-                // Stack currently: [function, class_name]
-
-                // Load .type_params for creating Generic base
-                let dot_type_params = self.name(".type_params");
-                emit!(self, Instruction::LoadNameAny(dot_type_params));
-
-                // Call INTRINSIC_SUBSCRIPT_GENERIC to create Generic[*type_params]
-                emit!(
-                    self,
-                    Instruction::CallIntrinsic1 {
-                        func: bytecode::IntrinsicFunction1::SubscriptGeneric
-                    }
-                );
-
-                // Call __build_class__ with 3 positional args: function, class_name, Generic[T]
-                emit!(self, Instruction::CallFunctionPositional { nargs: 3 });
-            }
-        } else {
-            // No type params, normal compilation
-            let call = if let Some(arguments) = arguments {
-                self.compile_call_inner(2, arguments)?
-            } else {
-                CallType::Positional { nargs: 2 }
-            };
-            self.compile_normal_call(call);
-        }
-
-        // Pop the special type params symbol table
-        if type_params.is_some() {
-            self.pop_symbol_table();
-        }
-
-        self.apply_decorators(decorator_list);
-
-        self.store_name(name)
-    }
-
-    fn load_docstring(&mut self, doc_str: Option<String>) {
-        // TODO: __doc__ must be default None and no bytecode unless it is Some
-        // Duplicate top of stack (the function or class object)
-
-        // Doc string value:
-        self.emit_load_const(match doc_str {
-            Some(doc) => ConstantData::Str { value: doc.into() },
-            None => ConstantData::None, // set docstring None if not declared
-        });
-    }
-
-    fn compile_while(&mut self, test: &Expr, body: &[Stmt], orelse: &[Stmt]) -> CompileResult<()> {
-        let while_block = self.new_block();
-        let else_block = self.new_block();
-        let after_block = self.new_block();
-
-        emit!(self, Instruction::SetupLoop);
-        self.switch_to_block(while_block);
-
-        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,
-            Instruction::Jump {
-                target: while_block,
-            }
-        );
-        self.switch_to_block(else_block);
-        emit!(self, Instruction::PopBlock);
-        self.compile_statements(orelse)?;
-        self.switch_to_block(after_block);
-        Ok(())
-    }
-
-    fn compile_with(
-        &mut self,
-        items: &[WithItem],
-        body: &[Stmt],
-        is_async: bool,
-    ) -> CompileResult<()> {
-        let with_range = self.current_source_range;
-
-        let Some((item, items)) = items.split_first() else {
-            return Err(self.error(CodegenErrorType::EmptyWithItems));
-        };
-
-        let final_block = {
-            let final_block = self.new_block();
-            self.compile_expression(&item.context_expr)?;
-
-            self.set_source_range(with_range);
-            if is_async {
-                emit!(self, Instruction::BeforeAsyncWith);
-                emit!(self, Instruction::GetAwaitable);
-                self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                emit!(self, Instruction::SetupAsyncWith { end: final_block });
-            } else {
-                emit!(self, Instruction::SetupWith { end: final_block });
-            }
-
-            match &item.optional_vars {
-                Some(var) => {
-                    self.set_source_range(var.range());
-                    self.compile_store(var)?;
-                }
-                None => {
-                    emit!(self, Instruction::Pop);
-                }
-            }
-            final_block
-        };
-
-        if items.is_empty() {
-            if body.is_empty() {
-                return Err(self.error(CodegenErrorType::EmptyWithBody));
-            }
-            self.compile_statements(body)?;
-        } else {
-            self.set_source_range(with_range);
-            self.compile_with(items, body, is_async)?;
-        }
-
-        // sort of "stack up" the layers of with blocks:
-        // with a, b: body -> start_with(a) start_with(b) body() end_with(b) end_with(a)
-        self.set_source_range(with_range);
-        emit!(self, Instruction::PopBlock);
-
-        emit!(self, Instruction::EnterFinally);
-
-        self.switch_to_block(final_block);
-        emit!(self, Instruction::WithCleanupStart);
-
-        if is_async {
-            emit!(self, Instruction::GetAwaitable);
-            self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
-        }
-
-        emit!(self, Instruction::WithCleanupFinish);
-
-        Ok(())
-    }
-
-    fn compile_for(
-        &mut self,
-        target: &Expr,
-        iter: &Expr,
-        body: &[Stmt],
-        orelse: &[Stmt],
-        is_async: bool,
-    ) -> CompileResult<()> {
-        // Start loop
-        let for_block = self.new_block();
-        let else_block = self.new_block();
-        let after_block = self.new_block();
-
-        emit!(self, Instruction::SetupLoop);
-
-        // The thing iterated:
-        self.compile_expression(iter)?;
-
-        if is_async {
-            emit!(self, Instruction::GetAIter);
-
-            self.switch_to_block(for_block);
-            emit!(
-                self,
-                Instruction::SetupExcept {
-                    handler: else_block,
-                }
-            );
-            emit!(self, Instruction::GetANext);
-            self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
-            self.compile_store(target)?;
-            emit!(self, Instruction::PopBlock);
-        } else {
-            // Retrieve Iterator
-            emit!(self, Instruction::GetIter);
-
-            self.switch_to_block(for_block);
-            emit!(self, Instruction::ForIter { target: else_block });
-
-            // Start of loop iteration, set targets:
-            self.compile_store(target)?;
-        };
-
-        let was_in_loop = self.ctx.loop_data.replace((for_block, after_block));
-        self.compile_statements(body)?;
-        self.ctx.loop_data = was_in_loop;
-        emit!(self, Instruction::Jump { target: for_block });
-
-        self.switch_to_block(else_block);
-        if is_async {
-            emit!(self, Instruction::EndAsyncFor);
-        }
-        emit!(self, Instruction::PopBlock);
-        self.compile_statements(orelse)?;
-
-        self.switch_to_block(after_block);
-
-        Ok(())
-    }
-
-    fn forbidden_name(&mut self, name: &str, ctx: NameUsage) -> CompileResult<bool> {
-        if ctx == NameUsage::Store && name == "__debug__" {
-            return Err(self.error(CodegenErrorType::Assign("__debug__")));
-            // return Ok(true);
-        }
-        if ctx == NameUsage::Delete && name == "__debug__" {
-            return Err(self.error(CodegenErrorType::Delete("__debug__")));
-            // return Ok(true);
-        }
-        Ok(false)
-    }
-
-    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:?}");
-    }
-
-    /// Ensures that `pc.fail_pop` has at least `n + 1` entries.
-    /// If not, new labels are generated and pushed until the required size is reached.
-    fn ensure_fail_pop(&mut self, pc: &mut PatternContext, n: usize) -> CompileResult<()> {
-        let required_size = n + 1;
-        if required_size <= pc.fail_pop.len() {
-            return Ok(());
-        }
-        while pc.fail_pop.len() < required_size {
-            let new_block = self.new_block();
-            pc.fail_pop.push(new_block);
-        }
-        Ok(())
-    }
-
-    fn jump_to_fail_pop(&mut self, pc: &mut PatternContext, op: JumpOp) -> CompileResult<()> {
-        // Compute the total number of items to pop:
-        // items on top plus the captured objects.
-        let pops = pc.on_top + pc.stores.len();
-        // Ensure that the fail_pop vector has at least `pops + 1` elements.
-        self.ensure_fail_pop(pc, pops)?;
-        // Emit a jump using the jump target stored at index `pops`.
-        match op {
-            JumpOp::Jump => {
-                emit!(
-                    self,
-                    Instruction::Jump {
-                        target: pc.fail_pop[pops]
-                    }
-                );
-            }
-            JumpOp::PopJumpIfFalse => {
-                emit!(
-                    self,
-                    Instruction::JumpIfFalse {
-                        target: pc.fail_pop[pops]
-                    }
-                );
-            }
-        }
-        Ok(())
-    }
-
-    /// Emits the necessary POP instructions for all failure targets in the pattern context,
-    /// then resets the fail_pop vector.
-    fn emit_and_reset_fail_pop(&mut self, pc: &mut PatternContext) -> CompileResult<()> {
-        // If the fail_pop vector is empty, nothing needs to be done.
-        if pc.fail_pop.is_empty() {
-            debug_assert!(pc.fail_pop.is_empty());
-            return Ok(());
-        }
-        // Iterate over the fail_pop vector in reverse order, skipping the first label.
-        for &label in pc.fail_pop.iter().skip(1).rev() {
-            self.switch_to_block(label);
-            // Emit the POP instruction.
-            emit!(self, Instruction::Pop);
-        }
-        // Finally, use the first label.
-        self.switch_to_block(pc.fail_pop[0]);
-        pc.fail_pop.clear();
-        // Free the memory used by the vector.
-        pc.fail_pop.shrink_to_fit();
-        Ok(())
-    }
-
-    /// Duplicate the effect of Python 3.10's ROT_* instructions using SWAPs.
-    fn pattern_helper_rotate(&mut self, mut count: usize) -> CompileResult<()> {
-        while count > 1 {
-            // Emit a SWAP instruction with the current count.
-            emit!(
-                self,
-                Instruction::Swap {
-                    index: u32::try_from(count).unwrap()
-                }
-            );
-            count -= 1;
-        }
-        Ok(())
-    }
-
-    /// Helper to store a captured name for a star pattern.
-    ///
-    /// If `n` is `None`, it emits a POP_TOP instruction. Otherwise, it first
-    /// checks that the name is allowed and not already stored. Then it rotates
-    /// the object on the stack beneath any preserved items and appends the name
-    /// to the list of captured names.
-    fn pattern_helper_store_name(
-        &mut self,
-        n: Option<&Identifier>,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        match n {
-            // If no name is provided, simply pop the top of the stack.
-            None => {
-                emit!(self, Instruction::Pop);
-                Ok(())
-            }
-            Some(name) => {
-                // Check if the name is forbidden for storing.
-                if self.forbidden_name(name.as_str(), NameUsage::Store)? {
-                    return Err(self.compile_error_forbidden_name(name.as_str()));
-                }
-
-                // Ensure we don't store the same name twice.
-                // TODO: maybe pc.stores should be a set?
-                if pc.stores.contains(&name.to_string()) {
-                    return Err(
-                        self.error(CodegenErrorType::DuplicateStore(name.as_str().to_string()))
-                    );
-                }
-
-                // Calculate how many items to rotate:
-                let rotations = pc.on_top + pc.stores.len() + 1;
-                self.pattern_helper_rotate(rotations)?;
-
-                // Append the name to the captured stores.
-                pc.stores.push(name.to_string());
-                Ok(())
-            }
-        }
-    }
-
-    fn pattern_unpack_helper(&mut self, elts: &[Pattern]) -> CompileResult<()> {
-        let n = elts.len();
-        let mut seen_star = false;
-        for (i, elt) in elts.iter().enumerate() {
-            if elt.is_match_star() {
-                if !seen_star {
-                    if i >= (1 << 8) || (n - i - 1) >= ((i32::MAX as usize) >> 8) {
-                        todo!();
-                        // return self.compiler_error(loc, "too many expressions in star-unpacking sequence pattern");
-                    }
-                    let args = UnpackExArgs {
-                        before: u8::try_from(i).unwrap(),
-                        after: u8::try_from(n - i - 1).unwrap(),
-                    };
-                    emit!(self, Instruction::UnpackEx { args });
-                    seen_star = true;
-                } else {
-                    // TODO: Fix error msg
-                    return Err(self.error(CodegenErrorType::MultipleStarArgs));
-                    // return self.compiler_error(loc, "multiple starred expressions in sequence pattern");
-                }
-            }
-        }
-        if !seen_star {
-            emit!(
-                self,
-                Instruction::UnpackSequence {
-                    size: u32::try_from(n).unwrap()
-                }
-            );
-        }
-        Ok(())
-    }
-
-    fn pattern_helper_sequence_unpack(
-        &mut self,
-        patterns: &[Pattern],
-        _star: Option<usize>,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Unpack the sequence into individual subjects.
-        self.pattern_unpack_helper(patterns)?;
-        let size = patterns.len();
-        // Increase the on_top counter for the newly unpacked subjects.
-        pc.on_top += size;
-        // For each unpacked subject, compile its subpattern.
-        for pattern in patterns {
-            // Decrement on_top for each subject as it is consumed.
-            pc.on_top -= 1;
-            self.compile_pattern_subpattern(pattern, pc)?;
-        }
-        Ok(())
-    }
-
-    fn pattern_helper_sequence_subscr(
-        &mut self,
-        patterns: &[Pattern],
-        star: usize,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Keep the subject around for extracting elements.
-        pc.on_top += 1;
-        for (i, pattern) in patterns.iter().enumerate() {
-            // if pattern.is_wildcard() {
-            // continue;
-            // }
-            if i == star {
-                // This must be a starred wildcard.
-                // assert!(pattern.is_star_wildcard());
-                continue;
-            }
-            // Duplicate the subject.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
-            if i < star {
-                // For indices before the star, use a nonnegative index equal to i.
-                self.emit_load_const(ConstantData::Integer { value: i.into() });
-            } else {
-                // For indices after the star, compute a nonnegative index:
-                // index = len(subject) - (size - i)
-                emit!(self, Instruction::GetLen);
-                self.emit_load_const(ConstantData::Integer {
-                    value: (patterns.len() - 1).into(),
-                });
-                // Subtract to compute the correct index.
-                emit!(
-                    self,
-                    Instruction::BinaryOperation {
-                        op: BinaryOperator::Subtract
-                    }
-                );
-            }
-            // Use BINARY_OP/NB_SUBSCR to extract the element.
-            emit!(self, Instruction::BinarySubscript);
-            // Compile the subpattern in irrefutable mode.
-            self.compile_pattern_subpattern(pattern, pc)?;
-        }
-        // Pop the subject off the stack.
-        pc.on_top -= 1;
-        emit!(self, Instruction::Pop);
-        Ok(())
-    }
-
-    fn compile_pattern_subpattern(
-        &mut self,
-        p: &Pattern,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Save the current allow_irrefutable state.
-        let old_allow_irrefutable = pc.allow_irrefutable;
-        // Temporarily allow irrefutable patterns.
-        pc.allow_irrefutable = true;
-        // Compile the pattern.
-        self.compile_pattern(p, pc)?;
-        // Restore the original state.
-        pc.allow_irrefutable = old_allow_irrefutable;
-        Ok(())
-    }
-
-    fn compile_pattern_as(
-        &mut self,
-        p: &PatternMatchAs,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // If there is no sub-pattern, then it's an irrefutable match.
-        if p.pattern.is_none() {
-            if !pc.allow_irrefutable {
-                if let Some(_name) = p.name.as_ref() {
-                    // TODO: This error message does not match cpython exactly
-                    // A name capture makes subsequent patterns unreachable.
-                    return Err(self.error(CodegenErrorType::UnreachablePattern(
-                        PatternUnreachableReason::NameCapture,
-                    )));
-                } else {
-                    // A wildcard makes remaining patterns unreachable.
-                    return Err(self.error(CodegenErrorType::UnreachablePattern(
-                        PatternUnreachableReason::Wildcard,
-                    )));
-                }
-            }
-            // If irrefutable matches are allowed, store the name (if any).
-            return self.pattern_helper_store_name(p.name.as_ref(), pc);
-        }
-
-        // Otherwise, there is a sub-pattern. Duplicate the object on top of the stack.
-        pc.on_top += 1;
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
-        // Compile the sub-pattern.
-        self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
-        // After success, decrement the on_top counter.
-        pc.on_top -= 1;
-        // Store the captured name (if any).
-        self.pattern_helper_store_name(p.name.as_ref(), pc)?;
-        Ok(())
-    }
-
-    fn compile_pattern_star(
-        &mut self,
-        p: &PatternMatchStar,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        self.pattern_helper_store_name(p.name.as_ref(), pc)?;
-        Ok(())
-    }
-
-    /// Validates that keyword attributes in a class pattern are allowed
-    /// and not duplicated.
-    fn validate_kwd_attrs(
-        &mut self,
-        attrs: &[Identifier],
-        _patterns: &[Pattern],
-    ) -> CompileResult<()> {
-        let n_attrs = attrs.len();
-        for i in 0..n_attrs {
-            let attr = attrs[i].as_str();
-            // Check if the attribute name is forbidden in a Store context.
-            if self.forbidden_name(attr, NameUsage::Store)? {
-                // Return an error if the name is forbidden.
-                return Err(self.compile_error_forbidden_name(attr));
-            }
-            // Check for duplicates: compare with every subsequent attribute.
-            for ident in attrs.iter().take(n_attrs).skip(i + 1) {
-                let other = ident.as_str();
-                if attr == other {
-                    return Err(self.error(CodegenErrorType::RepeatedAttributePattern));
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn compile_pattern_class(
-        &mut self,
-        p: &PatternMatchClass,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Extract components from the MatchClass pattern.
-        let match_class = p;
-        let patterns = &match_class.arguments.patterns;
-
-        // Extract keyword attributes and patterns.
-        // Capacity is pre-allocated based on the number of keyword arguments.
-        let mut kwd_attrs = Vec::with_capacity(match_class.arguments.keywords.len());
-        let mut kwd_patterns = Vec::with_capacity(match_class.arguments.keywords.len());
-        for kwd in &match_class.arguments.keywords {
-            kwd_attrs.push(kwd.attr.clone());
-            kwd_patterns.push(kwd.pattern.clone());
-        }
-
-        let nargs = patterns.len();
-        let n_attrs = kwd_attrs.len();
-
-        // 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);
-        }
-
-        // Validate keyword attributes if any.
-        if n_attrs != 0 {
-            self.validate_kwd_attrs(&kwd_attrs, &kwd_patterns)?;
-        }
-
-        // Compile the class expression.
-        self.compile_expression(&match_class.cls)?;
-
-        // Create a new tuple of attribute names.
-        let mut attr_names = vec![];
-        for name in kwd_attrs.iter() {
-            // Py_NewRef(name) is emulated by cloning the name into a PyObject.
-            attr_names.push(ConstantData::Str {
-                value: name.as_str().to_string().into(),
-            });
-        }
-
-        use bytecode::TestOperator::*;
-
-        // Emit instructions:
-        // 1. Load the new tuple of attribute names.
-        self.emit_load_const(ConstantData::Tuple {
-            elements: attr_names,
-        });
-        // 2. Emit MATCH_CLASS with nargs.
-        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
-        // 3. Duplicate the top of the stack.
-        emit!(self, Instruction::CopyItem { index: 1_u32 });
-        // 4. Load None.
-        self.emit_load_const(ConstantData::None);
-        // 5. Compare with IS_OP 1.
-        emit!(self, Instruction::TestOperation { op: IsNot });
-
-        // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
-        pc.on_top += 1;
-        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-
-        // Unpack the tuple into (nargs + n_attrs) items.
-        let total = nargs + n_attrs;
-        emit!(
-            self,
-            Instruction::UnpackSequence {
-                size: u32::try_from(total).unwrap()
-            }
-        );
-        pc.on_top += total;
-        pc.on_top -= 1;
-
-        // Process each sub-pattern.
-        for subpattern in patterns.iter().chain(kwd_patterns.iter()) {
-            // Decrement the on_top counter as each sub-pattern is processed
-            // (on_top should be zero at the end of the algorithm as a sanity check).
-            pc.on_top -= 1;
-            if subpattern.is_wildcard() {
-                emit!(self, Instruction::Pop);
-            }
-            // Compile the subpattern without irrefutability checks.
-            self.compile_pattern_subpattern(subpattern, pc)?;
-        }
-        Ok(())
-    }
-
-    // fn compile_pattern_mapping(&mut self, p: &PatternMatchMapping, pc: &mut PatternContext) -> CompileResult<()> {
-    //     // Ensure the pattern is a mapping pattern.
-    //     let mapping = p; // Extract MatchMapping-specific data.
-    //     let keys = &mapping.keys;
-    //     let patterns = &mapping.patterns;
-    //     let size = keys.len();
-    //     let n_patterns = patterns.len();
-
-    //     if size != n_patterns {
-    //         panic!("keys ({}) / patterns ({}) length mismatch in mapping pattern", size, n_patterns);
-    //         // return self.compiler_error(
-    //             // &format!("keys ({}) / patterns ({}) length mismatch in mapping pattern", size, n_patterns)
-    //         // );
-    //     }
-
-    //     // A double-star target is present if `rest` is set.
-    //     let star_target = mapping.rest;
-
-    //     // Keep the subject on top during the mapping and length checks.
-    //     pc.on_top += 1;
-    //     emit!(self, Instruction::MatchMapping);
-    //     self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-
-    //     // If the pattern is just "{}" (empty mapping) and there's no star target,
-    //     // we're done—pop the subject.
-    //     if size == 0 && star_target.is_none() {
-    //         pc.on_top -= 1;
-    //         emit!(self, Instruction::Pop);
-    //         return Ok(());
-    //     }
-
-    //     // If there are any keys, perform a length check.
-    //     if size != 0 {
-    //         emit!(self, Instruction::GetLen);
-    //         self.emit_load_const(ConstantData::Integer { value: size.into() });
-    //         emit!(self, Instruction::CompareOperation { op: ComparisonOperator::GreaterOrEqual });
-    //         self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-    //     }
-
-    //     // Check that the number of sub-patterns is not absurd.
-    //     if size.saturating_sub(1) > (i32::MAX as usize) {
-    //         panic!("too many sub-patterns in mapping pattern");
-    //         // return self.compiler_error("too many sub-patterns in mapping pattern");
-    //     }
-
-    //     // Collect all keys into a set for duplicate checking.
-    //     let mut seen = HashSet::new();
-
-    //     // For each key, validate it and check for duplicates.
-    //     for (i, key) in keys.iter().enumerate() {
-    //         if let Some(key_val) = key.as_literal_expr() {
-    //             let in_seen = seen.contains(&key_val);
-    //             if in_seen {
-    //                 panic!("mapping pattern checks duplicate key: {:?}", key_val);
-    //                 // return self.compiler_error(format!("mapping pattern checks duplicate key: {:?}", key_val));
-    //             }
-    //             seen.insert(key_val);
-    //         } else if !key.is_attribute_expr() {
-    //             panic!("mapping pattern keys may only match literals and attribute lookups");
-    //             // return self.compiler_error("mapping pattern keys may only match literals and attribute lookups");
-    //         }
-
-    //         // Visit the key expression.
-    //         self.compile_expression(key)?;
-    //     }
-    //     // Drop the set (its resources will be freed automatically).
-
-    //     // Build a tuple of keys and emit MATCH_KEYS.
-    //     emit!(self, Instruction::BuildTuple { size: size as u32 });
-    //     emit!(self, Instruction::MatchKeys);
-    //     // Now, on top of the subject there are two new tuples: one of keys and one of values.
-    //     pc.on_top += 2;
-
-    //     // Prepare for matching the values.
-    //     emit!(self, Instruction::CopyItem { index: 1_u32 });
-    //     self.emit_load_const(ConstantData::None);
-    //     // TODO: should be is
-    //     emit!(self, Instruction::TestOperation::IsNot);
-    //     self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-
-    //     // Unpack the tuple of values.
-    //     emit!(self, Instruction::UnpackSequence { size: size as u32 });
-    //     pc.on_top += size.saturating_sub(1);
-
-    //     // Compile each subpattern in "subpattern" mode.
-    //     for pattern in patterns {
-    //         pc.on_top = pc.on_top.saturating_sub(1);
-    //         self.compile_pattern_subpattern(pattern, pc)?;
-    //     }
-
-    //     // Consume the tuple of keys and the subject.
-    //     pc.on_top = pc.on_top.saturating_sub(2);
-    //     if let Some(star_target) = star_target {
-    //         // If we have a starred name, bind a dict of remaining items to it.
-    //         // This sequence of instructions performs:
-    //         //   rest = dict(subject)
-    //         //   for key in keys: del rest[key]
-    //         emit!(self, Instruction::BuildMap { size: 0 });           // Build an empty dict.
-    //         emit!(self, Instruction::Swap(3));                        // Rearrange stack: [empty, keys, subject]
-    //         emit!(self, Instruction::DictUpdate { size: 2 });         // Update dict with subject.
-    //         emit!(self, Instruction::UnpackSequence { size: size as u32 }); // Unpack keys.
-    //         let mut remaining = size;
-    //         while remaining > 0 {
-    //             emit!(self, Instruction::CopyItem { index: 1 + remaining as u32 }); // Duplicate subject copy.
-    //             emit!(self, Instruction::Swap { index: 2_u32 });                    // Bring key to top.
-    //             emit!(self, Instruction::DeleteSubscript);              // Delete key from dict.
-    //             remaining -= 1;
-    //         }
-    //         // Bind the dict to the starred target.
-    //         self.pattern_helper_store_name(Some(&star_target), pc)?;
-    //     } else {
-    //         // No starred target: just pop the tuple of keys and the subject.
-    //         emit!(self, Instruction::Pop);
-    //         emit!(self, Instruction::Pop);
-    //     }
-    //     Ok(())
-    // }
-
-    fn compile_pattern_or(
-        &mut self,
-        p: &PatternMatchOr,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // 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");
-
-        // Save the current pattern context.
-        let old_pc = pc.clone();
-        // Simulate Py_INCREF on pc.stores by cloning it.
-        pc.stores = pc.stores.clone();
-        let mut control: Option<Vec<String>> = None; // Will hold the capture list of the first alternative.
-
-        // Process each alternative.
-        for (i, alt) in p.patterns.iter().enumerate() {
-            // Create a fresh empty store for this alternative.
-            pc.stores = Vec::new();
-            // An irrefutable subpattern must be last (if allowed).
-            pc.allow_irrefutable = (i == size - 1) && old_pc.allow_irrefutable;
-            // Reset failure targets and the on_top counter.
-            pc.fail_pop.clear();
-            pc.on_top = 0;
-            // Emit a COPY(1) instruction before compiling the alternative.
-            emit!(self, Instruction::CopyItem { index: 1_u32 });
-            self.compile_pattern(alt, pc)?;
-
-            let n_stores = pc.stores.len();
-            if i == 0 {
-                // Save the captured names from the first alternative.
-                control = Some(pc.stores.clone());
-            } else {
-                let control_vec = control.as_ref().unwrap();
-                if n_stores != control_vec.len() {
-                    return Err(self.error(CodegenErrorType::ConflictingNameBindPattern));
-                } else if n_stores > 0 {
-                    // Check that the names occur in the same order.
-                    for i_control in (0..n_stores).rev() {
-                        let name = &control_vec[i_control];
-                        // Find the index of `name` in the current stores.
-                        let i_stores =
-                            pc.stores.iter().position(|n| n == name).ok_or_else(|| {
-                                self.error(CodegenErrorType::ConflictingNameBindPattern)
-                            })?;
-                        if i_control != i_stores {
-                            // The orders differ; we must reorder.
-                            assert!(i_stores < i_control, "expected i_stores < i_control");
-                            let rotations = i_stores + 1;
-                            // Rotate pc.stores: take a slice of the first `rotations` items...
-                            let rotated = pc.stores[0..rotations].to_vec();
-                            // Remove those elements.
-                            for _ in 0..rotations {
-                                pc.stores.remove(0);
-                            }
-                            // Insert the rotated slice at the appropriate index.
-                            let insert_pos = i_control - i_stores;
-                            for (j, elem) in rotated.into_iter().enumerate() {
-                                pc.stores.insert(insert_pos + j, elem);
-                            }
-                            // Also perform the same rotation on the evaluation stack.
-                            for _ in 0..(i_stores + 1) {
-                                self.pattern_helper_rotate(i_control + 1)?;
-                            }
-                        }
-                    }
-                }
-            }
-            // Emit a jump to the common end label and reset any failure jump targets.
-            emit!(self, Instruction::Jump { target: end });
-            self.emit_and_reset_fail_pop(pc)?;
-        }
-
-        // Restore the original pattern context.
-        *pc = old_pc.clone();
-        // Simulate Py_INCREF on pc.stores.
-        pc.stores = pc.stores.clone();
-        // In C, old_pc.fail_pop is set to NULL to avoid freeing it later.
-        // In Rust, old_pc is a local clone, so we need not worry about that.
-
-        // No alternative matched: pop the subject and fail.
-        emit!(self, Instruction::Pop);
-        self.jump_to_fail_pop(pc, JumpOp::Jump)?;
-
-        // Use the label "end".
-        self.switch_to_block(end);
-
-        // Adjust the final captures.
-        let n_stores = control.as_ref().unwrap().len();
-        let n_rots = n_stores + 1 + pc.on_top + pc.stores.len();
-        for i in 0..n_stores {
-            // Rotate the capture to its proper place.
-            self.pattern_helper_rotate(n_rots)?;
-            let name = &control.as_ref().unwrap()[i];
-            // Check for duplicate binding.
-            if pc.stores.contains(name) {
-                return Err(self.error(CodegenErrorType::DuplicateStore(name.to_string())));
-            }
-            pc.stores.push(name.clone());
-        }
-
-        // Old context and control will be dropped automatically.
-        // Finally, pop the copy of the subject.
-        emit!(self, Instruction::Pop);
-        Ok(())
-    }
-
-    fn compile_pattern_sequence(
-        &mut self,
-        p: &PatternMatchSequence,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Ensure the pattern is a MatchSequence.
-        let patterns = &p.patterns; // a slice of Pattern
-        let size = patterns.len();
-        let mut star: Option<usize> = None;
-        let mut only_wildcard = true;
-        let mut star_wildcard = false;
-
-        // Find a starred pattern, if it exists. There may be at most one.
-        for (i, pattern) in patterns.iter().enumerate() {
-            if pattern.is_match_star() {
-                if star.is_some() {
-                    // TODO: Fix error msg
-                    return Err(self.error(CodegenErrorType::MultipleStarArgs));
-                }
-                // star wildcard check
-                star_wildcard = pattern
-                    .as_match_star()
-                    .map(|m| m.name.is_none())
-                    .unwrap_or(false);
-                only_wildcard &= star_wildcard;
-                star = Some(i);
-                continue;
-            }
-            // wildcard check
-            only_wildcard &= pattern
-                .as_match_as()
-                .map(|m| m.name.is_none())
-                .unwrap_or(false);
-        }
-
-        // Keep the subject on top during the sequence and length checks.
-        pc.on_top += 1;
-        emit!(self, Instruction::MatchSequence);
-        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-
-        if star.is_none() {
-            // No star: len(subject) == size
-            emit!(self, Instruction::GetLen);
-            self.emit_load_const(ConstantData::Integer { value: size.into() });
-            emit!(
-                self,
-                Instruction::CompareOperation {
-                    op: ComparisonOperator::Equal
-                }
-            );
-            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-        } else if size > 1 {
-            // Star exists: len(subject) >= size - 1
-            emit!(self, Instruction::GetLen);
-            self.emit_load_const(ConstantData::Integer {
-                value: (size - 1).into(),
-            });
-            emit!(
-                self,
-                Instruction::CompareOperation {
-                    op: ComparisonOperator::GreaterOrEqual
-                }
-            );
-            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-        }
-
-        // Whatever comes next should consume the subject.
-        pc.on_top -= 1;
-        if only_wildcard {
-            // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
-            emit!(self, Instruction::Pop);
-        } else if star_wildcard {
-            self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
-        } else {
-            self.pattern_helper_sequence_unpack(patterns, star, pc)?;
-        }
-        Ok(())
-    }
-
-    fn compile_pattern_value(
-        &mut self,
-        p: &PatternMatchValue,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // TODO: ensure literal or attribute lookup
-        self.compile_expression(&p.value)?;
-        emit!(
-            self,
-            Instruction::CompareOperation {
-                op: bytecode::ComparisonOperator::Equal
-            }
-        );
-        // emit!(self, Instruction::ToBool);
-        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-        Ok(())
-    }
-
-    fn compile_pattern_singleton(
-        &mut self,
-        p: &PatternMatchSingleton,
-        pc: &mut PatternContext,
-    ) -> CompileResult<()> {
-        // Load the singleton constant value.
-        self.emit_load_const(match p.value {
-            Singleton::None => ConstantData::None,
-            Singleton::False => ConstantData::Boolean { value: false },
-            Singleton::True => ConstantData::Boolean { value: true },
-        });
-        // Compare using the "Is" operator.
-        emit!(
-            self,
-            Instruction::CompareOperation {
-                op: bytecode::ComparisonOperator::Equal
-            }
-        );
-        // Jump to the failure label if the comparison is false.
-        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
-        Ok(())
-    }
-
-    fn compile_pattern(
-        &mut self,
-        pattern_type: &Pattern,
-        pattern_context: &mut PatternContext,
-    ) -> CompileResult<()> {
-        match &pattern_type {
-            Pattern::MatchValue(pattern_type) => {
-                self.compile_pattern_value(pattern_type, pattern_context)
-            }
-            Pattern::MatchSingleton(pattern_type) => {
-                self.compile_pattern_singleton(pattern_type, pattern_context)
-            }
-            Pattern::MatchSequence(pattern_type) => {
-                self.compile_pattern_sequence(pattern_type, pattern_context)
-            }
-            // Pattern::MatchMapping(pattern_type) => self.compile_pattern_mapping(pattern_type, pattern_context),
-            Pattern::MatchClass(pattern_type) => {
-                self.compile_pattern_class(pattern_type, pattern_context)
-            }
-            Pattern::MatchStar(pattern_type) => {
-                self.compile_pattern_star(pattern_type, pattern_context)
-            }
-            Pattern::MatchAs(pattern_type) => {
-                self.compile_pattern_as(pattern_type, pattern_context)
-            }
-            Pattern::MatchOr(pattern_type) => {
-                self.compile_pattern_or(pattern_type, pattern_context)
-            }
-            _ => {
-                // The eprintln gives context as to which pattern type is not implemented.
-                eprintln!("not implemented pattern type: {pattern_type:?}");
-                Err(self.error(CodegenErrorType::NotImplementedYet))
-            }
-        }
-    }
-
-    fn compile_match_inner(
-        &mut self,
-        subject: &Expr,
-        cases: &[MatchCase],
-        pattern_context: &mut PatternContext,
-    ) -> CompileResult<()> {
-        self.compile_expression(subject)?;
-        let end = self.new_block();
-
-        let num_cases = cases.len();
-        assert!(num_cases > 0);
-        let has_default = cases.iter().last().unwrap().pattern.is_match_star() && num_cases > 1;
-
-        let case_count = num_cases - if has_default { 1 } else { 0 };
-        for (i, m) in cases.iter().enumerate().take(case_count) {
-            // Only copy the subject if not on the last case
-            if i != case_count - 1 {
-                emit!(self, Instruction::CopyItem { index: 1_u32 });
-            }
-
-            pattern_context.stores = Vec::with_capacity(1);
-            pattern_context.allow_irrefutable = m.guard.is_some() || i == case_count - 1;
-            pattern_context.fail_pop.clear();
-            pattern_context.on_top = 0;
-
-            self.compile_pattern(&m.pattern, pattern_context)?;
-            assert_eq!(pattern_context.on_top, 0);
-
-            for name in &pattern_context.stores {
-                self.compile_name(name, NameUsage::Store)?;
-            }
-
-            if let Some(ref _guard) = m.guard {
-                self.ensure_fail_pop(pattern_context, 0)?;
-                // TODO: Fix compile jump if call
-                return Err(self.error(CodegenErrorType::NotImplementedYet));
-                // Jump if the guard fails. We assume that patter_context.fail_pop[0] is the jump target.
-                // self.compile_jump_if(&m.pattern, &guard, pattern_context.fail_pop[0])?;
-            }
-
-            if i != case_count - 1 {
-                emit!(self, Instruction::Pop);
-            }
-
-            self.compile_statements(&m.body)?;
-            emit!(self, Instruction::Jump { target: end });
-            self.emit_and_reset_fail_pop(pattern_context)?;
-        }
-
-        if has_default {
-            let m = &cases[num_cases - 1];
-            if num_cases == 1 {
-                emit!(self, Instruction::Pop);
-            } else {
-                emit!(self, Instruction::Nop);
-            }
-            if let Some(ref _guard) = m.guard {
-                // TODO: Fix compile jump if call
-                return Err(self.error(CodegenErrorType::NotImplementedYet));
-            }
-            self.compile_statements(&m.body)?;
-        }
-        self.switch_to_block(end);
-        Ok(())
-    }
-
-    fn compile_match(&mut self, subject: &Expr, cases: &[MatchCase]) -> CompileResult<()> {
-        let mut pattern_context = PatternContext::new();
-        self.compile_match_inner(subject, cases, &mut pattern_context)?;
-        Ok(())
-    }
-
-    fn compile_chained_comparison(
-        &mut self,
-        left: &Expr,
-        ops: &[CmpOp],
-        exprs: &[Expr],
-    ) -> CompileResult<()> {
-        assert!(!ops.is_empty());
-        assert_eq!(exprs.len(), ops.len());
-        let (last_op, mid_ops) = ops.split_last().unwrap();
-        let (last_val, mid_exprs) = exprs.split_last().unwrap();
-
-        use bytecode::ComparisonOperator::*;
-        use bytecode::TestOperator::*;
-        let compile_cmpop = |c: &mut Self, op: &CmpOp| match op {
-            CmpOp::Eq => emit!(c, Instruction::CompareOperation { op: Equal }),
-            CmpOp::NotEq => emit!(c, Instruction::CompareOperation { op: NotEqual }),
-            CmpOp::Lt => emit!(c, Instruction::CompareOperation { op: Less }),
-            CmpOp::LtE => emit!(c, Instruction::CompareOperation { op: LessOrEqual }),
-            CmpOp::Gt => emit!(c, Instruction::CompareOperation { op: Greater }),
-            CmpOp::GtE => {
-                emit!(c, Instruction::CompareOperation { op: GreaterOrEqual })
-            }
-            CmpOp::In => emit!(c, Instruction::TestOperation { op: In }),
-            CmpOp::NotIn => emit!(c, Instruction::TestOperation { op: NotIn }),
-            CmpOp::Is => emit!(c, Instruction::TestOperation { op: Is }),
-            CmpOp::IsNot => emit!(c, Instruction::TestOperation { op: IsNot }),
-        };
-
-        // a == b == c == d
-        // compile into (pseudo code):
-        // result = a == b
-        // if result:
-        //   result = b == c
-        //   if result:
-        //     result = c == d
-
-        // initialize lhs outside of loop
-        self.compile_expression(left)?;
-
-        let end_blocks = if mid_exprs.is_empty() {
-            None
-        } else {
-            let break_block = self.new_block();
-            let after_block = self.new_block();
-            Some((break_block, after_block))
-        };
-
-        // for all comparisons except the last (as the last one doesn't need a conditional jump)
-        for (op, val) in mid_ops.iter().zip(mid_exprs) {
-            self.compile_expression(val)?;
-            // store rhs for the next comparison in chain
-            emit!(self, Instruction::Duplicate);
-            emit!(self, Instruction::Rotate3);
-
-            compile_cmpop(self, op);
-
-            // if comparison result is false, we break with this value; if true, try the next one.
-            if let Some((break_block, _)) = end_blocks {
-                emit!(
-                    self,
-                    Instruction::JumpIfFalseOrPop {
-                        target: break_block,
-                    }
-                );
-            }
-        }
-
-        // handle the last comparison
-        self.compile_expression(last_val)?;
-        compile_cmpop(self, last_op);
-
-        if let Some((break_block, after_block)) = end_blocks {
-            emit!(
-                self,
-                Instruction::Jump {
-                    target: after_block,
-                }
-            );
-
-            // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
-            self.switch_to_block(break_block);
-            emit!(self, Instruction::Rotate2);
-            emit!(self, Instruction::Pop);
-
-            self.switch_to_block(after_block);
-        }
-
-        Ok(())
-    }
-
-    fn compile_annotation(&mut self, annotation: &Expr) -> CompileResult<()> {
-        if self.future_annotations {
-            self.emit_load_const(ConstantData::Str {
-                value: unparse_expr(annotation, &self.source_code)
-                    .to_string()
-                    .into(),
-            });
-        } else {
-            let was_in_annotation = self.in_annotation;
-            self.in_annotation = true;
-
-            // Special handling for starred annotations (*Ts -> Unpack[Ts])
-            let result = match annotation {
-                Expr::Starred(ExprStarred { value, .. }) => {
-                    // Following CPython's approach:
-                    // *args: *Ts (where Ts is a TypeVarTuple).
-                    // Do [annotation_value] = [*Ts].
-                    self.compile_expression(value)?;
-                    emit!(self, Instruction::UnpackSequence { size: 1 });
-                    Ok(())
-                }
-                _ => self.compile_expression(annotation),
-            };
-
-            self.in_annotation = was_in_annotation;
-            result?;
-        }
-        Ok(())
-    }
-
-    fn compile_annotated_assign(
-        &mut self,
-        target: &Expr,
-        annotation: &Expr,
-        value: Option<&Expr>,
-    ) -> CompileResult<()> {
-        if let Some(value) = value {
-            self.compile_expression(value)?;
-            self.compile_store(target)?;
-        }
-
-        // Annotations are only evaluated in a module or class.
-        if self.ctx.in_func() {
-            return Ok(());
-        }
-
-        // Compile annotation:
-        self.compile_annotation(annotation)?;
-
-        if let Expr::Name(ExprName { id, .. }) = &target {
-            // Store as dict entry in __annotations__ dict:
-            let annotations = self.name("__annotations__");
-            emit!(self, Instruction::LoadNameAny(annotations));
-            self.emit_load_const(ConstantData::Str {
-                value: self.mangle(id.as_str()).into_owned().into(),
-            });
-            emit!(self, Instruction::StoreSubscript);
-        } else {
-            // Drop annotation if not assigned to simple identifier.
-            emit!(self, Instruction::Pop);
-        }
-
-        Ok(())
-    }
-
-    fn compile_store(&mut self, target: &Expr) -> CompileResult<()> {
-        match &target {
-            Expr::Name(ExprName { id, .. }) => self.store_name(id.as_str())?,
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                self.compile_expression(value)?;
-                self.compile_expression(slice)?;
-                emit!(self, Instruction::StoreSubscript);
-            }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
-                self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::StoreAttr { idx });
-            }
-            Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
-                let mut seen_star = false;
-
-                // Scan for star args:
-                for (i, element) in elts.iter().enumerate() {
-                    if let Expr::Starred(_) = &element {
-                        if seen_star {
-                            return Err(self.error(CodegenErrorType::MultipleStarArgs));
-                        } else {
-                            seen_star = true;
-                            let before = i;
-                            let after = elts.len() - i - 1;
-                            let (before, after) = (|| Some((before.to_u8()?, after.to_u8()?)))()
-                                .ok_or_else(|| {
-                                    self.error_ranged(
-                                        CodegenErrorType::TooManyStarUnpack,
-                                        target.range(),
-                                    )
-                                })?;
-                            let args = bytecode::UnpackExArgs { before, after };
-                            emit!(self, Instruction::UnpackEx { args });
-                        }
-                    }
-                }
-
-                if !seen_star {
-                    emit!(
-                        self,
-                        Instruction::UnpackSequence {
-                            size: elts.len().to_u32(),
-                        }
-                    );
-                }
-
-                for element in elts {
-                    if let Expr::Starred(ExprStarred { value, .. }) = &element {
-                        self.compile_store(value)?;
-                    } else {
-                        self.compile_store(element)?;
-                    }
-                }
-            }
-            _ => {
-                return Err(self.error(match target {
-                    Expr::Starred(_) => CodegenErrorType::SyntaxError(
-                        "starred assignment target must be in a list or tuple".to_owned(),
-                    ),
-                    _ => CodegenErrorType::Assign(target.python_name()),
-                }));
-            }
-        }
-
-        Ok(())
-    }
-
-    fn compile_augassign(
-        &mut self,
-        target: &Expr,
-        op: &Operator,
-        value: &Expr,
-    ) -> CompileResult<()> {
-        enum AugAssignKind<'a> {
-            Name { id: &'a str },
-            Subscript,
-            Attr { idx: bytecode::NameIdx },
-        }
-
-        let kind = match &target {
-            Expr::Name(ExprName { id, .. }) => {
-                let id = id.as_str();
-                self.compile_name(id, NameUsage::Load)?;
-                AugAssignKind::Name { id }
-            }
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                self.compile_expression(value)?;
-                self.compile_expression(slice)?;
-                emit!(self, Instruction::Duplicate2);
-                emit!(self, Instruction::Subscript);
-                AugAssignKind::Subscript
-            }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                let attr = attr.as_str();
-                self.check_forbidden_name(attr, NameUsage::Store)?;
-                self.compile_expression(value)?;
-                emit!(self, Instruction::Duplicate);
-                let idx = self.name(attr);
-                emit!(self, Instruction::LoadAttr { idx });
-                AugAssignKind::Attr { idx }
-            }
-            _ => {
-                return Err(self.error(CodegenErrorType::Assign(target.python_name())));
-            }
-        };
-
-        self.compile_expression(value)?;
-        self.compile_op(op, true);
-
-        match kind {
-            AugAssignKind::Name { id } => {
-                // stack: RESULT
-                self.compile_name(id, NameUsage::Store)?;
-            }
-            AugAssignKind::Subscript => {
-                // stack: CONTAINER SLICE RESULT
-                emit!(self, Instruction::Rotate3);
-                emit!(self, Instruction::StoreSubscript);
-            }
-            AugAssignKind::Attr { idx } => {
-                // stack: CONTAINER RESULT
-                emit!(self, Instruction::Rotate2);
-                emit!(self, Instruction::StoreAttr { idx });
-            }
-        }
-
-        Ok(())
-    }
-
-    fn compile_op(&mut self, op: &Operator, inplace: bool) {
-        let op = match op {
-            Operator::Add => bytecode::BinaryOperator::Add,
-            Operator::Sub => bytecode::BinaryOperator::Subtract,
-            Operator::Mult => bytecode::BinaryOperator::Multiply,
-            Operator::MatMult => bytecode::BinaryOperator::MatrixMultiply,
-            Operator::Div => bytecode::BinaryOperator::Divide,
-            Operator::FloorDiv => bytecode::BinaryOperator::FloorDivide,
-            Operator::Mod => bytecode::BinaryOperator::Modulo,
-            Operator::Pow => bytecode::BinaryOperator::Power,
-            Operator::LShift => bytecode::BinaryOperator::Lshift,
-            Operator::RShift => bytecode::BinaryOperator::Rshift,
-            Operator::BitOr => bytecode::BinaryOperator::Or,
-            Operator::BitXor => bytecode::BinaryOperator::Xor,
-            Operator::BitAnd => bytecode::BinaryOperator::And,
-        };
-        if inplace {
-            emit!(self, Instruction::BinaryOperationInplace { op })
-        } else {
-            emit!(self, Instruction::BinaryOperation { op })
-        }
-    }
-
-    /// Implement boolean short circuit evaluation logic.
-    /// https://en.wikipedia.org/wiki/Short-circuit_evaluation
-    ///
-    /// This means, in a boolean statement 'x and y' the variable y will
-    /// not be evaluated when x is false.
-    ///
-    /// The idea is to jump to a label if the expression is either true or false
-    /// (indicated by the condition parameter).
-    fn compile_jump_if(
-        &mut self,
-        expression: &Expr,
-        condition: bool,
-        target_block: ir::BlockIdx,
-    ) -> CompileResult<()> {
-        // Compile expression for test, and jump to label if false
-        match &expression {
-            Expr::BoolOp(ExprBoolOp { op, values, .. }) => {
-                match op {
-                    BoolOp::And => {
-                        if condition {
-                            // If all values are true.
-                            let end_block = self.new_block();
-                            let (last_value, values) = values.split_last().unwrap();
-
-                            // If any of the values is false, we can short-circuit.
-                            for value in values {
-                                self.compile_jump_if(value, false, end_block)?;
-                            }
-
-                            // It depends upon the last value now: will it be true?
-                            self.compile_jump_if(last_value, true, target_block)?;
-                            self.switch_to_block(end_block);
-                        } else {
-                            // If any value is false, the whole condition is false.
-                            for value in values {
-                                self.compile_jump_if(value, false, target_block)?;
-                            }
-                        }
-                    }
-                    BoolOp::Or => {
-                        if condition {
-                            // If any of the values is true.
-                            for value in values {
-                                self.compile_jump_if(value, true, target_block)?;
-                            }
-                        } else {
-                            // If all of the values are false.
-                            let end_block = self.new_block();
-                            let (last_value, values) = values.split_last().unwrap();
-
-                            // If any value is true, we can short-circuit:
-                            for value in values {
-                                self.compile_jump_if(value, true, end_block)?;
-                            }
-
-                            // It all depends upon the last value now!
-                            self.compile_jump_if(last_value, false, target_block)?;
-                            self.switch_to_block(end_block);
-                        }
-                    }
-                }
-            }
-            Expr::UnaryOp(ExprUnaryOp {
-                op: UnaryOp::Not,
-                operand,
-                ..
-            }) => {
-                self.compile_jump_if(operand, !condition, target_block)?;
-            }
-            _ => {
-                // Fall back case which always will work!
-                self.compile_expression(expression)?;
-                if condition {
-                    emit!(
-                        self,
-                        Instruction::JumpIfTrue {
-                            target: target_block,
-                        }
-                    );
-                } else {
-                    emit!(
-                        self,
-                        Instruction::JumpIfFalse {
-                            target: target_block,
-                        }
-                    );
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Compile a boolean operation as an expression.
-    /// This means, that the last value remains on the stack.
-    fn compile_bool_op(&mut self, op: &BoolOp, values: &[Expr]) -> CompileResult<()> {
-        let after_block = self.new_block();
-
-        let (last_value, values) = values.split_last().unwrap();
-        for value in values {
-            self.compile_expression(value)?;
-
-            match op {
-                BoolOp::And => {
-                    emit!(
-                        self,
-                        Instruction::JumpIfFalseOrPop {
-                            target: after_block,
-                        }
-                    );
-                }
-                BoolOp::Or => {
-                    emit!(
-                        self,
-                        Instruction::JumpIfTrueOrPop {
-                            target: after_block,
-                        }
-                    );
-                }
-            }
-        }
-
-        // If all values did not qualify, take the value of the last value:
-        self.compile_expression(last_value)?;
-        self.switch_to_block(after_block);
-        Ok(())
-    }
-
-    fn compile_dict(&mut self, items: &[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;
-        }
-        emit!(self, Instruction::BuildMap { size });
-
-        for item in unpacked {
-            self.compile_expression(&item.value)?;
-            emit!(self, Instruction::DictUpdate);
-        }
-
-        Ok(())
-    }
-
-    fn compile_expression(&mut self, expression: &Expr) -> CompileResult<()> {
-        use ruff_python_ast::*;
-        trace!("Compiling {expression:?}");
-        let range = expression.range();
-        self.set_source_range(range);
-
-        match &expression {
-            Expr::Call(ExprCall {
-                func, arguments, ..
-            }) => self.compile_call(func, arguments)?,
-            Expr::BoolOp(ExprBoolOp { op, values, .. }) => self.compile_bool_op(op, values)?,
-            Expr::BinOp(ExprBinOp {
-                left, op, right, ..
-            }) => {
-                self.compile_expression(left)?;
-                self.compile_expression(right)?;
-
-                // Perform operation:
-                self.compile_op(op, false);
-            }
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                self.compile_expression(value)?;
-                self.compile_expression(slice)?;
-                emit!(self, Instruction::Subscript);
-            }
-            Expr::UnaryOp(ExprUnaryOp { op, operand, .. }) => {
-                self.compile_expression(operand)?;
-
-                // Perform operation:
-                let op = match op {
-                    UnaryOp::UAdd => bytecode::UnaryOperator::Plus,
-                    UnaryOp::USub => bytecode::UnaryOperator::Minus,
-                    UnaryOp::Not => bytecode::UnaryOperator::Not,
-                    UnaryOp::Invert => bytecode::UnaryOperator::Invert,
-                };
-                emit!(self, Instruction::UnaryOperation { op });
-            }
-            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
-                self.compile_expression(value)?;
-                let idx = self.name(attr.as_str());
-                emit!(self, Instruction::LoadAttr { idx });
-            }
-            Expr::Compare(ExprCompare {
-                left,
-                ops,
-                comparators,
-                ..
-            }) => {
-                self.compile_chained_comparison(left, ops, comparators)?;
-            }
-            // Expr::Constant(ExprConstant { value, .. }) => {
-            //     self.emit_load_const(compile_constant(value));
-            // }
-            Expr::List(ExprList { elts, .. }) => {
-                let (size, unpack) = self.gather_elements(0, elts)?;
-                if unpack {
-                    emit!(self, Instruction::BuildListFromTuples { size });
-                } else {
-                    emit!(self, Instruction::BuildList { size });
-                }
-            }
-            Expr::Tuple(ExprTuple { elts, .. }) => {
-                let (size, unpack) = self.gather_elements(0, elts)?;
-                if unpack {
-                    if size > 1 {
-                        emit!(self, Instruction::BuildTupleFromTuples { size });
-                    }
-                } else {
-                    emit!(self, Instruction::BuildTuple { size });
-                }
-            }
-            Expr::Set(ExprSet { elts, .. }) => {
-                let (size, unpack) = self.gather_elements(0, elts)?;
-                if unpack {
-                    emit!(self, Instruction::BuildSetFromTuples { size });
-                } else {
-                    emit!(self, Instruction::BuildSet { size });
-                }
-            }
-            Expr::Dict(ExprDict { items, .. }) => {
-                self.compile_dict(items)?;
-            }
-            Expr::Slice(ExprSlice {
-                lower, upper, step, ..
-            }) => {
-                let mut compile_bound = |bound: Option<&Expr>| match bound {
-                    Some(exp) => self.compile_expression(exp),
-                    None => {
-                        self.emit_load_const(ConstantData::None);
-                        Ok(())
-                    }
-                };
-                compile_bound(lower.as_deref())?;
-                compile_bound(upper.as_deref())?;
-                if let Some(step) = step {
-                    self.compile_expression(step)?;
-                }
-                let step = step.is_some();
-                emit!(self, Instruction::BuildSlice { step });
-            }
-            Expr::Yield(ExprYield { value, .. }) => {
-                if !self.ctx.in_func() {
-                    return Err(self.error(CodegenErrorType::InvalidYield));
-                }
-                self.mark_generator();
-                match value {
-                    Some(expression) => self.compile_expression(expression)?,
-                    Option::None => self.emit_load_const(ConstantData::None),
-                };
-                emit!(self, Instruction::YieldValue);
-            }
-            Expr::Await(ExprAwait { value, .. }) => {
-                if self.ctx.func != FunctionContext::AsyncFunction {
-                    return Err(self.error(CodegenErrorType::InvalidAwait));
-                }
-                self.compile_expression(value)?;
-                emit!(self, Instruction::GetAwaitable);
-                self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-            }
-            Expr::YieldFrom(ExprYieldFrom { value, .. }) => {
-                match self.ctx.func {
-                    FunctionContext::NoFunction => {
-                        return Err(self.error(CodegenErrorType::InvalidYieldFrom));
-                    }
-                    FunctionContext::AsyncFunction => {
-                        return Err(self.error(CodegenErrorType::AsyncYieldFrom));
-                    }
-                    FunctionContext::Function => {}
-                }
-                self.mark_generator();
-                self.compile_expression(value)?;
-                emit!(self, Instruction::GetIter);
-                self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-            }
-            Expr::Name(ExprName { id, .. }) => self.load_name(id.as_str())?,
-            Expr::Lambda(ExprLambda {
-                parameters, body, ..
-            }) => {
-                let prev_ctx = self.ctx;
-
-                let name = "<lambda>".to_owned();
-                let mut func_flags = self
-                    .enter_function(&name, parameters.as_deref().unwrap_or(&Default::default()))?;
-
-                self.ctx = CompileContext {
-                    loop_data: Option::None,
-                    in_class: prev_ctx.in_class,
-                    func: FunctionContext::Function,
-                };
-
-                self.current_code_info()
-                    .constants
-                    .insert_full(ConstantData::None);
-
-                self.compile_expression(body)?;
-                self.emit_return_value();
-                let code = self.pop_code_object();
-                if self.build_closure(&code) {
-                    func_flags |= bytecode::MakeFunctionFlags::CLOSURE;
-                }
-                self.emit_load_const(ConstantData::Code {
-                    code: Box::new(code),
-                });
-                self.emit_load_const(ConstantData::Str { value: name.into() });
-                // Turn code object into function object:
-                emit!(self, Instruction::MakeFunction(func_flags));
-
-                self.ctx = prev_ctx;
-            }
-            Expr::ListComp(ExprListComp {
-                elt, generators, ..
-            }) => {
-                self.compile_comprehension(
-                    "<listcomp>",
-                    Some(Instruction::BuildList {
-                        size: OpArgMarker::marker(),
-                    }),
-                    generators,
-                    &|compiler| {
-                        compiler.compile_comprehension_element(elt)?;
-                        emit!(
-                            compiler,
-                            Instruction::ListAppend {
-                                i: generators.len().to_u32(),
-                            }
-                        );
-                        Ok(())
-                    },
-                    ComprehensionType::List,
-                    Self::contains_await(elt),
-                )?;
-            }
-            Expr::SetComp(ExprSetComp {
-                elt, generators, ..
-            }) => {
-                self.compile_comprehension(
-                    "<setcomp>",
-                    Some(Instruction::BuildSet {
-                        size: OpArgMarker::marker(),
-                    }),
-                    generators,
-                    &|compiler| {
-                        compiler.compile_comprehension_element(elt)?;
-                        emit!(
-                            compiler,
-                            Instruction::SetAdd {
-                                i: generators.len().to_u32(),
-                            }
-                        );
-                        Ok(())
-                    },
-                    ComprehensionType::Set,
-                    Self::contains_await(elt),
-                )?;
-            }
-            Expr::DictComp(ExprDictComp {
-                key,
-                value,
-                generators,
-                ..
-            }) => {
-                self.compile_comprehension(
-                    "<dictcomp>",
-                    Some(Instruction::BuildMap {
-                        size: OpArgMarker::marker(),
-                    }),
-                    generators,
-                    &|compiler| {
-                        // changed evaluation order for Py38 named expression PEP 572
-                        compiler.compile_expression(key)?;
-                        compiler.compile_expression(value)?;
-
-                        emit!(
-                            compiler,
-                            Instruction::MapAdd {
-                                i: generators.len().to_u32(),
-                            }
-                        );
-
-                        Ok(())
-                    },
-                    ComprehensionType::Dict,
-                    Self::contains_await(key) || Self::contains_await(value),
-                )?;
-            }
-            Expr::Generator(ExprGenerator {
-                elt, generators, ..
-            }) => {
-                self.compile_comprehension(
-                    "<genexpr>",
-                    None,
-                    generators,
-                    &|compiler| {
-                        compiler.compile_comprehension_element(elt)?;
-                        compiler.mark_generator();
-                        emit!(compiler, Instruction::YieldValue);
-                        emit!(compiler, Instruction::Pop);
-
-                        Ok(())
-                    },
-                    ComprehensionType::Generator,
-                    Self::contains_await(elt),
-                )?;
-            }
-            Expr::Starred(ExprStarred { value, .. }) => {
-                if self.in_annotation {
-                    // In annotation context, starred expressions are allowed (PEP 646)
-                    // For now, just compile the inner value without wrapping with Unpack
-                    // This is a temporary solution until we figure out how to properly import typing
-                    self.compile_expression(value)?;
-                } else {
-                    return Err(self.error(CodegenErrorType::InvalidStarExpr));
-                }
-            }
-            Expr::If(ExprIf {
-                test, body, orelse, ..
-            }) => {
-                let else_block = self.new_block();
-                let after_block = self.new_block();
-                self.compile_jump_if(test, false, else_block)?;
-
-                // True case
-                self.compile_expression(body)?;
-                emit!(
-                    self,
-                    Instruction::Jump {
-                        target: after_block,
-                    }
-                );
-
-                // False case
-                self.switch_to_block(else_block);
-                self.compile_expression(orelse)?;
-
-                // End
-                self.switch_to_block(after_block);
-            }
-
-            Expr::Named(ExprNamed {
-                target,
-                value,
-                range: _,
-            }) => {
-                self.compile_expression(value)?;
-                emit!(self, Instruction::Duplicate);
-                self.compile_store(target)?;
-            }
-            Expr::FString(fstring) => {
-                self.compile_expr_fstring(fstring)?;
-            }
-            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_code.get_range(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(),
-                    });
-                }
-            }
-            Expr::BytesLiteral(bytes) => {
-                let iter = bytes.value.iter().flat_map(|x| x.iter().copied());
-                let v: Vec<u8> = iter.collect();
-                self.emit_load_const(ConstantData::Bytes { value: v });
-            }
-            Expr::NumberLiteral(number) => match &number.value {
-                Number::Int(int) => {
-                    let value = ruff_int_to_bigint(int).map_err(|e| self.error(e))?;
-                    self.emit_load_const(ConstantData::Integer { value });
-                }
-                Number::Float(float) => {
-                    self.emit_load_const(ConstantData::Float { value: *float });
-                }
-                Number::Complex { real, imag } => {
-                    self.emit_load_const(ConstantData::Complex {
-                        value: Complex::new(*real, *imag),
-                    });
-                }
-            },
-            Expr::BooleanLiteral(b) => {
-                self.emit_load_const(ConstantData::Boolean { value: b.value });
-            }
-            Expr::NoneLiteral(_) => {
-                self.emit_load_const(ConstantData::None);
-            }
-            Expr::EllipsisLiteral(_) => {
-                self.emit_load_const(ConstantData::Ellipsis);
-            }
-            Expr::IpyEscapeCommand(_) => {
-                panic!("unexpected ipy escape command");
-            }
-        }
-        Ok(())
-    }
-
-    fn compile_keywords(&mut self, keywords: &[Keyword]) -> CompileResult<()> {
-        let mut size = 0;
-        let groupby = keywords.iter().chunk_by(|e| e.arg.is_none());
-        for (is_unpacking, sub_keywords) in &groupby {
-            if is_unpacking {
-                for keyword in sub_keywords {
-                    self.compile_expression(&keyword.value)?;
-                    size += 1;
-                }
-            } else {
-                let mut sub_size = 0;
-                for keyword in sub_keywords {
-                    if let Some(name) = &keyword.arg {
-                        self.emit_load_const(ConstantData::Str {
-                            value: name.as_str().into(),
-                        });
-                        self.compile_expression(&keyword.value)?;
-                        sub_size += 1;
-                    }
-                }
-                emit!(self, Instruction::BuildMap { size: sub_size });
-                size += 1;
-            }
-        }
-        if size > 1 {
-            emit!(self, Instruction::BuildMapForCall { size });
-        }
-        Ok(())
-    }
-
-    fn compile_call(&mut self, func: &Expr, args: &Arguments) -> CompileResult<()> {
-        let method = if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
-            self.compile_expression(value)?;
-            let idx = self.name(attr.as_str());
-            emit!(self, Instruction::LoadMethod { idx });
-            true
-        } else {
-            self.compile_expression(func)?;
-            false
-        };
-        let call = self.compile_call_inner(0, args)?;
-        if method {
-            self.compile_method_call(call)
-        } else {
-            self.compile_normal_call(call)
-        }
-        Ok(())
-    }
-
-    fn compile_normal_call(&mut self, ty: CallType) {
-        match ty {
-            CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallFunctionPositional { nargs })
-            }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallFunctionKeyword { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallFunctionEx { has_kwargs }),
-        }
-    }
-    fn compile_method_call(&mut self, ty: CallType) {
-        match ty {
-            CallType::Positional { nargs } => {
-                emit!(self, Instruction::CallMethodPositional { nargs })
-            }
-            CallType::Keyword { nargs } => emit!(self, Instruction::CallMethodKeyword { nargs }),
-            CallType::Ex { has_kwargs } => emit!(self, Instruction::CallMethodEx { has_kwargs }),
-        }
-    }
-
-    fn compile_call_inner(
-        &mut self,
-        additional_positional: u32,
-        arguments: &Arguments,
-    ) -> CompileResult<CallType> {
-        let count = u32::try_from(arguments.len()).unwrap() + additional_positional;
-
-        // Normal arguments:
-        let (size, unpack) = self.gather_elements(additional_positional, &arguments.args)?;
-        let has_double_star = arguments.keywords.iter().any(|k| k.arg.is_none());
-
-        for keyword in &arguments.keywords {
-            if let Some(name) = &keyword.arg {
-                self.check_forbidden_name(name.as_str(), NameUsage::Store)?;
-            }
-        }
-
-        let call = if unpack || has_double_star {
-            // Create a tuple with positional args:
-            if unpack {
-                emit!(self, Instruction::BuildTupleFromTuples { size });
-            } else {
-                emit!(self, Instruction::BuildTuple { size });
-            }
-
-            // Create an optional map with kw-args:
-            let has_kwargs = !arguments.keywords.is_empty();
-            if has_kwargs {
-                self.compile_keywords(&arguments.keywords)?;
-            }
-            CallType::Ex { has_kwargs }
-        } else if !arguments.keywords.is_empty() {
-            let mut kwarg_names = vec![];
-            for keyword in &arguments.keywords {
-                if let Some(name) = &keyword.arg {
-                    kwarg_names.push(ConstantData::Str {
-                        value: name.as_str().into(),
-                    });
-                } else {
-                    // This means **kwargs!
-                    panic!("name must be set");
-                }
-                self.compile_expression(&keyword.value)?;
-            }
-
-            self.emit_load_const(ConstantData::Tuple {
-                elements: kwarg_names,
-            });
-            CallType::Keyword { nargs: count }
-        } else {
-            CallType::Positional { nargs: count }
-        };
-
-        Ok(call)
-    }
-
-    // Given a vector of expr / star expr generate code which gives either
-    // a list of expressions on the stack, or a list of tuples.
-    fn gather_elements(&mut self, before: u32, elements: &[Expr]) -> CompileResult<(u32, bool)> {
-        // First determine if we have starred elements:
-        let has_stars = elements.iter().any(|e| matches!(e, Expr::Starred(_)));
-
-        let size = if has_stars {
-            let mut size = 0;
-            let mut iter = elements.iter().peekable();
-            let mut run_size = before;
-
-            loop {
-                if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
-                    emit!(self, Instruction::BuildTuple { size: run_size });
-                    run_size = 0;
-                    size += 1;
-                }
-
-                match iter.next() {
-                    Some(Expr::Starred(ExprStarred { value, .. })) => {
-                        self.compile_expression(value)?;
-                        // We need to collect each unpacked element into a
-                        // tuple, since any side-effects during the conversion
-                        // should be made visible before evaluating remaining
-                        // expressions.
-                        emit!(self, Instruction::BuildTupleFromIter);
-                        size += 1;
-                    }
-                    Some(element) => {
-                        self.compile_expression(element)?;
-                        run_size += 1;
-                    }
-                    None => break,
-                }
-            }
-
-            size
-        } else {
-            for element in elements {
-                self.compile_expression(element)?;
-            }
-            before + elements.len().to_u32()
-        };
-
-        Ok((size, has_stars))
-    }
-
-    fn compile_comprehension_element(&mut self, element: &Expr) -> CompileResult<()> {
-        self.compile_expression(element).map_err(|e| {
-            if let CodegenErrorType::InvalidStarExpr = e.error {
-                self.error(CodegenErrorType::SyntaxError(
-                    "iterable unpacking cannot be used in comprehension".to_owned(),
-                ))
-            } else {
-                e
-            }
-        })
-    }
-
-    fn compile_comprehension(
-        &mut self,
-        name: &str,
-        init_collection: Option<Instruction>,
-        generators: &[Comprehension],
-        compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
-        comprehension_type: ComprehensionType,
-        element_contains_await: bool,
-    ) -> CompileResult<()> {
-        let prev_ctx = self.ctx;
-        let has_an_async_gen = generators.iter().any(|g| g.is_async);
-
-        // async comprehensions are allowed in various contexts:
-        // - list/set/dict comprehensions in async functions
-        // - always for generator expressions
-        // Note: generators have to be treated specially since their async version is a fundamentally
-        // different type (aiter vs iter) instead of just an awaitable.
-
-        // for if it actually is async, we check if any generator is async or if the element contains await
-
-        // if the element expression contains await, but the context doesn't allow for async,
-        // then we continue on here with is_async=false and will produce a syntax once the await is hit
-
-        let is_async_list_set_dict_comprehension = comprehension_type
-            != ComprehensionType::Generator
-            && (has_an_async_gen || element_contains_await) // does it have to be async? (uses await or async for)
-            && prev_ctx.func == FunctionContext::AsyncFunction; // is it allowed to be async? (in an async function)
-
-        let is_async_generator_comprehension = comprehension_type == ComprehensionType::Generator
-            && (has_an_async_gen || element_contains_await);
-
-        // since one is for generators, and one for not generators, they should never both be true
-        debug_assert!(!(is_async_list_set_dict_comprehension && is_async_generator_comprehension));
-
-        let is_async = is_async_list_set_dict_comprehension || is_async_generator_comprehension;
-
-        self.ctx = CompileContext {
-            loop_data: None,
-            in_class: prev_ctx.in_class,
-            func: if is_async {
-                FunctionContext::AsyncFunction
-            } else {
-                FunctionContext::Function
-            },
-        };
-
-        // We must have at least one generator:
-        assert!(!generators.is_empty());
-
-        let flags = bytecode::CodeFlags::NEW_LOCALS | bytecode::CodeFlags::IS_OPTIMIZED;
-        let flags = if is_async {
-            flags | bytecode::CodeFlags::IS_COROUTINE
-        } else {
-            flags
-        };
-
-        // Create magnificent function <listcomp>:
-        self.push_output(flags, 1, 1, 0, name.to_owned());
-        let arg0 = self.varname(".0")?;
-
-        let return_none = init_collection.is_none();
-        // Create empty object of proper type:
-        if let Some(init_collection) = init_collection {
-            self._emit(init_collection, OpArg(0), ir::BlockIdx::NULL)
-        }
-
-        let mut loop_labels = vec![];
-        for generator in generators {
-            let loop_block = self.new_block();
-            let after_block = self.new_block();
-
-            // emit!(self, Instruction::SetupLoop);
-
-            if loop_labels.is_empty() {
-                // Load iterator onto stack (passed as first argument):
-                emit!(self, Instruction::LoadFast(arg0));
-            } else {
-                // Evaluate iterated item:
-                self.compile_expression(&generator.iter)?;
-
-                // Get iterator / turn item into an iterator
-                if generator.is_async {
-                    emit!(self, Instruction::GetAIter);
-                } else {
-                    emit!(self, Instruction::GetIter);
-                }
-            }
-
-            loop_labels.push((loop_block, after_block));
-            self.switch_to_block(loop_block);
-            if generator.is_async {
-                emit!(
-                    self,
-                    Instruction::SetupExcept {
-                        handler: after_block,
-                    }
-                );
-                emit!(self, Instruction::GetANext);
-                self.emit_load_const(ConstantData::None);
-                emit!(self, Instruction::YieldFrom);
-                self.compile_store(&generator.target)?;
-                emit!(self, Instruction::PopBlock);
-            } else {
-                emit!(
-                    self,
-                    Instruction::ForIter {
-                        target: after_block,
-                    }
-                );
-                self.compile_store(&generator.target)?;
-            }
-
-            // Now evaluate the ifs:
-            for if_condition in &generator.ifs {
-                self.compile_jump_if(if_condition, false, loop_block)?
-            }
-        }
-
-        compile_element(self)?;
-
-        for (loop_block, after_block) in loop_labels.iter().rev().copied() {
-            // Repeat:
-            emit!(self, Instruction::Jump { target: loop_block });
-
-            // End of for loop:
-            self.switch_to_block(after_block);
-            if has_an_async_gen {
-                emit!(self, Instruction::EndAsyncFor);
-            }
-        }
-
-        if return_none {
-            self.emit_load_const(ConstantData::None)
-        }
-
-        // Return freshly filled list:
-        self.emit_return_value();
-
-        // Fetch code for listcomp function:
-        let code = self.pop_code_object();
-
-        self.ctx = prev_ctx;
-
-        let mut func_flags = bytecode::MakeFunctionFlags::empty();
-        if self.build_closure(&code) {
-            func_flags |= bytecode::MakeFunctionFlags::CLOSURE;
-        }
-
-        // List comprehension code:
-        self.emit_load_const(ConstantData::Code {
-            code: Box::new(code),
-        });
-
-        // List comprehension function name:
-        self.emit_load_const(ConstantData::Str { value: name.into() });
-
-        // Turn code object into function object:
-        emit!(self, Instruction::MakeFunction(func_flags));
-
-        // Evaluate iterated item:
-        self.compile_expression(&generators[0].iter)?;
-
-        // Get iterator / turn item into an iterator
-        if has_an_async_gen {
-            emit!(self, Instruction::GetAIter);
-        } else {
-            emit!(self, Instruction::GetIter);
-        };
-
-        // Call just created <listcomp> function:
-        emit!(self, Instruction::CallFunctionPositional { nargs: 1 });
-        if is_async_list_set_dict_comprehension {
-            // async, but not a generator and not an async for
-            // in this case, we end up with an awaitable
-            // that evaluates to the list/set/dict, so here we add an await
-            emit!(self, Instruction::GetAwaitable);
-            self.emit_load_const(ConstantData::None);
-            emit!(self, Instruction::YieldFrom);
-        }
-
-        Ok(())
-    }
-
-    fn compile_future_features(&mut self, features: &[Alias]) -> Result<(), CodegenError> {
-        if let DoneWithFuture::Yes = self.done_with_future_stmts {
-            return Err(self.error(CodegenErrorType::InvalidFuturePlacement));
-        }
-        self.done_with_future_stmts = DoneWithFuture::DoneWithDoc;
-        for feature in features {
-            match feature.name.as_str() {
-                // Python 3 features; we've already implemented them by default
-                "nested_scopes" | "generators" | "division" | "absolute_import"
-                | "with_statement" | "print_function" | "unicode_literals" | "generator_stop" => {}
-                "annotations" => self.future_annotations = true,
-                other => {
-                    return Err(
-                        self.error(CodegenErrorType::InvalidFutureFeature(other.to_owned()))
-                    );
-                }
-            }
-        }
-        Ok(())
-    }
-
-    // Low level helper functions:
-    fn _emit(&mut self, instr: Instruction, arg: OpArg, target: ir::BlockIdx) {
-        let range = self.current_source_range;
-        let location = self.source_code.source_location(range.start());
-        // TODO: insert source filename
-        self.current_block().instructions.push(ir::InstructionInfo {
-            instr,
-            arg,
-            target,
-            location,
-            // range,
-        });
-    }
-
-    fn emit_no_arg(&mut self, ins: Instruction) {
-        self._emit(ins, OpArg::null(), ir::BlockIdx::NULL)
-    }
-
-    fn emit_arg<A: OpArgType, T: EmitArg<A>>(
-        &mut self,
-        arg: T,
-        f: impl FnOnce(OpArgMarker<A>) -> Instruction,
-    ) {
-        let (op, arg, target) = arg.emit(f);
-        self._emit(op, arg, target)
-    }
-
-    // fn block_done()
-
-    fn arg_constant(&mut self, constant: ConstantData) -> u32 {
-        let info = self.current_code_info();
-        info.constants.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 })
-    }
-
-    fn emit_return_const(&mut self, constant: ConstantData) {
-        let idx = self.arg_constant(constant);
-        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
-    }
-
-    fn emit_return_value(&mut self) {
-        if let Some(inst) = self.current_block().instructions.last_mut() {
-            if let Instruction::LoadConst { idx } = inst.instr {
-                inst.instr = Instruction::ReturnConst { idx };
-                return;
-            }
-        }
-        emit!(self, Instruction::ReturnValue)
-    }
-
-    fn current_code_info(&mut self) -> &mut ir::CodeInfo {
-        self.code_stack.last_mut().expect("no code on stack")
-    }
-
-    fn current_block(&mut self) -> &mut ir::Block {
-        let info = self.current_code_info();
-        &mut info.blocks[info.current_block]
-    }
-
-    fn new_block(&mut self) -> ir::BlockIdx {
-        let code = self.current_code_info();
-        let idx = ir::BlockIdx(code.blocks.len().to_u32());
-        code.blocks.push(ir::Block::default());
-        idx
-    }
-
-    fn switch_to_block(&mut self, block: ir::BlockIdx) {
-        let code = self.current_code_info();
-        let prev = code.current_block;
-        assert_ne!(prev, block, "recursive switching {prev:?} -> {block:?}");
-        assert_eq!(
-            code.blocks[block].next,
-            ir::BlockIdx::NULL,
-            "switching {prev:?} -> {block:?} to completed block"
-        );
-        let prev_block = &mut code.blocks[prev.0 as usize];
-        assert_eq!(
-            prev_block.next.0,
-            u32::MAX,
-            "switching {prev:?} -> {block:?} from block that's already got a next"
-        );
-        prev_block.next = block;
-        code.current_block = block;
-    }
-
-    const fn set_source_range(&mut self, range: TextRange) {
-        self.current_source_range = range;
-    }
-
-    fn get_source_line_number(&mut self) -> OneIndexed {
-        self.source_code
-            .line_index(self.current_source_range.start())
-    }
-
-    fn push_qualified_path(&mut self, name: &str) {
-        self.qualified_path.push(name.to_owned());
-    }
-
-    fn mark_generator(&mut self) {
-        self.current_code_info().flags |= bytecode::CodeFlags::IS_GENERATOR
-    }
-
-    /// Whether the expression contains an await expression and
-    /// thus requires the function to be async.
-    /// Async with and async for are statements, so I won't check for them here
-    fn contains_await(expression: &Expr) -> bool {
-        use ruff_python_ast::*;
-
-        match &expression {
-            Expr::Call(ExprCall {
-                func, arguments, ..
-            }) => {
-                Self::contains_await(func)
-                    || arguments.args.iter().any(Self::contains_await)
-                    || arguments
-                        .keywords
-                        .iter()
-                        .any(|kw| Self::contains_await(&kw.value))
-            }
-            Expr::BoolOp(ExprBoolOp { values, .. }) => values.iter().any(Self::contains_await),
-            Expr::BinOp(ExprBinOp { left, right, .. }) => {
-                Self::contains_await(left) || Self::contains_await(right)
-            }
-            Expr::Subscript(ExprSubscript { value, slice, .. }) => {
-                Self::contains_await(value) || Self::contains_await(slice)
-            }
-            Expr::UnaryOp(ExprUnaryOp { operand, .. }) => Self::contains_await(operand),
-            Expr::Attribute(ExprAttribute { value, .. }) => Self::contains_await(value),
-            Expr::Compare(ExprCompare {
-                left, comparators, ..
-            }) => Self::contains_await(left) || comparators.iter().any(Self::contains_await),
-            Expr::List(ExprList { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Tuple(ExprTuple { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Set(ExprSet { elts, .. }) => elts.iter().any(Self::contains_await),
-            Expr::Dict(ExprDict { items, .. }) => items
-                .iter()
-                .flat_map(|item| &item.key)
-                .any(Self::contains_await),
-            Expr::Slice(ExprSlice {
-                lower, upper, step, ..
-            }) => {
-                lower.as_deref().is_some_and(Self::contains_await)
-                    || upper.as_deref().is_some_and(Self::contains_await)
-                    || step.as_deref().is_some_and(Self::contains_await)
-            }
-            Expr::Yield(ExprYield { value, .. }) => {
-                value.as_deref().is_some_and(Self::contains_await)
-            }
-            Expr::Await(ExprAwait { .. }) => true,
-            Expr::YieldFrom(ExprYieldFrom { value, .. }) => Self::contains_await(value),
-            Expr::Name(ExprName { .. }) => false,
-            Expr::Lambda(ExprLambda { body, .. }) => Self::contains_await(body),
-            Expr::ListComp(ExprListComp {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::SetComp(ExprSetComp {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::DictComp(ExprDictComp {
-                key,
-                value,
-                generators,
-                ..
-            }) => {
-                Self::contains_await(key)
-                    || Self::contains_await(value)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::Generator(ExprGenerator {
-                elt, generators, ..
-            }) => {
-                Self::contains_await(elt)
-                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
-            }
-            Expr::Starred(expr) => Self::contains_await(&expr.value),
-            Expr::If(ExprIf {
-                test, body, orelse, ..
-            }) => {
-                Self::contains_await(test)
-                    || Self::contains_await(body)
-                    || Self::contains_await(orelse)
-            }
-
-            Expr::Named(ExprNamed {
-                target,
-                value,
-                range: _,
-            }) => Self::contains_await(target) || Self::contains_await(value),
-            Expr::FString(ExprFString { value, range: _ }) => {
-                fn expr_element_contains_await<F: Copy + Fn(&Expr) -> bool>(
-                    expr_element: &FStringExpressionElement,
-                    contains_await: F,
-                ) -> bool {
-                    contains_await(&expr_element.expression)
-                        || expr_element
-                            .format_spec
-                            .iter()
-                            .flat_map(|spec| spec.elements.expressions())
-                            .any(|element| expr_element_contains_await(element, contains_await))
-                }
-
-                value.elements().any(|element| match element {
-                    FStringElement::Expression(expr_element) => {
-                        expr_element_contains_await(expr_element, Self::contains_await)
-                    }
-                    FStringElement::Literal(_) => false,
-                })
-            }
-            Expr::StringLiteral(_)
-            | Expr::BytesLiteral(_)
-            | Expr::NumberLiteral(_)
-            | Expr::BooleanLiteral(_)
-            | Expr::NoneLiteral(_)
-            | Expr::EllipsisLiteral(_)
-            | Expr::IpyEscapeCommand(_) => false,
-        }
-    }
-
-    fn compile_expr_fstring(&mut self, fstring: &ExprFString) -> CompileResult<()> {
-        let fstring = &fstring.value;
-        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 });
-        }
-
-        Ok(())
-    }
-
-    fn compile_fstring_part(&mut self, part: &FStringPart) -> CompileResult<()> {
-        match part {
-            FStringPart::Literal(string) => {
-                if string.value.contains(char::REPLACEMENT_CHARACTER) {
-                    // might have a surrogate literal; should reparse to be sure
-                    let source = self.source_code.get_range(string.range);
-                    let value =
-                        crate::string_parser::parse_string_literal(source, string.flags.into());
-                    self.emit_load_const(ConstantData::Str {
-                        value: value.into(),
-                    });
-                } else {
-                    self.emit_load_const(ConstantData::Str {
-                        value: string.value.to_string().into(),
-                    });
-                }
-                Ok(())
-            }
-            FStringPart::FString(fstring) => self.compile_fstring(fstring),
-        }
-    }
-
-    fn compile_fstring(&mut self, fstring: &FString) -> CompileResult<()> {
-        self.compile_fstring_elements(fstring.flags, &fstring.elements)
-    }
-
-    fn compile_fstring_elements(
-        &mut self,
-        flags: FStringFlags,
-        fstring_elements: &FStringElements,
-    ) -> CompileResult<()> {
-        let mut element_count = 0;
-        for element in fstring_elements {
-            element_count += 1;
-            match element {
-                FStringElement::Literal(string) => {
-                    if string.value.contains(char::REPLACEMENT_CHARACTER) {
-                        // might have a surrogate literal; should reparse to be sure
-                        let source = self.source_code.get_range(string.range);
-                        let value = crate::string_parser::parse_fstring_literal_element(
-                            source.into(),
-                            flags.into(),
-                        );
-                        self.emit_load_const(ConstantData::Str {
-                            value: value.into(),
-                        });
-                    } else {
-                        self.emit_load_const(ConstantData::Str {
-                            value: string.value.to_string().into(),
-                        });
-                    }
-                }
-                FStringElement::Expression(fstring_expr) => {
-                    let mut conversion = fstring_expr.conversion;
-
-                    if let Some(DebugText { leading, trailing }) = &fstring_expr.debug_text {
-                        let range = fstring_expr.expression.range();
-                        let source = self.source_code.get_range(range);
-                        let text = [leading, source, trailing].concat();
-
-                        self.emit_load_const(ConstantData::Str { value: text.into() });
-                        element_count += 1;
-                    }
-
-                    match &fstring_expr.format_spec {
-                        None => {
-                            self.emit_load_const(ConstantData::Str {
-                                value: Wtf8Buf::new(),
-                            });
-                            // Match CPython behavior: If debug text is present, apply repr conversion.
-                            // See: https://github.com/python/cpython/blob/f61afca262d3a0aa6a8a501db0b1936c60858e35/Parser/action_helpers.c#L1456
-                            if conversion == ConversionFlag::None
-                                && fstring_expr.debug_text.is_some()
-                            {
-                                conversion = ConversionFlag::Repr;
-                            }
-                        }
-                        Some(format_spec) => {
-                            self.compile_fstring_elements(flags, &format_spec.elements)?;
-                        }
-                    }
-
-                    self.compile_expression(&fstring_expr.expression)?;
-
-                    let conversion = match conversion {
-                        ConversionFlag::None => bytecode::ConversionFlag::None,
-                        ConversionFlag::Str => bytecode::ConversionFlag::Str,
-                        ConversionFlag::Ascii => bytecode::ConversionFlag::Ascii,
-                        ConversionFlag::Repr => bytecode::ConversionFlag::Repr,
-                    };
-                    emit!(self, Instruction::FormatValue { conversion });
-                }
-            }
-        }
-
-        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
-                }
-            );
-        }
-
-        Ok(())
-    }
-}
-
-trait EmitArg<Arg: OpArgType> {
-    fn emit(
-        self,
-        f: impl FnOnce(OpArgMarker<Arg>) -> Instruction,
-    ) -> (Instruction, OpArg, ir::BlockIdx);
-}
-impl<T: OpArgType> EmitArg<T> for T {
-    fn emit(
-        self,
-        f: impl FnOnce(OpArgMarker<T>) -> Instruction,
-    ) -> (Instruction, OpArg, ir::BlockIdx) {
-        let (marker, arg) = OpArgMarker::new(self);
-        (f(marker), arg, ir::BlockIdx::NULL)
-    }
-}
-impl EmitArg<bytecode::Label> for ir::BlockIdx {
-    fn emit(
-        self,
-        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> Instruction,
-    ) -> (Instruction, OpArg, ir::BlockIdx) {
-        (f(OpArgMarker::marker()), OpArg::null(), self)
-    }
-}
-
-/// Strips leading whitespace from a docstring.
-///
-/// The code has been ported from `_PyCompile_CleanDoc` in cpython.
-/// `inspect.cleandoc` is also a good reference, but has a few incompatibilities.
-fn clean_doc(doc: &str) -> String {
-    let doc = expandtabs(doc, 8);
-    // First pass: find minimum indentation of any non-blank lines
-    // after first line.
-    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()
-    }
-}
-
-// copied from rustpython_common::str, so we don't have to depend on it just for this function
-fn expandtabs(input: &str, tab_size: usize) -> String {
-    let tab_stop = tab_size;
-    let mut expanded_str = String::with_capacity(input.len());
-    let mut tab_size = tab_stop;
-    let mut col_count = 0usize;
-    for ch in input.chars() {
-        match ch {
-            '\t' => {
-                let num_spaces = tab_size - col_count;
-                col_count += num_spaces;
-                let expand = " ".repeat(num_spaces);
-                expanded_str.push_str(&expand);
-            }
-            '\r' | '\n' => {
-                expanded_str.push(ch);
-                col_count = 0;
-                tab_size = 0;
-            }
-            _ => {
-                expanded_str.push(ch);
-                col_count += 1;
-            }
-        }
-        if col_count >= tab_size {
-            tab_size += tab_stop;
-        }
-    }
-    expanded_str
-}
-
-fn split_doc<'a>(body: &'a [Stmt], opts: &CompileOpts) -> (Option<String>, &'a [Stmt]) {
-    if let Some((Stmt::Expr(expr), body_rest)) = body.split_first() {
-        let doc_comment = match &*expr.value {
-            Expr::StringLiteral(value) => Some(&value.value),
-            // f-strings are not allowed in Python doc comments.
-            Expr::FString(_) => None,
-            _ => None,
-        };
-        if let Some(doc) = doc_comment {
-            return if opts.optimize < 2 {
-                (Some(clean_doc(doc.to_str())), body_rest)
-            } else {
-                (None, body_rest)
-            };
-        }
-    }
-    (None, body)
-}
-
-pub fn ruff_int_to_bigint(int: &Int) -> Result<BigInt, CodegenErrorType> {
-    if let Some(small) = int.as_u64() {
-        Ok(BigInt::from(small))
-    } else {
-        parse_big_integer(int)
-    }
-}
-
-/// Converts a `ruff` ast integer into a `BigInt`.
-/// Unlike small integers, big integers may be stored in one of four possible radix representations.
-fn parse_big_integer(int: &Int) -> Result<BigInt, CodegenErrorType> {
-    // TODO: Improve ruff API
-    // Can we avoid this copy?
-    let s = format!("{int}");
-    let mut s = s.as_str();
-    // See: https://peps.python.org/pep-0515/#literal-grammar
-    let radix = match s.get(0..2) {
-        Some("0b" | "0B") => {
-            s = s.get(2..).unwrap_or(s);
-            2
-        }
-        Some("0o" | "0O") => {
-            s = s.get(2..).unwrap_or(s);
-            8
-        }
-        Some("0x" | "0X") => {
-            s = s.get(2..).unwrap_or(s);
-            16
-        }
-        _ => 10,
-    };
-
-    BigInt::from_str_radix(s, radix).map_err(|e| {
-        CodegenErrorType::SyntaxError(format!(
-            "unparsed integer literal (radix {radix}): {s} ({e})"
-        ))
-    })
-}
-
-// Note: Not a good practice in general. Keep this trait private only for compiler
-trait ToU32 {
-    fn to_u32(self) -> u32;
-}
-
-impl ToU32 for usize {
-    fn to_u32(self) -> u32 {
-        self.try_into().unwrap()
-    }
-}
-
-#[cfg(test)]
-mod ruff_tests {
-    use super::*;
-    use ruff_python_ast::name::Name;
-    use ruff_python_ast::*;
-
-    /// Test if the compiler can correctly identify fstrings containing an `await` expression.
-    #[test]
-    fn test_fstring_contains_await() {
-        let range = TextRange::default();
-        let flags = FStringFlags::empty();
-
-        // f'{x}'
-        let expr_x = Expr::Name(ExprName {
-            range,
-            id: Name::new("x"),
-            ctx: ExprContext::Load,
-        });
-        let not_present = &Expr::FString(ExprFString {
-            range,
-            value: FStringValue::single(FString {
-                range,
-                elements: vec![FStringElement::Expression(FStringExpressionElement {
-                    range,
-                    expression: Box::new(expr_x),
-                    debug_text: None,
-                    conversion: ConversionFlag::None,
-                    format_spec: None,
-                })]
-                .into(),
-                flags,
-            }),
-        });
-        assert!(!Compiler::contains_await(not_present));
-
-        // f'{await x}'
-        let expr_await_x = Expr::Await(ExprAwait {
-            range,
-            value: Box::new(Expr::Name(ExprName {
-                range,
-                id: Name::new("x"),
-                ctx: ExprContext::Load,
-            })),
-        });
-        let present = &Expr::FString(ExprFString {
-            range,
-            value: FStringValue::single(FString {
-                range,
-                elements: vec![FStringElement::Expression(FStringExpressionElement {
-                    range,
-                    expression: Box::new(expr_await_x),
-                    debug_text: None,
-                    conversion: ConversionFlag::None,
-                    format_spec: None,
-                })]
-                .into(),
-                flags,
-            }),
-        });
-        assert!(Compiler::contains_await(present));
-
-        // f'{x:{await y}}'
-        let expr_x = Expr::Name(ExprName {
-            range,
-            id: Name::new("x"),
-            ctx: ExprContext::Load,
-        });
-        let expr_await_y = Expr::Await(ExprAwait {
-            range,
-            value: Box::new(Expr::Name(ExprName {
-                range,
-                id: Name::new("y"),
-                ctx: ExprContext::Load,
-            })),
-        });
-        let present = &Expr::FString(ExprFString {
-            range,
-            value: FStringValue::single(FString {
-                range,
-                elements: vec![FStringElement::Expression(FStringExpressionElement {
-                    range,
-                    expression: Box::new(expr_x),
-                    debug_text: None,
-                    conversion: ConversionFlag::None,
-                    format_spec: Some(Box::new(FStringFormatSpec {
-                        range,
-                        elements: vec![FStringElement::Expression(FStringExpressionElement {
-                            range,
-                            expression: Box::new(expr_await_y),
-                            debug_text: None,
-                            conversion: ConversionFlag::None,
-                            format_spec: None,
-                        })]
-                        .into(),
-                    })),
-                })]
-                .into(),
-                flags,
-            }),
-        });
-        assert!(Compiler::contains_await(present));
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn compile_exec(source: &str) -> CodeObject {
-        let opts = CompileOpts::default();
-        let source_code = SourceCode::new("source_path", source);
-        let parsed =
-            ruff_python_parser::parse(source_code.text, ruff_python_parser::Mode::Module.into())
-                .unwrap();
-        let ast = parsed.into_syntax();
-        let ast = match ast {
-            ruff_python_ast::Mod::Module(stmts) => stmts,
-            _ => unreachable!(),
-        };
-        let symbol_table = SymbolTable::scan_program(&ast, source_code.clone())
-            .map_err(|e| e.into_codegen_error(source_code.path.to_owned()))
-            .unwrap();
-        let mut compiler = Compiler::new(opts, source_code, "<module>".to_owned());
-        compiler.compile_program(&ast, symbol_table).unwrap();
-        compiler.pop_code_object()
-    }
-
-    macro_rules! assert_dis_snapshot {
-        ($value:expr) => {
-            insta::assert_snapshot!(
-                insta::internals::AutoName,
-                $value.display_expand_code_objects().to_string(),
-                stringify!($value)
-            )
-        };
-    }
-
-    #[test]
-    fn test_if_ors() {
-        assert_dis_snapshot!(compile_exec(
-            "\
-if True or False or False:
-    pass
-"
-        ));
-    }
-
-    #[test]
-    fn test_if_ands() {
-        assert_dis_snapshot!(compile_exec(
-            "\
-if True and False and False:
-    pass
-"
-        ));
-    }
-
-    #[test]
-    fn test_if_mixed() {
-        assert_dis_snapshot!(compile_exec(
-            "\
-if (True and False) or (False and True):
-    pass
-"
-        ));
-    }
-
-    #[test]
-    fn test_nested_double_async_with() {
-        assert_dis_snapshot!(compile_exec(
-            "\
-for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):
-    with self.subTest(type=type(stop_exc)):
-        try:
-            async with egg():
-                raise stop_exc
-        except Exception as ex:
-            self.assertIs(ex, stop_exc)
-        else:
-            self.fail(f'{stop_exc} was suppressed')
-"
-        ));
-    }
-}
diff --git a/compiler/codegen/src/error.rs b/compiler/codegen/src/error.rs
deleted file mode 100644
index 5e0ac12934..0000000000
--- a/compiler/codegen/src/error.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use ruff_source_file::SourceLocation;
-use std::fmt::{self, Display};
-use thiserror::Error;
-
-#[derive(Debug)]
-pub enum PatternUnreachableReason {
-    NameCapture,
-    Wildcard,
-}
-
-impl Display for PatternUnreachableReason {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::NameCapture => write!(f, "name capture"),
-            Self::Wildcard => write!(f, "wildcard"),
-        }
-    }
-}
-
-// pub type CodegenError = rustpython_parser_core::source_code::LocatedError<CodegenErrorType>;
-
-#[derive(Error, Debug)]
-pub struct CodegenError {
-    pub location: Option<SourceLocation>,
-    #[source]
-    pub error: CodegenErrorType,
-    pub source_path: String,
-}
-
-impl fmt::Display for CodegenError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // TODO:
-        self.error.fmt(f)
-    }
-}
-
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum InternalError {
-    StackOverflow,
-    StackUnderflow,
-    MissingSymbol(String),
-}
-
-impl Display for InternalError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::StackOverflow => write!(f, "stack overflow"),
-            Self::StackUnderflow => write!(f, "stack underflow"),
-            Self::MissingSymbol(s) => write!(
-                f,
-                "The symbol '{s}' must be present in the symbol table, even when it is undefined in python."
-            ),
-        }
-    }
-}
-
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum CodegenErrorType {
-    /// Invalid assignment, cannot store value in target.
-    Assign(&'static str),
-    /// Invalid delete
-    Delete(&'static str),
-    SyntaxError(String),
-    /// Multiple `*` detected
-    MultipleStarArgs,
-    /// Misplaced `*` expression
-    InvalidStarExpr,
-    /// Break statement outside of loop.
-    InvalidBreak,
-    /// Continue statement outside of loop.
-    InvalidContinue,
-    InvalidReturn,
-    InvalidYield,
-    InvalidYieldFrom,
-    InvalidAwait,
-    AsyncYieldFrom,
-    AsyncReturnValue,
-    InvalidFuturePlacement,
-    InvalidFutureFeature(String),
-    FunctionImportStar,
-    TooManyStarUnpack,
-    EmptyWithItems,
-    EmptyWithBody,
-    ForbiddenName,
-    DuplicateStore(String),
-    UnreachablePattern(PatternUnreachableReason),
-    RepeatedAttributePattern,
-    ConflictingNameBindPattern,
-    NotImplementedYet, // RustPython marker for unimplemented features
-}
-
-impl std::error::Error for CodegenErrorType {}
-
-impl fmt::Display for CodegenErrorType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CodegenErrorType::*;
-        match self {
-            Assign(target) => write!(f, "cannot assign to {target}"),
-            Delete(target) => write!(f, "cannot delete {target}"),
-            SyntaxError(err) => write!(f, "{}", err.as_str()),
-            MultipleStarArgs => {
-                write!(f, "two starred expressions in assignment")
-            }
-            InvalidStarExpr => write!(f, "cannot use starred expression here"),
-            InvalidBreak => write!(f, "'break' outside loop"),
-            InvalidContinue => write!(f, "'continue' outside loop"),
-            InvalidReturn => write!(f, "'return' outside function"),
-            InvalidYield => write!(f, "'yield' outside function"),
-            InvalidYieldFrom => write!(f, "'yield from' outside function"),
-            InvalidAwait => write!(f, "'await' outside async function"),
-            AsyncYieldFrom => write!(f, "'yield from' inside async function"),
-            AsyncReturnValue => {
-                write!(f, "'return' with value inside async generator")
-            }
-            InvalidFuturePlacement => write!(
-                f,
-                "from __future__ imports must occur at the beginning of the file"
-            ),
-            InvalidFutureFeature(feat) => {
-                write!(f, "future feature {feat} is not defined")
-            }
-            FunctionImportStar => {
-                write!(f, "import * only allowed at module level")
-            }
-            TooManyStarUnpack => {
-                write!(f, "too many expressions in star-unpacking assignment")
-            }
-            EmptyWithItems => {
-                write!(f, "empty items on With")
-            }
-            EmptyWithBody => {
-                write!(f, "empty body on With")
-            }
-            ForbiddenName => {
-                write!(f, "forbidden attribute name")
-            }
-            DuplicateStore(s) => {
-                write!(f, "duplicate store {s}")
-            }
-            UnreachablePattern(reason) => {
-                write!(f, "{reason} makes remaining patterns unreachable")
-            }
-            RepeatedAttributePattern => {
-                write!(f, "attribute name repeated in class pattern")
-            }
-            ConflictingNameBindPattern => {
-                write!(f, "alternative patterns bind different names")
-            }
-            NotImplementedYet => {
-                write!(f, "RustPython does not implement this feature yet")
-            }
-        }
-    }
-}
diff --git a/compiler/codegen/src/ir.rs b/compiler/codegen/src/ir.rs
deleted file mode 100644
index 7acd9d7f6a..0000000000
--- a/compiler/codegen/src/ir.rs
+++ /dev/null
@@ -1,339 +0,0 @@
-use std::ops;
-
-use crate::IndexSet;
-use crate::error::InternalError;
-use ruff_source_file::{OneIndexed, SourceLocation};
-use rustpython_compiler_core::bytecode::{
-    CodeFlags, CodeObject, CodeUnit, ConstantData, InstrDisplayContext, Instruction, Label, OpArg,
-};
-// use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
-
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub struct BlockIdx(pub u32);
-impl BlockIdx {
-    pub const NULL: Self = Self(u32::MAX);
-    const fn idx(self) -> usize {
-        self.0 as usize
-    }
-}
-impl ops::Index<BlockIdx> for [Block] {
-    type Output = Block;
-    fn index(&self, idx: BlockIdx) -> &Block {
-        &self[idx.idx()]
-    }
-}
-impl ops::IndexMut<BlockIdx> for [Block] {
-    fn index_mut(&mut self, idx: BlockIdx) -> &mut Block {
-        &mut self[idx.idx()]
-    }
-}
-impl ops::Index<BlockIdx> for Vec<Block> {
-    type Output = Block;
-    fn index(&self, idx: BlockIdx) -> &Block {
-        &self[idx.idx()]
-    }
-}
-impl ops::IndexMut<BlockIdx> for Vec<Block> {
-    fn index_mut(&mut self, idx: BlockIdx) -> &mut Block {
-        &mut self[idx.idx()]
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct InstructionInfo {
-    pub instr: Instruction,
-    pub arg: OpArg,
-    pub target: BlockIdx,
-    // pub range: TextRange,
-    pub location: SourceLocation,
-}
-
-// 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)]
-pub struct Block {
-    pub instructions: Vec<InstructionInfo>,
-    pub next: BlockIdx,
-}
-impl Default for Block {
-    fn default() -> Self {
-        Self {
-            instructions: Vec::new(),
-            next: BlockIdx::NULL,
-        }
-    }
-}
-
-pub struct CodeInfo {
-    pub flags: CodeFlags,
-    pub posonlyarg_count: u32, // Number of positional-only arguments
-    pub arg_count: u32,
-    pub kwonlyarg_count: u32,
-    pub source_path: String,
-    pub first_line_number: OneIndexed,
-    pub obj_name: String, // Name of the object that created this code object
-
-    pub blocks: Vec<Block>,
-    pub current_block: BlockIdx,
-    pub constants: IndexSet<ConstantData>,
-    pub name_cache: IndexSet<String>,
-    pub varname_cache: IndexSet<String>,
-    pub cellvar_cache: IndexSet<String>,
-    pub freevar_cache: IndexSet<String>,
-}
-impl CodeInfo {
-    pub fn finalize_code(mut self, optimize: u8) -> crate::InternalResult<CodeObject> {
-        if optimize > 0 {
-            self.dce();
-        }
-
-        let max_stackdepth = self.max_stackdepth()?;
-        let cell2arg = self.cell2arg();
-
-        let Self {
-            flags,
-            posonlyarg_count,
-            arg_count,
-            kwonlyarg_count,
-            source_path,
-            first_line_number,
-            obj_name,
-
-            mut blocks,
-            current_block: _,
-            constants,
-            name_cache,
-            varname_cache,
-            cellvar_cache,
-            freevar_cache,
-        } = self;
-
-        let mut instructions = Vec::new();
-        let mut locations = Vec::new();
-
-        let mut block_to_offset = vec![Label(0); blocks.len()];
-        loop {
-            let mut num_instructions = 0;
-            for (idx, block) in iter_blocks(&blocks) {
-                block_to_offset[idx.idx()] = Label(num_instructions as u32);
-                for instr in &block.instructions {
-                    num_instructions += instr.arg.instr_size()
-                }
-            }
-
-            instructions.reserve_exact(num_instructions);
-            locations.reserve_exact(num_instructions);
-
-            let mut recompile_extended_arg = false;
-            let mut next_block = BlockIdx(0);
-            while next_block != BlockIdx::NULL {
-                let block = &mut blocks[next_block];
-                for info in &mut block.instructions {
-                    let (op, arg, target) = (info.instr, &mut info.arg, info.target);
-                    if target != BlockIdx::NULL {
-                        let new_arg = OpArg(block_to_offset[target.idx()].0);
-                        recompile_extended_arg |= new_arg.instr_size() != arg.instr_size();
-                        *arg = new_arg;
-                    }
-                    let (extras, lo_arg) = arg.split();
-                    locations.extend(std::iter::repeat_n(info.location.clone(), arg.instr_size()));
-                    instructions.extend(
-                        extras
-                            .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
-                            .chain([CodeUnit { op, arg: lo_arg }]),
-                    );
-                }
-                next_block = block.next;
-            }
-
-            if !recompile_extended_arg {
-                break;
-            }
-
-            instructions.clear();
-            locations.clear()
-        }
-
-        Ok(CodeObject {
-            flags,
-            posonlyarg_count,
-            arg_count,
-            kwonlyarg_count,
-            source_path,
-            first_line_number: Some(first_line_number),
-            obj_name,
-
-            max_stackdepth,
-            instructions: instructions.into_boxed_slice(),
-            locations: locations.into_boxed_slice(),
-            constants: constants.into_iter().collect(),
-            names: name_cache.into_iter().collect(),
-            varnames: varname_cache.into_iter().collect(),
-            cellvars: cellvar_cache.into_iter().collect(),
-            freevars: freevar_cache.into_iter().collect(),
-            cell2arg,
-        })
-    }
-
-    fn cell2arg(&self) -> Option<Box<[i32]>> {
-        if self.cellvar_cache.is_empty() {
-            return None;
-        }
-
-        let total_args = self.arg_count
-            + self.kwonlyarg_count
-            + self.flags.contains(CodeFlags::HAS_VARARGS) as u32
-            + self.flags.contains(CodeFlags::HAS_VARKEYWORDS) as u32;
-
-        let mut found_cellarg = false;
-        let cell2arg = self
-            .cellvar_cache
-            .iter()
-            .map(|var| {
-                self.varname_cache
-                    .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) {
-        for block in &mut self.blocks {
-            let mut last_instr = None;
-            for (i, ins) in block.instructions.iter().enumerate() {
-                if ins.instr.unconditional_branch() {
-                    last_instr = Some(i);
-                    break;
-                }
-            }
-            if let Some(i) = last_instr {
-                block.instructions.truncate(i + 1);
-            }
-        }
-    }
-
-    fn max_stackdepth(&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));
-        const DEBUG: bool = false;
-        'process_blocks: while let Some(block) = stack.pop() {
-            let mut depth = start_depths[block.idx()];
-            if DEBUG {
-                eprintln!("===BLOCK {}===", block.0);
-            }
-            let block = &self.blocks[block];
-            for ins in &block.instructions {
-                let instr = &ins.instr;
-                let effect = instr.stack_effect(ins.arg, false);
-                if DEBUG {
-                    let display_arg = if ins.target == BlockIdx::NULL {
-                        ins.arg
-                    } else {
-                        OpArg(ins.target.0)
-                    };
-                    let instr_display = instr.display(display_arg, self);
-                    eprint!("{instr_display}: {depth} {effect:+} => ");
-                }
-                let new_depth = depth.checked_add_signed(effect).ok_or({
-                    if effect < 0 {
-                        InternalError::StackUnderflow
-                    } else {
-                        InternalError::StackOverflow
-                    }
-                })?;
-                if DEBUG {
-                    eprintln!("{new_depth}");
-                }
-                if new_depth > maxdepth {
-                    maxdepth = new_depth
-                }
-                // we don't want to worry about Break/Continue, they use unwinding to jump to
-                // their targets and as such the stack size is taken care of in frame.rs by setting
-                // it back to the level it was at when SetupLoop was run
-                if ins.target != BlockIdx::NULL
-                    && !matches!(
-                        instr,
-                        Instruction::Continue { .. } | Instruction::Break { .. }
-                    )
-                {
-                    let effect = instr.stack_effect(ins.arg, true);
-                    let target_depth = depth.checked_add_signed(effect).ok_or({
-                        if 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);
-                }
-                depth = new_depth;
-                if instr.unconditional_branch() {
-                    continue 'process_blocks;
-                }
-            }
-            stackdepth_push(&mut stack, &mut start_depths, block.next, depth);
-        }
-        if DEBUG {
-            eprintln!("DONE: {maxdepth}");
-        }
-        Ok(maxdepth)
-    }
-}
-
-impl InstrDisplayContext for CodeInfo {
-    type Constant = ConstantData;
-    fn get_constant(&self, i: usize) -> &ConstantData {
-        &self.constants[i]
-    }
-    fn get_name(&self, i: usize) -> &str {
-        self.name_cache[i].as_ref()
-    }
-    fn get_varname(&self, i: usize) -> &str {
-        self.varname_cache[i].as_ref()
-    }
-    fn get_cell_name(&self, i: usize) -> &str {
-        self.cellvar_cache
-            .get_index(i)
-            .unwrap_or_else(|| &self.freevar_cache[i - self.cellvar_cache.len()])
-            .as_ref()
-    }
-}
-
-fn stackdepth_push(
-    stack: &mut Vec<BlockIdx>,
-    start_depths: &mut [u32],
-    target: BlockIdx,
-    depth: u32,
-) {
-    let block_depth = &mut start_depths[target.idx()];
-    if *block_depth == u32::MAX || depth > *block_depth {
-        *block_depth = depth;
-        stack.push(target);
-    }
-}
-
-fn iter_blocks(blocks: &[Block]) -> impl Iterator<Item = (BlockIdx, &Block)> + '_ {
-    let mut next = BlockIdx(0);
-    std::iter::from_fn(move || {
-        if next == BlockIdx::NULL {
-            return None;
-        }
-        let (idx, b) = (next, &blocks[next]);
-        next = b.next;
-        Some((idx, b))
-    })
-}
diff --git a/compiler/codegen/src/lib.rs b/compiler/codegen/src/lib.rs
deleted file mode 100644
index 9b444de994..0000000000
--- a/compiler/codegen/src/lib.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! Compile a Python AST or source code into bytecode consumable by RustPython.
-#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
-#![doc(html_root_url = "https://docs.rs/rustpython-compiler/")]
-
-#[macro_use]
-extern crate log;
-
-type IndexMap<K, V> = indexmap::IndexMap<K, V, ahash::RandomState>;
-type IndexSet<T> = indexmap::IndexSet<T, ahash::RandomState>;
-
-pub mod compile;
-pub mod error;
-pub mod ir;
-mod string_parser;
-pub mod symboltable;
-mod unparse;
-
-pub use compile::CompileOpts;
-use ruff_python_ast::Expr;
-
-pub(crate) use compile::InternalResult;
-
-pub trait ToPythonName {
-    /// Returns a short name for the node suitable for use in error messages.
-    fn python_name(&self) -> &'static str;
-}
-
-impl ToPythonName for Expr {
-    fn python_name(&self) -> &'static str {
-        match self {
-            Self::BoolOp { .. } | Self::BinOp { .. } | Self::UnaryOp { .. } => "operator",
-            Self::Subscript { .. } => "subscript",
-            Self::Await { .. } => "await expression",
-            Self::Yield { .. } | Self::YieldFrom { .. } => "yield expression",
-            Self::Compare { .. } => "comparison",
-            Self::Attribute { .. } => "attribute",
-            Self::Call { .. } => "function call",
-            Self::BooleanLiteral(b) => {
-                if b.value {
-                    "True"
-                } else {
-                    "False"
-                }
-            }
-            Self::EllipsisLiteral(_) => "ellipsis",
-            Self::NoneLiteral(_) => "None",
-            Self::NumberLiteral(_) | Self::BytesLiteral(_) | Self::StringLiteral(_) => "literal",
-            Self::Tuple(_) => "tuple",
-            Self::List { .. } => "list",
-            Self::Dict { .. } => "dict display",
-            Self::Set { .. } => "set display",
-            Self::ListComp { .. } => "list comprehension",
-            Self::DictComp { .. } => "dict comprehension",
-            Self::SetComp { .. } => "set comprehension",
-            Self::Generator { .. } => "generator expression",
-            Self::Starred { .. } => "starred",
-            Self::Slice { .. } => "slice",
-            Self::FString { .. } => "f-string expression",
-            Self::Name { .. } => "name",
-            Self::Lambda { .. } => "lambda",
-            Self::If { .. } => "conditional expression",
-            Self::Named { .. } => "named expression",
-            Self::IpyEscapeCommand(_) => todo!(),
-        }
-    }
-}
diff --git a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap b/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
deleted file mode 100644
index cf6223be1f..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
+++ /dev/null
@@ -1,12 +0,0 @@
----
-source: compiler/codegen/src/compile.rs
-expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfFalse          (6)
-              2 LoadConst            (False)
-              3 JumpIfFalse          (6)
-              4 LoadConst            (False)
-              5 JumpIfFalse          (6)
-
-  2     >>    6 ReturnConst          (None)
diff --git a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap b/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
deleted file mode 100644
index 332d0fa985..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
+++ /dev/null
@@ -1,14 +0,0 @@
----
-source: compiler/codegen/src/compile.rs
-expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfFalse          (4)
-              2 LoadConst            (False)
-              3 JumpIfTrue           (8)
-        >>    4 LoadConst            (False)
-              5 JumpIfFalse          (8)
-              6 LoadConst            (True)
-              7 JumpIfFalse          (8)
-
-  2     >>    8 ReturnConst          (None)
diff --git a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap b/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
deleted file mode 100644
index d4a4d8f2c5..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
+++ /dev/null
@@ -1,12 +0,0 @@
----
-source: compiler/codegen/src/compile.rs
-expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfTrue           (6)
-              2 LoadConst            (False)
-              3 JumpIfTrue           (6)
-              4 LoadConst            (False)
-              5 JumpIfFalse          (6)
-
-  2     >>    6 ReturnConst          (None)
diff --git a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
deleted file mode 100644
index 36b00c567d..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
+++ /dev/null
@@ -1,86 +0,0 @@
----
-source: compiler/codegen/src/compile.rs
-expression: "compile_exec(\"\\\nfor stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n    with self.subTest(type=type(stop_exc)):\n        try:\n            async with egg():\n                raise stop_exc\n        except Exception as ex:\n            self.assertIs(ex, stop_exc)\n        else:\n            self.fail(f'{stop_exc} was suppressed')\n\")"
----
-  1           0 SetupLoop
-              1 LoadNameAny          (0, StopIteration)
-              2 LoadConst            ("spam")
-              3 CallFunctionPositional(1)
-              4 LoadNameAny          (1, StopAsyncIteration)
-              5 LoadConst            ("ham")
-              6 CallFunctionPositional(1)
-              7 BuildTuple           (2)
-              8 GetIter
-        >>    9 ForIter              (71)
-             10 StoreLocal           (2, stop_exc)
-
-  2          11 LoadNameAny          (3, self)
-             12 LoadMethod           (4, subTest)
-             13 LoadNameAny          (5, type)
-             14 LoadNameAny          (2, stop_exc)
-             15 CallFunctionPositional(1)
-             16 LoadConst            (("type"))
-             17 CallMethodKeyword    (1)
-             18 SetupWith            (68)
-             19 Pop
-
-  3          20 SetupExcept          (40)
-
-  4          21 LoadNameAny          (6, egg)
-             22 CallFunctionPositional(0)
-             23 BeforeAsyncWith
-             24 GetAwaitable
-             25 LoadConst            (None)
-             26 YieldFrom
-             27 SetupAsyncWith       (33)
-             28 Pop
-
-  5          29 LoadNameAny          (2, stop_exc)
-             30 Raise                (Raise)
-
-  4          31 PopBlock
-             32 EnterFinally
-        >>   33 WithCleanupStart
-             34 GetAwaitable
-             35 LoadConst            (None)
-             36 YieldFrom
-             37 WithCleanupFinish
-             38 PopBlock
-             39 Jump                 (57)
-        >>   40 Duplicate
-
-  6          41 LoadNameAny          (7, Exception)
-             42 TestOperation        (ExceptionMatch)
-             43 JumpIfFalse          (56)
-             44 StoreLocal           (8, ex)
-
-  7          45 LoadNameAny          (3, self)
-             46 LoadMethod           (9, assertIs)
-             47 LoadNameAny          (8, ex)
-             48 LoadNameAny          (2, stop_exc)
-             49 CallMethodPositional (2)
-             50 Pop
-             51 PopException
-             52 LoadConst            (None)
-             53 StoreLocal           (8, ex)
-             54 DeleteLocal          (8, ex)
-             55 Jump                 (66)
-        >>   56 Raise                (Reraise)
-
-  9     >>   57 LoadNameAny          (3, self)
-             58 LoadMethod           (10, fail)
-             59 LoadConst            ("")
-             60 LoadNameAny          (2, stop_exc)
-             61 FormatValue          (None)
-             62 LoadConst            (" was suppressed")
-             63 BuildString          (2)
-             64 CallMethodPositional (1)
-             65 Pop
-
-  2     >>   66 PopBlock
-             67 EnterFinally
-        >>   68 WithCleanupStart
-             69 WithCleanupFinish
-             70 Jump                 (9)
-        >>   71 PopBlock
-             72 ReturnConst          (None)
diff --git a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap b/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
deleted file mode 100644
index d80f10dfee..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
+++ /dev/null
@@ -1,14 +0,0 @@
----
-source: compiler/src/compile.rs
-expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfFalse          (6)
-              2 LoadConst            (False)
-              3 JumpIfFalse          (6)
-              4 LoadConst            (False)
-              5 JumpIfFalse          (6)
-
-  2     >>    6 LoadConst            (None)
-              7 ReturnValue
-
diff --git a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap b/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
deleted file mode 100644
index 0a9175bb12..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
+++ /dev/null
@@ -1,16 +0,0 @@
----
-source: compiler/src/compile.rs
-expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfFalse          (4)
-              2 LoadConst            (False)
-              3 JumpIfTrue           (8)
-        >>    4 LoadConst            (False)
-              5 JumpIfFalse          (8)
-              6 LoadConst            (True)
-              7 JumpIfFalse          (8)
-
-  2     >>    8 LoadConst            (None)
-              9 ReturnValue
-
diff --git a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap b/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
deleted file mode 100644
index 4b812639b2..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
+++ /dev/null
@@ -1,14 +0,0 @@
----
-source: compiler/src/compile.rs
-expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
----
-  1           0 LoadConst            (True)
-              1 JumpIfTrue           (6)
-              2 LoadConst            (False)
-              3 JumpIfTrue           (6)
-              4 LoadConst            (False)
-              5 JumpIfFalse          (6)
-
-  2     >>    6 LoadConst            (None)
-              7 ReturnValue
-
diff --git a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap b/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap
deleted file mode 100644
index 79a1a86ad1..0000000000
--- a/compiler/codegen/src/snapshots/rustpython_compiler_core__compile__tests__nested_double_async_with.snap
+++ /dev/null
@@ -1,87 +0,0 @@
----
-source: compiler/src/compile.rs
-expression: "compile_exec(\"\\\nfor stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n    with self.subTest(type=type(stop_exc)):\n        try:\n            async with woohoo():\n                raise stop_exc\n        except Exception as ex:\n            self.assertIs(ex, stop_exc)\n        else:\n            self.fail(f'{stop_exc} was suppressed')\n\")"
----
-  1           0 SetupLoop            (69)
-              1 LoadNameAny          (0, StopIteration)
-              2 LoadConst            ("spam")
-              3 CallFunctionPositional (1)
-              4 LoadNameAny          (1, StopAsyncIteration)
-              5 LoadConst            ("ham")
-              6 CallFunctionPositional (1)
-              7 BuildTuple           (2, false)
-              8 GetIter
-        >>    9 ForIter              (68)
-             10 StoreLocal           (2, stop_exc)
-
-  2          11 LoadNameAny          (3, self)
-             12 LoadMethod           (subTest)
-             13 LoadNameAny          (5, type)
-             14 LoadNameAny          (2, stop_exc)
-             15 CallFunctionPositional (1)
-             16 LoadConst            (("type"))
-             17 CallMethodKeyword    (1)
-             18 SetupWith            (65)
-             19 Pop
-
-  3          20 SetupExcept          (40)
-
-  4          21 LoadNameAny          (6, woohoo)
-             22 CallFunctionPositional (0)
-             23 BeforeAsyncWith
-             24 GetAwaitable
-             25 LoadConst            (None)
-             26 YieldFrom
-             27 SetupAsyncWith       (33)
-             28 Pop
-
-  5          29 LoadNameAny          (2, stop_exc)
-             30 Raise                (Raise)
-
-  4          31 PopBlock
-             32 EnterFinally
-        >>   33 WithCleanupStart
-             34 GetAwaitable
-             35 LoadConst            (None)
-             36 YieldFrom
-             37 WithCleanupFinish
-             38 PopBlock
-             39 Jump                 (54)
-        >>   40 Duplicate
-
-  6          41 LoadNameAny          (7, Exception)
-             42 TestOperation        (ExceptionMatch)
-             43 JumpIfFalse          (53)
-             44 StoreLocal           (8, ex)
-
-  7          45 LoadNameAny          (3, self)
-             46 LoadMethod           (assertIs)
-             47 LoadNameAny          (8, ex)
-             48 LoadNameAny          (2, stop_exc)
-             49 CallMethodPositional (2)
-             50 Pop
-             51 PopException
-             52 Jump                 (63)
-        >>   53 Raise                (Reraise)
-
-  9     >>   54 LoadNameAny          (3, self)
-             55 LoadMethod           (fail)
-             56 LoadConst            ("")
-
-  1          57 LoadNameAny          (2, stop_exc)
-             58 FormatValue          (None)
-
-  9          59 LoadConst            (" was suppressed")
-             60 BuildString          (2)
-             61 CallMethodPositional (1)
-             62 Pop
-
-  2     >>   63 PopBlock
-             64 EnterFinally
-        >>   65 WithCleanupStart
-             66 WithCleanupFinish
-             67 Jump                 (9)
-        >>   68 PopBlock
-        >>   69 LoadConst            (None)
-             70 ReturnValue
-
diff --git a/compiler/codegen/src/symboltable.rs b/compiler/codegen/src/symboltable.rs
deleted file mode 100644
index 2949f39a9f..0000000000
--- a/compiler/codegen/src/symboltable.rs
+++ /dev/null
@@ -1,1580 +0,0 @@
-/* Python code is pre-scanned for symbols in the ast.
-
-This ensures that global and nonlocal keywords are picked up.
-Then the compiler can use the symbol table to generate proper
-load and store instructions for names.
-
-Inspirational file: https://github.com/python/cpython/blob/main/Python/symtable.c
-*/
-
-use crate::{
-    IndexMap,
-    error::{CodegenError, CodegenErrorType},
-};
-use bitflags::bitflags;
-use ruff_python_ast::{
-    self as ast, Comprehension, Decorator, Expr, Identifier, ModExpression, ModModule, Parameter,
-    ParameterWithDefault, Parameters, Pattern, PatternMatchAs, PatternMatchClass,
-    PatternMatchMapping, PatternMatchOr, PatternMatchSequence, PatternMatchStar, PatternMatchValue,
-    Stmt, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams,
-};
-use ruff_text_size::{Ranged, TextRange};
-use rustpython_compiler_source::{SourceCode, SourceLocation};
-// use rustpython_ast::{self as ast, located::Located};
-// use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
-use std::{borrow::Cow, fmt};
-
-/// Captures all symbols in the current scope, and has a list of sub-scopes in this scope.
-#[derive(Clone)]
-pub struct SymbolTable {
-    /// The name of this symbol table. Often the name of the class or function.
-    pub name: String,
-
-    /// The type of symbol table
-    pub typ: SymbolTableType,
-
-    /// The line number in the source code where this symboltable begins.
-    pub line_number: u32,
-
-    // Return True if the block is a nested class or function
-    pub is_nested: bool,
-
-    /// A set of symbols present on this scope level.
-    pub symbols: IndexMap<String, Symbol>,
-
-    /// A list of sub-scopes in the order as found in the
-    /// AST nodes.
-    pub sub_tables: Vec<SymbolTable>,
-}
-
-impl SymbolTable {
-    fn new(name: String, typ: SymbolTableType, line_number: u32, is_nested: bool) -> Self {
-        Self {
-            name,
-            typ,
-            line_number,
-            is_nested,
-            symbols: IndexMap::default(),
-            sub_tables: vec![],
-        }
-    }
-
-    pub fn scan_program(
-        program: &ModModule,
-        source_code: SourceCode<'_>,
-    ) -> SymbolTableResult<Self> {
-        let mut builder = SymbolTableBuilder::new(source_code);
-        builder.scan_statements(program.body.as_ref())?;
-        builder.finish()
-    }
-
-    pub fn scan_expr(expr: &ModExpression, source_code: SourceCode<'_>) -> SymbolTableResult<Self> {
-        let mut builder = SymbolTableBuilder::new(source_code);
-        builder.scan_expression(expr.body.as_ref(), ExpressionContext::Load)?;
-        builder.finish()
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SymbolTableType {
-    Module,
-    Class,
-    Function,
-    Comprehension,
-    TypeParams,
-}
-
-impl fmt::Display for SymbolTableType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Module => write!(f, "module"),
-            Self::Class => write!(f, "class"),
-            Self::Function => write!(f, "function"),
-            Self::Comprehension => write!(f, "comprehension"),
-            Self::TypeParams => write!(f, "type parameter"),
-            // TODO missing types from the C implementation
-            // if self._table.type == _symtable.TYPE_ANNOTATION:
-            //     return "annotation"
-            // if self._table.type == _symtable.TYPE_TYPE_VAR_BOUND:
-            //     return "TypeVar bound"
-            // if self._table.type == _symtable.TYPE_TYPE_ALIAS:
-            //     return "type alias"
-        }
-    }
-}
-
-/// Indicator for a single symbol what the scope of this symbol is.
-/// The scope can be unknown, which is unfortunate, but not impossible.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SymbolScope {
-    Unknown,
-    Local,
-    GlobalExplicit,
-    GlobalImplicit,
-    Free,
-    Cell,
-}
-
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct SymbolFlags: u16 {
-        const REFERENCED = 0x001;
-        const ASSIGNED = 0x002;
-        const PARAMETER = 0x004;
-        const ANNOTATED = 0x008;
-        const IMPORTED = 0x010;
-        const NONLOCAL = 0x020;
-        // indicates if the symbol gets a value assigned by a named expression in a comprehension
-        // this is required to correct the scope in the analysis.
-        const ASSIGNED_IN_COMPREHENSION = 0x040;
-        // indicates that the symbol is used a bound iterator variable. We distinguish this case
-        // from normal assignment to detect disallowed re-assignment to iterator variables.
-        const ITER = 0x080;
-        /// indicates that the symbol is a free variable in a class method from the scope that the
-        /// class is defined in, e.g.:
-        /// ```python
-        /// def foo(x):
-        ///     class A:
-        ///         def method(self):
-        ///             return x // is_free_class
-        /// ```
-        const FREE_CLASS = 0x100;
-        const BOUND = Self::ASSIGNED.bits() | Self::PARAMETER.bits() | Self::IMPORTED.bits() | Self::ITER.bits();
-    }
-}
-
-/// A single symbol in a table. Has various properties such as the scope
-/// of the symbol, and also the various uses of the symbol.
-#[derive(Debug, Clone)]
-pub struct Symbol {
-    pub name: String,
-    pub scope: SymbolScope,
-    pub flags: SymbolFlags,
-}
-
-impl Symbol {
-    fn new(name: &str) -> Self {
-        Self {
-            name: name.to_owned(),
-            // table,
-            scope: SymbolScope::Unknown,
-            flags: SymbolFlags::empty(),
-        }
-    }
-
-    pub const fn is_global(&self) -> bool {
-        matches!(
-            self.scope,
-            SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit
-        )
-    }
-
-    pub const fn is_local(&self) -> bool {
-        matches!(self.scope, SymbolScope::Local | SymbolScope::Cell)
-    }
-
-    pub const fn is_bound(&self) -> bool {
-        self.flags.intersects(SymbolFlags::BOUND)
-    }
-}
-
-#[derive(Debug)]
-pub struct SymbolTableError {
-    error: String,
-    location: Option<SourceLocation>,
-}
-
-impl SymbolTableError {
-    pub fn into_codegen_error(self, source_path: String) -> CodegenError {
-        CodegenError {
-            location: self.location,
-            error: CodegenErrorType::SyntaxError(self.error),
-            source_path,
-        }
-    }
-}
-
-type SymbolTableResult<T = ()> = Result<T, SymbolTableError>;
-
-impl SymbolTable {
-    pub fn lookup(&self, name: &str) -> Option<&Symbol> {
-        self.symbols.get(name)
-    }
-}
-
-impl std::fmt::Debug for SymbolTable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "SymbolTable({:?} symbols, {:?} sub scopes)",
-            self.symbols.len(),
-            self.sub_tables.len()
-        )
-    }
-}
-
-/* Perform some sort of analysis on nonlocals, globals etc..
-  See also: https://github.com/python/cpython/blob/main/Python/symtable.c#L410
-*/
-fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
-    let mut analyzer = SymbolTableAnalyzer::default();
-    analyzer.analyze_symbol_table(symbol_table)
-}
-
-type SymbolMap = IndexMap<String, Symbol>;
-
-mod stack {
-    use std::panic;
-    use std::ptr::NonNull;
-    pub struct StackStack<T> {
-        v: Vec<NonNull<T>>,
-    }
-    impl<T> Default for StackStack<T> {
-        fn default() -> Self {
-            Self { v: Vec::new() }
-        }
-    }
-    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.
-        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)));
-            self.v.pop();
-            res.unwrap_or_else(|x| panic::resume_unwind(x))
-        }
-
-        pub fn iter(&self) -> impl DoubleEndedIterator<Item = &T> + '_ {
-            self.as_ref().iter().copied()
-        }
-        pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> + '_ {
-            self.as_mut().iter_mut().map(|x| &mut **x)
-        }
-        // pub fn top(&self) -> Option<&T> {
-        //     self.as_ref().last().copied()
-        // }
-        // pub fn top_mut(&mut self) -> Option<&mut T> {
-        //     self.as_mut().last_mut().map(|x| &mut **x)
-        // }
-        pub fn len(&self) -> usize {
-            self.v.len()
-        }
-        pub fn is_empty(&self) -> bool {
-            self.len() == 0
-        }
-
-        pub fn as_ref(&self) -> &[&T] {
-            unsafe { &*(self.v.as_slice() as *const [NonNull<T>] as *const [&T]) }
-        }
-
-        pub fn as_mut(&mut self) -> &mut [&mut T] {
-            unsafe { &mut *(self.v.as_mut_slice() as *mut [NonNull<T>] as *mut [&mut T]) }
-        }
-    }
-}
-use stack::StackStack;
-
-/// Symbol table analysis. Can be used to analyze a fully
-/// build symbol table structure. It will mark variables
-/// as local variables for example.
-#[derive(Default)]
-#[repr(transparent)]
-struct SymbolTableAnalyzer {
-    tables: StackStack<(SymbolMap, SymbolTableType)>,
-}
-
-impl SymbolTableAnalyzer {
-    fn analyze_symbol_table(&mut self, symbol_table: &mut SymbolTable) -> SymbolTableResult {
-        let symbols = std::mem::take(&mut symbol_table.symbols);
-        let sub_tables = &mut *symbol_table.sub_tables;
-
-        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:
-            for sub_table in sub_tables.iter_mut() {
-                inner_scope.analyze_symbol_table(sub_table)?;
-            }
-            Ok(())
-        })?;
-
-        symbol_table.symbols = info.0;
-
-        // Analyze symbols:
-        for symbol in symbol_table.symbols.values_mut() {
-            self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
-        }
-        Ok(())
-    }
-
-    fn analyze_symbol(
-        &mut self,
-        symbol: &mut Symbol,
-        st_typ: SymbolTableType,
-        sub_tables: &[SymbolTable],
-    ) -> SymbolTableResult {
-        if symbol
-            .flags
-            .contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
-            && st_typ == SymbolTableType::Comprehension
-        {
-            // propagate symbol to next higher level that can hold it,
-            // i.e., function or module. Comprehension is skipped and
-            // Class is not allowed and detected as error.
-            //symbol.scope = SymbolScope::Nonlocal;
-            self.analyze_symbol_comprehension(symbol, 0)?
-        } else {
-            match symbol.scope {
-                SymbolScope::Free => {
-                    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) != Some(SymbolScope::Free)
-                        {
-                            return Err(SymbolTableError {
-                                error: format!("no binding for nonlocal '{}' found", symbol.name),
-                                // TODO: accurate location info, somehow
-                                location: None,
-                            });
-                        }
-                    } else {
-                        return Err(SymbolTableError {
-                            error: format!(
-                                "nonlocal {} defined at place without an enclosing scope",
-                                symbol.name
-                            ),
-                            // TODO: accurate location info, somehow
-                            location: None,
-                        });
-                    }
-                }
-                SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit => {
-                    // TODO: add more checks for globals?
-                }
-                SymbolScope::Local | SymbolScope::Cell => {
-                    // all is well
-                }
-                SymbolScope::Unknown => {
-                    // 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) {
-                        scope
-                    } else if self.tables.is_empty() {
-                        // Don't make assumptions when we don't know.
-                        SymbolScope::Unknown
-                    } else {
-                        // If there are scopes above we assume global.
-                        SymbolScope::GlobalImplicit
-                    };
-                    symbol.scope = scope;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn found_in_outer_scope(&mut self, name: &str) -> Option<SymbolScope> {
-        let mut decl_depth = None;
-        for (i, (symbols, typ)) in self.tables.iter().rev().enumerate() {
-            if matches!(typ, SymbolTableType::Module)
-                || matches!(typ, SymbolTableType::Class if name != "__class__")
-            {
-                continue;
-            }
-            if let Some(sym) = symbols.get(name) {
-                match sym.scope {
-                    SymbolScope::GlobalExplicit => return Some(SymbolScope::GlobalExplicit),
-                    SymbolScope::GlobalImplicit => {}
-                    _ => {
-                        if sym.is_bound() {
-                            decl_depth = Some(i);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        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 (table, typ) in self.tables.iter_mut().rev().take(decl_depth) {
-                if let SymbolTableType::Class = typ {
-                    if let Some(free_class) = table.get_mut(name) {
-                        free_class.flags.insert(SymbolFlags::FREE_CLASS)
-                    } else {
-                        let mut symbol = Symbol::new(name);
-                        symbol.flags.insert(SymbolFlags::FREE_CLASS);
-                        symbol.scope = SymbolScope::Free;
-                        table.insert(name.to_owned(), symbol);
-                    }
-                } 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);
-                }
-            }
-        }
-
-        decl_depth.map(|_| SymbolScope::Free)
-    }
-
-    fn found_in_inner_scope(
-        &self,
-        sub_tables: &[SymbolTable],
-        name: &str,
-        st_typ: SymbolTableType,
-    ) -> Option<SymbolScope> {
-        sub_tables.iter().find_map(|st| {
-            let sym = st.symbols.get(name)?;
-            if sym.scope == SymbolScope::Free || sym.flags.contains(SymbolFlags::FREE_CLASS) {
-                if st_typ == SymbolTableType::Class && name != "__class__" {
-                    None
-                } else {
-                    Some(SymbolScope::Cell)
-                }
-            } else if sym.scope == SymbolScope::GlobalExplicit && self.tables.is_empty() {
-                // the symbol is defined on the module level, and an inner scope declares
-                // a global that points to it
-                Some(SymbolScope::GlobalExplicit)
-            } else {
-                None
-            }
-        })
-    }
-
-    // Implements the symbol analysis and scope extension for names
-    // assigned by a named expression in a comprehension. See:
-    // https://github.com/python/cpython/blob/7b78e7f9fd77bb3280ee39fb74b86772a7d46a70/Python/symtable.c#L1435
-    fn analyze_symbol_comprehension(
-        &mut self,
-        symbol: &mut Symbol,
-        parent_offset: usize,
-    ) -> SymbolTableResult {
-        // when this is called, we expect to be in the direct parent scope of the scope that contains 'symbol'
-        let last = self.tables.iter_mut().rev().nth(parent_offset).unwrap();
-        let symbols = &mut last.0;
-        let table_type = last.1;
-
-        // it is not allowed to use an iterator variable as assignee in a named expression
-        if symbol.flags.contains(SymbolFlags::ITER) {
-            return Err(SymbolTableError {
-                error: format!(
-                    "assignment expression cannot rebind comprehension iteration variable {}",
-                    symbol.name
-                ),
-                // TODO: accurate location info, somehow
-                location: None,
-            });
-        }
-
-        match table_type {
-            SymbolTableType::Module => {
-                symbol.scope = SymbolScope::GlobalImplicit;
-            }
-            SymbolTableType::Class => {
-                // named expressions are forbidden in comprehensions on class scope
-                return Err(SymbolTableError {
-                    error: "assignment expression within a comprehension cannot be used in a class body".to_string(),
-                    // TODO: accurate location info, somehow
-                    location: None,
-                });
-            }
-            SymbolTableType::Function => {
-                if let Some(parent_symbol) = symbols.get_mut(&symbol.name) {
-                    if let SymbolScope::Unknown = parent_symbol.scope {
-                        // this information is new, as the assignment is done in inner scope
-                        parent_symbol.flags.insert(SymbolFlags::ASSIGNED);
-                    }
-
-                    symbol.scope = if parent_symbol.is_global() {
-                        parent_symbol.scope
-                    } else {
-                        SymbolScope::Free
-                    };
-                } else {
-                    let mut cloned_sym = symbol.clone();
-                    cloned_sym.scope = SymbolScope::Cell;
-                    last.0.insert(cloned_sym.name.to_owned(), cloned_sym);
-                }
-            }
-            SymbolTableType::Comprehension => {
-                // TODO check for conflicts - requires more context information about variables
-                match symbols.get_mut(&symbol.name) {
-                    Some(parent_symbol) => {
-                        // check if assignee is an iterator in top scope
-                        if parent_symbol.flags.contains(SymbolFlags::ITER) {
-                            return Err(SymbolTableError {
-                                error: format!(
-                                    "assignment expression cannot rebind comprehension iteration variable {}",
-                                    symbol.name
-                                ),
-                                location: None,
-                            });
-                        }
-
-                        // we synthesize the assignment to the symbol from inner scope
-                        parent_symbol.flags.insert(SymbolFlags::ASSIGNED); // more checks are required
-                    }
-                    None => {
-                        // extend the scope of the inner symbol
-                        // as we are in a nested comprehension, we expect that the symbol is needed
-                        // outside, too, and set it therefore to non-local scope. I.e., we expect to
-                        // find a definition on a higher level
-                        let mut cloned_sym = symbol.clone();
-                        cloned_sym.scope = SymbolScope::Free;
-                        last.0.insert(cloned_sym.name.to_owned(), cloned_sym);
-                    }
-                }
-
-                self.analyze_symbol_comprehension(symbol, parent_offset + 1)?;
-            }
-            SymbolTableType::TypeParams => {
-                todo!("analyze symbol comprehension for type params");
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone)]
-enum SymbolUsage {
-    Global,
-    Nonlocal,
-    Used,
-    Assigned,
-    Imported,
-    AnnotationAssigned,
-    Parameter,
-    AnnotationParameter,
-    AssignedNamedExprInComprehension,
-    Iter,
-}
-
-struct SymbolTableBuilder<'src> {
-    class_name: Option<String>,
-    // Scope stack.
-    tables: Vec<SymbolTable>,
-    future_annotations: bool,
-    source_code: SourceCode<'src>,
-}
-
-/// Enum to indicate in what mode an expression
-/// was used.
-/// In cpython this is stored in the AST, but I think this
-/// is not logical, since it is not context free.
-#[derive(Copy, Clone, PartialEq)]
-enum ExpressionContext {
-    Load,
-    Store,
-    Delete,
-    Iter,
-    IterDefinitionExp,
-}
-
-impl<'src> SymbolTableBuilder<'src> {
-    fn new(source_code: SourceCode<'src>) -> Self {
-        let mut this = Self {
-            class_name: None,
-            tables: vec![],
-            future_annotations: false,
-            source_code,
-        };
-        this.enter_scope("top", SymbolTableType::Module, 0);
-        this
-    }
-}
-
-impl SymbolTableBuilder<'_> {
-    fn finish(mut self) -> Result<SymbolTable, SymbolTableError> {
-        assert_eq!(self.tables.len(), 1);
-        let mut symbol_table = self.tables.pop().unwrap();
-        analyze_symbol_table(&mut symbol_table)?;
-        Ok(symbol_table)
-    }
-
-    fn enter_scope(&mut self, name: &str, typ: SymbolTableType, line_number: u32) {
-        let is_nested = self
-            .tables
-            .last()
-            .map(|table| table.is_nested || table.typ == SymbolTableType::Function)
-            .unwrap_or(false);
-        let table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
-        self.tables.push(table);
-    }
-
-    /// Pop symbol table and add to sub table of parent table.
-    fn leave_scope(&mut self) {
-        let table = self.tables.pop().unwrap();
-        self.tables.last_mut().unwrap().sub_tables.push(table);
-    }
-
-    fn line_index_start(&self, range: TextRange) -> u32 {
-        self.source_code.line_index(range.start()).get() as _
-    }
-
-    fn scan_statements(&mut self, statements: &[Stmt]) -> SymbolTableResult {
-        for statement in statements {
-            self.scan_statement(statement)?;
-        }
-        Ok(())
-    }
-
-    fn scan_parameters(&mut self, parameters: &[ParameterWithDefault]) -> SymbolTableResult {
-        for parameter in parameters {
-            self.scan_parameter(&parameter.parameter)?;
-        }
-        Ok(())
-    }
-
-    fn scan_parameter(&mut self, parameter: &Parameter) -> SymbolTableResult {
-        let usage = if parameter.annotation.is_some() {
-            SymbolUsage::AnnotationParameter
-        } else {
-            SymbolUsage::Parameter
-        };
-        self.register_ident(&parameter.name, usage)
-    }
-
-    fn scan_annotation(&mut self, annotation: &Expr) -> SymbolTableResult {
-        if self.future_annotations {
-            Ok(())
-        } else {
-            self.scan_expression(annotation, ExpressionContext::Load)
-        }
-    }
-
-    fn scan_statement(&mut self, statement: &Stmt) -> SymbolTableResult {
-        use ruff_python_ast::*;
-        if let Stmt::ImportFrom(StmtImportFrom { module, names, .. }) = &statement {
-            if module.as_ref().map(|id| id.as_str()) == Some("__future__") {
-                for feature in names {
-                    if &feature.name == "annotations" {
-                        self.future_annotations = true;
-                    }
-                }
-            }
-        }
-        match &statement {
-            Stmt::Global(StmtGlobal { names, .. }) => {
-                for name in names {
-                    self.register_ident(name, SymbolUsage::Global)?;
-                }
-            }
-            Stmt::Nonlocal(StmtNonlocal { names, .. }) => {
-                for name in names {
-                    self.register_ident(name, SymbolUsage::Nonlocal)?;
-                }
-            }
-            Stmt::FunctionDef(StmtFunctionDef {
-                name,
-                body,
-                parameters,
-                decorator_list,
-                type_params,
-                returns,
-                range,
-                ..
-            }) => {
-                self.scan_decorators(decorator_list, ExpressionContext::Load)?;
-                self.register_ident(name, SymbolUsage::Assigned)?;
-                if let Some(expression) = returns {
-                    self.scan_annotation(expression)?;
-                }
-                if let Some(type_params) = type_params {
-                    self.enter_scope(
-                        &format!("<generic parameters of {}>", name.as_str()),
-                        SymbolTableType::TypeParams,
-                        // FIXME: line no
-                        self.line_index_start(*range),
-                    );
-                    self.scan_type_params(type_params)?;
-                }
-                self.enter_scope_with_parameters(
-                    name.as_str(),
-                    parameters,
-                    self.line_index_start(*range),
-                )?;
-                self.scan_statements(body)?;
-                self.leave_scope();
-                if type_params.is_some() {
-                    self.leave_scope();
-                }
-            }
-            Stmt::ClassDef(StmtClassDef {
-                name,
-                body,
-                arguments,
-                decorator_list,
-                type_params,
-                range,
-            }) => {
-                if let Some(type_params) = type_params {
-                    self.enter_scope(
-                        &format!("<generic parameters of {}>", name.as_str()),
-                        SymbolTableType::TypeParams,
-                        self.line_index_start(type_params.range),
-                    );
-                    self.scan_type_params(type_params)?;
-                }
-                self.enter_scope(
-                    name.as_str(),
-                    SymbolTableType::Class,
-                    self.line_index_start(*range),
-                );
-                let prev_class = self.class_name.replace(name.to_string());
-                self.register_name("__module__", SymbolUsage::Assigned, *range)?;
-                self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
-                self.register_name("__doc__", SymbolUsage::Assigned, *range)?;
-                self.register_name("__class__", SymbolUsage::Assigned, *range)?;
-                self.scan_statements(body)?;
-                self.leave_scope();
-                self.class_name = prev_class;
-                if let Some(arguments) = arguments {
-                    self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
-                    for keyword in &arguments.keywords {
-                        self.scan_expression(&keyword.value, ExpressionContext::Load)?;
-                    }
-                }
-                if type_params.is_some() {
-                    self.leave_scope();
-                }
-                self.scan_decorators(decorator_list, ExpressionContext::Load)?;
-                self.register_ident(name, SymbolUsage::Assigned)?;
-            }
-            Stmt::Expr(StmtExpr { value, .. }) => {
-                self.scan_expression(value, ExpressionContext::Load)?
-            }
-            Stmt::If(StmtIf {
-                test,
-                body,
-                elif_else_clauses,
-                ..
-            }) => {
-                self.scan_expression(test, ExpressionContext::Load)?;
-                self.scan_statements(body)?;
-                for elif in elif_else_clauses {
-                    if let Some(test) = &elif.test {
-                        self.scan_expression(test, ExpressionContext::Load)?;
-                    }
-                    self.scan_statements(&elif.body)?;
-                }
-            }
-            Stmt::For(StmtFor {
-                target,
-                iter,
-                body,
-                orelse,
-                ..
-            }) => {
-                self.scan_expression(target, ExpressionContext::Store)?;
-                self.scan_expression(iter, ExpressionContext::Load)?;
-                self.scan_statements(body)?;
-                self.scan_statements(orelse)?;
-            }
-            Stmt::While(StmtWhile {
-                test, body, orelse, ..
-            }) => {
-                self.scan_expression(test, ExpressionContext::Load)?;
-                self.scan_statements(body)?;
-                self.scan_statements(orelse)?;
-            }
-            Stmt::Break(_) | Stmt::Continue(_) | Stmt::Pass(_) => {
-                // No symbols here.
-            }
-            Stmt::Import(StmtImport { names, .. })
-            | Stmt::ImportFrom(StmtImportFrom { names, .. }) => {
-                for name in names {
-                    if let Some(alias) = &name.asname {
-                        // `import my_module as my_alias`
-                        self.register_ident(alias, SymbolUsage::Imported)?;
-                    } else {
-                        // `import module`
-                        self.register_name(
-                            name.name.split('.').next().unwrap(),
-                            SymbolUsage::Imported,
-                            name.name.range,
-                        )?;
-                    }
-                }
-            }
-            Stmt::Return(StmtReturn { value, .. }) => {
-                if let Some(expression) = value {
-                    self.scan_expression(expression, ExpressionContext::Load)?;
-                }
-            }
-            Stmt::Assert(StmtAssert { test, msg, .. }) => {
-                self.scan_expression(test, ExpressionContext::Load)?;
-                if let Some(expression) = msg {
-                    self.scan_expression(expression, ExpressionContext::Load)?;
-                }
-            }
-            Stmt::Delete(StmtDelete { targets, .. }) => {
-                self.scan_expressions(targets, ExpressionContext::Delete)?;
-            }
-            Stmt::Assign(StmtAssign { targets, value, .. }) => {
-                self.scan_expressions(targets, ExpressionContext::Store)?;
-                self.scan_expression(value, ExpressionContext::Load)?;
-            }
-            Stmt::AugAssign(StmtAugAssign { target, value, .. }) => {
-                self.scan_expression(target, ExpressionContext::Store)?;
-                self.scan_expression(value, ExpressionContext::Load)?;
-            }
-            Stmt::AnnAssign(StmtAnnAssign {
-                target,
-                annotation,
-                value,
-                simple,
-                range,
-            }) => {
-                // https://github.com/python/cpython/blob/main/Python/symtable.c#L1233
-                match &**target {
-                    Expr::Name(ast::ExprName { id, .. }) if *simple => {
-                        self.register_name(id.as_str(), SymbolUsage::AnnotationAssigned, *range)?;
-                    }
-                    _ => {
-                        self.scan_expression(target, ExpressionContext::Store)?;
-                    }
-                }
-                self.scan_annotation(annotation)?;
-                if let Some(value) = value {
-                    self.scan_expression(value, ExpressionContext::Load)?;
-                }
-            }
-            Stmt::With(StmtWith { items, body, .. }) => {
-                for item in items {
-                    self.scan_expression(&item.context_expr, ExpressionContext::Load)?;
-                    if let Some(expression) = &item.optional_vars {
-                        self.scan_expression(expression, ExpressionContext::Store)?;
-                    }
-                }
-                self.scan_statements(body)?;
-            }
-            Stmt::Try(StmtTry {
-                body,
-                handlers,
-                orelse,
-                finalbody,
-                ..
-            }) => {
-                self.scan_statements(body)?;
-                for handler in handlers {
-                    let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
-                        type_,
-                        name,
-                        body,
-                        ..
-                    }) = &handler;
-                    if let Some(expression) = type_ {
-                        self.scan_expression(expression, ExpressionContext::Load)?;
-                    }
-                    if let Some(name) = name {
-                        self.register_ident(name, SymbolUsage::Assigned)?;
-                    }
-                    self.scan_statements(body)?;
-                }
-                self.scan_statements(orelse)?;
-                self.scan_statements(finalbody)?;
-            }
-            Stmt::Match(StmtMatch { subject, cases, .. }) => {
-                self.scan_expression(subject, ExpressionContext::Load)?;
-                for case in cases {
-                    self.scan_pattern(&case.pattern)?;
-                    if let Some(guard) = &case.guard {
-                        self.scan_expression(guard, ExpressionContext::Load)?;
-                    }
-                    self.scan_statements(&case.body)?;
-                }
-            }
-            Stmt::Raise(StmtRaise { exc, cause, .. }) => {
-                if let Some(expression) = exc {
-                    self.scan_expression(expression, ExpressionContext::Load)?;
-                }
-                if let Some(expression) = cause {
-                    self.scan_expression(expression, ExpressionContext::Load)?;
-                }
-            }
-            Stmt::TypeAlias(StmtTypeAlias {
-                name,
-                value,
-                type_params,
-                ..
-            }) => {
-                if let Some(type_params) = type_params {
-                    self.enter_scope(
-                        // &name.to_string(),
-                        "TypeAlias",
-                        SymbolTableType::TypeParams,
-                        self.line_index_start(type_params.range),
-                    );
-                    self.scan_type_params(type_params)?;
-                    self.scan_expression(value, ExpressionContext::Load)?;
-                    self.leave_scope();
-                } else {
-                    self.scan_expression(value, ExpressionContext::Load)?;
-                }
-                self.scan_expression(name, ExpressionContext::Store)?;
-            }
-            Stmt::IpyEscapeCommand(_) => todo!(),
-        }
-        Ok(())
-    }
-
-    fn scan_decorators(
-        &mut self,
-        decorators: &[Decorator],
-        context: ExpressionContext,
-    ) -> SymbolTableResult {
-        for decorator in decorators {
-            self.scan_expression(&decorator.expression, context)?;
-        }
-        Ok(())
-    }
-
-    fn scan_expressions(
-        &mut self,
-        expressions: &[Expr],
-        context: ExpressionContext,
-    ) -> SymbolTableResult {
-        for expression in expressions {
-            self.scan_expression(expression, context)?;
-        }
-        Ok(())
-    }
-
-    fn scan_expression(
-        &mut self,
-        expression: &Expr,
-        context: ExpressionContext,
-    ) -> SymbolTableResult {
-        use ruff_python_ast::*;
-        match expression {
-            Expr::BinOp(ExprBinOp {
-                left,
-                right,
-                range: _,
-                ..
-            }) => {
-                self.scan_expression(left, context)?;
-                self.scan_expression(right, context)?;
-            }
-            Expr::BoolOp(ExprBoolOp {
-                values, range: _, ..
-            }) => {
-                self.scan_expressions(values, context)?;
-            }
-            Expr::Compare(ExprCompare {
-                left,
-                comparators,
-                range: _,
-                ..
-            }) => {
-                self.scan_expression(left, context)?;
-                self.scan_expressions(comparators, context)?;
-            }
-            Expr::Subscript(ExprSubscript {
-                value,
-                slice,
-                range: _,
-                ..
-            }) => {
-                self.scan_expression(value, ExpressionContext::Load)?;
-                self.scan_expression(slice, ExpressionContext::Load)?;
-            }
-            Expr::Attribute(ExprAttribute {
-                value, range: _, ..
-            }) => {
-                self.scan_expression(value, ExpressionContext::Load)?;
-            }
-            Expr::Dict(ExprDict { items, range: _ }) => {
-                for item in items {
-                    if let Some(key) = &item.key {
-                        self.scan_expression(key, context)?;
-                    }
-                    self.scan_expression(&item.value, context)?;
-                }
-            }
-            Expr::Await(ExprAwait { value, range: _ }) => {
-                self.scan_expression(value, context)?;
-            }
-            Expr::Yield(ExprYield { value, range: _ }) => {
-                if let Some(expression) = value {
-                    self.scan_expression(expression, context)?;
-                }
-            }
-            Expr::YieldFrom(ExprYieldFrom { value, range: _ }) => {
-                self.scan_expression(value, context)?;
-            }
-            Expr::UnaryOp(ExprUnaryOp {
-                operand, range: _, ..
-            }) => {
-                self.scan_expression(operand, context)?;
-            }
-            Expr::Starred(ExprStarred {
-                value, range: _, ..
-            }) => {
-                self.scan_expression(value, context)?;
-            }
-            Expr::Tuple(ExprTuple { elts, range: _, .. })
-            | Expr::Set(ExprSet { elts, range: _, .. })
-            | Expr::List(ExprList { elts, range: _, .. }) => {
-                self.scan_expressions(elts, context)?;
-            }
-            Expr::Slice(ExprSlice {
-                lower,
-                upper,
-                step,
-                range: _,
-            }) => {
-                if let Some(lower) = lower {
-                    self.scan_expression(lower, context)?;
-                }
-                if let Some(upper) = upper {
-                    self.scan_expression(upper, context)?;
-                }
-                if let Some(step) = step {
-                    self.scan_expression(step, context)?;
-                }
-            }
-            Expr::Generator(ExprGenerator {
-                elt,
-                generators,
-                range,
-                ..
-            }) => {
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
-            }
-            Expr::ListComp(ExprListComp {
-                elt,
-                generators,
-                range,
-            }) => {
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
-            }
-            Expr::SetComp(ExprSetComp {
-                elt,
-                generators,
-                range,
-            }) => {
-                self.scan_comprehension("genexpr", elt, None, generators, *range)?;
-            }
-            Expr::DictComp(ExprDictComp {
-                key,
-                value,
-                generators,
-                range,
-            }) => {
-                self.scan_comprehension("genexpr", key, Some(value), generators, *range)?;
-            }
-            Expr::Call(ExprCall {
-                func,
-                arguments,
-                range: _,
-            }) => {
-                match context {
-                    ExpressionContext::IterDefinitionExp => {
-                        self.scan_expression(func, ExpressionContext::IterDefinitionExp)?;
-                    }
-                    _ => {
-                        self.scan_expression(func, ExpressionContext::Load)?;
-                    }
-                }
-
-                self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
-                for keyword in &arguments.keywords {
-                    self.scan_expression(&keyword.value, ExpressionContext::Load)?;
-                }
-            }
-            Expr::Name(ExprName { id, range, .. }) => {
-                let id = id.as_str();
-                // Determine the contextual usage of this symbol:
-                match context {
-                    ExpressionContext::Delete => {
-                        self.register_name(id, SymbolUsage::Assigned, *range)?;
-                        self.register_name(id, SymbolUsage::Used, *range)?;
-                    }
-                    ExpressionContext::Load | ExpressionContext::IterDefinitionExp => {
-                        self.register_name(id, SymbolUsage::Used, *range)?;
-                    }
-                    ExpressionContext::Store => {
-                        self.register_name(id, SymbolUsage::Assigned, *range)?;
-                    }
-                    ExpressionContext::Iter => {
-                        self.register_name(id, SymbolUsage::Iter, *range)?;
-                    }
-                }
-                // Interesting stuff about the __class__ variable:
-                // https://docs.python.org/3/reference/datamodel.html?highlight=__class__#creating-the-class-object
-                if context == ExpressionContext::Load
-                    && self.tables.last().unwrap().typ == SymbolTableType::Function
-                    && id == "super"
-                {
-                    self.register_name("__class__", SymbolUsage::Used, *range)?;
-                }
-            }
-            Expr::Lambda(ExprLambda {
-                body,
-                parameters,
-                range: _,
-            }) => {
-                if let Some(parameters) = parameters {
-                    self.enter_scope_with_parameters(
-                        "lambda",
-                        parameters,
-                        self.line_index_start(expression.range()),
-                    )?;
-                } else {
-                    self.enter_scope(
-                        "lambda",
-                        SymbolTableType::Function,
-                        self.line_index_start(expression.range()),
-                    );
-                }
-                match context {
-                    ExpressionContext::IterDefinitionExp => {
-                        self.scan_expression(body, ExpressionContext::IterDefinitionExp)?;
-                    }
-                    _ => {
-                        self.scan_expression(body, ExpressionContext::Load)?;
-                    }
-                }
-                self.leave_scope();
-            }
-            Expr::FString(ExprFString { value, .. }) => {
-                for expr in value.elements().filter_map(|x| x.as_expression()) {
-                    self.scan_expression(&expr.expression, ExpressionContext::Load)?;
-                    if let Some(format_spec) = &expr.format_spec {
-                        for element in format_spec.elements.expressions() {
-                            self.scan_expression(&element.expression, ExpressionContext::Load)?
-                        }
-                    }
-                }
-            }
-            // Constants
-            Expr::StringLiteral(_)
-            | Expr::BytesLiteral(_)
-            | Expr::NumberLiteral(_)
-            | Expr::BooleanLiteral(_)
-            | Expr::NoneLiteral(_)
-            | Expr::EllipsisLiteral(_) => {}
-            Expr::IpyEscapeCommand(_) => todo!(),
-            Expr::If(ExprIf {
-                test,
-                body,
-                orelse,
-                range: _,
-            }) => {
-                self.scan_expression(test, ExpressionContext::Load)?;
-                self.scan_expression(body, ExpressionContext::Load)?;
-                self.scan_expression(orelse, ExpressionContext::Load)?;
-            }
-
-            Expr::Named(ExprNamed {
-                target,
-                value,
-                range,
-            }) => {
-                // named expressions are not allowed in the definition of
-                // comprehension iterator definitions
-                if let ExpressionContext::IterDefinitionExp = context {
-                    return Err(SymbolTableError {
-                          error: "assignment expression cannot be used in a comprehension iterable expression".to_string(),
-                          location: Some(self.source_code.source_location(target.range().start())),
-                      });
-                }
-
-                self.scan_expression(value, ExpressionContext::Load)?;
-
-                // special handling for assigned identifier in named expressions
-                // that are used in comprehensions. This required to correctly
-                // propagate the scope of the named assigned named and not to
-                // propagate inner names.
-                if let Expr::Name(ExprName { id, .. }) = &**target {
-                    let id = id.as_str();
-                    let table = self.tables.last().unwrap();
-                    if table.typ == SymbolTableType::Comprehension {
-                        self.register_name(
-                            id,
-                            SymbolUsage::AssignedNamedExprInComprehension,
-                            *range,
-                        )?;
-                    } else {
-                        // omit one recursion. When the handling of an store changes for
-                        // Identifiers this needs adapted - more forward safe would be
-                        // calling scan_expression directly.
-                        self.register_name(id, SymbolUsage::Assigned, *range)?;
-                    }
-                } else {
-                    self.scan_expression(target, ExpressionContext::Store)?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn scan_comprehension(
-        &mut self,
-        scope_name: &str,
-        elt1: &Expr,
-        elt2: Option<&Expr>,
-        generators: &[Comprehension],
-        range: TextRange,
-    ) -> SymbolTableResult {
-        // Comprehensions are compiled as functions, so create a scope for them:
-        self.enter_scope(
-            scope_name,
-            SymbolTableType::Comprehension,
-            self.line_index_start(range),
-        );
-
-        // Register the passed argument to the generator function as the name ".0"
-        self.register_name(".0", SymbolUsage::Parameter, range)?;
-
-        self.scan_expression(elt1, ExpressionContext::Load)?;
-        if let Some(elt2) = elt2 {
-            self.scan_expression(elt2, ExpressionContext::Load)?;
-        }
-
-        let mut is_first_generator = true;
-        for generator in generators {
-            self.scan_expression(&generator.target, ExpressionContext::Iter)?;
-            if is_first_generator {
-                is_first_generator = false;
-            } else {
-                self.scan_expression(&generator.iter, ExpressionContext::IterDefinitionExp)?;
-            }
-
-            for if_expr in &generator.ifs {
-                self.scan_expression(if_expr, ExpressionContext::Load)?;
-            }
-        }
-
-        self.leave_scope();
-
-        // The first iterable is passed as an argument into the created function:
-        assert!(!generators.is_empty());
-        self.scan_expression(&generators[0].iter, ExpressionContext::IterDefinitionExp)?;
-
-        Ok(())
-    }
-
-    fn scan_type_params(&mut self, type_params: &TypeParams) -> SymbolTableResult {
-        // First register all type parameters
-        for type_param in &type_params.type_params {
-            match type_param {
-                TypeParam::TypeVar(TypeParamTypeVar {
-                    name,
-                    bound,
-                    range: type_var_range,
-                    ..
-                }) => {
-                    self.register_name(name.as_str(), SymbolUsage::Assigned, *type_var_range)?;
-                    if let Some(binding) = bound {
-                        self.scan_expression(binding, ExpressionContext::Load)?;
-                    }
-                }
-                TypeParam::ParamSpec(TypeParamParamSpec {
-                    name,
-                    range: param_spec_range,
-                    ..
-                }) => {
-                    self.register_name(name, SymbolUsage::Assigned, *param_spec_range)?;
-                }
-                TypeParam::TypeVarTuple(TypeParamTypeVarTuple {
-                    name,
-                    range: type_var_tuple_range,
-                    ..
-                }) => {
-                    self.register_name(name, SymbolUsage::Assigned, *type_var_tuple_range)?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    fn scan_patterns(&mut self, patterns: &[Pattern]) -> SymbolTableResult {
-        for pattern in patterns {
-            self.scan_pattern(pattern)?;
-        }
-        Ok(())
-    }
-
-    fn scan_pattern(&mut self, pattern: &Pattern) -> SymbolTableResult {
-        use Pattern::*;
-        match pattern {
-            MatchValue(PatternMatchValue { value, .. }) => {
-                self.scan_expression(value, ExpressionContext::Load)?
-            }
-            MatchSingleton(_) => {}
-            MatchSequence(PatternMatchSequence { patterns, .. }) => self.scan_patterns(patterns)?,
-            MatchMapping(PatternMatchMapping {
-                keys,
-                patterns,
-                rest,
-                ..
-            }) => {
-                self.scan_expressions(keys, ExpressionContext::Load)?;
-                self.scan_patterns(patterns)?;
-                if let Some(rest) = rest {
-                    self.register_ident(rest, SymbolUsage::Assigned)?;
-                }
-            }
-            MatchClass(PatternMatchClass { cls, arguments, .. }) => {
-                self.scan_expression(cls, ExpressionContext::Load)?;
-                self.scan_patterns(&arguments.patterns)?;
-                for kw in &arguments.keywords {
-                    self.scan_pattern(&kw.pattern)?;
-                }
-            }
-            MatchStar(PatternMatchStar { name, .. }) => {
-                if let Some(name) = name {
-                    self.register_ident(name, SymbolUsage::Assigned)?;
-                }
-            }
-            MatchAs(PatternMatchAs { pattern, name, .. }) => {
-                if let Some(pattern) = pattern {
-                    self.scan_pattern(pattern)?;
-                }
-                if let Some(name) = name {
-                    self.register_ident(name, SymbolUsage::Assigned)?;
-                }
-            }
-            MatchOr(PatternMatchOr { patterns, .. }) => self.scan_patterns(patterns)?,
-        }
-        Ok(())
-    }
-
-    fn enter_scope_with_parameters(
-        &mut self,
-        name: &str,
-        parameters: &Parameters,
-        line_number: u32,
-    ) -> 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?
-        }
-
-        // Annotations are scanned in outer scope:
-        for annotation in parameters
-            .posonlyargs
-            .iter()
-            .chain(parameters.args.iter())
-            .chain(parameters.kwonlyargs.iter())
-            .filter_map(|arg| arg.parameter.annotation.as_ref())
-        {
-            self.scan_annotation(annotation)?;
-        }
-        if let Some(annotation) = parameters
-            .vararg
-            .as_ref()
-            .and_then(|arg| arg.annotation.as_ref())
-        {
-            self.scan_annotation(annotation)?;
-        }
-        if let Some(annotation) = parameters
-            .kwarg
-            .as_ref()
-            .and_then(|arg| arg.annotation.as_ref())
-        {
-            self.scan_annotation(annotation)?;
-        }
-
-        self.enter_scope(name, SymbolTableType::Function, line_number);
-
-        // Fill scope with parameter names:
-        self.scan_parameters(&parameters.posonlyargs)?;
-        self.scan_parameters(&parameters.args)?;
-        self.scan_parameters(&parameters.kwonlyargs)?;
-        if let Some(name) = &parameters.vararg {
-            self.scan_parameter(name)?;
-        }
-        if let Some(name) = &parameters.kwarg {
-            self.scan_parameter(name)?;
-        }
-        Ok(())
-    }
-
-    fn register_ident(&mut self, ident: &Identifier, role: SymbolUsage) -> SymbolTableResult {
-        self.register_name(ident.as_str(), role, ident.range)
-    }
-
-    fn register_name(
-        &mut self,
-        name: &str,
-        role: SymbolUsage,
-        range: TextRange,
-    ) -> SymbolTableResult {
-        let location = self.source_code.source_location(range.start());
-        let location = Some(location);
-        let scope_depth = self.tables.len();
-        let table = self.tables.last_mut().unwrap();
-
-        let name = mangle_name(self.class_name.as_deref(), 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;
-            // Role already set..
-            match role {
-                SymbolUsage::Global if !symbol.is_global() => {
-                    if flags.contains(SymbolFlags::PARAMETER) {
-                        return Err(SymbolTableError {
-                            error: format!("name '{name}' is parameter and global"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::REFERENCED) {
-                        return Err(SymbolTableError {
-                            error: format!("name '{name}' is used prior to global declaration"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::ANNOTATED) {
-                        return Err(SymbolTableError {
-                            error: format!("annotated name '{name}' can't be global"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::ASSIGNED) {
-                        return Err(SymbolTableError {
-                            error: format!(
-                                "name '{name}' is assigned to before global declaration"
-                            ),
-                            location,
-                        });
-                    }
-                }
-                SymbolUsage::Nonlocal => {
-                    if flags.contains(SymbolFlags::PARAMETER) {
-                        return Err(SymbolTableError {
-                            error: format!("name '{name}' is parameter and nonlocal"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::REFERENCED) {
-                        return Err(SymbolTableError {
-                            error: format!("name '{name}' is used prior to nonlocal declaration"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::ANNOTATED) {
-                        return Err(SymbolTableError {
-                            error: format!("annotated name '{name}' can't be nonlocal"),
-                            location,
-                        });
-                    }
-                    if flags.contains(SymbolFlags::ASSIGNED) {
-                        return Err(SymbolTableError {
-                            error: format!(
-                                "name '{name}' is assigned to before nonlocal declaration"
-                            ),
-                            location,
-                        });
-                    }
-                }
-                _ => {
-                    // Ok?
-                }
-            }
-            symbol
-        } else {
-            // The symbol does not present on this scope level.
-            // Some checks to insert new symbol into symbol table:
-            match role {
-                SymbolUsage::Nonlocal if scope_depth < 2 => {
-                    return Err(SymbolTableError {
-                        error: format!("cannot define nonlocal '{name}' at top level."),
-                        location,
-                    });
-                }
-                _ => {
-                    // Ok!
-                }
-            }
-            // Insert symbol when required:
-            let symbol = Symbol::new(name.as_ref());
-            table.symbols.entry(name.into_owned()).or_insert(symbol)
-        };
-
-        // Set proper scope and flags on symbol:
-        let flags = &mut symbol.flags;
-        match role {
-            SymbolUsage::Nonlocal => {
-                symbol.scope = SymbolScope::Free;
-                flags.insert(SymbolFlags::NONLOCAL);
-            }
-            SymbolUsage::Imported => {
-                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::IMPORTED);
-            }
-            SymbolUsage::Parameter => {
-                flags.insert(SymbolFlags::PARAMETER);
-            }
-            SymbolUsage::AnnotationParameter => {
-                flags.insert(SymbolFlags::PARAMETER | SymbolFlags::ANNOTATED);
-            }
-            SymbolUsage::AnnotationAssigned => {
-                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::ANNOTATED);
-            }
-            SymbolUsage::Assigned => {
-                flags.insert(SymbolFlags::ASSIGNED);
-            }
-            SymbolUsage::AssignedNamedExprInComprehension => {
-                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::ASSIGNED_IN_COMPREHENSION);
-            }
-            SymbolUsage::Global => {
-                symbol.scope = SymbolScope::GlobalExplicit;
-            }
-            SymbolUsage::Used => {
-                flags.insert(SymbolFlags::REFERENCED);
-            }
-            SymbolUsage::Iter => {
-                flags.insert(SymbolFlags::ITER);
-            }
-        }
-
-        // and even more checking
-        // it is not allowed to assign to iterator variables (by named expressions)
-        if flags.contains(SymbolFlags::ITER | SymbolFlags::ASSIGNED)
-        /*&& symbol.is_assign_named_expr_in_comprehension*/
-        {
-            return Err(SymbolTableError {
-                error:
-                    "assignment expression cannot be used in a comprehension iterable expression"
-                        .to_string(),
-                location,
-            });
-        }
-        Ok(())
-    }
-}
-
-pub(crate) fn mangle_name<'a>(class_name: Option<&str>, name: &'a str) -> Cow<'a, str> {
-    let class_name = match class_name {
-        Some(n) => n,
-        None => return name.into(),
-    };
-    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);
-    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()
-}
diff --git a/compiler/core/Cargo.toml b/compiler/core/Cargo.toml
deleted file mode 100644
index 837f9e4866..0000000000
--- a/compiler/core/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
-[package]
-name = "rustpython-compiler-core"
-description = "RustPython specific bytecode."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-# rustpython-parser-core = { workspace = true, features=["location"] }
-ruff_source_file = { workspace = true }
-rustpython-wtf8 = { workspace = true }
-
-bitflags = { workspace = true }
-itertools = { workspace = true }
-malachite-bigint = { workspace = true }
-num-complex = { workspace = true }
-serde = { workspace = true, optional = true, default-features = false, features = ["derive"] }
-
-lz4_flex = "0.11"
-
-[lints]
-workspace = true
\ No newline at end of file
diff --git a/compiler/core/src/bytecode.rs b/compiler/core/src/bytecode.rs
deleted file mode 100644
index be55fe3502..0000000000
--- a/compiler/core/src/bytecode.rs
+++ /dev/null
@@ -1,1617 +0,0 @@
-//! Implement python as a virtual machine with bytecode. This module
-//! implements bytecode structure.
-
-use bitflags::bitflags;
-use itertools::Itertools;
-use malachite_bigint::BigInt;
-use num_complex::Complex64;
-use ruff_source_file::{OneIndexed, SourceLocation};
-use rustpython_wtf8::{Wtf8, Wtf8Buf};
-use std::marker::PhantomData;
-use std::{collections::BTreeSet, fmt, hash, mem};
-
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-#[repr(i8)]
-#[allow(clippy::cast_possible_wrap)]
-pub enum ConversionFlag {
-    /// No conversion
-    None = -1, // CPython uses -1
-    /// Converts by calling `str(<value>)`.
-    Str = b's' as i8,
-    /// Converts by calling `ascii(<value>)`.
-    Ascii = b'a' as i8,
-    /// Converts by calling `repr(<value>)`.
-    Repr = b'r' as i8,
-}
-
-pub trait Constant: Sized {
-    type Name: AsRef<str>;
-
-    /// Transforms the given Constant to a BorrowedConstant
-    fn borrow_constant(&self) -> BorrowedConstant<'_, Self>;
-}
-
-impl Constant for ConstantData {
-    type Name = String;
-    fn borrow_constant(&self) -> BorrowedConstant<'_, Self> {
-        use BorrowedConstant::*;
-        match self {
-            Self::Integer { value } => Integer { value },
-            Self::Float { value } => Float { value: *value },
-            Self::Complex { value } => Complex { value: *value },
-            Self::Boolean { value } => Boolean { value: *value },
-            Self::Str { value } => Str { value },
-            Self::Bytes { value } => Bytes { value },
-            Self::Code { code } => Code { code },
-            Self::Tuple { elements } => Tuple { elements },
-            Self::None => None,
-            Self::Ellipsis => Ellipsis,
-        }
-    }
-}
-
-/// A Constant Bag
-pub trait ConstantBag: Sized + Copy {
-    type Constant: Constant;
-    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant;
-    fn make_int(&self, value: BigInt) -> Self::Constant;
-    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant;
-    fn make_code(&self, code: CodeObject<Self::Constant>) -> Self::Constant;
-    fn make_name(&self, name: &str) -> <Self::Constant as Constant>::Name;
-}
-
-pub trait AsBag {
-    type Bag: ConstantBag;
-    #[allow(clippy::wrong_self_convention)]
-    fn as_bag(self) -> Self::Bag;
-}
-
-impl<Bag: ConstantBag> AsBag for Bag {
-    type Bag = Self;
-    fn as_bag(self) -> Self {
-        self
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct BasicBag;
-
-impl ConstantBag for BasicBag {
-    type Constant = ConstantData;
-    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {
-        constant.to_owned()
-    }
-    fn make_int(&self, value: BigInt) -> Self::Constant {
-        ConstantData::Integer { value }
-    }
-    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {
-        ConstantData::Tuple {
-            elements: elements.collect(),
-        }
-    }
-    fn make_code(&self, code: CodeObject<Self::Constant>) -> Self::Constant {
-        ConstantData::Code {
-            code: Box::new(code),
-        }
-    }
-    fn make_name(&self, name: &str) -> <Self::Constant as Constant>::Name {
-        name.to_owned()
-    }
-}
-
-/// Primary container of a single code object. Each python function has
-/// a code object. Also a module has a code object.
-#[derive(Clone)]
-pub struct CodeObject<C: Constant = ConstantData> {
-    pub instructions: Box<[CodeUnit]>,
-    pub locations: Box<[SourceLocation]>,
-    pub flags: CodeFlags,
-    pub posonlyarg_count: u32,
-    // Number of positional-only arguments
-    pub arg_count: u32,
-    pub kwonlyarg_count: u32,
-    pub source_path: C::Name,
-    pub first_line_number: Option<OneIndexed>,
-    pub max_stackdepth: u32,
-    pub obj_name: C::Name,
-    // Name of the object that created this code object
-    pub cell2arg: Option<Box<[i32]>>,
-    pub constants: Box<[C]>,
-    pub names: Box<[C::Name]>,
-    pub varnames: Box<[C::Name]>,
-    pub cellvars: Box<[C::Name]>,
-    pub freevars: Box<[C::Name]>,
-}
-
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct CodeFlags: u16 {
-        const NEW_LOCALS = 0x01;
-        const IS_GENERATOR = 0x02;
-        const IS_COROUTINE = 0x04;
-        const HAS_VARARGS = 0x08;
-        const HAS_VARKEYWORDS = 0x10;
-        const IS_OPTIMIZED = 0x20;
-    }
-}
-
-impl CodeFlags {
-    pub const NAME_MAPPING: &'static [(&'static str, Self)] = &[
-        ("GENERATOR", Self::IS_GENERATOR),
-        ("COROUTINE", Self::IS_COROUTINE),
-        (
-            "ASYNC_GENERATOR",
-            Self::from_bits_truncate(Self::IS_GENERATOR.bits() | Self::IS_COROUTINE.bits()),
-        ),
-        ("VARARGS", Self::HAS_VARARGS),
-        ("VARKEYWORDS", Self::HAS_VARKEYWORDS),
-    ];
-}
-
-/// an opcode argument that may be extended by a prior ExtendedArg
-#[derive(Copy, Clone, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct OpArgByte(pub u8);
-impl OpArgByte {
-    pub const fn null() -> Self {
-        Self(0)
-    }
-}
-impl fmt::Debug for OpArgByte {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-/// a full 32-bit op_arg, including any possible ExtendedArg extension
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)]
-pub struct OpArg(pub u32);
-impl OpArg {
-    pub const fn null() -> Self {
-        Self(0)
-    }
-
-    /// Returns how many CodeUnits a instruction with this op_arg will be encoded as
-    #[inline]
-    pub fn instr_size(self) -> usize {
-        (self.0 > 0xff) as usize + (self.0 > 0xff_ff) as usize + (self.0 > 0xff_ff_ff) as usize + 1
-    }
-
-    /// returns the arg split into any necessary ExtendedArg components (in big-endian order) and
-    /// the arg for the real opcode itself
-    #[inline(always)]
-    pub fn split(self) -> (impl ExactSizeIterator<Item = OpArgByte>, OpArgByte) {
-        let mut it = self
-            .0
-            .to_le_bytes()
-            .map(OpArgByte)
-            .into_iter()
-            .take(self.instr_size());
-        let lo = it.next().unwrap();
-        (it.rev(), lo)
-    }
-}
-
-#[derive(Default, Copy, Clone)]
-#[repr(transparent)]
-pub struct OpArgState {
-    state: u32,
-}
-
-impl OpArgState {
-    #[inline(always)]
-    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
-        let arg = self.extend(ins.arg);
-        if ins.op != Instruction::ExtendedArg {
-            self.reset();
-        }
-        (ins.op, arg)
-    }
-    #[inline(always)]
-    pub fn extend(&mut self, arg: OpArgByte) -> OpArg {
-        self.state = (self.state << 8) | u32::from(arg.0);
-        OpArg(self.state)
-    }
-    #[inline(always)]
-    pub fn reset(&mut self) {
-        self.state = 0
-    }
-}
-
-pub trait OpArgType: Copy {
-    fn from_op_arg(x: u32) -> Option<Self>;
-    fn to_op_arg(self) -> u32;
-}
-
-impl OpArgType for u32 {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(x)
-    }
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self
-    }
-}
-
-impl OpArgType for bool {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(x != 0)
-    }
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self as u32
-    }
-}
-
-macro_rules! op_arg_enum_impl {
-    (enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        impl OpArgType for $name {
-            fn to_op_arg(self) -> u32 {
-                self as u32
-            }
-            fn from_op_arg(x: u32) -> Option<Self> {
-                Some(match u8::try_from(x).ok()? {
-                    $($value => Self::$var,)*
-                    _ => return None,
-                })
-            }
-        }
-    };
-}
-
-macro_rules! op_arg_enum {
-    ($(#[$attr:meta])* $vis:vis enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
-        $(#[$attr])*
-        $vis enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        }
-
-        op_arg_enum_impl!(enum $name {
-            $($(#[$var_attr])* $var = $value,)*
-        });
-    };
-}
-
-#[derive(Copy, Clone)]
-pub struct Arg<T: OpArgType>(PhantomData<T>);
-
-impl<T: OpArgType> Arg<T> {
-    #[inline]
-    pub fn marker() -> Self {
-        Self(PhantomData)
-    }
-    #[inline]
-    pub fn new(arg: T) -> (Self, OpArg) {
-        (Self(PhantomData), OpArg(arg.to_op_arg()))
-    }
-    #[inline]
-    pub fn new_single(arg: T) -> (Self, OpArgByte)
-    where
-        T: Into<u8>,
-    {
-        (Self(PhantomData), OpArgByte(arg.into()))
-    }
-    #[inline(always)]
-    pub fn get(self, arg: OpArg) -> T {
-        self.try_get(arg).unwrap()
-    }
-    #[inline(always)]
-    pub fn try_get(self, arg: OpArg) -> Option<T> {
-        T::from_op_arg(arg.0)
-    }
-    #[inline(always)]
-    /// # Safety
-    /// T::from_op_arg(self) must succeed
-    pub unsafe fn get_unchecked(self, arg: OpArg) -> T {
-        // SAFETY: requirements forwarded from caller
-        unsafe { T::from_op_arg(arg.0).unwrap_unchecked() }
-    }
-}
-
-impl<T: OpArgType> PartialEq for Arg<T> {
-    fn eq(&self, _: &Self) -> bool {
-        true
-    }
-}
-impl<T: OpArgType> Eq for Arg<T> {}
-
-impl<T: OpArgType> fmt::Debug for Arg<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Arg<{}>", std::any::type_name::<T>())
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
-#[repr(transparent)]
-// XXX: if you add a new instruction that stores a Label, make sure to add it in
-// Instruction::label_arg
-pub struct Label(pub u32);
-
-impl OpArgType for Label {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Some(Self(x))
-    }
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.0
-    }
-}
-
-impl fmt::Display for Label {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl OpArgType for ConversionFlag {
-    #[inline]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        match x as u8 {
-            b's' => Some(Self::Str),
-            b'a' => Some(Self::Ascii),
-            b'r' => Some(Self::Repr),
-            std::u8::MAX => Some(Self::None),
-            _ => None,
-        }
-    }
-    #[inline]
-    fn to_op_arg(self) -> u32 {
-        self as i8 as u8 as u32
-    }
-}
-
-op_arg_enum!(
-    /// The kind of Raise that occurred.
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum RaiseKind {
-        Reraise = 0,
-        Raise = 1,
-        RaiseCause = 2,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_1
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction1 {
-        /// Import * special case
-        // ImportStar = 0,
-        /// Set stop iteration value
-        // StopAsyncIteration = 1,
-        /// Unary operators
-        // UnaryPositive = 2,
-        // UnaryNegative = 3,
-        // UnaryNot = 4,
-        // UnaryInvert = 5,
-        /// Exit init subclass
-        // ExitInitCheck = 6,
-        /// Create a new list from an iterator
-        // ListToTupleForCall = 7,
-        /// Type parameter related
-        // TypeVar = 8,
-        // TypeVarTuple = 9,
-        // ParamSpec = 10,
-        /// Generic subscript for PEP 695
-        SubscriptGeneric = 10,
-        // TypeAlias = 12,
-        // TypeParams = 13,
-    }
-);
-
-op_arg_enum!(
-    /// Intrinsic function for CALL_INTRINSIC_2
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum IntrinsicFunction2 {
-        // PrepReraiseS tar = 1,
-        // TypeVarWithBound = 2,
-        // TypeVarWithConstraints = 3,
-        // SetFunctionTypeParams = 4,
-        /// Set default value for type parameter (PEP 695)
-        SetTypeparamDefault = 5,
-    }
-);
-
-pub type NameIdx = u32;
-
-/// A Single bytecode instruction.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-#[repr(u8)]
-pub enum Instruction {
-    Nop,
-    /// Importing by name
-    ImportName {
-        idx: Arg<NameIdx>,
-    },
-    /// Importing without name
-    ImportNameless,
-    /// Import *
-    ImportStar,
-    /// from ... import ...
-    ImportFrom {
-        idx: Arg<NameIdx>,
-    },
-    LoadFast(Arg<NameIdx>),
-    LoadNameAny(Arg<NameIdx>),
-    LoadGlobal(Arg<NameIdx>),
-    LoadDeref(Arg<NameIdx>),
-    LoadClassDeref(Arg<NameIdx>),
-    StoreFast(Arg<NameIdx>),
-    StoreLocal(Arg<NameIdx>),
-    StoreGlobal(Arg<NameIdx>),
-    StoreDeref(Arg<NameIdx>),
-    DeleteFast(Arg<NameIdx>),
-    DeleteLocal(Arg<NameIdx>),
-    DeleteGlobal(Arg<NameIdx>),
-    DeleteDeref(Arg<NameIdx>),
-    LoadClosure(Arg<NameIdx>),
-    Subscript,
-    StoreSubscript,
-    DeleteSubscript,
-    StoreAttr {
-        idx: Arg<NameIdx>,
-    },
-    DeleteAttr {
-        idx: Arg<NameIdx>,
-    },
-    LoadConst {
-        /// index into constants vec
-        idx: Arg<u32>,
-    },
-    UnaryOperation {
-        op: Arg<UnaryOperator>,
-    },
-    BinaryOperation {
-        op: Arg<BinaryOperator>,
-    },
-    BinaryOperationInplace {
-        op: Arg<BinaryOperator>,
-    },
-    BinarySubscript,
-    LoadAttr {
-        idx: Arg<NameIdx>,
-    },
-    TestOperation {
-        op: Arg<TestOperator>,
-    },
-    CompareOperation {
-        op: Arg<ComparisonOperator>,
-    },
-    CopyItem {
-        index: Arg<u32>,
-    },
-    Pop,
-    Swap {
-        index: Arg<u32>,
-    },
-    // ToBool,
-    Rotate2,
-    Rotate3,
-    Duplicate,
-    Duplicate2,
-    GetIter,
-    GetLen,
-    CallIntrinsic1 {
-        func: Arg<IntrinsicFunction1>,
-    },
-    CallIntrinsic2 {
-        func: Arg<IntrinsicFunction2>,
-    },
-    Continue {
-        target: Arg<Label>,
-    },
-    Break {
-        target: Arg<Label>,
-    },
-    Jump {
-        target: Arg<Label>,
-    },
-    /// Pop the top of the stack, and jump if this value is true.
-    JumpIfTrue {
-        target: Arg<Label>,
-    },
-    /// Pop the top of the stack, and jump if this value is false.
-    JumpIfFalse {
-        target: Arg<Label>,
-    },
-    /// Peek at the top of the stack, and jump if this value is true.
-    /// Otherwise, pop top of stack.
-    JumpIfTrueOrPop {
-        target: Arg<Label>,
-    },
-    /// Peek at the top of the stack, and jump if this value is false.
-    /// Otherwise, pop top of stack.
-    JumpIfFalseOrPop {
-        target: Arg<Label>,
-    },
-    MakeFunction(Arg<MakeFunctionFlags>),
-    CallFunctionPositional {
-        nargs: Arg<u32>,
-    },
-    CallFunctionKeyword {
-        nargs: Arg<u32>,
-    },
-    CallFunctionEx {
-        has_kwargs: Arg<bool>,
-    },
-    LoadMethod {
-        idx: Arg<NameIdx>,
-    },
-    CallMethodPositional {
-        nargs: Arg<u32>,
-    },
-    CallMethodKeyword {
-        nargs: Arg<u32>,
-    },
-    CallMethodEx {
-        has_kwargs: Arg<bool>,
-    },
-    ForIter {
-        target: Arg<Label>,
-    },
-    ReturnValue,
-    ReturnConst {
-        idx: Arg<u32>,
-    },
-    YieldValue,
-    YieldFrom,
-    SetupAnnotation,
-    SetupLoop,
-
-    /// Setup a finally handler, which will be called whenever one of this events occurs:
-    /// - the block is popped
-    /// - the function returns
-    /// - an exception is returned
-    SetupFinally {
-        handler: Arg<Label>,
-    },
-
-    /// Enter a finally block, without returning, excepting, just because we are there.
-    EnterFinally,
-
-    /// Marker bytecode for the end of a finally sequence.
-    /// When this bytecode is executed, the eval loop does one of those things:
-    /// - Continue at a certain bytecode position
-    /// - Propagate the exception
-    /// - Return from a function
-    /// - Do nothing at all, just continue
-    EndFinally,
-
-    SetupExcept {
-        handler: Arg<Label>,
-    },
-    SetupWith {
-        end: Arg<Label>,
-    },
-    WithCleanupStart,
-    WithCleanupFinish,
-    PopBlock,
-    Raise {
-        kind: Arg<RaiseKind>,
-    },
-    BuildString {
-        size: Arg<u32>,
-    },
-    BuildTuple {
-        size: Arg<u32>,
-    },
-    BuildTupleFromTuples {
-        size: Arg<u32>,
-    },
-    BuildTupleFromIter,
-    BuildList {
-        size: Arg<u32>,
-    },
-    BuildListFromTuples {
-        size: Arg<u32>,
-    },
-    BuildSet {
-        size: Arg<u32>,
-    },
-    BuildSetFromTuples {
-        size: Arg<u32>,
-    },
-    BuildMap {
-        size: Arg<u32>,
-    },
-    BuildMapForCall {
-        size: Arg<u32>,
-    },
-    DictUpdate,
-    BuildSlice {
-        /// whether build a slice with a third step argument
-        step: Arg<bool>,
-    },
-    ListAppend {
-        i: Arg<u32>,
-    },
-    SetAdd {
-        i: Arg<u32>,
-    },
-    MapAdd {
-        i: Arg<u32>,
-    },
-
-    PrintExpr,
-    LoadBuildClass,
-    UnpackSequence {
-        size: Arg<u32>,
-    },
-    UnpackEx {
-        args: Arg<UnpackExArgs>,
-    },
-    FormatValue {
-        conversion: Arg<ConversionFlag>,
-    },
-    PopException,
-    Reverse {
-        amount: Arg<u32>,
-    },
-    GetAwaitable,
-    BeforeAsyncWith,
-    SetupAsyncWith {
-        end: Arg<Label>,
-    },
-    GetAIter,
-    GetANext,
-    EndAsyncFor,
-    MatchMapping,
-    MatchSequence,
-    MatchKeys,
-    MatchClass(Arg<u32>),
-    ExtendedArg,
-    TypeVar,
-    TypeVarWithBound,
-    TypeVarWithConstraint,
-    TypeAlias,
-    TypeVarTuple,
-    ParamSpec,
-    // If you add a new instruction here, be sure to keep LAST_INSTRUCTION updated
-}
-// This must be kept up to date to avoid marshaling errors
-const LAST_INSTRUCTION: Instruction = Instruction::ParamSpec;
-const _: () = assert!(mem::size_of::<Instruction>() == 1);
-
-impl From<Instruction> for u8 {
-    #[inline]
-    fn from(ins: Instruction) -> Self {
-        // SAFETY: there's no padding bits
-        unsafe { std::mem::transmute::<Instruction, Self>(ins) }
-    }
-}
-
-impl TryFrom<u8> for Instruction {
-    type Error = crate::marshal::MarshalError;
-
-    #[inline]
-    fn try_from(value: u8) -> Result<Self, crate::marshal::MarshalError> {
-        if value <= u8::from(LAST_INSTRUCTION) {
-            Ok(unsafe { std::mem::transmute::<u8, Self>(value) })
-        } else {
-            Err(crate::marshal::MarshalError::InvalidBytecode)
-        }
-    }
-}
-
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct CodeUnit {
-    pub op: Instruction,
-    pub arg: OpArgByte,
-}
-
-const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
-
-impl CodeUnit {
-    pub fn new(op: Instruction, arg: OpArgByte) -> Self {
-        Self { op, arg }
-    }
-}
-
-use self::Instruction::*;
-
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct MakeFunctionFlags: u8 {
-        const CLOSURE = 0x01;
-        const ANNOTATIONS = 0x02;
-        const KW_ONLY_DEFAULTS = 0x04;
-        const DEFAULTS = 0x08;
-        const TYPE_PARAMS = 0x10;
-    }
-}
-impl OpArgType for MakeFunctionFlags {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        Self::from_bits(x as u8)
-    }
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        self.bits().into()
-    }
-}
-
-/// A Constant (which usually encapsulates data within it)
-///
-/// # Examples
-/// ```
-/// use rustpython_compiler_core::bytecode::ConstantData;
-/// let a = ConstantData::Float {value: 120f64};
-/// let b = ConstantData::Boolean {value: false};
-/// assert_ne!(a, b);
-/// ```
-#[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> },
-    None,
-    Ellipsis,
-}
-
-impl PartialEq for ConstantData {
-    fn eq(&self, other: &Self) -> bool {
-        use ConstantData::*;
-        match (self, other) {
-            (Integer { value: a }, Integer { value: b }) => a == b,
-            // we want to compare floats *by actual value* - if we have the *exact same* float
-            // already in a constant cache, we want to use that
-            (Float { value: a }, Float { value: b }) => a.to_bits() == b.to_bits(),
-            (Complex { value: a }, Complex { value: b }) => {
-                a.re.to_bits() == b.re.to_bits() && a.im.to_bits() == b.im.to_bits()
-            }
-            (Boolean { value: a }, Boolean { value: b }) => a == b,
-            (Str { value: a }, Str { value: b }) => a == b,
-            (Bytes { value: a }, Bytes { value: b }) => a == b,
-            (Code { code: a }, Code { code: b }) => std::ptr::eq(a.as_ref(), b.as_ref()),
-            (Tuple { elements: a }, Tuple { elements: b }) => a == b,
-            (None, None) => true,
-            (Ellipsis, Ellipsis) => true,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for ConstantData {}
-
-impl hash::Hash for ConstantData {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        use ConstantData::*;
-        mem::discriminant(self).hash(state);
-        match self {
-            Integer { value } => value.hash(state),
-            Float { value } => value.to_bits().hash(state),
-            Complex { value } => {
-                value.re.to_bits().hash(state);
-                value.im.to_bits().hash(state);
-            }
-            Boolean { value } => value.hash(state),
-            Str { value } => value.hash(state),
-            Bytes { value } => value.hash(state),
-            Code { code } => std::ptr::hash(code.as_ref(), state),
-            Tuple { elements } => elements.hash(state),
-            None => {}
-            Ellipsis => {}
-        }
-    }
-}
-
-/// A borrowed Constant
-pub enum BorrowedConstant<'a, C: Constant> {
-    Integer { value: &'a BigInt },
-    Float { value: f64 },
-    Complex { value: Complex64 },
-    Boolean { value: bool },
-    Str { value: &'a Wtf8 },
-    Bytes { value: &'a [u8] },
-    Code { code: &'a CodeObject<C> },
-    Tuple { elements: &'a [C] },
-    None,
-    Ellipsis,
-}
-
-impl<C: Constant> Copy for BorrowedConstant<'_, C> {}
-impl<C: Constant> Clone for BorrowedConstant<'_, C> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<C: Constant> BorrowedConstant<'_, C> {
-    pub fn fmt_display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BorrowedConstant::Integer { value } => write!(f, "{value}"),
-            BorrowedConstant::Float { value } => write!(f, "{value}"),
-            BorrowedConstant::Complex { value } => write!(f, "{value}"),
-            BorrowedConstant::Boolean { value } => {
-                write!(f, "{}", if *value { "True" } else { "False" })
-            }
-            BorrowedConstant::Str { value } => write!(f, "{value:?}"),
-            BorrowedConstant::Bytes { value } => write!(f, "b\"{}\"", value.escape_ascii()),
-            BorrowedConstant::Code { code } => write!(f, "{code:?}"),
-            BorrowedConstant::Tuple { elements } => {
-                write!(f, "(")?;
-                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, "..."),
-        }
-    }
-    pub fn to_owned(self) -> ConstantData {
-        use ConstantData::*;
-        match self {
-            BorrowedConstant::Integer { value } => Integer {
-                value: value.clone(),
-            },
-            BorrowedConstant::Float { value } => Float { value },
-            BorrowedConstant::Complex { value } => Complex { value },
-            BorrowedConstant::Boolean { value } => Boolean { value },
-            BorrowedConstant::Str { value } => Str {
-                value: value.to_owned(),
-            },
-            BorrowedConstant::Bytes { value } => Bytes {
-                value: value.to_owned(),
-            },
-            BorrowedConstant::Code { code } => Code {
-                code: Box::new(code.map_clone_bag(&BasicBag)),
-            },
-            BorrowedConstant::Tuple { elements } => Tuple {
-                elements: elements
-                    .iter()
-                    .map(|c| c.borrow_constant().to_owned())
-                    .collect(),
-            },
-            BorrowedConstant::None => None,
-            BorrowedConstant::Ellipsis => Ellipsis,
-        }
-    }
-}
-
-op_arg_enum!(
-    /// The possible comparison operators
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum ComparisonOperator {
-        // be intentional with bits so that we can do eval_ord with just a bitwise and
-        // bits: | Equal | Greater | Less |
-        Less = 0b001,
-        Greater = 0b010,
-        NotEqual = 0b011,
-        Equal = 0b100,
-        LessOrEqual = 0b101,
-        GreaterOrEqual = 0b110,
-    }
-);
-
-op_arg_enum!(
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum TestOperator {
-        In = 0,
-        NotIn = 1,
-        Is = 2,
-        IsNot = 3,
-        /// two exceptions that match?
-        ExceptionMatch = 4,
-    }
-);
-
-op_arg_enum!(
-    /// The possible Binary operators
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use rustpython_compiler_core::Instruction::BinaryOperation;
-    /// use rustpython_compiler_core::BinaryOperator::Add;
-    /// let op = BinaryOperation {op: Add};
-    /// ```
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum BinaryOperator {
-        Power = 0,
-        Multiply = 1,
-        MatrixMultiply = 2,
-        Divide = 3,
-        FloorDivide = 4,
-        Modulo = 5,
-        Add = 6,
-        Subtract = 7,
-        Lshift = 8,
-        Rshift = 9,
-        And = 10,
-        Xor = 11,
-        Or = 12,
-    }
-);
-
-op_arg_enum!(
-    /// The possible unary operators
-    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-    #[repr(u8)]
-    pub enum UnaryOperator {
-        Not = 0,
-        Invert = 1,
-        Minus = 2,
-        Plus = 3,
-    }
-);
-
-#[derive(Copy, Clone)]
-pub struct UnpackExArgs {
-    pub before: u8,
-    pub after: u8,
-}
-
-impl OpArgType for UnpackExArgs {
-    #[inline(always)]
-    fn from_op_arg(x: u32) -> Option<Self> {
-        let [before, after, ..] = x.to_le_bytes();
-        Some(Self { before, after })
-    }
-    #[inline(always)]
-    fn to_op_arg(self) -> u32 {
-        u32::from_le_bytes([self.before, self.after, 0, 0])
-    }
-}
-impl fmt::Display for UnpackExArgs {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "before: {}, after: {}", self.before, self.after)
-    }
-}
-
-/*
-Maintain a stack of blocks on the VM.
-pub enum BlockType {
-    Loop,
-    Except,
-}
-*/
-
-/// Argument structure
-pub struct Arguments<'a, N: AsRef<str>> {
-    pub posonlyargs: &'a [N],
-    pub args: &'a [N],
-    pub vararg: Option<&'a N>,
-    pub kwonlyargs: &'a [N],
-    pub varkwarg: Option<&'a N>,
-}
-
-impl<N: AsRef<str>> fmt::Debug for Arguments<'_, N> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        macro_rules! fmt_slice {
-            ($x:expr) => {
-                format_args!("[{}]", $x.iter().map(AsRef::as_ref).format(", "))
-            };
-        }
-        f.debug_struct("Arguments")
-            .field("posonlyargs", &fmt_slice!(self.posonlyargs))
-            .field("args", &fmt_slice!(self.posonlyargs))
-            .field("vararg", &self.vararg.map(N::as_ref))
-            .field("kwonlyargs", &fmt_slice!(self.kwonlyargs))
-            .field("varkwarg", &self.varkwarg.map(N::as_ref))
-            .finish()
-    }
-}
-
-impl<C: Constant> CodeObject<C> {
-    /// Get all arguments of the code object
-    /// like inspect.getargs
-    pub fn arg_names(&self) -> Arguments<'_, C::Name> {
-        let nargs = self.arg_count as usize;
-        let nkwargs = self.kwonlyarg_count as usize;
-        let mut varargs_pos = nargs + nkwargs;
-        let posonlyargs = &self.varnames[..self.posonlyarg_count as usize];
-        let args = &self.varnames[..nargs];
-        let kwonlyargs = &self.varnames[nargs..varargs_pos];
-
-        let vararg = if self.flags.contains(CodeFlags::HAS_VARARGS) {
-            let vararg = &self.varnames[varargs_pos];
-            varargs_pos += 1;
-            Some(vararg)
-        } else {
-            None
-        };
-        let varkwarg = if self.flags.contains(CodeFlags::HAS_VARKEYWORDS) {
-            Some(&self.varnames[varargs_pos])
-        } else {
-            None
-        };
-
-        Arguments {
-            posonlyargs,
-            args,
-            vararg,
-            kwonlyargs,
-            varkwarg,
-        }
-    }
-
-    /// Return the labels targeted by the instructions of this CodeObject
-    pub fn label_targets(&self) -> BTreeSet<Label> {
-        let mut label_targets = BTreeSet::new();
-        let mut arg_state = OpArgState::default();
-        for instruction in &*self.instructions {
-            let (instruction, arg) = arg_state.get(*instruction);
-            if let Some(l) = instruction.label_arg() {
-                label_targets.insert(l.get(arg));
-            }
-        }
-        label_targets
-    }
-
-    fn display_inner(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        expand_code_objects: bool,
-        level: usize,
-    ) -> fmt::Result {
-        let label_targets = self.label_targets();
-        let line_digits = (3).max(self.locations.last().unwrap().row.to_string().len());
-        let offset_digits = (4).max(self.instructions.len().to_string().len());
-        let mut last_line = OneIndexed::MAX;
-        let mut arg_state = OpArgState::default();
-        for (offset, &instruction) in self.instructions.iter().enumerate() {
-            let (instruction, arg) = arg_state.get(instruction);
-            // optional line number
-            let line = self.locations[offset].row;
-            if line != last_line {
-                if last_line != OneIndexed::MAX {
-                    writeln!(f)?;
-                }
-                last_line = line;
-                write!(f, "{line:line_digits$}")?;
-            } else {
-                for _ in 0..line_digits {
-                    write!(f, " ")?;
-                }
-            }
-            write!(f, " ")?;
-
-            // level indent
-            for _ in 0..level {
-                write!(f, "    ")?;
-            }
-
-            // arrow and offset
-            let arrow = if label_targets.contains(&Label(offset as u32)) {
-                ">>"
-            } else {
-                "  "
-            };
-            write!(f, "{arrow} {offset:offset_digits$} ")?;
-
-            // instruction
-            instruction.fmt_dis(arg, f, self, expand_code_objects, 21, level)?;
-            writeln!(f)?;
-        }
-        Ok(())
-    }
-
-    /// Recursively display this CodeObject
-    pub fn display_expand_code_objects(&self) -> impl fmt::Display + '_ {
-        struct Display<'a, C: Constant>(&'a CodeObject<C>);
-        impl<C: Constant> fmt::Display for Display<'_, C> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                self.0.display_inner(f, true, 1)
-            }
-        }
-        Display(self)
-    }
-
-    /// Map this CodeObject to one that holds a Bag::Constant
-    pub fn map_bag<Bag: ConstantBag>(self, bag: Bag) -> CodeObject<Bag::Constant> {
-        let map_names = |names: Box<[C::Name]>| {
-            names
-                .into_vec()
-                .into_iter()
-                .map(|x| bag.make_name(x.as_ref()))
-                .collect::<Box<[_]>>()
-        };
-        CodeObject {
-            constants: self
-                .constants
-                .into_vec()
-                .into_iter()
-                .map(|x| bag.make_constant(x.borrow_constant()))
-                .collect(),
-            names: map_names(self.names),
-            varnames: map_names(self.varnames),
-            cellvars: map_names(self.cellvars),
-            freevars: map_names(self.freevars),
-            source_path: bag.make_name(self.source_path.as_ref()),
-            obj_name: bag.make_name(self.obj_name.as_ref()),
-
-            instructions: self.instructions,
-            locations: self.locations,
-            flags: self.flags,
-            posonlyarg_count: self.posonlyarg_count,
-            arg_count: self.arg_count,
-            kwonlyarg_count: self.kwonlyarg_count,
-            first_line_number: self.first_line_number,
-            max_stackdepth: self.max_stackdepth,
-            cell2arg: self.cell2arg,
-        }
-    }
-
-    /// Same as `map_bag` but clones `self`
-    pub fn map_clone_bag<Bag: ConstantBag>(&self, bag: &Bag) -> CodeObject<Bag::Constant> {
-        let map_names =
-            |names: &[C::Name]| names.iter().map(|x| bag.make_name(x.as_ref())).collect();
-        CodeObject {
-            constants: self
-                .constants
-                .iter()
-                .map(|x| bag.make_constant(x.borrow_constant()))
-                .collect(),
-            names: map_names(&self.names),
-            varnames: map_names(&self.varnames),
-            cellvars: map_names(&self.cellvars),
-            freevars: map_names(&self.freevars),
-            source_path: bag.make_name(self.source_path.as_ref()),
-            obj_name: bag.make_name(self.obj_name.as_ref()),
-
-            instructions: self.instructions.clone(),
-            locations: self.locations.clone(),
-            flags: self.flags,
-            posonlyarg_count: self.posonlyarg_count,
-            arg_count: self.arg_count,
-            kwonlyarg_count: self.kwonlyarg_count,
-            first_line_number: self.first_line_number,
-            max_stackdepth: self.max_stackdepth,
-            cell2arg: self.cell2arg.clone(),
-        }
-    }
-}
-
-impl<C: Constant> fmt::Display for CodeObject<C> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display_inner(f, false, 1)?;
-        for constant in &*self.constants {
-            if let BorrowedConstant::Code { code } = constant.borrow_constant() {
-                writeln!(f, "\nDisassembly of {code:?}")?;
-                code.fmt(f)?;
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Instruction {
-    /// Gets the label stored inside this instruction, if it exists
-    #[inline]
-    pub fn label_arg(&self) -> Option<Arg<Label>> {
-        match self {
-            Jump { target: l }
-            | JumpIfTrue { target: l }
-            | JumpIfFalse { target: l }
-            | JumpIfTrueOrPop { target: l }
-            | JumpIfFalseOrPop { target: l }
-            | ForIter { target: l }
-            | SetupFinally { handler: l }
-            | SetupExcept { handler: l }
-            | SetupWith { end: l }
-            | SetupAsyncWith { end: l }
-            | Break { target: l }
-            | Continue { target: l } => Some(*l),
-            _ => None,
-        }
-    }
-
-    /// Whether this is an unconditional branching
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction};
-    /// let jump_inst = Instruction::Jump { target: Arg::marker() };
-    /// assert!(jump_inst.unconditional_branch())
-    /// ```
-    pub fn unconditional_branch(&self) -> bool {
-        matches!(
-            self,
-            Jump { .. }
-                | Continue { .. }
-                | Break { .. }
-                | ReturnValue
-                | ReturnConst { .. }
-                | Raise { .. }
-        )
-    }
-
-    /// What effect this instruction has on the stack
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, UnaryOperator};
-    /// let (target, jump_arg) = Arg::new(Label(0xF));
-    /// let jump_instruction = Instruction::Jump { target };
-    /// let (op, invert_arg) = Arg::new(UnaryOperator::Invert);
-    /// let invert_instruction = Instruction::UnaryOperation { op };
-    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
-    /// assert_eq!(invert_instruction.stack_effect(invert_arg, false), 0);
-    /// ```
-    ///
-    pub fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
-        match self {
-            Nop => 0,
-            ImportName { .. } | ImportNameless => -1,
-            ImportStar => -1,
-            ImportFrom { .. } => 1,
-            LoadFast(_) | LoadNameAny(_) | LoadGlobal(_) | LoadDeref(_) | LoadClassDeref(_) => 1,
-            StoreFast(_) | StoreLocal(_) | StoreGlobal(_) | StoreDeref(_) => -1,
-            DeleteFast(_) | DeleteLocal(_) | DeleteGlobal(_) | DeleteDeref(_) => 0,
-            LoadClosure(_) => 1,
-            Subscript => -1,
-            StoreSubscript => -3,
-            DeleteSubscript => -2,
-            LoadAttr { .. } => 0,
-            StoreAttr { .. } => -2,
-            DeleteAttr { .. } => -1,
-            LoadConst { .. } => 1,
-            UnaryOperation { .. } => 0,
-            BinaryOperation { .. }
-            | BinaryOperationInplace { .. }
-            | TestOperation { .. }
-            | CompareOperation { .. } => -1,
-            BinarySubscript => -1,
-            CopyItem { .. } => 1,
-            Pop => -1,
-            Swap { .. } => 0,
-            // ToBool => 0,
-            Rotate2 | Rotate3 => 0,
-            Duplicate => 1,
-            Duplicate2 => 2,
-            GetIter => 0,
-            GetLen => 1,
-            CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
-            CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
-            Continue { .. } => 0,
-            Break { .. } => 0,
-            Jump { .. } => 0,
-            JumpIfTrue { .. } | JumpIfFalse { .. } => -1,
-            JumpIfTrueOrPop { .. } | JumpIfFalseOrPop { .. } => {
-                if jump {
-                    0
-                } else {
-                    -1
-                }
-            }
-            MakeFunction(flags) => {
-                let flags = flags.get(arg);
-                -2 - flags.contains(MakeFunctionFlags::CLOSURE) as i32
-                    - flags.contains(MakeFunctionFlags::ANNOTATIONS) as i32
-                    - flags.contains(MakeFunctionFlags::KW_ONLY_DEFAULTS) as i32
-                    - flags.contains(MakeFunctionFlags::DEFAULTS) as i32
-                    + 1
-            }
-            CallFunctionPositional { nargs } => -(nargs.get(arg) as i32) - 1 + 1,
-            CallMethodPositional { nargs } => -(nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 1 + 1,
-            CallMethodKeyword { nargs } => -1 - (nargs.get(arg) as i32) - 3 + 1,
-            CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 1 + 1,
-            CallMethodEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 3 + 1,
-            LoadMethod { .. } => -1 + 3,
-            ForIter { .. } => {
-                if jump {
-                    -1
-                } else {
-                    1
-                }
-            }
-            ReturnValue => -1,
-            ReturnConst { .. } => 0,
-            YieldValue => 0,
-            YieldFrom => -1,
-            SetupAnnotation | SetupLoop | SetupFinally { .. } | EnterFinally | EndFinally => 0,
-            SetupExcept { .. } => jump as i32,
-            SetupWith { .. } => (!jump) as i32,
-            WithCleanupStart => 0,
-            WithCleanupFinish => -1,
-            PopBlock => 0,
-            Raise { kind } => -(kind.get(arg) as u8 as i32),
-            BuildString { size }
-            | BuildTuple { size, .. }
-            | BuildTupleFromTuples { size, .. }
-            | BuildList { size, .. }
-            | BuildListFromTuples { size, .. }
-            | BuildSet { size, .. }
-            | BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
-            BuildTupleFromIter => 0,
-            BuildMap { size } => {
-                let nargs = size.get(arg) * 2;
-                -(nargs as i32) + 1
-            }
-            BuildMapForCall { size } => {
-                let nargs = size.get(arg);
-                -(nargs as i32) + 1
-            }
-            DictUpdate => -1,
-            BuildSlice { step } => -2 - (step.get(arg) as i32) + 1,
-            ListAppend { .. } | SetAdd { .. } => -1,
-            MapAdd { .. } => -2,
-            PrintExpr => -1,
-            LoadBuildClass => 1,
-            UnpackSequence { size } => -1 + size.get(arg) as i32,
-            UnpackEx { args } => {
-                let UnpackExArgs { before, after } = args.get(arg);
-                -1 + before as i32 + 1 + after as i32
-            }
-            FormatValue { .. } => -1,
-            PopException => 0,
-            Reverse { .. } => 0,
-            GetAwaitable => 0,
-            BeforeAsyncWith => 1,
-            SetupAsyncWith { .. } => {
-                if jump {
-                    -1
-                } else {
-                    0
-                }
-            }
-            GetAIter => 0,
-            GetANext => 1,
-            EndAsyncFor => -2,
-            MatchMapping | MatchSequence => 0,
-            MatchKeys => -1,
-            MatchClass(_) => -2,
-            ExtendedArg => 0,
-            TypeVar => 0,
-            TypeVarWithBound => -1,
-            TypeVarWithConstraint => -1,
-            TypeAlias => -2,
-            ParamSpec => 0,
-            TypeVarTuple => 0,
-        }
-    }
-
-    pub fn display<'a>(
-        &'a self,
-        arg: OpArg,
-        ctx: &'a impl InstrDisplayContext,
-    ) -> impl fmt::Display + 'a {
-        struct FmtFn<F>(F);
-        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                (self.0)(f)
-            }
-        }
-        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn fmt_dis(
-        &self,
-        arg: OpArg,
-        f: &mut fmt::Formatter<'_>,
-        ctx: &impl InstrDisplayContext,
-        expand_code_objects: bool,
-        pad: usize,
-        level: usize,
-    ) -> fmt::Result {
-        macro_rules! w {
-            ($variant:ident) => {
-                write!(f, stringify!($variant))
-            };
-            ($variant:ident, $map:ident = $arg_marker:expr) => {{
-                let arg = $arg_marker.get(arg);
-                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
-            }};
-            ($variant:ident, $arg_marker:expr) => {
-                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
-            };
-            ($variant:ident, ?$arg_marker:expr) => {
-                write!(
-                    f,
-                    "{:pad$}({:?})",
-                    stringify!($variant),
-                    $arg_marker.get(arg)
-                )
-            };
-        }
-
-        let varname = |i: u32| ctx.get_varname(i as usize);
-        let name = |i: u32| ctx.get_name(i as usize);
-        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
-
-        let fmt_const =
-            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
-                let value = ctx.get_constant(idx.get(arg) as usize);
-                match value.borrow_constant() {
-                    BorrowedConstant::Code { code } if expand_code_objects => {
-                        write!(f, "{op:pad$}({code:?}):")?;
-                        code.display_inner(f, true, level + 1)?;
-                        Ok(())
-                    }
-                    c => {
-                        write!(f, "{op:pad$}(")?;
-                        c.fmt_display(f)?;
-                        write!(f, ")")
-                    }
-                }
-            };
-
-        match self {
-            Nop => w!(Nop),
-            ImportName { idx } => w!(ImportName, name = idx),
-            ImportNameless => w!(ImportNameless),
-            ImportStar => w!(ImportStar),
-            ImportFrom { idx } => w!(ImportFrom, name = idx),
-            LoadFast(idx) => w!(LoadFast, varname = idx),
-            LoadNameAny(idx) => w!(LoadNameAny, name = idx),
-            LoadGlobal(idx) => w!(LoadGlobal, name = idx),
-            LoadDeref(idx) => w!(LoadDeref, cell_name = idx),
-            LoadClassDeref(idx) => w!(LoadClassDeref, cell_name = idx),
-            StoreFast(idx) => w!(StoreFast, varname = idx),
-            StoreLocal(idx) => w!(StoreLocal, name = idx),
-            StoreGlobal(idx) => w!(StoreGlobal, name = idx),
-            StoreDeref(idx) => w!(StoreDeref, cell_name = idx),
-            DeleteFast(idx) => w!(DeleteFast, varname = idx),
-            DeleteLocal(idx) => w!(DeleteLocal, name = idx),
-            DeleteGlobal(idx) => w!(DeleteGlobal, name = idx),
-            DeleteDeref(idx) => w!(DeleteDeref, cell_name = idx),
-            LoadClosure(i) => w!(LoadClosure, cell_name = i),
-            Subscript => w!(Subscript),
-            StoreSubscript => w!(StoreSubscript),
-            DeleteSubscript => w!(DeleteSubscript),
-            StoreAttr { idx } => w!(StoreAttr, name = idx),
-            DeleteAttr { idx } => w!(DeleteAttr, name = idx),
-            LoadConst { idx } => fmt_const("LoadConst", arg, f, idx),
-            UnaryOperation { op } => w!(UnaryOperation, ?op),
-            BinaryOperation { op } => w!(BinaryOperation, ?op),
-            BinaryOperationInplace { op } => w!(BinaryOperationInplace, ?op),
-            BinarySubscript => w!(BinarySubscript),
-            LoadAttr { idx } => w!(LoadAttr, name = idx),
-            TestOperation { op } => w!(TestOperation, ?op),
-            CompareOperation { op } => w!(CompareOperation, ?op),
-            CopyItem { index } => w!(CopyItem, index),
-            Pop => w!(Pop),
-            Swap { index } => w!(Swap, index),
-            // ToBool => w!(ToBool),
-            Rotate2 => w!(Rotate2),
-            Rotate3 => w!(Rotate3),
-            Duplicate => w!(Duplicate),
-            Duplicate2 => w!(Duplicate2),
-            GetIter => w!(GetIter),
-            // GET_LEN
-            GetLen => w!(GetLen),
-            CallIntrinsic1 { func } => w!(CallIntrinsic1, ?func),
-            CallIntrinsic2 { func } => w!(CallIntrinsic2, ?func),
-            Continue { target } => w!(Continue, target),
-            Break { target } => w!(Break, target),
-            Jump { target } => w!(Jump, target),
-            JumpIfTrue { target } => w!(JumpIfTrue, target),
-            JumpIfFalse { target } => w!(JumpIfFalse, target),
-            JumpIfTrueOrPop { target } => w!(JumpIfTrueOrPop, target),
-            JumpIfFalseOrPop { target } => w!(JumpIfFalseOrPop, target),
-            MakeFunction(flags) => w!(MakeFunction, ?flags),
-            CallFunctionPositional { nargs } => w!(CallFunctionPositional, nargs),
-            CallFunctionKeyword { nargs } => w!(CallFunctionKeyword, nargs),
-            CallFunctionEx { has_kwargs } => w!(CallFunctionEx, has_kwargs),
-            LoadMethod { idx } => w!(LoadMethod, name = idx),
-            CallMethodPositional { nargs } => w!(CallMethodPositional, nargs),
-            CallMethodKeyword { nargs } => w!(CallMethodKeyword, nargs),
-            CallMethodEx { has_kwargs } => w!(CallMethodEx, has_kwargs),
-            ForIter { target } => w!(ForIter, target),
-            ReturnValue => w!(ReturnValue),
-            ReturnConst { idx } => fmt_const("ReturnConst", arg, f, idx),
-            YieldValue => w!(YieldValue),
-            YieldFrom => w!(YieldFrom),
-            SetupAnnotation => w!(SetupAnnotation),
-            SetupLoop => w!(SetupLoop),
-            SetupExcept { handler } => w!(SetupExcept, handler),
-            SetupFinally { handler } => w!(SetupFinally, handler),
-            EnterFinally => w!(EnterFinally),
-            EndFinally => w!(EndFinally),
-            SetupWith { end } => w!(SetupWith, end),
-            WithCleanupStart => w!(WithCleanupStart),
-            WithCleanupFinish => w!(WithCleanupFinish),
-            BeforeAsyncWith => w!(BeforeAsyncWith),
-            SetupAsyncWith { end } => w!(SetupAsyncWith, end),
-            PopBlock => w!(PopBlock),
-            Raise { kind } => w!(Raise, ?kind),
-            BuildString { size } => w!(BuildString, size),
-            BuildTuple { size } => w!(BuildTuple, size),
-            BuildTupleFromTuples { size } => w!(BuildTupleFromTuples, size),
-            BuildTupleFromIter => w!(BuildTupleFromIter),
-            BuildList { size } => w!(BuildList, size),
-            BuildListFromTuples { size } => w!(BuildListFromTuples, size),
-            BuildSet { size } => w!(BuildSet, size),
-            BuildSetFromTuples { size } => w!(BuildSetFromTuples, size),
-            BuildMap { size } => w!(BuildMap, size),
-            BuildMapForCall { size } => w!(BuildMapForCall, size),
-            DictUpdate => w!(DictUpdate),
-            BuildSlice { step } => w!(BuildSlice, step),
-            ListAppend { i } => w!(ListAppend, i),
-            SetAdd { i } => w!(SetAdd, i),
-            MapAdd { i } => w!(MapAdd, i),
-            PrintExpr => w!(PrintExpr),
-            LoadBuildClass => w!(LoadBuildClass),
-            UnpackSequence { size } => w!(UnpackSequence, size),
-            UnpackEx { args } => w!(UnpackEx, args),
-            FormatValue { conversion } => w!(FormatValue, ?conversion),
-            PopException => w!(PopException),
-            Reverse { amount } => w!(Reverse, amount),
-            GetAwaitable => w!(GetAwaitable),
-            GetAIter => w!(GetAIter),
-            GetANext => w!(GetANext),
-            EndAsyncFor => w!(EndAsyncFor),
-            MatchMapping => w!(MatchMapping),
-            MatchSequence => w!(MatchSequence),
-            MatchKeys => w!(MatchKeys),
-            MatchClass(arg) => w!(MatchClass, arg),
-            ExtendedArg => w!(ExtendedArg, Arg::<u32>::marker()),
-            TypeVar => w!(TypeVar),
-            TypeVarWithBound => w!(TypeVarWithBound),
-            TypeVarWithConstraint => w!(TypeVarWithConstraint),
-            TypeAlias => w!(TypeAlias),
-            ParamSpec => w!(ParamSpec),
-            TypeVarTuple => w!(TypeVarTuple),
-        }
-    }
-}
-
-pub trait InstrDisplayContext {
-    type Constant: Constant;
-    fn get_constant(&self, i: usize) -> &Self::Constant;
-    fn get_name(&self, i: usize) -> &str;
-    fn get_varname(&self, i: usize) -> &str;
-    fn get_cell_name(&self, i: usize) -> &str;
-}
-
-impl<C: Constant> InstrDisplayContext for CodeObject<C> {
-    type Constant = C;
-    fn get_constant(&self, i: usize) -> &C {
-        &self.constants[i]
-    }
-    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_cell_name(&self, i: usize) -> &str {
-        self.cellvars
-            .get(i)
-            .unwrap_or_else(|| &self.freevars[i - self.cellvars.len()])
-            .as_ref()
-    }
-}
-
-impl fmt::Display for ConstantData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.borrow_constant().fmt_display(f)
-    }
-}
-
-impl<C: Constant> fmt::Debug for CodeObject<C> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "<code object {} at ??? file {:?}, line {}>",
-            self.obj_name.as_ref(),
-            self.source_path.as_ref(),
-            self.first_line_number.map_or(-1, |x| x.get() as i32)
-        )
-    }
-}
diff --git a/compiler/core/src/lib.rs b/compiler/core/src/lib.rs
deleted file mode 100644
index 75fde66684..0000000000
--- a/compiler/core/src/lib.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
-#![doc(html_root_url = "https://docs.rs/rustpython-compiler-core/")]
-
-pub mod bytecode;
-pub mod frozen;
-pub mod marshal;
-mod mode;
-
-pub use mode::Mode;
diff --git a/compiler/core/src/marshal.rs b/compiler/core/src/marshal.rs
deleted file mode 100644
index 700bb48230..0000000000
--- a/compiler/core/src/marshal.rs
+++ /dev/null
@@ -1,635 +0,0 @@
-use crate::bytecode::*;
-use malachite_bigint::{BigInt, Sign};
-use num_complex::Complex64;
-use ruff_source_file::{OneIndexed, SourceLocation};
-use rustpython_wtf8::Wtf8;
-use std::convert::Infallible;
-
-pub const FORMAT_VERSION: u32 = 4;
-
-#[derive(Debug)]
-pub enum MarshalError {
-    /// Unexpected End Of File
-    Eof,
-    /// Invalid Bytecode
-    InvalidBytecode,
-    /// Invalid utf8 in string
-    InvalidUtf8,
-    /// Invalid source location
-    InvalidLocation,
-    /// Bad type marker
-    BadType,
-}
-
-impl std::fmt::Display for MarshalError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Eof => f.write_str("unexpected end of data"),
-            Self::InvalidBytecode => f.write_str("invalid bytecode"),
-            Self::InvalidUtf8 => f.write_str("invalid utf8"),
-            Self::InvalidLocation => f.write_str("invalid source location"),
-            Self::BadType => f.write_str("bad type marker"),
-        }
-    }
-}
-
-impl From<std::str::Utf8Error> for MarshalError {
-    fn from(_: std::str::Utf8Error) -> Self {
-        Self::InvalidUtf8
-    }
-}
-
-impl std::error::Error for MarshalError {}
-
-type Result<T, E = MarshalError> = std::result::Result<T, E>;
-
-#[repr(u8)]
-enum Type {
-    // Null = b'0',
-    None = b'N',
-    False = b'F',
-    True = b'T',
-    StopIter = b'S',
-    Ellipsis = b'.',
-    Int = b'i',
-    Float = b'g',
-    Complex = b'y',
-    // Long = b'l',  // i32
-    Bytes = b's', // = TYPE_STRING
-    // Interned = b't',
-    // Ref = b'r',
-    Tuple = b'(',
-    List = b'[',
-    Dict = b'{',
-    Code = b'c',
-    Unicode = b'u',
-    // Unknown = b'?',
-    Set = b'<',
-    FrozenSet = b'>',
-    Ascii = b'a',
-    // AsciiInterned = b'A',
-    // SmallTuple = b')',
-    // 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'N' => None,
-            b'F' => False,
-            b'T' => True,
-            b'S' => StopIter,
-            b'.' => Ellipsis,
-            b'i' => Int,
-            b'g' => Float,
-            b'y' => Complex,
-            // b'l' => Long,
-            b's' => Bytes,
-            // b't' => Interned,
-            // b'r' => Ref,
-            b'(' => Tuple,
-            b'[' => List,
-            b'{' => Dict,
-            b'c' => Code,
-            b'u' => Unicode,
-            // b'?' => Unknown,
-            b'<' => Set,
-            b'>' => FrozenSet,
-            b'a' => Ascii,
-            // b'A' => AsciiInterned,
-            // b')' => SmallTuple,
-            // b'z' => ShortAscii,
-            // b'Z' => ShortAsciiInterned,
-            _ => return Err(MarshalError::BadType),
-        })
-    }
-}
-
-pub trait Read {
-    fn read_slice(&mut self, n: u32) -> Result<&[u8]>;
-    fn read_array<const N: usize>(&mut self) -> Result<&[u8; N]> {
-        self.read_slice(N as u32).map(|s| s.try_into().unwrap())
-    }
-    fn read_str(&mut self, len: u32) -> Result<&str> {
-        Ok(std::str::from_utf8(self.read_slice(len)?)?)
-    }
-    fn read_wtf8(&mut self, len: u32) -> Result<&Wtf8> {
-        Wtf8::from_bytes(self.read_slice(len)?).ok_or(MarshalError::InvalidUtf8)
-    }
-    fn read_u8(&mut self) -> Result<u8> {
-        Ok(u8::from_le_bytes(*self.read_array()?))
-    }
-    fn read_u16(&mut self) -> Result<u16> {
-        Ok(u16::from_le_bytes(*self.read_array()?))
-    }
-    fn read_u32(&mut self) -> Result<u32> {
-        Ok(u32::from_le_bytes(*self.read_array()?))
-    }
-    fn read_u64(&mut self) -> Result<u64> {
-        Ok(u64::from_le_bytes(*self.read_array()?))
-    }
-}
-
-pub(crate) trait ReadBorrowed<'a>: Read {
-    fn read_slice_borrow(&mut self, n: u32) -> Result<&'a [u8]>;
-    fn read_str_borrow(&mut self, len: u32) -> Result<&'a str> {
-        Ok(std::str::from_utf8(self.read_slice_borrow(len)?)?)
-    }
-}
-
-impl Read for &[u8] {
-    fn read_slice(&mut self, n: u32) -> Result<&[u8]> {
-        self.read_slice_borrow(n)
-    }
-}
-
-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)
-    }
-}
-
-pub struct Cursor<B> {
-    pub data: B,
-    pub position: usize,
-}
-
-impl<B: AsRef<[u8]>> Read for Cursor<B> {
-    fn read_slice(&mut self, n: u32) -> Result<&[u8]> {
-        let data = &self.data.as_ref()[self.position..];
-        let slice = data.get(..n as usize).ok_or(MarshalError::Eof)?;
-        self.position += n as usize;
-        Ok(slice)
-    }
-}
-
-pub fn deserialize_code<R: Read, Bag: ConstantBag>(
-    rdr: &mut R,
-    bag: Bag,
-) -> Result<CodeObject<Bag::Constant>> {
-    let len = rdr.read_u32()?;
-    let instructions = rdr.read_slice(len * 2)?;
-    let instructions = instructions
-        .chunks_exact(2)
-        .map(|cu| {
-            let op = Instruction::try_from(cu[0])?;
-            let arg = OpArgByte(cu[1]);
-            Ok(CodeUnit { op, arg })
-        })
-        .collect::<Result<Box<[CodeUnit]>>>()?;
-
-    let len = rdr.read_u32()?;
-    let locations = (0..len)
-        .map(|_| {
-            Ok(SourceLocation {
-                row: OneIndexed::new(rdr.read_u32()? as _).ok_or(MarshalError::InvalidLocation)?,
-                column: OneIndexed::from_zero_indexed(rdr.read_u32()? as _),
-            })
-        })
-        .collect::<Result<Box<[SourceLocation]>>>()?;
-
-    let flags = CodeFlags::from_bits_truncate(rdr.read_u16()?);
-
-    let posonlyarg_count = rdr.read_u32()?;
-    let arg_count = rdr.read_u32()?;
-    let kwonlyarg_count = rdr.read_u32()?;
-
-    let len = rdr.read_u32()?;
-    let source_path = bag.make_name(rdr.read_str(len)?);
-
-    let first_line_number = OneIndexed::new(rdr.read_u32()? as _);
-    let max_stackdepth = rdr.read_u32()?;
-
-    let len = rdr.read_u32()?;
-    let obj_name = bag.make_name(rdr.read_str(len)?);
-
-    let len = rdr.read_u32()?;
-    let cell2arg = (len != 0)
-        .then(|| {
-            (0..len)
-                .map(|_| Ok(rdr.read_u32()? as i32))
-                .collect::<Result<Box<[i32]>>>()
-        })
-        .transpose()?;
-
-    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<[_]>>>()
-    };
-
-    let names = read_names()?;
-    let varnames = read_names()?;
-    let cellvars = read_names()?;
-    let freevars = read_names()?;
-
-    Ok(CodeObject {
-        instructions,
-        locations,
-        flags,
-        posonlyarg_count,
-        arg_count,
-        kwonlyarg_count,
-        source_path,
-        first_line_number,
-        max_stackdepth,
-        obj_name,
-        cell2arg,
-        constants,
-        names,
-        varnames,
-        cellvars,
-        freevars,
-    })
-}
-
-pub trait MarshalBag: Copy {
-    type Value;
-    fn make_bool(&self, value: bool) -> Self::Value;
-    fn make_none(&self) -> Self::Value;
-    fn make_ellipsis(&self) -> Self::Value;
-    fn make_float(&self, value: f64) -> Self::Value;
-    fn make_complex(&self, value: Complex64) -> Self::Value;
-    fn make_str(&self, value: &Wtf8) -> Self::Value;
-    fn make_bytes(&self, value: &[u8]) -> Self::Value;
-    fn make_int(&self, value: BigInt) -> Self::Value;
-    fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value;
-    fn make_code(
-        &self,
-        code: CodeObject<<Self::ConstantBag as ConstantBag>::Constant>,
-    ) -> Self::Value;
-    fn make_stop_iter(&self) -> Result<Self::Value>;
-    fn make_list(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
-    fn make_set(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
-    fn make_frozenset(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
-    fn make_dict(
-        &self,
-        it: impl Iterator<Item = (Self::Value, Self::Value)>,
-    ) -> Result<Self::Value>;
-    type ConstantBag: ConstantBag;
-    fn constant_bag(self) -> Self::ConstantBag;
-}
-
-impl<Bag: ConstantBag> MarshalBag for Bag {
-    type Value = Bag::Constant;
-    fn make_bool(&self, value: bool) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Boolean { value })
-    }
-    fn make_none(&self) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::None)
-    }
-    fn make_ellipsis(&self) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Ellipsis)
-    }
-    fn make_float(&self, value: f64) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Float { value })
-    }
-    fn make_complex(&self, value: Complex64) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Complex { value })
-    }
-    fn make_str(&self, value: &Wtf8) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Str { value })
-    }
-    fn make_bytes(&self, value: &[u8]) -> Self::Value {
-        self.make_constant::<Bag::Constant>(BorrowedConstant::Bytes { value })
-    }
-    fn make_int(&self, value: BigInt) -> Self::Value {
-        self.make_int(value)
-    }
-    fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value {
-        self.make_tuple(elements)
-    }
-    fn make_code(
-        &self,
-        code: CodeObject<<Self::ConstantBag as ConstantBag>::Constant>,
-    ) -> Self::Value {
-        self.make_code(code)
-    }
-    fn make_stop_iter(&self) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
-    }
-    fn make_list(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
-    }
-    fn make_set(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
-    }
-    fn make_frozenset(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
-    }
-    fn make_dict(
-        &self,
-        _: impl Iterator<Item = (Self::Value, Self::Value)>,
-    ) -> Result<Self::Value> {
-        Err(MarshalError::BadType)
-    }
-    type ConstantBag = Self;
-    fn constant_bag(self) -> Self::ConstantBag {
-        self
-    }
-}
-
-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 value = match typ {
-        Type::True => bag.make_bool(true),
-        Type::False => bag.make_bool(false),
-        Type::None => bag.make_none(),
-        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)
-        }
-        Type::Float => {
-            let value = f64::from_bits(rdr.read_u64()?);
-            bag.make_float(value)
-        }
-        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 => {
-            let len = rdr.read_u32()?;
-            let value = rdr.read_wtf8(len)?;
-            bag.make_str(value)
-        }
-        Type::Tuple => {
-            let len = rdr.read_u32()?;
-            let it = (0..len).map(|_| deserialize_value(rdr, bag));
-            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));
-            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));
-            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));
-            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))??
-        }
-        Type::Bytes => {
-            // Following CPython, 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())?),
-    };
-    Ok(value)
-}
-
-pub trait Dumpable: Sized {
-    type Error;
-    type Constant: Constant;
-    fn with_dump<R>(&self, f: impl FnOnce(DumpableValue<'_, Self>) -> R) -> Result<R, Self::Error>;
-}
-
-pub enum DumpableValue<'a, D: Dumpable> {
-    Integer(&'a BigInt),
-    Float(f64),
-    Complex(Complex64),
-    Boolean(bool),
-    Str(&'a Wtf8),
-    Bytes(&'a [u8]),
-    Code(&'a CodeObject<D::Constant>),
-    Tuple(&'a [D]),
-    None,
-    Ellipsis,
-    StopIter,
-    List(&'a [D]),
-    Set(&'a [D]),
-    Frozenset(&'a [D]),
-    Dict(&'a [(D, D)]),
-}
-
-impl<'a, C: Constant> From<BorrowedConstant<'a, C>> for DumpableValue<'a, C> {
-    fn from(c: BorrowedConstant<'a, C>) -> Self {
-        match c {
-            BorrowedConstant::Integer { value } => Self::Integer(value),
-            BorrowedConstant::Float { value } => Self::Float(value),
-            BorrowedConstant::Complex { value } => Self::Complex(value),
-            BorrowedConstant::Boolean { value } => Self::Boolean(value),
-            BorrowedConstant::Str { value } => Self::Str(value),
-            BorrowedConstant::Bytes { value } => Self::Bytes(value),
-            BorrowedConstant::Code { code } => Self::Code(code),
-            BorrowedConstant::Tuple { elements } => Self::Tuple(elements),
-            BorrowedConstant::None => Self::None,
-            BorrowedConstant::Ellipsis => Self::Ellipsis,
-        }
-    }
-}
-
-impl<C: Constant> Dumpable for C {
-    type Error = Infallible;
-    type Constant = Self;
-    #[inline(always)]
-    fn with_dump<R>(&self, f: impl FnOnce(DumpableValue<'_, Self>) -> R) -> Result<R, Self::Error> {
-        Ok(f(self.borrow_constant().into()))
-    }
-}
-
-pub trait Write {
-    fn write_slice(&mut self, slice: &[u8]);
-    fn write_u8(&mut self, v: u8) {
-        self.write_slice(&v.to_le_bytes())
-    }
-    fn write_u16(&mut self, v: u16) {
-        self.write_slice(&v.to_le_bytes())
-    }
-    fn write_u32(&mut self, v: u32) {
-        self.write_slice(&v.to_le_bytes())
-    }
-    fn write_u64(&mut self, v: u64) {
-        self.write_slice(&v.to_le_bytes())
-    }
-}
-
-impl Write for Vec<u8> {
-    fn write_slice(&mut self, slice: &[u8]) {
-        self.extend_from_slice(slice)
-    }
-}
-
-pub(crate) fn write_len<W: Write>(buf: &mut W, len: usize) {
-    let Ok(len) = len.try_into() else {
-        panic!("too long to serialize")
-    };
-    buf.write_u32(len);
-}
-
-pub(crate) fn write_vec<W: Write>(buf: &mut W, slice: &[u8]) {
-    write_len(buf, slice.len());
-    buf.write_slice(slice);
-}
-
-pub fn serialize_value<W: Write, D: Dumpable>(
-    buf: &mut W,
-    constant: DumpableValue<'_, D>,
-) -> 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);
-        }
-        DumpableValue::Float(f) => {
-            buf.write_u8(Type::Float as u8);
-            buf.write_u64(f.to_bits());
-        }
-        DumpableValue::Complex(c) => {
-            buf.write_u8(Type::Complex as u8);
-            buf.write_u64(c.re.to_bits());
-            buf.write_u64(c.im.to_bits());
-        }
-        DumpableValue::Boolean(b) => {
-            buf.write_u8(if b { Type::True } else { Type::False } as u8);
-        }
-        DumpableValue::Str(s) => {
-            buf.write_u8(Type::Unicode as u8);
-            write_vec(buf, s.as_bytes());
-        }
-        DumpableValue::Bytes(b) => {
-            buf.write_u8(Type::Bytes as u8);
-            write_vec(buf, b);
-        }
-        DumpableValue::Code(c) => {
-            buf.write_u8(Type::Code as u8);
-            serialize_code(buf, c);
-        }
-        DumpableValue::Tuple(tup) => {
-            buf.write_u8(Type::Tuple as u8);
-            write_len(buf, tup.len());
-            for val in tup {
-                val.with_dump(|val| serialize_value(buf, val))??
-            }
-        }
-        DumpableValue::None => {
-            buf.write_u8(Type::None as u8);
-        }
-        DumpableValue::Ellipsis => {
-            buf.write_u8(Type::Ellipsis as u8);
-        }
-        DumpableValue::StopIter => {
-            buf.write_u8(Type::StopIter as u8);
-        }
-        DumpableValue::List(l) => {
-            buf.write_u8(Type::List as u8);
-            write_len(buf, l.len());
-            for val in l {
-                val.with_dump(|val| serialize_value(buf, val))??
-            }
-        }
-        DumpableValue::Set(set) => {
-            buf.write_u8(Type::Set as u8);
-            write_len(buf, set.len());
-            for val in set {
-                val.with_dump(|val| serialize_value(buf, val))??
-            }
-        }
-        DumpableValue::Frozenset(set) => {
-            buf.write_u8(Type::FrozenSet as u8);
-            write_len(buf, set.len());
-            for val in set {
-                val.with_dump(|val| serialize_value(buf, val))??
-            }
-        }
-        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))??;
-            }
-        }
-    }
-    Ok(())
-}
-
-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);
-
-    write_len(buf, code.locations.len());
-    for loc in &*code.locations {
-        buf.write_u32(loc.row.get() as _);
-        buf.write_u32(loc.column.to_zero_indexed() as _);
-    }
-
-    buf.write_u16(code.flags.bits());
-
-    buf.write_u32(code.posonlyarg_count);
-    buf.write_u32(code.arg_count);
-    buf.write_u32(code.kwonlyarg_count);
-
-    write_vec(buf, code.source_path.as_ref().as_bytes());
-
-    buf.write_u32(code.first_line_number.map_or(0, |x| x.get() as _));
-    buf.write_u32(code.max_stackdepth);
-
-    write_vec(buf, code.obj_name.as_ref().as_bytes());
-
-    let cell2arg = code.cell2arg.as_deref().unwrap_or(&[]);
-    write_len(buf, cell2arg.len());
-    for &i in cell2arg {
-        buf.write_u32(i as u32)
-    }
-
-    write_len(buf, code.constants.len());
-    for constant in &*code.constants {
-        serialize_value(buf, constant.borrow_constant().into()).unwrap_or_else(|x| match x {})
-    }
-
-    let mut write_names = |names: &[C::Name]| {
-        write_len(buf, names.len());
-        for name in names {
-            write_vec(buf, name.as_ref().as_bytes());
-        }
-    };
-
-    write_names(&code.names);
-    write_names(&code.varnames);
-    write_names(&code.cellvars);
-    write_names(&code.freevars);
-}
diff --git a/compiler/literal/Cargo.toml b/compiler/literal/Cargo.toml
deleted file mode 100644
index da55d107b3..0000000000
--- a/compiler/literal/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "rustpython-literal"
-description = "Common literal handling utilities mostly useful for unparse and repr."
-edition = { workspace = true }
-version = { workspace = true }
-authors = { workspace = true }
-repository = { workspace = true }
-license = { workspace = true }
-rust-version = { workspace = true }
-
-[dependencies]
-rustpython-wtf8 = { workspace = true }
-
-hexf-parse = "0.2.1"
-is-macro.workspace = true
-lexical-parse-float = { version = "1.0.4", features = ["format"] }
-num-traits = { workspace = true }
-unic-ucd-category = { workspace = true }
-
-[dev-dependencies]
-rand = { workspace = true }
diff --git a/compiler/literal/src/float.rs b/compiler/literal/src/float.rs
deleted file mode 100644
index 0c07d97c98..0000000000
--- a/compiler/literal/src/float.rs
+++ /dev/null
@@ -1,298 +0,0 @@
-use crate::format::Case;
-use num_traits::{Float, Zero};
-use std::f64;
-
-pub fn parse_str(literal: &str) -> Option<f64> {
-    parse_inner(literal.trim().as_bytes())
-}
-
-pub fn parse_bytes(literal: &[u8]) -> Option<f64> {
-    parse_inner(literal.trim_ascii())
-}
-
-fn parse_inner(literal: &[u8]) -> Option<f64> {
-    use lexical_parse_float::{
-        FromLexicalWithOptions, NumberFormatBuilder, Options, format::PYTHON3_LITERAL,
-    };
-
-    // lexical-core's format::PYTHON_STRING is inaccurate
-    const PYTHON_STRING: u128 = NumberFormatBuilder::rebuild(PYTHON3_LITERAL)
-        .no_special(false)
-        .build();
-    f64::from_lexical_with_options::<PYTHON_STRING>(literal, &Options::new()).ok()
-}
-
-pub fn is_integer(v: f64) -> bool {
-    (v - v.round()).abs() < f64::EPSILON
-}
-
-fn format_nan(case: Case) -> String {
-    let nan = match case {
-        Case::Lower => "nan",
-        Case::Upper => "NAN",
-    };
-
-    nan.to_string()
-}
-
-fn format_inf(case: Case) -> String {
-    let inf = match case {
-        Case::Lower => "inf",
-        Case::Upper => "INF",
-    };
-
-    inf.to_string()
-}
-
-pub fn decimal_point_or_empty(precision: usize, alternate_form: bool) -> &'static str {
-    match (precision, alternate_form) {
-        (0, true) => ".",
-        _ => "",
-    }
-}
-
-pub fn format_fixed(precision: usize, magnitude: f64, case: Case, alternate_form: bool) -> String {
-    match magnitude {
-        magnitude if magnitude.is_finite() => {
-            let point = decimal_point_or_empty(precision, alternate_form);
-            let precision = std::cmp::min(precision, u16::MAX as usize);
-            format!("{magnitude:.precision$}{point}")
-        }
-        magnitude if magnitude.is_nan() => format_nan(case),
-        magnitude if magnitude.is_infinite() => format_inf(case),
-        _ => "".to_string(),
-    }
-}
-
-// Formats floats into Python style exponent notation, by first formatting in Rust style
-// exponent notation (`1.0000e0`), then convert to Python style (`1.0000e+00`).
-pub fn format_exponent(
-    precision: usize,
-    magnitude: f64,
-    case: Case,
-    alternate_form: bool,
-) -> String {
-    match magnitude {
-        magnitude if magnitude.is_finite() => {
-            let r_exp = format!("{magnitude:.precision$e}");
-            let mut parts = r_exp.splitn(2, 'e');
-            let base = parts.next().unwrap();
-            let exponent = parts.next().unwrap().parse::<i64>().unwrap();
-            let e = match case {
-                Case::Lower => 'e',
-                Case::Upper => 'E',
-            };
-            let point = decimal_point_or_empty(precision, alternate_form);
-            format!("{base}{point}{e}{exponent:+#03}")
-        }
-        magnitude if magnitude.is_nan() => format_nan(case),
-        magnitude if magnitude.is_infinite() => format_inf(case),
-        _ => "".to_string(),
-    }
-}
-
-/// If s represents a floating point value, trailing zeros and a possibly trailing
-/// decimal point will be removed.
-/// This function does NOT work with decimal commas.
-fn maybe_remove_trailing_redundant_chars(s: String, alternate_form: bool) -> String {
-    if !alternate_form && s.contains('.') {
-        // only truncate floating point values when not in alternate form
-        let s = remove_trailing_zeros(s);
-        remove_trailing_decimal_point(s)
-    } else {
-        s
-    }
-}
-
-fn remove_trailing_zeros(s: String) -> String {
-    let mut s = s;
-    while s.ends_with('0') {
-        s.pop();
-    }
-    s
-}
-
-fn remove_trailing_decimal_point(s: String) -> String {
-    let mut s = s;
-    if s.ends_with('.') {
-        s.pop();
-    }
-    s
-}
-
-pub fn format_general(
-    precision: usize,
-    magnitude: f64,
-    case: Case,
-    alternate_form: bool,
-    always_shows_fract: bool,
-) -> String {
-    match magnitude {
-        magnitude if magnitude.is_finite() => {
-            let r_exp = format!("{:.*e}", precision.saturating_sub(1), magnitude);
-            let mut parts = r_exp.splitn(2, 'e');
-            let base = parts.next().unwrap();
-            let exponent = parts.next().unwrap().parse::<i64>().unwrap();
-            if exponent < -4 || exponent + (always_shows_fract as i64) >= (precision as i64) {
-                let e = match case {
-                    Case::Lower => 'e',
-                    Case::Upper => 'E',
-                };
-                let magnitude = format!("{:.*}", precision + 1, base);
-                let base = maybe_remove_trailing_redundant_chars(magnitude, alternate_form);
-                let point = decimal_point_or_empty(precision.saturating_sub(1), alternate_form);
-                format!("{base}{point}{e}{exponent:+#03}")
-            } else {
-                let precision = ((precision as i64) - 1 - exponent) as usize;
-                let magnitude = format!("{magnitude:.precision$}");
-                let base = maybe_remove_trailing_redundant_chars(magnitude, alternate_form);
-                let point = decimal_point_or_empty(precision, alternate_form);
-                format!("{base}{point}")
-            }
-        }
-        magnitude if magnitude.is_nan() => format_nan(case),
-        magnitude if magnitude.is_infinite() => format_inf(case),
-        _ => "".to_string(),
-    }
-}
-
-// TODO: rewrite using format_general
-pub fn to_string(value: f64) -> String {
-    let lit = format!("{value:e}");
-    if let Some(position) = lit.find('e') {
-        let significand = &lit[..position];
-        let exponent = &lit[position + 1..];
-        let exponent = exponent.parse::<i32>().unwrap();
-        if exponent < 16 && exponent > -5 {
-            if is_integer(value) {
-                format!("{value:.1?}")
-            } else {
-                value.to_string()
-            }
-        } else {
-            format!("{significand}e{exponent:+#03}")
-        }
-    } else {
-        let mut s = value.to_string();
-        s.make_ascii_lowercase();
-        s
-    }
-}
-
-pub fn from_hex(s: &str) -> Option<f64> {
-    if let Ok(f) = hexf_parse::parse_hexf64(s, false) {
-        return Some(f);
-    }
-    match s.to_ascii_lowercase().as_str() {
-        "nan" | "+nan" | "-nan" => Some(f64::NAN),
-        "inf" | "infinity" | "+inf" | "+infinity" => Some(f64::INFINITY),
-        "-inf" | "-infinity" => Some(f64::NEG_INFINITY),
-        value => {
-            let mut hex = String::with_capacity(value.len());
-            let has_0x = value.contains("0x");
-            let has_p = value.contains('p');
-            let has_dot = value.contains('.');
-            let mut start = 0;
-
-            if !has_0x && value.starts_with('-') {
-                hex.push_str("-0x");
-                start += 1;
-            } else if !has_0x {
-                hex.push_str("0x");
-                if value.starts_with('+') {
-                    start += 1;
-                }
-            }
-
-            for (index, ch) in value.chars().enumerate() {
-                if ch == 'p' {
-                    if has_dot {
-                        hex.push('p');
-                    } else {
-                        hex.push_str(".p");
-                    }
-                } else if index >= start {
-                    hex.push(ch);
-                }
-            }
-
-            if !has_p && has_dot {
-                hex.push_str("p0");
-            } else if !has_p && !has_dot {
-                hex.push_str(".p0")
-            }
-
-            hexf_parse::parse_hexf64(hex.as_str(), false).ok()
-        }
-    }
-}
-
-pub fn to_hex(value: f64) -> String {
-    let (mantissa, exponent, sign) = value.integer_decode();
-    let sign_fmt = if sign < 0 { "-" } else { "" };
-    match value {
-        value if value.is_zero() => format!("{sign_fmt}0x0.0p+0"),
-        value if value.is_infinite() => format!("{sign_fmt}inf"),
-        value if value.is_nan() => "nan".to_owned(),
-        _ => {
-            const BITS: i16 = 52;
-            const FRACT_MASK: u64 = 0xf_ffff_ffff_ffff;
-            format!(
-                "{}{:#x}.{:013x}p{:+}",
-                sign_fmt,
-                mantissa >> BITS,
-                mantissa & FRACT_MASK,
-                exponent + BITS
-            )
-        }
-    }
-}
-
-#[test]
-fn test_to_hex() {
-    use rand::Rng;
-    for _ in 0..20000 {
-        let bytes = rand::rng().random::<u64>();
-        let f = f64::from_bits(bytes);
-        if !f.is_finite() {
-            continue;
-        }
-        let hex = to_hex(f);
-        // println!("{} -> {}", f, hex);
-        let roundtrip = hexf_parse::parse_hexf64(&hex, false).unwrap();
-        // println!("  -> {}", roundtrip);
-        assert!(f == roundtrip, "{f} {hex} {roundtrip}");
-    }
-}
-
-#[test]
-fn test_remove_trailing_zeros() {
-    assert!(remove_trailing_zeros(String::from("100")) == *"1");
-    assert!(remove_trailing_zeros(String::from("100.00")) == *"100.");
-
-    // leave leading zeros untouched
-    assert!(remove_trailing_zeros(String::from("001")) == *"001");
-
-    // leave strings untouched if they don't end with 0
-    assert!(remove_trailing_zeros(String::from("101")) == *"101");
-}
-
-#[test]
-fn test_remove_trailing_decimal_point() {
-    assert!(remove_trailing_decimal_point(String::from("100.")) == *"100");
-    assert!(remove_trailing_decimal_point(String::from("1.")) == *"1");
-
-    // leave leading decimal points untouched
-    assert!(remove_trailing_decimal_point(String::from(".5")) == *".5");
-}
-
-#[test]
-fn test_maybe_remove_trailing_redundant_chars() {
-    assert!(maybe_remove_trailing_redundant_chars(String::from("100."), true) == *"100.");
-    assert!(maybe_remove_trailing_redundant_chars(String::from("100."), false) == *"100");
-    assert!(maybe_remove_trailing_redundant_chars(String::from("1."), false) == *"1");
-    assert!(maybe_remove_trailing_redundant_chars(String::from("10.0"), false) == *"10");
-
-    // don't truncate integers
-    assert!(maybe_remove_trailing_redundant_chars(String::from("1000"), false) == *"1000");
-}
diff --git a/compiler/source/Cargo.toml b/compiler/source/Cargo.toml
deleted file mode 100644
index 373af47cf0..0000000000
--- a/compiler/source/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "rustpython-compiler-source"
-description = "RustPython Source and Index"
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-ruff_source_file = { workspace = true }
-ruff_text_size = { workspace = true }
-
-[lints]
-workspace = true
\ No newline at end of file
diff --git a/compiler/source/src/lib.rs b/compiler/source/src/lib.rs
deleted file mode 100644
index 2d967e218d..0000000000
--- a/compiler/source/src/lib.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-pub use ruff_source_file::{LineIndex, OneIndexed as LineNumber, SourceLocation};
-use ruff_text_size::TextRange;
-pub use ruff_text_size::TextSize;
-
-#[derive(Clone)]
-pub struct SourceCode<'src> {
-    pub path: &'src str,
-    pub text: &'src str,
-    pub index: LineIndex,
-}
-
-impl<'src> SourceCode<'src> {
-    pub fn new(path: &'src str, text: &'src str) -> Self {
-        let index = LineIndex::from_source_text(text);
-        Self { path, text, index }
-    }
-
-    pub fn line_index(&self, offset: TextSize) -> LineNumber {
-        self.index.line_index(offset)
-    }
-
-    pub fn source_location(&self, offset: TextSize) -> SourceLocation {
-        self.index.source_location(offset, self.text)
-    }
-
-    pub fn get_range(&'src self, range: TextRange) -> &'src str {
-        &self.text[range.start().to_usize()..range.end().to_usize()]
-    }
-}
-
-pub struct SourceCodeOwned {
-    pub path: String,
-    pub text: String,
-    pub index: LineIndex,
-}
-
-impl SourceCodeOwned {
-    pub fn new(path: String, text: String) -> Self {
-        let index = LineIndex::from_source_text(&text);
-        Self { path, text, index }
-    }
-}
diff --git a/compiler/src/lib.rs b/compiler/src/lib.rs
deleted file mode 100644
index 717593ac4b..0000000000
--- a/compiler/src/lib.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-use ruff_source_file::SourceLocation;
-use rustpython_codegen::{compile, symboltable};
-
-pub use rustpython_codegen::compile::CompileOpts;
-pub use rustpython_compiler_core::{Mode, bytecode::CodeObject};
-use rustpython_compiler_source::SourceCode;
-
-// these modules are out of repository. re-exporting them here for convenience.
-pub use ruff_python_ast as ast;
-pub use ruff_python_parser as parser;
-pub use rustpython_codegen as codegen;
-pub use rustpython_compiler_core as core;
-pub use rustpython_compiler_source as source;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum CompileErrorType {
-    #[error(transparent)]
-    Codegen(#[from] codegen::error::CodegenErrorType),
-    #[error(transparent)]
-    Parse(#[from] parser::ParseErrorType),
-}
-
-#[derive(Error, Debug)]
-pub struct ParseError {
-    #[source]
-    pub error: parser::ParseErrorType,
-    pub raw_location: ruff_text_size::TextRange,
-    pub location: SourceLocation,
-    pub source_path: String,
-}
-
-impl std::fmt::Display for ParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.error.fmt(f)
-    }
-}
-
-#[derive(Error, Debug)]
-pub enum CompileError {
-    #[error(transparent)]
-    Codegen(#[from] codegen::error::CodegenError),
-    #[error(transparent)]
-    Parse(#[from] ParseError),
-}
-
-impl CompileError {
-    pub fn from_ruff_parse_error(error: parser::ParseError, source_code: &SourceCode<'_>) -> Self {
-        let location = source_code.source_location(error.location.start());
-        Self::Parse(ParseError {
-            error: error.error,
-            raw_location: error.location,
-            location,
-            source_path: source_code.path.to_owned(),
-        })
-    }
-
-    pub fn location(&self) -> Option<SourceLocation> {
-        match self {
-            Self::Codegen(codegen_error) => codegen_error.location.clone(),
-            Self::Parse(parse_error) => Some(parse_error.location.clone()),
-        }
-    }
-
-    pub const fn python_location(&self) -> (usize, usize) {
-        match self {
-            Self::Codegen(codegen_error) => {
-                if let Some(location) = &codegen_error.location {
-                    (location.row.get(), location.column.get())
-                } else {
-                    (0, 0)
-                }
-            }
-            Self::Parse(parse_error) => (
-                parse_error.location.row.get(),
-                parse_error.location.column.get(),
-            ),
-        }
-    }
-
-    pub fn source_path(&self) -> &str {
-        match self {
-            Self::Codegen(codegen_error) => &codegen_error.source_path,
-            Self::Parse(parse_error) => &parse_error.source_path,
-        }
-    }
-}
-
-/// Compile a given source code into a bytecode object.
-pub fn compile(
-    source: &str,
-    mode: Mode,
-    source_path: &str,
-    opts: CompileOpts,
-) -> Result<CodeObject, CompileError> {
-    // TODO: do this less hacky; ruff's parser should translate a CRLF line
-    //       break in a multiline string into just an LF in the parsed value
-    #[cfg(windows)]
-    let source = &source.replace("\r\n", "\n");
-    let source_code = SourceCode::new(source_path, source);
-    _compile(source_code, mode, opts)
-    // let index = LineIndex::from_source_text(source);
-    // let source_code = SourceCode::new(source, &index);
-    // let mut locator = LinearLocator::new(source);
-    // let mut ast = match parser::parse(source, mode.into(), &source_path) {
-    //     Ok(x) => x,
-    //     Err(e) => return Err(locator.locate_error(e)),
-    // };
-
-    // TODO:
-    // if opts.optimize > 0 {
-    //     ast = ConstantOptimizer::new()
-    //         .fold_mod(ast)
-    //         .unwrap_or_else(|e| match e {});
-    // }
-    // let ast = locator.fold_mod(ast).unwrap_or_else(|e| match e {});
-}
-
-fn _compile(
-    source_code: SourceCode<'_>,
-    mode: Mode,
-    opts: CompileOpts,
-) -> Result<CodeObject, CompileError> {
-    let parser_mode = match mode {
-        Mode::Exec => parser::Mode::Module,
-        Mode::Eval => parser::Mode::Expression,
-        // ruff does not have an interactive mode, which is fine,
-        // since these are only different in terms of compilation
-        Mode::Single | Mode::BlockExpr => parser::Mode::Module,
-    };
-    let parsed = parser::parse(source_code.text, parser_mode.into())
-        .map_err(|err| CompileError::from_ruff_parse_error(err, &source_code))?;
-    let ast = parsed.into_syntax();
-    compile::compile_top(ast, source_code, mode, opts).map_err(|e| e.into())
-}
-
-pub fn compile_symtable(
-    source: &str,
-    mode: Mode,
-    source_path: &str,
-) -> Result<symboltable::SymbolTable, CompileError> {
-    let source_code = SourceCode::new(source_path, source);
-    _compile_symtable(source_code, mode)
-}
-
-pub fn _compile_symtable(
-    source_code: SourceCode<'_>,
-    mode: Mode,
-) -> Result<symboltable::SymbolTable, CompileError> {
-    let res = match mode {
-        Mode::Exec | Mode::Single | Mode::BlockExpr => {
-            let ast = ruff_python_parser::parse_module(source_code.text)
-                .map_err(|e| CompileError::from_ruff_parse_error(e, &source_code))?;
-            symboltable::SymbolTable::scan_program(&ast.into_syntax(), source_code.clone())
-        }
-        Mode::Eval => {
-            let ast = ruff_python_parser::parse(source_code.text, parser::Mode::Expression.into())
-                .map_err(|e| CompileError::from_ruff_parse_error(e, &source_code))?;
-            symboltable::SymbolTable::scan_expr(
-                &ast.into_syntax().expect_expression(),
-                source_code.clone(),
-            )
-        }
-    };
-    res.map_err(|e| e.into_codegen_error(source_code.path.to_owned()).into())
-}
-
-#[test]
-fn test_compile() {
-    let code = "x = 'abc'";
-    let compiled = compile(code, Mode::Single, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_phello() {
-    let code = r#"
-initialized = True
-def main():
-    print("Hello world!")
-if __name__ == '__main__':
-    main()
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_if_elif_else() {
-    let code = r#"
-if False:
-    pass
-elif False:
-    pass
-elif False:
-    pass
-else:
-    pass
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_lambda() {
-    let code = r#"
-lambda: 'a'
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_lambda2() {
-    let code = r#"
-(lambda x: f'hello, {x}')('world}')
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_lambda3() {
-    let code = r#"
-def g():
-    pass
-def f():
-    if False:
-        return lambda x: g(x)
-    elif False:
-        return g
-    else:
-        return g
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_int() {
-    let code = r#"
-a = 0xFF
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_bigint() {
-    let code = r#"
-a = 0xFFFFFFFFFFFFFFFFFFFFFFFF
-"#;
-    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_compile_fstring() {
-    let code1 = r#"
-assert f"1" == '1'
-    "#;
-    let compiled = compile(code1, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-
-    let code2 = r#"
-assert f"{1}" == '1'
-    "#;
-    let compiled = compile(code2, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-    let code3 = r#"
-assert f"{1+1}" == '2'
-    "#;
-    let compiled = compile(code3, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-
-    let code4 = r#"
-assert f"{{{(lambda: f'{1}')}" == '{1'
-    "#;
-    let compiled = compile(code4, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-
-    let code5 = r#"
-assert f"a{1}" == 'a1'
-    "#;
-    let compiled = compile(code5, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-
-    let code6 = r#"
-assert f"{{{(lambda x: f'hello, {x}')('world}')}" == '{hello, world}'
-    "#;
-    let compiled = compile(code6, Mode::Exec, "<>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
-
-#[test]
-fn test_simple_enum() {
-    let code = r#"
-import enum
-@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
-class RegexFlag:
-    NOFLAG = 0
-    DEBUG = 1
-print(RegexFlag.NOFLAG & RegexFlag.DEBUG)
-"#;
-    let compiled = compile(code, Mode::Exec, "<string>", CompileOpts::default());
-    dbg!(compiled.expect("compile error"));
-}
diff --git a/crates/codegen/Cargo.toml b/crates/codegen/Cargo.toml
new file mode 100644
index 0000000000..ce7e8d74f5
--- /dev/null
+++ b/crates/codegen/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "rustpython-codegen"
+description = "Compiler for python code into bytecode for the rustpython VM."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+rustpython-compiler-core = { workspace = true }
+rustpython-literal = {workspace = true }
+rustpython-wtf8 = { workspace = true }
+ruff_python_ast = { workspace = true }
+ruff_text_size = { workspace = true }
+
+ahash = { workspace = true }
+bitflags = { workspace = true }
+indexmap = { workspace = true }
+itertools = { workspace = true }
+log = { workspace = true }
+num-complex = { workspace = true }
+num-traits = { workspace = true }
+thiserror = { workspace = true }
+malachite-bigint = { workspace = true }
+memchr = { workspace = true }
+unicode_names2 = { workspace = true }
+
+[dev-dependencies]
+ruff_python_parser = { workspace = true }
+insta = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
new file mode 100644
index 0000000000..7782e6ec48
--- /dev/null
+++ b/crates/codegen/src/compile.rs
@@ -0,0 +1,7951 @@
+//!
+//! Take an AST and transform it into bytecode
+//!
+//! Inspirational code:
+//!   <https://github.com/python/cpython/blob/main/Python/compile.c>
+//!   <https://github.com/micropython/micropython/blob/master/py/compile.c>
+
+// spell-checker:ignore starunpack subscripter
+
+#![deny(clippy::cast_possible_truncation)]
+
+use crate::{
+    IndexMap, IndexSet, ToPythonName,
+    error::{CodegenError, CodegenErrorType, InternalError, PatternUnreachableReason},
+    ir::{self, BlockIdx},
+    symboltable::{self, CompilerScope, SymbolFlags, SymbolScope, SymbolTable},
+    unparse::UnparseExpr,
+};
+use alloc::borrow::Cow;
+use itertools::Itertools;
+use malachite_bigint::BigInt;
+use num_complex::Complex;
+use num_traits::{Num, ToPrimitive};
+use ruff_python_ast::{
+    Alias, Arguments, BoolOp, CmpOp, Comprehension, ConversionFlag, DebugText, Decorator, DictItem,
+    ExceptHandler, ExceptHandlerExceptHandler, Expr, ExprAttribute, ExprBoolOp, ExprContext,
+    ExprFString, ExprList, ExprName, ExprSlice, ExprStarred, ExprSubscript, ExprTString, ExprTuple,
+    ExprUnaryOp, FString, FStringFlags, FStringPart, Identifier, Int, InterpolatedStringElement,
+    InterpolatedStringElements, Keyword, MatchCase, ModExpression, ModModule, Operator, Parameters,
+    Pattern, PatternMatchAs, PatternMatchClass, PatternMatchMapping, PatternMatchOr,
+    PatternMatchSequence, PatternMatchSingleton, PatternMatchStar, PatternMatchValue, Singleton,
+    Stmt, StmtExpr, TString, TypeParam, TypeParamParamSpec, TypeParamTypeVar,
+    TypeParamTypeVarTuple, TypeParams, UnaryOp, WithItem,
+    visitor::{Visitor, walk_expr},
+};
+use ruff_text_size::{Ranged, TextRange};
+use std::collections::HashSet;
+
+use rustpython_compiler_core::{
+    Mode, OneIndexed, PositionEncoding, SourceFile, SourceLocation,
+    bytecode::{
+        self, AnyInstruction, Arg as OpArgMarker, BinaryOperator, BuildSliceArgCount, CodeObject,
+        ComparisonOperator, ConstantData, ConvertValueOparg, Instruction, Invert, OpArg, OpArgType,
+        PseudoInstruction, UnpackExArgs,
+    },
+};
+use rustpython_wtf8::Wtf8Buf;
+
+const MAXBLOCKS: usize = 20;
+
+#[derive(Debug, Clone, Copy)]
+pub enum FBlockType {
+    WhileLoop,
+    ForLoop,
+    TryExcept,
+    FinallyTry,
+    FinallyEnd,
+    With,
+    AsyncWith,
+    HandlerCleanup,
+    PopValue,
+    ExceptionHandler,
+    ExceptionGroupHandler,
+    AsyncComprehensionGenerator,
+    StopIteration,
+}
+
+/// Stores additional data for fblock unwinding
+// fb_datum
+#[derive(Debug, Clone)]
+pub enum FBlockDatum {
+    None,
+    /// For FinallyTry: stores the finally body statements to compile during unwind
+    FinallyBody(Vec<Stmt>),
+    /// For HandlerCleanup: stores the exception variable name (e.g., "e" in "except X as e")
+    ExceptionName(String),
+}
+
+/// Type of super() call optimization detected by can_optimize_super_call()
+#[derive(Debug, Clone)]
+enum SuperCallType<'a> {
+    /// super(class, self) - explicit 2-argument form
+    TwoArg {
+        class_arg: &'a Expr,
+        self_arg: &'a Expr,
+    },
+    /// super() - implicit 0-argument form (uses __class__ cell)
+    ZeroArg,
+}
+
+#[derive(Debug, Clone)]
+pub struct FBlockInfo {
+    pub fb_type: FBlockType,
+    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,
+}
+
+pub(crate) type InternalResult<T> = Result<T, InternalError>;
+type CompileResult<T> = Result<T, CodegenError>;
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+enum NameUsage {
+    Load,
+    Store,
+    Delete,
+}
+
+fn is_forbidden_name(name: &str) -> bool {
+    // See https://docs.python.org/3/library/constants.html#built-in-constants
+    const BUILTIN_CONSTANTS: &[&str] = &["__debug__"];
+
+    BUILTIN_CONSTANTS.contains(&name)
+}
+
+/// Main structure holding the state of compilation.
+struct Compiler {
+    code_stack: Vec<ir::CodeInfo>,
+    symbol_table_stack: Vec<SymbolTable>,
+    source_file: SourceFile,
+    // current_source_location: SourceLocation,
+    current_source_range: TextRange,
+    done_with_future_stmts: DoneWithFuture,
+    future_annotations: bool,
+    ctx: CompileContext,
+    opts: CompileOpts,
+    in_annotation: bool,
+}
+
+enum DoneWithFuture {
+    No,
+    DoneWithDoc,
+    Yes,
+}
+
+#[derive(Debug, Clone)]
+pub struct CompileOpts {
+    /// How optimized the bytecode output should be; any optimize > 0 does
+    /// not emit assert statements
+    pub optimize: u8,
+    /// Include column info in bytecode (-X no_debug_ranges disables)
+    pub debug_ranges: bool,
+}
+
+impl Default for CompileOpts {
+    fn default() -> Self {
+        Self {
+            optimize: 0,
+            debug_ranges: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct CompileContext {
+    loop_data: Option<(BlockIdx, BlockIdx)>,
+    in_class: bool,
+    func: FunctionContext,
+    /// True if we're anywhere inside an async function (even inside nested comprehensions)
+    in_async_scope: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum FunctionContext {
+    NoFunction,
+    Function,
+    AsyncFunction,
+}
+
+impl CompileContext {
+    fn in_func(self) -> bool {
+        self.func != FunctionContext::NoFunction
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum ComprehensionType {
+    Generator,
+    List,
+    Set,
+    Dict,
+}
+
+fn validate_duplicate_params(params: &Parameters) -> Result<(), CodegenErrorType> {
+    let mut seen_params = HashSet::new();
+    for param in params {
+        let param_name = param.name().as_str();
+        if !seen_params.insert(param_name) {
+            return Err(CodegenErrorType::SyntaxError(format!(
+                r#"Duplicate parameter "{param_name}""#
+            )));
+        }
+    }
+
+    Ok(())
+}
+
+/// Compile an Mod produced from ruff parser
+pub fn compile_top(
+    ast: ruff_python_ast::Mod,
+    source_file: SourceFile,
+    mode: Mode,
+    opts: CompileOpts,
+) -> CompileResult<CodeObject> {
+    match ast {
+        ruff_python_ast::Mod::Module(module) => match mode {
+            Mode::Exec | Mode::Eval => compile_program(&module, source_file, opts),
+            Mode::Single => compile_program_single(&module, source_file, opts),
+            Mode::BlockExpr => compile_block_expression(&module, source_file, opts),
+        },
+        ruff_python_ast::Mod::Expression(expr) => compile_expression(&expr, source_file, opts),
+    }
+}
+
+/// Compile a standard Python program to bytecode
+pub fn compile_program(
+    ast: &ModModule,
+    source_file: SourceFile,
+    opts: CompileOpts,
+) -> CompileResult<CodeObject> {
+    let symbol_table = SymbolTable::scan_program(ast, source_file.clone())
+        .map_err(|e| e.into_codegen_error(source_file.name().to_owned()))?;
+    let mut compiler = Compiler::new(opts, source_file, "<module>".to_owned());
+    compiler.compile_program(ast, symbol_table)?;
+    let code = compiler.exit_scope();
+    trace!("Compilation completed: {code:?}");
+    Ok(code)
+}
+
+/// Compile a Python program to bytecode for the context of a REPL
+pub fn compile_program_single(
+    ast: &ModModule,
+    source_file: SourceFile,
+    opts: CompileOpts,
+) -> CompileResult<CodeObject> {
+    let symbol_table = SymbolTable::scan_program(ast, source_file.clone())
+        .map_err(|e| e.into_codegen_error(source_file.name().to_owned()))?;
+    let mut compiler = Compiler::new(opts, source_file, "<module>".to_owned());
+    compiler.compile_program_single(&ast.body, symbol_table)?;
+    let code = compiler.exit_scope();
+    trace!("Compilation completed: {code:?}");
+    Ok(code)
+}
+
+pub fn compile_block_expression(
+    ast: &ModModule,
+    source_file: SourceFile,
+    opts: CompileOpts,
+) -> CompileResult<CodeObject> {
+    let symbol_table = SymbolTable::scan_program(ast, source_file.clone())
+        .map_err(|e| e.into_codegen_error(source_file.name().to_owned()))?;
+    let mut compiler = Compiler::new(opts, source_file, "<module>".to_owned());
+    compiler.compile_block_expr(&ast.body, symbol_table)?;
+    let code = compiler.exit_scope();
+    trace!("Compilation completed: {code:?}");
+    Ok(code)
+}
+
+pub fn compile_expression(
+    ast: &ModExpression,
+    source_file: SourceFile,
+    opts: CompileOpts,
+) -> CompileResult<CodeObject> {
+    let symbol_table = SymbolTable::scan_expr(ast, source_file.clone())
+        .map_err(|e| e.into_codegen_error(source_file.name().to_owned()))?;
+    let mut compiler = Compiler::new(opts, source_file, "<module>".to_owned());
+    compiler.compile_eval(ast, symbol_table)?;
+    let code = compiler.exit_scope();
+    Ok(code)
+}
+
+macro_rules! emit {
+    // Struct variant with single identifier (e.g., Foo::A { arg })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident $(,)? } $(,)?) => {
+        $c.emit_arg($arg, |x| $enum::$op { $arg: x })
+    };
+
+    // Struct variant with explicit value (e.g., Foo::A { arg: 42 })
+    ($c:expr, $enum:ident :: $op:ident { $arg:ident : $arg_val:expr $(,)? } $(,)?) => {
+        $c.emit_arg($arg_val, |x| $enum::$op { $arg: x })
+    };
+
+    // Tuple variant (e.g., Foo::B(42))
+    ($c:expr, $enum:ident :: $op:ident($arg_val:expr $(,)? ) $(,)?) => {
+        $c.emit_arg($arg_val, $enum::$op)
+    };
+
+    // No-arg variant (e.g., Foo::C)
+    ($c:expr, $enum:ident :: $op:ident $(,)?) => {
+        $c.emit_no_arg($enum::$op)
+    };
+}
+
+fn eprint_location(zelf: &Compiler) {
+    let start = zelf
+        .source_file
+        .to_source_code()
+        .source_location(zelf.current_source_range.start(), PositionEncoding::Utf8);
+    let end = zelf
+        .source_file
+        .to_source_code()
+        .source_location(zelf.current_source_range.end(), PositionEncoding::Utf8);
+    eprintln!(
+        "LOCATION: {} from {}:{} to {}:{}",
+        zelf.source_file.name(),
+        start.line,
+        start.character_offset,
+        end.line,
+        end.character_offset
+    );
+}
+
+/// Better traceback for internal error
+#[track_caller]
+fn unwrap_internal<T>(zelf: &Compiler, r: InternalResult<T>) -> T {
+    if let Err(ref r_err) = r {
+        eprintln!("=== CODEGEN PANIC INFO ===");
+        eprintln!("This IS an internal error: {r_err}");
+        eprint_location(zelf);
+        eprintln!("=== END PANIC INFO ===");
+    }
+    r.unwrap()
+}
+
+fn compiler_unwrap_option<T>(zelf: &Compiler, o: Option<T>) -> T {
+    if o.is_none() {
+        eprintln!("=== CODEGEN PANIC INFO ===");
+        eprintln!("This IS an internal error, an option was unwrapped during codegen");
+        eprint_location(zelf);
+        eprintln!("=== END PANIC INFO ===");
+    }
+    o.unwrap()
+}
+
+// fn compiler_result_unwrap<T, E: core::fmt::Debug>(zelf: &Compiler, result: Result<T, E>) -> T {
+//     if result.is_err() {
+//         eprintln!("=== CODEGEN PANIC INFO ===");
+//         eprintln!("This IS an internal error, an result was unwrapped during codegen");
+//         eprint_location(zelf);
+//         eprintln!("=== END PANIC INFO ===");
+//     }
+//     result.unwrap()
+// }
+
+/// The pattern context holds information about captured names and jump targets.
+#[derive(Clone)]
+pub struct PatternContext {
+    /// A list of names captured by the pattern.
+    pub stores: Vec<String>,
+    /// If false, then any name captures against our subject will raise.
+    pub allow_irrefutable: bool,
+    /// A list of jump target labels used on pattern failure.
+    pub fail_pop: Vec<BlockIdx>,
+    /// The number of items on top of the stack that should remain.
+    pub on_top: usize,
+}
+
+impl Default for PatternContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl PatternContext {
+    pub const fn new() -> Self {
+        Self {
+            stores: Vec::new(),
+            allow_irrefutable: false,
+            fail_pop: Vec::new(),
+            on_top: 0,
+        }
+    }
+
+    pub fn fail_pop_size(&self) -> usize {
+        self.fail_pop.len()
+    }
+}
+
+enum JumpOp {
+    Jump,
+    PopJumpIfFalse,
+}
+
+/// Type of collection to build in starunpack_helper
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum CollectionType {
+    Tuple,
+    List,
+    Set,
+}
+
+impl Compiler {
+    fn new(opts: CompileOpts, source_file: SourceFile, code_name: String) -> Self {
+        let module_code = ir::CodeInfo {
+            flags: bytecode::CodeFlags::NEWLOCALS,
+            source_path: source_file.name().to_owned(),
+            private: None,
+            blocks: vec![ir::Block::default()],
+            current_block: BlockIdx::new(0),
+            metadata: ir::CodeUnitMetadata {
+                name: code_name.clone(),
+                qualname: Some(code_name),
+                consts: IndexSet::default(),
+                names: IndexSet::default(),
+                varnames: IndexSet::default(),
+                cellvars: IndexSet::default(),
+                freevars: IndexSet::default(),
+                fast_hidden: IndexMap::default(),
+                argcount: 0,
+                posonlyargcount: 0,
+                kwonlyargcount: 0,
+                firstlineno: OneIndexed::MIN,
+            },
+            static_attributes: None,
+            in_inlined_comp: false,
+            fblock: Vec::with_capacity(MAXBLOCKS),
+            symbol_table_index: 0, // Module is always the first symbol table
+        };
+        Self {
+            code_stack: vec![module_code],
+            symbol_table_stack: Vec::new(),
+            source_file,
+            // current_source_location: SourceLocation::default(),
+            current_source_range: TextRange::default(),
+            done_with_future_stmts: DoneWithFuture::No,
+            future_annotations: false,
+            ctx: CompileContext {
+                loop_data: None,
+                in_class: false,
+                func: FunctionContext::NoFunction,
+                in_async_scope: false,
+            },
+            opts,
+            in_annotation: false,
+        }
+    }
+
+    /// Check if the slice is a two-element slice (no step)
+    // = is_two_element_slice
+    const fn is_two_element_slice(slice: &Expr) -> bool {
+        matches!(slice, Expr::Slice(s) if s.step.is_none())
+    }
+
+    /// Compile a slice expression
+    // = compiler_slice
+    fn compile_slice(&mut self, s: &ExprSlice) -> CompileResult<BuildSliceArgCount> {
+        // Compile lower
+        if let Some(lower) = &s.lower {
+            self.compile_expression(lower)?;
+        } else {
+            self.emit_load_const(ConstantData::None);
+        }
+
+        // Compile upper
+        if let Some(upper) = &s.upper {
+            self.compile_expression(upper)?;
+        } else {
+            self.emit_load_const(ConstantData::None);
+        }
+
+        Ok(match &s.step {
+            Some(step) => {
+                // Compile step if present
+                self.compile_expression(step)?;
+                BuildSliceArgCount::Three
+            }
+            None => BuildSliceArgCount::Two,
+        })
+    }
+
+    /// Compile a subscript expression
+    // = compiler_subscript
+    fn compile_subscript(
+        &mut self,
+        value: &Expr,
+        slice: &Expr,
+        ctx: 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 == ExprContext::Load {
+        //     check_subscripter(value);
+        //     check_index(value, slice);
+        // }
+
+        // VISIT(c, expr, e->v.Subscript.value)
+        self.compile_expression(value)?;
+
+        // Handle two-element slice (for Load/Store, not Del)
+        if Self::is_two_element_slice(slice) && !matches!(ctx, ExprContext::Del) {
+            let argc = match slice {
+                Expr::Slice(s) => self.compile_slice(s)?,
+                _ => unreachable!("is_two_element_slice should only return true for Expr::Slice"),
+            };
+            match ctx {
+                ExprContext::Load => {
+                    emit!(self, Instruction::BuildSlice { argc });
+                    emit!(self, Instruction::Subscript);
+                }
+                ExprContext::Store => {
+                    emit!(self, Instruction::BuildSlice { argc });
+                    emit!(self, Instruction::StoreSubscr);
+                }
+                _ => unreachable!(),
+            }
+        } else {
+            // VISIT(c, expr, e->v.Subscript.slice)
+            self.compile_expression(slice)?;
+
+            // Emit appropriate instruction based on context
+            match ctx {
+                ExprContext::Load => emit!(self, Instruction::Subscript),
+                ExprContext::Store => emit!(self, Instruction::StoreSubscr),
+                ExprContext::Del => emit!(self, Instruction::DeleteSubscr),
+                ExprContext::Invalid => {
+                    return Err(self.error(CodegenErrorType::SyntaxError(
+                        "Invalid expression context".to_owned(),
+                    )));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Helper function for compiling tuples/lists/sets with starred expressions
+    ///
+    /// Parameters:
+    /// - elts: The elements to compile
+    /// - pushed: Number of items already on the stack
+    /// - collection_type: What type of collection to build (tuple, list, set)
+    ///
+    // = starunpack_helper in compile.c
+    fn starunpack_helper(
+        &mut self,
+        elts: &[Expr],
+        pushed: u32,
+        collection_type: CollectionType,
+    ) -> CompileResult<()> {
+        // Use RustPython's existing approach with BuildXFromTuples
+        let (size, unpack) = self.gather_elements(pushed, elts)?;
+
+        if unpack {
+            // Has starred elements
+            match collection_type {
+                CollectionType::Tuple => {
+                    if size > 1 || pushed > 0 {
+                        emit!(self, Instruction::BuildTupleFromTuples { size });
+                    }
+                    // If size == 1 and pushed == 0, the single tuple is already on the stack
+                }
+                CollectionType::List => {
+                    emit!(self, Instruction::BuildListFromTuples { size });
+                }
+                CollectionType::Set => {
+                    emit!(self, Instruction::BuildSetFromTuples { size });
+                }
+            }
+        } else {
+            // No starred elements
+            match collection_type {
+                CollectionType::Tuple => {
+                    emit!(self, Instruction::BuildTuple { size });
+                }
+                CollectionType::List => {
+                    emit!(self, Instruction::BuildList { size });
+                }
+                CollectionType::Set => {
+                    emit!(self, Instruction::BuildSet { size });
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn error(&mut self, error: CodegenErrorType) -> CodegenError {
+        self.error_ranged(error, self.current_source_range)
+    }
+
+    fn error_ranged(&mut self, error: CodegenErrorType, range: TextRange) -> CodegenError {
+        let location = self
+            .source_file
+            .to_source_code()
+            .source_location(range.start(), PositionEncoding::Utf8);
+        CodegenError {
+            error,
+            location: Some(location),
+            source_path: self.source_file.name().to_owned(),
+        }
+    }
+
+    /// Get the SymbolTable for the current scope.
+    fn current_symbol_table(&self) -> &SymbolTable {
+        self.symbol_table_stack
+            .last()
+            .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> {
+        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())
+    }
+
+    /// Get the index of a cell variable.
+    fn get_cell_var_index(&mut self, name: &str) -> CompileResult<u32> {
+        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())
+    }
+
+    /// Get the index of a local variable.
+    fn get_local_var_index(&mut self, name: &str) -> CompileResult<u32> {
+        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())
+    }
+
+    /// Get the index of a global name.
+    fn get_global_name_index(&mut self, name: &str) -> u32 {
+        let info = self.code_stack.last_mut().unwrap();
+        let idx = info
+            .metadata
+            .names
+            .get_index_of(name)
+            .unwrap_or_else(|| info.metadata.names.insert_full(name.to_owned()).0);
+        idx.to_u32()
+    }
+
+    /// Push the next symbol table on to the stack
+    fn push_symbol_table(&mut self) -> CompileResult<&SymbolTable> {
+        // Look up the next table contained in the scope of the current table
+        let current_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table");
+
+        if current_table.next_sub_table >= current_table.sub_tables.len() {
+            let name = current_table.name.clone();
+            let typ = current_table.typ;
+            return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                "no symbol table available in {} (type: {:?})",
+                name, typ
+            ))));
+        }
+
+        let idx = current_table.next_sub_table;
+        current_table.next_sub_table += 1;
+        let table = current_table.sub_tables[idx].clone();
+
+        // Push the next table onto the stack
+        self.symbol_table_stack.push(table);
+        Ok(self.current_symbol_table())
+    }
+
+    /// Pop the current symbol table off the stack
+    fn pop_symbol_table(&mut self) -> SymbolTable {
+        self.symbol_table_stack.pop().expect("compiler bug")
+    }
+
+    /// Check if a super() call can be optimized
+    /// Returns Some(SuperCallType) if optimization is possible, None otherwise
+    fn can_optimize_super_call<'a>(
+        &self,
+        value: &'a Expr,
+        attr: &str,
+    ) -> Option<SuperCallType<'a>> {
+        use ruff_python_ast::*;
+
+        // 1. value must be a Call expression
+        let Expr::Call(ExprCall {
+            func, arguments, ..
+        }) = value
+        else {
+            return None;
+        };
+
+        // 2. func must be Name("super")
+        let Expr::Name(ExprName { id, .. }) = func.as_ref() else {
+            return None;
+        };
+        if id.as_str() != "super" {
+            return None;
+        }
+
+        // 3. attr must not be "__class__"
+        if attr == "__class__" {
+            return None;
+        }
+
+        // 4. No keyword arguments
+        if !arguments.keywords.is_empty() {
+            return None;
+        }
+
+        // 5. Must be inside a function (not at module level or class body)
+        if !self.ctx.in_func() {
+            return None;
+        }
+
+        // 6. "super" must be GlobalImplicit (not redefined locally or at module level)
+        let table = self.current_symbol_table();
+        if let Some(symbol) = table.lookup("super")
+            && symbol.scope != SymbolScope::GlobalImplicit
+        {
+            return None;
+        }
+        // Also check top-level scope to detect module-level shadowing.
+        // Only block if super is actually *bound* at module level (not just used).
+        if let Some(top_table) = self.symbol_table_stack.first()
+            && let Some(sym) = top_table.lookup("super")
+            && sym.scope != SymbolScope::GlobalImplicit
+        {
+            return None;
+        }
+
+        // 7. Check argument pattern
+        let args = &arguments.args;
+
+        // No starred expressions allowed
+        if args.iter().any(|arg| matches!(arg, Expr::Starred(_))) {
+            return None;
+        }
+
+        match args.len() {
+            2 => {
+                // 2-arg: super(class, self)
+                Some(SuperCallType::TwoArg {
+                    class_arg: &args[0],
+                    self_arg: &args[1],
+                })
+            }
+            0 => {
+                // 0-arg: super() - need __class__ cell and first parameter
+                // Enclosing function should have at least one positional argument
+                let info = self.code_stack.last()?;
+                if info.metadata.argcount == 0 && info.metadata.posonlyargcount == 0 {
+                    return None;
+                }
+
+                // Check if __class__ is available as a cell/free variable
+                // The scope must be Free (from enclosing class) or have FREE_CLASS flag
+                if let Some(symbol) = table.lookup("__class__") {
+                    if symbol.scope != SymbolScope::Free
+                        && !symbol.flags.contains(SymbolFlags::FREE_CLASS)
+                    {
+                        return None;
+                    }
+                } else {
+                    // __class__ not in symbol table, optimization not possible
+                    return None;
+                }
+
+                Some(SuperCallType::ZeroArg)
+            }
+            _ => None, // 1 or 3+ args - not optimizable
+        }
+    }
+
+    /// Load arguments for super() optimization onto the stack
+    /// Stack result: [global_super, class, self]
+    fn load_args_for_super(&mut self, super_type: &SuperCallType<'_>) -> CompileResult<()> {
+        // 1. Load global super
+        self.compile_name("super", NameUsage::Load)?;
+
+        match super_type {
+            SuperCallType::TwoArg {
+                class_arg,
+                self_arg,
+            } => {
+                // 2-arg: load provided arguments
+                self.compile_expression(class_arg)?;
+                self.compile_expression(self_arg)?;
+            }
+            SuperCallType::ZeroArg => {
+                // 0-arg: load __class__ cell and first parameter
+                // Load __class__ from cell/free variable
+                let scope = self.get_ref_type("__class__").map_err(|e| self.error(e))?;
+                let idx = match scope {
+                    SymbolScope::Cell => self.get_cell_var_index("__class__")?,
+                    SymbolScope::Free => self.get_free_var_index("__class__")?,
+                    _ => {
+                        return Err(self.error(CodegenErrorType::SyntaxError(
+                            "super(): __class__ cell not found".to_owned(),
+                        )));
+                    }
+                };
+                self.emit_arg(idx, Instruction::LoadDeref);
+
+                // Load first parameter (typically 'self').
+                // Safety: can_optimize_super_call() ensures argcount > 0, and
+                // parameters are always added to varnames first (see symboltable.rs).
+                let first_param = {
+                    let info = self.code_stack.last().unwrap();
+                    info.metadata.varnames.first().cloned()
+                };
+                let first_param = first_param.ok_or_else(|| {
+                    self.error(CodegenErrorType::SyntaxError(
+                        "super(): no arguments and no first parameter".to_owned(),
+                    ))
+                })?;
+                self.compile_name(&first_param, NameUsage::Load)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Check if this is an inlined comprehension context (PEP 709)
+    /// Currently disabled - always returns false to avoid stack issues
+    fn is_inlined_comprehension_context(&self, _comprehension_type: ComprehensionType) -> bool {
+        // TODO: Implement PEP 709 inlined comprehensions properly
+        // For now, disabled to avoid stack underflow issues
+        false
+    }
+
+    /// Enter a new scope
+    // = compiler_enter_scope
+    fn enter_scope(
+        &mut self,
+        name: &str,
+        scope_type: CompilerScope,
+        key: usize, // In RustPython, we use the index in symbol_table_stack as key
+        lineno: u32,
+    ) -> CompileResult<()> {
+        // Create location
+        let location = SourceLocation {
+            line: OneIndexed::new(lineno as usize).unwrap_or(OneIndexed::MIN),
+            character_offset: OneIndexed::MIN,
+        };
+
+        // Allocate a new compiler unit
+
+        // In Rust, we'll create the structure directly
+        let source_path = self.source_file.name().to_owned();
+
+        // Lookup symbol table entry using key (_PySymtable_Lookup)
+        let ste = match self.symbol_table_stack.get(key) {
+            Some(v) => v,
+            None => {
+                return Err(self.error(CodegenErrorType::SyntaxError(
+                    "unknown symbol table entry".to_owned(),
+                )));
+            }
+        };
+
+        // 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)
+        let mut cellvar_cache = IndexSet::default();
+        let mut cell_names: Vec<_> = ste
+            .symbols
+            .iter()
+            .filter(|(_, s)| s.scope == SymbolScope::Cell)
+            .map(|(name, _)| name.clone())
+            .collect();
+        cell_names.sort();
+        for name in cell_names {
+            cellvar_cache.insert(name);
+        }
+
+        // Handle implicit __class__ cell if needed
+        if ste.needs_class_closure {
+            // Cook up an implicit __class__ cell
+            debug_assert_eq!(scope_type, CompilerScope::Class);
+            cellvar_cache.insert("__class__".to_string());
+        }
+
+        // Handle implicit __classdict__ cell if needed
+        if ste.needs_classdict {
+            // Cook up an implicit __classdict__ cell
+            debug_assert_eq!(scope_type, CompilerScope::Class);
+            cellvar_cache.insert("__classdict__".to_string());
+        }
+
+        // Build freevars using dictbytype (FREE scope, offset by cellvars size)
+        let mut freevar_cache = IndexSet::default();
+        let mut free_names: Vec<_> = ste
+            .symbols
+            .iter()
+            .filter(|(_, s)| {
+                s.scope == SymbolScope::Free || s.flags.contains(SymbolFlags::FREE_CLASS)
+            })
+            .map(|(name, _)| name.clone())
+            .collect();
+        free_names.sort();
+        for name in free_names {
+            freevar_cache.insert(name);
+        }
+
+        // Initialize u_metadata fields
+        let (flags, posonlyarg_count, arg_count, kwonlyarg_count) = match scope_type {
+            CompilerScope::Module => (bytecode::CodeFlags::empty(), 0, 0, 0),
+            CompilerScope::Class => (bytecode::CodeFlags::empty(), 0, 0, 0),
+            CompilerScope::Function | CompilerScope::AsyncFunction | CompilerScope::Lambda => (
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
+                0, // Will be set later in enter_function
+                0, // Will be set later in enter_function
+                0, // Will be set later in enter_function
+            ),
+            CompilerScope::Comprehension => (
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
+                0,
+                1, // comprehensions take one argument (.0)
+                0,
+            ),
+            CompilerScope::TypeParams => (
+                bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
+                0,
+                0,
+                0,
+            ),
+        };
+
+        // Get private name from parent scope
+        let private = if !self.code_stack.is_empty() {
+            self.code_stack.last().unwrap().private.clone()
+        } else {
+            None
+        };
+
+        // Create the new compilation unit
+        let code_info = ir::CodeInfo {
+            flags,
+            source_path: source_path.clone(),
+            private,
+            blocks: vec![ir::Block::default()],
+            current_block: BlockIdx::new(0),
+            metadata: ir::CodeUnitMetadata {
+                name: name.to_owned(),
+                qualname: None, // Will be set below
+                consts: IndexSet::default(),
+                names: IndexSet::default(),
+                varnames: varname_cache,
+                cellvars: cellvar_cache,
+                freevars: freevar_cache,
+                fast_hidden: IndexMap::default(),
+                argcount: arg_count,
+                posonlyargcount: posonlyarg_count,
+                kwonlyargcount: kwonlyarg_count,
+                firstlineno: OneIndexed::new(lineno as usize).unwrap_or(OneIndexed::MIN),
+            },
+            static_attributes: if scope_type == CompilerScope::Class {
+                Some(IndexSet::default())
+            } else {
+                None
+            },
+            in_inlined_comp: false,
+            fblock: Vec::with_capacity(MAXBLOCKS),
+            symbol_table_index: key,
+        };
+
+        // Push the old compiler unit on the stack (like PyCapsule)
+        // This happens before setting qualname
+        self.code_stack.push(code_info);
+
+        // Set qualname after pushing (uses compiler_set_qualname logic)
+        if scope_type != CompilerScope::Module {
+            self.set_qualname();
+        }
+
+        // Emit RESUME instruction
+        let _resume_loc = if scope_type == CompilerScope::Module {
+            // Module scope starts with lineno 0
+            SourceLocation {
+                line: OneIndexed::MIN,
+                character_offset: OneIndexed::MIN,
+            }
+        } else {
+            location
+        };
+
+        // Set the source range for the RESUME instruction
+        // For now, just use an empty range at the beginning
+        self.current_source_range = TextRange::default();
+        emit!(
+            self,
+            Instruction::Resume {
+                arg: bytecode::ResumeType::AtFuncStart as u32
+            }
+        );
+
+        if scope_type == CompilerScope::Module {
+            // This would be loc.lineno = -1 in CPython
+            // We handle this differently in RustPython
+        }
+
+        Ok(())
+    }
+
+    fn push_output(
+        &mut self,
+        flags: bytecode::CodeFlags,
+        posonlyarg_count: u32,
+        arg_count: u32,
+        kwonlyarg_count: u32,
+        obj_name: String,
+    ) -> CompileResult<()> {
+        // First push the symbol table
+        let table = self.push_symbol_table()?;
+        let scope_type = table.typ;
+
+        // The key is the current position in the symbol table stack
+        let key = self.symbol_table_stack.len() - 1;
+
+        // Get the line number
+        let lineno = self.get_source_line_number().get();
+
+        // Call enter_scope which does most of the work
+        self.enter_scope(&obj_name, scope_type, key, lineno.to_u32())?;
+
+        // Override the values that push_output sets explicitly
+        // enter_scope sets default values based on scope_type, but push_output
+        // allows callers to specify exact values
+        if let Some(info) = self.code_stack.last_mut() {
+            info.flags = flags;
+            info.metadata.argcount = arg_count;
+            info.metadata.posonlyargcount = posonlyarg_count;
+            info.metadata.kwonlyargcount = kwonlyarg_count;
+        }
+        Ok(())
+    }
+
+    // compiler_exit_scope
+    fn exit_scope(&mut self) -> CodeObject {
+        let _table = self.pop_symbol_table();
+
+        // Various scopes can have sub_tables:
+        // - TypeParams scope can have sub_tables (the function body's symbol table)
+        // - Module scope can have sub_tables (for TypeAlias scopes, nested functions, classes)
+        // - Function scope can have sub_tables (for nested functions, classes)
+        // - Class scope can have sub_tables (for nested classes, methods)
+
+        let pop = self.code_stack.pop();
+        let stack_top = compiler_unwrap_option(self, pop);
+        // No parent scope stack to maintain
+        unwrap_internal(self, stack_top.finalize_code(&self.opts))
+    }
+
+    /// Push a new fblock
+    // = compiler_push_fblock
+    fn push_fblock(
+        &mut self,
+        fb_type: FBlockType,
+        fb_block: BlockIdx,
+        fb_exit: BlockIdx,
+    ) -> CompileResult<()> {
+        self.push_fblock_full(
+            fb_type,
+            fb_block,
+            fb_exit,
+            None,
+            0,
+            false,
+            FBlockDatum::None,
+        )
+    }
+
+    /// Push an fblock with exception handler info
+    fn push_fblock_with_handler(
+        &mut self,
+        fb_type: FBlockType,
+        fb_block: BlockIdx,
+        fb_exit: BlockIdx,
+        fb_handler: Option<BlockIdx>,
+        fb_stack_depth: u32,
+        fb_preserve_lasti: bool,
+    ) -> CompileResult<()> {
+        self.push_fblock_full(
+            fb_type,
+            fb_block,
+            fb_exit,
+            fb_handler,
+            fb_stack_depth,
+            fb_preserve_lasti,
+            FBlockDatum::None,
+        )
+    }
+
+    /// Push an fblock with all parameters including fb_datum
+    #[allow(clippy::too_many_arguments)]
+    fn push_fblock_full(
+        &mut self,
+        fb_type: FBlockType,
+        fb_block: BlockIdx,
+        fb_exit: BlockIdx,
+        fb_handler: Option<BlockIdx>,
+        fb_stack_depth: u32,
+        fb_preserve_lasti: bool,
+        fb_datum: FBlockDatum,
+    ) -> CompileResult<()> {
+        let code = self.current_code_info();
+        if code.fblock.len() >= MAXBLOCKS {
+            return Err(self.error(CodegenErrorType::SyntaxError(
+                "too many statically nested blocks".to_owned(),
+            )));
+        }
+        code.fblock.push(FBlockInfo {
+            fb_type,
+            fb_block,
+            fb_exit,
+            fb_handler,
+            fb_stack_depth,
+            fb_preserve_lasti,
+            fb_datum,
+        });
+        Ok(())
+    }
+
+    /// Pop an fblock
+    // = compiler_pop_fblock
+    fn pop_fblock(&mut self, _expected_type: FBlockType) -> FBlockInfo {
+        let code = self.current_code_info();
+        // TODO: Add assertion to check expected type matches
+        // assert!(matches!(fblock.fb_type, expected_type));
+        code.fblock.pop().expect("fblock stack underflow")
+    }
+
+    /// Unwind a single fblock, emitting cleanup code
+    /// preserve_tos: if true, preserve the top of stack (e.g., return value)
+    fn unwind_fblock(&mut self, info: &FBlockInfo, preserve_tos: bool) -> CompileResult<()> {
+        match info.fb_type {
+            FBlockType::WhileLoop
+            | FBlockType::ExceptionHandler
+            | FBlockType::ExceptionGroupHandler
+            | FBlockType::AsyncComprehensionGenerator
+            | FBlockType::StopIteration => {
+                // No cleanup needed
+            }
+
+            FBlockType::ForLoop => {
+                // Pop the iterator
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop);
+            }
+
+            FBlockType::TryExcept => {
+                // No POP_BLOCK with exception table, just pop fblock
+            }
+
+            FBlockType::FinallyTry => {
+                // FinallyTry is now handled specially in unwind_fblock_stack
+                // to avoid infinite recursion when the finally body contains return/break/continue.
+                // This branch should not be reached.
+                unreachable!("FinallyTry should be handled by unwind_fblock_stack");
+            }
+
+            FBlockType::FinallyEnd => {
+                // Stack when in FinallyEnd: [..., prev_exc, exc] or
+                // [..., prev_exc, exc, return_value] if preserve_tos
+                // Note: No lasti here - it's only pushed for cleanup handler exceptions
+                // We need to pop: exc, prev_exc (via PopExcept)
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop); // exc
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopExcept); // prev_exc is restored
+            }
+
+            FBlockType::With | FBlockType::AsyncWith => {
+                // Stack when entering: [..., __exit__, return_value (if preserve_tos)]
+                // Need to call __exit__(None, None, None)
+
+                emit!(self, PseudoInstruction::PopBlock);
+
+                // If preserving return value, swap it below __exit__
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                // 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]
+                self.emit_load_const(ConstantData::None);
+                self.emit_load_const(ConstantData::None);
+                self.emit_load_const(ConstantData::None);
+                // Stack: [..., __exit__, NULL, None, None, None]
+                emit!(self, Instruction::Call { nargs: 3 });
+
+                // For async with, await the result
+                if matches!(info.fb_type, FBlockType::AsyncWith) {
+                    emit!(self, Instruction::GetAwaitable);
+                    self.emit_load_const(ConstantData::None);
+                    self.compile_yield_from_sequence(true)?;
+                }
+
+                // Pop the __exit__ result
+                emit!(self, Instruction::PopTop);
+            }
+
+            FBlockType::HandlerCleanup => {
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopExcept);
+
+                // If there's an exception name, clean it up
+                if let FBlockDatum::ExceptionName(ref name) = info.fb_datum {
+                    self.emit_load_const(ConstantData::None);
+                    self.store_name(name)?;
+                    self.compile_name(name, NameUsage::Delete)?;
+                }
+            }
+
+            FBlockType::PopValue => {
+                if preserve_tos {
+                    emit!(self, Instruction::Swap { index: 2 });
+                }
+                emit!(self, Instruction::PopTop);
+            }
+        }
+        Ok(())
+    }
+
+    /// Unwind the fblock stack, emitting cleanup code for each block
+    /// preserve_tos: if true, preserve the top of stack (e.g., return value)
+    /// stop_at_loop: if true, stop when encountering a loop (for break/continue)
+    fn unwind_fblock_stack(&mut self, preserve_tos: bool, stop_at_loop: bool) -> CompileResult<()> {
+        // Collect the info we need, with indices for FinallyTry blocks
+        #[derive(Clone)]
+        enum UnwindInfo {
+            Normal(FBlockInfo),
+            FinallyTry {
+                body: Vec<ruff_python_ast::Stmt>,
+                fblock_idx: usize,
+            },
+        }
+        let mut unwind_infos = Vec::new();
+
+        {
+            let code = self.current_code_info();
+            for i in (0..code.fblock.len()).rev() {
+                // Check for exception group handler (forbidden)
+                if matches!(code.fblock[i].fb_type, FBlockType::ExceptionGroupHandler) {
+                    return Err(self.error(CodegenErrorType::BreakContinueReturnInExceptStar));
+                }
+
+                // Stop at loop if requested
+                if stop_at_loop
+                    && matches!(
+                        code.fblock[i].fb_type,
+                        FBlockType::WhileLoop | FBlockType::ForLoop
+                    )
+                {
+                    break;
+                }
+
+                if matches!(code.fblock[i].fb_type, FBlockType::FinallyTry) {
+                    if let FBlockDatum::FinallyBody(ref body) = code.fblock[i].fb_datum {
+                        unwind_infos.push(UnwindInfo::FinallyTry {
+                            body: body.clone(),
+                            fblock_idx: i,
+                        });
+                    }
+                } else {
+                    unwind_infos.push(UnwindInfo::Normal(code.fblock[i].clone()));
+                }
+            }
+        }
+
+        // Process each fblock
+        for info in unwind_infos {
+            match info {
+                UnwindInfo::Normal(fblock_info) => {
+                    self.unwind_fblock(&fblock_info, preserve_tos)?;
+                }
+                UnwindInfo::FinallyTry { body, fblock_idx } => {
+                    // Temporarily remove the FinallyTry fblock so nested return/break/continue
+                    // in the finally body won't see it again
+                    let code = self.current_code_info();
+                    let saved_fblock = code.fblock.remove(fblock_idx);
+
+                    // Push PopValue fblock if preserving tos
+                    // IMPORTANT: When preserving TOS (return value), we need to update the
+                    // exception handler's stack_depth to account for the return value on stack.
+                    // Otherwise, if an exception occurs during the finally body, the stack
+                    // will be unwound to the wrong depth and the return value will be lost.
+                    if preserve_tos {
+                        // Get the handler info from the saved fblock (or current handler)
+                        // and create a new handler with stack_depth + 1
+                        let (handler, stack_depth, preserve_lasti) =
+                            if let Some(handler) = saved_fblock.fb_handler {
+                                (
+                                    Some(handler),
+                                    saved_fblock.fb_stack_depth + 1, // +1 for return value
+                                    saved_fblock.fb_preserve_lasti,
+                                )
+                            } else {
+                                // No handler in saved_fblock, check current handler
+                                if let Some(current_handler) = self.current_except_handler() {
+                                    (
+                                        Some(current_handler.handler_block),
+                                        current_handler.stack_depth + 1, // +1 for return value
+                                        current_handler.preserve_lasti,
+                                    )
+                                } else {
+                                    (None, 1, false) // No handler, but still track the return value
+                                }
+                            };
+
+                        self.push_fblock_with_handler(
+                            FBlockType::PopValue,
+                            saved_fblock.fb_block,
+                            saved_fblock.fb_block,
+                            handler,
+                            stack_depth,
+                            preserve_lasti,
+                        )?;
+                    }
+
+                    self.compile_statements(&body)?;
+
+                    if preserve_tos {
+                        self.pop_fblock(FBlockType::PopValue);
+                    }
+
+                    // Restore the fblock
+                    let code = self.current_code_info();
+                    code.fblock.insert(fblock_idx, saved_fblock);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Get the current exception handler from fblock stack
+    fn current_except_handler(&self) -> Option<ir::ExceptHandlerInfo> {
+        let code = self.code_stack.last()?;
+        // Walk fblock stack from top to find the nearest exception handler
+        for fblock in code.fblock.iter().rev() {
+            if let Some(handler) = fblock.fb_handler {
+                return Some(ir::ExceptHandlerInfo {
+                    handler_block: handler,
+                    stack_depth: fblock.fb_stack_depth,
+                    preserve_lasti: fblock.fb_preserve_lasti,
+                });
+            }
+        }
+        None
+    }
+
+    // could take impl Into<Cow<str>>, but everything is borrowed from ast structs; we never
+    // actually have a `String` to pass
+    fn name(&mut self, name: &str) -> bytecode::NameIdx {
+        self._name_inner(name, |i| &mut i.metadata.names)
+    }
+    fn varname(&mut self, name: &str) -> CompileResult<bytecode::NameIdx> {
+        if Self::is_forbidden_arg_name(name) {
+            return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                "cannot assign to {name}",
+            ))));
+        }
+        Ok(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 {
+        let name = self.mangle(name);
+        let cache = cache(self.current_code_info());
+        cache
+            .get_index_of(name.as_ref())
+            .unwrap_or_else(|| cache.insert_full(name.into_owned()).0)
+            .to_u32()
+    }
+
+    /// Set the qualified name for the current code object
+    // = compiler_set_qualname
+    fn set_qualname(&mut self) -> String {
+        let qualname = self.make_qualname();
+        self.current_code_info().metadata.qualname = Some(qualname.clone());
+        qualname
+    }
+    fn make_qualname(&mut self) -> String {
+        let stack_size = self.code_stack.len();
+        assert!(stack_size >= 1);
+
+        let current_obj_name = self.current_code_info().metadata.name.clone();
+
+        // If we're at the module level (stack_size == 1), qualname is just the name
+        if stack_size <= 1 {
+            return current_obj_name;
+        }
+
+        // Check parent scope
+        let mut parent_idx = stack_size - 2;
+        let mut parent = &self.code_stack[parent_idx];
+
+        // If parent is TypeParams scope, look at grandparent
+        // Check if parent is a type params scope by name pattern
+        if parent.metadata.name.starts_with("<generic parameters of ") {
+            if stack_size == 2 {
+                // If we're immediately within the module, qualname is just the name
+                return current_obj_name;
+            }
+            // Use grandparent
+            parent_idx = stack_size - 3;
+            parent = &self.code_stack[parent_idx];
+        }
+
+        // Check if this is a global class/function
+        let mut force_global = false;
+        if stack_size > self.symbol_table_stack.len() {
+            // We might be in a situation where symbol table isn't pushed yet
+            // In this case, check the parent symbol table
+            if let Some(parent_table) = self.symbol_table_stack.last()
+                && let Some(symbol) = parent_table.lookup(&current_obj_name)
+                && symbol.scope == SymbolScope::GlobalExplicit
+            {
+                force_global = true;
+            }
+        } else if let Some(_current_table) = self.symbol_table_stack.last() {
+            // Mangle the name if necessary (for private names in classes)
+            let mangled_name = self.mangle(&current_obj_name);
+
+            // Look up in parent symbol table to check scope
+            if self.symbol_table_stack.len() >= 2 {
+                let parent_table = &self.symbol_table_stack[self.symbol_table_stack.len() - 2];
+                if let Some(symbol) = parent_table.lookup(&mangled_name)
+                    && symbol.scope == SymbolScope::GlobalExplicit
+                {
+                    force_global = true;
+                }
+            }
+        }
+
+        // Build the qualified name
+        if force_global {
+            // For global symbols, qualname is just the name
+            current_obj_name
+        } else {
+            // Check parent scope type
+            let parent_obj_name = &parent.metadata.name;
+
+            // Determine if parent is a function-like scope
+            let is_function_parent = parent.flags.contains(bytecode::CodeFlags::OPTIMIZED)
+                && !parent_obj_name.starts_with("<") // Not a special scope like <lambda>, <listcomp>, etc.
+                && parent_obj_name != "<module>"; // Not the module scope
+
+            if is_function_parent {
+                // For functions, append .<locals> to parent qualname
+                // Use parent's qualname if available, otherwise use parent_obj_name
+                let parent_qualname = parent.metadata.qualname.as_ref().unwrap_or(parent_obj_name);
+                format!("{parent_qualname}.<locals>.{current_obj_name}")
+            } else {
+                // For classes and other scopes, use parent's qualname directly
+                // Use parent's qualname if available, otherwise use parent_obj_name
+                let parent_qualname = parent.metadata.qualname.as_ref().unwrap_or(parent_obj_name);
+                if parent_qualname == "<module>" {
+                    // Module level, just use the name
+                    current_obj_name
+                } else {
+                    // Concatenate parent qualname with current name
+                    format!("{parent_qualname}.{current_obj_name}")
+                }
+            }
+        }
+    }
+
+    fn compile_program(
+        &mut self,
+        body: &ModModule,
+        symbol_table: SymbolTable,
+    ) -> CompileResult<()> {
+        let size_before = self.code_stack.len();
+        self.symbol_table_stack.push(symbol_table);
+
+        let (doc, statements) = split_doc(&body.body, &self.opts);
+        if let Some(value) = doc {
+            self.emit_load_const(ConstantData::Str {
+                value: value.into(),
+            });
+            let doc = self.name("__doc__");
+            emit!(self, Instruction::StoreGlobal(doc))
+        }
+
+        if Self::find_ann(statements) {
+            emit!(self, Instruction::SetupAnnotations);
+        }
+
+        self.compile_statements(statements)?;
+
+        assert_eq!(self.code_stack.len(), size_before);
+
+        // Emit None at end:
+        self.emit_return_const(ConstantData::None);
+        Ok(())
+    }
+
+    fn compile_program_single(
+        &mut self,
+        body: &[Stmt],
+        symbol_table: SymbolTable,
+    ) -> CompileResult<()> {
+        self.symbol_table_stack.push(symbol_table);
+
+        if Self::find_ann(body) {
+            emit!(self, Instruction::SetupAnnotations);
+        }
+
+        if let Some((last, body)) = body.split_last() {
+            for statement in body {
+                if let Stmt::Expr(StmtExpr { value, .. }) = &statement {
+                    self.compile_expression(value)?;
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::Print
+                        }
+                    );
+
+                    emit!(self, Instruction::PopTop);
+                } else {
+                    self.compile_statement(statement)?;
+                }
+            }
+
+            if let Stmt::Expr(StmtExpr { value, .. }) = &last {
+                self.compile_expression(value)?;
+                emit!(self, Instruction::Copy { index: 1_u32 });
+                emit!(
+                    self,
+                    Instruction::CallIntrinsic1 {
+                        func: bytecode::IntrinsicFunction1::Print
+                    }
+                );
+
+                emit!(self, Instruction::PopTop);
+            } else {
+                self.compile_statement(last)?;
+                self.emit_load_const(ConstantData::None);
+            }
+        } else {
+            self.emit_load_const(ConstantData::None);
+        };
+
+        self.emit_return_value();
+        Ok(())
+    }
+
+    fn compile_block_expr(
+        &mut self,
+        body: &[Stmt],
+        symbol_table: SymbolTable,
+    ) -> CompileResult<()> {
+        self.symbol_table_stack.push(symbol_table);
+
+        self.compile_statements(body)?;
+
+        if let Some(last_statement) = body.last() {
+            match last_statement {
+                Stmt::Expr(_) => {
+                    self.current_block().instructions.pop(); // pop Instruction::PopTop
+                }
+                Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {
+                    let pop_instructions = self.current_block().instructions.pop();
+                    let store_inst = compiler_unwrap_option(self, pop_instructions); // pop Instruction::Store
+                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    self.current_block().instructions.push(store_inst);
+                }
+                _ => self.emit_load_const(ConstantData::None),
+            }
+        }
+        self.emit_return_value();
+
+        Ok(())
+    }
+
+    // Compile statement in eval mode:
+    fn compile_eval(
+        &mut self,
+        expression: &ModExpression,
+        symbol_table: SymbolTable,
+    ) -> CompileResult<()> {
+        self.symbol_table_stack.push(symbol_table);
+        self.compile_expression(&expression.body)?;
+        self.emit_return_value();
+        Ok(())
+    }
+
+    fn compile_statements(&mut self, statements: &[Stmt]) -> CompileResult<()> {
+        for statement in statements {
+            self.compile_statement(statement)?
+        }
+        Ok(())
+    }
+
+    fn load_name(&mut self, name: &str) -> CompileResult<()> {
+        self.compile_name(name, NameUsage::Load)
+    }
+
+    fn store_name(&mut self, name: &str) -> CompileResult<()> {
+        self.compile_name(name, NameUsage::Store)
+    }
+
+    fn mangle<'a>(&self, name: &'a str) -> Cow<'a, str> {
+        // Use private from current code unit for name mangling
+        let private = self
+            .code_stack
+            .last()
+            .and_then(|info| info.private.as_deref());
+        symboltable::mangle_name(private, name)
+    }
+
+    fn check_forbidden_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
+        let msg = match usage {
+            NameUsage::Store if is_forbidden_name(name) => "cannot assign to",
+            NameUsage::Delete if is_forbidden_name(name) => "cannot delete",
+            _ => return Ok(()),
+        };
+        Err(self.error(CodegenErrorType::SyntaxError(format!("{msg} {name}"))))
+    }
+
+    // = compiler_nameop
+    fn compile_name(&mut self, name: &str, usage: NameUsage) -> CompileResult<()> {
+        enum NameOp {
+            Fast,
+            Global,
+            Deref,
+            Name,
+        }
+
+        let name = self.mangle(name);
+        self.check_forbidden_name(&name, usage)?;
+
+        // Special handling for __debug__
+        if NameUsage::Load == usage && name == "__debug__" {
+            self.emit_load_const(ConstantData::Boolean {
+                value: self.opts.optimize == 0,
+            });
+            return Ok(());
+        }
+
+        // Determine the operation type based on symbol scope
+        let is_function_like = self.ctx.in_func();
+
+        // Look up the symbol, handling TypeParams scope specially
+        let (symbol_scope, _is_typeparams) = {
+            let current_table = self.current_symbol_table();
+            let is_typeparams = current_table.typ == CompilerScope::TypeParams;
+
+            // First try to find in current table
+            let symbol = current_table.lookup(name.as_ref());
+
+            // If not found and we're in TypeParams scope, try parent scope
+            let symbol = if symbol.is_none() && is_typeparams {
+                self.symbol_table_stack
+                    .get(self.symbol_table_stack.len() - 2) // Try to get parent index
+                    .expect("Symbol has no parent! This is a compiler bug.")
+                    .lookup(name.as_ref())
+            } else {
+                symbol
+            };
+
+            (symbol.map(|s| s.scope), is_typeparams)
+        };
+
+        let actual_scope = symbol_scope.ok_or_else(|| {
+            self.error(CodegenErrorType::SyntaxError(format!(
+                "The symbol '{name}' must be present in the symbol table"
+            )))
+        })?;
+
+        // Determine operation type based on scope
+        let op_type = match actual_scope {
+            SymbolScope::Free => NameOp::Deref,
+            SymbolScope::Cell => NameOp::Deref,
+            SymbolScope::Local => {
+                if is_function_like {
+                    NameOp::Fast
+                } else {
+                    NameOp::Name
+                }
+            }
+            SymbolScope::GlobalImplicit => {
+                if is_function_like {
+                    NameOp::Global
+                } else {
+                    NameOp::Name
+                }
+            }
+            SymbolScope::GlobalExplicit => NameOp::Global,
+            SymbolScope::Unknown => NameOp::Name,
+        };
+
+        // Generate appropriate instructions based on operation type
+        match op_type {
+            NameOp::Deref => {
+                let idx = 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 {
+                    NameUsage::Load => {
+                        // Special case for class scope
+                        if self.ctx.in_class && !self.ctx.in_func() {
+                            Instruction::LoadFromDictOrDeref
+                        } else {
+                            Instruction::LoadDeref
+                        }
+                    }
+                    NameUsage::Store => Instruction::StoreDeref,
+                    NameUsage::Delete => Instruction::DeleteDeref,
+                };
+                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,
+                };
+                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,
+                };
+                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,
+                };
+                self.emit_arg(idx, op);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn compile_statement(&mut self, statement: &Stmt) -> CompileResult<()> {
+        use ruff_python_ast::*;
+        trace!("Compiling {statement:?}");
+        self.set_source_range(statement.range());
+
+        match &statement {
+            // we do this here because `from __future__` still executes that `from` statement at runtime,
+            // we still need to compile the ImportFrom down below
+            Stmt::ImportFrom(StmtImportFrom { module, names, .. })
+                if module.as_ref().map(|id| id.as_str()) == Some("__future__") =>
+            {
+                self.compile_future_features(names)?
+            }
+            // ignore module-level doc comments
+            Stmt::Expr(StmtExpr { value, .. })
+                if matches!(&**value, Expr::StringLiteral(..))
+                    && matches!(self.done_with_future_stmts, DoneWithFuture::No) =>
+            {
+                self.done_with_future_stmts = DoneWithFuture::DoneWithDoc
+            }
+            // if we find any other statement, stop accepting future statements
+            _ => self.done_with_future_stmts = DoneWithFuture::Yes,
+        }
+
+        match &statement {
+            Stmt::Import(StmtImport { names, .. }) => {
+                // import a, b, c as d
+                for name in names {
+                    let name = &name;
+                    self.emit_load_const(ConstantData::Integer {
+                        value: num_traits::Zero::zero(),
+                    });
+                    self.emit_load_const(ConstantData::None);
+                    let idx = self.name(&name.name);
+                    emit!(self, Instruction::ImportName { idx });
+                    if let Some(alias) = &name.asname {
+                        for part in name.name.split('.').skip(1) {
+                            let idx = self.name(part);
+                            emit!(self, Instruction::LoadAttr { idx });
+                        }
+                        self.store_name(alias.as_str())?
+                    } else {
+                        self.store_name(name.name.split('.').next().unwrap())?
+                    }
+                }
+            }
+            Stmt::ImportFrom(StmtImportFrom {
+                level,
+                module,
+                names,
+                ..
+            }) => {
+                let import_star = names.iter().any(|n| &n.name == "*");
+
+                let from_list = if import_star {
+                    if self.ctx.in_func() {
+                        return Err(self.error_ranged(
+                            CodegenErrorType::FunctionImportStar,
+                            statement.range(),
+                        ));
+                    }
+                    vec![ConstantData::Str { value: "*".into() }]
+                } else {
+                    names
+                        .iter()
+                        .map(|n| ConstantData::Str {
+                            value: n.name.as_str().into(),
+                        })
+                        .collect()
+                };
+
+                // from .... import (*fromlist)
+                self.emit_load_const(ConstantData::Integer {
+                    value: (*level).into(),
+                });
+                self.emit_load_const(ConstantData::Tuple {
+                    elements: from_list,
+                });
+
+                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 });
+
+                if import_star {
+                    // from .... import *
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::ImportStar
+                        }
+                    );
+                } else {
+                    // from mod import a, b as c
+
+                    for name in names {
+                        let name = &name;
+                        let idx = self.name(name.name.as_str());
+                        // import symbol from module:
+                        emit!(self, Instruction::ImportFrom { idx });
+
+                        // Store module under proper name:
+                        if let Some(alias) = &name.asname {
+                            self.store_name(alias.as_str())?
+                        } else {
+                            self.store_name(name.name.as_str())?
+                        }
+                    }
+
+                    // Pop module from stack:
+                    emit!(self, Instruction::PopTop);
+                }
+            }
+            Stmt::Expr(StmtExpr { value, .. }) => {
+                self.compile_expression(value)?;
+
+                // Pop result of stack, since we not use it:
+                emit!(self, Instruction::PopTop);
+            }
+            Stmt::Global(_) | Stmt::Nonlocal(_) => {
+                // Handled during symbol table construction.
+            }
+            Stmt::If(StmtIf {
+                test,
+                body,
+                elif_else_clauses,
+                ..
+            }) => {
+                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);
+                    }
+                }
+            }
+            Stmt::While(StmtWhile {
+                test, body, orelse, ..
+            }) => self.compile_while(test, body, orelse)?,
+            Stmt::With(StmtWith {
+                items,
+                body,
+                is_async,
+                ..
+            }) => self.compile_with(items, body, *is_async)?,
+            Stmt::For(StmtFor {
+                target,
+                iter,
+                body,
+                orelse,
+                is_async,
+                ..
+            }) => self.compile_for(target, iter, body, orelse, *is_async)?,
+            Stmt::Match(StmtMatch { subject, cases, .. }) => self.compile_match(subject, cases)?,
+            Stmt::Raise(StmtRaise {
+                exc, cause, range, ..
+            }) => {
+                let kind = match exc {
+                    Some(value) => {
+                        self.compile_expression(value)?;
+                        match cause {
+                            Some(cause) => {
+                                self.compile_expression(cause)?;
+                                bytecode::RaiseKind::RaiseCause
+                            }
+                            None => bytecode::RaiseKind::Raise,
+                        }
+                    }
+                    None => bytecode::RaiseKind::BareRaise,
+                };
+                self.set_source_range(*range);
+                emit!(self, Instruction::RaiseVarargs { kind });
+            }
+            Stmt::Try(StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                is_star,
+                ..
+            }) => {
+                if *is_star {
+                    self.compile_try_star_except(body, handlers, orelse, finalbody)?
+                } else {
+                    self.compile_try_statement(body, handlers, orelse, finalbody)?
+                }
+            }
+            Stmt::FunctionDef(StmtFunctionDef {
+                name,
+                parameters,
+                body,
+                decorator_list,
+                returns,
+                type_params,
+                is_async,
+                ..
+            }) => {
+                validate_duplicate_params(parameters).map_err(|e| self.error(e))?;
+
+                self.compile_function_def(
+                    name.as_str(),
+                    parameters,
+                    body,
+                    decorator_list,
+                    returns.as_deref(),
+                    *is_async,
+                    type_params.as_deref(),
+                )?
+            }
+            Stmt::ClassDef(StmtClassDef {
+                name,
+                body,
+                decorator_list,
+                type_params,
+                arguments,
+                ..
+            }) => self.compile_class_def(
+                name.as_str(),
+                body,
+                decorator_list,
+                type_params.as_deref(),
+                arguments.as_deref(),
+            )?,
+            Stmt::Assert(StmtAssert { test, msg, .. }) => {
+                // if some flag, ignore all assert statements!
+                if self.opts.optimize == 0 {
+                    let after_block = self.new_block();
+                    self.compile_jump_if(test, true, after_block)?;
+
+                    let assertion_error = self.name("AssertionError");
+                    emit!(self, Instruction::LoadGlobal(assertion_error));
+                    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 });
+                        }
+                    }
+                    emit!(
+                        self,
+                        Instruction::RaiseVarargs {
+                            kind: bytecode::RaiseKind::Raise,
+                        }
+                    );
+
+                    self.switch_to_block(after_block);
+                }
+            }
+            Stmt::Break(_) => {
+                // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
+                self.compile_break_continue(statement.range(), true)?;
+            }
+            Stmt::Continue(_) => {
+                // Unwind fblock stack until we find a loop, emitting cleanup for each fblock
+                self.compile_break_continue(statement.range(), false)?;
+            }
+            Stmt::Return(StmtReturn { value, .. }) => {
+                if !self.ctx.in_func() {
+                    return Err(
+                        self.error_ranged(CodegenErrorType::InvalidReturn, statement.range())
+                    );
+                }
+
+                match value {
+                    Some(v) => {
+                        if self.ctx.func == FunctionContext::AsyncFunction
+                            && self
+                                .current_code_info()
+                                .flags
+                                .contains(bytecode::CodeFlags::GENERATOR)
+                        {
+                            return Err(self.error_ranged(
+                                CodegenErrorType::AsyncReturnValue,
+                                statement.range(),
+                            ));
+                        }
+                        self.compile_expression(v)?;
+                        // Unwind fblock stack with preserve_tos=true (preserve return value)
+                        self.unwind_fblock_stack(true, false)?;
+                        self.emit_return_value();
+                    }
+                    None => {
+                        // Unwind fblock stack with preserve_tos=false (no value to preserve)
+                        self.unwind_fblock_stack(false, false)?;
+                        self.emit_return_const(ConstantData::None);
+                    }
+                }
+            }
+            Stmt::Assign(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 });
+                    }
+                    self.compile_store(target)?;
+                }
+            }
+            Stmt::AugAssign(StmtAugAssign {
+                target, op, value, ..
+            }) => self.compile_augassign(target, op, value)?,
+            Stmt::AnnAssign(StmtAnnAssign {
+                target,
+                annotation,
+                value,
+                ..
+            }) => self.compile_annotated_assign(target, annotation, value.as_deref())?,
+            Stmt::Delete(StmtDelete { targets, .. }) => {
+                for target in targets {
+                    self.compile_delete(target)?;
+                }
+            }
+            Stmt::Pass(_) => {
+                // No need to emit any code here :)
+            }
+            Stmt::TypeAlias(StmtTypeAlias {
+                name,
+                type_params,
+                value,
+                ..
+            }) => {
+                // let name_string = name.to_string();
+                let Some(name) = name.as_name_expr() else {
+                    // FIXME: is error here?
+                    return Err(self.error(CodegenErrorType::SyntaxError(
+                        "type alias expect name".to_owned(),
+                    )));
+                };
+                let name_string = name.id.to_string();
+
+                // For PEP 695 syntax, we need to compile type_params first
+                // so that they're available when compiling the value expression
+                // Push name first
+                self.emit_load_const(ConstantData::Str {
+                    value: name_string.clone().into(),
+                });
+
+                if let Some(type_params) = type_params {
+                    // For TypeAlias, we need to use push_symbol_table to properly handle the TypeAlias scope
+                    self.push_symbol_table()?;
+
+                    // Compile type params and push to stack
+                    self.compile_type_params(type_params)?;
+                    // Stack now has [name, type_params_tuple]
+
+                    // Compile value expression (can now see T1, T2)
+                    self.compile_expression(value)?;
+                    // Stack: [name, type_params_tuple, value]
+
+                    // Pop the TypeAlias scope
+                    self.pop_symbol_table();
+                } else {
+                    // Push None for type_params
+                    self.emit_load_const(ConstantData::None);
+                    // Stack: [name, None]
+
+                    // Compile value expression
+                    self.compile_expression(value)?;
+                    // Stack: [name, None, value]
+                }
+
+                // Build tuple of 3 elements and call intrinsic
+                emit!(self, Instruction::BuildTuple { size: 3 });
+                emit!(
+                    self,
+                    Instruction::CallIntrinsic1 {
+                        func: bytecode::IntrinsicFunction1::TypeAlias
+                    }
+                );
+                self.store_name(&name_string)?;
+            }
+            Stmt::IpyEscapeCommand(_) => todo!(),
+        }
+        Ok(())
+    }
+
+    fn compile_delete(&mut self, expression: &Expr) -> CompileResult<()> {
+        use ruff_python_ast::*;
+        match &expression {
+            Expr::Name(ExprName { id, .. }) => self.compile_name(id.as_str(), NameUsage::Delete)?,
+            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+                self.check_forbidden_name(attr.as_str(), NameUsage::Delete)?;
+                self.compile_expression(value)?;
+                let idx = self.name(attr.as_str());
+                emit!(self, Instruction::DeleteAttr { idx });
+            }
+            Expr::Subscript(ExprSubscript {
+                value, slice, ctx, ..
+            }) => {
+                self.compile_subscript(value, slice, *ctx)?;
+            }
+            Expr::Tuple(ExprTuple { elts, .. }) | Expr::List(ExprList { elts, .. }) => {
+                for element in elts {
+                    self.compile_delete(element)?;
+                }
+            }
+            Expr::BinOp(_) | Expr::UnaryOp(_) => {
+                return Err(self.error(CodegenErrorType::Delete("expression")));
+            }
+            _ => return Err(self.error(CodegenErrorType::Delete(expression.python_name()))),
+        }
+        Ok(())
+    }
+
+    fn enter_function(&mut self, name: &str, parameters: &Parameters) -> CompileResult<()> {
+        // TODO: partition_in_place
+        let mut kw_without_defaults = vec![];
+        let mut kw_with_defaults = vec![];
+        for kwonlyarg in &parameters.kwonlyargs {
+            if let Some(default) = &kwonlyarg.default {
+                kw_with_defaults.push((&kwonlyarg.parameter, default));
+            } else {
+                kw_without_defaults.push(&kwonlyarg.parameter);
+            }
+        }
+
+        self.push_output(
+            bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED,
+            parameters.posonlyargs.len().to_u32(),
+            (parameters.posonlyargs.len() + parameters.args.len()).to_u32(),
+            parameters.kwonlyargs.len().to_u32(),
+            name.to_owned(),
+        )?;
+
+        let args_iter = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .map(|arg| &arg.parameter)
+            .chain(kw_without_defaults)
+            .chain(kw_with_defaults.into_iter().map(|(arg, _)| arg));
+        for name in args_iter {
+            self.varname(name.name.as_str())?;
+        }
+
+        if let Some(name) = parameters.vararg.as_deref() {
+            self.current_code_info().flags |= bytecode::CodeFlags::VARARGS;
+            self.varname(name.name.as_str())?;
+        }
+        if let Some(name) = parameters.kwarg.as_deref() {
+            self.current_code_info().flags |= bytecode::CodeFlags::VARKEYWORDS;
+            self.varname(name.name.as_str())?;
+        }
+
+        Ok(())
+    }
+
+    /// Push decorators onto the stack in source order.
+    /// For @dec1 @dec2 def foo(): stack becomes [dec1, NULL, dec2, NULL]
+    fn prepare_decorators(&mut self, decorator_list: &[Decorator]) -> CompileResult<()> {
+        for decorator in decorator_list {
+            self.compile_expression(&decorator.expression)?;
+            emit!(self, Instruction::PushNull);
+        }
+        Ok(())
+    }
+
+    /// Apply decorators in reverse order (LIFO from stack).
+    /// Stack [dec1, NULL, dec2, NULL, func] -> dec2(func) -> dec1(dec2(func))
+    /// The forward loop works because each Call pops from TOS, naturally
+    /// applying decorators bottom-up (innermost first).
+    fn apply_decorators(&mut self, decorator_list: &[Decorator]) {
+        for _ in decorator_list {
+            emit!(self, Instruction::Call { nargs: 1 });
+        }
+    }
+
+    /// Compile type parameter bound or default in a separate scope and return closure
+    fn compile_type_param_bound_or_default(
+        &mut self,
+        expr: &Expr,
+        name: &str,
+        allow_starred: bool,
+    ) -> CompileResult<()> {
+        // Push the next symbol table onto the stack
+        self.push_symbol_table()?;
+
+        // Get the current symbol table
+        let key = self.symbol_table_stack.len() - 1;
+        let lineno = expr.range().start().to_u32();
+
+        // Enter scope with the type parameter name
+        self.enter_scope(name, CompilerScope::TypeParams, key, lineno)?;
+
+        // Compile the expression
+        if allow_starred && matches!(expr, Expr::Starred(_)) {
+            if let Expr::Starred(starred) = expr {
+                self.compile_expression(&starred.value)?;
+                emit!(self, Instruction::UnpackSequence { size: 1 });
+            }
+        } else {
+            self.compile_expression(expr)?;
+        }
+
+        // Return value
+        emit!(self, Instruction::ReturnValue);
+
+        // 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);
+
+        // Call the function immediately
+        emit!(self, Instruction::Call { nargs: 0 });
+
+        Ok(())
+    }
+
+    /// Store each type parameter so it is accessible to the current scope, and leave a tuple of
+    /// all the type parameters on the stack. Handles default values per PEP 695.
+    fn compile_type_params(&mut self, type_params: &TypeParams) -> CompileResult<()> {
+        // First, compile each type parameter and store it
+        for type_param in &type_params.type_params {
+            match type_param {
+                TypeParam::TypeVar(TypeParamTypeVar {
+                    name,
+                    bound,
+                    default,
+                    ..
+                }) => {
+                    self.emit_load_const(ConstantData::Str {
+                        value: name.as_str().into(),
+                    });
+
+                    if let Some(expr) = &bound {
+                        let scope_name = if expr.is_tuple_expr() {
+                            format!("<TypeVar constraint of {name}>")
+                        } else {
+                            format!("<TypeVar bound of {name}>")
+                        };
+                        self.compile_type_param_bound_or_default(expr, &scope_name, false)?;
+
+                        let intrinsic = if expr.is_tuple_expr() {
+                            bytecode::IntrinsicFunction2::TypeVarWithConstraint
+                        } else {
+                            bytecode::IntrinsicFunction2::TypeVarWithBound
+                        };
+                        emit!(self, Instruction::CallIntrinsic2 { func: intrinsic });
+                    } else {
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic1 {
+                                func: bytecode::IntrinsicFunction1::TypeVar
+                            }
+                        );
+                    }
+
+                    if let Some(default_expr) = default {
+                        let scope_name = format!("<TypeVar default of {name}>");
+                        self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic2 {
+                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            }
+                        );
+                    }
+
+                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    self.store_name(name.as_ref())?;
+                }
+                TypeParam::ParamSpec(TypeParamParamSpec { name, default, .. }) => {
+                    self.emit_load_const(ConstantData::Str {
+                        value: name.as_str().into(),
+                    });
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::ParamSpec
+                        }
+                    );
+
+                    if let Some(default_expr) = default {
+                        let scope_name = format!("<ParamSpec default of {name}>");
+                        self.compile_type_param_bound_or_default(default_expr, &scope_name, false)?;
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic2 {
+                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            }
+                        );
+                    }
+
+                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    self.store_name(name.as_ref())?;
+                }
+                TypeParam::TypeVarTuple(TypeParamTypeVarTuple { name, default, .. }) => {
+                    self.emit_load_const(ConstantData::Str {
+                        value: name.as_str().into(),
+                    });
+                    emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::TypeVarTuple
+                        }
+                    );
+
+                    if let Some(default_expr) = default {
+                        // TypeVarTuple allows starred expressions
+                        let scope_name = format!("<TypeVarTuple default of {name}>");
+                        self.compile_type_param_bound_or_default(default_expr, &scope_name, true)?;
+                        emit!(
+                            self,
+                            Instruction::CallIntrinsic2 {
+                                func: bytecode::IntrinsicFunction2::SetTypeparamDefault
+                            }
+                        );
+                    }
+
+                    emit!(self, Instruction::Copy { index: 1_u32 });
+                    self.store_name(name.as_ref())?;
+                }
+            };
+        }
+        emit!(
+            self,
+            Instruction::BuildTuple {
+                size: u32::try_from(type_params.len()).unwrap(),
+            }
+        );
+        Ok(())
+    }
+
+    fn compile_try_statement(
+        &mut self,
+        body: &[Stmt],
+        handlers: &[ExceptHandler],
+        orelse: &[Stmt],
+        finalbody: &[Stmt],
+    ) -> CompileResult<()> {
+        let handler_block = self.new_block();
+        let finally_block = self.new_block();
+
+        // finally needs TWO blocks:
+        // - finally_block: normal path (no exception active)
+        // - finally_except_block: exception path (PUSH_EXC_INFO -> body -> RERAISE)
+        let finally_except_block = if !finalbody.is_empty() {
+            Some(self.new_block())
+        } else {
+            None
+        };
+        let finally_cleanup_block = if finally_except_block.is_some() {
+            Some(self.new_block())
+        } else {
+            None
+        };
+        // End block - continuation point after try-finally
+        // Normal path jumps here to skip exception path blocks
+        let end_block = self.new_block();
+
+        // Calculate the stack depth at this point (for exception table)
+        // SETUP_FINALLY captures current stack depth
+        let current_depth = self.handler_stack_depth();
+
+        // Setup a finally block if we have a finally statement.
+        // Push fblock with handler info for exception table generation
+        // IMPORTANT: handler goes to finally_except_block (exception path), not finally_block
+        if !finalbody.is_empty() {
+            // No SetupFinally emit - exception table handles this
+            // Store finally body in fb_datum for unwind_fblock to compile inline
+            // SETUP_FINALLY doesn't push lasti for try body handler
+            // Exception table: L1 to L2 -> L4 [1] (no lasti)
+            self.push_fblock_full(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                finally_except_block, // Exception path goes to finally_except_block
+                current_depth,
+                false, // No lasti for first finally handler
+                FBlockDatum::FinallyBody(finalbody.to_vec()), // Clone finally body for unwind
+            )?;
+        }
+
+        let else_block = self.new_block();
+
+        // if handlers is empty, compile body directly
+        // without wrapping in TryExcept (only FinallyTry is needed)
+        if handlers.is_empty() {
+            // Just compile body with FinallyTry fblock active (if finalbody exists)
+            self.compile_statements(body)?;
+
+            // Pop FinallyTry fblock BEFORE compiling orelse/finally (normal path)
+            // This prevents exception table from covering the normal path
+            if !finalbody.is_empty() {
+                self.pop_fblock(FBlockType::FinallyTry);
+            }
+
+            // Compile orelse (usually empty for try-finally without except)
+            self.compile_statements(orelse)?;
+
+            // Snapshot sub_tables before first finally compilation
+            // This allows us to restore them for the second compilation (exception path)
+            let sub_table_cursor = if !finalbody.is_empty() && finally_except_block.is_some() {
+                self.symbol_table_stack.last().map(|t| t.next_sub_table)
+            } else {
+                None
+            };
+
+            // Compile finally body inline for normal path
+            if !finalbody.is_empty() {
+                self.compile_statements(finalbody)?;
+            }
+
+            // Jump to end (skip exception path blocks)
+            emit!(self, PseudoInstruction::Jump { target: end_block });
+
+            if let Some(finally_except) = finally_except_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;
+                }
+
+                self.switch_to_block(finally_except);
+                // PUSH_EXC_INFO first, THEN push FinallyEnd fblock
+                // Stack after unwind (no lasti): [exc] (depth = current_depth + 1)
+                // Stack after PUSH_EXC_INFO: [prev_exc, exc] (depth = current_depth + 2)
+                emit!(self, Instruction::PushExcInfo);
+                if let Some(cleanup) = finally_cleanup_block {
+                    // FinallyEnd fblock must be pushed AFTER PUSH_EXC_INFO
+                    // Depth = current_depth + 1 (only prev_exc remains after RERAISE pops exc)
+                    // Exception table: L4 to L5 -> L6 [2] lasti (cleanup handler DOES push lasti)
+                    self.push_fblock_with_handler(
+                        FBlockType::FinallyEnd,
+                        cleanup,
+                        cleanup,
+                        Some(cleanup),
+                        current_depth + 1,
+                        true, // Cleanup handler pushes lasti
+                    )?;
+                }
+                self.compile_statements(finalbody)?;
+
+                // Pop FinallyEnd fblock BEFORE emitting RERAISE
+                // This ensures RERAISE routes to outer exception handler, not cleanup block
+                // Cleanup block is only for new exceptions raised during finally body execution
+                if finally_cleanup_block.is_some() {
+                    self.pop_fblock(FBlockType::FinallyEnd);
+                }
+
+                // Restore prev_exc as current exception before RERAISE
+                // Stack: [prev_exc, exc] -> COPY 2 -> [prev_exc, exc, prev_exc]
+                // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
+                // Stack after POP_EXCEPT: [prev_exc, exc]
+                emit!(self, Instruction::Copy { index: 2_u32 });
+                emit!(self, Instruction::PopExcept);
+
+                // RERAISE 0: re-raise the original exception to outer handler
+                emit!(
+                    self,
+                    Instruction::RaiseVarargs {
+                        kind: bytecode::RaiseKind::ReraiseFromStack
+                    }
+                );
+            }
+
+            if let Some(cleanup) = finally_cleanup_block {
+                self.switch_to_block(cleanup);
+                emit!(self, Instruction::Copy { index: 3_u32 });
+                emit!(self, Instruction::PopExcept);
+                emit!(
+                    self,
+                    Instruction::RaiseVarargs {
+                        kind: bytecode::RaiseKind::ReraiseFromStack
+                    }
+                );
+            }
+
+            self.switch_to_block(end_block);
+            return Ok(());
+        }
+
+        // try:
+        // Push fblock with handler info for exception table generation
+        // No SetupExcept emit - exception table handles this
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept,
+            handler_block,
+            handler_block,
+            Some(handler_block),
+            current_depth, // stack depth for exception handler
+            false,         // no lasti for except
+        )?;
+        self.compile_statements(body)?;
+        self.pop_fblock(FBlockType::TryExcept);
+        // No PopBlock emit - exception table handles this
+        emit!(self, PseudoInstruction::Jump { target: else_block });
+
+        // except handlers:
+        self.switch_to_block(handler_block);
+
+        // SETUP_CLEANUP(cleanup) for except block
+        // This handles exceptions during exception matching
+        // Exception table: L2 to L3 -> L5 [1] lasti
+        // After PUSH_EXC_INFO, stack is [prev_exc, exc]
+        // depth=1 means keep prev_exc on stack when routing to cleanup
+        let cleanup_block = self.new_block();
+        self.push_fblock_with_handler(
+            FBlockType::ExceptionHandler,
+            cleanup_block,
+            cleanup_block,
+            Some(cleanup_block),
+            current_depth + 1, // After PUSH_EXC_INFO: [prev_exc] stays on stack
+            true,              // preserve_lasti for cleanup
+        )?;
+
+        // Exception is on top of stack now, pushed by unwind_blocks
+        // PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc] for PopExcept
+        emit!(self, Instruction::PushExcInfo);
+        for handler in handlers {
+            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
+                type_, name, body, ..
+            }) = &handler;
+            let next_handler = self.new_block();
+
+            // If we gave a typ,
+            // check if this handler can handle the exception:
+            if let Some(exc_type) = type_ {
+                // Duplicate exception for test:
+                emit!(self, Instruction::Copy { index: 1_u32 });
+
+                // Check exception type:
+                self.compile_expression(exc_type)?;
+                emit!(self, Instruction::JumpIfNotExcMatch(next_handler));
+
+                // We have a match, store in name (except x as y)
+                if let Some(alias) = name {
+                    self.store_name(alias.as_str())?
+                } else {
+                    // Drop exception from top of stack:
+                    emit!(self, Instruction::PopTop);
+                }
+            } else {
+                // Catch all!
+                // Drop exception from top of stack:
+                emit!(self, Instruction::PopTop);
+            }
+
+            // If name is bound, we need a cleanup handler for RERAISE
+            let handler_cleanup_block = if name.is_some() {
+                // SETUP_CLEANUP(cleanup_end) for named handler
+                let cleanup_end = self.new_block();
+                // Stack at handler entry: [prev_exc, exc]
+                // depth = 1 (prev_exc on stack after exception is popped)
+                let handler_depth = current_depth + 1;
+                self.push_fblock_with_handler(
+                    FBlockType::HandlerCleanup,
+                    cleanup_end,
+                    cleanup_end,
+                    Some(cleanup_end),
+                    handler_depth,
+                    true, // preserve_lasti for RERAISE
+                )?;
+                Some(cleanup_end)
+            } else {
+                // no SETUP_CLEANUP for unnamed handler
+                self.push_fblock(FBlockType::HandlerCleanup, finally_block, finally_block)?;
+                None
+            };
+
+            // Handler code:
+            self.compile_statements(body)?;
+
+            self.pop_fblock(FBlockType::HandlerCleanup);
+
+            // Create a block for normal path continuation (after handler body succeeds)
+            let handler_normal_exit = self.new_block();
+            emit!(
+                self,
+                PseudoInstruction::Jump {
+                    target: handler_normal_exit,
+                }
+            );
+
+            // cleanup_end block for named handler
+            // IMPORTANT: In CPython, cleanup_end is within outer SETUP_CLEANUP scope.
+            // so when RERAISE is executed, it goes to the cleanup block which does POP_EXCEPT.
+            // We MUST compile cleanup_end BEFORE popping ExceptionHandler so RERAISE routes to cleanup_block.
+            if let Some(cleanup_end) = handler_cleanup_block {
+                self.switch_to_block(cleanup_end);
+                if let Some(alias) = name {
+                    // name = None; del name; before RERAISE
+                    self.emit_load_const(ConstantData::None);
+                    self.store_name(alias.as_str())?;
+                    self.compile_name(alias.as_str(), NameUsage::Delete)?;
+                }
+                // RERAISE 1 (with lasti) - exception is on stack from exception table routing
+                // Stack at entry: [prev_exc (at handler_depth), lasti, exc]
+                // This RERAISE is within ExceptionHandler scope, so it routes to cleanup_block
+                // which does COPY 3; POP_EXCEPT; RERAISE
+                emit!(
+                    self,
+                    Instruction::RaiseVarargs {
+                        kind: bytecode::RaiseKind::ReraiseFromStack,
+                    }
+                );
+            }
+
+            // Switch to normal exit block - this is where handler body success continues
+            self.switch_to_block(handler_normal_exit);
+
+            // Now pop ExceptionHandler - the normal path continues from here
+            // POP_BLOCK (HandlerCleanup) then POP_BLOCK (SETUP_CLEANUP)
+            // followed by POP_EXCEPT
+            self.pop_fblock(FBlockType::ExceptionHandler);
+            emit!(self, Instruction::PopExcept);
+
+            // Delete the exception variable if it was bound (normal path)
+            if let Some(alias) = name {
+                // Set the variable to None before deleting
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            // Jump to finally block
+            emit!(
+                self,
+                PseudoInstruction::Jump {
+                    target: 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
+            )?;
+
+            // Emit a new label for the next handler
+            self.switch_to_block(next_handler);
+        }
+
+        // If code flows here, we have an unhandled exception,
+        // raise the exception again!
+        // RERAISE 0
+        // Stack: [prev_exc, exc] - exception is on stack from PUSH_EXC_INFO
+        // NOTE: We emit RERAISE 0 BEFORE popping fblock so it is within cleanup handler scope
+        emit!(
+            self,
+            Instruction::RaiseVarargs {
+                kind: bytecode::RaiseKind::ReraiseFromStack,
+            }
+        );
+
+        // Pop EXCEPTION_HANDLER fblock
+        // Pop after RERAISE so the instruction has the correct exception handler
+        self.pop_fblock(FBlockType::ExceptionHandler);
+
+        // cleanup block (POP_EXCEPT_AND_RERAISE)
+        // Stack at entry: [prev_exc, lasti, exc] (depth=1 + lasti + exc pushed)
+        // COPY 3: copy prev_exc to top -> [prev_exc, lasti, exc, prev_exc]
+        // POP_EXCEPT: pop prev_exc from stack and restore -> [prev_exc, lasti, exc]
+        // RERAISE 1: reraise with lasti
+        self.switch_to_block(cleanup_block);
+        emit!(self, Instruction::Copy { index: 3_u32 });
+        emit!(self, Instruction::PopExcept);
+        emit!(
+            self,
+            Instruction::RaiseVarargs {
+                kind: bytecode::RaiseKind::ReraiseFromStack,
+            }
+        );
+
+        // We successfully ran the try block:
+        // else:
+        self.switch_to_block(else_block);
+        self.compile_statements(orelse)?;
+
+        // Pop the FinallyTry fblock before jumping to finally
+        if !finalbody.is_empty() {
+            // No PopBlock/EnterFinally emit - exception table handles this
+            self.pop_fblock(FBlockType::FinallyTry);
+        }
+
+        // Snapshot sub_tables before first finally compilation (for double compilation issue)
+        let sub_table_cursor = if !finalbody.is_empty() && finally_except_block.is_some() {
+            self.symbol_table_stack.last().map(|t| t.next_sub_table)
+        } else {
+            None
+        };
+
+        // finally (normal path):
+        self.switch_to_block(finally_block);
+        if !finalbody.is_empty() {
+            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 });
+        }
+
+        // finally (exception path)
+        // This is where exceptions go to run finally before reraise
+        // Stack at entry: [lasti, exc] (from exception table with preserve_lasti=true)
+        if let Some(finally_except) = finally_except_block {
+            // Restore sub_tables for exception path compilation
+            if let Some(cursor) = sub_table_cursor
+                && let Some(current_table) = self.symbol_table_stack.last_mut()
+            {
+                current_table.next_sub_table = cursor;
+            }
+
+            self.switch_to_block(finally_except);
+
+            // SETUP_CLEANUP for finally body
+            // Exceptions during finally body need to go to cleanup block
+            // Stack at entry: [lasti, exc] (lasti from exception table, exc pushed)
+            // After PUSH_EXC_INFO: [lasti, prev_exc, exc]
+            // So depth should account for lasti being on stack
+            if let Some(cleanup) = finally_cleanup_block {
+                self.push_fblock_with_handler(
+                    FBlockType::FinallyEnd,
+                    cleanup,
+                    cleanup,
+                    Some(cleanup),
+                    current_depth + 1, // [lasti] on stack before PUSH_EXC_INFO
+                    true,
+                )?;
+            }
+
+            // PUSH_EXC_INFO: [lasti, exc] -> [lasti, prev_exc, exc]
+            // Sets exc as current VM exception, saves prev_exc for restoration
+            emit!(self, Instruction::PushExcInfo);
+
+            // Run finally body
+            self.compile_statements(finalbody)?;
+
+            // Pop FinallyEnd fblock BEFORE emitting RERAISE
+            // This ensures RERAISE routes to outer exception handler, not cleanup block
+            // Cleanup block is only for new exceptions raised during finally body execution
+            if finally_cleanup_block.is_some() {
+                self.pop_fblock(FBlockType::FinallyEnd);
+            }
+
+            // Restore prev_exc as current exception before RERAISE
+            // Stack: [lasti, prev_exc, exc] -> COPY 2 -> [lasti, prev_exc, exc, prev_exc]
+            // POP_EXCEPT pops prev_exc and sets exc_info->exc_value = prev_exc
+            // Stack after POP_EXCEPT: [lasti, prev_exc, exc]
+            emit!(self, Instruction::Copy { index: 2_u32 });
+            emit!(self, Instruction::PopExcept);
+
+            // RERAISE 0: re-raise the original exception to outer handler
+            // Stack: [lasti, prev_exc, exc] - exception is on top
+            emit!(
+                self,
+                Instruction::RaiseVarargs {
+                    kind: bytecode::RaiseKind::ReraiseFromStack,
+                }
+            );
+        }
+
+        // finally cleanup block
+        // This handles exceptions that occur during the finally body itself
+        // Stack at entry: [lasti, prev_exc, lasti2, exc2] after exception table routing
+        if let Some(cleanup) = finally_cleanup_block {
+            self.switch_to_block(cleanup);
+            // COPY 3: copy the exception from position 3
+            emit!(self, Instruction::Copy { index: 3_u32 });
+            // 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,
+                }
+            );
+        }
+
+        // End block - continuation point after try-finally
+        // Normal execution continues here after the finally block
+        self.switch_to_block(end_block);
+
+        Ok(())
+    }
+
+    fn compile_try_star_except(
+        &mut self,
+        body: &[Stmt],
+        handlers: &[ExceptHandler],
+        orelse: &[Stmt],
+        finalbody: &[Stmt],
+    ) -> CompileResult<()> {
+        // compiler_try_star_except
+        // Stack layout during handler processing: [prev_exc, orig, list, rest]
+        let handler_block = self.new_block();
+        let finally_block = self.new_block();
+        let else_block = self.new_block();
+        let end_block = self.new_block();
+        let reraise_star_block = self.new_block();
+        let reraise_block = self.new_block();
+        let _cleanup_block = self.new_block();
+
+        // Calculate the stack depth at this point (for exception table)
+        let current_depth = self.handler_stack_depth();
+
+        // Push fblock with handler info for exception table generation
+        if !finalbody.is_empty() {
+            // No SetupFinally emit - exception table handles this
+            self.push_fblock_with_handler(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                Some(finally_block),
+                current_depth, // stack depth for exception handler
+                true,          // preserve lasti for finally
+            )?;
+        }
+
+        // SETUP_FINALLY for try body
+        // Push fblock with handler info for exception table generation
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept,
+            handler_block,
+            handler_block,
+            Some(handler_block),
+            current_depth, // stack depth for exception handler
+            false,         // no lasti for except
+        )?;
+        self.compile_statements(body)?;
+        self.pop_fblock(FBlockType::TryExcept);
+        emit!(self, PseudoInstruction::Jump { target: else_block });
+
+        // Exception handler entry
+        self.switch_to_block(handler_block);
+        // Stack: [exc] (from exception table)
+
+        // PUSH_EXC_INFO
+        emit!(self, Instruction::PushExcInfo);
+        // Stack: [prev_exc, exc]
+
+        // Push EXCEPTION_GROUP_HANDLER fblock
+        let eg_dummy1 = self.new_block();
+        let eg_dummy2 = self.new_block();
+        self.push_fblock(FBlockType::ExceptionGroupHandler, eg_dummy1, eg_dummy2)?;
+
+        let n = handlers.len();
+        for (i, handler) in handlers.iter().enumerate() {
+            let ExceptHandler::ExceptHandler(ExceptHandlerExceptHandler {
+                type_, name, body, ..
+            }) = handler;
+
+            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
+                if let Expr::Tuple(ExprTuple { elts, range, .. }) = exc_type.as_ref()
+                    && let Some(first) = elts.first()
+                    && range.start().to_u32() == first.range().start().to_u32()
+                {
+                    return Err(self.error(CodegenErrorType::SyntaxError(
+                        "multiple exception types must be parenthesized".to_owned(),
+                    )));
+                }
+                self.compile_expression(exc_type)?;
+            } else {
+                return Err(self.error(CodegenErrorType::SyntaxError(
+                    "except* must specify an exception type".to_owned(),
+                )));
+            }
+            // Stack: [prev_exc, orig, list, rest, type]
+
+            // ADDOP(c, loc, CHECK_EG_MATCH);
+            emit!(self, Instruction::CheckEgMatch);
+            // Stack: [prev_exc, orig, list, new_rest, match]
+
+            // ADDOP_I(c, loc, COPY, 1);
+            // ADDOP_JUMP(c, loc, POP_JUMP_IF_NONE, no_match);
+            emit!(self, Instruction::Copy { index: 1 });
+            self.emit_load_const(ConstantData::None);
+            emit!(self, Instruction::IsOp(bytecode::Invert::No)); // is None?
+            emit!(
+                self,
+                Instruction::PopJumpIfTrue {
+                    target: no_match_block
+                }
+            );
+
+            // Handler matched
+            // Stack: [prev_exc, orig, list, new_rest, match]
+            let handler_except_block = self.new_block();
+
+            // Set matched exception as current exception (for __context__ in handler body)
+            // This ensures that exceptions raised in the handler get the matched part
+            // as their __context__, not the original full exception group
+            emit!(self, Instruction::SetExcInfo);
+
+            // Store match to name or pop
+            if let Some(alias) = name {
+                self.store_name(alias.as_str())?;
+            } else {
+                emit!(self, Instruction::PopTop); // pop match
+            }
+            // 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(
+                FBlockType::HandlerCleanup,
+                next_block,
+                end_block,
+                Some(handler_except_block),
+                eg_handler_depth,
+                true, // preserve lasti
+            )?;
+
+            // Execute handler body
+            self.compile_statements(body)?;
+
+            // Handler body completed normally
+            self.pop_fblock(FBlockType::HandlerCleanup);
+
+            // Cleanup name binding
+            if let Some(alias) = name {
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            // Jump to next handler
+            emit!(self, PseudoInstruction::Jump { target: next_block });
+
+            // Handler raised an exception (cleanup_end label)
+            self.switch_to_block(handler_except_block);
+            // Stack: [prev_exc, orig, list, new_rest, lasti, raised_exc]
+            // (lasti is pushed because push_lasti=true in HANDLER_CLEANUP fblock)
+
+            // Cleanup name binding
+            if let Some(alias) = name {
+                self.emit_load_const(ConstantData::None);
+                self.store_name(alias.as_str())?;
+                self.compile_name(alias.as_str(), NameUsage::Delete)?;
+            }
+
+            // LIST_APPEND(3) - append raised_exc to list
+            // Stack: [prev_exc, orig, list, new_rest, lasti, raised_exc]
+            // After pop: [prev_exc, orig, list, new_rest, lasti] (len=5)
+            // nth_value(i) = stack[len - i - 1], we need stack[2] = list
+            // stack[5 - i - 1] = 2 -> i = 2
+            emit!(self, Instruction::ListAppend { i: 2 });
+            // Stack: [prev_exc, orig, list, new_rest, lasti]
+
+            // POP_TOP - pop lasti
+            emit!(self, Instruction::PopTop);
+            // Stack: [prev_exc, orig, list, new_rest]
+
+            // JUMP except_with_error
+            // We directly JUMP to next_block since no_match_block falls through to it
+            emit!(self, PseudoInstruction::Jump { target: next_block });
+
+            // No match - pop match (None)
+            self.switch_to_block(no_match_block);
+            emit!(self, Instruction::PopTop); // pop match (None)
+            // Stack: [prev_exc, orig, list, new_rest]
+            // Falls through to next_block
+
+            // except_with_error label
+            // All paths merge here at next_block
+            self.switch_to_block(next_block);
+            // Stack: [prev_exc, orig, list, rest]
+
+            // After last handler, append rest to list
+            if i == n - 1 {
+                // Stack: [prev_exc, orig, list, rest]
+                // ADDOP_I(c, NO_LOCATION, LIST_APPEND, 1);
+                // PEEK(1) = stack[len-1] after pop
+                // RustPython nth_value(i) = stack[len-i-1] after pop
+                // For LIST_APPEND 1: stack[len-1] = stack[len-i-1] -> i = 0
+                emit!(self, Instruction::ListAppend { i: 0 });
+                // Stack: [prev_exc, orig, list]
+                emit!(
+                    self,
+                    PseudoInstruction::Jump {
+                        target: reraise_star_block
+                    }
+                );
+            }
+        }
+
+        // Pop EXCEPTION_GROUP_HANDLER fblock
+        self.pop_fblock(FBlockType::ExceptionGroupHandler);
+
+        // Reraise star block
+        self.switch_to_block(reraise_star_block);
+        // Stack: [prev_exc, orig, list]
+
+        // CALL_INTRINSIC_2 PREP_RERAISE_STAR
+        // Takes 2 args (orig, list) and produces result
+        emit!(
+            self,
+            Instruction::CallIntrinsic2 {
+                func: bytecode::IntrinsicFunction2::PrepReraiseStar
+            }
+        );
+        // Stack: [prev_exc, result]
+
+        // COPY 1
+        emit!(self, Instruction::Copy { index: 1 });
+        // Stack: [prev_exc, result, result]
+
+        // POP_JUMP_IF_NOT_NONE reraise
+        self.emit_load_const(ConstantData::None);
+        emit!(self, Instruction::IsOp(bytecode::Invert::Yes)); // is not None?
+        emit!(
+            self,
+            Instruction::PopJumpIfTrue {
+                target: reraise_block
+            }
+        );
+        // Stack: [prev_exc, result]
+
+        // Nothing to reraise
+        // POP_TOP - pop result (None)
+        emit!(self, Instruction::PopTop);
+        // Stack: [prev_exc]
+
+        // POP_BLOCK - no-op for us with exception tables (fblocks handle this)
+        // POP_EXCEPT - restore previous exception context
+        emit!(self, Instruction::PopExcept);
+        // Stack: []
+
+        if !finalbody.is_empty() {
+            self.pop_fblock(FBlockType::FinallyTry);
+        }
+
+        emit!(self, PseudoInstruction::Jump { target: end_block });
+
+        // Reraise the result
+        self.switch_to_block(reraise_block);
+        // Stack: [prev_exc, result]
+
+        // POP_BLOCK - no-op for us
+        // SWAP 2
+        emit!(self, Instruction::Swap { index: 2 });
+        // Stack: [result, prev_exc]
+
+        // POP_EXCEPT
+        emit!(self, Instruction::PopExcept);
+        // Stack: [result]
+
+        // RERAISE 0
+        emit!(self, Instruction::Reraise { depth: 0 });
+
+        // try-else path
+        // NOTE: When we reach here in compilation, the nothing-to-reraise path above
+        // has already popped FinallyTry. But else_block is a different execution path
+        // that branches from try body success (where FinallyTry is still active).
+        // We need to re-push FinallyTry to reflect the correct fblock state for else path.
+        if !finalbody.is_empty() {
+            self.push_fblock_with_handler(
+                FBlockType::FinallyTry,
+                finally_block,
+                finally_block,
+                Some(finally_block),
+                current_depth,
+                true,
+            )?;
+        }
+        self.switch_to_block(else_block);
+        self.compile_statements(orelse)?;
+
+        if !finalbody.is_empty() {
+            // Pop the FinallyTry fblock we just pushed for the else path
+            self.pop_fblock(FBlockType::FinallyTry);
+        }
+
+        emit!(self, PseudoInstruction::Jump { target: end_block });
+
+        self.switch_to_block(end_block);
+        if !finalbody.is_empty() {
+            self.switch_to_block(finally_block);
+            self.compile_statements(finalbody)?;
+            // No EndFinally emit - exception table handles this
+        }
+
+        Ok(())
+    }
+
+    fn is_forbidden_arg_name(name: &str) -> bool {
+        is_forbidden_name(name)
+    }
+
+    /// Compile default arguments
+    // = compiler_default_arguments
+    fn compile_default_arguments(
+        &mut self,
+        parameters: &Parameters,
+    ) -> CompileResult<bytecode::MakeFunctionFlags> {
+        let mut funcflags = bytecode::MakeFunctionFlags::empty();
+
+        // Handle positional defaults
+        let defaults: Vec<_> = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .filter_map(|x| x.default.as_deref())
+            .collect();
+
+        if !defaults.is_empty() {
+            // Compile defaults and build tuple
+            for default in &defaults {
+                self.compile_expression(default)?;
+            }
+            emit!(
+                self,
+                Instruction::BuildTuple {
+                    size: defaults.len().to_u32()
+                }
+            );
+            funcflags |= bytecode::MakeFunctionFlags::DEFAULTS;
+        }
+
+        // Handle keyword-only defaults
+        let mut kw_with_defaults = vec![];
+        for kwonlyarg in &parameters.kwonlyargs {
+            if let Some(default) = &kwonlyarg.default {
+                kw_with_defaults.push((&kwonlyarg.parameter, default));
+            }
+        }
+
+        if !kw_with_defaults.is_empty() {
+            // Compile kwdefaults and build dict
+            for (arg, default) in &kw_with_defaults {
+                self.emit_load_const(ConstantData::Str {
+                    value: arg.name.as_str().into(),
+                });
+                self.compile_expression(default)?;
+            }
+            emit!(
+                self,
+                Instruction::BuildMap {
+                    size: kw_with_defaults.len().to_u32(),
+                }
+            );
+            funcflags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
+        }
+
+        Ok(funcflags)
+    }
+
+    /// Compile function body and create function object
+    // = compiler_function_body
+    fn compile_function_body(
+        &mut self,
+        name: &str,
+        parameters: &Parameters,
+        body: &[Stmt],
+        is_async: bool,
+        funcflags: bytecode::MakeFunctionFlags,
+    ) -> CompileResult<()> {
+        // Always enter function scope
+        self.enter_function(name, parameters)?;
+        self.current_code_info()
+            .flags
+            .set(bytecode::CodeFlags::COROUTINE, is_async);
+
+        // Set up context
+        let prev_ctx = self.ctx;
+        self.ctx = CompileContext {
+            loop_data: None,
+            in_class: prev_ctx.in_class,
+            func: if is_async {
+                FunctionContext::AsyncFunction
+            } else {
+                FunctionContext::Function
+            },
+            // A function starts a new async scope only if it's async
+            in_async_scope: is_async,
+        };
+
+        // Set qualname
+        self.set_qualname();
+
+        // Handle docstring
+        let (doc_str, body) = split_doc(body, &self.opts);
+        self.current_code_info()
+            .metadata
+            .consts
+            .insert_full(ConstantData::None);
+
+        // Compile body statements
+        self.compile_statements(body)?;
+
+        // Emit None at end if needed
+        match body.last() {
+            Some(Stmt::Return(_)) => {}
+            _ => {
+                self.emit_return_const(ConstantData::None);
+            }
+        }
+
+        // Exit scope and create function object
+        let code = self.exit_scope();
+        self.ctx = prev_ctx;
+
+        // Create function object with closure
+        self.make_closure(code, funcflags)?;
+
+        // Handle docstring if present
+        if let Some(doc) = doc_str {
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            self.emit_load_const(ConstantData::Str {
+                value: doc.to_string().into(),
+            });
+            emit!(self, Instruction::Swap { index: 2 });
+            let doc_attr = self.name("__doc__");
+            emit!(self, Instruction::StoreAttr { idx: doc_attr });
+        }
+
+        Ok(())
+    }
+
+    /// Compile function annotations
+    // = compiler_visit_annotations
+    fn visit_annotations(
+        &mut self,
+        parameters: &Parameters,
+        returns: Option<&Expr>,
+    ) -> CompileResult<u32> {
+        let mut num_annotations = 0;
+
+        // Handle parameter annotations
+        let parameters_iter = core::iter::empty()
+            .chain(&parameters.posonlyargs)
+            .chain(&parameters.args)
+            .chain(&parameters.kwonlyargs)
+            .map(|x| &x.parameter)
+            .chain(parameters.vararg.as_deref())
+            .chain(parameters.kwarg.as_deref());
+
+        for param in parameters_iter {
+            if let Some(annotation) = &param.annotation {
+                self.emit_load_const(ConstantData::Str {
+                    value: self.mangle(param.name.as_str()).into_owned().into(),
+                });
+                self.compile_annotation(annotation)?;
+                num_annotations += 1;
+            }
+        }
+
+        // Handle return annotation last
+        if let Some(annotation) = returns {
+            self.emit_load_const(ConstantData::Str {
+                value: "return".into(),
+            });
+            self.compile_annotation(annotation)?;
+            num_annotations += 1;
+        }
+
+        Ok(num_annotations)
+    }
+
+    // = compiler_function
+    #[allow(clippy::too_many_arguments)]
+    fn compile_function_def(
+        &mut self,
+        name: &str,
+        parameters: &Parameters,
+        body: &[Stmt],
+        decorator_list: &[Decorator],
+        returns: Option<&Expr>, // TODO: use type hint somehow..
+        is_async: bool,
+        type_params: Option<&TypeParams>,
+    ) -> CompileResult<()> {
+        self.prepare_decorators(decorator_list)?;
+
+        // compile defaults and return funcflags
+        let funcflags = self.compile_default_arguments(parameters)?;
+
+        let is_generic = type_params.is_some();
+        let mut num_typeparam_args = 0;
+
+        if is_generic {
+            // Count args to pass to type params scope
+            if funcflags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+                num_typeparam_args += 1;
+            }
+            if funcflags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+                num_typeparam_args += 1;
+            }
+
+            // Enter type params scope
+            let type_params_name = format!("<generic parameters of {name}>");
+            self.push_output(
+                bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
+                0,
+                num_typeparam_args as u32,
+                0,
+                type_params_name,
+            )?;
+
+            // Add parameter names to varnames for the type params scope
+            // These will be passed as arguments when the closure is called
+            let current_info = self.current_code_info();
+            if funcflags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+                current_info
+                    .metadata
+                    .varnames
+                    .insert(".defaults".to_owned());
+            }
+            if funcflags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+                current_info
+                    .metadata
+                    .varnames
+                    .insert(".kwdefaults".to_owned());
+            }
+
+            // Compile type parameters
+            self.compile_type_params(type_params.unwrap())?;
+
+            // Load defaults/kwdefaults with LOAD_FAST
+            for i in 0..num_typeparam_args {
+                emit!(self, Instruction::LoadFast(i as u32));
+            }
+        }
+
+        // Compile annotations
+        let mut annotations_flag = bytecode::MakeFunctionFlags::empty();
+        let num_annotations = self.visit_annotations(parameters, returns)?;
+        if num_annotations > 0 {
+            annotations_flag = bytecode::MakeFunctionFlags::ANNOTATIONS;
+            emit!(
+                self,
+                Instruction::BuildMap {
+                    size: num_annotations,
+                }
+            );
+        }
+
+        // Compile function body
+        let final_funcflags = funcflags | annotations_flag;
+        self.compile_function_body(name, parameters, body, is_async, final_funcflags)?;
+
+        // Handle type params if present
+        if is_generic {
+            // SWAP to get function on top
+            // Stack: [type_params_tuple, function] -> [function, type_params_tuple]
+            emit!(self, Instruction::Swap { index: 2 });
+
+            // Call INTRINSIC_SET_FUNCTION_TYPE_PARAMS
+            emit!(
+                self,
+                Instruction::CallIntrinsic2 {
+                    func: bytecode::IntrinsicFunction2::SetFunctionTypeParams,
+                }
+            );
+
+            // Return the function object from type params scope
+            emit!(self, Instruction::ReturnValue);
+
+            // Set argcount for type params scope
+            self.current_code_info().metadata.argcount = num_typeparam_args as u32;
+
+            // Exit type params scope and create closure
+            let type_params_code = self.exit_scope();
+
+            // Make closure for type params code
+            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
+
+            // Call the type params closure with defaults/kwdefaults as arguments.
+            // Call protocol: [callable, self_or_null, arg1, ..., argN]
+            // We need to reorder: [args..., closure] -> [closure, NULL, args...]
+            // Using Swap operations to move closure down and insert NULL.
+            // Note: num_typeparam_args is at most 2 (defaults tuple, kwdefaults dict).
+            if num_typeparam_args > 0 {
+                match num_typeparam_args {
+                    1 => {
+                        // Stack: [arg1, closure]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, NULL]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1]
+                    }
+                    2 => {
+                        // Stack: [arg1, arg2, closure]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, arg1, arg2]
+                        emit!(self, Instruction::PushNull); // [closure, arg1, arg2, NULL]
+                        emit!(self, Instruction::Swap { index: 3 }); // [closure, NULL, arg2, arg1]
+                        emit!(self, Instruction::Swap { index: 2 }); // [closure, NULL, arg1, arg2]
+                    }
+                    _ => unreachable!("only defaults and kwdefaults are supported"),
+                }
+                emit!(
+                    self,
+                    Instruction::Call {
+                        nargs: num_typeparam_args as u32
+                    }
+                );
+            } else {
+                // Stack: [closure]
+                emit!(self, Instruction::PushNull);
+                // Stack: [closure, NULL]
+                emit!(self, Instruction::Call { nargs: 0 });
+            }
+        }
+
+        // Apply decorators
+        self.apply_decorators(decorator_list);
+
+        // Store the function
+        self.store_name(name)?;
+
+        Ok(())
+    }
+
+    /// Determines if a variable should be CELL or FREE type
+    // = get_ref_type
+    fn get_ref_type(&self, name: &str) -> Result<SymbolScope, CodegenErrorType> {
+        let table = self.symbol_table_stack.last().unwrap();
+
+        // Special handling for __class__ and __classdict__ in class scope
+        // This should only apply when we're actually IN a class body,
+        // not when we're in a method nested inside a class.
+        if table.typ == CompilerScope::Class && (name == "__class__" || name == "__classdict__") {
+            return Ok(SymbolScope::Cell);
+        }
+        match table.lookup(name) {
+            Some(symbol) => match symbol.scope {
+                SymbolScope::Cell => Ok(SymbolScope::Cell),
+                SymbolScope::Free => Ok(SymbolScope::Free),
+                _ if symbol.flags.contains(SymbolFlags::FREE_CLASS) => Ok(SymbolScope::Free),
+                _ => Err(CodegenErrorType::SyntaxError(format!(
+                    "get_ref_type: invalid scope for '{name}'"
+                ))),
+            },
+            None => Err(CodegenErrorType::SyntaxError(format!(
+                "get_ref_type: cannot find symbol '{name}'"
+            ))),
+        }
+    }
+
+    /// Loads closure variables if needed and creates a function object
+    // = compiler_make_closure
+    fn make_closure(
+        &mut self,
+        code: CodeObject,
+        flags: bytecode::MakeFunctionFlags,
+    ) -> CompileResult<()> {
+        // Handle free variables (closure)
+        let has_freevars = !code.freevars.is_empty();
+        if has_freevars {
+            // Build closure tuple by loading free variables
+
+            for var in &code.freevars {
+                // Special case: If a class contains a method with a
+                // free variable that has the same name as a method,
+                // the name will be considered free *and* local in the
+                // class. It should be handled by the closure, as
+                // well as by the normal name lookup logic.
+
+                // Get reference type using our get_ref_type function
+                let ref_type = self.get_ref_type(var).map_err(|e| self.error(e))?;
+
+                // Get parent code info
+                let parent_code = self.code_stack.last().unwrap();
+                let cellvars_len = parent_code.metadata.cellvars.len();
+
+                // Look up the variable index based on reference type
+                let idx = match ref_type {
+                    SymbolScope::Cell => parent_code
+                        .metadata
+                        .cellvars
+                        .get_index_of(var)
+                        .or_else(|| {
+                            parent_code
+                                .metadata
+                                .freevars
+                                .get_index_of(var)
+                                .map(|i| i + cellvars_len)
+                        })
+                        .ok_or_else(|| {
+                            self.error(CodegenErrorType::SyntaxError(format!(
+                                "compiler_make_closure: cannot find '{var}' in parent vars",
+                            )))
+                        })?,
+                    SymbolScope::Free => parent_code
+                        .metadata
+                        .freevars
+                        .get_index_of(var)
+                        .map(|i| i + cellvars_len)
+                        .or_else(|| parent_code.metadata.cellvars.get_index_of(var))
+                        .ok_or_else(|| {
+                            self.error(CodegenErrorType::SyntaxError(format!(
+                                "compiler_make_closure: cannot find '{var}' in parent vars",
+                            )))
+                        })?,
+                    _ => {
+                        return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                            "compiler_make_closure: unexpected ref_type {ref_type:?} for '{var}'",
+                        ))));
+                    }
+                };
+
+                emit!(self, Instruction::LoadClosure(idx.to_u32()));
+            }
+
+            // Build tuple of closure variables
+            emit!(
+                self,
+                Instruction::BuildTuple {
+                    size: code.freevars.len().to_u32(),
+                }
+            );
+        }
+
+        // load code object and create function
+        self.emit_load_const(ConstantData::Code {
+            code: Box::new(code),
+        });
+
+        // Create function with no flags
+        emit!(self, Instruction::MakeFunction);
+
+        // Now set attributes one by one using SET_FUNCTION_ATTRIBUTE
+        // Note: The order matters! Values must be on stack before calling SET_FUNCTION_ATTRIBUTE
+
+        // Set closure if needed
+        if has_freevars {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::CLOSURE
+                }
+            );
+        }
+
+        // Set annotations if present
+        if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::ANNOTATIONS
+                }
+            );
+        }
+
+        // Set kwdefaults if present
+        if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS
+                }
+            );
+        }
+
+        // Set defaults if present
+        if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::DEFAULTS
+                }
+            );
+        }
+
+        // Set type_params if present
+        if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
+            emit!(
+                self,
+                Instruction::SetFunctionAttribute {
+                    attr: bytecode::MakeFunctionFlags::TYPE_PARAMS
+                }
+            );
+        }
+
+        Ok(())
+    }
+
+    // Python/compile.c find_ann
+    fn find_ann(body: &[Stmt]) -> bool {
+        use ruff_python_ast::*;
+        for statement in body {
+            let res = match &statement {
+                Stmt::AnnAssign(_) => true,
+                Stmt::For(StmtFor { body, orelse, .. }) => {
+                    Self::find_ann(body) || Self::find_ann(orelse)
+                }
+                Stmt::If(StmtIf {
+                    body,
+                    elif_else_clauses,
+                    ..
+                }) => {
+                    Self::find_ann(body)
+                        || elif_else_clauses.iter().any(|x| Self::find_ann(&x.body))
+                }
+                Stmt::While(StmtWhile { body, orelse, .. }) => {
+                    Self::find_ann(body) || Self::find_ann(orelse)
+                }
+                Stmt::With(StmtWith { body, .. }) => Self::find_ann(body),
+                Stmt::Try(StmtTry {
+                    body,
+                    orelse,
+                    finalbody,
+                    ..
+                }) => Self::find_ann(body) || Self::find_ann(orelse) || Self::find_ann(finalbody),
+                _ => false,
+            };
+            if res {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Compile the class body into a code object
+    // = compiler_class_body
+    fn compile_class_body(
+        &mut self,
+        name: &str,
+        body: &[Stmt],
+        type_params: Option<&TypeParams>,
+        firstlineno: u32,
+    ) -> CompileResult<CodeObject> {
+        // 1. Enter class scope
+        let key = self.symbol_table_stack.len();
+        self.push_symbol_table()?;
+        self.enter_scope(name, CompilerScope::Class, key, firstlineno)?;
+
+        // Set qualname using the new method
+        let qualname = self.set_qualname();
+
+        // For class scopes, set u_private to the class name for name mangling
+        self.code_stack.last_mut().unwrap().private = Some(name.to_owned());
+
+        // 2. Set up class namespace
+        let (doc_str, body) = split_doc(body, &self.opts);
+
+        // Load (global) __name__ and store as __module__
+        let dunder_name = self.name("__name__");
+        emit!(self, Instruction::LoadGlobal(dunder_name));
+        let dunder_module = self.name("__module__");
+        emit!(self, Instruction::StoreName(dunder_module));
+
+        // Store __qualname__
+        self.emit_load_const(ConstantData::Str {
+            value: qualname.into(),
+        });
+        let qualname_name = self.name("__qualname__");
+        emit!(self, Instruction::StoreName(qualname_name));
+
+        // Store __doc__ only if there's an explicit docstring
+        if let Some(doc) = doc_str {
+            self.emit_load_const(ConstantData::Str { value: doc.into() });
+            let doc_name = self.name("__doc__");
+            emit!(self, Instruction::StoreName(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));
+
+            // Store as __type_params__
+            let dunder_type_params = self.name("__type_params__");
+            emit!(self, Instruction::StoreName(dunder_type_params));
+        }
+
+        // Setup annotations if needed
+        if Self::find_ann(body) {
+            emit!(self, Instruction::SetupAnnotations);
+        }
+
+        // 3. Compile the class body
+        self.compile_statements(body)?;
+
+        // 4. Handle __classcell__ if needed
+        let classcell_idx = self
+            .code_stack
+            .last_mut()
+            .unwrap()
+            .metadata
+            .cellvars
+            .iter()
+            .position(|var| *var == "__class__");
+
+        if let Some(classcell_idx) = classcell_idx {
+            emit!(self, Instruction::LoadClosure(classcell_idx.to_u32()));
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            let classcell = self.name("__classcell__");
+            emit!(self, Instruction::StoreName(classcell));
+        } else {
+            self.emit_load_const(ConstantData::None);
+        }
+
+        // Return the class namespace
+        self.emit_return_value();
+
+        // Exit scope and return the code object
+        Ok(self.exit_scope())
+    }
+
+    fn compile_class_def(
+        &mut self,
+        name: &str,
+        body: &[Stmt],
+        decorator_list: &[Decorator],
+        type_params: Option<&TypeParams>,
+        arguments: Option<&Arguments>,
+    ) -> CompileResult<()> {
+        self.prepare_decorators(decorator_list)?;
+
+        let is_generic = type_params.is_some();
+        let firstlineno = self.get_source_line_number().get().to_u32();
+
+        // Step 1: If generic, enter type params scope and compile type params
+        if is_generic {
+            let type_params_name = format!("<generic parameters of {name}>");
+            self.push_output(
+                bytecode::CodeFlags::OPTIMIZED | bytecode::CodeFlags::NEWLOCALS,
+                0,
+                0,
+                0,
+                type_params_name,
+            )?;
+
+            // Set private name for name mangling
+            self.code_stack.last_mut().unwrap().private = Some(name.to_owned());
+
+            // 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));
+        }
+
+        // Step 2: Compile class body (always done, whether generic or not)
+        let prev_ctx = self.ctx;
+        self.ctx = CompileContext {
+            func: FunctionContext::NoFunction,
+            in_class: true,
+            loop_data: None,
+            in_async_scope: false,
+        };
+        let class_code = self.compile_class_body(name, body, type_params, firstlineno)?;
+        self.ctx = prev_ctx;
+
+        // Step 3: Generate the rest of the code for the call
+        if is_generic {
+            // Still in type params scope
+            let dot_type_params = self.name(".type_params");
+            let dot_generic_base = self.name(".generic_base");
+
+            // Create .generic_base
+            emit!(self, Instruction::LoadName(dot_type_params));
+            emit!(
+                self,
+                Instruction::CallIntrinsic1 {
+                    func: bytecode::IntrinsicFunction1::SubscriptGeneric
+                }
+            );
+            emit!(self, Instruction::StoreName(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;
+
+            // Create class function with closure
+            self.make_closure(class_code, func_flags)?;
+            self.emit_load_const(ConstantData::Str { value: name.into() });
+
+            // Compile bases and call __build_class__
+            // Check for starred bases or **kwargs
+            let has_starred = arguments
+                .is_some_and(|args| args.args.iter().any(|arg| matches!(arg, Expr::Starred(_))));
+            let has_double_star =
+                arguments.is_some_and(|args| args.keywords.iter().any(|kw| kw.arg.is_none()));
+
+            if has_starred || has_double_star {
+                // Use CallFunctionEx for *bases or **kwargs
+                // Stack has: [__build_class__, NULL, class_func, name]
+                // Need to build: args tuple = (class_func, name, *bases, .generic_base)
+
+                // Compile bases with gather_elements (handles starred)
+                let (size, unpack) = if let Some(arguments) = arguments {
+                    self.gather_elements(2, &arguments.args)? // 2 = class_func + name already on stack
+                } else {
+                    // Just class_func and name (no bases)
+                    (2, false)
+                };
+
+                // Add .generic_base as final base
+                emit!(self, Instruction::LoadName(dot_generic_base));
+
+                // Build args tuple
+                if unpack {
+                    // Starred: gather_elements produced tuples on stack
+                    emit!(self, Instruction::BuildTuple { size: 1 }); // (.generic_base,)
+                    emit!(self, Instruction::BuildTupleFromTuples { size: size + 1 });
+                } else {
+                    // No starred: individual elements on stack
+                    // size includes class_func + name + bases count, +1 for .generic_base
+                    emit!(self, Instruction::BuildTuple { size: size + 1 });
+                }
+
+                // Build kwargs if needed
+                let has_kwargs = arguments.is_some_and(|args| !args.keywords.is_empty());
+                if has_kwargs {
+                    self.compile_keywords(&arguments.unwrap().keywords)?;
+                }
+                emit!(self, Instruction::CallFunctionEx { has_kwargs });
+            } else {
+                // Simple case: no starred bases, no **kwargs
+                // Compile bases normally
+                let base_count = if let Some(arguments) = arguments {
+                    for arg in &arguments.args {
+                        self.compile_expression(arg)?;
+                    }
+                    arguments.args.len()
+                } else {
+                    0
+                };
+
+                // Load .generic_base as the last base
+                emit!(self, Instruction::LoadName(dot_generic_base));
+
+                let nargs = 2 + u32::try_from(base_count).expect("too many base classes") + 1;
+
+                // Handle keyword arguments (no **kwargs here)
+                if let Some(arguments) = arguments
+                    && !arguments.keywords.is_empty()
+                {
+                    let mut kwarg_names = vec![];
+                    for keyword in &arguments.keywords {
+                        let name = keyword.arg.as_ref().expect(
+                            "keyword argument name must be set (no **kwargs in this branch)",
+                        );
+                        kwarg_names.push(ConstantData::Str {
+                            value: name.as_str().into(),
+                        });
+                        self.compile_expression(&keyword.value)?;
+                    }
+                    self.emit_load_const(ConstantData::Tuple {
+                        elements: kwarg_names,
+                    });
+                    emit!(
+                        self,
+                        Instruction::CallKw {
+                            nargs: nargs
+                                + u32::try_from(arguments.keywords.len())
+                                    .expect("too many keyword arguments")
+                        }
+                    );
+                } else {
+                    emit!(self, Instruction::Call { nargs });
+                }
+            }
+
+            // Return the created class
+            self.emit_return_value();
+
+            // Exit type params scope and wrap in function
+            let type_params_code = self.exit_scope();
+
+            // Execute the type params function
+            self.make_closure(type_params_code, bytecode::MakeFunctionFlags::empty())?;
+            emit!(self, Instruction::PushNull);
+            emit!(self, Instruction::Call { nargs: 0 });
+        } else {
+            // Non-generic class: standard path
+            emit!(self, Instruction::LoadBuildClass);
+            emit!(self, Instruction::PushNull);
+
+            // Create class function with closure
+            self.make_closure(class_code, bytecode::MakeFunctionFlags::empty())?;
+            self.emit_load_const(ConstantData::Str { value: name.into() });
+
+            if let Some(arguments) = arguments {
+                self.compile_call_helper(2, arguments)?;
+            } else {
+                emit!(self, Instruction::Call { nargs: 2 });
+            }
+        }
+
+        // Step 4: Apply decorators and store (common to both paths)
+        self.apply_decorators(decorator_list);
+        self.store_name(name)
+    }
+
+    fn compile_while(&mut self, test: &Expr, body: &[Stmt], orelse: &[Stmt]) -> CompileResult<()> {
+        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)?;
+
+        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,
+            }
+        );
+        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);
+        Ok(())
+    }
+
+    fn compile_with(
+        &mut self,
+        items: &[WithItem],
+        body: &[Stmt],
+        is_async: bool,
+    ) -> CompileResult<()> {
+        // Python 3.12+ style with statement:
+        //
+        // BEFORE_WITH          # TOS: ctx_mgr -> [__exit__, __enter__ result]
+        // L1: STORE_NAME f     # exception table: L1 to L2 -> L3 [1] lasti
+        // L2: ... body ...
+        //     LOAD_CONST None  # normal exit
+        //     LOAD_CONST None
+        //     LOAD_CONST None
+        //     CALL 2           # __exit__(None, None, None)
+        //     POP_TOP
+        //     JUMP after
+        // L3: PUSH_EXC_INFO    # exception handler
+        //     WITH_EXCEPT_START # call __exit__(type, value, tb), push result
+        //     TO_BOOL
+        //     POP_JUMP_IF_TRUE suppress
+        //     RERAISE 2
+        // suppress:
+        //     POP_TOP          # pop exit result
+        // L5: POP_EXCEPT
+        //     POP_TOP          # pop __exit__
+        //     POP_TOP          # pop prev_exc (or lasti depending on layout)
+        //     JUMP after
+        // L6: COPY 3           # cleanup handler for reraise
+        //     POP_EXCEPT
+        //     RERAISE 1
+        // after: ...
+
+        let with_range = self.current_source_range;
+
+        let Some((item, items)) = items.split_first() else {
+            return Err(self.error(CodegenErrorType::EmptyWithItems));
+        };
+
+        let exc_handler_block = self.new_block();
+        let after_block = self.new_block();
+
+        // Compile context expression and BEFORE_WITH
+        self.compile_expression(&item.context_expr)?;
+        self.set_source_range(with_range);
+
+        if is_async {
+            if self.ctx.func != FunctionContext::AsyncFunction {
+                return Err(self.error(CodegenErrorType::InvalidAsyncWith));
+            }
+            emit!(self, Instruction::BeforeAsyncWith);
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+        } else {
+            emit!(self, Instruction::BeforeWith);
+        }
+
+        // Stack: [..., __exit__, enter_result]
+        // Push fblock for exception table - handler goes to exc_handler_block
+        // preserve_lasti=true for with statements
+        // Use handler_stack_depth() to include all items on stack (for loops, etc.)
+        let with_depth = self.handler_stack_depth() + 1; // +1 for current __exit__
+        self.push_fblock_with_handler(
+            if is_async {
+                FBlockType::AsyncWith
+            } else {
+                FBlockType::With
+            },
+            exc_handler_block, // block start (will become exit target after store)
+            after_block,
+            Some(exc_handler_block),
+            with_depth,
+            true, // preserve_lasti=true
+        )?;
+
+        // Store or pop the enter result
+        match &item.optional_vars {
+            Some(var) => {
+                self.set_source_range(var.range());
+                self.compile_store(var)?;
+            }
+            None => {
+                emit!(self, Instruction::PopTop);
+            }
+        }
+        // Stack: [..., __exit__]
+
+        // Compile body or nested with
+        if items.is_empty() {
+            if body.is_empty() {
+                return Err(self.error(CodegenErrorType::EmptyWithBody));
+            }
+            self.compile_statements(body)?;
+        } else {
+            self.set_source_range(with_range);
+            self.compile_with(items, body, is_async)?;
+        }
+
+        // Pop fblock before normal exit
+        self.pop_fblock(if is_async {
+            FBlockType::AsyncWith
+        } else {
+            FBlockType::With
+        });
+
+        // ===== Normal exit path =====
+        // Stack: [..., __exit__]
+        // Call __exit__(None, None, None)
+        self.set_source_range(with_range);
+        emit!(self, Instruction::PushNull);
+        self.emit_load_const(ConstantData::None);
+        self.emit_load_const(ConstantData::None);
+        self.emit_load_const(ConstantData::None);
+        emit!(self, Instruction::Call { nargs: 3 });
+        if is_async {
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+        }
+        emit!(self, Instruction::PopTop); // Pop __exit__ result
+        emit!(
+            self,
+            PseudoInstruction::Jump {
+                target: after_block
+            }
+        );
+
+        // ===== Exception handler path =====
+        // Stack at entry (after unwind): [..., __exit__, lasti, exc]
+        // PUSH_EXC_INFO -> [..., __exit__, lasti, prev_exc, exc]
+        self.switch_to_block(exc_handler_block);
+
+        // Create blocks for exception handling
+        let cleanup_block = self.new_block();
+        let suppress_block = self.new_block();
+
+        // Push nested fblock for cleanup handler
+        // Stack at exc_handler_block entry: [..., __exit__, lasti, exc]
+        // After PUSH_EXC_INFO: [..., __exit__, lasti, prev_exc, exc]
+        // If exception in __exit__, cleanup handler entry: [..., __exit__, lasti, prev_exc, lasti2, exc2]
+        // cleanup_depth should be: with_depth + 2 (lasti + prev_exc)
+        let cleanup_depth = with_depth + 2;
+        self.push_fblock_with_handler(
+            FBlockType::ExceptionHandler,
+            exc_handler_block,
+            after_block,
+            Some(cleanup_block),
+            cleanup_depth,
+            true, // preserve_lasti=true
+        )?;
+
+        // PUSH_EXC_INFO: [exc] -> [prev_exc, exc]
+        emit!(self, Instruction::PushExcInfo);
+
+        // WITH_EXCEPT_START: call __exit__(type, value, tb)
+        // Stack: [..., __exit__, lasti, prev_exc, exc]
+        // __exit__ is at TOS-3, call with exception info
+        emit!(self, Instruction::WithExceptStart);
+
+        if is_async {
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            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
+            }
+        );
+
+        // Pop the nested fblock BEFORE RERAISE so that RERAISE's exception
+        // handler points to the outer handler (try-except), not cleanup_block.
+        // This is critical: when RERAISE propagates the exception, the exception
+        // table should route it to the outer try-except, not back to cleanup.
+        self.pop_fblock(FBlockType::ExceptionHandler);
+
+        // Not suppressed: RERAISE 2
+        emit!(self, Instruction::Reraise { depth: 2 });
+
+        // ===== Suppress block =====
+        // Exception was suppressed, clean up stack
+        // Stack: [..., __exit__, lasti, prev_exc, exc, True]
+        // Need to pop: True, exc, prev_exc, __exit__
+        self.switch_to_block(suppress_block);
+        emit!(self, Instruction::PopTop); // pop True (TO_BOOL result)
+        emit!(self, Instruction::PopExcept); // pop exc and restore prev_exc
+        emit!(self, Instruction::PopTop); // pop __exit__
+        emit!(self, Instruction::PopTop); // pop lasti
+        emit!(
+            self,
+            PseudoInstruction::Jump {
+                target: after_block
+            }
+        );
+
+        // ===== Cleanup block (for nested exception during __exit__) =====
+        // Stack: [..., __exit__, lasti, prev_exc, lasti2, exc2]
+        // COPY 3: copy prev_exc to TOS
+        // POP_EXCEPT: restore exception state
+        // RERAISE 1: re-raise with lasti
+        //
+        // NOTE: We DON'T clear the fblock stack here because we want
+        // outer exception handlers (e.g., try-except wrapping this with statement)
+        // to be in the exception table for these instructions.
+        // If we cleared fblock, exceptions here would propagate uncaught.
+        self.switch_to_block(cleanup_block);
+        emit!(self, Instruction::Copy { index: 3 });
+        emit!(self, Instruction::PopExcept);
+        emit!(self, Instruction::Reraise { depth: 1 });
+
+        // ===== After block =====
+        self.switch_to_block(after_block);
+
+        Ok(())
+    }
+
+    fn compile_for(
+        &mut self,
+        target: &Expr,
+        iter: &Expr,
+        body: &[Stmt],
+        orelse: &[Stmt],
+        is_async: bool,
+    ) -> CompileResult<()> {
+        // Start loop
+        let for_block = self.new_block();
+        let else_block = self.new_block();
+        let after_block = self.new_block();
+
+        // The thing iterated:
+        self.compile_expression(iter)?;
+
+        if is_async {
+            if self.ctx.func != FunctionContext::AsyncFunction {
+                return Err(self.error(CodegenErrorType::InvalidAsyncFor));
+            }
+            emit!(self, Instruction::GetAIter);
+
+            self.switch_to_block(for_block);
+
+            // Push fblock for async for loop with exception handler info
+            // Note: SetupExcept is no longer emitted (exception table handles StopAsyncIteration)
+            // Stack at this point: [..., async_iterator]
+            // We need handler_stack_depth() + 1 to keep parent items + async_iterator on stack when exception occurs
+            let async_for_depth = self.handler_stack_depth() + 1;
+            self.push_fblock_with_handler(
+                FBlockType::ForLoop,
+                for_block,
+                after_block,
+                Some(else_block), // Handler for StopAsyncIteration
+                async_for_depth,  // stack depth: keep async_iterator and parent items
+                false,            // no lasti needed
+            )?;
+
+            emit!(self, Instruction::GetANext);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+            self.compile_store(target)?;
+            // Note: PopBlock is no longer emitted (exception table handles this)
+        } else {
+            // Retrieve Iterator
+            emit!(self, Instruction::GetIter);
+
+            self.switch_to_block(for_block);
+
+            // Push fblock for for loop
+            self.push_fblock(FBlockType::ForLoop, for_block, after_block)?;
+
+            emit!(self, Instruction::ForIter { target: else_block });
+
+            // Start of loop iteration, set targets:
+            self.compile_store(target)?;
+        };
+
+        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 });
+
+        self.switch_to_block(else_block);
+
+        // Pop fblock
+        self.pop_fblock(FBlockType::ForLoop);
+
+        if is_async {
+            emit!(self, Instruction::EndAsyncFor);
+        }
+        self.compile_statements(orelse)?;
+
+        self.switch_to_block(after_block);
+
+        Ok(())
+    }
+
+    fn forbidden_name(&mut self, name: &str, ctx: NameUsage) -> CompileResult<bool> {
+        if ctx == NameUsage::Store && name == "__debug__" {
+            return Err(self.error(CodegenErrorType::Assign("__debug__")));
+            // return Ok(true);
+        }
+        if ctx == NameUsage::Delete && name == "__debug__" {
+            return Err(self.error(CodegenErrorType::Delete("__debug__")));
+            // return Ok(true);
+        }
+        Ok(false)
+    }
+
+    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:?}");
+    }
+
+    /// Ensures that `pc.fail_pop` has at least `n + 1` entries.
+    /// If not, new labels are generated and pushed until the required size is reached.
+    fn ensure_fail_pop(&mut self, pc: &mut PatternContext, n: usize) -> CompileResult<()> {
+        let required_size = n + 1;
+        if required_size <= pc.fail_pop.len() {
+            return Ok(());
+        }
+        while pc.fail_pop.len() < required_size {
+            let new_block = self.new_block();
+            pc.fail_pop.push(new_block);
+        }
+        Ok(())
+    }
+
+    fn jump_to_fail_pop(&mut self, pc: &mut PatternContext, op: JumpOp) -> CompileResult<()> {
+        // Compute the total number of items to pop:
+        // items on top plus the captured objects.
+        let pops = pc.on_top + pc.stores.len();
+        // Ensure that the fail_pop vector has at least `pops + 1` elements.
+        self.ensure_fail_pop(pc, pops)?;
+        // Emit a jump using the jump target stored at index `pops`.
+        match op {
+            JumpOp::Jump => {
+                emit!(
+                    self,
+                    PseudoInstruction::Jump {
+                        target: pc.fail_pop[pops]
+                    }
+                );
+            }
+            JumpOp::PopJumpIfFalse => {
+                emit!(
+                    self,
+                    Instruction::PopJumpIfFalse {
+                        target: pc.fail_pop[pops]
+                    }
+                );
+            }
+        }
+        Ok(())
+    }
+
+    /// Emits the necessary POP instructions for all failure targets in the pattern context,
+    /// then resets the fail_pop vector.
+    fn emit_and_reset_fail_pop(&mut self, pc: &mut PatternContext) -> CompileResult<()> {
+        // If the fail_pop vector is empty, nothing needs to be done.
+        if pc.fail_pop.is_empty() {
+            debug_assert!(pc.fail_pop.is_empty());
+            return Ok(());
+        }
+        // Iterate over the fail_pop vector in reverse order, skipping the first label.
+        for &label in pc.fail_pop.iter().skip(1).rev() {
+            self.switch_to_block(label);
+            // Emit the POP instruction.
+            emit!(self, Instruction::PopTop);
+        }
+        // Finally, use the first label.
+        self.switch_to_block(pc.fail_pop[0]);
+        pc.fail_pop.clear();
+        // Free the memory used by the vector.
+        pc.fail_pop.shrink_to_fit();
+        Ok(())
+    }
+
+    /// Duplicate the effect of Python 3.10's ROT_* instructions using SWAPs.
+    fn pattern_helper_rotate(&mut self, mut count: usize) -> CompileResult<()> {
+        // Rotate TOS (top of stack) to position `count` down
+        // This is done by a series of swaps
+        // For count=1, no rotation needed (already at top)
+        // For count=2, swap TOS with item 1 position down
+        // For count=3, swap TOS with item 2 positions down, then with item 1 position down
+        while count > 1 {
+            // Emit a SWAP instruction with the current count.
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(count).unwrap()
+                }
+            );
+            count -= 1;
+        }
+        Ok(())
+    }
+
+    /// Helper to store a captured name for a star pattern.
+    ///
+    /// If `n` is `None`, it emits a POP_TOP instruction. Otherwise, it first
+    /// checks that the name is allowed and not already stored. Then it rotates
+    /// the object on the stack beneath any preserved items and appends the name
+    /// to the list of captured names.
+    fn pattern_helper_store_name(
+        &mut self,
+        n: Option<&Identifier>,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        match n {
+            // If no name is provided, simply pop the top of the stack.
+            None => {
+                emit!(self, Instruction::PopTop);
+                Ok(())
+            }
+            Some(name) => {
+                // Check if the name is forbidden for storing.
+                if self.forbidden_name(name.as_str(), NameUsage::Store)? {
+                    return Err(self.compile_error_forbidden_name(name.as_str()));
+                }
+
+                // Ensure we don't store the same name twice.
+                // TODO: maybe pc.stores should be a set?
+                if pc.stores.contains(&name.to_string()) {
+                    return Err(
+                        self.error(CodegenErrorType::DuplicateStore(name.as_str().to_string()))
+                    );
+                }
+
+                // Calculate how many items to rotate:
+                let rotations = pc.on_top + pc.stores.len() + 1;
+                self.pattern_helper_rotate(rotations)?;
+
+                // Append the name to the captured stores.
+                pc.stores.push(name.to_string());
+                Ok(())
+            }
+        }
+    }
+
+    fn pattern_unpack_helper(&mut self, elts: &[Pattern]) -> CompileResult<()> {
+        let n = elts.len();
+        let mut seen_star = false;
+        for (i, elt) in elts.iter().enumerate() {
+            if elt.is_match_star() {
+                if !seen_star {
+                    if i >= (1 << 8) || (n - i - 1) >= ((i32::MAX as usize) >> 8) {
+                        todo!();
+                        // return self.compiler_error(loc, "too many expressions in star-unpacking sequence pattern");
+                    }
+                    let args = UnpackExArgs {
+                        before: u8::try_from(i).unwrap(),
+                        after: u8::try_from(n - i - 1).unwrap(),
+                    };
+                    emit!(self, Instruction::UnpackEx { args });
+                    seen_star = true;
+                } else {
+                    // TODO: Fix error msg
+                    return Err(self.error(CodegenErrorType::MultipleStarArgs));
+                    // return self.compiler_error(loc, "multiple starred expressions in sequence pattern");
+                }
+            }
+        }
+        if !seen_star {
+            emit!(
+                self,
+                Instruction::UnpackSequence {
+                    size: u32::try_from(n).unwrap()
+                }
+            );
+        }
+        Ok(())
+    }
+
+    fn pattern_helper_sequence_unpack(
+        &mut self,
+        patterns: &[Pattern],
+        _star: Option<usize>,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Unpack the sequence into individual subjects.
+        self.pattern_unpack_helper(patterns)?;
+        let size = patterns.len();
+        // Increase the on_top counter for the newly unpacked subjects.
+        pc.on_top += size;
+        // For each unpacked subject, compile its subpattern.
+        for pattern in patterns {
+            // Decrement on_top for each subject as it is consumed.
+            pc.on_top -= 1;
+            self.compile_pattern_subpattern(pattern, pc)?;
+        }
+        Ok(())
+    }
+
+    fn pattern_helper_sequence_subscr(
+        &mut self,
+        patterns: &[Pattern],
+        star: usize,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Keep the subject around for extracting elements.
+        pc.on_top += 1;
+        for (i, pattern) in patterns.iter().enumerate() {
+            // if pattern.is_wildcard() {
+            // continue;
+            // }
+            if i == star {
+                // This must be a starred wildcard.
+                // assert!(pattern.is_star_wildcard());
+                continue;
+            }
+            // Duplicate the subject.
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            if i < star {
+                // For indices before the star, use a nonnegative index equal to i.
+                self.emit_load_const(ConstantData::Integer { value: i.into() });
+            } else {
+                // For indices after the star, compute a nonnegative index:
+                // index = len(subject) - (size - i)
+                emit!(self, Instruction::GetLen);
+                self.emit_load_const(ConstantData::Integer {
+                    value: (patterns.len() - i).into(),
+                });
+                // Subtract to compute the correct index.
+                emit!(
+                    self,
+                    Instruction::BinaryOp {
+                        op: BinaryOperator::Subtract
+                    }
+                );
+            }
+            // Use BINARY_OP/NB_SUBSCR to extract the element.
+            emit!(self, Instruction::BinarySubscr);
+            // Compile the subpattern in irrefutable mode.
+            self.compile_pattern_subpattern(pattern, pc)?;
+        }
+        // Pop the subject off the stack.
+        pc.on_top -= 1;
+        emit!(self, Instruction::PopTop);
+        Ok(())
+    }
+
+    fn compile_pattern_subpattern(
+        &mut self,
+        p: &Pattern,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Save the current allow_irrefutable state.
+        let old_allow_irrefutable = pc.allow_irrefutable;
+        // Temporarily allow irrefutable patterns.
+        pc.allow_irrefutable = true;
+        // Compile the pattern.
+        self.compile_pattern(p, pc)?;
+        // Restore the original state.
+        pc.allow_irrefutable = old_allow_irrefutable;
+        Ok(())
+    }
+
+    fn compile_pattern_as(
+        &mut self,
+        p: &PatternMatchAs,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // If there is no sub-pattern, then it's an irrefutable match.
+        if p.pattern.is_none() {
+            if !pc.allow_irrefutable {
+                if let Some(_name) = p.name.as_ref() {
+                    // TODO: This error message does not match cpython exactly
+                    // A name capture makes subsequent patterns unreachable.
+                    return Err(self.error(CodegenErrorType::UnreachablePattern(
+                        PatternUnreachableReason::NameCapture,
+                    )));
+                } else {
+                    // A wildcard makes remaining patterns unreachable.
+                    return Err(self.error(CodegenErrorType::UnreachablePattern(
+                        PatternUnreachableReason::Wildcard,
+                    )));
+                }
+            }
+            // If irrefutable matches are allowed, store the name (if any).
+            return self.pattern_helper_store_name(p.name.as_ref(), pc);
+        }
+
+        // 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 });
+        // Compile the sub-pattern.
+        self.compile_pattern(p.pattern.as_ref().unwrap(), pc)?;
+        // After success, decrement the on_top counter.
+        pc.on_top -= 1;
+        // Store the captured name (if any).
+        self.pattern_helper_store_name(p.name.as_ref(), pc)?;
+        Ok(())
+    }
+
+    fn compile_pattern_star(
+        &mut self,
+        p: &PatternMatchStar,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        self.pattern_helper_store_name(p.name.as_ref(), pc)?;
+        Ok(())
+    }
+
+    /// Validates that keyword attributes in a class pattern are allowed
+    /// and not duplicated.
+    fn validate_kwd_attrs(
+        &mut self,
+        attrs: &[Identifier],
+        _patterns: &[Pattern],
+    ) -> CompileResult<()> {
+        let n_attrs = attrs.len();
+        for i in 0..n_attrs {
+            let attr = attrs[i].as_str();
+            // Check if the attribute name is forbidden in a Store context.
+            if self.forbidden_name(attr, NameUsage::Store)? {
+                // Return an error if the name is forbidden.
+                return Err(self.compile_error_forbidden_name(attr));
+            }
+            // Check for duplicates: compare with every subsequent attribute.
+            for ident in attrs.iter().take(n_attrs).skip(i + 1) {
+                let other = ident.as_str();
+                if attr == other {
+                    return Err(self.error(CodegenErrorType::RepeatedAttributePattern));
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn compile_pattern_class(
+        &mut self,
+        p: &PatternMatchClass,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Extract components from the MatchClass pattern.
+        let match_class = p;
+        let patterns = &match_class.arguments.patterns;
+
+        // Extract keyword attributes and patterns.
+        // Capacity is pre-allocated based on the number of keyword arguments.
+        let mut kwd_attrs = Vec::with_capacity(match_class.arguments.keywords.len());
+        let mut kwd_patterns = Vec::with_capacity(match_class.arguments.keywords.len());
+        for kwd in &match_class.arguments.keywords {
+            kwd_attrs.push(kwd.attr.clone());
+            kwd_patterns.push(kwd.pattern.clone());
+        }
+
+        let nargs = patterns.len();
+        let n_attrs = kwd_attrs.len();
+
+        // 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);
+        }
+
+        // Validate keyword attributes if any.
+        if n_attrs != 0 {
+            self.validate_kwd_attrs(&kwd_attrs, &kwd_patterns)?;
+        }
+
+        // Compile the class expression.
+        self.compile_expression(&match_class.cls)?;
+
+        // Create a new tuple of attribute names.
+        let mut attr_names = vec![];
+        for name in &kwd_attrs {
+            // Py_NewRef(name) is emulated by cloning the name into a PyObject.
+            attr_names.push(ConstantData::Str {
+                value: name.as_str().to_string().into(),
+            });
+        }
+
+        // Emit instructions:
+        // 1. Load the new tuple of attribute names.
+        self.emit_load_const(ConstantData::Tuple {
+            elements: attr_names,
+        });
+        // 2. Emit MATCH_CLASS with nargs.
+        emit!(self, Instruction::MatchClass(u32::try_from(nargs).unwrap()));
+        // 3. Duplicate the top of the stack.
+        emit!(self, Instruction::Copy { index: 1_u32 });
+        // 4. Load None.
+        self.emit_load_const(ConstantData::None);
+        // 5. Compare with IS_OP 1.
+        emit!(self, Instruction::IsOp(Invert::Yes));
+
+        // At this point the TOS is a tuple of (nargs + n_attrs) attributes (or None).
+        pc.on_top += 1;
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+
+        // Unpack the tuple into (nargs + n_attrs) items.
+        let total = nargs + n_attrs;
+        emit!(
+            self,
+            Instruction::UnpackSequence {
+                size: u32::try_from(total).unwrap()
+            }
+        );
+        pc.on_top += total;
+        pc.on_top -= 1;
+
+        // Process each sub-pattern.
+        for subpattern in patterns.iter().chain(kwd_patterns.iter()) {
+            // Check if this is a true wildcard (underscore pattern without name binding)
+            let is_true_wildcard = match subpattern {
+                Pattern::MatchAs(match_as) => {
+                    // Only consider it wildcard if both pattern and name are None (i.e., "_")
+                    match_as.pattern.is_none() && match_as.name.is_none()
+                }
+                _ => subpattern.is_wildcard(),
+            };
+
+            // Decrement the on_top counter for each sub-pattern
+            pc.on_top -= 1;
+
+            if is_true_wildcard {
+                emit!(self, Instruction::PopTop);
+                continue; // Don't compile wildcard patterns
+            }
+
+            // Compile the subpattern without irrefutability checks.
+            self.compile_pattern_subpattern(subpattern, pc)?;
+        }
+        Ok(())
+    }
+
+    fn compile_pattern_mapping(
+        &mut self,
+        p: &PatternMatchMapping,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        let mapping = p;
+        let keys = &mapping.keys;
+        let patterns = &mapping.patterns;
+        let size = keys.len();
+        let star_target = &mapping.rest;
+
+        // Validate pattern count matches key count
+        if keys.len() != patterns.len() {
+            return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                "keys ({}) / patterns ({}) length mismatch in mapping pattern",
+                keys.len(),
+                patterns.len()
+            ))));
+        }
+
+        // Validate rest pattern: '_' cannot be used as a rest target
+        if let Some(rest) = star_target
+            && rest.as_str() == "_"
+        {
+            return Err(self.error(CodegenErrorType::SyntaxError("invalid syntax".to_string())));
+        }
+
+        // Step 1: Check if subject is a mapping
+        // Stack: [subject]
+        pc.on_top += 1;
+
+        emit!(self, Instruction::MatchMapping);
+        // Stack: [subject, is_mapping]
+
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        // Stack: [subject]
+
+        // Special case: empty pattern {} with no rest
+        if size == 0 && star_target.is_none() {
+            // If the pattern is just "{}", we're done! Pop the subject
+            pc.on_top -= 1;
+            emit!(self, Instruction::PopTop);
+            return Ok(());
+        }
+
+        // Length check for patterns with keys
+        if size > 0 {
+            // Check if the mapping has at least 'size' keys
+            emit!(self, Instruction::GetLen);
+            self.emit_load_const(ConstantData::Integer { value: size.into() });
+            // Stack: [subject, len, size]
+            emit!(
+                self,
+                Instruction::CompareOp {
+                    op: ComparisonOperator::GreaterOrEqual
+                }
+            );
+            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+            // Stack: [subject]
+        }
+
+        // Check for overflow (INT_MAX < size - 1)
+        if size > (i32::MAX as usize + 1) {
+            return Err(self.error(CodegenErrorType::SyntaxError(
+                "too many sub-patterns in mapping pattern".to_string(),
+            )));
+        }
+        #[allow(clippy::cast_possible_truncation)]
+        let size = size as u32; // checked right before
+
+        // Step 2: If we have keys to match
+        if size > 0 {
+            // Validate and compile keys
+            let mut seen = HashSet::new();
+            for key in keys {
+                let is_attribute = matches!(key, Expr::Attribute(_));
+                let is_literal = matches!(
+                    key,
+                    Expr::NumberLiteral(_)
+                        | Expr::StringLiteral(_)
+                        | Expr::BytesLiteral(_)
+                        | Expr::BooleanLiteral(_)
+                        | Expr::NoneLiteral(_)
+                );
+                let key_repr = if is_literal {
+                    UnparseExpr::new(key, &self.source_file).to_string()
+                } else if is_attribute {
+                    String::new()
+                } else {
+                    return Err(self.error(CodegenErrorType::SyntaxError(
+                        "mapping pattern keys may only match literals and attribute lookups"
+                            .to_string(),
+                    )));
+                };
+
+                if !key_repr.is_empty() && seen.contains(&key_repr) {
+                    return Err(self.error(CodegenErrorType::SyntaxError(format!(
+                        "mapping pattern checks duplicate key ({key_repr})"
+                    ))));
+                }
+                if !key_repr.is_empty() {
+                    seen.insert(key_repr);
+                }
+
+                self.compile_expression(key)?;
+            }
+        }
+        // Stack: [subject, key1, key2, ..., key_n]
+
+        // Build tuple of keys (empty tuple if size==0)
+        emit!(self, Instruction::BuildTuple { size });
+        // Stack: [subject, keys_tuple]
+
+        // Match keys
+        emit!(self, Instruction::MatchKeys);
+        // Stack: [subject, keys_tuple, values_or_none]
+        pc.on_top += 2; // subject and keys_tuple are underneath
+
+        // Check if match succeeded
+        emit!(self, Instruction::Copy { index: 1_u32 });
+        // Stack: [subject, keys_tuple, values_tuple, values_tuple_copy]
+
+        // Check if copy is None (consumes the copy like POP_JUMP_IF_NONE)
+        self.emit_load_const(ConstantData::None);
+        emit!(self, Instruction::IsOp(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 });
+        // 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;
+
+        // Step 3: Process matched values
+        for i in 0..size {
+            pc.on_top -= 1;
+            self.compile_pattern_subpattern(&patterns[i as usize], pc)?;
+        }
+
+        // After processing subpatterns, adjust on_top
+        // "Whatever happens next should consume the tuple of keys and the subject"
+        // Stack currently: [subject, keys_tuple, ...any captured values...]
+        pc.on_top -= 2;
+
+        // Step 4: Handle rest pattern or cleanup
+        if let Some(rest_name) = star_target {
+            // Build rest dict for **rest pattern
+            // Stack: [subject, keys_tuple]
+
+            // Build rest dict exactly
+            emit!(self, Instruction::BuildMap { size: 0 });
+            // Stack: [subject, keys_tuple, {}]
+            emit!(self, Instruction::Swap { index: 3 });
+            // Stack: [{}, keys_tuple, subject]
+            emit!(self, Instruction::DictUpdate { index: 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 });
+            // Stack: [rest_dict, k1, k2, ..., kn] (if size==0, nothing pushed)
+
+            // Delete each key from rest_dict (skipped when size==0)
+            // while (size) { COPY(1 + size--); SWAP(2); DELETE_SUBSCR }
+            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
+                    }
+                );
+                // Stack: [rest_dict, k1, ..., kn, rest_dict]
+                emit!(self, Instruction::Swap { index: 2 });
+                // Stack: [rest_dict, k1, ..., kn-1, rest_dict, kn]
+                emit!(self, Instruction::DeleteSubscr);
+                // Stack: [rest_dict, k1, ..., kn-1] (removed kn from rest_dict)
+                remaining -= 1;
+            }
+            // Stack: [rest_dict] (plus any previously stored values)
+            // pattern_helper_store_name will handle the rotation correctly
+
+            // Store the rest dict
+            self.pattern_helper_store_name(Some(rest_name), pc)?;
+
+            // After storing all values, pc.on_top should be 0
+            // The values are rotated to the bottom for later storage
+            pc.on_top = 0;
+        } else {
+            // Non-rest pattern: just clean up the stack
+
+            // Pop them as we're not using them
+            emit!(self, Instruction::PopTop); // Pop keys_tuple
+            emit!(self, Instruction::PopTop); // Pop subject
+        }
+
+        Ok(())
+    }
+
+    fn compile_pattern_or(
+        &mut self,
+        p: &PatternMatchOr,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // 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");
+
+        // Save the current pattern context.
+        let old_pc = pc.clone();
+        // Simulate Py_INCREF on pc.stores by cloning it.
+        pc.stores = pc.stores.clone();
+        let mut control: Option<Vec<String>> = None; // Will hold the capture list of the first alternative.
+
+        // Process each alternative.
+        for (i, alt) in p.patterns.iter().enumerate() {
+            // Create a fresh empty store for this alternative.
+            pc.stores = Vec::new();
+            // An irrefutable subpattern must be last (if allowed).
+            pc.allow_irrefutable = (i == size - 1) && old_pc.allow_irrefutable;
+            // Reset failure targets and the on_top counter.
+            pc.fail_pop.clear();
+            pc.on_top = 0;
+            // Emit a COPY(1) instruction before compiling the alternative.
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            self.compile_pattern(alt, pc)?;
+
+            let n_stores = pc.stores.len();
+            if i == 0 {
+                // Save the captured names from the first alternative.
+                control = Some(pc.stores.clone());
+            } else {
+                let control_vec = control.as_ref().unwrap();
+                if n_stores != control_vec.len() {
+                    return Err(self.error(CodegenErrorType::ConflictingNameBindPattern));
+                } else if n_stores > 0 {
+                    // Check that the names occur in the same order.
+                    for i_control in (0..n_stores).rev() {
+                        let name = &control_vec[i_control];
+                        // Find the index of `name` in the current stores.
+                        let i_stores =
+                            pc.stores.iter().position(|n| n == name).ok_or_else(|| {
+                                self.error(CodegenErrorType::ConflictingNameBindPattern)
+                            })?;
+                        if i_control != i_stores {
+                            // The orders differ; we must reorder.
+                            assert!(i_stores < i_control, "expected i_stores < i_control");
+                            let rotations = i_stores + 1;
+                            // Rotate pc.stores: take a slice of the first `rotations` items...
+                            let rotated = pc.stores[0..rotations].to_vec();
+                            // Remove those elements.
+                            for _ in 0..rotations {
+                                pc.stores.remove(0);
+                            }
+                            // Insert the rotated slice at the appropriate index.
+                            let insert_pos = i_control - i_stores;
+                            for (j, elem) in rotated.into_iter().enumerate() {
+                                pc.stores.insert(insert_pos + j, elem);
+                            }
+                            // Also perform the same rotation on the evaluation stack.
+                            for _ in 0..=i_stores {
+                                self.pattern_helper_rotate(i_control + 1)?;
+                            }
+                        }
+                    }
+                }
+            }
+            // Emit a jump to the common end label and reset any failure jump targets.
+            emit!(self, PseudoInstruction::Jump { target: end });
+            self.emit_and_reset_fail_pop(pc)?;
+        }
+
+        // Restore the original pattern context.
+        *pc = old_pc.clone();
+        // Simulate Py_INCREF on pc.stores.
+        pc.stores = pc.stores.clone();
+        // In C, old_pc.fail_pop is set to NULL to avoid freeing it later.
+        // In Rust, old_pc is a local clone, so we need not worry about that.
+
+        // No alternative matched: pop the subject and fail.
+        emit!(self, Instruction::PopTop);
+        self.jump_to_fail_pop(pc, JumpOp::Jump)?;
+
+        // Use the label "end".
+        self.switch_to_block(end);
+
+        // Adjust the final captures.
+        let n_stores = control.as_ref().unwrap().len();
+        let n_rots = n_stores + 1 + pc.on_top + pc.stores.len();
+        for i in 0..n_stores {
+            // Rotate the capture to its proper place.
+            self.pattern_helper_rotate(n_rots)?;
+            let name = &control.as_ref().unwrap()[i];
+            // Check for duplicate binding.
+            if pc.stores.contains(name) {
+                return Err(self.error(CodegenErrorType::DuplicateStore(name.to_string())));
+            }
+            pc.stores.push(name.clone());
+        }
+
+        // Old context and control will be dropped automatically.
+        // Finally, pop the copy of the subject.
+        emit!(self, Instruction::PopTop);
+        Ok(())
+    }
+
+    fn compile_pattern_sequence(
+        &mut self,
+        p: &PatternMatchSequence,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Ensure the pattern is a MatchSequence.
+        let patterns = &p.patterns; // a slice of Pattern
+        let size = patterns.len();
+        let mut star: Option<usize> = None;
+        let mut only_wildcard = true;
+        let mut star_wildcard = false;
+
+        // Find a starred pattern, if it exists. There may be at most one.
+        for (i, pattern) in patterns.iter().enumerate() {
+            if pattern.is_match_star() {
+                if star.is_some() {
+                    // TODO: Fix error msg
+                    return Err(self.error(CodegenErrorType::MultipleStarArgs));
+                }
+                // star wildcard check
+                star_wildcard = pattern
+                    .as_match_star()
+                    .map(|m| m.name.is_none())
+                    .unwrap_or(false);
+                only_wildcard &= star_wildcard;
+                star = Some(i);
+                continue;
+            }
+            // wildcard check
+            only_wildcard &= pattern
+                .as_match_as()
+                .map(|m| m.name.is_none())
+                .unwrap_or(false);
+        }
+
+        // Keep the subject on top during the sequence and length checks.
+        pc.on_top += 1;
+        emit!(self, Instruction::MatchSequence);
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+
+        if star.is_none() {
+            // No star: len(subject) == size
+            emit!(self, Instruction::GetLen);
+            self.emit_load_const(ConstantData::Integer { value: size.into() });
+            emit!(
+                self,
+                Instruction::CompareOp {
+                    op: ComparisonOperator::Equal
+                }
+            );
+            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        } else if size > 1 {
+            // Star exists: len(subject) >= size - 1
+            emit!(self, Instruction::GetLen);
+            self.emit_load_const(ConstantData::Integer {
+                value: (size - 1).into(),
+            });
+            emit!(
+                self,
+                Instruction::CompareOp {
+                    op: ComparisonOperator::GreaterOrEqual
+                }
+            );
+            self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        }
+
+        // Whatever comes next should consume the subject.
+        pc.on_top -= 1;
+        if only_wildcard {
+            // Patterns like: [] / [_] / [_, _] / [*_] / [_, *_] / [_, _, *_] / etc.
+            emit!(self, Instruction::PopTop);
+        } else if star_wildcard {
+            self.pattern_helper_sequence_subscr(patterns, star.unwrap(), pc)?;
+        } else {
+            self.pattern_helper_sequence_unpack(patterns, star, pc)?;
+        }
+        Ok(())
+    }
+
+    fn compile_pattern_value(
+        &mut self,
+        p: &PatternMatchValue,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // TODO: ensure literal or attribute lookup
+        self.compile_expression(&p.value)?;
+        emit!(
+            self,
+            Instruction::CompareOp {
+                op: bytecode::ComparisonOperator::Equal
+            }
+        );
+        // emit!(self, Instruction::ToBool);
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        Ok(())
+    }
+
+    fn compile_pattern_singleton(
+        &mut self,
+        p: &PatternMatchSingleton,
+        pc: &mut PatternContext,
+    ) -> CompileResult<()> {
+        // Load the singleton constant value.
+        self.emit_load_const(match p.value {
+            Singleton::None => ConstantData::None,
+            Singleton::False => ConstantData::Boolean { value: false },
+            Singleton::True => ConstantData::Boolean { value: true },
+        });
+        // Compare using the "Is" operator.
+        emit!(self, Instruction::IsOp(Invert::No));
+        // Jump to the failure label if the comparison is false.
+        self.jump_to_fail_pop(pc, JumpOp::PopJumpIfFalse)?;
+        Ok(())
+    }
+
+    fn compile_pattern(
+        &mut self,
+        pattern_type: &Pattern,
+        pattern_context: &mut PatternContext,
+    ) -> CompileResult<()> {
+        match &pattern_type {
+            Pattern::MatchValue(pattern_type) => {
+                self.compile_pattern_value(pattern_type, pattern_context)
+            }
+            Pattern::MatchSingleton(pattern_type) => {
+                self.compile_pattern_singleton(pattern_type, pattern_context)
+            }
+            Pattern::MatchSequence(pattern_type) => {
+                self.compile_pattern_sequence(pattern_type, pattern_context)
+            }
+            Pattern::MatchMapping(pattern_type) => {
+                self.compile_pattern_mapping(pattern_type, pattern_context)
+            }
+            Pattern::MatchClass(pattern_type) => {
+                self.compile_pattern_class(pattern_type, pattern_context)
+            }
+            Pattern::MatchStar(pattern_type) => {
+                self.compile_pattern_star(pattern_type, pattern_context)
+            }
+            Pattern::MatchAs(pattern_type) => {
+                self.compile_pattern_as(pattern_type, pattern_context)
+            }
+            Pattern::MatchOr(pattern_type) => {
+                self.compile_pattern_or(pattern_type, pattern_context)
+            }
+        }
+    }
+
+    fn compile_match_inner(
+        &mut self,
+        subject: &Expr,
+        cases: &[MatchCase],
+        pattern_context: &mut PatternContext,
+    ) -> CompileResult<()> {
+        self.compile_expression(subject)?;
+        let end = self.new_block();
+
+        let num_cases = cases.len();
+        assert!(num_cases > 0);
+        let has_default = cases.iter().last().unwrap().pattern.is_match_star() && num_cases > 1;
+
+        let case_count = num_cases - if has_default { 1 } else { 0 };
+        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 });
+            }
+
+            pattern_context.stores = Vec::with_capacity(1);
+            pattern_context.allow_irrefutable = m.guard.is_some() || i == case_count - 1;
+            pattern_context.fail_pop.clear();
+            pattern_context.on_top = 0;
+
+            self.compile_pattern(&m.pattern, pattern_context)?;
+            assert_eq!(pattern_context.on_top, 0);
+
+            for name in &pattern_context.stores {
+                self.compile_name(name, NameUsage::Store)?;
+            }
+
+            if let Some(ref guard) = m.guard {
+                self.ensure_fail_pop(pattern_context, 0)?;
+                // Compile the guard expression
+                self.compile_expression(guard)?;
+                emit!(self, Instruction::ToBool);
+                emit!(
+                    self,
+                    Instruction::PopJumpIfFalse {
+                        target: pattern_context.fail_pop[0]
+                    }
+                );
+            }
+
+            if i != case_count - 1 {
+                emit!(self, Instruction::PopTop);
+            }
+
+            self.compile_statements(&m.body)?;
+            emit!(self, PseudoInstruction::Jump { target: end });
+            self.emit_and_reset_fail_pop(pattern_context)?;
+        }
+
+        if has_default {
+            let m = &cases[num_cases - 1];
+            if num_cases == 1 {
+                emit!(self, Instruction::PopTop);
+            } else {
+                emit!(self, Instruction::Nop);
+            }
+            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::PopTop);
+            }
+            self.compile_statements(&m.body)?;
+        }
+        self.switch_to_block(end);
+        Ok(())
+    }
+
+    fn compile_match(&mut self, subject: &Expr, cases: &[MatchCase]) -> CompileResult<()> {
+        let mut pattern_context = PatternContext::new();
+        self.compile_match_inner(subject, cases, &mut pattern_context)?;
+        Ok(())
+    }
+
+    /// [CPython `compiler_addcompare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L2880-L2924)
+    fn compile_addcompare(&mut self, op: &CmpOp) {
+        use bytecode::ComparisonOperator::*;
+        match op {
+            CmpOp::Eq => emit!(self, Instruction::CompareOp { op: Equal }),
+            CmpOp::NotEq => emit!(self, Instruction::CompareOp { op: NotEqual }),
+            CmpOp::Lt => emit!(self, Instruction::CompareOp { op: Less }),
+            CmpOp::LtE => emit!(self, Instruction::CompareOp { op: LessOrEqual }),
+            CmpOp::Gt => emit!(self, Instruction::CompareOp { op: Greater }),
+            CmpOp::GtE => {
+                emit!(self, Instruction::CompareOp { op: GreaterOrEqual })
+            }
+            CmpOp::In => emit!(self, Instruction::ContainsOp(Invert::No)),
+            CmpOp::NotIn => emit!(self, Instruction::ContainsOp(Invert::Yes)),
+            CmpOp::Is => emit!(self, Instruction::IsOp(Invert::No)),
+            CmpOp::IsNot => emit!(self, Instruction::IsOp(Invert::Yes)),
+        }
+    }
+
+    /// Compile a chained comparison.
+    ///
+    /// ```py
+    /// a == b == c == d
+    /// ```
+    ///
+    /// Will compile into (pseudo code):
+    ///
+    /// ```py
+    /// result = a == b
+    /// if result:
+    ///   result = b == c
+    ///   if result:
+    ///     result = c == d
+    /// ```
+    ///
+    /// # See Also
+    /// - [CPython `compiler_compare`](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Python/compile.c#L4678-L4717)
+    fn compile_compare(
+        &mut self,
+        left: &Expr,
+        ops: &[CmpOp],
+        comparators: &[Expr],
+    ) -> CompileResult<()> {
+        let (last_op, mid_ops) = ops.split_last().unwrap();
+        let (last_comparator, mid_comparators) = comparators.split_last().unwrap();
+
+        // initialize lhs outside of loop
+        self.compile_expression(left)?;
+
+        if mid_comparators.is_empty() {
+            self.compile_expression(last_comparator)?;
+            self.compile_addcompare(last_op);
+
+            return Ok(());
+        }
+
+        let cleanup = self.new_block();
+
+        // for all comparisons except the last (as the last one doesn't need a conditional jump)
+        for (op, comparator) in mid_ops.iter().zip(mid_comparators) {
+            self.compile_expression(comparator)?;
+
+            // store rhs for the next comparison in chain
+            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::Copy { index: 2 });
+
+            self.compile_addcompare(op);
+
+            // if comparison result is false, we break with this value; if true, try the next one.
+            /*
+            emit!(self, Instruction::Copy { index: 1 });
+            // emit!(self, Instruction::ToBool); // TODO: Uncomment this
+            emit!(self, Instruction::PopJumpIfFalse { target: cleanup });
+            emit!(self, Instruction::PopTop);
+            */
+
+            emit!(self, Instruction::JumpIfFalseOrPop { target: cleanup });
+        }
+
+        self.compile_expression(last_comparator)?;
+        self.compile_addcompare(last_op);
+
+        let end = self.new_block();
+        emit!(self, PseudoInstruction::Jump { target: end });
+
+        // early exit left us with stack: `rhs, comparison_result`. We need to clean up rhs.
+        self.switch_to_block(cleanup);
+        emit!(self, Instruction::Swap { index: 2 });
+        emit!(self, Instruction::PopTop);
+
+        self.switch_to_block(end);
+        Ok(())
+    }
+
+    fn compile_annotation(&mut self, annotation: &Expr) -> CompileResult<()> {
+        if self.future_annotations {
+            self.emit_load_const(ConstantData::Str {
+                value: UnparseExpr::new(annotation, &self.source_file)
+                    .to_string()
+                    .into(),
+            });
+        } else {
+            let was_in_annotation = self.in_annotation;
+            self.in_annotation = true;
+
+            // Special handling for starred annotations (*Ts -> Unpack[Ts])
+            let result = match annotation {
+                Expr::Starred(ExprStarred { value, .. }) => {
+                    // *args: *Ts (where Ts is a TypeVarTuple).
+                    // Do [annotation_value] = [*Ts].
+                    self.compile_expression(value)?;
+                    emit!(self, Instruction::UnpackSequence { size: 1 });
+                    Ok(())
+                }
+                _ => self.compile_expression(annotation),
+            };
+
+            self.in_annotation = was_in_annotation;
+            result?;
+        }
+        Ok(())
+    }
+
+    fn compile_annotated_assign(
+        &mut self,
+        target: &Expr,
+        annotation: &Expr,
+        value: Option<&Expr>,
+    ) -> CompileResult<()> {
+        if let Some(value) = value {
+            self.compile_expression(value)?;
+            self.compile_store(target)?;
+        }
+
+        // Annotations are only evaluated in a module or class.
+        if self.ctx.in_func() {
+            return Ok(());
+        }
+
+        // Compile annotation:
+        self.compile_annotation(annotation)?;
+
+        if let Expr::Name(ExprName { id, .. }) = &target {
+            // Store as dict entry in __annotations__ dict:
+            let annotations = self.name("__annotations__");
+            emit!(self, Instruction::LoadName(annotations));
+            self.emit_load_const(ConstantData::Str {
+                value: self.mangle(id.as_str()).into_owned().into(),
+            });
+            emit!(self, Instruction::StoreSubscr);
+        } else {
+            // Drop annotation if not assigned to simple identifier.
+            emit!(self, Instruction::PopTop);
+        }
+
+        Ok(())
+    }
+
+    fn compile_store(&mut self, target: &Expr) -> CompileResult<()> {
+        match &target {
+            Expr::Name(ExprName { id, .. }) => self.store_name(id.as_str())?,
+            Expr::Subscript(ExprSubscript {
+                value, slice, ctx, ..
+            }) => {
+                self.compile_subscript(value, slice, *ctx)?;
+            }
+            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+                self.check_forbidden_name(attr.as_str(), NameUsage::Store)?;
+                self.compile_expression(value)?;
+                let idx = self.name(attr.as_str());
+                emit!(self, Instruction::StoreAttr { idx });
+            }
+            Expr::List(ExprList { elts, .. }) | Expr::Tuple(ExprTuple { elts, .. }) => {
+                let mut seen_star = false;
+
+                // Scan for star args:
+                for (i, element) in elts.iter().enumerate() {
+                    if let Expr::Starred(_) = &element {
+                        if seen_star {
+                            return Err(self.error(CodegenErrorType::MultipleStarArgs));
+                        } else {
+                            seen_star = true;
+                            let before = i;
+                            let after = elts.len() - i - 1;
+                            let (before, after) = (|| Some((before.to_u8()?, after.to_u8()?)))()
+                                .ok_or_else(|| {
+                                    self.error_ranged(
+                                        CodegenErrorType::TooManyStarUnpack,
+                                        target.range(),
+                                    )
+                                })?;
+                            let args = bytecode::UnpackExArgs { before, after };
+                            emit!(self, Instruction::UnpackEx { args });
+                        }
+                    }
+                }
+
+                if !seen_star {
+                    emit!(
+                        self,
+                        Instruction::UnpackSequence {
+                            size: elts.len().to_u32(),
+                        }
+                    );
+                }
+
+                for element in elts {
+                    if let Expr::Starred(ExprStarred { value, .. }) = &element {
+                        self.compile_store(value)?;
+                    } else {
+                        self.compile_store(element)?;
+                    }
+                }
+            }
+            _ => {
+                return Err(self.error(match target {
+                    Expr::Starred(_) => CodegenErrorType::SyntaxError(
+                        "starred assignment target must be in a list or tuple".to_owned(),
+                    ),
+                    _ => CodegenErrorType::Assign(target.python_name()),
+                }));
+            }
+        }
+
+        Ok(())
+    }
+
+    fn compile_augassign(
+        &mut self,
+        target: &Expr,
+        op: &Operator,
+        value: &Expr,
+    ) -> CompileResult<()> {
+        enum AugAssignKind<'a> {
+            Name { id: &'a str },
+            Subscript,
+            Attr { idx: bytecode::NameIdx },
+        }
+
+        let kind = match &target {
+            Expr::Name(ExprName { id, .. }) => {
+                let id = id.as_str();
+                self.compile_name(id, NameUsage::Load)?;
+                AugAssignKind::Name { id }
+            }
+            Expr::Subscript(ExprSubscript {
+                value,
+                slice,
+                ctx: _,
+                ..
+            }) => {
+                // For augmented assignment, we need to load the value first
+                // 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::Subscript);
+                AugAssignKind::Subscript
+            }
+            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+                let attr = attr.as_str();
+                self.check_forbidden_name(attr, NameUsage::Store)?;
+                self.compile_expression(value)?;
+                emit!(self, Instruction::Copy { index: 1_u32 });
+                let idx = self.name(attr);
+                emit!(self, Instruction::LoadAttr { idx });
+                AugAssignKind::Attr { idx }
+            }
+            _ => {
+                return Err(self.error(CodegenErrorType::Assign(target.python_name())));
+            }
+        };
+
+        self.compile_expression(value)?;
+        self.compile_op(op, true);
+
+        match kind {
+            AugAssignKind::Name { id } => {
+                // stack: RESULT
+                self.compile_name(id, NameUsage::Store)?;
+            }
+            AugAssignKind::Subscript => {
+                // stack: CONTAINER SLICE RESULT
+                emit!(self, Instruction::Swap { index: 3 });
+                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::StoreSubscr);
+            }
+            AugAssignKind::Attr { idx } => {
+                // stack: CONTAINER RESULT
+                emit!(self, Instruction::Swap { index: 2 });
+                emit!(self, Instruction::StoreAttr { idx });
+            }
+        }
+
+        Ok(())
+    }
+
+    fn compile_op(&mut self, op: &Operator, inplace: bool) {
+        let bin_op = match op {
+            Operator::Add => BinaryOperator::Add,
+            Operator::Sub => BinaryOperator::Subtract,
+            Operator::Mult => BinaryOperator::Multiply,
+            Operator::MatMult => BinaryOperator::MatrixMultiply,
+            Operator::Div => BinaryOperator::TrueDivide,
+            Operator::FloorDiv => BinaryOperator::FloorDivide,
+            Operator::Mod => BinaryOperator::Remainder,
+            Operator::Pow => BinaryOperator::Power,
+            Operator::LShift => BinaryOperator::Lshift,
+            Operator::RShift => BinaryOperator::Rshift,
+            Operator::BitOr => BinaryOperator::Or,
+            Operator::BitXor => BinaryOperator::Xor,
+            Operator::BitAnd => BinaryOperator::And,
+        };
+
+        let op = if inplace { bin_op.as_inplace() } else { bin_op };
+        emit!(self, Instruction::BinaryOp { op })
+    }
+
+    /// Implement boolean short circuit evaluation logic.
+    /// https://en.wikipedia.org/wiki/Short-circuit_evaluation
+    ///
+    /// This means, in a boolean statement 'x and y' the variable y will
+    /// not be evaluated when x is false.
+    ///
+    /// The idea is to jump to a label if the expression is either true or false
+    /// (indicated by the condition parameter).
+    fn compile_jump_if(
+        &mut self,
+        expression: &Expr,
+        condition: bool,
+        target_block: BlockIdx,
+    ) -> CompileResult<()> {
+        // Compile expression for test, and jump to label if false
+        match &expression {
+            Expr::BoolOp(ExprBoolOp { op, values, .. }) => {
+                match op {
+                    BoolOp::And => {
+                        if condition {
+                            // If all values are true.
+                            let end_block = self.new_block();
+                            let (last_value, values) = values.split_last().unwrap();
+
+                            // If any of the values is false, we can short-circuit.
+                            for value in values {
+                                self.compile_jump_if(value, false, end_block)?;
+                            }
+
+                            // It depends upon the last value now: will it be true?
+                            self.compile_jump_if(last_value, true, target_block)?;
+                            self.switch_to_block(end_block);
+                        } else {
+                            // If any value is false, the whole condition is false.
+                            for value in values {
+                                self.compile_jump_if(value, false, target_block)?;
+                            }
+                        }
+                    }
+                    BoolOp::Or => {
+                        if condition {
+                            // If any of the values is true.
+                            for value in values {
+                                self.compile_jump_if(value, true, target_block)?;
+                            }
+                        } else {
+                            // If all of the values are false.
+                            let end_block = self.new_block();
+                            let (last_value, values) = values.split_last().unwrap();
+
+                            // If any value is true, we can short-circuit:
+                            for value in values {
+                                self.compile_jump_if(value, true, end_block)?;
+                            }
+
+                            // It all depends upon the last value now!
+                            self.compile_jump_if(last_value, false, target_block)?;
+                            self.switch_to_block(end_block);
+                        }
+                    }
+                }
+            }
+            Expr::UnaryOp(ExprUnaryOp {
+                op: UnaryOp::Not,
+                operand,
+                ..
+            }) => {
+                self.compile_jump_if(operand, !condition, target_block)?;
+            }
+            _ => {
+                // Fall back case which always will work!
+                self.compile_expression(expression)?;
+                if condition {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfTrue {
+                            target: target_block,
+                        }
+                    );
+                } else {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfFalse {
+                            target: target_block,
+                        }
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Compile a boolean operation as an expression.
+    /// This means, that the last value remains on the stack.
+    fn compile_bool_op(&mut self, op: &BoolOp, values: &[Expr]) -> CompileResult<()> {
+        let after_block = self.new_block();
+
+        let (last_value, values) = values.split_last().unwrap();
+
+        for value in values {
+            self.compile_expression(value)?;
+
+            emit!(self, Instruction::Copy { index: 1_u32 });
+            match op {
+                BoolOp::And => {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfFalse {
+                            target: after_block,
+                        }
+                    );
+                }
+                BoolOp::Or => {
+                    emit!(
+                        self,
+                        Instruction::PopJumpIfTrue {
+                            target: after_block,
+                        }
+                    );
+                }
+            }
+
+            emit!(self, Instruction::PopTop);
+        }
+
+        // If all values did not qualify, take the value of the last value:
+        self.compile_expression(last_value)?;
+        self.switch_to_block(after_block);
+        Ok(())
+    }
+
+    fn compile_dict(&mut self, items: &[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;
+        }
+        emit!(self, Instruction::BuildMap { size });
+
+        for item in unpacked {
+            self.compile_expression(&item.value)?;
+            emit!(self, Instruction::DictUpdate { index: 1 });
+        }
+
+        Ok(())
+    }
+
+    /// Compile the yield-from/await sequence using SEND/END_SEND/CLEANUP_THROW.
+    /// compiler_add_yield_from
+    /// This generates:
+    ///   send:
+    ///     SEND exit
+    ///     SETUP_FINALLY fail (via exception table)
+    ///     YIELD_VALUE 1
+    ///     POP_BLOCK (implicit)
+    ///     RESUME
+    ///     JUMP send
+    ///   fail:
+    ///     CLEANUP_THROW
+    ///   exit:
+    ///     END_SEND
+    fn compile_yield_from_sequence(&mut self, is_await: bool) -> CompileResult<()> {
+        let send_block = self.new_block();
+        let fail_block = self.new_block();
+        let exit_block = self.new_block();
+
+        // send:
+        self.switch_to_block(send_block);
+        emit!(self, Instruction::Send { target: exit_block });
+
+        // SETUP_FINALLY fail - set up exception handler for YIELD_VALUE
+        // Stack at this point: [receiver, yielded_value]
+        // handler_depth = base + 2 (receiver + yielded_value)
+        let handler_depth = self.handler_stack_depth() + 2;
+        self.push_fblock_with_handler(
+            FBlockType::TryExcept, // Use TryExcept for exception handler
+            send_block,
+            exit_block,
+            Some(fail_block),
+            handler_depth,
+            false, // no lasti needed
+        )?;
+
+        // YIELD_VALUE with arg=1 (yield-from/await mode - not wrapped for async gen)
+        emit!(self, Instruction::YieldValue { arg: 1 });
+
+        // POP_BLOCK (implicit - pop fblock before RESUME)
+        self.pop_fblock(FBlockType::TryExcept);
+
+        // RESUME
+        emit!(
+            self,
+            Instruction::Resume {
+                arg: if is_await {
+                    bytecode::ResumeType::AfterAwait as u32
+                } else {
+                    bytecode::ResumeType::AfterYieldFrom as u32
+                }
+            }
+        );
+
+        // JUMP_NO_INTERRUPT send (regular JUMP in RustPython)
+        emit!(self, PseudoInstruction::Jump { target: send_block });
+
+        // fail: CLEANUP_THROW
+        // Stack when exception: [receiver, yielded_value, exc]
+        // CLEANUP_THROW: [sub_iter, last_sent_val, exc] -> [None, value]
+        // After: stack is [None, value], fall through to exit
+        self.switch_to_block(fail_block);
+        emit!(self, Instruction::CleanupThrow);
+        // Fall through to exit block
+
+        // exit: END_SEND
+        // Stack: [receiver, value] (from SEND) or [None, value] (from CLEANUP_THROW)
+        // END_SEND: [receiver/None, value] -> [value]
+        self.switch_to_block(exit_block);
+        emit!(self, Instruction::EndSend);
+
+        Ok(())
+    }
+
+    fn compile_expression(&mut self, expression: &Expr) -> CompileResult<()> {
+        use ruff_python_ast::*;
+        trace!("Compiling {expression:?}");
+        let range = expression.range();
+        self.set_source_range(range);
+
+        match &expression {
+            Expr::Call(ExprCall {
+                func, arguments, ..
+            }) => self.compile_call(func, arguments)?,
+            Expr::BoolOp(ExprBoolOp { op, values, .. }) => self.compile_bool_op(op, values)?,
+            Expr::BinOp(ExprBinOp {
+                left, op, right, ..
+            }) => {
+                self.compile_expression(left)?;
+                self.compile_expression(right)?;
+
+                // Perform operation:
+                self.compile_op(op, false);
+            }
+            Expr::Subscript(ExprSubscript {
+                value, slice, ctx, ..
+            }) => {
+                self.compile_subscript(value, slice, *ctx)?;
+            }
+            Expr::UnaryOp(ExprUnaryOp { op, operand, .. }) => {
+                self.compile_expression(operand)?;
+
+                // Perform operation:
+                match op {
+                    UnaryOp::UAdd => emit!(
+                        self,
+                        Instruction::CallIntrinsic1 {
+                            func: bytecode::IntrinsicFunction1::UnaryPositive
+                        }
+                    ),
+                    UnaryOp::USub => emit!(self, Instruction::UnaryNegative),
+                    UnaryOp::Not => {
+                        emit!(self, Instruction::ToBool);
+                        emit!(self, Instruction::UnaryNot);
+                    }
+                    UnaryOp::Invert => emit!(self, Instruction::UnaryInvert),
+                };
+            }
+            Expr::Attribute(ExprAttribute { value, attr, .. }) => {
+                // Check for super() attribute access optimization
+                if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
+                    // super().attr or super(cls, self).attr optimization
+                    // Stack: [global_super, class, self] → LOAD_SUPER_ATTR → [attr]
+                    self.load_args_for_super(&super_type)?;
+                    let idx = self.name(attr.as_str());
+                    match super_type {
+                        SuperCallType::TwoArg { .. } => {
+                            // LoadSuperAttr (pseudo) - will be converted to real LoadSuperAttr
+                            // with flags=0b10 (has_class=true, load_method=false) in ir.rs
+                            emit!(self, Instruction::LoadSuperAttr { arg: idx });
+                        }
+                        SuperCallType::ZeroArg => {
+                            emit!(self, PseudoInstruction::LoadZeroSuperAttr { idx });
+                        }
+                    }
+                } else {
+                    // Normal attribute access
+                    self.compile_expression(value)?;
+                    let idx = self.name(attr.as_str());
+                    emit!(self, Instruction::LoadAttr { idx });
+                }
+            }
+            Expr::Compare(ExprCompare {
+                left,
+                ops,
+                comparators,
+                ..
+            }) => {
+                self.compile_compare(left, ops, comparators)?;
+            }
+            // Expr::Constant(ExprConstant { value, .. }) => {
+            //     self.emit_load_const(compile_constant(value));
+            // }
+            Expr::List(ExprList { elts, .. }) => {
+                self.starunpack_helper(elts, 0, CollectionType::List)?;
+            }
+            Expr::Tuple(ExprTuple { elts, .. }) => {
+                self.starunpack_helper(elts, 0, CollectionType::Tuple)?;
+            }
+            Expr::Set(ExprSet { elts, .. }) => {
+                self.starunpack_helper(elts, 0, CollectionType::Set)?;
+            }
+            Expr::Dict(ExprDict { items, .. }) => {
+                self.compile_dict(items)?;
+            }
+            Expr::Slice(ExprSlice {
+                lower, upper, step, ..
+            }) => {
+                let mut compile_bound = |bound: Option<&Expr>| match bound {
+                    Some(exp) => self.compile_expression(exp),
+                    None => {
+                        self.emit_load_const(ConstantData::None);
+                        Ok(())
+                    }
+                };
+                compile_bound(lower.as_deref())?;
+                compile_bound(upper.as_deref())?;
+                if let Some(step) = step {
+                    self.compile_expression(step)?;
+                }
+                let argc = match step {
+                    Some(_) => BuildSliceArgCount::Three,
+                    None => BuildSliceArgCount::Two,
+                };
+                emit!(self, Instruction::BuildSlice { argc });
+            }
+            Expr::Yield(ExprYield { value, .. }) => {
+                if !self.ctx.in_func() {
+                    return Err(self.error(CodegenErrorType::InvalidYield));
+                }
+                self.mark_generator();
+                match value {
+                    Some(expression) => self.compile_expression(expression)?,
+                    Option::None => self.emit_load_const(ConstantData::None),
+                };
+                // arg=0: direct yield (wrapped for async generators)
+                emit!(self, Instruction::YieldValue { arg: 0 });
+                emit!(
+                    self,
+                    Instruction::Resume {
+                        arg: bytecode::ResumeType::AfterYield as u32
+                    }
+                );
+            }
+            Expr::Await(ExprAwait { value, .. }) => {
+                if self.ctx.func != FunctionContext::AsyncFunction {
+                    return Err(self.error(CodegenErrorType::InvalidAwait));
+                }
+                self.compile_expression(value)?;
+                emit!(self, Instruction::GetAwaitable);
+                self.emit_load_const(ConstantData::None);
+                self.compile_yield_from_sequence(true)?;
+            }
+            Expr::YieldFrom(ExprYieldFrom { value, .. }) => {
+                match self.ctx.func {
+                    FunctionContext::NoFunction => {
+                        return Err(self.error(CodegenErrorType::InvalidYieldFrom));
+                    }
+                    FunctionContext::AsyncFunction => {
+                        return Err(self.error(CodegenErrorType::AsyncYieldFrom));
+                    }
+                    FunctionContext::Function => {}
+                }
+                self.mark_generator();
+                self.compile_expression(value)?;
+                emit!(self, Instruction::GetYieldFromIter);
+                self.emit_load_const(ConstantData::None);
+                self.compile_yield_from_sequence(false)?;
+            }
+            Expr::Name(ExprName { id, .. }) => self.load_name(id.as_str())?,
+            Expr::Lambda(ExprLambda {
+                parameters, body, ..
+            }) => {
+                let default_params = Parameters::default();
+                let params = parameters.as_deref().unwrap_or(&default_params);
+                validate_duplicate_params(params).map_err(|e| self.error(e))?;
+
+                let prev_ctx = self.ctx;
+                let name = "<lambda>".to_owned();
+
+                // Prepare defaults before entering function
+                let defaults: Vec<_> = core::iter::empty()
+                    .chain(&params.posonlyargs)
+                    .chain(&params.args)
+                    .filter_map(|x| x.default.as_deref())
+                    .collect();
+                let have_defaults = !defaults.is_empty();
+
+                if have_defaults {
+                    let size = defaults.len().to_u32();
+                    for element in &defaults {
+                        self.compile_expression(element)?;
+                    }
+                    emit!(self, Instruction::BuildTuple { size });
+                }
+
+                // Prepare keyword-only defaults
+                let mut kw_with_defaults = vec![];
+                for kwonlyarg in &params.kwonlyargs {
+                    if let Some(default) = &kwonlyarg.default {
+                        kw_with_defaults.push((&kwonlyarg.parameter, default));
+                    }
+                }
+
+                let have_kwdefaults = !kw_with_defaults.is_empty();
+                if have_kwdefaults {
+                    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(),
+                        });
+                        self.compile_expression(default)?;
+                    }
+                    emit!(
+                        self,
+                        Instruction::BuildMap {
+                            size: default_kw_count.to_u32(),
+                        }
+                    );
+                }
+
+                self.enter_function(&name, params)?;
+                let mut func_flags = bytecode::MakeFunctionFlags::empty();
+                if have_defaults {
+                    func_flags |= bytecode::MakeFunctionFlags::DEFAULTS;
+                }
+                if have_kwdefaults {
+                    func_flags |= bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS;
+                }
+
+                // Set qualname for lambda
+                self.set_qualname();
+
+                self.ctx = CompileContext {
+                    loop_data: Option::None,
+                    in_class: prev_ctx.in_class,
+                    func: FunctionContext::Function,
+                    // Lambda is never async, so new scope is not async
+                    in_async_scope: false,
+                };
+
+                self.current_code_info()
+                    .metadata
+                    .consts
+                    .insert_full(ConstantData::None);
+
+                self.compile_expression(body)?;
+                self.emit_return_value();
+                let code = self.exit_scope();
+
+                // Create lambda function with closure
+                self.make_closure(code, func_flags)?;
+
+                self.ctx = prev_ctx;
+            }
+            Expr::ListComp(ExprListComp {
+                elt, generators, ..
+            }) => {
+                self.compile_comprehension(
+                    "<listcomp>",
+                    Some(
+                        Instruction::BuildList {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
+                    generators,
+                    &|compiler| {
+                        compiler.compile_comprehension_element(elt)?;
+                        emit!(
+                            compiler,
+                            Instruction::ListAppend {
+                                i: generators.len().to_u32(),
+                            }
+                        );
+                        Ok(())
+                    },
+                    ComprehensionType::List,
+                    Self::contains_await(elt) || Self::generators_contain_await(generators),
+                )?;
+            }
+            Expr::SetComp(ExprSetComp {
+                elt, generators, ..
+            }) => {
+                self.compile_comprehension(
+                    "<setcomp>",
+                    Some(
+                        Instruction::BuildSet {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
+                    generators,
+                    &|compiler| {
+                        compiler.compile_comprehension_element(elt)?;
+                        emit!(
+                            compiler,
+                            Instruction::SetAdd {
+                                i: generators.len().to_u32(),
+                            }
+                        );
+                        Ok(())
+                    },
+                    ComprehensionType::Set,
+                    Self::contains_await(elt) || Self::generators_contain_await(generators),
+                )?;
+            }
+            Expr::DictComp(ExprDictComp {
+                key,
+                value,
+                generators,
+                ..
+            }) => {
+                self.compile_comprehension(
+                    "<dictcomp>",
+                    Some(
+                        Instruction::BuildMap {
+                            size: OpArgMarker::marker(),
+                        }
+                        .into(),
+                    ),
+                    generators,
+                    &|compiler| {
+                        // changed evaluation order for Py38 named expression PEP 572
+                        compiler.compile_expression(key)?;
+                        compiler.compile_expression(value)?;
+
+                        emit!(
+                            compiler,
+                            Instruction::MapAdd {
+                                i: generators.len().to_u32(),
+                            }
+                        );
+
+                        Ok(())
+                    },
+                    ComprehensionType::Dict,
+                    Self::contains_await(key)
+                        || Self::contains_await(value)
+                        || Self::generators_contain_await(generators),
+                )?;
+            }
+            Expr::Generator(ExprGenerator {
+                elt, generators, ..
+            }) => {
+                // Check if element or generators contain async content
+                // This makes the generator expression into an async generator
+                let element_contains_await =
+                    Self::contains_await(elt) || Self::generators_contain_await(generators);
+                self.compile_comprehension(
+                    "<genexpr>",
+                    None,
+                    generators,
+                    &|compiler| {
+                        // Compile the element expression
+                        // Note: if element is an async comprehension, compile_expression
+                        // already handles awaiting it, so we don't need to await again here
+                        compiler.compile_comprehension_element(elt)?;
+
+                        compiler.mark_generator();
+                        // arg=0: direct yield (wrapped for async generators)
+                        emit!(compiler, Instruction::YieldValue { arg: 0 });
+                        emit!(
+                            compiler,
+                            Instruction::Resume {
+                                arg: bytecode::ResumeType::AfterYield as u32
+                            }
+                        );
+                        emit!(compiler, Instruction::PopTop);
+
+                        Ok(())
+                    },
+                    ComprehensionType::Generator,
+                    element_contains_await,
+                )?;
+            }
+            Expr::Starred(ExprStarred { value, .. }) => {
+                if self.in_annotation {
+                    // In annotation context, starred expressions are allowed (PEP 646)
+                    // For now, just compile the inner value without wrapping with Unpack
+                    // This is a temporary solution until we figure out how to properly import typing
+                    self.compile_expression(value)?;
+                } else {
+                    return Err(self.error(CodegenErrorType::InvalidStarExpr));
+                }
+            }
+            Expr::If(ExprIf {
+                test, body, orelse, ..
+            }) => {
+                let else_block = self.new_block();
+                let after_block = self.new_block();
+                self.compile_jump_if(test, false, else_block)?;
+
+                // True case
+                self.compile_expression(body)?;
+                emit!(
+                    self,
+                    PseudoInstruction::Jump {
+                        target: after_block,
+                    }
+                );
+
+                // False case
+                self.switch_to_block(else_block);
+                self.compile_expression(orelse)?;
+
+                // End
+                self.switch_to_block(after_block);
+            }
+
+            Expr::Named(ExprNamed {
+                target,
+                value,
+                node_index: _,
+                range: _,
+            }) => {
+                self.compile_expression(value)?;
+                emit!(self, Instruction::Copy { index: 1_u32 });
+                self.compile_store(target)?;
+            }
+            Expr::FString(fstring) => {
+                self.compile_expr_fstring(fstring)?;
+            }
+            Expr::TString(tstring) => {
+                self.compile_expr_tstring(tstring)?;
+            }
+            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(),
+                    });
+                }
+            }
+            Expr::BytesLiteral(bytes) => {
+                let iter = bytes.value.iter().flat_map(|x| x.iter().copied());
+                let v: Vec<u8> = iter.collect();
+                self.emit_load_const(ConstantData::Bytes { value: v });
+            }
+            Expr::NumberLiteral(number) => match &number.value {
+                Number::Int(int) => {
+                    let value = ruff_int_to_bigint(int).map_err(|e| self.error(e))?;
+                    self.emit_load_const(ConstantData::Integer { value });
+                }
+                Number::Float(float) => {
+                    self.emit_load_const(ConstantData::Float { value: *float });
+                }
+                Number::Complex { real, imag } => {
+                    self.emit_load_const(ConstantData::Complex {
+                        value: Complex::new(*real, *imag),
+                    });
+                }
+            },
+            Expr::BooleanLiteral(b) => {
+                self.emit_load_const(ConstantData::Boolean { value: b.value });
+            }
+            Expr::NoneLiteral(_) => {
+                self.emit_load_const(ConstantData::None);
+            }
+            Expr::EllipsisLiteral(_) => {
+                self.emit_load_const(ConstantData::Ellipsis);
+            }
+            Expr::IpyEscapeCommand(_) => {
+                panic!("unexpected ipy escape command");
+            }
+        }
+        Ok(())
+    }
+
+    fn compile_keywords(&mut self, keywords: &[Keyword]) -> CompileResult<()> {
+        let mut size = 0;
+        let groupby = keywords.iter().chunk_by(|e| e.arg.is_none());
+        for (is_unpacking, sub_keywords) in &groupby {
+            if is_unpacking {
+                for keyword in sub_keywords {
+                    self.compile_expression(&keyword.value)?;
+                    size += 1;
+                }
+            } else {
+                let mut sub_size = 0;
+                for keyword in sub_keywords {
+                    if let Some(name) = &keyword.arg {
+                        self.emit_load_const(ConstantData::Str {
+                            value: name.as_str().into(),
+                        });
+                        self.compile_expression(&keyword.value)?;
+                        sub_size += 1;
+                    }
+                }
+                emit!(self, Instruction::BuildMap { size: sub_size });
+                size += 1;
+            }
+        }
+        if size > 1 {
+            emit!(self, Instruction::BuildMapForCall { size });
+        }
+        Ok(())
+    }
+
+    fn compile_call(&mut self, func: &Expr, args: &Arguments) -> CompileResult<()> {
+        // Method call: obj → LOAD_ATTR_METHOD → [method, self_or_null] → args → CALL
+        // Regular call: func → PUSH_NULL → args → CALL
+        if let Expr::Attribute(ExprAttribute { value, attr, .. }) = &func {
+            // Check for super() method call optimization
+            if let Some(super_type) = self.can_optimize_super_call(value, attr.as_str()) {
+                // super().method() or super(cls, self).method() optimization
+                // Stack: [global_super, class, self] → LOAD_SUPER_METHOD → [method, self]
+                self.load_args_for_super(&super_type)?;
+                let idx = self.name(attr.as_str());
+                match super_type {
+                    SuperCallType::TwoArg { .. } => {
+                        emit!(self, PseudoInstruction::LoadSuperMethod { idx });
+                    }
+                    SuperCallType::ZeroArg => {
+                        emit!(self, PseudoInstruction::LoadZeroSuperMethod { idx });
+                    }
+                }
+                self.compile_call_helper(0, args)?;
+            } else {
+                // Normal method call: compile object, then LOAD_ATTR_METHOD
+                // LOAD_ATTR_METHOD pushes [method, self_or_null] on stack
+                self.compile_expression(value)?;
+                let idx = self.name(attr.as_str());
+                emit!(self, PseudoInstruction::LoadAttrMethod { idx });
+                self.compile_call_helper(0, args)?;
+            }
+        } else {
+            // Regular call: push func, then NULL for self_or_null slot
+            // Stack layout: [func, NULL, args...] - same as method call [func, self, args...]
+            self.compile_expression(func)?;
+            emit!(self, Instruction::PushNull);
+            self.compile_call_helper(0, args)?;
+        }
+        Ok(())
+    }
+
+    /// Compile call arguments and emit the appropriate CALL instruction.
+    /// This is shared between compiler_call and compiler_class.
+    fn compile_call_helper(
+        &mut self,
+        additional_positional: u32,
+        arguments: &Arguments,
+    ) -> CompileResult<()> {
+        let args_count = u32::try_from(arguments.len()).expect("too many arguments");
+        let count = args_count
+            .checked_add(additional_positional)
+            .expect("too many arguments");
+
+        // Normal arguments:
+        let (size, unpack) = self.gather_elements(additional_positional, &arguments.args)?;
+        let has_double_star = arguments.keywords.iter().any(|k| k.arg.is_none());
+
+        for keyword in &arguments.keywords {
+            if let Some(name) = &keyword.arg {
+                self.check_forbidden_name(name.as_str(), NameUsage::Store)?;
+            }
+        }
+
+        if unpack || has_double_star {
+            // Create a tuple with positional args:
+            if unpack {
+                emit!(self, Instruction::BuildTupleFromTuples { size });
+            } else {
+                emit!(self, Instruction::BuildTuple { size });
+            }
+
+            // Create an optional map with kw-args:
+            let has_kwargs = !arguments.keywords.is_empty();
+            if has_kwargs {
+                self.compile_keywords(&arguments.keywords)?;
+            }
+            emit!(self, Instruction::CallFunctionEx { has_kwargs });
+        } else if !arguments.keywords.is_empty() {
+            // No **kwargs in this branch (has_double_star is false),
+            // so all keywords have arg.is_some()
+            let mut kwarg_names = Vec::with_capacity(arguments.keywords.len());
+            for keyword in &arguments.keywords {
+                let name = keyword
+                    .arg
+                    .as_ref()
+                    .expect("has_double_star is false, so arg must be Some");
+                kwarg_names.push(ConstantData::Str {
+                    value: name.as_str().into(),
+                });
+                self.compile_expression(&keyword.value)?;
+            }
+
+            self.emit_load_const(ConstantData::Tuple {
+                elements: kwarg_names,
+            });
+            // nargs = positional args + keyword args
+            let positional = additional_positional
+                .checked_add(u32::try_from(arguments.args.len()).expect("too many positional args"))
+                .expect("too many positional args");
+            let keyword_count =
+                u32::try_from(arguments.keywords.len()).expect("too many keyword args");
+            let nargs = positional
+                .checked_add(keyword_count)
+                .expect("too many arguments");
+            emit!(self, Instruction::CallKw { nargs });
+        } else {
+            emit!(self, Instruction::Call { nargs: count });
+        }
+
+        Ok(())
+    }
+
+    // Given a vector of expr / star expr generate code which gives either
+    // a list of expressions on the stack, or a list of tuples.
+    fn gather_elements(&mut self, before: u32, elements: &[Expr]) -> CompileResult<(u32, bool)> {
+        // First determine if we have starred elements:
+        let has_stars = elements.iter().any(|e| matches!(e, Expr::Starred(_)));
+
+        let size = if has_stars {
+            let mut size = 0;
+            let mut iter = elements.iter().peekable();
+            let mut run_size = before;
+
+            loop {
+                if iter.peek().is_none_or(|e| matches!(e, Expr::Starred(_))) {
+                    emit!(self, Instruction::BuildTuple { size: run_size });
+                    run_size = 0;
+                    size += 1;
+                }
+
+                match iter.next() {
+                    Some(Expr::Starred(ExprStarred { value, .. })) => {
+                        self.compile_expression(value)?;
+                        // We need to collect each unpacked element into a
+                        // tuple, since any side-effects during the conversion
+                        // should be made visible before evaluating remaining
+                        // expressions.
+                        emit!(self, Instruction::BuildTupleFromIter);
+                        size += 1;
+                    }
+                    Some(element) => {
+                        self.compile_expression(element)?;
+                        run_size += 1;
+                    }
+                    None => break,
+                }
+            }
+
+            size
+        } else {
+            for element in elements {
+                self.compile_expression(element)?;
+            }
+            before + elements.len().to_u32()
+        };
+
+        Ok((size, has_stars))
+    }
+
+    fn compile_comprehension_element(&mut self, element: &Expr) -> CompileResult<()> {
+        self.compile_expression(element).map_err(|e| {
+            if let CodegenErrorType::InvalidStarExpr = e.error {
+                self.error(CodegenErrorType::SyntaxError(
+                    "iterable unpacking cannot be used in comprehension".to_owned(),
+                ))
+            } else {
+                e
+            }
+        })
+    }
+
+    fn compile_comprehension(
+        &mut self,
+        name: &str,
+        init_collection: Option<AnyInstruction>,
+        generators: &[Comprehension],
+        compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
+        comprehension_type: ComprehensionType,
+        element_contains_await: bool,
+    ) -> CompileResult<()> {
+        let prev_ctx = self.ctx;
+        let has_an_async_gen = generators.iter().any(|g| g.is_async);
+
+        // Check for async comprehension outside async function (list/set/dict only, not generator expressions)
+        // Use in_async_scope to allow nested async comprehensions inside an async function
+        if comprehension_type != ComprehensionType::Generator
+            && (has_an_async_gen || element_contains_await)
+            && !prev_ctx.in_async_scope
+        {
+            return Err(self.error(CodegenErrorType::InvalidAsyncComprehension));
+        }
+
+        // Check if this comprehension should be inlined (PEP 709)
+        let is_inlined = self.is_inlined_comprehension_context(comprehension_type);
+
+        // async comprehensions are allowed in various contexts:
+        // - list/set/dict comprehensions in async functions (or nested within)
+        // - always for generator expressions
+        let is_async_list_set_dict_comprehension = comprehension_type
+            != ComprehensionType::Generator
+            && (has_an_async_gen || element_contains_await)
+            && prev_ctx.in_async_scope;
+
+        let is_async_generator_comprehension = comprehension_type == ComprehensionType::Generator
+            && (has_an_async_gen || element_contains_await);
+
+        debug_assert!(!(is_async_list_set_dict_comprehension && is_async_generator_comprehension));
+
+        let is_async = is_async_list_set_dict_comprehension || is_async_generator_comprehension;
+
+        // We must have at least one generator:
+        assert!(!generators.is_empty());
+
+        if is_inlined {
+            // PEP 709: Inlined comprehension - compile inline without new scope
+            return self.compile_inlined_comprehension(
+                init_collection,
+                generators,
+                compile_element,
+                has_an_async_gen,
+            );
+        }
+
+        // Non-inlined path: create a new code object (generator expressions, etc.)
+        self.ctx = CompileContext {
+            loop_data: None,
+            in_class: prev_ctx.in_class,
+            func: if is_async {
+                FunctionContext::AsyncFunction
+            } else {
+                FunctionContext::Function
+            },
+            // Inherit in_async_scope from parent - nested async comprehensions are allowed
+            // if we're anywhere inside an async function
+            in_async_scope: prev_ctx.in_async_scope || is_async,
+        };
+
+        let flags = bytecode::CodeFlags::NEWLOCALS | bytecode::CodeFlags::OPTIMIZED;
+        let flags = if is_async {
+            flags | bytecode::CodeFlags::COROUTINE
+        } else {
+            flags
+        };
+
+        // 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();
+        // Create empty object of proper type:
+        if let Some(init_collection) = init_collection {
+            self._emit(init_collection, OpArg(0), BlockIdx::NULL)
+        }
+
+        let mut loop_labels = vec![];
+        for generator in generators {
+            let loop_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));
+            } else {
+                // Evaluate iterated item:
+                self.compile_expression(&generator.iter)?;
+
+                // Get iterator / turn item into an iterator
+                if generator.is_async {
+                    emit!(self, Instruction::GetAIter);
+                } else {
+                    emit!(self, Instruction::GetIter);
+                }
+            }
+
+            loop_labels.push((loop_block, after_block, generator.is_async));
+            self.switch_to_block(loop_block);
+            if generator.is_async {
+                emit!(self, Instruction::GetANext);
+
+                let current_depth = (init_collection.is_some() as u32)
+                    + u32::try_from(loop_labels.len()).unwrap()
+                    + 1;
+                self.push_fblock_with_handler(
+                    FBlockType::AsyncComprehensionGenerator,
+                    loop_block,
+                    after_block,
+                    Some(after_block),
+                    current_depth,
+                    false,
+                )?;
+                self.emit_load_const(ConstantData::None);
+                self.compile_yield_from_sequence(true)?;
+                self.compile_store(&generator.target)?;
+                self.pop_fblock(FBlockType::AsyncComprehensionGenerator);
+            } else {
+                emit!(
+                    self,
+                    Instruction::ForIter {
+                        target: after_block,
+                    }
+                );
+                self.compile_store(&generator.target)?;
+            }
+
+            // Now evaluate the ifs:
+            for if_condition in &generator.ifs {
+                self.compile_jump_if(if_condition, false, loop_block)?
+            }
+        }
+
+        compile_element(self)?;
+
+        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
+
+            self.switch_to_block(after_block);
+            if is_async {
+                emit!(self, Instruction::EndAsyncFor);
+                emit!(self, Instruction::PopTop);
+            }
+        }
+
+        if return_none {
+            self.emit_load_const(ConstantData::None)
+        }
+
+        self.emit_return_value();
+
+        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);
+
+        // Evaluate iterated item:
+        self.compile_expression(&generators[0].iter)?;
+
+        // Get iterator / turn item into an iterator
+        // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
+        if generators[0].is_async {
+            emit!(self, Instruction::GetAIter);
+        } else {
+            emit!(self, Instruction::GetIter);
+        };
+
+        // Call just created <listcomp> function:
+        emit!(self, Instruction::Call { nargs: 1 });
+        if is_async_list_set_dict_comprehension {
+            emit!(self, Instruction::GetAwaitable);
+            self.emit_load_const(ConstantData::None);
+            self.compile_yield_from_sequence(true)?;
+        }
+
+        Ok(())
+    }
+
+    /// Collect variable names from an assignment target expression
+    fn collect_target_names(&self, target: &Expr, names: &mut Vec<String>) {
+        match target {
+            Expr::Name(name) => {
+                let name_str = name.id.to_string();
+                if !names.contains(&name_str) {
+                    names.push(name_str);
+                }
+            }
+            Expr::Tuple(tuple) => {
+                for elt in &tuple.elts {
+                    self.collect_target_names(elt, names);
+                }
+            }
+            Expr::List(list) => {
+                for elt in &list.elts {
+                    self.collect_target_names(elt, names);
+                }
+            }
+            Expr::Starred(starred) => {
+                self.collect_target_names(&starred.value, names);
+            }
+            _ => {
+                // Other targets (attribute, subscript) don't bind local names
+            }
+        }
+    }
+
+    /// Compile an inlined comprehension (PEP 709)
+    /// This generates bytecode inline without creating a new code object
+    fn compile_inlined_comprehension(
+        &mut self,
+        init_collection: Option<AnyInstruction>,
+        generators: &[Comprehension],
+        compile_element: &dyn Fn(&mut Self) -> CompileResult<()>,
+        _has_an_async_gen: bool,
+    ) -> CompileResult<()> {
+        // PEP 709: Consume the comprehension's sub_table (but we won't use it as a separate scope)
+        // We need to consume it to keep sub_tables in sync with AST traversal order.
+        // The symbols are already merged into parent scope by analyze_symbol_table.
+        let _comp_table = self
+            .symbol_table_stack
+            .last_mut()
+            .expect("no current symbol table")
+            .sub_tables
+            .remove(0);
+
+        // Collect local variables that need to be saved/restored
+        // These are variables bound in the comprehension (iteration vars from targets)
+        let mut pushed_locals: Vec<String> = Vec::new();
+        for generator in generators {
+            self.collect_target_names(&generator.target, &mut pushed_locals);
+        }
+
+        // Step 1: Compile the outermost iterator
+        self.compile_expression(&generators[0].iter)?;
+        // Use is_async from the first generator, not has_an_async_gen which covers ALL generators
+        if generators[0].is_async {
+            emit!(self, Instruction::GetAIter);
+        } else {
+            emit!(self, Instruction::GetIter);
+        }
+
+        // Step 2: Save local variables that will be shadowed by the comprehension
+        for name in &pushed_locals {
+            let idx = self.varname(name)?;
+            emit!(self, Instruction::LoadFastAndClear(idx));
+        }
+
+        // Step 3: SWAP iterator to TOS (above saved locals)
+        if !pushed_locals.is_empty() {
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                }
+            );
+        }
+
+        // Step 4: Create the collection (list/set/dict)
+        // For generator expressions, init_collection is None
+        if let Some(init_collection) = init_collection {
+            self._emit(init_collection, OpArg(0), BlockIdx::NULL);
+            // SWAP to get iterator on top
+            emit!(self, Instruction::Swap { index: 2 });
+        }
+
+        // Set up exception handler for cleanup on exception
+        let cleanup_block = self.new_block();
+        let end_block = self.new_block();
+
+        if !pushed_locals.is_empty() {
+            // Calculate stack depth for exception handler
+            // Stack: [saved_locals..., collection?, iterator]
+            let depth = self.handler_stack_depth()
+                + u32::try_from(pushed_locals.len()).unwrap()
+                + init_collection.is_some() as u32
+                + 1;
+            self.push_fblock_with_handler(
+                FBlockType::TryExcept,
+                cleanup_block,
+                end_block,
+                Some(cleanup_block),
+                depth,
+                false,
+            )?;
+        }
+
+        // Step 5: Compile the comprehension loop(s)
+        let mut loop_labels = vec![];
+        for (i, generator) in generators.iter().enumerate() {
+            let loop_block = self.new_block();
+            let after_block = self.new_block();
+
+            if i > 0 {
+                // For nested loops, compile the iterator expression
+                self.compile_expression(&generator.iter)?;
+                if generator.is_async {
+                    emit!(self, Instruction::GetAIter);
+                } else {
+                    emit!(self, Instruction::GetIter);
+                }
+            }
+
+            loop_labels.push((loop_block, after_block, generator.is_async));
+            self.switch_to_block(loop_block);
+
+            if generator.is_async {
+                emit!(self, Instruction::GetANext);
+                self.emit_load_const(ConstantData::None);
+                self.compile_yield_from_sequence(true)?;
+                self.compile_store(&generator.target)?;
+            } else {
+                emit!(
+                    self,
+                    Instruction::ForIter {
+                        target: after_block,
+                    }
+                );
+                self.compile_store(&generator.target)?;
+            }
+
+            // Evaluate the if conditions
+            for if_condition in &generator.ifs {
+                self.compile_jump_if(if_condition, false, loop_block)?;
+            }
+        }
+
+        // Step 6: Compile the element expression and append to collection
+        compile_element(self)?;
+
+        // Step 7: Close all loops
+        for (loop_block, after_block, is_async) in loop_labels.iter().rev().copied() {
+            emit!(self, PseudoInstruction::Jump { target: loop_block });
+            self.switch_to_block(after_block);
+            if is_async {
+                emit!(self, Instruction::EndAsyncFor);
+            }
+            // Pop the iterator
+            emit!(self, Instruction::PopTop);
+        }
+
+        // Step 8: Clean up - restore saved locals
+        if !pushed_locals.is_empty() {
+            self.pop_fblock(FBlockType::TryExcept);
+
+            // Normal path: jump past cleanup
+            emit!(self, PseudoInstruction::Jump { target: end_block });
+
+            // Exception cleanup path
+            self.switch_to_block(cleanup_block);
+            // Stack: [saved_locals..., collection, exception]
+            // Swap to get collection out from under exception
+            emit!(self, Instruction::Swap { index: 2 });
+            emit!(self, Instruction::PopTop); // Pop incomplete collection
+
+            // Restore locals
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                }
+            );
+            for name in pushed_locals.iter().rev() {
+                let idx = self.varname(name)?;
+                emit!(self, Instruction::StoreFast(idx));
+            }
+            // Re-raise the exception
+            emit!(
+                self,
+                Instruction::RaiseVarargs {
+                    kind: bytecode::RaiseKind::ReraiseFromStack
+                }
+            );
+
+            // Normal end path
+            self.switch_to_block(end_block);
+        }
+
+        // SWAP result to TOS (above saved locals)
+        if !pushed_locals.is_empty() {
+            emit!(
+                self,
+                Instruction::Swap {
+                    index: u32::try_from(pushed_locals.len() + 1).unwrap()
+                }
+            );
+        }
+
+        // Restore saved locals
+        for name in pushed_locals.iter().rev() {
+            let idx = self.varname(name)?;
+            emit!(self, Instruction::StoreFast(idx));
+        }
+
+        Ok(())
+    }
+
+    fn compile_future_features(&mut self, features: &[Alias]) -> Result<(), CodegenError> {
+        if let DoneWithFuture::Yes = self.done_with_future_stmts {
+            return Err(self.error(CodegenErrorType::InvalidFuturePlacement));
+        }
+        self.done_with_future_stmts = DoneWithFuture::DoneWithDoc;
+        for feature in features {
+            match feature.name.as_str() {
+                // Python 3 features; we've already implemented them by default
+                "nested_scopes" | "generators" | "division" | "absolute_import"
+                | "with_statement" | "print_function" | "unicode_literals" | "generator_stop" => {}
+                "annotations" => self.future_annotations = true,
+                other => {
+                    return Err(
+                        self.error(CodegenErrorType::InvalidFutureFeature(other.to_owned()))
+                    );
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // Low level helper functions:
+    fn _emit<I: Into<AnyInstruction>>(&mut self, instr: I, arg: OpArg, target: BlockIdx) {
+        let range = self.current_source_range;
+        let source = self.source_file.to_source_code();
+        let location = source.source_location(range.start(), PositionEncoding::Utf8);
+        let end_location = source.source_location(range.end(), PositionEncoding::Utf8);
+        let except_handler = self.current_except_handler();
+        self.current_block().instructions.push(ir::InstructionInfo {
+            instr: instr.into(),
+            arg,
+            target,
+            location,
+            end_location,
+            except_handler,
+        });
+    }
+
+    fn emit_no_arg<I: Into<AnyInstruction>>(&mut self, ins: I) {
+        self._emit(ins, OpArg::null(), BlockIdx::NULL)
+    }
+
+    fn emit_arg<A: OpArgType, T: EmitArg<A>, I: Into<AnyInstruction>>(
+        &mut self,
+        arg: T,
+        f: impl FnOnce(OpArgMarker<A>) -> I,
+    ) {
+        let (op, arg, target) = arg.emit(f);
+        self._emit(op, arg, target)
+    }
+
+    // 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 })
+    }
+
+    fn emit_return_const(&mut self, constant: ConstantData) {
+        let idx = self.arg_constant(constant);
+        self.emit_arg(idx, |idx| Instruction::ReturnConst { idx })
+    }
+
+    fn emit_return_value(&mut self) {
+        if let Some(inst) = self.current_block().instructions.last_mut()
+            && let AnyInstruction::Real(Instruction::LoadConst { idx }) = inst.instr
+        {
+            inst.instr = Instruction::ReturnConst { idx }.into();
+            return;
+        }
+        emit!(self, Instruction::ReturnValue)
+    }
+
+    fn current_code_info(&mut self) -> &mut ir::CodeInfo {
+        self.code_stack.last_mut().expect("no code on stack")
+    }
+
+    /// Compile break or continue statement with proper fblock cleanup.
+    /// compiler_break, compiler_continue
+    /// This handles unwinding through With blocks and exception handlers.
+    fn compile_break_continue(
+        &mut self,
+        range: ruff_text_size::TextRange,
+        is_break: bool,
+    ) -> CompileResult<()> {
+        // unwind_fblock_stack
+        // We need to unwind fblocks and compile cleanup code. For FinallyTry blocks,
+        // we need to compile the finally body inline, but we must temporarily pop
+        // the fblock so that nested break/continue in the finally body don't see it.
+
+        // First, find the loop
+        let code = self.current_code_info();
+        let mut loop_idx = None;
+        let mut is_for_loop = false;
+
+        for i in (0..code.fblock.len()).rev() {
+            match code.fblock[i].fb_type {
+                FBlockType::WhileLoop => {
+                    loop_idx = Some(i);
+                    is_for_loop = false;
+                    break;
+                }
+                FBlockType::ForLoop => {
+                    loop_idx = Some(i);
+                    is_for_loop = true;
+                    break;
+                }
+                FBlockType::ExceptionGroupHandler => {
+                    return Err(
+                        self.error_ranged(CodegenErrorType::BreakContinueReturnInExceptStar, range)
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        let Some(loop_idx) = loop_idx else {
+            if is_break {
+                return Err(self.error_ranged(CodegenErrorType::InvalidBreak, range));
+            } else {
+                return Err(self.error_ranged(CodegenErrorType::InvalidContinue, range));
+            }
+        };
+
+        let loop_block = code.fblock[loop_idx].fb_block;
+        let exit_block = code.fblock[loop_idx].fb_exit;
+
+        // Collect the fblocks we need to unwind through, from top down to (but not including) the loop
+        #[derive(Clone)]
+        enum UnwindAction {
+            With {
+                is_async: bool,
+            },
+            HandlerCleanup,
+            FinallyTry {
+                body: Vec<ruff_python_ast::Stmt>,
+                fblock_idx: usize,
+            },
+            FinallyEnd,
+            PopValue, // Pop return value when continue/break cancels a return
+        }
+        let mut unwind_actions = Vec::new();
+
+        {
+            let code = self.current_code_info();
+            for i in (loop_idx + 1..code.fblock.len()).rev() {
+                match code.fblock[i].fb_type {
+                    FBlockType::With => {
+                        unwind_actions.push(UnwindAction::With { is_async: false });
+                    }
+                    FBlockType::AsyncWith => {
+                        unwind_actions.push(UnwindAction::With { is_async: true });
+                    }
+                    FBlockType::HandlerCleanup => {
+                        unwind_actions.push(UnwindAction::HandlerCleanup);
+                    }
+                    FBlockType::FinallyTry => {
+                        // Need to execute finally body before break/continue
+                        if let FBlockDatum::FinallyBody(ref body) = code.fblock[i].fb_datum {
+                            unwind_actions.push(UnwindAction::FinallyTry {
+                                body: body.clone(),
+                                fblock_idx: i,
+                            });
+                        }
+                    }
+                    FBlockType::FinallyEnd => {
+                        // Inside finally block reached via exception - need to pop exception
+                        unwind_actions.push(UnwindAction::FinallyEnd);
+                    }
+                    FBlockType::PopValue => {
+                        // Pop the return value that was saved on stack
+                        unwind_actions.push(UnwindAction::PopValue);
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        // Emit cleanup for each fblock
+        for action in unwind_actions {
+            match action {
+                UnwindAction::With { is_async } => {
+                    // compiler_call_exit_with_nones
+                    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 });
+
+                    if is_async {
+                        emit!(self, Instruction::GetAwaitable);
+                        self.emit_load_const(ConstantData::None);
+                        self.compile_yield_from_sequence(true)?;
+                    }
+
+                    emit!(self, Instruction::PopTop);
+                }
+                UnwindAction::HandlerCleanup => {
+                    emit!(self, Instruction::PopExcept);
+                }
+                UnwindAction::FinallyTry { body, fblock_idx } => {
+                    // compile finally body inline
+                    // Temporarily pop the FinallyTry fblock so nested break/continue
+                    // in the finally body won't see it again.
+                    let code = self.current_code_info();
+                    let saved_fblock = code.fblock.remove(fblock_idx);
+
+                    self.compile_statements(&body)?;
+
+                    // Restore the fblock (though this break/continue will jump away,
+                    // this keeps the fblock stack consistent for error checking)
+                    let code = self.current_code_info();
+                    code.fblock.insert(fblock_idx, saved_fblock);
+                }
+                UnwindAction::FinallyEnd => {
+                    // Stack when in FinallyEnd: [..., prev_exc, exc]
+                    // Note: No lasti here - it's only pushed for cleanup handler exceptions
+                    // We need to pop: exc, prev_exc (via PopExcept)
+                    emit!(self, Instruction::PopTop); // exc
+                    emit!(self, Instruction::PopExcept); // prev_exc is restored
+                }
+                UnwindAction::PopValue => {
+                    // Pop the return value - continue/break cancels the pending return
+                    emit!(self, Instruction::PopTop);
+                }
+            }
+        }
+
+        // For break in a for loop, pop the iterator
+        if is_break && is_for_loop {
+            emit!(self, Instruction::PopTop);
+        }
+
+        // Jump to target
+        if is_break {
+            emit!(self, Instruction::Break { target: exit_block });
+        } else {
+            emit!(self, Instruction::Continue { target: loop_block });
+        }
+
+        Ok(())
+    }
+
+    /// Calculate the current exception handler stack depth.
+    /// CPython calculates this based on the SETUP_FINALLY/SETUP_CLEANUP stack depth.
+    fn handler_stack_depth(&self) -> u32 {
+        let code = match self.code_stack.last() {
+            Some(c) => c,
+            None => return 0,
+        };
+        let mut depth = 0u32;
+        for fblock in &code.fblock {
+            match fblock.fb_type {
+                FBlockType::ForLoop => depth += 1,
+                FBlockType::With | FBlockType::AsyncWith => depth += 1,
+                // HandlerCleanup does NOT add to stack depth - it only tracks
+                // cleanup code for named exception handlers. The stack item
+                // (prev_exc) is already counted by ExceptionHandler.
+                // FBlockType::HandlerCleanup => depth += 1,
+                // inside exception handler, prev_exc is on stack
+                FBlockType::ExceptionHandler => depth += 1,
+                // ExceptionGroupHandler: inside except* handler path
+                // Stack has [prev_exc, orig, list, rest] - add 4 for these
+                FBlockType::ExceptionGroupHandler => depth += 4,
+                // FinallyEnd: inside finally exception path
+                // Stack has [prev_exc, exc] - add 2 for these (no lasti at this level)
+                FBlockType::FinallyEnd => depth += 2,
+                // PopValue: preserving a return value on stack during inline finally
+                // The return value adds 1 to the stack depth
+                FBlockType::PopValue => depth += 1,
+                _ => {}
+            }
+        }
+        depth
+    }
+
+    fn current_block(&mut self) -> &mut ir::Block {
+        let info = self.current_code_info();
+        &mut info.blocks[info.current_block]
+    }
+
+    fn new_block(&mut self) -> BlockIdx {
+        let code = self.current_code_info();
+        let idx = BlockIdx::new(code.blocks.len().to_u32());
+        code.blocks.push(ir::Block::default());
+        idx
+    }
+
+    fn switch_to_block(&mut self, block: BlockIdx) {
+        let code = self.current_code_info();
+        let prev = code.current_block;
+        assert_ne!(prev, block, "recursive switching {prev:?} -> {block:?}");
+        assert_eq!(
+            code.blocks[block].next,
+            BlockIdx::NULL,
+            "switching {prev:?} -> {block:?} to completed block"
+        );
+        let prev_block = &mut code.blocks[prev.idx()];
+        assert_eq!(
+            u32::from(prev_block.next),
+            u32::MAX,
+            "switching {prev:?} -> {block:?} from block that's already got a next"
+        );
+        prev_block.next = block;
+        code.current_block = block;
+    }
+
+    const fn set_source_range(&mut self, range: TextRange) {
+        self.current_source_range = range;
+    }
+
+    fn get_source_line_number(&mut self) -> OneIndexed {
+        self.source_file
+            .to_source_code()
+            .line_index(self.current_source_range.start())
+    }
+
+    fn mark_generator(&mut self) {
+        self.current_code_info().flags |= bytecode::CodeFlags::GENERATOR
+    }
+
+    /// Whether the expression contains an await expression and
+    /// thus requires the function to be async.
+    ///
+    /// Both:
+    /// ```py
+    /// async with: ...
+    /// async for: ...
+    /// ```
+    /// are statements, so we won't check for them here
+    fn contains_await(expression: &Expr) -> bool {
+        #[derive(Default)]
+        struct AwaitVisitor {
+            found: bool,
+        }
+
+        impl Visitor<'_> for AwaitVisitor {
+            fn visit_expr(&mut self, expr: &Expr) {
+                if self.found {
+                    return;
+                }
+
+                match expr {
+                    Expr::Await(_) => self.found = true,
+                    // Note: We do NOT check for async comprehensions here.
+                    // Async list/set/dict comprehensions are handled by compile_comprehension
+                    // which already awaits the result. A generator expression containing
+                    // an async comprehension as its element does NOT become an async generator,
+                    // because the async comprehension is awaited when evaluating the element.
+                    _ => walk_expr(self, expr),
+                }
+            }
+        }
+
+        let mut visitor = AwaitVisitor::default();
+        visitor.visit_expr(expression);
+        visitor.found
+    }
+
+    /// Check if any of the generators (except the first one's iter) contains an await expression.
+    /// The first generator's iter is evaluated outside the comprehension scope.
+    fn generators_contain_await(generators: &[Comprehension]) -> bool {
+        for (i, generator) in generators.iter().enumerate() {
+            // First generator's iter is evaluated outside the comprehension
+            if i > 0 && Self::contains_await(&generator.iter) {
+                return true;
+            }
+            // Check ifs in all generators
+            for if_expr in &generator.ifs {
+                if Self::contains_await(if_expr) {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    fn compile_expr_fstring(&mut self, fstring: &ExprFString) -> CompileResult<()> {
+        let fstring = &fstring.value;
+        for part in fstring {
+            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 });
+        }
+
+        Ok(())
+    }
+
+    fn compile_fstring_part(&mut self, part: &FStringPart) -> CompileResult<()> {
+        match part {
+            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(),
+                    });
+                } else {
+                    self.emit_load_const(ConstantData::Str {
+                        value: string.value.to_string().into(),
+                    });
+                }
+                Ok(())
+            }
+            FStringPart::FString(fstring) => self.compile_fstring(fstring),
+        }
+    }
+
+    fn compile_fstring(&mut self, fstring: &FString) -> CompileResult<()> {
+        self.compile_fstring_elements(fstring.flags, &fstring.elements)
+    }
+
+    fn compile_fstring_elements(
+        &mut self,
+        flags: FStringFlags,
+        fstring_elements: &InterpolatedStringElements,
+    ) -> CompileResult<()> {
+        let mut element_count = 0;
+        for element in fstring_elements {
+            element_count += 1;
+            match element {
+                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(),
+                        });
+                    } else {
+                        self.emit_load_const(ConstantData::Str {
+                            value: string.value.to_string().into(),
+                        });
+                    }
+                }
+                InterpolatedStringElement::Interpolation(fstring_expr) => {
+                    let mut conversion = match fstring_expr.conversion {
+                        ConversionFlag::None => ConvertValueOparg::None,
+                        ConversionFlag::Str => ConvertValueOparg::Str,
+                        ConversionFlag::Repr => ConvertValueOparg::Repr,
+                        ConversionFlag::Ascii => ConvertValueOparg::Ascii,
+                    };
+
+                    if let Some(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;
+
+                        // If debug text is present, apply repr conversion when no `format_spec` specified.
+                        // See action_helpers.c: fstring_find_expr_replacement
+                        if matches!(
+                            (conversion, &fstring_expr.format_spec),
+                            (ConvertValueOparg::None, None)
+                        ) {
+                            conversion = ConvertValueOparg::Repr;
+                        }
+                    }
+
+                    self.compile_expression(&fstring_expr.expression)?;
+
+                    match conversion {
+                        ConvertValueOparg::None => {}
+                        ConvertValueOparg::Str
+                        | ConvertValueOparg::Repr
+                        | ConvertValueOparg::Ascii => {
+                            emit!(self, Instruction::ConvertValue { oparg: conversion })
+                        }
+                    }
+
+                    match &fstring_expr.format_spec {
+                        Some(format_spec) => {
+                            self.compile_fstring_elements(flags, &format_spec.elements)?;
+
+                            emit!(self, Instruction::FormatWithSpec);
+                        }
+                        None => {
+                            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
+                }
+            );
+        }
+
+        Ok(())
+    }
+
+    fn compile_expr_tstring(&mut self, expr_tstring: &ExprTString) -> CompileResult<()> {
+        // TStringValue can contain multiple TString parts (implicit concatenation)
+        // Each TString part should be compiled and the results merged into a single Template
+        let tstring_value = &expr_tstring.value;
+
+        // Collect all strings and compile all interpolations
+        let mut all_strings: Vec<Wtf8Buf> = Vec::new();
+        let mut current_string = Wtf8Buf::new();
+        let mut interp_count: u32 = 0;
+
+        for tstring in tstring_value.iter() {
+            self.compile_tstring_into(
+                tstring,
+                &mut all_strings,
+                &mut current_string,
+                &mut interp_count,
+            )?;
+        }
+
+        // Add trailing string
+        all_strings.push(std::mem::take(&mut current_string));
+
+        // Now build the Template:
+        // Stack currently has all interpolations from compile_tstring_into calls
+
+        // 1. Build interpolations tuple from the interpolations on the stack
+        emit!(self, Instruction::BuildTuple { size: interp_count });
+
+        // 2. Load all string parts
+        let string_count: u32 = all_strings
+            .len()
+            .try_into()
+            .expect("t-string string count overflowed");
+        for s in &all_strings {
+            self.emit_load_const(ConstantData::Str { value: s.clone() });
+        }
+
+        // 3. Build strings tuple
+        emit!(self, Instruction::BuildTuple { size: string_count });
+
+        // 4. Swap so strings is below interpolations: [interps, strings] -> [strings, interps]
+        emit!(self, Instruction::Swap { index: 2 });
+
+        // 5. Build the Template
+        emit!(self, Instruction::BuildTemplate);
+
+        Ok(())
+    }
+
+    fn compile_tstring_into(
+        &mut self,
+        tstring: &TString,
+        strings: &mut Vec<Wtf8Buf>,
+        current_string: &mut Wtf8Buf,
+        interp_count: &mut u32,
+    ) -> CompileResult<()> {
+        for element in &tstring.elements {
+            match element {
+                InterpolatedStringElement::Literal(lit) => {
+                    // Accumulate literal parts into current_string
+                    current_string.push_str(&lit.value);
+                }
+                InterpolatedStringElement::Interpolation(interp) => {
+                    // Finish current string segment
+                    strings.push(std::mem::take(current_string));
+
+                    // Compile the interpolation value
+                    self.compile_expression(&interp.expression)?;
+
+                    // Load the expression source string
+                    let expr_range = interp.expression.range();
+                    let expr_source = self.source_file.slice(expr_range);
+                    self.emit_load_const(ConstantData::Str {
+                        value: expr_source.to_string().into(),
+                    });
+
+                    // Determine conversion code
+                    let conversion: u32 = match interp.conversion {
+                        ConversionFlag::None => 0,
+                        ConversionFlag::Str => 1,
+                        ConversionFlag::Repr => 2,
+                        ConversionFlag::Ascii => 3,
+                    };
+
+                    // Handle format_spec
+                    let has_format_spec = interp.format_spec.is_some();
+                    if let Some(format_spec) = &interp.format_spec {
+                        // Compile format_spec as a string using fstring element compilation
+                        // Use default FStringFlags since format_spec syntax is independent of t-string flags
+                        self.compile_fstring_elements(
+                            FStringFlags::empty(),
+                            &format_spec.elements,
+                        )?;
+                    }
+
+                    // Emit BUILD_INTERPOLATION
+                    // oparg encoding: (conversion << 2) | has_format_spec
+                    let oparg = (conversion << 2) | (has_format_spec as u32);
+                    emit!(self, Instruction::BuildInterpolation { oparg });
+
+                    *interp_count += 1;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+trait EmitArg<Arg: OpArgType> {
+    fn emit<I: Into<AnyInstruction>>(
+        self,
+        f: impl FnOnce(OpArgMarker<Arg>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx);
+}
+
+impl<T: OpArgType> EmitArg<T> for T {
+    fn emit<I: Into<AnyInstruction>>(
+        self,
+        f: impl FnOnce(OpArgMarker<T>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
+        let (marker, arg) = OpArgMarker::new(self);
+        (f(marker).into(), arg, BlockIdx::NULL)
+    }
+}
+
+impl EmitArg<bytecode::Label> for BlockIdx {
+    fn emit<I: Into<AnyInstruction>>(
+        self,
+        f: impl FnOnce(OpArgMarker<bytecode::Label>) -> I,
+    ) -> (AnyInstruction, OpArg, BlockIdx) {
+        (f(OpArgMarker::marker()).into(), OpArg::null(), self)
+    }
+}
+
+/// Strips leading whitespace from a docstring.
+///
+/// `inspect.cleandoc` is a good reference, but has a few incompatibilities.
+// = _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.
+    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()
+    }
+}
+
+// copied from rustpython_common::str, so we don't have to depend on it just for this function
+fn expandtabs(input: &str, tab_size: usize) -> String {
+    let tab_stop = tab_size;
+    let mut expanded_str = String::with_capacity(input.len());
+    let mut tab_size = tab_stop;
+    let mut col_count = 0usize;
+    for ch in input.chars() {
+        match ch {
+            '\t' => {
+                let num_spaces = tab_size - col_count;
+                col_count += num_spaces;
+                let expand = " ".repeat(num_spaces);
+                expanded_str.push_str(&expand);
+            }
+            '\r' | '\n' => {
+                expanded_str.push(ch);
+                col_count = 0;
+                tab_size = 0;
+            }
+            _ => {
+                expanded_str.push(ch);
+                col_count += 1;
+            }
+        }
+        if col_count >= tab_size {
+            tab_size += tab_stop;
+        }
+    }
+    expanded_str
+}
+
+fn split_doc<'a>(body: &'a [Stmt], opts: &CompileOpts) -> (Option<String>, &'a [Stmt]) {
+    if let Some((Stmt::Expr(expr), body_rest)) = body.split_first() {
+        let doc_comment = match &*expr.value {
+            Expr::StringLiteral(value) => Some(&value.value),
+            // f-strings are not allowed in Python doc comments.
+            Expr::FString(_) => None,
+            _ => None,
+        };
+        if let Some(doc) = doc_comment {
+            return if opts.optimize < 2 {
+                (Some(clean_doc(doc.to_str())), body_rest)
+            } else {
+                (None, body_rest)
+            };
+        }
+    }
+    (None, body)
+}
+
+pub fn ruff_int_to_bigint(int: &Int) -> Result<BigInt, CodegenErrorType> {
+    if let Some(small) = int.as_u64() {
+        Ok(BigInt::from(small))
+    } else {
+        parse_big_integer(int)
+    }
+}
+
+/// Converts a `ruff` ast integer into a `BigInt`.
+/// Unlike small integers, big integers may be stored in one of four possible radix representations.
+fn parse_big_integer(int: &Int) -> Result<BigInt, CodegenErrorType> {
+    // TODO: Improve ruff API
+    // Can we avoid this copy?
+    let s = format!("{int}");
+    let mut s = s.as_str();
+    // See: https://peps.python.org/pep-0515/#literal-grammar
+    let radix = match s.get(0..2) {
+        Some("0b" | "0B") => {
+            s = s.get(2..).unwrap_or(s);
+            2
+        }
+        Some("0o" | "0O") => {
+            s = s.get(2..).unwrap_or(s);
+            8
+        }
+        Some("0x" | "0X") => {
+            s = s.get(2..).unwrap_or(s);
+            16
+        }
+        _ => 10,
+    };
+
+    BigInt::from_str_radix(s, radix).map_err(|e| {
+        CodegenErrorType::SyntaxError(format!(
+            "unparsed integer literal (radix {radix}): {s} ({e})"
+        ))
+    })
+}
+
+// Note: Not a good practice in general. Keep this trait private only for compiler
+trait ToU32 {
+    fn to_u32(self) -> u32;
+}
+
+impl ToU32 for usize {
+    fn to_u32(self) -> u32 {
+        self.try_into().unwrap()
+    }
+}
+
+#[cfg(test)]
+mod ruff_tests {
+    use super::*;
+    use ruff_python_ast::name::Name;
+    use ruff_python_ast::*;
+
+    /// Test if the compiler can correctly identify fstrings containing an `await` expression.
+    #[test]
+    fn test_fstring_contains_await() {
+        let range = TextRange::default();
+        let flags = FStringFlags::empty();
+
+        // f'{x}'
+        let expr_x = Expr::Name(ExprName {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            id: Name::new("x"),
+            ctx: ExprContext::Load,
+        });
+        let not_present = &Expr::FString(ExprFString {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            value: FStringValue::single(FString {
+                node_index: AtomicNodeIndex::NONE,
+                range,
+                elements: vec![InterpolatedStringElement::Interpolation(
+                    InterpolatedElement {
+                        node_index: AtomicNodeIndex::NONE,
+                        range,
+                        expression: Box::new(expr_x),
+                        debug_text: None,
+                        conversion: ConversionFlag::None,
+                        format_spec: None,
+                    },
+                )]
+                .into(),
+                flags,
+            }),
+        });
+        assert!(!Compiler::contains_await(not_present));
+
+        // f'{await x}'
+        let expr_await_x = Expr::Await(ExprAwait {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            value: Box::new(Expr::Name(ExprName {
+                node_index: AtomicNodeIndex::NONE,
+                range,
+                id: Name::new("x"),
+                ctx: ExprContext::Load,
+            })),
+        });
+        let present = &Expr::FString(ExprFString {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            value: FStringValue::single(FString {
+                node_index: AtomicNodeIndex::NONE,
+                range,
+                elements: vec![InterpolatedStringElement::Interpolation(
+                    InterpolatedElement {
+                        node_index: AtomicNodeIndex::NONE,
+                        range,
+                        expression: Box::new(expr_await_x),
+                        debug_text: None,
+                        conversion: ConversionFlag::None,
+                        format_spec: None,
+                    },
+                )]
+                .into(),
+                flags,
+            }),
+        });
+        assert!(Compiler::contains_await(present));
+
+        // f'{x:{await y}}'
+        let expr_x = Expr::Name(ExprName {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            id: Name::new("x"),
+            ctx: ExprContext::Load,
+        });
+        let expr_await_y = Expr::Await(ExprAwait {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            value: Box::new(Expr::Name(ExprName {
+                node_index: AtomicNodeIndex::NONE,
+                range,
+                id: Name::new("y"),
+                ctx: ExprContext::Load,
+            })),
+        });
+        let present = &Expr::FString(ExprFString {
+            node_index: AtomicNodeIndex::NONE,
+            range,
+            value: FStringValue::single(FString {
+                node_index: AtomicNodeIndex::NONE,
+                range,
+                elements: vec![InterpolatedStringElement::Interpolation(
+                    InterpolatedElement {
+                        node_index: AtomicNodeIndex::NONE,
+                        range,
+                        expression: Box::new(expr_x),
+                        debug_text: None,
+                        conversion: ConversionFlag::None,
+                        format_spec: Some(Box::new(InterpolatedStringFormatSpec {
+                            node_index: AtomicNodeIndex::NONE,
+                            range,
+                            elements: vec![InterpolatedStringElement::Interpolation(
+                                InterpolatedElement {
+                                    node_index: AtomicNodeIndex::NONE,
+                                    range,
+                                    expression: Box::new(expr_await_y),
+                                    debug_text: None,
+                                    conversion: ConversionFlag::None,
+                                    format_spec: None,
+                                },
+                            )]
+                            .into(),
+                        })),
+                    },
+                )]
+                .into(),
+                flags,
+            }),
+        });
+        assert!(Compiler::contains_await(present));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rustpython_compiler_core::SourceFileBuilder;
+
+    fn compile_exec(source: &str) -> CodeObject {
+        let opts = CompileOpts::default();
+        let source_file = SourceFileBuilder::new("source_path", source).finish();
+        let parsed = ruff_python_parser::parse(
+            source_file.source_text(),
+            ruff_python_parser::Mode::Module.into(),
+        )
+        .unwrap();
+        let ast = parsed.into_syntax();
+        let ast = match ast {
+            ruff_python_ast::Mod::Module(stmts) => stmts,
+            _ => unreachable!(),
+        };
+        let symbol_table = SymbolTable::scan_program(&ast, source_file.clone())
+            .map_err(|e| e.into_codegen_error(source_file.name().to_owned()))
+            .unwrap();
+        let mut compiler = Compiler::new(opts, source_file, "<module>".to_owned());
+        compiler.compile_program(&ast, symbol_table).unwrap();
+        compiler.exit_scope()
+    }
+
+    macro_rules! assert_dis_snapshot {
+        ($value:expr) => {
+            insta::assert_snapshot!(
+                insta::internals::AutoName,
+                $value.display_expand_code_objects().to_string(),
+                stringify!($value)
+            )
+        };
+    }
+
+    #[test]
+    fn test_if_ors() {
+        assert_dis_snapshot!(compile_exec(
+            "\
+if True or False or False:
+    pass
+"
+        ));
+    }
+
+    #[test]
+    fn test_if_ands() {
+        assert_dis_snapshot!(compile_exec(
+            "\
+if True and False and False:
+    pass
+"
+        ));
+    }
+
+    #[test]
+    fn test_if_mixed() {
+        assert_dis_snapshot!(compile_exec(
+            "\
+if (True and False) or (False and True):
+    pass
+"
+        ));
+    }
+
+    #[test]
+    fn test_nested_double_async_with() {
+        assert_dis_snapshot!(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')
+"
+        ));
+    }
+}
diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
new file mode 100644
index 0000000000..5bd7c7ecaf
--- /dev/null
+++ b/crates/codegen/src/error.rs
@@ -0,0 +1,176 @@
+use alloc::fmt;
+use core::fmt::Display;
+use rustpython_compiler_core::SourceLocation;
+use thiserror::Error;
+
+#[derive(Debug)]
+pub enum PatternUnreachableReason {
+    NameCapture,
+    Wildcard,
+}
+
+impl Display for PatternUnreachableReason {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::NameCapture => write!(f, "name capture"),
+            Self::Wildcard => write!(f, "wildcard"),
+        }
+    }
+}
+
+// pub type CodegenError = rustpython_parser_core::source_code::LocatedError<CodegenErrorType>;
+
+#[derive(Error, Debug)]
+pub struct CodegenError {
+    pub location: Option<SourceLocation>,
+    #[source]
+    pub error: CodegenErrorType,
+    pub source_path: String,
+}
+
+impl fmt::Display for CodegenError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // TODO:
+        self.error.fmt(f)
+    }
+}
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum InternalError {
+    StackOverflow,
+    StackUnderflow,
+    MissingSymbol(String),
+}
+
+impl Display for InternalError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::StackOverflow => write!(f, "stack overflow"),
+            Self::StackUnderflow => write!(f, "stack underflow"),
+            Self::MissingSymbol(s) => write!(
+                f,
+                "The symbol '{s}' must be present in the symbol table, even when it is undefined in python."
+            ),
+        }
+    }
+}
+
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum CodegenErrorType {
+    /// Invalid assignment, cannot store value in target.
+    Assign(&'static str),
+    /// Invalid delete
+    Delete(&'static str),
+    SyntaxError(String),
+    /// Multiple `*` detected
+    MultipleStarArgs,
+    /// Misplaced `*` expression
+    InvalidStarExpr,
+    /// Break statement outside of loop.
+    InvalidBreak,
+    /// Continue statement outside of loop.
+    InvalidContinue,
+    InvalidReturn,
+    InvalidYield,
+    InvalidYieldFrom,
+    InvalidAwait,
+    InvalidAsyncFor,
+    InvalidAsyncWith,
+    InvalidAsyncComprehension,
+    AsyncYieldFrom,
+    AsyncReturnValue,
+    InvalidFuturePlacement,
+    InvalidFutureFeature(String),
+    FunctionImportStar,
+    TooManyStarUnpack,
+    EmptyWithItems,
+    EmptyWithBody,
+    ForbiddenName,
+    DuplicateStore(String),
+    UnreachablePattern(PatternUnreachableReason),
+    RepeatedAttributePattern,
+    ConflictingNameBindPattern,
+    /// break/continue/return inside except* block
+    BreakContinueReturnInExceptStar,
+    NotImplementedYet, // RustPython marker for unimplemented features
+}
+
+impl core::error::Error for CodegenErrorType {}
+
+impl fmt::Display for CodegenErrorType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CodegenErrorType::*;
+        match self {
+            Assign(target) => write!(f, "cannot assign to {target}"),
+            Delete(target) => write!(f, "cannot delete {target}"),
+            SyntaxError(err) => write!(f, "{}", err.as_str()),
+            MultipleStarArgs => {
+                write!(f, "two starred expressions in assignment")
+            }
+            InvalidStarExpr => write!(f, "cannot use starred expression here"),
+            InvalidBreak => write!(f, "'break' outside loop"),
+            InvalidContinue => write!(f, "'continue' outside loop"),
+            InvalidReturn => write!(f, "'return' outside function"),
+            InvalidYield => write!(f, "'yield' outside function"),
+            InvalidYieldFrom => write!(f, "'yield from' outside function"),
+            InvalidAwait => write!(f, "'await' outside async function"),
+            InvalidAsyncFor => write!(f, "'async for' outside async function"),
+            InvalidAsyncWith => write!(f, "'async with' outside async function"),
+            InvalidAsyncComprehension => {
+                write!(
+                    f,
+                    "asynchronous comprehension outside of an asynchronous function"
+                )
+            }
+            AsyncYieldFrom => write!(f, "'yield from' inside async function"),
+            AsyncReturnValue => {
+                write!(f, "'return' with value inside async generator")
+            }
+            InvalidFuturePlacement => write!(
+                f,
+                "from __future__ imports must occur at the beginning of the file"
+            ),
+            InvalidFutureFeature(feat) => {
+                write!(f, "future feature {feat} is not defined")
+            }
+            FunctionImportStar => {
+                write!(f, "import * only allowed at module level")
+            }
+            TooManyStarUnpack => {
+                write!(f, "too many expressions in star-unpacking assignment")
+            }
+            EmptyWithItems => {
+                write!(f, "empty items on With")
+            }
+            EmptyWithBody => {
+                write!(f, "empty body on With")
+            }
+            ForbiddenName => {
+                write!(f, "forbidden attribute name")
+            }
+            DuplicateStore(s) => {
+                write!(f, "duplicate store {s}")
+            }
+            UnreachablePattern(reason) => {
+                write!(f, "{reason} makes remaining patterns unreachable")
+            }
+            RepeatedAttributePattern => {
+                write!(f, "attribute name repeated in class pattern")
+            }
+            ConflictingNameBindPattern => {
+                write!(f, "alternative patterns bind different names")
+            }
+            BreakContinueReturnInExceptStar => {
+                write!(
+                    f,
+                    "'break', 'continue' and 'return' cannot appear in an except* block"
+                )
+            }
+            NotImplementedYet => {
+                write!(f, "RustPython does not implement this feature yet")
+            }
+        }
+    }
+}
diff --git a/crates/codegen/src/ir.rs b/crates/codegen/src/ir.rs
new file mode 100644
index 0000000000..8935f2063c
--- /dev/null
+++ b/crates/codegen/src/ir.rs
@@ -0,0 +1,778 @@
+use core::ops;
+
+use crate::{IndexMap, IndexSet, error::InternalError};
+
+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, encode_load_attr_arg,
+        encode_load_super_attr_arg,
+    },
+    varint::{write_signed_varint, write_varint},
+};
+
+/// Metadata for a code unit
+// = _PyCompile_CodeUnitMetadata
+#[derive(Clone, Debug)]
+pub struct CodeUnitMetadata {
+    pub name: String,                        // u_name (obj_name)
+    pub qualname: Option<String>,            // u_qualname
+    pub consts: IndexSet<ConstantData>,      // u_consts
+    pub names: IndexSet<String>,             // u_names
+    pub varnames: IndexSet<String>,          // u_varnames
+    pub cellvars: IndexSet<String>,          // u_cellvars
+    pub freevars: IndexSet<String>,          // u_freevars
+    pub fast_hidden: IndexMap<String, bool>, // u_fast_hidden
+    pub argcount: u32,                       // u_argcount
+    pub posonlyargcount: u32,                // u_posonlyargcount
+    pub kwonlyargcount: u32,                 // u_kwonlyargcount
+    pub firstlineno: OneIndexed,             // u_firstlineno
+}
+// use rustpython_parser_core::source_code::{LineNumber, SourceLocation};
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct BlockIdx(u32);
+
+impl BlockIdx {
+    pub const NULL: Self = Self::new(u32::MAX);
+
+    /// Creates a new instance of [`BlockIdx`] from a [`u32`].
+    #[must_use]
+    pub const fn new(value: u32) -> Self {
+        Self(value)
+    }
+
+    /// Returns the inner value as a [`usize`].
+    #[must_use]
+    pub const fn idx(self) -> usize {
+        self.0 as usize
+    }
+}
+
+impl From<BlockIdx> for u32 {
+    fn from(block_idx: BlockIdx) -> Self {
+        block_idx.0
+    }
+}
+
+impl ops::Index<BlockIdx> for [Block] {
+    type Output = Block;
+
+    fn index(&self, idx: BlockIdx) -> &Block {
+        &self[idx.idx()]
+    }
+}
+
+impl ops::IndexMut<BlockIdx> for [Block] {
+    fn index_mut(&mut self, idx: BlockIdx) -> &mut Block {
+        &mut self[idx.idx()]
+    }
+}
+
+impl ops::Index<BlockIdx> for Vec<Block> {
+    type Output = Block;
+
+    fn index(&self, idx: BlockIdx) -> &Block {
+        &self[idx.idx()]
+    }
+}
+
+impl ops::IndexMut<BlockIdx> for Vec<Block> {
+    fn index_mut(&mut self, idx: BlockIdx) -> &mut Block {
+        &mut self[idx.idx()]
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct InstructionInfo {
+    pub instr: AnyInstruction,
+    pub arg: OpArg,
+    pub target: BlockIdx,
+    pub location: SourceLocation,
+    pub end_location: SourceLocation,
+    pub except_handler: Option<ExceptHandlerInfo>,
+}
+
+/// Exception handler information for an instruction
+#[derive(Debug, Clone)]
+pub struct ExceptHandlerInfo {
+    /// Block to jump to when exception occurs
+    pub handler_block: BlockIdx,
+    /// Stack depth at handler entry
+    pub stack_depth: u32,
+    /// Whether to push lasti before exception
+    pub preserve_lasti: bool,
+}
+
+// spell-checker:ignore petgraph
+// TODO: look into using petgraph for handling blocks and stuff? it's heavier than this, but it
+// might enable more analysis/optimizations
+#[derive(Debug)]
+pub struct Block {
+    pub instructions: Vec<InstructionInfo>,
+    pub next: BlockIdx,
+}
+
+impl Default for Block {
+    fn default() -> Self {
+        Self {
+            instructions: Vec::new(),
+            next: BlockIdx::NULL,
+        }
+    }
+}
+
+pub struct CodeInfo {
+    pub flags: CodeFlags,
+    pub source_path: String,
+    pub private: Option<String>, // For private name mangling, mostly for class
+
+    pub blocks: Vec<Block>,
+    pub current_block: BlockIdx,
+
+    pub metadata: CodeUnitMetadata,
+
+    // For class scopes: attributes accessed via self.X
+    pub static_attributes: Option<IndexSet<String>>,
+
+    // True if compiling an inlined comprehension
+    pub in_inlined_comp: bool,
+
+    // Block stack for tracking nested control structures
+    pub fblock: Vec<crate::compile::FBlockInfo>,
+
+    // Reference to the symbol table for this scope
+    pub symbol_table_index: usize,
+}
+
+impl CodeInfo {
+    pub fn finalize_code(
+        mut self,
+        opts: &crate::compile::CompileOpts,
+    ) -> crate::InternalResult<CodeObject> {
+        if opts.optimize > 0 {
+            self.dce();
+        }
+
+        let max_stackdepth = self.max_stackdepth()?;
+        let cell2arg = self.cell2arg();
+
+        let Self {
+            flags,
+            source_path,
+            private: _, // private is only used during compilation
+
+            mut blocks,
+            current_block: _,
+            metadata,
+            static_attributes: _,
+            in_inlined_comp: _,
+            fblock: _,
+            symbol_table_index: _,
+        } = self;
+
+        let CodeUnitMetadata {
+            name: obj_name,
+            qualname,
+            consts: constants,
+            names: name_cache,
+            varnames: varname_cache,
+            cellvars: cellvar_cache,
+            freevars: freevar_cache,
+            fast_hidden: _,
+            argcount: arg_count,
+            posonlyargcount: posonlyarg_count,
+            kwonlyargcount: kwonlyarg_count,
+            firstlineno: first_line_number,
+        } = metadata;
+
+        let mut instructions = Vec::new();
+        let mut locations = Vec::new();
+
+        // convert_pseudo_ops: instructions before the main loop
+        for block in blocks
+            .iter_mut()
+            .filter(|b| b.next != BlockIdx::NULL || !b.instructions.is_empty())
+        {
+            for info in &mut block.instructions {
+                // Special case for:
+                // - `Instruction::LoadAttr`
+                // - `Instruction::LoadSuperAttr`
+
+                if let Some(instr) = info.instr.real() {
+                    match instr {
+                        // LOAD_ATTR → encode with method flag=0
+                        Instruction::LoadAttr { idx } => {
+                            let encoded = encode_load_attr_arg(idx.get(info.arg), false);
+                            info.arg = OpArg(encoded);
+                            info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
+                        }
+                        // LOAD_SUPER_ATTR → encode with flags=0b10 (method=0, class=1)
+                        Instruction::LoadSuperAttr { arg: idx } => {
+                            let encoded =
+                                encode_load_super_attr_arg(idx.get(info.arg), false, true);
+                            info.arg = OpArg(encoded);
+                            info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                        }
+                        _ => {}
+                    }
+
+                    continue;
+                }
+
+                let instr = info.instr.expect_pseudo();
+
+                match instr {
+                    // LOAD_ATTR_METHOD pseudo → LOAD_ATTR (with method flag=1)
+                    PseudoInstruction::LoadAttrMethod { idx } => {
+                        let encoded = encode_load_attr_arg(idx.get(info.arg), true);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadAttr { idx: Arg::marker() }.into();
+                    }
+                    // POP_BLOCK pseudo → NOP
+                    PseudoInstruction::PopBlock => {
+                        info.instr = Instruction::Nop.into();
+                    }
+                    // LOAD_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b11: method=1, class=1)
+                    PseudoInstruction::LoadSuperMethod { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, true);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                    }
+                    // LOAD_ZERO_SUPER_ATTR pseudo → LOAD_SUPER_ATTR (flags=0b00: method=0, class=0)
+                    PseudoInstruction::LoadZeroSuperAttr { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), false, false);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                    }
+                    // LOAD_ZERO_SUPER_METHOD pseudo → LOAD_SUPER_ATTR (flags=0b01: method=1, class=0)
+                    PseudoInstruction::LoadZeroSuperMethod { idx } => {
+                        let encoded = encode_load_super_attr_arg(idx.get(info.arg), true, false);
+                        info.arg = OpArg(encoded);
+                        info.instr = Instruction::LoadSuperAttr { arg: Arg::marker() }.into();
+                    }
+                    PseudoInstruction::Jump { .. } => {
+                        // PseudoInstruction::Jump instructions are handled later
+                    }
+                    PseudoInstruction::JumpNoInterrupt { .. }
+                    | PseudoInstruction::Reserved258
+                    | PseudoInstruction::SetupCleanup
+                    | PseudoInstruction::SetupFinally
+                    | PseudoInstruction::SetupWith
+                    | PseudoInstruction::StoreFastMaybeNull => {
+                        unimplemented!("Got a placeholder pseudo instruction ({instr:?})")
+                    }
+                }
+            }
+        }
+
+        let mut block_to_offset = vec![Label(0); blocks.len()];
+        // block_to_index: maps block idx to instruction index (for exception table)
+        // This is the index into the final instructions array, including EXTENDED_ARG
+        let mut block_to_index = vec![0u32; blocks.len()];
+        loop {
+            let mut num_instructions = 0;
+            for (idx, block) in iter_blocks(&blocks) {
+                block_to_offset[idx.idx()] = Label(num_instructions as u32);
+                // block_to_index uses the same value as block_to_offset but as u32
+                // because lasti in frame.rs is the index into instructions array
+                // and instructions array index == byte offset (each instruction is 1 CodeUnit)
+                block_to_index[idx.idx()] = num_instructions as u32;
+                for instr in &block.instructions {
+                    num_instructions += instr.arg.instr_size();
+                }
+            }
+
+            instructions.reserve_exact(num_instructions);
+            locations.reserve_exact(num_instructions);
+
+            let mut recompile_extended_arg = 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;
+                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;
+                    }
+
+                    // 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 {
+                                Instruction::JumpBackward {
+                                    target: Arg::marker(),
+                                }
+                            }
+                        }
+                        other => other.expect_real(),
+                    };
+
+                    let (extras, lo_arg) = info.arg.split();
+                    locations.extend(core::iter::repeat_n(
+                        (info.location, info.end_location),
+                        info.arg.instr_size(),
+                    ));
+                    instructions.extend(
+                        extras
+                            .map(|byte| CodeUnit::new(Instruction::ExtendedArg, byte))
+                            .chain([CodeUnit { op, arg: lo_arg }]),
+                    );
+                    current_offset += info.arg.instr_size() as u32;
+                }
+                next_block = block.next;
+            }
+
+            if !recompile_extended_arg {
+                break;
+            }
+
+            instructions.clear();
+            locations.clear()
+        }
+
+        // Generate linetable from locations
+        let linetable = generate_linetable(
+            &locations,
+            first_line_number.get() as i32,
+            opts.debug_ranges,
+        );
+
+        // Generate exception table before moving source_path
+        let exceptiontable = generate_exception_table(&blocks, &block_to_index);
+
+        Ok(CodeObject {
+            flags,
+            posonlyarg_count,
+            arg_count,
+            kwonlyarg_count,
+            source_path,
+            first_line_number: Some(first_line_number),
+            obj_name: obj_name.clone(),
+            qualname: qualname.unwrap_or(obj_name),
+
+            max_stackdepth,
+            instructions: CodeUnits::from(instructions),
+            locations: locations.into_boxed_slice(),
+            constants: constants.into_iter().collect(),
+            names: name_cache.into_iter().collect(),
+            varnames: varname_cache.into_iter().collect(),
+            cellvars: cellvar_cache.into_iter().collect(),
+            freevars: freevar_cache.into_iter().collect(),
+            cell2arg,
+            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) {
+        for block in &mut self.blocks {
+            let mut last_instr = None;
+            for (i, ins) in block.instructions.iter().enumerate() {
+                if ins.instr.unconditional_branch() {
+                    last_instr = Some(i);
+                    break;
+                }
+            }
+            if let Some(i) = last_instr {
+                block.instructions.truncate(i + 1);
+            }
+        }
+    }
+
+    fn max_stackdepth(&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));
+        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 {
+                eprintln!("===BLOCK {}===", block_idx.0);
+            }
+            let block = &self.blocks[block_idx];
+            for ins in &block.instructions {
+                let instr = &ins.instr;
+                let effect = instr.stack_effect(ins.arg, false);
+                if DEBUG {
+                    let display_arg = if ins.target == BlockIdx::NULL {
+                        ins.arg
+                    } else {
+                        OpArg(ins.target.0)
+                    };
+                    let instr_display = instr.display(display_arg, self);
+                    eprint!("{instr_display}: {depth} {effect:+} => ");
+                }
+                let new_depth = depth.checked_add_signed(effect).ok_or({
+                    if effect < 0 {
+                        InternalError::StackUnderflow
+                    } else {
+                        InternalError::StackOverflow
+                    }
+                })?;
+                if DEBUG {
+                    eprintln!("{new_depth}");
+                }
+                if new_depth > maxdepth {
+                    maxdepth = new_depth
+                }
+                // Process target blocks for branching instructions
+                if ins.target != BlockIdx::NULL {
+                    let effect = instr.stack_effect(ins.arg, true);
+                    let target_depth = depth.checked_add_signed(effect).ok_or({
+                        if effect < 0 {
+                            InternalError::StackUnderflow
+                        } else {
+                            InternalError::StackOverflow
+                        }
+                    })?;
+                    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,
+                        handler.handler_block,
+                        handler_depth,
+                    );
+                }
+                depth = new_depth;
+                if instr.unconditional_branch() {
+                    continue 'process_blocks;
+                }
+            }
+            // Only push next block if it's not NULL
+            if block.next != BlockIdx::NULL {
+                stackdepth_push(&mut stack, &mut start_depths, block.next, depth);
+            }
+        }
+        if DEBUG {
+            eprintln!("DONE: {maxdepth}");
+        }
+        Ok(maxdepth)
+    }
+}
+
+impl InstrDisplayContext for CodeInfo {
+    type Constant = ConstantData;
+    fn get_constant(&self, i: usize) -> &ConstantData {
+        &self.metadata.consts[i]
+    }
+    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_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 stackdepth_push(
+    stack: &mut Vec<BlockIdx>,
+    start_depths: &mut [u32],
+    target: BlockIdx,
+    depth: u32,
+) {
+    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);
+    }
+}
+
+fn iter_blocks(blocks: &[Block]) -> impl Iterator<Item = (BlockIdx, &Block)> + '_ {
+    let mut next = BlockIdx(0);
+    core::iter::from_fn(move || {
+        if next == BlockIdx::NULL {
+            return None;
+        }
+        let (idx, b) = (next, &blocks[next]);
+        next = b.next;
+        Some((idx, b))
+    })
+}
+
+/// Generate Python 3.11+ format linetable from source locations
+fn generate_linetable(
+    locations: &[(SourceLocation, SourceLocation)],
+    first_line: i32,
+    debug_ranges: bool,
+) -> Box<[u8]> {
+    if locations.is_empty() {
+        return Box::new([]);
+    }
+
+    let mut linetable = Vec::new();
+    // Initialize prev_line to first_line
+    // The first entry's delta is relative to co_firstlineno
+    let mut prev_line = first_line;
+    let mut i = 0;
+
+    while i < locations.len() {
+        let (loc, end_loc) = &locations[i];
+
+        // Count consecutive instructions with the same location
+        let mut length = 1;
+        while i + length < locations.len() && locations[i + length] == locations[i] {
+            length += 1;
+        }
+
+        // Process in chunks of up to 8 instructions
+        while length > 0 {
+            let entry_length = length.min(8);
+
+            // Get line information
+            let line = loc.line.get() as i32;
+            let end_line = end_loc.line.get() as i32;
+            let line_delta = line - prev_line;
+            let end_line_delta = end_line - line;
+
+            // When debug_ranges is disabled, only emit line info (NoColumns format)
+            if !debug_ranges {
+                // NoColumns format (code 13): line info only, no column data
+                linetable.push(
+                    0x80 | ((PyCodeLocationInfoKind::NoColumns as u8) << 3)
+                        | ((entry_length - 1) as u8),
+                );
+                write_signed_varint(&mut linetable, line_delta);
+
+                prev_line = line;
+                length -= entry_length;
+                i += entry_length;
+                continue;
+            }
+
+            // Get column information (only when debug_ranges is enabled)
+            let col = loc.character_offset.to_zero_indexed() as i32;
+            let end_col = end_loc.character_offset.to_zero_indexed() as i32;
+
+            // Choose the appropriate encoding based on line delta and column info
+            if line_delta == 0 && end_line_delta == 0 {
+                if col < 80 && end_col - col < 16 && end_col >= col {
+                    // Short form (codes 0-9) for common cases
+                    let code = (col / 8).min(9) as u8; // Short0 to Short9
+                    linetable.push(0x80 | (code << 3) | ((entry_length - 1) as u8));
+                    let col_byte = (((col % 8) as u8) << 4) | ((end_col - col) as u8 & 0xf);
+                    linetable.push(col_byte);
+                } else if col < 128 && end_col < 128 {
+                    // One-line form (code 10) for same line
+                    linetable.push(
+                        0x80 | ((PyCodeLocationInfoKind::OneLine0 as u8) << 3)
+                            | ((entry_length - 1) as u8),
+                    );
+                    linetable.push(col as u8);
+                    linetable.push(end_col as u8);
+                } else {
+                    // Long form for columns >= 128
+                    linetable.push(
+                        0x80 | ((PyCodeLocationInfoKind::Long as u8) << 3)
+                            | ((entry_length - 1) as u8),
+                    );
+                    write_signed_varint(&mut linetable, 0); // line_delta = 0
+                    write_varint(&mut linetable, 0); // end_line delta = 0
+                    write_varint(&mut linetable, (col as u32) + 1);
+                    write_varint(&mut linetable, (end_col as u32) + 1);
+                }
+            } else if line_delta > 0 && line_delta < 3 && end_line_delta == 0 {
+                // One-line form (codes 11-12) for line deltas 1-2
+                if col < 128 && end_col < 128 {
+                    let code = (PyCodeLocationInfoKind::OneLine0 as u8) + (line_delta as u8);
+                    linetable.push(0x80 | (code << 3) | ((entry_length - 1) as u8));
+                    linetable.push(col as u8);
+                    linetable.push(end_col as u8);
+                } else {
+                    // Long form for columns >= 128
+                    linetable.push(
+                        0x80 | ((PyCodeLocationInfoKind::Long as u8) << 3)
+                            | ((entry_length - 1) as u8),
+                    );
+                    write_signed_varint(&mut linetable, line_delta);
+                    write_varint(&mut linetable, 0); // end_line delta = 0
+                    write_varint(&mut linetable, (col as u32) + 1);
+                    write_varint(&mut linetable, (end_col as u32) + 1);
+                }
+            } else {
+                // Long form (code 14) for all other cases
+                // Handles: line_delta < 0, line_delta >= 3, multi-line spans, or columns >= 128
+                linetable.push(
+                    0x80 | ((PyCodeLocationInfoKind::Long as u8) << 3) | ((entry_length - 1) as u8),
+                );
+                write_signed_varint(&mut linetable, line_delta);
+                write_varint(&mut linetable, end_line_delta as u32);
+                write_varint(&mut linetable, (col as u32) + 1);
+                write_varint(&mut linetable, (end_col as u32) + 1);
+            }
+
+            prev_line = line;
+            length -= entry_length;
+            i += entry_length;
+        }
+    }
+
+    linetable.into_boxed_slice()
+}
+
+/// Generate Python 3.11+ exception table from instruction handler info
+fn generate_exception_table(blocks: &[Block], block_to_index: &[u32]) -> Box<[u8]> {
+    let mut entries: Vec<ExceptionTableEntry> = Vec::new();
+    let mut current_entry: Option<(ExceptHandlerInfo, u32)> = None; // (handler_info, start_index)
+    let mut instr_index = 0u32;
+
+    // Iterate through all instructions in block order
+    // instr_index is the index into the final instructions array (including EXTENDED_ARG)
+    // This matches how frame.rs uses lasti
+    for (_, block) in iter_blocks(blocks) {
+        for instr in &block.instructions {
+            // instr_size includes EXTENDED_ARG instructions
+            let instr_size = instr.arg.instr_size() as u32;
+
+            match (&current_entry, &instr.except_handler) {
+                // No current entry, no handler - nothing to do
+                (None, None) => {}
+
+                // No current entry, handler starts - begin new entry
+                (None, Some(handler)) => {
+                    current_entry = Some((handler.clone(), instr_index));
+                }
+
+                // Current entry exists, same handler - continue
+                (Some((curr_handler, _)), Some(handler))
+                    if curr_handler.handler_block == handler.handler_block
+                        && curr_handler.stack_depth == handler.stack_depth
+                        && curr_handler.preserve_lasti == handler.preserve_lasti => {}
+
+                // Current entry exists, different handler - finish current, start new
+                (Some((curr_handler, start)), Some(handler)) => {
+                    let target_index = block_to_index[curr_handler.handler_block.idx()];
+                    entries.push(ExceptionTableEntry::new(
+                        *start,
+                        instr_index,
+                        target_index,
+                        curr_handler.stack_depth as u16,
+                        curr_handler.preserve_lasti,
+                    ));
+                    current_entry = Some((handler.clone(), instr_index));
+                }
+
+                // Current entry exists, no handler - finish current entry
+                (Some((curr_handler, start)), None) => {
+                    let target_index = block_to_index[curr_handler.handler_block.idx()];
+                    entries.push(ExceptionTableEntry::new(
+                        *start,
+                        instr_index,
+                        target_index,
+                        curr_handler.stack_depth as u16,
+                        curr_handler.preserve_lasti,
+                    ));
+                    current_entry = None;
+                }
+            }
+
+            instr_index += instr_size; // Account for EXTENDED_ARG instructions
+        }
+    }
+
+    // Finish any remaining entry
+    if let Some((curr_handler, start)) = current_entry {
+        let target_index = block_to_index[curr_handler.handler_block.idx()];
+        entries.push(ExceptionTableEntry::new(
+            start,
+            instr_index,
+            target_index,
+            curr_handler.stack_depth as u16,
+            curr_handler.preserve_lasti,
+        ));
+    }
+
+    encode_exception_table(&entries)
+}
diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs
new file mode 100644
index 0000000000..34d3870ae9
--- /dev/null
+++ b/crates/codegen/src/lib.rs
@@ -0,0 +1,69 @@
+//! Compile a Python AST or source code into bytecode consumable by RustPython.
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
+#![doc(html_root_url = "https://docs.rs/rustpython-compiler/")]
+
+#[macro_use]
+extern crate log;
+
+extern crate alloc;
+
+type IndexMap<K, V> = indexmap::IndexMap<K, V, ahash::RandomState>;
+type IndexSet<T> = indexmap::IndexSet<T, ahash::RandomState>;
+
+pub mod compile;
+pub mod error;
+pub mod ir;
+mod string_parser;
+pub mod symboltable;
+mod unparse;
+
+pub use compile::CompileOpts;
+use ruff_python_ast::Expr;
+
+pub(crate) use compile::InternalResult;
+
+pub trait ToPythonName {
+    /// Returns a short name for the node suitable for use in error messages.
+    fn python_name(&self) -> &'static str;
+}
+
+impl ToPythonName for Expr {
+    fn python_name(&self) -> &'static str {
+        match self {
+            Self::BoolOp { .. } | Self::BinOp { .. } | Self::UnaryOp { .. } => "operator",
+            Self::Subscript { .. } => "subscript",
+            Self::Await { .. } => "await expression",
+            Self::Yield { .. } | Self::YieldFrom { .. } => "yield expression",
+            Self::Compare { .. } => "comparison",
+            Self::Attribute { .. } => "attribute",
+            Self::Call { .. } => "function call",
+            Self::BooleanLiteral(b) => {
+                if b.value {
+                    "True"
+                } else {
+                    "False"
+                }
+            }
+            Self::EllipsisLiteral(_) => "ellipsis",
+            Self::NoneLiteral(_) => "None",
+            Self::NumberLiteral(_) | Self::BytesLiteral(_) | Self::StringLiteral(_) => "literal",
+            Self::Tuple(_) => "tuple",
+            Self::List { .. } => "list",
+            Self::Dict { .. } => "dict display",
+            Self::Set { .. } => "set display",
+            Self::ListComp { .. } => "list comprehension",
+            Self::DictComp { .. } => "dict comprehension",
+            Self::SetComp { .. } => "set comprehension",
+            Self::Generator { .. } => "generator expression",
+            Self::Starred { .. } => "starred",
+            Self::Slice { .. } => "slice",
+            Self::FString { .. } => "f-string expression",
+            Self::TString { .. } => "t-string expression",
+            Self::Name { .. } => "name",
+            Self::Lambda { .. } => "lambda",
+            Self::If { .. } => "conditional expression",
+            Self::Named { .. } => "named expression",
+            Self::IpyEscapeCommand(_) => todo!(),
+        }
+    }
+}
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
new file mode 100644
index 0000000000..4c9c29887e
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ands.snap
@@ -0,0 +1,12 @@
+---
+source: crates/codegen/src/compile.rs
+expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
+---
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_FALSE    (6)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_FALSE    (6)
+              4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (6)
+
+  2     >>    6 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
new file mode 100644
index 0000000000..a93479df96
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_mixed.snap
@@ -0,0 +1,14 @@
+---
+source: crates/codegen/src/compile.rs
+expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
+---
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_FALSE    (4)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_TRUE     (8)
+        >>    4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (8)
+              6 LOAD_CONST           (True)
+              7 POP_JUMP_IF_FALSE    (8)
+
+  2     >>    8 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
new file mode 100644
index 0000000000..37a862cc65
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__if_ors.snap
@@ -0,0 +1,12 @@
+---
+source: crates/codegen/src/compile.rs
+expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
+---
+  1           0 LOAD_CONST           (True)
+              1 POP_JUMP_IF_TRUE     (6)
+              2 LOAD_CONST           (False)
+              3 POP_JUMP_IF_TRUE     (6)
+              4 LOAD_CONST           (False)
+              5 POP_JUMP_IF_FALSE    (6)
+
+  2     >>    6 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
new file mode 100644
index 0000000000..c4d2ed8379
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_codegen__compile__tests__nested_double_async_with.snap
@@ -0,0 +1,147 @@
+---
+source: crates/codegen/src/compile.rs
+expression: "compile_exec(\"\\\nasync def test():\n    for stop_exc in (StopIteration('spam'), StopAsyncIteration('ham')):\n        with self.subTest(type=type(stop_exc)):\n            try:\n                async with egg():\n                    raise stop_exc\n            except Exception as ex:\n                self.assertIs(ex, stop_exc)\n            else:\n                self.fail(f'{stop_exc} was suppressed')\n\")"
+---
+  3           0 LOAD_CONST           (<code object test at ??? file "source_path", line 1>):  1               0 RESUME               (0)
+
+  2               1 LOAD_GLOBAL          (0, StopIteration)
+                  2 PUSH_NULL
+                  3 LOAD_CONST           ("spam")
+                  4 CALL                 (1)
+                  5 LOAD_GLOBAL          (1, StopAsyncIteration)
+                  6 PUSH_NULL
+                  7 LOAD_CONST           ("ham")
+                  8 CALL                 (1)
+                  9 BUILD_TUPLE          (2)
+                 10 GET_ITER
+            >>   11 FOR_ITER             (129)
+                 12 STORE_FAST           (0, stop_exc)
+
+  3              13 LOAD_GLOBAL          (2, self)
+                 14 LOAD_ATTR            (7, subTest, method=true)
+                 15 LOAD_GLOBAL          (4, type)
+                 16 PUSH_NULL
+                 17 LOAD_FAST            (0, stop_exc)
+                 18 CALL                 (1)
+                 19 LOAD_CONST           (("type"))
+                 20 CALL_KW              (1)
+                 21 BEFORE_WITH
+                 22 POP_TOP
+
+  5              23 LOAD_GLOBAL          (5, egg)
+                 24 PUSH_NULL
+                 25 CALL                 (0)
+                 26 BEFORE_ASYNC_WITH
+                 27 GET_AWAITABLE
+                 28 LOAD_CONST           (None)
+            >>   29 SEND                 (34)
+                 30 YIELD_VALUE          (1)
+                 31 RESUME               (3)
+                 32 JUMP_BACKWARD        (29)
+                 33 CLEANUP_THROW
+            >>   34 END_SEND
+                 35 POP_TOP
+
+  6              36 LOAD_FAST            (0, stop_exc)
+                 37 RAISE_VARARGS        (Raise)
+
+  5              38 PUSH_NULL
+                 39 LOAD_CONST           (None)
+                 40 LOAD_CONST           (None)
+                 41 LOAD_CONST           (None)
+                 42 CALL                 (3)
+                 43 GET_AWAITABLE
+                 44 LOAD_CONST           (None)
+            >>   45 SEND                 (50)
+                 46 YIELD_VALUE          (1)
+                 47 RESUME               (3)
+                 48 JUMP_BACKWARD        (45)
+                 49 CLEANUP_THROW
+            >>   50 END_SEND
+                 51 POP_TOP
+                 52 JUMP_FORWARD         (74)
+                 53 PUSH_EXC_INFO
+                 54 WITH_EXCEPT_START
+                 55 GET_AWAITABLE
+                 56 LOAD_CONST           (None)
+            >>   57 SEND                 (62)
+                 58 YIELD_VALUE          (1)
+                 59 RESUME               (3)
+                 60 JUMP_BACKWARD        (57)
+                 61 CLEANUP_THROW
+            >>   62 END_SEND
+                 63 TO_BOOL
+                 64 POP_JUMP_IF_TRUE     (66)
+                 65 RERAISE              (2)
+            >>   66 POP_TOP
+                 67 POP_EXCEPT
+                 68 POP_TOP
+                 69 POP_TOP
+                 70 JUMP_FORWARD         (74)
+                 71 COPY                 (3)
+                 72 POP_EXCEPT
+                 73 RERAISE              (1)
+            >>   74 JUMP_FORWARD         (100)
+                 75 PUSH_EXC_INFO
+                 76 COPY                 (1)
+
+  7              77 LOAD_GLOBAL          (6, Exception)
+                 78 JUMP_IF_NOT_EXC_MATCH(96)
+                 79 STORE_FAST           (1, ex)
+
+  8              80 LOAD_GLOBAL          (2, self)
+                 81 LOAD_ATTR            (15, assertIs, method=true)
+                 82 LOAD_FAST            (1, ex)
+                 83 LOAD_FAST            (0, stop_exc)
+                 84 CALL                 (2)
+                 85 POP_TOP
+                 86 JUMP_FORWARD         (91)
+                 87 LOAD_CONST           (None)
+                 88 STORE_FAST           (1, ex)
+                 89 DELETE_FAST          (1, ex)
+                 90 RAISE_VARARGS        (ReraiseFromStack)
+            >>   91 POP_EXCEPT
+                 92 LOAD_CONST           (None)
+                 93 STORE_FAST           (1, ex)
+                 94 DELETE_FAST          (1, ex)
+                 95 JUMP_FORWARD         (108)
+            >>   96 RAISE_VARARGS        (ReraiseFromStack)
+                 97 COPY                 (3)
+                 98 POP_EXCEPT
+                 99 RAISE_VARARGS        (ReraiseFromStack)
+
+ 10         >>  100 LOAD_GLOBAL          (2, self)
+                101 LOAD_ATTR            (17, fail, method=true)
+                102 LOAD_FAST            (0, stop_exc)
+                103 FORMAT_SIMPLE
+                104 LOAD_CONST           (" was suppressed")
+                105 BUILD_STRING         (2)
+                106 CALL                 (1)
+                107 POP_TOP
+
+  3         >>  108 PUSH_NULL
+                109 LOAD_CONST           (None)
+                110 LOAD_CONST           (None)
+                111 LOAD_CONST           (None)
+                112 CALL                 (3)
+                113 POP_TOP
+                114 JUMP_FORWARD         (128)
+                115 PUSH_EXC_INFO
+                116 WITH_EXCEPT_START
+                117 TO_BOOL
+                118 POP_JUMP_IF_TRUE     (120)
+                119 RERAISE              (2)
+            >>  120 POP_TOP
+                121 POP_EXCEPT
+                122 POP_TOP
+                123 POP_TOP
+                124 JUMP_FORWARD         (128)
+                125 COPY                 (3)
+                126 POP_EXCEPT
+                127 RERAISE              (1)
+            >>  128 JUMP_BACKWARD        (11)
+            >>  129 RETURN_CONST         (None)
+
+              1 MAKE_FUNCTION
+              2 STORE_NAME           (0, test)
+              3 RETURN_CONST         (None)
diff --git a/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
new file mode 100644
index 0000000000..bc88cf2349
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ands.snap
@@ -0,0 +1,14 @@
+---
+source: compiler/src/compile.rs
+expression: "compile_exec(\"\\\nif True and False and False:\n    pass\n\")"
+---
+  1           0 LoadConst            (True)
+              1 PopJumpIfFalse       (6)
+              2 LoadConst            (False)
+              3 PopJumpIfFalse       (6)
+              4 LoadConst            (False)
+              5 PopJumpIfFalse       (6)
+
+  2     >>    6 LoadConst            (None)
+              7 ReturnValue
+
diff --git a/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
new file mode 100644
index 0000000000..b19cbb119d
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_mixed.snap
@@ -0,0 +1,16 @@
+---
+source: compiler/src/compile.rs
+expression: "compile_exec(\"\\\nif (True and False) or (False and True):\n    pass\n\")"
+---
+  1           0 LoadConst            (True)
+              1 PopJumpIfFalse       (4)
+              2 LoadConst            (False)
+              3 PopJumpIfTrue        (8)
+        >>    4 LoadConst            (False)
+              5 PopJumpIfFalse       (8)
+              6 LoadConst            (True)
+              7 PopJumpIfFalse       (8)
+
+  2     >>    8 LoadConst            (None)
+              9 ReturnValue
+
diff --git a/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
new file mode 100644
index 0000000000..3d1f5a1d6f
--- /dev/null
+++ b/crates/codegen/src/snapshots/rustpython_compiler_core__compile__tests__if_ors.snap
@@ -0,0 +1,14 @@
+---
+source: compiler/src/compile.rs
+expression: "compile_exec(\"\\\nif True or False or False:\n    pass\n\")"
+---
+  1           0 LoadConst            (True)
+              1 PopJumpIfTrue        (6)
+              2 LoadConst            (False)
+              3 PopJumpIfTrue        (6)
+              4 LoadConst            (False)
+              5 PopJumpIfFalse       (6)
+
+  2     >>    6 LoadConst            (None)
+              7 ReturnValue
+
diff --git a/compiler/codegen/src/string_parser.rs b/crates/codegen/src/string_parser.rs
similarity index 98%
rename from compiler/codegen/src/string_parser.rs
rename to crates/codegen/src/string_parser.rs
index ede2f118c3..175e75c1a2 100644
--- a/compiler/codegen/src/string_parser.rs
+++ b/crates/codegen/src/string_parser.rs
@@ -5,7 +5,7 @@
 //! after ruff has already successfully parsed the string literal, meaning
 //! we don't need to do any validation or error handling.
 
-use std::convert::Infallible;
+use core::convert::Infallible;
 
 use ruff_python_ast::{AnyStringFlags, StringFlags};
 use rustpython_wtf8::{CodePoint, Wtf8, Wtf8Buf};
@@ -96,7 +96,7 @@ impl StringParser {
         }
 
         // OK because radix_bytes is always going to be in the ASCII range.
-        let radix_str = std::str::from_utf8(&radix_bytes[..len]).expect("ASCII bytes");
+        let radix_str = core::str::from_utf8(&radix_bytes[..len]).expect("ASCII bytes");
         let value = u32::from_str_radix(radix_str, 8).unwrap();
         char::from_u32(value).unwrap()
     }
diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
new file mode 100644
index 0000000000..e8eb3c7fee
--- /dev/null
+++ b/crates/codegen/src/symboltable.rs
@@ -0,0 +1,2047 @@
+/* Python code is pre-scanned for symbols in the ast.
+
+This ensures that global and nonlocal keywords are picked up.
+Then the compiler can use the symbol table to generate proper
+load and store instructions for names.
+
+Inspirational file: https://github.com/python/cpython/blob/main/Python/symtable.c
+*/
+
+use crate::{
+    IndexMap,
+    error::{CodegenError, CodegenErrorType},
+};
+use alloc::{borrow::Cow, fmt};
+use bitflags::bitflags;
+use ruff_python_ast::{
+    self as ast, Comprehension, Decorator, Expr, Identifier, ModExpression, ModModule, Parameter,
+    ParameterWithDefault, Parameters, Pattern, PatternMatchAs, PatternMatchClass,
+    PatternMatchMapping, PatternMatchOr, PatternMatchSequence, PatternMatchStar, PatternMatchValue,
+    Stmt, TypeParam, TypeParamParamSpec, TypeParamTypeVar, TypeParamTypeVarTuple, TypeParams,
+};
+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)]
+pub struct SymbolTable {
+    /// The name of this symbol table. Often the name of the class or function.
+    pub name: String,
+
+    /// The type of symbol table
+    pub typ: CompilerScope,
+
+    /// The line number in the source code where this symboltable begins.
+    pub line_number: u32,
+
+    // Return True if the block is a nested class or function
+    pub is_nested: bool,
+
+    /// A set of symbols present on this scope level.
+    pub symbols: IndexMap<String, Symbol>,
+
+    /// A list of sub-scopes in the order as found in the
+    /// AST nodes.
+    pub sub_tables: Vec<SymbolTable>,
+
+    /// Cursor pointing to the next sub-table to consume during compilation.
+    pub next_sub_table: usize,
+
+    /// Variable names in definition order (parameters first, then locals)
+    pub varnames: Vec<String>,
+
+    /// Whether this class scope needs an implicit __class__ cell
+    pub needs_class_closure: bool,
+
+    /// Whether this class scope needs an implicit __classdict__ cell
+    pub needs_classdict: bool,
+
+    /// Whether this type param scope can see the parent class scope
+    pub can_see_class_scope: bool,
+
+    /// Whether this comprehension scope should be inlined (PEP 709)
+    /// True for list/set/dict comprehensions in non-generator expressions
+    pub comp_inlined: bool,
+}
+
+impl SymbolTable {
+    fn new(name: String, typ: CompilerScope, line_number: u32, is_nested: bool) -> Self {
+        Self {
+            name,
+            typ,
+            line_number,
+            is_nested,
+            symbols: IndexMap::default(),
+            sub_tables: vec![],
+            next_sub_table: 0,
+            varnames: Vec::new(),
+            needs_class_closure: false,
+            needs_classdict: false,
+            can_see_class_scope: false,
+            comp_inlined: false,
+        }
+    }
+
+    pub fn scan_program(program: &ModModule, source_file: SourceFile) -> SymbolTableResult<Self> {
+        let mut builder = SymbolTableBuilder::new(source_file);
+        builder.scan_statements(program.body.as_ref())?;
+        builder.finish()
+    }
+
+    pub fn scan_expr(expr: &ModExpression, source_file: SourceFile) -> SymbolTableResult<Self> {
+        let mut builder = SymbolTableBuilder::new(source_file);
+        builder.scan_expression(expr.body.as_ref(), ExpressionContext::Load)?;
+        builder.finish()
+    }
+
+    pub fn lookup(&self, name: &str) -> Option<&Symbol> {
+        self.symbols.get(name)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompilerScope {
+    Module,
+    Class,
+    Function,
+    AsyncFunction,
+    Lambda,
+    Comprehension,
+    TypeParams,
+}
+
+impl fmt::Display for CompilerScope {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Module => write!(f, "module"),
+            Self::Class => write!(f, "class"),
+            Self::Function => write!(f, "function"),
+            Self::AsyncFunction => write!(f, "async function"),
+            Self::Lambda => write!(f, "lambda"),
+            Self::Comprehension => write!(f, "comprehension"),
+            Self::TypeParams => write!(f, "type parameter"),
+            // TODO missing types from the C implementation
+            // if self._table.type == _symtable.TYPE_ANNOTATION:
+            //     return "annotation"
+            // if self._table.type == _symtable.TYPE_TYPE_VAR_BOUND:
+            //     return "TypeVar bound"
+            // if self._table.type == _symtable.TYPE_TYPE_ALIAS:
+            //     return "type alias"
+        }
+    }
+}
+
+/// Indicator for a single symbol what the scope of this symbol is.
+/// The scope can be unknown, which is unfortunate, but not impossible.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SymbolScope {
+    Unknown,
+    Local,
+    GlobalExplicit,
+    GlobalImplicit,
+    Free,
+    Cell,
+}
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct SymbolFlags: u16 {
+        const REFERENCED = 0x001;  // USE
+        const ASSIGNED = 0x002;    // DEF_LOCAL
+        const PARAMETER = 0x004;   // DEF_PARAM
+        const ANNOTATED = 0x008;   // DEF_ANNOT
+        const IMPORTED = 0x010;    // DEF_IMPORT
+        const NONLOCAL = 0x020;    // DEF_NONLOCAL
+        // indicates if the symbol gets a value assigned by a named expression in a comprehension
+        // this is required to correct the scope in the analysis.
+        const ASSIGNED_IN_COMPREHENSION = 0x040;
+        // indicates that the symbol is used a bound iterator variable. We distinguish this case
+        // from normal assignment to detect disallowed re-assignment to iterator variables.
+        const ITER = 0x080;
+        /// indicates that the symbol is a free variable in a class method from the scope that the
+        /// class is defined in, e.g.:
+        /// ```python
+        /// def foo(x):
+        ///     class A:
+        ///         def method(self):
+        ///             return x // is_free_class
+        /// ```
+        const FREE_CLASS = 0x100;  // DEF_FREE_CLASS
+        const GLOBAL = 0x200;      // DEF_GLOBAL
+        const COMP_ITER = 0x400;   // DEF_COMP_ITER
+        const COMP_CELL = 0x800;   // DEF_COMP_CELL
+        const TYPE_PARAM = 0x1000; // DEF_TYPE_PARAM
+        const BOUND = Self::ASSIGNED.bits() | Self::PARAMETER.bits() | Self::IMPORTED.bits() | Self::ITER.bits() | Self::TYPE_PARAM.bits();
+    }
+}
+
+/// A single symbol in a table. Has various properties such as the scope
+/// of the symbol, and also the various uses of the symbol.
+#[derive(Debug, Clone)]
+pub struct Symbol {
+    pub name: String,
+    pub scope: SymbolScope,
+    pub flags: SymbolFlags,
+}
+
+impl Symbol {
+    fn new(name: &str) -> Self {
+        Self {
+            name: name.to_owned(),
+            // table,
+            scope: SymbolScope::Unknown,
+            flags: SymbolFlags::empty(),
+        }
+    }
+
+    pub const fn is_global(&self) -> bool {
+        matches!(
+            self.scope,
+            SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit
+        )
+    }
+
+    pub const fn is_local(&self) -> bool {
+        matches!(self.scope, SymbolScope::Local | SymbolScope::Cell)
+    }
+
+    pub const fn is_bound(&self) -> bool {
+        self.flags.intersects(SymbolFlags::BOUND)
+    }
+}
+
+#[derive(Debug)]
+pub struct SymbolTableError {
+    error: String,
+    location: Option<SourceLocation>,
+}
+
+impl SymbolTableError {
+    pub fn into_codegen_error(self, source_path: String) -> CodegenError {
+        CodegenError {
+            location: self.location,
+            error: CodegenErrorType::SyntaxError(self.error),
+            source_path,
+        }
+    }
+}
+
+type SymbolTableResult<T = ()> = Result<T, SymbolTableError>;
+
+impl core::fmt::Debug for SymbolTable {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(
+            f,
+            "SymbolTable({:?} symbols, {:?} sub scopes)",
+            self.symbols.len(),
+            self.sub_tables.len()
+        )
+    }
+}
+
+/* Perform some sort of analysis on nonlocals, globals etc..
+  See also: https://github.com/python/cpython/blob/main/Python/symtable.c#L410
+*/
+fn analyze_symbol_table(symbol_table: &mut SymbolTable) -> SymbolTableResult {
+    let mut analyzer = SymbolTableAnalyzer::default();
+    // Discard the newfree set at the top level - it's only needed for propagation
+    let _newfree = analyzer.analyze_symbol_table(symbol_table)?;
+    Ok(())
+}
+
+/* Drop __class__ and __classdict__ from free variables in class scope
+   and set the appropriate flags. Equivalent to CPython's drop_class_free().
+   See: https://github.com/python/cpython/blob/main/Python/symtable.c#L884
+
+   This function removes __class__ and __classdict__ from the
+   `newfree` set (which contains free variables collected from all child scopes)
+   and sets the corresponding flags on the class's symbol table entry.
+*/
+fn drop_class_free(symbol_table: &mut SymbolTable, newfree: &mut HashSet<String>) {
+    // Check if __class__ is in the free variables collected from children
+    // If found, it means a child scope (method) references __class__
+    if newfree.remove("__class__") {
+        symbol_table.needs_class_closure = true;
+    }
+
+    // Check if __classdict__ is in the free variables collected from children
+    if newfree.remove("__classdict__") {
+        symbol_table.needs_classdict = true;
+    }
+}
+
+type SymbolMap = IndexMap<String, Symbol>;
+
+mod stack {
+    use core::ptr::NonNull;
+    use std::panic;
+    pub struct StackStack<T> {
+        v: Vec<NonNull<T>>,
+    }
+    impl<T> Default for StackStack<T> {
+        fn default() -> Self {
+            Self { v: Vec::new() }
+        }
+    }
+    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.
+        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)));
+            self.v.pop();
+            res.unwrap_or_else(|x| panic::resume_unwind(x))
+        }
+
+        pub fn iter(&self) -> impl DoubleEndedIterator<Item = &T> + '_ {
+            self.as_ref().iter().copied()
+        }
+        pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> + '_ {
+            self.as_mut().iter_mut().map(|x| &mut **x)
+        }
+        // pub fn top(&self) -> Option<&T> {
+        //     self.as_ref().last().copied()
+        // }
+        // pub fn top_mut(&mut self) -> Option<&mut T> {
+        //     self.as_mut().last_mut().map(|x| &mut **x)
+        // }
+        pub fn len(&self) -> usize {
+            self.v.len()
+        }
+        pub fn is_empty(&self) -> bool {
+            self.len() == 0
+        }
+
+        pub fn as_ref(&self) -> &[&T] {
+            unsafe { &*(self.v.as_slice() as *const [NonNull<T>] as *const [&T]) }
+        }
+
+        pub fn as_mut(&mut self) -> &mut [&mut T] {
+            unsafe { &mut *(self.v.as_mut_slice() as *mut [NonNull<T>] as *mut [&mut T]) }
+        }
+    }
+}
+use stack::StackStack;
+
+/// Symbol table analysis. Can be used to analyze a fully
+/// build symbol table structure. It will mark variables
+/// as local variables for example.
+#[derive(Default)]
+#[repr(transparent)]
+struct SymbolTableAnalyzer {
+    tables: StackStack<(SymbolMap, CompilerScope)>,
+}
+
+impl SymbolTableAnalyzer {
+    /// Analyze a symbol table and return the set of free variables.
+    /// See symtable.c analyze_block().
+    fn analyze_symbol_table(
+        &mut self,
+        symbol_table: &mut SymbolTable,
+    ) -> SymbolTableResult<HashSet<String>> {
+        let symbols = core::mem::take(&mut symbol_table.symbols);
+        let sub_tables = &mut *symbol_table.sub_tables;
+
+        // Collect free variables from all child scopes
+        let mut newfree = HashSet::new();
+
+        let mut info = (symbols, symbol_table.typ);
+        self.tables.with_append(&mut info, |list| {
+            let inner_scope = unsafe { &mut *(list as *mut _ as *mut Self) };
+            // Analyze sub scopes and collect their free variables
+            for sub_table in sub_tables.iter_mut() {
+                let child_free = inner_scope.analyze_symbol_table(sub_table)?;
+                // Propagate child's free variables to this scope
+                newfree.extend(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);
+                    }
+                }
+            }
+        }
+
+        // Analyze symbols in current scope
+        for symbol in symbol_table.symbols.values_mut() {
+            self.analyze_symbol(symbol, symbol_table.typ, sub_tables)?;
+
+            // Collect free variables from this scope
+            // These will be propagated to the parent scope
+            if symbol.scope == SymbolScope::Free || symbol.flags.contains(SymbolFlags::FREE_CLASS) {
+                newfree.insert(symbol.name.clone());
+            }
+        }
+
+        // Handle class-specific implicit cells
+        // 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);
+        }
+
+        Ok(newfree)
+    }
+
+    fn analyze_symbol(
+        &mut self,
+        symbol: &mut Symbol,
+        st_typ: CompilerScope,
+        sub_tables: &[SymbolTable],
+    ) -> SymbolTableResult {
+        if symbol
+            .flags
+            .contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
+            && st_typ == CompilerScope::Comprehension
+        {
+            // propagate symbol to next higher level that can hold it,
+            // i.e., function or module. Comprehension is skipped and
+            // Class is not allowed and detected as error.
+            //symbol.scope = SymbolScope::Nonlocal;
+            self.analyze_symbol_comprehension(symbol, 0)?
+        } else {
+            match symbol.scope {
+                SymbolScope::Free => {
+                    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) != Some(SymbolScope::Free)
+                        {
+                            return Err(SymbolTableError {
+                                error: format!("no binding for nonlocal '{}' found", symbol.name),
+                                // TODO: accurate location info, somehow
+                                location: None,
+                            });
+                        }
+                    } else {
+                        return Err(SymbolTableError {
+                            error: format!(
+                                "nonlocal {} defined at place without an enclosing scope",
+                                symbol.name
+                            ),
+                            // TODO: accurate location info, somehow
+                            location: None,
+                        });
+                    }
+                }
+                SymbolScope::GlobalExplicit | SymbolScope::GlobalImplicit => {
+                    // TODO: add more checks for globals?
+                }
+                SymbolScope::Local | SymbolScope::Cell => {
+                    // all is well
+                }
+                SymbolScope::Unknown => {
+                    // 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) {
+                        scope
+                    } else if self.tables.is_empty() {
+                        // Don't make assumptions when we don't know.
+                        SymbolScope::Unknown
+                    } else {
+                        // If there are scopes above we assume global.
+                        SymbolScope::GlobalImplicit
+                    };
+                    symbol.scope = scope;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn found_in_outer_scope(&mut self, name: &str) -> Option<SymbolScope> {
+        let mut decl_depth = None;
+        for (i, (symbols, typ)) in self.tables.iter().rev().enumerate() {
+            if matches!(typ, CompilerScope::Module)
+                || matches!(typ, CompilerScope::Class if name != "__class__")
+            {
+                continue;
+            }
+
+            // __class__ is implicitly declared in class scope
+            // This handles the case where super() is called in a nested class method
+            if name == "__class__" && matches!(typ, CompilerScope::Class) {
+                decl_depth = Some(i);
+                break;
+            }
+
+            if let Some(sym) = symbols.get(name) {
+                match sym.scope {
+                    SymbolScope::GlobalExplicit => return Some(SymbolScope::GlobalExplicit),
+                    SymbolScope::GlobalImplicit => {}
+                    _ => {
+                        if sym.is_bound() {
+                            decl_depth = Some(i);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        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 (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) {
+                        free_class.flags.insert(SymbolFlags::FREE_CLASS)
+                    } else {
+                        let mut symbol = Symbol::new(name);
+                        symbol.flags.insert(SymbolFlags::FREE_CLASS);
+                        symbol.scope = SymbolScope::Free;
+                        table.insert(name.to_owned(), symbol);
+                    }
+                } 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);
+                }
+            }
+        }
+
+        decl_depth.map(|_| SymbolScope::Free)
+    }
+
+    fn found_in_inner_scope(
+        &self,
+        sub_tables: &[SymbolTable],
+        name: &str,
+        st_typ: CompilerScope,
+    ) -> Option<SymbolScope> {
+        sub_tables.iter().find_map(|st| {
+            let sym = st.symbols.get(name)?;
+            if sym.scope == SymbolScope::Free || sym.flags.contains(SymbolFlags::FREE_CLASS) {
+                if st_typ == CompilerScope::Class && name != "__class__" {
+                    None
+                } else {
+                    Some(SymbolScope::Cell)
+                }
+            } else if sym.scope == SymbolScope::GlobalExplicit && self.tables.is_empty() {
+                // the symbol is defined on the module level, and an inner scope declares
+                // a global that points to it
+                Some(SymbolScope::GlobalExplicit)
+            } else {
+                None
+            }
+        })
+    }
+
+    // Implements the symbol analysis and scope extension for names
+    // assigned by a named expression in a comprehension. See:
+    // https://github.com/python/cpython/blob/7b78e7f9fd77bb3280ee39fb74b86772a7d46a70/Python/symtable.c#L1435
+    fn analyze_symbol_comprehension(
+        &mut self,
+        symbol: &mut Symbol,
+        parent_offset: usize,
+    ) -> SymbolTableResult {
+        // when this is called, we expect to be in the direct parent scope of the scope that contains 'symbol'
+        let last = self.tables.iter_mut().rev().nth(parent_offset).unwrap();
+        let symbols = &mut last.0;
+        let table_type = last.1;
+
+        // it is not allowed to use an iterator variable as assignee in a named expression
+        if symbol.flags.contains(SymbolFlags::ITER) {
+            return Err(SymbolTableError {
+                error: format!(
+                    "assignment expression cannot rebind comprehension iteration variable {}",
+                    symbol.name
+                ),
+                // TODO: accurate location info, somehow
+                location: None,
+            });
+        }
+
+        match table_type {
+            CompilerScope::Module => {
+                symbol.scope = SymbolScope::GlobalImplicit;
+            }
+            CompilerScope::Class => {
+                // named expressions are forbidden in comprehensions on class scope
+                return Err(SymbolTableError {
+                    error: "assignment expression within a comprehension cannot be used in a class body".to_string(),
+                    // TODO: accurate location info, somehow
+                    location: None,
+                });
+            }
+            CompilerScope::Function | CompilerScope::AsyncFunction | CompilerScope::Lambda => {
+                if let Some(parent_symbol) = symbols.get_mut(&symbol.name) {
+                    if let SymbolScope::Unknown = parent_symbol.scope {
+                        // this information is new, as the assignment is done in inner scope
+                        parent_symbol.flags.insert(SymbolFlags::ASSIGNED);
+                    }
+
+                    symbol.scope = if parent_symbol.is_global() {
+                        parent_symbol.scope
+                    } else {
+                        SymbolScope::Free
+                    };
+                } else {
+                    let mut cloned_sym = symbol.clone();
+                    cloned_sym.scope = SymbolScope::Cell;
+                    last.0.insert(cloned_sym.name.to_owned(), cloned_sym);
+                }
+            }
+            CompilerScope::Comprehension => {
+                // TODO check for conflicts - requires more context information about variables
+                match symbols.get_mut(&symbol.name) {
+                    Some(parent_symbol) => {
+                        // check if assignee is an iterator in top scope
+                        if parent_symbol.flags.contains(SymbolFlags::ITER) {
+                            return Err(SymbolTableError {
+                                error: format!(
+                                    "assignment expression cannot rebind comprehension iteration variable {}",
+                                    symbol.name
+                                ),
+                                location: None,
+                            });
+                        }
+
+                        // we synthesize the assignment to the symbol from inner scope
+                        parent_symbol.flags.insert(SymbolFlags::ASSIGNED); // more checks are required
+                    }
+                    None => {
+                        // extend the scope of the inner symbol
+                        // as we are in a nested comprehension, we expect that the symbol is needed
+                        // outside, too, and set it therefore to non-local scope. I.e., we expect to
+                        // find a definition on a higher level
+                        let mut cloned_sym = symbol.clone();
+                        cloned_sym.scope = SymbolScope::Free;
+                        last.0.insert(cloned_sym.name.to_owned(), cloned_sym);
+                    }
+                }
+
+                self.analyze_symbol_comprehension(symbol, parent_offset + 1)?;
+            }
+            CompilerScope::TypeParams => {
+                // Named expression in comprehension cannot be used in type params
+                return Err(SymbolTableError {
+                    error: "assignment expression within a comprehension cannot be used within the definition of a generic".to_string(),
+                    location: None,
+                });
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+enum SymbolUsage {
+    Global,
+    Nonlocal,
+    Used,
+    Assigned,
+    Imported,
+    AnnotationAssigned,
+    Parameter,
+    AnnotationParameter,
+    AssignedNamedExprInComprehension,
+    Iter,
+    TypeParam,
+}
+
+struct SymbolTableBuilder {
+    class_name: Option<String>,
+    // Scope stack.
+    tables: Vec<SymbolTable>,
+    future_annotations: bool,
+    source_file: SourceFile,
+    // Current scope's varnames being collected (temporary storage)
+    current_varnames: Vec<String>,
+    // Track if we're inside an iterable definition expression (for nested comprehensions)
+    in_iter_def_exp: bool,
+    // Track if we're inside an annotation (yield/await/named expr not allowed)
+    in_annotation: bool,
+    // Track if we're inside a type alias (yield/await/named expr not allowed)
+    in_type_alias: bool,
+    // Track if we're scanning an inner loop iteration target (not the first generator)
+    in_comp_inner_loop_target: bool,
+    // Scope info for error messages (e.g., "a TypeVar bound")
+    scope_info: Option<&'static str>,
+}
+
+/// Enum to indicate in what mode an expression
+/// was used.
+/// In cpython this is stored in the AST, but I think this
+/// is not logical, since it is not context free.
+#[derive(Copy, Clone, PartialEq)]
+enum ExpressionContext {
+    Load,
+    Store,
+    Delete,
+    Iter,
+    IterDefinitionExp,
+}
+
+impl SymbolTableBuilder {
+    fn new(source_file: SourceFile) -> Self {
+        let mut this = Self {
+            class_name: None,
+            tables: vec![],
+            future_annotations: false,
+            source_file,
+            current_varnames: Vec::new(),
+            in_iter_def_exp: false,
+            in_annotation: false,
+            in_type_alias: false,
+            in_comp_inner_loop_target: false,
+            scope_info: None,
+        };
+        this.enter_scope("top", CompilerScope::Module, 0);
+        this
+    }
+
+    fn finish(mut self) -> Result<SymbolTable, SymbolTableError> {
+        assert_eq!(self.tables.len(), 1);
+        let mut symbol_table = self.tables.pop().unwrap();
+        // Save varnames for the top-level module scope
+        symbol_table.varnames = self.current_varnames;
+        analyze_symbol_table(&mut symbol_table)?;
+        Ok(symbol_table)
+    }
+
+    fn enter_scope(&mut self, name: &str, typ: CompilerScope, line_number: u32) {
+        let is_nested = self
+            .tables
+            .last()
+            .map(|table| table.is_nested || table.typ == CompilerScope::Function)
+            .unwrap_or(false);
+        let table = SymbolTable::new(name.to_owned(), typ, line_number, is_nested);
+        self.tables.push(table);
+        // Clear current_varnames for the new scope
+        self.current_varnames.clear();
+    }
+
+    fn enter_type_param_block(&mut self, name: &str, line_number: u32) -> SymbolTableResult {
+        // Check if we're in a class scope
+        let in_class = self
+            .tables
+            .last()
+            .is_some_and(|t| t.typ == CompilerScope::Class);
+
+        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
+        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())?;
+            }
+        }
+
+        // Register .type_params as a SET symbol (it will be converted to cell variable later)
+        self.register_name(".type_params", SymbolUsage::Assigned, TextRange::default())?;
+
+        Ok(())
+    }
+
+    /// Pop symbol table and add to sub table of parent table.
+    fn leave_scope(&mut self) {
+        let mut table = self.tables.pop().unwrap();
+        // Save the collected varnames to the symbol table
+        table.varnames = core::mem::take(&mut self.current_varnames);
+        self.tables.last_mut().unwrap().sub_tables.push(table);
+    }
+
+    fn line_index_start(&self, range: TextRange) -> u32 {
+        self.source_file
+            .to_source_code()
+            .line_index(range.start())
+            .get() as _
+    }
+
+    fn scan_statements(&mut self, statements: &[Stmt]) -> SymbolTableResult {
+        for statement in statements {
+            self.scan_statement(statement)?;
+        }
+        Ok(())
+    }
+
+    fn scan_parameters(&mut self, parameters: &[ParameterWithDefault]) -> SymbolTableResult {
+        for parameter in parameters {
+            self.scan_parameter(&parameter.parameter)?;
+        }
+        Ok(())
+    }
+
+    fn scan_parameter(&mut self, parameter: &Parameter) -> SymbolTableResult {
+        let usage = if parameter.annotation.is_some() {
+            SymbolUsage::AnnotationParameter
+        } else {
+            SymbolUsage::Parameter
+        };
+
+        // Check for duplicate parameter names
+        let table = self.tables.last().unwrap();
+        if table.symbols.contains_key(parameter.name.as_str()) {
+            return Err(SymbolTableError {
+                error: format!(
+                    "duplicate parameter '{}' in function definition",
+                    parameter.name
+                ),
+                location: Some(
+                    self.source_file
+                        .to_source_code()
+                        .source_location(parameter.name.range.start(), PositionEncoding::Utf8),
+                ),
+            });
+        }
+
+        self.register_ident(&parameter.name, usage)
+    }
+
+    fn scan_annotation(&mut self, annotation: &Expr) -> SymbolTableResult {
+        if self.future_annotations {
+            Ok(())
+        } else {
+            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
+        }
+    }
+
+    fn scan_statement(&mut self, statement: &Stmt) -> SymbolTableResult {
+        use ruff_python_ast::*;
+        if let Stmt::ImportFrom(StmtImportFrom { module, names, .. }) = &statement
+            && module.as_ref().map(|id| id.as_str()) == Some("__future__")
+        {
+            self.future_annotations =
+                self.future_annotations || names.iter().any(|future| &future.name == "annotations");
+        }
+
+        match &statement {
+            Stmt::Global(StmtGlobal { names, .. }) => {
+                for name in names {
+                    self.register_ident(name, SymbolUsage::Global)?;
+                }
+            }
+            Stmt::Nonlocal(StmtNonlocal { names, .. }) => {
+                for name in names {
+                    self.register_ident(name, SymbolUsage::Nonlocal)?;
+                }
+            }
+            Stmt::FunctionDef(StmtFunctionDef {
+                name,
+                body,
+                parameters,
+                decorator_list,
+                type_params,
+                returns,
+                range,
+                ..
+            }) => {
+                self.scan_decorators(decorator_list, ExpressionContext::Load)?;
+                self.register_ident(name, SymbolUsage::Assigned)?;
+                if let Some(expression) = returns {
+                    self.scan_annotation(expression)?;
+                }
+                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),
+                    )?;
+                    self.scan_type_params(type_params)?;
+                }
+                self.enter_scope_with_parameters(
+                    name.as_str(),
+                    parameters,
+                    self.line_index_start(*range),
+                )?;
+                self.scan_statements(body)?;
+                self.leave_scope();
+                if type_params.is_some() {
+                    self.leave_scope();
+                }
+            }
+            Stmt::ClassDef(StmtClassDef {
+                name,
+                body,
+                arguments,
+                decorator_list,
+                type_params,
+                range,
+                node_index: _,
+            }) => {
+                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),
+                    )?;
+                    self.scan_type_params(type_params)?;
+                }
+                self.enter_scope(
+                    name.as_str(),
+                    CompilerScope::Class,
+                    self.line_index_start(*range),
+                );
+                let prev_class = self.class_name.replace(name.to_string());
+                self.register_name("__module__", SymbolUsage::Assigned, *range)?;
+                self.register_name("__qualname__", SymbolUsage::Assigned, *range)?;
+                self.register_name("__doc__", SymbolUsage::Assigned, *range)?;
+                self.register_name("__class__", SymbolUsage::Assigned, *range)?;
+                self.scan_statements(body)?;
+                self.leave_scope();
+                self.class_name = prev_class;
+                if let Some(arguments) = arguments {
+                    self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
+                    for keyword in &arguments.keywords {
+                        self.scan_expression(&keyword.value, ExpressionContext::Load)?;
+                    }
+                }
+                if type_params.is_some() {
+                    self.leave_scope();
+                }
+                self.scan_decorators(decorator_list, ExpressionContext::Load)?;
+                self.register_ident(name, SymbolUsage::Assigned)?;
+            }
+            Stmt::Expr(StmtExpr { value, .. }) => {
+                self.scan_expression(value, ExpressionContext::Load)?
+            }
+            Stmt::If(StmtIf {
+                test,
+                body,
+                elif_else_clauses,
+                ..
+            }) => {
+                self.scan_expression(test, ExpressionContext::Load)?;
+                self.scan_statements(body)?;
+                for elif in elif_else_clauses {
+                    if let Some(test) = &elif.test {
+                        self.scan_expression(test, ExpressionContext::Load)?;
+                    }
+                    self.scan_statements(&elif.body)?;
+                }
+            }
+            Stmt::For(StmtFor {
+                target,
+                iter,
+                body,
+                orelse,
+                ..
+            }) => {
+                self.scan_expression(target, ExpressionContext::Store)?;
+                self.scan_expression(iter, ExpressionContext::Load)?;
+                self.scan_statements(body)?;
+                self.scan_statements(orelse)?;
+            }
+            Stmt::While(StmtWhile {
+                test, body, orelse, ..
+            }) => {
+                self.scan_expression(test, ExpressionContext::Load)?;
+                self.scan_statements(body)?;
+                self.scan_statements(orelse)?;
+            }
+            Stmt::Break(_) | Stmt::Continue(_) | Stmt::Pass(_) => {
+                // No symbols here.
+            }
+            Stmt::Import(StmtImport { names, .. })
+            | Stmt::ImportFrom(StmtImportFrom { names, .. }) => {
+                for name in names {
+                    if let Some(alias) = &name.asname {
+                        // `import my_module as my_alias`
+                        self.register_ident(alias, SymbolUsage::Imported)?;
+                    } else if name.name.as_str() == "*" {
+                        // Star imports are only allowed at module level
+                        if self.tables.last().unwrap().typ != CompilerScope::Module {
+                            return Err(SymbolTableError {
+                                error: "'import *' only allowed at module level".to_string(),
+                                location: Some(self.source_file.to_source_code().source_location(
+                                    name.name.range.start(),
+                                    PositionEncoding::Utf8,
+                                )),
+                            });
+                        }
+                        // Don't register star imports as symbols
+                    } else {
+                        // `import module`
+                        self.register_name(
+                            name.name.split('.').next().unwrap(),
+                            SymbolUsage::Imported,
+                            name.name.range,
+                        )?;
+                    }
+                }
+            }
+            Stmt::Return(StmtReturn { value, .. }) => {
+                if let Some(expression) = value {
+                    self.scan_expression(expression, ExpressionContext::Load)?;
+                }
+            }
+            Stmt::Assert(StmtAssert { test, msg, .. }) => {
+                self.scan_expression(test, ExpressionContext::Load)?;
+                if let Some(expression) = msg {
+                    self.scan_expression(expression, ExpressionContext::Load)?;
+                }
+            }
+            Stmt::Delete(StmtDelete { targets, .. }) => {
+                self.scan_expressions(targets, ExpressionContext::Delete)?;
+            }
+            Stmt::Assign(StmtAssign { targets, value, .. }) => {
+                self.scan_expressions(targets, ExpressionContext::Store)?;
+                self.scan_expression(value, ExpressionContext::Load)?;
+            }
+            Stmt::AugAssign(StmtAugAssign { target, value, .. }) => {
+                self.scan_expression(target, ExpressionContext::Store)?;
+                self.scan_expression(value, ExpressionContext::Load)?;
+            }
+            Stmt::AnnAssign(StmtAnnAssign {
+                target,
+                annotation,
+                value,
+                simple,
+                range,
+                node_index: _,
+            }) => {
+                // https://github.com/python/cpython/blob/main/Python/symtable.c#L1233
+                match &**target {
+                    Expr::Name(ast::ExprName { id, .. }) if *simple => {
+                        self.register_name(id.as_str(), SymbolUsage::AnnotationAssigned, *range)?;
+                    }
+                    _ => {
+                        self.scan_expression(target, ExpressionContext::Store)?;
+                    }
+                }
+                self.scan_annotation(annotation)?;
+                if let Some(value) = value {
+                    self.scan_expression(value, ExpressionContext::Load)?;
+                }
+            }
+            Stmt::With(StmtWith { items, body, .. }) => {
+                for item in items {
+                    self.scan_expression(&item.context_expr, ExpressionContext::Load)?;
+                    if let Some(expression) = &item.optional_vars {
+                        self.scan_expression(expression, ExpressionContext::Store)?;
+                    }
+                }
+                self.scan_statements(body)?;
+            }
+            Stmt::Try(StmtTry {
+                body,
+                handlers,
+                orelse,
+                finalbody,
+                ..
+            }) => {
+                self.scan_statements(body)?;
+                for handler in handlers {
+                    let ExceptHandler::ExceptHandler(ast::ExceptHandlerExceptHandler {
+                        type_,
+                        name,
+                        body,
+                        ..
+                    }) = &handler;
+                    if let Some(expression) = type_ {
+                        self.scan_expression(expression, ExpressionContext::Load)?;
+                    }
+                    if let Some(name) = name {
+                        self.register_ident(name, SymbolUsage::Assigned)?;
+                    }
+                    self.scan_statements(body)?;
+                }
+                self.scan_statements(orelse)?;
+                self.scan_statements(finalbody)?;
+            }
+            Stmt::Match(StmtMatch { subject, cases, .. }) => {
+                self.scan_expression(subject, ExpressionContext::Load)?;
+                for case in cases {
+                    self.scan_pattern(&case.pattern)?;
+                    if let Some(guard) = &case.guard {
+                        self.scan_expression(guard, ExpressionContext::Load)?;
+                    }
+                    self.scan_statements(&case.body)?;
+                }
+            }
+            Stmt::Raise(StmtRaise { exc, cause, .. }) => {
+                if let Some(expression) = exc {
+                    self.scan_expression(expression, ExpressionContext::Load)?;
+                }
+                if let Some(expression) = cause {
+                    self.scan_expression(expression, ExpressionContext::Load)?;
+                }
+            }
+            Stmt::TypeAlias(StmtTypeAlias {
+                name,
+                value,
+                type_params,
+                ..
+            }) => {
+                let was_in_type_alias = self.in_type_alias;
+                self.in_type_alias = true;
+                if let Some(type_params) = type_params {
+                    self.enter_type_param_block(
+                        "TypeAlias",
+                        self.line_index_start(type_params.range),
+                    )?;
+                    self.scan_type_params(type_params)?;
+                    self.scan_expression(value, ExpressionContext::Load)?;
+                    self.leave_scope();
+                } else {
+                    self.scan_expression(value, ExpressionContext::Load)?;
+                }
+                self.in_type_alias = was_in_type_alias;
+                self.scan_expression(name, ExpressionContext::Store)?;
+            }
+            Stmt::IpyEscapeCommand(_) => todo!(),
+        }
+        Ok(())
+    }
+
+    fn scan_decorators(
+        &mut self,
+        decorators: &[Decorator],
+        context: ExpressionContext,
+    ) -> SymbolTableResult {
+        for decorator in decorators {
+            self.scan_expression(&decorator.expression, context)?;
+        }
+        Ok(())
+    }
+
+    fn scan_expressions(
+        &mut self,
+        expressions: &[Expr],
+        context: ExpressionContext,
+    ) -> SymbolTableResult {
+        for expression in expressions {
+            self.scan_expression(expression, context)?;
+        }
+        Ok(())
+    }
+
+    fn scan_expression(
+        &mut self,
+        expression: &Expr,
+        context: ExpressionContext,
+    ) -> SymbolTableResult {
+        use ruff_python_ast::*;
+
+        // Check for expressions not allowed in certain contexts
+        // (type parameters, annotations, type aliases, TypeVar bounds/defaults)
+        if let Some(keyword) = match expression {
+            Expr::Yield(_) | Expr::YieldFrom(_) => Some("yield"),
+            Expr::Await(_) => Some("await"),
+            Expr::Named(_) => Some("named"),
+            _ => None,
+        } {
+            // Determine the context name for the error message
+            // scope_info takes precedence (e.g., "a TypeVar bound")
+            let context_name = if let Some(scope_info) = self.scope_info {
+                Some(scope_info)
+            } else if let Some(table) = self.tables.last()
+                && table.typ == CompilerScope::TypeParams
+            {
+                Some("a type parameter")
+            } else if self.in_annotation {
+                Some("an annotation")
+            } else if self.in_type_alias {
+                Some("a type alias")
+            } else {
+                None
+            };
+
+            if let Some(context_name) = context_name {
+                return Err(SymbolTableError {
+                    error: format!("{keyword} expression cannot be used within {context_name}"),
+                    location: Some(
+                        self.source_file
+                            .to_source_code()
+                            .source_location(expression.range().start(), PositionEncoding::Utf8),
+                    ),
+                });
+            }
+        }
+
+        match expression {
+            Expr::BinOp(ExprBinOp {
+                left,
+                right,
+                range: _,
+                ..
+            }) => {
+                self.scan_expression(left, context)?;
+                self.scan_expression(right, context)?;
+            }
+            Expr::BoolOp(ExprBoolOp {
+                values, range: _, ..
+            }) => {
+                self.scan_expressions(values, context)?;
+            }
+            Expr::Compare(ExprCompare {
+                left,
+                comparators,
+                range: _,
+                ..
+            }) => {
+                self.scan_expression(left, context)?;
+                self.scan_expressions(comparators, context)?;
+            }
+            Expr::Subscript(ExprSubscript {
+                value,
+                slice,
+                range: _,
+                ..
+            }) => {
+                self.scan_expression(value, ExpressionContext::Load)?;
+                self.scan_expression(slice, ExpressionContext::Load)?;
+            }
+            Expr::Attribute(ExprAttribute {
+                value, range: _, ..
+            }) => {
+                self.scan_expression(value, ExpressionContext::Load)?;
+            }
+            Expr::Dict(ExprDict {
+                items,
+                node_index: _,
+                range: _,
+            }) => {
+                for item in items {
+                    if let Some(key) = &item.key {
+                        self.scan_expression(key, context)?;
+                    }
+                    self.scan_expression(&item.value, context)?;
+                }
+            }
+            Expr::Await(ExprAwait {
+                value,
+                node_index: _,
+                range: _,
+            }) => {
+                self.scan_expression(value, context)?;
+            }
+            Expr::Yield(ExprYield {
+                value,
+                node_index: _,
+                range: _,
+            }) => {
+                if let Some(expression) = value {
+                    self.scan_expression(expression, context)?;
+                }
+            }
+            Expr::YieldFrom(ExprYieldFrom {
+                value,
+                node_index: _,
+                range: _,
+            }) => {
+                self.scan_expression(value, context)?;
+            }
+            Expr::UnaryOp(ExprUnaryOp {
+                operand, range: _, ..
+            }) => {
+                self.scan_expression(operand, context)?;
+            }
+            Expr::Starred(ExprStarred {
+                value, range: _, ..
+            }) => {
+                self.scan_expression(value, context)?;
+            }
+            Expr::Tuple(ExprTuple { elts, range: _, .. })
+            | Expr::Set(ExprSet { elts, range: _, .. })
+            | Expr::List(ExprList { elts, range: _, .. }) => {
+                self.scan_expressions(elts, context)?;
+            }
+            Expr::Slice(ExprSlice {
+                lower,
+                upper,
+                step,
+                node_index: _,
+                range: _,
+            }) => {
+                if let Some(lower) = lower {
+                    self.scan_expression(lower, context)?;
+                }
+                if let Some(upper) = upper {
+                    self.scan_expression(upper, context)?;
+                }
+                if let Some(step) = step {
+                    self.scan_expression(step, context)?;
+                }
+            }
+            Expr::Generator(ExprGenerator {
+                elt,
+                generators,
+                range,
+                ..
+            }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
+                // Generator expression - is_generator = true
+                self.scan_comprehension("<genexpr>", elt, None, generators, *range, true)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
+            }
+            Expr::ListComp(ExprListComp {
+                elt,
+                generators,
+                range,
+                node_index: _,
+            }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
+                // List comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<listcomp>", elt, None, generators, *range, false)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
+            }
+            Expr::SetComp(ExprSetComp {
+                elt,
+                generators,
+                range,
+                node_index: _,
+            }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
+                // Set comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<setcomp>", elt, None, generators, *range, false)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
+            }
+            Expr::DictComp(ExprDictComp {
+                key,
+                value,
+                generators,
+                range,
+                node_index: _,
+            }) => {
+                let was_in_iter_def_exp = self.in_iter_def_exp;
+                if context == ExpressionContext::IterDefinitionExp {
+                    self.in_iter_def_exp = true;
+                }
+                // Dict comprehension - is_generator = false (can be inlined)
+                self.scan_comprehension("<dictcomp>", key, Some(value), generators, *range, false)?;
+                self.in_iter_def_exp = was_in_iter_def_exp;
+            }
+            Expr::Call(ExprCall {
+                func,
+                arguments,
+                node_index: _,
+                range: _,
+            }) => {
+                match context {
+                    ExpressionContext::IterDefinitionExp => {
+                        self.scan_expression(func, ExpressionContext::IterDefinitionExp)?;
+                    }
+                    _ => {
+                        self.scan_expression(func, ExpressionContext::Load)?;
+                    }
+                }
+
+                self.scan_expressions(&arguments.args, ExpressionContext::Load)?;
+                for keyword in &arguments.keywords {
+                    self.scan_expression(&keyword.value, ExpressionContext::Load)?;
+                }
+            }
+            Expr::Name(ExprName { id, range, .. }) => {
+                let id = id.as_str();
+                // Determine the contextual usage of this symbol:
+                match context {
+                    ExpressionContext::Delete => {
+                        self.register_name(id, SymbolUsage::Assigned, *range)?;
+                        self.register_name(id, SymbolUsage::Used, *range)?;
+                    }
+                    ExpressionContext::Load | ExpressionContext::IterDefinitionExp => {
+                        self.register_name(id, SymbolUsage::Used, *range)?;
+                    }
+                    ExpressionContext::Store => {
+                        self.register_name(id, SymbolUsage::Assigned, *range)?;
+                    }
+                    ExpressionContext::Iter => {
+                        self.register_name(id, SymbolUsage::Iter, *range)?;
+                    }
+                }
+                // Interesting stuff about the __class__ variable:
+                // https://docs.python.org/3/reference/datamodel.html?highlight=__class__#creating-the-class-object
+                if context == ExpressionContext::Load
+                    && self.tables.last().unwrap().typ == CompilerScope::Function
+                    && id == "super"
+                {
+                    self.register_name("__class__", SymbolUsage::Used, *range)?;
+                }
+            }
+            Expr::Lambda(ExprLambda {
+                body,
+                parameters,
+                node_index: _,
+                range: _,
+            }) => {
+                if let Some(parameters) = parameters {
+                    self.enter_scope_with_parameters(
+                        "lambda",
+                        parameters,
+                        self.line_index_start(expression.range()),
+                    )?;
+                } else {
+                    self.enter_scope(
+                        "lambda",
+                        CompilerScope::Lambda,
+                        self.line_index_start(expression.range()),
+                    );
+                }
+                match context {
+                    ExpressionContext::IterDefinitionExp => {
+                        self.scan_expression(body, ExpressionContext::IterDefinitionExp)?;
+                    }
+                    _ => {
+                        self.scan_expression(body, ExpressionContext::Load)?;
+                    }
+                }
+                self.leave_scope();
+            }
+            Expr::FString(ExprFString { value, .. }) => {
+                for expr in value.elements().filter_map(|x| x.as_interpolation()) {
+                    self.scan_expression(&expr.expression, ExpressionContext::Load)?;
+                    if let Some(format_spec) = &expr.format_spec {
+                        for element in format_spec.elements.interpolations() {
+                            self.scan_expression(&element.expression, ExpressionContext::Load)?
+                        }
+                    }
+                }
+            }
+            Expr::TString(tstring) => {
+                // Scan t-string interpolation expressions (similar to f-strings)
+                for expr in tstring
+                    .value
+                    .elements()
+                    .filter_map(|x| x.as_interpolation())
+                {
+                    self.scan_expression(&expr.expression, ExpressionContext::Load)?;
+                    if let Some(format_spec) = &expr.format_spec {
+                        for element in format_spec.elements.interpolations() {
+                            self.scan_expression(&element.expression, ExpressionContext::Load)?
+                        }
+                    }
+                }
+            }
+            // Constants
+            Expr::StringLiteral(_)
+            | Expr::BytesLiteral(_)
+            | Expr::NumberLiteral(_)
+            | Expr::BooleanLiteral(_)
+            | Expr::NoneLiteral(_)
+            | Expr::EllipsisLiteral(_) => {}
+            Expr::IpyEscapeCommand(_) => todo!(),
+            Expr::If(ExprIf {
+                test,
+                body,
+                orelse,
+                node_index: _,
+                range: _,
+            }) => {
+                self.scan_expression(test, ExpressionContext::Load)?;
+                self.scan_expression(body, ExpressionContext::Load)?;
+                self.scan_expression(orelse, ExpressionContext::Load)?;
+            }
+
+            Expr::Named(ExprNamed {
+                target,
+                value,
+                range,
+                node_index: _,
+            }) => {
+                // named expressions are not allowed in the definition of
+                // comprehension iterator definitions (including nested comprehensions)
+                if context == ExpressionContext::IterDefinitionExp || self.in_iter_def_exp {
+                    return Err(SymbolTableError {
+                          error: "assignment expression cannot be used in a comprehension iterable expression".to_string(),
+                          location: Some(self.source_file.to_source_code().source_location(target.range().start(), PositionEncoding::Utf8)),
+                      });
+                }
+
+                self.scan_expression(value, ExpressionContext::Load)?;
+
+                // special handling for assigned identifier in named expressions
+                // that are used in comprehensions. This required to correctly
+                // propagate the scope of the named assigned named and not to
+                // propagate inner names.
+                if let Expr::Name(ExprName { id, .. }) = &**target {
+                    let id = id.as_str();
+                    let table = self.tables.last().unwrap();
+                    if table.typ == CompilerScope::Comprehension {
+                        self.register_name(
+                            id,
+                            SymbolUsage::AssignedNamedExprInComprehension,
+                            *range,
+                        )?;
+                    } else {
+                        // omit one recursion. When the handling of an store changes for
+                        // Identifiers this needs adapted - more forward safe would be
+                        // calling scan_expression directly.
+                        self.register_name(id, SymbolUsage::Assigned, *range)?;
+                    }
+                } else {
+                    self.scan_expression(target, ExpressionContext::Store)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn scan_comprehension(
+        &mut self,
+        scope_name: &str,
+        elt1: &Expr,
+        elt2: Option<&Expr>,
+        generators: &[Comprehension],
+        range: TextRange,
+        is_generator: bool,
+    ) -> SymbolTableResult {
+        // Comprehensions are compiled as functions, so create a scope for them:
+        self.enter_scope(
+            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;
+        }
+
+        // Register the passed argument to the generator function as the name ".0"
+        self.register_name(".0", SymbolUsage::Parameter, range)?;
+
+        self.scan_expression(elt1, ExpressionContext::Load)?;
+        if let Some(elt2) = elt2 {
+            self.scan_expression(elt2, ExpressionContext::Load)?;
+        }
+
+        let mut is_first_generator = true;
+        for generator in generators {
+            // Set flag for INNER_LOOP_CONFLICT check (only for inner loops, not the first)
+            if !is_first_generator {
+                self.in_comp_inner_loop_target = true;
+            }
+            self.scan_expression(&generator.target, ExpressionContext::Iter)?;
+            self.in_comp_inner_loop_target = false;
+
+            if is_first_generator {
+                is_first_generator = false;
+            } else {
+                self.scan_expression(&generator.iter, ExpressionContext::IterDefinitionExp)?;
+            }
+
+            for if_expr in &generator.ifs {
+                self.scan_expression(if_expr, ExpressionContext::Load)?;
+            }
+        }
+
+        self.leave_scope();
+
+        // The first iterable is passed as an argument into the created function:
+        assert!(!generators.is_empty());
+        self.scan_expression(&generators[0].iter, ExpressionContext::IterDefinitionExp)?;
+
+        Ok(())
+    }
+
+    /// Scan type parameter bound or default in a separate scope
+    // = symtable_visit_type_param_bound_or_default
+    fn scan_type_param_bound_or_default(
+        &mut self,
+        expr: &Expr,
+        scope_name: &str,
+        scope_info: &'static str,
+    ) -> SymbolTableResult {
+        // Enter a new TypeParams scope for the bound/default expression
+        // This allows the expression to access outer scope symbols
+        let line_number = self.line_index_start(expr.range());
+        self.enter_scope(scope_name, CompilerScope::TypeParams, line_number);
+
+        // Note: In CPython, can_see_class_scope is preserved in the new scope
+        // In RustPython, this is handled through the scope hierarchy
+
+        // Set scope_info for better error messages
+        let old_scope_info = self.scope_info;
+        self.scope_info = Some(scope_info);
+
+        // Scan the expression in this new scope
+        let result = self.scan_expression(expr, ExpressionContext::Load);
+
+        // Restore scope_info and exit the scope
+        self.scope_info = old_scope_info;
+        self.leave_scope();
+
+        result
+    }
+
+    fn scan_type_params(&mut self, type_params: &TypeParams) -> SymbolTableResult {
+        // Check for duplicate type parameter names
+        let mut seen_names: std::collections::HashSet<&str> = std::collections::HashSet::new();
+        for type_param in &type_params.type_params {
+            let (name, range) = match type_param {
+                TypeParam::TypeVar(tv) => (tv.name.as_str(), tv.range),
+                TypeParam::ParamSpec(ps) => (ps.name.as_str(), ps.range),
+                TypeParam::TypeVarTuple(tvt) => (tvt.name.as_str(), tvt.range),
+            };
+            if !seen_names.insert(name) {
+                return Err(SymbolTableError {
+                    error: format!("duplicate type parameter '{}'", name),
+                    location: Some(
+                        self.source_file
+                            .to_source_code()
+                            .source_location(range.start(), PositionEncoding::Utf8),
+                    ),
+                });
+            }
+        }
+
+        // Register .type_params as a type parameter (automatically becomes cell variable)
+        self.register_name(".type_params", SymbolUsage::TypeParam, type_params.range)?;
+
+        // First register all type parameters
+        for type_param in &type_params.type_params {
+            match type_param {
+                TypeParam::TypeVar(TypeParamTypeVar {
+                    name,
+                    bound,
+                    range: type_var_range,
+                    default,
+                    node_index: _,
+                }) => {
+                    self.register_name(name.as_str(), SymbolUsage::TypeParam, *type_var_range)?;
+
+                    // Process bound in a separate scope
+                    if let Some(binding) = bound {
+                        let (scope_name, scope_info) = if binding.is_tuple_expr() {
+                            (
+                                format!("<TypeVar constraint of {name}>"),
+                                "a TypeVar constraint",
+                            )
+                        } else {
+                            (format!("<TypeVar bound of {name}>"), "a TypeVar bound")
+                        };
+                        self.scan_type_param_bound_or_default(binding, &scope_name, scope_info)?;
+                    }
+
+                    // Process default in a separate scope
+                    if let Some(default_value) = default {
+                        let scope_name = format!("<TypeVar default of {name}>");
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a TypeVar default",
+                        )?;
+                    }
+                }
+                TypeParam::ParamSpec(TypeParamParamSpec {
+                    name,
+                    range: param_spec_range,
+                    default,
+                    node_index: _,
+                }) => {
+                    self.register_name(name, SymbolUsage::TypeParam, *param_spec_range)?;
+
+                    // Process default in a separate scope
+                    if let Some(default_value) = default {
+                        let scope_name = format!("<ParamSpec default of {name}>");
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a ParamSpec default",
+                        )?;
+                    }
+                }
+                TypeParam::TypeVarTuple(TypeParamTypeVarTuple {
+                    name,
+                    range: type_var_tuple_range,
+                    default,
+                    node_index: _,
+                }) => {
+                    self.register_name(name, SymbolUsage::TypeParam, *type_var_tuple_range)?;
+
+                    // Process default in a separate scope
+                    if let Some(default_value) = default {
+                        let scope_name = format!("<TypeVarTuple default of {name}>");
+                        self.scan_type_param_bound_or_default(
+                            default_value,
+                            &scope_name,
+                            "a TypeVarTuple default",
+                        )?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn scan_patterns(&mut self, patterns: &[Pattern]) -> SymbolTableResult {
+        for pattern in patterns {
+            self.scan_pattern(pattern)?;
+        }
+        Ok(())
+    }
+
+    fn scan_pattern(&mut self, pattern: &Pattern) -> SymbolTableResult {
+        use Pattern::*;
+        match pattern {
+            MatchValue(PatternMatchValue { value, .. }) => {
+                self.scan_expression(value, ExpressionContext::Load)?
+            }
+            MatchSingleton(_) => {}
+            MatchSequence(PatternMatchSequence { patterns, .. }) => self.scan_patterns(patterns)?,
+            MatchMapping(PatternMatchMapping {
+                keys,
+                patterns,
+                rest,
+                ..
+            }) => {
+                self.scan_expressions(keys, ExpressionContext::Load)?;
+                self.scan_patterns(patterns)?;
+                if let Some(rest) = rest {
+                    self.register_ident(rest, SymbolUsage::Assigned)?;
+                }
+            }
+            MatchClass(PatternMatchClass { cls, arguments, .. }) => {
+                self.scan_expression(cls, ExpressionContext::Load)?;
+                self.scan_patterns(&arguments.patterns)?;
+                for kw in &arguments.keywords {
+                    self.scan_pattern(&kw.pattern)?;
+                }
+            }
+            MatchStar(PatternMatchStar { name, .. }) => {
+                if let Some(name) = name {
+                    self.register_ident(name, SymbolUsage::Assigned)?;
+                }
+            }
+            MatchAs(PatternMatchAs { pattern, name, .. }) => {
+                if let Some(pattern) = pattern {
+                    self.scan_pattern(pattern)?;
+                }
+                if let Some(name) = name {
+                    self.register_ident(name, SymbolUsage::Assigned)?;
+                }
+            }
+            MatchOr(PatternMatchOr { patterns, .. }) => self.scan_patterns(patterns)?,
+        }
+        Ok(())
+    }
+
+    fn enter_scope_with_parameters(
+        &mut self,
+        name: &str,
+        parameters: &Parameters,
+        line_number: u32,
+    ) -> 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?
+        }
+
+        // Annotations are scanned in outer scope:
+        for annotation in parameters
+            .posonlyargs
+            .iter()
+            .chain(parameters.args.iter())
+            .chain(parameters.kwonlyargs.iter())
+            .filter_map(|arg| arg.parameter.annotation.as_ref())
+        {
+            self.scan_annotation(annotation)?;
+        }
+        if let Some(annotation) = parameters
+            .vararg
+            .as_ref()
+            .and_then(|arg| arg.annotation.as_ref())
+        {
+            self.scan_annotation(annotation)?;
+        }
+        if let Some(annotation) = parameters
+            .kwarg
+            .as_ref()
+            .and_then(|arg| arg.annotation.as_ref())
+        {
+            self.scan_annotation(annotation)?;
+        }
+
+        self.enter_scope(name, CompilerScope::Function, line_number);
+
+        // Fill scope with parameter names:
+        self.scan_parameters(&parameters.posonlyargs)?;
+        self.scan_parameters(&parameters.args)?;
+        self.scan_parameters(&parameters.kwonlyargs)?;
+        if let Some(name) = &parameters.vararg {
+            self.scan_parameter(name)?;
+        }
+        if let Some(name) = &parameters.kwarg {
+            self.scan_parameter(name)?;
+        }
+        Ok(())
+    }
+
+    fn register_ident(&mut self, ident: &Identifier, role: SymbolUsage) -> SymbolTableResult {
+        self.register_name(ident.as_str(), role, ident.range)
+    }
+
+    fn register_name(
+        &mut self,
+        name: &str,
+        role: SymbolUsage,
+        range: TextRange,
+    ) -> SymbolTableResult {
+        let location = self
+            .source_file
+            .to_source_code()
+            .source_location(range.start(), PositionEncoding::Utf8);
+        let location = Some(location);
+        let scope_depth = self.tables.len();
+        let table = self.tables.last_mut().unwrap();
+
+        let name = mangle_name(self.class_name.as_deref(), 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;
+
+            // INNER_LOOP_CONFLICT: comprehension inner loop cannot rebind
+            // a variable that was used as a named expression target
+            // Example: [i for i in range(5) if (j := 0) for j in range(5)]
+            // Here 'j' is used in named expr first, then as inner loop iter target
+            if self.in_comp_inner_loop_target
+                && flags.contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
+            {
+                return Err(SymbolTableError {
+                    error: format!(
+                        "comprehension inner loop cannot rebind assignment expression target '{}'",
+                        name
+                    ),
+                    location,
+                });
+            }
+
+            // Role already set..
+            match role {
+                SymbolUsage::Global if !symbol.is_global() => {
+                    if flags.contains(SymbolFlags::PARAMETER) {
+                        return Err(SymbolTableError {
+                            error: format!("name '{name}' is parameter and global"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::REFERENCED) {
+                        return Err(SymbolTableError {
+                            error: format!("name '{name}' is used prior to global declaration"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::ANNOTATED) {
+                        return Err(SymbolTableError {
+                            error: format!("annotated name '{name}' can't be global"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::ASSIGNED) {
+                        return Err(SymbolTableError {
+                            error: format!(
+                                "name '{name}' is assigned to before global declaration"
+                            ),
+                            location,
+                        });
+                    }
+                }
+                SymbolUsage::Nonlocal => {
+                    if flags.contains(SymbolFlags::PARAMETER) {
+                        return Err(SymbolTableError {
+                            error: format!("name '{name}' is parameter and nonlocal"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::REFERENCED) {
+                        return Err(SymbolTableError {
+                            error: format!("name '{name}' is used prior to nonlocal declaration"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::ANNOTATED) {
+                        return Err(SymbolTableError {
+                            error: format!("annotated name '{name}' can't be nonlocal"),
+                            location,
+                        });
+                    }
+                    if flags.contains(SymbolFlags::ASSIGNED) {
+                        return Err(SymbolTableError {
+                            error: format!(
+                                "name '{name}' is assigned to before nonlocal declaration"
+                            ),
+                            location,
+                        });
+                    }
+                }
+                _ => {
+                    // Ok?
+                }
+            }
+            symbol
+        } else {
+            // The symbol does not present on this scope level.
+            // Some checks to insert new symbol into symbol table:
+            match role {
+                SymbolUsage::Nonlocal if scope_depth < 2 => {
+                    return Err(SymbolTableError {
+                        error: format!("cannot define nonlocal '{name}' at top level."),
+                        location,
+                    });
+                }
+                _ => {
+                    // Ok!
+                }
+            }
+            // Insert symbol when required:
+            let symbol = Symbol::new(name.as_ref());
+            table.symbols.entry(name.into_owned()).or_insert(symbol)
+        };
+
+        // Set proper scope and flags on symbol:
+        let flags = &mut symbol.flags;
+        match role {
+            SymbolUsage::Nonlocal => {
+                symbol.scope = SymbolScope::Free;
+                flags.insert(SymbolFlags::NONLOCAL);
+            }
+            SymbolUsage::Imported => {
+                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::IMPORTED);
+            }
+            SymbolUsage::Parameter => {
+                flags.insert(SymbolFlags::PARAMETER);
+                // Parameters are always added to varnames first
+                let name_str = symbol.name.clone();
+                if !self.current_varnames.contains(&name_str) {
+                    self.current_varnames.push(name_str);
+                }
+            }
+            SymbolUsage::AnnotationParameter => {
+                flags.insert(SymbolFlags::PARAMETER | SymbolFlags::ANNOTATED);
+                // Annotated parameters are also added to varnames
+                let name_str = symbol.name.clone();
+                if !self.current_varnames.contains(&name_str) {
+                    self.current_varnames.push(name_str);
+                }
+            }
+            SymbolUsage::AnnotationAssigned => {
+                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::ANNOTATED);
+            }
+            SymbolUsage::Assigned => {
+                flags.insert(SymbolFlags::ASSIGNED);
+                // Local variables (assigned) are added to varnames if they are local scope
+                // and not already in varnames
+                if symbol.scope == SymbolScope::Local {
+                    let name_str = symbol.name.clone();
+                    if !self.current_varnames.contains(&name_str) {
+                        self.current_varnames.push(name_str);
+                    }
+                }
+            }
+            SymbolUsage::AssignedNamedExprInComprehension => {
+                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::ASSIGNED_IN_COMPREHENSION);
+                // Named expressions in comprehensions might also be locals
+                if symbol.scope == SymbolScope::Local {
+                    let name_str = symbol.name.clone();
+                    if !self.current_varnames.contains(&name_str) {
+                        self.current_varnames.push(name_str);
+                    }
+                }
+            }
+            SymbolUsage::Global => {
+                symbol.scope = SymbolScope::GlobalExplicit;
+                flags.insert(SymbolFlags::GLOBAL);
+            }
+            SymbolUsage::Used => {
+                flags.insert(SymbolFlags::REFERENCED);
+            }
+            SymbolUsage::Iter => {
+                flags.insert(SymbolFlags::ITER);
+            }
+            SymbolUsage::TypeParam => {
+                flags.insert(SymbolFlags::ASSIGNED | SymbolFlags::TYPE_PARAM);
+            }
+        }
+
+        // and even more checking
+        // it is not allowed to assign to iterator variables (by named expressions)
+        if flags.contains(SymbolFlags::ITER)
+            && flags.contains(SymbolFlags::ASSIGNED_IN_COMPREHENSION)
+        {
+            return Err(SymbolTableError {
+                error: format!(
+                    "assignment expression cannot rebind comprehension iteration variable '{}'",
+                    symbol.name
+                ),
+                location,
+            });
+        }
+        Ok(())
+    }
+}
+
+pub(crate) fn mangle_name<'a>(class_name: Option<&str>, name: &'a str) -> Cow<'a, str> {
+    let class_name = match class_name {
+        Some(n) => n,
+        None => return name.into(),
+    };
+    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);
+    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()
+}
diff --git a/compiler/codegen/src/unparse.rs b/crates/codegen/src/unparse.rs
similarity index 88%
rename from compiler/codegen/src/unparse.rs
rename to crates/codegen/src/unparse.rs
index 47e883da3a..7b26d22918 100644
--- a/compiler/codegen/src/unparse.rs
+++ b/crates/codegen/src/unparse.rs
@@ -1,13 +1,12 @@
-use ruff_python_ast as ruff;
+use alloc::fmt;
+use core::fmt::Display as _;
+use ruff_python_ast::{
+    self as ruff, Arguments, BoolOp, Comprehension, ConversionFlag, Expr, Identifier, Operator,
+    Parameter, ParameterWithDefault, Parameters,
+};
 use ruff_text_size::Ranged;
-use rustpython_compiler_source::SourceCode;
+use rustpython_compiler_core::SourceFile;
 use rustpython_literal::escape::{AsciiEscape, UnicodeEscape};
-use std::fmt::{self, Display as _};
-
-use ruff::{
-    Arguments, BoolOp, Comprehension, ConversionFlag, Expr, Identifier, Operator, Parameter,
-    ParameterWithDefault, Parameters,
-};
 
 mod precedence {
     macro_rules! precedence {
@@ -29,28 +28,33 @@ mod precedence {
 
 struct Unparser<'a, 'b, 'c> {
     f: &'b mut fmt::Formatter<'a>,
-    source: &'c SourceCode<'c>,
+    source: &'c SourceFile,
 }
+
 impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
-    const fn new(f: &'b mut fmt::Formatter<'a>, source: &'c SourceCode<'c>) -> Self {
-        Unparser { f, source }
+    const fn new(f: &'b mut fmt::Formatter<'a>, source: &'c SourceFile) -> Self {
+        Self { f, source }
     }
 
     fn p(&mut self, s: &str) -> fmt::Result {
         self.f.write_str(s)
     }
+
     fn p_id(&mut self, s: &Identifier) -> fmt::Result {
         self.f.write_str(s.as_str())
     }
+
     fn p_if(&mut self, cond: bool, s: &str) -> fmt::Result {
         if cond {
             self.f.write_str(s)?;
         }
         Ok(())
     }
+
     fn p_delim(&mut self, first: &mut bool, s: &str) -> fmt::Result {
-        self.p_if(!std::mem::take(first), s)
+        self.p_if(!core::mem::take(first), s)
     }
+
     fn write_fmt(&mut self, f: fmt::Arguments<'_>) -> fmt::Result {
         self.f.write_fmt(f)
     }
@@ -82,6 +86,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::BoolOp(ruff::ExprBoolOp {
                 op,
                 values,
+                node_index: _,
                 range: _range,
             }) => {
                 let (op, prec) = op_prec!(bin, op, BoolOp, And("and", AND), Or("or", OR));
@@ -96,6 +101,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::Named(ruff::ExprNamed {
                 target,
                 value,
+                node_index: _,
                 range: _range,
             }) => {
                 group_if!(precedence::TUPLE, {
@@ -108,6 +114,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 left,
                 op,
                 right,
+                node_index: _,
                 range: _range,
             }) => {
                 let right_associative = matches!(op, Operator::Pow);
@@ -138,6 +145,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::UnaryOp(ruff::ExprUnaryOp {
                 op,
                 operand,
+                node_index: _,
                 range: _range,
             }) => {
                 let (op, prec) = op_prec!(
@@ -157,6 +165,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::Lambda(ruff::ExprLambda {
                 parameters,
                 body,
+                node_index: _,
                 range: _range,
             }) => {
                 group_if!(precedence::TEST, {
@@ -166,13 +175,14 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     } else {
                         self.p("lambda")?;
                     }
-                    write!(self, ": {}", unparse_expr(body, self.source))?;
+                    write!(self, ": {}", UnparseExpr::new(body, self.source))?;
                 })
             }
             Expr::If(ruff::ExprIf {
                 test,
                 body,
                 orelse,
+                node_index: _,
                 range: _range,
             }) => {
                 group_if!(precedence::TEST, {
@@ -185,6 +195,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             }
             Expr::Dict(ruff::ExprDict {
                 items,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("{")?;
@@ -192,7 +203,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 for item in items {
                     self.p_delim(&mut first, ", ")?;
                     if let Some(k) = &item.key {
-                        write!(self, "{}: ", unparse_expr(k, self.source))?;
+                        write!(self, "{}: ", UnparseExpr::new(k, self.source))?;
                     } else {
                         self.p("**")?;
                     }
@@ -202,6 +213,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             }
             Expr::Set(ruff::ExprSet {
                 elts,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("{")?;
@@ -215,6 +227,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::ListComp(ruff::ExprListComp {
                 elt,
                 generators,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("[")?;
@@ -225,6 +238,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::SetComp(ruff::ExprSetComp {
                 elt,
                 generators,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("{")?;
@@ -236,6 +250,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 key,
                 value,
                 generators,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("{")?;
@@ -249,6 +264,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 parenthesized: _,
                 elt,
                 generators,
+                node_index: _,
                 range: _range,
             }) => {
                 self.p("(")?;
@@ -258,6 +274,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             }
             Expr::Await(ruff::ExprAwait {
                 value,
+                node_index: _,
                 range: _range,
             }) => {
                 group_if!(precedence::AWAIT, {
@@ -267,24 +284,31 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             }
             Expr::Yield(ruff::ExprYield {
                 value,
+                node_index: _,
                 range: _range,
             }) => {
                 if let Some(value) = value {
-                    write!(self, "(yield {})", unparse_expr(value, self.source))?;
+                    write!(self, "(yield {})", UnparseExpr::new(value, self.source))?;
                 } else {
                     self.p("(yield)")?;
                 }
             }
             Expr::YieldFrom(ruff::ExprYieldFrom {
                 value,
+                node_index: _,
                 range: _range,
             }) => {
-                write!(self, "(yield from {})", unparse_expr(value, self.source))?;
+                write!(
+                    self,
+                    "(yield from {})",
+                    UnparseExpr::new(value, self.source)
+                )?;
             }
             Expr::Compare(ruff::ExprCompare {
                 left,
                 ops,
                 comparators,
+                node_index: _,
                 range: _range,
             }) => {
                 group_if!(precedence::CMP, {
@@ -301,6 +325,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
             Expr::Call(ruff::ExprCall {
                 func,
                 arguments: Arguments { args, keywords, .. },
+                node_index: _,
                 range: _range,
             }) => {
                 self.unparse_expr(func, precedence::ATOM)?;
@@ -310,6 +335,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                         Expr::Generator(ruff::ExprGenerator {
                             elt,
                             generators,
+                            node_index: _,
                             range: _range,
                             ..
                         }),
@@ -340,6 +366,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 self.p(")")?;
             }
             Expr::FString(ruff::ExprFString { value, .. }) => self.unparse_fstring(value)?,
+            Expr::TString(_) => self.p("t\"\"")?,
             Expr::StringLiteral(ruff::ExprStringLiteral { value, .. }) => {
                 if value.is_unicode() {
                     self.p("u")?
@@ -354,7 +381,11 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                     .fmt(self.f)?
             }
             Expr::NumberLiteral(ruff::ExprNumberLiteral { value, .. }) => {
-                const { assert!(f64::MAX_10_EXP == 308) };
+                #[allow(clippy::correctness, clippy::assertions_on_constants)]
+                const {
+                    assert!(f64::MAX_10_EXP == 308)
+                };
+
                 let inf_str = "1e309";
                 match value {
                     ruff::Number::Int(int) => int.fmt(self.f)?,
@@ -428,6 +459,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 lower,
                 upper,
                 step,
+                node_index: _,
                 range: _range,
             }) => {
                 if let Some(lower) = lower {
@@ -461,7 +493,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         if let Some(vararg) = &args.vararg {
             self.unparse_arg(vararg)?;
         }
-        for kwarg in args.kwonlyargs.iter() {
+        for kwarg in &args.kwonlyargs {
             self.p_delim(&mut first, ", ")?;
             self.unparse_function_arg(kwarg)?;
         }
@@ -475,7 +507,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
     fn unparse_function_arg(&mut self, arg: &ParameterWithDefault) -> fmt::Result {
         self.unparse_arg(&arg.parameter)?;
         if let Some(default) = &arg.default {
-            write!(self, "={}", unparse_expr(default, self.source))?;
+            write!(self, "={}", UnparseExpr::new(default, self.source))?;
         }
         Ok(())
     }
@@ -483,7 +515,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
     fn unparse_arg(&mut self, arg: &Parameter) -> fmt::Result {
         self.p_id(&arg.name)?;
         if let Some(ann) = &arg.annotation {
-            write!(self, ": {}", unparse_expr(ann, self.source))?;
+            write!(self, ": {}", UnparseExpr::new(ann, self.source))?;
         }
         Ok(())
     }
@@ -506,7 +538,10 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_fstring_body(&mut self, elements: &[ruff::FStringElement]) -> fmt::Result {
+    fn unparse_fstring_body(
+        &mut self,
+        elements: &[ruff::InterpolatedStringElement],
+    ) -> fmt::Result {
         for elem in elements {
             self.unparse_fstring_elem(elem)?;
         }
@@ -518,14 +553,14 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         val: &Expr,
         debug_text: Option<&ruff::DebugText>,
         conversion: ConversionFlag,
-        spec: Option<&ruff::FStringFormatSpec>,
+        spec: Option<&ruff::InterpolatedStringFormatSpec>,
     ) -> fmt::Result {
         let buffered = to_string_fmt(|f| {
             Unparser::new(f, self.source).unparse_expr(val, precedence::TEST + 1)
         });
         if let Some(ruff::DebugText { leading, trailing }) = debug_text {
             self.p(leading)?;
-            self.p(self.source.get_range(val.range()))?;
+            self.p(self.source.slice(val.range()))?;
             self.p(trailing)?;
         }
         let brace = if buffered.starts_with('{') {
@@ -541,7 +576,7 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         if conversion != ConversionFlag::None {
             self.p("!")?;
             let buf = &[conversion as u8];
-            let c = std::str::from_utf8(buf).unwrap();
+            let c = core::str::from_utf8(buf).unwrap();
             self.p(c)?;
         }
 
@@ -555,9 +590,9 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
         Ok(())
     }
 
-    fn unparse_fstring_elem(&mut self, elem: &ruff::FStringElement) -> fmt::Result {
+    fn unparse_fstring_elem(&mut self, elem: &ruff::InterpolatedStringElement) -> fmt::Result {
         match elem {
-            ruff::FStringElement::Expression(ruff::FStringExpressionElement {
+            ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
                 expression,
                 debug_text,
                 conversion,
@@ -569,9 +604,10 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
                 *conversion,
                 format_spec.as_deref(),
             ),
-            ruff::FStringElement::Literal(ruff::FStringLiteralElement { value, .. }) => {
-                self.unparse_fstring_str(value)
-            }
+            ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+                value,
+                ..
+            }) => self.unparse_fstring_str(value),
         }
     }
 
@@ -599,11 +635,13 @@ impl<'a, 'b, 'c> Unparser<'a, 'b, 'c> {
 
 pub struct UnparseExpr<'a> {
     expr: &'a Expr,
-    source: &'a SourceCode<'a>,
+    source: &'a SourceFile,
 }
 
-pub const fn unparse_expr<'a>(expr: &'a Expr, source: &'a SourceCode<'a>) -> UnparseExpr<'a> {
-    UnparseExpr { expr, source }
+impl<'a> UnparseExpr<'a> {
+    pub const fn new(expr: &'a Expr, source: &'a SourceFile) -> Self {
+        Self { expr, source }
+    }
 }
 
 impl fmt::Display for UnparseExpr<'_> {
@@ -613,7 +651,7 @@ impl fmt::Display for UnparseExpr<'_> {
 }
 
 fn to_string_fmt(f: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result) -> String {
-    use std::cell::Cell;
+    use core::cell::Cell;
     struct Fmt<F>(Cell<Option<F>>);
     impl<F: FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for Fmt<F> {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/common/Cargo.toml b/crates/common/Cargo.toml
new file mode 100644
index 0000000000..9fd7ea3880
--- /dev/null
+++ b/crates/common/Cargo.toml
@@ -0,0 +1,53 @@
+[package]
+name = "rustpython-common"
+description = "General python functions and algorithms for use in RustPython"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[features]
+threading = ["parking_lot"]
+wasm_js = ["getrandom/wasm_js"]
+
+[dependencies]
+rustpython-literal = { workspace = true }
+rustpython-wtf8 = { workspace = true }
+
+ascii = { workspace = true }
+bitflags = { workspace = true }
+cfg-if = { workspace = true }
+getrandom = { workspace = true }
+itertools = { workspace = true }
+libc = { workspace = true }
+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 }
+
+lock_api = "0.4"
+siphasher = "1"
+num-complex.workspace = true
+
+[target.'cfg(unix)'.dependencies]
+nix = { workspace = true }
+
+[target.'cfg(windows)'.dependencies]
+widestring = { workspace = true }
+windows-sys = { workspace = true, features = [
+    "Win32_Foundation",
+    "Win32_Networking_WinSock",
+    "Win32_Storage_FileSystem",
+    "Win32_System_Ioctl",
+    "Win32_System_LibraryLoader",
+    "Win32_System_SystemServices",
+] }
+
+[lints]
+workspace = true
diff --git a/common/src/atomic.rs b/crates/common/src/atomic.rs
similarity index 100%
rename from common/src/atomic.rs
rename to crates/common/src/atomic.rs
diff --git a/common/src/borrow.rs b/crates/common/src/borrow.rs
similarity index 98%
rename from common/src/borrow.rs
rename to crates/common/src/borrow.rs
index 610084006e..d8389479b3 100644
--- a/common/src/borrow.rs
+++ b/crates/common/src/borrow.rs
@@ -2,10 +2,8 @@ use crate::lock::{
     MapImmutable, PyImmutableMappedMutexGuard, PyMappedMutexGuard, PyMappedRwLockReadGuard,
     PyMappedRwLockWriteGuard, PyMutexGuard, PyRwLockReadGuard, PyRwLockWriteGuard,
 };
-use std::{
-    fmt,
-    ops::{Deref, DerefMut},
-};
+use alloc::fmt;
+use core::ops::{Deref, DerefMut};
 
 macro_rules! impl_from {
     ($lt:lifetime, $gen:ident, $t:ty, $($var:ident($from:ty),)*) => {
diff --git a/common/src/boxvec.rs b/crates/common/src/boxvec.rs
similarity index 98%
rename from common/src/boxvec.rs
rename to crates/common/src/boxvec.rs
index 4f3928e56b..3260e76ca8 100644
--- a/common/src/boxvec.rs
+++ b/crates/common/src/boxvec.rs
@@ -2,13 +2,13 @@
 //! An unresizable vector backed by a `Box<[T]>`
 
 #![allow(clippy::needless_lifetimes)]
-
-use std::{
+use alloc::{fmt, slice};
+use core::{
     borrow::{Borrow, BorrowMut},
-    cmp, fmt,
+    cmp,
     mem::{self, MaybeUninit},
     ops::{Bound, Deref, DerefMut, RangeBounds},
-    ptr, slice,
+    ptr,
 };
 
 pub struct BoxVec<T> {
@@ -165,7 +165,7 @@ impl<T> BoxVec<T> {
         if index >= self.len() {
             None
         } else {
-            self.drain(index..index + 1).next()
+            self.drain(index..=index).next()
         }
     }
 
@@ -555,7 +555,7 @@ impl<T> Extend<T> for BoxVec<T> {
             };
             let mut iter = iter.into_iter();
             loop {
-                if std::ptr::eq(ptr, end_ptr) {
+                if core::ptr::eq(ptr, end_ptr) {
                     break;
                 }
                 if let Some(elt) = iter.next() {
@@ -693,7 +693,7 @@ impl<T> CapacityError<T> {
 
 const CAPERROR: &str = "insufficient capacity";
 
-impl<T> std::error::Error for CapacityError<T> {}
+impl<T> core::error::Error for CapacityError<T> {}
 
 impl<T> fmt::Display for CapacityError<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/crates/common/src/cformat.rs b/crates/common/src/cformat.rs
new file mode 100644
index 0000000000..24332396fd
--- /dev/null
+++ b/crates/common/src/cformat.rs
@@ -0,0 +1,1164 @@
+//! Implementation of Printf-Style string formatting
+//! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
+use alloc::fmt;
+use bitflags::bitflags;
+use core::{
+    cmp,
+    iter::{Enumerate, Peekable},
+    str::FromStr,
+};
+use itertools::Itertools;
+use malachite_bigint::{BigInt, Sign};
+use num_traits::Signed;
+use rustpython_literal::{float, format::Case};
+
+use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
+
+#[derive(Debug, PartialEq)]
+pub enum CFormatErrorType {
+    UnmatchedKeyParentheses,
+    MissingModuloSign,
+    UnsupportedFormatChar(CodePoint),
+    IncompleteFormat,
+    IntTooBig,
+    // Unimplemented,
+}
+
+// also contains how many chars the parsing function consumed
+pub type ParsingError = (CFormatErrorType, usize);
+
+#[derive(Debug, PartialEq)]
+pub struct CFormatError {
+    pub typ: CFormatErrorType, // FIXME
+    pub index: usize,
+}
+
+impl fmt::Display for CFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CFormatErrorType::*;
+        match self.typ {
+            UnmatchedKeyParentheses => write!(f, "incomplete format key"),
+            IncompleteFormat => write!(f, "incomplete format"),
+            UnsupportedFormatChar(c) => write!(
+                f,
+                "unsupported format character '{}' ({:#x}) at index {}",
+                c,
+                c.to_u32(),
+                self.index
+            ),
+            IntTooBig => write!(f, "width/precision too big"),
+            _ => write!(f, "unexpected error parsing format string"),
+        }
+    }
+}
+
+pub type CFormatConversion = super::format::FormatConversion;
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[repr(u8)]
+pub enum CNumberType {
+    DecimalD = b'd',
+    DecimalI = b'i',
+    DecimalU = b'u',
+    Octal = b'o',
+    HexLower = b'x',
+    HexUpper = b'X',
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[repr(u8)]
+pub enum CFloatType {
+    ExponentLower = b'e',
+    ExponentUpper = b'E',
+    PointDecimalLower = b'f',
+    PointDecimalUpper = b'F',
+    GeneralLower = b'g',
+    GeneralUpper = b'G',
+}
+
+impl CFloatType {
+    const fn case(self) -> Case {
+        use CFloatType::*;
+
+        match self {
+            ExponentLower | PointDecimalLower | GeneralLower => Case::Lower,
+            ExponentUpper | PointDecimalUpper | GeneralUpper => Case::Upper,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[repr(u8)]
+pub enum CCharacterType {
+    Character = b'c',
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum CFormatType {
+    Number(CNumberType),
+    Float(CFloatType),
+    Character(CCharacterType),
+    String(CFormatConversion),
+}
+
+impl CFormatType {
+    pub const fn to_char(self) -> char {
+        match self {
+            Self::Number(x) => x as u8 as char,
+            Self::Float(x) => x as u8 as char,
+            Self::Character(x) => x as u8 as char,
+            Self::String(x) => x as u8 as char,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum CFormatPrecision {
+    Quantity(CFormatQuantity),
+    Dot,
+}
+
+impl From<CFormatQuantity> for CFormatPrecision {
+    fn from(quantity: CFormatQuantity) -> Self {
+        Self::Quantity(quantity)
+    }
+}
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct CConversionFlags: u32 {
+        const ALTERNATE_FORM = 0b0000_0001;
+        const ZERO_PAD = 0b0000_0010;
+        const LEFT_ADJUST = 0b0000_0100;
+        const BLANK_SIGN = 0b0000_1000;
+        const SIGN_CHAR = 0b0001_0000;
+    }
+}
+
+impl CConversionFlags {
+    #[inline]
+    pub const fn sign_string(&self) -> &'static str {
+        if self.contains(Self::SIGN_CHAR) {
+            "+"
+        } else if self.contains(Self::BLANK_SIGN) {
+            " "
+        } else {
+            ""
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum CFormatQuantity {
+    Amount(usize),
+    FromValuesTuple,
+}
+
+pub trait FormatBuf:
+    Extend<Self::Char> + Default + FromIterator<Self::Char> + From<String>
+{
+    type Char: FormatChar;
+    fn chars(&self) -> impl Iterator<Item = Self::Char>;
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    fn concat(self, other: Self) -> Self;
+}
+
+pub trait FormatChar: Copy + Into<CodePoint> + From<u8> {
+    fn to_char_lossy(self) -> char;
+    fn eq_char(self, c: char) -> bool;
+}
+
+impl FormatBuf for String {
+    type Char = char;
+
+    fn chars(&self) -> impl Iterator<Item = Self::Char> {
+        (**self).chars()
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+
+    fn concat(mut self, other: Self) -> Self {
+        self.extend([other]);
+        self
+    }
+}
+
+impl FormatChar for char {
+    fn to_char_lossy(self) -> char {
+        self
+    }
+
+    fn eq_char(self, c: char) -> bool {
+        self == c
+    }
+}
+
+impl FormatBuf for Wtf8Buf {
+    type Char = CodePoint;
+
+    fn chars(&self) -> impl Iterator<Item = Self::Char> {
+        self.code_points()
+    }
+
+    fn len(&self) -> usize {
+        (**self).len()
+    }
+
+    fn concat(mut self, other: Self) -> Self {
+        self.extend([other]);
+        self
+    }
+}
+
+impl FormatChar for CodePoint {
+    fn to_char_lossy(self) -> char {
+        self.to_char_lossy()
+    }
+
+    fn eq_char(self, c: char) -> bool {
+        self == c
+    }
+}
+
+impl FormatBuf for Vec<u8> {
+    type Char = u8;
+
+    fn chars(&self) -> impl Iterator<Item = Self::Char> {
+        self.iter().copied()
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+
+    fn concat(mut self, other: Self) -> Self {
+        self.extend(other);
+        self
+    }
+}
+
+impl FormatChar for u8 {
+    fn to_char_lossy(self) -> char {
+        self.into()
+    }
+
+    fn eq_char(self, c: char) -> bool {
+        char::from(self) == c
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub struct CFormatSpec {
+    pub flags: CConversionFlags,
+    pub min_field_width: Option<CFormatQuantity>,
+    pub precision: Option<CFormatPrecision>,
+    pub format_type: CFormatType,
+    // chars_consumed: usize,
+}
+
+#[derive(Debug, PartialEq)]
+pub struct CFormatSpecKeyed<T> {
+    pub mapping_key: Option<T>,
+    pub spec: CFormatSpec,
+}
+
+#[cfg(test)]
+impl FromStr for CFormatSpec {
+    type Err = ParsingError;
+
+    fn from_str(text: &str) -> Result<Self, Self::Err> {
+        text.parse::<CFormatSpecKeyed<String>>()
+            .map(|CFormatSpecKeyed { mapping_key, spec }| {
+                assert!(mapping_key.is_none());
+                spec
+            })
+    }
+}
+
+impl FromStr for CFormatSpecKeyed<String> {
+    type Err = ParsingError;
+
+    fn from_str(text: &str) -> Result<Self, Self::Err> {
+        let mut chars = text.chars().enumerate().peekable();
+        if chars.next().map(|x| x.1) != Some('%') {
+            return Err((CFormatErrorType::MissingModuloSign, 1));
+        }
+
+        Self::parse(&mut chars)
+    }
+}
+
+pub type ParseIter<I> = Peekable<Enumerate<I>>;
+
+impl<T: FormatBuf> CFormatSpecKeyed<T> {
+    pub fn parse<I>(iter: &mut ParseIter<I>) -> Result<Self, ParsingError>
+    where
+        I: Iterator<Item = T::Char>,
+    {
+        let mapping_key = parse_spec_mapping_key(iter)?;
+        let flags = parse_flags(iter);
+        let min_field_width = parse_quantity(iter)?;
+        let precision = parse_precision(iter)?;
+        consume_length(iter);
+        let format_type = parse_format_type(iter)?;
+
+        let spec = CFormatSpec {
+            flags,
+            min_field_width,
+            precision,
+            format_type,
+        };
+        Ok(Self { mapping_key, spec })
+    }
+}
+
+impl CFormatSpec {
+    fn compute_fill_string<T: FormatBuf>(fill_char: T::Char, fill_chars_needed: usize) -> T {
+        (0..fill_chars_needed).map(|_| fill_char).collect()
+    }
+
+    fn fill_string<T: FormatBuf>(
+        &self,
+        string: T,
+        fill_char: T::Char,
+        num_prefix_chars: Option<usize>,
+    ) -> T {
+        let mut num_chars = string.chars().count();
+        if let Some(num_prefix_chars) = num_prefix_chars {
+            num_chars += num_prefix_chars;
+        }
+        let num_chars = num_chars;
+
+        let width = match &self.min_field_width {
+            Some(CFormatQuantity::Amount(width)) => cmp::max(width, &num_chars),
+            _ => &num_chars,
+        };
+        let fill_chars_needed = width.saturating_sub(num_chars);
+        let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
+
+        if !fill_string.is_empty() {
+            if self.flags.contains(CConversionFlags::LEFT_ADJUST) {
+                string.concat(fill_string)
+            } else {
+                fill_string.concat(string)
+            }
+        } else {
+            string
+        }
+    }
+
+    fn fill_string_with_precision<T: FormatBuf>(&self, string: T, fill_char: T::Char) -> T {
+        let num_chars = string.chars().count();
+
+        let width = match &self.precision {
+            Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(width))) => {
+                cmp::max(width, &num_chars)
+            }
+            _ => &num_chars,
+        };
+        let fill_chars_needed = width.saturating_sub(num_chars);
+        let fill_string: T = Self::compute_fill_string(fill_char, fill_chars_needed);
+
+        if !fill_string.is_empty() {
+            // Don't left-adjust if precision-filling: that will always be prepending 0s to %d
+            // arguments, the LEFT_ADJUST flag will be used by a later call to fill_string with
+            // the 0-filled string as the string param.
+            fill_string.concat(string)
+        } else {
+            string
+        }
+    }
+
+    fn format_string_with_precision<T: FormatBuf>(
+        &self,
+        string: T,
+        precision: Option<&CFormatPrecision>,
+    ) -> T {
+        // truncate if needed
+        let string = match precision {
+            Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(precision)))
+                if string.chars().count() > *precision =>
+            {
+                string.chars().take(*precision).collect::<T>()
+            }
+            Some(CFormatPrecision::Dot) => {
+                // truncate to 0
+                T::default()
+            }
+            _ => string,
+        };
+        self.fill_string(string, b' '.into(), None)
+    }
+
+    #[inline]
+    pub fn format_string<T: FormatBuf>(&self, string: T) -> T {
+        self.format_string_with_precision(string, self.precision.as_ref())
+    }
+
+    #[inline]
+    pub fn format_char<T: FormatBuf>(&self, ch: T::Char) -> T {
+        self.format_string_with_precision(
+            T::from_iter([ch]),
+            Some(&(CFormatQuantity::Amount(1).into())),
+        )
+    }
+
+    pub fn format_bytes(&self, bytes: &[u8]) -> Vec<u8> {
+        let bytes = if let Some(CFormatPrecision::Quantity(CFormatQuantity::Amount(precision))) =
+            self.precision
+        {
+            &bytes[..cmp::min(bytes.len(), precision)]
+        } else {
+            bytes
+        };
+        if let Some(CFormatQuantity::Amount(width)) = self.min_field_width {
+            let fill = cmp::max(0, width - bytes.len());
+            let mut v = Vec::with_capacity(bytes.len() + fill);
+            if self.flags.contains(CConversionFlags::LEFT_ADJUST) {
+                v.extend_from_slice(bytes);
+                v.append(&mut vec![b' '; fill]);
+            } else {
+                v.append(&mut vec![b' '; fill]);
+                v.extend_from_slice(bytes);
+            }
+            v
+        } else {
+            bytes.to_vec()
+        }
+    }
+
+    pub fn format_number(&self, num: &BigInt) -> String {
+        use CNumberType::*;
+        let CFormatType::Number(format_type) = self.format_type else {
+            unreachable!()
+        };
+        let magnitude = num.abs();
+        let prefix = if self.flags.contains(CConversionFlags::ALTERNATE_FORM) {
+            match format_type {
+                Octal => "0o",
+                HexLower => "0x",
+                HexUpper => "0X",
+                _ => "",
+            }
+        } else {
+            ""
+        };
+
+        let magnitude_string: String = match format_type {
+            DecimalD | DecimalI | DecimalU => magnitude.to_str_radix(10),
+            Octal => magnitude.to_str_radix(8),
+            HexLower => magnitude.to_str_radix(16),
+            HexUpper => {
+                let mut result = magnitude.to_str_radix(16);
+                result.make_ascii_uppercase();
+                result
+            }
+        };
+
+        let sign_string = match num.sign() {
+            Sign::Minus => "-",
+            _ => self.flags.sign_string(),
+        };
+
+        let padded_magnitude_string = self.fill_string_with_precision(magnitude_string, '0');
+
+        if self.flags.contains(CConversionFlags::ZERO_PAD) {
+            let fill_char = if !self.flags.contains(CConversionFlags::LEFT_ADJUST) {
+                '0'
+            } else {
+                ' ' // '-' overrides the '0' conversion if both are given
+            };
+            let signed_prefix = format!("{sign_string}{prefix}");
+            format!(
+                "{}{}",
+                signed_prefix,
+                self.fill_string(
+                    padded_magnitude_string,
+                    fill_char,
+                    Some(signed_prefix.chars().count()),
+                ),
+            )
+        } else {
+            self.fill_string(
+                format!("{sign_string}{prefix}{padded_magnitude_string}"),
+                ' ',
+                None,
+            )
+        }
+    }
+
+    pub fn format_float(&self, num: f64) -> String {
+        let sign_string = if num.is_sign_negative() && !num.is_nan() {
+            "-"
+        } else {
+            self.flags.sign_string()
+        };
+
+        let precision = match &self.precision {
+            Some(CFormatPrecision::Quantity(quantity)) => match quantity {
+                CFormatQuantity::Amount(amount) => *amount,
+                CFormatQuantity::FromValuesTuple => 6,
+            },
+            Some(CFormatPrecision::Dot) => 0,
+            None => 6,
+        };
+
+        let CFormatType::Float(format_type) = self.format_type else {
+            unreachable!()
+        };
+
+        let magnitude = num.abs();
+        let case = format_type.case();
+
+        let magnitude_string = match format_type {
+            CFloatType::PointDecimalLower | CFloatType::PointDecimalUpper => float::format_fixed(
+                precision,
+                magnitude,
+                case,
+                self.flags.contains(CConversionFlags::ALTERNATE_FORM),
+            ),
+            CFloatType::ExponentLower | CFloatType::ExponentUpper => float::format_exponent(
+                precision,
+                magnitude,
+                case,
+                self.flags.contains(CConversionFlags::ALTERNATE_FORM),
+            ),
+            CFloatType::GeneralLower | CFloatType::GeneralUpper => {
+                let precision = if precision == 0 { 1 } else { precision };
+                float::format_general(
+                    precision,
+                    magnitude,
+                    case,
+                    self.flags.contains(CConversionFlags::ALTERNATE_FORM),
+                    false,
+                )
+            }
+        };
+
+        if self.flags.contains(CConversionFlags::ZERO_PAD) {
+            let fill_char = if !self.flags.contains(CConversionFlags::LEFT_ADJUST) {
+                '0'
+            } else {
+                ' '
+            };
+            format!(
+                "{}{}",
+                sign_string,
+                self.fill_string(
+                    magnitude_string,
+                    fill_char,
+                    Some(sign_string.chars().count()),
+                )
+            )
+        } else {
+            self.fill_string(format!("{sign_string}{magnitude_string}"), ' ', None)
+        }
+    }
+}
+
+fn parse_spec_mapping_key<T, I>(iter: &mut ParseIter<I>) -> Result<Option<T>, ParsingError>
+where
+    T: FormatBuf,
+    I: Iterator<Item = T::Char>,
+{
+    if let Some((index, _)) = iter.next_if(|(_, c)| c.eq_char('(')) {
+        return match parse_text_inside_parentheses(iter) {
+            Some(key) => Ok(Some(key)),
+            None => Err((CFormatErrorType::UnmatchedKeyParentheses, index)),
+        };
+    }
+    Ok(None)
+}
+
+fn parse_flags<C, I>(iter: &mut ParseIter<I>) -> CConversionFlags
+where
+    C: FormatChar,
+    I: Iterator<Item = C>,
+{
+    let mut flags = CConversionFlags::empty();
+    iter.peeking_take_while(|(_, c)| {
+        let flag = match c.to_char_lossy() {
+            '#' => CConversionFlags::ALTERNATE_FORM,
+            '0' => CConversionFlags::ZERO_PAD,
+            '-' => CConversionFlags::LEFT_ADJUST,
+            ' ' => CConversionFlags::BLANK_SIGN,
+            '+' => CConversionFlags::SIGN_CHAR,
+            _ => return false,
+        };
+        flags |= flag;
+        true
+    })
+    .for_each(drop);
+    flags
+}
+
+fn consume_length<C, I>(iter: &mut ParseIter<I>)
+where
+    C: FormatChar,
+    I: Iterator<Item = C>,
+{
+    iter.next_if(|(_, c)| matches!(c.to_char_lossy(), 'h' | 'l' | 'L'));
+}
+
+fn parse_format_type<C, I>(iter: &mut ParseIter<I>) -> Result<CFormatType, ParsingError>
+where
+    C: FormatChar,
+    I: Iterator<Item = C>,
+{
+    use CFloatType::*;
+    use CNumberType::*;
+    let (index, c) = iter.next().ok_or_else(|| {
+        (
+            CFormatErrorType::IncompleteFormat,
+            iter.peek().map(|x| x.0).unwrap_or(0),
+        )
+    })?;
+    let format_type = match c.to_char_lossy() {
+        'd' => CFormatType::Number(DecimalD),
+        'i' => CFormatType::Number(DecimalI),
+        'u' => CFormatType::Number(DecimalU),
+        'o' => CFormatType::Number(Octal),
+        'x' => CFormatType::Number(HexLower),
+        'X' => CFormatType::Number(HexUpper),
+        'e' => CFormatType::Float(ExponentLower),
+        'E' => CFormatType::Float(ExponentUpper),
+        'f' => CFormatType::Float(PointDecimalLower),
+        'F' => CFormatType::Float(PointDecimalUpper),
+        'g' => CFormatType::Float(GeneralLower),
+        'G' => CFormatType::Float(GeneralUpper),
+        'c' => CFormatType::Character(CCharacterType::Character),
+        'r' => CFormatType::String(CFormatConversion::Repr),
+        's' => CFormatType::String(CFormatConversion::Str),
+        'b' => CFormatType::String(CFormatConversion::Bytes),
+        'a' => CFormatType::String(CFormatConversion::Ascii),
+        _ => return Err((CFormatErrorType::UnsupportedFormatChar(c.into()), index)),
+    };
+    Ok(format_type)
+}
+
+fn parse_quantity<C, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatQuantity>, ParsingError>
+where
+    C: FormatChar,
+    I: Iterator<Item = C>,
+{
+    if let Some(&(_, c)) = iter.peek() {
+        if c.eq_char('*') {
+            iter.next().unwrap();
+            return Ok(Some(CFormatQuantity::FromValuesTuple));
+        }
+        if let Some(i) = c.to_char_lossy().to_digit(10) {
+            let mut num = i as i32;
+            iter.next().unwrap();
+            while let Some(&(index, c)) = iter.peek() {
+                if let Some(i) = c.to_char_lossy().to_digit(10) {
+                    num = num
+                        .checked_mul(10)
+                        .and_then(|num| num.checked_add(i as i32))
+                        .ok_or((CFormatErrorType::IntTooBig, index))?;
+                    iter.next().unwrap();
+                } else {
+                    break;
+                }
+            }
+            return Ok(Some(CFormatQuantity::Amount(num.unsigned_abs() as usize)));
+        }
+    }
+    Ok(None)
+}
+
+fn parse_precision<C, I>(iter: &mut ParseIter<I>) -> Result<Option<CFormatPrecision>, ParsingError>
+where
+    C: FormatChar,
+    I: Iterator<Item = C>,
+{
+    if iter.next_if(|(_, c)| c.eq_char('.')).is_some() {
+        let quantity = parse_quantity(iter)?;
+        let precision = quantity.map_or(CFormatPrecision::Dot, CFormatPrecision::Quantity);
+        return Ok(Some(precision));
+    }
+    Ok(None)
+}
+
+fn parse_text_inside_parentheses<T, I>(iter: &mut ParseIter<I>) -> Option<T>
+where
+    T: FormatBuf,
+    I: Iterator<Item = T::Char>,
+{
+    let mut counter: i32 = 1;
+    let mut contained_text = T::default();
+    loop {
+        let (_, c) = iter.next()?;
+        match c.to_char_lossy() {
+            '(' => {
+                counter += 1;
+            }
+            ')' => {
+                counter -= 1;
+            }
+            _ => (),
+        }
+
+        if counter > 0 {
+            contained_text.extend([c]);
+        } else {
+            break;
+        }
+    }
+
+    Some(contained_text)
+}
+
+#[derive(Debug, PartialEq)]
+pub enum CFormatPart<T> {
+    Literal(T),
+    Spec(CFormatSpecKeyed<T>),
+}
+
+impl<T> CFormatPart<T> {
+    #[inline]
+    pub const fn is_specifier(&self) -> bool {
+        matches!(self, Self::Spec { .. })
+    }
+
+    #[inline]
+    pub const fn has_key(&self) -> bool {
+        match self {
+            Self::Spec(s) => s.mapping_key.is_some(),
+            _ => false,
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct CFormatStrOrBytes<S> {
+    parts: Vec<(usize, CFormatPart<S>)>,
+}
+
+impl<S> CFormatStrOrBytes<S> {
+    pub fn check_specifiers(&self) -> Option<(usize, bool)> {
+        let mut count = 0;
+        let mut mapping_required = false;
+        for (_, part) in &self.parts {
+            if part.is_specifier() {
+                let has_key = part.has_key();
+                if count == 0 {
+                    mapping_required = has_key;
+                } else if mapping_required != has_key {
+                    return None;
+                }
+                count += 1;
+            }
+        }
+        Some((count, mapping_required))
+    }
+
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = &(usize, CFormatPart<S>)> {
+        self.parts.iter()
+    }
+
+    #[inline]
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (usize, CFormatPart<S>)> {
+        self.parts.iter_mut()
+    }
+
+    pub fn parse<I>(iter: &mut ParseIter<I>) -> Result<Self, CFormatError>
+    where
+        S: FormatBuf,
+        I: Iterator<Item = S::Char>,
+    {
+        let mut parts = vec![];
+        let mut literal = S::default();
+        let mut part_index = 0;
+        while let Some((index, c)) = iter.next() {
+            if c.eq_char('%') {
+                if let Some(&(_, second)) = iter.peek() {
+                    if second.eq_char('%') {
+                        iter.next().unwrap();
+                        literal.extend([second]);
+                        continue;
+                    } else {
+                        if !literal.is_empty() {
+                            parts.push((
+                                part_index,
+                                CFormatPart::Literal(core::mem::take(&mut literal)),
+                            ));
+                        }
+                        let spec = CFormatSpecKeyed::parse(iter).map_err(|err| CFormatError {
+                            typ: err.0,
+                            index: err.1,
+                        })?;
+                        parts.push((index, CFormatPart::Spec(spec)));
+                        if let Some(&(index, _)) = iter.peek() {
+                            part_index = index;
+                        }
+                    }
+                } else {
+                    return Err(CFormatError {
+                        typ: CFormatErrorType::IncompleteFormat,
+                        index: index + 1,
+                    });
+                }
+            } else {
+                literal.extend([c]);
+            }
+        }
+        if !literal.is_empty() {
+            parts.push((part_index, CFormatPart::Literal(literal)));
+        }
+        Ok(Self { parts })
+    }
+}
+
+impl<S> IntoIterator for CFormatStrOrBytes<S> {
+    type Item = (usize, CFormatPart<S>);
+    type IntoIter = alloc::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.parts.into_iter()
+    }
+}
+
+pub type CFormatBytes = CFormatStrOrBytes<Vec<u8>>;
+
+impl CFormatBytes {
+    pub fn parse_from_bytes(bytes: &[u8]) -> Result<Self, CFormatError> {
+        let mut iter = bytes.iter().cloned().enumerate().peekable();
+        Self::parse(&mut iter)
+    }
+}
+
+pub type CFormatString = CFormatStrOrBytes<String>;
+
+impl FromStr for CFormatString {
+    type Err = CFormatError;
+
+    fn from_str(text: &str) -> Result<Self, Self::Err> {
+        let mut iter = text.chars().enumerate().peekable();
+        Self::parse(&mut iter)
+    }
+}
+
+pub type CFormatWtf8 = CFormatStrOrBytes<Wtf8Buf>;
+
+impl CFormatWtf8 {
+    pub fn parse_from_wtf8(s: &Wtf8) -> Result<Self, CFormatError> {
+        let mut iter = s.code_points().enumerate().peekable();
+        Self::parse(&mut iter)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fill_and_align() {
+        assert_eq!(
+            "%10s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("test".to_owned()),
+            "      test".to_owned()
+        );
+        assert_eq!(
+            "%-10s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("test".to_owned()),
+            "test      ".to_owned()
+        );
+        assert_eq!(
+            "%#10x"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(0x1337)),
+            "    0x1337".to_owned()
+        );
+        assert_eq!(
+            "%-#10x"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(0x1337)),
+            "0x1337    ".to_owned()
+        );
+    }
+
+    #[test]
+    fn test_parse_key() {
+        let expected = Ok(CFormatSpecKeyed {
+            mapping_key: Some("amount".to_owned()),
+            spec: CFormatSpec {
+                format_type: CFormatType::Number(CNumberType::DecimalD),
+                min_field_width: None,
+                precision: None,
+                flags: CConversionFlags::empty(),
+            },
+        });
+        assert_eq!("%(amount)d".parse::<CFormatSpecKeyed<String>>(), expected);
+
+        let expected = Ok(CFormatSpecKeyed {
+            mapping_key: Some("m((u(((l((((ti))))p)))l))e".to_owned()),
+            spec: CFormatSpec {
+                format_type: CFormatType::Number(CNumberType::DecimalD),
+                min_field_width: None,
+                precision: None,
+                flags: CConversionFlags::empty(),
+            },
+        });
+        assert_eq!(
+            "%(m((u(((l((((ti))))p)))l))e)d".parse::<CFormatSpecKeyed<String>>(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_format_parse_key_fail() {
+        assert_eq!(
+            "%(aged".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::UnmatchedKeyParentheses,
+                index: 1
+            })
+        );
+    }
+
+    #[test]
+    fn test_format_parse_type_fail() {
+        assert_eq!(
+            "Hello %n".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::UnsupportedFormatChar('n'.into()),
+                index: 7
+            })
+        );
+    }
+
+    #[test]
+    fn test_incomplete_format_fail() {
+        assert_eq!(
+            "Hello %".parse::<CFormatString>(),
+            Err(CFormatError {
+                typ: CFormatErrorType::IncompleteFormat,
+                index: 7
+            })
+        );
+    }
+
+    #[test]
+    fn test_parse_flags() {
+        let expected = Ok(CFormatSpec {
+            format_type: CFormatType::Number(CNumberType::DecimalD),
+            min_field_width: Some(CFormatQuantity::Amount(10)),
+            precision: None,
+            flags: CConversionFlags::all(),
+        });
+        let parsed = "%  0   -+++###10d".parse::<CFormatSpec>();
+        assert_eq!(parsed, expected);
+        assert_eq!(
+            parsed.unwrap().format_number(&BigInt::from(12)),
+            "+12       ".to_owned()
+        );
+    }
+
+    #[test]
+    fn test_parse_and_format_string() {
+        assert_eq!(
+            "%5.4s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("Hello, World!".to_owned()),
+            " Hell".to_owned()
+        );
+        assert_eq!(
+            "%-5.4s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("Hello, World!".to_owned()),
+            "Hell ".to_owned()
+        );
+        assert_eq!(
+            "%.s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("Hello, World!".to_owned()),
+            "".to_owned()
+        );
+        assert_eq!(
+            "%5.s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("Hello, World!".to_owned()),
+            "     ".to_owned()
+        );
+    }
+
+    #[test]
+    fn test_parse_and_format_unicode_string() {
+        assert_eq!(
+            "%.2s"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_string("❤❤❤❤❤❤❤❤".to_owned()),
+            "❤❤".to_owned()
+        );
+    }
+
+    #[test]
+    fn test_parse_and_format_number() {
+        assert_eq!(
+            "%5d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(27)),
+            "   27".to_owned()
+        );
+        assert_eq!(
+            "%05d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(27)),
+            "00027".to_owned()
+        );
+        assert_eq!(
+            "%.5d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(27)),
+            "00027".to_owned()
+        );
+        assert_eq!(
+            "%+05d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(27)),
+            "+0027".to_owned()
+        );
+        assert_eq!(
+            "%-d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(-27)),
+            "-27".to_owned()
+        );
+        assert_eq!(
+            "% d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(27)),
+            " 27".to_owned()
+        );
+        assert_eq!(
+            "% d"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(-27)),
+            "-27".to_owned()
+        );
+        assert_eq!(
+            "%08x"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(0x1337)),
+            "00001337".to_owned()
+        );
+        assert_eq!(
+            "%#010x"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(0x1337)),
+            "0x00001337".to_owned()
+        );
+        assert_eq!(
+            "%-#010x"
+                .parse::<CFormatSpec>()
+                .unwrap()
+                .format_number(&BigInt::from(0x1337)),
+            "0x1337    ".to_owned()
+        );
+    }
+
+    #[test]
+    fn test_parse_and_format_float() {
+        assert_eq!(
+            "%f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            "1.234500"
+        );
+        assert_eq!(
+            "%.2f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            "1.23"
+        );
+        assert_eq!(
+            "%.f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            "1"
+        );
+        assert_eq!(
+            "%+.f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            "+1"
+        );
+        assert_eq!(
+            "%+f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            "+1.234500"
+        );
+        assert_eq!(
+            "% f".parse::<CFormatSpec>().unwrap().format_float(1.2345),
+            " 1.234500"
+        );
+        assert_eq!(
+            "%f".parse::<CFormatSpec>().unwrap().format_float(-1.2345),
+            "-1.234500"
+        );
+        assert_eq!(
+            "%f".parse::<CFormatSpec>()
+                .unwrap()
+                .format_float(1.2345678901),
+            "1.234568"
+        );
+    }
+
+    #[test]
+    fn test_format_parse() {
+        let fmt = "Hello, my name is %s and I'm %d years old";
+        let expected = Ok(CFormatString {
+            parts: vec![
+                (0, CFormatPart::Literal("Hello, my name is ".to_owned())),
+                (
+                    18,
+                    CFormatPart::Spec(CFormatSpecKeyed {
+                        mapping_key: None,
+                        spec: CFormatSpec {
+                            format_type: CFormatType::String(CFormatConversion::Str),
+                            min_field_width: None,
+                            precision: None,
+                            flags: CConversionFlags::empty(),
+                        },
+                    }),
+                ),
+                (20, CFormatPart::Literal(" and I'm ".to_owned())),
+                (
+                    29,
+                    CFormatPart::Spec(CFormatSpecKeyed {
+                        mapping_key: None,
+                        spec: CFormatSpec {
+                            format_type: CFormatType::Number(CNumberType::DecimalD),
+                            min_field_width: None,
+                            precision: None,
+                            flags: CConversionFlags::empty(),
+                        },
+                    }),
+                ),
+                (31, CFormatPart::Literal(" years old".to_owned())),
+            ],
+        });
+        let result = fmt.parse::<CFormatString>();
+        assert_eq!(
+            result, expected,
+            "left = {result:#?} \n\n\n right = {expected:#?}"
+        );
+    }
+}
diff --git a/crates/common/src/crt_fd.rs b/crates/common/src/crt_fd.rs
new file mode 100644
index 0000000000..1902a362e3
--- /dev/null
+++ b/crates/common/src/crt_fd.rs
@@ -0,0 +1,414 @@
+//! A module implementing an io type backed by the C runtime's file descriptors, i.e. what's
+//! returned from libc::open, even on windows.
+
+use alloc::fmt;
+use core::cmp;
+use std::{ffi, io};
+
+#[cfg(not(windows))]
+use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
+#[cfg(windows)]
+use std::os::windows::io::BorrowedHandle;
+
+mod c {
+    pub(super) use libc::*;
+
+    #[cfg(windows)]
+    pub(super) use libc::commit as fsync;
+    #[cfg(windows)]
+    unsafe extern "C" {
+        #[link_name = "_chsize_s"]
+        pub(super) fn ftruncate(fd: i32, len: i64) -> i32;
+    }
+}
+
+// this is basically what CPython has for Py_off_t; windows uses long long
+// for offsets, other platforms just use off_t
+#[cfg(not(windows))]
+pub type Offset = c::off_t;
+#[cfg(windows)]
+pub type Offset = c::c_longlong;
+
+#[cfg(not(windows))]
+pub type Raw = RawFd;
+#[cfg(windows)]
+pub type Raw = i32;
+
+#[inline]
+fn cvt<I: num_traits::PrimInt>(ret: I) -> io::Result<I> {
+    if ret < I::zero() {
+        // CRT functions set errno, not GetLastError(), so use errno_io_error
+        Err(crate::os::errno_io_error())
+    } else {
+        Ok(ret)
+    }
+}
+
+fn cvt_fd(ret: Raw) -> io::Result<Owned> {
+    cvt(ret).map(|fd| unsafe { Owned::from_raw(fd) })
+}
+
+const MAX_RW: usize = if cfg!(any(windows, target_vendor = "apple")) {
+    i32::MAX as usize
+} else {
+    isize::MAX as usize
+};
+
+#[cfg(not(windows))]
+type OwnedInner = OwnedFd;
+#[cfg(not(windows))]
+type BorrowedInner<'fd> = BorrowedFd<'fd>;
+
+#[cfg(windows)]
+mod win {
+    use super::*;
+    use std::marker::PhantomData;
+    use std::mem::ManuallyDrop;
+
+    #[repr(transparent)]
+    pub(super) struct OwnedInner(i32);
+
+    impl OwnedInner {
+        #[inline]
+        pub unsafe fn from_raw_fd(fd: Raw) -> Self {
+            Self(fd)
+        }
+        #[inline]
+        pub fn as_raw_fd(&self) -> Raw {
+            self.0
+        }
+        #[inline]
+        pub fn into_raw_fd(self) -> Raw {
+            let me = ManuallyDrop::new(self);
+            me.0
+        }
+    }
+
+    impl Drop for OwnedInner {
+        #[inline]
+        fn drop(&mut self) {
+            let _ = _close(self.0);
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    #[repr(transparent)]
+    pub(super) struct BorrowedInner<'fd> {
+        fd: Raw,
+        _marker: PhantomData<&'fd Owned>,
+    }
+
+    impl BorrowedInner<'_> {
+        #[inline]
+        pub const unsafe fn borrow_raw(fd: Raw) -> Self {
+            Self {
+                fd,
+                _marker: PhantomData,
+            }
+        }
+        #[inline]
+        pub fn as_raw_fd(&self) -> Raw {
+            self.fd
+        }
+    }
+}
+
+#[cfg(windows)]
+use self::win::{BorrowedInner, OwnedInner};
+
+#[repr(transparent)]
+pub struct Owned {
+    inner: OwnedInner,
+}
+
+impl fmt::Debug for Owned {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("crt_fd::Owned")
+            .field(&self.as_raw())
+            .finish()
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct Borrowed<'fd> {
+    inner: BorrowedInner<'fd>,
+}
+
+impl<'fd> PartialEq for Borrowed<'fd> {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_raw() == other.as_raw()
+    }
+}
+impl<'fd> Eq for Borrowed<'fd> {}
+
+impl fmt::Debug for Borrowed<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("crt_fd::Borrowed")
+            .field(&self.as_raw())
+            .finish()
+    }
+}
+
+impl Owned {
+    /// Create a `crt_fd::Owned` from a raw file descriptor.
+    ///
+    /// # Safety
+    ///
+    /// `fd` must be a valid file descriptor.
+    #[inline]
+    pub unsafe fn from_raw(fd: Raw) -> Self {
+        let inner = unsafe { OwnedInner::from_raw_fd(fd) };
+        Self { inner }
+    }
+
+    /// Create a `crt_fd::Owned` from a raw file descriptor.
+    ///
+    /// Returns an error if `fd` is -1.
+    ///
+    /// # Safety
+    ///
+    /// `fd` must be a valid file descriptor.
+    #[inline]
+    pub unsafe fn try_from_raw(fd: Raw) -> io::Result<Self> {
+        if fd == -1 {
+            Err(ebadf())
+        } else {
+            Ok(unsafe { Self::from_raw(fd) })
+        }
+    }
+
+    #[inline]
+    pub fn borrow(&self) -> Borrowed<'_> {
+        unsafe { Borrowed::borrow_raw(self.as_raw()) }
+    }
+
+    #[inline]
+    pub fn as_raw(&self) -> Raw {
+        self.inner.as_raw_fd()
+    }
+
+    #[inline]
+    pub fn into_raw(self) -> Raw {
+        self.inner.into_raw_fd()
+    }
+
+    pub fn leak<'fd>(self) -> Borrowed<'fd> {
+        unsafe { Borrowed::borrow_raw(self.into_raw()) }
+    }
+}
+
+#[cfg(unix)]
+impl From<Owned> for OwnedFd {
+    fn from(fd: Owned) -> Self {
+        fd.inner
+    }
+}
+
+#[cfg(unix)]
+impl From<OwnedFd> for Owned {
+    fn from(fd: OwnedFd) -> Self {
+        Self { inner: fd }
+    }
+}
+
+#[cfg(unix)]
+impl AsFd for Owned {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.inner.as_fd()
+    }
+}
+
+#[cfg(unix)]
+impl AsRawFd for Owned {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_raw()
+    }
+}
+
+#[cfg(unix)]
+impl FromRawFd for Owned {
+    unsafe fn from_raw_fd(fd: RawFd) -> Self {
+        unsafe { Self::from_raw(fd) }
+    }
+}
+
+#[cfg(unix)]
+impl IntoRawFd for Owned {
+    fn into_raw_fd(self) -> RawFd {
+        self.into_raw()
+    }
+}
+
+impl<'fd> Borrowed<'fd> {
+    /// Create a `crt_fd::Borrowed` from a raw file descriptor.
+    ///
+    /// # Safety
+    ///
+    /// `fd` must be a valid file descriptor.
+    #[inline]
+    pub const unsafe fn borrow_raw(fd: Raw) -> Self {
+        let inner = unsafe { BorrowedInner::borrow_raw(fd) };
+        Self { inner }
+    }
+
+    /// Create a `crt_fd::Borrowed` from a raw file descriptor.
+    ///
+    /// Returns an error if `fd` is -1.
+    ///
+    /// # Safety
+    ///
+    /// `fd` must be a valid file descriptor.
+    #[inline]
+    pub unsafe fn try_borrow_raw(fd: Raw) -> io::Result<Self> {
+        if fd == -1 {
+            Err(ebadf())
+        } else {
+            Ok(unsafe { Self::borrow_raw(fd) })
+        }
+    }
+
+    #[inline]
+    pub fn as_raw(self) -> Raw {
+        self.inner.as_raw_fd()
+    }
+}
+
+#[cfg(unix)]
+impl<'fd> From<Borrowed<'fd>> for BorrowedFd<'fd> {
+    fn from(fd: Borrowed<'fd>) -> Self {
+        fd.inner
+    }
+}
+
+#[cfg(unix)]
+impl<'fd> From<BorrowedFd<'fd>> for Borrowed<'fd> {
+    fn from(fd: BorrowedFd<'fd>) -> Self {
+        Self { inner: fd }
+    }
+}
+
+#[cfg(unix)]
+impl AsFd for Borrowed<'_> {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.inner.as_fd()
+    }
+}
+
+#[cfg(unix)]
+impl AsRawFd for Borrowed<'_> {
+    fn as_raw_fd(&self) -> RawFd {
+        self.as_raw()
+    }
+}
+
+#[inline]
+fn ebadf() -> io::Error {
+    io::Error::from_raw_os_error(c::EBADF)
+}
+
+pub fn open(path: &ffi::CStr, flags: i32, mode: i32) -> io::Result<Owned> {
+    cvt_fd(unsafe { c::open(path.as_ptr(), flags, mode) })
+}
+
+#[cfg(windows)]
+pub fn wopen(path: &widestring::WideCStr, flags: i32, mode: i32) -> io::Result<Owned> {
+    cvt_fd(unsafe { suppress_iph!(c::wopen(path.as_ptr(), flags, mode)) })
+}
+
+#[cfg(all(any(unix, target_os = "wasi"), not(target_os = "redox")))]
+pub fn openat(dir: Borrowed<'_>, path: &ffi::CStr, flags: i32, mode: i32) -> io::Result<Owned> {
+    cvt_fd(unsafe { c::openat(dir.as_raw(), path.as_ptr(), flags, mode) })
+}
+
+pub fn fsync(fd: Borrowed<'_>) -> io::Result<()> {
+    cvt(unsafe { suppress_iph!(c::fsync(fd.as_raw())) })?;
+    Ok(())
+}
+
+fn _close(fd: Raw) -> io::Result<()> {
+    cvt(unsafe { suppress_iph!(c::close(fd)) })?;
+    Ok(())
+}
+
+pub fn close(fd: Owned) -> io::Result<()> {
+    _close(fd.into_raw())
+}
+
+pub fn ftruncate(fd: Borrowed<'_>, len: Offset) -> io::Result<()> {
+    let ret = unsafe { suppress_iph!(c::ftruncate(fd.as_raw(), len)) };
+    // On Windows, _chsize_s returns 0 on success, or a positive error code (errno value) on failure.
+    // On other platforms, ftruncate returns 0 on success, or -1 on failure with errno set.
+    #[cfg(windows)]
+    {
+        if ret != 0 {
+            // _chsize_s returns errno directly, convert to Windows error code
+            let winerror = crate::os::errno_to_winerror(ret);
+            return Err(io::Error::from_raw_os_error(winerror));
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        cvt(ret)?;
+    }
+    Ok(())
+}
+
+#[cfg(windows)]
+pub fn as_handle(fd: Borrowed<'_>) -> io::Result<BorrowedHandle<'_>> {
+    use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE};
+    unsafe extern "C" {
+        fn _get_osfhandle(fd: Borrowed<'_>) -> c::intptr_t;
+    }
+    let handle = unsafe { suppress_iph!(_get_osfhandle(fd)) };
+    if handle as HANDLE == INVALID_HANDLE_VALUE {
+        // _get_osfhandle is a CRT function that sets errno, not GetLastError()
+        Err(crate::os::errno_io_error())
+    } else {
+        Ok(unsafe { BorrowedHandle::borrow_raw(handle as _) })
+    }
+}
+
+fn _write(fd: Raw, buf: &[u8]) -> io::Result<usize> {
+    let count = cmp::min(buf.len(), MAX_RW);
+    let n = cvt(unsafe { suppress_iph!(c::write(fd, buf.as_ptr() as _, count as _)) })?;
+    Ok(n as usize)
+}
+
+fn _read(fd: Raw, buf: &mut [u8]) -> io::Result<usize> {
+    let count = cmp::min(buf.len(), MAX_RW);
+    let n = cvt(unsafe { suppress_iph!(libc::read(fd, buf.as_mut_ptr() as _, count as _)) })?;
+    Ok(n as usize)
+}
+
+pub fn write(fd: Borrowed<'_>, buf: &[u8]) -> io::Result<usize> {
+    _write(fd.as_raw(), buf)
+}
+
+pub fn read(fd: Borrowed<'_>, buf: &mut [u8]) -> io::Result<usize> {
+    _read(fd.as_raw(), buf)
+}
+
+macro_rules! impl_rw {
+    ($t:ty) => {
+        impl io::Write for $t {
+            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+                _write(self.as_raw(), buf)
+            }
+
+            #[inline]
+            fn flush(&mut self) -> io::Result<()> {
+                Ok(())
+            }
+        }
+
+        impl io::Read for $t {
+            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+                _read(self.as_raw(), buf)
+            }
+        }
+    };
+}
+
+impl_rw!(Owned);
+impl_rw!(Borrowed<'_>);
diff --git a/common/src/encodings.rs b/crates/common/src/encodings.rs
similarity index 99%
rename from common/src/encodings.rs
rename to crates/common/src/encodings.rs
index 39ca266126..d54581eb9e 100644
--- a/common/src/encodings.rs
+++ b/crates/common/src/encodings.rs
@@ -1,4 +1,4 @@
-use std::ops::{self, Range};
+use core::ops::{self, Range};
 
 use num_traits::ToPrimitive;
 
@@ -260,7 +260,7 @@ pub mod errors {
     use crate::str::UnicodeEscapeCodepoint;
 
     use super::*;
-    use std::fmt::Write;
+    use core::fmt::Write;
 
     pub struct Strict;
 
diff --git a/common/src/fileutils.rs b/crates/common/src/fileutils.rs
similarity index 78%
rename from common/src/fileutils.rs
rename to crates/common/src/fileutils.rs
index e9a93947c1..7170b270d9 100644
--- a/common/src/fileutils.rs
+++ b/crates/common/src/fileutils.rs
@@ -8,12 +8,12 @@ pub use libc::stat as StatStruct;
 pub use windows::{StatStruct, fstat};
 
 #[cfg(not(windows))]
-pub fn fstat(fd: libc::c_int) -> std::io::Result<StatStruct> {
-    let mut stat = std::mem::MaybeUninit::uninit();
+pub fn fstat(fd: crate::crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
+    let mut stat = core::mem::MaybeUninit::uninit();
     unsafe {
-        let ret = libc::fstat(fd, stat.as_mut_ptr());
+        let ret = libc::fstat(fd.as_raw(), stat.as_mut_ptr());
         if ret == -1 {
-            Err(crate::os::last_os_error())
+            Err(crate::os::errno_io_error())
         } else {
             Ok(stat.assume_init())
         }
@@ -22,15 +22,14 @@ pub fn fstat(fd: libc::c_int) -> std::io::Result<StatStruct> {
 
 #[cfg(windows)]
 pub mod windows {
-    use crate::suppress_iph;
+    use crate::crt_fd;
     use crate::windows::ToWideString;
     use libc::{S_IFCHR, S_IFDIR, S_IFMT};
     use std::ffi::{CString, OsStr, OsString};
-    use std::os::windows::ffi::OsStrExt;
+    use std::os::windows::io::AsRawHandle;
     use std::sync::OnceLock;
     use windows_sys::Win32::Foundation::{
-        BOOL, ERROR_INVALID_HANDLE, ERROR_NOT_SUPPORTED, FILETIME, FreeLibrary, HANDLE,
-        INVALID_HANDLE_VALUE, SetLastError,
+        ERROR_INVALID_HANDLE, ERROR_NOT_SUPPORTED, FILETIME, FreeLibrary, SetLastError,
     };
     use windows_sys::Win32::Storage::FileSystem::{
         BY_HANDLE_FILE_INFORMATION, FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_READONLY,
@@ -75,45 +74,31 @@ pub mod windows {
         pub fn update_st_mode_from_path(&mut self, path: &OsStr, attr: u32) {
             if attr & FILE_ATTRIBUTE_DIRECTORY == 0 {
                 let file_extension = path
-                    .encode_wide()
-                    .collect::<Vec<u16>>()
+                    .to_wide()
                     .split(|&c| c == '.' as u16)
                     .next_back()
                     .and_then(|s| String::from_utf16(s).ok());
 
-                if let Some(file_extension) = file_extension {
-                    if file_extension.eq_ignore_ascii_case("exe")
+                if let Some(file_extension) = file_extension
+                    && (file_extension.eq_ignore_ascii_case("exe")
                         || file_extension.eq_ignore_ascii_case("bat")
                         || file_extension.eq_ignore_ascii_case("cmd")
-                        || file_extension.eq_ignore_ascii_case("com")
-                    {
-                        self.st_mode |= 0o111;
-                    }
+                        || file_extension.eq_ignore_ascii_case("com"))
+                {
+                    self.st_mode |= 0o111;
                 }
             }
         }
     }
 
-    unsafe extern "C" {
-        fn _get_osfhandle(fd: i32) -> libc::intptr_t;
-    }
-
-    fn get_osfhandle(fd: i32) -> std::io::Result<isize> {
-        let ret = unsafe { suppress_iph!(_get_osfhandle(fd)) };
-        if ret as HANDLE == INVALID_HANDLE_VALUE {
-            Err(crate::os::last_os_error())
-        } else {
-            Ok(ret)
-        }
-    }
-
     // _Py_fstat_noraise in cpython
-    pub fn fstat(fd: libc::c_int) -> std::io::Result<StatStruct> {
-        let h = get_osfhandle(fd);
+    pub fn fstat(fd: crt_fd::Borrowed<'_>) -> std::io::Result<StatStruct> {
+        let h = crt_fd::as_handle(fd);
         if h.is_err() {
             unsafe { SetLastError(ERROR_INVALID_HANDLE) };
         }
         let h = h?;
+        let h = h.as_raw_handle();
         // reset stat?
 
         let file_type = unsafe { GetFileType(h as _) };
@@ -180,7 +165,7 @@ pub mod windows {
     }
 
     fn file_time_to_time_t_nsec(in_ptr: &FILETIME) -> (libc::time_t, libc::c_int) {
-        let in_val: i64 = unsafe { std::mem::transmute_copy(in_ptr) };
+        let in_val: i64 = unsafe { core::mem::transmute_copy(in_ptr) };
         let nsec_out = (in_val % 10_000_000) * 100; // FILETIME is in units of 100 nsec.
         let time_out = (in_val / 10_000_000) - SECS_BETWEEN_EPOCHS;
         (time_out, nsec_out as _)
@@ -219,7 +204,7 @@ pub mod windows {
         let st_nlink = info.nNumberOfLinks as i32;
 
         let st_ino = if let Some(id_info) = id_info {
-            let file_id: [u64; 2] = unsafe { std::mem::transmute_copy(&id_info.FileId) };
+            let file_id: [u64; 2] = unsafe { core::mem::transmute_copy(&id_info.FileId) };
             file_id
         } else {
             let ino = ((info.nFileIndexHigh as u64) << 32) + info.nFileIndexLow as u64;
@@ -312,13 +297,14 @@ pub mod windows {
                     FILE_INFO_BY_NAME_CLASS,
                     *mut libc::c_void,
                     u32,
-                ) -> BOOL,
+                ) -> i32,
             >,
         > = OnceLock::new();
 
         let GetFileInformationByName = GET_FILE_INFORMATION_BY_NAME
             .get_or_init(|| {
-                let library_name = OsString::from("api-ms-win-core-file-l2-1-4").to_wide_with_nul();
+                let library_name =
+                    OsString::from("api-ms-win-core-file-l2-1-4.dll").to_wide_with_nul();
                 let module = unsafe { LoadLibraryW(library_name.as_ptr()) };
                 if module.is_null() {
                     return None;
@@ -328,7 +314,7 @@ pub mod windows {
                     unsafe { GetProcAddress(module, name.as_bytes_with_nul().as_ptr()) }
                 {
                     Some(unsafe {
-                        std::mem::transmute::<
+                        core::mem::transmute::<
                             unsafe extern "system" fn() -> isize,
                             unsafe extern "system" fn(
                                 *const u16,
@@ -451,3 +437,93 @@ pub mod windows {
         }
     }
 }
+
+// _Py_fopen_obj in cpython (Python/fileutils.c:1757-1835)
+// Open a file using std::fs::File and convert to FILE*
+// Automatically handles path encoding and EINTR retries
+pub fn fopen(path: &std::path::Path, mode: &str) -> std::io::Result<*mut libc::FILE> {
+    use alloc::ffi::CString;
+    use std::fs::File;
+
+    // Currently only supports read mode
+    // Can be extended to support "wb", "w+b", etc. if needed
+    if mode != "rb" {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            format!("unsupported mode: {}", mode),
+        ));
+    }
+
+    // Open file using std::fs::File (handles path encoding and EINTR automatically)
+    let file = File::open(path)?;
+
+    #[cfg(windows)]
+    {
+        use std::os::windows::io::IntoRawHandle;
+
+        // Convert File handle to CRT file descriptor
+        let handle = file.into_raw_handle();
+        let fd = unsafe { libc::open_osfhandle(handle as isize, libc::O_RDONLY) };
+        if fd == -1 {
+            return Err(std::io::Error::last_os_error());
+        }
+
+        // Convert fd to FILE*
+        let mode_cstr = CString::new(mode).unwrap();
+        let fp = unsafe { libc::fdopen(fd, mode_cstr.as_ptr()) };
+        if fp.is_null() {
+            unsafe { libc::close(fd) };
+            return Err(std::io::Error::last_os_error());
+        }
+
+        // Set non-inheritable (Windows needs this explicitly)
+        if let Err(e) = set_inheritable(fd, false) {
+            unsafe { libc::fclose(fp) };
+            return Err(e);
+        }
+
+        Ok(fp)
+    }
+
+    #[cfg(not(windows))]
+    {
+        use std::os::fd::IntoRawFd;
+
+        // Convert File to raw fd
+        let fd = file.into_raw_fd();
+
+        // Convert fd to FILE*
+        let mode_cstr = CString::new(mode).unwrap();
+        let fp = unsafe { libc::fdopen(fd, mode_cstr.as_ptr()) };
+        if fp.is_null() {
+            unsafe { libc::close(fd) };
+            return Err(std::io::Error::last_os_error());
+        }
+
+        // Unix: O_CLOEXEC is already set by File::open, so non-inheritable is automatic
+        Ok(fp)
+    }
+}
+
+// set_inheritable in cpython (Python/fileutils.c:1443-1570)
+// Set the inheritable flag of the specified file descriptor
+// Only used on Windows; Unix automatically sets O_CLOEXEC
+#[cfg(windows)]
+fn set_inheritable(fd: libc::c_int, inheritable: bool) -> std::io::Result<()> {
+    use windows_sys::Win32::Foundation::{
+        HANDLE, HANDLE_FLAG_INHERIT, INVALID_HANDLE_VALUE, SetHandleInformation,
+    };
+
+    let handle = unsafe { libc::get_osfhandle(fd) };
+    if handle == INVALID_HANDLE_VALUE as isize {
+        return Err(std::io::Error::last_os_error());
+    }
+
+    let flags = if inheritable { HANDLE_FLAG_INHERIT } else { 0 };
+    let result = unsafe { SetHandleInformation(handle as HANDLE, HANDLE_FLAG_INHERIT, flags) };
+    if result == 0 {
+        return Err(std::io::Error::last_os_error());
+    }
+
+    Ok(())
+}
diff --git a/common/src/float_ops.rs b/crates/common/src/float_ops.rs
similarity index 100%
rename from common/src/float_ops.rs
rename to crates/common/src/float_ops.rs
diff --git a/crates/common/src/format.rs b/crates/common/src/format.rs
new file mode 100644
index 0000000000..1afee519ae
--- /dev/null
+++ b/crates/common/src/format.rs
@@ -0,0 +1,1528 @@
+// spell-checker:ignore ddfe
+use core::ops::Deref;
+use core::{cmp, str::FromStr};
+use itertools::{Itertools, PeekingNext};
+use malachite_base::num::basic::floats::PrimitiveFloat;
+use malachite_bigint::{BigInt, Sign};
+use num_complex::Complex64;
+use num_traits::FromPrimitive;
+use num_traits::{Signed, cast::ToPrimitive};
+use rustpython_literal::float;
+use rustpython_literal::format::Case;
+
+use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
+
+trait FormatParse {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8)
+    where
+        Self: Sized;
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[repr(u8)]
+pub enum FormatConversion {
+    Str = b's',
+    Repr = b'r',
+    Ascii = b'b',
+    Bytes = b'a',
+}
+
+impl FormatParse for FormatConversion {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
+        let Some(conversion) = Self::from_string(text) else {
+            return (None, text);
+        };
+        let mut chars = text.code_points();
+        chars.next(); // Consume the bang
+        chars.next(); // Consume one r,s,a char
+        (Some(conversion), chars.as_wtf8())
+    }
+}
+
+impl FormatConversion {
+    pub fn from_char(c: CodePoint) -> Option<Self> {
+        match c.to_char_lossy() {
+            's' => Some(Self::Str),
+            'r' => Some(Self::Repr),
+            'a' => Some(Self::Ascii),
+            'b' => Some(Self::Bytes),
+            _ => None,
+        }
+    }
+
+    fn from_string(text: &Wtf8) -> Option<Self> {
+        let mut chars = text.code_points();
+        if chars.next()? != '!' {
+            return None;
+        }
+
+        Self::from_char(chars.next()?)
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum FormatAlign {
+    Left,
+    Right,
+    AfterSign,
+    Center,
+}
+
+impl FormatAlign {
+    fn from_char(c: CodePoint) -> Option<Self> {
+        match c.to_char_lossy() {
+            '<' => Some(Self::Left),
+            '>' => Some(Self::Right),
+            '=' => Some(Self::AfterSign),
+            '^' => Some(Self::Center),
+            _ => None,
+        }
+    }
+}
+
+impl FormatParse for FormatAlign {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
+        let mut chars = text.code_points();
+        if let Some(maybe_align) = chars.next().and_then(Self::from_char) {
+            (Some(maybe_align), chars.as_wtf8())
+        } else {
+            (None, text)
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum FormatSign {
+    Plus,
+    Minus,
+    MinusOrSpace,
+}
+
+impl FormatParse for FormatSign {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
+        let mut chars = text.code_points();
+        match chars.next().and_then(CodePoint::to_char) {
+            Some('-') => (Some(Self::Minus), chars.as_wtf8()),
+            Some('+') => (Some(Self::Plus), chars.as_wtf8()),
+            Some(' ') => (Some(Self::MinusOrSpace), chars.as_wtf8()),
+            _ => (None, text),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatGrouping {
+    Comma,
+    Underscore,
+}
+
+impl FormatParse for FormatGrouping {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
+        let mut chars = text.code_points();
+        match chars.next().and_then(CodePoint::to_char) {
+            Some('_') => (Some(Self::Underscore), chars.as_wtf8()),
+            Some(',') => (Some(Self::Comma), chars.as_wtf8()),
+            _ => (None, text),
+        }
+    }
+}
+
+impl From<&FormatGrouping> for char {
+    fn from(fg: &FormatGrouping) -> Self {
+        match fg {
+            FormatGrouping::Comma => ',',
+            FormatGrouping::Underscore => '_',
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatType {
+    String,
+    Binary,
+    Character,
+    Decimal,
+    Octal,
+    Number(Case),
+    Hex(Case),
+    Exponent(Case),
+    GeneralFormat(Case),
+    FixedPoint(Case),
+    Percentage,
+}
+
+impl From<&FormatType> for char {
+    fn from(from: &FormatType) -> Self {
+        match from {
+            FormatType::String => 's',
+            FormatType::Binary => 'b',
+            FormatType::Character => 'c',
+            FormatType::Decimal => 'd',
+            FormatType::Octal => 'o',
+            FormatType::Number(Case::Lower) => 'n',
+            FormatType::Number(Case::Upper) => 'N',
+            FormatType::Hex(Case::Lower) => 'x',
+            FormatType::Hex(Case::Upper) => 'X',
+            FormatType::Exponent(Case::Lower) => 'e',
+            FormatType::Exponent(Case::Upper) => 'E',
+            FormatType::GeneralFormat(Case::Lower) => 'g',
+            FormatType::GeneralFormat(Case::Upper) => 'G',
+            FormatType::FixedPoint(Case::Lower) => 'f',
+            FormatType::FixedPoint(Case::Upper) => 'F',
+            FormatType::Percentage => '%',
+        }
+    }
+}
+
+impl FormatParse for FormatType {
+    fn parse(text: &Wtf8) -> (Option<Self>, &Wtf8) {
+        let mut chars = text.code_points();
+        match chars.next().and_then(CodePoint::to_char) {
+            Some('s') => (Some(Self::String), chars.as_wtf8()),
+            Some('b') => (Some(Self::Binary), chars.as_wtf8()),
+            Some('c') => (Some(Self::Character), chars.as_wtf8()),
+            Some('d') => (Some(Self::Decimal), chars.as_wtf8()),
+            Some('o') => (Some(Self::Octal), chars.as_wtf8()),
+            Some('n') => (Some(Self::Number(Case::Lower)), chars.as_wtf8()),
+            Some('N') => (Some(Self::Number(Case::Upper)), chars.as_wtf8()),
+            Some('x') => (Some(Self::Hex(Case::Lower)), chars.as_wtf8()),
+            Some('X') => (Some(Self::Hex(Case::Upper)), chars.as_wtf8()),
+            Some('e') => (Some(Self::Exponent(Case::Lower)), chars.as_wtf8()),
+            Some('E') => (Some(Self::Exponent(Case::Upper)), chars.as_wtf8()),
+            Some('f') => (Some(Self::FixedPoint(Case::Lower)), chars.as_wtf8()),
+            Some('F') => (Some(Self::FixedPoint(Case::Upper)), chars.as_wtf8()),
+            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()),
+            _ => (None, text),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct FormatSpec {
+    conversion: Option<FormatConversion>,
+    fill: Option<CodePoint>,
+    align: Option<FormatAlign>,
+    sign: Option<FormatSign>,
+    alternate_form: bool,
+    width: Option<usize>,
+    grouping_option: Option<FormatGrouping>,
+    precision: Option<usize>,
+    format_type: Option<FormatType>,
+}
+
+fn get_num_digits(text: &Wtf8) -> usize {
+    for (index, character) in text.code_point_indices() {
+        if !character.is_char_and(|c| c.is_ascii_digit()) {
+            return index;
+        }
+    }
+    text.len()
+}
+
+fn parse_fill_and_align(text: &Wtf8) -> (Option<CodePoint>, Option<FormatAlign>, &Wtf8) {
+    let char_indices: Vec<(usize, CodePoint)> = text.code_point_indices().take(3).collect();
+    if char_indices.is_empty() {
+        (None, None, text)
+    } else if char_indices.len() == 1 {
+        let (maybe_align, remaining) = FormatAlign::parse(text);
+        (None, maybe_align, remaining)
+    } else {
+        let (maybe_align, remaining) = FormatAlign::parse(&text[char_indices[1].0..]);
+        if maybe_align.is_some() {
+            (Some(char_indices[0].1), maybe_align, remaining)
+        } else {
+            let (only_align, only_align_remaining) = FormatAlign::parse(text);
+            (None, only_align, only_align_remaining)
+        }
+    }
+}
+
+fn parse_number(text: &Wtf8) -> Result<(Option<usize>, &Wtf8), FormatSpecError> {
+    let num_digits: usize = get_num_digits(text);
+    if num_digits == 0 {
+        return Ok((None, text));
+    }
+    if let Some(num) = parse_usize(&text[..num_digits]) {
+        Ok((Some(num), &text[num_digits..]))
+    } else {
+        // NOTE: this condition is different from CPython
+        Err(FormatSpecError::DecimalDigitsTooMany)
+    }
+}
+
+fn parse_alternate_form(text: &Wtf8) -> (bool, &Wtf8) {
+    let mut chars = text.code_points();
+    match chars.next().and_then(CodePoint::to_char) {
+        Some('#') => (true, chars.as_wtf8()),
+        _ => (false, text),
+    }
+}
+
+fn parse_zero(text: &Wtf8) -> (bool, &Wtf8) {
+    let mut chars = text.code_points();
+    match chars.next().and_then(CodePoint::to_char) {
+        Some('0') => (true, chars.as_wtf8()),
+        _ => (false, text),
+    }
+}
+
+fn parse_precision(text: &Wtf8) -> Result<(Option<usize>, &Wtf8), FormatSpecError> {
+    let mut chars = text.code_points();
+    Ok(match chars.next().and_then(CodePoint::to_char) {
+        Some('.') => {
+            let (size, remaining) = parse_number(chars.as_wtf8())?;
+            if let Some(size) = size {
+                if size > i32::MAX as usize {
+                    return Err(FormatSpecError::PrecisionTooBig);
+                }
+                (Some(size), remaining)
+            } else {
+                (None, text)
+            }
+        }
+        _ => (None, text),
+    })
+}
+
+impl FormatSpec {
+    pub fn parse(text: impl AsRef<Wtf8>) -> Result<Self, FormatSpecError> {
+        Self::_parse(text.as_ref())
+    }
+
+    fn _parse(text: &Wtf8) -> Result<Self, FormatSpecError> {
+        // get_integer in CPython
+        let (conversion, text) = FormatConversion::parse(text);
+        let (mut fill, mut align, text) = parse_fill_and_align(text);
+        let (sign, text) = FormatSign::parse(text);
+        let (alternate_form, text) = parse_alternate_form(text);
+        let (zero, text) = parse_zero(text);
+        let (width, text) = parse_number(text)?;
+        let (grouping_option, text) = FormatGrouping::parse(text);
+        if let Some(grouping) = &grouping_option {
+            Self::validate_separator(grouping, text)?;
+        }
+        let (precision, text) = parse_precision(text)?;
+        let (format_type, text) = FormatType::parse(text);
+        if !text.is_empty() {
+            return Err(FormatSpecError::InvalidFormatSpecifier);
+        }
+
+        if zero && fill.is_none() {
+            fill.replace('0'.into());
+            align = align.or(Some(FormatAlign::AfterSign));
+        }
+
+        Ok(Self {
+            conversion,
+            fill,
+            align,
+            sign,
+            alternate_form,
+            width,
+            grouping_option,
+            precision,
+            format_type,
+        })
+    }
+
+    fn validate_separator(grouping: &FormatGrouping, text: &Wtf8) -> Result<(), FormatSpecError> {
+        let mut chars = text.code_points().peekable();
+        match chars.peek().and_then(|cp| CodePoint::to_char(*cp)) {
+            Some(c) if c == ',' || c == '_' => {
+                if c == char::from(grouping) {
+                    Err(FormatSpecError::UnspecifiedFormat(c, c))
+                } else {
+                    Err(FormatSpecError::ExclusiveFormat(',', '_'))
+                }
+            }
+            _ => Ok(()),
+        }
+    }
+
+    fn compute_fill_string(fill_char: CodePoint, fill_chars_needed: i32) -> Wtf8Buf {
+        (0..fill_chars_needed).map(|_| fill_char).collect()
+    }
+
+    fn add_magnitude_separators_for_char(
+        magnitude_str: String,
+        inter: i32,
+        sep: char,
+        disp_digit_cnt: i32,
+    ) -> String {
+        // Don't add separators to the floating decimal point of numbers
+        let mut parts = magnitude_str.splitn(2, '.');
+        let magnitude_int_str = parts.next().unwrap().to_string();
+        let dec_digit_cnt = magnitude_str.len() as i32 - magnitude_int_str.len() as i32;
+        let int_digit_cnt = disp_digit_cnt - dec_digit_cnt;
+        let mut result = Self::separate_integer(magnitude_int_str, inter, sep, int_digit_cnt);
+        if let Some(part) = parts.next() {
+            result.push_str(&format!(".{part}"))
+        }
+        result
+    }
+
+    fn separate_integer(
+        magnitude_str: String,
+        inter: i32,
+        sep: char,
+        disp_digit_cnt: i32,
+    ) -> String {
+        let magnitude_len = magnitude_str.len() as i32;
+        let offset = (disp_digit_cnt % (inter + 1) == 0) as i32;
+        let disp_digit_cnt = disp_digit_cnt + offset;
+        let pad_cnt = disp_digit_cnt - magnitude_len;
+        let sep_cnt = disp_digit_cnt / (inter + 1);
+        let diff = pad_cnt - sep_cnt;
+        if pad_cnt > 0 && diff > 0 {
+            // separate with 0 padding
+            let padding = "0".repeat(diff as usize);
+            let padded_num = format!("{padding}{magnitude_str}");
+            Self::insert_separator(padded_num, inter, sep, sep_cnt)
+        } else {
+            // separate without padding
+            let sep_cnt = (magnitude_len - 1) / inter;
+            Self::insert_separator(magnitude_str, inter, sep, sep_cnt)
+        }
+    }
+
+    fn insert_separator(mut magnitude_str: String, inter: i32, sep: char, sep_cnt: i32) -> String {
+        let magnitude_len = magnitude_str.len() as i32;
+        for i in 1..=sep_cnt {
+            magnitude_str.insert((magnitude_len - inter * i) as usize, sep);
+        }
+        magnitude_str
+    }
+
+    fn validate_format(&self, default_format_type: FormatType) -> Result<(), FormatSpecError> {
+        let format_type = self.format_type.as_ref().unwrap_or(&default_format_type);
+        match (&self.grouping_option, format_type) {
+            (
+                Some(FormatGrouping::Comma),
+                FormatType::String
+                | FormatType::Character
+                | FormatType::Binary
+                | FormatType::Octal
+                | FormatType::Hex(_)
+                | FormatType::Number(_),
+            ) => {
+                let ch = char::from(format_type);
+                Err(FormatSpecError::UnspecifiedFormat(',', ch))
+            }
+            (
+                Some(FormatGrouping::Underscore),
+                FormatType::String | FormatType::Character | FormatType::Number(_),
+            ) => {
+                let ch = char::from(format_type);
+                Err(FormatSpecError::UnspecifiedFormat('_', ch))
+            }
+            _ => Ok(()),
+        }
+    }
+
+    const fn get_separator_interval(&self) -> usize {
+        match self.format_type {
+            Some(FormatType::Binary | FormatType::Octal | FormatType::Hex(_)) => 4,
+            Some(
+                FormatType::Decimal
+                | FormatType::FixedPoint(_)
+                | FormatType::GeneralFormat(_)
+                | FormatType::Exponent(_)
+                | FormatType::Percentage,
+            ) => 3,
+            None => 3,
+            _ => panic!("Separators only valid for numbers!"),
+        }
+    }
+
+    fn add_magnitude_separators(&self, magnitude_str: String, prefix: &str) -> String {
+        match &self.grouping_option {
+            Some(fg) => {
+                let sep = char::from(fg);
+                let inter = self.get_separator_interval().try_into().unwrap();
+                let magnitude_len = magnitude_str.len();
+                let disp_digit_cnt = if self.fill == Some('0'.into())
+                    && self.align == Some(FormatAlign::AfterSign)
+                {
+                    let width = self.width.unwrap_or(magnitude_len) as i32 - prefix.len() as i32;
+                    cmp::max(width, magnitude_len as i32)
+                } else {
+                    magnitude_len as i32
+                };
+                Self::add_magnitude_separators_for_char(magnitude_str, inter, sep, disp_digit_cnt)
+            }
+            None => magnitude_str,
+        }
+    }
+
+    pub fn format_bool(&self, input: bool) -> Result<String, FormatSpecError> {
+        let x = u8::from(input);
+        match &self.format_type {
+            Some(
+                FormatType::Binary
+                | FormatType::Decimal
+                | FormatType::Octal
+                | FormatType::Number(Case::Lower)
+                | FormatType::Hex(_)
+                | FormatType::GeneralFormat(_)
+                | FormatType::Character,
+            ) => self.format_int(&BigInt::from_u8(x).unwrap()),
+            Some(FormatType::Exponent(_) | FormatType::FixedPoint(_) | FormatType::Percentage) => {
+                self.format_float(x as f64)
+            }
+            None => {
+                let first_letter = (input.to_string().as_bytes()[0] as char).to_uppercase();
+                Ok(first_letter.collect::<String>() + &input.to_string()[1..])
+            }
+            _ => Err(FormatSpecError::InvalidFormatSpecifier),
+        }
+    }
+
+    pub fn format_float(&self, num: f64) -> 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: Result<String, FormatSpecError> = match &self.format_type {
+            Some(FormatType::FixedPoint(case)) => Ok(float::format_fixed(
+                precision,
+                magnitude,
+                *case,
+                self.alternate_form,
+            )),
+            Some(FormatType::Decimal)
+            | Some(FormatType::Binary)
+            | Some(FormatType::Octal)
+            | Some(FormatType::Hex(_))
+            | Some(FormatType::String)
+            | Some(FormatType::Character)
+            | Some(FormatType::Number(Case::Upper)) => {
+                let ch = char::from(self.format_type.as_ref().unwrap());
+                Err(FormatSpecError::UnknownFormatCode(ch, "float"))
+            }
+            Some(FormatType::GeneralFormat(case)) | Some(FormatType::Number(case)) => {
+                let precision = if precision == 0 { 1 } else { precision };
+                Ok(float::format_general(
+                    precision,
+                    magnitude,
+                    *case,
+                    self.alternate_form,
+                    false,
+                ))
+            }
+            Some(FormatType::Exponent(case)) => Ok(float::format_exponent(
+                precision,
+                magnitude,
+                *case,
+                self.alternate_form,
+            )),
+            Some(FormatType::Percentage) => match magnitude {
+                magnitude if magnitude.is_nan() => Ok("nan%".to_owned()),
+                magnitude if magnitude.is_infinite() => Ok("inf%".to_owned()),
+                _ => {
+                    let result = format!("{:.*}", precision, magnitude * 100.0);
+                    let point = float::decimal_point_or_empty(precision, self.alternate_form);
+                    Ok(format!("{result}{point}%"))
+                }
+            },
+            None => match magnitude {
+                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
+                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
+                _ => match self.precision {
+                    Some(precision) => Ok(float::format_general(
+                        precision,
+                        magnitude,
+                        Case::Lower,
+                        self.alternate_form,
+                        true,
+                    )),
+                    None => Ok(float::to_string(magnitude)),
+                },
+            },
+        };
+        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 => " ",
+            }
+        };
+        let magnitude_str = self.add_magnitude_separators(raw_magnitude_str?, sign_str);
+        self.format_sign_and_align(&AsciiStr::new(&magnitude_str), sign_str, FormatAlign::Right)
+    }
+
+    #[inline]
+    fn format_int_radix(&self, magnitude: BigInt, radix: u32) -> Result<String, FormatSpecError> {
+        match self.precision {
+            Some(_) => Err(FormatSpecError::PrecisionNotAllowed),
+            None => Ok(magnitude.to_str_radix(radix)),
+        }
+    }
+
+    pub fn format_int(&self, num: &BigInt) -> Result<String, FormatSpecError> {
+        self.validate_format(FormatType::Decimal)?;
+        let magnitude = num.abs();
+        let prefix = if self.alternate_form {
+            match self.format_type {
+                Some(FormatType::Binary) => "0b",
+                Some(FormatType::Octal) => "0o",
+                Some(FormatType::Hex(Case::Lower)) => "0x",
+                Some(FormatType::Hex(Case::Upper)) => "0X",
+                _ => "",
+            }
+        } else {
+            ""
+        };
+        let raw_magnitude_str = match self.format_type {
+            Some(FormatType::Binary) => self.format_int_radix(magnitude, 2),
+            Some(FormatType::Decimal) => self.format_int_radix(magnitude, 10),
+            Some(FormatType::Octal) => self.format_int_radix(magnitude, 8),
+            Some(FormatType::Hex(Case::Lower)) => self.format_int_radix(magnitude, 16),
+            Some(FormatType::Hex(Case::Upper)) => match self.precision {
+                Some(_) => Err(FormatSpecError::PrecisionNotAllowed),
+                None => {
+                    let mut result = magnitude.to_str_radix(16);
+                    result.make_ascii_uppercase();
+                    Ok(result)
+                }
+            },
+            Some(FormatType::Number(Case::Lower)) => self.format_int_radix(magnitude, 10),
+            Some(FormatType::Number(Case::Upper)) => {
+                Err(FormatSpecError::UnknownFormatCode('N', "int"))
+            }
+            Some(FormatType::String) => Err(FormatSpecError::UnknownFormatCode('s', "int")),
+            Some(FormatType::Character) => match (self.sign, self.alternate_form) {
+                (Some(_), _) => Err(FormatSpecError::NotAllowed("Sign")),
+                (_, true) => Err(FormatSpecError::NotAllowed("Alternate form (#)")),
+                (_, _) => match num.to_u32() {
+                    Some(n) if n <= 0x10ffff => Ok(core::char::from_u32(n).unwrap().to_string()),
+                    Some(_) | None => Err(FormatSpecError::CodeNotInRange),
+                },
+            },
+            Some(FormatType::GeneralFormat(_))
+            | Some(FormatType::FixedPoint(_))
+            | Some(FormatType::Exponent(_))
+            | Some(FormatType::Percentage) => match num.to_f64() {
+                Some(float) => return self.format_float(float),
+                _ => Err(FormatSpecError::UnableToConvert),
+            },
+            None => self.format_int_radix(magnitude, 10),
+        }?;
+        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 => " ",
+            },
+        };
+        let sign_prefix = format!("{sign_str}{prefix}");
+        let magnitude_str = self.add_magnitude_separators(raw_magnitude_str, &sign_prefix);
+        self.format_sign_and_align(
+            &AsciiStr::new(&magnitude_str),
+            &sign_prefix,
+            FormatAlign::Right,
+        )
+    }
+
+    pub fn format_string<T>(&self, s: &T) -> Result<String, FormatSpecError>
+    where
+        T: CharLen + Deref<Target = str>,
+    {
+        self.validate_format(FormatType::String)?;
+        match self.format_type {
+            Some(FormatType::String) | None => self
+                .format_sign_and_align(s, "", FormatAlign::Left)
+                .map(|mut value| {
+                    if let Some(precision) = self.precision {
+                        value.truncate(precision);
+                    }
+                    value
+                }),
+            _ => {
+                let ch = char::from(self.format_type.as_ref().unwrap());
+                Err(FormatSpecError::UnknownFormatCode(ch, "str"))
+            }
+        }
+    }
+
+    pub fn format_complex(&self, num: &Complex64) -> Result<String, FormatSpecError> {
+        let (formatted_re, formatted_im) = self.format_complex_re_im(num)?;
+        // Enclose in parentheses if there is no format type and formatted_re is not empty
+        let magnitude_str = if self.format_type.is_none() && !formatted_re.is_empty() {
+            format!("({formatted_re}{formatted_im})")
+        } else {
+            format!("{formatted_re}{formatted_im}")
+        };
+        if let Some(FormatAlign::AfterSign) = &self.align {
+            return Err(FormatSpecError::AlignmentFlag);
+        }
+        match &self.fill.unwrap_or(' '.into()).to_char() {
+            Some('0') => Err(FormatSpecError::ZeroPadding),
+            _ => self.format_sign_and_align(&AsciiStr::new(&magnitude_str), "", FormatAlign::Right),
+        }
+    }
+
+    fn format_complex_re_im(&self, num: &Complex64) -> Result<(String, String), FormatSpecError> {
+        // Format real part
+        let mut formatted_re = String::new();
+        if num.re != 0.0 || num.re.is_negative_zero() || self.format_type.is_some() {
+            let sign_re = if num.re.is_sign_negative() && !num.is_nan() {
+                "-"
+            } else {
+                match self.sign.unwrap_or(FormatSign::Minus) {
+                    FormatSign::Plus => "+",
+                    FormatSign::Minus => "",
+                    FormatSign::MinusOrSpace => " ",
+                }
+            };
+            let re = self.format_complex_float(num.re)?;
+            formatted_re = format!("{sign_re}{re}");
+        }
+        // Format imaginary part
+        let sign_im = if num.im.is_sign_negative() && !num.im.is_nan() {
+            "-"
+        } else if formatted_re.is_empty() {
+            ""
+        } else {
+            "+"
+        };
+        let im = self.format_complex_float(num.im)?;
+        Ok((formatted_re, format!("{sign_im}{im}j")))
+    }
+
+    fn format_complex_float(&self, num: f64) -> Result<String, FormatSpecError> {
+        self.validate_format(FormatType::FixedPoint(Case::Lower))?;
+        let precision = self.precision.unwrap_or(6);
+        let magnitude = num.abs();
+        let magnitude_str = match &self.format_type {
+            Some(FormatType::Decimal)
+            | Some(FormatType::Binary)
+            | Some(FormatType::Octal)
+            | Some(FormatType::Hex(_))
+            | Some(FormatType::String)
+            | Some(FormatType::Character)
+            | Some(FormatType::Number(Case::Upper))
+            | Some(FormatType::Percentage) => {
+                let ch = char::from(self.format_type.as_ref().unwrap());
+                Err(FormatSpecError::UnknownFormatCode(ch, "complex"))
+            }
+            Some(FormatType::FixedPoint(case)) => Ok(float::format_fixed(
+                precision,
+                magnitude,
+                *case,
+                self.alternate_form,
+            )),
+            Some(FormatType::GeneralFormat(case)) | Some(FormatType::Number(case)) => {
+                let precision = if precision == 0 { 1 } else { precision };
+                Ok(float::format_general(
+                    precision,
+                    magnitude,
+                    *case,
+                    self.alternate_form,
+                    false,
+                ))
+            }
+            Some(FormatType::Exponent(case)) => Ok(float::format_exponent(
+                precision,
+                magnitude,
+                *case,
+                self.alternate_form,
+            )),
+            None => match magnitude {
+                magnitude if magnitude.is_nan() => Ok("nan".to_owned()),
+                magnitude if magnitude.is_infinite() => Ok("inf".to_owned()),
+                _ => match self.precision {
+                    Some(precision) => Ok(float::format_general(
+                        precision,
+                        magnitude,
+                        Case::Lower,
+                        self.alternate_form,
+                        true,
+                    )),
+                    None => {
+                        if magnitude.fract() == 0.0 {
+                            Ok(magnitude.trunc().to_string())
+                        } else {
+                            Ok(magnitude.to_string())
+                        }
+                    }
+                },
+            },
+        }?;
+        match &self.grouping_option {
+            Some(fg) => {
+                let sep = char::from(fg);
+                let inter = self.get_separator_interval().try_into().unwrap();
+                let len = magnitude_str.len() as i32;
+                let separated_magnitude =
+                    Self::add_magnitude_separators_for_char(magnitude_str, inter, sep, len);
+                Ok(separated_magnitude)
+            }
+            None => Ok(magnitude_str),
+        }
+    }
+
+    fn format_sign_and_align<T>(
+        &self,
+        magnitude_str: &T,
+        sign_str: &str,
+        default_align: FormatAlign,
+    ) -> Result<String, FormatSpecError>
+    where
+        T: CharLen + Deref<Target = str>,
+    {
+        let align = self.align.unwrap_or(default_align);
+
+        let num_chars = magnitude_str.char_len();
+        let fill_char = self.fill.unwrap_or(' '.into());
+        let fill_chars_needed: i32 = self.width.map_or(0, |w| {
+            cmp::max(0, (w as i32) - (num_chars as i32) - (sign_str.len() as i32))
+        });
+
+        let magnitude_str = magnitude_str.deref();
+        Ok(match align {
+            FormatAlign::Left => format!(
+                "{}{}{}",
+                sign_str,
+                magnitude_str,
+                Self::compute_fill_string(fill_char, fill_chars_needed)
+            ),
+            FormatAlign::Right => format!(
+                "{}{}{}",
+                Self::compute_fill_string(fill_char, fill_chars_needed),
+                sign_str,
+                magnitude_str
+            ),
+            FormatAlign::AfterSign => format!(
+                "{}{}{}",
+                sign_str,
+                Self::compute_fill_string(fill_char, fill_chars_needed),
+                magnitude_str
+            ),
+            FormatAlign::Center => {
+                let left_fill_chars_needed = fill_chars_needed / 2;
+                let right_fill_chars_needed = fill_chars_needed - left_fill_chars_needed;
+                let left_fill_string = Self::compute_fill_string(fill_char, left_fill_chars_needed);
+                let right_fill_string =
+                    Self::compute_fill_string(fill_char, right_fill_chars_needed);
+                format!("{left_fill_string}{sign_str}{magnitude_str}{right_fill_string}")
+            }
+        })
+    }
+}
+
+pub trait CharLen {
+    /// Returns the number of characters in the text
+    fn char_len(&self) -> usize;
+}
+
+struct AsciiStr<'a> {
+    inner: &'a str,
+}
+
+impl<'a> AsciiStr<'a> {
+    const fn new(inner: &'a str) -> Self {
+        Self { inner }
+    }
+}
+
+impl CharLen for AsciiStr<'_> {
+    fn char_len(&self) -> usize {
+        self.inner.len()
+    }
+}
+
+impl Deref for AsciiStr<'_> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatSpecError {
+    DecimalDigitsTooMany,
+    PrecisionTooBig,
+    InvalidFormatSpecifier,
+    UnspecifiedFormat(char, char),
+    ExclusiveFormat(char, char),
+    UnknownFormatCode(char, &'static str),
+    PrecisionNotAllowed,
+    NotAllowed(&'static str),
+    UnableToConvert,
+    CodeNotInRange,
+    ZeroPadding,
+    AlignmentFlag,
+    NotImplemented(char, &'static str),
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatParseError {
+    UnmatchedBracket,
+    MissingStartBracket,
+    UnescapedStartBracketInLiteral,
+    InvalidFormatSpecifier,
+    UnknownConversion,
+    EmptyAttribute,
+    MissingRightBracket,
+    InvalidCharacterAfterRightBracket,
+}
+
+impl FromStr for FormatSpec {
+    type Err = FormatSpecError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse(s)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FieldNamePart {
+    Attribute(Wtf8Buf),
+    Index(usize),
+    StringIndex(Wtf8Buf),
+}
+
+impl FieldNamePart {
+    fn parse_part(
+        chars: &mut impl PeekingNext<Item = CodePoint>,
+    ) -> Result<Option<Self>, FormatParseError> {
+        chars
+            .next()
+            .map(|ch| match ch.to_char_lossy() {
+                '.' => {
+                    let mut attribute = Wtf8Buf::new();
+                    for ch in chars.peeking_take_while(|ch| *ch != '.' && *ch != '[') {
+                        attribute.push(ch);
+                    }
+                    if attribute.is_empty() {
+                        Err(FormatParseError::EmptyAttribute)
+                    } else {
+                        Ok(Self::Attribute(attribute))
+                    }
+                }
+                '[' => {
+                    let mut index = Wtf8Buf::new();
+                    for ch in chars {
+                        if ch == ']' {
+                            return if index.is_empty() {
+                                Err(FormatParseError::EmptyAttribute)
+                            } else if let Some(index) = parse_usize(&index) {
+                                Ok(Self::Index(index))
+                            } else {
+                                Ok(Self::StringIndex(index))
+                            };
+                        }
+                        index.push(ch);
+                    }
+                    Err(FormatParseError::MissingRightBracket)
+                }
+                _ => Err(FormatParseError::InvalidCharacterAfterRightBracket),
+            })
+            .transpose()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FieldType {
+    Auto,
+    Index(usize),
+    Keyword(Wtf8Buf),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct FieldName {
+    pub field_type: FieldType,
+    pub parts: Vec<FieldNamePart>,
+}
+
+fn parse_usize(s: &Wtf8) -> Option<usize> {
+    s.as_str().ok().and_then(|s| s.parse().ok())
+}
+
+impl FieldName {
+    pub fn parse(text: &Wtf8) -> Result<Self, FormatParseError> {
+        let mut chars = text.code_points().peekable();
+        let first: Wtf8Buf = chars
+            .peeking_take_while(|ch| *ch != '.' && *ch != '[')
+            .collect();
+
+        let field_type = if first.is_empty() {
+            FieldType::Auto
+        } else if let Some(index) = parse_usize(&first) {
+            FieldType::Index(index)
+        } else {
+            FieldType::Keyword(first)
+        };
+
+        let mut parts = Vec::new();
+        while let Some(part) = FieldNamePart::parse_part(&mut chars)? {
+            parts.push(part)
+        }
+
+        Ok(Self { field_type, parts })
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum FormatPart {
+    Field {
+        field_name: Wtf8Buf,
+        conversion_spec: Option<CodePoint>,
+        format_spec: Wtf8Buf,
+    },
+    Literal(Wtf8Buf),
+}
+
+#[derive(Debug, PartialEq)]
+pub struct FormatString {
+    pub format_parts: Vec<FormatPart>,
+}
+
+impl FormatString {
+    fn parse_literal_single(text: &Wtf8) -> Result<(CodePoint, &Wtf8), FormatParseError> {
+        let mut chars = text.code_points();
+        // This should never be called with an empty str
+        let first_char = chars.next().unwrap();
+        // isn't this detectable only with bytes operation?
+        if first_char == '{' || first_char == '}' {
+            let maybe_next_char = chars.next();
+            // if we see a bracket, it has to be escaped by doubling up to be in a literal
+            return if maybe_next_char.is_none() || maybe_next_char.unwrap() != first_char {
+                Err(FormatParseError::UnescapedStartBracketInLiteral)
+            } else {
+                Ok((first_char, chars.as_wtf8()))
+            };
+        }
+        Ok((first_char, chars.as_wtf8()))
+    }
+
+    fn parse_literal(text: &Wtf8) -> Result<(FormatPart, &Wtf8), FormatParseError> {
+        let mut cur_text = text;
+        let mut result_string = Wtf8Buf::new();
+        while !cur_text.is_empty() {
+            match Self::parse_literal_single(cur_text) {
+                Ok((next_char, remaining)) => {
+                    result_string.push(next_char);
+                    cur_text = remaining;
+                }
+                Err(err) => {
+                    return if !result_string.is_empty() {
+                        Ok((FormatPart::Literal(result_string), cur_text))
+                    } else {
+                        Err(err)
+                    };
+                }
+            }
+        }
+        Ok((FormatPart::Literal(result_string), "".as_ref()))
+    }
+
+    fn parse_part_in_brackets(text: &Wtf8) -> Result<FormatPart, FormatParseError> {
+        let mut chars = text.code_points().peekable();
+
+        let mut left = Wtf8Buf::new();
+        let mut right = Wtf8Buf::new();
+
+        let mut split = false;
+        let mut selected = &mut left;
+        let mut inside_brackets = false;
+
+        while let Some(char) = chars.next() {
+            if char == '[' {
+                inside_brackets = true;
+
+                selected.push(char);
+
+                while let Some(next_char) = chars.next() {
+                    selected.push(next_char);
+
+                    if next_char == ']' {
+                        inside_brackets = false;
+                        break;
+                    }
+                    if chars.peek().is_none() {
+                        return Err(FormatParseError::MissingRightBracket);
+                    }
+                }
+            } else if char == ':' && !split && !inside_brackets {
+                split = true;
+                selected = &mut right;
+            } else {
+                selected.push(char);
+            }
+        }
+
+        // before the comma is a keyword or arg index, after the comma is maybe a spec.
+        let arg_part: &Wtf8 = &left;
+
+        let format_spec = if split { right } else { Wtf8Buf::new() };
+
+        // left can still be the conversion (!r, !s, !a)
+        let parts: Vec<&Wtf8> = arg_part.splitn(2, "!".as_ref()).collect();
+        // before the bang is a keyword or arg index, after the comma is maybe a conversion spec.
+        let arg_part = parts[0];
+
+        let conversion_spec = parts
+            .get(1)
+            .map(|conversion| {
+                // conversions are only every one character
+                conversion
+                    .code_points()
+                    .exactly_one()
+                    .map_err(|_| FormatParseError::UnknownConversion)
+            })
+            .transpose()?;
+
+        Ok(FormatPart::Field {
+            field_name: arg_part.to_owned(),
+            conversion_spec,
+            format_spec,
+        })
+    }
+
+    fn parse_spec(text: &Wtf8) -> Result<(FormatPart, &Wtf8), FormatParseError> {
+        let mut nested = false;
+        let mut end_bracket_pos = None;
+        let mut left = Wtf8Buf::new();
+
+        // There may be one layer nesting brackets in spec
+        for (idx, c) in text.code_point_indices() {
+            if idx == 0 {
+                if c != '{' {
+                    return Err(FormatParseError::MissingStartBracket);
+                }
+            } else if c == '{' {
+                if nested {
+                    return Err(FormatParseError::InvalidFormatSpecifier);
+                } else {
+                    nested = true;
+                    left.push(c);
+                    continue;
+                }
+            } else if c == '}' {
+                if nested {
+                    nested = false;
+                    left.push(c);
+                    continue;
+                } else {
+                    end_bracket_pos = Some(idx);
+                    break;
+                }
+            } else {
+                left.push(c);
+            }
+        }
+        if let Some(pos) = end_bracket_pos {
+            let right = &text[pos..];
+            let format_part = Self::parse_part_in_brackets(&left)?;
+            Ok((format_part, &right[1..]))
+        } else {
+            Err(FormatParseError::UnmatchedBracket)
+        }
+    }
+}
+
+pub trait FromTemplate<'a>: Sized {
+    type Err;
+    fn from_str(s: &'a Wtf8) -> Result<Self, Self::Err>;
+}
+
+impl<'a> FromTemplate<'a> for FormatString {
+    type Err = FormatParseError;
+
+    fn from_str(text: &'a Wtf8) -> Result<Self, Self::Err> {
+        let mut cur_text: &Wtf8 = text;
+        let mut parts: Vec<FormatPart> = Vec::new();
+        while !cur_text.is_empty() {
+            // Try to parse both literals and bracketed format parts until we
+            // run out of text
+            cur_text = Self::parse_literal(cur_text)
+                .or_else(|_| Self::parse_spec(cur_text))
+                .map(|(part, new_text)| {
+                    parts.push(part);
+                    new_text
+                })?;
+        }
+        Ok(Self {
+            format_parts: parts,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fill_and_align() {
+        let parse_fill_and_align = |text| {
+            let (fill, align, rest) = parse_fill_and_align(str::as_ref(text));
+            (
+                fill.and_then(CodePoint::to_char),
+                align,
+                rest.as_str().unwrap(),
+            )
+        };
+        assert_eq!(
+            parse_fill_and_align(" <"),
+            (Some(' '), Some(FormatAlign::Left), "")
+        );
+        assert_eq!(
+            parse_fill_and_align(" <22"),
+            (Some(' '), Some(FormatAlign::Left), "22")
+        );
+        assert_eq!(
+            parse_fill_and_align("<22"),
+            (None, Some(FormatAlign::Left), "22")
+        );
+        assert_eq!(
+            parse_fill_and_align(" ^^"),
+            (Some(' '), Some(FormatAlign::Center), "^")
+        );
+        assert_eq!(
+            parse_fill_and_align("==="),
+            (Some('='), Some(FormatAlign::AfterSign), "=")
+        );
+    }
+
+    #[test]
+    fn test_width_only() {
+        let expected = Ok(FormatSpec {
+            conversion: None,
+            fill: None,
+            align: None,
+            sign: None,
+            alternate_form: false,
+            width: Some(33),
+            grouping_option: None,
+            precision: None,
+            format_type: None,
+        });
+        assert_eq!(FormatSpec::parse("33"), expected);
+    }
+
+    #[test]
+    fn test_fill_and_width() {
+        let expected = Ok(FormatSpec {
+            conversion: None,
+            fill: Some('<'.into()),
+            align: Some(FormatAlign::Right),
+            sign: None,
+            alternate_form: false,
+            width: Some(33),
+            grouping_option: None,
+            precision: None,
+            format_type: None,
+        });
+        assert_eq!(FormatSpec::parse("<>33"), expected);
+    }
+
+    #[test]
+    fn test_all() {
+        let expected = Ok(FormatSpec {
+            conversion: None,
+            fill: Some('<'.into()),
+            align: Some(FormatAlign::Right),
+            sign: Some(FormatSign::Minus),
+            alternate_form: true,
+            width: Some(23),
+            grouping_option: Some(FormatGrouping::Comma),
+            precision: Some(11),
+            format_type: Some(FormatType::Binary),
+        });
+        assert_eq!(FormatSpec::parse("<>-#23,.11b"), expected);
+    }
+
+    fn format_bool(text: &str, value: bool) -> Result<String, FormatSpecError> {
+        FormatSpec::parse(text).and_then(|spec| spec.format_bool(value))
+    }
+
+    #[test]
+    fn test_format_bool() {
+        assert_eq!(format_bool("b", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("b", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("d", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("d", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("o", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("o", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("n", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("n", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("x", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("x", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("X", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("X", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("g", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("g", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("G", true), Ok("1".to_owned()));
+        assert_eq!(format_bool("G", false), Ok("0".to_owned()));
+        assert_eq!(format_bool("c", true), Ok("\x01".to_owned()));
+        assert_eq!(format_bool("c", false), Ok("\x00".to_owned()));
+        assert_eq!(format_bool("e", true), Ok("1.000000e+00".to_owned()));
+        assert_eq!(format_bool("e", false), Ok("0.000000e+00".to_owned()));
+        assert_eq!(format_bool("E", true), Ok("1.000000E+00".to_owned()));
+        assert_eq!(format_bool("E", false), Ok("0.000000E+00".to_owned()));
+        assert_eq!(format_bool("f", true), Ok("1.000000".to_owned()));
+        assert_eq!(format_bool("f", false), Ok("0.000000".to_owned()));
+        assert_eq!(format_bool("F", true), Ok("1.000000".to_owned()));
+        assert_eq!(format_bool("F", false), Ok("0.000000".to_owned()));
+        assert_eq!(format_bool("%", true), Ok("100.000000%".to_owned()));
+        assert_eq!(format_bool("%", false), Ok("0.000000%".to_owned()));
+    }
+
+    #[test]
+    fn test_format_int() {
+        assert_eq!(
+            FormatSpec::parse("d")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("16".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("x")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("10".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("b")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("10000".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("o")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("20".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("+d")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("+16".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("^ 5d")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Minus, b"\x10")),
+            Ok(" -16 ".to_owned())
+        );
+        assert_eq!(
+            FormatSpec::parse("0>+#10x")
+                .unwrap()
+                .format_int(&BigInt::from_bytes_be(Sign::Plus, b"\x10")),
+            Ok("00000+0x10".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_format_int_sep() {
+        let spec = FormatSpec::parse(",").expect("");
+        assert_eq!(spec.grouping_option, Some(FormatGrouping::Comma));
+        assert_eq!(
+            spec.format_int(&BigInt::from_str("1234567890123456789012345678").unwrap()),
+            Ok("1,234,567,890,123,456,789,012,345,678".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_format_int_width_and_grouping() {
+        // issue #5922: width + comma grouping should pad left, not inside the number
+        let spec = FormatSpec::parse("10,").unwrap();
+        let result = spec.format_int(&BigInt::from(1234)).unwrap();
+        assert_eq!(result, "     1,234"); // CPython 3.13.5
+    }
+
+    #[test]
+    fn test_format_int_padding_with_grouping() {
+        // CPython behavior: f'{1234:010,}' results in "00,001,234"
+        let spec1 = FormatSpec::parse("010,").unwrap();
+        let result1 = spec1.format_int(&BigInt::from(1234)).unwrap();
+        assert_eq!(result1, "00,001,234");
+
+        // CPython behavior: f'{-1234:010,}' results in "-0,001,234"
+        let spec2 = FormatSpec::parse("010,").unwrap();
+        let result2 = spec2.format_int(&BigInt::from(-1234)).unwrap();
+        assert_eq!(result2, "-0,001,234");
+
+        // CPython behavior: f'{-1234:=10,}' results in "-    1,234"
+        let spec3 = FormatSpec::parse("=10,").unwrap();
+        let result3 = spec3.format_int(&BigInt::from(-1234)).unwrap();
+        assert_eq!(result3, "-    1,234");
+
+        // CPython behavior: f'{1234:=10,}' results in "     1,234" (same as right-align for positive numbers)
+        let spec4 = FormatSpec::parse("=10,").unwrap();
+        let result4 = spec4.format_int(&BigInt::from(1234)).unwrap();
+        assert_eq!(result4, "     1,234");
+    }
+
+    #[test]
+    fn test_format_int_non_aftersign_zero_padding() {
+        // CPython behavior: f'{1234:0>10,}' results in "000001,234"
+        let spec = FormatSpec::parse("0>10,").unwrap();
+        let result = spec.format_int(&BigInt::from(1234)).unwrap();
+        assert_eq!(result, "000001,234");
+    }
+
+    #[test]
+    fn test_format_parse() {
+        let expected = Ok(FormatString {
+            format_parts: vec![
+                FormatPart::Literal("abcd".into()),
+                FormatPart::Field {
+                    field_name: "1".into(),
+                    conversion_spec: None,
+                    format_spec: "".into(),
+                },
+                FormatPart::Literal(":".into()),
+                FormatPart::Field {
+                    field_name: "key".into(),
+                    conversion_spec: None,
+                    format_spec: "".into(),
+                },
+            ],
+        });
+
+        assert_eq!(FormatString::from_str("abcd{1}:{key}".as_ref()), expected);
+    }
+
+    #[test]
+    fn test_format_parse_multi_byte_char() {
+        assert!(FormatString::from_str("{a:%ЫйЯЧ}".as_ref()).is_ok());
+    }
+
+    #[test]
+    fn test_format_parse_fail() {
+        assert_eq!(
+            FormatString::from_str("{s".as_ref()),
+            Err(FormatParseError::UnmatchedBracket)
+        );
+    }
+
+    #[test]
+    fn test_square_brackets_inside_format() {
+        assert_eq!(
+            FormatString::from_str("{[:123]}".as_ref()),
+            Ok(FormatString {
+                format_parts: vec![FormatPart::Field {
+                    field_name: "[:123]".into(),
+                    conversion_spec: None,
+                    format_spec: "".into(),
+                }],
+            }),
+        );
+
+        assert_eq!(FormatString::from_str("{asdf[:123]asdf}".as_ref()), {
+            Ok(FormatString {
+                format_parts: vec![FormatPart::Field {
+                    field_name: "asdf[:123]asdf".into(),
+                    conversion_spec: None,
+                    format_spec: "".into(),
+                }],
+            })
+        });
+
+        assert_eq!(FormatString::from_str("{[1234}".as_ref()), {
+            Err(FormatParseError::MissingRightBracket)
+        });
+    }
+
+    #[test]
+    fn test_format_parse_escape() {
+        let expected = Ok(FormatString {
+            format_parts: vec![
+                FormatPart::Literal("{".into()),
+                FormatPart::Field {
+                    field_name: "key".into(),
+                    conversion_spec: None,
+                    format_spec: "".into(),
+                },
+                FormatPart::Literal("}ddfe".into()),
+            ],
+        });
+
+        assert_eq!(FormatString::from_str("{{{key}}}ddfe".as_ref()), expected);
+    }
+
+    #[test]
+    fn test_format_invalid_specification() {
+        assert_eq!(
+            FormatSpec::parse("%3"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse(".2fa"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse("ds"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse("x+"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse("b4"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse("o!"),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+        assert_eq!(
+            FormatSpec::parse("d "),
+            Err(FormatSpecError::InvalidFormatSpecifier)
+        );
+    }
+
+    #[test]
+    fn test_parse_field_name() {
+        let parse = |s: &str| FieldName::parse(s.as_ref());
+        assert_eq!(
+            parse(""),
+            Ok(FieldName {
+                field_type: FieldType::Auto,
+                parts: Vec::new(),
+            })
+        );
+        assert_eq!(
+            parse("0"),
+            Ok(FieldName {
+                field_type: FieldType::Index(0),
+                parts: Vec::new(),
+            })
+        );
+        assert_eq!(
+            parse("key"),
+            Ok(FieldName {
+                field_type: FieldType::Keyword("key".into()),
+                parts: Vec::new(),
+            })
+        );
+        assert_eq!(
+            parse("key.attr[0][string]"),
+            Ok(FieldName {
+                field_type: FieldType::Keyword("key".into()),
+                parts: vec![
+                    FieldNamePart::Attribute("attr".into()),
+                    FieldNamePart::Index(0),
+                    FieldNamePart::StringIndex("string".into())
+                ],
+            })
+        );
+        assert_eq!(parse("key.."), Err(FormatParseError::EmptyAttribute));
+        assert_eq!(parse("key[]"), Err(FormatParseError::EmptyAttribute));
+        assert_eq!(parse("key["), Err(FormatParseError::MissingRightBracket));
+        assert_eq!(
+            parse("key[0]after"),
+            Err(FormatParseError::InvalidCharacterAfterRightBracket)
+        );
+    }
+}
diff --git a/common/src/hash.rs b/crates/common/src/hash.rs
similarity index 95%
rename from common/src/hash.rs
rename to crates/common/src/hash.rs
index dcf424f7ba..40c428d89e 100644
--- a/common/src/hash.rs
+++ b/crates/common/src/hash.rs
@@ -1,7 +1,7 @@
+use core::hash::{BuildHasher, Hash, Hasher};
 use malachite_bigint::BigInt;
 use num_traits::ToPrimitive;
 use siphasher::sip::SipHasher24;
-use std::hash::{BuildHasher, Hash, Hasher};
 
 pub type PyHash = i64;
 pub type PyUHash = u64;
@@ -19,9 +19,9 @@ pub const INF: PyHash = 314_159;
 pub const NAN: PyHash = 0;
 pub const IMAG: PyHash = MULTIPLIER;
 pub const ALGO: &str = "siphash24";
-pub const HASH_BITS: usize = std::mem::size_of::<PyHash>() * 8;
+pub const HASH_BITS: usize = core::mem::size_of::<PyHash>() * 8;
 // SipHasher24 takes 2 u64s as a seed
-pub const SEED_BITS: usize = std::mem::size_of::<u64>() * 2 * 8;
+pub const SEED_BITS: usize = core::mem::size_of::<u64>() * 2 * 8;
 
 // pub const CUTOFF: usize = 7;
 
@@ -134,7 +134,7 @@ pub fn hash_bigint(value: &BigInt) -> PyHash {
         Some(i) => mod_int(i),
         None => (value % MODULUS).to_i64().unwrap_or_else(|| unsafe {
             // SAFETY: MODULUS < i64::MAX, so value % MODULUS is guaranteed to be in the range of i64
-            std::hint::unreachable_unchecked()
+            core::hint::unreachable_unchecked()
         }),
     };
     fix_sentinel(ret)
diff --git a/crates/common/src/int.rs b/crates/common/src/int.rs
new file mode 100644
index 0000000000..57696e21fe
--- /dev/null
+++ b/crates/common/src/int.rs
@@ -0,0 +1,208 @@
+use malachite_base::{num::conversion::traits::RoundingInto, rounding_modes::RoundingMode};
+use malachite_bigint::{BigInt, BigUint, Sign};
+use malachite_q::Rational;
+use num_traits::{One, ToPrimitive, Zero};
+
+pub fn true_div(numerator: &BigInt, denominator: &BigInt) -> f64 {
+    let rational = Rational::from_integers_ref(numerator.into(), denominator.into());
+    match rational.rounding_into(RoundingMode::Nearest) {
+        // returned value is $t::MAX but still less than the original
+        (val, core::cmp::Ordering::Less) if val == f64::MAX => f64::INFINITY,
+        // returned value is $t::MIN but still greater than the original
+        (val, core::cmp::Ordering::Greater) if val == f64::MIN => f64::NEG_INFINITY,
+        (val, _) => val,
+    }
+}
+
+pub fn float_to_ratio(value: f64) -> Option<(BigInt, BigInt)> {
+    let sign = match core::cmp::PartialOrd::partial_cmp(&value, &0.0)? {
+        core::cmp::Ordering::Less => Sign::Minus,
+        core::cmp::Ordering::Equal => return Some((BigInt::zero(), BigInt::one())),
+        core::cmp::Ordering::Greater => Sign::Plus,
+    };
+    Rational::try_from(value).ok().map(|x| {
+        let (numer, denom) = x.into_numerator_and_denominator();
+        (
+            BigInt::from_biguint(sign, numer.into()),
+            BigUint::from(denom).into(),
+        )
+    })
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum BytesToIntError {
+    InvalidLiteral { base: u32 },
+    InvalidBase,
+    DigitLimit { got: usize, limit: usize },
+}
+
+// https://github.com/python/cpython/blob/4e665351082c50018fb31d80db25b4693057393e/Objects/longobject.c#L2977
+// https://github.com/python/cpython/blob/4e665351082c50018fb31d80db25b4693057393e/Objects/longobject.c#L2884
+pub fn bytes_to_int(
+    buf: &[u8],
+    mut base: u32,
+    digit_limit: usize,
+) -> Result<BigInt, BytesToIntError> {
+    if base != 0 && !(2..=36).contains(&base) {
+        return Err(BytesToIntError::InvalidBase);
+    }
+
+    let mut buf = buf.trim_ascii();
+
+    // split sign
+    let sign = match buf.first() {
+        Some(b'+') => Some(Sign::Plus),
+        Some(b'-') => Some(Sign::Minus),
+        None => return Err(BytesToIntError::InvalidLiteral { base }),
+        _ => None,
+    };
+
+    if sign.is_some() {
+        buf = &buf[1..];
+    }
+
+    let mut error_if_nonzero = false;
+    if base == 0 {
+        match (buf.first(), buf.get(1)) {
+            (Some(v), _) if *v != b'0' => base = 10,
+            (_, Some(b'x' | b'X')) => base = 16,
+            (_, Some(b'o' | b'O')) => base = 8,
+            (_, Some(b'b' | b'B')) => base = 2,
+            (_, _) => {
+                // "old" (C-style) octal literal, now invalid. it might still be zero though
+                base = 10;
+                error_if_nonzero = true;
+            }
+        }
+    }
+
+    if error_if_nonzero {
+        if let [_first, others @ .., last] = buf {
+            let is_zero = *last == b'0' && others.iter().all(|&c| c == b'0' || c == b'_');
+            if !is_zero {
+                return Err(BytesToIntError::InvalidLiteral { base });
+            }
+        }
+        return Ok(BigInt::zero());
+    }
+
+    if buf.first().is_some_and(|&v| v == b'0')
+        && buf.get(1).is_some_and(|&v| {
+            (base == 16 && (v == b'x' || v == b'X'))
+                || (base == 8 && (v == b'o' || v == b'O'))
+                || (base == 2 && (v == b'b' || v == b'B'))
+        })
+    {
+        buf = &buf[2..];
+
+        // One underscore allowed here
+        if buf.first().is_some_and(|&v| v == b'_') {
+            buf = &buf[1..];
+        }
+    }
+
+    // Reject empty strings
+    let mut prev = *buf
+        .first()
+        .ok_or(BytesToIntError::InvalidLiteral { base })?;
+
+    // Leading underscore not allowed
+    if prev == b'_' || !prev.is_ascii_alphanumeric() {
+        return Err(BytesToIntError::InvalidLiteral { base });
+    }
+
+    // Verify all characters are digits and underscores
+    let mut digits = 1;
+    for &cur in buf.iter().skip(1) {
+        if cur == b'_' {
+            // Double underscore not allowed
+            if prev == b'_' {
+                return Err(BytesToIntError::InvalidLiteral { base });
+            }
+        } else if cur.is_ascii_alphanumeric() {
+            digits += 1;
+        } else {
+            return Err(BytesToIntError::InvalidLiteral { base });
+        }
+
+        prev = cur;
+    }
+
+    // Trailing underscore not allowed
+    if prev == b'_' {
+        return Err(BytesToIntError::InvalidLiteral { base });
+    }
+
+    if digit_limit > 0 && !base.is_power_of_two() && digits > digit_limit {
+        return Err(BytesToIntError::DigitLimit {
+            got: digits,
+            limit: digit_limit,
+        });
+    }
+
+    let uint = BigUint::parse_bytes(buf, base).ok_or(BytesToIntError::InvalidLiteral { base })?;
+    Ok(BigInt::from_biguint(sign.unwrap_or(Sign::Plus), uint))
+}
+
+// num-bigint now returns Some(inf) for to_f64() in some cases, so just keep that the same for now
+#[inline(always)]
+pub fn bigint_to_finite_float(int: &BigInt) -> Option<f64> {
+    int.to_f64().filter(|f| f.is_finite())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const DIGIT_LIMIT: usize = 4300; // Default of Cpython
+
+    #[test]
+    fn bytes_to_int_valid() {
+        for ((buf, base), expected) in [
+            (("0b101", 2), BigInt::from(5)),
+            (("0x_10", 16), BigInt::from(16)),
+            (("0b", 16), BigInt::from(11)),
+            (("+0b101", 2), BigInt::from(5)),
+            (("0_0_0", 10), BigInt::from(0)),
+            (("000", 0), BigInt::from(0)),
+            (("0_100", 10), BigInt::from(100)),
+        ] {
+            assert_eq!(
+                bytes_to_int(buf.as_bytes(), base, DIGIT_LIMIT),
+                Ok(expected)
+            );
+        }
+    }
+
+    #[test]
+    fn bytes_to_int_invalid_literal() {
+        for ((buf, base), expected) in [
+            (("09_99", 0), BytesToIntError::InvalidLiteral { base: 10 }),
+            (("0_", 0), BytesToIntError::InvalidLiteral { base: 10 }),
+            (("0_", 2), BytesToIntError::InvalidLiteral { base: 2 }),
+        ] {
+            assert_eq!(
+                bytes_to_int(buf.as_bytes(), base, DIGIT_LIMIT),
+                Err(expected)
+            )
+        }
+    }
+
+    #[test]
+    fn bytes_to_int_invalid_base() {
+        for base in [1, 37] {
+            assert_eq!(
+                bytes_to_int("012345".as_bytes(), base, DIGIT_LIMIT),
+                Err(BytesToIntError::InvalidBase)
+            )
+        }
+    }
+
+    #[test]
+    fn bytes_to_int_digit_limit() {
+        assert_eq!(
+            bytes_to_int("012345".as_bytes(), 10, 5),
+            Err(BytesToIntError::DigitLimit { got: 6, limit: 5 })
+        );
+    }
+}
diff --git a/crates/common/src/lib.rs b/crates/common/src/lib.rs
new file mode 100644
index 0000000000..0181562d04
--- /dev/null
+++ b/crates/common/src/lib.rs
@@ -0,0 +1,39 @@
+//! A crate to hold types and functions common to all rustpython components.
+
+#![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
+
+extern crate alloc;
+
+#[macro_use]
+mod macros;
+pub use macros::*;
+
+pub mod atomic;
+pub mod borrow;
+pub mod boxvec;
+pub mod cformat;
+#[cfg(any(unix, windows, target_os = "wasi"))]
+pub mod crt_fd;
+pub mod encodings;
+#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+pub mod fileutils;
+pub mod float_ops;
+pub mod format;
+pub mod hash;
+pub mod int;
+pub mod linked_list;
+pub mod lock;
+pub mod os;
+pub mod rand;
+pub mod rc;
+pub mod refcount;
+pub mod static_cell;
+pub mod str;
+#[cfg(windows)]
+pub mod windows;
+
+pub use rustpython_wtf8 as wtf8;
+
+pub mod vendored {
+    pub use ascii;
+}
diff --git a/common/src/linked_list.rs b/crates/common/src/linked_list.rs
similarity index 99%
rename from common/src/linked_list.rs
rename to crates/common/src/linked_list.rs
index 8afc1478e6..fb2b126034 100644
--- a/common/src/linked_list.rs
+++ b/crates/common/src/linked_list.rs
@@ -253,7 +253,7 @@ impl<L: Link> LinkedList<L, L::Target> {
     // === rustpython additions ===
 
     pub fn iter(&self) -> impl Iterator<Item = &L::Target> {
-        std::iter::successors(self.head, |node| unsafe {
+        core::iter::successors(self.head, |node| unsafe {
             L::pointers(*node).as_ref().get_next()
         })
         .map(|ptr| unsafe { ptr.as_ref() })
diff --git a/common/src/lock.rs b/crates/common/src/lock.rs
similarity index 100%
rename from common/src/lock.rs
rename to crates/common/src/lock.rs
diff --git a/common/src/lock/cell_lock.rs b/crates/common/src/lock/cell_lock.rs
similarity index 99%
rename from common/src/lock/cell_lock.rs
rename to crates/common/src/lock/cell_lock.rs
index 25a5cfedba..73d722a8fd 100644
--- a/common/src/lock/cell_lock.rs
+++ b/crates/common/src/lock/cell_lock.rs
@@ -1,9 +1,9 @@
 // spell-checker:ignore upgradably sharedly
+use core::{cell::Cell, num::NonZero};
 use lock_api::{
     GetThreadId, RawMutex, RawRwLock, RawRwLockDowngrade, RawRwLockRecursive, RawRwLockUpgrade,
     RawRwLockUpgradeDowngrade,
 };
-use std::{cell::Cell, num::NonZero};
 
 pub struct RawCellMutex {
     locked: Cell<bool>,
diff --git a/common/src/lock/immutable_mutex.rs b/crates/common/src/lock/immutable_mutex.rs
similarity index 95%
rename from common/src/lock/immutable_mutex.rs
rename to crates/common/src/lock/immutable_mutex.rs
index 81c5c93be7..2013cf1c60 100644
--- a/common/src/lock/immutable_mutex.rs
+++ b/crates/common/src/lock/immutable_mutex.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::needless_lifetimes)]
 
+use alloc::fmt;
+use core::{marker::PhantomData, ops::Deref};
 use lock_api::{MutexGuard, RawMutex};
-use std::{fmt, marker::PhantomData, ops::Deref};
 
 /// A mutex guard that has an exclusive lock, but only an immutable reference; useful if you
 /// need to map a mutex guard with a function that returns an `&T`. Construct using the
@@ -22,7 +23,7 @@ impl<'a, R: RawMutex, T: ?Sized> MapImmutable<'a, R, T> for MutexGuard<'a, R, T>
     {
         let raw = unsafe { MutexGuard::mutex(&s).raw() };
         let data = f(&s) as *const U;
-        std::mem::forget(s);
+        core::mem::forget(s);
         ImmutableMappedMutexGuard {
             raw,
             data,
@@ -38,7 +39,7 @@ impl<'a, R: RawMutex, T: ?Sized> ImmutableMappedMutexGuard<'a, R, T> {
     {
         let raw = s.raw;
         let data = f(&s) as *const U;
-        std::mem::forget(s);
+        core::mem::forget(s);
         ImmutableMappedMutexGuard {
             raw,
             data,
diff --git a/common/src/lock/thread_mutex.rs b/crates/common/src/lock/thread_mutex.rs
similarity index 98%
rename from common/src/lock/thread_mutex.rs
rename to crates/common/src/lock/thread_mutex.rs
index 2949a3c6c1..67ffc89245 100644
--- a/common/src/lock/thread_mutex.rs
+++ b/crates/common/src/lock/thread_mutex.rs
@@ -1,14 +1,14 @@
 #![allow(clippy::needless_lifetimes)]
 
-use lock_api::{GetThreadId, GuardNoSend, RawMutex};
-use std::{
+use alloc::fmt;
+use core::{
     cell::UnsafeCell,
-    fmt,
     marker::PhantomData,
     ops::{Deref, DerefMut},
     ptr::NonNull,
     sync::atomic::{AtomicUsize, Ordering},
 };
+use lock_api::{GetThreadId, GuardNoSend, RawMutex};
 
 // based off ReentrantMutex from lock_api
 
@@ -174,7 +174,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutexGuard<'a, R, G, T> {
     ) -> MappedThreadMutexGuard<'a, R, G, U> {
         let data = f(&mut s).into();
         let mu = &s.mu.raw;
-        std::mem::forget(s);
+        core::mem::forget(s);
         MappedThreadMutexGuard {
             mu,
             data,
@@ -188,7 +188,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutexGuard<'a, R, G, T> {
         if let Some(data) = f(&mut s) {
             let data = data.into();
             let mu = &s.mu.raw;
-            std::mem::forget(s);
+            core::mem::forget(s);
             Ok(MappedThreadMutexGuard {
                 mu,
                 data,
@@ -241,7 +241,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> MappedThreadMutexGuard<'a, R, G
     ) -> MappedThreadMutexGuard<'a, R, G, U> {
         let data = f(&mut s).into();
         let mu = s.mu;
-        std::mem::forget(s);
+        core::mem::forget(s);
         MappedThreadMutexGuard {
             mu,
             data,
@@ -255,7 +255,7 @@ impl<'a, R: RawMutex, G: GetThreadId, T: ?Sized> MappedThreadMutexGuard<'a, R, G
         if let Some(data) = f(&mut s) {
             let data = data.into();
             let mu = s.mu;
-            std::mem::forget(s);
+            core::mem::forget(s);
             Ok(MappedThreadMutexGuard {
                 mu,
                 data,
diff --git a/common/src/macros.rs b/crates/common/src/macros.rs
similarity index 100%
rename from common/src/macros.rs
rename to crates/common/src/macros.rs
diff --git a/crates/common/src/os.rs b/crates/common/src/os.rs
new file mode 100644
index 0000000000..1ce25988d2
--- /dev/null
+++ b/crates/common/src/os.rs
@@ -0,0 +1,228 @@
+// spell-checker:disable
+// TODO: we can move more os-specific bindings/interfaces from stdlib::{os, posix, nt} to here
+
+use core::str::Utf8Error;
+use std::{io, process::ExitCode};
+
+/// Convert exit code to std::process::ExitCode
+///
+/// On Windows, this supports the full u32 range including STATUS_CONTROL_C_EXIT (0xC000013A).
+/// On other platforms, only the lower 8 bits are used.
+pub fn exit_code(code: u32) -> ExitCode {
+    #[cfg(windows)]
+    {
+        // For large exit codes like STATUS_CONTROL_C_EXIT (0xC000013A),
+        // we need to call std::process::exit() directly since ExitCode::from(u8)
+        // would truncate the value, and ExitCode::from_raw() is still unstable.
+        // FIXME: side effect in exit_code is not ideal.
+        if code > u8::MAX as u32 {
+            std::process::exit(code as i32)
+        }
+    }
+    ExitCode::from(code as u8)
+}
+
+pub trait ErrorExt {
+    fn posix_errno(&self) -> i32;
+}
+
+impl ErrorExt for io::Error {
+    #[cfg(not(windows))]
+    fn posix_errno(&self) -> i32 {
+        self.raw_os_error().unwrap_or(0)
+    }
+    #[cfg(windows)]
+    fn posix_errno(&self) -> i32 {
+        let winerror = self.raw_os_error().unwrap_or(0);
+        winerror_to_errno(winerror)
+    }
+}
+
+/// Get the last error from C runtime library functions (like _dup, _dup2, _fstat, etc.)
+/// CRT functions set errno, not GetLastError(), so we need to read errno directly.
+#[cfg(windows)]
+pub fn errno_io_error() -> io::Error {
+    let errno: i32 = get_errno();
+    let winerror = errno_to_winerror(errno);
+    io::Error::from_raw_os_error(winerror)
+}
+
+#[cfg(not(windows))]
+pub fn errno_io_error() -> io::Error {
+    std::io::Error::last_os_error()
+}
+
+#[cfg(windows)]
+pub fn get_errno() -> i32 {
+    unsafe extern "C" {
+        fn _get_errno(pValue: *mut i32) -> i32;
+    }
+    let mut errno = 0;
+    unsafe { suppress_iph!(_get_errno(&mut errno)) };
+    errno
+}
+
+#[cfg(not(windows))]
+pub fn get_errno() -> i32 {
+    std::io::Error::last_os_error().posix_errno()
+}
+
+/// Set errno to the specified value.
+#[cfg(windows)]
+pub fn set_errno(value: i32) {
+    unsafe extern "C" {
+        fn _set_errno(value: i32) -> i32;
+    }
+    unsafe { suppress_iph!(_set_errno(value)) };
+}
+
+#[cfg(unix)]
+pub fn set_errno(value: i32) {
+    nix::errno::Errno::from_raw(value).set();
+}
+
+#[cfg(unix)]
+pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
+    use std::os::unix::ffi::OsStrExt;
+    Ok(std::ffi::OsStr::from_bytes(b))
+}
+
+#[cfg(not(unix))]
+pub fn bytes_as_os_str(b: &[u8]) -> Result<&std::ffi::OsStr, Utf8Error> {
+    Ok(core::str::from_utf8(b)?.as_ref())
+}
+
+#[cfg(unix)]
+pub use std::os::unix::ffi;
+#[cfg(target_os = "wasi")]
+pub use std::os::wasi::ffi;
+
+#[cfg(windows)]
+pub fn errno_to_winerror(errno: i32) -> i32 {
+    use libc::*;
+    use windows_sys::Win32::Foundation::*;
+    let winerror = match errno {
+        ENOENT => ERROR_FILE_NOT_FOUND,
+        E2BIG => ERROR_BAD_ENVIRONMENT,
+        ENOEXEC => ERROR_BAD_FORMAT,
+        EBADF => ERROR_INVALID_HANDLE,
+        ECHILD => ERROR_WAIT_NO_CHILDREN,
+        EAGAIN => ERROR_NO_PROC_SLOTS,
+        ENOMEM => ERROR_NOT_ENOUGH_MEMORY,
+        EACCES => ERROR_ACCESS_DENIED,
+        EEXIST => ERROR_FILE_EXISTS,
+        EXDEV => ERROR_NOT_SAME_DEVICE,
+        ENOTDIR => ERROR_DIRECTORY,
+        EMFILE => ERROR_TOO_MANY_OPEN_FILES,
+        ENOSPC => ERROR_DISK_FULL,
+        EPIPE => ERROR_BROKEN_PIPE,
+        ENOTEMPTY => ERROR_DIR_NOT_EMPTY,
+        EILSEQ => ERROR_NO_UNICODE_TRANSLATION,
+        EINVAL => ERROR_INVALID_FUNCTION,
+        _ => ERROR_INVALID_FUNCTION,
+    };
+    winerror as _
+}
+
+// winerror: https://learn.microsoft.com/windows/win32/debug/system-error-codes--0-499-
+// errno: https://learn.microsoft.com/cpp/c-runtime-library/errno-constants?view=msvc-170
+#[cfg(windows)]
+pub fn winerror_to_errno(winerror: i32) -> i32 {
+    use libc::*;
+    use windows_sys::Win32::{
+        Foundation::*,
+        Networking::WinSock::{WSAEACCES, WSAEBADF, WSAEFAULT, WSAEINTR, WSAEINVAL, WSAEMFILE},
+    };
+    // Unwrap FACILITY_WIN32 HRESULT errors.
+    // if ((winerror & 0xFFFF0000) == 0x80070000) {
+    //     winerror &= 0x0000FFFF;
+    // }
+
+    // Winsock error codes (10000-11999) are errno values.
+    if (10000..12000).contains(&winerror) {
+        match winerror {
+            WSAEINTR | WSAEBADF | WSAEACCES | WSAEFAULT | WSAEINVAL | WSAEMFILE => {
+                // Winsock definitions of errno values. See WinSock2.h
+                return winerror - 10000;
+            }
+            _ => return winerror as _,
+        }
+    }
+
+    #[allow(non_upper_case_globals)]
+    match winerror as u32 {
+        ERROR_FILE_NOT_FOUND
+        | ERROR_PATH_NOT_FOUND
+        | ERROR_INVALID_DRIVE
+        | ERROR_NO_MORE_FILES
+        | ERROR_BAD_NETPATH
+        | ERROR_BAD_NET_NAME
+        | ERROR_BAD_PATHNAME
+        | ERROR_FILENAME_EXCED_RANGE => ENOENT,
+        ERROR_BAD_ENVIRONMENT => E2BIG,
+        ERROR_BAD_FORMAT
+        | ERROR_INVALID_STARTING_CODESEG
+        | ERROR_INVALID_STACKSEG
+        | ERROR_INVALID_MODULETYPE
+        | ERROR_INVALID_EXE_SIGNATURE
+        | ERROR_EXE_MARKED_INVALID
+        | ERROR_BAD_EXE_FORMAT
+        | ERROR_ITERATED_DATA_EXCEEDS_64k
+        | ERROR_INVALID_MINALLOCSIZE
+        | ERROR_DYNLINK_FROM_INVALID_RING
+        | ERROR_IOPL_NOT_ENABLED
+        | ERROR_INVALID_SEGDPL
+        | ERROR_AUTODATASEG_EXCEEDS_64k
+        | ERROR_RING2SEG_MUST_BE_MOVABLE
+        | ERROR_RELOC_CHAIN_XEEDS_SEGLIM
+        | ERROR_INFLOOP_IN_RELOC_CHAIN => ENOEXEC,
+        ERROR_INVALID_HANDLE | ERROR_INVALID_TARGET_HANDLE | ERROR_DIRECT_ACCESS_HANDLE => EBADF,
+        ERROR_WAIT_NO_CHILDREN | ERROR_CHILD_NOT_COMPLETE => ECHILD,
+        ERROR_NO_PROC_SLOTS | ERROR_MAX_THRDS_REACHED | ERROR_NESTING_NOT_ALLOWED => EAGAIN,
+        ERROR_ARENA_TRASHED
+        | ERROR_NOT_ENOUGH_MEMORY
+        | ERROR_INVALID_BLOCK
+        | ERROR_NOT_ENOUGH_QUOTA => ENOMEM,
+        ERROR_ACCESS_DENIED
+        | ERROR_CURRENT_DIRECTORY
+        | ERROR_WRITE_PROTECT
+        | ERROR_BAD_UNIT
+        | ERROR_NOT_READY
+        | ERROR_BAD_COMMAND
+        | ERROR_CRC
+        | ERROR_BAD_LENGTH
+        | ERROR_SEEK
+        | ERROR_NOT_DOS_DISK
+        | ERROR_SECTOR_NOT_FOUND
+        | ERROR_OUT_OF_PAPER
+        | ERROR_WRITE_FAULT
+        | ERROR_READ_FAULT
+        | ERROR_GEN_FAILURE
+        | ERROR_SHARING_VIOLATION
+        | ERROR_LOCK_VIOLATION
+        | ERROR_WRONG_DISK
+        | ERROR_SHARING_BUFFER_EXCEEDED
+        | ERROR_NETWORK_ACCESS_DENIED
+        | ERROR_CANNOT_MAKE
+        | ERROR_FAIL_I24
+        | ERROR_DRIVE_LOCKED
+        | ERROR_SEEK_ON_DEVICE
+        | ERROR_NOT_LOCKED
+        | ERROR_LOCK_FAILED
+        | 35 => EACCES,
+        ERROR_FILE_EXISTS | ERROR_ALREADY_EXISTS => EEXIST,
+        ERROR_NOT_SAME_DEVICE => EXDEV,
+        ERROR_DIRECTORY => ENOTDIR,
+        ERROR_TOO_MANY_OPEN_FILES => EMFILE,
+        ERROR_DISK_FULL => ENOSPC,
+        ERROR_BROKEN_PIPE | ERROR_NO_DATA => EPIPE,
+        ERROR_DIR_NOT_EMPTY => ENOTEMPTY,
+        ERROR_NO_UNICODE_TRANSLATION => EILSEQ,
+        ERROR_INVALID_FUNCTION
+        | ERROR_INVALID_ACCESS
+        | ERROR_INVALID_DATA
+        | ERROR_INVALID_PARAMETER
+        | ERROR_NEGATIVE_SEEK => EINVAL,
+        _ => EINVAL,
+    }
+}
diff --git a/common/src/rand.rs b/crates/common/src/rand.rs
similarity index 100%
rename from common/src/rand.rs
rename to crates/common/src/rand.rs
diff --git a/common/src/rc.rs b/crates/common/src/rc.rs
similarity index 89%
rename from common/src/rc.rs
rename to crates/common/src/rc.rs
index 40c7cf97a8..9e4cca228f 100644
--- a/common/src/rc.rs
+++ b/crates/common/src/rc.rs
@@ -1,7 +1,7 @@
 #[cfg(not(feature = "threading"))]
-use std::rc::Rc;
+use alloc::rc::Rc;
 #[cfg(feature = "threading")]
-use std::sync::Arc;
+use alloc::sync::Arc;
 
 // type aliases instead of new-types because you can't do `fn method(self: PyRc<Self>)` with a
 // newtype; requires the arbitrary_self_types unstable feature
diff --git a/common/src/refcount.rs b/crates/common/src/refcount.rs
similarity index 100%
rename from common/src/refcount.rs
rename to crates/common/src/refcount.rs
diff --git a/common/src/static_cell.rs b/crates/common/src/static_cell.rs
similarity index 100%
rename from common/src/static_cell.rs
rename to crates/common/src/static_cell.rs
diff --git a/crates/common/src/str.rs b/crates/common/src/str.rs
new file mode 100644
index 0000000000..155012ed21
--- /dev/null
+++ b/crates/common/src/str.rs
@@ -0,0 +1,677 @@
+// spell-checker:ignore uncomputed
+use crate::atomic::{PyAtomic, Radium};
+use crate::format::CharLen;
+use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
+use ascii::{AsciiChar, AsciiStr, AsciiString};
+use core::fmt;
+use core::ops::{Bound, RangeBounds};
+use core::sync::atomic::Ordering::Relaxed;
+
+#[cfg(not(target_arch = "wasm32"))]
+#[allow(non_camel_case_types)]
+pub type wchar_t = libc::wchar_t;
+#[cfg(target_arch = "wasm32")]
+#[allow(non_camel_case_types)]
+pub type wchar_t = u32;
+
+/// Utf8 + state.ascii (+ PyUnicode_Kind in future)
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum StrKind {
+    Ascii,
+    Utf8,
+    Wtf8,
+}
+
+impl core::ops::BitOr for StrKind {
+    type Output = Self;
+
+    fn bitor(self, other: Self) -> Self {
+        use StrKind::*;
+        match (self, other) {
+            (Wtf8, _) | (_, Wtf8) => Wtf8,
+            (Utf8, _) | (_, Utf8) => Utf8,
+            (Ascii, Ascii) => Ascii,
+        }
+    }
+}
+
+impl StrKind {
+    pub const fn is_ascii(&self) -> bool {
+        matches!(self, Self::Ascii)
+    }
+
+    pub const fn is_utf8(&self) -> bool {
+        matches!(self, Self::Ascii | Self::Utf8)
+    }
+
+    #[inline(always)]
+    pub fn can_encode(&self, code: CodePoint) -> bool {
+        match self {
+            Self::Ascii => code.is_ascii(),
+            Self::Utf8 => code.to_char().is_some(),
+            Self::Wtf8 => true,
+        }
+    }
+}
+
+pub trait DeduceStrKind {
+    fn str_kind(&self) -> StrKind;
+}
+
+impl DeduceStrKind for str {
+    fn str_kind(&self) -> StrKind {
+        if self.is_ascii() {
+            StrKind::Ascii
+        } else {
+            StrKind::Utf8
+        }
+    }
+}
+
+impl DeduceStrKind for Wtf8 {
+    fn str_kind(&self) -> StrKind {
+        if self.is_ascii() {
+            StrKind::Ascii
+        } else if self.is_utf8() {
+            StrKind::Utf8
+        } else {
+            StrKind::Wtf8
+        }
+    }
+}
+
+impl DeduceStrKind for String {
+    fn str_kind(&self) -> StrKind {
+        (**self).str_kind()
+    }
+}
+
+impl DeduceStrKind for Wtf8Buf {
+    fn str_kind(&self) -> StrKind {
+        (**self).str_kind()
+    }
+}
+
+impl<T: DeduceStrKind + ?Sized> DeduceStrKind for &T {
+    fn str_kind(&self) -> StrKind {
+        (**self).str_kind()
+    }
+}
+
+impl<T: DeduceStrKind + ?Sized> DeduceStrKind for Box<T> {
+    fn str_kind(&self) -> StrKind {
+        (**self).str_kind()
+    }
+}
+
+#[derive(Debug)]
+pub enum PyKindStr<'a> {
+    Ascii(&'a AsciiStr),
+    Utf8(&'a str),
+    Wtf8(&'a Wtf8),
+}
+
+#[derive(Debug, Clone)]
+pub struct StrData {
+    data: Box<Wtf8>,
+    kind: StrKind,
+    len: StrLen,
+}
+
+struct StrLen(PyAtomic<usize>);
+
+impl From<usize> for StrLen {
+    #[inline(always)]
+    fn from(value: usize) -> Self {
+        Self(Radium::new(value))
+    }
+}
+
+impl fmt::Debug for StrLen {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let len = self.0.load(Relaxed);
+        if len == usize::MAX {
+            f.write_str("<uncomputed>")
+        } else {
+            len.fmt(f)
+        }
+    }
+}
+
+impl StrLen {
+    #[inline(always)]
+    fn zero() -> Self {
+        0usize.into()
+    }
+
+    #[inline(always)]
+    fn uncomputed() -> Self {
+        usize::MAX.into()
+    }
+}
+
+impl Clone for StrLen {
+    fn clone(&self) -> Self {
+        Self(self.0.load(Relaxed).into())
+    }
+}
+
+impl Default for StrData {
+    fn default() -> Self {
+        Self {
+            data: <Box<Wtf8>>::default(),
+            kind: StrKind::Ascii,
+            len: StrLen::zero(),
+        }
+    }
+}
+
+impl From<Box<Wtf8>> for StrData {
+    fn from(value: Box<Wtf8>) -> Self {
+        // doing the check is ~10x faster for ascii, and is actually only 2% slower worst case for
+        // non-ascii; see https://github.com/RustPython/RustPython/pull/2586#issuecomment-844611532
+        let kind = value.str_kind();
+        unsafe { Self::new_str_unchecked(value, kind) }
+    }
+}
+
+impl From<Box<str>> for StrData {
+    #[inline]
+    fn from(value: Box<str>) -> Self {
+        // doing the check is ~10x faster for ascii, and is actually only 2% slower worst case for
+        // non-ascii; see https://github.com/RustPython/RustPython/pull/2586#issuecomment-844611532
+        let kind = value.str_kind();
+        unsafe { Self::new_str_unchecked(value.into(), kind) }
+    }
+}
+
+impl From<Box<AsciiStr>> for StrData {
+    #[inline]
+    fn from(value: Box<AsciiStr>) -> Self {
+        Self {
+            len: value.len().into(),
+            data: value.into(),
+            kind: StrKind::Ascii,
+        }
+    }
+}
+
+impl From<AsciiChar> for StrData {
+    fn from(ch: AsciiChar) -> Self {
+        AsciiString::from(ch).into_boxed_ascii_str().into()
+    }
+}
+
+impl From<char> for StrData {
+    fn from(ch: char) -> Self {
+        if let Ok(ch) = ascii::AsciiChar::from_ascii(ch) {
+            ch.into()
+        } else {
+            Self {
+                data: ch.to_string().into(),
+                kind: StrKind::Utf8,
+                len: 1.into(),
+            }
+        }
+    }
+}
+
+impl From<CodePoint> for StrData {
+    fn from(ch: CodePoint) -> Self {
+        if let Some(ch) = ch.to_char() {
+            ch.into()
+        } else {
+            Self {
+                data: Wtf8Buf::from(ch).into(),
+                kind: StrKind::Wtf8,
+                len: 1.into(),
+            }
+        }
+    }
+}
+
+impl StrData {
+    /// # Safety
+    ///
+    /// Given `bytes` must be valid data for given `kind`
+    pub unsafe fn new_str_unchecked(data: Box<Wtf8>, kind: StrKind) -> Self {
+        let len = match kind {
+            StrKind::Ascii => data.len().into(),
+            _ => StrLen::uncomputed(),
+        };
+        Self { data, kind, len }
+    }
+
+    /// # Safety
+    ///
+    /// `char_len` must be accurate.
+    pub unsafe fn new_with_char_len(data: Box<Wtf8>, kind: StrKind, char_len: usize) -> Self {
+        Self {
+            data,
+            kind,
+            len: char_len.into(),
+        }
+    }
+
+    #[inline]
+    pub const fn as_wtf8(&self) -> &Wtf8 {
+        &self.data
+    }
+
+    #[inline]
+    pub fn as_str(&self) -> Option<&str> {
+        self.kind
+            .is_utf8()
+            .then(|| unsafe { core::str::from_utf8_unchecked(self.data.as_bytes()) })
+    }
+
+    pub fn as_ascii(&self) -> Option<&AsciiStr> {
+        self.kind
+            .is_ascii()
+            .then(|| unsafe { AsciiStr::from_ascii_unchecked(self.data.as_bytes()) })
+    }
+
+    pub const fn kind(&self) -> StrKind {
+        self.kind
+    }
+
+    #[inline]
+    pub fn as_str_kind(&self) -> PyKindStr<'_> {
+        match self.kind {
+            StrKind::Ascii => {
+                PyKindStr::Ascii(unsafe { AsciiStr::from_ascii_unchecked(self.data.as_bytes()) })
+            }
+            StrKind::Utf8 => {
+                PyKindStr::Utf8(unsafe { core::str::from_utf8_unchecked(self.data.as_bytes()) })
+            }
+            StrKind::Wtf8 => PyKindStr::Wtf8(&self.data),
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    #[inline]
+    pub fn char_len(&self) -> usize {
+        match self.len.0.load(Relaxed) {
+            usize::MAX => self._compute_char_len(),
+            len => len,
+        }
+    }
+
+    #[cold]
+    fn _compute_char_len(&self) -> usize {
+        let len = if let Some(s) = self.as_str() {
+            // utf8 chars().count() is optimized
+            s.chars().count()
+        } else {
+            self.data.code_points().count()
+        };
+        // len cannot be usize::MAX, since vec.capacity() < sys.maxsize
+        self.len.0.store(len, Relaxed);
+        len
+    }
+
+    pub fn nth_char(&self, index: usize) -> CodePoint {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s[index].into(),
+            PyKindStr::Utf8(s) => s.chars().nth(index).unwrap().into(),
+            PyKindStr::Wtf8(w) => w.code_points().nth(index).unwrap(),
+        }
+    }
+}
+
+impl core::fmt::Display for StrData {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.data.fmt(f)
+    }
+}
+
+impl CharLen for StrData {
+    fn char_len(&self) -> usize {
+        self.char_len()
+    }
+}
+
+pub fn try_get_chars(s: &str, range: impl RangeBounds<usize>) -> Option<&str> {
+    let mut chars = s.chars();
+    let start = match range.start_bound() {
+        Bound::Included(&i) => i,
+        Bound::Excluded(&i) => i + 1,
+        Bound::Unbounded => 0,
+    };
+    for _ in 0..start {
+        chars.next()?;
+    }
+    let s = chars.as_str();
+    let range_len = match range.end_bound() {
+        Bound::Included(&i) => i + 1 - start,
+        Bound::Excluded(&i) => i - start,
+        Bound::Unbounded => return Some(s),
+    };
+    char_range_end(s, range_len).map(|end| &s[..end])
+}
+
+pub fn get_chars(s: &str, range: impl RangeBounds<usize>) -> &str {
+    try_get_chars(s, range).unwrap()
+}
+
+#[inline]
+pub fn char_range_end(s: &str, n_chars: usize) -> Option<usize> {
+    let i = match n_chars.checked_sub(1) {
+        Some(last_char_index) => {
+            let (index, c) = s.char_indices().nth(last_char_index)?;
+            index + c.len_utf8()
+        }
+        None => 0,
+    };
+    Some(i)
+}
+
+pub fn try_get_codepoints(w: &Wtf8, range: impl RangeBounds<usize>) -> Option<&Wtf8> {
+    let mut chars = w.code_points();
+    let start = match range.start_bound() {
+        Bound::Included(&i) => i,
+        Bound::Excluded(&i) => i + 1,
+        Bound::Unbounded => 0,
+    };
+    for _ in 0..start {
+        chars.next()?;
+    }
+    let s = chars.as_wtf8();
+    let range_len = match range.end_bound() {
+        Bound::Included(&i) => i + 1 - start,
+        Bound::Excluded(&i) => i - start,
+        Bound::Unbounded => return Some(s),
+    };
+    codepoint_range_end(s, range_len).map(|end| &s[..end])
+}
+
+pub fn get_codepoints(w: &Wtf8, range: impl RangeBounds<usize>) -> &Wtf8 {
+    try_get_codepoints(w, range).unwrap()
+}
+
+#[inline]
+pub fn codepoint_range_end(s: &Wtf8, n_chars: usize) -> Option<usize> {
+    let i = match n_chars.checked_sub(1) {
+        Some(last_char_index) => {
+            let (index, c) = s.code_point_indices().nth(last_char_index)?;
+            index + c.len_wtf8()
+        }
+        None => 0,
+    };
+    Some(i)
+}
+
+pub fn zfill(bytes: &[u8], width: usize) -> Vec<u8> {
+    if width <= bytes.len() {
+        bytes.to_vec()
+    } else {
+        let (sign, s) = match bytes.first() {
+            Some(_sign @ b'+') | Some(_sign @ b'-') => {
+                (unsafe { bytes.get_unchecked(..1) }, &bytes[1..])
+            }
+            _ => (&b""[..], bytes),
+        };
+        let mut filled = Vec::new();
+        filled.extend_from_slice(sign);
+        filled.extend(core::iter::repeat_n(b'0', width - bytes.len()));
+        filled.extend_from_slice(s);
+        filled
+    }
+}
+
+/// Convert a string to ascii compatible, escaping unicode-s into escape
+/// sequences.
+pub fn to_ascii(value: &str) -> AsciiString {
+    let mut ascii = Vec::new();
+    for c in value.chars() {
+        if c.is_ascii() {
+            ascii.push(c as u8);
+        } else {
+            let c = c as i64;
+            let hex = if c < 0x100 {
+                format!("\\x{c:02x}")
+            } else if c < 0x10000 {
+                format!("\\u{c:04x}")
+            } else {
+                format!("\\U{c:08x}")
+            };
+            ascii.append(&mut hex.into_bytes());
+        }
+    }
+    unsafe { AsciiString::from_ascii_unchecked(ascii) }
+}
+
+pub struct UnicodeEscapeCodepoint(pub CodePoint);
+
+impl fmt::Display for UnicodeEscapeCodepoint {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let c = self.0.to_u32();
+        if c >= 0x10000 {
+            write!(f, "\\U{c:08x}")
+        } else if c >= 0x100 {
+            write!(f, "\\u{c:04x}")
+        } else {
+            write!(f, "\\x{c:02x}")
+        }
+    }
+}
+
+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;
+
+    const fn substitution_cost(mut a: u8, mut b: u8) -> usize {
+        if (a & 31) != (b & 31) {
+            return MOVE_COST;
+        }
+        if a == b {
+            return 0;
+        }
+        if a.is_ascii_uppercase() {
+            a += b'a' - b'A';
+        }
+        if b.is_ascii_uppercase() {
+            b += b'a' - b'A';
+        }
+        if a == b { CASE_COST } else { MOVE_COST }
+    }
+
+    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;
+        }
+
+        let (mut a_bytes, mut b_bytes) = (a, b);
+        let (mut a_begin, mut a_end) = (0usize, a.len());
+        let (mut b_begin, mut b_end) = (0usize, b.len());
+
+        while a_end > 0 && b_end > 0 && (a_bytes[a_begin] == b_bytes[b_begin]) {
+            a_begin += 1;
+            b_begin += 1;
+            a_end -= 1;
+            b_end -= 1;
+        }
+        while a_end > 0
+            && b_end > 0
+            && (a_bytes[a_begin + a_end - 1] == b_bytes[b_begin + b_end - 1])
+        {
+            a_end -= 1;
+            b_end -= 1;
+        }
+        if a_end == 0 || b_end == 0 {
+            return (a_end + b_end) * MOVE_COST;
+        }
+        if a_end > MAX_STRING_SIZE || b_end > MAX_STRING_SIZE {
+            return max_cost + 1;
+        }
+
+        if b_end < a_end {
+            core::mem::swap(&mut a_bytes, &mut b_bytes);
+            core::mem::swap(&mut a_begin, &mut b_begin);
+            core::mem::swap(&mut a_end, &mut b_end);
+        }
+
+        if (b_end - a_end) * MOVE_COST > max_cost {
+            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 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;
+                }
+            }
+            result
+        })
+    }
+}
+
+/// Replace all tabs in a string with spaces, using the given tab size.
+pub fn expandtabs(input: &str, tab_size: usize) -> String {
+    let tab_stop = tab_size;
+    let mut expanded_str = String::with_capacity(input.len());
+    let mut tab_size = tab_stop;
+    let mut col_count = 0usize;
+    for ch in input.chars() {
+        match ch {
+            '\t' => {
+                let num_spaces = tab_size - col_count;
+                col_count += num_spaces;
+                let expand = " ".repeat(num_spaces);
+                expanded_str.push_str(&expand);
+            }
+            '\r' | '\n' => {
+                expanded_str.push(ch);
+                col_count = 0;
+                tab_size = 0;
+            }
+            _ => {
+                expanded_str.push(ch);
+                col_count += 1;
+            }
+        }
+        if col_count >= tab_size {
+            tab_size += tab_stop;
+        }
+    }
+    expanded_str
+}
+
+/// Creates an [`AsciiStr`][ascii::AsciiStr] from a string literal, throwing a compile error if the
+/// literal isn't actually ascii.
+///
+/// ```compile_fail
+/// # use rustpython_common::str::ascii;
+/// ascii!("I ❤️ Rust & Python");
+/// ```
+#[macro_export]
+macro_rules! ascii {
+    ($x:expr $(,)?) => {{
+        let s = const {
+            let s: &str = $x;
+            assert!(s.is_ascii(), "ascii!() argument is not an ascii string");
+            s
+        };
+        unsafe { $crate::vendored::ascii::AsciiStr::from_ascii_unchecked(s.as_bytes()) }
+    }};
+}
+pub use ascii;
+
+// TODO: this should probably live in a crate like unic or unicode-properties
+const UNICODE_DECIMAL_VALUES: &[char] = &[
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '٠', '١', '٢', '٣', '٤', '٥', '٦', '٧', '٨',
+    '٩', '۰', '۱', '۲', '۳', '۴', '۵', '۶', '۷', '۸', '۹', '߀', '߁', '߂', '߃', '߄', '߅', '߆', '߇',
+    '߈', '߉', '०', '१', '२', '३', '४', '५', '६', '७', '८', '९', '০', '১', '২', '৩', '৪', '৫', '৬',
+    '৭', '৮', '৯', '੦', '੧', '੨', '੩', '੪', '੫', '੬', '੭', '੮', '੯', '૦', '૧', '૨', '૩', '૪', '૫',
+    '૬', '૭', '૮', '૯', '୦', '୧', '୨', '୩', '୪', '୫', '୬', '୭', '୮', '୯', '௦', '௧', '௨', '௩', '௪',
+    '௫', '௬', '௭', '௮', '௯', '౦', '౧', '౨', '౩', '౪', '౫', '౬', '౭', '౮', '౯', '೦', '೧', '೨', '೩',
+    '೪', '೫', '೬', '೭', '೮', '೯', '൦', '൧', '൨', '൩', '൪', '൫', '൬', '൭', '൮', '൯', '෦', '෧', '෨',
+    '෩', '෪', '෫', '෬', '෭', '෮', '෯', '๐', '๑', '๒', '๓', '๔', '๕', '๖', '๗', '๘', '๙', '໐', '໑',
+    '໒', '໓', '໔', '໕', '໖', '໗', '໘', '໙', '༠', '༡', '༢', '༣', '༤', '༥', '༦', '༧', '༨', '༩', '၀',
+    '၁', '၂', '၃', '၄', '၅', '၆', '၇', '၈', '၉', '႐', '႑', '႒', '႓', '႔', '႕', '႖', '႗', '႘', '႙',
+    '០', '១', '២', '៣', '៤', '៥', '៦', '៧', '៨', '៩', '᠐', '᠑', '᠒', '᠓', '᠔', '᠕', '᠖', '᠗', '᠘',
+    '᠙', '᥆', '᥇', '᥈', '᥉', '᥊', '᥋', '᥌', '᥍', '᥎', '᥏', '᧐', '᧑', '᧒', '᧓', '᧔', '᧕', '᧖', '᧗',
+    '᧘', '᧙', '᪀', '᪁', '᪂', '᪃', '᪄', '᪅', '᪆', '᪇', '᪈', '᪉', '᪐', '᪑', '᪒', '᪓', '᪔', '᪕', '᪖',
+    '᪗', '᪘', '᪙', '᭐', '᭑', '᭒', '᭓', '᭔', '᭕', '᭖', '᭗', '᭘', '᭙', '᮰', '᮱', '᮲', '᮳', '᮴', '᮵',
+    '᮶', '᮷', '᮸', '᮹', '᱀', '᱁', '᱂', '᱃', '᱄', '᱅', '᱆', '᱇', '᱈', '᱉', '᱐', '᱑', '᱒', '᱓', '᱔',
+    '᱕', '᱖', '᱗', '᱘', '᱙', '꘠', '꘡', '꘢', '꘣', '꘤', '꘥', '꘦', '꘧', '꘨', '꘩', '꣐', '꣑', '꣒', '꣓',
+    '꣔', '꣕', '꣖', '꣗', '꣘', '꣙', '꤀', '꤁', '꤂', '꤃', '꤄', '꤅', '꤆', '꤇', '꤈', '꤉', '꧐', '꧑', '꧒',
+    '꧓', '꧔', '꧕', '꧖', '꧗', '꧘', '꧙', '꧰', '꧱', '꧲', '꧳', '꧴', '꧵', '꧶', '꧷', '꧸', '꧹', '꩐', '꩑',
+    '꩒', '꩓', '꩔', '꩕', '꩖', '꩗', '꩘', '꩙', '꯰', '꯱', '꯲', '꯳', '꯴', '꯵', '꯶', '꯷', '꯸', '꯹', '０',
+    '１', '２', '３', '４', '５', '６', '７', '８', '９', '𐒠', '𐒡', '𐒢', '𐒣', '𐒤', '𐒥', '𐒦', '𐒧',
+    '𐒨', '𐒩', '𑁦', '𑁧', '𑁨', '𑁩', '𑁪', '𑁫', '𑁬', '𑁭', '𑁮', '𑁯', '𑃰', '𑃱', '𑃲', '𑃳', '𑃴', '𑃵', '𑃶',
+    '𑃷', '𑃸', '𑃹', '𑄶', '𑄷', '𑄸', '𑄹', '𑄺', '𑄻', '𑄼', '𑄽', '𑄾', '𑄿', '𑇐', '𑇑', '𑇒', '𑇓', '𑇔', '𑇕',
+    '𑇖', '𑇗', '𑇘', '𑇙', '𑋰', '𑋱', '𑋲', '𑋳', '𑋴', '𑋵', '𑋶', '𑋷', '𑋸', '𑋹', '𑑐', '𑑑', '𑑒', '𑑓', '𑑔',
+    '𑑕', '𑑖', '𑑗', '𑑘', '𑑙', '𑓐', '𑓑', '𑓒', '𑓓', '𑓔', '𑓕', '𑓖', '𑓗', '𑓘', '𑓙', '𑙐', '𑙑', '𑙒', '𑙓',
+    '𑙔', '𑙕', '𑙖', '𑙗', '𑙘', '𑙙', '𑛀', '𑛁', '𑛂', '𑛃', '𑛄', '𑛅', '𑛆', '𑛇', '𑛈', '𑛉', '𑜰', '𑜱', '𑜲',
+    '𑜳', '𑜴', '𑜵', '𑜶', '𑜷', '𑜸', '𑜹', '𑣠', '𑣡', '𑣢', '𑣣', '𑣤', '𑣥', '𑣦', '𑣧', '𑣨', '𑣩', '𑱐', '𑱑',
+    '𑱒', '𑱓', '𑱔', '𑱕', '𑱖', '𑱗', '𑱘', '𑱙', '𑵐', '𑵑', '𑵒', '𑵓', '𑵔', '𑵕', '𑵖', '𑵗', '𑵘', '𑵙', '𖩠',
+    '𖩡', '𖩢', '𖩣', '𖩤', '𖩥', '𖩦', '𖩧', '𖩨', '𖩩', '𖭐', '𖭑', '𖭒', '𖭓', '𖭔', '𖭕', '𖭖', '𖭗', '𖭘', '𖭙',
+    '𝟎', '𝟏', '𝟐', '𝟑', '𝟒', '𝟓', '𝟔', '𝟕', '𝟖', '𝟗', '𝟘', '𝟙', '𝟚', '𝟛', '𝟜', '𝟝', '𝟞', '𝟟', '𝟠',
+    '𝟡', '𝟢', '𝟣', '𝟤', '𝟥', '𝟦', '𝟧', '𝟨', '𝟩', '𝟪', '𝟫', '𝟬', '𝟭', '𝟮', '𝟯', '𝟰', '𝟱', '𝟲', '𝟳',
+    '𝟴', '𝟵', '𝟶', '𝟷', '𝟸', '𝟹', '𝟺', '𝟻', '𝟼', '𝟽', '𝟾', '𝟿', '𞥐', '𞥑', '𞥒', '𞥓', '𞥔', '𞥕', '𞥖',
+    '𞥗', '𞥘', '𞥙',
+];
+
+pub fn char_to_decimal(ch: char) -> Option<u8> {
+    UNICODE_DECIMAL_VALUES
+        .binary_search(&ch)
+        .ok()
+        .map(|i| (i % 10) as u8)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_chars() {
+        let s = "0123456789";
+        assert_eq!(get_chars(s, 3..7), "3456");
+        assert_eq!(get_chars(s, 3..7), &s[3..7]);
+
+        let s = "0유니코드 문자열9";
+        assert_eq!(get_chars(s, 3..7), "코드 문");
+
+        let s = "0😀😃😄😁😆😅😂🤣9";
+        assert_eq!(get_chars(s, 3..7), "😄😁😆😅");
+    }
+}
diff --git a/crates/common/src/windows.rs b/crates/common/src/windows.rs
new file mode 100644
index 0000000000..a934a118ec
--- /dev/null
+++ b/crates/common/src/windows.rs
@@ -0,0 +1,56 @@
+use rustpython_wtf8::Wtf8;
+use std::{
+    ffi::{OsStr, OsString},
+    os::windows::ffi::{OsStrExt, OsStringExt},
+};
+
+/// _MAX_ENV from Windows CRT stdlib.h - maximum environment variable size
+pub const _MAX_ENV: usize = 32767;
+
+pub trait ToWideString {
+    fn to_wide(&self) -> Vec<u16>;
+    fn to_wide_with_nul(&self) -> Vec<u16>;
+}
+
+impl<T> ToWideString for T
+where
+    T: AsRef<OsStr>,
+{
+    fn to_wide(&self) -> Vec<u16> {
+        self.as_ref().encode_wide().collect()
+    }
+    fn to_wide_with_nul(&self) -> Vec<u16> {
+        self.as_ref().encode_wide().chain(Some(0)).collect()
+    }
+}
+
+impl ToWideString for OsStr {
+    fn to_wide(&self) -> Vec<u16> {
+        self.encode_wide().collect()
+    }
+    fn to_wide_with_nul(&self) -> Vec<u16> {
+        self.encode_wide().chain(Some(0)).collect()
+    }
+}
+
+impl ToWideString for Wtf8 {
+    fn to_wide(&self) -> Vec<u16> {
+        self.encode_wide().collect()
+    }
+    fn to_wide_with_nul(&self) -> Vec<u16> {
+        self.encode_wide().chain(Some(0)).collect()
+    }
+}
+
+pub trait FromWideString
+where
+    Self: Sized,
+{
+    fn from_wides_until_nul(wide: &[u16]) -> Self;
+}
+impl FromWideString for OsString {
+    fn from_wides_until_nul(wide: &[u16]) -> OsString {
+        let len = wide.iter().take_while(|&&c| c != 0).count();
+        OsString::from_wide(&wide[..len])
+    }
+}
diff --git a/crates/compiler-core/Cargo.toml b/crates/compiler-core/Cargo.toml
new file mode 100644
index 0000000000..f4e619b95a
--- /dev/null
+++ b/crates/compiler-core/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "rustpython-compiler-core"
+description = "RustPython specific bytecode."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+# rustpython-parser-core = { workspace = true, features=["location"] }
+ruff_source_file = { workspace = true }
+rustpython-wtf8 = { workspace = true }
+
+bitflags = { workspace = true }
+itertools = { workspace = true }
+malachite-bigint = { workspace = true }
+num-complex = { workspace = true }
+
+lz4_flex = "0.12"
+
+[lints]
+workspace = true
diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
new file mode 100644
index 0000000000..a0054b2887
--- /dev/null
+++ b/crates/compiler-core/src/bytecode.rs
@@ -0,0 +1,870 @@
+//! Implement python as a virtual machine with bytecode. This module
+//! implements bytecode structure.
+
+use crate::{
+    marshal::MarshalError,
+    varint::{read_varint, read_varint_with_start, write_varint, write_varint_with_start},
+    {OneIndexed, SourceLocation},
+};
+use alloc::{collections::BTreeSet, fmt, vec::Vec};
+use bitflags::bitflags;
+use core::{hash, mem, ops::Deref};
+use itertools::Itertools;
+use malachite_bigint::BigInt;
+use num_complex::Complex64;
+use rustpython_wtf8::{Wtf8, Wtf8Buf};
+
+pub use crate::bytecode::{
+    instruction::{
+        AnyInstruction, Arg, Instruction, InstructionMetadata, PseudoInstruction,
+        decode_load_attr_arg, decode_load_super_attr_arg, encode_load_attr_arg,
+        encode_load_super_attr_arg,
+    },
+    oparg::{
+        BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
+        IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx, OpArg,
+        OpArgByte, OpArgState, OpArgType, RaiseKind, ResumeType, UnpackExArgs,
+    },
+};
+
+mod instruction;
+mod oparg;
+
+/// Exception table entry for zero-cost exception handling
+/// Format: (start, size, target, depth<<1|lasti)
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ExceptionTableEntry {
+    /// Start instruction offset (inclusive)
+    pub start: u32,
+    /// End instruction offset (exclusive)
+    pub end: u32,
+    /// Handler target offset
+    pub target: u32,
+    /// Stack depth at handler entry
+    pub depth: u16,
+    /// Whether to push lasti before exception
+    pub push_lasti: bool,
+}
+
+impl ExceptionTableEntry {
+    pub fn new(start: u32, end: u32, target: u32, depth: u16, push_lasti: bool) -> Self {
+        Self {
+            start,
+            end,
+            target,
+            depth,
+            push_lasti,
+        }
+    }
+}
+
+/// Encode exception table entries.
+/// Uses 6-bit varint encoding with start marker (MSB) and continuation bit.
+pub fn encode_exception_table(entries: &[ExceptionTableEntry]) -> alloc::boxed::Box<[u8]> {
+    let mut data = Vec::new();
+    for entry in entries {
+        let size = entry.end.saturating_sub(entry.start);
+        let depth_lasti = ((entry.depth as u32) << 1) | (entry.push_lasti as u32);
+
+        write_varint_with_start(&mut data, entry.start);
+        write_varint(&mut data, size);
+        write_varint(&mut data, entry.target);
+        write_varint(&mut data, depth_lasti);
+    }
+    data.into_boxed_slice()
+}
+
+/// Find exception handler for given instruction offset.
+pub fn find_exception_handler(table: &[u8], offset: u32) -> Option<ExceptionTableEntry> {
+    let mut pos = 0;
+    while pos < table.len() {
+        let start = read_varint_with_start(table, &mut pos)?;
+        let size = read_varint(table, &mut pos)?;
+        let target = read_varint(table, &mut pos)?;
+        let depth_lasti = read_varint(table, &mut pos)?;
+
+        let end = start + size;
+        let depth = (depth_lasti >> 1) as u16;
+        let push_lasti = (depth_lasti & 1) != 0;
+
+        if offset >= start && offset < end {
+            return Some(ExceptionTableEntry {
+                start,
+                end,
+                target,
+                depth,
+                push_lasti,
+            });
+        }
+    }
+    None
+}
+
+/// CPython 3.11+ linetable location info codes
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum PyCodeLocationInfoKind {
+    // Short forms are 0 to 9
+    Short0 = 0,
+    Short1 = 1,
+    Short2 = 2,
+    Short3 = 3,
+    Short4 = 4,
+    Short5 = 5,
+    Short6 = 6,
+    Short7 = 7,
+    Short8 = 8,
+    Short9 = 9,
+    // One line forms are 10 to 12
+    OneLine0 = 10,
+    OneLine1 = 11,
+    OneLine2 = 12,
+    NoColumns = 13,
+    Long = 14,
+    None = 15,
+}
+
+impl PyCodeLocationInfoKind {
+    pub fn from_code(code: u8) -> Option<Self> {
+        match code {
+            0 => Some(Self::Short0),
+            1 => Some(Self::Short1),
+            2 => Some(Self::Short2),
+            3 => Some(Self::Short3),
+            4 => Some(Self::Short4),
+            5 => Some(Self::Short5),
+            6 => Some(Self::Short6),
+            7 => Some(Self::Short7),
+            8 => Some(Self::Short8),
+            9 => Some(Self::Short9),
+            10 => Some(Self::OneLine0),
+            11 => Some(Self::OneLine1),
+            12 => Some(Self::OneLine2),
+            13 => Some(Self::NoColumns),
+            14 => Some(Self::Long),
+            15 => Some(Self::None),
+            _ => Option::None,
+        }
+    }
+
+    pub fn is_short(&self) -> bool {
+        (*self as u8) <= 9
+    }
+
+    pub fn short_column_group(&self) -> Option<u8> {
+        if self.is_short() {
+            Some(*self as u8)
+        } else {
+            Option::None
+        }
+    }
+
+    pub fn one_line_delta(&self) -> Option<i32> {
+        match self {
+            Self::OneLine0 => Some(0),
+            Self::OneLine1 => Some(1),
+            Self::OneLine2 => Some(2),
+            _ => Option::None,
+        }
+    }
+}
+
+pub trait Constant: Sized {
+    type Name: AsRef<str>;
+
+    /// Transforms the given Constant to a BorrowedConstant
+    fn borrow_constant(&self) -> BorrowedConstant<'_, Self>;
+}
+
+impl Constant for ConstantData {
+    type Name = String;
+
+    fn borrow_constant(&self) -> BorrowedConstant<'_, Self> {
+        use BorrowedConstant::*;
+
+        match self {
+            Self::Integer { value } => Integer { value },
+            Self::Float { value } => Float { value: *value },
+            Self::Complex { value } => Complex { value: *value },
+            Self::Boolean { value } => Boolean { value: *value },
+            Self::Str { value } => Str { value },
+            Self::Bytes { value } => Bytes { value },
+            Self::Code { code } => Code { code },
+            Self::Tuple { elements } => Tuple { elements },
+            Self::None => None,
+            Self::Ellipsis => Ellipsis,
+        }
+    }
+}
+
+/// A Constant Bag
+pub trait ConstantBag: Sized + Copy {
+    type Constant: Constant;
+
+    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant;
+
+    fn make_int(&self, value: BigInt) -> Self::Constant;
+
+    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant;
+
+    fn make_code(&self, code: CodeObject<Self::Constant>) -> Self::Constant;
+
+    fn make_name(&self, name: &str) -> <Self::Constant as Constant>::Name;
+}
+
+pub trait AsBag {
+    type Bag: ConstantBag;
+
+    #[allow(clippy::wrong_self_convention)]
+    fn as_bag(self) -> Self::Bag;
+}
+
+impl<Bag: ConstantBag> AsBag for Bag {
+    type Bag = Self;
+
+    fn as_bag(self) -> Self {
+        self
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct BasicBag;
+
+impl ConstantBag for BasicBag {
+    type Constant = ConstantData;
+
+    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {
+        constant.to_owned()
+    }
+
+    fn make_int(&self, value: BigInt) -> Self::Constant {
+        ConstantData::Integer { value }
+    }
+
+    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {
+        ConstantData::Tuple {
+            elements: elements.collect(),
+        }
+    }
+
+    fn make_code(&self, code: CodeObject<Self::Constant>) -> Self::Constant {
+        ConstantData::Code {
+            code: Box::new(code),
+        }
+    }
+
+    fn make_name(&self, name: &str) -> <Self::Constant as Constant>::Name {
+        name.to_owned()
+    }
+}
+
+/// Primary container of a single code object. Each python function has
+/// a code object. Also a module has a code object.
+#[derive(Clone)]
+pub struct CodeObject<C: Constant = ConstantData> {
+    pub instructions: CodeUnits,
+    pub locations: Box<[(SourceLocation, SourceLocation)]>,
+    pub flags: CodeFlags,
+    /// Number of positional-only arguments
+    pub posonlyarg_count: u32,
+    pub arg_count: u32,
+    pub kwonlyarg_count: u32,
+    pub source_path: C::Name,
+    pub first_line_number: Option<OneIndexed>,
+    pub max_stackdepth: u32,
+    /// Name of the object that created this code object
+    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 names: Box<[C::Name]>,
+    pub varnames: Box<[C::Name]>,
+    pub cellvars: Box<[C::Name]>,
+    pub freevars: Box<[C::Name]>,
+    /// Line number table (CPython 3.11+ format)
+    pub linetable: Box<[u8]>,
+    /// Exception handling table
+    pub exceptiontable: Box<[u8]>,
+}
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct CodeFlags: u16 {
+        const OPTIMIZED = 0x0001;
+        const NEWLOCALS = 0x0002;
+        const VARARGS = 0x0004;
+        const VARKEYWORDS = 0x0008;
+        const GENERATOR = 0x0020;
+        const COROUTINE = 0x0080;
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct CodeUnit {
+    pub op: Instruction,
+    pub arg: OpArgByte,
+}
+
+const _: () = assert!(mem::size_of::<CodeUnit>() == 2);
+
+impl CodeUnit {
+    pub const fn new(op: Instruction, arg: OpArgByte) -> Self {
+        Self { op, arg }
+    }
+}
+
+impl TryFrom<&[u8]> for CodeUnit {
+    type Error = MarshalError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        match value.len() {
+            2 => Ok(Self::new(value[0].try_into()?, value[1].into())),
+            _ => Err(Self::Error::InvalidBytecode),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct CodeUnits(Box<[CodeUnit]>);
+
+impl TryFrom<&[u8]> for CodeUnits {
+    type Error = MarshalError;
+
+    fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
+        if !value.len().is_multiple_of(2) {
+            return Err(Self::Error::InvalidBytecode);
+        }
+
+        value.chunks_exact(2).map(CodeUnit::try_from).collect()
+    }
+}
+
+impl<const N: usize> From<[CodeUnit; N]> for CodeUnits {
+    fn from(value: [CodeUnit; N]) -> Self {
+        Self(Box::from(value))
+    }
+}
+
+impl From<Vec<CodeUnit>> for CodeUnits {
+    fn from(value: Vec<CodeUnit>) -> Self {
+        Self(value.into_boxed_slice())
+    }
+}
+
+impl FromIterator<CodeUnit> for CodeUnits {
+    fn from_iter<T: IntoIterator<Item = CodeUnit>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl Deref for CodeUnits {
+    type Target = [CodeUnit];
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// A Constant (which usually encapsulates data within it)
+///
+/// # Examples
+/// ```
+/// use rustpython_compiler_core::bytecode::ConstantData;
+/// let a = ConstantData::Float {value: 120f64};
+/// let b = ConstantData::Boolean {value: false};
+/// assert_ne!(a, b);
+/// ```
+#[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> },
+    None,
+    Ellipsis,
+}
+
+impl PartialEq for ConstantData {
+    fn eq(&self, other: &Self) -> bool {
+        use ConstantData::*;
+
+        match (self, other) {
+            (Integer { value: a }, Integer { value: b }) => a == b,
+            // we want to compare floats *by actual value* - if we have the *exact same* float
+            // already in a constant cache, we want to use that
+            (Float { value: a }, Float { value: b }) => a.to_bits() == b.to_bits(),
+            (Complex { value: a }, Complex { value: b }) => {
+                a.re.to_bits() == b.re.to_bits() && a.im.to_bits() == b.im.to_bits()
+            }
+            (Boolean { value: a }, Boolean { value: b }) => a == b,
+            (Str { value: a }, Str { value: b }) => a == b,
+            (Bytes { value: a }, Bytes { value: b }) => a == b,
+            (Code { code: a }, Code { code: b }) => core::ptr::eq(a.as_ref(), b.as_ref()),
+            (Tuple { elements: a }, Tuple { elements: b }) => a == b,
+            (None, None) => true,
+            (Ellipsis, Ellipsis) => true,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for ConstantData {}
+
+impl hash::Hash for ConstantData {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        use ConstantData::*;
+
+        mem::discriminant(self).hash(state);
+        match self {
+            Integer { value } => value.hash(state),
+            Float { value } => value.to_bits().hash(state),
+            Complex { value } => {
+                value.re.to_bits().hash(state);
+                value.im.to_bits().hash(state);
+            }
+            Boolean { value } => value.hash(state),
+            Str { value } => value.hash(state),
+            Bytes { value } => value.hash(state),
+            Code { code } => core::ptr::hash(code.as_ref(), state),
+            Tuple { elements } => elements.hash(state),
+            None => {}
+            Ellipsis => {}
+        }
+    }
+}
+
+/// A borrowed Constant
+pub enum BorrowedConstant<'a, C: Constant> {
+    Integer { value: &'a BigInt },
+    Float { value: f64 },
+    Complex { value: Complex64 },
+    Boolean { value: bool },
+    Str { value: &'a Wtf8 },
+    Bytes { value: &'a [u8] },
+    Code { code: &'a CodeObject<C> },
+    Tuple { elements: &'a [C] },
+    None,
+    Ellipsis,
+}
+
+impl<C: Constant> Copy for BorrowedConstant<'_, C> {}
+
+impl<C: Constant> Clone for BorrowedConstant<'_, C> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<C: Constant> BorrowedConstant<'_, C> {
+    pub fn fmt_display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BorrowedConstant::Integer { value } => write!(f, "{value}"),
+            BorrowedConstant::Float { value } => write!(f, "{value}"),
+            BorrowedConstant::Complex { value } => write!(f, "{value}"),
+            BorrowedConstant::Boolean { value } => {
+                write!(f, "{}", if *value { "True" } else { "False" })
+            }
+            BorrowedConstant::Str { value } => write!(f, "{value:?}"),
+            BorrowedConstant::Bytes { value } => write!(f, r#"b"{}""#, value.escape_ascii()),
+            BorrowedConstant::Code { code } => write!(f, "{code:?}"),
+            BorrowedConstant::Tuple { elements } => {
+                write!(f, "(")?;
+                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, "..."),
+        }
+    }
+
+    pub fn to_owned(self) -> ConstantData {
+        use ConstantData::*;
+
+        match self {
+            BorrowedConstant::Integer { value } => Integer {
+                value: value.clone(),
+            },
+            BorrowedConstant::Float { value } => Float { value },
+            BorrowedConstant::Complex { value } => Complex { value },
+            BorrowedConstant::Boolean { value } => Boolean { value },
+            BorrowedConstant::Str { value } => Str {
+                value: value.to_owned(),
+            },
+            BorrowedConstant::Bytes { value } => Bytes {
+                value: value.to_owned(),
+            },
+            BorrowedConstant::Code { code } => Code {
+                code: Box::new(code.map_clone_bag(&BasicBag)),
+            },
+            BorrowedConstant::Tuple { elements } => Tuple {
+                elements: elements
+                    .iter()
+                    .map(|c| c.borrow_constant().to_owned())
+                    .collect(),
+            },
+            BorrowedConstant::None => None,
+            BorrowedConstant::Ellipsis => Ellipsis,
+        }
+    }
+}
+
+/*
+Maintain a stack of blocks on the VM.
+pub enum BlockType {
+    Loop,
+    Except,
+}
+*/
+
+/// Argument structure
+pub struct Arguments<'a, N: AsRef<str>> {
+    pub posonlyargs: &'a [N],
+    pub args: &'a [N],
+    pub vararg: Option<&'a N>,
+    pub kwonlyargs: &'a [N],
+    pub varkwarg: Option<&'a N>,
+}
+
+impl<N: AsRef<str>> fmt::Debug for Arguments<'_, N> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        macro_rules! fmt_slice {
+            ($x:expr) => {
+                format_args!("[{}]", $x.iter().map(AsRef::as_ref).format(", "))
+            };
+        }
+        f.debug_struct("Arguments")
+            .field("posonlyargs", &fmt_slice!(self.posonlyargs))
+            .field("args", &fmt_slice!(self.posonlyargs))
+            .field("vararg", &self.vararg.map(N::as_ref))
+            .field("kwonlyargs", &fmt_slice!(self.kwonlyargs))
+            .field("varkwarg", &self.varkwarg.map(N::as_ref))
+            .finish()
+    }
+}
+
+impl<C: Constant> CodeObject<C> {
+    /// Get all arguments of the code object
+    /// like inspect.getargs
+    pub fn arg_names(&self) -> Arguments<'_, C::Name> {
+        let nargs = self.arg_count as usize;
+        let nkwargs = self.kwonlyarg_count as usize;
+        let mut varargs_pos = nargs + nkwargs;
+        let posonlyargs = &self.varnames[..self.posonlyarg_count as usize];
+        let args = &self.varnames[..nargs];
+        let kwonlyargs = &self.varnames[nargs..varargs_pos];
+
+        let vararg = if self.flags.contains(CodeFlags::VARARGS) {
+            let vararg = &self.varnames[varargs_pos];
+            varargs_pos += 1;
+            Some(vararg)
+        } else {
+            None
+        };
+        let varkwarg = if self.flags.contains(CodeFlags::VARKEYWORDS) {
+            Some(&self.varnames[varargs_pos])
+        } else {
+            None
+        };
+
+        Arguments {
+            posonlyargs,
+            args,
+            vararg,
+            kwonlyargs,
+            varkwarg,
+        }
+    }
+
+    /// Return the labels targeted by the instructions of this CodeObject
+    pub fn label_targets(&self) -> BTreeSet<Label> {
+        let mut label_targets = BTreeSet::new();
+        let mut arg_state = OpArgState::default();
+        for instruction in &*self.instructions {
+            let (instruction, arg) = arg_state.get(*instruction);
+            if let Some(l) = instruction.label_arg() {
+                label_targets.insert(l.get(arg));
+            }
+        }
+        label_targets
+    }
+
+    fn display_inner(
+        &self,
+        f: &mut fmt::Formatter<'_>,
+        expand_code_objects: bool,
+        level: usize,
+    ) -> fmt::Result {
+        let label_targets = self.label_targets();
+        let line_digits = (3).max(self.locations.last().unwrap().0.line.digits().get());
+        let offset_digits = (4).max(1 + self.instructions.len().ilog10() as usize);
+        let mut last_line = OneIndexed::MAX;
+        let mut arg_state = OpArgState::default();
+        for (offset, &instruction) in self.instructions.iter().enumerate() {
+            let (instruction, arg) = arg_state.get(instruction);
+            // optional line number
+            let line = self.locations[offset].0.line;
+            if line != last_line {
+                if last_line != OneIndexed::MAX {
+                    writeln!(f)?;
+                }
+                last_line = line;
+                write!(f, "{line:line_digits$}")?;
+            } else {
+                for _ in 0..line_digits {
+                    write!(f, " ")?;
+                }
+            }
+            write!(f, " ")?;
+
+            // level indent
+            for _ in 0..level {
+                write!(f, "    ")?;
+            }
+
+            // arrow and offset
+            let arrow = if label_targets.contains(&Label(offset as u32)) {
+                ">>"
+            } else {
+                "  "
+            };
+            write!(f, "{arrow} {offset:offset_digits$} ")?;
+
+            // instruction
+            instruction.fmt_dis(arg, f, self, expand_code_objects, 21, level)?;
+            writeln!(f)?;
+        }
+        Ok(())
+    }
+
+    /// Recursively display this CodeObject
+    pub fn display_expand_code_objects(&self) -> impl fmt::Display + '_ {
+        struct Display<'a, C: Constant>(&'a CodeObject<C>);
+        impl<C: Constant> fmt::Display for Display<'_, C> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                self.0.display_inner(f, true, 1)
+            }
+        }
+        Display(self)
+    }
+
+    /// Map this CodeObject to one that holds a Bag::Constant
+    pub fn map_bag<Bag: ConstantBag>(self, bag: Bag) -> CodeObject<Bag::Constant> {
+        let map_names = |names: Box<[C::Name]>| {
+            names
+                .into_vec()
+                .into_iter()
+                .map(|x| bag.make_name(x.as_ref()))
+                .collect::<Box<[_]>>()
+        };
+        CodeObject {
+            constants: self
+                .constants
+                .into_vec()
+                .into_iter()
+                .map(|x| bag.make_constant(x.borrow_constant()))
+                .collect(),
+            names: map_names(self.names),
+            varnames: map_names(self.varnames),
+            cellvars: map_names(self.cellvars),
+            freevars: map_names(self.freevars),
+            source_path: bag.make_name(self.source_path.as_ref()),
+            obj_name: bag.make_name(self.obj_name.as_ref()),
+            qualname: bag.make_name(self.qualname.as_ref()),
+
+            instructions: self.instructions,
+            locations: self.locations,
+            flags: self.flags,
+            posonlyarg_count: self.posonlyarg_count,
+            arg_count: self.arg_count,
+            kwonlyarg_count: self.kwonlyarg_count,
+            first_line_number: self.first_line_number,
+            max_stackdepth: self.max_stackdepth,
+            cell2arg: self.cell2arg,
+            linetable: self.linetable,
+            exceptiontable: self.exceptiontable,
+        }
+    }
+
+    /// Same as `map_bag` but clones `self`
+    pub fn map_clone_bag<Bag: ConstantBag>(&self, bag: &Bag) -> CodeObject<Bag::Constant> {
+        let map_names =
+            |names: &[C::Name]| names.iter().map(|x| bag.make_name(x.as_ref())).collect();
+        CodeObject {
+            constants: self
+                .constants
+                .iter()
+                .map(|x| bag.make_constant(x.borrow_constant()))
+                .collect(),
+            names: map_names(&self.names),
+            varnames: map_names(&self.varnames),
+            cellvars: map_names(&self.cellvars),
+            freevars: map_names(&self.freevars),
+            source_path: bag.make_name(self.source_path.as_ref()),
+            obj_name: bag.make_name(self.obj_name.as_ref()),
+            qualname: bag.make_name(self.qualname.as_ref()),
+
+            instructions: self.instructions.clone(),
+            locations: self.locations.clone(),
+            flags: self.flags,
+            posonlyarg_count: self.posonlyarg_count,
+            arg_count: self.arg_count,
+            kwonlyarg_count: self.kwonlyarg_count,
+            first_line_number: self.first_line_number,
+            max_stackdepth: self.max_stackdepth,
+            cell2arg: self.cell2arg.clone(),
+            linetable: self.linetable.clone(),
+            exceptiontable: self.exceptiontable.clone(),
+        }
+    }
+}
+
+impl<C: Constant> fmt::Display for CodeObject<C> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display_inner(f, false, 1)?;
+        for constant in &*self.constants {
+            if let BorrowedConstant::Code { code } = constant.borrow_constant() {
+                writeln!(f, "\nDisassembly of {code:?}")?;
+                code.fmt(f)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+pub trait InstrDisplayContext {
+    type Constant: Constant;
+
+    fn get_constant(&self, i: usize) -> &Self::Constant;
+
+    fn get_name(&self, i: usize) -> &str;
+
+    fn get_varname(&self, i: usize) -> &str;
+
+    fn get_cell_name(&self, i: usize) -> &str;
+}
+
+impl<C: Constant> InstrDisplayContext for CodeObject<C> {
+    type Constant = C;
+
+    fn get_constant(&self, i: usize) -> &C {
+        &self.constants[i]
+    }
+
+    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_cell_name(&self, i: usize) -> &str {
+        self.cellvars
+            .get(i)
+            .unwrap_or_else(|| &self.freevars[i - self.cellvars.len()])
+            .as_ref()
+    }
+}
+
+impl fmt::Display for ConstantData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.borrow_constant().fmt_display(f)
+    }
+}
+
+impl<C: Constant> fmt::Debug for CodeObject<C> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "<code object {} at ??? file {:?}, line {}>",
+            self.obj_name.as_ref(),
+            self.source_path.as_ref(),
+            self.first_line_number.map_or(-1, |x| x.get() as i32)
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_exception_table_encode_decode() {
+        let entries = vec![
+            ExceptionTableEntry::new(0, 10, 20, 2, false),
+            ExceptionTableEntry::new(15, 25, 30, 1, true),
+        ];
+
+        let encoded = encode_exception_table(&entries);
+
+        // Find handler at offset 5 (in range [0, 10))
+        let handler = find_exception_handler(&encoded, 5);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.start, 0);
+        assert_eq!(handler.end, 10);
+        assert_eq!(handler.target, 20);
+        assert_eq!(handler.depth, 2);
+        assert!(!handler.push_lasti);
+
+        // Find handler at offset 20 (in range [15, 25))
+        let handler = find_exception_handler(&encoded, 20);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.start, 15);
+        assert_eq!(handler.end, 25);
+        assert_eq!(handler.target, 30);
+        assert_eq!(handler.depth, 1);
+        assert!(handler.push_lasti);
+
+        // No handler at offset 12 (not in any range)
+        let handler = find_exception_handler(&encoded, 12);
+        assert!(handler.is_none());
+
+        // No handler at offset 30 (past all ranges)
+        let handler = find_exception_handler(&encoded, 30);
+        assert!(handler.is_none());
+    }
+
+    #[test]
+    fn test_exception_table_empty() {
+        let entries: Vec<ExceptionTableEntry> = vec![];
+        let encoded = encode_exception_table(&entries);
+        assert!(encoded.is_empty());
+        assert!(find_exception_handler(&encoded, 0).is_none());
+    }
+
+    #[test]
+    fn test_exception_table_single_entry() {
+        let entries = vec![ExceptionTableEntry::new(5, 15, 100, 3, true)];
+        let encoded = encode_exception_table(&entries);
+
+        // Inside range
+        let handler = find_exception_handler(&encoded, 10);
+        assert!(handler.is_some());
+        let handler = handler.unwrap();
+        assert_eq!(handler.target, 100);
+        assert_eq!(handler.depth, 3);
+        assert!(handler.push_lasti);
+
+        // At start boundary (inclusive)
+        assert!(find_exception_handler(&encoded, 5).is_some());
+
+        // At end boundary (exclusive)
+        assert!(find_exception_handler(&encoded, 15).is_none());
+    }
+}
diff --git a/crates/compiler-core/src/bytecode/instruction.rs b/crates/compiler-core/src/bytecode/instruction.rs
new file mode 100644
index 0000000000..2cca03127c
--- /dev/null
+++ b/crates/compiler-core/src/bytecode/instruction.rs
@@ -0,0 +1,1353 @@
+use core::{fmt, marker::PhantomData, mem};
+
+use crate::{
+    bytecode::{
+        BorrowedConstant, Constant, InstrDisplayContext,
+        oparg::{
+            BinaryOperator, BuildSliceArgCount, ComparisonOperator, ConvertValueOparg,
+            IntrinsicFunction1, IntrinsicFunction2, Invert, Label, MakeFunctionFlags, NameIdx,
+            OpArg, OpArgByte, OpArgType, RaiseKind, UnpackExArgs,
+        },
+    },
+    marshal::MarshalError,
+};
+
+/// A Single bytecode instruction that are executed by the VM.
+///
+/// Currently aligned with CPython 3.13.
+///
+/// ## See also
+/// - [CPython opcode IDs](https://github.com/python/cpython/blob/627894459a84be3488a1789919679c997056a03c/Include/opcode_ids.h)
+#[derive(Clone, Copy, Debug)]
+#[repr(u8)]
+pub enum Instruction {
+    // ==================== No-argument instructions (opcode < 44) ====================
+    Cache = 0, // Placeholder
+    BeforeAsyncWith = 1,
+    BeforeWith = 2,
+    BinaryOpInplaceAddUnicode = 3, // Placeholder
+    BinarySlice = 4,               // Placeholder
+    BinarySubscr = 5,
+    CheckEgMatch = 6,
+    CheckExcMatch = 7,
+    CleanupThrow = 8,
+    DeleteSubscr = 9,
+    EndAsyncFor = 10,
+    EndFor = 11, // Placeholder
+    EndSend = 12,
+    ExitInitCheck = 13, // Placeholder
+    FormatSimple = 14,
+    FormatWithSpec = 15,
+    GetAIter = 16,
+    Reserved = 17,
+    GetANext = 18,
+    GetIter = 19,
+    GetLen = 20,
+    GetYieldFromIter = 21,
+    InterpreterExit = 22,    // Placeholder
+    LoadAssertionError = 23, // Placeholder
+    LoadBuildClass = 24,
+    LoadLocals = 25, // Placeholder
+    MakeFunction = 26,
+    MatchKeys = 27,
+    MatchMapping = 28,
+    MatchSequence = 29,
+    Nop = 30,
+    PopExcept = 31,
+    PopTop = 32,
+    PushExcInfo = 33,
+    PushNull = 34,        // Placeholder
+    ReturnGenerator = 35, // Placeholder
+    ReturnValue = 36,
+    SetupAnnotations = 37,
+    StoreSlice = 38, // Placeholder
+    StoreSubscr = 39,
+    ToBool = 40,
+    UnaryInvert = 41,
+    UnaryNegative = 42,
+    UnaryNot = 43,
+    WithExceptStart = 44,
+    // ==================== With-argument instructions (opcode > 44) ====================
+    BinaryOp {
+        op: Arg<BinaryOperator>,
+    } = 45,
+    BuildConstKeyMap {
+        size: Arg<u32>,
+    } = 46, // Placeholder
+    BuildList {
+        size: Arg<u32>,
+    } = 47,
+    BuildMap {
+        size: Arg<u32>,
+    } = 48,
+    BuildSet {
+        size: Arg<u32>,
+    } = 49,
+    BuildSlice {
+        argc: Arg<BuildSliceArgCount>,
+    } = 50,
+    BuildString {
+        size: Arg<u32>,
+    } = 51,
+    BuildTuple {
+        size: Arg<u32>,
+    } = 52,
+    Call {
+        nargs: Arg<u32>,
+    } = 53,
+    CallFunctionEx {
+        has_kwargs: Arg<bool>,
+    } = 54,
+    CallIntrinsic1 {
+        func: Arg<IntrinsicFunction1>,
+    } = 55,
+    CallIntrinsic2 {
+        func: Arg<IntrinsicFunction2>,
+    } = 56,
+    CallKw {
+        nargs: Arg<u32>,
+    } = 57,
+    CompareOp {
+        op: Arg<ComparisonOperator>,
+    } = 58,
+    ContainsOp(Arg<Invert>) = 59,
+    ConvertValue {
+        oparg: Arg<ConvertValueOparg>,
+    } = 60,
+    Copy {
+        index: Arg<u32>,
+    } = 61,
+    CopyFreeVars {
+        count: Arg<u32>,
+    } = 62, // Placeholder
+    DeleteAttr {
+        idx: Arg<NameIdx>,
+    } = 63,
+    DeleteDeref(Arg<NameIdx>) = 64,
+    DeleteFast(Arg<NameIdx>) = 65,
+    DeleteGlobal(Arg<NameIdx>) = 66,
+    DeleteName(Arg<NameIdx>) = 67,
+    DictMerge {
+        index: Arg<u32>,
+    } = 68, // Placeholder
+    DictUpdate {
+        index: Arg<u32>,
+    } = 69,
+    EnterExecutor = 70, // Placeholder
+    ExtendedArg = 71,
+    ForIter {
+        target: Arg<Label>,
+    } = 72,
+    GetAwaitable = 73, // TODO: Make this instruction to hold an oparg
+    ImportFrom {
+        idx: Arg<NameIdx>,
+    } = 74,
+    ImportName {
+        idx: Arg<NameIdx>,
+    } = 75,
+    IsOp(Arg<Invert>) = 76,
+    JumpBackward {
+        target: Arg<Label>,
+    } = 77, // Placeholder
+    JumpBackwardNoInterrupt {
+        target: Arg<Label>,
+    } = 78, // Placeholder
+    JumpForward {
+        target: Arg<Label>,
+    } = 79, // Placeholder
+    ListAppend {
+        i: Arg<u32>,
+    } = 80,
+    ListExtend {
+        i: Arg<u32>,
+    } = 81, // Placeholder
+    LoadAttr {
+        idx: Arg<NameIdx>,
+    } = 82,
+    LoadConst {
+        idx: Arg<u32>,
+    } = 83,
+    LoadDeref(Arg<NameIdx>) = 84,
+    LoadFast(Arg<NameIdx>) = 85,
+    LoadFastAndClear(Arg<NameIdx>) = 86,
+    LoadFastCheck(Arg<NameIdx>) = 87, // Placeholder
+    LoadFastLoadFast {
+        arg: Arg<u32>,
+    } = 88, // Placeholder
+    LoadFromDictOrDeref(Arg<NameIdx>) = 89,
+    LoadFromDictOrGlobals(Arg<NameIdx>) = 90, // Placeholder
+    LoadGlobal(Arg<NameIdx>) = 91,
+    LoadName(Arg<NameIdx>) = 92,
+    LoadSuperAttr {
+        arg: Arg<u32>,
+    } = 93,
+    MakeCell(Arg<NameIdx>) = 94, // Placeholder
+    MapAdd {
+        i: Arg<u32>,
+    } = 95,
+    MatchClass(Arg<u32>) = 96,
+    PopJumpIfFalse {
+        target: Arg<Label>,
+    } = 97,
+    PopJumpIfNone {
+        target: Arg<Label>,
+    } = 98, // Placeholder
+    PopJumpIfNotNone {
+        target: Arg<Label>,
+    } = 99, // Placeholder
+    PopJumpIfTrue {
+        target: Arg<Label>,
+    } = 100,
+    RaiseVarargs {
+        kind: Arg<RaiseKind>,
+    } = 101,
+    Reraise {
+        depth: Arg<u32>,
+    } = 102,
+    ReturnConst {
+        idx: Arg<u32>,
+    } = 103,
+    Send {
+        target: Arg<Label>,
+    } = 104,
+    SetAdd {
+        i: Arg<u32>,
+    } = 105,
+    SetFunctionAttribute {
+        attr: Arg<MakeFunctionFlags>,
+    } = 106,
+    SetUpdate {
+        i: Arg<u32>,
+    } = 107, // Placeholder
+    StoreAttr {
+        idx: Arg<NameIdx>,
+    } = 108,
+    StoreDeref(Arg<NameIdx>) = 109,
+    StoreFast(Arg<NameIdx>) = 110,
+    StoreFastLoadFast {
+        store_idx: Arg<NameIdx>,
+        load_idx: Arg<NameIdx>,
+    } = 111,
+    StoreFastStoreFast {
+        arg: Arg<u32>,
+    } = 112, // Placeholder
+    StoreGlobal(Arg<NameIdx>) = 113,
+    StoreName(Arg<NameIdx>) = 114,
+    Swap {
+        index: Arg<u32>,
+    } = 115,
+    UnpackEx {
+        args: Arg<UnpackExArgs>,
+    } = 116,
+    UnpackSequence {
+        size: Arg<u32>,
+    } = 117,
+    YieldValue {
+        arg: Arg<u32>,
+    } = 118,
+    // ==================== RustPython-only instructions (119-133) ====================
+    // Ideally, we want to be fully aligned with CPython opcodes, but we still have some leftovers.
+    // So we assign random IDs to these opcodes.
+    Break {
+        target: Arg<Label>,
+    } = 119,
+    BuildListFromTuples {
+        size: Arg<u32>,
+    } = 120,
+    BuildMapForCall {
+        size: Arg<u32>,
+    } = 121,
+    BuildSetFromTuples {
+        size: Arg<u32>,
+    } = 122,
+    BuildTupleFromIter = 123,
+    BuildTupleFromTuples {
+        size: Arg<u32>,
+    } = 124,
+    /// Build a Template from strings tuple and interpolations tuple on stack.
+    /// Stack: [strings_tuple, interpolations_tuple] -> [template]
+    BuildTemplate = 125,
+    /// Build an Interpolation from value, expression string, and optional format_spec on stack.
+    ///
+    /// oparg encoding: (conversion << 2) | has_format_spec
+    /// - has_format_spec (bit 0): if 1, format_spec is on stack
+    /// - conversion (bits 2+): 0=None, 1=Str, 2=Repr, 3=Ascii
+    ///
+    /// Stack: [value, expression_str, format_spec?] -> [interpolation]
+    BuildInterpolation {
+        oparg: Arg<u32>,
+    } = 126,
+    Continue {
+        target: Arg<Label>,
+    } = 128,
+    JumpIfFalseOrPop {
+        target: Arg<Label>,
+    } = 129,
+    JumpIfTrueOrPop {
+        target: Arg<Label>,
+    } = 130,
+    JumpIfNotExcMatch(Arg<Label>) = 131,
+    SetExcInfo = 132,
+    Subscript = 133,
+    // End of custom instructions
+    Resume {
+        arg: Arg<u32>,
+    } = 149,
+    BinaryOpAddFloat = 150,                     // Placeholder
+    BinaryOpAddInt = 151,                       // Placeholder
+    BinaryOpAddUnicode = 152,                   // Placeholder
+    BinaryOpMultiplyFloat = 153,                // Placeholder
+    BinaryOpMultiplyInt = 154,                  // Placeholder
+    BinaryOpSubtractFloat = 155,                // Placeholder
+    BinaryOpSubtractInt = 156,                  // Placeholder
+    BinarySubscrDict = 157,                     // Placeholder
+    BinarySubscrGetitem = 158,                  // Placeholder
+    BinarySubscrListInt = 159,                  // Placeholder
+    BinarySubscrStrInt = 160,                   // Placeholder
+    BinarySubscrTupleInt = 161,                 // Placeholder
+    CallAllocAndEnterInit = 162,                // Placeholder
+    CallBoundMethodExactArgs = 163,             // Placeholder
+    CallBoundMethodGeneral = 164,               // Placeholder
+    CallBuiltinClass = 165,                     // Placeholder
+    CallBuiltinFast = 166,                      // Placeholder
+    CallBuiltinFastWithKeywords = 167,          // Placeholder
+    CallBuiltinO = 168,                         // Placeholder
+    CallIsinstance = 169,                       // Placeholder
+    CallLen = 170,                              // Placeholder
+    CallListAppend = 171,                       // Placeholder
+    CallMethodDescriptorFast = 172,             // Placeholder
+    CallMethodDescriptorFastWithKeywords = 173, // Placeholder
+    CallMethodDescriptorNoargs = 174,           // Placeholder
+    CallMethodDescriptorO = 175,                // Placeholder
+    CallNonPyGeneral = 176,                     // Placeholder
+    CallPyExactArgs = 177,                      // Placeholder
+    CallPyGeneral = 178,                        // Placeholder
+    CallStr1 = 179,                             // Placeholder
+    CallTuple1 = 180,                           // Placeholder
+    CallType1 = 181,                            // Placeholder
+    CompareOpFloat = 182,                       // Placeholder
+    CompareOpInt = 183,                         // Placeholder
+    CompareOpStr = 184,                         // Placeholder
+    ContainsOpDict = 185,                       // Placeholder
+    ContainsOpSet = 186,                        // Placeholder
+    ForIterGen = 187,                           // Placeholder
+    ForIterList = 188,                          // Placeholder
+    ForIterRange = 189,                         // Placeholder
+    ForIterTuple = 190,                         // Placeholder
+    LoadAttrClass = 191,                        // Placeholder
+    LoadAttrGetattributeOverridden = 192,       // Placeholder
+    LoadAttrInstanceValue = 193,                // Placeholder
+    LoadAttrMethodLazyDict = 194,               // Placeholder
+    LoadAttrMethodNoDict = 195,                 // Placeholder
+    LoadAttrMethodWithValues = 196,             // Placeholder
+    LoadAttrModule = 197,                       // Placeholder
+    LoadAttrNondescriptorNoDict = 198,          // Placeholder
+    LoadAttrNondescriptorWithValues = 199,      // Placeholder
+    LoadAttrProperty = 200,                     // Placeholder
+    LoadAttrSlot = 201,                         // Placeholder
+    LoadAttrWithHint = 202,                     // Placeholder
+    LoadGlobalBuiltin = 203,                    // Placeholder
+    LoadGlobalModule = 204,                     // Placeholder
+    LoadSuperAttrAttr = 205,                    // Placeholder
+    LoadSuperAttrMethod = 206,                  // Placeholder
+    ResumeCheck = 207,                          // Placeholder
+    SendGen = 208,                              // Placeholder
+    StoreAttrInstanceValue = 209,               // Placeholder
+    StoreAttrSlot = 210,                        // Placeholder
+    StoreAttrWithHint = 211,                    // Placeholder
+    StoreSubscrDict = 212,                      // Placeholder
+    StoreSubscrListInt = 213,                   // Placeholder
+    ToBoolAlwaysTrue = 214,                     // Placeholder
+    ToBoolBool = 215,                           // Placeholder
+    ToBoolInt = 216,                            // Placeholder
+    ToBoolList = 217,                           // Placeholder
+    ToBoolNone = 218,                           // Placeholder
+    ToBoolStr = 219,                            // Placeholder
+    UnpackSequenceList = 220,                   // Placeholder
+    UnpackSequenceTuple = 221,                  // Placeholder
+    UnpackSequenceTwoTuple = 222,               // Placeholder
+    InstrumentedResume = 236,                   // Placeholder
+    InstrumentedEndFor = 237,                   // Placeholder
+    InstrumentedEndSend = 238,                  // Placeholder
+    InstrumentedReturnValue = 239,              // Placeholder
+    InstrumentedReturnConst = 240,              // Placeholder
+    InstrumentedYieldValue = 241,               // Placeholder
+    InstrumentedLoadSuperAttr = 242,            // Placeholder
+    InstrumentedForIter = 243,                  // Placeholder
+    InstrumentedCall = 244,                     // Placeholder
+    InstrumentedCallKw = 245,                   // Placeholder
+    InstrumentedCallFunctionEx = 246,           // Placeholder
+    InstrumentedInstruction = 247,              // Placeholder
+    InstrumentedJumpForward = 248,              // Placeholder
+    InstrumentedJumpBackward = 249,             // Placeholder
+    InstrumentedPopJumpIfTrue = 250,            // Placeholder
+    InstrumentedPopJumpIfFalse = 251,           // Placeholder
+    InstrumentedPopJumpIfNone = 252,            // Placeholder
+    InstrumentedPopJumpIfNotNone = 253,         // Placeholder
+    InstrumentedLine = 254,                     // Placeholder
+    // Pseudos (needs to be moved to `PseudoInstruction` enum.
+    LoadClosure(Arg<NameIdx>) = 255, // TODO: Move to pseudos
+}
+
+const _: () = assert!(mem::size_of::<Instruction>() == 1);
+
+impl From<Instruction> for u8 {
+    #[inline]
+    fn from(ins: Instruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { mem::transmute::<Instruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u8> for Instruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u8) -> Result<Self, MarshalError> {
+        // CPython-compatible opcodes (0-118)
+        let cpython_start = u8::from(Self::Cache);
+        let cpython_end = u8::from(Self::YieldValue { arg: Arg::marker() });
+
+        // Resume has a non-contiguous opcode (149)
+        let resume_id = u8::from(Self::Resume { arg: Arg::marker() });
+
+        let specialized_start = u8::from(Self::BinaryOpAddFloat);
+        let specialized_end = u8::from(Self::UnpackSequenceTwoTuple);
+
+        let instrumented_start = u8::from(Self::InstrumentedResume);
+        let instrumented_end = u8::from(Self::InstrumentedLine);
+
+        // TODO: Remove this; This instruction needs to be pseudo
+        let load_closure = u8::from(Self::LoadClosure(Arg::marker()));
+
+        // RustPython-only opcodes (explicit list to avoid gaps like 125-127)
+        let custom_ops: &[u8] = &[
+            u8::from(Self::Break {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::BuildListFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildMapForCall {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildSetFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildTupleFromIter),
+            u8::from(Self::BuildTupleFromTuples {
+                size: Arg::marker(),
+            }),
+            u8::from(Self::BuildTemplate),
+            u8::from(Self::BuildInterpolation {
+                oparg: Arg::marker(),
+            }),
+            // 127 is unused
+            u8::from(Self::Continue {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfFalseOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfTrueOrPop {
+                target: Arg::marker(),
+            }),
+            u8::from(Self::JumpIfNotExcMatch(Arg::marker())),
+            u8::from(Self::SetExcInfo),
+            u8::from(Self::Subscript),
+        ];
+
+        if (cpython_start..=cpython_end).contains(&value)
+            || value == resume_id
+            || value == load_closure
+            || custom_ops.contains(&value)
+            || (specialized_start..=specialized_end).contains(&value)
+            || (instrumented_start..=instrumented_end).contains(&value)
+        {
+            Ok(unsafe { mem::transmute::<u8, Self>(value) })
+        } else {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
+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::JumpIfNotExcMatch(l)
+            | Self::PopJumpIfTrue { target: l }
+            | Self::PopJumpIfFalse { target: l }
+            | Self::JumpIfTrueOrPop { target: l }
+            | Self::JumpIfFalseOrPop { target: l }
+            | Self::ForIter { target: l }
+            | Self::Break { target: l }
+            | Self::Continue { target: l }
+            | Self::Send { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    fn unconditional_branch(&self) -> bool {
+        matches!(
+            self,
+            Self::JumpForward { .. }
+                | Self::JumpBackward { .. }
+                | Self::JumpBackwardNoInterrupt { .. }
+                | Self::Continue { .. }
+                | Self::Break { .. }
+                | Self::ReturnValue
+                | Self::ReturnConst { .. }
+                | Self::RaiseVarargs { .. }
+                | Self::Reraise { .. }
+        )
+    }
+
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32 {
+        match self {
+            Self::Nop => 0,
+            Self::ImportName { .. } => -1,
+            Self::ImportFrom { .. } => 1,
+            Self::LoadFast(_) => 1,
+            Self::LoadFastAndClear(_) => 1,
+            Self::LoadName(_) => 1,
+            Self::LoadGlobal(_) => 1,
+            Self::LoadDeref(_) => 1,
+            Self::StoreFast(_) => -1,
+            Self::StoreName(_) => -1,
+            Self::StoreGlobal(_) => -1,
+            Self::StoreDeref(_) => -1,
+            Self::StoreFastLoadFast { .. } => 0, // pop 1, push 1
+            Self::DeleteFast(_) => 0,
+            Self::DeleteName(_) => 0,
+            Self::DeleteGlobal(_) => 0,
+            Self::DeleteDeref(_) => 0,
+            Self::LoadFromDictOrDeref(_) => 1,
+            Self::Subscript => -1,
+            Self::StoreSubscr => -3,
+            Self::DeleteSubscr => -2,
+            Self::LoadAttr { .. } => 0,
+            Self::StoreAttr { .. } => -2,
+            Self::DeleteAttr { .. } => -1,
+            Self::LoadConst { .. } => 1,
+            Self::Reserved => 0,
+            Self::BinaryOp { .. } => -1,
+            Self::CompareOp { .. } => -1,
+            Self::BinarySubscr => -1,
+            Self::Copy { .. } => 1,
+            Self::PopTop => -1,
+            Self::Swap { .. } => 0,
+            Self::ToBool => 0,
+            Self::GetIter => 0,
+            Self::GetLen => 1,
+            Self::CallIntrinsic1 { .. } => 0,  // Takes 1, pushes 1
+            Self::CallIntrinsic2 { .. } => -1, // Takes 2, pushes 1
+            Self::Continue { .. } => 0,
+            Self::Break { .. } => 0,
+            Self::PopJumpIfTrue { .. } => -1,
+            Self::PopJumpIfFalse { .. } => -1,
+            Self::JumpIfTrueOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::JumpIfFalseOrPop { .. } => {
+                if jump {
+                    0
+                } else {
+                    -1
+                }
+            }
+            Self::MakeFunction => {
+                // CPython 3.13 style: MakeFunction only pops code object
+                -1 + 1 // pop code, push function
+            }
+            Self::SetFunctionAttribute { .. } => {
+                // pops attribute value and function, pushes function back
+                -2 + 1
+            }
+            // Call: pops nargs + self_or_null + callable, pushes result
+            Self::Call { nargs } => -(nargs.get(arg) as i32) - 2 + 1,
+            // CallKw: pops kw_names_tuple + nargs + self_or_null + callable, pushes result
+            Self::CallKw { nargs } => -1 - (nargs.get(arg) as i32) - 2 + 1,
+            // CallFunctionEx: pops kwargs(if any) + args_tuple + self_or_null + callable, pushes result
+            Self::CallFunctionEx { has_kwargs } => -1 - (has_kwargs.get(arg) as i32) - 2 + 1,
+            Self::CheckEgMatch => 0, // pops 2 (exc, type), pushes 2 (rest, match)
+            Self::ConvertValue { .. } => 0,
+            Self::FormatSimple => 0,
+            Self::FormatWithSpec => -1,
+            Self::ForIter { .. } => {
+                if jump {
+                    -1
+                } else {
+                    1
+                }
+            }
+            Self::IsOp(_) => -1,
+            Self::ContainsOp(_) => -1,
+            Self::JumpIfNotExcMatch(_) => -2,
+            Self::ReturnValue => -1,
+            Self::ReturnConst { .. } => 0,
+            Self::Resume { .. } => 0,
+            Self::YieldValue { .. } => 0,
+            // SEND: (receiver, val) -> (receiver, retval) - no change, both paths keep same depth
+            Self::Send { .. } => 0,
+            // END_SEND: (receiver, value) -> (value)
+            Self::EndSend => -1,
+            // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) = 3 pop, 2 push = -1
+            Self::CleanupThrow => -1,
+            Self::SetExcInfo => 0,
+            Self::PushExcInfo => 1,    // [exc] -> [prev_exc, exc]
+            Self::CheckExcMatch => 0,  // [exc, type] -> [exc, bool] (pops type, pushes bool)
+            Self::Reraise { .. } => 0, // Exception raised, stack effect doesn't matter
+            Self::SetupAnnotations => 0,
+            Self::BeforeWith => 1, // push __exit__, then replace ctx_mgr with __enter__ result
+            Self::WithExceptStart => 1, // push __exit__ result
+            Self::RaiseVarargs { kind } => {
+                // Stack effects for different raise kinds:
+                // - Reraise (0): gets from VM state, no stack pop
+                // - Raise (1): pops 1 exception
+                // - RaiseCause (2): pops 2 (exception + cause)
+                // - ReraiseFromStack (3): pops 1 exception from stack
+                match kind.get(arg) {
+                    RaiseKind::BareRaise => 0,
+                    RaiseKind::Raise => -1,
+                    RaiseKind::RaiseCause => -2,
+                    RaiseKind::ReraiseFromStack => -1,
+                }
+            }
+            Self::BuildString { size } => -(size.get(arg) as i32) + 1,
+            Self::BuildTuple { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildList { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildListFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSet { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildSetFromTuples { size, .. } => -(size.get(arg) as i32) + 1,
+            Self::BuildTupleFromIter => 0,
+            Self::BuildMap { size } => {
+                let nargs = size.get(arg) * 2;
+                -(nargs as i32) + 1
+            }
+            Self::BuildMapForCall { size } => {
+                let nargs = size.get(arg);
+                -(nargs as i32) + 1
+            }
+            Self::DictUpdate { .. } => -1,
+            Self::BuildSlice { argc } => {
+                // push 1
+                // pops either 2/3
+                // Default to Two (2 args) if arg is invalid
+                1 - (argc
+                    .try_get(arg)
+                    .unwrap_or(BuildSliceArgCount::Two)
+                    .argc()
+                    .get() as i32)
+            }
+            Self::ListAppend { .. } => -1,
+            Self::SetAdd { .. } => -1,
+            Self::MapAdd { .. } => -2,
+            Self::LoadBuildClass => 1,
+            Self::UnpackSequence { size } => -1 + size.get(arg) as i32,
+            Self::UnpackEx { args } => {
+                let UnpackExArgs { before, after } = args.get(arg);
+                -1 + before as i32 + 1 + after as i32
+            }
+            Self::PopExcept => 0,
+            Self::GetAwaitable => 0,
+            Self::BeforeAsyncWith => 1,
+            Self::GetAIter => 0,
+            Self::GetANext => 1,
+            Self::EndAsyncFor => -2,  // pops (awaitable, exc) from stack
+            Self::MatchMapping => 1,  // Push bool result
+            Self::MatchSequence => 1, // Push bool result
+            Self::MatchKeys => 1, // Pop 2 (subject, keys), push 3 (subject, keys_or_none, values_or_none)
+            Self::MatchClass(_) => -2,
+            Self::ExtendedArg => 0,
+            Self::UnaryInvert => 0,
+            Self::UnaryNegative => 0,
+            Self::UnaryNot => 0,
+            Self::GetYieldFromIter => 0,
+            Self::PushNull => 1, // Push NULL for call protocol
+            // 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 => 0,
+            Self::BinaryOpInplaceAddUnicode => 0,
+            Self::EndFor => 0,
+            Self::ExitInitCheck => 0,
+            Self::InterpreterExit => 0,
+            Self::LoadAssertionError => 0,
+            Self::LoadLocals => 0,
+            Self::ReturnGenerator => 0,
+            Self::StoreSlice => 0,
+            Self::DictMerge { .. } => 0,
+            Self::BuildConstKeyMap { .. } => 0,
+            Self::CopyFreeVars { .. } => 0,
+            Self::EnterExecutor => 0,
+            Self::JumpBackwardNoInterrupt { .. } => 0,
+            Self::JumpBackward { .. } => 0,
+            Self::JumpForward { .. } => 0,
+            Self::ListExtend { .. } => 0,
+            Self::LoadFastCheck(_) => 0,
+            Self::LoadFastLoadFast { .. } => 0,
+            Self::LoadFromDictOrGlobals(_) => 0,
+            Self::SetUpdate { .. } => 0,
+            Self::MakeCell(_) => 0,
+            Self::StoreFastStoreFast { .. } => 0,
+            Self::PopJumpIfNone { .. } => 0,
+            Self::PopJumpIfNotNone { .. } => 0,
+            Self::LoadClosure(_) => 1,
+            Self::BinaryOpAddFloat => 0,
+            Self::BinaryOpAddInt => 0,
+            Self::BinaryOpAddUnicode => 0,
+            Self::BinaryOpMultiplyFloat => 0,
+            Self::BinaryOpMultiplyInt => 0,
+            Self::BinaryOpSubtractFloat => 0,
+            Self::BinaryOpSubtractInt => 0,
+            Self::BinarySubscrDict => 0,
+            Self::BinarySubscrGetitem => 0,
+            Self::BinarySubscrListInt => 0,
+            Self::BinarySubscrStrInt => 0,
+            Self::BinarySubscrTupleInt => 0,
+            Self::CallAllocAndEnterInit => 0,
+            Self::CallBoundMethodExactArgs => 0,
+            Self::CallBoundMethodGeneral => 0,
+            Self::CallBuiltinClass => 0,
+            Self::CallBuiltinFast => 0,
+            Self::CallBuiltinFastWithKeywords => 0,
+            Self::CallBuiltinO => 0,
+            Self::CallIsinstance => 0,
+            Self::CallLen => 0,
+            Self::CallListAppend => 0,
+            Self::CallMethodDescriptorFast => 0,
+            Self::CallMethodDescriptorFastWithKeywords => 0,
+            Self::CallMethodDescriptorNoargs => 0,
+            Self::CallMethodDescriptorO => 0,
+            Self::CallNonPyGeneral => 0,
+            Self::CallPyExactArgs => 0,
+            Self::CallPyGeneral => 0,
+            Self::CallStr1 => 0,
+            Self::CallTuple1 => 0,
+            Self::CallType1 => 0,
+            Self::CompareOpFloat => 0,
+            Self::CompareOpInt => 0,
+            Self::CompareOpStr => 0,
+            Self::ContainsOpDict => 0,
+            Self::ContainsOpSet => 0,
+            Self::ForIterGen => 0,
+            Self::ForIterList => 0,
+            Self::ForIterRange => 0,
+            Self::ForIterTuple => 0,
+            Self::LoadAttrClass => 0,
+            Self::LoadAttrGetattributeOverridden => 0,
+            Self::LoadAttrInstanceValue => 0,
+            Self::LoadAttrMethodLazyDict => 0,
+            Self::LoadAttrMethodNoDict => 0,
+            Self::LoadAttrMethodWithValues => 0,
+            Self::LoadAttrModule => 0,
+            Self::LoadAttrNondescriptorNoDict => 0,
+            Self::LoadAttrNondescriptorWithValues => 0,
+            Self::LoadAttrProperty => 0,
+            Self::LoadAttrSlot => 0,
+            Self::LoadAttrWithHint => 0,
+            Self::LoadGlobalBuiltin => 0,
+            Self::LoadGlobalModule => 0,
+            Self::LoadSuperAttrAttr => 0,
+            Self::LoadSuperAttrMethod => 0,
+            Self::ResumeCheck => 0,
+            Self::SendGen => 0,
+            Self::StoreAttrInstanceValue => 0,
+            Self::StoreAttrSlot => 0,
+            Self::StoreAttrWithHint => 0,
+            Self::StoreSubscrDict => 0,
+            Self::StoreSubscrListInt => 0,
+            Self::ToBoolAlwaysTrue => 0,
+            Self::ToBoolBool => 0,
+            Self::ToBoolInt => 0,
+            Self::ToBoolList => 0,
+            Self::ToBoolNone => 0,
+            Self::ToBoolStr => 0,
+            Self::UnpackSequenceList => 0,
+            Self::UnpackSequenceTuple => 0,
+            Self::UnpackSequenceTwoTuple => 0,
+            Self::InstrumentedResume => 0,
+            Self::InstrumentedEndFor => 0,
+            Self::InstrumentedEndSend => 0,
+            Self::InstrumentedReturnValue => 0,
+            Self::InstrumentedReturnConst => 0,
+            Self::InstrumentedYieldValue => 0,
+            Self::InstrumentedLoadSuperAttr => 0,
+            Self::InstrumentedForIter => 0,
+            Self::InstrumentedCall => 0,
+            Self::InstrumentedCallKw => 0,
+            Self::InstrumentedCallFunctionEx => 0,
+            Self::InstrumentedInstruction => 0,
+            Self::InstrumentedJumpForward => 0,
+            Self::InstrumentedJumpBackward => 0,
+            Self::InstrumentedPopJumpIfTrue => 0,
+            Self::InstrumentedPopJumpIfFalse => 0,
+            Self::InstrumentedPopJumpIfNone => 0,
+            Self::InstrumentedPopJumpIfNotNone => 0,
+            Self::InstrumentedLine => 0,
+            // 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 }
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result {
+        macro_rules! w {
+            ($variant:ident) => {
+                write!(f, stringify!($variant))
+            };
+            ($variant:ident, $map:ident = $arg_marker:expr) => {{
+                let arg = $arg_marker.get(arg);
+                write!(f, "{:pad$}({}, {})", stringify!($variant), arg, $map(arg))
+            }};
+            ($variant:ident, $arg_marker:expr) => {
+                write!(f, "{:pad$}({})", stringify!($variant), $arg_marker.get(arg))
+            };
+            ($variant:ident, ?$arg_marker:expr) => {
+                write!(
+                    f,
+                    "{:pad$}({:?})",
+                    stringify!($variant),
+                    $arg_marker.get(arg)
+                )
+            };
+        }
+
+        let varname = |i: u32| ctx.get_varname(i as usize);
+        let name = |i: u32| ctx.get_name(i as usize);
+        let cell_name = |i: u32| ctx.get_cell_name(i as usize);
+
+        let fmt_const =
+            |op: &str, arg: OpArg, f: &mut fmt::Formatter<'_>, idx: &Arg<u32>| -> fmt::Result {
+                let value = ctx.get_constant(idx.get(arg) as usize);
+                match value.borrow_constant() {
+                    BorrowedConstant::Code { code } if expand_code_objects => {
+                        write!(f, "{op:pad$}({code:?}):")?;
+                        code.display_inner(f, true, level + 1)?;
+                        Ok(())
+                    }
+                    c => {
+                        write!(f, "{op:pad$}(")?;
+                        c.fmt_display(f)?;
+                        write!(f, ")")
+                    }
+                }
+            };
+
+        match self {
+            Self::BeforeAsyncWith => w!(BEFORE_ASYNC_WITH),
+            Self::BeforeWith => w!(BEFORE_WITH),
+            Self::BinaryOp { op } => write!(f, "{:pad$}({})", "BINARY_OP", op.get(arg)),
+            Self::BinarySubscr => w!(BINARY_SUBSCR),
+            Self::Break { target } => w!(BREAK, target),
+            Self::BuildList { size } => w!(BUILD_LIST, size),
+            Self::BuildListFromTuples { size } => w!(BUILD_LIST_FROM_TUPLES, size),
+            Self::BuildMap { size } => w!(BUILD_MAP, size),
+            Self::BuildMapForCall { size } => w!(BUILD_MAP_FOR_CALL, size),
+            Self::BuildSet { size } => w!(BUILD_SET, size),
+            Self::BuildSetFromTuples { size } => w!(BUILD_SET_FROM_TUPLES, size),
+            Self::BuildSlice { argc } => w!(BUILD_SLICE, ?argc),
+            Self::BuildString { size } => w!(BUILD_STRING, size),
+            Self::BuildTuple { size } => w!(BUILD_TUPLE, size),
+            Self::BuildTupleFromIter => w!(BUILD_TUPLE_FROM_ITER),
+            Self::BuildTupleFromTuples { size } => w!(BUILD_TUPLE_FROM_TUPLES, size),
+            Self::Call { nargs } => w!(CALL, nargs),
+            Self::CallFunctionEx { has_kwargs } => w!(CALL_FUNCTION_EX, has_kwargs),
+            Self::CallKw { nargs } => w!(CALL_KW, nargs),
+            Self::CallIntrinsic1 { func } => w!(CALL_INTRINSIC_1, ?func),
+            Self::CallIntrinsic2 { func } => w!(CALL_INTRINSIC_2, ?func),
+            Self::CheckEgMatch => w!(CHECK_EG_MATCH),
+            Self::CheckExcMatch => w!(CHECK_EXC_MATCH),
+            Self::CleanupThrow => w!(CLEANUP_THROW),
+            Self::CompareOp { op } => w!(COMPARE_OP, ?op),
+            Self::ContainsOp(inv) => w!(CONTAINS_OP, ?inv),
+            Self::Continue { target } => w!(CONTINUE, target),
+            Self::ConvertValue { oparg } => write!(f, "{:pad$}{}", "CONVERT_VALUE", oparg.get(arg)),
+            Self::Copy { index } => w!(COPY, index),
+            Self::DeleteAttr { idx } => w!(DELETE_ATTR, name = idx),
+            Self::DeleteDeref(idx) => w!(DELETE_DEREF, cell_name = idx),
+            Self::DeleteFast(idx) => w!(DELETE_FAST, varname = idx),
+            Self::DeleteGlobal(idx) => w!(DELETE_GLOBAL, name = idx),
+            Self::DeleteName(idx) => w!(DELETE_NAME, name = idx),
+            Self::DeleteSubscr => w!(DELETE_SUBSCR),
+            Self::DictUpdate { index } => w!(DICT_UPDATE, index),
+            Self::EndAsyncFor => w!(END_ASYNC_FOR),
+            Self::EndSend => w!(END_SEND),
+            Self::ExtendedArg => w!(EXTENDED_ARG, Arg::<u32>::marker()),
+            Self::ForIter { target } => w!(FOR_ITER, target),
+            Self::FormatSimple => w!(FORMAT_SIMPLE),
+            Self::FormatWithSpec => w!(FORMAT_WITH_SPEC),
+            Self::GetAIter => w!(GET_AITER),
+            Self::GetANext => w!(GET_ANEXT),
+            Self::GetAwaitable => w!(GET_AWAITABLE),
+            Self::Reserved => w!(RESERVED),
+            Self::GetIter => w!(GET_ITER),
+            Self::GetLen => w!(GET_LEN),
+            Self::ImportFrom { idx } => w!(IMPORT_FROM, name = idx),
+            Self::ImportName { idx } => w!(IMPORT_NAME, name = idx),
+            Self::IsOp(inv) => w!(IS_OP, ?inv),
+            Self::JumpBackward { target } => w!(JUMP_BACKWARD, target),
+            Self::JumpBackwardNoInterrupt { target } => w!(JUMP_BACKWARD_NO_INTERRUPT, target),
+            Self::JumpForward { target } => w!(JUMP_FORWARD, target),
+            Self::JumpIfFalseOrPop { target } => w!(JUMP_IF_FALSE_OR_POP, target),
+            Self::JumpIfNotExcMatch(target) => w!(JUMP_IF_NOT_EXC_MATCH, target),
+            Self::JumpIfTrueOrPop { target } => w!(JUMP_IF_TRUE_OR_POP, target),
+            Self::ListAppend { i } => w!(LIST_APPEND, i),
+            Self::LoadAttr { idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, is_method) = decode_load_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                if is_method {
+                    write!(
+                        f,
+                        "{:pad$}({}, {}, method=true)",
+                        "LOAD_ATTR", encoded, attr_name
+                    )
+                } else {
+                    write!(f, "{:pad$}({}, {})", "LOAD_ATTR", encoded, attr_name)
+                }
+            }
+            Self::LoadBuildClass => w!(LOAD_BUILD_CLASS),
+            Self::LoadFromDictOrDeref(i) => w!(LOAD_FROM_DICT_OR_DEREF, cell_name = i),
+            Self::LoadClosure(i) => w!(LOAD_CLOSURE, cell_name = i),
+            Self::LoadConst { idx } => fmt_const("LOAD_CONST", arg, f, idx),
+            Self::LoadDeref(idx) => w!(LOAD_DEREF, cell_name = idx),
+            Self::LoadFast(idx) => w!(LOAD_FAST, varname = idx),
+            Self::LoadFastAndClear(idx) => w!(LOAD_FAST_AND_CLEAR, varname = idx),
+            Self::LoadGlobal(idx) => w!(LOAD_GLOBAL, name = idx),
+            Self::LoadName(idx) => w!(LOAD_NAME, name = idx),
+            Self::LoadSuperAttr { arg: idx } => {
+                let encoded = idx.get(arg);
+                let (name_idx, load_method, has_class) = decode_load_super_attr_arg(encoded);
+                let attr_name = name(name_idx);
+                write!(
+                    f,
+                    "{:pad$}({}, {}, method={}, class={})",
+                    "LOAD_SUPER_ATTR", encoded, attr_name, load_method, has_class
+                )
+            }
+            Self::MakeFunction => w!(MAKE_FUNCTION),
+            Self::MapAdd { i } => w!(MAP_ADD, i),
+            Self::MatchClass(arg) => w!(MATCH_CLASS, arg),
+            Self::MatchKeys => w!(MATCH_KEYS),
+            Self::MatchMapping => w!(MATCH_MAPPING),
+            Self::MatchSequence => w!(MATCH_SEQUENCE),
+            Self::Nop => w!(NOP),
+            Self::PopExcept => w!(POP_EXCEPT),
+            Self::PopJumpIfFalse { target } => w!(POP_JUMP_IF_FALSE, target),
+            Self::PopJumpIfTrue { target } => w!(POP_JUMP_IF_TRUE, target),
+            Self::PopTop => w!(POP_TOP),
+            Self::PushExcInfo => w!(PUSH_EXC_INFO),
+            Self::PushNull => w!(PUSH_NULL),
+            Self::RaiseVarargs { kind } => w!(RAISE_VARARGS, ?kind),
+            Self::Reraise { depth } => w!(RERAISE, depth),
+            Self::Resume { arg } => w!(RESUME, arg),
+            Self::ReturnConst { idx } => fmt_const("RETURN_CONST", arg, f, idx),
+            Self::ReturnValue => w!(RETURN_VALUE),
+            Self::Send { target } => w!(SEND, target),
+            Self::SetAdd { i } => w!(SET_ADD, i),
+            Self::SetExcInfo => w!(SET_EXC_INFO),
+            Self::SetFunctionAttribute { attr } => w!(SET_FUNCTION_ATTRIBUTE, ?attr),
+            Self::SetupAnnotations => w!(SETUP_ANNOTATIONS),
+            Self::StoreAttr { idx } => w!(STORE_ATTR, name = idx),
+            Self::StoreDeref(idx) => w!(STORE_DEREF, cell_name = idx),
+            Self::StoreFast(idx) => w!(STORE_FAST, varname = idx),
+            Self::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                write!(f, "STORE_FAST_LOAD_FAST")?;
+                write!(f, " ({}, {})", store_idx.get(arg), load_idx.get(arg))
+            }
+            Self::StoreGlobal(idx) => w!(STORE_GLOBAL, name = idx),
+            Self::StoreName(idx) => w!(STORE_NAME, name = idx),
+            Self::StoreSubscr => w!(STORE_SUBSCR),
+            Self::Subscript => w!(SUBSCRIPT),
+            Self::Swap { index } => w!(SWAP, index),
+            Self::ToBool => w!(TO_BOOL),
+            Self::UnpackEx { args } => w!(UNPACK_EX, args),
+            Self::UnpackSequence { size } => w!(UNPACK_SEQUENCE, size),
+            Self::WithExceptStart => w!(WITH_EXCEPT_START),
+            Self::UnaryInvert => w!(UNARY_INVERT),
+            Self::UnaryNegative => w!(UNARY_NEGATIVE),
+            Self::UnaryNot => w!(UNARY_NOT),
+            Self::YieldValue { arg } => w!(YIELD_VALUE, arg),
+            Self::GetYieldFromIter => w!(GET_YIELD_FROM_ITER),
+            Self::BuildTemplate => w!(BUILD_TEMPLATE),
+            Self::BuildInterpolation { oparg } => w!(BUILD_INTERPOLATION, oparg),
+            _ => w!(RUSTPYTHON_PLACEHOLDER),
+        }
+    }
+}
+
+/// Instructions used by the compiler. They are not executed by the VM.
+#[derive(Clone, Copy, Debug)]
+#[repr(u16)]
+pub enum PseudoInstruction {
+    Jump {
+        target: Arg<Label>,
+    } = 256,
+    JumpNoInterrupt {
+        target: Arg<Label>,
+    } = 257, // Placeholder
+    Reserved258 = 258,
+    LoadAttrMethod {
+        idx: Arg<NameIdx>,
+    } = 259,
+    // "Zero" variants are for 0-arg super() calls (has_class=false).
+    // Non-"Zero" variants are for 2-arg super(cls, self) calls (has_class=true).
+    /// 2-arg super(cls, self).method() - has_class=true, load_method=true
+    LoadSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 260,
+    LoadZeroSuperAttr {
+        idx: Arg<NameIdx>,
+    } = 261,
+    LoadZeroSuperMethod {
+        idx: Arg<NameIdx>,
+    } = 262,
+    PopBlock = 263,
+    SetupCleanup = 264,       // Placeholder
+    SetupFinally = 265,       // Placeholder
+    SetupWith = 266,          // Placeholder
+    StoreFastMaybeNull = 267, // Placeholder
+}
+
+const _: () = assert!(mem::size_of::<PseudoInstruction>() == 2);
+
+impl From<PseudoInstruction> for u16 {
+    #[inline]
+    fn from(ins: PseudoInstruction) -> Self {
+        // SAFETY: there's no padding bits
+        unsafe { mem::transmute::<PseudoInstruction, Self>(ins) }
+    }
+}
+
+impl TryFrom<u16> for PseudoInstruction {
+    type Error = MarshalError;
+
+    #[inline]
+    fn try_from(value: u16) -> Result<Self, MarshalError> {
+        let start = u16::from(Self::Jump {
+            target: Arg::marker(),
+        });
+        let end = u16::from(Self::StoreFastMaybeNull);
+
+        if (start..=end).contains(&value) {
+            Ok(unsafe { mem::transmute::<u16, Self>(value) })
+        } else {
+            Err(Self::Error::InvalidBytecode)
+        }
+    }
+}
+
+impl InstructionMetadata for PseudoInstruction {
+    fn label_arg(&self) -> Option<Arg<Label>> {
+        match self {
+            Self::Jump { target: l } => Some(*l),
+            _ => None,
+        }
+    }
+
+    fn unconditional_branch(&self) -> bool {
+        matches!(self, Self::Jump { .. },)
+    }
+
+    fn stack_effect(&self, _arg: OpArg, _jump: bool) -> i32 {
+        match self {
+            Self::Jump { .. } => 0,
+            Self::JumpNoInterrupt { .. } => 0,
+            Self::LoadAttrMethod { .. } => 1, // pop obj, push method + self_or_null
+            Self::LoadSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::LoadZeroSuperAttr { .. } => -3 + 1, // pop 3, push [attr]
+            Self::LoadZeroSuperMethod { .. } => -3 + 2, // pop 3, push [method, self_or_null]
+            Self::PopBlock => 0,
+            Self::SetupCleanup => 0,
+            Self::SetupFinally => 0,
+            Self::SetupWith => 0,
+            Self::StoreFastMaybeNull => 0,
+            Self::Reserved258 => 0,
+        }
+    }
+
+    fn fmt_dis(
+        &self,
+        _arg: OpArg,
+        _f: &mut fmt::Formatter<'_>,
+        _ctx: &impl InstrDisplayContext,
+        _expand_code_objects: bool,
+        _pad: usize,
+        _level: usize,
+    ) -> fmt::Result {
+        unimplemented!()
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum AnyInstruction {
+    Real(Instruction),
+    Pseudo(PseudoInstruction),
+}
+
+impl From<Instruction> for AnyInstruction {
+    fn from(value: Instruction) -> Self {
+        Self::Real(value)
+    }
+}
+
+impl From<PseudoInstruction> for AnyInstruction {
+    fn from(value: PseudoInstruction) -> Self {
+        Self::Pseudo(value)
+    }
+}
+
+impl TryFrom<u8> for AnyInstruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Ok(Instruction::try_from(value)?.into())
+    }
+}
+
+impl TryFrom<u16> for AnyInstruction {
+    type Error = MarshalError;
+
+    fn try_from(value: u16) -> Result<Self, Self::Error> {
+        match u8::try_from(value) {
+            Ok(v) => v.try_into(),
+            Err(_) => Ok(PseudoInstruction::try_from(value)?.into()),
+        }
+    }
+}
+
+macro_rules! inst_either {
+    (fn $name:ident ( &self $(, $arg:ident : $arg_ty:ty )* ) -> $ret:ty ) => {
+        fn $name(&self $(, $arg : $arg_ty )* ) -> $ret {
+            match self {
+                Self::Real(op) => op.$name($($arg),*),
+                Self::Pseudo(op) => op.$name($($arg),*),
+            }
+        }
+    };
+}
+
+impl InstructionMetadata for AnyInstruction {
+    inst_either!(fn label_arg(&self) -> Option<Arg<Label>>);
+
+    inst_either!(fn unconditional_branch(&self) -> bool);
+
+    inst_either!(fn stack_effect(&self, arg: OpArg, jump: bool) -> i32);
+
+    inst_either!(fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize
+    ) -> fmt::Result);
+}
+
+impl AnyInstruction {
+    /// Gets the inner value of [`Self::Real`].
+    pub const fn real(self) -> Option<Instruction> {
+        match self {
+            Self::Real(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    /// Gets the inner value of [`Self::Pseudo`].
+    pub const fn pseudo(self) -> Option<PseudoInstruction> {
+        match self {
+            Self::Pseudo(ins) => Some(ins),
+            _ => None,
+        }
+    }
+
+    /// Same as [`Self::real`] but panics if wasn't called on [`Self::Real`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Real`].
+    pub const fn expect_real(self) -> Instruction {
+        self.real()
+            .expect("Expected Instruction::Real, found Instruction::Pseudo")
+    }
+
+    /// Same as [`Self::pseudo`] but panics if wasn't called on [`Self::Pseudo`].
+    ///
+    /// # Panics
+    ///
+    /// If was called on something else other than [`Self::Pseudo`].
+    pub const fn expect_pseudo(self) -> PseudoInstruction {
+        self.pseudo()
+            .expect("Expected Instruction::Pseudo, found Instruction::Real")
+    }
+}
+
+pub trait InstructionMetadata {
+    /// Gets the label stored inside this instruction, if it exists.
+    fn label_arg(&self) -> Option<Arg<Label>>;
+
+    /// Whether this is an unconditional branching.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, InstructionMetadata};
+    /// let jump_inst = Instruction::JumpForward { target: Arg::marker() };
+    /// assert!(jump_inst.unconditional_branch())
+    /// ```
+    fn unconditional_branch(&self) -> bool;
+
+    /// What effect this instruction has on the stack
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rustpython_compiler_core::bytecode::{Arg, Instruction, Label, InstructionMetadata};
+    /// let (target, jump_arg) = Arg::new(Label(0xF));
+    /// let jump_instruction = Instruction::JumpForward { target };
+    /// assert_eq!(jump_instruction.stack_effect(jump_arg, true), 0);
+    /// ```
+    fn stack_effect(&self, arg: OpArg, jump: bool) -> i32;
+
+    #[allow(clippy::too_many_arguments)]
+    fn fmt_dis(
+        &self,
+        arg: OpArg,
+        f: &mut fmt::Formatter<'_>,
+        ctx: &impl InstrDisplayContext,
+        expand_code_objects: bool,
+        pad: usize,
+        level: usize,
+    ) -> fmt::Result;
+
+    fn display<'a>(
+        &'a self,
+        arg: OpArg,
+        ctx: &'a impl InstrDisplayContext,
+    ) -> impl fmt::Display + 'a {
+        struct FmtFn<F>(F);
+        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Display for FmtFn<F> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                (self.0)(f)
+            }
+        }
+        FmtFn(move |f: &mut fmt::Formatter<'_>| self.fmt_dis(arg, f, ctx, false, 0, 0))
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct Arg<T: OpArgType>(PhantomData<T>);
+
+impl<T: OpArgType> Arg<T> {
+    #[inline]
+    pub const fn marker() -> Self {
+        Self(PhantomData)
+    }
+
+    #[inline]
+    pub fn new(arg: T) -> (Self, OpArg) {
+        (Self(PhantomData), OpArg(arg.to_op_arg()))
+    }
+
+    #[inline]
+    pub fn new_single(arg: T) -> (Self, OpArgByte)
+    where
+        T: Into<u8>,
+    {
+        (Self(PhantomData), OpArgByte(arg.into()))
+    }
+
+    #[inline(always)]
+    pub fn get(self, arg: OpArg) -> T {
+        self.try_get(arg).unwrap()
+    }
+
+    #[inline(always)]
+    pub fn try_get(self, arg: OpArg) -> Option<T> {
+        T::from_op_arg(arg.0)
+    }
+
+    /// # Safety
+    /// T::from_op_arg(self) must succeed
+    #[inline(always)]
+    pub unsafe fn get_unchecked(self, arg: OpArg) -> T {
+        // SAFETY: requirements forwarded from caller
+        unsafe { T::from_op_arg(arg.0).unwrap_unchecked() }
+    }
+}
+
+impl<T: OpArgType> PartialEq for Arg<T> {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+impl<T: OpArgType> Eq for Arg<T> {}
+
+impl<T: OpArgType> fmt::Debug for Arg<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Arg<{}>", core::any::type_name::<T>())
+    }
+}
+
+/// Encode LOAD_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
new file mode 100644
index 0000000000..c662a0a926
--- /dev/null
+++ b/crates/compiler-core/src/bytecode/oparg.rs
@@ -0,0 +1,582 @@
+use bitflags::bitflags;
+
+use core::{fmt, num::NonZeroU8};
+
+use crate::bytecode::{CodeUnit, instruction::Instruction};
+
+pub trait OpArgType: Copy {
+    fn from_op_arg(x: u32) -> Option<Self>;
+
+    fn to_op_arg(self) -> u32;
+}
+
+/// Opcode argument that may be extended by a prior ExtendedArg.
+#[derive(Copy, Clone, PartialEq, Eq)]
+#[repr(transparent)]
+pub struct OpArgByte(pub u8);
+
+impl OpArgByte {
+    pub const fn null() -> Self {
+        Self(0)
+    }
+}
+
+impl From<u8> for OpArgByte {
+    fn from(raw: u8) -> Self {
+        Self(raw)
+    }
+}
+
+impl fmt::Debug for OpArgByte {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+/// Full 32-bit op_arg, including any possible ExtendedArg extension.
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)]
+pub struct OpArg(pub u32);
+
+impl OpArg {
+    pub const fn null() -> Self {
+        Self(0)
+    }
+
+    /// Returns how many CodeUnits a instruction with this op_arg will be encoded as
+    #[inline]
+    pub const fn instr_size(self) -> usize {
+        (self.0 > 0xff) as usize + (self.0 > 0xff_ff) as usize + (self.0 > 0xff_ff_ff) as usize + 1
+    }
+
+    /// returns the arg split into any necessary ExtendedArg components (in big-endian order) and
+    /// the arg for the real opcode itself
+    #[inline(always)]
+    pub fn split(self) -> (impl ExactSizeIterator<Item = OpArgByte>, OpArgByte) {
+        let mut it = self
+            .0
+            .to_le_bytes()
+            .map(OpArgByte)
+            .into_iter()
+            .take(self.instr_size());
+        let lo = it.next().unwrap();
+        (it.rev(), lo)
+    }
+}
+
+impl From<u32> for OpArg {
+    fn from(raw: u32) -> Self {
+        Self(raw)
+    }
+}
+
+#[derive(Default, Copy, Clone)]
+#[repr(transparent)]
+pub struct OpArgState {
+    state: u32,
+}
+
+impl OpArgState {
+    #[inline(always)]
+    pub fn get(&mut self, ins: CodeUnit) -> (Instruction, OpArg) {
+        let arg = self.extend(ins.arg);
+        if !matches!(ins.op, Instruction::ExtendedArg) {
+            self.reset();
+        }
+        (ins.op, arg)
+    }
+
+    #[inline(always)]
+    pub fn extend(&mut self, arg: OpArgByte) -> OpArg {
+        self.state = (self.state << 8) | u32::from(arg.0);
+        OpArg(self.state)
+    }
+
+    #[inline(always)]
+    pub const fn reset(&mut self) {
+        self.state = 0
+    }
+}
+
+/// Oparg values for [`Instruction::ConvertValue`].
+///
+/// ## See also
+///
+/// - [CPython FVC_* flags](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Include/ceval.h#L129-L132)
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+pub enum ConvertValueOparg {
+    /// No conversion.
+    ///
+    /// ```python
+    /// f"{x}"
+    /// f"{x:4}"
+    /// ```
+    None = 0,
+    /// Converts by calling `str(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!s}"
+    /// f"{x!s:2}"
+    /// ```
+    Str = 1,
+    /// Converts by calling `repr(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!r}"
+    /// f"{x!r:2}"
+    /// ```
+    Repr = 2,
+    /// Converts by calling `ascii(<value>)`.
+    ///
+    /// ```python
+    /// f"{x!a}"
+    /// f"{x!a:2}"
+    /// ```
+    Ascii = 3,
+}
+
+impl fmt::Display for ConvertValueOparg {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let out = match self {
+            Self::Str => "1 (str)",
+            Self::Repr => "2 (repr)",
+            Self::Ascii => "3 (ascii)",
+            // We should never reach this. `FVC_NONE` are being handled by `Instruction::FormatSimple`
+            Self::None => "",
+        };
+
+        write!(f, "{out}")
+    }
+}
+
+impl OpArgType for ConvertValueOparg {
+    #[inline]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(match x {
+            // Ruff `ConversionFlag::None` is `-1i8`,
+            // when its converted to `u8` its value is `u8::MAX`
+            0 | 255 => Self::None,
+            1 => Self::Str,
+            2 => Self::Repr,
+            3 => Self::Ascii,
+            _ => return None,
+        })
+    }
+
+    #[inline]
+    fn to_op_arg(self) -> u32 {
+        self as u32
+    }
+}
+
+/// Resume type for the RESUME instruction
+#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
+#[repr(u32)]
+pub enum ResumeType {
+    AtFuncStart = 0,
+    AfterYield = 1,
+    AfterYieldFrom = 2,
+    AfterAwait = 3,
+}
+
+impl OpArgType for u32 {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(x)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self
+    }
+}
+
+impl OpArgType for bool {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(x != 0)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self as u32
+    }
+}
+
+macro_rules! op_arg_enum_impl {
+    (enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
+        impl OpArgType for $name {
+            fn to_op_arg(self) -> u32 {
+                self as u32
+            }
+
+            fn from_op_arg(x: u32) -> Option<Self> {
+                Some(match u8::try_from(x).ok()? {
+                    $($value => Self::$var,)*
+                    _ => return None,
+                })
+            }
+        }
+    };
+}
+
+macro_rules! op_arg_enum {
+    ($(#[$attr:meta])* $vis:vis enum $name:ident { $($(#[$var_attr:meta])* $var:ident = $value:literal,)* }) => {
+        $(#[$attr])*
+        $vis enum $name {
+            $($(#[$var_attr])* $var = $value,)*
+        }
+
+        op_arg_enum_impl!(enum $name {
+            $($(#[$var_attr])* $var = $value,)*
+        });
+    };
+}
+
+pub type NameIdx = u32;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
+#[repr(transparent)]
+pub struct Label(pub u32);
+
+impl OpArgType for Label {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(Self(x))
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self.0
+    }
+}
+
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+op_arg_enum!(
+    /// The kind of Raise that occurred.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum RaiseKind {
+        /// Bare `raise` statement with no arguments.
+        /// Gets the current exception from VM state (topmost_exception).
+        /// Maps to RAISE_VARARGS with oparg=0.
+        BareRaise = 0,
+        /// `raise exc` - exception is on the stack.
+        /// Maps to RAISE_VARARGS with oparg=1.
+        Raise = 1,
+        /// `raise exc from cause` - exception and cause are on the stack.
+        /// Maps to RAISE_VARARGS with oparg=2.
+        RaiseCause = 2,
+        /// Reraise exception from the stack top.
+        /// Used in exception handler cleanup blocks (finally, except).
+        /// Gets exception from stack, not from VM state.
+        /// Maps to the RERAISE opcode.
+        ReraiseFromStack = 3,
+    }
+);
+
+op_arg_enum!(
+    /// Intrinsic function for CALL_INTRINSIC_1
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum IntrinsicFunction1 {
+        // Invalid = 0,
+        Print = 1,
+        /// Import * operation
+        ImportStar = 2,
+        // StopIterationError = 3,
+        // AsyncGenWrap = 4,
+        UnaryPositive = 5,
+        /// Convert list to tuple
+        ListToTuple = 6,
+        /// Type parameter related
+        TypeVar = 7,
+        ParamSpec = 8,
+        TypeVarTuple = 9,
+        /// Generic subscript for PEP 695
+        SubscriptGeneric = 10,
+        TypeAlias = 11,
+    }
+);
+
+op_arg_enum!(
+    /// Intrinsic function for CALL_INTRINSIC_2
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum IntrinsicFunction2 {
+        PrepReraiseStar = 1,
+        TypeVarWithBound = 2,
+        TypeVarWithConstraint = 3,
+        SetFunctionTypeParams = 4,
+        /// Set default value for type parameter (PEP 695)
+        SetTypeparamDefault = 5,
+    }
+);
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct MakeFunctionFlags: u8 {
+        const CLOSURE = 0x01;
+        const ANNOTATIONS = 0x02;
+        const KW_ONLY_DEFAULTS = 0x04;
+        const DEFAULTS = 0x08;
+        const TYPE_PARAMS = 0x10;
+    }
+}
+
+impl OpArgType for MakeFunctionFlags {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Self::from_bits(x as u8)
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        self.bits().into()
+    }
+}
+
+op_arg_enum!(
+    /// The possible comparison operators
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    #[repr(u8)]
+    pub enum ComparisonOperator {
+        // be intentional with bits so that we can do eval_ord with just a bitwise and
+        // bits: | Equal | Greater | Less |
+        Less = 0b001,
+        Greater = 0b010,
+        NotEqual = 0b011,
+        Equal = 0b100,
+        LessOrEqual = 0b101,
+        GreaterOrEqual = 0b110,
+    }
+);
+
+op_arg_enum!(
+    /// The possible Binary operators
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use rustpython_compiler_core::bytecode::{Arg, BinaryOperator, Instruction};
+    /// let (op, _) = Arg::new(BinaryOperator::Add);
+    /// let instruction = Instruction::BinaryOp { op };
+    /// ```
+    ///
+    /// See also:
+    /// - [_PyEval_BinaryOps](https://github.com/python/cpython/blob/8183fa5e3f78ca6ab862de7fb8b14f3d929421e0/Python/ceval.c#L316-L343)
+    #[repr(u8)]
+    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
+    pub enum BinaryOperator {
+        /// `+`
+        Add = 0,
+        /// `&`
+        And = 1,
+        /// `//`
+        FloorDivide = 2,
+        /// `<<`
+        Lshift = 3,
+        /// `@`
+        MatrixMultiply = 4,
+        /// `*`
+        Multiply = 5,
+        /// `%`
+        Remainder = 6,
+        /// `|`
+        Or = 7,
+        /// `**`
+        Power = 8,
+        /// `>>`
+        Rshift = 9,
+        /// `-`
+        Subtract = 10,
+        /// `/`
+        TrueDivide = 11,
+        /// `^`
+        Xor = 12,
+        /// `+=`
+        InplaceAdd = 13,
+        /// `&=`
+        InplaceAnd = 14,
+        /// `//=`
+        InplaceFloorDivide = 15,
+        /// `<<=`
+        InplaceLshift = 16,
+        /// `@=`
+        InplaceMatrixMultiply = 17,
+        /// `*=`
+        InplaceMultiply = 18,
+        /// `%=`
+        InplaceRemainder = 19,
+        /// `|=`
+        InplaceOr = 20,
+        /// `**=`
+        InplacePower = 21,
+        /// `>>=`
+        InplaceRshift = 22,
+        /// `-=`
+        InplaceSubtract = 23,
+        /// `/=`
+        InplaceTrueDivide = 24,
+        /// `^=`
+        InplaceXor = 25,
+    }
+);
+
+impl BinaryOperator {
+    /// Get the "inplace" version of the operator.
+    /// This has no effect if `self` is already an "inplace" operator.
+    ///
+    /// # Example
+    /// ```rust
+    /// use rustpython_compiler_core::bytecode::BinaryOperator;
+    ///
+    /// assert_eq!(BinaryOperator::Power.as_inplace(), BinaryOperator::InplacePower);
+    ///
+    /// assert_eq!(BinaryOperator::InplaceSubtract.as_inplace(), BinaryOperator::InplaceSubtract);
+    /// ```
+    #[must_use]
+    pub const fn as_inplace(self) -> Self {
+        match self {
+            Self::Add => Self::InplaceAdd,
+            Self::And => Self::InplaceAnd,
+            Self::FloorDivide => Self::InplaceFloorDivide,
+            Self::Lshift => Self::InplaceLshift,
+            Self::MatrixMultiply => Self::InplaceMatrixMultiply,
+            Self::Multiply => Self::InplaceMultiply,
+            Self::Remainder => Self::InplaceRemainder,
+            Self::Or => Self::InplaceOr,
+            Self::Power => Self::InplacePower,
+            Self::Rshift => Self::InplaceRshift,
+            Self::Subtract => Self::InplaceSubtract,
+            Self::TrueDivide => Self::InplaceTrueDivide,
+            Self::Xor => Self::InplaceXor,
+            _ => self,
+        }
+    }
+}
+
+impl fmt::Display for BinaryOperator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let op = match self {
+            Self::Add => "+",
+            Self::And => "&",
+            Self::FloorDivide => "//",
+            Self::Lshift => "<<",
+            Self::MatrixMultiply => "@",
+            Self::Multiply => "*",
+            Self::Remainder => "%",
+            Self::Or => "|",
+            Self::Power => "**",
+            Self::Rshift => ">>",
+            Self::Subtract => "-",
+            Self::TrueDivide => "/",
+            Self::Xor => "^",
+            Self::InplaceAdd => "+=",
+            Self::InplaceAnd => "&=",
+            Self::InplaceFloorDivide => "//=",
+            Self::InplaceLshift => "<<=",
+            Self::InplaceMatrixMultiply => "@=",
+            Self::InplaceMultiply => "*=",
+            Self::InplaceRemainder => "%=",
+            Self::InplaceOr => "|=",
+            Self::InplacePower => "**=",
+            Self::InplaceRshift => ">>=",
+            Self::InplaceSubtract => "-=",
+            Self::InplaceTrueDivide => "/=",
+            Self::InplaceXor => "^=",
+        };
+        write!(f, "{op}")
+    }
+}
+
+op_arg_enum!(
+    /// Whether or not to invert the operation.
+    #[repr(u8)]
+    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+    pub enum Invert {
+        /// ```py
+        /// foo is bar
+        /// x in lst
+        /// ```
+        No = 0,
+        /// ```py
+        /// foo is not bar
+        /// x not in lst
+        /// ```
+        Yes = 1,
+    }
+);
+
+/// Specifies if a slice is built with either 2 or 3 arguments.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum BuildSliceArgCount {
+    /// ```py
+    /// x[5:10]
+    /// ```
+    Two,
+    /// ```py
+    /// x[5:10:2]
+    /// ```
+    Three,
+}
+
+impl OpArgType for BuildSliceArgCount {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        Some(match x {
+            2 => Self::Two,
+            3 => Self::Three,
+            _ => return None,
+        })
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        u32::from(self.argc().get())
+    }
+}
+
+impl BuildSliceArgCount {
+    /// Get the numeric value of `Self`.
+    #[must_use]
+    pub const fn argc(self) -> NonZeroU8 {
+        let inner = match self {
+            Self::Two => 2,
+            Self::Three => 3,
+        };
+        // Safety: `inner` can be either 2 or 3.
+        unsafe { NonZeroU8::new_unchecked(inner) }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct UnpackExArgs {
+    pub before: u8,
+    pub after: u8,
+}
+
+impl OpArgType for UnpackExArgs {
+    #[inline(always)]
+    fn from_op_arg(x: u32) -> Option<Self> {
+        let [before, after, ..] = x.to_le_bytes();
+        Some(Self { before, after })
+    }
+
+    #[inline(always)]
+    fn to_op_arg(self) -> u32 {
+        u32::from_le_bytes([self.before, self.after, 0, 0])
+    }
+}
+
+impl fmt::Display for UnpackExArgs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "before: {}, after: {}", self.before, self.after)
+    }
+}
diff --git a/compiler/core/src/frozen.rs b/crates/compiler-core/src/frozen.rs
similarity index 99%
rename from compiler/core/src/frozen.rs
rename to crates/compiler-core/src/frozen.rs
index 466a914f04..a79569ad7f 100644
--- a/compiler/core/src/frozen.rs
+++ b/crates/compiler-core/src/frozen.rs
@@ -57,6 +57,7 @@ impl<B: AsRef<[u8]> + ?Sized> FrozenLib<B> {
 impl<'a, B: AsRef<[u8]> + ?Sized> IntoIterator for &'a FrozenLib<B> {
     type Item = (&'a str, FrozenModule<&'a [u8]>);
     type IntoIter = FrozenModulesIter<'a>;
+
     fn into_iter(self) -> Self::IntoIter {
         self.decode()
     }
@@ -84,6 +85,7 @@ impl<'a> Iterator for FrozenModulesIter<'a> {
         (self.remaining as usize, Some(self.remaining as usize))
     }
 }
+
 impl ExactSizeIterator for FrozenModulesIter<'_> {}
 
 fn read_entry<'a>(
diff --git a/crates/compiler-core/src/lib.rs b/crates/compiler-core/src/lib.rs
new file mode 100644
index 0000000000..151d4cdea5
--- /dev/null
+++ b/crates/compiler-core/src/lib.rs
@@ -0,0 +1,16 @@
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
+#![doc(html_root_url = "https://docs.rs/rustpython-compiler-core/")]
+
+extern crate alloc;
+
+pub mod bytecode;
+pub mod frozen;
+pub mod marshal;
+mod mode;
+pub mod varint;
+
+pub use mode::Mode;
+
+pub use ruff_source_file::{
+    LineIndex, OneIndexed, PositionEncoding, SourceFile, SourceFileBuilder, SourceLocation,
+};
diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
new file mode 100644
index 0000000000..5b528fe7e5
--- /dev/null
+++ b/crates/compiler-core/src/marshal.rs
@@ -0,0 +1,703 @@
+use crate::{OneIndexed, SourceLocation, bytecode::*};
+use core::convert::Infallible;
+use malachite_bigint::{BigInt, Sign};
+use num_complex::Complex64;
+use rustpython_wtf8::Wtf8;
+
+pub const FORMAT_VERSION: u32 = 4;
+
+#[derive(Debug)]
+pub enum MarshalError {
+    /// Unexpected End Of File
+    Eof,
+    /// Invalid Bytecode
+    InvalidBytecode,
+    /// Invalid utf8 in string
+    InvalidUtf8,
+    /// Invalid source location
+    InvalidLocation,
+    /// Bad type marker
+    BadType,
+}
+
+impl core::fmt::Display for MarshalError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Eof => f.write_str("unexpected end of data"),
+            Self::InvalidBytecode => f.write_str("invalid bytecode"),
+            Self::InvalidUtf8 => f.write_str("invalid utf8"),
+            Self::InvalidLocation => f.write_str("invalid source location"),
+            Self::BadType => f.write_str("bad type marker"),
+        }
+    }
+}
+
+impl From<core::str::Utf8Error> for MarshalError {
+    fn from(_: core::str::Utf8Error) -> Self {
+        Self::InvalidUtf8
+    }
+}
+
+impl core::error::Error for MarshalError {}
+
+type Result<T, E = MarshalError> = core::result::Result<T, E>;
+
+#[repr(u8)]
+enum Type {
+    // Null = b'0',
+    None = b'N',
+    False = b'F',
+    True = b'T',
+    StopIter = b'S',
+    Ellipsis = b'.',
+    Int = b'i',
+    Float = b'g',
+    Complex = b'y',
+    // Long = b'l',  // i32
+    Bytes = b's', // = TYPE_STRING
+    // Interned = b't',
+    // Ref = b'r',
+    Tuple = b'(',
+    List = b'[',
+    Dict = b'{',
+    Code = b'c',
+    Unicode = b'u',
+    // Unknown = b'?',
+    Set = b'<',
+    FrozenSet = b'>',
+    Ascii = b'a',
+    // AsciiInterned = b'A',
+    // SmallTuple = b')',
+    // 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'N' => None,
+            b'F' => False,
+            b'T' => True,
+            b'S' => StopIter,
+            b'.' => Ellipsis,
+            b'i' => Int,
+            b'g' => Float,
+            b'y' => Complex,
+            // b'l' => Long,
+            b's' => Bytes,
+            // b't' => Interned,
+            // b'r' => Ref,
+            b'(' => Tuple,
+            b'[' => List,
+            b'{' => Dict,
+            b'c' => Code,
+            b'u' => Unicode,
+            // b'?' => Unknown,
+            b'<' => Set,
+            b'>' => FrozenSet,
+            b'a' => Ascii,
+            // b'A' => AsciiInterned,
+            // b')' => SmallTuple,
+            // b'z' => ShortAscii,
+            // b'Z' => ShortAsciiInterned,
+            _ => return Err(MarshalError::BadType),
+        })
+    }
+}
+
+pub trait Read {
+    fn read_slice(&mut self, n: u32) -> Result<&[u8]>;
+
+    fn read_array<const N: usize>(&mut self) -> Result<&[u8; N]> {
+        self.read_slice(N as u32).map(|s| s.try_into().unwrap())
+    }
+
+    fn read_str(&mut self, len: u32) -> Result<&str> {
+        Ok(core::str::from_utf8(self.read_slice(len)?)?)
+    }
+
+    fn read_wtf8(&mut self, len: u32) -> Result<&Wtf8> {
+        Wtf8::from_bytes(self.read_slice(len)?).ok_or(MarshalError::InvalidUtf8)
+    }
+
+    fn read_u8(&mut self) -> Result<u8> {
+        Ok(u8::from_le_bytes(*self.read_array()?))
+    }
+
+    fn read_u16(&mut self) -> Result<u16> {
+        Ok(u16::from_le_bytes(*self.read_array()?))
+    }
+
+    fn read_u32(&mut self) -> Result<u32> {
+        Ok(u32::from_le_bytes(*self.read_array()?))
+    }
+
+    fn read_u64(&mut self) -> Result<u64> {
+        Ok(u64::from_le_bytes(*self.read_array()?))
+    }
+}
+
+pub(crate) trait ReadBorrowed<'a>: Read {
+    fn read_slice_borrow(&mut self, n: u32) -> Result<&'a [u8]>;
+
+    fn read_str_borrow(&mut self, len: u32) -> Result<&'a str> {
+        Ok(core::str::from_utf8(self.read_slice_borrow(len)?)?)
+    }
+}
+
+impl Read for &[u8] {
+    fn read_slice(&mut self, n: u32) -> Result<&[u8]> {
+        self.read_slice_borrow(n)
+    }
+}
+
+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)
+    }
+}
+
+pub struct Cursor<B> {
+    pub data: B,
+    pub position: usize,
+}
+
+impl<B: AsRef<[u8]>> Read for Cursor<B> {
+    fn read_slice(&mut self, n: u32) -> Result<&[u8]> {
+        let data = &self.data.as_ref()[self.position..];
+        let slice = data.get(..n as usize).ok_or(MarshalError::Eof)?;
+        self.position += n as usize;
+        Ok(slice)
+    }
+}
+
+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_u16()?);
+
+    let posonlyarg_count = rdr.read_u32()?;
+    let arg_count = rdr.read_u32()?;
+    let kwonlyarg_count = rdr.read_u32()?;
+
+    let len = rdr.read_u32()?;
+    let source_path = bag.make_name(rdr.read_str(len)?);
+
+    let first_line_number = OneIndexed::new(rdr.read_u32()? as _);
+    let max_stackdepth = rdr.read_u32()?;
+
+    let len = rdr.read_u32()?;
+    let obj_name = bag.make_name(rdr.read_str(len)?);
+
+    let len = rdr.read_u32()?;
+    let qualname = bag.make_name(rdr.read_str(len)?);
+
+    let len = rdr.read_u32()?;
+    let cell2arg = (len != 0)
+        .then(|| {
+            (0..len)
+                .map(|_| Ok(rdr.read_u32()? as i32))
+                .collect::<Result<Box<[i32]>>>()
+        })
+        .transpose()?;
+
+    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<[_]>>>()
+    };
+
+    let names = read_names()?;
+    let varnames = read_names()?;
+    let cellvars = read_names()?;
+    let freevars = read_names()?;
+
+    // Read linetable and exceptiontable
+    let linetable_len = rdr.read_u32()?;
+    let linetable = rdr.read_slice(linetable_len)?.to_vec().into_boxed_slice();
+
+    let exceptiontable_len = rdr.read_u32()?;
+    let exceptiontable = rdr
+        .read_slice(exceptiontable_len)?
+        .to_vec()
+        .into_boxed_slice();
+
+    Ok(CodeObject {
+        instructions,
+        locations,
+        flags,
+        posonlyarg_count,
+        arg_count,
+        kwonlyarg_count,
+        source_path,
+        first_line_number,
+        max_stackdepth,
+        obj_name,
+        qualname,
+        cell2arg,
+        constants,
+        names,
+        varnames,
+        cellvars,
+        freevars,
+        linetable,
+        exceptiontable,
+    })
+}
+
+pub trait MarshalBag: Copy {
+    type Value;
+    type ConstantBag: ConstantBag;
+
+    fn make_bool(&self, value: bool) -> Self::Value;
+
+    fn make_none(&self) -> Self::Value;
+
+    fn make_ellipsis(&self) -> Self::Value;
+
+    fn make_float(&self, value: f64) -> Self::Value;
+
+    fn make_complex(&self, value: Complex64) -> Self::Value;
+
+    fn make_str(&self, value: &Wtf8) -> Self::Value;
+
+    fn make_bytes(&self, value: &[u8]) -> Self::Value;
+
+    fn make_int(&self, value: BigInt) -> Self::Value;
+
+    fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value;
+
+    fn make_code(
+        &self,
+        code: CodeObject<<Self::ConstantBag as ConstantBag>::Constant>,
+    ) -> Self::Value;
+
+    fn make_stop_iter(&self) -> Result<Self::Value>;
+
+    fn make_list(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
+
+    fn make_set(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
+
+    fn make_frozenset(&self, it: impl Iterator<Item = Self::Value>) -> Result<Self::Value>;
+
+    fn make_dict(
+        &self,
+        it: impl Iterator<Item = (Self::Value, Self::Value)>,
+    ) -> Result<Self::Value>;
+
+    fn constant_bag(self) -> Self::ConstantBag;
+}
+
+impl<Bag: ConstantBag> MarshalBag for Bag {
+    type Value = Bag::Constant;
+    type ConstantBag = Self;
+
+    fn make_bool(&self, value: bool) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Boolean { value })
+    }
+
+    fn make_none(&self) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::None)
+    }
+
+    fn make_ellipsis(&self) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Ellipsis)
+    }
+
+    fn make_float(&self, value: f64) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Float { value })
+    }
+
+    fn make_complex(&self, value: Complex64) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Complex { value })
+    }
+
+    fn make_str(&self, value: &Wtf8) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Str { value })
+    }
+
+    fn make_bytes(&self, value: &[u8]) -> Self::Value {
+        self.make_constant::<Bag::Constant>(BorrowedConstant::Bytes { value })
+    }
+
+    fn make_int(&self, value: BigInt) -> Self::Value {
+        self.make_int(value)
+    }
+
+    fn make_tuple(&self, elements: impl Iterator<Item = Self::Value>) -> Self::Value {
+        self.make_tuple(elements)
+    }
+
+    fn make_code(
+        &self,
+        code: CodeObject<<Self::ConstantBag as ConstantBag>::Constant>,
+    ) -> Self::Value {
+        self.make_code(code)
+    }
+
+    fn make_stop_iter(&self) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
+    fn make_list(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
+    fn make_set(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
+    fn make_frozenset(&self, _: impl Iterator<Item = Self::Value>) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
+    fn make_dict(
+        &self,
+        _: impl Iterator<Item = (Self::Value, Self::Value)>,
+    ) -> Result<Self::Value> {
+        Err(MarshalError::BadType)
+    }
+
+    fn constant_bag(self) -> Self::ConstantBag {
+        self
+    }
+}
+
+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 value = match typ {
+        Type::True => bag.make_bool(true),
+        Type::False => bag.make_bool(false),
+        Type::None => bag.make_none(),
+        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)
+        }
+        Type::Float => {
+            let value = f64::from_bits(rdr.read_u64()?);
+            bag.make_float(value)
+        }
+        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 => {
+            let len = rdr.read_u32()?;
+            let value = rdr.read_wtf8(len)?;
+            bag.make_str(value)
+        }
+        Type::Tuple => {
+            let len = rdr.read_u32()?;
+            let it = (0..len).map(|_| deserialize_value(rdr, bag));
+            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));
+            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));
+            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));
+            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))??
+        }
+        Type::Bytes => {
+            // Following CPython, 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())?),
+    };
+    Ok(value)
+}
+
+pub trait Dumpable: Sized {
+    type Error;
+    type Constant: Constant;
+
+    fn with_dump<R>(&self, f: impl FnOnce(DumpableValue<'_, Self>) -> R) -> Result<R, Self::Error>;
+}
+
+pub enum DumpableValue<'a, D: Dumpable> {
+    Integer(&'a BigInt),
+    Float(f64),
+    Complex(Complex64),
+    Boolean(bool),
+    Str(&'a Wtf8),
+    Bytes(&'a [u8]),
+    Code(&'a CodeObject<D::Constant>),
+    Tuple(&'a [D]),
+    None,
+    Ellipsis,
+    StopIter,
+    List(&'a [D]),
+    Set(&'a [D]),
+    Frozenset(&'a [D]),
+    Dict(&'a [(D, D)]),
+}
+
+impl<'a, C: Constant> From<BorrowedConstant<'a, C>> for DumpableValue<'a, C> {
+    fn from(c: BorrowedConstant<'a, C>) -> Self {
+        match c {
+            BorrowedConstant::Integer { value } => Self::Integer(value),
+            BorrowedConstant::Float { value } => Self::Float(value),
+            BorrowedConstant::Complex { value } => Self::Complex(value),
+            BorrowedConstant::Boolean { value } => Self::Boolean(value),
+            BorrowedConstant::Str { value } => Self::Str(value),
+            BorrowedConstant::Bytes { value } => Self::Bytes(value),
+            BorrowedConstant::Code { code } => Self::Code(code),
+            BorrowedConstant::Tuple { elements } => Self::Tuple(elements),
+            BorrowedConstant::None => Self::None,
+            BorrowedConstant::Ellipsis => Self::Ellipsis,
+        }
+    }
+}
+
+impl<C: Constant> Dumpable for C {
+    type Error = Infallible;
+    type Constant = Self;
+
+    #[inline(always)]
+    fn with_dump<R>(&self, f: impl FnOnce(DumpableValue<'_, Self>) -> R) -> Result<R, Self::Error> {
+        Ok(f(self.borrow_constant().into()))
+    }
+}
+
+pub trait Write {
+    fn write_slice(&mut self, slice: &[u8]);
+
+    fn write_u8(&mut self, v: u8) {
+        self.write_slice(&v.to_le_bytes())
+    }
+
+    fn write_u16(&mut self, v: u16) {
+        self.write_slice(&v.to_le_bytes())
+    }
+
+    fn write_u32(&mut self, v: u32) {
+        self.write_slice(&v.to_le_bytes())
+    }
+
+    fn write_u64(&mut self, v: u64) {
+        self.write_slice(&v.to_le_bytes())
+    }
+}
+
+impl Write for Vec<u8> {
+    fn write_slice(&mut self, slice: &[u8]) {
+        self.extend_from_slice(slice)
+    }
+}
+
+pub(crate) fn write_len<W: Write>(buf: &mut W, len: usize) {
+    let Ok(len) = len.try_into() else {
+        panic!("too long to serialize")
+    };
+    buf.write_u32(len);
+}
+
+pub(crate) fn write_vec<W: Write>(buf: &mut W, slice: &[u8]) {
+    write_len(buf, slice.len());
+    buf.write_slice(slice);
+}
+
+pub fn serialize_value<W: Write, D: Dumpable>(
+    buf: &mut W,
+    constant: DumpableValue<'_, D>,
+) -> 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);
+        }
+        DumpableValue::Float(f) => {
+            buf.write_u8(Type::Float as u8);
+            buf.write_u64(f.to_bits());
+        }
+        DumpableValue::Complex(c) => {
+            buf.write_u8(Type::Complex as u8);
+            buf.write_u64(c.re.to_bits());
+            buf.write_u64(c.im.to_bits());
+        }
+        DumpableValue::Boolean(b) => {
+            buf.write_u8(if b { Type::True } else { Type::False } as u8);
+        }
+        DumpableValue::Str(s) => {
+            buf.write_u8(Type::Unicode as u8);
+            write_vec(buf, s.as_bytes());
+        }
+        DumpableValue::Bytes(b) => {
+            buf.write_u8(Type::Bytes as u8);
+            write_vec(buf, b);
+        }
+        DumpableValue::Code(c) => {
+            buf.write_u8(Type::Code as u8);
+            serialize_code(buf, c);
+        }
+        DumpableValue::Tuple(tup) => {
+            buf.write_u8(Type::Tuple as u8);
+            write_len(buf, tup.len());
+            for val in tup {
+                val.with_dump(|val| serialize_value(buf, val))??
+            }
+        }
+        DumpableValue::None => {
+            buf.write_u8(Type::None as u8);
+        }
+        DumpableValue::Ellipsis => {
+            buf.write_u8(Type::Ellipsis as u8);
+        }
+        DumpableValue::StopIter => {
+            buf.write_u8(Type::StopIter as u8);
+        }
+        DumpableValue::List(l) => {
+            buf.write_u8(Type::List as u8);
+            write_len(buf, l.len());
+            for val in l {
+                val.with_dump(|val| serialize_value(buf, val))??
+            }
+        }
+        DumpableValue::Set(set) => {
+            buf.write_u8(Type::Set as u8);
+            write_len(buf, set.len());
+            for val in set {
+                val.with_dump(|val| serialize_value(buf, val))??
+            }
+        }
+        DumpableValue::Frozenset(set) => {
+            buf.write_u8(Type::FrozenSet as u8);
+            write_len(buf, set.len());
+            for val in set {
+                val.with_dump(|val| serialize_value(buf, val))??
+            }
+        }
+        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))??;
+            }
+        }
+    }
+    Ok(())
+}
+
+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);
+
+    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 _);
+    }
+
+    buf.write_u16(code.flags.bits());
+
+    buf.write_u32(code.posonlyarg_count);
+    buf.write_u32(code.arg_count);
+    buf.write_u32(code.kwonlyarg_count);
+
+    write_vec(buf, code.source_path.as_ref().as_bytes());
+
+    buf.write_u32(code.first_line_number.map_or(0, |x| x.get() as _));
+    buf.write_u32(code.max_stackdepth);
+
+    write_vec(buf, code.obj_name.as_ref().as_bytes());
+    write_vec(buf, code.qualname.as_ref().as_bytes());
+
+    let cell2arg = code.cell2arg.as_deref().unwrap_or(&[]);
+    write_len(buf, cell2arg.len());
+    for &i in cell2arg {
+        buf.write_u32(i as u32)
+    }
+
+    write_len(buf, code.constants.len());
+    for constant in &*code.constants {
+        serialize_value(buf, constant.borrow_constant().into()).unwrap_or_else(|x| match x {})
+    }
+
+    let mut write_names = |names: &[C::Name]| {
+        write_len(buf, names.len());
+        for name in names {
+            write_vec(buf, name.as_ref().as_bytes());
+        }
+    };
+
+    write_names(&code.names);
+    write_names(&code.varnames);
+    write_names(&code.cellvars);
+    write_names(&code.freevars);
+
+    // Serialize linetable and exceptiontable
+    write_vec(buf, &code.linetable);
+    write_vec(buf, &code.exceptiontable);
+}
diff --git a/compiler/core/src/mode.rs b/crates/compiler-core/src/mode.rs
similarity index 80%
rename from compiler/core/src/mode.rs
rename to crates/compiler-core/src/mode.rs
index 35e9e77f59..f2b19d677b 100644
--- a/compiler/core/src/mode.rs
+++ b/crates/compiler-core/src/mode.rs
@@ -7,7 +7,7 @@ pub enum Mode {
     BlockExpr,
 }
 
-impl std::str::FromStr for Mode {
+impl core::str::FromStr for Mode {
     type Err = ModeParseError;
 
     // To support `builtins.compile()` `mode` argument
@@ -25,8 +25,8 @@ impl std::str::FromStr for Mode {
 #[derive(Debug)]
 pub struct ModeParseError;
 
-impl std::fmt::Display for ModeParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for ModeParseError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, r#"mode must be "exec", "eval", or "single""#)
     }
 }
diff --git a/crates/compiler-core/src/varint.rs b/crates/compiler-core/src/varint.rs
new file mode 100644
index 0000000000..db8eb88b0e
--- /dev/null
+++ b/crates/compiler-core/src/varint.rs
@@ -0,0 +1,138 @@
+//! Variable-length integer encoding utilities.
+//!
+//! Uses 6-bit chunks with a continuation bit (0x40) to encode integers.
+//! Used for exception tables and line number tables.
+
+/// Write a variable-length unsigned integer using 6-bit chunks.
+/// Returns the number of bytes written.
+#[inline]
+pub fn write_varint(buf: &mut Vec<u8>, mut val: u32) -> usize {
+    let start_len = buf.len();
+    while val >= 64 {
+        buf.push(0x40 | (val & 0x3f) as u8);
+        val >>= 6;
+    }
+    buf.push(val as u8);
+    buf.len() - start_len
+}
+
+/// Write a variable-length signed integer.
+/// Returns the number of bytes written.
+#[inline]
+pub fn write_signed_varint(buf: &mut Vec<u8>, val: i32) -> usize {
+    let uval = if val < 0 {
+        // (0 - val as u32) handles INT_MIN correctly
+        ((0u32.wrapping_sub(val as u32)) << 1) | 1
+    } else {
+        (val as u32) << 1
+    };
+    write_varint(buf, uval)
+}
+
+/// Write a variable-length unsigned integer with a start marker (0x80 bit).
+/// Used for exception table entries where each entry starts with the marker.
+pub fn write_varint_with_start(data: &mut Vec<u8>, val: u32) {
+    let start_pos = data.len();
+    write_varint(data, val);
+    // Set start bit on first byte
+    if let Some(first) = data.get_mut(start_pos) {
+        *first |= 0x80;
+    }
+}
+
+/// Read a variable-length unsigned integer that starts with a start marker (0x80 bit).
+/// Returns None if not at a valid start byte or end of data.
+pub fn read_varint_with_start(data: &[u8], pos: &mut usize) -> Option<u32> {
+    if *pos >= data.len() {
+        return None;
+    }
+    let first = data[*pos];
+    if first & 0x80 == 0 {
+        return None; // Not a start byte
+    }
+    *pos += 1;
+
+    let mut val = (first & 0x3f) as u32;
+    let mut shift = 6;
+    let mut has_continuation = first & 0x40 != 0;
+
+    while has_continuation && *pos < data.len() {
+        let byte = data[*pos];
+        if byte & 0x80 != 0 {
+            break; // Next entry start
+        }
+        *pos += 1;
+        val |= ((byte & 0x3f) as u32) << shift;
+        shift += 6;
+        has_continuation = byte & 0x40 != 0;
+    }
+    Some(val)
+}
+
+/// Read a variable-length unsigned integer.
+/// Returns None if end of data or malformed.
+pub fn read_varint(data: &[u8], pos: &mut usize) -> Option<u32> {
+    if *pos >= data.len() {
+        return None;
+    }
+
+    let mut val = 0u32;
+    let mut shift = 0;
+
+    loop {
+        if *pos >= data.len() {
+            return None;
+        }
+        let byte = data[*pos];
+        if byte & 0x80 != 0 && shift > 0 {
+            break; // Next entry start
+        }
+        *pos += 1;
+        val |= ((byte & 0x3f) as u32) << shift;
+        shift += 6;
+        if byte & 0x40 == 0 {
+            break;
+        }
+    }
+    Some(val)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_write_read_varint() {
+        let mut buf = Vec::new();
+        write_varint(&mut buf, 0);
+        write_varint(&mut buf, 63);
+        write_varint(&mut buf, 64);
+        write_varint(&mut buf, 4095);
+
+        // Values: 0, 63, 64, 4095
+        assert_eq!(buf.len(), 1 + 1 + 2 + 2);
+    }
+
+    #[test]
+    fn test_write_read_signed_varint() {
+        let mut buf = Vec::new();
+        write_signed_varint(&mut buf, 0);
+        write_signed_varint(&mut buf, 1);
+        write_signed_varint(&mut buf, -1);
+        write_signed_varint(&mut buf, i32::MIN);
+
+        assert!(!buf.is_empty());
+    }
+
+    #[test]
+    fn test_varint_with_start() {
+        let mut buf = Vec::new();
+        write_varint_with_start(&mut buf, 42);
+        write_varint_with_start(&mut buf, 100);
+
+        let mut pos = 0;
+        assert_eq!(read_varint_with_start(&buf, &mut pos), Some(42));
+        assert_eq!(read_varint_with_start(&buf, &mut pos), Some(100));
+        assert_eq!(read_varint_with_start(&buf, &mut pos), None);
+    }
+}
diff --git a/crates/compiler-source/Cargo.toml b/crates/compiler-source/Cargo.toml
new file mode 100644
index 0000000000..068d31e87e
--- /dev/null
+++ b/crates/compiler-source/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "rustpython-compiler-source"
+description = "(DEPRECATED) RustPython Source and Index"
+version = "0.5.0+deprecated"
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+ruff_source_file = { workspace = true }
+ruff_text_size = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/compiler-source/src/lib.rs b/crates/compiler-source/src/lib.rs
new file mode 100644
index 0000000000..e3fb55ef60
--- /dev/null
+++ b/crates/compiler-source/src/lib.rs
@@ -0,0 +1,43 @@
+pub use ruff_source_file::{LineIndex, OneIndexed as LineNumber, PositionEncoding, SourceLocation};
+use ruff_text_size::TextRange;
+pub use ruff_text_size::TextSize;
+
+#[derive(Clone)]
+pub struct SourceCode<'src> {
+    pub path: &'src str,
+    pub text: &'src str,
+    pub index: LineIndex,
+}
+
+impl<'src> SourceCode<'src> {
+    pub fn new(path: &'src str, text: &'src str) -> Self {
+        let index = LineIndex::from_source_text(text);
+        Self { path, text, index }
+    }
+
+    pub fn line_index(&self, offset: TextSize) -> LineNumber {
+        self.index.line_index(offset)
+    }
+
+    pub fn source_location(&self, offset: TextSize) -> SourceLocation {
+        self.index
+            .source_location(offset, self.text, PositionEncoding::Utf8)
+    }
+
+    pub fn get_range(&'src self, range: TextRange) -> &'src str {
+        &self.text[range.start().to_usize()..range.end().to_usize()]
+    }
+}
+
+pub struct SourceCodeOwned {
+    pub path: String,
+    pub text: String,
+    pub index: LineIndex,
+}
+
+impl SourceCodeOwned {
+    pub fn new(path: String, text: String) -> Self {
+        let index = LineIndex::from_source_text(&text);
+        Self { path, text, index }
+    }
+}
diff --git a/crates/compiler/Cargo.toml b/crates/compiler/Cargo.toml
new file mode 100644
index 0000000000..5c79324111
--- /dev/null
+++ b/crates/compiler/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "rustpython-compiler"
+description = "A usability wrapper around rustpython-parser and rustpython-compiler-core"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+rustpython-codegen = { workspace = true }
+rustpython-compiler-core = { workspace = true }
+ruff_python_parser = { workspace = true }
+ruff_python_ast = { workspace = true }
+ruff_source_file = { workspace = true }
+ruff_text_size = { workspace = true }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+
+[lints]
+workspace = true
diff --git a/crates/compiler/src/lib.rs b/crates/compiler/src/lib.rs
new file mode 100644
index 0000000000..11e3bf0d07
--- /dev/null
+++ b/crates/compiler/src/lib.rs
@@ -0,0 +1,329 @@
+use ruff_source_file::{PositionEncoding, SourceFile, SourceFileBuilder, SourceLocation};
+use rustpython_codegen::{compile, symboltable};
+
+pub use rustpython_codegen::compile::CompileOpts;
+pub use rustpython_compiler_core::{Mode, bytecode::CodeObject};
+
+// these modules are out of repository. re-exporting them here for convenience.
+pub use ruff_python_ast as ast;
+pub use ruff_python_parser as parser;
+pub use rustpython_codegen as codegen;
+pub use rustpython_compiler_core as core;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum CompileErrorType {
+    #[error(transparent)]
+    Codegen(#[from] codegen::error::CodegenErrorType),
+    #[error(transparent)]
+    Parse(#[from] parser::ParseErrorType),
+}
+
+#[derive(Error, Debug)]
+pub struct ParseError {
+    #[source]
+    pub error: parser::ParseErrorType,
+    pub raw_location: ruff_text_size::TextRange,
+    pub location: SourceLocation,
+    pub end_location: SourceLocation,
+    pub source_path: String,
+}
+
+impl ::core::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+        self.error.fmt(f)
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum CompileError {
+    #[error(transparent)]
+    Codegen(#[from] codegen::error::CodegenError),
+    #[error(transparent)]
+    Parse(#[from] ParseError),
+}
+
+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);
+        }
+
+        Self::Parse(ParseError {
+            error: error.error,
+            raw_location: error.location,
+            location,
+            end_location,
+            source_path: source_file.name().to_owned(),
+        })
+    }
+
+    pub const fn location(&self) -> Option<SourceLocation> {
+        match self {
+            Self::Codegen(codegen_error) => codegen_error.location,
+            Self::Parse(parse_error) => Some(parse_error.location),
+        }
+    }
+
+    pub const fn python_location(&self) -> (usize, usize) {
+        if let Some(location) = self.location() {
+            (location.line.get(), location.character_offset.get())
+        } else {
+            (0, 0)
+        }
+    }
+
+    pub fn python_end_location(&self) -> Option<(usize, usize)> {
+        match self {
+            CompileError::Codegen(_) => None,
+            CompileError::Parse(parse_error) => Some((
+                parse_error.end_location.line.get(),
+                parse_error.end_location.character_offset.get(),
+            )),
+        }
+    }
+
+    pub fn source_path(&self) -> &str {
+        match self {
+            Self::Codegen(codegen_error) => &codegen_error.source_path,
+            Self::Parse(parse_error) => &parse_error.source_path,
+        }
+    }
+}
+
+/// Compile a given source code into a bytecode object.
+pub fn compile(
+    source: &str,
+    mode: Mode,
+    source_path: &str,
+    opts: CompileOpts,
+) -> Result<CodeObject, CompileError> {
+    // TODO: do this less hacky; ruff's parser should translate a CRLF line
+    //       break in a multiline string into just an LF in the parsed value
+    #[cfg(windows)]
+    let source = source.replace("\r\n", "\n");
+    #[cfg(windows)]
+    let source = source.as_str();
+
+    let source_file = SourceFileBuilder::new(source_path, source).finish();
+    _compile(source_file, mode, opts)
+    // let index = LineIndex::from_source_text(source);
+    // let source_code = SourceCode::new(source, &index);
+    // let mut locator = LinearLocator::new(source);
+    // let mut ast = match parser::parse(source, mode.into(), &source_path) {
+    //     Ok(x) => x,
+    //     Err(e) => return Err(locator.locate_error(e)),
+    // };
+
+    // TODO:
+    // if opts.optimize > 0 {
+    //     ast = ConstantOptimizer::new()
+    //         .fold_mod(ast)
+    //         .unwrap_or_else(|e| match e {});
+    // }
+    // let ast = locator.fold_mod(ast).unwrap_or_else(|e| match e {});
+}
+
+fn _compile(
+    source_file: SourceFile,
+    mode: Mode,
+    opts: CompileOpts,
+) -> Result<CodeObject, CompileError> {
+    let parser_mode = match mode {
+        Mode::Exec => parser::Mode::Module,
+        Mode::Eval => parser::Mode::Expression,
+        // ruff does not have an interactive mode, which is fine,
+        // since these are only different in terms of compilation
+        Mode::Single | Mode::BlockExpr => parser::Mode::Module,
+    };
+    let parsed = parser::parse(source_file.source_text(), parser_mode.into())
+        .map_err(|err| CompileError::from_ruff_parse_error(err, &source_file))?;
+    let ast = parsed.into_syntax();
+    compile::compile_top(ast, source_file, mode, opts).map_err(|e| e.into())
+}
+
+pub fn compile_symtable(
+    source: &str,
+    mode: Mode,
+    source_path: &str,
+) -> Result<symboltable::SymbolTable, CompileError> {
+    let source_file = SourceFileBuilder::new(source_path, source).finish();
+    _compile_symtable(source_file, mode)
+}
+
+pub fn _compile_symtable(
+    source_file: SourceFile,
+    mode: Mode,
+) -> Result<symboltable::SymbolTable, CompileError> {
+    let res = match mode {
+        Mode::Exec | Mode::Single | Mode::BlockExpr => {
+            let ast = ruff_python_parser::parse_module(source_file.source_text())
+                .map_err(|e| CompileError::from_ruff_parse_error(e, &source_file))?;
+            symboltable::SymbolTable::scan_program(&ast.into_syntax(), source_file.clone())
+        }
+        Mode::Eval => {
+            let ast = ruff_python_parser::parse(
+                source_file.source_text(),
+                parser::Mode::Expression.into(),
+            )
+            .map_err(|e| CompileError::from_ruff_parse_error(e, &source_file))?;
+            symboltable::SymbolTable::scan_expr(
+                &ast.into_syntax().expect_expression(),
+                source_file.clone(),
+            )
+        }
+    };
+    res.map_err(|e| e.into_codegen_error(source_file.name().to_owned()).into())
+}
+
+#[test]
+fn test_compile() {
+    let code = "x = 'abc'";
+    let compiled = compile(code, Mode::Single, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_phello() {
+    let code = r#"
+initialized = True
+def main():
+    print("Hello world!")
+if __name__ == '__main__':
+    main()
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_if_elif_else() {
+    let code = r#"
+if False:
+    pass
+elif False:
+    pass
+elif False:
+    pass
+else:
+    pass
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_lambda() {
+    let code = r#"
+lambda: 'a'
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_lambda2() {
+    let code = r#"
+(lambda x: f'hello, {x}')('world}')
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_lambda3() {
+    let code = r#"
+def g():
+    pass
+def f():
+    if False:
+        return lambda x: g(x)
+    elif False:
+        return g
+    else:
+        return g
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_int() {
+    let code = r#"
+a = 0xFF
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_bigint() {
+    let code = r#"
+a = 0xFFFFFFFFFFFFFFFFFFFFFFFF
+"#;
+    let compiled = compile(code, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_compile_fstring() {
+    let code1 = r#"
+assert f"1" == '1'
+    "#;
+    let compiled = compile(code1, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+
+    let code2 = r#"
+assert f"{1}" == '1'
+    "#;
+    let compiled = compile(code2, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+    let code3 = r#"
+assert f"{1+1}" == '2'
+    "#;
+    let compiled = compile(code3, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+
+    let code4 = r#"
+assert f"{{{(lambda: f'{1}')}" == '{1'
+    "#;
+    let compiled = compile(code4, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+
+    let code5 = r#"
+assert f"a{1}" == 'a1'
+    "#;
+    let compiled = compile(code5, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+
+    let code6 = r#"
+assert f"{{{(lambda x: f'hello, {x}')('world}')}" == '{hello, world}'
+    "#;
+    let compiled = compile(code6, Mode::Exec, "<>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
+
+#[test]
+fn test_simple_enum() {
+    let code = r#"
+import enum
+@enum._simple_enum(enum.IntFlag, boundary=enum.KEEP)
+class RegexFlag:
+    NOFLAG = 0
+    DEBUG = 1
+print(RegexFlag.NOFLAG & RegexFlag.DEBUG)
+"#;
+    let compiled = compile(code, Mode::Exec, "<string>", CompileOpts::default());
+    dbg!(compiled.expect("compile error"));
+}
diff --git a/crates/derive-impl/Cargo.toml b/crates/derive-impl/Cargo.toml
new file mode 100644
index 0000000000..a772cab1d3
--- /dev/null
+++ b/crates/derive-impl/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "rustpython-derive-impl"
+description = "Rust language extensions and macros specific to rustpython."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[dependencies]
+rustpython-compiler-core = { workspace = true }
+# rustpython-parser-core = { workspace = true }
+rustpython-doc = { workspace = true }
+
+itertools = { workspace = true }
+syn = { workspace = true, features = ["full", "extra-traits"] }
+
+maplit = "1.0.2"
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn-ext = { version = "0.5.0", features = ["full"] }
+textwrap = { version = "0.16.1", default-features = false }
+
+[lints]
+workspace = true
diff --git a/derive-impl/src/compile_bytecode.rs b/crates/derive-impl/src/compile_bytecode.rs
similarity index 93%
rename from derive-impl/src/compile_bytecode.rs
rename to crates/derive-impl/src/compile_bytecode.rs
index edd746f1e1..23c90690da 100644
--- a/derive-impl/src/compile_bytecode.rs
+++ b/crates/derive-impl/src/compile_bytecode.rs
@@ -58,11 +58,11 @@ pub trait Compiler {
         source: &str,
         mode: Mode,
         module_name: String,
-    ) -> Result<CodeObject, Box<dyn std::error::Error>>;
+    ) -> Result<CodeObject, Box<dyn core::error::Error>>;
 }
 
 impl CompilationSource {
-    fn compile_string<D: std::fmt::Display, F: FnOnce() -> D>(
+    fn compile_string<D: core::fmt::Display, F: FnOnce() -> D>(
         &self,
         source: &str,
         mode: Mode,
@@ -140,10 +140,10 @@ impl CompilationSource {
         let mut code_map = HashMap::new();
         let paths = fs::read_dir(path)
             .or_else(|e| {
-                if cfg!(windows) {
-                    if let Ok(real_path) = fs::read_to_string(path.canonicalize().unwrap()) {
-                        return fs::read_dir(real_path.trim());
-                    }
+                if cfg!(windows)
+                    && let Ok(real_path) = fs::read_to_string(path.canonicalize().unwrap())
+                {
+                    return fs::read_dir(real_path.trim());
                 }
                 Err(e)
             })
@@ -195,14 +195,14 @@ impl CompilationSource {
                     })
                 };
                 let code = compile_path(&path).or_else(|e| {
-                    if cfg!(windows) {
-                        if let Ok(real_path) = fs::read_to_string(path.canonicalize().unwrap()) {
-                            let joined = path.parent().unwrap().join(real_path.trim());
-                            if joined.exists() {
-                                return compile_path(&joined);
-                            } else {
-                                return Err(e);
-                            }
+                    if cfg!(windows)
+                        && let Ok(real_path) = fs::read_to_string(path.canonicalize().unwrap())
+                    {
+                        let joined = path.parent().unwrap().join(real_path.trim());
+                        if joined.exists() {
+                            return compile_path(&joined);
+                        } else {
+                            return Err(e);
                         }
                     }
                     Err(e)
diff --git a/derive-impl/src/error.rs b/crates/derive-impl/src/error.rs
similarity index 100%
rename from derive-impl/src/error.rs
rename to crates/derive-impl/src/error.rs
diff --git a/crates/derive-impl/src/from_args.rs b/crates/derive-impl/src/from_args.rs
new file mode 100644
index 0000000000..667f887e81
--- /dev/null
+++ b/crates/derive-impl/src/from_args.rs
@@ -0,0 +1,243 @@
+use proc_macro2::TokenStream;
+use quote::{ToTokens, quote};
+use syn::ext::IdentExt;
+use syn::meta::ParseNestedMeta;
+use syn::{Attribute, Data, DeriveInput, Expr, Field, Ident, Result, Token, parse_quote};
+
+/// The kind of the python parameter, this corresponds to the value of Parameter.kind
+/// (https://docs.python.org/3/library/inspect.html#inspect.Parameter.kind)
+#[derive(Default)]
+enum ParameterKind {
+    PositionalOnly,
+    #[default]
+    PositionalOrKeyword,
+    KeywordOnly,
+    Flatten,
+}
+
+impl TryFrom<&Ident> for ParameterKind {
+    type Error = ();
+
+    fn try_from(ident: &Ident) -> core::result::Result<Self, Self::Error> {
+        Ok(match ident.to_string().as_str() {
+            "positional" => Self::PositionalOnly,
+            "any" => Self::PositionalOrKeyword,
+            "named" => Self::KeywordOnly,
+            "flatten" => Self::Flatten,
+            _ => return Err(()),
+        })
+    }
+}
+
+// None == quote!(Default::default())
+type DefaultValue = Option<Expr>;
+
+#[derive(Default)]
+struct ArgAttribute {
+    name: Option<String>,
+    kind: ParameterKind,
+    default: Option<DefaultValue>,
+}
+
+impl ArgAttribute {
+    fn from_attribute(attr: &Attribute) -> Option<Result<Self>> {
+        if !attr.path().is_ident("pyarg") {
+            return None;
+        }
+
+        let inner = move || {
+            let mut arg_attr = None;
+            attr.parse_nested_meta(|meta| {
+                let Some(arg_attr) = &mut arg_attr else {
+                    let kind = meta
+                        .path
+                        .get_ident()
+                        .and_then(|ident| ParameterKind::try_from(ident).ok())
+                        .ok_or_else(|| {
+                            meta.error(
+                                "The first argument to #[pyarg()] must be the parameter type, \
+                                 either 'positional', 'any', 'named', or 'flatten'.",
+                            )
+                        })?;
+                    arg_attr = Some(Self {
+                        name: None,
+                        kind,
+                        default: None,
+                    });
+                    return Ok(());
+                };
+                arg_attr.parse_argument(meta)
+            })?;
+            arg_attr
+                .ok_or_else(|| err_span!(attr, "There must be at least one argument to #[pyarg()]"))
+        };
+        Some(inner())
+    }
+
+    fn parse_argument(&mut self, meta: ParseNestedMeta<'_>) -> Result<()> {
+        if let ParameterKind::Flatten = self.kind {
+            return Err(meta.error("can't put additional arguments on a flatten arg"));
+        }
+        if meta.path.is_ident("default") && meta.input.peek(Token![=]) {
+            if matches!(self.default, Some(Some(_))) {
+                return Err(meta.error("Default already set"));
+            }
+            let val = meta.value()?;
+            self.default = Some(Some(val.parse()?))
+        } else if meta.path.is_ident("default") || meta.path.is_ident("optional") {
+            if self.default.is_none() {
+                self.default = Some(None);
+            }
+        } else if meta.path.is_ident("name") {
+            if self.name.is_some() {
+                return Err(meta.error("already have a name"));
+            }
+            let val = meta.value()?.parse::<syn::LitStr>()?;
+            self.name = Some(val.value())
+        } else {
+            return Err(meta.error("Unrecognized pyarg attribute"));
+        }
+
+        Ok(())
+    }
+}
+
+impl TryFrom<&Field> for ArgAttribute {
+    type Error = syn::Error;
+
+    fn try_from(field: &Field) -> core::result::Result<Self, Self::Error> {
+        let mut pyarg_attrs = field
+            .attrs
+            .iter()
+            .filter_map(Self::from_attribute)
+            .collect::<core::result::Result<Vec<_>, _>>()?;
+
+        if pyarg_attrs.len() >= 2 {
+            bail_span!(field, "Multiple pyarg attributes on field")
+        };
+
+        Ok(pyarg_attrs.pop().unwrap_or_default())
+    }
+}
+
+fn generate_field((i, field): (usize, &Field)) -> Result<TokenStream> {
+    let attr = ArgAttribute::try_from(field)?;
+    let name = field.ident.as_ref();
+    let name_string = name.map(|ident| ident.unraw().to_string());
+    if matches!(&name_string, Some(s) if s.starts_with("_phantom")) {
+        return Ok(quote! {
+            #name: ::std::marker::PhantomData,
+        });
+    }
+
+    let field_name = match name {
+        Some(id) => id.to_token_stream(),
+        None => syn::Index::from(i).into_token_stream(),
+    };
+
+    if let ParameterKind::Flatten = attr.kind {
+        return Ok(quote! {
+            #field_name: ::rustpython_vm::function::FromArgs::from_args(vm, args)?,
+        });
+    }
+
+    let pyname = attr
+        .name
+        .or(name_string)
+        .ok_or_else(|| err_span!(field, "field in tuple struct must have name attribute"))?;
+
+    let middle = quote! {
+        .map(|x| ::rustpython_vm::convert::TryFromObject::try_from_object(vm, x)).transpose()?
+    };
+
+    let ending = if let Some(default) = attr.default {
+        let ty = &field.ty;
+        let default = default.unwrap_or_else(|| parse_quote!(::std::default::Default::default()));
+        quote! {
+            .map(<#ty as ::rustpython_vm::function::FromArgOptional>::from_inner)
+            .unwrap_or_else(|| #default)
+        }
+    } else {
+        let err = match attr.kind {
+            ParameterKind::PositionalOnly | ParameterKind::PositionalOrKeyword => quote! {
+                ::rustpython_vm::function::ArgumentError::TooFewArgs
+            },
+            ParameterKind::KeywordOnly => quote! {
+                ::rustpython_vm::function::ArgumentError::RequiredKeywordArgument(#pyname.to_owned())
+            },
+            ParameterKind::Flatten => unreachable!(),
+        };
+        quote! {
+            .ok_or_else(|| #err)?
+        }
+    };
+
+    let file_output = match attr.kind {
+        ParameterKind::PositionalOnly => quote! {
+            #field_name: args.take_positional()#middle #ending,
+        },
+        ParameterKind::PositionalOrKeyword => quote! {
+            #field_name: args.take_positional_keyword(#pyname)#middle #ending,
+        },
+        ParameterKind::KeywordOnly => quote! {
+            #field_name: args.take_keyword(#pyname)#middle #ending,
+        },
+        ParameterKind::Flatten => unreachable!(),
+    };
+
+    Ok(file_output)
+}
+
+fn compute_arity_bounds(field_attrs: &[ArgAttribute]) -> (usize, usize) {
+    let positional_fields = field_attrs.iter().filter(|attr| {
+        matches!(
+            attr.kind,
+            ParameterKind::PositionalOnly | ParameterKind::PositionalOrKeyword
+        )
+    });
+
+    let min_arity = positional_fields
+        .clone()
+        .filter(|attr| attr.default.is_none())
+        .count();
+    let max_arity = positional_fields.count();
+
+    (min_arity, max_arity)
+}
+
+pub fn impl_from_args(input: DeriveInput) -> Result<TokenStream> {
+    let (fields, field_attrs) = match input.data {
+        Data::Struct(syn::DataStruct { fields, .. }) => (
+            fields
+                .iter()
+                .enumerate()
+                .map(generate_field)
+                .collect::<Result<TokenStream>>()?,
+            fields
+                .iter()
+                .filter_map(|field| field.try_into().ok())
+                .collect::<Vec<ArgAttribute>>(),
+        ),
+        _ => bail_span!(input, "FromArgs input must be a struct"),
+    };
+
+    let (min_arity, max_arity) = compute_arity_bounds(&field_attrs);
+
+    let name = input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let output = quote! {
+        impl #impl_generics ::rustpython_vm::function::FromArgs for #name #ty_generics #where_clause {
+            fn arity() -> ::std::ops::RangeInclusive<usize> {
+                #min_arity..=#max_arity
+            }
+
+            fn from_args(
+                vm: &::rustpython_vm::VirtualMachine,
+                args: &mut ::rustpython_vm::function::FuncArgs
+            ) -> ::core::result::Result<Self, ::rustpython_vm::function::ArgumentError> {
+                Ok(Self { #fields })
+            }
+        }
+    };
+    Ok(output)
+}
diff --git a/crates/derive-impl/src/lib.rs b/crates/derive-impl/src/lib.rs
new file mode 100644
index 0000000000..51bb0af406
--- /dev/null
+++ b/crates/derive-impl/src/lib.rs
@@ -0,0 +1,83 @@
+#![recursion_limit = "128"]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
+#![doc(html_root_url = "https://docs.rs/rustpython-derive/")]
+
+extern crate proc_macro;
+
+#[macro_use]
+extern crate maplit;
+
+#[macro_use]
+mod error;
+#[macro_use]
+mod util;
+
+mod compile_bytecode;
+mod from_args;
+mod pyclass;
+mod pymodule;
+mod pypayload;
+mod pystructseq;
+mod pytraverse;
+
+use error::Diagnostic;
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::{DeriveInput, Item};
+use syn_ext::types::PunctuatedNestedMeta;
+
+pub use compile_bytecode::Compiler;
+
+fn result_to_tokens(result: Result<TokenStream, impl Into<Diagnostic>>) -> TokenStream {
+    result
+        .map_err(|e| e.into())
+        .unwrap_or_else(ToTokens::into_token_stream)
+}
+
+pub fn derive_from_args(input: DeriveInput) -> TokenStream {
+    result_to_tokens(from_args::impl_from_args(input))
+}
+
+pub fn pyclass(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    if matches!(item, syn::Item::Impl(_) | syn::Item::Trait(_)) {
+        result_to_tokens(pyclass::impl_pyclass_impl(attr, item))
+    } else {
+        result_to_tokens(pyclass::impl_pyclass(attr, item))
+    }
+}
+
+pub fn pyexception(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    if matches!(item, syn::Item::Impl(_)) {
+        result_to_tokens(pyclass::impl_pyexception_impl(attr, item))
+    } else {
+        result_to_tokens(pyclass::impl_pyexception(attr, item))
+    }
+}
+
+pub fn pymodule(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    result_to_tokens(pymodule::impl_pymodule(attr, item))
+}
+
+pub fn pystruct_sequence(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    result_to_tokens(pystructseq::impl_pystruct_sequence(attr, item))
+}
+
+pub fn pystruct_sequence_data(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
+    result_to_tokens(pystructseq::impl_pystruct_sequence_data(attr, item))
+}
+
+pub fn py_compile(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
+    result_to_tokens(compile_bytecode::impl_py_compile(input, compiler))
+}
+
+pub fn py_freeze(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
+    result_to_tokens(compile_bytecode::impl_py_freeze(input, compiler))
+}
+
+pub fn pypayload(input: DeriveInput) -> TokenStream {
+    result_to_tokens(pypayload::impl_pypayload(input))
+}
+
+pub fn pytraverse(item: DeriveInput) -> TokenStream {
+    result_to_tokens(pytraverse::impl_pytraverse(item))
+}
diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
new file mode 100644
index 0000000000..a81a7bacba
--- /dev/null
+++ b/crates/derive-impl/src/pyclass.rs
@@ -0,0 +1,1951 @@
+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,
+};
+use core::str::FromStr;
+use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
+use quote::{ToTokens, quote, quote_spanned};
+use rustpython_doc::DB;
+use std::collections::{HashMap, HashSet};
+use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
+use syn_ext::ext::*;
+use syn_ext::types::*;
+
+#[derive(Copy, Clone, Debug)]
+enum AttrName {
+    Method,
+    ClassMethod,
+    StaticMethod,
+    GetSet,
+    Slot,
+    Attr,
+    ExtendClass,
+    Member,
+}
+
+impl core::fmt::Display for AttrName {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let s = match self {
+            Self::Method => "pymethod",
+            Self::ClassMethod => "pyclassmethod",
+            Self::StaticMethod => "pystaticmethod",
+            Self::GetSet => "pygetset",
+            Self::Slot => "pyslot",
+            Self::Attr => "pyattr",
+            Self::ExtendClass => "extend_class",
+            Self::Member => "pymember",
+        };
+        s.fmt(f)
+    }
+}
+
+impl FromStr for AttrName {
+    type Err = String;
+
+    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
+        Ok(match s {
+            "pymethod" => Self::Method,
+            "pyclassmethod" => Self::ClassMethod,
+            "pystaticmethod" => Self::StaticMethod,
+            "pygetset" => Self::GetSet,
+            "pyslot" => Self::Slot,
+            "pyattr" => Self::Attr,
+            "extend_class" => Self::ExtendClass,
+            "pymember" => Self::Member,
+            s => {
+                return Err(s.to_owned());
+            }
+        })
+    }
+}
+
+#[derive(Default)]
+struct ImplContext {
+    is_trait: bool,
+    attribute_items: ItemNursery,
+    method_items: MethodNursery,
+    getset_items: GetSetNursery,
+    member_items: MemberNursery,
+    extend_slots_items: ItemNursery,
+    class_extensions: Vec<TokenStream>,
+    errors: Vec<syn::Error>,
+}
+
+fn extract_items_into_context<'a, Item>(
+    context: &mut ImplContext,
+    items: impl Iterator<Item = &'a mut Item>,
+) where
+    Item: ItemLike + ToTokens + GetIdent + syn_ext::ext::ItemAttrExt + 'a,
+{
+    for item in items {
+        let r = item.try_split_attr_mut(|attrs, item| {
+            let (py_items, cfgs) = attrs_to_content_items(attrs, impl_item_new::<Item>)?;
+            for py_item in py_items.iter().rev() {
+                let r = py_item.gen_impl_item(ImplItemArgs::<Item> {
+                    item,
+                    attrs,
+                    context,
+                    cfgs: cfgs.as_slice(),
+                });
+                context.errors.ok_or_push(r);
+            }
+            Ok(())
+        });
+        context.errors.ok_or_push(r);
+    }
+    context.errors.ok_or_push(context.method_items.validate());
+    context.errors.ok_or_push(context.getset_items.validate());
+    context.errors.ok_or_push(context.member_items.validate());
+}
+
+pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+    let mut context = ImplContext::default();
+    let mut tokens = match item {
+        Item::Impl(mut imp) => {
+            extract_items_into_context(&mut context, imp.items.iter_mut());
+
+            let (impl_ty, payload_guess) = match imp.self_ty.as_ref() {
+                syn::Type::Path(syn::TypePath {
+                    path: syn::Path { segments, .. },
+                    ..
+                }) if segments.len() == 1 => {
+                    let segment = &segments[0];
+                    let payload_ty = if segment.ident == "Py" || segment.ident == "PyRef" {
+                        match &segment.arguments {
+                            syn::PathArguments::AngleBracketed(
+                                syn::AngleBracketedGenericArguments { args, .. },
+                            ) if args.len() == 1 => {
+                                let arg = &args[0];
+                                match arg {
+                                    syn::GenericArgument::Type(syn::Type::Path(
+                                        syn::TypePath {
+                                            path: syn::Path { segments, .. },
+                                            ..
+                                        },
+                                    )) if segments.len() == 1 => segments[0].ident.clone(),
+                                    _ => {
+                                        return Err(syn::Error::new_spanned(
+                                            segment,
+                                            "Py{Ref}<T> is expected but Py{Ref}<?> is found",
+                                        ));
+                                    }
+                                }
+                            }
+                            _ => {
+                                return Err(syn::Error::new_spanned(
+                                    segment,
+                                    "Py{Ref}<T> is expected but Py{Ref}? is found",
+                                ));
+                            }
+                        }
+                    } else {
+                        if !matches!(segment.arguments, syn::PathArguments::None) {
+                            return Err(syn::Error::new_spanned(
+                                segment,
+                                "PyImpl can only be implemented for Py{Ref}<T> or T",
+                            ));
+                        }
+                        segment.ident.clone()
+                    };
+                    (segment.ident.clone(), payload_ty)
+                }
+                _ => {
+                    return Err(syn::Error::new_spanned(
+                        imp.self_ty,
+                        "PyImpl can only be implemented for Py{Ref}<T> or T",
+                    ));
+                }
+            };
+
+            let ExtractedImplAttrs {
+                payload: attr_payload,
+                flags,
+                with_impl,
+                with_method_defs,
+                with_slots,
+                itemsize,
+            } = extract_impl_attrs(attr, &impl_ty)?;
+            let payload_ty = attr_payload.unwrap_or(payload_guess);
+            let method_def = &context.method_items;
+            let getset_impl = &context.getset_items;
+            let member_impl = &context.member_items;
+            let extend_impl = context.attribute_items.validate()?;
+            let slots_impl = context.extend_slots_items.validate()?;
+            let class_extensions = &context.class_extensions;
+
+            let extra_methods = [
+                parse_quote! {
+                    const __OWN_METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_def;
+                },
+                parse_quote! {
+                    fn __extend_py_class(
+                        ctx: &::rustpython_vm::Context,
+                        class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
+                    ) {
+                        #getset_impl
+                        #member_impl
+                        #extend_impl
+                        #(#class_extensions)*
+                    }
+                },
+                {
+                    let itemsize_impl = itemsize.as_ref().map(|size| {
+                        quote! {
+                            slots.itemsize = #size;
+                        }
+                    });
+                    parse_quote! {
+                        fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
+                            #itemsize_impl
+                            #slots_impl
+                        }
+                    }
+                },
+            ];
+            imp.items.extend(extra_methods);
+            let is_main_impl = impl_ty == payload_ty;
+            if is_main_impl {
+                let method_defs = if with_method_defs.is_empty() {
+                    quote!(#impl_ty::__OWN_METHOD_DEFS)
+                } else {
+                    quote!(
+                        rustpython_vm::function::PyMethodDef::__const_concat_arrays::<
+                            { #impl_ty::__OWN_METHOD_DEFS.len() #(+ #with_method_defs.len())* },
+                        >(&[#impl_ty::__OWN_METHOD_DEFS, #(#with_method_defs,)*])
+                    )
+                };
+                quote! {
+                    #imp
+                    impl ::rustpython_vm::class::PyClassImpl for #payload_ty {
+                        const TP_FLAGS: ::rustpython_vm::types::PyTypeFlags = #flags;
+
+                        fn impl_extend_class(
+                            ctx: &::rustpython_vm::Context,
+                            class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
+                        ) {
+                            #impl_ty::__extend_py_class(ctx, class);
+                            #with_impl
+                        }
+
+                        const METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_defs;
+
+                        fn extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
+                            #with_slots
+                            #impl_ty::__extend_slots(slots);
+                        }
+                    }
+                }
+            } else {
+                imp.into_token_stream()
+            }
+        }
+        Item::Trait(mut trai) => {
+            let mut context = ImplContext {
+                is_trait: true,
+                ..Default::default()
+            };
+            let mut has_extend_slots = false;
+            for item in &trai.items {
+                let has = match item {
+                    syn::TraitItem::Fn(item) => item.sig.ident == "extend_slots",
+                    _ => false,
+                };
+                if has {
+                    has_extend_slots = has;
+                    break;
+                }
+            }
+            extract_items_into_context(&mut context, trai.items.iter_mut());
+
+            let ExtractedImplAttrs {
+                with_impl,
+                with_slots,
+                ..
+            } = extract_impl_attrs(attr, &trai.ident)?;
+
+            let method_def = &context.method_items;
+            let getset_impl = &context.getset_items;
+            let member_impl = &context.member_items;
+            let extend_impl = &context.attribute_items.validate()?;
+            let slots_impl = &context.extend_slots_items.validate()?;
+            let class_extensions = &context.class_extensions;
+            let call_extend_slots = if has_extend_slots {
+                quote! {
+                    Self::extend_slots(slots);
+                }
+            } else {
+                quote! {}
+            };
+            let extra_methods = [
+                parse_quote! {
+                    const __OWN_METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_def;
+                },
+                parse_quote! {
+                    fn __extend_py_class(
+                        ctx: &::rustpython_vm::Context,
+                        class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
+                    ) {
+                        #getset_impl
+                        #member_impl
+                        #extend_impl
+                        #with_impl
+                        #(#class_extensions)*
+                    }
+                },
+                parse_quote! {
+                    fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
+                        #with_slots
+                        #slots_impl
+                        #call_extend_slots
+                    }
+                },
+            ];
+            trai.items.extend(extra_methods);
+
+            trai.into_token_stream()
+        }
+        item => item.into_token_stream(),
+    };
+    if let Some(error) = context.errors.into_error() {
+        let error = Diagnostic::from(error);
+        tokens = quote! {
+            #tokens
+            #error
+        }
+    }
+    Ok(tokens)
+}
+
+/// Validates that when a base class is specified, the struct has the base type as its first field.
+/// This ensures proper memory layout for subclassing (required for #[repr(transparent)] to work correctly).
+fn validate_base_field(item: &Item, base_path: &syn::Path) -> Result<()> {
+    let Item::Struct(item_struct) = item else {
+        // Only validate structs - enums with base are already an error elsewhere
+        return Ok(());
+    };
+
+    // Get the base type name for error messages
+    let base_name = base_path
+        .segments
+        .last()
+        .map(|s| s.ident.to_string())
+        .unwrap_or_else(|| quote!(#base_path).to_string());
+
+    match &item_struct.fields {
+        syn::Fields::Named(fields) => {
+            let Some(first_field) = fields.named.first() else {
+                bail_span!(
+                    item_struct,
+                    "#[pyclass] with base = {base_name} requires the first field to be of type {base_name}, but the struct has no fields"
+                );
+            };
+            if !type_matches_path(&first_field.ty, base_path) {
+                bail_span!(
+                    first_field,
+                    "#[pyclass] with base = {base_name} requires the first field to be of type {base_name}"
+                );
+            }
+        }
+        syn::Fields::Unnamed(fields) => {
+            let Some(first_field) = fields.unnamed.first() else {
+                bail_span!(
+                    item_struct,
+                    "#[pyclass] with base = {base_name} requires the first field to be of type {base_name}, but the struct has no fields"
+                );
+            };
+            if !type_matches_path(&first_field.ty, base_path) {
+                bail_span!(
+                    first_field,
+                    "#[pyclass] with base = {base_name} requires the first field to be of type {base_name}"
+                );
+            }
+        }
+        syn::Fields::Unit => {
+            bail_span!(
+                item_struct,
+                "#[pyclass] with base = {base_name} requires the first field to be of type {base_name}, but the struct is a unit struct"
+            );
+        }
+    }
+
+    Ok(())
+}
+
+/// Check if a type matches a given path (handles simple cases like `Foo` or `path::to::Foo`)
+fn type_matches_path(ty: &syn::Type, path: &syn::Path) -> bool {
+    // Compare by converting both to string representation for macro hygiene
+    let ty_str = quote!(#ty).to_string().replace(' ', "");
+    let path_str = quote!(#path).to_string().replace(' ', "");
+
+    // Check if both are the same or if the type ends with the path's last segment
+    if ty_str == path_str {
+        return true;
+    }
+
+    // Also match if just the last segment matches (e.g., foo::Bar matches Bar)
+    let syn::Type::Path(type_path) = ty else {
+        return false;
+    };
+    let Some(type_last) = type_path.path.segments.last() else {
+        return false;
+    };
+    let Some(path_last) = path.segments.last() else {
+        return false;
+    };
+    type_last.ident == path_last.ident
+}
+
+fn generate_class_def(
+    ident: &Ident,
+    name: &str,
+    module_name: Option<&str>,
+    base: Option<syn::Path>,
+    metaclass: Option<String>,
+    unhashable: bool,
+    attrs: &[Attribute],
+) -> Result<TokenStream> {
+    let doc = attrs.doc().or_else(|| {
+        let module_name = module_name.unwrap_or("builtins");
+        DB.get(&format!("{module_name}.{name}"))
+            .copied()
+            .map(str::to_owned)
+    });
+    let doc = if let Some(doc) = doc {
+        quote!(Some(#doc))
+    } else {
+        quote!(None)
+    };
+    let module_class_name = if let Some(module_name) = module_name {
+        format!("{module_name}.{name}")
+    } else {
+        name.to_owned()
+    };
+    let module_name = match module_name {
+        Some(v) => quote!(Some(#v) ),
+        None => quote!(None),
+    };
+    let unhashable = if unhashable {
+        quote!(true)
+    } else {
+        quote!(false)
+    };
+    let is_pystruct = attrs.iter().any(|attr| {
+        attr.path().is_ident("derive")
+            && if let Ok(Meta::List(l)) = attr.parse_meta() {
+                l.nested
+                    .into_iter()
+                    .any(|n| n.get_ident().is_some_and(|p| p == "PyStructSequence"))
+            } else {
+                false
+            }
+    });
+    // Check if the type has #[repr(transparent)] - only then we can safely
+    // generate PySubclass impl (requires same memory layout as base type)
+    let is_repr_transparent = attrs.iter().any(|attr| {
+        attr.path().is_ident("repr")
+            && if let Ok(Meta::List(l)) = attr.parse_meta() {
+                l.nested
+                    .into_iter()
+                    .any(|n| n.get_ident().is_some_and(|p| p == "transparent"))
+            } else {
+                false
+            }
+    });
+    // If repr(transparent) with a base, the type has the same memory layout as base,
+    // so basicsize should be 0 (no additional space beyond the base type)
+    // Otherwise, basicsize = sizeof(payload). The header size is added in __basicsize__ getter.
+    let basicsize = if is_repr_transparent && base.is_some() {
+        quote!(0)
+    } else {
+        quote!(std::mem::size_of::<#ident>())
+    };
+    if base.is_some() && is_pystruct {
+        bail_span!(ident, "PyStructSequence cannot have `base` class attr",);
+    }
+    let base_class = if is_pystruct {
+        Some(quote! { rustpython_vm::builtins::PyTuple })
+    } else {
+        base.as_ref().map(|typ| {
+            quote_spanned! { ident.span() => #typ }
+        })
+    }
+    .map(|typ| {
+        quote! {
+            fn static_baseclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                use rustpython_vm::class::StaticType;
+                #typ::static_type()
+            }
+        }
+    });
+
+    let meta_class = metaclass.map(|typ| {
+        let typ = Ident::new(&typ, ident.span());
+        quote! {
+            fn static_metaclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                use rustpython_vm::class::StaticType;
+                #typ::static_type()
+            }
+        }
+    });
+
+    let base_or_object = if let Some(ref base) = base {
+        quote! { #base }
+    } else {
+        quote! { ::rustpython_vm::builtins::PyBaseObject }
+    };
+
+    // Generate PySubclass impl for #[repr(transparent)] types with base class
+    // (tuple struct assumed, so &self.0 works)
+    let subclass_impl = if !is_pystruct && is_repr_transparent {
+        base.as_ref().map(|typ| {
+            quote! {
+                impl ::rustpython_vm::class::PySubclass for #ident {
+                    type Base = #typ;
+
+                    #[inline]
+                    fn as_base(&self) -> &Self::Base {
+                        &self.0
+                    }
+                }
+            }
+        })
+    } else {
+        None
+    };
+
+    let tokens = quote! {
+        impl ::rustpython_vm::class::PyClassDef for #ident {
+            const NAME: &'static str = #name;
+            const MODULE_NAME: Option<&'static str> = #module_name;
+            const TP_NAME: &'static str = #module_class_name;
+            const DOC: Option<&'static str> = #doc;
+            const BASICSIZE: usize = #basicsize;
+            const UNHASHABLE: bool = #unhashable;
+
+            type Base = #base_or_object;
+        }
+
+        impl ::rustpython_vm::class::StaticType for #ident {
+            fn static_cell() -> &'static ::rustpython_vm::common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> {
+                ::rustpython_vm::common::static_cell! {
+                    static CELL: ::rustpython_vm::builtins::PyTypeRef;
+                }
+                &CELL
+            }
+
+            #meta_class
+
+            #base_class
+        }
+
+        #subclass_impl
+    };
+    Ok(tokens)
+}
+
+pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+    if matches!(item, syn::Item::Use(_)) {
+        return Ok(quote!(#item));
+    }
+    let (ident, attrs) = pyclass_ident_and_attrs(&item)?;
+    let fake_ident = Ident::new("pyclass", item.span());
+    let class_meta = ClassItemMeta::from_nested(ident.clone(), fake_ident, attr.into_iter())?;
+    let class_name = class_meta.class_name()?;
+    let module_name = class_meta.module()?;
+    let base = class_meta.base()?;
+    let metaclass = class_meta.metaclass()?;
+    let unhashable = class_meta.unhashable()?;
+
+    // Validate that if base is specified, the first field must be of the base type
+    if let Some(ref base_path) = base {
+        validate_base_field(&item, base_path)?;
+    }
+
+    let class_def = generate_class_def(
+        ident,
+        &class_name,
+        module_name.as_deref(),
+        base.clone(),
+        metaclass,
+        unhashable,
+        attrs,
+    )?;
+
+    const ALLOWED_TRAVERSE_OPTS: &[&str] = &["manual"];
+    // try to know if it have a `#[pyclass(trace)]` exist on this struct
+    // TODO(discord9): rethink on auto detect `#[Derive(PyTrace)]`
+
+    // 1. no `traverse` at all: generate a dummy try_traverse
+    // 2. `traverse = "manual"`: generate a try_traverse, but not #[derive(Traverse)]
+    // 3. `traverse`: generate a try_traverse, and #[derive(Traverse)]
+    let (maybe_trace_code, derive_trace) = {
+        if class_meta.inner()._has_key("traverse")? {
+            let maybe_trace_code = quote! {
+                impl ::rustpython_vm::object::MaybeTraverse for #ident {
+                    const IS_TRACE: bool = true;
+                    fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
+                        ::rustpython_vm::object::Traverse::traverse(self, tracer_fn);
+                    }
+                }
+            };
+            // if the key `traverse` exist but not as key-value, _optional_str return Err(...)
+            // so we need to check if it is Ok(Some(...))
+            let value = class_meta.inner()._optional_str("traverse");
+            let derive_trace = if let Ok(Some(s)) = value {
+                if !ALLOWED_TRAVERSE_OPTS.contains(&s.as_str()) {
+                    bail_span!(
+                        item,
+                        "traverse attribute only accept {ALLOWED_TRAVERSE_OPTS:?} as value or no value at all",
+                    );
+                }
+                assert_eq!(s, "manual");
+                quote! {}
+            } else {
+                quote! {#[derive(Traverse)]}
+            };
+            (maybe_trace_code, derive_trace)
+        } else {
+            (
+                // a dummy impl, which do nothing
+                // #attrs
+                quote! {
+                    impl ::rustpython_vm::object::MaybeTraverse for #ident {
+                        fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
+                            // do nothing
+                        }
+                    }
+                },
+                quote! {},
+            )
+        }
+    };
+
+    // Generate PyPayload impl based on whether base exists
+    #[allow(clippy::collapsible_else_if)]
+    let impl_payload = if let Some(base_type) = &base {
+        let class_fn = if let Some(ctx_type_name) = class_meta.ctx_name()? {
+            let ctx_type_ident = Ident::new(&ctx_type_name, ident.span());
+            quote! { ctx.types.#ctx_type_ident }
+        } else {
+            quote! { <Self as ::rustpython_vm::class::StaticType>::static_type() }
+        };
+
+        quote! {
+            // static_assertions::const_assert!(std::mem::size_of::<#base_type>() <= std::mem::size_of::<#ident>());
+            impl ::rustpython_vm::PyPayload for #ident {
+                const PAYLOAD_TYPE_ID: ::core::any::TypeId = <#base_type as ::rustpython_vm::PyPayload>::PAYLOAD_TYPE_ID;
+
+                #[inline]
+                fn validate_downcastable_from(obj: &::rustpython_vm::PyObject) -> bool {
+                    <Self as ::rustpython_vm::class::PyClassDef>::BASICSIZE <= obj.class().slots.basicsize && obj.class().fast_issubclass(<Self as ::rustpython_vm::class::StaticType>::static_type())
+                }
+
+                fn class(ctx: &::rustpython_vm::vm::Context) -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                    #class_fn
+                }
+            }
+        }
+    } else {
+        if let Some(ctx_type_name) = class_meta.ctx_name()? {
+            let ctx_type_ident = Ident::new(&ctx_type_name, ident.span());
+            quote! {
+                impl ::rustpython_vm::PyPayload for #ident {
+                    fn class(ctx: &::rustpython_vm::vm::Context) -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                        ctx.types.#ctx_type_ident
+                    }
+                }
+            }
+        } else {
+            quote! {}
+        }
+    };
+
+    let empty_impl = if let Some(attrs) = class_meta.impl_attrs()? {
+        let attrs: Meta = parse_quote! (#attrs);
+        quote! {
+            #[pyclass(#attrs)]
+            impl #ident {}
+        }
+    } else {
+        quote! {}
+    };
+
+    let ret = quote! {
+        #derive_trace
+        #item
+        #maybe_trace_code
+        #class_def
+        #impl_payload
+        #empty_impl
+    };
+    Ok(ret)
+}
+
+/// Special macro to create exception types.
+///
+/// Why do we need it and why can't we just use `pyclass` macro instead?
+/// We generate exception types with a `macro_rules`,
+/// similar to how CPython does it.
+/// But, inside `macro_rules` we don't have an opportunity
+/// to add non-literal attributes to `pyclass`.
+/// That's why we have to use this proxy.
+pub(crate) fn impl_pyexception(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+    let (ident, _attrs) = pyexception_ident_and_attrs(&item)?;
+    let fake_ident = Ident::new("pyclass", item.span());
+    let class_meta = ExceptionItemMeta::from_nested(ident.clone(), fake_ident, attr.into_iter())?;
+    let class_name = class_meta.class_name()?;
+
+    let base_class_name = class_meta.base()?;
+    let impl_pyclass = if class_meta.has_impl()? {
+        quote! {
+            #[pyexception]
+            impl #ident {}
+        }
+    } else {
+        quote! {}
+    };
+
+    let ret = quote! {
+        #[pyclass(module = false, name = #class_name, base = #base_class_name)]
+        #item
+        #impl_pyclass
+    };
+    Ok(ret)
+}
+
+pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
+    let Item::Impl(imp) = item else {
+        return Ok(item.into_token_stream());
+    };
+
+    // Check if with(Constructor) is specified. If Constructor trait is used, don't generate slot_new
+    let mut extra_attrs = Vec::new();
+    let mut with_items = vec![];
+    for nested in &attr {
+        if let NestedMeta::Meta(Meta::List(MetaList { path, nested, .. })) = nested {
+            // If we already found the constructor trait, no need to keep looking for it
+            if path.is_ident("with") {
+                for meta in nested {
+                    with_items.push(meta.get_ident().expect("with() has non-ident item").clone());
+                }
+                continue;
+            }
+            extra_attrs.push(NestedMeta::Meta(Meta::List(MetaList {
+                path: path.clone(),
+                paren_token: Default::default(),
+                nested: nested.clone(),
+            })));
+        }
+    }
+
+    let with_contains = |with_items: &[Ident], s: &str| {
+        // Check if Constructor is in the list
+        with_items.iter().any(|ident| ident == s)
+    };
+
+    let syn::ItemImpl {
+        generics,
+        self_ty,
+        items,
+        ..
+    } = &imp;
+
+    let slot_new = if with_contains(&with_items, "Constructor") {
+        quote!()
+    } else {
+        with_items.push(Ident::new("Constructor", Span::call_site()));
+        quote! {
+            impl ::rustpython_vm::types::Constructor for #self_ty {
+                type Args = ::rustpython_vm::function::FuncArgs;
+
+                fn slot_new(
+                    cls: ::rustpython_vm::builtins::PyTypeRef,
+                    args: ::rustpython_vm::function::FuncArgs,
+                    vm: &::rustpython_vm::VirtualMachine,
+                ) -> ::rustpython_vm::PyResult {
+                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_new(cls, args, vm)
+                }
+                fn py_new(
+                    _cls: &::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
+                    _args: Self::Args,
+                    _vm: &::rustpython_vm::VirtualMachine
+                ) -> ::rustpython_vm::PyResult<Self> {
+                    unreachable!("slot_new is defined")
+                }
+            }
+        }
+    };
+
+    // We need this method, because of how `CPython` copies `__init__`
+    // from `BaseException` in `SimpleExtendsException` macro.
+    // See: `(initproc)BaseException_init`
+    // spell-checker:ignore initproc
+    let slot_init = if with_contains(&with_items, "Initializer") {
+        quote!()
+    } else {
+        with_items.push(Ident::new("Initializer", Span::call_site()));
+        quote! {
+            impl ::rustpython_vm::types::Initializer for #self_ty {
+                type Args = ::rustpython_vm::function::FuncArgs;
+
+                fn slot_init(
+                    zelf: ::rustpython_vm::PyObjectRef,
+                    args: ::rustpython_vm::function::FuncArgs,
+                    vm: &::rustpython_vm::VirtualMachine,
+                ) -> ::rustpython_vm::PyResult<()> {
+                    <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
+                }
+
+                fn init(
+                    _zelf: ::rustpython_vm::PyRef<Self>,
+                    _args: Self::Args,
+                    _vm: &::rustpython_vm::VirtualMachine
+                ) -> ::rustpython_vm::PyResult<()> {
+                    unreachable!("slot_init is defined")
+                }
+            }
+        }
+    };
+
+    let extra_attrs_tokens = if extra_attrs.is_empty() {
+        quote!()
+    } else {
+        quote!(, #(#extra_attrs),*)
+    };
+
+    Ok(quote! {
+        #[pyclass(flags(BASETYPE, HAS_DICT), with(#(#with_items),*) #extra_attrs_tokens)]
+        impl #generics #self_ty {
+            #(#items)*
+        }
+
+        #slot_new
+        #slot_init
+    })
+}
+
+macro_rules! define_content_item {
+    (
+        $(#[$meta:meta])*
+        $vis:vis struct $name:ident
+    ) => {
+        $(#[$meta])*
+        $vis struct $name {
+            inner: ContentItemInner<AttrName>,
+        }
+
+        impl ContentItem for $name {
+            type AttrName = AttrName;
+
+            fn inner(&self) -> &ContentItemInner<AttrName> {
+                &self.inner
+            }
+        }
+    };
+}
+
+define_content_item!(
+    /// #[pymethod] and #[pyclassmethod]
+    struct MethodItem
+);
+
+define_content_item!(
+    /// #[pygetset]
+    struct GetSetItem
+);
+
+define_content_item!(
+    /// #[pyslot]
+    struct SlotItem
+);
+
+define_content_item!(
+    /// #[pyattr]
+    struct AttributeItem
+);
+
+define_content_item!(
+    /// #[extend_class]
+    struct ExtendClassItem
+);
+
+define_content_item!(
+    /// #[pymember]
+    struct MemberItem
+);
+
+struct ImplItemArgs<'a, Item: ItemLike> {
+    item: &'a Item,
+    attrs: &'a mut Vec<Attribute>,
+    context: &'a mut ImplContext,
+    cfgs: &'a [Attribute],
+}
+
+trait ImplItem<Item>: ContentItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()>;
+}
+
+impl<Item> ImplItem<Item> for MethodItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let func = args
+            .item
+            .function_or_method()
+            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
+        let ident = &func.sig().ident;
+
+        let item_attr = args.attrs.remove(self.index());
+        let item_meta = MethodItemMeta::from_attr(ident.clone(), &item_attr)?;
+
+        let py_name = item_meta.method_name()?;
+
+        // Disallow slot methods - they should be defined via trait implementations
+        // These are exposed as wrapper_descriptor via add_operators from SLOT_DEFS
+        if !args.context.is_trait {
+            const FORBIDDEN_SLOT_METHODS: &[(&str, &str)] = &[
+                // Constructor/Initializer traits
+                ("__new__", "Constructor"),
+                ("__init__", "Initializer"),
+                // Representable trait
+                // ("__repr__", "Representable"),
+                // ("__str__", "???"), // allow __str__
+                // Hashable trait
+                ("__hash__", "Hashable"),
+                // Callable trait
+                ("__call__", "Callable"),
+                // GetAttr/SetAttr traits
+                // NOTE: __getattribute__, __setattr__, __delattr__ are intentionally NOT forbidden
+                // because they need pymethod for subclass override mechanism to work properly.
+                // GetDescriptor/SetDescriptor traits
+                // ("__get__", "GetDescriptor"),
+                // ("__set__", "SetDescriptor"),
+                // ("__delete__", "SetDescriptor"),
+                // AsNumber trait
+                ("__add__", "AsNumber"),
+                ("__radd__", "AsNumber"),
+                ("__iadd__", "AsNumber"),
+                ("__sub__", "AsNumber"),
+                ("__rsub__", "AsNumber"),
+                ("__isub__", "AsNumber"),
+                ("__mul__", "AsNumber"),
+                ("__rmul__", "AsNumber"),
+                ("__imul__", "AsNumber"),
+                ("__truediv__", "AsNumber"),
+                ("__rtruediv__", "AsNumber"),
+                ("__itruediv__", "AsNumber"),
+                ("__floordiv__", "AsNumber"),
+                ("__rfloordiv__", "AsNumber"),
+                ("__ifloordiv__", "AsNumber"),
+                ("__mod__", "AsNumber"),
+                ("__rmod__", "AsNumber"),
+                ("__imod__", "AsNumber"),
+                ("__pow__", "AsNumber"),
+                ("__rpow__", "AsNumber"),
+                ("__ipow__", "AsNumber"),
+                ("__divmod__", "AsNumber"),
+                ("__rdivmod__", "AsNumber"),
+                ("__matmul__", "AsNumber"),
+                ("__rmatmul__", "AsNumber"),
+                ("__imatmul__", "AsNumber"),
+                ("__lshift__", "AsNumber"),
+                ("__rlshift__", "AsNumber"),
+                ("__ilshift__", "AsNumber"),
+                ("__rshift__", "AsNumber"),
+                ("__rrshift__", "AsNumber"),
+                ("__irshift__", "AsNumber"),
+                ("__and__", "AsNumber"),
+                ("__rand__", "AsNumber"),
+                ("__iand__", "AsNumber"),
+                ("__or__", "AsNumber"),
+                ("__ror__", "AsNumber"),
+                ("__ior__", "AsNumber"),
+                ("__xor__", "AsNumber"),
+                ("__rxor__", "AsNumber"),
+                ("__ixor__", "AsNumber"),
+                ("__neg__", "AsNumber"),
+                ("__pos__", "AsNumber"),
+                ("__abs__", "AsNumber"),
+                ("__invert__", "AsNumber"),
+                ("__int__", "AsNumber"),
+                ("__float__", "AsNumber"),
+                ("__index__", "AsNumber"),
+                ("__bool__", "AsNumber"),
+                // AsSequence trait
+                // ("__len__", "AsSequence (or AsMapping)"),
+                // ("__contains__", "AsSequence"),
+                // AsMapping trait
+                // ("__getitem__", "AsMapping (or AsSequence)"),
+                // ("__setitem__", "AsMapping (or AsSequence)"),
+                // ("__delitem__", "AsMapping (or AsSequence)"),
+                // IterNext trait
+                // ("__iter__", "IterNext"),
+                // ("__next__", "IterNext"),
+                // Comparable trait
+                ("__eq__", "Comparable"),
+                ("__ne__", "Comparable"),
+                ("__lt__", "Comparable"),
+                ("__le__", "Comparable"),
+                ("__gt__", "Comparable"),
+                ("__ge__", "Comparable"),
+            ];
+
+            if let Some((_, trait_name)) = FORBIDDEN_SLOT_METHODS
+                .iter()
+                .find(|(method, _)| *method == py_name.as_str())
+            {
+                return Err(syn::Error::new(
+                    ident.span(),
+                    format!(
+                        "#[pymethod] cannot define '{py_name}'. Use `impl {trait_name} for ...` instead. \
+                         Slot methods are exposed as wrapper_descriptor automatically.",
+                    ),
+                ));
+            }
+        }
+
+        let raw = item_meta.raw()?;
+        let sig_doc = text_signature(func.sig(), &py_name);
+
+        // Add #[allow(non_snake_case)] for setter methods like set___name__
+        let method_name = ident.to_string();
+        if method_name.starts_with("set_") && method_name.contains("__") {
+            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
+            args.attrs.push(allow_attr);
+        }
+
+        let doc = args.attrs.doc().map(|doc| format_doc(&sig_doc, &doc));
+        args.context.method_items.add_item(MethodNurseryItem {
+            py_name,
+            cfgs: args.cfgs.to_vec(),
+            ident: ident.to_owned(),
+            doc,
+            raw,
+            attr_name: self.inner.attr_name,
+        });
+        Ok(())
+    }
+}
+
+impl<Item> ImplItem<Item> for GetSetItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let func = args
+            .item
+            .function_or_method()
+            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
+        let ident = &func.sig().ident;
+
+        let item_attr = args.attrs.remove(self.index());
+        let item_meta = GetSetItemMeta::from_attr(ident.clone(), &item_attr)?;
+
+        let (py_name, kind) = item_meta.getset_name()?;
+
+        // Add #[allow(non_snake_case)] for setter methods
+        if matches!(kind, GetSetItemKind::Set) {
+            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
+            args.attrs.push(allow_attr);
+        }
+
+        args.context
+            .getset_items
+            .add_item(py_name, args.cfgs.to_vec(), kind, ident.clone())?;
+        Ok(())
+    }
+}
+
+impl<Item> ImplItem<Item> for SlotItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let (ident, span) = if let Ok(c) = args.item.constant() {
+            (c.ident(), c.span())
+        } else if let Ok(f) = args.item.function_or_method() {
+            (&f.sig().ident, f.span())
+        } else {
+            return Err(self.new_syn_error(
+                args.item.span(),
+                "can only be on a method or const function pointer",
+            ));
+        };
+
+        let item_attr = args.attrs.remove(self.index());
+        let item_meta = SlotItemMeta::from_attr(ident.clone(), &item_attr)?;
+
+        let slot_ident = item_meta.slot_name()?;
+        let slot_ident = Ident::new(&slot_ident.to_string().to_lowercase(), slot_ident.span());
+        let slot_name = slot_ident.to_string();
+        let tokens = {
+            const NON_ATOMIC_SLOTS: &[&str] = &["as_buffer"];
+            const POINTER_SLOTS: &[&str] = &["as_sequence", "as_mapping"];
+            const STATIC_GEN_SLOTS: &[&str] = &["as_number"];
+
+            if NON_ATOMIC_SLOTS.contains(&slot_name.as_str()) {
+                quote_spanned! { span =>
+                    slots.#slot_ident = Some(Self::#ident as _);
+                }
+            } else if POINTER_SLOTS.contains(&slot_name.as_str()) {
+                quote_spanned! { span =>
+                    slots.#slot_ident.store(Some(PointerSlot::from(Self::#ident())));
+                }
+            } else if STATIC_GEN_SLOTS.contains(&slot_name.as_str()) {
+                quote_spanned! { span =>
+                    slots.#slot_ident = Self::#ident().into();
+                }
+            } else {
+                quote_spanned! { span =>
+                    slots.#slot_ident.store(Some(Self::#ident as _));
+                }
+            }
+        };
+
+        let pyname = format!("(slot {slot_name})");
+        args.context.extend_slots_items.add_item(
+            ident.clone(),
+            vec![pyname],
+            args.cfgs.to_vec(),
+            tokens,
+            2,
+        )?;
+
+        Ok(())
+    }
+}
+
+impl<Item> ImplItem<Item> for AttributeItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let cfgs = args.cfgs.to_vec();
+        let attr = args.attrs.remove(self.index());
+
+        let get_py_name = |attr: &Attribute, ident: &Ident| -> Result<_> {
+            let item_meta = SimpleItemMeta::from_attr(ident.clone(), attr)?;
+            let py_name = item_meta.simple_name()?;
+            Ok(py_name)
+        };
+        let (ident, py_name, tokens) =
+            if args.item.function_or_method().is_ok() || args.item.constant().is_ok() {
+                let ident = args.item.get_ident().unwrap();
+                let py_name = get_py_name(&attr, ident)?;
+
+                let value = if args.item.constant().is_ok() {
+                    // TODO: ctx.new_value
+                    quote_spanned!(ident.span() => ctx.new_int(Self::#ident).into())
+                } else {
+                    quote_spanned!(ident.span() => Self::#ident(ctx))
+                };
+                (
+                    ident,
+                    py_name.clone(),
+                    quote! {
+                        class.set_str_attr(#py_name, #value, ctx);
+                    },
+                )
+            } else {
+                return Err(self.new_syn_error(
+                    args.item.span(),
+                    "can only be on a const or an associated method without argument",
+                ));
+            };
+
+        args.context
+            .attribute_items
+            .add_item(ident.clone(), vec![py_name], cfgs, tokens, 1)?;
+
+        Ok(())
+    }
+}
+
+impl<Item> ImplItem<Item> for ExtendClassItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        args.attrs.remove(self.index());
+
+        let ident = &args
+            .item
+            .function_or_method()
+            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?
+            .sig()
+            .ident;
+
+        args.context.class_extensions.push(quote! {
+            Self::#ident(ctx, class);
+        });
+
+        Ok(())
+    }
+}
+
+impl<Item> ImplItem<Item> for MemberItem
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
+        let func = args
+            .item
+            .function_or_method()
+            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
+        let ident = &func.sig().ident;
+
+        let item_attr = args.attrs.remove(self.index());
+        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,
+        };
+
+        // Add #[allow(non_snake_case)] for setter methods
+        if matches!(member_item_kind, MemberItemKind::Set) {
+            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
+            args.attrs.push(allow_attr);
+        }
+
+        args.context.member_items.add_item(
+            py_name,
+            member_item_kind,
+            member_kind,
+            ident.clone(),
+        )?;
+        Ok(())
+    }
+}
+
+#[derive(Default)]
+struct MethodNursery {
+    items: Vec<MethodNurseryItem>,
+}
+
+struct MethodNurseryItem {
+    py_name: String,
+    cfgs: Vec<Attribute>,
+    ident: Ident,
+    raw: bool,
+    doc: Option<String>,
+    attr_name: AttrName,
+}
+
+impl MethodNursery {
+    fn add_item(&mut self, item: MethodNurseryItem) {
+        self.items.push(item);
+    }
+
+    fn validate(&mut self) -> Result<()> {
+        let mut name_set = HashSet::new();
+        for item in &self.items {
+            if !name_set.insert((&item.py_name, &item.cfgs)) {
+                bail_span!(item.ident, "duplicate method name `{}`", item.py_name);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ToTokens for MethodNursery {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let mut inner_tokens = TokenStream::new();
+        for item in &self.items {
+            let py_name = &item.py_name;
+            let ident = &item.ident;
+            let cfgs = &item.cfgs;
+            let doc = if let Some(doc) = item.doc.as_ref() {
+                quote! { Some(#doc) }
+            } else {
+                quote! { None }
+            };
+            let flags = match &item.attr_name {
+                AttrName::Method => {
+                    quote! { rustpython_vm::function::PyMethodFlags::METHOD }
+                }
+                AttrName::ClassMethod => {
+                    quote! { rustpython_vm::function::PyMethodFlags::CLASS }
+                }
+                AttrName::StaticMethod => {
+                    quote! { rustpython_vm::function::PyMethodFlags::STATIC }
+                }
+                _ => unreachable!(),
+            };
+            // TODO: intern
+            // let py_name = if py_name.starts_with("__") && py_name.ends_with("__") {
+            //     let name_ident = Ident::new(&py_name, ident.span());
+            //     quote_spanned! { ident.span() => ctx.names.#name_ident }
+            // } else {
+            //     quote_spanned! { ident.span() => #py_name }
+            // };
+            let method_new = if item.raw {
+                quote!(new_raw_const)
+            } else {
+                quote!(new_const)
+            };
+            inner_tokens.extend(quote! [
+                #(#cfgs)*
+                rustpython_vm::function::PyMethodDef::#method_new(
+                    #py_name,
+                    Self::#ident,
+                    #flags,
+                    #doc,
+                ),
+            ]);
+        }
+        let array: TokenTree = Group::new(Delimiter::Bracket, inner_tokens).into();
+        tokens.extend([array]);
+    }
+}
+
+#[derive(Default)]
+#[allow(clippy::type_complexity)]
+struct GetSetNursery {
+    map: HashMap<(String, Vec<Attribute>), (Option<Ident>, Option<Ident>)>,
+    validated: bool,
+}
+
+enum GetSetItemKind {
+    Get,
+    Set,
+}
+
+impl GetSetNursery {
+    fn add_item(
+        &mut self,
+        name: String,
+        cfgs: Vec<Attribute>,
+        kind: GetSetItemKind,
+        item_ident: Ident,
+    ) -> Result<()> {
+        assert!(!self.validated, "new item is not allowed after validation");
+        // Note: Both getter and setter can have #[cfg], but they must have matching cfgs
+        // since the map key is (name, cfgs). This ensures getter and setter are paired correctly.
+        let entry = self.map.entry((name.clone(), cfgs)).or_default();
+        let func = match kind {
+            GetSetItemKind::Get => &mut entry.0,
+            GetSetItemKind::Set => &mut entry.1,
+        };
+        if func.is_some() {
+            bail_span!(
+                item_ident,
+                "Multiple property accessors with name '{}'",
+                name
+            );
+        }
+        *func = Some(item_ident);
+        Ok(())
+    }
+
+    fn validate(&mut self) -> Result<()> {
+        let mut errors = Vec::new();
+        for ((name, _cfgs), (getter, setter)) in &self.map {
+            if getter.is_none() {
+                errors.push(err_span!(
+                    setter.as_ref().unwrap(),
+                    "GetSet '{}' is missing a getter",
+                    name
+                ));
+            };
+        }
+        errors.into_result()?;
+        self.validated = true;
+        Ok(())
+    }
+}
+
+impl ToTokens for GetSetNursery {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        assert!(self.validated, "Call `validate()` before token generation");
+        let properties = self.map.iter().map(|((name, cfgs), (getter, setter))| {
+            let setter = match setter {
+                Some(setter) => quote_spanned! { setter.span() => .with_set(Self::#setter)},
+                None => quote! {},
+            };
+            quote_spanned! { getter.span() =>
+                #( #cfgs )*
+                class.set_str_attr(
+                    #name,
+                    ::rustpython_vm::PyRef::new_ref(
+                        ::rustpython_vm::builtins::PyGetSet::new(#name.into(), class)
+                            .with_get(Self::#getter)
+                            #setter,
+                            ctx.types.getset_type.to_owned(), None),
+                    ctx
+                );
+            }
+        });
+        tokens.extend(properties);
+    }
+}
+
+#[derive(Default)]
+#[allow(clippy::type_complexity)]
+struct MemberNursery {
+    map: HashMap<(String, MemberKind), (Option<Ident>, Option<Ident>)>,
+    validated: bool,
+}
+
+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,
+        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 func = match kind {
+            MemberItemKind::Get => &mut entry.0,
+            MemberItemKind::Set => &mut entry.1,
+        };
+        if func.is_some() {
+            bail_span!(item_ident, "Multiple member accessors with name '{}'", name);
+        }
+        *func = Some(item_ident);
+        Ok(())
+    }
+
+    fn validate(&mut self) -> Result<()> {
+        let mut errors = Vec::new();
+        for ((name, _), (getter, setter)) in &self.map {
+            if getter.is_none() {
+                errors.push(err_span!(
+                    setter.as_ref().unwrap(),
+                    "Member '{}' is missing a getter",
+                    name
+                ));
+            };
+        }
+        errors.into_result()?;
+        self.validated = true;
+        Ok(())
+    }
+}
+
+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,
+                    );
+                }
+            });
+        tokens.extend(properties);
+    }
+}
+
+struct MethodItemMeta(ItemMetaInner);
+
+impl ItemMeta for MethodItemMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "raw"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self(inner)
+    }
+
+    fn inner(&self) -> &ItemMetaInner {
+        &self.0
+    }
+}
+
+impl MethodItemMeta {
+    fn raw(&self) -> Result<bool> {
+        self.inner()._bool("raw")
+    }
+
+    fn method_name(&self) -> Result<String> {
+        let inner = self.inner();
+        let name = inner._optional_str("name")?;
+        Ok(if let Some(name) = name {
+            name
+        } else {
+            inner.item_name()
+        })
+    }
+}
+
+struct GetSetItemMeta(ItemMetaInner);
+
+impl ItemMeta for GetSetItemMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "setter"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self(inner)
+    }
+
+    fn inner(&self) -> &ItemMetaInner {
+        &self.0
+    }
+}
+
+impl GetSetItemMeta {
+    fn getset_name(&self) -> Result<(String, GetSetItemKind)> {
+        let inner = self.inner();
+        let kind = if inner._bool("setter")? {
+            GetSetItemKind::Set
+        } else {
+            GetSetItemKind::Get
+        };
+        let name = inner._optional_str("name")?;
+        let py_name = if let Some(name) = name {
+            name
+        } else {
+            let sig_name = inner.item_name();
+            let extract_prefix_name = |prefix, item_typ| {
+                if let Some(name) = sig_name.strip_prefix(prefix) {
+                    if name.is_empty() {
+                        Err(err_span!(
+                            inner.meta_ident,
+                            r#"A #[{}({typ})] fn with a {prefix}* name must \
+                             have something after "{prefix}""#,
+                            inner.meta_name(),
+                            typ = item_typ,
+                            prefix = prefix
+                        ))
+                    } else {
+                        Ok(name.to_owned())
+                    }
+                } else {
+                    Err(err_span!(
+                        inner.meta_ident,
+                        r#"A #[{}(setter)] fn must either have a `name` \
+                         parameter or a fn name along the lines of "set_*""#,
+                        inner.meta_name()
+                    ))
+                }
+            };
+            match kind {
+                GetSetItemKind::Get => sig_name,
+                GetSetItemKind::Set => extract_prefix_name("set_", "setter")?,
+            }
+        };
+        Ok((py_name, kind))
+    }
+}
+
+struct SlotItemMeta(ItemMetaInner);
+
+impl ItemMeta for SlotItemMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &[]; // not used
+
+    fn from_nested<I>(item_ident: Ident, meta_ident: Ident, mut nested: I) -> Result<Self>
+    where
+        I: core::iter::Iterator<Item = NestedMeta>,
+    {
+        let meta_map = if let Some(nested_meta) = nested.next() {
+            match nested_meta {
+                NestedMeta::Meta(meta) => {
+                    Some([("name".to_owned(), (0, meta))].iter().cloned().collect())
+                }
+                _ => None,
+            }
+        } else {
+            Some(HashMap::default())
+        };
+        let (Some(meta_map), None) = (meta_map, nested.next()) else {
+            bail_span!(
+                meta_ident,
+                "#[pyslot] must be of the form #[pyslot] or #[pyslot(slot_name)]"
+            )
+        };
+        Ok(Self::from_inner(ItemMetaInner {
+            item_ident,
+            meta_ident,
+            meta_map,
+        }))
+    }
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self(inner)
+    }
+
+    fn inner(&self) -> &ItemMetaInner {
+        &self.0
+    }
+}
+
+impl SlotItemMeta {
+    fn slot_name(&self) -> Result<Ident> {
+        let inner = self.inner();
+        let method_name = if let Some((_, meta)) = inner.meta_map.get("name") {
+            match meta {
+                Meta::Path(path) => path.get_ident().cloned(),
+                _ => None,
+            }
+        } else {
+            let ident_str = self.inner().item_name();
+            // Convert to lowercase to handle both SLOT_NEW and slot_new
+            let ident_lower = ident_str.to_lowercase();
+            let name = if let Some(stripped) = ident_lower.strip_prefix("slot_") {
+                proc_macro2::Ident::new(stripped, inner.item_ident.span())
+            } else {
+                inner.item_ident.clone()
+            };
+            Some(name)
+        };
+        let method_name = method_name.ok_or_else(|| {
+            err_span!(
+                inner.meta_ident,
+                "#[pyslot] must be of the form #[pyslot] or #[pyslot(slot_name)]",
+            )
+        })?;
+
+        // Strip double underscores from slot names like __init__ -> init
+        let method_name_str = method_name.to_string();
+        let slot_name = if method_name_str.starts_with("__")
+            && method_name_str.ends_with("__")
+            && method_name_str.len() > 4
+        {
+            &method_name_str[2..method_name_str.len() - 2]
+        } else {
+            &method_name_str
+        };
+
+        Ok(proc_macro2::Ident::new(slot_name, slot_name.span()))
+    }
+}
+
+struct MemberItemMeta(ItemMetaInner);
+
+impl ItemMeta for MemberItemMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["type", "setter"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self(inner)
+    }
+
+    fn inner(&self) -> &ItemMetaInner {
+        &self.0
+    }
+}
+
+impl MemberItemMeta {
+    fn member_name(&self) -> Result<(String, MemberItemKind)> {
+        let inner = self.inner();
+        let sig_name = inner.item_name();
+        let extract_prefix_name = |prefix, item_typ| {
+            if let Some(name) = sig_name.strip_prefix(prefix) {
+                if name.is_empty() {
+                    Err(err_span!(
+                        inner.meta_ident,
+                        r#"A #[{}({typ})] fn with a {prefix}* name must \
+                         have something after "{prefix}""#,
+                        inner.meta_name(),
+                        typ = item_typ,
+                        prefix = prefix
+                    ))
+                } else {
+                    Ok(name.to_owned())
+                }
+            } else {
+                Err(err_span!(
+                    inner.meta_ident,
+                    r#"A #[{}(setter)] fn must either have a `name` \
+                     parameter or a fn name along the lines of "set_*""#,
+                    inner.meta_name()
+                ))
+            }
+        };
+        let kind = if inner._bool("setter")? {
+            MemberItemKind::Set
+        } else {
+            MemberItemKind::Get
+        };
+        let name = match kind {
+            MemberItemKind::Get => sig_name,
+            MemberItemKind::Set => extract_prefix_name("set_", "setter")?,
+        };
+        Ok((name, kind))
+    }
+
+    fn member_kind(&self) -> Result<Option<String>> {
+        let inner = self.inner();
+        inner._optional_str("type")
+    }
+}
+
+struct ExtractedImplAttrs {
+    payload: Option<Ident>,
+    flags: TokenStream,
+    with_impl: TokenStream,
+    with_method_defs: Vec<TokenStream>,
+    with_slots: TokenStream,
+    itemsize: Option<syn::Expr>,
+}
+
+fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<ExtractedImplAttrs> {
+    let mut withs = Vec::new();
+    let mut with_method_defs = Vec::new();
+    let mut with_slots = Vec::new();
+    let mut flags = vec![quote! {
+        {
+            #[cfg(not(debug_assertions))] {
+                ::rustpython_vm::types::PyTypeFlags::DEFAULT
+            }
+            #[cfg(debug_assertions)] {
+                ::rustpython_vm::types::PyTypeFlags::DEFAULT
+                    .union(::rustpython_vm::types::PyTypeFlags::_CREATED_WITH_FLAGS)
+            }
+        }
+    }];
+    let mut payload = None;
+    let mut itemsize = None;
+
+    for attr in attr {
+        match attr {
+            NestedMeta::Meta(Meta::List(MetaList { path, nested, .. })) => {
+                if path.is_ident("with") {
+                    for meta in nested {
+                        let NestedMeta::Meta(Meta::Path(path)) = &meta else {
+                            bail_span!(meta, "#[pyclass(with(...))] arguments must be paths")
+                        };
+                        let (extend_class, method_defs, extend_slots) = if path.is_ident("PyRef")
+                            || path.is_ident("Py")
+                        {
+                            // special handling for PyRef
+                            (
+                                quote!(#path::<Self>::__extend_py_class),
+                                quote!(#path::<Self>::__OWN_METHOD_DEFS),
+                                quote!(#path::<Self>::__extend_slots),
+                            )
+                        } else {
+                            if path.is_ident("DefaultConstructor") {
+                                bail_span!(
+                                    meta,
+                                    "Try `#[pyclass(with(Constructor, ...))]` instead of `#[pyclass(with(DefaultConstructor, ...))]`. DefaultConstructor implicitly implements Constructor."
+                                )
+                            }
+                            (
+                                quote!(<Self as #path>::__extend_py_class),
+                                quote!(<Self as #path>::__OWN_METHOD_DEFS),
+                                quote!(<Self as #path>::__extend_slots),
+                            )
+                        };
+                        let item_span = item.span().resolved_at(Span::call_site());
+                        withs.push(quote_spanned! { path.span() =>
+                            #extend_class(ctx, class);
+                        });
+                        with_method_defs.push(method_defs);
+                        // For Initializer and Constructor traits, directly set the slot
+                        // instead of calling __extend_slots. This ensures that the trait
+                        // impl's override (e.g., slot_init in impl Initializer) is used,
+                        // not the trait's default implementation.
+                        let slot_code = if path.is_ident("Initializer") {
+                            quote_spanned! { item_span =>
+                                slots.init.store(Some(<Self as ::rustpython_vm::types::Initializer>::slot_init as _));
+                            }
+                        } else if path.is_ident("Constructor") {
+                            quote_spanned! { item_span =>
+                                slots.new.store(Some(<Self as ::rustpython_vm::types::Constructor>::slot_new as _));
+                            }
+                        } else {
+                            quote_spanned! { item_span =>
+                                #extend_slots(slots);
+                            }
+                        };
+                        with_slots.push(slot_code);
+                    }
+                } else if path.is_ident("flags") {
+                    for meta in nested {
+                        let NestedMeta::Meta(Meta::Path(path)) = meta else {
+                            bail_span!(meta, "#[pyclass(flags(...))] arguments should be ident")
+                        };
+                        let ident = path.get_ident().ok_or_else(|| {
+                            err_span!(path, "#[pyclass(flags(...))] arguments should be ident")
+                        })?;
+                        flags.push(quote_spanned! { ident.span() =>
+                             .union(::rustpython_vm::types::PyTypeFlags::#ident)
+                        });
+                    }
+                    flags.push(quote! {
+                        .union(::rustpython_vm::types::PyTypeFlags::IMMUTABLETYPE)
+                    });
+                } else {
+                    bail_span!(path, "Unknown pyimpl attribute")
+                }
+            }
+            NestedMeta::Meta(Meta::NameValue(syn::MetaNameValue { path, value, .. })) => {
+                if path.is_ident("payload") {
+                    if let syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }) = value
+                    {
+                        payload = Some(Ident::new(&lit.value(), lit.span()));
+                    } else {
+                        bail_span!(value, "payload must be a string literal")
+                    }
+                } else if path.is_ident("itemsize") {
+                    itemsize = Some(value);
+                } else {
+                    bail_span!(path, "Unknown pyimpl attribute")
+                }
+            }
+            attr => bail_span!(attr, "Unknown pyimpl attribute"),
+        }
+    }
+
+    Ok(ExtractedImplAttrs {
+        payload,
+        flags: quote! {
+            #(#flags)*
+        },
+        with_impl: quote! {
+            #(#withs)*
+        },
+        with_method_defs,
+        with_slots: quote! {
+            #(#with_slots)*
+        },
+        itemsize,
+    })
+}
+
+fn impl_item_new<Item>(
+    index: usize,
+    attr_name: AttrName,
+) -> Result<Box<dyn ImplItem<Item, AttrName = AttrName>>>
+where
+    Item: ItemLike + ToTokens + GetIdent,
+{
+    use AttrName::*;
+    Ok(match attr_name {
+        attr_name @ Method | attr_name @ ClassMethod | attr_name @ StaticMethod => {
+            Box::new(MethodItem {
+                inner: ContentItemInner { index, attr_name },
+            })
+        }
+        GetSet => Box::new(GetSetItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
+        Slot => Box::new(SlotItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
+        Attr => Box::new(AttributeItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
+        ExtendClass => Box::new(ExtendClassItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
+        Member => Box::new(MemberItem {
+            inner: ContentItemInner { index, attr_name },
+        }),
+    })
+}
+
+fn attrs_to_content_items<F, R>(
+    attrs: &[Attribute],
+    item_new: F,
+) -> Result<(Vec<R>, Vec<Attribute>)>
+where
+    F: Fn(usize, AttrName) -> Result<R>,
+{
+    let mut cfgs: Vec<Attribute> = Vec::new();
+    let mut result = Vec::new();
+
+    let mut iter = attrs.iter().enumerate().peekable();
+    while let Some((_, attr)) = iter.peek() {
+        // take all cfgs but no py items
+        let attr = *attr;
+        let attr_name = if let Some(ident) = attr.get_ident() {
+            ident.to_string()
+        } else {
+            continue;
+        };
+        if attr_name == "cfg" {
+            cfgs.push(attr.clone());
+        } else if ALL_ALLOWED_NAMES.contains(&attr_name.as_str()) {
+            break;
+        }
+        iter.next();
+    }
+
+    for (i, attr) in iter {
+        // take py items but no cfgs
+        let attr_name = if let Some(ident) = attr.get_ident() {
+            ident.to_string()
+        } else {
+            continue;
+        };
+        if attr_name == "cfg" {
+            bail_span!(attr, "#[py*] items must be placed under `cfgs`",);
+        }
+        let attr_name = match AttrName::from_str(attr_name.as_str()) {
+            Ok(name) => name,
+            Err(wrong_name) => {
+                if ALL_ALLOWED_NAMES.contains(&attr_name.as_str()) {
+                    bail_span!(attr, "#[pyclass] doesn't accept #[{}]", wrong_name)
+                } else {
+                    continue;
+                }
+            }
+        };
+
+        result.push(item_new(i, attr_name)?);
+    }
+    Ok((result, cfgs))
+}
+
+#[allow(dead_code)]
+fn parse_vec_ident(
+    attr: &[NestedMeta],
+    item: &Item,
+    index: usize,
+    message: &str,
+) -> Result<String> {
+    Ok(attr
+        .get(index)
+        .ok_or_else(|| err_span!(item, "We require {} argument to be set", message))?
+        .get_ident()
+        .ok_or_else(|| {
+            err_span!(
+                item,
+                "We require {} argument to be ident or string",
+                message
+            )
+        })?
+        .to_string())
+}
diff --git a/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
similarity index 84%
rename from derive-impl/src/pymodule.rs
rename to crates/derive-impl/src/pymodule.rs
index 9e052cd1ff..3689ac97fd 100644
--- a/derive-impl/src/pymodule.rs
+++ b/crates/derive-impl/src/pymodule.rs
@@ -1,12 +1,15 @@
 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,
 };
+use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
 use quote::{ToTokens, quote, quote_spanned};
-use std::{collections::HashSet, str::FromStr};
+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;
@@ -16,14 +19,18 @@ enum AttrName {
     Function,
     Attr,
     Class,
+    Exception,
+    StructSequence,
 }
 
-impl std::fmt::Display for AttrName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for AttrName {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let s = match self {
             Self::Function => "pyfunction",
             Self::Attr => "pyattr",
             Self::Class => "pyclass",
+            Self::Exception => "pyexception",
+            Self::StructSequence => "pystruct_sequence",
         };
         s.fmt(f)
     }
@@ -32,11 +39,13 @@ impl std::fmt::Display for AttrName {
 impl FromStr for AttrName {
     type Err = String;
 
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
         Ok(match s {
             "pyfunction" => Self::Function,
             "pyattr" => Self::Attr,
             "pyclass" => Self::Class,
+            "pyexception" => Self::Exception,
+            "pystruct_sequence" => Self::StructSequence,
             s => {
                 return Err(s.to_owned());
             }
@@ -97,13 +106,7 @@ pub fn impl_pymodule(attr: PunctuatedNestedMeta, module_item: Item) -> Result<To
     let module_name = context.name.as_str();
     let function_items = context.function_items.validate()?;
     let attribute_items = context.attribute_items.validate()?;
-    let doc = doc.or_else(|| {
-        crate::doc::Database::shared()
-            .try_path(module_name)
-            .ok()
-            .flatten()
-            .map(str::to_owned)
-    });
+    let doc = doc.or_else(|| DB.get(module_name).copied().map(str::to_owned));
     let doc = if let Some(doc) = doc {
         quote!(Some(#doc))
     } else {
@@ -232,7 +235,12 @@ fn module_item_new(
             inner: ContentItemInner { index, attr_name },
             py_attrs,
         }),
-        AttrName::Class => Box::new(ClassItem {
+        // pyexception is treated like pyclass - both define types
+        AttrName::Class | AttrName::Exception => Box::new(ClassItem {
+            inner: ContentItemInner { index, attr_name },
+            py_attrs,
+        }),
+        AttrName::StructSequence => Box::new(StructSequenceItem {
             inner: ContentItemInner { index, attr_name },
             py_attrs,
         }),
@@ -302,13 +310,16 @@ where
             result.push(item_new(i, attr_name, Vec::new()));
         } else {
             match attr_name {
-                AttrName::Class | AttrName::Function => {
+                AttrName::Class
+                | AttrName::Function
+                | AttrName::Exception
+                | AttrName::StructSequence => {
                     result.push(item_new(i, attr_name, py_attrs.clone()));
                 }
                 _ => {
                     bail_span!(
                         attr,
-                        "#[pyclass] or #[pyfunction] only can follow #[pyattr]",
+                        "#[pyclass], #[pyfunction], #[pyexception], or #[pystruct_sequence] can follow #[pyattr]",
                     )
                 }
             }
@@ -403,6 +414,12 @@ struct AttributeItem {
     py_attrs: Vec<usize>,
 }
 
+/// #[pystruct_sequence]
+struct StructSequenceItem {
+    inner: ContentItemInner<AttrName>,
+    py_attrs: Vec<usize>,
+}
+
 impl ContentItem for FunctionItem {
     type AttrName = AttrName;
 
@@ -427,6 +444,14 @@ impl ContentItem for AttributeItem {
     }
 }
 
+impl ContentItem for StructSequenceItem {
+    type AttrName = AttrName;
+
+    fn inner(&self) -> &ContentItemInner<AttrName> {
+        &self.inner
+    }
+}
+
 struct ModuleItemArgs<'a> {
     item: &'a mut Item,
     attrs: &'a mut Vec<Attribute>,
@@ -459,11 +484,10 @@ impl ModuleItem for FunctionItem {
         let sig_doc = text_signature(func.sig(), &py_name);
 
         let module = args.module_name();
+        // TODO: doc must exist at least one of code or CPython
         let doc = args.attrs.doc().or_else(|| {
-            crate::doc::Database::shared()
-                .try_module_item(module, &py_name)
-                .ok() // TODO: doc must exist at least one of code or CPython
-                .flatten()
+            DB.get(&format!("{module}.{py_name}"))
+                .copied()
                 .map(str::to_owned)
         });
         let doc = if let Some(doc) = doc {
@@ -604,6 +628,84 @@ impl ModuleItem for ClassItem {
     }
 }
 
+impl ModuleItem for StructSequenceItem {
+    fn gen_module_item(&self, args: ModuleItemArgs<'_>) -> Result<()> {
+        // Get the struct identifier (this IS the Python type, e.g., PyStructTime)
+        let pytype_ident = match args.item {
+            Item::Struct(s) => s.ident.clone(),
+            other => bail_span!(other, "#[pystruct_sequence] can only be on a struct"),
+        };
+
+        // Parse the #[pystruct_sequence(name = "...", module = "...", no_attr)] attribute
+        let structseq_attr = &args.attrs[self.inner.index];
+        let meta = PyStructSequenceMeta::from_attr(pytype_ident.clone(), structseq_attr)?;
+
+        let class_name = meta.class_name()?.ok_or_else(|| {
+            syn::Error::new_spanned(
+                structseq_attr,
+                "#[pystruct_sequence] requires name parameter",
+            )
+        })?;
+        let module_name = meta.module()?.unwrap_or_else(|| args.context.name.clone());
+        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));
+        );
+
+        // Handle py_attrs for custom names, or use class_name as default
+        let mut py_names = Vec::new();
+        for attr_index in self.py_attrs.iter().rev() {
+            let attr_attr = args.attrs.remove(*attr_index);
+            let item_meta = SimpleItemMeta::from_attr(pytype_ident.clone(), &attr_attr)?;
+            let py_name = item_meta
+                .optional_name()
+                .unwrap_or_else(|| class_name.clone());
+            py_names.push(py_name);
+        }
+
+        // Require explicit #[pyattr] or no_attr, like #[pyclass]
+        if self.py_attrs.is_empty() && !no_attr {
+            bail_span!(
+                pytype_ident,
+                "#[pystruct_sequence] requires #[pyattr] to be a module attribute. \
+                 To keep it free type, try #[pystruct_sequence(..., no_attr)]"
+            )
+        }
+
+        let set_attr = match py_names.len() {
+            0 => quote! {
+                let _ = new_class;  // suppress warning
+            },
+            1 => {
+                let py_name = &py_names[0];
+                quote! {
+                    vm.__module_set_attr(&module, vm.ctx.intern_str(#py_name), new_class).unwrap();
+                }
+            }
+            _ => quote! {
+                for name in [#(#py_names,)*] {
+                    vm.__module_set_attr(&module, vm.ctx.intern_str(name), new_class.clone()).unwrap();
+                }
+            },
+        };
+
+        args.context.attribute_items.add_item(
+            pytype_ident.clone(),
+            py_names,
+            args.cfgs.to_vec(),
+            quote_spanned! { pytype_ident.span() =>
+                #class_new
+                #set_attr
+            },
+            0,
+        )?;
+        Ok(())
+    }
+}
+
 impl ModuleItem for AttributeItem {
     fn gen_module_item(&self, args: ModuleItemArgs<'_>) -> Result<()> {
         let cfgs = args.cfgs.to_vec();
diff --git a/derive-impl/src/pypayload.rs b/crates/derive-impl/src/pypayload.rs
similarity index 100%
rename from derive-impl/src/pypayload.rs
rename to crates/derive-impl/src/pypayload.rs
diff --git a/crates/derive-impl/src/pystructseq.rs b/crates/derive-impl/src/pystructseq.rs
new file mode 100644
index 0000000000..0ee0c2c2e3
--- /dev/null
+++ b/crates/derive-impl/src/pystructseq.rs
@@ -0,0 +1,638 @@
+use crate::util::{ItemMeta, ItemMetaInner};
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::{DeriveInput, Ident, Item, Result};
+use syn_ext::ext::{AttributeExt, GetIdent};
+use syn_ext::types::{Meta, PunctuatedNestedMeta};
+
+// #[pystruct_sequence_data] - For Data structs
+
+/// Field kind for struct sequence
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum FieldKind {
+    /// Named visible field (has getter, shown in repr)
+    Named,
+    /// Unnamed visible field (index-only, no getter)
+    Unnamed,
+    /// Hidden/skipped field (stored in tuple, but hidden from repr/len/index)
+    Skipped,
+}
+
+/// Parsed field with its kind
+struct ParsedField {
+    ident: Ident,
+    kind: FieldKind,
+    /// Optional cfg attributes for conditional compilation
+    cfg_attrs: Vec<syn::Attribute>,
+}
+
+/// Parsed field info from struct
+struct FieldInfo {
+    /// All fields in order with their kinds
+    fields: Vec<ParsedField>,
+}
+
+impl FieldInfo {
+    fn named_fields(&self) -> Vec<&ParsedField> {
+        self.fields
+            .iter()
+            .filter(|f| f.kind == FieldKind::Named)
+            .collect()
+    }
+
+    fn visible_fields(&self) -> Vec<&ParsedField> {
+        self.fields
+            .iter()
+            .filter(|f| f.kind != FieldKind::Skipped)
+            .collect()
+    }
+
+    fn skipped_fields(&self) -> Vec<&ParsedField> {
+        self.fields
+            .iter()
+            .filter(|f| f.kind == FieldKind::Skipped)
+            .collect()
+    }
+
+    fn n_unnamed_fields(&self) -> usize {
+        self.fields
+            .iter()
+            .filter(|f| f.kind == FieldKind::Unnamed)
+            .count()
+    }
+}
+
+/// Parse field info from struct
+fn parse_fields(input: &mut DeriveInput) -> Result<FieldInfo> {
+    let syn::Data::Struct(struc) = &mut input.data else {
+        bail_span!(input, "#[pystruct_sequence_data] can only be on a struct")
+    };
+
+    let syn::Fields::Named(fields) = &mut struc.fields else {
+        bail_span!(
+            input,
+            "#[pystruct_sequence_data] can only be on a struct with named fields"
+        );
+    };
+
+    let mut parsed_fields = Vec::with_capacity(fields.named.len());
+
+    for field in &mut fields.named {
+        let mut skip = false;
+        let mut unnamed = false;
+        let mut attrs_to_remove = Vec::new();
+        let mut cfg_attrs = Vec::new();
+
+        for (i, attr) in field.attrs.iter().enumerate() {
+            // Collect cfg attributes for conditional compilation
+            if attr.path().is_ident("cfg") {
+                cfg_attrs.push(attr.clone());
+                continue;
+            }
+
+            if !attr.path().is_ident("pystruct_sequence") {
+                continue;
+            }
+
+            let Ok(meta) = attr.parse_meta() else {
+                continue;
+            };
+
+            let Meta::List(l) = meta else {
+                bail_span!(input, "Only #[pystruct_sequence(...)] form is allowed");
+            };
+
+            let idents: Vec<_> = l
+                .nested
+                .iter()
+                .filter_map(|n| n.get_ident())
+                .cloned()
+                .collect();
+
+            for ident in idents {
+                match ident.to_string().as_str() {
+                    "skip" => {
+                        skip = true;
+                    }
+                    "unnamed" => {
+                        unnamed = true;
+                    }
+                    _ => {
+                        bail_span!(ident, "Unknown item for #[pystruct_sequence(...)]")
+                    }
+                }
+            }
+
+            attrs_to_remove.push(i);
+        }
+
+        // Remove attributes in reverse order
+        attrs_to_remove.sort_unstable_by(|a, b| b.cmp(a));
+        for index in attrs_to_remove {
+            field.attrs.remove(index);
+        }
+
+        let ident = field.ident.clone().unwrap();
+        let kind = if skip {
+            FieldKind::Skipped
+        } else if unnamed {
+            FieldKind::Unnamed
+        } else {
+            FieldKind::Named
+        };
+
+        parsed_fields.push(ParsedField {
+            ident,
+            kind,
+            cfg_attrs,
+        });
+    }
+
+    Ok(FieldInfo {
+        fields: parsed_fields,
+    })
+}
+
+/// Check if `try_from_object` is present in attribute arguments
+fn has_try_from_object(attr: &PunctuatedNestedMeta) -> bool {
+    attr.iter().any(|nested| {
+        nested
+            .get_ident()
+            .is_some_and(|ident| ident == "try_from_object")
+    })
+}
+
+/// Attribute macro for Data structs: #[pystruct_sequence_data(...)]
+///
+/// Generates:
+/// - `REQUIRED_FIELD_NAMES` constant (named visible fields)
+/// - `OPTIONAL_FIELD_NAMES` constant (hidden/skipped fields)
+/// - `UNNAMED_FIELDS_LEN` constant
+/// - `into_tuple()` method
+/// - Field index constants (e.g., `TM_YEAR_INDEX`)
+///
+/// Options:
+/// - `try_from_object`: Generate `try_from_elements()` method and `TryFromObject` impl
+pub(crate) fn impl_pystruct_sequence_data(
+    attr: PunctuatedNestedMeta,
+    item: Item,
+) -> Result<TokenStream> {
+    let Item::Struct(item_struct) = item else {
+        bail_span!(
+            item,
+            "#[pystruct_sequence_data] can only be applied to structs"
+        );
+    };
+
+    let try_from_object = has_try_from_object(&attr);
+    let mut input: DeriveInput = DeriveInput {
+        attrs: item_struct.attrs.clone(),
+        vis: item_struct.vis.clone(),
+        ident: item_struct.ident.clone(),
+        generics: item_struct.generics.clone(),
+        data: syn::Data::Struct(syn::DataStruct {
+            struct_token: item_struct.struct_token,
+            fields: item_struct.fields.clone(),
+            semi_token: item_struct.semi_token,
+        }),
+    };
+    let field_info = parse_fields(&mut input)?;
+    let data_ident = &input.ident;
+
+    let named_fields = field_info.named_fields();
+    let visible_fields = field_info.visible_fields();
+    let skipped_fields = field_info.skipped_fields();
+    let n_unnamed_fields = field_info.n_unnamed_fields();
+
+    // Generate field index constants for visible fields (with cfg guards)
+    let field_indices: Vec<_> = visible_fields
+        .iter()
+        .enumerate()
+        .map(|(i, field)| {
+            let const_name = format_ident!("{}_INDEX", field.ident.to_string().to_uppercase());
+            let cfg_attrs = &field.cfg_attrs;
+            quote! {
+                #(#cfg_attrs)*
+                pub const #const_name: usize = #i;
+            }
+        })
+        .collect();
+
+    // Generate field name entries with cfg guards for named fields
+    let named_field_names: Vec<_> = named_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! { stringify!(#ident), }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { stringify!(#ident) },
+                }
+            }
+        })
+        .collect();
+
+    // Generate field name entries with cfg guards for skipped fields
+    let skipped_field_names: Vec<_> = skipped_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! { stringify!(#ident), }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { stringify!(#ident) },
+                }
+            }
+        })
+        .collect();
+
+    // Generate into_tuple items with cfg guards
+    let visible_tuple_items: Vec<_> = visible_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! {
+                    ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm),
+                }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm) },
+                }
+            }
+        })
+        .collect();
+
+    let skipped_tuple_items: Vec<_> = skipped_fields
+        .iter()
+        .map(|f| {
+            let ident = &f.ident;
+            let cfg_attrs = &f.cfg_attrs;
+            if cfg_attrs.is_empty() {
+                quote! {
+                    ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm),
+                }
+            } else {
+                quote! {
+                    #(#cfg_attrs)*
+                    { ::rustpython_vm::convert::ToPyObject::to_pyobject(self.#ident, vm) },
+                }
+            }
+        })
+        .collect();
+
+    // Generate TryFromObject impl only when try_from_object=true
+    let try_from_object_impl = if try_from_object {
+        let n_required = visible_fields.len();
+        quote! {
+            impl ::rustpython_vm::TryFromObject for #data_ident {
+                fn try_from_object(
+                    vm: &::rustpython_vm::VirtualMachine,
+                    obj: ::rustpython_vm::PyObjectRef,
+                ) -> ::rustpython_vm::PyResult<Self> {
+                    let seq: Vec<::rustpython_vm::PyObjectRef> = obj.try_into_value(vm)?;
+                    if seq.len() < #n_required {
+                        return Err(vm.new_type_error(format!(
+                            "{} requires at least {} elements",
+                            stringify!(#data_ident),
+                            #n_required
+                        )));
+                    }
+                    <Self as ::rustpython_vm::types::PyStructSequenceData>::try_from_elements(seq, vm)
+                }
+            }
+        }
+    } else {
+        quote! {}
+    };
+
+    // Generate try_from_elements trait override only when try_from_object=true
+    let try_from_elements_trait_override = if try_from_object {
+        let visible_field_inits: Vec<_> = visible_fields
+            .iter()
+            .map(|f| {
+                let ident = &f.ident;
+                let cfg_attrs = &f.cfg_attrs;
+                if cfg_attrs.is_empty() {
+                    quote! { #ident: iter.next().unwrap().clone().try_into_value(vm)?, }
+                } else {
+                    quote! {
+                        #(#cfg_attrs)*
+                        #ident: iter.next().unwrap().clone().try_into_value(vm)?,
+                    }
+                }
+            })
+            .collect();
+        let skipped_field_inits: Vec<_> = skipped_fields
+            .iter()
+            .map(|f| {
+                let ident = &f.ident;
+                let cfg_attrs = &f.cfg_attrs;
+                if cfg_attrs.is_empty() {
+                    quote! {
+                        #ident: match iter.next() {
+                            Some(v) => v.clone().try_into_value(vm)?,
+                            None => vm.ctx.none(),
+                        },
+                    }
+                } else {
+                    quote! {
+                        #(#cfg_attrs)*
+                        #ident: match iter.next() {
+                            Some(v) => v.clone().try_into_value(vm)?,
+                            None => vm.ctx.none(),
+                        },
+                    }
+                }
+            })
+            .collect();
+        quote! {
+            fn try_from_elements(
+                elements: Vec<::rustpython_vm::PyObjectRef>,
+                vm: &::rustpython_vm::VirtualMachine,
+            ) -> ::rustpython_vm::PyResult<Self> {
+                let mut iter = elements.into_iter();
+                Ok(Self {
+                    #(#visible_field_inits)*
+                    #(#skipped_field_inits)*
+                })
+            }
+        }
+    } else {
+        quote! {}
+    };
+
+    let output = quote! {
+        impl #data_ident {
+            #(#field_indices)*
+        }
+
+        // PyStructSequenceData trait impl
+        impl ::rustpython_vm::types::PyStructSequenceData for #data_ident {
+            const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(#named_field_names)*];
+            const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(#skipped_field_names)*];
+            const UNNAMED_FIELDS_LEN: usize = #n_unnamed_fields;
+
+            fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
+                let items = vec![
+                    #(#visible_tuple_items)*
+                    #(#skipped_tuple_items)*
+                ];
+                ::rustpython_vm::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
+            }
+
+            #try_from_elements_trait_override
+        }
+
+        #try_from_object_impl
+    };
+
+    // For attribute macro, we need to output the original struct as well
+    // But first, strip #[pystruct_sequence] attributes from fields
+    let mut clean_struct = item_struct.clone();
+    if let syn::Fields::Named(ref mut fields) = clean_struct.fields {
+        for field in &mut fields.named {
+            field
+                .attrs
+                .retain(|attr| !attr.path().is_ident("pystruct_sequence"));
+        }
+    }
+
+    Ok(quote! {
+        #clean_struct
+        #output
+    })
+}
+
+// #[pystruct_sequence(...)] - For Python type structs
+
+/// Meta parser for #[pystruct_sequence(...)]
+pub(crate) struct PyStructSequenceMeta {
+    inner: ItemMetaInner,
+}
+
+impl ItemMeta for PyStructSequenceMeta {
+    const ALLOWED_NAMES: &'static [&'static str] = &["name", "module", "data", "no_attr"];
+
+    fn from_inner(inner: ItemMetaInner) -> Self {
+        Self { inner }
+    }
+    fn inner(&self) -> &ItemMetaInner {
+        &self.inner
+    }
+}
+
+impl PyStructSequenceMeta {
+    pub fn class_name(&self) -> Result<Option<String>> {
+        const KEY: &str = "name";
+        let inner = self.inner();
+        if let Some((_, meta)) = inner.meta_map.get(KEY) {
+            if let Meta::NameValue(syn::MetaNameValue {
+                value:
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }),
+                ..
+            }) = meta
+            {
+                return Ok(Some(lit.value()));
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystruct_sequence({KEY}=value)] expects a string value"
+            )
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn module(&self) -> Result<Option<String>> {
+        const KEY: &str = "module";
+        let inner = self.inner();
+        if let Some((_, meta)) = inner.meta_map.get(KEY) {
+            if let Meta::NameValue(syn::MetaNameValue {
+                value:
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }),
+                ..
+            }) = meta
+            {
+                return Ok(Some(lit.value()));
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystruct_sequence({KEY}=value)] expects a string value"
+            )
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn data_type(&self) -> Result<Ident> {
+        const KEY: &str = "data";
+        let inner = self.inner();
+        if let Some((_, meta)) = inner.meta_map.get(KEY) {
+            if let Meta::NameValue(syn::MetaNameValue {
+                value:
+                    syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }),
+                ..
+            }) = meta
+            {
+                return Ok(format_ident!("{}", lit.value()));
+            }
+            bail_span!(
+                inner.meta_ident,
+                "#[pystruct_sequence({KEY}=value)] expects a string value"
+            )
+        } else {
+            bail_span!(
+                inner.meta_ident,
+                "#[pystruct_sequence] requires data parameter (e.g., data = \"DataStructName\")"
+            )
+        }
+    }
+
+    pub fn no_attr(&self) -> Result<bool> {
+        self.inner()._bool("no_attr")
+    }
+}
+
+/// Attribute macro for struct sequences.
+///
+/// Usage:
+/// ```ignore
+/// #[pystruct_sequence_data]
+/// struct StructTimeData { ... }
+///
+/// #[pystruct_sequence(name = "struct_time", module = "time", data = "StructTimeData")]
+/// struct PyStructTime;
+/// ```
+pub(crate) fn impl_pystruct_sequence(
+    attr: PunctuatedNestedMeta,
+    item: Item,
+) -> Result<TokenStream> {
+    let Item::Struct(struct_item) = item else {
+        bail_span!(item, "#[pystruct_sequence] can only be applied to a struct");
+    };
+
+    let ident = struct_item.ident.clone();
+    let fake_ident = Ident::new("pystruct_sequence", ident.span());
+    let meta = PyStructSequenceMeta::from_nested(ident, fake_ident, attr.into_iter())?;
+
+    let pytype_ident = struct_item.ident.clone();
+    let pytype_vis = struct_item.vis.clone();
+    let data_ident = meta.data_type()?;
+
+    let class_name = meta.class_name()?.ok_or_else(|| {
+        syn::Error::new_spanned(
+            &struct_item.ident,
+            "#[pystruct_sequence] requires name parameter",
+        )
+    })?;
+    let module_name = meta.module()?;
+
+    // Module name handling
+    let module_name_tokens = match &module_name {
+        Some(m) => quote!(Some(#m)),
+        None => quote!(None),
+    };
+
+    let module_class_name = if let Some(ref m) = module_name {
+        format!("{}.{}", m, class_name)
+    } else {
+        class_name.clone()
+    };
+
+    let output = quote! {
+        // The Python type struct - newtype wrapping PyTuple
+        #[derive(Debug)]
+        #[repr(transparent)]
+        #pytype_vis struct #pytype_ident(pub ::rustpython_vm::builtins::PyTuple);
+
+        // PyClassDef for Python type
+        impl ::rustpython_vm::class::PyClassDef for #pytype_ident {
+            const NAME: &'static str = #class_name;
+            const MODULE_NAME: Option<&'static str> = #module_name_tokens;
+            const TP_NAME: &'static str = #module_class_name;
+            const DOC: Option<&'static str> = None;
+            const BASICSIZE: usize = 0;
+            const UNHASHABLE: bool = false;
+
+            type Base = ::rustpython_vm::builtins::PyTuple;
+        }
+
+        // StaticType for Python type
+        impl ::rustpython_vm::class::StaticType for #pytype_ident {
+            fn static_cell() -> &'static ::rustpython_vm::common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> {
+                ::rustpython_vm::common::static_cell! {
+                    static CELL: ::rustpython_vm::builtins::PyTypeRef;
+                }
+                &CELL
+            }
+
+            fn static_baseclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                use ::rustpython_vm::class::StaticType;
+                ::rustpython_vm::builtins::PyTuple::static_type()
+            }
+        }
+
+        // Subtype uses base type's payload_type_id
+        impl ::rustpython_vm::PyPayload for #pytype_ident {
+            const PAYLOAD_TYPE_ID: ::core::any::TypeId = <::rustpython_vm::builtins::PyTuple as ::rustpython_vm::PyPayload>::PAYLOAD_TYPE_ID;
+
+            #[inline]
+            fn validate_downcastable_from(obj: &::rustpython_vm::PyObject) -> bool {
+                obj.class().fast_issubclass(<Self as ::rustpython_vm::class::StaticType>::static_type())
+            }
+
+            fn class(_ctx: &::rustpython_vm::vm::Context) -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
+                <Self as ::rustpython_vm::class::StaticType>::static_type()
+            }
+        }
+
+        // MaybeTraverse - delegate to inner PyTuple
+        impl ::rustpython_vm::object::MaybeTraverse for #pytype_ident {
+            fn try_traverse(&self, traverse_fn: &mut ::rustpython_vm::object::TraverseFn<'_>) {
+                self.0.try_traverse(traverse_fn)
+            }
+        }
+
+        // PySubclass for proper inheritance
+        impl ::rustpython_vm::class::PySubclass for #pytype_ident {
+            type Base = ::rustpython_vm::builtins::PyTuple;
+
+            #[inline]
+            fn as_base(&self) -> &Self::Base {
+                &self.0
+            }
+        }
+
+        // PyStructSequence trait for Python type
+        impl ::rustpython_vm::types::PyStructSequence for #pytype_ident {
+            type Data = #data_ident;
+        }
+
+        // ToPyObject for Data struct - uses PyStructSequence::from_data
+        impl ::rustpython_vm::convert::ToPyObject for #data_ident {
+            fn to_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::PyObjectRef {
+                <#pytype_ident as ::rustpython_vm::types::PyStructSequence>::from_data(self, vm).into()
+            }
+        }
+    };
+
+    Ok(output)
+}
diff --git a/derive-impl/src/pytraverse.rs b/crates/derive-impl/src/pytraverse.rs
similarity index 86%
rename from derive-impl/src/pytraverse.rs
rename to crates/derive-impl/src/pytraverse.rs
index 728722b83a..c4ec382329 100644
--- a/derive-impl/src/pytraverse.rs
+++ b/crates/derive-impl/src/pytraverse.rs
@@ -37,7 +37,7 @@ fn field_to_traverse_code(field: &Field) -> Result<TokenStream> {
         .attrs
         .iter()
         .filter_map(pytraverse_arg)
-        .collect::<std::result::Result<Vec<_>, _>>()?;
+        .collect::<core::result::Result<Vec<_>, _>>()?;
     let do_trace = if pytraverse_attrs.len() > 1 {
         bail_span!(
             field,
@@ -105,8 +105,19 @@ pub(crate) fn impl_pytraverse(mut item: DeriveInput) -> Result<TokenStream> {
 
     let ty = &item.ident;
 
+    // Add Traverse bound to all type parameters
+    for param in &mut item.generics.params {
+        if let syn::GenericParam::Type(type_param) = param {
+            type_param
+                .bounds
+                .push(syn::parse_quote!(::rustpython_vm::object::Traverse));
+        }
+    }
+
+    let (impl_generics, ty_generics, where_clause) = item.generics.split_for_impl();
+
     let ret = quote! {
-        unsafe impl ::rustpython_vm::object::Traverse for #ty {
+        unsafe impl #impl_generics ::rustpython_vm::object::Traverse for #ty #ty_generics #where_clause {
             fn traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
                 #trace_code
             }
diff --git a/derive-impl/src/util.rs b/crates/derive-impl/src/util.rs
similarity index 93%
rename from derive-impl/src/util.rs
rename to crates/derive-impl/src/util.rs
index 47a0606f05..6be1fcdf7a 100644
--- a/derive-impl/src/util.rs
+++ b/crates/derive-impl/src/util.rs
@@ -97,7 +97,7 @@ pub(crate) struct ContentItemInner<T> {
 }
 
 pub(crate) trait ContentItem {
-    type AttrName: std::str::FromStr + std::fmt::Display;
+    type AttrName: core::str::FromStr + core::fmt::Display;
 
     fn inner(&self) -> &ContentItemInner<Self::AttrName>;
     fn index(&self) -> usize {
@@ -125,7 +125,7 @@ impl ItemMetaInner {
         allowed_names: &[&'static str],
     ) -> Result<Self>
     where
-        I: std::iter::Iterator<Item = NestedMeta>,
+        I: core::iter::Iterator<Item = NestedMeta>,
     {
         let (meta_map, lits) = nested.into_unique_map_and_lits(|path| {
             if let Some(ident) = path.get_ident() {
@@ -187,6 +187,35 @@ impl ItemMetaInner {
         Ok(value)
     }
 
+    pub fn _optional_path(&self, key: &str) -> Result<Option<syn::Path>> {
+        let value = if let Some((_, meta)) = self.meta_map.get(key) {
+            let Meta::NameValue(syn::MetaNameValue { value, .. }) = meta else {
+                bail_span!(
+                    meta,
+                    "#[{}({} = ...)] must be a name-value pair",
+                    self.meta_name(),
+                    key
+                )
+            };
+
+            // Try to parse as a Path (identifier or path like Foo or foo::Bar)
+            match syn::parse2::<syn::Path>(value.to_token_stream()) {
+                Ok(path) => Some(path),
+                Err(_) => {
+                    bail_span!(
+                        value,
+                        "#[{}({} = ...)] must be a valid type path (e.g., PyBaseException)",
+                        self.meta_name(),
+                        key
+                    )
+                }
+            }
+        } else {
+            None
+        };
+        Ok(value)
+    }
+
     pub fn _has_key(&self, key: &str) -> Result<bool> {
         Ok(matches!(self.meta_map.get(key), Some((_, _))))
     }
@@ -214,7 +243,7 @@ impl ItemMetaInner {
     pub fn _optional_list(
         &self,
         key: &str,
-    ) -> Result<Option<impl std::iter::Iterator<Item = &'_ NestedMeta>>> {
+    ) -> Result<Option<impl core::iter::Iterator<Item = &'_ NestedMeta>>> {
         let value = if let Some((_, meta)) = self.meta_map.get(key) {
             let Meta::List(MetaList {
                 path: _, nested, ..
@@ -240,7 +269,7 @@ pub(crate) trait ItemMeta: Sized {
 
     fn from_nested<I>(item_ident: Ident, meta_ident: Ident, nested: I) -> Result<Self>
     where
-        I: std::iter::Iterator<Item = NestedMeta>,
+        I: core::iter::Iterator<Item = NestedMeta>,
     {
         Ok(Self::from_inner(ItemMetaInner::from_nested(
             item_ident,
@@ -384,8 +413,8 @@ impl ClassItemMeta {
         self.inner()._optional_str("ctx")
     }
 
-    pub fn base(&self) -> Result<Option<String>> {
-        self.inner()._optional_str("base")
+    pub fn base(&self) -> Result<Option<syn::Path>> {
+        self.inner()._optional_path("base")
     }
 
     pub fn unhashable(&self) -> Result<bool> {
@@ -446,7 +475,8 @@ impl ClassItemMeta {
 pub(crate) struct ExceptionItemMeta(ClassItemMeta);
 
 impl ItemMeta for ExceptionItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "base", "unhashable", "ctx", "impl"];
+    const ALLOWED_NAMES: &'static [&'static str] =
+        &["module", "name", "base", "unhashable", "ctx", "impl"];
 
     fn from_inner(inner: ItemMetaInner) -> Self {
         Self(ClassItemMeta(inner))
@@ -499,7 +529,7 @@ impl ExceptionItemMeta {
     }
 }
 
-impl std::ops::Deref for ExceptionItemMeta {
+impl core::ops::Deref for ExceptionItemMeta {
     type Target = ClassItemMeta;
     fn deref(&self) -> &Self::Target {
         &self.0
diff --git a/crates/derive/Cargo.toml b/crates/derive/Cargo.toml
new file mode 100644
index 0000000000..5ecd490cf9
--- /dev/null
+++ b/crates/derive/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "rustpython-derive"
+description = "Rust language extensions and macros specific to rustpython."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+rustpython-compiler = { workspace = true }
+rustpython-derive-impl = { workspace = true }
+syn = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/crates/derive/src/lib.rs b/crates/derive/src/lib.rs
new file mode 100644
index 0000000000..5a3ff84c63
--- /dev/null
+++ b/crates/derive/src/lib.rs
@@ -0,0 +1,321 @@
+#![recursion_limit = "128"]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
+#![doc(html_root_url = "https://docs.rs/rustpython-derive/")]
+
+use proc_macro::TokenStream;
+use rustpython_derive_impl as derive_impl;
+use syn::parse_macro_input;
+use syn::punctuated::Punctuated;
+
+#[proc_macro_derive(FromArgs, attributes(pyarg))]
+pub fn derive_from_args(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input);
+    derive_impl::derive_from_args(input).into()
+}
+
+/// The attribute can be applied either to a struct, trait, or impl.
+/// # Struct
+/// This implements `MaybeTraverse`, `PyClassDef`, and `StaticType` for the struct.
+/// Consider deriving `Traverse` to implement it.
+/// ## Arguments
+/// - `module`: the module which contains the class --  can be omitted if in a `#[pymodule]`.
+/// - `name`: the name of the Python class, by default it is the name of the struct.
+/// - `base`: the base class of the Python class.
+///   This does not cause inheritance of functions or attributes that must be done by a separate trait.
+/// # Impl
+/// This part implements `PyClassImpl` for the struct.
+/// This includes methods, getters/setters, etc.; only annotated methods will be included.
+/// Common functions and abilities like instantiation and `__call__` are often implemented by
+/// traits rather than in the `impl` itself; see `Constructor` and `Callable` respectively for those.
+/// ## Arguments
+/// - `name`: the name of the Python class, when no name is provided the struct name is used.
+/// - `flags`: the flags of the class, see `PyTypeFlags`.
+///     - `BASETYPE`: allows the class to be inheritable.
+///     - `IMMUTABLETYPE`: class attributes are immutable.
+/// - `with`: which trait implementations are to be included in the python class.
+/// ```rust, ignore
+/// #[pyclass(module = "my_module", name = "MyClass", base = BaseClass)]
+/// struct MyStruct {
+///    x: i32,
+/// }
+///
+/// impl Constructor for MyStruct {
+///     ...
+/// }
+///
+/// #[pyclass(with(Constructor))]
+/// impl MyStruct {
+///    ...
+/// }
+/// ```
+/// ## Inner markers
+/// ### pymethod/pyclassmethod/pystaticmethod
+/// `pymethod` is used to mark a method of the Python class.
+/// `pyclassmethod` is used to mark a class method.
+/// `pystaticmethod` is used to mark a static method.
+/// #### Method signature
+/// The first parameter can be either `&self` or `<var>: PyRef<Self>` for `pymethod`.
+/// The first parameter can be `cls: PyTypeRef` for `pyclassmethod`.
+/// There is no mandatory parameter for `pystaticmethod`.
+/// Both are valid and essentially the same, but the latter can yield more control.
+/// The last parameter can optionally be of the type `&VirtualMachine` to access the VM.
+/// All other values must implement `IntoPyResult`.
+/// Numeric types, `String`, `bool`, and `PyObjectRef` implement this trait,
+/// but so does any object that implements `PyValue`.
+/// Consider using `OptionalArg` for optional arguments.
+/// #### Arguments
+/// - `name`: the name of the method in Python,
+///   by default it is the same as the Rust method, or surrounded by double underscores if magic is present.
+///   This overrides `magic` and the default name and cannot be used with `magic` to prevent ambiguity.
+/// ### pygetset
+/// This is used to mark a getter/setter pair.
+/// #### Arguments
+/// - `setter`: marks the method as a setter, it acts as a getter by default.
+///   Setter method names should be prefixed with `set_`.
+/// - `name`: the name of the attribute in Python, by default it is the same as the Rust method.
+/// - `magic`: marks the method as a magic method: the method name is surrounded with double underscores.
+///   This cannot be used with `name` to prevent ambiguity.
+///
+/// Ensure both the getter and setter are marked with `name` and `magic` in the same manner.
+/// #### Examples
+/// ```rust, ignore
+/// #[pyclass]
+/// impl MyStruct {
+///    #[pygetset]
+///    fn x(&self) -> PyResult<i32> {
+///       Ok(self.x.lock())
+///     }
+///    #[pygetset(setter)]
+///   fn set_x(&mut self, value: i32) -> PyResult<()> {
+///      self.x.set(value);
+///     Ok(())
+///     }
+/// }
+/// ```
+/// ### pyslot
+/// This is used to mark a slot method it should be marked by prefixing the method in rust with `slot_`.
+/// #### Arguments
+/// - name: the name of the slot method.
+/// ### pyattr
+/// ### extend_class
+/// This helps inherit attributes from a parent class.
+/// The method this is applied on should be called `extend_class_with_fields`.
+/// #### Examples
+/// ```rust, ignore
+/// #[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!("body")).into(),
+///             ctx.new_str(ascii!("type_ignores")).into(),
+///         ])
+///         .into(),
+///     );
+///     class.set_attr(identifier!(ctx, _attributes), ctx.new_list(vec![]).into());
+/// }
+/// ```
+/// ### pymember
+/// # Trait
+/// `#[pyclass]` on traits functions a lot like `#[pyclass]` on `impl` blocks.
+/// Note that associated functions that are annotated with `#[pymethod]` or similar **must**
+/// have a body, abstract functions should be wrapped before applying an annotation.
+#[proc_macro_attribute]
+pub fn pyclass(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let item = parse_macro_input!(item);
+    derive_impl::pyclass(attr, item).into()
+}
+
+/// Helper macro to define `Exception` types.
+/// More-or-less is an alias to `pyclass` macro.
+///
+/// This macro serves a goal of generating multiple
+/// `BaseException` / `Exception`
+/// subtypes in a uniform and convenient manner.
+/// It looks like `SimpleExtendsException` in `CPython`.
+/// <https://github.com/python/cpython/blob/main/Objects/exceptions.c>
+#[proc_macro_attribute]
+pub fn pyexception(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let item = parse_macro_input!(item);
+    derive_impl::pyexception(attr, item).into()
+}
+
+/// This attribute must be applied to an inline module.
+/// It defines a Python module in the form a `make_module` function in the module;
+/// this has to be used in a `get_module_inits` to properly register the module.
+/// Additionally, this macro defines 'MODULE_NAME' and 'DOC' in the module.
+/// # Arguments
+/// - `name`: the name of the python module,
+///   by default, it is the name of the module, but this can be configured.
+/// ```rust, ignore
+/// // This will create a module named `my_module`
+/// #[pymodule(name = "my_module")]
+/// mod module {
+/// }
+/// ```
+/// - `sub`: declare the module as a submodule of another module.
+/// ```rust, ignore
+/// #[pymodule(sub)]
+/// mod submodule {
+/// }
+///
+/// #[pymodule(with(submodule))]
+/// mod my_module {
+/// }
+/// ```
+/// - `with`: declare the list of submodules that this module contains (see `sub` for example).
+/// ## Inner markers
+/// ### pyattr
+/// `pyattr` is a multipurpose marker that can be used in a pymodule.
+/// The most common use is to mark a function or class as a part of the module.
+/// This can be done by applying it to a function or struct prior to the `#[pyfunction]` or `#[pyclass]` macro.
+/// If applied to a constant, it will be added to the module as an attribute.
+/// If applied to a function not marked with `pyfunction`,
+/// it will also be added to the module as an attribute but the value is the result of the function.
+/// If `#[pyattr(once)]` is used in this case, the function will be called once
+/// and the result will be stored using a `static_cell`.
+/// #### Examples
+/// ```rust, ignore
+/// #[pymodule]
+/// mod my_module {
+///     #[pyattr]
+///     const MY_CONSTANT: i32 = 42;
+///     #[pyattr]
+///    fn another_constant() -> PyResult<i32> {
+///       Ok(42)
+///    }
+///   #[pyattr(once)]
+///   fn once() -> PyResult<i32> {
+///     // This will only be called once and the result will be stored.
+///     Ok(2 ** 24)
+///  }
+///
+///     #[pyattr]
+///     #[pyfunction]
+///     fn my_function(vm: &VirtualMachine) -> PyResult<()> {
+///         ...
+///     }
+/// }
+/// ```
+/// ### pyfunction
+/// This is used to create a python function.
+/// #### Function signature
+/// The last argument can optionally be of the type `&VirtualMachine` to access the VM.
+/// Refer to the `pymethod` documentation (located in the `pyclass` macro documentation)
+/// for more information on what regular argument types are permitted.
+/// #### Arguments
+/// - `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 item = parse_macro_input!(item);
+    derive_impl::pymodule(attr, item).into()
+}
+
+/// Attribute macro for defining Python struct sequence types.
+///
+/// This macro is applied to an empty struct to create a Python type
+/// that wraps a Data struct.
+///
+/// # Example
+/// ```ignore
+/// #[pystruct_sequence_data]
+/// struct StructTimeData {
+///     pub tm_year: PyObjectRef,
+///     #[pystruct_sequence(skip)]
+///     pub tm_gmtoff: PyObjectRef,
+/// }
+///
+/// #[pystruct_sequence(name = "struct_time", module = "time", data = "StructTimeData")]
+/// struct PyStructTime;
+/// ```
+#[proc_macro_attribute]
+pub fn pystruct_sequence(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let item = parse_macro_input!(item);
+    derive_impl::pystruct_sequence(attr, item).into()
+}
+
+/// Attribute macro for struct sequence Data structs.
+///
+/// Generates field name constants, index constants, and `into_tuple()` method.
+///
+/// # Example
+/// ```ignore
+/// #[pystruct_sequence_data]
+/// struct StructTimeData {
+///     pub tm_year: PyObjectRef,
+///     pub tm_mon: PyObjectRef,
+///     #[pystruct_sequence(skip)]  // optional field, not included in tuple
+///     pub tm_gmtoff: PyObjectRef,
+/// }
+/// ```
+///
+/// # Options
+/// - `try_from_object`: Generate `try_from_elements()` method and `TryFromObject` impl
+///
+/// ```ignore
+/// #[pystruct_sequence_data(try_from_object)]
+/// struct StructTimeData { ... }
+/// ```
+#[proc_macro_attribute]
+pub fn pystruct_sequence_data(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
+    let item = parse_macro_input!(item);
+    derive_impl::pystruct_sequence_data(attr, item).into()
+}
+
+struct Compiler;
+impl derive_impl::Compiler for Compiler {
+    fn compile(
+        &self,
+        source: &str,
+        mode: rustpython_compiler::Mode,
+        module_name: String,
+    ) -> Result<rustpython_compiler::CodeObject, Box<dyn core::error::Error>> {
+        use rustpython_compiler::{CompileOpts, compile};
+        Ok(compile(source, mode, &module_name, CompileOpts::default())?)
+    }
+}
+
+#[proc_macro]
+pub fn py_compile(input: TokenStream) -> TokenStream {
+    derive_impl::py_compile(input.into(), &Compiler).into()
+}
+
+#[proc_macro]
+pub fn py_freeze(input: TokenStream) -> TokenStream {
+    derive_impl::py_freeze(input.into(), &Compiler).into()
+}
+
+#[proc_macro_derive(PyPayload)]
+pub fn pypayload(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input);
+    derive_impl::pypayload(input).into()
+}
+
+/// use on struct with named fields like `struct A{x:PyRef<B>, y:PyRef<C>}` to impl `Traverse` for datatype.
+///
+/// use `#[pytraverse(skip)]` on fields you wish not to trace
+///
+/// add `trace` attr to `#[pyclass]` to make it impl `MaybeTraverse` that will call `Traverse`'s `traverse` method so make it
+/// traceable(Even from type-erased PyObject)(i.e. write `#[pyclass(trace)]`).
+/// # Example
+/// ```rust, ignore
+/// #[pyclass(module = false, traverse)]
+/// #[derive(Default, Traverse)]
+/// pub struct PyList {
+///     elements: PyRwLock<Vec<PyObjectRef>>,
+///     #[pytraverse(skip)]
+///     len: AtomicCell<usize>,
+/// }
+/// ```
+/// This create both `MaybeTraverse` that call `Traverse`'s `traverse` method and `Traverse` that impl `Traverse`
+/// for `PyList` which call elements' `traverse` method and ignore `len` field.
+#[proc_macro_derive(Traverse, attributes(pytraverse))]
+pub fn pytraverse(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let item = parse_macro_input!(item);
+    derive_impl::pytraverse(item).into()
+}
diff --git a/crates/doc/.gitignore b/crates/doc/.gitignore
new file mode 100644
index 0000000000..9ab870da89
--- /dev/null
+++ b/crates/doc/.gitignore
@@ -0,0 +1 @@
+generated/
diff --git a/crates/doc/Cargo.toml b/crates/doc/Cargo.toml
new file mode 100644
index 0000000000..3435fabc8b
--- /dev/null
+++ b/crates/doc/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "rustpython-doc"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license-file = "LICENSE"
+
+[dependencies]
+phf = { workspace = true }
+
+[lib]
+doctest = false # Crashes when true
+
+[lints]
+workspace = true
diff --git a/crates/doc/LICENSE b/crates/doc/LICENSE
new file mode 100644
index 0000000000..20cf39097c
--- /dev/null
+++ b/crates/doc/LICENSE
@@ -0,0 +1,277 @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see https://opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+Python software and documentation are licensed under the
+Python Software Foundation License Version 2.
+
+Starting with Python 3.8.6, examples, recipes, and other code in
+the documentation are dual licensed under the PSF License Version 2
+and the Zero-Clause BSD license.
+
+Some software incorporated into Python is under different licenses.
+The licenses are listed with code falling under that license.
+
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001 Python Software Foundation; All Rights Reserved"
+are retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
+----------------------------------------------------------------------
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/crates/doc/generate.py b/crates/doc/generate.py
new file mode 100644
index 0000000000..73cb462bb9
--- /dev/null
+++ b/crates/doc/generate.py
@@ -0,0 +1,223 @@
+#!/usr/bin/env python
+import argparse
+import inspect
+import json
+import os
+import pathlib
+import platform
+import pydoc
+import re
+import sys
+import types
+import typing
+import warnings
+from importlib.machinery import EXTENSION_SUFFIXES, ExtensionFileLoader
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterable
+
+OUTPUT_FILE = pathlib.Path(__file__).parent / "generated" / f"{sys.platform}.json"
+OUTPUT_FILE.parent.mkdir(exist_ok=True)
+
+UNICODE_ESCAPE = re.compile(r"\\u([0-9]+)")
+
+IGNORED_MODULES = {"this", "antigravity"}
+IGNORED_ATTRS = {
+    "__annotations__",
+    "__class__",
+    "__dict__",
+    "__dir__",
+    "__doc__",
+    "__file__",
+    "__name__",
+    "__qualname__",
+}
+
+
+type Parts = tuple[str, ...]
+
+
+class DocEntry(typing.NamedTuple):
+    parts: Parts
+    raw_doc: str | None
+
+    @property
+    def key(self) -> str:
+        return ".".join(self.parts)
+
+    @property
+    def doc(self) -> str:
+        assert self.raw_doc is not None
+
+        return re.sub(UNICODE_ESCAPE, r"\\u{\1}", inspect.cleandoc(self.raw_doc))
+
+
+def is_c_extension(module: types.ModuleType) -> bool:
+    """
+    Check whether a module was written in C.
+
+    Returns
+    -------
+    bool
+
+    Notes
+    -----
+    Adapted from: https://stackoverflow.com/a/39304199
+    """
+    loader = getattr(module, "__loader__", None)
+    if isinstance(loader, ExtensionFileLoader):
+        return True
+
+    try:
+        inspect.getsource(module)
+    except (OSError, TypeError):
+        return True
+
+    try:
+        module_filename = inspect.getfile(module)
+    except TypeError:
+        return True
+
+    module_filetype = os.path.splitext(module_filename)[1]
+    return module_filetype in EXTENSION_SUFFIXES
+
+
+def is_child_of(obj: typing.Any, module: types.ModuleType) -> bool:
+    """
+    Whether or not an object is a child of a module.
+
+    Returns
+    -------
+    bool
+    """
+    return inspect.getmodule(obj) is module
+
+
+def iter_modules() -> "Iterable[types.ModuleType]":
+    """
+    Yields
+    ------
+    :class:`types.Module`
+        Python modules.
+    """
+    for module_name in sys.stdlib_module_names - IGNORED_MODULES:
+        try:
+            with warnings.catch_warnings():
+                warnings.filterwarnings("ignore", category=DeprecationWarning)
+                module = __import__(module_name)
+        except ImportError:
+            warnings.warn(f"Could not import {module_name}", category=ImportWarning)
+            continue
+
+        yield module
+
+
+def iter_c_modules() -> "Iterable[types.ModuleType]":
+    """
+    Yields
+    ------
+    :class:`types.Module`
+        Modules that are written in C. (not pure python)
+    """
+    yield from filter(is_c_extension, iter_modules())
+
+
+def traverse(
+    obj: typing.Any, module: types.ModuleType, parts: Parts = ()
+) -> "typing.Iterable[DocEntry]":
+    if inspect.ismodule(obj):
+        parts += (obj.__name__,)
+
+    if any(f(obj) for f in (inspect.ismodule, inspect.isclass, inspect.isbuiltin)):
+        yield DocEntry(parts, pydoc._getowndoc(obj))
+
+    for name, attr in inspect.getmembers(obj):
+        if name in IGNORED_ATTRS:
+            continue
+
+        if attr == obj:
+            continue
+
+        if (module is obj) and (not is_child_of(attr, module)):
+            continue
+
+        # Don't recurse into modules imported by our module. i.e. `ipaddress.py` imports `re` don't traverse `re`
+        if (not inspect.ismodule(obj)) and inspect.ismodule(attr):
+            continue
+
+        new_parts = parts + (name,)
+
+        attr_typ = type(attr)
+        is_type_or_builtin = any(attr_typ is x for x in (type, type(__builtins__)))
+
+        if is_type_or_builtin:
+            yield from traverse(attr, module, new_parts)
+            continue
+
+        is_callable = (
+            callable(attr)
+            or not issubclass(attr_typ, type)
+            or attr_typ.__name__ in ("getset_descriptor", "member_descriptor")
+        )
+
+        is_func = any(
+            f(attr)
+            for f in (inspect.isfunction, inspect.ismethod, inspect.ismethoddescriptor)
+        )
+
+        if is_callable or is_func:
+            yield DocEntry(new_parts, pydoc._getowndoc(attr))
+
+
+def find_doc_entries() -> "Iterable[DocEntry]":
+    yield from (
+        doc_entry
+        for module in iter_c_modules()
+        for doc_entry in traverse(module, module)
+    )
+    yield from (doc_entry for doc_entry in traverse(__builtins__, __builtins__))
+
+    builtin_types = [
+        type(None),
+        type(bytearray().__iter__()),
+        type(bytes().__iter__()),
+        type(dict().__iter__()),
+        type(dict().items()),
+        type(dict().items().__iter__()),
+        type(dict().values()),
+        type(dict().values().__iter__()),
+        type(lambda: ...),
+        type(list().__iter__()),
+        type(memoryview(b"").__iter__()),
+        type(range(0).__iter__()),
+        type(set().__iter__()),
+        type(str().__iter__()),
+        type(tuple().__iter__()),
+    ]
+
+    # Add types from the types module (e.g., ModuleType, FunctionType, etc.)
+    for name in dir(types):
+        if name.startswith("_"):
+            continue
+        obj = getattr(types, name)
+        if isinstance(obj, type):
+            builtin_types.append(obj)
+
+    for typ in builtin_types:
+        parts = ("builtins", typ.__name__)
+        yield DocEntry(parts, pydoc._getowndoc(typ))
+        yield from traverse(typ, __builtins__, parts)
+
+
+def main():
+    docs = {
+        entry.key: entry.doc
+        for entry in find_doc_entries()
+        if entry.raw_doc is not None and isinstance(entry.raw_doc, str)
+    }
+    dumped = json.dumps(docs, sort_keys=True, indent=4)
+    OUTPUT_FILE.write_text(dumped)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/crates/doc/src/data.inc.rs b/crates/doc/src/data.inc.rs
new file mode 100644
index 0000000000..4411587ca8
--- /dev/null
+++ b/crates/doc/src/data.inc.rs
@@ -0,0 +1,9561 @@
+// This file was auto-generated by `.github/workflows/update-doc-db.yml`.
+// CPython version: 3.13.9
+// spell-checker: disable
+
+pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {
+    "_abc" => "Module contains faster C implementation of abc.ABCMeta",
+    "_abc._abc_init" => "Internal ABC helper for class set-up. Should be never used outside abc module.",
+    "_abc._abc_instancecheck" => "Internal ABC helper for instance checks. Should be never used outside abc module.",
+    "_abc._abc_register" => "Internal ABC helper for subclasss registration. Should be never used outside abc module.",
+    "_abc._abc_subclasscheck" => "Internal ABC helper for subclasss checks. Should be never used outside abc module.",
+    "_abc._get_dump" => "Internal ABC helper for cache and registry debugging.\n\nReturn shallow copies of registry, of both caches, and\nnegative cache version. Don't call this function directly,\ninstead use ABC._dump_registry() for a nice repr.",
+    "_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.",
+    "_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.__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.",
+    "_asyncio.Future.__delattr__" => "Implement delattr(self, name).",
+    "_asyncio.Future.__eq__" => "Return self==value.",
+    "_asyncio.Future.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_asyncio.Future.__ge__" => "Return self>=value.",
+    "_asyncio.Future.__getattribute__" => "Return getattr(self, name).",
+    "_asyncio.Future.__getstate__" => "Helper for pickle.",
+    "_asyncio.Future.__gt__" => "Return self>value.",
+    "_asyncio.Future.__hash__" => "Return hash(self).",
+    "_asyncio.Future.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_asyncio.Future.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_asyncio.Future.__iter__" => "Implement iter(self).",
+    "_asyncio.Future.__le__" => "Return self<=value.",
+    "_asyncio.Future.__lt__" => "Return self<value.",
+    "_asyncio.Future.__ne__" => "Return self!=value.",
+    "_asyncio.Future.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_asyncio.Future.__reduce__" => "Helper for pickle.",
+    "_asyncio.Future.__reduce_ex__" => "Helper for pickle.",
+    "_asyncio.Future.__repr__" => "Return repr(self).",
+    "_asyncio.Future.__setattr__" => "Implement setattr(self, name, value).",
+    "_asyncio.Future.__sizeof__" => "Size of object in memory, in bytes.",
+    "_asyncio.Future.__str__" => "Return str(self).",
+    "_asyncio.Future.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_asyncio.Future._make_cancelled_error" => "Create the CancelledError to raise if the Future is cancelled.\n\nThis should only be called once when handling a cancellation since\nit erases the context exception value.",
+    "_asyncio.Future.add_done_callback" => "Add a callback to be run when the future becomes done.\n\nThe callback is called with a single argument - the future object. If\nthe future is already done when this is called, the callback is\nscheduled with call_soon.",
+    "_asyncio.Future.cancel" => "Cancel the future and schedule callbacks.\n\nIf the future is already done or cancelled, return False.  Otherwise,\nchange the future's state to cancelled, schedule the callbacks and\nreturn True.",
+    "_asyncio.Future.cancelled" => "Return True if the future was cancelled.",
+    "_asyncio.Future.done" => "Return True if the future is done.\n\nDone means either that a result / exception are available, or that the\nfuture was cancelled.",
+    "_asyncio.Future.exception" => "Return the exception that was set on this future.\n\nThe exception (or None if no exception was set) is returned only if\nthe future is done.  If the future has been cancelled, raises\nCancelledError.  If the future isn't done yet, raises\nInvalidStateError.",
+    "_asyncio.Future.get_loop" => "Return the event loop the Future is bound to.",
+    "_asyncio.Future.remove_done_callback" => "Remove all instances of a callback from the \"call when done\" list.\n\nReturns the number of callbacks removed.",
+    "_asyncio.Future.result" => "Return the result this future represents.\n\nIf the future has been cancelled, raises CancelledError.  If the\nfuture's result isn't yet available, raises InvalidStateError.  If\nthe future is done and has an exception set, this exception is raised.",
+    "_asyncio.Future.set_exception" => "Mark the future done and set an exception.\n\nIf the future is already done when this method is called, raises\nInvalidStateError.",
+    "_asyncio.Future.set_result" => "Mark the future done and set its result.\n\nIf the future is already done when this method is called, raises\nInvalidStateError.",
+    "_asyncio.Task" => "A coroutine wrapped in a Future.",
+    "_asyncio.Task.__await__" => "Return an iterator to be used in await expression.",
+    "_asyncio.Task.__class_getitem__" => "See PEP 585",
+    "_asyncio.Task.__del__" => "Called when the instance is about to be destroyed.",
+    "_asyncio.Task.__delattr__" => "Implement delattr(self, name).",
+    "_asyncio.Task.__eq__" => "Return self==value.",
+    "_asyncio.Task.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_asyncio.Task.__ge__" => "Return self>=value.",
+    "_asyncio.Task.__getattribute__" => "Return getattr(self, name).",
+    "_asyncio.Task.__getstate__" => "Helper for pickle.",
+    "_asyncio.Task.__gt__" => "Return self>value.",
+    "_asyncio.Task.__hash__" => "Return hash(self).",
+    "_asyncio.Task.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_asyncio.Task.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_asyncio.Task.__iter__" => "Implement iter(self).",
+    "_asyncio.Task.__le__" => "Return self<=value.",
+    "_asyncio.Task.__lt__" => "Return self<value.",
+    "_asyncio.Task.__ne__" => "Return self!=value.",
+    "_asyncio.Task.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_asyncio.Task.__reduce__" => "Helper for pickle.",
+    "_asyncio.Task.__reduce_ex__" => "Helper for pickle.",
+    "_asyncio.Task.__repr__" => "Return repr(self).",
+    "_asyncio.Task.__setattr__" => "Implement setattr(self, name, value).",
+    "_asyncio.Task.__sizeof__" => "Size of object in memory, in bytes.",
+    "_asyncio.Task.__str__" => "Return str(self).",
+    "_asyncio.Task.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_asyncio.Task._make_cancelled_error" => "Create the CancelledError to raise if the Task is cancelled.\n\nThis should only be called once when handling a cancellation since\nit erases the context exception value.",
+    "_asyncio.Task.add_done_callback" => "Add a callback to be run when the future becomes done.\n\nThe callback is called with a single argument - the future object. If\nthe future is already done when this is called, the callback is\nscheduled with call_soon.",
+    "_asyncio.Task.cancel" => "Request that this task cancel itself.\n\nThis arranges for a CancelledError to be thrown into the\nwrapped coroutine on the next cycle through the event loop.\nThe coroutine then has a chance to clean up or even deny\nthe request using try/except/finally.\n\nUnlike Future.cancel, this does not guarantee that the\ntask will be cancelled: the exception might be caught and\nacted upon, delaying cancellation of the task or preventing\ncancellation completely.  The task may also return a value or\nraise a different exception.\n\nImmediately after this method is called, Task.cancelled() will\nnot return True (unless the task was already cancelled).  A\ntask will be marked as cancelled when the wrapped coroutine\nterminates with a CancelledError exception (even if cancel()\nwas not called).\n\nThis also increases the task's count of cancellation requests.",
+    "_asyncio.Task.cancelled" => "Return True if the future was cancelled.",
+    "_asyncio.Task.cancelling" => "Return the count of the task's cancellation requests.\n\nThis count is incremented when .cancel() is called\nand may be decremented using .uncancel().",
+    "_asyncio.Task.done" => "Return True if the future is done.\n\nDone means either that a result / exception are available, or that the\nfuture was cancelled.",
+    "_asyncio.Task.exception" => "Return the exception that was set on this future.\n\nThe exception (or None if no exception was set) is returned only if\nthe future is done.  If the future has been cancelled, raises\nCancelledError.  If the future isn't done yet, raises\nInvalidStateError.",
+    "_asyncio.Task.get_loop" => "Return the event loop the Future is bound to.",
+    "_asyncio.Task.get_stack" => "Return the list of stack frames for this task's coroutine.\n\nIf the coroutine is not done, this returns the stack where it is\nsuspended.  If the coroutine has completed successfully or was\ncancelled, this returns an empty list.  If the coroutine was\nterminated by an exception, this returns the list of traceback\nframes.\n\nThe frames are always ordered from oldest to newest.\n\nThe optional limit gives the maximum number of frames to\nreturn; by default all available frames are returned.  Its\nmeaning differs depending on whether a stack or a traceback is\nreturned: the newest frames of a stack are returned, but the\noldest frames of a traceback are returned.  (This matches the\nbehavior of the traceback module.)\n\nFor reasons beyond our control, only one stack frame is\nreturned for a suspended coroutine.",
+    "_asyncio.Task.print_stack" => "Print the stack or traceback for this task's coroutine.\n\nThis produces output similar to that of the traceback module,\nfor the frames retrieved by get_stack().  The limit argument\nis passed to get_stack().  The file argument is an I/O stream\nto which the output is written; by default output is written\nto sys.stderr.",
+    "_asyncio.Task.remove_done_callback" => "Remove all instances of a callback from the \"call when done\" list.\n\nReturns the number of callbacks removed.",
+    "_asyncio.Task.result" => "Return the result this future represents.\n\nIf the future has been cancelled, raises CancelledError.  If the\nfuture's result isn't yet available, raises InvalidStateError.  If\nthe future is done and has an exception set, this exception is raised.",
+    "_asyncio.Task.uncancel" => "Decrement the task's count of cancellation requests.\n\nThis should be used by tasks that catch CancelledError\nand wish to continue indefinitely until they are cancelled again.\n\nReturns the remaining number of cancellation requests.",
+    "_asyncio._enter_task" => "Enter into task execution or resume suspended task.\n\nTask belongs to loop.\n\nReturns None.",
+    "_asyncio._get_running_loop" => "Return the running event loop or None.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.",
+    "_asyncio._leave_task" => "Leave task execution or suspend a task.\n\nTask belongs to loop.\n\nReturns None.",
+    "_asyncio._register_eager_task" => "Register a new task in asyncio as executed by loop.\n\nReturns None.",
+    "_asyncio._register_task" => "Register a new task in asyncio as executed by loop.\n\nReturns None.",
+    "_asyncio._set_running_loop" => "Set the running event loop.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.",
+    "_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.current_task" => "Return a currently executed task.",
+    "_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.",
+    "_bisect.bisect_left" => "Return the index where to insert item x in list a, assuming a is sorted.\n\nThe return value i is such that all e in a[:i] have e < x, and all e in\na[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will\ninsert just before the leftmost x already there.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.\n\nA custom key function can be supplied to customize the sort order.",
+    "_bisect.bisect_right" => "Return the index where to insert item x in list a, assuming a is sorted.\n\nThe return value i is such that all e in a[:i] have e <= x, and all e in\na[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will\ninsert just after the rightmost x already there.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.\n\nA custom key function can be supplied to customize the sort order.",
+    "_bisect.insort_left" => "Insert item x in list a, and keep it sorted assuming a is sorted.\n\nIf x is already in a, insert it to the left of the leftmost x.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.\n\nA custom key function can be supplied to customize the sort order.",
+    "_bisect.insort_right" => "Insert item x in list a, and keep it sorted assuming a is sorted.\n\nIf x is already in a, insert it to the right of the rightmost x.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.\n\nA custom key function can be supplied to customize the sort order.",
+    "_blake2" => "_blake2b provides BLAKE2b for hashlib",
+    "_blake2.blake2b" => "Return a new BLAKE2b hash object.",
+    "_blake2.blake2b.__delattr__" => "Implement delattr(self, name).",
+    "_blake2.blake2b.__eq__" => "Return self==value.",
+    "_blake2.blake2b.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_blake2.blake2b.__ge__" => "Return self>=value.",
+    "_blake2.blake2b.__getattribute__" => "Return getattr(self, name).",
+    "_blake2.blake2b.__getstate__" => "Helper for pickle.",
+    "_blake2.blake2b.__gt__" => "Return self>value.",
+    "_blake2.blake2b.__hash__" => "Return hash(self).",
+    "_blake2.blake2b.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_blake2.blake2b.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_blake2.blake2b.__le__" => "Return self<=value.",
+    "_blake2.blake2b.__lt__" => "Return self<value.",
+    "_blake2.blake2b.__ne__" => "Return self!=value.",
+    "_blake2.blake2b.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_blake2.blake2b.__reduce__" => "Helper for pickle.",
+    "_blake2.blake2b.__reduce_ex__" => "Helper for pickle.",
+    "_blake2.blake2b.__repr__" => "Return repr(self).",
+    "_blake2.blake2b.__setattr__" => "Implement setattr(self, name, value).",
+    "_blake2.blake2b.__sizeof__" => "Size of object in memory, in bytes.",
+    "_blake2.blake2b.__str__" => "Return str(self).",
+    "_blake2.blake2b.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_blake2.blake2b.copy" => "Return a copy of the hash object.",
+    "_blake2.blake2b.digest" => "Return the digest value as a bytes object.",
+    "_blake2.blake2b.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_blake2.blake2b.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_blake2.blake2s" => "Return a new BLAKE2s hash object.",
+    "_blake2.blake2s.__delattr__" => "Implement delattr(self, name).",
+    "_blake2.blake2s.__eq__" => "Return self==value.",
+    "_blake2.blake2s.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_blake2.blake2s.__ge__" => "Return self>=value.",
+    "_blake2.blake2s.__getattribute__" => "Return getattr(self, name).",
+    "_blake2.blake2s.__getstate__" => "Helper for pickle.",
+    "_blake2.blake2s.__gt__" => "Return self>value.",
+    "_blake2.blake2s.__hash__" => "Return hash(self).",
+    "_blake2.blake2s.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_blake2.blake2s.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_blake2.blake2s.__le__" => "Return self<=value.",
+    "_blake2.blake2s.__lt__" => "Return self<value.",
+    "_blake2.blake2s.__ne__" => "Return self!=value.",
+    "_blake2.blake2s.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_blake2.blake2s.__reduce__" => "Helper for pickle.",
+    "_blake2.blake2s.__reduce_ex__" => "Helper for pickle.",
+    "_blake2.blake2s.__repr__" => "Return repr(self).",
+    "_blake2.blake2s.__setattr__" => "Implement setattr(self, name, value).",
+    "_blake2.blake2s.__sizeof__" => "Size of object in memory, in bytes.",
+    "_blake2.blake2s.__str__" => "Return str(self).",
+    "_blake2.blake2s.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_blake2.blake2s.copy" => "Return a copy of the hash object.",
+    "_blake2.blake2s.digest" => "Return the digest value as a bytes object.",
+    "_blake2.blake2s.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_blake2.blake2s.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_bz2.BZ2Compressor" => "Create a compressor object for compressing data incrementally.\n\n  compresslevel\n    Compression level, as a number between 1 and 9.\n\nFor one-shot compression, use the compress() function instead.",
+    "_bz2.BZ2Compressor.__delattr__" => "Implement delattr(self, name).",
+    "_bz2.BZ2Compressor.__eq__" => "Return self==value.",
+    "_bz2.BZ2Compressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_bz2.BZ2Compressor.__ge__" => "Return self>=value.",
+    "_bz2.BZ2Compressor.__getattribute__" => "Return getattr(self, name).",
+    "_bz2.BZ2Compressor.__getstate__" => "Helper for pickle.",
+    "_bz2.BZ2Compressor.__gt__" => "Return self>value.",
+    "_bz2.BZ2Compressor.__hash__" => "Return hash(self).",
+    "_bz2.BZ2Compressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_bz2.BZ2Compressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_bz2.BZ2Compressor.__le__" => "Return self<=value.",
+    "_bz2.BZ2Compressor.__lt__" => "Return self<value.",
+    "_bz2.BZ2Compressor.__ne__" => "Return self!=value.",
+    "_bz2.BZ2Compressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_bz2.BZ2Compressor.__reduce__" => "Helper for pickle.",
+    "_bz2.BZ2Compressor.__reduce_ex__" => "Helper for pickle.",
+    "_bz2.BZ2Compressor.__repr__" => "Return repr(self).",
+    "_bz2.BZ2Compressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_bz2.BZ2Compressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_bz2.BZ2Compressor.__str__" => "Return str(self).",
+    "_bz2.BZ2Compressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_bz2.BZ2Compressor.compress" => "Provide data to the compressor object.\n\nReturns a chunk of compressed data if possible, or b'' otherwise.\n\nWhen you have finished providing data to the compressor, call the\nflush() method to finish the compression process.",
+    "_bz2.BZ2Compressor.flush" => "Finish the compression process.\n\nReturns the compressed data left in internal buffers.\n\nThe compressor object may not be used after this method is called.",
+    "_bz2.BZ2Decompressor" => "Create a decompressor object for decompressing data incrementally.\n\nFor one-shot decompression, use the decompress() function instead.",
+    "_bz2.BZ2Decompressor.__delattr__" => "Implement delattr(self, name).",
+    "_bz2.BZ2Decompressor.__eq__" => "Return self==value.",
+    "_bz2.BZ2Decompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_bz2.BZ2Decompressor.__ge__" => "Return self>=value.",
+    "_bz2.BZ2Decompressor.__getattribute__" => "Return getattr(self, name).",
+    "_bz2.BZ2Decompressor.__getstate__" => "Helper for pickle.",
+    "_bz2.BZ2Decompressor.__gt__" => "Return self>value.",
+    "_bz2.BZ2Decompressor.__hash__" => "Return hash(self).",
+    "_bz2.BZ2Decompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_bz2.BZ2Decompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_bz2.BZ2Decompressor.__le__" => "Return self<=value.",
+    "_bz2.BZ2Decompressor.__lt__" => "Return self<value.",
+    "_bz2.BZ2Decompressor.__ne__" => "Return self!=value.",
+    "_bz2.BZ2Decompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_bz2.BZ2Decompressor.__reduce__" => "Helper for pickle.",
+    "_bz2.BZ2Decompressor.__reduce_ex__" => "Helper for pickle.",
+    "_bz2.BZ2Decompressor.__repr__" => "Return repr(self).",
+    "_bz2.BZ2Decompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_bz2.BZ2Decompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_bz2.BZ2Decompressor.__str__" => "Return str(self).",
+    "_bz2.BZ2Decompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_bz2.BZ2Decompressor.decompress" => "Decompress *data*, returning uncompressed data as bytes.\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 stream is reached raises an\nEOFError.  Any data found after the end of the stream is ignored and saved in\nthe unused_data attribute.",
+    "_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.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.",
+    "_codecs.lookup_error" => "lookup_error(errors) -> handler\n\nReturn the error handler for the specified error handling name or raise a\nLookupError, if no handler exists under this name.",
+    "_codecs.register" => "Register a codec search function.\n\nSearch functions are expected to take one argument, the encoding name in\nall lower case letters, and either return None, or a tuple of functions\n(encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).",
+    "_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._count_elements" => "Count elements in the iterable, updating the mapping",
+    "_contextvars" => "Context Variables",
+    "_contextvars.Context.__contains__" => "Return bool(key in self).",
+    "_contextvars.Context.__delattr__" => "Implement delattr(self, name).",
+    "_contextvars.Context.__eq__" => "Return self==value.",
+    "_contextvars.Context.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_contextvars.Context.__ge__" => "Return self>=value.",
+    "_contextvars.Context.__getattribute__" => "Return getattr(self, name).",
+    "_contextvars.Context.__getitem__" => "Return self[key].",
+    "_contextvars.Context.__getstate__" => "Helper for pickle.",
+    "_contextvars.Context.__gt__" => "Return self>value.",
+    "_contextvars.Context.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_contextvars.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.",
+    "_contextvars.Context.__iter__" => "Implement iter(self).",
+    "_contextvars.Context.__le__" => "Return self<=value.",
+    "_contextvars.Context.__len__" => "Return len(self).",
+    "_contextvars.Context.__lt__" => "Return self<value.",
+    "_contextvars.Context.__ne__" => "Return self!=value.",
+    "_contextvars.Context.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_contextvars.Context.__reduce__" => "Helper for pickle.",
+    "_contextvars.Context.__reduce_ex__" => "Helper for pickle.",
+    "_contextvars.Context.__repr__" => "Return repr(self).",
+    "_contextvars.Context.__setattr__" => "Implement setattr(self, name, value).",
+    "_contextvars.Context.__sizeof__" => "Size of object in memory, in bytes.",
+    "_contextvars.Context.__str__" => "Return str(self).",
+    "_contextvars.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).",
+    "_contextvars.Context.copy" => "Return a shallow copy of the context object.",
+    "_contextvars.Context.get" => "Return the value for `key` if `key` has the value in the context object.\n\nIf `key` does not exist, return `default`. If `default` is not given,\nreturn None.",
+    "_contextvars.Context.items" => "Return all variables and their values in the context object.\n\nThe result is returned as a list of 2-tuples (variable, value).",
+    "_contextvars.Context.keys" => "Return a list of all variables in the context object.",
+    "_contextvars.Context.values" => "Return a list of all variables' values in the context object.",
+    "_contextvars.ContextVar.__class_getitem__" => "See PEP 585",
+    "_contextvars.ContextVar.__delattr__" => "Implement delattr(self, name).",
+    "_contextvars.ContextVar.__eq__" => "Return self==value.",
+    "_contextvars.ContextVar.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_contextvars.ContextVar.__ge__" => "Return self>=value.",
+    "_contextvars.ContextVar.__getattribute__" => "Return getattr(self, name).",
+    "_contextvars.ContextVar.__getstate__" => "Helper for pickle.",
+    "_contextvars.ContextVar.__gt__" => "Return self>value.",
+    "_contextvars.ContextVar.__hash__" => "Return hash(self).",
+    "_contextvars.ContextVar.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_contextvars.ContextVar.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_contextvars.ContextVar.__le__" => "Return self<=value.",
+    "_contextvars.ContextVar.__lt__" => "Return self<value.",
+    "_contextvars.ContextVar.__ne__" => "Return self!=value.",
+    "_contextvars.ContextVar.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_contextvars.ContextVar.__reduce__" => "Helper for pickle.",
+    "_contextvars.ContextVar.__reduce_ex__" => "Helper for pickle.",
+    "_contextvars.ContextVar.__repr__" => "Return repr(self).",
+    "_contextvars.ContextVar.__setattr__" => "Implement setattr(self, name, value).",
+    "_contextvars.ContextVar.__sizeof__" => "Size of object in memory, in bytes.",
+    "_contextvars.ContextVar.__str__" => "Return str(self).",
+    "_contextvars.ContextVar.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_contextvars.ContextVar.get" => "Return a value for the context variable for the current context.\n\nIf there is no value for the variable in the current context, the method will:\n * return the value of the default argument of the method, if provided; or\n * return the default value for the context variable, if it was created\n   with one; or\n * raise a LookupError.",
+    "_contextvars.ContextVar.reset" => "Reset the context variable.\n\nThe variable is reset to the value it had before the `ContextVar.set()` that\ncreated the token was used.",
+    "_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.__eq__" => "Return self==value.",
+    "_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).",
+    "_contextvars.Token.__getstate__" => "Helper for pickle.",
+    "_contextvars.Token.__gt__" => "Return self>value.",
+    "_contextvars.Token.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_contextvars.Token.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_contextvars.Token.__le__" => "Return self<=value.",
+    "_contextvars.Token.__lt__" => "Return self<value.",
+    "_contextvars.Token.__ne__" => "Return self!=value.",
+    "_contextvars.Token.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_contextvars.Token.__reduce__" => "Helper for pickle.",
+    "_contextvars.Token.__reduce_ex__" => "Helper for pickle.",
+    "_contextvars.Token.__repr__" => "Return repr(self).",
+    "_contextvars.Token.__setattr__" => "Implement setattr(self, name, value).",
+    "_contextvars.Token.__sizeof__" => "Size of object in memory, in bytes.",
+    "_contextvars.Token.__str__" => "Return str(self).",
+    "_contextvars.Token.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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" => "CSV parsing and writing.",
+    "_csv.Dialect" => "CSV dialect\n\nThe Dialect type records CSV parsing and generation options.",
+    "_csv.Dialect.__delattr__" => "Implement delattr(self, name).",
+    "_csv.Dialect.__eq__" => "Return self==value.",
+    "_csv.Dialect.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_csv.Dialect.__ge__" => "Return self>=value.",
+    "_csv.Dialect.__getattribute__" => "Return getattr(self, name).",
+    "_csv.Dialect.__getstate__" => "Helper for pickle.",
+    "_csv.Dialect.__gt__" => "Return self>value.",
+    "_csv.Dialect.__hash__" => "Return hash(self).",
+    "_csv.Dialect.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_csv.Dialect.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_csv.Dialect.__le__" => "Return self<=value.",
+    "_csv.Dialect.__lt__" => "Return self<value.",
+    "_csv.Dialect.__ne__" => "Return self!=value.",
+    "_csv.Dialect.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_csv.Dialect.__reduce__" => "raises an exception to avoid pickling",
+    "_csv.Dialect.__reduce_ex__" => "raises an exception to avoid pickling",
+    "_csv.Dialect.__repr__" => "Return repr(self).",
+    "_csv.Dialect.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.",
+    "_csv.Error.__ge__" => "Return self>=value.",
+    "_csv.Error.__getattribute__" => "Return getattr(self, name).",
+    "_csv.Error.__getstate__" => "Helper for pickle.",
+    "_csv.Error.__gt__" => "Return self>value.",
+    "_csv.Error.__hash__" => "Return hash(self).",
+    "_csv.Error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_csv.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.",
+    "_csv.Error.__le__" => "Return self<=value.",
+    "_csv.Error.__lt__" => "Return self<value.",
+    "_csv.Error.__ne__" => "Return self!=value.",
+    "_csv.Error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_csv.Error.__reduce_ex__" => "Helper for pickle.",
+    "_csv.Error.__repr__" => "Return repr(self).",
+    "_csv.Error.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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.",
+    "_csv.Reader.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_csv.Reader.__ge__" => "Return self>=value.",
+    "_csv.Reader.__getattribute__" => "Return getattr(self, name).",
+    "_csv.Reader.__getstate__" => "Helper for pickle.",
+    "_csv.Reader.__gt__" => "Return self>value.",
+    "_csv.Reader.__hash__" => "Return hash(self).",
+    "_csv.Reader.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_csv.Reader.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_csv.Reader.__iter__" => "Implement iter(self).",
+    "_csv.Reader.__le__" => "Return self<=value.",
+    "_csv.Reader.__lt__" => "Return self<value.",
+    "_csv.Reader.__ne__" => "Return self!=value.",
+    "_csv.Reader.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_csv.Reader.__next__" => "Implement next(self).",
+    "_csv.Reader.__reduce__" => "Helper for pickle.",
+    "_csv.Reader.__reduce_ex__" => "Helper for pickle.",
+    "_csv.Reader.__repr__" => "Return repr(self).",
+    "_csv.Reader.__setattr__" => "Implement setattr(self, name, value).",
+    "_csv.Reader.__sizeof__" => "Size of object in memory, in bytes.",
+    "_csv.Reader.__str__" => "Return str(self).",
+    "_csv.Reader.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.Writer" => "CSV writer\n\nWriter objects are responsible for generating tabular data\nin CSV format from sequence input.",
+    "_csv.Writer.__delattr__" => "Implement delattr(self, name).",
+    "_csv.Writer.__eq__" => "Return self==value.",
+    "_csv.Writer.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_csv.Writer.__ge__" => "Return self>=value.",
+    "_csv.Writer.__getattribute__" => "Return getattr(self, name).",
+    "_csv.Writer.__getstate__" => "Helper for pickle.",
+    "_csv.Writer.__gt__" => "Return self>value.",
+    "_csv.Writer.__hash__" => "Return hash(self).",
+    "_csv.Writer.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_csv.Writer.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_csv.Writer.__le__" => "Return self<=value.",
+    "_csv.Writer.__lt__" => "Return self<value.",
+    "_csv.Writer.__ne__" => "Return self!=value.",
+    "_csv.Writer.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_csv.Writer.__reduce__" => "Helper for pickle.",
+    "_csv.Writer.__reduce_ex__" => "Helper for pickle.",
+    "_csv.Writer.__repr__" => "Return repr(self).",
+    "_csv.Writer.__setattr__" => "Implement setattr(self, name, value).",
+    "_csv.Writer.__sizeof__" => "Size of object in memory, in bytes.",
+    "_csv.Writer.__str__" => "Return str(self).",
+    "_csv.Writer.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.Writer.writerow" => "Construct and write a CSV record from an iterable of fields.\n\nNon-string elements will be converted to string.",
+    "_csv.Writer.writerows" => "Construct and write a series of iterables to a csv file.\n\nNon-string elements will be converted to string.",
+    "_csv.field_size_limit" => "Sets an upper limit on parsed fields.\n\nReturns old limit. If limit is not given, no new limit is set and\nthe old limit is returned",
+    "_csv.get_dialect" => "Return the dialect instance associated with name.",
+    "_csv.list_dialects" => "Return a list of all known dialect names.",
+    "_csv.reader" => "Return a reader object that will process lines from the given iterable.\n\nThe \"iterable\" argument can be any object that returns a line\nof input for each iteration, such as a file object or a list.  The\noptional \"dialect\" argument defines a CSV dialect.  The function\nalso accepts optional keyword arguments which override settings\nprovided by the dialect.\n\nThe returned object is an iterator.  Each iteration returns a row\nof the CSV file (which can span multiple input lines).",
+    "_csv.register_dialect" => "Create a mapping from a string name to a CVS dialect.\n\nThe optional \"dialect\" argument specifies the base dialect instance\nor the name of the registered dialect.  The function also accepts\noptional keyword arguments which override settings provided by the\ndialect.",
+    "_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.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.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.",
+    "_ctypes.COMError.__ge__" => "Return self>=value.",
+    "_ctypes.COMError.__getattribute__" => "Return getattr(self, name).",
+    "_ctypes.COMError.__getstate__" => "Helper for pickle.",
+    "_ctypes.COMError.__gt__" => "Return self>value.",
+    "_ctypes.COMError.__hash__" => "Return hash(self).",
+    "_ctypes.COMError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ctypes.COMError.__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.COMError.__le__" => "Return self<=value.",
+    "_ctypes.COMError.__lt__" => "Return self<value.",
+    "_ctypes.COMError.__ne__" => "Return self!=value.",
+    "_ctypes.COMError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ctypes.COMError.__reduce_ex__" => "Helper for pickle.",
+    "_ctypes.COMError.__repr__" => "Return repr(self).",
+    "_ctypes.COMError.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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.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.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",
+    "_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.",
+    "_curses.cbreak" => "Enter cbreak mode.\n\n  flag\n    If false, the effect is the same as calling nocbreak().\n\nIn cbreak mode (sometimes called \"rare\" mode) normal tty line buffering is\nturned off and characters are available to be read one by one.  However,\nunlike raw mode, special characters (interrupt, quit, suspend, and flow\ncontrol) retain their effects on the tty driver and calling program.\nCalling first raw() then cbreak() leaves the terminal in cbreak mode.",
+    "_curses.color_content" => "Return the red, green, and blue (RGB) components of the specified color.\n\n  color_number\n    The number of the color (0 - (COLORS-1)).\n\nA 3-tuple is returned, containing the R, G, B values for the given color,\nwhich will be between 0 (no component) and 1000 (maximum amount of component).",
+    "_curses.color_pair" => "Return the attribute value for displaying text in the specified color.\n\n  pair_number\n    The number of the color pair.\n\nThis attribute value can be combined with A_STANDOUT, A_REVERSE, and the\nother A_* attributes.  pair_number() is the counterpart to this function.",
+    "_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.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.",
+    "_curses.error.__ge__" => "Return self>=value.",
+    "_curses.error.__getattribute__" => "Return getattr(self, name).",
+    "_curses.error.__getstate__" => "Helper for pickle.",
+    "_curses.error.__gt__" => "Return self>value.",
+    "_curses.error.__hash__" => "Return hash(self).",
+    "_curses.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_curses.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.",
+    "_curses.error.__le__" => "Return self<=value.",
+    "_curses.error.__lt__" => "Return self<value.",
+    "_curses.error.__ne__" => "Return self!=value.",
+    "_curses.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_curses.error.__reduce_ex__" => "Helper for pickle.",
+    "_curses.error.__repr__" => "Return repr(self).",
+    "_curses.error.__setattr__" => "Implement setattr(self, name, value).",
+    "_curses.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_curses.get_tabsize" => "Gets the curses TABSIZE setting.\n\nGets 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.getmouse" => "Retrieve the queued mouse event.\n\nAfter getch() returns KEY_MOUSE to signal a mouse event, this function\nreturns a 5-tuple (id, x, y, z, bstate).",
+    "_curses.getsyx" => "Return the current coordinates of the virtual screen cursor.\n\nReturn a (y, x) tuple.  If leaveok is currently true, return (-1, -1).",
+    "_curses.getwin" => "Read window related data stored in the file by an earlier putwin() call.\n\nThe routine then creates and initializes a new window using that data,\nreturning the new window object.",
+    "_curses.halfdelay" => "Enter half-delay mode.\n\n  tenths\n    Maximal blocking delay in tenths of seconds (1 - 255).\n\nUse nocbreak() to leave half-delay mode.",
+    "_curses.has_colors" => "Return True if the terminal can display colors; otherwise, return False.",
+    "_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.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.isendwin" => "Return True if endwin() has been called.",
+    "_curses.keyname" => "Return the name of specified key.\n\nkey\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.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.",
+    "_curses.noecho" => "Leave echo mode.\n\nEchoing of input characters is turned off.",
+    "_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_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.",
+    "_curses.raw" => "Enter raw mode.\n\n  flag\n    If false, the effect is the same as calling noraw().\n\nIn raw mode, normal line buffering and processing of interrupt, quit,\nsuspend, and flow control keys are turned off; characters are presented to\ncurses input functions one by one.",
+    "_curses.reset_prog_mode" => "Restore the terminal to \"program\" mode, as previously saved by def_prog_mode().",
+    "_curses.reset_shell_mode" => "Restore the terminal to \"shell\" mode, as previously saved by def_shell_mode().",
+    "_curses.resetty" => "Restore terminal mode.",
+    "_curses.resize_term" => "Backend function used by resizeterm(), performing most of the work.\n\n  nlines\n    Height.\n  ncols\n    Width.\n\nWhen resizing the windows, resize_term() blank-fills the areas that are\nextended.  The calling application should fill in these areas with appropriate\ndata.  The resize_term() function attempts to resize all windows.  However,\ndue to the calling convention of pads, it is not possible to resize these\nwithout additional interaction with the application.",
+    "_curses.resizeterm" => "Resize the standard and current windows to the specified dimensions.\n\n  nlines\n    Height.\n  ncols\n    Width.\n\nAdjusts other bookkeeping data used by the curses library that record the\nwindow dimensions (in particular the SIGWINCH handler).",
+    "_curses.savetty" => "Save terminal mode.",
+    "_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.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.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_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.",
+    "_curses.window.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_curses.window.__ge__" => "Return self>=value.",
+    "_curses.window.__getattribute__" => "Return getattr(self, name).",
+    "_curses.window.__getstate__" => "Helper for pickle.",
+    "_curses.window.__gt__" => "Return self>value.",
+    "_curses.window.__hash__" => "Return hash(self).",
+    "_curses.window.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_curses.window.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_curses.window.__le__" => "Return self<=value.",
+    "_curses.window.__lt__" => "Return self<value.",
+    "_curses.window.__ne__" => "Return self!=value.",
+    "_curses.window.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_curses.window.__reduce__" => "Helper for pickle.",
+    "_curses.window.__reduce_ex__" => "Helper for pickle.",
+    "_curses.window.__repr__" => "Return repr(self).",
+    "_curses.window.__setattr__" => "Implement setattr(self, name, value).",
+    "_curses.window.__sizeof__" => "Size of object in memory, in bytes.",
+    "_curses.window.__str__" => "Return str(self).",
+    "_curses.window.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.window.addch" => "addch([y, x,] ch, [attr=_curses.A_NORMAL])\nPaint the character.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n  ch\n    Character to add.\n  attr\n    Attributes for the character.\n\nPaint character ch at (y, x) with attributes attr,\noverwriting any character previously painted at that location.\nBy default, the character position and attributes are the\ncurrent settings for the window object.",
+    "_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.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.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.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.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.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.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.",
+    "_curses.window.overwrite" => "overwrite(destwin, [sminrow, smincol, dminrow, dmincol, dmaxrow,\n          dmaxcol])\nOverwrite the window on top of destwin.\n\nThe windows need not be the same size, in which case only the overlapping\nregion is copied.  This copy is destructive, which means that the current\nbackground character overwrites the old contents of destwin.\n\nTo get fine-grained control over the copied region, the second form of\noverwrite() can be used. sminrow and smincol are the upper-left coordinates\nof the source window, the other variables mark a rectangle in the destination\nwindow.",
+    "_curses.window.putwin" => "Write all data associated with the window into the provided file object.\n\nThis information can be later retrieved using the getwin() function.",
+    "_curses.window.redrawln" => "Mark the specified lines corrupted.\n\n  beg\n    Starting line number.\n  num\n    The number of lines.\n\nThey should be completely redrawn on the next refresh() call.",
+    "_curses.window.refresh" => "refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])\nUpdate the display immediately.\n\nSynchronize actual screen with previous drawing/deleting methods.\nThe 6 optional arguments can only be specified when the window is a pad\ncreated with newpad().  The additional parameters are needed to indicate\nwhat part of the pad and screen are involved.  pminrow and pmincol specify\nthe upper left-hand corner of the rectangle to be displayed in the pad.\nsminrow, smincol, smaxrow, and smaxcol specify the edges of the rectangle to\nbe displayed on the screen.  The lower right-hand corner of the rectangle to\nbe displayed in the pad is calculated from the screen coordinates, since the\nrectangles must be the same size.  Both rectangles must be entirely contained\nwithin their respective structures.  Negative values of pminrow, pmincol,\nsminrow, or smincol are treated as if they were zero.",
+    "_curses.window.scroll" => "scroll([lines=1])\nScroll the screen or scrolling region.\n\n  lines\n    Number of lines to scroll.\n\nScroll upward if the argument is positive and downward if it is negative.",
+    "_curses.window.setscrreg" => "Define a software scrolling region.\n\n  top\n    First line number.\n  bottom\n    Last line number.\n\nAll scrolling actions will take place in this region.",
+    "_curses.window.subpad" => "subwin([nlines=0, ncols=0,] begin_y, begin_x)\nCreate a sub-window (screen-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\nBy default, the sub-window will extend from the specified position to the\nlower right corner of the window.",
+    "_curses.window.subwin" => "subwin([nlines=0, ncols=0,] begin_y, begin_x)\nCreate a sub-window (screen-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\nBy default, the sub-window will extend from the specified position to the\nlower right corner of the window.",
+    "_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.",
+    "_curses_panel.error.__ge__" => "Return self>=value.",
+    "_curses_panel.error.__getattribute__" => "Return getattr(self, name).",
+    "_curses_panel.error.__getstate__" => "Helper for pickle.",
+    "_curses_panel.error.__gt__" => "Return self>value.",
+    "_curses_panel.error.__hash__" => "Return hash(self).",
+    "_curses_panel.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_curses_panel.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.",
+    "_curses_panel.error.__le__" => "Return self<=value.",
+    "_curses_panel.error.__lt__" => "Return self<value.",
+    "_curses_panel.error.__ne__" => "Return self!=value.",
+    "_curses_panel.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_curses_panel.error.__reduce_ex__" => "Helper for pickle.",
+    "_curses_panel.error.__repr__" => "Return repr(self).",
+    "_curses_panel.error.__setattr__" => "Implement setattr(self, name, value).",
+    "_curses_panel.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_curses_panel.panel.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_curses_panel.panel.__ge__" => "Return self>=value.",
+    "_curses_panel.panel.__getattribute__" => "Return getattr(self, name).",
+    "_curses_panel.panel.__getstate__" => "Helper for pickle.",
+    "_curses_panel.panel.__gt__" => "Return self>value.",
+    "_curses_panel.panel.__hash__" => "Return hash(self).",
+    "_curses_panel.panel.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_curses_panel.panel.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_curses_panel.panel.__le__" => "Return self<=value.",
+    "_curses_panel.panel.__lt__" => "Return self<value.",
+    "_curses_panel.panel.__ne__" => "Return self!=value.",
+    "_curses_panel.panel.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_curses_panel.panel.__reduce__" => "Helper for pickle.",
+    "_curses_panel.panel.__reduce_ex__" => "Helper for pickle.",
+    "_curses_panel.panel.__repr__" => "Return repr(self).",
+    "_curses_panel.panel.__setattr__" => "Implement setattr(self, name, value).",
+    "_curses_panel.panel.__sizeof__" => "Size of object in memory, in bytes.",
+    "_curses_panel.panel.__str__" => "Return str(self).",
+    "_curses_panel.panel.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.panel.above" => "Return the panel above the current panel.",
+    "_curses_panel.panel.below" => "Return the panel below the current panel.",
+    "_curses_panel.panel.bottom" => "Push the panel to the bottom of the stack.",
+    "_curses_panel.panel.hidden" => "Return True if the panel is hidden (not visible), False otherwise.",
+    "_curses_panel.panel.hide" => "Hide the panel.\n\nThis does not delete the object, it just makes the window on screen invisible.",
+    "_curses_panel.panel.move" => "Move the panel to the screen coordinates (y, x).",
+    "_curses_panel.panel.replace" => "Change the window associated with the panel to the window win.",
+    "_curses_panel.panel.set_userptr" => "Set the panel's user pointer to obj.",
+    "_curses_panel.panel.show" => "Display the panel (which might have been hidden).",
+    "_curses_panel.panel.top" => "Push panel to the top of the stack.",
+    "_curses_panel.panel.userptr" => "Return the user pointer for the panel.",
+    "_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",
+    "_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.",
+    "_dbm.error.__ge__" => "Return self>=value.",
+    "_dbm.error.__getattribute__" => "Return getattr(self, name).",
+    "_dbm.error.__getstate__" => "Helper for pickle.",
+    "_dbm.error.__gt__" => "Return self>value.",
+    "_dbm.error.__hash__" => "Return hash(self).",
+    "_dbm.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_dbm.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.",
+    "_dbm.error.__le__" => "Return self<=value.",
+    "_dbm.error.__lt__" => "Return self<value.",
+    "_dbm.error.__ne__" => "Return self!=value.",
+    "_dbm.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_dbm.error.__reduce_ex__" => "Helper for pickle.",
+    "_dbm.error.__repr__" => "Return repr(self).",
+    "_dbm.error.__setattr__" => "Implement setattr(self, name, value).",
+    "_dbm.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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).",
+    "_decimal" => "C decimal arithmetic module",
+    "_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._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).",
+    "_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.",
+    "_gdbm.error.__ge__" => "Return self>=value.",
+    "_gdbm.error.__getattribute__" => "Return getattr(self, name).",
+    "_gdbm.error.__getstate__" => "Helper for pickle.",
+    "_gdbm.error.__gt__" => "Return self>value.",
+    "_gdbm.error.__hash__" => "Return hash(self).",
+    "_gdbm.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_gdbm.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.",
+    "_gdbm.error.__le__" => "Return self<=value.",
+    "_gdbm.error.__lt__" => "Return self<value.",
+    "_gdbm.error.__ne__" => "Return self!=value.",
+    "_gdbm.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_gdbm.error.__reduce_ex__" => "Helper for pickle.",
+    "_gdbm.error.__repr__" => "Return repr(self).",
+    "_gdbm.error.__setattr__" => "Implement setattr(self, name, value).",
+    "_gdbm.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.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",
+    "_hashlib.HASH.__delattr__" => "Implement delattr(self, name).",
+    "_hashlib.HASH.__eq__" => "Return self==value.",
+    "_hashlib.HASH.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_hashlib.HASH.__ge__" => "Return self>=value.",
+    "_hashlib.HASH.__getattribute__" => "Return getattr(self, name).",
+    "_hashlib.HASH.__getstate__" => "Helper for pickle.",
+    "_hashlib.HASH.__gt__" => "Return self>value.",
+    "_hashlib.HASH.__hash__" => "Return hash(self).",
+    "_hashlib.HASH.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hashlib.HASH.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_hashlib.HASH.__le__" => "Return self<=value.",
+    "_hashlib.HASH.__lt__" => "Return self<value.",
+    "_hashlib.HASH.__ne__" => "Return self!=value.",
+    "_hashlib.HASH.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hashlib.HASH.__reduce__" => "Helper for pickle.",
+    "_hashlib.HASH.__reduce_ex__" => "Helper for pickle.",
+    "_hashlib.HASH.__repr__" => "Return repr(self).",
+    "_hashlib.HASH.__setattr__" => "Implement setattr(self, name, value).",
+    "_hashlib.HASH.__sizeof__" => "Size of object in memory, in bytes.",
+    "_hashlib.HASH.__str__" => "Return str(self).",
+    "_hashlib.HASH.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.HASH.copy" => "Return a copy of the hash object.",
+    "_hashlib.HASH.digest" => "Return the digest value as a bytes object.",
+    "_hashlib.HASH.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_hashlib.HASH.update" => "Update this hash object's state with the provided string.",
+    "_hashlib.HASHXOF" => "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(length) -- return the current digest value\nhexdigest(length) -- 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",
+    "_hashlib.HASHXOF.__delattr__" => "Implement delattr(self, name).",
+    "_hashlib.HASHXOF.__eq__" => "Return self==value.",
+    "_hashlib.HASHXOF.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_hashlib.HASHXOF.__ge__" => "Return self>=value.",
+    "_hashlib.HASHXOF.__getattribute__" => "Return getattr(self, name).",
+    "_hashlib.HASHXOF.__getstate__" => "Helper for pickle.",
+    "_hashlib.HASHXOF.__gt__" => "Return self>value.",
+    "_hashlib.HASHXOF.__hash__" => "Return hash(self).",
+    "_hashlib.HASHXOF.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hashlib.HASHXOF.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_hashlib.HASHXOF.__le__" => "Return self<=value.",
+    "_hashlib.HASHXOF.__lt__" => "Return self<value.",
+    "_hashlib.HASHXOF.__ne__" => "Return self!=value.",
+    "_hashlib.HASHXOF.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hashlib.HASHXOF.__reduce__" => "Helper for pickle.",
+    "_hashlib.HASHXOF.__reduce_ex__" => "Helper for pickle.",
+    "_hashlib.HASHXOF.__repr__" => "Return repr(self).",
+    "_hashlib.HASHXOF.__setattr__" => "Implement setattr(self, name, value).",
+    "_hashlib.HASHXOF.__sizeof__" => "Size of object in memory, in bytes.",
+    "_hashlib.HASHXOF.__str__" => "Return str(self).",
+    "_hashlib.HASHXOF.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.HASHXOF.copy" => "Return a copy of the hash object.",
+    "_hashlib.HASHXOF.digest" => "Return the digest value as a bytes object.",
+    "_hashlib.HASHXOF.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_hashlib.HASHXOF.update" => "Update this hash object's state with the provided string.",
+    "_hashlib.HMAC" => "The object used to calculate HMAC of a message.\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 name, including the hash algorithm used by this object\ndigest_size -- number of bytes in digest() output",
+    "_hashlib.HMAC.__delattr__" => "Implement delattr(self, name).",
+    "_hashlib.HMAC.__eq__" => "Return self==value.",
+    "_hashlib.HMAC.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_hashlib.HMAC.__ge__" => "Return self>=value.",
+    "_hashlib.HMAC.__getattribute__" => "Return getattr(self, name).",
+    "_hashlib.HMAC.__getstate__" => "Helper for pickle.",
+    "_hashlib.HMAC.__gt__" => "Return self>value.",
+    "_hashlib.HMAC.__hash__" => "Return hash(self).",
+    "_hashlib.HMAC.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hashlib.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.",
+    "_hashlib.HMAC.__le__" => "Return self<=value.",
+    "_hashlib.HMAC.__lt__" => "Return self<value.",
+    "_hashlib.HMAC.__ne__" => "Return self!=value.",
+    "_hashlib.HMAC.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hashlib.HMAC.__reduce__" => "Helper for pickle.",
+    "_hashlib.HMAC.__reduce_ex__" => "Helper for pickle.",
+    "_hashlib.HMAC.__repr__" => "Return repr(self).",
+    "_hashlib.HMAC.__setattr__" => "Implement setattr(self, name, value).",
+    "_hashlib.HMAC.__sizeof__" => "Size of object in memory, in bytes.",
+    "_hashlib.HMAC.__str__" => "Return str(self).",
+    "_hashlib.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).",
+    "_hashlib.HMAC.copy" => "Return a copy (\"clone\") of the HMAC object.",
+    "_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.",
+    "_hashlib.UnsupportedDigestmodError.__ge__" => "Return self>=value.",
+    "_hashlib.UnsupportedDigestmodError.__getattribute__" => "Return getattr(self, name).",
+    "_hashlib.UnsupportedDigestmodError.__getstate__" => "Helper for pickle.",
+    "_hashlib.UnsupportedDigestmodError.__gt__" => "Return self>value.",
+    "_hashlib.UnsupportedDigestmodError.__hash__" => "Return hash(self).",
+    "_hashlib.UnsupportedDigestmodError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_hashlib.UnsupportedDigestmodError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_hashlib.UnsupportedDigestmodError.__le__" => "Return self<=value.",
+    "_hashlib.UnsupportedDigestmodError.__lt__" => "Return self<value.",
+    "_hashlib.UnsupportedDigestmodError.__ne__" => "Return self!=value.",
+    "_hashlib.UnsupportedDigestmodError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_hashlib.UnsupportedDigestmodError.__reduce_ex__" => "Helper for pickle.",
+    "_hashlib.UnsupportedDigestmodError.__repr__" => "Return repr(self).",
+    "_hashlib.UnsupportedDigestmodError.__setattr__" => "Implement setattr(self, name, value).",
+    "_hashlib.UnsupportedDigestmodError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_hashlib.hmac_new" => "Return a new hmac object.",
+    "_hashlib.new" => "Return a new hash object using the named algorithm.\n\nAn optional string argument may be provided and will be\nautomatically hashed.\n\nThe MD5 and SHA1 algorithms are always supported.",
+    "_hashlib.openssl_md5" => "Returns a md5 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha1" => "Returns a sha1 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha224" => "Returns a sha224 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha256" => "Returns a sha256 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha384" => "Returns a sha384 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha3_224" => "Returns a sha3-224 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha3_256" => "Returns a sha3-256 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha3_384" => "Returns a sha3-384 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha3_512" => "Returns a sha3-512 hash object; optionally initialized with a string",
+    "_hashlib.openssl_sha512" => "Returns a sha512 hash object; optionally initialized with a string",
+    "_hashlib.openssl_shake_128" => "Returns a shake-128 variable hash object; optionally initialized with a string",
+    "_hashlib.openssl_shake_256" => "Returns a shake-256 variable hash object; optionally initialized with a string",
+    "_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.heappop" => "Pop the smallest item off the heap, maintaining the heap invariant.",
+    "_heapq.heappush" => "Push item onto 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.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)",
+    "_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._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)",
+    "_imp.acquire_lock" => "Acquires the interpreter's import lock for the current thread.\n\nThis lock should be used by import hooks to ensure thread-safety when importing\nmodules. On platforms without threads, this function does nothing.",
+    "_imp.create_builtin" => "Create an extension module.",
+    "_imp.create_dynamic" => "Create an extension module.",
+    "_imp.exec_builtin" => "Initialize a built-in module.",
+    "_imp.exec_dynamic" => "Initialize an extension module.",
+    "_imp.extension_suffixes" => "Returns the list of file suffixes used to identify extension modules.",
+    "_imp.find_frozen" => "Return info about the corresponding frozen module (if there is one) or None.\n\nThe returned info (a 2-tuple):\n\n * data         the raw marshalled bytes\n * is_package   whether or not it is a package\n * origname     the originally frozen module's name, or None if not\n                a stdlib module (this will usually be the same as\n                the module's current name)",
+    "_imp.get_frozen_object" => "Create a code object for a frozen module.",
+    "_imp.init_frozen" => "Initializes a frozen module.",
+    "_imp.is_builtin" => "Returns True if the module name corresponds to a built-in module.",
+    "_imp.is_frozen" => "Returns True if the module name corresponds to a frozen module.",
+    "_imp.is_frozen_package" => "Returns True if the module name is of a frozen package.",
+    "_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.",
+    "_interpchannels.ChannelClosedError.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelClosedError.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelClosedError.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelClosedError.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelClosedError.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelClosedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelClosedError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelClosedError.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelClosedError.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelClosedError.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelClosedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelClosedError.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelClosedError.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelClosedError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelClosedError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_interpchannels.ChannelEmptyError.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelEmptyError.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelEmptyError.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelEmptyError.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelEmptyError.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelEmptyError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelEmptyError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelEmptyError.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelEmptyError.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelEmptyError.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelEmptyError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelEmptyError.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelEmptyError.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelEmptyError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelEmptyError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_interpchannels.ChannelError.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelError.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelError.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelError.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelError.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelError.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelError.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelError.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelError.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelError.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_interpchannels.ChannelID.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpchannels.ChannelID.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelID.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelID.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelID.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelID.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelID.__index__" => "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    "_interpchannels.ChannelID.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelID.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelID.__int__" => "int(self)",
+    "_interpchannels.ChannelID.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelID.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelID.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelID.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelID.__reduce__" => "Helper for pickle.",
+    "_interpchannels.ChannelID.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelID.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelID.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelID.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpchannels.ChannelID.__str__" => "Return str(self).",
+    "_interpchannels.ChannelID.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.ChannelID.end" => "'send', 'recv', or 'both'",
+    "_interpchannels.ChannelID.recv" => "the 'recv' end of the channel",
+    "_interpchannels.ChannelID.send" => "the 'send' end of the channel",
+    "_interpchannels.ChannelInfo" => "ChannelInfo\n\nA named tuple of a channel's state.",
+    "_interpchannels.ChannelInfo.__add__" => "Return self+value.",
+    "_interpchannels.ChannelInfo.__class_getitem__" => "See PEP 585",
+    "_interpchannels.ChannelInfo.__contains__" => "Return bool(key in self).",
+    "_interpchannels.ChannelInfo.__delattr__" => "Implement delattr(self, name).",
+    "_interpchannels.ChannelInfo.__eq__" => "Return self==value.",
+    "_interpchannels.ChannelInfo.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpchannels.ChannelInfo.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelInfo.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelInfo.__getitem__" => "Return self[key].",
+    "_interpchannels.ChannelInfo.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelInfo.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelInfo.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelInfo.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelInfo.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelInfo.__iter__" => "Implement iter(self).",
+    "_interpchannels.ChannelInfo.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelInfo.__len__" => "Return len(self).",
+    "_interpchannels.ChannelInfo.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelInfo.__mul__" => "Return self*value.",
+    "_interpchannels.ChannelInfo.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelInfo.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelInfo.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelInfo.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_interpchannels.ChannelInfo.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelInfo.__rmul__" => "Return value*self.",
+    "_interpchannels.ChannelInfo.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelInfo.__sizeof__" => "Size of object in memory, in bytes.",
+    "_interpchannels.ChannelInfo.__str__" => "Return str(self).",
+    "_interpchannels.ChannelInfo.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.ChannelInfo.closed" => "both ends are closed",
+    "_interpchannels.ChannelInfo.closing" => "send is closed, recv is non-empty",
+    "_interpchannels.ChannelInfo.count" => "queued objects",
+    "_interpchannels.ChannelInfo.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_interpchannels.ChannelInfo.num_interp_both" => "interpreters bound to both ends",
+    "_interpchannels.ChannelInfo.num_interp_both_recv_released" => "interpreters bound to both ends and released_from_the recv end",
+    "_interpchannels.ChannelInfo.num_interp_both_released" => "interpreters bound to both ends and released_from_both",
+    "_interpchannels.ChannelInfo.num_interp_both_send_released" => "interpreters bound to both ends and released_from_the send end",
+    "_interpchannels.ChannelInfo.num_interp_recv" => "interpreters bound to the send end",
+    "_interpchannels.ChannelInfo.num_interp_recv_released" => "interpreters bound to the send end and released",
+    "_interpchannels.ChannelInfo.num_interp_send" => "interpreters bound to the send end",
+    "_interpchannels.ChannelInfo.num_interp_send_released" => "interpreters bound to the send end and released",
+    "_interpchannels.ChannelInfo.open" => "both ends are open",
+    "_interpchannels.ChannelInfo.recv_associated" => "current interpreter is bound to the recv end",
+    "_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.",
+    "_interpchannels.ChannelNotEmptyError.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelNotEmptyError.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelNotEmptyError.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelNotEmptyError.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelNotEmptyError.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelNotEmptyError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelNotEmptyError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelNotEmptyError.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelNotEmptyError.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelNotEmptyError.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelNotEmptyError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelNotEmptyError.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelNotEmptyError.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelNotEmptyError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelNotEmptyError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_interpchannels.ChannelNotFoundError.__ge__" => "Return self>=value.",
+    "_interpchannels.ChannelNotFoundError.__getattribute__" => "Return getattr(self, name).",
+    "_interpchannels.ChannelNotFoundError.__getstate__" => "Helper for pickle.",
+    "_interpchannels.ChannelNotFoundError.__gt__" => "Return self>value.",
+    "_interpchannels.ChannelNotFoundError.__hash__" => "Return hash(self).",
+    "_interpchannels.ChannelNotFoundError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpchannels.ChannelNotFoundError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_interpchannels.ChannelNotFoundError.__le__" => "Return self<=value.",
+    "_interpchannels.ChannelNotFoundError.__lt__" => "Return self<value.",
+    "_interpchannels.ChannelNotFoundError.__ne__" => "Return self!=value.",
+    "_interpchannels.ChannelNotFoundError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpchannels.ChannelNotFoundError.__reduce_ex__" => "Helper for pickle.",
+    "_interpchannels.ChannelNotFoundError.__repr__" => "Return repr(self).",
+    "_interpchannels.ChannelNotFoundError.__setattr__" => "Implement setattr(self, name, value).",
+    "_interpchannels.ChannelNotFoundError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_interpchannels.get_channel_defaults" => "get_channel_defaults(cid)\n\nReturn the channel's default values, set when it was created.",
+    "_interpchannels.get_count" => "get_count(cid)\n\nReturn the number of items in the channel.",
+    "_interpchannels.get_info" => "get_info(cid)\n\nReturn details about the channel.",
+    "_interpchannels.list_all" => "channel_list_all() -> [cid]\n\nReturn the list of all IDs for active channels.",
+    "_interpchannels.list_interpreters" => "channel_list_interpreters(cid, *, send) -> [id]\n\nReturn the list of all interpreter IDs associated with an end of the channel.\n\nThe 'send' argument should be a boolean indicating whether to use the send or\nreceive end.",
+    "_interpchannels.recv" => "channel_recv(cid, [default]) -> (obj, unboundop)\n\nReturn a new object from the data at the front of the channel's queue.\n\nIf there is nothing to receive then raise ChannelEmptyError, unless\na default value is provided.  In that case return it.",
+    "_interpchannels.release" => "channel_release(cid, *, send=None, recv=None, force=True)\n\nClose the channel for the current interpreter.  'send' and 'recv'\n(bool) may be used to indicate the ends to close.  By default both\nends are closed.  Closing an already closed end is a noop.",
+    "_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.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.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_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.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.",
+    "_interpreters.CrossInterpreterBufferView.__delattr__" => "Implement delattr(self, name).",
+    "_interpreters.CrossInterpreterBufferView.__eq__" => "Return self==value.",
+    "_interpreters.CrossInterpreterBufferView.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_interpreters.CrossInterpreterBufferView.__ge__" => "Return self>=value.",
+    "_interpreters.CrossInterpreterBufferView.__getattribute__" => "Return getattr(self, name).",
+    "_interpreters.CrossInterpreterBufferView.__getstate__" => "Helper for pickle.",
+    "_interpreters.CrossInterpreterBufferView.__gt__" => "Return self>value.",
+    "_interpreters.CrossInterpreterBufferView.__hash__" => "Return hash(self).",
+    "_interpreters.CrossInterpreterBufferView.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_interpreters.CrossInterpreterBufferView.__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.CrossInterpreterBufferView.__le__" => "Return self<=value.",
+    "_interpreters.CrossInterpreterBufferView.__lt__" => "Return self<value.",
+    "_interpreters.CrossInterpreterBufferView.__ne__" => "Return self!=value.",
+    "_interpreters.CrossInterpreterBufferView.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_interpreters.CrossInterpreterBufferView.__reduce__" => "Helper for pickle.",
+    "_interpreters.CrossInterpreterBufferView.__reduce_ex__" => "Helper for pickle.",
+    "_interpreters.CrossInterpreterBufferView.__repr__" => "Return repr(self).",
+    "_interpreters.CrossInterpreterBufferView.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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.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.",
+    "_interpreters.get_current" => "get_current() -> (ID, whence)\n\nReturn the ID of current interpreter.",
+    "_interpreters.get_main" => "get_main() -> (ID, whence)\n\nReturn the ID of main interpreter.",
+    "_interpreters.is_running" => "is_running(id, *, restrict=False) -> bool\n\nReturn whether or not the identified interpreter is running.",
+    "_interpreters.is_shareable" => "is_shareable(obj) -> bool\n\nReturn True if the object's data may be shared between interpreters and\nFalse otherwise.",
+    "_interpreters.list_all" => "list_all() -> [(ID, whence)]\n\nReturn a list containing the ID of every existing interpreter.",
+    "_interpreters.new_config" => "new_config(name='isolated', /, **overrides) -> type.SimpleNamespace\n\nReturn a representation of a new PyInterpreterConfig.\n\nThe name determines the initial values of the config.  Supported named\nconfigs are: default, isolated, legacy, and empty.\n\nAny keyword arguments are set on the corresponding config fields,\noverriding the initial values.",
+    "_interpreters.run_func" => "run_func(id, func, shared=None, *, restrict=False)\n\nExecute the body of the provided function in the identified interpreter.\nCode objects are also supported.  In both cases, closures and args\nare not supported.  Methods and other callables are not supported either.\n\n(See _interpreters.exec().",
+    "_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.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).",
+    "_io.BufferedRWPair.__eq__" => "Return self==value.",
+    "_io.BufferedRWPair.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BufferedRWPair.__ge__" => "Return self>=value.",
+    "_io.BufferedRWPair.__getattribute__" => "Return getattr(self, name).",
+    "_io.BufferedRWPair.__getstate__" => "Helper for pickle.",
+    "_io.BufferedRWPair.__gt__" => "Return self>value.",
+    "_io.BufferedRWPair.__hash__" => "Return hash(self).",
+    "_io.BufferedRWPair.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BufferedRWPair.__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.BufferedRWPair.__iter__" => "Implement iter(self).",
+    "_io.BufferedRWPair.__le__" => "Return self<=value.",
+    "_io.BufferedRWPair.__lt__" => "Return self<value.",
+    "_io.BufferedRWPair.__ne__" => "Return self!=value.",
+    "_io.BufferedRWPair.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BufferedRWPair.__next__" => "Implement next(self).",
+    "_io.BufferedRWPair.__reduce__" => "Helper for pickle.",
+    "_io.BufferedRWPair.__reduce_ex__" => "Helper for pickle.",
+    "_io.BufferedRWPair.__repr__" => "Return repr(self).",
+    "_io.BufferedRWPair.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BufferedRWPair.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.BufferedRWPair.__str__" => "Return str(self).",
+    "_io.BufferedRWPair.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.BufferedRWPair.detach" => "Disconnect this buffer from its underlying raw stream and return it.\n\nAfter the raw stream has been detached, the buffer is in an unusable\nstate.",
+    "_io.BufferedRWPair.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io.BufferedRWPair.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.BufferedRWPair.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.",
+    "_io.BufferedRWPair.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io.BufferedRWPair.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io.BufferedRWPair.tell" => "Return current stream position.",
+    "_io.BufferedRWPair.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_io.BufferedRWPair.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.BufferedRandom" => "A buffered interface to random access streams.\n\nThe constructor creates a reader and writer for a seekable stream,\nraw, given in the first argument. If the buffer_size is omitted it\ndefaults to DEFAULT_BUFFER_SIZE.",
+    "_io.BufferedRandom.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.BufferedRandom.__delattr__" => "Implement delattr(self, name).",
+    "_io.BufferedRandom.__eq__" => "Return self==value.",
+    "_io.BufferedRandom.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BufferedRandom.__ge__" => "Return self>=value.",
+    "_io.BufferedRandom.__getattribute__" => "Return getattr(self, name).",
+    "_io.BufferedRandom.__gt__" => "Return self>value.",
+    "_io.BufferedRandom.__hash__" => "Return hash(self).",
+    "_io.BufferedRandom.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BufferedRandom.__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.BufferedRandom.__iter__" => "Implement iter(self).",
+    "_io.BufferedRandom.__le__" => "Return self<=value.",
+    "_io.BufferedRandom.__lt__" => "Return self<value.",
+    "_io.BufferedRandom.__ne__" => "Return self!=value.",
+    "_io.BufferedRandom.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BufferedRandom.__next__" => "Implement next(self).",
+    "_io.BufferedRandom.__reduce__" => "Helper for pickle.",
+    "_io.BufferedRandom.__reduce_ex__" => "Helper for pickle.",
+    "_io.BufferedRandom.__repr__" => "Return repr(self).",
+    "_io.BufferedRandom.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BufferedRandom.__str__" => "Return str(self).",
+    "_io.BufferedRandom.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.BufferedRandom.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.",
+    "_io.BufferedRandom.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.BufferedReader" => "Create a new buffered reader using the given readable raw IO object.",
+    "_io.BufferedReader.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.BufferedReader.__delattr__" => "Implement delattr(self, name).",
+    "_io.BufferedReader.__eq__" => "Return self==value.",
+    "_io.BufferedReader.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BufferedReader.__ge__" => "Return self>=value.",
+    "_io.BufferedReader.__getattribute__" => "Return getattr(self, name).",
+    "_io.BufferedReader.__gt__" => "Return self>value.",
+    "_io.BufferedReader.__hash__" => "Return hash(self).",
+    "_io.BufferedReader.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BufferedReader.__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.BufferedReader.__iter__" => "Implement iter(self).",
+    "_io.BufferedReader.__le__" => "Return self<=value.",
+    "_io.BufferedReader.__lt__" => "Return self<value.",
+    "_io.BufferedReader.__ne__" => "Return self!=value.",
+    "_io.BufferedReader.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BufferedReader.__next__" => "Implement next(self).",
+    "_io.BufferedReader.__reduce__" => "Helper for pickle.",
+    "_io.BufferedReader.__reduce_ex__" => "Helper for pickle.",
+    "_io.BufferedReader.__repr__" => "Return repr(self).",
+    "_io.BufferedReader.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BufferedReader.__str__" => "Return str(self).",
+    "_io.BufferedReader.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.BufferedReader.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.",
+    "_io.BufferedReader.writable" => "Return whether object was opened for writing.\n\nIf False, write() will raise OSError.",
+    "_io.BufferedReader.write" => "Write buffer b to the IO stream.\n\nReturn the number of bytes written, which is always\nthe length of b in bytes.\n\nRaise BlockingIOError if the buffer is full and the\nunderlying raw stream cannot accept more data at the moment.",
+    "_io.BufferedReader.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.BufferedWriter" => "A buffer for a writeable sequential RawIO object.\n\nThe constructor creates a BufferedWriter for the given writeable raw\nstream. If the buffer_size is not given, it defaults to\nDEFAULT_BUFFER_SIZE.",
+    "_io.BufferedWriter.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.BufferedWriter.__delattr__" => "Implement delattr(self, name).",
+    "_io.BufferedWriter.__eq__" => "Return self==value.",
+    "_io.BufferedWriter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BufferedWriter.__ge__" => "Return self>=value.",
+    "_io.BufferedWriter.__getattribute__" => "Return getattr(self, name).",
+    "_io.BufferedWriter.__gt__" => "Return self>value.",
+    "_io.BufferedWriter.__hash__" => "Return hash(self).",
+    "_io.BufferedWriter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BufferedWriter.__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.BufferedWriter.__iter__" => "Implement iter(self).",
+    "_io.BufferedWriter.__le__" => "Return self<=value.",
+    "_io.BufferedWriter.__lt__" => "Return self<value.",
+    "_io.BufferedWriter.__ne__" => "Return self!=value.",
+    "_io.BufferedWriter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BufferedWriter.__next__" => "Implement next(self).",
+    "_io.BufferedWriter.__reduce__" => "Helper for pickle.",
+    "_io.BufferedWriter.__reduce_ex__" => "Helper for pickle.",
+    "_io.BufferedWriter.__repr__" => "Return repr(self).",
+    "_io.BufferedWriter.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BufferedWriter.__str__" => "Return str(self).",
+    "_io.BufferedWriter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.BufferedWriter.read" => "Read and return up to n bytes.\n\nIf the size argument is omitted, None, or negative, read and\nreturn all data until EOF.\n\nIf the size argument is positive, and the underlying raw stream is\nnot 'interactive', multiple raw reads may be issued to satisfy\nthe byte count (unless EOF is reached first).\nHowever, for interactive raw streams (as well as sockets and pipes),\nat most one raw read will be issued, and a short result does not\nimply that EOF is imminent.\n\nReturn an empty bytes object on EOF.\n\nReturn None if the underlying raw stream was open in non-blocking\nmode and no data is available at the moment.",
+    "_io.BufferedWriter.read1" => "Read and return up to size bytes, with at most one read() call to the underlying raw stream.\n\nReturn an empty bytes object on EOF.\nA short result does not imply that EOF is imminent.",
+    "_io.BufferedWriter.readable" => "Return whether object was opened for reading.\n\nIf False, read() will raise OSError.",
+    "_io.BufferedWriter.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.BufferedWriter.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.",
+    "_io.BufferedWriter.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.BytesIO" => "Buffered I/O implementation using an in-memory bytes buffer.",
+    "_io.BytesIO.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.BytesIO.__delattr__" => "Implement delattr(self, name).",
+    "_io.BytesIO.__eq__" => "Return self==value.",
+    "_io.BytesIO.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.BytesIO.__ge__" => "Return self>=value.",
+    "_io.BytesIO.__getattribute__" => "Return getattr(self, name).",
+    "_io.BytesIO.__gt__" => "Return self>value.",
+    "_io.BytesIO.__hash__" => "Return hash(self).",
+    "_io.BytesIO.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.BytesIO.__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.BytesIO.__iter__" => "Implement iter(self).",
+    "_io.BytesIO.__le__" => "Return self<=value.",
+    "_io.BytesIO.__lt__" => "Return self<value.",
+    "_io.BytesIO.__ne__" => "Return self!=value.",
+    "_io.BytesIO.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.BytesIO.__next__" => "Implement next(self).",
+    "_io.BytesIO.__reduce__" => "Helper for pickle.",
+    "_io.BytesIO.__reduce_ex__" => "Helper for pickle.",
+    "_io.BytesIO.__repr__" => "Return repr(self).",
+    "_io.BytesIO.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.BytesIO.__str__" => "Return str(self).",
+    "_io.BytesIO.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.BytesIO.close" => "Disable all I/O operations.",
+    "_io.BytesIO.closed" => "True if the file is closed.",
+    "_io.BytesIO.detach" => "Disconnect this buffer from its underlying raw stream and return it.\n\nAfter the raw stream has been detached, the buffer is in an unusable\nstate.",
+    "_io.BytesIO.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io.BytesIO.flush" => "Does nothing.",
+    "_io.BytesIO.getbuffer" => "Get a read-write view over the contents of the BytesIO object.",
+    "_io.BytesIO.getvalue" => "Retrieve the entire contents of the BytesIO object.",
+    "_io.BytesIO.isatty" => "Always returns False.\n\nBytesIO objects are not connected to a TTY-like device.",
+    "_io.BytesIO.read" => "Read at most size bytes, returned as a bytes object.\n\nIf the size argument is negative, read until EOF is reached.\nReturn an empty bytes object at EOF.",
+    "_io.BytesIO.read1" => "Read at most size bytes, returned as a bytes object.\n\nIf the size argument is negative or omitted, read until EOF is reached.\nReturn an empty bytes object at EOF.",
+    "_io.BytesIO.readable" => "Returns True if the IO object can be read.",
+    "_io.BytesIO.readinto" => "Read bytes into buffer.\n\nReturns number of bytes read (0 for EOF), or None if the object\nis set not to block and has no data to read.",
+    "_io.BytesIO.readline" => "Next line from the file, as a bytes object.\n\nRetain newline.  A non-negative size argument limits the maximum\nnumber of bytes to return (an incomplete line may be returned then).\nReturn an empty bytes object at EOF.",
+    "_io.BytesIO.readlines" => "List of bytes objects, each a line from the file.\n\nCall readline() repeatedly and return a list of the lines so read.\nThe optional size argument, if given, is an approximate bound on the\ntotal number of bytes in the lines returned.",
+    "_io.BytesIO.seek" => "Change stream position.\n\nSeek to byte offset pos relative to position indicated by whence:\n     0  Start of stream (the default).  pos should be >= 0;\n     1  Current position - pos may be negative;\n     2  End of stream - pos usually negative.\nReturns the new absolute position.",
+    "_io.BytesIO.seekable" => "Returns True if the IO object can be seeked.",
+    "_io.BytesIO.tell" => "Current file position, an integer.",
+    "_io.BytesIO.truncate" => "Truncate the file to at most size bytes.\n\nSize defaults to the current file position, as returned by tell().\nThe current file position is unchanged.  Returns the new size.",
+    "_io.BytesIO.writable" => "Returns True if the IO object can be written.",
+    "_io.BytesIO.write" => "Write bytes to file.\n\nReturn the number of bytes written.",
+    "_io.BytesIO.writelines" => "Write lines to the file.\n\nNote that newlines are not added.  lines can be any iterable object\nproducing bytes-like objects. This is equivalent to calling write() for\neach element.",
+    "_io.FileIO" => "Open a file.\n\nThe mode can be 'r' (default), 'w', 'x' or 'a' for reading,\nwriting, exclusive creation or appending.  The file will be created if it\ndoesn't exist when opened for writing or appending; it will be truncated\nwhen opened for writing.  A FileExistsError will be raised if it already\nexists when opened for creating. Opening a file for creating implies\nwriting so this mode behaves in a similar way to 'w'.Add a '+' to the mode\nto allow simultaneous reading and writing. A custom opener can be used by\npassing a callable as *opener*. The underlying file descriptor for the file\nobject is then obtained by calling opener with (*name*, *flags*).\n*opener* must return an open file descriptor (passing os.open as *opener*\nresults in functionality similar to passing None).",
+    "_io.FileIO.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.FileIO.__delattr__" => "Implement delattr(self, name).",
+    "_io.FileIO.__eq__" => "Return self==value.",
+    "_io.FileIO.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.FileIO.__ge__" => "Return self>=value.",
+    "_io.FileIO.__getattribute__" => "Return getattr(self, name).",
+    "_io.FileIO.__gt__" => "Return self>value.",
+    "_io.FileIO.__hash__" => "Return hash(self).",
+    "_io.FileIO.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.FileIO.__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.FileIO.__iter__" => "Implement iter(self).",
+    "_io.FileIO.__le__" => "Return self<=value.",
+    "_io.FileIO.__lt__" => "Return self<value.",
+    "_io.FileIO.__ne__" => "Return self!=value.",
+    "_io.FileIO.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.FileIO.__next__" => "Implement next(self).",
+    "_io.FileIO.__reduce__" => "Helper for pickle.",
+    "_io.FileIO.__reduce_ex__" => "Helper for pickle.",
+    "_io.FileIO.__repr__" => "Return repr(self).",
+    "_io.FileIO.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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().",
+    "_io.FileIO.fileno" => "Return the underlying file descriptor (an integer).",
+    "_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.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.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.",
+    "_io.FileIO.seek" => "Move to new file position and return the file position.\n\nArgument offset is a byte count.  Optional argument whence defaults to\nSEEK_SET or 0 (offset from start of file, offset should be >= 0); other values\nare SEEK_CUR or 1 (move relative to current position, positive or negative),\nand SEEK_END or 2 (move relative to end of file, usually negative, although\nmany platforms allow seeking beyond the end of a file).\n\nNote that not all file objects are seekable.",
+    "_io.FileIO.seekable" => "True if file supports random-access.",
+    "_io.FileIO.tell" => "Current file position.\n\nCan raise OSError for non seekable files.",
+    "_io.FileIO.truncate" => "Truncate the file to at most size bytes and return the truncated size.\n\nSize defaults to the current file position, as returned by tell().\nThe current file position is changed to the value of size.",
+    "_io.FileIO.writable" => "True if file was opened in a write mode.",
+    "_io.FileIO.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.  In non-blocking mode,\nreturns None if the write would block.",
+    "_io.FileIO.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.IncrementalNewlineDecoder" => "Codec used when reading a file in universal newlines mode.\n\nIt wraps another incremental decoder, translating \\r\\n and \\r into \\n.\nIt also records the types of newlines encountered.  When used with\ntranslate=False, it ensures that the newline sequence is returned in\none piece. When used with decoder=None, it expects unicode strings as\ndecode input and translates newlines without first invoking an external\ndecoder.",
+    "_io.IncrementalNewlineDecoder.__delattr__" => "Implement delattr(self, name).",
+    "_io.IncrementalNewlineDecoder.__eq__" => "Return self==value.",
+    "_io.IncrementalNewlineDecoder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.IncrementalNewlineDecoder.__ge__" => "Return self>=value.",
+    "_io.IncrementalNewlineDecoder.__getattribute__" => "Return getattr(self, name).",
+    "_io.IncrementalNewlineDecoder.__getstate__" => "Helper for pickle.",
+    "_io.IncrementalNewlineDecoder.__gt__" => "Return self>value.",
+    "_io.IncrementalNewlineDecoder.__hash__" => "Return hash(self).",
+    "_io.IncrementalNewlineDecoder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.IncrementalNewlineDecoder.__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.IncrementalNewlineDecoder.__le__" => "Return self<=value.",
+    "_io.IncrementalNewlineDecoder.__lt__" => "Return self<value.",
+    "_io.IncrementalNewlineDecoder.__ne__" => "Return self!=value.",
+    "_io.IncrementalNewlineDecoder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.IncrementalNewlineDecoder.__reduce__" => "Helper for pickle.",
+    "_io.IncrementalNewlineDecoder.__reduce_ex__" => "Helper for pickle.",
+    "_io.IncrementalNewlineDecoder.__repr__" => "Return repr(self).",
+    "_io.IncrementalNewlineDecoder.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.IncrementalNewlineDecoder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.IncrementalNewlineDecoder.__str__" => "Return str(self).",
+    "_io.IncrementalNewlineDecoder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.StringIO" => "Text I/O implementation using an in-memory buffer.\n\nThe initial_value argument sets the value of object.  The newline\nargument is like the one of TextIOWrapper's constructor.",
+    "_io.StringIO.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.StringIO.__delattr__" => "Implement delattr(self, name).",
+    "_io.StringIO.__eq__" => "Return self==value.",
+    "_io.StringIO.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.StringIO.__ge__" => "Return self>=value.",
+    "_io.StringIO.__getattribute__" => "Return getattr(self, name).",
+    "_io.StringIO.__gt__" => "Return self>value.",
+    "_io.StringIO.__hash__" => "Return hash(self).",
+    "_io.StringIO.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.StringIO.__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.StringIO.__iter__" => "Implement iter(self).",
+    "_io.StringIO.__le__" => "Return self<=value.",
+    "_io.StringIO.__lt__" => "Return self<value.",
+    "_io.StringIO.__ne__" => "Return self!=value.",
+    "_io.StringIO.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.StringIO.__next__" => "Implement next(self).",
+    "_io.StringIO.__reduce__" => "Helper for pickle.",
+    "_io.StringIO.__reduce_ex__" => "Helper for pickle.",
+    "_io.StringIO.__repr__" => "Return repr(self).",
+    "_io.StringIO.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.StringIO.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.StringIO.__str__" => "Return str(self).",
+    "_io.StringIO.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.StringIO.close" => "Close the IO object.\n\nAttempting any further operation after the object is closed\nwill raise a ValueError.\n\nThis method has no effect if the file is already closed.",
+    "_io.StringIO.detach" => "Separate the underlying buffer from the TextIOBase and return it.\n\nAfter the underlying buffer has been detached, the TextIO is in an unusable state.",
+    "_io.StringIO.encoding" => "Encoding of the text stream.\n\nSubclasses should override.",
+    "_io.StringIO.errors" => "The error setting of the decoder or encoder.\n\nSubclasses should override.",
+    "_io.StringIO.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io.StringIO.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io.StringIO.getvalue" => "Retrieve the entire contents of the object.",
+    "_io.StringIO.isatty" => "Return whether this is an 'interactive' stream.\n\nReturn False if it can't be determined.",
+    "_io.StringIO.read" => "Read at most size characters, returned as a string.\n\nIf the argument is negative or omitted, read until EOF\nis reached. Return an empty string at EOF.",
+    "_io.StringIO.readable" => "Returns True if the IO object can be read.",
+    "_io.StringIO.readline" => "Read until newline or EOF.\n\nReturns an empty string if EOF is hit immediately.",
+    "_io.StringIO.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.",
+    "_io.StringIO.seek" => "Change stream position.\n\nSeek to character offset pos relative to position indicated by whence:\n    0  Start of stream (the default).  pos should be >= 0;\n    1  Current position - pos must be 0;\n    2  End of stream - pos must be 0.\nReturns the new absolute position.",
+    "_io.StringIO.seekable" => "Returns True if the IO object can be seeked.",
+    "_io.StringIO.tell" => "Tell the current file position.",
+    "_io.StringIO.truncate" => "Truncate size to pos.\n\nThe pos argument defaults to the current file position, as\nreturned by tell().  The current file position is unchanged.\nReturns the new absolute position.",
+    "_io.StringIO.writable" => "Returns True if the IO object can be written.",
+    "_io.StringIO.write" => "Write string to file.\n\nReturns the number of characters written, which is always equal to\nthe length of the string.",
+    "_io.StringIO.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.TextIOWrapper" => "Character and line based layer over a BufferedIOBase object, buffer.\n\nencoding gives the name of the encoding that the stream will be\ndecoded or encoded with. It defaults to locale.getencoding().\n\nerrors determines the strictness of encoding and decoding (see\nhelp(codecs.Codec) or the documentation for codecs.register) and\ndefaults to \"strict\".\n\nnewline controls how line endings are handled. It can be None, '',\n'\\n', '\\r', and '\\r\\n'.  It works as follows:\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 line_buffering is True, a call to flush is implied when a call to\nwrite contains a newline character.",
+    "_io.TextIOWrapper.__del__" => "Called when the instance is about to be destroyed.",
+    "_io.TextIOWrapper.__delattr__" => "Implement delattr(self, name).",
+    "_io.TextIOWrapper.__eq__" => "Return self==value.",
+    "_io.TextIOWrapper.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io.TextIOWrapper.__ge__" => "Return self>=value.",
+    "_io.TextIOWrapper.__getattribute__" => "Return getattr(self, name).",
+    "_io.TextIOWrapper.__gt__" => "Return self>value.",
+    "_io.TextIOWrapper.__hash__" => "Return hash(self).",
+    "_io.TextIOWrapper.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io.TextIOWrapper.__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.TextIOWrapper.__iter__" => "Implement iter(self).",
+    "_io.TextIOWrapper.__le__" => "Return self<=value.",
+    "_io.TextIOWrapper.__lt__" => "Return self<value.",
+    "_io.TextIOWrapper.__ne__" => "Return self!=value.",
+    "_io.TextIOWrapper.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io.TextIOWrapper.__next__" => "Implement next(self).",
+    "_io.TextIOWrapper.__reduce__" => "Helper for pickle.",
+    "_io.TextIOWrapper.__reduce_ex__" => "Helper for pickle.",
+    "_io.TextIOWrapper.__repr__" => "Return repr(self).",
+    "_io.TextIOWrapper.__setattr__" => "Implement setattr(self, name, value).",
+    "_io.TextIOWrapper.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io.TextIOWrapper.__str__" => "Return str(self).",
+    "_io.TextIOWrapper.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.TextIOWrapper.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.",
+    "_io.TextIOWrapper.reconfigure" => "Reconfigure the text stream with new parameters.\n\nThis also does an implicit stream flush.",
+    "_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._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).",
+    "_io._BufferedIOBase.__eq__" => "Return self==value.",
+    "_io._BufferedIOBase.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._BufferedIOBase.__ge__" => "Return self>=value.",
+    "_io._BufferedIOBase.__getattribute__" => "Return getattr(self, name).",
+    "_io._BufferedIOBase.__getstate__" => "Helper for pickle.",
+    "_io._BufferedIOBase.__gt__" => "Return self>value.",
+    "_io._BufferedIOBase.__hash__" => "Return hash(self).",
+    "_io._BufferedIOBase.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._BufferedIOBase.__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._BufferedIOBase.__iter__" => "Implement iter(self).",
+    "_io._BufferedIOBase.__le__" => "Return self<=value.",
+    "_io._BufferedIOBase.__lt__" => "Return self<value.",
+    "_io._BufferedIOBase.__ne__" => "Return self!=value.",
+    "_io._BufferedIOBase.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._BufferedIOBase.__next__" => "Implement next(self).",
+    "_io._BufferedIOBase.__reduce__" => "Helper for pickle.",
+    "_io._BufferedIOBase.__reduce_ex__" => "Helper for pickle.",
+    "_io._BufferedIOBase.__repr__" => "Return repr(self).",
+    "_io._BufferedIOBase.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._BufferedIOBase.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._BufferedIOBase.__str__" => "Return str(self).",
+    "_io._BufferedIOBase.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._BufferedIOBase.close" => "Flush and close the IO object.\n\nThis method has no effect if the file is already closed.",
+    "_io._BufferedIOBase.detach" => "Disconnect this buffer from its underlying raw stream and return it.\n\nAfter the raw stream has been detached, the buffer is in an unusable\nstate.",
+    "_io._BufferedIOBase.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io._BufferedIOBase.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io._BufferedIOBase.isatty" => "Return whether this is an 'interactive' stream.\n\nReturn False if it can't be determined.",
+    "_io._BufferedIOBase.read" => "Read and return up to n bytes.\n\nIf the size argument is omitted, None, or negative, read and\nreturn all data until EOF.\n\nIf the size argument is positive, and the underlying raw stream is\nnot 'interactive', multiple raw reads may be issued to satisfy\nthe byte count (unless EOF is reached first).\nHowever, for interactive raw streams (as well as sockets and pipes),\nat most one raw read will be issued, and a short result does not\nimply that EOF is imminent.\n\nReturn an empty bytes object on EOF.\n\nReturn None if the underlying raw stream was open in non-blocking\nmode and no data is available at the moment.",
+    "_io._BufferedIOBase.read1" => "Read and return up to size bytes, with at most one read() call to the underlying raw stream.\n\nReturn an empty bytes object on EOF.\nA short result does not imply that EOF is imminent.",
+    "_io._BufferedIOBase.readable" => "Return whether object was opened for reading.\n\nIf False, read() will raise OSError.",
+    "_io._BufferedIOBase.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._BufferedIOBase.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.",
+    "_io._BufferedIOBase.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io._BufferedIOBase.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io._BufferedIOBase.tell" => "Return current stream position.",
+    "_io._BufferedIOBase.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_io._BufferedIOBase.writable" => "Return whether object was opened for writing.\n\nIf False, write() will raise OSError.",
+    "_io._BufferedIOBase.write" => "Write buffer b to the IO stream.\n\nReturn the number of bytes written, which is always\nthe length of b in bytes.\n\nRaise BlockingIOError if the buffer is full and the\nunderlying raw stream cannot accept more data at the moment.",
+    "_io._BufferedIOBase.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._BytesIOBuffer.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "_io._BytesIOBuffer.__delattr__" => "Implement delattr(self, name).",
+    "_io._BytesIOBuffer.__eq__" => "Return self==value.",
+    "_io._BytesIOBuffer.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._BytesIOBuffer.__ge__" => "Return self>=value.",
+    "_io._BytesIOBuffer.__getattribute__" => "Return getattr(self, name).",
+    "_io._BytesIOBuffer.__getstate__" => "Helper for pickle.",
+    "_io._BytesIOBuffer.__gt__" => "Return self>value.",
+    "_io._BytesIOBuffer.__hash__" => "Return hash(self).",
+    "_io._BytesIOBuffer.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._BytesIOBuffer.__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._BytesIOBuffer.__le__" => "Return self<=value.",
+    "_io._BytesIOBuffer.__lt__" => "Return self<value.",
+    "_io._BytesIOBuffer.__ne__" => "Return self!=value.",
+    "_io._BytesIOBuffer.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._BytesIOBuffer.__reduce__" => "Helper for pickle.",
+    "_io._BytesIOBuffer.__reduce_ex__" => "Helper for pickle.",
+    "_io._BytesIOBuffer.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "_io._BytesIOBuffer.__repr__" => "Return repr(self).",
+    "_io._BytesIOBuffer.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._BytesIOBuffer.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._BytesIOBuffer.__str__" => "Return str(self).",
+    "_io._BytesIOBuffer.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._IOBase" => "The abstract base class for all I/O classes.\n\nThis class provides dummy implementations for many methods that\nderived classes can override selectively; the default implementations\nrepresent a file that cannot be read, written or seeked.\n\nEven though IOBase does not declare read, readinto, or write because\ntheir signatures will vary, implementations and clients should\nconsider those methods part of the interface. Also, implementations\nmay raise UnsupportedOperation when operations they do not support are\ncalled.\n\nThe basic type used for binary data read from or written to a file is\nbytes. Other bytes-like objects are accepted as method arguments too.\nIn some cases (such as readinto), a writable object is required. Text\nI/O classes work with str data.\n\nNote that calling any method (except additional calls to close(),\nwhich are ignored) on a closed stream should raise a ValueError.\n\nIOBase (and its subclasses) support the iterator protocol, meaning\nthat an IOBase object can be iterated over yielding the lines in a\nstream.\n\nIOBase also supports the :keyword:`with` statement. In this example,\nfp is closed after the suite of the with statement is complete:\n\nwith open('spam.txt', 'r') as fp:\n    fp.write('Spam and eggs!')",
+    "_io._IOBase.__del__" => "Called when the instance is about to be destroyed.",
+    "_io._IOBase.__delattr__" => "Implement delattr(self, name).",
+    "_io._IOBase.__eq__" => "Return self==value.",
+    "_io._IOBase.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._IOBase.__ge__" => "Return self>=value.",
+    "_io._IOBase.__getattribute__" => "Return getattr(self, name).",
+    "_io._IOBase.__getstate__" => "Helper for pickle.",
+    "_io._IOBase.__gt__" => "Return self>value.",
+    "_io._IOBase.__hash__" => "Return hash(self).",
+    "_io._IOBase.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._IOBase.__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._IOBase.__iter__" => "Implement iter(self).",
+    "_io._IOBase.__le__" => "Return self<=value.",
+    "_io._IOBase.__lt__" => "Return self<value.",
+    "_io._IOBase.__ne__" => "Return self!=value.",
+    "_io._IOBase.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._IOBase.__next__" => "Implement next(self).",
+    "_io._IOBase.__reduce__" => "Helper for pickle.",
+    "_io._IOBase.__reduce_ex__" => "Helper for pickle.",
+    "_io._IOBase.__repr__" => "Return repr(self).",
+    "_io._IOBase.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._IOBase.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._IOBase.__str__" => "Return str(self).",
+    "_io._IOBase.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._IOBase.close" => "Flush and close the IO object.\n\nThis method has no effect if the file is already closed.",
+    "_io._IOBase.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io._IOBase.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io._IOBase.isatty" => "Return whether this is an 'interactive' stream.\n\nReturn False if it can't be determined.",
+    "_io._IOBase.readable" => "Return whether object was opened for reading.\n\nIf False, read() will raise OSError.",
+    "_io._IOBase.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._IOBase.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.",
+    "_io._IOBase.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io._IOBase.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io._IOBase.tell" => "Return current stream position.",
+    "_io._IOBase.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_io._IOBase.writable" => "Return whether object was opened for writing.\n\nIf False, write() will raise OSError.",
+    "_io._IOBase.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._RawIOBase" => "Base class for raw binary I/O.",
+    "_io._RawIOBase.__del__" => "Called when the instance is about to be destroyed.",
+    "_io._RawIOBase.__delattr__" => "Implement delattr(self, name).",
+    "_io._RawIOBase.__eq__" => "Return self==value.",
+    "_io._RawIOBase.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._RawIOBase.__ge__" => "Return self>=value.",
+    "_io._RawIOBase.__getattribute__" => "Return getattr(self, name).",
+    "_io._RawIOBase.__getstate__" => "Helper for pickle.",
+    "_io._RawIOBase.__gt__" => "Return self>value.",
+    "_io._RawIOBase.__hash__" => "Return hash(self).",
+    "_io._RawIOBase.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._RawIOBase.__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._RawIOBase.__iter__" => "Implement iter(self).",
+    "_io._RawIOBase.__le__" => "Return self<=value.",
+    "_io._RawIOBase.__lt__" => "Return self<value.",
+    "_io._RawIOBase.__ne__" => "Return self!=value.",
+    "_io._RawIOBase.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._RawIOBase.__next__" => "Implement next(self).",
+    "_io._RawIOBase.__reduce__" => "Helper for pickle.",
+    "_io._RawIOBase.__reduce_ex__" => "Helper for pickle.",
+    "_io._RawIOBase.__repr__" => "Return repr(self).",
+    "_io._RawIOBase.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._RawIOBase.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._RawIOBase.__str__" => "Return str(self).",
+    "_io._RawIOBase.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._RawIOBase.close" => "Flush and close the IO object.\n\nThis method has no effect if the file is already closed.",
+    "_io._RawIOBase.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io._RawIOBase.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io._RawIOBase.isatty" => "Return whether this is an 'interactive' stream.\n\nReturn False if it can't be determined.",
+    "_io._RawIOBase.readable" => "Return whether object was opened for reading.\n\nIf False, read() will raise OSError.",
+    "_io._RawIOBase.readall" => "Read until EOF, using multiple read() call.",
+    "_io._RawIOBase.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._RawIOBase.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.",
+    "_io._RawIOBase.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io._RawIOBase.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io._RawIOBase.tell" => "Return current stream position.",
+    "_io._RawIOBase.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_io._RawIOBase.writable" => "Return whether object was opened for writing.\n\nIf False, write() will raise OSError.",
+    "_io._RawIOBase.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._TextIOBase" => "Base class for text I/O.\n\nThis class provides a character and line based interface to stream\nI/O. There is no readinto method because Python's character strings\nare immutable.",
+    "_io._TextIOBase.__del__" => "Called when the instance is about to be destroyed.",
+    "_io._TextIOBase.__delattr__" => "Implement delattr(self, name).",
+    "_io._TextIOBase.__eq__" => "Return self==value.",
+    "_io._TextIOBase.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._TextIOBase.__ge__" => "Return self>=value.",
+    "_io._TextIOBase.__getattribute__" => "Return getattr(self, name).",
+    "_io._TextIOBase.__getstate__" => "Helper for pickle.",
+    "_io._TextIOBase.__gt__" => "Return self>value.",
+    "_io._TextIOBase.__hash__" => "Return hash(self).",
+    "_io._TextIOBase.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._TextIOBase.__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._TextIOBase.__iter__" => "Implement iter(self).",
+    "_io._TextIOBase.__le__" => "Return self<=value.",
+    "_io._TextIOBase.__lt__" => "Return self<value.",
+    "_io._TextIOBase.__ne__" => "Return self!=value.",
+    "_io._TextIOBase.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._TextIOBase.__next__" => "Implement next(self).",
+    "_io._TextIOBase.__reduce__" => "Helper for pickle.",
+    "_io._TextIOBase.__reduce_ex__" => "Helper for pickle.",
+    "_io._TextIOBase.__repr__" => "Return repr(self).",
+    "_io._TextIOBase.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._TextIOBase.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._TextIOBase.__str__" => "Return str(self).",
+    "_io._TextIOBase.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._TextIOBase.close" => "Flush and close the IO object.\n\nThis method has no effect if the file is already closed.",
+    "_io._TextIOBase.detach" => "Separate the underlying buffer from the TextIOBase and return it.\n\nAfter the underlying buffer has been detached, the TextIO is in an unusable state.",
+    "_io._TextIOBase.encoding" => "Encoding of the text stream.\n\nSubclasses should override.",
+    "_io._TextIOBase.errors" => "The error setting of the decoder or encoder.\n\nSubclasses should override.",
+    "_io._TextIOBase.fileno" => "Return underlying file descriptor if one exists.\n\nRaise OSError if the IO object does not use a file descriptor.",
+    "_io._TextIOBase.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io._TextIOBase.isatty" => "Return whether this is an 'interactive' stream.\n\nReturn False if it can't be determined.",
+    "_io._TextIOBase.newlines" => "Line endings translated so far.\n\nOnly line endings translated during reading are considered.\n\nSubclasses should override.",
+    "_io._TextIOBase.read" => "Read at most size characters from stream.\n\nRead from underlying buffer until we have size characters or we hit EOF.\nIf size is negative or omitted, read until EOF.",
+    "_io._TextIOBase.readable" => "Return whether object was opened for reading.\n\nIf False, read() will raise OSError.",
+    "_io._TextIOBase.readline" => "Read until newline or EOF.\n\nReturn an empty string if EOF is hit immediately.\nIf size is specified, at most size characters will be read.",
+    "_io._TextIOBase.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.",
+    "_io._TextIOBase.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io._TextIOBase.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io._TextIOBase.tell" => "Return current stream position.",
+    "_io._TextIOBase.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_io._TextIOBase.writable" => "Return whether object was opened for writing.\n\nIf False, write() will raise OSError.",
+    "_io._TextIOBase.write" => "Write string s to stream.\n\nReturn the number of characters written\n(which is always equal to the length of the string).",
+    "_io._TextIOBase.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._WindowsConsoleIO" => "Open a console buffer by file descriptor.\n\nThe mode can be 'rb' (default), or 'wb' for reading or writing bytes. All\nother mode characters will be ignored. Mode 'b' will be assumed if it is\nomitted. The *opener* parameter is always ignored.",
+    "_io._WindowsConsoleIO.__del__" => "Called when the instance is about to be destroyed.",
+    "_io._WindowsConsoleIO.__delattr__" => "Implement delattr(self, name).",
+    "_io._WindowsConsoleIO.__eq__" => "Return self==value.",
+    "_io._WindowsConsoleIO.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_io._WindowsConsoleIO.__ge__" => "Return self>=value.",
+    "_io._WindowsConsoleIO.__getattribute__" => "Return getattr(self, name).",
+    "_io._WindowsConsoleIO.__getstate__" => "Helper for pickle.",
+    "_io._WindowsConsoleIO.__gt__" => "Return self>value.",
+    "_io._WindowsConsoleIO.__hash__" => "Return hash(self).",
+    "_io._WindowsConsoleIO.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_io._WindowsConsoleIO.__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._WindowsConsoleIO.__iter__" => "Implement iter(self).",
+    "_io._WindowsConsoleIO.__le__" => "Return self<=value.",
+    "_io._WindowsConsoleIO.__lt__" => "Return self<value.",
+    "_io._WindowsConsoleIO.__ne__" => "Return self!=value.",
+    "_io._WindowsConsoleIO.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_io._WindowsConsoleIO.__next__" => "Implement next(self).",
+    "_io._WindowsConsoleIO.__reduce__" => "Helper for pickle.",
+    "_io._WindowsConsoleIO.__reduce_ex__" => "Helper for pickle.",
+    "_io._WindowsConsoleIO.__repr__" => "Return repr(self).",
+    "_io._WindowsConsoleIO.__setattr__" => "Implement setattr(self, name, value).",
+    "_io._WindowsConsoleIO.__sizeof__" => "Size of object in memory, in bytes.",
+    "_io._WindowsConsoleIO.__str__" => "Return str(self).",
+    "_io._WindowsConsoleIO.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._WindowsConsoleIO.close" => "Close the console object.\n\nA closed console object cannot be used for further I/O operations.\nclose() may be called more than once without error.",
+    "_io._WindowsConsoleIO.closed" => "True if the file is closed",
+    "_io._WindowsConsoleIO.closefd" => "True if the file descriptor will be closed by close().",
+    "_io._WindowsConsoleIO.fileno" => "Return the underlying file descriptor (an integer).",
+    "_io._WindowsConsoleIO.flush" => "Flush write buffers, if applicable.\n\nThis is not implemented for read-only and non-blocking streams.",
+    "_io._WindowsConsoleIO.isatty" => "Always True.",
+    "_io._WindowsConsoleIO.mode" => "String giving the file mode",
+    "_io._WindowsConsoleIO.read" => "Read at most size bytes, returned as bytes.\n\nOnly makes one system call when size is a positive integer,\nso less data may be returned than requested.\nReturn an empty bytes object at EOF.",
+    "_io._WindowsConsoleIO.readable" => "True if console is an input buffer.",
+    "_io._WindowsConsoleIO.readall" => "Read all data from the console, returned as bytes.\n\nReturn an empty bytes object at EOF.",
+    "_io._WindowsConsoleIO.readinto" => "Same as RawIOBase.readinto().",
+    "_io._WindowsConsoleIO.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._WindowsConsoleIO.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.",
+    "_io._WindowsConsoleIO.seek" => "Change the stream position to the given byte offset.\n\n  offset\n    The stream position, relative to 'whence'.\n  whence\n    The relative position to seek from.\n\nThe offset is interpreted relative to the position indicated by whence.\nValues for whence are:\n\n* os.SEEK_SET or 0 -- start of stream (the default); offset should be zero or positive\n* os.SEEK_CUR or 1 -- current stream position; offset may be negative\n* os.SEEK_END or 2 -- end of stream; offset is usually negative\n\nReturn the new absolute position.",
+    "_io._WindowsConsoleIO.seekable" => "Return whether object supports random access.\n\nIf False, seek(), tell() and truncate() will raise OSError.\nThis method may need to do a test seek().",
+    "_io._WindowsConsoleIO.tell" => "Return current stream position.",
+    "_io._WindowsConsoleIO.truncate" => "Truncate file to size bytes.\n\nFile pointer is left unchanged. Size defaults to the current IO position\nas reported by tell(). Return the new size.",
+    "_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_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",
+    "_json.encode_basestring" => "encode_basestring(string) -> string\n\nReturn a JSON representation of a Python string",
+    "_json.encode_basestring_ascii" => "encode_basestring_ascii(string) -> string\n\nReturn an ASCII-only JSON representation of a Python string",
+    "_json.make_encoder" => "Encoder(markers, default, encoder, indent, key_separator, item_separator, sort_keys, skipkeys, allow_nan)",
+    "_json.make_encoder.__call__" => "Call self as a function.",
+    "_json.make_encoder.__delattr__" => "Implement delattr(self, name).",
+    "_json.make_encoder.__eq__" => "Return self==value.",
+    "_json.make_encoder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_json.make_encoder.__ge__" => "Return self>=value.",
+    "_json.make_encoder.__getattribute__" => "Return getattr(self, name).",
+    "_json.make_encoder.__getstate__" => "Helper for pickle.",
+    "_json.make_encoder.__gt__" => "Return self>value.",
+    "_json.make_encoder.__hash__" => "Return hash(self).",
+    "_json.make_encoder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_json.make_encoder.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_json.make_encoder.__le__" => "Return self<=value.",
+    "_json.make_encoder.__lt__" => "Return self<value.",
+    "_json.make_encoder.__ne__" => "Return self!=value.",
+    "_json.make_encoder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_json.make_encoder.__reduce__" => "Helper for pickle.",
+    "_json.make_encoder.__reduce_ex__" => "Helper for pickle.",
+    "_json.make_encoder.__repr__" => "Return repr(self).",
+    "_json.make_encoder.__setattr__" => "Implement setattr(self, name, value).",
+    "_json.make_encoder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_json.make_encoder.__str__" => "Return str(self).",
+    "_json.make_encoder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_json.make_encoder.default" => "default",
+    "_json.make_encoder.encoder" => "encoder",
+    "_json.make_encoder.indent" => "indent",
+    "_json.make_encoder.item_separator" => "item_separator",
+    "_json.make_encoder.key_separator" => "key_separator",
+    "_json.make_encoder.markers" => "markers",
+    "_json.make_encoder.skipkeys" => "skipkeys",
+    "_json.make_encoder.sort_keys" => "sort_keys",
+    "_json.make_scanner" => "JSON scanner object",
+    "_json.make_scanner.__call__" => "Call self as a function.",
+    "_json.make_scanner.__delattr__" => "Implement delattr(self, name).",
+    "_json.make_scanner.__eq__" => "Return self==value.",
+    "_json.make_scanner.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_json.make_scanner.__ge__" => "Return self>=value.",
+    "_json.make_scanner.__getattribute__" => "Return getattr(self, name).",
+    "_json.make_scanner.__getstate__" => "Helper for pickle.",
+    "_json.make_scanner.__gt__" => "Return self>value.",
+    "_json.make_scanner.__hash__" => "Return hash(self).",
+    "_json.make_scanner.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_json.make_scanner.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_json.make_scanner.__le__" => "Return self<=value.",
+    "_json.make_scanner.__lt__" => "Return self<value.",
+    "_json.make_scanner.__ne__" => "Return self!=value.",
+    "_json.make_scanner.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_json.make_scanner.__reduce__" => "Helper for pickle.",
+    "_json.make_scanner.__reduce_ex__" => "Helper for pickle.",
+    "_json.make_scanner.__repr__" => "Return repr(self).",
+    "_json.make_scanner.__setattr__" => "Implement setattr(self, name, value).",
+    "_json.make_scanner.__sizeof__" => "Size of object in memory, in bytes.",
+    "_json.make_scanner.__str__" => "Return str(self).",
+    "_json.make_scanner.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_json.make_scanner.object_hook" => "object_hook",
+    "_json.make_scanner.parse_constant" => "parse_constant",
+    "_json.make_scanner.parse_float" => "parse_float",
+    "_json.make_scanner.parse_int" => "parse_int",
+    "_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.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.",
+    "_locale.dgettext" => "dgettext(domain, msg) -> string\n\nReturn translation of msg in domain.",
+    "_locale.getencoding" => "Get the current locale encoding.",
+    "_locale.gettext" => "gettext(msg) -> string\n\nReturn translation of msg.",
+    "_locale.localeconv" => "Returns numeric and monetary locale-specific parameters.",
+    "_locale.nl_langinfo" => "Return the value for the locale information associated with key.",
+    "_locale.setlocale" => "Activates/queries locale processing.",
+    "_locale.strcoll" => "Compares two strings according to the locale.",
+    "_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.__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.",
+    "_lsprof.Profiler.__ge__" => "Return self>=value.",
+    "_lsprof.Profiler.__getattribute__" => "Return getattr(self, name).",
+    "_lsprof.Profiler.__getstate__" => "Helper for pickle.",
+    "_lsprof.Profiler.__gt__" => "Return self>value.",
+    "_lsprof.Profiler.__hash__" => "Return hash(self).",
+    "_lsprof.Profiler.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lsprof.Profiler.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lsprof.Profiler.__le__" => "Return self<=value.",
+    "_lsprof.Profiler.__lt__" => "Return self<value.",
+    "_lsprof.Profiler.__ne__" => "Return self!=value.",
+    "_lsprof.Profiler.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lsprof.Profiler.__reduce__" => "Helper for pickle.",
+    "_lsprof.Profiler.__reduce_ex__" => "Helper for pickle.",
+    "_lsprof.Profiler.__repr__" => "Return repr(self).",
+    "_lsprof.Profiler.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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",
+    "_lsprof.profiler_entry.__contains__" => "Return bool(key in self).",
+    "_lsprof.profiler_entry.__delattr__" => "Implement delattr(self, name).",
+    "_lsprof.profiler_entry.__eq__" => "Return self==value.",
+    "_lsprof.profiler_entry.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_lsprof.profiler_entry.__ge__" => "Return self>=value.",
+    "_lsprof.profiler_entry.__getattribute__" => "Return getattr(self, name).",
+    "_lsprof.profiler_entry.__getitem__" => "Return self[key].",
+    "_lsprof.profiler_entry.__getstate__" => "Helper for pickle.",
+    "_lsprof.profiler_entry.__gt__" => "Return self>value.",
+    "_lsprof.profiler_entry.__hash__" => "Return hash(self).",
+    "_lsprof.profiler_entry.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lsprof.profiler_entry.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lsprof.profiler_entry.__iter__" => "Implement iter(self).",
+    "_lsprof.profiler_entry.__le__" => "Return self<=value.",
+    "_lsprof.profiler_entry.__len__" => "Return len(self).",
+    "_lsprof.profiler_entry.__lt__" => "Return self<value.",
+    "_lsprof.profiler_entry.__mul__" => "Return self*value.",
+    "_lsprof.profiler_entry.__ne__" => "Return self!=value.",
+    "_lsprof.profiler_entry.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lsprof.profiler_entry.__reduce_ex__" => "Helper for pickle.",
+    "_lsprof.profiler_entry.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_lsprof.profiler_entry.__repr__" => "Return repr(self).",
+    "_lsprof.profiler_entry.__rmul__" => "Return value*self.",
+    "_lsprof.profiler_entry.__setattr__" => "Implement setattr(self, name, value).",
+    "_lsprof.profiler_entry.__sizeof__" => "Size of object in memory, in bytes.",
+    "_lsprof.profiler_entry.__str__" => "Return str(self).",
+    "_lsprof.profiler_entry.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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_entry.callcount" => "how many times this was called",
+    "_lsprof.profiler_entry.calls" => "details of the calls",
+    "_lsprof.profiler_entry.code" => "code object or built-in function name",
+    "_lsprof.profiler_entry.count" => "Return number of occurrences of value.",
+    "_lsprof.profiler_entry.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_lsprof.profiler_entry.inlinetime" => "inline time in this entry (not in subcalls)",
+    "_lsprof.profiler_entry.reccallcount" => "how many times called recursively",
+    "_lsprof.profiler_entry.totaltime" => "total time in this entry",
+    "_lsprof.profiler_subentry.__add__" => "Return self+value.",
+    "_lsprof.profiler_subentry.__class_getitem__" => "See PEP 585",
+    "_lsprof.profiler_subentry.__contains__" => "Return bool(key in self).",
+    "_lsprof.profiler_subentry.__delattr__" => "Implement delattr(self, name).",
+    "_lsprof.profiler_subentry.__eq__" => "Return self==value.",
+    "_lsprof.profiler_subentry.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_lsprof.profiler_subentry.__ge__" => "Return self>=value.",
+    "_lsprof.profiler_subentry.__getattribute__" => "Return getattr(self, name).",
+    "_lsprof.profiler_subentry.__getitem__" => "Return self[key].",
+    "_lsprof.profiler_subentry.__getstate__" => "Helper for pickle.",
+    "_lsprof.profiler_subentry.__gt__" => "Return self>value.",
+    "_lsprof.profiler_subentry.__hash__" => "Return hash(self).",
+    "_lsprof.profiler_subentry.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lsprof.profiler_subentry.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lsprof.profiler_subentry.__iter__" => "Implement iter(self).",
+    "_lsprof.profiler_subentry.__le__" => "Return self<=value.",
+    "_lsprof.profiler_subentry.__len__" => "Return len(self).",
+    "_lsprof.profiler_subentry.__lt__" => "Return self<value.",
+    "_lsprof.profiler_subentry.__mul__" => "Return self*value.",
+    "_lsprof.profiler_subentry.__ne__" => "Return self!=value.",
+    "_lsprof.profiler_subentry.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lsprof.profiler_subentry.__reduce_ex__" => "Helper for pickle.",
+    "_lsprof.profiler_subentry.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_lsprof.profiler_subentry.__repr__" => "Return repr(self).",
+    "_lsprof.profiler_subentry.__rmul__" => "Return value*self.",
+    "_lsprof.profiler_subentry.__setattr__" => "Implement setattr(self, name, value).",
+    "_lsprof.profiler_subentry.__sizeof__" => "Size of object in memory, in bytes.",
+    "_lsprof.profiler_subentry.__str__" => "Return str(self).",
+    "_lsprof.profiler_subentry.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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_subentry.callcount" => "how many times this is called",
+    "_lsprof.profiler_subentry.code" => "called code object or built-in function name",
+    "_lsprof.profiler_subentry.count" => "Return number of occurrences of value.",
+    "_lsprof.profiler_subentry.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_lsprof.profiler_subentry.inlinetime" => "inline time (not in further subcalls)",
+    "_lsprof.profiler_subentry.reccallcount" => "how many times this is called recursively",
+    "_lsprof.profiler_subentry.totaltime" => "total time spent in this call",
+    "_lzma.LZMACompressor" => "LZMACompressor(format=FORMAT_XZ, check=-1, preset=None, filters=None)\n\nCreate a compressor object for compressing data incrementally.\n\nformat specifies the container format to use for the output. This can\nbe FORMAT_XZ (default), FORMAT_ALONE, or FORMAT_RAW.\n\ncheck specifies the integrity check to use. For FORMAT_XZ, the default\nis CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not support integrity\nchecks; for these formats, check must be omitted, or be CHECK_NONE.\n\nThe settings used by the compressor can be specified either as a\npreset compression level (with the 'preset' argument), or in detail\nas a custom filter chain (with the 'filters' argument). For FORMAT_XZ\nand FORMAT_ALONE, the default is to use the PRESET_DEFAULT preset\nlevel. For FORMAT_RAW, the caller must always specify a filter chain;\nthe raw compressor does not support preset compression levels.\n\npreset (if provided) should be an integer in the range 0-9, optionally\nOR-ed with the constant PRESET_EXTREME.\n\nfilters (if provided) should be a sequence of dicts. Each dict should\nhave an entry for \"id\" indicating the ID of the filter, plus\nadditional entries for options to the filter.\n\nFor one-shot compression, use the compress() function instead.",
+    "_lzma.LZMACompressor.__delattr__" => "Implement delattr(self, name).",
+    "_lzma.LZMACompressor.__eq__" => "Return self==value.",
+    "_lzma.LZMACompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_lzma.LZMACompressor.__ge__" => "Return self>=value.",
+    "_lzma.LZMACompressor.__getattribute__" => "Return getattr(self, name).",
+    "_lzma.LZMACompressor.__getstate__" => "Helper for pickle.",
+    "_lzma.LZMACompressor.__gt__" => "Return self>value.",
+    "_lzma.LZMACompressor.__hash__" => "Return hash(self).",
+    "_lzma.LZMACompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lzma.LZMACompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lzma.LZMACompressor.__le__" => "Return self<=value.",
+    "_lzma.LZMACompressor.__lt__" => "Return self<value.",
+    "_lzma.LZMACompressor.__ne__" => "Return self!=value.",
+    "_lzma.LZMACompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lzma.LZMACompressor.__reduce__" => "Helper for pickle.",
+    "_lzma.LZMACompressor.__reduce_ex__" => "Helper for pickle.",
+    "_lzma.LZMACompressor.__repr__" => "Return repr(self).",
+    "_lzma.LZMACompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_lzma.LZMACompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_lzma.LZMACompressor.__str__" => "Return str(self).",
+    "_lzma.LZMACompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.LZMACompressor.compress" => "Provide data to the compressor object.\n\nReturns a chunk of compressed data if possible, or b'' otherwise.\n\nWhen you have finished providing data to the compressor, call the\nflush() method to finish the compression process.",
+    "_lzma.LZMACompressor.flush" => "Finish the compression process.\n\nReturns the compressed data left in internal buffers.\n\nThe compressor object may not be used after this method is called.",
+    "_lzma.LZMADecompressor" => "Create a decompressor object for decompressing data incrementally.\n\n  format\n    Specifies the container format of the input stream.  If this is\n    FORMAT_AUTO (the default), the decompressor will automatically detect\n    whether the input is FORMAT_XZ or FORMAT_ALONE.  Streams created with\n    FORMAT_RAW cannot be autodetected.\n  memlimit\n    Limit the amount of memory used by the decompressor.  This will cause\n    decompression to fail if the input cannot be decompressed within the\n    given limit.\n  filters\n    A custom filter chain.  This argument is required for FORMAT_RAW, and\n    not accepted with any other format.  When provided, this should be a\n    sequence of dicts, each indicating the ID and options for a single\n    filter.\n\nFor one-shot decompression, use the decompress() function instead.",
+    "_lzma.LZMADecompressor.__delattr__" => "Implement delattr(self, name).",
+    "_lzma.LZMADecompressor.__eq__" => "Return self==value.",
+    "_lzma.LZMADecompressor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_lzma.LZMADecompressor.__ge__" => "Return self>=value.",
+    "_lzma.LZMADecompressor.__getattribute__" => "Return getattr(self, name).",
+    "_lzma.LZMADecompressor.__getstate__" => "Helper for pickle.",
+    "_lzma.LZMADecompressor.__gt__" => "Return self>value.",
+    "_lzma.LZMADecompressor.__hash__" => "Return hash(self).",
+    "_lzma.LZMADecompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lzma.LZMADecompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lzma.LZMADecompressor.__le__" => "Return self<=value.",
+    "_lzma.LZMADecompressor.__lt__" => "Return self<value.",
+    "_lzma.LZMADecompressor.__ne__" => "Return self!=value.",
+    "_lzma.LZMADecompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lzma.LZMADecompressor.__reduce__" => "Helper for pickle.",
+    "_lzma.LZMADecompressor.__reduce_ex__" => "Helper for pickle.",
+    "_lzma.LZMADecompressor.__repr__" => "Return repr(self).",
+    "_lzma.LZMADecompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "_lzma.LZMADecompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "_lzma.LZMADecompressor.__str__" => "Return str(self).",
+    "_lzma.LZMADecompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.LZMADecompressor.check" => "ID of the integrity check used by the input stream.",
+    "_lzma.LZMADecompressor.decompress" => "Decompress *data*, returning uncompressed data as bytes.\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 stream is reached raises an\nEOFError.  Any data found after the end of the stream is ignored and saved in\nthe unused_data attribute.",
+    "_lzma.LZMADecompressor.eof" => "True if the end-of-stream marker has been reached.",
+    "_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.",
+    "_lzma.LZMAError.__ge__" => "Return self>=value.",
+    "_lzma.LZMAError.__getattribute__" => "Return getattr(self, name).",
+    "_lzma.LZMAError.__getstate__" => "Helper for pickle.",
+    "_lzma.LZMAError.__gt__" => "Return self>value.",
+    "_lzma.LZMAError.__hash__" => "Return hash(self).",
+    "_lzma.LZMAError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_lzma.LZMAError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_lzma.LZMAError.__le__" => "Return self<=value.",
+    "_lzma.LZMAError.__lt__" => "Return self<value.",
+    "_lzma.LZMAError.__ne__" => "Return self!=value.",
+    "_lzma.LZMAError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_lzma.LZMAError.__reduce_ex__" => "Helper for pickle.",
+    "_lzma.LZMAError.__repr__" => "Return repr(self).",
+    "_lzma.LZMAError.__setattr__" => "Implement setattr(self, name, value).",
+    "_lzma.LZMAError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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._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.",
+    "_md5.MD5Type.__delattr__" => "Implement delattr(self, name).",
+    "_md5.MD5Type.__eq__" => "Return self==value.",
+    "_md5.MD5Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_md5.MD5Type.__ge__" => "Return self>=value.",
+    "_md5.MD5Type.__getattribute__" => "Return getattr(self, name).",
+    "_md5.MD5Type.__getstate__" => "Helper for pickle.",
+    "_md5.MD5Type.__gt__" => "Return self>value.",
+    "_md5.MD5Type.__hash__" => "Return hash(self).",
+    "_md5.MD5Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_md5.MD5Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_md5.MD5Type.__le__" => "Return self<=value.",
+    "_md5.MD5Type.__lt__" => "Return self<value.",
+    "_md5.MD5Type.__ne__" => "Return self!=value.",
+    "_md5.MD5Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_md5.MD5Type.__reduce__" => "Helper for pickle.",
+    "_md5.MD5Type.__reduce_ex__" => "Helper for pickle.",
+    "_md5.MD5Type.__repr__" => "Return repr(self).",
+    "_md5.MD5Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_md5.MD5Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_md5.MD5Type.__str__" => "Return str(self).",
+    "_md5.MD5Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_md5.MD5Type.copy" => "Return a copy of the hash object.",
+    "_md5.MD5Type.digest" => "Return the digest value as a bytes object.",
+    "_md5.MD5Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_md5.MD5Type.update" => "Update this hash object's state with the provided string.",
+    "_md5.md5" => "Return a new MD5 hash object; optionally initialized with a string.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__delattr__" => "Implement delattr(self, name).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__eq__" => "Return self==value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__ge__" => "Return self>=value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__getattribute__" => "Return getattr(self, name).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__getstate__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__gt__" => "Return self>value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__hash__" => "Return hash(self).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__le__" => "Return self<=value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__lt__" => "Return self<value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__ne__" => "Return self!=value.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__reduce__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__reduce_ex__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__repr__" => "Return repr(self).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__setattr__" => "Implement setattr(self, name, value).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_multibytecodec.MultibyteIncrementalDecoder.__str__" => "Return str(self).",
+    "_multibytecodec.MultibyteIncrementalDecoder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_multibytecodec.MultibyteIncrementalDecoder.errors" => "how to treat errors",
+    "_multibytecodec.MultibyteIncrementalEncoder.__delattr__" => "Implement delattr(self, name).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__eq__" => "Return self==value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__ge__" => "Return self>=value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__getattribute__" => "Return getattr(self, name).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__getstate__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__gt__" => "Return self>value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__hash__" => "Return hash(self).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__le__" => "Return self<=value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__lt__" => "Return self<value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__ne__" => "Return self!=value.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__reduce__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__reduce_ex__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__repr__" => "Return repr(self).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__setattr__" => "Implement setattr(self, name, value).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__sizeof__" => "Size of object in memory, in bytes.",
+    "_multibytecodec.MultibyteIncrementalEncoder.__str__" => "Return str(self).",
+    "_multibytecodec.MultibyteIncrementalEncoder.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_multibytecodec.MultibyteIncrementalEncoder.errors" => "how to treat errors",
+    "_multibytecodec.MultibyteStreamReader.__delattr__" => "Implement delattr(self, name).",
+    "_multibytecodec.MultibyteStreamReader.__eq__" => "Return self==value.",
+    "_multibytecodec.MultibyteStreamReader.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_multibytecodec.MultibyteStreamReader.__ge__" => "Return self>=value.",
+    "_multibytecodec.MultibyteStreamReader.__getattribute__" => "Return getattr(self, name).",
+    "_multibytecodec.MultibyteStreamReader.__getstate__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamReader.__gt__" => "Return self>value.",
+    "_multibytecodec.MultibyteStreamReader.__hash__" => "Return hash(self).",
+    "_multibytecodec.MultibyteStreamReader.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_multibytecodec.MultibyteStreamReader.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_multibytecodec.MultibyteStreamReader.__le__" => "Return self<=value.",
+    "_multibytecodec.MultibyteStreamReader.__lt__" => "Return self<value.",
+    "_multibytecodec.MultibyteStreamReader.__ne__" => "Return self!=value.",
+    "_multibytecodec.MultibyteStreamReader.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_multibytecodec.MultibyteStreamReader.__reduce__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamReader.__reduce_ex__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamReader.__repr__" => "Return repr(self).",
+    "_multibytecodec.MultibyteStreamReader.__setattr__" => "Implement setattr(self, name, value).",
+    "_multibytecodec.MultibyteStreamReader.__sizeof__" => "Size of object in memory, in bytes.",
+    "_multibytecodec.MultibyteStreamReader.__str__" => "Return str(self).",
+    "_multibytecodec.MultibyteStreamReader.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_multibytecodec.MultibyteStreamReader.errors" => "how to treat errors",
+    "_multibytecodec.MultibyteStreamWriter.__delattr__" => "Implement delattr(self, name).",
+    "_multibytecodec.MultibyteStreamWriter.__eq__" => "Return self==value.",
+    "_multibytecodec.MultibyteStreamWriter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_multibytecodec.MultibyteStreamWriter.__ge__" => "Return self>=value.",
+    "_multibytecodec.MultibyteStreamWriter.__getattribute__" => "Return getattr(self, name).",
+    "_multibytecodec.MultibyteStreamWriter.__getstate__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamWriter.__gt__" => "Return self>value.",
+    "_multibytecodec.MultibyteStreamWriter.__hash__" => "Return hash(self).",
+    "_multibytecodec.MultibyteStreamWriter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_multibytecodec.MultibyteStreamWriter.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_multibytecodec.MultibyteStreamWriter.__le__" => "Return self<=value.",
+    "_multibytecodec.MultibyteStreamWriter.__lt__" => "Return self<value.",
+    "_multibytecodec.MultibyteStreamWriter.__ne__" => "Return self!=value.",
+    "_multibytecodec.MultibyteStreamWriter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_multibytecodec.MultibyteStreamWriter.__reduce__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamWriter.__reduce_ex__" => "Helper for pickle.",
+    "_multibytecodec.MultibyteStreamWriter.__repr__" => "Return repr(self).",
+    "_multibytecodec.MultibyteStreamWriter.__setattr__" => "Implement setattr(self, name, value).",
+    "_multibytecodec.MultibyteStreamWriter.__sizeof__" => "Size of object in memory, in bytes.",
+    "_multibytecodec.MultibyteStreamWriter.__str__" => "Return str(self).",
+    "_multibytecodec.MultibyteStreamWriter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_multibytecodec.MultibyteStreamWriter.errors" => "how to treat errors",
+    "_multiprocessing.SemLock" => "Semaphore/Mutex type",
+    "_multiprocessing.SemLock.__delattr__" => "Implement delattr(self, name).",
+    "_multiprocessing.SemLock.__enter__" => "Enter the semaphore/lock.",
+    "_multiprocessing.SemLock.__eq__" => "Return self==value.",
+    "_multiprocessing.SemLock.__exit__" => "Exit the semaphore/lock.",
+    "_multiprocessing.SemLock.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_multiprocessing.SemLock.__ge__" => "Return self>=value.",
+    "_multiprocessing.SemLock.__getattribute__" => "Return getattr(self, name).",
+    "_multiprocessing.SemLock.__getstate__" => "Helper for pickle.",
+    "_multiprocessing.SemLock.__gt__" => "Return self>value.",
+    "_multiprocessing.SemLock.__hash__" => "Return hash(self).",
+    "_multiprocessing.SemLock.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_multiprocessing.SemLock.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_multiprocessing.SemLock.__le__" => "Return self<=value.",
+    "_multiprocessing.SemLock.__lt__" => "Return self<value.",
+    "_multiprocessing.SemLock.__ne__" => "Return self!=value.",
+    "_multiprocessing.SemLock.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_multiprocessing.SemLock.__reduce__" => "Helper for pickle.",
+    "_multiprocessing.SemLock.__reduce_ex__" => "Helper for pickle.",
+    "_multiprocessing.SemLock.__repr__" => "Return repr(self).",
+    "_multiprocessing.SemLock.__setattr__" => "Implement setattr(self, name, value).",
+    "_multiprocessing.SemLock.__sizeof__" => "Size of object in memory, in bytes.",
+    "_multiprocessing.SemLock.__str__" => "Return str(self).",
+    "_multiprocessing.SemLock.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_multiprocessing.SemLock._after_fork" => "Rezero the net acquisition count after fork().",
+    "_multiprocessing.SemLock._count" => "Num of `acquire()`s minus num of `release()`s for this process.",
+    "_multiprocessing.SemLock._get_value" => "Get the value of the semaphore.",
+    "_multiprocessing.SemLock._is_mine" => "Whether the lock is owned by this thread.",
+    "_multiprocessing.SemLock._is_zero" => "Return whether semaphore has value zero.",
+    "_multiprocessing.SemLock.acquire" => "Acquire the semaphore/lock.",
+    "_multiprocessing.SemLock.handle" => "",
+    "_multiprocessing.SemLock.kind" => "",
+    "_multiprocessing.SemLock.maxvalue" => "",
+    "_multiprocessing.SemLock.name" => "",
+    "_multiprocessing.SemLock.release" => "Release the semaphore/lock.",
+    "_opcode" => "Opcode support module.",
+    "_opcode.get_executor" => "Return the executor object at offset in code if exists, None otherwise.",
+    "_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_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.",
+    "_opcode.has_exc" => "Return True if the opcode sets an exception handler, False otherwise.",
+    "_opcode.has_free" => "Return True if the opcode accesses a free variable, False otherwise.\n\nNote that 'free' in this context refers to names in the current scope\nthat are referenced by inner scopes or names in outer scopes that are\nreferenced from this scope. It does not include references to global\nor builtin scopes.",
+    "_opcode.has_jump" => "Return True if the opcode has a jump target, False otherwise.",
+    "_opcode.has_local" => "Return True if the opcode accesses a local variable, False otherwise.",
+    "_opcode.has_name" => "Return True if the opcode accesses an attribute by name, False otherwise.",
+    "_opcode.is_valid" => "Return True if opcode is valid, False otherwise.",
+    "_opcode.stack_effect" => "Compute the stack effect of the opcode.",
+    "_operator" => "Operator interface.\n\nThis module exports a set of functions implemented in C corresponding\nto the intrinsic operators of Python.  For example, operator.add(x, y)\nis equivalent to the expression x+y.  The function names are those\nused for special methods; variants without leading and trailing\n'__' are also provided for convenience.",
+    "_operator._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.",
+    "_operator.abs" => "Same as abs(a).",
+    "_operator.add" => "Same as a + b.",
+    "_operator.and_" => "Same as a & b.",
+    "_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).",
+    "_operator.countOf" => "Return the number of items in a which are, or which equal, b.",
+    "_operator.delitem" => "Same as del a[b].",
+    "_operator.eq" => "Same as a == b.",
+    "_operator.floordiv" => "Same as a // b.",
+    "_operator.ge" => "Same as a >= b.",
+    "_operator.getitem" => "Same as a[b].",
+    "_operator.gt" => "Same as a > b.",
+    "_operator.iadd" => "Same as a += b.",
+    "_operator.iand" => "Same as a &= b.",
+    "_operator.iconcat" => "Same as a += b, for a and b sequences.",
+    "_operator.ifloordiv" => "Same as a //= b.",
+    "_operator.ilshift" => "Same as a <<= b.",
+    "_operator.imatmul" => "Same as a @= b.",
+    "_operator.imod" => "Same as a %= b.",
+    "_operator.imul" => "Same as a *= b.",
+    "_operator.index" => "Same as a.__index__()",
+    "_operator.indexOf" => "Return the first index of b in a.",
+    "_operator.inv" => "Same as ~a.",
+    "_operator.invert" => "Same as ~a.",
+    "_operator.ior" => "Same as a |= b.",
+    "_operator.ipow" => "Same as a **= b.",
+    "_operator.irshift" => "Same as a >>= b.",
+    "_operator.is_" => "Same as a is b.",
+    "_operator.is_not" => "Same as a is not b.",
+    "_operator.isub" => "Same as a -= b.",
+    "_operator.itruediv" => "Same as a /= b.",
+    "_operator.ixor" => "Same as a ^= b.",
+    "_operator.le" => "Same as a <= b.",
+    "_operator.length_hint" => "Return an estimate of the number of items in obj.\n\nThis is useful for presizing containers when building from an iterable.\n\nIf the object supports len(), the result will be exact.\nOtherwise, it may over- or under-estimate by an arbitrary amount.\nThe result will be an integer >= 0.",
+    "_operator.lshift" => "Same as a << b.",
+    "_operator.lt" => "Same as a < b.",
+    "_operator.matmul" => "Same as a @ b.",
+    "_operator.mod" => "Same as a % b.",
+    "_operator.mul" => "Same as a * b.",
+    "_operator.ne" => "Same as a != b.",
+    "_operator.neg" => "Same as -a.",
+    "_operator.not_" => "Same as not a.",
+    "_operator.or_" => "Same as a | b.",
+    "_operator.pos" => "Same as +a.",
+    "_operator.pow" => "Same as a ** b.",
+    "_operator.rshift" => "Same as a >> b.",
+    "_operator.setitem" => "Same as a[b] = c.",
+    "_operator.sub" => "Same as a - b.",
+    "_operator.truediv" => "Same as a / b.",
+    "_operator.truth" => "Return True if a is true, False otherwise.",
+    "_operator.xor" => "Same as a ^ b.",
+    "_overlapped.BindLocal" => "Bind a socket handle to an arbitrary local port.\n\nfamily should be AF_INET or AF_INET6.",
+    "_overlapped.ConnectPipe" => "Connect to the pipe for asynchronous I/O (overlapped).",
+    "_overlapped.CreateEvent" => "Create an event.\n\nEventAttributes must be None.",
+    "_overlapped.CreateIoCompletionPort" => "Create a completion port or register a handle with a port.",
+    "_overlapped.FormatMessage" => "Return error message for an error code.",
+    "_overlapped.GetQueuedCompletionStatus" => "Get a message from completion port.\n\nWait for up to msecs milliseconds.",
+    "_overlapped.Overlapped" => "OVERLAPPED structure wrapper.",
+    "_overlapped.Overlapped.AcceptEx" => "Start overlapped wait for client to connect.",
+    "_overlapped.Overlapped.ConnectEx" => "Start overlapped connect.\n\nclient_handle should be unbound.",
+    "_overlapped.Overlapped.ConnectNamedPipe" => "Start overlapped wait for a client to connect.",
+    "_overlapped.Overlapped.ReadFile" => "Start overlapped read.",
+    "_overlapped.Overlapped.ReadFileInto" => "Start overlapped receive.",
+    "_overlapped.Overlapped.TransmitFile" => "Transmit file data over a connected socket.",
+    "_overlapped.Overlapped.WSARecv" => "Start overlapped receive.",
+    "_overlapped.Overlapped.WSARecvFrom" => "Start overlapped receive.",
+    "_overlapped.Overlapped.WSARecvFromInto" => "Start overlapped receive.",
+    "_overlapped.Overlapped.WSARecvInto" => "Start overlapped receive.",
+    "_overlapped.Overlapped.WSASend" => "Start overlapped send.",
+    "_overlapped.Overlapped.WSASendTo" => "Start overlapped sendto over a connectionless (UDP) socket.",
+    "_overlapped.Overlapped.WriteFile" => "Start overlapped write.",
+    "_overlapped.Overlapped.__delattr__" => "Implement delattr(self, name).",
+    "_overlapped.Overlapped.__eq__" => "Return self==value.",
+    "_overlapped.Overlapped.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_overlapped.Overlapped.__ge__" => "Return self>=value.",
+    "_overlapped.Overlapped.__getattribute__" => "Return getattr(self, name).",
+    "_overlapped.Overlapped.__getstate__" => "Helper for pickle.",
+    "_overlapped.Overlapped.__gt__" => "Return self>value.",
+    "_overlapped.Overlapped.__hash__" => "Return hash(self).",
+    "_overlapped.Overlapped.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_overlapped.Overlapped.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_overlapped.Overlapped.__le__" => "Return self<=value.",
+    "_overlapped.Overlapped.__lt__" => "Return self<value.",
+    "_overlapped.Overlapped.__ne__" => "Return self!=value.",
+    "_overlapped.Overlapped.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_overlapped.Overlapped.__reduce__" => "Helper for pickle.",
+    "_overlapped.Overlapped.__reduce_ex__" => "Helper for pickle.",
+    "_overlapped.Overlapped.__repr__" => "Return repr(self).",
+    "_overlapped.Overlapped.__setattr__" => "Implement setattr(self, name, value).",
+    "_overlapped.Overlapped.__sizeof__" => "Size of object in memory, in bytes.",
+    "_overlapped.Overlapped.__str__" => "Return str(self).",
+    "_overlapped.Overlapped.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_overlapped.Overlapped.address" => "Address of overlapped structure",
+    "_overlapped.Overlapped.cancel" => "Cancel overlapped operation.",
+    "_overlapped.Overlapped.error" => "Error from last operation",
+    "_overlapped.Overlapped.event" => "Overlapped event handle",
+    "_overlapped.Overlapped.getresult" => "Retrieve result of operation.\n\nIf wait is true then it blocks until the operation is finished.  If wait\nis false and the operation is still pending then an error is raised.",
+    "_overlapped.Overlapped.pending" => "Whether the operation is pending",
+    "_overlapped.PostQueuedCompletionStatus" => "Post a message to completion port.",
+    "_overlapped.RegisterWaitWithQueue" => "Register wait for Object; when complete CompletionPort is notified.",
+    "_overlapped.ResetEvent" => "Reset event.",
+    "_overlapped.SetEvent" => "Set event.",
+    "_overlapped.UnregisterWait" => "Unregister wait handle.",
+    "_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.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.",
+    "_pickle.PickleError.__ge__" => "Return self>=value.",
+    "_pickle.PickleError.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.PickleError.__getstate__" => "Helper for pickle.",
+    "_pickle.PickleError.__gt__" => "Return self>value.",
+    "_pickle.PickleError.__hash__" => "Return hash(self).",
+    "_pickle.PickleError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.PickleError.__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.PickleError.__le__" => "Return self<=value.",
+    "_pickle.PickleError.__lt__" => "Return self<value.",
+    "_pickle.PickleError.__ne__" => "Return self!=value.",
+    "_pickle.PickleError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.PickleError.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.PickleError.__repr__" => "Return repr(self).",
+    "_pickle.PickleError.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.PickleError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_pickle.Pickler.__ge__" => "Return self>=value.",
+    "_pickle.Pickler.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.Pickler.__getstate__" => "Helper for pickle.",
+    "_pickle.Pickler.__gt__" => "Return self>value.",
+    "_pickle.Pickler.__hash__" => "Return hash(self).",
+    "_pickle.Pickler.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.Pickler.__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.Pickler.__le__" => "Return self<=value.",
+    "_pickle.Pickler.__lt__" => "Return self<value.",
+    "_pickle.Pickler.__ne__" => "Return self!=value.",
+    "_pickle.Pickler.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.Pickler.__reduce__" => "Helper for pickle.",
+    "_pickle.Pickler.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.Pickler.__repr__" => "Return repr(self).",
+    "_pickle.Pickler.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.Pickler.__sizeof__" => "Returns size in memory, in bytes.",
+    "_pickle.Pickler.__str__" => "Return str(self).",
+    "_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.",
+    "_pickle.PicklingError.__ge__" => "Return self>=value.",
+    "_pickle.PicklingError.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.PicklingError.__getstate__" => "Helper for pickle.",
+    "_pickle.PicklingError.__gt__" => "Return self>value.",
+    "_pickle.PicklingError.__hash__" => "Return hash(self).",
+    "_pickle.PicklingError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.PicklingError.__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.PicklingError.__le__" => "Return self<=value.",
+    "_pickle.PicklingError.__lt__" => "Return self<value.",
+    "_pickle.PicklingError.__ne__" => "Return self!=value.",
+    "_pickle.PicklingError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.PicklingError.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.PicklingError.__repr__" => "Return repr(self).",
+    "_pickle.PicklingError.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.PicklingError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_pickle.Unpickler.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_pickle.Unpickler.__ge__" => "Return self>=value.",
+    "_pickle.Unpickler.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.Unpickler.__getstate__" => "Helper for pickle.",
+    "_pickle.Unpickler.__gt__" => "Return self>value.",
+    "_pickle.Unpickler.__hash__" => "Return hash(self).",
+    "_pickle.Unpickler.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.Unpickler.__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.Unpickler.__le__" => "Return self<=value.",
+    "_pickle.Unpickler.__lt__" => "Return self<value.",
+    "_pickle.Unpickler.__ne__" => "Return self!=value.",
+    "_pickle.Unpickler.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.Unpickler.__reduce__" => "Helper for pickle.",
+    "_pickle.Unpickler.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.Unpickler.__repr__" => "Return repr(self).",
+    "_pickle.Unpickler.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.Unpickler.__sizeof__" => "Returns size in memory, in bytes.",
+    "_pickle.Unpickler.__str__" => "Return str(self).",
+    "_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.",
+    "_pickle.UnpicklingError.__ge__" => "Return self>=value.",
+    "_pickle.UnpicklingError.__getattribute__" => "Return getattr(self, name).",
+    "_pickle.UnpicklingError.__getstate__" => "Helper for pickle.",
+    "_pickle.UnpicklingError.__gt__" => "Return self>value.",
+    "_pickle.UnpicklingError.__hash__" => "Return hash(self).",
+    "_pickle.UnpicklingError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_pickle.UnpicklingError.__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.UnpicklingError.__le__" => "Return self<=value.",
+    "_pickle.UnpicklingError.__lt__" => "Return self<value.",
+    "_pickle.UnpicklingError.__ne__" => "Return self!=value.",
+    "_pickle.UnpicklingError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_pickle.UnpicklingError.__reduce_ex__" => "Helper for pickle.",
+    "_pickle.UnpicklingError.__repr__" => "Return repr(self).",
+    "_pickle.UnpicklingError.__setattr__" => "Implement setattr(self, name, value).",
+    "_pickle.UnpicklingError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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",
+    "_posixshmem.shm_open" => "Open a shared memory object.  Returns a file descriptor (integer).",
+    "_posixshmem.shm_unlink" => "Remove a shared memory object (similar to unlink()).\n\nRemove a shared memory object name, and, once all processes  have  unmapped\nthe object, de-allocates and destroys the contents of the associated memory\nregion.",
+    "_posixsubprocess" => "A POSIX helper for the subprocess module.",
+    "_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.",
+    "_queue.Empty.__ge__" => "Return self>=value.",
+    "_queue.Empty.__getattribute__" => "Return getattr(self, name).",
+    "_queue.Empty.__getstate__" => "Helper for pickle.",
+    "_queue.Empty.__gt__" => "Return self>value.",
+    "_queue.Empty.__hash__" => "Return hash(self).",
+    "_queue.Empty.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_queue.Empty.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_queue.Empty.__le__" => "Return self<=value.",
+    "_queue.Empty.__lt__" => "Return self<value.",
+    "_queue.Empty.__ne__" => "Return self!=value.",
+    "_queue.Empty.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_queue.Empty.__reduce_ex__" => "Helper for pickle.",
+    "_queue.Empty.__repr__" => "Return repr(self).",
+    "_queue.Empty.__setattr__" => "Implement setattr(self, name, value).",
+    "_queue.Empty.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.SimpleQueue" => "Simple, unbounded, reentrant FIFO queue.",
+    "_queue.SimpleQueue.__class_getitem__" => "See PEP 585",
+    "_queue.SimpleQueue.__delattr__" => "Implement delattr(self, name).",
+    "_queue.SimpleQueue.__eq__" => "Return self==value.",
+    "_queue.SimpleQueue.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_queue.SimpleQueue.__ge__" => "Return self>=value.",
+    "_queue.SimpleQueue.__getattribute__" => "Return getattr(self, name).",
+    "_queue.SimpleQueue.__getstate__" => "Helper for pickle.",
+    "_queue.SimpleQueue.__gt__" => "Return self>value.",
+    "_queue.SimpleQueue.__hash__" => "Return hash(self).",
+    "_queue.SimpleQueue.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_queue.SimpleQueue.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_queue.SimpleQueue.__le__" => "Return self<=value.",
+    "_queue.SimpleQueue.__lt__" => "Return self<value.",
+    "_queue.SimpleQueue.__ne__" => "Return self!=value.",
+    "_queue.SimpleQueue.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_queue.SimpleQueue.__reduce__" => "Helper for pickle.",
+    "_queue.SimpleQueue.__reduce_ex__" => "Helper for pickle.",
+    "_queue.SimpleQueue.__repr__" => "Return repr(self).",
+    "_queue.SimpleQueue.__setattr__" => "Implement setattr(self, name, value).",
+    "_queue.SimpleQueue.__sizeof__" => "Size of object in memory, in bytes.",
+    "_queue.SimpleQueue.__str__" => "Return str(self).",
+    "_queue.SimpleQueue.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.SimpleQueue.empty" => "Return True if the queue is empty, False otherwise (not reliable!).",
+    "_queue.SimpleQueue.get" => "Remove and return an item from the queue.\n\nIf optional args 'block' is true and 'timeout' is None (the default),\nblock if necessary until an item is available. If 'timeout' is\na non-negative number, it blocks at most 'timeout' seconds and raises\nthe Empty exception if no item was available within that time.\nOtherwise ('block' is false), return an item if one is immediately\navailable, else raise the Empty exception ('timeout' is ignored\nin that case).",
+    "_queue.SimpleQueue.get_nowait" => "Remove and return an item from the queue without blocking.\n\nOnly get an item if one is immediately available. Otherwise\nraise the Empty exception.",
+    "_queue.SimpleQueue.put" => "Put the item on the queue.\n\nThe optional 'block' and 'timeout' arguments are ignored, as this method\nnever blocks.  They are provided for compatibility with the Queue class.",
+    "_queue.SimpleQueue.put_nowait" => "Put an item into the queue without blocking.\n\nThis is exactly equivalent to `put(item)` and is only provided\nfor compatibility with the Queue class.",
+    "_queue.SimpleQueue.qsize" => "Return the approximate size of the queue (not reliable!).",
+    "_random" => "Module implements the Mersenne Twister random number generator.",
+    "_random.Random" => "Random() -> create a random number generator with its own internal state.",
+    "_random.Random.__delattr__" => "Implement delattr(self, name).",
+    "_random.Random.__eq__" => "Return self==value.",
+    "_random.Random.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_random.Random.__ge__" => "Return self>=value.",
+    "_random.Random.__getattribute__" => "Return getattr(self, name).",
+    "_random.Random.__getstate__" => "Helper for pickle.",
+    "_random.Random.__gt__" => "Return self>value.",
+    "_random.Random.__hash__" => "Return hash(self).",
+    "_random.Random.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_random.Random.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_random.Random.__le__" => "Return self<=value.",
+    "_random.Random.__lt__" => "Return self<value.",
+    "_random.Random.__ne__" => "Return self!=value.",
+    "_random.Random.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_random.Random.__reduce__" => "Helper for pickle.",
+    "_random.Random.__reduce_ex__" => "Helper for pickle.",
+    "_random.Random.__repr__" => "Return repr(self).",
+    "_random.Random.__setattr__" => "Implement setattr(self, name, value).",
+    "_random.Random.__sizeof__" => "Size of object in memory, in bytes.",
+    "_random.Random.__str__" => "Return str(self).",
+    "_random.Random.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_random.Random.getrandbits" => "getrandbits(k) -> x.  Generates an int with k random bits.",
+    "_random.Random.getstate" => "getstate() -> tuple containing the current state.",
+    "_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.",
+    "_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.",
+    "_sha1.SHA1Type.__ge__" => "Return self>=value.",
+    "_sha1.SHA1Type.__getattribute__" => "Return getattr(self, name).",
+    "_sha1.SHA1Type.__getstate__" => "Helper for pickle.",
+    "_sha1.SHA1Type.__gt__" => "Return self>value.",
+    "_sha1.SHA1Type.__hash__" => "Return hash(self).",
+    "_sha1.SHA1Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha1.SHA1Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha1.SHA1Type.__le__" => "Return self<=value.",
+    "_sha1.SHA1Type.__lt__" => "Return self<value.",
+    "_sha1.SHA1Type.__ne__" => "Return self!=value.",
+    "_sha1.SHA1Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha1.SHA1Type.__reduce__" => "Helper for pickle.",
+    "_sha1.SHA1Type.__reduce_ex__" => "Helper for pickle.",
+    "_sha1.SHA1Type.__repr__" => "Return repr(self).",
+    "_sha1.SHA1Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha1.SHA1Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha1.SHA1Type.__str__" => "Return str(self).",
+    "_sha1.SHA1Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha1.SHA1Type.copy" => "Return a copy of the hash object.",
+    "_sha1.SHA1Type.digest" => "Return the digest value as a bytes object.",
+    "_sha1.SHA1Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha1.SHA1Type.update" => "Update this hash object's state with the provided string.",
+    "_sha1.sha1" => "Return a new SHA1 hash object; optionally initialized with a string.",
+    "_sha2.SHA224Type.__delattr__" => "Implement delattr(self, name).",
+    "_sha2.SHA224Type.__eq__" => "Return self==value.",
+    "_sha2.SHA224Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha2.SHA224Type.__ge__" => "Return self>=value.",
+    "_sha2.SHA224Type.__getattribute__" => "Return getattr(self, name).",
+    "_sha2.SHA224Type.__getstate__" => "Helper for pickle.",
+    "_sha2.SHA224Type.__gt__" => "Return self>value.",
+    "_sha2.SHA224Type.__hash__" => "Return hash(self).",
+    "_sha2.SHA224Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha2.SHA224Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha2.SHA224Type.__le__" => "Return self<=value.",
+    "_sha2.SHA224Type.__lt__" => "Return self<value.",
+    "_sha2.SHA224Type.__ne__" => "Return self!=value.",
+    "_sha2.SHA224Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha2.SHA224Type.__reduce__" => "Helper for pickle.",
+    "_sha2.SHA224Type.__reduce_ex__" => "Helper for pickle.",
+    "_sha2.SHA224Type.__repr__" => "Return repr(self).",
+    "_sha2.SHA224Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha2.SHA224Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha2.SHA224Type.__str__" => "Return str(self).",
+    "_sha2.SHA224Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha2.SHA224Type.copy" => "Return a copy of the hash object.",
+    "_sha2.SHA224Type.digest" => "Return the digest value as a bytes object.",
+    "_sha2.SHA224Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha2.SHA224Type.update" => "Update this hash object's state with the provided string.",
+    "_sha2.SHA256Type.__delattr__" => "Implement delattr(self, name).",
+    "_sha2.SHA256Type.__eq__" => "Return self==value.",
+    "_sha2.SHA256Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha2.SHA256Type.__ge__" => "Return self>=value.",
+    "_sha2.SHA256Type.__getattribute__" => "Return getattr(self, name).",
+    "_sha2.SHA256Type.__getstate__" => "Helper for pickle.",
+    "_sha2.SHA256Type.__gt__" => "Return self>value.",
+    "_sha2.SHA256Type.__hash__" => "Return hash(self).",
+    "_sha2.SHA256Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha2.SHA256Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha2.SHA256Type.__le__" => "Return self<=value.",
+    "_sha2.SHA256Type.__lt__" => "Return self<value.",
+    "_sha2.SHA256Type.__ne__" => "Return self!=value.",
+    "_sha2.SHA256Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha2.SHA256Type.__reduce__" => "Helper for pickle.",
+    "_sha2.SHA256Type.__reduce_ex__" => "Helper for pickle.",
+    "_sha2.SHA256Type.__repr__" => "Return repr(self).",
+    "_sha2.SHA256Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha2.SHA256Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha2.SHA256Type.__str__" => "Return str(self).",
+    "_sha2.SHA256Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha2.SHA256Type.copy" => "Return a copy of the hash object.",
+    "_sha2.SHA256Type.digest" => "Return the digest value as a bytes object.",
+    "_sha2.SHA256Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha2.SHA256Type.update" => "Update this hash object's state with the provided string.",
+    "_sha2.SHA384Type.__delattr__" => "Implement delattr(self, name).",
+    "_sha2.SHA384Type.__eq__" => "Return self==value.",
+    "_sha2.SHA384Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha2.SHA384Type.__ge__" => "Return self>=value.",
+    "_sha2.SHA384Type.__getattribute__" => "Return getattr(self, name).",
+    "_sha2.SHA384Type.__getstate__" => "Helper for pickle.",
+    "_sha2.SHA384Type.__gt__" => "Return self>value.",
+    "_sha2.SHA384Type.__hash__" => "Return hash(self).",
+    "_sha2.SHA384Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha2.SHA384Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha2.SHA384Type.__le__" => "Return self<=value.",
+    "_sha2.SHA384Type.__lt__" => "Return self<value.",
+    "_sha2.SHA384Type.__ne__" => "Return self!=value.",
+    "_sha2.SHA384Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha2.SHA384Type.__reduce__" => "Helper for pickle.",
+    "_sha2.SHA384Type.__reduce_ex__" => "Helper for pickle.",
+    "_sha2.SHA384Type.__repr__" => "Return repr(self).",
+    "_sha2.SHA384Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha2.SHA384Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha2.SHA384Type.__str__" => "Return str(self).",
+    "_sha2.SHA384Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha2.SHA384Type.copy" => "Return a copy of the hash object.",
+    "_sha2.SHA384Type.digest" => "Return the digest value as a bytes object.",
+    "_sha2.SHA384Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha2.SHA384Type.update" => "Update this hash object's state with the provided string.",
+    "_sha2.SHA512Type.__delattr__" => "Implement delattr(self, name).",
+    "_sha2.SHA512Type.__eq__" => "Return self==value.",
+    "_sha2.SHA512Type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha2.SHA512Type.__ge__" => "Return self>=value.",
+    "_sha2.SHA512Type.__getattribute__" => "Return getattr(self, name).",
+    "_sha2.SHA512Type.__getstate__" => "Helper for pickle.",
+    "_sha2.SHA512Type.__gt__" => "Return self>value.",
+    "_sha2.SHA512Type.__hash__" => "Return hash(self).",
+    "_sha2.SHA512Type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha2.SHA512Type.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha2.SHA512Type.__le__" => "Return self<=value.",
+    "_sha2.SHA512Type.__lt__" => "Return self<value.",
+    "_sha2.SHA512Type.__ne__" => "Return self!=value.",
+    "_sha2.SHA512Type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha2.SHA512Type.__reduce__" => "Helper for pickle.",
+    "_sha2.SHA512Type.__reduce_ex__" => "Helper for pickle.",
+    "_sha2.SHA512Type.__repr__" => "Return repr(self).",
+    "_sha2.SHA512Type.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha2.SHA512Type.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha2.SHA512Type.__str__" => "Return str(self).",
+    "_sha2.SHA512Type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha2.SHA512Type.copy" => "Return a copy of the hash object.",
+    "_sha2.SHA512Type.digest" => "Return the digest value as a bytes object.",
+    "_sha2.SHA512Type.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha2.SHA512Type.update" => "Update this hash object's state with the provided string.",
+    "_sha2.sha224" => "Return a new SHA-224 hash object; optionally initialized with a string.",
+    "_sha2.sha256" => "Return a new SHA-256 hash object; optionally initialized with a string.",
+    "_sha2.sha384" => "Return a new SHA-384 hash object; optionally initialized with a string.",
+    "_sha2.sha512" => "Return a new SHA-512 hash object; optionally initialized with a string.",
+    "_sha3.sha3_224" => "sha3_224([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 28 bytes.",
+    "_sha3.sha3_224.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.sha3_224.__eq__" => "Return self==value.",
+    "_sha3.sha3_224.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.sha3_224.__ge__" => "Return self>=value.",
+    "_sha3.sha3_224.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.sha3_224.__getstate__" => "Helper for pickle.",
+    "_sha3.sha3_224.__gt__" => "Return self>value.",
+    "_sha3.sha3_224.__hash__" => "Return hash(self).",
+    "_sha3.sha3_224.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.sha3_224.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.sha3_224.__le__" => "Return self<=value.",
+    "_sha3.sha3_224.__lt__" => "Return self<value.",
+    "_sha3.sha3_224.__ne__" => "Return self!=value.",
+    "_sha3.sha3_224.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.sha3_224.__reduce__" => "Helper for pickle.",
+    "_sha3.sha3_224.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.sha3_224.__repr__" => "Return repr(self).",
+    "_sha3.sha3_224.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.sha3_224.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.sha3_224.__str__" => "Return str(self).",
+    "_sha3.sha3_224.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.sha3_224.copy" => "Return a copy of the hash object.",
+    "_sha3.sha3_224.digest" => "Return the digest value as a bytes object.",
+    "_sha3.sha3_224.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha3.sha3_224.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_sha3.sha3_256" => "sha3_256([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 32 bytes.",
+    "_sha3.sha3_256.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.sha3_256.__eq__" => "Return self==value.",
+    "_sha3.sha3_256.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.sha3_256.__ge__" => "Return self>=value.",
+    "_sha3.sha3_256.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.sha3_256.__getstate__" => "Helper for pickle.",
+    "_sha3.sha3_256.__gt__" => "Return self>value.",
+    "_sha3.sha3_256.__hash__" => "Return hash(self).",
+    "_sha3.sha3_256.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.sha3_256.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.sha3_256.__le__" => "Return self<=value.",
+    "_sha3.sha3_256.__lt__" => "Return self<value.",
+    "_sha3.sha3_256.__ne__" => "Return self!=value.",
+    "_sha3.sha3_256.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.sha3_256.__reduce__" => "Helper for pickle.",
+    "_sha3.sha3_256.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.sha3_256.__repr__" => "Return repr(self).",
+    "_sha3.sha3_256.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.sha3_256.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.sha3_256.__str__" => "Return str(self).",
+    "_sha3.sha3_256.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.sha3_256.copy" => "Return a copy of the hash object.",
+    "_sha3.sha3_256.digest" => "Return the digest value as a bytes object.",
+    "_sha3.sha3_256.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha3.sha3_256.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_sha3.sha3_384" => "sha3_384([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 48 bytes.",
+    "_sha3.sha3_384.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.sha3_384.__eq__" => "Return self==value.",
+    "_sha3.sha3_384.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.sha3_384.__ge__" => "Return self>=value.",
+    "_sha3.sha3_384.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.sha3_384.__getstate__" => "Helper for pickle.",
+    "_sha3.sha3_384.__gt__" => "Return self>value.",
+    "_sha3.sha3_384.__hash__" => "Return hash(self).",
+    "_sha3.sha3_384.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.sha3_384.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.sha3_384.__le__" => "Return self<=value.",
+    "_sha3.sha3_384.__lt__" => "Return self<value.",
+    "_sha3.sha3_384.__ne__" => "Return self!=value.",
+    "_sha3.sha3_384.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.sha3_384.__reduce__" => "Helper for pickle.",
+    "_sha3.sha3_384.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.sha3_384.__repr__" => "Return repr(self).",
+    "_sha3.sha3_384.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.sha3_384.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.sha3_384.__str__" => "Return str(self).",
+    "_sha3.sha3_384.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.sha3_384.copy" => "Return a copy of the hash object.",
+    "_sha3.sha3_384.digest" => "Return the digest value as a bytes object.",
+    "_sha3.sha3_384.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha3.sha3_384.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_sha3.sha3_512" => "sha3_512([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 64 bytes.",
+    "_sha3.sha3_512.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.sha3_512.__eq__" => "Return self==value.",
+    "_sha3.sha3_512.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.sha3_512.__ge__" => "Return self>=value.",
+    "_sha3.sha3_512.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.sha3_512.__getstate__" => "Helper for pickle.",
+    "_sha3.sha3_512.__gt__" => "Return self>value.",
+    "_sha3.sha3_512.__hash__" => "Return hash(self).",
+    "_sha3.sha3_512.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.sha3_512.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.sha3_512.__le__" => "Return self<=value.",
+    "_sha3.sha3_512.__lt__" => "Return self<value.",
+    "_sha3.sha3_512.__ne__" => "Return self!=value.",
+    "_sha3.sha3_512.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.sha3_512.__reduce__" => "Helper for pickle.",
+    "_sha3.sha3_512.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.sha3_512.__repr__" => "Return repr(self).",
+    "_sha3.sha3_512.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.sha3_512.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.sha3_512.__str__" => "Return str(self).",
+    "_sha3.sha3_512.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.sha3_512.copy" => "Return a copy of the hash object.",
+    "_sha3.sha3_512.digest" => "Return the digest value as a bytes object.",
+    "_sha3.sha3_512.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha3.sha3_512.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_sha3.shake_128" => "shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.",
+    "_sha3.shake_128.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.shake_128.__eq__" => "Return self==value.",
+    "_sha3.shake_128.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.shake_128.__ge__" => "Return self>=value.",
+    "_sha3.shake_128.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.shake_128.__getstate__" => "Helper for pickle.",
+    "_sha3.shake_128.__gt__" => "Return self>value.",
+    "_sha3.shake_128.__hash__" => "Return hash(self).",
+    "_sha3.shake_128.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.shake_128.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.shake_128.__le__" => "Return self<=value.",
+    "_sha3.shake_128.__lt__" => "Return self<value.",
+    "_sha3.shake_128.__ne__" => "Return self!=value.",
+    "_sha3.shake_128.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.shake_128.__reduce__" => "Helper for pickle.",
+    "_sha3.shake_128.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.shake_128.__repr__" => "Return repr(self).",
+    "_sha3.shake_128.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.shake_128.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.shake_128.__str__" => "Return str(self).",
+    "_sha3.shake_128.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.shake_128.copy" => "Return a copy of the hash object.",
+    "_sha3.shake_128.digest" => "Return the digest value as a bytes object.",
+    "_sha3.shake_128.hexdigest" => "Return the digest value as a string of hexadecimal digits.",
+    "_sha3.shake_128.update" => "Update this hash object's state with the provided bytes-like object.",
+    "_sha3.shake_256" => "shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.",
+    "_sha3.shake_256.__delattr__" => "Implement delattr(self, name).",
+    "_sha3.shake_256.__eq__" => "Return self==value.",
+    "_sha3.shake_256.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_sha3.shake_256.__ge__" => "Return self>=value.",
+    "_sha3.shake_256.__getattribute__" => "Return getattr(self, name).",
+    "_sha3.shake_256.__getstate__" => "Helper for pickle.",
+    "_sha3.shake_256.__gt__" => "Return self>value.",
+    "_sha3.shake_256.__hash__" => "Return hash(self).",
+    "_sha3.shake_256.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_sha3.shake_256.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_sha3.shake_256.__le__" => "Return self<=value.",
+    "_sha3.shake_256.__lt__" => "Return self<value.",
+    "_sha3.shake_256.__ne__" => "Return self!=value.",
+    "_sha3.shake_256.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_sha3.shake_256.__reduce__" => "Helper for pickle.",
+    "_sha3.shake_256.__reduce_ex__" => "Helper for pickle.",
+    "_sha3.shake_256.__repr__" => "Return repr(self).",
+    "_sha3.shake_256.__setattr__" => "Implement setattr(self, name, value).",
+    "_sha3.shake_256.__sizeof__" => "Size of object in memory, in bytes.",
+    "_sha3.shake_256.__str__" => "Return str(self).",
+    "_sha3.shake_256.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_sha3.shake_256.copy" => "Return a copy of the hash object.",
+    "_sha3.shake_256.digest" => "Return the digest value as a bytes object.",
+    "_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.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.",
+    "_signal.getsignal" => "Return the current action for the given signal.\n\nThe return value can be:\n  SIG_IGN -- if the signal is being ignored\n  SIG_DFL -- if the default action for the signal is in effect\n  None    -- if an unknown handler is in effect\n  anything else -- the callable Python object used as a handler",
+    "_signal.pause" => "Wait until a signal arrives.",
+    "_signal.pidfd_send_signal" => "Send a signal to a process referred to by a pid file descriptor.",
+    "_signal.pthread_kill" => "Send a signal to a thread.",
+    "_signal.pthread_sigmask" => "Fetch and/or change the signal mask of the calling thread.",
+    "_signal.raise_signal" => "Send a signal to the executing process.",
+    "_signal.set_wakeup_fd" => "Sets the fd to be written to (with the signal number) when a signal comes in.\n\nA library can use this to wakeup select or poll.\nThe previous fd or -1 is returned.\n\nThe fd must be non-blocking.",
+    "_signal.setitimer" => "Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n\nThe timer will fire after value seconds and after that every interval seconds.\nThe itimer can be cleared by setting seconds to zero.\n\nReturns old values as a tuple: (delay, interval).",
+    "_signal.siginterrupt" => "Change system call restart behaviour.\n\nIf flag is False, system calls will be restarted when interrupted by\nsignal sig, else system calls will be interrupted.",
+    "_signal.signal" => "Set the action for the given signal.\n\nThe action can be SIG_DFL, SIG_IGN, or a callable Python object.\nThe previous action is returned.  See getsignal() for possible return values.\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.sigpending" => "Examine pending signals.\n\nReturns a set of signal numbers that are pending for delivery to\nthe calling thread.",
+    "_signal.sigtimedwait" => "Like sigwaitinfo(), but with a timeout.\n\nThe timeout is specified in seconds, with floating-point numbers allowed.",
+    "_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.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.",
+    "_socket.CMSG_SPACE" => "CMSG_SPACE(length) -> buffer size\n\nReturn the buffer size needed for recvmsg() to receive an ancillary\ndata item with associated data of the given length, along with any\ntrailing padding.  The buffer space needed to receive multiple items\nis the sum of the CMSG_SPACE() values for their associated data\nlengths.  Raises OverflowError if length is outside the permissible\nrange of values.",
+    "_socket.SocketType" => "socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object\nsocket(family=-1, type=-1, proto=-1, fileno=None) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\nThe socket is created as non-inheritable.\n\nWhen a fileno is passed in, family, type and proto are auto-detected,\nunless they are explicitly set.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\n_accept() -- accept connection, returning new socket fd and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket fd duplicated from fileno()\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten([n]) -- start listening for incoming connections\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(bool) -- set or clear the blocking I/O flag\ngetblocking() -- return True if socket is blocking, False if non-blocking\nsetsockopt(level, optname, value[, optlen]) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!",
+    "_socket.SocketType.__del__" => "Called when the instance is about to be destroyed.",
+    "_socket.SocketType.__delattr__" => "Implement delattr(self, name).",
+    "_socket.SocketType.__eq__" => "Return self==value.",
+    "_socket.SocketType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_socket.SocketType.__ge__" => "Return self>=value.",
+    "_socket.SocketType.__getattribute__" => "Return getattr(self, name).",
+    "_socket.SocketType.__getstate__" => "Helper for pickle.",
+    "_socket.SocketType.__gt__" => "Return self>value.",
+    "_socket.SocketType.__hash__" => "Return hash(self).",
+    "_socket.SocketType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_socket.SocketType.__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.SocketType.__le__" => "Return self<=value.",
+    "_socket.SocketType.__lt__" => "Return self<value.",
+    "_socket.SocketType.__ne__" => "Return self!=value.",
+    "_socket.SocketType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_socket.SocketType.__reduce__" => "Helper for pickle.",
+    "_socket.SocketType.__reduce_ex__" => "Helper for pickle.",
+    "_socket.SocketType.__repr__" => "Return repr(self).",
+    "_socket.SocketType.__setattr__" => "Implement setattr(self, name, value).",
+    "_socket.SocketType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_socket.SocketType.__str__" => "Return str(self).",
+    "_socket.SocketType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.SocketType._accept" => "_accept() -> (integer, address info)\n\nWait for an incoming connection.  Return a new socket file descriptor\nrepresenting the connection, and the address of the client.\nFor IP sockets, the address info is a pair (hostaddr, port).",
+    "_socket.SocketType.bind" => "bind(address)\n\nBind the socket to a local address.  For IP sockets, the address is a\npair (host, port); the host must refer to the local host. For raw packet\nsockets the address is a tuple (ifname, proto [,pkttype [,hatype [,addr]]])",
+    "_socket.SocketType.close" => "close()\n\nClose the socket.  It cannot be used after this call.",
+    "_socket.SocketType.connect" => "connect(address)\n\nConnect the socket to a remote address.  For IP sockets, the address\nis a pair (host, port).",
+    "_socket.SocketType.connect_ex" => "connect_ex(address) -> errno\n\nThis is like connect(address), but returns an error code (the errno value)\ninstead of raising an exception when an error occurs.",
+    "_socket.SocketType.detach" => "detach()\n\nClose the socket object without closing the underlying file descriptor.\nThe object cannot be used after this call, but the file descriptor\ncan be reused for other purposes.  The file descriptor is returned.",
+    "_socket.SocketType.family" => "the socket family",
+    "_socket.SocketType.fileno" => "fileno() -> integer\n\nReturn the integer file descriptor of the socket.",
+    "_socket.SocketType.getblocking" => "getblocking()\n\nReturns True if socket is in blocking mode, or False if it\nis in non-blocking mode.",
+    "_socket.SocketType.getpeername" => "getpeername() -> address info\n\nReturn the address of the remote endpoint.  For IP sockets, the address\ninfo is a pair (hostaddr, port).",
+    "_socket.SocketType.getsockname" => "getsockname() -> address info\n\nReturn the address of the local endpoint. The format depends on the\naddress family. For IPv4 sockets, the address info is a pair\n(hostaddr, port). For IPv6 sockets, the address info is a 4-tuple\n(hostaddr, port, flowinfo, scope_id).",
+    "_socket.SocketType.getsockopt" => "getsockopt(level, option[, buffersize]) -> value\n\nGet a socket option.  See the Unix manual for level and option.\nIf a nonzero buffersize argument is given, the return value is a\nstring of that length; otherwise it is an integer.",
+    "_socket.SocketType.gettimeout" => "gettimeout() -> timeout\n\nReturns the timeout in seconds (float) associated with socket\noperations. A timeout of None indicates that timeouts on socket\noperations are disabled.",
+    "_socket.SocketType.ioctl" => "ioctl(cmd, option) -> long\n\nControl the socket with WSAIoctl syscall. Currently supported 'cmd' values are\nSIO_RCVALL:  'option' must be one of the socket.RCVALL_* constants.\nSIO_KEEPALIVE_VALS:  'option' is a tuple of (onoff, timeout, interval).\nSIO_LOOPBACK_FAST_PATH: 'option' is a boolean value, and is disabled by default",
+    "_socket.SocketType.listen" => "listen([backlog])\n\nEnable a server to accept connections.  If backlog is specified, it must be\nat least 0 (if it is lower, it is set to 0); it specifies the number of\nunaccepted connections that the system will allow before refusing new\nconnections. If not specified, a default reasonable value is chosen.",
+    "_socket.SocketType.proto" => "the socket protocol",
+    "_socket.SocketType.recv" => "recv(buffersize[, flags]) -> data\n\nReceive up to buffersize bytes from the socket.  For the optional flags\nargument, see the Unix manual.  When no data is available, block until\nat least one byte is available or until the remote end is closed.  When\nthe remote end is closed and all data is read, return the empty string.",
+    "_socket.SocketType.recv_into" => "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\nA version of recv() that stores its data into a buffer rather than creating\na new string.  Receive up to buffersize bytes from the socket.  If buffersize\nis not specified (or 0), receive up to the size available in the given buffer.\n\nSee recv() for documentation about the flags.",
+    "_socket.SocketType.recvfrom" => "recvfrom(buffersize[, flags]) -> (data, address info)\n\nLike recv(buffersize, flags) but also return the sender's address info.",
+    "_socket.SocketType.recvfrom_into" => "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\nLike recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.",
+    "_socket.SocketType.recvmsg" => "recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\nReceive normal data (up to bufsize bytes) and ancillary data from the\nsocket.  The ancbufsize argument sets the size in bytes of the\ninternal buffer used to receive the ancillary data; it defaults to 0,\nmeaning that no ancillary data will be received.  Appropriate buffer\nsizes for ancillary data can be calculated using CMSG_SPACE() or\nCMSG_LEN(), and items which do not fit into the buffer might be\ntruncated or discarded.  The flags argument defaults to 0 and has the\nsame meaning as for recv().\n\nThe return value is a 4-tuple: (data, ancdata, msg_flags, address).\nThe data item is a bytes object holding the non-ancillary data\nreceived.  The ancdata item is a list of zero or more tuples\n(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n(control messages) received: cmsg_level and cmsg_type are integers\nspecifying the protocol level and protocol-specific type respectively,\nand cmsg_data is a bytes object holding the associated data.  The\nmsg_flags item is the bitwise OR of various flags indicating\nconditions on the received message; see your system documentation for\ndetails.  If the receiving socket is unconnected, address is the\naddress of the sending socket, if available; otherwise, its value is\nunspecified.\n\nIf recvmsg() raises an exception after the system call returns, it\nwill first attempt to close any file descriptors received via the\nSCM_RIGHTS mechanism.",
+    "_socket.SocketType.recvmsg_into" => "recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\nReceive normal data and ancillary data from the socket, scattering the\nnon-ancillary data into a series of buffers.  The buffers argument\nmust be an iterable of objects that export writable buffers\n(e.g. bytearray objects); these will be filled with successive chunks\nof the non-ancillary data until it has all been written or there are\nno more buffers.  The ancbufsize argument sets the size in bytes of\nthe internal buffer used to receive the ancillary data; it defaults to\n0, meaning that no ancillary data will be received.  Appropriate\nbuffer sizes for ancillary data can be calculated using CMSG_SPACE()\nor CMSG_LEN(), and items which do not fit into the buffer might be\ntruncated or discarded.  The flags argument defaults to 0 and has the\nsame meaning as for recv().\n\nThe return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\nThe nbytes item is the total number of bytes of non-ancillary data\nwritten into the buffers.  The ancdata item is a list of zero or more\ntuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\ndata (control messages) received: cmsg_level and cmsg_type are\nintegers specifying the protocol level and protocol-specific type\nrespectively, and cmsg_data is a bytes object holding the associated\ndata.  The msg_flags item is the bitwise OR of various flags\nindicating conditions on the received message; see your system\ndocumentation for details.  If the receiving socket is unconnected,\naddress is the address of the sending socket, if available; otherwise,\nits value is unspecified.\n\nIf recvmsg_into() raises an exception after the system call returns,\nit will first attempt to close any file descriptors received via the\nSCM_RIGHTS mechanism.",
+    "_socket.SocketType.send" => "send(data[, flags]) -> count\n\nSend a data string to the socket.  For the optional flags\nargument, see the Unix manual.  Return the number of bytes\nsent; this may be less than len(data) if the network is busy.",
+    "_socket.SocketType.sendall" => "sendall(data[, flags])\n\nSend a data string to the socket.  For the optional flags\nargument, see the Unix manual.  This calls send() repeatedly\nuntil all data is sent.  If an error occurs, it's impossible\nto tell how much data has been sent.",
+    "_socket.SocketType.sendmsg" => "sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\nSend normal and ancillary data to the socket, gathering the\nnon-ancillary data from a series of buffers and concatenating it into\na single message.  The buffers argument specifies the non-ancillary\ndata as an iterable of bytes-like objects (e.g. bytes objects).\nThe ancdata argument specifies the ancillary data (control messages)\nas an iterable of zero or more tuples (cmsg_level, cmsg_type,\ncmsg_data), where cmsg_level and cmsg_type are integers specifying the\nprotocol level and protocol-specific type respectively, and cmsg_data\nis a bytes-like object holding the associated data.  The flags\nargument defaults to 0 and has the same meaning as for send().  If\naddress is supplied and not None, it sets a destination address for\nthe message.  The return value is the number of bytes of non-ancillary\ndata sent.",
+    "_socket.SocketType.sendmsg_afalg" => "sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])\n\nSet operation mode, IV and length of associated data for an AF_ALG\noperation socket.",
+    "_socket.SocketType.sendto" => "sendto(data[, flags], address) -> count\n\nLike send(data, flags) but allows specifying the destination address.\nFor IP sockets, the address is a pair (hostaddr, port).",
+    "_socket.SocketType.setblocking" => "setblocking(flag)\n\nSet the socket to blocking (flag is true) or non-blocking (false).\nsetblocking(True) is equivalent to settimeout(None);\nsetblocking(False) is equivalent to settimeout(0.0).",
+    "_socket.SocketType.setsockopt" => "setsockopt(level, option, value: int)\nsetsockopt(level, option, value: buffer)\nsetsockopt(level, option, None, optlen: int)\n\nSet a socket option.  See the Unix manual for level and option.\nThe value argument can either be an integer, a string buffer, or\nNone, optlen.",
+    "_socket.SocketType.settimeout" => "settimeout(timeout)\n\nSet a timeout on socket operations.  'timeout' can be a float,\ngiving in seconds, or None.  Setting a timeout of None disables\nthe timeout feature and is equivalent to setblocking(1).\nSetting a timeout of zero is the same as setblocking(0).",
+    "_socket.SocketType.share" => "share(process_id) -> bytes\n\nShare the socket with another process.  The target process id\nmust be provided and the resulting bytes object passed to the target\nprocess.  There the shared socket can be instantiated by calling\nsocket.fromshare().",
+    "_socket.SocketType.shutdown" => "shutdown(flag)\n\nShut down the reading side of the socket (flag == SHUT_RD), the writing side\nof the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).",
+    "_socket.SocketType.timeout" => "the socket timeout",
+    "_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.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.",
+    "_socket.gethostbyname" => "gethostbyname(host) -> address\n\nReturn the IP address (a string of the form '255.255.255.255') for a host.",
+    "_socket.gethostbyname_ex" => "gethostbyname_ex(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.",
+    "_socket.gethostname" => "gethostname() -> string\n\nReturn the current host name.",
+    "_socket.getnameinfo" => "getnameinfo(sockaddr, flags) --> (host, port)\n\nGet host and port for a sockaddr.",
+    "_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.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_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.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.",
+    "_socket.socket" => "socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object\nsocket(family=-1, type=-1, proto=-1, fileno=None) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\nThe socket is created as non-inheritable.\n\nWhen a fileno is passed in, family, type and proto are auto-detected,\nunless they are explicitly set.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\n_accept() -- accept connection, returning new socket fd and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket fd duplicated from fileno()\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten([n]) -- start listening for incoming connections\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(bool) -- set or clear the blocking I/O flag\ngetblocking() -- return True if socket is blocking, False if non-blocking\nsetsockopt(level, optname, value[, optlen]) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!",
+    "_socket.socket.__del__" => "Called when the instance is about to be destroyed.",
+    "_socket.socket.__delattr__" => "Implement delattr(self, name).",
+    "_socket.socket.__eq__" => "Return self==value.",
+    "_socket.socket.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_socket.socket.__ge__" => "Return self>=value.",
+    "_socket.socket.__getattribute__" => "Return getattr(self, name).",
+    "_socket.socket.__getstate__" => "Helper for pickle.",
+    "_socket.socket.__gt__" => "Return self>value.",
+    "_socket.socket.__hash__" => "Return hash(self).",
+    "_socket.socket.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_socket.socket.__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.socket.__le__" => "Return self<=value.",
+    "_socket.socket.__lt__" => "Return self<value.",
+    "_socket.socket.__ne__" => "Return self!=value.",
+    "_socket.socket.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_socket.socket.__reduce__" => "Helper for pickle.",
+    "_socket.socket.__reduce_ex__" => "Helper for pickle.",
+    "_socket.socket.__repr__" => "Return repr(self).",
+    "_socket.socket.__setattr__" => "Implement setattr(self, name, value).",
+    "_socket.socket.__sizeof__" => "Size of object in memory, in bytes.",
+    "_socket.socket.__str__" => "Return str(self).",
+    "_socket.socket.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.socket._accept" => "_accept() -> (integer, address info)\n\nWait for an incoming connection.  Return a new socket file descriptor\nrepresenting the connection, and the address of the client.\nFor IP sockets, the address info is a pair (hostaddr, port).",
+    "_socket.socket.bind" => "bind(address)\n\nBind the socket to a local address.  For IP sockets, the address is a\npair (host, port); the host must refer to the local host. For raw packet\nsockets the address is a tuple (ifname, proto [,pkttype [,hatype [,addr]]])",
+    "_socket.socket.close" => "close()\n\nClose the socket.  It cannot be used after this call.",
+    "_socket.socket.connect" => "connect(address)\n\nConnect the socket to a remote address.  For IP sockets, the address\nis a pair (host, port).",
+    "_socket.socket.connect_ex" => "connect_ex(address) -> errno\n\nThis is like connect(address), but returns an error code (the errno value)\ninstead of raising an exception when an error occurs.",
+    "_socket.socket.detach" => "detach()\n\nClose the socket object without closing the underlying file descriptor.\nThe object cannot be used after this call, but the file descriptor\ncan be reused for other purposes.  The file descriptor is returned.",
+    "_socket.socket.family" => "the socket family",
+    "_socket.socket.fileno" => "fileno() -> integer\n\nReturn the integer file descriptor of the socket.",
+    "_socket.socket.getblocking" => "getblocking()\n\nReturns True if socket is in blocking mode, or False if it\nis in non-blocking mode.",
+    "_socket.socket.getpeername" => "getpeername() -> address info\n\nReturn the address of the remote endpoint.  For IP sockets, the address\ninfo is a pair (hostaddr, port).",
+    "_socket.socket.getsockname" => "getsockname() -> address info\n\nReturn the address of the local endpoint. The format depends on the\naddress family. For IPv4 sockets, the address info is a pair\n(hostaddr, port). For IPv6 sockets, the address info is a 4-tuple\n(hostaddr, port, flowinfo, scope_id).",
+    "_socket.socket.getsockopt" => "getsockopt(level, option[, buffersize]) -> value\n\nGet a socket option.  See the Unix manual for level and option.\nIf a nonzero buffersize argument is given, the return value is a\nstring of that length; otherwise it is an integer.",
+    "_socket.socket.gettimeout" => "gettimeout() -> timeout\n\nReturns the timeout in seconds (float) associated with socket\noperations. A timeout of None indicates that timeouts on socket\noperations are disabled.",
+    "_socket.socket.ioctl" => "ioctl(cmd, option) -> long\n\nControl the socket with WSAIoctl syscall. Currently supported 'cmd' values are\nSIO_RCVALL:  'option' must be one of the socket.RCVALL_* constants.\nSIO_KEEPALIVE_VALS:  'option' is a tuple of (onoff, timeout, interval).\nSIO_LOOPBACK_FAST_PATH: 'option' is a boolean value, and is disabled by default",
+    "_socket.socket.listen" => "listen([backlog])\n\nEnable a server to accept connections.  If backlog is specified, it must be\nat least 0 (if it is lower, it is set to 0); it specifies the number of\nunaccepted connections that the system will allow before refusing new\nconnections. If not specified, a default reasonable value is chosen.",
+    "_socket.socket.proto" => "the socket protocol",
+    "_socket.socket.recv" => "recv(buffersize[, flags]) -> data\n\nReceive up to buffersize bytes from the socket.  For the optional flags\nargument, see the Unix manual.  When no data is available, block until\nat least one byte is available or until the remote end is closed.  When\nthe remote end is closed and all data is read, return the empty string.",
+    "_socket.socket.recv_into" => "recv_into(buffer, [nbytes[, flags]]) -> nbytes_read\n\nA version of recv() that stores its data into a buffer rather than creating\na new string.  Receive up to buffersize bytes from the socket.  If buffersize\nis not specified (or 0), receive up to the size available in the given buffer.\n\nSee recv() for documentation about the flags.",
+    "_socket.socket.recvfrom" => "recvfrom(buffersize[, flags]) -> (data, address info)\n\nLike recv(buffersize, flags) but also return the sender's address info.",
+    "_socket.socket.recvfrom_into" => "recvfrom_into(buffer[, nbytes[, flags]]) -> (nbytes, address info)\n\nLike recv_into(buffer[, nbytes[, flags]]) but also return the sender's address info.",
+    "_socket.socket.recvmsg" => "recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)\n\nReceive normal data (up to bufsize bytes) and ancillary data from the\nsocket.  The ancbufsize argument sets the size in bytes of the\ninternal buffer used to receive the ancillary data; it defaults to 0,\nmeaning that no ancillary data will be received.  Appropriate buffer\nsizes for ancillary data can be calculated using CMSG_SPACE() or\nCMSG_LEN(), and items which do not fit into the buffer might be\ntruncated or discarded.  The flags argument defaults to 0 and has the\nsame meaning as for recv().\n\nThe return value is a 4-tuple: (data, ancdata, msg_flags, address).\nThe data item is a bytes object holding the non-ancillary data\nreceived.  The ancdata item is a list of zero or more tuples\n(cmsg_level, cmsg_type, cmsg_data) representing the ancillary data\n(control messages) received: cmsg_level and cmsg_type are integers\nspecifying the protocol level and protocol-specific type respectively,\nand cmsg_data is a bytes object holding the associated data.  The\nmsg_flags item is the bitwise OR of various flags indicating\nconditions on the received message; see your system documentation for\ndetails.  If the receiving socket is unconnected, address is the\naddress of the sending socket, if available; otherwise, its value is\nunspecified.\n\nIf recvmsg() raises an exception after the system call returns, it\nwill first attempt to close any file descriptors received via the\nSCM_RIGHTS mechanism.",
+    "_socket.socket.recvmsg_into" => "recvmsg_into(buffers[, ancbufsize[, flags]]) -> (nbytes, ancdata, msg_flags, address)\n\nReceive normal data and ancillary data from the socket, scattering the\nnon-ancillary data into a series of buffers.  The buffers argument\nmust be an iterable of objects that export writable buffers\n(e.g. bytearray objects); these will be filled with successive chunks\nof the non-ancillary data until it has all been written or there are\nno more buffers.  The ancbufsize argument sets the size in bytes of\nthe internal buffer used to receive the ancillary data; it defaults to\n0, meaning that no ancillary data will be received.  Appropriate\nbuffer sizes for ancillary data can be calculated using CMSG_SPACE()\nor CMSG_LEN(), and items which do not fit into the buffer might be\ntruncated or discarded.  The flags argument defaults to 0 and has the\nsame meaning as for recv().\n\nThe return value is a 4-tuple: (nbytes, ancdata, msg_flags, address).\nThe nbytes item is the total number of bytes of non-ancillary data\nwritten into the buffers.  The ancdata item is a list of zero or more\ntuples (cmsg_level, cmsg_type, cmsg_data) representing the ancillary\ndata (control messages) received: cmsg_level and cmsg_type are\nintegers specifying the protocol level and protocol-specific type\nrespectively, and cmsg_data is a bytes object holding the associated\ndata.  The msg_flags item is the bitwise OR of various flags\nindicating conditions on the received message; see your system\ndocumentation for details.  If the receiving socket is unconnected,\naddress is the address of the sending socket, if available; otherwise,\nits value is unspecified.\n\nIf recvmsg_into() raises an exception after the system call returns,\nit will first attempt to close any file descriptors received via the\nSCM_RIGHTS mechanism.",
+    "_socket.socket.send" => "send(data[, flags]) -> count\n\nSend a data string to the socket.  For the optional flags\nargument, see the Unix manual.  Return the number of bytes\nsent; this may be less than len(data) if the network is busy.",
+    "_socket.socket.sendall" => "sendall(data[, flags])\n\nSend a data string to the socket.  For the optional flags\nargument, see the Unix manual.  This calls send() repeatedly\nuntil all data is sent.  If an error occurs, it's impossible\nto tell how much data has been sent.",
+    "_socket.socket.sendmsg" => "sendmsg(buffers[, ancdata[, flags[, address]]]) -> count\n\nSend normal and ancillary data to the socket, gathering the\nnon-ancillary data from a series of buffers and concatenating it into\na single message.  The buffers argument specifies the non-ancillary\ndata as an iterable of bytes-like objects (e.g. bytes objects).\nThe ancdata argument specifies the ancillary data (control messages)\nas an iterable of zero or more tuples (cmsg_level, cmsg_type,\ncmsg_data), where cmsg_level and cmsg_type are integers specifying the\nprotocol level and protocol-specific type respectively, and cmsg_data\nis a bytes-like object holding the associated data.  The flags\nargument defaults to 0 and has the same meaning as for send().  If\naddress is supplied and not None, it sets a destination address for\nthe message.  The return value is the number of bytes of non-ancillary\ndata sent.",
+    "_socket.socket.sendmsg_afalg" => "sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags=MSG_MORE]]])\n\nSet operation mode, IV and length of associated data for an AF_ALG\noperation socket.",
+    "_socket.socket.sendto" => "sendto(data[, flags], address) -> count\n\nLike send(data, flags) but allows specifying the destination address.\nFor IP sockets, the address is a pair (hostaddr, port).",
+    "_socket.socket.setblocking" => "setblocking(flag)\n\nSet the socket to blocking (flag is true) or non-blocking (false).\nsetblocking(True) is equivalent to settimeout(None);\nsetblocking(False) is equivalent to settimeout(0.0).",
+    "_socket.socket.setsockopt" => "setsockopt(level, option, value: int)\nsetsockopt(level, option, value: buffer)\nsetsockopt(level, option, None, optlen: int)\n\nSet a socket option.  See the Unix manual for level and option.\nThe value argument can either be an integer, a string buffer, or\nNone, optlen.",
+    "_socket.socket.settimeout" => "settimeout(timeout)\n\nSet a timeout on socket operations.  'timeout' can be a float,\ngiving in seconds, or None.  Setting a timeout of None disables\nthe timeout feature and is equivalent to setblocking(1).\nSetting a timeout of zero is the same as setblocking(0).",
+    "_socket.socket.share" => "share(process_id) -> bytes\n\nShare the socket with another process.  The target process id\nmust be provided and the resulting bytes object passed to the target\nprocess.  There the shared socket can be instantiated by calling\nsocket.fromshare().",
+    "_socket.socket.shutdown" => "shutdown(flag)\n\nShut down the reading side of the socket (flag == SHUT_RD), the writing side\nof the socket (flag == SHUT_WR), or both ends (flag == SHUT_RDWR).",
+    "_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.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]",
+    "_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.",
+    "_ssl.Certificate.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.Certificate.__ge__" => "Return self>=value.",
+    "_ssl.Certificate.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.Certificate.__getstate__" => "Helper for pickle.",
+    "_ssl.Certificate.__gt__" => "Return self>value.",
+    "_ssl.Certificate.__hash__" => "Return hash(self).",
+    "_ssl.Certificate.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.Certificate.__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.Certificate.__le__" => "Return self<=value.",
+    "_ssl.Certificate.__lt__" => "Return self<value.",
+    "_ssl.Certificate.__ne__" => "Return self!=value.",
+    "_ssl.Certificate.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.Certificate.__reduce__" => "Helper for pickle.",
+    "_ssl.Certificate.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.Certificate.__repr__" => "Return repr(self).",
+    "_ssl.Certificate.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.Certificate.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.Certificate.__str__" => "Return str(self).",
+    "_ssl.Certificate.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.MemoryBIO.__delattr__" => "Implement delattr(self, name).",
+    "_ssl.MemoryBIO.__eq__" => "Return self==value.",
+    "_ssl.MemoryBIO.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl.MemoryBIO.__ge__" => "Return self>=value.",
+    "_ssl.MemoryBIO.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.MemoryBIO.__getstate__" => "Helper for pickle.",
+    "_ssl.MemoryBIO.__gt__" => "Return self>value.",
+    "_ssl.MemoryBIO.__hash__" => "Return hash(self).",
+    "_ssl.MemoryBIO.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.MemoryBIO.__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.MemoryBIO.__le__" => "Return self<=value.",
+    "_ssl.MemoryBIO.__lt__" => "Return self<value.",
+    "_ssl.MemoryBIO.__ne__" => "Return self!=value.",
+    "_ssl.MemoryBIO.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.MemoryBIO.__reduce__" => "Helper for pickle.",
+    "_ssl.MemoryBIO.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.MemoryBIO.__repr__" => "Return repr(self).",
+    "_ssl.MemoryBIO.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.MemoryBIO.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.MemoryBIO.__str__" => "Return str(self).",
+    "_ssl.MemoryBIO.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.MemoryBIO.eof" => "Whether the memory BIO is at EOF.",
+    "_ssl.MemoryBIO.pending" => "The number of bytes pending in the memory BIO.",
+    "_ssl.MemoryBIO.read" => "Read up to size bytes from the memory BIO.\n\nIf size is not specified, read the entire buffer.\nIf the return value is an empty bytes instance, this means either\nEOF or that no data is available. Use the \"eof\" property to\ndistinguish between the two.",
+    "_ssl.MemoryBIO.write" => "Writes the bytes b into the memory BIO.\n\nReturns the number of bytes written.",
+    "_ssl.MemoryBIO.write_eof" => "Write an EOF marker to the memory BIO.\n\nWhen all data has been read, the \"eof\" property will be True.",
+    "_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.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.",
+    "_ssl.SSLSession.__ge__" => "Return self>=value.",
+    "_ssl.SSLSession.__getattribute__" => "Return getattr(self, name).",
+    "_ssl.SSLSession.__getstate__" => "Helper for pickle.",
+    "_ssl.SSLSession.__gt__" => "Return self>value.",
+    "_ssl.SSLSession.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl.SSLSession.__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.SSLSession.__le__" => "Return self<=value.",
+    "_ssl.SSLSession.__lt__" => "Return self<value.",
+    "_ssl.SSLSession.__ne__" => "Return self!=value.",
+    "_ssl.SSLSession.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl.SSLSession.__reduce__" => "Helper for pickle.",
+    "_ssl.SSLSession.__reduce_ex__" => "Helper for pickle.",
+    "_ssl.SSLSession.__repr__" => "Return repr(self).",
+    "_ssl.SSLSession.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl.SSLSession.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl.SSLSession.__str__" => "Return str(self).",
+    "_ssl.SSLSession.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.SSLSession.has_ticket" => "Does the session contain a ticket?",
+    "_ssl.SSLSession.id" => "Session ID.",
+    "_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._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.",
+    "_ssl._SSLContext.__ge__" => "Return self>=value.",
+    "_ssl._SSLContext.__getattribute__" => "Return getattr(self, name).",
+    "_ssl._SSLContext.__getstate__" => "Helper for pickle.",
+    "_ssl._SSLContext.__gt__" => "Return self>value.",
+    "_ssl._SSLContext.__hash__" => "Return hash(self).",
+    "_ssl._SSLContext.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl._SSLContext.__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._SSLContext.__le__" => "Return self<=value.",
+    "_ssl._SSLContext.__lt__" => "Return self<value.",
+    "_ssl._SSLContext.__ne__" => "Return self!=value.",
+    "_ssl._SSLContext.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl._SSLContext.__reduce__" => "Helper for pickle.",
+    "_ssl._SSLContext.__reduce_ex__" => "Helper for pickle.",
+    "_ssl._SSLContext.__repr__" => "Return repr(self).",
+    "_ssl._SSLContext.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl._SSLContext.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl._SSLContext.__str__" => "Return str(self).",
+    "_ssl._SSLContext.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._SSLContext.cert_store_stats" => "Returns quantities of loaded X.509 certificates.\n\nX.509 certificates with a CA extension and certificate revocation lists\ninside the context's cert store.\n\nNOTE: Certificates in a capath directory aren't loaded unless they have\nbeen used at least once.",
+    "_ssl._SSLContext.get_ca_certs" => "Returns a list of dicts with information of loaded CA certs.\n\nIf the optional argument is True, returns a DER-encoded copy of the CA\ncertificate.\n\nNOTE: Certificates in a capath directory aren't loaded unless they have\nbeen used at least once.",
+    "_ssl._SSLContext.num_tickets" => "Control the number of TLSv1.3 session tickets.",
+    "_ssl._SSLContext.security_level" => "The current security level.",
+    "_ssl._SSLContext.sni_callback" => "Set a callback that will be called when a server name is provided by the SSL/TLS client in the SNI extension.\n\nIf the argument is None then the callback is disabled. The method is called\nwith the SSLSocket, the server name as a string, and the SSLContext object.\n\nSee RFC 6066 for details of the SNI extension.",
+    "_ssl._SSLSocket.__delattr__" => "Implement delattr(self, name).",
+    "_ssl._SSLSocket.__eq__" => "Return self==value.",
+    "_ssl._SSLSocket.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_ssl._SSLSocket.__ge__" => "Return self>=value.",
+    "_ssl._SSLSocket.__getattribute__" => "Return getattr(self, name).",
+    "_ssl._SSLSocket.__getstate__" => "Helper for pickle.",
+    "_ssl._SSLSocket.__gt__" => "Return self>value.",
+    "_ssl._SSLSocket.__hash__" => "Return hash(self).",
+    "_ssl._SSLSocket.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_ssl._SSLSocket.__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._SSLSocket.__le__" => "Return self<=value.",
+    "_ssl._SSLSocket.__lt__" => "Return self<value.",
+    "_ssl._SSLSocket.__ne__" => "Return self!=value.",
+    "_ssl._SSLSocket.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_ssl._SSLSocket.__reduce__" => "Helper for pickle.",
+    "_ssl._SSLSocket.__reduce_ex__" => "Helper for pickle.",
+    "_ssl._SSLSocket.__repr__" => "Return repr(self).",
+    "_ssl._SSLSocket.__setattr__" => "Implement setattr(self, name, value).",
+    "_ssl._SSLSocket.__sizeof__" => "Size of object in memory, in bytes.",
+    "_ssl._SSLSocket.__str__" => "Return str(self).",
+    "_ssl._SSLSocket.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._SSLSocket.context" => "This changes the context associated with the SSLSocket.\n\nThis is typically used from within a callback function set by the sni_callback\non the SSLContext to change the certificate information associated with the\nSSLSocket before the cryptographic exchange handshake messages.",
+    "_ssl._SSLSocket.get_channel_binding" => "Get channel binding data for current connection.\n\nRaise ValueError if the requested `cb_type` is not supported.  Return bytes\nof the data or None if the data is not available (e.g. before the handshake).\nOnly 'tls-unique' channel binding data from RFC 5929 is supported.",
+    "_ssl._SSLSocket.getpeercert" => "Returns the certificate for the peer.\n\nIf no certificate was provided, returns None.  If a certificate was\nprovided, but not validated, returns an empty dictionary.  Otherwise\nreturns a dict containing information about the peer certificate.\n\nIf the optional argument is True, returns a DER-encoded copy of the\npeer certificate, or None if no certificate was provided.  This will\nreturn the certificate even if it wasn't validated.",
+    "_ssl._SSLSocket.owner" => "The Python-level owner of this object.\n\nPassed as \"self\" in servername callback.",
+    "_ssl._SSLSocket.pending" => "Returns the number of already decrypted bytes available for read, pending on the connection.",
+    "_ssl._SSLSocket.read" => "read(size, [buffer])\nRead up to size bytes from the SSL socket.",
+    "_ssl._SSLSocket.server_hostname" => "The currently set server hostname (for SNI).",
+    "_ssl._SSLSocket.server_side" => "Whether this is a server-side socket.",
+    "_ssl._SSLSocket.session" => "The underlying SSLSession object.",
+    "_ssl._SSLSocket.session_reused" => "Was the client session reused during handshake?",
+    "_ssl._SSLSocket.shutdown" => "Does the SSL shutdown handshake with the remote end.",
+    "_ssl._SSLSocket.verify_client_post_handshake" => "Initiate TLS 1.3 post-handshake authentication",
+    "_ssl._SSLSocket.write" => "Writes the bytes-like object b into the SSL object.\n\nReturns the number of bytes written.",
+    "_ssl.enum_certificates" => "Retrieve certificates from Windows' cert store.\n\nstore_name may be one of 'CA', 'ROOT' or 'MY'.  The system may provide\nmore cert storages, too.  The function returns a list of (bytes,\nencoding_type, trust) tuples.  The encoding_type flag can be interpreted\nwith X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either\na set of OIDs or the boolean True.",
+    "_ssl.enum_crls" => "Retrieve CRLs from Windows' cert store.\n\nstore_name may be one of 'CA', 'ROOT' or 'MY'.  The system may provide\nmore cert storages, too.  The function returns a list of (bytes,\nencoding_type) tuples.  The encoding_type flag can be interpreted with\nX509_ASN_ENCODING or PKCS_7_ASN_ENCODING.",
+    "_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" => "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.",
+    "_stat.S_ISCHR" => "S_ISCHR(mode) -> bool\n\nReturn True if mode is from a character special device file.",
+    "_stat.S_ISDIR" => "S_ISDIR(mode) -> bool\n\nReturn True if mode is from a directory.",
+    "_stat.S_ISDOOR" => "S_ISDOOR(mode) -> bool\n\nReturn True if mode is from a door.",
+    "_stat.S_ISFIFO" => "S_ISFIFO(mode) -> bool\n\nReturn True if mode is from a FIFO (named pipe).",
+    "_stat.S_ISLNK" => "S_ISLNK(mode) -> bool\n\nReturn True if mode is from a symbolic link.",
+    "_stat.S_ISPORT" => "S_ISPORT(mode) -> bool\n\nReturn True if mode is from an event port.",
+    "_stat.S_ISREG" => "S_ISREG(mode) -> bool\n\nReturn True if mode is from a regular file.",
+    "_stat.S_ISSOCK" => "S_ISSOCK(mode) -> bool\n\nReturn True if mode is from a socket.",
+    "_stat.S_ISWHT" => "S_ISWHT(mode) -> bool\n\nReturn True if mode is from a whiteout.",
+    "_stat.filemode" => "Convert a file's mode to a string of the form '-rwxrwxrwx'",
+    "_statistics" => "Accelerators for the statistics module.",
+    "_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.Struct" => "Struct(fmt) --> compiled struct object",
+    "_struct.Struct.__delattr__" => "Implement delattr(self, name).",
+    "_struct.Struct.__eq__" => "Return self==value.",
+    "_struct.Struct.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_struct.Struct.__ge__" => "Return self>=value.",
+    "_struct.Struct.__getattribute__" => "Return getattr(self, name).",
+    "_struct.Struct.__getstate__" => "Helper for pickle.",
+    "_struct.Struct.__gt__" => "Return self>value.",
+    "_struct.Struct.__hash__" => "Return hash(self).",
+    "_struct.Struct.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_struct.Struct.__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.Struct.__le__" => "Return self<=value.",
+    "_struct.Struct.__lt__" => "Return self<value.",
+    "_struct.Struct.__ne__" => "Return self!=value.",
+    "_struct.Struct.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_struct.Struct.__reduce__" => "Helper for pickle.",
+    "_struct.Struct.__reduce_ex__" => "Helper for pickle.",
+    "_struct.Struct.__repr__" => "Return repr(self).",
+    "_struct.Struct.__setattr__" => "Implement setattr(self, name, value).",
+    "_struct.Struct.__sizeof__" => "S.__sizeof__() -> size of S in memory, in bytes",
+    "_struct.Struct.__str__" => "Return str(self).",
+    "_struct.Struct.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.Struct.format" => "struct format string",
+    "_struct.Struct.iter_unpack" => "Return an iterator yielding tuples.\n\nTuples are unpacked from the given bytes source, like a repeated\ninvocation of unpack_from().\n\nRequires that the bytes length be a multiple of the struct size.",
+    "_struct.Struct.pack" => "S.pack(v1, v2, ...) -> bytes\n\nReturn a bytes object containing values v1, v2, ... packed according\nto the format string S.format.  See help(struct) for more on format\nstrings.",
+    "_struct.Struct.pack_into" => "S.pack_into(buffer, offset, v1, v2, ...)\n\nPack the values v1, v2, ... according to the format string S.format\nand write the packed bytes into the writable buffer buf starting at\noffset.  Note that the offset is a required argument.  See\nhelp(struct) for more on format strings.",
+    "_struct.Struct.size" => "struct size in bytes",
+    "_struct.Struct.unpack" => "Return a tuple containing unpacked values.\n\nUnpack according to the format string Struct.format. The buffer's size\nin bytes must be Struct.size.\n\nSee help(struct) for more on format strings.",
+    "_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.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.",
+    "_struct.unpack" => "Return a tuple containing values unpacked according to the format string.\n\nThe buffer's size in bytes must be calcsize(format).\n\nSee help(struct) for more on format strings.",
+    "_struct.unpack_from" => "Return a tuple containing values unpacked according to the format string.\n\nThe buffer's size, minus offset, must be at least calcsize(format).\n\nSee help(struct) for more on format strings.",
+    "_suggestions._generate_suggestions" => "Returns the candidate in candidates that's closest to item",
+    "_symtable.symtable" => "Return symbol and scope dictionaries used internally by compiler.",
+    "_sysconfig" => "A helper for the sysconfig module.",
+    "_sysconfig.config_vars" => "Returns a dictionary containing build variables intended to be exposed by sysconfig.",
+    "_thread" => "This module provides primitive operations to write multi-threaded programs.\nThe 'threading' module provides a more convenient interface.",
+    "_thread.LockType" => "A lock object is a synchronization primitive.  To create a lock,\ncall threading.Lock().  Methods are:\n\nacquire() -- lock the lock, possibly blocking until it can be obtained\nrelease() -- unlock of the lock\nlocked() -- test whether the lock is currently locked\n\nA lock is not owned by the thread that locked it; another thread may\nunlock it.  A thread attempting to lock a lock that it has already locked\nwill block until another thread unlocks it.  Deadlocks may ensue.",
+    "_thread.LockType.__delattr__" => "Implement delattr(self, name).",
+    "_thread.LockType.__enter__" => "Lock the lock.",
+    "_thread.LockType.__eq__" => "Return self==value.",
+    "_thread.LockType.__exit__" => "Release the lock.",
+    "_thread.LockType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread.LockType.__ge__" => "Return self>=value.",
+    "_thread.LockType.__getattribute__" => "Return getattr(self, name).",
+    "_thread.LockType.__getstate__" => "Helper for pickle.",
+    "_thread.LockType.__gt__" => "Return self>value.",
+    "_thread.LockType.__hash__" => "Return hash(self).",
+    "_thread.LockType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread.LockType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread.LockType.__le__" => "Return self<=value.",
+    "_thread.LockType.__lt__" => "Return self<value.",
+    "_thread.LockType.__ne__" => "Return self!=value.",
+    "_thread.LockType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread.LockType.__reduce__" => "Helper for pickle.",
+    "_thread.LockType.__reduce_ex__" => "Helper for pickle.",
+    "_thread.LockType.__repr__" => "Return repr(self).",
+    "_thread.LockType.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread.LockType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread.LockType.__str__" => "Return str(self).",
+    "_thread.LockType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_thread.LockType.acquire" => "Lock the lock.  Without argument, this blocks if the lock is already\nlocked (even by the same thread), waiting for another thread to release\nthe lock, and return True once the lock is acquired.\nWith an argument, this will only block if the argument is true,\nand the return value reflects whether the lock is acquired.\nThe blocking operation is interruptible.",
+    "_thread.LockType.acquire_lock" => "An obsolete synonym of acquire().",
+    "_thread.LockType.locked" => "Return whether the lock is in the locked state.",
+    "_thread.LockType.locked_lock" => "An obsolete synonym of locked().",
+    "_thread.LockType.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.LockType.release_lock" => "An obsolete synonym of release().",
+    "_thread.RLock.__delattr__" => "Implement delattr(self, name).",
+    "_thread.RLock.__enter__" => "Lock the lock.",
+    "_thread.RLock.__eq__" => "Return self==value.",
+    "_thread.RLock.__exit__" => "Release the lock.",
+    "_thread.RLock.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread.RLock.__ge__" => "Return self>=value.",
+    "_thread.RLock.__getattribute__" => "Return getattr(self, name).",
+    "_thread.RLock.__getstate__" => "Helper for pickle.",
+    "_thread.RLock.__gt__" => "Return self>value.",
+    "_thread.RLock.__hash__" => "Return hash(self).",
+    "_thread.RLock.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread.RLock.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread.RLock.__le__" => "Return self<=value.",
+    "_thread.RLock.__lt__" => "Return self<value.",
+    "_thread.RLock.__ne__" => "Return self!=value.",
+    "_thread.RLock.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread.RLock.__reduce__" => "Helper for pickle.",
+    "_thread.RLock.__reduce_ex__" => "Helper for pickle.",
+    "_thread.RLock.__repr__" => "Return repr(self).",
+    "_thread.RLock.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread.RLock.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread.RLock.__str__" => "Return str(self).",
+    "_thread.RLock.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_thread.RLock._acquire_restore" => "For internal use by `threading.Condition`.",
+    "_thread.RLock._is_owned" => "For internal use by `threading.Condition`.",
+    "_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.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.",
+    "_thread._ExceptHookArgs.__class_getitem__" => "See PEP 585",
+    "_thread._ExceptHookArgs.__contains__" => "Return bool(key in self).",
+    "_thread._ExceptHookArgs.__delattr__" => "Implement delattr(self, name).",
+    "_thread._ExceptHookArgs.__eq__" => "Return self==value.",
+    "_thread._ExceptHookArgs.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread._ExceptHookArgs.__ge__" => "Return self>=value.",
+    "_thread._ExceptHookArgs.__getattribute__" => "Return getattr(self, name).",
+    "_thread._ExceptHookArgs.__getitem__" => "Return self[key].",
+    "_thread._ExceptHookArgs.__getstate__" => "Helper for pickle.",
+    "_thread._ExceptHookArgs.__gt__" => "Return self>value.",
+    "_thread._ExceptHookArgs.__hash__" => "Return hash(self).",
+    "_thread._ExceptHookArgs.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread._ExceptHookArgs.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread._ExceptHookArgs.__iter__" => "Implement iter(self).",
+    "_thread._ExceptHookArgs.__le__" => "Return self<=value.",
+    "_thread._ExceptHookArgs.__len__" => "Return len(self).",
+    "_thread._ExceptHookArgs.__lt__" => "Return self<value.",
+    "_thread._ExceptHookArgs.__mul__" => "Return self*value.",
+    "_thread._ExceptHookArgs.__ne__" => "Return self!=value.",
+    "_thread._ExceptHookArgs.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread._ExceptHookArgs.__reduce_ex__" => "Helper for pickle.",
+    "_thread._ExceptHookArgs.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "_thread._ExceptHookArgs.__repr__" => "Return repr(self).",
+    "_thread._ExceptHookArgs.__rmul__" => "Return value*self.",
+    "_thread._ExceptHookArgs.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread._ExceptHookArgs.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread._ExceptHookArgs.__str__" => "Return str(self).",
+    "_thread._ExceptHookArgs.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_thread._ExceptHookArgs.count" => "Return number of occurrences of value.",
+    "_thread._ExceptHookArgs.exc_traceback" => "Exception traceback",
+    "_thread._ExceptHookArgs.exc_type" => "Exception type",
+    "_thread._ExceptHookArgs.exc_value" => "Exception value",
+    "_thread._ExceptHookArgs.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "_thread._ExceptHookArgs.thread" => "Thread",
+    "_thread._ThreadHandle.__delattr__" => "Implement delattr(self, name).",
+    "_thread._ThreadHandle.__eq__" => "Return self==value.",
+    "_thread._ThreadHandle.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread._ThreadHandle.__ge__" => "Return self>=value.",
+    "_thread._ThreadHandle.__getattribute__" => "Return getattr(self, name).",
+    "_thread._ThreadHandle.__getstate__" => "Helper for pickle.",
+    "_thread._ThreadHandle.__gt__" => "Return self>value.",
+    "_thread._ThreadHandle.__hash__" => "Return hash(self).",
+    "_thread._ThreadHandle.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread._ThreadHandle.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread._ThreadHandle.__le__" => "Return self<=value.",
+    "_thread._ThreadHandle.__lt__" => "Return self<value.",
+    "_thread._ThreadHandle.__ne__" => "Return self!=value.",
+    "_thread._ThreadHandle.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread._ThreadHandle.__reduce__" => "Helper for pickle.",
+    "_thread._ThreadHandle.__reduce_ex__" => "Helper for pickle.",
+    "_thread._ThreadHandle.__repr__" => "Return repr(self).",
+    "_thread._ThreadHandle.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread._ThreadHandle.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread._ThreadHandle.__str__" => "Return str(self).",
+    "_thread._ThreadHandle.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_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._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).",
+    "_thread._local.__eq__" => "Return self==value.",
+    "_thread._local.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread._local.__ge__" => "Return self>=value.",
+    "_thread._local.__getattribute__" => "Return getattr(self, name).",
+    "_thread._local.__getstate__" => "Helper for pickle.",
+    "_thread._local.__gt__" => "Return self>value.",
+    "_thread._local.__hash__" => "Return hash(self).",
+    "_thread._local.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread._local.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread._local.__le__" => "Return self<=value.",
+    "_thread._local.__lt__" => "Return self<value.",
+    "_thread._local.__ne__" => "Return self!=value.",
+    "_thread._local.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread._local.__reduce__" => "Helper for pickle.",
+    "_thread._local.__reduce_ex__" => "Helper for pickle.",
+    "_thread._local.__repr__" => "Return repr(self).",
+    "_thread._local.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread._local.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread._local.__str__" => "Return str(self).",
+    "_thread._local.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_thread._make_thread_handle" => "Internal only. Make a thread handle for threads not spawned\nby the _thread or threading module.",
+    "_thread._shutdown" => "Wait for all non-daemon threads (other than the calling thread) to stop.",
+    "_thread.allocate" => "An obsolete synonym of allocate_lock().",
+    "_thread.allocate_lock" => "Create a new lock object. See help(type(threading.Lock())) for\ninformation about locks.",
+    "_thread.daemon_threads_allowed" => "Return True if daemon threads are allowed in the current interpreter,\nand False otherwise.",
+    "_thread.exit" => "This is synonymous to ``raise SystemExit''.  It will cause the current\nthread to exit silently unless the exception is caught.",
+    "_thread.exit_thread" => "An obsolete synonym of exit().",
+    "_thread.get_ident" => "Return a non-zero integer that uniquely identifies the current thread\namongst other threads that exist simultaneously.\nThis may be used to identify per-thread resources.\nEven though on some platforms threads identities may appear to be\nallocated consecutive numbers starting at 1, this behavior should not\nbe relied upon, and the number should be seen purely as a magic cookie.\nA thread's identity may be reused for another thread after it exits.",
+    "_thread.get_native_id" => "Return a non-negative integer identifying the thread as reported\nby the OS (kernel). This may be used to uniquely identify a\nparticular thread within a system.",
+    "_thread.interrupt_main" => "Simulate the arrival of the given signal in the main thread,\nwhere the corresponding signal handler will be executed.\nIf *signum* is omitted, SIGINT is assumed.\nA subthread can use this function to interrupt the main thread.\n\nNote: the default signal handler for SIGINT raises ``KeyboardInterrupt``.",
+    "_thread.lock" => "A lock object is a synchronization primitive.  To create a lock,\ncall threading.Lock().  Methods are:\n\nacquire() -- lock the lock, possibly blocking until it can be obtained\nrelease() -- unlock of the lock\nlocked() -- test whether the lock is currently locked\n\nA lock is not owned by the thread that locked it; another thread may\nunlock it.  A thread attempting to lock a lock that it has already locked\nwill block until another thread unlocks it.  Deadlocks may ensue.",
+    "_thread.lock.__delattr__" => "Implement delattr(self, name).",
+    "_thread.lock.__enter__" => "Lock the lock.",
+    "_thread.lock.__eq__" => "Return self==value.",
+    "_thread.lock.__exit__" => "Release the lock.",
+    "_thread.lock.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_thread.lock.__ge__" => "Return self>=value.",
+    "_thread.lock.__getattribute__" => "Return getattr(self, name).",
+    "_thread.lock.__getstate__" => "Helper for pickle.",
+    "_thread.lock.__gt__" => "Return self>value.",
+    "_thread.lock.__hash__" => "Return hash(self).",
+    "_thread.lock.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_thread.lock.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_thread.lock.__le__" => "Return self<=value.",
+    "_thread.lock.__lt__" => "Return self<value.",
+    "_thread.lock.__ne__" => "Return self!=value.",
+    "_thread.lock.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_thread.lock.__reduce__" => "Helper for pickle.",
+    "_thread.lock.__reduce_ex__" => "Helper for pickle.",
+    "_thread.lock.__repr__" => "Return repr(self).",
+    "_thread.lock.__setattr__" => "Implement setattr(self, name, value).",
+    "_thread.lock.__sizeof__" => "Size of object in memory, in bytes.",
+    "_thread.lock.__str__" => "Return str(self).",
+    "_thread.lock.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_thread.lock.acquire" => "Lock the lock.  Without argument, this blocks if the lock is already\nlocked (even by the same thread), waiting for another thread to release\nthe lock, and return True once the lock is acquired.\nWith an argument, this will only block if the argument is true,\nand the return value reflects whether the lock is acquired.\nThe blocking operation is interruptible.",
+    "_thread.lock.acquire_lock" => "An obsolete synonym of acquire().",
+    "_thread.lock.locked" => "Return whether the lock is in the locked state.",
+    "_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.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.",
+    "_tkinter.TclError.__ge__" => "Return self>=value.",
+    "_tkinter.TclError.__getattribute__" => "Return getattr(self, name).",
+    "_tkinter.TclError.__getstate__" => "Helper for pickle.",
+    "_tkinter.TclError.__gt__" => "Return self>value.",
+    "_tkinter.TclError.__hash__" => "Return hash(self).",
+    "_tkinter.TclError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_tkinter.TclError.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_tkinter.TclError.__le__" => "Return self<=value.",
+    "_tkinter.TclError.__lt__" => "Return self<value.",
+    "_tkinter.TclError.__ne__" => "Return self!=value.",
+    "_tkinter.TclError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_tkinter.TclError.__reduce_ex__" => "Helper for pickle.",
+    "_tkinter.TclError.__repr__" => "Return repr(self).",
+    "_tkinter.TclError.__setattr__" => "Implement setattr(self, name, value).",
+    "_tkinter.TclError.__sizeof__" => "Size of object in memory, in bytes.",
+    "_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.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.",
+    "_tkinter.Tcl_Obj.__ge__" => "Return self>=value.",
+    "_tkinter.Tcl_Obj.__getattribute__" => "Return getattr(self, name).",
+    "_tkinter.Tcl_Obj.__getstate__" => "Helper for pickle.",
+    "_tkinter.Tcl_Obj.__gt__" => "Return self>value.",
+    "_tkinter.Tcl_Obj.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_tkinter.Tcl_Obj.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_tkinter.Tcl_Obj.__le__" => "Return self<=value.",
+    "_tkinter.Tcl_Obj.__lt__" => "Return self<value.",
+    "_tkinter.Tcl_Obj.__ne__" => "Return self!=value.",
+    "_tkinter.Tcl_Obj.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_tkinter.Tcl_Obj.__reduce__" => "Helper for pickle.",
+    "_tkinter.Tcl_Obj.__reduce_ex__" => "Helper for pickle.",
+    "_tkinter.Tcl_Obj.__repr__" => "Return repr(self).",
+    "_tkinter.Tcl_Obj.__setattr__" => "Implement setattr(self, name, value).",
+    "_tkinter.Tcl_Obj.__sizeof__" => "Size of object in memory, in bytes.",
+    "_tkinter.Tcl_Obj.__str__" => "Return str(self).",
+    "_tkinter.Tcl_Obj.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.Tcl_Obj.string" => "the string representation of this object, either as str or bytes",
+    "_tkinter.Tcl_Obj.typename" => "name of the Tcl type",
+    "_tkinter.TkappType.__delattr__" => "Implement delattr(self, name).",
+    "_tkinter.TkappType.__eq__" => "Return self==value.",
+    "_tkinter.TkappType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_tkinter.TkappType.__ge__" => "Return self>=value.",
+    "_tkinter.TkappType.__getattribute__" => "Return getattr(self, name).",
+    "_tkinter.TkappType.__getstate__" => "Helper for pickle.",
+    "_tkinter.TkappType.__gt__" => "Return self>value.",
+    "_tkinter.TkappType.__hash__" => "Return hash(self).",
+    "_tkinter.TkappType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_tkinter.TkappType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_tkinter.TkappType.__le__" => "Return self<=value.",
+    "_tkinter.TkappType.__lt__" => "Return self<value.",
+    "_tkinter.TkappType.__ne__" => "Return self!=value.",
+    "_tkinter.TkappType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_tkinter.TkappType.__reduce__" => "Helper for pickle.",
+    "_tkinter.TkappType.__reduce_ex__" => "Helper for pickle.",
+    "_tkinter.TkappType.__repr__" => "Return repr(self).",
+    "_tkinter.TkappType.__setattr__" => "Implement setattr(self, name, value).",
+    "_tkinter.TkappType.__sizeof__" => "Size of object in memory, in bytes.",
+    "_tkinter.TkappType.__str__" => "Return str(self).",
+    "_tkinter.TkappType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.TkappType.gettrace" => "Get the tracing function.",
+    "_tkinter.TkappType.settrace" => "Set the tracing function.",
+    "_tkinter.TkttType.__delattr__" => "Implement delattr(self, name).",
+    "_tkinter.TkttType.__eq__" => "Return self==value.",
+    "_tkinter.TkttType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_tkinter.TkttType.__ge__" => "Return self>=value.",
+    "_tkinter.TkttType.__getattribute__" => "Return getattr(self, name).",
+    "_tkinter.TkttType.__getstate__" => "Helper for pickle.",
+    "_tkinter.TkttType.__gt__" => "Return self>value.",
+    "_tkinter.TkttType.__hash__" => "Return hash(self).",
+    "_tkinter.TkttType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_tkinter.TkttType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_tkinter.TkttType.__le__" => "Return self<=value.",
+    "_tkinter.TkttType.__lt__" => "Return self<value.",
+    "_tkinter.TkttType.__ne__" => "Return self!=value.",
+    "_tkinter.TkttType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_tkinter.TkttType.__reduce__" => "Helper for pickle.",
+    "_tkinter.TkttType.__reduce_ex__" => "Helper for pickle.",
+    "_tkinter.TkttType.__repr__" => "Return repr(self).",
+    "_tkinter.TkttType.__setattr__" => "Implement setattr(self, name, value).",
+    "_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.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).",
+    "_tokenize.TokenizerIter.__eq__" => "Return self==value.",
+    "_tokenize.TokenizerIter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_tokenize.TokenizerIter.__ge__" => "Return self>=value.",
+    "_tokenize.TokenizerIter.__getattribute__" => "Return getattr(self, name).",
+    "_tokenize.TokenizerIter.__getstate__" => "Helper for pickle.",
+    "_tokenize.TokenizerIter.__gt__" => "Return self>value.",
+    "_tokenize.TokenizerIter.__hash__" => "Return hash(self).",
+    "_tokenize.TokenizerIter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_tokenize.TokenizerIter.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_tokenize.TokenizerIter.__iter__" => "Implement iter(self).",
+    "_tokenize.TokenizerIter.__le__" => "Return self<=value.",
+    "_tokenize.TokenizerIter.__lt__" => "Return self<value.",
+    "_tokenize.TokenizerIter.__ne__" => "Return self!=value.",
+    "_tokenize.TokenizerIter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_tokenize.TokenizerIter.__next__" => "Implement next(self).",
+    "_tokenize.TokenizerIter.__reduce__" => "Helper for pickle.",
+    "_tokenize.TokenizerIter.__reduce_ex__" => "Helper for pickle.",
+    "_tokenize.TokenizerIter.__repr__" => "Return repr(self).",
+    "_tokenize.TokenizerIter.__setattr__" => "Implement setattr(self, name, value).",
+    "_tokenize.TokenizerIter.__sizeof__" => "Size of object in memory, in bytes.",
+    "_tokenize.TokenizerIter.__str__" => "Return str(self).",
+    "_tokenize.TokenizerIter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "_tracemalloc" => "Debug module to trace memory blocks allocated by Python.",
+    "_tracemalloc._get_object_traceback" => "Get the traceback where the Python object obj was allocated.\n\nReturn a tuple of (filename: str, lineno: int) tuples.\nReturn None if the tracemalloc module is disabled or did not\ntrace the allocation of the object.",
+    "_tracemalloc._get_traces" => "Get traces of all memory blocks allocated by Python.\n\nReturn a list of (size: int, traceback: tuple) tuples.\ntraceback is a tuple of (filename: str, lineno: int) tuples.\n\nReturn an empty list if the tracemalloc module is disabled.",
+    "_tracemalloc.clear_traces" => "Clear traces of memory blocks allocated by Python.",
+    "_tracemalloc.get_traceback_limit" => "Get the maximum number of frames stored in the traceback of a trace.\n\nBy default, a trace of an allocated memory block only stores\nthe most recent frame: the limit is 1.",
+    "_tracemalloc.get_traced_memory" => "Get the current size and peak size of memory blocks traced by tracemalloc.\n\nReturns a tuple: (current: int, peak: int).",
+    "_tracemalloc.get_tracemalloc_memory" => "Get the memory usage in bytes of the tracemalloc module.\n\nThis memory is used internally to trace memory allocations.",
+    "_tracemalloc.is_tracing" => "Return True if the tracemalloc module is tracing Python memory allocations.",
+    "_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.",
+    "_typing" => "Primitives and accelerators for the typing module.",
+    "_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_explicit" => "Issue a warning, or maybe ignore it or raise an exception.",
+    "_weakref" => "Weak-reference support module.",
+    "_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.",
+    "_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.",
+    "_winapi.CreatePipe" => "Create an anonymous pipe.\n\n  pipe_attrs\n    Ignored internally, can be None.\n\nReturns a 2-tuple of handles, to the read and write ends of the pipe.",
+    "_winapi.CreateProcess" => "Create a new process and its primary thread.\n\n  command_line\n    Can be str or None\n  proc_attrs\n    Ignored internally, can be None.\n  thread_attrs\n    Ignored internally, can be None.\n\nThe return value is a tuple of the process handle, thread handle,\nprocess ID, and thread ID.",
+    "_winapi.DuplicateHandle" => "Return a duplicate handle object.\n\nThe duplicate handle refers to the same object as the original\nhandle. Therefore, any changes to the object are reflected\nthrough both handles.",
+    "_winapi.GetACP" => "Get the current Windows ANSI code page identifier.",
+    "_winapi.GetCurrentProcess" => "Return a handle object for the current process.",
+    "_winapi.GetExitCodeProcess" => "Return the termination status of the specified process.",
+    "_winapi.GetLongPathName" => "Return the long version of the provided path.\n\nIf the path is already in its long form, returns the same value.\n\nThe path must already be a 'str'. If the type is not known, use\nos.fsdecode before calling this function.",
+    "_winapi.GetModuleFileName" => "Return the fully-qualified path for the file that contains module.\n\nThe module must have been loaded by the current process.\n\nThe module parameter should be a handle to the loaded module\nwhose path is being requested. If this parameter is 0,\nGetModuleFileName retrieves the path of the executable file\nof the current process.",
+    "_winapi.GetShortPathName" => "Return the short version of the provided path.\n\nIf the path is already in its short form, returns the same value.\n\nThe path must already be a 'str'. If the type is not known, use\nos.fsdecode before calling this function.",
+    "_winapi.GetStdHandle" => "Return a handle to the specified standard device.\n\n  std_handle\n    One of STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, or STD_ERROR_HANDLE.\n\nThe integer associated with the handle object is returned.",
+    "_winapi.GetVersion" => "Return the version number of the current operating system.",
+    "_winapi.Overlapped" => "OVERLAPPED structure wrapper",
+    "_winapi.Overlapped.__delattr__" => "Implement delattr(self, name).",
+    "_winapi.Overlapped.__eq__" => "Return self==value.",
+    "_winapi.Overlapped.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "_winapi.Overlapped.__ge__" => "Return self>=value.",
+    "_winapi.Overlapped.__getattribute__" => "Return getattr(self, name).",
+    "_winapi.Overlapped.__getstate__" => "Helper for pickle.",
+    "_winapi.Overlapped.__gt__" => "Return self>value.",
+    "_winapi.Overlapped.__hash__" => "Return hash(self).",
+    "_winapi.Overlapped.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "_winapi.Overlapped.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "_winapi.Overlapped.__le__" => "Return self<=value.",
+    "_winapi.Overlapped.__lt__" => "Return self<value.",
+    "_winapi.Overlapped.__ne__" => "Return self!=value.",
+    "_winapi.Overlapped.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "_winapi.Overlapped.__reduce__" => "Helper for pickle.",
+    "_winapi.Overlapped.__reduce_ex__" => "Helper for pickle.",
+    "_winapi.Overlapped.__repr__" => "Return repr(self).",
+    "_winapi.Overlapped.__setattr__" => "Implement setattr(self, name, value).",
+    "_winapi.Overlapped.__sizeof__" => "Size of object in memory, in bytes.",
+    "_winapi.Overlapped.__str__" => "Return str(self).",
+    "_winapi.Overlapped.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.Overlapped.event" => "overlapped event handle",
+    "_winapi.TerminateProcess" => "Terminate the specified process and all of its threads.",
+    "_winapi.WaitForSingleObject" => "Wait for a single object.\n\nWait until the specified object is in the signaled state or\nthe time-out interval elapses. The timeout value is specified\nin milliseconds.",
+    "_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",
+    "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.",
+    "array.ArrayType.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "array.ArrayType.__class_getitem__" => "See PEP 585",
+    "array.ArrayType.__contains__" => "Return bool(key in self).",
+    "array.ArrayType.__copy__" => "Return a copy of the array.",
+    "array.ArrayType.__deepcopy__" => "Return a copy of the array.",
+    "array.ArrayType.__delattr__" => "Implement delattr(self, name).",
+    "array.ArrayType.__delitem__" => "Delete self[key].",
+    "array.ArrayType.__eq__" => "Return self==value.",
+    "array.ArrayType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "array.ArrayType.__ge__" => "Return self>=value.",
+    "array.ArrayType.__getattribute__" => "Return getattr(self, name).",
+    "array.ArrayType.__getitem__" => "Return self[key].",
+    "array.ArrayType.__getstate__" => "Helper for pickle.",
+    "array.ArrayType.__gt__" => "Return self>value.",
+    "array.ArrayType.__iadd__" => "Implement self+=value.",
+    "array.ArrayType.__imul__" => "Implement self*=value.",
+    "array.ArrayType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "array.ArrayType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "array.ArrayType.__iter__" => "Implement iter(self).",
+    "array.ArrayType.__le__" => "Return self<=value.",
+    "array.ArrayType.__len__" => "Return len(self).",
+    "array.ArrayType.__lt__" => "Return self<value.",
+    "array.ArrayType.__mul__" => "Return self*value.",
+    "array.ArrayType.__ne__" => "Return self!=value.",
+    "array.ArrayType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "array.ArrayType.__reduce__" => "Helper for pickle.",
+    "array.ArrayType.__reduce_ex__" => "Return state information for pickling.",
+    "array.ArrayType.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "array.ArrayType.__repr__" => "Return repr(self).",
+    "array.ArrayType.__rmul__" => "Return value*self.",
+    "array.ArrayType.__setattr__" => "Implement setattr(self, name, value).",
+    "array.ArrayType.__setitem__" => "Set self[key] to value.",
+    "array.ArrayType.__sizeof__" => "Size of the array in memory, in bytes.",
+    "array.ArrayType.__str__" => "Return str(self).",
+    "array.ArrayType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "array.ArrayType.append" => "Append new value v to the end of the array.",
+    "array.ArrayType.buffer_info" => "Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.\n\nThe length should be multiplied by the itemsize attribute to calculate\nthe buffer length in bytes.",
+    "array.ArrayType.byteswap" => "Byteswap all items of the array.\n\nIf the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is\nraised.",
+    "array.ArrayType.clear" => "Remove all items from the array.",
+    "array.ArrayType.count" => "Return number of occurrences of v in the array.",
+    "array.ArrayType.extend" => "Append items to the end of the array.",
+    "array.ArrayType.frombytes" => "Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.",
+    "array.ArrayType.fromfile" => "Read n objects from the file object f and append them to the end of the array.",
+    "array.ArrayType.fromlist" => "Append items to array from list.",
+    "array.ArrayType.fromunicode" => "Extends this array with data from the unicode string ustr.\n\nThe array must be a unicode type array; otherwise a ValueError is raised.\nUse array.frombytes(ustr.encode(...)) to append Unicode data to an array of\nsome other type.",
+    "array.ArrayType.index" => "Return index of first occurrence of v in the array.\n\nRaise ValueError if the value is not present.",
+    "array.ArrayType.insert" => "Insert a new item v into the array before position i.",
+    "array.ArrayType.itemsize" => "the size, in bytes, of one array item",
+    "array.ArrayType.pop" => "Return the i-th element and delete it from the array.\n\ni defaults to -1.",
+    "array.ArrayType.remove" => "Remove the first occurrence of v in the array.",
+    "array.ArrayType.reverse" => "Reverse the order of the items in the array.",
+    "array.ArrayType.tobytes" => "Convert the array to an array of machine values and return the bytes representation.",
+    "array.ArrayType.tofile" => "Write all items (as machine values) to the file object f.",
+    "array.ArrayType.tolist" => "Convert array to an ordinary list with the same items.",
+    "array.ArrayType.tounicode" => "Extends this array with data from the unicode string ustr.\n\nConvert the array to a unicode string.  The array must be a unicode type array;\notherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a\nunicode string from an array of some other type.",
+    "array.ArrayType.typecode" => "the typecode character used to create the array",
+    "array._array_reconstructor" => "Internal. Used for pickling support.",
+    "array.array" => "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.array.__add__" => "Return self+value.",
+    "array.array.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "array.array.__class_getitem__" => "See PEP 585",
+    "array.array.__contains__" => "Return bool(key in self).",
+    "array.array.__copy__" => "Return a copy of the array.",
+    "array.array.__deepcopy__" => "Return a copy of the array.",
+    "array.array.__delattr__" => "Implement delattr(self, name).",
+    "array.array.__delitem__" => "Delete self[key].",
+    "array.array.__eq__" => "Return self==value.",
+    "array.array.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "array.array.__ge__" => "Return self>=value.",
+    "array.array.__getattribute__" => "Return getattr(self, name).",
+    "array.array.__getitem__" => "Return self[key].",
+    "array.array.__getstate__" => "Helper for pickle.",
+    "array.array.__gt__" => "Return self>value.",
+    "array.array.__iadd__" => "Implement self+=value.",
+    "array.array.__imul__" => "Implement self*=value.",
+    "array.array.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "array.array.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "array.array.__iter__" => "Implement iter(self).",
+    "array.array.__le__" => "Return self<=value.",
+    "array.array.__len__" => "Return len(self).",
+    "array.array.__lt__" => "Return self<value.",
+    "array.array.__mul__" => "Return self*value.",
+    "array.array.__ne__" => "Return self!=value.",
+    "array.array.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "array.array.__reduce__" => "Helper for pickle.",
+    "array.array.__reduce_ex__" => "Return state information for pickling.",
+    "array.array.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "array.array.__repr__" => "Return repr(self).",
+    "array.array.__rmul__" => "Return value*self.",
+    "array.array.__setattr__" => "Implement setattr(self, name, value).",
+    "array.array.__setitem__" => "Set self[key] to value.",
+    "array.array.__sizeof__" => "Size of the array in memory, in bytes.",
+    "array.array.__str__" => "Return str(self).",
+    "array.array.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "array.array.append" => "Append new value v to the end of the array.",
+    "array.array.buffer_info" => "Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.\n\nThe length should be multiplied by the itemsize attribute to calculate\nthe buffer length in bytes.",
+    "array.array.byteswap" => "Byteswap all items of the array.\n\nIf the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is\nraised.",
+    "array.array.clear" => "Remove all items from the array.",
+    "array.array.count" => "Return number of occurrences of v in the array.",
+    "array.array.extend" => "Append items to the end of the array.",
+    "array.array.frombytes" => "Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method.",
+    "array.array.fromfile" => "Read n objects from the file object f and append them to the end of the array.",
+    "array.array.fromlist" => "Append items to array from list.",
+    "array.array.fromunicode" => "Extends this array with data from the unicode string ustr.\n\nThe array must be a unicode type array; otherwise a ValueError is raised.\nUse array.frombytes(ustr.encode(...)) to append Unicode data to an array of\nsome other type.",
+    "array.array.index" => "Return index of first occurrence of v in the array.\n\nRaise ValueError if the value is not present.",
+    "array.array.insert" => "Insert a new item v into the array before position i.",
+    "array.array.itemsize" => "the size, in bytes, of one array item",
+    "array.array.pop" => "Return the i-th element and delete it from the array.\n\ni defaults to -1.",
+    "array.array.remove" => "Remove the first occurrence of v in the array.",
+    "array.array.reverse" => "Reverse the order of the items in the array.",
+    "array.array.tobytes" => "Convert the array to an array of machine values and return the bytes representation.",
+    "array.array.tofile" => "Write all items (as machine values) to the file object f.",
+    "array.array.tolist" => "Convert array to an ordinary list with the same items.",
+    "array.array.tounicode" => "Extends this array with data from the unicode string ustr.\n\nConvert the array to a unicode string.  The array must be a unicode type array;\notherwise a ValueError is raised.  Use array.tobytes().decode() to obtain a\nunicode string from an array of some other type.",
+    "array.array.typecode" => "the typecode character used to create the array",
+    "atexit" => "allow programmer to define multiple exit functions to be executed\nupon normal program termination.\n\nTwo public functions, register and unregister, are defined.",
+    "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.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.",
+    "binascii.Error.__ge__" => "Return self>=value.",
+    "binascii.Error.__getattribute__" => "Return getattr(self, name).",
+    "binascii.Error.__getstate__" => "Helper for pickle.",
+    "binascii.Error.__gt__" => "Return self>value.",
+    "binascii.Error.__hash__" => "Return hash(self).",
+    "binascii.Error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "binascii.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.",
+    "binascii.Error.__le__" => "Return self<=value.",
+    "binascii.Error.__lt__" => "Return self<value.",
+    "binascii.Error.__ne__" => "Return self!=value.",
+    "binascii.Error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "binascii.Error.__reduce_ex__" => "Helper for pickle.",
+    "binascii.Error.__repr__" => "Return repr(self).",
+    "binascii.Error.__setattr__" => "Implement setattr(self, name, value).",
+    "binascii.Error.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.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.",
+    "binascii.Incomplete.__ge__" => "Return self>=value.",
+    "binascii.Incomplete.__getattribute__" => "Return getattr(self, name).",
+    "binascii.Incomplete.__getstate__" => "Helper for pickle.",
+    "binascii.Incomplete.__gt__" => "Return self>value.",
+    "binascii.Incomplete.__hash__" => "Return hash(self).",
+    "binascii.Incomplete.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "binascii.Incomplete.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "binascii.Incomplete.__le__" => "Return self<=value.",
+    "binascii.Incomplete.__lt__" => "Return self<value.",
+    "binascii.Incomplete.__ne__" => "Return self!=value.",
+    "binascii.Incomplete.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "binascii.Incomplete.__reduce_ex__" => "Helper for pickle.",
+    "binascii.Incomplete.__repr__" => "Return repr(self).",
+    "binascii.Incomplete.__setattr__" => "Implement setattr(self, name, value).",
+    "binascii.Incomplete.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.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.",
+    "binascii.b2a_base64" => "Base64-code line of data.",
+    "binascii.b2a_hex" => "Hexadecimal representation of binary data.\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\nThe return value is a bytes object.  This function is also\navailable as \"hexlify()\".\n\nExample:\n>>> binascii.b2a_hex(b'\\xb9\\x01\\xef')\nb'b901ef'\n>>> binascii.hexlify(b'\\xb9\\x01\\xef', ':')\nb'b9:01:ef'\n>>> binascii.b2a_hex(b'\\xb9\\x01\\xef', b'_', 2)\nb'b9_01ef'",
+    "binascii.b2a_qp" => "Encode a string using quoted-printable encoding.\n\nOn encoding, when istext is set, newlines are not encoded, and white\nspace at end of lines is.  When istext is not set, \\r and \\n (CR/LF)\nare both encoded.  When quotetabs is set, space and tabs are encoded.",
+    "binascii.b2a_uu" => "Uuencode line of data.",
+    "binascii.crc32" => "Compute CRC-32 incrementally.",
+    "binascii.crc_hqx" => "Compute CRC-CCITT incrementally.",
+    "binascii.hexlify" => "Hexadecimal representation of binary data.\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\nThe return value is a bytes object.  This function is also\navailable as \"b2a_hex()\".",
+    "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.",
+    "builtins.ArithmeticError.__ge__" => "Return self>=value.",
+    "builtins.ArithmeticError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ArithmeticError.__getstate__" => "Helper for pickle.",
+    "builtins.ArithmeticError.__gt__" => "Return self>value.",
+    "builtins.ArithmeticError.__hash__" => "Return hash(self).",
+    "builtins.ArithmeticError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ArithmeticError.__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.ArithmeticError.__le__" => "Return self<=value.",
+    "builtins.ArithmeticError.__lt__" => "Return self<value.",
+    "builtins.ArithmeticError.__ne__" => "Return self!=value.",
+    "builtins.ArithmeticError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ArithmeticError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ArithmeticError.__repr__" => "Return repr(self).",
+    "builtins.ArithmeticError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.AssertionError.__ge__" => "Return self>=value.",
+    "builtins.AssertionError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.AssertionError.__getstate__" => "Helper for pickle.",
+    "builtins.AssertionError.__gt__" => "Return self>value.",
+    "builtins.AssertionError.__hash__" => "Return hash(self).",
+    "builtins.AssertionError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.AssertionError.__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.AssertionError.__le__" => "Return self<=value.",
+    "builtins.AssertionError.__lt__" => "Return self<value.",
+    "builtins.AssertionError.__ne__" => "Return self!=value.",
+    "builtins.AssertionError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.AssertionError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.AssertionError.__repr__" => "Return repr(self).",
+    "builtins.AssertionError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.AttributeError.__ge__" => "Return self>=value.",
+    "builtins.AttributeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.AttributeError.__gt__" => "Return self>value.",
+    "builtins.AttributeError.__hash__" => "Return hash(self).",
+    "builtins.AttributeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.AttributeError.__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.AttributeError.__le__" => "Return self<=value.",
+    "builtins.AttributeError.__lt__" => "Return self<value.",
+    "builtins.AttributeError.__ne__" => "Return self!=value.",
+    "builtins.AttributeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.AttributeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.AttributeError.__repr__" => "Return repr(self).",
+    "builtins.AttributeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.name" => "attribute name",
+    "builtins.AttributeError.obj" => "object",
+    "builtins.AttributeError.with_traceback" => "Exception.with_traceback(tb) --\nset 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.",
+    "builtins.BaseException.__ge__" => "Return self>=value.",
+    "builtins.BaseException.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BaseException.__getstate__" => "Helper for pickle.",
+    "builtins.BaseException.__gt__" => "Return self>value.",
+    "builtins.BaseException.__hash__" => "Return hash(self).",
+    "builtins.BaseException.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.BaseException.__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.BaseException.__le__" => "Return self<=value.",
+    "builtins.BaseException.__lt__" => "Return self<value.",
+    "builtins.BaseException.__ne__" => "Return self!=value.",
+    "builtins.BaseException.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BaseException.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BaseException.__repr__" => "Return repr(self).",
+    "builtins.BaseException.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.BaseExceptionGroup.__ge__" => "Return self>=value.",
+    "builtins.BaseExceptionGroup.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BaseExceptionGroup.__getstate__" => "Helper for pickle.",
+    "builtins.BaseExceptionGroup.__gt__" => "Return self>value.",
+    "builtins.BaseExceptionGroup.__hash__" => "Return hash(self).",
+    "builtins.BaseExceptionGroup.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.BaseExceptionGroup.__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.BaseExceptionGroup.__le__" => "Return self<=value.",
+    "builtins.BaseExceptionGroup.__lt__" => "Return self<value.",
+    "builtins.BaseExceptionGroup.__ne__" => "Return self!=value.",
+    "builtins.BaseExceptionGroup.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BaseExceptionGroup.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BaseExceptionGroup.__repr__" => "Return repr(self).",
+    "builtins.BaseExceptionGroup.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.BlockingIOError.__ge__" => "Return self>=value.",
+    "builtins.BlockingIOError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BlockingIOError.__getstate__" => "Helper for pickle.",
+    "builtins.BlockingIOError.__gt__" => "Return self>value.",
+    "builtins.BlockingIOError.__hash__" => "Return hash(self).",
+    "builtins.BlockingIOError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.BlockingIOError.__le__" => "Return self<=value.",
+    "builtins.BlockingIOError.__lt__" => "Return self<value.",
+    "builtins.BlockingIOError.__ne__" => "Return self!=value.",
+    "builtins.BlockingIOError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BlockingIOError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BlockingIOError.__repr__" => "Return repr(self).",
+    "builtins.BlockingIOError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.BrokenPipeError.__ge__" => "Return self>=value.",
+    "builtins.BrokenPipeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BrokenPipeError.__getstate__" => "Helper for pickle.",
+    "builtins.BrokenPipeError.__gt__" => "Return self>value.",
+    "builtins.BrokenPipeError.__hash__" => "Return hash(self).",
+    "builtins.BrokenPipeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.BrokenPipeError.__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.BrokenPipeError.__le__" => "Return self<=value.",
+    "builtins.BrokenPipeError.__lt__" => "Return self<value.",
+    "builtins.BrokenPipeError.__ne__" => "Return self!=value.",
+    "builtins.BrokenPipeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BrokenPipeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BrokenPipeError.__repr__" => "Return repr(self).",
+    "builtins.BrokenPipeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.BufferError.__ge__" => "Return self>=value.",
+    "builtins.BufferError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BufferError.__getstate__" => "Helper for pickle.",
+    "builtins.BufferError.__gt__" => "Return self>value.",
+    "builtins.BufferError.__hash__" => "Return hash(self).",
+    "builtins.BufferError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.BufferError.__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.BufferError.__le__" => "Return self<=value.",
+    "builtins.BufferError.__lt__" => "Return self<value.",
+    "builtins.BufferError.__ne__" => "Return self!=value.",
+    "builtins.BufferError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BufferError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BufferError.__repr__" => "Return repr(self).",
+    "builtins.BufferError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.BytesWarning.__ge__" => "Return self>=value.",
+    "builtins.BytesWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.BytesWarning.__getstate__" => "Helper for pickle.",
+    "builtins.BytesWarning.__gt__" => "Return self>value.",
+    "builtins.BytesWarning.__hash__" => "Return hash(self).",
+    "builtins.BytesWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.BytesWarning.__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.BytesWarning.__le__" => "Return self<=value.",
+    "builtins.BytesWarning.__lt__" => "Return self<value.",
+    "builtins.BytesWarning.__ne__" => "Return self!=value.",
+    "builtins.BytesWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.BytesWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.BytesWarning.__repr__" => "Return repr(self).",
+    "builtins.BytesWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ChildProcessError.__ge__" => "Return self>=value.",
+    "builtins.ChildProcessError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ChildProcessError.__getstate__" => "Helper for pickle.",
+    "builtins.ChildProcessError.__gt__" => "Return self>value.",
+    "builtins.ChildProcessError.__hash__" => "Return hash(self).",
+    "builtins.ChildProcessError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ChildProcessError.__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.ChildProcessError.__le__" => "Return self<=value.",
+    "builtins.ChildProcessError.__lt__" => "Return self<value.",
+    "builtins.ChildProcessError.__ne__" => "Return self!=value.",
+    "builtins.ChildProcessError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ChildProcessError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ChildProcessError.__repr__" => "Return repr(self).",
+    "builtins.ChildProcessError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ConnectionAbortedError.__ge__" => "Return self>=value.",
+    "builtins.ConnectionAbortedError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ConnectionAbortedError.__getstate__" => "Helper for pickle.",
+    "builtins.ConnectionAbortedError.__gt__" => "Return self>value.",
+    "builtins.ConnectionAbortedError.__hash__" => "Return hash(self).",
+    "builtins.ConnectionAbortedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ConnectionAbortedError.__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.ConnectionAbortedError.__le__" => "Return self<=value.",
+    "builtins.ConnectionAbortedError.__lt__" => "Return self<value.",
+    "builtins.ConnectionAbortedError.__ne__" => "Return self!=value.",
+    "builtins.ConnectionAbortedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ConnectionAbortedError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ConnectionAbortedError.__repr__" => "Return repr(self).",
+    "builtins.ConnectionAbortedError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ConnectionError.__ge__" => "Return self>=value.",
+    "builtins.ConnectionError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ConnectionError.__getstate__" => "Helper for pickle.",
+    "builtins.ConnectionError.__gt__" => "Return self>value.",
+    "builtins.ConnectionError.__hash__" => "Return hash(self).",
+    "builtins.ConnectionError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ConnectionError.__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.ConnectionError.__le__" => "Return self<=value.",
+    "builtins.ConnectionError.__lt__" => "Return self<value.",
+    "builtins.ConnectionError.__ne__" => "Return self!=value.",
+    "builtins.ConnectionError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ConnectionError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ConnectionError.__repr__" => "Return repr(self).",
+    "builtins.ConnectionError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ConnectionRefusedError.__ge__" => "Return self>=value.",
+    "builtins.ConnectionRefusedError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ConnectionRefusedError.__getstate__" => "Helper for pickle.",
+    "builtins.ConnectionRefusedError.__gt__" => "Return self>value.",
+    "builtins.ConnectionRefusedError.__hash__" => "Return hash(self).",
+    "builtins.ConnectionRefusedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ConnectionRefusedError.__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.ConnectionRefusedError.__le__" => "Return self<=value.",
+    "builtins.ConnectionRefusedError.__lt__" => "Return self<value.",
+    "builtins.ConnectionRefusedError.__ne__" => "Return self!=value.",
+    "builtins.ConnectionRefusedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ConnectionRefusedError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ConnectionRefusedError.__repr__" => "Return repr(self).",
+    "builtins.ConnectionRefusedError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ConnectionResetError.__ge__" => "Return self>=value.",
+    "builtins.ConnectionResetError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ConnectionResetError.__getstate__" => "Helper for pickle.",
+    "builtins.ConnectionResetError.__gt__" => "Return self>value.",
+    "builtins.ConnectionResetError.__hash__" => "Return hash(self).",
+    "builtins.ConnectionResetError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ConnectionResetError.__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.ConnectionResetError.__le__" => "Return self<=value.",
+    "builtins.ConnectionResetError.__lt__" => "Return self<value.",
+    "builtins.ConnectionResetError.__ne__" => "Return self!=value.",
+    "builtins.ConnectionResetError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ConnectionResetError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ConnectionResetError.__repr__" => "Return repr(self).",
+    "builtins.ConnectionResetError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.DeprecationWarning.__ge__" => "Return self>=value.",
+    "builtins.DeprecationWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.DeprecationWarning.__getstate__" => "Helper for pickle.",
+    "builtins.DeprecationWarning.__gt__" => "Return self>value.",
+    "builtins.DeprecationWarning.__hash__" => "Return hash(self).",
+    "builtins.DeprecationWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.DeprecationWarning.__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.DeprecationWarning.__le__" => "Return self<=value.",
+    "builtins.DeprecationWarning.__lt__" => "Return self<value.",
+    "builtins.DeprecationWarning.__ne__" => "Return self!=value.",
+    "builtins.DeprecationWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.DeprecationWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.DeprecationWarning.__repr__" => "Return repr(self).",
+    "builtins.DeprecationWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.DynamicClassAttribute.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.DynamicClassAttribute.__ge__" => "Return self>=value.",
+    "builtins.DynamicClassAttribute.__getattribute__" => "Return getattr(self, name).",
+    "builtins.DynamicClassAttribute.__getstate__" => "Helper for pickle.",
+    "builtins.DynamicClassAttribute.__gt__" => "Return self>value.",
+    "builtins.DynamicClassAttribute.__hash__" => "Return hash(self).",
+    "builtins.DynamicClassAttribute.__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.DynamicClassAttribute.__le__" => "Return self<=value.",
+    "builtins.DynamicClassAttribute.__lt__" => "Return self<value.",
+    "builtins.DynamicClassAttribute.__ne__" => "Return self!=value.",
+    "builtins.DynamicClassAttribute.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.DynamicClassAttribute.__reduce__" => "Helper for pickle.",
+    "builtins.DynamicClassAttribute.__reduce_ex__" => "Helper for pickle.",
+    "builtins.DynamicClassAttribute.__repr__" => "Return repr(self).",
+    "builtins.DynamicClassAttribute.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.DynamicClassAttribute.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.DynamicClassAttribute.__str__" => "Return str(self).",
+    "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.",
+    "builtins.EOFError.__ge__" => "Return self>=value.",
+    "builtins.EOFError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.EOFError.__getstate__" => "Helper for pickle.",
+    "builtins.EOFError.__gt__" => "Return self>value.",
+    "builtins.EOFError.__hash__" => "Return hash(self).",
+    "builtins.EOFError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.EOFError.__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.EOFError.__le__" => "Return self<=value.",
+    "builtins.EOFError.__lt__" => "Return self<value.",
+    "builtins.EOFError.__ne__" => "Return self!=value.",
+    "builtins.EOFError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.EOFError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.EOFError.__repr__" => "Return repr(self).",
+    "builtins.EOFError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.EncodingWarning.__ge__" => "Return self>=value.",
+    "builtins.EncodingWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.EncodingWarning.__getstate__" => "Helper for pickle.",
+    "builtins.EncodingWarning.__gt__" => "Return self>value.",
+    "builtins.EncodingWarning.__hash__" => "Return hash(self).",
+    "builtins.EncodingWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.EncodingWarning.__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.EncodingWarning.__le__" => "Return self<=value.",
+    "builtins.EncodingWarning.__lt__" => "Return self<value.",
+    "builtins.EncodingWarning.__ne__" => "Return self!=value.",
+    "builtins.EncodingWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.EncodingWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.EncodingWarning.__repr__" => "Return repr(self).",
+    "builtins.EncodingWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.EnvironmentError.__ge__" => "Return self>=value.",
+    "builtins.EnvironmentError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.EnvironmentError.__getstate__" => "Helper for pickle.",
+    "builtins.EnvironmentError.__gt__" => "Return self>value.",
+    "builtins.EnvironmentError.__hash__" => "Return hash(self).",
+    "builtins.EnvironmentError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.EnvironmentError.__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.EnvironmentError.__le__" => "Return self<=value.",
+    "builtins.EnvironmentError.__lt__" => "Return self<value.",
+    "builtins.EnvironmentError.__ne__" => "Return self!=value.",
+    "builtins.EnvironmentError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.EnvironmentError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.EnvironmentError.__repr__" => "Return repr(self).",
+    "builtins.EnvironmentError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.Exception.__ge__" => "Return self>=value.",
+    "builtins.Exception.__getattribute__" => "Return getattr(self, name).",
+    "builtins.Exception.__getstate__" => "Helper for pickle.",
+    "builtins.Exception.__gt__" => "Return self>value.",
+    "builtins.Exception.__hash__" => "Return hash(self).",
+    "builtins.Exception.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.Exception.__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.Exception.__le__" => "Return self<=value.",
+    "builtins.Exception.__lt__" => "Return self<value.",
+    "builtins.Exception.__ne__" => "Return self!=value.",
+    "builtins.Exception.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.Exception.__reduce_ex__" => "Helper for pickle.",
+    "builtins.Exception.__repr__" => "Return repr(self).",
+    "builtins.Exception.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ExceptionGroup.__ge__" => "Return self>=value.",
+    "builtins.ExceptionGroup.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ExceptionGroup.__getstate__" => "Helper for pickle.",
+    "builtins.ExceptionGroup.__gt__" => "Return self>value.",
+    "builtins.ExceptionGroup.__hash__" => "Return hash(self).",
+    "builtins.ExceptionGroup.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ExceptionGroup.__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.ExceptionGroup.__le__" => "Return self<=value.",
+    "builtins.ExceptionGroup.__lt__" => "Return self<value.",
+    "builtins.ExceptionGroup.__ne__" => "Return self!=value.",
+    "builtins.ExceptionGroup.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ExceptionGroup.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ExceptionGroup.__repr__" => "Return repr(self).",
+    "builtins.ExceptionGroup.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.ExceptionGroup.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.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.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.",
+    "builtins.FileExistsError.__ge__" => "Return self>=value.",
+    "builtins.FileExistsError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.FileExistsError.__getstate__" => "Helper for pickle.",
+    "builtins.FileExistsError.__gt__" => "Return self>value.",
+    "builtins.FileExistsError.__hash__" => "Return hash(self).",
+    "builtins.FileExistsError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.FileExistsError.__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.FileExistsError.__le__" => "Return self<=value.",
+    "builtins.FileExistsError.__lt__" => "Return self<value.",
+    "builtins.FileExistsError.__ne__" => "Return self!=value.",
+    "builtins.FileExistsError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.FileExistsError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.FileExistsError.__repr__" => "Return repr(self).",
+    "builtins.FileExistsError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.FileNotFoundError.__ge__" => "Return self>=value.",
+    "builtins.FileNotFoundError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.FileNotFoundError.__getstate__" => "Helper for pickle.",
+    "builtins.FileNotFoundError.__gt__" => "Return self>value.",
+    "builtins.FileNotFoundError.__hash__" => "Return hash(self).",
+    "builtins.FileNotFoundError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.FileNotFoundError.__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.FileNotFoundError.__le__" => "Return self<=value.",
+    "builtins.FileNotFoundError.__lt__" => "Return self<value.",
+    "builtins.FileNotFoundError.__ne__" => "Return self!=value.",
+    "builtins.FileNotFoundError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.FileNotFoundError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.FileNotFoundError.__repr__" => "Return repr(self).",
+    "builtins.FileNotFoundError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.FloatingPointError.__ge__" => "Return self>=value.",
+    "builtins.FloatingPointError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.FloatingPointError.__getstate__" => "Helper for pickle.",
+    "builtins.FloatingPointError.__gt__" => "Return self>value.",
+    "builtins.FloatingPointError.__hash__" => "Return hash(self).",
+    "builtins.FloatingPointError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.FloatingPointError.__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.FloatingPointError.__le__" => "Return self<=value.",
+    "builtins.FloatingPointError.__lt__" => "Return self<value.",
+    "builtins.FloatingPointError.__ne__" => "Return self!=value.",
+    "builtins.FloatingPointError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.FloatingPointError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.FloatingPointError.__repr__" => "Return repr(self).",
+    "builtins.FloatingPointError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.FutureWarning.__ge__" => "Return self>=value.",
+    "builtins.FutureWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.FutureWarning.__getstate__" => "Helper for pickle.",
+    "builtins.FutureWarning.__gt__" => "Return self>value.",
+    "builtins.FutureWarning.__hash__" => "Return hash(self).",
+    "builtins.FutureWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.FutureWarning.__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.FutureWarning.__le__" => "Return self<=value.",
+    "builtins.FutureWarning.__lt__" => "Return self<value.",
+    "builtins.FutureWarning.__ne__" => "Return self!=value.",
+    "builtins.FutureWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.FutureWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.FutureWarning.__repr__" => "Return repr(self).",
+    "builtins.FutureWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.GeneratorExit.__ge__" => "Return self>=value.",
+    "builtins.GeneratorExit.__getattribute__" => "Return getattr(self, name).",
+    "builtins.GeneratorExit.__getstate__" => "Helper for pickle.",
+    "builtins.GeneratorExit.__gt__" => "Return self>value.",
+    "builtins.GeneratorExit.__hash__" => "Return hash(self).",
+    "builtins.GeneratorExit.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.GeneratorExit.__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.GeneratorExit.__le__" => "Return self<=value.",
+    "builtins.GeneratorExit.__lt__" => "Return self<value.",
+    "builtins.GeneratorExit.__ne__" => "Return self!=value.",
+    "builtins.GeneratorExit.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.GeneratorExit.__reduce_ex__" => "Helper for pickle.",
+    "builtins.GeneratorExit.__repr__" => "Return repr(self).",
+    "builtins.GeneratorExit.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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).",
+    "builtins.GenericAlias.__eq__" => "Return self==value.",
+    "builtins.GenericAlias.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.GenericAlias.__ge__" => "Return self>=value.",
+    "builtins.GenericAlias.__getattribute__" => "Return getattr(self, name).",
+    "builtins.GenericAlias.__getitem__" => "Return self[key].",
+    "builtins.GenericAlias.__getstate__" => "Helper for pickle.",
+    "builtins.GenericAlias.__gt__" => "Return self>value.",
+    "builtins.GenericAlias.__hash__" => "Return hash(self).",
+    "builtins.GenericAlias.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.GenericAlias.__iter__" => "Implement iter(self).",
+    "builtins.GenericAlias.__le__" => "Return self<=value.",
+    "builtins.GenericAlias.__lt__" => "Return self<value.",
+    "builtins.GenericAlias.__ne__" => "Return self!=value.",
+    "builtins.GenericAlias.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.GenericAlias.__or__" => "Return self|value.",
+    "builtins.GenericAlias.__parameters__" => "Type variables in the GenericAlias.",
+    "builtins.GenericAlias.__reduce_ex__" => "Helper for pickle.",
+    "builtins.GenericAlias.__repr__" => "Return repr(self).",
+    "builtins.GenericAlias.__ror__" => "Return value|self.",
+    "builtins.GenericAlias.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.GenericAlias.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.",
+    "builtins.IOError.__ge__" => "Return self>=value.",
+    "builtins.IOError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.IOError.__getstate__" => "Helper for pickle.",
+    "builtins.IOError.__gt__" => "Return self>value.",
+    "builtins.IOError.__hash__" => "Return hash(self).",
+    "builtins.IOError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.IOError.__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.IOError.__le__" => "Return self<=value.",
+    "builtins.IOError.__lt__" => "Return self<value.",
+    "builtins.IOError.__ne__" => "Return self!=value.",
+    "builtins.IOError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.IOError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.IOError.__repr__" => "Return repr(self).",
+    "builtins.IOError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ImportError.__ge__" => "Return self>=value.",
+    "builtins.ImportError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ImportError.__getstate__" => "Helper for pickle.",
+    "builtins.ImportError.__gt__" => "Return self>value.",
+    "builtins.ImportError.__hash__" => "Return hash(self).",
+    "builtins.ImportError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ImportError.__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.ImportError.__le__" => "Return self<=value.",
+    "builtins.ImportError.__lt__" => "Return self<value.",
+    "builtins.ImportError.__ne__" => "Return self!=value.",
+    "builtins.ImportError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ImportError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ImportError.__repr__" => "Return repr(self).",
+    "builtins.ImportError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ImportWarning.__ge__" => "Return self>=value.",
+    "builtins.ImportWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ImportWarning.__getstate__" => "Helper for pickle.",
+    "builtins.ImportWarning.__gt__" => "Return self>value.",
+    "builtins.ImportWarning.__hash__" => "Return hash(self).",
+    "builtins.ImportWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ImportWarning.__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.ImportWarning.__le__" => "Return self<=value.",
+    "builtins.ImportWarning.__lt__" => "Return self<value.",
+    "builtins.ImportWarning.__ne__" => "Return self!=value.",
+    "builtins.ImportWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ImportWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ImportWarning.__repr__" => "Return repr(self).",
+    "builtins.ImportWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.IndentationError.__ge__" => "Return self>=value.",
+    "builtins.IndentationError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.IndentationError.__getstate__" => "Helper for pickle.",
+    "builtins.IndentationError.__gt__" => "Return self>value.",
+    "builtins.IndentationError.__hash__" => "Return hash(self).",
+    "builtins.IndentationError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.IndentationError.__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.IndentationError.__le__" => "Return self<=value.",
+    "builtins.IndentationError.__lt__" => "Return self<value.",
+    "builtins.IndentationError.__ne__" => "Return self!=value.",
+    "builtins.IndentationError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.IndentationError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.IndentationError.__repr__" => "Return repr(self).",
+    "builtins.IndentationError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.end_lineno" => "exception end lineno",
+    "builtins.IndentationError.end_offset" => "exception end offset",
+    "builtins.IndentationError.filename" => "exception filename",
+    "builtins.IndentationError.lineno" => "exception lineno",
+    "builtins.IndentationError.msg" => "exception msg",
+    "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.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.",
+    "builtins.IndexError.__ge__" => "Return self>=value.",
+    "builtins.IndexError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.IndexError.__getstate__" => "Helper for pickle.",
+    "builtins.IndexError.__gt__" => "Return self>value.",
+    "builtins.IndexError.__hash__" => "Return hash(self).",
+    "builtins.IndexError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.IndexError.__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.IndexError.__le__" => "Return self<=value.",
+    "builtins.IndexError.__lt__" => "Return self<value.",
+    "builtins.IndexError.__ne__" => "Return self!=value.",
+    "builtins.IndexError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.IndexError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.IndexError.__repr__" => "Return repr(self).",
+    "builtins.IndexError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.InterruptedError.__ge__" => "Return self>=value.",
+    "builtins.InterruptedError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.InterruptedError.__getstate__" => "Helper for pickle.",
+    "builtins.InterruptedError.__gt__" => "Return self>value.",
+    "builtins.InterruptedError.__hash__" => "Return hash(self).",
+    "builtins.InterruptedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.InterruptedError.__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.InterruptedError.__le__" => "Return self<=value.",
+    "builtins.InterruptedError.__lt__" => "Return self<value.",
+    "builtins.InterruptedError.__ne__" => "Return self!=value.",
+    "builtins.InterruptedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.InterruptedError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.InterruptedError.__repr__" => "Return repr(self).",
+    "builtins.InterruptedError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.IsADirectoryError.__ge__" => "Return self>=value.",
+    "builtins.IsADirectoryError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.IsADirectoryError.__getstate__" => "Helper for pickle.",
+    "builtins.IsADirectoryError.__gt__" => "Return self>value.",
+    "builtins.IsADirectoryError.__hash__" => "Return hash(self).",
+    "builtins.IsADirectoryError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.IsADirectoryError.__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.IsADirectoryError.__le__" => "Return self<=value.",
+    "builtins.IsADirectoryError.__lt__" => "Return self<value.",
+    "builtins.IsADirectoryError.__ne__" => "Return self!=value.",
+    "builtins.IsADirectoryError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.IsADirectoryError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.IsADirectoryError.__repr__" => "Return repr(self).",
+    "builtins.IsADirectoryError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.KeyError.__ge__" => "Return self>=value.",
+    "builtins.KeyError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.KeyError.__getstate__" => "Helper for pickle.",
+    "builtins.KeyError.__gt__" => "Return self>value.",
+    "builtins.KeyError.__hash__" => "Return hash(self).",
+    "builtins.KeyError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.KeyError.__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.KeyError.__le__" => "Return self<=value.",
+    "builtins.KeyError.__lt__" => "Return self<value.",
+    "builtins.KeyError.__ne__" => "Return self!=value.",
+    "builtins.KeyError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.KeyError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.KeyError.__repr__" => "Return repr(self).",
+    "builtins.KeyError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.KeyboardInterrupt.__ge__" => "Return self>=value.",
+    "builtins.KeyboardInterrupt.__getattribute__" => "Return getattr(self, name).",
+    "builtins.KeyboardInterrupt.__getstate__" => "Helper for pickle.",
+    "builtins.KeyboardInterrupt.__gt__" => "Return self>value.",
+    "builtins.KeyboardInterrupt.__hash__" => "Return hash(self).",
+    "builtins.KeyboardInterrupt.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.KeyboardInterrupt.__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.KeyboardInterrupt.__le__" => "Return self<=value.",
+    "builtins.KeyboardInterrupt.__lt__" => "Return self<value.",
+    "builtins.KeyboardInterrupt.__ne__" => "Return self!=value.",
+    "builtins.KeyboardInterrupt.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.KeyboardInterrupt.__reduce_ex__" => "Helper for pickle.",
+    "builtins.KeyboardInterrupt.__repr__" => "Return repr(self).",
+    "builtins.KeyboardInterrupt.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.LookupError.__ge__" => "Return self>=value.",
+    "builtins.LookupError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.LookupError.__getstate__" => "Helper for pickle.",
+    "builtins.LookupError.__gt__" => "Return self>value.",
+    "builtins.LookupError.__hash__" => "Return hash(self).",
+    "builtins.LookupError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.LookupError.__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.LookupError.__le__" => "Return self<=value.",
+    "builtins.LookupError.__lt__" => "Return self<value.",
+    "builtins.LookupError.__ne__" => "Return self!=value.",
+    "builtins.LookupError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.LookupError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.LookupError.__repr__" => "Return repr(self).",
+    "builtins.LookupError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.MemoryError.__ge__" => "Return self>=value.",
+    "builtins.MemoryError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.MemoryError.__getstate__" => "Helper for pickle.",
+    "builtins.MemoryError.__gt__" => "Return self>value.",
+    "builtins.MemoryError.__hash__" => "Return hash(self).",
+    "builtins.MemoryError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.MemoryError.__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.MemoryError.__le__" => "Return self<=value.",
+    "builtins.MemoryError.__lt__" => "Return self<value.",
+    "builtins.MemoryError.__ne__" => "Return self!=value.",
+    "builtins.MemoryError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.MemoryError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.MemoryError.__repr__" => "Return repr(self).",
+    "builtins.MemoryError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ModuleNotFoundError.__ge__" => "Return self>=value.",
+    "builtins.ModuleNotFoundError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ModuleNotFoundError.__getstate__" => "Helper for pickle.",
+    "builtins.ModuleNotFoundError.__gt__" => "Return self>value.",
+    "builtins.ModuleNotFoundError.__hash__" => "Return hash(self).",
+    "builtins.ModuleNotFoundError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ModuleNotFoundError.__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.ModuleNotFoundError.__le__" => "Return self<=value.",
+    "builtins.ModuleNotFoundError.__lt__" => "Return self<value.",
+    "builtins.ModuleNotFoundError.__ne__" => "Return self!=value.",
+    "builtins.ModuleNotFoundError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ModuleNotFoundError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ModuleNotFoundError.__repr__" => "Return repr(self).",
+    "builtins.ModuleNotFoundError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.NameError.__ge__" => "Return self>=value.",
+    "builtins.NameError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.NameError.__getstate__" => "Helper for pickle.",
+    "builtins.NameError.__gt__" => "Return self>value.",
+    "builtins.NameError.__hash__" => "Return hash(self).",
+    "builtins.NameError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.NameError.__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.NameError.__le__" => "Return self<=value.",
+    "builtins.NameError.__lt__" => "Return self<value.",
+    "builtins.NameError.__ne__" => "Return self!=value.",
+    "builtins.NameError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.NameError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.NameError.__repr__" => "Return repr(self).",
+    "builtins.NameError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.name" => "name",
+    "builtins.NameError.with_traceback" => "Exception.with_traceback(tb) --\nset 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).",
+    "builtins.NoneType.__eq__" => "Return self==value.",
+    "builtins.NoneType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.NoneType.__ge__" => "Return self>=value.",
+    "builtins.NoneType.__getattribute__" => "Return getattr(self, name).",
+    "builtins.NoneType.__getstate__" => "Helper for pickle.",
+    "builtins.NoneType.__gt__" => "Return self>value.",
+    "builtins.NoneType.__hash__" => "Return hash(self).",
+    "builtins.NoneType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.NoneType.__le__" => "Return self<=value.",
+    "builtins.NoneType.__lt__" => "Return self<value.",
+    "builtins.NoneType.__ne__" => "Return self!=value.",
+    "builtins.NoneType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.NoneType.__reduce__" => "Helper for pickle.",
+    "builtins.NoneType.__reduce_ex__" => "Helper for pickle.",
+    "builtins.NoneType.__repr__" => "Return repr(self).",
+    "builtins.NoneType.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.NoneType.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.",
+    "builtins.NotADirectoryError.__ge__" => "Return self>=value.",
+    "builtins.NotADirectoryError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.NotADirectoryError.__getstate__" => "Helper for pickle.",
+    "builtins.NotADirectoryError.__gt__" => "Return self>value.",
+    "builtins.NotADirectoryError.__hash__" => "Return hash(self).",
+    "builtins.NotADirectoryError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.NotADirectoryError.__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.NotADirectoryError.__le__" => "Return self<=value.",
+    "builtins.NotADirectoryError.__lt__" => "Return self<value.",
+    "builtins.NotADirectoryError.__ne__" => "Return self!=value.",
+    "builtins.NotADirectoryError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.NotADirectoryError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.NotADirectoryError.__repr__" => "Return repr(self).",
+    "builtins.NotADirectoryError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.NotImplementedError.__ge__" => "Return self>=value.",
+    "builtins.NotImplementedError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.NotImplementedError.__getstate__" => "Helper for pickle.",
+    "builtins.NotImplementedError.__gt__" => "Return self>value.",
+    "builtins.NotImplementedError.__hash__" => "Return hash(self).",
+    "builtins.NotImplementedError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.NotImplementedError.__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.NotImplementedError.__le__" => "Return self<=value.",
+    "builtins.NotImplementedError.__lt__" => "Return self<value.",
+    "builtins.NotImplementedError.__ne__" => "Return self!=value.",
+    "builtins.NotImplementedError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.NotImplementedError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.NotImplementedError.__repr__" => "Return repr(self).",
+    "builtins.NotImplementedError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.NotImplementedType" => "The type of the NotImplemented singleton.",
+    "builtins.NotImplementedType.__bool__" => "True if self else False",
+    "builtins.NotImplementedType.__delattr__" => "Implement delattr(self, name).",
+    "builtins.NotImplementedType.__eq__" => "Return self==value.",
+    "builtins.NotImplementedType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.NotImplementedType.__ge__" => "Return self>=value.",
+    "builtins.NotImplementedType.__getattribute__" => "Return getattr(self, name).",
+    "builtins.NotImplementedType.__getstate__" => "Helper for pickle.",
+    "builtins.NotImplementedType.__gt__" => "Return self>value.",
+    "builtins.NotImplementedType.__hash__" => "Return hash(self).",
+    "builtins.NotImplementedType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.NotImplementedType.__le__" => "Return self<=value.",
+    "builtins.NotImplementedType.__lt__" => "Return self<value.",
+    "builtins.NotImplementedType.__ne__" => "Return self!=value.",
+    "builtins.NotImplementedType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.NotImplementedType.__reduce_ex__" => "Helper for pickle.",
+    "builtins.NotImplementedType.__repr__" => "Return repr(self).",
+    "builtins.NotImplementedType.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.NotImplementedType.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.",
+    "builtins.OSError.__ge__" => "Return self>=value.",
+    "builtins.OSError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.OSError.__getstate__" => "Helper for pickle.",
+    "builtins.OSError.__gt__" => "Return self>value.",
+    "builtins.OSError.__hash__" => "Return hash(self).",
+    "builtins.OSError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.OSError.__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.OSError.__le__" => "Return self<=value.",
+    "builtins.OSError.__lt__" => "Return self<value.",
+    "builtins.OSError.__ne__" => "Return self!=value.",
+    "builtins.OSError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.OSError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.OSError.__repr__" => "Return repr(self).",
+    "builtins.OSError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.OverflowError.__ge__" => "Return self>=value.",
+    "builtins.OverflowError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.OverflowError.__getstate__" => "Helper for pickle.",
+    "builtins.OverflowError.__gt__" => "Return self>value.",
+    "builtins.OverflowError.__hash__" => "Return hash(self).",
+    "builtins.OverflowError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.OverflowError.__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.OverflowError.__le__" => "Return self<=value.",
+    "builtins.OverflowError.__lt__" => "Return self<value.",
+    "builtins.OverflowError.__ne__" => "Return self!=value.",
+    "builtins.OverflowError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.OverflowError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.OverflowError.__repr__" => "Return repr(self).",
+    "builtins.OverflowError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.PendingDeprecationWarning.__ge__" => "Return self>=value.",
+    "builtins.PendingDeprecationWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.PendingDeprecationWarning.__getstate__" => "Helper for pickle.",
+    "builtins.PendingDeprecationWarning.__gt__" => "Return self>value.",
+    "builtins.PendingDeprecationWarning.__hash__" => "Return hash(self).",
+    "builtins.PendingDeprecationWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.PendingDeprecationWarning.__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.PendingDeprecationWarning.__le__" => "Return self<=value.",
+    "builtins.PendingDeprecationWarning.__lt__" => "Return self<value.",
+    "builtins.PendingDeprecationWarning.__ne__" => "Return self!=value.",
+    "builtins.PendingDeprecationWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.PendingDeprecationWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.PendingDeprecationWarning.__repr__" => "Return repr(self).",
+    "builtins.PendingDeprecationWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.PermissionError.__ge__" => "Return self>=value.",
+    "builtins.PermissionError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.PermissionError.__getstate__" => "Helper for pickle.",
+    "builtins.PermissionError.__gt__" => "Return self>value.",
+    "builtins.PermissionError.__hash__" => "Return hash(self).",
+    "builtins.PermissionError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.PermissionError.__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.PermissionError.__le__" => "Return self<=value.",
+    "builtins.PermissionError.__lt__" => "Return self<value.",
+    "builtins.PermissionError.__ne__" => "Return self!=value.",
+    "builtins.PermissionError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.PermissionError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.PermissionError.__repr__" => "Return repr(self).",
+    "builtins.PermissionError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ProcessLookupError.__ge__" => "Return self>=value.",
+    "builtins.ProcessLookupError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ProcessLookupError.__getstate__" => "Helper for pickle.",
+    "builtins.ProcessLookupError.__gt__" => "Return self>value.",
+    "builtins.ProcessLookupError.__hash__" => "Return hash(self).",
+    "builtins.ProcessLookupError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ProcessLookupError.__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.ProcessLookupError.__le__" => "Return self<=value.",
+    "builtins.ProcessLookupError.__lt__" => "Return self<value.",
+    "builtins.ProcessLookupError.__ne__" => "Return self!=value.",
+    "builtins.ProcessLookupError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ProcessLookupError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ProcessLookupError.__repr__" => "Return repr(self).",
+    "builtins.ProcessLookupError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.PythonFinalizationError.__ge__" => "Return self>=value.",
+    "builtins.PythonFinalizationError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.PythonFinalizationError.__getstate__" => "Helper for pickle.",
+    "builtins.PythonFinalizationError.__gt__" => "Return self>value.",
+    "builtins.PythonFinalizationError.__hash__" => "Return hash(self).",
+    "builtins.PythonFinalizationError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.PythonFinalizationError.__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.PythonFinalizationError.__le__" => "Return self<=value.",
+    "builtins.PythonFinalizationError.__lt__" => "Return self<value.",
+    "builtins.PythonFinalizationError.__ne__" => "Return self!=value.",
+    "builtins.PythonFinalizationError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.PythonFinalizationError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.PythonFinalizationError.__repr__" => "Return repr(self).",
+    "builtins.PythonFinalizationError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.RecursionError.__ge__" => "Return self>=value.",
+    "builtins.RecursionError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.RecursionError.__getstate__" => "Helper for pickle.",
+    "builtins.RecursionError.__gt__" => "Return self>value.",
+    "builtins.RecursionError.__hash__" => "Return hash(self).",
+    "builtins.RecursionError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.RecursionError.__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.RecursionError.__le__" => "Return self<=value.",
+    "builtins.RecursionError.__lt__" => "Return self<value.",
+    "builtins.RecursionError.__ne__" => "Return self!=value.",
+    "builtins.RecursionError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.RecursionError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.RecursionError.__repr__" => "Return repr(self).",
+    "builtins.RecursionError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ReferenceError.__ge__" => "Return self>=value.",
+    "builtins.ReferenceError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ReferenceError.__getstate__" => "Helper for pickle.",
+    "builtins.ReferenceError.__gt__" => "Return self>value.",
+    "builtins.ReferenceError.__hash__" => "Return hash(self).",
+    "builtins.ReferenceError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ReferenceError.__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.ReferenceError.__le__" => "Return self<=value.",
+    "builtins.ReferenceError.__lt__" => "Return self<value.",
+    "builtins.ReferenceError.__ne__" => "Return self!=value.",
+    "builtins.ReferenceError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ReferenceError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ReferenceError.__repr__" => "Return repr(self).",
+    "builtins.ReferenceError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ResourceWarning.__ge__" => "Return self>=value.",
+    "builtins.ResourceWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ResourceWarning.__getstate__" => "Helper for pickle.",
+    "builtins.ResourceWarning.__gt__" => "Return self>value.",
+    "builtins.ResourceWarning.__hash__" => "Return hash(self).",
+    "builtins.ResourceWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ResourceWarning.__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.ResourceWarning.__le__" => "Return self<=value.",
+    "builtins.ResourceWarning.__lt__" => "Return self<value.",
+    "builtins.ResourceWarning.__ne__" => "Return self!=value.",
+    "builtins.ResourceWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ResourceWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ResourceWarning.__repr__" => "Return repr(self).",
+    "builtins.ResourceWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.RuntimeError.__ge__" => "Return self>=value.",
+    "builtins.RuntimeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.RuntimeError.__getstate__" => "Helper for pickle.",
+    "builtins.RuntimeError.__gt__" => "Return self>value.",
+    "builtins.RuntimeError.__hash__" => "Return hash(self).",
+    "builtins.RuntimeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.RuntimeError.__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.RuntimeError.__le__" => "Return self<=value.",
+    "builtins.RuntimeError.__lt__" => "Return self<value.",
+    "builtins.RuntimeError.__ne__" => "Return self!=value.",
+    "builtins.RuntimeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.RuntimeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.RuntimeError.__repr__" => "Return repr(self).",
+    "builtins.RuntimeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.RuntimeWarning.__ge__" => "Return self>=value.",
+    "builtins.RuntimeWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.RuntimeWarning.__getstate__" => "Helper for pickle.",
+    "builtins.RuntimeWarning.__gt__" => "Return self>value.",
+    "builtins.RuntimeWarning.__hash__" => "Return hash(self).",
+    "builtins.RuntimeWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.RuntimeWarning.__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.RuntimeWarning.__le__" => "Return self<=value.",
+    "builtins.RuntimeWarning.__lt__" => "Return self<value.",
+    "builtins.RuntimeWarning.__ne__" => "Return self!=value.",
+    "builtins.RuntimeWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.RuntimeWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.RuntimeWarning.__repr__" => "Return repr(self).",
+    "builtins.RuntimeWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.SimpleNamespace" => "A simple attribute-based namespace.",
+    "builtins.SimpleNamespace.__delattr__" => "Implement delattr(self, name).",
+    "builtins.SimpleNamespace.__eq__" => "Return self==value.",
+    "builtins.SimpleNamespace.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.SimpleNamespace.__ge__" => "Return self>=value.",
+    "builtins.SimpleNamespace.__getattribute__" => "Return getattr(self, name).",
+    "builtins.SimpleNamespace.__getstate__" => "Helper for pickle.",
+    "builtins.SimpleNamespace.__gt__" => "Return self>value.",
+    "builtins.SimpleNamespace.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.SimpleNamespace.__le__" => "Return self<=value.",
+    "builtins.SimpleNamespace.__lt__" => "Return self<value.",
+    "builtins.SimpleNamespace.__ne__" => "Return self!=value.",
+    "builtins.SimpleNamespace.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.SimpleNamespace.__reduce__" => "Return state information for pickling",
+    "builtins.SimpleNamespace.__reduce_ex__" => "Helper for pickle.",
+    "builtins.SimpleNamespace.__replace__" => "Return a copy of the namespace object with new values for the specified attributes.",
+    "builtins.SimpleNamespace.__repr__" => "Return repr(self).",
+    "builtins.SimpleNamespace.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.SimpleNamespace.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.",
+    "builtins.StopAsyncIteration.__ge__" => "Return self>=value.",
+    "builtins.StopAsyncIteration.__getattribute__" => "Return getattr(self, name).",
+    "builtins.StopAsyncIteration.__getstate__" => "Helper for pickle.",
+    "builtins.StopAsyncIteration.__gt__" => "Return self>value.",
+    "builtins.StopAsyncIteration.__hash__" => "Return hash(self).",
+    "builtins.StopAsyncIteration.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.StopAsyncIteration.__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.StopAsyncIteration.__le__" => "Return self<=value.",
+    "builtins.StopAsyncIteration.__lt__" => "Return self<value.",
+    "builtins.StopAsyncIteration.__ne__" => "Return self!=value.",
+    "builtins.StopAsyncIteration.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.StopAsyncIteration.__reduce_ex__" => "Helper for pickle.",
+    "builtins.StopAsyncIteration.__repr__" => "Return repr(self).",
+    "builtins.StopAsyncIteration.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.StopIteration.__ge__" => "Return self>=value.",
+    "builtins.StopIteration.__getattribute__" => "Return getattr(self, name).",
+    "builtins.StopIteration.__getstate__" => "Helper for pickle.",
+    "builtins.StopIteration.__gt__" => "Return self>value.",
+    "builtins.StopIteration.__hash__" => "Return hash(self).",
+    "builtins.StopIteration.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.StopIteration.__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.StopIteration.__le__" => "Return self<=value.",
+    "builtins.StopIteration.__lt__" => "Return self<value.",
+    "builtins.StopIteration.__ne__" => "Return self!=value.",
+    "builtins.StopIteration.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.StopIteration.__reduce_ex__" => "Helper for pickle.",
+    "builtins.StopIteration.__repr__" => "Return repr(self).",
+    "builtins.StopIteration.__setattr__" => "Implement setattr(self, name, value).",
+    "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.value" => "generator return value",
+    "builtins.StopIteration.with_traceback" => "Exception.with_traceback(tb) --\nset 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.",
+    "builtins.SyntaxError.__ge__" => "Return self>=value.",
+    "builtins.SyntaxError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.SyntaxError.__getstate__" => "Helper for pickle.",
+    "builtins.SyntaxError.__gt__" => "Return self>value.",
+    "builtins.SyntaxError.__hash__" => "Return hash(self).",
+    "builtins.SyntaxError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.SyntaxError.__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.SyntaxError.__le__" => "Return self<=value.",
+    "builtins.SyntaxError.__lt__" => "Return self<value.",
+    "builtins.SyntaxError.__ne__" => "Return self!=value.",
+    "builtins.SyntaxError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.SyntaxError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.SyntaxError.__repr__" => "Return repr(self).",
+    "builtins.SyntaxError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.end_lineno" => "exception end lineno",
+    "builtins.SyntaxError.end_offset" => "exception end offset",
+    "builtins.SyntaxError.filename" => "exception filename",
+    "builtins.SyntaxError.lineno" => "exception lineno",
+    "builtins.SyntaxError.msg" => "exception msg",
+    "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.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.",
+    "builtins.SyntaxWarning.__ge__" => "Return self>=value.",
+    "builtins.SyntaxWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.SyntaxWarning.__getstate__" => "Helper for pickle.",
+    "builtins.SyntaxWarning.__gt__" => "Return self>value.",
+    "builtins.SyntaxWarning.__hash__" => "Return hash(self).",
+    "builtins.SyntaxWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.SyntaxWarning.__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.SyntaxWarning.__le__" => "Return self<=value.",
+    "builtins.SyntaxWarning.__lt__" => "Return self<value.",
+    "builtins.SyntaxWarning.__ne__" => "Return self!=value.",
+    "builtins.SyntaxWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.SyntaxWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.SyntaxWarning.__repr__" => "Return repr(self).",
+    "builtins.SyntaxWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.SystemError.__ge__" => "Return self>=value.",
+    "builtins.SystemError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.SystemError.__getstate__" => "Helper for pickle.",
+    "builtins.SystemError.__gt__" => "Return self>value.",
+    "builtins.SystemError.__hash__" => "Return hash(self).",
+    "builtins.SystemError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.SystemError.__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.SystemError.__le__" => "Return self<=value.",
+    "builtins.SystemError.__lt__" => "Return self<value.",
+    "builtins.SystemError.__ne__" => "Return self!=value.",
+    "builtins.SystemError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.SystemError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.SystemError.__repr__" => "Return repr(self).",
+    "builtins.SystemError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.SystemExit.__ge__" => "Return self>=value.",
+    "builtins.SystemExit.__getattribute__" => "Return getattr(self, name).",
+    "builtins.SystemExit.__getstate__" => "Helper for pickle.",
+    "builtins.SystemExit.__gt__" => "Return self>value.",
+    "builtins.SystemExit.__hash__" => "Return hash(self).",
+    "builtins.SystemExit.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.SystemExit.__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.SystemExit.__le__" => "Return self<=value.",
+    "builtins.SystemExit.__lt__" => "Return self<value.",
+    "builtins.SystemExit.__ne__" => "Return self!=value.",
+    "builtins.SystemExit.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.SystemExit.__reduce_ex__" => "Helper for pickle.",
+    "builtins.SystemExit.__repr__" => "Return repr(self).",
+    "builtins.SystemExit.__setattr__" => "Implement setattr(self, name, value).",
+    "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.code" => "exception code",
+    "builtins.SystemExit.with_traceback" => "Exception.with_traceback(tb) --\nset 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.",
+    "builtins.TabError.__ge__" => "Return self>=value.",
+    "builtins.TabError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.TabError.__getstate__" => "Helper for pickle.",
+    "builtins.TabError.__gt__" => "Return self>value.",
+    "builtins.TabError.__hash__" => "Return hash(self).",
+    "builtins.TabError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.TabError.__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.TabError.__le__" => "Return self<=value.",
+    "builtins.TabError.__lt__" => "Return self<value.",
+    "builtins.TabError.__ne__" => "Return self!=value.",
+    "builtins.TabError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.TabError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.TabError.__repr__" => "Return repr(self).",
+    "builtins.TabError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.end_lineno" => "exception end lineno",
+    "builtins.TabError.end_offset" => "exception end offset",
+    "builtins.TabError.filename" => "exception filename",
+    "builtins.TabError.lineno" => "exception lineno",
+    "builtins.TabError.msg" => "exception msg",
+    "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.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.",
+    "builtins.TimeoutError.__ge__" => "Return self>=value.",
+    "builtins.TimeoutError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.TimeoutError.__getstate__" => "Helper for pickle.",
+    "builtins.TimeoutError.__gt__" => "Return self>value.",
+    "builtins.TimeoutError.__hash__" => "Return hash(self).",
+    "builtins.TimeoutError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.TimeoutError.__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.TimeoutError.__le__" => "Return self<=value.",
+    "builtins.TimeoutError.__lt__" => "Return self<value.",
+    "builtins.TimeoutError.__ne__" => "Return self!=value.",
+    "builtins.TimeoutError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.TimeoutError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.TimeoutError.__repr__" => "Return repr(self).",
+    "builtins.TimeoutError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.TypeError.__ge__" => "Return self>=value.",
+    "builtins.TypeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.TypeError.__getstate__" => "Helper for pickle.",
+    "builtins.TypeError.__gt__" => "Return self>value.",
+    "builtins.TypeError.__hash__" => "Return hash(self).",
+    "builtins.TypeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.TypeError.__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.TypeError.__le__" => "Return self<=value.",
+    "builtins.TypeError.__lt__" => "Return self<value.",
+    "builtins.TypeError.__ne__" => "Return self!=value.",
+    "builtins.TypeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.TypeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.TypeError.__repr__" => "Return repr(self).",
+    "builtins.TypeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.UnboundLocalError.__ge__" => "Return self>=value.",
+    "builtins.UnboundLocalError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnboundLocalError.__getstate__" => "Helper for pickle.",
+    "builtins.UnboundLocalError.__gt__" => "Return self>value.",
+    "builtins.UnboundLocalError.__hash__" => "Return hash(self).",
+    "builtins.UnboundLocalError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnboundLocalError.__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.UnboundLocalError.__le__" => "Return self<=value.",
+    "builtins.UnboundLocalError.__lt__" => "Return self<value.",
+    "builtins.UnboundLocalError.__ne__" => "Return self!=value.",
+    "builtins.UnboundLocalError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnboundLocalError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnboundLocalError.__repr__" => "Return repr(self).",
+    "builtins.UnboundLocalError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.name" => "name",
+    "builtins.UnboundLocalError.with_traceback" => "Exception.with_traceback(tb) --\nset 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.",
+    "builtins.UnicodeDecodeError.__ge__" => "Return self>=value.",
+    "builtins.UnicodeDecodeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnicodeDecodeError.__getstate__" => "Helper for pickle.",
+    "builtins.UnicodeDecodeError.__gt__" => "Return self>value.",
+    "builtins.UnicodeDecodeError.__hash__" => "Return hash(self).",
+    "builtins.UnicodeDecodeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnicodeDecodeError.__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.UnicodeDecodeError.__le__" => "Return self<=value.",
+    "builtins.UnicodeDecodeError.__lt__" => "Return self<value.",
+    "builtins.UnicodeDecodeError.__ne__" => "Return self!=value.",
+    "builtins.UnicodeDecodeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnicodeDecodeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnicodeDecodeError.__repr__" => "Return repr(self).",
+    "builtins.UnicodeDecodeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.UnicodeEncodeError.__ge__" => "Return self>=value.",
+    "builtins.UnicodeEncodeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnicodeEncodeError.__getstate__" => "Helper for pickle.",
+    "builtins.UnicodeEncodeError.__gt__" => "Return self>value.",
+    "builtins.UnicodeEncodeError.__hash__" => "Return hash(self).",
+    "builtins.UnicodeEncodeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnicodeEncodeError.__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.UnicodeEncodeError.__le__" => "Return self<=value.",
+    "builtins.UnicodeEncodeError.__lt__" => "Return self<value.",
+    "builtins.UnicodeEncodeError.__ne__" => "Return self!=value.",
+    "builtins.UnicodeEncodeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnicodeEncodeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnicodeEncodeError.__repr__" => "Return repr(self).",
+    "builtins.UnicodeEncodeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.UnicodeError.__ge__" => "Return self>=value.",
+    "builtins.UnicodeError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnicodeError.__getstate__" => "Helper for pickle.",
+    "builtins.UnicodeError.__gt__" => "Return self>value.",
+    "builtins.UnicodeError.__hash__" => "Return hash(self).",
+    "builtins.UnicodeError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnicodeError.__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.UnicodeError.__le__" => "Return self<=value.",
+    "builtins.UnicodeError.__lt__" => "Return self<value.",
+    "builtins.UnicodeError.__ne__" => "Return self!=value.",
+    "builtins.UnicodeError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnicodeError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnicodeError.__repr__" => "Return repr(self).",
+    "builtins.UnicodeError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.UnicodeTranslateError.__ge__" => "Return self>=value.",
+    "builtins.UnicodeTranslateError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnicodeTranslateError.__getstate__" => "Helper for pickle.",
+    "builtins.UnicodeTranslateError.__gt__" => "Return self>value.",
+    "builtins.UnicodeTranslateError.__hash__" => "Return hash(self).",
+    "builtins.UnicodeTranslateError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnicodeTranslateError.__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.UnicodeTranslateError.__le__" => "Return self<=value.",
+    "builtins.UnicodeTranslateError.__lt__" => "Return self<value.",
+    "builtins.UnicodeTranslateError.__ne__" => "Return self!=value.",
+    "builtins.UnicodeTranslateError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnicodeTranslateError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnicodeTranslateError.__repr__" => "Return repr(self).",
+    "builtins.UnicodeTranslateError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.UnicodeWarning.__ge__" => "Return self>=value.",
+    "builtins.UnicodeWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UnicodeWarning.__getstate__" => "Helper for pickle.",
+    "builtins.UnicodeWarning.__gt__" => "Return self>value.",
+    "builtins.UnicodeWarning.__hash__" => "Return hash(self).",
+    "builtins.UnicodeWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UnicodeWarning.__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.UnicodeWarning.__le__" => "Return self<=value.",
+    "builtins.UnicodeWarning.__lt__" => "Return self<value.",
+    "builtins.UnicodeWarning.__ne__" => "Return self!=value.",
+    "builtins.UnicodeWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UnicodeWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UnicodeWarning.__repr__" => "Return repr(self).",
+    "builtins.UnicodeWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.UserWarning.__ge__" => "Return self>=value.",
+    "builtins.UserWarning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.UserWarning.__getstate__" => "Helper for pickle.",
+    "builtins.UserWarning.__gt__" => "Return self>value.",
+    "builtins.UserWarning.__hash__" => "Return hash(self).",
+    "builtins.UserWarning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.UserWarning.__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.UserWarning.__le__" => "Return self<=value.",
+    "builtins.UserWarning.__lt__" => "Return self<value.",
+    "builtins.UserWarning.__ne__" => "Return self!=value.",
+    "builtins.UserWarning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.UserWarning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.UserWarning.__repr__" => "Return repr(self).",
+    "builtins.UserWarning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.ValueError.__ge__" => "Return self>=value.",
+    "builtins.ValueError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ValueError.__getstate__" => "Helper for pickle.",
+    "builtins.ValueError.__gt__" => "Return self>value.",
+    "builtins.ValueError.__hash__" => "Return hash(self).",
+    "builtins.ValueError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ValueError.__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.ValueError.__le__" => "Return self<=value.",
+    "builtins.ValueError.__lt__" => "Return self<value.",
+    "builtins.ValueError.__ne__" => "Return self!=value.",
+    "builtins.ValueError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ValueError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ValueError.__repr__" => "Return repr(self).",
+    "builtins.ValueError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.Warning.__ge__" => "Return self>=value.",
+    "builtins.Warning.__getattribute__" => "Return getattr(self, name).",
+    "builtins.Warning.__getstate__" => "Helper for pickle.",
+    "builtins.Warning.__gt__" => "Return self>value.",
+    "builtins.Warning.__hash__" => "Return hash(self).",
+    "builtins.Warning.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.Warning.__le__" => "Return self<=value.",
+    "builtins.Warning.__lt__" => "Return self<value.",
+    "builtins.Warning.__ne__" => "Return self!=value.",
+    "builtins.Warning.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.Warning.__reduce_ex__" => "Helper for pickle.",
+    "builtins.Warning.__repr__" => "Return repr(self).",
+    "builtins.Warning.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.",
+    "builtins.WindowsError.__ge__" => "Return self>=value.",
+    "builtins.WindowsError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.WindowsError.__getstate__" => "Helper for pickle.",
+    "builtins.WindowsError.__gt__" => "Return self>value.",
+    "builtins.WindowsError.__hash__" => "Return hash(self).",
+    "builtins.WindowsError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.WindowsError.__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.WindowsError.__le__" => "Return self<=value.",
+    "builtins.WindowsError.__lt__" => "Return self<value.",
+    "builtins.WindowsError.__ne__" => "Return self!=value.",
+    "builtins.WindowsError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.WindowsError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.WindowsError.__repr__" => "Return repr(self).",
+    "builtins.WindowsError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.ZeroDivisionError.__ge__" => "Return self>=value.",
+    "builtins.ZeroDivisionError.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ZeroDivisionError.__getstate__" => "Helper for pickle.",
+    "builtins.ZeroDivisionError.__gt__" => "Return self>value.",
+    "builtins.ZeroDivisionError.__hash__" => "Return hash(self).",
+    "builtins.ZeroDivisionError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ZeroDivisionError.__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.ZeroDivisionError.__le__" => "Return self<=value.",
+    "builtins.ZeroDivisionError.__lt__" => "Return self<value.",
+    "builtins.ZeroDivisionError.__ne__" => "Return self!=value.",
+    "builtins.ZeroDivisionError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ZeroDivisionError.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ZeroDivisionError.__repr__" => "Return repr(self).",
+    "builtins.ZeroDivisionError.__setattr__" => "Implement setattr(self, name, value).",
+    "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._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.",
+    "builtins._IncompleteInputError.__ge__" => "Return self>=value.",
+    "builtins._IncompleteInputError.__getattribute__" => "Return getattr(self, name).",
+    "builtins._IncompleteInputError.__getstate__" => "Helper for pickle.",
+    "builtins._IncompleteInputError.__gt__" => "Return self>value.",
+    "builtins._IncompleteInputError.__hash__" => "Return hash(self).",
+    "builtins._IncompleteInputError.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins._IncompleteInputError.__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._IncompleteInputError.__le__" => "Return self<=value.",
+    "builtins._IncompleteInputError.__lt__" => "Return self<value.",
+    "builtins._IncompleteInputError.__ne__" => "Return self!=value.",
+    "builtins._IncompleteInputError.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins._IncompleteInputError.__reduce_ex__" => "Helper for pickle.",
+    "builtins._IncompleteInputError.__repr__" => "Return repr(self).",
+    "builtins._IncompleteInputError.__setattr__" => "Implement setattr(self, name, value).",
+    "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.end_lineno" => "exception end lineno",
+    "builtins._IncompleteInputError.end_offset" => "exception end offset",
+    "builtins._IncompleteInputError.filename" => "exception filename",
+    "builtins._IncompleteInputError.lineno" => "exception lineno",
+    "builtins._IncompleteInputError.msg" => "exception msg",
+    "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.__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.",
+    "builtins.aiter" => "Return an AsyncIterator for an AsyncIterable object.",
+    "builtins.all" => "Return True if bool(x) is True for all values x in the iterable.\n\nIf the iterable is empty, return True.",
+    "builtins.anext" => "Return the next item from the async iterator.\n\nIf default is given and the async iterator is exhausted,\nit is returned instead of raising StopAsyncIteration.",
+    "builtins.any" => "Return True if bool(x) is True for any x in the iterable.\n\nIf the iterable is empty, return False.",
+    "builtins.ascii" => "Return an ASCII-only representation of an object.\n\nAs repr(), return a string containing a printable representation of an\nobject, but escape the non-ASCII characters in the string returned by\nrepr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\nto that returned by repr() in Python 2.",
+    "builtins.async_generator.__aiter__" => "Return an awaitable, that resolves in asynchronous iterator.",
+    "builtins.async_generator.__anext__" => "Return a value or raise StopAsyncIteration.",
+    "builtins.async_generator.__class_getitem__" => "See PEP 585",
+    "builtins.async_generator.__del__" => "Called when the instance is about to be destroyed.",
+    "builtins.async_generator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.async_generator.__eq__" => "Return self==value.",
+    "builtins.async_generator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.async_generator.__ge__" => "Return self>=value.",
+    "builtins.async_generator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.async_generator.__getstate__" => "Helper for pickle.",
+    "builtins.async_generator.__gt__" => "Return self>value.",
+    "builtins.async_generator.__hash__" => "Return hash(self).",
+    "builtins.async_generator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.async_generator.__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.async_generator.__le__" => "Return self<=value.",
+    "builtins.async_generator.__lt__" => "Return self<value.",
+    "builtins.async_generator.__ne__" => "Return self!=value.",
+    "builtins.async_generator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.async_generator.__reduce__" => "Helper for pickle.",
+    "builtins.async_generator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.async_generator.__repr__" => "Return repr(self).",
+    "builtins.async_generator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.async_generator.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes",
+    "builtins.async_generator.__str__" => "Return str(self).",
+    "builtins.async_generator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.async_generator.aclose" => "aclose() -> raise GeneratorExit inside generator.",
+    "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.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.",
+    "builtins.bool.__and__" => "Return self&value.",
+    "builtins.bool.__bool__" => "True if self else False",
+    "builtins.bool.__ceil__" => "Ceiling of an Integral returns itself.",
+    "builtins.bool.__delattr__" => "Implement delattr(self, name).",
+    "builtins.bool.__divmod__" => "Return divmod(self, value).",
+    "builtins.bool.__eq__" => "Return self==value.",
+    "builtins.bool.__float__" => "float(self)",
+    "builtins.bool.__floor__" => "Flooring an Integral returns itself.",
+    "builtins.bool.__floordiv__" => "Return self//value.",
+    "builtins.bool.__format__" => "Convert to a string according to format_spec.",
+    "builtins.bool.__ge__" => "Return self>=value.",
+    "builtins.bool.__getattribute__" => "Return getattr(self, name).",
+    "builtins.bool.__getstate__" => "Helper for pickle.",
+    "builtins.bool.__gt__" => "Return self>value.",
+    "builtins.bool.__hash__" => "Return hash(self).",
+    "builtins.bool.__index__" => "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    "builtins.bool.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.bool.__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.bool.__int__" => "int(self)",
+    "builtins.bool.__invert__" => "~self",
+    "builtins.bool.__le__" => "Return self<=value.",
+    "builtins.bool.__lshift__" => "Return self<<value.",
+    "builtins.bool.__lt__" => "Return self<value.",
+    "builtins.bool.__mod__" => "Return self%value.",
+    "builtins.bool.__mul__" => "Return self*value.",
+    "builtins.bool.__ne__" => "Return self!=value.",
+    "builtins.bool.__neg__" => "-self",
+    "builtins.bool.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.bool.__or__" => "Return self|value.",
+    "builtins.bool.__pos__" => "+self",
+    "builtins.bool.__pow__" => "Return pow(self, value, mod).",
+    "builtins.bool.__radd__" => "Return value+self.",
+    "builtins.bool.__rand__" => "Return value&self.",
+    "builtins.bool.__rdivmod__" => "Return divmod(value, self).",
+    "builtins.bool.__reduce__" => "Helper for pickle.",
+    "builtins.bool.__reduce_ex__" => "Helper for pickle.",
+    "builtins.bool.__repr__" => "Return repr(self).",
+    "builtins.bool.__rfloordiv__" => "Return value//self.",
+    "builtins.bool.__rlshift__" => "Return value<<self.",
+    "builtins.bool.__rmod__" => "Return value%self.",
+    "builtins.bool.__rmul__" => "Return value*self.",
+    "builtins.bool.__ror__" => "Return value|self.",
+    "builtins.bool.__round__" => "Rounding an Integral returns itself.\n\nRounding with an ndigits argument also returns an integer.",
+    "builtins.bool.__rpow__" => "Return pow(value, self, mod).",
+    "builtins.bool.__rrshift__" => "Return value>>self.",
+    "builtins.bool.__rshift__" => "Return self>>value.",
+    "builtins.bool.__rsub__" => "Return value-self.",
+    "builtins.bool.__rtruediv__" => "Return value/self.",
+    "builtins.bool.__rxor__" => "Return value^self.",
+    "builtins.bool.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.bool.__sizeof__" => "Returns size in memory, in bytes.",
+    "builtins.bool.__str__" => "Return str(self).",
+    "builtins.bool.__sub__" => "Return self-value.",
+    "builtins.bool.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.bool.__truediv__" => "Return self/value.",
+    "builtins.bool.__trunc__" => "Truncating an Integral returns itself.",
+    "builtins.bool.__xor__" => "Return self^value.",
+    "builtins.bool.as_integer_ratio" => "Return a pair of integers, whose ratio is equal to the original int.\n\nThe ratio is in lowest terms and has a positive denominator.\n\n>>> (10).as_integer_ratio()\n(10, 1)\n>>> (-10).as_integer_ratio()\n(-10, 1)\n>>> (0).as_integer_ratio()\n(0, 1)",
+    "builtins.bool.bit_count" => "Number of ones in the binary representation of the absolute value of self.\n\nAlso known as the population count.\n\n>>> bin(13)\n'0b1101'\n>>> (13).bit_count()\n3",
+    "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.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.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).",
+    "builtins.builtin_function_or_method.__eq__" => "Return self==value.",
+    "builtins.builtin_function_or_method.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.builtin_function_or_method.__ge__" => "Return self>=value.",
+    "builtins.builtin_function_or_method.__getattribute__" => "Return getattr(self, name).",
+    "builtins.builtin_function_or_method.__getstate__" => "Helper for pickle.",
+    "builtins.builtin_function_or_method.__gt__" => "Return self>value.",
+    "builtins.builtin_function_or_method.__hash__" => "Return hash(self).",
+    "builtins.builtin_function_or_method.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.builtin_function_or_method.__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.builtin_function_or_method.__le__" => "Return self<=value.",
+    "builtins.builtin_function_or_method.__lt__" => "Return self<value.",
+    "builtins.builtin_function_or_method.__ne__" => "Return self!=value.",
+    "builtins.builtin_function_or_method.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.builtin_function_or_method.__reduce_ex__" => "Helper for pickle.",
+    "builtins.builtin_function_or_method.__repr__" => "Return repr(self).",
+    "builtins.builtin_function_or_method.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.builtin_function_or_method.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.builtin_function_or_method.__str__" => "Return str(self).",
+    "builtins.builtin_function_or_method.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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" => "bytearray(iterable_of_ints) -> bytearray\nbytearray(string, encoding[, errors]) -> bytearray\nbytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\nbytearray(int) -> bytes array of size given by the parameter initialized with null bytes\nbytearray() -> empty bytes array\n\nConstruct a mutable bytearray object from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - a bytes or a buffer object\n  - any object implementing the buffer API.\n  - an integer",
+    "builtins.bytearray.__add__" => "Return self+value.",
+    "builtins.bytearray.__alloc__" => "B.__alloc__() -> int\n\nReturn the number of bytes actually allocated.",
+    "builtins.bytearray.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "builtins.bytearray.__contains__" => "Return bool(key in self).",
+    "builtins.bytearray.__delattr__" => "Implement delattr(self, name).",
+    "builtins.bytearray.__delitem__" => "Delete self[key].",
+    "builtins.bytearray.__eq__" => "Return self==value.",
+    "builtins.bytearray.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.bytearray.__ge__" => "Return self>=value.",
+    "builtins.bytearray.__getattribute__" => "Return getattr(self, name).",
+    "builtins.bytearray.__getitem__" => "Return self[key].",
+    "builtins.bytearray.__getstate__" => "Helper for pickle.",
+    "builtins.bytearray.__gt__" => "Return self>value.",
+    "builtins.bytearray.__iadd__" => "Implement self+=value.",
+    "builtins.bytearray.__imul__" => "Implement self*=value.",
+    "builtins.bytearray.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.bytearray.__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.bytearray.__iter__" => "Implement iter(self).",
+    "builtins.bytearray.__le__" => "Return self<=value.",
+    "builtins.bytearray.__len__" => "Return len(self).",
+    "builtins.bytearray.__lt__" => "Return self<value.",
+    "builtins.bytearray.__mod__" => "Return self%value.",
+    "builtins.bytearray.__mul__" => "Return self*value.",
+    "builtins.bytearray.__ne__" => "Return self!=value.",
+    "builtins.bytearray.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.bytearray.__reduce__" => "Return state information for pickling.",
+    "builtins.bytearray.__reduce_ex__" => "Return state information for pickling.",
+    "builtins.bytearray.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "builtins.bytearray.__repr__" => "Return repr(self).",
+    "builtins.bytearray.__rmod__" => "Return value%self.",
+    "builtins.bytearray.__rmul__" => "Return value*self.",
+    "builtins.bytearray.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.bytearray.__setitem__" => "Set self[key] to value.",
+    "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.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.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.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.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.",
+    "builtins.bytearray.isdigit" => "B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise.",
+    "builtins.bytearray.islower" => "B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise.",
+    "builtins.bytearray.isspace" => "B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise.",
+    "builtins.bytearray.istitle" => "B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise.",
+    "builtins.bytearray.isupper" => "B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise.",
+    "builtins.bytearray.join" => "Concatenate any number of bytes/bytearray objects.\n\nThe bytearray whose method is called is inserted in between each pair.\n\nThe result is returned as a new bytearray object.",
+    "builtins.bytearray.ljust" => "Return a left-justified string of length width.\n\nPadding is done using the specified fill character.",
+    "builtins.bytearray.lower" => "B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase.",
+    "builtins.bytearray.lstrip" => "Strip leading bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading ASCII whitespace.",
+    "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.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.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.",
+    "builtins.bytearray.rjust" => "Return a right-justified string of length width.\n\nPadding is done using the specified fill character.",
+    "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.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.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.",
+    "builtins.bytearray.translate" => "Return a copy with each character mapped by the given translation table.\n\n  table\n    Translation table, which must be a bytes object of length 256.\n\nAll characters occurring in the optional argument delete are removed.\nThe remaining characters are mapped through the given translation table.",
+    "builtins.bytearray.upper" => "B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase.",
+    "builtins.bytearray.zfill" => "Pad a numeric string with zeros on the left, to fill a field of the given width.\n\nThe original string is never truncated.",
+    "builtins.bytearray_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.bytearray_iterator.__eq__" => "Return self==value.",
+    "builtins.bytearray_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.bytearray_iterator.__ge__" => "Return self>=value.",
+    "builtins.bytearray_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.bytearray_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.bytearray_iterator.__gt__" => "Return self>value.",
+    "builtins.bytearray_iterator.__hash__" => "Return hash(self).",
+    "builtins.bytearray_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.bytearray_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.",
+    "builtins.bytearray_iterator.__iter__" => "Implement iter(self).",
+    "builtins.bytearray_iterator.__le__" => "Return self<=value.",
+    "builtins.bytearray_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.bytearray_iterator.__lt__" => "Return self<value.",
+    "builtins.bytearray_iterator.__ne__" => "Return self!=value.",
+    "builtins.bytearray_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.bytearray_iterator.__next__" => "Implement next(self).",
+    "builtins.bytearray_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.bytearray_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.bytearray_iterator.__repr__" => "Return repr(self).",
+    "builtins.bytearray_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.bytearray_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.bytearray_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.bytearray_iterator.__str__" => "Return str(self).",
+    "builtins.bytearray_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.bytes" => "bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - any object implementing the buffer API.\n  - an integer",
+    "builtins.bytes.__add__" => "Return self+value.",
+    "builtins.bytes.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "builtins.bytes.__bytes__" => "Convert this value to exact type bytes.",
+    "builtins.bytes.__contains__" => "Return bool(key in self).",
+    "builtins.bytes.__delattr__" => "Implement delattr(self, name).",
+    "builtins.bytes.__eq__" => "Return self==value.",
+    "builtins.bytes.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.bytes.__ge__" => "Return self>=value.",
+    "builtins.bytes.__getattribute__" => "Return getattr(self, name).",
+    "builtins.bytes.__getitem__" => "Return self[key].",
+    "builtins.bytes.__getstate__" => "Helper for pickle.",
+    "builtins.bytes.__gt__" => "Return self>value.",
+    "builtins.bytes.__hash__" => "Return hash(self).",
+    "builtins.bytes.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.bytes.__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.bytes.__iter__" => "Implement iter(self).",
+    "builtins.bytes.__le__" => "Return self<=value.",
+    "builtins.bytes.__len__" => "Return len(self).",
+    "builtins.bytes.__lt__" => "Return self<value.",
+    "builtins.bytes.__mod__" => "Return self%value.",
+    "builtins.bytes.__mul__" => "Return self*value.",
+    "builtins.bytes.__ne__" => "Return self!=value.",
+    "builtins.bytes.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.bytes.__reduce__" => "Helper for pickle.",
+    "builtins.bytes.__reduce_ex__" => "Helper for pickle.",
+    "builtins.bytes.__repr__" => "Return repr(self).",
+    "builtins.bytes.__rmod__" => "Return value%self.",
+    "builtins.bytes.__rmul__" => "Return value*self.",
+    "builtins.bytes.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.bytes.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.bytes.__str__" => "Return str(self).",
+    "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.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'.",
+    "builtins.bytes.hex" => "Create a string of hexadecimal numbers from a bytes 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 = 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.bytes.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.bytes.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.bytes.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.bytes.isascii" => "B.isascii() -> bool\n\nReturn True if B is empty or all characters in B are ASCII,\nFalse otherwise.",
+    "builtins.bytes.isdigit" => "B.isdigit() -> bool\n\nReturn True if all characters in B are digits\nand there is at least one character in B, False otherwise.",
+    "builtins.bytes.islower" => "B.islower() -> bool\n\nReturn True if all cased characters in B are lowercase and there is\nat least one cased character in B, False otherwise.",
+    "builtins.bytes.isspace" => "B.isspace() -> bool\n\nReturn True if all characters in B are whitespace\nand there is at least one character in B, False otherwise.",
+    "builtins.bytes.istitle" => "B.istitle() -> bool\n\nReturn True if B is a titlecased string and there is at least one\ncharacter in B, i.e. uppercase characters may only follow uncased\ncharacters and lowercase characters only cased ones. Return False\notherwise.",
+    "builtins.bytes.isupper" => "B.isupper() -> bool\n\nReturn True if all cased characters in B are uppercase and there is\nat least one cased character in B, False otherwise.",
+    "builtins.bytes.join" => "Concatenate any number of bytes objects.\n\nThe bytes whose method is called is inserted in between each pair.\n\nThe result is returned as a new bytes object.\n\nExample: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.",
+    "builtins.bytes.ljust" => "Return a left-justified string of length width.\n\nPadding is done using the specified fill character.",
+    "builtins.bytes.lower" => "B.lower() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to lowercase.",
+    "builtins.bytes.lstrip" => "Strip leading bytes contained in the argument.\n\nIf the argument is omitted or None, strip leading  ASCII whitespace.",
+    "builtins.bytes.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.bytes.partition" => "Partition the bytes into three parts using the given separator.\n\nThis will search for the separator sep in the bytes. If the separator is found,\nreturns a 3-tuple containing the part before the separator, the separator\nitself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing the original bytes\nobject and two empty bytes objects.",
+    "builtins.bytes.removeprefix" => "Return a bytes object with the given prefix string removed if present.\n\nIf the bytes starts with the prefix string, return bytes[len(prefix):].\nOtherwise, return a copy of the original bytes.",
+    "builtins.bytes.removesuffix" => "Return a bytes object with the given suffix string removed if present.\n\nIf the bytes ends with the suffix string and that suffix is not empty,\nreturn bytes[:-len(prefix)].  Otherwise, return a copy of the original\nbytes.",
+    "builtins.bytes.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.bytes.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.bytes.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.",
+    "builtins.bytes.rjust" => "Return a right-justified string of length width.\n\nPadding is done using the specified fill character.",
+    "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.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.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.",
+    "builtins.bytes.translate" => "Return a copy with each character mapped by the given translation table.\n\n  table\n    Translation table, which must be a bytes object of length 256.\n\nAll characters occurring in the optional argument delete are removed.\nThe remaining characters are mapped through the given translation table.",
+    "builtins.bytes.upper" => "B.upper() -> copy of B\n\nReturn a copy of B with all ASCII characters converted to uppercase.",
+    "builtins.bytes.zfill" => "Pad a numeric string with zeros on the left, to fill a field of the given width.\n\nThe original string is never truncated.",
+    "builtins.bytes_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.bytes_iterator.__eq__" => "Return self==value.",
+    "builtins.bytes_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.bytes_iterator.__ge__" => "Return self>=value.",
+    "builtins.bytes_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.bytes_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.bytes_iterator.__gt__" => "Return self>value.",
+    "builtins.bytes_iterator.__hash__" => "Return hash(self).",
+    "builtins.bytes_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.bytes_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.",
+    "builtins.bytes_iterator.__iter__" => "Implement iter(self).",
+    "builtins.bytes_iterator.__le__" => "Return self<=value.",
+    "builtins.bytes_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.bytes_iterator.__lt__" => "Return self<value.",
+    "builtins.bytes_iterator.__ne__" => "Return self!=value.",
+    "builtins.bytes_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.bytes_iterator.__next__" => "Implement next(self).",
+    "builtins.bytes_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.bytes_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.bytes_iterator.__repr__" => "Return repr(self).",
+    "builtins.bytes_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.bytes_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.bytes_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.__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.",
+    "builtins.cell.__ge__" => "Return self>=value.",
+    "builtins.cell.__getattribute__" => "Return getattr(self, name).",
+    "builtins.cell.__getstate__" => "Helper for pickle.",
+    "builtins.cell.__gt__" => "Return self>value.",
+    "builtins.cell.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.cell.__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.cell.__le__" => "Return self<=value.",
+    "builtins.cell.__lt__" => "Return self<value.",
+    "builtins.cell.__ne__" => "Return self!=value.",
+    "builtins.cell.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.cell.__reduce__" => "Helper for pickle.",
+    "builtins.cell.__reduce_ex__" => "Helper for pickle.",
+    "builtins.cell.__repr__" => "Return repr(self).",
+    "builtins.cell.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.cell.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.cell.__str__" => "Return str(self).",
+    "builtins.cell.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.chr" => "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.",
+    "builtins.classmethod" => "Convert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n  class C:\n      @classmethod\n      def f(cls, arg1, arg2, argN):\n          ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()).  The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.",
+    "builtins.classmethod.__delattr__" => "Implement delattr(self, name).",
+    "builtins.classmethod.__eq__" => "Return self==value.",
+    "builtins.classmethod.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.classmethod.__ge__" => "Return self>=value.",
+    "builtins.classmethod.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.classmethod.__getattribute__" => "Return getattr(self, name).",
+    "builtins.classmethod.__getstate__" => "Helper for pickle.",
+    "builtins.classmethod.__gt__" => "Return self>value.",
+    "builtins.classmethod.__hash__" => "Return hash(self).",
+    "builtins.classmethod.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.classmethod.__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.classmethod.__le__" => "Return self<=value.",
+    "builtins.classmethod.__lt__" => "Return self<value.",
+    "builtins.classmethod.__ne__" => "Return self!=value.",
+    "builtins.classmethod.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.classmethod.__reduce__" => "Helper for pickle.",
+    "builtins.classmethod.__reduce_ex__" => "Helper for pickle.",
+    "builtins.classmethod.__repr__" => "Return repr(self).",
+    "builtins.classmethod.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.classmethod.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.classmethod.__str__" => "Return str(self).",
+    "builtins.classmethod.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.classmethod_descriptor.__call__" => "Call self as a function.",
+    "builtins.classmethod_descriptor.__delattr__" => "Implement delattr(self, name).",
+    "builtins.classmethod_descriptor.__eq__" => "Return self==value.",
+    "builtins.classmethod_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.classmethod_descriptor.__ge__" => "Return self>=value.",
+    "builtins.classmethod_descriptor.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.classmethod_descriptor.__getattribute__" => "Return getattr(self, name).",
+    "builtins.classmethod_descriptor.__getstate__" => "Helper for pickle.",
+    "builtins.classmethod_descriptor.__gt__" => "Return self>value.",
+    "builtins.classmethod_descriptor.__hash__" => "Return hash(self).",
+    "builtins.classmethod_descriptor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.classmethod_descriptor.__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.classmethod_descriptor.__le__" => "Return self<=value.",
+    "builtins.classmethod_descriptor.__lt__" => "Return self<value.",
+    "builtins.classmethod_descriptor.__ne__" => "Return self!=value.",
+    "builtins.classmethod_descriptor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.classmethod_descriptor.__reduce__" => "Helper for pickle.",
+    "builtins.classmethod_descriptor.__reduce_ex__" => "Helper for pickle.",
+    "builtins.classmethod_descriptor.__repr__" => "Return repr(self).",
+    "builtins.classmethod_descriptor.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.classmethod_descriptor.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.classmethod_descriptor.__str__" => "Return str(self).",
+    "builtins.classmethod_descriptor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.code" => "Create a code object.  Not for the faint of heart.",
+    "builtins.code.__delattr__" => "Implement delattr(self, name).",
+    "builtins.code.__eq__" => "Return self==value.",
+    "builtins.code.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.code.__ge__" => "Return self>=value.",
+    "builtins.code.__getattribute__" => "Return getattr(self, name).",
+    "builtins.code.__getstate__" => "Helper for pickle.",
+    "builtins.code.__gt__" => "Return self>value.",
+    "builtins.code.__hash__" => "Return hash(self).",
+    "builtins.code.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.code.__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.code.__le__" => "Return self<=value.",
+    "builtins.code.__lt__" => "Return self<value.",
+    "builtins.code.__ne__" => "Return self!=value.",
+    "builtins.code.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.code.__reduce__" => "Helper for pickle.",
+    "builtins.code.__reduce_ex__" => "Helper for pickle.",
+    "builtins.code.__replace__" => "The same as replace().",
+    "builtins.code.__repr__" => "Return repr(self).",
+    "builtins.code.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.code.__str__" => "Return str(self).",
+    "builtins.code.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.code._varname_from_oparg" => "(internal-only) Return the local variable name for the given oparg.\n\nWARNING: this method is for internal use only and may change or go away.",
+    "builtins.code.replace" => "Return a copy of the code object with new values for the specified fields.",
+    "builtins.compile" => "Compile source into a code object that can be executed by exec() or eval().\n\nThe source code may represent a Python module, statement or expression.\nThe filename will be used for run-time error messages.\nThe mode must be 'exec' to compile a module, 'single' to compile a\nsingle (interactive) statement, or 'eval' to compile an expression.\nThe flags argument, if present, controls which future statements influence\nthe compilation of the code.\nThe dont_inherit argument, if true, stops the compilation inheriting\nthe effects of any future statements in effect in the code calling\ncompile; if absent or false these statements do influence the compilation,\nin addition to any features explicitly specified.",
+    "builtins.complex" => "Create a complex number from a string or numbers.\n\nIf a string is given, parse it as a complex number.\nIf a single number is given, convert it to a complex number.\nIf the 'real' or 'imag' arguments are given, create a complex number\nwith the specified real and imaginary components.",
+    "builtins.complex.__abs__" => "abs(self)",
+    "builtins.complex.__add__" => "Return self+value.",
+    "builtins.complex.__bool__" => "True if self else False",
+    "builtins.complex.__complex__" => "Convert this value to exact type complex.",
+    "builtins.complex.__delattr__" => "Implement delattr(self, name).",
+    "builtins.complex.__eq__" => "Return self==value.",
+    "builtins.complex.__format__" => "Convert to a string according to format_spec.",
+    "builtins.complex.__ge__" => "Return self>=value.",
+    "builtins.complex.__getattribute__" => "Return getattr(self, name).",
+    "builtins.complex.__getstate__" => "Helper for pickle.",
+    "builtins.complex.__gt__" => "Return self>value.",
+    "builtins.complex.__hash__" => "Return hash(self).",
+    "builtins.complex.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.complex.__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.complex.__le__" => "Return self<=value.",
+    "builtins.complex.__lt__" => "Return self<value.",
+    "builtins.complex.__mul__" => "Return self*value.",
+    "builtins.complex.__ne__" => "Return self!=value.",
+    "builtins.complex.__neg__" => "-self",
+    "builtins.complex.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.complex.__pos__" => "+self",
+    "builtins.complex.__pow__" => "Return pow(self, value, mod).",
+    "builtins.complex.__radd__" => "Return value+self.",
+    "builtins.complex.__reduce__" => "Helper for pickle.",
+    "builtins.complex.__reduce_ex__" => "Helper for pickle.",
+    "builtins.complex.__repr__" => "Return repr(self).",
+    "builtins.complex.__rmul__" => "Return value*self.",
+    "builtins.complex.__rpow__" => "Return pow(value, self, mod).",
+    "builtins.complex.__rsub__" => "Return value-self.",
+    "builtins.complex.__rtruediv__" => "Return value/self.",
+    "builtins.complex.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.complex.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.complex.__str__" => "Return str(self).",
+    "builtins.complex.__sub__" => "Return self-value.",
+    "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.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.",
+    "builtins.coroutine.__class_getitem__" => "See PEP 585",
+    "builtins.coroutine.__del__" => "Called when the instance is about to be destroyed.",
+    "builtins.coroutine.__delattr__" => "Implement delattr(self, name).",
+    "builtins.coroutine.__eq__" => "Return self==value.",
+    "builtins.coroutine.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.coroutine.__ge__" => "Return self>=value.",
+    "builtins.coroutine.__getattribute__" => "Return getattr(self, name).",
+    "builtins.coroutine.__getstate__" => "Helper for pickle.",
+    "builtins.coroutine.__gt__" => "Return self>value.",
+    "builtins.coroutine.__hash__" => "Return hash(self).",
+    "builtins.coroutine.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.coroutine.__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.coroutine.__le__" => "Return self<=value.",
+    "builtins.coroutine.__lt__" => "Return self<value.",
+    "builtins.coroutine.__ne__" => "Return self!=value.",
+    "builtins.coroutine.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.coroutine.__reduce__" => "Helper for pickle.",
+    "builtins.coroutine.__reduce_ex__" => "Helper for pickle.",
+    "builtins.coroutine.__repr__" => "Return repr(self).",
+    "builtins.coroutine.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.coroutine.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes",
+    "builtins.coroutine.__str__" => "Return str(self).",
+    "builtins.coroutine.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.coroutine.close" => "close() -> raise GeneratorExit inside coroutine.",
+    "builtins.coroutine.cr_await" => "object being awaited on, or None",
+    "builtins.coroutine.send" => "send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.",
+    "builtins.coroutine.throw" => "throw(value)\nthrow(type[,value[,traceback]])\n\nRaise exception in coroutine, return next iterated value or raise\nStopIteration.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.",
+    "builtins.delattr" => "Deletes the named attribute from the given object.\n\ndelattr(x, 'y') is equivalent to ``del x.y``",
+    "builtins.dict" => "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)",
+    "builtins.dict.__class_getitem__" => "See PEP 585",
+    "builtins.dict.__contains__" => "True if the dictionary has the specified key, else False.",
+    "builtins.dict.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict.__delitem__" => "Delete self[key].",
+    "builtins.dict.__eq__" => "Return self==value.",
+    "builtins.dict.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict.__ge__" => "Return self>=value.",
+    "builtins.dict.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict.__getitem__" => "Return self[key].",
+    "builtins.dict.__getstate__" => "Helper for pickle.",
+    "builtins.dict.__gt__" => "Return self>value.",
+    "builtins.dict.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.dict.__ior__" => "Return self|=value.",
+    "builtins.dict.__iter__" => "Implement iter(self).",
+    "builtins.dict.__le__" => "Return self<=value.",
+    "builtins.dict.__len__" => "Return len(self).",
+    "builtins.dict.__lt__" => "Return self<value.",
+    "builtins.dict.__ne__" => "Return self!=value.",
+    "builtins.dict.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict.__or__" => "Return self|value.",
+    "builtins.dict.__reduce__" => "Helper for pickle.",
+    "builtins.dict.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict.__repr__" => "Return repr(self).",
+    "builtins.dict.__reversed__" => "Return a reverse iterator over the dict keys.",
+    "builtins.dict.__ror__" => "Return value|self.",
+    "builtins.dict.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict.__setitem__" => "Set self[key] to value.",
+    "builtins.dict.__sizeof__" => "Return the size of the dict in memory, in bytes.",
+    "builtins.dict.__str__" => "Return str(self).",
+    "builtins.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).",
+    "builtins.dict.clear" => "Remove all items from the dict.",
+    "builtins.dict.copy" => "Return a shallow copy of the dict.",
+    "builtins.dict.fromkeys" => "Create a new dictionary with keys from iterable and values set to value.",
+    "builtins.dict.get" => "Return the value for key if key is in the dictionary, else default.",
+    "builtins.dict.items" => "Return a set-like object providing a view on the dict's items.",
+    "builtins.dict.keys" => "Return a set-like object providing a view on the dict's keys.",
+    "builtins.dict.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.",
+    "builtins.dict.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.",
+    "builtins.dict.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.",
+    "builtins.dict.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]",
+    "builtins.dict.values" => "Return an object providing a view on the dict's values.",
+    "builtins.dict_itemiterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict_itemiterator.__eq__" => "Return self==value.",
+    "builtins.dict_itemiterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict_itemiterator.__ge__" => "Return self>=value.",
+    "builtins.dict_itemiterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict_itemiterator.__getstate__" => "Helper for pickle.",
+    "builtins.dict_itemiterator.__gt__" => "Return self>value.",
+    "builtins.dict_itemiterator.__hash__" => "Return hash(self).",
+    "builtins.dict_itemiterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.dict_itemiterator.__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.dict_itemiterator.__iter__" => "Implement iter(self).",
+    "builtins.dict_itemiterator.__le__" => "Return self<=value.",
+    "builtins.dict_itemiterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.dict_itemiterator.__lt__" => "Return self<value.",
+    "builtins.dict_itemiterator.__ne__" => "Return self!=value.",
+    "builtins.dict_itemiterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict_itemiterator.__next__" => "Implement next(self).",
+    "builtins.dict_itemiterator.__reduce__" => "Return state information for pickling.",
+    "builtins.dict_itemiterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict_itemiterator.__repr__" => "Return repr(self).",
+    "builtins.dict_itemiterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict_itemiterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.dict_itemiterator.__str__" => "Return str(self).",
+    "builtins.dict_itemiterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.dict_items.__and__" => "Return self&value.",
+    "builtins.dict_items.__contains__" => "Return bool(key in self).",
+    "builtins.dict_items.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict_items.__eq__" => "Return self==value.",
+    "builtins.dict_items.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict_items.__ge__" => "Return self>=value.",
+    "builtins.dict_items.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict_items.__getstate__" => "Helper for pickle.",
+    "builtins.dict_items.__gt__" => "Return self>value.",
+    "builtins.dict_items.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.dict_items.__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.dict_items.__iter__" => "Implement iter(self).",
+    "builtins.dict_items.__le__" => "Return self<=value.",
+    "builtins.dict_items.__len__" => "Return len(self).",
+    "builtins.dict_items.__lt__" => "Return self<value.",
+    "builtins.dict_items.__ne__" => "Return self!=value.",
+    "builtins.dict_items.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict_items.__or__" => "Return self|value.",
+    "builtins.dict_items.__rand__" => "Return value&self.",
+    "builtins.dict_items.__reduce__" => "Helper for pickle.",
+    "builtins.dict_items.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict_items.__repr__" => "Return repr(self).",
+    "builtins.dict_items.__reversed__" => "Return a reverse iterator over the dict items.",
+    "builtins.dict_items.__ror__" => "Return value|self.",
+    "builtins.dict_items.__rsub__" => "Return value-self.",
+    "builtins.dict_items.__rxor__" => "Return value^self.",
+    "builtins.dict_items.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict_items.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.dict_items.__str__" => "Return str(self).",
+    "builtins.dict_items.__sub__" => "Return self-value.",
+    "builtins.dict_items.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.dict_items.__xor__" => "Return self^value.",
+    "builtins.dict_items.isdisjoint" => "Return True if the view and the given iterable have a null intersection.",
+    "builtins.dict_items.mapping" => "dictionary that this view refers to",
+    "builtins.dict_keyiterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict_keyiterator.__eq__" => "Return self==value.",
+    "builtins.dict_keyiterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict_keyiterator.__ge__" => "Return self>=value.",
+    "builtins.dict_keyiterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict_keyiterator.__getstate__" => "Helper for pickle.",
+    "builtins.dict_keyiterator.__gt__" => "Return self>value.",
+    "builtins.dict_keyiterator.__hash__" => "Return hash(self).",
+    "builtins.dict_keyiterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.dict_keyiterator.__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.dict_keyiterator.__iter__" => "Implement iter(self).",
+    "builtins.dict_keyiterator.__le__" => "Return self<=value.",
+    "builtins.dict_keyiterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.dict_keyiterator.__lt__" => "Return self<value.",
+    "builtins.dict_keyiterator.__ne__" => "Return self!=value.",
+    "builtins.dict_keyiterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict_keyiterator.__next__" => "Implement next(self).",
+    "builtins.dict_keyiterator.__reduce__" => "Return state information for pickling.",
+    "builtins.dict_keyiterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict_keyiterator.__repr__" => "Return repr(self).",
+    "builtins.dict_keyiterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict_keyiterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.dict_keyiterator.__str__" => "Return str(self).",
+    "builtins.dict_keyiterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.dict_valueiterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict_valueiterator.__eq__" => "Return self==value.",
+    "builtins.dict_valueiterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict_valueiterator.__ge__" => "Return self>=value.",
+    "builtins.dict_valueiterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict_valueiterator.__getstate__" => "Helper for pickle.",
+    "builtins.dict_valueiterator.__gt__" => "Return self>value.",
+    "builtins.dict_valueiterator.__hash__" => "Return hash(self).",
+    "builtins.dict_valueiterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.dict_valueiterator.__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.dict_valueiterator.__iter__" => "Implement iter(self).",
+    "builtins.dict_valueiterator.__le__" => "Return self<=value.",
+    "builtins.dict_valueiterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.dict_valueiterator.__lt__" => "Return self<value.",
+    "builtins.dict_valueiterator.__ne__" => "Return self!=value.",
+    "builtins.dict_valueiterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict_valueiterator.__next__" => "Implement next(self).",
+    "builtins.dict_valueiterator.__reduce__" => "Return state information for pickling.",
+    "builtins.dict_valueiterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict_valueiterator.__repr__" => "Return repr(self).",
+    "builtins.dict_valueiterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict_valueiterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.dict_valueiterator.__str__" => "Return str(self).",
+    "builtins.dict_valueiterator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.dict_values.__delattr__" => "Implement delattr(self, name).",
+    "builtins.dict_values.__eq__" => "Return self==value.",
+    "builtins.dict_values.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.dict_values.__ge__" => "Return self>=value.",
+    "builtins.dict_values.__getattribute__" => "Return getattr(self, name).",
+    "builtins.dict_values.__getstate__" => "Helper for pickle.",
+    "builtins.dict_values.__gt__" => "Return self>value.",
+    "builtins.dict_values.__hash__" => "Return hash(self).",
+    "builtins.dict_values.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.dict_values.__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.dict_values.__iter__" => "Implement iter(self).",
+    "builtins.dict_values.__le__" => "Return self<=value.",
+    "builtins.dict_values.__len__" => "Return len(self).",
+    "builtins.dict_values.__lt__" => "Return self<value.",
+    "builtins.dict_values.__ne__" => "Return self!=value.",
+    "builtins.dict_values.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.dict_values.__reduce__" => "Helper for pickle.",
+    "builtins.dict_values.__reduce_ex__" => "Helper for pickle.",
+    "builtins.dict_values.__repr__" => "Return repr(self).",
+    "builtins.dict_values.__reversed__" => "Return a reverse iterator over the dict values.",
+    "builtins.dict_values.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.dict_values.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.dict_values.__str__" => "Return str(self).",
+    "builtins.dict_values.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.dict_values.mapping" => "dictionary that this view refers to",
+    "builtins.dir" => "dir([object]) -> list of strings\n\nIf called without an argument, return the names in the current scope.\nElse, return an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it.\nIf the object supplies a method named __dir__, it will be used; otherwise\nthe default dir() logic is used and returns:\n  for a module object: the module's attributes.\n  for a class object:  its attributes, and recursively the attributes\n    of its bases.\n  for any other object: its attributes, its class's attributes, and\n    recursively the attributes of its class's base classes.",
+    "builtins.divmod" => "Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.",
+    "builtins.ellipsis" => "The type of the Ellipsis singleton.",
+    "builtins.ellipsis.__delattr__" => "Implement delattr(self, name).",
+    "builtins.ellipsis.__eq__" => "Return self==value.",
+    "builtins.ellipsis.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.ellipsis.__ge__" => "Return self>=value.",
+    "builtins.ellipsis.__getattribute__" => "Return getattr(self, name).",
+    "builtins.ellipsis.__getstate__" => "Helper for pickle.",
+    "builtins.ellipsis.__gt__" => "Return self>value.",
+    "builtins.ellipsis.__hash__" => "Return hash(self).",
+    "builtins.ellipsis.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.ellipsis.__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.ellipsis.__le__" => "Return self<=value.",
+    "builtins.ellipsis.__lt__" => "Return self<value.",
+    "builtins.ellipsis.__ne__" => "Return self!=value.",
+    "builtins.ellipsis.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.ellipsis.__reduce_ex__" => "Helper for pickle.",
+    "builtins.ellipsis.__repr__" => "Return repr(self).",
+    "builtins.ellipsis.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.ellipsis.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.ellipsis.__str__" => "Return str(self).",
+    "builtins.ellipsis.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.enumerate" => "Return an enumerate object.\n\n  iterable\n    an object supporting iteration\n\nThe enumerate object yields pairs containing a count (from start, which\ndefaults to zero) and a value yielded by the iterable argument.\n\nenumerate is useful for obtaining an indexed list:\n    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...",
+    "builtins.enumerate.__class_getitem__" => "See PEP 585",
+    "builtins.enumerate.__delattr__" => "Implement delattr(self, name).",
+    "builtins.enumerate.__eq__" => "Return self==value.",
+    "builtins.enumerate.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.enumerate.__ge__" => "Return self>=value.",
+    "builtins.enumerate.__getattribute__" => "Return getattr(self, name).",
+    "builtins.enumerate.__getstate__" => "Helper for pickle.",
+    "builtins.enumerate.__gt__" => "Return self>value.",
+    "builtins.enumerate.__hash__" => "Return hash(self).",
+    "builtins.enumerate.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.enumerate.__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.enumerate.__iter__" => "Implement iter(self).",
+    "builtins.enumerate.__le__" => "Return self<=value.",
+    "builtins.enumerate.__lt__" => "Return self<value.",
+    "builtins.enumerate.__ne__" => "Return self!=value.",
+    "builtins.enumerate.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.enumerate.__next__" => "Implement next(self).",
+    "builtins.enumerate.__reduce__" => "Return state information for pickling.",
+    "builtins.enumerate.__reduce_ex__" => "Helper for pickle.",
+    "builtins.enumerate.__repr__" => "Return repr(self).",
+    "builtins.enumerate.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.enumerate.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.enumerate.__str__" => "Return str(self).",
+    "builtins.enumerate.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.eval" => "Evaluate the given source in the context of globals and locals.\n\nThe source may be a string representing a Python expression\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.",
+    "builtins.exec" => "Execute the given source in the context of globals and locals.\n\nThe source may be a string representing one or more Python statements\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.\nThe closure must be a tuple of cellvars, and can only be used\nwhen source is a code object requiring exactly that many cellvars.",
+    "builtins.filter" => "Return an iterator yielding those items of iterable for which function(item)\nis true. If function is None, return the items that are true.",
+    "builtins.filter.__delattr__" => "Implement delattr(self, name).",
+    "builtins.filter.__eq__" => "Return self==value.",
+    "builtins.filter.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.filter.__ge__" => "Return self>=value.",
+    "builtins.filter.__getattribute__" => "Return getattr(self, name).",
+    "builtins.filter.__getstate__" => "Helper for pickle.",
+    "builtins.filter.__gt__" => "Return self>value.",
+    "builtins.filter.__hash__" => "Return hash(self).",
+    "builtins.filter.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.filter.__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.filter.__iter__" => "Implement iter(self).",
+    "builtins.filter.__le__" => "Return self<=value.",
+    "builtins.filter.__lt__" => "Return self<value.",
+    "builtins.filter.__ne__" => "Return self!=value.",
+    "builtins.filter.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.filter.__next__" => "Implement next(self).",
+    "builtins.filter.__reduce__" => "Return state information for pickling.",
+    "builtins.filter.__reduce_ex__" => "Helper for pickle.",
+    "builtins.filter.__repr__" => "Return repr(self).",
+    "builtins.filter.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.filter.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.filter.__str__" => "Return str(self).",
+    "builtins.filter.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.float" => "Convert a string or number to a floating-point number, if possible.",
+    "builtins.float.__abs__" => "abs(self)",
+    "builtins.float.__add__" => "Return self+value.",
+    "builtins.float.__bool__" => "True if self else False",
+    "builtins.float.__ceil__" => "Return the ceiling as an Integral.",
+    "builtins.float.__delattr__" => "Implement delattr(self, name).",
+    "builtins.float.__divmod__" => "Return divmod(self, value).",
+    "builtins.float.__eq__" => "Return self==value.",
+    "builtins.float.__float__" => "float(self)",
+    "builtins.float.__floor__" => "Return the floor as an Integral.",
+    "builtins.float.__floordiv__" => "Return self//value.",
+    "builtins.float.__format__" => "Formats the float according to format_spec.",
+    "builtins.float.__ge__" => "Return self>=value.",
+    "builtins.float.__getattribute__" => "Return getattr(self, name).",
+    "builtins.float.__getformat__" => "You probably don't want to use this function.\n\n  typestr\n    Must be 'double' or 'float'.\n\nIt exists mainly to be used in Python's test suite.\n\nThis function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\nlittle-endian' best describes the format of floating-point numbers used by the\nC type named by typestr.",
+    "builtins.float.__getstate__" => "Helper for pickle.",
+    "builtins.float.__gt__" => "Return self>value.",
+    "builtins.float.__hash__" => "Return hash(self).",
+    "builtins.float.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.float.__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.float.__int__" => "int(self)",
+    "builtins.float.__le__" => "Return self<=value.",
+    "builtins.float.__lt__" => "Return self<value.",
+    "builtins.float.__mod__" => "Return self%value.",
+    "builtins.float.__mul__" => "Return self*value.",
+    "builtins.float.__ne__" => "Return self!=value.",
+    "builtins.float.__neg__" => "-self",
+    "builtins.float.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.float.__pos__" => "+self",
+    "builtins.float.__pow__" => "Return pow(self, value, mod).",
+    "builtins.float.__radd__" => "Return value+self.",
+    "builtins.float.__rdivmod__" => "Return divmod(value, self).",
+    "builtins.float.__reduce__" => "Helper for pickle.",
+    "builtins.float.__reduce_ex__" => "Helper for pickle.",
+    "builtins.float.__repr__" => "Return repr(self).",
+    "builtins.float.__rfloordiv__" => "Return value//self.",
+    "builtins.float.__rmod__" => "Return value%self.",
+    "builtins.float.__rmul__" => "Return value*self.",
+    "builtins.float.__round__" => "Return the Integral closest to x, rounding half toward even.\n\nWhen an argument is passed, work like built-in round(x, ndigits).",
+    "builtins.float.__rpow__" => "Return pow(value, self, mod).",
+    "builtins.float.__rsub__" => "Return value-self.",
+    "builtins.float.__rtruediv__" => "Return value/self.",
+    "builtins.float.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.float.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.float.__str__" => "Return str(self).",
+    "builtins.float.__sub__" => "Return self-value.",
+    "builtins.float.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.float.__truediv__" => "Return self/value.",
+    "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.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",
+    "builtins.float.is_integer" => "Return True if the float is an integer.",
+    "builtins.float.real" => "the real part of a complex number",
+    "builtins.format" => "Return type(value).__format__(value, format_spec)\n\nMany built-in types implement format_spec according to the\nFormat Specification Mini-language. See help('FORMATTING').\n\nIf type(value) does not supply a method named __format__\nand format_spec is empty, then str(value) is returned.\nSee also help('SPECIALMETHODS').",
+    "builtins.frame.__delattr__" => "Implement delattr(self, name).",
+    "builtins.frame.__eq__" => "Return self==value.",
+    "builtins.frame.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.frame.__ge__" => "Return self>=value.",
+    "builtins.frame.__getattribute__" => "Return getattr(self, name).",
+    "builtins.frame.__getstate__" => "Helper for pickle.",
+    "builtins.frame.__gt__" => "Return self>value.",
+    "builtins.frame.__hash__" => "Return hash(self).",
+    "builtins.frame.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.frame.__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.frame.__le__" => "Return self<=value.",
+    "builtins.frame.__lt__" => "Return self<value.",
+    "builtins.frame.__ne__" => "Return self!=value.",
+    "builtins.frame.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.frame.__reduce__" => "Helper for pickle.",
+    "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.__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.frozenset" => "Build an immutable unordered collection of unique elements.",
+    "builtins.frozenset.__and__" => "Return self&value.",
+    "builtins.frozenset.__class_getitem__" => "See PEP 585",
+    "builtins.frozenset.__contains__" => "x.__contains__(y) <==> y in x.",
+    "builtins.frozenset.__delattr__" => "Implement delattr(self, name).",
+    "builtins.frozenset.__eq__" => "Return self==value.",
+    "builtins.frozenset.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.frozenset.__ge__" => "Return self>=value.",
+    "builtins.frozenset.__getattribute__" => "Return getattr(self, name).",
+    "builtins.frozenset.__getstate__" => "Helper for pickle.",
+    "builtins.frozenset.__gt__" => "Return self>value.",
+    "builtins.frozenset.__hash__" => "Return hash(self).",
+    "builtins.frozenset.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.frozenset.__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.frozenset.__iter__" => "Implement iter(self).",
+    "builtins.frozenset.__le__" => "Return self<=value.",
+    "builtins.frozenset.__len__" => "Return len(self).",
+    "builtins.frozenset.__lt__" => "Return self<value.",
+    "builtins.frozenset.__ne__" => "Return self!=value.",
+    "builtins.frozenset.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.frozenset.__or__" => "Return self|value.",
+    "builtins.frozenset.__rand__" => "Return value&self.",
+    "builtins.frozenset.__reduce__" => "Return state information for pickling.",
+    "builtins.frozenset.__reduce_ex__" => "Helper for pickle.",
+    "builtins.frozenset.__repr__" => "Return repr(self).",
+    "builtins.frozenset.__ror__" => "Return value|self.",
+    "builtins.frozenset.__rsub__" => "Return value-self.",
+    "builtins.frozenset.__rxor__" => "Return value^self.",
+    "builtins.frozenset.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.frozenset.__sizeof__" => "S.__sizeof__() -> size of S in memory, in bytes.",
+    "builtins.frozenset.__str__" => "Return str(self).",
+    "builtins.frozenset.__sub__" => "Return self-value.",
+    "builtins.frozenset.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.frozenset.__xor__" => "Return self^value.",
+    "builtins.frozenset.copy" => "Return a shallow copy of a set.",
+    "builtins.frozenset.difference" => "Return a new set with elements in the set that are not in the others.",
+    "builtins.frozenset.intersection" => "Return a new set with elements common to the set and all others.",
+    "builtins.frozenset.isdisjoint" => "Return True if two sets have a null intersection.",
+    "builtins.frozenset.issubset" => "Report whether another set contains this set.",
+    "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.__call__" => "Call self as a function.",
+    "builtins.function.__delattr__" => "Implement delattr(self, name).",
+    "builtins.function.__eq__" => "Return self==value.",
+    "builtins.function.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.function.__ge__" => "Return self>=value.",
+    "builtins.function.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.function.__getattribute__" => "Return getattr(self, name).",
+    "builtins.function.__getstate__" => "Helper for pickle.",
+    "builtins.function.__gt__" => "Return self>value.",
+    "builtins.function.__hash__" => "Return hash(self).",
+    "builtins.function.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.function.__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.function.__le__" => "Return self<=value.",
+    "builtins.function.__lt__" => "Return self<value.",
+    "builtins.function.__ne__" => "Return self!=value.",
+    "builtins.function.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.function.__reduce__" => "Helper for pickle.",
+    "builtins.function.__reduce_ex__" => "Helper for pickle.",
+    "builtins.function.__repr__" => "Return repr(self).",
+    "builtins.function.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.function.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.function.__str__" => "Return str(self).",
+    "builtins.function.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.function.__type_params__" => "Get the declared type parameters for a function.",
+    "builtins.generator.__class_getitem__" => "See PEP 585",
+    "builtins.generator.__del__" => "Called when the instance is about to be destroyed.",
+    "builtins.generator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.generator.__eq__" => "Return self==value.",
+    "builtins.generator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.generator.__ge__" => "Return self>=value.",
+    "builtins.generator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.generator.__getstate__" => "Helper for pickle.",
+    "builtins.generator.__gt__" => "Return self>value.",
+    "builtins.generator.__hash__" => "Return hash(self).",
+    "builtins.generator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.generator.__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.generator.__iter__" => "Implement iter(self).",
+    "builtins.generator.__le__" => "Return self<=value.",
+    "builtins.generator.__lt__" => "Return self<value.",
+    "builtins.generator.__ne__" => "Return self!=value.",
+    "builtins.generator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.generator.__next__" => "Implement next(self).",
+    "builtins.generator.__reduce__" => "Helper for pickle.",
+    "builtins.generator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.generator.__repr__" => "Return repr(self).",
+    "builtins.generator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.generator.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes",
+    "builtins.generator.__str__" => "Return str(self).",
+    "builtins.generator.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.generator.close" => "close() -> raise GeneratorExit inside generator.",
+    "builtins.generator.gi_yieldfrom" => "object being iterated by yield from, or None",
+    "builtins.generator.send" => "send(value) -> send 'value' into generator,\nreturn next yielded value or raise StopIteration.",
+    "builtins.generator.throw" => "throw(value)\nthrow(type[,value[,tb]])\n\nRaise exception in generator, return next yielded value or raise\nStopIteration.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.",
+    "builtins.getattr" => "getattr(object, name[, default]) -> value\n\nGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\nWhen a default argument is given, it is returned when the attribute doesn't\nexist; without it, an exception is raised in that case.",
+    "builtins.getset_descriptor.__delattr__" => "Implement delattr(self, name).",
+    "builtins.getset_descriptor.__delete__" => "Delete an attribute of instance.",
+    "builtins.getset_descriptor.__eq__" => "Return self==value.",
+    "builtins.getset_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.getset_descriptor.__ge__" => "Return self>=value.",
+    "builtins.getset_descriptor.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.getset_descriptor.__getattribute__" => "Return getattr(self, name).",
+    "builtins.getset_descriptor.__getstate__" => "Helper for pickle.",
+    "builtins.getset_descriptor.__gt__" => "Return self>value.",
+    "builtins.getset_descriptor.__hash__" => "Return hash(self).",
+    "builtins.getset_descriptor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.getset_descriptor.__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.getset_descriptor.__le__" => "Return self<=value.",
+    "builtins.getset_descriptor.__lt__" => "Return self<value.",
+    "builtins.getset_descriptor.__ne__" => "Return self!=value.",
+    "builtins.getset_descriptor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.getset_descriptor.__reduce__" => "Helper for pickle.",
+    "builtins.getset_descriptor.__reduce_ex__" => "Helper for pickle.",
+    "builtins.getset_descriptor.__repr__" => "Return repr(self).",
+    "builtins.getset_descriptor.__set__" => "Set an attribute of instance to value.",
+    "builtins.getset_descriptor.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.getset_descriptor.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.getset_descriptor.__str__" => "Return str(self).",
+    "builtins.getset_descriptor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.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.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",
+    "builtins.int.__abs__" => "abs(self)",
+    "builtins.int.__add__" => "Return self+value.",
+    "builtins.int.__and__" => "Return self&value.",
+    "builtins.int.__bool__" => "True if self else False",
+    "builtins.int.__ceil__" => "Ceiling of an Integral returns itself.",
+    "builtins.int.__delattr__" => "Implement delattr(self, name).",
+    "builtins.int.__divmod__" => "Return divmod(self, value).",
+    "builtins.int.__eq__" => "Return self==value.",
+    "builtins.int.__float__" => "float(self)",
+    "builtins.int.__floor__" => "Flooring an Integral returns itself.",
+    "builtins.int.__floordiv__" => "Return self//value.",
+    "builtins.int.__format__" => "Convert to a string according to format_spec.",
+    "builtins.int.__ge__" => "Return self>=value.",
+    "builtins.int.__getattribute__" => "Return getattr(self, name).",
+    "builtins.int.__getstate__" => "Helper for pickle.",
+    "builtins.int.__gt__" => "Return self>value.",
+    "builtins.int.__hash__" => "Return hash(self).",
+    "builtins.int.__index__" => "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    "builtins.int.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.int.__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.int.__int__" => "int(self)",
+    "builtins.int.__invert__" => "~self",
+    "builtins.int.__le__" => "Return self<=value.",
+    "builtins.int.__lshift__" => "Return self<<value.",
+    "builtins.int.__lt__" => "Return self<value.",
+    "builtins.int.__mod__" => "Return self%value.",
+    "builtins.int.__mul__" => "Return self*value.",
+    "builtins.int.__ne__" => "Return self!=value.",
+    "builtins.int.__neg__" => "-self",
+    "builtins.int.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.int.__or__" => "Return self|value.",
+    "builtins.int.__pos__" => "+self",
+    "builtins.int.__pow__" => "Return pow(self, value, mod).",
+    "builtins.int.__radd__" => "Return value+self.",
+    "builtins.int.__rand__" => "Return value&self.",
+    "builtins.int.__rdivmod__" => "Return divmod(value, self).",
+    "builtins.int.__reduce__" => "Helper for pickle.",
+    "builtins.int.__reduce_ex__" => "Helper for pickle.",
+    "builtins.int.__repr__" => "Return repr(self).",
+    "builtins.int.__rfloordiv__" => "Return value//self.",
+    "builtins.int.__rlshift__" => "Return value<<self.",
+    "builtins.int.__rmod__" => "Return value%self.",
+    "builtins.int.__rmul__" => "Return value*self.",
+    "builtins.int.__ror__" => "Return value|self.",
+    "builtins.int.__round__" => "Rounding an Integral returns itself.\n\nRounding with an ndigits argument also returns an integer.",
+    "builtins.int.__rpow__" => "Return pow(value, self, mod).",
+    "builtins.int.__rrshift__" => "Return value>>self.",
+    "builtins.int.__rshift__" => "Return self>>value.",
+    "builtins.int.__rsub__" => "Return value-self.",
+    "builtins.int.__rtruediv__" => "Return value/self.",
+    "builtins.int.__rxor__" => "Return value^self.",
+    "builtins.int.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.int.__sizeof__" => "Returns size in memory, in bytes.",
+    "builtins.int.__str__" => "Return str(self).",
+    "builtins.int.__sub__" => "Return self-value.",
+    "builtins.int.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.int.__truediv__" => "Return self/value.",
+    "builtins.int.__trunc__" => "Truncating an Integral returns itself.",
+    "builtins.int.__xor__" => "Return self^value.",
+    "builtins.int.as_integer_ratio" => "Return a pair of integers, whose ratio is equal to the original int.\n\nThe ratio is in lowest terms and has a positive denominator.\n\n>>> (10).as_integer_ratio()\n(10, 1)\n>>> (-10).as_integer_ratio()\n(-10, 1)\n>>> (0).as_integer_ratio()\n(0, 1)",
+    "builtins.int.bit_count" => "Number of ones in the binary representation of the absolute value of self.\n\nAlso known as the population count.\n\n>>> bin(13)\n'0b1101'\n>>> (13).bit_count()\n3",
+    "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.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.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.",
+    "builtins.len" => "Return the number of items in a container.",
+    "builtins.list" => "Built-in mutable sequence.\n\nIf no argument is given, the constructor creates a new empty list.\nThe argument must be an iterable if specified.",
+    "builtins.list.__add__" => "Return self+value.",
+    "builtins.list.__class_getitem__" => "See PEP 585",
+    "builtins.list.__contains__" => "Return bool(key in self).",
+    "builtins.list.__delattr__" => "Implement delattr(self, name).",
+    "builtins.list.__delitem__" => "Delete self[key].",
+    "builtins.list.__eq__" => "Return self==value.",
+    "builtins.list.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.list.__ge__" => "Return self>=value.",
+    "builtins.list.__getattribute__" => "Return getattr(self, name).",
+    "builtins.list.__getitem__" => "Return self[index].",
+    "builtins.list.__getstate__" => "Helper for pickle.",
+    "builtins.list.__gt__" => "Return self>value.",
+    "builtins.list.__iadd__" => "Implement self+=value.",
+    "builtins.list.__imul__" => "Implement self*=value.",
+    "builtins.list.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.list.__iter__" => "Implement iter(self).",
+    "builtins.list.__le__" => "Return self<=value.",
+    "builtins.list.__len__" => "Return len(self).",
+    "builtins.list.__lt__" => "Return self<value.",
+    "builtins.list.__mul__" => "Return self*value.",
+    "builtins.list.__ne__" => "Return self!=value.",
+    "builtins.list.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.list.__reduce__" => "Helper for pickle.",
+    "builtins.list.__reduce_ex__" => "Helper for pickle.",
+    "builtins.list.__repr__" => "Return repr(self).",
+    "builtins.list.__reversed__" => "Return a reverse iterator over the list.",
+    "builtins.list.__rmul__" => "Return value*self.",
+    "builtins.list.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.list.__setitem__" => "Set self[key] to value.",
+    "builtins.list.__sizeof__" => "Return the size of the list in memory, in bytes.",
+    "builtins.list.__str__" => "Return str(self).",
+    "builtins.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).",
+    "builtins.list.append" => "Append object to the end of the list.",
+    "builtins.list.clear" => "Remove all items from list.",
+    "builtins.list.copy" => "Return a shallow copy of the list.",
+    "builtins.list.count" => "Return number of occurrences of value.",
+    "builtins.list.extend" => "Extend list by appending elements from the iterable.",
+    "builtins.list.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "builtins.list.insert" => "Insert object before index.",
+    "builtins.list.pop" => "Remove and return item at index (default last).\n\nRaises IndexError if list is empty or index is out of range.",
+    "builtins.list.remove" => "Remove first occurrence of value.\n\nRaises ValueError if the value is not present.",
+    "builtins.list.reverse" => "Reverse *IN PLACE*.",
+    "builtins.list.sort" => "Sort the list in ascending order and return None.\n\nThe sort is in-place (i.e. the list itself is modified) and stable (i.e. the\norder of two equal elements is maintained).\n\nIf a key function is given, apply it once to each list item and sort them,\nascending or descending, according to their function values.\n\nThe reverse flag can be set to sort in descending order.",
+    "builtins.list_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.list_iterator.__eq__" => "Return self==value.",
+    "builtins.list_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.list_iterator.__ge__" => "Return self>=value.",
+    "builtins.list_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.list_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.list_iterator.__gt__" => "Return self>value.",
+    "builtins.list_iterator.__hash__" => "Return hash(self).",
+    "builtins.list_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.list_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.",
+    "builtins.list_iterator.__iter__" => "Implement iter(self).",
+    "builtins.list_iterator.__le__" => "Return self<=value.",
+    "builtins.list_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.list_iterator.__lt__" => "Return self<value.",
+    "builtins.list_iterator.__ne__" => "Return self!=value.",
+    "builtins.list_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.list_iterator.__next__" => "Implement next(self).",
+    "builtins.list_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.list_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.list_iterator.__repr__" => "Return repr(self).",
+    "builtins.list_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.list_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.list_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.__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.",
+    "builtins.map.__ge__" => "Return self>=value.",
+    "builtins.map.__getattribute__" => "Return getattr(self, name).",
+    "builtins.map.__getstate__" => "Helper for pickle.",
+    "builtins.map.__gt__" => "Return self>value.",
+    "builtins.map.__hash__" => "Return hash(self).",
+    "builtins.map.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.map.__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.map.__iter__" => "Implement iter(self).",
+    "builtins.map.__le__" => "Return self<=value.",
+    "builtins.map.__lt__" => "Return self<value.",
+    "builtins.map.__ne__" => "Return self!=value.",
+    "builtins.map.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.map.__next__" => "Implement next(self).",
+    "builtins.map.__reduce__" => "Return state information for pickling.",
+    "builtins.map.__reduce_ex__" => "Helper for pickle.",
+    "builtins.map.__repr__" => "Return repr(self).",
+    "builtins.map.__setattr__" => "Implement setattr(self, name, value).",
+    "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).",
+    "builtins.mappingproxy" => "Read-only proxy of a mapping.",
+    "builtins.mappingproxy.__class_getitem__" => "See PEP 585",
+    "builtins.mappingproxy.__contains__" => "Return bool(key in self).",
+    "builtins.mappingproxy.__delattr__" => "Implement delattr(self, name).",
+    "builtins.mappingproxy.__eq__" => "Return self==value.",
+    "builtins.mappingproxy.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.mappingproxy.__ge__" => "Return self>=value.",
+    "builtins.mappingproxy.__getattribute__" => "Return getattr(self, name).",
+    "builtins.mappingproxy.__getitem__" => "Return self[key].",
+    "builtins.mappingproxy.__getstate__" => "Helper for pickle.",
+    "builtins.mappingproxy.__gt__" => "Return self>value.",
+    "builtins.mappingproxy.__hash__" => "Return hash(self).",
+    "builtins.mappingproxy.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.mappingproxy.__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.mappingproxy.__ior__" => "Return self|=value.",
+    "builtins.mappingproxy.__iter__" => "Implement iter(self).",
+    "builtins.mappingproxy.__le__" => "Return self<=value.",
+    "builtins.mappingproxy.__len__" => "Return len(self).",
+    "builtins.mappingproxy.__lt__" => "Return self<value.",
+    "builtins.mappingproxy.__ne__" => "Return self!=value.",
+    "builtins.mappingproxy.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.mappingproxy.__or__" => "Return self|value.",
+    "builtins.mappingproxy.__reduce__" => "Helper for pickle.",
+    "builtins.mappingproxy.__reduce_ex__" => "Helper for pickle.",
+    "builtins.mappingproxy.__repr__" => "Return repr(self).",
+    "builtins.mappingproxy.__reversed__" => "D.__reversed__() -> reverse iterator",
+    "builtins.mappingproxy.__ror__" => "Return value|self.",
+    "builtins.mappingproxy.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.mappingproxy.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.mappingproxy.__str__" => "Return str(self).",
+    "builtins.mappingproxy.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.mappingproxy.copy" => "D.copy() -> a shallow copy of D",
+    "builtins.mappingproxy.get" => "Return the value for key if key is in the mapping, else default.",
+    "builtins.mappingproxy.items" => "D.items() -> a set-like object providing a view on D's items",
+    "builtins.mappingproxy.keys" => "D.keys() -> a set-like object providing a view on D's keys",
+    "builtins.mappingproxy.values" => "D.values() -> an object providing a view on D's values",
+    "builtins.max" => "max(iterable, *[, default=obj, key=func]) -> value\nmax(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its biggest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more positional arguments, return the largest argument.",
+    "builtins.member_descriptor.__delattr__" => "Implement delattr(self, name).",
+    "builtins.member_descriptor.__delete__" => "Delete an attribute of instance.",
+    "builtins.member_descriptor.__eq__" => "Return self==value.",
+    "builtins.member_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.member_descriptor.__ge__" => "Return self>=value.",
+    "builtins.member_descriptor.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.member_descriptor.__getattribute__" => "Return getattr(self, name).",
+    "builtins.member_descriptor.__getstate__" => "Helper for pickle.",
+    "builtins.member_descriptor.__gt__" => "Return self>value.",
+    "builtins.member_descriptor.__hash__" => "Return hash(self).",
+    "builtins.member_descriptor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.member_descriptor.__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.member_descriptor.__le__" => "Return self<=value.",
+    "builtins.member_descriptor.__lt__" => "Return self<value.",
+    "builtins.member_descriptor.__ne__" => "Return self!=value.",
+    "builtins.member_descriptor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.member_descriptor.__reduce_ex__" => "Helper for pickle.",
+    "builtins.member_descriptor.__repr__" => "Return repr(self).",
+    "builtins.member_descriptor.__set__" => "Set an attribute of instance to value.",
+    "builtins.member_descriptor.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.member_descriptor.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.member_descriptor.__str__" => "Return str(self).",
+    "builtins.member_descriptor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.memory_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.memory_iterator.__eq__" => "Return self==value.",
+    "builtins.memory_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.memory_iterator.__ge__" => "Return self>=value.",
+    "builtins.memory_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.memory_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.memory_iterator.__gt__" => "Return self>value.",
+    "builtins.memory_iterator.__hash__" => "Return hash(self).",
+    "builtins.memory_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.memory_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.",
+    "builtins.memory_iterator.__iter__" => "Implement iter(self).",
+    "builtins.memory_iterator.__le__" => "Return self<=value.",
+    "builtins.memory_iterator.__lt__" => "Return self<value.",
+    "builtins.memory_iterator.__ne__" => "Return self!=value.",
+    "builtins.memory_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.memory_iterator.__next__" => "Implement next(self).",
+    "builtins.memory_iterator.__reduce__" => "Helper for pickle.",
+    "builtins.memory_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.memory_iterator.__repr__" => "Return repr(self).",
+    "builtins.memory_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.memory_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.memory_iterator.__str__" => "Return str(self).",
+    "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.__delattr__" => "Implement delattr(self, name).",
+    "builtins.memoryview.__delitem__" => "Delete self[key].",
+    "builtins.memoryview.__eq__" => "Return self==value.",
+    "builtins.memoryview.__exit__" => "Release the underlying buffer exposed by the memoryview object.",
+    "builtins.memoryview.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.memoryview.__ge__" => "Return self>=value.",
+    "builtins.memoryview.__getattribute__" => "Return getattr(self, name).",
+    "builtins.memoryview.__getitem__" => "Return self[key].",
+    "builtins.memoryview.__getstate__" => "Helper for pickle.",
+    "builtins.memoryview.__gt__" => "Return self>value.",
+    "builtins.memoryview.__hash__" => "Return hash(self).",
+    "builtins.memoryview.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.memoryview.__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.memoryview.__iter__" => "Implement iter(self).",
+    "builtins.memoryview.__le__" => "Return self<=value.",
+    "builtins.memoryview.__len__" => "Return len(self).",
+    "builtins.memoryview.__lt__" => "Return self<value.",
+    "builtins.memoryview.__ne__" => "Return self!=value.",
+    "builtins.memoryview.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.memoryview.__reduce__" => "Helper for pickle.",
+    "builtins.memoryview.__reduce_ex__" => "Helper for pickle.",
+    "builtins.memoryview.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "builtins.memoryview.__repr__" => "Return repr(self).",
+    "builtins.memoryview.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.memoryview.__setitem__" => "Set self[key] to value.",
+    "builtins.memoryview.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.memoryview.__str__" => "Return str(self).",
+    "builtins.memoryview.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._from_flags" => "Create a new memoryview object which references the given object.",
+    "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.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.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.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.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.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.",
+    "builtins.memoryview.toreadonly" => "Return a readonly version of the memoryview.",
+    "builtins.method" => "Create a bound instance method object.",
+    "builtins.method-wrapper.__call__" => "Call self as a function.",
+    "builtins.method-wrapper.__delattr__" => "Implement delattr(self, name).",
+    "builtins.method-wrapper.__eq__" => "Return self==value.",
+    "builtins.method-wrapper.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.method-wrapper.__ge__" => "Return self>=value.",
+    "builtins.method-wrapper.__getattribute__" => "Return getattr(self, name).",
+    "builtins.method-wrapper.__getstate__" => "Helper for pickle.",
+    "builtins.method-wrapper.__gt__" => "Return self>value.",
+    "builtins.method-wrapper.__hash__" => "Return hash(self).",
+    "builtins.method-wrapper.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.method-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.",
+    "builtins.method-wrapper.__le__" => "Return self<=value.",
+    "builtins.method-wrapper.__lt__" => "Return self<value.",
+    "builtins.method-wrapper.__ne__" => "Return self!=value.",
+    "builtins.method-wrapper.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.method-wrapper.__reduce_ex__" => "Helper for pickle.",
+    "builtins.method-wrapper.__repr__" => "Return repr(self).",
+    "builtins.method-wrapper.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.method-wrapper.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.method-wrapper.__str__" => "Return str(self).",
+    "builtins.method-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).",
+    "builtins.method.__call__" => "Call self as a function.",
+    "builtins.method.__delattr__" => "Implement delattr(self, name).",
+    "builtins.method.__eq__" => "Return self==value.",
+    "builtins.method.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.method.__func__" => "the function (or other callable) implementing a method",
+    "builtins.method.__ge__" => "Return self>=value.",
+    "builtins.method.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.method.__getattribute__" => "Return getattr(self, name).",
+    "builtins.method.__getstate__" => "Helper for pickle.",
+    "builtins.method.__gt__" => "Return self>value.",
+    "builtins.method.__hash__" => "Return hash(self).",
+    "builtins.method.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.method.__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.method.__le__" => "Return self<=value.",
+    "builtins.method.__lt__" => "Return self<value.",
+    "builtins.method.__ne__" => "Return self!=value.",
+    "builtins.method.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.method.__reduce_ex__" => "Helper for pickle.",
+    "builtins.method.__repr__" => "Return repr(self).",
+    "builtins.method.__self__" => "the instance to which a method is bound",
+    "builtins.method.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.method.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.method.__str__" => "Return str(self).",
+    "builtins.method.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.method_descriptor.__call__" => "Call self as a function.",
+    "builtins.method_descriptor.__delattr__" => "Implement delattr(self, name).",
+    "builtins.method_descriptor.__eq__" => "Return self==value.",
+    "builtins.method_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.method_descriptor.__ge__" => "Return self>=value.",
+    "builtins.method_descriptor.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.method_descriptor.__getattribute__" => "Return getattr(self, name).",
+    "builtins.method_descriptor.__getstate__" => "Helper for pickle.",
+    "builtins.method_descriptor.__gt__" => "Return self>value.",
+    "builtins.method_descriptor.__hash__" => "Return hash(self).",
+    "builtins.method_descriptor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.method_descriptor.__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.method_descriptor.__le__" => "Return self<=value.",
+    "builtins.method_descriptor.__lt__" => "Return self<value.",
+    "builtins.method_descriptor.__ne__" => "Return self!=value.",
+    "builtins.method_descriptor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.method_descriptor.__reduce_ex__" => "Helper for pickle.",
+    "builtins.method_descriptor.__repr__" => "Return repr(self).",
+    "builtins.method_descriptor.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.method_descriptor.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.method_descriptor.__str__" => "Return str(self).",
+    "builtins.method_descriptor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.min" => "min(iterable, *[, default=obj, key=func]) -> value\nmin(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its smallest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more positional arguments, return the smallest argument.",
+    "builtins.module" => "Create a module object.\n\nThe name must be a string; the optional doc argument can have any type.",
+    "builtins.module.__delattr__" => "Implement delattr(self, name).",
+    "builtins.module.__eq__" => "Return self==value.",
+    "builtins.module.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.module.__ge__" => "Return self>=value.",
+    "builtins.module.__getattribute__" => "Return getattr(self, name).",
+    "builtins.module.__getstate__" => "Helper for pickle.",
+    "builtins.module.__gt__" => "Return self>value.",
+    "builtins.module.__hash__" => "Return hash(self).",
+    "builtins.module.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.module.__le__" => "Return self<=value.",
+    "builtins.module.__lt__" => "Return self<value.",
+    "builtins.module.__ne__" => "Return self!=value.",
+    "builtins.module.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.module.__reduce__" => "Helper for pickle.",
+    "builtins.module.__reduce_ex__" => "Helper for pickle.",
+    "builtins.module.__repr__" => "Return repr(self).",
+    "builtins.module.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.module.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.module.__str__" => "Return str(self).",
+    "builtins.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).",
+    "builtins.next" => "next(iterator[, default])\n\nReturn the next item from the iterator. If default is given and the iterator\nis exhausted, it is returned instead of raising StopIteration.",
+    "builtins.object" => "The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.",
+    "builtins.object.__delattr__" => "Implement delattr(self, name).",
+    "builtins.object.__eq__" => "Return self==value.",
+    "builtins.object.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.object.__ge__" => "Return self>=value.",
+    "builtins.object.__getattribute__" => "Return getattr(self, name).",
+    "builtins.object.__getstate__" => "Helper for pickle.",
+    "builtins.object.__gt__" => "Return self>value.",
+    "builtins.object.__hash__" => "Return hash(self).",
+    "builtins.object.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.object.__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.object.__le__" => "Return self<=value.",
+    "builtins.object.__lt__" => "Return self<value.",
+    "builtins.object.__ne__" => "Return self!=value.",
+    "builtins.object.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.object.__reduce__" => "Helper for pickle.",
+    "builtins.object.__reduce_ex__" => "Helper for pickle.",
+    "builtins.object.__repr__" => "Return repr(self).",
+    "builtins.object.__setattr__" => "Implement setattr(self, name, value).",
+    "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.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.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.",
+    "builtins.property.__eq__" => "Return self==value.",
+    "builtins.property.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.property.__ge__" => "Return self>=value.",
+    "builtins.property.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.property.__getattribute__" => "Return getattr(self, name).",
+    "builtins.property.__getstate__" => "Helper for pickle.",
+    "builtins.property.__gt__" => "Return self>value.",
+    "builtins.property.__hash__" => "Return hash(self).",
+    "builtins.property.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.property.__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.property.__le__" => "Return self<=value.",
+    "builtins.property.__lt__" => "Return self<value.",
+    "builtins.property.__ne__" => "Return self!=value.",
+    "builtins.property.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.property.__reduce__" => "Helper for pickle.",
+    "builtins.property.__reduce_ex__" => "Helper for pickle.",
+    "builtins.property.__repr__" => "Return repr(self).",
+    "builtins.property.__set__" => "Set an attribute of instance to value.",
+    "builtins.property.__set_name__" => "Method to set name of a property.",
+    "builtins.property.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.property.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.property.__str__" => "Return str(self).",
+    "builtins.property.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.property.deleter" => "Descriptor to obtain a copy of the property with a different deleter.",
+    "builtins.property.getter" => "Descriptor to obtain a copy of the property with a different getter.",
+    "builtins.property.setter" => "Descriptor to obtain a copy of the property with a different setter.",
+    "builtins.range" => "range(stop) -> range object\nrange(start, stop[, step]) -> range object\n\nReturn an object that produces a sequence of integers from start (inclusive)\nto stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\nstart defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\nThese are exactly the valid indices for a list of 4 elements.\nWhen step is given, it specifies the increment (or decrement).",
+    "builtins.range.__bool__" => "True if self else False",
+    "builtins.range.__contains__" => "Return bool(key in self).",
+    "builtins.range.__delattr__" => "Implement delattr(self, name).",
+    "builtins.range.__eq__" => "Return self==value.",
+    "builtins.range.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.range.__ge__" => "Return self>=value.",
+    "builtins.range.__getattribute__" => "Return getattr(self, name).",
+    "builtins.range.__getitem__" => "Return self[key].",
+    "builtins.range.__getstate__" => "Helper for pickle.",
+    "builtins.range.__gt__" => "Return self>value.",
+    "builtins.range.__hash__" => "Return hash(self).",
+    "builtins.range.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.range.__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.range.__iter__" => "Implement iter(self).",
+    "builtins.range.__le__" => "Return self<=value.",
+    "builtins.range.__len__" => "Return len(self).",
+    "builtins.range.__lt__" => "Return self<value.",
+    "builtins.range.__ne__" => "Return self!=value.",
+    "builtins.range.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.range.__reduce_ex__" => "Helper for pickle.",
+    "builtins.range.__repr__" => "Return repr(self).",
+    "builtins.range.__reversed__" => "Return a reverse iterator.",
+    "builtins.range.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.range.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.range.__str__" => "Return str(self).",
+    "builtins.range.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.range.count" => "rangeobject.count(value) -> integer -- return number of occurrences of value",
+    "builtins.range.index" => "rangeobject.index(value) -> integer -- return index of value.\nRaise ValueError if the value is not present.",
+    "builtins.range_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.range_iterator.__eq__" => "Return self==value.",
+    "builtins.range_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.range_iterator.__ge__" => "Return self>=value.",
+    "builtins.range_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.range_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.range_iterator.__gt__" => "Return self>value.",
+    "builtins.range_iterator.__hash__" => "Return hash(self).",
+    "builtins.range_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.range_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.",
+    "builtins.range_iterator.__iter__" => "Implement iter(self).",
+    "builtins.range_iterator.__le__" => "Return self<=value.",
+    "builtins.range_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.range_iterator.__lt__" => "Return self<value.",
+    "builtins.range_iterator.__ne__" => "Return self!=value.",
+    "builtins.range_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.range_iterator.__next__" => "Implement next(self).",
+    "builtins.range_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.range_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.range_iterator.__repr__" => "Return repr(self).",
+    "builtins.range_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.range_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.range_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.range_iterator.__str__" => "Return str(self).",
+    "builtins.range_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.repr" => "Return the canonical string representation of the object.\n\nFor many object types, including most builtins, eval(repr(obj)) == obj.",
+    "builtins.reversed" => "Return a reverse iterator over the values of the given sequence.",
+    "builtins.reversed.__delattr__" => "Implement delattr(self, name).",
+    "builtins.reversed.__eq__" => "Return self==value.",
+    "builtins.reversed.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.reversed.__ge__" => "Return self>=value.",
+    "builtins.reversed.__getattribute__" => "Return getattr(self, name).",
+    "builtins.reversed.__getstate__" => "Helper for pickle.",
+    "builtins.reversed.__gt__" => "Return self>value.",
+    "builtins.reversed.__hash__" => "Return hash(self).",
+    "builtins.reversed.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.reversed.__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.reversed.__iter__" => "Implement iter(self).",
+    "builtins.reversed.__le__" => "Return self<=value.",
+    "builtins.reversed.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.reversed.__lt__" => "Return self<value.",
+    "builtins.reversed.__ne__" => "Return self!=value.",
+    "builtins.reversed.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.reversed.__next__" => "Implement next(self).",
+    "builtins.reversed.__reduce__" => "Return state information for pickling.",
+    "builtins.reversed.__reduce_ex__" => "Helper for pickle.",
+    "builtins.reversed.__repr__" => "Return repr(self).",
+    "builtins.reversed.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.reversed.__setstate__" => "Set state information for unpickling.",
+    "builtins.reversed.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.reversed.__str__" => "Return str(self).",
+    "builtins.reversed.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.round" => "Round a number to a given precision in decimal digits.\n\nThe return value is an integer if ndigits is omitted or None.  Otherwise\nthe return value has the same type as the number.  ndigits may be negative.",
+    "builtins.set" => "Build an unordered collection of unique elements.",
+    "builtins.set.__and__" => "Return self&value.",
+    "builtins.set.__class_getitem__" => "See PEP 585",
+    "builtins.set.__contains__" => "x.__contains__(y) <==> y in x.",
+    "builtins.set.__delattr__" => "Implement delattr(self, name).",
+    "builtins.set.__eq__" => "Return self==value.",
+    "builtins.set.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.set.__ge__" => "Return self>=value.",
+    "builtins.set.__getattribute__" => "Return getattr(self, name).",
+    "builtins.set.__getstate__" => "Helper for pickle.",
+    "builtins.set.__gt__" => "Return self>value.",
+    "builtins.set.__iand__" => "Return self&=value.",
+    "builtins.set.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.set.__ior__" => "Return self|=value.",
+    "builtins.set.__isub__" => "Return self-=value.",
+    "builtins.set.__iter__" => "Implement iter(self).",
+    "builtins.set.__ixor__" => "Return self^=value.",
+    "builtins.set.__le__" => "Return self<=value.",
+    "builtins.set.__len__" => "Return len(self).",
+    "builtins.set.__lt__" => "Return self<value.",
+    "builtins.set.__ne__" => "Return self!=value.",
+    "builtins.set.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.set.__or__" => "Return self|value.",
+    "builtins.set.__rand__" => "Return value&self.",
+    "builtins.set.__reduce__" => "Return state information for pickling.",
+    "builtins.set.__reduce_ex__" => "Helper for pickle.",
+    "builtins.set.__repr__" => "Return repr(self).",
+    "builtins.set.__ror__" => "Return value|self.",
+    "builtins.set.__rsub__" => "Return value-self.",
+    "builtins.set.__rxor__" => "Return value^self.",
+    "builtins.set.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.set.__sizeof__" => "S.__sizeof__() -> size of S in memory, in bytes.",
+    "builtins.set.__str__" => "Return str(self).",
+    "builtins.set.__sub__" => "Return self-value.",
+    "builtins.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).",
+    "builtins.set.__xor__" => "Return self^value.",
+    "builtins.set.add" => "Add an element to a set.\n\nThis has no effect if the element is already present.",
+    "builtins.set.clear" => "Remove all elements from this set.",
+    "builtins.set.copy" => "Return a shallow copy of a set.",
+    "builtins.set.difference" => "Return a new set with elements in the set that are not in the others.",
+    "builtins.set.difference_update" => "Update the set, removing elements found in others.",
+    "builtins.set.discard" => "Remove an element from a set if it is a member.\n\nUnlike set.remove(), the discard() method does not raise\nan exception when an element is missing from the set.",
+    "builtins.set.intersection" => "Return a new set with elements common to the set and all others.",
+    "builtins.set.intersection_update" => "Update the set, keeping only elements found in it and all others.",
+    "builtins.set.isdisjoint" => "Return True if two sets have a null intersection.",
+    "builtins.set.issubset" => "Report whether another set contains this set.",
+    "builtins.set.issuperset" => "Report whether this set contains another set.",
+    "builtins.set.pop" => "Remove and return an arbitrary set element.\n\nRaises KeyError if the set is empty.",
+    "builtins.set.remove" => "Remove an element from a set; it must be a member.\n\nIf the element is not a member, raise a KeyError.",
+    "builtins.set.symmetric_difference" => "Return a new set with elements in either the set or other but not both.",
+    "builtins.set.symmetric_difference_update" => "Update the set, keeping only elements found in either set, but not in both.",
+    "builtins.set.union" => "Return a new set with elements from the set and all others.",
+    "builtins.set.update" => "Update the set, adding elements from all others.",
+    "builtins.set_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.set_iterator.__eq__" => "Return self==value.",
+    "builtins.set_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.set_iterator.__ge__" => "Return self>=value.",
+    "builtins.set_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.set_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.set_iterator.__gt__" => "Return self>value.",
+    "builtins.set_iterator.__hash__" => "Return hash(self).",
+    "builtins.set_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.set_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.",
+    "builtins.set_iterator.__iter__" => "Implement iter(self).",
+    "builtins.set_iterator.__le__" => "Return self<=value.",
+    "builtins.set_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.set_iterator.__lt__" => "Return self<value.",
+    "builtins.set_iterator.__ne__" => "Return self!=value.",
+    "builtins.set_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.set_iterator.__next__" => "Implement next(self).",
+    "builtins.set_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.set_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.set_iterator.__repr__" => "Return repr(self).",
+    "builtins.set_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.set_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.set_iterator.__str__" => "Return str(self).",
+    "builtins.set_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.setattr" => "Sets the named attribute on the given object to the specified value.\n\nsetattr(x, 'y', v) is equivalent to ``x.y = v``",
+    "builtins.slice" => "slice(stop)\nslice(start, stop[, step])\n\nCreate a slice object.  This is used for extended slicing (e.g. a[0:10:2]).",
+    "builtins.slice.__delattr__" => "Implement delattr(self, name).",
+    "builtins.slice.__eq__" => "Return self==value.",
+    "builtins.slice.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.slice.__ge__" => "Return self>=value.",
+    "builtins.slice.__getattribute__" => "Return getattr(self, name).",
+    "builtins.slice.__getstate__" => "Helper for pickle.",
+    "builtins.slice.__gt__" => "Return self>value.",
+    "builtins.slice.__hash__" => "Return hash(self).",
+    "builtins.slice.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.slice.__le__" => "Return self<=value.",
+    "builtins.slice.__lt__" => "Return self<value.",
+    "builtins.slice.__ne__" => "Return self!=value.",
+    "builtins.slice.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.slice.__reduce__" => "Return state information for pickling.",
+    "builtins.slice.__reduce_ex__" => "Helper for pickle.",
+    "builtins.slice.__repr__" => "Return repr(self).",
+    "builtins.slice.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.slice.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.slice.__str__" => "Return str(self).",
+    "builtins.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).",
+    "builtins.slice.indices" => "S.indices(len) -> (start, stop, stride)\n\nAssuming a sequence of length len, calculate the start and stop\nindices, and the stride length of the extended slice described by\nS. Out of bounds indices are clipped in a manner consistent with the\nhandling of normal slices.",
+    "builtins.sorted" => "Return a new list containing all items from the iterable in ascending order.\n\nA custom key function can be supplied to customize the sort order, and the\nreverse flag can be set to request the result in descending order.",
+    "builtins.staticmethod" => "Convert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n     class C:\n         @staticmethod\n         def f(arg1, arg2, argN):\n             ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). Both the class and the instance are ignored, and\nneither is passed implicitly as the first argument to the method.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin.",
+    "builtins.staticmethod.__call__" => "Call self as a function.",
+    "builtins.staticmethod.__delattr__" => "Implement delattr(self, name).",
+    "builtins.staticmethod.__eq__" => "Return self==value.",
+    "builtins.staticmethod.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.staticmethod.__ge__" => "Return self>=value.",
+    "builtins.staticmethod.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.staticmethod.__getattribute__" => "Return getattr(self, name).",
+    "builtins.staticmethod.__getstate__" => "Helper for pickle.",
+    "builtins.staticmethod.__gt__" => "Return self>value.",
+    "builtins.staticmethod.__hash__" => "Return hash(self).",
+    "builtins.staticmethod.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.staticmethod.__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.staticmethod.__le__" => "Return self<=value.",
+    "builtins.staticmethod.__lt__" => "Return self<value.",
+    "builtins.staticmethod.__ne__" => "Return self!=value.",
+    "builtins.staticmethod.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.staticmethod.__reduce__" => "Helper for pickle.",
+    "builtins.staticmethod.__reduce_ex__" => "Helper for pickle.",
+    "builtins.staticmethod.__repr__" => "Return repr(self).",
+    "builtins.staticmethod.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.staticmethod.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.staticmethod.__str__" => "Return str(self).",
+    "builtins.staticmethod.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.str" => "str(object='') -> str\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\n\nCreate a new string object from the given object. If encoding or\nerrors is specified, then the object must expose a data buffer\nthat will be decoded using the given encoding and error handler.\nOtherwise, returns the result of object.__str__() (if defined)\nor repr(object).\nencoding defaults to 'utf-8'.\nerrors defaults to 'strict'.",
+    "builtins.str.__add__" => "Return self+value.",
+    "builtins.str.__contains__" => "Return bool(key in self).",
+    "builtins.str.__delattr__" => "Implement delattr(self, name).",
+    "builtins.str.__eq__" => "Return self==value.",
+    "builtins.str.__format__" => "Return a formatted version of the string as described by format_spec.",
+    "builtins.str.__ge__" => "Return self>=value.",
+    "builtins.str.__getattribute__" => "Return getattr(self, name).",
+    "builtins.str.__getitem__" => "Return self[key].",
+    "builtins.str.__getstate__" => "Helper for pickle.",
+    "builtins.str.__gt__" => "Return self>value.",
+    "builtins.str.__hash__" => "Return hash(self).",
+    "builtins.str.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.str.__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.str.__iter__" => "Implement iter(self).",
+    "builtins.str.__le__" => "Return self<=value.",
+    "builtins.str.__len__" => "Return len(self).",
+    "builtins.str.__lt__" => "Return self<value.",
+    "builtins.str.__mod__" => "Return self%value.",
+    "builtins.str.__mul__" => "Return self*value.",
+    "builtins.str.__ne__" => "Return self!=value.",
+    "builtins.str.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.str.__reduce__" => "Helper for pickle.",
+    "builtins.str.__reduce_ex__" => "Helper for pickle.",
+    "builtins.str.__repr__" => "Return repr(self).",
+    "builtins.str.__rmod__" => "Return value%self.",
+    "builtins.str.__rmul__" => "Return value*self.",
+    "builtins.str.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.str.__sizeof__" => "Return the size of the string in memory, in bytes.",
+    "builtins.str.__str__" => "Return str(self).",
+    "builtins.str.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.str.capitalize" => "Return a capitalized version of the string.\n\nMore specifically, make the first character have upper case and the rest lower\ncase.",
+    "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.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 '}').",
+    "builtins.str.format_map" => "Return a formatted version of the string, using substitutions from mapping.\nThe substitutions are identified by braces ('{' and '}').",
+    "builtins.str.index" => "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.\nRaises ValueError when the substring is not found.",
+    "builtins.str.isalnum" => "Return True if the string is an alpha-numeric string, False otherwise.\n\nA string is alpha-numeric if all characters in the string are alpha-numeric and\nthere is at least one character in the string.",
+    "builtins.str.isalpha" => "Return True if the string is an alphabetic string, False otherwise.\n\nA string is alphabetic if all characters in the string are alphabetic and there\nis at least one character in the string.",
+    "builtins.str.isascii" => "Return True if all characters in the string are ASCII, False otherwise.\n\nASCII characters have code points in the range U+0000-U+007F.\nEmpty string is ASCII too.",
+    "builtins.str.isdecimal" => "Return True if the string is a decimal string, False otherwise.\n\nA string is a decimal string if all characters in the string are decimal and\nthere is at least one character in the string.",
+    "builtins.str.isdigit" => "Return True if the string is a digit string, False otherwise.\n\nA string is a digit string if all characters in the string are digits and there\nis at least one character in the string.",
+    "builtins.str.isidentifier" => "Return True if the string is a valid Python identifier, False otherwise.\n\nCall keyword.iskeyword(s) to test whether string s is a reserved identifier,\nsuch as \"def\" or \"class\".",
+    "builtins.str.islower" => "Return True if the string is a lowercase string, False otherwise.\n\nA string is lowercase if all cased characters in the string are lowercase and\nthere is at least one cased character in the string.",
+    "builtins.str.isnumeric" => "Return True if the string is a numeric string, False otherwise.\n\nA string is numeric if all characters in the string are numeric and there is at\nleast one character in the string.",
+    "builtins.str.isprintable" => "Return True if all characters in the string are printable, False otherwise.\n\nA character is printable if repr() may use it in its output.",
+    "builtins.str.isspace" => "Return True if the string is a whitespace string, False otherwise.\n\nA string is whitespace if all characters in the string are whitespace and there\nis at least one character in the string.",
+    "builtins.str.istitle" => "Return True if the string is a title-cased string, False otherwise.\n\nIn a title-cased string, upper- and title-case characters may only\nfollow uncased characters and lowercase characters only cased ones.",
+    "builtins.str.isupper" => "Return True if the string is an uppercase string, False otherwise.\n\nA string is uppercase if all cased characters in the string are uppercase and\nthere is at least one cased character in the string.",
+    "builtins.str.join" => "Concatenate any number of strings.\n\nThe string whose method is called is inserted in between each given string.\nThe result is returned as a new string.\n\nExample: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'",
+    "builtins.str.ljust" => "Return a left-justified string of length width.\n\nPadding is done using the specified fill character (default is a space).",
+    "builtins.str.lower" => "Return a copy of the string converted to lowercase.",
+    "builtins.str.lstrip" => "Return a copy of the string with leading whitespace removed.\n\nIf chars is given and not None, remove characters in chars instead.",
+    "builtins.str.maketrans" => "Return a translation table usable for str.translate().\n\nIf there is only one argument, it must be a dictionary mapping Unicode\nordinals (integers) or characters to Unicode ordinals, strings or None.\nCharacter keys will be then converted to ordinals.\nIf there are two arguments, they must be strings of equal length, and\nin the resulting dictionary, each character in x will be mapped to the\ncharacter at the same position in y. If there is a third argument, it\nmust be a string, whose characters will be mapped to None in the result.",
+    "builtins.str.partition" => "Partition the string into three parts using the given separator.\n\nThis will search for the separator in the string.  If the separator is found,\nreturns a 3-tuple containing the part before the separator, the separator\nitself, and the part after it.\n\nIf the separator is not found, returns a 3-tuple containing the original string\nand two empty strings.",
+    "builtins.str.removeprefix" => "Return a str with the given prefix string removed if present.\n\nIf the string starts with the prefix string, return string[len(prefix):].\nOtherwise, return a copy of the original string.",
+    "builtins.str.removesuffix" => "Return a str with the given suffix string removed if present.\n\nIf the string ends with the suffix string and that suffix is not empty,\nreturn string[:-len(suffix)]. Otherwise, return a copy of the original\nstring.",
+    "builtins.str.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.str.rfind" => "Return the highest 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.rindex" => "Return the highest 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.\nRaises ValueError when the substring is not found.",
+    "builtins.str.rjust" => "Return a right-justified string of length width.\n\nPadding is done using the specified fill character (default is a space).",
+    "builtins.str.rpartition" => "Partition the string into three parts using the given separator.\n\nThis will search for the separator in the string, 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 strings\nand the original string.",
+    "builtins.str.rsplit" => "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 end of the string and works to the front.",
+    "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.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.",
+    "builtins.str.translate" => "Replace each character in the string using the given translation table.\n\n  table\n    Translation table, which must be a mapping of Unicode ordinals to\n    Unicode ordinals, strings, or None.\n\nThe table must implement lookup/indexing via __getitem__, for instance a\ndictionary or list.  If this operation raises LookupError, the character is\nleft untouched.  Characters mapped to None are deleted.",
+    "builtins.str.upper" => "Return a copy of the string converted to uppercase.",
+    "builtins.str.zfill" => "Pad a numeric string with zeros on the left, to fill a field of the given width.\n\nThe string is never truncated.",
+    "builtins.str_ascii_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.str_ascii_iterator.__eq__" => "Return self==value.",
+    "builtins.str_ascii_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.str_ascii_iterator.__ge__" => "Return self>=value.",
+    "builtins.str_ascii_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.str_ascii_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.str_ascii_iterator.__gt__" => "Return self>value.",
+    "builtins.str_ascii_iterator.__hash__" => "Return hash(self).",
+    "builtins.str_ascii_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.str_ascii_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.",
+    "builtins.str_ascii_iterator.__iter__" => "Implement iter(self).",
+    "builtins.str_ascii_iterator.__le__" => "Return self<=value.",
+    "builtins.str_ascii_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.str_ascii_iterator.__lt__" => "Return self<value.",
+    "builtins.str_ascii_iterator.__ne__" => "Return self!=value.",
+    "builtins.str_ascii_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.str_ascii_iterator.__next__" => "Implement next(self).",
+    "builtins.str_ascii_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.str_ascii_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.str_ascii_iterator.__repr__" => "Return repr(self).",
+    "builtins.str_ascii_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.str_ascii_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.str_ascii_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.str_ascii_iterator.__str__" => "Return str(self).",
+    "builtins.str_ascii_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.sum" => "Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n\nWhen the iterable is empty, return the start value.\nThis function is intended specifically for use with numeric values and may\nreject non-numeric types.",
+    "builtins.super" => "super() -> same as super(__class__, <first argument>)\nsuper(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n    def meth(self, arg):\n        super().meth(arg)\nThis works for class methods too:\nclass C(B):\n    @classmethod\n    def cmeth(cls, arg):\n        super().cmeth(arg)",
+    "builtins.super.__delattr__" => "Implement delattr(self, name).",
+    "builtins.super.__eq__" => "Return self==value.",
+    "builtins.super.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.super.__ge__" => "Return self>=value.",
+    "builtins.super.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.super.__getattribute__" => "Return getattr(self, name).",
+    "builtins.super.__getstate__" => "Helper for pickle.",
+    "builtins.super.__gt__" => "Return self>value.",
+    "builtins.super.__hash__" => "Return hash(self).",
+    "builtins.super.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.super.__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.super.__le__" => "Return self<=value.",
+    "builtins.super.__lt__" => "Return self<value.",
+    "builtins.super.__ne__" => "Return self!=value.",
+    "builtins.super.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.super.__reduce__" => "Helper for pickle.",
+    "builtins.super.__reduce_ex__" => "Helper for pickle.",
+    "builtins.super.__repr__" => "Return repr(self).",
+    "builtins.super.__self__" => "the instance invoking super(); may be None",
+    "builtins.super.__self_class__" => "the type of the instance invoking super(); may be None",
+    "builtins.super.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.super.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.super.__str__" => "Return str(self).",
+    "builtins.super.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.super.__thisclass__" => "the class invoking super()",
+    "builtins.traceback" => "Create a new traceback object.",
+    "builtins.traceback.__delattr__" => "Implement delattr(self, name).",
+    "builtins.traceback.__eq__" => "Return self==value.",
+    "builtins.traceback.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.traceback.__ge__" => "Return self>=value.",
+    "builtins.traceback.__getattribute__" => "Return getattr(self, name).",
+    "builtins.traceback.__getstate__" => "Helper for pickle.",
+    "builtins.traceback.__gt__" => "Return self>value.",
+    "builtins.traceback.__hash__" => "Return hash(self).",
+    "builtins.traceback.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.traceback.__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.traceback.__le__" => "Return self<=value.",
+    "builtins.traceback.__lt__" => "Return self<value.",
+    "builtins.traceback.__ne__" => "Return self!=value.",
+    "builtins.traceback.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.traceback.__reduce__" => "Helper for pickle.",
+    "builtins.traceback.__reduce_ex__" => "Helper for pickle.",
+    "builtins.traceback.__repr__" => "Return repr(self).",
+    "builtins.traceback.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.traceback.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.traceback.__str__" => "Return str(self).",
+    "builtins.traceback.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.tuple" => "Built-in immutable sequence.\n\nIf no argument is given, the constructor returns an empty tuple.\nIf iterable is specified the tuple is initialized from iterable's items.\n\nIf the argument is a tuple, the return value is the same object.",
+    "builtins.tuple.__add__" => "Return self+value.",
+    "builtins.tuple.__class_getitem__" => "See PEP 585",
+    "builtins.tuple.__contains__" => "Return bool(key in self).",
+    "builtins.tuple.__delattr__" => "Implement delattr(self, name).",
+    "builtins.tuple.__eq__" => "Return self==value.",
+    "builtins.tuple.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.tuple.__ge__" => "Return self>=value.",
+    "builtins.tuple.__getattribute__" => "Return getattr(self, name).",
+    "builtins.tuple.__getitem__" => "Return self[key].",
+    "builtins.tuple.__getstate__" => "Helper for pickle.",
+    "builtins.tuple.__gt__" => "Return self>value.",
+    "builtins.tuple.__hash__" => "Return hash(self).",
+    "builtins.tuple.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.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.",
+    "builtins.tuple.__iter__" => "Implement iter(self).",
+    "builtins.tuple.__le__" => "Return self<=value.",
+    "builtins.tuple.__len__" => "Return len(self).",
+    "builtins.tuple.__lt__" => "Return self<value.",
+    "builtins.tuple.__mul__" => "Return self*value.",
+    "builtins.tuple.__ne__" => "Return self!=value.",
+    "builtins.tuple.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.tuple.__reduce__" => "Helper for pickle.",
+    "builtins.tuple.__reduce_ex__" => "Helper for pickle.",
+    "builtins.tuple.__repr__" => "Return repr(self).",
+    "builtins.tuple.__rmul__" => "Return value*self.",
+    "builtins.tuple.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.tuple.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.tuple.__str__" => "Return str(self).",
+    "builtins.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).",
+    "builtins.tuple.count" => "Return number of occurrences of value.",
+    "builtins.tuple.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "builtins.tuple_iterator.__delattr__" => "Implement delattr(self, name).",
+    "builtins.tuple_iterator.__eq__" => "Return self==value.",
+    "builtins.tuple_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.tuple_iterator.__ge__" => "Return self>=value.",
+    "builtins.tuple_iterator.__getattribute__" => "Return getattr(self, name).",
+    "builtins.tuple_iterator.__getstate__" => "Helper for pickle.",
+    "builtins.tuple_iterator.__gt__" => "Return self>value.",
+    "builtins.tuple_iterator.__hash__" => "Return hash(self).",
+    "builtins.tuple_iterator.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.tuple_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.",
+    "builtins.tuple_iterator.__iter__" => "Implement iter(self).",
+    "builtins.tuple_iterator.__le__" => "Return self<=value.",
+    "builtins.tuple_iterator.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "builtins.tuple_iterator.__lt__" => "Return self<value.",
+    "builtins.tuple_iterator.__ne__" => "Return self!=value.",
+    "builtins.tuple_iterator.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.tuple_iterator.__next__" => "Implement next(self).",
+    "builtins.tuple_iterator.__reduce__" => "Return state information for pickling.",
+    "builtins.tuple_iterator.__reduce_ex__" => "Helper for pickle.",
+    "builtins.tuple_iterator.__repr__" => "Return repr(self).",
+    "builtins.tuple_iterator.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.tuple_iterator.__setstate__" => "Set state information for unpickling.",
+    "builtins.tuple_iterator.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.tuple_iterator.__str__" => "Return str(self).",
+    "builtins.tuple_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.type" => "type(object) -> the object's type\ntype(name, bases, dict, **kwds) -> a new type",
+    "builtins.type.__base__" => "The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.",
+    "builtins.type.__base__.__delattr__" => "Implement delattr(self, name).",
+    "builtins.type.__base__.__eq__" => "Return self==value.",
+    "builtins.type.__base__.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.type.__base__.__ge__" => "Return self>=value.",
+    "builtins.type.__base__.__getattribute__" => "Return getattr(self, name).",
+    "builtins.type.__base__.__getstate__" => "Helper for pickle.",
+    "builtins.type.__base__.__gt__" => "Return self>value.",
+    "builtins.type.__base__.__hash__" => "Return hash(self).",
+    "builtins.type.__base__.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.type.__base__.__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.type.__base__.__le__" => "Return self<=value.",
+    "builtins.type.__base__.__lt__" => "Return self<value.",
+    "builtins.type.__base__.__ne__" => "Return self!=value.",
+    "builtins.type.__base__.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.type.__base__.__reduce__" => "Helper for pickle.",
+    "builtins.type.__base__.__reduce_ex__" => "Helper for pickle.",
+    "builtins.type.__base__.__repr__" => "Return repr(self).",
+    "builtins.type.__base__.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.type.__base__.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.type.__base__.__str__" => "Return str(self).",
+    "builtins.type.__base__.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.type.__call__" => "Call self as a function.",
+    "builtins.type.__delattr__" => "Implement delattr(self, name).",
+    "builtins.type.__eq__" => "Return self==value.",
+    "builtins.type.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.type.__ge__" => "Return self>=value.",
+    "builtins.type.__getattribute__" => "Return getattr(self, name).",
+    "builtins.type.__getstate__" => "Helper for pickle.",
+    "builtins.type.__gt__" => "Return self>value.",
+    "builtins.type.__hash__" => "Return hash(self).",
+    "builtins.type.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.type.__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.type.__instancecheck__" => "Check if an object is an instance.",
+    "builtins.type.__le__" => "Return self<=value.",
+    "builtins.type.__lt__" => "Return self<value.",
+    "builtins.type.__ne__" => "Return self!=value.",
+    "builtins.type.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.type.__or__" => "Return self|value.",
+    "builtins.type.__prepare__" => "Create the namespace for the class statement",
+    "builtins.type.__reduce__" => "Helper for pickle.",
+    "builtins.type.__reduce_ex__" => "Helper for pickle.",
+    "builtins.type.__repr__" => "Return repr(self).",
+    "builtins.type.__ror__" => "Return value|self.",
+    "builtins.type.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.type.__sizeof__" => "Return memory consumption of the type object.",
+    "builtins.type.__str__" => "Return str(self).",
+    "builtins.type.__subclasscheck__" => "Check if a class is a subclass.",
+    "builtins.type.__subclasses__" => "Return a list of immediate subclasses.",
+    "builtins.type.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.type.mro" => "Return a type's method resolution order.",
+    "builtins.vars" => "vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.",
+    "builtins.wrapper_descriptor.__call__" => "Call self as a function.",
+    "builtins.wrapper_descriptor.__delattr__" => "Implement delattr(self, name).",
+    "builtins.wrapper_descriptor.__eq__" => "Return self==value.",
+    "builtins.wrapper_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.wrapper_descriptor.__ge__" => "Return self>=value.",
+    "builtins.wrapper_descriptor.__get__" => "Return an attribute of instance, which is of type owner.",
+    "builtins.wrapper_descriptor.__getattribute__" => "Return getattr(self, name).",
+    "builtins.wrapper_descriptor.__getstate__" => "Helper for pickle.",
+    "builtins.wrapper_descriptor.__gt__" => "Return self>value.",
+    "builtins.wrapper_descriptor.__hash__" => "Return hash(self).",
+    "builtins.wrapper_descriptor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.wrapper_descriptor.__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.wrapper_descriptor.__le__" => "Return self<=value.",
+    "builtins.wrapper_descriptor.__lt__" => "Return self<value.",
+    "builtins.wrapper_descriptor.__ne__" => "Return self!=value.",
+    "builtins.wrapper_descriptor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.wrapper_descriptor.__reduce_ex__" => "Helper for pickle.",
+    "builtins.wrapper_descriptor.__repr__" => "Return repr(self).",
+    "builtins.wrapper_descriptor.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.wrapper_descriptor.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.wrapper_descriptor.__str__" => "Return str(self).",
+    "builtins.wrapper_descriptor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.zip" => "The zip object yields n-length tuples, where n is the number of iterables\npassed as positional arguments to zip().  The i-th element in every tuple\ncomes from the i-th iterable argument to zip().  This continues until the\nshortest argument is exhausted.\n\nIf strict is true and one of the arguments is exhausted before the others,\nraise a ValueError.\n\n   >>> list(zip('abcdefg', range(3), range(4)))\n   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]",
+    "builtins.zip.__delattr__" => "Implement delattr(self, name).",
+    "builtins.zip.__eq__" => "Return self==value.",
+    "builtins.zip.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "builtins.zip.__ge__" => "Return self>=value.",
+    "builtins.zip.__getattribute__" => "Return getattr(self, name).",
+    "builtins.zip.__getstate__" => "Helper for pickle.",
+    "builtins.zip.__gt__" => "Return self>value.",
+    "builtins.zip.__hash__" => "Return hash(self).",
+    "builtins.zip.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "builtins.zip.__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.zip.__iter__" => "Implement iter(self).",
+    "builtins.zip.__le__" => "Return self<=value.",
+    "builtins.zip.__lt__" => "Return self<value.",
+    "builtins.zip.__ne__" => "Return self!=value.",
+    "builtins.zip.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "builtins.zip.__next__" => "Implement next(self).",
+    "builtins.zip.__reduce__" => "Return state information for pickling.",
+    "builtins.zip.__reduce_ex__" => "Helper for pickle.",
+    "builtins.zip.__repr__" => "Return repr(self).",
+    "builtins.zip.__setattr__" => "Implement setattr(self, name, value).",
+    "builtins.zip.__setstate__" => "Set state information for unpickling.",
+    "builtins.zip.__sizeof__" => "Size of object in memory, in bytes.",
+    "builtins.zip.__str__" => "Return str(self).",
+    "builtins.zip.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "cmath" => "This module provides access to mathematical functions for complex\nnumbers.",
+    "cmath.acos" => "Return the arc cosine of z.",
+    "cmath.acosh" => "Return the inverse hyperbolic cosine of z.",
+    "cmath.asin" => "Return the arc sine of z.",
+    "cmath.asinh" => "Return the inverse hyperbolic sine of z.",
+    "cmath.atan" => "Return the arc tangent of z.",
+    "cmath.atanh" => "Return the inverse hyperbolic tangent of z.",
+    "cmath.cos" => "Return the cosine of z.",
+    "cmath.cosh" => "Return the hyperbolic cosine of z.",
+    "cmath.exp" => "Return the exponential value e**z.",
+    "cmath.isclose" => "Determine whether two complex 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 must be\nsmaller than at least one of the tolerances.\n\n-inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is\nnot close to anything, even itself. inf and -inf are only close to themselves.",
+    "cmath.isfinite" => "Return True if both the real and imaginary parts of z are finite, else False.",
+    "cmath.isinf" => "Checks if the real or imaginary part of z is infinite.",
+    "cmath.isnan" => "Checks if the real or imaginary part of z not a number (NaN).",
+    "cmath.log" => "log(z[, base]) -> the logarithm of z to the given base.\n\nIf the base is not specified, returns the natural logarithm (base e) of z.",
+    "cmath.log10" => "Return the base-10 logarithm of z.",
+    "cmath.phase" => "Return argument, also known as the phase angle, of a complex.",
+    "cmath.polar" => "Convert a complex from rectangular coordinates to polar coordinates.\n\nr is the distance from 0 and phi the phase angle.",
+    "cmath.rect" => "Convert from polar coordinates to rectangular coordinates.",
+    "cmath.sin" => "Return the sine of z.",
+    "cmath.sinh" => "Return the hyperbolic sine of z.",
+    "cmath.sqrt" => "Return the square root of z.",
+    "cmath.tan" => "Return the tangent of z.",
+    "cmath.tanh" => "Return the hyperbolic tangent of z.",
+    "errno" => "This module makes available standard errno system symbols.\n\nThe value of each symbol is the corresponding integer value,\ne.g., on most systems, errno.ENOENT equals the integer 2.\n\nThe dictionary errno.errorcode maps numeric codes to symbol names,\ne.g., errno.errorcode[2] could be the string 'ENOENT'.\n\nSymbols that are not relevant to the underlying system are not defined.\n\nTo map error codes to error messages, use the function os.strerror(),\ne.g. os.strerror(2) could return 'No such file or directory'.",
+    "faulthandler" => "faulthandler module.",
+    "faulthandler._fatal_error_c_thread" => "Call Py_FatalError() in a new C thread.",
+    "faulthandler._raise_exception" => "Call RaiseException(code, flags).",
+    "faulthandler._read_null" => "Read from NULL, raise a SIGSEGV or SIGBUS signal depending on the platform.",
+    "faulthandler._sigabrt" => "Raise a SIGABRT signal.",
+    "faulthandler._sigfpe" => "Raise a SIGFPE signal.",
+    "faulthandler._sigsegv" => "Raise a SIGSEGV signal.",
+    "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_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.",
+    "faulthandler.is_enabled" => "Check if the handler is enabled.",
+    "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)",
+    "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.",
+    "gc.enable" => "Enable automatic garbage collection.",
+    "gc.freeze" => "Freeze all current tracked objects and ignore them for future collections.\n\nThis can be used before a POSIX fork() call to make the gc copy-on-write friendly.\nNote: collection before a POSIX fork() call may free pages for future allocation\nwhich can cause copy-on-write.",
+    "gc.get_count" => "Return a three-tuple of the current collection counts.",
+    "gc.get_debug" => "Get the garbage collection debugging flags.",
+    "gc.get_freeze_count" => "Return the number of objects in the permanent generation.",
+    "gc.get_objects" => "Return a list of objects tracked by the collector (excluding the list returned).\n\n  generation\n    Generation to extract the objects from.\n\nIf generation is not None, return only the objects tracked by the collector\nthat are in that generation.",
+    "gc.get_referents" => "Return the list of objects that are directly referred to by 'objs'.",
+    "gc.get_referrers" => "Return the list of objects that directly refer to any of 'objs'.",
+    "gc.get_stats" => "Return a list of dictionaries containing per-generation statistics.",
+    "gc.get_threshold" => "Return the current collection thresholds.",
+    "gc.is_finalized" => "Returns true if the object has been already finalized by the GC.",
+    "gc.is_tracked" => "Returns true if the object is tracked by the garbage collector.\n\nSimple atomic objects will return false.",
+    "gc.isenabled" => "Returns true if automatic garbage collection is enabled.",
+    "gc.set_debug" => "Set the garbage collection debugging flags.\n\n  flags\n    An integer that can have the following bits turned on:\n      DEBUG_STATS - Print statistics during collection.\n      DEBUG_COLLECTABLE - Print collectable objects found.\n      DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects\n        found.\n      DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n      DEBUG_LEAK - Debug leaking programs (everything but STATS).\n\nDebugging information is written to sys.stderr.",
+    "gc.set_threshold" => "set_threshold(threshold0, [threshold1, [threshold2]])\nSet the collection thresholds (the collection frequency).\n\nSetting 'threshold0' to zero disables collection.",
+    "gc.unfreeze" => "Unfreeze all objects in the permanent generation.\n\nPut all objects in the permanent generation back into oldest generation.",
+    "grp" => "Access to the Unix group database.\n\nGroup entries are reported as 4-tuples containing the following fields\nfrom the group database, in order:\n\n  gr_name   - name of the group\n  gr_passwd - group password (encrypted); often empty\n  gr_gid    - numeric ID of the group\n  gr_mem    - list of members\n\nThe gid is an integer, name and password are strings.  (Note that most\nusers are not explicitly listed as members of the groups they are in\naccording to the password database.  Check both databases to get\ncomplete membership information.)",
+    "grp.getgrall" => "Return a list of all available group entries, in arbitrary order.\n\nAn entry whose name starts with '+' or '-' represents an instruction\nto use YP/NIS and may not be accessible via getgrnam or getgrgid.",
+    "grp.getgrgid" => "Return the group database entry for the given numeric group ID.\n\nIf id is not valid, raise KeyError.",
+    "grp.getgrnam" => "Return the group database entry for the given group name.\n\nIf name is not valid, raise KeyError.",
+    "grp.struct_group" => "grp.struct_group: Results from getgr*() routines.\n\nThis object may be accessed either as a tuple of\n  (gr_name,gr_passwd,gr_gid,gr_mem)\nor via the object attributes as named in the above tuple.",
+    "grp.struct_group.__add__" => "Return self+value.",
+    "grp.struct_group.__class_getitem__" => "See PEP 585",
+    "grp.struct_group.__contains__" => "Return bool(key in self).",
+    "grp.struct_group.__delattr__" => "Implement delattr(self, name).",
+    "grp.struct_group.__eq__" => "Return self==value.",
+    "grp.struct_group.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "grp.struct_group.__ge__" => "Return self>=value.",
+    "grp.struct_group.__getattribute__" => "Return getattr(self, name).",
+    "grp.struct_group.__getitem__" => "Return self[key].",
+    "grp.struct_group.__getstate__" => "Helper for pickle.",
+    "grp.struct_group.__gt__" => "Return self>value.",
+    "grp.struct_group.__hash__" => "Return hash(self).",
+    "grp.struct_group.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "grp.struct_group.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "grp.struct_group.__iter__" => "Implement iter(self).",
+    "grp.struct_group.__le__" => "Return self<=value.",
+    "grp.struct_group.__len__" => "Return len(self).",
+    "grp.struct_group.__lt__" => "Return self<value.",
+    "grp.struct_group.__mul__" => "Return self*value.",
+    "grp.struct_group.__ne__" => "Return self!=value.",
+    "grp.struct_group.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "grp.struct_group.__reduce_ex__" => "Helper for pickle.",
+    "grp.struct_group.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "grp.struct_group.__repr__" => "Return repr(self).",
+    "grp.struct_group.__rmul__" => "Return value*self.",
+    "grp.struct_group.__setattr__" => "Implement setattr(self, name, value).",
+    "grp.struct_group.__sizeof__" => "Size of object in memory, in bytes.",
+    "grp.struct_group.__str__" => "Return str(self).",
+    "grp.struct_group.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "grp.struct_group.count" => "Return number of occurrences of value.",
+    "grp.struct_group.gr_gid" => "group id",
+    "grp.struct_group.gr_mem" => "group members",
+    "grp.struct_group.gr_name" => "group name",
+    "grp.struct_group.gr_passwd" => "password",
+    "grp.struct_group.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "itertools" => "Functional tools for creating and using iterators.\n\nInfinite iterators:\ncount(start=0, step=1) --> start, start+step, start+2*step, ...\ncycle(p) --> p0, p1, ... plast, p0, p1, ...\nrepeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times\n\nIterators terminating on the shortest input sequence:\naccumulate(p[, func]) --> p0, p0+p1, p0+p1+p2\nbatched(p, n) --> [p0, p1, ..., p_n-1], [p_n, p_n+1, ..., p_2n-1], ...\nchain(p, q, ...) --> p0, p1, ... plast, q0, q1, ...\nchain.from_iterable([p, q, ...]) --> p0, p1, ... plast, q0, q1, ...\ncompress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...\ndropwhile(predicate, seq) --> seq[n], seq[n+1], starting when predicate fails\ngroupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)\nfilterfalse(predicate, seq) --> elements of seq where predicate(elem) is False\nislice(seq, [start,] stop [, step]) --> elements from\n       seq[start:stop:step]\npairwise(s) --> (s[0],s[1]), (s[1],s[2]), (s[2], s[3]), ...\nstarmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\ntee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n\ntakewhile(predicate, seq) --> seq[0], seq[1], until predicate fails\nzip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ...\n\nCombinatoric generators:\nproduct(p, q, ... [repeat=1]) --> cartesian product\npermutations(p[, r])\ncombinations(p, r)\ncombinations_with_replacement(p, r)",
+    "itertools._grouper.__delattr__" => "Implement delattr(self, name).",
+    "itertools._grouper.__eq__" => "Return self==value.",
+    "itertools._grouper.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools._grouper.__ge__" => "Return self>=value.",
+    "itertools._grouper.__getattribute__" => "Return getattr(self, name).",
+    "itertools._grouper.__getstate__" => "Helper for pickle.",
+    "itertools._grouper.__gt__" => "Return self>value.",
+    "itertools._grouper.__hash__" => "Return hash(self).",
+    "itertools._grouper.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools._grouper.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools._grouper.__iter__" => "Implement iter(self).",
+    "itertools._grouper.__le__" => "Return self<=value.",
+    "itertools._grouper.__lt__" => "Return self<value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools._grouper.__repr__" => "Return repr(self).",
+    "itertools._grouper.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools._grouper.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools._grouper.__str__" => "Return str(self).",
+    "itertools._grouper.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._tee" => "Iterator wrapped to make it copyable.",
+    "itertools._tee.__copy__" => "Returns an independent iterator.",
+    "itertools._tee.__delattr__" => "Implement delattr(self, name).",
+    "itertools._tee.__eq__" => "Return self==value.",
+    "itertools._tee.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools._tee.__ge__" => "Return self>=value.",
+    "itertools._tee.__getattribute__" => "Return getattr(self, name).",
+    "itertools._tee.__getstate__" => "Helper for pickle.",
+    "itertools._tee.__gt__" => "Return self>value.",
+    "itertools._tee.__hash__" => "Return hash(self).",
+    "itertools._tee.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools._tee.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools._tee.__iter__" => "Implement iter(self).",
+    "itertools._tee.__le__" => "Return self<=value.",
+    "itertools._tee.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools._tee_dataobject" => "teedataobject(iterable, values, next, /)\n--\n\nData container common to multiple tee objects.",
+    "itertools._tee_dataobject.__delattr__" => "Implement delattr(self, name).",
+    "itertools._tee_dataobject.__eq__" => "Return self==value.",
+    "itertools._tee_dataobject.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools._tee_dataobject.__ge__" => "Return self>=value.",
+    "itertools._tee_dataobject.__getattribute__" => "Return getattr(self, name).",
+    "itertools._tee_dataobject.__getstate__" => "Helper for pickle.",
+    "itertools._tee_dataobject.__gt__" => "Return self>value.",
+    "itertools._tee_dataobject.__hash__" => "Return hash(self).",
+    "itertools._tee_dataobject.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools._tee_dataobject.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools._tee_dataobject.__le__" => "Return self<=value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools._tee_dataobject.__repr__" => "Return repr(self).",
+    "itertools._tee_dataobject.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools._tee_dataobject.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools._tee_dataobject.__str__" => "Return str(self).",
+    "itertools._tee_dataobject.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.accumulate" => "Return series of accumulated sums (or other binary function results).",
+    "itertools.accumulate.__delattr__" => "Implement delattr(self, name).",
+    "itertools.accumulate.__eq__" => "Return self==value.",
+    "itertools.accumulate.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.accumulate.__ge__" => "Return self>=value.",
+    "itertools.accumulate.__getattribute__" => "Return getattr(self, name).",
+    "itertools.accumulate.__getstate__" => "Helper for pickle.",
+    "itertools.accumulate.__gt__" => "Return self>value.",
+    "itertools.accumulate.__hash__" => "Return hash(self).",
+    "itertools.accumulate.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.accumulate.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.accumulate.__iter__" => "Implement iter(self).",
+    "itertools.accumulate.__le__" => "Return self<=value.",
+    "itertools.accumulate.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.batched" => "Batch data into tuples of length n. The last batch may be shorter than n.\n\nLoops over the input iterable and accumulates data into tuples\nup to size n.  The input is consumed lazily, just enough to\nfill a batch.  The result is yielded as soon as a batch is full\nor when the input iterable is exhausted.\n\n    >>> for batch in batched('ABCDEFG', 3):\n    ...     print(batch)\n    ...\n    ('A', 'B', 'C')\n    ('D', 'E', 'F')\n    ('G',)\n\nIf \"strict\" is True, raises a ValueError if the final batch is shorter\nthan n.",
+    "itertools.batched.__delattr__" => "Implement delattr(self, name).",
+    "itertools.batched.__eq__" => "Return self==value.",
+    "itertools.batched.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.batched.__ge__" => "Return self>=value.",
+    "itertools.batched.__getattribute__" => "Return getattr(self, name).",
+    "itertools.batched.__getstate__" => "Helper for pickle.",
+    "itertools.batched.__gt__" => "Return self>value.",
+    "itertools.batched.__hash__" => "Return hash(self).",
+    "itertools.batched.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.batched.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.batched.__iter__" => "Implement iter(self).",
+    "itertools.batched.__le__" => "Return self<=value.",
+    "itertools.batched.__lt__" => "Return self<value.",
+    "itertools.batched.__ne__" => "Return self!=value.",
+    "itertools.batched.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "itertools.batched.__next__" => "Implement next(self).",
+    "itertools.batched.__reduce__" => "Helper for pickle.",
+    "itertools.batched.__reduce_ex__" => "Helper for pickle.",
+    "itertools.batched.__repr__" => "Return repr(self).",
+    "itertools.batched.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.batched.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.batched.__str__" => "Return str(self).",
+    "itertools.batched.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.chain" => "Return a chain object whose .__next__() method returns elements from the\nfirst iterable until it is exhausted, then elements from the next\niterable, until all of the iterables are exhausted.",
+    "itertools.chain.__class_getitem__" => "See PEP 585",
+    "itertools.chain.__delattr__" => "Implement delattr(self, name).",
+    "itertools.chain.__eq__" => "Return self==value.",
+    "itertools.chain.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.chain.__ge__" => "Return self>=value.",
+    "itertools.chain.__getattribute__" => "Return getattr(self, name).",
+    "itertools.chain.__getstate__" => "Helper for pickle.",
+    "itertools.chain.__gt__" => "Return self>value.",
+    "itertools.chain.__hash__" => "Return hash(self).",
+    "itertools.chain.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.chain.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.chain.__iter__" => "Implement iter(self).",
+    "itertools.chain.__le__" => "Return self<=value.",
+    "itertools.chain.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.chain.from_iterable" => "Alternative chain() constructor taking a single iterable argument that evaluates lazily.",
+    "itertools.combinations" => "Return successive r-length combinations of elements in the iterable.\n\ncombinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)",
+    "itertools.combinations.__delattr__" => "Implement delattr(self, name).",
+    "itertools.combinations.__eq__" => "Return self==value.",
+    "itertools.combinations.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.combinations.__ge__" => "Return self>=value.",
+    "itertools.combinations.__getattribute__" => "Return getattr(self, name).",
+    "itertools.combinations.__getstate__" => "Helper for pickle.",
+    "itertools.combinations.__gt__" => "Return self>value.",
+    "itertools.combinations.__hash__" => "Return hash(self).",
+    "itertools.combinations.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.combinations.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.combinations.__iter__" => "Implement iter(self).",
+    "itertools.combinations.__le__" => "Return self<=value.",
+    "itertools.combinations.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.combinations_with_replacement" => "Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats.\n\ncombinations_with_replacement('ABC', 2) --> ('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')",
+    "itertools.combinations_with_replacement.__delattr__" => "Implement delattr(self, name).",
+    "itertools.combinations_with_replacement.__eq__" => "Return self==value.",
+    "itertools.combinations_with_replacement.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.combinations_with_replacement.__ge__" => "Return self>=value.",
+    "itertools.combinations_with_replacement.__getattribute__" => "Return getattr(self, name).",
+    "itertools.combinations_with_replacement.__getstate__" => "Helper for pickle.",
+    "itertools.combinations_with_replacement.__gt__" => "Return self>value.",
+    "itertools.combinations_with_replacement.__hash__" => "Return hash(self).",
+    "itertools.combinations_with_replacement.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.combinations_with_replacement.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.combinations_with_replacement.__iter__" => "Implement iter(self).",
+    "itertools.combinations_with_replacement.__le__" => "Return self<=value.",
+    "itertools.combinations_with_replacement.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.compress" => "Return data elements corresponding to true selector elements.\n\nForms a shorter iterator from selected data elements using the selectors to\nchoose the data elements.",
+    "itertools.compress.__delattr__" => "Implement delattr(self, name).",
+    "itertools.compress.__eq__" => "Return self==value.",
+    "itertools.compress.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.compress.__ge__" => "Return self>=value.",
+    "itertools.compress.__getattribute__" => "Return getattr(self, name).",
+    "itertools.compress.__getstate__" => "Helper for pickle.",
+    "itertools.compress.__gt__" => "Return self>value.",
+    "itertools.compress.__hash__" => "Return hash(self).",
+    "itertools.compress.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.compress.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.compress.__iter__" => "Implement iter(self).",
+    "itertools.compress.__le__" => "Return self<=value.",
+    "itertools.compress.__lt__" => "Return self<value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools.compress.__repr__" => "Return repr(self).",
+    "itertools.compress.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.compress.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.compress.__str__" => "Return str(self).",
+    "itertools.compress.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.count" => "Return a count object whose .__next__() method returns consecutive values.\n\nEquivalent to:\n    def count(firstval=0, step=1):\n        x = firstval\n        while 1:\n            yield x\n            x += step",
+    "itertools.count.__delattr__" => "Implement delattr(self, name).",
+    "itertools.count.__eq__" => "Return self==value.",
+    "itertools.count.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.count.__ge__" => "Return self>=value.",
+    "itertools.count.__getattribute__" => "Return getattr(self, name).",
+    "itertools.count.__getstate__" => "Helper for pickle.",
+    "itertools.count.__gt__" => "Return self>value.",
+    "itertools.count.__hash__" => "Return hash(self).",
+    "itertools.count.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.count.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.count.__iter__" => "Implement iter(self).",
+    "itertools.count.__le__" => "Return self<=value.",
+    "itertools.count.__lt__" => "Return self<value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools.count.__repr__" => "Return repr(self).",
+    "itertools.count.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.count.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.count.__str__" => "Return str(self).",
+    "itertools.count.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.cycle" => "Return elements from the iterable until it is exhausted. Then repeat the sequence indefinitely.",
+    "itertools.cycle.__delattr__" => "Implement delattr(self, name).",
+    "itertools.cycle.__eq__" => "Return self==value.",
+    "itertools.cycle.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.cycle.__ge__" => "Return self>=value.",
+    "itertools.cycle.__getattribute__" => "Return getattr(self, name).",
+    "itertools.cycle.__getstate__" => "Helper for pickle.",
+    "itertools.cycle.__gt__" => "Return self>value.",
+    "itertools.cycle.__hash__" => "Return hash(self).",
+    "itertools.cycle.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.cycle.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.cycle.__iter__" => "Implement iter(self).",
+    "itertools.cycle.__le__" => "Return self<=value.",
+    "itertools.cycle.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.dropwhile" => "Drop items from the iterable while predicate(item) is true.\n\nAfterwards, return every element until the iterable is exhausted.",
+    "itertools.dropwhile.__delattr__" => "Implement delattr(self, name).",
+    "itertools.dropwhile.__eq__" => "Return self==value.",
+    "itertools.dropwhile.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.dropwhile.__ge__" => "Return self>=value.",
+    "itertools.dropwhile.__getattribute__" => "Return getattr(self, name).",
+    "itertools.dropwhile.__getstate__" => "Helper for pickle.",
+    "itertools.dropwhile.__gt__" => "Return self>value.",
+    "itertools.dropwhile.__hash__" => "Return hash(self).",
+    "itertools.dropwhile.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.dropwhile.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.dropwhile.__iter__" => "Implement iter(self).",
+    "itertools.dropwhile.__le__" => "Return self<=value.",
+    "itertools.dropwhile.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.filterfalse" => "Return those items of iterable for which function(item) is false.\n\nIf function is None, return the items that are false.",
+    "itertools.filterfalse.__delattr__" => "Implement delattr(self, name).",
+    "itertools.filterfalse.__eq__" => "Return self==value.",
+    "itertools.filterfalse.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.filterfalse.__ge__" => "Return self>=value.",
+    "itertools.filterfalse.__getattribute__" => "Return getattr(self, name).",
+    "itertools.filterfalse.__getstate__" => "Helper for pickle.",
+    "itertools.filterfalse.__gt__" => "Return self>value.",
+    "itertools.filterfalse.__hash__" => "Return hash(self).",
+    "itertools.filterfalse.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.filterfalse.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.filterfalse.__iter__" => "Implement iter(self).",
+    "itertools.filterfalse.__le__" => "Return self<=value.",
+    "itertools.filterfalse.__lt__" => "Return self<value.",
+    "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_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.__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.",
+    "itertools.groupby.__ge__" => "Return self>=value.",
+    "itertools.groupby.__getattribute__" => "Return getattr(self, name).",
+    "itertools.groupby.__getstate__" => "Helper for pickle.",
+    "itertools.groupby.__gt__" => "Return self>value.",
+    "itertools.groupby.__hash__" => "Return hash(self).",
+    "itertools.groupby.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.groupby.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.groupby.__iter__" => "Implement iter(self).",
+    "itertools.groupby.__le__" => "Return self<=value.",
+    "itertools.groupby.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.islice" => "islice(iterable, stop) --> islice object\nislice(iterable, start, stop[, step]) --> islice object\n\nReturn an iterator whose next() method returns selected values from an\niterable.  If start is specified, will skip all preceding elements;\notherwise, start defaults to zero.  Step defaults to one.  If\nspecified as another value, step determines how many values are\nskipped between successive calls.  Works like a slice() on a list\nbut returns an iterator.",
+    "itertools.islice.__delattr__" => "Implement delattr(self, name).",
+    "itertools.islice.__eq__" => "Return self==value.",
+    "itertools.islice.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.islice.__ge__" => "Return self>=value.",
+    "itertools.islice.__getattribute__" => "Return getattr(self, name).",
+    "itertools.islice.__getstate__" => "Helper for pickle.",
+    "itertools.islice.__gt__" => "Return self>value.",
+    "itertools.islice.__hash__" => "Return hash(self).",
+    "itertools.islice.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.islice.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.islice.__iter__" => "Implement iter(self).",
+    "itertools.islice.__le__" => "Return self<=value.",
+    "itertools.islice.__lt__" => "Return self<value.",
+    "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_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.__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.",
+    "itertools.pairwise.__ge__" => "Return self>=value.",
+    "itertools.pairwise.__getattribute__" => "Return getattr(self, name).",
+    "itertools.pairwise.__getstate__" => "Helper for pickle.",
+    "itertools.pairwise.__gt__" => "Return self>value.",
+    "itertools.pairwise.__hash__" => "Return hash(self).",
+    "itertools.pairwise.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.pairwise.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.pairwise.__iter__" => "Implement iter(self).",
+    "itertools.pairwise.__le__" => "Return self<=value.",
+    "itertools.pairwise.__lt__" => "Return self<value.",
+    "itertools.pairwise.__ne__" => "Return self!=value.",
+    "itertools.pairwise.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "itertools.pairwise.__next__" => "Implement next(self).",
+    "itertools.pairwise.__reduce__" => "Helper for pickle.",
+    "itertools.pairwise.__reduce_ex__" => "Helper for pickle.",
+    "itertools.pairwise.__repr__" => "Return repr(self).",
+    "itertools.pairwise.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.pairwise.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.pairwise.__str__" => "Return str(self).",
+    "itertools.pairwise.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.permutations" => "Return successive r-length permutations of elements in the iterable.\n\npermutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)",
+    "itertools.permutations.__delattr__" => "Implement delattr(self, name).",
+    "itertools.permutations.__eq__" => "Return self==value.",
+    "itertools.permutations.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.permutations.__ge__" => "Return self>=value.",
+    "itertools.permutations.__getattribute__" => "Return getattr(self, name).",
+    "itertools.permutations.__getstate__" => "Helper for pickle.",
+    "itertools.permutations.__gt__" => "Return self>value.",
+    "itertools.permutations.__hash__" => "Return hash(self).",
+    "itertools.permutations.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.permutations.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.permutations.__iter__" => "Implement iter(self).",
+    "itertools.permutations.__le__" => "Return self<=value.",
+    "itertools.permutations.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.product" => "Cartesian product of input iterables.  Equivalent to nested for-loops.\n\nFor example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).\nThe leftmost iterators are in the outermost for-loop, so the output tuples\ncycle in a manner similar to an odometer (with the rightmost element changing\non every iteration).\n\nTo compute the product of an iterable with itself, specify the number\nof repetitions with the optional repeat keyword argument. For example,\nproduct(A, repeat=4) means the same as product(A, A, A, A).\n\nproduct('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)\nproduct((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...",
+    "itertools.product.__delattr__" => "Implement delattr(self, name).",
+    "itertools.product.__eq__" => "Return self==value.",
+    "itertools.product.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.product.__ge__" => "Return self>=value.",
+    "itertools.product.__getattribute__" => "Return getattr(self, name).",
+    "itertools.product.__getstate__" => "Helper for pickle.",
+    "itertools.product.__gt__" => "Return self>value.",
+    "itertools.product.__hash__" => "Return hash(self).",
+    "itertools.product.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.product.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.product.__iter__" => "Implement iter(self).",
+    "itertools.product.__le__" => "Return self<=value.",
+    "itertools.product.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.repeat" => "repeat(object [,times]) -> create an iterator which returns the object\nfor the specified number of times.  If not specified, returns the object\nendlessly.",
+    "itertools.repeat.__delattr__" => "Implement delattr(self, name).",
+    "itertools.repeat.__eq__" => "Return self==value.",
+    "itertools.repeat.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.repeat.__ge__" => "Return self>=value.",
+    "itertools.repeat.__getattribute__" => "Return getattr(self, name).",
+    "itertools.repeat.__getstate__" => "Helper for pickle.",
+    "itertools.repeat.__gt__" => "Return self>value.",
+    "itertools.repeat.__hash__" => "Return hash(self).",
+    "itertools.repeat.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.repeat.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.repeat.__iter__" => "Implement iter(self).",
+    "itertools.repeat.__le__" => "Return self<=value.",
+    "itertools.repeat.__length_hint__" => "Private method returning an estimate of len(list(it)).",
+    "itertools.repeat.__lt__" => "Return self<value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools.repeat.__repr__" => "Return repr(self).",
+    "itertools.repeat.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.repeat.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.repeat.__str__" => "Return str(self).",
+    "itertools.repeat.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.starmap" => "Return an iterator whose values are returned from the function evaluated with an argument tuple taken from the given sequence.",
+    "itertools.starmap.__delattr__" => "Implement delattr(self, name).",
+    "itertools.starmap.__eq__" => "Return self==value.",
+    "itertools.starmap.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.starmap.__ge__" => "Return self>=value.",
+    "itertools.starmap.__getattribute__" => "Return getattr(self, name).",
+    "itertools.starmap.__getstate__" => "Helper for pickle.",
+    "itertools.starmap.__gt__" => "Return self>value.",
+    "itertools.starmap.__hash__" => "Return hash(self).",
+    "itertools.starmap.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.starmap.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.starmap.__iter__" => "Implement iter(self).",
+    "itertools.starmap.__le__" => "Return self<=value.",
+    "itertools.starmap.__lt__" => "Return self<value.",
+    "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_ex__" => "Helper for pickle.",
+    "itertools.starmap.__repr__" => "Return repr(self).",
+    "itertools.starmap.__setattr__" => "Implement setattr(self, name, value).",
+    "itertools.starmap.__sizeof__" => "Size of object in memory, in bytes.",
+    "itertools.starmap.__str__" => "Return str(self).",
+    "itertools.starmap.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.takewhile" => "Return successive entries from an iterable as long as the predicate evaluates to true for each entry.",
+    "itertools.takewhile.__delattr__" => "Implement delattr(self, name).",
+    "itertools.takewhile.__eq__" => "Return self==value.",
+    "itertools.takewhile.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.takewhile.__ge__" => "Return self>=value.",
+    "itertools.takewhile.__getattribute__" => "Return getattr(self, name).",
+    "itertools.takewhile.__getstate__" => "Helper for pickle.",
+    "itertools.takewhile.__gt__" => "Return self>value.",
+    "itertools.takewhile.__hash__" => "Return hash(self).",
+    "itertools.takewhile.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.takewhile.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.takewhile.__iter__" => "Implement iter(self).",
+    "itertools.takewhile.__le__" => "Return self<=value.",
+    "itertools.takewhile.__lt__" => "Return self<value.",
+    "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_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).",
+    "itertools.tee" => "Returns a tuple of n independent iterators.",
+    "itertools.zip_longest" => "Return a zip_longest object whose .__next__() method returns a tuple where\nthe i-th element comes from the i-th iterable argument.  The .__next__()\nmethod continues until the longest iterable in the argument sequence\nis exhausted and then it raises StopIteration.  When the shorter iterables\nare exhausted, the fillvalue is substituted in their place.  The fillvalue\ndefaults to None or can be specified by a keyword argument.",
+    "itertools.zip_longest.__delattr__" => "Implement delattr(self, name).",
+    "itertools.zip_longest.__eq__" => "Return self==value.",
+    "itertools.zip_longest.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "itertools.zip_longest.__ge__" => "Return self>=value.",
+    "itertools.zip_longest.__getattribute__" => "Return getattr(self, name).",
+    "itertools.zip_longest.__getstate__" => "Helper for pickle.",
+    "itertools.zip_longest.__gt__" => "Return self>value.",
+    "itertools.zip_longest.__hash__" => "Return hash(self).",
+    "itertools.zip_longest.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "itertools.zip_longest.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "itertools.zip_longest.__iter__" => "Implement iter(self).",
+    "itertools.zip_longest.__le__" => "Return self<=value.",
+    "itertools.zip_longest.__lt__" => "Return self<value.",
+    "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_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).",
+    "marshal" => "This module contains functions that can read and write Python values in\na binary format. The format is specific to Python, but independent of\nmachine architecture issues.\n\nNot all Python object types are supported; in general, only objects\nwhose value is independent from a particular invocation of Python can be\nwritten and read by this module. The following types are supported:\nNone, integers, floating-point numbers, strings, bytes, bytearrays,\ntuples, lists, sets, dictionaries, and code objects, where it\nshould be understood that tuples, lists and dictionaries are only\nsupported as long as the values contained therein are themselves\nsupported; and recursive lists and dictionaries should not be written\n(they will cause infinite loops).\n\nVariables:\n\nversion -- indicates the format that the module uses. Version 0 is the\n    historical format, version 1 shares interned strings and version 2\n    uses a binary format for floating-point numbers.\n    Version 3 shares common object references (New in version 3.4).\n\nFunctions:\n\ndump() -- write value to a file\nload() -- read value from a file\ndumps() -- marshal value as a bytes object\nloads() -- read value from a bytes-like object",
+    "marshal.dump" => "Write the value on the open file.\n\n  value\n    Must be a supported type.\n  file\n    Must be a writeable binary file.\n  version\n    Indicates the data format that dump should use.\n  allow_code\n    Allow to write code objects.\n\nIf the value has (or contains an object that has) an unsupported type, a\nValueError exception is raised - but garbage data will also be written\nto the file. The object will not be properly read back by load().",
+    "marshal.dumps" => "Return the bytes object that would be written to a file by dump(value, file).\n\n  value\n    Must be a supported type.\n  version\n    Indicates the data format that dumps should use.\n  allow_code\n    Allow to write code objects.\n\nRaise a ValueError exception if value has (or contains an object that has) an\nunsupported type.",
+    "marshal.load" => "Read one value from the open file and return it.\n\n  file\n    Must be readable binary file.\n  allow_code\n    Allow to load code objects.\n\nIf no valid value is read (e.g. because the data has a different Python\nversion's incompatible marshal format), raise EOFError, ValueError or\nTypeError.\n\nNote: If an object containing an unsupported type was marshalled with\ndump(), load() will substitute None for the unmarshallable type.",
+    "marshal.loads" => "Convert the bytes-like object to a value.\n\n  allow_code\n    Allow to load code objects.\n\nIf no valid value is found, raise EOFError, ValueError or TypeError.  Extra\nbytes in the input are ignored.",
+    "math" => "This module provides access to the mathematical functions\ndefined by the C standard.",
+    "math.acos" => "Return the arc cosine (measured in radians) of x.\n\nThe result is between 0 and pi.",
+    "math.acosh" => "Return the inverse hyperbolic cosine of x.",
+    "math.asin" => "Return the arc sine (measured in radians) of x.\n\nThe result is between -pi/2 and pi/2.",
+    "math.asinh" => "Return the inverse hyperbolic sine of x.",
+    "math.atan" => "Return the arc tangent (measured in radians) of x.\n\nThe result is between -pi/2 and pi/2.",
+    "math.atan2" => "Return the arc tangent (measured in radians) of y/x.\n\nUnlike atan(y/x), the signs of both x and y are considered.",
+    "math.atanh" => "Return the inverse hyperbolic tangent of x.",
+    "math.cbrt" => "Return the cube root of x.",
+    "math.ceil" => "Return the ceiling of x as an Integral.\n\nThis is the smallest integer >= x.",
+    "math.comb" => "Number of ways to choose k items from n items without repetition and without order.\n\nEvaluates to n! / (k! * (n - k)!) when k <= n and evaluates\nto zero when k > n.\n\nAlso called the binomial coefficient because it is equivalent\nto the coefficient of k-th term in polynomial expansion of the\nexpression (1 + x)**n.\n\nRaises TypeError if either of the arguments are not integers.\nRaises ValueError if either of the arguments are negative.",
+    "math.copysign" => "Return a float with the magnitude (absolute value) of x but the sign of y.\n\nOn platforms that support signed zeros, copysign(1.0, -0.0)\nreturns -1.0.",
+    "math.cos" => "Return the cosine of x (measured in radians).",
+    "math.cosh" => "Return the hyperbolic cosine of x.",
+    "math.degrees" => "Convert angle x from radians to degrees.",
+    "math.dist" => "Return the Euclidean distance between two points p and q.\n\nThe points should be specified as sequences (or iterables) of\ncoordinates.  Both inputs must have the same dimension.\n\nRoughly equivalent to:\n    sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))",
+    "math.erf" => "Error function at x.",
+    "math.erfc" => "Complementary error function at x.",
+    "math.exp" => "Return e raised to the power of x.",
+    "math.exp2" => "Return 2 raised to the power of x.",
+    "math.expm1" => "Return exp(x)-1.\n\nThis function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.",
+    "math.fabs" => "Return the absolute value of the float x.",
+    "math.factorial" => "Find n!.",
+    "math.floor" => "Return the floor of x as an Integral.\n\nThis is the largest integer <= x.",
+    "math.fma" => "Fused multiply-add operation.\n\nCompute (x * y) + z with a single round.",
+    "math.fmod" => "Return fmod(x, y), according to platform C.\n\nx % y may differ.",
+    "math.frexp" => "Return the mantissa and exponent of x, as pair (m, e).\n\nm is a float and e is an int, such that x = m * 2.**e.\nIf x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.",
+    "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.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.",
+    "math.isnan" => "Return True if x is a NaN (not a number), and False otherwise.",
+    "math.isqrt" => "Return the integer part of the square root of the input.",
+    "math.lcm" => "Least Common Multiple.",
+    "math.ldexp" => "Return x * (2**i).\n\nThis is essentially the inverse of frexp().",
+    "math.lgamma" => "Natural logarithm of absolute value of Gamma function at x.",
+    "math.log" => "log(x, [base=math.e])\nReturn the logarithm of x to the given base.\n\nIf the base is not specified, returns the natural logarithm (base e) of x.",
+    "math.log10" => "Return the base 10 logarithm of x.",
+    "math.log1p" => "Return the natural logarithm of 1+x (base e).\n\nThe result is computed in a way which is accurate for x near zero.",
+    "math.log2" => "Return the base 2 logarithm of x.",
+    "math.modf" => "Return the fractional and integer parts of x.\n\nBoth results carry the sign of x and are floats.",
+    "math.nextafter" => "Return the floating-point value the given number of steps after x towards y.\n\nIf steps is not specified or is None, it defaults to 1.\n\nRaises a TypeError, if x or y is not a double, or if steps is not an integer.\nRaises ValueError if steps is negative.",
+    "math.perm" => "Number of ways to choose k items from n items without repetition and with order.\n\nEvaluates to n! / (n - k)! when k <= n and evaluates\nto zero when k > n.\n\nIf k is not specified or is None, then k defaults to n\nand the function returns n!.\n\nRaises TypeError if either of the arguments are not integers.\nRaises ValueError if either of the arguments are negative.",
+    "math.pow" => "Return x**y (x to the power of y).",
+    "math.prod" => "Calculate the product of all the elements in the input iterable.\n\nThe default start value for the product is 1.\n\nWhen the iterable is empty, return the start value.  This function is\nintended specifically for use with numeric values and may reject\nnon-numeric types.",
+    "math.radians" => "Convert angle x from degrees to radians.",
+    "math.remainder" => "Difference between x and the closest integer multiple of y.\n\nReturn x - n*y where n*y is the closest integer multiple of y.\nIn the case where x is exactly halfway between two multiples of\ny, the nearest even value of n is used. The result is always exact.",
+    "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.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.",
+    "math.ulp" => "Return the value of the least significant bit of the float x.",
+    "mmap.mmap" => "Windows: mmap(fileno, length[, tagname[, access[, offset]]])\n\nMaps length bytes from the file specified by the file handle fileno,\nand returns a mmap object.  If length is larger than the current size\nof the file, the file is extended to contain length bytes.  If length\nis 0, the maximum length of the map is the current size of the file,\nexcept that if the file is empty Windows raises an exception (you cannot\ncreate an empty mapping on Windows).\n\nUnix: mmap(fileno, length[, flags[, prot[, access[, offset[, trackfd]]]]])\n\nMaps length bytes from the file specified by the file descriptor fileno,\nand returns a mmap object.  If length is 0, the maximum length of the map\nwill be the current size of the file when mmap is called.\nflags specifies the nature of the mapping. MAP_PRIVATE creates a\nprivate copy-on-write mapping, so changes to the contents of the mmap\nobject will be private to this process, and MAP_SHARED creates a mapping\nthat's shared with all other processes mapping the same areas of the file.\nThe default value is MAP_SHARED.\n\nTo map anonymous memory, pass -1 as the fileno (both versions).",
+    "mmap.mmap.__buffer__" => "Return a buffer object that exposes the underlying memory of the object.",
+    "mmap.mmap.__delattr__" => "Implement delattr(self, name).",
+    "mmap.mmap.__delitem__" => "Delete self[key].",
+    "mmap.mmap.__eq__" => "Return self==value.",
+    "mmap.mmap.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "mmap.mmap.__ge__" => "Return self>=value.",
+    "mmap.mmap.__getattribute__" => "Return getattr(self, name).",
+    "mmap.mmap.__getitem__" => "Return self[key].",
+    "mmap.mmap.__getstate__" => "Helper for pickle.",
+    "mmap.mmap.__gt__" => "Return self>value.",
+    "mmap.mmap.__hash__" => "Return hash(self).",
+    "mmap.mmap.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "mmap.mmap.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "mmap.mmap.__le__" => "Return self<=value.",
+    "mmap.mmap.__len__" => "Return len(self).",
+    "mmap.mmap.__lt__" => "Return self<value.",
+    "mmap.mmap.__ne__" => "Return self!=value.",
+    "mmap.mmap.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "mmap.mmap.__reduce__" => "Helper for pickle.",
+    "mmap.mmap.__reduce_ex__" => "Helper for pickle.",
+    "mmap.mmap.__release_buffer__" => "Release the buffer object that exposes the underlying memory of the object.",
+    "mmap.mmap.__repr__" => "Return repr(self).",
+    "mmap.mmap.__setattr__" => "Implement setattr(self, name, value).",
+    "mmap.mmap.__setitem__" => "Set self[key] to value.",
+    "mmap.mmap.__sizeof__" => "Size of object in memory, in bytes.",
+    "mmap.mmap.__str__" => "Return str(self).",
+    "mmap.mmap.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "msvcrt.GetErrorMode" => "Wrapper around GetErrorMode.",
+    "msvcrt.SetErrorMode" => "Wrapper around SetErrorMode.",
+    "msvcrt.get_osfhandle" => "Return the file handle for the file descriptor fd.\n\nRaises OSError if fd is not recognized.",
+    "msvcrt.getch" => "Read a keypress and return the resulting character as a byte string.\n\nNothing is echoed to the console. This call will block if a keypress is\nnot already available, but will not wait for Enter to be pressed. If the\npressed key was a special function key, this will return '\\000' or\n'\\xe0'; the next call will return the keycode. The Control-C keypress\ncannot be read with this function.",
+    "msvcrt.getche" => "Similar to getch(), but the keypress will be echoed if possible.",
+    "msvcrt.getwch" => "Wide char variant of getch(), returning a Unicode value.",
+    "msvcrt.getwche" => "Wide char variant of getche(), returning a Unicode value.",
+    "msvcrt.heapmin" => "Minimize the malloc() heap.\n\nForce the malloc() heap to clean itself up and return unused blocks\nto the operating system. On failure, this raises OSError.",
+    "msvcrt.kbhit" => "Returns a nonzero value if a keypress is waiting to be read. Otherwise, return 0.",
+    "msvcrt.locking" => "Lock part of a file based on file descriptor fd from the C runtime.\n\nRaises OSError on failure. The locked region of the file extends from\nthe current file position for nbytes bytes, and may continue beyond\nthe end of the file. mode must be one of the LK_* constants listed\nbelow. Multiple regions in a file may be locked at the same time, but\nmay not overlap. Adjacent regions are not merged; they must be unlocked\nindividually.",
+    "msvcrt.open_osfhandle" => "Create a C runtime file descriptor from the file handle handle.\n\nThe flags parameter should be a bitwise OR of os.O_APPEND, os.O_RDONLY,\nand os.O_TEXT. The returned file descriptor may be used as a parameter\nto os.fdopen() to create a file object.",
+    "msvcrt.putch" => "Print the byte string char to the console without buffering.",
+    "msvcrt.putwch" => "Wide char variant of putch(), accepting a Unicode value.",
+    "msvcrt.setmode" => "Set the line-end translation mode for the file descriptor fd.\n\nTo set it to text mode, flags should be os.O_TEXT; for binary, it\nshould be os.O_BINARY.\n\nReturn value is the previous mode.",
+    "msvcrt.ungetch" => "Opposite of getch.\n\nCause the byte string char to be \"pushed back\" into the\nconsole buffer; it will be the next character read by\ngetch() or getche().",
+    "msvcrt.ungetwch" => "Wide char variant of ungetch(), accepting a Unicode value.",
+    "nt" => "This module provides access to operating system functionality that is\nstandardized by the C Standard and the POSIX standard (a thinly\ndisguised Unix interface).  Refer to the library manual and\ncorresponding Unix manual entries for more information on calls.",
+    "nt.DirEntry.__class_getitem__" => "See PEP 585",
+    "nt.DirEntry.__delattr__" => "Implement delattr(self, name).",
+    "nt.DirEntry.__eq__" => "Return self==value.",
+    "nt.DirEntry.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.DirEntry.__fspath__" => "Returns the path for the entry.",
+    "nt.DirEntry.__ge__" => "Return self>=value.",
+    "nt.DirEntry.__getattribute__" => "Return getattr(self, name).",
+    "nt.DirEntry.__getstate__" => "Helper for pickle.",
+    "nt.DirEntry.__gt__" => "Return self>value.",
+    "nt.DirEntry.__hash__" => "Return hash(self).",
+    "nt.DirEntry.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.DirEntry.__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.DirEntry.__le__" => "Return self<=value.",
+    "nt.DirEntry.__lt__" => "Return self<value.",
+    "nt.DirEntry.__ne__" => "Return self!=value.",
+    "nt.DirEntry.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.DirEntry.__reduce__" => "Helper for pickle.",
+    "nt.DirEntry.__reduce_ex__" => "Helper for pickle.",
+    "nt.DirEntry.__repr__" => "Return repr(self).",
+    "nt.DirEntry.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.DirEntry.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.DirEntry.__str__" => "Return str(self).",
+    "nt.DirEntry.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.DirEntry.inode" => "Return inode of the entry; cached per entry.",
+    "nt.DirEntry.is_dir" => "Return True if the entry is a directory; cached per entry.",
+    "nt.DirEntry.is_file" => "Return True if the entry is a file; cached per entry.",
+    "nt.DirEntry.is_junction" => "Return True if the entry is a junction; cached per entry.",
+    "nt.DirEntry.is_symlink" => "Return True if the entry is a symbolic link; cached per entry.",
+    "nt.DirEntry.name" => "the entry's base filename, relative to scandir() \"path\" argument",
+    "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._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.",
+    "nt._getfinalpathname" => "A helper function for samepath on windows.",
+    "nt._getvolumepathname" => "A helper function for ismount on Win32.",
+    "nt._inputhook" => "Calls PyOS_CallInputHook droppong the GIL first",
+    "nt._is_inputhook_installed" => "Checks if PyOS_CallInputHook is set",
+    "nt._path_exists" => "Test whether a path exists.  Returns False for broken symbolic links.",
+    "nt._path_isdevdrive" => "Determines whether the specified path is on a Windows Dev Drive.",
+    "nt._path_isdir" => "Return true if the pathname refers to an existing directory.",
+    "nt._path_isfile" => "Test whether a path is a regular file",
+    "nt._path_isjunction" => "Test whether a path is a junction",
+    "nt._path_islink" => "Test whether a path is a symbolic link",
+    "nt._path_lexists" => "Test whether a path exists.  Returns True for broken symbolic links.",
+    "nt._path_normpath" => "Normalize path, eliminating double slashes, etc.",
+    "nt._path_splitroot" => "Removes everything after the root on Win32.",
+    "nt._path_splitroot_ex" => "Split a pathname into drive, root and tail.\n\nThe tail contains anything after the root.",
+    "nt._remove_dll_directory" => "Removes a path from the DLL search path.\n\nThe parameter is an opaque value that was returned from\nos.add_dll_directory. You can only remove directories that you added\nyourself.",
+    "nt._supports_virtual_terminal" => "Checks if virtual terminal is supported in windows",
+    "nt.abort" => "Abort the interpreter immediately.\n\nThis function 'dumps core' or otherwise fails in the hardest way possible\non the hosting operating system.  This function never returns.",
+    "nt.access" => "Use the real uid/gid to test for access to a path.\n\n  path\n    Path to be tested; can be string, bytes, or a path-like object.\n  mode\n    Operating-system mode bitfield.  Can be F_OK to test existence,\n    or the inclusive-OR of R_OK, W_OK, and X_OK.\n  dir_fd\n    If 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\n    directory.\n  effective_ids\n    If True, access will use the effective uid/gid instead of\n    the real uid/gid.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    access will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd, effective_ids, and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nNote that most operations will use the effective uid/gid, therefore this\n  routine can be used in a suid/sgid environment to test if the invoking user\n  has the specified access to the path.",
+    "nt.chdir" => "Change the current working directory to the specified path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\nIf this functionality is unavailable, using it raises an exception.",
+    "nt.chmod" => "Change the access permissions of a file.\n\n  path\n    Path to be modified.  May always be specified as a str, bytes, or a path-like object.\n    On some platforms, path may also be specified as an open file descriptor.\n    If this functionality is unavailable, using it raises an exception.\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  dir_fd\n    If 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\n    directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    chmod will modify the symbolic link itself instead of the file\n    the link points to.\n\nIt is an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.\ndir_fd and follow_symlinks may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.",
+    "nt.close" => "Close a file descriptor.",
+    "nt.closerange" => "Closes all file descriptors in [fd_low, fd_high), ignoring errors.",
+    "nt.cpu_count" => "Return the number of logical CPUs in the system.\n\nReturn None if indeterminable.",
+    "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.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).",
+    "nt.fsync" => "Force write of fd to disk.",
+    "nt.ftruncate" => "Truncate a file, specified by file descriptor, to a specific length.",
+    "nt.get_blocking" => "Get the blocking mode of the file descriptor.\n\nReturn False if the O_NONBLOCK flag is set, True if the flag is cleared.",
+    "nt.get_handle_inheritable" => "Get the close-on-exe flag of the specified file descriptor.",
+    "nt.get_inheritable" => "Get the close-on-exe flag of the specified file descriptor.",
+    "nt.get_terminal_size" => "Return the size of the terminal window as (columns, lines).\n\nThe optional argument fd (default standard output) specifies\nwhich file descriptor should be queried.\n\nIf the file descriptor is not connected to a terminal, an OSError\nis thrown.\n\nThis function will only be defined if an implementation is\navailable for this system.\n\nshutil.get_terminal_size is the high-level function which should\nnormally be used, os.get_terminal_size is the low-level implementation.",
+    "nt.getcwd" => "Return a unicode string representing the current working directory.",
+    "nt.getcwdb" => "Return a bytes string representing the current working directory.",
+    "nt.getlogin" => "Return the actual login name.",
+    "nt.getpid" => "Return the current process id.",
+    "nt.getppid" => "Return the parent's process id.\n\nIf the parent process has already exited, Windows machines will still\nreturn its id; others systems will return the id of the 'init' process (1).",
+    "nt.isatty" => "Return True if the fd is connected to a terminal.\n\nReturn True if the file descriptor is an open file descriptor\nconnected to the slave end of a terminal.",
+    "nt.kill" => "Kill a process with a signal.",
+    "nt.lchmod" => "Change the access permissions of a file, without following symbolic links.\n\nIf path is a symlink, this affects the link itself rather than the target.\nEquivalent to chmod(path, mode, follow_symlinks=False).\"",
+    "nt.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.",
+    "nt.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.",
+    "nt.listdrives" => "Return a list containing the names of drives in the system.\n\nA drive name typically looks like 'C:\\\\'.",
+    "nt.listmounts" => "Return a list containing mount points for a particular volume.\n\n'volume' should be a GUID path as returned from os.listvolumes.",
+    "nt.listvolumes" => "Return a list containing the volumes in the system.\n\nVolumes are typically represented as a GUID path.",
+    "nt.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.",
+    "nt.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).",
+    "nt.mkdir" => "Create a directory.\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.\n\nThe mode argument is ignored on Windows. Where it is used, the current umask\nvalue is first masked out.",
+    "nt.open" => "Open a file for low level IO.  Returns a file descriptor (integer).\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.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.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.",
+    "nt.replace" => "Rename a file or directory, overwriting the destination.\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.",
+    "nt.rmdir" => "Remove a directory.\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.scandir" => "Return an iterator of DirEntry objects for given path.\n\npath can be specified as either str, bytes, or a path-like object.  If path\nis bytes, the names of yielded DirEntry objects will also be bytes; in\nall other circumstances they will be str.\n\nIf path is None, uses the path='.'.",
+    "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.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.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.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.",
+    "nt.times_result.__class_getitem__" => "See PEP 585",
+    "nt.times_result.__contains__" => "Return bool(key in self).",
+    "nt.times_result.__delattr__" => "Implement delattr(self, name).",
+    "nt.times_result.__eq__" => "Return self==value.",
+    "nt.times_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.times_result.__ge__" => "Return self>=value.",
+    "nt.times_result.__getattribute__" => "Return getattr(self, name).",
+    "nt.times_result.__getitem__" => "Return self[key].",
+    "nt.times_result.__getstate__" => "Helper for pickle.",
+    "nt.times_result.__gt__" => "Return self>value.",
+    "nt.times_result.__hash__" => "Return hash(self).",
+    "nt.times_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.times_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.times_result.__iter__" => "Implement iter(self).",
+    "nt.times_result.__le__" => "Return self<=value.",
+    "nt.times_result.__len__" => "Return len(self).",
+    "nt.times_result.__lt__" => "Return self<value.",
+    "nt.times_result.__mul__" => "Return self*value.",
+    "nt.times_result.__ne__" => "Return self!=value.",
+    "nt.times_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.times_result.__reduce_ex__" => "Helper for pickle.",
+    "nt.times_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "nt.times_result.__repr__" => "Return repr(self).",
+    "nt.times_result.__rmul__" => "Return value*self.",
+    "nt.times_result.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.times_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.times_result.__str__" => "Return str(self).",
+    "nt.times_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.times_result.children_system" => "system time of children",
+    "nt.times_result.children_user" => "user time of children",
+    "nt.times_result.count" => "Return number of occurrences of value.",
+    "nt.times_result.elapsed" => "elapsed time since an arbitrary point in the past",
+    "nt.times_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "nt.times_result.system" => "system time",
+    "nt.times_result.user" => "user time",
+    "nt.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.",
+    "nt.umask" => "Set the current numeric umask and return the previous umask.",
+    "nt.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.",
+    "nt.uname_result.__add__" => "Return self+value.",
+    "nt.uname_result.__class_getitem__" => "See PEP 585",
+    "nt.uname_result.__contains__" => "Return bool(key in self).",
+    "nt.uname_result.__delattr__" => "Implement delattr(self, name).",
+    "nt.uname_result.__eq__" => "Return self==value.",
+    "nt.uname_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "nt.uname_result.__ge__" => "Return self>=value.",
+    "nt.uname_result.__getattribute__" => "Return getattr(self, name).",
+    "nt.uname_result.__getitem__" => "Return self[key].",
+    "nt.uname_result.__getstate__" => "Helper for pickle.",
+    "nt.uname_result.__gt__" => "Return self>value.",
+    "nt.uname_result.__hash__" => "Return hash(self).",
+    "nt.uname_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "nt.uname_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.uname_result.__iter__" => "Implement iter(self).",
+    "nt.uname_result.__le__" => "Return self<=value.",
+    "nt.uname_result.__len__" => "Return len(self).",
+    "nt.uname_result.__lt__" => "Return self<value.",
+    "nt.uname_result.__mul__" => "Return self*value.",
+    "nt.uname_result.__ne__" => "Return self!=value.",
+    "nt.uname_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "nt.uname_result.__reduce_ex__" => "Helper for pickle.",
+    "nt.uname_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "nt.uname_result.__repr__" => "Return repr(self).",
+    "nt.uname_result.__rmul__" => "Return value*self.",
+    "nt.uname_result.__setattr__" => "Implement setattr(self, name, value).",
+    "nt.uname_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "nt.uname_result.__str__" => "Return str(self).",
+    "nt.uname_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.uname_result.count" => "Return number of occurrences of value.",
+    "nt.uname_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "nt.uname_result.machine" => "hardware identifier",
+    "nt.uname_result.nodename" => "name of machine on network (implementation-defined)",
+    "nt.uname_result.release" => "operating system release",
+    "nt.uname_result.sysname" => "operating system name",
+    "nt.uname_result.version" => "operating system version",
+    "nt.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.",
+    "nt.unsetenv" => "Delete an environment variable.",
+    "nt.urandom" => "Return a bytes object containing random bytes suitable for cryptographic use.",
+    "nt.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.",
+    "nt.waitpid" => "Wait for completion of a given process.\n\nReturns a tuple of information regarding the process:\n    (pid, status << 8)\n\nThe options argument is ignored on Windows.",
+    "nt.waitstatus_to_exitcode" => "Convert a wait status to an exit code.\n\nOn Unix:\n\n* If WIFEXITED(status) is true, return WEXITSTATUS(status).\n* If WIFSIGNALED(status) is true, return -WTERMSIG(status).\n* Otherwise, raise a ValueError.\n\nOn Windows, return status shifted right by 8 bits.\n\nOn Unix, if the process is being traced or if waitpid() was called with\nWUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.\nThis function must not be called if WIFSTOPPED(status) is true.",
+    "nt.write" => "Write a bytes object to a file descriptor.",
+    "posix" => "This module provides access to operating system functionality that is\nstandardized by the C Standard and the POSIX standard (a thinly\ndisguised Unix interface).  Refer to the library manual and\ncorresponding Unix manual entries for more information on calls.",
+    "posix.DirEntry.__class_getitem__" => "See PEP 585",
+    "posix.DirEntry.__delattr__" => "Implement delattr(self, name).",
+    "posix.DirEntry.__eq__" => "Return self==value.",
+    "posix.DirEntry.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.DirEntry.__fspath__" => "Returns the path for the entry.",
+    "posix.DirEntry.__ge__" => "Return self>=value.",
+    "posix.DirEntry.__getattribute__" => "Return getattr(self, name).",
+    "posix.DirEntry.__getstate__" => "Helper for pickle.",
+    "posix.DirEntry.__gt__" => "Return self>value.",
+    "posix.DirEntry.__hash__" => "Return hash(self).",
+    "posix.DirEntry.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.DirEntry.__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.DirEntry.__le__" => "Return self<=value.",
+    "posix.DirEntry.__lt__" => "Return self<value.",
+    "posix.DirEntry.__ne__" => "Return self!=value.",
+    "posix.DirEntry.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.DirEntry.__reduce__" => "Helper for pickle.",
+    "posix.DirEntry.__reduce_ex__" => "Helper for pickle.",
+    "posix.DirEntry.__repr__" => "Return repr(self).",
+    "posix.DirEntry.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.DirEntry.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.DirEntry.__str__" => "Return str(self).",
+    "posix.DirEntry.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.DirEntry.inode" => "Return inode of the entry; cached per entry.",
+    "posix.DirEntry.is_dir" => "Return True if the entry is a directory; cached per entry.",
+    "posix.DirEntry.is_file" => "Return True if the entry is a file; cached per entry.",
+    "posix.DirEntry.is_junction" => "Return True if the entry is a junction; cached per entry.",
+    "posix.DirEntry.is_symlink" => "Return True if the entry is a symbolic link; cached per entry.",
+    "posix.DirEntry.name" => "the entry's base filename, relative to scandir() \"path\" argument",
+    "posix.DirEntry.path" => "the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)",
+    "posix.DirEntry.stat" => "Return stat_result object for the entry; cached per entry.",
+    "posix.WCOREDUMP" => "Return True if the process returning status was dumped to a core file.",
+    "posix.WEXITSTATUS" => "Return the process return code from status.",
+    "posix.WIFCONTINUED" => "Return True if a particular process was continued from a job control stop.\n\nReturn True if the process returning status was continued from a\njob control stop.",
+    "posix.WIFEXITED" => "Return True if the process returning status exited via the exit() system call.",
+    "posix.WIFSIGNALED" => "Return True if the process returning status was terminated by a signal.",
+    "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._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",
+    "posix._is_inputhook_installed" => "Checks if PyOS_CallInputHook is set",
+    "posix._path_normpath" => "Normalize path, eliminating double slashes, etc.",
+    "posix._path_splitroot_ex" => "Split a pathname into drive, root and tail.\n\nThe tail contains anything after the root.",
+    "posix.abort" => "Abort the interpreter immediately.\n\nThis function 'dumps core' or otherwise fails in the hardest way possible\non the hosting operating system.  This function never returns.",
+    "posix.access" => "Use the real uid/gid to test for access to a path.\n\n  path\n    Path to be tested; can be string, bytes, or a path-like object.\n  mode\n    Operating-system mode bitfield.  Can be F_OK to test existence,\n    or the inclusive-OR of R_OK, W_OK, and X_OK.\n  dir_fd\n    If 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\n    directory.\n  effective_ids\n    If True, access will use the effective uid/gid instead of\n    the real uid/gid.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    access will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd, effective_ids, and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nNote that most operations will use the effective uid/gid, therefore this\n  routine can be used in a suid/sgid environment to test if the invoking user\n  has the specified access to the path.",
+    "posix.chdir" => "Change the current working directory to the specified path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\nIf this functionality is unavailable, using it raises an exception.",
+    "posix.chflags" => "Set file flags.\n\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, chflags will change flags on the symbolic link itself instead of the\n  file the link points to.\nfollow_symlinks may not be implemented on your platform.  If it is\nunavailable, using it will raise a NotImplementedError.",
+    "posix.chmod" => "Change the access permissions of a file.\n\n  path\n    Path to be modified.  May always be specified as a str, bytes, or a path-like object.\n    On some platforms, path may also be specified as an open file descriptor.\n    If this functionality is unavailable, using it raises an exception.\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  dir_fd\n    If 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\n    directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    chmod will modify the symbolic link itself instead of the file\n    the link points to.\n\nIt is an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.\ndir_fd and follow_symlinks may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.",
+    "posix.chown" => "Change the owner and group id of path to the numeric uid and gid.\\\n\n  path\n    Path to be examined; can be string, bytes, a path-like object, or 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 relative; path will then be relative to that\n    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\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.\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, chown 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 as\n  an open file descriptor.\ndir_fd and follow_symlinks may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.",
+    "posix.chroot" => "Change root directory to path.",
+    "posix.close" => "Close a file descriptor.",
+    "posix.closerange" => "Closes all file descriptors in [fd_low, fd_high), ignoring errors.",
+    "posix.confstr" => "Return a string-valued system configuration variable.",
+    "posix.copy_file_range" => "Copy count bytes from one file descriptor to another.\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\nIf offset_src is None, then src is read from the current position;\nrespectively for offset_dst.",
+    "posix.cpu_count" => "Return the number of logical CPUs in the system.\n\nReturn None if indeterminable.",
+    "posix.ctermid" => "Return the name of the controlling terminal for this process.",
+    "posix.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.",
+    "posix.dup" => "Return a duplicate of a file descriptor.",
+    "posix.dup2" => "Duplicate file descriptor.",
+    "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.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).",
+    "posix.fdatasync" => "Force write of fd to disk without forcing update of metadata.",
+    "posix.fork" => "Fork a child process.\n\nReturn 0 to child process and PID of child to parent process.",
+    "posix.forkpty" => "Fork a new process with a new pseudo-terminal as controlling tty.\n\nReturns a tuple of (pid, master_fd).\nLike fork(), return pid of 0 to the child process,\nand pid of child to the parent process.\nTo both, return fd of newly opened pseudo-terminal.",
+    "posix.fpathconf" => "Return the configuration limit name for the file descriptor fd.\n\nIf there is no limit, return -1.",
+    "posix.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.",
+    "posix.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).",
+    "posix.fstatvfs" => "Perform an fstatvfs system call on the given fd.\n\nEquivalent to statvfs(fd).",
+    "posix.fsync" => "Force write of fd to disk.",
+    "posix.ftruncate" => "Truncate a file, specified by file descriptor, to a specific length.",
+    "posix.get_blocking" => "Get the blocking mode of the file descriptor.\n\nReturn False if the O_NONBLOCK flag is set, True if the flag is cleared.",
+    "posix.get_inheritable" => "Get the close-on-exe flag of the specified file descriptor.",
+    "posix.get_terminal_size" => "Return the size of the terminal window as (columns, lines).\n\nThe optional argument fd (default standard output) specifies\nwhich file descriptor should be queried.\n\nIf the file descriptor is not connected to a terminal, an OSError\nis thrown.\n\nThis function will only be defined if an implementation is\navailable for this system.\n\nshutil.get_terminal_size is the high-level function which should\nnormally be used, os.get_terminal_size is the low-level implementation.",
+    "posix.getcwd" => "Return a unicode string representing the current working directory.",
+    "posix.getcwdb" => "Return a bytes string representing the current working directory.",
+    "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.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.",
+    "posix.getpgid" => "Call the system call getpgid(), and return the result.",
+    "posix.getpgrp" => "Return the current process group id.",
+    "posix.getpid" => "Return the current process id.",
+    "posix.getppid" => "Return the parent's process id.\n\nIf the parent process has already exited, Windows machines will still\nreturn its id; others systems will return the id of the 'init' process (1).",
+    "posix.getpriority" => "Return program scheduling priority.",
+    "posix.getrandom" => "Obtain a series of random bytes.",
+    "posix.getresgid" => "Return a tuple of the current process's real, effective, and saved group ids.",
+    "posix.getresuid" => "Return a tuple of the current process's real, effective, and saved user ids.",
+    "posix.getsid" => "Call the system call getsid(pid) and return the result.",
+    "posix.getuid" => "Return the current process's user id.",
+    "posix.getxattr" => "Return the value of extended attribute attribute on path.\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, getxattr will examine the symbolic link itself instead of the file\n  the link points to.",
+    "posix.grantpt" => "Grant access to the slave pseudo-terminal device.\n\n  fd\n    File descriptor of a master pseudo-terminal device.\n\nPerforms a grantpt() C function call.",
+    "posix.initgroups" => "Initialize the group access list.\n\nCall the system initgroups() to initialize the group access list with all of\nthe groups of which the specified username is a member, plus the specified\ngroup id.",
+    "posix.isatty" => "Return True if the fd is connected to a terminal.\n\nReturn True if the file descriptor is an open file descriptor\nconnected to the slave end of a terminal.",
+    "posix.kill" => "Kill a process with a signal.",
+    "posix.killpg" => "Kill a process group with a signal.",
+    "posix.lchflags" => "Set file flags.\n\nThis function will not follow symbolic links.\nEquivalent to chflags(path, flags, follow_symlinks=False).",
+    "posix.lchmod" => "Change the access permissions of a file, without following symbolic links.\n\nIf path is a symlink, this affects the link itself rather than the target.\nEquivalent to chmod(path, mode, follow_symlinks=False).\"",
+    "posix.lchown" => "Change the owner and group id of path to the numeric uid and gid.\n\nThis function will not follow symbolic links.\nEquivalent to os.chown(path, uid, gid, follow_symlinks=False).",
+    "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.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).",
+    "posix.major" => "Extracts a device major number from a raw device number.",
+    "posix.makedev" => "Composes a raw device number from the major and minor device numbers.",
+    "posix.minor" => "Extracts a device minor number from a raw device number.",
+    "posix.mkdir" => "Create a directory.\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.\n\nThe mode argument is ignored on Windows. Where it is used, the current umask\nvalue is first masked out.",
+    "posix.mkfifo" => "Create a \"fifo\" (a POSIX named pipe).\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.mknod" => "Create a node in the file system.\n\nCreate a node in the file system (file, device special file or named pipe)\nat path.  mode specifies both the permissions to use and the\ntype of node to be created, being combined (bitwise OR) with one of\nS_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO.  If S_IFCHR or S_IFBLK is set on mode,\ndevice defines the newly created device special file (probably using\nos.makedev()).  Otherwise device is ignored.\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.nice" => "Add increment to the priority of process and return the new priority.",
+    "posix.open" => "Open a file for low level IO.  Returns a file descriptor (integer).\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.openpty" => "Open a pseudo-terminal.\n\nReturn a tuple of (master_fd, slave_fd) containing open file descriptors\nfor both the master and slave ends.",
+    "posix.pathconf" => "Return the configuration limit name for the file or directory path.\n\nIf there is no limit, return -1.\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.pidfd_open" => "Return a file descriptor referring to the process *pid*.\n\nThe descriptor can be used to perform process management without races and\nsignals.",
+    "posix.pipe" => "Create a pipe.\n\nReturns a tuple of two file descriptors:\n  (read_fd, write_fd)",
+    "posix.pipe2" => "Create a pipe with flags set atomically.\n\nReturns a tuple of two file descriptors:\n  (read_fd, write_fd)\n\nflags can be constructed by ORing together one or more of these values:\nO_NONBLOCK, O_CLOEXEC.",
+    "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.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.",
+    "posix.putenv" => "Change or add an environment variable.",
+    "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.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.",
+    "posix.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.",
+    "posix.removexattr" => "Remove extended attribute attribute on path.\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, removexattr will modify the symbolic link itself instead of the file\n  the link points to.",
+    "posix.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.",
+    "posix.replace" => "Rename a file or directory, overwriting the destination.\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.",
+    "posix.rmdir" => "Remove a directory.\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.scandir" => "Return an iterator of DirEntry objects for given path.\n\npath can be specified as either str, bytes, or a path-like object.  If path\nis bytes, the names of yielded DirEntry objects will also be bytes; in\nall other circumstances they will be str.\n\nIf path is None, uses the path='.'.",
+    "posix.sched_get_priority_max" => "Get the maximum scheduling priority for policy.",
+    "posix.sched_get_priority_min" => "Get the minimum scheduling priority for policy.",
+    "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.__add__" => "Return self+value.",
+    "posix.sched_param.__class_getitem__" => "See PEP 585",
+    "posix.sched_param.__contains__" => "Return bool(key in self).",
+    "posix.sched_param.__delattr__" => "Implement delattr(self, name).",
+    "posix.sched_param.__eq__" => "Return self==value.",
+    "posix.sched_param.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.sched_param.__ge__" => "Return self>=value.",
+    "posix.sched_param.__getattribute__" => "Return getattr(self, name).",
+    "posix.sched_param.__getitem__" => "Return self[key].",
+    "posix.sched_param.__getstate__" => "Helper for pickle.",
+    "posix.sched_param.__gt__" => "Return self>value.",
+    "posix.sched_param.__hash__" => "Return hash(self).",
+    "posix.sched_param.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.sched_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.",
+    "posix.sched_param.__iter__" => "Implement iter(self).",
+    "posix.sched_param.__le__" => "Return self<=value.",
+    "posix.sched_param.__len__" => "Return len(self).",
+    "posix.sched_param.__lt__" => "Return self<value.",
+    "posix.sched_param.__mul__" => "Return self*value.",
+    "posix.sched_param.__ne__" => "Return self!=value.",
+    "posix.sched_param.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.sched_param.__reduce_ex__" => "Helper for pickle.",
+    "posix.sched_param.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.sched_param.__repr__" => "Return repr(self).",
+    "posix.sched_param.__rmul__" => "Return value*self.",
+    "posix.sched_param.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.sched_param.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.sched_param.__str__" => "Return str(self).",
+    "posix.sched_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).",
+    "posix.sched_param.count" => "Return number of occurrences of value.",
+    "posix.sched_param.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "posix.sched_param.sched_priority" => "the scheduling priority",
+    "posix.sched_rr_get_interval" => "Return the round-robin quantum for the process identified by pid, in seconds.\n\nValue returned is a float.",
+    "posix.sched_setaffinity" => "Set the CPU affinity of the process identified by pid to mask.\n\nmask should be an iterable of integers identifying CPUs.",
+    "posix.sched_setparam" => "Set scheduling parameters for the process identified by pid.\n\nIf pid is 0, sets parameters for the calling process.\nparam should be an instance of sched_param.",
+    "posix.sched_setscheduler" => "Set the scheduling policy for the process identified by pid.\n\nIf pid is 0, the calling process is changed.\nparam is an instance of sched_param.",
+    "posix.sched_yield" => "Voluntarily relinquish the CPU.",
+    "posix.sendfile" => "Copy count bytes from file descriptor in_fd to file descriptor out_fd.",
+    "posix.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.",
+    "posix.set_inheritable" => "Set the inheritable flag of the specified file descriptor.",
+    "posix.setegid" => "Set the current process's effective group id.",
+    "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.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.",
+    "posix.setregid" => "Set the current process's real and effective group ids.",
+    "posix.setresgid" => "Set the current process's real, effective, and saved group ids.",
+    "posix.setresuid" => "Set the current process's real, effective, and saved user ids.",
+    "posix.setreuid" => "Set the current process's real and effective user ids.",
+    "posix.setsid" => "Call the system call setsid().",
+    "posix.setuid" => "Set the current process's user id.",
+    "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.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.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.",
+    "posix.sysconf" => "Return an integer-valued system configuration variable.",
+    "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.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.",
+    "posix.times_result.__class_getitem__" => "See PEP 585",
+    "posix.times_result.__contains__" => "Return bool(key in self).",
+    "posix.times_result.__delattr__" => "Implement delattr(self, name).",
+    "posix.times_result.__eq__" => "Return self==value.",
+    "posix.times_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.times_result.__ge__" => "Return self>=value.",
+    "posix.times_result.__getattribute__" => "Return getattr(self, name).",
+    "posix.times_result.__getitem__" => "Return self[key].",
+    "posix.times_result.__getstate__" => "Helper for pickle.",
+    "posix.times_result.__gt__" => "Return self>value.",
+    "posix.times_result.__hash__" => "Return hash(self).",
+    "posix.times_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.times_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.times_result.__iter__" => "Implement iter(self).",
+    "posix.times_result.__le__" => "Return self<=value.",
+    "posix.times_result.__len__" => "Return len(self).",
+    "posix.times_result.__lt__" => "Return self<value.",
+    "posix.times_result.__mul__" => "Return self*value.",
+    "posix.times_result.__ne__" => "Return self!=value.",
+    "posix.times_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.times_result.__reduce_ex__" => "Helper for pickle.",
+    "posix.times_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.times_result.__repr__" => "Return repr(self).",
+    "posix.times_result.__rmul__" => "Return value*self.",
+    "posix.times_result.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.times_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.times_result.__str__" => "Return str(self).",
+    "posix.times_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.times_result.children_system" => "system time of children",
+    "posix.times_result.children_user" => "user time of children",
+    "posix.times_result.count" => "Return number of occurrences of value.",
+    "posix.times_result.elapsed" => "elapsed time since an arbitrary point in the past",
+    "posix.times_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "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.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.",
+    "posix.uname_result.__add__" => "Return self+value.",
+    "posix.uname_result.__class_getitem__" => "See PEP 585",
+    "posix.uname_result.__contains__" => "Return bool(key in self).",
+    "posix.uname_result.__delattr__" => "Implement delattr(self, name).",
+    "posix.uname_result.__eq__" => "Return self==value.",
+    "posix.uname_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.uname_result.__ge__" => "Return self>=value.",
+    "posix.uname_result.__getattribute__" => "Return getattr(self, name).",
+    "posix.uname_result.__getitem__" => "Return self[key].",
+    "posix.uname_result.__getstate__" => "Helper for pickle.",
+    "posix.uname_result.__gt__" => "Return self>value.",
+    "posix.uname_result.__hash__" => "Return hash(self).",
+    "posix.uname_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.uname_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.uname_result.__iter__" => "Implement iter(self).",
+    "posix.uname_result.__le__" => "Return self<=value.",
+    "posix.uname_result.__len__" => "Return len(self).",
+    "posix.uname_result.__lt__" => "Return self<value.",
+    "posix.uname_result.__mul__" => "Return self*value.",
+    "posix.uname_result.__ne__" => "Return self!=value.",
+    "posix.uname_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.uname_result.__reduce_ex__" => "Helper for pickle.",
+    "posix.uname_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.uname_result.__repr__" => "Return repr(self).",
+    "posix.uname_result.__rmul__" => "Return value*self.",
+    "posix.uname_result.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.uname_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.uname_result.__str__" => "Return str(self).",
+    "posix.uname_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.uname_result.count" => "Return number of occurrences of value.",
+    "posix.uname_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "posix.uname_result.machine" => "hardware identifier",
+    "posix.uname_result.nodename" => "name of machine on network (implementation-defined)",
+    "posix.uname_result.release" => "operating system release",
+    "posix.uname_result.sysname" => "operating system name",
+    "posix.uname_result.version" => "operating system version",
+    "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.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)",
+    "posix.wait3" => "Wait for completion of a child process.\n\nReturns a tuple of information about the child process:\n  (pid, status, rusage)",
+    "posix.wait4" => "Wait for completion of a specific child process.\n\nReturns a tuple of information about the child process:\n  (pid, status, rusage)",
+    "posix.waitid" => "Returns the result of waiting for a process or processes.\n\n  idtype\n    Must be one of be P_PID, P_PGID or P_ALL.\n  id\n    The id to wait on.\n  options\n    Constructed from the ORing of one or more of WEXITED, WSTOPPED\n    or WCONTINUED and additionally may be ORed with WNOHANG or WNOWAIT.\n\nReturns either waitid_result or None if WNOHANG is specified and there are\nno children in a waitable state.",
+    "posix.waitid_result" => "waitid_result: Result from waitid.\n\nThis object may be accessed either as a tuple of\n  (si_pid, si_uid, si_signo, si_status, si_code),\nor via the attributes si_pid, si_uid, and so on.\n\nSee os.waitid for more information.",
+    "posix.waitid_result.__add__" => "Return self+value.",
+    "posix.waitid_result.__class_getitem__" => "See PEP 585",
+    "posix.waitid_result.__contains__" => "Return bool(key in self).",
+    "posix.waitid_result.__delattr__" => "Implement delattr(self, name).",
+    "posix.waitid_result.__eq__" => "Return self==value.",
+    "posix.waitid_result.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "posix.waitid_result.__ge__" => "Return self>=value.",
+    "posix.waitid_result.__getattribute__" => "Return getattr(self, name).",
+    "posix.waitid_result.__getitem__" => "Return self[key].",
+    "posix.waitid_result.__getstate__" => "Helper for pickle.",
+    "posix.waitid_result.__gt__" => "Return self>value.",
+    "posix.waitid_result.__hash__" => "Return hash(self).",
+    "posix.waitid_result.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "posix.waitid_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.waitid_result.__iter__" => "Implement iter(self).",
+    "posix.waitid_result.__le__" => "Return self<=value.",
+    "posix.waitid_result.__len__" => "Return len(self).",
+    "posix.waitid_result.__lt__" => "Return self<value.",
+    "posix.waitid_result.__mul__" => "Return self*value.",
+    "posix.waitid_result.__ne__" => "Return self!=value.",
+    "posix.waitid_result.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "posix.waitid_result.__reduce_ex__" => "Helper for pickle.",
+    "posix.waitid_result.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "posix.waitid_result.__repr__" => "Return repr(self).",
+    "posix.waitid_result.__rmul__" => "Return value*self.",
+    "posix.waitid_result.__setattr__" => "Implement setattr(self, name, value).",
+    "posix.waitid_result.__sizeof__" => "Size of object in memory, in bytes.",
+    "posix.waitid_result.__str__" => "Return str(self).",
+    "posix.waitid_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.waitid_result.count" => "Return number of occurrences of value.",
+    "posix.waitid_result.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "posix.waitpid" => "Wait for completion of a given child process.\n\nReturns a tuple of information regarding the child process:\n    (pid, status)\n\nThe options argument is ignored on Windows.",
+    "posix.waitstatus_to_exitcode" => "Convert a wait status to an exit code.\n\nOn Unix:\n\n* If WIFEXITED(status) is true, return WEXITSTATUS(status).\n* If WIFSIGNALED(status) is true, return -WTERMSIG(status).\n* Otherwise, raise a ValueError.\n\nOn Windows, return status shifted right by 8 bits.\n\nOn Unix, if the process is being traced or if waitpid() was called with\nWUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.\nThis function must not be called if WIFSTOPPED(status) is true.",
+    "posix.write" => "Write a bytes object to a file descriptor.",
+    "posix.writev" => "Iterate over buffers, and write the contents of each to a file descriptor.\n\nReturns the total number of bytes written.\nbuffers must be a sequence of bytes-like objects.",
+    "pwd" => "This module provides access to the Unix password database.\nIt is available on all Unix versions.\n\nPassword database entries are reported as 7-tuples containing the following\nitems from the password database (see `<pwd.h>'), in order:\npw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell.\nThe uid and gid items are integers, all others are strings. An\nexception is raised if the entry asked for cannot be found.",
+    "pwd.getpwall" => "Return a list of all available password database entries, in arbitrary order.\n\nSee help(pwd) for more on password database entries.",
+    "pwd.getpwnam" => "Return the password database entry for the given user name.\n\nSee `help(pwd)` for more on password database entries.",
+    "pwd.getpwuid" => "Return the password database entry for the given numeric user ID.\n\nSee `help(pwd)` for more on password database entries.",
+    "pwd.struct_passwd" => "pwd.struct_passwd: Results from getpw*() routines.\n\nThis object may be accessed either as a tuple of\n  (pw_name,pw_passwd,pw_uid,pw_gid,pw_gecos,pw_dir,pw_shell)\nor via the object attributes as named in the above tuple.",
+    "pwd.struct_passwd.__add__" => "Return self+value.",
+    "pwd.struct_passwd.__class_getitem__" => "See PEP 585",
+    "pwd.struct_passwd.__contains__" => "Return bool(key in self).",
+    "pwd.struct_passwd.__delattr__" => "Implement delattr(self, name).",
+    "pwd.struct_passwd.__eq__" => "Return self==value.",
+    "pwd.struct_passwd.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "pwd.struct_passwd.__ge__" => "Return self>=value.",
+    "pwd.struct_passwd.__getattribute__" => "Return getattr(self, name).",
+    "pwd.struct_passwd.__getitem__" => "Return self[key].",
+    "pwd.struct_passwd.__getstate__" => "Helper for pickle.",
+    "pwd.struct_passwd.__gt__" => "Return self>value.",
+    "pwd.struct_passwd.__hash__" => "Return hash(self).",
+    "pwd.struct_passwd.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "pwd.struct_passwd.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "pwd.struct_passwd.__iter__" => "Implement iter(self).",
+    "pwd.struct_passwd.__le__" => "Return self<=value.",
+    "pwd.struct_passwd.__len__" => "Return len(self).",
+    "pwd.struct_passwd.__lt__" => "Return self<value.",
+    "pwd.struct_passwd.__mul__" => "Return self*value.",
+    "pwd.struct_passwd.__ne__" => "Return self!=value.",
+    "pwd.struct_passwd.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "pwd.struct_passwd.__reduce_ex__" => "Helper for pickle.",
+    "pwd.struct_passwd.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "pwd.struct_passwd.__repr__" => "Return repr(self).",
+    "pwd.struct_passwd.__rmul__" => "Return value*self.",
+    "pwd.struct_passwd.__setattr__" => "Implement setattr(self, name, value).",
+    "pwd.struct_passwd.__sizeof__" => "Size of object in memory, in bytes.",
+    "pwd.struct_passwd.__str__" => "Return str(self).",
+    "pwd.struct_passwd.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "pwd.struct_passwd.count" => "Return number of occurrences of value.",
+    "pwd.struct_passwd.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "pwd.struct_passwd.pw_dir" => "home directory",
+    "pwd.struct_passwd.pw_gecos" => "real name",
+    "pwd.struct_passwd.pw_gid" => "group id",
+    "pwd.struct_passwd.pw_name" => "user name",
+    "pwd.struct_passwd.pw_passwd" => "password",
+    "pwd.struct_passwd.pw_shell" => "shell program",
+    "pwd.struct_passwd.pw_uid" => "user id",
+    "pyexpat" => "Python wrapper for Expat parser.",
+    "pyexpat.ErrorString" => "Returns string error for given number.",
+    "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.ParseFile" => "Parse XML data from file-like object.",
+    "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.",
+    "pyexpat.XMLParserType.UseForeignDTD" => "Allows the application to provide an artificial external subset if one is not specified as part of the document instance.\n\nThis readily allows the use of a 'default' document type controlled by the\napplication, while still getting the advantage of providing document type\ninformation to the parser. 'flag' defaults to True if not provided.",
+    "pyexpat.XMLParserType.__delattr__" => "Implement delattr(self, name).",
+    "pyexpat.XMLParserType.__eq__" => "Return self==value.",
+    "pyexpat.XMLParserType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "pyexpat.XMLParserType.__ge__" => "Return self>=value.",
+    "pyexpat.XMLParserType.__getattribute__" => "Return getattr(self, name).",
+    "pyexpat.XMLParserType.__getstate__" => "Helper for pickle.",
+    "pyexpat.XMLParserType.__gt__" => "Return self>value.",
+    "pyexpat.XMLParserType.__hash__" => "Return hash(self).",
+    "pyexpat.XMLParserType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "pyexpat.XMLParserType.__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.XMLParserType.__le__" => "Return self<=value.",
+    "pyexpat.XMLParserType.__lt__" => "Return self<value.",
+    "pyexpat.XMLParserType.__ne__" => "Return self!=value.",
+    "pyexpat.XMLParserType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "pyexpat.XMLParserType.__reduce__" => "Helper for pickle.",
+    "pyexpat.XMLParserType.__reduce_ex__" => "Helper for pickle.",
+    "pyexpat.XMLParserType.__repr__" => "Return repr(self).",
+    "pyexpat.XMLParserType.__setattr__" => "Implement setattr(self, name, value).",
+    "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).",
+    "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.",
+    "readline.clear_history" => "Clear the current readline history.",
+    "readline.get_begidx" => "Get the beginning index of the completion scope.",
+    "readline.get_completer" => "Get the current completer function.",
+    "readline.get_completer_delims" => "Get the word delimiters for completion.",
+    "readline.get_completion_type" => "Get the type of completion being attempted.",
+    "readline.get_current_history_length" => "Return the current (not the maximum) length of history.",
+    "readline.get_endidx" => "Get the ending index of the completion scope.",
+    "readline.get_history_item" => "Return the current contents of history item at one-based index.",
+    "readline.get_history_length" => "Return the maximum number of lines that will be written to the history file.",
+    "readline.get_line_buffer" => "Return the current contents of the line buffer.",
+    "readline.insert_text" => "Insert text into the line buffer at the cursor position.",
+    "readline.parse_and_bind" => "Execute the init line provided in the string argument.",
+    "readline.read_history_file" => "Load a readline history file.\n\nThe default filename is ~/.history.",
+    "readline.read_init_file" => "Execute a readline initialization file.\n\nThe default filename is the last filename used.",
+    "readline.redisplay" => "Change what's displayed on the screen to reflect contents of the line buffer.",
+    "readline.remove_history_item" => "Remove history item given by its zero-based position.",
+    "readline.replace_history_item" => "Replaces history item given by its position with contents of line.\n\npos is zero-based.",
+    "readline.set_auto_history" => "Enables or disables automatic history.",
+    "readline.set_completer" => "Set or remove the completer function.\n\nThe function is called as function(text, state),\nfor state in 0, 1, 2, ..., until it returns a non-string.\nIt should return the next possible completion starting with 'text'.",
+    "readline.set_completer_delims" => "Set the word delimiters for completion.",
+    "readline.set_completion_display_matches_hook" => "Set or remove the completion display function.\n\nThe function is called as\n  function(substitution, [matches], longest_match_length)\nonce each time matches need to be displayed.",
+    "readline.set_history_length" => "Set the maximal number of lines which will be written to the history file.\n\nA negative length is used to inhibit history truncation.",
+    "readline.set_pre_input_hook" => "Set or remove the function invoked by the rl_pre_input_hook callback.\n\nThe function is called with no arguments after the first prompt\nhas been printed and just before readline starts reading input\ncharacters.",
+    "readline.set_startup_hook" => "Set or remove the function invoked by the rl_startup_hook callback.\n\nThe function is called with no arguments just\nbefore readline prints the first prompt.",
+    "readline.write_history_file" => "Save a readline history file.\n\nThe default filename is ~/.history.",
+    "resource.struct_rusage" => "struct_rusage: Result from getrusage.\n\nThis object may be accessed either as a tuple of\n    (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n    nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\nor via the attributes ru_utime, ru_stime, ru_maxrss, and so on.",
+    "resource.struct_rusage.__add__" => "Return self+value.",
+    "resource.struct_rusage.__class_getitem__" => "See PEP 585",
+    "resource.struct_rusage.__contains__" => "Return bool(key in self).",
+    "resource.struct_rusage.__delattr__" => "Implement delattr(self, name).",
+    "resource.struct_rusage.__eq__" => "Return self==value.",
+    "resource.struct_rusage.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "resource.struct_rusage.__ge__" => "Return self>=value.",
+    "resource.struct_rusage.__getattribute__" => "Return getattr(self, name).",
+    "resource.struct_rusage.__getitem__" => "Return self[key].",
+    "resource.struct_rusage.__getstate__" => "Helper for pickle.",
+    "resource.struct_rusage.__gt__" => "Return self>value.",
+    "resource.struct_rusage.__hash__" => "Return hash(self).",
+    "resource.struct_rusage.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "resource.struct_rusage.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "resource.struct_rusage.__iter__" => "Implement iter(self).",
+    "resource.struct_rusage.__le__" => "Return self<=value.",
+    "resource.struct_rusage.__len__" => "Return len(self).",
+    "resource.struct_rusage.__lt__" => "Return self<value.",
+    "resource.struct_rusage.__mul__" => "Return self*value.",
+    "resource.struct_rusage.__ne__" => "Return self!=value.",
+    "resource.struct_rusage.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "resource.struct_rusage.__reduce_ex__" => "Helper for pickle.",
+    "resource.struct_rusage.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "resource.struct_rusage.__repr__" => "Return repr(self).",
+    "resource.struct_rusage.__rmul__" => "Return value*self.",
+    "resource.struct_rusage.__setattr__" => "Implement setattr(self, name, value).",
+    "resource.struct_rusage.__sizeof__" => "Size of object in memory, in bytes.",
+    "resource.struct_rusage.__str__" => "Return str(self).",
+    "resource.struct_rusage.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "resource.struct_rusage.count" => "Return number of occurrences of value.",
+    "resource.struct_rusage.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "resource.struct_rusage.ru_idrss" => "unshared data size",
+    "resource.struct_rusage.ru_inblock" => "block input operations",
+    "resource.struct_rusage.ru_isrss" => "unshared stack size",
+    "resource.struct_rusage.ru_ixrss" => "shared memory size",
+    "resource.struct_rusage.ru_majflt" => "page faults requiring I/O",
+    "resource.struct_rusage.ru_maxrss" => "max. resident set size",
+    "resource.struct_rusage.ru_minflt" => "page faults not requiring I/O",
+    "resource.struct_rusage.ru_msgrcv" => "IPC messages received",
+    "resource.struct_rusage.ru_msgsnd" => "IPC messages sent",
+    "resource.struct_rusage.ru_nivcsw" => "involuntary context switches",
+    "resource.struct_rusage.ru_nsignals" => "signals received",
+    "resource.struct_rusage.ru_nswap" => "number of swap outs",
+    "resource.struct_rusage.ru_nvcsw" => "voluntary context switches",
+    "resource.struct_rusage.ru_oublock" => "block output operations",
+    "resource.struct_rusage.ru_stime" => "system time used",
+    "resource.struct_rusage.ru_utime" => "user time used",
+    "select" => "This module supports asynchronous I/O on multiple file descriptors.\n\n*** IMPORTANT NOTICE ***\nOn Windows, only sockets are supported; on Unix, all file descriptors.",
+    "select.epoll" => "select.epoll(sizehint=-1, flags=0)\n\nReturns an epolling object\n\nsizehint must be a positive integer or -1 for the default size. The\nsizehint is used to optimize internal data structures. It doesn't limit\nthe maximum number of monitored events.",
+    "select.epoll.__delattr__" => "Implement delattr(self, name).",
+    "select.epoll.__eq__" => "Return self==value.",
+    "select.epoll.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "select.epoll.__ge__" => "Return self>=value.",
+    "select.epoll.__getattribute__" => "Return getattr(self, name).",
+    "select.epoll.__getstate__" => "Helper for pickle.",
+    "select.epoll.__gt__" => "Return self>value.",
+    "select.epoll.__hash__" => "Return hash(self).",
+    "select.epoll.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "select.epoll.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "select.epoll.__le__" => "Return self<=value.",
+    "select.epoll.__lt__" => "Return self<value.",
+    "select.epoll.__ne__" => "Return self!=value.",
+    "select.epoll.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "select.epoll.__reduce__" => "Helper for pickle.",
+    "select.epoll.__reduce_ex__" => "Helper for pickle.",
+    "select.epoll.__repr__" => "Return repr(self).",
+    "select.epoll.__setattr__" => "Implement setattr(self, name, value).",
+    "select.epoll.__sizeof__" => "Size of object in memory, in bytes.",
+    "select.epoll.__str__" => "Return str(self).",
+    "select.epoll.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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.epoll.close" => "Close the epoll control file descriptor.\n\nFurther operations on the epoll object will raise an exception.",
+    "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.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.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.",
+    "select.kevent.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "select.kevent.__ge__" => "Return self>=value.",
+    "select.kevent.__getattribute__" => "Return getattr(self, name).",
+    "select.kevent.__getstate__" => "Helper for pickle.",
+    "select.kevent.__gt__" => "Return self>value.",
+    "select.kevent.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "select.kevent.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "select.kevent.__le__" => "Return self<=value.",
+    "select.kevent.__lt__" => "Return self<value.",
+    "select.kevent.__ne__" => "Return self!=value.",
+    "select.kevent.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "select.kevent.__reduce__" => "Helper for pickle.",
+    "select.kevent.__reduce_ex__" => "Helper for pickle.",
+    "select.kevent.__repr__" => "Return repr(self).",
+    "select.kevent.__setattr__" => "Implement setattr(self, name, value).",
+    "select.kevent.__sizeof__" => "Size of object in memory, in bytes.",
+    "select.kevent.__str__" => "Return str(self).",
+    "select.kevent.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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" => "Kqueue syscall wrapper.\n\nFor example, to start watching a socket for input:\n>>> kq = kqueue()\n>>> sock = socket()\n>>> sock.connect((host, port))\n>>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\nTo wait one second for it to become writeable:\n>>> kq.control(None, 1, 1000)\n\nTo stop listening:\n>>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)",
+    "select.kqueue.__del__" => "Called when the instance is about to be destroyed.",
+    "select.kqueue.__delattr__" => "Implement delattr(self, name).",
+    "select.kqueue.__eq__" => "Return self==value.",
+    "select.kqueue.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "select.kqueue.__ge__" => "Return self>=value.",
+    "select.kqueue.__getattribute__" => "Return getattr(self, name).",
+    "select.kqueue.__getstate__" => "Helper for pickle.",
+    "select.kqueue.__gt__" => "Return self>value.",
+    "select.kqueue.__hash__" => "Return hash(self).",
+    "select.kqueue.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "select.kqueue.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "select.kqueue.__le__" => "Return self<=value.",
+    "select.kqueue.__lt__" => "Return self<value.",
+    "select.kqueue.__ne__" => "Return self!=value.",
+    "select.kqueue.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "select.kqueue.__reduce__" => "Helper for pickle.",
+    "select.kqueue.__reduce_ex__" => "Helper for pickle.",
+    "select.kqueue.__repr__" => "Return repr(self).",
+    "select.kqueue.__setattr__" => "Implement setattr(self, name, value).",
+    "select.kqueue.__sizeof__" => "Size of object in memory, in bytes.",
+    "select.kqueue.__str__" => "Return str(self).",
+    "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.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.",
+    "select.select" => "Wait until one or more file descriptors are ready for some kind of I/O.\n\nThe first three arguments are iterables of file descriptors to be waited for:\nrlist -- wait until ready for reading\nwlist -- wait until ready for writing\nxlist -- wait for an \"exceptional condition\"\nIf only one kind of condition is required, pass [] for the other lists.\n\nA file descriptor is either a socket or file object, or a small integer\ngotten from a fileno() method call on one of those.\n\nThe optional 4th argument specifies a timeout in seconds; it may be\na floating-point number to specify fractions of seconds.  If it is absent\nor None, the call will never time out.\n\nThe return value is a tuple of three lists corresponding to the first three\narguments; each contains the subset of the corresponding file descriptors\nthat are ready.\n\n*** IMPORTANT NOTICE ***\nOn Windows, only sockets are supported; on Unix, all file\ndescriptors can be used.",
+    "sys" => "This module provides access to some objects used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\n\nDynamic objects:\n\nargv -- command line arguments; argv[0] is the script pathname if known\npath -- module search path; path[0] is the script directory, else ''\nmodules -- dictionary of loaded modules\n\ndisplayhook -- called to show results in an interactive session\nexcepthook -- called to handle any uncaught exception other than SystemExit\n  To customize printing in an interactive session or to install a custom\n  top-level exception handler, assign other functions to replace these.\n\nstdin -- standard input file object; used by input()\nstdout -- standard output file object; used by print()\nstderr -- standard error object; used for error messages\n  By assigning other file objects (or objects that behave like files)\n  to these, it is possible to redirect all of the interpreter's I/O.\n\nlast_exc - the last uncaught exception\n  Only available in an interactive session after a\n  traceback has been printed.\nlast_type -- type of last uncaught exception\nlast_value -- value of last uncaught exception\nlast_traceback -- traceback of last uncaught exception\n  These three are the (deprecated) legacy representation of last_exc.\n\nStatic objects:\n\nbuiltin_module_names -- tuple of module names built into this interpreter\ncopyright -- copyright notice pertaining to this interpreter\nexec_prefix -- prefix used to find the machine-specific Python library\nexecutable -- absolute path of the executable binary of the Python interpreter\nfloat_info -- a named tuple with information about the float implementation.\nfloat_repr_style -- string indicating the style of repr() output for floats\nhash_info -- a named tuple with information about the hash algorithm.\nhexversion -- version information encoded as a single integer\nimplementation -- Python implementation information.\nint_info -- a named tuple with information about the int implementation.\nmaxsize -- the largest supported length of containers.\nmaxunicode -- the value of the largest Unicode code point\nplatform -- platform identifier\nprefix -- prefix used to find the Python library\nthread_info -- a named tuple with information about the thread implementation.\nversion -- the version of this interpreter as a string\nversion_info -- version information as a named tuple\ndllhandle -- [Windows only] integer handle of the Python DLL\nwinver -- [Windows only] version number of the Python DLL\n_enablelegacywindowsfsencoding -- [Windows only]\n__stdin__ -- the original stdin; don't touch!\n__stdout__ -- the original stdout; don't touch!\n__stderr__ -- the original stderr; don't touch!\n__displayhook__ -- the original displayhook; don't touch!\n__excepthook__ -- the original excepthook; don't touch!\n\nFunctions:\n\ndisplayhook() -- print an object to the screen, and save it in builtins._\nexcepthook() -- print an exception and its traceback to sys.stderr\nexception() -- return the current thread's active exception\nexc_info() -- return information about the current thread's active exception\nexit() -- exit the interpreter by raising SystemExit\ngetdlopenflags() -- returns flags to be used for dlopen() calls\ngetprofile() -- get the global profiling function\ngetrefcount() -- return the reference count for an object (plus one :-)\ngetrecursionlimit() -- return the max recursion depth for the interpreter\ngetsizeof() -- return the size of an object in bytes\ngettrace() -- get the global debug tracing function\nsetdlopenflags() -- set the flags to be used for dlopen() calls\nsetprofile() -- set the global profiling function\nsetrecursionlimit() -- set the max recursion depth for the interpreter\nsettrace() -- set the global debug tracing function",
+    "sys.__breakpointhook__" => "This hook function is called by built-in breakpoint().",
+    "sys.__displayhook__" => "Print an object to sys.stdout and also save it in builtins._",
+    "sys.__excepthook__" => "Handle an exception by displaying it with a traceback on sys.stderr.",
+    "sys.__unraisablehook__" => "Handle an unraisable exception.\n\nThe unraisable argument has the following attributes:\n\n* exc_type: Exception type.\n* exc_value: Exception value, can be None.\n* exc_traceback: Exception traceback, can be None.\n* err_msg: Error message, can be None.\n* object: Object causing the exception, can be None.",
+    "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._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._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_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.",
+    "sys.activate_stack_trampoline" => "Activate stack profiler trampoline *backend*.",
+    "sys.addaudithook" => "Adds a new audit hook callback.",
+    "sys.audit" => "Passes the event to any audit hooks that are attached.",
+    "sys.breakpointhook" => "This hook function is called by built-in breakpoint().",
+    "sys.call_tracing" => "Call func(*args), while tracing is enabled.\n\nThe tracing state is saved, and restored afterwards.  This is intended\nto be called from a debugger from a checkpoint, to recursively debug\nsome other code.",
+    "sys.deactivate_stack_trampoline" => "Deactivate the current stack profiler trampoline backend.\n\nIf no stack profiler is activated, this function has no effect.",
+    "sys.displayhook" => "Print an object to sys.stdout and also save it in builtins._",
+    "sys.exc_info" => "Return current exception information: (type, value, traceback).\n\nReturn information about the most recent exception caught by an except\nclause in the current stack frame or in an older stack frame.",
+    "sys.excepthook" => "Handle an exception by displaying it with a traceback on sys.stderr.",
+    "sys.exception" => "Return the current exception.\n\nReturn the most recent exception caught by an except clause\nin the current stack frame or in an older stack frame, or None\nif no such exception exists.",
+    "sys.exit" => "Exit the interpreter by raising SystemExit(status).\n\nIf the status is omitted or None, it defaults to zero (i.e., success).\nIf the status is an integer, it will be used as the system exit status.\nIf it is another kind of object, it will be printed and the system\nexit status will be one (i.e., failure).",
+    "sys.get_asyncgen_hooks" => "Return the installed asynchronous generators hooks.\n\nThis returns a namedtuple of the form (firstiter, finalizer).",
+    "sys.get_coroutine_origin_tracking_depth" => "Check status of origin tracking for coroutine objects in this thread.",
+    "sys.get_int_max_str_digits" => "Return the maximum string digits limit for non-binary int<->str conversions.",
+    "sys.getallocatedblocks" => "Return the number of memory blocks currently allocated.",
+    "sys.getdefaultencoding" => "Return the current default encoding used by the Unicode implementation.",
+    "sys.getdlopenflags" => "Return the current value of the flags that are used for dlopen calls.\n\nThe flag constants are defined in the os module.",
+    "sys.getfilesystemencodeerrors" => "Return the error mode used Unicode to OS filename conversion.",
+    "sys.getfilesystemencoding" => "Return the encoding used to convert Unicode filenames to OS filenames.",
+    "sys.getprofile" => "Return the profiling function set with sys.setprofile.\n\nSee the profiler chapter in the library manual.",
+    "sys.getrecursionlimit" => "Return the current value of the recursion limit.\n\nThe recursion limit is the maximum depth of the Python interpreter\nstack.  This limit prevents infinite recursion from causing an overflow\nof the C stack and crashing Python.",
+    "sys.getrefcount" => "Return the reference count of object.\n\nThe count returned is generally one higher than you might expect,\nbecause it includes the (temporary) reference as an argument to\ngetrefcount().",
+    "sys.getsizeof" => "getsizeof(object [, default]) -> int\n\nReturn the size of object in bytes.",
+    "sys.getswitchinterval" => "Return the current thread switch interval; see sys.setswitchinterval().",
+    "sys.gettrace" => "Return the global debug tracing function set with sys.settrace.\n\nSee the debugger chapter in the library manual.",
+    "sys.getunicodeinternedsize" => "Return the number of elements of the unicode interned dictionary",
+    "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_stack_trampoline_active" => "Return *True* if a stack profiler trampoline is active.",
+    "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.",
+    "sys.setdlopenflags" => "Set the flags used by the interpreter for dlopen calls.\n\nThis is used, for example, when the interpreter loads extension\nmodules. Among other things, this will enable a lazy resolving of\nsymbols when importing a module, if called as sys.setdlopenflags(0).\nTo share symbols across extension modules, call as\nsys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag\nmodules can be found in the os module (RTLD_xxx constants, e.g.\nos.RTLD_LAZY).",
+    "sys.setprofile" => "Set the profiling function.\n\nIt will be called on each function call and return.  See the profiler\nchapter in the library manual.",
+    "sys.setrecursionlimit" => "Set the maximum depth of the Python interpreter stack to n.\n\nThis limit prevents infinite recursion from causing an overflow of the C\nstack and crashing Python.  The highest possible limit is platform-\ndependent.",
+    "sys.setswitchinterval" => "Set the ideal thread switching delay inside the Python interpreter.\n\nThe actual frequency of switching threads can be lower if the\ninterpreter executes long sequences of uninterruptible code\n(this is implementation-specific and workload-dependent).\n\nThe parameter must represent the desired switching delay in seconds\nA typical value is 0.005 (5 milliseconds).",
+    "sys.settrace" => "Set the global debug tracing function.\n\nIt will be called on each function call.  See the debugger chapter\nin the library manual.",
+    "sys.unraisablehook" => "Handle an unraisable exception.\n\nThe unraisable argument has the following attributes:\n\n* exc_type: Exception type.\n* exc_value: Exception value, can be None.\n* exc_traceback: Exception traceback, can be None.\n* err_msg: Error message, can be None.\n* object: Object causing the exception, can be None.",
+    "syslog.LOG_MASK" => "Calculates the mask for the individual priority pri.",
+    "syslog.LOG_UPTO" => "Calculates the mask for all priorities up to and including pri.",
+    "syslog.closelog" => "Reset the syslog module values and call the system library closelog().",
+    "syslog.openlog" => "Set logging options of subsequent syslog() calls.",
+    "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.",
+    "termios.error.__ge__" => "Return self>=value.",
+    "termios.error.__getattribute__" => "Return getattr(self, name).",
+    "termios.error.__getstate__" => "Helper for pickle.",
+    "termios.error.__gt__" => "Return self>value.",
+    "termios.error.__hash__" => "Return hash(self).",
+    "termios.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "termios.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.",
+    "termios.error.__le__" => "Return self<=value.",
+    "termios.error.__lt__" => "Return self<value.",
+    "termios.error.__ne__" => "Return self!=value.",
+    "termios.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "termios.error.__reduce_ex__" => "Helper for pickle.",
+    "termios.error.__repr__" => "Return repr(self).",
+    "termios.error.__setattr__" => "Implement setattr(self, name, value).",
+    "termios.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.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.",
+    "termios.tcgetattr" => "Get the tty attributes for file descriptor fd.\n\nReturns a list [iflag, oflag, cflag, lflag, ispeed, ospeed, cc]\nwhere cc is a list of the tty special characters (each a string of\nlength 1, except the items with indices VMIN and VTIME, which are\nintegers when these fields are defined).  The interpretation of the\nflags and the speeds as well as the indexing in the cc array must be\ndone using the symbolic constants defined in this module.",
+    "termios.tcgetwinsize" => "Get the tty winsize for file descriptor fd.\n\nReturns a tuple (ws_row, ws_col).",
+    "termios.tcsendbreak" => "Send a break on file descriptor fd.\n\nA zero duration sends a break for 0.25-0.5 seconds; a nonzero duration\nhas a system dependent meaning.",
+    "termios.tcsetattr" => "Set the tty attributes for file descriptor fd.\n\nThe attributes to be set are taken from the attributes argument, which\nis a list like the one returned by tcgetattr(). The when argument\ndetermines when the attributes are changed: termios.TCSANOW to\nchange immediately, termios.TCSADRAIN to change after transmitting all\nqueued output, or termios.TCSAFLUSH to change after transmitting all\nqueued output and discarding all queued input.",
+    "termios.tcsetwinsize" => "Set the tty winsize for file descriptor fd.\n\nThe winsize to be set is taken from the winsize argument, which\nis a two-item tuple (ws_row, ws_col) like the one returned by tcgetwinsize().",
+    "time" => "This module provides various functions to manipulate time values.\n\nThere are two standard representations of time.  One is the number\nof seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\nor a floating-point number (to represent fractions of seconds).\nThe epoch is the point where the time starts, the return value of time.gmtime(0).\nIt is January 1, 1970, 00:00:00 (UTC) on all platforms.\n\nThe other representation is a tuple of 9 integers giving local time.\nThe tuple items are:\n  year (including century, e.g. 1998)\n  month (1-12)\n  day (1-31)\n  hours (0-23)\n  minutes (0-59)\n  seconds (0-59)\n  weekday (0-6, Monday is 0)\n  Julian day (day in the year, 1-366)\n  DST (Daylight Savings Time) flag (-1, 0 or 1)\nIf the DST flag is 0, the time is given in the regular time zone;\nif it is 1, the time is given in the DST time zone;\nif it is -1, mktime() should guess based on the date and time.",
+    "time.asctime" => "asctime([tuple]) -> string\n\nConvert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\nWhen the time tuple is not present, current time as returned by localtime()\nis used.",
+    "time.clock_getres" => "clock_getres(clk_id) -> floating-point number\n\nReturn the resolution (precision) of the specified clock clk_id.",
+    "time.clock_gettime" => "Return the time of the specified clock clk_id as a float.",
+    "time.clock_gettime_ns" => "Return the time of the specified clock clk_id as nanoseconds (int).",
+    "time.clock_settime" => "clock_settime(clk_id, time)\n\nSet the time of the specified clock clk_id.",
+    "time.clock_settime_ns" => "clock_settime_ns(clk_id, time)\n\nSet the time of the specified clock clk_id with nanoseconds.",
+    "time.ctime" => "ctime(seconds) -> string\n\nConvert a time in seconds since the Epoch to a string in local time.\nThis is equivalent to asctime(localtime(seconds)). When the time tuple is\nnot present, current time as returned by localtime() is used.",
+    "time.get_clock_info" => "get_clock_info(name: str) -> dict\n\nGet information of the specified clock.",
+    "time.gmtime" => "gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n                       tm_sec, tm_wday, tm_yday, tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\nGMT).  When 'seconds' is not passed in, convert the current time instead.\n\nIf the platform supports the tm_gmtoff and tm_zone, they are available as\nattributes only.",
+    "time.localtime" => "localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n                          tm_sec,tm_wday,tm_yday,tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing local time.\nWhen 'seconds' is not passed in, convert the current time instead.",
+    "time.mktime" => "mktime(tuple) -> floating-point number\n\nConvert a time tuple in local time to seconds since the Epoch.\nNote that mktime(gmtime(0)) will not generally return zero for most\ntime zones; instead the returned value will either be equal to that\nof the timezone or altzone attributes on the time module.",
+    "time.monotonic" => "monotonic() -> float\n\nMonotonic clock, cannot go backward.",
+    "time.monotonic_ns" => "monotonic_ns() -> int\n\nMonotonic clock, cannot go backward, as nanoseconds.",
+    "time.perf_counter" => "perf_counter() -> float\n\nPerformance counter for benchmarking.",
+    "time.perf_counter_ns" => "perf_counter_ns() -> int\n\nPerformance counter for benchmarking as nanoseconds.",
+    "time.process_time" => "process_time() -> float\n\nProcess time for profiling: sum of the kernel and user-space CPU time.",
+    "time.process_time_ns" => "process_time() -> int\n\nProcess time for profiling as nanoseconds:\nsum of the kernel and user-space CPU time.",
+    "time.pthread_getcpuclockid" => "pthread_getcpuclockid(thread_id) -> int\n\nReturn the clk_id of a thread's CPU time clock.",
+    "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.__add__" => "Return self+value.",
+    "time.struct_time.__class_getitem__" => "See PEP 585",
+    "time.struct_time.__contains__" => "Return bool(key in self).",
+    "time.struct_time.__delattr__" => "Implement delattr(self, name).",
+    "time.struct_time.__eq__" => "Return self==value.",
+    "time.struct_time.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "time.struct_time.__ge__" => "Return self>=value.",
+    "time.struct_time.__getattribute__" => "Return getattr(self, name).",
+    "time.struct_time.__getitem__" => "Return self[key].",
+    "time.struct_time.__getstate__" => "Helper for pickle.",
+    "time.struct_time.__gt__" => "Return self>value.",
+    "time.struct_time.__hash__" => "Return hash(self).",
+    "time.struct_time.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "time.struct_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.",
+    "time.struct_time.__iter__" => "Implement iter(self).",
+    "time.struct_time.__le__" => "Return self<=value.",
+    "time.struct_time.__len__" => "Return len(self).",
+    "time.struct_time.__lt__" => "Return self<value.",
+    "time.struct_time.__mul__" => "Return self*value.",
+    "time.struct_time.__ne__" => "Return self!=value.",
+    "time.struct_time.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "time.struct_time.__reduce_ex__" => "Helper for pickle.",
+    "time.struct_time.__replace__" => "Return a copy of the structure with new values for the specified fields.",
+    "time.struct_time.__repr__" => "Return repr(self).",
+    "time.struct_time.__rmul__" => "Return value*self.",
+    "time.struct_time.__setattr__" => "Implement setattr(self, name, value).",
+    "time.struct_time.__sizeof__" => "Size of object in memory, in bytes.",
+    "time.struct_time.__str__" => "Return str(self).",
+    "time.struct_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).",
+    "time.struct_time.count" => "Return number of occurrences of value.",
+    "time.struct_time.index" => "Return first index of value.\n\nRaises ValueError if the value is not present.",
+    "time.struct_time.tm_gmtoff" => "offset from UTC in seconds",
+    "time.struct_time.tm_hour" => "hours, range [0, 23]",
+    "time.struct_time.tm_isdst" => "1 if summer time is in effect, 0 if not, and -1 if unknown",
+    "time.struct_time.tm_mday" => "day of month, range [1, 31]",
+    "time.struct_time.tm_min" => "minutes, range [0, 59]",
+    "time.struct_time.tm_mon" => "month of year, range [1, 12]",
+    "time.struct_time.tm_sec" => "seconds, range [0, 61])",
+    "time.struct_time.tm_wday" => "day of week, range [0, 6], Monday is 0",
+    "time.struct_time.tm_yday" => "day of year, range [1, 366]",
+    "time.struct_time.tm_year" => "year, for example, 1993",
+    "time.struct_time.tm_zone" => "abbreviation of timezone name",
+    "time.thread_time" => "thread_time() -> float\n\nThread time for profiling: sum of the kernel and user-space CPU time.",
+    "time.thread_time_ns" => "thread_time() -> int\n\nThread time for profiling as nanoseconds:\nsum of the kernel and user-space CPU time.",
+    "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.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.",
+    "unicodedata.UCD.__ge__" => "Return self>=value.",
+    "unicodedata.UCD.__getattribute__" => "Return getattr(self, name).",
+    "unicodedata.UCD.__getstate__" => "Helper for pickle.",
+    "unicodedata.UCD.__gt__" => "Return self>value.",
+    "unicodedata.UCD.__hash__" => "Return hash(self).",
+    "unicodedata.UCD.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "unicodedata.UCD.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "unicodedata.UCD.__le__" => "Return self<=value.",
+    "unicodedata.UCD.__lt__" => "Return self<value.",
+    "unicodedata.UCD.__ne__" => "Return self!=value.",
+    "unicodedata.UCD.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "unicodedata.UCD.__reduce__" => "Helper for pickle.",
+    "unicodedata.UCD.__reduce_ex__" => "Helper for pickle.",
+    "unicodedata.UCD.__repr__" => "Return repr(self).",
+    "unicodedata.UCD.__setattr__" => "Implement setattr(self, name, value).",
+    "unicodedata.UCD.__sizeof__" => "Size of object in memory, in bytes.",
+    "unicodedata.UCD.__str__" => "Return str(self).",
+    "unicodedata.UCD.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "unicodedata.UCD.bidirectional" => "Returns the bidirectional class assigned to the character chr as string.\n\nIf no such value is defined, an empty string is returned.",
+    "unicodedata.UCD.category" => "Returns the general category assigned to the character chr as string.",
+    "unicodedata.UCD.combining" => "Returns the canonical combining class assigned to the character chr as integer.\n\nReturns 0 if no combining class is defined.",
+    "unicodedata.UCD.decimal" => "Converts a Unicode character into its equivalent decimal value.\n\nReturns the decimal value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.",
+    "unicodedata.UCD.decomposition" => "Returns the character decomposition mapping assigned to the character chr as string.\n\nAn empty string is returned in case no such mapping is defined.",
+    "unicodedata.UCD.digit" => "Converts a Unicode character into its equivalent digit value.\n\nReturns the digit value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.",
+    "unicodedata.UCD.east_asian_width" => "Returns the east asian width assigned to the character chr as string.",
+    "unicodedata.UCD.is_normalized" => "Return whether the Unicode string unistr is in the normal form 'form'.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.",
+    "unicodedata.UCD.lookup" => "Look up character by name.\n\nIf a character with the given name is found, return the\ncorresponding character.  If not found, KeyError is raised.",
+    "unicodedata.UCD.mirrored" => "Returns the mirrored property assigned to the character chr as integer.\n\nReturns 1 if the character has been identified as a \"mirrored\"\ncharacter in bidirectional text, 0 otherwise.",
+    "unicodedata.UCD.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.UCD.normalize" => "Return the normal form 'form' for the Unicode string unistr.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.",
+    "unicodedata.UCD.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.",
+    "unicodedata.bidirectional" => "Returns the bidirectional class assigned to the character chr as string.\n\nIf no such value is defined, an empty string is returned.",
+    "unicodedata.category" => "Returns the general category assigned to the character chr as string.",
+    "unicodedata.combining" => "Returns the canonical combining class assigned to the character chr as integer.\n\nReturns 0 if no combining class is defined.",
+    "unicodedata.decimal" => "Converts a Unicode character into its equivalent decimal value.\n\nReturns the decimal value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.",
+    "unicodedata.decomposition" => "Returns the character decomposition mapping assigned to the character chr as string.\n\nAn empty string is returned in case no such mapping is defined.",
+    "unicodedata.digit" => "Converts a Unicode character into its equivalent digit value.\n\nReturns the digit value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.",
+    "unicodedata.east_asian_width" => "Returns the east asian width assigned to the character chr as string.",
+    "unicodedata.is_normalized" => "Return whether the Unicode string unistr is in the normal form 'form'.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.",
+    "unicodedata.lookup" => "Look up character by name.\n\nIf a character with the given name is found, return the\ncorresponding character.  If not found, KeyError is raised.",
+    "unicodedata.mirrored" => "Returns the mirrored property assigned to the character chr as integer.\n\nReturns 1 if the character has been identified as a \"mirrored\"\ncharacter in bidirectional text, 0 otherwise.",
+    "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.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.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.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)",
+    "winreg.HKEYType.__add__" => "Return self+value.",
+    "winreg.HKEYType.__and__" => "Return self&value.",
+    "winreg.HKEYType.__bool__" => "True if self else False",
+    "winreg.HKEYType.__delattr__" => "Implement delattr(self, name).",
+    "winreg.HKEYType.__divmod__" => "Return divmod(self, value).",
+    "winreg.HKEYType.__eq__" => "Return self==value.",
+    "winreg.HKEYType.__float__" => "float(self)",
+    "winreg.HKEYType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.",
+    "winreg.HKEYType.__ge__" => "Return self>=value.",
+    "winreg.HKEYType.__getattribute__" => "Return getattr(self, name).",
+    "winreg.HKEYType.__getstate__" => "Helper for pickle.",
+    "winreg.HKEYType.__gt__" => "Return self>value.",
+    "winreg.HKEYType.__hash__" => "Return hash(self).",
+    "winreg.HKEYType.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "winreg.HKEYType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "winreg.HKEYType.__int__" => "int(self)",
+    "winreg.HKEYType.__invert__" => "~self",
+    "winreg.HKEYType.__le__" => "Return self<=value.",
+    "winreg.HKEYType.__lshift__" => "Return self<<value.",
+    "winreg.HKEYType.__lt__" => "Return self<value.",
+    "winreg.HKEYType.__mod__" => "Return self%value.",
+    "winreg.HKEYType.__mul__" => "Return self*value.",
+    "winreg.HKEYType.__ne__" => "Return self!=value.",
+    "winreg.HKEYType.__neg__" => "-self",
+    "winreg.HKEYType.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "winreg.HKEYType.__or__" => "Return self|value.",
+    "winreg.HKEYType.__pos__" => "+self",
+    "winreg.HKEYType.__pow__" => "Return pow(self, value, mod).",
+    "winreg.HKEYType.__radd__" => "Return value+self.",
+    "winreg.HKEYType.__rand__" => "Return value&self.",
+    "winreg.HKEYType.__rdivmod__" => "Return divmod(value, self).",
+    "winreg.HKEYType.__reduce__" => "Helper for pickle.",
+    "winreg.HKEYType.__reduce_ex__" => "Helper for pickle.",
+    "winreg.HKEYType.__repr__" => "Return repr(self).",
+    "winreg.HKEYType.__rlshift__" => "Return value<<self.",
+    "winreg.HKEYType.__rmod__" => "Return value%self.",
+    "winreg.HKEYType.__rmul__" => "Return value*self.",
+    "winreg.HKEYType.__ror__" => "Return value|self.",
+    "winreg.HKEYType.__rpow__" => "Return pow(value, self, mod).",
+    "winreg.HKEYType.__rrshift__" => "Return value>>self.",
+    "winreg.HKEYType.__rshift__" => "Return self>>value.",
+    "winreg.HKEYType.__rsub__" => "Return value-self.",
+    "winreg.HKEYType.__rxor__" => "Return value^self.",
+    "winreg.HKEYType.__setattr__" => "Implement setattr(self, name, value).",
+    "winreg.HKEYType.__sizeof__" => "Size of object in memory, in bytes.",
+    "winreg.HKEYType.__str__" => "Return str(self).",
+    "winreg.HKEYType.__sub__" => "Return self-value.",
+    "winreg.HKEYType.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).",
+    "winreg.HKEYType.__xor__" => "Return self^value.",
+    "winreg.LoadKey" => "Insert data into the registry from a file.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  sub_key\n    A string that identifies the sub-key to load.\n  file_name\n    The name of the file to load registry data from.  This file must\n    have been created with the SaveKey() function.  Under the file\n    allocation table (FAT) file system, the filename may not have an\n    extension.\n\nCreates a subkey under the specified key and stores registration\ninformation from a specified file into that subkey.\n\nA call to LoadKey() fails if the calling process does not have the\nSE_RESTORE_PRIVILEGE privilege.\n\nIf key is a handle returned by ConnectRegistry(), then the path\nspecified in fileName is relative to the remote computer.\n\nThe MSDN docs imply key must be in the HKEY_USER or HKEY_LOCAL_MACHINE\ntree.",
+    "winreg.OpenKey" => "Opens 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 identifies the sub_key to open.\n  reserved\n    A reserved integer that must be zero.  Default is zero.\n  access\n    An integer that specifies an access mask that describes the desired\n    security access for the key.  Default is KEY_READ.\n\nThe result is a new handle to the specified key.\nIf the function fails, an OSError exception is raised.",
+    "winreg.OpenKeyEx" => "Opens 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 identifies the sub_key to open.\n  reserved\n    A reserved integer that must be zero.  Default is zero.\n  access\n    An integer that specifies an access mask that describes the desired\n    security access for the key.  Default is KEY_READ.\n\nThe result is a new handle to the specified key.\nIf the function fails, an OSError exception is raised.",
+    "winreg.QueryInfoKey" => "Returns information about a key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n\nThe result is a tuple of 3 items:\nAn integer that identifies the number of sub keys this key has.\nAn integer that identifies the number of values this key has.\nAn integer that identifies when the key was last modified (if available)\nas 100's of nanoseconds since Jan 1, 1600.",
+    "winreg.QueryReflectionKey" => "Returns the reflection state for the specified key as a bool.\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.",
+    "winreg.QueryValue" => "Retrieves the unnamed value for a key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  sub_key\n    A string that holds the name of the subkey with which the value\n    is associated.  If this parameter is None or empty, the function\n    retrieves the value set by the SetValue() method for the key\n    identified by key.\n\nValues in the registry have name, type, and data components. This method\nretrieves the data for a key's first value that has a NULL name.\nBut since the underlying API call doesn't return the type, you'll\nprobably be happier using QueryValueEx; this function is just here for\ncompleteness.",
+    "winreg.QueryValueEx" => "Retrieves the type and value of a specified sub-key.\n\n  key\n    An already open key, or any one of the predefined HKEY_* constants.\n  name\n    A string indicating the value to query.\n\nBehaves mostly like QueryValue(), but also returns the type of the\nspecified value name associated with the given open registry key.\n\nThe return value is a tuple of the value and the type_id.",
+    "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.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.",
+    "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.__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.",
+    "zlib._ZlibDecompressor.__ge__" => "Return self>=value.",
+    "zlib._ZlibDecompressor.__getattribute__" => "Return getattr(self, name).",
+    "zlib._ZlibDecompressor.__getstate__" => "Helper for pickle.",
+    "zlib._ZlibDecompressor.__gt__" => "Return self>value.",
+    "zlib._ZlibDecompressor.__hash__" => "Return hash(self).",
+    "zlib._ZlibDecompressor.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "zlib._ZlibDecompressor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.",
+    "zlib._ZlibDecompressor.__le__" => "Return self<=value.",
+    "zlib._ZlibDecompressor.__lt__" => "Return self<value.",
+    "zlib._ZlibDecompressor.__ne__" => "Return self!=value.",
+    "zlib._ZlibDecompressor.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "zlib._ZlibDecompressor.__reduce__" => "Helper for pickle.",
+    "zlib._ZlibDecompressor.__reduce_ex__" => "Helper for pickle.",
+    "zlib._ZlibDecompressor.__repr__" => "Return repr(self).",
+    "zlib._ZlibDecompressor.__setattr__" => "Implement setattr(self, name, value).",
+    "zlib._ZlibDecompressor.__sizeof__" => "Size of object in memory, in bytes.",
+    "zlib._ZlibDecompressor.__str__" => "Return str(self).",
+    "zlib._ZlibDecompressor.__subclasshook__" => "Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return 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._ZlibDecompressor.decompress" => "Decompress *data*, returning uncompressed data as bytes.\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 stream is reached raises an\nEOFError.  Any data found after the end of the stream is ignored and saved in\nthe unused_data attribute.",
+    "zlib._ZlibDecompressor.eof" => "True if the end-of-stream marker has been reached.",
+    "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.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.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.",
+    "zlib.error.__ge__" => "Return self>=value.",
+    "zlib.error.__getattribute__" => "Return getattr(self, name).",
+    "zlib.error.__getstate__" => "Helper for pickle.",
+    "zlib.error.__gt__" => "Return self>value.",
+    "zlib.error.__hash__" => "Return hash(self).",
+    "zlib.error.__init__" => "Initialize self.  See help(type(self)) for accurate signature.",
+    "zlib.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.",
+    "zlib.error.__le__" => "Return self<=value.",
+    "zlib.error.__lt__" => "Return self<value.",
+    "zlib.error.__ne__" => "Return self!=value.",
+    "zlib.error.__new__" => "Create and return a new object.  See help(type) for accurate signature.",
+    "zlib.error.__reduce_ex__" => "Helper for pickle.",
+    "zlib.error.__repr__" => "Return repr(self).",
+    "zlib.error.__setattr__" => "Implement setattr(self, name, value).",
+    "zlib.error.__sizeof__" => "Size of object in memory, in bytes.",
+    "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.",
+};
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
new file mode 100644
index 0000000000..cc81f17fc5
--- /dev/null
+++ b/crates/doc/src/lib.rs
@@ -0,0 +1,12 @@
+include!("./data.inc.rs");
+
+#[cfg(test)]
+mod test {
+    use super::DB;
+
+    #[test]
+    fn test_db() {
+        let doc = DB.get("array._array_reconstructor");
+        assert!(doc.is_some());
+    }
+}
diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
new file mode 100644
index 0000000000..fde10b7c00
--- /dev/null
+++ b/crates/jit/Cargo.toml
@@ -0,0 +1,34 @@
+[package]
+name = "rustpython-jit"
+description = "Experimental JIT(just in time) compiler for python code."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+autotests = false
+
+[dependencies]
+rustpython-compiler-core = { workspace = true }
+
+num-traits = { workspace = true }
+thiserror = { workspace = true }
+libffi = { workspace = true }
+
+cranelift = "0.127"
+cranelift-jit = "0.127"
+cranelift-module = "0.127"
+
+[dev-dependencies]
+rustpython-derive = { workspace = true }
+
+approx = "0.5.1"
+
+[[test]]
+name = "integration"
+path = "tests/lib.rs"
+
+[lints]
+workspace = true
diff --git a/jit/src/instructions.rs b/crates/jit/src/instructions.rs
similarity index 81%
rename from jit/src/instructions.rs
rename to crates/jit/src/instructions.rs
index 9ec0a4385e..64cbb2fd06 100644
--- a/jit/src/instructions.rs
+++ b/crates/jit/src/instructions.rs
@@ -4,8 +4,8 @@ use cranelift::codegen::ir::FuncRef;
 use cranelift::prelude::*;
 use num_traits::cast::ToPrimitive;
 use rustpython_compiler_core::bytecode::{
-    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction, Label,
-    OpArg, OpArgState, UnaryOperator,
+    self, BinaryOperator, BorrowedConstant, CodeObject, ComparisonOperator, Instruction,
+    IntrinsicFunction1, Label, OpArg, OpArgState,
 };
 use std::collections::HashMap;
 
@@ -27,6 +27,7 @@ enum JitValue {
     Float(Value),
     Bool(Value),
     None,
+    Null,
     Tuple(Vec<JitValue>),
     FuncRef(FuncRef),
 }
@@ -45,14 +46,14 @@ impl JitValue {
             JitValue::Int(_) => Some(JitType::Int),
             JitValue::Float(_) => Some(JitType::Float),
             JitValue::Bool(_) => Some(JitType::Bool),
-            JitValue::None | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
+            JitValue::None | JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
         }
     }
 
     fn into_value(self) -> Option<Value> {
         match self {
             JitValue::Int(val) | JitValue::Float(val) | JitValue::Bool(val) => Some(val),
-            JitValue::None | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
+            JitValue::None | JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => None,
         }
     }
 }
@@ -111,13 +112,11 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         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 var = Variable::new(idx as usize);
-            let local = Local {
+            let var = builder.declare_var(ty.to_cranelift());
+            Local {
                 var,
                 ty: ty.clone(),
-            };
-            builder.declare_var(var, ty.to_cranelift());
-            local
+            }
         });
         if ty != local.ty {
             Err(JitCompileError::NotSupported)
@@ -141,7 +140,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             }
             JitValue::Bool(val) => Ok(val),
             JitValue::None => Ok(self.builder.ins().iconst(types::I8, 0)),
-            JitValue::Tuple(_) | JitValue::FuncRef(_) => Err(JitCompileError::NotSupported),
+            JitValue::Null | JitValue::Tuple(_) | JitValue::FuncRef(_) => {
+                Err(JitCompileError::NotSupported)
+            }
         }
     }
 
@@ -174,9 +175,19 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 // Create or get the block for this label:
                 let target_block = self.get_or_create_block(label);
 
-                // If the current block isn't terminated, jump:
-                if let Some(cur) = self.builder.current_block() {
-                    if cur != target_block && self.builder.func.layout.last_inst(cur).is_none() {
+                // If the current block isn't terminated, add a fallthrough jump
+                if let Some(cur) = self.builder.current_block()
+                    && cur != target_block
+                {
+                    // Check if the block needs a terminator by examining the last instruction
+                    let needs_terminator = match self.builder.func.layout.last_inst(cur) {
+                        None => true, // Empty block needs terminator
+                        Some(inst) => {
+                            // Check if the last instruction is a terminator
+                            !self.builder.func.dfg.insts[inst].opcode().is_terminator()
+                        }
+                    };
+                    if needs_terminator {
                         self.builder.ins().jump(target_block, &[]);
                     }
                 }
@@ -197,18 +208,26 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             // Actually compile this instruction:
             self.add_instruction(func_ref, bytecode, instruction, arg)?;
 
-            // If that was a return instruction, mark future instructions unreachable
+            // If that was an unconditional branch or return, mark future instructions unreachable
             match instruction {
-                Instruction::ReturnValue | Instruction::ReturnConst { .. } => {
+                Instruction::ReturnValue
+                | Instruction::ReturnConst { .. }
+                | Instruction::JumpBackward { .. }
+                | Instruction::JumpBackwardNoInterrupt { .. }
+                | Instruction::JumpForward { .. } => {
                     in_unreachable_code = true;
                 }
                 _ => {}
             }
         }
 
-        // After processing, if the current block is unterminated, insert a trap or fallthrough
+        // After processing, if the current block is unterminated, insert a trap
         if let Some(cur) = self.builder.current_block() {
-            if self.builder.func.layout.last_inst(cur).is_none() {
+            let needs_terminator = match self.builder.func.layout.last_inst(cur) {
+                None => true,
+                Some(inst) => !self.builder.func.dfg.insts[inst].opcode().is_terminator(),
+            };
+            if needs_terminator {
                 self.builder.ins().trap(TrapCode::user(0).unwrap());
             }
         }
@@ -274,168 +293,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         arg: OpArg,
     ) -> Result<(), JitCompileError> {
         match instruction {
-            Instruction::ExtendedArg => Ok(()),
-            Instruction::JumpIfFalse { target } => {
-                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 else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, else_block, &[], then_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-            Instruction::JumpIfTrue { target } => {
-                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 else_block = self.builder.create_block();
-
-                self.builder
-                    .ins()
-                    .brif(val, then_block, &[], else_block, &[]);
-                self.builder.switch_to_block(else_block);
-
-                Ok(())
-            }
-
-            Instruction::Jump { target } => {
-                let target_block = self.get_or_create_block(target.get(arg));
-                self.builder.ins().jump(target_block, &[]);
-                Ok(())
-            }
-            Instruction::LoadFast(idx) => {
-                let local = self.variables[idx.get(arg) as usize]
-                    .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::StoreFast(idx) => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.store_variable(idx.get(arg), val)
-            }
-            Instruction::LoadConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.stack.push(val);
-                Ok(())
-            }
-            Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize);
-                self.stack.push(JitValue::Tuple(elements));
-                Ok(())
-            }
-            Instruction::UnpackSequence { size } => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-
-                let elements = match val {
-                    JitValue::Tuple(elements) => elements,
-                    _ => return Err(JitCompileError::NotSupported),
-                };
-
-                if elements.len() != size.get(arg) as usize {
-                    return Err(JitCompileError::NotSupported);
-                }
-
-                self.stack.extend(elements.into_iter().rev());
-                Ok(())
-            }
-            Instruction::ReturnValue => {
-                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                self.return_value(val)
-            }
-            Instruction::ReturnConst { idx } => {
-                let val = self
-                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
-                self.return_value(val)
-            }
-            Instruction::CompareOperation { op, .. } => {
-                let op = op.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)?;
-
-                let a_type: Option<JitType> = a.to_jit_type();
-                let b_type: Option<JitType> = b.to_jit_type();
-
-                match (a, b) {
-                    (JitValue::Int(a), JitValue::Int(b))
-                    | (JitValue::Bool(a), JitValue::Bool(b))
-                    | (JitValue::Bool(a), JitValue::Int(b))
-                    | (JitValue::Int(a), JitValue::Bool(b)) => {
-                        let operand_one = match a_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
-                            _ => a,
-                        };
-
-                        let operand_two = match b_type.unwrap() {
-                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
-                            _ => b,
-                        };
-
-                        let cond = match op {
-                            ComparisonOperator::Equal => IntCC::Equal,
-                            ComparisonOperator::NotEqual => IntCC::NotEqual,
-                            ComparisonOperator::Less => IntCC::SignedLessThan,
-                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
-                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
-                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    (JitValue::Float(a), JitValue::Float(b)) => {
-                        let cond = match op {
-                            ComparisonOperator::Equal => FloatCC::Equal,
-                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
-                            ComparisonOperator::Less => FloatCC::LessThan,
-                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
-                            ComparisonOperator::Greater => FloatCC::GreaterThan,
-                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
-                        };
-
-                        let val = self.builder.ins().fcmp(cond, a, b);
-                        self.stack.push(JitValue::Bool(val));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
-            Instruction::UnaryOperation { op, .. } => {
-                let op = op.get(arg);
-                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
-                match (op, a) {
-                    (UnaryOperator::Minus, JitValue::Int(val)) => {
-                        // Compile minus as 0 - a.
-                        let zero = self.builder.ins().iconst(types::I64, 0);
-                        let out = self.compile_sub(zero, val);
-                        self.stack.push(JitValue::Int(out));
-                        Ok(())
-                    }
-                    (UnaryOperator::Plus, JitValue::Int(val)) => {
-                        // Nothing to do
-                        self.stack.push(JitValue::Int(val));
-                        Ok(())
-                    }
-                    (UnaryOperator::Not, a) => {
-                        let boolean = self.boolean_val(a)?;
-                        let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
-                        self.stack.push(JitValue::Bool(not_boolean));
-                        Ok(())
-                    }
-                    _ => Err(JitCompileError::NotSupported),
-                }
-            }
-            Instruction::BinaryOperation { op } | Instruction::BinaryOperationInplace { op } => {
+            Instruction::BinaryOp { op } => {
                 let op = op.get(arg);
                 // the rhs is popped off first
                 let b = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
@@ -445,18 +303,30 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 let b_type = b.to_jit_type();
 
                 let val = match (op, a, b) {
-                    (BinaryOperator::Add, JitValue::Int(a), JitValue::Int(b)) => {
+                    (
+                        BinaryOperator::Add | BinaryOperator::InplaceAdd,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => {
                         let (out, carry) = self.builder.ins().sadd_overflow(a, b);
                         self.builder.ins().trapnz(carry, TrapCode::INTEGER_OVERFLOW);
                         JitValue::Int(out)
                     }
-                    (BinaryOperator::Subtract, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.compile_sub(a, b))
-                    }
-                    (BinaryOperator::FloorDivide, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().sdiv(a, b))
-                    }
-                    (BinaryOperator::Divide, JitValue::Int(a), JitValue::Int(b)) => {
+                    (
+                        BinaryOperator::Subtract | BinaryOperator::InplaceSubtract,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.compile_sub(a, b)),
+                    (
+                        BinaryOperator::FloorDivide | BinaryOperator::InplaceFloorDivide,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().sdiv(a, b)),
+                    (
+                        BinaryOperator::TrueDivide | BinaryOperator::InplaceTrueDivide,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => {
                         // Check if b == 0, If so trap with a division by zero error
                         self.builder
                             .ins()
@@ -466,15 +336,21 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                         let b_float = self.builder.ins().fcvt_from_sint(types::F64, b);
                         JitValue::Float(self.builder.ins().fdiv(a_float, b_float))
                     }
-                    (BinaryOperator::Multiply, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().imul(a, b))
-                    }
-                    (BinaryOperator::Modulo, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().srem(a, b))
-                    }
-                    (BinaryOperator::Power, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.compile_ipow(a, b))
-                    }
+                    (
+                        BinaryOperator::Multiply | BinaryOperator::InplaceMultiply,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().imul(a, b)),
+                    (
+                        BinaryOperator::Remainder | BinaryOperator::InplaceRemainder,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().srem(a, b)),
+                    (
+                        BinaryOperator::Power | BinaryOperator::InplacePower,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.compile_ipow(a, b)),
                     (
                         BinaryOperator::Lshift | BinaryOperator::Rshift,
                         JitValue::Int(a),
@@ -488,39 +364,57 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                             TrapCode::user(CustomTrapCode::NegativeShiftCount as u8).unwrap(),
                         );
 
-                        let out = if op == BinaryOperator::Lshift {
-                            self.builder.ins().ishl(a, b)
-                        } else {
-                            self.builder.ins().sshr(a, b)
-                        };
+                        let out =
+                            if matches!(op, BinaryOperator::Lshift | BinaryOperator::InplaceLshift)
+                            {
+                                self.builder.ins().ishl(a, b)
+                            } else {
+                                self.builder.ins().sshr(a, b)
+                            };
                         JitValue::Int(out)
                     }
-                    (BinaryOperator::And, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().band(a, b))
-                    }
-                    (BinaryOperator::Or, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().bor(a, b))
-                    }
-                    (BinaryOperator::Xor, JitValue::Int(a), JitValue::Int(b)) => {
-                        JitValue::Int(self.builder.ins().bxor(a, b))
-                    }
+                    (
+                        BinaryOperator::And | BinaryOperator::InplaceAnd,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().band(a, b)),
+                    (
+                        BinaryOperator::Or | BinaryOperator::InplaceOr,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().bor(a, b)),
+                    (
+                        BinaryOperator::Xor | BinaryOperator::InplaceXor,
+                        JitValue::Int(a),
+                        JitValue::Int(b),
+                    ) => JitValue::Int(self.builder.ins().bxor(a, b)),
 
                     // Floats
-                    (BinaryOperator::Add, JitValue::Float(a), JitValue::Float(b)) => {
-                        JitValue::Float(self.builder.ins().fadd(a, b))
-                    }
-                    (BinaryOperator::Subtract, JitValue::Float(a), JitValue::Float(b)) => {
-                        JitValue::Float(self.builder.ins().fsub(a, b))
-                    }
-                    (BinaryOperator::Multiply, JitValue::Float(a), JitValue::Float(b)) => {
-                        JitValue::Float(self.builder.ins().fmul(a, b))
-                    }
-                    (BinaryOperator::Divide, JitValue::Float(a), JitValue::Float(b)) => {
-                        JitValue::Float(self.builder.ins().fdiv(a, b))
-                    }
-                    (BinaryOperator::Power, JitValue::Float(a), JitValue::Float(b)) => {
-                        JitValue::Float(self.compile_fpow(a, b))
-                    }
+                    (
+                        BinaryOperator::Add | BinaryOperator::InplaceAdd,
+                        JitValue::Float(a),
+                        JitValue::Float(b),
+                    ) => JitValue::Float(self.builder.ins().fadd(a, b)),
+                    (
+                        BinaryOperator::Subtract | BinaryOperator::InplaceSubtract,
+                        JitValue::Float(a),
+                        JitValue::Float(b),
+                    ) => JitValue::Float(self.builder.ins().fsub(a, b)),
+                    (
+                        BinaryOperator::Multiply | BinaryOperator::InplaceMultiply,
+                        JitValue::Float(a),
+                        JitValue::Float(b),
+                    ) => JitValue::Float(self.builder.ins().fmul(a, b)),
+                    (
+                        BinaryOperator::TrueDivide | BinaryOperator::InplaceTrueDivide,
+                        JitValue::Float(a),
+                        JitValue::Float(b),
+                    ) => JitValue::Float(self.builder.ins().fdiv(a, b)),
+                    (
+                        BinaryOperator::Power | BinaryOperator::InplacePower,
+                        JitValue::Float(a),
+                        JitValue::Float(b),
+                    ) => JitValue::Float(self.compile_fpow(a, b)),
 
                     // Floats and Integers
                     (_, JitValue::Int(a), JitValue::Float(b))
@@ -536,19 +430,19 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                         };
 
                         match op {
-                            BinaryOperator::Add => {
+                            BinaryOperator::Add | BinaryOperator::InplaceAdd => {
                                 JitValue::Float(self.builder.ins().fadd(operand_one, operand_two))
                             }
-                            BinaryOperator::Subtract => {
+                            BinaryOperator::Subtract | BinaryOperator::InplaceSubtract => {
                                 JitValue::Float(self.builder.ins().fsub(operand_one, operand_two))
                             }
-                            BinaryOperator::Multiply => {
+                            BinaryOperator::Multiply | BinaryOperator::InplaceMultiply => {
                                 JitValue::Float(self.builder.ins().fmul(operand_one, operand_two))
                             }
-                            BinaryOperator::Divide => {
+                            BinaryOperator::TrueDivide | BinaryOperator::InplaceTrueDivide => {
                                 JitValue::Float(self.builder.ins().fdiv(operand_one, operand_two))
                             }
-                            BinaryOperator::Power => {
+                            BinaryOperator::Power | BinaryOperator::InplacePower => {
                                 JitValue::Float(self.compile_fpow(operand_one, operand_two))
                             }
                             _ => return Err(JitCompileError::NotSupported),
@@ -560,27 +454,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
                 Ok(())
             }
-            Instruction::SetupLoop => {
-                let loop_head = self.builder.create_block();
-                self.builder.ins().jump(loop_head, &[]);
-                self.builder.switch_to_block(loop_head);
-                Ok(())
-            }
-            Instruction::PopBlock => {
-                // TODO: block support
+            Instruction::BuildTuple { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize);
+                self.stack.push(JitValue::Tuple(elements));
                 Ok(())
             }
-            Instruction::LoadGlobal(idx) => {
-                let name = &bytecode.names[idx.get(arg) as usize];
-
-                if name.as_ref() != bytecode.obj_name.as_ref() {
-                    Err(JitCompileError::NotSupported)
-                } else {
-                    self.stack.push(JitValue::FuncRef(func_ref));
-                    Ok(())
-                }
-            }
-            Instruction::CallFunctionPositional { nargs } => {
+            Instruction::Call { nargs } => {
                 let nargs = nargs.get(arg);
 
                 let mut args = Vec::new();
@@ -589,6 +468,12 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     args.push(arg.into_value().unwrap());
                 }
 
+                // Pop self_or_null (should be Null for JIT-compiled recursive calls)
+                let self_or_null = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                if !matches!(self_or_null, JitValue::Null) {
+                    return Err(JitCompileError::NotSupported);
+                }
+
                 match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
                     JitValue::FuncRef(reference) => {
                         let call = self.builder.ins().call(reference, &args);
@@ -600,7 +485,162 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                     _ => Err(JitCompileError::BadBytecode),
                 }
             }
+            Instruction::PushNull => {
+                self.stack.push(JitValue::Null);
+                Ok(())
+            }
+            Instruction::CallIntrinsic1 { func } => {
+                match func.get(arg) {
+                    IntrinsicFunction1::UnaryPositive => {
+                        match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                            JitValue::Int(val) => {
+                                // Nothing to do
+                                self.stack.push(JitValue::Int(val));
+                                Ok(())
+                            }
+                            _ => Err(JitCompileError::NotSupported),
+                        }
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
+            }
+            Instruction::CompareOp { op, .. } => {
+                let op = op.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)?;
+
+                let a_type: Option<JitType> = a.to_jit_type();
+                let b_type: Option<JitType> = b.to_jit_type();
+
+                match (a, b) {
+                    (JitValue::Int(a), JitValue::Int(b))
+                    | (JitValue::Bool(a), JitValue::Bool(b))
+                    | (JitValue::Bool(a), JitValue::Int(b))
+                    | (JitValue::Int(a), JitValue::Bool(b)) => {
+                        let operand_one = match a_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, a),
+                            _ => a,
+                        };
+
+                        let operand_two = match b_type.unwrap() {
+                            JitType::Bool => self.builder.ins().uextend(types::I64, b),
+                            _ => b,
+                        };
+
+                        let cond = match op {
+                            ComparisonOperator::Equal => IntCC::Equal,
+                            ComparisonOperator::NotEqual => IntCC::NotEqual,
+                            ComparisonOperator::Less => IntCC::SignedLessThan,
+                            ComparisonOperator::LessOrEqual => IntCC::SignedLessThanOrEqual,
+                            ComparisonOperator::Greater => IntCC::SignedGreaterThan,
+                            ComparisonOperator::GreaterOrEqual => IntCC::SignedGreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().icmp(cond, operand_one, operand_two);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    (JitValue::Float(a), JitValue::Float(b)) => {
+                        let cond = match op {
+                            ComparisonOperator::Equal => FloatCC::Equal,
+                            ComparisonOperator::NotEqual => FloatCC::NotEqual,
+                            ComparisonOperator::Less => FloatCC::LessThan,
+                            ComparisonOperator::LessOrEqual => FloatCC::LessThanOrEqual,
+                            ComparisonOperator::Greater => FloatCC::GreaterThan,
+                            ComparisonOperator::GreaterOrEqual => FloatCC::GreaterThanOrEqual,
+                        };
+
+                        let val = self.builder.ins().fcmp(cond, a, b);
+                        self.stack.push(JitValue::Bool(val));
+                        Ok(())
+                    }
+                    _ => 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));
+                self.builder.ins().jump(target_block, &[]);
+                Ok(())
+            }
+            Instruction::LoadConst { idx } => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.stack.push(val);
+                Ok(())
+            }
+            Instruction::LoadFast(idx) => {
+                let local = self.variables[idx.get(arg) as usize]
+                    .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::LoadGlobal(idx) => {
+                let name = &bytecode.names[idx.get(arg) as usize];
+
+                if name.as_ref() != bytecode.obj_name.as_ref() {
+                    Err(JitCompileError::NotSupported)
+                } else {
+                    self.stack.push(JitValue::FuncRef(func_ref));
+                    Ok(())
+                }
+            }
             Instruction::Nop => Ok(()),
+            Instruction::PopJumpIfFalse { target } => {
+                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 else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, else_block, &[], then_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::PopJumpIfTrue { target } => {
+                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 else_block = self.builder.create_block();
+
+                self.builder
+                    .ins()
+                    .brif(val, then_block, &[], else_block, &[]);
+                self.builder.switch_to_block(else_block);
+
+                Ok(())
+            }
+            Instruction::PopTop => {
+                self.stack.pop();
+                Ok(())
+            }
+            Instruction::Resume { arg: _resume_arg } => {
+                // TODO: Implement the resume instruction
+                Ok(())
+            }
+            Instruction::ReturnConst { idx } => {
+                let val = self
+                    .prepare_const(bytecode.constants[idx.get(arg) as usize].borrow_constant())?;
+                self.return_value(val)
+            }
+            Instruction::ReturnValue => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.return_value(val)
+            }
+            Instruction::StoreFast(idx) => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                self.store_variable(idx.get(arg), val)
+            }
             Instruction::Swap { index } => {
                 let len = self.stack.len();
                 let i = len - 1;
@@ -608,8 +648,46 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
                 self.stack.swap(i, j);
                 Ok(())
             }
-            Instruction::Pop => {
-                self.stack.pop();
+            Instruction::ToBool => {
+                let a = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+                let value = self.boolean_val(a)?;
+                self.stack.push(JitValue::Bool(value));
+                Ok(())
+            }
+            Instruction::UnaryNot => {
+                let boolean = match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                    JitValue::Bool(val) => val,
+                    _ => return Err(JitCompileError::BadBytecode),
+                };
+                let not_boolean = self.builder.ins().bxor_imm(boolean, 1);
+                self.stack.push(JitValue::Bool(not_boolean));
+                Ok(())
+            }
+            Instruction::UnaryNegative => {
+                match self.stack.pop().ok_or(JitCompileError::BadBytecode)? {
+                    JitValue::Int(val) => {
+                        // Compile minus as 0 - val.
+                        let zero = self.builder.ins().iconst(types::I64, 0);
+                        let out = self.compile_sub(zero, val);
+                        self.stack.push(JitValue::Int(out));
+                        Ok(())
+                    }
+                    _ => Err(JitCompileError::NotSupported),
+                }
+            }
+            Instruction::UnpackSequence { size } => {
+                let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
+
+                let elements = match val {
+                    JitValue::Tuple(elements) => elements,
+                    _ => return Err(JitCompileError::NotSupported),
+                };
+
+                if elements.len() != size.get(arg) as usize {
+                    return Err(JitCompileError::NotSupported);
+                }
+
+                self.stack.extend(elements.into_iter().rev());
                 Ok(())
             }
             _ => Err(JitCompileError::NotSupported),
@@ -980,7 +1058,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_b_zero, b_zero_block, &[], continue_block, &[]);
         self.builder.switch_to_block(b_zero_block);
-        self.builder.ins().jump(merge_block, &[one_f]);
+        self.builder.ins().jump(merge_block, &[one_f.into()]);
         self.builder.switch_to_block(continue_block);
 
         // --- Edge Case 2: b is NaN → return NaN
@@ -991,7 +1069,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_b_nan, b_nan_block, &[], continue_block2, &[]);
         self.builder.switch_to_block(b_nan_block);
-        self.builder.ins().jump(merge_block, &[nan_f]);
+        self.builder.ins().jump(merge_block, &[nan_f.into()]);
         self.builder.switch_to_block(continue_block2);
 
         // --- Edge Case 3: a == 0.0 → return 0.0
@@ -1002,7 +1080,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_a_zero, a_zero_block, &[], continue_block3, &[]);
         self.builder.switch_to_block(a_zero_block);
-        self.builder.ins().jump(merge_block, &[zero_f]);
+        self.builder.ins().jump(merge_block, &[zero_f.into()]);
         self.builder.switch_to_block(continue_block3);
 
         // --- Edge Case 4: a is NaN → return NaN
@@ -1013,7 +1091,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_a_nan, a_nan_block, &[], continue_block4, &[]);
         self.builder.switch_to_block(a_nan_block);
-        self.builder.ins().jump(merge_block, &[nan_f]);
+        self.builder.ins().jump(merge_block, &[nan_f.into()]);
         self.builder.switch_to_block(continue_block4);
 
         // --- Edge Case 5: b == +infinity → return +infinity
@@ -1024,7 +1102,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_b_inf, b_inf_block, &[], continue_block5, &[]);
         self.builder.switch_to_block(b_inf_block);
-        self.builder.ins().jump(merge_block, &[inf_f]);
+        self.builder.ins().jump(merge_block, &[inf_f.into()]);
         self.builder.switch_to_block(continue_block5);
 
         // --- Edge Case 6: b == -infinity → return 0.0
@@ -1035,7 +1113,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_b_neg_inf, b_neg_inf_block, &[], continue_block6, &[]);
         self.builder.switch_to_block(b_neg_inf_block);
-        self.builder.ins().jump(merge_block, &[zero_f]);
+        self.builder.ins().jump(merge_block, &[zero_f.into()]);
         self.builder.switch_to_block(continue_block6);
 
         // --- Edge Case 7: a == +infinity → return +infinity
@@ -1046,7 +1124,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .ins()
             .brif(cmp_a_inf, a_inf_block, &[], continue_block7, &[]);
         self.builder.switch_to_block(a_inf_block);
-        self.builder.ins().jump(merge_block, &[inf_f]);
+        self.builder.ins().jump(merge_block, &[inf_f.into()]);
         self.builder.switch_to_block(continue_block7);
 
         // --- Edge Case 8: a == -infinity → check exponent parity
@@ -1068,7 +1146,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
             .brif(cmp_int, continue_neg_inf, &[], domain_error_blk, &[]);
 
         self.builder.switch_to_block(domain_error_blk);
-        self.builder.ins().jump(merge_block, &[nan_f]);
+        self.builder.ins().jump(merge_block, &[nan_f.into()]);
 
         self.builder.switch_to_block(continue_neg_inf);
         // b is an integer here; convert b_floor to an i64.
@@ -1083,17 +1161,21 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         let even_block = self.builder.create_block();
         self.builder.append_block_param(odd_block, f64_ty);
         self.builder.append_block_param(even_block, f64_ty);
-        self.builder
-            .ins()
-            .brif(is_odd, odd_block, &[neg_inf_f], even_block, &[inf_f]);
+        self.builder.ins().brif(
+            is_odd,
+            odd_block,
+            &[neg_inf_f.into()],
+            even_block,
+            &[inf_f.into()],
+        );
 
         self.builder.switch_to_block(odd_block);
         let phi_neg_inf = self.builder.block_params(odd_block)[0];
-        self.builder.ins().jump(merge_block, &[phi_neg_inf]);
+        self.builder.ins().jump(merge_block, &[phi_neg_inf.into()]);
 
         self.builder.switch_to_block(even_block);
         let phi_inf = self.builder.block_params(even_block)[0];
-        self.builder.ins().jump(merge_block, &[phi_inf]);
+        self.builder.ins().jump(merge_block, &[phi_inf.into()]);
 
         self.builder.switch_to_block(continue_block8);
 
@@ -1113,7 +1195,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         let product_dd = self.dd_mul(ln_a_dd, b_dd);
         let exp_dd = self.dd_exp(product_dd);
         let pos_res = self.dd_to_f64(exp_dd);
-        self.builder.ins().jump(merge_block, &[pos_res]);
+        self.builder.ins().jump(merge_block, &[pos_res.into()]);
 
         // ----- Case: a < 0: Only allow an integral exponent.
         self.builder.switch_to_block(a_neg_block);
@@ -1127,7 +1209,7 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
 
         // Domain error: non-integer exponent for negative base
         self.builder.switch_to_block(domain_error_blk);
-        self.builder.ins().jump(merge_block, &[nan_f]);
+        self.builder.ins().jump(merge_block, &[nan_f.into()]);
 
         // For negative base with an integer exponent:
         self.builder.switch_to_block(neg_int_block);
@@ -1150,18 +1232,24 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         self.builder.append_block_param(odd_block, f64_ty);
         self.builder.append_block_param(even_block, f64_ty);
         // Pass mag_val to both branches:
-        self.builder
-            .ins()
-            .brif(is_odd, odd_block, &[mag_val], even_block, &[mag_val]);
+        self.builder.ins().brif(
+            is_odd,
+            odd_block,
+            &[mag_val.into()],
+            even_block,
+            &[mag_val.into()],
+        );
 
         self.builder.switch_to_block(odd_block);
         let phi_mag_val = self.builder.block_params(odd_block)[0];
         let neg_val = self.builder.ins().fneg(phi_mag_val);
-        self.builder.ins().jump(merge_block, &[neg_val]);
+        self.builder.ins().jump(merge_block, &[neg_val.into()]);
 
         self.builder.switch_to_block(even_block);
         let phi_mag_val_even = self.builder.block_params(even_block)[0];
-        self.builder.ins().jump(merge_block, &[phi_mag_val_even]);
+        self.builder
+            .ins()
+            .jump(merge_block, &[phi_mag_val_even.into()]);
 
         // ----- Merge: Return the final result.
         self.builder.switch_to_block(merge_block);
@@ -1198,7 +1286,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         self.builder.append_block_param(continue_block, types::I64); // base
 
         // Initial jump to check if exponent is negative
-        self.builder.ins().jump(check_negative, &[b, a]);
+        self.builder
+            .ins()
+            .jump(check_negative, &[b.into(), a.into()]);
 
         // Check if exponent is negative
         self.builder.switch_to_block(check_negative);
@@ -1213,14 +1303,14 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         self.builder.ins().brif(
             is_negative,
             handle_negative,
-            &[exp_check, base_check],
+            &[exp_check.into(), base_check.into()],
             loop_block,
-            &[exp_check, one_i64, base_check],
+            &[exp_check.into(), one_i64.into(), base_check.into()],
         );
 
         // Handle negative exponent (return 0 for integer exponentiation)
         self.builder.switch_to_block(handle_negative);
-        self.builder.ins().jump(exit_block, &[zero]); // Return 0 for negative exponents
+        self.builder.ins().jump(exit_block, &[zero.into()]); // Return 0 for negative exponents
 
         // Loop block logic (square-and-multiply algorithm)
         self.builder.switch_to_block(loop_block);
@@ -1234,9 +1324,9 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         self.builder.ins().brif(
             is_zero,
             exit_block,
-            &[result_phi],
+            &[result_phi.into()],
             continue_block,
-            &[exp_phi, result_phi, base_phi],
+            &[exp_phi.into(), result_phi.into(), base_phi.into()],
         );
 
         // Continue block for non-zero case
@@ -1255,9 +1345,10 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         // Square the base and divide exponent by 2
         let squared_base = self.builder.ins().imul(base_phi, base_phi);
         let new_exp = self.builder.ins().sshr_imm(exp_phi, 1);
-        self.builder
-            .ins()
-            .jump(loop_block, &[new_exp, new_result, squared_base]);
+        self.builder.ins().jump(
+            loop_block,
+            &[new_exp.into(), new_result.into(), squared_base.into()],
+        );
 
         // Exit block
         self.builder.switch_to_block(exit_block);
diff --git a/crates/jit/src/lib.rs b/crates/jit/src/lib.rs
new file mode 100644
index 0000000000..1e27861766
--- /dev/null
+++ b/crates/jit/src/lib.rs
@@ -0,0 +1,377 @@
+mod instructions;
+
+extern crate alloc;
+
+use alloc::fmt;
+use core::mem::ManuallyDrop;
+use cranelift::prelude::*;
+use cranelift_jit::{JITBuilder, JITModule};
+use cranelift_module::{FuncId, Linkage, Module, ModuleError};
+use instructions::FunctionCompiler;
+use rustpython_compiler_core::bytecode;
+
+#[derive(Debug, thiserror::Error)]
+#[non_exhaustive]
+pub enum JitCompileError {
+    #[error("function can't be jitted")]
+    NotSupported,
+    #[error("bad bytecode")]
+    BadBytecode,
+    #[error("error while compiling to machine code: {0}")]
+    CraneliftError(Box<ModuleError>),
+}
+
+impl From<ModuleError> for JitCompileError {
+    fn from(err: ModuleError) -> Self {
+        Self::CraneliftError(Box::new(err))
+    }
+}
+
+#[derive(Debug, thiserror::Error, Eq, PartialEq)]
+#[non_exhaustive]
+pub enum JitArgumentError {
+    #[error("argument is of wrong type")]
+    ArgumentTypeMismatch,
+    #[error("wrong number of arguments")]
+    WrongNumberOfArguments,
+}
+
+struct Jit {
+    builder_context: FunctionBuilderContext,
+    ctx: codegen::Context,
+    module: JITModule,
+}
+
+impl Jit {
+    fn new() -> Self {
+        let builder = JITBuilder::new(cranelift_module::default_libcall_names())
+            .expect("Failed to build JITBuilder");
+        let module = JITModule::new(builder);
+        Self {
+            builder_context: FunctionBuilderContext::new(),
+            ctx: module.make_context(),
+            module,
+        }
+    }
+
+    fn build_function<C: bytecode::Constant>(
+        &mut self,
+        bytecode: &bytecode::CodeObject<C>,
+        args: &[JitType],
+        ret: Option<JitType>,
+    ) -> Result<(FuncId, JitSig), JitCompileError> {
+        for arg in args {
+            self.ctx
+                .func
+                .signature
+                .params
+                .push(AbiParam::new(arg.to_cranelift()));
+        }
+
+        if ret.is_some() {
+            self.ctx
+                .func
+                .signature
+                .returns
+                .push(AbiParam::new(ret.clone().unwrap().to_cranelift()));
+        }
+
+        let id = self.module.declare_function(
+            &format!("jit_{}", bytecode.obj_name.as_ref()),
+            Linkage::Export,
+            &self.ctx.func.signature,
+        )?;
+
+        let func_ref = self.module.declare_func_in_func(id, &mut self.ctx.func);
+
+        let mut builder = FunctionBuilder::new(&mut self.ctx.func, &mut self.builder_context);
+        let entry_block = builder.create_block();
+        builder.append_block_params_for_function_params(entry_block);
+        builder.switch_to_block(entry_block);
+
+        let sig = {
+            let mut compiler = FunctionCompiler::new(
+                &mut builder,
+                bytecode.varnames.len(),
+                args,
+                ret,
+                entry_block,
+            );
+
+            compiler.compile(func_ref, bytecode)?;
+
+            compiler.sig
+        };
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        self.module.define_function(id, &mut self.ctx)?;
+
+        self.module.clear_context(&mut self.ctx);
+
+        Ok((id, sig))
+    }
+}
+
+pub fn compile<C: bytecode::Constant>(
+    bytecode: &bytecode::CodeObject<C>,
+    args: &[JitType],
+    ret: Option<JitType>,
+) -> Result<CompiledCode, JitCompileError> {
+    let mut jit = Jit::new();
+
+    let (id, sig) = jit.build_function(bytecode, args, ret)?;
+
+    jit.module.finalize_definitions()?;
+
+    let code = jit.module.get_finalized_function(id);
+    Ok(CompiledCode {
+        sig,
+        code,
+        module: ManuallyDrop::new(jit.module),
+    })
+}
+
+pub struct CompiledCode {
+    sig: JitSig,
+    code: *const u8,
+    module: ManuallyDrop<JITModule>,
+}
+
+impl CompiledCode {
+    pub fn args_builder(&self) -> ArgsBuilder<'_> {
+        ArgsBuilder::new(self)
+    }
+
+    pub fn invoke(&self, args: &[AbiValue]) -> Result<Option<AbiValue>, JitArgumentError> {
+        if self.sig.args.len() != args.len() {
+            return Err(JitArgumentError::WrongNumberOfArguments);
+        }
+
+        let cif_args = self
+            .sig
+            .args
+            .iter()
+            .zip(args.iter())
+            .map(|(ty, val)| type_check(ty, val).map(|_| val))
+            .map(|v| v.map(AbiValue::to_libffi_arg))
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(unsafe { self.invoke_raw(&cif_args) })
+    }
+
+    unsafe fn invoke_raw(&self, cif_args: &[libffi::middle::Arg<'_>]) -> Option<AbiValue> {
+        unsafe {
+            let cif = self.sig.to_cif();
+            let value = cif.call::<UnTypedAbiValue>(
+                libffi::middle::CodePtr::from_ptr(self.code as *const _),
+                cif_args,
+            );
+            self.sig.ret.as_ref().map(|ty| value.to_typed(ty))
+        }
+    }
+}
+
+struct JitSig {
+    args: Vec<JitType>,
+    ret: Option<JitType>,
+}
+
+impl JitSig {
+    fn to_cif(&self) -> libffi::middle::Cif {
+        let ret = match self.ret {
+            Some(ref ty) => ty.to_libffi(),
+            None => libffi::middle::Type::void(),
+        };
+        libffi::middle::Cif::new(self.args.iter().map(JitType::to_libffi), ret)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum JitType {
+    Int,
+    Float,
+    Bool,
+}
+
+impl JitType {
+    fn to_cranelift(&self) -> types::Type {
+        match self {
+            Self::Int => types::I64,
+            Self::Float => types::F64,
+            Self::Bool => types::I8,
+        }
+    }
+
+    fn to_libffi(&self) -> libffi::middle::Type {
+        match self {
+            Self::Int => libffi::middle::Type::i64(),
+            Self::Float => libffi::middle::Type::f64(),
+            Self::Bool => libffi::middle::Type::u8(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+#[non_exhaustive]
+pub enum AbiValue {
+    Float(f64),
+    Int(i64),
+    Bool(bool),
+}
+
+impl AbiValue {
+    fn to_libffi_arg(&self) -> libffi::middle::Arg<'_> {
+        match self {
+            AbiValue::Int(i) => libffi::middle::Arg::new(i),
+            AbiValue::Float(f) => libffi::middle::Arg::new(f),
+            AbiValue::Bool(b) => libffi::middle::Arg::new(b),
+        }
+    }
+}
+
+impl From<i64> for AbiValue {
+    fn from(i: i64) -> Self {
+        AbiValue::Int(i)
+    }
+}
+
+impl From<f64> for AbiValue {
+    fn from(f: f64) -> Self {
+        AbiValue::Float(f)
+    }
+}
+
+impl From<bool> for AbiValue {
+    fn from(b: bool) -> Self {
+        AbiValue::Bool(b)
+    }
+}
+
+impl TryFrom<AbiValue> for i64 {
+    type Error = ();
+
+    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
+        match value {
+            AbiValue::Int(i) => Ok(i),
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<AbiValue> for f64 {
+    type Error = ();
+
+    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
+        match value {
+            AbiValue::Float(f) => Ok(f),
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<AbiValue> for bool {
+    type Error = ();
+
+    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
+        match value {
+            AbiValue::Bool(b) => Ok(b),
+            _ => Err(()),
+        }
+    }
+}
+
+fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {
+    match (ty, val) {
+        (JitType::Int, AbiValue::Int(_))
+        | (JitType::Float, AbiValue::Float(_))
+        | (JitType::Bool, AbiValue::Bool(_)) => Ok(()),
+        _ => Err(JitArgumentError::ArgumentTypeMismatch),
+    }
+}
+
+#[derive(Copy, Clone)]
+union UnTypedAbiValue {
+    float: f64,
+    int: i64,
+    boolean: u8,
+    _void: (),
+}
+
+impl UnTypedAbiValue {
+    unsafe fn to_typed(self, ty: &JitType) -> AbiValue {
+        unsafe {
+            match ty {
+                JitType::Int => AbiValue::Int(self.int),
+                JitType::Float => AbiValue::Float(self.float),
+                JitType::Bool => AbiValue::Bool(self.boolean != 0),
+            }
+        }
+    }
+}
+
+// we don't actually ever touch CompiledCode til we drop it, it should be safe.
+// TODO: confirm with wasmtime ppl that it's not unsound?
+unsafe impl Send for CompiledCode {}
+unsafe impl Sync for CompiledCode {}
+
+impl Drop for CompiledCode {
+    fn drop(&mut self) {
+        // SAFETY: The only pointer that this memory will also be dropped now
+        unsafe { ManuallyDrop::take(&mut self.module).free_memory() }
+    }
+}
+
+impl fmt::Debug for CompiledCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("[compiled code]")
+    }
+}
+
+pub struct ArgsBuilder<'a> {
+    values: Vec<Option<AbiValue>>,
+    code: &'a CompiledCode,
+}
+
+impl<'a> ArgsBuilder<'a> {
+    fn new(code: &'a CompiledCode) -> ArgsBuilder<'a> {
+        ArgsBuilder {
+            values: vec![None; code.sig.args.len()],
+            code,
+        }
+    }
+
+    pub fn set(&mut self, idx: usize, value: AbiValue) -> Result<(), JitArgumentError> {
+        type_check(&self.code.sig.args[idx], &value).map(|_| {
+            self.values[idx] = Some(value);
+        })
+    }
+
+    pub fn is_set(&self, idx: usize) -> bool {
+        self.values[idx].is_some()
+    }
+
+    pub fn into_args(self) -> Option<Args<'a>> {
+        // Ensure all values are set
+        if self.values.iter().any(|v| v.is_none()) {
+            return None;
+        }
+        Some(Args {
+            values: self.values.into_iter().map(|v| v.unwrap()).collect(),
+            code: self.code,
+        })
+    }
+}
+
+pub struct Args<'a> {
+    values: Vec<AbiValue>,
+    code: &'a CompiledCode,
+}
+
+impl Args<'_> {
+    pub fn invoke(&self) -> Option<AbiValue> {
+        let cif_args: Vec<_> = self.values.iter().map(AbiValue::to_libffi_arg).collect();
+        unsafe { self.code.invoke_raw(&cif_args) }
+    }
+}
diff --git a/jit/tests/bool_tests.rs b/crates/jit/tests/bool_tests.rs
similarity index 100%
rename from jit/tests/bool_tests.rs
rename to crates/jit/tests/bool_tests.rs
diff --git a/jit/tests/common.rs b/crates/jit/tests/common.rs
similarity index 78%
rename from jit/tests/common.rs
rename to crates/jit/tests/common.rs
index 16a4fded46..eabf27471b 100644
--- a/jit/tests/common.rs
+++ b/crates/jit/tests/common.rs
@@ -1,9 +1,9 @@
+use core::ops::ControlFlow;
 use rustpython_compiler_core::bytecode::{
     CodeObject, ConstantData, Instruction, OpArg, OpArgState,
 };
 use rustpython_jit::{CompiledCode, JitType};
 use std::collections::HashMap;
-use std::ops::ControlFlow;
 
 #[derive(Debug, Clone)]
 pub struct Function {
@@ -96,10 +96,10 @@ impl StackMachine {
                 let idx = idx.get(arg);
                 self.stack.push(constants[idx as usize].clone().into())
             }
-            Instruction::LoadNameAny(idx) => self
+            Instruction::LoadName(idx) => self
                 .stack
                 .push(StackValue::String(names[idx.get(arg) as usize].clone())),
-            Instruction::StoreLocal(idx) => {
+            Instruction::StoreName(idx) => {
                 let idx = idx.get(arg);
                 self.locals
                     .insert(names[idx as usize].clone(), self.stack.pop().unwrap());
@@ -122,36 +122,47 @@ impl StackMachine {
                 }
                 self.stack.push(StackValue::Map(map));
             }
-            Instruction::MakeFunction(_flags) => {
-                let _name = if let Some(StackValue::String(name)) = self.stack.pop() {
-                    name
-                } else {
-                    panic!("Expected function name")
-                };
+            Instruction::MakeFunction => {
                 let code = if let Some(StackValue::Code(code)) = self.stack.pop() {
                     code
                 } else {
                     panic!("Expected function code")
                 };
-                let annotations = if let Some(StackValue::Map(map)) = self.stack.pop() {
-                    map
+                // Other attributes will be set by SET_FUNCTION_ATTRIBUTE
+                self.stack.push(StackValue::Function(Function {
+                    code,
+                    annotations: HashMap::new(), // empty annotations, will be set later if needed
+                }));
+            }
+            Instruction::SetFunctionAttribute { attr } => {
+                // Stack: [..., attr_value, func] -> [..., func]
+                let func = if let Some(StackValue::Function(func)) = self.stack.pop() {
+                    func
                 } else {
-                    panic!("Expected function annotations")
+                    panic!("Expected function on stack for SET_FUNCTION_ATTRIBUTE")
                 };
-                self.stack
-                    .push(StackValue::Function(Function { code, annotations }));
-            }
-            Instruction::Duplicate => {
-                let value = self.stack.last().unwrap().clone();
-                self.stack.push(value);
-            }
-            Instruction::Rotate2 => {
-                let i = self.stack.len() - 2;
-                self.stack[i..].rotate_right(1);
-            }
-            Instruction::Rotate3 => {
-                let i = self.stack.len() - 3;
-                self.stack[i..].rotate_right(1);
+                let attr_value = self.stack.pop().expect("Expected attribute value on stack");
+
+                // For now, we only handle ANNOTATIONS flag in JIT tests
+                if attr
+                    .get(arg)
+                    .contains(rustpython_compiler_core::bytecode::MakeFunctionFlags::ANNOTATIONS)
+                {
+                    if let StackValue::Map(annotations) = attr_value {
+                        // Update function's annotations
+                        let updated_func = Function {
+                            code: func.code,
+                            annotations,
+                        };
+                        self.stack.push(StackValue::Function(updated_func));
+                    } else {
+                        panic!("Expected annotations to be a map");
+                    }
+                } else {
+                    // For other attributes, just push the function back unchanged
+                    // (since JIT tests mainly care about type annotations)
+                    self.stack.push(StackValue::Function(func));
+                }
             }
             Instruction::ReturnConst { idx } => {
                 let idx = idx.get(arg);
diff --git a/jit/tests/float_tests.rs b/crates/jit/tests/float_tests.rs
similarity index 100%
rename from jit/tests/float_tests.rs
rename to crates/jit/tests/float_tests.rs
diff --git a/jit/tests/int_tests.rs b/crates/jit/tests/int_tests.rs
similarity index 100%
rename from jit/tests/int_tests.rs
rename to crates/jit/tests/int_tests.rs
diff --git a/jit/tests/lib.rs b/crates/jit/tests/lib.rs
similarity index 100%
rename from jit/tests/lib.rs
rename to crates/jit/tests/lib.rs
diff --git a/jit/tests/misc_tests.rs b/crates/jit/tests/misc_tests.rs
similarity index 100%
rename from jit/tests/misc_tests.rs
rename to crates/jit/tests/misc_tests.rs
diff --git a/jit/tests/none_tests.rs b/crates/jit/tests/none_tests.rs
similarity index 100%
rename from jit/tests/none_tests.rs
rename to crates/jit/tests/none_tests.rs
diff --git a/crates/literal/Cargo.toml b/crates/literal/Cargo.toml
new file mode 100644
index 0000000000..bd6a269974
--- /dev/null
+++ b/crates/literal/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "rustpython-literal"
+description = "Common literal handling utilities mostly useful for unparse and repr."
+edition = { workspace = true }
+version = { workspace = true }
+authors = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+rust-version = { workspace = true }
+
+[dependencies]
+rustpython-wtf8 = { workspace = true }
+
+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 }
+
+[dev-dependencies]
+rand = { workspace = true }
diff --git a/compiler/literal/src/char.rs b/crates/literal/src/char.rs
similarity index 100%
rename from compiler/literal/src/char.rs
rename to crates/literal/src/char.rs
diff --git a/compiler/literal/src/complex.rs b/crates/literal/src/complex.rs
similarity index 100%
rename from compiler/literal/src/complex.rs
rename to crates/literal/src/complex.rs
diff --git a/compiler/literal/src/escape.rs b/crates/literal/src/escape.rs
similarity index 90%
rename from compiler/literal/src/escape.rs
rename to crates/literal/src/escape.rs
index 920e0a8cb1..72ceaf60d5 100644
--- a/compiler/literal/src/escape.rs
+++ b/crates/literal/src/escape.rs
@@ -8,26 +8,26 @@ pub enum Quote {
 
 impl Quote {
     #[inline]
-    pub const fn swap(self) -> Quote {
+    pub const fn swap(self) -> Self {
         match self {
-            Quote::Single => Quote::Double,
-            Quote::Double => Quote::Single,
+            Self::Single => Self::Double,
+            Self::Double => Self::Single,
         }
     }
 
     #[inline]
     pub const fn to_byte(&self) -> u8 {
         match self {
-            Quote::Single => b'\'',
-            Quote::Double => b'"',
+            Self::Single => b'\'',
+            Self::Double => b'"',
         }
     }
 
     #[inline]
     pub const fn to_char(&self) -> char {
         match self {
-            Quote::Single => '\'',
-            Quote::Double => '"',
+            Self::Single => '\'',
+            Self::Double => '"',
         }
     }
 }
@@ -55,9 +55,9 @@ pub unsafe trait Escape {
     /// # Safety
     ///
     /// This string must only contain printable characters.
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result;
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result;
-    fn write_body(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result;
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result;
+    fn write_body(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         if self.changed() {
             self.write_body_slow(formatter)
         } else {
@@ -95,7 +95,7 @@ pub struct UnicodeEscape<'a> {
 
 impl<'a> UnicodeEscape<'a> {
     #[inline]
-    pub fn with_forced_quote(source: &'a Wtf8, quote: Quote) -> Self {
+    pub const fn with_forced_quote(source: &'a Wtf8, quote: Quote) -> Self {
         let layout = EscapeLayout { quote, len: None };
         Self { source, layout }
     }
@@ -109,7 +109,7 @@ impl<'a> UnicodeEscape<'a> {
         Self::with_preferred_quote(source, Quote::Single)
     }
     #[inline]
-    pub fn str_repr<'r>(&'a self) -> StrRepr<'r, 'a> {
+    pub const fn str_repr<'r>(&'a self) -> StrRepr<'r, 'a> {
         StrRepr(self)
     }
 }
@@ -117,7 +117,7 @@ impl<'a> UnicodeEscape<'a> {
 pub struct StrRepr<'r, 'a>(&'r UnicodeEscape<'a>);
 
 impl StrRepr<'_, '_> {
-    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char(quote)?;
         self.0.write_body(formatter)?;
@@ -131,8 +131,8 @@ impl StrRepr<'_, '_> {
     }
 }
 
-impl std::fmt::Display for StrRepr<'_, '_> {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for StrRepr<'_, '_> {
+    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.write(formatter)
     }
 }
@@ -169,7 +169,7 @@ impl UnicodeEscape<'_> {
             };
             let Some(new_len) = length_add(out_len, incr) else {
                 #[cold]
-                fn stop(
+                const fn stop(
                     single_count: usize,
                     double_count: usize,
                     preferred_quote: Quote,
@@ -217,7 +217,7 @@ impl UnicodeEscape<'_> {
         ch: CodePoint,
         quote: Quote,
         formatter: &mut impl std::fmt::Write,
-    ) -> std::fmt::Result {
+    ) -> core::fmt::Result {
         let Some(ch) = ch.to_char() else {
             return write!(formatter, "\\u{:04x}", ch.to_u32());
         };
@@ -260,7 +260,7 @@ unsafe impl Escape for UnicodeEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         formatter.write_str(unsafe {
             // SAFETY: this function must be called only when source is printable characters (i.e. no surrogates)
             std::str::from_utf8_unchecked(self.source.as_bytes())
@@ -268,7 +268,7 @@ unsafe impl Escape for UnicodeEscape<'_> {
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         for ch in self.source.code_points() {
             Self::write_char(ch, self.layout().quote, formatter)?;
         }
@@ -283,11 +283,11 @@ pub struct AsciiEscape<'a> {
 
 impl<'a> AsciiEscape<'a> {
     #[inline]
-    pub fn new(source: &'a [u8], layout: EscapeLayout) -> Self {
+    pub const fn new(source: &'a [u8], layout: EscapeLayout) -> Self {
         Self { source, layout }
     }
     #[inline]
-    pub fn with_forced_quote(source: &'a [u8], quote: Quote) -> Self {
+    pub const fn with_forced_quote(source: &'a [u8], quote: Quote) -> Self {
         let layout = EscapeLayout { quote, len: None };
         Self { source, layout }
     }
@@ -301,7 +301,7 @@ impl<'a> AsciiEscape<'a> {
         Self::with_preferred_quote(source, Quote::Single)
     }
     #[inline]
-    pub fn bytes_repr<'r>(&'a self) -> BytesRepr<'r, 'a> {
+    pub const fn bytes_repr<'r>(&'a self) -> BytesRepr<'r, 'a> {
         BytesRepr(self)
     }
 }
@@ -329,7 +329,7 @@ impl AsciiEscape<'_> {
         let mut single_count = 0;
         let mut double_count = 0;
 
-        for ch in source.iter() {
+        for ch in source {
             let incr = match ch {
                 b'\'' => {
                     single_count += 1;
@@ -343,7 +343,7 @@ impl AsciiEscape<'_> {
             };
             let Some(new_len) = length_add(out_len, incr) else {
                 #[cold]
-                fn stop(
+                const fn stop(
                     single_count: usize,
                     double_count: usize,
                     preferred_quote: Quote,
@@ -370,7 +370,7 @@ impl AsciiEscape<'_> {
         }
     }
 
-    fn escaped_char_len(ch: u8) -> usize {
+    const fn escaped_char_len(ch: u8) -> usize {
         match ch {
             b'\\' | b'\t' | b'\r' | b'\n' => 2,
             0x20..=0x7e => 1,
@@ -378,7 +378,7 @@ impl AsciiEscape<'_> {
         }
     }
 
-    fn write_char(ch: u8, quote: Quote, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    fn write_char(ch: u8, quote: Quote, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         match ch {
             b'\t' => formatter.write_str("\\t"),
             b'\n' => formatter.write_str("\\n"),
@@ -404,7 +404,7 @@ unsafe impl Escape for AsciiEscape<'_> {
         &self.layout
     }
 
-    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    unsafe fn write_source(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         formatter.write_str(unsafe {
             // SAFETY: this function must be called only when source is printable ascii characters
             std::str::from_utf8_unchecked(self.source)
@@ -412,8 +412,8 @@ unsafe impl Escape for AsciiEscape<'_> {
     }
 
     #[cold]
-    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
-        for ch in self.source.iter() {
+    fn write_body_slow(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
+        for ch in self.source {
             Self::write_char(*ch, self.layout().quote, formatter)?;
         }
         Ok(())
@@ -423,7 +423,7 @@ unsafe impl Escape for AsciiEscape<'_> {
 pub struct BytesRepr<'r, 'a>(&'r AsciiEscape<'a>);
 
 impl BytesRepr<'_, '_> {
-    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> std::fmt::Result {
+    pub fn write(&self, formatter: &mut impl std::fmt::Write) -> core::fmt::Result {
         let quote = self.0.layout().quote.to_char();
         formatter.write_char('b')?;
         formatter.write_char(quote)?;
@@ -438,8 +438,8 @@ impl BytesRepr<'_, '_> {
     }
 }
 
-impl std::fmt::Display for BytesRepr<'_, '_> {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for BytesRepr<'_, '_> {
+    fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.write(formatter)
     }
 }
diff --git a/crates/literal/src/float.rs b/crates/literal/src/float.rs
new file mode 100644
index 0000000000..4d0d65cbb3
--- /dev/null
+++ b/crates/literal/src/float.rs
@@ -0,0 +1,298 @@
+use crate::format::Case;
+use num_traits::{Float, Zero};
+use std::f64;
+
+pub fn parse_str(literal: &str) -> Option<f64> {
+    parse_inner(literal.trim().as_bytes())
+}
+
+pub fn parse_bytes(literal: &[u8]) -> Option<f64> {
+    parse_inner(literal.trim_ascii())
+}
+
+fn parse_inner(literal: &[u8]) -> Option<f64> {
+    use lexical_parse_float::{
+        FromLexicalWithOptions, NumberFormatBuilder, Options, format::PYTHON3_LITERAL,
+    };
+
+    // lexical-core's format::PYTHON_STRING is inaccurate
+    const PYTHON_STRING: u128 = NumberFormatBuilder::rebuild(PYTHON3_LITERAL)
+        .no_special(false)
+        .build_unchecked();
+    f64::from_lexical_with_options::<PYTHON_STRING>(literal, &Options::new()).ok()
+}
+
+pub fn is_integer(v: f64) -> bool {
+    (v - v.round()).abs() < f64::EPSILON
+}
+
+fn format_nan(case: Case) -> String {
+    let nan = match case {
+        Case::Lower => "nan",
+        Case::Upper => "NAN",
+    };
+
+    nan.to_string()
+}
+
+fn format_inf(case: Case) -> String {
+    let inf = match case {
+        Case::Lower => "inf",
+        Case::Upper => "INF",
+    };
+
+    inf.to_string()
+}
+
+pub const fn decimal_point_or_empty(precision: usize, alternate_form: bool) -> &'static str {
+    match (precision, alternate_form) {
+        (0, true) => ".",
+        _ => "",
+    }
+}
+
+pub fn format_fixed(precision: usize, magnitude: f64, case: Case, alternate_form: bool) -> String {
+    match magnitude {
+        magnitude if magnitude.is_finite() => {
+            let point = decimal_point_or_empty(precision, alternate_form);
+            let precision = core::cmp::min(precision, u16::MAX as usize);
+            format!("{magnitude:.precision$}{point}")
+        }
+        magnitude if magnitude.is_nan() => format_nan(case),
+        magnitude if magnitude.is_infinite() => format_inf(case),
+        _ => "".to_string(),
+    }
+}
+
+// Formats floats into Python style exponent notation, by first formatting in Rust style
+// exponent notation (`1.0000e0`), then convert to Python style (`1.0000e+00`).
+pub fn format_exponent(
+    precision: usize,
+    magnitude: f64,
+    case: Case,
+    alternate_form: bool,
+) -> String {
+    match magnitude {
+        magnitude if magnitude.is_finite() => {
+            let r_exp = format!("{magnitude:.precision$e}");
+            let mut parts = r_exp.splitn(2, 'e');
+            let base = parts.next().unwrap();
+            let exponent = parts.next().unwrap().parse::<i64>().unwrap();
+            let e = match case {
+                Case::Lower => 'e',
+                Case::Upper => 'E',
+            };
+            let point = decimal_point_or_empty(precision, alternate_form);
+            format!("{base}{point}{e}{exponent:+#03}")
+        }
+        magnitude if magnitude.is_nan() => format_nan(case),
+        magnitude if magnitude.is_infinite() => format_inf(case),
+        _ => "".to_string(),
+    }
+}
+
+/// If s represents a floating point value, trailing zeros and a possibly trailing
+/// decimal point will be removed.
+/// This function does NOT work with decimal commas.
+fn maybe_remove_trailing_redundant_chars(s: String, alternate_form: bool) -> String {
+    if !alternate_form && s.contains('.') {
+        // only truncate floating point values when not in alternate form
+        let s = remove_trailing_zeros(s);
+        remove_trailing_decimal_point(s)
+    } else {
+        s
+    }
+}
+
+fn remove_trailing_zeros(s: String) -> String {
+    let mut s = s;
+    while s.ends_with('0') {
+        s.pop();
+    }
+    s
+}
+
+fn remove_trailing_decimal_point(s: String) -> String {
+    let mut s = s;
+    if s.ends_with('.') {
+        s.pop();
+    }
+    s
+}
+
+pub fn format_general(
+    precision: usize,
+    magnitude: f64,
+    case: Case,
+    alternate_form: bool,
+    always_shows_fract: bool,
+) -> String {
+    match magnitude {
+        magnitude if magnitude.is_finite() => {
+            let r_exp = format!("{:.*e}", precision.saturating_sub(1), magnitude);
+            let mut parts = r_exp.splitn(2, 'e');
+            let base = parts.next().unwrap();
+            let exponent = parts.next().unwrap().parse::<i64>().unwrap();
+            if exponent < -4 || exponent + (always_shows_fract as i64) >= (precision as i64) {
+                let e = match case {
+                    Case::Lower => 'e',
+                    Case::Upper => 'E',
+                };
+                let magnitude = format!("{:.*}", precision + 1, base);
+                let base = maybe_remove_trailing_redundant_chars(magnitude, alternate_form);
+                let point = decimal_point_or_empty(precision.saturating_sub(1), alternate_form);
+                format!("{base}{point}{e}{exponent:+#03}")
+            } else {
+                let precision = ((precision as i64) - 1 - exponent) as usize;
+                let magnitude = format!("{magnitude:.precision$}");
+                let base = maybe_remove_trailing_redundant_chars(magnitude, alternate_form);
+                let point = decimal_point_or_empty(precision, alternate_form);
+                format!("{base}{point}")
+            }
+        }
+        magnitude if magnitude.is_nan() => format_nan(case),
+        magnitude if magnitude.is_infinite() => format_inf(case),
+        _ => "".to_string(),
+    }
+}
+
+// TODO: rewrite using format_general
+pub fn to_string(value: f64) -> String {
+    let lit = format!("{value:e}");
+    if let Some(position) = lit.find('e') {
+        let significand = &lit[..position];
+        let exponent = &lit[position + 1..];
+        let exponent = exponent.parse::<i32>().unwrap();
+        if exponent < 16 && exponent > -5 {
+            if is_integer(value) {
+                format!("{value:.1?}")
+            } else {
+                value.to_string()
+            }
+        } else {
+            format!("{significand}e{exponent:+#03}")
+        }
+    } else {
+        let mut s = value.to_string();
+        s.make_ascii_lowercase();
+        s
+    }
+}
+
+pub fn from_hex(s: &str) -> Option<f64> {
+    if let Ok(f) = hexf_parse::parse_hexf64(s, false) {
+        return Some(f);
+    }
+    match s.to_ascii_lowercase().as_str() {
+        "nan" | "+nan" | "-nan" => Some(f64::NAN),
+        "inf" | "infinity" | "+inf" | "+infinity" => Some(f64::INFINITY),
+        "-inf" | "-infinity" => Some(f64::NEG_INFINITY),
+        value => {
+            let mut hex = String::with_capacity(value.len());
+            let has_0x = value.contains("0x");
+            let has_p = value.contains('p');
+            let has_dot = value.contains('.');
+            let mut start = 0;
+
+            if !has_0x && value.starts_with('-') {
+                hex.push_str("-0x");
+                start += 1;
+            } else if !has_0x {
+                hex.push_str("0x");
+                if value.starts_with('+') {
+                    start += 1;
+                }
+            }
+
+            for (index, ch) in value.chars().enumerate() {
+                if ch == 'p' {
+                    if has_dot {
+                        hex.push('p');
+                    } else {
+                        hex.push_str(".p");
+                    }
+                } else if index >= start {
+                    hex.push(ch);
+                }
+            }
+
+            if !has_p && has_dot {
+                hex.push_str("p0");
+            } else if !has_p && !has_dot {
+                hex.push_str(".p0")
+            }
+
+            hexf_parse::parse_hexf64(hex.as_str(), false).ok()
+        }
+    }
+}
+
+pub fn to_hex(value: f64) -> String {
+    let (mantissa, exponent, sign) = value.integer_decode();
+    let sign_fmt = if sign < 0 { "-" } else { "" };
+    match value {
+        value if value.is_zero() => format!("{sign_fmt}0x0.0p+0"),
+        value if value.is_infinite() => format!("{sign_fmt}inf"),
+        value if value.is_nan() => "nan".to_owned(),
+        _ => {
+            const BITS: i16 = 52;
+            const FRACT_MASK: u64 = 0xf_ffff_ffff_ffff;
+            format!(
+                "{}{:#x}.{:013x}p{:+}",
+                sign_fmt,
+                mantissa >> BITS,
+                mantissa & FRACT_MASK,
+                exponent + BITS
+            )
+        }
+    }
+}
+
+#[test]
+fn test_to_hex() {
+    use rand::Rng;
+    for _ in 0..20000 {
+        let bytes = rand::rng().random::<u64>();
+        let f = f64::from_bits(bytes);
+        if !f.is_finite() {
+            continue;
+        }
+        let hex = to_hex(f);
+        // println!("{} -> {}", f, hex);
+        let roundtrip = hexf_parse::parse_hexf64(&hex, false).unwrap();
+        // println!("  -> {}", roundtrip);
+        assert!(f == roundtrip, "{f} {hex} {roundtrip}");
+    }
+}
+
+#[test]
+fn test_remove_trailing_zeros() {
+    assert!(remove_trailing_zeros(String::from("100")) == *"1");
+    assert!(remove_trailing_zeros(String::from("100.00")) == *"100.");
+
+    // leave leading zeros untouched
+    assert!(remove_trailing_zeros(String::from("001")) == *"001");
+
+    // leave strings untouched if they don't end with 0
+    assert!(remove_trailing_zeros(String::from("101")) == *"101");
+}
+
+#[test]
+fn test_remove_trailing_decimal_point() {
+    assert!(remove_trailing_decimal_point(String::from("100.")) == *"100");
+    assert!(remove_trailing_decimal_point(String::from("1.")) == *"1");
+
+    // leave leading decimal points untouched
+    assert!(remove_trailing_decimal_point(String::from(".5")) == *".5");
+}
+
+#[test]
+fn test_maybe_remove_trailing_redundant_chars() {
+    assert!(maybe_remove_trailing_redundant_chars(String::from("100."), true) == *"100.");
+    assert!(maybe_remove_trailing_redundant_chars(String::from("100."), false) == *"100");
+    assert!(maybe_remove_trailing_redundant_chars(String::from("1."), false) == *"1");
+    assert!(maybe_remove_trailing_redundant_chars(String::from("10.0"), false) == *"10");
+
+    // don't truncate integers
+    assert!(maybe_remove_trailing_redundant_chars(String::from("1000"), false) == *"1000");
+}
diff --git a/compiler/literal/src/format.rs b/crates/literal/src/format.rs
similarity index 100%
rename from compiler/literal/src/format.rs
rename to crates/literal/src/format.rs
diff --git a/compiler/literal/src/lib.rs b/crates/literal/src/lib.rs
similarity index 100%
rename from compiler/literal/src/lib.rs
rename to crates/literal/src/lib.rs
diff --git a/pylib/Cargo.toml b/crates/pylib/Cargo.toml
similarity index 100%
rename from pylib/Cargo.toml
rename to crates/pylib/Cargo.toml
diff --git a/crates/pylib/Lib b/crates/pylib/Lib
new file mode 120000
index 0000000000..5665252daf
--- /dev/null
+++ b/crates/pylib/Lib
@@ -0,0 +1 @@
+../../Lib/
\ No newline at end of file
diff --git a/crates/pylib/build.rs b/crates/pylib/build.rs
new file mode 100644
index 0000000000..9b135690f8
--- /dev/null
+++ b/crates/pylib/build.rs
@@ -0,0 +1,42 @@
+const CRATE_ROOT: &str = "../..";
+
+fn main() {
+    process_python_libs(format!("{CRATE_ROOT}/vm/Lib/python_builtins/*").as_str());
+    process_python_libs(format!("{CRATE_ROOT}/vm/Lib/core_modules/*").as_str());
+
+    #[cfg(feature = "freeze-stdlib")]
+    if cfg!(windows) {
+        process_python_libs(format!("{CRATE_ROOT}/Lib/**/*").as_str());
+    } else {
+        process_python_libs("./Lib/**/*");
+    }
+
+    if cfg!(windows)
+        && let Ok(real_path) = std::fs::read_to_string("Lib")
+    {
+        let canonicalized_path = std::fs::canonicalize(real_path)
+            .expect("failed to resolve RUSTPYTHONPATH during build time");
+        // Strip the extended path prefix (\\?\) that canonicalize adds on Windows
+        let path_str = canonicalized_path.to_str().unwrap();
+        let path_str = path_str.strip_prefix(r"\\?\").unwrap_or(path_str);
+        println!("cargo:rustc-env=win_lib_path={path_str}");
+    }
+}
+
+// remove *.pyc files and add *.py to watch list
+fn process_python_libs(pattern: &str) {
+    let glob = glob::glob(pattern).unwrap_or_else(|e| panic!("failed to glob {pattern:?}: {e}"));
+    for entry in glob.flatten() {
+        if entry.is_dir() {
+            continue;
+        }
+        let display = entry.display();
+        if display.to_string().ends_with(".pyc") {
+            if std::fs::remove_file(&entry).is_err() {
+                println!("cargo:warning=failed to remove {display}")
+            }
+            continue;
+        }
+        println!("cargo:rerun-if-changed={display}");
+    }
+}
diff --git a/pylib/src/lib.rs b/crates/pylib/src/lib.rs
similarity index 100%
rename from pylib/src/lib.rs
rename to crates/pylib/src/lib.rs
diff --git a/vm/sre_engine/.gitignore b/crates/sre_engine/.gitignore
similarity index 100%
rename from vm/sre_engine/.gitignore
rename to crates/sre_engine/.gitignore
diff --git a/vm/sre_engine/Cargo.toml b/crates/sre_engine/Cargo.toml
similarity index 100%
rename from vm/sre_engine/Cargo.toml
rename to crates/sre_engine/Cargo.toml
diff --git a/vm/sre_engine/LICENSE b/crates/sre_engine/LICENSE
similarity index 100%
rename from vm/sre_engine/LICENSE
rename to crates/sre_engine/LICENSE
diff --git a/vm/sre_engine/benches/benches.rs b/crates/sre_engine/benches/benches.rs
similarity index 99%
rename from vm/sre_engine/benches/benches.rs
rename to crates/sre_engine/benches/benches.rs
index 127f72e274..9905a8db70 100644
--- a/vm/sre_engine/benches/benches.rs
+++ b/crates/sre_engine/benches/benches.rs
@@ -15,7 +15,7 @@ impl Pattern {
     fn state_range<'a, S: StrDrive>(
         &self,
         string: S,
-        range: std::ops::Range<usize>,
+        range: core::ops::Range<usize>,
     ) -> (Request<'a, S>, State) {
         let req = Request::new(string, range.start, range.end, self.code, false);
         let state = State::default();
diff --git a/vm/sre_engine/generate_tests.py b/crates/sre_engine/generate_tests.py
similarity index 100%
rename from vm/sre_engine/generate_tests.py
rename to crates/sre_engine/generate_tests.py
index 3af4d7e6a5..542852a249 100644
--- a/vm/sre_engine/generate_tests.py
+++ b/crates/sre_engine/generate_tests.py
@@ -1,8 +1,8 @@
+import json
 import os
-from pathlib import Path
 import re
-import json
 from itertools import chain
+from pathlib import Path
 
 m = re.search(r"const SRE_MAGIC: usize = (\d+);", open("src/constants.rs").read())
 sre_engine_magic = int(m.group(1))
diff --git a/vm/sre_engine/src/constants.rs b/crates/sre_engine/src/constants.rs
similarity index 90%
rename from vm/sre_engine/src/constants.rs
rename to crates/sre_engine/src/constants.rs
index 9fe792ce17..d90c08cb37 100644
--- a/vm/sre_engine/src/constants.rs
+++ b/crates/sre_engine/src/constants.rs
@@ -3,17 +3,17 @@
  *
  * regular expression matching engine
  *
- * NOTE: This file is generated by sre_constants.py.  If you need
- * to change anything in here, edit sre_constants.py and run it.
+ * Auto-generated by scripts/generate_sre_constants.py from
+ * Lib/re/_constants.py.
  *
  * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
  *
- * See the _sre.c file for information on usage and redistribution.
+ * See the sre.c file for information on usage and redistribution.
  */
 
 use bitflags::bitflags;
 
-pub const SRE_MAGIC: usize = 20221023;
+pub const SRE_MAGIC: usize = 20230612;
 #[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -62,6 +62,7 @@ pub enum SreOpcode {
     NOT_LITERAL_UNI_IGNORE = 41,
     RANGE_UNI_IGNORE = 42,
 }
+
 #[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -79,6 +80,7 @@ pub enum SreAtCode {
     UNI_BOUNDARY = 10,
     UNI_NON_BOUNDARY = 11,
 }
+
 #[derive(num_enum::TryFromPrimitive, Debug)]
 #[repr(u32)]
 #[allow(non_camel_case_types, clippy::upper_case_acronyms)]
@@ -102,10 +104,10 @@ pub enum SreCatCode {
     UNI_LINEBREAK = 16,
     UNI_NOT_LINEBREAK = 17,
 }
+
 bitflags! {
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
     pub struct SreFlag: u16 {
-        const TEMPLATE = 1;
         const IGNORECASE = 2;
         const LOCALE = 4;
         const MULTILINE = 8;
@@ -116,6 +118,7 @@ bitflags! {
         const ASCII = 256;
     }
 }
+
 bitflags! {
     pub struct SreInfo: u32 {
         const PREFIX = 1;
diff --git a/vm/sre_engine/src/engine.rs b/crates/sre_engine/src/engine.rs
similarity index 98%
rename from vm/sre_engine/src/engine.rs
rename to crates/sre_engine/src/engine.rs
index 92b62e9f63..f1f25a2d92 100644
--- a/vm/sre_engine/src/engine.rs
+++ b/crates/sre_engine/src/engine.rs
@@ -6,8 +6,8 @@ use crate::string::{
 };
 
 use super::{MAXREPEAT, SreAtCode, SreCatCode, SreInfo, SreOpcode, StrDrive, StringCursor};
+use core::{convert::TryFrom, ptr::null};
 use optional::Optioned;
-use std::{convert::TryFrom, ptr::null};
 
 #[derive(Debug, Clone, Copy)]
 pub struct Request<'a, S> {
@@ -27,8 +27,8 @@ impl<'a, S: StrDrive> Request<'a, S> {
         pattern_codes: &'a [u32],
         match_all: bool,
     ) -> Self {
-        let end = std::cmp::min(end, string.count());
-        let start = std::cmp::min(start, end);
+        let end = core::cmp::min(end, string.count());
+        let start = core::cmp::min(start, end);
 
         Self {
             string,
@@ -68,7 +68,7 @@ impl Marks {
         }
     }
 
-    pub fn last_index(&self) -> isize {
+    pub const fn last_index(&self) -> isize {
         self.last_index
     }
 
@@ -1054,11 +1054,11 @@ impl MatchContext {
         &req.pattern_codes[self.code_position..]
     }
 
-    fn remaining_codes<S>(&self, req: &Request<'_, S>) -> usize {
+    const fn remaining_codes<S>(&self, req: &Request<'_, S>) -> usize {
         req.pattern_codes.len() - self.code_position
     }
 
-    fn remaining_chars<S>(&self, req: &Request<'_, S>) -> usize {
+    const fn remaining_chars<S>(&self, req: &Request<'_, S>) -> usize {
         req.end - self.cursor.position
     }
 
@@ -1097,7 +1097,7 @@ impl MatchContext {
         self.peek_code(req, peek).try_into()
     }
 
-    fn skip_code(&mut self, skip: usize) {
+    const fn skip_code(&mut self, skip: usize) {
         self.code_position += skip;
     }
 
@@ -1105,12 +1105,12 @@ impl MatchContext {
         self.skip_code(self.peek_code(req, peek) as usize + 1);
     }
 
-    fn at_beginning(&self) -> bool {
+    const fn at_beginning(&self) -> bool {
         // self.ctx().string_position == self.state().start
         self.cursor.position == 0
     }
 
-    fn at_end<S>(&self, req: &Request<'_, S>) -> bool {
+    const fn at_end<S>(&self, req: &Request<'_, S>) -> bool {
         self.cursor.position == req.end
     }
 
@@ -1144,7 +1144,7 @@ impl MatchContext {
         this == that
     }
 
-    fn can_success<S>(&self, req: &Request<'_, S>) -> bool {
+    const fn can_success<S>(&self, req: &Request<'_, S>) -> bool {
         if !self.toplevel {
             return true;
         }
@@ -1163,12 +1163,12 @@ impl MatchContext {
     }
 
     #[must_use]
-    fn next_offset(&mut self, offset: usize, jump: Jump) -> Self {
+    const fn next_offset(&mut self, offset: usize, jump: Jump) -> Self {
         self.next_at(self.code_position + offset, jump)
     }
 
     #[must_use]
-    fn next_at(&mut self, code_position: usize, jump: Jump) -> Self {
+    const fn next_at(&mut self, code_position: usize, jump: Jump) -> Self {
         self.jump = jump;
         Self {
             code_position,
@@ -1332,7 +1332,7 @@ fn _count<S: StrDrive>(
     ctx: &mut MatchContext,
     max_count: usize,
 ) -> usize {
-    let max_count = std::cmp::min(max_count, ctx.remaining_chars(req));
+    let max_count = core::cmp::min(max_count, ctx.remaining_chars(req));
     let end = ctx.cursor.position + max_count;
     let opcode = SreOpcode::try_from(ctx.peek_code(req, 0)).unwrap();
 
diff --git a/vm/sre_engine/src/lib.rs b/crates/sre_engine/src/lib.rs
similarity index 100%
rename from vm/sre_engine/src/lib.rs
rename to crates/sre_engine/src/lib.rs
diff --git a/crates/sre_engine/src/string.rs b/crates/sre_engine/src/string.rs
new file mode 100644
index 0000000000..489819bfb3
--- /dev/null
+++ b/crates/sre_engine/src/string.rs
@@ -0,0 +1,466 @@
+use rustpython_wtf8::Wtf8;
+
+#[derive(Debug, Clone, Copy)]
+pub struct StringCursor {
+    pub(crate) ptr: *const u8,
+    pub position: usize,
+}
+
+impl Default for StringCursor {
+    fn default() -> Self {
+        Self {
+            ptr: core::ptr::null(),
+            position: 0,
+        }
+    }
+}
+
+pub trait StrDrive: Copy {
+    fn count(&self) -> usize;
+    fn create_cursor(&self, n: usize) -> StringCursor;
+    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize);
+    fn advance(cursor: &mut StringCursor) -> u32;
+    fn peek(cursor: &StringCursor) -> u32;
+    fn skip(cursor: &mut StringCursor, n: usize);
+    fn back_advance(cursor: &mut StringCursor) -> u32;
+    fn back_peek(cursor: &StringCursor) -> u32;
+    fn back_skip(cursor: &mut StringCursor, n: usize);
+}
+
+impl StrDrive for &[u8] {
+    #[inline]
+    fn count(&self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    fn create_cursor(&self, n: usize) -> StringCursor {
+        StringCursor {
+            ptr: self[n..].as_ptr(),
+            position: n,
+        }
+    }
+
+    #[inline]
+    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+        cursor.position = n;
+        cursor.ptr = self[n..].as_ptr();
+    }
+
+    #[inline]
+    fn advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position += 1;
+        unsafe { cursor.ptr = cursor.ptr.add(1) };
+        unsafe { *cursor.ptr as u32 }
+    }
+
+    #[inline]
+    fn peek(cursor: &StringCursor) -> u32 {
+        unsafe { *cursor.ptr as u32 }
+    }
+
+    #[inline]
+    fn skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position += n;
+        unsafe { cursor.ptr = cursor.ptr.add(n) };
+    }
+
+    #[inline]
+    fn back_advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position -= 1;
+        unsafe { cursor.ptr = cursor.ptr.sub(1) };
+        unsafe { *cursor.ptr as u32 }
+    }
+
+    #[inline]
+    fn back_peek(cursor: &StringCursor) -> u32 {
+        unsafe { *cursor.ptr.offset(-1) as u32 }
+    }
+
+    #[inline]
+    fn back_skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position -= n;
+        unsafe { cursor.ptr = cursor.ptr.sub(n) };
+    }
+}
+
+impl StrDrive for &str {
+    #[inline]
+    fn count(&self) -> usize {
+        self.chars().count()
+    }
+
+    #[inline]
+    fn create_cursor(&self, n: usize) -> StringCursor {
+        let mut cursor = StringCursor {
+            ptr: self.as_ptr(),
+            position: 0,
+        };
+        Self::skip(&mut cursor, n);
+        cursor
+    }
+
+    #[inline]
+    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+        if cursor.ptr.is_null() || cursor.position > n {
+            *cursor = Self::create_cursor(self, n);
+        } else if cursor.position < n {
+            Self::skip(cursor, n - cursor.position);
+        }
+    }
+
+    #[inline]
+    fn advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position += 1;
+        unsafe { next_code_point(&mut cursor.ptr) }
+    }
+
+    #[inline]
+    fn peek(cursor: &StringCursor) -> u32 {
+        let mut ptr = cursor.ptr;
+        unsafe { next_code_point(&mut ptr) }
+    }
+
+    #[inline]
+    fn skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position += n;
+        for _ in 0..n {
+            unsafe { next_code_point(&mut cursor.ptr) };
+        }
+    }
+
+    #[inline]
+    fn back_advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position -= 1;
+        unsafe { next_code_point_reverse(&mut cursor.ptr) }
+    }
+
+    #[inline]
+    fn back_peek(cursor: &StringCursor) -> u32 {
+        let mut ptr = cursor.ptr;
+        unsafe { next_code_point_reverse(&mut ptr) }
+    }
+
+    #[inline]
+    fn back_skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position -= n;
+        for _ in 0..n {
+            unsafe { next_code_point_reverse(&mut cursor.ptr) };
+        }
+    }
+}
+
+impl StrDrive for &Wtf8 {
+    #[inline]
+    fn count(&self) -> usize {
+        self.code_points().count()
+    }
+
+    #[inline]
+    fn create_cursor(&self, n: usize) -> StringCursor {
+        let mut cursor = StringCursor {
+            ptr: self.as_bytes().as_ptr(),
+            position: 0,
+        };
+        Self::skip(&mut cursor, n);
+        cursor
+    }
+
+    #[inline]
+    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
+        if cursor.ptr.is_null() || cursor.position > n {
+            *cursor = Self::create_cursor(self, n);
+        } else if cursor.position < n {
+            Self::skip(cursor, n - cursor.position);
+        }
+    }
+
+    #[inline]
+    fn advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position += 1;
+        unsafe { next_code_point(&mut cursor.ptr) }
+    }
+
+    #[inline]
+    fn peek(cursor: &StringCursor) -> u32 {
+        let mut ptr = cursor.ptr;
+        unsafe { next_code_point(&mut ptr) }
+    }
+
+    #[inline]
+    fn skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position += n;
+        for _ in 0..n {
+            unsafe { next_code_point(&mut cursor.ptr) };
+        }
+    }
+
+    #[inline]
+    fn back_advance(cursor: &mut StringCursor) -> u32 {
+        cursor.position -= 1;
+        unsafe { next_code_point_reverse(&mut cursor.ptr) }
+    }
+
+    #[inline]
+    fn back_peek(cursor: &StringCursor) -> u32 {
+        let mut ptr = cursor.ptr;
+        unsafe { next_code_point_reverse(&mut ptr) }
+    }
+
+    #[inline]
+    fn back_skip(cursor: &mut StringCursor, n: usize) {
+        cursor.position -= n;
+        for _ in 0..n {
+            unsafe { next_code_point_reverse(&mut cursor.ptr) };
+        }
+    }
+}
+
+/// Reads the next code point out of a byte iterator (assuming a
+/// UTF-8-like encoding).
+///
+/// # Safety
+///
+/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
+#[inline]
+const unsafe fn next_code_point(ptr: &mut *const u8) -> u32 {
+    // Decode UTF-8
+    let x = unsafe { **ptr };
+    *ptr = unsafe { ptr.offset(1) };
+
+    if x < 128 {
+        return x as u32;
+    }
+
+    // Multibyte case follows
+    // Decode from a byte combination out of: [[[x y] z] w]
+    // NOTE: Performance is sensitive to the exact formulation here
+    let init = utf8_first_byte(x, 2);
+    // SAFETY: `bytes` produces an UTF-8-like string,
+    // so the iterator must produce a value here.
+    let y = unsafe { **ptr };
+    *ptr = unsafe { ptr.offset(1) };
+    let mut ch = utf8_acc_cont_byte(init, y);
+    if x >= 0xE0 {
+        // [[x y z] w] case
+        // 5th bit in 0xE0 .. 0xEF is always clear, so `init` is still valid
+        // SAFETY: `bytes` produces an UTF-8-like string,
+        // so the iterator must produce a value here.
+        let z = unsafe { **ptr };
+        *ptr = unsafe { ptr.offset(1) };
+        let y_z = utf8_acc_cont_byte((y & CONT_MASK) as u32, z);
+        ch = (init << 12) | y_z;
+        if x >= 0xF0 {
+            // [x y z w] case
+            // use only the lower 3 bits of `init`
+            // SAFETY: `bytes` produces an UTF-8-like string,
+            // so the iterator must produce a value here.
+            let w = unsafe { **ptr };
+            *ptr = unsafe { ptr.offset(1) };
+            ch = ((init & 7) << 18) | utf8_acc_cont_byte(y_z, w);
+        }
+    }
+
+    ch
+}
+
+/// Reads the last code point out of a byte iterator (assuming a
+/// UTF-8-like encoding).
+///
+/// # Safety
+///
+/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
+#[inline]
+const unsafe fn next_code_point_reverse(ptr: &mut *const u8) -> u32 {
+    // Decode UTF-8
+    *ptr = unsafe { ptr.offset(-1) };
+    let w = match unsafe { **ptr } {
+        next_byte if next_byte < 128 => return next_byte as u32,
+        back_byte => back_byte,
+    };
+
+    // Multibyte case follows
+    // Decode from a byte combination out of: [x [y [z w]]]
+    let mut ch;
+    // SAFETY: `bytes` produces an UTF-8-like string,
+    // so the iterator must produce a value here.
+    *ptr = unsafe { ptr.offset(-1) };
+    let z = unsafe { **ptr };
+    ch = utf8_first_byte(z, 2);
+    if utf8_is_cont_byte(z) {
+        // SAFETY: `bytes` produces an UTF-8-like string,
+        // so the iterator must produce a value here.
+        *ptr = unsafe { ptr.offset(-1) };
+        let y = unsafe { **ptr };
+        ch = utf8_first_byte(y, 3);
+        if utf8_is_cont_byte(y) {
+            // SAFETY: `bytes` produces an UTF-8-like string,
+            // so the iterator must produce a value here.
+            *ptr = unsafe { ptr.offset(-1) };
+            let x = unsafe { **ptr };
+            ch = utf8_first_byte(x, 4);
+            ch = utf8_acc_cont_byte(ch, y);
+        }
+        ch = utf8_acc_cont_byte(ch, z);
+    }
+    ch = utf8_acc_cont_byte(ch, w);
+
+    ch
+}
+
+/// Returns the initial codepoint accumulator for the first byte.
+/// The first byte is special, only want bottom 5 bits for width 2, 4 bits
+/// for width 3, and 3 bits for width 4.
+#[inline]
+const fn utf8_first_byte(byte: u8, width: u32) -> u32 {
+    (byte & (0x7F >> width)) as u32
+}
+
+/// Returns the value of `ch` updated with continuation byte `byte`.
+#[inline]
+const fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {
+    (ch << 6) | (byte & CONT_MASK) as u32
+}
+
+/// Checks whether the byte is a UTF-8 continuation byte (i.e., starts with the
+/// bits `10`).
+#[inline]
+const fn utf8_is_cont_byte(byte: u8) -> bool {
+    (byte as i8) < -64
+}
+
+/// Mask of the value bits of a continuation byte.
+const CONT_MASK: u8 = 0b0011_1111;
+
+const fn is_py_ascii_whitespace(b: u8) -> bool {
+    matches!(b, b'\t' | b'\n' | b'\x0C' | b'\r' | b' ' | b'\x0B')
+}
+
+#[inline]
+pub(crate) fn is_word(ch: u32) -> bool {
+    ch == '_' as u32
+        || u8::try_from(ch)
+            .map(|x| x.is_ascii_alphanumeric())
+            .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_space(ch: u32) -> bool {
+    u8::try_from(ch)
+        .map(is_py_ascii_whitespace)
+        .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_digit(ch: u32) -> bool {
+    u8::try_from(ch)
+        .map(|x| x.is_ascii_digit())
+        .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_loc_alnum(ch: u32) -> bool {
+    // FIXME: Ignore the locales
+    u8::try_from(ch)
+        .map(|x| x.is_ascii_alphanumeric())
+        .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_loc_word(ch: u32) -> bool {
+    ch == '_' as u32 || is_loc_alnum(ch)
+}
+#[inline]
+pub(crate) const fn is_linebreak(ch: u32) -> bool {
+    ch == '\n' as u32
+}
+#[inline]
+pub fn lower_ascii(ch: u32) -> u32 {
+    u8::try_from(ch)
+        .map(|x| x.to_ascii_lowercase() as u32)
+        .unwrap_or(ch)
+}
+#[inline]
+pub(crate) fn lower_locate(ch: u32) -> u32 {
+    // FIXME: Ignore the locales
+    lower_ascii(ch)
+}
+#[inline]
+pub(crate) fn upper_locate(ch: u32) -> u32 {
+    // FIXME: Ignore the locales
+    u8::try_from(ch)
+        .map(|x| x.to_ascii_uppercase() as u32)
+        .unwrap_or(ch)
+}
+#[inline]
+pub(crate) fn is_uni_digit(ch: u32) -> bool {
+    // TODO: check with cpython
+    char::try_from(ch)
+        .map(|x| x.is_ascii_digit())
+        .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_uni_space(ch: u32) -> bool {
+    // TODO: check with cpython
+    is_space(ch)
+        || matches!(
+            ch,
+            0x0009
+                | 0x000A
+                | 0x000B
+                | 0x000C
+                | 0x000D
+                | 0x001C
+                | 0x001D
+                | 0x001E
+                | 0x001F
+                | 0x0020
+                | 0x0085
+                | 0x00A0
+                | 0x1680
+                | 0x2000
+                | 0x2001
+                | 0x2002
+                | 0x2003
+                | 0x2004
+                | 0x2005
+                | 0x2006
+                | 0x2007
+                | 0x2008
+                | 0x2009
+                | 0x200A
+                | 0x2028
+                | 0x2029
+                | 0x202F
+                | 0x205F
+                | 0x3000
+        )
+}
+#[inline]
+pub(crate) const fn is_uni_linebreak(ch: u32) -> bool {
+    matches!(
+        ch,
+        0x000A | 0x000B | 0x000C | 0x000D | 0x001C | 0x001D | 0x001E | 0x0085 | 0x2028 | 0x2029
+    )
+}
+#[inline]
+pub(crate) fn is_uni_alnum(ch: u32) -> bool {
+    // TODO: check with cpython
+    char::try_from(ch)
+        .map(|x| x.is_alphanumeric())
+        .unwrap_or(false)
+}
+#[inline]
+pub(crate) fn is_uni_word(ch: u32) -> bool {
+    ch == '_' as u32 || is_uni_alnum(ch)
+}
+#[inline]
+pub fn lower_unicode(ch: u32) -> u32 {
+    // TODO: check with cpython
+    char::try_from(ch)
+        .map(|x| x.to_lowercase().next().unwrap() as u32)
+        .unwrap_or(ch)
+}
+#[inline]
+pub fn upper_unicode(ch: u32) -> u32 {
+    // TODO: check with cpython
+    char::try_from(ch)
+        .map(|x| x.to_uppercase().next().unwrap() as u32)
+        .unwrap_or(ch)
+}
diff --git a/vm/sre_engine/tests/tests.rs b/crates/sre_engine/tests/tests.rs
similarity index 100%
rename from vm/sre_engine/tests/tests.rs
rename to crates/sre_engine/tests/tests.rs
diff --git a/crates/stdlib/Cargo.toml b/crates/stdlib/Cargo.toml
new file mode 100644
index 0000000000..e45a0eed15
--- /dev/null
+++ b/crates/stdlib/Cargo.toml
@@ -0,0 +1,166 @@
+[package]
+name = "rustpython-stdlib"
+description = "RustPython standard libraries in Rust."
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+default = ["compiler"]
+compiler = ["rustpython-vm/compiler"]
+threading = ["rustpython-common/threading", "rustpython-vm/threading"]
+sqlite = ["dep:libsqlite3-sys"]
+# SSL backends - default to rustls
+ssl = []
+ssl-rustls = ["ssl", "rustls", "rustls-native-certs", "rustls-pemfile", "rustls-platform-verifier", "x509-cert", "x509-parser", "der", "pem-rfc7468", "webpki-roots", "aws-lc-rs", "oid-registry", "pkcs8"]
+ssl-rustls-fips = ["ssl-rustls", "aws-lc-rs/fips"]
+ssl-openssl = ["ssl", "openssl", "openssl-sys", "foreign-types-shared", "openssl-probe"]
+ssl-vendor = ["ssl-openssl", "openssl/vendored"]
+tkinter = ["dep:tk-sys", "dep:tcl-sys", "dep:widestring"]
+flame-it = ["flame"]
+
+[dependencies]
+# rustpython crates
+rustpython-derive = { workspace = true }
+rustpython-vm = { workspace = true, default-features = false, features = ["compiler"]}
+rustpython-common = { workspace = true }
+
+ahash = { workspace = true }
+ascii = { workspace = true }
+cfg-if = { workspace = true }
+crossbeam-utils = { workspace = true }
+flame = { workspace = true, optional = true }
+hex = { workspace = true }
+itertools = { workspace = true }
+indexmap = { workspace = true }
+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 }
+phf = { version = "0.13", features = ["macros"] }
+
+memchr = { workspace = true }
+base64 = "0.22"
+csv-core = "0.1.11"
+dyn-clone = "1.0.10"
+pymath = { workspace = true }
+xml = "1.2"
+
+# random
+rand_core = { workspace = true }
+mt19937 = "3.1"
+
+# Crypto:
+digest = "0.10.3"
+md-5 = "0.10.1"
+sha-1 = "0.10.0"
+sha2 = "0.10.2"
+sha3 = "0.10.1"
+blake2 = "0.10.4"
+
+## 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 }
+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"] }
+libz-sys = { package = "libz-rs-sys", version = "0.5" }
+bzip2 = "0.6"
+
+# tkinter
+tk-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
+tcl-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
+widestring = { workspace = true, optional = true }
+chrono.workspace = true
+
+# uuid
+[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"] }
+
+[target.'cfg(all(unix, not(target_os = "redox"), not(target_os = "ios")))'.dependencies]
+termios = "0.3.3"
+
+[target.'cfg(unix)'.dependencies]
+rustix = { workspace = true }
+
+# mmap + socket dependencies
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+memmap2 = "0.9.9"
+page_size = "0.6"
+gethostname = "1.0.2"
+socket2 = { version = "0.6.0", features = ["all"] }
+dns-lookup = "3.0"
+
+# OpenSSL dependencies (optional, for ssl-openssl feature)
+openssl = { version = "0.10.72", optional = true }
+openssl-sys = { version = "0.9.110", optional = true }
+openssl-probe = { version = "0.2.0", 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-native-certs = { version = "0.8", optional = true }
+rustls-pemfile = { version = "2.2", optional = true }
+rustls-platform-verifier = { version = "0.6", optional = true }
+x509-cert = { version = "0.2.5", features = ["pem", "builder"], optional = true }
+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 }
+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"
+
+[target.'cfg(windows)'.dependencies]
+paste = { workspace = true }
+schannel = { workspace = true }
+widestring = { workspace = true }
+
+[target.'cfg(windows)'.dependencies.windows-sys]
+workspace = true
+features = [
+  "Win32_Foundation",
+  "Win32_Networking_WinSock",
+  "Win32_NetworkManagement_IpHelper",
+  "Win32_NetworkManagement_Ndis",
+  "Win32_Security_Cryptography",
+  "Win32_Storage_FileSystem",
+  "Win32_System_Diagnostics_Debug",
+  "Win32_System_Environment",
+  "Win32_System_IO",
+  "Win32_System_Threading"
+]
+
+[target.'cfg(target_os = "macos")'.dependencies]
+system-configuration = "0.7.0"
+
+[lints]
+workspace = true
diff --git a/crates/stdlib/build.rs b/crates/stdlib/build.rs
new file mode 100644
index 0000000000..83ebd81ead
--- /dev/null
+++ b/crates/stdlib/build.rs
@@ -0,0 +1,50 @@
+// spell-checker:ignore ossl osslconf
+
+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)]
+    let ossl_vers = [
+        (0x1_00_01_00_0, "ossl101"),
+        (0x1_00_02_00_0, "ossl102"),
+        (0x1_01_00_00_0, "ossl110"),
+        (0x1_01_00_07_0, "ossl110g"),
+        (0x1_01_00_08_0, "ossl110h"),
+        (0x1_01_01_00_0, "ossl111"),
+        (0x1_01_01_04_0, "ossl111d"),
+        (0x3_00_00_00_0, "ossl300"),
+        (0x3_01_00_00_0, "ossl310"),
+        (0x3_02_00_00_0, "ossl320"),
+        (0x3_03_00_00_0, "ossl330"),
+    ];
+
+    for (_, cfg) in ossl_vers {
+        println!("cargo::rustc-check-cfg=cfg({cfg})");
+    }
+
+    #[cfg(feature = "ssl-openssl")]
+    {
+        #[allow(clippy::unusual_byte_groupings)]
+        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
+            let version = u64::from_str_radix(&v, 16).unwrap();
+            for (ver, cfg) in ossl_vers {
+                if version >= ver {
+                    println!("cargo:rustc-cfg={cfg}");
+                }
+            }
+        }
+        if let Ok(v) = std::env::var("DEP_OPENSSL_CONF") {
+            for conf in v.split(',') {
+                println!("cargo:rustc-cfg=osslconf=\"{conf}\"");
+            }
+        }
+        // it's possible for openssl-sys to link against the system openssl under certain conditions,
+        // so let the ssl module know to only perform a probe if we're actually vendored
+        if std::env::var("DEP_OPENSSL_VENDORED").is_ok_and(|s| s == "1") {
+            println!("cargo::rustc-cfg=openssl_vendored")
+        }
+    }
+}
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
new file mode 100644
index 0000000000..463027d9ba
--- /dev/null
+++ b/crates/stdlib/src/array.rs
@@ -0,0 +1,1661 @@
+// spell-checker:ignore typecode tofile tolist fromfile
+
+use rustpython_vm::{PyRef, VirtualMachine, builtins::PyModule};
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = array::make_module(vm);
+
+    let array = module
+        .get_attr("array", vm)
+        .expect("Expect array has array type.");
+
+    let collections_abc = vm
+        .import("collections.abc", 0)
+        .expect("Expect collections exist.");
+    let abc = collections_abc
+        .get_attr("abc", vm)
+        .expect("Expect collections has abc submodule.");
+    let mutable_sequence = abc
+        .get_attr("MutableSequence", vm)
+        .expect("Expect collections.abc has MutableSequence type.");
+
+    let register = &mutable_sequence
+        .get_attr("register", vm)
+        .expect("Expect collections.abc.MutableSequence has register method.");
+    register
+        .call((array,), vm)
+        .expect("Expect collections.abc.MutableSequence.register(array.array) not fail.");
+
+    module
+}
+
+#[pymodule(name = "array")]
+mod array {
+    use crate::{
+        common::{
+            atomic::{self, AtomicUsize},
+            lock::{
+                PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyMutex, PyRwLock,
+                PyRwLockReadGuard, PyRwLockWriteGuard,
+            },
+            str::wchar_t,
+        },
+        vm::{
+            AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+            atomic_func,
+            builtins::{
+                PositionIterInternal, PyByteArray, PyBytes, PyBytesRef, PyDictRef, PyFloat,
+                PyGenericAlias, PyInt, PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyType,
+                PyTypeRef,
+            },
+            class_or_notimplemented,
+            convert::{ToPyObject, ToPyResult, TryFromBorrowedObject, TryFromObject},
+            function::{
+                ArgBytesLike, ArgIntoFloat, ArgIterable, KwArgs, OptionalArg, PyComparisonValue,
+            },
+            protocol::{
+                BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, PyIterReturn,
+                PyMappingMethods, PySequenceMethods,
+            },
+            sequence::{OptionalRangeArgs, SequenceExt, SequenceMutExt},
+            sliceable::{
+                SaturatedSlice, SequenceIndex, SequenceIndexOp, SliceableSequenceMutOp,
+                SliceableSequenceOp,
+            },
+            types::{
+                AsBuffer, AsMapping, AsSequence, Comparable, Constructor, IterNext, Iterable,
+                PyComparisonOp, Representable, SelfIter,
+            },
+        },
+    };
+    use alloc::fmt;
+    use core::cmp::Ordering;
+    use itertools::Itertools;
+    use num_traits::ToPrimitive;
+    use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
+    use std::os::raw;
+    macro_rules! def_array_enum {
+        ($(($n:ident, $t:ty, $c:literal, $scode:literal)),*$(,)?) => {
+            #[derive(Debug, Clone)]
+            pub enum ArrayContentType {
+                $($n(Vec<$t>),)*
+            }
+
+            impl ArrayContentType {
+                fn from_char(c: char) -> Result<Self, String> {
+                    match c {
+                        $($c => Ok(ArrayContentType::$n(Vec::new())),)*
+                        _ => Err(
+                            "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)".into()
+                        ),
+                    }
+                }
+
+                const fn typecode(&self) -> char {
+                    match self {
+                        $(ArrayContentType::$n(_) => $c,)*
+                    }
+                }
+
+                const fn typecode_str(&self) -> &'static str {
+                    match self {
+                        $(ArrayContentType::$n(_) => $scode,)*
+                    }
+                }
+
+                const fn itemsize_of_typecode(c: char) -> Option<usize> {
+                    match c {
+                        $($c => Some(core::mem::size_of::<$t>()),)*
+                        _ => None,
+                    }
+                }
+
+                const fn itemsize(&self) -> usize {
+                    match self {
+                        $(ArrayContentType::$n(_) => core::mem::size_of::<$t>(),)*
+                    }
+                }
+
+                fn addr(&self) -> usize {
+                    match self {
+                        $(ArrayContentType::$n(v) => v.as_ptr() as usize,)*
+                    }
+                }
+
+                fn len(&self) -> usize {
+                    match self {
+                        $(ArrayContentType::$n(v) => v.len(),)*
+                    }
+                }
+
+                fn reserve(&mut self, len: usize) {
+                    match self {
+                        $(ArrayContentType::$n(v) => v.reserve(len),)*
+                    }
+                }
+
+                fn push(&mut self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            let val = <$t>::try_into_from_object(vm, obj)?;
+                            v.push(val);
+                        })*
+                    }
+                    Ok(())
+                }
+
+                fn pop(&mut self, i: isize, vm: &VirtualMachine) -> PyResult {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                        let i = v.wrap_index(i).ok_or_else(|| {
+                            vm.new_index_error("pop index out of range".to_owned())
+                        })?;
+                            v.remove(i).to_pyresult(vm)
+                        })*
+                    }
+                }
+
+                fn insert(
+                    &mut self,
+                    i: isize,
+                    obj: PyObjectRef,
+                    vm: &VirtualMachine
+                ) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            let val = <$t>::try_into_from_object(vm, obj)?;
+                            v.insert(i.saturated_at(v.len()), val);
+                        })*
+                    }
+                    Ok(())
+                }
+
+                fn count(&self, obj: PyObjectRef, vm: &VirtualMachine) -> usize {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
+                                v.iter().filter(|&&a| a == val).count()
+                            } else {
+                                0
+                            }
+                        })*
+                    }
+                }
+
+                fn remove(&mut self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>{
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
+                                if let Some(pos) = v.iter().position(|&a| a == val) {
+                                    v.remove(pos);
+                                    return Ok(());
+                                }
+                            }
+                            Err(vm.new_value_error("array.remove(x): x not in array".to_owned()))
+                        })*
+                    }
+                }
+
+                fn frombytes_move(&mut self, b: Vec<u8>) {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            if v.is_empty() {
+                                // safe because every configuration of bytes for the types we
+                                // support are valid
+                                let b = core::mem::ManuallyDrop::new(b);
+                                let ptr = b.as_ptr() as *mut $t;
+                                let len = b.len() / core::mem::size_of::<$t>();
+                                let capacity = b.capacity() / core::mem::size_of::<$t>();
+                                *v = unsafe { Vec::from_raw_parts(ptr, len, capacity) };
+                            } else {
+                                self.frombytes(&b);
+                            }
+                        })*
+                    }
+                }
+
+                fn frombytes(&mut self, b: &[u8]) {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // safe because every configuration of bytes for the types we
+                            // support are valid
+                            if b.len() > 0 {
+                                let ptr = b.as_ptr() as *const $t;
+                                let ptr_len = b.len() / core::mem::size_of::<$t>();
+                                let slice = unsafe { core::slice::from_raw_parts(ptr, ptr_len) };
+                                v.extend_from_slice(slice);
+                            }
+                        })*
+                    }
+                }
+
+                fn fromlist(&mut self, list: &PyList, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // convert list before modify self
+                            let mut list: Vec<$t> = list
+                                .borrow_vec()
+                                .iter()
+                                .cloned()
+                                .map(|value| <$t>::try_into_from_object(vm, value))
+                                .try_collect()?;
+                            v.append(&mut list);
+                            Ok(())
+                        })*
+                    }
+                }
+
+                fn get_bytes(&self) -> &[u8] {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // safe because we're just reading memory as bytes
+                            let ptr = v.as_ptr() as *const u8;
+                            let ptr_len = v.len() * core::mem::size_of::<$t>();
+                            unsafe { core::slice::from_raw_parts(ptr, ptr_len) }
+                        })*
+                    }
+                }
+
+                fn get_bytes_mut(&mut self) -> &mut [u8] {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // safe because we're just reading memory as bytes
+                            let ptr = v.as_ptr() as *mut u8;
+                            let ptr_len = v.len() * core::mem::size_of::<$t>();
+                            unsafe { core::slice::from_raw_parts_mut(ptr, ptr_len) }
+                        })*
+                    }
+                }
+
+                fn index(
+                    &self,
+                    obj: PyObjectRef,
+                    start: usize,
+                    stop: usize,
+                    vm: &VirtualMachine
+                ) -> PyResult<usize> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
+                                if let Some(pos) = v.iter().take(stop as _).skip(start as _).position(|&elem| elem == val) {
+                                    return Ok(pos + start);
+                                }
+                            }
+                            Err(vm.new_value_error("array.index(x): x not in array".to_owned()))
+                        })*
+                    }
+                }
+
+                fn reverse(&mut self) {
+                    match self {
+                        $(ArrayContentType::$n(v) => v.reverse(),)*
+                    }
+                }
+
+                fn get(
+                    &self,
+                    i: usize,
+                    vm: &VirtualMachine
+                ) -> Option<PyResult> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.get(i).map(|x| x.to_pyresult(vm))
+                        })*
+                    }
+                }
+
+                fn getitem_by_index(&self, i: isize, vm: &VirtualMachine) -> PyResult {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.getitem_by_index(vm, i).map(|x| x.to_pyresult(vm))?
+                        })*
+                    }
+                }
+
+                fn getitem_by_slice(&self, slice: SaturatedSlice, vm: &VirtualMachine) -> PyResult {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            let r = v.getitem_by_slice(vm, slice)?;
+                            let array = PyArray::from(ArrayContentType::$n(r));
+                            array.to_pyresult(vm)
+                        })*
+                    }
+                }
+
+                fn setitem_by_index(
+                    &mut self,
+                    i: isize,
+                    value: PyObjectRef,
+                    vm: &VirtualMachine
+                ) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            let value = <$t>::try_into_from_object(vm, value)?;
+                            v.setitem_by_index(vm, i, value)
+                        })*
+                    }
+                }
+
+                fn setitem_by_slice(
+                    &mut self,
+                    slice: SaturatedSlice,
+                    items: &ArrayContentType,
+                    vm: &VirtualMachine
+                ) -> PyResult<()> {
+                    match self {
+                        $(Self::$n(elements) => if let ArrayContentType::$n(items) = items {
+                            elements.setitem_by_slice(vm, slice, items)
+                        } else {
+                            Err(vm.new_type_error(
+                                "bad argument type for built-in operation".to_owned()
+                            ))
+                        },)*
+                    }
+                }
+
+                fn setitem_by_slice_no_resize(
+                    &mut self,
+                    slice: SaturatedSlice,
+                    items: &ArrayContentType,
+                    vm: &VirtualMachine
+                ) -> PyResult<()> {
+                    match self {
+                        $(Self::$n(elements) => if let ArrayContentType::$n(items) = items {
+                            elements.setitem_by_slice_no_resize(vm, slice, items)
+                        } else {
+                            Err(vm.new_type_error(
+                                "bad argument type for built-in operation".to_owned()
+                            ))
+                        },)*
+                    }
+                }
+
+                fn delitem_by_index(&mut self, i: isize, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.delitem_by_index(vm, i)
+                        })*
+                    }
+                }
+
+                fn delitem_by_slice(&mut self, slice: SaturatedSlice, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.delitem_by_slice(vm, slice)
+                        })*
+                    }
+                }
+
+                fn add(&self, other: &ArrayContentType, vm: &VirtualMachine) -> PyResult<Self> {
+                    match self {
+                        $(ArrayContentType::$n(v) => if let ArrayContentType::$n(other) = other {
+                            let elements = v.iter().chain(other.iter()).cloned().collect();
+                            Ok(ArrayContentType::$n(elements))
+                        } else {
+                            Err(vm.new_type_error(
+                                "bad argument type for built-in operation".to_owned()
+                            ))
+                        },)*
+                    }
+                }
+
+                fn iadd(&mut self, other: &ArrayContentType, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => if let ArrayContentType::$n(other) = other {
+                            v.extend(other);
+                            Ok(())
+                        } else {
+                            Err(vm.new_type_error(
+                                "can only extend with array of same kind".to_owned()
+                            ))
+                        },)*
+                    }
+                }
+
+                fn mul(&self, value: isize, vm: &VirtualMachine) -> PyResult<Self> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // MemoryError instead Overflow Error, hard to says it is right
+                            // but it is how cpython doing right now
+                            let elements = v.mul(vm, value).map_err(|_| vm.new_memory_error("".to_owned()))?;
+                            Ok(ArrayContentType::$n(elements))
+                        })*
+                    }
+                }
+
+                fn imul(&mut self, value: isize, vm: &VirtualMachine) -> PyResult<()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            // MemoryError instead Overflow Error, hard to says it is right
+                            // but it is how cpython doing right now
+                            v.imul(vm, value).map_err(|_| vm.new_memory_error("".to_owned()))
+                        })*
+                    }
+                }
+
+                fn byteswap(&mut self) {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            for element in v.iter_mut() {
+                                let x = element.byteswap();
+                                *element = x;
+                            }
+                        })*
+                    }
+                }
+
+                fn repr(&self, class_name: &str, _vm: &VirtualMachine) -> PyResult<String> {
+                    // we don't need ReprGuard here
+                    let s = match self {
+                        $(ArrayContentType::$n(v) => {
+                            if v.is_empty() {
+                                format!("{}('{}')", class_name, $c)
+                            } else {
+                                format!("{}('{}', [{}])", class_name, $c, v.iter().format(", "))
+                            }
+                        })*
+                    };
+                    Ok(s)
+                }
+
+                fn iter<'a, 'vm: 'a>(
+                    &'a self,
+                    vm: &'vm VirtualMachine
+                ) -> impl Iterator<Item = PyResult> + 'a {
+                    (0..self.len()).map(move |i| self.get(i, vm).unwrap())
+                }
+
+                fn cmp(&self, other: &ArrayContentType) -> Result<Option<Ordering>, ()> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            if let ArrayContentType::$n(other) = other {
+                                Ok(PartialOrd::partial_cmp(v, other))
+                            } else {
+                                Err(())
+                            }
+                        })*
+                    }
+                }
+
+                fn get_objects(&self, vm: &VirtualMachine) -> Vec<PyObjectRef> {
+                    match self {
+                        $(ArrayContentType::$n(v) => {
+                            v.iter().map(|&x| x.to_object(vm)).collect()
+                        })*
+                    }
+                }
+            }
+        };
+    }
+
+    def_array_enum!(
+        (SignedByte, i8, 'b', "b"),
+        (UnsignedByte, u8, 'B', "B"),
+        (PyUnicode, WideChar, 'u', "u"),
+        (SignedShort, raw::c_short, 'h', "h"),
+        (UnsignedShort, raw::c_ushort, 'H', "H"),
+        (SignedInt, raw::c_int, 'i', "i"),
+        (UnsignedInt, raw::c_uint, 'I', "I"),
+        (SignedLong, raw::c_long, 'l', "l"),
+        (UnsignedLong, raw::c_ulong, 'L', "L"),
+        (SignedLongLong, raw::c_longlong, 'q', "q"),
+        (UnsignedLongLong, raw::c_ulonglong, 'Q', "Q"),
+        (Float, f32, 'f', "f"),
+        (Double, f64, 'd', "d"),
+    );
+
+    #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+    pub struct WideChar(wchar_t);
+
+    trait ArrayElement: Sized {
+        fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self>;
+        fn byteswap(self) -> Self;
+        fn to_object(self, vm: &VirtualMachine) -> PyObjectRef;
+    }
+
+    macro_rules! impl_int_element {
+        ($($t:ty,)*) => {$(
+            impl ArrayElement for $t {
+                fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+                    obj.try_index(vm)?.try_to_primitive(vm)
+                }
+                fn byteswap(self) -> Self {
+                    <$t>::swap_bytes(self)
+                }
+                fn to_object(self, vm: &VirtualMachine) -> PyObjectRef {
+                    self.to_pyobject(vm)
+                }
+            }
+        )*};
+    }
+
+    macro_rules! impl_float_element {
+        ($(($t:ty, $f_from:path, $f_swap:path, $f_to:path),)*) => {$(
+            impl ArrayElement for $t {
+                fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+                    $f_from(vm, obj)
+                }
+                fn byteswap(self) -> Self {
+                    $f_swap(self)
+                }
+                fn to_object(self, vm: &VirtualMachine) -> PyObjectRef {
+                    $f_to(self).into_pyobject(vm)
+                }
+            }
+        )*};
+    }
+
+    impl_int_element!(i8, u8, i16, u16, i32, u32, i64, u64,);
+    impl_float_element!(
+        (
+            f32,
+            f32_try_into_from_object,
+            f32_swap_bytes,
+            pyfloat_from_f32
+        ),
+        (f64, f64_try_into_from_object, f64_swap_bytes, PyFloat::from),
+    );
+
+    const fn f32_swap_bytes(x: f32) -> f32 {
+        f32::from_bits(x.to_bits().swap_bytes())
+    }
+
+    const fn f64_swap_bytes(x: f64) -> f64 {
+        f64::from_bits(x.to_bits().swap_bytes())
+    }
+
+    fn f32_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f32> {
+        ArgIntoFloat::try_from_object(vm, obj).map(|x| x.into_float() as f32)
+    }
+
+    fn f64_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f64> {
+        ArgIntoFloat::try_from_object(vm, obj).map(|x| x.into_float())
+    }
+
+    fn pyfloat_from_f32(value: f32) -> PyFloat {
+        PyFloat::from(value as f64)
+    }
+
+    impl ArrayElement for WideChar {
+        fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+            PyStrRef::try_from_object(vm, obj)?
+                .as_str()
+                .chars()
+                .exactly_one()
+                .map(|ch| Self(ch as _))
+                .map_err(|_| vm.new_type_error("array item must be unicode character"))
+        }
+        fn byteswap(self) -> Self {
+            Self(self.0.swap_bytes())
+        }
+        fn to_object(self, _vm: &VirtualMachine) -> PyObjectRef {
+            unreachable!()
+        }
+    }
+
+    fn u32_to_char(ch: u32) -> Result<CodePoint, String> {
+        CodePoint::from_u32(ch)
+            .ok_or_else(|| format!("character U+{ch:4x} is not in range [U+0000; U+10ffff]"))
+    }
+
+    impl TryFrom<WideChar> for CodePoint {
+        type Error = String;
+
+        fn try_from(ch: WideChar) -> Result<Self, Self::Error> {
+            // safe because every configuration of bytes for the types we support are valid
+            u32_to_char(ch.0 as _)
+        }
+    }
+
+    impl ToPyResult for WideChar {
+        fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
+            Ok(CodePoint::try_from(self)
+                .map_err(|e| vm.new_unicode_encode_error(e))?
+                .to_pyobject(vm))
+        }
+    }
+
+    impl fmt::Display for WideChar {
+        fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            unreachable!("`repr(array('u'))` calls `PyStr::repr`")
+        }
+    }
+
+    #[pyattr]
+    #[pyattr(name = "ArrayType")]
+    #[pyclass(name = "array")]
+    #[derive(Debug, PyPayload)]
+    pub struct PyArray {
+        array: PyRwLock<ArrayContentType>,
+        exports: AtomicUsize,
+    }
+
+    pub type PyArrayRef = PyRef<PyArray>;
+
+    impl From<ArrayContentType> for PyArray {
+        fn from(array: ArrayContentType) -> Self {
+            Self {
+                array: PyRwLock::new(array),
+                exports: AtomicUsize::new(0),
+            }
+        }
+    }
+
+    #[derive(FromArgs)]
+    pub struct ArrayNewArgs {
+        #[pyarg(positional)]
+        spec: PyStrRef,
+        #[pyarg(positional, optional)]
+        init: OptionalArg<PyObjectRef>,
+    }
+
+    impl Constructor for PyArray {
+        type Args = (ArrayNewArgs, KwArgs);
+
+        fn py_new(
+            cls: &Py<PyType>,
+            (ArrayNewArgs { spec, init }, kwargs): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            let spec = spec.as_str().chars().exactly_one().map_err(|_| {
+                vm.new_type_error("array() argument 1 must be a unicode character, not str")
+            })?;
+
+            if cls.is(Self::class(&vm.ctx)) && !kwargs.is_empty() {
+                return Err(vm.new_type_error("array.array() takes no keyword arguments"));
+            }
+
+            let mut array =
+                ArrayContentType::from_char(spec).map_err(|err| vm.new_value_error(err))?;
+
+            if let OptionalArg::Present(init) = init {
+                if let Some(init) = init.downcast_ref::<Self>() {
+                    match (spec, init.read().typecode()) {
+                        (spec, ch) if spec == ch => array.frombytes(&init.get_bytes()),
+                        (spec, 'u') => {
+                            return Err(vm.new_type_error(format!(
+                            "cannot use a unicode array to initialize an array with typecode '{spec}'"
+                        )))
+                        }
+                        _ => {
+                            for obj in init.read().iter(vm) {
+                                array.push(obj?, vm)?;
+                            }
+                        }
+                    }
+                } else if let Some(wtf8) = init.downcast_ref::<PyStr>() {
+                    if spec == 'u' {
+                        let bytes = Self::_unicode_to_wchar_bytes(wtf8.as_wtf8(), array.itemsize());
+                        array.frombytes_move(bytes);
+                    } else {
+                        return Err(vm.new_type_error(format!(
+                            "cannot use a str to initialize an array with typecode '{spec}'"
+                        )));
+                    }
+                } else if init.downcastable::<PyBytes>() || init.downcastable::<PyByteArray>() {
+                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
+                } else if let Ok(iter) = ArgIterable::try_from_object(vm, init.clone()) {
+                    for obj in iter.iter(vm)? {
+                        array.push(obj?, vm)?;
+                    }
+                } else {
+                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
+                }
+            }
+
+            Ok(Self::from(array))
+        }
+    }
+
+    #[pyclass(
+        flags(BASETYPE),
+        with(
+            Comparable,
+            AsBuffer,
+            AsMapping,
+            AsSequence,
+            Iterable,
+            Constructor,
+            Representable
+        )
+    )]
+    impl PyArray {
+        fn read(&self) -> PyRwLockReadGuard<'_, ArrayContentType> {
+            self.array.read()
+        }
+
+        fn write(&self) -> PyRwLockWriteGuard<'_, ArrayContentType> {
+            self.array.write()
+        }
+
+        #[pygetset]
+        fn typecode(&self, vm: &VirtualMachine) -> PyStrRef {
+            vm.ctx
+                .intern_str(self.read().typecode().to_string())
+                .to_owned()
+        }
+
+        #[pygetset]
+        fn itemsize(&self) -> usize {
+            self.read().itemsize()
+        }
+
+        #[pymethod]
+        fn append(zelf: &Py<Self>, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.try_resizable(vm)?.push(x, vm)
+        }
+
+        #[pymethod]
+        fn buffer_info(&self) -> (usize, usize) {
+            let array = self.read();
+            (array.addr(), array.len())
+        }
+
+        #[pymethod]
+        fn count(&self, x: PyObjectRef, vm: &VirtualMachine) -> usize {
+            self.read().count(x, vm)
+        }
+
+        #[pymethod]
+        fn remove(zelf: &Py<Self>, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.try_resizable(vm)?.remove(x, vm)
+        }
+
+        #[pymethod]
+        fn extend(zelf: &Py<Self>, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mut w = zelf.try_resizable(vm)?;
+            if zelf.is(&obj) {
+                w.imul(2, vm)
+            } else if let Some(array) = obj.downcast_ref::<Self>() {
+                w.iadd(&array.read(), vm)
+            } else {
+                let iter = ArgIterable::try_from_object(vm, obj)?;
+                // zelf.extend_from_iterable(iter, vm)
+                for obj in iter.iter(vm)? {
+                    w.push(obj?, vm)?;
+                }
+                Ok(())
+            }
+        }
+
+        fn _wchar_bytes_to_string(
+            bytes: &[u8],
+            item_size: usize,
+            vm: &VirtualMachine,
+        ) -> PyResult<Wtf8Buf> {
+            if item_size == 2 {
+                // safe because every configuration of bytes for the types we support are valid
+                let utf16 = unsafe {
+                    core::slice::from_raw_parts(
+                        bytes.as_ptr() as *const u16,
+                        bytes.len() / core::mem::size_of::<u16>(),
+                    )
+                };
+                Ok(Wtf8Buf::from_wide(utf16))
+            } else {
+                // safe because every configuration of bytes for the types we support are valid
+                let chars = unsafe {
+                    core::slice::from_raw_parts(
+                        bytes.as_ptr() as *const u32,
+                        bytes.len() / core::mem::size_of::<u32>(),
+                    )
+                };
+                chars
+                    .iter()
+                    .map(|&ch| {
+                        // cpython issue 17223
+                        u32_to_char(ch).map_err(|msg| vm.new_value_error(msg))
+                    })
+                    .try_collect()
+            }
+        }
+
+        fn _unicode_to_wchar_bytes(wtf8: &Wtf8, item_size: usize) -> Vec<u8> {
+            if item_size == 2 {
+                wtf8.encode_wide().flat_map(|ch| ch.to_ne_bytes()).collect()
+            } else {
+                wtf8.code_points()
+                    .flat_map(|ch| ch.to_u32().to_ne_bytes())
+                    .collect()
+            }
+        }
+
+        #[pymethod]
+        fn fromunicode(zelf: &Py<Self>, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let wtf8: &Wtf8 = obj.try_to_value(vm).map_err(|_| {
+                vm.new_type_error(format!(
+                    "fromunicode() argument must be str, not {}",
+                    obj.class().name()
+                ))
+            })?;
+            if zelf.read().typecode() != 'u' {
+                return Err(
+                    vm.new_value_error("fromunicode() may only be called on unicode type arrays")
+                );
+            }
+            let mut w = zelf.try_resizable(vm)?;
+            let bytes = Self::_unicode_to_wchar_bytes(wtf8, w.itemsize());
+            w.frombytes_move(bytes);
+            Ok(())
+        }
+
+        #[pymethod]
+        fn tounicode(&self, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+            let array = self.array.read();
+            if array.typecode() != 'u' {
+                return Err(
+                    vm.new_value_error("tounicode() may only be called on unicode type arrays")
+                );
+            }
+            let bytes = array.get_bytes();
+            Self::_wchar_bytes_to_string(bytes, self.itemsize(), vm)
+        }
+
+        fn _from_bytes(&self, b: &[u8], itemsize: usize, vm: &VirtualMachine) -> PyResult<()> {
+            if !b.len().is_multiple_of(itemsize) {
+                return Err(vm.new_value_error("bytes length not a multiple of item size"));
+            }
+            if b.len() / itemsize > 0 {
+                self.try_resizable(vm)?.frombytes(b);
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn frombytes(&self, b: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
+            let b = b.borrow_buf();
+            let itemsize = self.read().itemsize();
+            self._from_bytes(&b, itemsize, vm)
+        }
+
+        #[pymethod]
+        fn fromfile(&self, f: PyObjectRef, n: isize, vm: &VirtualMachine) -> PyResult<()> {
+            let itemsize = self.itemsize();
+            if n < 0 {
+                return Err(vm.new_value_error("negative count"));
+            }
+            let n = vm.check_repeat_or_overflow_error(itemsize, n)?;
+            let n_bytes = n * itemsize;
+
+            let b = vm.call_method(&f, "read", (n_bytes,))?;
+            let b = b
+                .downcast::<PyBytes>()
+                .map_err(|_| vm.new_type_error("read() didn't return bytes"))?;
+
+            let not_enough_bytes = b.len() != n_bytes;
+
+            self._from_bytes(b.as_bytes(), itemsize, vm)?;
+
+            if not_enough_bytes {
+                Err(vm.new_exception_msg(
+                    vm.ctx.exceptions.eof_error.to_owned(),
+                    "read() didn't return enough bytes".to_owned(),
+                ))
+            } else {
+                Ok(())
+            }
+        }
+
+        #[pymethod]
+        fn byteswap(&self) {
+            self.write().byteswap();
+        }
+
+        #[pymethod]
+        fn index(
+            &self,
+            x: PyObjectRef,
+            range: OptionalRangeArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<usize> {
+            let (start, stop) = range.saturate(self.__len__(), vm)?;
+            self.read().index(x, start, stop, vm)
+        }
+
+        #[pymethod]
+        fn insert(zelf: &Py<Self>, i: isize, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mut w = zelf.try_resizable(vm)?;
+            w.insert(i, x, vm)
+        }
+
+        #[pymethod]
+        fn pop(zelf: &Py<Self>, i: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult {
+            let mut w = zelf.try_resizable(vm)?;
+            if w.len() == 0 {
+                Err(vm.new_index_error("pop from empty array"))
+            } else {
+                w.pop(i.unwrap_or(-1), vm)
+            }
+        }
+
+        #[pymethod]
+        pub(crate) fn tobytes(&self) -> Vec<u8> {
+            self.read().get_bytes().to_vec()
+        }
+
+        #[pymethod]
+        fn tofile(&self, f: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            /* Write 64K blocks at a time */
+            /* XXX Make the block size settable */
+            const BLOCKSIZE: usize = 64 * 1024;
+
+            let bytes = {
+                let bytes = self.read();
+                bytes.get_bytes().to_vec()
+            };
+
+            for b in bytes.chunks(BLOCKSIZE) {
+                let b = PyBytes::from(b.to_vec()).into_ref(&vm.ctx);
+                vm.call_method(&f, "write", (b,))?;
+            }
+            Ok(())
+        }
+
+        pub(crate) fn get_bytes(&self) -> PyMappedRwLockReadGuard<'_, [u8]> {
+            PyRwLockReadGuard::map(self.read(), |a| a.get_bytes())
+        }
+
+        pub(crate) fn get_bytes_mut(&self) -> PyMappedRwLockWriteGuard<'_, [u8]> {
+            PyRwLockWriteGuard::map(self.write(), |a| a.get_bytes_mut())
+        }
+
+        #[pymethod]
+        fn tolist(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+            let array = self.read();
+            let mut v = Vec::with_capacity(array.len());
+            for obj in array.iter(vm) {
+                v.push(obj?);
+            }
+            Ok(v)
+        }
+
+        #[pymethod]
+        fn fromlist(zelf: &Py<Self>, list: PyListRef, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.try_resizable(vm)?.fromlist(&list, vm)
+        }
+
+        #[pymethod]
+        fn reverse(&self) {
+            self.write().reverse()
+        }
+
+        #[pymethod]
+        fn __copy__(&self) -> Self {
+            self.array.read().clone().into()
+        }
+
+        #[pymethod]
+        fn __deepcopy__(&self, _memo: PyObjectRef) -> Self {
+            self.__copy__()
+        }
+
+        fn getitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
+                SequenceIndex::Int(i) => self.read().getitem_by_index(i, vm),
+                SequenceIndex::Slice(slice) => self.read().getitem_by_slice(slice, vm),
+            }
+        }
+
+        fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            self.getitem_inner(&needle, vm)
+        }
+
+        fn setitem_inner(
+            zelf: &Py<Self>,
+            needle: &PyObject,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
+                SequenceIndex::Int(i) => zelf.write().setitem_by_index(i, value, vm),
+                SequenceIndex::Slice(slice) => {
+                    let cloned;
+                    let guard;
+                    let items = if zelf.is(&value) {
+                        cloned = zelf.read().clone();
+                        &cloned
+                    } else {
+                        match value.downcast_ref::<Self>() {
+                            Some(array) => {
+                                guard = array.read();
+                                &*guard
+                            }
+                            None => {
+                                return Err(vm.new_type_error(format!(
+                                    "can only assign array (not \"{}\") to array slice",
+                                    value.class()
+                                )));
+                            }
+                        }
+                    };
+                    if let Ok(mut w) = zelf.try_resizable(vm) {
+                        w.setitem_by_slice(slice, items, vm)
+                    } else {
+                        zelf.write().setitem_by_slice_no_resize(slice, items, vm)
+                    }
+                }
+            }
+        }
+
+        fn __setitem__(
+            zelf: &Py<Self>,
+            needle: PyObjectRef,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            Self::setitem_inner(zelf, &needle, value, vm)
+        }
+
+        fn delitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
+                SequenceIndex::Int(i) => self.try_resizable(vm)?.delitem_by_index(i, vm),
+                SequenceIndex::Slice(slice) => self.try_resizable(vm)?.delitem_by_slice(slice, vm),
+            }
+        }
+
+        fn __delitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            self.delitem_inner(&needle, vm)
+        }
+
+        fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            if let Some(other) = other.downcast_ref::<Self>() {
+                self.read()
+                    .add(&other.read(), vm)
+                    .map(|array| Self::from(array).into_ref(&vm.ctx))
+            } else {
+                Err(vm.new_type_error(format!(
+                    "can only append array (not \"{}\") to array",
+                    other.class().name()
+                )))
+            }
+        }
+
+        fn __iadd__(
+            zelf: PyRef<Self>,
+            other: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyRef<Self>> {
+            if zelf.is(&other) {
+                zelf.try_resizable(vm)?.imul(2, vm)?;
+            } else if let Some(other) = other.downcast_ref::<Self>() {
+                zelf.try_resizable(vm)?.iadd(&other.read(), vm)?;
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "can only extend array with array (not \"{}\")",
+                    other.class().name()
+                )));
+            }
+            Ok(zelf)
+        }
+
+        fn __mul__(&self, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            self.read()
+                .mul(value, vm)
+                .map(|x| Self::from(x).into_ref(&vm.ctx))
+        }
+
+        fn __imul__(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            zelf.try_resizable(vm)?.imul(value, vm)?;
+            Ok(zelf)
+        }
+
+        pub(crate) fn __len__(&self) -> usize {
+            self.read().len()
+        }
+
+        fn array_eq(&self, other: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+            // we cannot use zelf.is(other) for shortcut because if we contenting a
+            // float value NaN we always return False even they are the same object.
+            if self.__len__() != other.__len__() {
+                return Ok(false);
+            }
+            let array_a = self.read();
+            let array_b = other.read();
+
+            // fast path for same ArrayContentType type
+            if let Ok(ord) = array_a.cmp(&array_b) {
+                return Ok(ord == Some(Ordering::Equal));
+            }
+
+            let iter = Iterator::zip(array_a.iter(vm), array_b.iter(vm));
+
+            for (a, b) in iter {
+                if !vm.bool_eq(&*a?, &*b?)? {
+                    return Ok(false);
+                }
+            }
+            Ok(true)
+        }
+
+        #[pymethod]
+        fn __reduce_ex__(
+            zelf: &Py<Self>,
+            proto: usize,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
+            if proto < 3 {
+                return Self::__reduce__(zelf, vm);
+            }
+            let array = zelf.read();
+            let cls = zelf.class().to_owned();
+            let typecode = vm.ctx.new_str(array.typecode_str());
+            let bytes = vm.ctx.new_bytes(array.get_bytes().to_vec());
+            let code = MachineFormatCode::from_typecode(array.typecode()).unwrap();
+            let code = PyInt::from(u8::from(code)).into_pyobject(vm);
+            let module = vm.import("array", 0)?;
+            let func = module.get_attr("_array_reconstructor", vm)?;
+            Ok((
+                func,
+                vm.new_tuple((cls, typecode, code, bytes)),
+                zelf.as_object().dict(),
+            ))
+        }
+
+        #[pymethod]
+        fn __reduce__(
+            zelf: &Py<Self>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
+            let array = zelf.read();
+            let cls = zelf.class().to_owned();
+            let typecode = vm.ctx.new_str(array.typecode_str());
+            let values = if array.typecode() == 'u' {
+                let s = Self::_wchar_bytes_to_string(array.get_bytes(), array.itemsize(), vm)?;
+                s.code_points().map(|x| x.to_pyobject(vm)).collect()
+            } else {
+                array.get_objects(vm)
+            };
+            let values = vm.ctx.new_list(values);
+            Ok((
+                cls.into(),
+                vm.new_tuple((typecode, values)),
+                zelf.as_object().dict(),
+            ))
+        }
+
+        fn __contains__(&self, value: PyObjectRef, vm: &VirtualMachine) -> bool {
+            let array = self.array.read();
+            for element in array
+                .iter(vm)
+                .map(|x| x.expect("Expected to be checked by array.len() and read lock."))
+            {
+                if let Ok(true) =
+                    element.rich_compare_bool(value.as_object(), PyComparisonOp::Eq, vm)
+                {
+                    return true;
+                }
+            }
+
+            false
+        }
+
+        #[pyclassmethod]
+        fn __class_getitem__(
+            cls: PyTypeRef,
+            args: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyGenericAlias {
+            PyGenericAlias::from_args(cls, args, vm)
+        }
+    }
+
+    impl Comparable for PyArray {
+        fn cmp(
+            zelf: &Py<Self>,
+            other: &PyObject,
+            op: PyComparisonOp,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyComparisonValue> {
+            // TODO: deduplicate this logic with sequence::cmp in sequence.rs. Maybe make it generic?
+
+            // we cannot use zelf.is(other) for shortcut because if we contenting a
+            // float value NaN we always return False even they are the same object.
+            let other = class_or_notimplemented!(Self, other);
+
+            if let PyComparisonValue::Implemented(x) =
+                op.eq_only(|| Ok(zelf.array_eq(other, vm)?.into()))?
+            {
+                return Ok(x.into());
+            }
+
+            let array_a = zelf.read();
+            let array_b = other.read();
+
+            let res = match array_a.cmp(&array_b) {
+                // fast path for same ArrayContentType type
+                Ok(partial_ord) => partial_ord.is_some_and(|ord| op.eval_ord(ord)),
+                Err(()) => {
+                    let iter = Iterator::zip(array_a.iter(vm), array_b.iter(vm));
+
+                    for (a, b) in iter {
+                        let ret = match op {
+                            PyComparisonOp::Lt | PyComparisonOp::Le => {
+                                vm.bool_seq_lt(&*a?, &*b?)?
+                            }
+                            PyComparisonOp::Gt | PyComparisonOp::Ge => {
+                                vm.bool_seq_gt(&*a?, &*b?)?
+                            }
+                            _ => unreachable!(),
+                        };
+                        if let Some(v) = ret {
+                            return Ok(PyComparisonValue::Implemented(v));
+                        }
+                    }
+
+                    // fallback:
+                    op.eval_ord(array_a.len().cmp(&array_b.len()))
+                }
+            };
+
+            Ok(res.into())
+        }
+    }
+
+    impl AsBuffer for PyArray {
+        fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+            let array = zelf.read();
+            let buf = PyBuffer::new(
+                zelf.to_owned().into(),
+                BufferDescriptor::format(
+                    array.len() * array.itemsize(),
+                    false,
+                    array.itemsize(),
+                    array.typecode_str().into(),
+                ),
+                &BUFFER_METHODS,
+            );
+            Ok(buf)
+        }
+    }
+
+    impl Representable for PyArray {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let class = zelf.class();
+            let class_name = class.name();
+            if zelf.read().typecode() == 'u' {
+                if zelf.__len__() == 0 {
+                    return Ok(format!("{class_name}('u')"));
+                }
+                let to_unicode = zelf.tounicode(vm)?;
+                let escape = crate::vm::literal::escape::UnicodeEscape::new_repr(&to_unicode);
+                return Ok(format!("{}('u', {})", class_name, escape.str_repr()));
+            }
+            zelf.read().repr(&class_name, vm)
+        }
+    }
+
+    static BUFFER_METHODS: BufferMethods = BufferMethods {
+        obj_bytes: |buffer| buffer.obj_as::<PyArray>().get_bytes().into(),
+        obj_bytes_mut: |buffer| buffer.obj_as::<PyArray>().get_bytes_mut().into(),
+        release: |buffer| {
+            buffer
+                .obj_as::<PyArray>()
+                .exports
+                .fetch_sub(1, atomic::Ordering::Release);
+        },
+        retain: |buffer| {
+            buffer
+                .obj_as::<PyArray>()
+                .exports
+                .fetch_add(1, atomic::Ordering::Release);
+        },
+    };
+
+    impl AsMapping for PyArray {
+        fn as_mapping() -> &'static PyMappingMethods {
+            static AS_MAPPING: PyMappingMethods = PyMappingMethods {
+                length: atomic_func!(|mapping, _vm| Ok(
+                    PyArray::mapping_downcast(mapping).__len__()
+                )),
+                subscript: atomic_func!(|mapping, needle, vm| {
+                    PyArray::mapping_downcast(mapping).getitem_inner(needle, vm)
+                }),
+                ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                    let zelf = PyArray::mapping_downcast(mapping);
+                    if let Some(value) = value {
+                        PyArray::setitem_inner(zelf, needle, value, vm)
+                    } else {
+                        zelf.delitem_inner(needle, vm)
+                    }
+                }),
+            };
+            &AS_MAPPING
+        }
+    }
+
+    impl AsSequence for PyArray {
+        fn as_sequence() -> &'static PySequenceMethods {
+            static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
+                length: atomic_func!(|seq, _vm| Ok(PyArray::sequence_downcast(seq).__len__())),
+                concat: atomic_func!(|seq, other, vm| {
+                    let zelf = PyArray::sequence_downcast(seq);
+                    PyArray::__add__(zelf, other.to_owned(), vm).map(|x| x.into())
+                }),
+                repeat: atomic_func!(|seq, n, vm| {
+                    PyArray::sequence_downcast(seq)
+                        .__mul__(n, vm)
+                        .map(|x| x.into())
+                }),
+                item: atomic_func!(|seq, i, vm| {
+                    PyArray::sequence_downcast(seq)
+                        .read()
+                        .getitem_by_index(i, vm)
+                }),
+                ass_item: atomic_func!(|seq, i, value, vm| {
+                    let zelf = PyArray::sequence_downcast(seq);
+                    if let Some(value) = value {
+                        zelf.write().setitem_by_index(i, value, vm)
+                    } else {
+                        zelf.write().delitem_by_index(i, vm)
+                    }
+                }),
+                contains: atomic_func!(|seq, target, vm| {
+                    let zelf = PyArray::sequence_downcast(seq);
+                    Ok(zelf.__contains__(target.to_owned(), vm))
+                }),
+                inplace_concat: atomic_func!(|seq, other, vm| {
+                    let zelf = PyArray::sequence_downcast(seq).to_owned();
+                    PyArray::__iadd__(zelf, other.to_owned(), vm).map(|x| x.into())
+                }),
+                inplace_repeat: atomic_func!(|seq, n, vm| {
+                    let zelf = PyArray::sequence_downcast(seq).to_owned();
+                    PyArray::__imul__(zelf, n, vm).map(|x| x.into())
+                }),
+            };
+            &AS_SEQUENCE
+        }
+    }
+
+    impl Iterable for PyArray {
+        fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+            Ok(PyArrayIter {
+                internal: PyMutex::new(PositionIterInternal::new(zelf, 0)),
+            }
+            .into_pyobject(vm))
+        }
+    }
+
+    impl BufferResizeGuard for PyArray {
+        type Resizable<'a> = PyRwLockWriteGuard<'a, ArrayContentType>;
+
+        fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {
+            let w = self.write();
+            (self.exports.load(atomic::Ordering::SeqCst) == 0).then_some(w)
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(name = "arrayiterator", traverse)]
+    #[derive(Debug, PyPayload)]
+    pub struct PyArrayIter {
+        internal: PyMutex<PositionIterInternal<PyArrayRef>>,
+    }
+
+    #[pyclass(with(IterNext, Iterable), flags(HAS_DICT, DISALLOW_INSTANTIATION))]
+    impl PyArrayIter {
+        #[pymethod]
+        fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            self.internal
+                .lock()
+                .set_state(state, |obj, pos| pos.min(obj.__len__()), vm)
+        }
+
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+            self.internal
+                .lock()
+                .builtins_iter_reduce(|x| x.clone().into(), vm)
+        }
+    }
+
+    impl SelfIter for PyArrayIter {}
+    impl IterNext for PyArrayIter {
+        fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            zelf.internal.lock().next(|array, pos| {
+                Ok(match array.read().get(pos, vm) {
+                    Some(item) => PyIterReturn::Return(item?),
+                    None => PyIterReturn::StopIteration(None),
+                })
+            })
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct ReconstructorArgs {
+        #[pyarg(positional)]
+        arraytype: PyTypeRef,
+        #[pyarg(positional)]
+        typecode: PyStrRef,
+        #[pyarg(positional)]
+        mformat_code: MachineFormatCode,
+        #[pyarg(positional)]
+        items: PyBytesRef,
+    }
+
+    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
+    #[repr(u8)]
+    enum MachineFormatCode {
+        Int8 { signed: bool },                    // 0, 1
+        Int16 { signed: bool, big_endian: bool }, // 2, 3, 4, 5
+        Int32 { signed: bool, big_endian: bool }, // 6, 7, 8, 9
+        Int64 { signed: bool, big_endian: bool }, // 10, 11, 12, 13
+        Ieee754Float { big_endian: bool },        // 14, 15
+        Ieee754Double { big_endian: bool },       // 16, 17
+        Utf16 { big_endian: bool },               // 18, 19
+        Utf32 { big_endian: bool },               // 20, 21
+    }
+
+    impl From<MachineFormatCode> for u8 {
+        fn from(code: MachineFormatCode) -> Self {
+            use MachineFormatCode::*;
+            match code {
+                Int8 { signed } => signed as Self,
+                Int16 { signed, big_endian } => 2 + signed as Self * 2 + big_endian as Self,
+                Int32 { signed, big_endian } => 6 + signed as Self * 2 + big_endian as Self,
+                Int64 { signed, big_endian } => 10 + signed as Self * 2 + big_endian as Self,
+                Ieee754Float { big_endian } => 14 + big_endian as Self,
+                Ieee754Double { big_endian } => 16 + big_endian as Self,
+                Utf16 { big_endian } => 18 + big_endian as Self,
+                Utf32 { big_endian } => 20 + big_endian as Self,
+            }
+        }
+    }
+
+    impl TryFrom<u8> for MachineFormatCode {
+        type Error = u8;
+
+        fn try_from(code: u8) -> Result<Self, Self::Error> {
+            let big_endian = !code.is_multiple_of(2);
+            let signed = match code {
+                0 | 1 => code != 0,
+                2..=13 => (code - 2) % 4 >= 2,
+                _ => false,
+            };
+            match code {
+                0..=1 => Ok(Self::Int8 { signed }),
+                2..=5 => Ok(Self::Int16 { signed, big_endian }),
+                6..=9 => Ok(Self::Int32 { signed, big_endian }),
+                10..=13 => Ok(Self::Int64 { signed, big_endian }),
+                14..=15 => Ok(Self::Ieee754Float { big_endian }),
+                16..=17 => Ok(Self::Ieee754Double { big_endian }),
+                18..=19 => Ok(Self::Utf16 { big_endian }),
+                20..=21 => Ok(Self::Utf32 { big_endian }),
+                _ => Err(code),
+            }
+        }
+    }
+
+    impl<'a> TryFromBorrowedObject<'a> for MachineFormatCode {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+            obj.try_to_ref::<PyInt>(vm)
+                .map_err(|_| {
+                    vm.new_type_error(format!(
+                        "an integer is required (got type {})",
+                        obj.class().name()
+                    ))
+                })?
+                .try_to_primitive::<i32>(vm)?
+                .to_u8()
+                .unwrap_or(u8::MAX)
+                .try_into()
+                .map_err(|_| {
+                    vm.new_value_error("third argument must be a valid machine format code.")
+                })
+        }
+    }
+
+    impl MachineFormatCode {
+        fn from_typecode(code: char) -> Option<Self> {
+            use core::mem::size_of;
+            let signed = code.is_ascii_uppercase();
+            let big_endian = cfg!(target_endian = "big");
+            let int_size = match code {
+                'b' | 'B' => return Some(Self::Int8 { signed }),
+                'u' => {
+                    return match size_of::<wchar_t>() {
+                        2 => Some(Self::Utf16 { big_endian }),
+                        4 => Some(Self::Utf32 { big_endian }),
+                        _ => None,
+                    };
+                }
+                'f' => {
+                    // Copied from CPython
+                    const Y: f32 = 16711938.0;
+                    return match &Y.to_ne_bytes() {
+                        b"\x4b\x7f\x01\x02" => Some(Self::Ieee754Float { big_endian: true }),
+                        b"\x02\x01\x7f\x4b" => Some(Self::Ieee754Float { big_endian: false }),
+                        _ => None,
+                    };
+                }
+                'd' => {
+                    // Copied from CPython
+                    const Y: f64 = 9006104071832581.0;
+                    return match &Y.to_ne_bytes() {
+                        b"\x43\x3f\xff\x01\x02\x03\x04\x05" => {
+                            Some(Self::Ieee754Double { big_endian: true })
+                        }
+                        b"\x05\x04\x03\x02\x01\xff\x3f\x43" => {
+                            Some(Self::Ieee754Double { big_endian: false })
+                        }
+                        _ => None,
+                    };
+                }
+                _ => ArrayContentType::itemsize_of_typecode(code)? as u8,
+            };
+            match int_size {
+                2 => Some(Self::Int16 { signed, big_endian }),
+                4 => Some(Self::Int32 { signed, big_endian }),
+                8 => Some(Self::Int64 { signed, big_endian }),
+                _ => None,
+            }
+        }
+        const fn item_size(self) -> usize {
+            match self {
+                Self::Int8 { .. } => 1,
+                Self::Int16 { .. } | Self::Utf16 { .. } => 2,
+                Self::Int32 { .. } | Self::Utf32 { .. } | Self::Ieee754Float { .. } => 4,
+                Self::Int64 { .. } | Self::Ieee754Double { .. } => 8,
+            }
+        }
+    }
+
+    fn check_array_type(typ: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyTypeRef> {
+        if !typ.fast_issubclass(PyArray::class(&vm.ctx)) {
+            return Err(
+                vm.new_type_error(format!("{} is not a subtype of array.array", typ.name()))
+            );
+        }
+        Ok(typ)
+    }
+
+    fn check_type_code(spec: PyStrRef, 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",
+            )
+        })?;
+        ArrayContentType::from_char(spec)
+            .map_err(|_| vm.new_value_error("second argument must be a valid type code"))
+    }
+
+    macro_rules! chunk_to_obj {
+        ($BYTE:ident, $TY:ty, $BIG_ENDIAN:ident) => {{
+            let b = <[u8; ::core::mem::size_of::<$TY>()]>::try_from($BYTE).unwrap();
+            if $BIG_ENDIAN {
+                <$TY>::from_be_bytes(b)
+            } else {
+                <$TY>::from_le_bytes(b)
+            }
+        }};
+        ($VM:ident, $BYTE:ident, $TY:ty, $BIG_ENDIAN:ident) => {
+            chunk_to_obj!($BYTE, $TY, $BIG_ENDIAN).to_pyobject($VM)
+        };
+        ($VM:ident, $BYTE:ident, $SIGNED_TY:ty, $UNSIGNED_TY:ty, $SIGNED:ident, $BIG_ENDIAN:ident) => {{
+            let b = <[u8; ::core::mem::size_of::<$SIGNED_TY>()]>::try_from($BYTE).unwrap();
+            match ($SIGNED, $BIG_ENDIAN) {
+                (false, false) => <$UNSIGNED_TY>::from_le_bytes(b).to_pyobject($VM),
+                (false, true) => <$UNSIGNED_TY>::from_be_bytes(b).to_pyobject($VM),
+                (true, false) => <$SIGNED_TY>::from_le_bytes(b).to_pyobject($VM),
+                (true, true) => <$SIGNED_TY>::from_be_bytes(b).to_pyobject($VM),
+            }
+        }};
+    }
+
+    #[pyfunction]
+    fn _array_reconstructor(args: ReconstructorArgs, vm: &VirtualMachine) -> PyResult<PyArrayRef> {
+        let cls = check_array_type(args.arraytype, vm)?;
+        let mut array = check_type_code(args.typecode, vm)?;
+        let format = args.mformat_code;
+        let bytes = args.items.as_bytes();
+        if !bytes.len().is_multiple_of(format.item_size()) {
+            return Err(vm.new_value_error("bytes length not a multiple of item size"));
+        }
+        if MachineFormatCode::from_typecode(array.typecode()) == Some(format) {
+            array.frombytes(bytes);
+            return PyArray::from(array).into_ref_with_type(vm, cls);
+        }
+        if !matches!(
+            format,
+            MachineFormatCode::Utf16 { .. } | MachineFormatCode::Utf32 { .. }
+        ) {
+            array.reserve(bytes.len() / format.item_size());
+        }
+        let mut chunks = bytes.chunks(format.item_size());
+        match format {
+            MachineFormatCode::Ieee754Float { big_endian } => {
+                chunks.try_for_each(|b| array.push(chunk_to_obj!(vm, b, f32, big_endian), vm))?
+            }
+            MachineFormatCode::Ieee754Double { big_endian } => {
+                chunks.try_for_each(|b| array.push(chunk_to_obj!(vm, b, f64, big_endian), vm))?
+            }
+            MachineFormatCode::Int8 { signed } => chunks
+                .try_for_each(|b| array.push(chunk_to_obj!(vm, b, i8, u8, signed, false), vm))?,
+            MachineFormatCode::Int16 { signed, big_endian } => chunks.try_for_each(|b| {
+                array.push(chunk_to_obj!(vm, b, i16, u16, signed, big_endian), vm)
+            })?,
+            MachineFormatCode::Int32 { signed, big_endian } => chunks.try_for_each(|b| {
+                array.push(chunk_to_obj!(vm, b, i32, u32, signed, big_endian), vm)
+            })?,
+            MachineFormatCode::Int64 { signed, big_endian } => chunks.try_for_each(|b| {
+                array.push(chunk_to_obj!(vm, b, i64, u64, signed, big_endian), vm)
+            })?,
+            MachineFormatCode::Utf16 { big_endian } => {
+                let utf16: Vec<_> = chunks.map(|b| chunk_to_obj!(b, u16, big_endian)).collect();
+                let s = String::from_utf16(&utf16)
+                    .map_err(|_| vm.new_unicode_encode_error("items cannot decode as utf16"))?;
+                let bytes = PyArray::_unicode_to_wchar_bytes((*s).as_ref(), array.itemsize());
+                array.frombytes_move(bytes);
+            }
+            MachineFormatCode::Utf32 { big_endian } => {
+                let s: Wtf8Buf = chunks
+                    .map(|b| chunk_to_obj!(b, u32, big_endian))
+                    .map(|ch| u32_to_char(ch).map_err(|msg| vm.new_value_error(msg)))
+                    .try_collect()?;
+                let bytes = PyArray::_unicode_to_wchar_bytes(&s, array.itemsize());
+                array.frombytes_move(bytes);
+            }
+        };
+        PyArray::from(array).into_ref_with_type(vm, cls)
+    }
+}
diff --git a/stdlib/src/binascii.rs b/crates/stdlib/src/binascii.rs
similarity index 99%
rename from stdlib/src/binascii.rs
rename to crates/stdlib/src/binascii.rs
index a2316d3c20..671d1d9e25 100644
--- a/stdlib/src/binascii.rs
+++ b/crates/stdlib/src/binascii.rs
@@ -359,7 +359,7 @@ mod decl {
                     }
                     _ => unsafe {
                         // quad_pos is only assigned in this match statement to constants
-                        std::hint::unreachable_unchecked()
+                        core::hint::unreachable_unchecked()
                     },
                 }
             }
diff --git a/stdlib/src/bisect.rs b/crates/stdlib/src/bisect.rs
similarity index 98%
rename from stdlib/src/bisect.rs
rename to crates/stdlib/src/bisect.rs
index 46e689ac06..e712d0275d 100644
--- a/stdlib/src/bisect.rs
+++ b/crates/stdlib/src/bisect.rs
@@ -24,7 +24,7 @@ mod _bisect {
     #[inline]
     fn handle_default(arg: OptionalArg<ArgIndex>, vm: &VirtualMachine) -> PyResult<Option<isize>> {
         arg.into_option()
-            .map(|v| v.try_to_primitive(vm))
+            .map(|v| v.into_int_ref().try_to_primitive(vm))
             .transpose()
     }
 
diff --git a/stdlib/src/blake2.rs b/crates/stdlib/src/blake2.rs
similarity index 100%
rename from stdlib/src/blake2.rs
rename to crates/stdlib/src/blake2.rs
diff --git a/stdlib/src/bz2.rs b/crates/stdlib/src/bz2.rs
similarity index 91%
rename from stdlib/src/bz2.rs
rename to crates/stdlib/src/bz2.rs
index f4db2d9fa1..93142e92a6 100644
--- a/stdlib/src/bz2.rs
+++ b/crates/stdlib/src/bz2.rs
@@ -8,16 +8,17 @@ mod _bz2 {
         DecompressArgs, DecompressError, DecompressState, DecompressStatus, Decompressor,
     };
     use crate::vm::{
-        VirtualMachine,
-        builtins::{PyBytesRef, PyTypeRef},
+        Py, VirtualMachine,
+        builtins::{PyBytesRef, PyType},
         common::lock::PyMutex,
         function::{ArgBytesLike, OptionalArg},
-        object::{PyPayload, PyResult},
+        object::PyResult,
         types::Constructor,
     };
+    use alloc::fmt;
     use bzip2::{Decompress, Status, write::BzEncoder};
     use rustpython_vm::convert::ToPyException;
-    use std::{fmt, io::Write};
+    use std::io::Write;
 
     const BUFSIZ: usize = 8192;
 
@@ -61,12 +62,10 @@ mod _bz2 {
     impl Constructor for BZ2Decompressor {
         type Args = ();
 
-        fn py_new(cls: PyTypeRef, _: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self {
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
                 state: PyMutex::new(DecompressState::new(Decompress::new(false), vm)),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -132,8 +131,11 @@ mod _bz2 {
     impl Constructor for BZ2Compressor {
         type Args = (OptionalArg<i32>,);
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let (compresslevel,) = args;
+        fn py_new(
+            _cls: &Py<PyType>,
+            (compresslevel,): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             // TODO: seriously?
             // compresslevel.unwrap_or(bzip2::Compression::best().level().try_into().unwrap());
             let compresslevel = compresslevel.unwrap_or(9);
@@ -144,14 +146,12 @@ mod _bz2 {
                 }
             };
 
-            Self {
+            Ok(Self {
                 state: PyMutex::new(CompressorState {
                     flushed: false,
                     encoder: Some(BzEncoder::new(Vec::new(), level)),
                 }),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
diff --git a/crates/stdlib/src/cmath.rs b/crates/stdlib/src/cmath.rs
new file mode 100644
index 0000000000..e7abb3bcad
--- /dev/null
+++ b/crates/stdlib/src/cmath.rs
@@ -0,0 +1,170 @@
+pub(crate) use cmath::make_module;
+
+#[pymodule]
+mod cmath {
+    use crate::vm::{
+        PyResult, VirtualMachine,
+        function::{ArgIntoComplex, ArgIntoFloat, OptionalArg},
+    };
+    use num_complex::Complex64;
+
+    use crate::math::pymath_exception;
+
+    // Constants
+    #[pyattr(name = "e")]
+    const E: f64 = pymath::cmath::E;
+    #[pyattr(name = "pi")]
+    const PI: f64 = pymath::cmath::PI;
+    #[pyattr(name = "tau")]
+    const TAU: f64 = pymath::cmath::TAU;
+    #[pyattr(name = "inf")]
+    const INF: f64 = pymath::cmath::INF;
+    #[pyattr(name = "nan")]
+    const NAN: f64 = pymath::cmath::NAN;
+    #[pyattr(name = "infj")]
+    const INFJ: Complex64 = pymath::cmath::INFJ;
+    #[pyattr(name = "nanj")]
+    const NANJ: Complex64 = pymath::cmath::NANJ;
+
+    #[pyfunction]
+    fn phase(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::cmath::phase(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn polar(x: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
+        pymath::cmath::polar(x.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn rect(r: ArgIntoFloat, phi: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::rect(r.into_float(), phi.into_float())
+            .map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn isinf(z: ArgIntoComplex) -> bool {
+        pymath::cmath::isinf(z.into_complex())
+    }
+
+    #[pyfunction]
+    fn isfinite(z: ArgIntoComplex) -> bool {
+        pymath::cmath::isfinite(z.into_complex())
+    }
+
+    #[pyfunction]
+    fn isnan(z: ArgIntoComplex) -> bool {
+        pymath::cmath::isnan(z.into_complex())
+    }
+
+    #[pyfunction]
+    fn exp(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::exp(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn sqrt(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sqrt(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn sin(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sin(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn asin(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::asin(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn cos(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::cos(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn acos(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::acos(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn log(
+        z: ArgIntoComplex,
+        base: OptionalArg<ArgIntoComplex>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Complex64> {
+        pymath::cmath::log(
+            z.into_complex(),
+            base.into_option().map(|b| b.into_complex()),
+        )
+        .map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn log10(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::log10(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn acosh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::acosh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn atan(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::atan(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn atanh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::atanh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn tan(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::tan(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn tanh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::tanh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn sinh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::sinh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn cosh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::cosh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn asinh(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
+        pymath::cmath::asinh(z.into_complex()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[derive(FromArgs)]
+    struct IsCloseArgs {
+        #[pyarg(positional)]
+        a: ArgIntoComplex,
+        #[pyarg(positional)]
+        b: ArgIntoComplex,
+        #[pyarg(named, optional)]
+        rel_tol: OptionalArg<ArgIntoFloat>,
+        #[pyarg(named, optional)]
+        abs_tol: OptionalArg<ArgIntoFloat>,
+    }
+
+    #[pyfunction]
+    fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
+        let a = args.a.into_complex();
+        let b = args.b.into_complex();
+        let rel_tol = args.rel_tol.into_option().map(|v| v.into_float());
+        let abs_tol = args.abs_tol.into_option().map(|v| v.into_float());
+
+        pymath::cmath::isclose(a, b, rel_tol, abs_tol)
+            .map_err(|_| vm.new_value_error("tolerances must be non-negative"))
+    }
+}
diff --git a/stdlib/src/compression.rs b/crates/stdlib/src/compression.rs
similarity index 98%
rename from stdlib/src/compression.rs
rename to crates/stdlib/src/compression.rs
index 9fa7e3e02d..a857b4e53d 100644
--- a/stdlib/src/compression.rs
+++ b/crates/stdlib/src/compression.rs
@@ -107,7 +107,7 @@ impl<'a> Chunker<'a> {
     pub fn advance(&mut self, consumed: usize) {
         self.data1 = &self.data1[consumed..];
         if self.data1.is_empty() {
-            self.data1 = std::mem::take(&mut self.data2);
+            self.data1 = core::mem::take(&mut self.data2);
         }
     }
 }
@@ -140,7 +140,7 @@ pub fn _decompress_chunks<D: Decompressor>(
         let chunk = data.chunk();
         let flush = calc_flush(chunk.len() == data.len());
         loop {
-            let additional = std::cmp::min(bufsize, max_length - buf.capacity());
+            let additional = core::cmp::min(bufsize, max_length - buf.capacity());
             if additional == 0 {
                 return Ok((buf, false));
             }
@@ -204,7 +204,6 @@ pub trait CompressFlushKind: Copy {
 }
 
 pub trait CompressStatusKind: Copy {
-    const OK: Self;
     const EOF: Self;
 
     fn to_usize(self) -> usize;
diff --git a/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
similarity index 84%
rename from stdlib/src/contextvars.rs
rename to crates/stdlib/src/contextvars.rs
index 72eba70389..5608b39d1e 100644
--- a/stdlib/src/contextvars.rs
+++ b/crates/stdlib/src/contextvars.rs
@@ -1,6 +1,6 @@
 use crate::vm::{PyRef, VirtualMachine, builtins::PyModule, class::StaticType};
 use _contextvars::PyContext;
-use std::cell::RefCell;
+use core::cell::RefCell;
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _contextvars::make_module(vm);
@@ -24,20 +24,20 @@ thread_local! {
 mod _contextvars {
     use crate::vm::{
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
-        builtins::{PyGenericAlias, PyStrRef, PyTypeRef},
+        builtins::{PyGenericAlias, PyList, PyStrRef, PyType, PyTypeRef},
         class::StaticType,
         common::hash::PyHash,
         function::{ArgCallable, FuncArgs, OptionalArg},
         protocol::{PyMappingMethods, PySequenceMethods},
-        types::{AsMapping, AsSequence, Constructor, Hashable, Representable},
+        types::{AsMapping, AsSequence, Constructor, Hashable, Iterable, Representable},
     };
-    use crossbeam_utils::atomic::AtomicCell;
-    use indexmap::IndexMap;
-    use std::sync::LazyLock;
-    use std::{
+    use core::{
         cell::{Cell, RefCell, UnsafeCell},
         sync::atomic::Ordering,
     };
+    use crossbeam_utils::atomic::AtomicCell;
+    use indexmap::IndexMap;
+    use std::sync::LazyLock;
 
     // TODO: Real hamt implementation
     type Hamt = IndexMap<PyRef<ContextVar>, PyObjectRef, ahash::RandomState>;
@@ -90,11 +90,11 @@ mod _contextvars {
             }
         }
 
-        fn borrow_vars(&self) -> impl std::ops::Deref<Target = Hamt> + '_ {
+        fn borrow_vars(&self) -> impl core::ops::Deref<Target = Hamt> + '_ {
             self.inner.vars.hamt.borrow()
         }
 
-        fn borrow_vars_mut(&self) -> impl std::ops::DerefMut<Target = Hamt> + '_ {
+        fn borrow_vars_mut(&self) -> impl core::ops::DerefMut<Target = Hamt> + '_ {
             self.inner.vars.hamt.borrow_mut()
         }
 
@@ -107,8 +107,7 @@ mod _contextvars {
                 return Err(vm.new_runtime_error(msg));
             }
 
-            super::CONTEXTS.with(|ctxs| {
-                let mut ctxs = ctxs.borrow_mut();
+            super::CONTEXTS.with_borrow_mut(|ctxs| {
                 zelf.inner.idx.set(ctxs.len());
                 ctxs.push(zelf.to_owned());
             });
@@ -126,18 +125,12 @@ mod _contextvars {
                 return Err(vm.new_runtime_error(msg));
             }
 
-            super::CONTEXTS.with(|ctxs| {
-                let mut ctxs = ctxs.borrow_mut();
-                // TODO: use Vec::pop_if once stabilized
-                if ctxs.last().is_some_and(|ctx| ctx.get_id() == zelf.get_id()) {
-                    let _ = ctxs.pop();
-                    Ok(())
-                } else {
-                    let msg =
-                        "cannot exit context: thread state references a different context object"
-                            .to_owned();
-                    Err(vm.new_runtime_error(msg))
-                }
+            super::CONTEXTS.with_borrow_mut(|ctxs| {
+                let err_msg =
+                    "cannot exit context: thread state references a different context object";
+                ctxs.pop_if(|ctx| ctx.get_id() == zelf.get_id())
+                    .map(drop)
+                    .ok_or_else(|| vm.new_runtime_error(err_msg))
             })?;
             zelf.inner.entered.set(false);
 
@@ -145,8 +138,7 @@ mod _contextvars {
         }
 
         fn current(vm: &VirtualMachine) -> PyRef<Self> {
-            super::CONTEXTS.with(|ctxs| {
-                let mut ctxs = ctxs.borrow_mut();
+            super::CONTEXTS.with_borrow_mut(|ctxs| {
                 if let Some(ctx) = ctxs.last() {
                     ctx.clone()
                 } else {
@@ -171,7 +163,7 @@ mod _contextvars {
         }
     }
 
-    #[pyclass(with(Constructor, AsMapping, AsSequence))]
+    #[pyclass(with(Constructor, AsMapping, AsSequence, Iterable))]
     impl PyContext {
         #[pymethod]
         fn run(
@@ -197,7 +189,6 @@ mod _contextvars {
             }
         }
 
-        #[pymethod]
         fn __getitem__(
             &self,
             var: PyRef<ContextVar>,
@@ -210,16 +201,10 @@ mod _contextvars {
             Ok(item.to_owned())
         }
 
-        #[pymethod]
         fn __len__(&self) -> usize {
             self.borrow_vars().len()
         }
 
-        #[pymethod]
-        fn __iter__(&self) -> PyResult {
-            unimplemented!("Context.__iter__ is currently under construction")
-        }
-
         #[pymethod]
         fn get(
             &self,
@@ -248,12 +233,21 @@ mod _contextvars {
             let vars = zelf.borrow_vars();
             vars.values().map(|value| value.to_owned()).collect()
         }
+
+        // TODO: wrong return type
+        #[pymethod]
+        fn items(zelf: PyRef<Self>, vm: &VirtualMachine) -> Vec<PyObjectRef> {
+            let vars = zelf.borrow_vars();
+            vars.iter()
+                .map(|(k, v)| vm.ctx.new_tuple(vec![k.clone().into(), v.clone()]).into())
+                .collect()
+        }
     }
 
     impl Constructor for PyContext {
         type Args = ();
-        fn py_new(_cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Ok(Self::empty(vm).into_pyobject(vm))
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self::empty(vm))
         }
     }
 
@@ -272,7 +266,7 @@ mod _contextvars {
                         Err(vm.new_key_error(needle.to_owned().into()))
                     }
                 }),
-                ass_subscript: AtomicCell::new(None),
+                ass_subscript: None,
             };
             &AS_MAPPING
         }
@@ -291,6 +285,15 @@ mod _contextvars {
         }
     }
 
+    impl Iterable for PyContext {
+        fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+            let vars = zelf.borrow_vars();
+            let keys: Vec<PyObjectRef> = vars.keys().map(|k| k.clone().into()).collect();
+            let list = vm.ctx.new_list(keys);
+            <PyList as Iterable>::iter(list, vm)
+        }
+    }
+
     #[pyattr]
     #[pyclass(name, traverse)]
     #[derive(PyPayload)]
@@ -301,13 +304,13 @@ mod _contextvars {
         #[pytraverse(skip)]
         cached: AtomicCell<Option<ContextVarCache>>,
         #[pytraverse(skip)]
-        cached_id: std::sync::atomic::AtomicUsize, // cached_tsid in CPython
+        cached_id: core::sync::atomic::AtomicUsize, // cached_tsid in CPython
         #[pytraverse(skip)]
         hash: UnsafeCell<PyHash>,
     }
 
-    impl std::fmt::Debug for ContextVar {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for ContextVar {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             f.debug_struct("ContextVar").finish()
         }
     }
@@ -316,7 +319,7 @@ mod _contextvars {
 
     impl PartialEq for ContextVar {
         fn eq(&self, other: &Self) -> bool {
-            std::ptr::eq(self, other)
+            core::ptr::eq(self, other)
         }
     }
     impl Eq for ContextVar {}
@@ -382,17 +385,15 @@ mod _contextvars {
             default: OptionalArg<PyObjectRef>,
             vm: &VirtualMachine,
         ) -> PyResult<Option<PyObjectRef>> {
-            let found = super::CONTEXTS.with(|ctxs| {
-                let ctxs = ctxs.borrow();
+            let found = super::CONTEXTS.with_borrow(|ctxs| {
                 let ctx = ctxs.last()?;
                 let cached_ptr = zelf.cached.as_ptr();
                 debug_assert!(!cached_ptr.is_null());
-                if let Some(cached) = unsafe { &*cached_ptr } {
-                    if zelf.cached_id.load(Ordering::SeqCst) == ctx.get_id()
-                        && cached.idx + 1 == ctxs.len()
-                    {
-                        return Some(cached.object.clone());
-                    }
+                if let Some(cached) = unsafe { &*cached_ptr }
+                    && zelf.cached_id.load(Ordering::SeqCst) == ctx.get_id()
+                    && cached.idx + 1 == ctxs.len()
+                {
+                    return Some(cached.object.clone());
                 }
                 let vars = ctx.borrow_vars();
                 let obj = vars.get(zelf)?;
@@ -498,7 +499,9 @@ mod _contextvars {
 
     impl Constructor for ContextVar {
         type Args = ContextVarOptions;
-        fn py_new(_cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let args: Self::Args = args.bind(vm)?;
             let var = Self {
                 name: args.name.to_string(),
                 default: args.default.into_option(),
@@ -506,7 +509,7 @@ mod _contextvars {
                 cached: AtomicCell::new(None),
                 hash: UnsafeCell::new(0),
             };
-            let py_var = var.into_ref(&vm.ctx);
+            let py_var = var.into_ref_with_type(vm, cls)?;
 
             unsafe {
                 // SAFETY: py_var is not exposed to python memory model yet
@@ -514,11 +517,15 @@ mod _contextvars {
             };
             Ok(py_var.into())
         }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
     }
 
-    impl std::hash::Hash for ContextVar {
+    impl core::hash::Hash for ContextVar {
         #[inline]
-        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
             unsafe { *self.hash.get() }.hash(state)
         }
     }
@@ -580,6 +587,22 @@ mod _contextvars {
         ) -> PyGenericAlias {
             PyGenericAlias::from_args(cls, args, vm)
         }
+
+        #[pymethod]
+        fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
+            zelf
+        }
+
+        #[pymethod]
+        fn __exit__(
+            zelf: &Py<Self>,
+            _ty: PyObjectRef,
+            _val: PyObjectRef,
+            _tb: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            ContextVar::reset(&zelf.var, zelf.to_owned(), vm)
+        }
     }
 
     impl Constructor for ContextToken {
@@ -588,8 +611,8 @@ mod _contextvars {
         fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
             Err(vm.new_runtime_error("Tokens can only be created by ContextVars"))
         }
-        fn py_new(_cls: PyTypeRef, _args: Self::Args, _vm: &VirtualMachine) -> PyResult {
-            unreachable!()
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
         }
     }
 
diff --git a/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
similarity index 96%
rename from stdlib/src/csv.rs
rename to crates/stdlib/src/csv.rs
index a5add740f4..4f6cbd7682 100644
--- a/stdlib/src/csv.rs
+++ b/crates/stdlib/src/csv.rs
@@ -4,18 +4,21 @@ pub(crate) use _csv::make_module;
 mod _csv {
     use crate::common::lock::PyMutex;
     use crate::vm::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyInt, PyNone, PyStr, PyType, PyTypeError, PyTypeRef},
+        AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+        VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyInt, PyNone, PyStr, PyType, PyTypeRef},
         function::{ArgIterable, ArgumentError, FromArgs, FuncArgs, OptionalArg},
         protocol::{PyIter, PyIterReturn},
+        raise_if_stop,
         types::{Constructor, IterNext, Iterable, SelfIter},
     };
+    use alloc::fmt;
     use csv_core::Terminator;
     use itertools::{self, Itertools};
     use parking_lot::Mutex;
     use rustpython_vm::match_class;
+    use std::collections::HashMap;
     use std::sync::LazyLock;
-    use std::{collections::HashMap, fmt};
 
     #[pyattr]
     const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32;
@@ -67,10 +70,8 @@ mod _csv {
     impl Constructor for PyDialect {
         type Args = PyObjectRef;
 
-        fn py_new(cls: PyTypeRef, ctx: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self::try_from_object(vm, ctx)?
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+        fn py_new(_cls: &Py<PyType>, ctx: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            Self::try_from_object(vm, ctx)
         }
     }
     #[pyclass(with(Constructor))]
@@ -131,11 +132,11 @@ mod _csv {
     ///
     /// * If the 'delimiter' attribute is not a single-character string, a type error is returned.
     /// * If the 'obj' is not of string type and does not have a 'delimiter' attribute, a type error is returned.
-    fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<u8> {
+    fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<u8> {
         if let Ok(attr) = obj.get_attr("delimiter", vm) {
             parse_delimiter_from_obj(vm, &attr)
         } else {
-            match_class!(match obj.clone() {
+            match_class!(match obj.to_owned() {
                 s @ PyStr => {
                     Ok(s.as_str().bytes().exactly_one().map_err(|_| {
                         let msg = r#""delimiter" must be a 1-character string"#;
@@ -149,7 +150,7 @@ mod _csv {
             })
         }
     }
-    fn parse_quotechar_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<u8>> {
+    fn parse_quotechar_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Option<u8>> {
         match_class!(match obj.get_attr("quotechar", vm)? {
             s @ PyStr => {
                 Ok(Some(s.as_str().bytes().exactly_one().map_err(|_| {
@@ -170,7 +171,7 @@ mod _csv {
             }
         })
     }
-    fn parse_escapechar_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<Option<u8>> {
+    fn parse_escapechar_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Option<u8>> {
         match_class!(match obj.get_attr("escapechar", vm)? {
             s @ PyStr => {
                 Ok(Some(s.as_str().bytes().exactly_one().map_err(|_| {
@@ -192,10 +193,7 @@ mod _csv {
             }
         })
     }
-    fn prase_lineterminator_from_obj(
-        vm: &VirtualMachine,
-        obj: &PyObjectRef,
-    ) -> PyResult<Terminator> {
+    fn prase_lineterminator_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Terminator> {
         match_class!(match obj.get_attr("lineterminator", vm)? {
             s @ PyStr => {
                 Ok(if s.as_bytes().eq(b"\r\n") {
@@ -218,7 +216,7 @@ mod _csv {
             }
         })
     }
-    fn prase_quoting_from_obj(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult<QuoteStyle> {
+    fn prase_quoting_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<QuoteStyle> {
         match_class!(match obj.get_attr("quoting", vm)? {
             i @ PyInt => {
                 Ok(i.try_to_primitive::<isize>(vm)?.try_into().map_err(|_| {
@@ -269,7 +267,7 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
+        let Some(name) = name.downcast_ref::<PyStr>() else {
             return Err(vm.new_type_error("argument 0 must be a string"));
         };
         let dialect = match dialect {
@@ -290,7 +288,7 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<PyDialect> {
-        let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
+        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()),
@@ -309,7 +307,7 @@ mod _csv {
         mut _rest: FuncArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
-        let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
+        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()),
@@ -443,8 +441,8 @@ mod _csv {
         }
     }
     impl TryFrom<isize> for QuoteStyle {
-        type Error = PyTypeError;
-        fn try_from(num: isize) -> Result<Self, PyTypeError> {
+        type Error = ();
+        fn try_from(num: isize) -> Result<Self, Self::Error> {
             match num {
                 0 => Ok(Self::Minimal),
                 1 => Ok(Self::All),
@@ -452,7 +450,7 @@ mod _csv {
                 3 => Ok(Self::None),
                 4 => Ok(Self::Strings),
                 5 => Ok(Self::Notnull),
-                _ => Err(PyTypeError {}),
+                _ => Err(()),
             }
         }
     }
@@ -909,7 +907,7 @@ mod _csv {
         }
     }
 
-    #[pyclass(with(IterNext, Iterable))]
+    #[pyclass(with(IterNext, Iterable), flags(DISALLOW_INSTANTIATION))]
     impl Reader {
         #[pygetset]
         fn line_num(&self) -> u64 {
@@ -923,10 +921,7 @@ mod _csv {
     impl SelfIter for Reader {}
     impl IterNext for Reader {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-            let string = match zelf.iter.next(vm)? {
-                PyIterReturn::Return(obj) => obj,
-                PyIterReturn::StopIteration(v) => return Ok(PyIterReturn::StopIteration(v)),
-            };
+            let string = raise_if_stop!(zelf.iter.next(vm)?);
             let string = string.downcast::<PyStr>().map_err(|obj| {
                 new_csv_error(
                     vm,
@@ -1012,7 +1007,7 @@ mod _csv {
                         return Err(new_csv_error(vm, "filed too long to read".to_string()));
                     }
                     prev_end = end;
-                    let s = std::str::from_utf8(&buffer[range.clone()])
+                    let s = core::str::from_utf8(&buffer[range.clone()])
                         // not sure if this is possible - the input was all strings
                         .map_err(|_e| vm.new_unicode_decode_error("csv not utf8"))?;
                     // Rustpython TODO!
@@ -1063,7 +1058,7 @@ mod _csv {
         }
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Writer {
         #[pygetset(name = "dialect")]
         const fn get_dialect(&self, _vm: &VirtualMachine) -> PyDialect {
@@ -1122,7 +1117,7 @@ mod _csv {
             loop {
                 handle_res!(writer.terminator(&mut buffer[buffer_offset..]));
             }
-            let s = std::str::from_utf8(&buffer[..buffer_offset])
+            let s = core::str::from_utf8(&buffer[..buffer_offset])
                 .map_err(|_| vm.new_unicode_decode_error("csv not utf8"))?;
 
             self.write.call((s,), vm)
diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
new file mode 100644
index 0000000000..eba5643b86
--- /dev/null
+++ b/crates/stdlib/src/faulthandler.rs
@@ -0,0 +1,1210 @@
+pub(crate) use decl::make_module;
+
+#[allow(static_mut_refs)] // TODO: group code only with static mut refs
+#[pymodule(name = "faulthandler")]
+mod decl {
+    use crate::vm::{
+        PyObjectRef, PyResult, VirtualMachine, builtins::PyFloat, frame::Frame,
+        function::OptionalArg, py_io::Write,
+    };
+    use alloc::sync::Arc;
+    use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
+    use core::time::Duration;
+    use parking_lot::{Condvar, Mutex};
+    #[cfg(any(unix, windows))]
+    use rustpython_common::os::{get_errno, set_errno};
+    use std::thread;
+
+    /// fault_handler_t
+    #[cfg(unix)]
+    struct FaultHandler {
+        signum: libc::c_int,
+        enabled: bool,
+        name: &'static str,
+        previous: libc::sigaction,
+    }
+
+    #[cfg(windows)]
+    struct FaultHandler {
+        signum: libc::c_int,
+        enabled: bool,
+        name: &'static str,
+        previous: libc::sighandler_t,
+    }
+
+    #[cfg(unix)]
+    impl FaultHandler {
+        const fn new(signum: libc::c_int, name: &'static str) -> Self {
+            Self {
+                signum,
+                enabled: false,
+                name,
+                // SAFETY: sigaction is a C struct that can be zero-initialized
+                previous: unsafe { core::mem::zeroed() },
+            }
+        }
+    }
+
+    #[cfg(windows)]
+    impl FaultHandler {
+        const fn new(signum: libc::c_int, name: &'static str) -> Self {
+            Self {
+                signum,
+                enabled: false,
+                name,
+                previous: 0,
+            }
+        }
+    }
+
+    /// faulthandler_handlers[]
+    /// Number of fatal signals
+    #[cfg(unix)]
+    const FAULTHANDLER_NSIGNALS: usize = 5;
+    #[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
+    #[cfg(unix)]
+    static mut FAULTHANDLER_HANDLERS: [FaultHandler; FAULTHANDLER_NSIGNALS] = [
+        FaultHandler::new(libc::SIGBUS, "Bus error"),
+        FaultHandler::new(libc::SIGILL, "Illegal instruction"),
+        FaultHandler::new(libc::SIGFPE, "Floating-point exception"),
+        FaultHandler::new(libc::SIGABRT, "Aborted"),
+        FaultHandler::new(libc::SIGSEGV, "Segmentation fault"),
+    ];
+
+    #[cfg(windows)]
+    static mut FAULTHANDLER_HANDLERS: [FaultHandler; FAULTHANDLER_NSIGNALS] = [
+        FaultHandler::new(libc::SIGILL, "Illegal instruction"),
+        FaultHandler::new(libc::SIGFPE, "Floating-point exception"),
+        FaultHandler::new(libc::SIGABRT, "Aborted"),
+        FaultHandler::new(libc::SIGSEGV, "Segmentation fault"),
+    ];
+
+    /// fatal_error state
+    struct FatalErrorState {
+        enabled: AtomicBool,
+        fd: AtomicI32,
+        all_threads: AtomicBool,
+    }
+
+    static FATAL_ERROR: FatalErrorState = FatalErrorState {
+        enabled: AtomicBool::new(false),
+        fd: AtomicI32::new(2), // stderr by default
+        all_threads: AtomicBool::new(true),
+    };
+
+    // Watchdog thread state for dump_traceback_later
+    struct WatchdogState {
+        cancel: bool,
+        fd: i32,
+        timeout_us: u64,
+        repeat: bool,
+        exit: bool,
+        header: String,
+    }
+
+    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,
+    }
+
+    #[cfg(any(unix, windows))]
+    impl FrameSnapshot {
+        const EMPTY: Self = Self {
+            filename: [0; 256],
+            filename_len: 0,
+            lineno: 0,
+            funcname: [0; 128],
+            funcname_len: 0,
+        };
+    }
+
+    #[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) {
+        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())
+            }
+        };
+    }
+
+    // _Py_DumpHexadecimal (traceback.c)
+    #[cfg(any(unix, windows))]
+    fn dump_hexadecimal(fd: i32, value: u64, width: usize) {
+        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
+        let mut buf = [0u8; 18]; // "0x" + 16 hex digits
+        buf[0] = b'0';
+        buf[1] = b'x';
+
+        for i in 0..width {
+            let digit = ((value >> (4 * (width - 1 - i))) & 0xf) as usize;
+            buf[2 + i] = HEX_CHARS[digit];
+        }
+
+        let _ = unsafe {
+            #[cfg(windows)]
+            {
+                libc::write(fd, buf.as_ptr() as *const libc::c_void, (2 + width) as u32)
+            }
+            #[cfg(not(windows))]
+            {
+                libc::write(fd, buf.as_ptr() as *const libc::c_void, 2 + width)
+            }
+        };
+    }
+
+    // _Py_DumpDecimal (traceback.c)
+    #[cfg(any(unix, windows))]
+    fn dump_decimal(fd: i32, value: usize) {
+        let mut buf = [0u8; 20];
+        let mut v = value;
+        let mut i = buf.len();
+
+        if v == 0 {
+            puts(fd, "0");
+            return;
+        }
+
+        while v > 0 {
+            i -= 1;
+            buf[i] = b'0' + (v % 10) as u8;
+            v /= 10;
+        }
+
+        let len = buf.len() - i;
+        let _ = unsafe {
+            #[cfg(windows)]
+            {
+                libc::write(fd, buf[i..].as_ptr() as *const libc::c_void, len as u32)
+            }
+            #[cfg(not(windows))]
+            {
+                libc::write(fd, buf[i..].as_ptr() as *const libc::c_void, len)
+            }
+        };
+    }
+
+    /// Get current thread ID
+    #[cfg(unix)]
+    fn current_thread_id() -> u64 {
+        unsafe { libc::pthread_self() as u64 }
+    }
+
+    #[cfg(windows)]
+    fn current_thread_id() -> u64 {
+        unsafe { windows_sys::Win32::System::Threading::GetCurrentThreadId() as u64 }
+    }
+
+    // write_thread_id (traceback.c:1240-1256)
+    #[cfg(any(unix, windows))]
+    fn write_thread_id(fd: i32, is_current: bool) {
+        if is_current {
+            puts(fd, "Current thread 0x");
+        } else {
+            puts(fd, "Thread 0x");
+        }
+        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)
+    #[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())
+            }
+        };
+        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())
+            }
+        };
+        puts(fd, "\n");
+    }
+
+    // faulthandler_dump_traceback
+    #[cfg(any(unix, windows))]
+    fn faulthandler_dump_traceback(fd: i32, _all_threads: bool) {
+        static REENTRANT: AtomicBool = AtomicBool::new(false);
+
+        if REENTRANT.swap(true, Ordering::SeqCst) {
+            return;
+        }
+
+        // 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],
+                        );
+                    }
+                }
+            }
+        } else {
+            puts(fd, "  <no Python frame>\n");
+        }
+
+        REENTRANT.store(false, Ordering::SeqCst);
+    }
+
+    const MAX_FUNCTION_NAME_LEN: 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()
+        }
+    }
+
+    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)
+            }
+        }
+    }
+
+    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)
+        } else {
+            frame.current_location().line.get()
+        };
+        format!(
+            "  File \"{}\", line {} in {}",
+            frame.code.source_path, line, func_name
+        )
+    }
+
+    #[derive(FromArgs)]
+    struct DumpTracebackArgs {
+        #[pyarg(any, default)]
+        file: OptionalArg<PyObjectRef>,
+        #[pyarg(any, default = true)]
+        all_threads: bool,
+    }
+
+    #[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)?;
+
+        // Collect frame info first to avoid RefCell borrow conflict
+        let frame_lines: Vec<String> = vm.frames.borrow().iter().map(collect_frame_info).collect();
+
+        // 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)?;
+        }
+        Ok(())
+    }
+
+    #[derive(FromArgs)]
+    #[allow(unused)]
+    struct EnableArgs {
+        #[pyarg(any, default)]
+        file: OptionalArg<PyObjectRef>,
+        #[pyarg(any, default = true)]
+        all_threads: bool,
+    }
+
+    // faulthandler_py_enable
+    #[pyfunction]
+    fn enable(args: EnableArgs, vm: &VirtualMachine) -> PyResult<()> {
+        // Get file descriptor
+        let fd = get_fd_from_file_opt(args.file, vm)?;
+
+        // Store fd and all_threads in global state
+        FATAL_ERROR.fd.store(fd, Ordering::Relaxed);
+        FATAL_ERROR
+            .all_threads
+            .store(args.all_threads, Ordering::Relaxed);
+
+        // Install signal handlers
+        if !faulthandler_enable_internal() {
+            return Err(vm.new_runtime_error("Failed to enable faulthandler".to_owned()));
+        }
+
+        Ok(())
+    }
+
+    // Signal handlers
+
+    /// faulthandler_disable_fatal_handler (faulthandler.c:310-321)
+    #[cfg(unix)]
+    unsafe fn faulthandler_disable_fatal_handler(handler: &mut FaultHandler) {
+        if !handler.enabled {
+            return;
+        }
+        handler.enabled = false;
+        unsafe {
+            libc::sigaction(handler.signum, &handler.previous, core::ptr::null_mut());
+        }
+    }
+
+    #[cfg(windows)]
+    unsafe fn faulthandler_disable_fatal_handler(handler: &mut FaultHandler) {
+        if !handler.enabled {
+            return;
+        }
+        handler.enabled = false;
+        unsafe {
+            libc::signal(handler.signum, handler.previous);
+        }
+    }
+
+    // faulthandler_fatal_error
+    #[cfg(unix)]
+    extern "C" fn faulthandler_fatal_error(signum: libc::c_int) {
+        let save_errno = get_errno();
+
+        if !FATAL_ERROR.enabled.load(Ordering::Relaxed) {
+            return;
+        }
+
+        let fd = FATAL_ERROR.fd.load(Ordering::Relaxed);
+
+        let handler = unsafe {
+            FAULTHANDLER_HANDLERS
+                .iter_mut()
+                .find(|h| h.signum == signum)
+        };
+
+        // faulthandler_fatal_error
+        if let Some(h) = handler {
+            // Disable handler first (restores previous)
+            unsafe {
+                faulthandler_disable_fatal_handler(h);
+            }
+
+            puts(fd, "Fatal Python error: ");
+            puts(fd, h.name);
+            puts(fd, "\n\n");
+        } else {
+            puts(fd, "Fatal Python error from unexpected signum: ");
+            dump_decimal(fd, signum as usize);
+            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
+        unsafe {
+            libc::raise(signum);
+        }
+    }
+
+    // faulthandler_fatal_error for Windows
+    #[cfg(windows)]
+    extern "C" fn faulthandler_fatal_error(signum: libc::c_int) {
+        let save_errno = get_errno();
+
+        if !FATAL_ERROR.enabled.load(Ordering::Relaxed) {
+            return;
+        }
+
+        let fd = FATAL_ERROR.fd.load(Ordering::Relaxed);
+
+        let handler = unsafe {
+            FAULTHANDLER_HANDLERS
+                .iter_mut()
+                .find(|h| h.signum == signum)
+        };
+
+        if let Some(h) = handler {
+            unsafe {
+                faulthandler_disable_fatal_handler(h);
+            }
+            puts(fd, "Fatal Python error: ");
+            puts(fd, h.name);
+            puts(fd, "\n\n");
+        } else {
+            puts(fd, "Fatal Python error from unexpected signum: ");
+            dump_decimal(fd, signum as usize);
+            puts(fd, "\n\n");
+        }
+
+        let all_threads = FATAL_ERROR.all_threads.load(Ordering::Relaxed);
+        faulthandler_dump_traceback(fd, all_threads);
+
+        set_errno(save_errno);
+
+        // On Windows, don't explicitly call the previous handler for SIGSEGV
+        if signum == libc::SIGSEGV {
+            return;
+        }
+
+        unsafe {
+            libc::raise(signum);
+        }
+    }
+
+    // faulthandler_enable
+    #[cfg(unix)]
+    fn faulthandler_enable_internal() -> bool {
+        if FATAL_ERROR.enabled.load(Ordering::Relaxed) {
+            return true;
+        }
+
+        unsafe {
+            for handler in FAULTHANDLER_HANDLERS.iter_mut() {
+                if handler.enabled {
+                    continue;
+                }
+
+                let mut action: libc::sigaction = core::mem::zeroed();
+                action.sa_sigaction = faulthandler_fatal_error as libc::sighandler_t;
+                // SA_NODEFER flag
+                action.sa_flags = libc::SA_NODEFER;
+
+                if libc::sigaction(handler.signum, &action, &mut handler.previous) != 0 {
+                    return false;
+                }
+
+                handler.enabled = true;
+            }
+        }
+
+        FATAL_ERROR.enabled.store(true, Ordering::Relaxed);
+        true
+    }
+
+    #[cfg(windows)]
+    fn faulthandler_enable_internal() -> bool {
+        if FATAL_ERROR.enabled.load(Ordering::Relaxed) {
+            return true;
+        }
+
+        unsafe {
+            for handler in FAULTHANDLER_HANDLERS.iter_mut() {
+                if handler.enabled {
+                    continue;
+                }
+
+                handler.previous = libc::signal(
+                    handler.signum,
+                    faulthandler_fatal_error as libc::sighandler_t,
+                );
+
+                // SIG_ERR is -1 as sighandler_t (which is usize on Windows)
+                if handler.previous == libc::SIG_ERR as libc::sighandler_t {
+                    return false;
+                }
+
+                handler.enabled = true;
+            }
+        }
+
+        FATAL_ERROR.enabled.store(true, Ordering::Relaxed);
+        true
+    }
+
+    // faulthandler_disable
+    #[cfg(any(unix, windows))]
+    fn faulthandler_disable_internal() {
+        if !FATAL_ERROR.enabled.swap(false, Ordering::Relaxed) {
+            return;
+        }
+
+        unsafe {
+            for handler in FAULTHANDLER_HANDLERS.iter_mut() {
+                faulthandler_disable_fatal_handler(handler);
+            }
+        }
+    }
+
+    #[cfg(not(any(unix, windows)))]
+    fn faulthandler_enable_internal() -> bool {
+        FATAL_ERROR.enabled.store(true, Ordering::Relaxed);
+        true
+    }
+
+    #[cfg(not(any(unix, windows)))]
+    fn faulthandler_disable_internal() {
+        FATAL_ERROR.enabled.store(false, Ordering::Relaxed);
+    }
+
+    // faulthandler_disable_py
+    #[pyfunction]
+    fn disable() -> bool {
+        let was_enabled = FATAL_ERROR.enabled.load(Ordering::Relaxed);
+        faulthandler_disable_internal();
+        was_enabled
+    }
+
+    // faulthandler_is_enabled
+    #[pyfunction]
+    fn is_enabled() -> bool {
+        FATAL_ERROR.enabled.load(Ordering::Relaxed)
+    }
+
+    fn format_timeout(timeout_us: u64) -> String {
+        let sec = timeout_us / 1_000_000;
+        let us = timeout_us % 1_000_000;
+        let min = sec / 60;
+        let sec = sec % 60;
+        let hour = min / 60;
+        let min = min % 60;
+
+        if us != 0 {
+            format!("Timeout ({:02}:{:02}:{:02}.{:06})!\n", hour, min, sec, us)
+        } else {
+            format!("Timeout ({:02}:{:02}:{:02})!\n", hour, min, sec)
+        }
+    }
+
+    fn get_fd_from_file_opt(file: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<i32> {
+        match file {
+            OptionalArg::Present(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 Ok(fd);
+                }
+                // Try to get fileno() from file object
+                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())
+                    );
+                }
+                // Try to flush the file
+                let _ = vm.call_method(&f, "flush", ());
+                Ok(fd)
+            }
+            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()));
+                }
+                let fileno = vm.call_method(&stderr, "fileno", ())?;
+                let fd: i32 = fileno.try_to_value(vm)?;
+                let _ = vm.call_method(&stderr, "flush", ());
+                Ok(fd)
+            }
+        }
+    }
+
+    fn watchdog_thread(state: WatchdogHandle) {
+        let (lock, cvar) = &*state;
+
+        loop {
+            // Hold lock across wait_timeout to avoid race condition
+            let mut guard = lock.lock();
+            if guard.cancel {
+                return;
+            }
+            let timeout = Duration::from_micros(guard.timeout_us);
+            cvar.wait_for(&mut guard, timeout);
+
+            // Check if cancelled after wait
+            if guard.cancel {
+                return;
+            }
+
+            // Extract values before releasing lock for I/O
+            let (repeat, exit, fd, header) =
+                (guard.repeat, guard.exit, guard.fd, guard.header.clone());
+            drop(guard); // Release lock before I/O
+
+            // Timeout occurred, dump traceback
+            #[cfg(target_arch = "wasm32")]
+            let _ = (exit, fd, &header);
+
+            #[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);
+                }
+                #[cfg(not(windows))]
+                unsafe {
+                    libc::write(fd, msg.as_ptr() as *const libc::c_void, msg.len());
+                }
+
+                if exit {
+                    std::process::exit(1);
+                }
+            }
+
+            if !repeat {
+                return;
+            }
+        }
+    }
+
+    #[derive(FromArgs)]
+    #[allow(unused)]
+    struct DumpTracebackLaterArgs {
+        #[pyarg(positional)]
+        timeout: PyObjectRef,
+        #[pyarg(any, default = false)]
+        repeat: bool,
+        #[pyarg(any, default)]
+        file: OptionalArg<PyObjectRef>,
+        #[pyarg(any, default = false)]
+        exit: bool,
+    }
+
+    #[pyfunction]
+    fn dump_traceback_later(args: DumpTracebackLaterArgs, vm: &VirtualMachine) -> PyResult<()> {
+        use num_traits::ToPrimitive;
+        // Convert timeout to f64 (accepting int or float)
+        let timeout: f64 = if let Some(float) = args.timeout.downcast_ref::<PyFloat>() {
+            float.to_f64()
+        } else if let Some(int) = args.timeout.try_index_opt(vm).transpose()? {
+            int.as_bigint()
+                .to_i64()
+                .ok_or_else(|| vm.new_overflow_error("timeout value is too large".to_owned()))?
+                as f64
+        } else {
+            return Err(vm.new_type_error("timeout must be a number (int or float)".to_owned()));
+        };
+
+        if timeout <= 0.0 {
+            return Err(vm.new_value_error("timeout must be greater than 0".to_owned()));
+        }
+
+        let fd = get_fd_from_file_opt(args.file, vm)?;
+
+        // 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()));
+        }
+
+        let header = format_timeout(timeout_us);
+
+        // Cancel any previous watchdog
+        cancel_dump_traceback_later();
+
+        // Create new watchdog state
+        let state = Arc::new((
+            Mutex::new(WatchdogState {
+                cancel: false,
+                fd,
+                timeout_us,
+                repeat: args.repeat,
+                exit: args.exit,
+                header,
+            }),
+            Condvar::new(),
+        ));
+
+        // Store the state
+        {
+            let mut watchdog = WATCHDOG.lock();
+            *watchdog = Some(Arc::clone(&state));
+        }
+
+        // Start watchdog thread
+        thread::spawn(move || {
+            watchdog_thread(state);
+        });
+
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn cancel_dump_traceback_later() {
+        let state = {
+            let mut watchdog = WATCHDOG.lock();
+            watchdog.take()
+        };
+
+        if let Some(state) = state {
+            let (lock, cvar) = &*state;
+            {
+                let mut guard = lock.lock();
+                guard.cancel = true;
+            }
+            cvar.notify_all();
+        }
+    }
+
+    #[cfg(unix)]
+    mod user_signals {
+        use parking_lot::Mutex;
+
+        const NSIG: usize = 64;
+
+        #[derive(Clone)]
+        pub struct UserSignal {
+            pub enabled: bool,
+            pub fd: i32,
+            #[allow(dead_code)]
+            pub all_threads: bool,
+            pub chain: bool,
+            pub previous: libc::sighandler_t,
+        }
+
+        impl Default for UserSignal {
+            fn default() -> Self {
+                Self {
+                    enabled: false,
+                    fd: 2, // stderr
+                    all_threads: true,
+                    chain: false,
+                    previous: libc::SIG_DFL,
+                }
+            }
+        }
+
+        static USER_SIGNALS: Mutex<Option<Vec<UserSignal>>> = Mutex::new(None);
+
+        pub fn get_user_signal(signum: usize) -> Option<UserSignal> {
+            let guard = USER_SIGNALS.lock();
+            guard.as_ref().and_then(|v| v.get(signum).cloned())
+        }
+
+        pub fn set_user_signal(signum: usize, signal: UserSignal) {
+            let mut guard = USER_SIGNALS.lock();
+            if guard.is_none() {
+                *guard = Some(vec![UserSignal::default(); NSIG]);
+            }
+            if let Some(ref mut v) = *guard
+                && signum < v.len()
+            {
+                v[signum] = signal;
+            }
+        }
+
+        pub fn clear_user_signal(signum: usize) -> Option<UserSignal> {
+            let mut guard = USER_SIGNALS.lock();
+            if let Some(ref mut v) = *guard
+                && signum < v.len()
+                && v[signum].enabled
+            {
+                let old = v[signum].clone();
+                v[signum] = UserSignal::default();
+                return Some(old);
+            }
+            None
+        }
+
+        pub fn is_enabled(signum: usize) -> bool {
+            let guard = USER_SIGNALS.lock();
+            guard
+                .as_ref()
+                .and_then(|v| v.get(signum))
+                .is_some_and(|s| s.enabled)
+        }
+    }
+
+    #[cfg(unix)]
+    extern "C" fn faulthandler_user_signal(signum: libc::c_int) {
+        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()) };
+
+        // 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
+            unsafe {
+                libc::signal(signum, user.previous);
+                libc::raise(signum);
+                // Re-register our handler
+                libc::signal(signum, faulthandler_user_signal as libc::sighandler_t);
+            }
+        }
+    }
+
+    #[cfg(unix)]
+    fn check_signum(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
+        // Check if it's a fatal signal (faulthandler.c uses faulthandler_handlers array)
+        let is_fatal = unsafe { FAULTHANDLER_HANDLERS.iter().any(|h| h.signum == signum) };
+        if is_fatal {
+            return Err(vm.new_runtime_error(format!(
+                "signal {} cannot be registered, use enable() instead",
+                signum
+            )));
+        }
+
+        // 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()));
+        }
+
+        Ok(())
+    }
+
+    #[cfg(unix)]
+    #[derive(FromArgs)]
+    #[allow(unused)]
+    struct RegisterArgs {
+        #[pyarg(positional)]
+        signum: i32,
+        #[pyarg(any, default)]
+        file: OptionalArg<PyObjectRef>,
+        #[pyarg(any, default = true)]
+        all_threads: bool,
+        #[pyarg(any, default = false)]
+        chain: bool,
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn register(args: RegisterArgs, vm: &VirtualMachine) -> PyResult<()> {
+        check_signum(args.signum, vm)?;
+
+        let fd = get_fd_from_file_opt(args.file, vm)?;
+
+        let signum = args.signum as usize;
+
+        // 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 libc::sighandler_t)
+            };
+            if prev == libc::SIG_ERR {
+                return Err(vm.new_os_error(format!(
+                    "Failed to register signal handler for signal {}",
+                    args.signum
+                )));
+            }
+            prev
+        } else {
+            // Already registered, keep previous handler
+            user_signals::get_user_signal(signum)
+                .map(|u| u.previous)
+                .unwrap_or(libc::SIG_DFL)
+        };
+
+        user_signals::set_user_signal(
+            signum,
+            user_signals::UserSignal {
+                enabled: true,
+                fd,
+                all_threads: args.all_threads,
+                chain: args.chain,
+                previous,
+            },
+        );
+
+        Ok(())
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn unregister(signum: i32, vm: &VirtualMachine) -> PyResult<bool> {
+        check_signum(signum, vm)?;
+
+        if let Some(old) = user_signals::clear_user_signal(signum as usize) {
+            // Restore previous handler
+            unsafe {
+                libc::signal(signum, old.previous);
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    // Test functions for faulthandler testing
+
+    #[pyfunction]
+    fn _read_null() {
+        // This function intentionally causes a segmentation fault by reading from NULL
+        // Used for testing faulthandler
+        #[cfg(not(target_arch = "wasm32"))]
+        unsafe {
+            suppress_crash_report();
+            let ptr: *const i32 = core::ptr::null();
+            core::ptr::read_volatile(ptr);
+        }
+    }
+
+    #[derive(FromArgs)]
+    #[allow(dead_code)]
+    struct SigsegvArgs {
+        #[pyarg(any, default = false)]
+        release_gil: bool,
+    }
+
+    #[pyfunction]
+    fn _sigsegv(_args: SigsegvArgs) {
+        // Raise SIGSEGV signal
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            suppress_crash_report();
+
+            // Reset SIGSEGV to default behavior before raising
+            // This ensures the process will actually crash
+            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);
+            }
+        }
+    }
+
+    #[pyfunction]
+    fn _sigabrt() {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            suppress_crash_report();
+            unsafe {
+                libc::abort();
+            }
+        }
+    }
+
+    #[pyfunction]
+    fn _sigfpe() {
+        #[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);
+            }
+        }
+    }
+
+    #[pyfunction]
+    fn _fatal_error_c_thread() {
+        // This would call Py_FatalError in a new C thread
+        // For RustPython, we just panic in a new thread
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            suppress_crash_report();
+            std::thread::spawn(|| {
+                panic!("Fatal Python error: in new thread");
+            });
+            // Wait a bit for the thread to panic
+            std::thread::sleep(core::time::Duration::from_secs(1));
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn suppress_crash_report() {
+        #[cfg(windows)]
+        {
+            use windows_sys::Win32::System::Diagnostics::Debug::{
+                SEM_NOGPFAULTERRORBOX, SetErrorMode,
+            };
+            unsafe {
+                let mode = SetErrorMode(SEM_NOGPFAULTERRORBOX);
+                SetErrorMode(mode | SEM_NOGPFAULTERRORBOX);
+            }
+        }
+
+        #[cfg(unix)]
+        {
+            // Disable core dumps
+            #[cfg(not(any(target_os = "redox", target_os = "wasi")))]
+            {
+                use libc::{RLIMIT_CORE, rlimit, setrlimit};
+                let rl = rlimit {
+                    rlim_cur: 0,
+                    rlim_max: 0,
+                };
+                unsafe {
+                    let _ = setrlimit(RLIMIT_CORE, &rl);
+                }
+            }
+        }
+    }
+
+    // Windows-specific constants
+    #[cfg(windows)]
+    #[pyattr]
+    const _EXCEPTION_ACCESS_VIOLATION: u32 = 0xC0000005;
+
+    #[cfg(windows)]
+    #[pyattr]
+    const _EXCEPTION_INT_DIVIDE_BY_ZERO: u32 = 0xC0000094;
+
+    #[cfg(windows)]
+    #[pyattr]
+    const _EXCEPTION_STACK_OVERFLOW: u32 = 0xC00000FD;
+
+    #[cfg(windows)]
+    #[pyattr]
+    const _EXCEPTION_NONCONTINUABLE: u32 = 0x00000001;
+
+    #[cfg(windows)]
+    #[pyattr]
+    const _EXCEPTION_NONCONTINUABLE_EXCEPTION: u32 = 0xC0000025;
+
+    #[cfg(windows)]
+    #[derive(FromArgs)]
+    struct RaiseExceptionArgs {
+        #[pyarg(positional)]
+        code: u32,
+        #[pyarg(positional, default = 0)]
+        flags: u32,
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn _raise_exception(args: RaiseExceptionArgs) {
+        use windows_sys::Win32::System::Diagnostics::Debug::RaiseException;
+
+        suppress_crash_report();
+        unsafe {
+            RaiseException(args.code, args.flags, 0, core::ptr::null());
+        }
+    }
+}
diff --git a/stdlib/src/fcntl.rs b/crates/stdlib/src/fcntl.rs
similarity index 90%
rename from stdlib/src/fcntl.rs
rename to crates/stdlib/src/fcntl.rs
index 84b60b43ba..477c1f5421 100644
--- a/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, os},
+        stdlib::io,
     };
 
     // TODO: supply these from <asm-generic/fnctl.h> (please file an issue/PR upstream):
@@ -75,7 +75,7 @@ mod fcntl {
                 }
                 let ret = unsafe { libc::fcntl(fd, cmd, buf.as_mut_ptr()) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 return Ok(vm.ctx.new_bytes(buf[..arg_len].to_vec()).into());
             }
@@ -84,7 +84,7 @@ mod fcntl {
         };
         let ret = unsafe { libc::fcntl(fd, cmd, int as i32) };
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.new_pyobj(ret))
     }
@@ -92,11 +92,15 @@ mod fcntl {
     #[pyfunction]
     fn ioctl(
         io::Fildes(fd): io::Fildes,
-        request: u32,
+        request: i64,
         arg: OptionalArg<Either<Either<ArgMemoryBuffer, ArgStrOrBytesLike>, i32>>,
         mutate_flag: OptionalArg<bool>,
         vm: &VirtualMachine,
     ) -> PyResult {
+        // Convert to unsigned - handles both positive u32 values and negative i32 values
+        // that represent the same bit pattern (e.g., TIOCSWINSZ on some platforms).
+        // First truncate to u32 (takes lower 32 bits), then zero-extend to c_ulong.
+        let request = (request as u32) as libc::c_ulong;
         let arg = arg.unwrap_or_else(|| Either::B(0));
         match arg {
             Either::A(buf_kind) => {
@@ -117,7 +121,7 @@ mod fcntl {
                             let ret =
                                 unsafe { libc::ioctl(fd, request as _, arg_buf.as_mut_ptr()) };
                             if ret < 0 {
-                                return Err(os::errno_err(vm));
+                                return Err(vm.new_last_errno_error());
                             }
                             return Ok(vm.ctx.new_int(ret).into());
                         }
@@ -128,14 +132,14 @@ mod fcntl {
                 };
                 let ret = unsafe { libc::ioctl(fd, request as _, buf.as_mut_ptr()) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 Ok(vm.ctx.new_bytes(buf[..buf_len].to_vec()).into())
             }
             Either::B(i) => {
                 let ret = unsafe { libc::ioctl(fd, request as _, i) };
                 if ret < 0 {
-                    return Err(os::errno_err(vm));
+                    return Err(vm.new_last_errno_error());
                 }
                 Ok(vm.ctx.new_int(ret).into())
             }
@@ -149,7 +153,7 @@ mod fcntl {
         let ret = unsafe { libc::flock(fd, operation) };
         // TODO: add support for platforms that don't have a builtin `flock` syscall
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.ctx.new_int(ret).into())
     }
@@ -173,7 +177,7 @@ mod fcntl {
             };
         }
 
-        let mut l: libc::flock = unsafe { std::mem::zeroed() };
+        let mut l: libc::flock = unsafe { core::mem::zeroed() };
         l.l_type = if cmd == libc::LOCK_UN {
             try_into_l_type!(libc::F_UNLCK)
         } else if (cmd & libc::LOCK_SH) != 0 {
@@ -209,7 +213,7 @@ mod fcntl {
             )
         };
         if ret < 0 {
-            return Err(os::errno_err(vm));
+            return Err(vm.new_last_errno_error());
         }
         Ok(vm.ctx.new_int(ret).into())
     }
diff --git a/stdlib/src/gc.rs b/crates/stdlib/src/gc.rs
similarity index 100%
rename from stdlib/src/gc.rs
rename to crates/stdlib/src/gc.rs
diff --git a/stdlib/src/grp.rs b/crates/stdlib/src/grp.rs
similarity index 84%
rename from stdlib/src/grp.rs
rename to crates/stdlib/src/grp.rs
index b640494c13..9f7e419550 100644
--- a/stdlib/src/grp.rs
+++ b/crates/stdlib/src/grp.rs
@@ -10,29 +10,31 @@ mod grp {
         exceptions,
         types::PyStructSequence,
     };
+    use core::ptr::NonNull;
     use nix::unistd;
-    use std::ptr::NonNull;
 
-    #[pyattr]
-    #[pyclass(module = "grp", name = "struct_group", traverse)]
-    #[derive(PyStructSequence)]
-    struct Group {
-        #[pytraverse(skip)]
+    #[pystruct_sequence_data]
+    struct GroupData {
         gr_name: String,
-        #[pytraverse(skip)]
         gr_passwd: String,
-        #[pytraverse(skip)]
         gr_gid: u32,
         gr_mem: PyListRef,
     }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "struct_group", module = "grp", data = "GroupData")]
+    struct PyGroup;
+
     #[pyclass(with(PyStructSequence))]
-    impl Group {
+    impl PyGroup {}
+
+    impl GroupData {
         fn from_unistd_group(group: unistd::Group, vm: &VirtualMachine) -> Self {
-            let cstr_lossy = |s: std::ffi::CString| {
+            let cstr_lossy = |s: alloc::ffi::CString| {
                 s.into_string()
                     .unwrap_or_else(|e| e.into_cstring().to_string_lossy().into_owned())
             };
-            Group {
+            GroupData {
                 gr_name: group.name,
                 gr_passwd: cstr_lossy(group.passwd),
                 gr_gid: group.gid.as_raw(),
@@ -44,7 +46,7 @@ mod grp {
     }
 
     #[pyfunction]
-    fn getgrgid(gid: PyIntRef, vm: &VirtualMachine) -> PyResult<Group> {
+    fn getgrgid(gid: PyIntRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_gid = gid.as_bigint();
         let gid = libc::gid_t::try_from(gr_gid)
             .map(unistd::Gid::from_raw)
@@ -61,11 +63,11 @@ mod grp {
                     .into(),
             )
         })?;
-        Ok(Group::from_unistd_group(group, vm))
+        Ok(GroupData::from_unistd_group(group, vm))
     }
 
     #[pyfunction]
-    fn getgrnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<Group> {
+    fn getgrnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_name = name.as_str();
         if gr_name.contains('\0') {
             return Err(exceptions::cstring_error(vm));
@@ -78,7 +80,7 @@ mod grp {
                     .into(),
             )
         })?;
-        Ok(Group::from_unistd_group(group, vm))
+        Ok(GroupData::from_unistd_group(group, vm))
     }
 
     #[pyfunction]
@@ -91,7 +93,7 @@ mod grp {
         unsafe { libc::setgrent() };
         while let Some(ptr) = NonNull::new(unsafe { libc::getgrent() }) {
             let group = unistd::Group::from(unsafe { ptr.as_ref() });
-            let group = Group::from_unistd_group(group, vm).to_pyobject(vm);
+            let group = GroupData::from_unistd_group(group, vm).to_pyobject(vm);
             list.push(group);
         }
         unsafe { libc::endgrent() };
diff --git a/stdlib/src/hashlib.rs b/crates/stdlib/src/hashlib.rs
similarity index 92%
rename from stdlib/src/hashlib.rs
rename to crates/stdlib/src/hashlib.rs
index e7b03a2ff1..2da47ceb74 100644
--- a/stdlib/src/hashlib.rs
+++ b/crates/stdlib/src/hashlib.rs
@@ -7,11 +7,11 @@ pub mod _hashlib {
     use crate::common::lock::PyRwLock;
     use crate::vm::{
         Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBytes, PyStrRef, PyTypeRef},
+        builtins::{PyBytes, PyStrRef, PyTypeRef, PyValueError},
+        class::StaticType,
         convert::ToPyObject,
         function::{ArgBytesLike, ArgStrOrBytesLike, FuncArgs, OptionalArg},
-        protocol::PyBuffer,
-        types::Representable,
+        types::{Constructor, Initializer, Representable},
     };
     use blake2::{Blake2b512, Blake2s256};
     use digest::{DynDigest, core_api::BlockSizeUser};
@@ -22,6 +22,12 @@ pub mod _hashlib {
     use sha2::{Sha224, Sha256, Sha384, Sha512};
     use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
 
+    #[pyattr]
+    #[pyexception(name = "UnsupportedDigestmodError", base = PyValueError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct UnsupportedDigestmodError(PyValueError);
+
     #[derive(FromArgs, Debug)]
     #[allow(unused)]
     struct NewHashArgs {
@@ -91,8 +97,8 @@ pub mod _hashlib {
         pub ctx: PyRwLock<HashWrapper>,
     }
 
-    impl std::fmt::Debug for PyHasher {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for PyHasher {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "HASH {}", self.name)
         }
     }
@@ -164,8 +170,8 @@ pub mod _hashlib {
         ctx: PyRwLock<HashXofWrapper>,
     }
 
-    impl std::fmt::Debug for PyHasherXof {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for PyHasherXof {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "HASHXOF {}", self.name)
         }
     }
@@ -338,16 +344,21 @@ pub mod _hashlib {
     #[allow(unused)]
     pub struct NewHMACHashArgs {
         #[pyarg(positional)]
-        name: PyBuffer,
+        key: ArgBytesLike,
         #[pyarg(any, optional)]
-        data: OptionalArg<ArgBytesLike>,
-        #[pyarg(named, default = true)]
-        digestmod: bool, // TODO: RUSTPYTHON support functions & name functions
+        msg: OptionalArg<ArgBytesLike>,
+        #[pyarg(named, optional)]
+        digestmod: OptionalArg<PyObjectRef>,
     }
 
     #[pyfunction]
-    fn hmac_new(_args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        Err(vm.new_type_error("cannot create 'hmac' instances")) // TODO: RUSTPYTHON support hmac
+    fn hmac_new(args: NewHMACHashArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Raise UnsupportedDigestmodError so Python's hmac.py falls back to pure-Python implementation
+        let _ = args;
+        Err(vm.new_exception_msg(
+            UnsupportedDigestmodError::static_type().to_owned(),
+            "unsupported hash type".to_owned(),
+        ))
     }
 
     pub trait ThreadSafeDynDigest: DynClone + DynDigest + Sync + Send {}
diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
new file mode 100644
index 0000000000..4bdf453353
--- /dev/null
+++ b/crates/stdlib/src/json.rs
@@ -0,0 +1,733 @@
+pub(crate) use _json::make_module;
+mod machinery;
+
+#[pymodule]
+mod _json {
+    use super::machinery;
+    use crate::vm::{
+        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyStrRef, PyType},
+        convert::ToPyResult,
+        function::{IntoFuncArgs, OptionalArg},
+        protocol::PyIterReturn,
+        types::{Callable, Constructor},
+    };
+    use core::str::FromStr;
+    use malachite_bigint::BigInt;
+    use rustpython_common::wtf8::Wtf8Buf;
+    use std::collections::HashMap;
+
+    /// Skip JSON whitespace characters (space, tab, newline, carriage return).
+    /// Works with a byte slice and returns the number of bytes skipped.
+    /// Since all JSON whitespace chars are ASCII, bytes == chars.
+    #[inline]
+    fn skip_whitespace(bytes: &[u8]) -> usize {
+        flame_guard!("_json::skip_whitespace");
+        let mut count = 0;
+        for &b in bytes {
+            match b {
+                b' ' | b'\t' | b'\n' | b'\r' => count += 1,
+                _ => break,
+            }
+        }
+        count
+    }
+
+    /// Check if a byte slice starts with a given ASCII pattern.
+    #[inline]
+    fn starts_with_bytes(bytes: &[u8], pattern: &[u8]) -> bool {
+        bytes.len() >= pattern.len() && &bytes[..pattern.len()] == pattern
+    }
+
+    #[pyattr(name = "make_scanner")]
+    #[pyclass(name = "Scanner", traverse)]
+    #[derive(Debug, PyPayload)]
+    struct JsonScanner {
+        #[pytraverse(skip)]
+        strict: bool,
+        object_hook: Option<PyObjectRef>,
+        object_pairs_hook: Option<PyObjectRef>,
+        parse_float: Option<PyObjectRef>,
+        parse_int: Option<PyObjectRef>,
+        parse_constant: PyObjectRef,
+        ctx: PyObjectRef,
+    }
+
+    impl Constructor for JsonScanner {
+        type Args = PyObjectRef;
+
+        fn py_new(_cls: &Py<PyType>, ctx: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            let strict = ctx.get_attr("strict", vm)?.try_to_bool(vm)?;
+            let object_hook = vm.option_if_none(ctx.get_attr("object_hook", vm)?);
+            let object_pairs_hook = vm.option_if_none(ctx.get_attr("object_pairs_hook", vm)?);
+            let parse_float = ctx.get_attr("parse_float", vm)?;
+            let parse_float = if vm.is_none(&parse_float) || parse_float.is(vm.ctx.types.float_type)
+            {
+                None
+            } else {
+                Some(parse_float)
+            };
+            let parse_int = ctx.get_attr("parse_int", vm)?;
+            let parse_int = if vm.is_none(&parse_int) || parse_int.is(vm.ctx.types.int_type) {
+                None
+            } else {
+                Some(parse_int)
+            };
+            let parse_constant = ctx.get_attr("parse_constant", vm)?;
+
+            Ok(Self {
+                strict,
+                object_hook,
+                object_pairs_hook,
+                parse_float,
+                parse_int,
+                parse_constant,
+                ctx,
+            })
+        }
+    }
+
+    #[pyclass(with(Callable, Constructor))]
+    impl JsonScanner {
+        fn parse(
+            &self,
+            pystr: PyStrRef,
+            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 wtf8 = pystr.as_wtf8();
+
+            let first_byte = match bytes.get(byte_idx) {
+                Some(&b) => b,
+                None => {
+                    return Ok(PyIterReturn::StopIteration(Some(
+                        vm.ctx.new_int(char_idx).into(),
+                    )));
+                }
+            };
+
+            match first_byte {
+                b'"' => {
+                    // Parse string - pass slice starting after the quote
+                    let (wtf8_result, chars_consumed, _bytes_consumed) =
+                        machinery::scanstring(&wtf8[byte_idx + 1..], char_idx + 1, self.strict)
+                            .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+                    let end_char_idx = char_idx + 1 + chars_consumed;
+                    return Ok(PyIterReturn::Return(
+                        vm.new_tuple((wtf8_result, end_char_idx)).into(),
+                    ));
+                }
+                b'{' => {
+                    // Parse object in Rust
+                    let mut memo = HashMap::new();
+                    return self
+                        .parse_object(pystr, char_idx + 1, byte_idx + 1, &scan_once, &mut memo, vm)
+                        .map(|(obj, end_char, _end_byte)| {
+                            PyIterReturn::Return(vm.new_tuple((obj, end_char)).into())
+                        });
+                }
+                b'[' => {
+                    // Parse array in Rust
+                    let mut memo = HashMap::new();
+                    return self
+                        .parse_array(pystr, char_idx + 1, byte_idx + 1, &scan_once, &mut memo, vm)
+                        .map(|(obj, end_char, _end_byte)| {
+                            PyIterReturn::Return(vm.new_tuple((obj, end_char)).into())
+                        });
+                }
+                _ => {}
+            }
+
+            let s = &pystr.as_str()[byte_idx..];
+
+            macro_rules! parse_const {
+                ($s:literal, $val:expr) => {
+                    if s.starts_with($s) {
+                        return Ok(PyIterReturn::Return(
+                            vm.new_tuple(($val, char_idx + $s.len())).into(),
+                        ));
+                    }
+                };
+            }
+
+            parse_const!("null", vm.ctx.none());
+            parse_const!("true", true);
+            parse_const!("false", false);
+
+            if let Some((res, len)) = self.parse_number(s, vm) {
+                return Ok(PyIterReturn::Return(
+                    vm.new_tuple((res?, char_idx + len)).into(),
+                ));
+            }
+
+            macro_rules! parse_constant {
+                ($s:literal) => {
+                    if s.starts_with($s) {
+                        return Ok(PyIterReturn::Return(
+                            vm.new_tuple((
+                                self.parse_constant.call(($s,), vm)?,
+                                char_idx + $s.len(),
+                            ))
+                            .into(),
+                        ));
+                    }
+                };
+            }
+
+            parse_constant!("NaN");
+            parse_constant!("Infinity");
+            parse_constant!("-Infinity");
+
+            Ok(PyIterReturn::StopIteration(Some(
+                vm.ctx.new_int(char_idx).into(),
+            )))
+        }
+
+        fn parse_number(&self, s: &str, vm: &VirtualMachine) -> Option<(PyResult, usize)> {
+            flame_guard!("JsonScanner::parse_number");
+            let mut has_neg = false;
+            let mut has_decimal = false;
+            let mut has_exponent = false;
+            let mut has_e_sign = false;
+            let mut i = 0;
+            for c in s.chars() {
+                match c {
+                    '-' if i == 0 => has_neg = true,
+                    n if n.is_ascii_digit() => {}
+                    '.' if !has_decimal => has_decimal = true,
+                    'e' | 'E' if !has_exponent => has_exponent = true,
+                    '+' | '-' if !has_e_sign => has_e_sign = true,
+                    _ => break,
+                }
+                i += 1;
+            }
+            if i == 0 || (i == 1 && has_neg) {
+                return None;
+            }
+            let buf = &s[..i];
+            let ret = if has_decimal || has_exponent {
+                // float
+                if let Some(ref parse_float) = self.parse_float {
+                    parse_float.call((buf,), vm)
+                } else {
+                    Ok(vm.ctx.new_float(f64::from_str(buf).unwrap()).into())
+                }
+            } else if let Some(ref parse_int) = self.parse_int {
+                parse_int.call((buf,), vm)
+            } else {
+                Ok(vm.new_pyobj(BigInt::from_str(buf).unwrap()))
+            };
+            Some((ret, buf.len()))
+        }
+
+        /// Parse a JSON object starting after the opening '{'.
+        /// Returns (parsed_object, end_char_index, end_byte_index).
+        fn parse_object(
+            &self,
+            pystr: PyStrRef,
+            start_char_idx: usize,
+            start_byte_idx: usize,
+            scan_once: &PyObjectRef,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            flame_guard!("JsonScanner::parse_object");
+
+            let bytes = pystr.as_str().as_bytes();
+            let wtf8 = pystr.as_wtf8();
+            let mut char_idx = start_char_idx;
+            let mut byte_idx = start_byte_idx;
+
+            // Skip initial whitespace
+            let ws = skip_whitespace(&bytes[byte_idx..]);
+            char_idx += ws;
+            byte_idx += ws;
+
+            // Check for empty object
+            match bytes.get(byte_idx) {
+                Some(b'}') => {
+                    return self.finalize_object(vec![], char_idx + 1, byte_idx + 1, vm);
+                }
+                Some(b'"') => {
+                    // Continue to parse first key
+                }
+                _ => {
+                    return Err(self.make_decode_error(
+                        "Expecting property name enclosed in double quotes",
+                        pystr,
+                        char_idx,
+                        vm,
+                    ));
+                }
+            }
+
+            let mut pairs: Vec<(PyObjectRef, PyObjectRef)> = Vec::new();
+
+            loop {
+                // We're now at '"', skip it
+                char_idx += 1;
+                byte_idx += 1;
+
+                // Parse key string using scanstring with byte slice
+                let (key_wtf8, chars_consumed, bytes_consumed) =
+                    machinery::scanstring(&wtf8[byte_idx..], char_idx, self.strict)
+                        .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+
+                char_idx += chars_consumed;
+                byte_idx += bytes_consumed;
+
+                // Key memoization - reuse existing key strings
+                let key_str = key_wtf8.to_string();
+                let key: PyObjectRef = match memo.get(&key_str) {
+                    Some(cached) => cached.clone().into(),
+                    None => {
+                        let py_key = vm.ctx.new_str(key_str.clone());
+                        memo.insert(key_str, py_key.clone());
+                        py_key.into()
+                    }
+                };
+
+                // Skip whitespace after key
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Expect ':' delimiter
+                match bytes.get(byte_idx) {
+                    Some(b':') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ':' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+
+                // Skip whitespace after ':'
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Parse value recursively
+                let (value, value_char_end, value_byte_end) =
+                    self.call_scan_once(scan_once, pystr.clone(), char_idx, byte_idx, memo, vm)?;
+
+                pairs.push((key, value));
+                char_idx = value_char_end;
+                byte_idx = value_byte_end;
+
+                // Skip whitespace after value
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                // Check for ',' or '}'
+                match bytes.get(byte_idx) {
+                    Some(b'}') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                        break;
+                    }
+                    Some(b',') => {
+                        let comma_char_idx = char_idx;
+                        char_idx += 1;
+                        byte_idx += 1;
+
+                        // Skip whitespace after comma
+                        let ws = skip_whitespace(&bytes[byte_idx..]);
+                        char_idx += ws;
+                        byte_idx += ws;
+
+                        // Next must be '"'
+                        match bytes.get(byte_idx) {
+                            Some(b'"') => {
+                                // Continue to next key-value pair
+                            }
+                            Some(b'}') => {
+                                // Trailing comma before end of object
+                                return Err(self.make_decode_error(
+                                    "Illegal trailing comma before end of object",
+                                    pystr,
+                                    comma_char_idx,
+                                    vm,
+                                ));
+                            }
+                            _ => {
+                                return Err(self.make_decode_error(
+                                    "Expecting property name enclosed in double quotes",
+                                    pystr,
+                                    char_idx,
+                                    vm,
+                                ));
+                            }
+                        }
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ',' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+            }
+
+            self.finalize_object(pairs, char_idx, byte_idx, vm)
+        }
+
+        /// Parse a JSON array starting after the opening '['.
+        /// Returns (parsed_array, end_char_index, end_byte_index).
+        fn parse_array(
+            &self,
+            pystr: PyStrRef,
+            start_char_idx: usize,
+            start_byte_idx: usize,
+            scan_once: &PyObjectRef,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            flame_guard!("JsonScanner::parse_array");
+
+            let bytes = pystr.as_str().as_bytes();
+            let mut char_idx = start_char_idx;
+            let mut byte_idx = start_byte_idx;
+
+            // Skip initial whitespace
+            let ws = skip_whitespace(&bytes[byte_idx..]);
+            char_idx += ws;
+            byte_idx += ws;
+
+            // Check for empty array
+            if bytes.get(byte_idx) == Some(&b']') {
+                return Ok((vm.ctx.new_list(vec![]).into(), char_idx + 1, byte_idx + 1));
+            }
+
+            let mut values: Vec<PyObjectRef> = Vec::new();
+
+            loop {
+                // Parse value
+                let (value, value_char_end, value_byte_end) =
+                    self.call_scan_once(scan_once, pystr.clone(), char_idx, byte_idx, memo, vm)?;
+
+                values.push(value);
+                char_idx = value_char_end;
+                byte_idx = value_byte_end;
+
+                // Skip whitespace after value
+                let ws = skip_whitespace(&bytes[byte_idx..]);
+                char_idx += ws;
+                byte_idx += ws;
+
+                match bytes.get(byte_idx) {
+                    Some(b']') => {
+                        char_idx += 1;
+                        byte_idx += 1;
+                        break;
+                    }
+                    Some(b',') => {
+                        let comma_char_idx = char_idx;
+                        char_idx += 1;
+                        byte_idx += 1;
+
+                        // Skip whitespace after comma
+                        let ws = skip_whitespace(&bytes[byte_idx..]);
+                        char_idx += ws;
+                        byte_idx += ws;
+
+                        // Check for trailing comma
+                        if bytes.get(byte_idx) == Some(&b']') {
+                            return Err(self.make_decode_error(
+                                "Illegal trailing comma before end of array",
+                                pystr,
+                                comma_char_idx,
+                                vm,
+                            ));
+                        }
+                    }
+                    _ => {
+                        return Err(self.make_decode_error(
+                            "Expecting ',' delimiter",
+                            pystr,
+                            char_idx,
+                            vm,
+                        ));
+                    }
+                }
+            }
+
+            Ok((vm.ctx.new_list(values).into(), char_idx, byte_idx))
+        }
+
+        /// Finalize object construction with hooks.
+        fn finalize_object(
+            &self,
+            pairs: Vec<(PyObjectRef, PyObjectRef)>,
+            end_char_idx: usize,
+            end_byte_idx: usize,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            let result = if let Some(ref pairs_hook) = self.object_pairs_hook {
+                // object_pairs_hook takes priority - pass list of tuples
+                let pairs_list: Vec<PyObjectRef> = pairs
+                    .into_iter()
+                    .map(|(k, v)| vm.new_tuple((k, v)).into())
+                    .collect();
+                pairs_hook.call((vm.ctx.new_list(pairs_list),), vm)?
+            } else {
+                // Build a dict from pairs
+                let dict = vm.ctx.new_dict();
+                for (key, value) in pairs {
+                    dict.set_item(&*key, value, vm)?;
+                }
+
+                // Apply object_hook if present
+                let dict_obj: PyObjectRef = dict.into();
+                if let Some(ref hook) = self.object_hook {
+                    hook.call((dict_obj,), vm)?
+                } else {
+                    dict_obj
+                }
+            };
+
+            Ok((result, end_char_idx, end_byte_idx))
+        }
+
+        /// Call scan_once and handle the result.
+        /// Returns (value, end_char_idx, end_byte_idx).
+        fn call_scan_once(
+            &self,
+            scan_once: &PyObjectRef,
+            pystr: PyStrRef,
+            char_idx: usize,
+            byte_idx: usize,
+            memo: &mut HashMap<String, PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(PyObjectRef, usize, usize)> {
+            let s = pystr.as_str();
+            let bytes = s.as_bytes();
+            let wtf8 = pystr.as_wtf8();
+
+            let first_byte = match bytes.get(byte_idx) {
+                Some(&b) => b,
+                None => return Err(self.make_decode_error("Expecting value", pystr, char_idx, vm)),
+            };
+
+            match first_byte {
+                b'"' => {
+                    // String - pass slice starting after the quote
+                    let (wtf8_result, chars_consumed, bytes_consumed) =
+                        machinery::scanstring(&wtf8[byte_idx + 1..], char_idx + 1, self.strict)
+                            .map_err(|e| py_decode_error(e, pystr.clone(), vm))?;
+                    let py_str = vm.ctx.new_str(wtf8_result.to_string());
+                    Ok((
+                        py_str.into(),
+                        char_idx + 1 + chars_consumed,
+                        byte_idx + 1 + bytes_consumed,
+                    ))
+                }
+                b'{' => {
+                    // Object
+                    self.parse_object(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
+                }
+                b'[' => {
+                    // Array
+                    self.parse_array(pystr, char_idx + 1, byte_idx + 1, scan_once, memo, vm)
+                }
+                b'n' if starts_with_bytes(&bytes[byte_idx..], b"null") => {
+                    // null
+                    Ok((vm.ctx.none(), char_idx + 4, byte_idx + 4))
+                }
+                b't' if starts_with_bytes(&bytes[byte_idx..], b"true") => {
+                    // true
+                    Ok((vm.ctx.new_bool(true).into(), char_idx + 4, byte_idx + 4))
+                }
+                b'f' if starts_with_bytes(&bytes[byte_idx..], b"false") => {
+                    // false
+                    Ok((vm.ctx.new_bool(false).into(), char_idx + 5, byte_idx + 5))
+                }
+                b'N' if starts_with_bytes(&bytes[byte_idx..], b"NaN") => {
+                    // NaN
+                    let result = self.parse_constant.call(("NaN",), vm)?;
+                    Ok((result, char_idx + 3, byte_idx + 3))
+                }
+                b'I' if starts_with_bytes(&bytes[byte_idx..], b"Infinity") => {
+                    // Infinity
+                    let result = self.parse_constant.call(("Infinity",), vm)?;
+                    Ok((result, char_idx + 8, byte_idx + 8))
+                }
+                b'-' => {
+                    // -Infinity or negative number
+                    if starts_with_bytes(&bytes[byte_idx..], b"-Infinity") {
+                        let result = self.parse_constant.call(("-Infinity",), vm)?;
+                        return Ok((result, char_idx + 9, byte_idx + 9));
+                    }
+                    // Negative number - numbers are ASCII so len == bytes
+                    if let Some((result, len)) = self.parse_number(&s[byte_idx..], vm) {
+                        return Ok((result?, char_idx + len, byte_idx + len));
+                    }
+                    Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                }
+                b'0'..=b'9' => {
+                    // Positive number - numbers are ASCII so len == bytes
+                    if let Some((result, len)) = self.parse_number(&s[byte_idx..], vm) {
+                        return Ok((result?, char_idx + len, byte_idx + len));
+                    }
+                    Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                }
+                _ => {
+                    // Fall back to scan_once for unrecognized input
+                    // Note: This path requires char_idx for Python compatibility
+                    let result = scan_once.call((pystr.clone(), char_idx as isize), vm);
+
+                    match result {
+                        Ok(tuple) => {
+                            use crate::vm::builtins::PyTupleRef;
+                            let tuple: PyTupleRef = tuple.try_into_value(vm)?;
+                            if tuple.len() != 2 {
+                                return Err(vm.new_value_error("scan_once must return 2-tuple"));
+                            }
+                            let value = tuple.as_slice()[0].clone();
+                            let end_char_idx: isize = tuple.as_slice()[1].try_to_value(vm)?;
+                            // For fallback, we need to calculate byte_idx from char_idx
+                            // This is expensive but fallback should be rare
+                            let end_byte_idx = s
+                                .char_indices()
+                                .nth(end_char_idx as usize)
+                                .map(|(i, _)| i)
+                                .unwrap_or(s.len());
+                            Ok((value, end_char_idx as usize, end_byte_idx))
+                        }
+                        Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
+                            Err(self.make_decode_error("Expecting value", pystr, char_idx, vm))
+                        }
+                        Err(err) => Err(err),
+                    }
+                }
+            }
+        }
+
+        /// Create a decode error.
+        fn make_decode_error(
+            &self,
+            msg: &str,
+            s: PyStrRef,
+            pos: usize,
+            vm: &VirtualMachine,
+        ) -> PyBaseExceptionRef {
+            let err = machinery::DecodeError::new(msg, pos);
+            py_decode_error(err, s, vm)
+        }
+    }
+
+    impl Callable for JsonScanner {
+        type Args = (PyStrRef, isize);
+        fn call(zelf: &Py<Self>, (pystr, char_idx): Self::Args, vm: &VirtualMachine) -> PyResult {
+            if char_idx < 0 {
+                return Err(vm.new_value_error("idx cannot be negative"));
+            }
+            let char_idx = char_idx as usize;
+            let s = pystr.as_str();
+
+            // Calculate byte index from char index (O(char_idx) but only at entry point)
+            let byte_idx = if char_idx == 0 {
+                0
+            } else {
+                match s.char_indices().nth(char_idx) {
+                    Some((byte_i, _)) => byte_i,
+                    None => {
+                        // char_idx is beyond the string length
+                        return PyIterReturn::StopIteration(Some(vm.ctx.new_int(char_idx).into()))
+                            .to_pyresult(vm);
+                    }
+                }
+            };
+
+            zelf.parse(
+                pystr.clone(),
+                char_idx,
+                byte_idx,
+                zelf.to_owned().into(),
+                vm,
+            )
+            .and_then(|x| x.to_pyresult(vm))
+        }
+    }
+
+    fn encode_string(s: &str, ascii_only: bool) -> String {
+        flame_guard!("_json::encode_string");
+        let mut buf = Vec::<u8>::with_capacity(s.len() + 2);
+        machinery::write_json_string(s, ascii_only, &mut buf)
+            // SAFETY: writing to a vec can't fail
+            .unwrap_or_else(|_| unsafe { core::hint::unreachable_unchecked() });
+        // SAFETY: we only output valid utf8 from write_json_string
+        unsafe { String::from_utf8_unchecked(buf) }
+    }
+
+    #[pyfunction]
+    fn encode_basestring(s: PyStrRef) -> String {
+        encode_string(s.as_str(), false)
+    }
+
+    #[pyfunction]
+    fn encode_basestring_ascii(s: PyStrRef) -> String {
+        encode_string(s.as_str(), true)
+    }
+
+    fn py_decode_error(
+        e: machinery::DecodeError,
+        s: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyBaseExceptionRef {
+        let get_error = || -> PyResult<_> {
+            let cls = vm.try_class("json", "JSONDecodeError")?;
+            let exc = PyType::call(&cls, (e.msg, s, e.pos).into_args(vm), vm)?;
+            exc.try_into_value(vm)
+        };
+        match get_error() {
+            Ok(x) | Err(x) => x,
+        }
+    }
+
+    #[pyfunction]
+    fn scanstring(
+        s: PyStrRef,
+        end: usize,
+        strict: OptionalArg<bool>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(Wtf8Buf, usize)> {
+        flame_guard!("_json::scanstring");
+        let wtf8 = s.as_wtf8();
+
+        // Convert char index `end` to byte index
+        let byte_idx = if end == 0 {
+            0
+        } else {
+            wtf8.code_point_indices()
+                .nth(end)
+                .map(|(i, _)| i)
+                .ok_or_else(|| {
+                    py_decode_error(
+                        machinery::DecodeError::new("Unterminated string starting at", end - 1),
+                        s.clone(),
+                        vm,
+                    )
+                })?
+        };
+
+        let (result, chars_consumed, _bytes_consumed) =
+            machinery::scanstring(&wtf8[byte_idx..], end, strict.unwrap_or(true))
+                .map_err(|e| py_decode_error(e, s, vm))?;
+
+        Ok((result, end + chars_consumed))
+    }
+}
diff --git a/stdlib/src/json/machinery.rs b/crates/stdlib/src/json/machinery.rs
similarity index 75%
rename from stdlib/src/json/machinery.rs
rename to crates/stdlib/src/json/machinery.rs
index 57b8ae441f..f33a135ab2 100644
--- a/stdlib/src/json/machinery.rs
+++ b/crates/stdlib/src/json/machinery.rs
@@ -30,6 +30,7 @@
 use std::io;
 
 use itertools::Itertools;
+use memchr::memchr2;
 use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 
 static ESCAPE_CHARS: [&str; 0x20] = [
@@ -108,7 +109,7 @@ pub struct DecodeError {
     pub pos: usize,
 }
 impl DecodeError {
-    fn new(msg: impl Into<String>, pos: usize) -> Self {
+    pub fn new(msg: impl Into<String>, pos: usize) -> Self {
         let msg = msg.into();
         Self { msg, pos }
     }
@@ -126,24 +127,63 @@ impl StrOrChar<'_> {
         }
     }
 }
+/// Scan a JSON string starting right after the opening quote.
+///
+/// # Arguments
+/// * `s` - The string slice starting at the first character after the opening `"`
+/// * `char_offset` - The character index where this slice starts (for error messages)
+/// * `strict` - Whether to reject control characters
+///
+/// # Returns
+/// * `Ok((result, chars_consumed, bytes_consumed))` - The decoded string and how much was consumed
+/// * `Err(DecodeError)` - If the string is malformed
 pub fn scanstring<'a>(
     s: &'a Wtf8,
-    end: usize,
+    char_offset: usize,
     strict: bool,
-) -> Result<(Wtf8Buf, usize), DecodeError> {
+) -> Result<(Wtf8Buf, usize, usize), DecodeError> {
+    flame_guard!("machinery::scanstring");
+    let unterminated_err = || DecodeError::new("Unterminated string starting at", char_offset - 1);
+
+    let bytes = s.as_bytes();
+
+    // Fast path: use memchr to find " or \ quickly
+    if let Some(pos) = memchr2(b'"', b'\\', bytes)
+        && bytes[pos] == b'"'
+    {
+        let content_bytes = &bytes[..pos];
+
+        // In strict mode, check for control characters (0x00-0x1F)
+        let has_control_char = strict && content_bytes.iter().any(|&b| b < 0x20);
+
+        if !has_control_char {
+            flame_guard!("machinery::scanstring::fast_path");
+            let result_slice = &s[..pos];
+            let char_count = result_slice.code_points().count();
+            let mut out = Wtf8Buf::with_capacity(pos);
+            out.push_wtf8(result_slice);
+            // +1 for the closing quote
+            return Ok((out, char_count + 1, pos + 1));
+        }
+    }
+
+    // Slow path: chunk-based parsing for strings with escapes or control chars
+    flame_guard!("machinery::scanstring::slow_path");
     let mut chunks: Vec<StrOrChar<'a>> = Vec::new();
     let mut output_len = 0usize;
     let mut push_chunk = |chunk: StrOrChar<'a>| {
         output_len += chunk.len();
         chunks.push(chunk);
     };
-    let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);
-    let mut chars = s.code_point_indices().enumerate().skip(end).peekable();
-    let &(_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
+
+    let mut chars = s.code_point_indices().enumerate().peekable();
+    let mut chunk_start: usize = 0;
+
     while let Some((char_i, (byte_i, c))) = chars.next() {
         match c.to_char_lossy() {
             '"' => {
                 push_chunk(StrOrChar::Str(&s[chunk_start..byte_i]));
+                flame_guard!("machinery::scanstring::assemble_chunks");
                 let mut out = Wtf8Buf::with_capacity(output_len);
                 for x in chunks {
                     match x {
@@ -151,11 +191,12 @@ pub fn scanstring<'a>(
                         StrOrChar::Char(c) => out.push(c),
                     }
                 }
-                return Ok((out, char_i + 1));
+                // +1 for the closing quote
+                return Ok((out, char_i + 1, byte_i + 1));
             }
             '\\' => {
                 push_chunk(StrOrChar::Str(&s[chunk_start..byte_i]));
-                let (_, (_, c)) = chars.next().ok_or_else(unterminated_err)?;
+                let (next_char_i, (_, c)) = chars.next().ok_or_else(unterminated_err)?;
                 let esc = match c.to_char_lossy() {
                     '"' => "\"",
                     '\\' => "\\",
@@ -166,20 +207,21 @@ pub fn scanstring<'a>(
                     'r' => "\r",
                     't' => "\t",
                     'u' => {
-                        let mut uni = decode_unicode(&mut chars, char_i)?;
+                        let mut uni = decode_unicode(&mut chars, char_offset + char_i)?;
                         chunk_start = byte_i + 6;
                         if let Some(lead) = uni.to_lead_surrogate() {
                             // uni is a surrogate -- try to find its pair
                             let mut chars2 = chars.clone();
-                            if let Some(((pos2, _), (_, _))) = chars2
+                            if let Some(((_, (byte_pos2, _)), (_, _))) = chars2
                                 .next_tuple()
                                 .filter(|((_, (_, c1)), (_, (_, c2)))| *c1 == '\\' && *c2 == 'u')
                             {
-                                let uni2 = decode_unicode(&mut chars2, pos2)?;
+                                let uni2 =
+                                    decode_unicode(&mut chars2, char_offset + next_char_i + 1)?;
                                 if let Some(trail) = uni2.to_trail_surrogate() {
                                     // ok, we found what we were looking for -- \uXXXX\uXXXX, both surrogates
                                     uni = lead.merge(trail).into();
-                                    chunk_start = pos2 + 6;
+                                    chunk_start = byte_pos2 + 6;
                                     chars = chars2;
                                 }
                             }
@@ -188,7 +230,10 @@ pub fn scanstring<'a>(
                         continue;
                     }
                     _ => {
-                        return Err(DecodeError::new(format!("Invalid \\escape: {c:?}"), char_i));
+                        return Err(DecodeError::new(
+                            format!("Invalid \\escape: {c:?}"),
+                            char_offset + char_i,
+                        ));
                     }
                 };
                 chunk_start = byte_i + 2;
@@ -197,7 +242,7 @@ pub fn scanstring<'a>(
             '\x00'..='\x1f' if strict => {
                 return Err(DecodeError::new(
                     format!("Invalid control character {c:?} at"),
-                    char_i,
+                    char_offset + char_i,
                 ));
             }
             _ => {}
@@ -211,12 +256,13 @@ fn decode_unicode<I>(it: &mut I, pos: usize) -> Result<CodePoint, DecodeError>
 where
     I: Iterator<Item = (usize, (usize, CodePoint))>,
 {
+    flame_guard!("machinery::decode_unicode");
     let err = || DecodeError::new("Invalid \\uXXXX escape", pos);
-    let mut uni = 0;
-    for x in (0..4).rev() {
+    let mut uni = 0u16;
+    for _ in 0..4 {
         let (_, (_, c)) = it.next().ok_or_else(err)?;
         let d = c.to_char().and_then(|c| c.to_digit(16)).ok_or_else(err)? as u16;
-        uni += d * 16u16.pow(x);
+        uni = (uni << 4) | d;
     }
     Ok(uni.into())
 }
diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
new file mode 100644
index 0000000000..dc9bad4bd2
--- /dev/null
+++ b/crates/stdlib/src/lib.rs
@@ -0,0 +1,235 @@
+// to allow `mod foo {}` in foo.rs; clippy thinks this is a mistake/misunderstanding of
+// 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;
+extern crate alloc;
+
+#[macro_use]
+pub(crate) mod macros;
+
+pub mod array;
+mod binascii;
+mod bisect;
+mod cmath;
+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;
+
+mod blake2;
+mod hashlib;
+mod md5;
+mod sha1;
+mod sha256;
+mod sha3;
+mod sha512;
+
+mod json;
+
+#[cfg(not(any(target_os = "ios", target_arch = "wasm32")))]
+mod locale;
+
+mod math;
+#[cfg(any(unix, windows))]
+mod mmap;
+mod opcode;
+mod pyexpat;
+mod pystruct;
+mod random;
+mod statistics;
+mod suggestions;
+// TODO: maybe make this an extension module, if we ever get those
+// mod re;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod socket;
+#[cfg(all(unix, not(target_os = "redox")))]
+mod syslog;
+mod unicodedata;
+
+mod faulthandler;
+#[cfg(any(unix, target_os = "wasi"))]
+mod fcntl;
+#[cfg(not(target_arch = "wasm32"))]
+mod multiprocessing;
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+mod posixshmem;
+#[cfg(unix)]
+mod posixsubprocess;
+// libc is missing constants on redox
+#[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
+mod grp;
+#[cfg(windows)]
+mod overlapped;
+#[cfg(all(unix, not(target_os = "redox")))]
+mod resource;
+#[cfg(target_os = "macos")]
+mod scproxy;
+#[cfg(any(unix, windows, target_os = "wasi"))]
+mod select;
+#[cfg(all(
+    feature = "sqlite",
+    not(any(target_os = "android", target_arch = "wasm32"))
+))]
+mod sqlite;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
+mod openssl;
+#[cfg(all(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")))]
+mod termios;
+#[cfg(not(any(
+    target_os = "android",
+    target_os = "ios",
+    target_os = "windows",
+    target_arch = "wasm32",
+    target_os = "redox",
+)))]
+mod uuid;
+
+#[cfg(feature = "tkinter")]
+mod tkinter;
+
+use rustpython_common as common;
+use rustpython_vm as vm;
+
+use crate::vm::{builtins, stdlib::StdlibInitFunc};
+use alloc::borrow::Cow;
+
+pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInitFunc)> {
+    macro_rules! modules {
+        {
+            $(
+                #[cfg($cfg:meta)]
+                { $( $key:expr => $val:expr),* $(,)? }
+            )*
+        } => {{
+            [
+                $(
+                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
+                )*
+            ]
+            .into_iter()
+        }};
+    }
+    modules! {
+        #[cfg(all())]
+        {
+            "array" => array::make_module,
+            "binascii" => binascii::make_module,
+            "_bisect" => bisect::make_module,
+            "_bz2" => bz2::make_module,
+            "cmath" => cmath::make_module,
+            "_contextvars" => contextvars::make_module,
+            "_csv" => csv::make_module,
+            "faulthandler" => faulthandler::make_module,
+            "gc" => gc::make_module,
+            "_hashlib" => hashlib::make_module,
+            "_sha1" => sha1::make_module,
+            "_sha3" => sha3::make_module,
+            "_sha256" => sha256::make_module,
+            "_sha512" => sha512::make_module,
+            "_md5" => md5::make_module,
+            "_blake2" => blake2::make_module,
+            "_json" => json::make_module,
+            "math" => math::make_module,
+            "pyexpat" => pyexpat::make_module,
+            "_opcode" => opcode::make_module,
+            "_random" => random::make_module,
+            "_statistics" => statistics::make_module,
+            "_struct" => pystruct::make_module,
+            "unicodedata" => unicodedata::make_module,
+            "zlib" => zlib::make_module,
+            "_statistics" => statistics::make_module,
+            "_suggestions" => suggestions::make_module,
+            // crate::vm::sysmodule::sysconfigdata_name() => sysconfigdata::make_module,
+        }
+        #[cfg(any(unix, target_os = "wasi"))]
+        {
+            "fcntl" => fcntl::make_module,
+        }
+        #[cfg(any(unix, windows, target_os = "wasi"))]
+        {
+            "select" => select::make_module,
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            "_multiprocessing" => multiprocessing::make_module,
+            "_socket" => socket::make_module,
+        }
+        #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
+        {
+            "_lzma" => lzma::make_module,
+        }
+        #[cfg(all(feature = "sqlite", not(any(target_os = "android", target_arch = "wasm32"))))]
+        {
+            "_sqlite3" => sqlite::make_module,
+        }
+        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-rustls"))]
+        {
+            "_ssl" => ssl::make_module,
+        }
+        #[cfg(all(not(target_arch = "wasm32"), feature = "ssl-openssl"))]
+        {
+            "_ssl" => openssl::make_module,
+        }
+        #[cfg(windows)]
+        {
+            "_overlapped" => overlapped::make_module,
+        }
+        // Unix-only
+        #[cfg(unix)]
+        {
+            "_posixsubprocess" => posixsubprocess::make_module,
+        }
+        #[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+        {
+            "_posixshmem" => posixshmem::make_module,
+        }
+        #[cfg(any(unix, windows))]
+        {
+            "mmap" => mmap::make_module,
+        }
+        #[cfg(all(unix, not(target_os = "redox")))]
+        {
+            "syslog" => syslog::make_module,
+            "resource" => resource::make_module,
+        }
+        #[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
+        {
+            "termios" => termios::make_module,
+        }
+        #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
+        {
+            "grp" => grp::make_module,
+        }
+        #[cfg(target_os = "macos")]
+        {
+            "_scproxy" => scproxy::make_module,
+        }
+        #[cfg(not(any(target_os = "android", target_os = "ios", target_os = "windows", target_arch = "wasm32", target_os = "redox")))]
+        {
+            "_uuid" => uuid::make_module,
+        }
+        #[cfg(not(any(target_os = "ios", target_arch = "wasm32")))]
+        {
+            "_locale" => locale::make_module,
+        }
+        #[cfg(feature = "tkinter")]
+        {
+            "_tkinter" => tkinter::make_module,
+        }
+    }
+}
diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
new file mode 100644
index 0000000000..51cf352590
--- /dev/null
+++ b/crates/stdlib/src/locale.rs
@@ -0,0 +1,300 @@
+// spell-checker:ignore abday abmon yesexpr noexpr CRNCYSTR RADIXCHAR AMPM THOUSEP
+
+pub(crate) use _locale::make_module;
+
+#[cfg(windows)]
+#[repr(C)]
+struct lconv {
+    decimal_point: *mut libc::c_char,
+    thousands_sep: *mut libc::c_char,
+    grouping: *mut libc::c_char,
+    int_curr_symbol: *mut libc::c_char,
+    currency_symbol: *mut libc::c_char,
+    mon_decimal_point: *mut libc::c_char,
+    mon_thousands_sep: *mut libc::c_char,
+    mon_grouping: *mut libc::c_char,
+    positive_sign: *mut libc::c_char,
+    negative_sign: *mut libc::c_char,
+    int_frac_digits: libc::c_char,
+    frac_digits: libc::c_char,
+    p_cs_precedes: libc::c_char,
+    p_sep_by_space: libc::c_char,
+    n_cs_precedes: libc::c_char,
+    n_sep_by_space: libc::c_char,
+    p_sign_posn: libc::c_char,
+    n_sign_posn: libc::c_char,
+    int_p_cs_precedes: libc::c_char,
+    int_p_sep_by_space: libc::c_char,
+    int_n_cs_precedes: libc::c_char,
+    int_n_sep_by_space: libc::c_char,
+    int_p_sign_posn: libc::c_char,
+    int_n_sign_posn: libc::c_char,
+}
+
+#[cfg(windows)]
+unsafe extern "C" {
+    fn localeconv() -> *mut lconv;
+}
+
+#[cfg(unix)]
+use libc::localeconv;
+
+#[pymodule]
+mod _locale {
+    use alloc::ffi::CString;
+    use core::{ffi::CStr, ptr};
+    use rustpython_vm::{
+        PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyIntRef, PyListRef, PyStrRef, PyTypeRef},
+        convert::ToPyException,
+        function::OptionalArg,
+    };
+    #[cfg(windows)]
+    use windows_sys::Win32::Globalization::GetACP;
+
+    #[cfg(all(
+        unix,
+        not(any(target_os = "ios", target_os = "android", target_os = "redox"))
+    ))]
+    #[pyattr]
+    use libc::{
+        ABDAY_1, ABDAY_2, ABDAY_3, ABDAY_4, ABDAY_5, ABDAY_6, ABDAY_7, ABMON_1, ABMON_2, ABMON_3,
+        ABMON_4, ABMON_5, ABMON_6, ABMON_7, ABMON_8, ABMON_9, ABMON_10, ABMON_11, ABMON_12,
+        ALT_DIGITS, AM_STR, CODESET, CRNCYSTR, D_FMT, D_T_FMT, DAY_1, DAY_2, DAY_3, DAY_4, DAY_5,
+        DAY_6, DAY_7, ERA, ERA_D_FMT, ERA_D_T_FMT, ERA_T_FMT, MON_1, MON_2, MON_3, MON_4, MON_5,
+        MON_6, MON_7, MON_8, MON_9, MON_10, MON_11, MON_12, NOEXPR, PM_STR, RADIXCHAR, T_FMT,
+        T_FMT_AMPM, THOUSEP, YESEXPR,
+    };
+
+    #[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
+    #[pyattr]
+    use libc::LC_MESSAGES;
+
+    #[pyattr]
+    use libc::{LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME};
+
+    #[pyattr(name = "CHAR_MAX")]
+    fn char_max(vm: &VirtualMachine) -> PyIntRef {
+        vm.ctx.new_int(libc::c_char::MAX)
+    }
+
+    unsafe fn copy_grouping(group: *const libc::c_char, vm: &VirtualMachine) -> PyListRef {
+        let mut group_vec: Vec<PyObjectRef> = Vec::new();
+        if group.is_null() {
+            return vm.ctx.new_list(group_vec);
+        }
+
+        unsafe {
+            let mut ptr = group;
+            while ![0, libc::c_char::MAX].contains(&*ptr) {
+                let val = vm.ctx.new_int(*ptr);
+                group_vec.push(val.into());
+                ptr = ptr.add(1);
+            }
+        }
+        // https://github.com/python/cpython/blob/677320348728ce058fa3579017e985af74a236d4/Modules/_localemodule.c#L80
+        if !group_vec.is_empty() {
+            group_vec.push(vm.ctx.new_int(0).into());
+        }
+        vm.ctx.new_list(group_vec)
+    }
+
+    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))
+    }
+
+    #[pyattr(name = "Error", once)]
+    fn error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "locale",
+            "Error",
+            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
+        )
+    }
+
+    #[pyfunction]
+    fn strcoll(string1: PyStrRef, string2: PyStrRef, 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 {
+        // https://github.com/python/cpython/blob/eaae563b6878aa050b4ad406b67728b6b066220e/Modules/_localemodule.c#L390-L442
+        let n1 = string.byte_len() + 1;
+        let mut buff = vec![0u8; n1];
+
+        let cstr = CString::new(string.as_str()).map_err(|e| e.to_pyexception(vm))?;
+        let n2 = unsafe { libc::strxfrm(buff.as_mut_ptr() as _, cstr.as_ptr(), n1) };
+        buff = vec![0u8; n2 + 1];
+        unsafe {
+            libc::strxfrm(buff.as_mut_ptr() as _, cstr.as_ptr(), n2 + 1);
+        }
+        Ok(vm.new_pyobj(String::from_utf8(buff).expect("strxfrm returned invalid utf-8 string")))
+    }
+
+    #[pyfunction]
+    fn localeconv(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        let result = vm.ctx.new_dict();
+
+        unsafe {
+            macro_rules! set_string_field {
+                ($lc:expr, $field:ident) => {{
+                    result.set_item(
+                        stringify!($field),
+                        pystr_from_raw_cstr(vm, (*$lc).$field)?,
+                        vm,
+                    )?
+                }};
+            }
+
+            macro_rules! set_int_field {
+                ($lc:expr, $field:ident) => {{ result.set_item(stringify!($field), vm.new_pyobj((*$lc).$field), vm)? }};
+            }
+
+            macro_rules! set_group_field {
+                ($lc:expr, $field:ident) => {{
+                    result.set_item(
+                        stringify!($field),
+                        copy_grouping((*$lc).$field, vm).into(),
+                        vm,
+                    )?
+                }};
+            }
+
+            let lc = super::localeconv();
+            set_group_field!(lc, mon_grouping);
+            set_group_field!(lc, grouping);
+            set_int_field!(lc, int_frac_digits);
+            set_int_field!(lc, frac_digits);
+            set_int_field!(lc, p_cs_precedes);
+            set_int_field!(lc, p_sep_by_space);
+            set_int_field!(lc, n_cs_precedes);
+            set_int_field!(lc, p_sign_posn);
+            set_int_field!(lc, n_sign_posn);
+            set_string_field!(lc, decimal_point);
+            set_string_field!(lc, thousands_sep);
+            set_string_field!(lc, int_curr_symbol);
+            set_string_field!(lc, currency_symbol);
+            set_string_field!(lc, mon_decimal_point);
+            set_string_field!(lc, mon_thousands_sep);
+            set_int_field!(lc, n_sep_by_space);
+            set_string_field!(lc, positive_sign);
+            set_string_field!(lc, negative_sign);
+        }
+        Ok(result)
+    }
+
+    #[derive(FromArgs)]
+    struct LocaleArgs {
+        #[pyarg(any)]
+        category: i32,
+        #[pyarg(any, optional)]
+        locale: OptionalArg<Option<PyStrRef>>,
+    }
+
+    /// Maximum code page encoding name length on Windows
+    #[cfg(windows)]
+    const MAX_CP_LEN: usize = 15;
+
+    /// Check if the encoding part of a locale string is too long (Windows only)
+    #[cfg(windows)]
+    fn check_locale_name(locale: &str) -> bool {
+        if let Some(dot_pos) = locale.find('.') {
+            let encoding_part = &locale[dot_pos + 1..];
+            // Find the end of encoding (could be followed by '@' modifier)
+            let encoding_len = encoding_part.find('@').unwrap_or(encoding_part.len());
+            encoding_len <= MAX_CP_LEN
+        } else {
+            true
+        }
+    }
+
+    /// Check locale names for LC_ALL (handles semicolon-separated locales)
+    #[cfg(windows)]
+    fn check_locale_name_all(locale: &str) -> bool {
+        for part in locale.split(';') {
+            if !check_locale_name(part) {
+                return false;
+            }
+        }
+        true
+    }
+
+    #[pyfunction]
+    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")));
+        }
+        unsafe {
+            let result = match args.locale.flatten() {
+                None => libc::setlocale(args.category, ptr::null()),
+                Some(locale) => {
+                    // On Windows, validate encoding name length
+                    #[cfg(windows)]
+                    {
+                        let valid = if args.category == LC_ALL {
+                            check_locale_name_all(locale.as_str())
+                        } else {
+                            check_locale_name(locale.as_str())
+                        };
+                        if !valid {
+                            return Err(vm.new_exception_msg(
+                                error,
+                                String::from("unsupported locale setting"),
+                            ));
+                        }
+                    }
+                    let c_locale: CString =
+                        CString::new(locale.as_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")));
+            }
+            pystr_from_raw_cstr(vm, result)
+        }
+    }
+
+    /// Get the current locale encoding.
+    #[pyfunction]
+    fn getencoding() -> String {
+        #[cfg(windows)]
+        {
+            // On Windows, use GetACP() to get the ANSI code page
+            let acp = unsafe { GetACP() };
+            format!("cp{}", acp)
+        }
+        #[cfg(not(windows))]
+        {
+            // On Unix, use nl_langinfo(CODESET) or fallback to UTF-8
+            #[cfg(all(
+                unix,
+                not(any(target_os = "ios", target_os = "android", target_os = "redox"))
+            ))]
+            {
+                unsafe {
+                    let codeset = libc::nl_langinfo(libc::CODESET);
+                    if !codeset.is_null()
+                        && let Ok(s) = CStr::from_ptr(codeset).to_str()
+                        && !s.is_empty()
+                    {
+                        return s.to_string();
+                    }
+                }
+                "UTF-8".to_string()
+            }
+            #[cfg(any(target_os = "ios", target_os = "android", target_os = "redox"))]
+            {
+                "UTF-8".to_string()
+            }
+        }
+    }
+}
diff --git a/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
similarity index 96%
rename from stdlib/src/lzma.rs
rename to crates/stdlib/src/lzma.rs
index c2dd912577..b18ac3ee69 100644
--- a/stdlib/src/lzma.rs
+++ b/crates/stdlib/src/lzma.rs
@@ -8,6 +8,7 @@ mod _lzma {
         CompressFlushKind, CompressState, CompressStatusKind, Compressor, DecompressArgs,
         DecompressError, DecompressState, DecompressStatus, Decompressor,
     };
+    use alloc::fmt;
     #[pyattr]
     use lzma_sys::{
         LZMA_CHECK_CRC32 as CHECK_CRC32, LZMA_CHECK_CRC64 as CHECK_CRC64,
@@ -33,12 +34,11 @@ mod _lzma {
         LZMA_PRESET_LEVEL_MASK as PRESET_LEVEL_MASK,
     };
     use rustpython_common::lock::PyMutex;
-    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytesRef, PyTypeRef};
+    use rustpython_vm::builtins::{PyBaseExceptionRef, PyBytesRef, PyType, PyTypeRef};
     use rustpython_vm::convert::ToPyException;
     use rustpython_vm::function::ArgBytesLike;
     use rustpython_vm::types::Constructor;
-    use rustpython_vm::{PyObjectRef, PyPayload, PyResult, VirtualMachine};
-    use std::fmt;
+    use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
     use xz2::stream::{Action, Check, Error, Filters, LzmaOptions, Status, Stream};
 
     #[cfg(windows)]
@@ -148,7 +148,7 @@ mod _lzma {
     impl Constructor for LZMADecompressor {
         type Args = LZMADecompressorConstructorArgs;
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             if args.format == FORMAT_RAW && args.mem_limit.is_some() {
                 return Err(vm.new_value_error("Cannot specify memory limit with FORMAT_RAW"));
             }
@@ -161,15 +161,13 @@ mod _lzma {
                 // TODO: FORMAT_RAW
                 _ => return Err(new_lzma_error("Invalid format", vm)),
             };
-            Self {
+            Ok(Self {
                 state: PyMutex::new(DecompressState::new(
                     stream_result
                         .map_err(|_| new_lzma_error("Failed to initialize decoder", vm))?,
                     vm,
                 )),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -214,7 +212,6 @@ mod _lzma {
     }
 
     impl CompressStatusKind for Status {
-        const OK: Self = Status::Ok;
         const EOF: Self = Status::StreamEnd;
 
         fn to_usize(self) -> usize {
@@ -367,7 +364,7 @@ mod _lzma {
     impl Constructor for LZMACompressor {
         type Args = LZMACompressorConstructorArgs;
 
-        fn py_new(_cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        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
@@ -393,8 +390,7 @@ mod _lzma {
             };
             Ok(Self {
                 state: PyMutex::new(CompressState::new(CompressorInner::new(stream))),
-            }
-            .into_pyobject(vm))
+            })
         }
     }
 
diff --git a/crates/stdlib/src/macros.rs b/crates/stdlib/src/macros.rs
new file mode 100644
index 0000000000..385f4b1c4a
--- /dev/null
+++ b/crates/stdlib/src/macros.rs
@@ -0,0 +1,7 @@
+#[macro_export]
+macro_rules! flame_guard {
+    ($name:expr) => {
+        #[cfg(feature = "flame-it")]
+        let _guard = ::flame::start_guard($name);
+    };
+}
diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
new file mode 100644
index 0000000000..1e014e49e2
--- /dev/null
+++ b/crates/stdlib/src/math.rs
@@ -0,0 +1,960 @@
+pub(crate) use math::make_module;
+
+use crate::vm::{VirtualMachine, builtins::PyBaseExceptionRef};
+
+#[pymodule]
+mod math {
+    use crate::vm::{
+        AsObject, PyObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
+        builtins::{PyFloat, PyInt, PyIntRef, PyStrInterned, try_bigint_to_f64, try_f64_to_bigint},
+        function::{ArgIndex, ArgIntoFloat, ArgIterable, Either, OptionalArg, PosArgs},
+        identifier,
+    };
+    use malachite_bigint::BigInt;
+    use num_traits::{Signed, ToPrimitive};
+
+    use super::{float_repr, pymath_exception};
+
+    // Constants
+    #[pyattr]
+    use core::f64::consts::{E as e, PI as pi, TAU as tau};
+
+    #[pyattr(name = "inf")]
+    const INF: f64 = f64::INFINITY;
+    #[pyattr(name = "nan")]
+    const NAN: f64 = f64::NAN;
+
+    // Number theory functions:
+    #[pyfunction]
+    fn fabs(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::fabs(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn isfinite(x: ArgIntoFloat) -> bool {
+        pymath::math::isfinite(x.into_float())
+    }
+
+    #[pyfunction]
+    fn isinf(x: ArgIntoFloat) -> bool {
+        pymath::math::isinf(x.into_float())
+    }
+
+    #[pyfunction]
+    fn isnan(x: ArgIntoFloat) -> bool {
+        pymath::math::isnan(x.into_float())
+    }
+
+    #[derive(FromArgs)]
+    struct IsCloseArgs {
+        #[pyarg(positional)]
+        a: ArgIntoFloat,
+        #[pyarg(positional)]
+        b: ArgIntoFloat,
+        #[pyarg(named, optional)]
+        rel_tol: OptionalArg<ArgIntoFloat>,
+        #[pyarg(named, optional)]
+        abs_tol: OptionalArg<ArgIntoFloat>,
+    }
+
+    #[pyfunction]
+    fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
+        let a = args.a.into_float();
+        let b = args.b.into_float();
+        let rel_tol = args.rel_tol.into_option().map(|v| v.into_float());
+        let abs_tol = args.abs_tol.into_option().map(|v| v.into_float());
+
+        pymath::math::isclose(a, b, rel_tol, abs_tol)
+            .map_err(|_| vm.new_value_error("tolerances must be non-negative"))
+    }
+
+    #[pyfunction]
+    fn copysign(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::copysign(x.into_float(), y.into_float())
+            .map_err(|err| pymath_exception(err, vm))
+    }
+
+    // Power and logarithmic functions:
+    #[pyfunction]
+    fn exp(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::exp(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn exp2(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::exp2(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn expm1(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::expm1(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn log(x: PyObjectRef, base: OptionalArg<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
+        let base = base.into_option().map(|v| v.into_float());
+        // Check base first for proper error messages
+        if let Some(b) = base {
+            if b <= 0.0 {
+                return Err(vm.new_value_error(format!(
+                    "expected a positive input, got {}",
+                    super::float_repr(b)
+                )));
+            }
+            if b == 1.0 {
+                return Err(vm.new_value_error("math domain error".to_owned()));
+            }
+        }
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log_bigint(i.as_bigint(), base).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
+        }
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log(val, base).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn log1p(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::log1p(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn log2(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log2_bigint(i.as_bigint()).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
+        }
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log2(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn log10(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
+        // Handle BigInt specially for large values (only for actual int type, not float)
+        if let Some(i) = x.downcast_ref::<PyInt>() {
+            return pymath::math::log10_bigint(i.as_bigint()).map_err(|err| match err {
+                pymath::Error::EDOM => vm.new_value_error("expected a positive input".to_owned()),
+                _ => pymath_exception(err, vm),
+            });
+        }
+        let val = x.try_float(vm)?.to_f64();
+        pymath::math::log10(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a positive input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn pow(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::pow(x.into_float(), y.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn sqrt(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::sqrt(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a nonnegative input, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    // Trigonometric functions:
+    #[pyfunction]
+    fn acos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::acos(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number in range from -1 up to 1, got {}",
+                float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn asin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::asin(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number in range from -1 up to 1, got {}",
+                float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn atan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::atan(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn atan2(y: ArgIntoFloat, x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::atan2(y.into_float(), x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn cos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::cos(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn hypot(coordinates: PosArgs<ArgIntoFloat>) -> f64 {
+        let coords = ArgIntoFloat::vec_into_f64(coordinates.into_vec());
+        pymath::math::hypot(&coords)
+    }
+
+    #[pyfunction]
+    fn dist(p: Vec<ArgIntoFloat>, q: Vec<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
+        let p = ArgIntoFloat::vec_into_f64(p);
+        let q = ArgIntoFloat::vec_into_f64(q);
+        if p.len() != q.len() {
+            return Err(vm.new_value_error("both points must have the same number of dimensions"));
+        }
+        Ok(pymath::math::dist(&p, &q))
+    }
+
+    #[pyfunction]
+    fn sin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::sin(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn tan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::tan(val).map_err(|err| match err {
+            pymath::Error::EDOM => {
+                vm.new_value_error(format!("expected a finite input, got {}", float_repr(val)))
+            }
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn degrees(x: ArgIntoFloat) -> f64 {
+        pymath::math::degrees(x.into_float())
+    }
+
+    #[pyfunction]
+    fn radians(x: ArgIntoFloat) -> f64 {
+        pymath::math::radians(x.into_float())
+    }
+
+    // Hyperbolic functions:
+
+    #[pyfunction]
+    fn acosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::acosh(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn asinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::asinh(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn atanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::atanh(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a number between -1 and 1, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn cosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::cosh(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn sinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::sinh(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn tanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::tanh(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    // Special functions:
+    #[pyfunction]
+    fn erf(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::erf(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn erfc(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::erfc(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn gamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        let val = x.into_float();
+        pymath::math::gamma(val).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error(format!(
+                "expected a noninteger or positive integer, got {}",
+                super::float_repr(val)
+            )),
+            _ => pymath_exception(err, vm),
+        })
+    }
+
+    #[pyfunction]
+    fn lgamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::lgamma(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    fn try_magic_method(
+        func_name: &'static PyStrInterned,
+        vm: &VirtualMachine,
+        value: &PyObject,
+    ) -> PyResult {
+        let method = vm.get_method_or_type_error(value.to_owned(), func_name, || {
+            format!(
+                "type '{}' doesn't define '{}' method",
+                value.class().name(),
+                func_name.as_str(),
+            )
+        })?;
+        method.call((), vm)
+    }
+
+    #[pyfunction]
+    fn trunc(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        try_magic_method(identifier!(vm, __trunc__), vm, &x)
+    }
+
+    #[pyfunction]
+    fn ceil(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Only call __ceil__ if the class defines it - if it exists but is not callable,
+        // the error should be propagated (not fall back to float conversion)
+        if x.class().has_attr(identifier!(vm, __ceil__)) {
+            return try_magic_method(identifier!(vm, __ceil__), vm, &x);
+        }
+        // __ceil__ not defined - fall back to float conversion
+        if let Some(v) = x.try_float_opt(vm) {
+            let v = try_f64_to_bigint(v?.to_f64().ceil(), vm)?;
+            return Ok(vm.ctx.new_int(v).into());
+        }
+        Err(vm.new_type_error(format!(
+            "type '{}' doesn't define '__ceil__' method",
+            x.class().name(),
+        )))
+    }
+
+    #[pyfunction]
+    fn floor(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Only call __floor__ if the class defines it - if it exists but is not callable,
+        // the error should be propagated (not fall back to float conversion)
+        if x.class().has_attr(identifier!(vm, __floor__)) {
+            return try_magic_method(identifier!(vm, __floor__), vm, &x);
+        }
+        // __floor__ not defined - fall back to float conversion
+        if let Some(v) = x.try_float_opt(vm) {
+            let v = try_f64_to_bigint(v?.to_f64().floor(), vm)?;
+            return Ok(vm.ctx.new_int(v).into());
+        }
+        Err(vm.new_type_error(format!(
+            "type '{}' doesn't define '__floor__' method",
+            x.class().name(),
+        )))
+    }
+
+    #[pyfunction]
+    fn frexp(x: ArgIntoFloat) -> (f64, i32) {
+        pymath::math::frexp(x.into_float())
+    }
+
+    #[pyfunction]
+    fn ldexp(
+        x: Either<PyRef<PyFloat>, PyIntRef>,
+        i: PyIntRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<f64> {
+        let value = match x {
+            Either::A(f) => f.to_f64(),
+            Either::B(z) => try_bigint_to_f64(z.as_bigint(), vm)?,
+        };
+        pymath::math::ldexp_bigint(value, i.as_bigint()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn cbrt(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::cbrt(x.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn fsum(seq: ArgIterable<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
+        let values: Result<Vec<f64>, _> =
+            seq.iter(vm)?.map(|r| r.map(|v| v.into_float())).collect();
+        pymath::math::fsum(values?).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn modf(x: ArgIntoFloat) -> (f64, f64) {
+        pymath::math::modf(x.into_float())
+    }
+
+    #[derive(FromArgs)]
+    struct NextAfterArgs {
+        #[pyarg(positional)]
+        x: ArgIntoFloat,
+        #[pyarg(positional)]
+        y: ArgIntoFloat,
+        #[pyarg(named, optional)]
+        steps: OptionalArg<ArgIndex>,
+    }
+
+    #[pyfunction]
+    fn nextafter(arg: NextAfterArgs, vm: &VirtualMachine) -> PyResult<f64> {
+        let x = arg.x.into_float();
+        let y = arg.y.into_float();
+
+        let steps = match arg.steps.into_option() {
+            Some(steps) => {
+                let steps: i64 = steps.into_int_ref().try_to_primitive(vm)?;
+                if steps < 0 {
+                    return Err(vm.new_value_error("steps must be a non-negative integer"));
+                }
+                Some(steps as u64)
+            }
+            None => None,
+        };
+        Ok(pymath::math::nextafter(x, y, steps))
+    }
+
+    #[pyfunction]
+    fn ulp(x: ArgIntoFloat) -> f64 {
+        pymath::math::ulp(x.into_float())
+    }
+
+    #[pyfunction(name = "fmod")]
+    fn py_fmod(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::fmod(x.into_float(), y.into_float()).map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[pyfunction]
+    fn remainder(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
+        pymath::math::remainder(x.into_float(), y.into_float())
+            .map_err(|err| pymath_exception(err, vm))
+    }
+
+    #[derive(FromArgs)]
+    struct ProdArgs {
+        #[pyarg(positional)]
+        iterable: ArgIterable<PyObjectRef>,
+        #[pyarg(named, optional)]
+        start: OptionalArg<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn prod(args: ProdArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        use crate::vm::builtins::PyInt;
+
+        let iter = args.iterable;
+        let start = args.start;
+
+        // Check if start is provided and what type it is (exact types only, not subclasses)
+        let (mut obj_result, start_is_int, start_is_float) = match &start {
+            OptionalArg::Present(s) => {
+                let is_int = s.class().is(vm.ctx.types.int_type);
+                let is_float = s.class().is(vm.ctx.types.float_type);
+                (Some(s.clone()), is_int, is_float)
+            }
+            OptionalArg::Missing => (None, true, false), // Default is int 1
+        };
+
+        let mut item_iter = iter.iter(vm)?;
+
+        // Integer fast path
+        if start_is_int && !start_is_float {
+            let mut int_result: i64 = match &start {
+                OptionalArg::Present(s) => {
+                    if let Some(i) = s.downcast_ref::<PyInt>() {
+                        match i.as_bigint().try_into() {
+                            Ok(v) => v,
+                            Err(_) => {
+                                // Start overflows i64, fall through to generic path
+                                obj_result = Some(s.clone());
+                                i64::MAX // Will be ignored
+                            }
+                        }
+                    } else {
+                        1
+                    }
+                }
+                OptionalArg::Missing => 1,
+            };
+
+            if obj_result.is_none() {
+                loop {
+                    let item = match item_iter.next() {
+                        Some(r) => r?,
+                        None => return Ok(vm.ctx.new_int(int_result).into()),
+                    };
+
+                    // Only use fast path for exact int type (not subclasses)
+                    if item.class().is(vm.ctx.types.int_type)
+                        && let Some(int_item) = item.downcast_ref::<PyInt>()
+                        && let Ok(b) = int_item.as_bigint().try_into() as Result<i64, _>
+                        && let Some(product) = int_result.checked_mul(b)
+                    {
+                        int_result = product;
+                        continue;
+                    }
+
+                    // Overflow or non-int: restore to PyObject and continue
+                    obj_result = Some(vm.ctx.new_int(int_result).into());
+                    let temp = vm._mul(obj_result.as_ref().unwrap(), &item)?;
+                    obj_result = Some(temp);
+                    break;
+                }
+            }
+        }
+
+        // Float fast path
+        let obj_float = obj_result
+            .as_ref()
+            .and_then(|obj| obj.clone().downcast::<PyFloat>().ok());
+        if obj_float.is_some() || start_is_float {
+            let mut flt_result: f64 = if let Some(ref f) = obj_float {
+                f.to_f64()
+            } else if start_is_float && let OptionalArg::Present(s) = &start {
+                s.downcast_ref::<PyFloat>()
+                    .map(|f| f.to_f64())
+                    .unwrap_or(1.0)
+            } else {
+                1.0
+            };
+
+            loop {
+                let item = match item_iter.next() {
+                    Some(r) => r?,
+                    None => return Ok(vm.ctx.new_float(flt_result).into()),
+                };
+
+                // Only use fast path for exact float/int types (not subclasses)
+                if item.class().is(vm.ctx.types.float_type)
+                    && let Some(f) = item.downcast_ref::<PyFloat>()
+                {
+                    flt_result *= f.to_f64();
+                    continue;
+                }
+                if item.class().is(vm.ctx.types.int_type)
+                    && let Some(i) = item.downcast_ref::<PyInt>()
+                    && let Ok(v) = i.as_bigint().try_into() as Result<i64, _>
+                {
+                    flt_result *= v as f64;
+                    continue;
+                }
+
+                // Non-exact-float/int: restore and continue with generic path
+                obj_result = Some(vm.ctx.new_float(flt_result).into());
+                let temp = vm._mul(obj_result.as_ref().unwrap(), &item)?;
+                obj_result = Some(temp);
+                break;
+            }
+        }
+
+        // Generic path for remaining items
+        let mut result = obj_result.unwrap_or_else(|| vm.ctx.new_int(1).into());
+        for item in item_iter {
+            let item = item?;
+            result = vm._mul(&result, &item)?;
+        }
+
+        Ok(result)
+    }
+
+    #[pyfunction]
+    fn sumprod(
+        p: ArgIterable<PyObjectRef>,
+        q: ArgIterable<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        use crate::vm::builtins::PyInt;
+
+        let mut p_iter = p.iter(vm)?;
+        let mut q_iter = q.iter(vm)?;
+
+        // Fast path state
+        let mut int_path_enabled = true;
+        let mut int_total: i64 = 0;
+        let mut int_total_in_use = false;
+        let mut flt_p_values: Vec<f64> = Vec::new();
+        let mut flt_q_values: Vec<f64> = Vec::new();
+
+        // Fallback accumulator for generic Python path
+        let mut obj_total: Option<PyObjectRef> = None;
+
+        loop {
+            let m_p = p_iter.next();
+            let m_q = q_iter.next();
+
+            let (p_i, q_i, finished) = match (m_p, m_q) {
+                (Some(r_p), Some(r_q)) => (Some(r_p?), Some(r_q?), false),
+                (None, None) => (None, None, true),
+                _ => return Err(vm.new_value_error("Inputs are not the same length")),
+            };
+
+            // Integer fast path (only for exact int types, not subclasses)
+            if int_path_enabled {
+                if !finished {
+                    let (p_i, q_i) = (p_i.as_ref().unwrap(), q_i.as_ref().unwrap());
+                    if p_i.class().is(vm.ctx.types.int_type)
+                        && q_i.class().is(vm.ctx.types.int_type)
+                        && let (Some(p_int), Some(q_int)) =
+                            (p_i.downcast_ref::<PyInt>(), q_i.downcast_ref::<PyInt>())
+                        && let (Ok(p_val), Ok(q_val)) = (
+                            p_int.as_bigint().try_into() as Result<i64, _>,
+                            q_int.as_bigint().try_into() as Result<i64, _>,
+                        )
+                        && let Some(prod) = p_val.checked_mul(q_val)
+                        && let Some(new_total) = int_total.checked_add(prod)
+                    {
+                        int_total = new_total;
+                        int_total_in_use = true;
+                        continue;
+                    }
+                }
+                // Finalize int path
+                int_path_enabled = false;
+                if int_total_in_use {
+                    let int_obj: PyObjectRef = vm.ctx.new_int(int_total).into();
+                    obj_total = Some(match obj_total {
+                        Some(total) => vm._add(&total, &int_obj)?,
+                        None => int_obj,
+                    });
+                    int_total = 0;
+                    int_total_in_use = false;
+                }
+            }
+
+            // Float fast path - only when at least one value is exact float type
+            // (not subclasses, to preserve custom __mul__/__add__ behavior)
+            {
+                if !finished {
+                    let (p_i, q_i) = (p_i.as_ref().unwrap(), q_i.as_ref().unwrap());
+
+                    let p_is_exact_float = p_i.class().is(vm.ctx.types.float_type);
+                    let q_is_exact_float = q_i.class().is(vm.ctx.types.float_type);
+                    let p_is_exact_int = p_i.class().is(vm.ctx.types.int_type);
+                    let q_is_exact_int = q_i.class().is(vm.ctx.types.int_type);
+                    let p_is_exact_numeric = p_is_exact_float || p_is_exact_int;
+                    let q_is_exact_numeric = q_is_exact_float || q_is_exact_int;
+                    let has_exact_float = p_is_exact_float || q_is_exact_float;
+
+                    // Only use float path if at least one is exact float and both are exact int/float
+                    if has_exact_float && p_is_exact_numeric && q_is_exact_numeric {
+                        let p_flt = if let Some(f) = p_i.downcast_ref::<PyFloat>() {
+                            Some(f.to_f64())
+                        } else if let Some(i) = p_i.downcast_ref::<PyInt>() {
+                            // PyLong_AsDouble fails for integers too large for f64
+                            try_bigint_to_f64(i.as_bigint(), vm).ok()
+                        } else {
+                            None
+                        };
+
+                        let q_flt = if let Some(f) = q_i.downcast_ref::<PyFloat>() {
+                            Some(f.to_f64())
+                        } else if let Some(i) = q_i.downcast_ref::<PyInt>() {
+                            // PyLong_AsDouble fails for integers too large for f64
+                            try_bigint_to_f64(i.as_bigint(), vm).ok()
+                        } else {
+                            None
+                        };
+
+                        if let (Some(p_val), Some(q_val)) = (p_flt, q_flt) {
+                            flt_p_values.push(p_val);
+                            flt_q_values.push(q_val);
+                            continue;
+                        }
+                    }
+                }
+                // Finalize float path
+                if !flt_p_values.is_empty() {
+                    let flt_result = pymath::math::sumprod(&flt_p_values, &flt_q_values);
+                    let flt_obj: PyObjectRef = vm.ctx.new_float(flt_result).into();
+                    obj_total = Some(match obj_total {
+                        Some(total) => vm._add(&total, &flt_obj)?,
+                        None => flt_obj,
+                    });
+                    flt_p_values.clear();
+                    flt_q_values.clear();
+                }
+            }
+
+            if finished {
+                break;
+            }
+
+            // Generic Python path
+            let (p_i, q_i) = (p_i.unwrap(), q_i.unwrap());
+
+            // Collect current + remaining elements
+            let p_remaining: Result<Vec<PyObjectRef>, _> =
+                std::iter::once(Ok(p_i)).chain(p_iter).collect();
+            let q_remaining: Result<Vec<PyObjectRef>, _> =
+                std::iter::once(Ok(q_i)).chain(q_iter).collect();
+            let (p_vec, q_vec) = (p_remaining?, q_remaining?);
+
+            if p_vec.len() != q_vec.len() {
+                return Err(vm.new_value_error("Inputs are not the same length"));
+            }
+
+            let mut total = obj_total.unwrap_or_else(|| vm.ctx.new_int(0).into());
+            for (p_item, q_item) in p_vec.into_iter().zip(q_vec) {
+                let prod = vm._mul(&p_item, &q_item)?;
+                total = vm._add(&total, &prod)?;
+            }
+            return Ok(total);
+        }
+
+        Ok(obj_total.unwrap_or_else(|| vm.ctx.new_int(0).into()))
+    }
+
+    #[pyfunction]
+    fn fma(
+        x: ArgIntoFloat,
+        y: ArgIntoFloat,
+        z: ArgIntoFloat,
+        vm: &VirtualMachine,
+    ) -> PyResult<f64> {
+        pymath::math::fma(x.into_float(), y.into_float(), z.into_float()).map_err(|err| match err {
+            pymath::Error::EDOM => vm.new_value_error("invalid operation in fma"),
+            pymath::Error::ERANGE => vm.new_overflow_error("overflow in fma"),
+        })
+    }
+
+    // Integer functions:
+
+    #[pyfunction]
+    fn isqrt(x: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let value = x.into_int_ref();
+        pymath::math::integer::isqrt(value.as_bigint())
+            .map_err(|_| vm.new_value_error("isqrt() argument must be nonnegative"))
+    }
+
+    #[pyfunction]
+    fn gcd(args: PosArgs<ArgIndex>) -> BigInt {
+        let ints: Vec<_> = args
+            .into_vec()
+            .into_iter()
+            .map(|x| x.into_int_ref())
+            .collect();
+        let refs: Vec<_> = ints.iter().map(|x| x.as_bigint()).collect();
+        pymath::math::integer::gcd(&refs)
+    }
+
+    #[pyfunction]
+    fn lcm(args: PosArgs<ArgIndex>) -> BigInt {
+        let ints: Vec<_> = args
+            .into_vec()
+            .into_iter()
+            .map(|x| x.into_int_ref())
+            .collect();
+        let refs: Vec<_> = ints.iter().map(|x| x.as_bigint()).collect();
+        pymath::math::integer::lcm(&refs)
+    }
+
+    #[pyfunction]
+    fn factorial(x: PyIntRef, vm: &VirtualMachine) -> PyResult<BigInt> {
+        // Check for negative before overflow - negative values are always invalid
+        if x.as_bigint().is_negative() {
+            return Err(vm.new_value_error("factorial() not defined for negative values"));
+        }
+        let n: i64 = x.try_to_primitive(vm).map_err(|_| {
+            vm.new_overflow_error("factorial() argument should not exceed 9223372036854775807")
+        })?;
+        pymath::math::integer::factorial(n)
+            .map(|r| r.into())
+            .map_err(|_| vm.new_value_error("factorial() not defined for negative values"))
+    }
+
+    #[pyfunction]
+    fn perm(
+        n: ArgIndex,
+        k: OptionalArg<Option<ArgIndex>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<BigInt> {
+        let n_int = n.into_int_ref();
+        let n_big = n_int.as_bigint();
+
+        if n_big.is_negative() {
+            return Err(vm.new_value_error("n must be a non-negative integer"));
+        }
+
+        // k = None means k = n (factorial)
+        let k_int = k.flatten().map(|k| k.into_int_ref());
+        let k_big: Option<&BigInt> = k_int.as_ref().map(|k| k.as_bigint());
+
+        if let Some(k_val) = k_big {
+            if k_val.is_negative() {
+                return Err(vm.new_value_error("k must be a non-negative integer"));
+            }
+            if k_val > n_big {
+                return Ok(BigInt::from(0u8));
+            }
+        }
+
+        // Convert k to u64 (required by pymath)
+        let ki: u64 = match k_big {
+            None => match n_big.to_u64() {
+                Some(n) => n,
+                None => {
+                    return Err(vm.new_overflow_error(format!("n must not exceed {}", u64::MAX)));
+                }
+            },
+            Some(k_val) => match k_val.to_u64() {
+                Some(k) => k,
+                None => {
+                    return Err(vm.new_overflow_error(format!("k must not exceed {}", u64::MAX)));
+                }
+            },
+        };
+
+        // Fast path: n fits in i64
+        if let Some(ni) = n_big.to_i64()
+            && ni >= 0
+            && ki > 1
+        {
+            let result = pymath::math::integer::perm(ni, Some(ki as i64))
+                .map_err(|_| vm.new_value_error("perm() error"))?;
+            return Ok(result.into());
+        }
+
+        // BigInt path: use perm_bigint
+        let result = pymath::math::perm_bigint(n_big, ki);
+        Ok(result.into())
+    }
+
+    #[pyfunction]
+    fn comb(n: ArgIndex, k: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
+        let n_int = n.into_int_ref();
+        let n_big = n_int.as_bigint();
+        let k_int = k.into_int_ref();
+        let k_big = k_int.as_bigint();
+
+        if n_big.is_negative() {
+            return Err(vm.new_value_error("n must be a non-negative integer"));
+        }
+        if k_big.is_negative() {
+            return Err(vm.new_value_error("k must be a non-negative integer"));
+        }
+
+        // Fast path: n fits in i64
+        if let Some(ni) = n_big.to_i64()
+            && ni >= 0
+        {
+            // k overflow or k > n means result is 0
+            let ki = match k_big.to_i64() {
+                Some(k) if k >= 0 && k <= ni => k,
+                _ => return Ok(BigInt::from(0u8)),
+            };
+            // Apply symmetry: use min(k, n-k)
+            let ki = ki.min(ni - ki);
+            if ki > 1 {
+                let result = pymath::math::integer::comb(ni, ki)
+                    .map_err(|_| vm.new_value_error("comb() error"))?;
+                return Ok(result.into());
+            }
+            // ki <= 1 cases
+            if ki == 0 {
+                return Ok(BigInt::from(1u8));
+            }
+            return Ok(n_big.clone()); // ki == 1
+        }
+
+        // BigInt path: n doesn't fit in i64
+        // Apply symmetry: k = min(k, n - k)
+        let n_minus_k = n_big - k_big;
+        if n_minus_k.is_negative() {
+            return Ok(BigInt::from(0u8));
+        }
+        let effective_k = if &n_minus_k < k_big {
+            &n_minus_k
+        } else {
+            k_big
+        };
+
+        // k must fit in u64
+        let ki: u64 = match effective_k.to_u64() {
+            Some(k) => k,
+            None => {
+                return Err(
+                    vm.new_overflow_error(format!("min(n - k, k) must not exceed {}", u64::MAX))
+                );
+            }
+        };
+
+        let result = pymath::math::comb_bigint(n_big, ki);
+        Ok(result.into())
+    }
+}
+
+pub(crate) fn pymath_exception(err: pymath::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
+    match err {
+        pymath::Error::EDOM => vm.new_value_error("math domain error"),
+        pymath::Error::ERANGE => vm.new_overflow_error("math range error"),
+    }
+}
+
+/// Format a float in Python style (ensures trailing .0 for integers).
+fn float_repr(value: f64) -> String {
+    if value.is_nan() {
+        "nan".to_owned()
+    } else if value.is_infinite() {
+        if value.is_sign_positive() {
+            "inf".to_owned()
+        } else {
+            "-inf".to_owned()
+        }
+    } else {
+        let s = format!("{}", value);
+        // If no decimal point and not in scientific notation, add .0
+        if !s.contains('.') && !s.contains('e') && !s.contains('E') {
+            format!("{}.0", s)
+        } else {
+            s
+        }
+    }
+}
diff --git a/stdlib/src/md5.rs b/crates/stdlib/src/md5.rs
similarity index 100%
rename from stdlib/src/md5.rs
rename to crates/stdlib/src/md5.rs
diff --git a/crates/stdlib/src/mmap.rs b/crates/stdlib/src/mmap.rs
new file mode 100644
index 0000000000..d389552109
--- /dev/null
+++ b/crates/stdlib/src/mmap.rs
@@ -0,0 +1,1468 @@
+// spell-checker:disable
+//! mmap module
+pub(crate) use mmap::make_module;
+
+#[pymodule]
+mod mmap {
+    use crate::common::{
+        borrow::{BorrowedValue, BorrowedValueMut},
+        lock::{MapImmutable, PyMutex, PyMutexGuard},
+    };
+    use crate::vm::{
+        AsObject, FromArgs, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
+        TryFromBorrowedObject, VirtualMachine, atomic_func,
+        builtins::{PyBytes, PyBytesRef, PyInt, PyIntRef, PyType, PyTypeRef},
+        byte::{bytes_from_object, value_from_object},
+        convert::ToPyException,
+        function::{ArgBytesLike, FuncArgs, OptionalArg},
+        protocol::{
+            BufferDescriptor, BufferMethods, PyBuffer, PyMappingMethods, PySequenceMethods,
+        },
+        sliceable::{SaturatedSlice, SequenceIndex, SequenceIndexOp},
+        types::{AsBuffer, AsMapping, AsSequence, Constructor, Representable},
+    };
+    use core::ops::{Deref, DerefMut};
+    use crossbeam_utils::atomic::AtomicCell;
+    use memmap2::{Mmap, MmapMut, MmapOptions};
+    use num_traits::Signed;
+    use std::io::{self, Write};
+
+    #[cfg(unix)]
+    use nix::{sys::stat::fstat, unistd};
+    #[cfg(unix)]
+    use rustpython_common::crt_fd;
+
+    #[cfg(windows)]
+    use rustpython_common::suppress_iph;
+    #[cfg(windows)]
+    use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
+    #[cfg(windows)]
+    use windows_sys::Win32::{
+        Foundation::{
+            CloseHandle, DUPLICATE_SAME_ACCESS, DuplicateHandle, HANDLE, INVALID_HANDLE_VALUE,
+        },
+        Storage::FileSystem::{FILE_BEGIN, GetFileSize, SetEndOfFile, SetFilePointerEx},
+        System::Threading::GetCurrentProcess,
+    };
+
+    #[cfg(unix)]
+    fn validate_advice(vm: &VirtualMachine, advice: i32) -> PyResult<i32> {
+        match advice {
+            libc::MADV_NORMAL
+            | libc::MADV_RANDOM
+            | libc::MADV_SEQUENTIAL
+            | libc::MADV_WILLNEED
+            | libc::MADV_DONTNEED => Ok(advice),
+            #[cfg(any(
+                target_os = "linux",
+                target_os = "macos",
+                target_os = "ios",
+                target_os = "freebsd"
+            ))]
+            libc::MADV_FREE => Ok(advice),
+            #[cfg(target_os = "linux")]
+            libc::MADV_DONTFORK
+            | libc::MADV_DOFORK
+            | libc::MADV_MERGEABLE
+            | libc::MADV_UNMERGEABLE
+            | libc::MADV_HUGEPAGE
+            | libc::MADV_NOHUGEPAGE
+            | libc::MADV_REMOVE
+            | libc::MADV_DONTDUMP
+            | libc::MADV_DODUMP
+            | libc::MADV_HWPOISON => Ok(advice),
+            #[cfg(target_os = "freebsd")]
+            libc::MADV_NOSYNC
+            | libc::MADV_AUTOSYNC
+            | libc::MADV_NOCORE
+            | libc::MADV_CORE
+            | libc::MADV_PROTECT => Ok(advice),
+            _ => Err(vm.new_value_error("Not a valid Advice value")),
+        }
+    }
+
+    #[repr(C)]
+    #[derive(PartialEq, Eq, Debug)]
+    enum AccessMode {
+        Default = 0,
+        Read = 1,
+        Write = 2,
+        Copy = 3,
+    }
+
+    impl<'a> TryFromBorrowedObject<'a> for AccessMode {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+            let i = u32::try_from_borrowed_object(vm, obj)?;
+            Ok(match i {
+                0 => Self::Default,
+                1 => Self::Read,
+                2 => Self::Write,
+                3 => Self::Copy,
+                _ => return Err(vm.new_value_error("Not a valid AccessMode value")),
+            })
+        }
+    }
+
+    #[cfg(unix)]
+    #[pyattr]
+    use libc::{
+        MADV_DONTNEED, MADV_NORMAL, MADV_RANDOM, MADV_SEQUENTIAL, MADV_WILLNEED, MAP_ANON,
+        MAP_ANONYMOUS, MAP_PRIVATE, MAP_SHARED, PROT_EXEC, PROT_READ, PROT_WRITE,
+    };
+
+    #[cfg(target_os = "macos")]
+    #[pyattr]
+    use libc::{MADV_FREE_REUSABLE, MADV_FREE_REUSE};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "fuchsia",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use libc::MADV_FREE;
+
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    use libc::{
+        MADV_DODUMP, MADV_DOFORK, MADV_DONTDUMP, MADV_DONTFORK, MADV_HUGEPAGE, MADV_HWPOISON,
+        MADV_MERGEABLE, MADV_NOHUGEPAGE, MADV_REMOVE, MADV_UNMERGEABLE,
+    };
+
+    #[cfg(any(
+        target_os = "android",
+        all(
+            target_os = "linux",
+            any(
+                target_arch = "aarch64",
+                target_arch = "arm",
+                target_arch = "powerpc",
+                target_arch = "powerpc64",
+                target_arch = "s390x",
+                target_arch = "x86",
+                target_arch = "x86_64",
+                target_arch = "sparc64"
+            )
+        )
+    ))]
+    #[pyattr]
+    use libc::MADV_SOFT_OFFLINE;
+
+    #[cfg(all(target_os = "linux", target_arch = "x86_64", target_env = "gnu"))]
+    #[pyattr]
+    use libc::{MAP_DENYWRITE, MAP_EXECUTABLE, MAP_POPULATE};
+
+    // MAP_STACK is available on Linux, OpenBSD, and NetBSD
+    #[cfg(any(target_os = "linux", target_os = "openbsd", target_os = "netbsd"))]
+    #[pyattr]
+    use libc::MAP_STACK;
+
+    // FreeBSD-specific MADV constants
+    #[cfg(target_os = "freebsd")]
+    #[pyattr]
+    use libc::{MADV_AUTOSYNC, MADV_CORE, MADV_NOCORE, MADV_NOSYNC, MADV_PROTECT};
+
+    #[pyattr]
+    const ACCESS_DEFAULT: u32 = AccessMode::Default as u32;
+    #[pyattr]
+    const ACCESS_READ: u32 = AccessMode::Read as u32;
+    #[pyattr]
+    const ACCESS_WRITE: u32 = AccessMode::Write as u32;
+    #[pyattr]
+    const ACCESS_COPY: u32 = AccessMode::Copy as u32;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr(name = "PAGESIZE", once)]
+    fn page_size(_vm: &VirtualMachine) -> usize {
+        page_size::get()
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr(name = "ALLOCATIONGRANULARITY", once)]
+    fn granularity(_vm: &VirtualMachine) -> usize {
+        page_size::get_granularity()
+    }
+
+    #[pyattr(name = "error", once)]
+    fn error_type(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.exceptions.os_error.to_owned()
+    }
+
+    #[derive(Debug)]
+    enum MmapObj {
+        Write(MmapMut),
+        Read(Mmap),
+    }
+
+    impl MmapObj {
+        fn as_slice(&self) -> &[u8] {
+            match self {
+                MmapObj::Read(mmap) => &mmap[..],
+                MmapObj::Write(mmap) => &mmap[..],
+            }
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(name = "mmap")]
+    #[derive(Debug, PyPayload)]
+    struct PyMmap {
+        closed: AtomicCell<bool>,
+        mmap: PyMutex<Option<MmapObj>>,
+        #[cfg(unix)]
+        fd: AtomicCell<i32>,
+        #[cfg(windows)]
+        handle: AtomicCell<isize>, // HANDLE is isize on Windows
+        offset: i64,
+        size: AtomicCell<usize>,
+        pos: AtomicCell<usize>, // relative to offset
+        exports: AtomicCell<usize>,
+        access: AccessMode,
+    }
+
+    impl PyMmap {
+        /// Close the underlying file handle/descriptor if open
+        fn close_handle(&self) {
+            #[cfg(unix)]
+            {
+                let fd = self.fd.swap(-1);
+                if fd >= 0 {
+                    unsafe { libc::close(fd) };
+                }
+            }
+            #[cfg(windows)]
+            {
+                let handle = self.handle.swap(INVALID_HANDLE_VALUE as isize);
+                if handle != INVALID_HANDLE_VALUE as isize {
+                    unsafe { CloseHandle(handle as HANDLE) };
+                }
+            }
+        }
+    }
+
+    impl Drop for PyMmap {
+        fn drop(&mut self) {
+            self.close_handle();
+        }
+    }
+
+    #[cfg(unix)]
+    #[derive(FromArgs)]
+    struct MmapNewArgs {
+        #[pyarg(any)]
+        fileno: i32,
+        #[pyarg(any)]
+        length: isize,
+        #[pyarg(any, default = libc::MAP_SHARED)]
+        flags: libc::c_int,
+        #[pyarg(any, default = libc::PROT_WRITE | libc::PROT_READ)]
+        prot: libc::c_int,
+        #[pyarg(any, default = AccessMode::Default)]
+        access: AccessMode,
+        #[pyarg(any, default = 0)]
+        offset: i64,
+    }
+
+    #[cfg(windows)]
+    #[derive(FromArgs)]
+    struct MmapNewArgs {
+        #[pyarg(any)]
+        fileno: i32,
+        #[pyarg(any)]
+        length: isize,
+        #[pyarg(any, default)]
+        #[allow(dead_code)]
+        tagname: Option<PyObjectRef>,
+        #[pyarg(any, default = AccessMode::Default)]
+        access: AccessMode,
+        #[pyarg(any, default = 0)]
+        offset: i64,
+    }
+
+    impl MmapNewArgs {
+        /// Validate mmap constructor arguments
+        fn validate_new_args(&self, vm: &VirtualMachine) -> PyResult<usize> {
+            if self.length < 0 {
+                return Err(vm.new_overflow_error("memory mapped length must be positive"));
+            }
+            if self.offset < 0 {
+                return Err(vm.new_overflow_error("memory mapped offset must be positive"));
+            }
+            Ok(self.length as usize)
+        }
+    }
+
+    #[derive(FromArgs)]
+    pub struct FlushOptions {
+        #[pyarg(positional, default)]
+        offset: Option<isize>,
+        #[pyarg(positional, default)]
+        size: Option<isize>,
+    }
+
+    impl FlushOptions {
+        fn values(self, len: usize) -> Option<(usize, usize)> {
+            let offset = match self.offset {
+                Some(o) if o < 0 => return None,
+                Some(o) => o as usize,
+                None => 0,
+            };
+
+            let size = match self.size {
+                Some(s) if s < 0 => return None,
+                Some(s) => s as usize,
+                None => len,
+            };
+
+            if len.checked_sub(offset)? < size {
+                return None;
+            }
+
+            Some((offset, size))
+        }
+    }
+
+    #[derive(FromArgs, Clone)]
+    pub struct FindOptions {
+        #[pyarg(positional)]
+        sub: Vec<u8>,
+        #[pyarg(positional, default)]
+        start: Option<isize>,
+        #[pyarg(positional, default)]
+        end: Option<isize>,
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[derive(FromArgs)]
+    pub struct AdviseOptions {
+        #[pyarg(positional)]
+        option: libc::c_int,
+        #[pyarg(positional, default)]
+        start: Option<PyIntRef>,
+        #[pyarg(positional, default)]
+        length: Option<PyIntRef>,
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl AdviseOptions {
+        fn values(self, len: usize, vm: &VirtualMachine) -> PyResult<(libc::c_int, usize, usize)> {
+            let start = self
+                .start
+                .map(|s| {
+                    s.try_to_primitive::<usize>(vm)
+                        .ok()
+                        .filter(|s| *s < len)
+                        .ok_or_else(|| vm.new_value_error("madvise start out of bounds"))
+                })
+                .transpose()?
+                .unwrap_or(0);
+            let length = self
+                .length
+                .map(|s| {
+                    s.try_to_primitive::<usize>(vm)
+                        .map_err(|_| vm.new_value_error("madvise length invalid"))
+                })
+                .transpose()?
+                .unwrap_or(len);
+
+            if isize::MAX as usize - start < length {
+                return Err(vm.new_overflow_error("madvise length too large"));
+            }
+
+            let length = if start + length > len {
+                len - start
+            } else {
+                length
+            };
+
+            Ok((self.option, start, length))
+        }
+    }
+
+    impl Constructor for PyMmap {
+        type Args = MmapNewArgs;
+
+        #[cfg(unix)]
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            use libc::{MAP_PRIVATE, MAP_SHARED, PROT_READ, PROT_WRITE};
+
+            let mut map_size = args.validate_new_args(vm)?;
+            let MmapNewArgs {
+                fileno: fd,
+                flags,
+                prot,
+                access,
+                offset,
+                ..
+            } = args;
+
+            if (access != AccessMode::Default)
+                && ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ)))
+            {
+                return Err(vm.new_value_error("mmap can't specify both access and flags, prot."));
+            }
+
+            // TODO: memmap2 doesn't support mapping with prot and flags right now
+            let (_flags, _prot, access) = match access {
+                AccessMode::Read => (MAP_SHARED, PROT_READ, access),
+                AccessMode::Write => (MAP_SHARED, PROT_READ | PROT_WRITE, access),
+                AccessMode::Copy => (MAP_PRIVATE, PROT_READ | PROT_WRITE, access),
+                AccessMode::Default => {
+                    let access = if (prot & PROT_READ) != 0 && (prot & PROT_WRITE) != 0 {
+                        access
+                    } else if (prot & PROT_WRITE) != 0 {
+                        AccessMode::Write
+                    } else {
+                        AccessMode::Read
+                    };
+                    (flags, prot, access)
+                }
+            };
+
+            let fd = unsafe { crt_fd::Borrowed::try_borrow_raw(fd) };
+
+            // macOS: Issue #11277: fsync(2) is not enough on OS X - a special, OS X specific
+            // fcntl(2) is necessary to force DISKSYNC and get around mmap(2) bug
+            #[cfg(target_os = "macos")]
+            if let Ok(fd) = fd {
+                use std::os::fd::AsRawFd;
+                unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_FULLFSYNC) };
+            }
+
+            if let Ok(fd) = fd {
+                let metadata = fstat(fd)
+                    .map_err(|err| io::Error::from_raw_os_error(err as i32).to_pyexception(vm))?;
+                let file_len = metadata.st_size as i64;
+
+                if map_size == 0 {
+                    if file_len == 0 {
+                        return Err(vm.new_value_error("cannot mmap an empty file"));
+                    }
+
+                    if offset > file_len {
+                        return Err(vm.new_value_error("mmap offset is greater than file size"));
+                    }
+
+                    map_size = (file_len - offset)
+                        .try_into()
+                        .map_err(|_| vm.new_value_error("mmap length is too large"))?;
+                } else if offset > file_len || file_len - offset < map_size as i64 {
+                    return Err(vm.new_value_error("mmap length is greater than file size"));
+                }
+            }
+
+            let mut mmap_opt = MmapOptions::new();
+            let mmap_opt = mmap_opt.offset(offset as u64).len(map_size);
+
+            let (fd, mmap) = || -> std::io::Result<_> {
+                if let Ok(fd) = fd {
+                    let new_fd: crt_fd::Owned = unistd::dup(fd)?.into();
+                    let mmap = match access {
+                        AccessMode::Default | AccessMode::Write => {
+                            MmapObj::Write(unsafe { mmap_opt.map_mut(&new_fd) }?)
+                        }
+                        AccessMode::Read => MmapObj::Read(unsafe { mmap_opt.map(&new_fd) }?),
+                        AccessMode::Copy => MmapObj::Write(unsafe { mmap_opt.map_copy(&new_fd) }?),
+                    };
+                    Ok((Some(new_fd), mmap))
+                } else {
+                    let mmap = MmapObj::Write(mmap_opt.map_anon()?);
+                    Ok((None, mmap))
+                }
+            }()
+            .map_err(|e| e.to_pyexception(vm))?;
+
+            Ok(Self {
+                closed: AtomicCell::new(false),
+                mmap: PyMutex::new(Some(mmap)),
+                fd: AtomicCell::new(fd.map_or(-1, |fd| fd.into_raw())),
+                offset,
+                size: AtomicCell::new(map_size),
+                pos: AtomicCell::new(0),
+                exports: AtomicCell::new(0),
+                access,
+            })
+        }
+
+        #[cfg(windows)]
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            let mut map_size = args.validate_new_args(vm)?;
+            let MmapNewArgs {
+                fileno,
+                access,
+                offset,
+                ..
+            } = args;
+
+            // Get file handle from fileno
+            // fileno -1 or 0 means anonymous mapping
+            let fh: Option<HANDLE> = if fileno != -1 && fileno != 0 {
+                // Convert CRT file descriptor to Windows HANDLE
+                // Use suppress_iph! to avoid crashes when the fd is invalid.
+                // This is critical because socket fds wrapped via _open_osfhandle
+                // may cause crashes in _get_osfhandle on Windows.
+                // See Python bug https://bugs.python.org/issue30114
+                let handle = unsafe { suppress_iph!(libc::get_osfhandle(fileno)) };
+                // Check for invalid handle value (-1 on Windows)
+                if handle == -1 || handle == INVALID_HANDLE_VALUE as isize {
+                    return Err(vm.new_os_error(format!("Invalid file descriptor: {}", fileno)));
+                }
+                Some(handle as HANDLE)
+            } else {
+                None
+            };
+
+            // Get file size if we have a file handle and map_size is 0
+            let mut duplicated_handle: HANDLE = INVALID_HANDLE_VALUE;
+            if let Some(fh) = fh {
+                // Duplicate handle so Python code can close the original
+                let mut new_handle: HANDLE = INVALID_HANDLE_VALUE;
+                let result = unsafe {
+                    DuplicateHandle(
+                        GetCurrentProcess(),
+                        fh,
+                        GetCurrentProcess(),
+                        &mut new_handle,
+                        0,
+                        0, // not inheritable
+                        DUPLICATE_SAME_ACCESS,
+                    )
+                };
+                if result == 0 {
+                    return Err(io::Error::last_os_error().to_pyexception(vm));
+                }
+                duplicated_handle = new_handle;
+
+                // Get file size
+                let mut high: u32 = 0;
+                let low = unsafe { GetFileSize(fh, &mut high) };
+                if low == u32::MAX {
+                    let err = io::Error::last_os_error();
+                    if err.raw_os_error() != Some(0) {
+                        unsafe { CloseHandle(duplicated_handle) };
+                        return Err(err.to_pyexception(vm));
+                    }
+                }
+                let file_len = ((high as i64) << 32) | (low as i64);
+
+                if map_size == 0 {
+                    if file_len == 0 {
+                        unsafe { CloseHandle(duplicated_handle) };
+                        return Err(vm.new_value_error("cannot mmap an empty file"));
+                    }
+                    if offset >= file_len {
+                        unsafe { CloseHandle(duplicated_handle) };
+                        return Err(vm.new_value_error("mmap offset is greater than file size"));
+                    }
+                    if file_len - offset > isize::MAX as i64 {
+                        unsafe { CloseHandle(duplicated_handle) };
+                        return Err(vm.new_value_error("mmap length is too large"));
+                    }
+                    map_size = (file_len - offset) as usize;
+                } else {
+                    // If map_size > file_len, extend the file (Windows behavior)
+                    let required_size = offset.checked_add(map_size as i64).ok_or_else(|| {
+                        unsafe { CloseHandle(duplicated_handle) };
+                        vm.new_overflow_error("mmap size would cause file size overflow")
+                    })?;
+                    if required_size > file_len {
+                        // Extend file using SetFilePointerEx + SetEndOfFile
+                        let result = unsafe {
+                            SetFilePointerEx(
+                                duplicated_handle,
+                                required_size,
+                                std::ptr::null_mut(),
+                                FILE_BEGIN,
+                            )
+                        };
+                        if result == 0 {
+                            let err = io::Error::last_os_error();
+                            unsafe { CloseHandle(duplicated_handle) };
+                            return Err(err.to_pyexception(vm));
+                        }
+                        let result = unsafe { SetEndOfFile(duplicated_handle) };
+                        if result == 0 {
+                            let err = io::Error::last_os_error();
+                            unsafe { CloseHandle(duplicated_handle) };
+                            return Err(err.to_pyexception(vm));
+                        }
+                    }
+                }
+            }
+
+            let mut mmap_opt = MmapOptions::new();
+            let mmap_opt = mmap_opt.offset(offset as u64).len(map_size);
+
+            let (handle, mmap) = if duplicated_handle != INVALID_HANDLE_VALUE {
+                // Safety: We just duplicated this handle and it's valid
+                let owned_handle =
+                    unsafe { OwnedHandle::from_raw_handle(duplicated_handle as RawHandle) };
+
+                let mmap_result = match access {
+                    AccessMode::Default | AccessMode::Write => {
+                        unsafe { mmap_opt.map_mut(&owned_handle) }.map(MmapObj::Write)
+                    }
+                    AccessMode::Read => unsafe { mmap_opt.map(&owned_handle) }.map(MmapObj::Read),
+                    AccessMode::Copy => {
+                        unsafe { mmap_opt.map_copy(&owned_handle) }.map(MmapObj::Write)
+                    }
+                };
+
+                let mmap = mmap_result.map_err(|e| e.to_pyexception(vm))?;
+
+                // Keep the handle alive
+                let raw = owned_handle.as_raw_handle() as isize;
+                std::mem::forget(owned_handle);
+                (raw, mmap)
+            } else {
+                // Anonymous mapping
+                let mmap = mmap_opt.map_anon().map_err(|e| e.to_pyexception(vm))?;
+                (INVALID_HANDLE_VALUE as isize, MmapObj::Write(mmap))
+            };
+
+            Ok(Self {
+                closed: AtomicCell::new(false),
+                mmap: PyMutex::new(Some(mmap)),
+                handle: AtomicCell::new(handle),
+                offset,
+                size: AtomicCell::new(map_size),
+                pos: AtomicCell::new(0),
+                exports: AtomicCell::new(0),
+                access,
+            })
+        }
+    }
+
+    static BUFFER_METHODS: BufferMethods = BufferMethods {
+        obj_bytes: |buffer| buffer.obj_as::<PyMmap>().as_bytes(),
+        obj_bytes_mut: |buffer| buffer.obj_as::<PyMmap>().as_bytes_mut(),
+        release: |buffer| {
+            buffer.obj_as::<PyMmap>().exports.fetch_sub(1);
+        },
+        retain: |buffer| {
+            buffer.obj_as::<PyMmap>().exports.fetch_add(1);
+        },
+    };
+
+    impl AsBuffer for PyMmap {
+        fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+            let readonly = matches!(zelf.access, AccessMode::Read);
+            let buf = PyBuffer::new(
+                zelf.to_owned().into(),
+                BufferDescriptor::simple(zelf.__len__(), readonly),
+                &BUFFER_METHODS,
+            );
+
+            Ok(buf)
+        }
+    }
+
+    impl AsMapping for PyMmap {
+        fn as_mapping() -> &'static PyMappingMethods {
+            static AS_MAPPING: PyMappingMethods = PyMappingMethods {
+                length: atomic_func!(
+                    |mapping, _vm| Ok(PyMmap::mapping_downcast(mapping).__len__())
+                ),
+                subscript: atomic_func!(|mapping, needle, vm| {
+                    PyMmap::mapping_downcast(mapping).getitem_inner(needle, vm)
+                }),
+                ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                    let zelf = PyMmap::mapping_downcast(mapping);
+                    if let Some(value) = value {
+                        PyMmap::setitem_inner(zelf, needle, value, vm)
+                    } else {
+                        Err(vm
+                            .new_type_error("mmap object doesn't support item deletion".to_owned()))
+                    }
+                }),
+            };
+            &AS_MAPPING
+        }
+    }
+
+    impl AsSequence for PyMmap {
+        fn as_sequence() -> &'static PySequenceMethods {
+            use std::sync::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| {
+                    let zelf = PyMmap::sequence_downcast(seq);
+                    zelf.getitem_by_index(i, vm)
+                }),
+                ass_item: atomic_func!(|seq, i, value, vm| {
+                    let zelf = PyMmap::sequence_downcast(seq);
+                    if let Some(value) = value {
+                        PyMmap::setitem_by_index(zelf, i, value, vm)
+                    } else {
+                        Err(vm
+                            .new_type_error("mmap object doesn't support item deletion".to_owned()))
+                    }
+                }),
+                ..PySequenceMethods::NOT_IMPLEMENTED
+            });
+            &AS_SEQUENCE
+        }
+    }
+
+    #[pyclass(
+        with(Constructor, AsMapping, AsSequence, AsBuffer, Representable),
+        flags(BASETYPE)
+    )]
+    impl PyMmap {
+        fn as_bytes_mut(&self) -> BorrowedValueMut<'_, [u8]> {
+            PyMutexGuard::map(self.mmap.lock(), |m| {
+                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[..],
+                }
+            })
+            .into()
+        }
+
+        fn as_bytes(&self) -> BorrowedValue<'_, [u8]> {
+            PyMutexGuard::map_immutable(self.mmap.lock(), |m| {
+                m.as_ref().expect("mmap closed or invalid").as_slice()
+            })
+            .into()
+        }
+
+        fn __len__(&self) -> usize {
+            self.size.load()
+        }
+
+        #[inline]
+        fn pos(&self) -> usize {
+            self.pos.load()
+        }
+
+        #[inline]
+        fn advance_pos(&self, step: usize) {
+            self.pos.store(self.pos() + step);
+        }
+
+        #[inline]
+        fn try_writable<R>(
+            &self,
+            vm: &VirtualMachine,
+            f: impl FnOnce(&mut MmapMut) -> 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"),
+            }
+        }
+
+        fn check_valid(&self, vm: &VirtualMachine) -> PyResult<PyMutexGuard<'_, Option<MmapObj>>> {
+            let m = self.mmap.lock();
+
+            if m.is_none() {
+                return Err(vm.new_value_error("mmap closed or invalid"));
+            }
+
+            Ok(m)
+        }
+
+        /// TODO: impl resize
+        #[allow(dead_code)]
+        fn check_resizeable(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.exports.load() > 0 {
+                return Err(vm.new_buffer_error("mmap can't resize with extant buffers exported."));
+            }
+
+            if self.access == AccessMode::Write || self.access == AccessMode::Default {
+                return Ok(());
+            }
+
+            Err(vm.new_type_error("mmap can't resize a readonly or copy-on-write memory map."))
+        }
+
+        #[pygetset]
+        fn closed(&self) -> bool {
+            self.closed.load()
+        }
+
+        #[pymethod]
+        fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.closed() {
+                return Ok(());
+            }
+
+            if self.exports.load() > 0 {
+                return Err(vm.new_buffer_error("cannot close exported pointers exist."));
+            }
+
+            let mut mmap = self.mmap.lock();
+            self.closed.store(true);
+            *mmap = None;
+
+            self.close_handle();
+
+            Ok(())
+        }
+
+        fn get_find_range(&self, options: FindOptions) -> (usize, usize) {
+            let size = self.__len__();
+            let start = options
+                .start
+                .map(|start| start.saturated_at(size))
+                .unwrap_or_else(|| self.pos());
+            let end = options
+                .end
+                .map(|end| end.saturated_at(size))
+                .unwrap_or(size);
+            (start, end)
+        }
+
+        #[pymethod]
+        fn find(&self, options: FindOptions, vm: &VirtualMachine) -> PyResult<PyInt> {
+            let (start, end) = self.get_find_range(options.clone());
+
+            let sub = &options.sub;
+
+            // returns start position for empty string
+            if sub.is_empty() {
+                return Ok(PyInt::from(start as isize));
+            }
+
+            let mmap = self.check_valid(vm)?;
+            let buf = &mmap.as_ref().unwrap().as_slice()[start..end];
+            let pos = buf.windows(sub.len()).position(|window| window == sub);
+
+            Ok(pos.map_or(PyInt::from(-1isize), |i| PyInt::from(start + i)))
+        }
+
+        #[pymethod]
+        fn rfind(&self, options: FindOptions, vm: &VirtualMachine) -> PyResult<PyInt> {
+            let (start, end) = self.get_find_range(options.clone());
+
+            let sub = &options.sub;
+            // returns start position for empty string
+            if sub.is_empty() {
+                return Ok(PyInt::from(start as isize));
+            }
+
+            let mmap = self.check_valid(vm)?;
+            let buf = &mmap.as_ref().unwrap().as_slice()[start..end];
+            let pos = buf.windows(sub.len()).rposition(|window| window == sub);
+
+            Ok(pos.map_or(PyInt::from(-1isize), |i| PyInt::from(start + i)))
+        }
+
+        #[pymethod]
+        fn flush(&self, options: FlushOptions, vm: &VirtualMachine) -> PyResult<()> {
+            let (offset, size) = options
+                .values(self.__len__())
+                .ok_or_else(|| vm.new_value_error("flush values out of range"))?;
+
+            if self.access == AccessMode::Read || self.access == AccessMode::Copy {
+                return Ok(());
+            }
+
+            match self.check_valid(vm)?.deref().as_ref().unwrap() {
+                MmapObj::Read(_mmap) => {}
+                MmapObj::Write(mmap) => {
+                    mmap.flush_range(offset, size)
+                        .map_err(|e| e.to_pyexception(vm))?;
+                }
+            }
+
+            Ok(())
+        }
+
+        #[cfg(all(unix, not(target_os = "redox")))]
+        #[pymethod]
+        fn madvise(&self, options: AdviseOptions, vm: &VirtualMachine) -> PyResult<()> {
+            let (option, start, length) = options.values(self.__len__(), vm)?;
+            let advice = validate_advice(vm, option)?;
+
+            let guard = self.check_valid(vm)?;
+            let mmap = guard.deref().as_ref().unwrap();
+            let ptr = match mmap {
+                MmapObj::Read(m) => m.as_ptr(),
+                MmapObj::Write(m) => m.as_ptr(),
+            };
+
+            // Apply madvise to the specified range (start, length)
+            let ptr_with_offset = unsafe { ptr.add(start) };
+            let result =
+                unsafe { libc::madvise(ptr_with_offset as *mut libc::c_void, length, advice) };
+            if result != 0 {
+                return Err(io::Error::last_os_error().to_pyexception(vm));
+            }
+
+            Ok(())
+        }
+
+        #[pymethod(name = "move")]
+        fn move_(
+            &self,
+            dest: PyIntRef,
+            src: PyIntRef,
+            cnt: PyIntRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            fn args(
+                dest: PyIntRef,
+                src: PyIntRef,
+                cnt: PyIntRef,
+                size: usize,
+                vm: &VirtualMachine,
+            ) -> Option<(usize, usize, usize)> {
+                if dest.as_bigint().is_negative()
+                    || src.as_bigint().is_negative()
+                    || cnt.as_bigint().is_negative()
+                {
+                    return None;
+                }
+                let dest = dest.try_to_primitive(vm).ok()?;
+                let src = src.try_to_primitive(vm).ok()?;
+                let cnt = cnt.try_to_primitive(vm).ok()?;
+                if size - dest < cnt || size - src < cnt {
+                    return None;
+                }
+                Some((dest, src, cnt))
+            }
+
+            let size = self.__len__();
+            let (dest, src, cnt) = args(dest, src, cnt, size, vm)
+                .ok_or_else(|| vm.new_value_error("source, destination, or count out of range"))?;
+
+            let dest_end = dest + cnt;
+            let src_end = src + cnt;
+
+            self.try_writable(vm, |mmap| {
+                let src_buf = mmap[src..src_end].to_vec();
+                (&mut mmap[dest..dest_end])
+                    .write(&src_buf)
+                    .map_err(|e| e.to_pyexception(vm))?;
+                Ok(())
+            })?
+        }
+
+        #[pymethod]
+        fn read(&self, n: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+            let num_bytes = n
+                .map(|obj| {
+                    let class = obj.class().to_owned();
+                    obj.try_into_value::<Option<isize>>(vm).map_err(|_| {
+                        vm.new_type_error(format!(
+                            "read argument must be int or None, not {}",
+                            class.name()
+                        ))
+                    })
+                })
+                .transpose()?
+                .flatten();
+            let mmap = self.check_valid(vm)?;
+            let pos = self.pos();
+            let remaining = self.__len__().saturating_sub(pos);
+            let num_bytes = num_bytes
+                .filter(|&n| n >= 0 && (n as usize) <= remaining)
+                .map(|n| n as usize)
+                .unwrap_or(remaining);
+
+            let end_pos = pos + num_bytes;
+            let bytes = mmap.deref().as_ref().unwrap().as_slice()[pos..end_pos].to_vec();
+
+            let result = PyBytes::from(bytes).into_ref(&vm.ctx);
+
+            self.advance_pos(num_bytes);
+
+            Ok(result)
+        }
+
+        #[pymethod]
+        fn read_byte(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+            let pos = self.pos();
+            if pos >= self.__len__() {
+                return Err(vm.new_value_error("read byte out of range"));
+            }
+
+            let b = self.check_valid(vm)?.deref().as_ref().unwrap().as_slice()[pos];
+
+            self.advance_pos(1);
+
+            Ok(PyInt::from(b).into_ref(&vm.ctx))
+        }
+
+        #[pymethod]
+        fn readline(&self, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+            let pos = self.pos();
+            let mmap = self.check_valid(vm)?;
+
+            let remaining = self.__len__().saturating_sub(pos);
+            if remaining == 0 {
+                return Ok(PyBytes::from(vec![]).into_ref(&vm.ctx));
+            }
+
+            let slice = mmap.as_ref().unwrap().as_slice();
+            let eof = slice[pos..].iter().position(|&x| x == b'\n');
+
+            let end_pos = if let Some(i) = eof {
+                pos + i + 1
+            } else {
+                self.__len__()
+            };
+
+            let bytes = slice[pos..end_pos].to_vec();
+
+            let result = PyBytes::from(bytes).into_ref(&vm.ctx);
+
+            self.advance_pos(end_pos - pos);
+
+            Ok(result)
+        }
+
+        #[cfg(unix)]
+        #[pymethod]
+        fn resize(&self, _newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> {
+            self.check_resizeable(vm)?;
+            // TODO: implement using mremap on Linux
+            Err(vm.new_system_error("mmap: resizing not available--no mremap()"))
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn resize(&self, newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> {
+            self.check_resizeable(vm)?;
+
+            let newsize: usize = newsize
+                .try_to_primitive(vm)
+                .map_err(|_| vm.new_value_error("new size out of range"))?;
+
+            if newsize == 0 {
+                return Err(vm.new_value_error("new size must be positive"));
+            }
+
+            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();
+
+            if is_anonymous {
+                // For anonymous mmap, we need to:
+                // 1. Create a new anonymous mmap with the new size
+                // 2. Copy data from old mmap to new mmap
+                // 3. Replace the old mmap
+
+                let old_size = self.size.load();
+                let copy_size = core::cmp::min(old_size, newsize);
+
+                // Create new anonymous mmap
+                let mut new_mmap_opts = MmapOptions::new();
+                let mut new_mmap = new_mmap_opts
+                    .len(newsize)
+                    .map_anon()
+                    .map_err(|e| e.to_pyexception(vm))?;
+
+                // 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],
+                    };
+                    new_mmap[..copy_size].copy_from_slice(src);
+                }
+
+                *mmap_guard = Some(MmapObj::Write(new_mmap));
+                self.size.store(newsize);
+            } else {
+                // File-backed mmap resize
+
+                // Drop the current mmap to release the file mapping
+                *mmap_guard = None;
+
+                // Resize the file
+                let required_size = self.offset + newsize as i64;
+                let result = unsafe {
+                    SetFilePointerEx(
+                        handle as HANDLE,
+                        required_size,
+                        std::ptr::null_mut(),
+                        FILE_BEGIN,
+                    )
+                };
+                if result == 0 {
+                    // Restore original mmap on error
+                    let err = io::Error::last_os_error();
+                    self.try_restore_mmap(&mut mmap_guard, handle as HANDLE, self.size.load());
+                    return Err(err.to_pyexception(vm));
+                }
+
+                let result = unsafe { SetEndOfFile(handle as HANDLE) };
+                if result == 0 {
+                    let err = io::Error::last_os_error();
+                    self.try_restore_mmap(&mut mmap_guard, handle as HANDLE, self.size.load());
+                    return Err(err.to_pyexception(vm));
+                }
+
+                // Create new mmap with the new size
+                let new_mmap =
+                    Self::create_mmap_windows(handle as HANDLE, self.offset, newsize, &self.access)
+                        .map_err(|e| e.to_pyexception(vm))?;
+
+                *mmap_guard = Some(new_mmap);
+                self.size.store(newsize);
+            }
+
+            // Adjust position if it's beyond the new size
+            let pos = self.pos.load();
+            if pos > newsize {
+                self.pos.store(newsize);
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn seek(
+            &self,
+            dist: isize,
+            whence: OptionalArg<libc::c_int>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let how = whence.unwrap_or(0);
+            let size = self.__len__();
+
+            let new_pos = match how {
+                0 => dist, // relative to start
+                1 => {
+                    // relative to current position
+                    let pos = self.pos();
+                    if (((isize::MAX as usize) - pos) as isize) < dist {
+                        return Err(vm.new_value_error("seek out of range"));
+                    }
+                    pos as isize + dist
+                }
+                2 => {
+                    // relative to end
+                    if (((isize::MAX as usize) - size) as isize) < dist {
+                        return Err(vm.new_value_error("seek out of range"));
+                    }
+                    size as isize + dist
+                }
+                _ => return Err(vm.new_value_error("unknown seek type")),
+            };
+
+            if new_pos < 0 || (new_pos as usize) > size {
+                return Err(vm.new_value_error("seek out of range"));
+            }
+
+            self.pos.store(new_pos as usize);
+
+            Ok(())
+        }
+
+        #[cfg(unix)]
+        #[pymethod]
+        fn size(&self, vm: &VirtualMachine) -> std::io::Result<PyIntRef> {
+            let fd = unsafe { crt_fd::Borrowed::try_borrow_raw(self.fd.load())? };
+            let file_len = fstat(fd)?.st_size;
+            Ok(PyInt::from(file_len).into_ref(&vm.ctx))
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn size(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+            let handle = self.handle.load();
+            if handle == INVALID_HANDLE_VALUE as isize {
+                // Anonymous mapping, return the mmap size
+                return Ok(PyInt::from(self.__len__()).into_ref(&vm.ctx));
+            }
+
+            let mut high: u32 = 0;
+            let low = unsafe { GetFileSize(handle as HANDLE, &mut high) };
+            if low == u32::MAX {
+                let err = io::Error::last_os_error();
+                if err.raw_os_error() != Some(0) {
+                    return Err(err.to_pyexception(vm));
+                }
+            }
+            let file_len = ((high as i64) << 32) | (low as i64);
+            Ok(PyInt::from(file_len).into_ref(&vm.ctx))
+        }
+
+        #[pymethod]
+        fn tell(&self) -> PyResult<usize> {
+            Ok(self.pos())
+        }
+
+        #[pymethod]
+        fn write(&self, bytes: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+            let pos = self.pos();
+            let size = self.__len__();
+
+            let data = bytes.borrow_buf();
+
+            if pos > size || size - pos < data.len() {
+                return Err(vm.new_value_error("data out of range"));
+            }
+
+            let len = self.try_writable(vm, |mmap| {
+                (&mut mmap[pos..(pos + data.len())])
+                    .write(&data)
+                    .map_err(|err| err.to_pyexception(vm))?;
+                Ok(data.len())
+            })??;
+
+            self.advance_pos(len);
+
+            Ok(PyInt::from(len).into_ref(&vm.ctx))
+        }
+
+        #[pymethod]
+        fn write_byte(&self, byte: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let b = value_from_object(vm, &byte)?;
+
+            let pos = self.pos();
+            let size = self.__len__();
+
+            if pos >= size {
+                return Err(vm.new_value_error("write byte out of range"));
+            }
+
+            self.try_writable(vm, |mmap| {
+                mmap[pos] = b;
+            })?;
+
+            self.advance_pos(1);
+
+            Ok(())
+        }
+
+        fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            self.getitem_inner(&needle, vm)
+        }
+
+        fn __setitem__(
+            zelf: &Py<Self>,
+            needle: PyObjectRef,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            Self::setitem_inner(zelf, &needle, value, vm)
+        }
+
+        #[pymethod]
+        fn __enter__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            let _m = zelf.check_valid(vm)?;
+            Ok(zelf.to_owned())
+        }
+
+        #[pymethod]
+        fn __exit__(zelf: &Py<Self>, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.close(vm)
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn __sizeof__(&self) -> usize {
+            std::mem::size_of::<Self>()
+        }
+    }
+
+    impl PyMmap {
+        #[cfg(windows)]
+        fn create_mmap_windows(
+            handle: HANDLE,
+            offset: i64,
+            size: usize,
+            access: &AccessMode,
+        ) -> io::Result<MmapObj> {
+            use std::fs::File;
+
+            // Create an owned handle wrapper for memmap2
+            // We need to create a File from the handle
+            let file = unsafe { File::from_raw_handle(handle as RawHandle) };
+
+            let mut mmap_opt = MmapOptions::new();
+            let mmap_opt = mmap_opt.offset(offset as u64).len(size);
+
+            let result = match access {
+                AccessMode::Default | AccessMode::Write => {
+                    unsafe { mmap_opt.map_mut(&file) }.map(MmapObj::Write)
+                }
+                AccessMode::Read => unsafe { mmap_opt.map(&file) }.map(MmapObj::Read),
+                AccessMode::Copy => unsafe { mmap_opt.map_copy(&file) }.map(MmapObj::Write),
+            };
+
+            // Don't close the file handle - we're borrowing it
+            std::mem::forget(file);
+
+            result
+        }
+
+        /// Try to restore mmap after a failed resize operation.
+        /// Returns true if restoration succeeded, false otherwise.
+        /// If restoration fails, marks the mmap as closed.
+        #[cfg(windows)]
+        fn try_restore_mmap(&self, mmap_guard: &mut Option<MmapObj>, handle: HANDLE, size: usize) {
+            match Self::create_mmap_windows(handle, self.offset, size, &self.access) {
+                Ok(mmap) => *mmap_guard = Some(mmap),
+                Err(_) => self.closed.store(true),
+            }
+        }
+
+        fn getitem_by_index(&self, i: isize, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            let i = i
+                .wrapped_at(self.__len__())
+                .ok_or_else(|| vm.new_index_error("mmap index out of range"))?;
+
+            let b = self.check_valid(vm)?.deref().as_ref().unwrap().as_slice()[i];
+
+            Ok(PyInt::from(b).into_ref(&vm.ctx).into())
+        }
+
+        fn getitem_by_slice(
+            &self,
+            slice: &SaturatedSlice,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let (range, step, slice_len) = slice.adjust_indices(self.__len__());
+
+            let mmap = self.check_valid(vm)?;
+            let slice_data = mmap.deref().as_ref().unwrap().as_slice();
+
+            if slice_len == 0 {
+                return Ok(PyBytes::from(vec![]).into_ref(&vm.ctx).into());
+            } else if step == 1 {
+                return Ok(PyBytes::from(slice_data[range].to_vec())
+                    .into_ref(&vm.ctx)
+                    .into());
+            }
+
+            let mut result_buf = Vec::with_capacity(slice_len);
+            if step.is_negative() {
+                for i in range.rev().step_by(step.unsigned_abs()) {
+                    result_buf.push(slice_data[i]);
+                }
+            } else {
+                for i in range.step_by(step.unsigned_abs()) {
+                    result_buf.push(slice_data[i]);
+                }
+            }
+            Ok(PyBytes::from(result_buf).into_ref(&vm.ctx).into())
+        }
+
+        fn getitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "mmap")? {
+                SequenceIndex::Int(i) => self.getitem_by_index(i, vm),
+                SequenceIndex::Slice(slice) => self.getitem_by_slice(&slice, vm),
+            }
+        }
+
+        fn setitem_inner(
+            zelf: &Py<Self>,
+            needle: &PyObject,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "mmap")? {
+                SequenceIndex::Int(i) => Self::setitem_by_index(zelf, i, value, vm),
+                SequenceIndex::Slice(slice) => Self::setitem_by_slice(zelf, &slice, value, vm),
+            }
+        }
+
+        fn setitem_by_index(
+            &self,
+            i: isize,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let i: usize = i
+                .wrapped_at(self.__len__())
+                .ok_or_else(|| vm.new_index_error("mmap index out of range"))?;
+
+            let b = value_from_object(vm, &value)?;
+
+            self.try_writable(vm, |mmap| {
+                mmap[i] = b;
+            })?;
+
+            Ok(())
+        }
+
+        fn setitem_by_slice(
+            &self,
+            slice: &SaturatedSlice,
+            value: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let (range, step, slice_len) = slice.adjust_indices(self.__len__());
+
+            let bytes = bytes_from_object(vm, &value)?;
+
+            if bytes.len() != slice_len {
+                return Err(vm.new_index_error("mmap slice assignment is wrong size"));
+            }
+
+            if slice_len == 0 {
+                // do nothing
+                Ok(())
+            } else if step == 1 {
+                self.try_writable(vm, |mmap| {
+                    (&mut mmap[range])
+                        .write(&bytes)
+                        .map_err(|err| err.to_pyexception(vm))?;
+                    Ok(())
+                })?
+            } else {
+                let mut bi = 0; // bytes index
+                if step.is_negative() {
+                    for i in range.rev().step_by(step.unsigned_abs()) {
+                        self.try_writable(vm, |mmap| {
+                            mmap[i] = bytes[bi];
+                        })?;
+                        bi += 1;
+                    }
+                } else {
+                    for i in range.step_by(step.unsigned_abs()) {
+                        self.try_writable(vm, |mmap| {
+                            mmap[i] = bytes[bi];
+                        })?;
+                        bi += 1;
+                    }
+                }
+                Ok(())
+            }
+        }
+    }
+
+    impl Representable for PyMmap {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            let mmap = zelf.mmap.lock();
+
+            if mmap.is_none() {
+                return Ok("<mmap.mmap closed=True>".to_owned());
+            }
+
+            let access_str = match zelf.access {
+                AccessMode::Default => "ACCESS_DEFAULT",
+                AccessMode::Read => "ACCESS_READ",
+                AccessMode::Write => "ACCESS_WRITE",
+                AccessMode::Copy => "ACCESS_COPY",
+            };
+
+            let repr = format!(
+                "<mmap.mmap closed=False, access={}, length={}, pos={}, offset={}>",
+                access_str,
+                zelf.__len__(),
+                zelf.pos(),
+                zelf.offset
+            );
+
+            Ok(repr)
+        }
+    }
+}
diff --git a/crates/stdlib/src/multiprocessing.rs b/crates/stdlib/src/multiprocessing.rs
new file mode 100644
index 0000000000..bda13e6191
--- /dev/null
+++ b/crates/stdlib/src/multiprocessing.rs
@@ -0,0 +1,743 @@
+pub(crate) use _multiprocessing::make_module;
+
+#[cfg(windows)]
+#[pymodule]
+mod _multiprocessing {
+    use crate::vm::{PyResult, VirtualMachine, function::ArgBytesLike};
+    use windows_sys::Win32::Networking::WinSock::{self, SOCKET};
+
+    #[pyfunction]
+    fn closesocket(socket: usize, vm: &VirtualMachine) -> PyResult<()> {
+        let res = unsafe { WinSock::closesocket(socket as SOCKET) };
+        if res != 0 {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    #[pyfunction]
+    fn recv(socket: usize, size: usize, vm: &VirtualMachine) -> PyResult<libc::c_int> {
+        let mut buf = vec![0; 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)
+        }
+    }
+
+    #[pyfunction]
+    fn send(socket: usize, buf: ArgBytesLike, vm: &VirtualMachine) -> PyResult<libc::c_int> {
+        let ret = buf.with_ref(|b| unsafe {
+            WinSock::send(socket as SOCKET, b.as_ptr() as *const _, b.len() as i32, 0)
+        });
+        if ret < 0 {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(ret)
+        }
+    }
+}
+
+// Unix platforms (Linux, macOS, etc.)
+// macOS has broken sem_timedwait/sem_getvalue - we use polled fallback
+#[cfg(unix)]
+#[pymodule]
+mod _multiprocessing {
+    use crate::vm::{
+        Context, FromArgs, Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyDict, PyType, PyTypeRef},
+        function::{FuncArgs, KwArgs},
+        types::Constructor,
+    };
+    use libc::sem_t;
+    use nix::errno::Errno;
+    use std::{
+        ffi::CString,
+        sync::atomic::{AtomicI32, AtomicU64, Ordering},
+    };
+
+    /// Error type for sem_timedwait operations
+    #[cfg(target_vendor = "apple")]
+    enum SemWaitError {
+        Timeout,
+        SignalException(PyBaseExceptionRef),
+        OsError(Errno),
+    }
+
+    /// macOS fallback for sem_timedwait using select + sem_trywait polling
+    /// Matches sem_timedwait_save in semaphore.c
+    #[cfg(target_vendor = "apple")]
+    fn sem_timedwait_polled(
+        sem: *mut sem_t,
+        deadline: &libc::timespec,
+        vm: &VirtualMachine,
+    ) -> Result<(), SemWaitError> {
+        let mut delay: u64 = 0;
+
+        loop {
+            // poll: try to acquire
+            if unsafe { libc::sem_trywait(sem) } == 0 {
+                return Ok(());
+            }
+            let err = Errno::last();
+            if err != Errno::EAGAIN {
+                return Err(SemWaitError::OsError(err));
+            }
+
+            // get current time
+            let mut now = libc::timeval {
+                tv_sec: 0,
+                tv_usec: 0,
+            };
+            if unsafe { libc::gettimeofday(&mut now, std::ptr::null_mut()) } < 0 {
+                return Err(SemWaitError::OsError(Errno::last()));
+            }
+
+            // check for timeout
+            let deadline_usec = deadline.tv_sec * 1_000_000 + deadline.tv_nsec / 1000;
+            #[allow(clippy::unnecessary_cast)]
+            let now_usec = now.tv_sec as i64 * 1_000_000 + now.tv_usec as i64;
+
+            if now_usec >= deadline_usec {
+                return Err(SemWaitError::Timeout);
+            }
+
+            // calculate how much time is left
+            let difference = (deadline_usec - now_usec) as u64;
+
+            // check delay not too long -- maximum is 20 msecs
+            delay += 1000;
+            if delay > 20000 {
+                delay = 20000;
+            }
+            if delay > difference {
+                delay = difference;
+            }
+
+            // sleep using select
+            let mut tv_delay = libc::timeval {
+                tv_sec: (delay / 1_000_000) as _,
+                tv_usec: (delay % 1_000_000) as _,
+            };
+            unsafe {
+                libc::select(
+                    0,
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    &mut tv_delay,
+                )
+            };
+
+            // check for signals - preserve the exception (e.g., KeyboardInterrupt)
+            if let Err(exc) = vm.check_signals() {
+                return Err(SemWaitError::SignalException(exc));
+            }
+        }
+    }
+
+    // These match the values in Lib/multiprocessing/synchronize.py
+    const RECURSIVE_MUTEX: i32 = 0;
+    const SEMAPHORE: i32 = 1;
+
+    // #define ISMINE(o) (o->count > 0 && PyThread_get_thread_ident() == o->last_tid)
+    macro_rules! ismine {
+        ($self:expr) => {
+            $self.count.load(Ordering::Acquire) > 0
+                && $self.last_tid.load(Ordering::Acquire) == current_thread_id()
+        };
+    }
+
+    #[derive(FromArgs)]
+    struct SemLockNewArgs {
+        #[pyarg(positional)]
+        kind: i32,
+        #[pyarg(positional)]
+        value: i32,
+        #[pyarg(positional)]
+        maxvalue: i32,
+        #[pyarg(positional)]
+        name: String,
+        #[pyarg(positional)]
+        unlink: bool,
+    }
+
+    #[pyattr]
+    #[pyclass(name = "SemLock", module = "_multiprocessing")]
+    #[derive(Debug, PyPayload)]
+    struct SemLock {
+        handle: SemHandle,
+        kind: i32,
+        maxvalue: i32,
+        name: Option<String>,
+        last_tid: AtomicU64, // unsigned long
+        count: AtomicI32,    // int
+    }
+
+    #[derive(Debug)]
+    struct SemHandle {
+        raw: *mut sem_t,
+    }
+
+    unsafe impl Send for SemHandle {}
+    unsafe impl Sync for SemHandle {}
+
+    impl SemHandle {
+        fn create(
+            name: &str,
+            value: u32,
+            unlink: bool,
+            vm: &VirtualMachine,
+        ) -> PyResult<(Self, Option<String>)> {
+            let cname = semaphore_name(vm, name)?;
+            // SEM_CREATE(name, val, max) sem_open(name, O_CREAT | O_EXCL, 0600, val)
+            let raw = unsafe {
+                libc::sem_open(cname.as_ptr(), libc::O_CREAT | libc::O_EXCL, 0o600, value)
+            };
+            if raw == libc::SEM_FAILED {
+                let err = Errno::last();
+                return Err(os_error(vm, err));
+            }
+            if unlink {
+                // SEM_UNLINK(name) sem_unlink(name)
+                unsafe {
+                    libc::sem_unlink(cname.as_ptr());
+                }
+                Ok((SemHandle { raw }, None))
+            } else {
+                Ok((SemHandle { raw }, Some(name.to_owned())))
+            }
+        }
+
+        fn open_existing(name: &str, vm: &VirtualMachine) -> PyResult<Self> {
+            let cname = semaphore_name(vm, name)?;
+            let raw = unsafe { libc::sem_open(cname.as_ptr(), 0) };
+            if raw == libc::SEM_FAILED {
+                let err = Errno::last();
+                return Err(os_error(vm, err));
+            }
+            Ok(SemHandle { raw })
+        }
+
+        #[inline]
+        fn as_ptr(&self) -> *mut sem_t {
+            self.raw
+        }
+    }
+
+    impl Drop for SemHandle {
+        fn drop(&mut self) {
+            // Guard against default/uninitialized state.
+            // Note: SEM_FAILED is (sem_t*)-1, not null, but valid handles are never null
+            // and SEM_FAILED is never stored (error is returned immediately on sem_open failure).
+            if !self.raw.is_null() {
+                // SEM_CLOSE(sem) sem_close(sem)
+                unsafe {
+                    libc::sem_close(self.raw);
+                }
+            }
+        }
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl SemLock {
+        #[pygetset]
+        fn handle(&self) -> isize {
+            self.handle.as_ptr() as isize
+        }
+
+        #[pygetset]
+        fn kind(&self) -> i32 {
+            self.kind
+        }
+
+        #[pygetset]
+        fn maxvalue(&self) -> i32 {
+            self.maxvalue
+        }
+
+        #[pygetset]
+        fn name(&self) -> Option<String> {
+            self.name.clone()
+        }
+
+        /// Acquire the semaphore/lock.
+        // _multiprocessing_SemLock_acquire_impl
+        #[pymethod]
+        fn acquire(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<bool> {
+            // block=True, timeout=None
+
+            let blocking: bool = args
+                .kwargs
+                .get("block")
+                .or_else(|| args.args.first())
+                .map(|o| o.clone().try_to_bool(vm))
+                .transpose()?
+                .unwrap_or(true);
+
+            let timeout_obj = args
+                .kwargs
+                .get("timeout")
+                .or_else(|| args.args.get(1))
+                .cloned();
+
+            if self.kind == RECURSIVE_MUTEX && ismine!(self) {
+                self.count.fetch_add(1, Ordering::Release);
+                return Ok(true);
+            }
+
+            // timeout_obj != Py_None
+            let use_deadline = timeout_obj.as_ref().is_some_and(|o| !vm.is_none(o));
+
+            let deadline = if use_deadline {
+                let timeout_obj = timeout_obj.unwrap();
+                // This accepts both int and float, converting to f64
+                let timeout: f64 = timeout_obj.try_float(vm)?.to_f64();
+                let timeout = if timeout < 0.0 { 0.0 } else { timeout };
+
+                let mut tv = libc::timeval {
+                    tv_sec: 0,
+                    tv_usec: 0,
+                };
+                let res = unsafe { libc::gettimeofday(&mut tv, std::ptr::null_mut()) };
+                if res < 0 {
+                    return Err(vm.new_os_error("gettimeofday failed".to_string()));
+                }
+
+                // deadline calculation:
+                // long sec = (long) timeout;
+                // long nsec = (long) (1e9 * (timeout - sec) + 0.5);
+                // deadline.tv_sec = now.tv_sec + sec;
+                // deadline.tv_nsec = now.tv_usec * 1000 + nsec;
+                // deadline.tv_sec += (deadline.tv_nsec / 1000000000);
+                // deadline.tv_nsec %= 1000000000;
+                let sec = timeout as libc::c_long;
+                let nsec = (1e9 * (timeout - sec as f64) + 0.5) as libc::c_long;
+                let mut deadline = libc::timespec {
+                    tv_sec: tv.tv_sec + sec as libc::time_t,
+                    tv_nsec: (tv.tv_usec as libc::c_long * 1000 + nsec) as _,
+                };
+                deadline.tv_sec += (deadline.tv_nsec / 1_000_000_000) as libc::time_t;
+                deadline.tv_nsec %= 1_000_000_000;
+                Some(deadline)
+            } else {
+                None
+            };
+
+            // Check whether we can acquire without releasing the GIL and blocking
+            let mut res;
+            loop {
+                res = unsafe { libc::sem_trywait(self.handle.as_ptr()) };
+                if res >= 0 {
+                    break;
+                }
+                let err = Errno::last();
+                if err == Errno::EINTR {
+                    vm.check_signals()?;
+                    continue;
+                }
+                break;
+            }
+
+            // if (res < 0 && errno == EAGAIN && blocking)
+            if res < 0 && Errno::last() == Errno::EAGAIN && blocking {
+                // Couldn't acquire immediately, need to block
+                #[cfg(not(target_vendor = "apple"))]
+                {
+                    loop {
+                        // Py_BEGIN_ALLOW_THREADS / Py_END_ALLOW_THREADS
+                        // RustPython doesn't have GIL, so we just do the wait
+                        if let Some(ref dl) = deadline {
+                            res = unsafe { libc::sem_timedwait(self.handle.as_ptr(), dl) };
+                        } else {
+                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
+                        }
+
+                        if res >= 0 {
+                            break;
+                        }
+                        let err = Errno::last();
+                        if err == Errno::EINTR {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                #[cfg(target_vendor = "apple")]
+                {
+                    // macOS: use polled fallback since sem_timedwait is not available
+                    if let Some(ref dl) = deadline {
+                        match sem_timedwait_polled(self.handle.as_ptr(), dl, vm) {
+                            Ok(()) => res = 0,
+                            Err(SemWaitError::Timeout) => {
+                                // Timeout occurred - return false directly
+                                return Ok(false);
+                            }
+                            Err(SemWaitError::SignalException(exc)) => {
+                                // Propagate the original exception (e.g., KeyboardInterrupt)
+                                return Err(exc);
+                            }
+                            Err(SemWaitError::OsError(e)) => {
+                                return Err(os_error(vm, e));
+                            }
+                        }
+                    } else {
+                        // No timeout: use sem_wait (available on macOS)
+                        loop {
+                            res = unsafe { libc::sem_wait(self.handle.as_ptr()) };
+                            if res >= 0 {
+                                break;
+                            }
+                            let err = Errno::last();
+                            if err == Errno::EINTR {
+                                vm.check_signals()?;
+                                continue;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // result handling:
+            if res < 0 {
+                let err = Errno::last();
+                match err {
+                    Errno::EAGAIN | Errno::ETIMEDOUT => return Ok(false),
+                    Errno::EINTR => {
+                        // EINTR should be handled by the check_signals() loop above
+                        // If we reach here, check signals again and propagate any exception
+                        return vm.check_signals().map(|_| false);
+                    }
+                    _ => return Err(os_error(vm, err)),
+                }
+            }
+
+            self.count.fetch_add(1, Ordering::Release);
+            self.last_tid.store(current_thread_id(), Ordering::Release);
+
+            Ok(true)
+        }
+
+        /// Release the semaphore/lock.
+        // _multiprocessing_SemLock_release_impl
+        #[pymethod]
+        fn release(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.kind == RECURSIVE_MUTEX {
+                // if (!ISMINE(self))
+                if !ismine!(self) {
+                    return Err(vm.new_exception_msg(
+                        vm.ctx.exceptions.assertion_error.to_owned(),
+                        "attempt to release recursive lock not owned by thread".to_owned(),
+                    ));
+                }
+                // if (self->count > 1) { --self->count; Py_RETURN_NONE; }
+                if self.count.load(Ordering::Acquire) > 1 {
+                    self.count.fetch_sub(1, Ordering::Release);
+                    return Ok(());
+                }
+                // assert(self->count == 1);
+            } else {
+                // SEMAPHORE case: check value before releasing
+                #[cfg(not(target_vendor = "apple"))]
+                {
+                    // Linux: use sem_getvalue
+                    let mut sval: libc::c_int = 0;
+                    let res = unsafe { libc::sem_getvalue(self.handle.as_ptr(), &mut sval) };
+                    if res < 0 {
+                        return Err(os_error(vm, Errno::last()));
+                    }
+                    if sval >= self.maxvalue {
+                        return Err(vm.new_value_error(
+                            "semaphore or lock released too many times".to_owned(),
+                        ));
+                    }
+                }
+                #[cfg(target_vendor = "apple")]
+                {
+                    // macOS: HAVE_BROKEN_SEM_GETVALUE
+                    // We will only check properly the maxvalue == 1 case
+                    if self.maxvalue == 1 {
+                        // make sure that already locked
+                        if unsafe { libc::sem_trywait(self.handle.as_ptr()) } < 0 {
+                            if Errno::last() != Errno::EAGAIN {
+                                return Err(os_error(vm, Errno::last()));
+                            }
+                            // it is already locked as expected
+                        } else {
+                            // it was not locked so undo wait and raise
+                            if unsafe { libc::sem_post(self.handle.as_ptr()) } < 0 {
+                                return Err(os_error(vm, Errno::last()));
+                            }
+                            return Err(vm.new_value_error(
+                                "semaphore or lock released too many times".to_owned(),
+                            ));
+                        }
+                    }
+                }
+            }
+
+            let res = unsafe { libc::sem_post(self.handle.as_ptr()) };
+            if res < 0 {
+                return Err(os_error(vm, Errno::last()));
+            }
+
+            self.count.fetch_sub(1, Ordering::Release);
+            Ok(())
+        }
+
+        /// Enter the semaphore/lock (context manager).
+        // _multiprocessing_SemLock___enter___impl
+        #[pymethod(name = "__enter__")]
+        fn enter(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            // return _multiprocessing_SemLock_acquire_impl(self, 1, Py_None);
+            self.acquire(
+                FuncArgs::new::<Vec<_>, KwArgs>(
+                    vec![vm.ctx.new_bool(true).into()],
+                    KwArgs::default(),
+                ),
+                vm,
+            )
+        }
+
+        /// Exit the semaphore/lock (context manager).
+        // _multiprocessing_SemLock___exit___impl
+        #[pymethod]
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.release(vm)
+        }
+
+        /// Rebuild a SemLock from pickled state.
+        // _multiprocessing_SemLock__rebuild_impl
+        #[pyclassmethod(name = "_rebuild")]
+        fn rebuild(
+            cls: PyTypeRef,
+            _handle: isize,
+            kind: i32,
+            maxvalue: i32,
+            name: Option<String>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let Some(ref name_str) = name else {
+                return Err(vm.new_value_error("cannot rebuild SemLock without name".to_owned()));
+            };
+            let handle = SemHandle::open_existing(name_str, vm)?;
+            // return newsemlockobject(type, handle, kind, maxvalue, name_copy);
+            let zelf = SemLock {
+                handle,
+                kind,
+                maxvalue,
+                name,
+                last_tid: AtomicU64::new(0),
+                count: AtomicI32::new(0),
+            };
+            zelf.into_ref_with_type(vm, cls).map(Into::into)
+        }
+
+        /// Rezero the net acquisition count after fork().
+        // _multiprocessing_SemLock__after_fork_impl
+        #[pymethod]
+        fn _after_fork(&self) {
+            self.count.store(0, Ordering::Release);
+            // Also reset last_tid for safety
+            self.last_tid.store(0, Ordering::Release);
+        }
+
+        /// SemLock objects cannot be pickled directly.
+        /// Use multiprocessing.synchronize.SemLock wrapper which handles pickling.
+        #[pymethod]
+        fn __reduce__(&self, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot pickle 'SemLock' object".to_owned()))
+        }
+
+        /// Num of `acquire()`s minus num of `release()`s for this process.
+        // _multiprocessing_SemLock__count_impl
+        #[pymethod]
+        fn _count(&self) -> i32 {
+            self.count.load(Ordering::Acquire)
+        }
+
+        /// Whether the lock is owned by this thread.
+        // _multiprocessing_SemLock__is_mine_impl
+        #[pymethod]
+        fn _is_mine(&self) -> bool {
+            ismine!(self)
+        }
+
+        /// Get the value of the semaphore.
+        // _multiprocessing_SemLock__get_value_impl
+        #[pymethod]
+        fn _get_value(&self, vm: &VirtualMachine) -> PyResult<i32> {
+            #[cfg(not(target_vendor = "apple"))]
+            {
+                // Linux: use sem_getvalue
+                let mut sval: libc::c_int = 0;
+                let res = unsafe { libc::sem_getvalue(self.handle.as_ptr(), &mut sval) };
+                if res < 0 {
+                    return Err(os_error(vm, Errno::last()));
+                }
+                // some posix implementations use negative numbers to indicate
+                // the number of waiting threads
+                Ok(if sval < 0 { 0 } else { sval })
+            }
+            #[cfg(target_vendor = "apple")]
+            {
+                // macOS: HAVE_BROKEN_SEM_GETVALUE - raise NotImplementedError
+                Err(vm.new_not_implemented_error(String::new()))
+            }
+        }
+
+        /// Return whether semaphore has value zero.
+        // _multiprocessing_SemLock__is_zero_impl
+        #[pymethod]
+        fn _is_zero(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            #[cfg(not(target_vendor = "apple"))]
+            {
+                Ok(self._get_value(vm)? == 0)
+            }
+            #[cfg(target_vendor = "apple")]
+            {
+                // macOS: HAVE_BROKEN_SEM_GETVALUE
+                // Try to acquire - if EAGAIN, value is 0
+                if unsafe { libc::sem_trywait(self.handle.as_ptr()) } < 0 {
+                    if Errno::last() == Errno::EAGAIN {
+                        return Ok(true);
+                    }
+                    return Err(os_error(vm, Errno::last()));
+                }
+                // Successfully acquired - undo and return false
+                if unsafe { libc::sem_post(self.handle.as_ptr()) } < 0 {
+                    return Err(os_error(vm, Errno::last()));
+                }
+                Ok(false)
+            }
+        }
+
+        #[extend_class]
+        fn extend_class(ctx: &Context, class: &Py<PyType>) {
+            class.set_attr(
+                ctx.intern_str("RECURSIVE_MUTEX"),
+                ctx.new_int(RECURSIVE_MUTEX).into(),
+            );
+            class.set_attr(ctx.intern_str("SEMAPHORE"), ctx.new_int(SEMAPHORE).into());
+            // SEM_VALUE_MAX from system, or INT_MAX if negative
+            // We use a reasonable default
+            let sem_value_max: i32 = unsafe {
+                let val = libc::sysconf(libc::_SC_SEM_VALUE_MAX);
+                if val < 0 || val > i32::MAX as libc::c_long {
+                    i32::MAX
+                } else {
+                    val as i32
+                }
+            };
+            class.set_attr(
+                ctx.intern_str("SEM_VALUE_MAX"),
+                ctx.new_int(sem_value_max).into(),
+            );
+        }
+    }
+
+    impl Constructor for SemLock {
+        type Args = SemLockNewArgs;
+
+        // Create a new SemLock.
+        // _multiprocessing_SemLock_impl
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            if args.kind != RECURSIVE_MUTEX && args.kind != SEMAPHORE {
+                return Err(vm.new_value_error("unrecognized kind".to_owned()));
+            }
+            // Value validation
+            if args.value < 0 || args.value > args.maxvalue {
+                return Err(vm.new_value_error("invalid value".to_owned()));
+            }
+
+            let value = args.value as u32;
+            let (handle, name) = SemHandle::create(&args.name, value, args.unlink, vm)?;
+
+            // return newsemlockobject(type, handle, kind, maxvalue, name_copy);
+            Ok(SemLock {
+                handle,
+                kind: args.kind,
+                maxvalue: args.maxvalue,
+                name,
+                last_tid: AtomicU64::new(0),
+                count: AtomicI32::new(0),
+            })
+        }
+    }
+
+    /// Function to unlink semaphore names.
+    // _PyMp_sem_unlink.
+    #[pyfunction]
+    fn sem_unlink(name: String, vm: &VirtualMachine) -> PyResult<()> {
+        let cname = semaphore_name(vm, &name)?;
+        let res = unsafe { libc::sem_unlink(cname.as_ptr()) };
+        if res < 0 {
+            return Err(os_error(vm, Errno::last()));
+        }
+        Ok(())
+    }
+
+    /// Module-level flags dict.
+    #[pyattr]
+    fn flags(vm: &VirtualMachine) -> PyRef<PyDict> {
+        let flags = vm.ctx.new_dict();
+        // HAVE_SEM_OPEN is always 1 on Unix (we wouldn't be here otherwise)
+        flags
+            .set_item("HAVE_SEM_OPEN", vm.ctx.new_int(1).into(), vm)
+            .unwrap();
+
+        #[cfg(not(target_vendor = "apple"))]
+        {
+            // Linux: HAVE_SEM_TIMEDWAIT is available
+            flags
+                .set_item("HAVE_SEM_TIMEDWAIT", vm.ctx.new_int(1).into(), vm)
+                .unwrap();
+        }
+
+        #[cfg(target_vendor = "apple")]
+        {
+            // macOS: sem_getvalue is broken
+            flags
+                .set_item("HAVE_BROKEN_SEM_GETVALUE", vm.ctx.new_int(1).into(), vm)
+                .unwrap();
+        }
+
+        flags
+    }
+
+    fn semaphore_name(vm: &VirtualMachine, name: &str) -> PyResult<CString> {
+        // POSIX semaphore names must start with /
+        let mut full = String::with_capacity(name.len() + 1);
+        if !name.starts_with('/') {
+            full.push('/');
+        }
+        full.push_str(name);
+        CString::new(full).map_err(|_| vm.new_value_error("embedded null character".to_owned()))
+    }
+
+    fn os_error(vm: &VirtualMachine, err: Errno) -> PyBaseExceptionRef {
+        // _PyMp_SetError maps to PyErr_SetFromErrno
+        let exc_type = match err {
+            Errno::EEXIST => vm.ctx.exceptions.file_exists_error.to_owned(),
+            Errno::ENOENT => vm.ctx.exceptions.file_not_found_error.to_owned(),
+            _ => vm.ctx.exceptions.os_error.to_owned(),
+        };
+        vm.new_os_subtype_error(exc_type, Some(err as i32), err.desc().to_owned())
+            .upcast()
+    }
+
+    /// Get current thread identifier.
+    /// PyThread_get_thread_ident on Unix (pthread_self).
+    fn current_thread_id() -> u64 {
+        unsafe { libc::pthread_self() as u64 }
+    }
+}
+
+#[cfg(all(not(unix), not(windows)))]
+#[pymodule]
+mod _multiprocessing {}
diff --git a/crates/stdlib/src/opcode.rs b/crates/stdlib/src/opcode.rs
new file mode 100644
index 0000000000..fcde0de36e
--- /dev/null
+++ b/crates/stdlib/src/opcode.rs
@@ -0,0 +1,333 @@
+pub(crate) use opcode::make_module;
+
+#[pymodule]
+mod opcode {
+    use crate::vm::{
+        AsObject, PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyInt, PyIntRef},
+        bytecode::{AnyInstruction, Instruction, InstructionMetadata, PseudoInstruction},
+    };
+    use core::ops::Deref;
+
+    #[derive(Clone, Copy)]
+    struct Opcode(AnyInstruction);
+
+    impl Deref for Opcode {
+        type Target = AnyInstruction;
+
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl TryFrom<i32> for Opcode {
+        type Error = ();
+
+        fn try_from(value: i32) -> Result<Self, Self::Error> {
+            Ok(Self(
+                u16::try_from(value)
+                    .map_err(|_| ())?
+                    .try_into()
+                    .map_err(|_| ())?,
+            ))
+        }
+    }
+
+    impl Opcode {
+        // https://github.com/python/cpython/blob/bcee1c322115c581da27600f2ae55e5439c027eb/Include/opcode_ids.h#L238
+        const HAVE_ARGUMENT: i32 = 44;
+
+        pub fn try_from_pyint(raw: PyIntRef, vm: &VirtualMachine) -> PyResult<Self> {
+            let instruction = raw
+                .try_to_primitive::<u16>(vm)
+                .and_then(|v| {
+                    AnyInstruction::try_from(v).map_err(|_| {
+                        vm.new_exception_empty(vm.ctx.exceptions.value_error.to_owned())
+                    })
+                })
+                .map_err(|_| vm.new_value_error("invalid opcode or oparg"))?;
+
+            Ok(Self(instruction))
+        }
+
+        const fn inner(self) -> AnyInstruction {
+            self.0
+        }
+
+        /// Check if opcode is valid (can be converted to an AnyInstruction)
+        #[must_use]
+        pub fn is_valid(opcode: i32) -> bool {
+            Self::try_from(opcode).is_ok()
+        }
+
+        /// Check if instruction has an argument
+        #[must_use]
+        pub fn has_arg(opcode: i32) -> bool {
+            Self::is_valid(opcode) && opcode > Self::HAVE_ARGUMENT
+        }
+
+        /// Check if instruction uses co_consts
+        #[must_use]
+        pub fn has_const(opcode: i32) -> bool {
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::LoadConst { .. } | Instruction::ReturnConst { .. }
+                ))
+            )
+        }
+
+        /// Check if instruction uses co_names
+        #[must_use]
+        pub fn has_name(opcode: i32) -> bool {
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteAttr { .. }
+                        | Instruction::DeleteGlobal(_)
+                        | Instruction::DeleteName(_)
+                        | Instruction::ImportFrom { .. }
+                        | Instruction::ImportName { .. }
+                        | Instruction::LoadAttr { .. }
+                        | Instruction::LoadGlobal(_)
+                        | Instruction::LoadName(_)
+                        | Instruction::StoreAttr { .. }
+                        | Instruction::StoreGlobal(_)
+                        | Instruction::StoreName(_)
+                ) | AnyInstruction::Pseudo(PseudoInstruction::LoadAttrMethod { .. }))
+            )
+        }
+
+        /// Check if instruction is a jump
+        #[must_use]
+        pub fn has_jump(opcode: i32) -> bool {
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::Break { .. }
+                        | Instruction::Continue { .. }
+                        | Instruction::ForIter { .. }
+                        | Instruction::JumpIfFalseOrPop { .. }
+                        | Instruction::JumpIfNotExcMatch(_)
+                        | Instruction::JumpIfTrueOrPop { .. }
+                        | Instruction::PopJumpIfFalse { .. }
+                        | Instruction::PopJumpIfTrue { .. }
+                        | Instruction::Send { .. }
+                ) | AnyInstruction::Pseudo(PseudoInstruction::Jump { .. }))
+            )
+        }
+
+        /// Check if instruction uses co_freevars/co_cellvars
+        #[must_use]
+        pub fn has_free(opcode: i32) -> bool {
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteDeref(_)
+                        | Instruction::LoadFromDictOrDeref(_)
+                        | Instruction::LoadClosure(_)
+                        | Instruction::LoadDeref(_)
+                        | Instruction::StoreDeref(_)
+                ))
+            )
+        }
+
+        /// Check if instruction uses co_varnames (local variables)
+        #[must_use]
+        pub fn has_local(opcode: i32) -> bool {
+            matches!(
+                Self::try_from(opcode).map(|op| op.inner()),
+                Ok(AnyInstruction::Real(
+                    Instruction::DeleteFast(_)
+                        | Instruction::LoadFast(_)
+                        | Instruction::LoadFastAndClear(_)
+                        | Instruction::StoreFast(_)
+                        | Instruction::StoreFastLoadFast { .. }
+                ))
+            )
+        }
+
+        /// Check if instruction has exception info
+        #[must_use]
+        pub fn has_exc(_opcode: i32) -> bool {
+            // No instructions have exception info in RustPython
+            // (exception handling is done via exception table)
+            false
+        }
+    }
+
+    #[pyattr]
+    const ENABLE_SPECIALIZATION: i8 = 1;
+
+    #[derive(FromArgs)]
+    struct StackEffectArgs {
+        #[pyarg(positional)]
+        opcode: PyIntRef,
+        #[pyarg(positional, optional)]
+        oparg: Option<PyObjectRef>,
+        #[pyarg(named, optional)]
+        jump: Option<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn stack_effect(args: StackEffectArgs, vm: &VirtualMachine) -> PyResult<i32> {
+        let oparg = args
+            .oparg
+            .map(|v| {
+                if !v.fast_isinstance(vm.ctx.types.int_type) {
+                    return Err(vm.new_type_error(format!(
+                        "'{}' object cannot be interpreted as an integer",
+                        v.class().name()
+                    )));
+                }
+                v.downcast_ref::<PyInt>()
+                    .ok_or_else(|| {
+                        vm.new_type_error(format!(
+                            "'{}' object cannot be interpreted as an integer",
+                            v.class().name()
+                        ))
+                    })?
+                    .try_to_primitive::<u32>(vm)
+            })
+            .unwrap_or(Ok(0))?;
+
+        let jump = args
+            .jump
+            .map(|v| {
+                v.try_to_bool(vm).map_err(|_| {
+                    vm.new_value_error("stack_effect: jump must be False, True or None")
+                })
+            })
+            .unwrap_or(Ok(false))?;
+
+        let opcode = Opcode::try_from_pyint(args.opcode, vm)?;
+
+        Ok(opcode.stack_effect(oparg.into(), jump))
+    }
+
+    #[pyfunction]
+    fn is_valid(opcode: i32) -> bool {
+        Opcode::is_valid(opcode)
+    }
+
+    #[pyfunction]
+    fn has_arg(opcode: i32) -> bool {
+        Opcode::has_arg(opcode)
+    }
+
+    #[pyfunction]
+    fn has_const(opcode: i32) -> bool {
+        Opcode::has_const(opcode)
+    }
+
+    #[pyfunction]
+    fn has_name(opcode: i32) -> bool {
+        Opcode::has_name(opcode)
+    }
+
+    #[pyfunction]
+    fn has_jump(opcode: i32) -> bool {
+        Opcode::has_jump(opcode)
+    }
+
+    #[pyfunction]
+    fn has_free(opcode: i32) -> bool {
+        Opcode::has_free(opcode)
+    }
+
+    #[pyfunction]
+    fn has_local(opcode: i32) -> bool {
+        Opcode::has_local(opcode)
+    }
+
+    #[pyfunction]
+    fn has_exc(opcode: i32) -> bool {
+        Opcode::has_exc(opcode)
+    }
+
+    #[pyfunction]
+    fn get_intrinsic1_descs(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        [
+            "INTRINSIC_1_INVALID",
+            "INTRINSIC_PRINT",
+            "INTRINSIC_IMPORT_STAR",
+            "INTRINSIC_STOPITERATION_ERROR",
+            "INTRINSIC_ASYNC_GEN_WRAP",
+            "INTRINSIC_UNARY_POSITIVE",
+            "INTRINSIC_LIST_TO_TUPLE",
+            "INTRINSIC_TYPEVAR",
+            "INTRINSIC_PARAMSPEC",
+            "INTRINSIC_TYPEVARTUPLE",
+            "INTRINSIC_SUBSCRIPT_GENERIC",
+            "INTRINSIC_TYPEALIAS",
+        ]
+        .into_iter()
+        .map(|x| vm.ctx.new_str(x).into())
+        .collect()
+    }
+
+    #[pyfunction]
+    fn get_intrinsic2_descs(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        [
+            "INTRINSIC_2_INVALID",
+            "INTRINSIC_PREP_RERAISE_STAR",
+            "INTRINSIC_TYPEVAR_WITH_BOUND",
+            "INTRINSIC_TYPEVAR_WITH_CONSTRAINTS",
+            "INTRINSIC_SET_FUNCTION_TYPE_PARAMS",
+            "INTRINSIC_SET_TYPEPARAM_DEFAULT",
+        ]
+        .into_iter()
+        .map(|x| vm.ctx.new_str(x).into())
+        .collect()
+    }
+
+    #[pyfunction]
+    fn get_nb_ops(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        [
+            ("NB_ADD", "+"),
+            ("NB_AND", "&"),
+            ("NB_FLOOR_DIVIDE", "//"),
+            ("NB_LSHIFT", "<<"),
+            ("NB_MATRIX_MULTIPLY", "@"),
+            ("NB_MULTIPLY", "*"),
+            ("NB_REMAINDER", "%"),
+            ("NB_OR", "|"),
+            ("NB_POWER", "**"),
+            ("NB_RSHIFT", ">>"),
+            ("NB_SUBTRACT", "-"),
+            ("NB_TRUE_DIVIDE", "/"),
+            ("NB_XOR", "^"),
+            ("NB_INPLACE_ADD", "+="),
+            ("NB_INPLACE_AND", "&="),
+            ("NB_INPLACE_FLOOR_DIVIDE", "//="),
+            ("NB_INPLACE_LSHIFT", "<<="),
+            ("NB_INPLACE_MATRIX_MULTIPLY", "@="),
+            ("NB_INPLACE_MULTIPLY", "*="),
+            ("NB_INPLACE_REMAINDER", "%="),
+            ("NB_INPLACE_OR", "|="),
+            ("NB_INPLACE_POWER", "**="),
+            ("NB_INPLACE_RSHIFT", ">>="),
+            ("NB_INPLACE_SUBTRACT", "-="),
+            ("NB_INPLACE_TRUE_DIVIDE", "/="),
+            ("NB_INPLACE_XOR", "^="),
+        ]
+        .into_iter()
+        .map(|(a, b)| {
+            vm.ctx
+                .new_tuple(vec![vm.ctx.new_str(a).into(), vm.ctx.new_str(b).into()])
+                .into()
+        })
+        .collect()
+    }
+
+    #[pyfunction]
+    fn get_executor(_code: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // TODO
+        Ok(vm.ctx.none())
+    }
+
+    #[pyfunction]
+    fn get_specialization_stats(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.none()
+    }
+}
diff --git a/crates/stdlib/src/openssl.rs b/crates/stdlib/src/openssl.rs
new file mode 100644
index 0000000000..df153459f6
--- /dev/null
+++ b/crates/stdlib/src/openssl.rs
@@ -0,0 +1,4116 @@
+// spell-checker:disable
+
+mod cert;
+
+// SSL exception types (shared with rustls backend)
+#[path = "ssl/error.rs"]
+mod ssl_error;
+
+// Conditional compilation for OpenSSL version-specific error codes
+cfg_if::cfg_if! {
+    if #[cfg(ossl310)] {
+        // OpenSSL 3.1.0+
+        mod ssl_data_31;
+        use ssl_data_31 as ssl_data;
+    } else if #[cfg(ossl300)] {
+        // OpenSSL 3.0.0+
+        mod ssl_data_300;
+        use ssl_data_300 as ssl_data;
+    } else {
+        // OpenSSL 1.1.1+ (fallback)
+        mod ssl_data_111;
+        use ssl_data_111 as ssl_data;
+    }
+}
+
+use crate::vm::{PyRef, VirtualMachine, builtins::PyModule};
+use openssl_probe::ProbeResult;
+use std::sync::LazyLock;
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    // if openssl is vendored, it doesn't know the locations
+    // of system certificates - cache the probe result now.
+    #[cfg(openssl_vendored)]
+    LazyLock::force(&PROBE);
+    _ssl::make_module(vm)
+}
+
+// define our own copy of ProbeResult so we can handle the vendor case
+// easily, without having to have a bunch of cfgs
+cfg_if::cfg_if! {
+    if #[cfg(openssl_vendored)] {
+        static PROBE: LazyLock<ProbeResult> = LazyLock::new(openssl_probe::probe);
+        fn probe() -> &'static ProbeResult { &PROBE }
+    } else {
+        static EMPTY_PROBE: LazyLock<ProbeResult> = LazyLock::new(|| ProbeResult { cert_file: None, cert_dir: vec![] });
+        fn probe() -> &'static ProbeResult {
+            &EMPTY_PROBE
+        }
+    }
+}
+
+#[allow(non_upper_case_globals)]
+#[pymodule(with(cert::ssl_cert, ssl_error::ssl_error, ossl101, ossl111, windows))]
+mod _ssl {
+    use super::{bio, probe};
+
+    // Import error types and helpers used in this module (others are exposed via pymodule(with(...)))
+    use super::ssl_error::{
+        PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,
+        create_ssl_want_write_error,
+    };
+    use crate::{
+        common::lock::{
+            PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
+        },
+        socket::{self, PySocket},
+        vm::{
+            AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+            builtins::{
+                PyBaseException, PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType,
+                PyWeak,
+            },
+            class_or_notimplemented,
+            convert::ToPyException,
+            exceptions,
+            function::{
+                ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath, OptionalArg,
+                PyComparisonValue,
+            },
+            types::{Comparable, Constructor, PyComparisonOp},
+            utils::ToCString,
+        },
+    };
+    use crossbeam_utils::atomic::AtomicCell;
+    use foreign_types_shared::{ForeignType, ForeignTypeRef};
+    use openssl::{
+        asn1::{Asn1Object, Asn1ObjectRef},
+        error::ErrorStack,
+        nid::Nid,
+        ssl::{self, SslContextBuilder, SslOptions, SslVerifyMode},
+        x509::X509,
+    };
+    use openssl_sys as sys;
+    use rustpython_vm::ospath::OsPath;
+    use std::{
+        ffi::CStr,
+        fmt,
+        io::{Read, Write},
+        path::{Path, PathBuf},
+        sync::LazyLock,
+        time::Instant,
+    };
+
+    // Import certificate types from parent module
+    use super::cert::{self, cert_to_certificate, cert_to_py};
+
+    // Re-export PySSLCertificate to make it available in the _ssl module
+    // It will be automatically exposed to Python via #[pyclass]
+    #[allow(unused_imports)]
+    use super::cert::PySSLCertificate;
+
+    // Constants
+    #[pyattr]
+    use sys::{
+        // SSL Alert Descriptions that are exported by openssl_sys
+        SSL_AD_DECODE_ERROR,
+        SSL_AD_ILLEGAL_PARAMETER,
+        SSL_AD_UNRECOGNIZED_NAME,
+        // SSL_ERROR_INVALID_ERROR_CODE,
+        SSL_ERROR_SSL,
+        // SSL_ERROR_WANT_X509_LOOKUP,
+        SSL_ERROR_SYSCALL,
+        SSL_ERROR_WANT_CONNECT,
+        SSL_ERROR_WANT_READ,
+        SSL_ERROR_WANT_WRITE,
+        SSL_ERROR_ZERO_RETURN,
+        SSL_OP_CIPHER_SERVER_PREFERENCE as OP_CIPHER_SERVER_PREFERENCE,
+        SSL_OP_ENABLE_MIDDLEBOX_COMPAT as OP_ENABLE_MIDDLEBOX_COMPAT,
+        SSL_OP_LEGACY_SERVER_CONNECT as OP_LEGACY_SERVER_CONNECT,
+        SSL_OP_NO_SSLv2 as OP_NO_SSLv2,
+        SSL_OP_NO_SSLv3 as OP_NO_SSLv3,
+        SSL_OP_NO_TICKET as OP_NO_TICKET,
+        SSL_OP_NO_TLSv1 as OP_NO_TLSv1,
+        SSL_OP_SINGLE_DH_USE as OP_SINGLE_DH_USE,
+        SSL_OP_SINGLE_ECDH_USE as OP_SINGLE_ECDH_USE,
+        X509_V_FLAG_ALLOW_PROXY_CERTS as VERIFY_ALLOW_PROXY_CERTS,
+        X509_V_FLAG_CRL_CHECK as VERIFY_CRL_CHECK_LEAF,
+        X509_V_FLAG_PARTIAL_CHAIN as VERIFY_X509_PARTIAL_CHAIN,
+        X509_V_FLAG_TRUSTED_FIRST as VERIFY_X509_TRUSTED_FIRST,
+        X509_V_FLAG_X509_STRICT as VERIFY_X509_STRICT,
+    };
+
+    // SSL Alert Descriptions (RFC 5246 and extensions)
+    // Hybrid approach: use openssl_sys constants where available, hardcode others
+    #[pyattr]
+    const ALERT_DESCRIPTION_CLOSE_NOTIFY: libc::c_int = 0;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNEXPECTED_MESSAGE: libc::c_int = 10;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_RECORD_MAC: libc::c_int = 20;
+    #[pyattr]
+    const ALERT_DESCRIPTION_RECORD_OVERFLOW: libc::c_int = 22;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECOMPRESSION_FAILURE: libc::c_int = 30;
+    #[pyattr]
+    const ALERT_DESCRIPTION_HANDSHAKE_FAILURE: libc::c_int = 40;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE: libc::c_int = 42;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: libc::c_int = 43;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_REVOKED: libc::c_int = 44;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_EXPIRED: libc::c_int = 45;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN: libc::c_int = 46;
+    #[pyattr]
+    const ALERT_DESCRIPTION_ILLEGAL_PARAMETER: libc::c_int = SSL_AD_ILLEGAL_PARAMETER;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNKNOWN_CA: libc::c_int = 48;
+    #[pyattr]
+    const ALERT_DESCRIPTION_ACCESS_DENIED: libc::c_int = 49;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECODE_ERROR: libc::c_int = SSL_AD_DECODE_ERROR;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECRYPT_ERROR: libc::c_int = 51;
+    #[pyattr]
+    const ALERT_DESCRIPTION_PROTOCOL_VERSION: libc::c_int = 70;
+    #[pyattr]
+    const ALERT_DESCRIPTION_INSUFFICIENT_SECURITY: libc::c_int = 71;
+    #[pyattr]
+    const ALERT_DESCRIPTION_INTERNAL_ERROR: libc::c_int = 80;
+    #[pyattr]
+    const ALERT_DESCRIPTION_USER_CANCELLED: libc::c_int = 90;
+    #[pyattr]
+    const ALERT_DESCRIPTION_NO_RENEGOTIATION: libc::c_int = 100;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: libc::c_int = 110;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE: libc::c_int = 111;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNRECOGNIZED_NAME: libc::c_int = SSL_AD_UNRECOGNIZED_NAME;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE: libc::c_int = 113;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE: libc::c_int = 114;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY: libc::c_int = 115;
+
+    // CRL verification constants
+    #[pyattr]
+    const VERIFY_CRL_CHECK_CHAIN: libc::c_ulong =
+        sys::X509_V_FLAG_CRL_CHECK | sys::X509_V_FLAG_CRL_CHECK_ALL;
+
+    // taken from CPython, should probably be kept up to date with their version if it ever changes
+    #[pyattr]
+    const _DEFAULT_CIPHERS: &str =
+        "DEFAULT:!aNULL:!eNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK";
+    // #[pyattr] PROTOCOL_SSLv2: u32 = SslVersion::Ssl2 as u32;  // unsupported
+    // #[pyattr] PROTOCOL_SSLv3: u32 = SslVersion::Ssl3 as u32;
+    #[pyattr]
+    const PROTOCOL_SSLv23: u32 = SslVersion::Tls as u32;
+    #[pyattr]
+    const PROTOCOL_TLS: u32 = SslVersion::Tls as u32;
+    #[pyattr]
+    const PROTOCOL_TLS_CLIENT: u32 = SslVersion::TlsClient as u32;
+    #[pyattr]
+    const PROTOCOL_TLS_SERVER: u32 = SslVersion::TlsServer as u32;
+    #[pyattr]
+    const PROTOCOL_TLSv1: u32 = SslVersion::Tls1 as u32;
+    #[pyattr]
+    const PROTOCOL_TLSv1_1: u32 = SslVersion::Tls1_1 as u32;
+    #[pyattr]
+    const PROTOCOL_TLSv1_2: u32 = SslVersion::Tls1_2 as u32;
+    #[pyattr]
+    const PROTO_MINIMUM_SUPPORTED: i32 = ProtoVersion::MinSupported as i32;
+    #[pyattr]
+    const PROTO_SSLv3: i32 = ProtoVersion::Ssl3 as i32;
+    #[pyattr]
+    const PROTO_TLSv1: i32 = ProtoVersion::Tls1 as i32;
+    #[pyattr]
+    const PROTO_TLSv1_1: i32 = ProtoVersion::Tls1_1 as i32;
+    #[pyattr]
+    const PROTO_TLSv1_2: i32 = ProtoVersion::Tls1_2 as i32;
+    #[pyattr]
+    const PROTO_TLSv1_3: i32 = ProtoVersion::Tls1_3 as i32;
+    #[pyattr]
+    const PROTO_MAXIMUM_SUPPORTED: i32 = ProtoVersion::MaxSupported as i32;
+    #[pyattr]
+    const OP_ALL: libc::c_ulong = (sys::SSL_OP_ALL & !sys::SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) as _;
+    #[pyattr]
+    const HAS_TLS_UNIQUE: bool = true;
+    #[pyattr]
+    const CERT_NONE: u32 = CertRequirements::None as u32;
+    #[pyattr]
+    const CERT_OPTIONAL: u32 = CertRequirements::Optional as u32;
+    #[pyattr]
+    const CERT_REQUIRED: u32 = CertRequirements::Required as u32;
+    #[pyattr]
+    const VERIFY_DEFAULT: u32 = 0;
+    #[pyattr]
+    const HAS_SNI: bool = true;
+    #[pyattr]
+    const HAS_ECDH: bool = true;
+    #[pyattr]
+    const HAS_NPN: bool = false;
+    #[pyattr]
+    const HAS_ALPN: bool = true;
+    #[pyattr]
+    const HAS_SSLv2: bool = false;
+    #[pyattr]
+    const HAS_SSLv3: bool = false;
+    #[pyattr]
+    const HAS_TLSv1: bool = true;
+    #[pyattr]
+    const HAS_TLSv1_1: bool = true;
+    #[pyattr]
+    const HAS_TLSv1_2: bool = true;
+    #[pyattr]
+    const HAS_TLSv1_3: bool = cfg!(ossl111);
+    #[pyattr]
+    const HAS_PSK: bool = true;
+
+    // Encoding constants for Certificate.public_bytes()
+    #[pyattr]
+    pub(crate) const ENCODING_PEM: i32 = sys::X509_FILETYPE_PEM;
+    #[pyattr]
+    pub(crate) const ENCODING_DER: i32 = sys::X509_FILETYPE_ASN1;
+    #[pyattr]
+    const ENCODING_PEM_AUX: i32 = sys::X509_FILETYPE_PEM + 0x100;
+
+    // OpenSSL error codes for unexpected EOF detection
+    const ERR_LIB_SSL: i32 = 20;
+    const SSL_R_UNEXPECTED_EOF_WHILE_READING: i32 = 294;
+
+    // SSL_VERIFY constants for post-handshake authentication
+    #[cfg(ossl111)]
+    const SSL_VERIFY_POST_HANDSHAKE: libc::c_int = 0x20;
+
+    // the openssl version from the API headers
+
+    #[pyattr(name = "OPENSSL_VERSION")]
+    fn openssl_version(_vm: &VirtualMachine) -> &str {
+        openssl::version::version()
+    }
+    #[pyattr(name = "OPENSSL_VERSION_NUMBER")]
+    fn openssl_version_number(_vm: &VirtualMachine) -> i64 {
+        openssl::version::number()
+    }
+    #[pyattr(name = "OPENSSL_VERSION_INFO")]
+    fn openssl_version_info(_vm: &VirtualMachine) -> OpensslVersionInfo {
+        parse_version_info(openssl::version::number())
+    }
+
+    #[pyattr(name = "_OPENSSL_API_VERSION")]
+    fn _openssl_api_version(_vm: &VirtualMachine) -> OpensslVersionInfo {
+        let openssl_api_version = i64::from_str_radix(env!("OPENSSL_API_VERSION"), 16)
+            .expect("OPENSSL_API_VERSION is malformed");
+        parse_version_info(openssl_api_version)
+    }
+
+    type OpensslVersionInfo = (u8, u8, u8, u8, u8);
+    const fn parse_version_info(mut n: i64) -> OpensslVersionInfo {
+        let status = (n & 0xF) as u8;
+        n >>= 4;
+        let patch = (n & 0xFF) as u8;
+        n >>= 8;
+        let fix = (n & 0xFF) as u8;
+        n >>= 8;
+        let minor = (n & 0xFF) as u8;
+        n >>= 8;
+        let major = (n & 0xFF) as u8;
+        (major, minor, fix, patch, status)
+    }
+
+    #[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive, PartialEq)]
+    #[repr(i32)]
+    enum SslVersion {
+        Ssl2,
+        Ssl3 = 1,
+        Tls,
+        Tls1,
+        Tls1_1,
+        Tls1_2,
+        TlsClient = 0x10,
+        TlsServer,
+    }
+
+    #[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]
+    #[repr(i32)]
+    enum ProtoVersion {
+        MinSupported = -2,
+        Ssl3 = sys::SSL3_VERSION,
+        Tls1 = sys::TLS1_VERSION,
+        Tls1_1 = sys::TLS1_1_VERSION,
+        Tls1_2 = sys::TLS1_2_VERSION,
+        #[cfg(ossl111)]
+        Tls1_3 = sys::TLS1_3_VERSION,
+        #[cfg(not(ossl111))]
+        Tls1_3 = 0x304,
+        MaxSupported = -1,
+    }
+
+    #[derive(num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]
+    #[repr(i32)]
+    enum CertRequirements {
+        None,
+        Optional,
+        Required,
+    }
+
+    #[derive(Debug, PartialEq)]
+    enum SslServerOrClient {
+        Client,
+        Server,
+    }
+
+    unsafe fn ptr2obj(ptr: *mut sys::ASN1_OBJECT) -> Option<Asn1Object> {
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { Asn1Object::from_ptr(ptr) })
+        }
+    }
+
+    fn _txt2obj(s: &CStr, no_name: bool) -> Option<Asn1Object> {
+        unsafe { ptr2obj(sys::OBJ_txt2obj(s.as_ptr(), i32::from(no_name))) }
+    }
+    fn _nid2obj(nid: Nid) -> Option<Asn1Object> {
+        unsafe { ptr2obj(sys::OBJ_nid2obj(nid.as_raw())) }
+    }
+
+    type PyNid = (libc::c_int, String, String, Option<String>);
+    fn obj2py(obj: &Asn1ObjectRef, vm: &VirtualMachine) -> PyResult<PyNid> {
+        let nid = obj.nid();
+        let short_name = nid
+            .short_name()
+            .map_err(|_| vm.new_value_error("NID has no short name".to_owned()))?
+            .to_owned();
+        let long_name = nid
+            .long_name()
+            .map_err(|_| vm.new_value_error("NID has no long name".to_owned()))?
+            .to_owned();
+        Ok((
+            nid.as_raw(),
+            short_name,
+            long_name,
+            cert::obj2txt(obj, true),
+        ))
+    }
+
+    #[derive(FromArgs)]
+    struct Txt2ObjArgs {
+        txt: PyStrRef,
+        #[pyarg(any, default = false)]
+        name: bool,
+    }
+
+    #[pyfunction]
+    fn txt2obj(args: Txt2ObjArgs, vm: &VirtualMachine) -> PyResult<PyNid> {
+        _txt2obj(&args.txt.to_cstring(vm)?, !args.name)
+            .as_deref()
+            .ok_or_else(|| vm.new_value_error(format!("unknown object '{}'", args.txt)))
+            .and_then(|obj| obj2py(obj, vm))
+    }
+
+    #[pyfunction]
+    fn nid2obj(nid: libc::c_int, vm: &VirtualMachine) -> PyResult<PyNid> {
+        _nid2obj(Nid::from_raw(nid))
+            .as_deref()
+            .ok_or_else(|| vm.new_value_error(format!("unknown NID {nid}")))
+            .and_then(|obj| obj2py(obj, vm))
+    }
+
+    // Lazily compute and cache cert file/dir paths
+    static CERT_PATHS: LazyLock<(PathBuf, PathBuf)> = LazyLock::new(|| {
+        fn path_from_cstr(c: &CStr) -> PathBuf {
+            #[cfg(unix)]
+            {
+                use std::os::unix::ffi::OsStrExt;
+                std::ffi::OsStr::from_bytes(c.to_bytes()).into()
+            }
+            #[cfg(windows)]
+            {
+                // Use lossy conversion for potential non-UTF8
+                PathBuf::from(c.to_string_lossy().as_ref())
+            }
+        }
+
+        let probe = probe();
+        let cert_file = probe
+            .cert_file
+            .as_ref()
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                path_from_cstr(unsafe { CStr::from_ptr(sys::X509_get_default_cert_file()) })
+            });
+        let cert_dir = probe
+            .cert_dir
+            .first()
+            .map(PathBuf::from)
+            .unwrap_or_else(|| {
+                path_from_cstr(unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir()) })
+            });
+        (cert_file, cert_dir)
+    });
+
+    fn get_cert_file_dir() -> (&'static Path, &'static Path) {
+        let (cert_file, cert_dir) = &*CERT_PATHS;
+        (cert_file.as_path(), cert_dir.as_path())
+    }
+
+    // Lazily compute and cache cert environment variable names
+    static CERT_ENV_NAMES: LazyLock<(String, String)> = LazyLock::new(|| {
+        let cert_file_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_file_env()) }
+            .to_string_lossy()
+            .into_owned();
+        let cert_dir_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir_env()) }
+            .to_string_lossy()
+            .into_owned();
+        (cert_file_env, cert_dir_env)
+    });
+
+    #[pyfunction]
+    fn get_default_verify_paths(
+        vm: &VirtualMachine,
+    ) -> PyResult<(&'static str, PyObjectRef, &'static str, PyObjectRef)> {
+        let (cert_file_env, cert_dir_env) = &*CERT_ENV_NAMES;
+        let (cert_file, cert_dir) = get_cert_file_dir();
+        let cert_file = OsPath::new_str(cert_file).filename(vm);
+        let cert_dir = OsPath::new_str(cert_dir).filename(vm);
+        Ok((
+            cert_file_env.as_str(),
+            cert_file,
+            cert_dir_env.as_str(),
+            cert_dir,
+        ))
+    }
+
+    #[pyfunction(name = "RAND_status")]
+    fn rand_status() -> i32 {
+        unsafe { sys::RAND_status() }
+    }
+
+    #[pyfunction(name = "RAND_add")]
+    fn rand_add(string: ArgStrOrBytesLike, entropy: f64) {
+        let f = |b: &[u8]| {
+            for buf in b.chunks(libc::c_int::MAX as usize) {
+                unsafe { sys::RAND_add(buf.as_ptr() as *const _, buf.len() as _, entropy) }
+            }
+        };
+        f(&string.borrow_bytes())
+    }
+
+    #[pyfunction(name = "RAND_bytes")]
+    fn rand_bytes(n: i32, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        if n < 0 {
+            return Err(vm.new_value_error("num must be positive"));
+        }
+        let mut buf = vec![0; n as usize];
+        openssl::rand::rand_bytes(&mut buf).map_err(|e| convert_openssl_error(vm, e))?;
+        Ok(buf)
+    }
+
+    // Callback data stored in SSL ex_data for SNI/msg callbacks
+    struct SniCallbackData {
+        ssl_context: PyRef<PySslContext>,
+        // Use weak reference to avoid reference cycle:
+        // PySslSocket -> SslStream -> SSL -> ex_data -> SniCallbackData -> PySslSocket
+        ssl_socket_weak: PyRef<PyWeak>,
+    }
+
+    // Thread-local storage for VirtualMachine pointer during handshake
+    // SNI callback is only called during handshake which is synchronous
+    thread_local! {
+        static HANDSHAKE_VM: core::cell::Cell<Option<*const VirtualMachine>> = const { core::cell::Cell::new(None) };
+        // SSL pointer during handshake - needed because connection lock is held during handshake
+        // and callbacks may need to access SSL without acquiring the lock
+        static HANDSHAKE_SSL_PTR: core::cell::Cell<Option<*mut sys::SSL>> = const { core::cell::Cell::new(None) };
+    }
+
+    // RAII guard to set/clear thread-local handshake context
+    struct HandshakeVmGuard {
+        _ssl_ptr: *mut sys::SSL,
+    }
+
+    impl HandshakeVmGuard {
+        fn new(vm: &VirtualMachine, ssl_ptr: *mut sys::SSL) -> Self {
+            HANDSHAKE_VM.with(|cell| cell.set(Some(vm as *const _)));
+            HANDSHAKE_SSL_PTR.with(|cell| cell.set(Some(ssl_ptr)));
+            HandshakeVmGuard { _ssl_ptr: ssl_ptr }
+        }
+    }
+
+    impl Drop for HandshakeVmGuard {
+        fn drop(&mut self) {
+            HANDSHAKE_VM.with(|cell| cell.set(None));
+            HANDSHAKE_SSL_PTR.with(|cell| cell.set(None));
+        }
+    }
+
+    // Get SSL pointer - either from thread-local (during handshake) or from connection
+    fn get_ssl_ptr_for_context_change(connection: &PyRwLock<SslConnection>) -> *mut sys::SSL {
+        // First check if we're in a handshake callback (lock already held)
+        if let Some(ptr) = HANDSHAKE_SSL_PTR.with(|cell| cell.get()) {
+            return ptr;
+        }
+        // Otherwise, acquire the lock normally
+        connection.read().ssl().as_ptr()
+    }
+
+    // Get or create an ex_data index for SNI callback data
+    fn get_sni_ex_data_index() -> libc::c_int {
+        use std::sync::LazyLock;
+        static SNI_EX_DATA_IDX: LazyLock<libc::c_int> = LazyLock::new(|| unsafe {
+            sys::SSL_get_ex_new_index(
+                0,
+                std::ptr::null_mut(),
+                None,
+                None,
+                Some(sni_callback_data_free),
+            )
+        });
+        *SNI_EX_DATA_IDX
+    }
+
+    // Free function for callback data
+    // NOTE: We don't free the data here because it's managed manually in do_handshake
+    // to avoid use-after-free when the SSL object is dropped after timeout
+    unsafe extern "C" fn sni_callback_data_free(
+        _parent: *mut libc::c_void,
+        _ptr: *mut libc::c_void,
+        _ad: *mut sys::CRYPTO_EX_DATA,
+        _idx: libc::c_int,
+        _argl: libc::c_long,
+        _argp: *mut libc::c_void,
+    ) {
+        // Intentionally empty - data is freed in cleanup_sni_ex_data()
+    }
+
+    // Clean up SNI callback data from SSL ex_data
+    // Called after handshake to free the data and release references
+    unsafe fn cleanup_sni_ex_data(ssl_ptr: *mut sys::SSL) {
+        unsafe {
+            let idx = get_sni_ex_data_index();
+            let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
+            if !data_ptr.is_null() {
+                // Free the Box<SniCallbackData> - this releases references to context and socket
+                let _ = Box::from_raw(data_ptr as *mut SniCallbackData);
+                // Clear the ex_data to prevent double-free
+                sys::SSL_set_ex_data(ssl_ptr, idx, std::ptr::null_mut());
+            }
+        }
+    }
+
+    // Get or create an ex_data index for msg_callback data
+    fn get_msg_callback_ex_data_index() -> libc::c_int {
+        use std::sync::LazyLock;
+        static MSG_CB_EX_DATA_IDX: LazyLock<libc::c_int> = LazyLock::new(|| unsafe {
+            sys::SSL_get_ex_new_index(
+                0,
+                std::ptr::null_mut(),
+                None,
+                None,
+                Some(msg_callback_data_free),
+            )
+        });
+        *MSG_CB_EX_DATA_IDX
+    }
+
+    // Free function for msg_callback data - called by OpenSSL when SSL is freed
+    unsafe extern "C" fn msg_callback_data_free(
+        _parent: *mut libc::c_void,
+        ptr: *mut libc::c_void,
+        _ad: *mut sys::CRYPTO_EX_DATA,
+        _idx: libc::c_int,
+        _argl: libc::c_long,
+        _argp: *mut libc::c_void,
+    ) {
+        if !ptr.is_null() {
+            unsafe {
+                // Reconstruct PyObjectRef and drop to decrement reference count
+                let raw = std::ptr::NonNull::new_unchecked(ptr as *mut PyObject);
+                let _ = PyObjectRef::from_raw(raw);
+            }
+        }
+    }
+
+    // SNI callback function called by OpenSSL
+    unsafe extern "C" fn _servername_callback(
+        ssl_ptr: *mut sys::SSL,
+        al: *mut libc::c_int,
+        arg: *mut libc::c_void,
+    ) -> libc::c_int {
+        const SSL_TLSEXT_ERR_OK: libc::c_int = 0;
+        const SSL_TLSEXT_ERR_ALERT_FATAL: libc::c_int = 2;
+        const SSL_AD_INTERNAL_ERROR: libc::c_int = 80;
+        const TLSEXT_NAMETYPE_host_name: libc::c_int = 0;
+
+        if arg.is_null() {
+            return SSL_TLSEXT_ERR_OK;
+        }
+
+        unsafe {
+            let ctx = &*(arg as *const PySslContext);
+
+            // Get the callback
+            let callback_opt = ctx.sni_callback.lock().clone();
+            let Some(callback) = callback_opt else {
+                return SSL_TLSEXT_ERR_OK;
+            };
+
+            // Get callback data from SSL ex_data
+            let idx = get_sni_ex_data_index();
+            let data_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
+            if data_ptr.is_null() {
+                return SSL_TLSEXT_ERR_ALERT_FATAL;
+            }
+
+            let callback_data = &*(data_ptr as *const SniCallbackData);
+
+            // Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)
+            let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {
+                // VM not available - this shouldn't happen during handshake
+                *al = SSL_AD_INTERNAL_ERROR;
+                return SSL_TLSEXT_ERR_ALERT_FATAL;
+            };
+            let vm = &*vm_ptr;
+
+            // Get server name
+            let servername = sys::SSL_get_servername(ssl_ptr, TLSEXT_NAMETYPE_host_name);
+            let server_name_arg = if servername.is_null() {
+                vm.ctx.none()
+            } else {
+                let name_cstr = std::ffi::CStr::from_ptr(servername);
+                match name_cstr.to_str() {
+                    Ok(name_str) => vm.ctx.new_str(name_str).into(),
+                    Err(_) => vm.ctx.none(),
+                }
+            };
+
+            // Get SSL socket from callback data via weak reference
+            let ssl_socket_obj = callback_data
+                .ssl_socket_weak
+                .upgrade()
+                .unwrap_or_else(|| vm.ctx.none());
+
+            // Call the Python callback
+            match callback.call(
+                (
+                    ssl_socket_obj,
+                    server_name_arg,
+                    callback_data.ssl_context.to_owned(),
+                ),
+                vm,
+            ) {
+                Ok(result) => {
+                    // Check return value type (must be None or integer)
+                    if vm.is_none(&result) {
+                        // None is OK
+                        SSL_TLSEXT_ERR_OK
+                    } else {
+                        // Try to convert to integer
+                        match result.try_to_value::<i32>(vm) {
+                            Ok(alert_code) => {
+                                // Valid integer - use as alert code
+                                *al = alert_code;
+                                SSL_TLSEXT_ERR_ALERT_FATAL
+                            }
+                            Err(_) => {
+                                // Type conversion failed - raise TypeError
+                                let type_error = vm.new_type_error(format!(
+                                    "servername callback must return None or an integer, not '{}'",
+                                    result.class().name()
+                                ));
+                                vm.run_unraisable(type_error, None, result);
+                                *al = SSL_AD_INTERNAL_ERROR;
+                                SSL_TLSEXT_ERR_ALERT_FATAL
+                            }
+                        }
+                    }
+                }
+                Err(exc) => {
+                    // Log the exception but don't propagate it
+                    vm.run_unraisable(exc, None, vm.ctx.none());
+                    *al = SSL_AD_INTERNAL_ERROR;
+                    SSL_TLSEXT_ERR_ALERT_FATAL
+                }
+            }
+        }
+    }
+
+    // OpenSSL record type constants for msg_callback
+    const SSL3_RT_CHANGE_CIPHER_SPEC: i32 = 20;
+    const SSL3_RT_ALERT: i32 = 21;
+    const SSL3_RT_HANDSHAKE: i32 = 22;
+    const SSL3_RT_HEADER: i32 = 256;
+    const SSL3_RT_INNER_CONTENT_TYPE: i32 = 257;
+    // Special value for change cipher spec (CPython compatibility)
+    const SSL3_MT_CHANGE_CIPHER_SPEC: i32 = 0x0101;
+
+    // Message callback function called by OpenSSL
+    // Called during SSL operations to report protocol messages.
+    // debughelpers.c:_PySSL_msg_callback
+    unsafe extern "C" fn _msg_callback(
+        write_p: libc::c_int,
+        mut version: libc::c_int,
+        content_type: libc::c_int,
+        buf: *const libc::c_void,
+        len: usize,
+        ssl_ptr: *mut sys::SSL,
+        _arg: *mut libc::c_void,
+    ) {
+        if ssl_ptr.is_null() {
+            return;
+        }
+
+        unsafe {
+            // Get SSL socket from ex_data using the dedicated index
+            let idx = get_msg_callback_ex_data_index();
+            let ssl_socket_ptr = sys::SSL_get_ex_data(ssl_ptr, idx);
+            if ssl_socket_ptr.is_null() {
+                return;
+            }
+
+            // ssl_socket_ptr is a pointer to Box<Py<PySslSocket>>, set in _wrap_socket/_wrap_bio
+            let ssl_socket: &Py<PySslSocket> = &*(ssl_socket_ptr as *const Py<PySslSocket>);
+
+            // Get the callback from the context
+            let callback_opt = ssl_socket.ctx.read().msg_callback.lock().clone();
+            let Some(callback) = callback_opt else {
+                return;
+            };
+
+            // Get VM from thread-local storage (set by HandshakeVmGuard in do_handshake)
+            let Some(vm_ptr) = HANDSHAKE_VM.with(|cell| cell.get()) else {
+                // VM not available - this shouldn't happen during handshake
+                return;
+            };
+            let vm = &*vm_ptr;
+
+            // Get SSL socket owner object
+            let ssl_socket_obj = ssl_socket
+                .owner
+                .read()
+                .as_ref()
+                .and_then(|weak| weak.upgrade())
+                .unwrap_or_else(|| vm.ctx.none());
+
+            // Create the message bytes
+            let buf_slice = std::slice::from_raw_parts(buf as *const u8, len);
+            let msg_bytes = vm.ctx.new_bytes(buf_slice.to_vec());
+
+            // Determine direction string
+            let direction_str = if write_p != 0 { "write" } else { "read" };
+
+            // Calculate msg_type based on content_type (debughelpers.c behavior)
+            let msg_type = match content_type {
+                SSL3_RT_CHANGE_CIPHER_SPEC => SSL3_MT_CHANGE_CIPHER_SPEC,
+                SSL3_RT_ALERT => {
+                    // byte 1 is alert type
+                    if len >= 2 { buf_slice[1] as i32 } else { -1 }
+                }
+                SSL3_RT_HANDSHAKE => {
+                    // byte 0 is handshake type
+                    if !buf_slice.is_empty() {
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                SSL3_RT_HEADER => {
+                    // Frame header: version in bytes 1..2, type in byte 0
+                    if len >= 3 {
+                        version = ((buf_slice[1] as i32) << 8) | (buf_slice[2] as i32);
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                SSL3_RT_INNER_CONTENT_TYPE => {
+                    // Inner content type in byte 0
+                    if !buf_slice.is_empty() {
+                        buf_slice[0] as i32
+                    } else {
+                        -1
+                    }
+                }
+                _ => -1,
+            };
+
+            // Call the Python callback
+            // Signature: callback(conn, direction, version, content_type, msg_type, data)
+            match callback.call(
+                (
+                    ssl_socket_obj,
+                    vm.ctx.new_str(direction_str),
+                    vm.ctx.new_int(version),
+                    vm.ctx.new_int(content_type),
+                    vm.ctx.new_int(msg_type),
+                    msg_bytes,
+                ),
+                vm,
+            ) {
+                Ok(_) => {}
+                Err(exc) => {
+                    // Log the exception but don't propagate it
+                    vm.run_unraisable(exc, None, vm.ctx.none());
+                }
+            }
+        }
+    }
+
+    #[pyfunction(name = "RAND_pseudo_bytes")]
+    fn rand_pseudo_bytes(n: i32, vm: &VirtualMachine) -> PyResult<(Vec<u8>, bool)> {
+        if n < 0 {
+            return Err(vm.new_value_error("num must be positive"));
+        }
+        let mut buf = vec![0; n as usize];
+        let ret = unsafe { sys::RAND_bytes(buf.as_mut_ptr(), n) };
+        match ret {
+            0 | 1 => Ok((buf, ret == 1)),
+            _ => Err(convert_openssl_error(vm, ErrorStack::get())),
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "ssl", name = "_SSLContext")]
+    #[derive(PyPayload)]
+    struct PySslContext {
+        ctx: PyRwLock<SslContextBuilder>,
+        check_hostname: AtomicCell<bool>,
+        protocol: SslVersion,
+        post_handshake_auth: PyMutex<bool>,
+        sni_callback: PyMutex<Option<PyObjectRef>>,
+        msg_callback: PyMutex<Option<PyObjectRef>>,
+        psk_client_callback: PyMutex<Option<PyObjectRef>>,
+        psk_server_callback: PyMutex<Option<PyObjectRef>>,
+        psk_identity_hint: PyMutex<Option<String>>,
+    }
+
+    impl fmt::Debug for PySslContext {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("_SSLContext")
+        }
+    }
+
+    fn builder_as_ctx(x: &SslContextBuilder) -> &ssl::SslContextRef {
+        unsafe { ssl::SslContextRef::from_ptr(x.as_ptr()) }
+    }
+
+    impl Constructor for PySslContext {
+        type Args = i32;
+
+        fn py_new(
+            _cls: &Py<PyType>,
+            proto_version: Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            let proto = SslVersion::try_from(proto_version)
+                .map_err(|_| vm.new_value_error("invalid protocol version"))?;
+            let method = match proto {
+                // SslVersion::Ssl3 => unsafe { ssl::SslMethod::from_ptr(sys::SSLv3_method()) },
+                SslVersion::Tls => ssl::SslMethod::tls(),
+                SslVersion::Tls1 => ssl::SslMethod::tls(),
+                SslVersion::Tls1_1 => ssl::SslMethod::tls(),
+                SslVersion::Tls1_2 => ssl::SslMethod::tls(),
+                SslVersion::TlsClient => ssl::SslMethod::tls_client(),
+                SslVersion::TlsServer => ssl::SslMethod::tls_server(),
+                _ => return Err(vm.new_value_error("invalid protocol version")),
+            };
+            let mut builder =
+                SslContextBuilder::new(method).map_err(|e| convert_openssl_error(vm, e))?;
+
+            #[cfg(target_os = "android")]
+            android::load_client_ca_list(vm, &mut builder)?;
+
+            let check_hostname = proto == SslVersion::TlsClient;
+            builder.set_verify(if check_hostname {
+                SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
+            } else {
+                SslVerifyMode::NONE
+            });
+
+            // Start with OP_ALL but remove options that CPython doesn't include by default
+            let mut options = SslOptions::ALL & !SslOptions::DONT_INSERT_EMPTY_FRAGMENTS;
+            if proto != SslVersion::Ssl2 {
+                options |= SslOptions::NO_SSLV2;
+            }
+            if proto != SslVersion::Ssl3 {
+                options |= SslOptions::NO_SSLV3;
+            }
+            options |= SslOptions::NO_COMPRESSION;
+            options |= SslOptions::CIPHER_SERVER_PREFERENCE;
+            options |= SslOptions::SINGLE_DH_USE;
+            options |= SslOptions::SINGLE_ECDH_USE;
+            options |= SslOptions::ENABLE_MIDDLEBOX_COMPAT;
+            builder.set_options(options);
+            // Remove NO_TLSv1 and NO_TLSv1_1 which newer OpenSSL adds to OP_ALL
+            builder.clear_options(SslOptions::NO_TLSV1 | SslOptions::NO_TLSV1_1);
+
+            let mode = ssl::SslMode::ACCEPT_MOVING_WRITE_BUFFER | ssl::SslMode::AUTO_RETRY;
+            builder.set_mode(mode);
+
+            #[cfg(ossl111)]
+            unsafe {
+                sys::SSL_CTX_set_post_handshake_auth(builder.as_ptr(), 0);
+            }
+
+            // Note: Unlike some other implementations, we do NOT set session_id_context at the
+            // context level. CPython sets it only on individual SSL objects (server-side only).
+            // This matches CPython's behavior in _ssl.c where SSL_set_session_id_context is called
+            // in newPySSLSocket() at line 862, not during context creation.
+
+            // Set protocol version limits based on the protocol version
+            unsafe {
+                let ctx_ptr = builder.as_ptr();
+                match proto {
+                    SslVersion::Tls1 => {
+                        sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_VERSION);
+                        sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_VERSION);
+                    }
+                    SslVersion::Tls1_1 => {
+                        sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_1_VERSION);
+                        sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_1_VERSION);
+                    }
+                    SslVersion::Tls1_2 => {
+                        sys::SSL_CTX_set_min_proto_version(ctx_ptr, sys::TLS1_2_VERSION);
+                        sys::SSL_CTX_set_max_proto_version(ctx_ptr, sys::TLS1_2_VERSION);
+                    }
+                    _ => {
+                        // For Tls, TlsClient, TlsServer, use default (no restrictions)
+                    }
+                }
+            }
+
+            // Set default verify flags: VERIFY_X509_TRUSTED_FIRST
+            unsafe {
+                let ctx_ptr = builder.as_ptr();
+                let param = sys::SSL_CTX_get0_param(ctx_ptr);
+                sys::X509_VERIFY_PARAM_set_flags(param, sys::X509_V_FLAG_TRUSTED_FIRST);
+            }
+
+            Ok(PySslContext {
+                ctx: PyRwLock::new(builder),
+                check_hostname: AtomicCell::new(check_hostname),
+                protocol: proto,
+                post_handshake_auth: PyMutex::new(false),
+                sni_callback: PyMutex::new(None),
+                msg_callback: PyMutex::new(None),
+                psk_client_callback: PyMutex::new(None),
+                psk_server_callback: PyMutex::new(None),
+                psk_identity_hint: PyMutex::new(None),
+            })
+        }
+    }
+
+    #[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor))]
+    impl PySslContext {
+        fn builder(&self) -> PyRwLockWriteGuard<'_, SslContextBuilder> {
+            self.ctx.write()
+        }
+        fn ctx(&self) -> PyMappedRwLockReadGuard<'_, ssl::SslContextRef> {
+            PyRwLockReadGuard::map(self.ctx.read(), builder_as_ctx)
+        }
+
+        #[pygetset]
+        fn post_handshake_auth(&self) -> bool {
+            *self.post_handshake_auth.lock()
+        }
+        #[pygetset(setter)]
+        fn set_post_handshake_auth(
+            &self,
+            value: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let value = value.ok_or_else(|| vm.new_attribute_error("cannot delete attribute"))?;
+            *self.post_handshake_auth.lock() = value.is_true(vm)?;
+            Ok(())
+        }
+
+        #[cfg(ossl110)]
+        #[pygetset]
+        fn security_level(&self) -> i32 {
+            unsafe { SSL_CTX_get_security_level(self.ctx().as_ptr()) }
+        }
+
+        #[pymethod]
+        fn set_ciphers(&self, cipherlist: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+            let ciphers = cipherlist.as_str();
+            if ciphers.contains('\0') {
+                return Err(exceptions::cstring_error(vm));
+            }
+            self.builder()
+                .set_cipher_list(ciphers)
+                .map_err(|_| new_ssl_error(vm, "No cipher can be selected."))
+        }
+
+        #[pymethod]
+        fn get_ciphers(&self, vm: &VirtualMachine) -> PyResult<PyListRef> {
+            let ctx = self.ctx();
+            let ssl = ssl::Ssl::new(&ctx).map_err(|e| convert_openssl_error(vm, e))?;
+
+            unsafe {
+                let ciphers_ptr = SSL_get_ciphers(ssl.as_ptr());
+                if ciphers_ptr.is_null() {
+                    return Ok(vm.ctx.new_list(vec![]));
+                }
+
+                let num_ciphers = sys::OPENSSL_sk_num(ciphers_ptr as *const _);
+                let mut result = Vec::new();
+
+                for i in 0..num_ciphers {
+                    let cipher_ptr =
+                        sys::OPENSSL_sk_value(ciphers_ptr as *const _, i) as *const sys::SSL_CIPHER;
+                    let cipher = ssl::SslCipherRef::from_ptr(cipher_ptr as *mut _);
+
+                    let (name, version, bits) = cipher_to_tuple(cipher);
+                    let dict = vm.ctx.new_dict();
+                    dict.set_item("name", vm.ctx.new_str(name).into(), vm)?;
+                    dict.set_item("protocol", vm.ctx.new_str(version).into(), vm)?;
+                    dict.set_item("secret_bits", vm.ctx.new_int(bits).into(), vm)?;
+
+                    // Add description field
+                    let description = cipher_description(cipher_ptr);
+                    dict.set_item("description", vm.ctx.new_str(description).into(), vm)?;
+
+                    result.push(dict.into());
+                }
+
+                Ok(vm.ctx.new_list(result))
+            }
+        }
+
+        #[pymethod]
+        fn set_ecdh_curve(
+            &self,
+            name: Either<PyStrRef, ArgBytesLike>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            use openssl::ec::{EcGroup, EcKey};
+
+            // Convert name to CString, supporting both str and bytes
+            let name_cstr = match name {
+                Either::A(s) => {
+                    if s.as_str().contains('\0') {
+                        return Err(exceptions::cstring_error(vm));
+                    }
+                    s.to_cstring(vm)?
+                }
+                Either::B(b) => std::ffi::CString::new(b.borrow_buf().to_vec())
+                    .map_err(|_| exceptions::cstring_error(vm))?,
+            };
+
+            // Find the NID for the curve name using OBJ_sn2nid
+            let nid_raw = unsafe { sys::OBJ_sn2nid(name_cstr.as_ptr()) };
+            if nid_raw == 0 {
+                return Err(vm.new_value_error("unknown curve name"));
+            }
+            let nid = Nid::from_raw(nid_raw);
+
+            // Create EC key from the curve
+            let group = EcGroup::from_curve_name(nid).map_err(|e| convert_openssl_error(vm, e))?;
+            let key = EcKey::from_group(&group).map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Set the temporary ECDH key
+            self.builder()
+                .set_tmp_ecdh(&key)
+                .map_err(|e| convert_openssl_error(vm, e))
+        }
+
+        #[pygetset]
+        fn options(&self) -> libc::c_ulong {
+            self.ctx.read().options().bits() as _
+        }
+        #[pygetset(setter)]
+        fn set_options(&self, new_opts: libc::c_ulong) {
+            let mut ctx = self.builder();
+            // Get current options
+            let current = ctx.options().bits() as libc::c_ulong;
+
+            // Calculate options to clear and set
+            let clear = current & !new_opts;
+            let set = !current & new_opts;
+
+            // Clear options first (using raw FFI since openssl crate doesn't expose clear_options)
+            if clear != 0 {
+                unsafe {
+                    sys::SSL_CTX_clear_options(ctx.as_ptr(), clear);
+                }
+            }
+
+            // Then set new options
+            if set != 0 {
+                ctx.set_options(SslOptions::from_bits_truncate(set as _));
+            }
+        }
+        #[pygetset]
+        fn protocol(&self) -> i32 {
+            self.protocol as i32
+        }
+        #[pygetset]
+        fn verify_mode(&self) -> i32 {
+            let mode = self.ctx().verify_mode();
+            if mode == SslVerifyMode::NONE {
+                CertRequirements::None.into()
+            } else if mode == SslVerifyMode::PEER {
+                CertRequirements::Optional.into()
+            } else if mode == SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT {
+                CertRequirements::Required.into()
+            } else {
+                unreachable!()
+            }
+        }
+        #[pygetset(setter)]
+        fn set_verify_mode(&self, cert: i32, vm: &VirtualMachine) -> PyResult<()> {
+            let mut ctx = self.builder();
+            let cert_req = CertRequirements::try_from(cert)
+                .map_err(|_| vm.new_value_error("invalid value for verify_mode"))?;
+            let mode = match cert_req {
+                CertRequirements::None if self.check_hostname.load() => {
+                    return Err(vm.new_value_error(
+                        "Cannot set verify_mode to CERT_NONE when check_hostname is enabled.",
+                    ));
+                }
+                CertRequirements::None => SslVerifyMode::NONE,
+                CertRequirements::Optional => SslVerifyMode::PEER,
+                CertRequirements::Required => {
+                    SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
+                }
+            };
+            ctx.set_verify(mode);
+            Ok(())
+        }
+        #[pygetset]
+        fn verify_flags(&self) -> libc::c_ulong {
+            unsafe {
+                let ctx_ptr = self.ctx().as_ptr();
+                let param = sys::SSL_CTX_get0_param(ctx_ptr);
+                sys::X509_VERIFY_PARAM_get_flags(param)
+            }
+        }
+        #[pygetset(setter)]
+        fn set_verify_flags(&self, new_flags: libc::c_ulong, vm: &VirtualMachine) -> PyResult<()> {
+            unsafe {
+                let ctx_ptr = self.ctx().as_ptr();
+                let param = sys::SSL_CTX_get0_param(ctx_ptr);
+                let flags = sys::X509_VERIFY_PARAM_get_flags(param);
+                let clear = flags & !new_flags;
+                let set = !flags & new_flags;
+
+                if clear != 0 && sys::X509_VERIFY_PARAM_clear_flags(param, clear) == 0 {
+                    return Err(new_ssl_error(vm, "Failed to clear verify flags"));
+                }
+                if set != 0 && sys::X509_VERIFY_PARAM_set_flags(param, set) == 0 {
+                    return Err(new_ssl_error(vm, "Failed to set verify flags"));
+                }
+                Ok(())
+            }
+        }
+        #[pygetset]
+        fn check_hostname(&self) -> bool {
+            self.check_hostname.load()
+        }
+        #[pygetset(setter)]
+        fn set_check_hostname(&self, ch: bool) {
+            let mut ctx = self.builder();
+            if ch && builder_as_ctx(&ctx).verify_mode() == SslVerifyMode::NONE {
+                ctx.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
+            }
+            self.check_hostname.store(ch);
+        }
+
+        // PY_PROTO_MINIMUM_SUPPORTED = -2, PY_PROTO_MAXIMUM_SUPPORTED = -1
+        #[pygetset]
+        fn minimum_version(&self) -> i32 {
+            let ctx = self.ctx();
+            let version = unsafe { sys::SSL_CTX_get_min_proto_version(ctx.as_ptr()) };
+            if version == 0 {
+                -2 // PY_PROTO_MINIMUM_SUPPORTED
+            } else {
+                version
+            }
+        }
+        #[pygetset(setter)]
+        fn set_minimum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
+            // Handle special values
+            let proto_version = match value {
+                -2 => {
+                    // PY_PROTO_MINIMUM_SUPPORTED -> use minimum available (TLS 1.2)
+                    sys::TLS1_2_VERSION
+                }
+                -1 => {
+                    // PY_PROTO_MAXIMUM_SUPPORTED -> use maximum available
+                    // For max on min_proto_version, we use the newest available
+                    sys::TLS1_3_VERSION
+                }
+                _ => value,
+            };
+
+            let ctx = self.builder();
+            let result = unsafe { sys::SSL_CTX_set_min_proto_version(ctx.as_ptr(), proto_version) };
+            if result == 0 {
+                return Err(vm.new_value_error("invalid protocol version"));
+            }
+            Ok(())
+        }
+
+        #[pygetset]
+        fn maximum_version(&self) -> i32 {
+            let ctx = self.ctx();
+            let version = unsafe { sys::SSL_CTX_get_max_proto_version(ctx.as_ptr()) };
+            if version == 0 {
+                -1 // PY_PROTO_MAXIMUM_SUPPORTED
+            } else {
+                version
+            }
+        }
+        #[pygetset(setter)]
+        fn set_maximum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
+            // Handle special values
+            let proto_version = match value {
+                -1 => {
+                    // PY_PROTO_MAXIMUM_SUPPORTED -> use 0 for OpenSSL (means no limit)
+                    0
+                }
+                -2 => {
+                    // PY_PROTO_MINIMUM_SUPPORTED -> use minimum available (TLS 1.2)
+                    sys::TLS1_2_VERSION
+                }
+                _ => value,
+            };
+
+            let ctx = self.builder();
+            let result = unsafe { sys::SSL_CTX_set_max_proto_version(ctx.as_ptr(), proto_version) };
+            if result == 0 {
+                return Err(vm.new_value_error("invalid protocol version"));
+            }
+            Ok(())
+        }
+
+        #[pygetset]
+        fn num_tickets(&self, _vm: &VirtualMachine) -> PyResult<usize> {
+            // Only supported for TLS 1.3
+            #[cfg(ossl110)]
+            {
+                let ctx = self.ctx();
+                let num = unsafe { sys::SSL_CTX_get_num_tickets(ctx.as_ptr()) };
+                Ok(num)
+            }
+            #[cfg(not(ossl110))]
+            {
+                Ok(0)
+            }
+        }
+        #[pygetset(setter)]
+        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())
+                );
+            }
+
+            // 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()));
+            }
+
+            #[cfg(ossl110)]
+            {
+                let ctx = self.builder();
+                let result = unsafe { sys::SSL_CTX_set_num_tickets(ctx.as_ptr(), value as usize) };
+                if result != 1 {
+                    return Err(vm.new_value_error("failed to set num tickets."));
+                }
+                Ok(())
+            }
+            #[cfg(not(ossl110))]
+            {
+                let _ = (value, vm);
+                Ok(())
+            }
+        }
+
+        #[pymethod]
+        fn set_default_verify_paths(&self, vm: &VirtualMachine) -> PyResult<()> {
+            cfg_if::cfg_if! {
+                if #[cfg(openssl_vendored)] {
+                    let (cert_file, cert_dir) = get_cert_file_dir();
+                    self.builder()
+                        .load_verify_locations(Some(cert_file), Some(cert_dir))
+                        .map_err(|e| convert_openssl_error(vm, e))
+                } else {
+                    self.builder()
+                        .set_default_verify_paths()
+                        .map_err(|e| convert_openssl_error(vm, e))
+                }
+            }
+        }
+
+        #[pymethod]
+        fn _set_alpn_protocols(&self, protos: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
+            #[cfg(ossl102)]
+            {
+                let mut ctx = self.builder();
+                let server = protos.with_ref(|pbuf| {
+                    if pbuf.len() > libc::c_uint::MAX as usize {
+                        return Err(vm.new_overflow_error(format!(
+                            "protocols longer than {} bytes",
+                            libc::c_uint::MAX
+                        )));
+                    }
+                    ctx.set_alpn_protos(pbuf)
+                        .map_err(|e| convert_openssl_error(vm, e))?;
+                    Ok(pbuf.to_vec())
+                })?;
+                ctx.set_alpn_select_callback(move |_, client| {
+                    let proto =
+                        ssl::select_next_proto(&server, client).ok_or(ssl::AlpnError::NOACK)?;
+                    let pos = memchr::memmem::find(client, proto)
+                        .expect("selected alpn proto should be present in client protos");
+                    Ok(&client[pos..pos + proto.len()])
+                });
+                Ok(())
+            }
+            #[cfg(not(ossl102))]
+            {
+                Err(vm.new_not_implemented_error(
+                    "The NPN extension requires OpenSSL 1.0.1 or later.",
+                ))
+            }
+        }
+
+        #[pymethod]
+        fn set_psk_client_callback(
+            &self,
+            callback: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Cannot add PSK client callback to a server context
+            if self.protocol == SslVersion::TlsServer {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot add PSK client callback to a PROTOCOL_TLS_SERVER context"
+                            .to_owned(),
+                    )
+                    .upcast());
+            }
+
+            if vm.is_none(&callback) {
+                *self.psk_client_callback.lock() = None;
+                unsafe {
+                    sys::SSL_CTX_set_psk_client_callback(self.builder().as_ptr(), None);
+                }
+            } else {
+                if !callback.is_callable() {
+                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                }
+                *self.psk_client_callback.lock() = Some(callback);
+                // Note: The actual callback will be invoked via SSL app_data mechanism
+                // when do_handshake is called
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_psk_server_callback(
+            &self,
+            callback: PyObjectRef,
+            identity_hint: OptionalArg<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Cannot add PSK server callback to a client context
+            if self.protocol == SslVersion::TlsClient {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot add PSK server callback to a PROTOCOL_TLS_CLIENT context"
+                            .to_owned(),
+                    )
+                    .upcast());
+            }
+
+            if vm.is_none(&callback) {
+                *self.psk_server_callback.lock() = None;
+                *self.psk_identity_hint.lock() = None;
+                unsafe {
+                    sys::SSL_CTX_set_psk_server_callback(self.builder().as_ptr(), None);
+                }
+            } else {
+                if !callback.is_callable() {
+                    return Err(vm.new_type_error("callback must be callable".to_owned()));
+                }
+                *self.psk_server_callback.lock() = Some(callback);
+                if let OptionalArg::Present(hint) = identity_hint {
+                    *self.psk_identity_hint.lock() = Some(hint.as_str().to_owned());
+                }
+                // Note: The actual callback will be invoked via SSL app_data mechanism
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn load_verify_locations(
+            &self,
+            args: LoadVerifyLocationsArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            if let (None, None, None) = (&args.cafile, &args.capath, &args.cadata) {
+                return Err(vm.new_type_error("cafile, capath and cadata cannot be all omitted"));
+            }
+
+            #[cold]
+            fn invalid_cadata(vm: &VirtualMachine) -> PyBaseExceptionRef {
+                vm.new_type_error("cadata should be an ASCII string or a bytes-like object")
+            }
+
+            let mut ctx = self.builder();
+
+            // validate cadata type and load cadata
+            if let Some(cadata) = args.cadata {
+                let (certs, is_pem) = match cadata {
+                    Either::A(s) => {
+                        if !s.as_str().is_ascii() {
+                            return Err(invalid_cadata(vm));
+                        }
+                        (X509::stack_from_pem(s.as_bytes()), true)
+                    }
+                    Either::B(b) => (b.with_ref(x509_stack_from_der), false),
+                };
+                let certs = certs.map_err(|e| convert_openssl_error(vm, e))?;
+
+                // If no certificates were loaded, raise an error
+                if certs.is_empty() {
+                    let msg = if is_pem {
+                        "no start line: cadata does not contain a certificate"
+                    } else {
+                        "not enough data: cadata does not contain a certificate"
+                    };
+                    return Err(vm
+                        .new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            msg.to_owned(),
+                        )
+                        .upcast());
+                }
+
+                let store = ctx.cert_store_mut();
+                for cert in certs {
+                    store
+                        .add_cert(cert)
+                        .map_err(|e| convert_openssl_error(vm, e))?;
+                }
+            }
+
+            if args.cafile.is_some() || args.capath.is_some() {
+                let cafile_path = args.cafile.map(|p| p.to_path_buf(vm)).transpose()?;
+                let capath_path = args.capath.map(|p| p.to_path_buf(vm)).transpose()?;
+                // Check file/directory existence before calling OpenSSL to get proper errno
+                if let Some(ref path) = cafile_path
+                    && !path.exists()
+                {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.file_not_found_error.to_owned(),
+                            Some(libc::ENOENT),
+                            format!("No such file or directory: '{}'", path.display()),
+                        )
+                        .upcast());
+                }
+                if let Some(ref path) = capath_path
+                    && !path.exists()
+                {
+                    return Err(vm
+                        .new_os_subtype_error(
+                            vm.ctx.exceptions.file_not_found_error.to_owned(),
+                            Some(libc::ENOENT),
+                            format!("No such file or directory: '{}'", path.display()),
+                        )
+                        .upcast());
+                }
+                ctx.load_verify_locations(cafile_path.as_deref(), capath_path.as_deref())
+                    .map_err(|e| convert_openssl_error(vm, e))?;
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn get_ca_certs(
+            &self,
+            args: GetCertArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<Vec<PyObjectRef>> {
+            let binary_form = args.binary_form.unwrap_or(false);
+            let ctx = self.ctx();
+            #[cfg(ossl300)]
+            let certs = ctx.cert_store().all_certificates();
+            #[cfg(not(ossl300))]
+            let certs = ctx.cert_store().objects().iter().filter_map(|x| x.x509());
+
+            // Filter to only include CA certificates (Basic Constraints: CA=TRUE)
+            let certs = certs
+                .into_iter()
+                .filter(|cert| {
+                    unsafe {
+                        // X509_check_ca() returns 1 for CA certificates
+                        X509_check_ca(cert.as_ptr()) == 1
+                    }
+                })
+                .map(|ref cert| cert_to_py(vm, cert, binary_form))
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(certs)
+        }
+
+        #[pymethod]
+        fn cert_store_stats(&self, vm: &VirtualMachine) -> PyResult {
+            let ctx = self.ctx();
+            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()));
+            }
+
+            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()));
+            }
+
+            let mut x509_count = 0;
+            let mut crl_count = 0;
+            let mut ca_count = 0;
+
+            unsafe {
+                let num_objs = sys::OPENSSL_sk_num(objs_ptr as *const _);
+                for i in 0..num_objs {
+                    let obj_ptr =
+                        sys::OPENSSL_sk_value(objs_ptr as *const _, i) as *const sys::X509_OBJECT;
+                    let obj_type = X509_OBJECT_get_type(obj_ptr);
+
+                    match obj_type {
+                        X509_LU_X509 => {
+                            x509_count += 1;
+                            let x509_ptr = sys::X509_OBJECT_get0_X509(obj_ptr);
+                            // X509_check_ca returns non-zero for any CA type
+                            if !x509_ptr.is_null() && X509_check_ca(x509_ptr) != 0 {
+                                ca_count += 1;
+                            }
+                        }
+                        X509_LU_CRL => {
+                            crl_count += 1;
+                        }
+                        _ => {
+                            // Ignore unrecognized types
+                        }
+                    }
+                }
+                // Note: No need to free objs_ptr as X509_STORE_get0_objects returns
+                // a pointer to internal data that should not be freed by the caller
+            }
+
+            let dict = vm.ctx.new_dict();
+            dict.set_item("x509", vm.ctx.new_int(x509_count).into(), vm)?;
+            dict.set_item("crl", vm.ctx.new_int(crl_count).into(), vm)?;
+            dict.set_item("x509_ca", vm.ctx.new_int(ca_count).into(), vm)?;
+            Ok(dict.into())
+        }
+
+        #[pymethod]
+        fn session_stats(&self, vm: &VirtualMachine) -> PyResult {
+            let ctx = self.ctx();
+            let ctx_ptr = ctx.as_ptr();
+
+            let dict = vm.ctx.new_dict();
+
+            macro_rules! add_stat {
+                ($key:expr, $func:ident) => {
+                    let value = unsafe { $func(ctx_ptr) };
+                    dict.set_item($key, vm.ctx.new_int(value).into(), vm)?;
+                };
+            }
+
+            add_stat!("number", SSL_CTX_sess_number);
+            add_stat!("connect", SSL_CTX_sess_connect);
+            add_stat!("connect_good", SSL_CTX_sess_connect_good);
+            add_stat!("connect_renegotiate", SSL_CTX_sess_connect_renegotiate);
+            add_stat!("accept", SSL_CTX_sess_accept);
+            add_stat!("accept_good", SSL_CTX_sess_accept_good);
+            add_stat!("accept_renegotiate", SSL_CTX_sess_accept_renegotiate);
+            add_stat!("hits", SSL_CTX_sess_hits);
+            add_stat!("misses", SSL_CTX_sess_misses);
+            add_stat!("timeouts", SSL_CTX_sess_timeouts);
+            add_stat!("cache_full", SSL_CTX_sess_cache_full);
+
+            Ok(dict.into())
+        }
+
+        #[pymethod]
+        fn load_dh_params(&self, filepath: FsPath, vm: &VirtualMachine) -> PyResult<()> {
+            let path = filepath.to_path_buf(vm)?;
+
+            // Open the file using fopen (cross-platform)
+            let fp =
+                rustpython_common::fileutils::fopen(path.as_path(), "rb").map_err(|e| {
+                    match e.kind() {
+                        std::io::ErrorKind::NotFound => vm
+                            .new_os_subtype_error(
+                                vm.ctx.exceptions.file_not_found_error.to_owned(),
+                                Some(libc::ENOENT),
+                                e.to_string(),
+                            )
+                            .upcast(),
+                        _ => vm.new_os_error(e.to_string()),
+                    }
+                })?;
+
+            // Read DH parameters
+            let dh = unsafe {
+                PEM_read_DHparams(
+                    fp,
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                    std::ptr::null_mut(),
+                )
+            };
+            unsafe {
+                libc::fclose(fp);
+            }
+
+            if dh.is_null() {
+                return Err(convert_openssl_error(vm, ErrorStack::get()));
+            }
+
+            // Set temporary DH parameters
+            let ctx = self.builder();
+            let result = unsafe { sys::SSL_CTX_set_tmp_dh(ctx.as_ptr(), dh) };
+            unsafe {
+                sys::DH_free(dh);
+            }
+
+            if result != 1 {
+                return Err(convert_openssl_error(vm, ErrorStack::get()));
+            }
+
+            Ok(())
+        }
+
+        #[pygetset]
+        fn sni_callback(&self) -> Option<PyObjectRef> {
+            self.sni_callback.lock().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set_sni_callback(
+            &self,
+            value: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> 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(),
+                ));
+            }
+
+            let mut callback_guard = self.sni_callback.lock();
+
+            if let Some(callback_obj) = value {
+                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()));
+                    }
+
+                    // Set the callback
+                    *callback_guard = Some(callback_obj);
+
+                    // Set OpenSSL callback
+                    unsafe {
+                        sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust(
+                            self.ctx().as_ptr(),
+                            Some(_servername_callback),
+                        );
+                        sys::SSL_CTX_set_tlsext_servername_arg(
+                            self.ctx().as_ptr(),
+                            self as *const _ as *mut _,
+                        );
+                    }
+                } else {
+                    // Clear callback
+                    *callback_guard = None;
+                    unsafe {
+                        sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust(
+                            self.ctx().as_ptr(),
+                            None,
+                        );
+                    }
+                }
+            } else {
+                // Clear callback
+                *callback_guard = None;
+                unsafe {
+                    sys::SSL_CTX_set_tlsext_servername_callback__fixed_rust(
+                        self.ctx().as_ptr(),
+                        None,
+                    );
+                }
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_servername_callback(
+            &self,
+            callback: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            self.set_sni_callback(callback, vm)
+        }
+
+        #[pygetset(name = "_msg_callback")]
+        fn msg_callback(&self) -> Option<PyObjectRef> {
+            self.msg_callback.lock().clone()
+        }
+
+        #[pygetset(setter, name = "_msg_callback")]
+        fn set_msg_callback(
+            &self,
+            value: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let mut callback_guard = self.msg_callback.lock();
+
+            if let Some(callback_obj) = value {
+                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()));
+                    }
+
+                    // Set the callback
+                    *callback_guard = Some(callback_obj);
+
+                    // Set OpenSSL callback
+                    unsafe {
+                        SSL_CTX_set_msg_callback(self.ctx().as_ptr(), Some(_msg_callback));
+                    }
+                } else {
+                    // Clear callback
+                    *callback_guard = None;
+                    unsafe {
+                        SSL_CTX_set_msg_callback(self.ctx().as_ptr(), None);
+                    }
+                }
+            } else {
+                // Clear callback when value is None
+                *callback_guard = None;
+                unsafe {
+                    SSL_CTX_set_msg_callback(self.ctx().as_ptr(), None);
+                }
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn load_cert_chain(&self, args: LoadCertChainArgs, vm: &VirtualMachine) -> PyResult<()> {
+            use openssl::pkey::PKey;
+            use std::cell::RefCell;
+
+            let LoadCertChainArgs {
+                certfile,
+                keyfile,
+                password,
+            } = args;
+
+            let mut ctx = self.builder();
+            let key_path = keyfile.map(|path| path.to_path_buf(vm)).transpose()?;
+            let cert_path = certfile.to_path_buf(vm)?;
+
+            // Check file existence before calling OpenSSL to get proper errno
+            if !cert_path.exists() {
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        Some(libc::ENOENT),
+                        format!("No such file or directory: '{}'", cert_path.display()),
+                    )
+                    .upcast());
+            }
+            if let Some(ref kp) = key_path
+                && !kp.exists()
+            {
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        Some(libc::ENOENT),
+                        format!("No such file or directory: '{}'", kp.display()),
+                    )
+                    .upcast());
+            }
+
+            // Load certificate chain
+            ctx.set_certificate_chain_file(&cert_path)
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Load private key - handle password if provided
+            let key_file_path = key_path.as_ref().unwrap_or(&cert_path);
+
+            // PEM_BUFSIZE = 1024 (maximum password length in OpenSSL)
+            const PEM_BUFSIZE: usize = 1024;
+
+            // Read key file data
+            let key_data = std::fs::read(key_file_path)
+                .map_err(|e| crate::vm::convert::ToPyException::to_pyexception(&e, vm))?;
+
+            let pkey = if let Some(ref pw_obj) = password {
+                if pw_obj.is_callable() {
+                    // Callable password - use callback that calls Python function
+                    // Store any Python error that occurs in the callback
+                    let py_error: RefCell<Option<PyBaseExceptionRef>> = RefCell::new(None);
+
+                    let result = PKey::private_key_from_pem_callback(&key_data, |buf| {
+                        // Call the Python password callback
+                        let pw_result = pw_obj.call((), vm);
+                        match pw_result {
+                            Ok(result) => {
+                                // Extract password bytes
+                                match Self::extract_password_bytes(
+                                    &result,
+                                    "password callback must return a string",
+                                    vm,
+                                ) {
+                                    Ok(pw) => {
+                                        // Check password length
+                                        if pw.len() > PEM_BUFSIZE {
+                                            *py_error.borrow_mut() =
+                                                Some(vm.new_value_error(format!(
+                                                    "password cannot be longer than {} bytes",
+                                                    PEM_BUFSIZE
+                                                )));
+                                            return Err(openssl::error::ErrorStack::get());
+                                        }
+                                        let len = core::cmp::min(pw.len(), buf.len());
+                                        buf[..len].copy_from_slice(&pw[..len]);
+                                        Ok(len)
+                                    }
+                                    Err(e) => {
+                                        *py_error.borrow_mut() = Some(e);
+                                        Err(openssl::error::ErrorStack::get())
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                *py_error.borrow_mut() = Some(e);
+                                Err(openssl::error::ErrorStack::get())
+                            }
+                        }
+                    });
+
+                    // Check for Python error first
+                    if let Some(py_err) = py_error.into_inner() {
+                        return Err(py_err);
+                    }
+
+                    result.map_err(|e| convert_openssl_error(vm, e))?
+                } else {
+                    // Direct password (string/bytes)
+                    let pw = Self::extract_password_bytes(
+                        pw_obj,
+                        "password should be a string or bytes",
+                        vm,
+                    )?;
+
+                    // Check password length
+                    if pw.len() > PEM_BUFSIZE {
+                        return Err(vm.new_value_error(format!(
+                            "password cannot be longer than {} bytes",
+                            PEM_BUFSIZE
+                        )));
+                    }
+
+                    PKey::private_key_from_pem_passphrase(&key_data, &pw)
+                        .map_err(|e| convert_openssl_error(vm, e))?
+                }
+            } else {
+                // No password - use SSL_CTX_use_PrivateKey_file directly for correct error messages
+                ctx.set_private_key_file(key_file_path, ssl::SslFiletype::PEM)
+                    .map_err(|e| convert_openssl_error(vm, e))?;
+
+                // Verify key matches certificate and return early
+                return ctx
+                    .check_private_key()
+                    .map_err(|e| convert_openssl_error(vm, e));
+            };
+
+            ctx.set_private_key(&pkey)
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Verify key matches certificate
+            ctx.check_private_key()
+                .map_err(|e| convert_openssl_error(vm, e))
+        }
+
+        // Helper to extract password bytes from string/bytes/bytearray
+        fn extract_password_bytes(
+            obj: &PyObject,
+            bad_type_error: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<Vec<u8>> {
+            use crate::vm::builtins::{PyByteArray, PyBytes, PyStr};
+
+            if let Some(s) = obj.downcast_ref::<PyStr>() {
+                Ok(s.as_str().as_bytes().to_vec())
+            } else if let Some(b) = obj.downcast_ref::<PyBytes>() {
+                Ok(b.as_bytes().to_vec())
+            } else if let Some(ba) = obj.downcast_ref::<PyByteArray>() {
+                Ok(ba.borrow_buf().to_vec())
+            } else {
+                Err(vm.new_type_error(bad_type_error.to_owned()))
+            }
+        }
+
+        // Helper function to create SSL socket
+        // = CPython's newPySSLSocket()
+        fn new_py_ssl_socket(
+            ctx_ref: PyRef<PySslContext>,
+            server_side: bool,
+            server_hostname: Option<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<(ssl::Ssl, SslServerOrClient, Option<PyStrRef>)> {
+            // Validate socket type and context protocol
+            if server_side && ctx_ref.protocol == SslVersion::TlsClient {
+                return Err(new_ssl_error(
+                    vm,
+                    "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context",
+                ));
+            }
+            if !server_side && ctx_ref.protocol == SslVersion::TlsServer {
+                return Err(new_ssl_error(
+                    vm,
+                    "Cannot create a client socket with a PROTOCOL_TLS_SERVER context",
+                ));
+            }
+
+            // Create SSL object
+            let mut ssl =
+                ssl::Ssl::new(&ctx_ref.ctx()).map_err(|e| convert_openssl_error(vm, e))?;
+
+            // Set session id context for server-side sockets
+            let socket_type = if server_side {
+                unsafe {
+                    const SID_CTX: &[u8] = b"Python";
+                    let ret = SSL_set_session_id_context(
+                        ssl.as_ptr(),
+                        SID_CTX.as_ptr(),
+                        SID_CTX.len() as libc::c_uint,
+                    );
+                    if ret == 0 {
+                        return Err(convert_openssl_error(vm, ErrorStack::get()));
+                    }
+                }
+                SslServerOrClient::Server
+            } else {
+                SslServerOrClient::Client
+            };
+
+            // Configure server hostname
+            if let Some(hostname) = &server_hostname {
+                let hostname_str = hostname.as_str();
+                if hostname_str.is_empty() || hostname_str.starts_with('.') {
+                    return Err(vm.new_value_error(
+                        "server_hostname cannot be an empty string or start with a leading dot.",
+                    ));
+                }
+                if hostname_str.contains('\0') {
+                    return Err(vm.new_type_error("embedded null character"));
+                }
+                let ip = hostname_str.parse::<std::net::IpAddr>();
+                if ip.is_err() {
+                    ssl.set_hostname(hostname_str)
+                        .map_err(|e| convert_openssl_error(vm, e))?;
+                }
+                if ctx_ref.check_hostname.load() {
+                    if let Ok(ip) = ip {
+                        ssl.param_mut()
+                            .set_ip(ip)
+                            .map_err(|e| convert_openssl_error(vm, e))?;
+                    } else {
+                        ssl.param_mut()
+                            .set_host(hostname_str)
+                            .map_err(|e| convert_openssl_error(vm, e))?;
+                    }
+                }
+            }
+
+            // Configure post-handshake authentication
+            #[cfg(ossl111)]
+            if *ctx_ref.post_handshake_auth.lock() {
+                unsafe {
+                    if server_side {
+                        // Server socket: add SSL_VERIFY_POST_HANDSHAKE flag
+                        // Only in combination with SSL_VERIFY_PEER
+                        let mode = sys::SSL_get_verify_mode(ssl.as_ptr());
+                        if (mode & sys::SSL_VERIFY_PEER as libc::c_int) != 0 {
+                            sys::SSL_set_verify(
+                                ssl.as_ptr(),
+                                mode | SSL_VERIFY_POST_HANDSHAKE,
+                                None,
+                            );
+                        }
+                    } else {
+                        // Client socket: call SSL_set_post_handshake_auth
+                        SSL_set_post_handshake_auth(ssl.as_ptr(), 1);
+                    }
+                }
+            }
+
+            // Set connect/accept state
+            if server_side {
+                ssl.set_accept_state();
+            } else {
+                ssl.set_connect_state();
+            }
+
+            Ok((ssl, socket_type, server_hostname))
+        }
+
+        #[pymethod]
+        fn _wrap_socket(
+            zelf: PyRef<Self>,
+            args: WrapSocketArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            // Use common helper function
+            let (ssl, socket_type, server_hostname) =
+                Self::new_py_ssl_socket(zelf.clone(), args.server_side, args.server_hostname, vm)?;
+
+            // Create SslStream with socket
+            let stream = ssl::SslStream::new(ssl, SocketStream(args.sock.clone()))
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            let py_ssl_socket = PySslSocket {
+                ctx: PyRwLock::new(zelf.clone()),
+                connection: PyRwLock::new(SslConnection::Socket(stream)),
+                socket_type,
+                server_hostname,
+                owner: PyRwLock::new(args.owner.map(|o| o.downgrade(None, vm)).transpose()?),
+            };
+
+            // Convert to PyRef (heap allocation) to avoid use-after-free
+            let py_ref =
+                py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?;
+
+            // Check if SNI callback is configured (minimize lock time)
+            let has_sni_callback = zelf.sni_callback.lock().is_some();
+
+            // Set up ex_data for callbacks
+            unsafe {
+                let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
+
+                // Clone and store via into_raw() - increments refcount and returns stable pointer
+                // The refcount will be decremented by msg_callback_data_free when SSL is freed
+                let cloned: PyObjectRef = py_ref.clone().into();
+                let raw_ptr = cloned.into_raw();
+                let msg_cb_idx = get_msg_callback_ex_data_index();
+                sys::SSL_set_ex_data(ssl_ptr, msg_cb_idx, raw_ptr.as_ptr() as *mut _);
+
+                // Set SNI callback data if needed
+                if has_sni_callback {
+                    let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
+                    // Store callback data in SSL ex_data - use weak reference to avoid cycle
+                    let callback_data = Box::new(SniCallbackData {
+                        ssl_context: zelf.clone(),
+                        ssl_socket_weak,
+                    });
+                    let sni_idx = get_sni_ex_data_index();
+                    sys::SSL_set_ex_data(ssl_ptr, sni_idx, Box::into_raw(callback_data) as *mut _);
+                }
+            }
+
+            // Set session if provided
+            if let Some(session) = args.session
+                && !vm.is_none(&session)
+            {
+                py_ref.set_session(session, vm)?;
+            }
+
+            Ok(py_ref.into())
+        }
+
+        #[pymethod]
+        fn _wrap_bio(
+            zelf: PyRef<Self>,
+            args: WrapBioArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            // Use common helper function
+            let (ssl, socket_type, server_hostname) =
+                Self::new_py_ssl_socket(zelf.clone(), args.server_side, args.server_hostname, vm)?;
+
+            // Create BioStream wrapper
+            let bio_stream = BioStream {
+                inbio: args.incoming,
+                outbio: args.outgoing,
+            };
+
+            // Create SslStream with BioStream
+            let stream =
+                ssl::SslStream::new(ssl, bio_stream).map_err(|e| convert_openssl_error(vm, e))?;
+
+            let py_ssl_socket = PySslSocket {
+                ctx: PyRwLock::new(zelf.clone()),
+                connection: PyRwLock::new(SslConnection::Bio(stream)),
+                socket_type,
+                server_hostname,
+                owner: PyRwLock::new(args.owner.map(|o| o.downgrade(None, vm)).transpose()?),
+            };
+
+            // Convert to PyRef (heap allocation) to avoid use-after-free
+            let py_ref =
+                py_ssl_socket.into_ref_with_type(vm, PySslSocket::class(&vm.ctx).to_owned())?;
+
+            // Check if SNI callback is configured (minimize lock time)
+            let has_sni_callback = zelf.sni_callback.lock().is_some();
+
+            // Set up ex_data for callbacks
+            unsafe {
+                let ssl_ptr = py_ref.connection.read().ssl().as_ptr();
+
+                // Clone and store via into_raw() - increments refcount and returns stable pointer
+                // The refcount will be decremented by msg_callback_data_free when SSL is freed
+                let cloned: PyObjectRef = py_ref.clone().into();
+                let raw_ptr = cloned.into_raw();
+                let msg_cb_idx = get_msg_callback_ex_data_index();
+                sys::SSL_set_ex_data(ssl_ptr, msg_cb_idx, raw_ptr.as_ptr() as *mut _);
+
+                // Set SNI callback data if needed
+                if has_sni_callback {
+                    let ssl_socket_weak = py_ref.as_object().downgrade(None, vm)?;
+                    // Store callback data in SSL ex_data - use weak reference to avoid cycle
+                    let callback_data = Box::new(SniCallbackData {
+                        ssl_context: zelf.clone(),
+                        ssl_socket_weak,
+                    });
+                    let sni_idx = get_sni_ex_data_index();
+                    sys::SSL_set_ex_data(ssl_ptr, sni_idx, Box::into_raw(callback_data) as *mut _);
+                }
+            }
+
+            // Set session if provided
+            if let Some(session) = args.session
+                && !vm.is_none(&session)
+            {
+                py_ref.set_session(session, vm)?;
+            }
+
+            Ok(py_ref.into())
+        }
+    }
+
+    #[derive(FromArgs)]
+    #[allow(dead_code)] // Fields will be used when _wrap_bio is fully implemented
+    struct WrapBioArgs {
+        incoming: PyRef<PySslMemoryBio>,
+        outgoing: PyRef<PySslMemoryBio>,
+        server_side: bool,
+        #[pyarg(any, default)]
+        server_hostname: Option<PyStrRef>,
+        #[pyarg(named, default)]
+        owner: Option<PyObjectRef>,
+        #[pyarg(named, default)]
+        session: Option<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct WrapSocketArgs {
+        sock: PyRef<PySocket>,
+        server_side: bool,
+        #[pyarg(any, default)]
+        server_hostname: Option<PyStrRef>,
+        #[pyarg(named, default)]
+        owner: Option<PyObjectRef>,
+        #[pyarg(named, default)]
+        session: Option<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct LoadVerifyLocationsArgs {
+        #[pyarg(any, default)]
+        cafile: Option<FsPath>,
+        #[pyarg(any, default)]
+        capath: Option<FsPath>,
+        #[pyarg(any, default)]
+        cadata: Option<Either<PyStrRef, ArgBytesLike>>,
+    }
+
+    #[derive(FromArgs)]
+    struct LoadCertChainArgs {
+        certfile: FsPath,
+        #[pyarg(any, optional)]
+        keyfile: Option<FsPath>,
+        #[pyarg(any, optional)]
+        password: Option<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct GetCertArgs {
+        #[pyarg(any, optional)]
+        binary_form: OptionalArg<bool>,
+    }
+
+    // Err is true if the socket is blocking
+    type SocketDeadline = Result<Instant, bool>;
+
+    enum SelectRet {
+        Nonblocking,
+        TimedOut,
+        Closed,
+        Ok,
+    }
+
+    #[derive(Clone, Copy)]
+    enum SslNeeds {
+        Read,
+        Write,
+    }
+
+    struct SocketStream(PyRef<PySocket>);
+
+    impl SocketStream {
+        fn timeout_deadline(&self) -> SocketDeadline {
+            self.0.get_timeout().map(|d| Instant::now() + d)
+        }
+
+        fn select(&self, needs: SslNeeds, deadline: &SocketDeadline) -> SelectRet {
+            let sock = match self.0.sock_opt() {
+                Some(s) => s,
+                None => return SelectRet::Closed,
+            };
+            // For blocking sockets without timeout, call sock_select with None timeout
+            // to actually block waiting for data instead of busy-looping
+            let timeout = match &deadline {
+                Ok(deadline) => match deadline.checked_duration_since(Instant::now()) {
+                    Some(d) => Some(d),
+                    None => return SelectRet::TimedOut,
+                },
+                Err(true) => None, // Blocking: no timeout, wait indefinitely
+                Err(false) => return SelectRet::Nonblocking,
+            };
+            let res = socket::sock_select(
+                &sock,
+                match needs {
+                    SslNeeds::Read => socket::SelectKind::Read,
+                    SslNeeds::Write => socket::SelectKind::Write,
+                },
+                timeout,
+            );
+            match res {
+                Ok(true) => SelectRet::TimedOut,
+                _ => SelectRet::Ok,
+            }
+        }
+
+        fn socket_needs(
+            &self,
+            err: &ssl::Error,
+            deadline: &SocketDeadline,
+        ) -> (Option<SslNeeds>, SelectRet) {
+            let needs = match err.code() {
+                ssl::ErrorCode::WANT_READ => Some(SslNeeds::Read),
+                ssl::ErrorCode::WANT_WRITE => Some(SslNeeds::Write),
+                _ => None,
+            };
+            let state = needs.map_or(SelectRet::Ok, |needs| self.select(needs, deadline));
+            (needs, state)
+        }
+    }
+
+    fn socket_closed_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+        new_ssl_error(vm, "Underlying socket has been closed.")
+    }
+
+    // BIO stream wrapper to implement Read/Write traits for MemoryBIO
+    struct BioStream {
+        inbio: PyRef<PySslMemoryBio>,
+        outbio: PyRef<PySslMemoryBio>,
+    }
+
+    impl Read for BioStream {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            // Read from incoming MemoryBIO
+            unsafe {
+                let nbytes = sys::BIO_read(
+                    self.inbio.bio,
+                    buf.as_mut_ptr() as *mut _,
+                    buf.len().min(i32::MAX as usize) as i32,
+                );
+                if nbytes < 0 {
+                    // BIO_read returns -1 on error or when no data is available
+                    // Check if it's a retry condition (WANT_READ)
+                    Err(std::io::Error::new(
+                        std::io::ErrorKind::WouldBlock,
+                        "BIO has no data available",
+                    ))
+                } else {
+                    Ok(nbytes as usize)
+                }
+            }
+        }
+    }
+
+    impl Write for BioStream {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            // Write to outgoing MemoryBIO
+            unsafe {
+                let nbytes = sys::BIO_write(
+                    self.outbio.bio,
+                    buf.as_ptr() as *const _,
+                    buf.len().min(i32::MAX as usize) as i32,
+                );
+                if nbytes < 0 {
+                    return Err(std::io::Error::other("BIO write failed"));
+                }
+                Ok(nbytes as usize)
+            }
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> {
+            // MemoryBIO doesn't need flushing
+            Ok(())
+        }
+    }
+
+    // Enum to represent different SSL connection modes
+    enum SslConnection {
+        Socket(ssl::SslStream<SocketStream>),
+        Bio(ssl::SslStream<BioStream>),
+    }
+
+    impl SslConnection {
+        // Get a reference to the SSL object
+        fn ssl(&self) -> &ssl::SslRef {
+            match self {
+                SslConnection::Socket(stream) => stream.ssl(),
+                SslConnection::Bio(stream) => stream.ssl(),
+            }
+        }
+
+        // Get underlying socket stream reference (only for socket mode)
+        fn get_ref(&self) -> Option<&SocketStream> {
+            match self {
+                SslConnection::Socket(stream) => Some(stream.get_ref()),
+                SslConnection::Bio(_) => None,
+            }
+        }
+
+        // Check if this is in BIO mode
+        fn is_bio(&self) -> bool {
+            matches!(self, SslConnection::Bio(_))
+        }
+
+        // Perform SSL handshake
+        fn do_handshake(&mut self) -> Result<(), ssl::Error> {
+            match self {
+                SslConnection::Socket(stream) => stream.do_handshake(),
+                SslConnection::Bio(stream) => stream.do_handshake(),
+            }
+        }
+
+        // Write data to SSL connection
+        fn ssl_write(&mut self, buf: &[u8]) -> Result<usize, ssl::Error> {
+            match self {
+                SslConnection::Socket(stream) => stream.ssl_write(buf),
+                SslConnection::Bio(stream) => stream.ssl_write(buf),
+            }
+        }
+
+        // Read data from SSL connection
+        fn ssl_read(&mut self, buf: &mut [u8]) -> Result<usize, ssl::Error> {
+            match self {
+                SslConnection::Socket(stream) => stream.ssl_read(buf),
+                SslConnection::Bio(stream) => stream.ssl_read(buf),
+            }
+        }
+
+        // Get SSL shutdown state
+        fn get_shutdown(&mut self) -> ssl::ShutdownState {
+            match self {
+                SslConnection::Socket(stream) => stream.get_shutdown(),
+                SslConnection::Bio(stream) => stream.get_shutdown(),
+            }
+        }
+
+        // Check if incoming BIO has EOF (for BIO mode only)
+        fn is_bio_eof(&self) -> bool {
+            match self {
+                SslConnection::Socket(_) => false,
+                SslConnection::Bio(stream) => stream.get_ref().inbio.eof_written.load(),
+            }
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "ssl", name = "_SSLSocket", traverse)]
+    #[derive(PyPayload)]
+    struct PySslSocket {
+        ctx: PyRwLock<PyRef<PySslContext>>,
+        #[pytraverse(skip)]
+        connection: PyRwLock<SslConnection>,
+        #[pytraverse(skip)]
+        socket_type: SslServerOrClient,
+        server_hostname: Option<PyStrRef>,
+        owner: PyRwLock<Option<PyRef<PyWeak>>>,
+    }
+
+    impl fmt::Debug for PySslSocket {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("_SSLSocket")
+        }
+    }
+
+    #[pyclass(flags(IMMUTABLETYPE))]
+    impl PySslSocket {
+        #[pygetset]
+        fn owner(&self) -> Option<PyObjectRef> {
+            self.owner.read().as_ref().and_then(|weak| weak.upgrade())
+        }
+        #[pygetset(setter)]
+        fn set_owner(&self, owner: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mut lock = self.owner.write();
+            lock.take();
+            *lock = Some(owner.downgrade(None, vm)?);
+            Ok(())
+        }
+        #[pygetset]
+        fn server_side(&self) -> bool {
+            self.socket_type == SslServerOrClient::Server
+        }
+        #[pygetset]
+        fn context(&self) -> PyRef<PySslContext> {
+            self.ctx.read().clone()
+        }
+        #[pygetset(setter)]
+        fn set_context(&self, value: PyRef<PySslContext>, vm: &VirtualMachine) -> PyResult<()> {
+            // Get SSL pointer - use thread-local during handshake to avoid deadlock
+            // (connection lock is already held during handshake)
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+
+            // Set the new SSL_CTX on the SSL object
+            unsafe {
+                let result = SSL_set_SSL_CTX(ssl_ptr, value.ctx().as_ptr());
+                if result.is_null() {
+                    return Err(vm.new_runtime_error("Failed to set SSL context".to_owned()));
+                }
+            }
+
+            // Update self.ctx to the new context
+            *self.ctx.write() = value;
+            Ok(())
+        }
+        #[pygetset]
+        fn server_hostname(&self) -> Option<PyStrRef> {
+            self.server_hostname.clone()
+        }
+
+        #[pymethod]
+        fn getpeercert(
+            &self,
+            args: GetCertArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<PyObjectRef>> {
+            let binary = args.binary_form.unwrap_or(false);
+            let stream = self.connection.read();
+            if !stream.ssl().is_init_finished() {
+                return Err(vm.new_value_error("handshake not done yet"));
+            }
+
+            let peer_cert = stream.ssl().peer_certificate();
+            let Some(cert) = peer_cert else {
+                return Ok(None);
+            };
+
+            if binary {
+                // Return DER-encoded certificate
+                cert_to_py(vm, &cert, true).map(Some)
+            } else {
+                // Check verify_mode
+                unsafe {
+                    let ssl_ctx = sys::SSL_get_SSL_CTX(stream.ssl().as_ptr());
+                    let verify_mode = sys::SSL_CTX_get_verify_mode(ssl_ctx);
+                    if (verify_mode & sys::SSL_VERIFY_PEER as libc::c_int) == 0 {
+                        // Return empty dict when SSL_VERIFY_PEER is not set
+                        Ok(Some(vm.ctx.new_dict().into()))
+                    } else {
+                        // Return decoded certificate
+                        cert_to_py(vm, &cert, false).map(Some)
+                    }
+                }
+            }
+        }
+
+        #[pymethod]
+        fn get_unverified_chain(&self, vm: &VirtualMachine) -> PyResult<Option<PyListRef>> {
+            let stream = self.connection.read();
+            let ssl = stream.ssl();
+            let Some(chain) = ssl.peer_cert_chain() else {
+                return Ok(None);
+            };
+
+            // Return Certificate objects
+            let mut certs: Vec<PyObjectRef> = chain
+                .iter()
+                .map(|cert| unsafe {
+                    sys::X509_up_ref(cert.as_ptr());
+                    let owned = X509::from_ptr(cert.as_ptr());
+                    cert_to_certificate(vm, owned)
+                })
+                .collect::<PyResult<_>>()?;
+
+            // SSL_get_peer_cert_chain does not include peer cert for server-side sockets
+            // Add it manually at the beginning
+            if matches!(self.socket_type, SslServerOrClient::Server)
+                && let Some(peer_cert) = ssl.peer_certificate()
+            {
+                let peer_obj = cert_to_certificate(vm, peer_cert)?;
+                certs.insert(0, peer_obj);
+            }
+
+            Ok(Some(vm.ctx.new_list(certs)))
+        }
+
+        #[pymethod]
+        fn get_verified_chain(&self, vm: &VirtualMachine) -> PyResult<Option<PyListRef>> {
+            let stream = self.connection.read();
+            unsafe {
+                let chain = sys::SSL_get0_verified_chain(stream.ssl().as_ptr());
+                if chain.is_null() {
+                    return Ok(None);
+                }
+
+                let num_certs = sys::OPENSSL_sk_num(chain as *const _);
+
+                let mut certs = Vec::with_capacity(num_certs as usize);
+                // Return Certificate objects
+                for i in 0..num_certs {
+                    let cert_ptr = sys::OPENSSL_sk_value(chain as *const _, i) as *mut sys::X509;
+                    if cert_ptr.is_null() {
+                        continue;
+                    }
+                    // Clone the X509 certificate to create an owned copy
+                    sys::X509_up_ref(cert_ptr);
+                    let owned_cert = X509::from_ptr(cert_ptr);
+                    let cert_obj = cert_to_certificate(vm, owned_cert)?;
+                    certs.push(cert_obj);
+                }
+
+                Ok(if certs.is_empty() {
+                    None
+                } else {
+                    Some(vm.ctx.new_list(certs))
+                })
+            }
+        }
+
+        #[pymethod]
+        fn version(&self) -> Option<&'static str> {
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            // Return None if handshake is not complete (CPython behavior)
+            if unsafe { sys::SSL_is_init_finished(ssl_ptr) } == 0 {
+                return None;
+            }
+            let v = unsafe { ssl::SslRef::from_ptr(ssl_ptr).version_str() };
+            if v == "unknown" { None } else { Some(v) }
+        }
+
+        #[pymethod]
+        fn cipher(&self) -> Option<CipherTuple> {
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            unsafe { ssl::SslRef::from_ptr(ssl_ptr).current_cipher() }.map(cipher_to_tuple)
+        }
+
+        #[pymethod]
+        fn pending(&self) -> i32 {
+            let stream = self.connection.read();
+            unsafe { sys::SSL_pending(stream.ssl().as_ptr()) }
+        }
+
+        #[pymethod]
+        fn shared_ciphers(&self, vm: &VirtualMachine) -> Option<PyListRef> {
+            #[cfg(ossl110)]
+            {
+                // Use thread-local SSL pointer during handshake to avoid deadlock
+                let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+                unsafe {
+                    let server_ciphers = SSL_get_ciphers(ssl_ptr);
+                    if server_ciphers.is_null() {
+                        return None;
+                    }
+
+                    let client_ciphers = SSL_get_client_ciphers(ssl_ptr);
+                    if client_ciphers.is_null() {
+                        return None;
+                    }
+
+                    let mut result = Vec::new();
+                    let num_server = sys::OPENSSL_sk_num(server_ciphers as *const _);
+                    let num_client = sys::OPENSSL_sk_num(client_ciphers as *const _);
+
+                    for i in 0..num_server {
+                        let server_cipher_ptr = sys::OPENSSL_sk_value(server_ciphers as *const _, i)
+                            as *const sys::SSL_CIPHER;
+
+                        // Check if client supports this cipher by comparing pointers
+                        let mut found = false;
+                        for j in 0..num_client {
+                            let client_cipher_ptr =
+                                sys::OPENSSL_sk_value(client_ciphers as *const _, j)
+                                    as *const sys::SSL_CIPHER;
+
+                            if server_cipher_ptr == client_cipher_ptr {
+                                found = true;
+                                break;
+                            }
+                        }
+
+                        if found {
+                            let cipher = ssl::SslCipherRef::from_ptr(server_cipher_ptr as *mut _);
+                            let (name, version, bits) = cipher_to_tuple(cipher);
+                            let tuple = vm.new_tuple((
+                                vm.ctx.new_str(name),
+                                vm.ctx.new_str(version),
+                                vm.ctx.new_int(bits),
+                            ));
+                            result.push(tuple.into());
+                        }
+                    }
+
+                    if result.is_empty() {
+                        None
+                    } else {
+                        Some(vm.ctx.new_list(result))
+                    }
+                }
+            }
+            #[cfg(not(ossl110))]
+            {
+                let _ = vm;
+                None
+            }
+        }
+
+        #[pymethod]
+        fn selected_alpn_protocol(&self) -> Option<String> {
+            #[cfg(ossl102)]
+            {
+                // Use thread-local SSL pointer during handshake to avoid deadlock
+                let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+                unsafe {
+                    let mut out: *const libc::c_uchar = core::ptr::null();
+                    let mut outlen: libc::c_uint = 0;
+
+                    sys::SSL_get0_alpn_selected(ssl_ptr, &mut out, &mut outlen);
+
+                    if out.is_null() {
+                        None
+                    } else {
+                        let slice = std::slice::from_raw_parts(out, outlen as usize);
+                        Some(String::from_utf8_lossy(slice).into_owned())
+                    }
+                }
+            }
+            #[cfg(not(ossl102))]
+            {
+                None
+            }
+        }
+
+        #[pymethod]
+        fn get_channel_binding(
+            &self,
+            cb_type: OptionalArg<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<PyBytesRef>> {
+            const CB_MAXLEN: usize = 512;
+
+            let cb_type_str = cb_type.as_ref().map_or("tls-unique", |s| s.as_str());
+
+            if cb_type_str != "tls-unique" {
+                return Err(vm.new_value_error(format!(
+                    "Unsupported channel binding type '{}'",
+                    cb_type_str
+                )));
+            }
+
+            let stream = self.connection.read();
+            let ssl_ptr = stream.ssl().as_ptr();
+
+            unsafe {
+                let session_reused = sys::SSL_session_reused(ssl_ptr) != 0;
+                let is_client = matches!(self.socket_type, SslServerOrClient::Client);
+
+                // Use XOR logic from CPython
+                let use_finished = session_reused ^ is_client;
+
+                let mut buf = vec![0u8; CB_MAXLEN];
+                let len = if use_finished {
+                    sys::SSL_get_finished(ssl_ptr, buf.as_mut_ptr() as *mut _, CB_MAXLEN)
+                } else {
+                    sys::SSL_get_peer_finished(ssl_ptr, buf.as_mut_ptr() as *mut _, CB_MAXLEN)
+                };
+
+                if len == 0 {
+                    Ok(None)
+                } else {
+                    buf.truncate(len);
+                    Ok(Some(vm.ctx.new_bytes(buf)))
+                }
+            }
+        }
+
+        #[pymethod]
+        fn verify_client_post_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            #[cfg(ossl111)]
+            {
+                let stream = self.connection.read();
+                let result = unsafe { SSL_verify_client_post_handshake(stream.ssl().as_ptr()) };
+                if result == 0 {
+                    Err(convert_openssl_error(vm, openssl::error::ErrorStack::get()))
+                } else {
+                    Ok(())
+                }
+            }
+            #[cfg(not(ossl111))]
+            {
+                Err(vm.new_not_implemented_error(
+                    "Post-handshake auth is not supported by your OpenSSL version.".to_owned(),
+                ))
+            }
+        }
+
+        #[pymethod]
+        fn shutdown(&self, vm: &VirtualMachine) -> PyResult<Option<PyRef<PySocket>>> {
+            let stream = self.connection.read();
+            let ssl_ptr = stream.ssl().as_ptr();
+
+            // Perform SSL shutdown - may need to be called twice:
+            // 1st call: sends close-notify, returns 0
+            // 2nd call: reads peer's close-notify, returns 1
+            let mut ret = unsafe { sys::SSL_shutdown(ssl_ptr) };
+
+            // If ret == 0, try once more to complete the bidirectional shutdown
+            // This handles the case where peer's close-notify is already available
+            if ret == 0 {
+                ret = unsafe { sys::SSL_shutdown(ssl_ptr) };
+            }
+
+            if ret < 0 {
+                // Error occurred
+                let err = unsafe { sys::SSL_get_error(ssl_ptr, ret) };
+
+                if err == sys::SSL_ERROR_WANT_READ {
+                    return Err(create_ssl_want_read_error(vm).upcast());
+                } else if err == sys::SSL_ERROR_WANT_WRITE {
+                    return Err(create_ssl_want_write_error(vm).upcast());
+                } else {
+                    return Err(new_ssl_error(
+                        vm,
+                        format!("SSL shutdown failed: error code {}", err),
+                    ));
+                }
+            } else if ret == 0 {
+                // Still waiting for peer's close-notify after retry
+                // In BIO mode, raise SSLWantReadError
+                if stream.is_bio() {
+                    return Err(create_ssl_want_read_error(vm).upcast());
+                }
+            }
+
+            // BIO mode doesn't have an underlying socket to return
+            if stream.is_bio() {
+                return Ok(None);
+            }
+
+            // Return the underlying socket for socket mode
+            let socket = stream
+                .get_ref()
+                .expect("unwrap() called on bio mode; should only be called in socket mode");
+            Ok(Some(socket.0.clone()))
+        }
+
+        #[cfg(osslconf = "OPENSSL_NO_COMP")]
+        #[pymethod]
+        fn compression(&self) -> Option<&'static str> {
+            None
+        }
+        #[cfg(not(osslconf = "OPENSSL_NO_COMP"))]
+        #[pymethod]
+        fn compression(&self) -> Option<&'static str> {
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            let comp_method = unsafe { sys::SSL_get_current_compression(ssl_ptr) };
+            if comp_method.is_null() {
+                return None;
+            }
+            let typ = unsafe { sys::COMP_get_type(comp_method) };
+            let nid = Nid::from_raw(typ);
+            if nid == Nid::UNDEF {
+                return None;
+            }
+            nid.short_name().ok()
+        }
+
+        #[pymethod]
+        fn do_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            let mut stream = self.connection.write();
+            let ssl_ptr = stream.ssl().as_ptr();
+
+            // Set up thread-local VM and SSL pointer for callbacks
+            // This allows callbacks to access SSL without acquiring the connection lock
+            let _vm_guard = HandshakeVmGuard::new(vm, ssl_ptr);
+
+            // BIO mode: no timeout/select logic, just do handshake
+            if stream.is_bio() {
+                let result = stream.do_handshake().map_err(|e| {
+                    let exc = convert_ssl_error(vm, e);
+                    // If it's a cert verification error, set verify info
+                    if exc.class().is(PySSLCertVerificationError::class(&vm.ctx)) {
+                        set_verify_error_info(&exc, ssl_ptr, vm);
+                    }
+                    exc
+                });
+                // Clean up SNI ex_data after handshake (success or failure)
+                // SAFETY: ssl_ptr is valid for the lifetime of stream
+                unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                return result;
+            }
+
+            // Socket mode: handle timeout and blocking
+            let timeout = stream
+                .get_ref()
+                .expect("handshake called in bio mode; should only be called in socket mode")
+                .timeout_deadline();
+            loop {
+                let err = match stream.do_handshake() {
+                    Ok(()) => {
+                        // Clean up SNI ex_data after successful handshake
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                        return Ok(());
+                    }
+                    Err(e) => e,
+                };
+                let (needs, state) = stream
+                    .get_ref()
+                    .expect("handshake called in bio mode; should only be called in socket mode")
+                    .socket_needs(&err, &timeout);
+                match state {
+                    SelectRet::TimedOut => {
+                        // Clean up SNI ex_data before returning error
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                        return Err(socket::timeout_error_msg(
+                            vm,
+                            "The handshake operation timed out".to_owned(),
+                        )
+                        .upcast());
+                    }
+                    SelectRet::Closed => {
+                        // SAFETY: ssl_ptr is valid for the lifetime of stream
+                        unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                        return Err(socket_closed_error(vm));
+                    }
+                    SelectRet::Nonblocking => {}
+                    SelectRet::Ok => {
+                        // For blocking sockets, select() has completed successfully
+                        // Continue the handshake loop (matches CPython's SOCKET_IS_BLOCKING behavior)
+                        if needs.is_some() {
+                            continue;
+                        }
+                    }
+                }
+                let exc = convert_ssl_error(vm, err);
+                // If it's a cert verification error, set verify info
+                if exc.class().is(PySSLCertVerificationError::class(&vm.ctx)) {
+                    set_verify_error_info(&exc, ssl_ptr, vm);
+                }
+                // Clean up SNI ex_data before returning error
+                // SAFETY: ssl_ptr is valid for the lifetime of stream
+                unsafe { cleanup_sni_ex_data(ssl_ptr) };
+                return Err(exc);
+            }
+        }
+
+        #[pymethod]
+        fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+            let mut stream = self.connection.write();
+            let data = data.borrow_buf();
+            let data = &*data;
+
+            // BIO mode: no timeout/select logic
+            if stream.is_bio() {
+                return stream.ssl_write(data).map_err(|e| convert_ssl_error(vm, e));
+            }
+
+            // Socket mode: handle timeout and blocking
+            let socket_ref = stream
+                .get_ref()
+                .expect("write called in bio mode; should only be called in socket mode");
+            let timeout = socket_ref.timeout_deadline();
+            let state = socket_ref.select(SslNeeds::Write, &timeout);
+            match state {
+                SelectRet::TimedOut => {
+                    return Err(socket::timeout_error_msg(
+                        vm,
+                        "The write operation timed out".to_owned(),
+                    )
+                    .upcast());
+                }
+                SelectRet::Closed => return Err(socket_closed_error(vm)),
+                _ => {}
+            }
+            loop {
+                let err = match stream.ssl_write(data) {
+                    Ok(len) => return Ok(len),
+                    Err(e) => e,
+                };
+                let (needs, state) = stream
+                    .get_ref()
+                    .expect("write called in bio mode; should only be called in socket mode")
+                    .socket_needs(&err, &timeout);
+                match state {
+                    SelectRet::TimedOut => {
+                        return Err(socket::timeout_error_msg(
+                            vm,
+                            "The write operation timed out".to_owned(),
+                        )
+                        .upcast());
+                    }
+                    SelectRet::Closed => return Err(socket_closed_error(vm)),
+                    SelectRet::Nonblocking => {}
+                    SelectRet::Ok => {
+                        // For blocking sockets, select() has completed successfully
+                        // Continue the write loop (matches CPython's SOCKET_IS_BLOCKING behavior)
+                        if needs.is_some() {
+                            continue;
+                        }
+                    }
+                }
+                return Err(convert_ssl_error(vm, err));
+            }
+        }
+
+        #[pygetset]
+        fn session(&self, _vm: &VirtualMachine) -> PyResult<Option<PySslSession>> {
+            let stream = self.connection.read();
+            unsafe {
+                // Use SSL_get1_session which returns an owned reference (ref count already incremented)
+                let session_ptr = SSL_get1_session(stream.ssl().as_ptr());
+                if session_ptr.is_null() {
+                    Ok(None)
+                } else {
+                    Ok(Some(PySslSession {
+                        session: session_ptr,
+                        ctx: self.ctx.read().clone(),
+                    }))
+                }
+            }
+        }
+
+        #[pygetset(setter)]
+        fn set_session(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            // 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()))?;
+
+            // 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())
+                );
+            }
+
+            // 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())
+                );
+            }
+
+            // 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())
+                    );
+                }
+
+                let ret = sys::SSL_set_session(stream.ssl().as_ptr(), session.session);
+                if ret == 0 {
+                    return Err(convert_openssl_error(vm, ErrorStack::get()));
+                }
+            }
+
+            Ok(())
+        }
+
+        #[pygetset]
+        fn session_reused(&self) -> bool {
+            // Use thread-local SSL pointer during handshake to avoid deadlock
+            let ssl_ptr = get_ssl_ptr_for_context_change(&self.connection);
+            unsafe { sys::SSL_session_reused(ssl_ptr) != 0 }
+        }
+
+        #[pymethod]
+        fn read(
+            &self,
+            n: isize,
+            buffer: OptionalArg<ArgMemoryBuffer>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            // Handle negative n:
+            // - If buffer is None and n < 0: raise ValueError
+            // - If buffer is present and n <= 0: use buffer length
+            // This matches _ssl__SSLSocket_read_impl in CPython
+            let read_len: usize = match &buffer {
+                OptionalArg::Present(buf) => {
+                    let buf_len = buf.borrow_buf_mut().len();
+                    if n <= 0 || (n as usize) > buf_len {
+                        buf_len
+                    } else {
+                        n as usize
+                    }
+                }
+                OptionalArg::Missing => {
+                    if n < 0 {
+                        return Err(vm.new_value_error("size should not be negative".to_owned()));
+                    }
+                    n as usize
+                }
+            };
+
+            // Special case: reading 0 bytes should return empty bytes immediately
+            if read_len == 0 {
+                return if buffer.is_present() {
+                    Ok(vm.ctx.new_int(0).into())
+                } else {
+                    Ok(vm.ctx.new_bytes(vec![]).into())
+                };
+            }
+
+            let mut stream = self.connection.write();
+            let mut inner_buffer = if let OptionalArg::Present(buffer) = &buffer {
+                Either::A(buffer.borrow_buf_mut())
+            } else {
+                Either::B(vec![0u8; read_len])
+            };
+            let buf = match &mut inner_buffer {
+                Either::A(b) => &mut **b,
+                Either::B(b) => b.as_mut_slice(),
+            };
+            let buf = match buf.get_mut(..read_len) {
+                Some(b) => b,
+                None => buf,
+            };
+
+            // BIO mode: no timeout/select logic
+            let count = if stream.is_bio() {
+                match stream.ssl_read(buf) {
+                    Ok(count) => count,
+                    Err(e) => {
+                        // Handle ZERO_RETURN (EOF) - raise SSLEOFError
+                        if e.code() == ssl::ErrorCode::ZERO_RETURN {
+                            return Err(create_ssl_eof_error(vm).upcast());
+                        }
+                        // If WANT_READ and the incoming BIO has EOF written,
+                        // this is an unexpected EOF (transport closed without TLS close_notify)
+                        if e.code() == ssl::ErrorCode::WANT_READ && stream.is_bio_eof() {
+                            return Err(create_ssl_eof_error(vm).upcast());
+                        }
+                        return Err(convert_ssl_error(vm, e));
+                    }
+                }
+            } else {
+                // Socket mode: handle timeout and blocking
+                let timeout = stream
+                    .get_ref()
+                    .expect("read called in bio mode; should only be called in socket mode")
+                    .timeout_deadline();
+                loop {
+                    let err = match stream.ssl_read(buf) {
+                        Ok(count) => break count,
+                        Err(e) => e,
+                    };
+                    if err.code() == ssl::ErrorCode::ZERO_RETURN
+                        && stream.get_shutdown() == ssl::ShutdownState::RECEIVED
+                    {
+                        break 0;
+                    }
+                    let (needs, state) = stream
+                        .get_ref()
+                        .expect("read called in bio mode; should only be called in socket mode")
+                        .socket_needs(&err, &timeout);
+                    match state {
+                        SelectRet::TimedOut => {
+                            return Err(socket::timeout_error_msg(
+                                vm,
+                                "The read operation timed out".to_owned(),
+                            )
+                            .upcast());
+                        }
+                        SelectRet::Closed => return Err(socket_closed_error(vm)),
+                        SelectRet::Nonblocking => {}
+                        SelectRet::Ok => {
+                            // For blocking sockets, select() has completed successfully
+                            // Continue the read loop (matches CPython's SOCKET_IS_BLOCKING behavior)
+                            if needs.is_some() {
+                                continue;
+                            }
+                        }
+                    }
+                    return Err(convert_ssl_error(vm, err));
+                }
+            };
+            let ret = match inner_buffer {
+                Either::A(_buf) => vm.ctx.new_int(count).into(),
+                Either::B(mut buf) => {
+                    buf.truncate(count);
+                    buf.shrink_to_fit();
+                    vm.ctx.new_bytes(buf).into()
+                }
+            };
+            Ok(ret)
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "ssl", name = "SSLSession")]
+    #[derive(PyPayload)]
+    struct PySslSession {
+        session: *mut sys::SSL_SESSION,
+        ctx: PyRef<PySslContext>,
+    }
+
+    impl fmt::Debug for PySslSession {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("SSLSession")
+        }
+    }
+
+    impl Drop for PySslSession {
+        fn drop(&mut self) {
+            if !self.session.is_null() {
+                unsafe {
+                    sys::SSL_SESSION_free(self.session);
+                }
+            }
+        }
+    }
+
+    unsafe impl Send for PySslSession {}
+    unsafe impl Sync for PySslSession {}
+
+    impl Comparable for PySslSession {
+        fn cmp(
+            zelf: &Py<Self>,
+            other: &crate::vm::PyObject,
+            op: PyComparisonOp,
+            _vm: &VirtualMachine,
+        ) -> PyResult<PyComparisonValue> {
+            let other = class_or_notimplemented!(Self, other);
+
+            if !matches!(op, PyComparisonOp::Eq | PyComparisonOp::Ne) {
+                return Ok(PyComparisonValue::NotImplemented);
+            }
+            let mut eq = unsafe {
+                let mut self_len: libc::c_uint = 0;
+                let mut other_len: libc::c_uint = 0;
+                let self_id = sys::SSL_SESSION_get_id(zelf.session, &mut self_len);
+                let other_id = sys::SSL_SESSION_get_id(other.session, &mut other_len);
+
+                if self_len != other_len {
+                    false
+                } else {
+                    let self_slice = std::slice::from_raw_parts(self_id, self_len as usize);
+                    let other_slice = std::slice::from_raw_parts(other_id, other_len as usize);
+                    self_slice == other_slice
+                }
+            };
+            if matches!(op, PyComparisonOp::Ne) {
+                eq = !eq;
+            }
+            Ok(PyComparisonValue::Implemented(eq))
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "ssl", name = "MemoryBIO")]
+    #[derive(PyPayload)]
+    struct PySslMemoryBio {
+        bio: *mut sys::BIO,
+        eof_written: AtomicCell<bool>,
+    }
+
+    impl fmt::Debug for PySslMemoryBio {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("MemoryBIO")
+        }
+    }
+
+    impl Drop for PySslMemoryBio {
+        fn drop(&mut self) {
+            if !self.bio.is_null() {
+                unsafe {
+                    sys::BIO_free_all(self.bio);
+                }
+            }
+        }
+    }
+
+    unsafe impl Send for PySslMemoryBio {}
+    unsafe impl Sync for PySslMemoryBio {}
+
+    // OpenSSL functions not in openssl-sys
+
+    unsafe extern "C" {
+        // X509_check_ca returns 1 for CA certificates, 0 otherwise
+        fn X509_check_ca(x: *const sys::X509) -> libc::c_int;
+    }
+
+    unsafe extern "C" {
+        fn SSL_get_ciphers(ssl: *const sys::SSL) -> *const sys::stack_st_SSL_CIPHER;
+    }
+
+    #[cfg(ossl110)]
+    unsafe extern "C" {
+        fn SSL_get_client_ciphers(ssl: *const sys::SSL) -> *const sys::stack_st_SSL_CIPHER;
+    }
+
+    #[cfg(ossl111)]
+    unsafe extern "C" {
+        fn SSL_verify_client_post_handshake(ssl: *const sys::SSL) -> libc::c_int;
+        fn SSL_set_post_handshake_auth(ssl: *mut sys::SSL, val: libc::c_int);
+    }
+
+    #[cfg(ossl110)]
+    unsafe extern "C" {
+        fn SSL_CTX_get_security_level(ctx: *const sys::SSL_CTX) -> libc::c_int;
+    }
+
+    unsafe extern "C" {
+        fn SSL_set_SSL_CTX(ssl: *mut sys::SSL, ctx: *mut sys::SSL_CTX) -> *mut sys::SSL_CTX;
+    }
+
+    // Message callback type
+    #[allow(non_camel_case_types)]
+    type SSL_CTX_msg_callback = Option<
+        unsafe extern "C" fn(
+            write_p: libc::c_int,
+            version: libc::c_int,
+            content_type: libc::c_int,
+            buf: *const libc::c_void,
+            len: usize,
+            ssl: *mut sys::SSL,
+            arg: *mut libc::c_void,
+        ),
+    >;
+
+    unsafe extern "C" {
+        fn SSL_CTX_set_msg_callback(ctx: *mut sys::SSL_CTX, cb: SSL_CTX_msg_callback);
+    }
+
+    #[cfg(ossl110)]
+    unsafe extern "C" {
+        fn SSL_SESSION_has_ticket(session: *const sys::SSL_SESSION) -> libc::c_int;
+        fn SSL_SESSION_get_ticket_lifetime_hint(session: *const sys::SSL_SESSION) -> libc::c_ulong;
+    }
+
+    // X509 object types
+    const X509_LU_X509: libc::c_int = 1;
+    const X509_LU_CRL: libc::c_int = 2;
+
+    unsafe extern "C" {
+        fn X509_OBJECT_get_type(obj: *const sys::X509_OBJECT) -> libc::c_int;
+        fn SSL_set_session_id_context(
+            ssl: *mut sys::SSL,
+            sid_ctx: *const libc::c_uchar,
+            sid_ctx_len: libc::c_uint,
+        ) -> libc::c_int;
+        fn SSL_get1_session(ssl: *const sys::SSL) -> *mut sys::SSL_SESSION;
+    }
+
+    // SSL session statistics constants (used with SSL_CTX_ctrl)
+    const SSL_CTRL_SESS_NUMBER: libc::c_int = 20;
+    const SSL_CTRL_SESS_CONNECT: libc::c_int = 21;
+    const SSL_CTRL_SESS_CONNECT_GOOD: libc::c_int = 22;
+    const SSL_CTRL_SESS_CONNECT_RENEGOTIATE: libc::c_int = 23;
+    const SSL_CTRL_SESS_ACCEPT: libc::c_int = 24;
+    const SSL_CTRL_SESS_ACCEPT_GOOD: libc::c_int = 25;
+    const SSL_CTRL_SESS_ACCEPT_RENEGOTIATE: libc::c_int = 26;
+    const SSL_CTRL_SESS_HIT: libc::c_int = 27;
+    const SSL_CTRL_SESS_MISSES: libc::c_int = 29;
+    const SSL_CTRL_SESS_TIMEOUTS: libc::c_int = 30;
+    const SSL_CTRL_SESS_CACHE_FULL: libc::c_int = 31;
+
+    // SSL session statistics functions (implemented as macros in OpenSSL)
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_number(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_NUMBER, 0, std::ptr::null_mut()) }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_connect(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_CONNECT,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_connect_good(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_CONNECT_GOOD,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_connect_renegotiate(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_CONNECT_RENEGOTIATE,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_accept(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_ACCEPT, 0, std::ptr::null_mut()) }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_accept_good(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_ACCEPT_GOOD,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_accept_renegotiate(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_ACCEPT_RENEGOTIATE,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_hits(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_HIT, 0, std::ptr::null_mut()) }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_misses(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe { sys::SSL_CTX_ctrl(ctx as *mut _, SSL_CTRL_SESS_MISSES, 0, std::ptr::null_mut()) }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_timeouts(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_TIMEOUTS,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn SSL_CTX_sess_cache_full(ctx: *const sys::SSL_CTX) -> libc::c_long {
+        unsafe {
+            sys::SSL_CTX_ctrl(
+                ctx as *mut _,
+                SSL_CTRL_SESS_CACHE_FULL,
+                0,
+                std::ptr::null_mut(),
+            )
+        }
+    }
+
+    // DH parameters functions
+    unsafe extern "C" {
+        fn PEM_read_DHparams(
+            fp: *mut libc::FILE,
+            x: *mut *mut sys::DH,
+            cb: *mut libc::c_void,
+            u: *mut libc::c_void,
+        ) -> *mut sys::DH;
+    }
+
+    // OpenSSL BIO helper functions
+    // These are typically macros in OpenSSL, implemented via BIO_ctrl
+    const BIO_CTRL_PENDING: libc::c_int = 10;
+    const BIO_CTRL_SET_EOF: libc::c_int = 2;
+
+    #[allow(non_snake_case)]
+    unsafe fn BIO_ctrl_pending(bio: *mut sys::BIO) -> usize {
+        unsafe { sys::BIO_ctrl(bio, BIO_CTRL_PENDING, 0, std::ptr::null_mut()) as usize }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn BIO_set_mem_eof_return(bio: *mut sys::BIO, eof: libc::c_int) -> libc::c_int {
+        unsafe {
+            sys::BIO_ctrl(
+                bio,
+                BIO_CTRL_SET_EOF,
+                eof as libc::c_long,
+                std::ptr::null_mut(),
+            ) as libc::c_int
+        }
+    }
+
+    #[allow(non_snake_case)]
+    unsafe fn BIO_clear_retry_flags(bio: *mut sys::BIO) {
+        unsafe {
+            sys::BIO_clear_flags(bio, sys::BIO_FLAGS_RWS | sys::BIO_FLAGS_SHOULD_RETRY);
+        }
+    }
+
+    impl Constructor for PySslMemoryBio {
+        type Args = ();
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            unsafe {
+                let bio = sys::BIO_new(sys::BIO_s_mem());
+                if bio.is_null() {
+                    return Err(vm.new_memory_error("failed to allocate BIO".to_owned()));
+                }
+
+                sys::BIO_set_retry_read(bio);
+                BIO_set_mem_eof_return(bio, -1);
+
+                Ok(PySslMemoryBio {
+                    bio,
+                    eof_written: AtomicCell::new(false),
+                })
+            }
+        }
+    }
+
+    #[pyclass(flags(IMMUTABLETYPE), with(Constructor))]
+    impl PySslMemoryBio {
+        #[pygetset]
+        fn pending(&self) -> usize {
+            unsafe { BIO_ctrl_pending(self.bio) }
+        }
+
+        #[pygetset]
+        fn eof(&self) -> bool {
+            let pending = unsafe { BIO_ctrl_pending(self.bio) };
+            pending == 0 && self.eof_written.load()
+        }
+
+        #[pymethod]
+        fn read(&self, size: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+            unsafe {
+                let avail = BIO_ctrl_pending(self.bio).min(i32::MAX as usize) as i32;
+                let len = size.unwrap_or(-1);
+                let len = if len < 0 || len > avail { avail } else { len };
+
+                // When no data available, return empty bytes (CPython behavior)
+                // CPython returns empty bytes directly without calling BIO_read()
+                if len == 0 {
+                    return Ok(Vec::new());
+                }
+
+                let mut buf = vec![0u8; len as usize];
+                let nbytes = sys::BIO_read(self.bio, buf.as_mut_ptr() as *mut _, len);
+
+                if nbytes < 0 {
+                    return Err(convert_openssl_error(vm, ErrorStack::get()));
+                }
+
+                buf.truncate(nbytes as usize);
+                Ok(buf)
+            }
+        }
+
+        #[pymethod]
+        fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<i32> {
+            if self.eof_written.load() {
+                return Err(new_ssl_error(vm, "cannot write() after write_eof()"));
+            }
+
+            data.with_ref(|buf| unsafe {
+                if buf.len() > i32::MAX as usize {
+                    return Err(
+                        vm.new_overflow_error(format!("string longer than {} bytes", i32::MAX))
+                    );
+                }
+
+                let nbytes = sys::BIO_write(self.bio, buf.as_ptr() as *const _, buf.len() as i32);
+                if nbytes < 0 {
+                    return Err(convert_openssl_error(vm, ErrorStack::get()));
+                }
+
+                Ok(nbytes)
+            })
+        }
+
+        #[pymethod]
+        fn write_eof(&self) {
+            self.eof_written.store(true);
+            unsafe {
+                BIO_clear_retry_flags(self.bio);
+                BIO_set_mem_eof_return(self.bio, 0);
+            }
+        }
+    }
+
+    #[pyclass(flags(IMMUTABLETYPE), with(Comparable))]
+    impl PySslSession {
+        #[pygetset]
+        fn time(&self) -> i64 {
+            unsafe {
+                #[cfg(ossl330)]
+                {
+                    sys::SSL_SESSION_get_time(self.session) as i64
+                }
+                #[cfg(not(ossl330))]
+                {
+                    sys::SSL_SESSION_get_time(self.session) as i64
+                }
+            }
+        }
+
+        #[pygetset]
+        fn timeout(&self) -> i64 {
+            unsafe { sys::SSL_SESSION_get_timeout(self.session) as i64 }
+        }
+
+        #[pygetset]
+        fn ticket_lifetime_hint(&self) -> u64 {
+            // SSL_SESSION_get_ticket_lifetime_hint available in OpenSSL 1.1.0+
+            #[cfg(ossl110)]
+            {
+                unsafe { SSL_SESSION_get_ticket_lifetime_hint(self.session) as u64 }
+            }
+            #[cfg(not(ossl110))]
+            {
+                // Not available in older OpenSSL versions
+                0
+            }
+        }
+
+        #[pygetset]
+        fn id(&self, vm: &VirtualMachine) -> PyBytesRef {
+            unsafe {
+                let mut len: libc::c_uint = 0;
+                let id_ptr = sys::SSL_SESSION_get_id(self.session, &mut len);
+                let id_slice = std::slice::from_raw_parts(id_ptr, len as usize);
+                vm.ctx.new_bytes(id_slice.to_vec())
+            }
+        }
+
+        #[pygetset]
+        fn has_ticket(&self) -> bool {
+            // SSL_SESSION_has_ticket available in OpenSSL 1.1.0+
+            #[cfg(ossl110)]
+            {
+                unsafe { SSL_SESSION_has_ticket(self.session) != 0 }
+            }
+            #[cfg(not(ossl110))]
+            {
+                // Not available in older OpenSSL versions
+                false
+            }
+        }
+    }
+
+    /// Helper function to create SSL error with proper OSError subtype handling
+    fn new_ssl_error(vm: &VirtualMachine, msg: impl ToString) -> PyBaseExceptionRef {
+        vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), None, msg.to_string())
+            .upcast()
+    }
+
+    #[track_caller]
+    pub(crate) fn convert_openssl_error(
+        vm: &VirtualMachine,
+        err: ErrorStack,
+    ) -> PyBaseExceptionRef {
+        match err.errors().last() {
+            Some(e) => {
+                // Check if this is a system library error (errno-based)
+                let lib = sys::ERR_GET_LIB(e.code());
+
+                if lib == sys::ERR_LIB_SYS {
+                    // A system error is being reported; reason is set to errno
+                    let reason = sys::ERR_GET_REASON(e.code());
+
+                    // errno 2 = ENOENT = FileNotFoundError
+                    let exc_type = if reason == 2 {
+                        vm.ctx.exceptions.file_not_found_error.to_owned()
+                    } else {
+                        vm.ctx.exceptions.os_error.to_owned()
+                    };
+                    return vm.new_os_subtype_error(exc_type, Some(reason), "").upcast();
+                }
+
+                let caller = std::panic::Location::caller();
+                let (file, line) = (caller.file(), caller.line());
+                let file = file
+                    .rsplit_once(&['/', '\\'][..])
+                    .map_or(file, |(_, basename)| basename);
+
+                // Get error codes - same approach as CPython
+                let lib = sys::ERR_GET_LIB(e.code());
+                let reason = sys::ERR_GET_REASON(e.code());
+
+                // Look up error mnemonic from our static tables
+                // CPython uses dict lookup: err_codes_to_names[(lib, reason)]
+                let key = super::ssl_data::encode_error_key(lib, reason);
+                let errstr = super::ssl_data::ERROR_CODES
+                    .get(&key)
+                    .copied()
+                    .or_else(|| {
+                        // Fallback: use OpenSSL's error string
+                        e.reason()
+                    })
+                    .unwrap_or("unknown error");
+
+                // Check if this is a certificate verification error
+                // ERR_LIB_SSL = 20 (from _ssl_data_300.h)
+                // SSL_R_CERTIFICATE_VERIFY_FAILED = 134 (from _ssl_data_300.h)
+                let is_cert_verify_error = lib == 20 && reason == 134;
+
+                // Look up library name from our static table
+                // CPython uses: lib_codes_to_names[lib]
+                let lib_name = super::ssl_data::LIBRARY_CODES.get(&(lib as u32)).copied();
+
+                // Use SSLCertVerificationError for certificate verification failures
+                let cls = if is_cert_verify_error {
+                    PySSLCertVerificationError::class(&vm.ctx).to_owned()
+                } else {
+                    PySSLError::class(&vm.ctx).to_owned()
+                };
+
+                // Build message
+                let msg = if let Some(lib_str) = lib_name {
+                    format!("[{lib_str}] {errstr} ({file}:{line})")
+                } else {
+                    format!("{errstr} ({file}:{line})")
+                };
+
+                // Create exception instance
+                let reason = sys::ERR_GET_REASON(e.code());
+                let exc = vm.new_os_subtype_error(cls, Some(reason), msg);
+                let exc_obj: PyObjectRef = exc.upcast::<PyBaseException>().into();
+
+                // Set reason attribute (always set, even if just the error string)
+                let reason_value = vm.ctx.new_str(errstr);
+                let _ = exc_obj.set_attr("reason", reason_value, vm);
+
+                // Set library attribute (None if not available)
+                let library_value: PyObjectRef = if let Some(lib_str) = lib_name {
+                    vm.ctx.new_str(lib_str).into()
+                } else {
+                    vm.ctx.none()
+                };
+                let _ = exc_obj.set_attr("library", library_value, vm);
+
+                // For SSLCertVerificationError, set verify_code and verify_message
+                // Note: These will be set to None here, and can be updated by the caller
+                // if they have access to the SSL object
+                if is_cert_verify_error {
+                    let _ = exc_obj.set_attr("verify_code", vm.ctx.none(), vm);
+                    let _ = exc_obj.set_attr("verify_message", vm.ctx.none(), vm);
+                }
+
+                // Convert back to PyBaseExceptionRef
+                exc_obj.downcast().expect(
+                    "exc_obj is created as PyBaseExceptionRef and must downcast successfully",
+                )
+            }
+            None => {
+                let cls = PySSLError::class(&vm.ctx).to_owned();
+                vm.new_os_subtype_error(cls, None, "unknown SSL error")
+                    .upcast()
+            }
+        }
+    }
+
+    // Helper function to set verify_code and verify_message on SSLCertVerificationError
+    fn set_verify_error_info(
+        exc: &Py<PyBaseException>,
+        ssl_ptr: *const sys::SSL,
+        vm: &VirtualMachine,
+    ) {
+        // Get verify result
+        let verify_code = unsafe { sys::SSL_get_verify_result(ssl_ptr) };
+        let verify_code_obj = vm.ctx.new_int(verify_code);
+
+        // Get verify message
+        let verify_message = unsafe {
+            let verify_str = sys::X509_verify_cert_error_string(verify_code);
+            if verify_str.is_null() {
+                vm.ctx.none()
+            } else {
+                let c_str = std::ffi::CStr::from_ptr(verify_str);
+                vm.ctx.new_str(c_str.to_string_lossy()).into()
+            }
+        };
+
+        let exc_obj = exc.as_object();
+        let _ = exc_obj.set_attr("verify_code", verify_code_obj, vm);
+        let _ = exc_obj.set_attr("verify_message", verify_message, vm);
+    }
+    #[track_caller]
+    fn convert_ssl_error(
+        vm: &VirtualMachine,
+        e: impl std::borrow::Borrow<ssl::Error>,
+    ) -> PyBaseExceptionRef {
+        let e = e.borrow();
+        let (cls, msg) = match e.code() {
+            ssl::ErrorCode::WANT_READ => {
+                return create_ssl_want_read_error(vm).upcast();
+            }
+            ssl::ErrorCode::WANT_WRITE => {
+                return create_ssl_want_write_error(vm).upcast();
+            }
+            ssl::ErrorCode::SYSCALL => match e.io_error() {
+                Some(io_err) => return io_err.to_pyexception(vm),
+                // When no I/O error and OpenSSL error queue is empty,
+                // this is an EOF in violation of protocol -> SSLEOFError
+                None => {
+                    return create_ssl_eof_error(vm).upcast();
+                }
+            },
+            ssl::ErrorCode::SSL => {
+                // Check for OpenSSL 3.0 SSL_R_UNEXPECTED_EOF_WHILE_READING
+                if let Some(ssl_err) = e.ssl_error() {
+                    // In OpenSSL 3.0+, unexpected EOF is reported as SSL_ERROR_SSL
+                    // with this specific reason code instead of SSL_ERROR_SYSCALL
+                    unsafe {
+                        let err_code = sys::ERR_peek_last_error();
+                        let reason = sys::ERR_GET_REASON(err_code);
+                        let lib = sys::ERR_GET_LIB(err_code);
+                        if lib == ERR_LIB_SSL && reason == SSL_R_UNEXPECTED_EOF_WHILE_READING {
+                            return create_ssl_eof_error(vm).upcast();
+                        }
+                    }
+                    return convert_openssl_error(vm, ssl_err.clone());
+                }
+                (
+                    PySSLError::class(&vm.ctx).to_owned(),
+                    "A failure in the SSL library occurred",
+                )
+            }
+            _ => (
+                PySSLError::class(&vm.ctx).to_owned(),
+                "A failure in the SSL library occurred",
+            ),
+        };
+        vm.new_os_subtype_error(cls, None, msg).upcast()
+    }
+
+    // SSL_FILETYPE_ASN1 part of _add_ca_certs in CPython
+    fn x509_stack_from_der(der: &[u8]) -> Result<Vec<X509>, ErrorStack> {
+        unsafe {
+            openssl::init();
+            let bio = bio::MemBioSlice::new(der)?;
+
+            let mut certs = vec![];
+            let mut was_bio_eof = false;
+
+            loop {
+                // Check for EOF before attempting to parse (like CPython's _add_ca_certs)
+                // BIO_ctrl with BIO_CTRL_EOF returns 1 if EOF, 0 otherwise
+                if sys::BIO_ctrl(bio.as_ptr(), sys::BIO_CTRL_EOF, 0, std::ptr::null_mut()) != 0 {
+                    was_bio_eof = true;
+                    break;
+                }
+
+                let cert = sys::d2i_X509_bio(bio.as_ptr(), std::ptr::null_mut());
+                if cert.is_null() {
+                    // Parse error (not just EOF)
+                    break;
+                }
+                certs.push(X509::from_ptr(cert));
+            }
+
+            // If we loaded some certs but didn't reach EOF, there's garbage data
+            // (like cacert_der + b"A") - this is an error
+            if !certs.is_empty() && !was_bio_eof {
+                // Return the error from the last failed parse attempt
+                return Err(ErrorStack::get());
+            }
+
+            // Clear any errors (including parse errors when no certs loaded)
+            // Let the caller decide how to handle empty results
+            sys::ERR_clear_error();
+            Ok(certs)
+        }
+    }
+
+    type CipherTuple = (&'static str, &'static str, i32);
+
+    fn cipher_to_tuple(cipher: &ssl::SslCipherRef) -> CipherTuple {
+        (cipher.name(), cipher.version(), cipher.bits().secret)
+    }
+
+    fn cipher_description(cipher: *const sys::SSL_CIPHER) -> String {
+        unsafe {
+            // SSL_CIPHER_description writes up to 128 bytes
+            let mut buf = vec![0u8; 256];
+            let result = sys::SSL_CIPHER_description(
+                cipher,
+                buf.as_mut_ptr() as *mut libc::c_char,
+                buf.len() as i32,
+            );
+            if result.is_null() {
+                return String::from("No description available");
+            }
+            // Find the null terminator
+            let len = buf.iter().position(|&c| c == 0).unwrap_or(buf.len());
+            String::from_utf8_lossy(&buf[..len]).trim().to_string()
+        }
+    }
+
+    impl Read for SocketStream {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            let mut socket: &PySocket = &self.0;
+            socket.read(buf)
+        }
+    }
+
+    impl Write for SocketStream {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            let mut socket: &PySocket = &self.0;
+            socket.write(buf)
+        }
+        fn flush(&mut self) -> std::io::Result<()> {
+            let mut socket: &PySocket = &self.0;
+            socket.flush()
+        }
+    }
+
+    #[cfg(target_os = "android")]
+    mod android {
+        use super::convert_openssl_error;
+        use crate::vm::{VirtualMachine, builtins::PyBaseExceptionRef};
+        use openssl::{
+            ssl::SslContextBuilder,
+            x509::{X509, store::X509StoreBuilder},
+        };
+        use std::{
+            fs::{File, read_dir},
+            io::Read,
+            path::Path,
+        };
+
+        static CERT_DIR: &'static str = "/system/etc/security/cacerts";
+
+        pub(super) fn load_client_ca_list(
+            vm: &VirtualMachine,
+            b: &mut SslContextBuilder,
+        ) -> Result<(), PyBaseExceptionRef> {
+            let root = Path::new(CERT_DIR);
+            if !root.is_dir() {
+                return Err(vm
+                    .new_os_subtype_error(
+                        vm.ctx.exceptions.file_not_found_error.to_owned(),
+                        None,
+                        CERT_DIR.to_string(),
+                    )
+                    .upcast());
+            }
+
+            let mut combined_pem = String::new();
+            let entries = read_dir(root)
+                .map_err(|err| vm.new_os_error(format!("read cert root: {}", err)))?;
+            for entry in entries {
+                let entry =
+                    entry.map_err(|err| vm.new_os_error(format!("iter cert root: {}", err)))?;
+
+                let path = entry.path();
+                if !path.is_file() {
+                    continue;
+                }
+
+                File::open(&path)
+                    .and_then(|mut file| file.read_to_string(&mut combined_pem))
+                    .map_err(|err| {
+                        vm.new_os_error(format!("open cert file {}: {}", path.display(), err))
+                    })?;
+
+                combined_pem.push('\n');
+            }
+
+            let mut store_b =
+                X509StoreBuilder::new().map_err(|err| convert_openssl_error(vm, err))?;
+            let x509_vec = X509::stack_from_pem(combined_pem.as_bytes())
+                .map_err(|err| convert_openssl_error(vm, err))?;
+            for x509 in x509_vec {
+                store_b
+                    .add_cert(x509)
+                    .map_err(|err| convert_openssl_error(vm, err))?;
+            }
+            b.set_cert_store(store_b.build());
+
+            Ok(())
+        }
+    }
+}
+
+#[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)]
+mod ossl101 {
+    #[pyattr]
+    use openssl_sys::{
+        SSL_OP_NO_COMPRESSION as OP_NO_COMPRESSION, SSL_OP_NO_TLSv1_1 as OP_NO_TLSv1_1,
+        SSL_OP_NO_TLSv1_2 as OP_NO_TLSv1_2,
+    };
+}
+
+#[allow(non_upper_case_globals)]
+#[cfg(ossl111)]
+#[pymodule(sub)]
+mod ossl111 {
+    #[pyattr]
+    use openssl_sys::SSL_OP_NO_TLSv1_3 as OP_NO_TLSv1_3;
+}
+
+#[cfg(windows)]
+#[pymodule(sub)]
+mod windows {
+    use crate::{
+        common::ascii,
+        vm::{
+            PyObjectRef, PyPayload, PyResult, VirtualMachine,
+            builtins::{PyFrozenSet, PyStrRef},
+            convert::ToPyException,
+        },
+    };
+
+    #[pyfunction]
+    fn enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        use schannel::{RawPointer, cert_context::ValidUses, cert_store::CertStore};
+        use windows_sys::Win32::Security::Cryptography;
+
+        // TODO: check every store for it, not just 2 of them:
+        // https://github.com/python/cpython/blob/3.8/Modules/_ssl.c#L5603-L5610
+        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())
+            .collect::<Vec<_>>();
+        let certs = stores.iter().flat_map(|s| s.certs()).map(|c| {
+            let cert = vm.ctx.new_bytes(c.to_der().to_owned());
+            let enc_type = unsafe {
+                let ptr = c.as_ptr() as *const Cryptography::CERT_CONTEXT;
+                (*ptr).dwCertEncodingType
+            };
+            let enc_type = match enc_type {
+                Cryptography::X509_ASN_ENCODING => vm.new_pyobj(ascii!("x509_asn")),
+                Cryptography::PKCS_7_ASN_ENCODING => vm.new_pyobj(ascii!("pkcs_7_asn")),
+                other => vm.new_pyobj(other),
+            };
+            let usage: PyObjectRef = match c.valid_uses().map_err(|e| e.to_pyexception(vm))? {
+                ValidUses::All => vm.ctx.new_bool(true).into(),
+                ValidUses::Oids(oids) => PyFrozenSet::from_iter(
+                    vm,
+                    oids.into_iter().map(|oid| vm.ctx.new_str(oid).into()),
+                )?
+                .into_ref(&vm.ctx)
+                .into(),
+            };
+            Ok(vm.new_tuple((cert, enc_type, usage)).into())
+        });
+        let certs: Vec<PyObjectRef> = certs.collect::<PyResult<Vec<_>>>()?;
+        Ok(certs)
+    }
+}
+
+mod bio {
+    //! based off rust-openssl's private `bio` module
+
+    use libc::c_int;
+    use openssl::error::ErrorStack;
+    use openssl_sys as sys;
+    use std::marker::PhantomData;
+
+    pub struct MemBioSlice<'a>(*mut sys::BIO, PhantomData<&'a [u8]>);
+
+    impl Drop for MemBioSlice<'_> {
+        fn drop(&mut self) {
+            unsafe {
+                sys::BIO_free_all(self.0);
+            }
+        }
+    }
+
+    impl<'a> MemBioSlice<'a> {
+        pub fn new(buf: &'a [u8]) -> Result<MemBioSlice<'a>, ErrorStack> {
+            openssl::init();
+
+            assert!(buf.len() <= c_int::MAX as usize);
+            let bio = unsafe { sys::BIO_new_mem_buf(buf.as_ptr() as *const _, buf.len() as c_int) };
+            if bio.is_null() {
+                return Err(ErrorStack::get());
+            }
+
+            Ok(MemBioSlice(bio, PhantomData))
+        }
+
+        pub fn as_ptr(&self) -> *mut sys::BIO {
+            self.0
+        }
+    }
+}
diff --git a/crates/stdlib/src/openssl/cert.rs b/crates/stdlib/src/openssl/cert.rs
new file mode 100644
index 0000000000..b63d824a83
--- /dev/null
+++ b/crates/stdlib/src/openssl/cert.rs
@@ -0,0 +1,366 @@
+pub(super) use ssl_cert::{PySSLCertificate, cert_to_certificate, cert_to_py, obj2txt};
+
+// Certificate type for SSL module
+
+#[pymodule(sub)]
+pub(crate) mod ssl_cert {
+    use crate::{
+        common::{ascii, hash::PyHash},
+        vm::{
+            Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+            class_or_notimplemented,
+            convert::{ToPyException, ToPyObject},
+            function::{FsPath, OptionalArg, PyComparisonValue},
+            types::{Comparable, Hashable, PyComparisonOp, Representable},
+        },
+    };
+    use foreign_types_shared::ForeignTypeRef;
+    use openssl::{
+        asn1::Asn1ObjectRef,
+        nid::Nid,
+        x509::{self, X509, X509Ref},
+    };
+    use openssl_sys as sys;
+    use std::fmt;
+
+    // Import constants and error converter from _ssl module
+    use crate::openssl::_ssl::{ENCODING_DER, ENCODING_PEM, convert_openssl_error};
+
+    pub(crate) fn obj2txt(obj: &Asn1ObjectRef, no_name: bool) -> Option<String> {
+        let no_name = i32::from(no_name);
+        let ptr = obj.as_ptr();
+        let b = unsafe {
+            let buflen = sys::OBJ_obj2txt(std::ptr::null_mut(), 0, ptr, no_name);
+            assert!(buflen >= 0);
+            if buflen == 0 {
+                return None;
+            }
+            let buflen = buflen as usize;
+            let mut buf = Vec::<u8>::with_capacity(buflen + 1);
+            let ret = sys::OBJ_obj2txt(
+                buf.as_mut_ptr() as *mut libc::c_char,
+                buf.capacity() as _,
+                ptr,
+                no_name,
+            );
+            assert!(ret >= 0);
+            // SAFETY: OBJ_obj2txt initialized the buffer successfully
+            buf.set_len(buflen);
+            buf
+        };
+        let s = String::from_utf8(b)
+            .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
+        Some(s)
+    }
+
+    #[pyattr]
+    #[pyclass(module = "ssl", name = "Certificate")]
+    #[derive(PyPayload)]
+    pub(crate) struct PySSLCertificate {
+        pub(crate) cert: X509,
+    }
+
+    impl fmt::Debug for PySSLCertificate {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("Certificate")
+        }
+    }
+
+    #[pyclass(with(Comparable, Hashable, Representable))]
+    impl PySSLCertificate {
+        #[pymethod]
+        fn public_bytes(
+            &self,
+            format: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let format = format.unwrap_or(ENCODING_PEM);
+
+            match format {
+                ENCODING_DER => {
+                    // DER encoding
+                    let der = self
+                        .cert
+                        .to_der()
+                        .map_err(|e| convert_openssl_error(vm, e))?;
+                    Ok(vm.ctx.new_bytes(der).into())
+                }
+                ENCODING_PEM => {
+                    // PEM encoding - returns string
+                    let pem = self
+                        .cert
+                        .to_pem()
+                        .map_err(|e| convert_openssl_error(vm, e))?;
+                    let pem_str = String::from_utf8(pem)
+                        .map_err(|_| vm.new_value_error("Invalid UTF-8 in PEM"))?;
+                    Ok(vm.ctx.new_str(pem_str).into())
+                }
+                _ => Err(vm.new_value_error("Unsupported format")),
+            }
+        }
+
+        #[pymethod]
+        fn get_info(&self, vm: &VirtualMachine) -> PyResult {
+            cert_to_dict(vm, &self.cert)
+        }
+    }
+
+    impl Comparable for PySSLCertificate {
+        fn cmp(
+            zelf: &Py<Self>,
+            other: &PyObject,
+            op: PyComparisonOp,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyComparisonValue> {
+            let other = class_or_notimplemented!(Self, other);
+
+            // Only support equality comparison
+            if !matches!(op, PyComparisonOp::Eq | PyComparisonOp::Ne) {
+                return Ok(PyComparisonValue::NotImplemented);
+            }
+
+            // Compare DER encodings
+            let self_der = zelf
+                .cert
+                .to_der()
+                .map_err(|e| convert_openssl_error(vm, e))?;
+            let other_der = other
+                .cert
+                .to_der()
+                .map_err(|e| convert_openssl_error(vm, e))?;
+
+            let eq = self_der == other_der;
+            Ok(op.eval_ord(eq.cmp(&true)).into())
+        }
+    }
+
+    impl Hashable for PySSLCertificate {
+        fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash> {
+            // Use subject name hash as certificate hash
+            let hash = unsafe { sys::X509_subject_name_hash(zelf.cert.as_ptr()) };
+            Ok(hash as PyHash)
+        }
+    }
+
+    impl Representable for PySSLCertificate {
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            // Build subject string like "CN=localhost, O=Python"
+            let subject = zelf.cert.subject_name();
+            let mut parts: Vec<String> = Vec::new();
+            for entry in subject.entries() {
+                // Use short name (SN) if available, otherwise use OID
+                let name = match entry.object().nid().short_name() {
+                    Ok(sn) => sn.to_string(),
+                    Err(_) => obj2txt(entry.object(), true).unwrap_or_default(),
+                };
+                if let Ok(value) = entry.data().as_utf8() {
+                    parts.push(format!("{}={}", name, value));
+                }
+            }
+            if parts.is_empty() {
+                Ok("<Certificate>".to_string())
+            } else {
+                Ok(format!("<Certificate '{}'>", parts.join(", ")))
+            }
+        }
+    }
+
+    fn name_to_py(vm: &VirtualMachine, name: &x509::X509NameRef) -> PyResult {
+        let list = name
+            .entries()
+            .map(|entry| {
+                let txt = obj2txt(entry.object(), false).to_pyobject(vm);
+                let asn1_str = entry.data();
+                let data_bytes = asn1_str.as_slice();
+                let data = match std::str::from_utf8(data_bytes) {
+                    Ok(s) => vm.ctx.new_str(s.to_owned()),
+                    Err(_) => vm
+                        .ctx
+                        .new_str(String::from_utf8_lossy(data_bytes).into_owned()),
+                };
+                Ok(vm.new_tuple(((txt, data),)).into())
+            })
+            .collect::<Result<_, _>>()?;
+        Ok(vm.ctx.new_tuple(list).into())
+    }
+
+    // Helper to convert X509 to dict (for getpeercert with binary=False)
+    fn cert_to_dict(vm: &VirtualMachine, cert: &X509Ref) -> PyResult {
+        let dict = vm.ctx.new_dict();
+
+        dict.set_item("subject", name_to_py(vm, cert.subject_name())?, vm)?;
+        dict.set_item("issuer", name_to_py(vm, cert.issuer_name())?, vm)?;
+        // X.509 version: OpenSSL uses 0-based (0=v1, 1=v2, 2=v3) but Python uses 1-based (1=v1, 2=v2, 3=v3)
+        dict.set_item("version", vm.new_pyobj(cert.version() + 1), vm)?;
+
+        let serial_num = cert
+            .serial_number()
+            .to_bn()
+            .and_then(|bn| bn.to_hex_str())
+            .map_err(|e| convert_openssl_error(vm, e))?;
+        // Serial number must have even length (each byte = 2 hex chars)
+        // BigNum::to_hex_str() strips leading zeros, so we need to pad
+        let serial_str = serial_num.to_string();
+        let serial_str = if serial_str.len() % 2 == 1 {
+            format!("0{}", serial_str)
+        } else {
+            serial_str
+        };
+        dict.set_item("serialNumber", vm.ctx.new_str(serial_str).into(), vm)?;
+
+        dict.set_item(
+            "notBefore",
+            vm.ctx.new_str(cert.not_before().to_string()).into(),
+            vm,
+        )?;
+        dict.set_item(
+            "notAfter",
+            vm.ctx.new_str(cert.not_after().to_string()).into(),
+            vm,
+        )?;
+
+        if let Some(names) = cert.subject_alt_names() {
+            let san: Vec<PyObjectRef> = names
+                .iter()
+                .map(|gen_name| {
+                    if let Some(email) = gen_name.email() {
+                        vm.new_tuple((ascii!("email"), email)).into()
+                    } else if let Some(dnsname) = gen_name.dnsname() {
+                        vm.new_tuple((ascii!("DNS"), dnsname)).into()
+                    } else if let Some(ip) = gen_name.ipaddress() {
+                        // Parse IP address properly (IPv4 or IPv6)
+                        let ip_str = if ip.len() == 4 {
+                            // IPv4
+                            format!("{}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3])
+                        } else if ip.len() == 16 {
+                            // IPv6 - format with all zeros visible (not compressed)
+                            let ip_addr =
+                                std::net::Ipv6Addr::from(<[u8; 16]>::try_from(&ip[0..16]).unwrap());
+                            let s = ip_addr.segments();
+                            format!(
+                                "{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}",
+                                s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]
+                            )
+                        } else {
+                            // Fallback for unexpected length
+                            String::from_utf8_lossy(ip).into_owned()
+                        };
+                        vm.new_tuple((ascii!("IP Address"), ip_str)).into()
+                    } else if let Some(uri) = gen_name.uri() {
+                        vm.new_tuple((ascii!("URI"), uri)).into()
+                    } else {
+                        // Handle DirName, Registered ID, and othername
+                        // Check if this is a directory name
+                        if let Some(dirname) = gen_name.directory_name()
+                            && let Ok(py_name) = name_to_py(vm, dirname)
+                        {
+                            return vm.new_tuple((ascii!("DirName"), py_name)).into();
+                        }
+
+                        // Check for Registered ID (GEN_RID)
+                        // Access raw GENERAL_NAME to check type
+                        let ptr = gen_name.as_ptr();
+                        unsafe {
+                            if (*ptr).type_ == sys::GEN_RID {
+                                // d is ASN1_OBJECT* for GEN_RID
+                                let oid_ptr = (*ptr).d as *const sys::ASN1_OBJECT;
+                                if !oid_ptr.is_null() {
+                                    let oid_ref = Asn1ObjectRef::from_ptr(oid_ptr as *mut _);
+                                    if let Some(oid_str) = obj2txt(oid_ref, true) {
+                                        return vm
+                                            .new_tuple((ascii!("Registered ID"), oid_str))
+                                            .into();
+                                    }
+                                }
+                            }
+                        }
+
+                        // For othername and other unsupported types
+                        vm.new_tuple((ascii!("othername"), ascii!("<unsupported>")))
+                            .into()
+                    }
+                })
+                .collect();
+            dict.set_item("subjectAltName", vm.ctx.new_tuple(san).into(), vm)?;
+        };
+
+        // Authority Information Access: OCSP URIs
+        if let Ok(ocsp_list) = cert.ocsp_responders()
+            && !ocsp_list.is_empty()
+        {
+            let uris: Vec<PyObjectRef> = ocsp_list
+                .iter()
+                .map(|s| vm.ctx.new_str(s.to_string()).into())
+                .collect();
+            dict.set_item("OCSP", vm.ctx.new_tuple(uris).into(), vm)?;
+        }
+
+        // Authority Information Access: CA Issuers URIs
+        if let Some(aia) = cert.authority_info() {
+            let ca_issuers: Vec<PyObjectRef> = aia
+                .iter()
+                .filter_map(|ad| {
+                    // Check if method is CA Issuers (NID_ad_ca_issuers)
+                    if ad.method().nid() != Nid::AD_CA_ISSUERS {
+                        return None;
+                    }
+                    // Get URI from location
+                    ad.location()
+                        .uri()
+                        .map(|uri| vm.ctx.new_str(uri.to_owned()).into())
+                })
+                .collect();
+            if !ca_issuers.is_empty() {
+                dict.set_item("caIssuers", vm.ctx.new_tuple(ca_issuers).into(), vm)?;
+            }
+        }
+
+        // CRL Distribution Points
+        if let Some(crl_dps) = cert.crl_distribution_points() {
+            let mut crl_uris: Vec<PyObjectRef> = Vec::new();
+            for dp in crl_dps.iter() {
+                if let Some(dp_name) = dp.distpoint()
+                    && let Some(fullname) = dp_name.fullname()
+                {
+                    for gn in fullname.iter() {
+                        if let Some(uri) = gn.uri() {
+                            crl_uris.push(vm.ctx.new_str(uri.to_owned()).into());
+                        }
+                    }
+                }
+            }
+            if !crl_uris.is_empty() {
+                dict.set_item(
+                    "crlDistributionPoints",
+                    vm.ctx.new_tuple(crl_uris).into(),
+                    vm,
+                )?;
+            }
+        }
+
+        Ok(dict.into())
+    }
+
+    // Helper to create Certificate object from X509
+    pub(crate) fn cert_to_certificate(vm: &VirtualMachine, cert: X509) -> PyResult {
+        Ok(PySSLCertificate { cert }.into_ref(&vm.ctx).into())
+    }
+
+    // For getpeercert() - returns bytes or dict depending on binary flag
+    pub(crate) fn cert_to_py(vm: &VirtualMachine, cert: &X509Ref, binary: bool) -> PyResult {
+        if binary {
+            let b = cert.to_der().map_err(|e| convert_openssl_error(vm, e))?;
+            Ok(vm.ctx.new_bytes(b).into())
+        } else {
+            cert_to_dict(vm, cert)
+        }
+    }
+
+    #[pyfunction]
+    pub(crate) fn _test_decode_cert(path: FsPath, vm: &VirtualMachine) -> PyResult {
+        let path = path.to_path_buf(vm)?;
+        let pem = std::fs::read(path).map_err(|e| e.to_pyexception(vm))?;
+        let x509 = X509::from_pem(&pem).map_err(|e| convert_openssl_error(vm, e))?;
+        cert_to_py(vm, &x509, false)
+    }
+}
diff --git a/crates/stdlib/src/openssl/ssl_data_111.rs b/crates/stdlib/src/openssl/ssl_data_111.rs
new file mode 100644
index 0000000000..2d5f56f485
--- /dev/null
+++ b/crates/stdlib/src/openssl/ssl_data_111.rs
@@ -0,0 +1,1347 @@
+// File generated by tools/make_ssl_data_rs.py
+// Generated on 2025-10-29T07:17:23.692784+00:00
+// Source: OpenSSL from /tmp/openssl-1.1.1
+// spell-checker: disable
+
+use phf::phf_map;
+
+// Maps lib_code -> library name
+// Example: 20 -> "SSL"
+pub static LIBRARY_CODES: phf::Map<u32, &'static str> = phf_map! {
+    1u32 => "NONE",
+    2u32 => "SYS",
+    3u32 => "BN",
+    4u32 => "RSA",
+    5u32 => "DH",
+    6u32 => "EVP",
+    7u32 => "BUF",
+    8u32 => "OBJ",
+    9u32 => "PEM",
+    10u32 => "DSA",
+    11u32 => "X509",
+    12u32 => "METH",
+    13u32 => "ASN1",
+    14u32 => "CONF",
+    15u32 => "CRYPTO",
+    16u32 => "EC",
+    20u32 => "SSL",
+    21u32 => "SSL23",
+    22u32 => "SSL2",
+    23u32 => "SSL3",
+    30u32 => "RSAREF",
+    31u32 => "PROXY",
+    32u32 => "BIO",
+    33u32 => "PKCS7",
+    34u32 => "X509V3",
+    35u32 => "PKCS12",
+    36u32 => "RAND",
+    37u32 => "DSO",
+    38u32 => "ENGINE",
+    39u32 => "OCSP",
+    40u32 => "UI",
+    41u32 => "COMP",
+    42u32 => "ECDSA",
+    43u32 => "ECDH",
+    44u32 => "OSSL_STORE",
+    45u32 => "FIPS",
+    46u32 => "CMS",
+    47u32 => "TS",
+    48u32 => "HMAC",
+    49u32 => "JPAKE",
+    50u32 => "CT",
+    51u32 => "ASYNC",
+    52u32 => "KDF",
+    53u32 => "SM2",
+    128u32 => "USER",
+};
+
+// Maps encoded (lib, reason) -> error mnemonic
+// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED"
+// Key encoding: (lib << 32) | reason
+pub static ERROR_CODES: phf::Map<u64, &'static str> = phf_map! {
+    55834575019u64 => "ADDING_OBJECT",
+    55834575051u64 => "ASN1_PARSE_ERROR",
+    55834575052u64 => "ASN1_SIG_PARSE_ERROR",
+    55834574948u64 => "AUX_ERROR",
+    55834574950u64 => "BAD_OBJECT_HEADER",
+    55834575078u64 => "BAD_TEMPLATE",
+    55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH",
+    55834574953u64 => "BN_LIB",
+    55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH",
+    55834574955u64 => "BUFFER_TOO_SMALL",
+    55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    55834575065u64 => "CONTEXT_NOT_INITIALISED",
+    55834574957u64 => "DATA_IS_WRONG",
+    55834574958u64 => "DECODE_ERROR",
+    55834575022u64 => "DEPTH_EXCEEDED",
+    55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED",
+    55834574960u64 => "ENCODE_ERROR",
+    55834575021u64 => "ERROR_GETTING_TIME",
+    55834575020u64 => "ERROR_LOADING_SECTION",
+    55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS",
+    55834574963u64 => "EXPECTING_AN_INTEGER",
+    55834574964u64 => "EXPECTING_AN_OBJECT",
+    55834574967u64 => "EXPLICIT_LENGTH_MISMATCH",
+    55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED",
+    55834574969u64 => "FIELD_MISSING",
+    55834574970u64 => "FIRST_NUM_TOO_LARGE",
+    55834574971u64 => "HEADER_TOO_LONG",
+    55834575023u64 => "ILLEGAL_BITSTRING_FORMAT",
+    55834575024u64 => "ILLEGAL_BOOLEAN",
+    55834574972u64 => "ILLEGAL_CHARACTERS",
+    55834575025u64 => "ILLEGAL_FORMAT",
+    55834575026u64 => "ILLEGAL_HEX",
+    55834575027u64 => "ILLEGAL_IMPLICIT_TAG",
+    55834575028u64 => "ILLEGAL_INTEGER",
+    55834575074u64 => "ILLEGAL_NEGATIVE_VALUE",
+    55834575029u64 => "ILLEGAL_NESTED_TAGGING",
+    55834574973u64 => "ILLEGAL_NULL",
+    55834575030u64 => "ILLEGAL_NULL_VALUE",
+    55834575031u64 => "ILLEGAL_OBJECT",
+    55834574974u64 => "ILLEGAL_OPTIONAL_ANY",
+    55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE",
+    55834575069u64 => "ILLEGAL_PADDING",
+    55834574975u64 => "ILLEGAL_TAGGED_ANY",
+    55834575032u64 => "ILLEGAL_TIME_VALUE",
+    55834575070u64 => "ILLEGAL_ZERO_CONTENT",
+    55834575033u64 => "INTEGER_NOT_ASCII_FORMAT",
+    55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG",
+    55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT",
+    55834574977u64 => "INVALID_BMPSTRING_LENGTH",
+    55834574978u64 => "INVALID_DIGIT",
+    55834575053u64 => "INVALID_MIME_TYPE",
+    55834575034u64 => "INVALID_MODIFIER",
+    55834575035u64 => "INVALID_NUMBER",
+    55834575064u64 => "INVALID_OBJECT_ENCODING",
+    55834575075u64 => "INVALID_SCRYPT_PARAMETERS",
+    55834574979u64 => "INVALID_SEPARATOR",
+    55834575066u64 => "INVALID_STRING_TABLE_VALUE",
+    55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH",
+    55834574982u64 => "INVALID_UTF8STRING",
+    55834575067u64 => "INVALID_VALUE",
+    55834575036u64 => "LIST_ERROR",
+    55834575054u64 => "MIME_NO_CONTENT_TYPE",
+    55834575055u64 => "MIME_PARSE_ERROR",
+    55834575056u64 => "MIME_SIG_PARSE_ERROR",
+    55834574985u64 => "MISSING_EOC",
+    55834574986u64 => "MISSING_SECOND_NUMBER",
+    55834575037u64 => "MISSING_VALUE",
+    55834574987u64 => "MSTRING_NOT_UNIVERSAL",
+    55834574988u64 => "MSTRING_WRONG_TAG",
+    55834575045u64 => "NESTED_ASN1_STRING",
+    55834575049u64 => "NESTED_TOO_DEEP",
+    55834574989u64 => "NON_HEX_CHARACTERS",
+    55834575038u64 => "NOT_ASCII_FORMAT",
+    55834574990u64 => "NOT_ENOUGH_DATA",
+    55834575057u64 => "NO_CONTENT_TYPE",
+    55834574991u64 => "NO_MATCHING_CHOICE_TYPE",
+    55834575058u64 => "NO_MULTIPART_BODY_FAILURE",
+    55834575059u64 => "NO_MULTIPART_BOUNDARY",
+    55834575060u64 => "NO_SIG_CONTENT_TYPE",
+    55834574992u64 => "NULL_IS_WRONG_LENGTH",
+    55834575039u64 => "OBJECT_NOT_ASCII_FORMAT",
+    55834574993u64 => "ODD_NUMBER_OF_CHARS",
+    55834574995u64 => "SECOND_NUMBER_TOO_LARGE",
+    55834574996u64 => "SEQUENCE_LENGTH_MISMATCH",
+    55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED",
+    55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG",
+    55834574998u64 => "SHORT_LINE",
+    55834575061u64 => "SIG_INVALID_MIME_TYPE",
+    55834575050u64 => "STREAMING_NOT_SUPPORTED",
+    55834574999u64 => "STRING_TOO_LONG",
+    55834575000u64 => "STRING_TOO_SHORT",
+    55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    55834575041u64 => "TIME_NOT_ASCII_FORMAT",
+    55834575071u64 => "TOO_LARGE",
+    55834575003u64 => "TOO_LONG",
+    55834575072u64 => "TOO_SMALL",
+    55834575004u64 => "TYPE_NOT_CONSTRUCTED",
+    55834575043u64 => "TYPE_NOT_PRIMITIVE",
+    55834575007u64 => "UNEXPECTED_EOC",
+    55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH",
+    55834575008u64 => "UNKNOWN_FORMAT",
+    55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM",
+    55834575010u64 => "UNKNOWN_OBJECT_TYPE",
+    55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE",
+    55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM",
+    55834575042u64 => "UNKNOWN_TAG",
+    55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE",
+    55834575076u64 => "UNSUPPORTED_CIPHER",
+    55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    55834575044u64 => "UNSUPPORTED_TYPE",
+    55834575073u64 => "WRONG_INTEGER_TYPE",
+    55834575048u64 => "WRONG_PUBLIC_KEY_TYPE",
+    55834575016u64 => "WRONG_TAG",
+    219043332197u64 => "FAILED_TO_SET_POOL",
+    219043332198u64 => "FAILED_TO_SWAP_CONTEXT",
+    219043332201u64 => "INIT_FAILED",
+    219043332199u64 => "INVALID_POOL_SIZE",
+    137438953572u64 => "ACCEPT_ERROR",
+    137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET",
+    137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE",
+    137438953573u64 => "BAD_FOPEN_MODE",
+    137438953596u64 => "BROKEN_PIPE",
+    137438953575u64 => "CONNECT_ERROR",
+    137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET",
+    137438953604u64 => "GETSOCKNAME_ERROR",
+    137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS",
+    137438953606u64 => "GETTING_SOCKTYPE",
+    137438953597u64 => "INVALID_ARGUMENT",
+    137438953607u64 => "INVALID_SOCKET",
+    137438953595u64 => "IN_USE",
+    137438953574u64 => "LENGTH_TOO_LONG",
+    137438953608u64 => "LISTEN_V6_ONLY",
+    137438953614u64 => "LOOKUP_RETURNED_NOTHING",
+    137438953602u64 => "MALFORMED_HOST_OR_SERVICE",
+    137438953582u64 => "NBIO_CONNECT_ERROR",
+    137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED",
+    137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED",
+    137438953585u64 => "NO_PORT_DEFINED",
+    137438953600u64 => "NO_SUCH_FILE",
+    137438953587u64 => "NULL_PARAMETER",
+    137438953589u64 => "UNABLE_TO_BIND_SOCKET",
+    137438953590u64 => "UNABLE_TO_CREATE_SOCKET",
+    137438953609u64 => "UNABLE_TO_KEEPALIVE",
+    137438953591u64 => "UNABLE_TO_LISTEN_SOCKET",
+    137438953610u64 => "UNABLE_TO_NODELAY",
+    137438953611u64 => "UNABLE_TO_REUSEADDR",
+    137438953617u64 => "UNAVAILABLE_IP_FAMILY",
+    137438953592u64 => "UNINITIALIZED",
+    137438953612u64 => "UNKNOWN_INFO_TYPE",
+    137438953618u64 => "UNSUPPORTED_IP_FAMILY",
+    137438953593u64 => "UNSUPPORTED_METHOD",
+    137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY",
+    137438953598u64 => "WRITE_TO_READ_ONLY_BIO",
+    137438953594u64 => "WSASTARTUP",
+    12884901988u64 => "ARG2_LT_ARG3",
+    12884901989u64 => "BAD_RECIPROCAL",
+    12884902002u64 => "BIGNUM_TOO_LONG",
+    12884902006u64 => "BITS_TOO_SMALL",
+    12884901990u64 => "CALLED_WITH_EVEN_MODULUS",
+    12884901991u64 => "DIV_BY_ZERO",
+    12884901992u64 => "ENCODING_ERROR",
+    12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA",
+    12884901998u64 => "INPUT_NOT_REDUCED",
+    12884901994u64 => "INVALID_LENGTH",
+    12884902003u64 => "INVALID_RANGE",
+    12884902007u64 => "INVALID_SHIFT",
+    12884901999u64 => "NOT_A_SQUARE",
+    12884901995u64 => "NOT_INITIALIZED",
+    12884901996u64 => "NO_INVERSE",
+    12884902004u64 => "NO_SOLUTION",
+    12884902005u64 => "PRIVATE_KEY_TOO_LARGE",
+    12884902000u64 => "P_IS_NOT_PRIME",
+    12884902001u64 => "TOO_MANY_ITERATIONS",
+    12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES",
+    197568495715u64 => "ADD_SIGNER_ERROR",
+    197568495777u64 => "ATTRIBUTE_ERROR",
+    197568495791u64 => "CERTIFICATE_ALREADY_PRESENT",
+    197568495776u64 => "CERTIFICATE_HAS_NO_KEYID",
+    197568495716u64 => "CERTIFICATE_VERIFY_ERROR",
+    197568495717u64 => "CIPHER_INITIALISATION_ERROR",
+    197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR",
+    197568495719u64 => "CMS_DATAFINAL_ERROR",
+    197568495720u64 => "CMS_LIB",
+    197568495786u64 => "CONTENTIDENTIFIER_MISMATCH",
+    197568495721u64 => "CONTENT_NOT_FOUND",
+    197568495787u64 => "CONTENT_TYPE_MISMATCH",
+    197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA",
+    197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA",
+    197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA",
+    197568495725u64 => "CONTENT_VERIFY_ERROR",
+    197568495726u64 => "CTRL_ERROR",
+    197568495727u64 => "CTRL_FAILURE",
+    197568495728u64 => "DECRYPT_ERROR",
+    197568495729u64 => "ERROR_GETTING_PUBLIC_KEY",
+    197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE",
+    197568495731u64 => "ERROR_SETTING_KEY",
+    197568495732u64 => "ERROR_SETTING_RECIPIENTINFO",
+    197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH",
+    197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER",
+    197568495734u64 => "INVALID_KEY_LENGTH",
+    197568495735u64 => "MD_BIO_INIT_ERROR",
+    197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH",
+    197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH",
+    197568495788u64 => "MSGSIGDIGEST_ERROR",
+    197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE",
+    197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH",
+    197568495780u64 => "NEED_ONE_SIGNER",
+    197568495781u64 => "NOT_A_SIGNED_RECEIPT",
+    197568495738u64 => "NOT_ENCRYPTED_DATA",
+    197568495739u64 => "NOT_KEK",
+    197568495797u64 => "NOT_KEY_AGREEMENT",
+    197568495740u64 => "NOT_KEY_TRANSPORT",
+    197568495793u64 => "NOT_PWRI",
+    197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    197568495742u64 => "NO_CIPHER",
+    197568495743u64 => "NO_CONTENT",
+    197568495789u64 => "NO_CONTENT_TYPE",
+    197568495744u64 => "NO_DEFAULT_DIGEST",
+    197568495745u64 => "NO_DIGEST_SET",
+    197568495746u64 => "NO_KEY",
+    197568495790u64 => "NO_KEY_OR_CERT",
+    197568495747u64 => "NO_MATCHING_DIGEST",
+    197568495748u64 => "NO_MATCHING_RECIPIENT",
+    197568495782u64 => "NO_MATCHING_SIGNATURE",
+    197568495783u64 => "NO_MSGSIGDIGEST",
+    197568495794u64 => "NO_PASSWORD",
+    197568495749u64 => "NO_PRIVATE_KEY",
+    197568495750u64 => "NO_PUBLIC_KEY",
+    197568495784u64 => "NO_RECEIPT_REQUEST",
+    197568495751u64 => "NO_SIGNERS",
+    197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    197568495785u64 => "RECEIPT_DECODE_ERROR",
+    197568495753u64 => "RECIPIENT_ERROR",
+    197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    197568495755u64 => "SIGNFINAL_ERROR",
+    197568495756u64 => "SMIME_TEXT_ERROR",
+    197568495757u64 => "STORE_INIT_ERROR",
+    197568495758u64 => "TYPE_NOT_COMPRESSED_DATA",
+    197568495759u64 => "TYPE_NOT_DATA",
+    197568495760u64 => "TYPE_NOT_DIGESTED_DATA",
+    197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA",
+    197568495762u64 => "TYPE_NOT_ENVELOPED_DATA",
+    197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT",
+    197568495764u64 => "UNKNOWN_CIPHER",
+    197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    197568495766u64 => "UNKNOWN_ID",
+    197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM",
+    197568495768u64 => "UNSUPPORTED_CONTENT_TYPE",
+    197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM",
+    197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM",
+    197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE",
+    197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE",
+    197568495772u64 => "UNSUPPORTED_TYPE",
+    197568495773u64 => "UNWRAP_ERROR",
+    197568495796u64 => "UNWRAP_FAILURE",
+    197568495774u64 => "VERIFICATION_FAILURE",
+    197568495775u64 => "WRAP_ERROR",
+    176093659235u64 => "ZLIB_DEFLATE_ERROR",
+    176093659236u64 => "ZLIB_INFLATE_ERROR",
+    176093659237u64 => "ZLIB_NOT_SUPPORTED",
+    60129542254u64 => "ERROR_LOADING_DSO",
+    60129542259u64 => "LIST_CANNOT_BE_NULL",
+    60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET",
+    60129542245u64 => "MISSING_EQUAL_SIGN",
+    60129542256u64 => "MISSING_INIT_FUNCTION",
+    60129542253u64 => "MODULE_INITIALIZATION_ERROR",
+    60129542246u64 => "NO_CLOSE_BRACE",
+    60129542249u64 => "NO_CONF",
+    60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE",
+    60129542251u64 => "NO_SECTION",
+    60129542258u64 => "NO_SUCH_FILE",
+    60129542252u64 => "NO_VALUE",
+    60129542265u64 => "NUMBER_TOO_LARGE",
+    60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE",
+    60129542261u64 => "SSL_COMMAND_SECTION_EMPTY",
+    60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    60129542263u64 => "SSL_SECTION_EMPTY",
+    60129542264u64 => "SSL_SECTION_NOT_FOUND",
+    60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION",
+    60129542257u64 => "UNKNOWN_MODULE_NAME",
+    60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG",
+    60129542248u64 => "VARIABLE_HAS_NO_VALUE",
+    64424509541u64 => "FIPS_MODE_NOT_SUPPORTED",
+    64424509542u64 => "ILLEGAL_HEX_DIGIT",
+    64424509543u64 => "ODD_NUMBER_OF_DIGITS",
+    214748364908u64 => "BASE64_DECODE_ERROR",
+    214748364900u64 => "INVALID_LOG_ID_LENGTH",
+    214748364909u64 => "LOG_CONF_INVALID",
+    214748364910u64 => "LOG_CONF_INVALID_KEY",
+    214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION",
+    214748364912u64 => "LOG_CONF_MISSING_KEY",
+    214748364913u64 => "LOG_KEY_INVALID",
+    214748364916u64 => "SCT_FUTURE_TIMESTAMP",
+    214748364904u64 => "SCT_INVALID",
+    214748364907u64 => "SCT_INVALID_SIGNATURE",
+    214748364905u64 => "SCT_LIST_INVALID",
+    214748364914u64 => "SCT_LOG_ID_MISMATCH",
+    214748364906u64 => "SCT_NOT_SET",
+    214748364915u64 => "SCT_UNSUPPORTED_VERSION",
+    214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID",
+    214748364902u64 => "UNSUPPORTED_ENTRY_TYPE",
+    214748364903u64 => "UNSUPPORTED_VERSION",
+    21474836581u64 => "BAD_GENERATOR",
+    21474836589u64 => "BN_DECODE_ERROR",
+    21474836586u64 => "BN_ERROR",
+    21474836595u64 => "CHECK_INVALID_J_VALUE",
+    21474836596u64 => "CHECK_INVALID_Q_VALUE",
+    21474836602u64 => "CHECK_PUBKEY_INVALID",
+    21474836603u64 => "CHECK_PUBKEY_TOO_LARGE",
+    21474836604u64 => "CHECK_PUBKEY_TOO_SMALL",
+    21474836597u64 => "CHECK_P_NOT_PRIME",
+    21474836598u64 => "CHECK_P_NOT_SAFE_PRIME",
+    21474836599u64 => "CHECK_Q_NOT_PRIME",
+    21474836584u64 => "DECODE_ERROR",
+    21474836590u64 => "INVALID_PARAMETER_NAME",
+    21474836594u64 => "INVALID_PARAMETER_NID",
+    21474836582u64 => "INVALID_PUBKEY",
+    21474836592u64 => "KDF_PARAMETER_ERROR",
+    21474836588u64 => "KEYS_NOT_SET",
+    21474836605u64 => "MISSING_PUBKEY",
+    21474836583u64 => "MODULUS_TOO_LARGE",
+    21474836600u64 => "NOT_SUITABLE_GENERATOR",
+    21474836587u64 => "NO_PARAMETERS_SET",
+    21474836580u64 => "NO_PRIVATE_VALUE",
+    21474836585u64 => "PARAMETER_ENCODING_ERROR",
+    21474836591u64 => "PEER_KEY_ERROR",
+    21474836593u64 => "SHARED_INFO_ERROR",
+    21474836601u64 => "UNABLE_TO_CHECK_GENERATOR",
+    42949673062u64 => "BAD_Q_VALUE",
+    42949673068u64 => "BN_DECODE_ERROR",
+    42949673069u64 => "BN_ERROR",
+    42949673064u64 => "DECODE_ERROR",
+    42949673066u64 => "INVALID_DIGEST_TYPE",
+    42949673072u64 => "INVALID_PARAMETERS",
+    42949673061u64 => "MISSING_PARAMETERS",
+    42949673071u64 => "MISSING_PRIVATE_KEY",
+    42949673063u64 => "MODULUS_TOO_LARGE",
+    42949673067u64 => "NO_PARAMETERS_SET",
+    42949673065u64 => "PARAMETER_ENCODING_ERROR",
+    42949673073u64 => "Q_NOT_PRIME",
+    42949673070u64 => "SEED_LEN_SMALL",
+    158913790052u64 => "CTRL_FAILED",
+    158913790062u64 => "DSO_ALREADY_LOADED",
+    158913790065u64 => "EMPTY_FILE_STRUCTURE",
+    158913790066u64 => "FAILURE",
+    158913790053u64 => "FILENAME_TOO_BIG",
+    158913790054u64 => "FINISH_FAILED",
+    158913790067u64 => "INCORRECT_FILE_SYNTAX",
+    158913790055u64 => "LOAD_FAILED",
+    158913790061u64 => "NAME_TRANSLATION_FAILED",
+    158913790063u64 => "NO_FILENAME",
+    158913790056u64 => "NULL_HANDLE",
+    158913790064u64 => "SET_FILENAME_FAILED",
+    158913790057u64 => "STACK_ERROR",
+    158913790058u64 => "SYM_FAILURE",
+    158913790059u64 => "UNLOAD_FAILED",
+    158913790060u64 => "UNSUPPORTED",
+    68719476851u64 => "ASN1_ERROR",
+    68719476892u64 => "BAD_SIGNATURE",
+    68719476880u64 => "BIGNUM_OUT_OF_RANGE",
+    68719476836u64 => "BUFFER_TOO_SMALL",
+    68719476901u64 => "CANNOT_INVERT",
+    68719476882u64 => "COORDINATES_OUT_OF_RANGE",
+    68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH",
+    68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING",
+    68719476853u64 => "D2I_ECPKPARAMETERS_FAILURE",
+    68719476878u64 => "DECODE_ERROR",
+    68719476854u64 => "DISCRIMINANT_IS_ZERO",
+    68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE",
+    68719476879u64 => "FIELD_TOO_LARGE",
+    68719476883u64 => "GF2M_NOT_SUPPORTED",
+    68719476856u64 => "GROUP2PKPARAMETERS_FAILURE",
+    68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE",
+    68719476837u64 => "INCOMPATIBLE_OBJECTS",
+    68719476848u64 => "INVALID_ARGUMENT",
+    68719476846u64 => "INVALID_COMPRESSED_POINT",
+    68719476845u64 => "INVALID_COMPRESSION_BIT",
+    68719476877u64 => "INVALID_CURVE",
+    68719476887u64 => "INVALID_DIGEST",
+    68719476874u64 => "INVALID_DIGEST_TYPE",
+    68719476838u64 => "INVALID_ENCODING",
+    68719476839u64 => "INVALID_FIELD",
+    68719476840u64 => "INVALID_FORM",
+    68719476858u64 => "INVALID_GROUP_ORDER",
+    68719476852u64 => "INVALID_KEY",
+    68719476897u64 => "INVALID_OUTPUT_LENGTH",
+    68719476869u64 => "INVALID_PEER_KEY",
+    68719476868u64 => "INVALID_PENTANOMIAL_BASIS",
+    68719476859u64 => "INVALID_PRIVATE_KEY",
+    68719476873u64 => "INVALID_TRINOMIAL_BASIS",
+    68719476884u64 => "KDF_PARAMETER_ERROR",
+    68719476876u64 => "KEYS_NOT_SET",
+    68719476872u64 => "LADDER_POST_FAILURE",
+    68719476889u64 => "LADDER_PRE_FAILURE",
+    68719476898u64 => "LADDER_STEP_FAILURE",
+    68719476903u64 => "MISSING_OID",
+    68719476860u64 => "MISSING_PARAMETERS",
+    68719476861u64 => "MISSING_PRIVATE_KEY",
+    68719476893u64 => "NEED_NEW_SETUP_VALUES",
+    68719476871u64 => "NOT_A_NIST_PRIME",
+    68719476862u64 => "NOT_IMPLEMENTED",
+    68719476847u64 => "NOT_INITIALIZED",
+    68719476875u64 => "NO_PARAMETERS_SET",
+    68719476890u64 => "NO_PRIVATE_VALUE",
+    68719476888u64 => "OPERATION_NOT_SUPPORTED",
+    68719476870u64 => "PASSED_NULL_PARAMETER",
+    68719476885u64 => "PEER_KEY_ERROR",
+    68719476863u64 => "PKPARAMETERS2GROUP_FAILURE",
+    68719476891u64 => "POINT_ARITHMETIC_FAILURE",
+    68719476842u64 => "POINT_AT_INFINITY",
+    68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE",
+    68719476843u64 => "POINT_IS_NOT_ON_CURVE",
+    68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED",
+    68719476886u64 => "SHARED_INFO_ERROR",
+    68719476844u64 => "SLOT_FULL",
+    68719476849u64 => "UNDEFINED_GENERATOR",
+    68719476864u64 => "UNDEFINED_ORDER",
+    68719476900u64 => "UNKNOWN_COFACTOR",
+    68719476865u64 => "UNKNOWN_GROUP",
+    68719476850u64 => "UNKNOWN_ORDER",
+    68719476867u64 => "UNSUPPORTED_FIELD",
+    68719476881u64 => "WRONG_CURVE_PARAMETERS",
+    68719476866u64 => "WRONG_ORDER",
+    163208757348u64 => "ALREADY_LOADED",
+    163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER",
+    163208757382u64 => "CMD_NOT_EXECUTABLE",
+    163208757383u64 => "COMMAND_TAKES_INPUT",
+    163208757384u64 => "COMMAND_TAKES_NO_INPUT",
+    163208757351u64 => "CONFLICTING_ENGINE_ID",
+    163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED",
+    163208757352u64 => "DSO_FAILURE",
+    163208757380u64 => "DSO_NOT_FOUND",
+    163208757396u64 => "ENGINES_SECTION_ERROR",
+    163208757350u64 => "ENGINE_CONFIGURATION_ERROR",
+    163208757353u64 => "ENGINE_IS_NOT_IN_LIST",
+    163208757397u64 => "ENGINE_SECTION_ERROR",
+    163208757376u64 => "FAILED_LOADING_PRIVATE_KEY",
+    163208757377u64 => "FAILED_LOADING_PUBLIC_KEY",
+    163208757354u64 => "FINISH_FAILED",
+    163208757356u64 => "ID_OR_NAME_MISSING",
+    163208757357u64 => "INIT_FAILED",
+    163208757358u64 => "INTERNAL_LIST_ERROR",
+    163208757391u64 => "INVALID_ARGUMENT",
+    163208757385u64 => "INVALID_CMD_NAME",
+    163208757386u64 => "INVALID_CMD_NUMBER",
+    163208757399u64 => "INVALID_INIT_VALUE",
+    163208757398u64 => "INVALID_STRING",
+    163208757365u64 => "NOT_INITIALISED",
+    163208757360u64 => "NOT_LOADED",
+    163208757368u64 => "NO_CONTROL_FUNCTION",
+    163208757392u64 => "NO_INDEX",
+    163208757373u64 => "NO_LOAD_FUNCTION",
+    163208757378u64 => "NO_REFERENCE",
+    163208757364u64 => "NO_SUCH_ENGINE",
+    163208757394u64 => "UNIMPLEMENTED_CIPHER",
+    163208757395u64 => "UNIMPLEMENTED_DIGEST",
+    163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD",
+    163208757393u64 => "VERSION_INCOMPATIBILITY",
+    25769803919u64 => "AES_KEY_SETUP_FAILED",
+    25769803952u64 => "ARIA_KEY_SETUP_FAILED",
+    25769803876u64 => "BAD_DECRYPT",
+    25769803971u64 => "BAD_KEY_LENGTH",
+    25769803931u64 => "BUFFER_TOO_SMALL",
+    25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED",
+    25769803898u64 => "CIPHER_PARAMETER_ERROR",
+    25769803923u64 => "COMMAND_NOT_SUPPORTED",
+    25769803949u64 => "COPY_ERROR",
+    25769803908u64 => "CTRL_NOT_IMPLEMENTED",
+    25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED",
+    25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH",
+    25769803890u64 => "DECODE_ERROR",
+    25769803877u64 => "DIFFERENT_KEY_TYPES",
+    25769803929u64 => "DIFFERENT_PARAMETERS",
+    25769803941u64 => "ERROR_LOADING_SECTION",
+    25769803942u64 => "ERROR_SETTING_FIPS_MODE",
+    25769803950u64 => "EXPECTING_AN_HMAC_KEY",
+    25769803903u64 => "EXPECTING_AN_RSA_KEY",
+    25769803904u64 => "EXPECTING_A_DH_KEY",
+    25769803905u64 => "EXPECTING_A_DSA_KEY",
+    25769803918u64 => "EXPECTING_A_EC_KEY",
+    25769803940u64 => "EXPECTING_A_POLY1305_KEY",
+    25769803951u64 => "EXPECTING_A_SIPHASH_KEY",
+    25769803943u64 => "FIPS_MODE_NOT_SUPPORTED",
+    25769803958u64 => "GET_RAW_KEY_FAILED",
+    25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS",
+    25769803910u64 => "INITIALIZATION_ERROR",
+    25769803887u64 => "INPUT_NOT_INITIALIZED",
+    25769803928u64 => "INVALID_DIGEST",
+    25769803944u64 => "INVALID_FIPS_MODE",
+    25769803970u64 => "INVALID_IV_LENGTH",
+    25769803939u64 => "INVALID_KEY",
+    25769803906u64 => "INVALID_KEY_LENGTH",
+    25769803924u64 => "INVALID_OPERATION",
+    25769803896u64 => "KEYGEN_FAILURE",
+    25769803956u64 => "KEY_SETUP_FAILED",
+    25769803948u64 => "MEMORY_LIMIT_EXCEEDED",
+    25769803935u64 => "MESSAGE_DIGEST_IS_NULL",
+    25769803920u64 => "METHOD_NOT_SUPPORTED",
+    25769803879u64 => "MISSING_PARAMETERS",
+    25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH",
+    25769803907u64 => "NO_CIPHER_SET",
+    25769803934u64 => "NO_DEFAULT_DIGEST",
+    25769803915u64 => "NO_DIGEST_SET",
+    25769803930u64 => "NO_KEY_SET",
+    25769803925u64 => "NO_OPERATION_SET",
+    25769803953u64 => "ONLY_ONESHOT_SUPPORTED",
+    25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    25769803927u64 => "OPERATON_NOT_INITIALIZED",
+    25769803960u64 => "OUTPUT_WOULD_OVERFLOW",
+    25769803938u64 => "PARTIALLY_OVERLAPPING",
+    25769803957u64 => "PBKDF2_ERROR",
+    25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED",
+    25769803921u64 => "PRIVATE_KEY_DECODE_ERROR",
+    25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR",
+    25769803882u64 => "PUBLIC_KEY_NOT_RSA",
+    25769803936u64 => "UNKNOWN_CIPHER",
+    25769803937u64 => "UNKNOWN_DIGEST",
+    25769803945u64 => "UNKNOWN_OPTION",
+    25769803897u64 => "UNKNOWN_PBE_ALGORITHM",
+    25769803932u64 => "UNSUPPORTED_ALGORITHM",
+    25769803883u64 => "UNSUPPORTED_CIPHER",
+    25769803899u64 => "UNSUPPORTED_KEYLENGTH",
+    25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION",
+    25769803884u64 => "UNSUPPORTED_KEY_SIZE",
+    25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS",
+    25769803901u64 => "UNSUPPORTED_PRF",
+    25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM",
+    25769803902u64 => "UNSUPPORTED_SALT_TYPE",
+    25769803946u64 => "WRAP_MODE_NOT_ALLOWED",
+    25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH",
+    25769803959u64 => "XTS_DUPLICATED_KEYS",
+    223338299492u64 => "INVALID_DIGEST",
+    223338299501u64 => "MISSING_ITERATION_COUNT",
+    223338299496u64 => "MISSING_KEY",
+    223338299497u64 => "MISSING_MESSAGE_DIGEST",
+    223338299493u64 => "MISSING_PARAMETER",
+    223338299502u64 => "MISSING_PASS",
+    223338299503u64 => "MISSING_SALT",
+    223338299499u64 => "MISSING_SECRET",
+    223338299498u64 => "MISSING_SEED",
+    223338299495u64 => "UNKNOWN_PARAMETER_TYPE",
+    223338299500u64 => "VALUE_ERROR",
+    223338299494u64 => "VALUE_MISSING",
+    34359738470u64 => "OID_EXISTS",
+    34359738469u64 => "UNKNOWN_NID",
+    167503724645u64 => "CERTIFICATE_VERIFY_ERROR",
+    167503724646u64 => "DIGEST_ERR",
+    167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD",
+    167503724667u64 => "ERROR_IN_THISUPDATE_FIELD",
+    167503724665u64 => "ERROR_PARSING_URL",
+    167503724647u64 => "MISSING_OCSPSIGNING_USAGE",
+    167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE",
+    167503724648u64 => "NOT_BASIC_RESPONSE",
+    167503724649u64 => "NO_CERTIFICATES_IN_CHAIN",
+    167503724652u64 => "NO_RESPONSE_DATA",
+    167503724653u64 => "NO_REVOKED_TIME",
+    167503724674u64 => "NO_SIGNER_KEY",
+    167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    167503724672u64 => "REQUEST_NOT_SIGNED",
+    167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA",
+    167503724656u64 => "ROOT_CA_NOT_TRUSTED",
+    167503724658u64 => "SERVER_RESPONSE_ERROR",
+    167503724659u64 => "SERVER_RESPONSE_PARSE_ERROR",
+    167503724661u64 => "SIGNATURE_FAILURE",
+    167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    167503724669u64 => "STATUS_EXPIRED",
+    167503724670u64 => "STATUS_NOT_YET_VALID",
+    167503724671u64 => "STATUS_TOO_OLD",
+    167503724663u64 => "UNKNOWN_MESSAGE_DIGEST",
+    167503724664u64 => "UNKNOWN_NID",
+    167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE",
+    188978561131u64 => "AMBIGUOUS_CONTENT_TYPE",
+    188978561139u64 => "BAD_PASSWORD_READ",
+    188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC",
+    188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST",
+    188978561130u64 => "INVALID_SCHEME",
+    188978561136u64 => "IS_NOT_A",
+    188978561140u64 => "LOADER_INCOMPLETE",
+    188978561141u64 => "LOADING_STARTED",
+    188978561124u64 => "NOT_A_CERTIFICATE",
+    188978561125u64 => "NOT_A_CRL",
+    188978561126u64 => "NOT_A_KEY",
+    188978561127u64 => "NOT_A_NAME",
+    188978561128u64 => "NOT_PARAMETERS",
+    188978561138u64 => "PASSPHRASE_CALLBACK_ERROR",
+    188978561132u64 => "PATH_MUST_BE_ABSOLUTE",
+    188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES",
+    188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED",
+    188978561129u64 => "UNREGISTERED_SCHEME",
+    188978561134u64 => "UNSUPPORTED_CONTENT_TYPE",
+    188978561142u64 => "UNSUPPORTED_OPERATION",
+    188978561144u64 => "UNSUPPORTED_SEARCH_TYPE",
+    188978561135u64 => "URI_AUTHORITY_UNSUPPORTED",
+    38654705764u64 => "BAD_BASE64_DECODE",
+    38654705765u64 => "BAD_DECRYPT",
+    38654705766u64 => "BAD_END_LINE",
+    38654705767u64 => "BAD_IV_CHARS",
+    38654705780u64 => "BAD_MAGIC_NUMBER",
+    38654705768u64 => "BAD_PASSWORD_READ",
+    38654705781u64 => "BAD_VERSION_NUMBER",
+    38654705782u64 => "BIO_WRITE_FAILURE",
+    38654705791u64 => "CIPHER_IS_NULL",
+    38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY",
+    38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB",
+    38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB",
+    38654705792u64 => "HEADER_TOO_LONG",
+    38654705785u64 => "INCONSISTENT_HEADER",
+    38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR",
+    38654705787u64 => "KEYBLOB_TOO_SHORT",
+    38654705793u64 => "MISSING_DEK_IV",
+    38654705769u64 => "NOT_DEK_INFO",
+    38654705770u64 => "NOT_ENCRYPTED",
+    38654705771u64 => "NOT_PROC_TYPE",
+    38654705772u64 => "NO_START_LINE",
+    38654705773u64 => "PROBLEMS_GETTING_PASSWORD",
+    38654705788u64 => "PVK_DATA_TOO_SHORT",
+    38654705789u64 => "PVK_TOO_SHORT",
+    38654705775u64 => "READ_KEY",
+    38654705776u64 => "SHORT_HEADER",
+    38654705794u64 => "UNEXPECTED_DEK_IV",
+    38654705777u64 => "UNSUPPORTED_CIPHER",
+    38654705778u64 => "UNSUPPORTED_ENCRYPTION",
+    38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS",
+    38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    150323855460u64 => "CANT_PACK_STRUCTURE",
+    150323855481u64 => "CONTENT_TYPE_NOT_DATA",
+    150323855461u64 => "DECODE_ERROR",
+    150323855462u64 => "ENCODE_ERROR",
+    150323855463u64 => "ENCRYPT_ERROR",
+    150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE",
+    150323855464u64 => "INVALID_NULL_ARGUMENT",
+    150323855465u64 => "INVALID_NULL_PKCS12_POINTER",
+    150323855466u64 => "IV_GEN_ERROR",
+    150323855467u64 => "KEY_GEN_ERROR",
+    150323855468u64 => "MAC_ABSENT",
+    150323855469u64 => "MAC_GENERATION_ERROR",
+    150323855470u64 => "MAC_SETUP_ERROR",
+    150323855471u64 => "MAC_STRING_SET_ERROR",
+    150323855473u64 => "MAC_VERIFY_FAILURE",
+    150323855474u64 => "PARSE_ERROR",
+    150323855475u64 => "PKCS12_ALGOR_CIPHERINIT_ERROR",
+    150323855476u64 => "PKCS12_CIPHERFINAL_ERROR",
+    150323855477u64 => "PKCS12_PBE_CRYPT_ERROR",
+    150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    150323855479u64 => "UNSUPPORTED_PKCS12_MODE",
+    141733920885u64 => "CERTIFICATE_VERIFY_ERROR",
+    141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    141733920884u64 => "CIPHER_NOT_INITIALIZED",
+    141733920886u64 => "CONTENT_AND_DATA_PRESENT",
+    141733920920u64 => "CTRL_ERROR",
+    141733920887u64 => "DECRYPT_ERROR",
+    141733920869u64 => "DIGEST_FAILURE",
+    141733920917u64 => "ENCRYPTION_CTRL_FAILURE",
+    141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920888u64 => "ERROR_ADDING_RECIPIENT",
+    141733920889u64 => "ERROR_SETTING_CIPHER",
+    141733920911u64 => "INVALID_NULL_POINTER",
+    141733920923u64 => "INVALID_SIGNED_DATA_TYPE",
+    141733920890u64 => "NO_CONTENT",
+    141733920919u64 => "NO_DEFAULT_DIGEST",
+    141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND",
+    141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE",
+    141733920891u64 => "NO_SIGNATURES_ON_DATA",
+    141733920910u64 => "NO_SIGNERS",
+    141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE",
+    141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    141733920921u64 => "PKCS7_ADD_SIGNER_ERROR",
+    141733920913u64 => "PKCS7_DATASIGN",
+    141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    141733920873u64 => "SIGNATURE_FAILURE",
+    141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    141733920915u64 => "SIGNING_CTRL_FAILURE",
+    141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920897u64 => "SMIME_TEXT_ERROR",
+    141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE",
+    141733920875u64 => "UNABLE_TO_FIND_MEM_BIO",
+    141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST",
+    141733920877u64 => "UNKNOWN_DIGEST_TYPE",
+    141733920878u64 => "UNKNOWN_OPERATION",
+    141733920879u64 => "UNSUPPORTED_CIPHER_TYPE",
+    141733920880u64 => "UNSUPPORTED_CONTENT_TYPE",
+    141733920881u64 => "WRONG_CONTENT_TYPE",
+    141733920882u64 => "WRONG_PKCS7_TYPE",
+    154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG",
+    154618822759u64 => "ALREADY_INSTANTIATED",
+    154618822761u64 => "ARGUMENT_OUT_OF_RANGE",
+    154618822777u64 => "CANNOT_OPEN_FILE",
+    154618822785u64 => "DRBG_ALREADY_INITIALIZED",
+    154618822760u64 => "DRBG_NOT_INITIALISED",
+    154618822762u64 => "ENTROPY_INPUT_TOO_LONG",
+    154618822780u64 => "ENTROPY_OUT_OF_RANGE",
+    154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED",
+    154618822763u64 => "ERROR_INITIALISING_DRBG",
+    154618822764u64 => "ERROR_INSTANTIATING_DRBG",
+    154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT",
+    154618822766u64 => "ERROR_RETRIEVING_ENTROPY",
+    154618822767u64 => "ERROR_RETRIEVING_NONCE",
+    154618822782u64 => "FAILED_TO_CREATE_LOCK",
+    154618822757u64 => "FUNC_NOT_IMPLEMENTED",
+    154618822779u64 => "FWRITE_ERROR",
+    154618822768u64 => "GENERATE_ERROR",
+    154618822769u64 => "INTERNAL_ERROR",
+    154618822770u64 => "IN_ERROR_STATE",
+    154618822778u64 => "NOT_A_REGULAR_FILE",
+    154618822771u64 => "NOT_INSTANTIATED",
+    154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED",
+    154618822786u64 => "PARENT_LOCKING_NOT_ENABLED",
+    154618822787u64 => "PARENT_STRENGTH_TOO_WEAK",
+    154618822772u64 => "PERSONALISATION_STRING_TOO_LONG",
+    154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED",
+    154618822756u64 => "PRNG_NOT_SEEDED",
+    154618822781u64 => "RANDOM_POOL_OVERFLOW",
+    154618822790u64 => "RANDOM_POOL_UNDERFLOW",
+    154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG",
+    154618822774u64 => "RESEED_ERROR",
+    154618822775u64 => "SELFTEST_FAILURE",
+    154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED",
+    154618822792u64 => "TOO_MUCH_NONCE_REQUESTED",
+    154618822788u64 => "UNSUPPORTED_DRBG_FLAGS",
+    154618822776u64 => "UNSUPPORTED_DRBG_TYPE",
+    17179869284u64 => "ALGORITHM_MISMATCH",
+    17179869285u64 => "BAD_E_VALUE",
+    17179869286u64 => "BAD_FIXED_HEADER_DECRYPT",
+    17179869287u64 => "BAD_PAD_BYTE_COUNT",
+    17179869288u64 => "BAD_SIGNATURE",
+    17179869290u64 => "BLOCK_TYPE_IS_NOT_01",
+    17179869291u64 => "BLOCK_TYPE_IS_NOT_02",
+    17179869292u64 => "DATA_GREATER_THAN_MOD_LEN",
+    17179869293u64 => "DATA_TOO_LARGE",
+    17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE",
+    17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS",
+    17179869295u64 => "DATA_TOO_SMALL",
+    17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE",
+    17179869342u64 => "DIGEST_DOES_NOT_MATCH",
+    17179869329u64 => "DIGEST_NOT_ALLOWED",
+    17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY",
+    17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D",
+    17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D",
+    17179869307u64 => "D_E_NOT_CONGRUENT_TO_1",
+    17179869317u64 => "FIRST_OCTET_INVALID",
+    17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE",
+    17179869341u64 => "INVALID_DIGEST",
+    17179869327u64 => "INVALID_DIGEST_LENGTH",
+    17179869321u64 => "INVALID_HEADER",
+    17179869344u64 => "INVALID_LABEL",
+    17179869315u64 => "INVALID_MESSAGE_LENGTH",
+    17179869340u64 => "INVALID_MGF1_MD",
+    17179869351u64 => "INVALID_MULTI_PRIME_KEY",
+    17179869345u64 => "INVALID_OAEP_PARAMETERS",
+    17179869322u64 => "INVALID_PADDING",
+    17179869325u64 => "INVALID_PADDING_MODE",
+    17179869333u64 => "INVALID_PSS_PARAMETERS",
+    17179869330u64 => "INVALID_PSS_SALTLEN",
+    17179869334u64 => "INVALID_SALT_LENGTH",
+    17179869323u64 => "INVALID_TRAILER",
+    17179869326u64 => "INVALID_X931_DIGEST",
+    17179869310u64 => "IQMP_NOT_INVERSE_OF_Q",
+    17179869349u64 => "KEY_PRIME_NUM_INVALID",
+    17179869304u64 => "KEY_SIZE_TOO_SMALL",
+    17179869318u64 => "LAST_OCTET_INVALID",
+    17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED",
+    17179869363u64 => "MISSING_PRIVATE_KEY",
+    17179869289u64 => "MODULUS_TOO_LARGE",
+    17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R",
+    17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D",
+    17179869354u64 => "MP_R_NOT_PRIME",
+    17179869324u64 => "NO_PUBLIC_EXPONENT",
+    17179869297u64 => "NULL_BEFORE_BLOCK_MISSING",
+    17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES",
+    17179869311u64 => "N_DOES_NOT_EQUAL_P_Q",
+    17179869305u64 => "OAEP_DECODING_ERROR",
+    17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    17179869298u64 => "PADDING_CHECK_FAILED",
+    17179869343u64 => "PKCS_DECODING_ERROR",
+    17179869348u64 => "PSS_SALTLEN_TOO_SMALL",
+    17179869312u64 => "P_NOT_PRIME",
+    17179869313u64 => "Q_NOT_PRIME",
+    17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED",
+    17179869320u64 => "SLEN_CHECK_FAILED",
+    17179869319u64 => "SLEN_RECOVERY_FAILED",
+    17179869299u64 => "SSLV3_ROLLBACK_ATTACK",
+    17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    17179869301u64 => "UNKNOWN_ALGORITHM_TYPE",
+    17179869350u64 => "UNKNOWN_DIGEST",
+    17179869335u64 => "UNKNOWN_MASK_DIGEST",
+    17179869302u64 => "UNKNOWN_PADDING_TYPE",
+    17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE",
+    17179869347u64 => "UNSUPPORTED_LABEL_SOURCE",
+    17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM",
+    17179869338u64 => "UNSUPPORTED_MASK_PARAMETER",
+    17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE",
+    17179869331u64 => "VALUE_MISSING",
+    17179869303u64 => "WRONG_SIGNATURE_LENGTH",
+    227633266788u64 => "ASN1_ERROR",
+    227633266789u64 => "BAD_SIGNATURE",
+    227633266795u64 => "BUFFER_TOO_SMALL",
+    227633266798u64 => "DIST_ID_TOO_LARGE",
+    227633266800u64 => "ID_NOT_SET",
+    227633266799u64 => "ID_TOO_LARGE",
+    227633266796u64 => "INVALID_CURVE",
+    227633266790u64 => "INVALID_DIGEST",
+    227633266791u64 => "INVALID_DIGEST_TYPE",
+    227633266792u64 => "INVALID_ENCODING",
+    227633266793u64 => "INVALID_FIELD",
+    227633266797u64 => "NO_PARAMETERS_SET",
+    227633266794u64 => "USER_ID_TOO_LARGE",
+    85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY",
+    85899346020u64 => "APP_DATA_IN_HANDSHAKE",
+    85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT",
+    85899346063u64 => "AT_LEAST_TLS_1_0_NEEDED_IN_FIPS_MODE",
+    85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE",
+    85899346023u64 => "BAD_CHANGE_CIPHER_SPEC",
+    85899346106u64 => "BAD_CIPHER",
+    85899346310u64 => "BAD_DATA",
+    85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK",
+    85899346027u64 => "BAD_DECOMPRESSION",
+    85899346022u64 => "BAD_DH_VALUE",
+    85899346031u64 => "BAD_DIGEST_LENGTH",
+    85899346153u64 => "BAD_EARLY_DATA",
+    85899346224u64 => "BAD_ECC_CERT",
+    85899346226u64 => "BAD_ECPOINT",
+    85899346030u64 => "BAD_EXTENSION",
+    85899346252u64 => "BAD_HANDSHAKE_LENGTH",
+    85899346156u64 => "BAD_HANDSHAKE_STATE",
+    85899346025u64 => "BAD_HELLO_REQUEST",
+    85899346183u64 => "BAD_HRR_VERSION",
+    85899346028u64 => "BAD_KEY_SHARE",
+    85899346042u64 => "BAD_KEY_UPDATE",
+    85899346212u64 => "BAD_LEGACY_VERSION",
+    85899346191u64 => "BAD_LENGTH",
+    85899346160u64 => "BAD_PACKET",
+    85899346035u64 => "BAD_PACKET_LENGTH",
+    85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER",
+    85899346139u64 => "BAD_PSK",
+    85899346034u64 => "BAD_PSK_IDENTITY",
+    85899346363u64 => "BAD_RECORD_TYPE",
+    85899346039u64 => "BAD_RSA_ENCRYPT",
+    85899346043u64 => "BAD_SIGNATURE",
+    85899346267u64 => "BAD_SRP_A_LENGTH",
+    85899346291u64 => "BAD_SRP_PARAMETERS",
+    85899346272u64 => "BAD_SRTP_MKI_VALUE",
+    85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST",
+    85899346044u64 => "BAD_SSL_FILETYPE",
+    85899346304u64 => "BAD_VALUE",
+    85899346047u64 => "BAD_WRITE_RETRY",
+    85899346173u64 => "BINDER_DOES_NOT_VERIFY",
+    85899346048u64 => "BIO_NOT_SET",
+    85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG",
+    85899346050u64 => "BN_LIB",
+    85899346154u64 => "CALLBACK_FAILED",
+    85899346029u64 => "CANNOT_CHANGE_CIPHER",
+    85899346051u64 => "CA_DN_LENGTH_MISMATCH",
+    85899346317u64 => "CA_KEY_TOO_SMALL",
+    85899346318u64 => "CA_MD_TOO_WEAK",
+    85899346053u64 => "CCS_RECEIVED_EARLY",
+    85899346054u64 => "CERTIFICATE_VERIFY_FAILED",
+    85899346297u64 => "CERT_CB_ERROR",
+    85899346055u64 => "CERT_LENGTH_MISMATCH",
+    85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED",
+    85899346057u64 => "CIPHER_CODE_WRONG_LENGTH",
+    85899346058u64 => "CIPHER_OR_HASH_UNAVAILABLE",
+    85899346146u64 => "CLIENTHELLO_TLSEXT",
+    85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG",
+    85899346263u64 => "COMPRESSION_DISABLED",
+    85899346061u64 => "COMPRESSION_FAILURE",
+    85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE",
+    85899346062u64 => "COMPRESSION_LIBRARY_ERROR",
+    85899346064u64 => "CONNECTION_TYPE_NOT_SET",
+    85899346087u64 => "CONTEXT_NOT_DANE_ENABLED",
+    85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE",
+    85899346228u64 => "COOKIE_MISMATCH",
+    85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED",
+    85899346092u64 => "DANE_ALREADY_ENABLED",
+    85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL",
+    85899346095u64 => "DANE_NOT_ENABLED",
+    85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE",
+    85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE",
+    85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH",
+    85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH",
+    85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE",
+    85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY",
+    85899346122u64 => "DANE_TLSA_BAD_SELECTOR",
+    85899346123u64 => "DANE_TLSA_NULL_DATA",
+    85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED",
+    85899346066u64 => "DATA_LENGTH_TOO_LONG",
+    85899346067u64 => "DECRYPTION_FAILED",
+    85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC",
+    85899346314u64 => "DH_KEY_TOO_SMALL",
+    85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG",
+    85899346069u64 => "DIGEST_CHECK_FAILED",
+    85899346254u64 => "DTLS_MESSAGE_TOO_BIG",
+    85899346229u64 => "DUPLICATE_COMPRESSION_ID",
+    85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING",
+    85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE",
+    85899346319u64 => "EE_KEY_TOO_SMALL",
+    85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST",
+    85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG",
+    85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST",
+    85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN",
+    85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE",
+    85899346072u64 => "EXCESSIVE_MESSAGE_SIZE",
+    85899346199u64 => "EXTENSION_NOT_RECEIVED",
+    85899346073u64 => "EXTRA_DATA_IN_MESSAGE",
+    85899346083u64 => "EXT_LENGTH_MISMATCH",
+    85899346325u64 => "FAILED_TO_INIT_ASYNC",
+    85899346321u64 => "FRAGMENTED_CLIENT_HELLO",
+    85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS",
+    85899346075u64 => "HTTPS_PROXY_REQUEST",
+    85899346076u64 => "HTTP_REQUEST",
+    85899346082u64 => "ILLEGAL_POINT_COMPRESSION",
+    85899346300u64 => "ILLEGAL_SUITEB_DIGEST",
+    85899346293u64 => "INAPPROPRIATE_FALLBACK",
+    85899346260u64 => "INCONSISTENT_COMPRESSION",
+    85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN",
+    85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI",
+    85899346024u64 => "INCONSISTENT_EXTMS",
+    85899346161u64 => "INSUFFICIENT_SECURITY",
+    85899346125u64 => "INVALID_ALERT",
+    85899346180u64 => "INVALID_CCS_MESSAGE",
+    85899346158u64 => "INVALID_CERTIFICATE_OR_ALG",
+    85899346200u64 => "INVALID_COMMAND",
+    85899346261u64 => "INVALID_COMPRESSION_ALGORITHM",
+    85899346203u64 => "INVALID_CONFIG",
+    85899346033u64 => "INVALID_CONFIGURATION_NAME",
+    85899346202u64 => "INVALID_CONTEXT",
+    85899346132u64 => "INVALID_CT_VALIDATION_TYPE",
+    85899346040u64 => "INVALID_KEY_UPDATE_TYPE",
+    85899346094u64 => "INVALID_MAX_EARLY_DATA",
+    85899346305u64 => "INVALID_NULL_CMD_NAME",
+    85899346322u64 => "INVALID_SEQUENCE_NUMBER",
+    85899346308u64 => "INVALID_SERVERINFO_DATA",
+    85899346919u64 => "INVALID_SESSION_ID",
+    85899346277u64 => "INVALID_SRP_USERNAME",
+    85899346248u64 => "INVALID_STATUS_RESPONSE",
+    85899346245u64 => "INVALID_TICKET_KEYS_LENGTH",
+    85899346079u64 => "LENGTH_MISMATCH",
+    85899346324u64 => "LENGTH_TOO_LONG",
+    85899346080u64 => "LENGTH_TOO_SHORT",
+    85899346194u64 => "LIBRARY_BUG",
+    85899346081u64 => "LIBRARY_HAS_NO_CIPHERS",
+    85899346085u64 => "MISSING_DSA_SIGNING_CERT",
+    85899346301u64 => "MISSING_ECDSA_SIGNING_CERT",
+    85899346176u64 => "MISSING_FATAL",
+    85899346210u64 => "MISSING_PARAMETERS",
+    85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION",
+    85899346088u64 => "MISSING_RSA_CERTIFICATE",
+    85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT",
+    85899346090u64 => "MISSING_RSA_SIGNING_CERT",
+    85899346032u64 => "MISSING_SIGALGS_EXTENSION",
+    85899346141u64 => "MISSING_SIGNING_CERT",
+    85899346278u64 => "MISSING_SRP_PARAM",
+    85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION",
+    85899346091u64 => "MISSING_TMP_DH_KEY",
+    85899346231u64 => "MISSING_TMP_ECDH_KEY",
+    85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA",
+    85899346102u64 => "NOT_ON_RECORD_BOUNDARY",
+    85899346209u64 => "NOT_REPLACING_CERTIFICATE",
+    85899346204u64 => "NOT_SERVER",
+    85899346155u64 => "NO_APPLICATION_PROTOCOL",
+    85899346096u64 => "NO_CERTIFICATES_RETURNED",
+    85899346097u64 => "NO_CERTIFICATE_ASSIGNED",
+    85899346099u64 => "NO_CERTIFICATE_SET",
+    85899346134u64 => "NO_CHANGE_FOLLOWING_HRR",
+    85899346101u64 => "NO_CIPHERS_AVAILABLE",
+    85899346103u64 => "NO_CIPHERS_SPECIFIED",
+    85899346105u64 => "NO_CIPHER_MATCH",
+    85899346251u64 => "NO_CLIENT_CERT_METHOD",
+    85899346107u64 => "NO_COMPRESSION_SPECIFIED",
+    85899346207u64 => "NO_COOKIE_CALLBACK_SET",
+    85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER",
+    85899346108u64 => "NO_METHOD_SPECIFIED",
+    85899346309u64 => "NO_PEM_EXTENSIONS",
+    85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED",
+    85899346111u64 => "NO_PROTOCOLS_AVAILABLE",
+    85899346259u64 => "NO_RENEGOTIATION",
+    85899346244u64 => "NO_REQUIRED_DIGEST",
+    85899346113u64 => "NO_SHARED_CIPHER",
+    85899346330u64 => "NO_SHARED_GROUPS",
+    85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS",
+    85899346279u64 => "NO_SRTP_PROFILES",
+    85899346021u64 => "NO_SUITABLE_KEY_SHARE",
+    85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM",
+    85899346136u64 => "NO_VALID_SCTS",
+    85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK",
+    85899346115u64 => "NULL_SSL_CTX",
+    85899346116u64 => "NULL_SSL_METHOD_PASSED",
+    85899346214u64 => "OCSP_CALLBACK_FAILURE",
+    85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED",
+    85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED",
+    85899346157u64 => "OVERFLOW_ERROR",
+    85899346118u64 => "PACKET_LENGTH_TOO_LONG",
+    85899346147u64 => "PARSE_TLSEXT",
+    85899346190u64 => "PATH_TOO_LONG",
+    85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE",
+    85899346311u64 => "PEM_NAME_BAD_PREFIX",
+    85899346312u64 => "PEM_NAME_TOO_SHORT",
+    85899346326u64 => "PIPELINE_FAILURE",
+    85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR",
+    85899346208u64 => "PRIVATE_KEY_MISMATCH",
+    85899346127u64 => "PROTOCOL_IS_SHUTDOWN",
+    85899346143u64 => "PSK_IDENTITY_NOT_FOUND",
+    85899346144u64 => "PSK_NO_CLIENT_CB",
+    85899346145u64 => "PSK_NO_SERVER_CB",
+    85899346131u64 => "READ_BIO_NOT_SET",
+    85899346232u64 => "READ_TIMEOUT_EXPIRED",
+    85899346133u64 => "RECORD_LENGTH_MISMATCH",
+    85899346218u64 => "RECORD_TOO_SMALL",
+    85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG",
+    85899346256u64 => "RENEGOTIATION_ENCODING_ERR",
+    85899346257u64 => "RENEGOTIATION_MISMATCH",
+    85899346205u64 => "REQUEST_PENDING",
+    85899346206u64 => "REQUEST_SENT",
+    85899346135u64 => "REQUIRED_CIPHER_MISSING",
+    85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING",
+    85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING",
+    85899346128u64 => "SCT_VERIFICATION_FAILED",
+    85899346195u64 => "SERVERHELLO_TLSEXT",
+    85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED",
+    85899346327u64 => "SHUTDOWN_WHILE_IN_INIT",
+    85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR",
+    85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE",
+    85899346281u64 => "SRP_A_CALC",
+    85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES",
+    85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG",
+    85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE",
+    85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH",
+    85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME",
+    85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE",
+    85899346220u64 => "SSL3_SESSION_ID_TOO_LONG",
+    85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE",
+    85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC",
+    85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED",
+    85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED",
+    85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN",
+    85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE",
+    85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE",
+    85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER",
+    85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE",
+    85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE",
+    85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE",
+    85899346037u64 => "SSL_COMMAND_SECTION_EMPTY",
+    85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION",
+    85899346149u64 => "SSL_HANDSHAKE_FAILURE",
+    85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS",
+    85899346292u64 => "SSL_NEGATIVE_LENGTH",
+    85899346046u64 => "SSL_SECTION_EMPTY",
+    85899346056u64 => "SSL_SECTION_NOT_FOUND",
+    85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED",
+    85899346222u64 => "SSL_SESSION_ID_CONFLICT",
+    85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG",
+    85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH",
+    85899346328u64 => "SSL_SESSION_ID_TOO_LONG",
+    85899346130u64 => "SSL_SESSION_VERSION_MISMATCH",
+    85899346041u64 => "STILL_IN_INIT",
+    85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED",
+    85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION",
+    85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED",
+    85899346970u64 => "TLSV1_ALERT_DECODE_ERROR",
+    85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED",
+    85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR",
+    85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION",
+    85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK",
+    85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY",
+    85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR",
+    85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION",
+    85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION",
+    85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW",
+    85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA",
+    85899347010u64 => "TLSV1_ALERT_USER_CANCELLED",
+    85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE",
+    85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE",
+    85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE",
+    85899347032u64 => "TLSV1_UNRECOGNIZED_NAME",
+    85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION",
+    85899346285u64 => "TLS_HEARTBEAT_PEER_DOESNT_ACCEPT",
+    85899346286u64 => "TLS_HEARTBEAT_PENDING",
+    85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL",
+    85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST",
+    85899346052u64 => "TOO_MANY_KEY_UPDATES",
+    85899346329u64 => "TOO_MANY_WARN_ALERTS",
+    85899346084u64 => "TOO_MUCH_EARLY_DATA",
+    85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS",
+    85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS",
+    85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES",
+    85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES",
+    85899346182u64 => "UNEXPECTED_CCS_MESSAGE",
+    85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA",
+    85899346164u64 => "UNEXPECTED_MESSAGE",
+    85899346165u64 => "UNEXPECTED_RECORD",
+    85899346196u64 => "UNINITIALIZED",
+    85899346166u64 => "UNKNOWN_ALERT_TYPE",
+    85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE",
+    85899346168u64 => "UNKNOWN_CIPHER_RETURNED",
+    85899346169u64 => "UNKNOWN_CIPHER_TYPE",
+    85899346306u64 => "UNKNOWN_CMD_NAME",
+    85899346059u64 => "UNKNOWN_COMMAND",
+    85899346288u64 => "UNKNOWN_DIGEST",
+    85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE",
+    85899346171u64 => "UNKNOWN_PKEY_TYPE",
+    85899346172u64 => "UNKNOWN_PROTOCOL",
+    85899346174u64 => "UNKNOWN_SSL_VERSION",
+    85899346175u64 => "UNKNOWN_STATE",
+    85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED",
+    85899346137u64 => "UNSOLICITED_EXTENSION",
+    85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE",
+    85899346178u64 => "UNSUPPORTED_PROTOCOL",
+    85899346179u64 => "UNSUPPORTED_SSL_VERSION",
+    85899346249u64 => "UNSUPPORTED_STATUS_TYPE",
+    85899346289u64 => "USE_SRTP_NOT_NEGOTIATED",
+    85899346086u64 => "VERSION_TOO_HIGH",
+    85899346316u64 => "VERSION_TOO_LOW",
+    85899346303u64 => "WRONG_CERTIFICATE_TYPE",
+    85899346181u64 => "WRONG_CIPHER_RETURNED",
+    85899346298u64 => "WRONG_CURVE",
+    85899346184u64 => "WRONG_SIGNATURE_LENGTH",
+    85899346185u64 => "WRONG_SIGNATURE_SIZE",
+    85899346290u64 => "WRONG_SIGNATURE_TYPE",
+    85899346186u64 => "WRONG_SSL_VERSION",
+    85899346187u64 => "WRONG_VERSION_NUMBER",
+    85899346188u64 => "X509_LIB",
+    85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS",
+    201863463044u64 => "BAD_PKCS7_TYPE",
+    201863463045u64 => "BAD_TYPE",
+    201863463049u64 => "CANNOT_LOAD_CERT",
+    201863463050u64 => "CANNOT_LOAD_KEY",
+    201863463012u64 => "CERTIFICATE_VERIFY_ERROR",
+    201863463039u64 => "COULD_NOT_SET_ENGINE",
+    201863463027u64 => "COULD_NOT_SET_TIME",
+    201863463046u64 => "DETACHED_CONTENT",
+    201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR",
+    201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR",
+    201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR",
+    201863463014u64 => "INVALID_NULL_POINTER",
+    201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE",
+    201863463015u64 => "MESSAGE_IMPRINT_MISMATCH",
+    201863463016u64 => "NONCE_MISMATCH",
+    201863463017u64 => "NONCE_NOT_RETURNED",
+    201863463018u64 => "NO_CONTENT",
+    201863463019u64 => "NO_TIME_STAMP_TOKEN",
+    201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR",
+    201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED",
+    201863463020u64 => "POLICY_MISMATCH",
+    201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    201863463033u64 => "RESPONSE_SETUP_ERROR",
+    201863463021u64 => "SIGNATURE_FAILURE",
+    201863463022u64 => "THERE_MUST_BE_ONE_SIGNER",
+    201863463034u64 => "TIME_SYSCALL_ERROR",
+    201863463042u64 => "TOKEN_NOT_PRESENT",
+    201863463043u64 => "TOKEN_PRESENT",
+    201863463023u64 => "TSA_NAME_MISMATCH",
+    201863463024u64 => "TSA_UNTRUSTED",
+    201863463035u64 => "TST_INFO_SETUP_ERROR",
+    201863463036u64 => "TS_DATASIGN",
+    201863463037u64 => "UNACCEPTABLE_POLICY",
+    201863463038u64 => "UNSUPPORTED_MD_ALGORITHM",
+    201863463025u64 => "UNSUPPORTED_VERSION",
+    201863463047u64 => "VAR_BAD_VALUE",
+    201863463048u64 => "VAR_LOOKUP_FAILURE",
+    201863463026u64 => "WRONG_CONTENT_TYPE",
+    171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS",
+    171798691942u64 => "INDEX_TOO_LARGE",
+    171798691943u64 => "INDEX_TOO_SMALL",
+    171798691945u64 => "NO_RESULT_BUFFER",
+    171798691947u64 => "PROCESSING_ERROR",
+    171798691940u64 => "RESULT_TOO_LARGE",
+    171798691941u64 => "RESULT_TOO_SMALL",
+    171798691949u64 => "SYSASSIGN_ERROR",
+    171798691950u64 => "SYSDASSGN_ERROR",
+    171798691951u64 => "SYSQIOW_ERROR",
+    171798691946u64 => "UNKNOWN_CONTROL_COMMAND",
+    171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE",
+    171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED",
+    146028888182u64 => "BAD_IP_ADDRESS",
+    146028888183u64 => "BAD_OBJECT",
+    146028888164u64 => "BN_DEC2BN_ERROR",
+    146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR",
+    146028888213u64 => "DIRNAME_ERROR",
+    146028888224u64 => "DISTPOINT_ALREADY_SET",
+    146028888197u64 => "DUPLICATE_ZONE_ID",
+    146028888195u64 => "ERROR_CONVERTING_ZONE",
+    146028888208u64 => "ERROR_CREATING_EXTENSION",
+    146028888192u64 => "ERROR_IN_EXTENSION",
+    146028888201u64 => "EXPECTED_A_SECTION_NAME",
+    146028888209u64 => "EXTENSION_EXISTS",
+    146028888179u64 => "EXTENSION_NAME_ERROR",
+    146028888166u64 => "EXTENSION_NOT_FOUND",
+    146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED",
+    146028888180u64 => "EXTENSION_VALUE_ERROR",
+    146028888215u64 => "ILLEGAL_EMPTY_EXTENSION",
+    146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG",
+    146028888226u64 => "INVALID_ASNUMBER",
+    146028888227u64 => "INVALID_ASRANGE",
+    146028888168u64 => "INVALID_BOOLEAN_STRING",
+    146028888169u64 => "INVALID_EXTENSION_STRING",
+    146028888229u64 => "INVALID_INHERITANCE",
+    146028888230u64 => "INVALID_IPADDRESS",
+    146028888225u64 => "INVALID_MULTIPLE_RDNS",
+    146028888170u64 => "INVALID_NAME",
+    146028888171u64 => "INVALID_NULL_ARGUMENT",
+    146028888172u64 => "INVALID_NULL_NAME",
+    146028888173u64 => "INVALID_NULL_VALUE",
+    146028888204u64 => "INVALID_NUMBER",
+    146028888205u64 => "INVALID_NUMBERS",
+    146028888174u64 => "INVALID_OBJECT_IDENTIFIER",
+    146028888202u64 => "INVALID_OPTION",
+    146028888198u64 => "INVALID_POLICY_IDENTIFIER",
+    146028888217u64 => "INVALID_PROXY_POLICY_SETTING",
+    146028888210u64 => "INVALID_PURPOSE",
+    146028888228u64 => "INVALID_SAFI",
+    146028888199u64 => "INVALID_SECTION",
+    146028888207u64 => "INVALID_SYNTAX",
+    146028888190u64 => "ISSUER_DECODE_ERROR",
+    146028888188u64 => "MISSING_VALUE",
+    146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS",
+    146028888200u64 => "NO_CONFIG_DATABASE",
+    146028888185u64 => "NO_ISSUER_CERTIFICATE",
+    146028888191u64 => "NO_ISSUER_DETAILS",
+    146028888203u64 => "NO_POLICY_IDENTIFIER",
+    146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED",
+    146028888178u64 => "NO_PUBLIC_KEY",
+    146028888189u64 => "NO_SUBJECT_DETAILS",
+    146028888212u64 => "OPERATION_NOT_DEFINED",
+    146028888211u64 => "OTHERNAME_ERROR",
+    146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED",
+    146028888220u64 => "POLICY_PATH_LENGTH",
+    146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED",
+    146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY",
+    146028888214u64 => "SECTION_NOT_FOUND",
+    146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS",
+    146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID",
+    146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT",
+    146028888193u64 => "UNKNOWN_EXTENSION",
+    146028888194u64 => "UNKNOWN_EXTENSION_NAME",
+    146028888184u64 => "UNKNOWN_OPTION",
+    146028888181u64 => "UNSUPPORTED_OPTION",
+    146028888231u64 => "UNSUPPORTED_TYPE",
+    146028888196u64 => "USER_TOO_LONG",
+    47244640366u64 => "AKID_MISMATCH",
+    47244640389u64 => "BAD_SELECTOR",
+    47244640356u64 => "BAD_X509_FILETYPE",
+    47244640374u64 => "BASE64_DECODE_ERROR",
+    47244640370u64 => "CANT_CHECK_DH_KEY",
+    47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE",
+    47244640383u64 => "CRL_ALREADY_DELTA",
+    47244640387u64 => "CRL_VERIFY_FAILURE",
+    47244640384u64 => "IDP_MISMATCH",
+    47244640394u64 => "INVALID_ATTRIBUTES",
+    47244640369u64 => "INVALID_DIRECTORY",
+    47244640375u64 => "INVALID_FIELD_NAME",
+    47244640379u64 => "INVALID_TRUST",
+    47244640385u64 => "ISSUER_MISMATCH",
+    47244640371u64 => "KEY_TYPE_MISMATCH",
+    47244640372u64 => "KEY_VALUES_MISMATCH",
+    47244640359u64 => "LOADING_CERT_DIR",
+    47244640360u64 => "LOADING_DEFAULTS",
+    47244640380u64 => "METHOD_NOT_SUPPORTED",
+    47244640390u64 => "NAME_TOO_LONG",
+    47244640388u64 => "NEWER_CRL_NOT_NEWER",
+    47244640391u64 => "NO_CERTIFICATE_FOUND",
+    47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND",
+    47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY",
+    47244640393u64 => "NO_CRL_FOUND",
+    47244640386u64 => "NO_CRL_NUMBER",
+    47244640381u64 => "PUBLIC_KEY_DECODE_ERROR",
+    47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR",
+    47244640362u64 => "SHOULD_RETRY",
+    47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN",
+    47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY",
+    47244640373u64 => "UNKNOWN_KEY_TYPE",
+    47244640365u64 => "UNKNOWN_NID",
+    47244640377u64 => "UNKNOWN_PURPOSE_ID",
+    47244640376u64 => "UNKNOWN_TRUST_ID",
+    47244640367u64 => "UNSUPPORTED_ALGORITHM",
+    47244640368u64 => "WRONG_LOOKUP_TYPE",
+    47244640378u64 => "WRONG_TYPE",
+};
+
+/// Helper function to create encoded key from (lib, reason) pair
+#[inline]
+pub fn encode_error_key(lib: i32, reason: i32) -> u64 {
+    ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF)
+}
diff --git a/crates/stdlib/src/openssl/ssl_data_300.rs b/crates/stdlib/src/openssl/ssl_data_300.rs
new file mode 100644
index 0000000000..0f657eb1b0
--- /dev/null
+++ b/crates/stdlib/src/openssl/ssl_data_300.rs
@@ -0,0 +1,1759 @@
+// File generated by tools/make_ssl_data_rs.py
+// Generated on 2025-10-29T07:17:23.737586+00:00
+// Source: OpenSSL from /tmp/openssl-3.0
+// spell-checker: disable
+
+use phf::phf_map;
+
+// Maps lib_code -> library name
+// Example: 20 -> "SSL"
+pub static LIBRARY_CODES: phf::Map<u32, &'static str> = phf_map! {
+    0u32 => "MASK",
+    1u32 => "NONE",
+    2u32 => "SYS",
+    3u32 => "BN",
+    4u32 => "RSA",
+    5u32 => "DH",
+    6u32 => "EVP",
+    7u32 => "BUF",
+    8u32 => "OBJ",
+    9u32 => "PEM",
+    10u32 => "DSA",
+    11u32 => "X509",
+    12u32 => "METH",
+    13u32 => "ASN1",
+    14u32 => "CONF",
+    15u32 => "CRYPTO",
+    16u32 => "EC",
+    20u32 => "SSL",
+    21u32 => "SSL23",
+    22u32 => "SSL2",
+    23u32 => "SSL3",
+    30u32 => "RSAREF",
+    31u32 => "PROXY",
+    32u32 => "BIO",
+    33u32 => "PKCS7",
+    34u32 => "X509V3",
+    35u32 => "PKCS12",
+    36u32 => "RAND",
+    37u32 => "DSO",
+    38u32 => "ENGINE",
+    39u32 => "OCSP",
+    40u32 => "UI",
+    41u32 => "COMP",
+    42u32 => "ECDSA",
+    43u32 => "ECDH",
+    44u32 => "OSSL_STORE",
+    45u32 => "FIPS",
+    46u32 => "CMS",
+    47u32 => "TS",
+    48u32 => "HMAC",
+    49u32 => "JPAKE",
+    50u32 => "CT",
+    51u32 => "ASYNC",
+    52u32 => "KDF",
+    53u32 => "SM2",
+    54u32 => "ESS",
+    55u32 => "PROP",
+    56u32 => "CRMF",
+    57u32 => "PROV",
+    58u32 => "CMP",
+    59u32 => "OSSL_ENCODER",
+    60u32 => "OSSL_DECODER",
+    61u32 => "HTTP",
+    128u32 => "USER",
+};
+
+// Maps encoded (lib, reason) -> error mnemonic
+// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED"
+// Key encoding: (lib << 32) | reason
+pub static ERROR_CODES: phf::Map<u64, &'static str> = phf_map! {
+    55834575019u64 => "ADDING_OBJECT",
+    55834575051u64 => "ASN1_PARSE_ERROR",
+    55834575052u64 => "ASN1_SIG_PARSE_ERROR",
+    55834574948u64 => "AUX_ERROR",
+    55834574950u64 => "BAD_OBJECT_HEADER",
+    55834575078u64 => "BAD_TEMPLATE",
+    55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH",
+    55834574953u64 => "BN_LIB",
+    55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH",
+    55834574955u64 => "BUFFER_TOO_SMALL",
+    55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    55834575065u64 => "CONTEXT_NOT_INITIALISED",
+    55834574957u64 => "DATA_IS_WRONG",
+    55834574958u64 => "DECODE_ERROR",
+    55834575022u64 => "DEPTH_EXCEEDED",
+    55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED",
+    55834574960u64 => "ENCODE_ERROR",
+    55834575021u64 => "ERROR_GETTING_TIME",
+    55834575020u64 => "ERROR_LOADING_SECTION",
+    55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS",
+    55834574963u64 => "EXPECTING_AN_INTEGER",
+    55834574964u64 => "EXPECTING_AN_OBJECT",
+    55834574967u64 => "EXPLICIT_LENGTH_MISMATCH",
+    55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED",
+    55834574969u64 => "FIELD_MISSING",
+    55834574970u64 => "FIRST_NUM_TOO_LARGE",
+    55834574971u64 => "HEADER_TOO_LONG",
+    55834575023u64 => "ILLEGAL_BITSTRING_FORMAT",
+    55834575024u64 => "ILLEGAL_BOOLEAN",
+    55834574972u64 => "ILLEGAL_CHARACTERS",
+    55834575025u64 => "ILLEGAL_FORMAT",
+    55834575026u64 => "ILLEGAL_HEX",
+    55834575027u64 => "ILLEGAL_IMPLICIT_TAG",
+    55834575028u64 => "ILLEGAL_INTEGER",
+    55834575074u64 => "ILLEGAL_NEGATIVE_VALUE",
+    55834575029u64 => "ILLEGAL_NESTED_TAGGING",
+    55834574973u64 => "ILLEGAL_NULL",
+    55834575030u64 => "ILLEGAL_NULL_VALUE",
+    55834575031u64 => "ILLEGAL_OBJECT",
+    55834574974u64 => "ILLEGAL_OPTIONAL_ANY",
+    55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE",
+    55834575069u64 => "ILLEGAL_PADDING",
+    55834574975u64 => "ILLEGAL_TAGGED_ANY",
+    55834575032u64 => "ILLEGAL_TIME_VALUE",
+    55834575070u64 => "ILLEGAL_ZERO_CONTENT",
+    55834575033u64 => "INTEGER_NOT_ASCII_FORMAT",
+    55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG",
+    55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT",
+    55834574977u64 => "INVALID_BMPSTRING_LENGTH",
+    55834574978u64 => "INVALID_DIGIT",
+    55834575053u64 => "INVALID_MIME_TYPE",
+    55834575034u64 => "INVALID_MODIFIER",
+    55834575035u64 => "INVALID_NUMBER",
+    55834575064u64 => "INVALID_OBJECT_ENCODING",
+    55834575075u64 => "INVALID_SCRYPT_PARAMETERS",
+    55834574979u64 => "INVALID_SEPARATOR",
+    55834575066u64 => "INVALID_STRING_TABLE_VALUE",
+    55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH",
+    55834574982u64 => "INVALID_UTF8STRING",
+    55834575067u64 => "INVALID_VALUE",
+    55834575079u64 => "LENGTH_TOO_LONG",
+    55834575036u64 => "LIST_ERROR",
+    55834575054u64 => "MIME_NO_CONTENT_TYPE",
+    55834575055u64 => "MIME_PARSE_ERROR",
+    55834575056u64 => "MIME_SIG_PARSE_ERROR",
+    55834574985u64 => "MISSING_EOC",
+    55834574986u64 => "MISSING_SECOND_NUMBER",
+    55834575037u64 => "MISSING_VALUE",
+    55834574987u64 => "MSTRING_NOT_UNIVERSAL",
+    55834574988u64 => "MSTRING_WRONG_TAG",
+    55834575045u64 => "NESTED_ASN1_STRING",
+    55834575049u64 => "NESTED_TOO_DEEP",
+    55834574989u64 => "NON_HEX_CHARACTERS",
+    55834575038u64 => "NOT_ASCII_FORMAT",
+    55834574990u64 => "NOT_ENOUGH_DATA",
+    55834575057u64 => "NO_CONTENT_TYPE",
+    55834574991u64 => "NO_MATCHING_CHOICE_TYPE",
+    55834575058u64 => "NO_MULTIPART_BODY_FAILURE",
+    55834575059u64 => "NO_MULTIPART_BOUNDARY",
+    55834575060u64 => "NO_SIG_CONTENT_TYPE",
+    55834574992u64 => "NULL_IS_WRONG_LENGTH",
+    55834575039u64 => "OBJECT_NOT_ASCII_FORMAT",
+    55834574993u64 => "ODD_NUMBER_OF_CHARS",
+    55834574995u64 => "SECOND_NUMBER_TOO_LARGE",
+    55834574996u64 => "SEQUENCE_LENGTH_MISMATCH",
+    55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED",
+    55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG",
+    55834574998u64 => "SHORT_LINE",
+    55834575061u64 => "SIG_INVALID_MIME_TYPE",
+    55834575050u64 => "STREAMING_NOT_SUPPORTED",
+    55834574999u64 => "STRING_TOO_LONG",
+    55834575000u64 => "STRING_TOO_SHORT",
+    55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    55834575041u64 => "TIME_NOT_ASCII_FORMAT",
+    55834575071u64 => "TOO_LARGE",
+    55834575003u64 => "TOO_LONG",
+    55834575072u64 => "TOO_SMALL",
+    55834575004u64 => "TYPE_NOT_CONSTRUCTED",
+    55834575043u64 => "TYPE_NOT_PRIMITIVE",
+    55834575007u64 => "UNEXPECTED_EOC",
+    55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH",
+    55834575077u64 => "UNKNOWN_DIGEST",
+    55834575008u64 => "UNKNOWN_FORMAT",
+    55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM",
+    55834575010u64 => "UNKNOWN_OBJECT_TYPE",
+    55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE",
+    55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM",
+    55834575042u64 => "UNKNOWN_TAG",
+    55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE",
+    55834575076u64 => "UNSUPPORTED_CIPHER",
+    55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    55834575044u64 => "UNSUPPORTED_TYPE",
+    55834575073u64 => "WRONG_INTEGER_TYPE",
+    55834575048u64 => "WRONG_PUBLIC_KEY_TYPE",
+    55834575016u64 => "WRONG_TAG",
+    219043332197u64 => "FAILED_TO_SET_POOL",
+    219043332198u64 => "FAILED_TO_SWAP_CONTEXT",
+    219043332201u64 => "INIT_FAILED",
+    219043332199u64 => "INVALID_POOL_SIZE",
+    137438953572u64 => "ACCEPT_ERROR",
+    137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET",
+    137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE",
+    137438953573u64 => "BAD_FOPEN_MODE",
+    137438953596u64 => "BROKEN_PIPE",
+    137438953575u64 => "CONNECT_ERROR",
+    137438953619u64 => "CONNECT_TIMEOUT",
+    137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET",
+    137438953604u64 => "GETSOCKNAME_ERROR",
+    137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS",
+    137438953606u64 => "GETTING_SOCKTYPE",
+    137438953597u64 => "INVALID_ARGUMENT",
+    137438953607u64 => "INVALID_SOCKET",
+    137438953595u64 => "IN_USE",
+    137438953574u64 => "LENGTH_TOO_LONG",
+    137438953608u64 => "LISTEN_V6_ONLY",
+    137438953614u64 => "LOOKUP_RETURNED_NOTHING",
+    137438953602u64 => "MALFORMED_HOST_OR_SERVICE",
+    137438953582u64 => "NBIO_CONNECT_ERROR",
+    137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED",
+    137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED",
+    137438953585u64 => "NO_PORT_DEFINED",
+    137438953600u64 => "NO_SUCH_FILE",
+    137438953576u64 => "TRANSFER_ERROR",
+    137438953577u64 => "TRANSFER_TIMEOUT",
+    137438953589u64 => "UNABLE_TO_BIND_SOCKET",
+    137438953590u64 => "UNABLE_TO_CREATE_SOCKET",
+    137438953609u64 => "UNABLE_TO_KEEPALIVE",
+    137438953591u64 => "UNABLE_TO_LISTEN_SOCKET",
+    137438953610u64 => "UNABLE_TO_NODELAY",
+    137438953611u64 => "UNABLE_TO_REUSEADDR",
+    137438953617u64 => "UNAVAILABLE_IP_FAMILY",
+    137438953592u64 => "UNINITIALIZED",
+    137438953612u64 => "UNKNOWN_INFO_TYPE",
+    137438953618u64 => "UNSUPPORTED_IP_FAMILY",
+    137438953593u64 => "UNSUPPORTED_METHOD",
+    137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY",
+    137438953598u64 => "WRITE_TO_READ_ONLY_BIO",
+    137438953594u64 => "WSASTARTUP",
+    12884901988u64 => "ARG2_LT_ARG3",
+    12884901989u64 => "BAD_RECIPROCAL",
+    12884902002u64 => "BIGNUM_TOO_LONG",
+    12884902006u64 => "BITS_TOO_SMALL",
+    12884901990u64 => "CALLED_WITH_EVEN_MODULUS",
+    12884901991u64 => "DIV_BY_ZERO",
+    12884901992u64 => "ENCODING_ERROR",
+    12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA",
+    12884901998u64 => "INPUT_NOT_REDUCED",
+    12884901994u64 => "INVALID_LENGTH",
+    12884902003u64 => "INVALID_RANGE",
+    12884902007u64 => "INVALID_SHIFT",
+    12884901999u64 => "NOT_A_SQUARE",
+    12884901995u64 => "NOT_INITIALIZED",
+    12884901996u64 => "NO_INVERSE",
+    12884902009u64 => "NO_PRIME_CANDIDATE",
+    12884902004u64 => "NO_SOLUTION",
+    12884902008u64 => "NO_SUITABLE_DIGEST",
+    12884902005u64 => "PRIVATE_KEY_TOO_LARGE",
+    12884902000u64 => "P_IS_NOT_PRIME",
+    12884902001u64 => "TOO_MANY_ITERATIONS",
+    12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES",
+    249108103307u64 => "ALGORITHM_NOT_SUPPORTED",
+    249108103335u64 => "BAD_CHECKAFTER_IN_POLLREP",
+    249108103276u64 => "BAD_REQUEST_ID",
+    249108103324u64 => "CERTHASH_UNMATCHED",
+    249108103277u64 => "CERTID_NOT_FOUND",
+    249108103337u64 => "CERTIFICATE_NOT_ACCEPTED",
+    249108103280u64 => "CERTIFICATE_NOT_FOUND",
+    249108103325u64 => "CERTREQMSG_NOT_FOUND",
+    249108103281u64 => "CERTRESPONSE_NOT_FOUND",
+    249108103282u64 => "CERT_AND_KEY_DO_NOT_MATCH",
+    249108103349u64 => "CHECKAFTER_OUT_OF_RANGE",
+    249108103344u64 => "ENCOUNTERED_KEYUPDATEWARNING",
+    249108103330u64 => "ENCOUNTERED_WAITING",
+    249108103283u64 => "ERROR_CALCULATING_PROTECTION",
+    249108103284u64 => "ERROR_CREATING_CERTCONF",
+    249108103285u64 => "ERROR_CREATING_CERTREP",
+    249108103331u64 => "ERROR_CREATING_CERTREQ",
+    249108103286u64 => "ERROR_CREATING_ERROR",
+    249108103287u64 => "ERROR_CREATING_GENM",
+    249108103288u64 => "ERROR_CREATING_GENP",
+    249108103290u64 => "ERROR_CREATING_PKICONF",
+    249108103291u64 => "ERROR_CREATING_POLLREP",
+    249108103292u64 => "ERROR_CREATING_POLLREQ",
+    249108103293u64 => "ERROR_CREATING_RP",
+    249108103294u64 => "ERROR_CREATING_RR",
+    249108103275u64 => "ERROR_PARSING_PKISTATUS",
+    249108103326u64 => "ERROR_PROCESSING_MESSAGE",
+    249108103295u64 => "ERROR_PROTECTING_MESSAGE",
+    249108103296u64 => "ERROR_SETTING_CERTHASH",
+    249108103328u64 => "ERROR_UNEXPECTED_CERTCONF",
+    249108103308u64 => "ERROR_VALIDATING_PROTECTION",
+    249108103339u64 => "ERROR_VALIDATING_SIGNATURE",
+    249108103332u64 => "FAILED_BUILDING_OWN_CHAIN",
+    249108103309u64 => "FAILED_EXTRACTING_PUBKEY",
+    249108103278u64 => "FAILURE_OBTAINING_RANDOM",
+    249108103297u64 => "FAIL_INFO_OUT_OF_RANGE",
+    249108103268u64 => "INVALID_ARGS",
+    249108103342u64 => "INVALID_OPTION",
+    249108103333u64 => "MISSING_CERTID",
+    249108103298u64 => "MISSING_KEY_INPUT_FOR_CREATING_PROTECTION",
+    249108103310u64 => "MISSING_KEY_USAGE_DIGITALSIGNATURE",
+    249108103289u64 => "MISSING_P10CSR",
+    249108103334u64 => "MISSING_PBM_SECRET",
+    249108103299u64 => "MISSING_PRIVATE_KEY",
+    249108103358u64 => "MISSING_PRIVATE_KEY_FOR_POPO",
+    249108103311u64 => "MISSING_PROTECTION",
+    249108103351u64 => "MISSING_PUBLIC_KEY",
+    249108103336u64 => "MISSING_REFERENCE_CERT",
+    249108103346u64 => "MISSING_SECRET",
+    249108103279u64 => "MISSING_SENDER_IDENTIFICATION",
+    249108103347u64 => "MISSING_TRUST_ANCHOR",
+    249108103312u64 => "MISSING_TRUST_STORE",
+    249108103329u64 => "MULTIPLE_REQUESTS_NOT_SUPPORTED",
+    249108103338u64 => "MULTIPLE_RESPONSES_NOT_SUPPORTED",
+    249108103270u64 => "MULTIPLE_SAN_SOURCES",
+    249108103362u64 => "NO_STDIO",
+    249108103313u64 => "NO_SUITABLE_SENDER_CERT",
+    249108103271u64 => "NULL_ARGUMENT",
+    249108103314u64 => "PKIBODY_ERROR",
+    249108103300u64 => "PKISTATUSINFO_NOT_FOUND",
+    249108103340u64 => "POLLING_FAILED",
+    249108103315u64 => "POTENTIALLY_INVALID_CERTIFICATE",
+    249108103348u64 => "RECEIVED_ERROR",
+    249108103316u64 => "RECIPNONCE_UNMATCHED",
+    249108103317u64 => "REQUEST_NOT_ACCEPTED",
+    249108103350u64 => "REQUEST_REJECTED_BY_SERVER",
+    249108103318u64 => "SENDER_GENERALNAME_TYPE_NOT_SUPPORTED",
+    249108103319u64 => "SRVCERT_DOES_NOT_VALIDATE_MSG",
+    249108103352u64 => "TOTAL_TIMEOUT",
+    249108103320u64 => "TRANSACTIONID_UNMATCHED",
+    249108103327u64 => "TRANSFER_ERROR",
+    249108103301u64 => "UNEXPECTED_PKIBODY",
+    249108103353u64 => "UNEXPECTED_PKISTATUS",
+    249108103321u64 => "UNEXPECTED_PVNO",
+    249108103302u64 => "UNKNOWN_ALGORITHM_ID",
+    249108103303u64 => "UNKNOWN_CERT_TYPE",
+    249108103354u64 => "UNKNOWN_PKISTATUS",
+    249108103304u64 => "UNSUPPORTED_ALGORITHM",
+    249108103305u64 => "UNSUPPORTED_KEY_TYPE",
+    249108103322u64 => "UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC",
+    249108103343u64 => "VALUE_TOO_LARGE",
+    249108103345u64 => "VALUE_TOO_SMALL",
+    249108103306u64 => "WRONG_ALGORITHM_OID",
+    249108103357u64 => "WRONG_CERTID",
+    249108103355u64 => "WRONG_CERTID_IN_RP",
+    249108103323u64 => "WRONG_PBM_VALUE",
+    249108103356u64 => "WRONG_RP_COMPONENT_COUNT",
+    249108103341u64 => "WRONG_SERIAL_IN_RP",
+    197568495715u64 => "ADD_SIGNER_ERROR",
+    197568495777u64 => "ATTRIBUTE_ERROR",
+    197568495791u64 => "CERTIFICATE_ALREADY_PRESENT",
+    197568495776u64 => "CERTIFICATE_HAS_NO_KEYID",
+    197568495716u64 => "CERTIFICATE_VERIFY_ERROR",
+    197568495800u64 => "CIPHER_AEAD_SET_TAG_ERROR",
+    197568495801u64 => "CIPHER_GET_TAG",
+    197568495717u64 => "CIPHER_INITIALISATION_ERROR",
+    197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR",
+    197568495719u64 => "CMS_DATAFINAL_ERROR",
+    197568495720u64 => "CMS_LIB",
+    197568495786u64 => "CONTENTIDENTIFIER_MISMATCH",
+    197568495721u64 => "CONTENT_NOT_FOUND",
+    197568495787u64 => "CONTENT_TYPE_MISMATCH",
+    197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA",
+    197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA",
+    197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA",
+    197568495725u64 => "CONTENT_VERIFY_ERROR",
+    197568495726u64 => "CTRL_ERROR",
+    197568495727u64 => "CTRL_FAILURE",
+    197568495803u64 => "DECODE_ERROR",
+    197568495728u64 => "DECRYPT_ERROR",
+    197568495729u64 => "ERROR_GETTING_PUBLIC_KEY",
+    197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE",
+    197568495731u64 => "ERROR_SETTING_KEY",
+    197568495732u64 => "ERROR_SETTING_RECIPIENTINFO",
+    197568495799u64 => "ESS_SIGNING_CERTID_MISMATCH_ERROR",
+    197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH",
+    197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER",
+    197568495734u64 => "INVALID_KEY_LENGTH",
+    197568495806u64 => "INVALID_LABEL",
+    197568495807u64 => "INVALID_OAEP_PARAMETERS",
+    197568495802u64 => "KDF_PARAMETER_ERROR",
+    197568495735u64 => "MD_BIO_INIT_ERROR",
+    197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH",
+    197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH",
+    197568495788u64 => "MSGSIGDIGEST_ERROR",
+    197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE",
+    197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH",
+    197568495780u64 => "NEED_ONE_SIGNER",
+    197568495781u64 => "NOT_A_SIGNED_RECEIPT",
+    197568495738u64 => "NOT_ENCRYPTED_DATA",
+    197568495739u64 => "NOT_KEK",
+    197568495797u64 => "NOT_KEY_AGREEMENT",
+    197568495740u64 => "NOT_KEY_TRANSPORT",
+    197568495793u64 => "NOT_PWRI",
+    197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    197568495742u64 => "NO_CIPHER",
+    197568495743u64 => "NO_CONTENT",
+    197568495789u64 => "NO_CONTENT_TYPE",
+    197568495744u64 => "NO_DEFAULT_DIGEST",
+    197568495745u64 => "NO_DIGEST_SET",
+    197568495746u64 => "NO_KEY",
+    197568495790u64 => "NO_KEY_OR_CERT",
+    197568495747u64 => "NO_MATCHING_DIGEST",
+    197568495748u64 => "NO_MATCHING_RECIPIENT",
+    197568495782u64 => "NO_MATCHING_SIGNATURE",
+    197568495783u64 => "NO_MSGSIGDIGEST",
+    197568495794u64 => "NO_PASSWORD",
+    197568495749u64 => "NO_PRIVATE_KEY",
+    197568495750u64 => "NO_PUBLIC_KEY",
+    197568495784u64 => "NO_RECEIPT_REQUEST",
+    197568495751u64 => "NO_SIGNERS",
+    197568495804u64 => "PEER_KEY_ERROR",
+    197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    197568495785u64 => "RECEIPT_DECODE_ERROR",
+    197568495753u64 => "RECIPIENT_ERROR",
+    197568495805u64 => "SHARED_INFO_ERROR",
+    197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    197568495755u64 => "SIGNFINAL_ERROR",
+    197568495756u64 => "SMIME_TEXT_ERROR",
+    197568495757u64 => "STORE_INIT_ERROR",
+    197568495758u64 => "TYPE_NOT_COMPRESSED_DATA",
+    197568495759u64 => "TYPE_NOT_DATA",
+    197568495760u64 => "TYPE_NOT_DIGESTED_DATA",
+    197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA",
+    197568495762u64 => "TYPE_NOT_ENVELOPED_DATA",
+    197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT",
+    197568495764u64 => "UNKNOWN_CIPHER",
+    197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    197568495766u64 => "UNKNOWN_ID",
+    197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM",
+    197568495768u64 => "UNSUPPORTED_CONTENT_TYPE",
+    197568495808u64 => "UNSUPPORTED_ENCRYPTION_TYPE",
+    197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM",
+    197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM",
+    197568495809u64 => "UNSUPPORTED_LABEL_SOURCE",
+    197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE",
+    197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE",
+    197568495811u64 => "UNSUPPORTED_SIGNATURE_ALGORITHM",
+    197568495772u64 => "UNSUPPORTED_TYPE",
+    197568495773u64 => "UNWRAP_ERROR",
+    197568495796u64 => "UNWRAP_FAILURE",
+    197568495774u64 => "VERIFICATION_FAILURE",
+    197568495775u64 => "WRAP_ERROR",
+    176093659235u64 => "ZLIB_DEFLATE_ERROR",
+    176093659236u64 => "ZLIB_INFLATE_ERROR",
+    176093659237u64 => "ZLIB_NOT_SUPPORTED",
+    60129542254u64 => "ERROR_LOADING_DSO",
+    60129542266u64 => "INVALID_PRAGMA",
+    60129542259u64 => "LIST_CANNOT_BE_NULL",
+    60129542267u64 => "MANDATORY_BRACES_IN_VARIABLE_EXPANSION",
+    60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET",
+    60129542245u64 => "MISSING_EQUAL_SIGN",
+    60129542256u64 => "MISSING_INIT_FUNCTION",
+    60129542253u64 => "MODULE_INITIALIZATION_ERROR",
+    60129542246u64 => "NO_CLOSE_BRACE",
+    60129542249u64 => "NO_CONF",
+    60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE",
+    60129542251u64 => "NO_SECTION",
+    60129542258u64 => "NO_SUCH_FILE",
+    60129542252u64 => "NO_VALUE",
+    60129542265u64 => "NUMBER_TOO_LARGE",
+    60129542268u64 => "OPENSSL_CONF_REFERENCES_MISSING_SECTION",
+    60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE",
+    60129542270u64 => "RECURSIVE_SECTION_REFERENCE",
+    60129542269u64 => "RELATIVE_PATH",
+    60129542261u64 => "SSL_COMMAND_SECTION_EMPTY",
+    60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    60129542263u64 => "SSL_SECTION_EMPTY",
+    60129542264u64 => "SSL_SECTION_NOT_FOUND",
+    60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION",
+    60129542257u64 => "UNKNOWN_MODULE_NAME",
+    60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG",
+    60129542248u64 => "VARIABLE_HAS_NO_VALUE",
+    240518168676u64 => "BAD_PBM_ITERATIONCOUNT",
+    240518168678u64 => "CRMFERROR",
+    240518168679u64 => "ERROR",
+    240518168680u64 => "ERROR_DECODING_CERTIFICATE",
+    240518168681u64 => "ERROR_DECRYPTING_CERTIFICATE",
+    240518168682u64 => "ERROR_DECRYPTING_SYMMETRIC_KEY",
+    240518168683u64 => "FAILURE_OBTAINING_RANDOM",
+    240518168684u64 => "ITERATIONCOUNT_BELOW_100",
+    240518168677u64 => "MALFORMED_IV",
+    240518168685u64 => "NULL_ARGUMENT",
+    240518168689u64 => "POPOSKINPUT_NOT_SUPPORTED",
+    240518168693u64 => "POPO_INCONSISTENT_PUBLIC_KEY",
+    240518168697u64 => "POPO_MISSING",
+    240518168694u64 => "POPO_MISSING_PUBLIC_KEY",
+    240518168695u64 => "POPO_MISSING_SUBJECT",
+    240518168696u64 => "POPO_RAVERIFIED_NOT_ACCEPTED",
+    240518168686u64 => "SETTING_MAC_ALGOR_FAILURE",
+    240518168687u64 => "SETTING_OWF_ALGOR_FAILURE",
+    240518168688u64 => "UNSUPPORTED_ALGORITHM",
+    240518168690u64 => "UNSUPPORTED_CIPHER",
+    240518168691u64 => "UNSUPPORTED_METHOD_FOR_CREATING_POPO",
+    240518168692u64 => "UNSUPPORTED_POPO_METHOD",
+    64424509557u64 => "BAD_ALGORITHM_NAME",
+    64424509558u64 => "CONFLICTING_NAMES",
+    64424509561u64 => "HEX_STRING_TOO_SHORT",
+    64424509542u64 => "ILLEGAL_HEX_DIGIT",
+    64424509546u64 => "INSUFFICIENT_DATA_SPACE",
+    64424509547u64 => "INSUFFICIENT_PARAM_SIZE",
+    64424509548u64 => "INSUFFICIENT_SECURE_DATA_SPACE",
+    64424509562u64 => "INVALID_NEGATIVE_VALUE",
+    64424509549u64 => "INVALID_NULL_ARGUMENT",
+    64424509550u64 => "INVALID_OSSL_PARAM_TYPE",
+    64424509543u64 => "ODD_NUMBER_OF_DIGITS",
+    64424509544u64 => "PROVIDER_ALREADY_EXISTS",
+    64424509545u64 => "PROVIDER_SECTION_ERROR",
+    64424509559u64 => "RANDOM_SECTION_ERROR",
+    64424509551u64 => "SECURE_MALLOC_FAILURE",
+    64424509552u64 => "STRING_TOO_LONG",
+    64424509553u64 => "TOO_MANY_BYTES",
+    64424509554u64 => "TOO_MANY_RECORDS",
+    64424509556u64 => "TOO_SMALL_BUFFER",
+    64424509560u64 => "UNKNOWN_NAME_IN_RANDOM_SECTION",
+    64424509555u64 => "ZERO_LENGTH_NUMBER",
+    214748364908u64 => "BASE64_DECODE_ERROR",
+    214748364900u64 => "INVALID_LOG_ID_LENGTH",
+    214748364909u64 => "LOG_CONF_INVALID",
+    214748364910u64 => "LOG_CONF_INVALID_KEY",
+    214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION",
+    214748364912u64 => "LOG_CONF_MISSING_KEY",
+    214748364913u64 => "LOG_KEY_INVALID",
+    214748364916u64 => "SCT_FUTURE_TIMESTAMP",
+    214748364904u64 => "SCT_INVALID",
+    214748364907u64 => "SCT_INVALID_SIGNATURE",
+    214748364905u64 => "SCT_LIST_INVALID",
+    214748364914u64 => "SCT_LOG_ID_MISMATCH",
+    214748364906u64 => "SCT_NOT_SET",
+    214748364915u64 => "SCT_UNSUPPORTED_VERSION",
+    214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID",
+    214748364902u64 => "UNSUPPORTED_ENTRY_TYPE",
+    214748364903u64 => "UNSUPPORTED_VERSION",
+    21474836607u64 => "BAD_FFC_PARAMETERS",
+    21474836581u64 => "BAD_GENERATOR",
+    21474836589u64 => "BN_DECODE_ERROR",
+    21474836586u64 => "BN_ERROR",
+    21474836595u64 => "CHECK_INVALID_J_VALUE",
+    21474836596u64 => "CHECK_INVALID_Q_VALUE",
+    21474836602u64 => "CHECK_PUBKEY_INVALID",
+    21474836603u64 => "CHECK_PUBKEY_TOO_LARGE",
+    21474836604u64 => "CHECK_PUBKEY_TOO_SMALL",
+    21474836597u64 => "CHECK_P_NOT_PRIME",
+    21474836598u64 => "CHECK_P_NOT_SAFE_PRIME",
+    21474836599u64 => "CHECK_Q_NOT_PRIME",
+    21474836584u64 => "DECODE_ERROR",
+    21474836590u64 => "INVALID_PARAMETER_NAME",
+    21474836594u64 => "INVALID_PARAMETER_NID",
+    21474836582u64 => "INVALID_PUBKEY",
+    21474836608u64 => "INVALID_SECRET",
+    21474836592u64 => "KDF_PARAMETER_ERROR",
+    21474836588u64 => "KEYS_NOT_SET",
+    21474836605u64 => "MISSING_PUBKEY",
+    21474836583u64 => "MODULUS_TOO_LARGE",
+    21474836606u64 => "MODULUS_TOO_SMALL",
+    21474836600u64 => "NOT_SUITABLE_GENERATOR",
+    21474836587u64 => "NO_PARAMETERS_SET",
+    21474836580u64 => "NO_PRIVATE_VALUE",
+    21474836585u64 => "PARAMETER_ENCODING_ERROR",
+    21474836591u64 => "PEER_KEY_ERROR",
+    21474836610u64 => "Q_TOO_LARGE",
+    21474836593u64 => "SHARED_INFO_ERROR",
+    21474836601u64 => "UNABLE_TO_CHECK_GENERATOR",
+    42949673074u64 => "BAD_FFC_PARAMETERS",
+    42949673062u64 => "BAD_Q_VALUE",
+    42949673068u64 => "BN_DECODE_ERROR",
+    42949673069u64 => "BN_ERROR",
+    42949673064u64 => "DECODE_ERROR",
+    42949673066u64 => "INVALID_DIGEST_TYPE",
+    42949673072u64 => "INVALID_PARAMETERS",
+    42949673061u64 => "MISSING_PARAMETERS",
+    42949673071u64 => "MISSING_PRIVATE_KEY",
+    42949673063u64 => "MODULUS_TOO_LARGE",
+    42949673067u64 => "NO_PARAMETERS_SET",
+    42949673065u64 => "PARAMETER_ENCODING_ERROR",
+    42949673075u64 => "P_NOT_PRIME",
+    42949673073u64 => "Q_NOT_PRIME",
+    42949673070u64 => "SEED_LEN_SMALL",
+    42949673076u64 => "TOO_MANY_RETRIES",
+    158913790052u64 => "CTRL_FAILED",
+    158913790062u64 => "DSO_ALREADY_LOADED",
+    158913790065u64 => "EMPTY_FILE_STRUCTURE",
+    158913790066u64 => "FAILURE",
+    158913790053u64 => "FILENAME_TOO_BIG",
+    158913790054u64 => "FINISH_FAILED",
+    158913790067u64 => "INCORRECT_FILE_SYNTAX",
+    158913790055u64 => "LOAD_FAILED",
+    158913790061u64 => "NAME_TRANSLATION_FAILED",
+    158913790063u64 => "NO_FILENAME",
+    158913790056u64 => "NULL_HANDLE",
+    158913790064u64 => "SET_FILENAME_FAILED",
+    158913790057u64 => "STACK_ERROR",
+    158913790058u64 => "SYM_FAILURE",
+    158913790059u64 => "UNLOAD_FAILED",
+    158913790060u64 => "UNSUPPORTED",
+    68719476851u64 => "ASN1_ERROR",
+    68719476892u64 => "BAD_SIGNATURE",
+    68719476880u64 => "BIGNUM_OUT_OF_RANGE",
+    68719476836u64 => "BUFFER_TOO_SMALL",
+    68719476901u64 => "CANNOT_INVERT",
+    68719476882u64 => "COORDINATES_OUT_OF_RANGE",
+    68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH",
+    68719476906u64 => "CURVE_DOES_NOT_SUPPORT_ECDSA",
+    68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING",
+    68719476878u64 => "DECODE_ERROR",
+    68719476854u64 => "DISCRIMINANT_IS_ZERO",
+    68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE",
+    68719476863u64 => "EXPLICIT_PARAMS_NOT_SUPPORTED",
+    68719476902u64 => "FAILED_MAKING_PUBLIC_KEY",
+    68719476879u64 => "FIELD_TOO_LARGE",
+    68719476883u64 => "GF2M_NOT_SUPPORTED",
+    68719476856u64 => "GROUP2PKPARAMETERS_FAILURE",
+    68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE",
+    68719476837u64 => "INCOMPATIBLE_OBJECTS",
+    68719476904u64 => "INVALID_A",
+    68719476848u64 => "INVALID_ARGUMENT",
+    68719476905u64 => "INVALID_B",
+    68719476907u64 => "INVALID_COFACTOR",
+    68719476846u64 => "INVALID_COMPRESSED_POINT",
+    68719476845u64 => "INVALID_COMPRESSION_BIT",
+    68719476877u64 => "INVALID_CURVE",
+    68719476887u64 => "INVALID_DIGEST",
+    68719476874u64 => "INVALID_DIGEST_TYPE",
+    68719476838u64 => "INVALID_ENCODING",
+    68719476839u64 => "INVALID_FIELD",
+    68719476840u64 => "INVALID_FORM",
+    68719476909u64 => "INVALID_GENERATOR",
+    68719476858u64 => "INVALID_GROUP_ORDER",
+    68719476852u64 => "INVALID_KEY",
+    68719476853u64 => "INVALID_LENGTH",
+    68719476910u64 => "INVALID_NAMED_GROUP_CONVERSION",
+    68719476897u64 => "INVALID_OUTPUT_LENGTH",
+    68719476908u64 => "INVALID_P",
+    68719476869u64 => "INVALID_PEER_KEY",
+    68719476868u64 => "INVALID_PENTANOMIAL_BASIS",
+    68719476859u64 => "INVALID_PRIVATE_KEY",
+    68719476911u64 => "INVALID_SEED",
+    68719476873u64 => "INVALID_TRINOMIAL_BASIS",
+    68719476884u64 => "KDF_PARAMETER_ERROR",
+    68719476876u64 => "KEYS_NOT_SET",
+    68719476872u64 => "LADDER_POST_FAILURE",
+    68719476889u64 => "LADDER_PRE_FAILURE",
+    68719476898u64 => "LADDER_STEP_FAILURE",
+    68719476903u64 => "MISSING_OID",
+    68719476860u64 => "MISSING_PARAMETERS",
+    68719476861u64 => "MISSING_PRIVATE_KEY",
+    68719476893u64 => "NEED_NEW_SETUP_VALUES",
+    68719476871u64 => "NOT_A_NIST_PRIME",
+    68719476862u64 => "NOT_IMPLEMENTED",
+    68719476847u64 => "NOT_INITIALIZED",
+    68719476875u64 => "NO_PARAMETERS_SET",
+    68719476890u64 => "NO_PRIVATE_VALUE",
+    68719476888u64 => "OPERATION_NOT_SUPPORTED",
+    68719476870u64 => "PASSED_NULL_PARAMETER",
+    68719476885u64 => "PEER_KEY_ERROR",
+    68719476891u64 => "POINT_ARITHMETIC_FAILURE",
+    68719476842u64 => "POINT_AT_INFINITY",
+    68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE",
+    68719476843u64 => "POINT_IS_NOT_ON_CURVE",
+    68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED",
+    68719476886u64 => "SHARED_INFO_ERROR",
+    68719476844u64 => "SLOT_FULL",
+    68719476912u64 => "TOO_MANY_RETRIES",
+    68719476849u64 => "UNDEFINED_GENERATOR",
+    68719476864u64 => "UNDEFINED_ORDER",
+    68719476900u64 => "UNKNOWN_COFACTOR",
+    68719476865u64 => "UNKNOWN_GROUP",
+    68719476850u64 => "UNKNOWN_ORDER",
+    68719476867u64 => "UNSUPPORTED_FIELD",
+    68719476881u64 => "WRONG_CURVE_PARAMETERS",
+    68719476866u64 => "WRONG_ORDER",
+    163208757348u64 => "ALREADY_LOADED",
+    163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER",
+    163208757382u64 => "CMD_NOT_EXECUTABLE",
+    163208757383u64 => "COMMAND_TAKES_INPUT",
+    163208757384u64 => "COMMAND_TAKES_NO_INPUT",
+    163208757351u64 => "CONFLICTING_ENGINE_ID",
+    163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED",
+    163208757352u64 => "DSO_FAILURE",
+    163208757380u64 => "DSO_NOT_FOUND",
+    163208757396u64 => "ENGINES_SECTION_ERROR",
+    163208757350u64 => "ENGINE_CONFIGURATION_ERROR",
+    163208757353u64 => "ENGINE_IS_NOT_IN_LIST",
+    163208757397u64 => "ENGINE_SECTION_ERROR",
+    163208757376u64 => "FAILED_LOADING_PRIVATE_KEY",
+    163208757377u64 => "FAILED_LOADING_PUBLIC_KEY",
+    163208757354u64 => "FINISH_FAILED",
+    163208757356u64 => "ID_OR_NAME_MISSING",
+    163208757357u64 => "INIT_FAILED",
+    163208757358u64 => "INTERNAL_LIST_ERROR",
+    163208757391u64 => "INVALID_ARGUMENT",
+    163208757385u64 => "INVALID_CMD_NAME",
+    163208757386u64 => "INVALID_CMD_NUMBER",
+    163208757399u64 => "INVALID_INIT_VALUE",
+    163208757398u64 => "INVALID_STRING",
+    163208757365u64 => "NOT_INITIALISED",
+    163208757360u64 => "NOT_LOADED",
+    163208757368u64 => "NO_CONTROL_FUNCTION",
+    163208757392u64 => "NO_INDEX",
+    163208757373u64 => "NO_LOAD_FUNCTION",
+    163208757378u64 => "NO_REFERENCE",
+    163208757364u64 => "NO_SUCH_ENGINE",
+    163208757394u64 => "UNIMPLEMENTED_CIPHER",
+    163208757395u64 => "UNIMPLEMENTED_DIGEST",
+    163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD",
+    163208757393u64 => "VERSION_INCOMPATIBILITY",
+    231928234091u64 => "EMPTY_ESS_CERT_ID_LIST",
+    231928234087u64 => "ESS_CERT_DIGEST_ERROR",
+    231928234088u64 => "ESS_CERT_ID_NOT_FOUND",
+    231928234089u64 => "ESS_CERT_ID_WRONG_ORDER",
+    231928234090u64 => "ESS_DIGEST_ALG_UNKNOWN",
+    231928234086u64 => "ESS_SIGNING_CERTIFICATE_ERROR",
+    231928234084u64 => "ESS_SIGNING_CERT_ADD_ERROR",
+    231928234085u64 => "ESS_SIGNING_CERT_V2_ADD_ERROR",
+    231928234092u64 => "MISSING_SIGNING_CERTIFICATE_ATTRIBUTE",
+    25769803919u64 => "AES_KEY_SETUP_FAILED",
+    25769803952u64 => "ARIA_KEY_SETUP_FAILED",
+    25769803976u64 => "BAD_ALGORITHM_NAME",
+    25769803876u64 => "BAD_DECRYPT",
+    25769803971u64 => "BAD_KEY_LENGTH",
+    25769803931u64 => "BUFFER_TOO_SMALL",
+    25769804001u64 => "CACHE_CONSTANTS_FAILED",
+    25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED",
+    25769803973u64 => "CANNOT_GET_PARAMETERS",
+    25769803974u64 => "CANNOT_SET_PARAMETERS",
+    25769803960u64 => "CIPHER_NOT_GCM_MODE",
+    25769803898u64 => "CIPHER_PARAMETER_ERROR",
+    25769803923u64 => "COMMAND_NOT_SUPPORTED",
+    25769803977u64 => "CONFLICTING_ALGORITHM_NAME",
+    25769803949u64 => "COPY_ERROR",
+    25769803908u64 => "CTRL_NOT_IMPLEMENTED",
+    25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED",
+    25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH",
+    25769803890u64 => "DECODE_ERROR",
+    25769803986u64 => "DEFAULT_QUERY_PARSE_ERROR",
+    25769803877u64 => "DIFFERENT_KEY_TYPES",
+    25769803929u64 => "DIFFERENT_PARAMETERS",
+    25769803941u64 => "ERROR_LOADING_SECTION",
+    25769803950u64 => "EXPECTING_AN_HMAC_KEY",
+    25769803903u64 => "EXPECTING_AN_RSA_KEY",
+    25769803904u64 => "EXPECTING_A_DH_KEY",
+    25769803905u64 => "EXPECTING_A_DSA_KEY",
+    25769803995u64 => "EXPECTING_A_ECX_KEY",
+    25769803918u64 => "EXPECTING_A_EC_KEY",
+    25769803940u64 => "EXPECTING_A_POLY1305_KEY",
+    25769803951u64 => "EXPECTING_A_SIPHASH_KEY",
+    25769803964u64 => "FINAL_ERROR",
+    25769803990u64 => "GENERATE_ERROR",
+    25769803958u64 => "GET_RAW_KEY_FAILED",
+    25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS",
+    25769803980u64 => "INACCESSIBLE_DOMAIN_PARAMETERS",
+    25769803979u64 => "INACCESSIBLE_KEY",
+    25769803910u64 => "INITIALIZATION_ERROR",
+    25769803887u64 => "INPUT_NOT_INITIALIZED",
+    25769803961u64 => "INVALID_CUSTOM_LENGTH",
+    25769803928u64 => "INVALID_DIGEST",
+    25769803970u64 => "INVALID_IV_LENGTH",
+    25769803939u64 => "INVALID_KEY",
+    25769803906u64 => "INVALID_KEY_LENGTH",
+    25769803997u64 => "INVALID_LENGTH",
+    25769803994u64 => "INVALID_NULL_ALGORITHM",
+    25769803924u64 => "INVALID_OPERATION",
+    25769803969u64 => "INVALID_PROVIDER_FUNCTIONS",
+    25769803962u64 => "INVALID_SALT_LENGTH",
+    25769803999u64 => "INVALID_SECRET_LENGTH",
+    25769803996u64 => "INVALID_SEED_LENGTH",
+    25769803998u64 => "INVALID_VALUE",
+    25769803981u64 => "KEYMGMT_EXPORT_FAILURE",
+    25769803956u64 => "KEY_SETUP_FAILED",
+    25769803989u64 => "LOCKING_NOT_SUPPORTED",
+    25769803948u64 => "MEMORY_LIMIT_EXCEEDED",
+    25769803935u64 => "MESSAGE_DIGEST_IS_NULL",
+    25769803920u64 => "METHOD_NOT_SUPPORTED",
+    25769803879u64 => "MISSING_PARAMETERS",
+    25769803966u64 => "NOT_ABLE_TO_COPY_CTX",
+    25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH",
+    25769803907u64 => "NO_CIPHER_SET",
+    25769803934u64 => "NO_DEFAULT_DIGEST",
+    25769803915u64 => "NO_DIGEST_SET",
+    25769803982u64 => "NO_IMPORT_FUNCTION",
+    25769803975u64 => "NO_KEYMGMT_AVAILABLE",
+    25769803972u64 => "NO_KEYMGMT_PRESENT",
+    25769803930u64 => "NO_KEY_SET",
+    25769803925u64 => "NO_OPERATION_SET",
+    25769803984u64 => "NULL_MAC_PKEY_CTX",
+    25769803953u64 => "ONLY_ONESHOT_SUPPORTED",
+    25769803927u64 => "OPERATION_NOT_INITIALIZED",
+    25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    25769803978u64 => "OUTPUT_WOULD_OVERFLOW",
+    25769803963u64 => "PARAMETER_TOO_LARGE",
+    25769803938u64 => "PARTIALLY_OVERLAPPING",
+    25769803957u64 => "PBKDF2_ERROR",
+    25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED",
+    25769803921u64 => "PRIVATE_KEY_DECODE_ERROR",
+    25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR",
+    25769803882u64 => "PUBLIC_KEY_NOT_RSA",
+    25769804003u64 => "SETTING_XOF_FAILED",
+    25769803985u64 => "SET_DEFAULT_PROPERTY_FAILURE",
+    25769803959u64 => "TOO_MANY_RECORDS",
+    25769803988u64 => "UNABLE_TO_ENABLE_LOCKING",
+    25769803991u64 => "UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE",
+    25769803992u64 => "UNABLE_TO_GET_RANDOM_STRENGTH",
+    25769803987u64 => "UNABLE_TO_LOCK_CONTEXT",
+    25769803993u64 => "UNABLE_TO_SET_CALLBACKS",
+    25769803936u64 => "UNKNOWN_CIPHER",
+    25769803937u64 => "UNKNOWN_DIGEST",
+    25769803983u64 => "UNKNOWN_KEY_TYPE",
+    25769803945u64 => "UNKNOWN_OPTION",
+    25769803897u64 => "UNKNOWN_PBE_ALGORITHM",
+    25769803932u64 => "UNSUPPORTED_ALGORITHM",
+    25769803883u64 => "UNSUPPORTED_CIPHER",
+    25769803899u64 => "UNSUPPORTED_KEYLENGTH",
+    25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION",
+    25769803884u64 => "UNSUPPORTED_KEY_SIZE",
+    25769804000u64 => "UNSUPPORTED_KEY_TYPE",
+    25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS",
+    25769803901u64 => "UNSUPPORTED_PRF",
+    25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM",
+    25769803902u64 => "UNSUPPORTED_SALT_TYPE",
+    25769803965u64 => "UPDATE_ERROR",
+    25769803946u64 => "WRAP_MODE_NOT_ALLOWED",
+    25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH",
+    25769803967u64 => "XTS_DATA_UNIT_IS_TOO_LARGE",
+    25769803968u64 => "XTS_DUPLICATED_KEYS",
+    261993005164u64 => "ASN1_LEN_EXCEEDS_MAX_RESP_LEN",
+    261993005156u64 => "CONNECT_FAILURE",
+    261993005165u64 => "ERROR_PARSING_ASN1_LENGTH",
+    261993005175u64 => "ERROR_PARSING_CONTENT_LENGTH",
+    261993005157u64 => "ERROR_PARSING_URL",
+    261993005159u64 => "ERROR_RECEIVING",
+    261993005158u64 => "ERROR_SENDING",
+    261993005184u64 => "FAILED_READING_DATA",
+    261993005182u64 => "HEADER_PARSE_ERROR",
+    261993005176u64 => "INCONSISTENT_CONTENT_LENGTH",
+    261993005179u64 => "INVALID_PORT_NUMBER",
+    261993005181u64 => "INVALID_URL_PATH",
+    261993005180u64 => "INVALID_URL_SCHEME",
+    261993005173u64 => "MAX_RESP_LEN_EXCEEDED",
+    261993005166u64 => "MISSING_ASN1_ENCODING",
+    261993005177u64 => "MISSING_CONTENT_TYPE",
+    261993005167u64 => "MISSING_REDIRECT_LOCATION",
+    261993005161u64 => "RECEIVED_ERROR",
+    261993005162u64 => "RECEIVED_WRONG_HTTP_VERSION",
+    261993005168u64 => "REDIRECTION_FROM_HTTPS_TO_HTTP",
+    261993005172u64 => "REDIRECTION_NOT_ENABLED",
+    261993005169u64 => "RESPONSE_LINE_TOO_LONG",
+    261993005160u64 => "RESPONSE_PARSE_ERROR",
+    261993005185u64 => "RETRY_TIMEOUT",
+    261993005183u64 => "SERVER_CANCELED_CONNECTION",
+    261993005178u64 => "SOCK_NOT_SUPPORTED",
+    261993005170u64 => "STATUS_CODE_UNSUPPORTED",
+    261993005163u64 => "TLS_NOT_ENABLED",
+    261993005171u64 => "TOO_MANY_REDIRECTIONS",
+    261993005174u64 => "UNEXPECTED_CONTENT_TYPE",
+    34359738470u64 => "OID_EXISTS",
+    34359738469u64 => "UNKNOWN_NID",
+    34359738471u64 => "UNKNOWN_OBJECT_NAME",
+    167503724645u64 => "CERTIFICATE_VERIFY_ERROR",
+    167503724646u64 => "DIGEST_ERR",
+    167503724650u64 => "DIGEST_NAME_ERR",
+    167503724651u64 => "DIGEST_SIZE_ERR",
+    167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD",
+    167503724667u64 => "ERROR_IN_THISUPDATE_FIELD",
+    167503724647u64 => "MISSING_OCSPSIGNING_USAGE",
+    167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE",
+    167503724648u64 => "NOT_BASIC_RESPONSE",
+    167503724649u64 => "NO_CERTIFICATES_IN_CHAIN",
+    167503724652u64 => "NO_RESPONSE_DATA",
+    167503724653u64 => "NO_REVOKED_TIME",
+    167503724674u64 => "NO_SIGNER_KEY",
+    167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    167503724672u64 => "REQUEST_NOT_SIGNED",
+    167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA",
+    167503724656u64 => "ROOT_CA_NOT_TRUSTED",
+    167503724661u64 => "SIGNATURE_FAILURE",
+    167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    167503724669u64 => "STATUS_EXPIRED",
+    167503724670u64 => "STATUS_NOT_YET_VALID",
+    167503724671u64 => "STATUS_TOO_OLD",
+    167503724663u64 => "UNKNOWN_MESSAGE_DIGEST",
+    167503724664u64 => "UNKNOWN_NID",
+    167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE",
+    257698037861u64 => "COULD_NOT_DECODE_OBJECT",
+    257698037862u64 => "DECODER_NOT_FOUND",
+    257698037860u64 => "MISSING_GET_PARAMS",
+    253403070565u64 => "ENCODER_NOT_FOUND",
+    253403070564u64 => "INCORRECT_PROPERTY_QUERY",
+    253403070566u64 => "MISSING_GET_PARAMS",
+    188978561131u64 => "AMBIGUOUS_CONTENT_TYPE",
+    188978561139u64 => "BAD_PASSWORD_READ",
+    188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC",
+    188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST",
+    188978561130u64 => "INVALID_SCHEME",
+    188978561136u64 => "IS_NOT_A",
+    188978561140u64 => "LOADER_INCOMPLETE",
+    188978561141u64 => "LOADING_STARTED",
+    188978561124u64 => "NOT_A_CERTIFICATE",
+    188978561125u64 => "NOT_A_CRL",
+    188978561127u64 => "NOT_A_NAME",
+    188978561126u64 => "NOT_A_PRIVATE_KEY",
+    188978561146u64 => "NOT_A_PUBLIC_KEY",
+    188978561128u64 => "NOT_PARAMETERS",
+    188978561147u64 => "NO_LOADERS_FOUND",
+    188978561138u64 => "PASSPHRASE_CALLBACK_ERROR",
+    188978561132u64 => "PATH_MUST_BE_ABSOLUTE",
+    188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES",
+    188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED",
+    188978561129u64 => "UNREGISTERED_SCHEME",
+    188978561134u64 => "UNSUPPORTED_CONTENT_TYPE",
+    188978561142u64 => "UNSUPPORTED_OPERATION",
+    188978561144u64 => "UNSUPPORTED_SEARCH_TYPE",
+    188978561135u64 => "URI_AUTHORITY_UNSUPPORTED",
+    38654705764u64 => "BAD_BASE64_DECODE",
+    38654705765u64 => "BAD_DECRYPT",
+    38654705766u64 => "BAD_END_LINE",
+    38654705767u64 => "BAD_IV_CHARS",
+    38654705780u64 => "BAD_MAGIC_NUMBER",
+    38654705768u64 => "BAD_PASSWORD_READ",
+    38654705781u64 => "BAD_VERSION_NUMBER",
+    38654705782u64 => "BIO_WRITE_FAILURE",
+    38654705791u64 => "CIPHER_IS_NULL",
+    38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY",
+    38654705795u64 => "EXPECTING_DSS_KEY_BLOB",
+    38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB",
+    38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB",
+    38654705796u64 => "EXPECTING_RSA_KEY_BLOB",
+    38654705792u64 => "HEADER_TOO_LONG",
+    38654705785u64 => "INCONSISTENT_HEADER",
+    38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR",
+    38654705787u64 => "KEYBLOB_TOO_SHORT",
+    38654705793u64 => "MISSING_DEK_IV",
+    38654705769u64 => "NOT_DEK_INFO",
+    38654705770u64 => "NOT_ENCRYPTED",
+    38654705771u64 => "NOT_PROC_TYPE",
+    38654705772u64 => "NO_START_LINE",
+    38654705773u64 => "PROBLEMS_GETTING_PASSWORD",
+    38654705788u64 => "PVK_DATA_TOO_SHORT",
+    38654705789u64 => "PVK_TOO_SHORT",
+    38654705775u64 => "READ_KEY",
+    38654705776u64 => "SHORT_HEADER",
+    38654705794u64 => "UNEXPECTED_DEK_IV",
+    38654705777u64 => "UNSUPPORTED_CIPHER",
+    38654705778u64 => "UNSUPPORTED_ENCRYPTION",
+    38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS",
+    38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    150323855460u64 => "CANT_PACK_STRUCTURE",
+    150323855481u64 => "CONTENT_TYPE_NOT_DATA",
+    150323855461u64 => "DECODE_ERROR",
+    150323855462u64 => "ENCODE_ERROR",
+    150323855463u64 => "ENCRYPT_ERROR",
+    150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE",
+    150323855464u64 => "INVALID_NULL_ARGUMENT",
+    150323855465u64 => "INVALID_NULL_PKCS12_POINTER",
+    150323855472u64 => "INVALID_TYPE",
+    150323855466u64 => "IV_GEN_ERROR",
+    150323855467u64 => "KEY_GEN_ERROR",
+    150323855468u64 => "MAC_ABSENT",
+    150323855469u64 => "MAC_GENERATION_ERROR",
+    150323855470u64 => "MAC_SETUP_ERROR",
+    150323855471u64 => "MAC_STRING_SET_ERROR",
+    150323855473u64 => "MAC_VERIFY_FAILURE",
+    150323855474u64 => "PARSE_ERROR",
+    150323855476u64 => "PKCS12_CIPHERFINAL_ERROR",
+    150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    150323855479u64 => "UNSUPPORTED_PKCS12_MODE",
+    141733920885u64 => "CERTIFICATE_VERIFY_ERROR",
+    141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    141733920884u64 => "CIPHER_NOT_INITIALIZED",
+    141733920886u64 => "CONTENT_AND_DATA_PRESENT",
+    141733920920u64 => "CTRL_ERROR",
+    141733920887u64 => "DECRYPT_ERROR",
+    141733920869u64 => "DIGEST_FAILURE",
+    141733920917u64 => "ENCRYPTION_CTRL_FAILURE",
+    141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920888u64 => "ERROR_ADDING_RECIPIENT",
+    141733920889u64 => "ERROR_SETTING_CIPHER",
+    141733920911u64 => "INVALID_NULL_POINTER",
+    141733920923u64 => "INVALID_SIGNED_DATA_TYPE",
+    141733920890u64 => "NO_CONTENT",
+    141733920919u64 => "NO_DEFAULT_DIGEST",
+    141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND",
+    141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE",
+    141733920891u64 => "NO_SIGNATURES_ON_DATA",
+    141733920910u64 => "NO_SIGNERS",
+    141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE",
+    141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    141733920921u64 => "PKCS7_ADD_SIGNER_ERROR",
+    141733920913u64 => "PKCS7_DATASIGN",
+    141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    141733920873u64 => "SIGNATURE_FAILURE",
+    141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    141733920915u64 => "SIGNING_CTRL_FAILURE",
+    141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920897u64 => "SMIME_TEXT_ERROR",
+    141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE",
+    141733920875u64 => "UNABLE_TO_FIND_MEM_BIO",
+    141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST",
+    141733920877u64 => "UNKNOWN_DIGEST_TYPE",
+    141733920878u64 => "UNKNOWN_OPERATION",
+    141733920879u64 => "UNSUPPORTED_CIPHER_TYPE",
+    141733920880u64 => "UNSUPPORTED_CONTENT_TYPE",
+    141733920881u64 => "WRONG_CONTENT_TYPE",
+    141733920882u64 => "WRONG_PKCS7_TYPE",
+    236223201380u64 => "NAME_TOO_LONG",
+    236223201381u64 => "NOT_AN_ASCII_CHARACTER",
+    236223201382u64 => "NOT_AN_HEXADECIMAL_DIGIT",
+    236223201383u64 => "NOT_AN_IDENTIFIER",
+    236223201384u64 => "NOT_AN_OCTAL_DIGIT",
+    236223201385u64 => "NOT_A_DECIMAL_DIGIT",
+    236223201386u64 => "NO_MATCHING_STRING_DELIMITER",
+    236223201387u64 => "NO_VALUE",
+    236223201388u64 => "PARSE_FAILED",
+    236223201389u64 => "STRING_TOO_LONG",
+    236223201390u64 => "TRAILING_CHARACTERS",
+    244813136056u64 => "ADDITIONAL_INPUT_TOO_LONG",
+    244813136045u64 => "ALGORITHM_MISMATCH",
+    244813136057u64 => "ALREADY_INSTANTIATED",
+    244813135972u64 => "BAD_DECRYPT",
+    244813136013u64 => "BAD_ENCODING",
+    244813136014u64 => "BAD_LENGTH",
+    244813136033u64 => "BAD_TLS_CLIENT_VERSION",
+    244813136032u64 => "BN_ERROR",
+    244813135974u64 => "CIPHER_OPERATION_FAILED",
+    244813136077u64 => "DERIVATION_FUNCTION_INIT_FAILED",
+    244813136046u64 => "DIGEST_NOT_ALLOWED",
+    244813136058u64 => "ENTROPY_SOURCE_STRENGTH_TOO_WEAK",
+    244813136060u64 => "ERROR_INSTANTIATING_DRBG",
+    244813136061u64 => "ERROR_RETRIEVING_ENTROPY",
+    244813136062u64 => "ERROR_RETRIEVING_NONCE",
+    244813136036u64 => "FAILED_DURING_DERIVATION",
+    244813136052u64 => "FAILED_TO_CREATE_LOCK",
+    244813136034u64 => "FAILED_TO_DECRYPT",
+    244813135993u64 => "FAILED_TO_GENERATE_KEY",
+    244813135975u64 => "FAILED_TO_GET_PARAMETER",
+    244813135976u64 => "FAILED_TO_SET_PARAMETER",
+    244813136047u64 => "FAILED_TO_SIGN",
+    244813136099u64 => "FIPS_MODULE_CONDITIONAL_ERROR",
+    244813136096u64 => "FIPS_MODULE_ENTERING_ERROR_STATE",
+    244813136097u64 => "FIPS_MODULE_IN_ERROR_STATE",
+    244813136063u64 => "GENERATE_ERROR",
+    244813136037u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE",
+    244813136082u64 => "INDICATOR_INTEGRITY_FAILURE",
+    244813136053u64 => "INSUFFICIENT_DRBG_STRENGTH",
+    244813135980u64 => "INVALID_AAD",
+    244813136083u64 => "INVALID_CONFIG_DATA",
+    244813136029u64 => "INVALID_CONSTANT_LENGTH",
+    244813136048u64 => "INVALID_CURVE",
+    244813135983u64 => "INVALID_CUSTOM_LENGTH",
+    244813135987u64 => "INVALID_DATA",
+    244813135994u64 => "INVALID_DIGEST",
+    244813136038u64 => "INVALID_DIGEST_LENGTH",
+    244813136090u64 => "INVALID_DIGEST_SIZE",
+    244813136102u64 => "INVALID_INPUT_LENGTH",
+    244813135995u64 => "INVALID_ITERATION_COUNT",
+    244813135981u64 => "INVALID_IV_LENGTH",
+    244813136030u64 => "INVALID_KEY",
+    244813135977u64 => "INVALID_KEY_LENGTH",
+    244813136023u64 => "INVALID_MAC",
+    244813136039u64 => "INVALID_MGF1_MD",
+    244813135997u64 => "INVALID_MODE",
+    244813136089u64 => "INVALID_OUTPUT_LENGTH",
+    244813136040u64 => "INVALID_PADDING_MODE",
+    244813136070u64 => "INVALID_PUBINFO",
+    244813135984u64 => "INVALID_SALT_LENGTH",
+    244813136026u64 => "INVALID_SEED_LENGTH",
+    244813136051u64 => "INVALID_SIGNATURE_SIZE",
+    244813136084u64 => "INVALID_STATE",
+    244813135982u64 => "INVALID_TAG",
+    244813135990u64 => "INVALID_TAG_LENGTH",
+    244813136072u64 => "INVALID_UKM_LENGTH",
+    244813136042u64 => "INVALID_X931_DIGEST",
+    244813136064u64 => "IN_ERROR_STATE",
+    244813135973u64 => "KEY_SETUP_FAILED",
+    244813136043u64 => "KEY_SIZE_TOO_SMALL",
+    244813136074u64 => "LENGTH_TOO_LARGE",
+    244813136075u64 => "MISMATCHING_DOMAIN_PARAMETERS",
+    244813136016u64 => "MISSING_CEK_ALG",
+    244813136027u64 => "MISSING_CIPHER",
+    244813136085u64 => "MISSING_CONFIG_DATA",
+    244813136028u64 => "MISSING_CONSTANT",
+    244813136000u64 => "MISSING_KEY",
+    244813136022u64 => "MISSING_MAC",
+    244813136001u64 => "MISSING_MESSAGE_DIGEST",
+    244813136081u64 => "MISSING_OID",
+    244813136002u64 => "MISSING_PASS",
+    244813136003u64 => "MISSING_SALT",
+    244813136004u64 => "MISSING_SECRET",
+    244813136012u64 => "MISSING_SEED",
+    244813136005u64 => "MISSING_SESSION_ID",
+    244813136006u64 => "MISSING_TYPE",
+    244813136007u64 => "MISSING_XCGHASH",
+    244813136086u64 => "MODULE_INTEGRITY_FAILURE",
+    244813136093u64 => "NOT_A_PRIVATE_KEY",
+    244813136092u64 => "NOT_A_PUBLIC_KEY",
+    244813136065u64 => "NOT_INSTANTIATED",
+    244813136098u64 => "NOT_PARAMETERS",
+    244813136008u64 => "NOT_SUPPORTED",
+    244813135985u64 => "NOT_XOF_OR_INVALID_LENGTH",
+    244813135986u64 => "NO_KEY_SET",
+    244813136049u64 => "NO_PARAMETERS_SET",
+    244813136050u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    244813135978u64 => "OUTPUT_BUFFER_TOO_SMALL",
+    244813136100u64 => "PARENT_CANNOT_GENERATE_RANDOM_NUMBERS",
+    244813136059u64 => "PARENT_CANNOT_SUPPLY_ENTROPY_SEED",
+    244813136054u64 => "PARENT_LOCKING_NOT_ENABLED",
+    244813136066u64 => "PARENT_STRENGTH_TOO_WEAK",
+    244813136091u64 => "PATH_MUST_BE_ABSOLUTE",
+    244813136067u64 => "PERSONALISATION_STRING_TOO_LONG",
+    244813136044u64 => "PSS_SALTLEN_TOO_SMALL",
+    244813136068u64 => "REQUEST_TOO_LARGE_FOR_DRBG",
+    244813136078u64 => "REQUIRE_CTR_MODE_CIPHER",
+    244813136069u64 => "RESEED_ERROR",
+    244813136094u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES",
+    244813136101u64 => "SEED_SOURCES_MUST_NOT_HAVE_A_PARENT",
+    244813136087u64 => "SELF_TEST_KAT_FAILURE",
+    244813136088u64 => "SELF_TEST_POST_FAILURE",
+    244813135992u64 => "TAG_NOT_NEEDED",
+    244813135991u64 => "TAG_NOT_SET",
+    244813135998u64 => "TOO_MANY_RECORDS",
+    244813136079u64 => "UNABLE_TO_FIND_CIPHERS",
+    244813136071u64 => "UNABLE_TO_GET_PARENT_STRENGTH",
+    244813136031u64 => "UNABLE_TO_GET_PASSPHRASE",
+    244813136080u64 => "UNABLE_TO_INITIALISE_CIPHERS",
+    244813136019u64 => "UNABLE_TO_LOAD_SHA256",
+    244813136073u64 => "UNABLE_TO_LOCK_PARENT",
+    244813136076u64 => "UNABLE_TO_RESEED",
+    244813136017u64 => "UNSUPPORTED_CEK_ALG",
+    244813136025u64 => "UNSUPPORTED_KEY_SIZE",
+    244813136009u64 => "UNSUPPORTED_MAC_TYPE",
+    244813136024u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS",
+    244813136095u64 => "URI_AUTHORITY_UNSUPPORTED",
+    244813136010u64 => "VALUE_ERROR",
+    244813135979u64 => "WRONG_FINAL_BLOCK_LENGTH",
+    244813136011u64 => "WRONG_OUTPUT_BUFFER_SIZE",
+    244813136055u64 => "XOF_DIGESTS_NOT_ALLOWED",
+    244813136020u64 => "XTS_DATA_UNIT_IS_TOO_LARGE",
+    244813136021u64 => "XTS_DUPLICATED_KEYS",
+    154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG",
+    154618822759u64 => "ALREADY_INSTANTIATED",
+    154618822761u64 => "ARGUMENT_OUT_OF_RANGE",
+    154618822777u64 => "CANNOT_OPEN_FILE",
+    154618822785u64 => "DRBG_ALREADY_INITIALIZED",
+    154618822760u64 => "DRBG_NOT_INITIALISED",
+    154618822762u64 => "ENTROPY_INPUT_TOO_LONG",
+    154618822780u64 => "ENTROPY_OUT_OF_RANGE",
+    154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED",
+    154618822763u64 => "ERROR_INITIALISING_DRBG",
+    154618822764u64 => "ERROR_INSTANTIATING_DRBG",
+    154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT",
+    154618822766u64 => "ERROR_RETRIEVING_ENTROPY",
+    154618822767u64 => "ERROR_RETRIEVING_NONCE",
+    154618822782u64 => "FAILED_TO_CREATE_LOCK",
+    154618822757u64 => "FUNC_NOT_IMPLEMENTED",
+    154618822779u64 => "FWRITE_ERROR",
+    154618822768u64 => "GENERATE_ERROR",
+    154618822795u64 => "INSUFFICIENT_DRBG_STRENGTH",
+    154618822769u64 => "INTERNAL_ERROR",
+    154618822770u64 => "IN_ERROR_STATE",
+    154618822778u64 => "NOT_A_REGULAR_FILE",
+    154618822771u64 => "NOT_INSTANTIATED",
+    154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED",
+    154618822786u64 => "PARENT_LOCKING_NOT_ENABLED",
+    154618822787u64 => "PARENT_STRENGTH_TOO_WEAK",
+    154618822772u64 => "PERSONALISATION_STRING_TOO_LONG",
+    154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED",
+    154618822756u64 => "PRNG_NOT_SEEDED",
+    154618822781u64 => "RANDOM_POOL_OVERFLOW",
+    154618822790u64 => "RANDOM_POOL_UNDERFLOW",
+    154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG",
+    154618822774u64 => "RESEED_ERROR",
+    154618822775u64 => "SELFTEST_FAILURE",
+    154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED",
+    154618822792u64 => "TOO_MUCH_NONCE_REQUESTED",
+    154618822799u64 => "UNABLE_TO_CREATE_DRBG",
+    154618822800u64 => "UNABLE_TO_FETCH_DRBG",
+    154618822797u64 => "UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER",
+    154618822794u64 => "UNABLE_TO_GET_PARENT_STRENGTH",
+    154618822796u64 => "UNABLE_TO_LOCK_PARENT",
+    154618822788u64 => "UNSUPPORTED_DRBG_FLAGS",
+    154618822776u64 => "UNSUPPORTED_DRBG_TYPE",
+    17179869284u64 => "ALGORITHM_MISMATCH",
+    17179869285u64 => "BAD_E_VALUE",
+    17179869286u64 => "BAD_FIXED_HEADER_DECRYPT",
+    17179869287u64 => "BAD_PAD_BYTE_COUNT",
+    17179869288u64 => "BAD_SIGNATURE",
+    17179869290u64 => "BLOCK_TYPE_IS_NOT_01",
+    17179869291u64 => "BLOCK_TYPE_IS_NOT_02",
+    17179869292u64 => "DATA_GREATER_THAN_MOD_LEN",
+    17179869293u64 => "DATA_TOO_LARGE",
+    17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE",
+    17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS",
+    17179869295u64 => "DATA_TOO_SMALL",
+    17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE",
+    17179869342u64 => "DIGEST_DOES_NOT_MATCH",
+    17179869329u64 => "DIGEST_NOT_ALLOWED",
+    17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY",
+    17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D",
+    17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D",
+    17179869307u64 => "D_E_NOT_CONGRUENT_TO_1",
+    17179869317u64 => "FIRST_OCTET_INVALID",
+    17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE",
+    17179869341u64 => "INVALID_DIGEST",
+    17179869327u64 => "INVALID_DIGEST_LENGTH",
+    17179869321u64 => "INVALID_HEADER",
+    17179869355u64 => "INVALID_KEYPAIR",
+    17179869357u64 => "INVALID_KEY_LENGTH",
+    17179869344u64 => "INVALID_LABEL",
+    17179869365u64 => "INVALID_LENGTH",
+    17179869315u64 => "INVALID_MESSAGE_LENGTH",
+    17179869340u64 => "INVALID_MGF1_MD",
+    17179869358u64 => "INVALID_MODULUS",
+    17179869351u64 => "INVALID_MULTI_PRIME_KEY",
+    17179869345u64 => "INVALID_OAEP_PARAMETERS",
+    17179869322u64 => "INVALID_PADDING",
+    17179869325u64 => "INVALID_PADDING_MODE",
+    17179869333u64 => "INVALID_PSS_PARAMETERS",
+    17179869330u64 => "INVALID_PSS_SALTLEN",
+    17179869359u64 => "INVALID_REQUEST",
+    17179869334u64 => "INVALID_SALT_LENGTH",
+    17179869360u64 => "INVALID_STRENGTH",
+    17179869323u64 => "INVALID_TRAILER",
+    17179869326u64 => "INVALID_X931_DIGEST",
+    17179869310u64 => "IQMP_NOT_INVERSE_OF_Q",
+    17179869349u64 => "KEY_PRIME_NUM_INVALID",
+    17179869304u64 => "KEY_SIZE_TOO_SMALL",
+    17179869318u64 => "LAST_OCTET_INVALID",
+    17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED",
+    17179869363u64 => "MISSING_PRIVATE_KEY",
+    17179869289u64 => "MODULUS_TOO_LARGE",
+    17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R",
+    17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D",
+    17179869354u64 => "MP_R_NOT_PRIME",
+    17179869324u64 => "NO_PUBLIC_EXPONENT",
+    17179869297u64 => "NULL_BEFORE_BLOCK_MISSING",
+    17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES",
+    17179869311u64 => "N_DOES_NOT_EQUAL_P_Q",
+    17179869305u64 => "OAEP_DECODING_ERROR",
+    17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    17179869298u64 => "PADDING_CHECK_FAILED",
+    17179869361u64 => "PAIRWISE_TEST_FAILURE",
+    17179869343u64 => "PKCS_DECODING_ERROR",
+    17179869348u64 => "PSS_SALTLEN_TOO_SMALL",
+    17179869362u64 => "PUB_EXPONENT_OUT_OF_RANGE",
+    17179869312u64 => "P_NOT_PRIME",
+    17179869313u64 => "Q_NOT_PRIME",
+    17179869364u64 => "RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT",
+    17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED",
+    17179869320u64 => "SLEN_CHECK_FAILED",
+    17179869319u64 => "SLEN_RECOVERY_FAILED",
+    17179869299u64 => "SSLV3_ROLLBACK_ATTACK",
+    17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    17179869301u64 => "UNKNOWN_ALGORITHM_TYPE",
+    17179869350u64 => "UNKNOWN_DIGEST",
+    17179869335u64 => "UNKNOWN_MASK_DIGEST",
+    17179869302u64 => "UNKNOWN_PADDING_TYPE",
+    17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE",
+    17179869347u64 => "UNSUPPORTED_LABEL_SOURCE",
+    17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM",
+    17179869338u64 => "UNSUPPORTED_MASK_PARAMETER",
+    17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE",
+    17179869331u64 => "VALUE_MISSING",
+    17179869303u64 => "WRONG_SIGNATURE_LENGTH",
+    227633266788u64 => "ASN1_ERROR",
+    227633266789u64 => "BAD_SIGNATURE",
+    227633266795u64 => "BUFFER_TOO_SMALL",
+    227633266798u64 => "DIST_ID_TOO_LARGE",
+    227633266800u64 => "ID_NOT_SET",
+    227633266799u64 => "ID_TOO_LARGE",
+    227633266796u64 => "INVALID_CURVE",
+    227633266790u64 => "INVALID_DIGEST",
+    227633266791u64 => "INVALID_DIGEST_TYPE",
+    227633266792u64 => "INVALID_ENCODING",
+    227633266793u64 => "INVALID_FIELD",
+    227633266801u64 => "INVALID_PRIVATE_KEY",
+    227633266797u64 => "NO_PARAMETERS_SET",
+    227633266794u64 => "USER_ID_TOO_LARGE",
+    85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY",
+    85899346020u64 => "APP_DATA_IN_HANDSHAKE",
+    85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT",
+    85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE",
+    85899346023u64 => "BAD_CHANGE_CIPHER_SPEC",
+    85899346106u64 => "BAD_CIPHER",
+    85899346310u64 => "BAD_DATA",
+    85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK",
+    85899346027u64 => "BAD_DECOMPRESSION",
+    85899346022u64 => "BAD_DH_VALUE",
+    85899346031u64 => "BAD_DIGEST_LENGTH",
+    85899346153u64 => "BAD_EARLY_DATA",
+    85899346224u64 => "BAD_ECC_CERT",
+    85899346226u64 => "BAD_ECPOINT",
+    85899346030u64 => "BAD_EXTENSION",
+    85899346252u64 => "BAD_HANDSHAKE_LENGTH",
+    85899346156u64 => "BAD_HANDSHAKE_STATE",
+    85899346025u64 => "BAD_HELLO_REQUEST",
+    85899346183u64 => "BAD_HRR_VERSION",
+    85899346028u64 => "BAD_KEY_SHARE",
+    85899346042u64 => "BAD_KEY_UPDATE",
+    85899346212u64 => "BAD_LEGACY_VERSION",
+    85899346191u64 => "BAD_LENGTH",
+    85899346160u64 => "BAD_PACKET",
+    85899346035u64 => "BAD_PACKET_LENGTH",
+    85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER",
+    85899346139u64 => "BAD_PSK",
+    85899346034u64 => "BAD_PSK_IDENTITY",
+    85899346363u64 => "BAD_RECORD_TYPE",
+    85899346039u64 => "BAD_RSA_ENCRYPT",
+    85899346043u64 => "BAD_SIGNATURE",
+    85899346267u64 => "BAD_SRP_A_LENGTH",
+    85899346291u64 => "BAD_SRP_PARAMETERS",
+    85899346272u64 => "BAD_SRTP_MKI_VALUE",
+    85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST",
+    85899346044u64 => "BAD_SSL_FILETYPE",
+    85899346304u64 => "BAD_VALUE",
+    85899346047u64 => "BAD_WRITE_RETRY",
+    85899346173u64 => "BINDER_DOES_NOT_VERIFY",
+    85899346048u64 => "BIO_NOT_SET",
+    85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG",
+    85899346050u64 => "BN_LIB",
+    85899346154u64 => "CALLBACK_FAILED",
+    85899346029u64 => "CANNOT_CHANGE_CIPHER",
+    85899346219u64 => "CANNOT_GET_GROUP_NAME",
+    85899346051u64 => "CA_DN_LENGTH_MISMATCH",
+    85899346317u64 => "CA_KEY_TOO_SMALL",
+    85899346318u64 => "CA_MD_TOO_WEAK",
+    85899346053u64 => "CCS_RECEIVED_EARLY",
+    85899346054u64 => "CERTIFICATE_VERIFY_FAILED",
+    85899346297u64 => "CERT_CB_ERROR",
+    85899346055u64 => "CERT_LENGTH_MISMATCH",
+    85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED",
+    85899346057u64 => "CIPHER_CODE_WRONG_LENGTH",
+    85899346146u64 => "CLIENTHELLO_TLSEXT",
+    85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG",
+    85899346263u64 => "COMPRESSION_DISABLED",
+    85899346061u64 => "COMPRESSION_FAILURE",
+    85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE",
+    85899346062u64 => "COMPRESSION_LIBRARY_ERROR",
+    85899346064u64 => "CONNECTION_TYPE_NOT_SET",
+    85899346087u64 => "CONTEXT_NOT_DANE_ENABLED",
+    85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE",
+    85899346228u64 => "COOKIE_MISMATCH",
+    85899346216u64 => "COPY_PARAMETERS_FAILED",
+    85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED",
+    85899346092u64 => "DANE_ALREADY_ENABLED",
+    85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL",
+    85899346095u64 => "DANE_NOT_ENABLED",
+    85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE",
+    85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE",
+    85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH",
+    85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH",
+    85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE",
+    85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY",
+    85899346122u64 => "DANE_TLSA_BAD_SELECTOR",
+    85899346123u64 => "DANE_TLSA_NULL_DATA",
+    85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED",
+    85899346066u64 => "DATA_LENGTH_TOO_LONG",
+    85899346067u64 => "DECRYPTION_FAILED",
+    85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC",
+    85899346314u64 => "DH_KEY_TOO_SMALL",
+    85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG",
+    85899346069u64 => "DIGEST_CHECK_FAILED",
+    85899346254u64 => "DTLS_MESSAGE_TOO_BIG",
+    85899346229u64 => "DUPLICATE_COMPRESSION_ID",
+    85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING",
+    85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE",
+    85899346319u64 => "EE_KEY_TOO_SMALL",
+    85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST",
+    85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG",
+    85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST",
+    85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN",
+    85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE",
+    85899346072u64 => "EXCESSIVE_MESSAGE_SIZE",
+    85899346199u64 => "EXTENSION_NOT_RECEIVED",
+    85899346073u64 => "EXTRA_DATA_IN_MESSAGE",
+    85899346083u64 => "EXT_LENGTH_MISMATCH",
+    85899346325u64 => "FAILED_TO_INIT_ASYNC",
+    85899346321u64 => "FRAGMENTED_CLIENT_HELLO",
+    85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS",
+    85899346075u64 => "HTTPS_PROXY_REQUEST",
+    85899346076u64 => "HTTP_REQUEST",
+    85899346082u64 => "ILLEGAL_POINT_COMPRESSION",
+    85899346300u64 => "ILLEGAL_SUITEB_DIGEST",
+    85899346293u64 => "INAPPROPRIATE_FALLBACK",
+    85899346260u64 => "INCONSISTENT_COMPRESSION",
+    85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN",
+    85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI",
+    85899346024u64 => "INCONSISTENT_EXTMS",
+    85899346161u64 => "INSUFFICIENT_SECURITY",
+    85899346125u64 => "INVALID_ALERT",
+    85899346180u64 => "INVALID_CCS_MESSAGE",
+    85899346158u64 => "INVALID_CERTIFICATE_OR_ALG",
+    85899346200u64 => "INVALID_COMMAND",
+    85899346261u64 => "INVALID_COMPRESSION_ALGORITHM",
+    85899346203u64 => "INVALID_CONFIG",
+    85899346033u64 => "INVALID_CONFIGURATION_NAME",
+    85899346202u64 => "INVALID_CONTEXT",
+    85899346132u64 => "INVALID_CT_VALIDATION_TYPE",
+    85899346040u64 => "INVALID_KEY_UPDATE_TYPE",
+    85899346094u64 => "INVALID_MAX_EARLY_DATA",
+    85899346305u64 => "INVALID_NULL_CMD_NAME",
+    85899346322u64 => "INVALID_SEQUENCE_NUMBER",
+    85899346308u64 => "INVALID_SERVERINFO_DATA",
+    85899346919u64 => "INVALID_SESSION_ID",
+    85899346277u64 => "INVALID_SRP_USERNAME",
+    85899346248u64 => "INVALID_STATUS_RESPONSE",
+    85899346245u64 => "INVALID_TICKET_KEYS_LENGTH",
+    85899346253u64 => "LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED",
+    85899346079u64 => "LENGTH_MISMATCH",
+    85899346324u64 => "LENGTH_TOO_LONG",
+    85899346080u64 => "LENGTH_TOO_SHORT",
+    85899346194u64 => "LIBRARY_BUG",
+    85899346081u64 => "LIBRARY_HAS_NO_CIPHERS",
+    85899346085u64 => "MISSING_DSA_SIGNING_CERT",
+    85899346301u64 => "MISSING_ECDSA_SIGNING_CERT",
+    85899346176u64 => "MISSING_FATAL",
+    85899346210u64 => "MISSING_PARAMETERS",
+    85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION",
+    85899346088u64 => "MISSING_RSA_CERTIFICATE",
+    85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT",
+    85899346090u64 => "MISSING_RSA_SIGNING_CERT",
+    85899346032u64 => "MISSING_SIGALGS_EXTENSION",
+    85899346141u64 => "MISSING_SIGNING_CERT",
+    85899346278u64 => "MISSING_SRP_PARAM",
+    85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION",
+    85899346091u64 => "MISSING_TMP_DH_KEY",
+    85899346231u64 => "MISSING_TMP_ECDH_KEY",
+    85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA",
+    85899346102u64 => "NOT_ON_RECORD_BOUNDARY",
+    85899346209u64 => "NOT_REPLACING_CERTIFICATE",
+    85899346204u64 => "NOT_SERVER",
+    85899346155u64 => "NO_APPLICATION_PROTOCOL",
+    85899346096u64 => "NO_CERTIFICATES_RETURNED",
+    85899346097u64 => "NO_CERTIFICATE_ASSIGNED",
+    85899346099u64 => "NO_CERTIFICATE_SET",
+    85899346134u64 => "NO_CHANGE_FOLLOWING_HRR",
+    85899346101u64 => "NO_CIPHERS_AVAILABLE",
+    85899346103u64 => "NO_CIPHERS_SPECIFIED",
+    85899346105u64 => "NO_CIPHER_MATCH",
+    85899346251u64 => "NO_CLIENT_CERT_METHOD",
+    85899346107u64 => "NO_COMPRESSION_SPECIFIED",
+    85899346207u64 => "NO_COOKIE_CALLBACK_SET",
+    85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER",
+    85899346108u64 => "NO_METHOD_SPECIFIED",
+    85899346309u64 => "NO_PEM_EXTENSIONS",
+    85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED",
+    85899346111u64 => "NO_PROTOCOLS_AVAILABLE",
+    85899346259u64 => "NO_RENEGOTIATION",
+    85899346244u64 => "NO_REQUIRED_DIGEST",
+    85899346113u64 => "NO_SHARED_CIPHER",
+    85899346330u64 => "NO_SHARED_GROUPS",
+    85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS",
+    85899346279u64 => "NO_SRTP_PROFILES",
+    85899346217u64 => "NO_SUITABLE_DIGEST_ALGORITHM",
+    85899346215u64 => "NO_SUITABLE_GROUPS",
+    85899346021u64 => "NO_SUITABLE_KEY_SHARE",
+    85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM",
+    85899346136u64 => "NO_VALID_SCTS",
+    85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK",
+    85899346115u64 => "NULL_SSL_CTX",
+    85899346116u64 => "NULL_SSL_METHOD_PASSED",
+    85899346225u64 => "OCSP_CALLBACK_FAILURE",
+    85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED",
+    85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED",
+    85899346157u64 => "OVERFLOW_ERROR",
+    85899346118u64 => "PACKET_LENGTH_TOO_LONG",
+    85899346147u64 => "PARSE_TLSEXT",
+    85899346190u64 => "PATH_TOO_LONG",
+    85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE",
+    85899346311u64 => "PEM_NAME_BAD_PREFIX",
+    85899346312u64 => "PEM_NAME_TOO_SHORT",
+    85899346326u64 => "PIPELINE_FAILURE",
+    85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR",
+    85899346208u64 => "PRIVATE_KEY_MISMATCH",
+    85899346127u64 => "PROTOCOL_IS_SHUTDOWN",
+    85899346143u64 => "PSK_IDENTITY_NOT_FOUND",
+    85899346144u64 => "PSK_NO_CLIENT_CB",
+    85899346145u64 => "PSK_NO_SERVER_CB",
+    85899346131u64 => "READ_BIO_NOT_SET",
+    85899346232u64 => "READ_TIMEOUT_EXPIRED",
+    85899346133u64 => "RECORD_LENGTH_MISMATCH",
+    85899346218u64 => "RECORD_TOO_SMALL",
+    85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG",
+    85899346256u64 => "RENEGOTIATION_ENCODING_ERR",
+    85899346257u64 => "RENEGOTIATION_MISMATCH",
+    85899346205u64 => "REQUEST_PENDING",
+    85899346206u64 => "REQUEST_SENT",
+    85899346135u64 => "REQUIRED_CIPHER_MISSING",
+    85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING",
+    85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING",
+    85899346128u64 => "SCT_VERIFICATION_FAILED",
+    85899346195u64 => "SERVERHELLO_TLSEXT",
+    85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED",
+    85899346327u64 => "SHUTDOWN_WHILE_IN_INIT",
+    85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR",
+    85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE",
+    85899346281u64 => "SRP_A_CALC",
+    85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES",
+    85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG",
+    85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE",
+    85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH",
+    85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME",
+    85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE",
+    85899346220u64 => "SSL3_SESSION_ID_TOO_LONG",
+    85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE",
+    85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC",
+    85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED",
+    85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED",
+    85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN",
+    85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE",
+    85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE",
+    85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER",
+    85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE",
+    85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE",
+    85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE",
+    85899346037u64 => "SSL_COMMAND_SECTION_EMPTY",
+    85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION",
+    85899346149u64 => "SSL_HANDSHAKE_FAILURE",
+    85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS",
+    85899346292u64 => "SSL_NEGATIVE_LENGTH",
+    85899346046u64 => "SSL_SECTION_EMPTY",
+    85899346056u64 => "SSL_SECTION_NOT_FOUND",
+    85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED",
+    85899346222u64 => "SSL_SESSION_ID_CONFLICT",
+    85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG",
+    85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH",
+    85899346328u64 => "SSL_SESSION_ID_TOO_LONG",
+    85899346130u64 => "SSL_SESSION_VERSION_MISMATCH",
+    85899346041u64 => "STILL_IN_INIT",
+    85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED",
+    85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION",
+    85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED",
+    85899346970u64 => "TLSV1_ALERT_DECODE_ERROR",
+    85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED",
+    85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR",
+    85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION",
+    85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK",
+    85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY",
+    85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR",
+    85899347040u64 => "TLSV1_ALERT_NO_APPLICATION_PROTOCOL",
+    85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION",
+    85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION",
+    85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW",
+    85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA",
+    85899347035u64 => "TLSV1_ALERT_UNKNOWN_PSK_IDENTITY",
+    85899347010u64 => "TLSV1_ALERT_USER_CANCELLED",
+    85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE",
+    85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE",
+    85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE",
+    85899347032u64 => "TLSV1_UNRECOGNIZED_NAME",
+    85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION",
+    85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL",
+    85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST",
+    85899346052u64 => "TOO_MANY_KEY_UPDATES",
+    85899346329u64 => "TOO_MANY_WARN_ALERTS",
+    85899346084u64 => "TOO_MUCH_EARLY_DATA",
+    85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS",
+    85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS",
+    85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES",
+    85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES",
+    85899346182u64 => "UNEXPECTED_CCS_MESSAGE",
+    85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA",
+    85899346214u64 => "UNEXPECTED_EOF_WHILE_READING",
+    85899346164u64 => "UNEXPECTED_MESSAGE",
+    85899346165u64 => "UNEXPECTED_RECORD",
+    85899346196u64 => "UNINITIALIZED",
+    85899346166u64 => "UNKNOWN_ALERT_TYPE",
+    85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE",
+    85899346168u64 => "UNKNOWN_CIPHER_RETURNED",
+    85899346169u64 => "UNKNOWN_CIPHER_TYPE",
+    85899346306u64 => "UNKNOWN_CMD_NAME",
+    85899346059u64 => "UNKNOWN_COMMAND",
+    85899346288u64 => "UNKNOWN_DIGEST",
+    85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE",
+    85899346171u64 => "UNKNOWN_PKEY_TYPE",
+    85899346172u64 => "UNKNOWN_PROTOCOL",
+    85899346174u64 => "UNKNOWN_SSL_VERSION",
+    85899346175u64 => "UNKNOWN_STATE",
+    85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED",
+    85899346137u64 => "UNSOLICITED_EXTENSION",
+    85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE",
+    85899346178u64 => "UNSUPPORTED_PROTOCOL",
+    85899346179u64 => "UNSUPPORTED_SSL_VERSION",
+    85899346249u64 => "UNSUPPORTED_STATUS_TYPE",
+    85899346289u64 => "USE_SRTP_NOT_NEGOTIATED",
+    85899346086u64 => "VERSION_TOO_HIGH",
+    85899346316u64 => "VERSION_TOO_LOW",
+    85899346303u64 => "WRONG_CERTIFICATE_TYPE",
+    85899346181u64 => "WRONG_CIPHER_RETURNED",
+    85899346298u64 => "WRONG_CURVE",
+    85899346184u64 => "WRONG_SIGNATURE_LENGTH",
+    85899346185u64 => "WRONG_SIGNATURE_SIZE",
+    85899346290u64 => "WRONG_SIGNATURE_TYPE",
+    85899346186u64 => "WRONG_SSL_VERSION",
+    85899346187u64 => "WRONG_VERSION_NUMBER",
+    85899346188u64 => "X509_LIB",
+    85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS",
+    201863463044u64 => "BAD_PKCS7_TYPE",
+    201863463045u64 => "BAD_TYPE",
+    201863463049u64 => "CANNOT_LOAD_CERT",
+    201863463050u64 => "CANNOT_LOAD_KEY",
+    201863463012u64 => "CERTIFICATE_VERIFY_ERROR",
+    201863463039u64 => "COULD_NOT_SET_ENGINE",
+    201863463027u64 => "COULD_NOT_SET_TIME",
+    201863463046u64 => "DETACHED_CONTENT",
+    201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR",
+    201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR",
+    201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR",
+    201863463014u64 => "INVALID_NULL_POINTER",
+    201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE",
+    201863463015u64 => "MESSAGE_IMPRINT_MISMATCH",
+    201863463016u64 => "NONCE_MISMATCH",
+    201863463017u64 => "NONCE_NOT_RETURNED",
+    201863463018u64 => "NO_CONTENT",
+    201863463019u64 => "NO_TIME_STAMP_TOKEN",
+    201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR",
+    201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED",
+    201863463020u64 => "POLICY_MISMATCH",
+    201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    201863463033u64 => "RESPONSE_SETUP_ERROR",
+    201863463021u64 => "SIGNATURE_FAILURE",
+    201863463022u64 => "THERE_MUST_BE_ONE_SIGNER",
+    201863463034u64 => "TIME_SYSCALL_ERROR",
+    201863463042u64 => "TOKEN_NOT_PRESENT",
+    201863463043u64 => "TOKEN_PRESENT",
+    201863463023u64 => "TSA_NAME_MISMATCH",
+    201863463024u64 => "TSA_UNTRUSTED",
+    201863463035u64 => "TST_INFO_SETUP_ERROR",
+    201863463036u64 => "TS_DATASIGN",
+    201863463037u64 => "UNACCEPTABLE_POLICY",
+    201863463038u64 => "UNSUPPORTED_MD_ALGORITHM",
+    201863463025u64 => "UNSUPPORTED_VERSION",
+    201863463047u64 => "VAR_BAD_VALUE",
+    201863463048u64 => "VAR_LOOKUP_FAILURE",
+    201863463026u64 => "WRONG_CONTENT_TYPE",
+    171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS",
+    171798691942u64 => "INDEX_TOO_LARGE",
+    171798691943u64 => "INDEX_TOO_SMALL",
+    171798691945u64 => "NO_RESULT_BUFFER",
+    171798691947u64 => "PROCESSING_ERROR",
+    171798691940u64 => "RESULT_TOO_LARGE",
+    171798691941u64 => "RESULT_TOO_SMALL",
+    171798691949u64 => "SYSASSIGN_ERROR",
+    171798691950u64 => "SYSDASSGN_ERROR",
+    171798691951u64 => "SYSQIOW_ERROR",
+    171798691946u64 => "UNKNOWN_CONTROL_COMMAND",
+    171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE",
+    171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED",
+    146028888182u64 => "BAD_IP_ADDRESS",
+    146028888183u64 => "BAD_OBJECT",
+    146028888164u64 => "BN_DEC2BN_ERROR",
+    146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR",
+    146028888213u64 => "DIRNAME_ERROR",
+    146028888224u64 => "DISTPOINT_ALREADY_SET",
+    146028888197u64 => "DUPLICATE_ZONE_ID",
+    146028888233u64 => "EMPTY_KEY_USAGE",
+    146028888195u64 => "ERROR_CONVERTING_ZONE",
+    146028888208u64 => "ERROR_CREATING_EXTENSION",
+    146028888192u64 => "ERROR_IN_EXTENSION",
+    146028888201u64 => "EXPECTED_A_SECTION_NAME",
+    146028888209u64 => "EXTENSION_EXISTS",
+    146028888179u64 => "EXTENSION_NAME_ERROR",
+    146028888166u64 => "EXTENSION_NOT_FOUND",
+    146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED",
+    146028888180u64 => "EXTENSION_VALUE_ERROR",
+    146028888215u64 => "ILLEGAL_EMPTY_EXTENSION",
+    146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG",
+    146028888226u64 => "INVALID_ASNUMBER",
+    146028888227u64 => "INVALID_ASRANGE",
+    146028888168u64 => "INVALID_BOOLEAN_STRING",
+    146028888222u64 => "INVALID_CERTIFICATE",
+    146028888172u64 => "INVALID_EMPTY_NAME",
+    146028888169u64 => "INVALID_EXTENSION_STRING",
+    146028888229u64 => "INVALID_INHERITANCE",
+    146028888230u64 => "INVALID_IPADDRESS",
+    146028888225u64 => "INVALID_MULTIPLE_RDNS",
+    146028888170u64 => "INVALID_NAME",
+    146028888171u64 => "INVALID_NULL_ARGUMENT",
+    146028888173u64 => "INVALID_NULL_VALUE",
+    146028888204u64 => "INVALID_NUMBER",
+    146028888205u64 => "INVALID_NUMBERS",
+    146028888174u64 => "INVALID_OBJECT_IDENTIFIER",
+    146028888202u64 => "INVALID_OPTION",
+    146028888198u64 => "INVALID_POLICY_IDENTIFIER",
+    146028888217u64 => "INVALID_PROXY_POLICY_SETTING",
+    146028888210u64 => "INVALID_PURPOSE",
+    146028888228u64 => "INVALID_SAFI",
+    146028888199u64 => "INVALID_SECTION",
+    146028888207u64 => "INVALID_SYNTAX",
+    146028888190u64 => "ISSUER_DECODE_ERROR",
+    146028888188u64 => "MISSING_VALUE",
+    146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS",
+    146028888232u64 => "NEGATIVE_PATHLEN",
+    146028888200u64 => "NO_CONFIG_DATABASE",
+    146028888185u64 => "NO_ISSUER_CERTIFICATE",
+    146028888191u64 => "NO_ISSUER_DETAILS",
+    146028888203u64 => "NO_POLICY_IDENTIFIER",
+    146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED",
+    146028888178u64 => "NO_PUBLIC_KEY",
+    146028888189u64 => "NO_SUBJECT_DETAILS",
+    146028888212u64 => "OPERATION_NOT_DEFINED",
+    146028888211u64 => "OTHERNAME_ERROR",
+    146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED",
+    146028888220u64 => "POLICY_PATH_LENGTH",
+    146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED",
+    146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY",
+    146028888214u64 => "SECTION_NOT_FOUND",
+    146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS",
+    146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID",
+    146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT",
+    146028888193u64 => "UNKNOWN_EXTENSION",
+    146028888194u64 => "UNKNOWN_EXTENSION_NAME",
+    146028888184u64 => "UNKNOWN_OPTION",
+    146028888181u64 => "UNSUPPORTED_OPTION",
+    146028888231u64 => "UNSUPPORTED_TYPE",
+    146028888196u64 => "USER_TOO_LONG",
+    47244640366u64 => "AKID_MISMATCH",
+    47244640389u64 => "BAD_SELECTOR",
+    47244640356u64 => "BAD_X509_FILETYPE",
+    47244640374u64 => "BASE64_DECODE_ERROR",
+    47244640370u64 => "CANT_CHECK_DH_KEY",
+    47244640395u64 => "CERTIFICATE_VERIFICATION_FAILED",
+    47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE",
+    47244640383u64 => "CRL_ALREADY_DELTA",
+    47244640387u64 => "CRL_VERIFY_FAILURE",
+    47244640396u64 => "DUPLICATE_ATTRIBUTE",
+    47244640397u64 => "ERROR_GETTING_MD_BY_NID",
+    47244640398u64 => "ERROR_USING_SIGINF_SET",
+    47244640384u64 => "IDP_MISMATCH",
+    47244640394u64 => "INVALID_ATTRIBUTES",
+    47244640369u64 => "INVALID_DIRECTORY",
+    47244640399u64 => "INVALID_DISTPOINT",
+    47244640375u64 => "INVALID_FIELD_NAME",
+    47244640379u64 => "INVALID_TRUST",
+    47244640385u64 => "ISSUER_MISMATCH",
+    47244640371u64 => "KEY_TYPE_MISMATCH",
+    47244640372u64 => "KEY_VALUES_MISMATCH",
+    47244640359u64 => "LOADING_CERT_DIR",
+    47244640360u64 => "LOADING_DEFAULTS",
+    47244640380u64 => "METHOD_NOT_SUPPORTED",
+    47244640390u64 => "NAME_TOO_LONG",
+    47244640388u64 => "NEWER_CRL_NOT_NEWER",
+    47244640391u64 => "NO_CERTIFICATE_FOUND",
+    47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND",
+    47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY",
+    47244640393u64 => "NO_CRL_FOUND",
+    47244640386u64 => "NO_CRL_NUMBER",
+    47244640381u64 => "PUBLIC_KEY_DECODE_ERROR",
+    47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR",
+    47244640362u64 => "SHOULD_RETRY",
+    47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN",
+    47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY",
+    47244640373u64 => "UNKNOWN_KEY_TYPE",
+    47244640365u64 => "UNKNOWN_NID",
+    47244640377u64 => "UNKNOWN_PURPOSE_ID",
+    47244640400u64 => "UNKNOWN_SIGID_ALGS",
+    47244640376u64 => "UNKNOWN_TRUST_ID",
+    47244640367u64 => "UNSUPPORTED_ALGORITHM",
+    47244640368u64 => "WRONG_LOOKUP_TYPE",
+    47244640378u64 => "WRONG_TYPE",
+};
+
+/// Helper function to create encoded key from (lib, reason) pair
+#[inline]
+pub fn encode_error_key(lib: i32, reason: i32) -> u64 {
+    ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF)
+}
diff --git a/crates/stdlib/src/openssl/ssl_data_31.rs b/crates/stdlib/src/openssl/ssl_data_31.rs
new file mode 100644
index 0000000000..4b80de539e
--- /dev/null
+++ b/crates/stdlib/src/openssl/ssl_data_31.rs
@@ -0,0 +1,1770 @@
+// File generated by tools/make_ssl_data_rs.py
+// Generated on 2025-10-29T07:17:16.621749+00:00
+// Source: OpenSSL from /tmp/openssl-3.1
+// spell-checker: disable
+
+use phf::phf_map;
+
+// Maps lib_code -> library name
+// Example: 20 -> "SSL"
+pub static LIBRARY_CODES: phf::Map<u32, &'static str> = phf_map! {
+    0u32 => "MASK",
+    1u32 => "NONE",
+    2u32 => "SYS",
+    3u32 => "BN",
+    4u32 => "RSA",
+    5u32 => "DH",
+    6u32 => "EVP",
+    7u32 => "BUF",
+    8u32 => "OBJ",
+    9u32 => "PEM",
+    10u32 => "DSA",
+    11u32 => "X509",
+    12u32 => "METH",
+    13u32 => "ASN1",
+    14u32 => "CONF",
+    15u32 => "CRYPTO",
+    16u32 => "EC",
+    20u32 => "SSL",
+    21u32 => "SSL23",
+    22u32 => "SSL2",
+    23u32 => "SSL3",
+    30u32 => "RSAREF",
+    31u32 => "PROXY",
+    32u32 => "BIO",
+    33u32 => "PKCS7",
+    34u32 => "X509V3",
+    35u32 => "PKCS12",
+    36u32 => "RAND",
+    37u32 => "DSO",
+    38u32 => "ENGINE",
+    39u32 => "OCSP",
+    40u32 => "UI",
+    41u32 => "COMP",
+    42u32 => "ECDSA",
+    43u32 => "ECDH",
+    44u32 => "OSSL_STORE",
+    45u32 => "FIPS",
+    46u32 => "CMS",
+    47u32 => "TS",
+    48u32 => "HMAC",
+    49u32 => "JPAKE",
+    50u32 => "CT",
+    51u32 => "ASYNC",
+    52u32 => "KDF",
+    53u32 => "SM2",
+    54u32 => "ESS",
+    55u32 => "PROP",
+    56u32 => "CRMF",
+    57u32 => "PROV",
+    58u32 => "CMP",
+    59u32 => "OSSL_ENCODER",
+    60u32 => "OSSL_DECODER",
+    61u32 => "HTTP",
+    128u32 => "USER",
+};
+
+// Maps encoded (lib, reason) -> error mnemonic
+// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED"
+// Key encoding: (lib << 32) | reason
+pub static ERROR_CODES: phf::Map<u64, &'static str> = phf_map! {
+    55834575019u64 => "ADDING_OBJECT",
+    55834575051u64 => "ASN1_PARSE_ERROR",
+    55834575052u64 => "ASN1_SIG_PARSE_ERROR",
+    55834574948u64 => "AUX_ERROR",
+    55834574950u64 => "BAD_OBJECT_HEADER",
+    55834575078u64 => "BAD_TEMPLATE",
+    55834575062u64 => "BMPSTRING_IS_WRONG_LENGTH",
+    55834574953u64 => "BN_LIB",
+    55834574954u64 => "BOOLEAN_IS_WRONG_LENGTH",
+    55834574955u64 => "BUFFER_TOO_SMALL",
+    55834574956u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    55834575065u64 => "CONTEXT_NOT_INITIALISED",
+    55834574957u64 => "DATA_IS_WRONG",
+    55834574958u64 => "DECODE_ERROR",
+    55834575022u64 => "DEPTH_EXCEEDED",
+    55834575046u64 => "DIGEST_AND_KEY_TYPE_NOT_SUPPORTED",
+    55834574960u64 => "ENCODE_ERROR",
+    55834575021u64 => "ERROR_GETTING_TIME",
+    55834575020u64 => "ERROR_LOADING_SECTION",
+    55834574962u64 => "ERROR_SETTING_CIPHER_PARAMS",
+    55834574963u64 => "EXPECTING_AN_INTEGER",
+    55834574964u64 => "EXPECTING_AN_OBJECT",
+    55834574967u64 => "EXPLICIT_LENGTH_MISMATCH",
+    55834574968u64 => "EXPLICIT_TAG_NOT_CONSTRUCTED",
+    55834574969u64 => "FIELD_MISSING",
+    55834574970u64 => "FIRST_NUM_TOO_LARGE",
+    55834574971u64 => "HEADER_TOO_LONG",
+    55834575023u64 => "ILLEGAL_BITSTRING_FORMAT",
+    55834575024u64 => "ILLEGAL_BOOLEAN",
+    55834574972u64 => "ILLEGAL_CHARACTERS",
+    55834575025u64 => "ILLEGAL_FORMAT",
+    55834575026u64 => "ILLEGAL_HEX",
+    55834575027u64 => "ILLEGAL_IMPLICIT_TAG",
+    55834575028u64 => "ILLEGAL_INTEGER",
+    55834575074u64 => "ILLEGAL_NEGATIVE_VALUE",
+    55834575029u64 => "ILLEGAL_NESTED_TAGGING",
+    55834574973u64 => "ILLEGAL_NULL",
+    55834575030u64 => "ILLEGAL_NULL_VALUE",
+    55834575031u64 => "ILLEGAL_OBJECT",
+    55834574974u64 => "ILLEGAL_OPTIONAL_ANY",
+    55834575018u64 => "ILLEGAL_OPTIONS_ON_ITEM_TEMPLATE",
+    55834575069u64 => "ILLEGAL_PADDING",
+    55834574975u64 => "ILLEGAL_TAGGED_ANY",
+    55834575032u64 => "ILLEGAL_TIME_VALUE",
+    55834575070u64 => "ILLEGAL_ZERO_CONTENT",
+    55834575033u64 => "INTEGER_NOT_ASCII_FORMAT",
+    55834574976u64 => "INTEGER_TOO_LARGE_FOR_LONG",
+    55834575068u64 => "INVALID_BIT_STRING_BITS_LEFT",
+    55834574977u64 => "INVALID_BMPSTRING_LENGTH",
+    55834574978u64 => "INVALID_DIGIT",
+    55834575053u64 => "INVALID_MIME_TYPE",
+    55834575034u64 => "INVALID_MODIFIER",
+    55834575035u64 => "INVALID_NUMBER",
+    55834575064u64 => "INVALID_OBJECT_ENCODING",
+    55834575075u64 => "INVALID_SCRYPT_PARAMETERS",
+    55834574979u64 => "INVALID_SEPARATOR",
+    55834575066u64 => "INVALID_STRING_TABLE_VALUE",
+    55834574981u64 => "INVALID_UNIVERSALSTRING_LENGTH",
+    55834574982u64 => "INVALID_UTF8STRING",
+    55834575067u64 => "INVALID_VALUE",
+    55834575079u64 => "LENGTH_TOO_LONG",
+    55834575036u64 => "LIST_ERROR",
+    55834575054u64 => "MIME_NO_CONTENT_TYPE",
+    55834575055u64 => "MIME_PARSE_ERROR",
+    55834575056u64 => "MIME_SIG_PARSE_ERROR",
+    55834574985u64 => "MISSING_EOC",
+    55834574986u64 => "MISSING_SECOND_NUMBER",
+    55834575037u64 => "MISSING_VALUE",
+    55834574987u64 => "MSTRING_NOT_UNIVERSAL",
+    55834574988u64 => "MSTRING_WRONG_TAG",
+    55834575045u64 => "NESTED_ASN1_STRING",
+    55834575049u64 => "NESTED_TOO_DEEP",
+    55834574989u64 => "NON_HEX_CHARACTERS",
+    55834575038u64 => "NOT_ASCII_FORMAT",
+    55834574990u64 => "NOT_ENOUGH_DATA",
+    55834575057u64 => "NO_CONTENT_TYPE",
+    55834574991u64 => "NO_MATCHING_CHOICE_TYPE",
+    55834575058u64 => "NO_MULTIPART_BODY_FAILURE",
+    55834575059u64 => "NO_MULTIPART_BOUNDARY",
+    55834575060u64 => "NO_SIG_CONTENT_TYPE",
+    55834574992u64 => "NULL_IS_WRONG_LENGTH",
+    55834575039u64 => "OBJECT_NOT_ASCII_FORMAT",
+    55834574993u64 => "ODD_NUMBER_OF_CHARS",
+    55834574995u64 => "SECOND_NUMBER_TOO_LARGE",
+    55834574996u64 => "SEQUENCE_LENGTH_MISMATCH",
+    55834574997u64 => "SEQUENCE_NOT_CONSTRUCTED",
+    55834575040u64 => "SEQUENCE_OR_SET_NEEDS_CONFIG",
+    55834574998u64 => "SHORT_LINE",
+    55834575061u64 => "SIG_INVALID_MIME_TYPE",
+    55834575050u64 => "STREAMING_NOT_SUPPORTED",
+    55834574999u64 => "STRING_TOO_LONG",
+    55834575000u64 => "STRING_TOO_SHORT",
+    55834575002u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    55834575041u64 => "TIME_NOT_ASCII_FORMAT",
+    55834575071u64 => "TOO_LARGE",
+    55834575003u64 => "TOO_LONG",
+    55834575072u64 => "TOO_SMALL",
+    55834575004u64 => "TYPE_NOT_CONSTRUCTED",
+    55834575043u64 => "TYPE_NOT_PRIMITIVE",
+    55834575007u64 => "UNEXPECTED_EOC",
+    55834575063u64 => "UNIVERSALSTRING_IS_WRONG_LENGTH",
+    55834575077u64 => "UNKNOWN_DIGEST",
+    55834575008u64 => "UNKNOWN_FORMAT",
+    55834575009u64 => "UNKNOWN_MESSAGE_DIGEST_ALGORITHM",
+    55834575010u64 => "UNKNOWN_OBJECT_TYPE",
+    55834575011u64 => "UNKNOWN_PUBLIC_KEY_TYPE",
+    55834575047u64 => "UNKNOWN_SIGNATURE_ALGORITHM",
+    55834575042u64 => "UNKNOWN_TAG",
+    55834575012u64 => "UNSUPPORTED_ANY_DEFINED_BY_TYPE",
+    55834575076u64 => "UNSUPPORTED_CIPHER",
+    55834575015u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    55834575044u64 => "UNSUPPORTED_TYPE",
+    55834575073u64 => "WRONG_INTEGER_TYPE",
+    55834575048u64 => "WRONG_PUBLIC_KEY_TYPE",
+    55834575016u64 => "WRONG_TAG",
+    219043332197u64 => "FAILED_TO_SET_POOL",
+    219043332198u64 => "FAILED_TO_SWAP_CONTEXT",
+    219043332201u64 => "INIT_FAILED",
+    219043332199u64 => "INVALID_POOL_SIZE",
+    137438953572u64 => "ACCEPT_ERROR",
+    137438953613u64 => "ADDRINFO_ADDR_IS_NOT_AF_INET",
+    137438953601u64 => "AMBIGUOUS_HOST_OR_SERVICE",
+    137438953573u64 => "BAD_FOPEN_MODE",
+    137438953596u64 => "BROKEN_PIPE",
+    137438953575u64 => "CONNECT_ERROR",
+    137438953619u64 => "CONNECT_TIMEOUT",
+    137438953579u64 => "GETHOSTBYNAME_ADDR_IS_NOT_AF_INET",
+    137438953604u64 => "GETSOCKNAME_ERROR",
+    137438953605u64 => "GETSOCKNAME_TRUNCATED_ADDRESS",
+    137438953606u64 => "GETTING_SOCKTYPE",
+    137438953597u64 => "INVALID_ARGUMENT",
+    137438953607u64 => "INVALID_SOCKET",
+    137438953595u64 => "IN_USE",
+    137438953574u64 => "LENGTH_TOO_LONG",
+    137438953608u64 => "LISTEN_V6_ONLY",
+    137438953614u64 => "LOOKUP_RETURNED_NOTHING",
+    137438953602u64 => "MALFORMED_HOST_OR_SERVICE",
+    137438953582u64 => "NBIO_CONNECT_ERROR",
+    137438953615u64 => "NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED",
+    137438953616u64 => "NO_HOSTNAME_OR_SERVICE_SPECIFIED",
+    137438953585u64 => "NO_PORT_DEFINED",
+    137438953600u64 => "NO_SUCH_FILE",
+    137438953576u64 => "TRANSFER_ERROR",
+    137438953577u64 => "TRANSFER_TIMEOUT",
+    137438953589u64 => "UNABLE_TO_BIND_SOCKET",
+    137438953590u64 => "UNABLE_TO_CREATE_SOCKET",
+    137438953609u64 => "UNABLE_TO_KEEPALIVE",
+    137438953591u64 => "UNABLE_TO_LISTEN_SOCKET",
+    137438953610u64 => "UNABLE_TO_NODELAY",
+    137438953611u64 => "UNABLE_TO_REUSEADDR",
+    137438953617u64 => "UNAVAILABLE_IP_FAMILY",
+    137438953592u64 => "UNINITIALIZED",
+    137438953612u64 => "UNKNOWN_INFO_TYPE",
+    137438953618u64 => "UNSUPPORTED_IP_FAMILY",
+    137438953593u64 => "UNSUPPORTED_METHOD",
+    137438953603u64 => "UNSUPPORTED_PROTOCOL_FAMILY",
+    137438953598u64 => "WRITE_TO_READ_ONLY_BIO",
+    137438953594u64 => "WSASTARTUP",
+    12884901988u64 => "ARG2_LT_ARG3",
+    12884901989u64 => "BAD_RECIPROCAL",
+    12884902002u64 => "BIGNUM_TOO_LONG",
+    12884902006u64 => "BITS_TOO_SMALL",
+    12884901990u64 => "CALLED_WITH_EVEN_MODULUS",
+    12884901991u64 => "DIV_BY_ZERO",
+    12884901992u64 => "ENCODING_ERROR",
+    12884901993u64 => "EXPAND_ON_STATIC_BIGNUM_DATA",
+    12884901998u64 => "INPUT_NOT_REDUCED",
+    12884901994u64 => "INVALID_LENGTH",
+    12884902003u64 => "INVALID_RANGE",
+    12884902007u64 => "INVALID_SHIFT",
+    12884901999u64 => "NOT_A_SQUARE",
+    12884901995u64 => "NOT_INITIALIZED",
+    12884901996u64 => "NO_INVERSE",
+    12884902009u64 => "NO_PRIME_CANDIDATE",
+    12884902004u64 => "NO_SOLUTION",
+    12884902008u64 => "NO_SUITABLE_DIGEST",
+    12884902005u64 => "PRIVATE_KEY_TOO_LARGE",
+    12884902000u64 => "P_IS_NOT_PRIME",
+    12884902001u64 => "TOO_MANY_ITERATIONS",
+    12884901997u64 => "TOO_MANY_TEMPORARY_VARIABLES",
+    249108103307u64 => "ALGORITHM_NOT_SUPPORTED",
+    249108103335u64 => "BAD_CHECKAFTER_IN_POLLREP",
+    249108103276u64 => "BAD_REQUEST_ID",
+    249108103324u64 => "CERTHASH_UNMATCHED",
+    249108103277u64 => "CERTID_NOT_FOUND",
+    249108103337u64 => "CERTIFICATE_NOT_ACCEPTED",
+    249108103280u64 => "CERTIFICATE_NOT_FOUND",
+    249108103325u64 => "CERTREQMSG_NOT_FOUND",
+    249108103281u64 => "CERTRESPONSE_NOT_FOUND",
+    249108103282u64 => "CERT_AND_KEY_DO_NOT_MATCH",
+    249108103349u64 => "CHECKAFTER_OUT_OF_RANGE",
+    249108103344u64 => "ENCOUNTERED_KEYUPDATEWARNING",
+    249108103330u64 => "ENCOUNTERED_WAITING",
+    249108103283u64 => "ERROR_CALCULATING_PROTECTION",
+    249108103284u64 => "ERROR_CREATING_CERTCONF",
+    249108103285u64 => "ERROR_CREATING_CERTREP",
+    249108103331u64 => "ERROR_CREATING_CERTREQ",
+    249108103286u64 => "ERROR_CREATING_ERROR",
+    249108103287u64 => "ERROR_CREATING_GENM",
+    249108103288u64 => "ERROR_CREATING_GENP",
+    249108103290u64 => "ERROR_CREATING_PKICONF",
+    249108103291u64 => "ERROR_CREATING_POLLREP",
+    249108103292u64 => "ERROR_CREATING_POLLREQ",
+    249108103293u64 => "ERROR_CREATING_RP",
+    249108103294u64 => "ERROR_CREATING_RR",
+    249108103275u64 => "ERROR_PARSING_PKISTATUS",
+    249108103326u64 => "ERROR_PROCESSING_MESSAGE",
+    249108103295u64 => "ERROR_PROTECTING_MESSAGE",
+    249108103296u64 => "ERROR_SETTING_CERTHASH",
+    249108103328u64 => "ERROR_UNEXPECTED_CERTCONF",
+    249108103308u64 => "ERROR_VALIDATING_PROTECTION",
+    249108103339u64 => "ERROR_VALIDATING_SIGNATURE",
+    249108103332u64 => "FAILED_BUILDING_OWN_CHAIN",
+    249108103309u64 => "FAILED_EXTRACTING_PUBKEY",
+    249108103278u64 => "FAILURE_OBTAINING_RANDOM",
+    249108103297u64 => "FAIL_INFO_OUT_OF_RANGE",
+    249108103268u64 => "INVALID_ARGS",
+    249108103342u64 => "INVALID_OPTION",
+    249108103333u64 => "MISSING_CERTID",
+    249108103298u64 => "MISSING_KEY_INPUT_FOR_CREATING_PROTECTION",
+    249108103310u64 => "MISSING_KEY_USAGE_DIGITALSIGNATURE",
+    249108103289u64 => "MISSING_P10CSR",
+    249108103334u64 => "MISSING_PBM_SECRET",
+    249108103299u64 => "MISSING_PRIVATE_KEY",
+    249108103358u64 => "MISSING_PRIVATE_KEY_FOR_POPO",
+    249108103311u64 => "MISSING_PROTECTION",
+    249108103351u64 => "MISSING_PUBLIC_KEY",
+    249108103336u64 => "MISSING_REFERENCE_CERT",
+    249108103346u64 => "MISSING_SECRET",
+    249108103279u64 => "MISSING_SENDER_IDENTIFICATION",
+    249108103347u64 => "MISSING_TRUST_ANCHOR",
+    249108103312u64 => "MISSING_TRUST_STORE",
+    249108103329u64 => "MULTIPLE_REQUESTS_NOT_SUPPORTED",
+    249108103338u64 => "MULTIPLE_RESPONSES_NOT_SUPPORTED",
+    249108103270u64 => "MULTIPLE_SAN_SOURCES",
+    249108103362u64 => "NO_STDIO",
+    249108103313u64 => "NO_SUITABLE_SENDER_CERT",
+    249108103271u64 => "NULL_ARGUMENT",
+    249108103314u64 => "PKIBODY_ERROR",
+    249108103300u64 => "PKISTATUSINFO_NOT_FOUND",
+    249108103340u64 => "POLLING_FAILED",
+    249108103315u64 => "POTENTIALLY_INVALID_CERTIFICATE",
+    249108103348u64 => "RECEIVED_ERROR",
+    249108103316u64 => "RECIPNONCE_UNMATCHED",
+    249108103317u64 => "REQUEST_NOT_ACCEPTED",
+    249108103350u64 => "REQUEST_REJECTED_BY_SERVER",
+    249108103318u64 => "SENDER_GENERALNAME_TYPE_NOT_SUPPORTED",
+    249108103319u64 => "SRVCERT_DOES_NOT_VALIDATE_MSG",
+    249108103352u64 => "TOTAL_TIMEOUT",
+    249108103320u64 => "TRANSACTIONID_UNMATCHED",
+    249108103327u64 => "TRANSFER_ERROR",
+    249108103301u64 => "UNEXPECTED_PKIBODY",
+    249108103353u64 => "UNEXPECTED_PKISTATUS",
+    249108103321u64 => "UNEXPECTED_PVNO",
+    249108103302u64 => "UNKNOWN_ALGORITHM_ID",
+    249108103303u64 => "UNKNOWN_CERT_TYPE",
+    249108103354u64 => "UNKNOWN_PKISTATUS",
+    249108103304u64 => "UNSUPPORTED_ALGORITHM",
+    249108103305u64 => "UNSUPPORTED_KEY_TYPE",
+    249108103322u64 => "UNSUPPORTED_PROTECTION_ALG_DHBASEDMAC",
+    249108103343u64 => "VALUE_TOO_LARGE",
+    249108103345u64 => "VALUE_TOO_SMALL",
+    249108103306u64 => "WRONG_ALGORITHM_OID",
+    249108103357u64 => "WRONG_CERTID",
+    249108103355u64 => "WRONG_CERTID_IN_RP",
+    249108103323u64 => "WRONG_PBM_VALUE",
+    249108103356u64 => "WRONG_RP_COMPONENT_COUNT",
+    249108103341u64 => "WRONG_SERIAL_IN_RP",
+    197568495715u64 => "ADD_SIGNER_ERROR",
+    197568495777u64 => "ATTRIBUTE_ERROR",
+    197568495791u64 => "CERTIFICATE_ALREADY_PRESENT",
+    197568495776u64 => "CERTIFICATE_HAS_NO_KEYID",
+    197568495716u64 => "CERTIFICATE_VERIFY_ERROR",
+    197568495800u64 => "CIPHER_AEAD_SET_TAG_ERROR",
+    197568495801u64 => "CIPHER_GET_TAG",
+    197568495717u64 => "CIPHER_INITIALISATION_ERROR",
+    197568495718u64 => "CIPHER_PARAMETER_INITIALISATION_ERROR",
+    197568495719u64 => "CMS_DATAFINAL_ERROR",
+    197568495720u64 => "CMS_LIB",
+    197568495786u64 => "CONTENTIDENTIFIER_MISMATCH",
+    197568495721u64 => "CONTENT_NOT_FOUND",
+    197568495787u64 => "CONTENT_TYPE_MISMATCH",
+    197568495722u64 => "CONTENT_TYPE_NOT_COMPRESSED_DATA",
+    197568495723u64 => "CONTENT_TYPE_NOT_ENVELOPED_DATA",
+    197568495724u64 => "CONTENT_TYPE_NOT_SIGNED_DATA",
+    197568495725u64 => "CONTENT_VERIFY_ERROR",
+    197568495726u64 => "CTRL_ERROR",
+    197568495727u64 => "CTRL_FAILURE",
+    197568495803u64 => "DECODE_ERROR",
+    197568495728u64 => "DECRYPT_ERROR",
+    197568495729u64 => "ERROR_GETTING_PUBLIC_KEY",
+    197568495730u64 => "ERROR_READING_MESSAGEDIGEST_ATTRIBUTE",
+    197568495731u64 => "ERROR_SETTING_KEY",
+    197568495732u64 => "ERROR_SETTING_RECIPIENTINFO",
+    197568495799u64 => "ESS_SIGNING_CERTID_MISMATCH_ERROR",
+    197568495733u64 => "INVALID_ENCRYPTED_KEY_LENGTH",
+    197568495792u64 => "INVALID_KEY_ENCRYPTION_PARAMETER",
+    197568495734u64 => "INVALID_KEY_LENGTH",
+    197568495806u64 => "INVALID_LABEL",
+    197568495807u64 => "INVALID_OAEP_PARAMETERS",
+    197568495802u64 => "KDF_PARAMETER_ERROR",
+    197568495735u64 => "MD_BIO_INIT_ERROR",
+    197568495736u64 => "MESSAGEDIGEST_ATTRIBUTE_WRONG_LENGTH",
+    197568495737u64 => "MESSAGEDIGEST_WRONG_LENGTH",
+    197568495788u64 => "MSGSIGDIGEST_ERROR",
+    197568495778u64 => "MSGSIGDIGEST_VERIFICATION_FAILURE",
+    197568495779u64 => "MSGSIGDIGEST_WRONG_LENGTH",
+    197568495780u64 => "NEED_ONE_SIGNER",
+    197568495781u64 => "NOT_A_SIGNED_RECEIPT",
+    197568495738u64 => "NOT_ENCRYPTED_DATA",
+    197568495739u64 => "NOT_KEK",
+    197568495797u64 => "NOT_KEY_AGREEMENT",
+    197568495740u64 => "NOT_KEY_TRANSPORT",
+    197568495793u64 => "NOT_PWRI",
+    197568495741u64 => "NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    197568495742u64 => "NO_CIPHER",
+    197568495743u64 => "NO_CONTENT",
+    197568495789u64 => "NO_CONTENT_TYPE",
+    197568495744u64 => "NO_DEFAULT_DIGEST",
+    197568495745u64 => "NO_DIGEST_SET",
+    197568495746u64 => "NO_KEY",
+    197568495790u64 => "NO_KEY_OR_CERT",
+    197568495747u64 => "NO_MATCHING_DIGEST",
+    197568495748u64 => "NO_MATCHING_RECIPIENT",
+    197568495782u64 => "NO_MATCHING_SIGNATURE",
+    197568495783u64 => "NO_MSGSIGDIGEST",
+    197568495794u64 => "NO_PASSWORD",
+    197568495749u64 => "NO_PRIVATE_KEY",
+    197568495750u64 => "NO_PUBLIC_KEY",
+    197568495784u64 => "NO_RECEIPT_REQUEST",
+    197568495751u64 => "NO_SIGNERS",
+    197568495804u64 => "PEER_KEY_ERROR",
+    197568495752u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    197568495785u64 => "RECEIPT_DECODE_ERROR",
+    197568495753u64 => "RECIPIENT_ERROR",
+    197568495805u64 => "SHARED_INFO_ERROR",
+    197568495754u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    197568495755u64 => "SIGNFINAL_ERROR",
+    197568495756u64 => "SMIME_TEXT_ERROR",
+    197568495757u64 => "STORE_INIT_ERROR",
+    197568495758u64 => "TYPE_NOT_COMPRESSED_DATA",
+    197568495759u64 => "TYPE_NOT_DATA",
+    197568495760u64 => "TYPE_NOT_DIGESTED_DATA",
+    197568495761u64 => "TYPE_NOT_ENCRYPTED_DATA",
+    197568495762u64 => "TYPE_NOT_ENVELOPED_DATA",
+    197568495763u64 => "UNABLE_TO_FINALIZE_CONTEXT",
+    197568495764u64 => "UNKNOWN_CIPHER",
+    197568495765u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    197568495766u64 => "UNKNOWN_ID",
+    197568495767u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    197568495810u64 => "UNSUPPORTED_CONTENT_ENCRYPTION_ALGORITHM",
+    197568495768u64 => "UNSUPPORTED_CONTENT_TYPE",
+    197568495808u64 => "UNSUPPORTED_ENCRYPTION_TYPE",
+    197568495769u64 => "UNSUPPORTED_KEK_ALGORITHM",
+    197568495795u64 => "UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM",
+    197568495809u64 => "UNSUPPORTED_LABEL_SOURCE",
+    197568495771u64 => "UNSUPPORTED_RECIPIENTINFO_TYPE",
+    197568495770u64 => "UNSUPPORTED_RECIPIENT_TYPE",
+    197568495811u64 => "UNSUPPORTED_SIGNATURE_ALGORITHM",
+    197568495772u64 => "UNSUPPORTED_TYPE",
+    197568495773u64 => "UNWRAP_ERROR",
+    197568495796u64 => "UNWRAP_FAILURE",
+    197568495774u64 => "VERIFICATION_FAILURE",
+    197568495775u64 => "WRAP_ERROR",
+    176093659235u64 => "ZLIB_DEFLATE_ERROR",
+    176093659236u64 => "ZLIB_INFLATE_ERROR",
+    176093659237u64 => "ZLIB_NOT_SUPPORTED",
+    60129542254u64 => "ERROR_LOADING_DSO",
+    60129542266u64 => "INVALID_PRAGMA",
+    60129542259u64 => "LIST_CANNOT_BE_NULL",
+    60129542267u64 => "MANDATORY_BRACES_IN_VARIABLE_EXPANSION",
+    60129542244u64 => "MISSING_CLOSE_SQUARE_BRACKET",
+    60129542245u64 => "MISSING_EQUAL_SIGN",
+    60129542256u64 => "MISSING_INIT_FUNCTION",
+    60129542253u64 => "MODULE_INITIALIZATION_ERROR",
+    60129542246u64 => "NO_CLOSE_BRACE",
+    60129542249u64 => "NO_CONF",
+    60129542250u64 => "NO_CONF_OR_ENVIRONMENT_VARIABLE",
+    60129542251u64 => "NO_SECTION",
+    60129542258u64 => "NO_SUCH_FILE",
+    60129542252u64 => "NO_VALUE",
+    60129542265u64 => "NUMBER_TOO_LARGE",
+    60129542268u64 => "OPENSSL_CONF_REFERENCES_MISSING_SECTION",
+    60129542255u64 => "RECURSIVE_DIRECTORY_INCLUDE",
+    60129542270u64 => "RECURSIVE_SECTION_REFERENCE",
+    60129542269u64 => "RELATIVE_PATH",
+    60129542261u64 => "SSL_COMMAND_SECTION_EMPTY",
+    60129542262u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    60129542263u64 => "SSL_SECTION_EMPTY",
+    60129542264u64 => "SSL_SECTION_NOT_FOUND",
+    60129542247u64 => "UNABLE_TO_CREATE_NEW_SECTION",
+    60129542257u64 => "UNKNOWN_MODULE_NAME",
+    60129542260u64 => "VARIABLE_EXPANSION_TOO_LONG",
+    60129542248u64 => "VARIABLE_HAS_NO_VALUE",
+    240518168676u64 => "BAD_PBM_ITERATIONCOUNT",
+    240518168678u64 => "CRMFERROR",
+    240518168679u64 => "ERROR",
+    240518168680u64 => "ERROR_DECODING_CERTIFICATE",
+    240518168681u64 => "ERROR_DECRYPTING_CERTIFICATE",
+    240518168682u64 => "ERROR_DECRYPTING_SYMMETRIC_KEY",
+    240518168683u64 => "FAILURE_OBTAINING_RANDOM",
+    240518168684u64 => "ITERATIONCOUNT_BELOW_100",
+    240518168677u64 => "MALFORMED_IV",
+    240518168685u64 => "NULL_ARGUMENT",
+    240518168689u64 => "POPOSKINPUT_NOT_SUPPORTED",
+    240518168693u64 => "POPO_INCONSISTENT_PUBLIC_KEY",
+    240518168697u64 => "POPO_MISSING",
+    240518168694u64 => "POPO_MISSING_PUBLIC_KEY",
+    240518168695u64 => "POPO_MISSING_SUBJECT",
+    240518168696u64 => "POPO_RAVERIFIED_NOT_ACCEPTED",
+    240518168686u64 => "SETTING_MAC_ALGOR_FAILURE",
+    240518168687u64 => "SETTING_OWF_ALGOR_FAILURE",
+    240518168688u64 => "UNSUPPORTED_ALGORITHM",
+    240518168690u64 => "UNSUPPORTED_CIPHER",
+    240518168691u64 => "UNSUPPORTED_METHOD_FOR_CREATING_POPO",
+    240518168692u64 => "UNSUPPORTED_POPO_METHOD",
+    64424509557u64 => "BAD_ALGORITHM_NAME",
+    64424509558u64 => "CONFLICTING_NAMES",
+    64424509561u64 => "HEX_STRING_TOO_SHORT",
+    64424509542u64 => "ILLEGAL_HEX_DIGIT",
+    64424509546u64 => "INSUFFICIENT_DATA_SPACE",
+    64424509547u64 => "INSUFFICIENT_PARAM_SIZE",
+    64424509548u64 => "INSUFFICIENT_SECURE_DATA_SPACE",
+    64424509567u64 => "INTEGER_OVERFLOW",
+    64424509562u64 => "INVALID_NEGATIVE_VALUE",
+    64424509549u64 => "INVALID_NULL_ARGUMENT",
+    64424509550u64 => "INVALID_OSSL_PARAM_TYPE",
+    64424509571u64 => "NO_PARAMS_TO_MERGE",
+    64424509568u64 => "NO_SPACE_FOR_TERMINATING_NULL",
+    64424509543u64 => "ODD_NUMBER_OF_DIGITS",
+    64424509563u64 => "PARAM_CANNOT_BE_REPRESENTED_EXACTLY",
+    64424509564u64 => "PARAM_NOT_INTEGER_TYPE",
+    64424509569u64 => "PARAM_OF_INCOMPATIBLE_TYPE",
+    64424509565u64 => "PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED",
+    64424509570u64 => "PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT",
+    64424509566u64 => "PARAM_VALUE_TOO_LARGE_FOR_DESTINATION",
+    64424509544u64 => "PROVIDER_ALREADY_EXISTS",
+    64424509545u64 => "PROVIDER_SECTION_ERROR",
+    64424509559u64 => "RANDOM_SECTION_ERROR",
+    64424509551u64 => "SECURE_MALLOC_FAILURE",
+    64424509552u64 => "STRING_TOO_LONG",
+    64424509553u64 => "TOO_MANY_BYTES",
+    64424509554u64 => "TOO_MANY_RECORDS",
+    64424509556u64 => "TOO_SMALL_BUFFER",
+    64424509560u64 => "UNKNOWN_NAME_IN_RANDOM_SECTION",
+    64424509555u64 => "ZERO_LENGTH_NUMBER",
+    214748364908u64 => "BASE64_DECODE_ERROR",
+    214748364900u64 => "INVALID_LOG_ID_LENGTH",
+    214748364909u64 => "LOG_CONF_INVALID",
+    214748364910u64 => "LOG_CONF_INVALID_KEY",
+    214748364911u64 => "LOG_CONF_MISSING_DESCRIPTION",
+    214748364912u64 => "LOG_CONF_MISSING_KEY",
+    214748364913u64 => "LOG_KEY_INVALID",
+    214748364916u64 => "SCT_FUTURE_TIMESTAMP",
+    214748364904u64 => "SCT_INVALID",
+    214748364907u64 => "SCT_INVALID_SIGNATURE",
+    214748364905u64 => "SCT_LIST_INVALID",
+    214748364914u64 => "SCT_LOG_ID_MISMATCH",
+    214748364906u64 => "SCT_NOT_SET",
+    214748364915u64 => "SCT_UNSUPPORTED_VERSION",
+    214748364901u64 => "UNRECOGNIZED_SIGNATURE_NID",
+    214748364902u64 => "UNSUPPORTED_ENTRY_TYPE",
+    214748364903u64 => "UNSUPPORTED_VERSION",
+    21474836607u64 => "BAD_FFC_PARAMETERS",
+    21474836581u64 => "BAD_GENERATOR",
+    21474836589u64 => "BN_DECODE_ERROR",
+    21474836586u64 => "BN_ERROR",
+    21474836595u64 => "CHECK_INVALID_J_VALUE",
+    21474836596u64 => "CHECK_INVALID_Q_VALUE",
+    21474836602u64 => "CHECK_PUBKEY_INVALID",
+    21474836603u64 => "CHECK_PUBKEY_TOO_LARGE",
+    21474836604u64 => "CHECK_PUBKEY_TOO_SMALL",
+    21474836597u64 => "CHECK_P_NOT_PRIME",
+    21474836598u64 => "CHECK_P_NOT_SAFE_PRIME",
+    21474836599u64 => "CHECK_Q_NOT_PRIME",
+    21474836584u64 => "DECODE_ERROR",
+    21474836590u64 => "INVALID_PARAMETER_NAME",
+    21474836594u64 => "INVALID_PARAMETER_NID",
+    21474836582u64 => "INVALID_PUBKEY",
+    21474836608u64 => "INVALID_SECRET",
+    21474836592u64 => "KDF_PARAMETER_ERROR",
+    21474836588u64 => "KEYS_NOT_SET",
+    21474836605u64 => "MISSING_PUBKEY",
+    21474836583u64 => "MODULUS_TOO_LARGE",
+    21474836606u64 => "MODULUS_TOO_SMALL",
+    21474836600u64 => "NOT_SUITABLE_GENERATOR",
+    21474836587u64 => "NO_PARAMETERS_SET",
+    21474836580u64 => "NO_PRIVATE_VALUE",
+    21474836585u64 => "PARAMETER_ENCODING_ERROR",
+    21474836591u64 => "PEER_KEY_ERROR",
+    21474836610u64 => "Q_TOO_LARGE",
+    21474836593u64 => "SHARED_INFO_ERROR",
+    21474836601u64 => "UNABLE_TO_CHECK_GENERATOR",
+    42949673074u64 => "BAD_FFC_PARAMETERS",
+    42949673062u64 => "BAD_Q_VALUE",
+    42949673068u64 => "BN_DECODE_ERROR",
+    42949673069u64 => "BN_ERROR",
+    42949673064u64 => "DECODE_ERROR",
+    42949673066u64 => "INVALID_DIGEST_TYPE",
+    42949673072u64 => "INVALID_PARAMETERS",
+    42949673061u64 => "MISSING_PARAMETERS",
+    42949673071u64 => "MISSING_PRIVATE_KEY",
+    42949673063u64 => "MODULUS_TOO_LARGE",
+    42949673067u64 => "NO_PARAMETERS_SET",
+    42949673065u64 => "PARAMETER_ENCODING_ERROR",
+    42949673075u64 => "P_NOT_PRIME",
+    42949673073u64 => "Q_NOT_PRIME",
+    42949673070u64 => "SEED_LEN_SMALL",
+    42949673076u64 => "TOO_MANY_RETRIES",
+    158913790052u64 => "CTRL_FAILED",
+    158913790062u64 => "DSO_ALREADY_LOADED",
+    158913790065u64 => "EMPTY_FILE_STRUCTURE",
+    158913790066u64 => "FAILURE",
+    158913790053u64 => "FILENAME_TOO_BIG",
+    158913790054u64 => "FINISH_FAILED",
+    158913790067u64 => "INCORRECT_FILE_SYNTAX",
+    158913790055u64 => "LOAD_FAILED",
+    158913790061u64 => "NAME_TRANSLATION_FAILED",
+    158913790063u64 => "NO_FILENAME",
+    158913790056u64 => "NULL_HANDLE",
+    158913790064u64 => "SET_FILENAME_FAILED",
+    158913790057u64 => "STACK_ERROR",
+    158913790058u64 => "SYM_FAILURE",
+    158913790059u64 => "UNLOAD_FAILED",
+    158913790060u64 => "UNSUPPORTED",
+    68719476851u64 => "ASN1_ERROR",
+    68719476892u64 => "BAD_SIGNATURE",
+    68719476880u64 => "BIGNUM_OUT_OF_RANGE",
+    68719476836u64 => "BUFFER_TOO_SMALL",
+    68719476901u64 => "CANNOT_INVERT",
+    68719476882u64 => "COORDINATES_OUT_OF_RANGE",
+    68719476896u64 => "CURVE_DOES_NOT_SUPPORT_ECDH",
+    68719476906u64 => "CURVE_DOES_NOT_SUPPORT_ECDSA",
+    68719476895u64 => "CURVE_DOES_NOT_SUPPORT_SIGNING",
+    68719476878u64 => "DECODE_ERROR",
+    68719476854u64 => "DISCRIMINANT_IS_ZERO",
+    68719476855u64 => "EC_GROUP_NEW_BY_NAME_FAILURE",
+    68719476863u64 => "EXPLICIT_PARAMS_NOT_SUPPORTED",
+    68719476902u64 => "FAILED_MAKING_PUBLIC_KEY",
+    68719476879u64 => "FIELD_TOO_LARGE",
+    68719476883u64 => "GF2M_NOT_SUPPORTED",
+    68719476856u64 => "GROUP2PKPARAMETERS_FAILURE",
+    68719476857u64 => "I2D_ECPKPARAMETERS_FAILURE",
+    68719476837u64 => "INCOMPATIBLE_OBJECTS",
+    68719476904u64 => "INVALID_A",
+    68719476848u64 => "INVALID_ARGUMENT",
+    68719476905u64 => "INVALID_B",
+    68719476907u64 => "INVALID_COFACTOR",
+    68719476846u64 => "INVALID_COMPRESSED_POINT",
+    68719476845u64 => "INVALID_COMPRESSION_BIT",
+    68719476877u64 => "INVALID_CURVE",
+    68719476887u64 => "INVALID_DIGEST",
+    68719476874u64 => "INVALID_DIGEST_TYPE",
+    68719476838u64 => "INVALID_ENCODING",
+    68719476839u64 => "INVALID_FIELD",
+    68719476840u64 => "INVALID_FORM",
+    68719476909u64 => "INVALID_GENERATOR",
+    68719476858u64 => "INVALID_GROUP_ORDER",
+    68719476852u64 => "INVALID_KEY",
+    68719476853u64 => "INVALID_LENGTH",
+    68719476910u64 => "INVALID_NAMED_GROUP_CONVERSION",
+    68719476897u64 => "INVALID_OUTPUT_LENGTH",
+    68719476908u64 => "INVALID_P",
+    68719476869u64 => "INVALID_PEER_KEY",
+    68719476868u64 => "INVALID_PENTANOMIAL_BASIS",
+    68719476859u64 => "INVALID_PRIVATE_KEY",
+    68719476911u64 => "INVALID_SEED",
+    68719476873u64 => "INVALID_TRINOMIAL_BASIS",
+    68719476884u64 => "KDF_PARAMETER_ERROR",
+    68719476876u64 => "KEYS_NOT_SET",
+    68719476872u64 => "LADDER_POST_FAILURE",
+    68719476889u64 => "LADDER_PRE_FAILURE",
+    68719476898u64 => "LADDER_STEP_FAILURE",
+    68719476903u64 => "MISSING_OID",
+    68719476860u64 => "MISSING_PARAMETERS",
+    68719476861u64 => "MISSING_PRIVATE_KEY",
+    68719476893u64 => "NEED_NEW_SETUP_VALUES",
+    68719476871u64 => "NOT_A_NIST_PRIME",
+    68719476862u64 => "NOT_IMPLEMENTED",
+    68719476847u64 => "NOT_INITIALIZED",
+    68719476875u64 => "NO_PARAMETERS_SET",
+    68719476890u64 => "NO_PRIVATE_VALUE",
+    68719476888u64 => "OPERATION_NOT_SUPPORTED",
+    68719476870u64 => "PASSED_NULL_PARAMETER",
+    68719476885u64 => "PEER_KEY_ERROR",
+    68719476891u64 => "POINT_ARITHMETIC_FAILURE",
+    68719476842u64 => "POINT_AT_INFINITY",
+    68719476899u64 => "POINT_COORDINATES_BLIND_FAILURE",
+    68719476843u64 => "POINT_IS_NOT_ON_CURVE",
+    68719476894u64 => "RANDOM_NUMBER_GENERATION_FAILED",
+    68719476886u64 => "SHARED_INFO_ERROR",
+    68719476844u64 => "SLOT_FULL",
+    68719476912u64 => "TOO_MANY_RETRIES",
+    68719476849u64 => "UNDEFINED_GENERATOR",
+    68719476864u64 => "UNDEFINED_ORDER",
+    68719476900u64 => "UNKNOWN_COFACTOR",
+    68719476865u64 => "UNKNOWN_GROUP",
+    68719476850u64 => "UNKNOWN_ORDER",
+    68719476867u64 => "UNSUPPORTED_FIELD",
+    68719476881u64 => "WRONG_CURVE_PARAMETERS",
+    68719476866u64 => "WRONG_ORDER",
+    163208757348u64 => "ALREADY_LOADED",
+    163208757381u64 => "ARGUMENT_IS_NOT_A_NUMBER",
+    163208757382u64 => "CMD_NOT_EXECUTABLE",
+    163208757383u64 => "COMMAND_TAKES_INPUT",
+    163208757384u64 => "COMMAND_TAKES_NO_INPUT",
+    163208757351u64 => "CONFLICTING_ENGINE_ID",
+    163208757367u64 => "CTRL_COMMAND_NOT_IMPLEMENTED",
+    163208757352u64 => "DSO_FAILURE",
+    163208757380u64 => "DSO_NOT_FOUND",
+    163208757396u64 => "ENGINES_SECTION_ERROR",
+    163208757350u64 => "ENGINE_CONFIGURATION_ERROR",
+    163208757353u64 => "ENGINE_IS_NOT_IN_LIST",
+    163208757397u64 => "ENGINE_SECTION_ERROR",
+    163208757376u64 => "FAILED_LOADING_PRIVATE_KEY",
+    163208757377u64 => "FAILED_LOADING_PUBLIC_KEY",
+    163208757354u64 => "FINISH_FAILED",
+    163208757356u64 => "ID_OR_NAME_MISSING",
+    163208757357u64 => "INIT_FAILED",
+    163208757358u64 => "INTERNAL_LIST_ERROR",
+    163208757391u64 => "INVALID_ARGUMENT",
+    163208757385u64 => "INVALID_CMD_NAME",
+    163208757386u64 => "INVALID_CMD_NUMBER",
+    163208757399u64 => "INVALID_INIT_VALUE",
+    163208757398u64 => "INVALID_STRING",
+    163208757365u64 => "NOT_INITIALISED",
+    163208757360u64 => "NOT_LOADED",
+    163208757368u64 => "NO_CONTROL_FUNCTION",
+    163208757392u64 => "NO_INDEX",
+    163208757373u64 => "NO_LOAD_FUNCTION",
+    163208757378u64 => "NO_REFERENCE",
+    163208757364u64 => "NO_SUCH_ENGINE",
+    163208757394u64 => "UNIMPLEMENTED_CIPHER",
+    163208757395u64 => "UNIMPLEMENTED_DIGEST",
+    163208757349u64 => "UNIMPLEMENTED_PUBLIC_KEY_METHOD",
+    163208757393u64 => "VERSION_INCOMPATIBILITY",
+    231928234091u64 => "EMPTY_ESS_CERT_ID_LIST",
+    231928234087u64 => "ESS_CERT_DIGEST_ERROR",
+    231928234088u64 => "ESS_CERT_ID_NOT_FOUND",
+    231928234089u64 => "ESS_CERT_ID_WRONG_ORDER",
+    231928234090u64 => "ESS_DIGEST_ALG_UNKNOWN",
+    231928234086u64 => "ESS_SIGNING_CERTIFICATE_ERROR",
+    231928234084u64 => "ESS_SIGNING_CERT_ADD_ERROR",
+    231928234085u64 => "ESS_SIGNING_CERT_V2_ADD_ERROR",
+    231928234092u64 => "MISSING_SIGNING_CERTIFICATE_ATTRIBUTE",
+    25769803919u64 => "AES_KEY_SETUP_FAILED",
+    25769803952u64 => "ARIA_KEY_SETUP_FAILED",
+    25769803976u64 => "BAD_ALGORITHM_NAME",
+    25769803876u64 => "BAD_DECRYPT",
+    25769803971u64 => "BAD_KEY_LENGTH",
+    25769803931u64 => "BUFFER_TOO_SMALL",
+    25769804001u64 => "CACHE_CONSTANTS_FAILED",
+    25769803933u64 => "CAMELLIA_KEY_SETUP_FAILED",
+    25769803973u64 => "CANNOT_GET_PARAMETERS",
+    25769803974u64 => "CANNOT_SET_PARAMETERS",
+    25769803960u64 => "CIPHER_NOT_GCM_MODE",
+    25769803898u64 => "CIPHER_PARAMETER_ERROR",
+    25769803923u64 => "COMMAND_NOT_SUPPORTED",
+    25769803977u64 => "CONFLICTING_ALGORITHM_NAME",
+    25769803949u64 => "COPY_ERROR",
+    25769803908u64 => "CTRL_NOT_IMPLEMENTED",
+    25769803909u64 => "CTRL_OPERATION_NOT_IMPLEMENTED",
+    25769803914u64 => "DATA_NOT_MULTIPLE_OF_BLOCK_LENGTH",
+    25769803890u64 => "DECODE_ERROR",
+    25769803986u64 => "DEFAULT_QUERY_PARSE_ERROR",
+    25769803877u64 => "DIFFERENT_KEY_TYPES",
+    25769803929u64 => "DIFFERENT_PARAMETERS",
+    25769803941u64 => "ERROR_LOADING_SECTION",
+    25769803950u64 => "EXPECTING_AN_HMAC_KEY",
+    25769803903u64 => "EXPECTING_AN_RSA_KEY",
+    25769803904u64 => "EXPECTING_A_DH_KEY",
+    25769803905u64 => "EXPECTING_A_DSA_KEY",
+    25769803995u64 => "EXPECTING_A_ECX_KEY",
+    25769803918u64 => "EXPECTING_A_EC_KEY",
+    25769803940u64 => "EXPECTING_A_POLY1305_KEY",
+    25769803951u64 => "EXPECTING_A_SIPHASH_KEY",
+    25769803964u64 => "FINAL_ERROR",
+    25769803990u64 => "GENERATE_ERROR",
+    25769803958u64 => "GET_RAW_KEY_FAILED",
+    25769803947u64 => "ILLEGAL_SCRYPT_PARAMETERS",
+    25769803980u64 => "INACCESSIBLE_DOMAIN_PARAMETERS",
+    25769803979u64 => "INACCESSIBLE_KEY",
+    25769803910u64 => "INITIALIZATION_ERROR",
+    25769803887u64 => "INPUT_NOT_INITIALIZED",
+    25769803961u64 => "INVALID_CUSTOM_LENGTH",
+    25769803928u64 => "INVALID_DIGEST",
+    25769803970u64 => "INVALID_IV_LENGTH",
+    25769803939u64 => "INVALID_KEY",
+    25769803906u64 => "INVALID_KEY_LENGTH",
+    25769803997u64 => "INVALID_LENGTH",
+    25769803994u64 => "INVALID_NULL_ALGORITHM",
+    25769803924u64 => "INVALID_OPERATION",
+    25769803969u64 => "INVALID_PROVIDER_FUNCTIONS",
+    25769803962u64 => "INVALID_SALT_LENGTH",
+    25769803999u64 => "INVALID_SECRET_LENGTH",
+    25769803996u64 => "INVALID_SEED_LENGTH",
+    25769803998u64 => "INVALID_VALUE",
+    25769803981u64 => "KEYMGMT_EXPORT_FAILURE",
+    25769803956u64 => "KEY_SETUP_FAILED",
+    25769803989u64 => "LOCKING_NOT_SUPPORTED",
+    25769803948u64 => "MEMORY_LIMIT_EXCEEDED",
+    25769803935u64 => "MESSAGE_DIGEST_IS_NULL",
+    25769803920u64 => "METHOD_NOT_SUPPORTED",
+    25769803879u64 => "MISSING_PARAMETERS",
+    25769803966u64 => "NOT_ABLE_TO_COPY_CTX",
+    25769803954u64 => "NOT_XOF_OR_INVALID_LENGTH",
+    25769803907u64 => "NO_CIPHER_SET",
+    25769803934u64 => "NO_DEFAULT_DIGEST",
+    25769803915u64 => "NO_DIGEST_SET",
+    25769803982u64 => "NO_IMPORT_FUNCTION",
+    25769803975u64 => "NO_KEYMGMT_AVAILABLE",
+    25769803972u64 => "NO_KEYMGMT_PRESENT",
+    25769803930u64 => "NO_KEY_SET",
+    25769803925u64 => "NO_OPERATION_SET",
+    25769803984u64 => "NULL_MAC_PKEY_CTX",
+    25769803953u64 => "ONLY_ONESHOT_SUPPORTED",
+    25769803927u64 => "OPERATION_NOT_INITIALIZED",
+    25769803926u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    25769803978u64 => "OUTPUT_WOULD_OVERFLOW",
+    25769803963u64 => "PARAMETER_TOO_LARGE",
+    25769803938u64 => "PARTIALLY_OVERLAPPING",
+    25769803957u64 => "PBKDF2_ERROR",
+    25769803955u64 => "PKEY_APPLICATION_ASN1_METHOD_ALREADY_REGISTERED",
+    25769803921u64 => "PRIVATE_KEY_DECODE_ERROR",
+    25769803922u64 => "PRIVATE_KEY_ENCODE_ERROR",
+    25769803882u64 => "PUBLIC_KEY_NOT_RSA",
+    25769804003u64 => "SETTING_XOF_FAILED",
+    25769803985u64 => "SET_DEFAULT_PROPERTY_FAILURE",
+    25769803959u64 => "TOO_MANY_RECORDS",
+    25769803988u64 => "UNABLE_TO_ENABLE_LOCKING",
+    25769803991u64 => "UNABLE_TO_GET_MAXIMUM_REQUEST_SIZE",
+    25769803992u64 => "UNABLE_TO_GET_RANDOM_STRENGTH",
+    25769803987u64 => "UNABLE_TO_LOCK_CONTEXT",
+    25769803993u64 => "UNABLE_TO_SET_CALLBACKS",
+    25769803936u64 => "UNKNOWN_CIPHER",
+    25769803937u64 => "UNKNOWN_DIGEST",
+    25769803983u64 => "UNKNOWN_KEY_TYPE",
+    25769803945u64 => "UNKNOWN_OPTION",
+    25769803897u64 => "UNKNOWN_PBE_ALGORITHM",
+    25769803932u64 => "UNSUPPORTED_ALGORITHM",
+    25769803883u64 => "UNSUPPORTED_CIPHER",
+    25769803899u64 => "UNSUPPORTED_KEYLENGTH",
+    25769803900u64 => "UNSUPPORTED_KEY_DERIVATION_FUNCTION",
+    25769803884u64 => "UNSUPPORTED_KEY_SIZE",
+    25769804000u64 => "UNSUPPORTED_KEY_TYPE",
+    25769803911u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS",
+    25769803901u64 => "UNSUPPORTED_PRF",
+    25769803894u64 => "UNSUPPORTED_PRIVATE_KEY_ALGORITHM",
+    25769803902u64 => "UNSUPPORTED_SALT_TYPE",
+    25769803965u64 => "UPDATE_ERROR",
+    25769803946u64 => "WRAP_MODE_NOT_ALLOWED",
+    25769803885u64 => "WRONG_FINAL_BLOCK_LENGTH",
+    25769803967u64 => "XTS_DATA_UNIT_IS_TOO_LARGE",
+    25769803968u64 => "XTS_DUPLICATED_KEYS",
+    261993005164u64 => "ASN1_LEN_EXCEEDS_MAX_RESP_LEN",
+    261993005156u64 => "CONNECT_FAILURE",
+    261993005165u64 => "ERROR_PARSING_ASN1_LENGTH",
+    261993005175u64 => "ERROR_PARSING_CONTENT_LENGTH",
+    261993005157u64 => "ERROR_PARSING_URL",
+    261993005159u64 => "ERROR_RECEIVING",
+    261993005158u64 => "ERROR_SENDING",
+    261993005184u64 => "FAILED_READING_DATA",
+    261993005182u64 => "HEADER_PARSE_ERROR",
+    261993005176u64 => "INCONSISTENT_CONTENT_LENGTH",
+    261993005179u64 => "INVALID_PORT_NUMBER",
+    261993005181u64 => "INVALID_URL_PATH",
+    261993005180u64 => "INVALID_URL_SCHEME",
+    261993005173u64 => "MAX_RESP_LEN_EXCEEDED",
+    261993005166u64 => "MISSING_ASN1_ENCODING",
+    261993005177u64 => "MISSING_CONTENT_TYPE",
+    261993005167u64 => "MISSING_REDIRECT_LOCATION",
+    261993005161u64 => "RECEIVED_ERROR",
+    261993005162u64 => "RECEIVED_WRONG_HTTP_VERSION",
+    261993005168u64 => "REDIRECTION_FROM_HTTPS_TO_HTTP",
+    261993005172u64 => "REDIRECTION_NOT_ENABLED",
+    261993005169u64 => "RESPONSE_LINE_TOO_LONG",
+    261993005160u64 => "RESPONSE_PARSE_ERROR",
+    261993005185u64 => "RETRY_TIMEOUT",
+    261993005183u64 => "SERVER_CANCELED_CONNECTION",
+    261993005178u64 => "SOCK_NOT_SUPPORTED",
+    261993005170u64 => "STATUS_CODE_UNSUPPORTED",
+    261993005163u64 => "TLS_NOT_ENABLED",
+    261993005171u64 => "TOO_MANY_REDIRECTIONS",
+    261993005174u64 => "UNEXPECTED_CONTENT_TYPE",
+    34359738470u64 => "OID_EXISTS",
+    34359738469u64 => "UNKNOWN_NID",
+    34359738471u64 => "UNKNOWN_OBJECT_NAME",
+    167503724645u64 => "CERTIFICATE_VERIFY_ERROR",
+    167503724646u64 => "DIGEST_ERR",
+    167503724650u64 => "DIGEST_NAME_ERR",
+    167503724651u64 => "DIGEST_SIZE_ERR",
+    167503724666u64 => "ERROR_IN_NEXTUPDATE_FIELD",
+    167503724667u64 => "ERROR_IN_THISUPDATE_FIELD",
+    167503724647u64 => "MISSING_OCSPSIGNING_USAGE",
+    167503724668u64 => "NEXTUPDATE_BEFORE_THISUPDATE",
+    167503724648u64 => "NOT_BASIC_RESPONSE",
+    167503724649u64 => "NO_CERTIFICATES_IN_CHAIN",
+    167503724652u64 => "NO_RESPONSE_DATA",
+    167503724653u64 => "NO_REVOKED_TIME",
+    167503724674u64 => "NO_SIGNER_KEY",
+    167503724654u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    167503724672u64 => "REQUEST_NOT_SIGNED",
+    167503724655u64 => "RESPONSE_CONTAINS_NO_REVOCATION_DATA",
+    167503724656u64 => "ROOT_CA_NOT_TRUSTED",
+    167503724661u64 => "SIGNATURE_FAILURE",
+    167503724662u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    167503724669u64 => "STATUS_EXPIRED",
+    167503724670u64 => "STATUS_NOT_YET_VALID",
+    167503724671u64 => "STATUS_TOO_OLD",
+    167503724663u64 => "UNKNOWN_MESSAGE_DIGEST",
+    167503724664u64 => "UNKNOWN_NID",
+    167503724673u64 => "UNSUPPORTED_REQUESTORNAME_TYPE",
+    257698037861u64 => "COULD_NOT_DECODE_OBJECT",
+    257698037862u64 => "DECODER_NOT_FOUND",
+    257698037860u64 => "MISSING_GET_PARAMS",
+    253403070565u64 => "ENCODER_NOT_FOUND",
+    253403070564u64 => "INCORRECT_PROPERTY_QUERY",
+    253403070566u64 => "MISSING_GET_PARAMS",
+    188978561131u64 => "AMBIGUOUS_CONTENT_TYPE",
+    188978561139u64 => "BAD_PASSWORD_READ",
+    188978561137u64 => "ERROR_VERIFYING_PKCS12_MAC",
+    188978561145u64 => "FINGERPRINT_SIZE_DOES_NOT_MATCH_DIGEST",
+    188978561130u64 => "INVALID_SCHEME",
+    188978561136u64 => "IS_NOT_A",
+    188978561140u64 => "LOADER_INCOMPLETE",
+    188978561141u64 => "LOADING_STARTED",
+    188978561124u64 => "NOT_A_CERTIFICATE",
+    188978561125u64 => "NOT_A_CRL",
+    188978561127u64 => "NOT_A_NAME",
+    188978561126u64 => "NOT_A_PRIVATE_KEY",
+    188978561146u64 => "NOT_A_PUBLIC_KEY",
+    188978561128u64 => "NOT_PARAMETERS",
+    188978561147u64 => "NO_LOADERS_FOUND",
+    188978561138u64 => "PASSPHRASE_CALLBACK_ERROR",
+    188978561132u64 => "PATH_MUST_BE_ABSOLUTE",
+    188978561143u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES",
+    188978561133u64 => "UI_PROCESS_INTERRUPTED_OR_CANCELLED",
+    188978561129u64 => "UNREGISTERED_SCHEME",
+    188978561134u64 => "UNSUPPORTED_CONTENT_TYPE",
+    188978561142u64 => "UNSUPPORTED_OPERATION",
+    188978561144u64 => "UNSUPPORTED_SEARCH_TYPE",
+    188978561135u64 => "URI_AUTHORITY_UNSUPPORTED",
+    38654705764u64 => "BAD_BASE64_DECODE",
+    38654705765u64 => "BAD_DECRYPT",
+    38654705766u64 => "BAD_END_LINE",
+    38654705767u64 => "BAD_IV_CHARS",
+    38654705780u64 => "BAD_MAGIC_NUMBER",
+    38654705768u64 => "BAD_PASSWORD_READ",
+    38654705781u64 => "BAD_VERSION_NUMBER",
+    38654705782u64 => "BIO_WRITE_FAILURE",
+    38654705791u64 => "CIPHER_IS_NULL",
+    38654705779u64 => "ERROR_CONVERTING_PRIVATE_KEY",
+    38654705795u64 => "EXPECTING_DSS_KEY_BLOB",
+    38654705783u64 => "EXPECTING_PRIVATE_KEY_BLOB",
+    38654705784u64 => "EXPECTING_PUBLIC_KEY_BLOB",
+    38654705796u64 => "EXPECTING_RSA_KEY_BLOB",
+    38654705792u64 => "HEADER_TOO_LONG",
+    38654705785u64 => "INCONSISTENT_HEADER",
+    38654705786u64 => "KEYBLOB_HEADER_PARSE_ERROR",
+    38654705787u64 => "KEYBLOB_TOO_SHORT",
+    38654705793u64 => "MISSING_DEK_IV",
+    38654705769u64 => "NOT_DEK_INFO",
+    38654705770u64 => "NOT_ENCRYPTED",
+    38654705771u64 => "NOT_PROC_TYPE",
+    38654705772u64 => "NO_START_LINE",
+    38654705773u64 => "PROBLEMS_GETTING_PASSWORD",
+    38654705788u64 => "PVK_DATA_TOO_SHORT",
+    38654705789u64 => "PVK_TOO_SHORT",
+    38654705775u64 => "READ_KEY",
+    38654705776u64 => "SHORT_HEADER",
+    38654705794u64 => "UNEXPECTED_DEK_IV",
+    38654705777u64 => "UNSUPPORTED_CIPHER",
+    38654705778u64 => "UNSUPPORTED_ENCRYPTION",
+    38654705790u64 => "UNSUPPORTED_KEY_COMPONENTS",
+    38654705774u64 => "UNSUPPORTED_PUBLIC_KEY_TYPE",
+    150323855460u64 => "CANT_PACK_STRUCTURE",
+    150323855481u64 => "CONTENT_TYPE_NOT_DATA",
+    150323855461u64 => "DECODE_ERROR",
+    150323855462u64 => "ENCODE_ERROR",
+    150323855463u64 => "ENCRYPT_ERROR",
+    150323855480u64 => "ERROR_SETTING_ENCRYPTED_DATA_TYPE",
+    150323855464u64 => "INVALID_NULL_ARGUMENT",
+    150323855465u64 => "INVALID_NULL_PKCS12_POINTER",
+    150323855472u64 => "INVALID_TYPE",
+    150323855466u64 => "IV_GEN_ERROR",
+    150323855467u64 => "KEY_GEN_ERROR",
+    150323855468u64 => "MAC_ABSENT",
+    150323855469u64 => "MAC_GENERATION_ERROR",
+    150323855470u64 => "MAC_SETUP_ERROR",
+    150323855471u64 => "MAC_STRING_SET_ERROR",
+    150323855473u64 => "MAC_VERIFY_FAILURE",
+    150323855474u64 => "PARSE_ERROR",
+    150323855476u64 => "PKCS12_CIPHERFINAL_ERROR",
+    150323855478u64 => "UNKNOWN_DIGEST_ALGORITHM",
+    150323855479u64 => "UNSUPPORTED_PKCS12_MODE",
+    141733920885u64 => "CERTIFICATE_VERIFY_ERROR",
+    141733920912u64 => "CIPHER_HAS_NO_OBJECT_IDENTIFIER",
+    141733920884u64 => "CIPHER_NOT_INITIALIZED",
+    141733920886u64 => "CONTENT_AND_DATA_PRESENT",
+    141733920920u64 => "CTRL_ERROR",
+    141733920887u64 => "DECRYPT_ERROR",
+    141733920869u64 => "DIGEST_FAILURE",
+    141733920917u64 => "ENCRYPTION_CTRL_FAILURE",
+    141733920918u64 => "ENCRYPTION_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920888u64 => "ERROR_ADDING_RECIPIENT",
+    141733920889u64 => "ERROR_SETTING_CIPHER",
+    141733920911u64 => "INVALID_NULL_POINTER",
+    141733920923u64 => "INVALID_SIGNED_DATA_TYPE",
+    141733920890u64 => "NO_CONTENT",
+    141733920919u64 => "NO_DEFAULT_DIGEST",
+    141733920922u64 => "NO_MATCHING_DIGEST_TYPE_FOUND",
+    141733920883u64 => "NO_RECIPIENT_MATCHES_CERTIFICATE",
+    141733920891u64 => "NO_SIGNATURES_ON_DATA",
+    141733920910u64 => "NO_SIGNERS",
+    141733920872u64 => "OPERATION_NOT_SUPPORTED_ON_THIS_TYPE",
+    141733920892u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    141733920921u64 => "PKCS7_ADD_SIGNER_ERROR",
+    141733920913u64 => "PKCS7_DATASIGN",
+    141733920895u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    141733920873u64 => "SIGNATURE_FAILURE",
+    141733920896u64 => "SIGNER_CERTIFICATE_NOT_FOUND",
+    141733920915u64 => "SIGNING_CTRL_FAILURE",
+    141733920916u64 => "SIGNING_NOT_SUPPORTED_FOR_THIS_KEY_TYPE",
+    141733920897u64 => "SMIME_TEXT_ERROR",
+    141733920874u64 => "UNABLE_TO_FIND_CERTIFICATE",
+    141733920875u64 => "UNABLE_TO_FIND_MEM_BIO",
+    141733920876u64 => "UNABLE_TO_FIND_MESSAGE_DIGEST",
+    141733920877u64 => "UNKNOWN_DIGEST_TYPE",
+    141733920878u64 => "UNKNOWN_OPERATION",
+    141733920879u64 => "UNSUPPORTED_CIPHER_TYPE",
+    141733920880u64 => "UNSUPPORTED_CONTENT_TYPE",
+    141733920881u64 => "WRONG_CONTENT_TYPE",
+    141733920882u64 => "WRONG_PKCS7_TYPE",
+    236223201380u64 => "NAME_TOO_LONG",
+    236223201381u64 => "NOT_AN_ASCII_CHARACTER",
+    236223201382u64 => "NOT_AN_HEXADECIMAL_DIGIT",
+    236223201383u64 => "NOT_AN_IDENTIFIER",
+    236223201384u64 => "NOT_AN_OCTAL_DIGIT",
+    236223201385u64 => "NOT_A_DECIMAL_DIGIT",
+    236223201386u64 => "NO_MATCHING_STRING_DELIMITER",
+    236223201387u64 => "NO_VALUE",
+    236223201388u64 => "PARSE_FAILED",
+    236223201389u64 => "STRING_TOO_LONG",
+    236223201390u64 => "TRAILING_CHARACTERS",
+    244813136056u64 => "ADDITIONAL_INPUT_TOO_LONG",
+    244813136045u64 => "ALGORITHM_MISMATCH",
+    244813136057u64 => "ALREADY_INSTANTIATED",
+    244813135972u64 => "BAD_DECRYPT",
+    244813136013u64 => "BAD_ENCODING",
+    244813136014u64 => "BAD_LENGTH",
+    244813136033u64 => "BAD_TLS_CLIENT_VERSION",
+    244813136032u64 => "BN_ERROR",
+    244813135974u64 => "CIPHER_OPERATION_FAILED",
+    244813136077u64 => "DERIVATION_FUNCTION_INIT_FAILED",
+    244813136046u64 => "DIGEST_NOT_ALLOWED",
+    244813136105u64 => "EMS_NOT_ENABLED",
+    244813136058u64 => "ENTROPY_SOURCE_STRENGTH_TOO_WEAK",
+    244813136060u64 => "ERROR_INSTANTIATING_DRBG",
+    244813136061u64 => "ERROR_RETRIEVING_ENTROPY",
+    244813136062u64 => "ERROR_RETRIEVING_NONCE",
+    244813136036u64 => "FAILED_DURING_DERIVATION",
+    244813136052u64 => "FAILED_TO_CREATE_LOCK",
+    244813136034u64 => "FAILED_TO_DECRYPT",
+    244813135993u64 => "FAILED_TO_GENERATE_KEY",
+    244813135975u64 => "FAILED_TO_GET_PARAMETER",
+    244813135976u64 => "FAILED_TO_SET_PARAMETER",
+    244813136047u64 => "FAILED_TO_SIGN",
+    244813136099u64 => "FIPS_MODULE_CONDITIONAL_ERROR",
+    244813136096u64 => "FIPS_MODULE_ENTERING_ERROR_STATE",
+    244813136097u64 => "FIPS_MODULE_IN_ERROR_STATE",
+    244813136063u64 => "GENERATE_ERROR",
+    244813136037u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE",
+    244813136082u64 => "INDICATOR_INTEGRITY_FAILURE",
+    244813136053u64 => "INSUFFICIENT_DRBG_STRENGTH",
+    244813135980u64 => "INVALID_AAD",
+    244813136083u64 => "INVALID_CONFIG_DATA",
+    244813136029u64 => "INVALID_CONSTANT_LENGTH",
+    244813136048u64 => "INVALID_CURVE",
+    244813135983u64 => "INVALID_CUSTOM_LENGTH",
+    244813135987u64 => "INVALID_DATA",
+    244813135994u64 => "INVALID_DIGEST",
+    244813136038u64 => "INVALID_DIGEST_LENGTH",
+    244813136090u64 => "INVALID_DIGEST_SIZE",
+    244813136102u64 => "INVALID_INPUT_LENGTH",
+    244813135995u64 => "INVALID_ITERATION_COUNT",
+    244813135981u64 => "INVALID_IV_LENGTH",
+    244813136030u64 => "INVALID_KEY",
+    244813135977u64 => "INVALID_KEY_LENGTH",
+    244813136023u64 => "INVALID_MAC",
+    244813136039u64 => "INVALID_MGF1_MD",
+    244813135997u64 => "INVALID_MODE",
+    244813136089u64 => "INVALID_OUTPUT_LENGTH",
+    244813136040u64 => "INVALID_PADDING_MODE",
+    244813136070u64 => "INVALID_PUBINFO",
+    244813135984u64 => "INVALID_SALT_LENGTH",
+    244813136026u64 => "INVALID_SEED_LENGTH",
+    244813136051u64 => "INVALID_SIGNATURE_SIZE",
+    244813136084u64 => "INVALID_STATE",
+    244813135982u64 => "INVALID_TAG",
+    244813135990u64 => "INVALID_TAG_LENGTH",
+    244813136072u64 => "INVALID_UKM_LENGTH",
+    244813136042u64 => "INVALID_X931_DIGEST",
+    244813136064u64 => "IN_ERROR_STATE",
+    244813135973u64 => "KEY_SETUP_FAILED",
+    244813136043u64 => "KEY_SIZE_TOO_SMALL",
+    244813136074u64 => "LENGTH_TOO_LARGE",
+    244813136075u64 => "MISMATCHING_DOMAIN_PARAMETERS",
+    244813136016u64 => "MISSING_CEK_ALG",
+    244813136027u64 => "MISSING_CIPHER",
+    244813136085u64 => "MISSING_CONFIG_DATA",
+    244813136028u64 => "MISSING_CONSTANT",
+    244813136000u64 => "MISSING_KEY",
+    244813136022u64 => "MISSING_MAC",
+    244813136001u64 => "MISSING_MESSAGE_DIGEST",
+    244813136081u64 => "MISSING_OID",
+    244813136002u64 => "MISSING_PASS",
+    244813136003u64 => "MISSING_SALT",
+    244813136004u64 => "MISSING_SECRET",
+    244813136012u64 => "MISSING_SEED",
+    244813136005u64 => "MISSING_SESSION_ID",
+    244813136006u64 => "MISSING_TYPE",
+    244813136007u64 => "MISSING_XCGHASH",
+    244813136086u64 => "MODULE_INTEGRITY_FAILURE",
+    244813136093u64 => "NOT_A_PRIVATE_KEY",
+    244813136092u64 => "NOT_A_PUBLIC_KEY",
+    244813136065u64 => "NOT_INSTANTIATED",
+    244813136098u64 => "NOT_PARAMETERS",
+    244813136008u64 => "NOT_SUPPORTED",
+    244813135985u64 => "NOT_XOF_OR_INVALID_LENGTH",
+    244813135986u64 => "NO_KEY_SET",
+    244813136049u64 => "NO_PARAMETERS_SET",
+    244813136050u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    244813135978u64 => "OUTPUT_BUFFER_TOO_SMALL",
+    244813136100u64 => "PARENT_CANNOT_GENERATE_RANDOM_NUMBERS",
+    244813136059u64 => "PARENT_CANNOT_SUPPLY_ENTROPY_SEED",
+    244813136054u64 => "PARENT_LOCKING_NOT_ENABLED",
+    244813136066u64 => "PARENT_STRENGTH_TOO_WEAK",
+    244813136091u64 => "PATH_MUST_BE_ABSOLUTE",
+    244813136067u64 => "PERSONALISATION_STRING_TOO_LONG",
+    244813136044u64 => "PSS_SALTLEN_TOO_SMALL",
+    244813136068u64 => "REQUEST_TOO_LARGE_FOR_DRBG",
+    244813136078u64 => "REQUIRE_CTR_MODE_CIPHER",
+    244813136069u64 => "RESEED_ERROR",
+    244813136094u64 => "SEARCH_ONLY_SUPPORTED_FOR_DIRECTORIES",
+    244813136101u64 => "SEED_SOURCES_MUST_NOT_HAVE_A_PARENT",
+    244813136087u64 => "SELF_TEST_KAT_FAILURE",
+    244813136088u64 => "SELF_TEST_POST_FAILURE",
+    244813135992u64 => "TAG_NOT_NEEDED",
+    244813135991u64 => "TAG_NOT_SET",
+    244813135998u64 => "TOO_MANY_RECORDS",
+    244813136079u64 => "UNABLE_TO_FIND_CIPHERS",
+    244813136071u64 => "UNABLE_TO_GET_PARENT_STRENGTH",
+    244813136031u64 => "UNABLE_TO_GET_PASSPHRASE",
+    244813136080u64 => "UNABLE_TO_INITIALISE_CIPHERS",
+    244813136019u64 => "UNABLE_TO_LOAD_SHA256",
+    244813136073u64 => "UNABLE_TO_LOCK_PARENT",
+    244813136076u64 => "UNABLE_TO_RESEED",
+    244813136017u64 => "UNSUPPORTED_CEK_ALG",
+    244813136025u64 => "UNSUPPORTED_KEY_SIZE",
+    244813136009u64 => "UNSUPPORTED_MAC_TYPE",
+    244813136024u64 => "UNSUPPORTED_NUMBER_OF_ROUNDS",
+    244813136095u64 => "URI_AUTHORITY_UNSUPPORTED",
+    244813136010u64 => "VALUE_ERROR",
+    244813135979u64 => "WRONG_FINAL_BLOCK_LENGTH",
+    244813136011u64 => "WRONG_OUTPUT_BUFFER_SIZE",
+    244813136055u64 => "XOF_DIGESTS_NOT_ALLOWED",
+    244813136020u64 => "XTS_DATA_UNIT_IS_TOO_LARGE",
+    244813136021u64 => "XTS_DUPLICATED_KEYS",
+    154618822758u64 => "ADDITIONAL_INPUT_TOO_LONG",
+    154618822759u64 => "ALREADY_INSTANTIATED",
+    154618822761u64 => "ARGUMENT_OUT_OF_RANGE",
+    154618822777u64 => "CANNOT_OPEN_FILE",
+    154618822785u64 => "DRBG_ALREADY_INITIALIZED",
+    154618822760u64 => "DRBG_NOT_INITIALISED",
+    154618822762u64 => "ENTROPY_INPUT_TOO_LONG",
+    154618822780u64 => "ENTROPY_OUT_OF_RANGE",
+    154618822783u64 => "ERROR_ENTROPY_POOL_WAS_IGNORED",
+    154618822763u64 => "ERROR_INITIALISING_DRBG",
+    154618822764u64 => "ERROR_INSTANTIATING_DRBG",
+    154618822765u64 => "ERROR_RETRIEVING_ADDITIONAL_INPUT",
+    154618822766u64 => "ERROR_RETRIEVING_ENTROPY",
+    154618822767u64 => "ERROR_RETRIEVING_NONCE",
+    154618822782u64 => "FAILED_TO_CREATE_LOCK",
+    154618822757u64 => "FUNC_NOT_IMPLEMENTED",
+    154618822779u64 => "FWRITE_ERROR",
+    154618822768u64 => "GENERATE_ERROR",
+    154618822795u64 => "INSUFFICIENT_DRBG_STRENGTH",
+    154618822769u64 => "INTERNAL_ERROR",
+    154618822793u64 => "INVALID_PROPERTY_QUERY",
+    154618822770u64 => "IN_ERROR_STATE",
+    154618822778u64 => "NOT_A_REGULAR_FILE",
+    154618822771u64 => "NOT_INSTANTIATED",
+    154618822784u64 => "NO_DRBG_IMPLEMENTATION_SELECTED",
+    154618822786u64 => "PARENT_LOCKING_NOT_ENABLED",
+    154618822787u64 => "PARENT_STRENGTH_TOO_WEAK",
+    154618822772u64 => "PERSONALISATION_STRING_TOO_LONG",
+    154618822789u64 => "PREDICTION_RESISTANCE_NOT_SUPPORTED",
+    154618822756u64 => "PRNG_NOT_SEEDED",
+    154618822781u64 => "RANDOM_POOL_OVERFLOW",
+    154618822790u64 => "RANDOM_POOL_UNDERFLOW",
+    154618822773u64 => "REQUEST_TOO_LARGE_FOR_DRBG",
+    154618822774u64 => "RESEED_ERROR",
+    154618822775u64 => "SELFTEST_FAILURE",
+    154618822791u64 => "TOO_LITTLE_NONCE_REQUESTED",
+    154618822792u64 => "TOO_MUCH_NONCE_REQUESTED",
+    154618822799u64 => "UNABLE_TO_CREATE_DRBG",
+    154618822800u64 => "UNABLE_TO_FETCH_DRBG",
+    154618822797u64 => "UNABLE_TO_GET_PARENT_RESEED_PROP_COUNTER",
+    154618822794u64 => "UNABLE_TO_GET_PARENT_STRENGTH",
+    154618822796u64 => "UNABLE_TO_LOCK_PARENT",
+    154618822788u64 => "UNSUPPORTED_DRBG_FLAGS",
+    154618822776u64 => "UNSUPPORTED_DRBG_TYPE",
+    17179869284u64 => "ALGORITHM_MISMATCH",
+    17179869285u64 => "BAD_E_VALUE",
+    17179869286u64 => "BAD_FIXED_HEADER_DECRYPT",
+    17179869287u64 => "BAD_PAD_BYTE_COUNT",
+    17179869288u64 => "BAD_SIGNATURE",
+    17179869290u64 => "BLOCK_TYPE_IS_NOT_01",
+    17179869291u64 => "BLOCK_TYPE_IS_NOT_02",
+    17179869292u64 => "DATA_GREATER_THAN_MOD_LEN",
+    17179869293u64 => "DATA_TOO_LARGE",
+    17179869294u64 => "DATA_TOO_LARGE_FOR_KEY_SIZE",
+    17179869316u64 => "DATA_TOO_LARGE_FOR_MODULUS",
+    17179869295u64 => "DATA_TOO_SMALL",
+    17179869306u64 => "DATA_TOO_SMALL_FOR_KEY_SIZE",
+    17179869342u64 => "DIGEST_DOES_NOT_MATCH",
+    17179869329u64 => "DIGEST_NOT_ALLOWED",
+    17179869296u64 => "DIGEST_TOO_BIG_FOR_RSA_KEY",
+    17179869308u64 => "DMP1_NOT_CONGRUENT_TO_D",
+    17179869309u64 => "DMQ1_NOT_CONGRUENT_TO_D",
+    17179869307u64 => "D_E_NOT_CONGRUENT_TO_1",
+    17179869317u64 => "FIRST_OCTET_INVALID",
+    17179869328u64 => "ILLEGAL_OR_UNSUPPORTED_PADDING_MODE",
+    17179869341u64 => "INVALID_DIGEST",
+    17179869327u64 => "INVALID_DIGEST_LENGTH",
+    17179869321u64 => "INVALID_HEADER",
+    17179869355u64 => "INVALID_KEYPAIR",
+    17179869357u64 => "INVALID_KEY_LENGTH",
+    17179869344u64 => "INVALID_LABEL",
+    17179869365u64 => "INVALID_LENGTH",
+    17179869315u64 => "INVALID_MESSAGE_LENGTH",
+    17179869340u64 => "INVALID_MGF1_MD",
+    17179869358u64 => "INVALID_MODULUS",
+    17179869351u64 => "INVALID_MULTI_PRIME_KEY",
+    17179869345u64 => "INVALID_OAEP_PARAMETERS",
+    17179869322u64 => "INVALID_PADDING",
+    17179869325u64 => "INVALID_PADDING_MODE",
+    17179869333u64 => "INVALID_PSS_PARAMETERS",
+    17179869330u64 => "INVALID_PSS_SALTLEN",
+    17179869359u64 => "INVALID_REQUEST",
+    17179869334u64 => "INVALID_SALT_LENGTH",
+    17179869360u64 => "INVALID_STRENGTH",
+    17179869323u64 => "INVALID_TRAILER",
+    17179869326u64 => "INVALID_X931_DIGEST",
+    17179869310u64 => "IQMP_NOT_INVERSE_OF_Q",
+    17179869349u64 => "KEY_PRIME_NUM_INVALID",
+    17179869304u64 => "KEY_SIZE_TOO_SMALL",
+    17179869318u64 => "LAST_OCTET_INVALID",
+    17179869336u64 => "MGF1_DIGEST_NOT_ALLOWED",
+    17179869363u64 => "MISSING_PRIVATE_KEY",
+    17179869289u64 => "MODULUS_TOO_LARGE",
+    17179869352u64 => "MP_COEFFICIENT_NOT_INVERSE_OF_R",
+    17179869353u64 => "MP_EXPONENT_NOT_CONGRUENT_TO_D",
+    17179869354u64 => "MP_R_NOT_PRIME",
+    17179869324u64 => "NO_PUBLIC_EXPONENT",
+    17179869297u64 => "NULL_BEFORE_BLOCK_MISSING",
+    17179869356u64 => "N_DOES_NOT_EQUAL_PRODUCT_OF_PRIMES",
+    17179869311u64 => "N_DOES_NOT_EQUAL_P_Q",
+    17179869305u64 => "OAEP_DECODING_ERROR",
+    17179869332u64 => "OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE",
+    17179869298u64 => "PADDING_CHECK_FAILED",
+    17179869361u64 => "PAIRWISE_TEST_FAILURE",
+    17179869343u64 => "PKCS_DECODING_ERROR",
+    17179869348u64 => "PSS_SALTLEN_TOO_SMALL",
+    17179869362u64 => "PUB_EXPONENT_OUT_OF_RANGE",
+    17179869312u64 => "P_NOT_PRIME",
+    17179869313u64 => "Q_NOT_PRIME",
+    17179869364u64 => "RANDOMNESS_SOURCE_STRENGTH_INSUFFICIENT",
+    17179869314u64 => "RSA_OPERATIONS_NOT_SUPPORTED",
+    17179869320u64 => "SLEN_CHECK_FAILED",
+    17179869319u64 => "SLEN_RECOVERY_FAILED",
+    17179869299u64 => "SSLV3_ROLLBACK_ATTACK",
+    17179869300u64 => "THE_ASN1_OBJECT_IDENTIFIER_IS_NOT_KNOWN_FOR_THIS_MD",
+    17179869301u64 => "UNKNOWN_ALGORITHM_TYPE",
+    17179869350u64 => "UNKNOWN_DIGEST",
+    17179869335u64 => "UNKNOWN_MASK_DIGEST",
+    17179869302u64 => "UNKNOWN_PADDING_TYPE",
+    17179869346u64 => "UNSUPPORTED_ENCRYPTION_TYPE",
+    17179869347u64 => "UNSUPPORTED_LABEL_SOURCE",
+    17179869337u64 => "UNSUPPORTED_MASK_ALGORITHM",
+    17179869338u64 => "UNSUPPORTED_MASK_PARAMETER",
+    17179869339u64 => "UNSUPPORTED_SIGNATURE_TYPE",
+    17179869331u64 => "VALUE_MISSING",
+    17179869303u64 => "WRONG_SIGNATURE_LENGTH",
+    227633266788u64 => "ASN1_ERROR",
+    227633266789u64 => "BAD_SIGNATURE",
+    227633266795u64 => "BUFFER_TOO_SMALL",
+    227633266798u64 => "DIST_ID_TOO_LARGE",
+    227633266800u64 => "ID_NOT_SET",
+    227633266799u64 => "ID_TOO_LARGE",
+    227633266796u64 => "INVALID_CURVE",
+    227633266790u64 => "INVALID_DIGEST",
+    227633266791u64 => "INVALID_DIGEST_TYPE",
+    227633266792u64 => "INVALID_ENCODING",
+    227633266793u64 => "INVALID_FIELD",
+    227633266801u64 => "INVALID_PRIVATE_KEY",
+    227633266797u64 => "NO_PARAMETERS_SET",
+    227633266794u64 => "USER_ID_TOO_LARGE",
+    85899346211u64 => "APPLICATION_DATA_AFTER_CLOSE_NOTIFY",
+    85899346020u64 => "APP_DATA_IN_HANDSHAKE",
+    85899346192u64 => "ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT",
+    85899346078u64 => "AT_LEAST_TLS_1_2_NEEDED_IN_SUITEB_MODE",
+    85899346023u64 => "BAD_CHANGE_CIPHER_SPEC",
+    85899346106u64 => "BAD_CIPHER",
+    85899346310u64 => "BAD_DATA",
+    85899346026u64 => "BAD_DATA_RETURNED_BY_CALLBACK",
+    85899346027u64 => "BAD_DECOMPRESSION",
+    85899346022u64 => "BAD_DH_VALUE",
+    85899346031u64 => "BAD_DIGEST_LENGTH",
+    85899346153u64 => "BAD_EARLY_DATA",
+    85899346224u64 => "BAD_ECC_CERT",
+    85899346226u64 => "BAD_ECPOINT",
+    85899346030u64 => "BAD_EXTENSION",
+    85899346252u64 => "BAD_HANDSHAKE_LENGTH",
+    85899346156u64 => "BAD_HANDSHAKE_STATE",
+    85899346025u64 => "BAD_HELLO_REQUEST",
+    85899346183u64 => "BAD_HRR_VERSION",
+    85899346028u64 => "BAD_KEY_SHARE",
+    85899346042u64 => "BAD_KEY_UPDATE",
+    85899346212u64 => "BAD_LEGACY_VERSION",
+    85899346191u64 => "BAD_LENGTH",
+    85899346160u64 => "BAD_PACKET",
+    85899346035u64 => "BAD_PACKET_LENGTH",
+    85899346036u64 => "BAD_PROTOCOL_VERSION_NUMBER",
+    85899346139u64 => "BAD_PSK",
+    85899346034u64 => "BAD_PSK_IDENTITY",
+    85899346363u64 => "BAD_RECORD_TYPE",
+    85899346039u64 => "BAD_RSA_ENCRYPT",
+    85899346043u64 => "BAD_SIGNATURE",
+    85899346267u64 => "BAD_SRP_A_LENGTH",
+    85899346291u64 => "BAD_SRP_PARAMETERS",
+    85899346272u64 => "BAD_SRTP_MKI_VALUE",
+    85899346273u64 => "BAD_SRTP_PROTECTION_PROFILE_LIST",
+    85899346044u64 => "BAD_SSL_FILETYPE",
+    85899346304u64 => "BAD_VALUE",
+    85899346047u64 => "BAD_WRITE_RETRY",
+    85899346173u64 => "BINDER_DOES_NOT_VERIFY",
+    85899346048u64 => "BIO_NOT_SET",
+    85899346049u64 => "BLOCK_CIPHER_PAD_IS_WRONG",
+    85899346050u64 => "BN_LIB",
+    85899346154u64 => "CALLBACK_FAILED",
+    85899346029u64 => "CANNOT_CHANGE_CIPHER",
+    85899346219u64 => "CANNOT_GET_GROUP_NAME",
+    85899346051u64 => "CA_DN_LENGTH_MISMATCH",
+    85899346317u64 => "CA_KEY_TOO_SMALL",
+    85899346318u64 => "CA_MD_TOO_WEAK",
+    85899346053u64 => "CCS_RECEIVED_EARLY",
+    85899346054u64 => "CERTIFICATE_VERIFY_FAILED",
+    85899346297u64 => "CERT_CB_ERROR",
+    85899346055u64 => "CERT_LENGTH_MISMATCH",
+    85899346138u64 => "CIPHERSUITE_DIGEST_HAS_CHANGED",
+    85899346057u64 => "CIPHER_CODE_WRONG_LENGTH",
+    85899346146u64 => "CLIENTHELLO_TLSEXT",
+    85899346060u64 => "COMPRESSED_LENGTH_TOO_LONG",
+    85899346263u64 => "COMPRESSION_DISABLED",
+    85899346061u64 => "COMPRESSION_FAILURE",
+    85899346227u64 => "COMPRESSION_ID_NOT_WITHIN_PRIVATE_RANGE",
+    85899346062u64 => "COMPRESSION_LIBRARY_ERROR",
+    85899346064u64 => "CONNECTION_TYPE_NOT_SET",
+    85899346087u64 => "CONTEXT_NOT_DANE_ENABLED",
+    85899346320u64 => "COOKIE_GEN_CALLBACK_FAILURE",
+    85899346228u64 => "COOKIE_MISMATCH",
+    85899346216u64 => "COPY_PARAMETERS_FAILED",
+    85899346126u64 => "CUSTOM_EXT_HANDLER_ALREADY_INSTALLED",
+    85899346092u64 => "DANE_ALREADY_ENABLED",
+    85899346093u64 => "DANE_CANNOT_OVERRIDE_MTYPE_FULL",
+    85899346095u64 => "DANE_NOT_ENABLED",
+    85899346100u64 => "DANE_TLSA_BAD_CERTIFICATE",
+    85899346104u64 => "DANE_TLSA_BAD_CERTIFICATE_USAGE",
+    85899346109u64 => "DANE_TLSA_BAD_DATA_LENGTH",
+    85899346112u64 => "DANE_TLSA_BAD_DIGEST_LENGTH",
+    85899346120u64 => "DANE_TLSA_BAD_MATCHING_TYPE",
+    85899346121u64 => "DANE_TLSA_BAD_PUBLIC_KEY",
+    85899346122u64 => "DANE_TLSA_BAD_SELECTOR",
+    85899346123u64 => "DANE_TLSA_NULL_DATA",
+    85899346065u64 => "DATA_BETWEEN_CCS_AND_FINISHED",
+    85899346066u64 => "DATA_LENGTH_TOO_LONG",
+    85899346067u64 => "DECRYPTION_FAILED",
+    85899346201u64 => "DECRYPTION_FAILED_OR_BAD_RECORD_MAC",
+    85899346314u64 => "DH_KEY_TOO_SMALL",
+    85899346068u64 => "DH_PUBLIC_VALUE_LENGTH_IS_WRONG",
+    85899346069u64 => "DIGEST_CHECK_FAILED",
+    85899346254u64 => "DTLS_MESSAGE_TOO_BIG",
+    85899346229u64 => "DUPLICATE_COMPRESSION_ID",
+    85899346238u64 => "ECC_CERT_NOT_FOR_SIGNING",
+    85899346294u64 => "ECDH_REQUIRED_FOR_SUITEB_MODE",
+    85899346319u64 => "EE_KEY_TOO_SMALL",
+    85899346274u64 => "EMPTY_SRTP_PROTECTION_PROFILE_LIST",
+    85899346070u64 => "ENCRYPTED_LENGTH_TOO_LONG",
+    85899346071u64 => "ERROR_IN_RECEIVED_CIPHER_LIST",
+    85899346124u64 => "ERROR_SETTING_TLSA_BASE_DOMAIN",
+    85899346114u64 => "EXCEEDS_MAX_FRAGMENT_SIZE",
+    85899346072u64 => "EXCESSIVE_MESSAGE_SIZE",
+    85899346199u64 => "EXTENSION_NOT_RECEIVED",
+    85899346073u64 => "EXTRA_DATA_IN_MESSAGE",
+    85899346083u64 => "EXT_LENGTH_MISMATCH",
+    85899346325u64 => "FAILED_TO_INIT_ASYNC",
+    85899346321u64 => "FRAGMENTED_CLIENT_HELLO",
+    85899346074u64 => "GOT_A_FIN_BEFORE_A_CCS",
+    85899346075u64 => "HTTPS_PROXY_REQUEST",
+    85899346076u64 => "HTTP_REQUEST",
+    85899346082u64 => "ILLEGAL_POINT_COMPRESSION",
+    85899346300u64 => "ILLEGAL_SUITEB_DIGEST",
+    85899346293u64 => "INAPPROPRIATE_FALLBACK",
+    85899346260u64 => "INCONSISTENT_COMPRESSION",
+    85899346142u64 => "INCONSISTENT_EARLY_DATA_ALPN",
+    85899346151u64 => "INCONSISTENT_EARLY_DATA_SNI",
+    85899346024u64 => "INCONSISTENT_EXTMS",
+    85899346161u64 => "INSUFFICIENT_SECURITY",
+    85899346125u64 => "INVALID_ALERT",
+    85899346180u64 => "INVALID_CCS_MESSAGE",
+    85899346158u64 => "INVALID_CERTIFICATE_OR_ALG",
+    85899346200u64 => "INVALID_COMMAND",
+    85899346261u64 => "INVALID_COMPRESSION_ALGORITHM",
+    85899346203u64 => "INVALID_CONFIG",
+    85899346033u64 => "INVALID_CONFIGURATION_NAME",
+    85899346202u64 => "INVALID_CONTEXT",
+    85899346132u64 => "INVALID_CT_VALIDATION_TYPE",
+    85899346040u64 => "INVALID_KEY_UPDATE_TYPE",
+    85899346094u64 => "INVALID_MAX_EARLY_DATA",
+    85899346305u64 => "INVALID_NULL_CMD_NAME",
+    85899346322u64 => "INVALID_SEQUENCE_NUMBER",
+    85899346308u64 => "INVALID_SERVERINFO_DATA",
+    85899346919u64 => "INVALID_SESSION_ID",
+    85899346277u64 => "INVALID_SRP_USERNAME",
+    85899346248u64 => "INVALID_STATUS_RESPONSE",
+    85899346245u64 => "INVALID_TICKET_KEYS_LENGTH",
+    85899346253u64 => "LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED",
+    85899346079u64 => "LENGTH_MISMATCH",
+    85899346324u64 => "LENGTH_TOO_LONG",
+    85899346080u64 => "LENGTH_TOO_SHORT",
+    85899346194u64 => "LIBRARY_BUG",
+    85899346081u64 => "LIBRARY_HAS_NO_CIPHERS",
+    85899346085u64 => "MISSING_DSA_SIGNING_CERT",
+    85899346301u64 => "MISSING_ECDSA_SIGNING_CERT",
+    85899346176u64 => "MISSING_FATAL",
+    85899346210u64 => "MISSING_PARAMETERS",
+    85899346230u64 => "MISSING_PSK_KEX_MODES_EXTENSION",
+    85899346088u64 => "MISSING_RSA_CERTIFICATE",
+    85899346089u64 => "MISSING_RSA_ENCRYPTING_CERT",
+    85899346090u64 => "MISSING_RSA_SIGNING_CERT",
+    85899346032u64 => "MISSING_SIGALGS_EXTENSION",
+    85899346141u64 => "MISSING_SIGNING_CERT",
+    85899346278u64 => "MISSING_SRP_PARAM",
+    85899346129u64 => "MISSING_SUPPORTED_GROUPS_EXTENSION",
+    85899346091u64 => "MISSING_TMP_DH_KEY",
+    85899346231u64 => "MISSING_TMP_ECDH_KEY",
+    85899346213u64 => "MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA",
+    85899346102u64 => "NOT_ON_RECORD_BOUNDARY",
+    85899346209u64 => "NOT_REPLACING_CERTIFICATE",
+    85899346204u64 => "NOT_SERVER",
+    85899346155u64 => "NO_APPLICATION_PROTOCOL",
+    85899346096u64 => "NO_CERTIFICATES_RETURNED",
+    85899346097u64 => "NO_CERTIFICATE_ASSIGNED",
+    85899346099u64 => "NO_CERTIFICATE_SET",
+    85899346134u64 => "NO_CHANGE_FOLLOWING_HRR",
+    85899346101u64 => "NO_CIPHERS_AVAILABLE",
+    85899346103u64 => "NO_CIPHERS_SPECIFIED",
+    85899346105u64 => "NO_CIPHER_MATCH",
+    85899346251u64 => "NO_CLIENT_CERT_METHOD",
+    85899346107u64 => "NO_COMPRESSION_SPECIFIED",
+    85899346207u64 => "NO_COOKIE_CALLBACK_SET",
+    85899346250u64 => "NO_GOST_CERTIFICATE_SENT_BY_PEER",
+    85899346108u64 => "NO_METHOD_SPECIFIED",
+    85899346309u64 => "NO_PEM_EXTENSIONS",
+    85899346110u64 => "NO_PRIVATE_KEY_ASSIGNED",
+    85899346111u64 => "NO_PROTOCOLS_AVAILABLE",
+    85899346259u64 => "NO_RENEGOTIATION",
+    85899346244u64 => "NO_REQUIRED_DIGEST",
+    85899346113u64 => "NO_SHARED_CIPHER",
+    85899346330u64 => "NO_SHARED_GROUPS",
+    85899346296u64 => "NO_SHARED_SIGNATURE_ALGORITHMS",
+    85899346279u64 => "NO_SRTP_PROFILES",
+    85899346217u64 => "NO_SUITABLE_DIGEST_ALGORITHM",
+    85899346215u64 => "NO_SUITABLE_GROUPS",
+    85899346021u64 => "NO_SUITABLE_KEY_SHARE",
+    85899346038u64 => "NO_SUITABLE_SIGNATURE_ALGORITHM",
+    85899346136u64 => "NO_VALID_SCTS",
+    85899346323u64 => "NO_VERIFY_COOKIE_CALLBACK",
+    85899346115u64 => "NULL_SSL_CTX",
+    85899346116u64 => "NULL_SSL_METHOD_PASSED",
+    85899346225u64 => "OCSP_CALLBACK_FAILURE",
+    85899346117u64 => "OLD_SESSION_CIPHER_NOT_RETURNED",
+    85899346264u64 => "OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED",
+    85899346157u64 => "OVERFLOW_ERROR",
+    85899346118u64 => "PACKET_LENGTH_TOO_LONG",
+    85899346147u64 => "PARSE_TLSEXT",
+    85899346190u64 => "PATH_TOO_LONG",
+    85899346119u64 => "PEER_DID_NOT_RETURN_A_CERTIFICATE",
+    85899346311u64 => "PEM_NAME_BAD_PREFIX",
+    85899346312u64 => "PEM_NAME_TOO_SHORT",
+    85899346326u64 => "PIPELINE_FAILURE",
+    85899346198u64 => "POST_HANDSHAKE_AUTH_ENCODING_ERR",
+    85899346208u64 => "PRIVATE_KEY_MISMATCH",
+    85899346127u64 => "PROTOCOL_IS_SHUTDOWN",
+    85899346143u64 => "PSK_IDENTITY_NOT_FOUND",
+    85899346144u64 => "PSK_NO_CLIENT_CB",
+    85899346145u64 => "PSK_NO_SERVER_CB",
+    85899346131u64 => "READ_BIO_NOT_SET",
+    85899346232u64 => "READ_TIMEOUT_EXPIRED",
+    85899346133u64 => "RECORD_LENGTH_MISMATCH",
+    85899346218u64 => "RECORD_TOO_SMALL",
+    85899346255u64 => "RENEGOTIATE_EXT_TOO_LONG",
+    85899346256u64 => "RENEGOTIATION_ENCODING_ERR",
+    85899346257u64 => "RENEGOTIATION_MISMATCH",
+    85899346205u64 => "REQUEST_PENDING",
+    85899346206u64 => "REQUEST_SENT",
+    85899346135u64 => "REQUIRED_CIPHER_MISSING",
+    85899346262u64 => "REQUIRED_COMPRESSION_ALGORITHM_MISSING",
+    85899346265u64 => "SCSV_RECEIVED_WHEN_RENEGOTIATING",
+    85899346128u64 => "SCT_VERIFICATION_FAILED",
+    85899346195u64 => "SERVERHELLO_TLSEXT",
+    85899346197u64 => "SESSION_ID_CONTEXT_UNINITIALIZED",
+    85899346327u64 => "SHUTDOWN_WHILE_IN_INIT",
+    85899346280u64 => "SIGNATURE_ALGORITHMS_ERROR",
+    85899346140u64 => "SIGNATURE_FOR_NON_SIGNING_CERTIFICATE",
+    85899346281u64 => "SRP_A_CALC",
+    85899346282u64 => "SRTP_COULD_NOT_ALLOCATE_PROFILES",
+    85899346283u64 => "SRTP_PROTECTION_PROFILE_LIST_TOO_LONG",
+    85899346284u64 => "SRTP_UNKNOWN_PROTECTION_PROFILE",
+    85899346152u64 => "SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH",
+    85899346239u64 => "SSL3_EXT_INVALID_SERVERNAME",
+    85899346240u64 => "SSL3_EXT_INVALID_SERVERNAME_TYPE",
+    85899346220u64 => "SSL3_SESSION_ID_TOO_LONG",
+    85899346962u64 => "SSLV3_ALERT_BAD_CERTIFICATE",
+    85899346940u64 => "SSLV3_ALERT_BAD_RECORD_MAC",
+    85899346965u64 => "SSLV3_ALERT_CERTIFICATE_EXPIRED",
+    85899346964u64 => "SSLV3_ALERT_CERTIFICATE_REVOKED",
+    85899346966u64 => "SSLV3_ALERT_CERTIFICATE_UNKNOWN",
+    85899346950u64 => "SSLV3_ALERT_DECOMPRESSION_FAILURE",
+    85899346960u64 => "SSLV3_ALERT_HANDSHAKE_FAILURE",
+    85899346967u64 => "SSLV3_ALERT_ILLEGAL_PARAMETER",
+    85899346961u64 => "SSLV3_ALERT_NO_CERTIFICATE",
+    85899346930u64 => "SSLV3_ALERT_UNEXPECTED_MESSAGE",
+    85899346963u64 => "SSLV3_ALERT_UNSUPPORTED_CERTIFICATE",
+    85899346037u64 => "SSL_COMMAND_SECTION_EMPTY",
+    85899346045u64 => "SSL_COMMAND_SECTION_NOT_FOUND",
+    85899346148u64 => "SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION",
+    85899346149u64 => "SSL_HANDSHAKE_FAILURE",
+    85899346150u64 => "SSL_LIBRARY_HAS_NO_CIPHERS",
+    85899346292u64 => "SSL_NEGATIVE_LENGTH",
+    85899346046u64 => "SSL_SECTION_EMPTY",
+    85899346056u64 => "SSL_SECTION_NOT_FOUND",
+    85899346221u64 => "SSL_SESSION_ID_CALLBACK_FAILED",
+    85899346222u64 => "SSL_SESSION_ID_CONFLICT",
+    85899346193u64 => "SSL_SESSION_ID_CONTEXT_TOO_LONG",
+    85899346223u64 => "SSL_SESSION_ID_HAS_BAD_LENGTH",
+    85899346328u64 => "SSL_SESSION_ID_TOO_LONG",
+    85899346130u64 => "SSL_SESSION_VERSION_MISMATCH",
+    85899346041u64 => "STILL_IN_INIT",
+    85899347036u64 => "TLSV13_ALERT_CERTIFICATE_REQUIRED",
+    85899347029u64 => "TLSV13_ALERT_MISSING_EXTENSION",
+    85899346969u64 => "TLSV1_ALERT_ACCESS_DENIED",
+    85899346970u64 => "TLSV1_ALERT_DECODE_ERROR",
+    85899346941u64 => "TLSV1_ALERT_DECRYPTION_FAILED",
+    85899346971u64 => "TLSV1_ALERT_DECRYPT_ERROR",
+    85899346980u64 => "TLSV1_ALERT_EXPORT_RESTRICTION",
+    85899347006u64 => "TLSV1_ALERT_INAPPROPRIATE_FALLBACK",
+    85899346991u64 => "TLSV1_ALERT_INSUFFICIENT_SECURITY",
+    85899347000u64 => "TLSV1_ALERT_INTERNAL_ERROR",
+    85899347040u64 => "TLSV1_ALERT_NO_APPLICATION_PROTOCOL",
+    85899347020u64 => "TLSV1_ALERT_NO_RENEGOTIATION",
+    85899346990u64 => "TLSV1_ALERT_PROTOCOL_VERSION",
+    85899346942u64 => "TLSV1_ALERT_RECORD_OVERFLOW",
+    85899346968u64 => "TLSV1_ALERT_UNKNOWN_CA",
+    85899347035u64 => "TLSV1_ALERT_UNKNOWN_PSK_IDENTITY",
+    85899347010u64 => "TLSV1_ALERT_USER_CANCELLED",
+    85899347034u64 => "TLSV1_BAD_CERTIFICATE_HASH_VALUE",
+    85899347033u64 => "TLSV1_BAD_CERTIFICATE_STATUS_RESPONSE",
+    85899347031u64 => "TLSV1_CERTIFICATE_UNOBTAINABLE",
+    85899347032u64 => "TLSV1_UNRECOGNIZED_NAME",
+    85899347030u64 => "TLSV1_UNSUPPORTED_EXTENSION",
+    85899346287u64 => "TLS_ILLEGAL_EXPORTER_LABEL",
+    85899346077u64 => "TLS_INVALID_ECPOINTFORMAT_LIST",
+    85899346052u64 => "TOO_MANY_KEY_UPDATES",
+    85899346329u64 => "TOO_MANY_WARN_ALERTS",
+    85899346084u64 => "TOO_MUCH_EARLY_DATA",
+    85899346234u64 => "UNABLE_TO_FIND_ECDH_PARAMETERS",
+    85899346159u64 => "UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS",
+    85899346162u64 => "UNABLE_TO_LOAD_SSL3_MD5_ROUTINES",
+    85899346163u64 => "UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES",
+    85899346182u64 => "UNEXPECTED_CCS_MESSAGE",
+    85899346098u64 => "UNEXPECTED_END_OF_EARLY_DATA",
+    85899346214u64 => "UNEXPECTED_EOF_WHILE_READING",
+    85899346164u64 => "UNEXPECTED_MESSAGE",
+    85899346165u64 => "UNEXPECTED_RECORD",
+    85899346196u64 => "UNINITIALIZED",
+    85899346166u64 => "UNKNOWN_ALERT_TYPE",
+    85899346167u64 => "UNKNOWN_CERTIFICATE_TYPE",
+    85899346168u64 => "UNKNOWN_CIPHER_RETURNED",
+    85899346169u64 => "UNKNOWN_CIPHER_TYPE",
+    85899346306u64 => "UNKNOWN_CMD_NAME",
+    85899346059u64 => "UNKNOWN_COMMAND",
+    85899346288u64 => "UNKNOWN_DIGEST",
+    85899346170u64 => "UNKNOWN_KEY_EXCHANGE_TYPE",
+    85899346171u64 => "UNKNOWN_PKEY_TYPE",
+    85899346172u64 => "UNKNOWN_PROTOCOL",
+    85899346174u64 => "UNKNOWN_SSL_VERSION",
+    85899346175u64 => "UNKNOWN_STATE",
+    85899346258u64 => "UNSAFE_LEGACY_RENEGOTIATION_DISABLED",
+    85899346137u64 => "UNSOLICITED_EXTENSION",
+    85899346177u64 => "UNSUPPORTED_COMPRESSION_ALGORITHM",
+    85899346235u64 => "UNSUPPORTED_ELLIPTIC_CURVE",
+    85899346178u64 => "UNSUPPORTED_PROTOCOL",
+    85899346179u64 => "UNSUPPORTED_SSL_VERSION",
+    85899346249u64 => "UNSUPPORTED_STATUS_TYPE",
+    85899346289u64 => "USE_SRTP_NOT_NEGOTIATED",
+    85899346086u64 => "VERSION_TOO_HIGH",
+    85899346316u64 => "VERSION_TOO_LOW",
+    85899346303u64 => "WRONG_CERTIFICATE_TYPE",
+    85899346181u64 => "WRONG_CIPHER_RETURNED",
+    85899346298u64 => "WRONG_CURVE",
+    85899346184u64 => "WRONG_SIGNATURE_LENGTH",
+    85899346185u64 => "WRONG_SIGNATURE_SIZE",
+    85899346290u64 => "WRONG_SIGNATURE_TYPE",
+    85899346186u64 => "WRONG_SSL_VERSION",
+    85899346187u64 => "WRONG_VERSION_NUMBER",
+    85899346188u64 => "X509_LIB",
+    85899346189u64 => "X509_VERIFICATION_SETUP_PROBLEMS",
+    201863463044u64 => "BAD_PKCS7_TYPE",
+    201863463045u64 => "BAD_TYPE",
+    201863463049u64 => "CANNOT_LOAD_CERT",
+    201863463050u64 => "CANNOT_LOAD_KEY",
+    201863463012u64 => "CERTIFICATE_VERIFY_ERROR",
+    201863463039u64 => "COULD_NOT_SET_ENGINE",
+    201863463027u64 => "COULD_NOT_SET_TIME",
+    201863463046u64 => "DETACHED_CONTENT",
+    201863463028u64 => "ESS_ADD_SIGNING_CERT_ERROR",
+    201863463051u64 => "ESS_ADD_SIGNING_CERT_V2_ERROR",
+    201863463013u64 => "ESS_SIGNING_CERTIFICATE_ERROR",
+    201863463014u64 => "INVALID_NULL_POINTER",
+    201863463029u64 => "INVALID_SIGNER_CERTIFICATE_PURPOSE",
+    201863463015u64 => "MESSAGE_IMPRINT_MISMATCH",
+    201863463016u64 => "NONCE_MISMATCH",
+    201863463017u64 => "NONCE_NOT_RETURNED",
+    201863463018u64 => "NO_CONTENT",
+    201863463019u64 => "NO_TIME_STAMP_TOKEN",
+    201863463030u64 => "PKCS7_ADD_SIGNATURE_ERROR",
+    201863463031u64 => "PKCS7_ADD_SIGNED_ATTR_ERROR",
+    201863463041u64 => "PKCS7_TO_TS_TST_INFO_FAILED",
+    201863463020u64 => "POLICY_MISMATCH",
+    201863463032u64 => "PRIVATE_KEY_DOES_NOT_MATCH_CERTIFICATE",
+    201863463033u64 => "RESPONSE_SETUP_ERROR",
+    201863463021u64 => "SIGNATURE_FAILURE",
+    201863463022u64 => "THERE_MUST_BE_ONE_SIGNER",
+    201863463034u64 => "TIME_SYSCALL_ERROR",
+    201863463042u64 => "TOKEN_NOT_PRESENT",
+    201863463043u64 => "TOKEN_PRESENT",
+    201863463023u64 => "TSA_NAME_MISMATCH",
+    201863463024u64 => "TSA_UNTRUSTED",
+    201863463035u64 => "TST_INFO_SETUP_ERROR",
+    201863463036u64 => "TS_DATASIGN",
+    201863463037u64 => "UNACCEPTABLE_POLICY",
+    201863463038u64 => "UNSUPPORTED_MD_ALGORITHM",
+    201863463025u64 => "UNSUPPORTED_VERSION",
+    201863463047u64 => "VAR_BAD_VALUE",
+    201863463048u64 => "VAR_LOOKUP_FAILURE",
+    201863463026u64 => "WRONG_CONTENT_TYPE",
+    171798691944u64 => "COMMON_OK_AND_CANCEL_CHARACTERS",
+    171798691942u64 => "INDEX_TOO_LARGE",
+    171798691943u64 => "INDEX_TOO_SMALL",
+    171798691945u64 => "NO_RESULT_BUFFER",
+    171798691947u64 => "PROCESSING_ERROR",
+    171798691940u64 => "RESULT_TOO_LARGE",
+    171798691941u64 => "RESULT_TOO_SMALL",
+    171798691949u64 => "SYSASSIGN_ERROR",
+    171798691950u64 => "SYSDASSGN_ERROR",
+    171798691951u64 => "SYSQIOW_ERROR",
+    171798691946u64 => "UNKNOWN_CONTROL_COMMAND",
+    171798691948u64 => "UNKNOWN_TTYGET_ERRNO_VALUE",
+    171798691952u64 => "USER_DATA_DUPLICATION_UNSUPPORTED",
+    146028888182u64 => "BAD_IP_ADDRESS",
+    146028888183u64 => "BAD_OBJECT",
+    146028888164u64 => "BN_DEC2BN_ERROR",
+    146028888165u64 => "BN_TO_ASN1_INTEGER_ERROR",
+    146028888213u64 => "DIRNAME_ERROR",
+    146028888224u64 => "DISTPOINT_ALREADY_SET",
+    146028888197u64 => "DUPLICATE_ZONE_ID",
+    146028888233u64 => "EMPTY_KEY_USAGE",
+    146028888195u64 => "ERROR_CONVERTING_ZONE",
+    146028888208u64 => "ERROR_CREATING_EXTENSION",
+    146028888192u64 => "ERROR_IN_EXTENSION",
+    146028888201u64 => "EXPECTED_A_SECTION_NAME",
+    146028888209u64 => "EXTENSION_EXISTS",
+    146028888179u64 => "EXTENSION_NAME_ERROR",
+    146028888166u64 => "EXTENSION_NOT_FOUND",
+    146028888167u64 => "EXTENSION_SETTING_NOT_SUPPORTED",
+    146028888180u64 => "EXTENSION_VALUE_ERROR",
+    146028888215u64 => "ILLEGAL_EMPTY_EXTENSION",
+    146028888216u64 => "INCORRECT_POLICY_SYNTAX_TAG",
+    146028888226u64 => "INVALID_ASNUMBER",
+    146028888227u64 => "INVALID_ASRANGE",
+    146028888168u64 => "INVALID_BOOLEAN_STRING",
+    146028888222u64 => "INVALID_CERTIFICATE",
+    146028888172u64 => "INVALID_EMPTY_NAME",
+    146028888169u64 => "INVALID_EXTENSION_STRING",
+    146028888229u64 => "INVALID_INHERITANCE",
+    146028888230u64 => "INVALID_IPADDRESS",
+    146028888225u64 => "INVALID_MULTIPLE_RDNS",
+    146028888170u64 => "INVALID_NAME",
+    146028888171u64 => "INVALID_NULL_ARGUMENT",
+    146028888173u64 => "INVALID_NULL_VALUE",
+    146028888204u64 => "INVALID_NUMBER",
+    146028888205u64 => "INVALID_NUMBERS",
+    146028888174u64 => "INVALID_OBJECT_IDENTIFIER",
+    146028888202u64 => "INVALID_OPTION",
+    146028888198u64 => "INVALID_POLICY_IDENTIFIER",
+    146028888217u64 => "INVALID_PROXY_POLICY_SETTING",
+    146028888210u64 => "INVALID_PURPOSE",
+    146028888228u64 => "INVALID_SAFI",
+    146028888199u64 => "INVALID_SECTION",
+    146028888207u64 => "INVALID_SYNTAX",
+    146028888190u64 => "ISSUER_DECODE_ERROR",
+    146028888188u64 => "MISSING_VALUE",
+    146028888206u64 => "NEED_ORGANIZATION_AND_NUMBERS",
+    146028888232u64 => "NEGATIVE_PATHLEN",
+    146028888200u64 => "NO_CONFIG_DATABASE",
+    146028888185u64 => "NO_ISSUER_CERTIFICATE",
+    146028888191u64 => "NO_ISSUER_DETAILS",
+    146028888203u64 => "NO_POLICY_IDENTIFIER",
+    146028888218u64 => "NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED",
+    146028888178u64 => "NO_PUBLIC_KEY",
+    146028888189u64 => "NO_SUBJECT_DETAILS",
+    146028888212u64 => "OPERATION_NOT_DEFINED",
+    146028888211u64 => "OTHERNAME_ERROR",
+    146028888219u64 => "POLICY_LANGUAGE_ALREADY_DEFINED",
+    146028888220u64 => "POLICY_PATH_LENGTH",
+    146028888221u64 => "POLICY_PATH_LENGTH_ALREADY_DEFINED",
+    146028888223u64 => "POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY",
+    146028888214u64 => "SECTION_NOT_FOUND",
+    146028888186u64 => "UNABLE_TO_GET_ISSUER_DETAILS",
+    146028888187u64 => "UNABLE_TO_GET_ISSUER_KEYID",
+    146028888175u64 => "UNKNOWN_BIT_STRING_ARGUMENT",
+    146028888193u64 => "UNKNOWN_EXTENSION",
+    146028888194u64 => "UNKNOWN_EXTENSION_NAME",
+    146028888184u64 => "UNKNOWN_OPTION",
+    146028888181u64 => "UNSUPPORTED_OPTION",
+    146028888231u64 => "UNSUPPORTED_TYPE",
+    146028888196u64 => "USER_TOO_LONG",
+    47244640366u64 => "AKID_MISMATCH",
+    47244640389u64 => "BAD_SELECTOR",
+    47244640356u64 => "BAD_X509_FILETYPE",
+    47244640374u64 => "BASE64_DECODE_ERROR",
+    47244640370u64 => "CANT_CHECK_DH_KEY",
+    47244640395u64 => "CERTIFICATE_VERIFICATION_FAILED",
+    47244640357u64 => "CERT_ALREADY_IN_HASH_TABLE",
+    47244640383u64 => "CRL_ALREADY_DELTA",
+    47244640387u64 => "CRL_VERIFY_FAILURE",
+    47244640396u64 => "DUPLICATE_ATTRIBUTE",
+    47244640397u64 => "ERROR_GETTING_MD_BY_NID",
+    47244640398u64 => "ERROR_USING_SIGINF_SET",
+    47244640384u64 => "IDP_MISMATCH",
+    47244640394u64 => "INVALID_ATTRIBUTES",
+    47244640369u64 => "INVALID_DIRECTORY",
+    47244640399u64 => "INVALID_DISTPOINT",
+    47244640375u64 => "INVALID_FIELD_NAME",
+    47244640379u64 => "INVALID_TRUST",
+    47244640385u64 => "ISSUER_MISMATCH",
+    47244640371u64 => "KEY_TYPE_MISMATCH",
+    47244640372u64 => "KEY_VALUES_MISMATCH",
+    47244640359u64 => "LOADING_CERT_DIR",
+    47244640360u64 => "LOADING_DEFAULTS",
+    47244640380u64 => "METHOD_NOT_SUPPORTED",
+    47244640390u64 => "NAME_TOO_LONG",
+    47244640388u64 => "NEWER_CRL_NOT_NEWER",
+    47244640391u64 => "NO_CERTIFICATE_FOUND",
+    47244640392u64 => "NO_CERTIFICATE_OR_CRL_FOUND",
+    47244640361u64 => "NO_CERT_SET_FOR_US_TO_VERIFY",
+    47244640393u64 => "NO_CRL_FOUND",
+    47244640386u64 => "NO_CRL_NUMBER",
+    47244640381u64 => "PUBLIC_KEY_DECODE_ERROR",
+    47244640382u64 => "PUBLIC_KEY_ENCODE_ERROR",
+    47244640362u64 => "SHOULD_RETRY",
+    47244640363u64 => "UNABLE_TO_FIND_PARAMETERS_IN_CHAIN",
+    47244640364u64 => "UNABLE_TO_GET_CERTS_PUBLIC_KEY",
+    47244640373u64 => "UNKNOWN_KEY_TYPE",
+    47244640365u64 => "UNKNOWN_NID",
+    47244640377u64 => "UNKNOWN_PURPOSE_ID",
+    47244640400u64 => "UNKNOWN_SIGID_ALGS",
+    47244640376u64 => "UNKNOWN_TRUST_ID",
+    47244640367u64 => "UNSUPPORTED_ALGORITHM",
+    47244640368u64 => "WRONG_LOOKUP_TYPE",
+    47244640378u64 => "WRONG_TYPE",
+};
+
+/// Helper function to create encoded key from (lib, reason) pair
+#[inline]
+pub fn encode_error_key(lib: i32, reason: i32) -> u64 {
+    ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF)
+}
diff --git a/crates/stdlib/src/overlapped.rs b/crates/stdlib/src/overlapped.rs
new file mode 100644
index 0000000000..664aa3f392
--- /dev/null
+++ b/crates/stdlib/src/overlapped.rs
@@ -0,0 +1,594 @@
+// spell-checker:disable
+
+pub(crate) use _overlapped::make_module;
+
+#[allow(non_snake_case)]
+#[pymodule]
+mod _overlapped {
+    // straight-forward port of Modules/overlapped.c
+
+    use crate::vm::{
+        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyBytesRef, PyType},
+        common::lock::PyMutex,
+        convert::{ToPyException, ToPyObject},
+        function::OptionalArg,
+        protocol::PyBuffer,
+        types::Constructor,
+    };
+    use windows_sys::Win32::{
+        Foundation::{self, GetLastError, HANDLE},
+        Networking::WinSock::{AF_INET, AF_INET6, SOCKADDR_IN, SOCKADDR_IN6},
+        System::IO::OVERLAPPED,
+    };
+
+    #[pyattr]
+    use windows_sys::Win32::{
+        Foundation::{
+            ERROR_IO_PENDING, ERROR_NETNAME_DELETED, ERROR_OPERATION_ABORTED, ERROR_PIPE_BUSY,
+            ERROR_PORT_UNREACHABLE, ERROR_SEM_TIMEOUT,
+        },
+        Networking::WinSock::{
+            SO_UPDATE_ACCEPT_CONTEXT, SO_UPDATE_CONNECT_CONTEXT, TF_REUSE_SOCKET,
+        },
+        System::Threading::INFINITE,
+    };
+
+    #[pyattr]
+    const INVALID_HANDLE_VALUE: isize =
+        unsafe { core::mem::transmute(windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE) };
+
+    #[pyattr]
+    const NULL: isize = 0;
+
+    #[pyattr]
+    #[pyclass(name)]
+    #[derive(PyPayload)]
+    struct Overlapped {
+        inner: PyMutex<OverlappedInner>,
+    }
+
+    struct OverlappedInner {
+        overlapped: OVERLAPPED,
+        handle: HANDLE,
+        error: u32,
+        data: OverlappedData,
+    }
+
+    unsafe impl Sync for OverlappedInner {}
+    unsafe impl Send for OverlappedInner {}
+
+    impl core::fmt::Debug for Overlapped {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            let zelf = self.inner.lock();
+            f.debug_struct("Overlapped")
+                // .field("overlapped", &(self.overlapped as *const _ as usize))
+                .field("handle", &zelf.handle)
+                .field("error", &zelf.error)
+                .field("data", &zelf.data)
+                .finish()
+        }
+    }
+
+    #[allow(dead_code)] // TODO: remove when done
+    #[derive(Debug)]
+    enum OverlappedData {
+        None,
+        NotStarted,
+        Read(PyBytesRef),
+        ReadInto(PyBuffer),
+        Write(PyBuffer),
+        Accept(PyObjectRef),
+        Connect,
+        Disconnect,
+        ConnectNamedPipe,
+        WaitNamedPipeAndConnect,
+        TransmitFile,
+        ReadFrom(OverlappedReadFrom),
+        WriteTo(PyBuffer),
+        ReadFromInto(OverlappedReadFromInto),
+    }
+
+    struct OverlappedReadFrom {
+        // A (buffer, (host, port)) tuple
+        result: PyObjectRef,
+        // The actual read buffer
+        allocated_buffer: PyObjectRef,
+        #[allow(dead_code)]
+        address: SOCKADDR_IN6, // TODO: remove when done
+        address_length: libc::c_int,
+    }
+
+    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", &self.address)
+                .field("address_length", &self.address_length)
+                .finish()
+        }
+    }
+
+    struct OverlappedReadFromInto {
+        // A (number of bytes read, (host, port)) tuple
+        result: PyObjectRef,
+        /* Buffer passed by the user */
+        user_buffer: PyBuffer,
+        #[allow(dead_code)]
+        address: SOCKADDR_IN6, // TODO: remove when done
+        address_length: libc::c_int,
+    }
+
+    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", &self.address)
+                .field("address_length", &self.address_length)
+                .finish()
+        }
+    }
+
+    fn mark_as_completed(ov: &mut OVERLAPPED) {
+        ov.Internal = 0;
+        if !ov.hEvent.is_null() {
+            unsafe { windows_sys::Win32::System::Threading::SetEvent(ov.hEvent) };
+        }
+    }
+
+    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),
+        };
+        // TODO: set errno and winerror
+        vm.new_exception_empty(exc.to_owned())
+    }
+
+    fn HasOverlappedIoCompleted(overlapped: &OVERLAPPED) -> bool {
+        overlapped.Internal != (Foundation::STATUS_PENDING as usize)
+    }
+
+    /// Parse a SOCKADDR_IN6 (which can also hold IPv4 addresses) to a Python address tuple
+    fn unparse_address(
+        addr: &SOCKADDR_IN6,
+        _addr_len: libc::c_int,
+        vm: &VirtualMachine,
+    ) -> PyObjectRef {
+        use crate::vm::convert::ToPyObject;
+
+        unsafe {
+            let family = addr.sin6_family;
+            if family == AF_INET {
+                // IPv4 address stored in SOCKADDR_IN6 structure
+                let addr_in = &*(addr as *const SOCKADDR_IN6 as *const SOCKADDR_IN);
+                let ip_bytes = addr_in.sin_addr.S_un.S_un_b;
+                let ip_str = format!(
+                    "{}.{}.{}.{}",
+                    ip_bytes.s_b1, ip_bytes.s_b2, ip_bytes.s_b3, ip_bytes.s_b4
+                );
+                let port = u16::from_be(addr_in.sin_port);
+                (ip_str, port).to_pyobject(vm)
+            } else if family == AF_INET6 {
+                // IPv6 address
+                let ip_bytes = addr.sin6_addr.u.Byte;
+                let ip_str = format!(
+                    "{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}",
+                    u16::from_be_bytes([ip_bytes[0], ip_bytes[1]]),
+                    u16::from_be_bytes([ip_bytes[2], ip_bytes[3]]),
+                    u16::from_be_bytes([ip_bytes[4], ip_bytes[5]]),
+                    u16::from_be_bytes([ip_bytes[6], ip_bytes[7]]),
+                    u16::from_be_bytes([ip_bytes[8], ip_bytes[9]]),
+                    u16::from_be_bytes([ip_bytes[10], ip_bytes[11]]),
+                    u16::from_be_bytes([ip_bytes[12], ip_bytes[13]]),
+                    u16::from_be_bytes([ip_bytes[14], ip_bytes[15]]),
+                );
+                let port = u16::from_be(addr.sin6_port);
+                let flowinfo = addr.sin6_flowinfo;
+                let scope_id = addr.Anonymous.sin6_scope_id;
+                (ip_str, port, flowinfo, scope_id).to_pyobject(vm)
+            } else {
+                // Unknown address family, return None
+                vm.ctx.none()
+            }
+        }
+    }
+
+    #[pyclass(with(Constructor))]
+    impl Overlapped {
+        #[pygetset]
+        fn address(&self, _vm: &VirtualMachine) -> usize {
+            let inner = self.inner.lock();
+            &inner.overlapped as *const _ as usize
+        }
+
+        #[pygetset]
+        fn pending(&self, _vm: &VirtualMachine) -> bool {
+            let inner = self.inner.lock();
+            !HasOverlappedIoCompleted(&inner.overlapped)
+                && !matches!(inner.data, OverlappedData::NotStarted)
+        }
+
+        fn WSARecv_inner(
+            inner: &mut OverlappedInner,
+            handle: isize,
+            buf: &[u8],
+            mut flags: u32,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            use windows_sys::Win32::Foundation::{
+                ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_SUCCESS,
+            };
+
+            let wsabuf = windows_sys::Win32::Networking::WinSock::WSABUF {
+                buf: buf.as_ptr() as *mut _,
+                len: buf.len() as _,
+            };
+            let mut n_read: u32 = 0;
+            // TODO: optimization with MaybeUninit
+            let ret = unsafe {
+                windows_sys::Win32::Networking::WinSock::WSARecv(
+                    handle as _,
+                    &wsabuf,
+                    1,
+                    &mut n_read,
+                    &mut flags,
+                    &mut inner.overlapped,
+                    None,
+                )
+            };
+            let err = if ret < 0 {
+                unsafe { windows_sys::Win32::Networking::WinSock::WSAGetLastError() as u32 }
+            } else {
+                Foundation::ERROR_SUCCESS
+            };
+            inner.error = err;
+            match err {
+                ERROR_BROKEN_PIPE => {
+                    mark_as_completed(&mut inner.overlapped);
+                    Err(from_windows_err(err, vm))
+                }
+                ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
+                _ => Err(from_windows_err(err, vm)),
+            }
+        }
+
+        #[pymethod]
+        fn WSARecv(
+            zelf: &Py<Self>,
+            handle: isize,
+            size: u32,
+            flags: u32,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let mut inner = zelf.inner.lock();
+            if !matches!(inner.data, OverlappedData::None) {
+                return Err(vm.new_value_error("operation already attempted"));
+            }
+
+            #[cfg(target_pointer_width = "32")]
+            let size = core::cmp::min(size, std::isize::MAX as _);
+
+            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
+            let buf = vm.ctx.new_bytes(buf);
+            inner.handle = handle as _;
+
+            let r = Self::WSARecv_inner(&mut inner, handle as _, buf.as_bytes(), flags, vm);
+            inner.data = OverlappedData::Read(buf);
+            r
+        }
+
+        #[pymethod]
+        fn cancel(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+            let inner = zelf.inner.lock();
+            if matches!(
+                inner.data,
+                OverlappedData::NotStarted | OverlappedData::WaitNamedPipeAndConnect
+            ) {
+                return Ok(());
+            }
+            let ret = if !HasOverlappedIoCompleted(&inner.overlapped) {
+                unsafe {
+                    windows_sys::Win32::System::IO::CancelIoEx(inner.handle, &inner.overlapped)
+                }
+            } else {
+                1
+            };
+            // 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());
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn getresult(zelf: &Py<Self>, wait: OptionalArg<bool>, vm: &VirtualMachine) -> PyResult {
+            use windows_sys::Win32::Foundation::{
+                ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_SUCCESS,
+            };
+            use windows_sys::Win32::System::IO::GetOverlappedResult;
+
+            let mut inner = zelf.inner.lock();
+            let wait = wait.unwrap_or(false);
+
+            // Check operation state
+            if matches!(inner.data, OverlappedData::None) {
+                return Err(vm.new_value_error("operation not yet attempted".to_owned()));
+            }
+            if matches!(inner.data, OverlappedData::NotStarted) {
+                return Err(vm.new_value_error("operation failed to start".to_owned()));
+            }
+
+            // Get the result
+            let mut transferred: u32 = 0;
+            let ret = unsafe {
+                GetOverlappedResult(
+                    inner.handle,
+                    &inner.overlapped,
+                    &mut transferred,
+                    if wait { 1 } else { 0 },
+                )
+            };
+
+            let err = if ret != 0 {
+                ERROR_SUCCESS
+            } else {
+                unsafe { GetLastError() }
+            };
+            inner.error = err;
+
+            // Handle errors
+            match err {
+                ERROR_SUCCESS | ERROR_MORE_DATA => {}
+                ERROR_BROKEN_PIPE => {
+                    // For read operations, broken pipe is acceptable
+                    match &inner.data {
+                        OverlappedData::Read(_) | OverlappedData::ReadInto(_) => {}
+                        OverlappedData::ReadFrom(rf)
+                            if rf.result.is(&vm.ctx.none())
+                                || rf.allocated_buffer.is(&vm.ctx.none()) =>
+                        {
+                            return Err(from_windows_err(err, vm));
+                        }
+                        OverlappedData::ReadFrom(_) => {}
+                        OverlappedData::ReadFromInto(rfi) if rfi.result.is(&vm.ctx.none()) => {
+                            return Err(from_windows_err(err, vm));
+                        }
+                        OverlappedData::ReadFromInto(_) => {}
+                        _ => return Err(from_windows_err(err, vm)),
+                    }
+                }
+                ERROR_IO_PENDING => {
+                    return Err(from_windows_err(err, vm));
+                }
+                _ => return Err(from_windows_err(err, vm)),
+            }
+
+            // Return result based on operation type
+            match &inner.data {
+                OverlappedData::Read(buf) => {
+                    // Resize buffer to actual bytes read
+                    let bytes = buf.as_bytes();
+                    let result = if transferred as usize != bytes.len() {
+                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    } else {
+                        buf.clone()
+                    };
+                    Ok(result.into())
+                }
+                OverlappedData::ReadInto(_) => {
+                    // Return number of bytes read
+                    Ok(vm.ctx.new_int(transferred).into())
+                }
+                OverlappedData::Write(_) => {
+                    // Return number of bytes written
+                    Ok(vm.ctx.new_int(transferred).into())
+                }
+                OverlappedData::Accept(_) => {
+                    // Return None for accept
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::Connect => {
+                    // Return None for connect
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::Disconnect => {
+                    // Return None for disconnect
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::ConnectNamedPipe => {
+                    // Return None for connect named pipe
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::WaitNamedPipeAndConnect => {
+                    // Return None
+                    Ok(vm.ctx.none())
+                }
+                OverlappedData::ReadFrom(rf) => {
+                    // Return (resized_buffer, (host, port)) tuple
+                    let buf = rf
+                        .allocated_buffer
+                        .downcast_ref::<crate::vm::builtins::PyBytes>()
+                        .unwrap();
+                    let bytes = buf.as_bytes();
+                    let resized_buf = if transferred as usize != bytes.len() {
+                        vm.ctx.new_bytes(bytes[..transferred as usize].to_vec())
+                    } else {
+                        buf.to_owned()
+                    };
+                    let addr_tuple = unparse_address(&rf.address, rf.address_length, vm);
+                    Ok(vm
+                        .ctx
+                        .new_tuple(vec![resized_buf.into(), addr_tuple])
+                        .into())
+                }
+                OverlappedData::ReadFromInto(rfi) => {
+                    // Return (transferred, (host, port)) tuple
+                    let addr_tuple = unparse_address(&rfi.address, rfi.address_length, vm);
+                    Ok(vm
+                        .ctx
+                        .new_tuple(vec![vm.ctx.new_int(transferred).into(), addr_tuple])
+                        .into())
+                }
+                _ => Ok(vm.ctx.none()),
+            }
+        }
+    }
+
+    impl Constructor for Overlapped {
+        type Args = (isize,);
+
+        fn py_new(
+            _cls: &Py<PyType>,
+            (mut event,): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            if event == INVALID_HANDLE_VALUE {
+                event = unsafe {
+                    windows_sys::Win32::System::Threading::CreateEventA(
+                        core::ptr::null(),
+                        Foundation::TRUE,
+                        Foundation::FALSE,
+                        core::ptr::null(),
+                    ) as isize
+                };
+                if event == NULL {
+                    return Err(vm.new_last_os_error());
+                }
+            }
+
+            let mut overlapped: OVERLAPPED = unsafe { std::mem::zeroed() };
+            if event != NULL {
+                overlapped.hEvent = event as _;
+            }
+            let inner = OverlappedInner {
+                overlapped,
+                handle: NULL as _,
+                error: 0,
+                data: OverlappedData::None,
+            };
+            Ok(Overlapped {
+                inner: PyMutex::new(inner),
+            })
+        }
+    }
+
+    unsafe fn u64_to_handle(raw_ptr_value: u64) -> HANDLE {
+        raw_ptr_value as HANDLE
+    }
+
+    #[pyfunction]
+    fn CreateIoCompletionPort(
+        handle: isize,
+        port: isize,
+        key: usize,
+        concurrency: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<isize> {
+        let r = unsafe {
+            windows_sys::Win32::System::IO::CreateIoCompletionPort(
+                handle as _,
+                port as _,
+                key,
+                concurrency,
+            ) as isize
+        };
+        if r as usize == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(r)
+    }
+
+    #[pyfunction]
+    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 ret = unsafe {
+            windows_sys::Win32::System::IO::GetQueuedCompletionStatus(
+                port as _,
+                &mut bytes_transferred,
+                &mut completion_key,
+                &mut overlapped,
+                msecs,
+            )
+        };
+        let err = if ret != 0 {
+            Foundation::ERROR_SUCCESS
+        } else {
+            unsafe { Foundation::GetLastError() }
+        };
+        if overlapped.is_null() {
+            if err == Foundation::WAIT_TIMEOUT {
+                return Ok(vm.ctx.none());
+            } else {
+                return Err(vm.new_last_os_error());
+            }
+        }
+
+        let value = vm.ctx.new_tuple(vec![
+            err.to_pyobject(vm),
+            completion_key.to_pyobject(vm),
+            bytes_transferred.to_pyobject(vm),
+            (overlapped as usize).to_pyobject(vm),
+        ]);
+        Ok(value.into())
+    }
+
+    #[pyfunction]
+    fn CreateEvent(
+        event_attributes: PyObjectRef,
+        manual_reset: bool,
+        initial_state: bool,
+        name: Option<String>,
+        vm: &VirtualMachine,
+    ) -> PyResult<isize> {
+        if !vm.is_none(&event_attributes) {
+            return Err(vm.new_value_error("EventAttributes must be None"));
+        }
+
+        let name = match name {
+            Some(name) => {
+                let name = widestring::WideCString::from_str(&name).unwrap();
+                name.as_ptr()
+            }
+            None => core::ptr::null(),
+        };
+        let event = unsafe {
+            windows_sys::Win32::System::Threading::CreateEventW(
+                core::ptr::null(),
+                manual_reset as _,
+                initial_state as _,
+                name,
+            ) as isize
+        };
+        if event == NULL {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(event)
+    }
+
+    #[pyfunction]
+    fn SetEvent(handle: u64, vm: &VirtualMachine) -> PyResult<()> {
+        let ret = unsafe { windows_sys::Win32::System::Threading::SetEvent(u64_to_handle(handle)) };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn ResetEvent(handle: u64, vm: &VirtualMachine) -> PyResult<()> {
+        let ret =
+            unsafe { windows_sys::Win32::System::Threading::ResetEvent(u64_to_handle(handle)) };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+}
diff --git a/crates/stdlib/src/posixshmem.rs b/crates/stdlib/src/posixshmem.rs
new file mode 100644
index 0000000000..a52866b798
--- /dev/null
+++ b/crates/stdlib/src/posixshmem.rs
@@ -0,0 +1,50 @@
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+pub(crate) use _posixshmem::make_module;
+
+#[cfg(all(unix, not(target_os = "redox"), not(target_os = "android")))]
+#[pymodule]
+mod _posixshmem {
+    use alloc::ffi::CString;
+
+    use crate::{
+        common::os::errno_io_error,
+        vm::{FromArgs, PyResult, VirtualMachine, builtins::PyStrRef, convert::IntoPyException},
+    };
+
+    #[derive(FromArgs)]
+    struct ShmOpenArgs {
+        #[pyarg(any)]
+        name: PyStrRef,
+        #[pyarg(any)]
+        flags: libc::c_int,
+        #[pyarg(any, default = 0o600)]
+        mode: libc::mode_t,
+    }
+
+    #[pyfunction]
+    fn shm_open(args: ShmOpenArgs, vm: &VirtualMachine) -> PyResult<libc::c_int> {
+        let name = CString::new(args.name.as_str()).map_err(|e| e.into_pyexception(vm))?;
+        let mode: libc::c_uint = args.mode as _;
+        #[cfg(target_os = "freebsd")]
+        let mode = mode.try_into().unwrap();
+        // SAFETY: `name` is a NUL-terminated string and `shm_open` does not write through it.
+        let fd = unsafe { libc::shm_open(name.as_ptr(), args.flags, mode) };
+        if fd == -1 {
+            Err(errno_io_error().into_pyexception(vm))
+        } else {
+            Ok(fd)
+        }
+    }
+
+    #[pyfunction]
+    fn shm_unlink(name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let name = CString::new(name.as_str()).map_err(|e| e.into_pyexception(vm))?;
+        // SAFETY: `name` is a valid NUL-terminated string and `shm_unlink` only reads it.
+        let ret = unsafe { libc::shm_unlink(name.as_ptr()) };
+        if ret == -1 {
+            Err(errno_io_error().into_pyexception(vm))
+        } else {
+            Ok(())
+        }
+    }
+}
diff --git a/crates/stdlib/src/posixsubprocess.rs b/crates/stdlib/src/posixsubprocess.rs
new file mode 100644
index 0000000000..a6badc081d
--- /dev/null
+++ b/crates/stdlib/src/posixsubprocess.rs
@@ -0,0 +1,538 @@
+// spell-checker:disable
+
+use crate::vm::{
+    builtins::PyListRef,
+    function::ArgSequence,
+    ospath::OsPath,
+    stdlib::posix,
+    {PyObjectRef, PyResult, TryFromObject, VirtualMachine},
+};
+use itertools::Itertools;
+use nix::{
+    errno::Errno,
+    unistd::{self, Pid},
+};
+use std::{
+    io::prelude::*,
+    os::fd::{AsFd, AsRawFd, BorrowedFd, IntoRawFd, OwnedFd, RawFd},
+};
+use unistd::{Gid, Uid};
+
+use alloc::ffi::CString;
+
+use core::{convert::Infallible as Never, ffi::CStr, marker::PhantomData, ops::Deref};
+
+pub(crate) use _posixsubprocess::make_module;
+
+#[pymodule]
+mod _posixsubprocess {
+    use rustpython_vm::{AsObject, TryFromBorrowedObject};
+
+    use super::*;
+    use crate::vm::{PyResult, VirtualMachine, convert::IntoPyException};
+
+    #[pyfunction]
+    fn fork_exec(args: ForkExecArgs<'_>, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
+        // Check for interpreter shutdown when preexec_fn is used
+        if args.preexec_fn.is_some()
+            && vm
+                .state
+                .finalizing
+                .load(std::sync::atomic::Ordering::Acquire)
+        {
+            return Err(vm.new_python_finalization_error(
+                "preexec_fn not supported at interpreter shutdown".to_owned(),
+            ));
+        }
+
+        let extra_groups = args
+            .groups_list
+            .as_ref()
+            .map(|l| Vec::<Gid>::try_from_borrowed_object(vm, l.as_object()))
+            .transpose()?;
+        let argv = CharPtrVec::from_iter(args.args.iter());
+        let envp = args.env_list.as_ref().map(CharPtrVec::from_iter);
+        let procargs = ProcArgs {
+            argv: &argv,
+            envp: envp.as_deref(),
+            extra_groups: extra_groups.as_deref(),
+        };
+        match unsafe { nix::unistd::fork() }.map_err(|err| err.into_pyexception(vm))? {
+            nix::unistd::ForkResult::Child => exec(&args, procargs, vm),
+            nix::unistd::ForkResult::Parent { child } => Ok(child.as_raw()),
+        }
+    }
+}
+
+macro_rules! gen_args {
+    ($($field:ident: $t:ty),*$(,)?) => {
+        #[derive(FromArgs)]
+        struct ForkExecArgs<'fd> {
+            $(#[pyarg(positional)] $field: $t,)*
+        }
+    };
+}
+
+struct CStrPathLike {
+    s: CString,
+}
+impl TryFromObject for CStrPathLike {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let s = OsPath::try_from_object(vm, obj)?.into_cstring(vm)?;
+        Ok(Self { s })
+    }
+}
+impl AsRef<CStr> for CStrPathLike {
+    fn as_ref(&self) -> &CStr {
+        &self.s
+    }
+}
+
+#[derive(Default)]
+struct CharPtrVec<'a> {
+    vec: Vec<*const libc::c_char>,
+    marker: PhantomData<Vec<&'a CStr>>,
+}
+
+impl<'a, T: AsRef<CStr>> FromIterator<&'a T> for CharPtrVec<'a> {
+    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
+        let vec = iter
+            .into_iter()
+            .map(|x| x.as_ref().as_ptr())
+            .chain(core::iter::once(core::ptr::null()))
+            .collect();
+        Self {
+            vec,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a> Deref for CharPtrVec<'a> {
+    type Target = CharPtrSlice<'a>;
+    fn deref(&self) -> &Self::Target {
+        unsafe {
+            &*(self.vec.as_slice() as *const [*const libc::c_char] as *const CharPtrSlice<'a>)
+        }
+    }
+}
+
+#[repr(transparent)]
+struct CharPtrSlice<'a> {
+    marker: PhantomData<[&'a CStr]>,
+    slice: [*const libc::c_char],
+}
+
+impl CharPtrSlice<'_> {
+    const fn as_ptr(&self) -> *const *const libc::c_char {
+        self.slice.as_ptr()
+    }
+}
+
+#[derive(Copy, Clone)]
+struct Fd(BorrowedFd<'static>);
+
+impl TryFromObject for Fd {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        match MaybeFd::try_from_object(vm, obj)? {
+            MaybeFd::Valid(fd) => Ok(fd),
+            MaybeFd::Invalid => Err(vm.new_value_error("invalid fd")),
+        }
+    }
+}
+
+impl Write for Fd {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        Ok(unistd::write(self, buf)?)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+impl AsRawFd for Fd {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
+impl IntoRawFd for Fd {
+    fn into_raw_fd(self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
+impl AsFd for Fd {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.0.as_fd()
+    }
+}
+
+impl From<OwnedFd> for Fd {
+    fn from(fd: OwnedFd) -> Self {
+        Self(unsafe { BorrowedFd::borrow_raw(fd.into_raw_fd()) })
+    }
+}
+
+#[derive(Copy, Clone)]
+enum MaybeFd {
+    Valid(Fd),
+    Invalid,
+}
+
+impl TryFromObject for MaybeFd {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let fd = i32::try_from_object(vm, obj)?;
+        Ok(if fd == -1 {
+            MaybeFd::Invalid
+        } else {
+            MaybeFd::Valid(Fd(unsafe { BorrowedFd::borrow_raw(fd) }))
+        })
+    }
+}
+
+impl AsRawFd for MaybeFd {
+    fn as_raw_fd(&self) -> RawFd {
+        match self {
+            MaybeFd::Valid(fd) => fd.as_raw_fd(),
+            MaybeFd::Invalid => -1,
+        }
+    }
+}
+
+// impl
+
+gen_args! {
+    args: ArgSequence<CStrPathLike> /* list */,
+    exec_list: ArgSequence<CStrPathLike> /* list */,
+    close_fds: bool,
+    fds_to_keep: ArgSequence<BorrowedFd<'fd>>,
+    cwd: Option<CStrPathLike>,
+    env_list: Option<ArgSequence<CStrPathLike>>,
+    p2cread: MaybeFd,
+    p2cwrite: MaybeFd,
+    c2pread: MaybeFd,
+    c2pwrite: MaybeFd,
+    errread: MaybeFd,
+    errwrite: MaybeFd,
+    errpipe_read: Fd,
+    errpipe_write: Fd,
+    restore_signals: bool,
+    call_setsid: bool,
+    pgid_to_set: libc::pid_t,
+    gid: Option<Gid>,
+    groups_list: Option<PyListRef>,
+    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
+struct ProcArgs<'a> {
+    argv: &'a CharPtrSlice<'a>,
+    envp: Option<&'a CharPtrSlice<'a>>,
+    extra_groups: Option<&'a [Gid]>,
+}
+
+fn exec(args: &ForkExecArgs<'_>, procargs: ProcArgs<'_>, vm: &VirtualMachine) -> ! {
+    let mut ctx = ExecErrorContext::NoExec;
+    match exec_inner(args, procargs, &mut ctx, vm) {
+        Ok(x) => match x {},
+        Err(e) => {
+            let mut pipe = args.errpipe_write;
+            if matches!(ctx, ExecErrorContext::PreExec) {
+                // For preexec_fn errors, use SubprocessError format (errno=0)
+                let _ = write!(pipe, "SubprocessError:0:{}", ctx.as_msg());
+            } else {
+                // errno is written in hex format
+                let _ = write!(pipe, "OSError:{:x}:{}", e as i32, ctx.as_msg());
+            }
+            std::process::exit(255)
+        }
+    }
+}
+
+enum ExecErrorContext {
+    NoExec,
+    ChDir,
+    PreExec,
+    Exec,
+}
+
+impl ExecErrorContext {
+    const fn as_msg(&self) -> &'static str {
+        match self {
+            Self::NoExec => "noexec",
+            Self::ChDir => "noexec:chdir",
+            Self::PreExec => "Exception occurred in preexec_fn.",
+            Self::Exec => "",
+        }
+    }
+}
+
+fn exec_inner(
+    args: &ForkExecArgs<'_>,
+    procargs: ProcArgs<'_>,
+    ctx: &mut ExecErrorContext,
+    vm: &VirtualMachine,
+) -> nix::Result<Never> {
+    for &fd in args.fds_to_keep.as_slice() {
+        if fd.as_raw_fd() != args.errpipe_write.as_raw_fd() {
+            posix::set_inheritable(fd, true)?
+        }
+    }
+
+    for &fd in &[args.p2cwrite, args.c2pread, args.errread] {
+        if let MaybeFd::Valid(fd) = fd {
+            unistd::close(fd)?;
+        }
+    }
+    unistd::close(args.errpipe_read)?;
+
+    let c2pwrite = match args.c2pwrite {
+        MaybeFd::Valid(c2pwrite) if c2pwrite.as_raw_fd() == 0 => {
+            let fd = unistd::dup(c2pwrite)?;
+            posix::set_inheritable(fd.as_fd(), true)?;
+            MaybeFd::Valid(fd.into())
+        }
+        fd => fd,
+    };
+
+    let mut errwrite = args.errwrite;
+    loop {
+        match errwrite {
+            MaybeFd::Valid(fd) if fd.as_raw_fd() == 0 || fd.as_raw_fd() == 1 => {
+                let fd = unistd::dup(fd)?;
+                posix::set_inheritable(fd.as_fd(), true)?;
+                errwrite = MaybeFd::Valid(fd.into());
+            }
+            _ => break,
+        }
+    }
+
+    fn dup_into_stdio<F>(fd: MaybeFd, io_fd: i32, dup2_stdio: F) -> nix::Result<()>
+    where
+        F: Fn(Fd) -> nix::Result<()>,
+    {
+        match fd {
+            MaybeFd::Valid(fd) if fd.as_raw_fd() == io_fd => {
+                posix::set_inheritable(fd.as_fd(), true)
+            }
+            MaybeFd::Valid(fd) => dup2_stdio(fd),
+            MaybeFd::Invalid => Ok(()),
+        }
+    }
+    dup_into_stdio(args.p2cread, 0, unistd::dup2_stdin)?;
+    dup_into_stdio(c2pwrite, 1, unistd::dup2_stdout)?;
+    dup_into_stdio(errwrite, 2, unistd::dup2_stderr)?;
+
+    if let Some(ref cwd) = args.cwd {
+        unistd::chdir(cwd.s.as_c_str()).inspect_err(|_| *ctx = ExecErrorContext::ChDir)?
+    }
+
+    if args.child_umask >= 0 {
+        unsafe { libc::umask(args.child_umask as libc::mode_t) };
+    }
+
+    if args.restore_signals {
+        unsafe {
+            libc::signal(libc::SIGPIPE, libc::SIG_DFL);
+            libc::signal(libc::SIGXFSZ, libc::SIG_DFL);
+        }
+    }
+
+    if args.call_setsid {
+        unistd::setsid()?;
+    }
+
+    if args.pgid_to_set > -1 {
+        unistd::setpgid(Pid::from_raw(0), Pid::from_raw(args.pgid_to_set))?;
+    }
+
+    if let Some(_groups) = procargs.extra_groups {
+        #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
+        unistd::setgroups(_groups)?;
+    }
+
+    if let Some(gid) = args.gid.filter(|x| x.as_raw() != u32::MAX) {
+        let ret = unsafe { libc::setregid(gid.as_raw(), gid.as_raw()) };
+        nix::Error::result(ret)?;
+    }
+
+    if let Some(uid) = args.uid.filter(|x| x.as_raw() != u32::MAX) {
+        let ret = unsafe { libc::setreuid(uid.as_raw(), uid.as_raw()) };
+        nix::Error::result(ret)?;
+    }
+
+    // Call preexec_fn after all process setup but before closing FDs
+    if let Some(ref preexec_fn) = args.preexec_fn {
+        match preexec_fn.call((), vm) {
+            Ok(_) => {}
+            Err(_e) => {
+                // Cannot safely stringify exception after fork
+                *ctx = ExecErrorContext::PreExec;
+                return Err(Errno::UnknownErrno);
+            }
+        }
+    }
+
+    *ctx = ExecErrorContext::Exec;
+
+    if args.close_fds {
+        close_fds(KeepFds {
+            above: 2,
+            keep: &args.fds_to_keep,
+        });
+    }
+
+    let mut first_err = None;
+    for exec in args.exec_list.as_slice() {
+        // not using nix's versions of these functions because those allocate the char-ptr array,
+        // and we can't allocate
+        if let Some(envp) = procargs.envp {
+            unsafe { libc::execve(exec.s.as_ptr(), procargs.argv.as_ptr(), envp.as_ptr()) };
+        } else {
+            unsafe { libc::execv(exec.s.as_ptr(), procargs.argv.as_ptr()) };
+        }
+        let e = Errno::last();
+        if e != Errno::ENOENT && e != Errno::ENOTDIR && first_err.is_none() {
+            first_err = Some(e)
+        }
+    }
+    Err(first_err.unwrap_or_else(Errno::last))
+}
+
+#[derive(Copy, Clone)]
+struct KeepFds<'a> {
+    above: i32,
+    keep: &'a [BorrowedFd<'a>],
+}
+
+impl KeepFds<'_> {
+    fn should_keep(self, fd: i32) -> bool {
+        fd > self.above
+            && self
+                .keep
+                .binary_search_by_key(&fd, BorrowedFd::as_raw_fd)
+                .is_err()
+    }
+}
+
+fn close_fds(keep: KeepFds<'_>) {
+    #[cfg(not(target_os = "redox"))]
+    if close_dir_fds(keep).is_ok() {
+        return;
+    }
+    #[cfg(target_os = "redox")]
+    if close_filetable_fds(keep).is_ok() {
+        return;
+    }
+    close_fds_brute_force(keep)
+}
+
+#[cfg(not(target_os = "redox"))]
+fn close_dir_fds(keep: KeepFds<'_>) -> nix::Result<()> {
+    use nix::{dir::Dir, fcntl::OFlag};
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+    ))]
+    let fd_dir_name = c"/dev/fd";
+
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    let fd_dir_name = c"/proc/self/fd";
+
+    let mut dir = Dir::open(
+        fd_dir_name,
+        OFlag::O_RDONLY | OFlag::O_DIRECTORY,
+        nix::sys::stat::Mode::empty(),
+    )?;
+    let dirfd = dir.as_raw_fd();
+    'outer: for e in dir.iter() {
+        let e = e?;
+        let mut parser = IntParser::default();
+        for &c in e.file_name().to_bytes() {
+            if parser.feed(c).is_err() {
+                continue 'outer;
+            }
+        }
+        let fd = parser.num;
+        if fd != dirfd && keep.should_keep(fd) {
+            let _ = unistd::close(fd);
+        }
+    }
+    Ok(())
+}
+
+#[cfg(target_os = "redox")]
+fn close_filetable_fds(keep: KeepFds<'_>) -> nix::Result<()> {
+    use nix::fcntl;
+    use std::os::fd::{FromRawFd, OwnedFd};
+    let filetable = fcntl::open(
+        c"/scheme/thisproc/current/filetable",
+        fcntl::OFlag::O_RDONLY,
+        nix::sys::stat::Mode::empty(),
+    )?;
+    let read_one = || -> nix::Result<_> {
+        let mut byte = 0;
+        let n = nix::unistd::read(&filetable, std::slice::from_mut(&mut byte))?;
+        Ok((n > 0).then_some(byte))
+    };
+    while let Some(c) = read_one()? {
+        let mut parser = IntParser::default();
+        if parser.feed(c).is_err() {
+            continue;
+        }
+        let done = loop {
+            let Some(c) = read_one()? else { break true };
+            if parser.feed(c).is_err() {
+                break false;
+            }
+        };
+
+        let fd = parser.num as i32;
+        if fd != filetable.as_raw_fd() && keep.should_keep(fd) {
+            let _ = unistd::close(fd);
+        }
+        if done {
+            break;
+        }
+    }
+    Ok(())
+}
+
+fn close_fds_brute_force(keep: KeepFds<'_>) {
+    let max_fd = nix::unistd::sysconf(nix::unistd::SysconfVar::OPEN_MAX)
+        .ok()
+        .flatten()
+        .unwrap_or(256) as i32;
+    let fds = itertools::chain![
+        Some(keep.above),
+        keep.keep.iter().map(BorrowedFd::as_raw_fd),
+        Some(max_fd)
+    ];
+    for fd in fds.tuple_windows().flat_map(|(start, end)| start + 1..end) {
+        unsafe { libc::close(fd) };
+    }
+}
+
+#[derive(Default)]
+struct IntParser {
+    num: i32,
+}
+
+struct NonDigit;
+impl IntParser {
+    fn feed(&mut self, c: u8) -> Result<(), NonDigit> {
+        let digit = (c as char).to_digit(10).ok_or(NonDigit)?;
+        self.num *= 10;
+        self.num += digit as i32;
+        Ok(())
+    }
+}
diff --git a/crates/stdlib/src/pyexpat.rs b/crates/stdlib/src/pyexpat.rs
new file mode 100644
index 0000000000..89cf690770
--- /dev/null
+++ b/crates/stdlib/src/pyexpat.rs
@@ -0,0 +1,424 @@
+//! Pyexpat builtin module
+
+// spell-checker: ignore libexpat
+
+use crate::vm::{PyRef, VirtualMachine, builtins::PyModule, extend_module};
+
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _pyexpat::make_module(vm);
+
+    extend_module!(vm, &module, {
+         "errors" => _errors::make_module(vm),
+         "model" => _model::make_module(vm),
+    });
+
+    module
+}
+
+macro_rules! create_property {
+    ($ctx: expr, $attributes: expr, $name: expr, $class: expr, $element: ident) => {
+        let attr = $ctx.new_static_getset(
+            $name,
+            $class,
+            move |this: &PyExpatLikeXmlParser| this.$element.read().clone(),
+            move |this: &PyExpatLikeXmlParser, func: PyObjectRef| *this.$element.write() = func,
+        );
+
+        $attributes.insert($ctx.intern_str($name), attr.into());
+    };
+}
+
+macro_rules! create_bool_property {
+    ($ctx: expr, $attributes: expr, $name: expr, $class: expr, $element: ident) => {
+        let attr = $ctx.new_static_getset(
+            $name,
+            $class,
+            move |this: &PyExpatLikeXmlParser| this.$element.read().clone(),
+            move |this: &PyExpatLikeXmlParser,
+                  value: PyObjectRef,
+                  vm: &VirtualMachine|
+                  -> PyResult<()> {
+                let bool_value = value.is_true(vm)?;
+                *this.$element.write() = vm.ctx.new_bool(bool_value).into();
+                Ok(())
+            },
+        );
+
+        $attributes.insert($ctx.intern_str($name), attr.into());
+    };
+}
+
+#[pymodule(name = "pyexpat")]
+mod _pyexpat {
+    use crate::vm::{
+        Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+        builtins::{PyBytesRef, PyStr, PyStrRef, PyType},
+        function::ArgBytesLike,
+        function::{Either, IntoFuncArgs, OptionalArg},
+    };
+    use rustpython_common::lock::PyRwLock;
+    use std::io::Cursor;
+    use xml::reader::XmlEvent;
+
+    type MutableObject = PyRwLock<PyObjectRef>;
+
+    #[pyattr(name = "version_info")]
+    pub const VERSION_INFO: (u32, u32, u32) = (2, 7, 1);
+
+    #[pyattr]
+    #[pyclass(name = "xmlparser", module = false, traverse)]
+    #[derive(Debug, PyPayload)]
+    pub struct PyExpatLikeXmlParser {
+        #[pytraverse(skip)]
+        namespace_separator: Option<String>,
+        start_element: MutableObject,
+        end_element: MutableObject,
+        character_data: MutableObject,
+        entity_decl: MutableObject,
+        buffer_text: MutableObject,
+        namespace_prefixes: MutableObject,
+        ordered_attributes: MutableObject,
+        specified_attributes: MutableObject,
+        intern: MutableObject,
+        // Additional handlers (stubs for compatibility)
+        processing_instruction: MutableObject,
+        unparsed_entity_decl: MutableObject,
+        notation_decl: MutableObject,
+        start_namespace_decl: MutableObject,
+        end_namespace_decl: MutableObject,
+        comment: MutableObject,
+        start_cdata_section: MutableObject,
+        end_cdata_section: MutableObject,
+        default: MutableObject,
+        default_expand: MutableObject,
+        not_standalone: MutableObject,
+        external_entity_ref: MutableObject,
+        start_doctype_decl: MutableObject,
+        end_doctype_decl: MutableObject,
+        xml_decl: MutableObject,
+        element_decl: MutableObject,
+        attlist_decl: MutableObject,
+        skipped_entity: MutableObject,
+    }
+    type PyExpatLikeXmlParserRef = PyRef<PyExpatLikeXmlParser>;
+
+    #[inline]
+    fn invoke_handler<T>(vm: &VirtualMachine, handler: &MutableObject, args: T)
+    where
+        T: IntoFuncArgs,
+    {
+        // Clone the handler while holding the read lock, then release the lock
+        let handler = handler.read().clone();
+        handler.call(args, vm).ok();
+    }
+
+    #[pyclass]
+    impl PyExpatLikeXmlParser {
+        fn new(
+            namespace_separator: Option<String>,
+            intern: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyExpatLikeXmlParserRef> {
+            let intern_dict = intern.unwrap_or_else(|| vm.ctx.new_dict().into());
+            Ok(Self {
+                namespace_separator,
+                start_element: MutableObject::new(vm.ctx.none()),
+                end_element: MutableObject::new(vm.ctx.none()),
+                character_data: MutableObject::new(vm.ctx.none()),
+                entity_decl: MutableObject::new(vm.ctx.none()),
+                buffer_text: MutableObject::new(vm.ctx.new_bool(false).into()),
+                namespace_prefixes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                ordered_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                specified_attributes: MutableObject::new(vm.ctx.new_bool(false).into()),
+                intern: MutableObject::new(intern_dict),
+                // Additional handlers (stubs for compatibility)
+                processing_instruction: MutableObject::new(vm.ctx.none()),
+                unparsed_entity_decl: MutableObject::new(vm.ctx.none()),
+                notation_decl: MutableObject::new(vm.ctx.none()),
+                start_namespace_decl: MutableObject::new(vm.ctx.none()),
+                end_namespace_decl: MutableObject::new(vm.ctx.none()),
+                comment: MutableObject::new(vm.ctx.none()),
+                start_cdata_section: MutableObject::new(vm.ctx.none()),
+                end_cdata_section: MutableObject::new(vm.ctx.none()),
+                default: MutableObject::new(vm.ctx.none()),
+                default_expand: MutableObject::new(vm.ctx.none()),
+                not_standalone: MutableObject::new(vm.ctx.none()),
+                external_entity_ref: MutableObject::new(vm.ctx.none()),
+                start_doctype_decl: MutableObject::new(vm.ctx.none()),
+                end_doctype_decl: MutableObject::new(vm.ctx.none()),
+                xml_decl: MutableObject::new(vm.ctx.none()),
+                element_decl: MutableObject::new(vm.ctx.none()),
+                attlist_decl: MutableObject::new(vm.ctx.none()),
+                skipped_entity: MutableObject::new(vm.ctx.none()),
+            }
+            .into_ref(&vm.ctx))
+        }
+
+        #[extend_class]
+        fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
+            let mut attributes = class.attributes.write();
+
+            create_property!(ctx, attributes, "StartElementHandler", class, start_element);
+            create_property!(ctx, attributes, "EndElementHandler", class, end_element);
+            create_property!(
+                ctx,
+                attributes,
+                "CharacterDataHandler",
+                class,
+                character_data
+            );
+            create_property!(ctx, attributes, "EntityDeclHandler", class, entity_decl);
+            create_bool_property!(ctx, attributes, "buffer_text", class, buffer_text);
+            create_bool_property!(
+                ctx,
+                attributes,
+                "namespace_prefixes",
+                class,
+                namespace_prefixes
+            );
+            create_bool_property!(
+                ctx,
+                attributes,
+                "ordered_attributes",
+                class,
+                ordered_attributes
+            );
+            create_bool_property!(
+                ctx,
+                attributes,
+                "specified_attributes",
+                class,
+                specified_attributes
+            );
+            create_property!(ctx, attributes, "intern", class, intern);
+            // Additional handlers (stubs for compatibility)
+            create_property!(
+                ctx,
+                attributes,
+                "ProcessingInstructionHandler",
+                class,
+                processing_instruction
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "UnparsedEntityDeclHandler",
+                class,
+                unparsed_entity_decl
+            );
+            create_property!(ctx, attributes, "NotationDeclHandler", class, notation_decl);
+            create_property!(
+                ctx,
+                attributes,
+                "StartNamespaceDeclHandler",
+                class,
+                start_namespace_decl
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndNamespaceDeclHandler",
+                class,
+                end_namespace_decl
+            );
+            create_property!(ctx, attributes, "CommentHandler", class, comment);
+            create_property!(
+                ctx,
+                attributes,
+                "StartCdataSectionHandler",
+                class,
+                start_cdata_section
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndCdataSectionHandler",
+                class,
+                end_cdata_section
+            );
+            create_property!(ctx, attributes, "DefaultHandler", class, default);
+            create_property!(
+                ctx,
+                attributes,
+                "DefaultHandlerExpand",
+                class,
+                default_expand
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "NotStandaloneHandler",
+                class,
+                not_standalone
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "ExternalEntityRefHandler",
+                class,
+                external_entity_ref
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "StartDoctypeDeclHandler",
+                class,
+                start_doctype_decl
+            );
+            create_property!(
+                ctx,
+                attributes,
+                "EndDoctypeDeclHandler",
+                class,
+                end_doctype_decl
+            );
+            create_property!(ctx, attributes, "XmlDeclHandler", class, xml_decl);
+            create_property!(ctx, attributes, "ElementDeclHandler", class, element_decl);
+            create_property!(ctx, attributes, "AttlistDeclHandler", class, attlist_decl);
+            create_property!(
+                ctx,
+                attributes,
+                "SkippedEntityHandler",
+                class,
+                skipped_entity
+            );
+        }
+
+        fn create_config(&self) -> xml::ParserConfig {
+            xml::ParserConfig::new()
+                .cdata_to_characters(true)
+                .coalesce_characters(false)
+                .whitespace_to_characters(true)
+        }
+
+        /// Construct element name with namespace if separator is set
+        fn make_name(&self, name: &xml::name::OwnedName) -> String {
+            match (&self.namespace_separator, &name.namespace) {
+                (Some(sep), Some(ns)) => format!("{}{}{}", ns, sep, name.local_name),
+                _ => name.local_name.clone(),
+            }
+        }
+
+        fn do_parse<T>(
+            &self,
+            vm: &VirtualMachine,
+            parser: xml::EventReader<T>,
+        ) -> Result<(), xml::reader::Error>
+        where
+            T: std::io::Read,
+        {
+            for e in parser {
+                match e {
+                    Ok(XmlEvent::StartElement {
+                        name, attributes, ..
+                    }) => {
+                        let dict = vm.ctx.new_dict();
+                        for attribute in attributes {
+                            let attr_name = self.make_name(&attribute.name);
+                            dict.set_item(
+                                attr_name.as_str(),
+                                vm.ctx.new_str(attribute.value).into(),
+                                vm,
+                            )
+                            .unwrap();
+                        }
+
+                        let name_str = PyStr::from(self.make_name(&name)).into_ref(&vm.ctx);
+                        invoke_handler(vm, &self.start_element, (name_str, dict));
+                    }
+                    Ok(XmlEvent::EndElement { name, .. }) => {
+                        let name_str = PyStr::from(self.make_name(&name)).into_ref(&vm.ctx);
+                        invoke_handler(vm, &self.end_element, (name_str,));
+                    }
+                    Ok(XmlEvent::Characters(chars)) => {
+                        let str = PyStr::from(chars).into_ref(&vm.ctx);
+                        invoke_handler(vm, &self.character_data, (str,));
+                    }
+                    Err(e) => return Err(e),
+                    _ => {}
+                }
+            }
+            Ok(())
+        }
+
+        #[pymethod(name = "Parse")]
+        fn parse(
+            &self,
+            data: Either<PyStrRef, PyBytesRef>,
+            _isfinal: OptionalArg<bool>,
+            vm: &VirtualMachine,
+        ) -> PyResult<i32> {
+            let bytes = match data {
+                Either::A(s) => s.as_bytes().to_vec(),
+                Either::B(b) => b.as_bytes().to_vec(),
+            };
+            // Empty data is valid - used to finalize parsing
+            if bytes.is_empty() {
+                return Ok(1);
+            }
+            let reader = Cursor::<Vec<u8>>::new(bytes);
+            let parser = self.create_config().create_reader(reader);
+            // Note: xml-rs is stricter than libexpat; some errors are silently ignored
+            // to maintain compatibility with existing Python code
+            let _ = self.do_parse(vm, parser);
+            Ok(1)
+        }
+
+        #[pymethod(name = "ParseFile")]
+        fn parse_file(&self, file: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
+            let read_res = vm.call_method(&file, "read", ())?;
+            let bytes_like = ArgBytesLike::try_from_object(vm, read_res)?;
+            let buf = bytes_like.borrow_buf().to_vec();
+            if buf.is_empty() {
+                return Ok(1);
+            }
+            let reader = Cursor::new(buf);
+            let parser = self.create_config().create_reader(reader);
+            // Note: xml-rs is stricter than libexpat; some errors are silently ignored
+            let _ = self.do_parse(vm, parser);
+            Ok(1)
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct ParserCreateArgs {
+        #[pyarg(any, optional)]
+        encoding: Option<PyStrRef>,
+        #[pyarg(any, optional)]
+        namespace_separator: Option<PyStrRef>,
+        #[pyarg(any, optional)]
+        intern: Option<PyObjectRef>,
+    }
+
+    #[pyfunction(name = "ParserCreate")]
+    fn parser_create(
+        args: ParserCreateArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyExpatLikeXmlParserRef> {
+        // Validate namespace_separator: must be at most one character
+        let ns_sep = match args.namespace_separator {
+            Some(ref s) => {
+                let chars: Vec<char> = s.as_str().chars().collect();
+                if chars.len() > 1 {
+                    return Err(vm.new_value_error(
+                        "namespace_separator must be at most one character, omitted, or None"
+                            .to_owned(),
+                    ));
+                }
+                Some(s.as_str().to_owned())
+            }
+            None => None,
+        };
+
+        // encoding parameter is currently not used (xml-rs handles encoding from XML declaration)
+        let _ = args.encoding;
+
+        PyExpatLikeXmlParser::new(ns_sep, args.intern, vm)
+    }
+}
+
+#[pymodule(name = "model")]
+mod _model {}
+
+#[pymodule(name = "errors")]
+mod _errors {}
diff --git a/stdlib/src/pystruct.rs b/crates/stdlib/src/pystruct.rs
similarity index 94%
rename from stdlib/src/pystruct.rs
rename to crates/stdlib/src/pystruct.rs
index 278418e246..8801f0d705 100644
--- a/stdlib/src/pystruct.rs
+++ b/crates/stdlib/src/pystruct.rs
@@ -12,11 +12,11 @@ pub(crate) mod _struct {
     use crate::vm::{
         AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
         buffer::{FormatSpec, new_struct_error, struct_error_type},
-        builtins::{PyBytes, PyStr, PyStrRef, PyTupleRef, PyTypeRef},
+        builtins::{PyBytes, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
         function::{ArgBytesLike, ArgMemoryBuffer, PosArgs},
         match_class,
         protocol::PyIterReturn,
-        types::{Constructor, IterNext, Iterable, Representable, SelfIter, Unconstructible},
+        types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
     use crossbeam_utils::atomic::AtomicCell;
 
@@ -28,7 +28,7 @@ pub(crate) mod _struct {
             // CPython turns str to bytes but we do reversed way here
             // The only performance difference is this transition cost
             let fmt = match_class!(match obj {
-                s @ PyStr => s.is_ascii().then_some(s),
+                s @ PyStr => s.isascii().then_some(s),
                 b @ PyBytes => ascii::AsciiStr::from_ascii(&b)
                     .ok()
                     .map(|s| vm.ctx.new_str(s)),
@@ -71,7 +71,7 @@ pub(crate) mod _struct {
             } else {
                 ("unpack_from", "unpacking")
             };
-            if offset >= buffer_len {
+            if offset + needed > buffer_len {
                 let msg = format!(
                     "{op} requires a buffer of at least {required} bytes for {op_action} {needed} \
                     bytes at offset {offset} (actual buffer size is {buffer_len})",
@@ -171,7 +171,7 @@ pub(crate) mod _struct {
                     vm,
                     "cannot iteratively unpack with a struct of length 0".to_owned(),
                 ))
-            } else if buffer.len() % format_spec.size != 0 {
+            } else if !buffer.len().is_multiple_of(format_spec.size) {
                 Err(new_struct_error(
                     vm,
                     format!(
@@ -189,7 +189,7 @@ pub(crate) mod _struct {
         }
     }
 
-    #[pyclass(with(Unconstructible, IterNext, Iterable))]
+    #[pyclass(with(IterNext, Iterable), flags(DISALLOW_INSTANTIATION))]
     impl UnpackIterator {
         #[pymethod]
         fn __length_hint__(&self) -> usize {
@@ -197,7 +197,7 @@ pub(crate) mod _struct {
         }
     }
     impl SelfIter for UnpackIterator {}
-    impl Unconstructible for UnpackIterator {}
+
     impl IterNext for UnpackIterator {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
             let size = zelf.format_spec.size;
@@ -241,12 +241,10 @@ pub(crate) mod _struct {
     impl Constructor for PyStruct {
         type Args = IntoStructFormatBytes;
 
-        fn py_new(cls: PyTypeRef, fmt: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(_cls: &Py<PyType>, fmt: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             let spec = fmt.format_spec(vm)?;
             let format = fmt.0;
-            Self { spec, format }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+            Ok(Self { spec, format })
         }
     }
 
diff --git a/stdlib/src/random.rs b/crates/stdlib/src/random.rs
similarity index 100%
rename from stdlib/src/random.rs
rename to crates/stdlib/src/random.rs
diff --git a/stdlib/src/re.rs b/crates/stdlib/src/re.rs
similarity index 100%
rename from stdlib/src/re.rs
rename to crates/stdlib/src/re.rs
diff --git a/stdlib/src/resource.rs b/crates/stdlib/src/resource.rs
similarity index 91%
rename from stdlib/src/resource.rs
rename to crates/stdlib/src/resource.rs
index 3a72af31d9..e6df75e4b0 100644
--- a/stdlib/src/resource.rs
+++ b/crates/stdlib/src/resource.rs
@@ -7,14 +7,15 @@ mod resource {
     use crate::vm::{
         PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
         convert::{ToPyException, ToPyObject},
-        stdlib::os,
         types::PyStructSequence,
     };
-    use std::{io, mem};
+    use core::mem;
+    use std::io;
 
     cfg_if::cfg_if! {
         if #[cfg(target_os = "android")] {
-            use libc::RLIM_NLIMITS;
+            #[expect(deprecated)]
+            const RLIM_NLIMITS: i32 = libc::RLIM_NLIMITS;
         } else {
             // This constant isn't abi-stable across os versions, so we just
             // pick a high number so we don't get false positive ValueErrors and just bubble up the
@@ -62,10 +63,8 @@ mod resource {
     #[pyattr]
     use libc::{RUSAGE_CHILDREN, RUSAGE_SELF};
 
-    #[pyattr]
-    #[pyclass(name = "struct_rusage")]
-    #[derive(PyStructSequence)]
-    struct Rusage {
+    #[pystruct_sequence_data]
+    struct RUsageData {
         ru_utime: f64,
         ru_stime: f64,
         ru_maxrss: libc::c_long,
@@ -84,10 +83,14 @@ mod resource {
         ru_nivcsw: libc::c_long,
     }
 
+    #[pyattr]
+    #[pystruct_sequence(name = "struct_rusage", module = "resource", data = "RUsageData")]
+    struct PyRUsage;
+
     #[pyclass(with(PyStructSequence))]
-    impl Rusage {}
+    impl PyRUsage {}
 
-    impl From<libc::rusage> for Rusage {
+    impl From<libc::rusage> for RUsageData {
         fn from(rusage: libc::rusage) -> Self {
             let tv = |tv: libc::timeval| tv.tv_sec as f64 + (tv.tv_usec as f64 / 1_000_000.0);
             Self {
@@ -112,7 +115,7 @@ mod resource {
     }
 
     #[pyfunction]
-    fn getrusage(who: i32, vm: &VirtualMachine) -> PyResult<Rusage> {
+    fn getrusage(who: i32, vm: &VirtualMachine) -> PyResult<RUsageData> {
         let res = unsafe {
             let mut rusage = mem::MaybeUninit::<libc::rusage>::uninit();
             if libc::getrusage(who, rusage.as_mut_ptr()) == -1 {
@@ -121,7 +124,7 @@ mod resource {
                 Ok(rusage.assume_init())
             }
         };
-        res.map(Rusage::from).map_err(|e| {
+        res.map(RUsageData::from).map_err(|e| {
             if e.kind() == io::ErrorKind::InvalidInput {
                 vm.new_value_error("invalid who parameter")
             } else {
@@ -158,7 +161,7 @@ mod resource {
         let rlimit = unsafe {
             let mut rlimit = mem::MaybeUninit::<libc::rlimit>::uninit();
             if libc::getrlimit(resource as _, rlimit.as_mut_ptr()) == -1 {
-                return Err(os::errno_err(vm));
+                return Err(vm.new_last_errno_error());
             }
             rlimit.assume_init()
         };
diff --git a/stdlib/src/scproxy.rs b/crates/stdlib/src/scproxy.rs
similarity index 82%
rename from stdlib/src/scproxy.rs
rename to crates/stdlib/src/scproxy.rs
index c63acf5343..b105dc4f2f 100644
--- a/stdlib/src/scproxy.rs
+++ b/crates/stdlib/src/scproxy.rs
@@ -5,8 +5,8 @@ mod _scproxy {
     // straight-forward port of Modules/_scproxy.c
 
     use crate::vm::{
-        PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStr},
+        Py, PyResult, VirtualMachine,
+        builtins::{PyDict, PyDictRef, PyStr},
         convert::ToPyObject,
     };
     use system_configuration::core_foundation::{
@@ -22,7 +22,7 @@ mod _scproxy {
 
     fn proxy_dict() -> Option<CFDictionary<CFString, CFType>> {
         // Py_BEGIN_ALLOW_THREADS
-        let proxy_dict = unsafe { SCDynamicStoreCopyProxies(std::ptr::null()) };
+        let proxy_dict = unsafe { SCDynamicStoreCopyProxies(core::ptr::null()) };
         // Py_END_ALLOW_THREADS
         if proxy_dict.is_null() {
             None
@@ -74,7 +74,7 @@ mod _scproxy {
 
         let result = vm.ctx.new_dict();
 
-        let set_proxy = |result: &PyDictRef,
+        let set_proxy = |result: &Py<PyDict>,
                          proto: &str,
                          enabled_key: CFStringRef,
                          host_key: CFStringRef,
@@ -86,23 +86,22 @@ mod _scproxy {
                     .and_then(|v| v.downcast::<CFNumber>())
                     .and_then(|v| v.to_i32())
                     .unwrap_or(0);
-            if enabled {
-                if let Some(host) = proxy_dict
+            if enabled
+                && let Some(host) = proxy_dict
                     .find(host_key)
                     .and_then(|v| v.downcast::<CFString>())
+            {
+                let h = alloc::borrow::Cow::<str>::from(&host);
+                let v = if let Some(port) = proxy_dict
+                    .find(port_key)
+                    .and_then(|v| v.downcast::<CFNumber>())
+                    .and_then(|v| v.to_i32())
                 {
-                    let h = std::borrow::Cow::<str>::from(&host);
-                    let v = if let Some(port) = proxy_dict
-                        .find(port_key)
-                        .and_then(|v| v.downcast::<CFNumber>())
-                        .and_then(|v| v.to_i32())
-                    {
-                        format!("http://{h}:{port}")
-                    } else {
-                        format!("http://{h}")
-                    };
-                    result.set_item(proto, vm.new_pyobj(v), vm)?;
-                }
+                    format!("http://{h}:{port}")
+                } else {
+                    format!("http://{h}")
+                };
+                result.set_item(proto, vm.new_pyobj(v), vm)?;
             }
             Ok(())
         };
diff --git a/stdlib/src/select.rs b/crates/stdlib/src/select.rs
similarity index 96%
rename from stdlib/src/select.rs
rename to crates/stdlib/src/select.rs
index d502313566..3c2f5e63c7 100644
--- a/stdlib/src/select.rs
+++ b/crates/stdlib/src/select.rs
@@ -4,7 +4,8 @@ use crate::vm::{
     PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine, builtins::PyListRef,
     builtins::PyModule,
 };
-use std::{io, mem};
+use core::mem;
+use std::io;
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(windows)]
@@ -158,7 +159,7 @@ impl FdSet {
     pub fn new() -> Self {
         // it's just ints, and all the code that's actually
         // interacting with it is in C, so it's safe to zero
-        let mut fdset = std::mem::MaybeUninit::zeroed();
+        let mut fdset = core::mem::MaybeUninit::zeroed();
         unsafe { platform::FD_ZERO(fdset.as_mut_ptr()) };
         Self(fdset)
     }
@@ -191,7 +192,7 @@ pub fn select(
 ) -> io::Result<i32> {
     let timeout = match timeout {
         Some(tv) => tv as *mut timeval,
-        None => std::ptr::null_mut(),
+        None => core::ptr::null_mut(),
     };
     let ret = unsafe {
         platform::select(
@@ -244,10 +245,10 @@ mod decl {
             Either::A(f) => f,
             Either::B(i) => i as f64,
         });
-        if let Some(timeout) = timeout {
-            if timeout < 0.0 {
-                return Err(vm.new_value_error("timeout must be positive"));
-            }
+        if let Some(timeout) = timeout
+            && timeout < 0.0
+        {
+            return Err(vm.new_value_error("timeout must be positive"));
         }
         let deadline = timeout.map(|s| time::time(vm).unwrap() + s);
 
@@ -336,12 +337,10 @@ mod decl {
             function::OptionalArg,
             stdlib::io::Fildes,
         };
+        use core::{convert::TryFrom, time::Duration};
         use libc::pollfd;
         use num_traits::{Signed, ToPrimitive};
-        use std::{
-            convert::TryFrom,
-            time::{Duration, Instant},
-        };
+        use std::time::Instant;
 
         #[derive(Default)]
         pub(super) struct TimeoutArg<const MILLIS: bool>(pub Option<Duration>);
@@ -350,7 +349,7 @@ mod decl {
             fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
                 let timeout = if vm.is_none(&obj) {
                     None
-                } else if let Some(float) = obj.payload::<PyFloat>() {
+                } else if let Some(float) = obj.downcast_ref::<PyFloat>() {
                     let float = float.to_f64();
                     if float.is_nan() {
                         return Err(vm.new_value_error("Invalid value NaN (not a number)"));
@@ -546,16 +545,16 @@ mod decl {
     pub(super) mod epoll {
         use super::*;
         use crate::vm::{
-            PyPayload,
-            builtins::PyTypeRef,
+            Py, PyPayload,
+            builtins::PyType,
             common::lock::{PyRwLock, PyRwLockReadGuard},
             convert::{IntoPyException, ToPyObject},
             function::OptionalArg,
             stdlib::io::Fildes,
             types::Constructor,
         };
+        use core::ops::Deref;
         use rustix::event::epoll::{self, EventData, EventFlags};
-        use std::ops::Deref;
         use std::os::fd::{AsRawFd, IntoRawFd, OwnedFd};
         use std::time::Instant;
 
@@ -575,17 +574,15 @@ mod decl {
 
         impl Constructor for PyEpoll {
             type Args = EpollNewArgs;
-            fn py_new(cls: PyTypeRef, args: EpollNewArgs, vm: &VirtualMachine) -> PyResult {
+
+            fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
                 if let ..=-2 | 0 = args.sizehint {
                     return Err(vm.new_value_error("negative sizehint"));
                 }
                 if !matches!(args.flags, 0 | libc::EPOLL_CLOEXEC) {
                     return Err(vm.new_os_error("invalid flags".to_owned()));
                 }
-                Self::new()
-                    .map_err(|e| e.into_pyexception(vm))?
-                    .into_ref_with_type(vm, cls)
-                    .map(Into::into)
+                Self::new().map_err(|e| e.into_pyexception(vm))
             }
         }
 
diff --git a/stdlib/src/sha1.rs b/crates/stdlib/src/sha1.rs
similarity index 100%
rename from stdlib/src/sha1.rs
rename to crates/stdlib/src/sha1.rs
diff --git a/stdlib/src/sha256.rs b/crates/stdlib/src/sha256.rs
similarity index 100%
rename from stdlib/src/sha256.rs
rename to crates/stdlib/src/sha256.rs
diff --git a/stdlib/src/sha3.rs b/crates/stdlib/src/sha3.rs
similarity index 100%
rename from stdlib/src/sha3.rs
rename to crates/stdlib/src/sha3.rs
diff --git a/stdlib/src/sha512.rs b/crates/stdlib/src/sha512.rs
similarity index 100%
rename from stdlib/src/sha512.rs
rename to crates/stdlib/src/sha512.rs
diff --git a/crates/stdlib/src/socket.rs b/crates/stdlib/src/socket.rs
new file mode 100644
index 0000000000..ea5f39cb40
--- /dev/null
+++ b/crates/stdlib/src/socket.rs
@@ -0,0 +1,3418 @@
+// spell-checker:disable
+
+use crate::vm::{PyRef, VirtualMachine, builtins::PyModule};
+#[cfg(feature = "ssl")]
+pub(super) use _socket::{PySocket, SelectKind, sock_select, timeout_error_msg};
+
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    #[cfg(windows)]
+    crate::vm::windows::init_winsock();
+    _socket::make_module(vm)
+}
+
+#[pymodule]
+mod _socket {
+    use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};
+    use crate::vm::{
+        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyListRef, PyOSError, PyStrRef, PyTupleRef, PyTypeRef},
+        common::os::ErrorExt,
+        convert::{IntoPyException, ToPyObject, TryFromBorrowedObject, TryFromObject},
+        function::{ArgBytesLike, ArgMemoryBuffer, Either, FsPath, OptionalArg, OptionalOption},
+        types::{Constructor, DefaultConstructor, Initializer, Representable},
+        utils::ToCString,
+    };
+    use core::{
+        mem::MaybeUninit,
+        net::{Ipv4Addr, Ipv6Addr, SocketAddr},
+        time::Duration,
+    };
+    use crossbeam_utils::atomic::AtomicCell;
+    use num_traits::ToPrimitive;
+    use socket2::Socket;
+    use std::{
+        ffi,
+        io::{self, Read, Write},
+        net::{self, Shutdown, ToSocketAddrs},
+        time::Instant,
+    };
+
+    #[cfg(unix)]
+    use libc as c;
+    #[cfg(windows)]
+    mod c {
+        pub use windows_sys::Win32::NetworkManagement::IpHelper::{if_indextoname, if_nametoindex};
+        pub use windows_sys::Win32::Networking::WinSock::{
+            INADDR_ANY, INADDR_BROADCAST, INADDR_LOOPBACK, INADDR_NONE,
+        };
+
+        pub use windows_sys::Win32::Networking::WinSock::{
+            AF_APPLETALK, AF_DECnet, AF_IPX, AF_LINK, AI_ADDRCONFIG, AI_ALL, AI_CANONNAME,
+            AI_NUMERICSERV, AI_V4MAPPED, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_HDRINCL,
+            IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_OPTIONS, IP_RECVDSTADDR,
+            IP_TOS, IP_TTL, IPPORT_RESERVED, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP,
+            IPPROTO_FRAGMENT, IPPROTO_GGP, IPPROTO_HOPOPTS, IPPROTO_ICMP, IPPROTO_ICMPV6,
+            IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IP, IPPROTO_IP as IPPROTO_IPIP, IPPROTO_IPV4,
+            IPPROTO_IPV6, IPPROTO_ND, IPPROTO_NONE, IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW,
+            IPPROTO_ROUTING, IPPROTO_TCP, IPPROTO_UDP, IPV6_CHECKSUM, IPV6_DONTFRAG, IPV6_HOPLIMIT,
+            IPV6_HOPOPTS, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, IPV6_MULTICAST_HOPS,
+            IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP, IPV6_PKTINFO, IPV6_RECVRTHDR, IPV6_RECVTCLASS,
+            IPV6_RTHDR, IPV6_TCLASS, IPV6_UNICAST_HOPS, IPV6_V6ONLY, MSG_BCAST, MSG_CTRUNC,
+            MSG_DONTROUTE, MSG_MCAST, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM,
+            NI_MAXHOST, NI_MAXSERV, NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV,
+            RCVALL_IPLEVEL, RCVALL_OFF, RCVALL_ON, RCVALL_SOCKETLEVELONLY, SD_BOTH as SHUT_RDWR,
+            SD_RECEIVE as SHUT_RD, SD_SEND as SHUT_WR, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH,
+            SIO_RCVALL, SO_BROADCAST, SO_ERROR, SO_LINGER, SO_OOBINLINE, SO_REUSEADDR, SO_TYPE,
+            SO_USELOOPBACK, SOCK_DGRAM, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM,
+            SOL_SOCKET, SOMAXCONN, TCP_NODELAY, WSAEBADF, WSAECONNRESET, WSAENOTSOCK,
+            WSAEWOULDBLOCK,
+        };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            INVALID_SOCKET, SOCKET_ERROR, WSA_FLAG_OVERLAPPED, WSADuplicateSocketW,
+            WSAGetLastError, WSAIoctl, WSAPROTOCOL_INFOW, WSASocketW,
+        };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            SO_REUSEADDR as SO_EXCLUSIVEADDRUSE, getprotobyname, getservbyname, getservbyport,
+            getsockopt, setsockopt,
+        };
+        pub use windows_sys::Win32::Networking::WinSock::{
+            WSA_NOT_ENOUGH_MEMORY as EAI_MEMORY, WSAEAFNOSUPPORT as EAI_FAMILY,
+            WSAEINVAL as EAI_BADFLAGS, WSAESOCKTNOSUPPORT as EAI_SOCKTYPE,
+            WSAHOST_NOT_FOUND as EAI_NODATA, WSAHOST_NOT_FOUND as EAI_NONAME,
+            WSANO_RECOVERY as EAI_FAIL, WSATRY_AGAIN as EAI_AGAIN,
+            WSATYPE_NOT_FOUND as EAI_SERVICE,
+        };
+        pub const IF_NAMESIZE: usize =
+            windows_sys::Win32::NetworkManagement::Ndis::IF_MAX_STRING_SIZE as _;
+        pub const AF_UNSPEC: i32 = windows_sys::Win32::Networking::WinSock::AF_UNSPEC as _;
+        pub const AF_INET: i32 = windows_sys::Win32::Networking::WinSock::AF_INET as _;
+        pub const AF_INET6: i32 = windows_sys::Win32::Networking::WinSock::AF_INET6 as _;
+        pub const AI_PASSIVE: i32 = windows_sys::Win32::Networking::WinSock::AI_PASSIVE as _;
+        pub const AI_NUMERICHOST: i32 =
+            windows_sys::Win32::Networking::WinSock::AI_NUMERICHOST as _;
+        pub const FROM_PROTOCOL_INFO: i32 = -1;
+    }
+    // constants
+    #[pyattr(name = "has_ipv6")]
+    const HAS_IPV6: bool = true;
+    #[pyattr]
+    // put IPPROTO_MAX later
+    use c::{
+        AF_INET, AF_INET6, AF_UNSPEC, INADDR_ANY, INADDR_LOOPBACK, INADDR_NONE, IPPROTO_ICMP,
+        IPPROTO_ICMPV6, IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP, IPPROTO_TCP as SOL_TCP, IPPROTO_UDP,
+        MSG_CTRUNC, MSG_DONTROUTE, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM, NI_MAXHOST,
+        NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV, SHUT_RD, SHUT_RDWR, SHUT_WR,
+        SO_BROADCAST, SO_ERROR, SO_LINGER, SO_OOBINLINE, SO_REUSEADDR, SO_TYPE, SOCK_DGRAM,
+        SOCK_STREAM, SOL_SOCKET, TCP_NODELAY,
+    };
+
+    #[cfg(not(target_os = "redox"))]
+    #[pyattr]
+    use c::{
+        AF_APPLETALK, AF_DECnet, AF_IPX, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP,
+        IPPROTO_FRAGMENT, IPPROTO_HOPOPTS, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IPIP, IPPROTO_NONE,
+        IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING,
+    };
+
+    #[cfg(unix)]
+    #[pyattr]
+    use c::{AF_UNIX, SO_REUSEPORT};
+
+    #[pyattr]
+    use c::{AI_ADDRCONFIG, AI_NUMERICHOST, AI_NUMERICSERV, AI_PASSIVE};
+
+    #[cfg(not(target_os = "redox"))]
+    #[pyattr]
+    use c::{SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET};
+
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    use c::{SOL_ATALK, SOL_AX25, SOL_IPX, SOL_NETROM, SOL_ROSE};
+
+    #[cfg(target_os = "freebsd")]
+    #[pyattr]
+    use c::SO_SETFIB;
+
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    use c::{
+        CAN_BCM, CAN_EFF_FLAG, CAN_EFF_MASK, CAN_ERR_FLAG, CAN_ERR_MASK, CAN_ISOTP, CAN_J1939,
+        CAN_RAW, CAN_RAW_ERR_FILTER, CAN_RAW_FD_FRAMES, CAN_RAW_FILTER, CAN_RAW_JOIN_FILTERS,
+        CAN_RAW_LOOPBACK, CAN_RAW_RECV_OWN_MSGS, CAN_RTR_FLAG, CAN_SFF_MASK, IPPROTO_MPTCP,
+        J1939_IDLE_ADDR, J1939_MAX_UNICAST_ADDR, J1939_NLA_BYTES_ACKED, J1939_NLA_PAD,
+        J1939_NO_ADDR, J1939_NO_NAME, J1939_NO_PGN, J1939_PGN_ADDRESS_CLAIMED,
+        J1939_PGN_ADDRESS_COMMANDED, J1939_PGN_MAX, J1939_PGN_PDU1_MAX, J1939_PGN_REQUEST,
+        SCM_J1939_DEST_ADDR, SCM_J1939_DEST_NAME, SCM_J1939_ERRQUEUE, SCM_J1939_PRIO,
+        SO_J1939_ERRQUEUE, SO_J1939_FILTER, SO_J1939_PROMISC, SO_J1939_SEND_PRIO, SOL_CAN_BASE,
+        SOL_CAN_RAW,
+    };
+
+    // CAN BCM opcodes
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_SETUP: i32 = 1;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_DELETE: i32 = 2;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_READ: i32 = 3;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_SEND: i32 = 4;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_SETUP: i32 = 5;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_DELETE: i32 = 6;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_READ: i32 = 7;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_STATUS: i32 = 8;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_EXPIRED: i32 = 9;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_STATUS: i32 = 10;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_TIMEOUT: i32 = 11;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_CHANGED: i32 = 12;
+
+    // CAN BCM flags (linux/can/bcm.h)
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_SETTIMER: i32 = 0x0001;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_STARTTIMER: i32 = 0x0002;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_COUNTEVT: i32 = 0x0004;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_ANNOUNCE: i32 = 0x0008;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_CP_CAN_ID: i32 = 0x0010;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_FILTER_ID: i32 = 0x0020;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_CHECK_DLC: i32 = 0x0040;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_NO_AUTOTIMER: i32 = 0x0080;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_ANNOUNCE_RESUME: i32 = 0x0100;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_TX_RESET_MULTI_IDX: i32 = 0x0200;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_RX_RTR_FRAME: i32 = 0x0400;
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    const CAN_BCM_CAN_FD_FRAME: i32 = 0x0800;
+
+    #[cfg(all(target_os = "linux", target_env = "gnu"))]
+    #[pyattr]
+    use c::SOL_RDS;
+
+    #[cfg(target_os = "netbsd")]
+    #[pyattr]
+    use c::IPPROTO_VRRP;
+
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    use c::{AF_SYSTEM, PF_SYSTEM, SYSPROTO_CONTROL, TCP_KEEPALIVE};
+
+    // RFC3542 IPv6 socket options for macOS (netinet6/in6.h)
+    // Not available in libc, define manually
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVHOPLIMIT: i32 = 37;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVRTHDR: i32 = 38;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVHOPOPTS: i32 = 39;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVDSTOPTS: i32 = 40;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_USE_MIN_MTU: i32 = 42;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RECVPATHMTU: i32 = 43;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_PATHMTU: i32 = 44;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_NEXTHOP: i32 = 48;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_HOPOPTS: i32 = 49;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_DSTOPTS: i32 = 50;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDR: i32 = 51;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDRDSTOPTS: i32 = 57;
+    #[cfg(target_vendor = "apple")]
+    #[pyattr]
+    const IPV6_RTHDR_TYPE_0: i32 = 0;
+
+    #[cfg(windows)]
+    #[pyattr]
+    use c::{
+        IPPORT_RESERVED, IPPROTO_IPV4, RCVALL_IPLEVEL, RCVALL_OFF, RCVALL_ON,
+        RCVALL_SOCKETLEVELONLY, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH, SIO_RCVALL,
+        SO_EXCLUSIVEADDRUSE,
+    };
+
+    #[cfg(not(windows))]
+    #[pyattr]
+    const IPPORT_RESERVED: i32 = 1024;
+
+    #[pyattr]
+    const IPPORT_USERRESERVED: i32 = 5000;
+
+    #[cfg(any(unix, target_os = "android"))]
+    #[pyattr]
+    use c::{
+        EAI_SYSTEM, MSG_EOR, SO_ACCEPTCONN, SO_DEBUG, SO_DONTROUTE, SO_KEEPALIVE, SO_RCVBUF,
+        SO_RCVLOWAT, SO_RCVTIMEO, SO_SNDBUF, SO_SNDLOWAT, SO_SNDTIMEO,
+    };
+
+    #[cfg(any(target_os = "android", target_os = "linux"))]
+    #[pyattr]
+    use c::{
+        ALG_OP_DECRYPT, ALG_OP_ENCRYPT, ALG_SET_AEAD_ASSOCLEN, ALG_SET_AEAD_AUTHSIZE, ALG_SET_IV,
+        ALG_SET_KEY, ALG_SET_OP, IP_DEFAULT_MULTICAST_LOOP, IP_RECVOPTS, IP_RETOPTS, IPV6_DSTOPTS,
+        IPV6_NEXTHOP, IPV6_PATHMTU, IPV6_RECVDSTOPTS, IPV6_RECVHOPLIMIT, IPV6_RECVHOPOPTS,
+        IPV6_RECVPATHMTU, IPV6_RTHDRDSTOPTS, NETLINK_CRYPTO, NETLINK_DNRTMSG, NETLINK_FIREWALL,
+        NETLINK_IP6_FW, NETLINK_NFLOG, NETLINK_ROUTE, NETLINK_USERSOCK, NETLINK_XFRM, SO_PASSSEC,
+        SO_PEERSEC, SOL_ALG,
+    };
+
+    #[cfg(any(target_os = "android", target_vendor = "apple"))]
+    #[pyattr]
+    use c::{AI_DEFAULT, AI_MASK, AI_V4MAPPED_CFG};
+
+    #[cfg(any(target_os = "freebsd", target_os = "netbsd"))]
+    #[pyattr]
+    use c::MSG_NOTIFICATION;
+
+    #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    use c::TCP_USER_TIMEOUT;
+
+    #[cfg(any(unix, target_os = "android", windows))]
+    #[pyattr]
+    use c::{
+        INADDR_BROADCAST, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_IF,
+        IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF,
+        IPV6_MULTICAST_LOOP, IPV6_UNICAST_HOPS, IPV6_V6ONLY,
+    };
+
+    #[cfg(any(unix, target_os = "android", windows))]
+    #[pyattr]
+    const INADDR_UNSPEC_GROUP: u32 = 0xe0000000;
+
+    #[cfg(any(unix, target_os = "android", windows))]
+    #[pyattr]
+    const INADDR_ALLHOSTS_GROUP: u32 = 0xe0000001;
+
+    #[cfg(any(unix, target_os = "android", windows))]
+    #[pyattr]
+    const INADDR_MAX_LOCAL_GROUP: u32 = 0xe00000ff;
+
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    use c::{
+        AF_ALG, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25, AF_BRIDGE, AF_CAN, AF_ECONET, AF_IRDA,
+        AF_LLC, AF_NETBEUI, AF_NETLINK, AF_NETROM, AF_PACKET, AF_PPPOX, AF_RDS, AF_SECURITY,
+        AF_TIPC, AF_VSOCK, AF_WANPIPE, AF_X25, IP_TRANSPARENT, MSG_CONFIRM, MSG_ERRQUEUE,
+        MSG_FASTOPEN, MSG_MORE, PF_CAN, PF_PACKET, PF_RDS, SCM_CREDENTIALS, SO_BINDTODEVICE,
+        SO_MARK, SOL_IP, SOL_TIPC, SOL_UDP, TCP_CORK, TCP_DEFER_ACCEPT, TCP_LINGER2, TCP_QUICKACK,
+        TCP_SYNCNT, TCP_WINDOW_CLAMP,
+    };
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const SO_VM_SOCKETS_BUFFER_SIZE: u32 = 0;
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const SO_VM_SOCKETS_BUFFER_MIN_SIZE: u32 = 1;
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const SO_VM_SOCKETS_BUFFER_MAX_SIZE: u32 = 2;
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const VMADDR_CID_ANY: u32 = 0xffffffff; // 0xffffffff
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const VMADDR_PORT_ANY: u32 = 0xffffffff; // 0xffffffff
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const VMADDR_CID_HOST: u32 = 2;
+
+    // gated on presence of AF_VSOCK:
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    #[pyattr]
+    const VM_SOCKETS_INVALID_VERSION: u32 = 0xffffffff; // 0xffffffff
+
+    // TODO: gated on https://github.com/rust-lang/libc/pull/1662
+    // // gated on presence of AF_VSOCK:
+    // #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
+    // #[pyattr(name = "IOCTL_VM_SOCKETS_GET_LOCAL_CID", once)]
+    // fn ioctl_vm_sockets_get_local_cid(_vm: &VirtualMachine) -> i32 {
+    //     c::_IO(7, 0xb9)
+    // }
+
+    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
+    #[pyattr]
+    const SOL_IP: i32 = 0;
+
+    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
+    #[pyattr]
+    const SOL_UDP: i32 = 17;
+
+    #[cfg(any(target_os = "android", target_os = "linux", windows))]
+    #[pyattr]
+    use c::{IP_OPTIONS, IPV6_HOPOPTS, IPV6_RECVRTHDR, IPV6_RTHDR};
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::{IPPROTO_HELLO, IPPROTO_XTP, LOCAL_PEERCRED, MSG_EOF};
+
+    #[cfg(any(target_os = "netbsd", target_os = "openbsd", windows))]
+    #[pyattr]
+    use c::{MSG_BCAST, MSG_MCAST};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "freebsd",
+        target_os = "linux"
+    ))]
+    #[pyattr]
+    use c::{IPPROTO_UDPLITE, TCP_CONGESTION};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "freebsd",
+        target_os = "linux"
+    ))]
+    #[pyattr]
+    const UDPLITE_SEND_CSCOV: i32 = 10;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "freebsd",
+        target_os = "linux"
+    ))]
+    #[pyattr]
+    const UDPLITE_RECV_CSCOV: i32 = 11;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    use c::AF_KEY;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::SO_DOMAIN;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "fuchsia",
+        all(
+            target_os = "linux",
+            any(
+                target_arch = "aarch64",
+                target_arch = "x86",
+                target_arch = "loongarch64",
+                target_arch = "mips",
+                target_arch = "powerpc",
+                target_arch = "powerpc64",
+                target_arch = "riscv64",
+                target_arch = "s390x",
+                target_arch = "x86_64"
+            )
+        ),
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::SO_PRIORITY;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    use c::IPPROTO_MOBILE;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::SCM_CREDS;
+
+    #[cfg(any(
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::TCP_FASTOPEN;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        all(
+            target_os = "linux",
+            any(
+                target_arch = "aarch64",
+                target_arch = "x86",
+                target_arch = "loongarch64",
+                target_arch = "mips",
+                target_arch = "powerpc",
+                target_arch = "powerpc64",
+                target_arch = "riscv64",
+                target_arch = "s390x",
+                target_arch = "x86_64"
+            )
+        ),
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::SO_PROTOCOL;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::IPV6_DONTFRAG;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::{SO_PASSCRED, SO_PEERCRED};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use c::TCP_INFO;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::IP_RECVTOS;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "netbsd",
+        target_os = "redox",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::NI_MAXSERV;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::{IPPROTO_EON, IPPROTO_IPCOMP};
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::IPPROTO_ND;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::{IPV6_CHECKSUM, IPV6_HOPLIMIT};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use c::IPPROTO_SCTP; // also in windows
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::{AI_ALL, AI_V4MAPPED};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::EAI_NODATA;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::{
+        AF_LINK, IP_RECVDSTADDR, IPPROTO_GGP, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, SO_USELOOPBACK,
+    };
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    use c::{MSG_CMSG_CLOEXEC, MSG_NOSIGNAL};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::TCP_KEEPIDLE;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::{TCP_KEEPCNT, TCP_KEEPINTVL};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "redox"
+    ))]
+    #[pyattr]
+    use c::{SOCK_CLOEXEC, SOCK_NONBLOCK};
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple"
+    ))]
+    #[pyattr]
+    use c::{
+        AF_ROUTE, AF_SNA, EAI_OVERFLOW, IPPROTO_GRE, IPPROTO_RSVP, IPPROTO_TP, IPV6_RECVPKTINFO,
+        MSG_DONTWAIT, SCM_RIGHTS, TCP_MAXSEG,
+    };
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::IPV6_PKTINFO;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::AI_CANONNAME;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    ))]
+    #[pyattr]
+    use c::{
+        EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NONAME, EAI_SERVICE,
+        EAI_SOCKTYPE, IP_HDRINCL, IP_TOS, IPV6_RECVTCLASS, IPV6_TCLASS, SOMAXCONN,
+    };
+
+    #[cfg(not(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_vendor = "apple",
+        windows
+    )))]
+    #[pyattr]
+    const SOMAXCONN: i32 = 5; // Common value
+
+    // HERE IS WHERE THE BLUETOOTH CONSTANTS START
+    // TODO: there should be a more intelligent way of detecting bluetooth on a platform.
+    //       CPython uses header-detection, but blocks NetBSD and DragonFly BSD
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    use c::AF_BLUETOOTH;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    const BDADDR_ANY: &str = "00:00:00:00:00:00";
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "linux",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    const BDADDR_LOCAL: &str = "00:00:00:FF:FF:FF";
+    // HERE IS WHERE THE BLUETOOTH CONSTANTS END
+
+    #[cfg(windows)]
+    #[pyattr]
+    use windows_sys::Win32::Networking::WinSock::{
+        IPPROTO_CBT, IPPROTO_ICLFXBM, IPPROTO_IGP, IPPROTO_L2TP, IPPROTO_PGM, IPPROTO_RDP,
+        IPPROTO_SCTP, IPPROTO_ST,
+    };
+
+    #[pyattr]
+    fn error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.exceptions.os_error.to_owned()
+    }
+
+    #[pyattr]
+    fn timeout(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.exceptions.timeout_error.to_owned()
+    }
+
+    #[pyattr(once)]
+    fn herror(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "socket",
+            "herror",
+            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
+        )
+    }
+    #[pyattr(once)]
+    fn gaierror(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "socket",
+            "gaierror",
+            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
+        )
+    }
+
+    #[pyfunction]
+    const fn htonl(x: u32) -> u32 {
+        u32::to_be(x)
+    }
+
+    #[pyfunction]
+    const fn htons(x: u16) -> u16 {
+        u16::to_be(x)
+    }
+
+    #[pyfunction]
+    const fn ntohl(x: u32) -> u32 {
+        u32::from_be(x)
+    }
+
+    #[pyfunction]
+    const fn ntohs(x: u16) -> u16 {
+        u16::from_be(x)
+    }
+
+    #[cfg(unix)]
+    type RawSocket = std::os::unix::io::RawFd;
+    #[cfg(windows)]
+    type RawSocket = std::os::windows::raw::SOCKET;
+
+    #[cfg(unix)]
+    macro_rules! errcode {
+        ($e:ident) => {
+            c::$e
+        };
+    }
+    #[cfg(windows)]
+    macro_rules! errcode {
+    ($e:ident) => {
+        paste::paste!(c::[<WSA $e>])
+    };
+}
+
+    #[cfg(windows)]
+    use windows_sys::Win32::NetworkManagement::IpHelper;
+
+    fn get_raw_sock(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<RawSocket> {
+        #[cfg(unix)]
+        type CastFrom = libc::c_long;
+        #[cfg(windows)]
+        type CastFrom = libc::c_longlong;
+
+        // should really just be to_index() but test_socket tests the error messages explicitly
+        if obj.fast_isinstance(vm.ctx.types.float_type) {
+            return Err(vm.new_type_error("integer argument expected, got float"));
+        }
+        let int = obj
+            .try_index_opt(vm)
+            .unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?;
+        int.try_to_primitive::<CastFrom>(vm)
+            .map(|sock| sock as RawSocket)
+    }
+
+    #[cfg(target_os = "linux")]
+    #[derive(FromArgs)]
+    struct SendmsgAfalgArgs {
+        #[pyarg(any, default)]
+        msg: Vec<ArgBytesLike>,
+        #[pyarg(named)]
+        op: u32,
+        #[pyarg(named, default)]
+        iv: Option<ArgBytesLike>,
+        #[pyarg(named, default)]
+        assoclen: OptionalArg<isize>,
+        #[pyarg(named, default)]
+        flags: i32,
+    }
+
+    #[pyattr(name = "socket")]
+    #[pyattr(name = "SocketType")]
+    #[pyclass(name = "socket")]
+    #[derive(Debug, PyPayload)]
+    pub struct PySocket {
+        kind: AtomicCell<i32>,
+        family: AtomicCell<i32>,
+        proto: AtomicCell<i32>,
+        pub(crate) timeout: AtomicCell<f64>,
+        sock: PyRwLock<Option<Socket>>,
+    }
+
+    const _: () = assert!(core::mem::size_of::<Option<Socket>>() == core::mem::size_of::<Socket>());
+
+    impl Default for PySocket {
+        fn default() -> Self {
+            Self {
+                kind: AtomicCell::default(),
+                family: AtomicCell::default(),
+                proto: AtomicCell::default(),
+                timeout: AtomicCell::new(-1.0),
+                sock: PyRwLock::new(None),
+            }
+        }
+    }
+
+    #[cfg(windows)]
+    const CLOSED_ERR: i32 = c::WSAENOTSOCK;
+    #[cfg(unix)]
+    const CLOSED_ERR: i32 = c::EBADF;
+
+    impl Read for &PySocket {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            (&mut &*self.sock()?).read(buf)
+        }
+    }
+
+    impl Write for &PySocket {
+        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+            (&mut &*self.sock()?).write(buf)
+        }
+
+        fn flush(&mut self) -> std::io::Result<()> {
+            (&mut &*self.sock()?).flush()
+        }
+    }
+
+    impl PySocket {
+        pub fn sock_opt(&self) -> Option<PyMappedRwLockReadGuard<'_, Socket>> {
+            let sock = PyRwLockReadGuard::try_map(self.sock.read(), |sock| sock.as_ref());
+            sock.ok()
+        }
+
+        pub fn sock(&self) -> io::Result<PyMappedRwLockReadGuard<'_, Socket>> {
+            self.sock_opt()
+                .ok_or_else(|| io::Error::from_raw_os_error(CLOSED_ERR))
+        }
+
+        fn init_inner(
+            &self,
+            family: i32,
+            socket_kind: i32,
+            proto: i32,
+            sock: Socket,
+        ) -> io::Result<()> {
+            self.family.store(family);
+            // Mask out SOCK_NONBLOCK and SOCK_CLOEXEC flags from stored type
+            // to ensure consistent cross-platform behavior
+            #[cfg(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            ))]
+            let masked_kind = socket_kind & !(c::SOCK_NONBLOCK | c::SOCK_CLOEXEC);
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            )))]
+            let masked_kind = socket_kind;
+            self.kind.store(masked_kind);
+            self.proto.store(proto);
+            let mut s = self.sock.write();
+            let sock = s.insert(sock);
+            // If SOCK_NONBLOCK is set, use timeout 0 (non-blocking)
+            #[cfg(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            ))]
+            let timeout = if socket_kind & c::SOCK_NONBLOCK != 0 {
+                0.0
+            } else {
+                DEFAULT_TIMEOUT.load()
+            };
+            #[cfg(not(any(
+                target_os = "android",
+                target_os = "dragonfly",
+                target_os = "freebsd",
+                target_os = "fuchsia",
+                target_os = "illumos",
+                target_os = "linux",
+                target_os = "netbsd",
+                target_os = "openbsd",
+                target_os = "redox"
+            )))]
+            let timeout = DEFAULT_TIMEOUT.load();
+            self.timeout.store(timeout);
+            if timeout >= 0.0 {
+                sock.set_nonblocking(true)?;
+            }
+            Ok(())
+        }
+
+        /// returns Err(blocking)
+        pub fn get_timeout(&self) -> Result<Duration, bool> {
+            let timeout = self.timeout.load();
+            if timeout > 0.0 {
+                Ok(Duration::from_secs_f64(timeout))
+            } else {
+                Err(timeout != 0.0)
+            }
+        }
+
+        fn sock_op<F, R>(
+            &self,
+            vm: &VirtualMachine,
+            select: SelectKind,
+            f: F,
+        ) -> Result<R, IoOrPyException>
+        where
+            F: FnMut() -> io::Result<R>,
+        {
+            let timeout = self.get_timeout().ok();
+            self.sock_op_timeout_err(vm, select, timeout, f)
+        }
+
+        fn sock_op_timeout_err<F, R>(
+            &self,
+            vm: &VirtualMachine,
+            select: SelectKind,
+            timeout: Option<Duration>,
+            mut f: F,
+        ) -> Result<R, IoOrPyException>
+        where
+            F: FnMut() -> io::Result<R>,
+        {
+            let deadline = timeout.map(Deadline::new);
+
+            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);
+                    match res {
+                        Ok(true) => return Err(IoOrPyException::Timeout),
+                        Err(e) if e.kind() == io::ErrorKind::Interrupted => {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        Err(e) => return Err(e.into()),
+                        Ok(false) => {} // no timeout, continue as normal
+                    }
+                }
+
+                let err = loop {
+                    // loop on interrupt
+                    match f() {
+                        Ok(x) => return Ok(x),
+                        Err(e) if e.kind() == io::ErrorKind::Interrupted => vm.check_signals()?,
+                        Err(e) => break e,
+                    }
+                };
+                if timeout.is_some() && err.kind() == io::ErrorKind::WouldBlock {
+                    continue;
+                }
+                return Err(err.into());
+            }
+        }
+
+        fn extract_address(
+            &self,
+            addr: PyObjectRef,
+            caller: &str,
+            vm: &VirtualMachine,
+        ) -> Result<socket2::SockAddr, IoOrPyException> {
+            let family = self.family.load();
+            match family {
+                #[cfg(unix)]
+                c::AF_UNIX => {
+                    use crate::vm::function::ArgStrOrBytesLike;
+                    use std::os::unix::ffi::OsStrExt;
+                    let buf = ArgStrOrBytesLike::try_from_object(vm, addr)?;
+                    let bytes = &*buf.borrow_bytes();
+                    let path = match &buf {
+                        ArgStrOrBytesLike::Buf(_) => ffi::OsStr::from_bytes(bytes).into(),
+                        ArgStrOrBytesLike::Str(s) => vm.fsencode(s)?,
+                    };
+                    socket2::SockAddr::unix(path)
+                        .map_err(|_| vm.new_os_error("AF_UNIX path too long".to_owned()).into())
+                }
+                c::AF_INET => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_INET address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    if tuple.len() != 2 {
+                        return Err(vm
+                            .new_type_error("AF_INET address must be a pair (host, post)")
+                            .into());
+                    }
+                    let addr = Address::from_tuple(&tuple, vm)?;
+                    let mut addr4 = get_addr(vm, addr.host, c::AF_INET)?;
+                    match &mut addr4 {
+                        SocketAddr::V4(addr4) => {
+                            addr4.set_port(addr.port);
+                        }
+                        SocketAddr::V6(_) => unreachable!(),
+                    }
+                    Ok(addr4.into())
+                }
+                c::AF_INET6 => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_INET6 address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    match tuple.len() {
+                        2..=4 => {}
+                        _ => return Err(vm.new_type_error(
+                            "AF_INET6 address must be a tuple (host, port[, flowinfo[, scopeid]])",
+                        ).into()),
+                    }
+                    let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&tuple, vm)?;
+                    let mut addr6 = get_addr(vm, addr.host, c::AF_INET6)?;
+                    match &mut addr6 {
+                        SocketAddr::V6(addr6) => {
+                            addr6.set_port(addr.port);
+                            addr6.set_flowinfo(flowinfo);
+                            addr6.set_scope_id(scopeid);
+                        }
+                        SocketAddr::V4(_) => unreachable!(),
+                    }
+                    Ok(addr6.into())
+                }
+                #[cfg(target_os = "linux")]
+                c::AF_CAN => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_CAN address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    if tuple.is_empty() || tuple.len() > 2 {
+                        return Err(vm
+                            .new_type_error(
+                                "AF_CAN address must be a tuple (interface,) or (interface, addr)",
+                            )
+                            .into());
+                    }
+                    let interface: PyStrRef = tuple[0].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_CAN interface must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    let ifname = interface.as_str();
+
+                    // Get interface index
+                    let ifindex = if ifname.is_empty() {
+                        0 // Bind to all CAN interfaces
+                    } else {
+                        // Check interface name length (IFNAMSIZ is typically 16)
+                        if ifname.len() >= 16 {
+                            return Err(vm
+                                .new_os_error("interface name too long".to_owned())
+                                .into());
+                        }
+                        let cstr = alloc::ffi::CString::new(ifname)
+                            .map_err(|_| vm.new_os_error("invalid interface name".to_owned()))?;
+                        let idx = unsafe { libc::if_nametoindex(cstr.as_ptr()) };
+                        if idx == 0 {
+                            return Err(io::Error::last_os_error().into());
+                        }
+                        idx as i32
+                    };
+
+                    // Create sockaddr_can
+                    let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
+                    let can_addr =
+                        &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_can;
+                    unsafe {
+                        (*can_addr).can_family = libc::AF_CAN as libc::sa_family_t;
+                        (*can_addr).can_ifindex = ifindex;
+                    }
+                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    Ok(unsafe {
+                        socket2::SockAddr::new(
+                            storage,
+                            std::mem::size_of::<libc::sockaddr_can>() as libc::socklen_t,
+                        )
+                    })
+                }
+                #[cfg(target_os = "linux")]
+                c::AF_ALG => {
+                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG address must be tuple, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    if tuple.len() != 2 {
+                        return Err(vm
+                            .new_type_error("AF_ALG address must be a tuple (type, name)")
+                            .into());
+                    }
+                    let alg_type: PyStrRef = tuple[0].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG type must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+                    let alg_name: PyStrRef = tuple[1].clone().downcast().map_err(|obj| {
+                        vm.new_type_error(format!(
+                            "{}(): AF_ALG name must be str, not {}",
+                            caller,
+                            obj.class().name()
+                        ))
+                    })?;
+
+                    let type_str = alg_type.as_str();
+                    let name_str = alg_name.as_str();
+
+                    // salg_type is 14 bytes, salg_name is 64 bytes
+                    if type_str.len() >= 14 {
+                        return Err(vm.new_value_error("type too long".to_owned()).into());
+                    }
+                    if name_str.len() >= 64 {
+                        return Err(vm.new_value_error("name too long".to_owned()).into());
+                    }
+
+                    // Create sockaddr_alg
+                    let mut storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
+                    let alg_addr =
+                        &mut storage as *mut libc::sockaddr_storage as *mut libc::sockaddr_alg;
+                    unsafe {
+                        (*alg_addr).salg_family = libc::AF_ALG as libc::sa_family_t;
+                        // Copy type string
+                        for (i, b) in type_str.bytes().enumerate() {
+                            (*alg_addr).salg_type[i] = b;
+                        }
+                        // Copy name string
+                        for (i, b) in name_str.bytes().enumerate() {
+                            (*alg_addr).salg_name[i] = b;
+                        }
+                    }
+                    let storage: socket2::SockAddrStorage = unsafe { std::mem::transmute(storage) };
+                    Ok(unsafe {
+                        socket2::SockAddr::new(
+                            storage,
+                            std::mem::size_of::<libc::sockaddr_alg>() as libc::socklen_t,
+                        )
+                    })
+                }
+                _ => Err(vm.new_os_error(format!("{caller}(): bad family")).into()),
+            }
+        }
+
+        fn connect_inner(
+            &self,
+            address: PyObjectRef,
+            caller: &str,
+            vm: &VirtualMachine,
+        ) -> Result<(), IoOrPyException> {
+            let sock_addr = self.extract_address(address, caller, vm)?;
+
+            let err = match self.sock()?.connect(&sock_addr) {
+                Ok(()) => return Ok(()),
+                Err(e) => e,
+            };
+
+            let wait_connect = if err.kind() == io::ErrorKind::Interrupted {
+                vm.check_signals()?;
+                self.timeout.load() != 0.0
+            } else {
+                #[cfg(unix)]
+                use c::EINPROGRESS;
+                #[cfg(windows)]
+                use c::WSAEWOULDBLOCK as EINPROGRESS;
+
+                self.timeout.load() > 0.0 && err.raw_os_error() == Some(EINPROGRESS)
+            };
+
+            if wait_connect {
+                // basically, connect() is async, and it registers an "error" on the socket when it's
+                // done connecting. SelectKind::Connect fills the errorfds fd_set, so if we wake up
+                // from poll and the error is EISCONN then we know that the connect is done
+                self.sock_op(vm, SelectKind::Connect, || {
+                    let sock = self.sock()?;
+                    let err = sock.take_error()?;
+                    match err {
+                        Some(e) if e.posix_errno() == libc::EISCONN => Ok(()),
+                        Some(e) => Err(e),
+                        // TODO: is this accurate?
+                        None => Ok(()),
+                    }
+                })
+            } else {
+                Err(err.into())
+            }
+        }
+    }
+
+    impl DefaultConstructor for PySocket {}
+
+    impl Initializer for PySocket {
+        type Args = (
+            OptionalArg<i32>,
+            OptionalArg<i32>,
+            OptionalArg<i32>,
+            OptionalOption<PyObjectRef>,
+        );
+
+        fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+            Self::_init(zelf, args, vm).map_err(|e| e.into_pyexception(vm))
+        }
+    }
+
+    impl Representable for PySocket {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok(format!(
+                "<socket object, fd={}, family={}, type={}, proto={}>",
+                zelf.fileno(),
+                zelf.family.load(),
+                zelf.kind.load(),
+                zelf.proto.load(),
+            ))
+        }
+    }
+
+    #[pyclass(with(Constructor, Initializer, Representable), flags(BASETYPE))]
+    impl PySocket {
+        fn _init(
+            zelf: PyRef<Self>,
+            (family, socket_kind, proto, fileno): <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 sock;
+
+            // On Windows, fileno can be bytes from socket.share() for fromshare()
+            #[cfg(windows)]
+            if let Some(fileno_obj) = fileno.flatten() {
+                use crate::vm::builtins::PyBytes;
+                if let Ok(bytes) = fileno_obj.clone().downcast::<PyBytes>() {
+                    let bytes_data = bytes.as_bytes();
+                    let expected_size = std::mem::size_of::<c::WSAPROTOCOL_INFOW>();
+
+                    if bytes_data.len() != expected_size {
+                        return Err(vm
+                            .new_value_error(format!(
+                                "socket descriptor string has wrong size, should be {} bytes",
+                                expected_size
+                            ))
+                            .into());
+                    }
+
+                    let mut info: c::WSAPROTOCOL_INFOW = unsafe { std::mem::zeroed() };
+                    unsafe {
+                        std::ptr::copy_nonoverlapping(
+                            bytes_data.as_ptr(),
+                            &mut info as *mut c::WSAPROTOCOL_INFOW as *mut u8,
+                            expected_size,
+                        );
+                    }
+
+                    let fd = unsafe {
+                        c::WSASocketW(
+                            c::FROM_PROTOCOL_INFO,
+                            c::FROM_PROTOCOL_INFO,
+                            c::FROM_PROTOCOL_INFO,
+                            &info,
+                            0,
+                            c::WSA_FLAG_OVERLAPPED,
+                        )
+                    };
+
+                    if fd == c::INVALID_SOCKET {
+                        return Err(Self::wsa_error().into());
+                    }
+
+                    crate::vm::stdlib::nt::raw_set_handle_inheritable(fd as _, false)?;
+
+                    family = info.iAddressFamily;
+                    socket_kind = info.iSocketType;
+                    proto = info.iProtocol;
+
+                    sock = unsafe { sock_from_raw_unchecked(fd as RawSocket) };
+                    return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+                }
+
+                // Not bytes, treat as regular fileno
+                let fileno = get_raw_sock(fileno_obj, vm)?;
+                sock = sock_from_raw(fileno, vm)?;
+                match sock.local_addr() {
+                    Ok(addr) if family == -1 => family = addr.family() as i32,
+                    Err(e)
+                        if family == -1
+                            || matches!(
+                                e.raw_os_error(),
+                                Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
+                            ) =>
+                    {
+                        std::mem::forget(sock);
+                        return Err(e.into());
+                    }
+                    _ => {}
+                }
+                if socket_kind == -1 {
+                    socket_kind = sock.r#type().map_err(|e| e.into_pyexception(vm))?.into();
+                }
+                proto = 0;
+                return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+            }
+
+            #[cfg(not(windows))]
+            let fileno = fileno
+                .flatten()
+                .map(|obj| get_raw_sock(obj, vm))
+                .transpose()?;
+            #[cfg(not(windows))]
+            if let Some(fileno) = fileno {
+                sock = sock_from_raw(fileno, vm)?;
+                match sock.local_addr() {
+                    Ok(addr) if family == -1 => family = addr.family() as i32,
+                    Err(e)
+                        if family == -1
+                            || matches!(
+                                e.raw_os_error(),
+                                Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
+                            ) =>
+                    {
+                        core::mem::forget(sock);
+                        return Err(e.into());
+                    }
+                    _ => {}
+                }
+                if socket_kind == -1 {
+                    socket_kind = sock.r#type().map_err(|e| e.into_pyexception(vm))?.into();
+                }
+                cfg_if::cfg_if! {
+                    if #[cfg(any(
+                        target_os = "android",
+                        target_os = "freebsd",
+                        target_os = "fuchsia",
+                        target_os = "linux",
+                    ))] {
+                        if proto == -1 {
+                            proto = sock.protocol()?.map_or(0, Into::into);
+                        }
+                    } else {
+                        proto = 0;
+                    }
+                }
+                return Ok(zelf.init_inner(family, socket_kind, proto, sock)?);
+            }
+
+            // No fileno provided, create new socket
+            {
+                if family == -1 {
+                    family = c::AF_INET as _
+                }
+                if socket_kind == -1 {
+                    socket_kind = c::SOCK_STREAM
+                }
+                if proto == -1 {
+                    proto = 0
+                }
+                sock = Socket::new(family.into(), socket_kind.into(), Some(proto.into()))?;
+            };
+            Ok(zelf.init_inner(family, socket_kind, proto, sock)?)
+        }
+
+        #[pymethod]
+        fn connect(
+            &self,
+            address: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> Result<(), IoOrPyException> {
+            self.connect_inner(address, "connect", vm)
+        }
+
+        #[pymethod]
+        fn connect_ex(&self, address: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
+            match self.connect_inner(address, "connect_ex", vm) {
+                Ok(()) => Ok(0),
+                Err(err) => err.errno(),
+            }
+        }
+
+        #[pymethod]
+        fn bind(&self, address: PyObjectRef, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
+            let sock_addr = self.extract_address(address, "bind", vm)?;
+            Ok(self.sock()?.bind(&sock_addr)?)
+        }
+
+        #[pymethod]
+        fn listen(&self, backlog: OptionalArg<i32>) -> io::Result<()> {
+            let backlog = backlog.unwrap_or(128);
+            let backlog = if backlog < 0 { 0 } else { backlog };
+            self.sock()?.listen(backlog)
+        }
+
+        #[pymethod]
+        fn _accept(
+            &self,
+            vm: &VirtualMachine,
+        ) -> Result<(RawSocket, PyObjectRef), IoOrPyException> {
+            // Use accept_raw() instead of accept() to avoid socket2's set_common_flags()
+            // which tries to set SO_NOSIGPIPE and fails with EINVAL on Unix domain sockets on macOS
+            let (sock, addr) = self.sock_op(vm, SelectKind::Read, || self.sock()?.accept_raw())?;
+            let fd = into_sock_fileno(sock);
+            Ok((fd, get_addr_tuple(&addr, vm)))
+        }
+
+        #[pymethod]
+        fn recv(
+            &self,
+            bufsize: usize,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<Vec<u8>, IoOrPyException> {
+            let flags = flags.unwrap_or(0);
+            let mut buffer = Vec::with_capacity(bufsize);
+            let sock = self.sock()?;
+            let n = self.sock_op(vm, SelectKind::Read, || {
+                sock.recv_with_flags(buffer.spare_capacity_mut(), flags)
+            })?;
+            unsafe { buffer.set_len(n) };
+            Ok(buffer)
+        }
+
+        #[pymethod]
+        fn recv_into(
+            &self,
+            buf: ArgMemoryBuffer,
+            nbytes: OptionalArg<isize>,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<usize, IoOrPyException> {
+            let flags = flags.unwrap_or(0);
+            let sock = self.sock()?;
+            let mut buf = buf.borrow_buf_mut();
+            let buf = &mut *buf;
+
+            // 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())
+                })?;
+                nbytes.min(buf.len())
+            } else {
+                buf.len()
+            };
+
+            let buf = &mut buf[..read_len];
+            self.sock_op(vm, SelectKind::Read, || {
+                sock.recv_with_flags(unsafe { slice_as_uninit(buf) }, flags)
+            })
+        }
+
+        #[pymethod]
+        fn recvfrom(
+            &self,
+            bufsize: isize,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<(Vec<u8>, PyObjectRef), IoOrPyException> {
+            let flags = flags.unwrap_or(0);
+            let bufsize = bufsize
+                .to_usize()
+                .ok_or_else(|| vm.new_value_error("negative buffersize in recvfrom"))?;
+            let mut buffer = Vec::with_capacity(bufsize);
+            let (n, addr) = self.sock_op(vm, SelectKind::Read, || {
+                self.sock()?
+                    .recv_from_with_flags(buffer.spare_capacity_mut(), flags)
+            })?;
+            unsafe { buffer.set_len(n) };
+            Ok((buffer, get_addr_tuple(&addr, vm)))
+        }
+
+        #[pymethod]
+        fn recvfrom_into(
+            &self,
+            buf: ArgMemoryBuffer,
+            nbytes: OptionalArg<isize>,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<(usize, PyObjectRef), IoOrPyException> {
+            let mut buf = buf.borrow_buf_mut();
+            let buf = &mut *buf;
+            let buf = match nbytes {
+                OptionalArg::Present(i) => {
+                    let i = i.to_usize().ok_or_else(|| {
+                        vm.new_value_error("negative buffersize in recvfrom_into")
+                    })?;
+                    buf.get_mut(..i).ok_or_else(|| {
+                        vm.new_value_error("nbytes is greater than the length of the buffer")
+                    })?
+                }
+                OptionalArg::Missing => buf,
+            };
+            let flags = flags.unwrap_or(0);
+            let sock = self.sock()?;
+            let (n, addr) = self.sock_op(vm, SelectKind::Read, || {
+                sock.recv_from_with_flags(unsafe { slice_as_uninit(buf) }, flags)
+            })?;
+            Ok((n, get_addr_tuple(&addr, vm)))
+        }
+
+        #[pymethod]
+        fn send(
+            &self,
+            bytes: ArgBytesLike,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<usize, IoOrPyException> {
+            let flags = flags.unwrap_or(0);
+            let buf = bytes.borrow_buf();
+            let buf = &*buf;
+            self.sock_op(vm, SelectKind::Write, || {
+                self.sock()?.send_with_flags(buf, flags)
+            })
+        }
+
+        #[pymethod]
+        fn sendall(
+            &self,
+            bytes: ArgBytesLike,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<(), IoOrPyException> {
+            let flags = flags.unwrap_or(0);
+
+            let timeout = self.get_timeout().ok();
+
+            let deadline = timeout.map(Deadline::new);
+
+            let buf = bytes.borrow_buf();
+            let buf = &*buf;
+            let mut buf_offset = 0;
+            // now we have like 3 layers of interrupt loop :)
+            while buf_offset < buf.len() {
+                let interval = deadline.as_ref().map(|d| d.time_until()).transpose()?;
+                self.sock_op_timeout_err(vm, SelectKind::Write, interval, || {
+                    let subbuf = &buf[buf_offset..];
+                    buf_offset += self.sock()?.send_with_flags(subbuf, flags)?;
+                    Ok(())
+                })?;
+                vm.check_signals()?;
+            }
+            Ok(())
+        }
+
+        #[pymethod]
+        fn sendto(
+            &self,
+            bytes: ArgBytesLike,
+            arg2: PyObjectRef,
+            arg3: OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> Result<usize, IoOrPyException> {
+            // signature is bytes[, flags], address
+            let (flags, address) = match arg3 {
+                OptionalArg::Present(arg3) => {
+                    // should just be i32::try_from_obj but tests check for error message
+                    let int = arg2
+                        .try_index_opt(vm)
+                        .unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?;
+                    let flags = int.try_to_primitive::<i32>(vm)?;
+                    (flags, arg3)
+                }
+                OptionalArg::Missing => (0, arg2),
+            };
+            let addr = self.extract_address(address, "sendto", vm)?;
+            let buf = bytes.borrow_buf();
+            let buf = &*buf;
+            self.sock_op(vm, SelectKind::Write, || {
+                self.sock()?.send_to_with_flags(buf, &addr, flags)
+            })
+        }
+
+        #[cfg(all(unix, not(target_os = "redox")))]
+        #[pymethod]
+        fn sendmsg(
+            &self,
+            buffers: Vec<ArgBytesLike>,
+            ancdata: OptionalArg,
+            flags: OptionalArg<i32>,
+            addr: OptionalOption,
+            vm: &VirtualMachine,
+        ) -> PyResult<usize> {
+            let flags = flags.unwrap_or(0);
+            let mut msg = socket2::MsgHdr::new();
+
+            let sockaddr;
+            if let Some(addr) = addr.flatten() {
+                sockaddr = self
+                    .extract_address(addr, "sendmsg", vm)
+                    .map_err(|e| e.into_pyexception(vm))?;
+                msg = msg.with_addr(&sockaddr);
+            }
+
+            let buffers = buffers
+                .iter()
+                .map(|buf| buf.borrow_buf())
+                .collect::<Vec<_>>();
+            let buffers = buffers
+                .iter()
+                .map(|buf| io::IoSlice::new(buf))
+                .collect::<Vec<_>>();
+            msg = msg.with_buffers(&buffers);
+
+            let control_buf;
+            if let OptionalArg::Present(ancdata) = ancdata {
+                let cmsgs = vm.extract_elements_with(
+                    &ancdata,
+                    |obj| -> PyResult<(i32, i32, ArgBytesLike)> {
+                        let seq: Vec<PyObjectRef> = obj.try_into_value(vm)?;
+                        let [lvl, typ, data]: [PyObjectRef; 3] = seq
+                            .try_into()
+                            .map_err(|_| vm.new_type_error("expected a sequence of length 3"))?;
+                        Ok((
+                            lvl.try_into_value(vm)?,
+                            typ.try_into_value(vm)?,
+                            data.try_into_value(vm)?,
+                        ))
+                    },
+                )?;
+                control_buf = Self::pack_cmsgs_to_send(&cmsgs, vm)?;
+                if !control_buf.is_empty() {
+                    msg = msg.with_control(&control_buf);
+                }
+            }
+
+            self.sock_op(vm, SelectKind::Write, || {
+                let sock = self.sock()?;
+                sock.sendmsg(&msg, flags)
+            })
+            .map_err(|e| e.into_pyexception(vm))
+        }
+
+        /// sendmsg_afalg([msg], *, op[, iv[, assoclen[, flags]]]) -> int
+        ///
+        /// Set operation mode and target IV for an AF_ALG socket.
+        #[cfg(target_os = "linux")]
+        #[pymethod]
+        fn sendmsg_afalg(&self, args: SendmsgAfalgArgs, vm: &VirtualMachine) -> PyResult<usize> {
+            let msg = args.msg;
+            let op = args.op;
+            let iv = args.iv;
+            let flags = args.flags;
+
+            // Validate assoclen - must be non-negative if provided
+            let assoclen: Option<u32> = match args.assoclen {
+                OptionalArg::Present(val) if val < 0 => {
+                    return Err(vm.new_type_error("assoclen must be non-negative".to_owned()));
+                }
+                OptionalArg::Present(val) => Some(val as u32),
+                OptionalArg::Missing => None,
+            };
+
+            // Build control messages for AF_ALG
+            let mut control_buf = Vec::new();
+
+            // Add ALG_SET_OP control message
+            {
+                let op_bytes = op.to_ne_bytes();
+                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_OP;
+                    let data = libc::CMSG_DATA(cmsg);
+                    std::ptr::copy_nonoverlapping(op_bytes.as_ptr(), data, op_bytes.len());
+                }
+            }
+
+            // Add ALG_SET_IV control message if iv is provided
+            if let Some(iv_data) = iv {
+                let iv_bytes = iv_data.borrow_buf();
+                // struct af_alg_iv { __u32 ivlen; __u8 iv[]; }
+                let iv_struct_size = 4 + iv_bytes.len();
+                let space = unsafe { libc::CMSG_SPACE(iv_struct_size as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(iv_struct_size as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_IV;
+                    let data = libc::CMSG_DATA(cmsg);
+                    // Write ivlen
+                    let ivlen = (iv_bytes.len() as u32).to_ne_bytes();
+                    std::ptr::copy_nonoverlapping(ivlen.as_ptr(), data, 4);
+                    // Write iv
+                    std::ptr::copy_nonoverlapping(iv_bytes.as_ptr(), data.add(4), iv_bytes.len());
+                }
+            }
+
+            // Add ALG_SET_AEAD_ASSOCLEN control message if assoclen is provided
+            if let Some(assoclen_val) = assoclen {
+                let assoclen_bytes = assoclen_val.to_ne_bytes();
+                let space = unsafe { libc::CMSG_SPACE(std::mem::size_of::<u32>() as u32) } as usize;
+                let old_len = control_buf.len();
+                control_buf.resize(old_len + space, 0u8);
+
+                let cmsg = control_buf[old_len..].as_mut_ptr() as *mut libc::cmsghdr;
+                unsafe {
+                    (*cmsg).cmsg_len = libc::CMSG_LEN(std::mem::size_of::<u32>() as u32) as _;
+                    (*cmsg).cmsg_level = libc::SOL_ALG;
+                    (*cmsg).cmsg_type = libc::ALG_SET_AEAD_ASSOCLEN;
+                    let data = libc::CMSG_DATA(cmsg);
+                    std::ptr::copy_nonoverlapping(
+                        assoclen_bytes.as_ptr(),
+                        data,
+                        assoclen_bytes.len(),
+                    );
+                }
+            }
+
+            // Build buffers
+            let buffers = msg.iter().map(|buf| buf.borrow_buf()).collect::<Vec<_>>();
+            let iovecs: Vec<libc::iovec> = buffers
+                .iter()
+                .map(|buf| libc::iovec {
+                    iov_base: buf.as_ptr() as *mut _,
+                    iov_len: buf.len(),
+                })
+                .collect();
+
+            // Set up msghdr
+            let mut msghdr: libc::msghdr = unsafe { std::mem::zeroed() };
+            msghdr.msg_iov = iovecs.as_ptr() as *mut _;
+            msghdr.msg_iovlen = iovecs.len() as _;
+            if !control_buf.is_empty() {
+                msghdr.msg_control = control_buf.as_mut_ptr() as *mut _;
+                msghdr.msg_controllen = control_buf.len() as _;
+            }
+
+            self.sock_op(vm, SelectKind::Write, || {
+                let sock = self.sock()?;
+                let fd = sock_fileno(&sock);
+                let ret = unsafe { libc::sendmsg(fd as libc::c_int, &msghdr, flags) };
+                if ret < 0 {
+                    Err(io::Error::last_os_error())
+                } else {
+                    Ok(ret as usize)
+                }
+            })
+            .map_err(|e| e.into_pyexception(vm))
+        }
+
+        /// recvmsg(bufsize[, ancbufsize[, flags]]) -> (data, ancdata, msg_flags, address)
+        ///
+        /// Receive normal data and ancillary data from the socket.
+        #[cfg(all(unix, not(target_os = "redox")))]
+        #[pymethod]
+        fn recvmsg(
+            &self,
+            bufsize: isize,
+            ancbufsize: OptionalArg<isize>,
+            flags: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyTupleRef> {
+            use core::mem::MaybeUninit;
+
+            if bufsize < 0 {
+                return Err(vm.new_value_error("negative buffer size in recvmsg".to_owned()));
+            }
+            let bufsize = bufsize as usize;
+
+            let ancbufsize = ancbufsize.unwrap_or(0);
+            if ancbufsize < 0 {
+                return Err(
+                    vm.new_value_error("negative ancillary buffer size in recvmsg".to_owned())
+                );
+            }
+            let ancbufsize = ancbufsize as usize;
+            let flags = flags.unwrap_or(0);
+
+            // Allocate buffers
+            let mut data_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); bufsize];
+            let mut anc_buf: Vec<MaybeUninit<u8>> = vec![MaybeUninit::uninit(); ancbufsize];
+            let mut addr_storage: libc::sockaddr_storage = unsafe { core::mem::zeroed() };
+
+            // Set up iovec
+            let mut iov = [libc::iovec {
+                iov_base: data_buf.as_mut_ptr().cast(),
+                iov_len: bufsize,
+            }];
+
+            // Set up msghdr
+            let mut msg: libc::msghdr = unsafe { core::mem::zeroed() };
+            msg.msg_name = (&mut addr_storage as *mut libc::sockaddr_storage).cast();
+            msg.msg_namelen = core::mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
+            msg.msg_iov = iov.as_mut_ptr();
+            msg.msg_iovlen = 1;
+            if ancbufsize > 0 {
+                msg.msg_control = anc_buf.as_mut_ptr().cast();
+                msg.msg_controllen = ancbufsize as _;
+            }
+
+            let n = self
+                .sock_op(vm, SelectKind::Read, || {
+                    let sock = self.sock()?;
+                    let fd = sock_fileno(&sock);
+                    let ret = unsafe { libc::recvmsg(fd as libc::c_int, &mut msg, flags) };
+                    if ret < 0 {
+                        Err(io::Error::last_os_error())
+                    } else {
+                        Ok(ret as usize)
+                    }
+                })
+                .map_err(|e| e.into_pyexception(vm))?;
+
+            // Build data bytes
+            let data = unsafe {
+                data_buf.set_len(n);
+                core::mem::transmute::<Vec<MaybeUninit<u8>>, Vec<u8>>(data_buf)
+            };
+
+            // Build ancdata list
+            let ancdata = Self::parse_ancillary_data(&msg, vm)?;
+
+            // Build address tuple
+            let address = if msg.msg_namelen > 0 {
+                let storage: socket2::SockAddrStorage =
+                    unsafe { core::mem::transmute(addr_storage) };
+                let addr = unsafe { socket2::SockAddr::new(storage, msg.msg_namelen) };
+                get_addr_tuple(&addr, vm)
+            } else {
+                vm.ctx.none()
+            };
+
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_bytes(data).into(),
+                ancdata,
+                vm.ctx.new_int(msg.msg_flags).into(),
+                address,
+            ]))
+        }
+
+        /// Parse ancillary data from a received message header
+        #[cfg(all(unix, not(target_os = "redox")))]
+        fn parse_ancillary_data(msg: &libc::msghdr, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            let mut result = Vec::new();
+
+            // Calculate buffer end for truncation handling
+            let ctrl_buf = msg.msg_control as *const u8;
+            let ctrl_end = unsafe { ctrl_buf.add(msg.msg_controllen as _) };
+
+            let mut cmsg: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(msg) };
+            while !cmsg.is_null() {
+                let cmsg_ref = unsafe { &*cmsg };
+                let data_ptr = unsafe { libc::CMSG_DATA(cmsg) };
+
+                // Calculate data length, respecting buffer truncation
+                let data_len_from_cmsg =
+                    cmsg_ref.cmsg_len as usize - (data_ptr as usize - cmsg as usize);
+                let available = ctrl_end as usize - data_ptr as usize;
+                let data_len = data_len_from_cmsg.min(available);
+
+                let data = unsafe { core::slice::from_raw_parts(data_ptr, data_len) };
+
+                let tuple = vm.ctx.new_tuple(vec![
+                    vm.ctx.new_int(cmsg_ref.cmsg_level).into(),
+                    vm.ctx.new_int(cmsg_ref.cmsg_type).into(),
+                    vm.ctx.new_bytes(data.to_vec()).into(),
+                ]);
+
+                result.push(tuple.into());
+
+                cmsg = unsafe { libc::CMSG_NXTHDR(msg, cmsg) };
+            }
+
+            Ok(vm.ctx.new_list(result).into())
+        }
+
+        // based on nix's implementation
+        #[cfg(all(unix, not(target_os = "redox")))]
+        fn pack_cmsgs_to_send(
+            cmsgs: &[(i32, i32, ArgBytesLike)],
+            vm: &VirtualMachine,
+        ) -> PyResult<Vec<u8>> {
+            use core::{mem, ptr};
+
+            if cmsgs.is_empty() {
+                return Ok(vec![]);
+            }
+
+            let capacity = cmsgs
+                .iter()
+                .map(|(_, _, buf)| buf.len())
+                .try_fold(0, |sum, len| {
+                    let space = checked_cmsg_space(len).ok_or_else(|| {
+                        vm.new_os_error("ancillary data item too large".to_owned())
+                    })?;
+                    usize::checked_add(sum, space)
+                        .ok_or_else(|| vm.new_os_error("too much ancillary data".to_owned()))
+                })?;
+
+            let mut cmsg_buffer = vec![0u8; capacity];
+
+            // make a dummy msghdr so we can use the CMSG_* apis
+            let mut mhdr = unsafe { mem::zeroed::<libc::msghdr>() };
+            mhdr.msg_control = cmsg_buffer.as_mut_ptr().cast();
+            mhdr.msg_controllen = capacity as _;
+
+            let mut pmhdr: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(&mhdr) };
+            for (lvl, typ, buf) in cmsgs {
+                if pmhdr.is_null() {
+                    return Err(vm.new_runtime_error(
+                        "unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR",
+                    ));
+                }
+                let data = &*buf.borrow_buf();
+                assert_eq!(data.len(), buf.len());
+                // Safe because we know that pmhdr is valid, and we initialized it with
+                // sufficient space
+                unsafe {
+                    (*pmhdr).cmsg_level = *lvl;
+                    (*pmhdr).cmsg_type = *typ;
+                    (*pmhdr).cmsg_len = libc::CMSG_LEN(data.len() as _) as _;
+                    ptr::copy_nonoverlapping(data.as_ptr(), libc::CMSG_DATA(pmhdr), data.len());
+                }
+
+                // Safe because mhdr is valid
+                pmhdr = unsafe { libc::CMSG_NXTHDR(&mhdr, pmhdr) };
+            }
+
+            Ok(cmsg_buffer)
+        }
+
+        #[pymethod]
+        fn close(&self) -> io::Result<()> {
+            let sock = self.sock.write().take();
+            if let Some(sock) = sock {
+                close_inner(into_sock_fileno(sock))?;
+            }
+            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 {
+            let sock = self.sock.write().take();
+            sock.map_or(INVALID_SOCKET as i64, |s| into_sock_fileno(s) as i64)
+        }
+
+        #[pymethod]
+        fn fileno(&self) -> i64 {
+            self.sock
+                .read()
+                .as_ref()
+                .map_or(INVALID_SOCKET as i64, |s| sock_fileno(s) as i64)
+        }
+
+        #[pymethod]
+        fn getsockname(&self, vm: &VirtualMachine) -> std::io::Result<PyObjectRef> {
+            let addr = self.sock()?.local_addr()?;
+
+            Ok(get_addr_tuple(&addr, vm))
+        }
+
+        #[pymethod]
+        fn getpeername(&self, vm: &VirtualMachine) -> std::io::Result<PyObjectRef> {
+            let addr = self.sock()?.peer_addr()?;
+
+            Ok(get_addr_tuple(&addr, vm))
+        }
+
+        #[pymethod]
+        fn gettimeout(&self) -> Option<f64> {
+            let timeout = self.timeout.load();
+            if timeout >= 0.0 { Some(timeout) } else { None }
+        }
+
+        #[pymethod]
+        fn setblocking(&self, block: bool) -> io::Result<()> {
+            self.timeout.store(if block { -1.0 } else { 0.0 });
+            self.sock()?.set_nonblocking(!block)
+        }
+
+        #[pymethod]
+        fn getblocking(&self) -> bool {
+            self.timeout.load() != 0.0
+        }
+
+        #[pymethod]
+        fn settimeout(&self, timeout: Option<Duration>) -> io::Result<()> {
+            self.timeout
+                .store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
+            // 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())
+        }
+
+        #[pymethod]
+        fn getsockopt(
+            &self,
+            level: i32,
+            name: i32,
+            buflen: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> Result<PyObjectRef, IoOrPyException> {
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+            let buflen = buflen.unwrap_or(0);
+            if buflen == 0 {
+                let mut flag: libc::c_int = 0;
+                let mut flagsize = core::mem::size_of::<libc::c_int>() as _;
+                let ret = unsafe {
+                    c::getsockopt(
+                        fd as _,
+                        level,
+                        name,
+                        &mut flag as *mut libc::c_int as *mut _,
+                        &mut flagsize,
+                    )
+                };
+                if ret < 0 {
+                    return Err(crate::common::os::errno_io_error().into());
+                }
+                Ok(vm.ctx.new_int(flag).into())
+            } else {
+                if buflen <= 0 || buflen > 1024 {
+                    return Err(vm
+                        .new_os_error("getsockopt buflen out of range".to_owned())
+                        .into());
+                }
+                let mut buf = vec![0u8; buflen as usize];
+                let mut buflen = buflen as _;
+                let ret = unsafe {
+                    c::getsockopt(
+                        fd as _,
+                        level,
+                        name,
+                        buf.as_mut_ptr() as *mut _,
+                        &mut buflen,
+                    )
+                };
+                if ret < 0 {
+                    return Err(crate::common::os::errno_io_error().into());
+                }
+                buf.truncate(buflen as usize);
+                Ok(vm.ctx.new_bytes(buf).into())
+            }
+        }
+
+        #[pymethod]
+        fn setsockopt(
+            &self,
+            level: i32,
+            name: i32,
+            value: Option<Either<ArgBytesLike, i32>>,
+            optlen: OptionalArg<u32>,
+            vm: &VirtualMachine,
+        ) -> Result<(), IoOrPyException> {
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+            let ret = match (value, optlen) {
+                (Some(Either::A(b)), OptionalArg::Missing) => b.with_ref(|b| unsafe {
+                    c::setsockopt(fd as _, level, name, b.as_ptr() as *const _, b.len() as _)
+                }),
+                (Some(Either::B(ref val)), OptionalArg::Missing) => unsafe {
+                    c::setsockopt(
+                        fd as _,
+                        level,
+                        name,
+                        val as *const i32 as *const _,
+                        core::mem::size_of::<i32>() as _,
+                    )
+                },
+                (None, OptionalArg::Present(optlen)) => unsafe {
+                    c::setsockopt(fd as _, level, name, core::ptr::null(), optlen as _)
+                },
+                _ => {
+                    return Err(vm
+                        .new_type_error("expected the value arg xor the optlen arg")
+                        .into());
+                }
+            };
+            if ret < 0 {
+                Err(crate::common::os::errno_io_error().into())
+            } else {
+                Ok(())
+            }
+        }
+
+        #[pymethod]
+        fn shutdown(&self, how: i32, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
+            let how = match how {
+                c::SHUT_RD => Shutdown::Read,
+                c::SHUT_WR => Shutdown::Write,
+                c::SHUT_RDWR => Shutdown::Both,
+                _ => {
+                    return Err(vm
+                        .new_value_error("`how` must be SHUT_RD, SHUT_WR, or SHUT_RDWR")
+                        .into());
+                }
+            };
+            Ok(self.sock()?.shutdown(how)?)
+        }
+
+        #[cfg(windows)]
+        fn wsa_error() -> io::Error {
+            io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn ioctl(
+            &self,
+            cmd: PyObjectRef,
+            option: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> Result<u32, IoOrPyException> {
+            use crate::vm::builtins::PyInt;
+            use crate::vm::convert::TryFromObject;
+
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+            let mut recv: u32 = 0;
+
+            // Convert cmd to u32, returning ValueError for invalid/negative values
+            let cmd_int = cmd
+                .downcast::<PyInt>()
+                .map_err(|_| vm.new_type_error("an integer is required"))?;
+            let cmd_val = cmd_int.as_bigint();
+            let cmd: u32 = cmd_val
+                .to_u32()
+                .ok_or_else(|| vm.new_value_error(format!("invalid ioctl command {}", cmd_val)))?;
+
+            match cmd {
+                c::SIO_RCVALL | c::SIO_LOOPBACK_FAST_PATH => {
+                    // Option must be an integer, not None
+                    if vm.is_none(&option) {
+                        return Err(vm
+                            .new_type_error("an integer is required (got type NoneType)")
+                            .into());
+                    }
+                    let option_val: u32 = TryFromObject::try_from_object(vm, option)?;
+                    let ret = unsafe {
+                        c::WSAIoctl(
+                            fd as _,
+                            cmd,
+                            &option_val as *const u32 as *const _,
+                            std::mem::size_of::<u32>() as u32,
+                            std::ptr::null_mut(),
+                            0,
+                            &mut recv,
+                            std::ptr::null_mut(),
+                            None,
+                        )
+                    };
+                    if ret == c::SOCKET_ERROR {
+                        return Err(Self::wsa_error().into());
+                    }
+                    Ok(recv)
+                }
+                c::SIO_KEEPALIVE_VALS => {
+                    let tuple: PyTupleRef = option
+                        .downcast()
+                        .map_err(|_| vm.new_type_error("SIO_KEEPALIVE_VALS requires a tuple"))?;
+                    if tuple.len() != 3 {
+                        return Err(vm
+                            .new_type_error(
+                                "SIO_KEEPALIVE_VALS requires (onoff, keepalivetime, keepaliveinterval)",
+                            )
+                            .into());
+                    }
+
+                    #[repr(C)]
+                    struct TcpKeepalive {
+                        onoff: u32,
+                        keepalivetime: u32,
+                        keepaliveinterval: u32,
+                    }
+
+                    let ka = TcpKeepalive {
+                        onoff: TryFromObject::try_from_object(vm, tuple[0].clone())?,
+                        keepalivetime: TryFromObject::try_from_object(vm, tuple[1].clone())?,
+                        keepaliveinterval: TryFromObject::try_from_object(vm, tuple[2].clone())?,
+                    };
+
+                    let ret = unsafe {
+                        c::WSAIoctl(
+                            fd as _,
+                            cmd,
+                            &ka as *const TcpKeepalive as *const _,
+                            std::mem::size_of::<TcpKeepalive>() as u32,
+                            std::ptr::null_mut(),
+                            0,
+                            &mut recv,
+                            std::ptr::null_mut(),
+                            None,
+                        )
+                    };
+                    if ret == c::SOCKET_ERROR {
+                        return Err(Self::wsa_error().into());
+                    }
+                    Ok(recv)
+                }
+                _ => Err(vm
+                    .new_value_error(format!("invalid ioctl command {}", cmd))
+                    .into()),
+            }
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn share(&self, process_id: u32, _vm: &VirtualMachine) -> Result<Vec<u8>, IoOrPyException> {
+            let sock = self.sock()?;
+            let fd = sock_fileno(&sock);
+
+            let mut info: MaybeUninit<c::WSAPROTOCOL_INFOW> = MaybeUninit::uninit();
+
+            let ret = unsafe { c::WSADuplicateSocketW(fd as _, process_id, info.as_mut_ptr()) };
+
+            if ret == c::SOCKET_ERROR {
+                return Err(Self::wsa_error().into());
+            }
+
+            let info = unsafe { info.assume_init() };
+            let bytes = unsafe {
+                std::slice::from_raw_parts(
+                    &info as *const c::WSAPROTOCOL_INFOW as *const u8,
+                    std::mem::size_of::<c::WSAPROTOCOL_INFOW>(),
+                )
+            };
+
+            Ok(bytes.to_vec())
+        }
+
+        #[pygetset(name = "type")]
+        fn kind(&self) -> i32 {
+            self.kind.load()
+        }
+
+        #[pygetset]
+        fn family(&self) -> i32 {
+            self.family.load()
+        }
+
+        #[pygetset]
+        fn proto(&self) -> i32 {
+            self.proto.load()
+        }
+    }
+
+    struct Address {
+        host: PyStrRef,
+        port: u16,
+    }
+
+    impl ToSocketAddrs for Address {
+        type Iter = alloc::vec::IntoIter<SocketAddr>;
+        fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
+            (self.host.as_str(), self.port).to_socket_addrs()
+        }
+    }
+
+    impl TryFromObject for Address {
+        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+            let tuple = PyTupleRef::try_from_object(vm, obj)?;
+            if tuple.len() != 2 {
+                Err(vm.new_type_error("Address tuple should have only 2 values"))
+            } else {
+                Self::from_tuple(&tuple, vm)
+            }
+        }
+    }
+
+    impl Address {
+        fn from_tuple(tuple: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<Self> {
+            let host = PyStrRef::try_from_object(vm, tuple[0].clone())?;
+            let port = i32::try_from_borrowed_object(vm, &tuple[1])?;
+            let port = port
+                .to_u16()
+                .ok_or_else(|| vm.new_overflow_error("port must be 0-65535."))?;
+            Ok(Self { host, port })
+        }
+
+        fn from_tuple_ipv6(
+            tuple: &[PyObjectRef],
+            vm: &VirtualMachine,
+        ) -> PyResult<(Self, u32, u32)> {
+            let addr = Self::from_tuple(tuple, vm)?;
+            let flowinfo = tuple
+                .get(2)
+                .map(|obj| u32::try_from_borrowed_object(vm, obj))
+                .transpose()?
+                .unwrap_or(0);
+            let scopeid = tuple
+                .get(3)
+                .map(|obj| u32::try_from_borrowed_object(vm, obj))
+                .transpose()?
+                .unwrap_or(0);
+            if flowinfo > 0xfffff {
+                return Err(vm.new_overflow_error("flowinfo must be 0-1048575."));
+            }
+            Ok((addr, flowinfo, scopeid))
+        }
+    }
+
+    fn get_ip_addr_tuple(addr: &SocketAddr, vm: &VirtualMachine) -> PyObjectRef {
+        match addr {
+            SocketAddr::V4(addr) => (addr.ip().to_string(), addr.port()).to_pyobject(vm),
+            SocketAddr::V6(addr) => (
+                addr.ip().to_string(),
+                addr.port(),
+                addr.flowinfo(),
+                addr.scope_id(),
+            )
+                .to_pyobject(vm),
+        }
+    }
+
+    fn get_addr_tuple(addr: &socket2::SockAddr, vm: &VirtualMachine) -> PyObjectRef {
+        if let Some(addr) = addr.as_socket() {
+            return get_ip_addr_tuple(&addr, vm);
+        }
+        #[cfg(unix)]
+        if addr.is_unix() {
+            use std::os::unix::ffi::OsStrExt;
+            if let Some(abstractpath) = addr.as_abstract_namespace() {
+                return vm.ctx.new_bytes([b"\0", abstractpath].concat()).into();
+            }
+            // necessary on macos
+            let path = ffi::OsStr::as_bytes(addr.as_pathname().unwrap_or("".as_ref()).as_ref());
+            let nul_pos = memchr::memchr(b'\0', path).unwrap_or(path.len());
+            let path = ffi::OsStr::from_bytes(&path[..nul_pos]);
+            return vm.fsdecode(path).into();
+        }
+        #[cfg(target_os = "linux")]
+        {
+            let family = addr.family();
+            if family == libc::AF_CAN as libc::sa_family_t {
+                // AF_CAN address: (interface_name,) or (interface_name, can_id)
+                let can_addr = unsafe { &*(addr.as_ptr() as *const libc::sockaddr_can) };
+                let ifindex = can_addr.can_ifindex;
+                let ifname = if ifindex == 0 {
+                    String::new()
+                } else {
+                    let mut buf = [0u8; libc::IF_NAMESIZE];
+                    let ret = unsafe {
+                        libc::if_indextoname(
+                            ifindex as libc::c_uint,
+                            buf.as_mut_ptr() as *mut libc::c_char,
+                        )
+                    };
+                    if ret.is_null() {
+                        String::new()
+                    } else {
+                        let nul_pos = memchr::memchr(b'\0', &buf).unwrap_or(buf.len());
+                        String::from_utf8_lossy(&buf[..nul_pos]).into_owned()
+                    }
+                };
+                return vm.ctx.new_tuple(vec![vm.ctx.new_str(ifname).into()]).into();
+            }
+            if family == libc::AF_ALG as libc::sa_family_t {
+                // AF_ALG address: (type, name)
+                let alg_addr = unsafe { &*(addr.as_ptr() as *const libc::sockaddr_alg) };
+                let type_bytes = &alg_addr.salg_type;
+                let name_bytes = &alg_addr.salg_name;
+                let type_nul = memchr::memchr(b'\0', type_bytes).unwrap_or(type_bytes.len());
+                let name_nul = memchr::memchr(b'\0', name_bytes).unwrap_or(name_bytes.len());
+                let type_str = String::from_utf8_lossy(&type_bytes[..type_nul]).into_owned();
+                let name_str = String::from_utf8_lossy(&name_bytes[..name_nul]).into_owned();
+                return vm
+                    .ctx
+                    .new_tuple(vec![
+                        vm.ctx.new_str(type_str).into(),
+                        vm.ctx.new_str(name_str).into(),
+                    ])
+                    .into();
+            }
+        }
+        // TODO: support more address families
+        (String::new(), 0).to_pyobject(vm)
+    }
+
+    #[pyfunction]
+    fn gethostname(vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        gethostname::gethostname()
+            .into_string()
+            .map(|hostname| vm.ctx.new_str(hostname))
+            .map_err(|err| vm.new_os_error(err.into_string().unwrap()))
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction]
+    fn sethostname(hostname: PyStrRef) -> nix::Result<()> {
+        nix::unistd::sethostname(hostname.as_str())
+    }
+
+    #[pyfunction]
+    fn inet_aton(ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        ip_string
+            .as_str()
+            .parse::<Ipv4Addr>()
+            .map(|ip_addr| Vec::<u8>::from(ip_addr.octets()))
+            .map_err(|_| {
+                vm.new_os_error("illegal IP address string passed to inet_aton".to_owned())
+            })
+    }
+
+    #[pyfunction]
+    fn inet_ntoa(packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let packed_ip = packed_ip.borrow_buf();
+        let packed_ip = <&[u8; 4]>::try_from(&*packed_ip)
+            .map_err(|_| vm.new_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
+        Ok(vm.ctx.new_str(Ipv4Addr::from(*packed_ip).to_string()))
+    }
+
+    fn cstr_opt_as_ptr(x: &OptionalArg<ffi::CString>) -> *const libc::c_char {
+        x.as_ref().map_or_else(core::ptr::null, |s| s.as_ptr())
+    }
+
+    #[pyfunction]
+    fn getservbyname(
+        servicename: PyStrRef,
+        protocolname: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<u16> {
+        let cstr_name = servicename.to_cstring(vm)?;
+        let cstr_proto = protocolname
+            .as_ref()
+            .map(|s| s.to_cstring(vm))
+            .transpose()?;
+        let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
+        let serv = unsafe { c::getservbyname(cstr_name.as_ptr() as _, cstr_proto as _) };
+        if serv.is_null() {
+            return Err(vm.new_os_error("service/proto not found".to_owned()));
+        }
+        let port = unsafe { (*serv).s_port };
+        Ok(u16::from_be(port as u16))
+    }
+
+    #[pyfunction]
+    fn getservbyport(
+        port: i32,
+        protocolname: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<String> {
+        let port = port
+            .to_u16()
+            .ok_or_else(|| vm.new_overflow_error("getservbyport: port must be 0-65535."))?;
+        let cstr_proto = protocolname
+            .as_ref()
+            .map(|s| s.to_cstring(vm))
+            .transpose()?;
+        let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
+        let serv = unsafe { c::getservbyport(port.to_be() as _, cstr_proto as _) };
+        if serv.is_null() {
+            return Err(vm.new_os_error("port/proto not found".to_owned()));
+        }
+        let s = unsafe { ffi::CStr::from_ptr((*serv).s_name as _) };
+        Ok(s.to_string_lossy().into_owned())
+    }
+
+    unsafe fn slice_as_uninit<T>(v: &mut [T]) -> &mut [MaybeUninit<T>] {
+        unsafe { &mut *(v as *mut [T] as *mut [MaybeUninit<T>]) }
+    }
+
+    enum IoOrPyException {
+        Timeout,
+        Py(PyBaseExceptionRef),
+        Io(io::Error),
+    }
+    impl From<PyBaseExceptionRef> for IoOrPyException {
+        fn from(exc: PyBaseExceptionRef) -> Self {
+            Self::Py(exc)
+        }
+    }
+    impl From<PyRef<PyOSError>> for IoOrPyException {
+        fn from(exc: PyRef<PyOSError>) -> Self {
+            Self::Py(exc.upcast())
+        }
+    }
+    impl From<io::Error> for IoOrPyException {
+        fn from(err: io::Error) -> Self {
+            Self::Io(err)
+        }
+    }
+    impl IoOrPyException {
+        fn errno(self) -> PyResult<i32> {
+            match self {
+                Self::Timeout => Ok(errcode!(EWOULDBLOCK)),
+                Self::Io(err) => Ok(err.posix_errno()),
+                Self::Py(exc) => Err(exc),
+            }
+        }
+    }
+    impl IntoPyException for IoOrPyException {
+        #[inline]
+        fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+            match self {
+                Self::Timeout => timeout_error(vm).upcast(),
+                Self::Py(exc) => exc,
+                Self::Io(err) => err.into_pyexception(vm),
+            }
+        }
+    }
+
+    #[derive(Copy, Clone)]
+    pub(crate) enum SelectKind {
+        Read,
+        Write,
+        Connect,
+    }
+
+    /// returns true if timed out
+    pub(crate) fn sock_select(
+        sock: &Socket,
+        kind: SelectKind,
+        interval: Option<Duration>,
+    ) -> io::Result<bool> {
+        #[cfg(unix)]
+        {
+            use nix::poll::*;
+            use std::os::fd::AsFd;
+            let events = match kind {
+                SelectKind::Read => PollFlags::POLLIN,
+                SelectKind::Write => PollFlags::POLLOUT,
+                SelectKind::Connect => PollFlags::POLLOUT | PollFlags::POLLERR,
+            };
+            let mut pollfd = [PollFd::new(sock.as_fd(), events)];
+            let timeout = match interval {
+                Some(d) => d.try_into().unwrap_or(PollTimeout::MAX),
+                None => PollTimeout::NONE,
+            };
+            let ret = poll(&mut pollfd, timeout)?;
+            Ok(ret == 0)
+        }
+        #[cfg(windows)]
+        {
+            use crate::select;
+
+            let fd = sock_fileno(sock);
+
+            let mut reads = select::FdSet::new();
+            let mut writes = select::FdSet::new();
+            let mut errs = select::FdSet::new();
+
+            let fd = fd as usize;
+            match kind {
+                SelectKind::Read => reads.insert(fd),
+                SelectKind::Write => writes.insert(fd),
+                SelectKind::Connect => {
+                    writes.insert(fd);
+                    errs.insert(fd);
+                }
+            }
+
+            let mut interval = interval.map(|dur| select::timeval {
+                tv_sec: dur.as_secs() as _,
+                tv_usec: dur.subsec_micros() as _,
+            });
+
+            select::select(
+                fd as i32 + 1,
+                &mut reads,
+                &mut writes,
+                &mut errs,
+                interval.as_mut(),
+            )
+            .map(|ret| ret == 0)
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct GAIOptions {
+        #[pyarg(positional)]
+        host: Option<PyStrRef>,
+        #[pyarg(positional)]
+        port: Option<Either<PyStrRef, i32>>,
+
+        #[pyarg(positional, default = c::AF_UNSPEC)]
+        family: i32,
+        #[pyarg(positional, default = 0)]
+        ty: i32,
+        #[pyarg(positional, default = 0)]
+        proto: i32,
+        #[pyarg(positional, default = 0)]
+        flags: i32,
+    }
+
+    #[pyfunction]
+    fn getaddrinfo(
+        opts: GAIOptions,
+        vm: &VirtualMachine,
+    ) -> Result<Vec<PyObjectRef>, IoOrPyException> {
+        let hints = dns_lookup::AddrInfoHints {
+            socktype: opts.ty,
+            protocol: opts.proto,
+            address: opts.family,
+            flags: opts.flags,
+        };
+
+        // Encode host using IDNA encoding
+        let host_encoded: Option<String> = match opts.host.as_ref() {
+            Some(s) => {
+                let encoded =
+                    vm.state
+                        .codec_registry
+                        .encode_text(s.to_owned(), "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()))?;
+                Some(host_str.to_owned())
+            }
+            None => None,
+        };
+        let host = host_encoded.as_deref();
+
+        // Encode port using UTF-8
+        let port: Option<alloc::borrow::Cow<'_, str>> = match opts.port.as_ref() {
+            Some(Either::A(s)) => Some(alloc::borrow::Cow::Borrowed(s.to_str().ok_or_else(
+                || vm.new_unicode_encode_error("surrogates not allowed".to_owned()),
+            )?)),
+            Some(Either::B(i)) => Some(alloc::borrow::Cow::Owned(i.to_string())),
+            None => None,
+        };
+        let port = port.as_ref().map(|p| p.as_ref());
+
+        let addrs = dns_lookup::getaddrinfo(host, port, Some(hints))
+            .map_err(|err| convert_socket_error(vm, err, SocketError::GaiError))?;
+
+        let list = addrs
+            .map(|ai| {
+                ai.map(|ai| {
+                    vm.new_tuple((
+                        ai.address,
+                        ai.socktype,
+                        ai.protocol,
+                        ai.canonname,
+                        get_ip_addr_tuple(&ai.sockaddr, vm),
+                    ))
+                    .into()
+                })
+            })
+            .collect::<io::Result<Vec<_>>>()?;
+        Ok(list)
+    }
+
+    #[pyfunction]
+    fn gethostbyaddr(
+        addr: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
+        let addr = get_addr(vm, addr, c::AF_UNSPEC)?;
+        let (hostname, _) = dns_lookup::getnameinfo(&addr, 0)
+            .map_err(|e| convert_socket_error(vm, e, SocketError::HError))?;
+        Ok((
+            hostname,
+            vm.ctx.new_list(vec![]),
+            vm.ctx
+                .new_list(vec![vm.ctx.new_str(addr.ip().to_string()).into()]),
+        ))
+    }
+
+    #[pyfunction]
+    fn gethostbyname(name: PyStrRef, vm: &VirtualMachine) -> Result<String, IoOrPyException> {
+        let addr = get_addr(vm, name, c::AF_INET)?;
+        match addr {
+            SocketAddr::V4(ip) => Ok(ip.ip().to_string()),
+            _ => unreachable!(),
+        }
+    }
+
+    #[pyfunction]
+    fn gethostbyname_ex(
+        name: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
+        let addr = get_addr(vm, name, c::AF_INET)?;
+        let (hostname, _) = dns_lookup::getnameinfo(&addr, 0)
+            .map_err(|e| convert_socket_error(vm, e, SocketError::HError))?;
+        Ok((
+            hostname,
+            vm.ctx.new_list(vec![]),
+            vm.ctx
+                .new_list(vec![vm.ctx.new_str(addr.ip().to_string()).into()]),
+        ))
+    }
+
+    #[pyfunction]
+    fn inet_pton(af_inet: i32, ip_string: PyStrRef, 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
+                .as_str()
+                .parse::<Ipv4Addr>()
+                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
+                .octets()
+                .to_vec(),
+            c::AF_INET6 => ip_string
+                .as_str()
+                .parse::<Ipv6Addr>()
+                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
+                .octets()
+                .to_vec(),
+            _ => return Err(vm.new_os_error("Address family not supported by protocol".to_owned())),
+        };
+        Ok(ip_addr)
+    }
+
+    #[pyfunction]
+    fn inet_ntop(af_inet: i32, packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<String> {
+        let packed_ip = packed_ip.borrow_buf();
+        match af_inet {
+            c::AF_INET => {
+                let packed_ip = <&[u8; 4]>::try_from(&*packed_ip).map_err(|_| {
+                    vm.new_value_error("invalid length of packed IP address string")
+                })?;
+                Ok(Ipv4Addr::from(*packed_ip).to_string())
+            }
+            c::AF_INET6 => {
+                let packed_ip = <&[u8; 16]>::try_from(&*packed_ip).map_err(|_| {
+                    vm.new_value_error("invalid length of packed IP address string")
+                })?;
+                Ok(get_ipv6_addr_str(Ipv6Addr::from(*packed_ip)))
+            }
+            _ => Err(vm.new_value_error(format!("unknown address family {af_inet}"))),
+        }
+    }
+
+    #[pyfunction]
+    fn getprotobyname(name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        let cstr = name.to_cstring(vm)?;
+        let proto = unsafe { c::getprotobyname(cstr.as_ptr() as _) };
+        if proto.is_null() {
+            return Err(vm.new_os_error("protocol not found".to_owned()));
+        }
+        let num = unsafe { (*proto).p_proto };
+        Ok(vm.ctx.new_int(num).into())
+    }
+
+    #[pyfunction]
+    fn getnameinfo(
+        address: PyTupleRef,
+        flags: i32,
+        vm: &VirtualMachine,
+    ) -> Result<(String, String), IoOrPyException> {
+        match address.len() {
+            2..=4 => {}
+            _ => {
+                return Err(vm.new_type_error("illegal sockaddr argument").into());
+            }
+        }
+        let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&address, vm)?;
+        let hints = dns_lookup::AddrInfoHints {
+            address: c::AF_UNSPEC,
+            socktype: c::SOCK_DGRAM,
+            flags: c::AI_NUMERICHOST,
+            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 mut ainfo = res.next().unwrap();
+        if res.next().is_some() {
+            return Err(vm
+                .new_os_error("sockaddr resolved to multiple addresses".to_owned())
+                .into());
+        }
+        match &mut ainfo.sockaddr {
+            SocketAddr::V4(_) => {
+                if address.len() != 2 {
+                    return Err(vm
+                        .new_os_error("IPv4 sockaddr must be 2 tuple".to_owned())
+                        .into());
+                }
+            }
+            SocketAddr::V6(addr) => {
+                addr.set_flowinfo(flowinfo);
+                addr.set_scope_id(scopeid);
+            }
+        }
+        dns_lookup::getnameinfo(&ainfo.sockaddr, flags)
+            .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn socketpair(
+        family: OptionalArg<i32>,
+        socket_kind: OptionalArg<i32>,
+        proto: OptionalArg<i32>,
+    ) -> Result<(PySocket, PySocket), IoOrPyException> {
+        let family = family.unwrap_or(libc::AF_UNIX);
+        let socket_kind = socket_kind.unwrap_or(libc::SOCK_STREAM);
+        let proto = proto.unwrap_or(0);
+        let (a, b) = Socket::pair(family.into(), socket_kind.into(), Some(proto.into()))?;
+        let py_a = PySocket::default();
+        py_a.init_inner(family, socket_kind, proto, a)?;
+        let py_b = PySocket::default();
+        py_b.init_inner(family, socket_kind, proto, b)?;
+        Ok((py_a, py_b))
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    type IfIndex = c::c_uint;
+    #[cfg(windows)]
+    type IfIndex = u32; // NET_IFINDEX but windows-sys 0.59 doesn't have it
+
+    #[cfg(not(target_os = "redox"))]
+    #[pyfunction]
+    fn if_nametoindex(name: FsPath, vm: &VirtualMachine) -> PyResult<IfIndex> {
+        let name = name.to_cstring(vm)?;
+        // in case 'if_nametoindex' does not set errno
+        crate::common::os::set_errno(libc::ENODEV);
+        let ret = unsafe { c::if_nametoindex(name.as_ptr() as _) };
+        if ret == 0 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(ret)
+        }
+    }
+
+    #[cfg(not(target_os = "redox"))]
+    #[pyfunction]
+    fn if_indextoname(index: IfIndex, vm: &VirtualMachine) -> PyResult<String> {
+        let mut buf = [0; c::IF_NAMESIZE + 1];
+        // in case 'if_indextoname' does not set errno
+        crate::common::os::set_errno(libc::ENXIO);
+        let ret = unsafe { c::if_indextoname(index, buf.as_mut_ptr()) };
+        if ret.is_null() {
+            Err(vm.new_last_errno_error())
+        } else {
+            let buf = unsafe { ffi::CStr::from_ptr(buf.as_ptr() as _) };
+            Ok(buf.to_string_lossy().into_owned())
+        }
+    }
+
+    #[cfg(any(
+        windows,
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "fuchsia",
+        target_os = "ios",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+    ))]
+    #[pyfunction]
+    fn if_nameindex(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        #[cfg(not(windows))]
+        {
+            let list = nix::net::if_::if_nameindex()
+                .map_err(|err| err.into_pyexception(vm))?
+                .to_slice()
+                .iter()
+                .map(|iface| {
+                    let tup: (u32, String) =
+                        (iface.index(), iface.name().to_string_lossy().into_owned());
+                    tup.to_pyobject(vm)
+                })
+                .collect();
+
+            Ok(list)
+        }
+        #[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))?;
+            let list = table.as_slice().iter().map(|entry| {
+                let name =
+                    get_name(&entry.InterfaceLuid).map_err(|err| err.into_pyexception(vm))?;
+                let tup = (entry.InterfaceIndex, name.to_string_lossy());
+                Ok(tup.to_pyobject(vm))
+            });
+            let list = list.collect::<PyResult<_>>()?;
+            return Ok(list);
+
+            fn get_name(luid: &NET_LUID_LH) -> io::Result<widestring::WideCString> {
+                let mut buf = [0; c::IF_NAMESIZE + 1];
+                let ret = unsafe {
+                    IpHelper::ConvertInterfaceLuidToNameW(luid, buf.as_mut_ptr(), buf.len())
+                };
+                if ret == 0 {
+                    Ok(widestring::WideCString::from_ustr_truncate(
+                        widestring::WideStr::from_slice(&buf[..]),
+                    ))
+                } else {
+                    Err(io::Error::from_raw_os_error(ret as i32))
+                }
+            }
+            struct MibTable {
+                ptr: ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
+            }
+            impl MibTable {
+                fn get_raw() -> io::Result<Self> {
+                    let mut ptr = ptr::null_mut();
+                    let ret = unsafe { IpHelper::GetIfTable2Ex(IpHelper::MibIfTableRaw, &mut ptr) };
+                    if ret == 0 {
+                        let ptr = unsafe { ptr::NonNull::new_unchecked(ptr) };
+                        Ok(Self { ptr })
+                    } else {
+                        Err(io::Error::from_raw_os_error(ret as i32))
+                    }
+                }
+            }
+            impl MibTable {
+                fn as_slice(&self) -> &[IpHelper::MIB_IF_ROW2] {
+                    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)
+                    }
+                }
+            }
+            impl Drop for MibTable {
+                fn drop(&mut self) {
+                    unsafe { IpHelper::FreeMibTable(self.ptr.as_ptr() as *mut _) };
+                }
+            }
+        }
+    }
+
+    fn get_addr(
+        vm: &VirtualMachine,
+        pyname: PyStrRef,
+        af: i32,
+    ) -> Result<SocketAddr, IoOrPyException> {
+        let name = pyname.as_str();
+        if name.is_empty() {
+            let hints = dns_lookup::AddrInfoHints {
+                address: af,
+                socktype: c::SOCK_DGRAM,
+                flags: c::AI_PASSIVE,
+                protocol: 0,
+            };
+            let mut res = dns_lookup::getaddrinfo(None, Some("0"), Some(hints))
+                .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?;
+            let ainfo = res.next().unwrap()?;
+            if res.next().is_some() {
+                return Err(vm
+                    .new_os_error("wildcard resolved to multiple address".to_owned())
+                    .into());
+            }
+            return Ok(ainfo.sockaddr);
+        }
+        if name == "255.255.255.255" || name == "<broadcast>" {
+            match af {
+                c::AF_INET | c::AF_UNSPEC => {}
+                _ => {
+                    return Err(vm
+                        .new_os_error("address family mismatched".to_owned())
+                        .into());
+                }
+            }
+            return Ok(SocketAddr::V4(net::SocketAddrV4::new(
+                c::INADDR_BROADCAST.into(),
+                0,
+            )));
+        }
+        if let c::AF_INET | c::AF_UNSPEC = af
+            && let Ok(addr) = name.parse::<Ipv4Addr>()
+        {
+            return Ok(SocketAddr::V4(net::SocketAddrV4::new(addr, 0)));
+        }
+        if matches!(af, c::AF_INET | c::AF_UNSPEC)
+            && !name.contains('%')
+            && let Ok(addr) = name.parse::<Ipv6Addr>()
+        {
+            return Ok(SocketAddr::V6(net::SocketAddrV6::new(addr, 0, 0, 0)));
+        }
+        let hints = dns_lookup::AddrInfoHints {
+            address: af,
+            ..Default::default()
+        };
+        let name = vm
+            .state
+            .codec_registry
+            .encode_text(pyname, "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))
+            .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?;
+        Ok(res.next().unwrap().map(|ainfo| ainfo.sockaddr)?)
+    }
+
+    fn sock_from_raw(fileno: RawSocket, vm: &VirtualMachine) -> PyResult<Socket> {
+        let invalid = {
+            cfg_if::cfg_if! {
+                if #[cfg(windows)] {
+                    fileno == INVALID_SOCKET
+                } else {
+                    fileno < 0
+                }
+            }
+        };
+        if invalid {
+            return Err(vm.new_value_error("negative file descriptor"));
+        }
+        Ok(unsafe { sock_from_raw_unchecked(fileno) })
+    }
+    /// SAFETY: fileno must not be equal to INVALID_SOCKET
+    unsafe fn sock_from_raw_unchecked(fileno: RawSocket) -> Socket {
+        #[cfg(unix)]
+        {
+            use std::os::unix::io::FromRawFd;
+            unsafe { Socket::from_raw_fd(fileno) }
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::io::FromRawSocket;
+            unsafe { Socket::from_raw_socket(fileno) }
+        }
+    }
+    pub(super) fn sock_fileno(sock: &Socket) -> RawSocket {
+        #[cfg(unix)]
+        {
+            use std::os::unix::io::AsRawFd;
+            sock.as_raw_fd()
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::io::AsRawSocket;
+            sock.as_raw_socket()
+        }
+    }
+    fn into_sock_fileno(sock: Socket) -> RawSocket {
+        #[cfg(unix)]
+        {
+            use std::os::unix::io::IntoRawFd;
+            sock.into_raw_fd()
+        }
+        #[cfg(windows)]
+        {
+            use std::os::windows::io::IntoRawSocket;
+            sock.into_raw_socket()
+        }
+    }
+
+    pub(super) const INVALID_SOCKET: RawSocket = {
+        #[cfg(unix)]
+        {
+            -1
+        }
+        #[cfg(windows)]
+        {
+            windows_sys::Win32::Networking::WinSock::INVALID_SOCKET as RawSocket
+        }
+    };
+
+    fn convert_socket_error(
+        vm: &VirtualMachine,
+        err: dns_lookup::LookupError,
+        err_kind: SocketError,
+    ) -> IoOrPyException {
+        if let dns_lookup::LookupErrorKind::System = err.kind() {
+            return io::Error::from(err).into();
+        }
+        let strerr = {
+            #[cfg(unix)]
+            {
+                let s = match err_kind {
+                    SocketError::GaiError => unsafe {
+                        ffi::CStr::from_ptr(libc::gai_strerror(err.error_num()))
+                    },
+                    SocketError::HError => unsafe {
+                        ffi::CStr::from_ptr(libc::hstrerror(err.error_num()))
+                    },
+                };
+                s.to_str().unwrap()
+            }
+            #[cfg(windows)]
+            {
+                "getaddrinfo failed"
+            }
+        };
+        let exception_cls = match err_kind {
+            SocketError::GaiError => gaierror(vm),
+            SocketError::HError => herror(vm),
+        };
+        vm.new_os_subtype_error(exception_cls, Some(err.error_num()), strerr)
+            .into()
+    }
+
+    fn timeout_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        timeout_error_msg(vm, "timed out".to_owned())
+    }
+    pub(crate) fn timeout_error_msg(vm: &VirtualMachine, msg: String) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(timeout(vm), None, msg)
+    }
+
+    fn get_ipv6_addr_str(ipv6: Ipv6Addr) -> String {
+        match ipv6.to_ipv4() {
+            // instead of "::0.0.ddd.ddd" it's "::xxxx"
+            Some(v4) if !ipv6.is_unspecified() && matches!(v4.octets(), [0, 0, _, _]) => {
+                format!("::{:x}", u32::from(v4))
+            }
+            _ => ipv6.to_string(),
+        }
+    }
+
+    pub(crate) struct Deadline {
+        deadline: Instant,
+    }
+
+    impl Deadline {
+        fn new(timeout: Duration) -> Self {
+            Self {
+                deadline: Instant::now() + timeout,
+            }
+        }
+        fn time_until(&self) -> Result<Duration, IoOrPyException> {
+            self.deadline
+                .checked_duration_since(Instant::now())
+                // past the deadline already
+                .ok_or(IoOrPyException::Timeout)
+        }
+    }
+
+    static DEFAULT_TIMEOUT: AtomicCell<f64> = AtomicCell::new(-1.0);
+
+    #[pyfunction]
+    fn getdefaulttimeout() -> Option<f64> {
+        let timeout = DEFAULT_TIMEOUT.load();
+        if timeout >= 0.0 { Some(timeout) } else { None }
+    }
+
+    #[pyfunction]
+    fn setdefaulttimeout(timeout: Option<Duration>) {
+        DEFAULT_TIMEOUT.store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
+    }
+
+    #[pyfunction]
+    fn dup(x: PyObjectRef, vm: &VirtualMachine) -> Result<RawSocket, IoOrPyException> {
+        let sock = get_raw_sock(x, vm)?;
+        let sock = core::mem::ManuallyDrop::new(sock_from_raw(sock, vm)?);
+        let newsock = sock.try_clone()?;
+        let fd = into_sock_fileno(newsock);
+        #[cfg(windows)]
+        crate::vm::stdlib::nt::raw_set_handle_inheritable(fd as _, false)?;
+        Ok(fd)
+    }
+
+    #[pyfunction]
+    fn close(x: PyObjectRef, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
+        Ok(close_inner(get_raw_sock(x, vm)?)?)
+    }
+
+    fn close_inner(x: RawSocket) -> io::Result<()> {
+        #[cfg(unix)]
+        use libc::close;
+        #[cfg(windows)]
+        use windows_sys::Win32::Networking::WinSock::closesocket as close;
+        let ret = unsafe { close(x as _) };
+        if ret < 0 {
+            let err = std::io::Error::last_os_error();
+            if err.raw_os_error() != Some(errcode!(ECONNRESET)) {
+                return Err(err);
+            }
+        }
+        Ok(())
+    }
+
+    enum SocketError {
+        HError,
+        GaiError,
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    fn checked_cmsg_len(len: usize) -> Option<usize> {
+        // SAFETY: CMSG_LEN is always safe
+        let cmsg_len = |length| unsafe { libc::CMSG_LEN(length) };
+        if len as u64 > (i32::MAX as u64 - cmsg_len(0) as u64) {
+            return None;
+        }
+        let res = cmsg_len(len as _) as usize;
+        if res > i32::MAX as usize || res < len {
+            return None;
+        }
+        Some(res)
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    fn checked_cmsg_space(len: usize) -> Option<usize> {
+        // SAFETY: CMSG_SPACE is always safe
+        let cmsg_space = |length| unsafe { libc::CMSG_SPACE(length) };
+        if len as u64 > (i32::MAX as u64 - cmsg_space(1) as u64) {
+            return None;
+        }
+        let res = cmsg_space(len as _) as usize;
+        if res > i32::MAX as usize || res < len {
+            return None;
+        }
+        Some(res)
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction(name = "CMSG_LEN")]
+    fn cmsg_len(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
+        checked_cmsg_len(length)
+            .ok_or_else(|| vm.new_overflow_error("CMSG_LEN() argument out of range"))
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction(name = "CMSG_SPACE")]
+    fn cmsg_space(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
+        checked_cmsg_space(length)
+            .ok_or_else(|| vm.new_overflow_error("CMSG_SPACE() argument out of range"))
+    }
+}
diff --git a/stdlib/src/sqlite.rs b/crates/stdlib/src/sqlite.rs
similarity index 78%
rename from stdlib/src/sqlite.rs
rename to crates/stdlib/src/sqlite.rs
index cec1f04ed9..7e0392b1f3 100644
--- a/stdlib/src/sqlite.rs
+++ b/crates/stdlib/src/sqlite.rs
@@ -29,21 +29,21 @@ mod _sqlite {
         sqlite3_bind_null, sqlite3_bind_parameter_count, sqlite3_bind_parameter_name,
         sqlite3_bind_text, sqlite3_blob, sqlite3_blob_bytes, sqlite3_blob_close, sqlite3_blob_open,
         sqlite3_blob_read, sqlite3_blob_write, sqlite3_busy_timeout, sqlite3_changes,
-        sqlite3_close_v2, sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count,
-        sqlite3_column_decltype, sqlite3_column_double, sqlite3_column_int64, sqlite3_column_name,
-        sqlite3_column_text, sqlite3_column_type, sqlite3_complete, sqlite3_context,
-        sqlite3_context_db_handle, sqlite3_create_collation_v2, sqlite3_create_function_v2,
-        sqlite3_create_window_function, sqlite3_data_count, sqlite3_db_handle, sqlite3_errcode,
-        sqlite3_errmsg, sqlite3_exec, sqlite3_expanded_sql, sqlite3_extended_errcode,
-        sqlite3_finalize, sqlite3_get_autocommit, sqlite3_interrupt, sqlite3_last_insert_rowid,
-        sqlite3_libversion, sqlite3_limit, sqlite3_open_v2, sqlite3_prepare_v2,
-        sqlite3_progress_handler, sqlite3_reset, sqlite3_result_blob, sqlite3_result_double,
-        sqlite3_result_error, sqlite3_result_error_nomem, sqlite3_result_error_toobig,
-        sqlite3_result_int64, sqlite3_result_null, sqlite3_result_text, sqlite3_set_authorizer,
-        sqlite3_sleep, sqlite3_step, sqlite3_stmt, sqlite3_stmt_busy, sqlite3_stmt_readonly,
-        sqlite3_threadsafe, sqlite3_total_changes, sqlite3_trace_v2, sqlite3_user_data,
-        sqlite3_value, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double,
-        sqlite3_value_int64, sqlite3_value_text, sqlite3_value_type,
+        sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_count, sqlite3_column_decltype,
+        sqlite3_column_double, sqlite3_column_int64, sqlite3_column_name, sqlite3_column_text,
+        sqlite3_column_type, sqlite3_complete, sqlite3_context, sqlite3_context_db_handle,
+        sqlite3_create_collation_v2, sqlite3_create_function_v2, sqlite3_create_window_function,
+        sqlite3_data_count, sqlite3_db_handle, sqlite3_errcode, sqlite3_errmsg, sqlite3_exec,
+        sqlite3_expanded_sql, sqlite3_extended_errcode, sqlite3_finalize, sqlite3_get_autocommit,
+        sqlite3_interrupt, sqlite3_last_insert_rowid, sqlite3_libversion, sqlite3_limit,
+        sqlite3_open_v2, sqlite3_prepare_v2, sqlite3_progress_handler, sqlite3_reset,
+        sqlite3_result_blob, sqlite3_result_double, sqlite3_result_error,
+        sqlite3_result_error_nomem, sqlite3_result_error_toobig, sqlite3_result_int64,
+        sqlite3_result_null, sqlite3_result_text, sqlite3_set_authorizer, sqlite3_sleep,
+        sqlite3_step, sqlite3_stmt, sqlite3_stmt_busy, sqlite3_stmt_readonly, sqlite3_threadsafe,
+        sqlite3_total_changes, sqlite3_trace_v2, sqlite3_user_data, sqlite3_value,
+        sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double, sqlite3_value_int64,
+        sqlite3_value_text, sqlite3_value_type,
     };
     use malachite_bigint::Sign;
     use rustpython_common::{
@@ -59,15 +59,22 @@ mod _sqlite {
         builtins::{
             PyBaseException, PyBaseExceptionRef, PyByteArray, PyBytes, PyDict, PyDictRef, PyFloat,
             PyInt, PyIntRef, PySlice, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
+            PyUtf8Str, PyUtf8StrRef,
         },
         convert::IntoObject,
-        function::{ArgCallable, ArgIterable, FsPath, FuncArgs, OptionalArg, PyComparisonValue},
+        function::{
+            ArgCallable, ArgIterable, FsPath, FuncArgs, OptionalArg, PyComparisonValue,
+            PySetterValue,
+        },
         object::{Traverse, TraverseFn},
-        protocol::{PyBuffer, PyIterReturn, PyMappingMethods, PySequence, PySequenceMethods},
+        protocol::{
+            PyBuffer, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequence,
+            PySequenceMethods,
+        },
         sliceable::{SaturatedSliceIter, SliceableSequenceOp},
         types::{
-            AsMapping, AsSequence, Callable, Comparable, Constructor, Hashable, IterNext, Iterable,
-            PyComparisonOp, SelfIter,
+            AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,
+            Initializer, IterNext, Iterable, PyComparisonOp, SelfIter,
         },
         utils::ToCString,
     };
@@ -153,6 +160,8 @@ mod _sqlite {
     const PARSE_DECLTYPES: c_int = 1;
     #[pyattr]
     const PARSE_COLNAMES: c_int = 2;
+    #[pyattr]
+    const LEGACY_TRANSACTION_CONTROL: c_int = -1;
 
     #[pyattr]
     use libsqlite3_sys::{
@@ -293,6 +302,41 @@ mod _sqlite {
         SQLITE_IOERR_CORRUPTFS
     );
 
+    /// Autocommit mode setting for sqlite3 connections.
+    /// - Legacy (default): use isolation_level to control transactions
+    /// - Enabled: autocommit mode (no automatic transactions)
+    /// - Disabled: manual commit mode
+    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+    enum AutocommitMode {
+        #[default]
+        Legacy,
+        Enabled,
+        Disabled,
+    }
+
+    impl TryFromBorrowedObject<'_> for AutocommitMode {
+        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Self> {
+            if obj.is(&vm.ctx.true_value) {
+                Ok(Self::Enabled)
+            } else if obj.is(&vm.ctx.false_value) {
+                Ok(Self::Disabled)
+            } else if let Ok(val) = obj.try_to_value::<c_int>(vm) {
+                if val == LEGACY_TRANSACTION_CONTROL {
+                    Ok(Self::Legacy)
+                } else {
+                    Err(vm.new_value_error(format!(
+                        "autocommit must be True, False, or sqlite3.LEGACY_TRANSACTION_CONTROL, not {val}"
+                    )))
+                }
+            } else {
+                Err(vm.new_type_error(format!(
+                    "autocommit must be True, False, or sqlite3.LEGACY_TRANSACTION_CONTROL, not {}",
+                    obj.class().name()
+                )))
+            }
+        }
+    }
+
     #[derive(FromArgs)]
     struct ConnectArgs {
         #[pyarg(any)]
@@ -313,6 +357,8 @@ mod _sqlite {
         cached_statements: c_int,
         #[pyarg(any, default = false)]
         uri: bool,
+        #[pyarg(any, default)]
+        autocommit: AutocommitMode,
     }
 
     unsafe impl Traverse for ConnectArgs {
@@ -480,7 +526,7 @@ mod _sqlite {
                 let text2 = vm.ctx.new_str(text2);
 
                 let val = callable.call((text1, text2), vm)?;
-                let Some(val) = val.to_number().index(vm) else {
+                let Some(val) = val.number().index(vm) else {
                     return Ok(0);
                 };
 
@@ -535,7 +581,7 @@ mod _sqlite {
                 let access = ptr_to_str(access, vm)?;
 
                 let val = callable.call((action, arg1, arg2, db_name, access), vm)?;
-                let Some(val) = val.payload::<PyInt>() else {
+                let Some(val) = val.downcast_ref::<PyInt>() else {
                     return Ok(SQLITE_DENY);
                 };
                 val.try_to_primitive::<c_int>(vm)
@@ -563,10 +609,10 @@ mod _sqlite {
 
         unsafe extern "C" fn progress_callback(data: *mut c_void) -> c_int {
             let (callable, vm) = unsafe { (*data.cast::<Self>()).retrieve() };
-            if let Ok(val) = callable.call((), vm) {
-                if let Ok(val) = val.is_true(vm) {
-                    return val as c_int;
-                }
+            if let Ok(val) = callable.call((), vm)
+                && let Ok(val) = val.is_true(vm)
+            {
+                return val as c_int;
             }
             -1
         }
@@ -642,7 +688,9 @@ mod _sqlite {
 
     #[pyfunction]
     fn connect(args: ConnectArgs, vm: &VirtualMachine) -> PyResult {
-        Connection::py_new(args.factory.clone(), args, vm)
+        let factory = args.factory.clone();
+        let conn = Connection::py_new(&factory, args, vm)?;
+        conn.into_ref_with_type(vm, factory).map(Into::into)
     }
 
     #[pyfunction]
@@ -695,7 +743,11 @@ mod _sqlite {
         }
         if let Ok(adapter) = proto.get_attr("__adapt__", vm) {
             match adapter.call((obj,), vm) {
-                Ok(val) => return Ok(val),
+                Ok(val) => {
+                    if !vm.is_none(&val) {
+                        return Ok(val);
+                    }
+                }
                 Err(exc) => {
                     if !exc.fast_isinstance(vm.ctx.exceptions.type_error) {
                         return Err(exc);
@@ -705,7 +757,11 @@ mod _sqlite {
         }
         if let Ok(adapter) = obj.get_attr("__conform__", vm) {
             match adapter.call((proto,), vm) {
-                Ok(val) => return Ok(val),
+                Ok(val) => {
+                    if !vm.is_none(&val) {
+                        return Ok(val);
+                    }
+                }
                 Err(exc) => {
                     if !exc.fast_isinstance(vm.ctx.exceptions.type_error) {
                         return Err(exc);
@@ -724,7 +780,14 @@ mod _sqlite {
         alt: OptionalArg<PyObjectRef>,
         vm: &VirtualMachine,
     ) -> PyResult {
-        // TODO: None proto
+        if matches!(proto, OptionalArg::Present(None)) {
+            return if let OptionalArg::Present(alt) = alt {
+                Ok(alt)
+            } else {
+                Err(new_programming_error(vm, "can't adapt".to_owned()))
+            };
+        }
+
         let proto = proto
             .flatten()
             .unwrap_or_else(|| PrepareProtocol::class(&vm.ctx).to_owned());
@@ -810,16 +873,18 @@ mod _sqlite {
     #[derive(PyPayload)]
     struct Connection {
         db: PyMutex<Option<Sqlite>>,
-        detect_types: c_int,
+        initialized: PyAtomic<bool>,
+        detect_types: PyAtomic<c_int>,
         isolation_level: PyAtomicRef<Option<PyStr>>,
-        check_same_thread: bool,
-        thread_ident: ThreadId,
+        check_same_thread: PyAtomic<bool>,
+        thread_ident: PyMutex<ThreadId>, // TODO: Use atomic
         row_factory: PyAtomicRef<Option<PyObject>>,
         text_factory: PyAtomicRef<PyObject>,
+        autocommit: PyMutex<AutocommitMode>,
     }
 
     impl Debug for Connection {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
             write!(f, "Sqlite3 Connection")
         }
     }
@@ -827,16 +892,46 @@ mod _sqlite {
     impl Constructor for Connection {
         type Args = ConnectArgs;
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Ok(Self::new(args, vm)?.into_ref_with_type(vm, cls)?.into())
+        fn py_new(cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            let text_factory = PyStr::class(&vm.ctx).to_owned().into_object();
+
+            // For non-subclassed Connection, initialize in __new__
+            // For subclassed Connection, leave db as None and require __init__ to be called
+            let is_base_class = cls.is(Connection::class(&vm.ctx));
+
+            let db = if is_base_class {
+                // Initialize immediately for base class
+                Some(Connection::initialize_db(&args, vm)?)
+            } else {
+                // For subclasses, require __init__ to be called
+                None
+            };
+
+            let initialized = db.is_some();
+
+            Ok(Self {
+                db: PyMutex::new(db),
+                initialized: Radium::new(initialized),
+                detect_types: Radium::new(args.detect_types),
+                isolation_level: PyAtomicRef::from(args.isolation_level),
+                check_same_thread: Radium::new(args.check_same_thread),
+                thread_ident: PyMutex::new(std::thread::current().id()),
+                row_factory: PyAtomicRef::from(None),
+                text_factory: PyAtomicRef::from(text_factory),
+                autocommit: PyMutex::new(args.autocommit),
+            })
         }
     }
 
     impl Callable for Connection {
-        type Args = (PyStrRef,);
+        type Args = FuncArgs;
 
         fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            if let Some(stmt) = Statement::new(zelf, &args.0, vm)? {
+            let _ = zelf.db_lock(vm)?;
+
+            let (sql,): (PyUtf8StrRef,) = args.bind(vm)?;
+
+            if let Some(stmt) = Statement::new(zelf, sql, vm)? {
                 Ok(stmt.into_ref(&vm.ctx).into())
             } else {
                 Ok(vm.ctx.none())
@@ -844,9 +939,58 @@ mod _sqlite {
         }
     }
 
-    #[pyclass(with(Constructor, Callable), flags(BASETYPE))]
+    impl Initializer for Connection {
+        type Args = ConnectArgs;
+
+        fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+            let was_initialized = Radium::swap(&zelf.initialized, false, Ordering::AcqRel);
+
+            // Reset factories to their defaults, matching CPython's behavior.
+            zelf.reset_factories(vm);
+
+            if was_initialized {
+                zelf.drop_db();
+            }
+
+            // Attempt to open the new database before mutating other state so failures leave
+            // the connection uninitialized (and subsequent operations raise ProgrammingError).
+            let db = Self::initialize_db(&args, vm)?;
+
+            let ConnectArgs {
+                detect_types,
+                isolation_level,
+                check_same_thread,
+                autocommit,
+                ..
+            } = args;
+
+            zelf.detect_types.store(detect_types, Ordering::Relaxed);
+            zelf.check_same_thread
+                .store(check_same_thread, Ordering::Relaxed);
+            *zelf.autocommit.lock() = autocommit;
+            *zelf.thread_ident.lock() = std::thread::current().id();
+            let _ = unsafe { zelf.isolation_level.swap(isolation_level) };
+
+            let mut guard = zelf.db.lock();
+            *guard = Some(db);
+            Radium::store(&zelf.initialized, true, Ordering::Release);
+            Ok(())
+        }
+    }
+
+    #[pyclass(with(Constructor, Callable, Initializer), flags(BASETYPE))]
     impl Connection {
-        fn new(args: ConnectArgs, vm: &VirtualMachine) -> PyResult<Self> {
+        fn drop_db(&self) {
+            self.db.lock().take();
+        }
+
+        fn reset_factories(&self, vm: &VirtualMachine) {
+            let default_text_factory = PyStr::class(&vm.ctx).to_owned().into_object();
+            let _ = unsafe { self.row_factory.swap(None) };
+            let _ = unsafe { self.text_factory.swap(default_text_factory) };
+        }
+
+        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;
@@ -854,17 +998,7 @@ mod _sqlite {
             if let Some(isolation_level) = &args.isolation_level {
                 begin_statement_ptr_from_isolation_level(isolation_level, vm)?;
             }
-            let text_factory = PyStr::class(&vm.ctx).to_owned().into_object();
-
-            Ok(Self {
-                db: PyMutex::new(Some(db)),
-                detect_types: args.detect_types,
-                isolation_level: PyAtomicRef::from(args.isolation_level),
-                check_same_thread: args.check_same_thread,
-                thread_ident: std::thread::current().id(),
-                row_factory: PyAtomicRef::from(None),
-                text_factory: PyAtomicRef::from(text_factory),
-            })
+            Ok(db)
         }
 
         fn db_lock(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, Sqlite>> {
@@ -881,7 +1015,7 @@ mod _sqlite {
             } else {
                 Err(new_programming_error(
                     vm,
-                    "Cannot operate on a closed database.".to_owned(),
+                    "Base Connection.__init__ not called.".to_owned(),
                 ))
             }
         }
@@ -946,10 +1080,14 @@ mod _sqlite {
         #[pymethod]
         fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
             self.check_thread(vm)?;
-            self.db.lock().take();
+            self.drop_db();
             Ok(())
         }
 
+        fn is_closed(&self) -> bool {
+            self.db.lock().is_none()
+        }
+
         #[pymethod]
         fn commit(&self, vm: &VirtualMachine) -> PyResult<()> {
             self.db_lock(vm)?.implicit_commit(vm)
@@ -968,7 +1106,7 @@ mod _sqlite {
         #[pymethod]
         fn execute(
             zelf: PyRef<Self>,
-            sql: PyStrRef,
+            sql: PyUtf8StrRef,
             parameters: OptionalArg<PyObjectRef>,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Cursor>> {
@@ -980,7 +1118,7 @@ mod _sqlite {
         #[pymethod]
         fn executemany(
             zelf: PyRef<Self>,
-            sql: PyStrRef,
+            sql: PyUtf8StrRef,
             seq_of_params: ArgIterable,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Cursor>> {
@@ -992,7 +1130,7 @@ mod _sqlite {
         #[pymethod]
         fn executescript(
             zelf: PyRef<Self>,
-            script: PyStrRef,
+            script: PyUtf8StrRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Cursor>> {
             let row_factory = zelf.row_factory.to_owned();
@@ -1141,7 +1279,7 @@ mod _sqlite {
         #[pymethod]
         fn create_collation(
             &self,
-            name: PyStrRef,
+            name: PyUtf8StrRef,
             callable: PyObjectRef,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
@@ -1253,14 +1391,14 @@ mod _sqlite {
         fn set_trace_callback(&self, callable: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             let db = self.db_lock(vm)?;
             let Some(data) = CallbackData::new(callable, vm) else {
-                unsafe { sqlite3_trace_v2(db.db, SQLITE_TRACE_STMT as u32, None, null_mut()) };
+                unsafe { sqlite3_trace_v2(db.db, SQLITE_TRACE_STMT, None, null_mut()) };
                 return Ok(());
             };
 
             let ret = unsafe {
                 sqlite3_trace_v2(
                     db.db,
-                    SQLITE_TRACE_STMT as u32,
+                    SQLITE_TRACE_STMT,
                     Some(CallbackData::trace_callback),
                     Box::into_raw(Box::new(data)).cast(),
                 )
@@ -1342,21 +1480,68 @@ mod _sqlite {
             self.isolation_level.deref().map(|x| x.to_owned())
         }
         #[pygetset(setter)]
-        fn set_isolation_level(&self, val: Option<PyStrRef>, vm: &VirtualMachine) -> PyResult<()> {
-            if let Some(val) = &val {
-                begin_statement_ptr_from_isolation_level(val, vm)?;
+        fn set_isolation_level(
+            &self,
+            value: PySetterValue<Option<PyStrRef>>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            match value {
+                PySetterValue::Assign(value) => {
+                    if let Some(val_str) = &value {
+                        begin_statement_ptr_from_isolation_level(val_str, vm)?;
+                    }
+
+                    // If setting isolation_level to None (auto-commit mode), commit any pending transaction
+                    if value.is_none() {
+                        let db = self.db_lock(vm)?;
+                        if !db.is_autocommit() {
+                            // Keep the lock and call implicit_commit directly to avoid race conditions
+                            db.implicit_commit(vm)?;
+                        }
+                    }
+                    let _ = unsafe { self.isolation_level.swap(value) };
+                    Ok(())
+                }
+                PySetterValue::Delete => Err(vm.new_attribute_error(
+                    "'isolation_level' attribute cannot be deleted".to_owned(),
+                )),
             }
+        }
 
-            // If setting isolation_level to None (auto-commit mode), commit any pending transaction
-            if val.is_none() {
-                let db = self.db_lock(vm)?;
-                if !db.is_autocommit() {
-                    // Keep the lock and call implicit_commit directly to avoid race conditions
-                    db.implicit_commit(vm)?;
+        #[pygetset]
+        fn autocommit(&self, vm: &VirtualMachine) -> PyObjectRef {
+            match *self.autocommit.lock() {
+                AutocommitMode::Enabled => vm.ctx.true_value.clone().into(),
+                AutocommitMode::Disabled => vm.ctx.false_value.clone().into(),
+                AutocommitMode::Legacy => vm.ctx.new_int(LEGACY_TRANSACTION_CONTROL).into(),
+            }
+        }
+        #[pygetset(setter)]
+        fn set_autocommit(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mode = AutocommitMode::try_from_borrowed_object(vm, &val)?;
+            let db = self.db_lock(vm)?;
+
+            // Handle transaction state based on mode change
+            match mode {
+                AutocommitMode::Enabled => {
+                    // If there's a pending transaction, commit it
+                    if !db.is_autocommit() {
+                        db._exec(b"COMMIT", vm)?;
+                    }
+                }
+                AutocommitMode::Disabled => {
+                    // If not in a transaction, begin one
+                    if db.is_autocommit() {
+                        db._exec(b"BEGIN", vm)?;
+                    }
+                }
+                AutocommitMode::Legacy => {
+                    // Legacy mode doesn't change transaction state
                 }
             }
 
-            let _ = unsafe { self.isolation_level.swap(val) };
+            drop(db);
+            *self.autocommit.lock() = mode;
             Ok(())
         }
 
@@ -1379,15 +1564,17 @@ mod _sqlite {
         }
 
         fn check_thread(&self, vm: &VirtualMachine) -> PyResult<()> {
-            if self.check_same_thread && (std::thread::current().id() != self.thread_ident) {
-                Err(new_programming_error(
-                    vm,
-                    "SQLite objects created in a thread can only be used in that same thread."
-                        .to_owned(),
-                ))
-            } else {
-                Ok(())
+            if self.check_same_thread.load(Ordering::Relaxed) {
+                let creator_id = *self.thread_ident.lock();
+                if std::thread::current().id() != creator_id {
+                    return Err(new_programming_error(
+                        vm,
+                        "SQLite objects created in a thread can only be used in that same thread."
+                            .to_owned(),
+                    ));
+                }
             }
+            Ok(())
         }
 
         #[pygetset]
@@ -1422,9 +1609,17 @@ mod _sqlite {
         #[pytraverse(skip)]
         rowcount: i64,
         statement: Option<PyRef<Statement>>,
+        #[pytraverse(skip)]
+        closed: bool,
     }
 
-    #[pyclass(with(Constructor, IterNext, Iterable), flags(BASETYPE))]
+    #[derive(FromArgs)]
+    struct FetchManyArgs {
+        #[pyarg(any, name = "size", optional)]
+        size: Option<c_int>,
+    }
+
+    #[pyclass(with(Constructor, Initializer, IterNext, Iterable), flags(BASETYPE))]
     impl Cursor {
         fn new(
             connection: PyRef<Connection>,
@@ -1441,28 +1636,53 @@ mod _sqlite {
                     lastrowid: -1,
                     rowcount: -1,
                     statement: None,
+                    closed: false,
                 })),
             }
         }
 
-        fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, CursorInner>> {
-            let guard = self.inner.lock();
-            if guard.is_some() {
-                Ok(PyMutexGuard::map(guard, |x| unsafe {
-                    x.as_mut().unwrap_unchecked()
-                }))
-            } else {
-                Err(new_programming_error(
+        fn new_uninitialized(connection: PyRef<Connection>, _vm: &VirtualMachine) -> Self {
+            Self {
+                connection,
+                arraysize: Radium::new(1),
+                row_factory: PyAtomicRef::from(None),
+                inner: PyMutex::from(None),
+            }
+        }
+
+        fn check_cursor_state(inner: Option<&CursorInner>, vm: &VirtualMachine) -> PyResult<()> {
+            match inner {
+                Some(inner) if inner.closed => Err(new_programming_error(
                     vm,
                     "Cannot operate on a closed cursor.".to_owned(),
-                ))
+                )),
+                Some(_) => Ok(()),
+                None => Err(new_programming_error(
+                    vm,
+                    "Base Cursor.__init__ not called.".to_owned(),
+                )),
             }
         }
 
+        fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, CursorInner>> {
+            let guard = self.inner.lock();
+            Self::check_cursor_state(guard.as_ref(), vm)?;
+            Ok(PyMutexGuard::map(guard, |x| unsafe {
+                x.as_mut().unwrap_unchecked()
+            }))
+        }
+
+        /// Check if cursor is valid without retaining the lock.
+        /// Use this when you only need to verify the cursor state but don't need to modify it.
+        fn check_cursor_valid(&self, vm: &VirtualMachine) -> PyResult<()> {
+            let guard = self.inner.lock();
+            Self::check_cursor_state(guard.as_ref(), vm)
+        }
+
         #[pymethod]
         fn execute(
             zelf: PyRef<Self>,
-            sql: PyStrRef,
+            sql: PyUtf8StrRef,
             parameters: OptionalArg<PyObjectRef>,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Self>> {
@@ -1472,7 +1692,7 @@ mod _sqlite {
                 stmt.lock().reset();
             }
 
-            let Some(stmt) = Statement::new(&zelf.connection, &sql, vm)? else {
+            let Some(stmt) = Statement::new(&zelf.connection, sql, vm)? else {
                 drop(inner);
                 return Ok(zelf);
             };
@@ -1482,9 +1702,11 @@ mod _sqlite {
 
             let db = zelf.connection.db_lock(vm)?;
 
+            // Start implicit transaction for DML statements unless in autocommit mode
             if stmt.is_dml
                 && db.is_autocommit()
                 && zelf.connection.isolation_level.deref().is_some()
+                && *zelf.connection.autocommit.lock() != AutocommitMode::Enabled
             {
                 db.begin_transaction(
                     zelf.connection
@@ -1496,8 +1718,16 @@ mod _sqlite {
             }
 
             let st = stmt.lock();
+            let params_needed = st.bind_parameter_count();
+
             if let OptionalArg::Present(parameters) = parameters {
                 st.bind_parameters(&parameters, vm)?;
+            } else if params_needed > 0 {
+                let msg = format!(
+                    "Incorrect number of bindings supplied. The current statement uses {}, and 0 were supplied.",
+                    params_needed
+                );
+                return Err(new_programming_error(vm, msg));
             }
 
             let ret = st.step();
@@ -1511,7 +1741,8 @@ mod _sqlite {
 
             inner.row_cast_map = zelf.build_row_cast_map(&st, vm)?;
 
-            inner.description = st.columns_description(zelf.connection.detect_types, vm)?;
+            let detect_types = zelf.connection.detect_types.load(Ordering::Relaxed);
+            inner.description = st.columns_description(detect_types, vm)?;
 
             if ret == SQLITE_ROW {
                 drop(st);
@@ -1534,7 +1765,7 @@ mod _sqlite {
         #[pymethod]
         fn executemany(
             zelf: PyRef<Self>,
-            sql: PyStrRef,
+            sql: PyUtf8StrRef,
             seq_of_params: ArgIterable,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Self>> {
@@ -1544,7 +1775,7 @@ mod _sqlite {
                 stmt.lock().reset();
             }
 
-            let Some(stmt) = Statement::new(&zelf.connection, &sql, vm)? else {
+            let Some(stmt) = Statement::new(&zelf.connection, sql, vm)? else {
                 drop(inner);
                 return Ok(zelf);
             };
@@ -1559,15 +1790,18 @@ mod _sqlite {
                 ));
             }
 
-            inner.description = st.columns_description(zelf.connection.detect_types, vm)?;
+            let detect_types = zelf.connection.detect_types.load(Ordering::Relaxed);
+            inner.description = st.columns_description(detect_types, vm)?;
 
             inner.rowcount = if stmt.is_dml { 0 } else { -1 };
 
             let db = zelf.connection.db_lock(vm)?;
 
+            // Start implicit transaction for DML statements unless in autocommit mode
             if stmt.is_dml
                 && db.is_autocommit()
                 && zelf.connection.isolation_level.deref().is_some()
+                && *zelf.connection.autocommit.lock() != AutocommitMode::Enabled
             {
                 db.begin_transaction(
                     zelf.connection
@@ -1608,9 +1842,11 @@ mod _sqlite {
         #[pymethod]
         fn executescript(
             zelf: PyRef<Self>,
-            script: PyStrRef,
+            script: PyUtf8StrRef,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<Self>> {
+            zelf.check_cursor_valid(vm)?;
+
             let db = zelf.connection.db_lock(vm)?;
 
             db.sql_limit(script.byte_len(), vm)?;
@@ -1639,14 +1875,17 @@ mod _sqlite {
         #[pymethod]
         fn fetchmany(
             zelf: &Py<Self>,
-            max_rows: OptionalArg<c_int>,
+            args: FetchManyArgs,
             vm: &VirtualMachine,
         ) -> PyResult<Vec<PyObjectRef>> {
-            let max_rows = max_rows.unwrap_or_else(|| zelf.arraysize.load(Ordering::Relaxed));
+            let max_rows = args
+                .size
+                .unwrap_or_else(|| zelf.arraysize.load(Ordering::Relaxed));
+
             let mut list = vec![];
-            while let PyIterReturn::Return(row) = Self::next(zelf, vm)? {
+            while let PyIterReturn::Return(row) = Cursor::next(zelf, vm)? {
                 list.push(row);
-                if list.len() as c_int >= max_rows {
+                if max_rows > 0 && list.len() as c_int >= max_rows {
                     break;
                 }
             }
@@ -1663,12 +1902,23 @@ mod _sqlite {
         }
 
         #[pymethod]
-        fn close(&self) {
-            if let Some(inner) = self.inner.lock().take() {
-                if let Some(stmt) = inner.statement {
-                    stmt.lock().reset();
-                }
+        fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Check if __init__ was called
+            let mut guard = self.inner.lock();
+
+            let Some(inner) = guard.as_mut() else {
+                return Err(new_programming_error(
+                    vm,
+                    "Base Cursor.__init__ not called.".to_owned(),
+                ));
+            };
+
+            if let Some(stmt) = &inner.statement {
+                stmt.lock().reset();
             }
+            inner.closed = true;
+
+            Ok(())
         }
 
         #[pymethod]
@@ -1710,7 +1960,8 @@ mod _sqlite {
             st: &SqliteStatementRaw,
             vm: &VirtualMachine,
         ) -> PyResult<Vec<Option<PyObjectRef>>> {
-            if self.connection.detect_types == 0 {
+            let detect_types = self.connection.detect_types.load(Ordering::Relaxed);
+            if detect_types == 0 {
                 return Ok(vec![]);
             }
 
@@ -1718,7 +1969,7 @@ mod _sqlite {
             let num_cols = st.column_count();
 
             for i in 0..num_cols {
-                if self.connection.detect_types & PARSE_COLNAMES != 0 {
+                if detect_types & PARSE_COLNAMES != 0 {
                     let col_name = st.column_name(i);
                     let col_name = ptr_to_str(col_name, vm)?;
                     let col_name = col_name
@@ -1733,7 +1984,7 @@ mod _sqlite {
                         continue;
                     }
                 }
-                if self.connection.detect_types & PARSE_DECLTYPES != 0 {
+                if detect_types & PARSE_DECLTYPES != 0 {
                     let decltype = st.column_decltype(i);
                     let decltype = ptr_to_str(decltype, vm)?;
                     if let Some(decltype) = decltype.split_terminator(&[' ', '(']).next() {
@@ -1754,16 +2005,51 @@ mod _sqlite {
     impl Constructor for Cursor {
         type Args = (PyRef<Connection>,);
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self::new(args.0, None, vm)
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+        fn py_new(
+            _cls: &Py<PyType>,
+            (connection,): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self::new_uninitialized(connection, vm))
+        }
+    }
+
+    impl Initializer for Cursor {
+        type Args = PyRef<Connection>;
+
+        fn init(zelf: PyRef<Self>, _connection: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            let mut guard = zelf.inner.lock();
+            if guard.is_some() {
+                // Already initialized (e.g., from a call to super().__init__)
+                return Ok(());
+            }
+            *guard = Some(CursorInner {
+                description: None,
+                row_cast_map: vec![],
+                lastrowid: -1,
+                rowcount: -1,
+                statement: None,
+                closed: false,
+            });
+            Ok(())
         }
     }
 
     impl SelfIter for Cursor {}
     impl IterNext for Cursor {
         fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            // Check if connection is closed first, and if so, clear statement to release file lock
+            if zelf.connection.is_closed() {
+                let mut guard = zelf.inner.lock();
+                if let Some(stmt) = guard.as_mut().and_then(|inner| inner.statement.take()) {
+                    stmt.lock().reset();
+                }
+                return Err(new_programming_error(
+                    vm,
+                    "Cannot operate on a closed database.".to_owned(),
+                ));
+            }
+
             let mut inner = zelf.inner(vm)?;
             let Some(stmt) = &inner.statement else {
                 return Ok(PyIterReturn::StopIteration(None));
@@ -1804,8 +2090,15 @@ mod _sqlite {
                             let text_factory = zelf.connection.text_factory.to_owned();
 
                             if text_factory.is(PyStr::class(&vm.ctx)) {
-                                let text = String::from_utf8(text).map_err(|_| {
-                                    new_operational_error(vm, "not valid UTF-8".to_owned())
+                                let text = String::from_utf8(text).map_err(|err| {
+                                    let col_name = st.column_name(i);
+                                    let col_name_str = ptr_to_str(col_name, vm).unwrap_or("?");
+                                    let valid_up_to = err.utf8_error().valid_up_to();
+                                    let text_prefix = String::from_utf8_lossy(&err.as_bytes()[..valid_up_to]);
+                                    let msg = format!(
+                                        "Could not decode to UTF-8 column '{col_name_str}' with text '{text_prefix}'"
+                                    );
+                                    new_operational_error(vm, msg)
                                 })?;
                                 vm.ctx.new_str(text).into()
                             } else if text_factory.is(PyBytes::class(&vm.ctx)) {
@@ -1882,18 +2175,18 @@ mod _sqlite {
             Ok(self
                 .description
                 .iter()
-                .map(|x| x.payload::<PyTuple>().unwrap().as_slice()[0].clone())
+                .map(|x| x.downcast_ref::<PyTuple>().unwrap().as_slice()[0].clone())
                 .collect())
         }
 
         fn subscript(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
-            if let Some(i) = needle.payload::<PyInt>() {
+            if let Some(i) = needle.downcast_ref::<PyInt>() {
                 let i = i.try_to_primitive::<isize>(vm)?;
                 self.data.getitem_by_index(vm, i)
-            } else if let Some(name) = needle.payload::<PyStr>() {
+            } else if let Some(name) = needle.downcast_ref::<PyStr>() {
                 for (obj, i) in self.description.iter().zip(0..) {
-                    let obj = &obj.payload::<PyTuple>().unwrap().as_slice()[0];
-                    let Some(obj) = obj.payload::<PyStr>() else {
+                    let obj = &obj.downcast_ref::<PyTuple>().unwrap().as_slice()[0];
+                    let Some(obj) = obj.downcast_ref::<PyStr>() else {
                         break;
                     };
                     let a_iter = name.as_str().chars().flat_map(|x| x.to_uppercase());
@@ -1904,7 +2197,7 @@ mod _sqlite {
                     }
                 }
                 Err(vm.new_index_error("No item with that key"))
-            } else if let Some(slice) = needle.payload::<PySlice>() {
+            } else if let Some(slice) = needle.downcast_ref::<PySlice>() {
                 let list = self.data.getitem_by_slice(vm, slice.to_saturated(vm)?)?;
                 Ok(vm.ctx.new_tuple(list).into())
             } else {
@@ -1916,20 +2209,18 @@ mod _sqlite {
     impl Constructor for Row {
         type Args = (PyRef<Cursor>, PyTupleRef);
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let description = args
-                .0
+        fn py_new(
+            _cls: &Py<PyType>,
+            (cursor, data): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            let description = cursor
                 .inner(vm)?
                 .description
                 .clone()
                 .ok_or_else(|| vm.new_value_error("no description in Cursor"))?;
 
-            Self {
-                data: args.1,
-                description,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            Ok(Self { data, description })
         }
     }
 
@@ -1947,7 +2238,7 @@ mod _sqlite {
             vm: &VirtualMachine,
         ) -> PyResult<PyComparisonValue> {
             op.eq_only(|| {
-                if let Some(other) = other.payload::<Self>() {
+                if let Some(other) = other.downcast_ref::<Self>() {
                     let eq = vm
                         .bool_eq(zelf.description.as_object(), other.description.as_object())?
                         && vm.bool_eq(zelf.data.as_object(), other.data.as_object())?;
@@ -1996,7 +2287,7 @@ mod _sqlite {
     }
 
     #[pyattr]
-    #[pyclass(name, traverse)]
+    #[pyclass(module = "sqlite3", name = "Blob", traverse)]
     #[derive(Debug, PyPayload)]
     struct Blob {
         connection: PyRef<Connection>,
@@ -2016,19 +2307,32 @@ mod _sqlite {
         }
     }
 
-    #[pyclass(with(AsMapping))]
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(AsMapping, AsNumber, AsSequence))]
     impl Blob {
         #[pymethod]
         fn close(&self) {
             self.inner.lock().take();
         }
 
+        fn ensure_connection_open(&self, vm: &VirtualMachine) -> PyResult<()> {
+            if self.connection.is_closed() {
+                Err(new_programming_error(
+                    vm,
+                    "Cannot operate on a closed database".to_owned(),
+                ))
+            } else {
+                Ok(())
+            }
+        }
+
         #[pymethod]
         fn read(
             &self,
             length: OptionalArg<c_int>,
             vm: &VirtualMachine,
         ) -> PyResult<PyRef<PyBytes>> {
+            self.ensure_connection_open(vm)?;
+
             let mut length = length.unwrap_or(-1);
             let mut inner = self.inner(vm)?;
             let blob_len = inner.blob.bytes();
@@ -2054,6 +2358,7 @@ mod _sqlite {
 
         #[pymethod]
         fn write(&self, data: PyBuffer, vm: &VirtualMachine) -> PyResult<()> {
+            self.ensure_connection_open(vm)?;
             let mut inner = self.inner(vm)?;
             let blob_len = inner.blob.bytes();
             let length = Self::expect_write(blob_len, data.desc.len, inner.offset, vm)?;
@@ -2069,6 +2374,7 @@ mod _sqlite {
 
         #[pymethod]
         fn tell(&self, vm: &VirtualMachine) -> PyResult<c_int> {
+            self.ensure_connection_open(vm)?;
             self.inner(vm).map(|x| x.offset)
         }
 
@@ -2079,6 +2385,7 @@ mod _sqlite {
             origin: OptionalArg<c_int>,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
+            self.ensure_connection_open(vm)?;
             let origin = origin.unwrap_or(libc::SEEK_SET);
             let mut inner = self.inner(vm)?;
             let blob_len = inner.blob.bytes();
@@ -2107,13 +2414,18 @@ mod _sqlite {
         }
 
         #[pymethod]
-        fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
-            zelf
+        fn __enter__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            zelf.ensure_connection_open(vm)?;
+            let _ = zelf.inner(vm)?;
+            Ok(zelf)
         }
 
         #[pymethod]
-        fn __exit__(&self, _args: FuncArgs) {
-            self.close()
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.ensure_connection_open(vm)?;
+            let _ = self.inner(vm)?;
+            self.close();
+            Ok(())
         }
 
         fn inner(&self, vm: &VirtualMachine) -> PyResult<PyMappedMutexGuard<'_, BlobInner>> {
@@ -2157,6 +2469,7 @@ mod _sqlite {
         }
 
         fn subscript(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
+            self.ensure_connection_open(vm)?;
             let inner = self.inner(vm)?;
             if let Some(index) = needle.try_index_opt(vm) {
                 let blob_len = inner.blob.bytes();
@@ -2164,7 +2477,7 @@ mod _sqlite {
                 let mut byte: u8 = 0;
                 let ret = inner.blob.read_single(&mut byte, index);
                 self.check(ret, vm).map(|_| vm.ctx.new_int(byte).into())
-            } else if let Some(slice) = needle.payload::<PySlice>() {
+            } else if let Some(slice) = needle.downcast_ref::<PySlice>() {
                 let blob_len = inner.blob.bytes();
                 let slice = slice.to_saturated(vm)?;
                 let (range, step, length) = slice.adjust_indices(blob_len as usize);
@@ -2200,12 +2513,14 @@ mod _sqlite {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             let Some(value) = value else {
-                return Err(vm.new_type_error("Blob doesn't support deletion"));
+                return Err(vm.new_type_error("Blob doesn't support slice deletion"));
             };
+            self.ensure_connection_open(vm)?;
             let inner = self.inner(vm)?;
 
             if let Some(index) = needle.try_index_opt(vm) {
-                let Some(value) = value.payload::<PyInt>() else {
+                // Handle single item assignment: blob[i] = b
+                let Some(value) = value.downcast_ref::<PyInt>() else {
                     return Err(vm.new_type_error(format!(
                         "'{}' object cannot be interpreted as an integer",
                         value.class()
@@ -2217,11 +2532,61 @@ mod _sqlite {
                 Self::expect_write(blob_len, 1, index, vm)?;
                 let ret = inner.blob.write_single(value, index);
                 self.check(ret, vm)
-            } else if let Some(_slice) = needle.payload::<PySlice>() {
-                Err(vm.new_not_implemented_error("Blob slice assignment is not implemented"))
-                // let blob_len = inner.blob.bytes();
-                // let slice = slice.to_saturated(vm)?;
-                // let (range, step, length) = slice.adjust_indices(blob_len as usize);
+            } else if let Some(slice) = needle.downcast_ref::<PySlice>() {
+                // Handle slice assignment: blob[a:b:c] = b"..."
+                let value_buf = PyBuffer::try_from_borrowed_object(vm, &value)?;
+
+                let buf = value_buf
+                    .as_contiguous()
+                    .ok_or_else(|| vm.new_buffer_error("underlying buffer is not C-contiguous"))?;
+
+                let blob_len = inner.blob.bytes();
+                let slice = slice.to_saturated(vm)?;
+                let (range, step, slice_len) = slice.adjust_indices(blob_len as usize);
+
+                if step == 0 {
+                    return Err(vm.new_value_error("slice step cannot be zero"));
+                }
+
+                if buf.len() != slice_len {
+                    return Err(vm.new_index_error("Blob slice assignment is wrong size"));
+                }
+
+                if slice_len == 0 {
+                    return Ok(());
+                }
+
+                if step == 1 {
+                    let ret = inner.blob.write(
+                        buf.as_ptr().cast(),
+                        buf.len() as c_int,
+                        range.start as c_int,
+                    );
+                    self.check(ret, vm)
+                } else {
+                    let span_len = range.end - range.start;
+                    let mut temp_buf = vec![0u8; span_len];
+
+                    let ret = inner.blob.read(
+                        temp_buf.as_mut_ptr().cast(),
+                        span_len as c_int,
+                        range.start as c_int,
+                    );
+                    self.check(ret, vm)?;
+
+                    let mut i_in_temp: usize = 0;
+                    for i_in_src in 0..slice_len {
+                        temp_buf[i_in_temp] = buf[i_in_src];
+                        i_in_temp += step as usize;
+                    }
+
+                    let ret = inner.blob.write(
+                        temp_buf.as_ptr().cast(),
+                        span_len as c_int,
+                        range.start as c_int,
+                    );
+                    self.check(ret, vm)
+                }
             } else {
                 Err(vm.new_type_error("Blob indices must be integers"))
             }
@@ -2253,6 +2618,50 @@ mod _sqlite {
         }
     }
 
+    impl AsNumber for Blob {
+        fn as_number() -> &'static PyNumberMethods {
+            static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+                add: Some(|a, b, vm| {
+                    Err(vm.new_type_error(format!(
+                        "unsupported operand type(s) for +: '{}' and '{}'",
+                        a.class().name(),
+                        b.class().name()
+                    )))
+                }),
+                multiply: Some(|a, b, vm| {
+                    Err(vm.new_type_error(format!(
+                        "unsupported operand type(s) for *: '{}' and '{}'",
+                        a.class().name(),
+                        b.class().name()
+                    )))
+                }),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
+    impl AsSequence for Blob {
+        fn as_sequence() -> &'static PySequenceMethods {
+            static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
+                length: None,
+                concat: None,
+                repeat: None,
+                item: None,
+                ass_item: None,
+                contains: atomic_func!(|seq, _needle, vm| {
+                    Err(vm.new_type_error(format!(
+                        "argument of type '{}' is not iterable",
+                        seq.obj.class().name(),
+                    )))
+                }),
+                inplace_concat: None,
+                inplace_repeat: None,
+            };
+            &AS_SEQUENCE
+        }
+    }
+
     #[pyattr]
     #[pyclass(name)]
     #[derive(Debug, PyPayload)]
@@ -2262,7 +2671,7 @@ mod _sqlite {
     impl PrepareProtocol {}
 
     #[pyattr]
-    #[pyclass(name)]
+    #[pyclass(module = "sqlite3", name = "Statement")]
     #[derive(PyPayload)]
     struct Statement {
         st: PyMutex<SqliteStatement>,
@@ -2270,7 +2679,7 @@ mod _sqlite {
     }
 
     impl Debug for Statement {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
             write!(
                 f,
                 "{} Statement",
@@ -2279,19 +2688,24 @@ mod _sqlite {
         }
     }
 
-    #[pyclass()]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Statement {
         fn new(
             connection: &Connection,
-            sql: &PyStr,
+            sql: PyUtf8StrRef,
             vm: &VirtualMachine,
         ) -> PyResult<Option<Self>> {
+            if sql.as_str().contains('\0') {
+                return Err(new_programming_error(
+                    vm,
+                    "statement contains a null character.".to_owned(),
+                ));
+            }
             let sql_cstr = sql.to_cstring(vm)?;
-            let sql_len = sql.byte_len() + 1;
 
             let db = connection.db_lock(vm)?;
 
-            db.sql_limit(sql_len, vm)?;
+            db.sql_limit(sql.byte_len(), vm)?;
 
             let mut tail = null();
             let st = db.prepare(sql_cstr.as_ptr(), &mut tail, vm)?;
@@ -2340,8 +2754,16 @@ mod _sqlite {
         }
     }
 
+    // sqlite3_close_v2 is not exported by libsqlite3-sys, so we declare it manually.
+    // It handles "zombie close" - if there are still unfinalized statements,
+    // the database will be closed when the last statement is finalized.
+    unsafe extern "C" {
+        fn sqlite3_close_v2(db: *mut sqlite3) -> c_int;
+    }
+
     impl Drop for Sqlite {
         fn drop(&mut self) {
+            // Use sqlite3_close_v2 for safe closing even with active statements
             unsafe { sqlite3_close_v2(self.raw.db) };
         }
     }
@@ -2624,15 +3046,16 @@ mod _sqlite {
 
             let ret = if vm.is_none(obj) {
                 unsafe { sqlite3_bind_null(self.st, pos) }
-            } else if let Some(val) = obj.payload::<PyInt>() {
+            } else if let Some(val) = obj.downcast_ref::<PyInt>() {
                 let val = val.try_to_primitive::<i64>(vm).map_err(|_| {
                     vm.new_overflow_error("Python int too large to convert to SQLite INTEGER")
                 })?;
                 unsafe { sqlite3_bind_int64(self.st, pos, val) }
-            } else if let Some(val) = obj.payload::<PyFloat>() {
+            } else if let Some(val) = obj.downcast_ref::<PyFloat>() {
                 let val = val.to_f64();
                 unsafe { sqlite3_bind_double(self.st, pos, val) }
-            } else if let Some(val) = obj.payload::<PyStr>() {
+            } else if let Some(val) = obj.downcast_ref::<PyStr>() {
+                let val = val.try_as_utf8(vm)?;
                 let (ptr, len) = str_to_ptr_len(val, vm)?;
                 unsafe { sqlite3_bind_text(self.st, pos, ptr, len, SQLITE_TRANSIENT()) }
             } else if let Ok(buffer) = PyBuffer::try_from_borrowed_object(vm, obj) {
@@ -2660,7 +3083,7 @@ mod _sqlite {
         fn bind_parameters(self, parameters: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
             if let Some(dict) = parameters.downcast_ref::<PyDict>() {
                 self.bind_parameters_name(dict, vm)
-            } else if let Ok(seq) = PySequence::try_protocol(parameters, vm) {
+            } else if let Ok(seq) = parameters.try_sequence(vm) {
                 self.bind_parameters_sequence(seq, vm)
             } else {
                 Err(new_programming_error(
@@ -2681,23 +3104,40 @@ mod _sqlite {
                 let name = unsafe { name.add(1) };
                 let name = ptr_to_str(name, vm)?;
 
-                let val = dict.get_item(name, vm)?;
+                let val = match dict.get_item_opt(name, vm)? {
+                    Some(val) => val,
+                    None => {
+                        return Err(new_programming_error(
+                            vm,
+                            format!("You did not supply a value for binding parameter :{name}.",),
+                        ));
+                    }
+                };
 
                 self.bind_parameter(i, &val, vm)?;
             }
             Ok(())
         }
 
+        fn bind_parameter_count(self) -> c_int {
+            unsafe { sqlite3_bind_parameter_count(self.st) }
+        }
+
         fn bind_parameters_sequence(
             self,
             seq: PySequence<'_>,
             vm: &VirtualMachine,
         ) -> PyResult<()> {
-            let num_needed = unsafe { sqlite3_bind_parameter_count(self.st) };
-            if seq.length(vm)? != num_needed as usize {
+            let num_needed = self.bind_parameter_count();
+            let num_supplied = seq.length(vm)?;
+
+            if num_supplied != num_needed as usize {
                 return Err(new_programming_error(
                     vm,
-                    "Incorrect number of binding supplied".to_owned(),
+                    format!(
+                        "Incorrect number of bindings supplied. The current statement uses {}, and {} were supplied.",
+                        num_needed, num_supplied
+                    ),
                 ));
             }
 
@@ -2855,7 +3295,9 @@ mod _sqlite {
         }
 
         fn aggregate_context<T>(self) -> *mut T {
-            unsafe { sqlite3_aggregate_context(self.ctx, std::mem::size_of::<T>() as c_int).cast() }
+            unsafe {
+                sqlite3_aggregate_context(self.ctx, core::mem::size_of::<T>() as c_int).cast()
+            }
         }
 
         fn result_exception(self, vm: &VirtualMachine, exc: PyBaseExceptionRef, msg: &str) {
@@ -2879,11 +3321,12 @@ mod _sqlite {
             unsafe {
                 if vm.is_none(val) {
                     sqlite3_result_null(self.ctx)
-                } else if let Some(val) = val.payload::<PyInt>() {
+                } else if let Some(val) = val.downcast_ref::<PyInt>() {
                     sqlite3_result_int64(self.ctx, val.try_to_primitive(vm)?)
-                } else if let Some(val) = val.payload::<PyFloat>() {
+                } else if let Some(val) = val.downcast_ref::<PyFloat>() {
                     sqlite3_result_double(self.ctx, val.to_f64())
-                } else if let Some(val) = val.payload::<PyStr>() {
+                } else if let Some(val) = val.downcast_ref::<PyStr>() {
+                    let val = val.try_as_utf8(vm)?;
                     let (ptr, len) = str_to_ptr_len(val, vm)?;
                     sqlite3_result_text(self.ctx, ptr, len, SQLITE_TRANSIENT())
                 } else if let Ok(buffer) = PyBuffer::try_from_borrowed_object(vm, val) {
@@ -2960,17 +3403,15 @@ mod _sqlite {
         } else if nbytes < 0 {
             Err(vm.new_system_error("negative size with ptr"))
         } else {
-            Ok(unsafe { std::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec())
+            Ok(unsafe { core::slice::from_raw_parts(p.cast(), nbytes as usize) }.to_vec())
         }
     }
 
-    fn str_to_ptr_len(s: &PyStr, vm: &VirtualMachine) -> PyResult<(*const libc::c_char, i32)> {
-        let s = s
-            .to_str()
-            .ok_or_else(|| vm.new_unicode_encode_error("surrogates not allowed"))?;
-        let len = c_int::try_from(s.len())
+    fn str_to_ptr_len(s: &PyUtf8Str, vm: &VirtualMachine) -> PyResult<(*const libc::c_char, i32)> {
+        let s_str = s.as_str();
+        let len = c_int::try_from(s_str.len())
             .map_err(|_| vm.new_overflow_error("TEXT longer than INT_MAX bytes"))?;
-        let ptr = s.as_ptr().cast();
+        let ptr = s_str.as_ptr().cast();
         Ok((ptr, len))
     }
 
@@ -3049,36 +3490,52 @@ mod _sqlite {
     }
 
     fn lstrip_sql(sql: &[u8]) -> Option<&[u8]> {
-        let mut pos = sql;
-        loop {
-            match pos.first()? {
+        let mut pos = 0;
+
+        // This loop is borrowed from the SQLite source code.
+        while let Some(t_char) = sql.get(pos) {
+            match t_char {
                 b' ' | b'\t' | b'\x0c' | b'\n' | b'\r' => {
-                    pos = &pos[1..];
+                    // Skip whitespace.
+                    pos += 1;
                 }
                 b'-' => {
-                    if *pos.get(1)? == b'-' {
-                        // line comments
-                        pos = &pos[2..];
-                        while *pos.first()? != b'\n' {
-                            pos = &pos[1..];
+                    // Skip line comments.
+                    if sql.get(pos + 1) == Some(&b'-') {
+                        pos += 2;
+                        while let Some(&ch) = sql.get(pos) {
+                            if ch == b'\n' {
+                                break;
+                            }
+                            pos += 1;
                         }
+                        let _ = sql.get(pos)?;
                     } else {
-                        return Some(pos);
+                        return Some(&sql[pos..]);
                     }
                 }
                 b'/' => {
-                    if *pos.get(1)? == b'*' {
-                        // c style comments
-                        pos = &pos[2..];
-                        while *pos.first()? != b'*' || *pos.get(1)? != b'/' {
-                            pos = &pos[1..];
+                    // Skip C style comments.
+                    if sql.get(pos + 1) == Some(&b'*') {
+                        pos += 2;
+                        while let Some(&ch) = sql.get(pos) {
+                            if ch == b'*' && sql.get(pos + 1) == Some(&b'/') {
+                                break;
+                            }
+                            pos += 1;
                         }
+                        let _ = sql.get(pos)?;
+                        pos += 2;
                     } else {
-                        return Some(pos);
+                        return Some(&sql[pos..]);
                     }
                 }
-                _ => return Some(pos),
+                _ => {
+                    return Some(&sql[pos..]);
+                }
             }
         }
+
+        None
     }
 }
diff --git a/crates/stdlib/src/ssl.rs b/crates/stdlib/src/ssl.rs
new file mode 100644
index 0000000000..31973a84f8
--- /dev/null
+++ b/crates/stdlib/src/ssl.rs
@@ -0,0 +1,4940 @@
+// spell-checker: ignore ssleof aesccm aesgcm getblocking setblocking ENDTLS TLSEXT
+
+//! Pure Rust SSL/TLS implementation using rustls
+//!
+//! This module provides SSL/TLS support without requiring C dependencies.
+//! It implements the Python ssl module API using:
+//! - rustls: TLS protocol implementation
+//! - x509-parser/x509-cert: Certificate parsing
+//! - ring: Cryptographic primitives
+//! - rustls-platform-verifier: Platform-native certificate verification
+//!
+//! DO NOT add openssl dependency here.
+//!
+//! Warning: This library contains AI-generated code and comments. Do not trust any code or comment without verification. Please have a qualified expert review the code and remove this notice after review.
+
+// OID (Object Identifier) management module
+mod oid;
+
+// Certificate operations module (parsing, validation, conversion)
+mod cert;
+
+// OpenSSL compatibility layer (abstracts rustls operations)
+mod compat;
+
+// SSL exception types (shared with openssl backend)
+mod error;
+
+pub(crate) use _ssl::make_module;
+
+#[allow(non_snake_case)]
+#[allow(non_upper_case_globals)]
+#[pymodule(with(error::ssl_error))]
+mod _ssl {
+    use crate::{
+        common::{
+            hash::PyHash,
+            lock::{PyMutex, PyRwLock},
+        },
+        socket::{PySocket, SelectKind, sock_select, timeout_error_msg},
+        vm::{
+            AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+            VirtualMachine,
+            builtins::{PyBaseExceptionRef, PyBytesRef, PyListRef, PyStrRef, PyType, PyTypeRef},
+            convert::IntoPyException,
+            function::{ArgBytesLike, ArgMemoryBuffer, FuncArgs, OptionalArg, PyComparisonValue},
+            stdlib::warnings,
+            types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+        },
+    };
+
+    // Import error types used in this module (others are exposed via pymodule(with(...)))
+    use super::error::{
+        PySSLEOFError, PySSLError, create_ssl_want_read_error, create_ssl_want_write_error,
+    };
+    use alloc::sync::Arc;
+    use core::{
+        sync::atomic::{AtomicUsize, Ordering},
+        time::Duration,
+    };
+    use std::{collections::HashMap, time::SystemTime};
+
+    // Rustls imports
+    use parking_lot::{Mutex as ParkingMutex, RwLock as ParkingRwLock};
+    use pem_rfc7468::{LineEnding, encode_string};
+    use rustls::{
+        ClientConfig, ClientConnection, RootCertStore, ServerConfig, ServerConnection,
+        client::{ClientSessionMemoryCache, ClientSessionStore},
+        crypto::SupportedKxGroup,
+        pki_types::{CertificateDer, CertificateRevocationListDer, PrivateKeyDer, ServerName},
+        server::{ClientHello, ResolvesServerCert},
+        sign::CertifiedKey,
+        version::{TLS12, TLS13},
+    };
+    use sha2::{Digest, Sha256};
+
+    // Import certificate operations module
+    use super::cert;
+
+    // Import OID module
+    use super::oid;
+
+    // Import compat module (OpenSSL compatibility layer)
+    use super::compat::{
+        ClientConfigOptions, MultiCertResolver, ProtocolSettings, ServerConfigOptions, SslError,
+        TlsConnection, create_client_config, create_server_config, curve_name_to_kx_group,
+        extract_cipher_info, get_cipher_encryption_desc, is_blocking_io_error,
+        normalize_cipher_name, ssl_do_handshake,
+    };
+
+    // Type aliases for better readability
+    // Additional type alias for certificate/key pairs (SessionCache and SniCertName defined below)
+
+    /// Certificate and private key pair used in SSL contexts
+    type CertKeyPair = (Arc<CertifiedKey>, PrivateKeyDer<'static>);
+
+    // Constants matching Python ssl module
+
+    // SSL/TLS Protocol versions
+    #[pyattr]
+    const PROTOCOL_TLS: i32 = 2; // Auto-negotiate best version
+    #[pyattr]
+    const PROTOCOL_SSLv23: i32 = PROTOCOL_TLS; // Alias for PROTOCOL_TLS
+    #[pyattr]
+    const PROTOCOL_TLS_CLIENT: i32 = 16;
+    #[pyattr]
+    const PROTOCOL_TLS_SERVER: i32 = 17;
+
+    // Note: rustls doesn't support TLS 1.0/1.1 for security reasons
+    // These are defined for API compatibility but will raise errors if used
+    #[pyattr]
+    const PROTOCOL_TLSv1: i32 = 3;
+    #[pyattr]
+    const PROTOCOL_TLSv1_1: i32 = 4;
+    #[pyattr]
+    const PROTOCOL_TLSv1_2: i32 = 5;
+    #[pyattr]
+    const PROTOCOL_TLSv1_3: i32 = 6;
+
+    // Protocol version constants for TLSVersion enum
+    #[pyattr]
+    const PROTO_SSLv3: i32 = 0x0300;
+    #[pyattr]
+    const PROTO_TLSv1: i32 = 0x0301;
+    #[pyattr]
+    const PROTO_TLSv1_1: i32 = 0x0302;
+    #[pyattr]
+    const PROTO_TLSv1_2: i32 = 0x0303;
+    #[pyattr]
+    const PROTO_TLSv1_3: i32 = 0x0304;
+
+    // Minimum and maximum supported protocol versions for rustls
+    // Use special values -2 and -1 to avoid enum name conflicts
+    #[pyattr]
+    const PROTO_MINIMUM_SUPPORTED: i32 = -2; // special value
+    #[pyattr]
+    const PROTO_MAXIMUM_SUPPORTED: i32 = -1; // special value
+
+    // Internal constants for rustls actual supported versions
+    // rustls only supports TLS 1.2 and TLS 1.3
+    const MINIMUM_VERSION: i32 = PROTO_TLSv1_2; // 0x0303
+    const MAXIMUM_VERSION: i32 = PROTO_TLSv1_3; // 0x0304
+
+    // Buffer sizes and limits (OpenSSL/CPython compatibility)
+    const PEM_BUFSIZE: usize = 1024;
+    // OpenSSL: ssl/ssl_local.h
+    const SSL3_RT_MAX_PLAIN_LENGTH: usize = 16384;
+    // SSL session cache size (common practice, similar to OpenSSL defaults)
+    const SSL_SESSION_CACHE_SIZE: usize = 256;
+
+    // Certificate verification modes
+    #[pyattr]
+    const CERT_NONE: i32 = 0;
+    #[pyattr]
+    const CERT_OPTIONAL: i32 = 1;
+    #[pyattr]
+    const CERT_REQUIRED: i32 = 2;
+
+    // Certificate requirements
+    #[pyattr]
+    const VERIFY_DEFAULT: i32 = 0;
+    #[pyattr]
+    const VERIFY_CRL_CHECK_LEAF: i32 = 4;
+    #[pyattr]
+    const VERIFY_CRL_CHECK_CHAIN: i32 = 12;
+    #[pyattr]
+    const VERIFY_X509_STRICT: i32 = 32;
+    #[pyattr]
+    const VERIFY_ALLOW_PROXY_CERTS: i32 = 64;
+    #[pyattr]
+    const VERIFY_X509_TRUSTED_FIRST: i32 = 32768;
+    #[pyattr]
+    const VERIFY_X509_PARTIAL_CHAIN: i32 = 0x80000;
+
+    // Options (OpenSSL-compatible flags, mostly no-op in rustls)
+    #[pyattr]
+    const OP_NO_SSLv2: i32 = 0x00000000; // Not supported anyway
+    #[pyattr]
+    const OP_NO_SSLv3: i32 = 0x02000000;
+    #[pyattr]
+    const OP_NO_TLSv1: i32 = 0x04000000;
+    #[pyattr]
+    const OP_NO_TLSv1_1: i32 = 0x10000000;
+    #[pyattr]
+    const OP_NO_TLSv1_2: i32 = 0x08000000;
+    #[pyattr]
+    const OP_NO_TLSv1_3: i32 = 0x20000000;
+    #[pyattr]
+    const OP_NO_COMPRESSION: i32 = 0x00020000;
+    #[pyattr]
+    const OP_CIPHER_SERVER_PREFERENCE: i32 = 0x00400000;
+    #[pyattr]
+    const OP_SINGLE_DH_USE: i32 = 0x00000000; // No-op in rustls
+    #[pyattr]
+    const OP_SINGLE_ECDH_USE: i32 = 0x00000000; // No-op in rustls
+    #[pyattr]
+    const OP_NO_TICKET: i32 = 0x00004000;
+    #[pyattr]
+    const OP_LEGACY_SERVER_CONNECT: i32 = 0x00000004;
+    #[pyattr]
+    const OP_NO_RENEGOTIATION: i32 = 0x40000000;
+    #[pyattr]
+    const OP_IGNORE_UNEXPECTED_EOF: i32 = 0x00000080;
+    #[pyattr]
+    const OP_ENABLE_MIDDLEBOX_COMPAT: i32 = 0x00100000;
+    #[pyattr]
+    const OP_ALL: i32 = 0x00000BFB; // Combined "safe" options (reduced for i32, excluding OP_LEGACY_SERVER_CONNECT for OpenSSL 3.0.0+ compatibility)
+
+    // Alert types (matching _TLSAlertType enum)
+    #[pyattr]
+    const ALERT_DESCRIPTION_CLOSE_NOTIFY: i32 = 0;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNEXPECTED_MESSAGE: i32 = 10;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_RECORD_MAC: i32 = 20;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECRYPTION_FAILED: i32 = 21;
+    #[pyattr]
+    const ALERT_DESCRIPTION_RECORD_OVERFLOW: i32 = 22;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECOMPRESSION_FAILURE: i32 = 30;
+    #[pyattr]
+    const ALERT_DESCRIPTION_HANDSHAKE_FAILURE: i32 = 40;
+    #[pyattr]
+    const ALERT_DESCRIPTION_NO_CERTIFICATE: i32 = 41;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE: i32 = 42;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: i32 = 43;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_REVOKED: i32 = 44;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_EXPIRED: i32 = 45;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN: i32 = 46;
+    #[pyattr]
+    const ALERT_DESCRIPTION_ILLEGAL_PARAMETER: i32 = 47;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNKNOWN_CA: i32 = 48;
+    #[pyattr]
+    const ALERT_DESCRIPTION_ACCESS_DENIED: i32 = 49;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECODE_ERROR: i32 = 50;
+    #[pyattr]
+    const ALERT_DESCRIPTION_DECRYPT_ERROR: i32 = 51;
+    #[pyattr]
+    const ALERT_DESCRIPTION_EXPORT_RESTRICTION: i32 = 60;
+    #[pyattr]
+    const ALERT_DESCRIPTION_PROTOCOL_VERSION: i32 = 70;
+    #[pyattr]
+    const ALERT_DESCRIPTION_INSUFFICIENT_SECURITY: i32 = 71;
+    #[pyattr]
+    const ALERT_DESCRIPTION_INTERNAL_ERROR: i32 = 80;
+    #[pyattr]
+    const ALERT_DESCRIPTION_INAPPROPRIATE_FALLBACK: i32 = 86;
+    #[pyattr]
+    const ALERT_DESCRIPTION_USER_CANCELLED: i32 = 90;
+    #[pyattr]
+    const ALERT_DESCRIPTION_NO_RENEGOTIATION: i32 = 100;
+    #[pyattr]
+    const ALERT_DESCRIPTION_MISSING_EXTENSION: i32 = 109;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: i32 = 110;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE: i32 = 111;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNRECOGNIZED_NAME: i32 = 112;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE: i32 = 113;
+    #[pyattr]
+    const ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE: i32 = 114;
+    #[pyattr]
+    const ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY: i32 = 115;
+    #[pyattr]
+    const ALERT_DESCRIPTION_CERTIFICATE_REQUIRED: i32 = 116;
+    #[pyattr]
+    const ALERT_DESCRIPTION_NO_APPLICATION_PROTOCOL: i32 = 120;
+
+    // Version info - reporting as OpenSSL 3.3.0 for compatibility
+    #[pyattr]
+    const OPENSSL_VERSION_NUMBER: i32 = 0x30300000; // OpenSSL 3.3.0 (808452096)
+    #[pyattr]
+    const OPENSSL_VERSION: &str = "OpenSSL 3.3.0 (rustls/0.23)";
+    #[pyattr]
+    const OPENSSL_VERSION_INFO: (i32, i32, i32, i32, i32) = (3, 3, 0, 0, 15); // 3.3.0 release
+    #[pyattr]
+    const _OPENSSL_API_VERSION: (i32, i32, i32, i32, i32) = (3, 3, 0, 0, 15); // 3.3.0 release
+
+    // Default cipher list for rustls - using modern secure ciphers
+    #[pyattr]
+    const _DEFAULT_CIPHERS: &str =
+        "TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256";
+
+    // Has features
+    #[pyattr]
+    const HAS_SNI: bool = true;
+    #[pyattr]
+    const HAS_TLS_UNIQUE: bool = false; // Not supported
+    #[pyattr]
+    const HAS_ECDH: bool = true;
+    #[pyattr]
+    const HAS_NPN: bool = false; // Deprecated, use ALPN
+    #[pyattr]
+    const HAS_ALPN: bool = true;
+    #[pyattr]
+    const HAS_PSK: bool = false; // PSK not supported in rustls
+    #[pyattr]
+    const HAS_SSLv2: bool = false;
+    #[pyattr]
+    const HAS_SSLv3: bool = false;
+    #[pyattr]
+    const HAS_TLSv1: bool = false; // Not supported for security
+    #[pyattr]
+    const HAS_TLSv1_1: bool = false; // Not supported for security
+    #[pyattr]
+    const HAS_TLSv1_2: bool = true; // rustls supports TLS 1.2
+    #[pyattr]
+    const HAS_TLSv1_3: bool = true;
+
+    // Encoding constants (matching OpenSSL)
+    #[pyattr]
+    const ENCODING_PEM: i32 = 1;
+    #[pyattr]
+    const ENCODING_DER: i32 = 2;
+    #[pyattr]
+    const ENCODING_PEM_AUX: i32 = 0x101; // PEM + 0x100
+
+    /// Validate server hostname for TLS SNI
+    ///
+    /// Checks that the hostname:
+    /// - Is not empty
+    /// - Does not start with a dot
+    /// - Is not an IP address (SNI requires DNS names)
+    /// - Does not contain null bytes
+    /// - Does not exceed 253 characters (DNS limit)
+    ///
+    /// Returns Ok(()) if validation passes, or an appropriate error.
+    fn validate_hostname(hostname: &str, vm: &VirtualMachine) -> PyResult<()> {
+        if hostname.is_empty() {
+            return Err(vm.new_value_error("server_hostname cannot be an empty string"));
+        }
+
+        if hostname.starts_with('.') {
+            return Err(vm.new_value_error("server_hostname cannot start with a dot"));
+        }
+
+        // IP addresses are allowed as server_hostname
+        // SNI will not be sent for IP addresses
+
+        if hostname.contains('\0') {
+            return Err(vm.new_type_error("embedded null character"));
+        }
+
+        if hostname.len() > 253 {
+            return Err(vm.new_value_error("server_hostname is too long (maximum 253 characters)"));
+        }
+
+        Ok(())
+    }
+
+    // SNI certificate resolver that uses shared mutable state
+    // The Python SNI callback updates this state, and resolve() reads from it
+    #[derive(Debug)]
+    struct SniCertResolver {
+        // SNI state: (certificate, server_name)
+        sni_state: Arc<ParkingMutex<SniCertName>>,
+    }
+
+    impl ResolvesServerCert for SniCertResolver {
+        fn resolve(&self, client_hello: ClientHello<'_>) -> Option<Arc<CertifiedKey>> {
+            let mut state = self.sni_state.lock();
+
+            // Extract and store SNI from client hello for later use
+            if let Some(sni) = client_hello.server_name() {
+                state.1 = Some(sni.to_string());
+            } else {
+                state.1 = None;
+            }
+
+            // Return the current certificate (may have been updated by Python callback)
+            Some(state.0.clone())
+        }
+    }
+
+    // Session data structure for tracking TLS sessions
+    #[derive(Debug, Clone)]
+    struct SessionData {
+        #[allow(dead_code)]
+        server_name: String,
+        session_id: Vec<u8>,
+        creation_time: SystemTime,
+        lifetime: u64,
+    }
+
+    // Type alias to simplify complex session cache type
+    type SessionCache = Arc<ParkingRwLock<HashMap<Vec<u8>, Arc<ParkingMutex<SessionData>>>>>;
+
+    // Type alias for SNI state
+    type SniCertName = (Arc<CertifiedKey>, Option<String>);
+
+    // SESSION EMULATION IMPLEMENTATION
+    //
+    // IMPORTANT: This is an EMULATION of CPython's SSL session management.
+    // Rustls 0.23 does NOT expose session data (ticket bytes, session IDs, etc.)
+    // through public APIs. All session value fields are private.
+    //
+    // LIMITATIONS:
+    // - Session IDs are generated from metadata (server name + timestamp hash)
+    //   NOT actual TLS session IDs
+    // - Ticket data is not stored (Rustls keeps it internally)
+    // - Session resumption works (via Rustls's automatic mechanism)
+    //   but we can't access the actual session state
+    //
+    // This implementation provides:
+    // ✓ session.id - synthetic ID based on metadata
+    // ✓ session.time - creation timestamp
+    // ✓ session.timeout - default lifetime value
+    // ✓ session.has_ticket - always True when session exists
+    // ✓ session_reused - tracked via handshake_kind()
+    // ✗ Actual TLS session ID/ticket data - NOT ACCESSIBLE
+
+    // Generate a synthetic session ID from server name and timestamp
+    // NOTE: This is NOT the actual TLS session ID, just a unique identifier
+    fn generate_session_id_from_metadata(server_name: &str, time: &SystemTime) -> Vec<u8> {
+        let mut hasher = Sha256::new();
+        hasher.update(server_name.as_bytes());
+        hasher.update(
+            time.duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_secs()
+                .to_le_bytes(),
+        );
+        hasher.finalize()[..16].to_vec()
+    }
+
+    // Custom ClientSessionStore that tracks session metadata for Python access
+    // NOTE: This wraps ClientSessionMemoryCache and records metadata when sessions are stored
+    #[derive(Debug)]
+    struct PythonClientSessionStore {
+        inner: Arc<ClientSessionMemoryCache>,
+        session_cache: SessionCache,
+    }
+
+    impl ClientSessionStore for PythonClientSessionStore {
+        fn set_kx_hint(&self, server_name: ServerName<'static>, group: rustls::NamedGroup) {
+            self.inner.set_kx_hint(server_name, group);
+        }
+
+        fn kx_hint(&self, server_name: &ServerName<'_>) -> Option<rustls::NamedGroup> {
+            self.inner.kx_hint(server_name)
+        }
+
+        fn set_tls12_session(
+            &self,
+            server_name: ServerName<'static>,
+            value: rustls::client::Tls12ClientSessionValue,
+        ) {
+            // Store in inner cache for actual resumption (Rustls handles this)
+            self.inner.set_tls12_session(server_name.clone(), value);
+
+            // Record metadata in Python-accessible cache
+            // NOTE: We can't access value.session_id or value.ticket (private fields)
+            // So we generate a synthetic ID from metadata
+            let creation_time = SystemTime::now();
+            let server_name_str = server_name.to_str();
+            let session_data = SessionData {
+                server_name: server_name_str.as_ref().to_string(),
+                session_id: generate_session_id_from_metadata(
+                    server_name_str.as_ref(),
+                    &creation_time,
+                ),
+                creation_time,
+                lifetime: 7200, // TLS 1.2 default session lifetime
+            };
+
+            let key = server_name_str.as_bytes().to_vec();
+            self.session_cache
+                .write()
+                .insert(key, Arc::new(ParkingMutex::new(session_data)));
+        }
+
+        fn tls12_session(
+            &self,
+            server_name: &ServerName<'_>,
+        ) -> Option<rustls::client::Tls12ClientSessionValue> {
+            self.inner.tls12_session(server_name)
+        }
+
+        fn remove_tls12_session(&self, server_name: &ServerName<'static>) {
+            self.inner.remove_tls12_session(server_name);
+
+            // Also remove from Python cache
+            let key = server_name.to_str().as_bytes().to_vec();
+            self.session_cache.write().remove(&key);
+        }
+
+        fn insert_tls13_ticket(
+            &self,
+            server_name: ServerName<'static>,
+            value: rustls::client::Tls13ClientSessionValue,
+        ) {
+            // Store in inner cache for actual resumption (Rustls handles this)
+            self.inner.insert_tls13_ticket(server_name.clone(), value);
+
+            // Record metadata in Python-accessible cache
+            // NOTE: We can't access value.ticket or value.lifetime_secs (private fields)
+            // So we use default values
+            let creation_time = SystemTime::now();
+            let server_name_str = server_name.to_str();
+            let session_data = SessionData {
+                server_name: server_name_str.to_string(),
+                session_id: generate_session_id_from_metadata(
+                    server_name_str.as_ref(),
+                    &creation_time,
+                ),
+                creation_time,
+                lifetime: 7200, // Default TLS 1.3 ticket lifetime (Rustls uses this)
+            };
+
+            let key = server_name_str.as_bytes().to_vec();
+            self.session_cache
+                .write()
+                .insert(key, Arc::new(ParkingMutex::new(session_data)));
+        }
+
+        fn take_tls13_ticket(
+            &self,
+            server_name: &ServerName<'static>,
+        ) -> Option<rustls::client::Tls13ClientSessionValue> {
+            self.inner.take_tls13_ticket(server_name)
+        }
+    }
+
+    /// Parse length-prefixed ALPN protocol list
+    ///
+    /// Format: [len1, proto1..., len2, proto2..., ...]
+    ///
+    /// This is the wire format used by Python's ssl.py when calling _set_alpn_protocols().
+    /// Each protocol is prefixed with a single byte indicating its length.
+    ///
+    /// # Arguments
+    /// * `bytes` - The length-prefixed protocol data
+    /// * `vm` - VirtualMachine for error creation
+    ///
+    /// # Returns
+    /// * `Ok(Vec<Vec<u8>>)` - List of protocol names as byte vectors
+    /// * `Err(PyBaseExceptionRef)` - ValueError with detailed error message
+    fn parse_length_prefixed_alpn(bytes: &[u8], vm: &VirtualMachine) -> PyResult<Vec<Vec<u8>>> {
+        let mut alpn_list = Vec::new();
+        let mut offset = 0;
+
+        while offset < bytes.len() {
+            // Check if we can read the length byte
+            if offset + 1 > bytes.len() {
+                return Err(vm.new_value_error(format!(
+                    "Invalid ALPN protocol data: unexpected end at offset {offset}",
+                )));
+            }
+
+            let proto_len = bytes[offset] as usize;
+            offset += 1;
+
+            // Validate protocol length
+            if proto_len == 0 {
+                return Err(vm.new_value_error(format!(
+                    "Invalid ALPN protocol data: protocol length cannot be 0 at offset {}",
+                    offset - 1
+                )));
+            }
+
+            // Check if we have enough bytes for the protocol data
+            if offset + proto_len > bytes.len() {
+                return Err(vm.new_value_error(format!(
+                    "Invalid ALPN protocol data: expected {} bytes at offset {}, but only {} bytes remain",
+                    proto_len, offset, bytes.len() - offset
+                )));
+            }
+
+            // Extract protocol bytes
+            let proto = bytes[offset..offset + proto_len].to_vec();
+            alpn_list.push(proto);
+            offset += proto_len;
+        }
+
+        Ok(alpn_list)
+    }
+
+    /// Parse OpenSSL cipher string to rustls SupportedCipherSuite list
+    ///
+    /// Supports patterns like:
+    /// - "AES128" → filters for AES_128
+    /// - "AES256" → filters for AES_256
+    /// - "AES128:AES256" → both
+    /// - "ECDHE+AESGCM" → ECDHE AND AESGCM (both conditions must match)
+    /// - "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());
+        }
+
+        let all_suites = ALL_CIPHER_SUITES;
+        let mut selected = Vec::new();
+
+        for part in cipher_str.split(':') {
+            let part = part.trim();
+
+            // Skip exclusions (rustls doesn't support these)
+            if part.starts_with('!') {
+                continue;
+            }
+
+            // Skip priority markers starting with +
+            if part.starts_with('+') {
+                continue;
+            }
+
+            // Match pattern
+            match part {
+                "ALL" | "DEFAULT" | "HIGH" => {
+                    // Add all available cipher suites
+                    selected.extend_from_slice(all_suites);
+                }
+                _ => {
+                    // Check if this is a compound pattern with + (AND condition)
+                    // e.g., "ECDHE+AESGCM" means ECDHE AND AESGCM
+                    let patterns: Vec<&str> = part.split('+').collect();
+
+                    let mut found_any = false;
+                    for suite in all_suites {
+                        let name = format!("{:?}", suite.suite());
+
+                        // Check if all patterns match (AND condition)
+                        let matches = patterns.iter().all(|&pattern| {
+                            // Handle common OpenSSL pattern variations
+                            if pattern.contains("AES128") {
+                                name.contains("AES_128")
+                            } else if pattern.contains("AES256") {
+                                name.contains("AES_256")
+                            } else if pattern == "AESGCM" {
+                                // AESGCM: AES with GCM mode
+                                name.contains("AES") && name.contains("GCM")
+                            } else if pattern == "AESCCM" {
+                                // AESCCM: AES with CCM mode
+                                name.contains("AES") && name.contains("CCM")
+                            } else if pattern == "CHACHA20" {
+                                name.contains("CHACHA20")
+                            } else if pattern == "ECDHE" {
+                                name.contains("ECDHE")
+                            } else if pattern == "DHE" {
+                                // DHE but not ECDHE
+                                name.contains("DHE") && !name.contains("ECDHE")
+                            } else if pattern == "ECDH" {
+                                // ECDH but not ECDHE
+                                name.contains("ECDH") && !name.contains("ECDHE")
+                            } else if pattern == "DH" {
+                                // DH but not DHE or ECDH
+                                name.contains("DH")
+                                    && !name.contains("DHE")
+                                    && !name.contains("ECDH")
+                            } else if pattern == "RSA" {
+                                name.contains("RSA")
+                            } else if pattern == "AES" {
+                                name.contains("AES")
+                            } else if pattern == "ECDSA" {
+                                name.contains("ECDSA")
+                            } else {
+                                // Direct substring match for other patterns
+                                name.contains(pattern)
+                            }
+                        });
+
+                        if matches {
+                            selected.push(*suite);
+                            found_any = true;
+                        }
+                    }
+
+                    if !found_any {
+                        // No matching cipher suite found - warn but continue
+                    }
+                }
+            }
+        }
+
+        // Remove duplicates
+        selected.dedup_by_key(|s| s.suite());
+
+        if selected.is_empty() {
+            Err("No cipher can be selected".to_string())
+        } else {
+            Ok(selected)
+        }
+    }
+
+    // SSLContext - manages TLS configuration
+    #[pyattr]
+    #[pyclass(name = "_SSLContext", module = "ssl", traverse)]
+    #[derive(Debug, PyPayload)]
+    struct PySSLContext {
+        #[pytraverse(skip)]
+        protocol: i32,
+        #[pytraverse(skip)]
+        check_hostname: PyRwLock<bool>,
+        #[pytraverse(skip)]
+        verify_mode: PyRwLock<i32>,
+        #[pytraverse(skip)]
+        verify_flags: PyRwLock<i32>,
+        // Rustls configuration (built lazily)
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        client_config: PyRwLock<Option<Arc<ClientConfig>>>,
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        server_config: PyRwLock<Option<Arc<ServerConfig>>>,
+        // Certificate store
+        #[pytraverse(skip)]
+        root_certs: PyRwLock<RootCertStore>,
+        // Store full CA certificates for get_ca_certs()
+        // RootCertStore only keeps TrustAnchors, not full certificates
+        #[pytraverse(skip)]
+        ca_certs_der: PyRwLock<Vec<Vec<u8>>>,
+        // Store CA certificates from capath for lazy loading simulation
+        // (CPython only returns these in get_ca_certs() after they're used in handshake)
+        #[pytraverse(skip)]
+        capath_certs_der: PyRwLock<Vec<Vec<u8>>>,
+        // Certificate Revocation Lists for CRL checking
+        #[pytraverse(skip)]
+        crls: PyRwLock<Vec<CertificateRevocationListDer<'static>>>,
+        // Server certificate/key pairs (supports multiple for RSA+ECC dual mode)
+        // OpenSSL allows multiple cert/key pairs to be loaded, and selects the appropriate
+        // one based on client capabilities during handshake
+        // Stored as (CertifiedKey, PrivateKeyDer) to support both server and client usage
+        #[pytraverse(skip)]
+        cert_keys: PyRwLock<Vec<CertKeyPair>>,
+        // Options
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        options: PyRwLock<i32>,
+        // ALPN protocols
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        alpn_protocols: PyRwLock<Vec<Vec<u8>>>,
+        // ALPN strict matching flag
+        // When false (default), mimics OpenSSL behavior: no ALPN negotiation failure
+        // When true, requires ALPN match (Rustls default behavior)
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        require_alpn_match: PyRwLock<bool>,
+        // TLS 1.3 features
+        #[pytraverse(skip)]
+        post_handshake_auth: PyRwLock<bool>,
+        #[pytraverse(skip)]
+        num_tickets: PyRwLock<i32>,
+        // Protocol version limits
+        #[pytraverse(skip)]
+        minimum_version: PyRwLock<i32>,
+        #[pytraverse(skip)]
+        maximum_version: PyRwLock<i32>,
+        // SNI callback for server-side (contains PyObjectRef - needs GC tracking)
+        sni_callback: PyRwLock<Option<PyObjectRef>>,
+        // Message callback for debugging (contains PyObjectRef - needs GC tracking)
+        msg_callback: PyRwLock<Option<PyObjectRef>>,
+        // ECDH curve name for key exchange
+        #[pytraverse(skip)]
+        ecdh_curve: PyRwLock<Option<String>>,
+        // Certificate statistics for cert_store_stats()
+        #[pytraverse(skip)]
+        ca_cert_count: PyRwLock<usize>, // Number of CA certificates
+        #[pytraverse(skip)]
+        x509_cert_count: PyRwLock<usize>, // Total number of certificates
+        // Session management
+        #[pytraverse(skip)]
+        client_session_cache: SessionCache,
+        // Rustls session store for actual TLS session resumption
+        #[pytraverse(skip)]
+        rustls_session_store: Arc<PythonClientSessionStore>,
+        // Rustls server session store for server-side session resumption
+        #[pytraverse(skip)]
+        rustls_server_session_store: Arc<rustls::server::ServerSessionMemoryCache>,
+        // Shared ticketer for TLS 1.2 session tickets
+        #[pytraverse(skip)]
+        server_ticketer: Arc<dyn rustls::server::ProducesTickets>,
+        // Server-side session statistics
+        #[pytraverse(skip)]
+        accept_count: AtomicUsize, // Total number of accepts
+        #[pytraverse(skip)]
+        session_hits: AtomicUsize, // Number of session reuses
+        // Cipher suite selection
+        /// Selected cipher suites (None = use all rustls defaults)
+        #[pytraverse(skip)]
+        selected_ciphers: PyRwLock<Option<Vec<rustls::SupportedCipherSuite>>>,
+    }
+
+    #[derive(FromArgs)]
+    struct WrapSocketArgs {
+        sock: PyObjectRef,
+        server_side: bool,
+        #[pyarg(positional, optional)]
+        server_hostname: OptionalArg<Option<PyStrRef>>,
+        #[pyarg(named, optional)]
+        owner: OptionalArg<PyObjectRef>,
+        #[pyarg(named, optional)]
+        session: OptionalArg<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct WrapBioArgs {
+        incoming: PyRef<PyMemoryBIO>,
+        outgoing: PyRef<PyMemoryBIO>,
+        #[pyarg(named, optional)]
+        server_side: OptionalArg<bool>,
+        #[pyarg(named, optional)]
+        server_hostname: OptionalArg<Option<PyStrRef>>,
+        #[pyarg(named, optional)]
+        owner: OptionalArg<PyObjectRef>,
+        #[pyarg(named, optional)]
+        session: OptionalArg<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct LoadVerifyLocationsArgs {
+        #[pyarg(any, optional)]
+        cafile: OptionalArg<Option<PyObjectRef>>,
+        #[pyarg(any, optional)]
+        capath: OptionalArg<Option<PyObjectRef>>,
+        #[pyarg(any, optional)]
+        cadata: OptionalArg<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct LoadCertChainArgs {
+        #[pyarg(any)]
+        certfile: PyObjectRef,
+        #[pyarg(any, optional)]
+        keyfile: OptionalArg<Option<PyObjectRef>>,
+        #[pyarg(any, optional)]
+        password: OptionalArg<PyObjectRef>,
+    }
+
+    #[derive(FromArgs)]
+    struct GetCertArgs {
+        #[pyarg(any, optional)]
+        binary_form: OptionalArg<bool>,
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl PySSLContext {
+        // Helper method to convert DER certificate bytes to Python dict
+        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()
+        }
+
+        #[pygetset(setter)]
+        fn set_check_hostname(&self, value: bool) {
+            *self.check_hostname.write() = value;
+            // When check_hostname is enabled, ensure verify_mode is at least CERT_REQUIRED
+            if value {
+                let current_verify_mode = *self.verify_mode.read();
+                if current_verify_mode == CERT_NONE {
+                    *self.verify_mode.write() = CERT_REQUIRED;
+                }
+            }
+        }
+
+        #[pygetset]
+        fn verify_mode(&self) -> i32 {
+            *self.verify_mode.read()
+        }
+
+        #[pygetset(setter)]
+        fn set_verify_mode(&self, mode: i32, vm: &VirtualMachine) -> PyResult<()> {
+            if !(CERT_NONE..=CERT_REQUIRED).contains(&mode) {
+                return Err(vm.new_value_error("invalid verify mode"));
+            }
+            // Cannot set CERT_NONE when check_hostname is enabled
+            if mode == CERT_NONE && *self.check_hostname.read() {
+                return Err(vm.new_value_error(
+                    "Cannot set verify_mode to CERT_NONE when check_hostname is enabled",
+                ));
+            }
+            *self.verify_mode.write() = mode;
+            Ok(())
+        }
+
+        #[pygetset]
+        fn protocol(&self) -> i32 {
+            self.protocol
+        }
+
+        #[pygetset]
+        fn verify_flags(&self) -> i32 {
+            *self.verify_flags.read()
+        }
+
+        #[pygetset(setter)]
+        fn set_verify_flags(&self, value: i32) {
+            *self.verify_flags.write() = value;
+        }
+
+        #[pygetset]
+        fn post_handshake_auth(&self) -> bool {
+            *self.post_handshake_auth.read()
+        }
+
+        #[pygetset(setter)]
+        fn set_post_handshake_auth(&self, value: bool) {
+            *self.post_handshake_auth.write() = value;
+        }
+
+        #[pygetset]
+        fn num_tickets(&self) -> i32 {
+            *self.num_tickets.read()
+        }
+
+        #[pygetset(setter)]
+        fn set_num_tickets(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
+            if value < 0 {
+                return Err(vm.new_value_error("num_tickets must be a non-negative integer"));
+            }
+            if self.protocol != PROTOCOL_TLS_SERVER {
+                return Err(
+                    vm.new_value_error("num_tickets can only be set on server-side contexts")
+                );
+            }
+            *self.num_tickets.write() = value;
+            Ok(())
+        }
+
+        #[pygetset]
+        fn options(&self) -> i32 {
+            *self.options.read()
+        }
+
+        #[pygetset(setter)]
+        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()));
+            }
+
+            // Deprecated SSL/TLS protocol version options
+            let opt_no = OP_NO_SSLv2
+                | OP_NO_SSLv3
+                | OP_NO_TLSv1
+                | OP_NO_TLSv1_1
+                | OP_NO_TLSv1_2
+                | OP_NO_TLSv1_3;
+
+            // Get current options and calculate newly set bits
+            let old_opts = *self.options.read();
+            let set = !old_opts & value; // Bits being newly set
+
+            // Warn if any deprecated options are being newly set
+            if (set & opt_no) != 0 {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    "ssl.OP_NO_SSL*/ssl.OP_NO_TLS* options are deprecated".to_owned(),
+                    2, // stack_level = 2
+                    vm,
+                )?;
+            }
+
+            *self.options.write() = value;
+            Ok(())
+        }
+
+        #[pygetset]
+        fn minimum_version(&self) -> i32 {
+            let v = *self.minimum_version.read();
+            // return MINIMUM_SUPPORTED if value is 0
+            if v == 0 { PROTO_MINIMUM_SUPPORTED } else { v }
+        }
+
+        #[pygetset(setter)]
+        fn set_minimum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
+            // Validate that the value is a valid TLS version constant
+            // Valid values: 0 (default), -2 (MINIMUM_SUPPORTED), -1 (MAXIMUM_SUPPORTED),
+            // or 0x0300-0x0304 (SSLv3-TLSv1.3)
+            if value != 0
+                && value != -2
+                && value != -1
+                && !(PROTO_SSLv3..=PROTO_TLSv1_3).contains(&value)
+            {
+                return Err(vm.new_value_error(format!("invalid protocol version: {value}")));
+            }
+            // Convert special values to rustls actual supported versions
+            // MINIMUM_SUPPORTED (-2) -> 0 (auto-negotiate)
+            // MAXIMUM_SUPPORTED (-1) -> MAXIMUM_VERSION (TLSv1.3)
+            let normalized_value = match value {
+                PROTO_MINIMUM_SUPPORTED => 0,               // Auto-negotiate
+                PROTO_MAXIMUM_SUPPORTED => MAXIMUM_VERSION, // TLSv1.3
+                _ => value,
+            };
+            *self.minimum_version.write() = normalized_value;
+            Ok(())
+        }
+
+        #[pygetset]
+        fn maximum_version(&self) -> i32 {
+            let v = *self.maximum_version.read();
+            // return MAXIMUM_SUPPORTED if value is 0
+            if v == 0 { PROTO_MAXIMUM_SUPPORTED } else { v }
+        }
+
+        #[pygetset(setter)]
+        fn set_maximum_version(&self, value: i32, vm: &VirtualMachine) -> PyResult<()> {
+            // Validate that the value is a valid TLS version constant
+            // Valid values: 0 (default), -2 (MINIMUM_SUPPORTED), -1 (MAXIMUM_SUPPORTED),
+            // or 0x0300-0x0304 (SSLv3-TLSv1.3)
+            if value != 0
+                && value != -2
+                && value != -1
+                && !(PROTO_SSLv3..=PROTO_TLSv1_3).contains(&value)
+            {
+                return Err(vm.new_value_error(format!("invalid protocol version: {value}")));
+            }
+            // Convert special values to rustls actual supported versions
+            // MAXIMUM_SUPPORTED (-1) -> 0 (auto-negotiate)
+            // MINIMUM_SUPPORTED (-2) -> MINIMUM_VERSION (TLSv1.2)
+            let normalized_value = match value {
+                PROTO_MAXIMUM_SUPPORTED => 0,               // Auto-negotiate
+                PROTO_MINIMUM_SUPPORTED => MINIMUM_VERSION, // TLSv1.2
+                _ => value,
+            };
+            *self.maximum_version.write() = normalized_value;
+            Ok(())
+        }
+
+        #[pymethod]
+        fn load_cert_chain(&self, args: LoadCertChainArgs, vm: &VirtualMachine) -> PyResult<()> {
+            // Parse certfile argument (str or bytes) to path
+            let cert_path = Self::parse_path_arg(&args.certfile, vm)?;
+
+            // Parse keyfile argument (default to certfile if not provided)
+            let key_path = match args.keyfile {
+                OptionalArg::Present(Some(ref k)) => Self::parse_path_arg(k, vm)?,
+                _ => cert_path.clone(),
+            };
+
+            // Parse password argument (str, bytes-like, or callable)
+            // Callable passwords are NOT invoked immediately (lazy evaluation)
+            let (password_str, password_callable) =
+                Self::parse_password_argument(&args.password, vm)?;
+
+            // Validate immediate password length (limit: PEM_BUFSIZE = 1024 bytes)
+            if let Some(ref pwd) = password_str
+                && pwd.len() > PEM_BUFSIZE
+            {
+                return Err(vm.new_value_error(format!(
+                    "password cannot be longer than {PEM_BUFSIZE} bytes",
+                )));
+            }
+
+            // First attempt: Load with immediate password (or None if callable)
+            let mut result =
+                cert::load_cert_chain_from_file(&cert_path, &key_path, password_str.as_deref());
+
+            // If failed and callable exists, invoke it and retry
+            // This implements lazy evaluation: callable only invoked if password is actually needed
+            if result.is_err()
+                && let Some(callable) = password_callable
+            {
+                // Invoke callable - exceptions propagate naturally
+                let pwd_result = callable.call((), vm)?;
+
+                // Convert callable result to string
+                let password_from_callable = if let Ok(pwd_str) =
+                    PyStrRef::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(),
+                        )
+                    })?
+                } else {
+                    return Err(vm.new_type_error(
+                        "password callback must return a string or bytes".to_owned(),
+                    ));
+                };
+
+                // Validate callable password length
+                if password_from_callable.len() > PEM_BUFSIZE {
+                    return Err(vm.new_value_error(format!(
+                        "password cannot be longer than {PEM_BUFSIZE} bytes",
+                    )));
+                }
+
+                // Retry with callable password
+                result = cert::load_cert_chain_from_file(
+                    &cert_path,
+                    &key_path,
+                    Some(&password_from_callable),
+                );
+            }
+
+            // Process result
+            let (certs, key) = result.map_err(|e| {
+                // Try to downcast to io::Error to preserve errno information
+                if let Ok(io_err) = e.downcast::<std::io::Error>() {
+                    match io_err.kind() {
+                        // File access errors (NotFound, PermissionDenied) - preserve errno
+                        std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {
+                            io_err.into_pyexception(vm)
+                        }
+                        // Other io::Error types
+                        std::io::ErrorKind::Other => {
+                            let msg = io_err.to_string();
+                            if msg.contains("Failed to decrypt") || msg.contains("wrong password") {
+                                // Wrong password error
+                                vm.new_os_subtype_error(
+                                    PySSLError::class(&vm.ctx).to_owned(),
+                                    None,
+                                    msg,
+                                )
+                                .upcast()
+                            } else {
+                                // [SSL] PEM lib
+                                super::compat::SslError::create_ssl_error_with_reason(
+                                    vm,
+                                    Some("SSL"),
+                                    "",
+                                    "PEM lib",
+                                )
+                            }
+                        }
+                        // PEM parsing errors - [SSL] PEM lib
+                        _ => super::compat::SslError::create_ssl_error_with_reason(
+                            vm,
+                            Some("SSL"),
+                            "",
+                            "PEM lib",
+                        ),
+                    }
+                } else {
+                    // Unknown error type - [SSL] PEM lib
+                    super::compat::SslError::create_ssl_error_with_reason(
+                        vm,
+                        Some("SSL"),
+                        "",
+                        "PEM lib",
+                    )
+                }
+            })?;
+
+            // Validate certificate and key match
+            cert::validate_cert_key_match(&certs, &key).map_err(|e| {
+                let msg = if e.contains("key values mismatch") {
+                    "[SSL: KEY_VALUES_MISMATCH] key values mismatch".to_owned()
+                } else {
+                    e
+                };
+                vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), Some(0), msg)
+                    .upcast()
+            })?;
+
+            // Auto-build certificate chain: if only leaf cert is in file, try to add CA certs
+            // This matches OpenSSL behavior where it automatically includes intermediate/CA certs
+            let mut full_chain = certs.clone();
+            if full_chain.len() == 1 {
+                // Only have leaf cert, try to build chain from CA certs
+                let ca_certs_der = self.ca_certs_der.read();
+                if !ca_certs_der.is_empty() {
+                    // Use build_verified_chain to construct full chain
+                    let chain_result = cert::build_verified_chain(&full_chain, &ca_certs_der);
+                    if chain_result.len() > 1 {
+                        // Successfully built a longer chain
+                        full_chain = chain_result.into_iter().map(CertificateDer::from).collect();
+                    }
+                }
+            }
+
+            // Additional validation: Create CertifiedKey to ensure rustls accepts it
+            let signing_key =
+                rustls::crypto::aws_lc_rs::sign::any_supported_type(&key).map_err(|_| {
+                    vm.new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "[SSL: KEY_VALUES_MISMATCH] key values mismatch",
+                    )
+                    .upcast()
+                })?;
+
+            let certified_key = CertifiedKey::new(full_chain.clone(), signing_key);
+            if certified_key.keys_match().is_err() {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "[SSL: KEY_VALUES_MISMATCH] key values mismatch",
+                    )
+                    .upcast());
+            }
+
+            // Add cert/key pair to collection (OpenSSL allows multiple cert/key pairs)
+            // Store both CertifiedKey (for server) and PrivateKeyDer (for client mTLS)
+            let cert_der = &full_chain[0];
+            let mut cert_keys = self.cert_keys.write();
+
+            // Remove any existing cert/key pair with the same certificate
+            // (This allows updating cert/key pair without duplicating)
+            cert_keys.retain(|(existing, _)| &existing.cert[0] != cert_der);
+
+            // Add new cert/key pair as tuple
+            cert_keys.push((Arc::new(certified_key), key));
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn load_verify_locations(
+            &self,
+            args: LoadVerifyLocationsArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Check that at least one argument is provided
+            let has_cafile = matches!(&args.cafile, OptionalArg::Present(Some(_)));
+            let has_capath = matches!(&args.capath, OptionalArg::Present(Some(_)));
+            let has_cadata = matches!(&args.cadata, OptionalArg::Present(obj) if !vm.is_none(obj));
+
+            if !has_cafile && !has_capath && !has_cadata {
+                return Err(
+                    vm.new_type_error("cafile, capath and cadata cannot be all omitted".to_owned())
+                );
+            }
+
+            // Parse arguments BEFORE acquiring locks to reduce lock scope
+            let cafile_path = if let OptionalArg::Present(Some(ref cafile_obj)) = args.cafile {
+                Some(Self::parse_path_arg(cafile_obj, vm)?)
+            } else {
+                None
+            };
+
+            let capath_dir = if let OptionalArg::Present(Some(ref capath_obj)) = args.capath {
+                Some(Self::parse_path_arg(capath_obj, vm)?)
+            } else {
+                None
+            };
+
+            let cadata_parsed = if let OptionalArg::Present(ref cadata_obj) = args.cadata
+                && !vm.is_none(cadata_obj)
+            {
+                let is_string = PyStrRef::try_from_object(vm, cadata_obj.clone()).is_ok();
+                let data_vec = self.parse_cadata_arg(cadata_obj, vm)?;
+                Some((data_vec, is_string))
+            } else {
+                None
+            };
+
+            // Check for CRL before acquiring main locks
+            let (crl_opt, cafile_is_crl) = if let Some(ref path) = cafile_path {
+                let crl = self.load_crl_from_file(path, vm)?;
+                let is_crl = crl.is_some();
+                (crl, is_crl)
+            } else {
+                (None, false)
+            };
+
+            // If it's a CRL, just add it (separate lock, no conflict with root_store)
+            if let Some(crl) = crl_opt {
+                self.crls.write().push(crl);
+            }
+
+            // Now acquire write locks for certificate loading
+            let mut root_store = self.root_certs.write();
+            let mut ca_certs_der = self.ca_certs_der.write();
+
+            // Load from file (if not CRL)
+            if let Some(ref path) = cafile_path
+                && !cafile_is_crl
+            {
+                // Not a CRL, load as certificate
+                let stats =
+                    self.load_certs_from_file_helper(&mut root_store, &mut ca_certs_der, path, vm)?;
+                self.update_cert_stats(stats);
+            }
+
+            // Load from directory (don't add to ca_certs_der)
+            if let Some(ref dir_path) = capath_dir {
+                let stats = self.load_certs_from_dir_helper(&mut root_store, dir_path, vm)?;
+                self.update_cert_stats(stats);
+            }
+
+            // Load from bytes or str
+            if let Some((ref data_vec, is_string)) = cadata_parsed {
+                let stats = self.load_certs_from_bytes_helper(
+                    &mut root_store,
+                    &mut ca_certs_der,
+                    data_vec,
+                    is_string, // PEM only for strings
+                    vm,
+                )?;
+                self.update_cert_stats(stats);
+            }
+
+            Ok(())
+        }
+
+        /// Helper: Get path from Python's os.environ
+        fn get_env_path(
+            environ: &PyObject,
+            var_name: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<String> {
+            let path_obj = environ.get_item(var_name, vm)?;
+            path_obj.try_into_value(vm)
+        }
+
+        /// Helper: Try to load certificates from Python's os.environ variables
+        ///
+        /// Returns true if certificates were successfully loaded.
+        ///
+        /// We use Python's os.environ instead of Rust's std::env
+        /// because Python code can modify os.environ at runtime (e.g.,
+        /// `os.environ['SSL_CERT_FILE'] = '/path'`), but rustls-native-certs uses
+        /// std::env which only sees the process environment at startup.
+        fn try_load_from_python_environ(
+            &self,
+            loader: &mut cert::CertLoader<'_>,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            use std::path::Path;
+
+            let os_module = vm.import("os", 0)?;
+            let environ = os_module.get_attr("environ", vm)?;
+
+            // Try SSL_CERT_FILE first
+            if let Ok(cert_file) = Self::get_env_path(&environ, "SSL_CERT_FILE", vm)
+                && Path::new(&cert_file).exists()
+                && let Ok(stats) = loader.load_from_file(&cert_file)
+            {
+                self.update_cert_stats(stats);
+                return Ok(true);
+            }
+
+            // Try SSL_CERT_DIR (only if SSL_CERT_FILE didn't work)
+            if let Ok(cert_dir) = Self::get_env_path(&environ, "SSL_CERT_DIR", vm)
+                && Path::new(&cert_dir).is_dir()
+                && let Ok(stats) = loader.load_from_dir(&cert_dir)
+            {
+                self.update_cert_stats(stats);
+                return Ok(true);
+            }
+
+            Ok(false)
+        }
+
+        /// Helper: Load system certificates using rustls-native-certs
+        ///
+        /// This uses platform-specific methods:
+        /// - Linux: openssl-probe to find certificate files
+        /// - macOS: Keychain API
+        /// - Windows: System certificate store (ROOT + CA stores)
+        fn load_system_certificates(
+            &self,
+            store: &mut rustls::RootCertStore,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            #[cfg(windows)]
+            {
+                // Windows: Use schannel to load from both ROOT and CA stores
+                use schannel::cert_store::CertStore;
+
+                let store_names = ["ROOT", "CA"];
+                let open_fns = [CertStore::open_current_user, CertStore::open_local_machine];
+
+                for store_name in store_names {
+                    for open_fn in &open_fns {
+                        if let Ok(cert_store) = open_fn(store_name) {
+                            for cert_ctx in cert_store.certs() {
+                                let der_bytes = cert_ctx.to_der();
+                                let cert =
+                                    rustls::pki_types::CertificateDer::from(der_bytes.to_vec());
+                                let is_ca = cert::is_ca_certificate(cert.as_ref());
+                                if store.add(cert).is_ok() {
+                                    *self.x509_cert_count.write() += 1;
+                                    if is_ca {
+                                        *self.ca_cert_count.write() += 1;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if *self.x509_cert_count.read() == 0 {
+                    return Err(vm.new_os_error("Failed to load certificates from Windows store"));
+                }
+
+                Ok(())
+            }
+
+            #[cfg(not(windows))]
+            {
+                let result = rustls_native_certs::load_native_certs();
+
+                // Load successfully found certificates
+                for cert in result.certs {
+                    let is_ca = cert::is_ca_certificate(cert.as_ref());
+                    if store.add(cert).is_ok() {
+                        *self.x509_cert_count.write() += 1;
+                        if is_ca {
+                            *self.ca_cert_count.write() += 1;
+                        }
+                    }
+                }
+
+                // If there were errors but some certs loaded, just continue
+                // If NO certs loaded and there were errors, report the first error
+                if *self.x509_cert_count.read() == 0 && !result.errors.is_empty() {
+                    return Err(vm.new_os_error(format!(
+                        "Failed to load native certificates: {}",
+                        result.errors[0]
+                    )));
+                }
+
+                Ok(())
+            }
+        }
+
+        #[pymethod]
+        fn load_default_certs(
+            &self,
+            _purpose: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let mut store = self.root_certs.write();
+
+            #[cfg(windows)]
+            {
+                // Windows: Load system certificates first, then additionally load from env
+                // see: test_load_default_certs_env_windows
+                let _ = self.load_system_certificates(&mut store, vm);
+
+                let mut lazy_ca_certs = Vec::new();
+                let mut loader = cert::CertLoader::new(&mut store, &mut lazy_ca_certs);
+                let _ = self.try_load_from_python_environ(&mut loader, vm)?;
+            }
+
+            #[cfg(not(windows))]
+            {
+                // Non-Windows: Try env vars first; only fallback to system certs if not set
+                // see: test_load_default_certs_env
+                let mut lazy_ca_certs = Vec::new();
+                let mut loader = cert::CertLoader::new(&mut store, &mut lazy_ca_certs);
+                let loaded = self.try_load_from_python_environ(&mut loader, vm)?;
+
+                if !loaded {
+                    let _ = self.load_system_certificates(&mut store, vm);
+                }
+            }
+
+            // If no certificates were loaded from system, fallback to webpki-roots (Mozilla CA bundle)
+            // This ensures we always have some trusted root certificates even if system cert loading fails
+            if *self.x509_cert_count.read() == 0 {
+                use webpki_roots;
+
+                // webpki_roots provides TLS_SERVER_ROOTS as &[TrustAnchor]
+                // We can use extend() to add them to the RootCertStore
+                let webpki_count = webpki_roots::TLS_SERVER_ROOTS.len();
+                store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
+
+                *self.x509_cert_count.write() += webpki_count;
+                *self.ca_cert_count.write() += webpki_count;
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_alpn_protocols(&self, protocols: PyListRef, vm: &VirtualMachine) -> PyResult<()> {
+            let mut alpn_list = Vec::new();
+            for item in protocols.borrow_vec().iter() {
+                let bytes = ArgBytesLike::try_from_object(vm, item.clone())?;
+                alpn_list.push(bytes.borrow_buf().to_vec());
+            }
+            *self.alpn_protocols.write() = alpn_list;
+            Ok(())
+        }
+
+        #[pymethod]
+        fn _set_alpn_protocols(&self, protos: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
+            let bytes = protos.borrow_buf();
+            let alpn_list = parse_length_prefixed_alpn(&bytes, vm)?;
+            *self.alpn_protocols.write() = alpn_list;
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_ciphers(&self, ciphers: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+            let cipher_str = ciphers.as_str();
+
+            // Parse cipher string and store selected ciphers
+            let selected_ciphers = parse_cipher_string(cipher_str).map_err(|e| {
+                vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), None, e)
+                    .upcast()
+            })?;
+
+            // Store in context
+            *self.selected_ciphers.write() = Some(selected_ciphers);
+
+            Ok(())
+        }
+
+        #[pymethod]
+        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()
+                .map(|suite| {
+                    // Extract cipher information using unified helper
+                    let cipher_info = extract_cipher_info(suite);
+
+                    // Convert to OpenSSL-style name
+                    // e.g., "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" -> "ECDHE-RSA-AES128-GCM-SHA256"
+                    let openssl_name = normalize_cipher_name(&cipher_info.name);
+
+                    // Determine key exchange and auth methods
+                    let (kx, auth) = if cipher_info.protocol == "TLSv1.3" {
+                        // TLS 1.3 doesn't distinguish - all use modern algos
+                        ("any", "any")
+                    } else if cipher_info.name.contains("ECDHE") {
+                        // TLS 1.2 with ECDHE
+                        let auth = if cipher_info.name.contains("ECDSA") {
+                            "ECDSA"
+                        } else if cipher_info.name.contains("RSA") {
+                            "RSA"
+                        } else {
+                            "any"
+                        };
+                        ("ECDH", auth)
+                    } else {
+                        ("any", "any")
+                    };
+
+                    // Build description string
+                    // Format: "{name} {protocol} Kx={kx} Au={auth} Enc={enc} Mac={mac}"
+                    let enc = get_cipher_encryption_desc(&openssl_name);
+
+                    let description = format!(
+                        "{} {} Kx={} Au={} Enc={} Mac=AEAD",
+                        openssl_name, cipher_info.protocol, kx, auth, enc
+                    );
+
+                    // Create cipher dict
+                    let dict = vm.ctx.new_dict();
+                    dict.set_item("name", vm.ctx.new_str(openssl_name).into(), vm)
+                        .unwrap();
+                    dict.set_item("protocol", vm.ctx.new_str(cipher_info.protocol).into(), vm)
+                        .unwrap();
+                    dict.set_item("id", vm.ctx.new_int(0).into(), vm).unwrap(); // Placeholder ID
+                    dict.set_item("strength_bits", vm.ctx.new_int(cipher_info.bits).into(), vm)
+                        .unwrap();
+                    dict.set_item("alg_bits", vm.ctx.new_int(cipher_info.bits).into(), vm)
+                        .unwrap();
+                    dict.set_item("description", vm.ctx.new_str(description).into(), vm)
+                        .unwrap();
+                    dict.into()
+                })
+                .collect::<Vec<_>>();
+
+            Ok(PyListRef::from(vm.ctx.new_list(cipher_list)))
+        }
+
+        #[pymethod]
+        fn set_default_verify_paths(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Just call load_default_certs
+            self.load_default_certs(OptionalArg::Missing, vm)
+        }
+
+        #[pymethod]
+        fn cert_store_stats(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // Use the certificate counters that are updated in load_verify_locations
+            let x509_count = *self.x509_cert_count.read() as i32;
+            let ca_count = *self.ca_cert_count.read() as i32;
+
+            let dict = vm.ctx.new_dict();
+            dict.set_item("x509", vm.ctx.new_int(x509_count).into(), vm)?;
+            dict.set_item("crl", vm.ctx.new_int(0).into(), vm)?; // CRL not supported
+            dict.set_item("x509_ca", vm.ctx.new_int(ca_count).into(), vm)?;
+            Ok(dict.into())
+        }
+
+        #[pymethod]
+        fn session_stats(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // Return session statistics
+            // NOTE: This is a partial implementation - rustls doesn't expose all OpenSSL stats
+            let dict = vm.ctx.new_dict();
+
+            // Number of sessions currently in the cache
+            let session_count = self.client_session_cache.read().len() as i32;
+            dict.set_item("number", vm.ctx.new_int(session_count).into(), vm)?;
+
+            // Client-side statistics (not tracked separately in this implementation)
+            dict.set_item("connect", vm.ctx.new_int(0).into(), vm)?;
+            dict.set_item("connect_good", vm.ctx.new_int(0).into(), vm)?;
+            dict.set_item("connect_renegotiate", vm.ctx.new_int(0).into(), vm)?; // rustls doesn't support renegotiation
+
+            // Server-side statistics
+            let accept_count = self.accept_count.load(Ordering::SeqCst) as i32;
+            dict.set_item("accept", vm.ctx.new_int(accept_count).into(), vm)?;
+            dict.set_item("accept_good", vm.ctx.new_int(accept_count).into(), vm)?; // Assume all accepts are good
+            dict.set_item("accept_renegotiate", vm.ctx.new_int(0).into(), vm)?; // rustls doesn't support renegotiation
+
+            // Session reuse statistics
+            let hits = self.session_hits.load(Ordering::SeqCst) as i32;
+            dict.set_item("hits", vm.ctx.new_int(hits).into(), vm)?;
+
+            // Misses, timeouts, and cache_full are not tracked in this implementation
+            dict.set_item("misses", vm.ctx.new_int(0).into(), vm)?;
+            dict.set_item("timeouts", vm.ctx.new_int(0).into(), vm)?;
+            dict.set_item("cache_full", vm.ctx.new_int(0).into(), vm)?;
+
+            Ok(dict.into())
+        }
+
+        #[pygetset]
+        fn sni_callback(&self) -> Option<PyObjectRef> {
+            self.sni_callback.read().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set_sni_callback(
+            &self,
+            callback: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Validate callback is callable or None
+            if let Some(ref cb) = callback
+                && !cb.is(vm.ctx.types.none_type)
+                && !cb.is_callable()
+            {
+                return Err(vm.new_type_error("sni_callback must be callable or None"));
+            }
+            *self.sni_callback.write() = callback;
+            Ok(())
+        }
+
+        #[pymethod]
+        fn set_servername_callback(
+            &self,
+            callback: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Alias for set_sni_callback
+            self.set_sni_callback(callback, vm)
+        }
+
+        #[pygetset]
+        fn security_level(&self) -> i32 {
+            // rustls uses a fixed security level
+            // Return 2 which is a reasonable default (equivalent to OpenSSL 1.1.0+ level 2)
+            2
+        }
+
+        #[pygetset]
+        fn _msg_callback(&self) -> Option<PyObjectRef> {
+            self.msg_callback.read().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set__msg_callback(
+            &self,
+            callback: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Validate callback is callable or None
+            if let Some(ref cb) = callback
+                && !cb.is(vm.ctx.types.none_type)
+                && !cb.is_callable()
+            {
+                return Err(vm.new_type_error("msg_callback must be callable or None"));
+            }
+            *self.msg_callback.write() = callback;
+            Ok(())
+        }
+
+        #[pymethod]
+        fn get_ca_certs(&self, args: GetCertArgs, vm: &VirtualMachine) -> PyResult<PyListRef> {
+            let binary_form = args.binary_form.unwrap_or(false);
+            let ca_certs_der = self.ca_certs_der.read();
+
+            let mut certs = Vec::new();
+            for cert_der in ca_certs_der.iter() {
+                // Parse certificate to check if it's a CA and get info
+                match x509_parser::parse_x509_certificate(cert_der) {
+                    Ok((_, cert)) => {
+                        // Check if this is a CA certificate (BasicConstraints: CA=TRUE)
+                        let is_ca = if let Ok(Some(bc_ext)) = cert.basic_constraints() {
+                            bc_ext.value.ca
+                        } else {
+                            false
+                        };
+
+                        // Only include CA certificates
+                        if !is_ca {
+                            continue;
+                        }
+
+                        if binary_form {
+                            // Return DER-encoded certificate as bytes
+                            certs.push(vm.ctx.new_bytes(cert_der.clone()).into());
+                        } else {
+                            // Return certificate as dict (use helper from _test_decode_cert)
+                            let dict = self.cert_der_to_dict(vm, cert_der)?;
+                            certs.push(dict);
+                        }
+                    }
+                    Err(_) => {
+                        // Skip invalid certificates
+                        continue;
+                    }
+                }
+            }
+
+            Ok(PyListRef::from(vm.ctx.new_list(certs)))
+        }
+
+        #[pymethod]
+        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()));
+            }
+
+            // Validate filepath is str or bytes
+            let path_str = if let Ok(s) = PyStrRef::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()))?
+            } else {
+                return Err(vm.new_type_error("DH params filepath must be str or bytes".to_owned()));
+            };
+
+            // Check if file exists
+            if !std::path::Path::new(&path_str).exists() {
+                // Create FileNotFoundError with errno=ENOENT (2)
+                let exc = vm.new_os_subtype_error(
+                    vm.ctx.exceptions.file_not_found_error.to_owned(),
+                    Some(2), // errno = ENOENT (2)
+                    "No such file or directory",
+                );
+                // Set filename attribute
+                let _ = exc
+                    .as_object()
+                    .set_attr("filename", vm.ctx.new_str(path_str.clone()), vm);
+                return Err(exc.upcast());
+            }
+
+            // Validate that the file contains DH parameters
+            // Read the file and check for DH PARAMETERS header
+            let contents =
+                std::fs::read_to_string(&path_str).map_err(|e| vm.new_os_error(e.to_string()))?;
+
+            if !contents.contains("BEGIN DH PARAMETERS")
+                && !contents.contains("BEGIN X9.42 DH PARAMETERS")
+            {
+                // File exists but doesn't contain DH parameters - raise SSLError
+                // [PEM: NO_START_LINE] no start line
+                return Err(super::compat::SslError::create_ssl_error_with_reason(
+                    vm,
+                    Some("PEM"),
+                    "NO_START_LINE",
+                    "[PEM: NO_START_LINE] no start line",
+                ));
+            }
+
+            // rustls doesn't use DH parameters (it uses ECDHE for key exchange)
+            // This is a no-op for compatibility with OpenSSL-based code
+            Ok(())
+        }
+
+        #[pymethod]
+        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()));
+            }
+
+            // Validate name is str or bytes
+            let curve_name = if let Ok(s) = PyStrRef::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()))?
+            } else {
+                return Err(vm.new_type_error("ECDH curve name must be str or bytes".to_owned()));
+            };
+
+            // Validate curve name (common curves for compatibility)
+            // rustls supports: X25519, secp256r1 (prime256v1), secp384r1
+            let valid_curves = [
+                "prime256v1",
+                "secp256r1",
+                "prime384v1",
+                "secp384r1",
+                "prime521v1",
+                "secp521r1",
+                "X25519",
+                "x25519",
+                "x448", // For future compatibility
+            ];
+
+            if !valid_curves.contains(&curve_name.as_str()) {
+                return Err(vm.new_value_error(format!("unknown curve name '{curve_name}'")));
+            }
+
+            // Store the curve name to be used during handshake
+            // This will limit the key exchange groups offered/accepted
+            *self.ecdh_curve.write() = Some(curve_name);
+            Ok(())
+        }
+
+        #[pymethod]
+        fn _wrap_socket(
+            zelf: PyRef<Self>,
+            args: WrapSocketArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyRef<PySSLSocket>> {
+            // Convert server_hostname to Option<String>
+            // Handle both missing argument and None value
+            let hostname = match args.server_hostname.into_option().flatten() {
+                Some(hostname_str) => {
+                    let hostname = hostname_str.as_str();
+
+                    // Validate hostname
+                    if hostname.is_empty() {
+                        return Err(vm.new_value_error("server_hostname cannot be an empty string"));
+                    }
+
+                    // Check if it starts with a dot
+                    if hostname.starts_with('.') {
+                        return Err(vm.new_value_error("server_hostname cannot start with a dot"));
+                    }
+
+                    // IP addresses are allowed
+                    // SNI will not be sent for IP addresses
+
+                    // Check for NULL bytes
+                    if hostname.contains('\0') {
+                        return Err(vm.new_type_error("embedded null character"));
+                    }
+
+                    Some(hostname.to_string())
+                }
+                None => None,
+            };
+
+            // Validate socket type and context protocol
+            if args.server_side && zelf.protocol == PROTOCOL_TLS_CLIENT {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context",
+                    )
+                    .upcast());
+            }
+            if !args.server_side && zelf.protocol == PROTOCOL_TLS_SERVER {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot create a client socket with a PROTOCOL_TLS_SERVER context",
+                    )
+                    .upcast());
+            }
+
+            // Create _SSLSocket instance
+            let ssl_socket = PySSLSocket {
+                sock: args.sock.clone(),
+                context: PyRwLock::new(zelf),
+                server_side: args.server_side,
+                server_hostname: PyRwLock::new(hostname),
+                connection: PyMutex::new(None),
+                handshake_done: PyMutex::new(false),
+                session_was_reused: PyMutex::new(false),
+                owner: PyRwLock::new(args.owner.into_option()),
+                // Filter out Python None objects - only store actual SSLSession objects
+                session: PyRwLock::new(args.session.into_option().filter(|s| !vm.is_none(s))),
+                verified_chain: PyRwLock::new(None),
+                incoming_bio: None,
+                outgoing_bio: None,
+                sni_state: PyRwLock::new(None),
+                pending_context: PyRwLock::new(None),
+                client_hello_buffer: PyMutex::new(None),
+                shutdown_state: PyMutex::new(ShutdownState::NotStarted),
+                pending_tls_output: PyMutex::new(Vec::new()),
+                deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
+            };
+
+            // Create PyRef with correct type
+            let ssl_socket_ref = ssl_socket
+                .into_ref_with_type(vm, vm.class("_ssl", "_SSLSocket"))
+                .map_err(|_| vm.new_type_error("Failed to create SSLSocket"))?;
+
+            Ok(ssl_socket_ref)
+        }
+
+        #[pymethod]
+        fn _wrap_bio(
+            zelf: PyRef<Self>,
+            args: WrapBioArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyRef<PySSLSocket>> {
+            // Convert server_hostname to Option<String>
+            // Handle both missing argument and None value
+            let hostname = match args.server_hostname.into_option().flatten() {
+                Some(hostname_str) => {
+                    let hostname = hostname_str.as_str();
+                    validate_hostname(hostname, vm)?;
+                    Some(hostname.to_string())
+                }
+                None => None,
+            };
+
+            // Extract server_side value
+            let server_side = args.server_side.unwrap_or(false);
+
+            // Validate socket type and context protocol
+            if server_side && zelf.protocol == PROTOCOL_TLS_CLIENT {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot create a server socket with a PROTOCOL_TLS_CLIENT context",
+                    )
+                    .upcast());
+            }
+            if !server_side && zelf.protocol == PROTOCOL_TLS_SERVER {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "Cannot create a client socket with a PROTOCOL_TLS_SERVER context",
+                    )
+                    .upcast());
+            }
+
+            // Create _SSLSocket instance with BIO mode
+            let ssl_socket = PySSLSocket {
+                sock: vm.ctx.none(), // No socket in BIO mode
+                context: PyRwLock::new(zelf),
+                server_side,
+                server_hostname: PyRwLock::new(hostname),
+                connection: PyMutex::new(None),
+                handshake_done: PyMutex::new(false),
+                session_was_reused: PyMutex::new(false),
+                owner: PyRwLock::new(args.owner.into_option()),
+                // Filter out Python None objects - only store actual SSLSession objects
+                session: PyRwLock::new(args.session.into_option().filter(|s| !vm.is_none(s))),
+                verified_chain: PyRwLock::new(None),
+                incoming_bio: Some(args.incoming),
+                outgoing_bio: Some(args.outgoing),
+                sni_state: PyRwLock::new(None),
+                pending_context: PyRwLock::new(None),
+                client_hello_buffer: PyMutex::new(None),
+                shutdown_state: PyMutex::new(ShutdownState::NotStarted),
+                pending_tls_output: PyMutex::new(Vec::new()),
+                deferred_cert_error: Arc::new(ParkingRwLock::new(None)),
+            };
+
+            let ssl_socket_ref = ssl_socket
+                .into_ref_with_type(vm, vm.class("_ssl", "_SSLSocket"))
+                .map_err(|_| vm.new_type_error("Failed to create SSLSocket"))?;
+
+            Ok(ssl_socket_ref)
+        }
+
+        // Helper functions (private):
+
+        /// Parse path argument (str or bytes) to string
+        fn parse_path_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<String> {
+            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
+                Ok(s.as_str().to_owned())
+            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
+                String::from_utf8(b.borrow_buf().to_vec())
+                    .map_err(|_| vm.new_value_error("path contains invalid UTF-8".to_owned()))
+            } else {
+                Err(vm.new_type_error("path should be a str or bytes".to_owned()))
+            }
+        }
+
+        /// Parse password argument (str, bytes-like, or callable)
+        ///
+        /// Returns (immediate_password, callable) where:
+        /// - immediate_password: Some(string) if password is str/bytes, None if callable
+        /// - callable: Some(PyObjectRef) if password is callable, None otherwise
+        fn parse_password_argument(
+            password: &OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> 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()) {
+                        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()),
+                        )?;
+                        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(),
+                        ))
+                    }
+                }
+                _ => Ok((None, None)),
+            }
+        }
+
+        /// Helper: Load certificates from file into existing store
+        fn load_certs_from_file_helper(
+            &self,
+            root_store: &mut RootCertStore,
+            ca_certs_der: &mut Vec<Vec<u8>>,
+            path: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<cert::CertStats> {
+            let mut loader = cert::CertLoader::new(root_store, ca_certs_der);
+            loader.load_from_file(path).map_err(|e| {
+                // Preserve errno for file access errors (NotFound, PermissionDenied)
+                match e.kind() {
+                    std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {
+                        e.into_pyexception(vm)
+                    }
+                    // PEM parsing errors
+                    _ => super::compat::SslError::create_ssl_error_with_reason(
+                        vm,
+                        Some("X509"),
+                        "",
+                        "PEM lib",
+                    ),
+                }
+            })
+        }
+
+        /// Helper: Load certificates from directory into existing store
+        fn load_certs_from_dir_helper(
+            &self,
+            root_store: &mut RootCertStore,
+            path: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<cert::CertStats> {
+            // Load certs and store them in capath_certs_der for lazy loading simulation
+            // (CPython only returns these in get_ca_certs() after they're used in handshake)
+            let mut capath_certs = Vec::new();
+            let mut loader = cert::CertLoader::new(root_store, &mut capath_certs);
+            let stats = loader
+                .load_from_dir(path)
+                .map_err(|e| e.into_pyexception(vm))?;
+
+            // Store loaded certs for potential tracking after handshake
+            *self.capath_certs_der.write() = capath_certs;
+
+            Ok(stats)
+        }
+
+        /// Helper: Load certificates from bytes into existing store
+        fn load_certs_from_bytes_helper(
+            &self,
+            root_store: &mut RootCertStore,
+            ca_certs_der: &mut Vec<Vec<u8>>,
+            data: &[u8],
+            pem_only: bool,
+            vm: &VirtualMachine,
+        ) -> PyResult<cert::CertStats> {
+            let mut loader = cert::CertLoader::new(root_store, ca_certs_der);
+            // treat_all_as_ca=true: CPython counts all certificates loaded via cadata as CA certs
+            // regardless of their Basic Constraints extension
+            // pem_only=true for string input
+            loader
+                .load_from_bytes_ex(data, true, pem_only)
+                .map_err(|e| {
+                    // Preserve specific error messages from cert.rs
+                    let err_msg = e.to_string();
+                    if err_msg.contains("no start line") {
+                        vm.new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            "no start line: cadata does not contain a certificate",
+                        )
+                        .upcast()
+                    } else if err_msg.contains("not enough data") {
+                        vm.new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            "not enough data: cadata does not contain a certificate",
+                        )
+                        .upcast()
+                    } else {
+                        vm.new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            err_msg,
+                        )
+                        .upcast()
+                    }
+                })
+        }
+
+        /// Helper: Try to parse data as CRL (PEM or DER format)
+        fn try_parse_crl(
+            &self,
+            data: &[u8],
+        ) -> Result<CertificateRevocationListDer<'static>, String> {
+            // Try PEM format first
+            let mut cursor = std::io::Cursor::new(data);
+            let mut crl_iter = rustls_pemfile::crls(&mut cursor);
+            if let Some(Ok(crl)) = crl_iter.next() {
+                return Ok(crl);
+            }
+
+            // Try DER format
+            // Basic validation: CRL should start with SEQUENCE tag (0x30)
+            if !data.is_empty() && data[0] == 0x30 {
+                return Ok(CertificateRevocationListDer::from(data.to_vec()));
+            }
+
+            Err("Not a valid CRL file".to_string())
+        }
+
+        /// Helper: Load CRL from file
+        fn load_crl_from_file(
+            &self,
+            path: &str,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<CertificateRevocationListDer<'static>>> {
+            let data = std::fs::read(path).map_err(|e| match e.kind() {
+                std::io::ErrorKind::NotFound | std::io::ErrorKind::PermissionDenied => {
+                    e.into_pyexception(vm)
+                }
+                _ => vm.new_os_error(e.to_string()),
+            })?;
+
+            match self.try_parse_crl(&data) {
+                Ok(crl) => Ok(Some(crl)),
+                Err(_) => Ok(None), // Not a CRL file, might be a cert file
+            }
+        }
+
+        /// Helper: Parse cadata argument (str or bytes)
+        fn parse_cadata_arg(&self, arg: &PyObject, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+            if let Ok(s) = PyStrRef::try_from_object(vm, arg.to_owned()) {
+                Ok(s.as_str().as_bytes().to_vec())
+            } else if let Ok(b) = ArgBytesLike::try_from_object(vm, arg.to_owned()) {
+                Ok(b.borrow_buf().to_vec())
+            } else {
+                Err(vm.new_type_error("cadata should be a str or bytes".to_owned()))
+            }
+        }
+
+        /// Helper: Update certificate statistics
+        fn update_cert_stats(&self, stats: cert::CertStats) {
+            *self.x509_cert_count.write() += stats.total_certs;
+            *self.ca_cert_count.write() += stats.ca_certs;
+        }
+    }
+
+    impl Constructor for PySSLContext {
+        type Args = (i32,);
+
+        fn py_new(
+            _cls: &Py<PyType>,
+            (protocol,): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            // Validate protocol
+            match protocol {
+                PROTOCOL_TLS | PROTOCOL_TLS_CLIENT | PROTOCOL_TLS_SERVER | PROTOCOL_TLSv1_2
+                | PROTOCOL_TLSv1_3 => {
+                    // Valid protocols
+                }
+                PROTOCOL_TLSv1 | PROTOCOL_TLSv1_1 => {
+                    return Err(vm.new_value_error(
+                        "TLS 1.0 and 1.1 are not supported by rustls for security reasons",
+                    ));
+                }
+                _ => {
+                    return Err(vm.new_value_error(format!("invalid protocol version: {protocol}")));
+                }
+            }
+
+            // Set default options
+            // OP_ALL | OP_NO_SSLv2 | OP_NO_SSLv3 | OP_NO_COMPRESSION |
+            // OP_CIPHER_SERVER_PREFERENCE | OP_SINGLE_DH_USE | OP_SINGLE_ECDH_USE |
+            // OP_ENABLE_MIDDLEBOX_COMPAT
+            let default_options = OP_ALL
+                | OP_NO_SSLv2
+                | OP_NO_SSLv3
+                | OP_NO_COMPRESSION
+                | OP_CIPHER_SERVER_PREFERENCE
+                | OP_SINGLE_DH_USE
+                | OP_SINGLE_ECDH_USE
+                | OP_ENABLE_MIDDLEBOX_COMPAT;
+
+            // Set default verify_mode based on protocol
+            // PROTOCOL_TLS_CLIENT defaults to CERT_REQUIRED
+            // PROTOCOL_TLS_SERVER defaults to CERT_NONE
+            let default_verify_mode = if protocol == PROTOCOL_TLS_CLIENT {
+                CERT_REQUIRED
+            } else {
+                CERT_NONE
+            };
+
+            // Set default verify_flags based on protocol
+            // Both PROTOCOL_TLS_CLIENT and PROTOCOL_TLS_SERVER only set VERIFY_X509_TRUSTED_FIRST
+            // Note: VERIFY_X509_PARTIAL_CHAIN and VERIFY_X509_STRICT are NOT set here
+            // - they're only added by create_default_context() in Python's ssl.py
+            let default_verify_flags = VERIFY_DEFAULT | VERIFY_X509_TRUSTED_FIRST;
+
+            // Set minimum and maximum protocol versions based on protocol constant
+            // specific protocol versions fix both min and max
+            let (min_version, max_version) = match protocol {
+                PROTOCOL_TLSv1_2 => (PROTO_TLSv1_2, PROTO_TLSv1_2), // Only TLS 1.2
+                PROTOCOL_TLSv1_3 => (PROTO_TLSv1_3, PROTO_TLSv1_3), // Only TLS 1.3
+                _ => (PROTO_MINIMUM_SUPPORTED, PROTO_MAXIMUM_SUPPORTED), // Auto-negotiate
+            };
+
+            // IMPORTANT: Create shared session cache BEFORE PySSLContext
+            // Both client_session_cache and PythonClientSessionStore.session_cache
+            // MUST point to the same HashMap to ensure Python-level and Rustls-level
+            // sessions are synchronized
+            let shared_session_cache = Arc::new(ParkingRwLock::new(HashMap::new()));
+            let rustls_client_store = Arc::new(PythonClientSessionStore {
+                inner: Arc::new(rustls::client::ClientSessionMemoryCache::new(
+                    SSL_SESSION_CACHE_SIZE,
+                )),
+                session_cache: shared_session_cache.clone(),
+            });
+
+            Ok(PySSLContext {
+                protocol,
+                check_hostname: PyRwLock::new(protocol == PROTOCOL_TLS_CLIENT),
+                verify_mode: PyRwLock::new(default_verify_mode),
+                verify_flags: PyRwLock::new(default_verify_flags),
+                client_config: PyRwLock::new(None),
+                server_config: PyRwLock::new(None),
+                root_certs: PyRwLock::new(RootCertStore::empty()),
+                ca_certs_der: PyRwLock::new(Vec::new()),
+                capath_certs_der: PyRwLock::new(Vec::new()),
+                crls: PyRwLock::new(Vec::new()),
+                cert_keys: PyRwLock::new(Vec::new()),
+                options: PyRwLock::new(default_options),
+                alpn_protocols: PyRwLock::new(Vec::new()),
+                require_alpn_match: PyRwLock::new(false),
+                post_handshake_auth: PyRwLock::new(false),
+                num_tickets: PyRwLock::new(2), // TLS 1.3 default
+                minimum_version: PyRwLock::new(min_version),
+                maximum_version: PyRwLock::new(max_version),
+                sni_callback: PyRwLock::new(None),
+                msg_callback: PyRwLock::new(None),
+                ecdh_curve: PyRwLock::new(None),
+                ca_cert_count: PyRwLock::new(0),
+                x509_cert_count: PyRwLock::new(0),
+                // Use the shared cache created above
+                client_session_cache: shared_session_cache,
+                rustls_session_store: rustls_client_store,
+                rustls_server_session_store: rustls::server::ServerSessionMemoryCache::new(
+                    SSL_SESSION_CACHE_SIZE,
+                ),
+                server_ticketer: rustls::crypto::aws_lc_rs::Ticketer::new()
+                    .expect("Failed to create shared ticketer for TLS 1.2 session resumption"),
+                accept_count: AtomicUsize::new(0),
+                session_hits: AtomicUsize::new(0),
+                selected_ciphers: PyRwLock::new(None),
+            })
+        }
+    }
+
+    // SSLSocket - represents a TLS-wrapped socket
+    #[pyattr]
+    #[pyclass(name = "_SSLSocket", module = "ssl", traverse)]
+    #[derive(Debug, PyPayload)]
+    pub(crate) struct PySSLSocket {
+        // Underlying socket
+        sock: PyObjectRef,
+        // SSL context
+        context: PyRwLock<PyRef<PySSLContext>>,
+        // Server-side or client-side
+        #[pytraverse(skip)]
+        server_side: bool,
+        // Server hostname for SNI
+        #[pytraverse(skip)]
+        server_hostname: PyRwLock<Option<String>>,
+        // TLS connection state
+        #[pytraverse(skip)]
+        connection: PyMutex<Option<TlsConnection>>,
+        // Handshake completed flag
+        #[pytraverse(skip)]
+        handshake_done: PyMutex<bool>,
+        // Session was reused (for session resumption tracking)
+        #[pytraverse(skip)]
+        session_was_reused: PyMutex<bool>,
+        // Owner (SSLSocket instance that owns this _SSLSocket)
+        owner: PyRwLock<Option<PyObjectRef>>,
+        // Session for resumption
+        session: PyRwLock<Option<PyObjectRef>>,
+        // Verified certificate chain (built during verification)
+        #[allow(dead_code)]
+        #[pytraverse(skip)]
+        verified_chain: PyRwLock<Option<Vec<CertificateDer<'static>>>>,
+        // MemoryBIO mode (optional)
+        incoming_bio: Option<PyRef<PyMemoryBIO>>,
+        outgoing_bio: Option<PyRef<PyMemoryBIO>>,
+        // SNI certificate resolver state (for server-side only)
+        #[pytraverse(skip)]
+        sni_state: PyRwLock<Option<Arc<ParkingMutex<SniCertName>>>>,
+        // Pending context change (for SNI callback deferred handling)
+        pending_context: PyRwLock<Option<PyRef<PySSLContext>>>,
+        // Buffer to store ClientHello for connection recreation
+        #[pytraverse(skip)]
+        client_hello_buffer: PyMutex<Option<Vec<u8>>>,
+        // Shutdown state for tracking close-notify exchange
+        #[pytraverse(skip)]
+        shutdown_state: PyMutex<ShutdownState>,
+        // Pending TLS output buffer for non-blocking sockets
+        // Stores unsent TLS bytes when sock_send() would block
+        // This prevents data loss when write_tls() drains rustls' internal buffer
+        // but the socket cannot accept all the data immediately
+        #[pytraverse(skip)]
+        pub(crate) pending_tls_output: PyMutex<Vec<u8>>,
+        // Deferred client certificate verification error (for TLS 1.3)
+        // Stores error message if client cert verification failed during handshake
+        // Error is raised on first I/O operation after handshake
+        // Using Arc to share with the certificate verifier
+        #[pytraverse(skip)]
+        deferred_cert_error: Arc<ParkingRwLock<Option<String>>>,
+    }
+
+    // Shutdown state for tracking close-notify exchange
+    #[derive(Debug, Clone, Copy, PartialEq)]
+    enum ShutdownState {
+        NotStarted,      // unwrap() not called yet
+        SentCloseNotify, // close-notify sent, waiting for peer's response
+        Completed,       // unwrap() completed successfully
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl PySSLSocket {
+        // Check if this is BIO mode
+        pub(crate) fn is_bio_mode(&self) -> bool {
+            self.incoming_bio.is_some() && self.outgoing_bio.is_some()
+        }
+
+        // Get incoming BIO reference (for EOF checking)
+        pub(crate) fn incoming_bio(&self) -> Option<PyObjectRef> {
+            self.incoming_bio.as_ref().map(|bio| bio.clone().into())
+        }
+
+        // Check for deferred certificate verification errors (TLS 1.3)
+        // If an error exists, raise it and clear it from storage
+        fn check_deferred_cert_error(&self, vm: &VirtualMachine) -> PyResult<()> {
+            let error_opt = self.deferred_cert_error.read().clone();
+            if let Some(error_msg) = error_opt {
+                // Clear the error so it's only raised once
+                *self.deferred_cert_error.write() = None;
+                // Raise OSError with the stored error message
+                return Err(vm.new_os_error(error_msg));
+            }
+            Ok(())
+        }
+
+        // Get socket timeout as Duration
+        pub(crate) fn get_socket_timeout(&self, vm: &VirtualMachine) -> PyResult<Option<Duration>> {
+            if self.is_bio_mode() {
+                return Ok(None);
+            }
+
+            // Get timeout from socket
+            let timeout_obj = self.sock.get_attr("gettimeout", vm)?.call((), vm)?;
+
+            // timeout can be None (blocking), 0.0 (non-blocking), or positive float
+            if vm.is_none(&timeout_obj) {
+                // None means blocking forever
+                Ok(None)
+            } else {
+                let timeout_float: f64 = timeout_obj.try_into_value(vm)?;
+                if timeout_float <= 0.0 {
+                    // 0 means non-blocking
+                    Ok(Some(Duration::from_secs(0)))
+                } else {
+                    // Positive timeout
+                    Ok(Some(Duration::from_secs_f64(timeout_float)))
+                }
+            }
+        }
+
+        // Create and store a session object after successful handshake
+        fn create_session_after_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Only create session for client-side connections
+            if self.server_side {
+                return Ok(());
+            }
+
+            // Check if session already exists
+            let session_opt = self.session.read().clone();
+            if let Some(ref s) = session_opt {
+                if vm.is_none(s) {
+                } else {
+                    return Ok(());
+                }
+            }
+
+            // Get server hostname
+            let server_name = self.server_hostname.read().clone();
+
+            // Try to get session data from context's session cache
+            // IMPORTANT: Acquire and release locks quickly to avoid deadlock
+            let context = self.context.read();
+            let session_cache_arc = context.client_session_cache.clone();
+            drop(context); // Release context lock ASAP
+
+            let (session_id, creation_time, lifetime) = if let Some(ref name) = server_name {
+                let key = name.as_bytes().to_vec();
+
+                // Clone the data we need while holding the lock, then immediately release
+                let session_data_opt = {
+                    let cache_guard = session_cache_arc.read();
+                    cache_guard.get(&key).cloned() // Clone Arc<PyMutex<SessionData>>
+                }; // Lock released here
+
+                if let Some(session_data_arc) = session_data_opt {
+                    let data = session_data_arc.lock();
+                    let result = (data.session_id.clone(), data.creation_time, data.lifetime);
+                    drop(data); // Explicit unlock
+                    result
+                } else {
+                    // Create new session ID if not in cache
+                    let time = std::time::SystemTime::now();
+                    (generate_session_id_from_metadata(name, &time), time, 7200)
+                }
+            } else {
+                // No server name, use defaults
+                let time = std::time::SystemTime::now();
+                (vec![0; 16], time, 7200)
+            };
+
+            // Create a new SSLSession object with real metadata
+            let session = PySSLSession {
+                // Use dummy session data to indicate we have a ticket
+                // TLS 1.2+ always uses session tickets/resumption
+                session_data: vec![1], // Non-empty to indicate has_ticket=True
+                session_id,
+                creation_time,
+                lifetime,
+            };
+
+            let py_session = session.into_pyobject(vm);
+
+            *self.session.write() = Some(py_session);
+
+            Ok(())
+        }
+
+        // Complete handshake and create session
+        /// Track which CA certificate from capath was used to verify peer
+        ///
+        /// This simulates lazy loading behavior: capath certificates
+        /// are only added to get_ca_certs() after they're actually used in a handshake.
+        fn track_used_ca_from_capath(&self) -> Result<(), String> {
+            // Extract capath_certs, releasing context lock quickly
+            let capath_certs = {
+                let context = self.context.read();
+                let certs = context.capath_certs_der.read();
+                if certs.is_empty() {
+                    return Ok(());
+                }
+                certs.clone()
+            };
+
+            // Extract peer certificates, releasing connection lock quickly
+            let top_cert_der = {
+                let conn_guard = self.connection.lock();
+                let conn = conn_guard.as_ref().ok_or("No connection")?;
+                let peer_certs = conn.peer_certificates().ok_or("No peer certificates")?;
+                if peer_certs.is_empty() {
+                    return Ok(());
+                }
+                peer_certs
+                    .iter()
+                    .map(|c| c.as_ref().to_vec())
+                    .next_back()
+                    .expect("is_empty checked above")
+            };
+
+            // Get the top certificate in the chain (closest to root)
+            // Note: Server usually doesn't send the root CA, so we check the last cert's issuer
+            let (_, top_cert) = x509_parser::parse_x509_certificate(&top_cert_der)
+                .map_err(|e| format!("Failed to parse top cert: {e}"))?;
+
+            let top_issuer = top_cert.issuer();
+
+            // Find matching CA in capath certs (skip unparseable certificates)
+            let matching_ca = capath_certs.iter().find_map(|ca_der| {
+                let (_, ca) = x509_parser::parse_x509_certificate(ca_der).ok()?;
+                // Check if this CA is self-signed (root CA) and matches the issuer
+                (ca.subject() == ca.issuer() && ca.subject() == top_issuer).then(|| ca_der.clone())
+            });
+
+            // Update ca_certs_der if we found a match
+            if let Some(ca_der) = matching_ca {
+                let context = self.context.read();
+                let mut ca_certs_der = context.ca_certs_der.write();
+                if !ca_certs_der.iter().any(|c| c == &ca_der) {
+                    ca_certs_der.push(ca_der);
+                }
+            }
+
+            Ok(())
+        }
+
+        fn complete_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            *self.handshake_done.lock() = true;
+
+            // Check if session was resumed - get value and release lock immediately
+            let was_resumed = self
+                .connection
+                .lock()
+                .as_ref()
+                .map(|conn| conn.is_session_resumed())
+                .unwrap_or(false);
+
+            *self.session_was_reused.lock() = was_resumed;
+
+            // Update context session statistics if server-side
+            if self.server_side {
+                let context = self.context.read();
+                // Increment accept count for every successful server handshake
+                context.accept_count.fetch_add(1, Ordering::SeqCst);
+                // Increment hits count if session was resumed
+                if was_resumed {
+                    context.session_hits.fetch_add(1, Ordering::SeqCst);
+                }
+            }
+
+            // Track CA certificate used during handshake (client-side only)
+            // This simulates lazy loading behavior for capath certificates
+            if !self.server_side {
+                // Don't fail handshake if tracking fails
+                let _ = self.track_used_ca_from_capath();
+            }
+
+            self.create_session_after_handshake(vm)?;
+            Ok(())
+        }
+
+        // Internal implementation with timeout control
+        pub(crate) fn sock_wait_for_io_impl(
+            &self,
+            kind: SelectKind,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            if self.is_bio_mode() {
+                // BIO mode doesn't use select
+                return Ok(false);
+            }
+
+            // Get timeout
+            let timeout = self.get_socket_timeout(vm)?;
+
+            // Check for non-blocking mode (timeout = 0)
+            if let Some(t) = timeout
+                && t.is_zero()
+            {
+                // Non-blocking mode - don't use select
+                return Ok(false);
+            }
+
+            // Use select with the effective timeout
+            let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+            let socket = py_socket
+                .sock()
+                .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+
+            let timed_out = sock_select(&socket, kind, timeout)
+                .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+            Ok(timed_out)
+        }
+
+        // SNI (Server Name Indication) Helper Methods:
+        // These methods support the server-side handshake SNI callback mechanism
+
+        /// Check if this is the first read during handshake (for SNI callback)
+        /// Returns true if we haven't processed ClientHello yet, regardless of SNI presence
+        pub(crate) fn is_first_sni_read(&self) -> bool {
+            self.client_hello_buffer.lock().is_none()
+        }
+
+        /// Check if SNI callback is configured
+        pub(crate) fn has_sni_callback(&self) -> bool {
+            // Nested read locks are safe
+            self.context.read().sni_callback.read().is_some()
+        }
+
+        /// Save ClientHello data from PyObjectRef for potential connection recreation
+        pub(crate) fn save_client_hello_from_bytes(&self, bytes_data: &[u8]) {
+            *self.client_hello_buffer.lock() = Some(bytes_data.to_vec());
+        }
+
+        /// Get the extracted SNI name from resolver
+        pub(crate) fn get_extracted_sni_name(&self) -> Option<String> {
+            // Clone the Arc option to avoid nested lock (sni_state.read -> arc.lock)
+            let sni_state_opt = self.sni_state.read().clone();
+            sni_state_opt.as_ref().and_then(|arc| arc.lock().1.clone())
+        }
+
+        /// Invoke the Python SNI callback
+        pub(crate) fn invoke_sni_callback(
+            &self,
+            sni_name: Option<&str>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let callback = self
+                .context
+                .read()
+                .sni_callback
+                .read()
+                .clone()
+                .ok_or_else(|| vm.new_value_error("SNI callback not set"))?;
+
+            let ssl_sock = self.owner.read().clone().unwrap_or(vm.ctx.none());
+            let server_name_py: PyObjectRef = match sni_name {
+                Some(name) => vm.ctx.new_str(name.to_string()).into(),
+                None => vm.ctx.none(),
+            };
+            let initial_context: PyObjectRef = self.context.read().clone().into();
+
+            // catches exceptions from the callback and reports them as unraisable
+            let result = match callback.call((ssl_sock, server_name_py, initial_context), vm) {
+                Ok(result) => result,
+                Err(exc) => {
+                    vm.run_unraisable(
+                        exc,
+                        Some("in ssl servername callback".to_owned()),
+                        callback.clone(),
+                    );
+                    // Return SSL error like SSL_TLSEXT_ERR_ALERT_FATAL
+                    let ssl_exc: PyBaseExceptionRef = vm
+                        .new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            "SNI callback raised exception",
+                        )
+                        .upcast();
+                    let _ = ssl_exc.as_object().set_attr(
+                        "reason",
+                        vm.ctx.new_str("TLSV1_ALERT_INTERNAL_ERROR"),
+                        vm,
+                    );
+                    return Err(ssl_exc);
+                }
+            };
+
+            // Check return value type (must be None or integer)
+            if !vm.is_none(&result) {
+                // Try to convert to integer
+                if result.try_to_value::<i32>(vm).is_err() {
+                    // Type conversion failed - raise TypeError as unraisable
+                    let type_error = vm.new_type_error(format!(
+                        "servername callback must return None or an integer, not '{}'",
+                        result.class().name()
+                    ));
+                    vm.run_unraisable(type_error, None, result.clone());
+
+                    // Return SSL error with reason set to TLSV1_ALERT_INTERNAL_ERROR
+                    //
+                    // RUSTLS API LIMITATION:
+                    // We cannot send a TLS InternalError alert to the client here because:
+                    // 1. Rustls does not provide a public API like send_fatal_alert()
+                    // 2. This method is called AFTER dropping the connection lock (to prevent deadlock)
+                    // 3. By the time we detect the error, the connection is no longer available
+                    //
+                    // CPython/OpenSSL behavior:
+                    // - SNI callback runs inside SSL_do_handshake with connection active
+                    // - Sets *al = SSL_AD_INTERNAL_ERROR
+                    // - OpenSSL automatically sends alert before returning
+                    //
+                    // RustPython/Rustls behavior:
+                    // - SNI callback runs after dropping connection lock (deadlock prevention)
+                    // - Exception has _reason='TLSV1_ALERT_INTERNAL_ERROR' for error reporting
+                    // - TCP connection closes without sending TLS alert to client
+                    //
+                    // If rustls adds send_fatal_alert() API in the future, we should:
+                    // - Re-acquire connection lock after callback
+                    // - Call: connection.send_fatal_alert(AlertDescription::InternalError)
+                    // - Then close connection
+                    let exc: PyBaseExceptionRef = vm
+                        .new_os_subtype_error(
+                            PySSLError::class(&vm.ctx).to_owned(),
+                            None,
+                            "SNI callback returned invalid type",
+                        )
+                        .upcast();
+                    let _ = exc.as_object().set_attr(
+                        "reason",
+                        vm.ctx.new_str("TLSV1_ALERT_INTERNAL_ERROR"),
+                        vm,
+                    );
+                    return Err(exc);
+                }
+            }
+
+            Ok(())
+        }
+
+        // Helper to call socket methods, bypassing any SSL wrapper
+        pub(crate) fn sock_recv(&self, size: usize, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // In BIO mode, read from incoming BIO (flags not supported)
+            if let Some(ref bio) = self.incoming_bio {
+                let bio_obj: PyObjectRef = bio.clone().into();
+                let read_method = bio_obj.get_attr("read", vm)?;
+                return read_method.call((vm.ctx.new_int(size),), vm);
+            }
+
+            // Normal socket mode
+            let socket_mod = vm.import("socket", 0)?;
+            let socket_class = socket_mod.get_attr("socket", vm)?;
+
+            // Call socket.socket.recv(self.sock, size, flags)
+            let recv_method = socket_class.get_attr("recv", vm)?;
+            recv_method.call((self.sock.clone(), vm.ctx.new_int(size)), vm)
+        }
+
+        /// Socket send - just sends data, caller must handle pending flush
+        /// Use flush_pending_tls_output before this if ordering is important
+        pub(crate) fn sock_send(&self, data: &[u8], vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // In BIO mode, write to outgoing BIO
+            if let Some(ref bio) = self.outgoing_bio {
+                let bio_obj: PyObjectRef = bio.clone().into();
+                let write_method = bio_obj.get_attr("write", vm)?;
+                return write_method.call((vm.ctx.new_bytes(data.to_vec()),), vm);
+            }
+
+            // Normal socket mode
+            let socket_mod = vm.import("socket", 0)?;
+            let socket_class = socket_mod.get_attr("socket", vm)?;
+
+            // Call socket.socket.send(self.sock, data)
+            let send_method = socket_class.get_attr("send", vm)?;
+            send_method.call((self.sock.clone(), vm.ctx.new_bytes(data.to_vec())), vm)
+        }
+
+        /// Flush any pending TLS output data to the socket
+        /// Optional deadline parameter allows respecting a read deadline during flush
+        pub(crate) fn flush_pending_tls_output(
+            &self,
+            vm: &VirtualMachine,
+            deadline: Option<std::time::Instant>,
+        ) -> PyResult<()> {
+            let mut pending = self.pending_tls_output.lock();
+            if pending.is_empty() {
+                return Ok(());
+            }
+
+            let socket_timeout = self.get_socket_timeout(vm)?;
+            let is_non_blocking = socket_timeout.map(|t| t.is_zero()).unwrap_or(false);
+
+            let mut sent_total = 0;
+            while sent_total < pending.len() {
+                // Calculate timeout: use deadline if provided, otherwise use socket timeout
+                let timeout_to_use = if let Some(dl) = deadline {
+                    let now = std::time::Instant::now();
+                    if now >= dl {
+                        // Deadline already passed
+                        *pending = pending[sent_total..].to_vec();
+                        return Err(
+                            timeout_error_msg(vm, "The operation timed out".to_string()).upcast()
+                        );
+                    }
+                    Some(dl - now)
+                } else {
+                    socket_timeout
+                };
+
+                // Use sock_select directly with calculated timeout
+                let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+                let socket = py_socket
+                    .sock()
+                    .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+                let timed_out = sock_select(&socket, SelectKind::Write, timeout_to_use)
+                    .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+                if timed_out {
+                    // Keep unsent data in pending buffer
+                    *pending = pending[sent_total..].to_vec();
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                match self.sock_send(&pending[sent_total..], vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent == 0 {
+                            if is_non_blocking {
+                                // Keep unsent data in pending buffer
+                                *pending = pending[sent_total..].to_vec();
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        sent_total += sent;
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            if is_non_blocking {
+                                // Keep unsent data in pending buffer
+                                *pending = pending[sent_total..].to_vec();
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        // Keep unsent data in pending buffer for other errors too
+                        *pending = pending[sent_total..].to_vec();
+                        return Err(e);
+                    }
+                }
+            }
+
+            // All data sent successfully
+            pending.clear();
+            Ok(())
+        }
+
+        /// Send TLS output data to socket, saving unsent bytes to pending buffer
+        /// This prevents data loss when rustls' write_tls() drains its internal buffer
+        /// but the socket cannot accept all the data immediately
+        fn send_tls_output(&self, buf: Vec<u8>, vm: &VirtualMachine) -> PyResult<()> {
+            if buf.is_empty() {
+                return Ok(());
+            }
+
+            let timeout = self.get_socket_timeout(vm)?;
+            let is_non_blocking = timeout.map(|t| t.is_zero()).unwrap_or(false);
+
+            let mut sent_total = 0;
+            while sent_total < buf.len() {
+                let timed_out = self.sock_wait_for_io_impl(SelectKind::Write, vm)?;
+                if timed_out {
+                    // Save unsent data to pending buffer
+                    self.pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                match self.sock_send(&buf[sent_total..], vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent == 0 {
+                            if is_non_blocking {
+                                // Save unsent data to pending buffer
+                                self.pending_tls_output
+                                    .lock()
+                                    .extend_from_slice(&buf[sent_total..]);
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        sent_total += sent;
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            if is_non_blocking {
+                                // Save unsent data to pending buffer
+                                self.pending_tls_output
+                                    .lock()
+                                    .extend_from_slice(&buf[sent_total..]);
+                                return Err(create_ssl_want_write_error(vm).upcast());
+                            }
+                            continue;
+                        }
+                        // Save unsent data for other errors too
+                        self.pending_tls_output
+                            .lock()
+                            .extend_from_slice(&buf[sent_total..]);
+                        return Err(e);
+                    }
+                }
+            }
+
+            Ok(())
+        }
+
+        /// Flush all pending TLS output data, respecting socket timeout
+        /// Used during handshake completion and shutdown() to ensure all data is sent
+        pub(crate) fn blocking_flush_all_pending(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Get socket timeout to respect during flush
+            let timeout = self.get_socket_timeout(vm)?;
+
+            loop {
+                let pending_data = {
+                    let pending = self.pending_tls_output.lock();
+                    if pending.is_empty() {
+                        return Ok(());
+                    }
+                    pending.clone()
+                };
+
+                // Wait for socket to be writable, respecting socket timeout
+                let py_socket: PyRef<PySocket> = self.sock.clone().try_into_value(vm)?;
+                let socket = py_socket
+                    .sock()
+                    .map_err(|e| vm.new_os_error(format!("Failed to get socket: {e}")))?;
+                let timed_out = sock_select(&socket, SelectKind::Write, timeout)
+                    .map_err(|e| vm.new_os_error(format!("select failed: {e}")))?;
+
+                if timed_out {
+                    return Err(
+                        timeout_error_msg(vm, "The write operation timed out".to_string()).upcast(),
+                    );
+                }
+
+                // Try to send pending data (use raw to avoid recursion)
+                match self.sock_send(&pending_data, vm) {
+                    Ok(result) => {
+                        let sent: usize = result.try_to_value::<isize>(vm)?.try_into().unwrap_or(0);
+                        if sent > 0 {
+                            let mut pending = self.pending_tls_output.lock();
+                            pending.drain(..sent);
+                        }
+                        // If sent == 0, socket wasn't ready despite select() saying so
+                        // Continue loop to retry - this avoids infinite loops
+                    }
+                    Err(e) => {
+                        if is_blocking_io_error(&e, vm) {
+                            continue;
+                        }
+                        return Err(e);
+                    }
+                }
+            }
+        }
+
+        #[pymethod]
+        fn __repr__(&self) -> String {
+            "<SSLSocket>".to_string()
+        }
+
+        // Helper function to convert Python PROTO_* constants to rustls versions
+        fn get_rustls_versions(
+            minimum: i32,
+            maximum: i32,
+            options: i32,
+        ) -> &'static [&'static rustls::SupportedProtocolVersion] {
+            // Rustls only supports TLS 1.2 and 1.3
+            // PROTO_TLSv1_2 = 0x0303, PROTO_TLSv1_3 = 0x0304
+            // PROTO_MINIMUM_SUPPORTED = -2, PROTO_MAXIMUM_SUPPORTED = -1
+            // If minimum and maximum are 0, use default (both TLS 1.2 and 1.3)
+
+            // Static arrays for single-version configurations
+            static TLS12_ONLY: &[&rustls::SupportedProtocolVersion] = &[&TLS12];
+            static TLS13_ONLY: &[&rustls::SupportedProtocolVersion] = &[&TLS13];
+
+            // Normalize special values: -2 (MINIMUM_SUPPORTED) → TLS 1.2, -1 (MAXIMUM_SUPPORTED) → TLS 1.3
+            let min = if minimum == -2 {
+                PROTO_TLSv1_2
+            } else {
+                minimum
+            };
+            let max = if maximum == -1 {
+                PROTO_TLSv1_3
+            } else {
+                maximum
+            };
+
+            // Check if versions are disabled by options
+            let tls12_disabled = (options & OP_NO_TLSv1_2) != 0;
+            let tls13_disabled = (options & OP_NO_TLSv1_3) != 0;
+
+            let want_tls12 = (min == 0 || min <= PROTO_TLSv1_2)
+                && (max == 0 || max >= PROTO_TLSv1_2)
+                && !tls12_disabled;
+            let want_tls13 = (min == 0 || min <= PROTO_TLSv1_3)
+                && (max == 0 || max >= PROTO_TLSv1_3)
+                && !tls13_disabled;
+
+            match (want_tls12, want_tls13) {
+                (true, true) => rustls::DEFAULT_VERSIONS, // Both TLS 1.2 and 1.3
+                (true, false) => TLS12_ONLY,              // Only TLS 1.2
+                (false, true) => TLS13_ONLY,              // Only TLS 1.3
+                (false, false) => rustls::DEFAULT_VERSIONS, // Fallback to default
+            }
+        }
+
+        /// Helper: Prepare TLS versions from context settings
+        fn prepare_tls_versions(&self) -> &'static [&'static rustls::SupportedProtocolVersion] {
+            let ctx = self.context.read();
+            let min_ver = *ctx.minimum_version.read();
+            let max_ver = *ctx.maximum_version.read();
+            let options = *ctx.options.read();
+            Self::get_rustls_versions(min_ver, max_ver, options)
+        }
+
+        /// Helper: Prepare KX groups (ECDH curve) from context settings
+        fn prepare_kx_groups(
+            &self,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<Vec<&'static dyn SupportedKxGroup>>> {
+            let ctx = self.context.read();
+            let ecdh_curve = ctx.ecdh_curve.read().clone();
+            drop(ctx);
+
+            if let Some(ref curve_name) = ecdh_curve {
+                match curve_name_to_kx_group(curve_name) {
+                    Ok(groups) => Ok(Some(groups)),
+                    Err(e) => Err(vm.new_value_error(format!("Failed to set ECDH curve: {e}"))),
+                }
+            } else {
+                Ok(None)
+            }
+        }
+
+        /// Helper: Prepare all common protocol settings (versions, KX groups, ciphers, ALPN)
+        fn prepare_protocol_settings(&self, vm: &VirtualMachine) -> PyResult<ProtocolSettings> {
+            let ctx = self.context.read();
+            let versions = self.prepare_tls_versions();
+            let kx_groups = self.prepare_kx_groups(vm)?;
+            let cipher_suites = ctx.selected_ciphers.read().clone();
+            let alpn_protocols = ctx.alpn_protocols.read().clone();
+
+            Ok(ProtocolSettings {
+                versions,
+                kx_groups,
+                cipher_suites,
+                alpn_protocols,
+            })
+        }
+
+        /// Initialize server-side TLS connection with configuration
+        ///
+        /// This method handles all server-side setup including:
+        /// - Certificate and key validation
+        /// - Client authentication configuration
+        /// - SNI (Server Name Indication) setup
+        /// - ALPN protocol negotiation
+        /// - Session resumption configuration
+        ///
+        /// Returns the configured ServerConnection.
+        fn initialize_server_connection(
+            &self,
+            conn_guard: &mut Option<TlsConnection>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            let ctx = self.context.read();
+            let cert_keys = ctx.cert_keys.read();
+
+            if cert_keys.is_empty() {
+                return Err(vm.new_value_error(
+                    "Server-side connection requires certificate and key (use load_cert_chain)",
+                ));
+            }
+
+            // Clone cert_keys for use in config
+            // PrivateKeyDer doesn't implement Clone, use clone_key()
+            let cert_keys_clone: Vec<CertKeyPair> = cert_keys
+                .iter()
+                .map(|(ck, pk)| (ck.clone(), pk.clone_key()))
+                .collect();
+            drop(cert_keys);
+
+            // Prepare common protocol settings (TLS versions, ECDH curve, cipher suites, ALPN)
+            let protocol_settings = self.prepare_protocol_settings(vm)?;
+            let min_ver = *ctx.minimum_version.read();
+
+            // Check if client certificate verification is required
+            let verify_mode = *ctx.verify_mode.read();
+            let root_store = ctx.root_certs.read();
+            let pha_enabled = *ctx.post_handshake_auth.read();
+
+            // Check if TLS 1.3 is being used
+            let is_tls13 = min_ver >= PROTO_TLSv1_3;
+
+            // For TLS 1.3: always use deferred validation for client certificates
+            // For TLS 1.2: use immediate validation during handshake
+            let use_deferred_validation = is_tls13
+                && !pha_enabled
+                && (verify_mode == CERT_REQUIRED || verify_mode == CERT_OPTIONAL);
+
+            // For TLS 1.3 + PHA: if PHA is enabled, don't request cert in initial handshake
+            // The certificate will be requested later via verify_client_post_handshake()
+            let request_initial_cert = if pha_enabled {
+                // PHA enabled: don't request cert initially (will use PHA later)
+                false
+            } else if verify_mode == CERT_REQUIRED || verify_mode == CERT_OPTIONAL {
+                // PHA not enabled or TLS 1.2: request cert in initial handshake
+                true
+            } else {
+                // CERT_NONE
+                false
+            };
+
+            // Check if SNI callback is set
+            let sni_callback = ctx.sni_callback.read().clone();
+            let use_sni_resolver = sni_callback.is_some();
+
+            // Create SNI state if needed (to be stored in PySSLSocket later)
+            // For SNI, use the first cert_key pair as the initial certificate
+            let sni_state: Option<Arc<ParkingMutex<SniCertName>>> = if use_sni_resolver {
+                // Use first cert_key as initial certificate for SNI
+                // Extract CertifiedKey from tuple
+                let (first_cert_key, _) = &cert_keys_clone[0];
+                let first_cert_key = first_cert_key.clone();
+
+                // Check if we already have existing SNI state (from previous connection)
+                let existing_sni_state = self.sni_state.read().clone();
+
+                if let Some(sni_state_arc) = existing_sni_state {
+                    // Reuse existing Arc and update its contents
+                    // This is crucial: rustls SniCertResolver holds references to this Arc
+                    let mut state = sni_state_arc.lock();
+                    state.0 = first_cert_key;
+                    state.1 = None; // Reset SNI name for new connection
+                    drop(state);
+
+                    // Return the existing Arc (not a new one!)
+                    Some(sni_state_arc)
+                } else {
+                    // First connection: create new SNI state
+                    Some(Arc::new(ParkingMutex::new((first_cert_key, None))))
+                }
+            } else {
+                None
+            };
+
+            // Determine which cert resolver to use
+            // Priority: SNI > Multi-cert/Single-cert via MultiCertResolver
+            let cert_resolver: Option<Arc<dyn ResolvesServerCert>> = if use_sni_resolver {
+                // SNI takes precedence - use first cert_key for initial setup
+                sni_state.as_ref().map(|sni_state_arc| {
+                    Arc::new(SniCertResolver {
+                        sni_state: sni_state_arc.clone(),
+                    }) as Arc<dyn ResolvesServerCert>
+                })
+            } else {
+                // Use MultiCertResolver for all cases (single or multiple certs)
+                // Extract CertifiedKey from tuples for MultiCertResolver
+                let cert_keys_only: Vec<Arc<CertifiedKey>> =
+                    cert_keys_clone.iter().map(|(ck, _)| ck.clone()).collect();
+                Some(Arc::new(MultiCertResolver::new(cert_keys_only)))
+            };
+
+            // Extract cert_chain and private_key from first cert_key
+            //
+            // Note: Since we always use cert_resolver now, these values won't actually be used
+            // by create_server_config. But we still need to provide them for the API signature.
+            let (first_cert_key, _) = &cert_keys_clone[0];
+            let certs_clone = first_cert_key.cert.clone();
+
+            // Provide a dummy key since cert_resolver will handle cert selection
+            let key_clone = PrivateKeyDer::Pkcs8(Vec::new().into());
+
+            // Get shared server session storage and ticketer from context
+            let server_session_storage = ctx.rustls_server_session_store.clone();
+            let server_ticketer = ctx.server_ticketer.clone();
+
+            // Build server config using compat helper
+            let config_options = ServerConfigOptions {
+                protocol_settings,
+                cert_chain: certs_clone,
+                private_key: key_clone,
+                root_store: if request_initial_cert {
+                    Some(root_store.clone())
+                } else {
+                    None
+                },
+                request_client_cert: request_initial_cert,
+                use_deferred_validation,
+                cert_resolver,
+                deferred_cert_error: if use_deferred_validation {
+                    Some(self.deferred_cert_error.clone())
+                } else {
+                    None
+                },
+                session_storage: Some(server_session_storage),
+                ticketer: Some(server_ticketer),
+            };
+
+            drop(root_store);
+
+            // Check if we have a cached ServerConfig
+            let cached_config_arc = ctx.server_config.read().clone();
+            drop(ctx);
+
+            let config_arc = if let Some(cached) = cached_config_arc {
+                // Don't use cache when SNI is enabled, because each connection needs
+                // a fresh SniCertResolver with the correct Arc references
+                if use_sni_resolver {
+                    let config =
+                        create_server_config(config_options).map_err(|e| vm.new_value_error(e))?;
+                    Arc::new(config)
+                } else {
+                    cached
+                }
+            } else {
+                let config =
+                    create_server_config(config_options).map_err(|e| vm.new_value_error(e))?;
+                let config_arc = Arc::new(config);
+
+                // Cache the ServerConfig for future connections
+                let ctx = self.context.read();
+                *ctx.server_config.write() = Some(config_arc.clone());
+                drop(ctx);
+
+                config_arc
+            };
+
+            let conn = ServerConnection::new(config_arc).map_err(|e| {
+                vm.new_value_error(format!("Failed to create server connection: {e}"))
+            })?;
+
+            *conn_guard = Some(TlsConnection::Server(conn));
+
+            // If ClientHello buffer exists (from SNI callback), re-inject it
+            if let Some(ref hello_data) = *self.client_hello_buffer.lock()
+                && let Some(TlsConnection::Server(ref mut server)) = *conn_guard
+            {
+                let mut cursor = std::io::Cursor::new(hello_data.as_slice());
+                let _ = server.read_tls(&mut cursor);
+
+                // Process the re-injected ClientHello
+                let _ = server.process_new_packets();
+
+                // DON'T clear buffer - keep it to prevent callback from being invoked again
+                // The buffer being non-empty signals that SNI callback was already processed
+            }
+
+            // Store SNI state if we're using SNI resolver
+            if let Some(sni_state_arc) = sni_state {
+                *self.sni_state.write() = Some(sni_state_arc);
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn do_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // Check if handshake already done
+            if *self.handshake_done.lock() {
+                return Ok(());
+            }
+
+            let mut conn_guard = self.connection.lock();
+
+            // Initialize connection if not already done
+            if conn_guard.is_none() {
+                // Check for pending context change (from SNI callback)
+                if let Some(new_ctx) = self.pending_context.write().take() {
+                    *self.context.write() = new_ctx;
+                }
+
+                if self.server_side {
+                    // Server-side connection - delegate to helper method
+                    self.initialize_server_connection(&mut conn_guard, vm)?;
+                } else {
+                    // Client-side connection
+                    let ctx = self.context.read();
+
+                    // Prepare common protocol settings (TLS versions, ECDH curve, cipher suites, ALPN)
+                    let protocol_settings = self.prepare_protocol_settings(vm)?;
+
+                    // Clone values we need before building config
+                    let verify_mode = *ctx.verify_mode.read();
+                    let root_store_clone = ctx.root_certs.read().clone();
+                    let ca_certs_der_clone = ctx.ca_certs_der.read().clone();
+
+                    // For client mTLS: extract cert_chain and private_key from first cert_key (if any)
+                    // Now we store both CertifiedKey and PrivateKeyDer as tuple
+                    let cert_keys_guard = ctx.cert_keys.read();
+                    let (cert_chain_clone, private_key_opt) = if !cert_keys_guard.is_empty() {
+                        let (first_cert_key, private_key) = &cert_keys_guard[0];
+                        let certs = first_cert_key.cert.clone();
+                        (certs, Some(private_key.clone_key()))
+                    } else {
+                        (Vec::new(), None)
+                    };
+                    drop(cert_keys_guard);
+
+                    let check_hostname = *ctx.check_hostname.read();
+                    let verify_flags = *ctx.verify_flags.read();
+
+                    // Get session store before dropping ctx
+                    let session_store = ctx.rustls_session_store.clone();
+
+                    // Get CRLs for revocation checking
+                    let crls_clone = ctx.crls.read().clone();
+
+                    // Drop ctx early to avoid borrow conflicts
+                    drop(ctx);
+
+                    // Build client config using compat helper
+                    let config_options = ClientConfigOptions {
+                        protocol_settings,
+                        root_store: if verify_mode != CERT_NONE {
+                            Some(root_store_clone)
+                        } else {
+                            None
+                        },
+                        ca_certs_der: ca_certs_der_clone,
+                        cert_chain: if !cert_chain_clone.is_empty() {
+                            Some(cert_chain_clone)
+                        } else {
+                            None
+                        },
+                        private_key: private_key_opt,
+                        verify_server_cert: verify_mode != CERT_NONE,
+                        check_hostname,
+                        verify_flags,
+                        session_store: Some(session_store),
+                        crls: crls_clone,
+                    };
+
+                    let config =
+                        create_client_config(config_options).map_err(|e| vm.new_value_error(e))?;
+
+                    // Parse server name for SNI
+                    // Convert to ServerName
+                    use rustls::pki_types::ServerName;
+                    let hostname_opt = self.server_hostname.read().clone();
+
+                    let server_name = if let Some(ref hostname) = hostname_opt {
+                        // Use the provided hostname for SNI
+                        ServerName::try_from(hostname.clone()).map_err(|e| {
+                            vm.new_value_error(format!("Invalid server hostname: {e:?}"))
+                        })?
+                    } else {
+                        // When server_hostname=None, use an IP address to suppress SNI
+                        // no hostname = no SNI extension
+                        ServerName::IpAddress(
+                            core::net::IpAddr::V4(core::net::Ipv4Addr::new(127, 0, 0, 1)).into(),
+                        )
+                    };
+
+                    let conn = ClientConnection::new(Arc::new(config), server_name.clone())
+                        .map_err(|e| {
+                            vm.new_value_error(format!("Failed to create client connection: {e}"))
+                        })?;
+
+                    *conn_guard = Some(TlsConnection::Client(conn));
+                }
+            }
+
+            // Perform the actual handshake by exchanging data with the socket/BIO
+
+            let conn = conn_guard.as_mut().expect("unreachable");
+            let is_client = matches!(conn, TlsConnection::Client(_));
+            let handshake_result = ssl_do_handshake(conn, self, vm);
+            drop(conn_guard);
+
+            if is_client {
+                // CLIENT is simple - no SNI callback handling needed
+                handshake_result.map_err(|e| e.into_py_err(vm))?;
+                self.complete_handshake(vm)?;
+                Ok(())
+            } else {
+                // Use OpenSSL-compatible handshake for server
+                // Handle SNI callback restart
+                match handshake_result {
+                    Ok(()) => {
+                        // Handshake completed successfully
+                        self.complete_handshake(vm)?;
+                        Ok(())
+                    }
+                    Err(SslError::SniCallbackRestart) => {
+                        // SNI detected - need to call callback and recreate connection
+
+                        // Get the SNI name that was extracted (may be None if client didn't send SNI)
+                        let sni_name = self.get_extracted_sni_name();
+
+                        // Now safe to call Python callback (no locks held)
+                        self.invoke_sni_callback(sni_name.as_deref(), vm)?;
+
+                        // Clear connection to trigger recreation
+                        *self.connection.lock() = None;
+
+                        // Recursively call do_handshake to recreate with new context
+                        self.do_handshake(vm)
+                    }
+                    Err(e) => {
+                        // Other errors - convert to Python exception
+                        Err(e.into_py_err(vm))
+                    }
+                }
+            }
+        }
+
+        #[pymethod]
+        fn read(
+            &self,
+            len: OptionalArg<isize>,
+            buffer: OptionalArg<ArgMemoryBuffer>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            // Convert len to usize, defaulting to 1024 if not provided
+            // -1 means read all available data (treat as large buffer size)
+            let len_val = len.unwrap_or(PEM_BUFSIZE as isize);
+            let mut len = if len_val == -1 {
+                // -1 is only valid when a buffer is provided
+                match &buffer {
+                    OptionalArg::Present(buf_arg) => buf_arg.len(),
+                    OptionalArg::Missing => {
+                        return Err(vm.new_value_error("negative read length"));
+                    }
+                }
+            } else if len_val < 0 {
+                return Err(vm.new_value_error("negative read length"));
+            } else {
+                len_val as usize
+            };
+
+            // if buffer is provided, limit len to buffer size
+            if let OptionalArg::Present(buf_arg) = &buffer {
+                let buf_len = buf_arg.len();
+                if len_val <= 0 || len > buf_len {
+                    len = buf_len;
+                }
+            }
+
+            // return empty bytes immediately for len=0
+            if len == 0 {
+                return match buffer {
+                    OptionalArg::Present(_) => Ok(vm.ctx.new_int(0).into()),
+                    OptionalArg::Missing => Ok(vm.ctx.new_bytes(vec![]).into()),
+                };
+            }
+
+            // Ensure handshake is done - if not, complete it first
+            // This matches OpenSSL behavior where SSL_read() auto-completes handshake
+            if !*self.handshake_done.lock() {
+                self.do_handshake(vm)?;
+            }
+
+            // Check if connection has been shut down
+            // After unwrap()/shutdown(), read operations should fail with SSLError
+            let shutdown_state = *self.shutdown_state.lock();
+            if shutdown_state != ShutdownState::NotStarted {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "cannot read after shutdown",
+                    )
+                    .upcast());
+            }
+
+            // Helper function to handle return value based on buffer presence
+            let return_data = |data: Vec<u8>,
+                               buffer_arg: &OptionalArg<ArgMemoryBuffer>,
+                               vm: &VirtualMachine|
+             -> PyResult<PyObjectRef> {
+                match buffer_arg {
+                    OptionalArg::Present(buf_arg) => {
+                        // Write into buffer and return number of bytes written
+                        let n = data.len();
+                        if n > 0 {
+                            let mut buf = buf_arg.borrow_buf_mut();
+                            let buf_slice = &mut *buf;
+                            let copy_len = n.min(buf_slice.len());
+                            buf_slice[..copy_len].copy_from_slice(&data[..copy_len]);
+                        }
+                        Ok(vm.ctx.new_int(n).into())
+                    }
+                    OptionalArg::Missing => {
+                        // Return bytes object
+                        Ok(vm.ctx.new_bytes(data).into())
+                    }
+                }
+            };
+
+            // Use compat layer for unified read logic with proper EOF handling
+            // This matches SSL_read_ex() approach
+            let mut buf = vec![0u8; len];
+            let read_result = {
+                let mut conn_guard = self.connection.lock();
+                let conn = conn_guard
+                    .as_mut()
+                    .ok_or_else(|| vm.new_value_error("Connection not established"))?;
+                crate::ssl::compat::ssl_read(conn, &mut buf, self, vm)
+            };
+            match read_result {
+                Ok(n) => {
+                    // Check for deferred certificate verification errors (TLS 1.3)
+                    // Must be checked AFTER ssl_read, as the error is set during I/O
+                    self.check_deferred_cert_error(vm)?;
+                    buf.truncate(n);
+                    return_data(buf, &buffer, vm)
+                }
+                Err(crate::ssl::compat::SslError::Eof) => {
+                    // EOF occurred in violation of protocol (unexpected closure)
+                    Err(vm
+                        .new_os_subtype_error(
+                            PySSLEOFError::class(&vm.ctx).to_owned(),
+                            None,
+                            "EOF occurred in violation of protocol",
+                        )
+                        .upcast())
+                }
+                Err(crate::ssl::compat::SslError::ZeroReturn) => {
+                    // Clean closure with close_notify - return empty data
+                    return_data(vec![], &buffer, vm)
+                }
+                Err(crate::ssl::compat::SslError::WantRead) => {
+                    // Non-blocking mode: would block
+                    Err(create_ssl_want_read_error(vm).upcast())
+                }
+                Err(crate::ssl::compat::SslError::WantWrite) => {
+                    // Non-blocking mode: would block on write
+                    Err(create_ssl_want_write_error(vm).upcast())
+                }
+                Err(crate::ssl::compat::SslError::Timeout(msg)) => {
+                    Err(timeout_error_msg(vm, msg).upcast())
+                }
+                Err(crate::ssl::compat::SslError::Py(e)) => {
+                    // Python exception - pass through
+                    Err(e)
+                }
+                Err(e) => {
+                    // Other SSL errors
+                    Err(e.into_py_err(vm))
+                }
+            }
+        }
+
+        #[pymethod]
+        fn pending(&self) -> PyResult<usize> {
+            // Returns the number of already decrypted bytes available for read
+            // This is critical for asyncore's readable() method which checks socket.pending() > 0
+            let mut conn_guard = self.connection.lock();
+            let conn = match conn_guard.as_mut() {
+                Some(c) => c,
+                None => return Ok(0), // No connection established yet
+            };
+
+            // 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()),
+                Err(_) => {
+                    // WouldBlock or other errors mean no data available
+                    // Return 0 like OpenSSL does when buffer is empty
+                    Ok(0)
+                }
+            }
+        }
+
+        #[pymethod]
+        fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+            let data_bytes = data.borrow_buf();
+            let data_len = data_bytes.len();
+
+            // return 0 immediately for empty write
+            if data_len == 0 {
+                return Ok(0);
+            }
+
+            // Ensure handshake is done - if not, complete it first
+            // This matches OpenSSL behavior where SSL_write() auto-completes handshake
+            if !*self.handshake_done.lock() {
+                self.do_handshake(vm)?;
+            }
+
+            // Check if connection has been shut down
+            // After unwrap()/shutdown(), write operations should fail with SSLError
+            let shutdown_state = *self.shutdown_state.lock();
+            if shutdown_state != ShutdownState::NotStarted {
+                return Err(vm
+                    .new_os_subtype_error(
+                        PySSLError::class(&vm.ctx).to_owned(),
+                        None,
+                        "cannot write after shutdown",
+                    )
+                    .upcast());
+            }
+
+            {
+                let mut conn_guard = self.connection.lock();
+                let conn = conn_guard
+                    .as_mut()
+                    .ok_or_else(|| vm.new_value_error("Connection not established"))?;
+
+                let is_bio = self.is_bio_mode();
+                let data: &[u8] = data_bytes.as_ref();
+
+                // CRITICAL: Flush any pending TLS data before writing new data
+                // This ensures TLS 1.3 Finished message reaches server before application data
+                // Without this, server may not be ready to process our data
+                if !is_bio {
+                    self.flush_pending_tls_output(vm, None)?;
+                }
+
+                // Write data in chunks to avoid filling the internal TLS buffer
+                // rustls has a limited internal buffer, so we need to flush periodically
+                const CHUNK_SIZE: usize = 16384; // 16KB chunks (typical TLS record size)
+                let mut written = 0;
+
+                while written < data.len() {
+                    let chunk_end = core::cmp::min(written + CHUNK_SIZE, data.len());
+                    let chunk = &data[written..chunk_end];
+
+                    // Write chunk to TLS layer
+                    {
+                        let mut writer = conn.writer();
+                        use std::io::Write;
+                        writer
+                            .write_all(chunk)
+                            .map_err(|e| vm.new_os_error(format!("Write failed: {e}")))?;
+                        // Flush to ensure data is converted to TLS records
+                        writer
+                            .flush()
+                            .map_err(|e| vm.new_os_error(format!("Flush failed: {e}")))?;
+                    }
+
+                    written = chunk_end;
+
+                    // Flush TLS data to socket after each chunk
+                    if conn.wants_write() {
+                        if is_bio {
+                            self.write_pending_tls(conn, vm)?;
+                        } else {
+                            // Socket mode: flush all pending TLS data
+                            // First, try to send any previously pending data
+                            self.flush_pending_tls_output(vm, None)?;
+
+                            while conn.wants_write() {
+                                let mut buf = Vec::new();
+                                conn.write_tls(&mut buf).map_err(|e| {
+                                    vm.new_os_error(format!("TLS write failed: {e}"))
+                                })?;
+
+                                if !buf.is_empty() {
+                                    // Try to send TLS data, saving unsent bytes to pending buffer
+                                    self.send_tls_output(buf, vm)?;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Check for deferred certificate verification errors (TLS 1.3)
+            // Must be checked AFTER write completes, as the error may be set during I/O
+            self.check_deferred_cert_error(vm)?;
+
+            Ok(data_len)
+        }
+
+        #[pymethod]
+        fn getpeercert(
+            &self,
+            args: GetCertArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<PyObjectRef>> {
+            let binary = args.binary_form.unwrap_or(false);
+
+            // Check if handshake is complete
+            if !*self.handshake_done.lock() {
+                return Err(vm.new_value_error("handshake not done yet"));
+            }
+
+            // Extract DER bytes from connection, releasing lock quickly
+            let der_bytes = {
+                let conn_guard = self.connection.lock();
+                let conn = conn_guard
+                    .as_ref()
+                    .ok_or_else(|| vm.new_value_error("No TLS connection established"))?;
+
+                let Some(peer_certificates) = conn.peer_certificates() else {
+                    return Ok(None);
+                };
+                let cert = peer_certificates
+                    .first()
+                    .ok_or_else(|| vm.new_value_error("No peer certificate available"))?;
+                cert.as_ref().to_vec()
+            };
+
+            if binary {
+                // Return DER-encoded certificate as bytes
+                return Ok(Some(vm.ctx.new_bytes(der_bytes).into()));
+            }
+
+            // Dictionary mode: check verify_mode
+            let verify_mode = *self.context.read().verify_mode.read();
+
+            if verify_mode == CERT_NONE {
+                // Return empty dict when CERT_NONE
+                return Ok(Some(vm.ctx.new_dict().into()));
+            }
+
+            // Parse DER certificate and convert to dict (outside lock)
+            let (_, cert) = x509_parser::parse_x509_certificate(&der_bytes)
+                .map_err(|e| vm.new_value_error(format!("Failed to parse certificate: {e}")))?;
+
+            cert::cert_to_dict(vm, &cert).map(Some)
+        }
+
+        #[pymethod]
+        fn cipher(&self) -> Option<(String, String, i32)> {
+            // Extract cipher suite, releasing lock quickly
+            let suite = {
+                let conn_guard = self.connection.lock();
+                conn_guard.as_ref()?.negotiated_cipher_suite()?
+            };
+
+            // Extract cipher information outside the lock
+            let cipher_info = extract_cipher_info(&suite);
+
+            // Note: returns a 3-tuple (name, protocol_version, bits)
+            // The 'description' field is part of get_ciphers() output, not cipher()
+            Some((
+                cipher_info.name,
+                cipher_info.protocol.to_string(),
+                cipher_info.bits,
+            ))
+        }
+
+        #[pymethod]
+        fn version(&self) -> Option<String> {
+            // Extract cipher suite, releasing lock quickly
+            let suite = {
+                let conn_guard = self.connection.lock();
+                conn_guard.as_ref()?.negotiated_cipher_suite()?
+            };
+
+            // Convert to string outside the lock
+            let version_str = match suite.version().version {
+                rustls::ProtocolVersion::TLSv1_2 => "TLSv1.2",
+                rustls::ProtocolVersion::TLSv1_3 => "TLSv1.3",
+                _ => "Unknown",
+            };
+
+            Some(version_str.to_string())
+        }
+
+        #[pymethod]
+        fn selected_alpn_protocol(&self) -> Option<String> {
+            let conn_guard = self.connection.lock();
+            let conn = conn_guard.as_ref()?;
+
+            let alpn_bytes = conn.alpn_protocol()?;
+
+            // Null byte protocol (vec![0u8]) means no actual ALPN match (fallback protocol)
+            if alpn_bytes.is_empty() || alpn_bytes == [0u8] {
+                return None;
+            }
+
+            // Convert bytes to string
+            String::from_utf8(alpn_bytes.to_vec()).ok()
+        }
+
+        #[pymethod]
+        fn selected_npn_protocol(&self) -> Option<String> {
+            // NPN (Next Protocol Negotiation) is the predecessor to ALPN
+            // It was deprecated in favor of ALPN (RFC 7301)
+            // Rustls doesn't support NPN, only ALPN
+            // Return None to indicate NPN is not supported
+            None
+        }
+
+        #[pygetset]
+        fn owner(&self) -> Option<PyObjectRef> {
+            self.owner.read().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set_owner(&self, owner: PyObjectRef, _vm: &VirtualMachine) -> PyResult<()> {
+            *self.owner.write() = Some(owner);
+            Ok(())
+        }
+
+        #[pygetset]
+        fn server_side(&self) -> bool {
+            self.server_side
+        }
+
+        #[pygetset]
+        fn context(&self) -> PyRef<PySSLContext> {
+            self.context.read().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set_context(&self, value: PyRef<PySSLContext>, _vm: &VirtualMachine) -> PyResult<()> {
+            // Update context reference immediately
+            // SSL_set_SSL_CTX allows context changes at any time,
+            // even after handshake completion
+            *self.context.write() = value;
+
+            // Clear pending context as we've applied the change
+            *self.pending_context.write() = None;
+
+            Ok(())
+        }
+
+        #[pygetset]
+        fn server_hostname(&self) -> Option<String> {
+            self.server_hostname.read().clone()
+        }
+
+        #[pygetset(setter)]
+        fn set_server_hostname(
+            &self,
+            value: Option<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Check if handshake is already done
+            if *self.handshake_done.lock() {
+                return Err(
+                    vm.new_value_error("Cannot set server_hostname on socket after handshake")
+                );
+            }
+
+            // Validate hostname
+            if let Some(hostname_str) = &value {
+                validate_hostname(hostname_str.as_str(), vm)?;
+            }
+
+            *self.server_hostname.write() = value.map(|s| s.as_str().to_string());
+            Ok(())
+        }
+
+        #[pygetset]
+        fn session(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // Return the stored session object if any
+            let sess = self.session.read().clone();
+            if let Some(s) = sess {
+                Ok(s)
+            } else {
+                Ok(vm.ctx.none())
+            }
+        }
+
+        #[pygetset(setter)]
+        fn set_session(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+            // Validate that value is an SSLSession
+            if !value.is(vm.ctx.types.none_type) {
+                // Try to downcast to SSLSession to validate
+                let _ = value
+                    .downcast_ref::<PySSLSession>()
+                    .ok_or_else(|| vm.new_type_error("Value is not a SSLSession."))?;
+            }
+
+            // Check if this is a client socket
+            if self.server_side {
+                return Err(vm.new_value_error("Cannot set session for server-side SSLSocket"));
+            }
+
+            // Check if handshake is already done
+            if *self.handshake_done.lock() {
+                return Err(vm.new_value_error("Cannot set session after handshake."));
+            }
+
+            // Store the session for potential use during handshake
+            *self.session.write() = if value.is(vm.ctx.types.none_type) {
+                None
+            } else {
+                Some(value)
+            };
+
+            Ok(())
+        }
+
+        #[pygetset]
+        fn session_reused(&self) -> bool {
+            // Return the tracked session reuse status
+            *self.session_was_reused.lock()
+        }
+
+        #[pymethod]
+        fn compression(&self) -> Option<&'static str> {
+            // rustls doesn't support compression
+            None
+        }
+
+        #[pymethod]
+        fn get_unverified_chain(&self, vm: &VirtualMachine) -> PyResult<Option<PyListRef>> {
+            // Get peer certificates from the connection
+            let conn_guard = self.connection.lock();
+            let conn = conn_guard
+                .as_ref()
+                .ok_or_else(|| vm.new_value_error("Handshake not completed"))?;
+
+            let certs = conn.peer_certificates();
+
+            let Some(certs) = certs else {
+                return Ok(None);
+            };
+
+            // Convert to list of Certificate objects
+            let cert_list: Vec<PyObjectRef> = certs
+                .iter()
+                .map(|cert_der| {
+                    let cert_bytes = cert_der.as_ref().to_vec();
+                    PySSLCertificate {
+                        der_bytes: cert_bytes,
+                    }
+                    .into_ref(&vm.ctx)
+                    .into()
+                })
+                .collect();
+
+            Ok(Some(vm.ctx.new_list(cert_list)))
+        }
+
+        #[pymethod]
+        fn get_verified_chain(&self, vm: &VirtualMachine) -> PyResult<Option<PyListRef>> {
+            // Get peer certificates (what peer sent during handshake)
+            let conn_guard = self.connection.lock();
+            let Some(ref conn) = *conn_guard else {
+                return Ok(None);
+            };
+
+            let peer_certs = conn.peer_certificates();
+
+            let Some(peer_certs_slice) = peer_certs else {
+                return Ok(None);
+            };
+
+            // Build the verified chain using cert module
+            let ctx_guard = self.context.read();
+            let ca_certs_der = ctx_guard.ca_certs_der.read();
+
+            let chain_der = cert::build_verified_chain(peer_certs_slice, &ca_certs_der);
+
+            // Convert DER chain to Python list of Certificate objects
+            let cert_list: Vec<PyObjectRef> = chain_der
+                .into_iter()
+                .map(|der_bytes| PySSLCertificate { der_bytes }.into_ref(&vm.ctx).into())
+                .collect();
+
+            Ok(Some(vm.ctx.new_list(cert_list)))
+        }
+
+        #[pymethod]
+        fn shutdown(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            // Check current shutdown state
+            let current_state = *self.shutdown_state.lock();
+
+            // If already completed, return immediately
+            if current_state == ShutdownState::Completed {
+                if self.is_bio_mode() {
+                    return Ok(vm.ctx.none());
+                }
+                return Ok(self.sock.clone());
+            }
+
+            // Get connection
+            let mut conn_guard = self.connection.lock();
+            let conn = conn_guard
+                .as_mut()
+                .ok_or_else(|| vm.new_value_error("Connection not established"))?;
+
+            let is_bio = self.is_bio_mode();
+
+            // Step 1: Send our close_notify if not already sent
+            if current_state == ShutdownState::NotStarted {
+                // First, flush ALL pending TLS data BEFORE sending close_notify
+                // This is CRITICAL - close_notify must come AFTER all application data
+                // Otherwise data loss occurs when peer receives close_notify first
+
+                // Step 1a: Flush any pending TLS records from rustls internal buffer
+                // This ensures all application data is converted to TLS records
+                while conn.wants_write() {
+                    let mut buf = Vec::new();
+                    conn.write_tls(&mut buf)
+                        .map_err(|e| vm.new_os_error(format!("TLS write failed: {e}")))?;
+                    if !buf.is_empty() {
+                        self.send_tls_output(buf, vm)?;
+                    }
+                }
+
+                // Step 1b: Flush pending_tls_output buffer to socket
+                if !is_bio {
+                    // Socket mode: blocking flush to ensure data order
+                    // Must complete before sending close_notify
+                    self.blocking_flush_all_pending(vm)?;
+                } else {
+                    // BIO mode: non-blocking flush (caller handles pending data)
+                    let _ = self.flush_pending_tls_output(vm, None);
+                }
+
+                conn.send_close_notify();
+
+                // Write close_notify to outgoing buffer/BIO
+                self.write_pending_tls(conn, vm)?;
+
+                // Update state
+                *self.shutdown_state.lock() = ShutdownState::SentCloseNotify;
+            }
+
+            // Step 2: Try to read and process peer's close_notify
+
+            // First check if we already have peer's close_notify
+            // This can happen if it was received during a previous read() call
+            let mut peer_closed = self.check_peer_closed(conn, vm)?;
+
+            // If peer hasn't closed yet, try to read from socket
+            if !peer_closed {
+                // Check socket timeout mode
+                let timeout_mode = if !is_bio {
+                    // Get socket timeout
+                    match self.sock.get_attr("gettimeout", vm) {
+                        Ok(method) => match method.call((), vm) {
+                            Ok(timeout) => {
+                                if vm.is_none(&timeout) {
+                                    // timeout=None means blocking
+                                    Some(None)
+                                } else if let Ok(t) = timeout.try_float(vm).map(|f| f.to_f64()) {
+                                    if t == 0.0 {
+                                        // timeout=0 means non-blocking
+                                        Some(Some(0.0))
+                                    } else {
+                                        // timeout>0 means timeout mode
+                                        Some(Some(t))
+                                    }
+                                } else {
+                                    None
+                                }
+                            }
+                            Err(_) => None,
+                        },
+                        Err(_) => None,
+                    }
+                } else {
+                    None // BIO mode
+                };
+
+                if is_bio {
+                    // In BIO mode: non-blocking read attempt
+                    if self.try_read_close_notify(conn, vm)? {
+                        peer_closed = true;
+                    }
+                } else if let Some(timeout) = timeout_mode {
+                    // All socket modes (blocking, timeout, non-blocking):
+                    // Return immediately after sending our close_notify.
+                    //
+                    // This matches CPython/OpenSSL behavior where SSL_shutdown()
+                    // returns after sending close_notify, allowing the app to
+                    // close the socket without waiting for peer's close_notify.
+                    //
+                    // Waiting for peer's close_notify can cause deadlock with
+                    // asyncore-based servers where both sides wait for the other's
+                    // close_notify before closing the connection.
+
+                    // Ensure all pending TLS data is sent before returning
+                    // This prevents data loss when rustls drains its buffer
+                    // but the socket couldn't accept all data immediately
+                    drop(conn_guard);
+
+                    // Respect socket timeout settings for flushing pending TLS data
+                    match timeout {
+                        Some(0.0) => {
+                            // Non-blocking: best-effort flush, ignore errors
+                            // to avoid deadlock with asyncore-based servers
+                            let _ = self.flush_pending_tls_output(vm, None);
+                        }
+                        Some(_t) => {
+                            // Timeout mode: use flush with socket's timeout
+                            // Errors (including timeout) are propagated to caller
+                            self.flush_pending_tls_output(vm, None)?;
+                        }
+                        None => {
+                            // Blocking mode: wait until all pending data is sent
+                            self.blocking_flush_all_pending(vm)?;
+                        }
+                    }
+
+                    *self.shutdown_state.lock() = ShutdownState::Completed;
+                    *self.connection.lock() = None;
+                    return Ok(self.sock.clone());
+                }
+
+                // Step 3: Check again if peer has sent close_notify (non-blocking/BIO mode only)
+                if !peer_closed {
+                    peer_closed = self.check_peer_closed(conn, vm)?;
+                }
+            }
+
+            drop(conn_guard); // Release lock before returning
+
+            if !peer_closed {
+                // Still waiting for peer's close-notify
+                // Raise SSLWantReadError to signal app needs to transfer data
+                // This is correct for non-blocking sockets and BIO mode
+                return Err(create_ssl_want_read_error(vm).upcast());
+            }
+            // Both close-notify exchanged, shutdown complete
+            *self.shutdown_state.lock() = ShutdownState::Completed;
+
+            if is_bio {
+                return Ok(vm.ctx.none());
+            }
+            Ok(self.sock.clone())
+        }
+
+        // Helper: Write all pending TLS data (including close_notify) to outgoing buffer/BIO
+        fn write_pending_tls(&self, conn: &mut TlsConnection, vm: &VirtualMachine) -> PyResult<()> {
+            // First, flush any previously pending TLS output
+            // Must succeed before sending new data to maintain order
+            self.flush_pending_tls_output(vm, None)?;
+
+            loop {
+                if !conn.wants_write() {
+                    break;
+                }
+
+                let mut buf = vec![0u8; SSL3_RT_MAX_PLAIN_LENGTH];
+                let written = conn
+                    .write_tls(&mut buf.as_mut_slice())
+                    .map_err(|e| vm.new_os_error(format!("TLS write failed: {e}")))?;
+
+                if written == 0 {
+                    break;
+                }
+
+                // Send TLS data, saving unsent bytes to pending buffer if needed
+                self.send_tls_output(buf[..written].to_vec(), vm)?;
+            }
+
+            Ok(())
+        }
+
+        // Helper: Try to read incoming data from socket/BIO
+        // Returns true if peer closed connection (with or without close_notify)
+        fn try_read_close_notify(
+            &self,
+            conn: &mut TlsConnection,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            // Try to read incoming data
+            match self.sock_recv(SSL3_RT_MAX_PLAIN_LENGTH, vm) {
+                Ok(bytes_obj) => {
+                    let bytes = ArgBytesLike::try_from_object(vm, bytes_obj)?;
+                    let data = bytes.borrow_buf();
+
+                    if data.is_empty() {
+                        // Empty read could mean EOF or just "no data yet" in BIO mode
+                        if let Some(ref bio) = self.incoming_bio {
+                            // BIO mode: check if EOF was signaled via write_eof()
+                            let bio_obj: PyObjectRef = bio.clone().into();
+                            let eof_attr = bio_obj.get_attr("eof", vm)?;
+                            let is_eof = eof_attr.try_to_bool(vm)?;
+                            if !is_eof {
+                                // No EOF signaled, just no data available yet
+                                return Ok(false);
+                            }
+                        }
+                        // Socket mode or BIO with EOF: peer closed connection
+                        // This is "ragged EOF" - peer closed without close_notify
+                        return Ok(true);
+                    }
+
+                    // Feed data to TLS connection
+                    let data_slice: &[u8] = data.as_ref();
+                    let mut cursor = std::io::Cursor::new(data_slice);
+                    let _ = conn.read_tls(&mut cursor);
+
+                    // Process packets
+                    let _ = conn.process_new_packets();
+                    Ok(false)
+                }
+                Err(e) => {
+                    // BlockingIOError means no data yet
+                    if is_blocking_io_error(&e, vm) {
+                        return Ok(false);
+                    }
+                    // Connection reset, EOF, or other error means peer closed
+                    // ECONNRESET, EPIPE, broken pipe, etc.
+                    Ok(true)
+                }
+            }
+        }
+
+        // Helper: Check if peer has sent close_notify
+        fn check_peer_closed(
+            &self,
+            conn: &mut TlsConnection,
+            vm: &VirtualMachine,
+        ) -> PyResult<bool> {
+            // Process any remaining packets and check peer_has_closed
+            let io_state = conn
+                .process_new_packets()
+                .map_err(|e| vm.new_os_error(format!("Failed to process packets: {e}")))?;
+
+            Ok(io_state.peer_has_closed())
+        }
+
+        #[pymethod]
+        fn shared_ciphers(&self, vm: &VirtualMachine) -> Option<PyListRef> {
+            // Return None for client-side sockets
+            if !self.server_side {
+                return None;
+            }
+
+            // Check if handshake completed
+            if !*self.handshake_done.lock() {
+                return None;
+            }
+
+            // Get negotiated cipher suite from rustls
+            let conn_guard = self.connection.lock();
+            let conn = conn_guard.as_ref()?;
+
+            let suite = conn.negotiated_cipher_suite()?;
+
+            // Extract cipher information using unified helper
+            let cipher_info = extract_cipher_info(&suite);
+
+            // Return as list with single tuple (name, version, bits)
+            let tuple = vm.ctx.new_tuple(vec![
+                vm.ctx.new_str(cipher_info.name).into(),
+                vm.ctx.new_str(cipher_info.protocol).into(),
+                vm.ctx.new_int(cipher_info.bits).into(),
+            ]);
+            Some(vm.ctx.new_list(vec![tuple.into()]))
+        }
+
+        #[pymethod]
+        fn verify_client_post_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // TLS 1.3 post-handshake authentication
+            // This is only valid for server-side TLS 1.3 connections
+
+            // Check if this is a server-side socket
+            if !self.server_side {
+                return Err(vm.new_value_error(
+                    "Cannot perform post-handshake authentication on client-side socket",
+                ));
+            }
+
+            // Check if handshake has been completed
+            if !*self.handshake_done.lock() {
+                return Err(vm.new_value_error(
+                    "Handshake must be completed before post-handshake authentication",
+                ));
+            }
+
+            // Check connection exists and protocol version
+            let conn_guard = self.connection.lock();
+            if let Some(conn) = conn_guard.as_ref() {
+                let version = match conn {
+                    TlsConnection::Client(_) => {
+                        return Err(vm.new_value_error(
+                            "Post-handshake authentication requires server socket",
+                        ));
+                    }
+                    TlsConnection::Server(server) => server.protocol_version(),
+                };
+
+                // Post-handshake auth is only available in TLS 1.3
+                if version != Some(rustls::ProtocolVersion::TLSv1_3) {
+                    // Get SSLError class from ssl module (not _ssl)
+                    // ssl.py imports _ssl.SSLError as ssl.SSLError
+                    let ssl_mod = vm.import("ssl", 0)?;
+                    let ssl_error_class = ssl_mod.get_attr("SSLError", vm)?;
+
+                    // Create SSLError instance with message containing WRONG_SSL_VERSION
+                    let msg = "[SSL: WRONG_SSL_VERSION] wrong ssl version";
+                    let args = vm.ctx.new_tuple(vec![vm.ctx.new_str(msg).into()]);
+                    let exc = ssl_error_class.call((args,), vm)?;
+
+                    return Err(exc
+                        .downcast()
+                        .map_err(|_| vm.new_type_error("Failed to create SSLError"))?);
+                }
+            } else {
+                return Err(vm.new_value_error("No SSL connection established"));
+            }
+
+            // rustls doesn't provide an API for post-handshake authentication.
+            // The rustls TLS library does not support requesting client certificates
+            // after the initial handshake is completed.
+            // Raise SSLError instead of NotImplementedError for compatibility
+            Err(vm
+                .new_os_subtype_error(
+                    PySSLError::class(&vm.ctx).to_owned(),
+                    None,
+                    "Post-handshake authentication is not supported by the rustls backend. \
+                 The rustls TLS library does not provide an API to request client certificates \
+                 after the initial handshake. Consider requesting the client certificate \
+                 during the initial handshake by setting the appropriate verify_mode before \
+                 calling do_handshake().",
+                )
+                .upcast())
+        }
+
+        #[pymethod]
+        fn get_channel_binding(
+            &self,
+            cb_type: OptionalArg<PyStrRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<PyBytesRef>> {
+            let cb_type_str = cb_type.as_ref().map_or("tls-unique", |s| s.as_str());
+
+            // rustls doesn't support channel binding (tls-unique, tls-server-end-point, etc.)
+            // This is because:
+            // 1. tls-unique requires access to TLS Finished messages, which rustls doesn't expose
+            // 2. tls-server-end-point requires the server certificate, which we don't track here
+            // 3. TLS 1.3 deprecated tls-unique anyway
+            //
+            // For compatibility, we'll return None (no channel binding available)
+            // rather than raising an error
+
+            if cb_type_str != "tls-unique" {
+                return Err(vm.new_value_error(format!(
+                    "Unsupported channel binding type '{cb_type_str}'",
+                )));
+            }
+
+            // Return None to indicate channel binding is not available
+            // This matches the behavior when the handshake hasn't completed yet
+            Ok(None)
+        }
+    }
+
+    impl Constructor for PySSLSocket {
+        type Args = ();
+
+        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(
+                "Cannot directly instantiate SSLSocket, use SSLContext.wrap_socket()",
+            ))
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
+    }
+
+    // MemoryBIO - provides in-memory buffer for SSL/TLS I/O
+    #[pyattr]
+    #[pyclass(name = "MemoryBIO", module = "ssl")]
+    #[derive(Debug, PyPayload)]
+    struct PyMemoryBIO {
+        // Internal buffer
+        buffer: PyMutex<Vec<u8>>,
+        // EOF flag
+        eof: PyRwLock<bool>,
+    }
+
+    #[pyclass(with(Constructor), flags(BASETYPE))]
+    impl PyMemoryBIO {
+        #[pymethod]
+        fn read(&self, len: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+            let mut buffer = self.buffer.lock();
+
+            if buffer.is_empty() && *self.eof.read() {
+                // Return empty bytes at EOF
+                return Ok(vm.ctx.new_bytes(vec![]));
+            }
+
+            let read_len = match len {
+                OptionalArg::Present(n) if n >= 0 => n as usize,
+                OptionalArg::Present(n) => {
+                    return Err(vm.new_value_error(format!("negative read length: {n}")));
+                }
+                OptionalArg::Missing => buffer.len(), // Read all available
+            };
+
+            let actual_len = read_len.min(buffer.len());
+            let data = buffer.drain(..actual_len).collect::<Vec<u8>>();
+
+            Ok(vm.ctx.new_bytes(data))
+        }
+
+        #[pymethod]
+        fn write(&self, buf: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+            // Check if it's a memoryview and if it's contiguous
+            if let Ok(mem_view) = buf.get_attr("c_contiguous", vm) {
+                // It's a memoryview, check if contiguous
+                let is_contiguous: bool = mem_view.try_to_bool(vm)?;
+                if !is_contiguous {
+                    return Err(vm.new_exception_msg(
+                        vm.ctx.exceptions.buffer_error.to_owned(),
+                        "non-contiguous buffer is not supported".to_owned(),
+                    ));
+                }
+            }
+
+            // Convert to bytes-like object
+            let bytes_like = ArgBytesLike::try_from_object(vm, buf)?;
+            let data = bytes_like.borrow_buf();
+            let len = data.len();
+
+            let mut buffer = self.buffer.lock();
+            buffer.extend_from_slice(&data);
+
+            Ok(len)
+        }
+
+        #[pymethod]
+        fn write_eof(&self, _vm: &VirtualMachine) -> PyResult<()> {
+            *self.eof.write() = true;
+            Ok(())
+        }
+
+        #[pygetset]
+        fn pending(&self) -> i32 {
+            self.buffer.lock().len() as i32
+        }
+
+        #[pygetset]
+        fn eof(&self) -> bool {
+            // EOF is true only when buffer is empty AND write_eof has been called
+            let pending = self.buffer.lock().len();
+            pending == 0 && *self.eof.read()
+        }
+    }
+
+    impl Representable for PyMemoryBIO {
+        #[inline]
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok("<MemoryBIO>".to_owned())
+        }
+    }
+
+    impl Constructor for PyMemoryBIO {
+        type Args = ();
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(PyMemoryBIO {
+                buffer: PyMutex::new(Vec::new()),
+                eof: PyRwLock::new(false),
+            })
+        }
+    }
+
+    // SSLSession - represents a cached SSL session
+    // NOTE: This is an EMULATION - actual session data is managed by Rustls internally
+    #[pyattr]
+    #[pyclass(name = "SSLSession", module = "ssl")]
+    #[derive(Debug, PyPayload)]
+    struct PySSLSession {
+        // Session data - serialized rustls session (EMULATED - kept empty)
+        session_data: Vec<u8>,
+        // Session ID - synthetic ID generated from metadata (NOT actual TLS session ID)
+        #[allow(dead_code)]
+        session_id: Vec<u8>,
+        // Session metadata
+        creation_time: std::time::SystemTime,
+        // Lifetime in seconds (default 7200 = 2 hours)
+        lifetime: u64,
+    }
+
+    #[pyclass(flags(BASETYPE))]
+    impl PySSLSession {
+        #[pygetset]
+        fn time(&self) -> i64 {
+            // Return session creation time as Unix timestamp
+            self.creation_time
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_secs() as i64
+        }
+
+        #[pygetset]
+        fn timeout(&self) -> i64 {
+            // Return session timeout/lifetime in seconds
+            self.lifetime as i64
+        }
+
+        #[pygetset]
+        fn ticket_lifetime_hint(&self) -> i64 {
+            // Return ticket lifetime hint (same as timeout for rustls)
+            self.lifetime as i64
+        }
+
+        #[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);
+            let hash = hasher.finish();
+
+            // Convert hash to bytes
+            vm.ctx.new_bytes(hash.to_be_bytes().to_vec())
+        }
+
+        #[pygetset]
+        fn has_ticket(&self) -> bool {
+            // For rustls, if we have session data, we have a ticket
+            !self.session_data.is_empty()
+        }
+    }
+
+    impl Representable for PySSLSession {
+        #[inline]
+        fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            Ok("<SSLSession>".to_owned())
+        }
+    }
+
+    // Helper functions
+
+    // OID module already imported at top of _ssl module
+
+    #[derive(FromArgs)]
+    struct Txt2ObjArgs {
+        txt: PyStrRef,
+        #[pyarg(named, optional)]
+        name: OptionalArg<bool>,
+    }
+
+    #[pyfunction]
+    fn txt2obj(args: Txt2ObjArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let txt = args.txt.as_str();
+        let name = args.name.unwrap_or(false);
+
+        // If name=False (default), only accept OID strings
+        // If name=True, accept both names and OID strings
+        let entry = if txt
+            .chars()
+            .next()
+            .map(|c| c.is_ascii_digit())
+            .unwrap_or(false)
+        {
+            // Looks like an OID string (starts with digit)
+            oid::find_by_oid_string(txt)
+        } else if name {
+            // name=True: allow shortname/longname lookup
+            oid::find_by_name(txt)
+        } else {
+            // name=False: only OID strings allowed, not names
+            None
+        };
+
+        let entry = entry.ok_or_else(|| vm.new_value_error(format!("unknown object '{txt}'")))?;
+
+        // Return tuple: (nid, shortname, longname, oid)
+        Ok(vm
+            .new_tuple((
+                vm.ctx.new_int(entry.nid),
+                vm.ctx.new_str(entry.short_name),
+                vm.ctx.new_str(entry.long_name),
+                vm.ctx.new_str(entry.oid_string()),
+            ))
+            .into())
+    }
+
+    #[pyfunction]
+    fn nid2obj(nid: i32, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let entry = oid::find_by_nid(nid)
+            .ok_or_else(|| vm.new_value_error(format!("unknown NID {nid}")))?;
+
+        // Return tuple: (nid, shortname, longname, oid)
+        Ok(vm
+            .new_tuple((
+                vm.ctx.new_int(entry.nid),
+                vm.ctx.new_str(entry.short_name),
+                vm.ctx.new_str(entry.long_name),
+                vm.ctx.new_str(entry.oid_string()),
+            ))
+            .into())
+    }
+
+    #[pyfunction]
+    fn get_default_verify_paths(vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Return default certificate paths as a tuple
+        // Lib/ssl.py expects: (openssl_cafile_env, openssl_cafile, openssl_capath_env, openssl_capath)
+        // parts[0] = environment variable name for cafile
+        // parts[1] = default cafile path
+        // parts[2] = environment variable name for capath
+        // parts[3] = default capath path
+
+        // Common default paths for different platforms
+        // These match the first candidates that rustls-native-certs/openssl-probe checks
+        #[cfg(target_os = "macos")]
+        let (default_cafile, default_capath) = {
+            // macOS primarily uses Keychain API, but provides fallback paths
+            // for compatibility and when Keychain access fails
+            (Some("/etc/ssl/cert.pem"), Some("/etc/ssl/certs"))
+        };
+
+        #[cfg(target_os = "linux")]
+        let (default_cafile, default_capath) = {
+            // Linux: matches openssl-probe's first candidate (/etc/ssl/cert.pem)
+            // openssl-probe checks multiple locations at runtime, but we return
+            // OpenSSL's compile-time default
+            (Some("/etc/ssl/cert.pem"), Some("/etc/ssl/certs"))
+        };
+
+        #[cfg(windows)]
+        let (default_cafile, default_capath) = {
+            // Windows uses certificate store, not file paths
+            // Return empty strings to avoid None being passed to os.path.isfile()
+            (Some(""), Some(""))
+        };
+
+        #[cfg(not(any(target_os = "macos", target_os = "linux", windows)))]
+        let (default_cafile, default_capath): (Option<&str>, Option<&str>) = (None, None);
+
+        let tuple = vm.ctx.new_tuple(vec![
+            vm.ctx.new_str("SSL_CERT_FILE").into(), // openssl_cafile_env
+            default_cafile
+                .map(|s| vm.ctx.new_str(s).into())
+                .unwrap_or_else(|| vm.ctx.none()), // openssl_cafile
+            vm.ctx.new_str("SSL_CERT_DIR").into(),  // openssl_capath_env
+            default_capath
+                .map(|s| vm.ctx.new_str(s).into())
+                .unwrap_or_else(|| vm.ctx.none()), // openssl_capath
+        ]);
+        Ok(tuple.into())
+    }
+
+    #[pyfunction]
+    fn RAND_status() -> i32 {
+        1 // Always have good randomness with aws-lc-rs
+    }
+
+    #[pyfunction]
+    fn RAND_add(_string: PyObjectRef, _entropy: f64) {
+        // No-op: aws-lc-rs handles its own entropy
+        // Accept any type (str, bytes, bytearray)
+    }
+
+    #[pyfunction]
+    fn RAND_bytes(n: i64, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+        use aws_lc_rs::rand::{SecureRandom, SystemRandom};
+
+        // Validate n is not negative
+        if n < 0 {
+            return Err(vm.new_value_error("num must be positive"));
+        }
+
+        let n_usize = n as usize;
+        let rng = SystemRandom::new();
+        let mut buf = vec![0u8; n_usize];
+        rng.fill(&mut buf)
+            .map_err(|_| vm.new_os_error("Failed to generate random bytes"))?;
+        Ok(PyBytesRef::from(vm.ctx.new_bytes(buf)))
+    }
+
+    #[pyfunction]
+    fn RAND_pseudo_bytes(n: i64, vm: &VirtualMachine) -> PyResult<(PyBytesRef, bool)> {
+        // In rustls/aws-lc-rs, all random bytes are cryptographically strong
+        let bytes = RAND_bytes(n, vm)?;
+        Ok((bytes, true))
+    }
+
+    /// Test helper to decode a certificate from a file path
+    ///
+    /// 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> {
+        // Read certificate file
+        let cert_data = std::fs::read(path.as_str()).map_err(|e| {
+            vm.new_os_error(format!(
+                "Failed to read certificate file {}: {}",
+                path.as_str(),
+                e
+            ))
+        })?;
+
+        // Auto-detect PEM vs DER format
+        let cert_der = if cert_data
+            .windows(27)
+            .any(|w| w == b"-----BEGIN CERTIFICATE-----")
+        {
+            // Parse PEM format
+            let mut cursor = std::io::Cursor::new(&cert_data);
+            rustls_pemfile::certs(&mut cursor)
+                .find_map(|r| r.ok())
+                .ok_or_else(|| vm.new_value_error("No valid certificate found in PEM file"))?
+                .to_vec()
+        } else {
+            // Assume DER format
+            cert_data
+        };
+
+        // Reuse the comprehensive helper function
+        cert::cert_der_to_dict_helper(vm, &cert_der)
+    }
+
+    #[pyfunction]
+    fn DER_cert_to_PEM_cert(der_cert: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let der_bytes = der_cert.borrow_buf();
+        let bytes_slice: &[u8] = der_bytes.as_ref();
+
+        // Use pem-rfc7468 for RFC 7468 compliant PEM encoding
+        let pem_str = encode_string("CERTIFICATE", LineEnding::LF, bytes_slice)
+            .map_err(|e| vm.new_value_error(format!("PEM encoding failed: {e}")))?;
+
+        Ok(vm.ctx.new_str(pem_str))
+    }
+
+    #[pyfunction]
+    fn PEM_cert_to_DER_cert(pem_cert: PyStrRef, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+        let pem_str = pem_cert.as_str();
+
+        // Parse PEM format
+        let mut cursor = std::io::Cursor::new(pem_str.as_bytes());
+        let mut certs = rustls_pemfile::certs(&mut cursor);
+
+        if let Some(Ok(cert)) = certs.next() {
+            Ok(vm.ctx.new_bytes(cert.to_vec()))
+        } else {
+            Err(vm.new_value_error("Failed to parse PEM certificate"))
+        }
+    }
+
+    // Windows-specific certificate store enumeration functions
+    #[cfg(windows)]
+    #[pyfunction]
+    fn enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        use schannel::{RawPointer, cert_context::ValidUses, cert_store::CertStore};
+        use windows_sys::Win32::Security::Cryptography;
+
+        // 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())
+            .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()
+            )));
+        }
+
+        let certs = stores.iter().flat_map(|s| s.certs()).map(|c| {
+            let cert = vm.ctx.new_bytes(c.to_der().to_owned());
+            let enc_type = unsafe {
+                let ptr = c.as_ptr() as *const Cryptography::CERT_CONTEXT;
+                (*ptr).dwCertEncodingType
+            };
+            let enc_type = match enc_type {
+                Cryptography::X509_ASN_ENCODING => vm.new_pyobj("x509_asn"),
+                Cryptography::PKCS_7_ASN_ENCODING => vm.new_pyobj("pkcs_7_asn"),
+                other => vm.new_pyobj(other),
+            };
+            let usage: PyObjectRef = match c.valid_uses() {
+                Ok(ValidUses::All) => vm.ctx.new_bool(true).into(),
+                Ok(ValidUses::Oids(oids)) => {
+                    match crate::builtins::PyFrozenSet::from_iter(
+                        vm,
+                        oids.into_iter().map(|oid| vm.ctx.new_str(oid).into()),
+                    ) {
+                        Ok(set) => set.into_ref(&vm.ctx).into(),
+                        Err(_) => vm.ctx.new_bool(true).into(),
+                    }
+                }
+                Err(_) => vm.ctx.new_bool(true).into(),
+            };
+            Ok(vm.new_tuple((cert, enc_type, usage)).into())
+        });
+        certs.collect::<PyResult<Vec<_>>>()
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn enum_crls(store_name: PyStrRef, 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()
+            .encode_utf16()
+            .chain(std::iter::once(0))
+            .collect();
+
+        // Open system store
+        let store = unsafe { CertOpenSystemStoreW(0, store_name_wide.as_ptr()) };
+
+        if store.is_null() {
+            return Err(vm.new_os_error(format!(
+                "failed to open certificate store {:?}",
+                store_name.as_str()
+            )));
+        }
+
+        let mut result = Vec::new();
+
+        let mut crl_context: *const CRL_CONTEXT = core::ptr::null();
+        loop {
+            crl_context = unsafe { CertEnumCRLsInStore(store, crl_context) };
+            if crl_context.is_null() {
+                break;
+            }
+
+            let crl = unsafe { &*crl_context };
+            let crl_bytes =
+                unsafe { std::slice::from_raw_parts(crl.pbCrlEncoded, crl.cbCrlEncoded as usize) };
+
+            let enc_type = if crl.dwCertEncodingType == X509_ASN_ENCODING {
+                vm.new_pyobj("x509_asn")
+            } else {
+                vm.new_pyobj(crl.dwCertEncodingType)
+            };
+
+            result.push(
+                vm.new_tuple((vm.ctx.new_bytes(crl_bytes.to_vec()), enc_type))
+                    .into(),
+            );
+        }
+
+        unsafe { CertCloseStore(store, 0) };
+
+        Ok(result)
+    }
+
+    // Certificate type for SSL module (pure Rust implementation)
+    #[pyattr]
+    #[pyclass(module = "_ssl", name = "Certificate")]
+    #[derive(Debug, PyPayload)]
+    pub struct PySSLCertificate {
+        // Store the raw DER bytes
+        der_bytes: Vec<u8>,
+    }
+
+    impl PySSLCertificate {
+        // Parse the certificate lazily
+        fn parse(&self) -> Result<x509_parser::certificate::X509Certificate<'_>, String> {
+            match x509_parser::parse_x509_certificate(&self.der_bytes) {
+                Ok((_, cert)) => Ok(cert),
+                Err(e) => Err(format!("Failed to parse certificate: {e}")),
+            }
+        }
+    }
+
+    #[pyclass(with(Comparable, Hashable, Representable))]
+    impl PySSLCertificate {
+        #[pymethod]
+        fn public_bytes(
+            &self,
+            format: OptionalArg<i32>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let format = format.unwrap_or(ENCODING_PEM);
+
+            match format {
+                x if x == ENCODING_DER => {
+                    // Return DER bytes directly
+                    Ok(vm.ctx.new_bytes(self.der_bytes.clone()).into())
+                }
+                x if x == ENCODING_PEM => {
+                    // Convert DER to PEM using RFC 7468 compliant encoding
+                    let pem_str = encode_string("CERTIFICATE", LineEnding::LF, &self.der_bytes)
+                        .map_err(|e| vm.new_value_error(format!("PEM encoding failed: {e}")))?;
+                    Ok(vm.ctx.new_str(pem_str).into())
+                }
+                _ => Err(vm.new_value_error("Unsupported format")),
+            }
+        }
+
+        #[pymethod]
+        fn get_info(&self, vm: &VirtualMachine) -> PyResult {
+            let cert = self.parse().map_err(|e| vm.new_value_error(e))?;
+            cert::cert_to_dict(vm, &cert)
+        }
+    }
+
+    // Implement Comparable trait for PySSLCertificate
+    impl Comparable for PySSLCertificate {
+        fn cmp(
+            zelf: &Py<Self>,
+            other: &PyObject,
+            op: PyComparisonOp,
+            _vm: &VirtualMachine,
+        ) -> PyResult<PyComparisonValue> {
+            op.eq_only(|| {
+                if let Some(other_cert) = other.downcast_ref::<Self>() {
+                    Ok((zelf.der_bytes == other_cert.der_bytes).into())
+                } else {
+                    Ok(PyComparisonValue::NotImplemented)
+                }
+            })
+        }
+    }
+
+    // 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)
+        }
+    }
+
+    // Implement Representable trait for PySSLCertificate
+    impl Representable for PySSLCertificate {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            // Try to parse and show subject
+            match zelf.parse() {
+                Ok(cert) => {
+                    let subject = cert.subject();
+                    // Get CN if available
+                    let cn = subject
+                        .iter_common_name()
+                        .next()
+                        .and_then(|attr| attr.as_str().ok())
+                        .unwrap_or("Unknown");
+                    Ok(format!("<Certificate(subject=CN={cn})>"))
+                }
+                Err(_) => Ok("<Certificate(invalid)>".to_owned()),
+            }
+        }
+    }
+}
diff --git a/crates/stdlib/src/ssl/cert.rs b/crates/stdlib/src/ssl/cert.rs
new file mode 100644
index 0000000000..cd39972cf4
--- /dev/null
+++ b/crates/stdlib/src/ssl/cert.rs
@@ -0,0 +1,1776 @@
+// cspell: ignore accessdescs
+
+//! Certificate parsing, validation, and conversion utilities for SSL/TLS
+//!
+//! This module provides reusable functions for working with X.509 certificates:
+//! - Parsing PEM/DER encoded certificates
+//! - Validating certificate properties (CA status, etc.)
+//! - Converting certificates to Python dict format
+//! - Building and verifying certificate chains
+//! - Loading certificates from files, directories, and bytes
+
+use alloc::sync::Arc;
+use chrono::{DateTime, Utc};
+use parking_lot::RwLock as ParkingRwLock;
+use rustls::{
+    DigitallySignedStruct, RootCertStore, SignatureScheme,
+    client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier},
+    pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime},
+    server::danger::{ClientCertVerified, ClientCertVerifier},
+};
+use rustpython_vm::{PyObjectRef, PyResult, VirtualMachine};
+use std::collections::HashSet;
+use x509_parser::prelude::*;
+
+use super::compat::{VERIFY_X509_PARTIAL_CHAIN, VERIFY_X509_STRICT};
+
+// Certificate Verification Constants
+
+/// All supported signature schemes for certificate verification
+///
+/// This list includes all modern signature algorithms supported by rustls.
+/// Used by verifiers that accept any signature scheme (NoVerifier, EmptyRootStoreVerifier).
+const ALL_SIGNATURE_SCHEMES: &[SignatureScheme] = &[
+    SignatureScheme::RSA_PKCS1_SHA256,
+    SignatureScheme::RSA_PKCS1_SHA384,
+    SignatureScheme::RSA_PKCS1_SHA512,
+    SignatureScheme::ECDSA_NISTP256_SHA256,
+    SignatureScheme::ECDSA_NISTP384_SHA384,
+    SignatureScheme::ECDSA_NISTP521_SHA512,
+    SignatureScheme::RSA_PSS_SHA256,
+    SignatureScheme::RSA_PSS_SHA384,
+    SignatureScheme::RSA_PSS_SHA512,
+    SignatureScheme::ED25519,
+];
+
+// Error Handling Utilities
+
+/// Certificate loading error types with specific error messages
+///
+/// This module provides consistent error creation functions for certificate
+/// operations, reducing code duplication and ensuring uniform error messages
+/// across the codebase.
+mod cert_error {
+    use alloc::sync::Arc;
+    use core::fmt::{Debug, Display};
+    use std::io;
+
+    /// Create InvalidData error with formatted message
+    pub fn invalid_data(msg: impl Into<String>) -> io::Error {
+        io::Error::new(io::ErrorKind::InvalidData, msg.into())
+    }
+
+    /// PEM parsing error variants
+    pub mod pem {
+        use super::*;
+
+        pub fn no_start_line(context: &str) -> io::Error {
+            invalid_data(format!("no start line: {context}"))
+        }
+
+        pub fn parse_failed(e: impl Display) -> io::Error {
+            invalid_data(format!("Failed to parse PEM certificate: {e}"))
+        }
+
+        pub fn parse_failed_debug(e: impl Debug) -> io::Error {
+            invalid_data(format!("Failed to parse PEM certificate: {e:?}"))
+        }
+
+        pub fn invalid_cert() -> io::Error {
+            invalid_data("No certificates found in certificate file")
+        }
+    }
+
+    /// DER parsing error variants
+    pub mod der {
+        use super::*;
+
+        pub fn not_enough_data(context: &str) -> io::Error {
+            invalid_data(format!("not enough data: {context}"))
+        }
+
+        pub fn parse_failed(e: impl Display) -> io::Error {
+            invalid_data(format!("Failed to parse DER certificate: {e}"))
+        }
+    }
+
+    /// Private key error variants
+    pub mod key {
+        use super::*;
+
+        pub fn not_found(context: &str) -> io::Error {
+            invalid_data(format!("No private key found in {context}"))
+        }
+
+        pub fn parse_failed(e: impl Display) -> io::Error {
+            invalid_data(format!("Failed to parse private key: {e}"))
+        }
+
+        pub fn parse_encrypted_failed(e: impl Display) -> io::Error {
+            invalid_data(format!("Failed to parse encrypted private key: {e}"))
+        }
+
+        pub fn decrypt_failed(e: impl Display) -> io::Error {
+            io::Error::other(format!(
+                "Failed to decrypt private key (wrong password?): {e}",
+            ))
+        }
+    }
+
+    /// Convert error message to rustls::Error with InvalidCertificate wrapper
+    pub fn to_rustls_invalid_cert(msg: impl Into<String>) -> rustls::Error {
+        rustls::Error::InvalidCertificate(rustls::CertificateError::Other(rustls::OtherError(
+            Arc::new(invalid_data(msg)),
+        )))
+    }
+
+    /// Convert error message to rustls::Error with InvalidCertificate wrapper and custom ErrorKind
+    pub fn to_rustls_cert_error(kind: io::ErrorKind, msg: impl Into<String>) -> rustls::Error {
+        rustls::Error::InvalidCertificate(rustls::CertificateError::Other(rustls::OtherError(
+            Arc::new(io::Error::new(kind, msg.into())),
+        )))
+    }
+}
+
+// Helper Functions for Certificate Parsing
+
+/// Map X.509 OID to human-readable attribute name
+///
+/// Converts common X.509 Distinguished Name OIDs to their standard names.
+/// Returns the OID string itself if not recognized.
+fn oid_to_attribute_name(oid_str: &str) -> &str {
+    match oid_str {
+        "2.5.4.3" => "commonName",
+        "2.5.4.6" => "countryName",
+        "2.5.4.7" => "localityName",
+        "2.5.4.8" => "stateOrProvinceName",
+        "2.5.4.10" => "organizationName",
+        "2.5.4.11" => "organizationalUnitName",
+        "1.2.840.113549.1.9.1" => "emailAddress",
+        _ => oid_str,
+    }
+}
+
+/// Format IP address (IPv4 or IPv6) to string
+///
+/// Formats raw IP address bytes according to standard notation:
+/// - IPv4: dotted decimal (e.g., "192.0.2.1")
+/// - IPv6: colon-separated hex (e.g., "2001:DB8:0:0:0:0:0:1")
+fn format_ip_address(ip: &[u8]) -> String {
+    if ip.len() == 4 {
+        // IPv4
+        format!("{}.{}.{}.{}", ip[0], ip[1], ip[2], ip[3])
+    } else if ip.len() == 16 {
+        // IPv6 - format in full form without compression (uppercase)
+        // CPython returns IPv6 in full form: 2001:DB8:0:0:0:0:0:1 (not 2001:db8::1)
+        let segments = [
+            u16::from_be_bytes([ip[0], ip[1]]),
+            u16::from_be_bytes([ip[2], ip[3]]),
+            u16::from_be_bytes([ip[4], ip[5]]),
+            u16::from_be_bytes([ip[6], ip[7]]),
+            u16::from_be_bytes([ip[8], ip[9]]),
+            u16::from_be_bytes([ip[10], ip[11]]),
+            u16::from_be_bytes([ip[12], ip[13]]),
+            u16::from_be_bytes([ip[14], ip[15]]),
+        ];
+        format!(
+            "{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}:{:X}",
+            segments[0],
+            segments[1],
+            segments[2],
+            segments[3],
+            segments[4],
+            segments[5],
+            segments[6],
+            segments[7]
+        )
+    } else {
+        // Unknown format - return as debug string
+        format!("{ip:?}")
+    }
+}
+
+/// Format ASN.1 time to string
+///
+/// Formats certificate validity dates in the format:
+/// "Mon DD HH:MM:SS YYYY GMT"
+fn format_asn1_time(time: &x509_parser::time::ASN1Time) -> String {
+    let timestamp = time.timestamp();
+    DateTime::<Utc>::from_timestamp(timestamp, 0)
+        .expect("ASN1Time must be valid timestamp")
+        .format("%b %e %H:%M:%S %Y GMT")
+        .to_string()
+}
+
+/// Format certificate serial number to hexadecimal string with even padding
+///
+/// Converts a BigUint serial number to uppercase hex string, ensuring
+/// even length by prepending '0' if necessary.
+fn format_serial_number(serial: &num_bigint::BigUint) -> String {
+    let mut serial_str = serial.to_str_radix(16).to_uppercase();
+    if serial_str.len() % 2 == 1 {
+        serial_str.insert(0, '0');
+    }
+    serial_str
+}
+
+/// Normalize wildcard hostname by stripping "*." prefix
+///
+/// Returns the normalized hostname without the wildcard prefix.
+/// Used for wildcard certificate matching.
+fn normalize_wildcard_hostname(hostname: &str) -> &str {
+    hostname.strip_prefix("*.").unwrap_or(hostname)
+}
+
+/// Process Subject Alternative Name (SAN) general names into Python tuples
+///
+/// Converts X.509 GeneralName entries into Python tuple format.
+/// Returns a vector of PyObjectRef tuples in the format: (type, value)
+fn process_san_general_names(
+    vm: &VirtualMachine,
+    general_names: &[GeneralName<'_>],
+) -> Vec<PyObjectRef> {
+    general_names
+        .iter()
+        .filter_map(|name| match name {
+            GeneralName::DNSName(dns) => Some(vm.new_tuple(("DNS", *dns)).into()),
+            GeneralName::IPAddress(ip) => {
+                let ip_str = format_ip_address(ip);
+                Some(vm.new_tuple(("IP Address", ip_str)).into())
+            }
+            GeneralName::RFC822Name(email) => Some(vm.new_tuple(("email", *email)).into()),
+            GeneralName::URI(uri) => Some(vm.new_tuple(("URI", *uri)).into()),
+            GeneralName::DirectoryName(dn) => {
+                let dn_str = format!("{dn}");
+                Some(vm.new_tuple(("DirName", dn_str)).into())
+            }
+            GeneralName::RegisteredID(oid) => {
+                let oid_str = oid.to_string();
+                Some(vm.new_tuple(("Registered ID", oid_str)).into())
+            }
+            GeneralName::OtherName(oid, value) => {
+                let oid_str = oid.to_string();
+                let value_str = format!("{value:?}");
+                Some(
+                    vm.new_tuple(("othername", format!("{oid_str}:{value_str}")))
+                        .into(),
+                )
+            }
+            _ => None,
+        })
+        .collect()
+}
+
+// Certificate Validation and Parsing
+
+/// Check if a certificate is a CA certificate by examining the Basic Constraints extension
+///
+/// Returns `true` if the certificate has Basic Constraints with CA=true,
+/// `false` otherwise (including parse errors or missing extension).
+/// This matches OpenSSL's X509_check_ca() behavior.
+pub fn is_ca_certificate(cert_der: &[u8]) -> bool {
+    // Parse the certificate
+    let Ok((_, cert)) = X509Certificate::from_der(cert_der) else {
+        return false;
+    };
+
+    // Check Basic Constraints extension
+    // If extension exists and CA=true, it's a CA certificate
+    // Otherwise (no extension or CA=false), it's NOT a CA certificate
+    if let Ok(Some(ext)) = cert.basic_constraints() {
+        return ext.value.ca;
+    }
+
+    // No Basic Constraints extension -> NOT a CA certificate
+    // (matches OpenSSL X509_check_ca() behavior)
+    false
+}
+
+/// Convert an X509Name to Python nested tuple format for SSL certificate dicts
+///
+/// Format: ((('CN', 'example.com'),), (('O', 'Example Org'),), ...)
+fn name_to_py(vm: &VirtualMachine, name: &x509_parser::x509::X509Name<'_>) -> PyResult {
+    let list: Vec<PyObjectRef> = name
+        .iter()
+        .flat_map(|rdn| {
+            // Each RDN can have multiple attributes
+            rdn.iter()
+                .map(|attr| {
+                    let oid_str = attr.attr_type().to_id_string();
+                    let value_str = attr.attr_value().as_str().unwrap_or("").to_string();
+                    let key = oid_to_attribute_name(&oid_str);
+
+                    vm.new_tuple((vm.new_tuple((vm.ctx.new_str(key), vm.ctx.new_str(value_str))),))
+                        .into()
+                })
+                .collect::<Vec<_>>()
+        })
+        .collect();
+
+    Ok(vm.ctx.new_tuple(list).into())
+}
+
+/// Convert DER-encoded certificate to Python dict (for getpeercert with binary_form=False)
+///
+/// Returns a dict with fields: subject, issuer, version, serialNumber,
+/// notBefore, notAfter, subjectAltName (if present)
+pub fn cert_to_dict(
+    vm: &VirtualMachine,
+    cert: &x509_parser::certificate::X509Certificate<'_>,
+) -> PyResult {
+    let dict = vm.ctx.new_dict();
+
+    // Subject and Issuer
+    dict.set_item("subject", name_to_py(vm, cert.subject())?, vm)?;
+    dict.set_item("issuer", name_to_py(vm, cert.issuer())?, vm)?;
+
+    // Version (X.509 v3 = version 2 in the cert, but Python uses 3)
+    dict.set_item(
+        "version",
+        vm.ctx.new_int(cert.version().0 as i32 + 1).into(),
+        vm,
+    )?;
+
+    // Serial number - hex format with even length
+    let serial = format_serial_number(&cert.serial);
+    dict.set_item("serialNumber", vm.ctx.new_str(serial).into(), vm)?;
+
+    // Validity dates - format with GMT using chrono
+    dict.set_item(
+        "notBefore",
+        vm.ctx
+            .new_str(format_asn1_time(&cert.validity().not_before))
+            .into(),
+        vm,
+    )?;
+    dict.set_item(
+        "notAfter",
+        vm.ctx
+            .new_str(format_asn1_time(&cert.validity().not_after))
+            .into(),
+        vm,
+    )?;
+
+    // Subject Alternative Names (if present)
+    if let Ok(Some(san_ext)) = cert.subject_alternative_name() {
+        let san_list = process_san_general_names(vm, &san_ext.value.general_names);
+
+        if !san_list.is_empty() {
+            dict.set_item("subjectAltName", vm.ctx.new_tuple(san_list).into(), vm)?;
+        }
+    }
+
+    Ok(dict.into())
+}
+
+/// Convert DER-encoded certificate to Python dict (for get_ca_certs)
+///
+/// Similar to cert_to_dict but includes additional fields like crlDistributionPoints
+/// and uses CPython's specific ordering: issuer, notAfter, notBefore, serialNumber, subject, version
+pub fn cert_der_to_dict_helper(vm: &VirtualMachine, cert_der: &[u8]) -> PyResult<PyObjectRef> {
+    // Parse the certificate using x509-parser
+    let (_, cert) = x509_parser::parse_x509_certificate(cert_der)
+        .map_err(|e| vm.new_value_error(format!("Failed to parse certificate: {e}")))?;
+
+    // Helper to convert X509Name to nested tuple format
+    let name_to_tuple = |name: &x509_parser::x509::X509Name<'_>| -> PyResult {
+        let mut entries = Vec::new();
+        for rdn in name.iter() {
+            for attr in rdn.iter() {
+                let oid_str = attr.attr_type().to_id_string();
+
+                // Get value as bytes and convert to string
+                let value_str = if let Ok(s) = attr.attr_value().as_str() {
+                    s.to_string()
+                } else {
+                    let value_bytes = attr.attr_value().data;
+                    match core::str::from_utf8(value_bytes) {
+                        Ok(s) => s.to_string(),
+                        Err(_) => String::from_utf8_lossy(value_bytes).into_owned(),
+                    }
+                };
+
+                let key = oid_to_attribute_name(&oid_str);
+
+                let entry =
+                    vm.new_tuple((vm.ctx.new_str(key.to_string()), vm.ctx.new_str(value_str)));
+                entries.push(vm.new_tuple((entry,)).into());
+            }
+        }
+        Ok(vm.ctx.new_tuple(entries).into())
+    };
+
+    let dict = vm.ctx.new_dict();
+
+    // CPython ordering: issuer, notAfter, notBefore, serialNumber, subject, version
+    dict.set_item("issuer", name_to_tuple(cert.issuer())?, vm)?;
+
+    // Validity - format with GMT using chrono
+    dict.set_item(
+        "notAfter",
+        vm.ctx
+            .new_str(format_asn1_time(&cert.validity().not_after))
+            .into(),
+        vm,
+    )?;
+    dict.set_item(
+        "notBefore",
+        vm.ctx
+            .new_str(format_asn1_time(&cert.validity().not_before))
+            .into(),
+        vm,
+    )?;
+
+    // Serial number - hex format with even length
+    let serial = format_serial_number(&cert.serial);
+    dict.set_item("serialNumber", vm.ctx.new_str(serial).into(), vm)?;
+
+    dict.set_item("subject", name_to_tuple(cert.subject())?, vm)?;
+
+    // Version
+    dict.set_item(
+        "version",
+        vm.ctx.new_int(cert.version().0 as i32 + 1).into(),
+        vm,
+    )?;
+
+    // Authority Information Access (OCSP and caIssuers) - use x509-parser's extensions_map
+    let mut ocsp_urls = Vec::new();
+    let mut ca_issuer_urls = Vec::new();
+    let mut crl_urls = Vec::new();
+
+    if let Ok(ext_map) = cert.tbs_certificate.extensions_map() {
+        use x509_parser::extensions::{GeneralName, ParsedExtension};
+        use x509_parser::oid_registry::{
+            OID_PKIX_AUTHORITY_INFO_ACCESS, OID_X509_EXT_CRL_DISTRIBUTION_POINTS,
+        };
+
+        // Authority Information Access
+        if let Some(ext) = ext_map.get(&OID_PKIX_AUTHORITY_INFO_ACCESS)
+            && let ParsedExtension::AuthorityInfoAccess(aia) = &ext.parsed_extension()
+        {
+            for desc in &aia.accessdescs {
+                if let GeneralName::URI(uri) = &desc.access_location {
+                    let method_str = desc.access_method.to_id_string();
+                    if method_str == "1.3.6.1.5.5.7.48.1" {
+                        // OCSP
+                        ocsp_urls.push(vm.ctx.new_str(uri.to_string()).into());
+                    } else if method_str == "1.3.6.1.5.5.7.48.2" {
+                        // caIssuers
+                        ca_issuer_urls.push(vm.ctx.new_str(uri.to_string()).into());
+                    }
+                }
+            }
+        }
+
+        // CRL Distribution Points
+        if let Some(ext) = ext_map.get(&OID_X509_EXT_CRL_DISTRIBUTION_POINTS)
+            && let ParsedExtension::CRLDistributionPoints(cdp) = &ext.parsed_extension()
+        {
+            for dp in cdp.points.iter() {
+                if let Some(dist_point) = &dp.distribution_point {
+                    use x509_parser::extensions::DistributionPointName;
+                    if let DistributionPointName::FullName(names) = dist_point {
+                        for name in names {
+                            if let GeneralName::URI(uri) = name {
+                                crl_urls.push(vm.ctx.new_str(uri.to_string()).into());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if !ocsp_urls.is_empty() {
+        dict.set_item("OCSP", vm.ctx.new_tuple(ocsp_urls).into(), vm)?;
+    }
+    if !ca_issuer_urls.is_empty() {
+        dict.set_item("caIssuers", vm.ctx.new_tuple(ca_issuer_urls).into(), vm)?;
+    }
+    if !crl_urls.is_empty() {
+        dict.set_item(
+            "crlDistributionPoints",
+            vm.ctx.new_tuple(crl_urls).into(),
+            vm,
+        )?;
+    }
+
+    // Subject Alternative Names
+    if let Ok(Some(san_ext)) = cert.subject_alternative_name() {
+        let mut san_entries = Vec::new();
+        for name in &san_ext.value.general_names {
+            use x509_parser::extensions::GeneralName;
+            match name {
+                GeneralName::DNSName(dns) => {
+                    san_entries.push(vm.new_tuple(("DNS", *dns)).into());
+                }
+                GeneralName::IPAddress(ip) => {
+                    let ip_str = format_ip_address(ip);
+                    san_entries.push(vm.new_tuple(("IP Address", ip_str)).into());
+                }
+                GeneralName::RFC822Name(email) => {
+                    san_entries.push(vm.new_tuple(("email", *email)).into());
+                }
+                GeneralName::URI(uri) => {
+                    san_entries.push(vm.new_tuple(("URI", *uri)).into());
+                }
+                GeneralName::OtherName(_oid, _data) => {
+                    // OtherName is not fully supported, mark as unsupported
+                    san_entries.push(vm.new_tuple(("othername", "<unsupported>")).into());
+                }
+                GeneralName::DirectoryName(name) => {
+                    // Convert X509Name to nested tuple format
+                    let dir_tuple = name_to_tuple(name)?;
+                    san_entries.push(vm.new_tuple(("DirName", dir_tuple)).into());
+                }
+                GeneralName::RegisteredID(oid) => {
+                    // Convert OID to string representation
+                    let oid_str = oid.to_id_string();
+                    san_entries.push(vm.new_tuple(("Registered ID", oid_str)).into());
+                }
+                _ => {}
+            }
+        }
+        if !san_entries.is_empty() {
+            dict.set_item("subjectAltName", vm.ctx.new_tuple(san_entries).into(), vm)?;
+        }
+    }
+
+    Ok(dict.into())
+}
+
+/// Build a verified certificate chain by adding CA certificates from the trust store
+///
+/// Takes peer certificates (from TLS handshake) and extends the chain by finding
+/// issuer certificates from the trust store until reaching a root certificate.
+///
+/// Returns the complete chain as DER-encoded bytes.
+pub fn build_verified_chain(
+    peer_certs: &[CertificateDer<'static>],
+    ca_certs_der: &[Vec<u8>],
+) -> Vec<Vec<u8>> {
+    let mut chain_der: Vec<Vec<u8>> = Vec::new();
+
+    // Start with peer certificates (what was sent during handshake)
+    for cert in peer_certs {
+        chain_der.push(cert.as_ref().to_vec());
+    }
+
+    // Keep adding issuers until we reach a root or can't find the issuer
+    while let Some(der) = chain_der.last() {
+        let last_cert_der = der;
+
+        // Parse the last certificate in the chain
+        let (_, last_cert) = match X509Certificate::from_der(last_cert_der) {
+            Ok(parsed) => parsed,
+            Err(_) => break,
+        };
+
+        // Check if it's self-signed (root certificate)
+        if last_cert.subject() == last_cert.issuer() {
+            // This is a root certificate, we're done
+            break;
+        }
+
+        // Try to find the issuer in the trust store
+        let issuer_name = last_cert.issuer();
+        let mut found_issuer = false;
+
+        for ca_der in ca_certs_der.iter() {
+            let (_, ca_cert) = match X509Certificate::from_der(ca_der) {
+                Ok(parsed) => parsed,
+                Err(_) => continue,
+            };
+
+            // Check if this CA's subject matches the certificate's issuer
+            if ca_cert.subject() == issuer_name {
+                // Check if we already have this certificate in the chain
+                if !chain_der.iter().any(|existing| existing == ca_der) {
+                    chain_der.push(ca_der.clone());
+                    found_issuer = true;
+                    break;
+                }
+            }
+        }
+
+        if !found_issuer {
+            // Can't find issuer, stop here
+            break;
+        }
+    }
+
+    chain_der
+}
+
+/// Statistics from certificate loading operations
+#[derive(Debug, Clone, Default)]
+pub struct CertStats {
+    pub total_certs: usize,
+    pub ca_certs: usize,
+}
+
+/// Certificate loader that handles PEM/DER parsing and validation
+///
+/// This structure encapsulates the common pattern of loading certificates
+/// from various sources (files, directories, bytes) and adding them to
+/// a RootCertStore while tracking statistics.
+///
+/// Duplicate certificates are detected and only counted once.
+pub struct CertLoader<'a> {
+    store: &'a mut RootCertStore,
+    ca_certs_der: &'a mut Vec<Vec<u8>>,
+    seen_certs: HashSet<Vec<u8>>,
+}
+
+impl<'a> CertLoader<'a> {
+    /// Create a new CertLoader with references to the store and DER cache
+    pub fn new(store: &'a mut RootCertStore, ca_certs_der: &'a mut Vec<Vec<u8>>) -> Self {
+        // Initialize seen_certs with existing certificates
+        let seen_certs = ca_certs_der.iter().cloned().collect();
+        Self {
+            store,
+            ca_certs_der,
+            seen_certs,
+        }
+    }
+
+    /// Load certificates from a file (supports both PEM and DER formats)
+    ///
+    /// Returns statistics about loaded certificates
+    pub fn load_from_file(&mut self, path: &str) -> Result<CertStats, std::io::Error> {
+        let contents = std::fs::read(path)?;
+        self.load_from_bytes(&contents)
+    }
+
+    /// Load certificates from a directory
+    ///
+    /// Reads all files in the directory and attempts to parse them as certificates.
+    /// Invalid files are silently skipped (matches OpenSSL capath behavior).
+    pub fn load_from_dir(&mut self, dir_path: &str) -> Result<CertStats, std::io::Error> {
+        let entries = std::fs::read_dir(dir_path)?;
+        let mut stats = CertStats::default();
+
+        for entry in entries {
+            let entry = entry?;
+            let path = entry.path();
+
+            // Skip directories and process all files
+            // OpenSSL capath uses hash-based naming like "4e1295a3.0"
+            if path.is_file()
+                && let Ok(contents) = std::fs::read(&path)
+            {
+                // Ignore errors for individual files (some may not be certs)
+                if let Ok(file_stats) = self.load_from_bytes(&contents) {
+                    stats.total_certs += file_stats.total_certs;
+                    stats.ca_certs += file_stats.ca_certs;
+                }
+            }
+        }
+
+        Ok(stats)
+    }
+
+    /// Helper: Add a certificate to the store with duplicate checking
+    ///
+    /// Returns true if the certificate was added (not a duplicate), false if it was a duplicate.
+    fn add_cert_to_store(
+        &mut self,
+        cert_bytes: Vec<u8>,
+        cert_der: CertificateDer<'static>,
+        treat_all_as_ca: bool,
+        stats: &mut CertStats,
+    ) -> bool {
+        // Check for duplicates using HashSet
+        if !self.seen_certs.insert(cert_bytes.clone()) {
+            return false; // Duplicate certificate - skip
+        }
+
+        // Determine if this is a CA certificate
+        let is_ca = if treat_all_as_ca {
+            true
+        } else {
+            is_ca_certificate(&cert_bytes)
+        };
+
+        // Store full DER for get_ca_certs()
+        self.ca_certs_der.push(cert_bytes);
+
+        // Add to trust store (rustls may handle duplicates internally)
+        let _ = self.store.add(cert_der);
+
+        // Update statistics
+        stats.total_certs += 1;
+        if is_ca {
+            stats.ca_certs += 1;
+        }
+
+        true
+    }
+
+    /// Load certificates from byte slice (auto-detects PEM vs DER format)
+    ///
+    /// Tries to parse as PEM first, falls back to DER if that fails.
+    /// Duplicate certificates are detected and only counted once.
+    ///
+    /// If `treat_all_as_ca` is true, all certificates are counted as CA certificates
+    /// regardless of their Basic Constraints (this matches
+    /// load_verify_locations with cadata parameter).
+    ///
+    /// If `pem_only` is true, only PEM parsing is attempted (for string input)
+    pub fn load_from_bytes_ex(
+        &mut self,
+        data: &[u8],
+        treat_all_as_ca: bool,
+        pem_only: bool,
+    ) -> Result<CertStats, std::io::Error> {
+        let mut stats = CertStats::default();
+
+        // Try to parse as PEM first
+        let mut cursor = std::io::Cursor::new(data);
+        let certs_iter = rustls_pemfile::certs(&mut cursor);
+
+        let mut found_any = false;
+        let mut first_pem_error = None; // Store first PEM parsing error
+        for cert_result in certs_iter {
+            match cert_result {
+                Ok(cert) => {
+                    found_any = true;
+                    let cert_bytes = cert.to_vec();
+
+                    // Validate that this is actually a valid X.509 certificate
+                    // rustls_pemfile only does base64 decoding, not X.509 validation
+                    if let Err(e) = X509Certificate::from_der(&cert_bytes) {
+                        // Invalid X.509 certificate
+                        return Err(cert_error::pem::parse_failed_debug(e));
+                    }
+
+                    // Add certificate using helper method (handles duplicates)
+                    self.add_cert_to_store(cert_bytes, cert, treat_all_as_ca, &mut stats);
+                    // Helper returns false for duplicates (skip counting)
+                }
+                Err(e) if !found_any => {
+                    // PEM parsing failed on first certificate
+                    if pem_only {
+                        // For string input (PEM only), return "no start line" error
+                        return Err(cert_error::pem::no_start_line(
+                            "cadata does not contain a certificate",
+                        ));
+                    }
+                    // Store the error and break to try DER format below
+                    first_pem_error = Some(e);
+                    break;
+                }
+                Err(e) => {
+                    // PEM parsing failed after some certs were loaded
+                    return Err(cert_error::pem::parse_failed(e));
+                }
+            }
+        }
+
+        // If PEM parsing found nothing, try DER format (unless pem_only)
+        // DER can have multiple certificates concatenated, so parse them sequentially
+        if !found_any && stats.total_certs == 0 {
+            // If we had a PEM parsing error, return it instead of trying DER fallback
+            // This ensures that malformed PEM files (like badcert.pem) raise an error
+            if let Some(e) = first_pem_error {
+                return Err(cert_error::pem::parse_failed(e));
+            }
+
+            // For PEM-only mode (string input), don't fallback to DER
+            if pem_only {
+                return Err(cert_error::pem::no_start_line(
+                    "cadata does not contain a certificate",
+                ));
+            }
+            let mut remaining = data;
+            let mut loaded_count = 0;
+
+            while !remaining.is_empty() {
+                match X509Certificate::from_der(remaining) {
+                    Ok((rest, _parsed_cert)) => {
+                        // Extract the DER bytes for this certificate
+                        // Length = total remaining - bytes left after parsing
+                        let cert_len = remaining.len() - rest.len();
+                        let cert_bytes = &remaining[..cert_len];
+                        let cert_der = CertificateDer::from(cert_bytes.to_vec());
+
+                        // Add certificate using helper method (handles duplicates)
+                        self.add_cert_to_store(
+                            cert_bytes.to_vec(),
+                            cert_der,
+                            treat_all_as_ca,
+                            &mut stats,
+                        );
+
+                        loaded_count += 1;
+                        remaining = rest; // Move to next certificate
+                    }
+                    Err(e) => {
+                        if loaded_count == 0 {
+                            // Failed to parse first certificate - invalid data
+                            return Err(cert_error::der::not_enough_data(
+                                "cadata does not contain a certificate",
+                            ));
+                        } else {
+                            // Loaded some certificates but failed on subsequent data (garbage)
+                            return Err(cert_error::der::parse_failed(e));
+                        }
+                    }
+                }
+            }
+
+            // If we somehow got here with no certificates loaded
+            if loaded_count == 0 {
+                return Err(cert_error::der::not_enough_data(
+                    "cadata does not contain a certificate",
+                ));
+            }
+        }
+
+        Ok(stats)
+    }
+
+    /// Load certificates from byte slice (auto-detects PEM vs DER format)
+    ///
+    /// This is a convenience wrapper that calls load_from_bytes_ex with treat_all_as_ca=false
+    /// and pem_only=false.
+    pub fn load_from_bytes(&mut self, data: &[u8]) -> Result<CertStats, std::io::Error> {
+        self.load_from_bytes_ex(data, false, false)
+    }
+}
+
+// NoVerifier: disables certificate verification (for CERT_NONE mode)
+#[derive(Debug)]
+pub struct NoVerifier;
+
+impl ServerCertVerifier for NoVerifier {
+    fn verify_server_cert(
+        &self,
+        _end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp_response: &[u8],
+        _now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // Accept all certificates without verification
+        Ok(ServerCertVerified::assertion())
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        // Accept all signatures without verification
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        // Accept all signatures without verification
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        ALL_SIGNATURE_SCHEMES.to_vec()
+    }
+}
+
+// HostnameIgnoringVerifier: verifies certificate chain but ignores hostname
+// This is used when check_hostname=False but verify_mode != CERT_NONE
+//
+// Unlike the previous implementation that used an inner WebPkiServerVerifier,
+// this version uses webpki directly to verify only the certificate chain,
+// completely bypassing hostname verification.
+#[derive(Debug)]
+pub struct HostnameIgnoringVerifier {
+    inner: Arc<dyn ServerCertVerifier>,
+}
+
+impl HostnameIgnoringVerifier {
+    /// Create a new HostnameIgnoringVerifier with a pre-built verifier
+    /// This is useful when you need to configure the verifier with CRLs or other options
+    pub fn new_with_verifier(inner: Arc<dyn ServerCertVerifier>) -> Self {
+        Self { inner }
+    }
+}
+
+impl ServerCertVerifier for HostnameIgnoringVerifier {
+    fn verify_server_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>, // Intentionally ignored
+        ocsp_response: &[u8],
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // Extract a hostname from the certificate to pass to inner verifier
+        // The inner verifier will validate certificate chain, trust anchors, etc.
+        // but may fail on hostname mismatch - we'll catch and ignore that error
+        let dummy_hostname = extract_first_dns_name(end_entity)
+            .unwrap_or_else(|| ServerName::try_from("localhost").expect("localhost is valid"));
+
+        // Call inner verifier for full certificate validation
+        match self.inner.verify_server_cert(
+            end_entity,
+            intermediates,
+            &dummy_hostname,
+            ocsp_response,
+            now,
+        ) {
+            Ok(verified) => Ok(verified),
+            Err(e) => {
+                // Check if the error is a hostname mismatch
+                // If so, ignore it (that's the whole point of HostnameIgnoringVerifier)
+                match e {
+                    rustls::Error::InvalidCertificate(
+                        rustls::CertificateError::NotValidForName,
+                    )
+                    | rustls::Error::InvalidCertificate(
+                        rustls::CertificateError::NotValidForNameContext { .. },
+                    ) => {
+                        // Hostname mismatch - this is expected and acceptable
+                        // The certificate chain, trust anchor, and expiry are valid
+                        Ok(ServerCertVerified::assertion())
+                    }
+                    _ => {
+                        // Other errors (expired cert, untrusted CA, etc.) should propagate
+                        Err(e)
+                    }
+                }
+            }
+        }
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls12_signature(message, cert, dss)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls13_signature(message, cert, dss)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        self.inner.supported_verify_schemes()
+    }
+}
+
+// Helper function to extract the first DNS name from a certificate
+fn extract_first_dns_name(cert_der: &CertificateDer<'_>) -> Option<ServerName<'static>> {
+    let (_, cert) = X509Certificate::from_der(cert_der.as_ref()).ok()?;
+
+    // Try Subject Alternative Names first
+    if let Ok(Some(san_ext)) = cert.subject_alternative_name() {
+        for name in &san_ext.value.general_names {
+            if let x509_parser::extensions::GeneralName::DNSName(dns) = name {
+                // Remove wildcard prefix if present (e.g., "*.example.com" → "example.com")
+                // This allows us to use the domain for certificate chain verification
+                // when check_hostname=False
+                let dns_str = dns.to_string();
+                let normalized_dns = normalize_wildcard_hostname(&dns_str);
+
+                match ServerName::try_from(normalized_dns.to_string()) {
+                    Ok(server_name) => {
+                        return Some(server_name);
+                    }
+                    Err(_e) => {
+                        // Continue to next
+                    }
+                }
+            }
+        }
+    }
+
+    // Fallback to Common Name
+    for rdn in cert.subject().iter() {
+        for attr in rdn.iter() {
+            if attr.attr_type() == &x509_parser::oid_registry::OID_X509_COMMON_NAME
+                && let Ok(cn) = attr.attr_value().as_str()
+            {
+                // Remove wildcard prefix if present
+                let normalized_cn = normalize_wildcard_hostname(cn);
+
+                match ServerName::try_from(normalized_cn.to_string()) {
+                    Ok(server_name) => {
+                        return Some(server_name);
+                    }
+                    Err(_e) => {}
+                }
+            }
+        }
+    }
+
+    None
+}
+
+// Custom client certificate verifier for TLS 1.3 deferred validation
+// This verifier always succeeds during handshake but stores verification errors
+// for later retrieval during I/O operations
+#[derive(Debug)]
+pub struct DeferredClientCertVerifier {
+    // The actual verifier that performs validation
+    inner: Arc<dyn ClientCertVerifier>,
+    // Shared storage for deferred error message
+    deferred_error: Arc<ParkingRwLock<Option<String>>>,
+}
+
+impl DeferredClientCertVerifier {
+    pub fn new(
+        inner: Arc<dyn ClientCertVerifier>,
+        deferred_error: Arc<ParkingRwLock<Option<String>>>,
+    ) -> Self {
+        Self {
+            inner,
+            deferred_error,
+        }
+    }
+}
+
+impl ClientCertVerifier for DeferredClientCertVerifier {
+    fn offer_client_auth(&self) -> bool {
+        self.inner.offer_client_auth()
+    }
+
+    fn client_auth_mandatory(&self) -> bool {
+        // Delegate to inner verifier to respect CERT_REQUIRED mode
+        // This ensures client certificates are mandatory when verify_mode=CERT_REQUIRED
+        self.inner.client_auth_mandatory()
+    }
+
+    fn root_hint_subjects(&self) -> &[rustls::DistinguishedName] {
+        self.inner.root_hint_subjects()
+    }
+
+    fn verify_client_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        now: UnixTime,
+    ) -> Result<ClientCertVerified, rustls::Error> {
+        // Perform the actual verification
+        let result = self
+            .inner
+            .verify_client_cert(end_entity, intermediates, now);
+
+        // If verification failed, store the error for the server's Python code
+        // AND return the error so rustls sends the appropriate TLS alert
+        if let Err(ref e) = result {
+            let error_msg = format!("certificate verify failed: {e}");
+            *self.deferred_error.write() = Some(error_msg);
+            // Return the error to rustls so it sends the alert to the client
+            return result;
+        }
+
+        result
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls12_signature(message, cert, dss)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls13_signature(message, cert, dss)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        self.inner.supported_verify_schemes()
+    }
+}
+
+// Public Utility Functions
+
+/// Load certificate chain and private key from files
+///
+/// This function loads a certificate chain from `cert_path` and a private key
+/// from `key_path`. If `password` is provided, it will be used to decrypt
+/// an encrypted private key.
+///
+/// Returns (certificate_chain, private_key) on success.
+///
+/// # Arguments
+/// * `cert_path` - Path to certificate file (PEM or DER format)
+/// * `key_path` - Path to private key file (PEM or DER format, optionally encrypted)
+/// * `password` - Optional password for encrypted private key
+///
+/// # Errors
+/// Returns error if:
+/// - Files cannot be read
+/// - Certificate or key cannot be parsed
+/// - Password is incorrect for encrypted key
+pub(super) fn load_cert_chain_from_file(
+    cert_path: &str,
+    key_path: &str,
+    password: Option<&str>,
+) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>), Box<dyn core::error::Error>> {
+    // Load certificate file - preserve io::Error for errno
+    let cert_contents = std::fs::read(cert_path)?;
+
+    // Parse certificates (PEM format)
+    let mut cert_cursor = std::io::Cursor::new(&cert_contents);
+    let certs: Vec<CertificateDer<'static>> = rustls_pemfile::certs(&mut cert_cursor)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(cert_error::pem::parse_failed)?;
+
+    if certs.is_empty() {
+        return Err(Box::new(cert_error::pem::invalid_cert()));
+    }
+
+    // Load private key file - preserve io::Error for errno
+    let key_contents = std::fs::read(key_path)?;
+
+    // Parse private key (supports PKCS8, RSA, EC formats)
+    let private_key = if let Some(pwd) = password {
+        // Try to parse as encrypted PKCS#8
+        use der::SecretDocument;
+        use pkcs8::EncryptedPrivateKeyInfo;
+        use rustls::pki_types::{PrivateKeyDer, PrivatePkcs8KeyDer};
+
+        let pem_str = String::from_utf8_lossy(&key_contents);
+
+        // Extract just the ENCRYPTED PRIVATE KEY block if present
+        // (file may contain multiple PEM blocks like key + certificate)
+        let encrypted_key_pem = if let Some(start) =
+            pem_str.find("-----BEGIN ENCRYPTED PRIVATE KEY-----")
+        {
+            if let Some(end_marker) = pem_str[start..].find("-----END ENCRYPTED PRIVATE KEY-----") {
+                let end = start + end_marker + "-----END ENCRYPTED PRIVATE KEY-----".len();
+                Some(&pem_str[start..end])
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        // Try to decode and decrypt PEM-encoded encrypted private key using pkcs8's PEM support
+        let decrypted_key_result = if let Some(key_pem) = encrypted_key_pem {
+            match SecretDocument::from_pem(key_pem) {
+                Ok((label, doc)) => {
+                    if label == "ENCRYPTED PRIVATE KEY" {
+                        // Parse encrypted key info from DER
+                        match EncryptedPrivateKeyInfo::try_from(doc.as_bytes()) {
+                            Ok(encrypted_key) => {
+                                // Decrypt with password
+                                match encrypted_key.decrypt(pwd.as_bytes()) {
+                                    Ok(decrypted) => {
+                                        // Convert decrypted SecretDocument to PrivateKeyDer
+                                        let key_vec: Vec<u8> = decrypted.as_bytes().to_vec();
+                                        let pkcs8_key: PrivatePkcs8KeyDer<'static> = key_vec.into();
+                                        Some(PrivateKeyDer::Pkcs8(pkcs8_key))
+                                    }
+                                    Err(e) => {
+                                        return Err(Box::new(cert_error::key::decrypt_failed(e)));
+                                    }
+                                }
+                            }
+                            Err(e) => {
+                                return Err(Box::new(cert_error::key::parse_encrypted_failed(e)));
+                            }
+                        }
+                    } else {
+                        None
+                    }
+                }
+                Err(_) => None,
+            }
+        } else {
+            None
+        };
+
+        match decrypted_key_result {
+            Some(key) => key,
+            None => {
+                // Not encrypted PKCS#8, try as unencrypted key
+                // (password might have been provided for an unencrypted key)
+                let mut key_cursor = std::io::Cursor::new(&key_contents);
+                match rustls_pemfile::private_key(&mut key_cursor) {
+                    Ok(Some(key)) => key,
+                    Ok(None) => {
+                        return Err(Box::new(cert_error::key::not_found("key file")));
+                    }
+                    Err(e) => {
+                        return Err(Box::new(cert_error::key::parse_failed(e)));
+                    }
+                }
+            }
+        }
+    } else {
+        // No password provided - try to parse unencrypted key
+        let mut key_cursor = std::io::Cursor::new(&key_contents);
+        match rustls_pemfile::private_key(&mut key_cursor) {
+            Ok(Some(key)) => key,
+            Ok(None) => {
+                return Err(Box::new(cert_error::key::not_found("key file")));
+            }
+            Err(e) => {
+                return Err(Box::new(cert_error::key::parse_failed(e)));
+            }
+        }
+    };
+
+    Ok((certs, private_key))
+}
+
+/// Validate that a certificate and private key match
+///
+/// This function checks that the public key in the certificate matches
+/// the provided private key. This is a basic sanity check to prevent
+/// configuration errors.
+///
+/// # Arguments
+/// * `certs` - Certificate chain (first certificate is the leaf)
+/// * `private_key` - Private key to validate against
+///
+/// # Errors
+/// Returns error if:
+/// - Certificate chain is empty
+/// - Public key extraction fails
+/// - Keys don't match
+///
+/// Note: This is a simplified validation. Full validation would require
+/// signing and verifying a test message, which is complex with rustls.
+pub fn validate_cert_key_match(
+    certs: &[CertificateDer<'_>],
+    private_key: &PrivateKeyDer<'_>,
+) -> Result<(), String> {
+    if certs.is_empty() {
+        return Err("Certificate chain is empty".to_string());
+    }
+
+    // For rustls, the actual validation happens when creating CertifiedKey
+    // We can attempt to create a signing key to verify the key is valid
+    use rustls::crypto::aws_lc_rs::sign::any_supported_type;
+
+    match any_supported_type(private_key) {
+        Ok(_signing_key) => {
+            // If we can create a signing key, the private key is valid
+            // Rustls will validate the cert-key match when building config
+            Ok(())
+        }
+        Err(_) => Err("PEM lib".to_string()),
+    }
+}
+
+/// StrictCertVerifier: wraps a ServerCertVerifier and adds RFC 5280 strict validation
+///
+/// When VERIFY_X509_STRICT flag is set, performs additional validation:
+/// - Checks for Authority Key Identifier (AKI) extension (required by RFC 5280 Section 4.2.1.1)
+/// - Validates other RFC 5280 compliance requirements
+///
+/// This matches X509_V_FLAG_X509_STRICT behavior in OpenSSL.
+#[derive(Debug)]
+pub struct StrictCertVerifier {
+    inner: Arc<dyn ServerCertVerifier>,
+    verify_flags: i32,
+}
+
+impl StrictCertVerifier {
+    /// Create a new StrictCertVerifier
+    ///
+    /// # Arguments
+    /// * `inner` - The underlying verifier to wrap
+    /// * `verify_flags` - SSL verification flags (e.g., VERIFY_X509_STRICT)
+    pub fn new(inner: Arc<dyn ServerCertVerifier>, verify_flags: i32) -> Self {
+        Self {
+            inner,
+            verify_flags,
+        }
+    }
+
+    /// Check if a certificate has the Authority Key Identifier extension
+    ///
+    /// RFC 5280 Section 4.2.1.1 states that conforming CAs MUST include this
+    /// extension in all certificates except self-signed certificates.
+    fn check_aki_present(cert_der: &[u8]) -> Result<(), String> {
+        let (_, cert) = X509Certificate::from_der(cert_der)
+            .map_err(|e| format!("Failed to parse certificate: {e}"))?;
+
+        // Check for Authority Key Identifier extension (OID 2.5.29.35)
+        let has_aki = cert
+            .tbs_certificate
+            .extensions()
+            .iter()
+            .any(|ext| ext.oid == oid_registry::OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER);
+
+        if !has_aki {
+            return Err(
+                "certificate verification failed: certificate missing required Authority Key Identifier extension"
+                    .to_string(),
+            );
+        }
+
+        Ok(())
+    }
+}
+
+impl ServerCertVerifier for StrictCertVerifier {
+    fn verify_server_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        server_name: &ServerName<'_>,
+        ocsp_response: &[u8],
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // First, perform the standard verification
+        let result = self.inner.verify_server_cert(
+            end_entity,
+            intermediates,
+            server_name,
+            ocsp_response,
+            now,
+        )?;
+
+        // If VERIFY_X509_STRICT flag is set, perform additional validation
+        if self.verify_flags & VERIFY_X509_STRICT != 0 {
+            // Check end entity certificate for AKI
+            // RFC 5280 Section 4.2.1.1: self-signed certificates are exempt from AKI requirement
+            if !is_self_signed(end_entity) {
+                Self::check_aki_present(end_entity.as_ref())
+                    .map_err(cert_error::to_rustls_invalid_cert)?;
+            }
+
+            // Check intermediate certificates for AKI
+            for intermediate in intermediates {
+                Self::check_aki_present(intermediate.as_ref())
+                    .map_err(cert_error::to_rustls_invalid_cert)?;
+            }
+        }
+
+        Ok(result)
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls12_signature(message, cert, dss)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls13_signature(message, cert, dss)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        self.inner.supported_verify_schemes()
+    }
+}
+
+/// EmptyRootStoreVerifier: used when verify_mode != CERT_NONE but no CA certs are loaded
+///
+/// This verifier always fails certificate verification with UnknownIssuer error,
+/// when no root certificates are available.
+/// This allows the SSL context to be created successfully, but handshake will fail
+/// with a proper SSLCertVerificationError (verify_code=20, UNABLE_TO_GET_ISSUER_CERT_LOCALLY).
+#[derive(Debug)]
+pub struct EmptyRootStoreVerifier;
+
+impl ServerCertVerifier for EmptyRootStoreVerifier {
+    fn verify_server_cert(
+        &self,
+        _end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp_response: &[u8],
+        _now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // Always fail with UnknownIssuer -  when no CA certs loaded
+        // This will be mapped to X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY (20)
+        Err(rustls::Error::InvalidCertificate(
+            rustls::CertificateError::UnknownIssuer,
+        ))
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        // Accept signatures during handshake - the cert verification will fail anyway
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        // Accept signatures during handshake - the cert verification will fail anyway
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        ALL_SIGNATURE_SCHEMES.to_vec()
+    }
+}
+
+/// CRLCheckVerifier: Wraps a verifier to enforce CRL checking when flags are set
+///
+/// This verifier ensures that when CRL checking flags are set (VERIFY_CRL_CHECK_LEAF = 4)
+/// but no CRLs have been loaded, the verification fails with UnknownRevocationStatus.
+/// This matches X509_V_FLAG_CRL_CHECK without loaded CRLs
+/// causes "unable to get CRL" error.
+#[derive(Debug)]
+pub struct CRLCheckVerifier {
+    inner: Arc<dyn ServerCertVerifier>,
+    has_crls: bool,
+    crl_check_enabled: bool,
+}
+
+impl CRLCheckVerifier {
+    pub fn new(
+        inner: Arc<dyn ServerCertVerifier>,
+        has_crls: bool,
+        crl_check_enabled: bool,
+    ) -> Self {
+        Self {
+            inner,
+            has_crls,
+            crl_check_enabled,
+        }
+    }
+}
+
+impl ServerCertVerifier for CRLCheckVerifier {
+    fn verify_server_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        server_name: &ServerName<'_>,
+        ocsp_response: &[u8],
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // If CRL checking is enabled but no CRLs are loaded, fail with UnknownRevocationStatus
+        // X509_V_ERR_UNABLE_TO_GET_CRL (3)
+        if self.crl_check_enabled && !self.has_crls {
+            return Err(rustls::Error::InvalidCertificate(
+                rustls::CertificateError::UnknownRevocationStatus,
+            ));
+        }
+
+        // Otherwise, delegate to inner verifier
+        self.inner
+            .verify_server_cert(end_entity, intermediates, server_name, ocsp_response, now)
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls12_signature(message, cert, dss)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls13_signature(message, cert, dss)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        self.inner.supported_verify_schemes()
+    }
+}
+
+/// Partial Chain Verifier - Handles VERIFY_X509_PARTIAL_CHAIN flag
+///
+/// OpenSSL's X509_V_FLAG_PARTIAL_CHAIN allows verification to succeed if any certificate
+/// in the presented chain is found in the trust store, not just the root CA. This is useful
+/// for trusting intermediate certificates or self-signed certificates directly.
+///
+/// rustls's WebPkiServerVerifier doesn't support this behavior by default, so we wrap it
+/// to add partial chain support when the flag is set.
+///
+/// Behavior:
+/// 1. Try standard verification first (full chain to trusted root)
+/// 2. If that fails and VERIFY_X509_PARTIAL_CHAIN is set:
+///    - Check if the end-entity certificate is in the trust store
+///    - If yes, accept the certificate as trusted
+///
+/// This matches accepting self-signed certificates that
+/// are explicitly loaded via load_verify_locations().
+#[derive(Debug)]
+pub struct PartialChainVerifier {
+    inner: Arc<dyn ServerCertVerifier>,
+    ca_certs_der: Vec<Vec<u8>>,
+    verify_flags: i32,
+}
+
+impl PartialChainVerifier {
+    pub fn new(
+        inner: Arc<dyn ServerCertVerifier>,
+        ca_certs_der: Vec<Vec<u8>>,
+        verify_flags: i32,
+    ) -> Self {
+        Self {
+            inner,
+            ca_certs_der,
+            verify_flags,
+        }
+    }
+}
+
+impl ServerCertVerifier for PartialChainVerifier {
+    fn verify_server_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        server_name: &ServerName<'_>,
+        ocsp_response: &[u8],
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        // Try standard verification first
+        match self.inner.verify_server_cert(
+            end_entity,
+            intermediates,
+            server_name,
+            ocsp_response,
+            now,
+        ) {
+            Ok(result) => Ok(result),
+            Err(e) => {
+                // If verification failed, check if the end-entity certificate is in the trust store
+                // OpenSSL behavior:
+                // 1. Self-signed certs in trust store: ALWAYS trusted (flag not required)
+                // 2. Non-self-signed end-entity certs in trust store: require VERIFY_X509_PARTIAL_CHAIN
+                // 3. Intermediate certs in trust store: require VERIFY_X509_PARTIAL_CHAIN
+                let end_entity_der = end_entity.as_ref();
+                if self
+                    .ca_certs_der
+                    .iter()
+                    .any(|cert_der| cert_der.as_slice() == end_entity_der)
+                {
+                    // End-entity certificate is in the trust store
+                    // Check if this is a self-signed certificate
+                    let is_self_signed_cert = is_self_signed(end_entity);
+
+                    // Self-signed: always trust (OpenSSL behavior)
+                    // Non-self-signed: require VERIFY_X509_PARTIAL_CHAIN flag
+                    if is_self_signed_cert || (self.verify_flags & VERIFY_X509_PARTIAL_CHAIN != 0) {
+                        // Certificate is trusted, but still perform hostname verification
+                        verify_hostname(end_entity, server_name)?;
+                        return Ok(ServerCertVerified::assertion());
+                    }
+                }
+                // No match found or non-self-signed without flag - return original error
+                Err(e)
+            }
+        }
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls12_signature(message, cert, dss)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.inner.verify_tls13_signature(message, cert, dss)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<SignatureScheme> {
+        self.inner.supported_verify_schemes()
+    }
+}
+
+// Hostname Verification:
+
+/// Check if a certificate is self-signed by comparing issuer and subject.
+/// Returns true if the certificate is self-signed (issuer == subject).
+fn is_self_signed(cert_der: &CertificateDer<'_>) -> bool {
+    use x509_parser::prelude::*;
+
+    // Parse the certificate
+    let Ok((_, cert)) = X509Certificate::from_der(cert_der.as_ref()) else {
+        // If we can't parse it, assume it's not self-signed (conservative approach)
+        return false;
+    };
+
+    // Compare issuer and subject
+    // A certificate is self-signed if issuer == subject
+    cert.issuer() == cert.subject()
+}
+
+/// Verify that a certificate is valid for the given hostname/IP address.
+/// This function checks Subject Alternative Names (SAN) and Common Name (CN).
+fn verify_hostname(
+    cert_der: &CertificateDer<'_>,
+    server_name: &ServerName<'_>,
+) -> Result<(), rustls::Error> {
+    use x509_parser::extensions::GeneralName;
+    use x509_parser::prelude::*;
+
+    // Parse the certificate
+    let (_, cert) = X509Certificate::from_der(cert_der.as_ref()).map_err(|e| {
+        cert_error::to_rustls_invalid_cert(format!(
+            "Failed to parse certificate for hostname verification: {e}"
+        ))
+    })?;
+
+    match server_name {
+        ServerName::DnsName(dns) => {
+            let expected_name = dns.as_ref();
+
+            // 1. Check Subject Alternative Names (SAN) - preferred method
+            if let Ok(Some(san_ext)) = cert.subject_alternative_name() {
+                for name in &san_ext.value.general_names {
+                    if let GeneralName::DNSName(dns_name) = name
+                        && hostname_matches(expected_name, dns_name)
+                    {
+                        return Ok(());
+                    }
+                }
+            }
+
+            // 2. Fallback to Common Name (CN) - deprecated but still checked for compatibility
+            for rdn in cert.subject().iter() {
+                for attr in rdn.iter() {
+                    if attr.attr_type() == &x509_parser::oid_registry::OID_X509_COMMON_NAME
+                        && let Ok(cn) = attr.attr_value().as_str()
+                        && hostname_matches(expected_name, cn)
+                    {
+                        return Ok(());
+                    }
+                }
+            }
+
+            // No match found - return error
+            Err(cert_error::to_rustls_invalid_cert(format!(
+                "Hostname mismatch: certificate is not valid for '{expected_name}'",
+            )))
+        }
+        ServerName::IpAddress(ip) => verify_ip_address(&cert, ip),
+        _ => {
+            // Unknown server name type
+            Err(cert_error::to_rustls_cert_error(
+                std::io::ErrorKind::InvalidInput,
+                "Unsupported server name type for hostname verification",
+            ))
+        }
+    }
+}
+
+/// Match a hostname against a pattern, supporting wildcard certificates (*.example.com).
+/// Implements RFC 6125 wildcard matching rules:
+/// - Wildcard must be in the leftmost label
+/// - Wildcard must be the only character in that label
+/// - Wildcard must match at least one character
+fn hostname_matches(expected: &str, pattern: &str) -> bool {
+    // Wildcard matching for *.example.com
+    if let Some(pattern_base) = pattern.strip_prefix("*.") {
+        // Find the first dot in expected hostname
+        if let Some(dot_pos) = expected.find('.') {
+            let expected_base = &expected[dot_pos + 1..];
+
+            // The base domains must match (case insensitive)
+            // and the leftmost label must not be empty
+            return dot_pos > 0 && expected_base.eq_ignore_ascii_case(pattern_base);
+        }
+
+        // No dot in expected, can't match wildcard
+        return false;
+    }
+
+    // Exact match (case insensitive per RFC 4343)
+    expected.eq_ignore_ascii_case(pattern)
+}
+
+/// Verify that a certificate is valid for the given IP address.
+/// Checks Subject Alternative Names for IP Address entries.
+fn verify_ip_address(
+    cert: &X509Certificate<'_>,
+    expected_ip: &rustls::pki_types::IpAddr,
+) -> Result<(), rustls::Error> {
+    use core::net::IpAddr;
+    use x509_parser::extensions::GeneralName;
+
+    // Convert rustls IpAddr to std::net::IpAddr for comparison
+    let expected_std_ip: IpAddr = match expected_ip {
+        rustls::pki_types::IpAddr::V4(octets) => IpAddr::V4(core::net::Ipv4Addr::from(*octets)),
+        rustls::pki_types::IpAddr::V6(octets) => IpAddr::V6(core::net::Ipv6Addr::from(*octets)),
+    };
+
+    // Check Subject Alternative Names for IP addresses
+    if let Ok(Some(san_ext)) = cert.subject_alternative_name() {
+        for name in &san_ext.value.general_names {
+            if let GeneralName::IPAddress(cert_ip_bytes) = name {
+                // Parse the IP address from the certificate
+                let cert_ip = match cert_ip_bytes.len() {
+                    4 => {
+                        // IPv4
+                        if let Ok(octets) = <[u8; 4]>::try_from(*cert_ip_bytes) {
+                            IpAddr::V4(core::net::Ipv4Addr::from(octets))
+                        } else {
+                            continue;
+                        }
+                    }
+                    16 => {
+                        // IPv6
+                        if let Ok(octets) = <[u8; 16]>::try_from(*cert_ip_bytes) {
+                            IpAddr::V6(core::net::Ipv6Addr::from(octets))
+                        } else {
+                            continue;
+                        }
+                    }
+                    _ => continue, // Invalid IP address length
+                };
+
+                if cert_ip == expected_std_ip {
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    // No matching IP address found
+    Err(cert_error::to_rustls_invalid_cert(format!(
+        "IP address mismatch: certificate is not valid for '{expected_std_ip}'",
+    )))
+}
diff --git a/crates/stdlib/src/ssl/compat.rs b/crates/stdlib/src/ssl/compat.rs
new file mode 100644
index 0000000000..3c72ccf4e2
--- /dev/null
+++ b/crates/stdlib/src/ssl/compat.rs
@@ -0,0 +1,2071 @@
+// spell-checker: ignore webpki ssleof sslerror akid certsign sslerr aesgcm
+
+// OpenSSL compatibility layer for rustls
+//
+// This module provides OpenSSL-like abstractions over rustls APIs,
+// making the code more readable and maintainable. Each function is named
+// after its OpenSSL equivalent (e.g., ssl_do_handshake corresponds to SSL_do_handshake).
+
+// SSL error code data tables (shared with OpenSSL backend for compatibility)
+// These map OpenSSL error codes to human-readable strings
+#[path = "../openssl/ssl_data_31.rs"]
+mod ssl_data;
+
+use crate::socket::{SelectKind, timeout_error_msg};
+use crate::vm::VirtualMachine;
+use alloc::sync::Arc;
+use parking_lot::RwLock as ParkingRwLock;
+use rustls::RootCertStore;
+use rustls::client::ClientConfig;
+use rustls::client::ClientConnection;
+use rustls::crypto::SupportedKxGroup;
+use rustls::pki_types::{CertificateDer, CertificateRevocationListDer, PrivateKeyDer};
+use rustls::server::ResolvesServerCert;
+use rustls::server::ServerConfig;
+use rustls::server::ServerConnection;
+use rustls::sign::CertifiedKey;
+use rustpython_vm::builtins::{PyBaseException, PyBaseExceptionRef};
+use rustpython_vm::convert::IntoPyException;
+use rustpython_vm::function::ArgBytesLike;
+use rustpython_vm::{AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject};
+use std::io::Read;
+use std::sync::Once;
+
+// Import PySSLSocket from parent module
+use super::_ssl::PySSLSocket;
+
+// Import error types and helper functions from error module
+use super::error::{
+    PySSLCertVerificationError, PySSLError, create_ssl_eof_error, create_ssl_want_read_error,
+    create_ssl_want_write_error, create_ssl_zero_return_error,
+};
+
+// SSL Verification Flags
+/// VERIFY_X509_STRICT flag for RFC 5280 strict compliance
+/// When set, performs additional validation including AKI extension checks
+pub const VERIFY_X509_STRICT: i32 = 0x20;
+
+/// VERIFY_X509_PARTIAL_CHAIN flag for partial chain validation
+/// When set, accept certificates if any certificate in the chain is in the trust store
+/// (not just root CAs). This matches OpenSSL's X509_V_FLAG_PARTIAL_CHAIN behavior.
+pub const VERIFY_X509_PARTIAL_CHAIN: i32 = 0x80000;
+
+// CryptoProvider Initialization:
+
+/// Ensure the default CryptoProvider is installed (thread-safe, runs once)
+///
+/// This is necessary because rustls 0.23+ requires a process-level CryptoProvider
+/// to be installed before using default_provider(). We use Once to ensure this
+/// happens exactly once, even if called from multiple threads.
+static INIT_PROVIDER: Once = Once::new();
+
+fn ensure_default_provider() {
+    INIT_PROVIDER.call_once(|| {
+        let _ = rustls::crypto::CryptoProvider::install_default(
+            rustls::crypto::aws_lc_rs::default_provider(),
+        );
+    });
+}
+
+// OpenSSL Constants:
+
+// OpenSSL TLS record maximum plaintext size (ssl/ssl_local.h)
+// #define SSL3_RT_MAX_PLAIN_LENGTH 16384
+const SSL3_RT_MAX_PLAIN_LENGTH: usize = 16384;
+
+// OpenSSL error library codes (include/openssl/err.h)
+// #define ERR_LIB_SSL 20
+const ERR_LIB_SSL: i32 = 20;
+
+// OpenSSL SSL error reason codes (include/openssl/sslerr.h)
+// #define SSL_R_NO_SHARED_CIPHER 193
+const SSL_R_NO_SHARED_CIPHER: i32 = 193;
+
+// OpenSSL X509 verification flags (include/openssl/x509_vfy.h)
+// #define X509_V_FLAG_CRL_CHECK 4
+const X509_V_FLAG_CRL_CHECK: i32 = 4;
+
+// X509 Certificate Verification Error Codes (OpenSSL Compatible):
+//
+// These constants match OpenSSL's X509_V_ERR_* values for certificate
+// verification. They are used to map rustls certificate errors to OpenSSL
+// error codes for compatibility.
+
+pub use x509::{
+    X509_V_ERR_CERT_HAS_EXPIRED, X509_V_ERR_CERT_NOT_YET_VALID, X509_V_ERR_CERT_REVOKED,
+    X509_V_ERR_HOSTNAME_MISMATCH, X509_V_ERR_INVALID_PURPOSE, X509_V_ERR_IP_ADDRESS_MISMATCH,
+    X509_V_ERR_UNABLE_TO_GET_CRL, X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY,
+    X509_V_ERR_UNSPECIFIED,
+};
+
+#[allow(dead_code)]
+mod x509 {
+    pub const X509_V_OK: i32 = 0;
+    pub const X509_V_ERR_UNSPECIFIED: i32 = 1;
+    pub const X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: i32 = 2;
+    pub const X509_V_ERR_UNABLE_TO_GET_CRL: i32 = 3;
+    pub const X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE: i32 = 4;
+    pub const X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE: i32 = 5;
+    pub const X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY: i32 = 6;
+    pub const X509_V_ERR_CERT_SIGNATURE_FAILURE: i32 = 7;
+    pub const X509_V_ERR_CRL_SIGNATURE_FAILURE: i32 = 8;
+    pub const X509_V_ERR_CERT_NOT_YET_VALID: i32 = 9;
+    pub const X509_V_ERR_CERT_HAS_EXPIRED: i32 = 10;
+    pub const X509_V_ERR_CRL_NOT_YET_VALID: i32 = 11;
+    pub const X509_V_ERR_CRL_HAS_EXPIRED: i32 = 12;
+    pub const X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: i32 = 13;
+    pub const X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: i32 = 14;
+    pub const X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD: i32 = 15;
+    pub const X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD: i32 = 16;
+    pub const X509_V_ERR_OUT_OF_MEM: i32 = 17;
+    pub const X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: i32 = 18;
+    pub const X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN: i32 = 19;
+    pub const X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: i32 = 20;
+    pub const X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE: i32 = 21;
+    pub const X509_V_ERR_CERT_CHAIN_TOO_LONG: i32 = 22;
+    pub const X509_V_ERR_CERT_REVOKED: i32 = 23;
+    pub const X509_V_ERR_INVALID_CA: i32 = 24;
+    pub const X509_V_ERR_PATH_LENGTH_EXCEEDED: i32 = 25;
+    pub const X509_V_ERR_INVALID_PURPOSE: i32 = 26;
+    pub const X509_V_ERR_CERT_UNTRUSTED: i32 = 27;
+    pub const X509_V_ERR_CERT_REJECTED: i32 = 28;
+    pub const X509_V_ERR_SUBJECT_ISSUER_MISMATCH: i32 = 29;
+    pub const X509_V_ERR_AKID_SKID_MISMATCH: i32 = 30;
+    pub const X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH: i32 = 31;
+    pub const X509_V_ERR_KEYUSAGE_NO_CERTSIGN: i32 = 32;
+    pub const X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER: i32 = 33;
+    pub const X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION: i32 = 34;
+    pub const X509_V_ERR_KEYUSAGE_NO_CRL_SIGN: i32 = 35;
+    pub const X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION: i32 = 36;
+    pub const X509_V_ERR_INVALID_NON_CA: i32 = 37;
+    pub const X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED: i32 = 38;
+    pub const X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE: i32 = 39;
+    pub const X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED: i32 = 40;
+    pub const X509_V_ERR_INVALID_EXTENSION: i32 = 41;
+    pub const X509_V_ERR_INVALID_POLICY_EXTENSION: i32 = 42;
+    pub const X509_V_ERR_NO_EXPLICIT_POLICY: i32 = 43;
+    pub const X509_V_ERR_DIFFERENT_CRL_SCOPE: i32 = 44;
+    pub const X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE: i32 = 45;
+    pub const X509_V_ERR_UNNESTED_RESOURCE: i32 = 46;
+    pub const X509_V_ERR_PERMITTED_VIOLATION: i32 = 47;
+    pub const X509_V_ERR_EXCLUDED_VIOLATION: i32 = 48;
+    pub const X509_V_ERR_SUBTREE_MINMAX: i32 = 49;
+    pub const X509_V_ERR_APPLICATION_VERIFICATION: i32 = 50;
+    pub const X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE: i32 = 51;
+    pub const X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX: i32 = 52;
+    pub const X509_V_ERR_UNSUPPORTED_NAME_SYNTAX: i32 = 53;
+    pub const X509_V_ERR_CRL_PATH_VALIDATION_ERROR: i32 = 54;
+    pub const X509_V_ERR_HOSTNAME_MISMATCH: i32 = 62;
+    pub const X509_V_ERR_EMAIL_MISMATCH: i32 = 63;
+    pub const X509_V_ERR_IP_ADDRESS_MISMATCH: i32 = 64;
+}
+
+// Certificate Error Conversion Functions:
+
+/// Convert rustls CertificateError to X509 verification code and message
+///
+/// Maps rustls certificate errors to OpenSSL X509_V_ERR_* codes for compatibility.
+/// Returns (verify_code, verify_message) tuple.
+fn rustls_cert_error_to_verify_info(cert_err: &rustls::CertificateError) -> (i32, &'static str) {
+    use rustls::CertificateError;
+
+    match cert_err {
+        CertificateError::UnknownIssuer => (
+            X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY,
+            "unable to get local issuer certificate",
+        ),
+        CertificateError::Expired => (X509_V_ERR_CERT_HAS_EXPIRED, "certificate has expired"),
+        CertificateError::NotValidYet => (
+            X509_V_ERR_CERT_NOT_YET_VALID,
+            "certificate is not yet valid",
+        ),
+        CertificateError::Revoked => (X509_V_ERR_CERT_REVOKED, "certificate revoked"),
+        CertificateError::UnknownRevocationStatus => (
+            X509_V_ERR_UNABLE_TO_GET_CRL,
+            "unable to get certificate CRL",
+        ),
+        CertificateError::InvalidPurpose => (
+            X509_V_ERR_INVALID_PURPOSE,
+            "unsupported certificate purpose",
+        ),
+        CertificateError::Other(other_err) => {
+            // Check if this is a hostname mismatch error from our verify_hostname function
+            let err_msg = format!("{other_err:?}");
+            if err_msg.contains("Hostname mismatch") || err_msg.contains("not valid for") {
+                (
+                    X509_V_ERR_HOSTNAME_MISMATCH,
+                    "Hostname mismatch, certificate is not valid for",
+                )
+            } else if err_msg.contains("IP address mismatch") {
+                (
+                    X509_V_ERR_IP_ADDRESS_MISMATCH,
+                    "IP address mismatch, certificate is not valid for",
+                )
+            } else {
+                (X509_V_ERR_UNSPECIFIED, "certificate verification failed")
+            }
+        }
+        _ => (X509_V_ERR_UNSPECIFIED, "certificate verification failed"),
+    }
+}
+
+/// Create SSLCertVerificationError with proper attributes
+///
+/// Matches CPython's _ssl.c fill_and_set_sslerror() behavior.
+/// This function creates a Python SSLCertVerificationError exception with verify_code
+/// and verify_message attributes set appropriately for the given rustls certificate error.
+///
+/// # Note
+/// If attribute setting fails (extremely rare), returns the exception without attributes
+pub(super) fn create_ssl_cert_verification_error(
+    vm: &VirtualMachine,
+    cert_err: &rustls::CertificateError,
+) -> PyResult<PyBaseExceptionRef> {
+    let (verify_code, verify_message) = rustls_cert_error_to_verify_info(cert_err);
+
+    let msg =
+        format!("[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: {verify_message}",);
+
+    let exc = vm.new_os_subtype_error(
+        PySSLCertVerificationError::class(&vm.ctx).to_owned(),
+        None,
+        msg,
+    );
+
+    // Set verify_code and verify_message attributes
+    // Ignore errors as they're extremely rare (e.g., out of memory)
+    exc.as_object().set_attr(
+        "verify_code",
+        vm.ctx.new_int(verify_code).as_object().to_owned(),
+        vm,
+    )?;
+    exc.as_object().set_attr(
+        "verify_message",
+        vm.ctx.new_str(verify_message).as_object().to_owned(),
+        vm,
+    )?;
+
+    exc.as_object()
+        .set_attr("library", vm.ctx.new_str("SSL").as_object().to_owned(), vm)?;
+    exc.as_object().set_attr(
+        "reason",
+        vm.ctx
+            .new_str("CERTIFICATE_VERIFY_FAILED")
+            .as_object()
+            .to_owned(),
+        vm,
+    )?;
+
+    Ok(exc.upcast())
+}
+
+/// Unified TLS connection type (client or server)
+#[derive(Debug)]
+pub(super) enum TlsConnection {
+    Client(ClientConnection),
+    Server(ServerConnection),
+}
+
+impl TlsConnection {
+    /// Check if handshake is in progress
+    pub fn is_handshaking(&self) -> bool {
+        match self {
+            TlsConnection::Client(conn) => conn.is_handshaking(),
+            TlsConnection::Server(conn) => conn.is_handshaking(),
+        }
+    }
+
+    /// Check if connection wants to read data
+    pub fn wants_read(&self) -> bool {
+        match self {
+            TlsConnection::Client(conn) => conn.wants_read(),
+            TlsConnection::Server(conn) => conn.wants_read(),
+        }
+    }
+
+    /// Check if connection wants to write data
+    pub fn wants_write(&self) -> bool {
+        match self {
+            TlsConnection::Client(conn) => conn.wants_write(),
+            TlsConnection::Server(conn) => conn.wants_write(),
+        }
+    }
+
+    /// Read TLS data from socket
+    pub fn read_tls(&mut self, reader: &mut dyn std::io::Read) -> std::io::Result<usize> {
+        match self {
+            TlsConnection::Client(conn) => conn.read_tls(reader),
+            TlsConnection::Server(conn) => conn.read_tls(reader),
+        }
+    }
+
+    /// Write TLS data to socket
+    pub fn write_tls(&mut self, writer: &mut dyn std::io::Write) -> std::io::Result<usize> {
+        match self {
+            TlsConnection::Client(conn) => conn.write_tls(writer),
+            TlsConnection::Server(conn) => conn.write_tls(writer),
+        }
+    }
+
+    /// Process new TLS packets
+    pub fn process_new_packets(&mut self) -> Result<rustls::IoState, rustls::Error> {
+        match self {
+            TlsConnection::Client(conn) => conn.process_new_packets(),
+            TlsConnection::Server(conn) => conn.process_new_packets(),
+        }
+    }
+
+    /// Get reader for plaintext data (rustls native type)
+    pub fn reader(&mut self) -> rustls::Reader<'_> {
+        match self {
+            TlsConnection::Client(conn) => conn.reader(),
+            TlsConnection::Server(conn) => conn.reader(),
+        }
+    }
+
+    /// Get writer for plaintext data (rustls native type)
+    pub fn writer(&mut self) -> rustls::Writer<'_> {
+        match self {
+            TlsConnection::Client(conn) => conn.writer(),
+            TlsConnection::Server(conn) => conn.writer(),
+        }
+    }
+
+    /// Check if session was resumed
+    pub fn is_session_resumed(&self) -> bool {
+        use rustls::HandshakeKind;
+        match self {
+            TlsConnection::Client(conn) => {
+                matches!(conn.handshake_kind(), Some(HandshakeKind::Resumed))
+            }
+            TlsConnection::Server(conn) => {
+                matches!(conn.handshake_kind(), Some(HandshakeKind::Resumed))
+            }
+        }
+    }
+
+    /// Send close_notify alert
+    pub fn send_close_notify(&mut self) {
+        match self {
+            TlsConnection::Client(conn) => conn.send_close_notify(),
+            TlsConnection::Server(conn) => conn.send_close_notify(),
+        }
+    }
+
+    /// Get negotiated ALPN protocol
+    pub fn alpn_protocol(&self) -> Option<&[u8]> {
+        match self {
+            TlsConnection::Client(conn) => conn.alpn_protocol(),
+            TlsConnection::Server(conn) => conn.alpn_protocol(),
+        }
+    }
+
+    /// Get negotiated cipher suite
+    pub fn negotiated_cipher_suite(&self) -> Option<rustls::SupportedCipherSuite> {
+        match self {
+            TlsConnection::Client(conn) => conn.negotiated_cipher_suite(),
+            TlsConnection::Server(conn) => conn.negotiated_cipher_suite(),
+        }
+    }
+
+    /// Get peer certificates
+    pub fn peer_certificates(&self) -> Option<&[rustls::pki_types::CertificateDer<'static>]> {
+        match self {
+            TlsConnection::Client(conn) => conn.peer_certificates(),
+            TlsConnection::Server(conn) => conn.peer_certificates(),
+        }
+    }
+}
+
+/// Error types matching OpenSSL error codes
+#[derive(Debug)]
+pub(super) enum SslError {
+    /// SSL_ERROR_WANT_READ
+    WantRead,
+    /// SSL_ERROR_WANT_WRITE
+    WantWrite,
+    /// SSL_ERROR_SYSCALL
+    Syscall(String),
+    /// SSL_ERROR_SSL
+    Ssl(String),
+    /// SSL_ERROR_ZERO_RETURN (clean closure with close_notify)
+    ZeroReturn,
+    /// Unexpected EOF without close_notify (protocol violation)
+    Eof,
+    /// Non-TLS data received before handshake completed
+    PreauthData,
+    /// Certificate verification error
+    CertVerification(rustls::CertificateError),
+    /// I/O error
+    Io(std::io::Error),
+    /// Timeout error (socket.timeout)
+    Timeout(String),
+    /// SNI callback triggered - need to restart handshake
+    SniCallbackRestart,
+    /// Python exception (pass through directly)
+    Py(PyBaseExceptionRef),
+    /// TLS alert received with OpenSSL-compatible error code
+    AlertReceived { lib: i32, reason: i32 },
+    /// NO_SHARED_CIPHER error (OpenSSL SSL_R_NO_SHARED_CIPHER)
+    NoCipherSuites,
+}
+
+impl SslError {
+    /// Convert TLS alert code to OpenSSL error reason code
+    /// OpenSSL uses reason = 1000 + alert_code for TLS alerts
+    fn alert_to_openssl_reason(alert: rustls::AlertDescription) -> i32 {
+        // AlertDescription can be converted to u8 via as u8 cast
+        1000 + (u8::from(alert) as i32)
+    }
+
+    /// Convert rustls error to SslError
+    pub fn from_rustls(err: rustls::Error) -> Self {
+        match err {
+            rustls::Error::InvalidCertificate(cert_err) => SslError::CertVerification(cert_err),
+            rustls::Error::AlertReceived(alert_desc) => {
+                // Map TLS alerts to OpenSSL-compatible error codes
+                // lib = 20 (ERR_LIB_SSL), reason = 1000 + alert_code
+                match alert_desc {
+                    rustls::AlertDescription::CloseNotify => {
+                        // Special case: close_notify is handled as ZeroReturn
+                        SslError::ZeroReturn
+                    }
+                    _ => {
+                        // All other alerts: convert to OpenSSL error code
+                        // This includes InternalError (80 -> reason 1080)
+                        SslError::AlertReceived {
+                            lib: ERR_LIB_SSL,
+                            reason: Self::alert_to_openssl_reason(alert_desc),
+                        }
+                    }
+                }
+            }
+            // OpenSSL 3.0 changed transport EOF from SSL_ERROR_SYSCALL with
+            // zero return value to SSL_ERROR_SSL with SSL_R_UNEXPECTED_EOF_WHILE_READING.
+            // In rustls, these cases correspond to unexpected connection closure:
+            rustls::Error::InvalidMessage(_) => {
+                // UnexpectedMessage, CorruptMessage, etc. → SSLEOFError
+                // Matches CPython's "EOF occurred in violation of protocol"
+                SslError::Eof
+            }
+            rustls::Error::PeerIncompatible(peer_err) => {
+                // Check for specific incompatibility types
+                use rustls::PeerIncompatible;
+                match peer_err {
+                    PeerIncompatible::NoCipherSuitesInCommon => {
+                        // Maps to OpenSSL SSL_R_NO_SHARED_CIPHER (lib=20, reason=193)
+                        SslError::NoCipherSuites
+                    }
+                    _ => {
+                        // Other protocol incompatibilities → SSLEOFError
+                        SslError::Eof
+                    }
+                }
+            }
+            _ => SslError::Ssl(format!("{err}")),
+        }
+    }
+
+    /// Create SSLError with library and reason from string values
+    ///
+    /// This is the base helper for creating SSLError with _library and _reason
+    /// attributes when you already have the string values.
+    ///
+    /// # Arguments
+    /// * `vm` - Virtual machine reference
+    /// * `library` - Library name (e.g., "PEM", "SSL")
+    /// * `reason` - Error reason (e.g., "PEM lib", "NO_SHARED_CIPHER")
+    /// * `message` - Main error message
+    ///
+    /// # Returns
+    /// PyBaseExceptionRef with _library and _reason attributes set
+    ///
+    /// # Note
+    /// If attribute setting fails (extremely rare), returns the exception without attributes
+    pub(super) fn create_ssl_error_with_reason(
+        vm: &VirtualMachine,
+        library: Option<&str>,
+        reason: &str,
+        message: impl Into<String>,
+    ) -> PyBaseExceptionRef {
+        let msg = message.into();
+        // SSLError args should be (errno, message) format
+        // FIXME: Use 1 as generic SSL error code
+        let exc = vm.new_os_subtype_error(PySSLError::class(&vm.ctx).to_owned(), Some(1), msg);
+
+        // Set library and reason attributes
+        // Ignore errors as they're extremely rare (e.g., out of memory)
+        let library_obj = match library {
+            Some(lib) => vm.ctx.new_str(lib).as_object().to_owned(),
+            None => vm.ctx.none(),
+        };
+        let _ = exc.as_object().set_attr("library", library_obj, vm);
+        let _ =
+            exc.as_object()
+                .set_attr("reason", vm.ctx.new_str(reason).as_object().to_owned(), vm);
+
+        exc.upcast()
+    }
+
+    /// Create SSLError with library and reason from ssl_data codes
+    ///
+    /// This helper converts OpenSSL numeric error codes to Python SSLError exceptions
+    /// with proper _library and _reason attributes by looking up the error strings
+    /// in ssl_data tables, then delegates to create_ssl_error_with_reason.
+    ///
+    /// # Arguments
+    /// * `vm` - Virtual machine reference
+    /// * `lib` - OpenSSL library code (e.g., ERR_LIB_SSL = 20)
+    /// * `reason` - OpenSSL reason code (e.g., SSL_R_NO_SHARED_CIPHER = 193)
+    ///
+    /// # Returns
+    /// PyBaseExceptionRef with _library and _reason attributes set
+    fn create_ssl_error_from_codes(
+        vm: &VirtualMachine,
+        lib: i32,
+        reason: i32,
+    ) -> PyBaseExceptionRef {
+        // Look up error strings from ssl_data tables
+        let key = ssl_data::encode_error_key(lib, reason);
+        let reason_str = ssl_data::ERROR_CODES
+            .get(&key)
+            .copied()
+            .unwrap_or("unknown error");
+
+        let lib_str = ssl_data::LIBRARY_CODES
+            .get(&(lib as u32))
+            .copied()
+            .unwrap_or("UNKNOWN");
+
+        // Delegate to create_ssl_error_with_reason for actual exception creation
+        Self::create_ssl_error_with_reason(
+            vm,
+            Some(lib_str),
+            reason_str,
+            format!("[SSL] {reason_str}"),
+        )
+    }
+
+    /// Convert to Python exception
+    pub fn into_py_err(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        match self {
+            SslError::WantRead => create_ssl_want_read_error(vm).upcast(),
+            SslError::WantWrite => create_ssl_want_write_error(vm).upcast(),
+            SslError::Timeout(msg) => timeout_error_msg(vm, msg).upcast(),
+            SslError::Syscall(msg) => {
+                // Create SSLError with library=None for syscall errors during SSL operations
+                Self::create_ssl_error_with_reason(vm, None, &msg, msg.clone())
+            }
+            SslError::Ssl(msg) => vm
+                .new_os_subtype_error(
+                    PySSLError::class(&vm.ctx).to_owned(),
+                    None,
+                    format!("SSL error: {msg}"),
+                )
+                .upcast(),
+            SslError::ZeroReturn => create_ssl_zero_return_error(vm).upcast(),
+            SslError::Eof => create_ssl_eof_error(vm).upcast(),
+            SslError::PreauthData => {
+                // Non-TLS data received before handshake
+                Self::create_ssl_error_with_reason(
+                    vm,
+                    None,
+                    "before TLS handshake with data",
+                    "before TLS handshake with data",
+                )
+            }
+            SslError::CertVerification(cert_err) => {
+                // Use the proper cert verification error creator
+                create_ssl_cert_verification_error(vm, &cert_err).expect("unlikely to happen")
+            }
+            SslError::Io(err) => err.into_pyexception(vm),
+            SslError::SniCallbackRestart => {
+                // This should be handled at PySSLSocket level
+                unreachable!("SniCallbackRestart should not reach Python layer")
+            }
+            SslError::Py(exc) => exc,
+            SslError::AlertReceived { lib, reason } => {
+                Self::create_ssl_error_from_codes(vm, lib, reason)
+            }
+            SslError::NoCipherSuites => {
+                // OpenSSL error: lib=20 (ERR_LIB_SSL), reason=193 (SSL_R_NO_SHARED_CIPHER)
+                Self::create_ssl_error_from_codes(vm, ERR_LIB_SSL, SSL_R_NO_SHARED_CIPHER)
+            }
+        }
+    }
+}
+
+pub type SslResult<T> = Result<T, SslError>;
+/// Common protocol settings shared between client and server connections
+#[derive(Debug)]
+pub struct ProtocolSettings {
+    pub versions: &'static [&'static rustls::SupportedProtocolVersion],
+    pub kx_groups: Option<Vec<&'static dyn rustls::crypto::SupportedKxGroup>>,
+    pub cipher_suites: Option<Vec<rustls::SupportedCipherSuite>>,
+    pub alpn_protocols: Vec<Vec<u8>>,
+}
+
+/// Options for creating a server TLS configuration
+#[derive(Debug)]
+pub struct ServerConfigOptions {
+    /// Common protocol settings (versions, ALPN, KX groups, cipher suites)
+    pub protocol_settings: ProtocolSettings,
+    /// Server certificate chain
+    pub cert_chain: Vec<CertificateDer<'static>>,
+    /// Server private key
+    pub private_key: PrivateKeyDer<'static>,
+    /// Root certificates for client verification (if required)
+    pub root_store: Option<RootCertStore>,
+    /// Whether to request client certificate
+    pub request_client_cert: bool,
+    /// Whether to use deferred client certificate validation (TLS 1.3)
+    pub use_deferred_validation: bool,
+    /// Custom certificate resolver (for SNI support)
+    pub cert_resolver: Option<Arc<dyn ResolvesServerCert>>,
+    /// Deferred certificate error storage (for TLS 1.3)
+    pub deferred_cert_error: Option<Arc<ParkingRwLock<Option<String>>>>,
+    /// Session storage for server-side session resumption
+    pub session_storage: Option<Arc<rustls::server::ServerSessionMemoryCache>>,
+    /// Shared ticketer for TLS 1.2 session tickets (stateless resumption)
+    pub ticketer: Option<Arc<dyn rustls::server::ProducesTickets>>,
+}
+
+/// Options for creating a client TLS configuration
+#[derive(Debug)]
+pub struct ClientConfigOptions {
+    /// Common protocol settings (versions, ALPN, KX groups, cipher suites)
+    pub protocol_settings: ProtocolSettings,
+    /// Root certificates for server verification
+    pub root_store: Option<RootCertStore>,
+    /// DER-encoded CA certificates (for partial chain verification)
+    pub ca_certs_der: Vec<Vec<u8>>,
+    /// Client certificate chain (for mTLS)
+    pub cert_chain: Option<Vec<CertificateDer<'static>>>,
+    /// Client private key (for mTLS)
+    pub private_key: Option<PrivateKeyDer<'static>>,
+    /// Whether to verify server certificates (CERT_NONE disables verification)
+    pub verify_server_cert: bool,
+    /// Whether to check hostname against certificate (check_hostname)
+    pub check_hostname: bool,
+    /// SSL verification flags (e.g., VERIFY_X509_STRICT)
+    pub verify_flags: i32,
+    /// Session store for client-side session resumption
+    pub session_store: Option<Arc<dyn rustls::client::ClientSessionStore>>,
+    /// Certificate Revocation Lists for CRL checking
+    pub crls: Vec<CertificateRevocationListDer<'static>>,
+}
+
+/// Create custom CryptoProvider with specified cipher suites and key exchange groups
+///
+/// This helper function consolidates the duplicated CryptoProvider creation logic
+/// for both server and client configurations.
+fn create_custom_crypto_provider(
+    cipher_suites: Option<Vec<rustls::SupportedCipherSuite>>,
+    kx_groups: Option<Vec<&'static dyn rustls::crypto::SupportedKxGroup>>,
+) -> Arc<rustls::crypto::CryptoProvider> {
+    use rustls::crypto::aws_lc_rs::{ALL_CIPHER_SUITES, ALL_KX_GROUPS};
+    let default_provider = rustls::crypto::aws_lc_rs::default_provider();
+
+    Arc::new(rustls::crypto::CryptoProvider {
+        cipher_suites: cipher_suites.unwrap_or_else(|| ALL_CIPHER_SUITES.to_vec()),
+        kx_groups: kx_groups.unwrap_or_else(|| ALL_KX_GROUPS.to_vec()),
+        signature_verification_algorithms: default_provider.signature_verification_algorithms,
+        secure_random: default_provider.secure_random,
+        key_provider: default_provider.key_provider,
+    })
+}
+
+/// Create a server TLS configuration
+///
+/// This abstracts the complex rustls ServerConfig building logic,
+/// matching SSL_CTX initialization for server sockets.
+pub(super) fn create_server_config(options: ServerConfigOptions) -> Result<ServerConfig, String> {
+    use rustls::server::WebPkiClientVerifier;
+
+    // Ensure default CryptoProvider is installed
+    ensure_default_provider();
+
+    // Create custom crypto provider using helper function
+    let custom_provider = create_custom_crypto_provider(
+        options.protocol_settings.cipher_suites.clone(),
+        options.protocol_settings.kx_groups.clone(),
+    );
+
+    // Step 1: Build the appropriate client cert verifier based on settings
+    let client_cert_verifier: Option<Arc<dyn rustls::server::danger::ClientCertVerifier>> =
+        if let Some(root_store) = options.root_store {
+            if options.request_client_cert {
+                // Client certificate verification required
+                let base_verifier = WebPkiClientVerifier::builder(Arc::new(root_store))
+                    .build()
+                    .map_err(|e| format!("Failed to create client verifier: {e}"))?;
+
+                if options.use_deferred_validation {
+                    // TLS 1.3: Use deferred validation
+                    if let Some(deferred_error) = options.deferred_cert_error {
+                        use crate::ssl::cert::DeferredClientCertVerifier;
+                        let deferred_verifier =
+                            DeferredClientCertVerifier::new(base_verifier, deferred_error);
+                        Some(Arc::new(deferred_verifier))
+                    } else {
+                        // No deferred error storage provided, use immediate validation
+                        Some(base_verifier)
+                    }
+                } else {
+                    // TLS 1.2 or non-deferred: Use immediate validation
+                    Some(base_verifier)
+                }
+            } else {
+                // No client authentication
+                None
+            }
+        } else {
+            // No root store - no client authentication
+            None
+        };
+
+    // Step 2: Create ServerConfig builder once with the selected verifier
+    let builder = ServerConfig::builder_with_provider(custom_provider.clone())
+        .with_protocol_versions(options.protocol_settings.versions)
+        .map_err(|e| format!("Failed to create server config builder: {e}"))?;
+
+    let builder = if let Some(verifier) = client_cert_verifier {
+        builder.with_client_cert_verifier(verifier)
+    } else {
+        builder.with_no_client_auth()
+    };
+
+    // Add certificate
+    let mut config = if let Some(resolver) = options.cert_resolver {
+        // Use custom cert resolver (e.g., for SNI)
+        builder.with_cert_resolver(resolver)
+    } else {
+        // Use single certificate
+        builder
+            .with_single_cert(options.cert_chain, options.private_key)
+            .map_err(|e| format!("Failed to set server certificate: {e}"))?
+    };
+
+    // Set ALPN protocols with fallback
+    apply_alpn_with_fallback(
+        &mut config.alpn_protocols,
+        &options.protocol_settings.alpn_protocols,
+    );
+
+    // Set session storage for server-side session resumption (TLS 1.3)
+    if let Some(session_storage) = options.session_storage {
+        config.session_storage = session_storage;
+    }
+
+    // Set ticketer for TLS 1.2 session tickets (stateless resumption)
+    if let Some(ticketer) = options.ticketer {
+        config.ticketer = ticketer.clone();
+    }
+
+    Ok(config)
+}
+
+/// Build WebPki verifier with CRL support
+///
+/// This helper function consolidates the duplicated CRL setup logic for both
+/// check_hostname=True and check_hostname=False cases.
+fn build_webpki_verifier_with_crls(
+    root_store: Arc<RootCertStore>,
+    crls: Vec<CertificateRevocationListDer<'static>>,
+    verify_flags: i32,
+) -> Result<Arc<dyn rustls::client::danger::ServerCertVerifier>, String> {
+    use rustls::client::WebPkiServerVerifier;
+
+    let mut verifier_builder = WebPkiServerVerifier::builder(root_store);
+
+    // Check if CRL verification is requested
+    let crl_check_requested = verify_flags & X509_V_FLAG_CRL_CHECK != 0;
+    let has_crls = !crls.is_empty();
+
+    // Add CRLs if provided OR if CRL checking is explicitly requested
+    // (even with empty CRLs, rustls will fail verification if CRL checking is enabled)
+    if has_crls || crl_check_requested {
+        verifier_builder = verifier_builder.with_crls(crls);
+
+        // Check if we should only verify end-entity (leaf) certificates
+        if verify_flags & X509_V_FLAG_CRL_CHECK != 0 {
+            verifier_builder = verifier_builder.only_check_end_entity_revocation();
+        }
+    }
+
+    let webpki_verifier = verifier_builder
+        .build()
+        .map_err(|e| format!("Failed to build WebPkiServerVerifier: {e}"))?;
+
+    Ok(webpki_verifier as Arc<dyn rustls::client::danger::ServerCertVerifier>)
+}
+
+/// Apply verifier wrappers (CRLCheckVerifier and StrictCertVerifier)
+///
+/// This helper function consolidates the duplicated verifier wrapping logic.
+fn apply_verifier_wrappers(
+    verifier: Arc<dyn rustls::client::danger::ServerCertVerifier>,
+    verify_flags: i32,
+    has_crls: bool,
+    ca_certs_der: Vec<Vec<u8>>,
+) -> Arc<dyn rustls::client::danger::ServerCertVerifier> {
+    let crl_check_requested = verify_flags & X509_V_FLAG_CRL_CHECK != 0;
+
+    // Wrap with CRLCheckVerifier to enforce CRL checking when flags are set
+    let verifier = if crl_check_requested {
+        use crate::ssl::cert::CRLCheckVerifier;
+        Arc::new(CRLCheckVerifier::new(
+            verifier,
+            has_crls,
+            crl_check_requested,
+        ))
+    } else {
+        verifier
+    };
+
+    // Always use PartialChainVerifier when trust store is not empty
+    // This allows self-signed certificates in trust store to be trusted
+    // (OpenSSL behavior: self-signed certs are always trusted, non-self-signed require flag)
+    let verifier = if !ca_certs_der.is_empty() {
+        use crate::ssl::cert::PartialChainVerifier;
+        Arc::new(PartialChainVerifier::new(
+            verifier,
+            ca_certs_der,
+            verify_flags,
+        ))
+    } else {
+        verifier
+    };
+
+    // Wrap with StrictCertVerifier if VERIFY_X509_STRICT flag is set
+    if verify_flags & VERIFY_X509_STRICT != 0 {
+        Arc::new(super::cert::StrictCertVerifier::new(verifier, verify_flags))
+    } else {
+        verifier
+    }
+}
+
+/// Apply ALPN protocols
+///
+/// OpenSSL 1.1.0f+ allows ALPN negotiation to fail without aborting handshake.
+/// rustls follows RFC 7301 strictly and rejects connections with no matching protocol.
+/// To emulate OpenSSL behavior, we add a special fallback protocol (null byte).
+fn apply_alpn_with_fallback(config_alpn: &mut Vec<Vec<u8>>, alpn_protocols: &[Vec<u8>]) {
+    if !alpn_protocols.is_empty() {
+        *config_alpn = alpn_protocols.to_vec();
+        config_alpn.push(vec![0u8]); // Add null byte as fallback marker
+    }
+}
+
+/// Create a client TLS configuration
+///
+/// This abstracts the complex rustls ClientConfig building logic,
+/// matching SSL_CTX initialization for client sockets.
+pub(super) fn create_client_config(options: ClientConfigOptions) -> Result<ClientConfig, String> {
+    // Ensure default CryptoProvider is installed
+    ensure_default_provider();
+
+    // Create custom crypto provider using helper function
+    let custom_provider = create_custom_crypto_provider(
+        options.protocol_settings.cipher_suites.clone(),
+        options.protocol_settings.kx_groups.clone(),
+    );
+
+    // Step 1: Build the appropriate verifier based on verification settings
+    let verifier: Arc<dyn rustls::client::danger::ServerCertVerifier> = if options
+        .verify_server_cert
+    {
+        // Verify server certificates
+        let root_store = options
+            .root_store
+            .ok_or("Root store required for server verification")?;
+
+        let root_store_arc = Arc::new(root_store);
+
+        // Check if root_store is empty (no CA certs loaded)
+        // CPython allows this and fails during handshake with SSLCertVerificationError
+        if root_store_arc.is_empty() {
+            // Use EmptyRootStoreVerifier - always fails with UnknownIssuer during handshake
+            use crate::ssl::cert::EmptyRootStoreVerifier;
+            Arc::new(EmptyRootStoreVerifier)
+        } else {
+            // Calculate has_crls once for both hostname verification paths
+            let has_crls = !options.crls.is_empty();
+
+            if options.check_hostname {
+                // Default behavior: verify both certificate chain and hostname
+                let base_verifier = build_webpki_verifier_with_crls(
+                    root_store_arc.clone(),
+                    options.crls,
+                    options.verify_flags,
+                )?;
+
+                // Apply CRL and Strict verifier wrappers using helper function
+                apply_verifier_wrappers(
+                    base_verifier,
+                    options.verify_flags,
+                    has_crls,
+                    options.ca_certs_der.clone(),
+                )
+            } else {
+                // check_hostname=False: verify certificate chain but ignore hostname
+                use crate::ssl::cert::HostnameIgnoringVerifier;
+
+                // Build verifier with CRL support using helper function
+                let webpki_verifier = build_webpki_verifier_with_crls(
+                    root_store_arc.clone(),
+                    options.crls,
+                    options.verify_flags,
+                )?;
+
+                // Apply CRL verifier wrapper if needed (without Strict wrapper yet)
+                let crl_check_requested = options.verify_flags & X509_V_FLAG_CRL_CHECK != 0;
+                let verifier = if crl_check_requested {
+                    use crate::ssl::cert::CRLCheckVerifier;
+                    Arc::new(CRLCheckVerifier::new(
+                        webpki_verifier,
+                        has_crls,
+                        crl_check_requested,
+                    )) as Arc<dyn rustls::client::danger::ServerCertVerifier>
+                } else {
+                    webpki_verifier
+                };
+
+                // Wrap with PartialChainVerifier if VERIFY_X509_PARTIAL_CHAIN is set
+                const VERIFY_X509_PARTIAL_CHAIN: i32 = 0x80000;
+                let verifier = if options.verify_flags & VERIFY_X509_PARTIAL_CHAIN != 0 {
+                    use crate::ssl::cert::PartialChainVerifier;
+                    Arc::new(PartialChainVerifier::new(
+                        verifier,
+                        options.ca_certs_der.clone(),
+                        options.verify_flags,
+                    )) as Arc<dyn rustls::client::danger::ServerCertVerifier>
+                } else {
+                    verifier
+                };
+
+                // Wrap with HostnameIgnoringVerifier to bypass hostname checking
+                let hostname_ignoring_verifier: Arc<
+                    dyn rustls::client::danger::ServerCertVerifier,
+                > = Arc::new(HostnameIgnoringVerifier::new_with_verifier(verifier));
+
+                // Apply Strict verifier wrapper once at the end if needed
+                if options.verify_flags & VERIFY_X509_STRICT != 0 {
+                    Arc::new(crate::ssl::cert::StrictCertVerifier::new(
+                        hostname_ignoring_verifier,
+                        options.verify_flags,
+                    ))
+                } else {
+                    hostname_ignoring_verifier
+                }
+            }
+        }
+    } else {
+        // CERT_NONE: disable all verification
+        use crate::ssl::cert::NoVerifier;
+        Arc::new(NoVerifier)
+    };
+
+    // Step 2: Create ClientConfig builder once with the selected verifier
+    let builder = ClientConfig::builder_with_provider(custom_provider.clone())
+        .with_protocol_versions(options.protocol_settings.versions)
+        .map_err(|e| format!("Failed to create client config builder: {e}"))?
+        .dangerous()
+        .with_custom_certificate_verifier(verifier);
+
+    // Add client certificate if provided (mTLS)
+    let mut config =
+        if let (Some(cert_chain), Some(private_key)) = (options.cert_chain, options.private_key) {
+            builder
+                .with_client_auth_cert(cert_chain, private_key)
+                .map_err(|e| format!("Failed to set client certificate: {e}"))?
+        } else {
+            builder.with_no_client_auth()
+        };
+
+    // Set ALPN protocols
+    apply_alpn_with_fallback(
+        &mut config.alpn_protocols,
+        &options.protocol_settings.alpn_protocols,
+    );
+
+    // Set session resumption
+    if let Some(session_store) = options.session_store {
+        use rustls::client::Resumption;
+        config.resumption = Resumption::store(session_store);
+    }
+
+    Ok(config)
+}
+
+/// Helper function - check if error is BlockingIOError
+pub(super) fn is_blocking_io_error(err: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
+    err.fast_isinstance(vm.ctx.exceptions.blocking_io_error)
+}
+
+// Socket I/O Helper Functions
+
+/// Send all bytes to socket, handling partial sends with blocking wait
+///
+/// Loops until all bytes are sent. For blocking sockets, this will wait
+/// until all data is sent. For non-blocking sockets, returns WantWrite
+/// if no progress can be made.
+/// Optional deadline parameter allows respecting a read deadline during flush.
+fn send_all_bytes(
+    socket: &PySSLSocket,
+    buf: Vec<u8>,
+    vm: &VirtualMachine,
+    deadline: Option<std::time::Instant>,
+) -> SslResult<()> {
+    // First, flush any previously pending TLS data with deadline
+    socket
+        .flush_pending_tls_output(vm, deadline)
+        .map_err(SslError::Py)?;
+
+    if buf.is_empty() {
+        return Ok(());
+    }
+
+    let mut sent_total = 0;
+    while sent_total < buf.len() {
+        // Check deadline before each send attempt
+        if let Some(dl) = deadline
+            && std::time::Instant::now() >= dl
+        {
+            socket
+                .pending_tls_output
+                .lock()
+                .extend_from_slice(&buf[sent_total..]);
+            return Err(SslError::Timeout("The operation timed out".to_string()));
+        }
+
+        match socket.sock_send(&buf[sent_total..], vm) {
+            Ok(result) => {
+                let sent: usize = result
+                    .try_to_value::<isize>(vm)
+                    .map_err(SslError::Py)?
+                    .try_into()
+                    .map_err(|_| SslError::Syscall("Invalid send return value".to_string()))?;
+                if sent == 0 {
+                    // No progress - save unsent bytes to pending buffer
+                    socket
+                        .pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(SslError::WantWrite);
+                }
+                sent_total += sent;
+            }
+            Err(e) => {
+                if is_blocking_io_error(&e, vm) {
+                    // Save unsent bytes to pending buffer
+                    socket
+                        .pending_tls_output
+                        .lock()
+                        .extend_from_slice(&buf[sent_total..]);
+                    return Err(SslError::WantWrite);
+                }
+                // For other errors, also save unsent bytes
+                socket
+                    .pending_tls_output
+                    .lock()
+                    .extend_from_slice(&buf[sent_total..]);
+                return Err(SslError::Py(e));
+            }
+        }
+    }
+    Ok(())
+}
+
+// Handshake Helper Functions
+
+/// Write TLS handshake data to socket/BIO
+///
+/// Drains all pending TLS data from rustls and sends it to the peer.
+/// Returns whether any progress was made.
+fn handshake_write_loop(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    force_initial_write: bool,
+    vm: &VirtualMachine,
+) -> SslResult<bool> {
+    let mut made_progress = false;
+
+    // Flush any previously pending TLS data before generating new output
+    // Must succeed before sending new data to maintain order
+    socket
+        .flush_pending_tls_output(vm, None)
+        .map_err(SslError::Py)?;
+
+    while conn.wants_write() || force_initial_write {
+        if force_initial_write && !conn.wants_write() {
+            // No data to write on first iteration - break to avoid infinite loop
+            break;
+        }
+
+        let mut buf = Vec::new();
+        let written = conn
+            .write_tls(&mut buf as &mut dyn std::io::Write)
+            .map_err(SslError::Io)?;
+
+        if written > 0 && !buf.is_empty() {
+            // Send all bytes to socket, handling partial sends
+            send_all_bytes(socket, buf, vm, None)?;
+            made_progress = true;
+        } else if written == 0 {
+            // No data written but wants_write is true - should not happen normally
+            // Break to avoid infinite loop
+            break;
+        }
+
+        // Check if there's more to write
+        if !conn.wants_write() {
+            break;
+        }
+    }
+
+    Ok(made_progress)
+}
+
+/// Read TLS handshake data from socket/BIO
+///
+/// Waits for and reads TLS records from the peer, handling SNI callback setup.
+/// Returns (made_progress, is_first_sni_read).
+fn handshake_read_data(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    is_bio: bool,
+    is_server: bool,
+    vm: &VirtualMachine,
+) -> SslResult<(bool, bool)> {
+    if !conn.wants_read() {
+        return Ok((false, false));
+    }
+
+    // SERVER-SPECIFIC: Check if this is the first read (for SNI callback)
+    // Must check BEFORE reading data, so we can detect first time
+    let is_first_sni_read = is_server && socket.is_first_sni_read();
+
+    // Wait for data in socket mode
+    if !is_bio {
+        let timed_out = socket
+            .sock_wait_for_io_impl(SelectKind::Read, vm)
+            .map_err(SslError::Py)?;
+
+        if timed_out {
+            // This should rarely happen now - only if socket itself has a timeout
+            // and we're waiting for required handshake data
+            return Err(SslError::Timeout("timed out".to_string()));
+        }
+    }
+
+    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
+                    return Ok((false, false));
+                }
+            }
+            return Err(SslError::Py(e));
+        }
+    };
+
+    // SERVER-SPECIFIC: Save ClientHello on first read for potential connection recreation
+    if is_first_sni_read {
+        // Extract bytes from PyObjectRef
+        use rustpython_vm::builtins::PyBytes;
+        if let Some(bytes_obj) = data_obj.downcast_ref::<PyBytes>() {
+            socket.save_client_hello_from_bytes(bytes_obj.as_bytes());
+        }
+    }
+
+    // Feed data to rustls
+    ssl_read_tls_records(conn, data_obj, is_bio, vm)?;
+
+    Ok((true, is_first_sni_read))
+}
+
+/// Handle handshake completion for server-side TLS 1.3
+///
+/// Tries to send NewSessionTicket in non-blocking mode to avoid deadlocks.
+/// Returns true if handshake is complete and we should exit.
+fn handle_handshake_complete(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    _is_server: bool,
+    vm: &VirtualMachine,
+) -> SslResult<bool> {
+    if conn.is_handshaking() {
+        return Ok(false); // Not complete yet
+    }
+
+    // Handshake is complete!
+    //
+    // Different behavior for BIO mode vs socket mode:
+    //
+    // BIO mode (CPython-compatible):
+    // - Python code calls outgoing.read() to get pending data
+    // - We just return here and let Python handle the data
+    //
+    // Socket mode (rustls-specific):
+    // - OpenSSL automatically writes to socket in SSL_do_handshake()
+    // - We must explicitly call write_tls() to send pending data
+    // - Without this, client hangs waiting for server's NewSessionTicket
+
+    if socket.is_bio_mode() {
+        // BIO mode: Write pending data to outgoing BIO (one-time drain)
+        // Python's ssl_io_loop will read from outgoing BIO
+        if conn.wants_write() {
+            // Call write_tls ONCE to drain pending data
+            // Do NOT loop on wants_write() - avoid infinite loop/deadlock
+            let tls_data = ssl_write_tls_records(conn)?;
+            if !tls_data.is_empty() {
+                send_all_bytes(socket, tls_data, vm, None)?;
+            }
+
+            // IMPORTANT: Don't check wants_write() again!
+            // Python's ssl_io_loop will call do_handshake() again if needed
+        }
+    } else if conn.wants_write() {
+        // Send all pending data (e.g., TLS 1.3 NewSessionTicket) to socket
+        // Must drain ALL rustls buffer - don't break on WantWrite
+        while conn.wants_write() {
+            let tls_data = ssl_write_tls_records(conn)?;
+            if tls_data.is_empty() {
+                break;
+            }
+            match send_all_bytes(socket, tls_data, vm, None) {
+                Ok(()) => {}
+                Err(SslError::WantWrite) => {
+                    // Socket buffer full, data saved to pending_tls_output
+                    // Flush pending and continue draining rustls buffer
+                    socket
+                        .blocking_flush_all_pending(vm)
+                        .map_err(SslError::Py)?;
+                }
+                Err(e) => return Err(e),
+            }
+        }
+    }
+
+    // CRITICAL: Ensure all pending TLS data is sent before returning
+    // TLS 1.3 Finished must reach server before handshake is considered complete
+    // Without this, server may not process application data
+    if !socket.is_bio_mode() {
+        // Flush pending_tls_output to ensure all TLS data reaches the server
+        socket
+            .blocking_flush_all_pending(vm)
+            .map_err(SslError::Py)?;
+    }
+
+    Ok(true)
+}
+
+/// Try to read plaintext data from TLS connection buffer
+///
+/// Returns Ok(Some(n)) if n bytes were read, Ok(None) if would block,
+/// or Err on real errors.
+fn try_read_plaintext(conn: &mut TlsConnection, buf: &mut [u8]) -> SslResult<Option<usize>> {
+    let mut reader = conn.reader();
+    match reader.read(buf) {
+        Ok(0) => {
+            // EOF from TLS connection
+            Ok(Some(0))
+        }
+        Ok(n) => {
+            // Successfully read n bytes
+            Ok(Some(n))
+        }
+        Err(e) if e.kind() != std::io::ErrorKind::WouldBlock => {
+            // Real error
+            Err(SslError::Io(e))
+        }
+        Err(_) => {
+            // WouldBlock - no plaintext available
+            Ok(None)
+        }
+    }
+}
+
+/// Equivalent to OpenSSL's SSL_do_handshake()
+///
+/// Performs TLS handshake by exchanging data with the peer until completion.
+/// This abstracts away the low-level rustls read_tls/write_tls loop.
+///
+/// = SSL_do_handshake()
+pub(super) fn ssl_do_handshake(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    vm: &VirtualMachine,
+) -> SslResult<()> {
+    // Check if handshake is already done
+    if !conn.is_handshaking() {
+        return Ok(());
+    }
+
+    let is_bio = socket.is_bio_mode();
+    let is_server = matches!(conn, TlsConnection::Server(_));
+    let mut first_iteration = true; // Track if this is the first loop iteration
+    let mut iteration_count = 0;
+
+    loop {
+        iteration_count += 1;
+        let mut made_progress = false;
+
+        // IMPORTANT: In BIO mode, force initial write even if wants_write() is false
+        // rustls requires write_tls() to be called to generate ClientHello/ServerHello
+        let force_initial_write = is_bio && first_iteration;
+
+        // Write TLS handshake data to socket/BIO
+        let write_progress = handshake_write_loop(conn, socket, force_initial_write, vm)?;
+        made_progress |= write_progress;
+
+        // Read TLS handshake data from socket/BIO
+        let (read_progress, is_first_sni_read) =
+            handshake_read_data(conn, socket, is_bio, is_server, vm)?;
+        made_progress |= read_progress;
+
+        // Process TLS packets (state machine)
+        if let Err(e) = conn.process_new_packets() {
+            // Send close_notify on error
+            if !is_bio {
+                conn.send_close_notify();
+                // Flush any pending TLS data before sending close_notify
+                let _ = socket.flush_pending_tls_output(vm, None);
+                // Actually send the close_notify alert using send_all_bytes
+                // for proper partial send handling and retry logic
+                if let Ok(alert_data) = ssl_write_tls_records(conn)
+                    && !alert_data.is_empty()
+                {
+                    let _ = send_all_bytes(socket, alert_data, vm, None);
+                }
+            }
+
+            // InvalidMessage during handshake means non-TLS data was received
+            // before the handshake completed (e.g., HTTP request to TLS server)
+            if matches!(e, rustls::Error::InvalidMessage(_)) {
+                return Err(SslError::PreauthData);
+            }
+
+            // Certificate verification errors are already handled by from_rustls
+
+            return Err(SslError::from_rustls(e));
+        }
+
+        // SERVER-SPECIFIC: Check SNI callback after processing packets
+        // SNI name is extracted during process_new_packets()
+        // Invoke callback on FIRST read if callback is configured, regardless of SNI presence
+        if is_server && is_first_sni_read && socket.has_sni_callback() {
+            // IMPORTANT: Do NOT call the callback here!
+            // The connection lock is still held, which would cause deadlock.
+            // Return SniCallbackRestart to signal do_handshake to:
+            // 1. Drop conn_guard
+            // 2. Call the callback (with Some(name) or None)
+            // 3. Restart handshake
+            return Err(SslError::SniCallbackRestart);
+        }
+
+        // Check if handshake is complete and handle post-handshake processing
+        // CRITICAL: We do NOT check wants_read() - this matches CPython/OpenSSL behavior!
+        if handle_handshake_complete(conn, socket, is_server, vm)? {
+            return Ok(());
+        }
+
+        // In BIO mode, stop after one iteration
+        if is_bio {
+            // Before returning WANT error, write any pending TLS data to BIO
+            // This is critical: if wants_write is true after process_new_packets,
+            // we need to write that data to the outgoing BIO before returning
+            if conn.wants_write() {
+                // Write all pending TLS data to outgoing BIO
+                loop {
+                    let mut buf = vec![0u8; SSL3_RT_MAX_PLAIN_LENGTH];
+                    let n = match conn.write_tls(&mut buf.as_mut_slice()) {
+                        Ok(n) => n,
+                        Err(_) => break,
+                    };
+                    if n == 0 {
+                        break;
+                    }
+                    // Send to outgoing BIO
+                    send_all_bytes(socket, buf[..n].to_vec(), vm, None)?;
+                    // Check if there's more to write
+                    if !conn.wants_write() {
+                        break;
+                    }
+                }
+                // After writing, check if we still want more
+                // If all data was written, wants_write may now be false
+                if conn.wants_write() {
+                    // Still need more - return WANT_WRITE
+                    return Err(SslError::WantWrite);
+                }
+                // Otherwise fall through to check wants_read
+            }
+
+            // Check if we need to read
+            if conn.wants_read() {
+                return Err(SslError::WantRead);
+            }
+            break;
+        }
+
+        // Mark that we've completed the first iteration
+        first_iteration = false;
+
+        // Improved loop termination logic:
+        // Continue looping if:
+        // 1. Rustls wants more I/O (wants_read or wants_write), OR
+        // 2. We made progress in this iteration
+        //
+        // This is more robust than just checking made_progress, because:
+        // - Rustls may need multiple iterations to process TLS state machine
+        // - Network delays may cause temporary "no progress" situations
+        // - wants_read/wants_write accurately reflect Rustls internal state
+        let should_continue = conn.wants_read() || conn.wants_write() || made_progress;
+
+        if !should_continue {
+            break;
+        }
+
+        // Safety check: prevent truly infinite loops (should never happen)
+        if iteration_count > 1000 {
+            break;
+        }
+    }
+
+    // If we exit the loop without completing handshake, return error
+    // Check rustls state to provide better error message
+    if conn.is_handshaking() {
+        Err(SslError::Syscall(format!(
+            "SSL handshake failed: incomplete after {iteration_count} iterations",
+        )))
+    } else {
+        // Handshake completed successfully (shouldn't reach here normally)
+        Ok(())
+    }
+}
+
+/// Equivalent to OpenSSL's SSL_read()
+///
+/// Reads application data from TLS connection.
+/// Automatically handles TLS record I/O as needed.
+///
+/// = SSL_read_ex()
+pub(super) fn ssl_read(
+    conn: &mut TlsConnection,
+    buf: &mut [u8],
+    socket: &PySSLSocket,
+    vm: &VirtualMachine,
+) -> SslResult<usize> {
+    let is_bio = socket.is_bio_mode();
+
+    // Get socket timeout and calculate deadline (= _PyDeadline_Init)
+    let deadline = if !is_bio {
+        match socket.get_socket_timeout(vm).map_err(SslError::Py)? {
+            Some(timeout) if !timeout.is_zero() => Some(std::time::Instant::now() + timeout),
+            _ => None, // None = blocking (no deadline), Some(0) = non-blocking (handled below)
+        }
+    } else {
+        None // BIO mode has no deadline
+    };
+
+    // CRITICAL: Flush any pending TLS output before reading
+    // This ensures data from previous write() calls is sent before we wait for response.
+    // Without this, write() may leave data in pending_tls_output (if socket buffer was full),
+    // and read() would timeout waiting for a response that the server never received.
+    if !is_bio {
+        socket
+            .flush_pending_tls_output(vm, deadline)
+            .map_err(SslError::Py)?;
+    }
+
+    // Loop to handle TLS records and post-handshake messages
+    // Matches SSL_read behavior which loops until data is available
+    //   - CPython uses OpenSSL's SSL_read which loops on SSL_ERROR_WANT_READ/WANT_WRITE
+    //   - We use rustls which requires manual read_tls/process_new_packets loop
+    //   - No iteration limit: relies on deadline and blocking I/O
+    //   - Blocking sockets: sock_select() and recv() wait at kernel level (no CPU busy-wait)
+    //   - Non-blocking sockets: immediate return on first WantRead
+    //   - Deadline prevents timeout issues
+
+    loop {
+        // Check deadline
+        if let Some(deadline) = deadline
+            && std::time::Instant::now() >= deadline
+        {
+            // Timeout expired
+            return Err(SslError::Timeout(
+                "The read operation timed out".to_string(),
+            ));
+        }
+        // Check if we need to read more TLS records BEFORE trying plaintext read
+        // This ensures we don't miss data that's already been processed
+        let needs_more_tls = conn.wants_read();
+
+        // Try to read plaintext from rustls buffer
+        if let Some(n) = try_read_plaintext(conn, buf)? {
+            return Ok(n);
+        }
+
+        // No plaintext available and rustls doesn't want to read more TLS records
+        if !needs_more_tls {
+            // Check if connection needs to write data first (e.g., TLS key update, renegotiation)
+            // This mirrors the handshake logic which checks both wants_read() and wants_write()
+            if conn.wants_write() && !is_bio {
+                // Check deadline BEFORE attempting flush
+                if let Some(deadline) = deadline
+                    && std::time::Instant::now() >= deadline
+                {
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
+                }
+
+                // Flush pending TLS data before continuing
+                // CRITICAL: Pass deadline so flush respects read timeout
+                let tls_data = ssl_write_tls_records(conn)?;
+                if !tls_data.is_empty() {
+                    // Use best-effort send - don't fail READ just because WRITE couldn't complete
+                    match send_all_bytes(socket, tls_data, vm, deadline) {
+                        Ok(()) => {}
+                        Err(SslError::WantWrite) => {
+                            // Socket buffer full - acceptable during READ operation
+                            // Pending data will be sent on next write/read call
+                        }
+                        Err(SslError::Timeout(_)) => {
+                            // Timeout during flush is acceptable during READ
+                            // Pending data stays buffered for next operation
+                        }
+                        Err(e) => return Err(e),
+                    }
+                }
+
+                // Check deadline AFTER flush attempt
+                if let Some(deadline) = deadline
+                    && std::time::Instant::now() >= deadline
+                {
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
+                }
+
+                // After flushing, rustls may want to read again - continue loop
+                continue;
+            }
+
+            // BIO mode: check for EOF
+            if is_bio && let Some(bio_obj) = socket.incoming_bio() {
+                let is_eof = bio_obj
+                    .get_attr("eof", vm)
+                    .and_then(|v| v.try_into_value::<bool>(vm))
+                    .unwrap_or(false);
+                if is_eof {
+                    return Err(SslError::Eof);
+                }
+            }
+
+            // For non-blocking sockets, return WantRead so caller can poll and retry.
+            // For blocking sockets (or sockets with timeout), wait for more data.
+            if !is_bio {
+                let timeout = socket.get_socket_timeout(vm).map_err(SslError::Py)?;
+                if let Some(t) = timeout
+                    && t.is_zero()
+                {
+                    // Non-blocking socket: return immediately
+                    return Err(SslError::WantRead);
+                }
+                // Blocking socket or socket with timeout: try to read more data from socket.
+                // Even though rustls says it doesn't want to read, more TLS records may arrive.
+                // This handles the case where rustls processed all buffered TLS records but
+                // more data is coming over the network.
+                let data = match socket.sock_recv(2048, vm) {
+                    Ok(data) => data,
+                    Err(e) => {
+                        if is_connection_closed_error(&e, vm) {
+                            return Err(SslError::Eof);
+                        }
+                        return Err(SslError::Py(e));
+                    }
+                };
+
+                let bytes_read = data
+                    .clone()
+                    .try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
+                    .map(|b| b.as_bytes().len())
+                    .unwrap_or(0);
+
+                if bytes_read == 0 {
+                    // No more data available - connection might be closed
+                    return Err(SslError::Eof);
+                }
+
+                // Feed data to rustls and process
+                ssl_read_tls_records(conn, data, false, vm)?;
+                conn.process_new_packets().map_err(SslError::from_rustls)?;
+
+                // Continue loop to try reading plaintext
+                continue;
+            }
+
+            return Err(SslError::WantRead);
+        }
+
+        // Read and process TLS records
+        match ssl_ensure_data_available(conn, socket, vm) {
+            Ok(_bytes_read) => {
+                // Successfully read and processed TLS data
+                // Continue loop to try reading plaintext
+            }
+            Err(SslError::Io(ref io_err)) if io_err.to_string().contains("message buffer full") => {
+                // This case should be rare now that ssl_read_tls_records handles buffer full
+                // Just continue loop to try again
+                continue;
+            }
+            Err(e) => {
+                // Other errors - check for buffered plaintext before propagating
+                match try_read_plaintext(conn, buf)? {
+                    Some(n) if n > 0 => {
+                        // Have buffered plaintext - return it successfully
+                        return Ok(n);
+                    }
+                    _ => {
+                        // No buffered data - propagate the error
+                        return Err(e);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// Helper functions (private-ish, used by public SSL functions)
+
+/// Write TLS records from rustls to socket
+fn ssl_write_tls_records(conn: &mut TlsConnection) -> SslResult<Vec<u8>> {
+    let mut buf = Vec::new();
+    let n = conn
+        .write_tls(&mut buf as &mut dyn std::io::Write)
+        .map_err(SslError::Io)?;
+
+    if n > 0 { Ok(buf) } else { Ok(Vec::new()) }
+}
+
+/// Read TLS records from socket to rustls
+fn ssl_read_tls_records(
+    conn: &mut TlsConnection,
+    data: PyObjectRef,
+    is_bio: bool,
+    vm: &VirtualMachine,
+) -> SslResult<()> {
+    // Convert PyObject to bytes-like (supports bytes, bytearray, etc.)
+    let bytes = ArgBytesLike::try_from_object(vm, data)
+        .map_err(|_| SslError::Syscall("Expected bytes-like object".to_string()))?;
+
+    let bytes_data = bytes.borrow_buf();
+
+    if bytes_data.is_empty() {
+        // different error for BIO vs socket mode
+        if is_bio {
+            // In BIO mode, no data means WANT_READ
+            return Err(SslError::WantRead);
+        } else {
+            // In socket mode, empty recv() means TCP EOF (FIN received)
+            // Need to distinguish:
+            // 1. Clean shutdown: received TLS close_notify → return ZeroReturn (0 bytes)
+            // 2. Unexpected EOF: no close_notify → return Eof (SSLEOFError)
+            //
+            // SSL_ERROR_ZERO_RETURN vs SSL_ERROR_SYSCALL(errno=0) logic
+            // CPython checks SSL_get_shutdown() & SSL_RECEIVED_SHUTDOWN
+            //
+            // Process any buffered TLS records (may contain close_notify)
+            let _ = conn.process_new_packets();
+
+            // IMPORTANT: CPython's default behavior (suppress_ragged_eofs=True)
+            // treats empty recv() as clean shutdown, returning 0 bytes instead of raising SSLEOFError.
+            //
+            // This is necessary for HTTP/1.0 servers that:
+            // 1. Send response without Content-Length header
+            // 2. Signal end-of-response by closing connection (TCP FIN)
+            // 3. Don't send TLS close_notify before TCP close
+            //
+            // While this could theoretically allow truncation attacks,
+            // it's the standard behavior for compatibility with real-world servers.
+            // Python only raises SSLEOFError when suppress_ragged_eofs=False is explicitly set.
+            //
+            // TODO: Implement suppress_ragged_eofs parameter if needed for strict security mode.
+            return Err(SslError::ZeroReturn);
+        }
+    }
+
+    // Feed all received data to read_tls - loop to consume all data
+    // read_tls may not consume all data in one call, and buffer may become full
+    let mut offset = 0;
+    while offset < bytes_data.len() {
+        let remaining = &bytes_data[offset..];
+        let mut cursor = std::io::Cursor::new(remaining);
+
+        match conn.read_tls(&mut cursor) {
+            Ok(read_bytes) => {
+                if read_bytes == 0 {
+                    // Buffer is full - process existing packets to make room
+                    conn.process_new_packets().map_err(SslError::from_rustls)?;
+
+                    // Try again - if we still can't consume, break
+                    let mut retry_cursor = std::io::Cursor::new(remaining);
+                    match conn.read_tls(&mut retry_cursor) {
+                        Ok(0) => {
+                            // Still can't consume - break to avoid infinite loop
+                            break;
+                        }
+                        Ok(n) => {
+                            offset += n;
+                        }
+                        Err(e) => {
+                            return Err(SslError::Io(e));
+                        }
+                    }
+                } else {
+                    offset += read_bytes;
+                }
+            }
+            Err(e) => {
+                // Check if it's a buffer full error (unlikely but handle it)
+                if e.to_string().contains("buffer full") {
+                    conn.process_new_packets().map_err(SslError::from_rustls)?;
+                    continue;
+                }
+                // Real error - propagate it
+                return Err(SslError::Io(e));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Check if an exception is a connection closed error
+/// In SSL context, these errors indicate unexpected connection termination without proper TLS shutdown
+fn is_connection_closed_error(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
+    use rustpython_vm::stdlib::errno::errors;
+
+    // Check for ConnectionAbortedError, ConnectionResetError (Python exception types)
+    if exc.fast_isinstance(vm.ctx.exceptions.connection_aborted_error)
+        || exc.fast_isinstance(vm.ctx.exceptions.connection_reset_error)
+    {
+        return true;
+    }
+
+    // Also check OSError with specific errno values (ECONNABORTED, ECONNRESET)
+    if exc.fast_isinstance(vm.ctx.exceptions.os_error)
+        && let Ok(errno) = exc.as_object().get_attr("errno", vm)
+        && let Ok(errno_int) = errno.try_int(vm)
+        && let Ok(errno_val) = errno_int.try_to_primitive::<i32>(vm)
+    {
+        return errno_val == errors::ECONNABORTED || errno_val == errors::ECONNRESET;
+    }
+    false
+}
+
+/// Ensure TLS data is available for reading
+/// Returns the number of bytes read from the socket
+fn ssl_ensure_data_available(
+    conn: &mut TlsConnection,
+    socket: &PySSLSocket,
+    vm: &VirtualMachine,
+) -> SslResult<usize> {
+    // Unlike OpenSSL's SSL_read, rustls requires explicit I/O
+    if conn.wants_read() {
+        let is_bio = socket.is_bio_mode();
+
+        // For non-BIO mode (regular sockets), check if socket is ready first
+        // PERFORMANCE OPTIMIZATION: Only use select for sockets with timeout
+        // - Blocking sockets (timeout=None): Skip select, recv() will block naturally
+        // - Timeout sockets: Use select to enforce timeout
+        // - Non-blocking sockets: Skip select, recv() will return EAGAIN immediately
+        if !is_bio {
+            let timeout = socket.get_socket_timeout(vm).map_err(SslError::Py)?;
+
+            // Only use select if socket has a positive timeout
+            if let Some(t) = timeout
+                && !t.is_zero()
+            {
+                // Socket has timeout - use select to enforce it
+                let timed_out = socket
+                    .sock_wait_for_io_impl(SelectKind::Read, vm)
+                    .map_err(SslError::Py)?;
+                if timed_out {
+                    // Socket not ready within timeout - raise socket.timeout
+                    return Err(SslError::Timeout(
+                        "The read operation timed out".to_string(),
+                    ));
+                }
+            }
+            // else: non-blocking socket (timeout=0) or blocking socket (timeout=None) - skip select
+        }
+
+        let data = match socket.sock_recv(2048, vm) {
+            Ok(data) => data,
+            Err(e) => {
+                // 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);
+                }
+                return Err(SslError::Py(e));
+            }
+        };
+
+        // Get the size of received data
+        let bytes_read = data
+            .clone()
+            .try_into_value::<rustpython_vm::builtins::PyBytes>(vm)
+            .map(|b| b.as_bytes().len())
+            .unwrap_or(0);
+
+        // Check if BIO has EOF set (incoming BIO closed)
+        let is_eof = if is_bio {
+            // Check incoming BIO's eof property
+            if let Some(bio_obj) = socket.incoming_bio() {
+                bio_obj
+                    .get_attr("eof", vm)
+                    .and_then(|v| v.try_into_value::<bool>(vm))
+                    .unwrap_or(false)
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+
+        // If BIO EOF is set and no data available, treat as connection EOF
+        if is_eof && bytes_read == 0 {
+            return Err(SslError::Eof);
+        }
+
+        // Feed data to rustls and process packets
+        ssl_read_tls_records(conn, data, is_bio, vm)?;
+
+        // Process any packets we successfully read
+        conn.process_new_packets().map_err(SslError::from_rustls)?;
+
+        Ok(bytes_read)
+    } else {
+        // No data to read
+        Ok(0)
+    }
+}
+
+// Multi-Certificate Resolver for RSA/ECC Support
+
+/// Multi-certificate resolver that selects appropriate certificate based on client capabilities
+///
+/// This resolver implements OpenSSL's behavior of supporting multiple certificate/key pairs
+/// (e.g., one RSA and one ECC) and selecting the appropriate one based on the client's
+/// supported signature algorithms during the TLS handshake.
+///
+/// OpenSSL's SSL_CTX_use_certificate_chain_file can be called multiple
+/// times to add different certificate types, and OpenSSL automatically selects the best one.
+#[derive(Debug)]
+pub(super) struct MultiCertResolver {
+    cert_keys: Vec<Arc<CertifiedKey>>,
+}
+
+impl MultiCertResolver {
+    /// Create a new multi-certificate resolver
+    pub fn new(cert_keys: Vec<Arc<CertifiedKey>>) -> Self {
+        Self { cert_keys }
+    }
+}
+
+impl ResolvesServerCert for MultiCertResolver {
+    fn resolve(&self, client_hello: rustls::server::ClientHello<'_>) -> Option<Arc<CertifiedKey>> {
+        // Get the signature schemes supported by the client
+        let client_schemes = client_hello.signature_schemes();
+
+        // Try to find a certificate that matches the client's signature schemes
+        for cert_key in &self.cert_keys {
+            // Check if this certificate's signing key is compatible with any of the
+            // client's supported signature schemes
+            if let Some(_scheme) = cert_key.key.choose_scheme(client_schemes) {
+                return Some(cert_key.clone());
+            }
+        }
+
+        // If no perfect match, return the first certificate as fallback
+        // (This matches OpenSSL's behavior of using the first loaded cert if negotiation fails)
+        self.cert_keys.first().cloned()
+    }
+}
+
+// Helper Functions for OpenSSL Compatibility:
+
+/// Normalize cipher suite name for OpenSSL compatibility
+///
+/// Converts rustls cipher names to OpenSSL format:
+/// - TLS_AES_256_GCM_SHA384 → AES256-GCM-SHA384
+/// - Replaces "AES-256" with "AES256" and "AES-128" with "AES128"
+pub(super) fn normalize_cipher_name(rustls_name: &str) -> String {
+    rustls_name
+        .strip_prefix("TLS_")
+        .unwrap_or(rustls_name)
+        .replace("_WITH_", "_")
+        .replace('_', "-")
+        .replace("AES-256", "AES256")
+        .replace("AES-128", "AES128")
+}
+
+/// Get cipher key size in bits from cipher suite name
+///
+/// Returns:
+/// - 256 for AES-256 and ChaCha20
+/// - 128 for AES-128
+/// - 0 for unknown ciphers
+pub(super) fn get_cipher_key_bits(cipher_name: &str) -> i32 {
+    if cipher_name.contains("256") || cipher_name.contains("CHACHA20") {
+        256
+    } else if cipher_name.contains("128") {
+        128
+    } else {
+        0
+    }
+}
+
+/// Get encryption algorithm description from cipher name
+///
+/// Returns human-readable encryption description for OpenSSL compatibility
+pub(super) fn get_cipher_encryption_desc(cipher_name: &str) -> &'static str {
+    if cipher_name.contains("AES256") {
+        "AESGCM(256)"
+    } else if cipher_name.contains("AES128") {
+        "AESGCM(128)"
+    } else if cipher_name.contains("CHACHA20") {
+        "CHACHA20-POLY1305(256)"
+    } else {
+        "Unknown"
+    }
+}
+
+/// Normalize rustls cipher suite name to IANA standard format
+///
+/// Converts rustls Debug format names to IANA standard:
+/// - "TLS13_AES_256_GCM_SHA384" -> "TLS_AES_256_GCM_SHA384"
+/// - Other names remain unchanged
+pub(super) fn normalize_rustls_cipher_name(rustls_name: &str) -> String {
+    if rustls_name.starts_with("TLS13_") {
+        rustls_name.replace("TLS13_", "TLS_")
+    } else {
+        rustls_name.to_string()
+    }
+}
+
+/// Convert rustls protocol version to string representation
+///
+/// Returns the TLS version string
+/// - TLSv1.2, TLSv1.3, or "Unknown"
+pub(super) fn get_protocol_version_str(version: &rustls::SupportedProtocolVersion) -> &'static str {
+    match version.version {
+        rustls::ProtocolVersion::TLSv1_2 => "TLSv1.2",
+        rustls::ProtocolVersion::TLSv1_3 => "TLSv1.3",
+        _ => "Unknown",
+    }
+}
+
+/// Cipher suite information
+///
+/// Contains all relevant cipher information extracted from a rustls CipherSuite
+pub(super) struct CipherInfo {
+    /// IANA standard cipher name (e.g., "TLS_AES_256_GCM_SHA384")
+    pub name: String,
+    /// TLS protocol version (e.g., "TLSv1.2", "TLSv1.3")
+    pub protocol: &'static str,
+    /// Key size in bits (e.g., 128, 256)
+    pub bits: i32,
+}
+
+/// Extract cipher information from a rustls CipherSuite
+///
+/// This consolidates the common cipher extraction logic used across
+/// get_ciphers(), cipher(), and shared_ciphers() methods.
+pub(super) fn extract_cipher_info(suite: &rustls::SupportedCipherSuite) -> CipherInfo {
+    let rustls_name = format!("{:?}", suite.suite());
+    let name = normalize_rustls_cipher_name(&rustls_name);
+    let protocol = get_protocol_version_str(suite.version());
+    let bits = get_cipher_key_bits(&name);
+
+    CipherInfo {
+        name,
+        protocol,
+        bits,
+    }
+}
+
+/// Convert curve name to rustls key exchange group
+///
+/// Maps OpenSSL curve names (e.g., "prime256v1", "secp384r1") to rustls KxGroups.
+/// Returns an error if the curve is not supported by rustls.
+pub(super) fn curve_name_to_kx_group(
+    curve: &str,
+) -> Result<Vec<&'static dyn SupportedKxGroup>, String> {
+    // Get the default crypto provider's key exchange groups
+    let provider = rustls::crypto::aws_lc_rs::default_provider();
+    let all_groups = &provider.kx_groups;
+
+    match curve {
+        // P-256 (also known as secp256r1 or prime256v1)
+        "prime256v1" | "secp256r1" => {
+            // Find SECP256R1 in the provider's groups
+            all_groups
+                .iter()
+                .find(|g| g.name() == rustls::NamedGroup::secp256r1)
+                .map(|g| vec![*g])
+                .ok_or_else(|| "secp256r1 not supported by crypto provider".to_owned())
+        }
+        // P-384 (also known as secp384r1 or prime384v1)
+        "secp384r1" | "prime384v1" => all_groups
+            .iter()
+            .find(|g| g.name() == rustls::NamedGroup::secp384r1)
+            .map(|g| vec![*g])
+            .ok_or_else(|| "secp384r1 not supported by crypto provider".to_owned()),
+        // X25519
+        "X25519" | "x25519" => all_groups
+            .iter()
+            .find(|g| g.name() == rustls::NamedGroup::X25519)
+            .map(|g| vec![*g])
+            .ok_or_else(|| "X25519 not supported by crypto provider".to_owned()),
+        // P-521 (also known as secp521r1 or prime521v1)
+        // Now supported with aws-lc-rs crypto provider
+        "prime521v1" | "secp521r1" => all_groups
+            .iter()
+            .find(|g| g.name() == rustls::NamedGroup::secp521r1)
+            .map(|g| vec![*g])
+            .ok_or_else(|| "secp521r1 not supported by crypto provider".to_owned()),
+        // X448
+        // Now supported with aws-lc-rs crypto provider
+        "X448" | "x448" => all_groups
+            .iter()
+            .find(|g| g.name() == rustls::NamedGroup::X448)
+            .map(|g| vec![*g])
+            .ok_or_else(|| "X448 not supported by crypto provider".to_owned()),
+        _ => Err(format!("unknown curve name '{curve}'")),
+    }
+}
diff --git a/crates/stdlib/src/ssl/error.rs b/crates/stdlib/src/ssl/error.rs
new file mode 100644
index 0000000000..d77910f6aa
--- /dev/null
+++ b/crates/stdlib/src/ssl/error.rs
@@ -0,0 +1,135 @@
+// SSL exception types shared between ssl (rustls) and openssl backends
+
+pub(crate) use ssl_error::*;
+
+#[pymodule(sub)]
+pub(crate) mod ssl_error {
+    use crate::vm::{
+        Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyBaseException, PyOSError, PyStrRef},
+        types::{Constructor, Initializer},
+    };
+
+    // Error type constants - exposed as pyattr and available for internal use
+    #[pyattr]
+    pub(crate) const SSL_ERROR_NONE: i32 = 0;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_SSL: i32 = 1;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_READ: i32 = 2;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_WRITE: i32 = 3;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_X509_LOOKUP: i32 = 4;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_SYSCALL: i32 = 5;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_ZERO_RETURN: i32 = 6;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_WANT_CONNECT: i32 = 7;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_EOF: i32 = 8;
+    #[pyattr]
+    pub(crate) const SSL_ERROR_INVALID_ERROR_CODE: i32 = 10;
+
+    #[pyattr]
+    #[pyexception(name = "SSLError", base = PyOSError)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLError(PyOSError);
+
+    #[pyexception]
+    impl PySSLError {
+        // Returns strerror attribute if available, otherwise str(args)
+        #[pymethod]
+        fn __str__(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            use crate::vm::AsObject;
+            // Try to get strerror attribute first (OSError compatibility)
+            if let Ok(strerror) = exc.as_object().get_attr("strerror", vm)
+                && !vm.is_none(&strerror)
+            {
+                return strerror.str(vm);
+            }
+
+            // Otherwise return str(args)
+            let args = exc.args();
+            if args.len() == 1 {
+                args.as_slice()[0].str(vm)
+            } else {
+                args.as_object().str(vm)
+            }
+        }
+    }
+
+    #[pyattr]
+    #[pyexception(name = "SSLZeroReturnError", base = PySSLError)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLZeroReturnError(PySSLError);
+
+    #[pyexception]
+    impl PySSLZeroReturnError {}
+
+    #[pyattr]
+    #[pyexception(name = "SSLWantReadError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLWantReadError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLWantWriteError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLWantWriteError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLSyscallError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLSyscallError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLEOFError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLEOFError(PySSLError);
+
+    #[pyattr]
+    #[pyexception(name = "SSLCertVerificationError", base = PySSLError, impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySSLCertVerificationError(PySSLError);
+
+    // Helper functions to create SSL exceptions with proper errno attribute
+    pub fn create_ssl_want_read_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLWantReadError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_WANT_READ),
+            "The operation did not complete (read)",
+        )
+    }
+
+    pub fn create_ssl_want_write_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLWantWriteError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_WANT_WRITE),
+            "The operation did not complete (write)",
+        )
+    }
+
+    pub fn create_ssl_eof_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLEOFError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_EOF),
+            "EOF occurred in violation of protocol",
+        )
+    }
+
+    pub fn create_ssl_zero_return_error(vm: &VirtualMachine) -> PyRef<PyOSError> {
+        vm.new_os_subtype_error(
+            PySSLZeroReturnError::class(&vm.ctx).to_owned(),
+            Some(SSL_ERROR_ZERO_RETURN),
+            "TLS/SSL connection has been closed (EOF)",
+        )
+    }
+}
diff --git a/crates/stdlib/src/ssl/oid.rs b/crates/stdlib/src/ssl/oid.rs
new file mode 100644
index 0000000000..2e13733a2a
--- /dev/null
+++ b/crates/stdlib/src/ssl/oid.rs
@@ -0,0 +1,464 @@
+// spell-checker: disable
+
+//! OID (Object Identifier) management for SSL/TLS
+//!
+//! This module provides OID lookup functionality compatible with CPython's ssl module.
+//! It uses oid-registry crate for well-known OIDs while maintaining NID (Numerical Identifier)
+//! mappings for CPython compatibility.
+
+use oid_registry::asn1_rs::Oid;
+use std::collections::HashMap;
+
+/// OID entry with openssl-compatible metadata
+#[derive(Debug, Clone)]
+pub struct OidEntry {
+    /// NID (OpenSSL Numerical Identifier) - must match CPython/OpenSSL values
+    pub nid: i32,
+    /// Short name (e.g., "CN", "serverAuth")
+    pub short_name: &'static str,
+    /// Long name/description (e.g., "commonName", "TLS Web Server Authentication")
+    pub long_name: &'static str,
+    /// OID reference (static or dynamic)
+    pub oid: OidRef,
+}
+
+/// OID reference - either from oid-registry or runtime-created
+#[derive(Debug, Clone)]
+pub enum OidRef {
+    /// Static OID from oid-registry crate (stored as value)
+    Static(Oid<'static>),
+    /// OID string (for OIDs not in oid-registry) - parsed on demand
+    String(&'static str),
+}
+
+impl OidEntry {
+    /// Create entry from oid-registry static constant
+    pub fn from_static(
+        nid: i32,
+        short_name: &'static str,
+        long_name: &'static str,
+        oid: &Oid<'static>,
+    ) -> Self {
+        Self {
+            nid,
+            short_name,
+            long_name,
+            oid: OidRef::Static(oid.clone()),
+        }
+    }
+
+    /// Create entry from OID string (for OIDs not in oid-registry)
+    pub const fn from_string(
+        nid: i32,
+        short_name: &'static str,
+        long_name: &'static str,
+        oid_str: &'static str,
+    ) -> Self {
+        Self {
+            nid,
+            short_name,
+            long_name,
+            oid: OidRef::String(oid_str),
+        }
+    }
+
+    /// Get OID as string (e.g., "2.5.4.3")
+    pub fn oid_string(&self) -> String {
+        match &self.oid {
+            OidRef::Static(oid) => oid.to_id_string(),
+            OidRef::String(s) => s.to_string(),
+        }
+    }
+}
+
+/// OID table with multiple indices for fast lookup
+pub struct OidTable {
+    /// All entries
+    entries: Vec<OidEntry>,
+    /// NID -> index mapping
+    nid_to_idx: HashMap<i32, usize>,
+    /// Short name -> index mapping
+    short_name_to_idx: HashMap<&'static str, usize>,
+    /// Long name -> index mapping (case-insensitive)
+    long_name_to_idx: HashMap<String, usize>,
+    /// OID string -> index mapping
+    oid_str_to_idx: HashMap<String, usize>,
+}
+
+impl OidTable {
+    fn build() -> Self {
+        let entries = build_oid_entries();
+        let mut nid_to_idx = HashMap::with_capacity(entries.len());
+        let mut short_name_to_idx = HashMap::with_capacity(entries.len());
+        let mut long_name_to_idx = HashMap::with_capacity(entries.len());
+        let mut oid_str_to_idx = HashMap::with_capacity(entries.len());
+
+        for (idx, entry) in entries.iter().enumerate() {
+            nid_to_idx.insert(entry.nid, idx);
+            short_name_to_idx.insert(entry.short_name, idx);
+            long_name_to_idx.insert(entry.long_name.to_lowercase(), idx);
+            oid_str_to_idx.insert(entry.oid_string(), idx);
+        }
+
+        Self {
+            entries,
+            nid_to_idx,
+            short_name_to_idx,
+            long_name_to_idx,
+            oid_str_to_idx,
+        }
+    }
+
+    pub fn find_by_nid(&self, nid: i32) -> Option<&OidEntry> {
+        self.nid_to_idx.get(&nid).map(|&idx| &self.entries[idx])
+    }
+
+    pub fn find_by_oid_string(&self, oid_str: &str) -> Option<&OidEntry> {
+        self.oid_str_to_idx
+            .get(oid_str)
+            .map(|&idx| &self.entries[idx])
+    }
+
+    pub fn find_by_name(&self, name: &str) -> Option<&OidEntry> {
+        // Try short name first (exact match)
+        self.short_name_to_idx
+            .get(name)
+            .or_else(|| {
+                // Try long name (case-insensitive)
+                self.long_name_to_idx.get(&name.to_lowercase())
+            })
+            .map(|&idx| &self.entries[idx])
+    }
+}
+
+/// Global OID table
+static OID_TABLE: std::sync::LazyLock<OidTable> = std::sync::LazyLock::new(OidTable::build);
+
+/// Macro to define OID entry using oid-registry constant
+macro_rules! oid_static {
+    ($nid:expr, $short:expr, $long:expr, $oid_const:path) => {
+        OidEntry::from_static($nid, $short, $long, &$oid_const)
+    };
+}
+
+/// Macro to define OID entry from string
+macro_rules! oid_string {
+    ($nid:expr, $short:expr, $long:expr, $oid_str:expr) => {
+        OidEntry::from_string($nid, $short, $long, $oid_str)
+    };
+}
+
+/// Build the complete OID table
+fn build_oid_entries() -> Vec<OidEntry> {
+    vec![
+        // Priority 1: X.509 DN Attributes (OpenSSL NID values)
+        // These NIDs MUST match OpenSSL for CPython compatibility
+        oid_static!(13, "CN", "commonName", oid_registry::OID_X509_COMMON_NAME),
+        oid_static!(14, "C", "countryName", oid_registry::OID_X509_COUNTRY_NAME),
+        oid_static!(
+            15,
+            "L",
+            "localityName",
+            oid_registry::OID_X509_LOCALITY_NAME
+        ),
+        oid_static!(
+            16,
+            "ST",
+            "stateOrProvinceName",
+            oid_registry::OID_X509_STATE_OR_PROVINCE_NAME
+        ),
+        oid_static!(
+            17,
+            "O",
+            "organizationName",
+            oid_registry::OID_X509_ORGANIZATION_NAME
+        ),
+        oid_static!(
+            18,
+            "OU",
+            "organizationalUnitName",
+            oid_registry::OID_X509_ORGANIZATIONAL_UNIT
+        ),
+        oid_static!(41, "name", "name", oid_registry::OID_X509_NAME),
+        oid_static!(42, "GN", "givenName", oid_registry::OID_X509_GIVEN_NAME),
+        oid_static!(43, "initials", "initials", oid_registry::OID_X509_INITIALS),
+        oid_static!(
+            4,
+            "serialNumber",
+            "serialNumber",
+            oid_registry::OID_X509_SERIALNUMBER
+        ),
+        oid_static!(100, "surname", "surname", oid_registry::OID_X509_SURNAME),
+        // emailAddress is special - it's in PKCS#9, not X.509
+        oid_static!(
+            48,
+            "emailAddress",
+            "emailAddress",
+            oid_registry::OID_PKCS9_EMAIL_ADDRESS
+        ),
+        // Priority 2: X.509 Extensions (Critical ones)
+        oid_static!(
+            82,
+            "subjectKeyIdentifier",
+            "X509v3 Subject Key Identifier",
+            oid_registry::OID_X509_EXT_SUBJECT_KEY_IDENTIFIER
+        ),
+        oid_static!(
+            83,
+            "keyUsage",
+            "X509v3 Key Usage",
+            oid_registry::OID_X509_EXT_KEY_USAGE
+        ),
+        oid_static!(
+            85,
+            "subjectAltName",
+            "X509v3 Subject Alternative Name",
+            oid_registry::OID_X509_EXT_SUBJECT_ALT_NAME
+        ),
+        oid_static!(
+            86,
+            "issuerAltName",
+            "X509v3 Issuer Alternative Name",
+            oid_registry::OID_X509_EXT_ISSUER_ALT_NAME
+        ),
+        oid_static!(
+            87,
+            "basicConstraints",
+            "X509v3 Basic Constraints",
+            oid_registry::OID_X509_EXT_BASIC_CONSTRAINTS
+        ),
+        oid_static!(
+            88,
+            "crlNumber",
+            "X509v3 CRL Number",
+            oid_registry::OID_X509_EXT_CRL_NUMBER
+        ),
+        oid_static!(
+            90,
+            "authorityKeyIdentifier",
+            "X509v3 Authority Key Identifier",
+            oid_registry::OID_X509_EXT_AUTHORITY_KEY_IDENTIFIER
+        ),
+        oid_static!(
+            126,
+            "extendedKeyUsage",
+            "X509v3 Extended Key Usage",
+            oid_registry::OID_X509_EXT_EXTENDED_KEY_USAGE
+        ),
+        oid_static!(
+            103,
+            "crlDistributionPoints",
+            "X509v3 CRL Distribution Points",
+            oid_registry::OID_X509_EXT_CRL_DISTRIBUTION_POINTS
+        ),
+        oid_static!(
+            89,
+            "certificatePolicies",
+            "X509v3 Certificate Policies",
+            oid_registry::OID_X509_EXT_CERTIFICATE_POLICIES
+        ),
+        oid_static!(
+            177,
+            "authorityInfoAccess",
+            "Authority Information Access",
+            oid_registry::OID_PKIX_AUTHORITY_INFO_ACCESS
+        ),
+        oid_static!(
+            105,
+            "nameConstraints",
+            "X509v3 Name Constraints",
+            oid_registry::OID_X509_EXT_NAME_CONSTRAINTS
+        ),
+        // Priority 3: Extended Key Usage OIDs (not in oid-registry)
+        // These are defined in RFC 5280 but not in oid-registry, so we use strings
+        oid_string!(
+            129,
+            "serverAuth",
+            "TLS Web Server Authentication",
+            "1.3.6.1.5.5.7.3.1"
+        ),
+        oid_string!(
+            130,
+            "clientAuth",
+            "TLS Web Client Authentication",
+            "1.3.6.1.5.5.7.3.2"
+        ),
+        oid_string!(131, "codeSigning", "Code Signing", "1.3.6.1.5.5.7.3.3"),
+        oid_string!(
+            132,
+            "emailProtection",
+            "E-mail Protection",
+            "1.3.6.1.5.5.7.3.4"
+        ),
+        oid_string!(133, "timeStamping", "Time Stamping", "1.3.6.1.5.5.7.3.8"),
+        oid_string!(180, "OCSPSigning", "OCSP Signing", "1.3.6.1.5.5.7.3.9"),
+        // Priority 4: Signature Algorithms
+        oid_static!(
+            6,
+            "rsaEncryption",
+            "rsaEncryption",
+            oid_registry::OID_PKCS1_RSAENCRYPTION
+        ),
+        oid_static!(
+            65,
+            "sha1WithRSAEncryption",
+            "sha1WithRSAEncryption",
+            oid_registry::OID_PKCS1_SHA1WITHRSA
+        ),
+        oid_static!(
+            668,
+            "sha256WithRSAEncryption",
+            "sha256WithRSAEncryption",
+            oid_registry::OID_PKCS1_SHA256WITHRSA
+        ),
+        oid_static!(
+            669,
+            "sha384WithRSAEncryption",
+            "sha384WithRSAEncryption",
+            oid_registry::OID_PKCS1_SHA384WITHRSA
+        ),
+        oid_static!(
+            670,
+            "sha512WithRSAEncryption",
+            "sha512WithRSAEncryption",
+            oid_registry::OID_PKCS1_SHA512WITHRSA
+        ),
+        oid_static!(
+            408,
+            "id-ecPublicKey",
+            "id-ecPublicKey",
+            oid_registry::OID_KEY_TYPE_EC_PUBLIC_KEY
+        ),
+        oid_static!(
+            794,
+            "ecdsa-with-SHA256",
+            "ecdsa-with-SHA256",
+            oid_registry::OID_SIG_ECDSA_WITH_SHA256
+        ),
+        oid_static!(
+            795,
+            "ecdsa-with-SHA384",
+            "ecdsa-with-SHA384",
+            oid_registry::OID_SIG_ECDSA_WITH_SHA384
+        ),
+        oid_static!(
+            796,
+            "ecdsa-with-SHA512",
+            "ecdsa-with-SHA512",
+            oid_registry::OID_SIG_ECDSA_WITH_SHA512
+        ),
+        // Priority 5: Hash Algorithms
+        oid_string!(64, "sha1", "sha1", "1.3.14.3.2.26"),
+        oid_static!(672, "sha256", "sha256", oid_registry::OID_NIST_HASH_SHA256),
+        oid_static!(673, "sha384", "sha384", oid_registry::OID_NIST_HASH_SHA384),
+        oid_static!(674, "sha512", "sha512", oid_registry::OID_NIST_HASH_SHA512),
+        oid_string!(675, "sha224", "sha224", "2.16.840.1.101.3.4.2.4"),
+        // Priority 6: Elliptic Curve OIDs
+        oid_static!(714, "secp256r1", "secp256r1", oid_registry::OID_EC_P256),
+        oid_string!(715, "secp384r1", "secp384r1", "1.3.132.0.34"),
+        oid_string!(716, "secp521r1", "secp521r1", "1.3.132.0.35"),
+        oid_string!(1172, "X25519", "X25519", "1.3.101.110"),
+        oid_string!(1173, "Ed25519", "Ed25519", "1.3.101.112"),
+        // Additional useful OIDs
+        oid_string!(
+            183,
+            "subjectInfoAccess",
+            "Subject Information Access",
+            "1.3.6.1.5.5.7.1.11"
+        ),
+        oid_string!(920, "OCSP", "OCSP", "1.3.6.1.5.5.7.48.1"),
+        oid_string!(921, "caIssuers", "CA Issuers", "1.3.6.1.5.5.7.48.2"),
+    ]
+}
+
+// Public API Functions
+
+/// Find OID entry by NID
+pub fn find_by_nid(nid: i32) -> Option<&'static OidEntry> {
+    OID_TABLE.find_by_nid(nid)
+}
+
+/// Find OID entry by OID string (e.g., "2.5.4.3")
+pub fn find_by_oid_string(oid_str: &str) -> Option<&'static OidEntry> {
+    OID_TABLE.find_by_oid_string(oid_str)
+}
+
+/// Find OID entry by name (short or long name)
+pub fn find_by_name(name: &str) -> Option<&'static OidEntry> {
+    OID_TABLE.find_by_name(name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_by_nid() {
+        let entry = find_by_nid(13).unwrap();
+        assert_eq!(entry.short_name, "CN");
+        assert_eq!(entry.long_name, "commonName");
+        assert_eq!(entry.oid_string(), "2.5.4.3");
+    }
+
+    #[test]
+    fn test_find_by_oid_string() {
+        let entry = find_by_oid_string("2.5.4.3").unwrap();
+        assert_eq!(entry.nid, 13);
+        assert_eq!(entry.short_name, "CN");
+    }
+
+    #[test]
+    fn test_find_by_name_short() {
+        let entry = find_by_name("CN").unwrap();
+        assert_eq!(entry.nid, 13);
+        assert_eq!(entry.oid_string(), "2.5.4.3");
+    }
+
+    #[test]
+    fn test_find_by_name_long() {
+        let entry = find_by_name("commonName").unwrap();
+        assert_eq!(entry.nid, 13);
+        assert_eq!(entry.short_name, "CN");
+    }
+
+    #[test]
+    fn test_find_by_name_case_insensitive() {
+        let entry = find_by_name("COMMONNAME").unwrap();
+        assert_eq!(entry.nid, 13);
+    }
+
+    #[test]
+    fn test_subject_alt_name() {
+        let entry = find_by_nid(85).unwrap();
+        assert_eq!(entry.short_name, "subjectAltName");
+        assert_eq!(entry.oid_string(), "2.5.29.17");
+    }
+
+    #[test]
+    fn test_server_auth_eku() {
+        let entry = find_by_nid(129).unwrap();
+        assert_eq!(entry.short_name, "serverAuth");
+        assert_eq!(entry.oid_string(), "1.3.6.1.5.5.7.3.1");
+    }
+
+    #[test]
+    fn test_no_duplicate_nids() {
+        let table = &*OID_TABLE;
+        assert_eq!(
+            table.entries.len(),
+            table.nid_to_idx.len(),
+            "Duplicate NIDs detected!"
+        );
+    }
+
+    #[test]
+    fn test_oid_count() {
+        let table = &*OID_TABLE;
+        // We should have 50+ OIDs defined
+        assert!(
+            table.entries.len() >= 50,
+            "Expected at least 50 OIDs, got {}",
+            table.entries.len()
+        );
+    }
+}
diff --git a/stdlib/src/statistics.rs b/crates/stdlib/src/statistics.rs
similarity index 97%
rename from stdlib/src/statistics.rs
rename to crates/stdlib/src/statistics.rs
index 141493c125..8be2447ffd 100644
--- a/stdlib/src/statistics.rs
+++ b/crates/stdlib/src/statistics.rs
@@ -7,7 +7,7 @@ mod _statistics {
     // See https://github.com/python/cpython/blob/6846d6712a0894f8e1a91716c11dd79f42864216/Modules/_statisticsmodule.c#L28-L120
     #[allow(clippy::excessive_precision)]
     fn normal_dist_inv_cdf(p: f64, mu: f64, sigma: f64) -> Option<f64> {
-        if p <= 0.0 || p >= 1.0 || sigma <= 0.0 {
+        if p <= 0.0 || p >= 1.0 {
             return None;
         }
 
@@ -126,7 +126,7 @@ mod _statistics {
         sigma: ArgIntoFloat,
         vm: &VirtualMachine,
     ) -> PyResult<f64> {
-        normal_dist_inv_cdf(*p, *mu, *sigma)
+        normal_dist_inv_cdf(p.into_float(), mu.into_float(), sigma.into_float())
             .ok_or_else(|| vm.new_value_error("inv_cdf undefined for these parameters"))
     }
 }
diff --git a/stdlib/src/suggestions.rs b/crates/stdlib/src/suggestions.rs
similarity index 100%
rename from stdlib/src/suggestions.rs
rename to crates/stdlib/src/suggestions.rs
diff --git a/stdlib/src/syslog.rs b/crates/stdlib/src/syslog.rs
similarity index 89%
rename from stdlib/src/syslog.rs
rename to crates/stdlib/src/syslog.rs
index 205fd85c44..b52d141569 100644
--- a/stdlib/src/syslog.rs
+++ b/crates/stdlib/src/syslog.rs
@@ -11,7 +11,8 @@ mod syslog {
         function::{OptionalArg, OptionalOption},
         utils::ToCString,
     };
-    use std::{ffi::CStr, os::raw::c_char};
+    use core::ffi::CStr;
+    use std::os::raw::c_char;
 
     #[pyattr]
     use libc::{
@@ -26,16 +27,16 @@ mod syslog {
     use libc::{LOG_AUTHPRIV, LOG_CRON, LOG_PERROR};
 
     fn get_argv(vm: &VirtualMachine) -> Option<PyStrRef> {
-        if let Some(argv) = vm.state.settings.argv.first() {
-            if !argv.is_empty() {
-                return Some(
-                    PyStr::from(match argv.find('\\') {
-                        Some(value) => &argv[value..],
-                        None => argv,
-                    })
-                    .into_ref(&vm.ctx),
-                );
-            }
+        if let Some(argv) = vm.state.config.settings.argv.first()
+            && !argv.is_empty()
+        {
+            return Some(
+                PyStr::from(match argv.find('\\') {
+                    Some(value) => &argv[value..],
+                    None => argv,
+                })
+                .into_ref(&vm.ctx),
+            );
         }
         None
     }
@@ -50,7 +51,7 @@ mod syslog {
         fn as_ptr(&self) -> *const c_char {
             match self {
                 Self::Explicit(cstr) => cstr.as_ptr(),
-                Self::Implicit => std::ptr::null(),
+                Self::Implicit => core::ptr::null(),
             }
         }
     }
diff --git a/stdlib/src/termios.rs b/crates/stdlib/src/termios.rs
similarity index 98%
rename from stdlib/src/termios.rs
rename to crates/stdlib/src/termios.rs
index 5bd8395ec3..a9ae1375c6 100644
--- a/stdlib/src/termios.rs
+++ b/crates/stdlib/src/termios.rs
@@ -217,9 +217,12 @@ mod termios {
             ))
         })?;
         for (cc, x) in termios.c_cc.iter_mut().zip(cc.iter()) {
-            *cc = if let Some(c) = x.payload::<PyBytes>().filter(|b| b.as_bytes().len() == 1) {
+            *cc = if let Some(c) = x
+                .downcast_ref::<PyBytes>()
+                .filter(|b| b.as_bytes().len() == 1)
+            {
                 c.as_bytes()[0] as _
-            } else if let Some(i) = x.payload::<PyInt>() {
+            } else if let Some(i) = x.downcast_ref::<PyInt>() {
                 i.try_to_primitive(vm)?
             } else {
                 return Err(vm.new_type_error(
diff --git a/stdlib/src/tkinter.rs b/crates/stdlib/src/tkinter.rs
similarity index 77%
rename from stdlib/src/tkinter.rs
rename to crates/stdlib/src/tkinter.rs
index 687458b193..6b7c4387d6 100644
--- a/stdlib/src/tkinter.rs
+++ b/crates/stdlib/src/tkinter.rs
@@ -4,8 +4,9 @@ pub(crate) use self::_tkinter::make_module;
 
 #[pymodule]
 mod _tkinter {
+    use rustpython_vm::convert::IntoPyException;
     use rustpython_vm::types::Constructor;
-    use rustpython_vm::{PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+    use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
 
     use rustpython_vm::builtins::{PyInt, PyStr, PyType};
     use std::{ffi, ptr};
@@ -59,8 +60,8 @@ mod _tkinter {
         value: *mut tk_sys::Tcl_Obj,
     }
 
-    impl std::fmt::Debug for TclObject {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for TclObject {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "TclObject")
         }
     }
@@ -72,6 +73,7 @@ mod _tkinter {
     impl TclObject {}
 
     static QUIT_MAIN_LOOP: AtomicBool = AtomicBool::new(false);
+    static ERROR_IN_CMD: AtomicBool = AtomicBool::new(false);
 
     #[pyattr]
     #[pyclass(name = "tkapp")]
@@ -107,8 +109,8 @@ mod _tkinter {
     unsafe impl Send for TkApp {}
     unsafe impl Sync for TkApp {}
 
-    impl std::fmt::Debug for TkApp {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    impl core::fmt::Debug for TkApp {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "TkApp")
         }
     }
@@ -125,7 +127,7 @@ mod _tkinter {
         interactive: i32,
         #[pyarg(any)]
         wantobjects: i32,
-        #[pyarg(any, default = "true")]
+        #[pyarg(any, default = true)]
         want_tk: bool,
         #[pyarg(any)]
         sync: i32,
@@ -136,11 +138,7 @@ mod _tkinter {
     impl Constructor for TkApp {
         type Args = TkAppConstructorArgs;
 
-        fn py_new(
-            _zelf: PyRef<PyType>,
-            args: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyObjectRef> {
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             create(args, vm)
         }
     }
@@ -168,10 +166,18 @@ mod _tkinter {
         )))
     }
 
+    #[derive(Debug, FromArgs)]
+    struct TkAppGetVarArgs {
+        #[pyarg(any)]
+        name: PyObjectRef,
+        #[pyarg(any, default)]
+        name2: Option<String>,
+    }
+
     // TODO: DISALLOW_INSTANTIATION
     #[pyclass(with(Constructor))]
     impl TkApp {
-        fn from_bool(&self, obj: *mut tk_sys::Tcl_Obj) -> bool {
+        fn tcl_obj_to_bool(&self, obj: *mut tk_sys::Tcl_Obj) -> bool {
             let mut res = -1;
             unsafe {
                 if tk_sys::Tcl_GetBooleanFromObj(self.interpreter, obj, &mut res)
@@ -184,16 +190,16 @@ mod _tkinter {
             res != 0
         }
 
-        fn from_object(
+        fn tcl_obj_to_pyobject(
             &self,
             obj: *mut tk_sys::Tcl_Obj,
             vm: &VirtualMachine,
         ) -> PyResult<PyObjectRef> {
             let type_ptr = unsafe { (*obj).typePtr };
-            if type_ptr == ptr::null() {
+            if type_ptr.is_null() {
                 return self.unicode_from_object(obj, vm);
             } else if type_ptr == self.old_boolean_type || type_ptr == self.boolean_type {
-                return Ok(vm.ctx.new_bool(self.from_bool(obj)).into());
+                return Ok(vm.ctx.new_bool(self.tcl_obj_to_bool(obj)).into());
             } else if type_ptr == self.string_type
                 || type_ptr == self.utf32_string_type
                 || type_ptr == self.pixel_type
@@ -202,7 +208,7 @@ mod _tkinter {
             }
             // TODO: handle other types
 
-            return Ok(TclObject { value: obj }.into_pyobject(vm));
+            Ok(TclObject { value: obj }.into_pyobject(vm))
         }
 
         fn unicode_from_string(
@@ -226,8 +232,8 @@ mod _tkinter {
             vm: &VirtualMachine,
         ) -> PyResult<PyObjectRef> {
             let type_ptr = unsafe { (*obj).typePtr };
-            if type_ptr != ptr::null()
-                && self.interpreter != ptr::null_mut()
+            if !type_ptr.is_null()
+                && !self.interpreter.is_null()
                 && (type_ptr == self.string_type || type_ptr == self.utf32_string_type)
             {
                 let len = ptr::null_mut();
@@ -247,30 +253,75 @@ mod _tkinter {
             Self::unicode_from_string(s, len as _, vm)
         }
 
-        #[pymethod]
-        fn getvar(&self, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        fn var_invoke(&self) {
+            if self.threaded && self.thread_id != Some(unsafe { tk_sys::Tcl_GetCurrentThread() }) {
+                // TODO: do stuff
+            }
+        }
+
+        fn inner_getvar(
+            &self,
+            args: TkAppGetVarArgs,
+            flags: u32,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let TkAppGetVarArgs { name, name2 } = args;
             // TODO: technically not thread safe
-            let name = varname_converter(arg, vm)?;
+            let name = varname_converter(name, vm)?;
 
+            let name = ffi::CString::new(name).map_err(|e| e.into_pyexception(vm))?;
+            let name2 =
+                ffi::CString::new(name2.unwrap_or_default()).map_err(|e| e.into_pyexception(vm))?;
+            let name2_ptr = if name2.is_empty() {
+                ptr::null()
+            } else {
+                name2.as_ptr()
+            };
             let res = unsafe {
                 tk_sys::Tcl_GetVar2Ex(
                     self.interpreter,
-                    ptr::null(),
                     name.as_ptr() as _,
-                    tk_sys::TCL_LEAVE_ERR_MSG as _,
+                    name2_ptr as _,
+                    flags as _,
                 )
             };
-            if res == ptr::null_mut() {
-                todo!();
+            if res.is_null() {
+                // TODO: Should be tk error
+                unsafe {
+                    let err_obj = tk_sys::Tcl_GetObjResult(self.interpreter);
+                    let err_str_obj = tk_sys::Tcl_GetString(err_obj);
+                    let err_cstr = ffi::CStr::from_ptr(err_str_obj as _);
+                    return Err(vm.new_type_error(format!("{err_cstr:?}")));
+                }
             }
             let res = if self.want_objects {
-                self.from_object(res, vm)
+                self.tcl_obj_to_pyobject(res, vm)
             } else {
                 self.unicode_from_object(res, vm)
             }?;
             Ok(res)
         }
 
+        #[pymethod]
+        fn getvar(&self, args: TkAppGetVarArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            self.var_invoke();
+            self.inner_getvar(args, tk_sys::TCL_LEAVE_ERR_MSG, vm)
+        }
+
+        #[pymethod]
+        fn globalgetvar(
+            &self,
+            args: TkAppGetVarArgs,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            self.var_invoke();
+            self.inner_getvar(
+                args,
+                tk_sys::TCL_LEAVE_ERR_MSG | tk_sys::TCL_GLOBAL_ONLY,
+                vm,
+            )
+        }
+
         #[pymethod]
         fn getint(&self, arg: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
             if let Some(int) = arg.downcast_ref::<PyInt>() {
@@ -289,7 +340,21 @@ mod _tkinter {
         #[pymethod]
         fn mainloop(&self, threshold: Option<i32>) -> PyResult<()> {
             let threshold = threshold.unwrap_or(0);
-            todo!();
+            // self.dispatching = true;
+            QUIT_MAIN_LOOP.store(false, Ordering::Relaxed);
+            while unsafe { tk_sys::Tk_GetNumMainWindows() } > threshold
+                && !QUIT_MAIN_LOOP.load(Ordering::Relaxed)
+                && !ERROR_IN_CMD.load(Ordering::Relaxed)
+            {
+                if self.threaded {
+                    unsafe { tk_sys::Tcl_DoOneEvent(0 as _) };
+                } else {
+                    unsafe { tk_sys::Tcl_DoOneEvent(tk_sys::TCL_DONT_WAIT as _) };
+                    // TODO: sleep for the proper time
+                    std::thread::sleep(std::time::Duration::from_millis(1));
+                }
+            }
+            Ok(())
         }
 
         #[pymethod]
@@ -299,13 +364,15 @@ mod _tkinter {
     }
 
     #[pyfunction]
-    fn create(args: TkAppConstructorArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    fn create(args: TkAppConstructorArgs, vm: &VirtualMachine) -> PyResult<TkApp> {
         unsafe {
             let interp = tk_sys::Tcl_CreateInterp();
             let want_objects = args.wantobjects != 0;
-            let threaded = {
+            let threaded = !{
                 let part1 = String::from("tcl_platform");
                 let part2 = String::from("threaded");
+                let part1 = ffi::CString::new(part1).map_err(|e| e.into_pyexception(vm))?;
+                let part2 = ffi::CString::new(part2).map_err(|e| e.into_pyexception(vm))?;
                 let part1_ptr = part1.as_ptr();
                 let part2_ptr = part2.as_ptr();
                 tk_sys::Tcl_GetVar2Ex(
@@ -314,7 +381,8 @@ mod _tkinter {
                     part2_ptr as _,
                     tk_sys::TCL_GLOBAL_ONLY as ffi::c_int,
                 )
-            } != ptr::null_mut();
+            }
+            .is_null();
             let thread_id = tk_sys::Tcl_GetCurrentThread();
             let dispatching = false;
             let trace = None;
@@ -339,8 +407,8 @@ mod _tkinter {
             let double_type = tk_sys::Tcl_GetObjType(double_str.as_ptr() as _);
             let int_str = String::from("int");
             let int_type = tk_sys::Tcl_GetObjType(int_str.as_ptr() as _);
-            let int_type = if int_type == ptr::null() {
-                let mut value = *tk_sys::Tcl_NewIntObj(0);
+            let int_type = if int_type.is_null() {
+                let mut value = *tk_sys::Tcl_NewWideIntObj(0);
                 let res = value.typePtr;
                 tk_sys::Tcl_DecrRefCount(&mut value);
                 res
@@ -374,33 +442,37 @@ mod _tkinter {
             }
 
             if args.interactive != 0 {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "tcl_interactive".as_ptr() as _,
+                    ptr::null(),
                     "1".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
             } else {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "tcl_interactive".as_ptr() as _,
+                    ptr::null(),
                     "0".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
             }
 
             let argv0 = args.class_name.clone().to_lowercase();
-            tk_sys::Tcl_SetVar(
+            tk_sys::Tcl_SetVar2(
                 interp,
                 "argv0".as_ptr() as _,
+                ptr::null(),
                 argv0.as_ptr() as _,
                 tk_sys::TCL_GLOBAL_ONLY as i32,
             );
 
             if !args.want_tk {
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "_tkinter_skip_tk_init".as_ptr() as _,
+                    ptr::null(),
                     "1".as_ptr() as _,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
@@ -418,11 +490,12 @@ mod _tkinter {
                     argv.push_str("-use ");
                     argv.push_str(&args.use_.unwrap());
                 }
-                argv.push_str("\0");
+                argv.push('\0');
                 let argv_ptr = argv.as_ptr() as *mut *mut i8;
-                tk_sys::Tcl_SetVar(
+                tk_sys::Tcl_SetVar2(
                     interp,
                     "argv".as_ptr() as _,
+                    ptr::null(),
                     argv_ptr as *const i8,
                     tk_sys::TCL_GLOBAL_ONLY as i32,
                 );
@@ -460,8 +533,7 @@ mod _tkinter {
                 string_type,
                 utf32_string_type,
                 pixel_type,
-            }
-            .into_pyobject(vm))
+            })
         }
     }
 
diff --git a/stdlib/src/unicodedata.rs b/crates/stdlib/src/unicodedata.rs
similarity index 92%
rename from stdlib/src/unicodedata.rs
rename to crates/stdlib/src/unicodedata.rs
index 6fbb385c4c..68d9a17e57 100644
--- a/stdlib/src/unicodedata.rs
+++ b/crates/stdlib/src/unicodedata.rs
@@ -24,9 +24,7 @@ pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
         "east_asian_width",
         "normalize",
         "mirrored",
-    ]
-    .into_iter()
-    {
+    ] {
         crate::vm::extend_module!(vm, &module, {
             attr => ucd.get_attr(attr, vm).unwrap(),
         });
@@ -107,7 +105,7 @@ mod unicodedata {
         }
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl Ucd {
         #[pymethod]
         fn category(&self, character: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
@@ -123,10 +121,10 @@ mod unicodedata {
 
         #[pymethod]
         fn lookup(&self, name: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-            if let Some(character) = unicode_names2::character(name.as_str()) {
-                if self.check_age(character.into()) {
-                    return Ok(character.to_string());
-                }
+            if let Some(character) = unicode_names2::character(name.as_str())
+                && self.check_age(character.into())
+            {
+                return Ok(character.to_string());
             }
             Err(vm.new_lookup_error(format!("undefined character name '{name}'")))
         }
@@ -140,14 +138,13 @@ mod unicodedata {
         ) -> PyResult {
             let c = self.extract_char(character, vm)?;
 
-            if let Some(c) = c {
-                if self.check_age(c) {
-                    if let Some(name) = c.to_char().and_then(unicode_names2::name) {
-                        return Ok(vm.ctx.new_str(name.to_string()).into());
-                    }
-                }
+            if let Some(c) = c
+                && self.check_age(c)
+                && let Some(name) = c.to_char().and_then(unicode_names2::name)
+            {
+                return Ok(vm.ctx.new_str(name.to_string()).into());
             }
-            default.ok_or_else(|| vm.new_value_error("character name not found!"))
+            default.ok_or_else(|| vm.new_value_error("no such name"))
         }
 
         #[pymethod]
diff --git a/stdlib/src/uuid.rs b/crates/stdlib/src/uuid.rs
similarity index 90%
rename from stdlib/src/uuid.rs
rename to crates/stdlib/src/uuid.rs
index 9b0e23a81c..3f75db402c 100644
--- a/stdlib/src/uuid.rs
+++ b/crates/stdlib/src/uuid.rs
@@ -30,4 +30,7 @@ mod _uuid {
     fn has_uuid_generate_time_safe(_vm: &VirtualMachine) -> u32 {
         0
     }
+
+    #[pyattr(name = "has_stable_extractable_node")]
+    const HAS_STABLE_EXTRACTABLE_NODE: bool = false;
 }
diff --git a/stdlib/src/zlib.rs b/crates/stdlib/src/zlib.rs
similarity index 95%
rename from stdlib/src/zlib.rs
rename to crates/stdlib/src/zlib.rs
index cf5669145b..632543c5c6 100644
--- a/stdlib/src/zlib.rs
+++ b/crates/stdlib/src/zlib.rs
@@ -10,8 +10,8 @@ mod zlib {
         Decompressor, USE_AFTER_FINISH_ERR, flush_sync,
     };
     use crate::vm::{
-        PyObject, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyBytesRef, PyIntRef, PyTypeRef},
+        Py, PyObject, PyPayload, PyResult, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyBytesRef, PyIntRef, PyType, PyTypeRef},
         common::lock::PyMutex,
         convert::{ToPyException, TryFromBorrowedObject},
         function::{ArgBytesLike, ArgPrimitiveIndex, ArgSize, OptionalArg},
@@ -39,7 +39,7 @@ mod zlib {
     #[pyattr(name = "ZLIB_RUNTIME_VERSION")]
     #[pyattr]
     const ZLIB_VERSION: &str = unsafe {
-        match std::ffi::CStr::from_ptr(libz_sys::zlibVersion()).to_str() {
+        match core::ffi::CStr::from_ptr(libz_sys::zlibVersion()).to_str() {
             Ok(s) => s,
             Err(_) => unreachable!(),
         }
@@ -193,11 +193,11 @@ mod zlib {
     fn decompressobj(args: DecompressobjArgs, vm: &VirtualMachine) -> PyResult<PyDecompress> {
         let mut decompress = InitOptions::new(args.wbits.value, vm)?.decompress();
         let zdict = args.zdict.into_option();
-        if let Some(dict) = &zdict {
-            if args.wbits.value < 0 {
-                dict.with_ref(|d| decompress.set_dictionary(d))
-                    .map_err(|_| new_zlib_error("failed to set dictionary", vm))?;
-            }
+        if let Some(dict) = &zdict
+            && args.wbits.value < 0
+        {
+            dict.with_ref(|d| decompress.set_dictionary(d))
+                .map_err(|_| new_zlib_error("failed to set dictionary", vm))?;
         }
         let inner = PyDecompressInner {
             decompress: Some(DecompressWithDict { decompress, zdict }),
@@ -225,7 +225,7 @@ mod zlib {
         inner: PyMutex<PyDecompressInner>,
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl PyDecompress {
         #[pygetset]
         fn eof(&self) -> bool {
@@ -322,7 +322,7 @@ mod zlib {
             };
 
             let inner = &mut *self.inner.lock();
-            let data = std::mem::replace(&mut inner.unconsumed_tail, vm.ctx.empty_bytes.clone());
+            let data = core::mem::replace(&mut inner.unconsumed_tail, vm.ctx.empty_bytes.clone());
 
             let (ret, _) = Self::decompress_inner(inner, &data, length, None, true, vm)?;
 
@@ -383,7 +383,7 @@ mod zlib {
         inner: PyMutex<CompressState<CompressInner>>,
     }
 
-    #[pyclass]
+    #[pyclass(flags(DISALLOW_INSTANTIATION))]
     impl PyCompress {
         #[pymethod]
         fn compress(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
@@ -422,7 +422,6 @@ mod zlib {
     }
 
     impl CompressStatusKind for Status {
-        const OK: Self = Self::Ok;
         const EOF: Self = Self::StreamEnd;
 
         fn to_usize(self) -> usize {
@@ -571,21 +570,19 @@ mod zlib {
     impl Constructor for ZlibDecompressor {
         type Args = DecompressobjArgs;
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
             let mut decompress = InitOptions::new(args.wbits.value, vm)?.decompress();
             let zdict = args.zdict.into_option();
-            if let Some(dict) = &zdict {
-                if args.wbits.value < 0 {
-                    dict.with_ref(|d| decompress.set_dictionary(d))
-                        .map_err(|_| new_zlib_error("failed to set dictionary", vm))?;
-                }
+            if let Some(dict) = &zdict
+                && args.wbits.value < 0
+            {
+                dict.with_ref(|d| decompress.set_dictionary(d))
+                    .map_err(|_| new_zlib_error("failed to set dictionary", vm))?;
             }
             let inner = DecompressState::new(DecompressWithDict { decompress, zdict }, vm);
-            Self {
+            Ok(Self {
                 inner: PyMutex::new(inner),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
diff --git a/crates/venvlauncher/Cargo.toml b/crates/venvlauncher/Cargo.toml
new file mode 100644
index 0000000000..ac3ea106b7
--- /dev/null
+++ b/crates/venvlauncher/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "rustpython-venvlauncher"
+description = "Lightweight venv launcher for RustPython"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+# Free-threaded variants (RustPython uses Py_GIL_DISABLED=true)
+[[bin]]
+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/venvlauncher/build.rs b/crates/venvlauncher/build.rs
new file mode 100644
index 0000000000..404f46a484
--- /dev/null
+++ b/crates/venvlauncher/build.rs
@@ -0,0 +1,21 @@
+//! Build script for venvlauncher
+//!
+//! Sets the Windows subsystem to GUI for venvwlauncher variants.
+//! Only MSVC toolchain is supported on Windows (same as CPython).
+
+fn main() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let target_env = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
+
+    // Only apply on Windows with MSVC toolchain
+    if target_os == "windows" && target_env == "msvc" {
+        let exe_name = std::env::var("CARGO_BIN_NAME").unwrap_or_default();
+
+        // venvwlauncher and venvwlaunchert should be Windows GUI applications
+        // (no console window)
+        if exe_name.contains("venvw") {
+            println!("cargo:rustc-link-arg=/SUBSYSTEM:WINDOWS");
+            println!("cargo:rustc-link-arg=/ENTRY:mainCRTStartup");
+        }
+    }
+}
diff --git a/crates/venvlauncher/src/main.rs b/crates/venvlauncher/src/main.rs
new file mode 100644
index 0000000000..fe147ce7ff
--- /dev/null
+++ b/crates/venvlauncher/src/main.rs
@@ -0,0 +1,155 @@
+//! RustPython venv launcher
+//!
+//! A lightweight launcher that reads pyvenv.cfg and delegates execution
+//! to the actual Python interpreter. This mimics CPython's venvlauncher.c.
+//! Windows only.
+
+#[cfg(not(windows))]
+compile_error!("venvlauncher is only supported on Windows");
+
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    match run() {
+        Ok(code) => ExitCode::from(code as u8),
+        Err(e) => {
+            eprintln!("venvlauncher error: {}", e);
+            ExitCode::from(1)
+        }
+    }
+}
+
+fn run() -> Result<u32, Box<dyn core::error::Error>> {
+    // 1. Get own executable path
+    let exe_path = env::current_exe()?;
+    let exe_name = exe_path
+        .file_name()
+        .ok_or("Failed to get executable name")?
+        .to_string_lossy();
+
+    // 2. Determine target executable name based on launcher name
+    // pythonw.exe / venvwlauncher -> pythonw.exe (GUI, no console)
+    // python.exe / venvlauncher -> python.exe (console)
+    let exe_name_lower = exe_name.to_lowercase();
+    let target_exe = if exe_name_lower.contains("pythonw") || exe_name_lower.contains("venvw") {
+        "pythonw.exe"
+    } else {
+        "python.exe"
+    };
+
+    // 3. Find pyvenv.cfg
+    // The launcher is in Scripts/ directory, pyvenv.cfg is in parent (venv root)
+    let scripts_dir = exe_path.parent().ok_or("Failed to get Scripts directory")?;
+    let venv_dir = scripts_dir.parent().ok_or("Failed to get venv directory")?;
+    let cfg_path = venv_dir.join("pyvenv.cfg");
+
+    if !cfg_path.exists() {
+        return Err(format!("pyvenv.cfg not found: {}", cfg_path.display()).into());
+    }
+
+    // 4. Parse home= from pyvenv.cfg
+    let home = read_home(&cfg_path)?;
+
+    // 5. Locate python executable in home directory
+    let python_path = PathBuf::from(&home).join(target_exe);
+    if !python_path.exists() {
+        return Err(format!("Python not found: {}", python_path.display()).into());
+    }
+
+    // 6. Set __PYVENV_LAUNCHER__ environment variable
+    // This tells Python it was launched from a venv
+    // SAFETY: We are in a single-threaded context (program entry point)
+    unsafe {
+        env::set_var("__PYVENV_LAUNCHER__", &exe_path);
+    }
+
+    // 7. Launch Python with same arguments
+    let args: Vec<String> = env::args().skip(1).collect();
+    launch_process(&python_path, &args)
+}
+
+/// Parse the `home=` value from pyvenv.cfg
+fn read_home(cfg_path: &Path) -> Result<String, Box<dyn core::error::Error>> {
+    let content = fs::read_to_string(cfg_path)?;
+
+    for line in content.lines() {
+        let line = line.trim();
+        // Skip comments and empty lines
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+
+        // Look for "home = <path>" or "home=<path>"
+        if let Some(rest) = line.strip_prefix("home") {
+            let rest = rest.trim_start();
+            if let Some(value) = rest.strip_prefix('=') {
+                return Ok(value.trim().to_string());
+            }
+        }
+    }
+
+    Err("'home' key not found in pyvenv.cfg".into())
+}
+
+/// Launch the Python process and wait for it to complete
+fn launch_process(exe: &Path, args: &[String]) -> Result<u32, Box<dyn core::error::Error>> {
+    use std::process::Command;
+
+    let status = Command::new(exe).args(args).status()?;
+
+    Ok(status.code().unwrap_or(1) as u32)
+}
+
+#[cfg(all(test, windows))]
+mod tests {
+    use super::*;
+    use std::io::Write;
+
+    #[test]
+    fn test_read_home() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "home = C:\\Python313").unwrap();
+        writeln!(file, "include-system-site-packages = false").unwrap();
+        writeln!(file, "version = 3.13.0").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "C:\\Python313");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+
+    #[test]
+    fn test_read_home_no_spaces() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv2.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "home=C:\\Python313").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "C:\\Python313");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+
+    #[test]
+    fn test_read_home_with_comments() {
+        let temp_dir = std::env::temp_dir();
+        let cfg_path = temp_dir.join("test_pyvenv3.cfg");
+
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "# This is a comment").unwrap();
+        writeln!(file, "home = D:\\RustPython").unwrap();
+
+        let home = read_home(&cfg_path).unwrap();
+        assert_eq!(home, "D:\\RustPython");
+
+        fs::remove_file(&cfg_path).unwrap();
+    }
+}
diff --git a/crates/vm/Cargo.toml b/crates/vm/Cargo.toml
new file mode 100644
index 0000000000..b74aba4114
--- /dev/null
+++ b/crates/vm/Cargo.toml
@@ -0,0 +1,152 @@
+[package]
+name = "rustpython-vm"
+description = "RustPython virtual machine."
+include = ["src/**/*.rs", "Cargo.toml", "build.rs", "Lib/**/*.py"]
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[features]
+default = ["compiler", "wasmbind", "stdio"]
+stdio = []
+importlib = []
+encodings = ["importlib"]
+vm-tracing-logging = []
+flame-it = ["flame", "flamer"]
+freeze-stdlib = ["encodings"]
+jit = ["rustpython-jit"]
+threading = ["rustpython-common/threading"]
+compiler = ["parser", "codegen", "rustpython-compiler"]
+ast = ["ruff_python_ast", "ruff_text_size"]
+codegen = ["rustpython-codegen", "ast"]
+parser = ["ast"]
+serde = ["dep:serde"]
+wasmbind = ["rustpython-common/wasm_js", "chrono/wasmbind", "wasm-bindgen"]
+
+[dependencies]
+rustpython-compiler = { workspace = true, optional = true }
+rustpython-codegen = { workspace = true, optional = true }
+rustpython-common = { workspace = true }
+rustpython-derive = { workspace = true }
+rustpython-jit = { workspace = true, optional = true }
+
+ruff_python_ast = { workspace = true, optional = true }
+ruff_python_parser = { workspace = true }
+ruff_text_size = { workspace = true, optional = true }
+rustpython-compiler-core = { workspace = true }
+rustpython-literal = { workspace = true }
+rustpython-sre_engine = { workspace = true }
+
+ascii = { workspace = true }
+ahash = { workspace = true }
+bitflags = { workspace = true }
+bstr = { workspace = true }
+cfg-if = { workspace = true }
+crossbeam-utils = { workspace = true }
+chrono = { workspace = true }
+constant_time_eq = { workspace = true }
+flame = { workspace = true, optional = true }
+getrandom = { workspace = true }
+hex = { workspace = true }
+indexmap = { workspace = true }
+itertools = { workspace = true }
+is-macro = { workspace = true }
+libc = { workspace = true }
+log = { workspace = true }
+malachite-bigint = { workspace = true }
+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 }
+scopeguard = { workspace = true }
+serde = { workspace = true, optional = true }
+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"
+flamer = { version = "0.5", optional = true }
+half = "2"
+optional = { workspace = true }
+result-like = "0.5.0"
+timsort = "0.1.2"
+
+## unicode stuff
+# 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 }
+
+[target.'cfg(unix)'.dependencies]
+rustix = { workspace = true }
+nix = { workspace = true }
+exitcode = "1.1.2"
+uname = "0.1.1"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+rustyline = { workspace = true }
+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]
+libffi = { workspace = true, features = ["system"] }
+libloading = "0.9"
+
+[target.'cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))'.dependencies]
+num_cpus = "1.17.0"
+
+[target.'cfg(windows)'.dependencies]
+junction = { workspace = true }
+
+[target.'cfg(windows)'.dependencies.windows-sys]
+workspace = true
+features = [
+  "Win32_Foundation",
+  "Win32_Globalization",
+  "Win32_Networking_WinSock",
+  "Win32_Security",
+  "Win32_Security_Authorization",
+  "Win32_Storage_FileSystem",
+  "Win32_System_Console",
+  "Win32_System_Diagnostics_Debug",
+  "Win32_System_Environment",
+  "Win32_System_IO",
+  "Win32_System_Ioctl",
+  "Win32_System_Kernel",
+  "Win32_System_LibraryLoader",
+  "Win32_System_Memory",
+  "Win32_System_Performance",
+  "Win32_System_Pipes",
+  "Win32_System_Registry",
+  "Win32_System_SystemInformation",
+  "Win32_System_SystemServices",
+  "Win32_System_Threading",
+  "Win32_System_Time",
+  "Win32_System_WindowsProgramming",
+  "Win32_UI_Shell",
+  "Win32_UI_WindowsAndMessaging",
+]
+
+[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
+wasm-bindgen = { workspace = true, optional = true }
+
+[build-dependencies]
+glob = { workspace = true }
+itertools = { workspace = true }
+
+[lints]
+workspace = true
diff --git a/vm/Lib/README.md b/crates/vm/Lib/README.md
similarity index 100%
rename from vm/Lib/README.md
rename to crates/vm/Lib/README.md
diff --git a/crates/vm/Lib/core_modules/codecs.py b/crates/vm/Lib/core_modules/codecs.py
new file mode 120000
index 0000000000..4a96fdd182
--- /dev/null
+++ b/crates/vm/Lib/core_modules/codecs.py
@@ -0,0 +1 @@
+../../../../Lib/codecs.py
\ No newline at end of file
diff --git a/crates/vm/Lib/core_modules/copyreg.py b/crates/vm/Lib/core_modules/copyreg.py
new file mode 120000
index 0000000000..6f4f0d4d44
--- /dev/null
+++ b/crates/vm/Lib/core_modules/copyreg.py
@@ -0,0 +1 @@
+../../../../Lib/copyreg.py
\ No newline at end of file
diff --git a/crates/vm/Lib/core_modules/encodings_ascii.py b/crates/vm/Lib/core_modules/encodings_ascii.py
new file mode 120000
index 0000000000..c0507e75b0
--- /dev/null
+++ b/crates/vm/Lib/core_modules/encodings_ascii.py
@@ -0,0 +1 @@
+../../../../Lib/encodings/ascii.py
\ No newline at end of file
diff --git a/crates/vm/Lib/core_modules/encodings_utf_8.py b/crates/vm/Lib/core_modules/encodings_utf_8.py
new file mode 120000
index 0000000000..0a82f3b4a4
--- /dev/null
+++ b/crates/vm/Lib/core_modules/encodings_utf_8.py
@@ -0,0 +1 @@
+../../../../Lib/encodings/utf_8.py
\ No newline at end of file
diff --git a/crates/vm/Lib/python_builtins/__hello__.py b/crates/vm/Lib/python_builtins/__hello__.py
new file mode 120000
index 0000000000..e7dedd3d0a
--- /dev/null
+++ b/crates/vm/Lib/python_builtins/__hello__.py
@@ -0,0 +1 @@
+../../../../Lib/__hello__.py
\ No newline at end of file
diff --git a/crates/vm/Lib/python_builtins/__phello__ b/crates/vm/Lib/python_builtins/__phello__
new file mode 120000
index 0000000000..21833dd18d
--- /dev/null
+++ b/crates/vm/Lib/python_builtins/__phello__
@@ -0,0 +1 @@
+../../../../Lib/__phello__/
\ No newline at end of file
diff --git a/crates/vm/Lib/python_builtins/_frozen_importlib.py b/crates/vm/Lib/python_builtins/_frozen_importlib.py
new file mode 120000
index 0000000000..9d752e80de
--- /dev/null
+++ b/crates/vm/Lib/python_builtins/_frozen_importlib.py
@@ -0,0 +1 @@
+../../../../Lib/importlib/_bootstrap.py
\ No newline at end of file
diff --git a/crates/vm/Lib/python_builtins/_frozen_importlib_external.py b/crates/vm/Lib/python_builtins/_frozen_importlib_external.py
new file mode 120000
index 0000000000..a6b0151067
--- /dev/null
+++ b/crates/vm/Lib/python_builtins/_frozen_importlib_external.py
@@ -0,0 +1 @@
+../../../../Lib/importlib/_bootstrap_external.py
\ No newline at end of file
diff --git a/crates/vm/Lib/python_builtins/_thread.py b/crates/vm/Lib/python_builtins/_thread.py
new file mode 120000
index 0000000000..9079ca9fda
--- /dev/null
+++ b/crates/vm/Lib/python_builtins/_thread.py
@@ -0,0 +1 @@
+../../../../Lib/_dummy_thread.py
\ No newline at end of file
diff --git a/crates/vm/build.rs b/crates/vm/build.rs
new file mode 100644
index 0000000000..f76bf3f5cb
--- /dev/null
+++ b/crates/vm/build.rs
@@ -0,0 +1,74 @@
+use itertools::Itertools;
+use std::{env, io::prelude::*, path::PathBuf, process::Command};
+
+fn main() {
+    let frozen_libs = if cfg!(feature = "freeze-stdlib") {
+        "Lib/*/*.py"
+    } else {
+        "Lib/python_builtins/*.py"
+    };
+    for entry in glob::glob(frozen_libs).expect("Lib/ exists?").flatten() {
+        let display = entry.display();
+        println!("cargo:rerun-if-changed={display}");
+    }
+    println!("cargo:rerun-if-changed=../../Lib/importlib/_bootstrap.py");
+
+    println!("cargo:rustc-env=RUSTPYTHON_GIT_HASH={}", git_hash());
+    println!(
+        "cargo:rustc-env=RUSTPYTHON_GIT_TIMESTAMP={}",
+        git_timestamp()
+    );
+    println!("cargo:rustc-env=RUSTPYTHON_GIT_TAG={}", git_tag());
+    println!("cargo:rustc-env=RUSTPYTHON_GIT_BRANCH={}", git_branch());
+    println!("cargo:rustc-env=RUSTC_VERSION={}", rustc_version());
+
+    println!(
+        "cargo:rustc-env=RUSTPYTHON_TARGET_TRIPLE={}",
+        env::var("TARGET").unwrap()
+    );
+
+    let mut env_path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    env_path.push("env_vars.rs");
+    let mut f = std::fs::File::create(env_path).unwrap();
+    write!(
+        f,
+        "sysvars! {{ {} }}",
+        std::env::vars_os().format_with(", ", |(k, v), f| f(&format_args!("{k:?} => {v:?}")))
+    )
+    .unwrap();
+}
+
+fn git_hash() -> String {
+    git(&["rev-parse", "--short", "HEAD"])
+}
+
+fn git_timestamp() -> String {
+    git(&["log", "-1", "--format=%ct"])
+}
+
+fn git_tag() -> String {
+    git(&["describe", "--all", "--always", "--dirty"])
+}
+
+fn git_branch() -> String {
+    git(&["name-rev", "--name-only", "HEAD"])
+}
+
+fn git(args: &[&str]) -> String {
+    command("git", args)
+}
+
+fn rustc_version() -> String {
+    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    command(rustc, &["-V"])
+}
+
+fn command(cmd: impl AsRef<std::ffi::OsStr>, args: &[&str]) -> String {
+    match Command::new(cmd).args(args).output() {
+        Ok(output) => match String::from_utf8(output.stdout) {
+            Ok(s) => s,
+            Err(err) => format!("(output error: {err})"),
+        },
+        Err(err) => format!("(command error: {err})"),
+    }
+}
diff --git a/vm/src/anystr.rs b/crates/vm/src/anystr.rs
similarity index 93%
rename from vm/src/anystr.rs
rename to crates/vm/src/anystr.rs
index ef6d24c100..79b62a58ab 100644
--- a/vm/src/anystr.rs
+++ b/crates/vm/src/anystr.rs
@@ -6,6 +6,8 @@ use crate::{
 };
 use num_traits::{cast::ToPrimitive, sign::Signed};
 
+use core::ops::Range;
+
 #[derive(FromArgs)]
 pub struct SplitArgs<T: TryFromObject> {
     #[pyarg(any, default)]
@@ -43,7 +45,7 @@ pub struct StartsEndsWithArgs {
 }
 
 impl StartsEndsWithArgs {
-    pub fn get_value(self, len: usize) -> (PyObjectRef, Option<std::ops::Range<usize>>) {
+    pub fn get_value(self, len: usize) -> (PyObjectRef, Option<Range<usize>>) {
         let range = if self.start.is_some() || self.end.is_some() {
             Some(adjust_indices(self.start, self.end, len))
         } else {
@@ -56,7 +58,7 @@ impl StartsEndsWithArgs {
     pub fn prepare<S, F>(self, s: &S, len: usize, substr: F) -> Option<(PyObjectRef, &S)>
     where
         S: ?Sized + AnyStr,
-        F: Fn(&S, std::ops::Range<usize>) -> &S,
+        F: Fn(&S, Range<usize>) -> &S,
     {
         let (affix, range) = self.get_value(len);
         let substr = if let Some(range) = range {
@@ -83,11 +85,7 @@ fn saturate_to_isize(py_int: PyIntRef) -> isize {
 }
 
 // help get optional string indices
-pub fn adjust_indices(
-    start: Option<PyIntRef>,
-    end: Option<PyIntRef>,
-    len: usize,
-) -> std::ops::Range<usize> {
+pub fn adjust_indices(start: Option<PyIntRef>, end: Option<PyIntRef>, len: usize) -> Range<usize> {
     let mut start = start.map_or(0, saturate_to_isize);
     let mut end = end.map_or(len as isize, saturate_to_isize);
     if end > len as isize {
@@ -111,7 +109,7 @@ pub trait StringRange {
     fn is_normal(&self) -> bool;
 }
 
-impl StringRange for std::ops::Range<usize> {
+impl StringRange for Range<usize> {
     fn is_normal(&self) -> bool {
         self.start <= self.end
     }
@@ -144,9 +142,9 @@ pub trait AnyStr {
     fn to_container(&self) -> Self::Container;
     fn as_bytes(&self) -> &[u8];
     fn elements(&self) -> impl Iterator<Item = Self::Char>;
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self;
+    fn get_bytes(&self, range: Range<usize>) -> &Self;
     // FIXME: get_chars is expensive for str
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self;
+    fn get_chars(&self, range: Range<usize>) -> &Self;
     fn bytes_len(&self) -> usize;
     // NOTE: str::chars().count() consumes the O(n) time. But pystr::char_len does cache.
     //       So using chars_len directly is too expensive and the below method shouldn't be implemented.
@@ -254,7 +252,7 @@ pub trait AnyStr {
     }
 
     #[inline]
-    fn py_find<F>(&self, needle: &Self, range: std::ops::Range<usize>, find: F) -> Option<usize>
+    fn py_find<F>(&self, needle: &Self, range: Range<usize>, find: F) -> Option<usize>
     where
         F: Fn(&Self, &Self) -> Option<usize>,
     {
@@ -268,7 +266,7 @@ pub trait AnyStr {
     }
 
     #[inline]
-    fn py_count<F>(&self, needle: &Self, range: std::ops::Range<usize>, count: F) -> usize
+    fn py_count<F>(&self, needle: &Self, range: Range<usize>, count: F) -> usize
     where
         F: Fn(&Self, &Self) -> usize,
     {
@@ -283,9 +281,9 @@ pub trait AnyStr {
         let mut u = Self::Container::with_capacity(
             (left + right) * fillchar.bytes_len() + self.bytes_len(),
         );
-        u.extend(std::iter::repeat_n(fillchar, left));
+        u.extend(core::iter::repeat_n(fillchar, left));
         u.push_str(self);
-        u.extend(std::iter::repeat_n(fillchar, right));
+        u.extend(core::iter::repeat_n(fillchar, right));
         u
     }
 
@@ -305,7 +303,7 @@ pub trait AnyStr {
 
     fn py_join(
         &self,
-        mut iter: impl std::iter::Iterator<Item = PyResult<impl AnyStrWrapper<Self> + TryFromObject>>,
+        mut iter: impl core::iter::Iterator<Item = PyResult<impl AnyStrWrapper<Self> + TryFromObject>>,
     ) -> PyResult<Self::Container> {
         let mut joined = if let Some(elem) = iter.next() {
             elem?.as_ref().unwrap().to_container()
@@ -328,7 +326,7 @@ pub trait AnyStr {
     ) -> PyResult<(Self::Container, bool, Self::Container)>
     where
         F: Fn() -> S,
-        S: std::iter::Iterator<Item = &'a Self>,
+        S: core::iter::Iterator<Item = &'a Self>,
     {
         if sub.is_empty() {
             return Err(vm.new_value_error("empty separator"));
diff --git a/crates/vm/src/buffer.rs b/crates/vm/src/buffer.rs
new file mode 100644
index 0000000000..6cbddb7333
--- /dev/null
+++ b/crates/vm/src/buffer.rs
@@ -0,0 +1,729 @@
+use crate::{
+    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::{PyBaseExceptionRef, PyBytesRef, PyTuple, PyTupleRef, PyTypeRef},
+    common::{static_cell, str::wchar_t},
+    convert::ToPyObject,
+    function::{ArgBytesLike, ArgIntoBool, ArgIntoFloat},
+};
+use alloc::fmt;
+use core::{iter::Peekable, mem};
+use half::f16;
+use itertools::Itertools;
+use malachite_bigint::BigInt;
+use num_traits::{PrimInt, ToPrimitive};
+use std::os::raw;
+
+type PackFunc = fn(&VirtualMachine, PyObjectRef, &mut [u8]) -> PyResult<()>;
+type UnpackFunc = fn(&VirtualMachine, &[u8]) -> PyObjectRef;
+
+static OVERFLOW_MSG: &str = "total struct size too long"; // not a const to reduce code size
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub(crate) enum Endianness {
+    Native,
+    Little,
+    Big,
+    Host,
+}
+
+impl Endianness {
+    /// Parse endianness
+    /// See also: https://docs.python.org/3/library/struct.html?highlight=struct#byte-order-size-and-alignment
+    fn parse<I>(chars: &mut Peekable<I>) -> Self
+    where
+        I: Sized + Iterator<Item = u8>,
+    {
+        let e = match chars.peek() {
+            Some(b'@') => Self::Native,
+            Some(b'=') => Self::Host,
+            Some(b'<') => Self::Little,
+            Some(b'>') | Some(b'!') => Self::Big,
+            _ => return Self::Native,
+        };
+        chars.next().unwrap();
+        e
+    }
+}
+
+trait ByteOrder {
+    fn convert<I: PrimInt>(i: I) -> I;
+}
+enum BigEndian {}
+impl ByteOrder for BigEndian {
+    fn convert<I: PrimInt>(i: I) -> I {
+        i.to_be()
+    }
+}
+enum LittleEndian {}
+impl ByteOrder for LittleEndian {
+    fn convert<I: PrimInt>(i: I) -> I {
+        i.to_le()
+    }
+}
+
+#[cfg(target_endian = "big")]
+type NativeEndian = BigEndian;
+#[cfg(target_endian = "little")]
+type NativeEndian = LittleEndian;
+
+#[derive(Copy, Clone, num_enum::TryFromPrimitive)]
+#[repr(u8)]
+pub(crate) enum FormatType {
+    Pad = b'x',
+    SByte = b'b',
+    UByte = b'B',
+    Char = b'c',
+    WideChar = b'u',
+    Str = b's',
+    Pascal = b'p',
+    Short = b'h',
+    UShort = b'H',
+    Int = b'i',
+    UInt = b'I',
+    Long = b'l',
+    ULong = b'L',
+    SSizeT = b'n',
+    SizeT = b'N',
+    LongLong = b'q',
+    ULongLong = b'Q',
+    Bool = b'?',
+    Half = b'e',
+    Float = b'f',
+    Double = b'd',
+    LongDouble = b'g',
+    VoidP = b'P',
+    PyObject = b'O',
+}
+
+impl fmt::Debug for FormatType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&(*self as u8 as char), f)
+    }
+}
+
+impl FormatType {
+    fn info(self, e: Endianness) -> &'static FormatInfo {
+        use FormatType::*;
+        use mem::{align_of, size_of};
+        macro_rules! native_info {
+            ($t:ty) => {{
+                &FormatInfo {
+                    size: size_of::<$t>(),
+                    align: align_of::<$t>(),
+                    pack: Some(<$t as Packable>::pack::<NativeEndian>),
+                    unpack: Some(<$t as Packable>::unpack::<NativeEndian>),
+                }
+            }};
+        }
+        macro_rules! nonnative_info {
+            ($t:ty, $end:ty) => {{
+                &FormatInfo {
+                    size: size_of::<$t>(),
+                    align: 0,
+                    pack: Some(<$t as Packable>::pack::<$end>),
+                    unpack: Some(<$t as Packable>::unpack::<$end>),
+                }
+            }};
+        }
+        macro_rules! match_nonnative {
+            ($zelf:expr, $end:ty) => {{
+                match $zelf {
+                    Pad | Str | Pascal => &FormatInfo {
+                        size: size_of::<u8>(),
+                        align: 0,
+                        pack: None,
+                        unpack: None,
+                    },
+                    SByte => nonnative_info!(i8, $end),
+                    UByte => nonnative_info!(u8, $end),
+                    Char => &FormatInfo {
+                        size: size_of::<u8>(),
+                        align: 0,
+                        pack: Some(pack_char),
+                        unpack: Some(unpack_char),
+                    },
+                    Short => nonnative_info!(i16, $end),
+                    UShort => nonnative_info!(u16, $end),
+                    Int | Long => nonnative_info!(i32, $end),
+                    UInt | ULong => nonnative_info!(u32, $end),
+                    LongLong => nonnative_info!(i64, $end),
+                    ULongLong => nonnative_info!(u64, $end),
+                    Bool => nonnative_info!(bool, $end),
+                    Half => nonnative_info!(f16, $end),
+                    Float => nonnative_info!(f32, $end),
+                    Double => nonnative_info!(f64, $end),
+                    LongDouble => nonnative_info!(f64, $end), // long double same as double
+                    PyObject => nonnative_info!(usize, $end), // pointer size
+                    _ => unreachable!(),                      // size_t or void*
+                }
+            }};
+        }
+        match e {
+            Endianness::Native => match self {
+                Pad | Str | Pascal => &FormatInfo {
+                    size: size_of::<raw::c_char>(),
+                    align: 0,
+                    pack: None,
+                    unpack: None,
+                },
+                SByte => native_info!(raw::c_schar),
+                UByte => native_info!(raw::c_uchar),
+                Char => &FormatInfo {
+                    size: size_of::<raw::c_char>(),
+                    align: 0,
+                    pack: Some(pack_char),
+                    unpack: Some(unpack_char),
+                },
+                WideChar => native_info!(wchar_t),
+                Short => native_info!(raw::c_short),
+                UShort => native_info!(raw::c_ushort),
+                Int => native_info!(raw::c_int),
+                UInt => native_info!(raw::c_uint),
+                Long => native_info!(raw::c_long),
+                ULong => native_info!(raw::c_ulong),
+                SSizeT => native_info!(isize), // ssize_t == isize
+                SizeT => native_info!(usize),  //  size_t == usize
+                LongLong => native_info!(raw::c_longlong),
+                ULongLong => native_info!(raw::c_ulonglong),
+                Bool => native_info!(bool),
+                Half => native_info!(f16),
+                Float => native_info!(raw::c_float),
+                Double => native_info!(raw::c_double),
+                LongDouble => native_info!(raw::c_double), // long double same as double for now
+                VoidP => native_info!(*mut raw::c_void),
+                PyObject => native_info!(*mut raw::c_void), // pointer to PyObject
+            },
+            Endianness::Big => match_nonnative!(self, BigEndian),
+            Endianness::Little => match_nonnative!(self, LittleEndian),
+            Endianness::Host => match_nonnative!(self, NativeEndian),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct FormatCode {
+    pub repeat: usize,
+    pub code: FormatType,
+    pub info: &'static FormatInfo,
+    pub pre_padding: usize,
+}
+
+impl FormatCode {
+    pub const fn arg_count(&self) -> usize {
+        match self.code {
+            FormatType::Pad => 0,
+            FormatType::Str | FormatType::Pascal => 1,
+            _ => self.repeat,
+        }
+    }
+
+    pub fn parse<I>(
+        chars: &mut Peekable<I>,
+        endianness: Endianness,
+    ) -> Result<(Vec<Self>, usize, usize), String>
+    where
+        I: Sized + Iterator<Item = u8>,
+    {
+        let mut offset = 0isize;
+        let mut arg_count = 0usize;
+        let mut codes = vec![];
+        while chars.peek().is_some() {
+            // determine repeat operator:
+            let repeat = match chars.peek() {
+                Some(b'0'..=b'9') => {
+                    let mut repeat = 0isize;
+                    while let Some(b'0'..=b'9') = chars.peek() {
+                        if let Some(c) = chars.next() {
+                            let current_digit = c - b'0';
+                            repeat = repeat
+                                .checked_mul(10)
+                                .and_then(|r| r.checked_add(current_digit as _))
+                                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
+                        }
+                    }
+                    repeat
+                }
+                _ => 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,
+                None => {
+                    // If we have a repeat count but only whitespace follows, error
+                    if repeat != 1 {
+                        return Err("repeat count given without format specifier".to_owned());
+                    }
+                    // Otherwise, we're done parsing
+                    break;
+                }
+            };
+
+            // Check for embedded null character
+            if c == 0 {
+                return Err("embedded null character".to_owned());
+            }
+
+            // PEP3118: Handle extended format specifiers
+            // T{...} - struct, X{} - function pointer, (...) - array shape, :name: - field name
+            if c == b'T' || c == b'X' {
+                // Skip struct/function pointer: consume until matching '}'
+                if chars.peek() == Some(&b'{') {
+                    chars.next(); // consume '{'
+                    let mut depth = 1;
+                    while depth > 0 {
+                        match chars.next() {
+                            Some(b'{') => depth += 1,
+                            Some(b'}') => depth -= 1,
+                            None => return Err("unmatched '{' in format".to_owned()),
+                            _ => {}
+                        }
+                    }
+                    continue;
+                }
+            }
+
+            if c == b'(' {
+                // Skip array shape: consume until matching ')'
+                let mut depth = 1;
+                while depth > 0 {
+                    match chars.next() {
+                        Some(b'(') => depth += 1,
+                        Some(b')') => depth -= 1,
+                        None => return Err("unmatched '(' in format".to_owned()),
+                        _ => {}
+                    }
+                }
+                continue;
+            }
+
+            if c == b':' {
+                // Skip field name: consume until next ':'
+                loop {
+                    match chars.next() {
+                        Some(b':') => break,
+                        None => return Err("unmatched ':' in format".to_owned()),
+                        _ => {}
+                    }
+                }
+                continue;
+            }
+
+            if c == b'{'
+                || c == b'}'
+                || c == b'&'
+                || c == b'<'
+                || c == b'>'
+                || c == b'@'
+                || c == b'='
+                || c == b'!'
+            {
+                // Skip standalone braces (pointer targets, etc.), pointer prefix, and nested endianness markers
+                continue;
+            }
+
+            let code = FormatType::try_from(c)
+                .ok()
+                .filter(|c| match c {
+                    FormatType::SSizeT | FormatType::SizeT | FormatType::VoidP => {
+                        endianness == Endianness::Native
+                    }
+                    _ => true,
+                })
+                .ok_or_else(|| "bad char in struct format".to_owned())?;
+
+            let info = code.info(endianness);
+
+            let padding = compensate_alignment(offset as usize, info.align)
+                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
+            offset = padding
+                .to_isize()
+                .and_then(|extra| offset.checked_add(extra))
+                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
+
+            let code = Self {
+                repeat: repeat as usize,
+                code,
+                info,
+                pre_padding: padding,
+            };
+            arg_count += code.arg_count();
+            codes.push(code);
+
+            offset = (info.size as isize)
+                .checked_mul(repeat)
+                .and_then(|item_size| offset.checked_add(item_size))
+                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
+        }
+
+        Ok((codes, offset as usize, arg_count))
+    }
+}
+
+const fn compensate_alignment(offset: usize, align: usize) -> Option<usize> {
+    if align != 0 && offset != 0 {
+        // a % b == a & (b-1) if b is a power of 2
+        (align - 1).checked_sub((offset - 1) & (align - 1))
+    } else {
+        // alignment is already all good
+        Some(0)
+    }
+}
+
+pub(crate) struct FormatInfo {
+    pub size: usize,
+    pub align: usize,
+    pub pack: Option<PackFunc>,
+    pub unpack: Option<UnpackFunc>,
+}
+impl fmt::Debug for FormatInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FormatInfo")
+            .field("size", &self.size)
+            .field("align", &self.align)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FormatSpec {
+    #[allow(dead_code)]
+    pub(crate) endianness: Endianness,
+    pub(crate) codes: Vec<FormatCode>,
+    pub size: usize,
+    pub arg_count: usize,
+}
+
+impl FormatSpec {
+    pub fn parse(fmt: &[u8], vm: &VirtualMachine) -> PyResult<Self> {
+        let mut chars = fmt.iter().copied().peekable();
+
+        // First determine "@", "<", ">","!" or "="
+        let endianness = Endianness::parse(&mut chars);
+
+        // Now, analyze struct string further:
+        let (codes, size, arg_count) =
+            FormatCode::parse(&mut chars, endianness).map_err(|err| new_struct_error(vm, err))?;
+
+        Ok(Self {
+            endianness,
+            codes,
+            size,
+            arg_count,
+        })
+    }
+
+    pub fn pack(&self, args: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        // Create data vector:
+        let mut data = vec![0; self.size];
+
+        self.pack_into(&mut data, args, vm)?;
+
+        Ok(data)
+    }
+
+    pub fn pack_into(
+        &self,
+        mut buffer: &mut [u8],
+        args: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if self.arg_count != args.len() {
+            return Err(new_struct_error(
+                vm,
+                format!(
+                    "pack expected {} items for packing (got {})",
+                    self.codes.len(),
+                    args.len()
+                ),
+            ));
+        }
+
+        let mut args = args.into_iter();
+        // Loop over all opcodes:
+        for code in &self.codes {
+            buffer = &mut buffer[code.pre_padding..];
+            debug!("code: {code:?}");
+            match code.code {
+                FormatType::Str => {
+                    let (buf, rest) = buffer.split_at_mut(code.repeat);
+                    pack_string(vm, args.next().unwrap(), buf)?;
+                    buffer = rest;
+                }
+                FormatType::Pascal => {
+                    let (buf, rest) = buffer.split_at_mut(code.repeat);
+                    pack_pascal(vm, args.next().unwrap(), buf)?;
+                    buffer = rest;
+                }
+                FormatType::Pad => {
+                    let (pad_buf, rest) = buffer.split_at_mut(code.repeat);
+                    for el in pad_buf {
+                        *el = 0
+                    }
+                    buffer = rest;
+                }
+                _ => {
+                    let pack = code.info.pack.unwrap();
+                    for arg in args.by_ref().take(code.repeat) {
+                        let (item_buf, rest) = buffer.split_at_mut(code.info.size);
+                        pack(vm, arg, item_buf)?;
+                        buffer = rest;
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn unpack(&self, mut data: &[u8], vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        if self.size != data.len() {
+            return Err(new_struct_error(
+                vm,
+                format!("unpack requires a buffer of {} bytes", self.size),
+            ));
+        }
+
+        let mut items = Vec::with_capacity(self.arg_count);
+        for code in &self.codes {
+            data = &data[code.pre_padding..];
+            debug!("unpack code: {code:?}");
+            match code.code {
+                FormatType::Pad => {
+                    data = &data[code.repeat..];
+                }
+                FormatType::Str => {
+                    let (str_data, rest) = data.split_at(code.repeat);
+                    // string is just stored inline
+                    items.push(vm.ctx.new_bytes(str_data.to_vec()).into());
+                    data = rest;
+                }
+                FormatType::Pascal => {
+                    let (str_data, rest) = data.split_at(code.repeat);
+                    items.push(unpack_pascal(vm, str_data));
+                    data = rest;
+                }
+                _ => {
+                    let unpack = code.info.unpack.unwrap();
+                    for _ in 0..code.repeat {
+                        let (item_data, rest) = data.split_at(code.info.size);
+                        items.push(unpack(vm, item_data));
+                        data = rest;
+                    }
+                }
+            };
+        }
+
+        Ok(PyTuple::new_ref(items, &vm.ctx))
+    }
+
+    #[inline]
+    pub const fn size(&self) -> usize {
+        self.size
+    }
+}
+
+trait Packable {
+    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()>;
+    fn unpack<E: ByteOrder>(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef;
+}
+
+trait PackInt: PrimInt {
+    fn pack_int<E: ByteOrder>(self, data: &mut [u8]);
+    fn unpack_int<E: ByteOrder>(data: &[u8]) -> Self;
+}
+
+macro_rules! make_pack_prim_int {
+    ($T:ty) => {
+        impl PackInt for $T {
+            fn pack_int<E: ByteOrder>(self, data: &mut [u8]) {
+                let i = E::convert(self);
+                data.copy_from_slice(&i.to_ne_bytes());
+            }
+            #[inline]
+            fn unpack_int<E: ByteOrder>(data: &[u8]) -> Self {
+                let mut x = [0; core::mem::size_of::<$T>()];
+                x.copy_from_slice(data);
+                E::convert(<$T>::from_ne_bytes(x))
+            }
+        }
+
+        impl Packable for $T {
+            fn pack<E: ByteOrder>(
+                vm: &VirtualMachine,
+                arg: PyObjectRef,
+                data: &mut [u8],
+            ) -> PyResult<()> {
+                let i: $T = get_int_or_index(vm, arg)?;
+                i.pack_int::<E>(data);
+                Ok(())
+            }
+
+            fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
+                let i = <$T>::unpack_int::<E>(rdr);
+                vm.ctx.new_int(i).into()
+            }
+        }
+    };
+}
+
+fn get_int_or_index<T>(vm: &VirtualMachine, arg: PyObjectRef) -> PyResult<T>
+where
+    T: PrimInt + for<'a> TryFrom<&'a BigInt>,
+{
+    let index = arg
+        .try_index_opt(vm)
+        .unwrap_or_else(|| Err(new_struct_error(vm, "required argument is not an integer")))?;
+    index
+        .try_to_primitive(vm)
+        .map_err(|_| new_struct_error(vm, "argument out of range"))
+}
+
+make_pack_prim_int!(i8);
+make_pack_prim_int!(u8);
+make_pack_prim_int!(i16);
+make_pack_prim_int!(u16);
+make_pack_prim_int!(i32);
+make_pack_prim_int!(u32);
+make_pack_prim_int!(i64);
+make_pack_prim_int!(u64);
+make_pack_prim_int!(usize);
+make_pack_prim_int!(isize);
+
+macro_rules! make_pack_float {
+    ($T:ty) => {
+        impl Packable for $T {
+            fn pack<E: ByteOrder>(
+                vm: &VirtualMachine,
+                arg: PyObjectRef,
+                data: &mut [u8],
+            ) -> PyResult<()> {
+                let f = ArgIntoFloat::try_from_object(vm, arg)?.into_float() as $T;
+                f.to_bits().pack_int::<E>(data);
+                Ok(())
+            }
+
+            fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
+                let i = PackInt::unpack_int::<E>(rdr);
+                <$T>::from_bits(i).to_pyobject(vm)
+            }
+        }
+    };
+}
+
+make_pack_float!(f32);
+make_pack_float!(f64);
+
+impl Packable for f16 {
+    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
+        let f_64 = ArgIntoFloat::try_from_object(vm, arg)?.into_float();
+        // "from_f64 should be preferred in any non-`const` context" except it gives the wrong result :/
+        let f_16 = Self::from_f64_const(f_64);
+        if f_16.is_infinite() != f_64.is_infinite() {
+            return Err(vm.new_overflow_error("float too large to pack with e format"));
+        }
+        f_16.to_bits().pack_int::<E>(data);
+        Ok(())
+    }
+
+    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
+        let i = PackInt::unpack_int::<E>(rdr);
+        Self::from_bits(i).to_f64().to_pyobject(vm)
+    }
+}
+
+impl Packable for *mut raw::c_void {
+    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
+        usize::pack::<E>(vm, arg, data)
+    }
+
+    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
+        usize::unpack::<E>(vm, rdr)
+    }
+}
+
+impl Packable for bool {
+    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
+        let v = ArgIntoBool::try_from_object(vm, arg)?.into_bool() as u8;
+        v.pack_int::<E>(data);
+        Ok(())
+    }
+
+    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
+        let i = u8::unpack_int::<E>(rdr);
+        vm.ctx.new_bool(i != 0).into()
+    }
+}
+
+fn pack_char(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
+    let v = PyBytesRef::try_from_object(vm, arg)?;
+    let ch = *v
+        .as_bytes()
+        .iter()
+        .exactly_one()
+        .map_err(|_| new_struct_error(vm, "char format requires a bytes object of length 1"))?;
+    data[0] = ch;
+    Ok(())
+}
+
+fn pack_string(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResult<()> {
+    let b = ArgBytesLike::try_from_object(vm, arg)?;
+    b.with_ref(|data| write_string(buf, data));
+    Ok(())
+}
+
+fn pack_pascal(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResult<()> {
+    if buf.is_empty() {
+        return Ok(());
+    }
+    let b = ArgBytesLike::try_from_object(vm, arg)?;
+    b.with_ref(|data| {
+        let string_length = core::cmp::min(core::cmp::min(data.len(), 255), buf.len() - 1);
+        buf[0] = string_length as u8;
+        write_string(&mut buf[1..], data);
+    });
+    Ok(())
+}
+
+fn write_string(buf: &mut [u8], data: &[u8]) {
+    let len_from_data = core::cmp::min(data.len(), buf.len());
+    buf[..len_from_data].copy_from_slice(&data[..len_from_data]);
+    for byte in &mut buf[len_from_data..] {
+        *byte = 0
+    }
+}
+
+fn unpack_char(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef {
+    vm.ctx.new_bytes(vec![data[0]]).into()
+}
+
+fn unpack_pascal(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef {
+    let (&len, data) = match data.split_first() {
+        Some(x) => x,
+        None => {
+            // cpython throws an internal SystemError here
+            return vm.ctx.new_bytes(vec![]).into();
+        }
+    };
+    let len = core::cmp::min(len as usize, data.len());
+    vm.ctx.new_bytes(data[..len].to_vec()).into()
+}
+
+// XXX: are those functions expected to be placed here?
+pub fn struct_error_type(vm: &VirtualMachine) -> &'static PyTypeRef {
+    static_cell! {
+        static INSTANCE: PyTypeRef;
+    }
+    INSTANCE.get_or_init(|| vm.ctx.new_exception_type("struct", "error", None))
+}
+
+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
+    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
new file mode 100644
index 0000000000..891083f3e6
--- /dev/null
+++ b/crates/vm/src/builtins/asyncgenerator.rs
@@ -0,0 +1,665 @@
+use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
+use crate::{
+    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::PyBaseExceptionRef,
+    class::PyClassImpl,
+    common::lock::PyMutex,
+    coroutine::{Coro, warn_deprecated_throw_signature},
+    frame::FrameRef,
+    function::OptionalArg,
+    protocol::PyIterReturn,
+    types::{Destructor, IterNext, Iterable, Representable, SelfIter},
+};
+
+use crossbeam_utils::atomic::AtomicCell;
+
+#[pyclass(name = "async_generator", module = false)]
+#[derive(Debug)]
+pub struct PyAsyncGen {
+    inner: Coro,
+    running_async: AtomicCell<bool>,
+    // whether hooks have been initialized
+    ag_hooks_inited: AtomicCell<bool>,
+    // ag_origin_or_finalizer - stores the finalizer callback
+    ag_finalizer: PyMutex<Option<PyObjectRef>>,
+}
+type PyAsyncGenRef = PyRef<PyAsyncGen>;
+
+impl PyPayload for PyAsyncGen {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.async_generator
+    }
+}
+
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(PyRef, Representable, Destructor))]
+impl PyAsyncGen {
+    pub const fn as_coro(&self) -> &Coro {
+        &self.inner
+    }
+
+    pub fn new(frame: FrameRef, name: PyStrRef, qualname: PyStrRef) -> Self {
+        Self {
+            inner: Coro::new(frame, name, qualname),
+            running_async: AtomicCell::new(false),
+            ag_hooks_inited: AtomicCell::new(false),
+            ag_finalizer: PyMutex::new(None),
+        }
+    }
+
+    /// Initialize async generator hooks.
+    /// Returns Ok(()) if successful, Err if firstiter hook raised an exception.
+    fn init_hooks(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+        // = async_gen_init_hooks
+        if zelf.ag_hooks_inited.load() {
+            return Ok(());
+        }
+
+        zelf.ag_hooks_inited.store(true);
+
+        // Get and store finalizer from VM
+        let finalizer = vm.async_gen_finalizer.borrow().clone();
+        if let Some(finalizer) = finalizer {
+            *zelf.ag_finalizer.lock() = Some(finalizer);
+        }
+
+        // Call firstiter hook
+        let firstiter = vm.async_gen_firstiter.borrow().clone();
+        if let Some(firstiter) = firstiter {
+            let obj: PyObjectRef = zelf.to_owned().into();
+            firstiter.call((obj,), vm)?;
+        }
+
+        Ok(())
+    }
+
+    /// Call finalizer hook if set.
+    fn call_finalizer(zelf: &Py<Self>, vm: &VirtualMachine) {
+        let finalizer = zelf.ag_finalizer.lock().clone();
+        if let Some(finalizer) = finalizer
+            && !zelf.inner.closed.load()
+        {
+            // Ignore any errors (PyErr_WriteUnraisable)
+            let obj: PyObjectRef = zelf.to_owned().into();
+            let _ = finalizer.call((obj,), vm);
+        }
+    }
+
+    #[pygetset]
+    fn __name__(&self) -> PyStrRef {
+        self.inner.name()
+    }
+
+    #[pygetset(setter)]
+    fn set___name__(&self, name: PyStrRef) {
+        self.inner.set_name(name)
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> PyStrRef {
+        self.inner.qualname()
+    }
+
+    #[pygetset(setter)]
+    fn set___qualname__(&self, qualname: PyStrRef) {
+        self.inner.set_qualname(qualname)
+    }
+
+    #[pygetset]
+    fn ag_await(&self, _vm: &VirtualMachine) -> Option<PyObjectRef> {
+        self.inner.frame().yield_from_target()
+    }
+    #[pygetset]
+    fn ag_frame(&self, _vm: &VirtualMachine) -> FrameRef {
+        self.inner.frame()
+    }
+    #[pygetset]
+    fn ag_running(&self, _vm: &VirtualMachine) -> bool {
+        self.inner.running()
+    }
+    #[pygetset]
+    fn ag_code(&self, _vm: &VirtualMachine) -> PyRef<PyCode> {
+        self.inner.frame().code.clone()
+    }
+
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+}
+
+#[pyclass]
+impl PyRef<PyAsyncGen> {
+    #[pymethod]
+    const fn __aiter__(self, _vm: &VirtualMachine) -> Self {
+        self
+    }
+
+    #[pymethod]
+    fn __anext__(self, vm: &VirtualMachine) -> PyResult<PyAsyncGenASend> {
+        PyAsyncGen::init_hooks(&self, vm)?;
+        Ok(PyAsyncGenASend {
+            ag: self,
+            state: AtomicCell::new(AwaitableState::Init),
+            value: vm.ctx.none(),
+        })
+    }
+
+    #[pymethod]
+    fn asend(self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyAsyncGenASend> {
+        PyAsyncGen::init_hooks(&self, vm)?;
+        Ok(PyAsyncGenASend {
+            ag: self,
+            state: AtomicCell::new(AwaitableState::Init),
+            value,
+        })
+    }
+
+    #[pymethod]
+    fn athrow(
+        self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        exc_tb: OptionalArg,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyAsyncGenAThrow> {
+        PyAsyncGen::init_hooks(&self, vm)?;
+        Ok(PyAsyncGenAThrow {
+            ag: self,
+            aclose: false,
+            state: AtomicCell::new(AwaitableState::Init),
+            value: (
+                exc_type,
+                exc_val.unwrap_or_none(vm),
+                exc_tb.unwrap_or_none(vm),
+            ),
+        })
+    }
+
+    #[pymethod]
+    fn aclose(self, vm: &VirtualMachine) -> PyResult<PyAsyncGenAThrow> {
+        PyAsyncGen::init_hooks(&self, vm)?;
+        Ok(PyAsyncGenAThrow {
+            ag: self,
+            aclose: true,
+            state: AtomicCell::new(AwaitableState::Init),
+            value: (
+                vm.ctx.exceptions.generator_exit.to_owned().into(),
+                vm.ctx.none(),
+                vm.ctx.none(),
+            ),
+        })
+    }
+}
+
+impl Representable for PyAsyncGen {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
+    }
+}
+
+#[pyclass(module = false, name = "async_generator_wrapped_value")]
+#[derive(Debug)]
+pub(crate) struct PyAsyncGenWrappedValue(pub PyObjectRef);
+impl PyPayload for PyAsyncGenWrappedValue {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.async_generator_wrapped_value
+    }
+}
+
+#[pyclass]
+impl PyAsyncGenWrappedValue {}
+
+impl PyAsyncGenWrappedValue {
+    fn unbox(ag: &PyAsyncGen, val: PyResult<PyIterReturn>, vm: &VirtualMachine) -> PyResult {
+        let (closed, async_done) = match &val {
+            Ok(PyIterReturn::StopIteration(_)) => (true, true),
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.generator_exit) => (true, true),
+            Err(_) => (false, true),
+            _ => (false, false),
+        };
+        if closed {
+            ag.inner.closed.store(true);
+        }
+        if async_done {
+            ag.running_async.store(false);
+        }
+        let val = val?.into_async_pyresult(vm)?;
+        match_class!(match val {
+            val @ Self => {
+                ag.running_async.store(false);
+                Err(vm.new_stop_iteration(Some(val.0.clone())))
+            }
+            val => Ok(val),
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+enum AwaitableState {
+    Init,
+    Iter,
+    Closed,
+}
+
+#[pyclass(module = false, name = "async_generator_asend")]
+#[derive(Debug)]
+pub(crate) struct PyAsyncGenASend {
+    ag: PyAsyncGenRef,
+    state: AtomicCell<AwaitableState>,
+    value: PyObjectRef,
+}
+
+impl PyPayload for PyAsyncGenASend {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.async_generator_asend
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyAsyncGenASend {
+    #[pymethod(name = "__await__")]
+    const fn r#await(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
+    }
+
+    #[pymethod]
+    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let val = match self.state.load() {
+            AwaitableState::Closed => {
+                return Err(
+                    vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()")
+                );
+            }
+            AwaitableState::Iter => val, // already running, all good
+            AwaitableState::Init => {
+                if self.ag.running_async.load() {
+                    return Err(
+                        vm.new_runtime_error("anext(): asynchronous generator is already running")
+                    );
+                }
+                self.ag.running_async.store(true);
+                self.state.store(AwaitableState::Iter);
+                if vm.is_none(&val) {
+                    self.value.clone()
+                } else {
+                    val
+                }
+            }
+        };
+        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();
+        }
+        res
+    }
+
+    #[pymethod]
+    fn throw(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        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()"));
+        }
+
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
+        let res = self.ag.inner.throw(
+            self.ag.as_object(),
+            exc_type,
+            exc_val.unwrap_or_none(vm),
+            exc_tb.unwrap_or_none(vm),
+            vm,
+        );
+        let res = PyAsyncGenWrappedValue::unbox(&self.ag, res, vm);
+        if res.is_err() {
+            self.close();
+        }
+        res
+    }
+
+    #[pymethod]
+    fn close(&self) {
+        self.state.store(AwaitableState::Closed);
+    }
+}
+
+impl SelfIter for PyAsyncGenASend {}
+impl IterNext for PyAsyncGenASend {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
+    }
+}
+
+#[pyclass(module = false, name = "async_generator_athrow")]
+#[derive(Debug)]
+pub(crate) struct PyAsyncGenAThrow {
+    ag: PyAsyncGenRef,
+    aclose: bool,
+    state: AtomicCell<AwaitableState>,
+    value: (PyObjectRef, PyObjectRef, PyObjectRef),
+}
+
+impl PyPayload for PyAsyncGenAThrow {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.async_generator_athrow
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyAsyncGenAThrow {
+    #[pymethod(name = "__await__")]
+    const fn r#await(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
+    }
+
+    #[pymethod]
+    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        match self.state.load() {
+            AwaitableState::Closed => {
+                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));
+                }
+                if !vm.is_none(&val) {
+                    return Err(vm.new_runtime_error(
+                        "can't send non-None value to a just-started async generator",
+                    ));
+                }
+                self.state.store(AwaitableState::Iter);
+                self.ag.running_async.store(true);
+
+                let (ty, val, tb) = self.value.clone();
+                let ret = self.ag.inner.throw(self.ag.as_object(), ty, val, tb, vm);
+                let ret = if self.aclose {
+                    if self.ignored_close(&ret) {
+                        Err(self.yield_close(vm))
+                    } else {
+                        ret.and_then(|o| o.into_async_pyresult(vm))
+                    }
+                } else {
+                    PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
+                };
+                ret.map_err(|e| self.check_error(e, vm))
+            }
+            AwaitableState::Iter => {
+                let ret = self.ag.inner.send(self.ag.as_object(), val, vm);
+                if self.aclose {
+                    match ret {
+                        Ok(PyIterReturn::Return(v))
+                            if v.downcastable::<PyAsyncGenWrappedValue>() =>
+                        {
+                            Err(self.yield_close(vm))
+                        }
+                        other => other
+                            .and_then(|o| o.into_async_pyresult(vm))
+                            .map_err(|e| self.check_error(e, vm)),
+                    }
+                } else {
+                    PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
+                }
+            }
+        }
+    }
+
+    #[pymethod]
+    fn throw(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        exc_tb: OptionalArg,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
+        let ret = self.ag.inner.throw(
+            self.ag.as_object(),
+            exc_type,
+            exc_val.unwrap_or_none(vm),
+            exc_tb.unwrap_or_none(vm),
+            vm,
+        );
+        let res = if self.aclose {
+            if self.ignored_close(&ret) {
+                Err(self.yield_close(vm))
+            } else {
+                ret.and_then(|o| o.into_async_pyresult(vm))
+            }
+        } else {
+            PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
+        };
+        res.map_err(|e| self.check_error(e, vm))
+    }
+
+    #[pymethod]
+    fn close(&self) {
+        self.state.store(AwaitableState::Closed);
+    }
+
+    fn ignored_close(&self, res: &PyResult<PyIterReturn>) -> bool {
+        res.as_ref().is_ok_and(|v| match v {
+            PyIterReturn::Return(obj) => obj.downcastable::<PyAsyncGenWrappedValue>(),
+            PyIterReturn::StopIteration(_) => false,
+        })
+    }
+    fn yield_close(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        self.ag.running_async.store(false);
+        self.state.store(AwaitableState::Closed);
+        vm.new_runtime_error("async generator ignored GeneratorExit")
+    }
+    fn check_error(&self, exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        self.ag.running_async.store(false);
+        self.state.store(AwaitableState::Closed);
+        if self.aclose
+            && (exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
+                || exc.fast_isinstance(vm.ctx.exceptions.generator_exit))
+        {
+            vm.new_stop_iteration(None)
+        } else {
+            exc
+        }
+    }
+}
+
+impl SelfIter for PyAsyncGenAThrow {}
+impl IterNext for PyAsyncGenAThrow {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
+    }
+}
+
+/// Awaitable wrapper for anext() builtin with default value.
+/// When StopAsyncIteration is raised, it converts it to StopIteration(default).
+#[pyclass(module = false, name = "anext_awaitable")]
+#[derive(Debug)]
+pub struct PyAnextAwaitable {
+    wrapped: PyObjectRef,
+    default_value: PyObjectRef,
+    state: AtomicCell<AwaitableState>,
+}
+
+impl PyPayload for PyAnextAwaitable {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.anext_awaitable
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyAnextAwaitable {
+    pub fn new(wrapped: PyObjectRef, default_value: PyObjectRef) -> Self {
+        Self {
+            wrapped,
+            default_value,
+            state: AtomicCell::new(AwaitableState::Init),
+        }
+    }
+
+    #[pymethod(name = "__await__")]
+    fn r#await(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        zelf
+    }
+
+    fn check_closed(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if let AwaitableState::Closed = self.state.load() {
+            return Err(vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()"));
+        }
+        Ok(())
+    }
+
+    /// Get the awaitable iterator from wrapped object.
+    // = anextawaitable_getiter.
+    fn get_awaitable_iter(&self, vm: &VirtualMachine) -> PyResult {
+        use crate::builtins::PyCoroutine;
+        use crate::protocol::PyIter;
+
+        let wrapped = &self.wrapped;
+
+        // If wrapped is already an async_generator_asend, it's an iterator
+        if wrapped.class().is(vm.ctx.types.async_generator_asend)
+            || wrapped.class().is(vm.ctx.types.async_generator_athrow)
+        {
+            return Ok(wrapped.clone());
+        }
+
+        // _PyCoro_GetAwaitableIter equivalent
+        let awaitable = if wrapped.class().is(vm.ctx.types.coroutine_type) {
+            // Coroutine - get __await__ later
+            wrapped.clone()
+        } 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",
+                    wrapped.class().name()
+                )));
+            }
+        };
+
+        // If awaitable is a coroutine, get its __await__
+        if awaitable.class().is(vm.ctx.types.coroutine_type) {
+            let coro_await = vm.call_method(&awaitable, "__await__", ())?;
+            // Check that __await__ returned an iterator
+            if !PyIter::check(&coro_await) {
+                return Err(vm.new_type_error("__await__ returned a non-iterable"));
+            }
+            return Ok(coro_await);
+        }
+
+        // Check the result is an iterator, not a coroutine
+        if awaitable.downcast_ref::<PyCoroutine>().is_some() {
+            return Err(vm.new_type_error("__await__() returned a coroutine"));
+        }
+
+        // Check that the result is an iterator
+        if !PyIter::check(&awaitable) {
+            return Err(vm.new_type_error(format!(
+                "__await__() returned non-iterator of type '{}'",
+                awaitable.class().name()
+            )));
+        }
+
+        Ok(awaitable)
+    }
+
+    #[pymethod]
+    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        self.check_closed(vm)?;
+        self.state.store(AwaitableState::Iter);
+        let awaitable = self.get_awaitable_iter(vm)?;
+        let result = vm.call_method(&awaitable, "send", (val,));
+        self.handle_result(result, vm)
+    }
+
+    #[pymethod]
+    fn throw(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        exc_tb: OptionalArg,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        self.check_closed(vm)?;
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
+        self.state.store(AwaitableState::Iter);
+        let awaitable = self.get_awaitable_iter(vm)?;
+        let result = vm.call_method(
+            &awaitable,
+            "throw",
+            (
+                exc_type,
+                exc_val.unwrap_or_none(vm),
+                exc_tb.unwrap_or_none(vm),
+            ),
+        );
+        self.handle_result(result, vm)
+    }
+
+    #[pymethod]
+    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+        self.state.store(AwaitableState::Closed);
+        if let Ok(awaitable) = self.get_awaitable_iter(vm) {
+            let _ = vm.call_method(&awaitable, "close", ());
+        }
+        Ok(())
+    }
+
+    /// Convert StopAsyncIteration to StopIteration(default_value)
+    fn handle_result(&self, result: PyResult, vm: &VirtualMachine) -> PyResult {
+        match result {
+            Ok(value) => Ok(value),
+            Err(exc) if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) => {
+                Err(vm.new_stop_iteration(Some(self.default_value.clone())))
+            }
+            Err(exc) => Err(exc),
+        }
+    }
+}
+
+impl SelfIter for PyAnextAwaitable {}
+impl IterNext for PyAnextAwaitable {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
+    }
+}
+
+/// _PyGen_Finalize for async generators
+impl Destructor for PyAsyncGen {
+    fn del(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
+        // Generator isn't paused, so no need to close
+        if zelf.inner.closed.load() {
+            return Ok(());
+        }
+
+        Self::call_finalizer(zelf, vm);
+        Ok(())
+    }
+}
+
+pub fn init(ctx: &Context) {
+    PyAsyncGen::extend_class(ctx, ctx.types.async_generator);
+    PyAsyncGenASend::extend_class(ctx, ctx.types.async_generator_asend);
+    PyAsyncGenAThrow::extend_class(ctx, ctx.types.async_generator_athrow);
+    PyAnextAwaitable::extend_class(ctx, ctx.types.anext_awaitable);
+}
diff --git a/crates/vm/src/builtins/bool.rs b/crates/vm/src/builtins/bool.rs
new file mode 100644
index 0000000000..24ded08ab1
--- /dev/null
+++ b/crates/vm/src/builtins/bool.rs
@@ -0,0 +1,205 @@
+use super::{PyInt, PyStrRef, PyType, PyTypeRef};
+use crate::common::format::FormatSpec;
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
+    class::PyClassImpl,
+    convert::{IntoPyException, ToPyObject, ToPyResult},
+    function::{FuncArgs, OptionalArg},
+    protocol::PyNumberMethods,
+    types::{AsNumber, Constructor, Representable},
+};
+use core::fmt::{Debug, Formatter};
+use num_traits::Zero;
+
+impl ToPyObject for bool {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_bool(self).into()
+    }
+}
+
+impl<'a> TryFromBorrowedObject<'a> for bool {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+        // Python takes integers as a legit bool value
+        match obj.downcast_ref::<PyInt>() {
+            Some(int_obj) => {
+                let int_val = int_obj.as_bigint();
+                Ok(!int_val.is_zero())
+            }
+            None => {
+                Err(vm.new_type_error(format!("Expected type bool, not {}", obj.class().name())))
+            }
+        }
+    }
+}
+
+impl PyObjectRef {
+    /// Convert Python bool into Rust bool.
+    pub fn try_to_bool(self, vm: &VirtualMachine) -> PyResult<bool> {
+        if self.is(&vm.ctx.true_value) {
+            return Ok(true);
+        }
+        if self.is(&vm.ctx.false_value) {
+            return Ok(false);
+        }
+
+        let slots = &self.class().slots;
+
+        // 1. Try nb_bool slot first
+        if let Some(nb_bool) = slots.as_number.boolean.load() {
+            return nb_bool(self.as_object().number(), vm);
+        }
+
+        // 2. Try mp_length slot (mapping protocol)
+        if let Some(mp_length) = slots.as_mapping.length.load() {
+            let len = mp_length(self.as_object().mapping_unchecked(), vm)?;
+            return Ok(len != 0);
+        }
+
+        // 3. Try sq_length slot (sequence protocol)
+        if let Some(sq_length) = slots.as_sequence.length.load() {
+            let len = sq_length(self.as_object().sequence_unchecked(), vm)?;
+            return Ok(len != 0);
+        }
+
+        // 4. Default: objects without __bool__ or __len__ are truthy
+        Ok(true)
+    }
+}
+
+#[pyclass(name = "bool", module = false, base = PyInt, ctx = "bool_type")]
+#[repr(transparent)]
+pub struct PyBool(pub PyInt);
+
+impl Debug for PyBool {
+    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
+        let value = !self.0.as_bigint().is_zero();
+        write!(f, "PyBool({})", value)
+    }
+}
+
+impl Constructor for PyBool {
+    type Args = OptionalArg<PyObjectRef>;
+
+    fn slot_new(zelf: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let x: Self::Args = args.bind(vm)?;
+        if !zelf.fast_isinstance(vm.ctx.types.type_type) {
+            let actual_class = zelf.class();
+            let actual_type = &actual_class.name();
+            return Err(vm.new_type_error(format!(
+                "requires a 'type' object but received a '{actual_type}'"
+            )));
+        }
+        let val = x.map_or(Ok(false), |val| val.try_to_bool(vm))?;
+        Ok(vm.ctx.new_bool(val).into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+#[pyclass(with(Constructor, AsNumber, Representable), flags(_MATCH_SELF))]
+impl PyBool {
+    #[pymethod]
+    fn __format__(obj: PyObjectRef, spec: PyStrRef, 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))
+            .map_err(|err| err.into_pyexception(vm))
+    }
+}
+
+impl PyBool {
+    pub(crate) fn __or__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        if lhs.fast_isinstance(vm.ctx.types.bool_type)
+            && rhs.fast_isinstance(vm.ctx.types.bool_type)
+        {
+            let lhs = get_value(&lhs);
+            let rhs = get_value(&rhs);
+            (lhs || rhs).to_pyobject(vm)
+        } else if let Some(lhs) = lhs.downcast_ref::<PyInt>() {
+            lhs.__or__(rhs).to_pyobject(vm)
+        } else {
+            vm.ctx.not_implemented()
+        }
+    }
+
+    pub(crate) fn __and__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        if lhs.fast_isinstance(vm.ctx.types.bool_type)
+            && rhs.fast_isinstance(vm.ctx.types.bool_type)
+        {
+            let lhs = get_value(&lhs);
+            let rhs = get_value(&rhs);
+            (lhs && rhs).to_pyobject(vm)
+        } else if let Some(lhs) = lhs.downcast_ref::<PyInt>() {
+            lhs.__and__(rhs).to_pyobject(vm)
+        } else {
+            vm.ctx.not_implemented()
+        }
+    }
+
+    pub(crate) fn __xor__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        if lhs.fast_isinstance(vm.ctx.types.bool_type)
+            && rhs.fast_isinstance(vm.ctx.types.bool_type)
+        {
+            let lhs = get_value(&lhs);
+            let rhs = get_value(&rhs);
+            (lhs ^ rhs).to_pyobject(vm)
+        } else if let Some(lhs) = lhs.downcast_ref::<PyInt>() {
+            lhs.__xor__(rhs).to_pyobject(vm)
+        } else {
+            vm.ctx.not_implemented()
+        }
+    }
+}
+
+impl AsNumber for PyBool {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            and: Some(|a, b, vm| PyBool::__and__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            xor: Some(|a, b, vm| PyBool::__xor__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            or: Some(|a, b, vm| PyBool::__or__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            ..PyInt::AS_NUMBER
+        };
+        &AS_NUMBER
+    }
+}
+
+impl Representable for PyBool {
+    #[inline]
+    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let name = if get_value(zelf.as_object()) {
+            vm.ctx.names.True
+        } else {
+            vm.ctx.names.False
+        };
+        Ok(name.to_owned())
+    }
+
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use slot_repr instead")
+    }
+}
+
+pub(crate) fn init(context: &Context) {
+    PyBool::extend_class(context, context.types.bool_type);
+}
+
+// pub fn not(vm: &VirtualMachine, obj: &PyObject) -> PyResult<bool> {
+//     if obj.fast_isinstance(vm.ctx.types.bool_type) {
+//         let value = get_value(obj);
+//         Ok(!value)
+//     } else {
+//         Err(vm.new_type_error(format!("Can only invert a bool, on {:?}", obj)))
+//     }
+// }
+
+// Retrieve inner int value:
+pub(crate) fn get_value(obj: &PyObject) -> bool {
+    !obj.downcast_ref::<PyBool>()
+        .unwrap()
+        .0
+        .as_bigint()
+        .is_zero()
+}
diff --git a/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
similarity index 89%
rename from vm/src/builtins/builtin_func.rs
rename to crates/vm/src/builtins/builtin_func.rs
index 51729b4ce6..422f922df9 100644
--- a/vm/src/builtins/builtin_func.rs
+++ b/crates/vm/src/builtins/builtin_func.rs
@@ -2,11 +2,12 @@ use super::{PyStrInterned, PyStrRef, PyType, type_};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
+    common::wtf8::Wtf8,
     convert::TryFromObject,
     function::{FuncArgs, PyComparisonValue, PyMethodDef, PyMethodFlags, PyNativeFn},
-    types::{Callable, Comparable, PyComparisonOp, Representable, Unconstructible},
+    types::{Callable, Comparable, PyComparisonOp, Representable},
 };
-use std::fmt;
+use alloc::fmt;
 
 // PyCFunctionObject in CPython
 #[pyclass(name = "builtin_function_or_method", module = false)]
@@ -27,7 +28,7 @@ impl fmt::Debug for PyNativeFunction {
         write!(
             f,
             "builtin function {}.{} ({:?}) self as instance of {:?}",
-            self.module.map_or("<unknown>", |m| m.as_str()),
+            self.module.map_or(Wtf8::new("<unknown>"), |m| m.as_wtf8()),
             self.value.name,
             self.value.flags,
             self.zelf.as_ref().map(|z| z.class().name().to_owned())
@@ -50,11 +51,11 @@ impl PyNativeFunction {
     }
 
     // PyCFunction_GET_SELF
-    pub const fn get_self(&self) -> Option<&PyObjectRef> {
+    pub fn get_self(&self) -> Option<&PyObject> {
         if self.value.flags.contains(PyMethodFlags::STATIC) {
             return None;
         }
-        self.zelf.as_ref()
+        self.zelf.as_deref()
     }
 
     pub const fn as_func(&self) -> &'static dyn PyNativeFn {
@@ -73,7 +74,7 @@ impl Callable for PyNativeFunction {
     }
 }
 
-#[pyclass(with(Callable, Unconstructible), flags(HAS_DICT))]
+#[pyclass(with(Callable), flags(HAS_DICT, DISALLOW_INSTANTIATION))]
 impl PyNativeFunction {
     #[pygetset]
     fn __module__(zelf: NativeFunctionOrMethod) -> Option<&'static PyStrInterned> {
@@ -113,7 +114,7 @@ impl PyNativeFunction {
         zelf.0.value.doc
     }
 
-    #[pygetset(name = "__self__")]
+    #[pygetset]
     fn __self__(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         vm.ctx.none()
     }
@@ -144,18 +145,16 @@ impl Representable for PyNativeFunction {
     }
 }
 
-impl Unconstructible for PyNativeFunction {}
-
 // `PyCMethodObject` in CPython
-#[pyclass(name = "builtin_method", module = false, base = "PyNativeFunction")]
+#[pyclass(name = "builtin_method", module = false, base = PyNativeFunction, ctx = "builtin_method_type")]
 pub struct PyNativeMethod {
     pub(crate) func: PyNativeFunction,
     pub(crate) class: &'static Py<PyType>, // TODO: the actual life is &'self
 }
 
 #[pyclass(
-    with(Unconstructible, Callable, Comparable, Representable),
-    flags(HAS_DICT)
+    with(Callable, Comparable, Representable),
+    flags(HAS_DICT, DISALLOW_INSTANTIATION)
 )]
 impl PyNativeMethod {
     #[pygetset]
@@ -182,18 +181,12 @@ impl PyNativeMethod {
         Ok((getattr, (target, name)))
     }
 
-    #[pygetset(name = "__self__")]
+    #[pygetset]
     fn __self__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> Option<PyObjectRef> {
         zelf.func.zelf.clone()
     }
 }
 
-impl PyPayload for PyNativeMethod {
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.builtin_method_type
-    }
-}
-
 impl fmt::Debug for PyNativeMethod {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
@@ -213,13 +206,13 @@ impl Comparable for PyNativeMethod {
         _vm: &VirtualMachine,
     ) -> PyResult<PyComparisonValue> {
         op.eq_only(|| {
-            if let Some(other) = other.payload::<Self>() {
+            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 && std::ptr::eq(zelf.func.value, other.func.value);
+                let eq = eq && core::ptr::eq(zelf.func.value, other.func.value);
                 Ok(eq.into())
             } else {
                 Ok(PyComparisonValue::NotImplemented)
@@ -251,8 +244,6 @@ impl Representable for PyNativeMethod {
     }
 }
 
-impl Unconstructible for PyNativeMethod {}
-
 pub fn init(context: &Context) {
     PyNativeFunction::extend_class(context, context.types.builtin_function_or_method_type);
     PyNativeMethod::extend_class(context, context.types.builtin_method_type);
diff --git a/vm/src/builtins/bytearray.rs b/crates/vm/src/builtins/bytearray.rs
similarity index 96%
rename from vm/src/builtins/bytearray.rs
rename to crates/vm/src/builtins/bytearray.rs
index ce48b2bd7c..0f9dce7230 100644
--- a/vm/src/builtins/bytearray.rs
+++ b/crates/vm/src/builtins/bytearray.rs
@@ -33,11 +33,11 @@ use crate::{
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor,
         DefaultConstructor, Initializer, IterNext, Iterable, PyComparisonOp, Representable,
-        SelfIter, Unconstructible,
+        SelfIter,
     },
 };
 use bstr::ByteSlice;
-use std::mem::size_of;
+use core::mem::size_of;
 
 #[pyclass(module = false, name = "bytearray", unhashable = true)]
 #[derive(Debug, Default)]
@@ -73,8 +73,9 @@ pub(crate) fn init(context: &Context) {
 }
 
 impl PyByteArray {
+    #[deprecated(note = "use PyByteArray::from(...).into_ref() instead")]
     pub fn new_ref(data: Vec<u8>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(data), ctx.types.bytearray_type.to_owned(), None)
+        Self::from(data).into_ref(ctx)
     }
 
     const fn from_inner(inner: PyBytesInner) -> Self {
@@ -169,7 +170,7 @@ impl PyByteArray {
 }
 
 #[pyclass(
-    flags(BASETYPE),
+    flags(BASETYPE, _MATCH_SELF),
     with(
         Py,
         PyRef,
@@ -205,7 +206,6 @@ impl PyByteArray {
         self.inner().capacity()
     }
 
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.borrow_buf().len()
     }
@@ -215,12 +215,10 @@ impl PyByteArray {
         size_of::<Self>() + self.borrow_buf().len() * size_of::<u8>()
     }
 
-    #[pymethod]
     fn __add__(&self, other: ArgBytesLike) -> Self {
         self.inner().add(&other.borrow_buf()).into()
     }
 
-    #[pymethod]
     fn __contains__(
         &self,
         needle: Either<PyBytesInner, PyIntRef>,
@@ -229,7 +227,6 @@ impl PyByteArray {
         self.inner().contains(needle, vm)
     }
 
-    #[pymethod]
     fn __iadd__(
         zelf: PyRef<Self>,
         other: ArgBytesLike,
@@ -241,12 +238,10 @@ impl PyByteArray {
         Ok(zelf)
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
 
-    #[pymethod]
     pub fn __delitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self._delitem(&needle, vm)
     }
@@ -328,7 +323,7 @@ impl PyByteArray {
 
     #[pyclassmethod]
     fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let bytes = PyBytesInner::fromhex(string.as_str(), vm)?;
+        let bytes = PyBytesInner::fromhex(string.as_bytes(), vm)?;
         let bytes = vm.ctx.new_bytes(bytes);
         let args = vec![bytes.into()].into();
         PyType::call(&cls, args, vm)
@@ -524,29 +519,20 @@ impl PyByteArray {
         self.inner().title().into()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(&self, value: ArgSize, vm: &VirtualMachine) -> PyResult<Self> {
         self.repeat(value.into(), vm)
     }
 
-    #[pymethod]
     fn __imul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::irepeat(&zelf, value.into(), vm)?;
         Ok(zelf)
     }
 
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         let formatted = self.inner().cformat(values, vm)?;
         Ok(formatted.into())
     }
 
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
     #[pymethod]
     fn reverse(&self) {
         self.borrow_buf_mut().reverse();
@@ -561,7 +547,6 @@ impl PyByteArray {
 
 #[pyclass]
 impl Py<PyByteArray> {
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
@@ -686,7 +671,7 @@ impl Initializer for PyByteArray {
     fn init(zelf: PyRef<Self>, options: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
         // First unpack bytearray and *then* get a lock to set it.
         let mut inner = options.get_bytearray_inner(vm)?;
-        std::mem::swap(&mut *zelf.inner_mut(), &mut inner);
+        core::mem::swap(&mut *zelf.inner_mut(), &mut inner);
         Ok(())
     }
 }
@@ -822,7 +807,7 @@ impl AsNumber for PyByteArray {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyByteArray>() {
-                    a.mod_(b.to_owned(), vm).to_pyresult(vm)
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -864,7 +849,7 @@ impl PyPayload for PyByteArrayIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyByteArrayIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -885,8 +870,6 @@ impl PyByteArrayIterator {
     }
 }
 
-impl Unconstructible for PyByteArrayIterator {}
-
 impl SelfIter for PyByteArrayIterator {}
 impl IterNext for PyByteArrayIterator {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
diff --git a/vm/src/builtins/bytes.rs b/crates/vm/src/builtins/bytes.rs
similarity index 87%
rename from vm/src/builtins/bytes.rs
rename to crates/vm/src/builtins/bytes.rs
index 22c93ee929..01e67358aa 100644
--- a/vm/src/builtins/bytes.rs
+++ b/crates/vm/src/builtins/bytes.rs
@@ -15,7 +15,8 @@ use crate::{
     common::{hash::PyHash, lock::PyMutex},
     convert::{ToPyObject, ToPyResult},
     function::{
-        ArgBytesLike, ArgIndex, ArgIterable, Either, OptionalArg, OptionalOption, PyComparisonValue,
+        ArgBytesLike, ArgIndex, ArgIterable, Either, FuncArgs, OptionalArg, OptionalOption,
+        PyComparisonValue,
     },
     protocol::{
         BufferDescriptor, BufferMethods, PyBuffer, PyIterReturn, PyMappingMethods, PyNumberMethods,
@@ -24,12 +25,12 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
         AsBuffer, AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, Hashable,
-        IterNext, Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
     },
 };
 use bstr::ByteSlice;
+use core::{mem::size_of, ops::Deref};
 use std::sync::LazyLock;
-use std::{mem::size_of, ops::Deref};
 
 #[pyclass(module = false, name = "bytes")]
 #[derive(Clone, Debug)]
@@ -91,16 +92,71 @@ pub(crate) fn init(context: &Context) {
 }
 
 impl Constructor for PyBytes {
-    type Args = ByteInnerNewOptions;
+    type Args = Vec<u8>;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let options: ByteInnerNewOptions = args.bind(vm)?;
+
+        // Optimizations for exact bytes type
+        if cls.is(vm.ctx.types.bytes_type) {
+            // Return empty bytes singleton
+            if options.source.is_missing()
+                && options.encoding.is_missing()
+                && options.errors.is_missing()
+            {
+                return Ok(vm.ctx.empty_bytes.clone().into());
+            }
+
+            // Return exact bytes as-is
+            if let OptionalArg::Present(ref obj) = options.source
+                && options.encoding.is_missing()
+                && options.errors.is_missing()
+                && let Ok(b) = obj.clone().downcast_exact::<PyBytes>(vm)
+            {
+                return Ok(b.into_pyref().into());
+            }
+        }
+
+        // Handle __bytes__ method - may return PyBytes directly
+        if let OptionalArg::Present(ref obj) = options.source
+            && options.encoding.is_missing()
+            && options.errors.is_missing()
+            && let Some(bytes_method) = vm.get_method(obj.clone(), identifier!(vm, __bytes__))
+        {
+            let bytes = bytes_method?.call((), vm)?;
+            // If exact bytes type and __bytes__ returns bytes, use it directly
+            if cls.is(vm.ctx.types.bytes_type)
+                && let Ok(b) = bytes.clone().downcast::<PyBytes>()
+            {
+                return Ok(b.into());
+            }
+            // Otherwise convert to Vec<u8>
+            let inner = PyBytesInner::try_from_borrowed_object(vm, &bytes)?;
+            let payload = Self::py_new(&cls, inner.elements, vm)?;
+            return payload.into_ref_with_type(vm, cls).map(Into::into);
+        }
+
+        // Fallback to get_bytearray_inner
+        let elements = options.get_bytearray_inner(vm)?.elements;
+
+        // Return empty bytes singleton for exact bytes types
+        if elements.is_empty() && cls.is(vm.ctx.types.bytes_type) {
+            return Ok(vm.ctx.empty_bytes.clone().into());
+        }
+
+        let payload = Self::py_new(&cls, elements, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
 
-    fn py_new(cls: PyTypeRef, options: Self::Args, vm: &VirtualMachine) -> PyResult {
-        options.get_bytes(cls, vm).to_pyresult(vm)
+    fn py_new(_cls: &Py<PyType>, elements: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self::from(elements))
     }
 }
 
 impl PyBytes {
+    #[deprecated(note = "use PyBytes::from(...).into_ref() instead")]
     pub fn new_ref(data: Vec<u8>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(data), ctx.types.bytes_type.to_owned(), None)
+        Self::from(data).into_ref(ctx)
     }
 
     fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
@@ -131,7 +187,8 @@ impl PyRef<PyBytes> {
 }
 
 #[pyclass(
-    flags(BASETYPE),
+    itemsize = 1,
+    flags(BASETYPE, _MATCH_SELF),
     with(
         Py,
         PyRef,
@@ -148,7 +205,6 @@ impl PyRef<PyBytes> {
 )]
 impl PyBytes {
     #[inline]
-    #[pymethod]
     pub const fn __len__(&self) -> usize {
         self.inner.len()
     }
@@ -168,12 +224,10 @@ impl PyBytes {
         size_of::<Self>() + self.len() * size_of::<u8>()
     }
 
-    #[pymethod]
     fn __add__(&self, other: ArgBytesLike) -> Vec<u8> {
         self.inner.add(&other.borrow_buf())
     }
 
-    #[pymethod]
     fn __contains__(
         &self,
         needle: Either<PyBytesInner, PyIntRef>,
@@ -187,7 +241,6 @@ impl PyBytes {
         PyBytesInner::maketrans(from, to, vm)
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
@@ -264,7 +317,7 @@ impl PyBytes {
 
     #[pyclassmethod]
     fn fromhex(cls: PyTypeRef, string: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let bytes = PyBytesInner::fromhex(string.as_str(), vm)?;
+        let bytes = PyBytesInner::fromhex(string.as_bytes(), vm)?;
         let bytes = vm.ctx.new_bytes(bytes).into();
         PyType::call(&cls, vec![bytes].into(), vm)
     }
@@ -456,23 +509,15 @@ impl PyBytes {
         self.inner.title().into()
     }
 
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgIndex, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.repeat(value.try_to_primitive(vm)?, vm)
+        zelf.repeat(value.into_int_ref().try_to_primitive(vm)?, vm)
     }
 
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         let formatted = self.inner.cformat(values, vm)?;
         Ok(formatted.into())
     }
 
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
     #[pymethod]
     fn __getnewargs__(&self, vm: &VirtualMachine) -> PyTupleRef {
         let param: Vec<PyObjectRef> = self.elements().map(|x| x.to_pyobject(vm)).collect();
@@ -621,7 +666,7 @@ impl AsNumber for PyBytes {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
             remainder: Some(|a, b, vm| {
                 if let Some(a) = a.downcast_ref::<PyBytes>() {
-                    a.mod_(b.to_owned(), vm).to_pyresult(vm)
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -693,7 +738,7 @@ impl PyPayload for PyBytesIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyBytesIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -714,7 +759,6 @@ impl PyBytesIterator {
             .set_state(state, |obj, pos| pos.min(obj.len()), vm)
     }
 }
-impl Unconstructible for PyBytesIterator {}
 
 impl SelfIter for PyBytesIterator {}
 impl IterNext for PyBytesIterator {
diff --git a/vm/src/builtins/classmethod.rs b/crates/vm/src/builtins/classmethod.rs
similarity index 88%
rename from vm/src/builtins/classmethod.rs
rename to crates/vm/src/builtins/classmethod.rs
index 03bdeb171d..5b7f921865 100644
--- a/vm/src/builtins/classmethod.rs
+++ b/crates/vm/src/builtins/classmethod.rs
@@ -3,6 +3,7 @@ use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     common::lock::PyMutex,
+    function::FuncArgs,
     types::{Constructor, GetDescriptor, Initializer, Representable},
 };
 
@@ -56,11 +57,11 @@ impl GetDescriptor for PyClassMethod {
     ) -> PyResult {
         let (zelf, _obj) = Self::_unwrap(&zelf, obj, vm)?;
         let cls = cls.unwrap_or_else(|| _obj.class().to_owned().into());
-        let call_descr_get: PyResult<PyObjectRef> = zelf.callable.lock().get_attr("__get__", vm);
+        // Clone and release lock before calling Python code to prevent deadlock
+        let callable = zelf.callable.lock().clone();
+        let call_descr_get: PyResult<PyObjectRef> = callable.get_attr("__get__", vm);
         match call_descr_get {
-            Err(_) => Ok(PyBoundMethod::new(cls, zelf.callable.lock().clone())
-                .into_ref(&vm.ctx)
-                .into()),
+            Err(_) => Ok(PyBoundMethod::new(cls, callable).into_ref(&vm.ctx).into()),
             Ok(call_descr_get) => call_descr_get.call((cls.clone(), cls), vm),
         }
     }
@@ -69,7 +70,8 @@ impl GetDescriptor for PyClassMethod {
 impl Constructor for PyClassMethod {
     type Args = PyObjectRef;
 
-    fn py_new(cls: PyTypeRef, callable: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let callable: Self::Args = args.bind(vm)?;
         // Create a dictionary to hold copied attributes
         let dict = vm.ctx.new_dict();
 
@@ -99,6 +101,10 @@ impl Constructor for PyClassMethod {
         let result = PyRef::new_ref(classmethod, cls, Some(dict));
         Ok(PyObjectRef::from(result))
     }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
 }
 
 impl Initializer for PyClassMethod {
@@ -111,19 +117,14 @@ impl Initializer for PyClassMethod {
 }
 
 impl PyClassMethod {
+    #[deprecated(note = "use PyClassMethod::from(...).into_ref() instead")]
     pub fn new_ref(callable: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {
-                callable: PyMutex::new(callable),
-            },
-            ctx.types.classmethod_type.to_owned(),
-            None,
-        )
+        Self::from(callable).into_ref(ctx)
     }
 }
 
 #[pyclass(
-    with(GetDescriptor, Constructor, Representable),
+    with(GetDescriptor, Constructor, Initializer, Representable),
     flags(BASETYPE, HAS_DICT)
 )]
 impl PyClassMethod {
diff --git a/crates/vm/src/builtins/code.rs b/crates/vm/src/builtins/code.rs
new file mode 100644
index 0000000000..85816aabb7
--- /dev/null
+++ b/crates/vm/src/builtins/code.rs
@@ -0,0 +1,1152 @@
+//! Infamous code object. The python class `code`
+
+use super::{PyBytesRef, PyStrRef, PyTupleRef, PyType};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::PyStrInterned,
+    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
+    class::{PyClassImpl, StaticType},
+    convert::{ToPyException, ToPyObject},
+    frozen,
+    function::OptionalArg,
+    types::{Constructor, Representable},
+};
+use alloc::fmt;
+use core::{borrow::Borrow, ops::Deref};
+use malachite_bigint::BigInt;
+use num_traits::Zero;
+use rustpython_compiler_core::{OneIndexed, bytecode::CodeUnits, bytecode::PyCodeLocationInfoKind};
+
+/// State for iterating through code address ranges
+struct PyCodeAddressRange<'a> {
+    ar_start: i32,
+    ar_end: i32,
+    ar_line: i32,
+    computed_line: i32,
+    reader: LineTableReader<'a>,
+}
+
+impl<'a> PyCodeAddressRange<'a> {
+    fn new(linetable: &'a [u8], first_line: i32) -> Self {
+        PyCodeAddressRange {
+            ar_start: 0,
+            ar_end: 0,
+            ar_line: -1,
+            computed_line: first_line,
+            reader: LineTableReader::new(linetable),
+        }
+    }
+
+    /// Check if this is a NO_LINE marker (code 15)
+    fn is_no_line_marker(byte: u8) -> bool {
+        (byte >> 3) == 0x1f
+    }
+
+    /// Advance to next address range
+    fn advance(&mut self) -> bool {
+        if self.reader.at_end() {
+            return false;
+        }
+
+        let first_byte = match self.reader.read_byte() {
+            Some(b) => b,
+            None => return false,
+        };
+
+        if (first_byte & 0x80) == 0 {
+            return false; // Invalid linetable
+        }
+
+        let code = (first_byte >> 3) & 0x0f;
+        let length = ((first_byte & 0x07) + 1) as i32;
+
+        // Get line delta for this entry
+        let line_delta = self.get_line_delta(code);
+
+        // Update computed line
+        self.computed_line += line_delta;
+
+        // Check for NO_LINE marker
+        if Self::is_no_line_marker(first_byte) {
+            self.ar_line = -1;
+        } else {
+            self.ar_line = self.computed_line;
+        }
+
+        // Update address range
+        self.ar_start = self.ar_end;
+        self.ar_end += length * 2; // sizeof(_Py_CODEUNIT) = 2
+
+        // Skip remaining bytes for this entry
+        while !self.reader.at_end() {
+            if let Some(b) = self.reader.peek_byte() {
+                if (b & 0x80) != 0 {
+                    break;
+                }
+                self.reader.read_byte();
+            } else {
+                break;
+            }
+        }
+
+        true
+    }
+
+    fn get_line_delta(&mut self, code: u8) -> i32 {
+        let kind = match PyCodeLocationInfoKind::from_code(code) {
+            Some(k) => k,
+            None => return 0,
+        };
+
+        match kind {
+            PyCodeLocationInfoKind::None => 0, // NO_LINE marker
+            PyCodeLocationInfoKind::Long => {
+                let delta = self.reader.read_signed_varint();
+                // Skip end_line, col, end_col
+                self.reader.read_varint();
+                self.reader.read_varint();
+                self.reader.read_varint();
+                delta
+            }
+            PyCodeLocationInfoKind::NoColumns => self.reader.read_signed_varint(),
+            PyCodeLocationInfoKind::OneLine0 => {
+                self.reader.read_byte(); // Skip column
+                self.reader.read_byte(); // Skip end column
+                0
+            }
+            PyCodeLocationInfoKind::OneLine1 => {
+                self.reader.read_byte(); // Skip column
+                self.reader.read_byte(); // Skip end column
+                1
+            }
+            PyCodeLocationInfoKind::OneLine2 => {
+                self.reader.read_byte(); // Skip column
+                self.reader.read_byte(); // Skip end column
+                2
+            }
+            _ if kind.is_short() => {
+                self.reader.read_byte(); // Skip column byte
+                0
+            }
+            _ => 0,
+        }
+    }
+}
+
+#[derive(FromArgs)]
+pub struct ReplaceArgs {
+    #[pyarg(named, optional)]
+    co_posonlyargcount: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_argcount: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_kwonlyargcount: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_filename: OptionalArg<PyStrRef>,
+    #[pyarg(named, optional)]
+    co_firstlineno: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_consts: OptionalArg<Vec<PyObjectRef>>,
+    #[pyarg(named, optional)]
+    co_name: OptionalArg<PyStrRef>,
+    #[pyarg(named, optional)]
+    co_names: OptionalArg<Vec<PyObjectRef>>,
+    #[pyarg(named, optional)]
+    co_flags: OptionalArg<u16>,
+    #[pyarg(named, optional)]
+    co_varnames: OptionalArg<Vec<PyObjectRef>>,
+    #[pyarg(named, optional)]
+    co_nlocals: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_stacksize: OptionalArg<u32>,
+    #[pyarg(named, optional)]
+    co_code: OptionalArg<crate::builtins::PyBytesRef>,
+    #[pyarg(named, optional)]
+    co_linetable: OptionalArg<crate::builtins::PyBytesRef>,
+    #[pyarg(named, optional)]
+    co_exceptiontable: OptionalArg<crate::builtins::PyBytesRef>,
+    #[pyarg(named, optional)]
+    co_freevars: OptionalArg<Vec<PyObjectRef>>,
+    #[pyarg(named, optional)]
+    co_cellvars: OptionalArg<Vec<PyObjectRef>>,
+    #[pyarg(named, optional)]
+    co_qualname: OptionalArg<PyStrRef>,
+}
+
+#[derive(Clone)]
+#[repr(transparent)]
+pub struct Literal(PyObjectRef);
+
+impl Borrow<PyObject> for Literal {
+    fn borrow(&self) -> &PyObject {
+        &self.0
+    }
+}
+
+impl From<Literal> for PyObjectRef {
+    fn from(obj: Literal) -> Self {
+        obj.0
+    }
+}
+
+fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<'_, Literal> {
+    match_class!(match obj {
+        ref i @ super::int::PyInt => {
+            let value = i.as_bigint();
+            if obj.class().is(super::bool_::PyBool::static_type()) {
+                BorrowedConstant::Boolean {
+                    value: !value.is_zero(),
+                }
+            } else {
+                BorrowedConstant::Integer { value }
+            }
+        }
+        ref f @ super::float::PyFloat => BorrowedConstant::Float { value: f.to_f64() },
+        ref c @ super::complex::PyComplex => BorrowedConstant::Complex {
+            value: c.to_complex()
+        },
+        ref s @ super::pystr::PyStr => BorrowedConstant::Str { value: s.as_wtf8() },
+        ref b @ super::bytes::PyBytes => BorrowedConstant::Bytes {
+            value: b.as_bytes()
+        },
+        ref c @ PyCode => {
+            BorrowedConstant::Code { code: &c.code }
+        }
+        ref t @ super::tuple::PyTuple => {
+            let elements = t.as_slice();
+            // SAFETY: Literal is repr(transparent) over PyObjectRef, and a Literal tuple only ever
+            //         has other literals as elements
+            let elements = unsafe { &*(elements as *const [PyObjectRef] as *const [Literal]) };
+            BorrowedConstant::Tuple { elements }
+        }
+        super::singletons::PyNone => BorrowedConstant::None,
+        super::slice::PyEllipsis => BorrowedConstant::Ellipsis,
+        _ => panic!("unexpected payload for constant python value"),
+    })
+}
+
+impl Constant for Literal {
+    type Name = &'static PyStrInterned;
+    fn borrow_constant(&self) -> BorrowedConstant<'_, Self> {
+        borrow_obj_constant(&self.0)
+    }
+}
+
+impl<'a> AsBag for &'a Context {
+    type Bag = PyObjBag<'a>;
+    fn as_bag(self) -> PyObjBag<'a> {
+        PyObjBag(self)
+    }
+}
+
+impl<'a> AsBag for &'a VirtualMachine {
+    type Bag = PyObjBag<'a>;
+    fn as_bag(self) -> PyObjBag<'a> {
+        PyObjBag(&self.ctx)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct PyObjBag<'a>(pub &'a Context);
+
+impl ConstantBag for PyObjBag<'_> {
+    type Constant = Literal;
+
+    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {
+        let ctx = self.0;
+        let obj = match constant {
+            BorrowedConstant::Integer { value } => ctx.new_bigint(value).into(),
+            BorrowedConstant::Float { value } => ctx.new_float(value).into(),
+            BorrowedConstant::Complex { value } => ctx.new_complex(value).into(),
+            BorrowedConstant::Str { value } if value.len() <= 20 => {
+                ctx.intern_str(value).to_object()
+            }
+            BorrowedConstant::Str { value } => ctx.new_str(value).into(),
+            BorrowedConstant::Bytes { value } => ctx.new_bytes(value.to_vec()).into(),
+            BorrowedConstant::Boolean { value } => ctx.new_bool(value).into(),
+            BorrowedConstant::Code { code } => ctx.new_code(code.map_clone_bag(self)).into(),
+            BorrowedConstant::Tuple { elements } => {
+                let elements = elements
+                    .iter()
+                    .map(|constant| self.make_constant(constant.borrow_constant()).0)
+                    .collect();
+                ctx.new_tuple(elements).into()
+            }
+            BorrowedConstant::None => ctx.none(),
+            BorrowedConstant::Ellipsis => ctx.ellipsis.clone().into(),
+        };
+
+        Literal(obj)
+    }
+
+    fn make_name(&self, name: &str) -> &'static PyStrInterned {
+        self.0.intern_str(name)
+    }
+
+    fn make_int(&self, value: BigInt) -> Self::Constant {
+        Literal(self.0.new_int(value).into())
+    }
+
+    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {
+        Literal(self.0.new_tuple(elements.map(|lit| lit.0).collect()).into())
+    }
+
+    fn make_code(&self, code: CodeObject) -> Self::Constant {
+        Literal(self.0.new_code(code).into())
+    }
+}
+
+pub type CodeObject = bytecode::CodeObject<Literal>;
+
+pub trait IntoCodeObject {
+    fn into_code_object(self, ctx: &Context) -> CodeObject;
+}
+
+impl IntoCodeObject for CodeObject {
+    fn into_code_object(self, _ctx: &Context) -> Self {
+        self
+    }
+}
+
+impl IntoCodeObject for bytecode::CodeObject {
+    fn into_code_object(self, ctx: &Context) -> CodeObject {
+        self.map_bag(PyObjBag(ctx))
+    }
+}
+
+impl<B: AsRef<[u8]>> IntoCodeObject for frozen::FrozenCodeObject<B> {
+    fn into_code_object(self, ctx: &Context) -> CodeObject {
+        self.decode(ctx)
+    }
+}
+
+#[pyclass(module = false, name = "code")]
+pub struct PyCode {
+    pub code: CodeObject,
+}
+
+impl Deref for PyCode {
+    type Target = CodeObject;
+    fn deref(&self) -> &Self::Target {
+        &self.code
+    }
+}
+
+impl PyCode {
+    pub const fn new(code: CodeObject) -> Self {
+        Self { code }
+    }
+    pub fn from_pyc_path(path: &std::path::Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        let name = match path.file_stem() {
+            Some(stem) => stem.display().to_string(),
+            None => "".to_owned(),
+        };
+        let content = std::fs::read(path).map_err(|e| e.to_pyexception(vm))?;
+        Self::from_pyc(
+            &content,
+            Some(&name),
+            Some(&path.display().to_string()),
+            Some("<source>"),
+            vm,
+        )
+    }
+    pub fn from_pyc(
+        pyc_bytes: &[u8],
+        name: Option<&str>,
+        bytecode_path: Option<&str>,
+        source_path: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<Self>> {
+        if !crate::import::check_pyc_magic_number_bytes(pyc_bytes) {
+            return Err(vm.new_value_error("pyc bytes has wrong MAGIC"));
+        }
+        let bootstrap_external = vm.import("_frozen_importlib_external", 0)?;
+        let compile_bytecode = bootstrap_external.get_attr("_compile_bytecode", vm)?;
+        // 16 is the pyc header length
+        let Some((_, code_bytes)) = pyc_bytes.split_at_checked(16) else {
+            return Err(vm.new_value_error(format!(
+                "pyc_bytes header is broken. 16 bytes expected but {} bytes given.",
+                pyc_bytes.len()
+            )));
+        };
+        let code_bytes_obj = vm.ctx.new_bytes(code_bytes.to_vec());
+        let compiled =
+            compile_bytecode.call((code_bytes_obj, name, bytecode_path, source_path), vm)?;
+        compiled.try_downcast(vm)
+    }
+}
+
+impl fmt::Debug for PyCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "code: {:?}", self.code)
+    }
+}
+
+impl PyPayload for PyCode {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.code_type
+    }
+}
+
+impl Representable for PyCode {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        let code = &zelf.code;
+        Ok(format!(
+            "<code object {} at {:#x} file {:?}, line {}>",
+            code.obj_name,
+            zelf.get_id(),
+            code.source_path.as_str(),
+            code.first_line_number.map_or(-1, |n| n.get() as i32)
+        ))
+    }
+}
+
+// Arguments for code object constructor
+#[derive(FromArgs)]
+pub struct PyCodeNewArgs {
+    argcount: u32,
+    posonlyargcount: u32,
+    kwonlyargcount: u32,
+    nlocals: u32,
+    stacksize: u32,
+    flags: u16,
+    co_code: PyBytesRef,
+    consts: PyTupleRef,
+    names: PyTupleRef,
+    varnames: PyTupleRef,
+    filename: PyStrRef,
+    name: PyStrRef,
+    qualname: PyStrRef,
+    firstlineno: i32,
+    linetable: PyBytesRef,
+    exceptiontable: PyBytesRef,
+    freevars: PyTupleRef,
+    cellvars: PyTupleRef,
+}
+
+impl Constructor for PyCode {
+    type Args = PyCodeNewArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        // Convert names tuple to vector of interned strings
+        let names: Box<[&'static PyStrInterned]> = args
+            .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()))
+            })
+            .collect::<PyResult<Vec<_>>>()?
+            .into_boxed_slice();
+
+        let varnames: Box<[&'static PyStrInterned]> = args
+            .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()))
+            })
+            .collect::<PyResult<Vec<_>>>()?
+            .into_boxed_slice();
+
+        let cellvars: Box<[&'static PyStrInterned]> = args
+            .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()))
+            })
+            .collect::<PyResult<Vec<_>>>()?
+            .into_boxed_slice();
+
+        let freevars: Box<[&'static PyStrInterned]> = args
+            .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()))
+            })
+            .collect::<PyResult<Vec<_>>>()?
+            .into_boxed_slice();
+
+        // Check nlocals matches varnames length
+        if args.nlocals as usize != varnames.len() {
+            return Err(vm.new_value_error(format!(
+                "nlocals ({}) != len(varnames) ({})",
+                args.nlocals,
+                varnames.len()
+            )));
+        }
+
+        // Parse and validate bytecode from bytes
+        let bytecode_bytes = args.co_code.as_bytes();
+        let instructions = CodeUnits::try_from(bytecode_bytes)
+            .map_err(|e| vm.new_value_error(format!("invalid bytecode: {}", e)))?;
+
+        // Convert constants
+        let constants: Box<[Literal]> = args
+            .consts
+            .iter()
+            .map(|obj| {
+                // Convert PyObject to Literal constant
+                // For now, just wrap it
+                Literal(obj.clone())
+            })
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        // Create locations (start and end pairs)
+        let row = if args.firstlineno > 0 {
+            OneIndexed::new(args.firstlineno as usize).unwrap_or(OneIndexed::MIN)
+        } else {
+            OneIndexed::MIN
+        };
+        let loc = rustpython_compiler_core::SourceLocation {
+            line: row,
+            character_offset: OneIndexed::from_zero_indexed(0),
+        };
+        let locations: Box<
+            [(
+                rustpython_compiler_core::SourceLocation,
+                rustpython_compiler_core::SourceLocation,
+            )],
+        > = vec![(loc, loc); instructions.len()].into_boxed_slice();
+
+        // Build the CodeObject
+        let code = CodeObject {
+            instructions,
+            locations,
+            flags: CodeFlags::from_bits_truncate(args.flags),
+            posonlyarg_count: args.posonlyargcount,
+            arg_count: args.argcount,
+            kwonlyarg_count: args.kwonlyargcount,
+            source_path: vm.ctx.intern_str(args.filename.as_str()),
+            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`
+            constants,
+            names,
+            varnames,
+            cellvars,
+            freevars,
+            linetable: args.linetable.as_bytes().to_vec().into_boxed_slice(),
+            exceptiontable: args.exceptiontable.as_bytes().to_vec().into_boxed_slice(),
+        };
+
+        Ok(PyCode::new(code))
+    }
+}
+
+#[pyclass(with(Representable, Constructor))]
+impl PyCode {
+    #[pygetset]
+    const fn co_posonlyargcount(&self) -> usize {
+        self.code.posonlyarg_count as usize
+    }
+
+    #[pygetset]
+    const fn co_argcount(&self) -> usize {
+        self.code.arg_count as usize
+    }
+
+    #[pygetset]
+    const fn co_stacksize(&self) -> u32 {
+        self.code.max_stackdepth
+    }
+
+    #[pygetset]
+    pub fn co_filename(&self) -> PyStrRef {
+        self.code.source_path.to_owned()
+    }
+
+    #[pygetset]
+    pub fn co_cellvars(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let cellvars = self
+            .cellvars
+            .iter()
+            .map(|name| name.to_pyobject(vm))
+            .collect();
+        vm.ctx.new_tuple(cellvars)
+    }
+
+    #[pygetset]
+    fn co_nlocals(&self) -> usize {
+        self.code.varnames.len()
+    }
+
+    #[pygetset]
+    fn co_firstlineno(&self) -> u32 {
+        self.code.first_line_number.map_or(0, |n| n.get() as _)
+    }
+
+    #[pygetset]
+    const fn co_kwonlyargcount(&self) -> usize {
+        self.code.kwonlyarg_count as usize
+    }
+
+    #[pygetset]
+    fn co_consts(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let consts = self.code.constants.iter().map(|x| x.0.clone()).collect();
+        vm.ctx.new_tuple(consts)
+    }
+
+    #[pygetset]
+    fn co_name(&self) -> PyStrRef {
+        self.code.obj_name.to_owned()
+    }
+    #[pygetset]
+    fn co_qualname(&self) -> PyStrRef {
+        self.code.qualname.to_owned()
+    }
+
+    #[pygetset]
+    fn co_names(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let names = self
+            .code
+            .names
+            .deref()
+            .iter()
+            .map(|name| name.to_pyobject(vm))
+            .collect();
+        vm.ctx.new_tuple(names)
+    }
+
+    #[pygetset]
+    const fn co_flags(&self) -> u16 {
+        self.code.flags.bits()
+    }
+
+    #[pygetset]
+    pub fn co_varnames(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let varnames = self.code.varnames.iter().map(|s| s.to_object()).collect();
+        vm.ctx.new_tuple(varnames)
+    }
+
+    #[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
+        let bytes = unsafe {
+            core::slice::from_raw_parts(
+                self.code.instructions.as_ptr() as *const u8,
+                self.code.instructions.len() * 2,
+            )
+        };
+        vm.ctx.new_bytes(bytes.to_vec())
+    }
+
+    #[pygetset]
+    pub fn co_freevars(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let names = self
+            .code
+            .freevars
+            .deref()
+            .iter()
+            .map(|name| name.to_pyobject(vm))
+            .collect();
+        vm.ctx.new_tuple(names)
+    }
+
+    #[pygetset]
+    pub fn co_linetable(&self, vm: &VirtualMachine) -> crate::builtins::PyBytesRef {
+        // Return the actual linetable from the code object
+        vm.ctx.new_bytes(self.code.linetable.to_vec())
+    }
+
+    #[pygetset]
+    pub fn co_exceptiontable(&self, vm: &VirtualMachine) -> crate::builtins::PyBytesRef {
+        // Return the actual exception table from the code object
+        vm.ctx.new_bytes(self.code.exceptiontable.to_vec())
+    }
+
+    #[pymethod]
+    pub fn co_lines(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // TODO: Implement lazy iterator (lineiterator) like CPython for better performance
+        // Currently returns eager list for simplicity
+
+        // Return an iterator over (start_offset, end_offset, lineno) tuples
+        let linetable = self.code.linetable.as_ref();
+        let mut lines = Vec::new();
+
+        if !linetable.is_empty() {
+            let first_line = self.code.first_line_number.map_or(0, |n| n.get() as i32);
+            let mut range = PyCodeAddressRange::new(linetable, first_line);
+
+            // Process all address ranges and merge consecutive entries with same line
+            let mut pending_entry: Option<(i32, i32, i32)> = None;
+
+            while range.advance() {
+                let start = range.ar_start;
+                let end = range.ar_end;
+                let line = range.ar_line;
+
+                if let Some((prev_start, _, prev_line)) = pending_entry {
+                    if prev_line == line {
+                        // Same line, extend the range
+                        pending_entry = Some((prev_start, end, prev_line));
+                    } else {
+                        // Different line, emit the previous entry
+                        let tuple = if prev_line == -1 {
+                            vm.ctx.new_tuple(vec![
+                                vm.ctx.new_int(prev_start).into(),
+                                vm.ctx.new_int(start).into(),
+                                vm.ctx.none(),
+                            ])
+                        } else {
+                            vm.ctx.new_tuple(vec![
+                                vm.ctx.new_int(prev_start).into(),
+                                vm.ctx.new_int(start).into(),
+                                vm.ctx.new_int(prev_line).into(),
+                            ])
+                        };
+                        lines.push(tuple.into());
+                        pending_entry = Some((start, end, line));
+                    }
+                } else {
+                    // First entry
+                    pending_entry = Some((start, end, line));
+                }
+            }
+
+            // Emit the last pending entry
+            if let Some((start, end, line)) = pending_entry {
+                let tuple = if line == -1 {
+                    vm.ctx.new_tuple(vec![
+                        vm.ctx.new_int(start).into(),
+                        vm.ctx.new_int(end).into(),
+                        vm.ctx.none(),
+                    ])
+                } else {
+                    vm.ctx.new_tuple(vec![
+                        vm.ctx.new_int(start).into(),
+                        vm.ctx.new_int(end).into(),
+                        vm.ctx.new_int(line).into(),
+                    ])
+                };
+                lines.push(tuple.into());
+            }
+        }
+
+        let list = vm.ctx.new_list(lines);
+        vm.call_method(list.as_object(), "__iter__", ())
+    }
+
+    #[pymethod]
+    pub fn co_positions(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Return an iterator over (line, end_line, column, end_column) tuples for each instruction
+        let linetable = self.code.linetable.as_ref();
+        let mut positions = Vec::new();
+
+        if !linetable.is_empty() {
+            let mut reader = LineTableReader::new(linetable);
+            let mut line = self.code.first_line_number.map_or(0, |n| n.get() as i32);
+
+            while !reader.at_end() {
+                let first_byte = match reader.read_byte() {
+                    Some(b) => b,
+                    None => break,
+                };
+
+                if (first_byte & 0x80) == 0 {
+                    break; // Invalid linetable
+                }
+
+                let code = (first_byte >> 3) & 0x0f;
+                let length = ((first_byte & 0x07) + 1) as i32;
+
+                let kind = match PyCodeLocationInfoKind::from_code(code) {
+                    Some(k) => k,
+                    None => break, // Invalid code
+                };
+
+                let (line_delta, end_line_delta, column, end_column): (
+                    i32,
+                    i32,
+                    Option<i32>,
+                    Option<i32>,
+                ) = match kind {
+                    PyCodeLocationInfoKind::None => {
+                        // No location - all values are None
+                        (0, 0, None, None)
+                    }
+                    PyCodeLocationInfoKind::Long => {
+                        // Long form
+                        let delta = reader.read_signed_varint();
+                        let end_line_delta = reader.read_varint() as i32;
+
+                        let col = reader.read_varint();
+                        let column = if col == 0 {
+                            None
+                        } else {
+                            Some((col - 1) as i32)
+                        };
+
+                        let end_col = reader.read_varint();
+                        let end_column = if end_col == 0 {
+                            None
+                        } else {
+                            Some((end_col - 1) as i32)
+                        };
+
+                        // endline = line + end_line_delta (will be computed after line update)
+                        (delta, end_line_delta, column, end_column)
+                    }
+                    PyCodeLocationInfoKind::NoColumns => {
+                        // No column form
+                        let delta = reader.read_signed_varint();
+                        (delta, 0, None, None) // endline will be same as line (delta = 0)
+                    }
+                    PyCodeLocationInfoKind::OneLine0
+                    | PyCodeLocationInfoKind::OneLine1
+                    | PyCodeLocationInfoKind::OneLine2 => {
+                        // One-line form - endline = line
+                        let col = reader.read_byte().unwrap_or(0) as i32;
+                        let end_col = reader.read_byte().unwrap_or(0) as i32;
+                        let delta = kind.one_line_delta().unwrap_or(0);
+                        (delta, 0, Some(col), Some(end_col)) // endline = line (delta = 0)
+                    }
+                    _ if kind.is_short() => {
+                        // Short form - endline = line
+                        let col_data = reader.read_byte().unwrap_or(0);
+                        let col_group = kind.short_column_group().unwrap_or(0);
+                        let col = ((col_group as i32) << 3) | ((col_data >> 4) as i32);
+                        let end_col = col + (col_data & 0x0f) as i32;
+                        (0, 0, Some(col), Some(end_col)) // endline = line (delta = 0)
+                    }
+                    _ => (0, 0, None, None),
+                };
+
+                // Update line number
+                line += line_delta;
+
+                // Generate position tuples for each instruction covered by this entry
+                for _ in 0..length {
+                    // Handle special case for no location (code 15)
+                    let final_line = if kind == PyCodeLocationInfoKind::None {
+                        None
+                    } else {
+                        Some(line)
+                    };
+
+                    let final_endline = if kind == PyCodeLocationInfoKind::None {
+                        None
+                    } else {
+                        Some(line + end_line_delta)
+                    };
+
+                    let line_obj = final_line.to_pyobject(vm);
+                    let end_line_obj = final_endline.to_pyobject(vm);
+                    let column_obj = column.to_pyobject(vm);
+                    let end_column_obj = end_column.to_pyobject(vm);
+
+                    let tuple =
+                        vm.ctx
+                            .new_tuple(vec![line_obj, end_line_obj, column_obj, end_column_obj]);
+                    positions.push(tuple.into());
+                }
+            }
+        }
+
+        let list = vm.ctx.new_list(positions);
+        vm.call_method(list.as_object(), "__iter__", ())
+    }
+
+    #[pymethod]
+    pub fn replace(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self> {
+        let ReplaceArgs {
+            co_posonlyargcount,
+            co_argcount,
+            co_kwonlyargcount,
+            co_filename,
+            co_firstlineno,
+            co_consts,
+            co_name,
+            co_names,
+            co_flags,
+            co_varnames,
+            co_nlocals,
+            co_stacksize,
+            co_code,
+            co_linetable,
+            co_exceptiontable,
+            co_freevars,
+            co_cellvars,
+            co_qualname,
+        } = args;
+        let posonlyarg_count = match co_posonlyargcount {
+            OptionalArg::Present(posonlyarg_count) => posonlyarg_count,
+            OptionalArg::Missing => self.code.posonlyarg_count,
+        };
+
+        let arg_count = match co_argcount {
+            OptionalArg::Present(arg_count) => arg_count,
+            OptionalArg::Missing => self.code.arg_count,
+        };
+
+        let source_path = match co_filename {
+            OptionalArg::Present(source_path) => source_path,
+            OptionalArg::Missing => self.code.source_path.to_owned(),
+        };
+
+        let first_line_number = match co_firstlineno {
+            OptionalArg::Present(first_line_number) => OneIndexed::new(first_line_number as _),
+            OptionalArg::Missing => self.code.first_line_number,
+        };
+
+        let kwonlyarg_count = match co_kwonlyargcount {
+            OptionalArg::Present(kwonlyarg_count) => kwonlyarg_count,
+            OptionalArg::Missing => self.code.kwonlyarg_count,
+        };
+
+        let constants = match co_consts {
+            OptionalArg::Present(constants) => constants,
+            OptionalArg::Missing => self.code.constants.iter().map(|x| x.0.clone()).collect(),
+        };
+
+        let obj_name = match co_name {
+            OptionalArg::Present(obj_name) => obj_name,
+            OptionalArg::Missing => self.code.obj_name.to_owned(),
+        };
+
+        let names = match co_names {
+            OptionalArg::Present(names) => names,
+            OptionalArg::Missing => self
+                .code
+                .names
+                .deref()
+                .iter()
+                .map(|name| name.to_pyobject(vm))
+                .collect(),
+        };
+
+        let flags = match co_flags {
+            OptionalArg::Present(flags) => flags,
+            OptionalArg::Missing => self.code.flags.bits(),
+        };
+
+        let varnames = match co_varnames {
+            OptionalArg::Present(varnames) => varnames,
+            OptionalArg::Missing => self.code.varnames.iter().map(|s| s.to_object()).collect(),
+        };
+
+        let qualname = match co_qualname {
+            OptionalArg::Present(qualname) => qualname,
+            OptionalArg::Missing => self.code.qualname.to_owned(),
+        };
+
+        let max_stackdepth = match co_stacksize {
+            OptionalArg::Present(stacksize) => stacksize,
+            OptionalArg::Missing => self.code.max_stackdepth,
+        };
+
+        let instructions = match co_code {
+            OptionalArg::Present(code_bytes) => {
+                // Parse and validate bytecode from bytes
+                CodeUnits::try_from(code_bytes.as_bytes())
+                    .map_err(|e| vm.new_value_error(format!("invalid bytecode: {}", e)))?
+            }
+            OptionalArg::Missing => self.code.instructions.clone(),
+        };
+
+        let cellvars = match co_cellvars {
+            OptionalArg::Present(cellvars) => cellvars
+                .into_iter()
+                .map(|o| o.as_interned_str(vm).unwrap())
+                .collect(),
+            OptionalArg::Missing => self.code.cellvars.clone(),
+        };
+
+        let freevars = match co_freevars {
+            OptionalArg::Present(freevars) => freevars
+                .into_iter()
+                .map(|o| o.as_interned_str(vm).unwrap())
+                .collect(),
+            OptionalArg::Missing => self.code.freevars.clone(),
+        };
+
+        // Validate co_nlocals if provided
+        if let OptionalArg::Present(nlocals) = co_nlocals
+            && nlocals as usize != varnames.len()
+        {
+            return Err(vm.new_value_error(format!(
+                "co_nlocals ({}) != len(co_varnames) ({})",
+                nlocals,
+                varnames.len()
+            )));
+        }
+
+        // Handle linetable and exceptiontable
+        let linetable = match co_linetable {
+            OptionalArg::Present(linetable) => linetable.as_bytes().to_vec().into_boxed_slice(),
+            OptionalArg::Missing => self.code.linetable.clone(),
+        };
+
+        let exceptiontable = match co_exceptiontable {
+            OptionalArg::Present(exceptiontable) => {
+                exceptiontable.as_bytes().to_vec().into_boxed_slice()
+            }
+            OptionalArg::Missing => self.code.exceptiontable.clone(),
+        };
+
+        let new_code = CodeObject {
+            flags: CodeFlags::from_bits_truncate(flags),
+            posonlyarg_count,
+            arg_count,
+            kwonlyarg_count,
+            source_path: source_path.as_object().as_interned_str(vm).unwrap(),
+            first_line_number,
+            obj_name: obj_name.as_object().as_interned_str(vm).unwrap(),
+            qualname: qualname.as_object().as_interned_str(vm).unwrap(),
+
+            max_stackdepth,
+            instructions,
+            // FIXME: invalid locations. Actually locations is a duplication of linetable.
+            // It can be removed once we move every other code to use linetable only.
+            locations: self.code.locations.clone(),
+            constants: constants.into_iter().map(Literal).collect(),
+            names: names
+                .into_iter()
+                .map(|o| o.as_interned_str(vm).unwrap())
+                .collect(),
+            varnames: varnames
+                .into_iter()
+                .map(|o| o.as_interned_str(vm).unwrap())
+                .collect(),
+            cellvars,
+            freevars,
+            cell2arg: self.code.cell2arg.clone(),
+            linetable,
+            exceptiontable,
+        };
+
+        Ok(PyCode::new(new_code))
+    }
+
+    #[pymethod]
+    fn _varname_from_oparg(&self, opcode: i32, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let idx_err = |vm: &VirtualMachine| vm.new_index_error("tuple index out of range");
+
+        let idx = usize::try_from(opcode).map_err(|_| idx_err(vm))?;
+
+        let varnames_len = self.code.varnames.len();
+        let cellvars_len = self.code.cellvars.len();
+
+        let name = if idx < varnames_len {
+            // Index in varnames
+            self.code.varnames.get(idx).ok_or_else(|| idx_err(vm))?
+        } else if idx < varnames_len + cellvars_len {
+            // Index in cellvars
+            self.code
+                .cellvars
+                .get(idx - varnames_len)
+                .ok_or_else(|| idx_err(vm))?
+        } else {
+            // Index in freevars
+            self.code
+                .freevars
+                .get(idx - varnames_len - cellvars_len)
+                .ok_or_else(|| idx_err(vm))?
+        };
+        Ok(name.to_object())
+    }
+}
+
+impl fmt::Display for PyCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl ToPyObject for CodeObject {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_code(self).into()
+    }
+}
+
+impl ToPyObject for bytecode::CodeObject {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_code(self).into()
+    }
+}
+
+// Helper struct for reading linetable
+struct LineTableReader<'a> {
+    data: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> LineTableReader<'a> {
+    fn new(data: &'a [u8]) -> Self {
+        Self { data, pos: 0 }
+    }
+
+    fn read_byte(&mut self) -> Option<u8> {
+        if self.pos < self.data.len() {
+            let byte = self.data[self.pos];
+            self.pos += 1;
+            Some(byte)
+        } else {
+            None
+        }
+    }
+
+    fn peek_byte(&self) -> Option<u8> {
+        if self.pos < self.data.len() {
+            Some(self.data[self.pos])
+        } else {
+            None
+        }
+    }
+
+    fn read_varint(&mut self) -> u32 {
+        if let Some(first) = self.read_byte() {
+            let mut val = (first & 0x3f) as u32;
+            let mut shift = 0;
+            let mut byte = first;
+            while (byte & 0x40) != 0 {
+                if let Some(next) = self.read_byte() {
+                    shift += 6;
+                    val |= ((next & 0x3f) as u32) << shift;
+                    byte = next;
+                } else {
+                    break;
+                }
+            }
+            val
+        } else {
+            0
+        }
+    }
+
+    fn read_signed_varint(&mut self) -> i32 {
+        let uval = self.read_varint();
+        if uval & 1 != 0 {
+            -((uval >> 1) as i32)
+        } else {
+            (uval >> 1) as i32
+        }
+    }
+
+    fn at_end(&self) -> bool {
+        self.pos >= self.data.len()
+    }
+}
+
+pub fn init(ctx: &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
new file mode 100644
index 0000000000..78729b2f5c
--- /dev/null
+++ b/crates/vm/src/builtins/complex.rs
@@ -0,0 +1,401 @@
+use super::{PyStr, PyType, PyTypeRef, float};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::PyStrRef,
+    class::PyClassImpl,
+    common::format::FormatSpec,
+    convert::{IntoPyException, ToPyObject, ToPyResult},
+    function::{FuncArgs, OptionalArg, PyComparisonValue},
+    protocol::PyNumberMethods,
+    stdlib::warnings,
+    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+};
+use core::num::Wrapping;
+use num_complex::Complex64;
+use num_traits::Zero;
+use rustpython_common::hash;
+
+/// Create a complex number from a real part and an optional imaginary part.
+///
+/// This is equivalent to (real + imag*1j) where imag defaults to 0.
+#[pyclass(module = false, name = "complex")]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct PyComplex {
+    value: Complex64,
+}
+
+impl PyPayload for PyComplex {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.complex_type
+    }
+}
+
+impl ToPyObject for Complex64 {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        PyComplex::from(self).to_pyobject(vm)
+    }
+}
+
+impl From<Complex64> for PyComplex {
+    fn from(value: Complex64) -> Self {
+        Self { value }
+    }
+}
+
+impl PyObjectRef {
+    /// Tries converting a python object into a complex, returns an option of whether the complex
+    /// and whether the  object was a complex originally or coerced into one
+    pub fn try_complex(&self, vm: &VirtualMachine) -> PyResult<Option<(Complex64, bool)>> {
+        if let Some(complex) = self.downcast_ref_if_exact::<PyComplex>(vm) {
+            return Ok(Some((complex.value, true)));
+        }
+        if let Some(method) = vm.get_method(self.clone(), identifier!(vm, __complex__)) {
+            let result = method?.call((), vm)?;
+
+            let ret_class = result.class().to_owned();
+            if let Some(ret) = result.downcast_ref::<PyComplex>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__complex__ returned non-complex (type {ret_class}).  \
+                    The ability to return an instance of a strict subclass of complex \
+                    is deprecated, and may be removed in a future version of Python."
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                return Ok(Some((ret.value, true)));
+            } else {
+                return match result.downcast_ref::<PyComplex>() {
+                    Some(complex_obj) => Ok(Some((complex_obj.value, true))),
+                    None => Err(vm.new_type_error(format!(
+                        "__complex__ returned non-complex (type '{}')",
+                        result.class().name()
+                    ))),
+                };
+            }
+        }
+        // `complex` does not have a `__complex__` by default, so subclasses might not either,
+        // use the actual stored value in this case
+        if let Some(complex) = self.downcast_ref::<PyComplex>() {
+            return Ok(Some((complex.value, true)));
+        }
+        if let Some(float) = self.try_float_opt(vm) {
+            return Ok(Some((Complex64::new(float?.to_f64(), 0.0), false)));
+        }
+        Ok(None)
+    }
+}
+
+pub fn init(context: &Context) {
+    PyComplex::extend_class(context, context.types.complex_type);
+}
+
+fn to_op_complex(value: &PyObject, vm: &VirtualMachine) -> PyResult<Option<Complex64>> {
+    let r = if let Some(complex) = value.downcast_ref::<PyComplex>() {
+        Some(complex.value)
+    } else {
+        float::to_op_float(value, vm)?.map(|float| Complex64::new(float, 0.0))
+    };
+    Ok(r)
+}
+
+fn inner_div(v1: Complex64, v2: Complex64, vm: &VirtualMachine) -> PyResult<Complex64> {
+    if v2.is_zero() {
+        return Err(vm.new_zero_division_error("complex division by zero"));
+    }
+
+    Ok(v1.fdiv(v2))
+}
+
+fn inner_pow(v1: Complex64, v2: Complex64, vm: &VirtualMachine) -> PyResult<Complex64> {
+    if v1.is_zero() {
+        return if v2.re < 0.0 || v2.im != 0.0 {
+            let msg = format!("{v1} cannot be raised to a negative or complex power");
+            Err(vm.new_zero_division_error(msg))
+        } else if v2.is_zero() {
+            Ok(Complex64::new(1.0, 0.0))
+        } else {
+            Ok(Complex64::new(0.0, 0.0))
+        };
+    }
+
+    let ans = powc(v1, v2);
+    if ans.is_infinite() && !(v1.is_infinite() || v2.is_infinite()) {
+        Err(vm.new_overflow_error("complex exponentiation overflow"))
+    } else {
+        Ok(ans)
+    }
+}
+
+// num-complex changed their powc() implementation in 0.4.4, making it incompatible
+// with what the regression tests expect. this is that old formula.
+fn powc(a: Complex64, exp: Complex64) -> Complex64 {
+    let (r, theta) = a.to_polar();
+    if r.is_zero() {
+        return Complex64::new(r, r);
+    }
+    Complex64::from_polar(
+        r.powf(exp.re) * (-exp.im * theta).exp(),
+        exp.re * theta + exp.im * r.ln(),
+    )
+}
+
+impl Constructor for PyComplex {
+    type Args = ComplexArgs;
+
+    fn slot_new(cls: PyTypeRef, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Optimization: return exact complex as-is (only when imag is not provided)
+        if cls.is(vm.ctx.types.complex_type)
+            && func_args.args.len() == 1
+            && func_args.kwargs.is_empty()
+            && func_args.args[0].class().is(vm.ctx.types.complex_type)
+        {
+            return Ok(func_args.args[0].clone());
+        }
+
+        let args: Self::Args = func_args.bind(vm)?;
+        let payload = Self::py_new(&cls, args, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        let imag_missing = args.imag.is_missing();
+        let (real, real_was_complex) = match args.real {
+            OptionalArg::Missing => (Complex64::new(0.0, 0.0), false),
+            OptionalArg::Present(val) => {
+                if let Some(c) = val.try_complex(vm)? {
+                    c
+                } else if let Some(s) = val.downcast_ref::<PyStr>() {
+                    if args.imag.is_present() {
+                        return Err(vm.new_type_error(
+                            "complex() can't take second arg if first is a string",
+                        ));
+                    }
+                    let (re, im) = s
+                        .to_str()
+                        .and_then(rustpython_literal::complex::parse_str)
+                        .ok_or_else(|| vm.new_value_error("complex() arg is a malformed string"))?;
+                    return Ok(Self::from(Complex64 { re, im }));
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "complex() first argument must be a string or a number, not '{}'",
+                        val.class().name()
+                    )));
+                }
+            }
+        };
+
+        let (imag, imag_was_complex) = match args.imag {
+            // Copy the imaginary from the real to the real of the imaginary
+            // if an  imaginary argument is not passed in
+            OptionalArg::Missing => (Complex64::new(real.im, 0.0), false),
+            OptionalArg::Present(obj) => {
+                if let Some(c) = obj.try_complex(vm)? {
+                    c
+                } else if obj.class().fast_issubclass(vm.ctx.types.str_type) {
+                    return Err(vm.new_type_error("complex() second arg can't be a string"));
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "complex() second argument must be a number, not '{}'",
+                        obj.class().name()
+                    )));
+                }
+            }
+        };
+
+        let final_real = if imag_was_complex {
+            real.re - imag.im
+        } else {
+            real.re
+        };
+
+        let final_imag = if real_was_complex && !imag_missing {
+            imag.re + real.im
+        } else {
+            imag.re
+        };
+        let value = Complex64::new(final_real, final_imag);
+        Ok(Self::from(value))
+    }
+}
+
+impl PyComplex {
+    #[deprecated(note = "use PyComplex::from(...).into_ref() instead")]
+    pub fn new_ref(value: Complex64, ctx: &Context) -> PyRef<Self> {
+        Self::from(value).into_ref(ctx)
+    }
+
+    pub const fn to_complex64(self) -> Complex64 {
+        self.value
+    }
+
+    pub const fn to_complex(&self) -> Complex64 {
+        self.value
+    }
+
+    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
+    where
+        F: FnOnce(Complex64, Complex64, &VirtualMachine) -> R,
+        R: ToPyResult,
+    {
+        if let (Some(a), Some(b)) = (to_op_complex(a, vm)?, to_op_complex(b, vm)?) {
+            op(a, b, vm).to_pyresult(vm)
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE),
+    with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
+)]
+impl PyComplex {
+    #[pygetset]
+    const fn real(&self) -> f64 {
+        self.value.re
+    }
+
+    #[pygetset]
+    const fn imag(&self) -> f64 {
+        self.value.im
+    }
+
+    #[pymethod]
+    fn conjugate(&self) -> Complex64 {
+        self.value.conj()
+    }
+
+    #[pymethod]
+    const fn __getnewargs__(&self) -> (f64, f64) {
+        let Complex64 { re, im } = self.value;
+        (re, im)
+    }
+
+    #[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))
+            .map_err(|err| err.into_pyexception(vm))
+    }
+}
+
+#[pyclass]
+impl PyRef<PyComplex> {
+    #[pymethod]
+    fn __complex__(self, vm: &VirtualMachine) -> Self {
+        if self.is(vm.ctx.types.complex_type) {
+            self
+        } else {
+            PyComplex::from(self.value).into_ref(&vm.ctx)
+        }
+    }
+}
+
+impl Comparable for PyComplex {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> 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
+                }
+            } else {
+                match float::to_op_float(other, vm) {
+                    Ok(Some(other)) => zelf.value == other.into(),
+                    Err(_) => false,
+                    Ok(None) => return Ok(PyComparisonValue::NotImplemented),
+                }
+            };
+            Ok(PyComparisonValue::Implemented(result))
+        })
+    }
+}
+
+impl Hashable for PyComplex {
+    #[inline]
+    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        let value = zelf.value;
+
+        let re_hash =
+            hash::hash_float(value.re).unwrap_or_else(|| hash::hash_object_id(zelf.get_id()));
+
+        let im_hash =
+            hash::hash_float(value.im).unwrap_or_else(|| hash::hash_object_id(zelf.get_id()));
+
+        let Wrapping(ret) = Wrapping(re_hash) + Wrapping(im_hash) * Wrapping(hash::IMAG);
+        Ok(hash::fix_sentinel(ret))
+    }
+}
+
+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)),
+            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) {
+                    PyComplex::number_op(a, b, inner_pow, vm)
+                } else {
+                    Err(vm.new_value_error(String::from("complex modulo")))
+                }
+            }),
+            negative: Some(|number, vm| {
+                let value = PyComplex::number_downcast(number).value;
+                (-value).to_pyresult(vm)
+            }),
+            positive: Some(|number, vm| {
+                PyComplex::number_downcast_exact(number, vm).to_pyresult(vm)
+            }),
+            absolute: Some(|number, vm| {
+                let value = PyComplex::number_downcast(number).value;
+                let result = value.norm();
+                // Check for overflow: hypot returns inf for finite inputs that overflow
+                if result.is_infinite() && value.re.is_finite() && value.im.is_finite() {
+                    return Err(vm.new_overflow_error("absolute value too large".to_owned()));
+                }
+                result.to_pyresult(vm)
+            }),
+            boolean: Some(|number, _vm| Ok(!PyComplex::number_downcast(number).value.is_zero())),
+            true_divide: Some(|a, b, vm| PyComplex::number_op(a, b, inner_div, vm)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+
+    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
+        vm.ctx.new_complex(zelf.value)
+    }
+}
+
+impl Representable for PyComplex {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        // TODO: when you fix this, move it to rustpython_common::complex::repr and update
+        //       ast/src/unparse.rs + impl Display for Constant in ast/src/constant.rs
+        let Complex64 { re, im } = zelf.value;
+        Ok(rustpython_literal::complex::to_string(re, im))
+    }
+}
+
+#[derive(FromArgs)]
+pub struct ComplexArgs {
+    #[pyarg(any, optional)]
+    real: OptionalArg<PyObjectRef>,
+    #[pyarg(any, optional)]
+    imag: OptionalArg<PyObjectRef>,
+}
diff --git a/crates/vm/src/builtins/coroutine.rs b/crates/vm/src/builtins/coroutine.rs
new file mode 100644
index 0000000000..9e8d5d534f
--- /dev/null
+++ b/crates/vm/src/builtins/coroutine.rs
@@ -0,0 +1,211 @@
+use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
+use crate::{
+    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    coroutine::{Coro, warn_deprecated_throw_signature},
+    frame::FrameRef,
+    function::OptionalArg,
+    protocol::PyIterReturn,
+    types::{IterNext, Iterable, Representable, SelfIter},
+};
+use crossbeam_utils::atomic::AtomicCell;
+
+#[pyclass(module = false, name = "coroutine")]
+#[derive(Debug)]
+// PyCoro_Type in CPython
+pub struct PyCoroutine {
+    inner: Coro,
+}
+
+impl PyPayload for PyCoroutine {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.coroutine_type
+    }
+}
+
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Representable))]
+impl PyCoroutine {
+    pub const fn as_coro(&self) -> &Coro {
+        &self.inner
+    }
+
+    pub fn new(frame: FrameRef, name: PyStrRef, qualname: PyStrRef) -> Self {
+        Self {
+            inner: Coro::new(frame, name, qualname),
+        }
+    }
+
+    #[pygetset]
+    fn __name__(&self) -> PyStrRef {
+        self.inner.name()
+    }
+
+    #[pygetset(setter)]
+    fn set___name__(&self, name: PyStrRef) {
+        self.inner.set_name(name)
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> PyStrRef {
+        self.inner.qualname()
+    }
+
+    #[pygetset(setter)]
+    fn set___qualname__(&self, qualname: PyStrRef) {
+        self.inner.set_qualname(qualname)
+    }
+
+    #[pymethod(name = "__await__")]
+    fn r#await(zelf: PyRef<Self>) -> PyCoroutineWrapper {
+        PyCoroutineWrapper {
+            coro: zelf,
+            closed: AtomicCell::new(false),
+        }
+    }
+
+    #[pygetset]
+    fn cr_await(&self, _vm: &VirtualMachine) -> Option<PyObjectRef> {
+        self.inner.frame().yield_from_target()
+    }
+    #[pygetset]
+    fn cr_frame(&self, _vm: &VirtualMachine) -> FrameRef {
+        self.inner.frame()
+    }
+    #[pygetset]
+    fn cr_running(&self, _vm: &VirtualMachine) -> bool {
+        self.inner.running()
+    }
+    #[pygetset]
+    fn cr_code(&self, _vm: &VirtualMachine) -> PyRef<PyCode> {
+        self.inner.frame().code.clone()
+    }
+    // TODO: coroutine origin tracking:
+    // https://docs.python.org/3/library/sys.html#sys.set_coroutine_origin_tracking_depth
+    #[pygetset]
+    const fn cr_origin(&self, _vm: &VirtualMachine) -> Option<(PyStrRef, usize, PyStrRef)> {
+        None
+    }
+
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+}
+
+#[pyclass]
+impl Py<PyCoroutine> {
+    #[pymethod]
+    fn send(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        self.inner.send(self.as_object(), value, vm)
+    }
+
+    #[pymethod]
+    fn throw(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        exc_tb: OptionalArg,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
+        self.inner.throw(
+            self.as_object(),
+            exc_type,
+            exc_val.unwrap_or_none(vm),
+            exc_tb.unwrap_or_none(vm),
+            vm,
+        )
+    }
+
+    #[pymethod]
+    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+        self.inner.close(self.as_object(), vm)
+    }
+}
+
+impl Representable for PyCoroutine {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
+    }
+}
+
+impl SelfIter for PyCoroutine {}
+impl IterNext for PyCoroutine {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        zelf.send(vm.ctx.none(), vm)
+    }
+}
+
+#[pyclass(module = false, name = "coroutine_wrapper")]
+#[derive(Debug)]
+// PyCoroWrapper_Type in CPython
+pub struct PyCoroutineWrapper {
+    coro: PyRef<PyCoroutine>,
+    closed: AtomicCell<bool>,
+}
+
+impl PyPayload for PyCoroutineWrapper {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.coroutine_wrapper_type
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyCoroutineWrapper {
+    fn check_closed(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if self.closed.load() {
+            return Err(vm.new_runtime_error("cannot reuse already awaited coroutine"));
+        }
+        Ok(())
+    }
+
+    #[pymethod]
+    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        self.check_closed(vm)?;
+        let result = self.coro.send(val, vm);
+        // Mark as closed if exhausted
+        if let Ok(PyIterReturn::StopIteration(_)) = &result {
+            self.closed.store(true);
+        }
+        result
+    }
+
+    #[pymethod]
+    fn throw(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: OptionalArg,
+        exc_tb: OptionalArg,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        self.check_closed(vm)?;
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
+        let result = self.coro.throw(exc_type, exc_val, exc_tb, vm);
+        // Mark as closed if exhausted
+        if let Ok(PyIterReturn::StopIteration(_)) = &result {
+            self.closed.store(true);
+        }
+        result
+    }
+
+    #[pymethod]
+    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
+        self.closed.store(true);
+        self.coro.close(vm)
+    }
+}
+
+impl SelfIter for PyCoroutineWrapper {}
+impl IterNext for PyCoroutineWrapper {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        Self::send(zelf, vm.ctx.none(), vm)
+    }
+}
+
+pub fn init(ctx: &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
new file mode 100644
index 0000000000..89dafdd14b
--- /dev/null
+++ b/crates/vm/src/builtins/descriptor.rs
@@ -0,0 +1,873 @@
+use super::{PyStr, PyStrInterned, PyType};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
+    class::PyClassImpl,
+    common::hash::PyHash,
+    convert::{ToPyObject, ToPyResult},
+    function::{ArgSize, FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
+    protocol::{PyNumberBinaryFunc, PyNumberTernaryFunc, PyNumberUnaryFunc},
+    types::{
+        Callable, Comparable, DelFunc, DescrGetFunc, DescrSetFunc, GenericMethod, GetDescriptor,
+        GetattroFunc, HashFunc, Hashable, InitFunc, IterFunc, IterNextFunc, MapAssSubscriptFunc,
+        MapLenFunc, MapSubscriptFunc, PyComparisonOp, Representable, RichCompareFunc,
+        SeqAssItemFunc, SeqConcatFunc, SeqContainsFunc, SeqItemFunc, SeqLenFunc, SeqRepeatFunc,
+        SetattroFunc, StringifyFunc,
+    },
+};
+use rustpython_common::lock::PyRwLock;
+
+#[derive(Debug)]
+pub struct PyDescriptor {
+    pub typ: &'static Py<PyType>,
+    pub name: &'static PyStrInterned,
+    pub qualname: PyRwLock<Option<String>>,
+}
+
+#[derive(Debug)]
+pub struct PyDescriptorOwned {
+    pub typ: PyRef<PyType>,
+    pub name: &'static PyStrInterned,
+    pub qualname: PyRwLock<Option<String>>,
+}
+
+#[pyclass(name = "method_descriptor", module = false)]
+pub struct PyMethodDescriptor {
+    pub common: PyDescriptor,
+    pub method: &'static PyMethodDef,
+    // vectorcall: vector_call_func,
+    pub objclass: &'static Py<PyType>, // TODO: move to tp_members
+}
+
+impl PyMethodDescriptor {
+    pub fn new(method: &'static PyMethodDef, typ: &'static Py<PyType>, ctx: &Context) -> Self {
+        Self {
+            common: PyDescriptor {
+                typ,
+                name: ctx.intern_str(method.name),
+                qualname: PyRwLock::new(None),
+            },
+            method,
+            objclass: typ,
+        }
+    }
+}
+
+impl PyPayload for PyMethodDescriptor {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.method_descriptor_type
+    }
+}
+
+impl core::fmt::Debug for PyMethodDescriptor {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "method descriptor for '{}'", self.common.name)
+    }
+}
+
+impl GetDescriptor for PyMethodDescriptor {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let descr = Self::_as_pyref(&zelf, vm).unwrap();
+        let bound = match obj {
+            Some(obj) => {
+                if descr.method.flags.contains(PyMethodFlags::METHOD) {
+                    if cls.is_some_and(|c| c.fast_isinstance(vm.ctx.types.type_type)) {
+                        obj
+                    } else {
+                        return Err(vm.new_type_error(format!(
+                            "descriptor '{}' needs a type, not '{}', as arg 2",
+                            descr.common.name.as_str(),
+                            obj.class().name()
+                        )));
+                    }
+                } else if descr.method.flags.contains(PyMethodFlags::CLASS) {
+                    obj.class().to_owned().into()
+                } else {
+                    unimplemented!()
+                }
+            }
+            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())
+    }
+}
+
+impl Callable for PyMethodDescriptor {
+    type Args = FuncArgs;
+    #[inline]
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        (zelf.method.func)(vm, args)
+    }
+}
+
+impl PyMethodDescriptor {
+    pub fn bind(&self, obj: PyObjectRef, ctx: &Context) -> PyRef<PyNativeMethod> {
+        self.method.build_bound_method(ctx, obj, self.common.typ)
+    }
+}
+
+#[pyclass(
+    with(GetDescriptor, Callable, Representable),
+    flags(METHOD_DESCRIPTOR, DISALLOW_INSTANTIATION)
+)]
+impl PyMethodDescriptor {
+    #[pygetset]
+    const fn __name__(&self) -> &'static PyStrInterned {
+        self.common.name
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> String {
+        format!("{}.{}", self.common.typ.name(), &self.common.name)
+    }
+
+    #[pygetset]
+    const fn __doc__(&self) -> Option<&'static str> {
+        self.method.doc
+    }
+
+    #[pygetset]
+    fn __text_signature__(&self) -> Option<String> {
+        self.method.doc.and_then(|doc| {
+            type_::get_text_signature_from_internal_doc(self.method.name, doc)
+                .map(|signature| signature.to_string())
+        })
+    }
+
+    #[pygetset]
+    fn __objclass__(&self) -> PyTypeRef {
+        self.objclass.to_owned()
+    }
+
+    #[pymethod]
+    fn __reduce__(
+        &self,
+        vm: &VirtualMachine,
+    ) -> (Option<PyObjectRef>, (Option<PyObjectRef>, &'static str)) {
+        let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
+        let classname = vm.builtins.get_attr(&self.common.typ.__name__(vm), vm).ok();
+        (builtins_getattr, (classname, self.method.name))
+    }
+}
+
+impl Representable for PyMethodDescriptor {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<method '{}' of '{}' objects>",
+            &zelf.method.name,
+            zelf.common.typ.name()
+        ))
+    }
+}
+
+#[derive(Debug)]
+pub enum MemberKind {
+    Bool = 14,
+    ObjectEx = 16,
+}
+
+pub type MemberSetterFunc = Option<fn(&VirtualMachine, PyObjectRef, PySetterValue) -> PyResult<()>>;
+
+pub enum MemberGetter {
+    Getter(fn(&VirtualMachine, PyObjectRef) -> PyResult),
+    Offset(usize),
+}
+
+pub enum MemberSetter {
+    Setter(MemberSetterFunc),
+    Offset(usize),
+}
+
+pub struct PyMemberDef {
+    pub name: String,
+    pub kind: MemberKind,
+    pub getter: MemberGetter,
+    pub setter: MemberSetter,
+    pub doc: Option<String>,
+}
+
+impl PyMemberDef {
+    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        match self.getter {
+            MemberGetter::Getter(getter) => (getter)(vm, obj),
+            MemberGetter::Offset(offset) => get_slot_from_object(obj, offset, self, vm),
+        }
+    }
+
+    fn set(
+        &self,
+        obj: PyObjectRef,
+        value: PySetterValue<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match self.setter {
+            MemberSetter::Setter(setter) => match setter {
+                Some(setter) => (setter)(vm, obj, value),
+                None => Err(vm.new_attribute_error("readonly attribute")),
+            },
+            MemberSetter::Offset(offset) => set_slot_at_object(obj, offset, self, value, vm),
+        }
+    }
+}
+
+impl core::fmt::Debug for PyMemberDef {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyMemberDef")
+            .field("name", &self.name)
+            .field("kind", &self.kind)
+            .field("doc", &self.doc)
+            .finish()
+    }
+}
+
+// = PyMemberDescrObject
+#[pyclass(name = "member_descriptor", module = false)]
+#[derive(Debug)]
+pub struct PyMemberDescriptor {
+    pub common: PyDescriptorOwned,
+    pub member: PyMemberDef,
+}
+
+impl PyPayload for PyMemberDescriptor {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.member_descriptor_type
+    }
+}
+
+fn calculate_qualname(descr: &PyDescriptorOwned, vm: &VirtualMachine) -> PyResult<Option<String>> {
+    if let Some(qualname) = vm.get_attribute_opt(descr.typ.clone().into(), "__qualname__")? {
+        let str = qualname.downcast::<PyStr>().map_err(|_| {
+            vm.new_type_error("<descriptor>.__objclass__.__qualname__ is not a unicode object")
+        })?;
+        Ok(Some(format!("{}.{}", str, descr.name)))
+    } else {
+        Ok(None)
+    }
+}
+
+#[pyclass(
+    with(GetDescriptor, Representable),
+    flags(BASETYPE, DISALLOW_INSTANTIATION)
+)]
+impl PyMemberDescriptor {
+    #[pygetset]
+    fn __doc__(&self) -> Option<String> {
+        self.member.doc.to_owned()
+    }
+
+    #[pygetset]
+    fn __qualname__(&self, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        let qualname = self.common.qualname.read();
+        Ok(if qualname.is_none() {
+            drop(qualname);
+            let calculated = calculate_qualname(&self.common, vm)?;
+            calculated.clone_into(&mut self.common.qualname.write());
+            calculated
+        } else {
+            qualname.to_owned()
+        })
+    }
+
+    #[pyslot]
+    fn descr_set(
+        zelf: &PyObject,
+        obj: PyObjectRef,
+        value: PySetterValue<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let zelf = Self::_as_pyref(zelf, vm)?;
+
+        if !obj.class().fast_issubclass(&zelf.common.typ) {
+            return Err(vm.new_type_error(format!(
+                "descriptor '{}' for '{}' objects doesn't apply to a '{}' object",
+                zelf.common.name,
+                zelf.common.typ.name(),
+                obj.class().name()
+            )));
+        }
+
+        zelf.member.set(obj, value, vm)
+    }
+}
+
+// PyMember_GetOne
+fn get_slot_from_object(
+    obj: PyObjectRef,
+    offset: usize,
+    member: &PyMemberDef,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let slot = match member.kind {
+        MemberKind::Bool => obj
+            .get_slot(offset)
+            .unwrap_or_else(|| vm.ctx.new_bool(false).into()),
+        MemberKind::ObjectEx => obj.get_slot(offset).ok_or_else(|| {
+            vm.new_no_attribute_error(obj.clone(), vm.ctx.new_str(member.name.clone()))
+        })?,
+    };
+    Ok(slot)
+}
+
+// PyMember_SetOne
+fn set_slot_at_object(
+    obj: PyObjectRef,
+    offset: usize,
+    member: &PyMemberDef,
+    value: PySetterValue,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    match member.kind {
+        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,
+            };
+            obj.set_slot(offset, value);
+        }
+    }
+
+    Ok(())
+}
+
+impl Representable for PyMemberDescriptor {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<member '{}' of '{}' objects>",
+            zelf.common.name,
+            zelf.common.typ.name(),
+        ))
+    }
+}
+
+impl GetDescriptor for PyMemberDescriptor {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: 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());
+                }
+                Ok(zelf)
+            }
+        }
+    }
+}
+
+pub fn init(ctx: &Context) {
+    PyMemberDescriptor::extend_class(ctx, ctx.types.member_descriptor_type);
+    PyMethodDescriptor::extend_class(ctx, ctx.types.method_descriptor_type);
+    PyWrapper::extend_class(ctx, ctx.types.wrapper_descriptor_type);
+    PyMethodWrapper::extend_class(ctx, ctx.types.method_wrapper_type);
+}
+
+// PyWrapper - wrapper_descriptor
+
+/// Each variant knows how to call the wrapped function with proper types
+#[derive(Clone, Copy)]
+pub enum SlotFunc {
+    // Basic slots
+    Init(InitFunc),
+    Hash(HashFunc),
+    Str(StringifyFunc),
+    Repr(StringifyFunc),
+    Iter(IterFunc),
+    IterNext(IterNextFunc),
+    Call(GenericMethod),
+    Del(DelFunc),
+
+    // Attribute access slots
+    GetAttro(GetattroFunc),
+    SetAttro(SetattroFunc), // __setattr__
+    DelAttro(SetattroFunc), // __delattr__ (same func type, different PySetterValue)
+
+    // Rich comparison slots (with comparison op)
+    RichCompare(RichCompareFunc, PyComparisonOp),
+
+    // Descriptor slots
+    DescrGet(DescrGetFunc),
+    DescrSet(DescrSetFunc), // __set__
+    DescrDel(DescrSetFunc), // __delete__ (same func type, different PySetterValue)
+
+    // Sequence sub-slots (sq_*)
+    SeqLength(SeqLenFunc),
+    SeqConcat(SeqConcatFunc),
+    SeqRepeat(SeqRepeatFunc),
+    SeqItem(SeqItemFunc),
+    SeqSetItem(SeqAssItemFunc), // __setitem__ (same func type, value = Some)
+    SeqDelItem(SeqAssItemFunc), // __delitem__ (same func type, value = None)
+    SeqContains(SeqContainsFunc),
+
+    // Mapping sub-slots (mp_*)
+    MapLength(MapLenFunc),
+    MapSubscript(MapSubscriptFunc),
+    MapSetSubscript(MapAssSubscriptFunc), // __setitem__ (same func type, value = Some)
+    MapDelSubscript(MapAssSubscriptFunc), // __delitem__ (same func type, value = None)
+
+    // Number sub-slots (nb_*) - grouped by signature
+    NumBoolean(PyNumberUnaryFunc<bool>),  // __bool__
+    NumUnary(PyNumberUnaryFunc),          // __int__, __float__, __index__
+    NumBinary(PyNumberBinaryFunc),        // __add__, __sub__, __mul__, etc.
+    NumBinaryRight(PyNumberBinaryFunc),   // __radd__, __rsub__, etc. (swapped args)
+    NumTernary(PyNumberTernaryFunc),      // __pow__
+    NumTernaryRight(PyNumberTernaryFunc), // __rpow__ (swapped first two args)
+}
+
+impl core::fmt::Debug for SlotFunc {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            SlotFunc::Init(_) => write!(f, "SlotFunc::Init(...)"),
+            SlotFunc::Hash(_) => write!(f, "SlotFunc::Hash(...)"),
+            SlotFunc::Str(_) => write!(f, "SlotFunc::Str(...)"),
+            SlotFunc::Repr(_) => write!(f, "SlotFunc::Repr(...)"),
+            SlotFunc::Iter(_) => write!(f, "SlotFunc::Iter(...)"),
+            SlotFunc::IterNext(_) => write!(f, "SlotFunc::IterNext(...)"),
+            SlotFunc::Call(_) => write!(f, "SlotFunc::Call(...)"),
+            SlotFunc::Del(_) => write!(f, "SlotFunc::Del(...)"),
+            SlotFunc::GetAttro(_) => write!(f, "SlotFunc::GetAttro(...)"),
+            SlotFunc::SetAttro(_) => write!(f, "SlotFunc::SetAttro(...)"),
+            SlotFunc::DelAttro(_) => write!(f, "SlotFunc::DelAttro(...)"),
+            SlotFunc::RichCompare(_, op) => write!(f, "SlotFunc::RichCompare(..., {:?})", op),
+            SlotFunc::DescrGet(_) => write!(f, "SlotFunc::DescrGet(...)"),
+            SlotFunc::DescrSet(_) => write!(f, "SlotFunc::DescrSet(...)"),
+            SlotFunc::DescrDel(_) => write!(f, "SlotFunc::DescrDel(...)"),
+            // Sequence sub-slots
+            SlotFunc::SeqLength(_) => write!(f, "SlotFunc::SeqLength(...)"),
+            SlotFunc::SeqConcat(_) => write!(f, "SlotFunc::SeqConcat(...)"),
+            SlotFunc::SeqRepeat(_) => write!(f, "SlotFunc::SeqRepeat(...)"),
+            SlotFunc::SeqItem(_) => write!(f, "SlotFunc::SeqItem(...)"),
+            SlotFunc::SeqSetItem(_) => write!(f, "SlotFunc::SeqSetItem(...)"),
+            SlotFunc::SeqDelItem(_) => write!(f, "SlotFunc::SeqDelItem(...)"),
+            SlotFunc::SeqContains(_) => write!(f, "SlotFunc::SeqContains(...)"),
+            // Mapping sub-slots
+            SlotFunc::MapLength(_) => write!(f, "SlotFunc::MapLength(...)"),
+            SlotFunc::MapSubscript(_) => write!(f, "SlotFunc::MapSubscript(...)"),
+            SlotFunc::MapSetSubscript(_) => write!(f, "SlotFunc::MapSetSubscript(...)"),
+            SlotFunc::MapDelSubscript(_) => write!(f, "SlotFunc::MapDelSubscript(...)"),
+            // Number sub-slots
+            SlotFunc::NumBoolean(_) => write!(f, "SlotFunc::NumBoolean(...)"),
+            SlotFunc::NumUnary(_) => write!(f, "SlotFunc::NumUnary(...)"),
+            SlotFunc::NumBinary(_) => write!(f, "SlotFunc::NumBinary(...)"),
+            SlotFunc::NumBinaryRight(_) => write!(f, "SlotFunc::NumBinaryRight(...)"),
+            SlotFunc::NumTernary(_) => write!(f, "SlotFunc::NumTernary(...)"),
+            SlotFunc::NumTernaryRight(_) => write!(f, "SlotFunc::NumTernaryRight(...)"),
+        }
+    }
+}
+
+impl SlotFunc {
+    /// Call the wrapped slot function with proper type handling
+    pub fn call(&self, obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        match self {
+            SlotFunc::Init(func) => {
+                func(obj, args, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::Hash(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__hash__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                let hash = func(&obj, vm)?;
+                Ok(vm.ctx.new_int(hash).into())
+            }
+            SlotFunc::Repr(func) | SlotFunc::Str(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    let name = match self {
+                        SlotFunc::Repr(_) => "__repr__",
+                        SlotFunc::Str(_) => "__str__",
+                        _ => unreachable!(),
+                    };
+                    return Err(vm.new_type_error(format!("{name}() takes no arguments (1 given)")));
+                }
+                let s = func(&obj, vm)?;
+                Ok(s.into())
+            }
+            SlotFunc::Iter(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__iter__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(obj, vm)
+            }
+            SlotFunc::IterNext(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__next__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(&obj, vm).to_pyresult(vm)
+            }
+            SlotFunc::Call(func) => func(&obj, args, vm),
+            SlotFunc::Del(func) => {
+                if !args.args.is_empty() || !args.kwargs.is_empty() {
+                    return Err(
+                        vm.new_type_error("__del__() takes no arguments (1 given)".to_owned())
+                    );
+                }
+                func(&obj, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::GetAttro(func) => {
+                let (name,): (PyRef<PyStr>,) = args.bind(vm)?;
+                func(&obj, &name, vm)
+            }
+            SlotFunc::SetAttro(func) => {
+                let (name, value): (PyRef<PyStr>, PyObjectRef) = args.bind(vm)?;
+                func(&obj, &name, PySetterValue::Assign(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::DelAttro(func) => {
+                let (name,): (PyRef<PyStr>,) = args.bind(vm)?;
+                func(&obj, &name, PySetterValue::Delete, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::RichCompare(func, op) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, &other, *op, vm).map(|r| match r {
+                    crate::function::Either::A(obj) => obj,
+                    crate::function::Either::B(cmp_val) => cmp_val.to_pyobject(vm),
+                })
+            }
+            SlotFunc::DescrGet(func) => {
+                let (instance, owner): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let owner = owner.into_option();
+                let instance_opt = if vm.is_none(&instance) {
+                    None
+                } else {
+                    Some(instance)
+                };
+                func(obj, instance_opt, owner, vm)
+            }
+            SlotFunc::DescrSet(func) => {
+                let (instance, value): (PyObjectRef, PyObjectRef) = args.bind(vm)?;
+                func(&obj, instance, PySetterValue::Assign(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::DescrDel(func) => {
+                let (instance,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, instance, PySetterValue::Delete, vm)?;
+                Ok(vm.ctx.none())
+            }
+            // Sequence sub-slots
+            SlotFunc::SeqLength(func) => {
+                args.bind::<()>(vm)?;
+                let len = func(obj.sequence_unchecked(), vm)?;
+                Ok(vm.ctx.new_int(len).into())
+            }
+            SlotFunc::SeqConcat(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), &other, vm)
+            }
+            SlotFunc::SeqRepeat(func) => {
+                let (n,): (ArgSize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), n.into(), vm)
+            }
+            SlotFunc::SeqItem(func) => {
+                let (index,): (isize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, vm)
+            }
+            SlotFunc::SeqSetItem(func) => {
+                let (index, value): (isize, PyObjectRef) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, Some(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::SeqDelItem(func) => {
+                let (index,): (isize,) = args.bind(vm)?;
+                func(obj.sequence_unchecked(), index, None, vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::SeqContains(func) => {
+                let (item,): (PyObjectRef,) = args.bind(vm)?;
+                let result = func(obj.sequence_unchecked(), &item, vm)?;
+                Ok(vm.ctx.new_bool(result).into())
+            }
+            // Mapping sub-slots
+            SlotFunc::MapLength(func) => {
+                args.bind::<()>(vm)?;
+                let len = func(obj.mapping_unchecked(), vm)?;
+                Ok(vm.ctx.new_int(len).into())
+            }
+            SlotFunc::MapSubscript(func) => {
+                let (key,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, vm)
+            }
+            SlotFunc::MapSetSubscript(func) => {
+                let (key, value): (PyObjectRef, PyObjectRef) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, Some(value), vm)?;
+                Ok(vm.ctx.none())
+            }
+            SlotFunc::MapDelSubscript(func) => {
+                let (key,): (PyObjectRef,) = args.bind(vm)?;
+                func(obj.mapping_unchecked(), &key, None, vm)?;
+                Ok(vm.ctx.none())
+            }
+            // Number sub-slots
+            SlotFunc::NumBoolean(func) => {
+                args.bind::<()>(vm)?;
+                let result = func(obj.number(), vm)?;
+                Ok(vm.ctx.new_bool(result).into())
+            }
+            SlotFunc::NumUnary(func) => {
+                args.bind::<()>(vm)?;
+                func(obj.number(), vm)
+            }
+            SlotFunc::NumBinary(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&obj, &other, vm)
+            }
+            SlotFunc::NumBinaryRight(func) => {
+                let (other,): (PyObjectRef,) = args.bind(vm)?;
+                func(&other, &obj, vm) // Swapped: other op obj
+            }
+            SlotFunc::NumTernary(func) => {
+                let (y, z): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let z = z.unwrap_or_else(|| vm.ctx.none());
+                func(&obj, &y, &z, vm)
+            }
+            SlotFunc::NumTernaryRight(func) => {
+                let (y, z): (PyObjectRef, crate::function::OptionalArg<PyObjectRef>) =
+                    args.bind(vm)?;
+                let z = z.unwrap_or_else(|| vm.ctx.none());
+                func(&y, &obj, &z, vm) // Swapped: y ** obj % z
+            }
+        }
+    }
+}
+
+/// wrapper_descriptor: wraps a slot function as a Python method
+// = PyWrapperDescrObject
+#[pyclass(name = "wrapper_descriptor", module = false)]
+#[derive(Debug)]
+pub struct PyWrapper {
+    pub typ: &'static Py<PyType>,
+    pub name: &'static PyStrInterned,
+    pub wrapped: SlotFunc,
+    pub doc: Option<&'static str>,
+}
+
+impl PyPayload for PyWrapper {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.wrapper_descriptor_type
+    }
+}
+
+impl GetDescriptor for PyWrapper {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match obj {
+            None => Ok(zelf),
+            Some(obj) => {
+                let zelf = zelf.downcast::<Self>().unwrap();
+                Ok(PyMethodWrapper { wrapper: zelf, obj }.into_pyobject(vm))
+            }
+        }
+    }
+}
+
+impl Callable for PyWrapper {
+    type Args = FuncArgs;
+
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // list.__init__(l, [1,2,3]) form - first arg is self
+        let (obj, rest): (PyObjectRef, FuncArgs) = args.bind(vm)?;
+
+        if !obj.fast_isinstance(zelf.typ) {
+            return Err(vm.new_type_error(format!(
+                "descriptor '{}' requires a '{}' object but received a '{}'",
+                zelf.name.as_str(),
+                zelf.typ.name(),
+                obj.class().name()
+            )));
+        }
+
+        zelf.wrapped.call(obj, rest, vm)
+    }
+}
+
+#[pyclass(
+    with(GetDescriptor, Callable, Representable),
+    flags(DISALLOW_INSTANTIATION)
+)]
+impl PyWrapper {
+    #[pygetset]
+    fn __name__(&self) -> &'static PyStrInterned {
+        self.name
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> String {
+        format!("{}.{}", self.typ.name(), self.name)
+    }
+
+    #[pygetset]
+    fn __objclass__(&self) -> PyTypeRef {
+        self.typ.to_owned()
+    }
+
+    #[pygetset]
+    fn __doc__(&self) -> Option<&'static str> {
+        self.doc
+    }
+}
+
+impl Representable for PyWrapper {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<slot wrapper '{}' of '{}' objects>",
+            zelf.name.as_str(),
+            zelf.typ.name()
+        ))
+    }
+}
+
+// PyMethodWrapper - method-wrapper
+
+/// method-wrapper: a slot wrapper bound to an instance
+/// Returned when accessing l.__init__ on an instance
+#[pyclass(name = "method-wrapper", module = false, traverse)]
+#[derive(Debug)]
+pub struct PyMethodWrapper {
+    pub wrapper: PyRef<PyWrapper>,
+    #[pytraverse(skip)]
+    pub obj: PyObjectRef,
+}
+
+impl PyPayload for PyMethodWrapper {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.method_wrapper_type
+    }
+}
+
+impl Callable for PyMethodWrapper {
+    type Args = FuncArgs;
+
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // bpo-37619: Check type compatibility before calling wrapped slot
+        if !zelf.obj.fast_isinstance(zelf.wrapper.typ) {
+            return Err(vm.new_type_error(format!(
+                "descriptor '{}' requires a '{}' object but received a '{}'",
+                zelf.wrapper.name.as_str(),
+                zelf.wrapper.typ.name(),
+                zelf.obj.class().name()
+            )));
+        }
+        zelf.wrapper.wrapped.call(zelf.obj.clone(), args, vm)
+    }
+}
+
+#[pyclass(
+    with(Callable, Representable, Hashable, Comparable),
+    flags(DISALLOW_INSTANTIATION)
+)]
+impl PyMethodWrapper {
+    #[pygetset]
+    fn __self__(&self) -> PyObjectRef {
+        self.obj.clone()
+    }
+
+    #[pygetset]
+    fn __name__(&self) -> &'static PyStrInterned {
+        self.wrapper.name
+    }
+
+    #[pygetset]
+    fn __objclass__(&self) -> PyTypeRef {
+        self.wrapper.typ.to_owned()
+    }
+
+    #[pymethod]
+    fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+        let builtins_getattr = vm.builtins.get_attr("getattr", vm)?;
+        Ok(vm
+            .ctx
+            .new_tuple(vec![
+                builtins_getattr,
+                vm.ctx
+                    .new_tuple(vec![
+                        zelf.obj.clone(),
+                        vm.ctx.new_str(zelf.wrapper.name.as_str()).into(),
+                    ])
+                    .into(),
+            ])
+            .into())
+    }
+}
+
+impl Representable for PyMethodWrapper {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<method-wrapper '{}' of {} object at {:#x}>",
+            zelf.wrapper.name.as_str(),
+            zelf.obj.class().name(),
+            zelf.obj.get_id()
+        ))
+    }
+}
+
+impl Hashable for PyMethodWrapper {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        let obj_hash = zelf.obj.hash(vm)?;
+        let wrapper_hash = zelf.wrapper.as_object().get_id() as PyHash;
+        Ok(obj_hash ^ wrapper_hash)
+    }
+}
+
+impl Comparable for PyMethodWrapper {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<crate::function::PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let eq = zelf.wrapper.is(&other.wrapper) && vm.bool_eq(&zelf.obj, &other.obj)?;
+            Ok(eq.into())
+        })
+    }
+}
diff --git a/vm/src/builtins/dict.rs b/crates/vm/src/builtins/dict.rs
similarity index 93%
rename from vm/src/builtins/dict.rs
rename to crates/vm/src/builtins/dict.rs
index e59aa5bcf7..d1adb8a066 100644
--- a/vm/src/builtins/dict.rs
+++ b/crates/vm/src/builtins/dict.rs
@@ -19,12 +19,12 @@ use crate::{
     recursion::ReprGuard,
     types::{
         AsMapping, AsNumber, AsSequence, Callable, Comparable, Constructor, DefaultConstructor,
-        Initializer, IterNext, Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        Initializer, IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
     },
     vm::VirtualMachine,
 };
+use alloc::fmt;
 use rustpython_common::lock::PyMutex;
-use std::fmt;
 use std::sync::LazyLock;
 
 pub type DictContentType = dict_inner::Dict;
@@ -51,8 +51,9 @@ impl PyPayload for PyDict {
 }
 
 impl PyDict {
+    #[deprecated(note = "use PyDict::default().into_ref() instead")]
     pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::default(), ctx.types.dict_type.to_owned(), None)
+        Self::default().into_ref(ctx)
     }
 
     /// escape hatch to access the underlying data structure directly. prefer adding a method on
@@ -61,6 +62,24 @@ impl PyDict {
         &self.entries
     }
 
+    /// Returns all keys as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn keys_vec(&self) -> Vec<PyObjectRef> {
+        self.entries.keys()
+    }
+
+    /// Returns all values as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn values_vec(&self) -> Vec<PyObjectRef> {
+        self.entries.values()
+    }
+
+    /// Returns all items as a Vec, atomically under a single read lock.
+    /// Thread-safe: prevents "dictionary changed size during iteration" errors.
+    pub fn items_vec(&self) -> Vec<(PyObjectRef, PyObjectRef)> {
+        self.entries.items()
+    }
+
     // Used in update and ior.
     pub(crate) fn merge_object(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         let casted: Result<PyRefExact<Self>, _> = other.downcast_exact(vm);
@@ -69,13 +88,21 @@ impl PyDict {
             Err(other) => other,
         };
         let dict = &self.entries;
-        if let Some(keys) = vm.get_method(other.clone(), vm.ctx.intern_str("keys")) {
-            let keys = keys?.call((), vm)?.get_iter(vm)?;
-            while let PyIterReturn::Return(key) = keys.next(vm)? {
-                let val = other.get_item(&*key, vm)?;
-                dict.insert(vm, &*key, val)?;
+        // Use get_attr to properly invoke __getattribute__ for proxy objects
+        let keys_result = other.get_attr(vm.ctx.intern_str("keys"), vm);
+        let has_keys = match keys_result {
+            Ok(keys_method) => {
+                let keys = keys_method.call((), vm)?.get_iter(vm)?;
+                while let PyIterReturn::Return(key) = keys.next(vm)? {
+                    let val = other.get_item(&*key, vm)?;
+                    dict.insert(vm, &*key, val)?;
+                }
+                true
             }
-        } else {
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => false,
+            Err(e) => return Err(e),
+        };
+        if !has_keys {
             let iter = other.get_iter(vm)?;
             loop {
                 fn err(vm: &VirtualMachine) -> PyBaseExceptionRef {
@@ -175,7 +202,7 @@ impl PyDict {
         AsMapping,
         Representable
     ),
-    flags(BASETYPE)
+    flags(BASETYPE, MAPPING, _MATCH_SELF)
 )]
 impl PyDict {
     #[pyclassmethod]
@@ -203,22 +230,19 @@ impl PyDict {
         }
     }
 
-    #[pymethod]
     pub fn __len__(&self) -> usize {
         self.entries.len()
     }
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.entries.sizeof()
+        core::mem::size_of::<Self>() + self.entries.sizeof()
     }
 
-    #[pymethod]
     fn __contains__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self.entries.contains(vm, &*key)
     }
 
-    #[pymethod]
     fn __delitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self.inner_delitem(&*key, vm)
     }
@@ -228,7 +252,6 @@ impl PyDict {
         self.entries.clear()
     }
 
-    #[pymethod]
     fn __setitem__(
         &self,
         key: PyObjectRef,
@@ -279,13 +302,12 @@ impl PyDict {
         if let OptionalArg::Present(dict_obj) = dict_obj {
             self.merge_object(dict_obj, vm)?;
         }
-        for (key, value) in kwargs.into_iter() {
+        for (key, value) in kwargs {
             self.entries.insert(vm, &key, value)?;
         }
         Ok(())
     }
 
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let other_dict: Result<PyDictRef, _> = other.downcast();
         if let Ok(other) = other_dict {
@@ -366,7 +388,6 @@ impl Py<PyDict> {
         Ok(Implemented(true))
     }
 
-    #[pymethod]
     #[cfg_attr(feature = "flame-it", flame("PyDictRef"))]
     fn __getitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self.inner_getitem(&*key, vm)
@@ -395,13 +416,11 @@ impl PyRef<PyDict> {
         PyDictReverseKeyIterator::new(self)
     }
 
-    #[pymethod]
     fn __ior__(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
         self.merge_object(other, vm)?;
         Ok(self)
     }
 
-    #[pymethod]
     fn __ror__(self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let other_dict: Result<Self, _> = other.downcast();
         if let Ok(other) = other_dict {
@@ -750,12 +769,11 @@ impl ExactSizeIterator for DictIter<'_> {
 
 #[pyclass]
 trait DictView: PyPayload + PyClassDef + Iterable + Representable {
-    type ReverseIter: PyPayload;
+    type ReverseIter: PyPayload + core::fmt::Debug;
 
-    fn dict(&self) -> &PyDictRef;
+    fn dict(&self) -> &Py<PyDict>;
     fn item(vm: &VirtualMachine, key: PyObjectRef, value: PyObjectRef) -> PyObjectRef;
 
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.dict().__len__()
     }
@@ -784,7 +802,7 @@ macro_rules! dict_view {
         impl DictView for $name {
             type ReverseIter = $reverse_iter_name;
 
-            fn dict(&self) -> &PyDictRef {
+            fn dict(&self) -> &Py<PyDict> {
                 &self.dict
             }
 
@@ -847,7 +865,7 @@ macro_rules! dict_view {
             }
         }
 
-        #[pyclass(with(Unconstructible, IterNext, Iterable))]
+        #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
         impl $iter_name {
             fn new(dict: PyDictRef) -> Self {
                 $iter_name {
@@ -877,8 +895,6 @@ macro_rules! dict_view {
             }
         }
 
-        impl Unconstructible for $iter_name {}
-
         impl SelfIter for $iter_name {}
         impl IterNext for $iter_name {
             #[allow(clippy::redundant_closure_call)]
@@ -922,7 +938,7 @@ macro_rules! dict_view {
             }
         }
 
-        #[pyclass(with(Unconstructible, IterNext, Iterable))]
+        #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
         impl $reverse_iter_name {
             fn new(dict: PyDictRef) -> Self {
                 let size = dict.size();
@@ -956,8 +972,6 @@ macro_rules! dict_view {
                     .rev_length_hint(|_| self.size.entries_size)
             }
         }
-        impl Unconstructible for $reverse_iter_name {}
-
         impl SelfIter for $reverse_iter_name {}
         impl IterNext for $reverse_iter_name {
             #[allow(clippy::redundant_closure_call)]
@@ -1043,38 +1057,30 @@ trait ViewSetOps: DictView {
         PySetInner::from_iter(iter, vm)
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.symmetric_difference(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.intersection(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.union(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod]
     fn __sub__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let zelf = Self::to_set(zelf, vm)?;
         let inner = zelf.difference(other, vm)?;
         Ok(PySet { inner })
     }
 
-    #[pymethod]
     fn __rsub__(zelf: PyRef<Self>, other: ArgIterable, vm: &VirtualMachine) -> PyResult<PySet> {
         let left = PySetInner::from_iter(other.iter(vm)?, vm)?;
         let right = ArgIterable::try_from_object(vm, Self::iter(zelf, vm)?)?;
@@ -1125,28 +1131,28 @@ trait ViewSetOps: DictView {
 }
 
 impl ViewSetOps for PyDictKeys {}
-#[pyclass(with(
-    DictView,
-    Unconstructible,
-    Comparable,
-    Iterable,
-    ViewSetOps,
-    AsSequence,
-    AsNumber,
-    Representable
-))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(
+        DictView,
+        Comparable,
+        Iterable,
+        ViewSetOps,
+        AsSequence,
+        AsNumber,
+        Representable
+    )
+)]
 impl PyDictKeys {
-    #[pymethod]
     fn __contains__(zelf: PyObjectRef, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        zelf.to_sequence().contains(&key, vm)
+        zelf.sequence_unchecked().contains(&key, vm)
     }
 
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
-impl Unconstructible for PyDictKeys {}
 
 impl Comparable for PyDictKeys {
     fn cmp(
@@ -1189,27 +1195,27 @@ impl AsNumber for PyDictKeys {
 }
 
 impl ViewSetOps for PyDictItems {}
-#[pyclass(with(
-    DictView,
-    Unconstructible,
-    Comparable,
-    Iterable,
-    ViewSetOps,
-    AsSequence,
-    AsNumber,
-    Representable
-))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(
+        DictView,
+        Comparable,
+        Iterable,
+        ViewSetOps,
+        AsSequence,
+        AsNumber,
+        Representable
+    )
+)]
 impl PyDictItems {
-    #[pymethod]
     fn __contains__(zelf: PyObjectRef, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        zelf.to_sequence().contains(&needle, vm)
+        zelf.sequence_unchecked().contains(&needle, vm)
     }
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
-impl Unconstructible for PyDictItems {}
 
 impl Comparable for PyDictItems {
     fn cmp(
@@ -1263,14 +1269,16 @@ impl AsNumber for PyDictItems {
     }
 }
 
-#[pyclass(with(DictView, Unconstructible, Iterable, AsSequence, Representable))]
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION),
+    with(DictView, Iterable, AsSequence, Representable)
+)]
 impl PyDictValues {
     #[pygetset]
     fn mapping(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf.dict().clone())
+        PyMappingProxy::from(zelf.dict().to_owned())
     }
 }
-impl Unconstructible for PyDictValues {}
 
 impl AsSequence for PyDictValues {
     fn as_sequence() -> &'static PySequenceMethods {
diff --git a/vm/src/builtins/enumerate.rs b/crates/vm/src/builtins/enumerate.rs
similarity index 83%
rename from vm/src/builtins/enumerate.rs
rename to crates/vm/src/builtins/enumerate.rs
index 64cd4e774e..29d51f420e 100644
--- a/vm/src/builtins/enumerate.rs
+++ b/crates/vm/src/builtins/enumerate.rs
@@ -8,6 +8,7 @@ use crate::{
     convert::ToPyObject,
     function::OptionalArg,
     protocol::{PyIter, PyIterReturn},
+    raise_if_stop,
     types::{Constructor, IterNext, Iterable, SelfIter},
 };
 use malachite_bigint::BigInt;
@@ -18,7 +19,7 @@ use num_traits::Zero;
 pub struct PyEnumerate {
     #[pytraverse(skip)]
     counter: PyRwLock<BigInt>,
-    iterator: PyIter,
+    iterable: PyIter,
 }
 
 impl PyPayload for PyEnumerate {
@@ -30,7 +31,8 @@ impl PyPayload for PyEnumerate {
 
 #[derive(FromArgs)]
 pub struct EnumerateArgs {
-    iterator: PyIter,
+    #[pyarg(any)]
+    iterable: PyIter,
     #[pyarg(any, optional)]
     start: OptionalArg<PyIntRef>,
 }
@@ -39,17 +41,15 @@ impl Constructor for PyEnumerate {
     type Args = EnumerateArgs;
 
     fn py_new(
-        cls: PyTypeRef,
-        Self::Args { iterator, start }: Self::Args,
-        vm: &VirtualMachine,
-    ) -> PyResult {
+        _cls: &Py<PyType>,
+        Self::Args { iterable, start }: Self::Args,
+        _vm: &VirtualMachine,
+    ) -> PyResult<Self> {
         let counter = start.map_or_else(BigInt::zero, |start| start.as_bigint().clone());
-        Self {
+        Ok(Self {
             counter: PyRwLock::new(counter),
-            iterator,
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+            iterable,
+        })
     }
 }
 
@@ -67,18 +67,16 @@ impl Py<PyEnumerate> {
     fn __reduce__(&self) -> (PyTypeRef, (PyIter, BigInt)) {
         (
             self.class().to_owned(),
-            (self.iterator.clone(), self.counter.read().clone()),
+            (self.iterable.clone(), self.counter.read().clone()),
         )
     }
 }
 
 impl SelfIter for PyEnumerate {}
+
 impl IterNext for PyEnumerate {
     fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let next_obj = match zelf.iterator.next(vm)? {
-            PyIterReturn::StopIteration(v) => return Ok(PyIterReturn::StopIteration(v)),
-            PyIterReturn::Return(obj) => obj,
-        };
+        let next_obj = raise_if_stop!(zelf.iterable.next(vm)?);
         let mut counter = zelf.counter.write();
         let position = counter.clone();
         *counter += 1;
@@ -111,10 +109,10 @@ impl PyReverseSequenceIterator {
     #[pymethod]
     fn __length_hint__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         let internal = self.internal.lock();
-        if let IterStatus::Active(obj) = &internal.status {
-            if internal.position <= obj.length(vm)? {
-                return Ok(internal.position + 1);
-            }
+        if let IterStatus::Active(obj) = &internal.status
+            && internal.position <= obj.length(vm)?
+        {
+            return Ok(internal.position + 1);
         }
         Ok(0)
     }
diff --git a/crates/vm/src/builtins/filter.rs b/crates/vm/src/builtins/filter.rs
new file mode 100644
index 0000000000..388fb8bb60
--- /dev/null
+++ b/crates/vm/src/builtins/filter.rs
@@ -0,0 +1,76 @@
+use super::{PyType, PyTypeRef};
+use crate::{
+    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    protocol::{PyIter, PyIterReturn},
+    raise_if_stop,
+    types::{Constructor, IterNext, Iterable, SelfIter},
+};
+
+#[pyclass(module = false, name = "filter", traverse)]
+#[derive(Debug)]
+pub struct PyFilter {
+    predicate: PyObjectRef,
+    iterator: PyIter,
+}
+
+impl PyPayload for PyFilter {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.filter_type
+    }
+}
+
+impl Constructor for PyFilter {
+    type Args = (PyObjectRef, PyIter);
+
+    fn py_new(
+        _cls: &Py<PyType>,
+        (function, iterator): Self::Args,
+        _vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            predicate: function,
+            iterator,
+        })
+    }
+}
+
+#[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
+impl PyFilter {
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> (PyTypeRef, (PyObjectRef, PyIter)) {
+        (
+            vm.ctx.types.filter_type.to_owned(),
+            (self.predicate.clone(), self.iterator.clone()),
+        )
+    }
+}
+
+impl SelfIter for PyFilter {}
+
+impl IterNext for PyFilter {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        let predicate = &zelf.predicate;
+        loop {
+            let next_obj = raise_if_stop!(zelf.iterator.next(vm)?);
+            let predicate_value = if vm.is_none(predicate) {
+                next_obj.clone()
+            } else {
+                // the predicate itself can raise StopIteration which does stop the filter iteration
+                raise_if_stop!(PyIterReturn::from_pyresult(
+                    predicate.call((next_obj.clone(),), vm),
+                    vm
+                )?)
+            };
+
+            if predicate_value.try_to_bool(vm)? {
+                return Ok(PyIterReturn::Return(next_obj));
+            }
+        }
+    }
+}
+
+pub fn init(context: &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
new file mode 100644
index 0000000000..9941aea9ba
--- /dev/null
+++ b/crates/vm/src/builtins/float.rs
@@ -0,0 +1,464 @@
+use super::{
+    PyByteArray, PyBytes, PyInt, PyIntRef, PyStr, PyStrRef, PyType, PyTypeRef, 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},
+    convert::{IntoPyException, ToPyObject, ToPyResult},
+    function::{
+        ArgBytesLike, FuncArgs, OptionalArg, OptionalOption, PyArithmeticValue::*,
+        PyComparisonValue,
+    },
+    protocol::PyNumberMethods,
+    types::{AsNumber, Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+};
+use malachite_bigint::{BigInt, ToBigInt};
+use num_complex::Complex64;
+use num_traits::{Signed, ToPrimitive, Zero};
+use rustpython_common::int::float_to_ratio;
+
+#[pyclass(module = false, name = "float")]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct PyFloat {
+    value: f64,
+}
+
+impl PyFloat {
+    pub const fn to_f64(&self) -> f64 {
+        self.value
+    }
+}
+
+impl PyPayload for PyFloat {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.float_type
+    }
+}
+
+impl ToPyObject for f64 {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_float(self).into()
+    }
+}
+impl ToPyObject for f32 {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_float(f64::from(self)).into()
+    }
+}
+
+impl From<f64> for PyFloat {
+    fn from(value: f64) -> Self {
+        Self { value }
+    }
+}
+
+pub(crate) fn to_op_float(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Option<f64>> {
+    let v = if let Some(float) = obj.downcast_ref::<PyFloat>() {
+        Some(float.value)
+    } else if let Some(int) = obj.downcast_ref::<PyInt>() {
+        Some(try_bigint_to_f64(int.as_bigint(), vm)?)
+    } else {
+        None
+    };
+    Ok(v)
+}
+
+macro_rules! impl_try_from_object_float {
+    ($($t:ty),*) => {
+        $(impl TryFromObject for $t {
+            fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+                PyRef::<PyFloat>::try_from_object(vm, obj).map(|f| f.to_f64() as $t)
+            }
+        })*
+    };
+}
+
+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"))
+}
+
+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"))
+}
+
+pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {
+    match value.to_bigint() {
+        Some(int) => Ok(int),
+        None => {
+            if value.is_infinite() {
+                Err(vm
+                    .new_overflow_error("OverflowError: cannot convert float infinity to integer"))
+            } else if value.is_nan() {
+                Err(vm.new_value_error("ValueError: cannot convert float NaN to integer"))
+            } else {
+                // unreachable unless BigInt has a bug
+                unreachable!(
+                    "A finite float value failed to be converted to bigint: {}",
+                    value
+                )
+            }
+        }
+    }
+}
+
+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"))
+}
+
+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()"))
+}
+
+pub fn float_pow(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult {
+    if v1.is_zero() && v2.is_sign_negative() {
+        let msg = "zero to a negative power";
+        Err(vm.new_zero_division_error(msg.to_owned()))
+    } else if v1.is_sign_negative() && (v2.floor() - v2).abs() > f64::EPSILON {
+        let v1 = Complex64::new(v1, 0.);
+        let v2 = Complex64::new(v2, 0.);
+        Ok(v1.powc(v2).to_pyobject(vm))
+    } else {
+        Ok(v1.powf(v2).to_pyobject(vm))
+    }
+}
+
+impl Constructor for PyFloat {
+    type Args = OptionalArg<PyObjectRef>;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Optimization: return exact float as-is
+        if cls.is(vm.ctx.types.float_type)
+            && args.kwargs.is_empty()
+            && let Some(first) = args.args.first()
+            && first.class().is(vm.ctx.types.float_type)
+        {
+            return Ok(first.clone());
+        }
+
+        let arg: Self::Args = args.bind(vm)?;
+        let payload = Self::py_new(&cls, arg, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, arg: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        let float_val = match arg {
+            OptionalArg::Missing => 0.0,
+            OptionalArg::Present(val) => {
+                if let Some(f) = val.try_float_opt(vm) {
+                    f?.value
+                } else {
+                    float_from_string(val, vm)?
+                }
+            }
+        };
+        Ok(Self::from(float_val))
+    }
+}
+
+fn float_from_string(val: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
+    let (bytearray, buffer, buffer_lock, mapped_string);
+    let b = if let Some(s) = val.downcast_ref::<PyStr>() {
+        use crate::common::str::PyKindStr;
+        match s.as_str_kind() {
+            PyKindStr::Ascii(s) => s.trim().as_bytes(),
+            PyKindStr::Utf8(s) => {
+                mapped_string = s
+                    .trim()
+                    .chars()
+                    .map(|c| {
+                        if let Some(n) = rustpython_common::str::char_to_decimal(c) {
+                            char::from_digit(n.into(), 10).unwrap()
+                        } else if c.is_whitespace() {
+                            ' '
+                        } else {
+                            c
+                        }
+                    })
+                    .collect::<String>();
+                mapped_string.as_bytes()
+            }
+            // if there are surrogates, it's not gonna parse anyway,
+            // so we can just choose a known bad value
+            PyKindStr::Wtf8(_) => b"",
+        }
+    } else if let Some(bytes) = val.downcast_ref::<PyBytes>() {
+        bytes.as_bytes()
+    } else if let Some(buf) = val.downcast_ref::<PyByteArray>() {
+        bytearray = buf.borrow_buf();
+        &*bytearray
+    } else if let Ok(b) = ArgBytesLike::try_from_borrowed_object(vm, &val) {
+        buffer = b;
+        buffer_lock = buffer.borrow_buf();
+        &*buffer_lock
+    } else {
+        return Err(vm.new_type_error(format!(
+            "float() argument must be a string or a number, not '{}'",
+            val.class().name()
+        )));
+    };
+    crate::literal::float::parse_bytes(b).ok_or_else(|| {
+        val.repr(vm)
+            .map(|repr| vm.new_value_error(format!("could not convert string to float: {repr}")))
+            .unwrap_or_else(|e| e)
+    })
+}
+
+#[pyclass(
+    flags(BASETYPE, _MATCH_SELF),
+    with(Comparable, Hashable, Constructor, AsNumber, Representable)
+)]
+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))
+            .map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[pystaticmethod]
+    fn __getformat__(spec: PyStrRef, 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'")
+            );
+        }
+
+        const BIG_ENDIAN: bool = cfg!(target_endian = "big");
+
+        Ok(if BIG_ENDIAN {
+            "IEEE, big-endian"
+        } else {
+            "IEEE, little-endian"
+        }
+        .to_owned())
+    }
+
+    #[pymethod]
+    fn __trunc__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
+        try_to_bigint(self.value, vm)
+    }
+
+    #[pymethod]
+    fn __floor__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
+        try_to_bigint(self.value.floor(), vm)
+    }
+
+    #[pymethod]
+    fn __ceil__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
+        try_to_bigint(self.value.ceil(), vm)
+    }
+
+    #[pymethod]
+    fn __round__(&self, ndigits: OptionalOption<PyIntRef>, vm: &VirtualMachine) -> PyResult {
+        let ndigits = ndigits.flatten();
+        let value = if let Some(ndigits) = ndigits {
+            let ndigits = ndigits.as_bigint();
+            let ndigits = match ndigits.to_i32() {
+                Some(n) => n,
+                None if ndigits.is_positive() => i32::MAX,
+                None => i32::MIN,
+            };
+            let float = float_ops::round_float_digits(self.value, ndigits)
+                .ok_or_else(|| vm.new_overflow_error("overflow occurred during round"))?;
+            vm.ctx.new_float(float).into()
+        } else {
+            let fract = self.value.fract();
+            let value = if (fract.abs() - 0.5).abs() < f64::EPSILON {
+                if self.value.trunc() % 2.0 == 0.0 {
+                    self.value - fract
+                } else {
+                    self.value + fract
+                }
+            } else {
+                self.value.round()
+            };
+            let int = try_to_bigint(value, vm)?;
+            vm.ctx.new_int(int).into()
+        };
+        Ok(value)
+    }
+
+    #[pygetset]
+    const fn real(zelf: PyRef<Self>) -> PyRef<Self> {
+        zelf
+    }
+
+    #[pygetset]
+    const fn imag(&self) -> f64 {
+        0.0f64
+    }
+
+    #[pymethod]
+    const fn conjugate(zelf: PyRef<Self>) -> PyRef<Self> {
+        zelf
+    }
+
+    #[pymethod]
+    fn is_integer(&self) -> bool {
+        crate::literal::float::is_integer(self.value)
+    }
+
+    #[pymethod]
+    fn as_integer_ratio(&self, vm: &VirtualMachine) -> PyResult<(PyIntRef, PyIntRef)> {
+        let value = self.value;
+
+        float_to_ratio(value)
+            .map(|(numer, denom)| (vm.ctx.new_bigint(&numer), vm.ctx.new_bigint(&denom)))
+            .ok_or_else(|| {
+                if value.is_infinite() {
+                    vm.new_overflow_error("cannot convert Infinity to integer ratio")
+                } else if value.is_nan() {
+                    vm.new_value_error("cannot convert NaN to integer ratio")
+                } else {
+                    unreachable!("finite float must able to convert to integer ratio")
+                }
+            })
+    }
+
+    #[pyclassmethod]
+    fn fromhex(cls: PyTypeRef, string: PyStrRef, 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)
+    }
+
+    #[pymethod]
+    fn hex(&self) -> String {
+        crate::literal::float::to_hex(self.value)
+    }
+
+    #[pymethod]
+    fn __getnewargs__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        (self.value,).to_pyobject(vm)
+    }
+}
+
+impl Comparable for PyFloat {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        let ret = if let Some(other) = other.downcast_ref::<Self>() {
+            zelf.value
+                .partial_cmp(&other.value)
+                .map_or_else(|| op == PyComparisonOp::Ne, |ord| op.eval_ord(ord))
+        } else if let Some(other) = other.downcast_ref::<PyInt>() {
+            let a = zelf.to_f64();
+            let b = other.as_bigint();
+            match op {
+                PyComparisonOp::Lt => float_ops::lt_int(a, b),
+                PyComparisonOp::Le => {
+                    if let (Some(a_int), Some(b_float)) = (a.to_bigint(), b.to_f64()) {
+                        a <= b_float && a_int <= *b
+                    } else {
+                        float_ops::lt_int(a, b)
+                    }
+                }
+                PyComparisonOp::Eq => float_ops::eq_int(a, b),
+                PyComparisonOp::Ne => !float_ops::eq_int(a, b),
+                PyComparisonOp::Ge => {
+                    if let (Some(a_int), Some(b_float)) = (a.to_bigint(), b.to_f64()) {
+                        a >= b_float && a_int >= *b
+                    } else {
+                        float_ops::gt_int(a, b)
+                    }
+                }
+                PyComparisonOp::Gt => float_ops::gt_int(a, b),
+            }
+        } else {
+            return Ok(NotImplemented);
+        };
+        Ok(Implemented(ret))
+    }
+}
+
+impl Hashable for PyFloat {
+    #[inline]
+    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        Ok(hash::hash_float(zelf.to_f64()).unwrap_or_else(|| hash::hash_object_id(zelf.get_id())))
+    }
+}
+
+impl AsNumber for PyFloat {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            add: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a + b, vm)),
+            subtract: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a - b, vm)),
+            multiply: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a * b, vm)),
+            remainder: Some(|a, b, vm| PyFloat::number_op(a, b, inner_mod, vm)),
+            divmod: Some(|a, b, vm| PyFloat::number_op(a, b, inner_divmod, vm)),
+            power: Some(|a, b, c, vm| {
+                if vm.is_none(c) {
+                    PyFloat::number_op(a, b, float_pow, vm)
+                } else {
+                    Err(vm.new_type_error(
+                        "pow() 3rd argument not allowed unless all arguments are integers",
+                    ))
+                }
+            }),
+            negative: Some(|num, vm| {
+                let value = PyFloat::number_downcast(num).value;
+                (-value).to_pyresult(vm)
+            }),
+            positive: Some(|num, vm| PyFloat::number_downcast_exact(num, vm).to_pyresult(vm)),
+            absolute: Some(|num, vm| {
+                let value = PyFloat::number_downcast(num).value;
+                value.abs().to_pyresult(vm)
+            }),
+            boolean: Some(|num, _vm| Ok(!PyFloat::number_downcast(num).value.is_zero())),
+            int: Some(|num, vm| {
+                let value = PyFloat::number_downcast(num).value;
+                try_to_bigint(value, vm).map(|x| PyInt::from(x).into_pyobject(vm))
+            }),
+            float: Some(|num, vm| Ok(PyFloat::number_downcast_exact(num, vm).into())),
+            floor_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_floordiv, vm)),
+            true_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_div, vm)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+
+    #[inline]
+    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
+        vm.ctx.new_float(zelf.value)
+    }
+}
+
+impl Representable for PyFloat {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(crate::literal::float::to_string(zelf.value))
+    }
+}
+
+impl PyFloat {
+    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
+    where
+        F: FnOnce(f64, f64, &VirtualMachine) -> R,
+        R: ToPyResult,
+    {
+        if let (Some(a), Some(b)) = (to_op_float(a, vm)?, to_op_float(b, vm)?) {
+            op(a, b, vm).to_pyresult(vm)
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+}
+
+// Retrieve inner float value:
+#[cfg(feature = "serde")]
+pub(crate) fn get_value(obj: &PyObject) -> f64 {
+    obj.downcast_ref::<PyFloat>().unwrap().value
+}
+
+#[rustfmt::skip] // to avoid line splitting
+pub fn init(context: &Context) {
+    PyFloat::extend_class(context, context.types.float_type);
+}
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
new file mode 100644
index 0000000000..28c4e75147
--- /dev/null
+++ b/crates/vm/src/builtins/frame.rs
@@ -0,0 +1,136 @@
+/*! The python `frame` type.
+
+*/
+
+use super::{PyCode, PyDictRef, PyIntRef, PyStrRef};
+use crate::{
+    AsObject, Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    frame::{Frame, FrameRef},
+    function::PySetterValue,
+    types::Representable,
+};
+use num_traits::Zero;
+
+pub fn init(context: &Context) {
+    Frame::extend_class(context, context.types.frame_type);
+}
+
+impl Representable for Frame {
+    #[inline]
+    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        const REPR: &str = "<frame object at .. >";
+        Ok(vm.ctx.intern_str(REPR).to_owned())
+    }
+
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use repr instead")
+    }
+}
+
+#[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 {
+        self.builtins.clone()
+    }
+
+    #[pygetset]
+    fn f_locals(&self, vm: &VirtualMachine) -> PyResult {
+        self.locals(vm).map(Into::into)
+    }
+
+    #[pygetset]
+    pub fn f_code(&self) -> PyRef<PyCode> {
+        self.code.clone()
+    }
+
+    #[pygetset]
+    fn f_lasti(&self) -> u32 {
+        // Return byte offset (each instruction is 2 bytes) for compatibility
+        self.lasti() * 2
+    }
+
+    #[pygetset]
+    pub fn f_lineno(&self) -> usize {
+        // If lasti is 0, execution hasn't started yet - use first line number
+        // Similar to PyCode_Addr2Line which returns co_firstlineno for addr_q < 0
+        if self.lasti() == 0 {
+            self.code.first_line_number.map(|n| n.get()).unwrap_or(1)
+        } else {
+            self.current_location().line.get()
+        }
+    }
+
+    #[pygetset]
+    fn f_trace(&self) -> PyObjectRef {
+        let boxed = self.trace.lock();
+        boxed.clone()
+    }
+
+    #[pygetset(setter)]
+    fn set_f_trace(&self, value: PySetterValue, vm: &VirtualMachine) {
+        let mut storage = self.trace.lock();
+        *storage = value.unwrap_or_none(vm);
+    }
+
+    #[pymember(type = "bool")]
+    fn f_trace_lines(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf: FrameRef = zelf.downcast().unwrap_or_else(|_| unreachable!());
+
+        let boxed = zelf.trace_lines.lock();
+        Ok(vm.ctx.new_bool(*boxed).into())
+    }
+
+    #[pymember(type = "bool", setter)]
+    fn set_f_trace_lines(
+        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_lines = zelf.trace_lines.lock();
+                *trace_lines = !value.as_bigint().is_zero();
+
+                Ok(())
+            }
+            PySetterValue::Delete => Err(vm.new_type_error("can't delete numeric/char attribute")),
+        }
+    }
+}
+
+#[pyclass]
+impl Py<Frame> {
+    #[pygetset]
+    pub fn f_back(&self, vm: &VirtualMachine) -> Option<PyRef<Frame>> {
+        // TODO: actually store f_back inside Frame struct
+
+        // 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
+            .borrow()
+            .iter()
+            .rev()
+            .skip_while(|p| !p.is(self.as_object()))
+            .nth(1)
+            .cloned()
+    }
+}
diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
new file mode 100644
index 0000000000..3d5159e58c
--- /dev/null
+++ b/crates/vm/src/builtins/function.rs
@@ -0,0 +1,961 @@
+#[cfg(feature = "jit")]
+mod jit;
+
+use super::{
+    PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyModule, PyStr, PyStrRef, PyTuple,
+    PyTupleRef, PyType,
+};
+#[cfg(feature = "jit")]
+use crate::common::lock::OnceCell;
+use crate::common::lock::PyMutex;
+use crate::function::ArgMapping;
+use crate::object::{Traverse, TraverseFn};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    bytecode,
+    class::PyClassImpl,
+    frame::Frame,
+    function::{FuncArgs, OptionalArg, PyComparisonValue, PySetterValue},
+    scope::Scope,
+    types::{
+        Callable, Comparable, Constructor, GetAttr, GetDescriptor, PyComparisonOp, Representable,
+    },
+};
+use itertools::Itertools;
+#[cfg(feature = "jit")]
+use rustpython_jit::CompiledCode;
+
+#[pyclass(module = false, name = "function", traverse = "manual")]
+#[derive(Debug)]
+pub struct PyFunction {
+    code: PyMutex<PyRef<PyCode>>,
+    globals: PyDictRef,
+    builtins: PyObjectRef,
+    closure: Option<PyRef<PyTuple<PyCellRef>>>,
+    defaults_and_kwdefaults: PyMutex<(Option<PyTupleRef>, Option<PyDictRef>)>,
+    name: PyMutex<PyStrRef>,
+    qualname: PyMutex<PyStrRef>,
+    type_params: PyMutex<PyTupleRef>,
+    annotations: PyMutex<PyDictRef>,
+    module: PyMutex<PyObjectRef>,
+    doc: PyMutex<PyObjectRef>,
+    #[cfg(feature = "jit")]
+    jitted_code: OnceCell<CompiledCode>,
+}
+
+unsafe impl Traverse for PyFunction {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.globals.traverse(tracer_fn);
+        if let Some(closure) = self.closure.as_ref() {
+            closure.as_untyped().traverse(tracer_fn);
+        }
+        self.defaults_and_kwdefaults.traverse(tracer_fn);
+    }
+}
+
+impl PyFunction {
+    #[inline]
+    pub(crate) fn new(
+        code: PyRef<PyCode>,
+        globals: PyDictRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let name = PyMutex::new(code.obj_name.to_owned());
+        let module = vm.unwrap_or_none(globals.get_item_opt(identifier!(vm, __name__), vm)?);
+        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()
+            } else {
+                vm.builtins.dict().into()
+            }
+        });
+        // If builtins is a module, use its __dict__ instead
+        let builtins = if let Some(module) = builtins.downcast_ref::<PyModule>() {
+            module.dict().into()
+        } else {
+            builtins
+        };
+
+        let qualname = vm.ctx.new_str(code.qualname.as_str());
+        let func = Self {
+            code: PyMutex::new(code.clone()),
+            globals,
+            builtins,
+            closure: None,
+            defaults_and_kwdefaults: PyMutex::new((None, None)),
+            name,
+            qualname: PyMutex::new(qualname),
+            type_params: PyMutex::new(vm.ctx.empty_tuple.clone()),
+            annotations: PyMutex::new(vm.ctx.new_dict()),
+            module: PyMutex::new(module),
+            doc: PyMutex::new(vm.ctx.none()),
+            #[cfg(feature = "jit")]
+            jitted_code: OnceCell::new(),
+        };
+        Ok(func)
+    }
+
+    fn fill_locals_from_args(
+        &self,
+        frame: &Frame,
+        func_args: FuncArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let code = &*self.code.lock();
+        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;
+        // let arg_names = self.code.arg_names();
+
+        // This parses the arguments from args and kwargs into
+        // the proper variables keeping into account default values
+        // and star-args and kwargs.
+        // See also: PyEval_EvalCodeWithName in cpython:
+        // https://github.com/python/cpython/blob/main/Python/ceval.c#L3681
+
+        let mut fastlocals = frame.fastlocals.lock();
+
+        let mut args_iter = func_args.args.into_iter();
+
+        // Copy positional arguments into local variables
+        // zip short-circuits if either iterator returns None, which is the behavior we want --
+        // only fill as much as there is to fill with as much as we have
+        for (local, arg) in Iterator::zip(
+            fastlocals.iter_mut().take(n_expected_args),
+            args_iter.by_ref().take(nargs),
+        ) {
+            *local = Some(arg);
+        }
+
+        let mut vararg_offset = total_args;
+        // Pack other positional arguments in to *args:
+        if code.flags.contains(bytecode::CodeFlags::VARARGS) {
+            let vararg_value = vm.ctx.new_tuple(args_iter.collect());
+            fastlocals[vararg_offset] = Some(vararg_value.into());
+            vararg_offset += 1;
+        } else {
+            // Check the number of positional arguments
+            if nargs > n_expected_args {
+                let n_defaults = self
+                    .defaults_and_kwdefaults
+                    .lock()
+                    .0
+                    .as_ref()
+                    .map_or(0, |d| d.len());
+                let n_required = n_expected_args - n_defaults;
+                let takes_msg = if n_defaults > 0 {
+                    format!("from {} to {}", n_required, n_expected_args)
+                } else {
+                    n_expected_args.to_string()
+                };
+                return Err(vm.new_type_error(format!(
+                    "{}() takes {} positional argument{} but {} {} given",
+                    self.__qualname__(),
+                    takes_msg,
+                    if n_expected_args == 1 { "" } else { "s" },
+                    nargs,
+                    if nargs == 1 { "was" } else { "were" }
+                )));
+            }
+        }
+
+        // Do we support `**kwargs` ?
+        let kwargs = if code.flags.contains(bytecode::CodeFlags::VARKEYWORDS) {
+            let d = vm.ctx.new_dict();
+            fastlocals[vararg_offset] = Some(d.clone().into());
+            Some(d)
+        } else {
+            None
+        };
+
+        let arg_pos = |range: core::ops::Range<_>, name: &str| {
+            code.varnames
+                .iter()
+                .enumerate()
+                .skip(range.start)
+                .take(range.end - range.start)
+                .find(|(_, s)| s.as_str() == name)
+                .map(|(p, _)| p)
+        };
+
+        let mut posonly_passed_as_kwarg = Vec::new();
+        // Handle keyword arguments
+        for (name, value) in func_args.kwargs {
+            // Check if we have a parameter with this name:
+            if let Some(pos) = arg_pos(code.posonlyarg_count as usize..total_args, &name) {
+                let slot = &mut fastlocals[pos];
+                if slot.is_some() {
+                    return Err(vm.new_type_error(format!(
+                        "{}() got multiple values for argument '{}'",
+                        self.__qualname__(),
+                        name
+                    )));
+                }
+                *slot = Some(value);
+            } else if let Some(kwargs) = kwargs.as_ref() {
+                kwargs.set_item(&name, value, vm)?;
+            } else if arg_pos(0..code.posonlyarg_count as usize, &name).is_some() {
+                posonly_passed_as_kwarg.push(name);
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "{}() got an unexpected keyword argument '{}'",
+                    self.__qualname__(),
+                    name
+                )));
+            }
+        }
+        if !posonly_passed_as_kwarg.is_empty() {
+            return Err(vm.new_type_error(format!(
+                "{}() got some positional-only arguments passed as keyword arguments: '{}'",
+                self.__qualname__(),
+                posonly_passed_as_kwarg.into_iter().format(", "),
+            )));
+        }
+
+        let mut defaults_and_kwdefaults = None;
+        // can't be a closure cause it returns a reference to a captured variable :/
+        macro_rules! get_defaults {
+            () => {{
+                defaults_and_kwdefaults
+                    .get_or_insert_with(|| self.defaults_and_kwdefaults.lock().clone())
+            }};
+        }
+
+        // Add missing positional arguments, if we have fewer positional arguments than the
+        // function definition calls for
+        if nargs < n_expected_args {
+            let defaults = get_defaults!().0.as_ref().map(|tup| tup.as_slice());
+            let n_defs = defaults.map_or(0, |d| d.len());
+
+            let n_required = code.arg_count as usize - n_defs;
+
+            // Given the number of defaults available, check all the arguments for which we
+            // _don't_ have defaults; if any are missing, raise an exception
+            let mut missing: Vec<_> = (nargs..n_required)
+                .filter_map(|i| {
+                    if fastlocals[i].is_none() {
+                        Some(&code.varnames[i])
+                    } else {
+                        None
+                    }
+                })
+                .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{}: '{}{}{}'",
+                    self.__qualname__(),
+                    missing_args_len,
+                    if missing_args_len == 1 { "" } else { "s" },
+                    missing.iter().join("', '"),
+                    and,
+                    right,
+                )));
+            }
+
+            if let Some(defaults) = defaults {
+                let n = core::cmp::min(nargs, n_expected_args);
+                let i = n.saturating_sub(n_required);
+
+                // We have sufficient defaults, so iterate over the corresponding names and use
+                // the default if we don't already have a value
+                for i in i..defaults.len() {
+                    let slot = &mut fastlocals[n_required + i];
+                    if slot.is_none() {
+                        *slot = Some(defaults[i].clone());
+                    }
+                }
+            }
+        };
+
+        if code.kwonlyarg_count > 0 {
+            // TODO: compile a list of missing arguments
+            // let mut missing = vec![];
+            // Check if kw only arguments are all present:
+            for (slot, kwarg) in fastlocals
+                .iter_mut()
+                .zip(&*code.varnames)
+                .skip(code.arg_count as usize)
+                .take(code.kwonlyarg_count as usize)
+                .filter(|(slot, _)| slot.is_none())
+            {
+                if let Some(defaults) = &get_defaults!().1
+                    && let Some(default) = defaults.get_item_opt(&**kwarg, vm)?
+                {
+                    *slot = Some(default);
+                    continue;
+                }
+
+                // No default value and not specified.
+                return Err(
+                    vm.new_type_error(format!("Missing required kw only argument: '{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);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Set function attribute based on MakeFunctionFlags
+    pub(crate) fn set_function_attribute(
+        &mut self,
+        attr: bytecode::MakeFunctionFlags,
+        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() = 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| {
+                    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)?);
+        } 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 {
+            unreachable!("This is a compiler bug");
+        }
+        Ok(())
+    }
+}
+
+impl Py<PyFunction> {
+    pub fn invoke_with_locals(
+        &self,
+        func_args: FuncArgs,
+        locals: Option<ArgMapping>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        #[cfg(feature = "jit")]
+        if let Some(jitted_code) = self.jitted_code.get() {
+            use crate::convert::ToPyObject;
+            match jit::get_jit_args(self, &func_args, jitted_code, vm) {
+                Ok(args) => {
+                    return Ok(args.invoke().to_pyobject(vm));
+                }
+                Err(err) => info!(
+                    "jit: function `{}` is falling back to being interpreted because of the \
+                    error: {}",
+                    self.code.lock().obj_name,
+                    err
+                ),
+            }
+        }
+
+        let code = self.code.lock().clone();
+
+        let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
+            ArgMapping::from_dict_exact(vm.ctx.new_dict())
+        } else if let Some(locals) = locals {
+            locals
+        } else {
+            ArgMapping::from_dict_exact(self.globals.clone())
+        };
+
+        // Construct frame:
+        let frame = Frame::new(
+            code.clone(),
+            Scope::new(Some(locals), self.globals.clone()),
+            vm.builtins.dict(),
+            self.closure.as_ref().map_or(&[], |c| c.as_slice()),
+            Some(self.to_owned().into()),
+            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))
+            }
+            (false, true) => {
+                Ok(PyCoroutine::new(frame, self.__name__(), self.__qualname__()).into_pyobject(vm))
+            }
+            (true, true) => {
+                Ok(PyAsyncGen::new(frame, self.__name__(), self.__qualname__()).into_pyobject(vm))
+            }
+            (false, false) => vm.run_frame(frame),
+        }
+    }
+
+    #[inline(always)]
+    pub fn invoke(&self, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        self.invoke_with_locals(func_args, None, vm)
+    }
+}
+
+impl PyPayload for PyFunction {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.function_type
+    }
+}
+
+#[pyclass(
+    with(GetDescriptor, Callable, Representable, Constructor),
+    flags(HAS_DICT, METHOD_DESCRIPTOR)
+)]
+impl PyFunction {
+    #[pygetset]
+    fn __code__(&self) -> PyRef<PyCode> {
+        self.code.lock().clone()
+    }
+
+    #[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();
+        // }
+    }
+
+    #[pygetset]
+    fn __defaults__(&self) -> Option<PyTupleRef> {
+        self.defaults_and_kwdefaults.lock().0.clone()
+    }
+    #[pygetset(setter)]
+    fn set___defaults__(&self, defaults: Option<PyTupleRef>) {
+        self.defaults_and_kwdefaults.lock().0 = defaults
+    }
+
+    #[pygetset]
+    fn __kwdefaults__(&self) -> Option<PyDictRef> {
+        self.defaults_and_kwdefaults.lock().1.clone()
+    }
+    #[pygetset(setter)]
+    fn set___kwdefaults__(&self, kwdefaults: Option<PyDictRef>) {
+        self.defaults_and_kwdefaults.lock().1 = kwdefaults
+    }
+
+    // {"__closure__",   T_OBJECT,     OFF(func_closure), READONLY},
+    // {"__doc__",       T_OBJECT,     OFF(func_doc), 0},
+    // {"__globals__",   T_OBJECT,     OFF(func_globals), READONLY},
+    // {"__module__",    T_OBJECT,     OFF(func_module), 0},
+    // {"__builtins__",  T_OBJECT,     OFF(func_builtins), READONLY},
+    #[pymember]
+    fn __globals__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf = Self::_as_pyref(&zelf, vm)?;
+        Ok(zelf.globals.clone().into())
+    }
+
+    #[pymember]
+    fn __closure__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf = Self::_as_pyref(&zelf, vm)?;
+        Ok(vm.unwrap_or_none(zelf.closure.clone().map(|x| x.into())))
+    }
+
+    #[pymember]
+    fn __builtins__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
+        let zelf = Self::_as_pyref(&zelf, vm)?;
+        Ok(zelf.builtins.clone())
+    }
+
+    #[pygetset]
+    fn __name__(&self) -> PyStrRef {
+        self.name.lock().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___name__(&self, name: PyStrRef) {
+        *self.name.lock() = name;
+    }
+
+    #[pymember]
+    fn __doc__(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult {
+        // When accessed from instance, obj is the PyFunction instance
+        if let Ok(func) = obj.downcast::<Self>() {
+            let doc = func.doc.lock();
+            Ok(doc.clone())
+        } else {
+            // When accessed from class, return None as there's no instance
+            Ok(vm.ctx.none())
+        }
+    }
+
+    #[pymember(setter)]
+    fn set___doc__(vm: &VirtualMachine, zelf: PyObjectRef, value: PySetterValue) -> PyResult<()> {
+        let zelf: PyRef<Self> = zelf.downcast().unwrap_or_else(|_| unreachable!());
+        let value = value.unwrap_or_none(vm);
+        *zelf.doc.lock() = value;
+        Ok(())
+    }
+
+    #[pygetset]
+    fn __module__(&self) -> PyObjectRef {
+        self.module.lock().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___module__(&self, module: PySetterValue<PyObjectRef>, vm: &VirtualMachine) {
+        *self.module.lock() = module.unwrap_or_none(vm);
+    }
+
+    #[pygetset]
+    fn __annotations__(&self) -> PyDictRef {
+        self.annotations.lock().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___annotations__(&self, annotations: PyDictRef) {
+        *self.annotations.lock() = annotations
+    }
+
+    #[pygetset]
+    fn __qualname__(&self) -> PyStrRef {
+        self.qualname.lock().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___qualname__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                let Ok(qualname) = value.downcast::<PyStr>() else {
+                    return Err(vm.new_type_error("__qualname__ must be set to a string object"));
+                };
+                *self.qualname.lock() = qualname;
+            }
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("__qualname__ must be set to a string object"));
+            }
+        }
+        Ok(())
+    }
+
+    #[pygetset]
+    fn __type_params__(&self) -> PyTupleRef {
+        self.type_params.lock().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___type_params__(
+        &self,
+        value: PySetterValue<PyTupleRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match value {
+            PySetterValue::Assign(value) => {
+                *self.type_params.lock() = value;
+            }
+            PySetterValue::Delete => {
+                return Err(vm.new_type_error("__type_params__ must be set to a tuple object"));
+            }
+        }
+        Ok(())
+    }
+
+    #[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)
+    }
+}
+
+impl GetDescriptor for PyFunction {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let (_zelf, obj) = Self::_unwrap(&zelf, obj, vm)?;
+        Ok(if vm.is_none(&obj) && !Self::_cls_is(&cls, obj.class()) {
+            zelf
+        } else {
+            PyBoundMethod::new(obj, zelf).into_ref(&vm.ctx).into()
+        })
+    }
+}
+
+impl Callable for PyFunction {
+    type Args = FuncArgs;
+    #[inline]
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        zelf.invoke(args, vm)
+    }
+}
+
+impl Representable for PyFunction {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(format!(
+            "<function {} at {:#x}>",
+            zelf.__qualname__(),
+            zelf.get_id()
+        ))
+    }
+}
+
+#[derive(FromArgs)]
+pub struct PyFunctionNewArgs {
+    #[pyarg(positional)]
+    code: PyRef<PyCode>,
+    #[pyarg(positional)]
+    globals: PyDictRef,
+    #[pyarg(any, optional)]
+    name: OptionalArg<PyStrRef>,
+    #[pyarg(any, optional)]
+    argdefs: Option<PyTupleRef>,
+    #[pyarg(any, optional)]
+    closure: Option<PyTupleRef>,
+    #[pyarg(any, optional)]
+    kwdefaults: Option<PyDictRef>,
+}
+
+impl Constructor for PyFunction {
+    type Args = PyFunctionNewArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        // Handle closure - must be a tuple of cells
+        let closure = if let Some(closure_tuple) = args.closure {
+            // Check that closure length matches code's free variables
+            if closure_tuple.len() != args.code.freevars.len() {
+                return Err(vm.new_value_error(format!(
+                    "{} requires closure of length {}, not {}",
+                    args.code.obj_name,
+                    args.code.freevars.len(),
+                    closure_tuple.len()
+                )));
+            }
+
+            // Validate that all items are cells and create typed tuple
+            let typed_closure = closure_tuple.try_into_typed::<PyCell>(vm)?;
+            Some(typed_closure)
+        } else if !args.code.freevars.is_empty() {
+            return Err(vm.new_type_error("arg 5 (closure) must be tuple"));
+        } else {
+            None
+        };
+
+        let mut func = Self::new(args.code.clone(), args.globals.clone(), vm)?;
+        // Set function name if provided
+        if let Some(name) = args.name.into_option() {
+            *func.name.lock() = name.clone();
+            // Also update qualname to match the name
+            *func.qualname.lock() = name;
+        }
+        // Now set additional attributes directly
+        if let Some(closure_tuple) = closure {
+            func.closure = Some(closure_tuple);
+        }
+        if let Some(argdefs) = args.argdefs {
+            func.defaults_and_kwdefaults.lock().0 = Some(argdefs);
+        }
+        if let Some(kwdefaults) = args.kwdefaults {
+            func.defaults_and_kwdefaults.lock().1 = Some(kwdefaults);
+        }
+
+        Ok(func)
+    }
+}
+
+#[pyclass(module = false, name = "method", traverse)]
+#[derive(Debug)]
+pub struct PyBoundMethod {
+    object: PyObjectRef,
+    function: PyObjectRef,
+}
+
+impl Callable for PyBoundMethod {
+    type Args = FuncArgs;
+    #[inline]
+    fn call(zelf: &Py<Self>, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        args.prepend_arg(zelf.object.clone());
+        zelf.function.call(args, vm)
+    }
+}
+
+impl Comparable for PyBoundMethod {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            Ok(PyComparisonValue::Implemented(
+                zelf.function.is(&other.function) && zelf.object.is(&other.object),
+            ))
+        })
+    }
+}
+
+impl GetAttr for PyBoundMethod {
+    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        let class_attr = vm
+            .ctx
+            .interned_str(name)
+            .and_then(|attr_name| zelf.get_class_attr(attr_name));
+        if let Some(obj) = class_attr {
+            return vm.call_if_get_descriptor(&obj, zelf.to_owned().into());
+        }
+        zelf.function.get_attr(name, vm)
+    }
+}
+
+#[derive(FromArgs)]
+pub struct PyBoundMethodNewArgs {
+    #[pyarg(positional)]
+    function: PyObjectRef,
+    #[pyarg(positional)]
+    object: PyObjectRef,
+}
+
+impl Constructor for PyBoundMethod {
+    type Args = PyBoundMethodNewArgs;
+
+    fn py_new(
+        _cls: &Py<PyType>,
+        Self::Args { function, object }: Self::Args,
+        _vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        Ok(Self::new(object, function))
+    }
+}
+
+impl PyBoundMethod {
+    pub const fn new(object: PyObjectRef, function: PyObjectRef) -> Self {
+        Self { object, function }
+    }
+
+    #[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)
+    }
+}
+
+#[pyclass(
+    with(Callable, Comparable, GetAttr, Constructor, Representable),
+    flags(IMMUTABLETYPE)
+)]
+impl PyBoundMethod {
+    #[pymethod]
+    fn __reduce__(
+        &self,
+        vm: &VirtualMachine,
+    ) -> (Option<PyObjectRef>, (PyObjectRef, Option<PyObjectRef>)) {
+        let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
+        let func_self = self.object.clone();
+        let func_name = self.function.get_attr("__name__", vm).ok();
+        (builtins_getattr, (func_self, func_name))
+    }
+
+    #[pygetset]
+    fn __doc__(&self, vm: &VirtualMachine) -> PyResult {
+        self.function.get_attr("__doc__", vm)
+    }
+
+    #[pygetset]
+    fn __func__(&self) -> PyObjectRef {
+        self.function.clone()
+    }
+
+    #[pygetset(name = "__self__")]
+    fn get_self(&self) -> PyObjectRef {
+        self.object.clone()
+    }
+
+    #[pygetset]
+    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 {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.bound_method_type
+    }
+}
+
+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(),
+        };
+        let object_repr = zelf.object.repr(vm)?;
+        Ok(format!(
+            "<bound method {formatted_func_name} of {object_repr}>",
+        ))
+    }
+}
+
+#[pyclass(module = false, name = "cell", traverse)]
+#[derive(Debug, Default)]
+pub(crate) struct PyCell {
+    contents: PyMutex<Option<PyObjectRef>>,
+}
+pub(crate) type PyCellRef = PyRef<PyCell>;
+
+impl PyPayload for PyCell {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.cell_type
+    }
+}
+
+impl Constructor for PyCell {
+    type Args = OptionalArg;
+
+    fn py_new(_cls: &Py<PyType>, value: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self::new(value.into_option()))
+    }
+}
+
+#[pyclass(with(Constructor))]
+impl PyCell {
+    pub const fn new(contents: Option<PyObjectRef>) -> Self {
+        Self {
+            contents: PyMutex::new(contents),
+        }
+    }
+
+    pub fn get(&self) -> Option<PyObjectRef> {
+        self.contents.lock().clone()
+    }
+    pub fn set(&self, x: Option<PyObjectRef>) {
+        *self.contents.lock() = x;
+    }
+
+    #[pygetset]
+    fn cell_contents(&self, vm: &VirtualMachine) -> PyResult {
+        self.get()
+            .ok_or_else(|| vm.new_value_error("Cell is empty"))
+    }
+    #[pygetset(setter)]
+    fn set_cell_contents(&self, x: PySetterValue) {
+        match x {
+            PySetterValue::Assign(value) => self.set(Some(value)),
+            PySetterValue::Delete => self.set(None),
+        }
+    }
+}
+
+pub fn init(context: &Context) {
+    PyFunction::extend_class(context, context.types.function_type);
+    PyBoundMethod::extend_class(context, context.types.bound_method_type);
+    PyCell::extend_class(context, context.types.cell_type);
+}
diff --git a/vm/src/builtins/function/jit.rs b/crates/vm/src/builtins/function/jit.rs
similarity index 89%
rename from vm/src/builtins/function/jit.rs
rename to crates/vm/src/builtins/function/jit.rs
index c528c9bb31..a28335900d 100644
--- a/vm/src/builtins/function/jit.rs
+++ b/crates/vm/src/builtins/function/jit.rs
@@ -1,6 +1,8 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyDictRef, PyFunction, PyStrInterned, bool_, float, int},
+    builtins::{
+        PyBaseExceptionRef, PyDict, PyDictRef, PyFunction, PyStrInterned, bool_, float, int,
+    },
     bytecode::CodeFlags,
     convert::ToPyObject,
     function::FuncArgs,
@@ -42,7 +44,7 @@ pub fn new_jit_error(msg: String, vm: &VirtualMachine) -> PyBaseExceptionRef {
     vm.new_exception_msg(jit_error, msg)
 }
 
-fn get_jit_arg_type(dict: &PyDictRef, name: &str, vm: &VirtualMachine) -> PyResult<JitType> {
+fn get_jit_arg_type(dict: &Py<PyDict>, name: &str, vm: &VirtualMachine) -> PyResult<JitType> {
     if let Some(value) = dict.get_item_opt(name, vm)? {
         if value.is(vm.ctx.types.int_type) {
             Ok(JitType::Int)
@@ -65,12 +67,12 @@ fn get_jit_arg_type(dict: &PyDictRef, name: &str, vm: &VirtualMachine) -> PyResu
 }
 
 pub fn get_jit_arg_types(func: &Py<PyFunction>, vm: &VirtualMachine) -> PyResult<Vec<JitType>> {
-    let arg_names = func.code.arg_names();
+    let code = func.code.lock();
+    let arg_names = code.arg_names();
 
-    if func
-        .code
+    if code
         .flags
-        .intersects(CodeFlags::HAS_VARARGS | CodeFlags::HAS_VARKEYWORDS)
+        .intersects(CodeFlags::VARARGS | CodeFlags::VARKEYWORDS)
     {
         return Err(new_jit_error(
             "Can't jit functions with variable number of arguments".to_owned(),
@@ -157,9 +159,13 @@ pub(crate) fn get_jit_args<'a>(
 ) -> Result<Args<'a>, ArgsError> {
     let mut jit_args = jitted_code.args_builder();
     let nargs = func_args.args.len();
-    let arg_names = func.code.arg_names();
 
-    if nargs > func.code.arg_count as usize || nargs < func.code.posonlyarg_count as usize {
+    let code = func.code.lock();
+    let arg_names = code.arg_names();
+    let arg_count = code.arg_count;
+    let posonlyarg_count = code.posonlyarg_count;
+
+    if nargs > arg_count as usize || nargs < posonlyarg_count as usize {
         return Err(ArgsError::WrongNumberOfArgs);
     }
 
@@ -178,7 +184,7 @@ pub(crate) fn get_jit_args<'a>(
             }
             jit_args.set(arg_idx, get_jit_value(vm, value)?)?;
         } else if let Some(kwarg_idx) = arg_pos(arg_names.kwonlyargs, name) {
-            let arg_idx = kwarg_idx + func.code.arg_count as usize;
+            let arg_idx = kwarg_idx + arg_count as usize;
             if jit_args.is_set(arg_idx) {
                 return Err(ArgsError::ArgPassedMultipleTimes);
             }
@@ -193,7 +199,7 @@ pub(crate) fn get_jit_args<'a>(
     // fill in positional defaults
     if let Some(defaults) = defaults {
         for (i, default) in defaults.iter().enumerate() {
-            let arg_idx = i + func.code.arg_count as usize - defaults.len();
+            let arg_idx = i + arg_count as usize - defaults.len();
             if !jit_args.is_set(arg_idx) {
                 jit_args.set(arg_idx, get_jit_value(vm, default)?)?;
             }
@@ -203,7 +209,7 @@ pub(crate) fn get_jit_args<'a>(
     // fill in keyword only defaults
     if let Some(kw_only_defaults) = kwdefaults {
         for (i, name) in arg_names.kwonlyargs.iter().enumerate() {
-            let arg_idx = i + func.code.arg_count as usize;
+            let arg_idx = i + arg_count as usize;
             if !jit_args.is_set(arg_idx) {
                 let default = kw_only_defaults
                     .get_item(&**name, vm)
@@ -214,5 +220,7 @@ pub(crate) fn get_jit_args<'a>(
         }
     }
 
+    drop(code);
+
     jit_args.into_args().ok_or(ArgsError::NotAllArgsPassed)
 }
diff --git a/vm/src/builtins/generator.rs b/crates/vm/src/builtins/generator.rs
similarity index 82%
rename from vm/src/builtins/generator.rs
rename to crates/vm/src/builtins/generator.rs
index 44021c24ed..9a1e737500 100644
--- a/vm/src/builtins/generator.rs
+++ b/crates/vm/src/builtins/generator.rs
@@ -6,11 +6,11 @@ use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
 use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
-    coroutine::Coro,
+    coroutine::{Coro, warn_deprecated_throw_signature},
     frame::FrameRef,
     function::OptionalArg,
     protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
+    types::{IterNext, Iterable, Representable, SelfIter},
 };
 
 #[pyclass(module = false, name = "generator")]
@@ -26,15 +26,15 @@ impl PyPayload for PyGenerator {
     }
 }
 
-#[pyclass(with(Py, Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(Py, IterNext, Iterable))]
 impl PyGenerator {
     pub const fn as_coro(&self) -> &Coro {
         &self.inner
     }
 
-    pub fn new(frame: FrameRef, name: PyStrRef) -> Self {
+    pub fn new(frame: FrameRef, name: PyStrRef, qualname: PyStrRef) -> Self {
         Self {
-            inner: Coro::new(frame, name),
+            inner: Coro::new(frame, name, qualname),
         }
     }
 
@@ -48,6 +48,16 @@ impl PyGenerator {
         self.inner.set_name(name)
     }
 
+    #[pygetset]
+    fn __qualname__(&self) -> PyStrRef {
+        self.inner.qualname()
+    }
+
+    #[pygetset(setter)]
+    fn set___qualname__(&self, qualname: PyStrRef) {
+        self.inner.set_qualname(qualname)
+    }
+
     #[pygetset]
     fn gi_frame(&self, _vm: &VirtualMachine) -> FrameRef {
         self.inner.frame()
@@ -89,6 +99,7 @@ impl Py<PyGenerator> {
         exc_tb: OptionalArg,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
+        warn_deprecated_throw_signature(&exc_val, &exc_tb, vm)?;
         self.inner.throw(
             self.as_object(),
             exc_type,
@@ -104,8 +115,6 @@ impl Py<PyGenerator> {
     }
 }
 
-impl Unconstructible for PyGenerator {}
-
 impl Representable for PyGenerator {
     #[inline]
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
diff --git a/vm/src/builtins/genericalias.rs b/crates/vm/src/builtins/genericalias.rs
similarity index 84%
rename from vm/src/builtins/genericalias.rs
rename to crates/vm/src/builtins/genericalias.rs
index fc666190bf..e9150e4c08 100644
--- a/vm/src/builtins/genericalias.rs
+++ b/crates/vm/src/builtins/genericalias.rs
@@ -16,7 +16,7 @@ use crate::{
         PyComparisonOp, Representable,
     },
 };
-use std::fmt;
+use alloc::fmt;
 
 // attr_exceptions
 static ATTR_EXCEPTIONS: [&str; 12] = [
@@ -58,7 +58,7 @@ impl PyPayload for PyGenericAlias {
 impl Constructor for PyGenericAlias {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
         if !args.kwargs.is_empty() {
             return Err(vm.new_type_error("GenericAlias() takes no keyword arguments"));
         }
@@ -68,9 +68,7 @@ impl Constructor for PyGenericAlias {
         } else {
             PyTuple::new_ref(vec![arguments], &vm.ctx)
         };
-        Self::new(origin, args, false, vm)
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+        Ok(Self::new(origin, args, false, vm))
     }
 }
 
@@ -122,16 +120,16 @@ impl PyGenericAlias {
                     .get_attribute_opt(obj.clone(), identifier!(vm, __args__))?
                     .is_some()
             {
-                return Ok(obj.repr(vm)?.as_str().to_string());
+                return Ok(obj.repr(vm)?.to_string());
             }
 
             match (
                 vm.get_attribute_opt(obj.clone(), identifier!(vm, __qualname__))?
-                    .and_then(|o| o.downcast_ref::<PyStr>().map(|n| n.as_str().to_string())),
+                    .and_then(|o| o.downcast_ref::<PyStr>().map(|n| n.to_string())),
                 vm.get_attribute_opt(obj.clone(), identifier!(vm, __module__))?
-                    .and_then(|o| o.downcast_ref::<PyStr>().map(|m| m.as_str().to_string())),
+                    .and_then(|o| o.downcast_ref::<PyStr>().map(|m| m.to_string())),
             ) {
-                (None, _) | (_, None) => Ok(obj.repr(vm)?.as_str().to_string()),
+                (None, _) | (_, None) => Ok(obj.repr(vm)?.to_string()),
                 (Some(qualname), Some(module)) => Ok(if module == "builtins" {
                     qualname
                 } else {
@@ -191,7 +189,6 @@ impl PyGenericAlias {
         }
     }
 
-    #[pymethod]
     fn __getitem__(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         let new_args = subs_parameters(
             zelf.to_owned().into(),
@@ -238,12 +235,10 @@ impl PyGenericAlias {
         Err(vm.new_type_error("issubclass() argument 2 cannot be a parameterized generic"))
     }
 
-    #[pymethod]
     fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         type_::or_(other, zelf, vm)
     }
 
-    #[pymethod]
     fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
         type_::or_(zelf, other, vm)
     }
@@ -269,22 +264,22 @@ pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupl
                 parameters[iparam] = arg.clone();
                 iparam += 1;
             }
-        } else if let Ok(subparams) = arg.get_attr(identifier!(vm, __parameters__), vm) {
-            if 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;
+        } 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;
                 }
             }
         }
@@ -296,11 +291,11 @@ pub(crate) fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupl
 }
 
 #[inline]
-fn tuple_index(vec: &[PyObjectRef], item: &PyObjectRef) -> Option<usize> {
+fn tuple_index(vec: &[PyObjectRef], item: &PyObject) -> Option<usize> {
     vec.iter().position(|element| element.is(item))
 }
 
-fn is_unpacked_typevartuple(arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+fn is_unpacked_typevartuple(arg: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     if arg.class().is(vm.ctx.types.type_type) {
         return Ok(false);
     }
@@ -314,7 +309,7 @@ fn is_unpacked_typevartuple(arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<
 
 fn subs_tvars(
     obj: PyObjectRef,
-    params: &PyTupleRef,
+    params: &Py<PyTuple>,
     arg_items: &[PyObjectRef],
     vm: &VirtualMachine,
 ) -> PyResult {
@@ -338,7 +333,7 @@ fn subs_tvars(
                             {
                                 // TypeVarTuple case - extend with tuple elements
                                 if let Ok(tuple) = substituted_arg.try_to_ref::<PyTuple>(vm) {
-                                    for elem in tuple.iter() {
+                                    for elem in tuple {
                                         sub_args.push(elem.clone());
                                     }
                                     continue;
@@ -376,23 +371,22 @@ fn unpack_args(item: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
         }
 
         // Try to get __typing_unpacked_tuple_args__
-        if let Ok(sub_args) = item.get_attr(identifier!(vm, __typing_unpacked_tuple_args__), vm) {
-            if !sub_args.is(&vm.ctx.none) {
-                if let Ok(tuple) = sub_args.try_to_ref::<PyTuple>(vm) {
-                    // Check for ellipsis at the end
-                    let has_ellipsis_at_end = tuple
-                        .as_slice()
-                        .last()
-                        .is_some_and(|item| item.is(&vm.ctx.ellipsis));
-
-                    if !has_ellipsis_at_end {
-                        // Safe to unpack - add all elements's PyList_SetSlice
-                        for arg in tuple.iter() {
-                            new_args.push(arg.clone());
-                        }
-                        continue;
-                    }
+        if let Ok(sub_args) = item.get_attr(identifier!(vm, __typing_unpacked_tuple_args__), vm)
+            && !sub_args.is(&vm.ctx.none)
+            && let Ok(tuple) = sub_args.try_to_ref::<PyTuple>(vm)
+        {
+            // Check for ellipsis at the end
+            let has_ellipsis_at_end = tuple
+                .as_slice()
+                .last()
+                .is_some_and(|item| item.is(&vm.ctx.ellipsis));
+
+            if !has_ellipsis_at_end {
+                // Safe to unpack - add all elements's PyList_SetSlice
+                for arg in tuple {
+                    new_args.push(arg.clone());
                 }
+                continue;
             }
         }
 
@@ -421,17 +415,17 @@ pub fn subs_parameters(
 
     // Step 2: Call __typing_prepare_subst__ on each parameter
     for param in parameters.iter() {
-        if let Ok(prepare) = param.get_attr(identifier!(vm, __typing_prepare_subst__), vm) {
-            if !prepare.is(&vm.ctx.none) {
-                // Call prepare(self, item)
-                item = if item.try_to_ref::<PyTuple>(vm).is_ok() {
-                    prepare.call((alias.clone(), item.clone()), vm)?
-                } else {
-                    // Create a tuple with the single item's "O(O)" format
-                    let tuple_args = PyTuple::new_ref(vec![item.clone()], &vm.ctx);
-                    prepare.call((alias.clone(), tuple_args.to_pyobject(vm)), vm)?
-                };
-            }
+        if let Ok(prepare) = param.get_attr(identifier!(vm, __typing_prepare_subst__), vm)
+            && !prepare.is(&vm.ctx.none)
+        {
+            // Call prepare(self, item)
+            item = if item.try_to_ref::<PyTuple>(vm).is_ok() {
+                prepare.call((alias.clone(), item.clone()), vm)?
+            } else {
+                // Create a tuple with the single item's "O(O)" format
+                let tuple_args = PyTuple::new_ref(vec![item.clone()], &vm.ctx);
+                prepare.call((alias.clone(), tuple_args.to_pyobject(vm)), vm)?
+            };
         }
     }
 
@@ -484,7 +478,7 @@ pub fn subs_parameters(
         if unpack {
             // Handle unpacked TypeVarTuple's tuple_extend
             if let Ok(tuple) = substituted_arg.try_to_ref::<PyTuple>(vm) {
-                for elem in tuple.iter() {
+                for elem in tuple {
                     new_args.push(elem.clone());
                 }
             } else {
@@ -526,12 +520,11 @@ 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| {
-            if let Err(exc) = obj.set_attr(identifier!(vm, __orig_class__), zelf.to_owned(), vm) {
-                if !exc.fast_isinstance(vm.ctx.exceptions.attribute_error)
-                    && !exc.fast_isinstance(vm.ctx.exceptions.type_error)
-                {
-                    return Err(exc);
-                }
+            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)
+            {
+                return Err(exc);
             }
             Ok(obj)
         })?
@@ -572,7 +565,7 @@ impl Hashable for PyGenericAlias {
 
 impl GetAttr for PyGenericAlias {
     fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        for exc in ATTR_EXCEPTIONS.iter() {
+        for exc in &ATTR_EXCEPTIONS {
             if *(*exc) == attr.to_string() {
                 return zelf.as_object().generic_getattr(attr, vm);
             }
@@ -617,19 +610,21 @@ impl Iterable for PyGenericAlias {
 /// 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.Generic type
+    // Get typing module and _GenericAlias
     let typing_module = vm.import("typing", 0)?;
     let generic_type = typing_module.get_attr("Generic", vm)?;
-    let generic_type = PyTypeRef::try_from_object(vm, generic_type)?;
 
-    // Create GenericAlias: Generic[type_params]
+    // 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) {
         tuple.to_owned()
     } else {
         PyTuple::new_ref(vec![type_params], &vm.ctx)
     };
 
-    Ok(PyGenericAlias::new(generic_type, args, false, vm).into_pyobject(vm))
+    // Create _GenericAlias instance
+    generic_alias_class.call((generic_type, args.to_pyobject(vm)), vm)
 }
 
 pub fn init(context: &Context) {
diff --git a/vm/src/builtins/getset.rs b/crates/vm/src/builtins/getset.rs
similarity index 82%
rename from vm/src/builtins/getset.rs
rename to crates/vm/src/builtins/getset.rs
index 4b966bbc31..86f0524b12 100644
--- a/vm/src/builtins/getset.rs
+++ b/crates/vm/src/builtins/getset.rs
@@ -7,7 +7,7 @@ use crate::{
     builtins::type_::PointerSlot,
     class::PyClassImpl,
     function::{IntoPyGetterFunc, IntoPySetterFunc, PyGetterFunc, PySetterFunc, PySetterValue},
-    types::{GetDescriptor, Unconstructible},
+    types::{GetDescriptor, Representable},
 };
 
 #[pyclass(module = false, name = "getset_descriptor")]
@@ -19,8 +19,8 @@ pub struct PyGetSet {
     // doc: Option<String>,
 }
 
-impl std::fmt::Debug for PyGetSet {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for PyGetSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(
             f,
             "PyGetSet {{ name: {}, getter: {}, setter: {} }}",
@@ -96,7 +96,7 @@ impl PyGetSet {
     }
 }
 
-#[pyclass(with(GetDescriptor, Unconstructible))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(GetDescriptor, Representable))]
 impl PyGetSet {
     // Descriptor methods
 
@@ -118,19 +118,6 @@ impl PyGetSet {
             )))
         }
     }
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
 
     #[pygetset]
     fn __name__(&self) -> String {
@@ -152,7 +139,23 @@ impl PyGetSet {
         Ok(unsafe { zelf.class.borrow_static() }.to_owned().into())
     }
 }
-impl Unconstructible for PyGetSet {}
+
+impl Representable for PyGetSet {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let class = unsafe { zelf.class.borrow_static() };
+        // Special case for object type
+        if core::ptr::eq(class, vm.ctx.types.object_type) {
+            Ok(format!("<attribute '{}'>", zelf.name))
+        } else {
+            Ok(format!(
+                "<attribute '{}' of '{}' objects>",
+                zelf.name,
+                class.name()
+            ))
+        }
+    }
+}
 
 pub(crate) fn init(context: &Context) {
     PyGetSet::extend_class(context, context.types.getset_type);
diff --git a/crates/vm/src/builtins/int.rs b/crates/vm/src/builtins/int.rs
new file mode 100644
index 0000000000..9b74b66e3a
--- /dev/null
+++ b/crates/vm/src/builtins/int.rs
@@ -0,0 +1,726 @@
+use super::{PyByteArray, PyBytes, PyStr, PyType, PyTypeRef, float};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
+    TryFromBorrowedObject, VirtualMachine,
+    builtins::PyStrRef,
+    bytes_inner::PyBytesInner,
+    class::PyClassImpl,
+    common::{
+        format::FormatSpec,
+        hash,
+        int::{bigint_to_finite_float, bytes_to_int, true_div},
+    },
+    convert::{IntoPyException, ToPyObject, ToPyResult},
+    function::{
+        ArgByteOrder, ArgIntoBool, FuncArgs, OptionalArg, PyArithmeticValue, PyComparisonValue,
+    },
+    protocol::{PyNumberMethods, handle_bytes_to_int_err},
+    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+};
+use alloc::fmt;
+use core::ops::{Neg, Not};
+use malachite_bigint::{BigInt, Sign};
+use num_integer::Integer;
+use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
+
+#[pyclass(module = false, name = "int")]
+#[derive(Debug)]
+pub struct PyInt {
+    value: BigInt,
+}
+
+impl fmt::Display for PyInt {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        BigInt::fmt(&self.value, f)
+    }
+}
+
+pub type PyIntRef = PyRef<PyInt>;
+
+impl<T> From<T> for PyInt
+where
+    T: Into<BigInt>,
+{
+    fn from(v: T) -> Self {
+        Self { value: v.into() }
+    }
+}
+
+impl PyPayload for PyInt {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.int_type
+    }
+
+    fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_int(self.value).into()
+    }
+}
+
+macro_rules! impl_into_pyobject_int {
+    ($($t:ty)*) => {$(
+        impl ToPyObject for $t {
+            fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+                vm.ctx.new_int(self).into()
+            }
+        }
+    )*};
+}
+
+impl_into_pyobject_int!(isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 BigInt);
+
+macro_rules! impl_try_from_object_int {
+    ($(($t:ty, $to_prim:ident),)*) => {$(
+        impl<'a> TryFromBorrowedObject<'a> for $t {
+            fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+                obj.try_value_with(|int: &PyInt| {
+                    int.try_to_primitive(vm)
+                }, vm)
+            }
+        }
+    )*};
+}
+
+impl_try_from_object_int!(
+    (isize, to_isize),
+    (i8, to_i8),
+    (i16, to_i16),
+    (i32, to_i32),
+    (i64, to_i64),
+    (i128, to_i128),
+    (usize, to_usize),
+    (u8, to_u8),
+    (u16, to_u16),
+    (u32, to_u32),
+    (u64, to_u64),
+    (u128, to_u128),
+);
+
+fn inner_pow(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
+    if int2.is_negative() {
+        let v1 = try_to_float(int1, vm)?;
+        let v2 = try_to_float(int2, vm)?;
+        float::float_pow(v1, v2, vm)
+    } else {
+        let value = if let Some(v2) = int2.to_u64() {
+            return Ok(vm.ctx.new_int(Pow::pow(int1, v2)).into());
+        } else if int1.is_one() {
+            1
+        } else if int1.is_zero() {
+            0
+        } else if int1 == &BigInt::from(-1) {
+            if int2.is_odd() { -1 } else { 1 }
+        } else {
+            // missing feature: BigInt exp
+            // practically, exp over u64 is not possible to calculate anyway
+            return Ok(vm.ctx.not_implemented());
+        };
+        Ok(vm.ctx.new_int(value).into())
+    }
+}
+
+fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
+    if int2.is_zero() {
+        Err(vm.new_zero_division_error("integer modulo by zero"))
+    } else {
+        Ok(vm.ctx.new_int(int1.mod_floor(int2)).into())
+    }
+}
+
+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"))
+    } else {
+        Ok(vm.ctx.new_int(int1.div_floor(int2)).into())
+    }
+}
+
+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"));
+    }
+    let (div, modulo) = int1.div_mod_floor(int2);
+    Ok(vm.new_tuple((div, modulo)).into())
+}
+
+fn inner_lshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
+    inner_shift(
+        base,
+        bits,
+        |base, bits| base << bits,
+        |bits, vm| {
+            bits.to_usize()
+                .ok_or_else(|| vm.new_overflow_error("the number is too large to convert to int"))
+        },
+        vm,
+    )
+}
+
+fn inner_rshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
+    inner_shift(
+        base,
+        bits,
+        |base, bits| base >> bits,
+        |bits, _vm| Ok(bits.to_usize().unwrap_or(usize::MAX)),
+        vm,
+    )
+}
+
+fn inner_shift<F, S>(
+    base: &BigInt,
+    bits: &BigInt,
+    shift_op: F,
+    shift_bits: S,
+    vm: &VirtualMachine,
+) -> PyResult
+where
+    F: Fn(&BigInt, usize) -> BigInt,
+    S: Fn(&BigInt, &VirtualMachine) -> PyResult<usize>,
+{
+    if bits.is_negative() {
+        Err(vm.new_value_error("negative shift count"))
+    } else if base.is_zero() {
+        Ok(vm.ctx.new_int(0).into())
+    } else {
+        shift_bits(bits, vm).map(|bits| vm.ctx.new_int(shift_op(base, bits)).into())
+    }
+}
+
+fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
+    if i2.is_zero() {
+        return Err(vm.new_zero_division_error("division by zero"));
+    }
+
+    let float = true_div(i1, i2);
+
+    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(),
+        ))
+    } else {
+        Ok(vm.ctx.new_float(float).into())
+    }
+}
+
+impl Constructor for PyInt {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        if cls.is(vm.ctx.types.bool_type) {
+            return Err(vm.new_type_error("int.__new__(bool) is not safe, use bool.__new__()"));
+        }
+
+        // Optimization: return exact int as-is (only for exact int type, not subclasses)
+        if cls.is(vm.ctx.types.int_type)
+            && args.args.len() == 1
+            && args.kwargs.is_empty()
+            && args.args[0].class().is(vm.ctx.types.int_type)
+        {
+            return Ok(args.args[0].clone());
+        }
+
+        let options: IntOptions = args.bind(vm)?;
+        let value = if let OptionalArg::Present(val) = options.val_options {
+            if let OptionalArg::Present(base) = options.base {
+                let base = base
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_u32()
+                    .filter(|&v| v == 0 || (2..=36).contains(&v))
+                    .ok_or_else(|| vm.new_value_error("int() base must be >= 2 and <= 36, or 0"))?;
+                try_int_radix(&val, base, vm)
+            } else {
+                val.try_int(vm).map(|x| x.as_bigint().clone())
+            }
+        } else if let OptionalArg::Present(_) = options.base {
+            Err(vm.new_type_error("int() missing string argument"))
+        } else {
+            Ok(Zero::zero())
+        }?;
+
+        Self::with_value(cls, value, vm).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl PyInt {
+    fn with_value<T>(cls: PyTypeRef, value: T, vm: &VirtualMachine) -> PyResult<PyRef<Self>>
+    where
+        T: Into<BigInt> + ToPrimitive,
+    {
+        if cls.is(vm.ctx.types.int_type) {
+            Ok(vm.ctx.new_int(value))
+        } else if cls.is(vm.ctx.types.bool_type) {
+            Ok(vm.ctx.new_bool(!value.into().eq(&BigInt::zero())).upcast())
+        } else {
+            Self::from(value).into_ref_with_type(vm, cls)
+        }
+    }
+
+    pub const fn as_bigint(&self) -> &BigInt {
+        &self.value
+    }
+
+    // _PyLong_AsUnsignedLongMask
+    pub fn as_u32_mask(&self) -> u32 {
+        let v = self.as_bigint();
+        v.to_u32()
+            .or_else(|| v.to_i32().map(|i| i as u32))
+            .unwrap_or_else(|| {
+                let mut out = 0u32;
+                for digit in v.iter_u32_digits() {
+                    out = out.wrapping_shl(32) | digit;
+                }
+                match v.sign() {
+                    Sign::Minus => out * -1i32 as u32,
+                    _ => out,
+                }
+            })
+    }
+
+    pub fn try_to_primitive<'a, I>(&'a self, vm: &VirtualMachine) -> PyResult<I>
+    where
+        I: PrimInt + TryFrom<&'a BigInt>,
+    {
+        I::try_from(self.as_bigint()).map_err(|_| {
+            vm.new_overflow_error(format!(
+                "Python int too large to convert to Rust {}",
+                core::any::type_name::<I>()
+            ))
+        })
+    }
+
+    #[inline]
+    fn int_op<F>(&self, other: PyObjectRef, op: F) -> PyArithmeticValue<BigInt>
+    where
+        F: Fn(&BigInt, &BigInt) -> BigInt,
+    {
+        let r = other
+            .downcast_ref::<Self>()
+            .map(|other| op(&self.value, &other.value));
+        PyArithmeticValue::from_option(r)
+    }
+
+    #[inline]
+    fn general_op<F>(&self, other: PyObjectRef, op: F, vm: &VirtualMachine) -> PyResult
+    where
+        F: Fn(&BigInt, &BigInt) -> PyResult,
+    {
+        if let Some(other) = other.downcast_ref::<Self>() {
+            op(&self.value, &other.value)
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+}
+
+#[pyclass(
+    itemsize = 4,
+    flags(BASETYPE, _MATCH_SELF),
+    with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
+)]
+impl PyInt {
+    pub(crate) fn __xor__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+        self.int_op(other, |a, b| a ^ b)
+    }
+
+    pub(crate) fn __or__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+        self.int_op(other, |a, b| a | b)
+    }
+
+    pub(crate) fn __and__(&self, other: PyObjectRef) -> PyArithmeticValue<BigInt> {
+        self.int_op(other, |a, b| a & b)
+    }
+
+    fn modpow(&self, other: PyObjectRef, modulus: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let modulus = match modulus.downcast_ref::<Self>() {
+            Some(val) => val.as_bigint(),
+            None => return Ok(vm.ctx.not_implemented()),
+        };
+        if modulus.is_zero() {
+            return Err(vm.new_value_error("pow() 3rd argument cannot be 0"));
+        }
+
+        self.general_op(
+            other,
+            |a, b| {
+                let i = if b.is_negative() {
+                    // modular multiplicative inverse
+                    // based on rust-num/num-integer#10, should hopefully be published soon
+                    fn normalize(a: BigInt, n: &BigInt) -> BigInt {
+                        let a = a % n;
+                        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))
+                        } else {
+                            None
+                        }
+                    }
+                    let a = inverse(a % modulus, modulus).ok_or_else(|| {
+                        vm.new_value_error("base is not invertible for the given modulus")
+                    })?;
+                    let b = -b;
+                    a.modpow(&b, modulus)
+                } else {
+                    a.modpow(b, modulus)
+                };
+                Ok(vm.ctx.new_int(i).into())
+            },
+            vm,
+        )
+    }
+
+    #[pymethod]
+    fn __round__(
+        zelf: PyRef<Self>,
+        ndigits: OptionalArg<PyIntRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<Self>> {
+        if let OptionalArg::Present(ndigits) = ndigits {
+            let ndigits = ndigits.as_bigint();
+            // round(12345, -2) == 12300
+            // If precision >= 0, then any integer is already rounded correctly
+            if let Some(ndigits) = ndigits.neg().to_u32()
+                && ndigits > 0
+            {
+                // Work with positive integers and negate at the end if necessary
+                let sign = if zelf.value.is_negative() {
+                    BigInt::from(-1)
+                } else {
+                    BigInt::from(1)
+                };
+                let value = zelf.value.abs();
+
+                // Divide and multiply by the power of 10 to get the approximate answer
+                let pow10 = BigInt::from(10).pow(ndigits);
+                let quotient = &value / &pow10;
+                let rounded = &quotient * &pow10;
+
+                // Malachite division uses floor rounding, Python uses half-even
+                let remainder = &value - &rounded;
+                let half_pow10 = &pow10 / BigInt::from(2);
+                let correction =
+                    if remainder > half_pow10 || (remainder == half_pow10 && quotient.is_odd()) {
+                        pow10
+                    } else {
+                        BigInt::from(0)
+                    };
+                let rounded = (rounded + correction) * sign;
+                return Ok(vm.ctx.new_int(rounded));
+            }
+        }
+        Ok(zelf)
+    }
+
+    #[pymethod]
+    fn __trunc__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[pymethod]
+    fn __floor__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[pymethod]
+    fn __ceil__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[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))
+            .map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[pymethod]
+    fn __sizeof__(&self) -> usize {
+        core::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
+    }
+
+    #[pymethod]
+    fn as_integer_ratio(&self, vm: &VirtualMachine) -> (PyRef<Self>, i32) {
+        (vm.ctx.new_bigint(&self.value), 1)
+    }
+
+    #[pymethod]
+    fn bit_length(&self) -> u64 {
+        self.value.bits()
+    }
+
+    #[pymethod]
+    fn conjugate(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[pyclassmethod]
+    fn from_bytes(
+        cls: PyTypeRef,
+        args: IntFromByteArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<Self>> {
+        let signed = args.signed.map_or(false, Into::into);
+        let value = match (args.byteorder, signed) {
+            (ArgByteOrder::Big, true) => BigInt::from_signed_bytes_be(args.bytes.as_bytes()),
+            (ArgByteOrder::Big, false) => BigInt::from_bytes_be(Sign::Plus, args.bytes.as_bytes()),
+            (ArgByteOrder::Little, true) => BigInt::from_signed_bytes_le(args.bytes.as_bytes()),
+            (ArgByteOrder::Little, false) => {
+                BigInt::from_bytes_le(Sign::Plus, args.bytes.as_bytes())
+            }
+        };
+        Self::with_value(cls, value, vm)
+    }
+
+    #[pymethod]
+    fn to_bytes(&self, args: IntToByteArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
+        let signed = args.signed.map_or(false, Into::into);
+        let byte_len = args.length;
+
+        let value = self.as_bigint();
+        match value.sign() {
+            Sign::Minus if !signed => {
+                return Err(vm.new_overflow_error("can't convert negative int to unsigned"));
+            }
+            Sign::NoSign => return Ok(vec![0u8; byte_len].into()),
+            _ => {}
+        }
+
+        let mut origin_bytes = match (args.byteorder, signed) {
+            (ArgByteOrder::Big, true) => value.to_signed_bytes_be(),
+            (ArgByteOrder::Big, false) => value.to_bytes_be().1,
+            (ArgByteOrder::Little, true) => value.to_signed_bytes_le(),
+            (ArgByteOrder::Little, false) => value.to_bytes_le().1,
+        };
+
+        let origin_len = origin_bytes.len();
+        if origin_len > byte_len {
+            return Err(vm.new_overflow_error("int too big to convert"));
+        }
+
+        let mut append_bytes = match value.sign() {
+            Sign::Minus => vec![255u8; byte_len - origin_len],
+            _ => vec![0u8; byte_len - origin_len],
+        };
+
+        let bytes = match args.byteorder {
+            ArgByteOrder::Big => {
+                let mut bytes = append_bytes;
+                bytes.append(&mut origin_bytes);
+                bytes
+            }
+            ArgByteOrder::Little => {
+                let mut bytes = origin_bytes;
+                bytes.append(&mut append_bytes);
+                bytes
+            }
+        };
+        Ok(bytes.into())
+    }
+
+    #[pygetset]
+    fn real(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[pygetset]
+    const fn imag(&self) -> usize {
+        0
+    }
+
+    #[pygetset]
+    fn numerator(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
+        zelf.__int__(vm)
+    }
+
+    #[pygetset]
+    const fn denominator(&self) -> usize {
+        1
+    }
+
+    #[pymethod]
+    const fn is_integer(&self) -> bool {
+        true
+    }
+
+    #[pymethod]
+    fn bit_count(&self) -> u32 {
+        self.value.iter_u32_digits().map(|n| n.count_ones()).sum()
+    }
+
+    #[pymethod]
+    fn __getnewargs__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        (self.value.clone(),).to_pyobject(vm)
+    }
+}
+
+#[pyclass]
+impl PyRef<PyInt> {
+    pub(crate) fn __int__(self, vm: &VirtualMachine) -> PyRefExact<PyInt> {
+        self.into_exact_or(&vm.ctx, |zelf| unsafe {
+            // TODO: this is actually safe. we need better interface
+            PyRefExact::new_unchecked(vm.ctx.new_bigint(&zelf.value))
+        })
+    }
+}
+
+impl Comparable for PyInt {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        let r = other
+            .downcast_ref::<Self>()
+            .map(|other| op.eval_ord(zelf.value.cmp(&other.value)));
+        Ok(PyComparisonValue::from_option(r))
+    }
+}
+
+impl Representable for PyInt {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        Ok(zelf.value.to_string())
+    }
+}
+
+impl Hashable for PyInt {
+    #[inline]
+    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        Ok(hash::hash_bigint(zelf.as_bigint()))
+    }
+}
+
+impl AsNumber for PyInt {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyInt::AS_NUMBER;
+        &AS_NUMBER
+    }
+
+    #[inline]
+    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
+        vm.ctx.new_bigint(&zelf.value)
+    }
+}
+
+impl PyInt {
+    pub(super) const AS_NUMBER: PyNumberMethods = PyNumberMethods {
+        add: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a + b, vm)),
+        subtract: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a - b, vm)),
+        multiply: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a * b, vm)),
+        remainder: Some(|a, b, vm| Self::number_op(a, b, inner_mod, vm)),
+        divmod: Some(|a, b, vm| Self::number_op(a, b, inner_divmod, vm)),
+        power: Some(|a, b, c, vm| {
+            if let Some(a) = a.downcast_ref::<Self>() {
+                if vm.is_none(c) {
+                    a.general_op(b.to_owned(), |a, b| inner_pow(a, b, vm), vm)
+                } else {
+                    a.modpow(b.to_owned(), c.to_owned(), vm)
+                }
+            } else {
+                Ok(vm.ctx.not_implemented())
+            }
+        }),
+        negative: Some(|num, vm| (&Self::number_downcast(num).value).neg().to_pyresult(vm)),
+        positive: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
+        absolute: Some(|num, vm| Self::number_downcast(num).value.abs().to_pyresult(vm)),
+        boolean: Some(|num, _vm| Ok(!Self::number_downcast(num).value.is_zero())),
+        invert: Some(|num, vm| (&Self::number_downcast(num).value).not().to_pyresult(vm)),
+        lshift: Some(|a, b, vm| Self::number_op(a, b, inner_lshift, vm)),
+        rshift: Some(|a, b, vm| Self::number_op(a, b, inner_rshift, vm)),
+        and: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a & b, vm)),
+        xor: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a ^ b, vm)),
+        or: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a | b, vm)),
+        int: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
+        float: Some(|num, vm| {
+            let zelf = Self::number_downcast(num);
+            try_to_float(&zelf.value, vm).map(|x| vm.ctx.new_float(x).into())
+        }),
+        floor_divide: Some(|a, b, vm| Self::number_op(a, b, inner_floordiv, vm)),
+        true_divide: Some(|a, b, vm| Self::number_op(a, b, inner_truediv, vm)),
+        index: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
+        ..PyNumberMethods::NOT_IMPLEMENTED
+    };
+
+    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
+    where
+        F: FnOnce(&BigInt, &BigInt, &VirtualMachine) -> R,
+        R: ToPyResult,
+    {
+        if let (Some(a), Some(b)) = (a.downcast_ref::<Self>(), b.downcast_ref::<Self>()) {
+            op(&a.value, &b.value, vm).to_pyresult(vm)
+        } else {
+            Ok(vm.ctx.not_implemented())
+        }
+    }
+}
+
+#[derive(FromArgs)]
+pub struct IntOptions {
+    #[pyarg(positional, optional)]
+    val_options: OptionalArg<PyObjectRef>,
+    #[pyarg(any, optional)]
+    base: OptionalArg<PyObjectRef>,
+}
+
+#[derive(FromArgs)]
+struct IntFromByteArgs {
+    bytes: PyBytesInner,
+    #[pyarg(any, default = ArgByteOrder::Big)]
+    byteorder: ArgByteOrder,
+    #[pyarg(named, optional)]
+    signed: OptionalArg<ArgIntoBool>,
+}
+
+#[derive(FromArgs)]
+struct IntToByteArgs {
+    #[pyarg(any, default = 1)]
+    length: usize,
+    #[pyarg(any, default = ArgByteOrder::Big)]
+    byteorder: ArgByteOrder,
+    #[pyarg(named, optional)]
+    signed: OptionalArg<ArgIntoBool>,
+}
+
+fn try_int_radix(obj: &PyObject, base: u32, vm: &VirtualMachine) -> PyResult<BigInt> {
+    match_class!(match obj.to_owned() {
+        string @ PyStr => {
+            let s = string.as_wtf8().trim();
+            bytes_to_int(s.as_bytes(), base, vm.state.int_max_str_digits.load())
+                .map_err(|e| handle_bytes_to_int_err(e, obj, vm))
+        }
+        bytes @ PyBytes => {
+            bytes_to_int(bytes.as_bytes(), base, vm.state.int_max_str_digits.load())
+                .map_err(|e| handle_bytes_to_int_err(e, obj, vm))
+        }
+        bytearray @ PyByteArray => {
+            let inner = bytearray.borrow_buf();
+            bytes_to_int(&inner, base, vm.state.int_max_str_digits.load())
+                .map_err(|e| handle_bytes_to_int_err(e, obj, vm))
+        }
+        _ => Err(vm.new_type_error("int() can't convert non-string with explicit base")),
+    })
+}
+
+// Retrieve inner int value:
+pub(crate) fn get_value(obj: &PyObject) -> &BigInt {
+    &obj.downcast_ref::<PyInt>().unwrap().value
+}
+
+pub fn try_to_float(int: &BigInt, vm: &VirtualMachine) -> PyResult<f64> {
+    bigint_to_finite_float(int)
+        .ok_or_else(|| vm.new_overflow_error("int too large to convert to float"))
+}
+
+pub(crate) fn init(context: &Context) {
+    PyInt::extend_class(context, context.types.int_type);
+}
diff --git a/crates/vm/src/builtins/interpolation.rs b/crates/vm/src/builtins/interpolation.rs
new file mode 100644
index 0000000000..1d29ad7b49
--- /dev/null
+++ b/crates/vm/src/builtins/interpolation.rs
@@ -0,0 +1,219 @@
+use super::{PyStr, PyStrRef, PyTupleRef, PyType, tuple::IntoPyTuple};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    common::hash::PyHash,
+    convert::ToPyObject,
+    function::{OptionalArg, PyComparisonValue},
+    types::{Comparable, Constructor, Hashable, PyComparisonOp, Representable},
+};
+
+/// Interpolation object for t-strings (PEP 750).
+///
+/// Represents an interpolated expression within a template string.
+#[pyclass(module = "string.templatelib", name = "Interpolation")]
+#[derive(Debug, Clone)]
+pub struct PyInterpolation {
+    pub value: PyObjectRef,
+    pub expression: PyStrRef,
+    pub conversion: PyObjectRef, // None or 's', 'r', 'a'
+    pub format_spec: PyStrRef,
+}
+
+impl PyPayload for PyInterpolation {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.interpolation_type
+    }
+}
+
+impl PyInterpolation {
+    pub fn new(
+        value: PyObjectRef,
+        expression: PyStrRef,
+        conversion: PyObjectRef,
+        format_spec: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        // Validate conversion like _PyInterpolation_Build does
+        let is_valid = vm.is_none(&conversion)
+            || conversion
+                .downcast_ref::<PyStr>()
+                .is_some_and(|s| matches!(s.as_str(), "s" | "r" | "a"));
+        if !is_valid {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.system_error.to_owned(),
+                "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'".to_owned(),
+            ));
+        }
+        Ok(Self {
+            value,
+            expression,
+            conversion,
+            format_spec,
+        })
+    }
+}
+
+impl Constructor for PyInterpolation {
+    type Args = InterpolationArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        let conversion = match args.conversion {
+            OptionalArg::Present(c) => {
+                if vm.is_none(&c) {
+                    vm.ctx.none()
+                } else {
+                    let s = c.downcast::<PyStr>().map_err(|_| {
+                        vm.new_type_error(
+                            "Interpolation() argument 'conversion' must be str or None",
+                        )
+                    })?;
+                    let s_str = s.as_str();
+                    if s_str.len() != 1 || !matches!(s_str.chars().next(), Some('s' | 'r' | 'a')) {
+                        return Err(vm.new_value_error(
+                            "Interpolation() argument 'conversion' must be one of 's', 'a' or 'r'",
+                        ));
+                    }
+                    s.into()
+                }
+            }
+            OptionalArg::Missing => vm.ctx.none(),
+        };
+
+        let expression = args
+            .expression
+            .unwrap_or_else(|| vm.ctx.empty_str.to_owned());
+        let format_spec = args
+            .format_spec
+            .unwrap_or_else(|| vm.ctx.empty_str.to_owned());
+
+        Ok(PyInterpolation {
+            value: args.value,
+            expression,
+            conversion,
+            format_spec,
+        })
+    }
+}
+
+#[derive(FromArgs)]
+pub struct InterpolationArgs {
+    #[pyarg(positional)]
+    value: PyObjectRef,
+    #[pyarg(any, optional)]
+    expression: OptionalArg<PyStrRef>,
+    #[pyarg(any, optional)]
+    conversion: OptionalArg<PyObjectRef>,
+    #[pyarg(any, optional)]
+    format_spec: OptionalArg<PyStrRef>,
+}
+
+#[pyclass(with(Constructor, Comparable, Hashable, Representable))]
+impl PyInterpolation {
+    #[pyattr]
+    fn __match_args__(ctx: &Context) -> PyTupleRef {
+        ctx.new_tuple(vec![
+            ctx.intern_str("value").to_owned().into(),
+            ctx.intern_str("expression").to_owned().into(),
+            ctx.intern_str("conversion").to_owned().into(),
+            ctx.intern_str("format_spec").to_owned().into(),
+        ])
+    }
+
+    #[pygetset]
+    fn value(&self) -> PyObjectRef {
+        self.value.clone()
+    }
+
+    #[pygetset]
+    fn expression(&self) -> PyStrRef {
+        self.expression.clone()
+    }
+
+    #[pygetset]
+    fn conversion(&self) -> PyObjectRef {
+        self.conversion.clone()
+    }
+
+    #[pygetset]
+    fn format_spec(&self) -> PyStrRef {
+        self.format_spec.clone()
+    }
+
+    #[pymethod]
+    fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
+        let cls = zelf.class().to_owned();
+        let args = (
+            zelf.value.clone(),
+            zelf.expression.clone(),
+            zelf.conversion.clone(),
+            zelf.format_spec.clone(),
+        );
+        (cls, args.to_pyobject(vm)).into_pytuple(vm)
+    }
+}
+
+impl Comparable for PyInterpolation {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+
+            let eq = vm.bool_eq(&zelf.value, &other.value)?
+                && vm.bool_eq(zelf.expression.as_object(), other.expression.as_object())?
+                && vm.bool_eq(&zelf.conversion, &other.conversion)?
+                && vm.bool_eq(zelf.format_spec.as_object(), other.format_spec.as_object())?;
+
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Hashable for PyInterpolation {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        // Hash based on (value, expression, conversion, format_spec)
+        let value_hash = zelf.value.hash(vm)?;
+        let expr_hash = zelf.expression.as_object().hash(vm)?;
+        let conv_hash = zelf.conversion.hash(vm)?;
+        let spec_hash = zelf.format_spec.as_object().hash(vm)?;
+
+        // Combine hashes
+        Ok(value_hash
+            .wrapping_add(expr_hash.wrapping_mul(3))
+            .wrapping_add(conv_hash.wrapping_mul(5))
+            .wrapping_add(spec_hash.wrapping_mul(7)))
+    }
+}
+
+impl Representable for PyInterpolation {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let value_repr = zelf.value.repr(vm)?;
+        let expr_repr = zelf.expression.repr(vm)?;
+
+        let conv_str = if vm.is_none(&zelf.conversion) {
+            "None".to_owned()
+        } else {
+            zelf.conversion.repr(vm)?.as_str().to_owned()
+        };
+
+        let spec_repr = zelf.format_spec.repr(vm)?;
+
+        Ok(format!(
+            "Interpolation({}, {}, {}, {})",
+            value_repr.as_str(),
+            expr_repr.as_str(),
+            conv_str,
+            spec_repr.as_str()
+        ))
+    }
+}
+
+pub fn init(context: &Context) {
+    PyInterpolation::extend_class(context, context.types.interpolation_type);
+}
diff --git a/crates/vm/src/builtins/iter.rs b/crates/vm/src/builtins/iter.rs
new file mode 100644
index 0000000000..736303e95e
--- /dev/null
+++ b/crates/vm/src/builtins/iter.rs
@@ -0,0 +1,279 @@
+/*
+ * iterator types
+ */
+
+use super::{PyInt, PyTupleRef, PyType};
+use crate::{
+    Context, Py, PyObject, 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,
+};
+
+/// Marks status of iterator.
+#[derive(Debug, Clone)]
+pub enum IterStatus<T> {
+    /// Iterator hasn't raised StopIteration.
+    Active(T),
+    /// Iterator has raised StopIteration.
+    Exhausted,
+}
+
+unsafe impl<T: Traverse> Traverse for IterStatus<T> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        match self {
+            Self::Active(r) => r.traverse(tracer_fn),
+            Self::Exhausted => (),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PositionIterInternal<T> {
+    pub status: IterStatus<T>,
+    pub position: usize,
+}
+
+unsafe impl<T: Traverse> Traverse for PositionIterInternal<T> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.status.traverse(tracer_fn)
+    }
+}
+
+impl<T> PositionIterInternal<T> {
+    pub const fn new(obj: T, position: usize) -> Self {
+        Self {
+            status: IterStatus::Active(obj),
+            position,
+        }
+    }
+
+    pub fn set_state<F>(&mut self, state: PyObjectRef, f: F, vm: &VirtualMachine) -> PyResult<()>
+    where
+        F: FnOnce(&T, usize) -> usize,
+    {
+        if let IterStatus::Active(obj) = &self.status {
+            if let Some(i) = state.downcast_ref::<PyInt>() {
+                let i = i.try_to_primitive(vm).unwrap_or(0);
+                self.position = f(obj, i);
+                Ok(())
+            } else {
+                Err(vm.new_type_error("an integer is required."))
+            }
+        } else {
+            Ok(())
+        }
+    }
+
+    fn _reduce<F>(&self, func: PyObjectRef, f: F, vm: &VirtualMachine) -> PyTupleRef
+    where
+        F: FnOnce(&T) -> PyObjectRef,
+    {
+        if let IterStatus::Active(obj) = &self.status {
+            vm.new_tuple((func, (f(obj),), self.position))
+        } else {
+            vm.new_tuple((func, (vm.ctx.new_list(Vec::new()),)))
+        }
+    }
+
+    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>,
+        OP: FnOnce(&mut Self),
+    {
+        if let IterStatus::Active(obj) = &self.status {
+            let ret = f(obj, self.position);
+            if let Ok(PyIterReturn::Return(_)) = ret {
+                op(self);
+            } else {
+                self.status = IterStatus::Exhausted;
+            }
+            ret
+        } else {
+            Ok(PyIterReturn::StopIteration(None))
+        }
+    }
+
+    pub fn next<F>(&mut self, f: F) -> PyResult<PyIterReturn>
+    where
+        F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,
+    {
+        self._next(f, |zelf| zelf.position += 1)
+    }
+
+    pub fn rev_next<F>(&mut self, f: F) -> PyResult<PyIterReturn>
+    where
+        F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,
+    {
+        self._next(f, |zelf| {
+            if zelf.position == 0 {
+                zelf.status = IterStatus::Exhausted;
+            } else {
+                zelf.position -= 1;
+            }
+        })
+    }
+
+    pub fn length_hint<F>(&self, f: F) -> usize
+    where
+        F: FnOnce(&T) -> usize,
+    {
+        if let IterStatus::Active(obj) = &self.status {
+            f(obj).saturating_sub(self.position)
+        } else {
+            0
+        }
+    }
+
+    pub fn rev_length_hint<F>(&self, f: F) -> usize
+    where
+        F: FnOnce(&T) -> usize,
+    {
+        if let IterStatus::Active(obj) = &self.status
+            && self.position <= f(obj)
+        {
+            return self.position + 1;
+        }
+        0
+    }
+}
+
+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_reversed(vm: &VirtualMachine) -> &PyObject {
+    static_cell! {
+        static INSTANCE: PyObjectRef;
+    }
+    INSTANCE.get_or_init(|| vm.builtins.get_attr("reversed", vm).unwrap())
+}
+
+#[pyclass(module = false, name = "iterator", traverse)]
+#[derive(Debug)]
+pub struct PySequenceIterator {
+    internal: PyMutex<PositionIterInternal<PyObjectRef>>,
+}
+
+impl PyPayload for PySequenceIterator {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.iter_type
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PySequenceIterator {
+    pub fn new(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+        let _seq = obj.try_sequence(vm)?;
+        Ok(Self {
+            internal: PyMutex::new(PositionIterInternal::new(obj, 0)),
+        })
+    }
+
+    #[pymethod]
+    fn __length_hint__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        let internal = self.internal.lock();
+        if let IterStatus::Active(obj) = &internal.status {
+            let seq = obj.sequence_unchecked();
+            seq.length(vm)
+                .map(|x| PyInt::from(x).into_pyobject(vm))
+                .unwrap_or_else(|_| vm.ctx.not_implemented())
+        } else {
+            PyInt::from(0).into_pyobject(vm)
+        }
+    }
+
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        self.internal.lock().builtins_iter_reduce(|x| x.clone(), vm)
+    }
+
+    #[pymethod]
+    fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        self.internal.lock().set_state(state, |_, pos| pos, vm)
+    }
+}
+
+impl SelfIter for PySequenceIterator {}
+impl IterNext for PySequenceIterator {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        zelf.internal.lock().next(|obj, pos| {
+            let seq = obj.sequence_unchecked();
+            PyIterReturn::from_getitem_result(seq.get_item(pos as isize, vm), vm)
+        })
+    }
+}
+
+#[pyclass(module = false, name = "callable_iterator", traverse)]
+#[derive(Debug)]
+pub struct PyCallableIterator {
+    sentinel: PyObjectRef,
+    status: PyRwLock<IterStatus<ArgCallable>>,
+}
+
+impl PyPayload for PyCallableIterator {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.callable_iterator
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyCallableIterator {
+    pub const fn new(callable: ArgCallable, sentinel: PyObjectRef) -> Self {
+        Self {
+            sentinel,
+            status: PyRwLock::new(IterStatus::Active(callable)),
+        }
+    }
+}
+
+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)
+            }
+        } else {
+            PyIterReturn::StopIteration(None)
+        };
+        Ok(next)
+    }
+}
+
+pub fn init(context: &Context) {
+    PySequenceIterator::extend_class(context, context.types.iter_type);
+    PyCallableIterator::extend_class(context, context.types.callable_iterator);
+}
diff --git a/vm/src/builtins/list.rs b/crates/vm/src/builtins/list.rs
similarity index 92%
rename from vm/src/builtins/list.rs
rename to crates/vm/src/builtins/list.rs
index 4f05390147..02475ee12b 100644
--- a/vm/src/builtins/list.rs
+++ b/crates/vm/src/builtins/list.rs
@@ -15,12 +15,13 @@ use crate::{
     sliceable::{SequenceIndex, SliceableSequenceMutOp, SliceableSequenceOp},
     types::{
         AsMapping, AsSequence, Comparable, Constructor, Initializer, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
 };
-use std::{fmt, ops::DerefMut};
+use alloc::fmt;
+use core::ops::DerefMut;
 
 #[pyclass(module = false, name = "list", unhashable = true, traverse)]
 #[derive(Default)]
@@ -63,8 +64,9 @@ impl ToPyObject for Vec<PyObjectRef> {
 }
 
 impl PyList {
+    #[deprecated(note = "use PyList::from(...).into_ref() instead")]
     pub fn new_ref(elements: Vec<PyObjectRef>, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(elements), ctx.types.list_type.to_owned(), None)
+        Self::from(elements).into_ref(ctx)
     }
 
     pub fn borrow_vec(&self) -> PyMappedRwLockReadGuard<'_, [PyObjectRef]> {
@@ -108,7 +110,7 @@ pub type PyListRef = PyRef<PyList>;
         AsSequence,
         Representable
     ),
-    flags(BASETYPE)
+    flags(BASETYPE, SEQUENCE, _MATCH_SELF)
 )]
 impl PyList {
     #[pymethod]
@@ -131,7 +133,7 @@ impl PyList {
     }
 
     fn concat(&self, other: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        let other = other.payload_if_subclass::<Self>(vm).ok_or_else(|| {
+        let other = other.downcast_ref::<Self>().ok_or_else(|| {
             vm.new_type_error(format!(
                 "Cannot add {} and {}",
                 Self::class(&vm.ctx).name(),
@@ -143,7 +145,6 @@ impl PyList {
         Ok(Self::from(elements).into_ref(&vm.ctx))
     }
 
-    #[pymethod]
     fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         self.concat(&other, vm)
     }
@@ -158,7 +159,6 @@ impl PyList {
         Ok(zelf.to_owned().into())
     }
 
-    #[pymethod]
     fn __iadd__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -171,7 +171,7 @@ impl PyList {
 
     #[pymethod]
     fn clear(&self) {
-        let _removed = std::mem::take(self.borrow_vec_mut().deref_mut());
+        let _removed = core::mem::take(self.borrow_vec_mut().deref_mut());
     }
 
     #[pymethod]
@@ -180,15 +180,14 @@ impl PyList {
     }
 
     #[allow(clippy::len_without_is_empty)]
-    #[pymethod]
     pub fn __len__(&self) -> usize {
         self.borrow_vec().len()
     }
 
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>()
-            + self.elements.read().capacity() * std::mem::size_of::<PyObjectRef>()
+        core::mem::size_of::<Self>()
+            + self.elements.read().capacity() * core::mem::size_of::<PyObjectRef>()
     }
 
     #[pymethod]
@@ -214,7 +213,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
@@ -229,7 +227,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
@@ -239,13 +236,10 @@ impl PyList {
         self._setitem(&needle, value, vm)
     }
 
-    #[pymethod]
-    #[pymethod(name = "__rmul__")]
     fn __mul__(&self, n: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         self.repeat(n.into(), vm)
     }
 
-    #[pymethod]
     fn __imul__(zelf: PyRef<Self>, n: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::irepeat(zelf, n.into(), vm)
     }
@@ -255,7 +249,6 @@ impl PyList {
         self.mut_count(vm, &needle)
     }
 
-    #[pymethod]
     pub(crate) fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self.mut_contains(vm, &needle)
     }
@@ -313,7 +306,6 @@ impl PyList {
         }
     }
 
-    #[pymethod]
     fn __delitem__(&self, subscript: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         self._delitem(&subscript, vm)
     }
@@ -323,9 +315,9 @@ impl PyList {
         // replace list contents with [] for duration of sort.
         // this prevents keyfunc from messing with the list and makes it easy to
         // check if it tries to append elements to it.
-        let mut elements = std::mem::take(self.borrow_vec_mut().deref_mut());
+        let mut elements = core::mem::take(self.borrow_vec_mut().deref_mut());
         let res = do_sort(vm, &mut elements, options.key, options.reverse);
-        std::mem::swap(self.borrow_vec_mut().deref_mut(), &mut elements);
+        core::mem::swap(self.borrow_vec_mut().deref_mut(), &mut elements);
         res?;
 
         if !elements.is_empty() {
@@ -346,14 +338,18 @@ where
     F: FnMut(PyObjectRef) -> PyResult<R>,
 {
     use crate::builtins::PyTuple;
-    if let Some(tuple) = obj.payload_if_exact::<PyTuple>(vm) {
+    if let Some(tuple) = obj.downcast_ref_if_exact::<PyTuple>(vm) {
         tuple.iter().map(|x| f(x.clone())).collect()
-    } else if let Some(list) = obj.payload_if_exact::<PyList>(vm) {
+    } else if let Some(list) = obj.downcast_ref_if_exact::<PyList>(vm) {
         list.borrow_vec().iter().map(|x| f(x.clone())).collect()
     } else {
         let iter = obj.to_owned().get_iter(vm)?;
         let iter = iter.iter::<PyObjectRef>(vm)?;
-        let len = obj.to_sequence().length_opt(vm).transpose()?.unwrap_or(0);
+        let len = obj
+            .sequence_unchecked()
+            .length_opt(vm)
+            .transpose()?
+            .unwrap_or(0);
         let mut v = Vec::with_capacity(len);
         for x in iter {
             v.push(f(x?)?);
@@ -366,11 +362,11 @@ where
 impl MutObjectSequenceOp for PyList {
     type Inner = [PyObjectRef];
 
-    fn do_get(index: usize, inner: &[PyObjectRef]) -> Option<&PyObjectRef> {
-        inner.get(index)
+    fn do_get(index: usize, inner: &[PyObjectRef]) -> Option<&PyObject> {
+        inner.get(index).map(|r| r.as_ref())
     }
 
-    fn do_lock(&self) -> impl std::ops::Deref<Target = [PyObjectRef]> {
+    fn do_lock(&self) -> impl core::ops::Deref<Target = [PyObjectRef]> {
         self.borrow_vec()
     }
 }
@@ -378,8 +374,8 @@ impl MutObjectSequenceOp for PyList {
 impl Constructor for PyList {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Self::default().into_ref_with_type(vm, cls).map(Into::into)
+    fn py_new(_cls: &Py<PyType>, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self::default())
     }
 }
 
@@ -392,7 +388,7 @@ impl Initializer for PyList {
         } else {
             vec![]
         };
-        std::mem::swap(zelf.borrow_vec_mut().deref_mut(), &mut elements);
+        core::mem::swap(zelf.borrow_vec_mut().deref_mut(), &mut elements);
         Ok(())
     }
 }
@@ -543,7 +539,7 @@ impl PyPayload for PyListIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyListIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -564,7 +560,6 @@ impl PyListIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyListIterator {}
 
 impl SelfIter for PyListIterator {}
 impl IterNext for PyListIterator {
@@ -589,7 +584,7 @@ impl PyPayload for PyListReverseIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyListReverseIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -610,7 +605,6 @@ impl PyListReverseIterator {
             .builtins_reversed_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyListReverseIterator {}
 
 impl SelfIter for PyListReverseIterator {}
 impl IterNext for PyListReverseIterator {
diff --git a/vm/src/builtins/map.rs b/crates/vm/src/builtins/map.rs
similarity index 79%
rename from vm/src/builtins/map.rs
rename to crates/vm/src/builtins/map.rs
index 004028c2cb..f83030824f 100644
--- a/vm/src/builtins/map.rs
+++ b/crates/vm/src/builtins/map.rs
@@ -5,6 +5,7 @@ use crate::{
     class::PyClassImpl,
     function::PosArgs,
     protocol::{PyIter, PyIterReturn},
+    raise_if_stop,
     types::{Constructor, IterNext, Iterable, SelfIter},
 };
 
@@ -25,11 +26,13 @@ impl PyPayload for PyMap {
 impl Constructor for PyMap {
     type Args = (PyObjectRef, PosArgs<PyIter>);
 
-    fn py_new(cls: PyTypeRef, (mapper, iterators): Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn py_new(
+        _cls: &Py<PyType>,
+        (mapper, iterators): Self::Args,
+        _vm: &VirtualMachine,
+    ) -> PyResult<Self> {
         let iterators = iterators.into_vec();
-        Self { mapper, iterators }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+        Ok(Self { mapper, iterators })
     }
 }
 
@@ -39,7 +42,7 @@ impl PyMap {
     fn __length_hint__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         self.iterators.iter().try_fold(0, |prev, cur| {
             let cur = cur.as_ref().to_owned().length_hint(0, vm)?;
-            let max = std::cmp::max(prev, cur);
+            let max = core::cmp::max(prev, cur);
             Ok(max)
         })
     }
@@ -53,14 +56,12 @@ impl PyMap {
 }
 
 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 = match iterator.next(vm)? {
-                PyIterReturn::Return(obj) => obj,
-                PyIterReturn::StopIteration(v) => return Ok(PyIterReturn::StopIteration(v)),
-            };
+            let item = raise_if_stop!(iterator.next(vm)?);
             next_objs.push(item);
         }
 
diff --git a/vm/src/builtins/mappingproxy.rs b/crates/vm/src/builtins/mappingproxy.rs
similarity index 88%
rename from vm/src/builtins/mappingproxy.rs
rename to crates/vm/src/builtins/mappingproxy.rs
index 5ba6597e1f..f7fb64fa6a 100644
--- a/vm/src/builtins/mappingproxy.rs
+++ b/crates/vm/src/builtins/mappingproxy.rs
@@ -6,7 +6,7 @@ use crate::{
     convert::ToPyObject,
     function::{ArgMapping, OptionalArg, PyComparisonValue},
     object::{Traverse, TraverseFn},
-    protocol::{PyMapping, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    protocol::{PyMappingMethods, PyNumberMethods, PySequenceMethods},
     types::{
         AsMapping, AsNumber, AsSequence, Comparable, Constructor, Iterable, PyComparisonOp,
         Representable,
@@ -61,20 +61,14 @@ impl From<PyDictRef> for PyMappingProxy {
 impl Constructor for PyMappingProxy {
     type Args = PyObjectRef;
 
-    fn py_new(cls: PyTypeRef, mapping: Self::Args, vm: &VirtualMachine) -> PyResult {
-        if let Some(methods) = PyMapping::find_methods(&mapping) {
-            if mapping.payload_if_subclass::<PyList>(vm).is_none()
-                && mapping.payload_if_subclass::<PyTuple>(vm).is_none()
-            {
-                return Self {
-                    mapping: MappingProxyInner::Mapping(ArgMapping::with_methods(
-                        mapping,
-                        unsafe { methods.borrow_static() },
-                    )),
-                }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into);
-            }
+    fn py_new(_cls: &Py<PyType>, mapping: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        if mapping.mapping_unchecked().check()
+            && !mapping.downcastable::<PyList>()
+            && !mapping.downcastable::<PyTuple>()
+        {
+            return Ok(Self {
+                mapping: MappingProxyInner::Mapping(ArgMapping::new(mapping)),
+            });
         }
         Err(vm.new_type_error(format!(
             "mappingproxy() argument must be a mapping, not {}",
@@ -117,7 +111,6 @@ impl PyMappingProxy {
         )?))
     }
 
-    #[pymethod]
     pub fn __getitem__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self.get_inner(key.clone(), vm)?
             .ok_or_else(|| vm.new_key_error(key))
@@ -128,11 +121,12 @@ impl PyMappingProxy {
             MappingProxyInner::Class(class) => Ok(key
                 .as_interned_str(vm)
                 .is_some_and(|key| class.attributes.read().contains_key(key))),
-            MappingProxyInner::Mapping(mapping) => mapping.to_sequence().contains(key, vm),
+            MappingProxyInner::Mapping(mapping) => {
+                mapping.obj().sequence_unchecked().contains(key, vm)
+            }
         }
     }
 
-    #[pymethod]
     pub fn __contains__(&self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self._contains(&key, vm)
     }
@@ -167,7 +161,9 @@ impl PyMappingProxy {
     #[pymethod]
     pub fn copy(&self, vm: &VirtualMachine) -> PyResult {
         match &self.mapping {
-            MappingProxyInner::Mapping(d) => vm.call_method(d, identifier!(vm, copy).as_str(), ()),
+            MappingProxyInner::Mapping(d) => {
+                vm.call_method(d.obj(), identifier!(vm, copy).as_str(), ())
+            }
             MappingProxyInner::Class(c) => {
                 Ok(PyDict::from_attributes(c.attributes.read().clone(), vm)?.to_pyobject(vm))
             }
@@ -179,7 +175,6 @@ impl PyMappingProxy {
         PyGenericAlias::from_args(cls, args, vm)
     }
 
-    #[pymethod]
     fn __len__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         let obj = self.to_object(vm)?;
         obj.length(vm)
@@ -194,7 +189,6 @@ impl PyMappingProxy {
         )
     }
 
-    #[pymethod]
     fn __ior__(&self, _args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         Err(vm.new_type_error(format!(
             r#""'|=' is not supported by {}; use '|' instead""#,
@@ -202,8 +196,6 @@ impl PyMappingProxy {
         )))
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, args: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         vm._or(self.copy(vm)?.as_ref(), args.as_ref())
     }
@@ -241,6 +233,7 @@ impl AsMapping for PyMappingProxy {
 impl AsSequence for PyMappingProxy {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            length: atomic_func!(|seq, vm| PyMappingProxy::sequence_downcast(seq).__len__(vm)),
             contains: atomic_func!(
                 |seq, target, vm| PyMappingProxy::sequence_downcast(seq)._contains(target, vm)
             ),
diff --git a/vm/src/builtins/memory.rs b/crates/vm/src/builtins/memory.rs
similarity index 95%
rename from vm/src/builtins/memory.rs
rename to crates/vm/src/builtins/memory.rs
index 33fd19573b..6db260c80e 100644
--- a/vm/src/builtins/memory.rs
+++ b/crates/vm/src/builtins/memory.rs
@@ -23,14 +23,14 @@ use crate::{
     sliceable::SequenceIndexOp,
     types::{
         AsBuffer, AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        PyComparisonOp, Representable, SelfIter,
     },
 };
+use core::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range};
 use crossbeam_utils::atomic::AtomicCell;
 use itertools::Itertools;
 use rustpython_common::lock::PyMutex;
 use std::sync::LazyLock;
-use std::{cmp::Ordering, fmt::Debug, mem::ManuallyDrop, ops::Range};
 
 #[derive(FromArgs)]
 pub struct PyMemoryViewNewArgs {
@@ -61,9 +61,8 @@ pub struct PyMemoryView {
 impl Constructor for PyMemoryView {
     type Args = PyMemoryViewNewArgs;
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let zelf = Self::from_object(&args.object, vm)?;
-        zelf.into_ref_with_type(vm, cls).map(Into::into)
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        Self::from_object(&args.object, vm)
     }
 }
 
@@ -75,7 +74,7 @@ impl PyMemoryView {
     /// this should be the main entrance to create the memoryview
     /// to avoid the chained memoryview
     pub fn from_object(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-        if let Some(other) = obj.payload::<Self>() {
+        if let Some(other) = obj.downcast_ref::<Self>() {
             Ok(other.new_view())
         } else {
             let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?;
@@ -330,10 +329,10 @@ impl PyMemoryView {
             return Ok(false);
         }
 
-        if let Some(other) = other.payload::<Self>() {
-            if other.released.load() {
-                return Ok(false);
-            }
+        if let Some(other) = other.downcast_ref::<Self>()
+            && other.released.load()
+        {
+            return Ok(false);
         }
 
         let other = match PyBuffer::try_from_borrowed_object(vm, other) {
@@ -538,17 +537,20 @@ impl Py<PyMemoryView> {
     }
 }
 
-#[pyclass(with(
-    Py,
-    Hashable,
-    Comparable,
-    AsBuffer,
-    AsMapping,
-    AsSequence,
-    Constructor,
-    Iterable,
-    Representable
-))]
+#[pyclass(
+    with(
+        Py,
+        Hashable,
+        Comparable,
+        AsBuffer,
+        AsMapping,
+        AsSequence,
+        Constructor,
+        Iterable,
+        Representable
+    ),
+    flags(SEQUENCE)
+)]
 impl PyMemoryView {
     // TODO: Uncomment when Python adds __class_getitem__ to memoryview
     // #[pyclassmethod]
@@ -657,7 +659,6 @@ impl PyMemoryView {
         self.release();
     }
 
-    #[pymethod]
     fn __getitem__(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         zelf.try_not_released(vm)?;
         if zelf.desc.ndim() == 0 {
@@ -665,10 +666,10 @@ impl PyMemoryView {
             if needle.is(&vm.ctx.ellipsis) {
                 return Ok(zelf.into());
             }
-            if let Some(tuple) = needle.payload::<PyTuple>() {
-                if tuple.is_empty() {
-                    return zelf.unpack_single(0, vm);
-                }
+            if let Some(tuple) = needle.downcast_ref::<PyTuple>()
+                && tuple.is_empty()
+            {
+                return zelf.unpack_single(0, vm);
             }
             return Err(vm.new_type_error("invalid indexing of 0-dim memory"));
         }
@@ -680,7 +681,6 @@ impl PyMemoryView {
         }
     }
 
-    #[pymethod]
     fn __delitem__(&self, _needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         if self.desc.readonly {
             return Err(vm.new_type_error("cannot modify read-only memory"));
@@ -688,15 +688,15 @@ impl PyMemoryView {
         Err(vm.new_type_error("cannot delete memory"))
     }
 
-    #[pymethod]
     fn __len__(&self, vm: &VirtualMachine) -> PyResult<usize> {
         self.try_not_released(vm)?;
-        Ok(if self.desc.ndim() == 0 {
-            1
+        if self.desc.ndim() == 0 {
+            // 0-dimensional memoryview has no length
+            Err(vm.new_type_error("0-dim memory has no length".to_owned()))
         } else {
             // shape for dim[0]
-            self.desc.dim_desc[0].0
-        })
+            Ok(self.desc.dim_desc[0].0)
+        }
     }
 
     #[pymethod]
@@ -743,7 +743,7 @@ impl PyMemoryView {
     fn cast_to_1d(&self, format: PyStrRef, vm: &VirtualMachine) -> PyResult<Self> {
         let format_spec = Self::parse_format(format.as_str(), vm)?;
         let itemsize = format_spec.size();
-        if self.desc.len % itemsize != 0 {
+        if !self.desc.len.is_multiple_of(itemsize) {
             return Err(vm.new_type_error("memoryview: length is not a multiple of itemsize"));
         }
 
@@ -845,7 +845,6 @@ impl PyMemoryView {
 
 #[pyclass]
 impl Py<PyMemoryView> {
-    #[pymethod]
     fn __setitem__(
         &self,
         needle: PyObjectRef,
@@ -864,10 +863,10 @@ impl Py<PyMemoryView> {
             // TODO: merge branches when we got conditional if let
             if needle.is(&vm.ctx.ellipsis) {
                 return self.pack_single(0, value, vm);
-            } else if let Some(tuple) = needle.payload::<PyTuple>() {
-                if tuple.is_empty() {
-                    return self.pack_single(0, value, vm);
-                }
+            } else if let Some(tuple) = needle.downcast_ref::<PyTuple>()
+                && tuple.is_empty()
+            {
+                return self.pack_single(0, value, vm);
             }
             return Err(vm.new_type_error("invalid indexing of 0-dim memory"));
         }
@@ -907,15 +906,15 @@ enum SubscriptNeedle {
 impl TryFromObject for SubscriptNeedle {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         // TODO: number protocol
-        if let Some(i) = obj.payload::<PyInt>() {
+        if let Some(i) = obj.downcast_ref::<PyInt>() {
             Ok(Self::Index(i.try_to_primitive(vm)?))
-        } else if obj.payload_is::<PySlice>() {
+        } else if obj.downcastable::<PySlice>() {
             Ok(Self::Slice(unsafe { obj.downcast_unchecked::<PySlice>() }))
         } else if let Ok(i) = obj.try_index(vm) {
             Ok(Self::Index(i.try_to_primitive(vm)?))
         } else {
-            if let Some(tuple) = obj.payload::<PyTuple>() {
-                if tuple.iter().all(|x| x.payload_is::<PyInt>()) {
+            if let Some(tuple) = obj.downcast_ref::<PyTuple>() {
+                if tuple.iter().all(|x| x.downcastable::<PyInt>()) {
                     let v = tuple
                         .iter()
                         .map(|x| {
@@ -924,7 +923,7 @@ impl TryFromObject for SubscriptNeedle {
                         })
                         .try_collect()?;
                     return Ok(Self::MultiIndex(v));
-                } else if tuple.iter().all(|x| x.payload_is::<PySlice>()) {
+                } else if tuple.iter().all(|x| x.downcastable::<PySlice>()) {
                     return Err(vm.new_not_implemented_error(
                         "multi-dimensional slicing is not implemented",
                     ));
@@ -1129,7 +1128,7 @@ impl PyPayload for PyMemoryViewIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyMemoryViewIterator {
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
@@ -1138,7 +1137,6 @@ impl PyMemoryViewIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyMemoryViewIterator {}
 
 impl SelfIter for PyMemoryViewIterator {}
 impl IterNext for PyMemoryViewIterator {
diff --git a/crates/vm/src/builtins/mod.rs b/crates/vm/src/builtins/mod.rs
new file mode 100644
index 0000000000..c40f09bdef
--- /dev/null
+++ b/crates/vm/src/builtins/mod.rs
@@ -0,0 +1,101 @@
+//! This package contains the python basic/builtin types
+//! 7 common PyRef type aliases are exposed - [`PyBytesRef`], [`PyDictRef`], [`PyIntRef`], [`PyListRef`], [`PyStrRef`], [`PyTypeRef`], [`PyTupleRef`]
+//! Do not add more PyRef type aliases. They will be rare enough to use directly `PyRef<T>`.
+
+pub(crate) mod asyncgenerator;
+pub use asyncgenerator::PyAsyncGen;
+pub(crate) mod builtin_func;
+pub(crate) mod bytearray;
+pub use bytearray::PyByteArray;
+pub(crate) mod bytes;
+pub use bytes::{PyBytes, PyBytesRef};
+pub(crate) mod classmethod;
+pub use classmethod::PyClassMethod;
+pub(crate) mod code;
+pub use code::PyCode;
+pub(crate) mod complex;
+pub use complex::PyComplex;
+pub(crate) mod coroutine;
+pub use coroutine::PyCoroutine;
+pub(crate) mod dict;
+pub use dict::{PyDict, PyDictRef};
+pub(crate) mod enumerate;
+pub use enumerate::PyEnumerate;
+pub(crate) mod filter;
+pub use filter::PyFilter;
+pub(crate) mod float;
+pub use float::PyFloat;
+pub(crate) mod frame;
+pub(crate) mod function;
+pub use function::{PyBoundMethod, PyFunction};
+pub(crate) mod generator;
+pub use generator::PyGenerator;
+pub(crate) mod genericalias;
+pub use genericalias::PyGenericAlias;
+pub(crate) mod getset;
+pub use getset::PyGetSet;
+pub(crate) mod int;
+pub use int::{PyInt, PyIntRef};
+pub(crate) mod interpolation;
+pub use interpolation::PyInterpolation;
+pub(crate) mod iter;
+pub use iter::*;
+pub(crate) mod list;
+pub use list::{PyList, PyListRef};
+pub(crate) mod map;
+pub use map::PyMap;
+pub(crate) mod mappingproxy;
+pub use mappingproxy::PyMappingProxy;
+pub(crate) mod memory;
+pub use memory::PyMemoryView;
+pub(crate) mod module;
+pub use module::{PyModule, PyModuleDef};
+pub(crate) mod namespace;
+pub use namespace::PyNamespace;
+pub(crate) mod object;
+pub use object::PyBaseObject;
+pub(crate) mod property;
+pub use property::PyProperty;
+#[path = "bool.rs"]
+pub(crate) mod bool_;
+pub use bool_::PyBool;
+#[path = "str.rs"]
+pub(crate) mod pystr;
+pub use pystr::{PyStr, PyStrInterned, PyStrRef, PyUtf8Str, PyUtf8StrRef};
+#[path = "super.rs"]
+pub(crate) mod super_;
+pub use super_::PySuper;
+#[path = "type.rs"]
+pub(crate) mod type_;
+pub use type_::{PyType, PyTypeRef};
+pub(crate) mod range;
+pub use range::PyRange;
+pub(crate) mod set;
+pub use set::{PyFrozenSet, PySet};
+pub(crate) mod singletons;
+pub use singletons::{PyNone, PyNotImplemented};
+pub(crate) mod slice;
+pub use slice::{PyEllipsis, PySlice};
+pub(crate) mod staticmethod;
+pub use staticmethod::PyStaticMethod;
+pub(crate) mod template;
+pub use template::{PyTemplate, PyTemplateIter};
+pub(crate) mod traceback;
+pub use traceback::PyTraceback;
+pub(crate) mod tuple;
+pub use tuple::{PyTuple, PyTupleRef};
+pub(crate) mod weakproxy;
+pub use weakproxy::PyWeakProxy;
+pub(crate) mod weakref;
+pub use weakref::PyWeak;
+pub(crate) mod zip;
+pub use zip::PyZip;
+#[path = "union.rs"]
+pub(crate) mod union_;
+pub use union_::PyUnion;
+pub(crate) mod descriptor;
+
+pub use float::try_to_bigint as try_f64_to_bigint;
+pub use int::try_to_float as try_bigint_to_f64;
+
+pub use crate::exceptions::types::*;
diff --git a/crates/vm/src/builtins/module.rs b/crates/vm/src/builtins/module.rs
new file mode 100644
index 0000000000..faa6e4813f
--- /dev/null
+++ b/crates/vm/src/builtins/module.rs
@@ -0,0 +1,226 @@
+use super::{PyDict, PyDictRef, PyStr, PyStrRef, PyType, PyTypeRef};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyStrInterned, pystr::AsPyStr},
+    class::PyClassImpl,
+    convert::ToPyObject,
+    function::{FuncArgs, PyMethodDef},
+    types::{GetAttr, Initializer, Representable},
+};
+
+#[pyclass(module = false, name = "module")]
+#[derive(Debug)]
+pub struct PyModuleDef {
+    // pub index: usize,
+    pub name: &'static PyStrInterned,
+    pub doc: Option<&'static PyStrInterned>,
+    // pub size: isize,
+    pub methods: &'static [PyMethodDef],
+    pub slots: PyModuleSlots,
+    // traverse: traverse_proc
+    // clear: inquiry
+    // free: free_func
+}
+
+pub type ModuleCreate =
+    fn(&VirtualMachine, &PyObject, &'static PyModuleDef) -> PyResult<PyRef<PyModule>>;
+pub type ModuleExec = fn(&VirtualMachine, &Py<PyModule>) -> PyResult<()>;
+
+#[derive(Default)]
+pub struct PyModuleSlots {
+    pub create: Option<ModuleCreate>,
+    pub exec: Option<ModuleExec>,
+}
+
+impl core::fmt::Debug for PyModuleSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyModuleSlots")
+            .field("create", &self.create.is_some())
+            .field("exec", &self.exec.is_some())
+            .finish()
+    }
+}
+
+#[allow(clippy::new_without_default)] // avoid Default implementation
+#[pyclass(module = false, name = "module")]
+#[derive(Debug)]
+pub struct PyModule {
+    // PyObject *md_dict;
+    pub def: Option<&'static PyModuleDef>,
+    // state: Any
+    // weaklist
+    // for logging purposes after md_dict is cleared
+    pub name: Option<&'static PyStrInterned>,
+}
+
+impl PyPayload for PyModule {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.module_type
+    }
+}
+
+#[derive(FromArgs)]
+pub struct ModuleInitArgs {
+    name: PyStrRef,
+    #[pyarg(any, default)]
+    doc: Option<PyStrRef>,
+}
+
+impl PyModule {
+    #[allow(clippy::new_without_default)]
+    pub const fn new() -> Self {
+        Self {
+            def: None,
+            name: None,
+        }
+    }
+
+    pub const fn from_def(def: &'static PyModuleDef) -> Self {
+        Self {
+            def: Some(def),
+            name: Some(def.name),
+        }
+    }
+
+    pub fn __init_dict_from_def(vm: &VirtualMachine, module: &Py<Self>) {
+        let doc = module.def.unwrap().doc.map(|doc| doc.to_owned());
+        module.init_dict(module.name.unwrap(), doc, vm);
+    }
+}
+
+impl Py<PyModule> {
+    pub fn __init_methods(&self, vm: &VirtualMachine) -> PyResult<()> {
+        debug_assert!(self.def.is_some());
+        for method in self.def.unwrap().methods {
+            let func = method
+                .to_function()
+                .with_module(self.name.unwrap())
+                .into_ref(&vm.ctx);
+            vm.__module_set_attr(self, vm.ctx.intern_str(method.name), func)?;
+        }
+        Ok(())
+    }
+
+    fn getattr_inner(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        if let Some(attr) = self.as_object().generic_getattr_opt(name, None, vm)? {
+            return Ok(attr);
+        }
+        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}'")
+        } else {
+            "".to_owned()
+        };
+        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()
+    }
+
+    // TODO: to be replaced by the commented-out dict method above once dictoffset land
+    pub fn dict(&self) -> PyDictRef {
+        self.as_object().dict().unwrap()
+    }
+
+    // TODO: should be on PyModule, not Py<PyModule>
+    pub(crate) fn init_dict(
+        &self,
+        name: &'static PyStrInterned,
+        doc: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) {
+        let dict = self.dict();
+        dict.set_item(identifier!(vm, __name__), name.to_object(), vm)
+            .expect("Failed to set __name__ on module");
+        dict.set_item(identifier!(vm, __doc__), doc.to_pyobject(vm), vm)
+            .expect("Failed to set __doc__ on module");
+        dict.set_item("__package__", vm.ctx.none(), vm)
+            .expect("Failed to set __package__ on module");
+        dict.set_item("__loader__", vm.ctx.none(), vm)
+            .expect("Failed to set __loader__ on module");
+        dict.set_item("__spec__", vm.ctx.none(), vm)
+            .expect("Failed to set __spec__ on module");
+    }
+
+    pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
+        let attr_name = attr_name.as_pystr(&vm.ctx);
+        self.getattr_inner(attr_name, vm)
+    }
+
+    pub fn set_attr<'a>(
+        &self,
+        attr_name: impl AsPyStr<'a>,
+        attr_value: impl Into<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        self.as_object().set_attr(attr_name, attr_value, vm)
+    }
+}
+
+#[pyclass(with(GetAttr, Initializer, Representable), flags(BASETYPE, HAS_DICT))]
+impl PyModule {
+    #[pyslot]
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        Self::new().into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    #[pymethod]
+    fn __dir__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        // First check if __dict__ attribute exists and is actually a dictionary
+        let dict_attr = zelf.as_object().get_attr(identifier!(vm, __dict__), vm)?;
+        let dict = dict_attr
+            .downcast::<PyDict>()
+            .map_err(|_| vm.new_type_error("<module>.__dict__ is not a dictionary"))?;
+        let attrs = dict.into_iter().map(|(k, _v)| k).collect();
+        Ok(attrs)
+    }
+}
+
+impl Initializer for PyModule {
+    type Args = ModuleInitArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        debug_assert!(
+            zelf.class()
+                .slots
+                .flags
+                .has_feature(crate::types::PyTypeFlags::HAS_DICT)
+        );
+        zelf.init_dict(vm.ctx.intern_str(args.name.as_str()), args.doc, vm);
+        Ok(())
+    }
+}
+
+impl GetAttr for PyModule {
+    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        zelf.getattr_inner(name, vm)
+    }
+}
+
+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)?;
+        let repr = module_repr.call((zelf.to_owned(),), vm)?;
+        repr.downcast()
+            .map_err(|_| vm.new_type_error("_module_repr did not return a string"))
+    }
+
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use repr instead")
+    }
+}
+
+pub(crate) fn init(context: &Context) {
+    PyModule::extend_class(context, context.types.module_type);
+}
diff --git a/vm/src/builtins/namespace.rs b/crates/vm/src/builtins/namespace.rs
similarity index 89%
rename from vm/src/builtins/namespace.rs
rename to crates/vm/src/builtins/namespace.rs
index 2c6b8e79d8..03969c35e7 100644
--- a/vm/src/builtins/namespace.rs
+++ b/crates/vm/src/builtins/namespace.rs
@@ -26,16 +26,6 @@ impl PyPayload for PyNamespace {
 
 impl DefaultConstructor for PyNamespace {}
 
-impl PyNamespace {
-    pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {},
-            ctx.types.namespace_type.to_owned(),
-            Some(ctx.new_dict()),
-        )
-    }
-}
-
 #[pyclass(
     flags(BASETYPE, HAS_DICT),
     with(Constructor, Initializer, Comparable, Representable)
@@ -61,7 +51,7 @@ impl Initializer for PyNamespace {
         if !args.args.is_empty() {
             return Err(vm.new_type_error("no positional arguments expected"));
         }
-        for (name, value) in args.kwargs.into_iter() {
+        for (name, value) in args.kwargs {
             let name = vm.ctx.new_str(name);
             zelf.as_object().set_attr(&name, value, vm)?;
         }
@@ -99,8 +89,8 @@ impl Representable for PyNamespace {
             let dict = zelf.as_object().dict().unwrap();
             let mut parts = Vec::with_capacity(dict.__len__());
             for (key, value) in dict {
-                let k = &key.repr(vm)?;
-                let key_str = k.as_str();
+                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));
             }
diff --git a/crates/vm/src/builtins/object.rs b/crates/vm/src/builtins/object.rs
new file mode 100644
index 0000000000..982e11afd0
--- /dev/null
+++ b/crates/vm/src/builtins/object.rs
@@ -0,0 +1,744 @@
+use super::{PyDictRef, PyList, PyStr, PyStrRef, PyType, PyTypeRef};
+use crate::common::hash::PyHash;
+use crate::types::PyTypeFlags;
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    convert::ToPyResult,
+    function::{Either, FuncArgs, PyArithmeticValue, PyComparisonValue, PySetterValue},
+    types::{Constructor, Initializer, PyComparisonOp},
+};
+use itertools::Itertools;
+
+/// object()
+/// --
+///
+/// The base class of the class hierarchy.
+///
+/// When called, it accepts no arguments and returns a new featureless
+/// instance that has no instance attributes and cannot be given any.
+#[pyclass(module = false, name = "object")]
+#[derive(Debug)]
+pub struct PyBaseObject;
+
+impl PyPayload for PyBaseObject {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.object_type
+    }
+}
+
+impl Constructor for PyBaseObject {
+    type Args = FuncArgs;
+
+    // = object_new
+    fn slot_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        if !args.args.is_empty() || !args.kwargs.is_empty() {
+            // Check if type's __new__ != object.__new__
+            let tp_new = cls.get_attr(identifier!(vm, __new__));
+            let object_new = vm.ctx.types.object_type.get_attr(identifier!(vm, __new__));
+
+            if let (Some(tp_new), Some(object_new)) = (tp_new, object_new) {
+                if !tp_new.is(&object_new) {
+                    // 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(),
+                    ));
+                }
+
+                // If we reach here, tp_new == object_new
+                // Now check if type's __init__ == object.__init__
+                let tp_init = cls.get_attr(identifier!(vm, __init__));
+                let object_init = vm.ctx.types.object_type.get_attr(identifier!(vm, __init__));
+
+                if let (Some(tp_init), Some(object_init)) = (tp_init, object_init)
+                    && tp_init.is(&object_init)
+                {
+                    // Both __new__ and __init__ are object's versions,
+                    // so the type accepts no arguments
+                    return Err(vm.new_type_error(format!("{}() takes no arguments", cls.name())));
+                }
+                // If tp_init != object_init, then the type has custom __init__
+                // which might accept arguments, so we allow it
+            }
+        }
+
+        // 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 unimplemented_abstract_method_count = unimplemented_abstract_method_count?;
+            let name = cls.name().to_string();
+
+            match unimplemented_abstract_method_count {
+                0 => {}
+                1 => {
+                    return Err(vm.new_type_error(format!(
+                        "class {name} without an implementation for abstract method '{methods}'"
+                    )));
+                }
+                2.. => {
+                    return Err(vm.new_type_error(format!(
+                        "class {name} without an implementation for abstract methods '{methods}'"
+                    )));
+                }
+                // TODO: remove `allow` when redox build doesn't complain about it
+                #[allow(unreachable_patterns)]
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(crate::PyRef::new_ref(Self, cls, dict).into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyBaseObject {
+    type Args = FuncArgs;
+
+    // object_init: excess_args validation
+    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        if args.is_empty() {
+            return Ok(());
+        }
+
+        let typ = zelf.class();
+        let object_type = &vm.ctx.types.object_type;
+
+        let typ_init = typ.slots.init.load().map(|f| f as usize);
+        let object_init = object_type.slots.init.load().map(|f| f as usize);
+
+        // 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(),
+            ));
+        }
+
+        let typ_new = typ.slots.new.load().map(|f| f as usize);
+        let object_new = object_type.slots.new.load().map(|f| f as usize);
+
+        // if (type->tp_new == object_new) → second error
+        if typ_new == object_new {
+            return Err(vm.new_type_error(format!(
+                "{}.__init__() takes exactly one argument (the instance to initialize)",
+                typ.name()
+            )));
+        }
+
+        // Both conditions false → OK (e.g., tuple, dict with custom __new__)
+        Ok(())
+    }
+
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        unreachable!("slot_init is defined")
+    }
+}
+
+// TODO: implement _PyType_GetSlotNames properly
+fn type_slot_names(typ: &Py<PyType>, vm: &VirtualMachine) -> PyResult<Option<super::PyListRef>> {
+    // let attributes = typ.attributes.read();
+    // if let Some(slot_names) = attributes.get(identifier!(vm.ctx, __slotnames__)) {
+    //     return match_class!(match slot_names.clone() {
+    //         l @ super::PyList => Ok(Some(l)),
+    //         _n @ super::PyNone => Ok(None),
+    //         _ => Err(vm.new_type_error(format!(
+    //             "{:.200}.__slotnames__ should be a list or None, not {:.200}",
+    //             typ.name(),
+    //             slot_names.class().name()
+    //         ))),
+    //     });
+    // }
+
+    let copyreg = vm.import("copyreg", 0)?;
+    let copyreg_slotnames = copyreg.get_attr("_slotnames", vm)?;
+    let slot_names = copyreg_slotnames.call((typ.to_owned(),), vm)?;
+    let result = match_class!(match slot_names {
+        l @ super::PyList => Some(l),
+        _n @ super::PyNone => None,
+        _ => return Err(vm.new_type_error("copyreg._slotnames didn't return a list or None")),
+    });
+    Ok(result)
+}
+
+// object_getstate_default
+fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
+    // Check itemsize
+    if required && obj.class().slots.itemsize > 0 {
+        return Err(vm.new_type_error(format!("cannot pickle {:.200} objects", obj.class().name())));
+    }
+
+    let state = if obj.dict().is_none_or(|d| d.is_empty()) {
+        vm.ctx.none()
+    } else {
+        // let state = object_get_dict(obj.clone(), obj.ctx()).unwrap();
+        let Some(state) = obj.dict() else {
+            return Ok(vm.ctx.none());
+        };
+        state.into()
+    };
+
+    let slot_names =
+        type_slot_names(obj.class(), vm).map_err(|_| vm.new_type_error("cannot pickle object"))?;
+
+    if required {
+        // Start with PyBaseObject_Type's basicsize
+        let mut basicsize = vm.ctx.types.object_type.slots.basicsize;
+
+        // Add __dict__ size if type has dict
+        if obj.class().slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+            basicsize += core::mem::size_of::<PyObjectRef>();
+        }
+
+        // Add __weakref__ size if type has weakref support
+        let has_weakref = if let Some(ref ext) = obj.class().heaptype_ext {
+            match &ext.slots {
+                None => true, // Heap type without __slots__ has automatic weakref
+                Some(slots) => slots.iter().any(|s| s.as_str() == "__weakref__"),
+            }
+        } else {
+            let weakref_name = vm.ctx.intern_str("__weakref__");
+            obj.class().attributes.read().contains_key(weakref_name)
+        };
+        if has_weakref {
+            basicsize += core::mem::size_of::<PyObjectRef>();
+        }
+
+        // Add slots size
+        if let Some(ref slot_names) = slot_names {
+            basicsize += core::mem::size_of::<PyObjectRef>() * slot_names.__len__();
+        }
+
+        // Fail if actual type's basicsize > expected basicsize
+        if obj.class().slots.basicsize > basicsize {
+            return Err(vm.new_type_error(format!("cannot pickle '{}' object", obj.class().name())));
+        }
+    }
+
+    if let Some(slot_names) = slot_names {
+        let slot_names_len = slot_names.__len__();
+        if slot_names_len > 0 {
+            let slots = vm.ctx.new_dict();
+            for i in 0..slot_names_len {
+                let borrowed_names = slot_names.borrow_vec();
+                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();
+            }
+
+            if !slots.is_empty() {
+                return (state, slots).to_pyresult(vm);
+            }
+        }
+    }
+
+    Ok(state)
+}
+
+// object_getstate
+// fn object_getstate(
+//     obj: &PyObject,
+//     required: bool,
+//     vm: &VirtualMachine,
+// ) -> PyResult {
+//     let getstate = obj.get_attr(identifier!(vm, __getstate__), vm)?;
+//     if vm.is_none(&getstate) {
+//         return Ok(None);
+//     }
+
+//     let getstate = match getstate.downcast_exact::<PyNativeFunction>(vm) {
+//         Ok(getstate)
+//             if getstate
+//                 .get_self()
+//                 .map_or(false, |self_obj| self_obj.is(obj))
+//                 && std::ptr::addr_eq(
+//                     getstate.as_func() as *const _,
+//                     &PyBaseObject::__getstate__ as &dyn crate::function::PyNativeFn as *const _,
+//                 ) =>
+//         {
+//             return object_getstate_default(obj, required, vm);
+//         }
+//         Ok(getstate) => getstate.into_pyref().into(),
+//         Err(getstate) => getstate,
+//     };
+//     getstate.call((), vm)
+// }
+
+#[pyclass(with(Constructor, Initializer), flags(BASETYPE))]
+impl PyBaseObject {
+    #[pymethod(raw)]
+    fn __getstate__(vm: &VirtualMachine, args: FuncArgs) -> PyResult {
+        let (zelf,): (PyObjectRef,) = args.bind(vm)?;
+        object_getstate_default(&zelf, false, vm)
+    }
+
+    #[pyslot]
+    fn slot_richcompare(
+        zelf: &PyObject,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
+        Self::cmp(zelf, other, op, vm).map(Either::B)
+    }
+
+    #[inline(always)]
+    fn cmp(
+        zelf: &PyObject,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        let res = match op {
+            PyComparisonOp::Eq => {
+                if zelf.is(other) {
+                    PyComparisonValue::Implemented(true)
+                } else {
+                    PyComparisonValue::NotImplemented
+                }
+            }
+            PyComparisonOp::Ne => {
+                let cmp = zelf.class().slots.richcompare.load().unwrap();
+                let value = match cmp(zelf, other, PyComparisonOp::Eq, vm)? {
+                    Either::A(obj) => PyArithmeticValue::from_object(vm, obj)
+                        .map(|obj| obj.try_to_bool(vm))
+                        .transpose()?,
+                    Either::B(value) => value,
+                };
+                value.map(|v| !v)
+            }
+            _ => PyComparisonValue::NotImplemented,
+        };
+        Ok(res)
+    }
+
+    /// Implement setattr(self, name, value).
+    #[pymethod]
+    fn __setattr__(
+        obj: PyObjectRef,
+        name: PyStrRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        obj.generic_setattr(&name, PySetterValue::Assign(value), vm)
+    }
+
+    /// Implement delattr(self, name).
+    #[pymethod]
+    fn __delattr__(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        obj.generic_setattr(&name, PySetterValue::Delete, vm)
+    }
+
+    #[pyslot]
+    fn slot_setattro(
+        obj: &PyObject,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        obj.generic_setattr(attr_name, value, vm)
+    }
+
+    /// Return str(self).
+    #[pyslot]
+    fn slot_str(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        // FIXME: try tp_repr first and fallback to object.__repr__
+        zelf.repr(vm)
+    }
+
+    #[pyslot]
+    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let class = zelf.class();
+        match (
+            class
+                .__qualname__(vm)
+                .downcast_ref::<PyStr>()
+                .map(|n| n.as_str()),
+            class
+                .__module__(vm)
+                .downcast_ref::<PyStr>()
+                .map(|m| m.as_str()),
+        ) {
+            (None, _) => Err(vm.new_type_error("Unknown qualified name")),
+            (Some(qualname), Some(module)) if module != "builtins" => Ok(PyStr::from(format!(
+                "<{}.{} object at {:#x}>",
+                module,
+                qualname,
+                zelf.get_id()
+            ))
+            .into_ref(&vm.ctx)),
+            _ => Ok(PyStr::from(format!(
+                "<{} object at {:#x}>",
+                class.slot_name(),
+                zelf.get_id()
+            ))
+            .into_ref(&vm.ctx)),
+        }
+    }
+
+    #[pyclassmethod]
+    fn __subclasshook__(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.not_implemented()
+    }
+
+    #[pyclassmethod]
+    fn __init_subclass__(_cls: PyTypeRef) {}
+
+    #[pymethod]
+    pub fn __dir__(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyList> {
+        obj.dir(vm)
+    }
+
+    #[pymethod]
+    fn __format__(
+        obj: PyObjectRef,
+        format_spec: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyStrRef> {
+        if !format_spec.is_empty() {
+            return Err(vm.new_type_error(format!(
+                "unsupported format string passed to {}.__format__",
+                obj.class().name()
+            )));
+        }
+        obj.str(vm)
+    }
+
+    #[pygetset]
+    fn __class__(obj: PyObjectRef) -> PyTypeRef {
+        obj.class().to_owned()
+    }
+
+    #[pygetset(setter)]
+    fn set___class__(
+        instance: PyObjectRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match value.downcast::<PyType>() {
+            Ok(cls) => {
+                let current_cls = instance.class();
+                let both_module = current_cls.fast_issubclass(vm.ctx.types.module_type)
+                    && cls.fast_issubclass(vm.ctx.types.module_type);
+                let both_mutable = !current_cls
+                    .slots
+                    .flags
+                    .has_feature(PyTypeFlags::IMMUTABLETYPE)
+                    && !cls.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE);
+                // FIXME(#1979) cls instances might have a payload
+                if both_mutable || both_module {
+                    let has_dict =
+                        |typ: &Py<PyType>| typ.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+                    // Compare slots tuples
+                    let slots_equal = match (
+                        current_cls
+                            .heaptype_ext
+                            .as_ref()
+                            .and_then(|e| e.slots.as_ref()),
+                        cls.heaptype_ext.as_ref().and_then(|e| e.slots.as_ref()),
+                    ) {
+                        (Some(a), Some(b)) => {
+                            a.len() == b.len()
+                                && a.iter()
+                                    .zip(b.iter())
+                                    .all(|(x, y)| x.as_str() == y.as_str())
+                        }
+                        (None, None) => true,
+                        _ => false,
+                    };
+                    if current_cls.slots.basicsize != cls.slots.basicsize
+                        || !slots_equal
+                        || has_dict(current_cls) != has_dict(&cls)
+                    {
+                        return Err(vm.new_type_error(format!(
+                            "__class__ assignment: '{}' object layout differs from '{}'",
+                            cls.name(),
+                            current_cls.name()
+                        )));
+                    }
+                    instance.set_class(cls, vm);
+                    Ok(())
+                } else {
+                    Err(vm.new_type_error(
+                        "__class__ assignment only supported for mutable types or ModuleType subclasses",
+                    ))
+                }
+            }
+            Err(value) => {
+                let value_class = value.class();
+                let type_repr = &value_class.name();
+                Err(vm.new_type_error(format!(
+                    "__class__ must be set to a class, not '{type_repr}' object"
+                )))
+            }
+        }
+    }
+
+    /// Return getattr(self, name).
+    #[pyslot]
+    pub(crate) fn getattro(obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        vm_trace!("object.__getattribute__({:?}, {:?})", obj, name);
+        obj.as_object().generic_getattr(name, vm)
+    }
+
+    #[pymethod]
+    fn __getattribute__(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        Self::getattro(&obj, &name, vm)
+    }
+
+    #[pymethod]
+    fn __reduce__(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        common_reduce(obj, 0, vm)
+    }
+
+    #[pymethod]
+    fn __reduce_ex__(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+        let __reduce__ = identifier!(vm, __reduce__);
+        if let Some(reduce) = vm.get_attribute_opt(obj.clone(), __reduce__)? {
+            let object_reduce = vm.ctx.types.object_type.get_attr(__reduce__).unwrap();
+            let typ_obj: PyObjectRef = obj.class().to_owned().into();
+            let class_reduce = typ_obj.get_attr(__reduce__, vm)?;
+            if !class_reduce.is(&object_reduce) {
+                return reduce.call((), vm);
+            }
+        }
+        common_reduce(obj, proto, vm)
+    }
+
+    #[pyslot]
+    fn slot_hash(zelf: &PyObject, _vm: &VirtualMachine) -> PyResult<PyHash> {
+        Ok(zelf.get_id() as _)
+    }
+
+    #[pymethod]
+    fn __sizeof__(zelf: PyObjectRef) -> usize {
+        zelf.class().slots.basicsize
+    }
+}
+
+pub fn object_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyDictRef> {
+    obj.dict()
+        .ok_or_else(|| vm.new_attribute_error("This object has no __dict__"))
+}
+pub fn object_set_dict(obj: PyObjectRef, dict: PyDictRef, vm: &VirtualMachine) -> PyResult<()> {
+    obj.set_dict(dict)
+        .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
+    // for trait impl that overrides #[pyslot] method
+    ctx.types
+        .object_type
+        .slots
+        .init
+        .store(Some(<PyBaseObject as Initializer>::slot_init));
+    PyBaseObject::extend_class(ctx, ctx.types.object_type);
+}
+
+/// Get arguments for __new__ from __getnewargs_ex__ or __getnewargs__
+/// Returns (args, kwargs) tuple where either can be None
+fn get_new_arguments(
+    obj: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<(Option<super::PyTupleRef>, Option<super::PyDictRef>)> {
+    // First try __getnewargs_ex__
+    if let Some(getnewargs_ex) = vm.get_special_method(obj, identifier!(vm, __getnewargs_ex__))? {
+        let newargs = getnewargs_ex.invoke((), vm)?;
+
+        let newargs_tuple: PyRef<super::PyTuple> = newargs.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "__getnewargs_ex__ should return a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        if newargs_tuple.len() != 2 {
+            return Err(vm.new_value_error(format!(
+                "__getnewargs_ex__ should return a tuple of length 2, not {}",
+                newargs_tuple.len()
+            )));
+        }
+
+        let args = newargs_tuple.as_slice()[0].clone();
+        let kwargs = newargs_tuple.as_slice()[1].clone();
+
+        let args_tuple: PyRef<super::PyTuple> = args.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "first item of the tuple returned by __getnewargs_ex__ must be a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        let kwargs_dict: PyRef<super::PyDict> = kwargs.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "second item of the tuple returned by __getnewargs_ex__ must be a dict, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        return Ok((Some(args_tuple), Some(kwargs_dict)));
+    }
+
+    // Fall back to __getnewargs__
+    if let Some(getnewargs) = vm.get_special_method(obj, identifier!(vm, __getnewargs__))? {
+        let args = getnewargs.invoke((), vm)?;
+
+        let args_tuple: PyRef<super::PyTuple> = args.downcast().map_err(|obj| {
+            vm.new_type_error(format!(
+                "__getnewargs__ should return a tuple, not '{}'",
+                obj.class().name()
+            ))
+        })?;
+
+        return Ok((Some(args_tuple), None));
+    }
+
+    // No __getnewargs_ex__ or __getnewargs__
+    Ok((None, None))
+}
+
+/// Check if __getstate__ is overridden by comparing with object.__getstate__
+fn is_getstate_overridden(obj: &PyObject, vm: &VirtualMachine) -> bool {
+    let obj_cls = obj.class();
+    let object_type = vm.ctx.types.object_type;
+
+    // If the class is object itself, not overridden
+    if obj_cls.is(object_type) {
+        return false;
+    }
+
+    // Check if __getstate__ in the MRO comes from object or elsewhere
+    // If the type has its own __getstate__, it's overridden
+    if let Some(getstate) = obj_cls.get_attr(identifier!(vm, __getstate__))
+        && let Some(obj_getstate) = object_type.get_attr(identifier!(vm, __getstate__))
+    {
+        return !getstate.is(&obj_getstate);
+    }
+    false
+}
+
+/// object_getstate - calls __getstate__ method or default implementation
+fn object_getstate(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
+    // If __getstate__ is not overridden, use the default implementation with required flag
+    if !is_getstate_overridden(obj, vm) {
+        return object_getstate_default(obj, required, vm);
+    }
+
+    // __getstate__ is overridden, call it without required
+    let getstate = obj.get_attr(identifier!(vm, __getstate__), vm)?;
+    getstate.call((), vm)
+}
+
+/// Get list items iterator if obj is a list (or subclass), None iterator otherwise
+fn get_items_iter(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, PyObjectRef)> {
+    let listitems: PyObjectRef = if obj.fast_isinstance(vm.ctx.types.list_type) {
+        obj.get_iter(vm)?.into()
+    } else {
+        vm.ctx.none()
+    };
+
+    let dictitems: PyObjectRef = if obj.fast_isinstance(vm.ctx.types.dict_type) {
+        let items = vm.call_method(obj, "items", ())?;
+        items.get_iter(vm)?.into()
+    } else {
+        vm.ctx.none()
+    };
+
+    Ok((listitems, dictitems))
+}
+
+/// reduce_newobj - creates reduce tuple for protocol >= 2
+fn reduce_newobj(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // Check if type has tp_new
+    let cls = obj.class();
+    if cls.slots.new.load().is_none() {
+        return Err(vm.new_type_error(format!("cannot pickle '{}' object", cls.name())));
+    }
+
+    let (args, kwargs) = get_new_arguments(&obj, vm)?;
+
+    let copyreg = vm.import("copyreg", 0)?;
+
+    let has_args = args.is_some();
+
+    let (newobj, newargs): (PyObjectRef, PyObjectRef) = if kwargs.is_none()
+        || kwargs.as_ref().is_some_and(|k| k.is_empty())
+    {
+        // Use copyreg.__newobj__
+        let newobj = copyreg.get_attr("__newobj__", vm)?;
+
+        let args_vec: Vec<PyObjectRef> = args.map(|a| a.as_slice().to_vec()).unwrap_or_default();
+
+        // Create (cls, *args) tuple
+        let mut newargs_vec: Vec<PyObjectRef> = vec![cls.to_owned().into()];
+        newargs_vec.extend(args_vec);
+        let newargs = vm.ctx.new_tuple(newargs_vec);
+
+        (newobj, newargs.into())
+    } else {
+        // Use copyreg.__newobj_ex__
+        let newobj = copyreg.get_attr("__newobj_ex__", vm)?;
+        let args_tuple: PyObjectRef = args
+            .map(|a| a.into())
+            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into());
+        let kwargs_dict: PyObjectRef = kwargs
+            .map(|k| k.into())
+            .unwrap_or_else(|| vm.ctx.new_dict().into());
+
+        let newargs = vm
+            .ctx
+            .new_tuple(vec![cls.to_owned().into(), args_tuple, kwargs_dict]);
+        (newobj, newargs.into())
+    };
+
+    // Determine if state is required
+    // required = !(has_args || is_list || is_dict)
+    let is_list = obj.fast_isinstance(vm.ctx.types.list_type);
+    let is_dict = obj.fast_isinstance(vm.ctx.types.dict_type);
+    let required = !(has_args || is_list || is_dict);
+
+    let state = object_getstate(&obj, required, vm)?;
+
+    let (listitems, dictitems) = get_items_iter(&obj, vm)?;
+
+    let result = vm
+        .ctx
+        .new_tuple(vec![newobj, newargs, state, listitems, dictitems]);
+    Ok(result.into())
+}
+
+fn common_reduce(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
+    if proto >= 2 {
+        reduce_newobj(obj, vm)
+    } else {
+        let copyreg = vm.import("copyreg", 0)?;
+        let reduce_ex = copyreg.get_attr("_reduce_ex", vm)?;
+        reduce_ex.call((obj, proto), vm)
+    }
+}
diff --git a/vm/src/builtins/property.rs b/crates/vm/src/builtins/property.rs
similarity index 77%
rename from vm/src/builtins/property.rs
rename to crates/vm/src/builtins/property.rs
index 925ec35f49..8cc9ba92e9 100644
--- a/vm/src/builtins/property.rs
+++ b/crates/vm/src/builtins/property.rs
@@ -1,7 +1,7 @@
 /*! Python `property` descriptor class.
 
 */
-use super::{PyStrRef, PyType, PyTypeRef};
+use super::{PyStrRef, PyType};
 use crate::common::lock::PyRwLock;
 use crate::function::{IntoFuncArgs, PosArgs};
 use crate::{
@@ -10,7 +10,7 @@ use crate::{
     function::{FuncArgs, PySetterValue},
     types::{Constructor, GetDescriptor, Initializer},
 };
-use std::sync::atomic::{AtomicBool, Ordering};
+use core::sync::atomic::{AtomicBool, Ordering};
 
 #[pyclass(module = false, name = "property", traverse)]
 #[derive(Debug)]
@@ -21,7 +21,7 @@ pub struct PyProperty {
     doc: PyRwLock<Option<PyObjectRef>>,
     name: PyRwLock<Option<PyObjectRef>>,
     #[pytraverse(skip)]
-    getter_doc: std::sync::atomic::AtomicBool,
+    getter_doc: core::sync::atomic::AtomicBool,
 }
 
 impl PyPayload for PyProperty {
@@ -55,7 +55,8 @@ impl GetDescriptor for PyProperty {
         let (zelf, obj) = Self::_unwrap(&zelf_obj, obj, vm)?;
         if vm.is_none(&obj) {
             Ok(zelf_obj)
-        } else if let Some(getter) = zelf.getter.read().as_ref() {
+        } else if let Some(getter) = zelf.getter.read().clone() {
+            // Clone and release lock before calling Python code to prevent deadlock
             getter.call((obj,), vm)
         } else {
             let error_msg = zelf.format_property_error(&obj, "getter", vm)?;
@@ -67,20 +68,30 @@ impl GetDescriptor for PyProperty {
 #[pyclass(with(Constructor, Initializer, GetDescriptor), flags(BASETYPE))]
 impl PyProperty {
     // Helper method to get property name
-    fn get_property_name(&self, vm: &VirtualMachine) -> Option<PyObjectRef> {
+    // Returns the name if available, None if not found, or propagates errors
+    fn get_property_name(&self, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
         // First check if name was set via __set_name__
-        if let Some(name) = self.name.read().as_ref() {
-            return Some(name.clone());
+        if let Some(name) = self.name.read().clone() {
+            return Ok(Some(name));
         }
 
-        // Otherwise try to get __name__ from getter
-        if let Some(getter) = self.getter.read().as_ref() {
-            if let Ok(name) = getter.get_attr("__name__", vm) {
-                return Some(name);
+        // Clone and release lock before calling Python code to prevent deadlock
+        let Some(getter) = self.getter.read().clone() else {
+            return Ok(None);
+        };
+
+        match getter.get_attr("__name__", vm) {
+            Ok(name) => Ok(Some(name)),
+            Err(e) => {
+                // If it's an AttributeError from the getter, return None
+                // Otherwise, propagate the original exception (e.g., RuntimeError)
+                if e.class().is(vm.ctx.exceptions.attribute_error) {
+                    Ok(None)
+                } else {
+                    Err(e)
+                }
             }
         }
-
-        None
     }
 
     // Descriptor methods
@@ -95,7 +106,8 @@ impl PyProperty {
         let zelf = zelf.try_to_ref::<Self>(vm)?;
         match value {
             PySetterValue::Assign(value) => {
-                if let Some(setter) = zelf.setter.read().as_ref() {
+                // Clone and release lock before calling Python code to prevent deadlock
+                if let Some(setter) = zelf.setter.read().clone() {
                     setter.call((obj, value), vm).map(drop)
                 } else {
                     let error_msg = zelf.format_property_error(&obj, "setter", vm)?;
@@ -103,7 +115,8 @@ impl PyProperty {
                 }
             }
             PySetterValue::Delete => {
-                if let Some(deleter) = zelf.deleter.read().as_ref() {
+                // Clone and release lock before calling Python code to prevent deadlock
+                if let Some(deleter) = zelf.deleter.read().clone() {
                     deleter.call((obj,), vm).map(drop)
                 } else {
                     let error_msg = zelf.format_property_error(&obj, "deleter", vm)?;
@@ -112,19 +125,6 @@ impl PyProperty {
             }
         }
     }
-    #[pymethod]
-    fn __set__(
-        zelf: PyObjectRef,
-        obj: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Assign(value), vm)
-    }
-    #[pymethod]
-    fn __delete__(zelf: PyObjectRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::descr_set(&zelf, obj, PySetterValue::Delete, vm)
-    }
 
     // Access functions
 
@@ -143,6 +143,21 @@ impl PyProperty {
         self.deleter.read().clone()
     }
 
+    #[pygetset(name = "__name__")]
+    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())
+            ),
+        }
+    }
+
+    #[pygetset(name = "__name__", setter)]
+    fn name_setter(&self, value: PyObjectRef) {
+        *self.name.write() = Some(value);
+    }
+
     fn doc_getter(&self) -> Option<PyObjectRef> {
         self.doc.read().clone()
     }
@@ -199,7 +214,7 @@ impl PyProperty {
         };
 
         // Create new property using py_new and init
-        let new_prop = Self::py_new(zelf.class().to_owned(), FuncArgs::default(), vm)?;
+        let new_prop = Self::slot_new(zelf.class().to_owned(), FuncArgs::default(), vm)?;
         let new_prop_ref = new_prop.downcast::<Self>().unwrap();
         Self::init(new_prop_ref.clone(), args, vm)?;
 
@@ -241,32 +256,33 @@ impl PyProperty {
     #[pygetset]
     fn __isabstractmethod__(&self, vm: &VirtualMachine) -> PyResult {
         // Helper to check if a method is abstract
-        let is_abstract = |method: &PyObjectRef| -> PyResult<bool> {
+        let is_abstract = |method: &PyObject| -> PyResult<bool> {
             match method.get_attr("__isabstractmethod__", vm) {
                 Ok(isabstract) => isabstract.try_to_bool(vm),
                 Err(_) => Ok(false),
             }
         };
 
+        // Clone and release lock before calling Python code to prevent deadlock
         // Check getter
-        if let Some(getter) = self.getter.read().as_ref() {
-            if is_abstract(getter)? {
-                return Ok(vm.ctx.new_bool(true).into());
-            }
+        if let Some(getter) = self.getter.read().clone()
+            && is_abstract(&getter)?
+        {
+            return Ok(vm.ctx.new_bool(true).into());
         }
 
         // Check setter
-        if let Some(setter) = self.setter.read().as_ref() {
-            if is_abstract(setter)? {
-                return Ok(vm.ctx.new_bool(true).into());
-            }
+        if let Some(setter) = self.setter.read().clone()
+            && is_abstract(&setter)?
+        {
+            return Ok(vm.ctx.new_bool(true).into());
         }
 
         // Check deleter
-        if let Some(deleter) = self.deleter.read().as_ref() {
-            if is_abstract(deleter)? {
-                return Ok(vm.ctx.new_bool(true).into());
-            }
+        if let Some(deleter) = self.deleter.read().clone()
+            && is_abstract(&deleter)?
+        {
+            return Ok(vm.ctx.new_bool(true).into());
         }
 
         Ok(vm.ctx.new_bool(false).into())
@@ -274,7 +290,8 @@ impl PyProperty {
 
     #[pygetset(setter)]
     fn set___isabstractmethod__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(getter) = self.getter.read().to_owned() {
+        // Clone and release lock before calling Python code to prevent deadlock
+        if let Some(getter) = self.getter.read().clone() {
             getter.set_attr("__isabstractmethod__", value, vm)?;
         }
         Ok(())
@@ -284,11 +301,11 @@ impl PyProperty {
     #[cold]
     fn format_property_error(
         &self,
-        obj: &PyObjectRef,
+        obj: &PyObject,
         error_type: &str,
         vm: &VirtualMachine,
     ) -> PyResult<String> {
-        let prop_name = self.get_property_name(vm);
+        let prop_name = self.get_property_name(vm)?;
         let obj_type = obj.class();
         let qualname = obj_type.__qualname__(vm);
 
@@ -311,17 +328,15 @@ impl PyProperty {
 impl Constructor for PyProperty {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Self {
+    fn py_new(_cls: &Py<PyType>, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self {
             getter: PyRwLock::new(None),
             setter: PyRwLock::new(None),
             deleter: PyRwLock::new(None),
             doc: PyRwLock::new(None),
             name: PyRwLock::new(None),
             getter_doc: AtomicBool::new(false),
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+        })
     }
 }
 
@@ -333,7 +348,7 @@ impl Initializer for PyProperty {
         let mut getter_doc = false;
 
         // Helper to get doc from getter
-        let get_getter_doc = |fget: &PyObjectRef| -> Option<PyObjectRef> {
+        let get_getter_doc = |fget: &PyObject| -> Option<PyObjectRef> {
             fget.get_attr("__doc__", vm)
                 .ok()
                 .filter(|doc| !vm.is_none(doc))
diff --git a/vm/src/builtins/range.rs b/crates/vm/src/builtins/range.rs
similarity index 95%
rename from vm/src/builtins/range.rs
rename to crates/vm/src/builtins/range.rs
index 2d6ea92b19..49f50ffbaa 100644
--- a/vm/src/builtins/range.rs
+++ b/crates/vm/src/builtins/range.rs
@@ -8,17 +8,17 @@ use crate::{
     class::PyClassImpl,
     common::hash::PyHash,
     function::{ArgIndex, FuncArgs, OptionalArg, PyComparisonValue},
-    protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     types::{
-        AsMapping, AsSequence, Comparable, Hashable, IterNext, Iterable, PyComparisonOp,
-        Representable, SelfIter, Unconstructible,
+        AsMapping, AsNumber, AsSequence, Comparable, Hashable, IterNext, Iterable, PyComparisonOp,
+        Representable, SelfIter,
     },
 };
+use core::cmp::max;
 use crossbeam_utils::atomic::AtomicCell;
 use malachite_bigint::{BigInt, Sign};
 use num_integer::Integer;
 use num_traits::{One, Signed, ToPrimitive, Zero};
-use std::cmp::max;
 use std::sync::LazyLock;
 
 // Search flag passed to iter_search
@@ -28,8 +28,6 @@ enum SearchType {
     Index,
 }
 
-// Note: might be a good idea to merge with _membership_iter_search or generalize (_sequence_iter_check?)
-// and place in vm.rs for all sequences to be able to use it.
 #[inline]
 fn iter_search(
     obj: &PyObject,
@@ -165,7 +163,7 @@ impl PyRange {
 }
 
 // pub fn get_value(obj: &PyObject) -> PyRange {
-//     obj.payload::<PyRange>().unwrap().clone()
+//     obj.downcast_ref::<PyRange>().unwrap().clone()
 // }
 
 pub fn init(context: &Context) {
@@ -174,15 +172,19 @@ pub fn init(context: &Context) {
     PyRangeIterator::extend_class(context, context.types.range_iterator_type);
 }
 
-#[pyclass(with(
-    Py,
-    AsMapping,
-    AsSequence,
-    Hashable,
-    Comparable,
-    Iterable,
-    Representable
-))]
+#[pyclass(
+    with(
+        Py,
+        AsMapping,
+        AsNumber,
+        AsSequence,
+        Hashable,
+        Comparable,
+        Iterable,
+        Representable
+    ),
+    flags(SEQUENCE)
+)]
 impl PyRange {
     fn new(cls: PyTypeRef, stop: ArgIndex, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self {
@@ -263,16 +265,10 @@ impl PyRange {
         )
     }
 
-    #[pymethod]
     fn __len__(&self) -> BigInt {
         self.compute_length()
     }
 
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !self.is_empty()
-    }
-
     #[pymethod]
     fn __reduce__(&self, vm: &VirtualMachine) -> (PyTypeRef, PyTupleRef) {
         let range_parameters: Vec<PyObjectRef> = [&self.start, &self.stop, &self.step]
@@ -283,7 +279,6 @@ impl PyRange {
         (vm.ctx.types.range_type.to_owned(), range_parameters_tuple)
     }
 
-    #[pymethod]
     fn __getitem__(&self, subscript: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         match RangeIndex::try_from_object(vm, subscript)? {
             RangeIndex::Slice(slice) => {
@@ -345,7 +340,6 @@ impl Py<PyRange> {
         }
     }
 
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> bool {
         self.contains_inner(&needle, vm)
     }
@@ -425,6 +419,19 @@ impl AsSequence for PyRange {
     }
 }
 
+impl AsNumber for PyRange {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyRange>().unwrap();
+                Ok(!zelf.is_empty())
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl Hashable for PyRange {
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
         let length = zelf.compute_length();
@@ -547,7 +554,7 @@ impl PyPayload for PyLongRangeIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyLongRangeIterator {
     #[pymethod]
     fn __length_hint__(&self) -> BigInt {
@@ -576,7 +583,6 @@ impl PyLongRangeIterator {
         )
     }
 }
-impl Unconstructible for PyLongRangeIterator {}
 
 impl SelfIter for PyLongRangeIterator {}
 impl IterNext for PyLongRangeIterator {
@@ -613,7 +619,7 @@ impl PyPayload for PyRangeIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyRangeIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -639,7 +645,6 @@ impl PyRangeIterator {
         )
     }
 }
-impl Unconstructible for PyRangeIterator {}
 
 impl SelfIter for PyRangeIterator {}
 impl IterNext for PyRangeIterator {
@@ -677,7 +682,7 @@ fn range_iter_reduce(
 
 // Silently clips state (i.e index) in range [0, usize::MAX].
 fn range_state(length: &BigInt, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-    if let Some(i) = state.payload::<PyInt>() {
+    if let Some(i) = state.downcast_ref::<PyInt>() {
         let mut index = i.as_bigint();
         let max_usize = BigInt::from(usize::MAX);
         if index > length {
diff --git a/vm/src/builtins/set.rs b/crates/vm/src/builtins/set.rs
similarity index 82%
rename from vm/src/builtins/set.rs
rename to crates/vm/src/builtins/set.rs
index c4fd116f6a..c347380973 100644
--- a/vm/src/builtins/set.rs
+++ b/crates/vm/src/builtins/set.rs
@@ -12,23 +12,25 @@ use crate::{
     common::{ascii, hash::PyHash, lock::PyMutex, rc::PyRc},
     convert::ToPyResult,
     dict_inner::{self, DictSize},
-    function::{ArgIterable, OptionalArg, PosArgs, PyArithmeticValue, PyComparisonValue},
+    function::{ArgIterable, FuncArgs, OptionalArg, PosArgs, PyArithmeticValue, PyComparisonValue},
     protocol::{PyIterReturn, PyNumberMethods, PySequenceMethods},
     recursion::ReprGuard,
     types::AsNumber,
     types::{
         AsSequence, Comparable, Constructor, DefaultConstructor, Hashable, Initializer, IterNext,
-        Iterable, PyComparisonOp, Representable, SelfIter, Unconstructible,
+        Iterable, PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
 };
+use alloc::fmt;
+use core::borrow::Borrow;
+use core::ops::Deref;
 use rustpython_common::{
     atomic::{Ordering, PyAtomic, Radium},
     hash,
 };
 use std::sync::LazyLock;
-use std::{fmt, ops::Deref};
 
 pub type SetContentType = dict_inner::Dict<()>;
 
@@ -39,10 +41,9 @@ pub struct PySet {
 }
 
 impl PySet {
+    #[deprecated(note = "Use `PySet::default().into_ref(ctx)` instead")]
     pub fn new_ref(ctx: &Context) -> PyRef<Self> {
-        // Initialized empty, as calling __hash__ is required for adding each object to the set
-        // which requires a VM context - this is done in the set code itself.
-        PyRef::new_ref(Self::default(), ctx.types.set_type.to_owned(), None)
+        Self::default().into_ref(ctx)
     }
 
     pub fn elements(&self) -> Vec<PyObjectRef> {
@@ -51,7 +52,7 @@ impl PySet {
 
     fn fold_op(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         op: fn(&PySetInner, ArgIterable, &VirtualMachine) -> PyResult<PySetInner>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -69,7 +70,7 @@ impl PySet {
         Ok(Self {
             inner: self
                 .inner
-                .fold_op(std::iter::once(other.into_iterable(vm)?), op, vm)?,
+                .fold_op(core::iter::once(other.into_iterable(vm)?), op, vm)?,
         })
     }
 }
@@ -112,7 +113,7 @@ impl PyFrozenSet {
 
     fn fold_op(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         op: fn(&PySetInner, ArgIterable, &VirtualMachine) -> PyResult<PySetInner>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -131,7 +132,7 @@ impl PyFrozenSet {
         Ok(Self {
             inner: self
                 .inner
-                .fold_op(std::iter::once(other.into_iterable(vm)?), op, vm)?,
+                .fold_op(core::iter::once(other.into_iterable(vm)?), op, vm)?,
             ..Default::default()
         })
     }
@@ -192,7 +193,7 @@ impl PySetInner {
 
     fn fold_op<O>(
         &self,
-        others: impl std::iter::Iterator<Item = O>,
+        others: impl core::iter::Iterator<Item = O>,
         op: fn(&Self, O, &VirtualMachine) -> PyResult<Self>,
         vm: &VirtualMachine,
     ) -> PyResult<Self> {
@@ -353,7 +354,7 @@ impl PySetInner {
 
     fn update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -396,7 +397,7 @@ impl PySetInner {
 
     fn intersection_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         let temp_inner = self.fold_op(others, Self::intersection, vm)?;
@@ -409,7 +410,7 @@ impl PySetInner {
 
     fn difference_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -423,7 +424,7 @@ impl PySetInner {
 
     fn symmetric_difference_update(
         &self,
-        others: impl std::iter::Iterator<Item = ArgIterable>,
+        others: impl core::iter::Iterator<Item = ArgIterable>,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         for iterable in others {
@@ -474,7 +475,7 @@ impl PySetInner {
         F: Fn(&PyObject, &VirtualMachine) -> PyResult<T>,
     {
         op(item, vm).or_else(|original_err| {
-            item.payload_if_subclass::<PySet>(vm)
+            item.downcast_ref::<PySet>()
                 // Keep original error around.
                 .ok_or(original_err)
                 .and_then(|set| {
@@ -530,17 +531,20 @@ fn reduce_set(
         AsNumber,
         Representable
     ),
-    flags(BASETYPE)
+    flags(BASETYPE, _MATCH_SELF)
 )]
 impl PySet {
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.inner.len()
     }
 
+    fn __contains__(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        self.inner.contains(needle, vm)
+    }
+
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.inner.sizeof()
+        core::mem::size_of::<Self>() + self.inner.sizeof()
     }
 
     #[pymethod]
@@ -550,11 +554,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
-    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.inner.contains(&needle, vm)
-    }
-
     #[pymethod]
     fn union(&self, others: PosArgs<ArgIterable>, vm: &VirtualMachine) -> PyResult<Self> {
         self.fold_op(others.into_iter(), PySetInner::union, vm)
@@ -594,8 +593,6 @@ impl PySet {
         self.inner.isdisjoint(other, vm)
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<Self>> {
         if let Ok(other) = AnySet::try_from_object(vm, other) {
             Ok(PyArithmeticValue::Implemented(self.op(
@@ -608,8 +605,6 @@ impl PySet {
         }
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(
         &self,
         other: PyObjectRef,
@@ -626,7 +621,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
     fn __sub__(
         &self,
         other: PyObjectRef,
@@ -643,7 +637,6 @@ impl PySet {
         }
     }
 
-    #[pymethod]
     fn __rsub__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -660,8 +653,6 @@ impl PySet {
         }
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(
         &self,
         other: PyObjectRef,
@@ -705,7 +696,6 @@ impl PySet {
         self.inner.pop(vm)
     }
 
-    #[pymethod]
     fn __ior__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         zelf.inner.update(set.into_iterable_iter(vm)?, vm)?;
         Ok(zelf)
@@ -729,10 +719,11 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __iand__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .intersection_update(std::iter::once(set.into_iterable(vm)?), vm)?;
+        if !set.is(zelf.as_object()) {
+            zelf.inner
+                .intersection_update(core::iter::once(set.into_iterable(vm)?), vm)?;
+        }
         Ok(zelf)
     }
 
@@ -742,10 +733,13 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __isub__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .difference_update(set.into_iterable_iter(vm)?, vm)?;
+        if set.is(zelf.as_object()) {
+            zelf.inner.clear();
+        } else {
+            zelf.inner
+                .difference_update(set.into_iterable_iter(vm)?, vm)?;
+        }
         Ok(zelf)
     }
 
@@ -760,10 +754,13 @@ impl PySet {
         Ok(())
     }
 
-    #[pymethod]
     fn __ixor__(zelf: PyRef<Self>, set: AnySet, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        zelf.inner
-            .symmetric_difference_update(set.into_iterable_iter(vm)?, vm)?;
+        if set.is(zelf.as_object()) {
+            zelf.inner.clear();
+        } else {
+            zelf.inner
+                .symmetric_difference_update(set.into_iterable_iter(vm)?, vm)?;
+        }
         Ok(zelf)
     }
 
@@ -799,9 +796,9 @@ impl AsSequence for PySet {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
             length: atomic_func!(|seq, _vm| Ok(PySet::sequence_downcast(seq).__len__())),
-            contains: atomic_func!(|seq, needle, vm| PySet::sequence_downcast(seq)
-                .inner
-                .contains(needle, vm)),
+            contains: atomic_func!(
+                |seq, needle, vm| PySet::sequence_downcast(seq).__contains__(needle, vm)
+            ),
             ..PySequenceMethods::NOT_IMPLEMENTED
         });
         &AS_SEQUENCE
@@ -830,30 +827,77 @@ impl Iterable for PySet {
 impl AsNumber for PySet {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            // Binary ops check both operands are sets (like CPython's set_sub, etc.)
+            // This is needed because __rsub__ swaps operands: a.__rsub__(b) calls subtract(b, a)
             subtract: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__sub__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    // When called via __rsub__, a might be PyFrozenSet
+                    a.__sub__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             and: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__and__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__and__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             xor: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__xor__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__xor__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             or: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PySet>() {
                     a.__or__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
+                    a.__or__(b.to_owned(), vm)
+                        .map(|r| {
+                            r.map(|s| PySet {
+                                inner: s.inner.clone(),
+                            })
+                        })
+                        .to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -919,35 +963,48 @@ impl Representable for PySet {
 }
 
 impl Constructor for PyFrozenSet {
-    type Args = OptionalArg<PyObjectRef>;
+    type Args = Vec<PyObjectRef>;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let iterable: OptionalArg<PyObjectRef> = args.bind(vm)?;
+
+        // Optimizations for exact frozenset type
+        if cls.is(vm.ctx.types.frozenset_type) {
+            // Return exact frozenset as-is
+            if let OptionalArg::Present(ref input) = iterable
+                && let Ok(fs) = input.clone().downcast_exact::<PyFrozenSet>(vm)
+            {
+                return Ok(fs.into_pyref().into());
+            }
 
-    fn py_new(cls: PyTypeRef, iterable: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let elements = if let OptionalArg::Present(iterable) = iterable {
-            let iterable = if cls.is(vm.ctx.types.frozenset_type) {
-                match iterable.downcast_exact::<Self>(vm) {
-                    Ok(fs) => return Ok(fs.into_pyref().into()),
-                    Err(iterable) => iterable,
-                }
-            } else {
-                iterable
-            };
+            // Return empty frozenset singleton
+            if iterable.is_missing() {
+                return Ok(vm.ctx.empty_frozenset.clone().into());
+            }
+        }
+
+        let elements: Vec<PyObjectRef> = if let OptionalArg::Present(iterable) = iterable {
             iterable.try_to_value(vm)?
         } else {
             vec![]
         };
 
-        // Return empty fs if iterable passed is empty and only for exact fs types.
+        // Return empty frozenset singleton for exact frozenset types (when iterable was empty)
         if elements.is_empty() && cls.is(vm.ctx.types.frozenset_type) {
-            Ok(vm.ctx.empty_frozenset.clone().into())
-        } else {
-            Self::from_iter(vm, elements)
-                .and_then(|o| o.into_ref_with_type(vm, cls).map(Into::into))
+            return Ok(vm.ctx.empty_frozenset.clone().into());
         }
+
+        let payload = Self::py_new(&cls, elements, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, elements: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        Self::from_iter(vm, elements)
     }
 }
 
 #[pyclass(
-    flags(BASETYPE),
+    flags(BASETYPE, _MATCH_SELF),
     with(
         Constructor,
         AsSequence,
@@ -959,14 +1016,17 @@ impl Constructor for PyFrozenSet {
     )
 )]
 impl PyFrozenSet {
-    #[pymethod]
     fn __len__(&self) -> usize {
         self.inner.len()
     }
 
+    fn __contains__(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        self.inner.contains(needle, vm)
+    }
+
     #[pymethod]
     fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.inner.sizeof()
+        core::mem::size_of::<Self>() + self.inner.sizeof()
     }
 
     #[pymethod]
@@ -982,11 +1042,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
-    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.inner.contains(&needle, vm)
-    }
-
     #[pymethod]
     fn union(&self, others: PosArgs<ArgIterable>, vm: &VirtualMachine) -> PyResult<Self> {
         self.fold_op(others.into_iter(), PySetInner::union, vm)
@@ -1026,8 +1081,6 @@ impl PyFrozenSet {
         self.inner.isdisjoint(other, vm)
     }
 
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
     fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<Self>> {
         if let Ok(set) = AnySet::try_from_object(vm, other) {
             Ok(PyArithmeticValue::Implemented(self.op(
@@ -1040,8 +1093,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
     fn __and__(
         &self,
         other: PyObjectRef,
@@ -1058,7 +1109,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
     fn __sub__(
         &self,
         other: PyObjectRef,
@@ -1075,7 +1125,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod]
     fn __rsub__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -1093,8 +1142,6 @@ impl PyFrozenSet {
         }
     }
 
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
     fn __xor__(
         &self,
         other: PyObjectRef,
@@ -1129,9 +1176,9 @@ impl AsSequence for PyFrozenSet {
     fn as_sequence() -> &'static PySequenceMethods {
         static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
             length: atomic_func!(|seq, _vm| Ok(PyFrozenSet::sequence_downcast(seq).__len__())),
-            contains: atomic_func!(|seq, needle, vm| PyFrozenSet::sequence_downcast(seq)
-                .inner
-                .contains(needle, vm)),
+            contains: atomic_func!(
+                |seq, needle, vm| PyFrozenSet::sequence_downcast(seq).__contains__(needle, vm)
+            ),
             ..PySequenceMethods::NOT_IMPLEMENTED
         });
         &AS_SEQUENCE
@@ -1183,30 +1230,53 @@ impl Iterable for PyFrozenSet {
 impl AsNumber for PyFrozenSet {
     fn as_number() -> &'static PyNumberMethods {
         static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            // Binary ops check both operands are sets (like CPython's set_sub, etc.)
+            // __rsub__ swaps operands. Result type follows first operand's type.
             subtract: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__sub__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    // When called via __rsub__, a might be PySet - return set (not frozenset)
+                    a.__sub__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             and: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__and__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__and__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             xor: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__xor__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__xor__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
             }),
             or: Some(|a, b, vm| {
+                if !AnySet::check(a, vm) || !AnySet::check(b, vm) {
+                    return Ok(vm.ctx.not_implemented());
+                }
                 if let Some(a) = a.downcast_ref::<PyFrozenSet>() {
                     a.__or__(b.to_owned(), vm).to_pyresult(vm)
+                } else if let Some(a) = a.downcast_ref::<PySet>() {
+                    a.__or__(b.to_owned(), vm).to_pyresult(vm)
                 } else {
                     Ok(vm.ctx.not_implemented())
                 }
@@ -1238,7 +1308,21 @@ struct AnySet {
     object: PyObjectRef,
 }
 
+impl Borrow<PyObject> for AnySet {
+    #[inline(always)]
+    fn borrow(&self) -> &PyObject {
+        &self.object
+    }
+}
+
 impl AnySet {
+    /// Check if object is a set or frozenset (including subclasses)
+    /// Equivalent to CPython's PyAnySet_Check
+    fn check(obj: &PyObject, vm: &VirtualMachine) -> bool {
+        let ctx = &vm.ctx;
+        obj.fast_isinstance(ctx.types.set_type) || obj.fast_isinstance(ctx.types.frozenset_type)
+    }
+
     fn into_iterable(self, vm: &VirtualMachine) -> PyResult<ArgIterable> {
         self.object.try_into_value(vm)
     }
@@ -1246,8 +1330,8 @@ impl AnySet {
     fn into_iterable_iter(
         self,
         vm: &VirtualMachine,
-    ) -> PyResult<impl std::iter::Iterator<Item = ArgIterable>> {
-        Ok(std::iter::once(self.into_iterable(vm)?))
+    ) -> PyResult<impl core::iter::Iterator<Item = ArgIterable>> {
+        Ok(core::iter::once(self.into_iterable(vm)?))
     }
 
     fn as_inner(&self) -> &PySetInner {
@@ -1292,7 +1376,7 @@ impl PyPayload for PySetIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PySetIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -1318,7 +1402,6 @@ impl PySetIterator {
         ))
     }
 }
-impl Unconstructible for PySetIterator {}
 
 impl SelfIter for PySetIterator {}
 impl IterNext for PySetIterator {
diff --git a/crates/vm/src/builtins/singletons.rs b/crates/vm/src/builtins/singletons.rs
new file mode 100644
index 0000000000..61ab1968a4
--- /dev/null
+++ b/crates/vm/src/builtins/singletons.rs
@@ -0,0 +1,137 @@
+use super::{PyStrRef, PyType, PyTypeRef};
+use crate::{
+    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    convert::ToPyObject,
+    function::FuncArgs,
+    protocol::PyNumberMethods,
+    types::{AsNumber, Constructor, Representable},
+};
+
+#[pyclass(module = false, name = "NoneType")]
+#[derive(Debug)]
+pub struct PyNone;
+
+impl PyPayload for PyNone {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.none_type
+    }
+}
+
+// This allows a built-in function to not return a value, mapping to
+// Python's behavior of returning `None` in this situation.
+impl ToPyObject for () {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.none()
+    }
+}
+
+impl<T: ToPyObject> ToPyObject for Option<T> {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        match self {
+            Some(x) => x.to_pyobject(vm),
+            None => vm.ctx.none(),
+        }
+    }
+}
+
+impl Constructor for PyNone {
+    type Args = ();
+
+    fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let _: () = args.bind(vm)?;
+        Ok(vm.ctx.none.clone().into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unreachable!("None is a singleton")
+    }
+}
+
+#[pyclass(with(Constructor, AsNumber, Representable))]
+impl PyNone {}
+
+impl Representable for PyNone {
+    #[inline]
+    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        Ok(vm.ctx.names.None.to_owned())
+    }
+
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use repr instead")
+    }
+}
+
+impl AsNumber for PyNone {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|_number, _vm| Ok(false)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+#[pyclass(module = false, name = "NotImplementedType")]
+#[derive(Debug)]
+pub struct PyNotImplemented;
+
+impl PyPayload for PyNotImplemented {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.not_implemented_type
+    }
+}
+
+impl Constructor for PyNotImplemented {
+    type Args = ();
+
+    fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let _: () = args.bind(vm)?;
+        Ok(vm.ctx.not_implemented.clone().into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unreachable!("PyNotImplemented is a singleton")
+    }
+}
+
+#[pyclass(with(Constructor, AsNumber, Representable))]
+impl PyNotImplemented {
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyStrRef {
+        vm.ctx.names.NotImplemented.to_owned()
+    }
+}
+
+impl AsNumber for PyNotImplemented {
+    fn as_number() -> &'static PyNumberMethods {
+        // TODO: As per https://bugs.python.org/issue35712, using NotImplemented
+        // in boolean contexts will need to raise a DeprecationWarning in 3.9
+        // and, eventually, a TypeError.
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|_number, _vm| Ok(true)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl Representable for PyNotImplemented {
+    #[inline]
+    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        Ok(vm.ctx.names.NotImplemented.to_owned())
+    }
+
+    #[cold]
+    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        unreachable!("use repr instead")
+    }
+}
+
+pub fn init(context: &Context) {
+    PyNone::extend_class(context, context.types.none_type);
+    PyNotImplemented::extend_class(context, context.types.not_implemented_type);
+}
diff --git a/vm/src/builtins/slice.rs b/crates/vm/src/builtins/slice.rs
similarity index 95%
rename from vm/src/builtins/slice.rs
rename to crates/vm/src/builtins/slice.rs
index f77c8cb8e8..3aa23b0746 100644
--- a/vm/src/builtins/slice.rs
+++ b/crates/vm/src/builtins/slice.rs
@@ -174,6 +174,7 @@ impl PySlice {
 
     #[pymethod]
     fn indices(&self, length: ArgIndex, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        let length = length.into_int_ref();
         let length = length.as_bigint();
         if length.is_negative() {
             return Err(vm.new_value_error("length should not be negative."));
@@ -228,7 +229,7 @@ impl Hashable for PySlice {
         };
 
         let mut acc = XXPRIME_5;
-        for part in [zelf.start_ref(vm), &zelf.stop, zelf.step_ref(vm)].iter() {
+        for part in &[zelf.start_ref(vm), &zelf.stop, zelf.step_ref(vm)] {
             let lane = part.hash(vm)? as PyUHash;
             if lane == u64::MAX as PyUHash {
                 return Ok(-1 as PyHash);
@@ -292,15 +293,10 @@ impl Representable for PySlice {
     #[inline]
     fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
         let start_repr = zelf.start_ref(vm).repr(vm)?;
-        let stop_repr = &zelf.stop.repr(vm)?;
+        let stop_repr = zelf.stop.repr(vm)?;
         let step_repr = zelf.step_ref(vm).repr(vm)?;
 
-        Ok(format!(
-            "slice({}, {}, {})",
-            start_repr.as_str(),
-            stop_repr.as_str(),
-            step_repr.as_str()
-        ))
+        Ok(format!("slice({start_repr}, {stop_repr}, {step_repr})"))
     }
 }
 
@@ -318,9 +314,14 @@ impl PyPayload for PyEllipsis {
 impl Constructor for PyEllipsis {
     type Args = ();
 
-    fn py_new(_cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let _: () = args.bind(vm)?;
         Ok(vm.ctx.ellipsis.clone().into())
     }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unreachable!("Ellipsis is a singleton")
+    }
 }
 
 #[pyclass(with(Constructor, Representable))]
diff --git a/vm/src/builtins/staticmethod.rs b/crates/vm/src/builtins/staticmethod.rs
similarity index 89%
rename from vm/src/builtins/staticmethod.rs
rename to crates/vm/src/builtins/staticmethod.rs
index c357516abb..5d2474a567 100644
--- a/vm/src/builtins/staticmethod.rs
+++ b/crates/vm/src/builtins/staticmethod.rs
@@ -43,7 +43,8 @@ impl From<PyObjectRef> for PyStaticMethod {
 impl Constructor for PyStaticMethod {
     type Args = PyObjectRef;
 
-    fn py_new(cls: PyTypeRef, callable: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let callable: Self::Args = args.bind(vm)?;
         let doc = callable.get_attr("__doc__", vm);
 
         let result = Self {
@@ -58,17 +59,21 @@ impl Constructor for PyStaticMethod {
 
         Ok(obj)
     }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
 }
 
 impl PyStaticMethod {
+    pub fn new(callable: PyObjectRef) -> Self {
+        Self {
+            callable: PyMutex::new(callable),
+        }
+    }
+    #[deprecated(note = "use PyStaticMethod::new(...).into_ref() instead")]
     pub fn new_ref(callable: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self {
-                callable: PyMutex::new(callable),
-            },
-            ctx.types.staticmethod_type.to_owned(),
-            None,
-        )
+        Self::new(callable).into_ref(ctx)
     }
 }
 
diff --git a/crates/vm/src/builtins/str.rs b/crates/vm/src/builtins/str.rs
new file mode 100644
index 0000000000..640778c8cb
--- /dev/null
+++ b/crates/vm/src/builtins/str.rs
@@ -0,0 +1,2517 @@
+use super::{
+    PositionIterInternal, PyBytesRef, PyDict, PyTupleRef, PyType, PyTypeRef,
+    int::{PyInt, PyIntRef},
+    iter::IterStatus::{self, Exhausted},
+};
+use crate::{
+    AsObject, Context, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
+    TryFromBorrowedObject, VirtualMachine,
+    anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper, adjust_indices},
+    atomic_func,
+    cformat::cformat_string,
+    class::PyClassImpl,
+    common::str::{PyKindStr, StrData, StrKind},
+    convert::{IntoPyException, ToPyException, ToPyObject, ToPyResult},
+    format::{format, format_map},
+    function::{ArgIterable, ArgSize, FuncArgs, OptionalArg, OptionalOption, PyComparisonValue},
+    intern::PyInterned,
+    object::{MaybeTraverse, Traverse, TraverseFn},
+    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    sequence::SequenceExt,
+    sliceable::{SequenceIndex, SliceableSequenceOp},
+    types::{
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
+        PyComparisonOp, Representable, SelfIter,
+    },
+};
+use alloc::{borrow::Cow, fmt};
+use ascii::{AsciiChar, AsciiStr, AsciiString};
+use bstr::ByteSlice;
+use core::{char, mem, ops::Range};
+use itertools::Itertools;
+use num_traits::ToPrimitive;
+use rustpython_common::{
+    ascii,
+    atomic::{self, PyAtomic, Radium},
+    format::{FormatSpec, FormatString, FromTemplate},
+    hash,
+    lock::PyMutex,
+    str::DeduceStrKind,
+    wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk},
+};
+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)
+    }
+}
+
+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)?;
+        Ok(pystr.as_str())
+    }
+}
+
+impl<'a> TryFromBorrowedObject<'a> for &'a Wtf8 {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+        let pystr: &Py<PyStr> = TryFromBorrowedObject::try_from_borrowed_object(vm, obj)?;
+        Ok(pystr.as_wtf8())
+    }
+}
+
+pub type PyStrRef = PyRef<PyStr>;
+pub type PyUtf8StrRef = PyRef<PyUtf8Str>;
+
+#[pyclass(module = false, name = "str")]
+pub struct PyStr {
+    data: StrData,
+    hash: PyAtomic<hash::PyHash>,
+}
+
+impl fmt::Debug for PyStr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PyStr")
+            .field("value", &self.as_wtf8())
+            .field("kind", &self.data.kind())
+            .field("hash", &self.hash)
+            .finish()
+    }
+}
+
+impl AsRef<str> for PyStr {
+    #[track_caller] // <- can remove this once it doesn't panic
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<str> for Py<PyStr> {
+    #[track_caller] // <- can remove this once it doesn't panic
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<str> for PyStrRef {
+    #[track_caller] // <- can remove this once it doesn't panic
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<Wtf8> for PyStr {
+    fn as_ref(&self) -> &Wtf8 {
+        self.as_wtf8()
+    }
+}
+
+impl AsRef<Wtf8> for Py<PyStr> {
+    fn as_ref(&self) -> &Wtf8 {
+        self.as_wtf8()
+    }
+}
+
+impl AsRef<Wtf8> for PyStrRef {
+    fn as_ref(&self) -> &Wtf8 {
+        self.as_wtf8()
+    }
+}
+
+impl<'a> From<&'a AsciiStr> for PyStr {
+    fn from(s: &'a AsciiStr) -> Self {
+        s.to_owned().into()
+    }
+}
+
+impl From<AsciiString> for PyStr {
+    fn from(s: AsciiString) -> Self {
+        s.into_boxed_ascii_str().into()
+    }
+}
+
+impl From<Box<AsciiStr>> for PyStr {
+    fn from(s: Box<AsciiStr>) -> Self {
+        StrData::from(s).into()
+    }
+}
+
+impl From<AsciiChar> for PyStr {
+    fn from(ch: AsciiChar) -> Self {
+        AsciiString::from(ch).into()
+    }
+}
+
+impl<'a> From<&'a str> for PyStr {
+    fn from(s: &'a str) -> Self {
+        s.to_owned().into()
+    }
+}
+
+impl<'a> From<&'a Wtf8> for PyStr {
+    fn from(s: &'a Wtf8) -> Self {
+        s.to_owned().into()
+    }
+}
+
+impl From<String> for PyStr {
+    fn from(s: String) -> Self {
+        s.into_boxed_str().into()
+    }
+}
+
+impl From<Wtf8Buf> for PyStr {
+    fn from(w: Wtf8Buf) -> Self {
+        w.into_box().into()
+    }
+}
+
+impl From<char> for PyStr {
+    fn from(ch: char) -> Self {
+        StrData::from(ch).into()
+    }
+}
+
+impl From<CodePoint> for PyStr {
+    fn from(ch: CodePoint) -> Self {
+        StrData::from(ch).into()
+    }
+}
+
+impl From<StrData> for PyStr {
+    fn from(data: StrData) -> Self {
+        Self {
+            data,
+            hash: Radium::new(hash::SENTINEL),
+        }
+    }
+}
+
+impl<'a> From<alloc::borrow::Cow<'a, str>> for PyStr {
+    fn from(s: alloc::borrow::Cow<'a, str>) -> Self {
+        s.into_owned().into()
+    }
+}
+
+impl From<Box<str>> for PyStr {
+    #[inline]
+    fn from(value: Box<str>) -> Self {
+        StrData::from(value).into()
+    }
+}
+
+impl From<Box<Wtf8>> for PyStr {
+    #[inline]
+    fn from(value: Box<Wtf8>) -> Self {
+        StrData::from(value).into()
+    }
+}
+
+impl Default for PyStr {
+    fn default() -> Self {
+        Self {
+            data: StrData::default(),
+            hash: Radium::new(hash::SENTINEL),
+        }
+    }
+}
+
+impl fmt::Display for PyStr {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_wtf8().fmt(f)
+    }
+}
+
+pub trait AsPyStr<'a>
+where
+    Self: 'a,
+{
+    #[allow(clippy::wrong_self_convention)] // to implement on refs
+    fn as_pystr(self, ctx: &Context) -> &'a Py<PyStr>;
+}
+
+impl<'a> AsPyStr<'a> for &'a Py<PyStr> {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
+impl<'a> AsPyStr<'a> for &'a PyStrRef {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
+impl AsPyStr<'static> for &'static str {
+    #[inline]
+    fn as_pystr(self, ctx: &Context) -> &'static Py<PyStr> {
+        ctx.intern_str(self)
+    }
+}
+
+impl<'a> AsPyStr<'a> for &'a PyStrInterned {
+    #[inline]
+    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
+        self
+    }
+}
+
+#[pyclass(module = false, name = "str_iterator", traverse = "manual")]
+#[derive(Debug)]
+pub struct PyStrIterator {
+    internal: PyMutex<(PositionIterInternal<PyStrRef>, usize)>,
+}
+
+unsafe impl Traverse for PyStrIterator {
+    fn traverse(&self, tracer: &mut TraverseFn<'_>) {
+        // No need to worry about deadlock, for inner is a PyStr and can't make ref cycle
+        self.internal.lock().0.traverse(tracer);
+    }
+}
+
+impl PyPayload for PyStrIterator {
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.str_iterator_type
+    }
+}
+
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
+impl PyStrIterator {
+    #[pymethod]
+    fn __length_hint__(&self) -> usize {
+        self.internal.lock().0.length_hint(|obj| obj.char_len())
+    }
+
+    #[pymethod]
+    fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let mut internal = self.internal.lock();
+        internal.1 = usize::MAX;
+        internal
+            .0
+            .set_state(state, |obj, pos| pos.min(obj.char_len()), vm)
+    }
+
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        self.internal
+            .lock()
+            .0
+            .builtins_iter_reduce(|x| x.clone().into(), vm)
+    }
+}
+
+impl SelfIter for PyStrIterator {}
+
+impl IterNext for PyStrIterator {
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        let mut internal = zelf.internal.lock();
+
+        if let IterStatus::Active(s) = &internal.0.status {
+            let value = s.as_wtf8();
+
+            if internal.1 == usize::MAX {
+                if let Some((offset, ch)) = value.code_point_indices().nth(internal.0.position) {
+                    internal.0.position += 1;
+                    internal.1 = offset + ch.len_wtf8();
+                    return Ok(PyIterReturn::Return(ch.to_pyobject(vm)));
+                }
+            } else if let Some(value) = value.get(internal.1..)
+                && let Some(ch) = value.code_points().next()
+            {
+                internal.0.position += 1;
+                internal.1 += ch.len_wtf8();
+                return Ok(PyIterReturn::Return(ch.to_pyobject(vm)));
+            }
+            internal.0.status = Exhausted;
+        }
+        Ok(PyIterReturn::StopIteration(None))
+    }
+}
+
+#[derive(FromArgs)]
+pub struct StrArgs {
+    #[pyarg(any, optional)]
+    object: OptionalArg<PyObjectRef>,
+    #[pyarg(any, optional)]
+    encoding: OptionalArg<PyStrRef>,
+    #[pyarg(any, optional)]
+    errors: OptionalArg<PyStrRef>,
+}
+
+impl Constructor for PyStr {
+    type Args = StrArgs;
+
+    fn slot_new(cls: PyTypeRef, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Optimization: return exact str as-is (only when no encoding/errors provided)
+        if cls.is(vm.ctx.types.str_type)
+            && func_args.args.len() == 1
+            && func_args.kwargs.is_empty()
+            && func_args.args[0].class().is(vm.ctx.types.str_type)
+        {
+            return Ok(func_args.args[0].clone());
+        }
+
+        let args: Self::Args = func_args.bind(vm)?;
+        let payload = Self::py_new(&cls, args, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        match args.object {
+            OptionalArg::Present(input) => {
+                if let OptionalArg::Present(enc) = args.encoding {
+                    let s = vm.state.codec_registry.decode_text(
+                        input,
+                        enc.as_str(),
+                        args.errors.into_option(),
+                        vm,
+                    )?;
+                    Ok(Self::from(s.as_wtf8().to_owned()))
+                } else {
+                    let s = input.str(vm)?;
+                    Ok(Self::from(s.as_wtf8().to_owned()))
+                }
+            }
+            OptionalArg::Missing => Ok(Self::from(String::new())),
+        }
+    }
+}
+
+impl PyStr {
+    /// # Safety: Given `bytes` must be valid data for given `kind`
+    unsafe fn new_str_unchecked(data: Box<Wtf8>, kind: StrKind) -> Self {
+        unsafe { StrData::new_str_unchecked(data, kind) }.into()
+    }
+
+    unsafe fn new_with_char_len<T: DeduceStrKind + Into<Box<Wtf8>>>(s: T, char_len: usize) -> Self {
+        let kind = s.str_kind();
+        unsafe { StrData::new_with_char_len(s.into(), kind, char_len) }.into()
+    }
+
+    /// # Safety
+    /// Given `bytes` must be ascii
+    pub unsafe fn new_ascii_unchecked(bytes: Vec<u8>) -> Self {
+        unsafe { AsciiString::from_ascii_unchecked(bytes) }.into()
+    }
+
+    #[deprecated(note = "use PyStr::from(...).into_ref() instead")]
+    pub fn new_ref(zelf: impl Into<Self>, ctx: &Context) -> PyRef<Self> {
+        let zelf = zelf.into();
+        zelf.into_ref(ctx)
+    }
+
+    fn new_substr(&self, s: Wtf8Buf) -> Self {
+        let kind = if self.kind().is_ascii() || s.is_ascii() {
+            StrKind::Ascii
+        } else if self.kind().is_utf8() || s.is_utf8() {
+            StrKind::Utf8
+        } else {
+            StrKind::Wtf8
+        };
+        unsafe {
+            // SAFETY: kind is properly decided for substring
+            Self::new_str_unchecked(s.into(), kind)
+        }
+    }
+
+    #[inline]
+    pub const fn as_wtf8(&self) -> &Wtf8 {
+        self.data.as_wtf8()
+    }
+
+    pub const fn as_bytes(&self) -> &[u8] {
+        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()
+    }
+
+    pub(crate) fn ensure_valid_utf8(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if self.is_utf8() {
+            Ok(())
+        } else {
+            let start = self
+                .as_wtf8()
+                .code_points()
+                .position(|c| c.to_char().is_none())
+                .unwrap();
+            Err(vm.new_unicode_encode_error_real(
+                identifier!(vm, utf_8).to_owned(),
+                vm.ctx.new_str(self.data.clone()),
+                start,
+                start + 1,
+                vm.ctx.new_str("surrogates not allowed"),
+            ))
+        }
+    }
+
+    pub fn to_string_lossy(&self) -> Cow<'_, str> {
+        self.to_str()
+            .map(Cow::Borrowed)
+            .unwrap_or_else(|| self.as_wtf8().to_string_lossy())
+    }
+
+    pub const fn kind(&self) -> StrKind {
+        self.data.kind()
+    }
+
+    #[inline]
+    pub fn as_str_kind(&self) -> PyKindStr<'_> {
+        self.data.as_str_kind()
+    }
+
+    pub const fn is_utf8(&self) -> bool {
+        self.kind().is_utf8()
+    }
+
+    fn char_all<F>(&self, test: F) -> bool
+    where
+        F: Fn(char) -> bool,
+    {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s.chars().all(|ch| test(ch.into())),
+            PyKindStr::Utf8(s) => s.chars().all(test),
+            PyKindStr::Wtf8(w) => w.code_points().all(|ch| ch.is_char_and(&test)),
+        }
+    }
+
+    fn repeat(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        if value == 0 && zelf.class().is(vm.ctx.types.str_type) {
+            // Special case: when some `str` is multiplied by `0`,
+            // returns the empty `str`.
+            return Ok(vm.ctx.empty_str.to_owned());
+        }
+        if (value == 1 || zelf.is_empty()) && zelf.class().is(vm.ctx.types.str_type) {
+            // Special case: when some `str` is multiplied by `1` or is the empty `str`,
+            // nothing really happens, we need to return an object itself
+            // with the same `id()` to be compatible with CPython.
+            // This only works for `str` itself, not its subclasses.
+            return Ok(zelf);
+        }
+        zelf.as_wtf8()
+            .as_bytes()
+            .mul(vm, value)
+            .map(|x| Self::from(unsafe { Wtf8Buf::from_bytes_unchecked(x) }).into_ref(&vm.ctx))
+    }
+
+    pub fn try_as_utf8<'a>(&'a self, vm: &VirtualMachine) -> PyResult<&'a PyUtf8Str> {
+        // Check if the string contains surrogates
+        self.ensure_valid_utf8(vm)?;
+        // If no surrogates, we can safely cast to PyStr
+        Ok(unsafe { &*(self as *const _ as *const PyUtf8Str) })
+    }
+}
+
+impl Py<PyStr> {
+    pub fn try_as_utf8<'a>(&'a self, vm: &VirtualMachine) -> PyResult<&'a Py<PyUtf8Str>> {
+        // Check if the string contains surrogates
+        self.ensure_valid_utf8(vm)?;
+        // If no surrogates, we can safely cast to PyStr
+        Ok(unsafe { &*(self as *const _ as *const Py<PyUtf8Str>) })
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE, _MATCH_SELF),
+    with(
+        AsMapping,
+        AsNumber,
+        AsSequence,
+        Representable,
+        Hashable,
+        Comparable,
+        Iterable,
+        Constructor
+    )
+)]
+impl PyStr {
+    fn __add__(zelf: PyRef<Self>, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if let Some(other) = other.downcast_ref::<Self>() {
+            let bytes = zelf.as_wtf8().py_add(other.as_wtf8());
+            Ok(unsafe {
+                // SAFETY: `kind` is safely decided
+                let kind = zelf.kind() | other.kind();
+                Self::new_str_unchecked(bytes.into(), kind)
+            }
+            .to_pyobject(vm))
+        } else if let Some(radd) = vm.get_method(other.clone(), identifier!(vm, __radd__)) {
+            // hack to get around not distinguishing number add from seq concat
+            radd?.call((zelf,), vm)
+        } else {
+            Err(vm.new_type_error(format!(
+                r#"can only concatenate str (not "{}") to str"#,
+                other.class().name()
+            )))
+        }
+    }
+
+    fn _contains(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        if let Some(needle) = needle.downcast_ref::<Self>() {
+            Ok(memchr::memmem::find(self.as_bytes(), needle.as_bytes()).is_some())
+        } else {
+            Err(vm.new_type_error(format!(
+                "'in <string>' requires string as left operand, not {}",
+                needle.class().name()
+            )))
+        }
+    }
+
+    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        self._contains(&needle, vm)
+    }
+
+    fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
+        let item = match SequenceIndex::try_from_borrowed_object(vm, needle, "str")? {
+            SequenceIndex::Int(i) => self.getitem_by_index(vm, i)?.to_pyobject(vm),
+            SequenceIndex::Slice(slice) => self.getitem_by_slice(vm, slice)?.to_pyobject(vm),
+        };
+        Ok(item)
+    }
+
+    fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        self._getitem(&needle, vm)
+    }
+
+    #[inline]
+    pub(crate) fn hash(&self, vm: &VirtualMachine) -> hash::PyHash {
+        match self.hash.load(atomic::Ordering::Relaxed) {
+            hash::SENTINEL => self._compute_hash(vm),
+            hash => hash,
+        }
+    }
+
+    #[cold]
+    fn _compute_hash(&self, vm: &VirtualMachine) -> hash::PyHash {
+        let hash_val = vm.state.hash_secret.hash_bytes(self.as_bytes());
+        debug_assert_ne!(hash_val, hash::SENTINEL);
+        // spell-checker:ignore cmpxchg
+        // like with char_len, we don't need a cmpxchg loop, since it'll always be the same value
+        self.hash.store(hash_val, atomic::Ordering::Relaxed);
+        hash_val
+    }
+
+    #[inline]
+    pub fn byte_len(&self) -> usize {
+        self.data.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    #[pymethod(name = "__len__")]
+    #[inline]
+    pub fn char_len(&self) -> usize {
+        self.data.char_len()
+    }
+
+    #[pymethod]
+    #[inline(always)]
+    pub const fn isascii(&self) -> bool {
+        matches!(self.kind(), StrKind::Ascii)
+    }
+
+    #[pymethod]
+    fn __sizeof__(&self) -> usize {
+        core::mem::size_of::<Self>() + self.byte_len() * core::mem::size_of::<u8>()
+    }
+
+    fn __mul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        Self::repeat(zelf, value.into(), vm)
+    }
+
+    #[inline]
+    pub(crate) fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
+        use crate::literal::escape::UnicodeEscape;
+        UnicodeEscape::new_repr(self.as_wtf8())
+            .str_repr()
+            .to_string()
+            .ok_or_else(|| vm.new_overflow_error("string is too long to generate repr"))
+    }
+
+    #[pymethod]
+    fn lower(&self) -> Self {
+        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(),
+        }
+    }
+
+    // casefold is much more aggressive than lower
+    #[pymethod]
+    fn casefold(&self) -> Self {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => caseless::default_case_fold_str(s.as_str()).into(),
+            PyKindStr::Utf8(s) => caseless::default_case_fold_str(s).into(),
+            PyKindStr::Wtf8(w) => w
+                .chunks()
+                .map(|c| match c {
+                    Wtf8Chunk::Utf8(s) => Wtf8Buf::from_string(caseless::default_case_fold_str(s)),
+                    Wtf8Chunk::Surrogate(c) => Wtf8Buf::from(c),
+                })
+                .collect::<Wtf8Buf>()
+                .into(),
+        }
+    }
+
+    #[pymethod]
+    fn upper(&self) -> Self {
+        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(),
+        }
+    }
+
+    #[pymethod]
+    fn capitalize(&self) -> Wtf8Buf {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => {
+                let mut s = s.to_owned();
+                if let [first, rest @ ..] = s.as_mut_slice() {
+                    first.make_ascii_uppercase();
+                    ascii::AsciiStr::make_ascii_lowercase(rest.into());
+                }
+                s.into()
+            }
+            PyKindStr::Utf8(s) => {
+                let mut chars = s.chars();
+                let mut out = String::with_capacity(s.len());
+                if let Some(c) = chars.next() {
+                    out.extend(c.to_titlecase());
+                    out.push_str(&chars.as_str().to_lowercase());
+                }
+                out.into()
+            }
+            PyKindStr::Wtf8(s) => {
+                let mut out = Wtf8Buf::with_capacity(s.len());
+                let mut chars = s.code_points();
+                if let Some(ch) = chars.next() {
+                    match ch.to_char() {
+                        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
+            }
+        }
+    }
+
+    #[pymethod]
+    fn split(zelf: &Py<Self>, args: SplitArgs, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        let elements = match zelf.as_str_kind() {
+            PyKindStr::Ascii(s) => s.py_split(
+                args,
+                vm,
+                || zelf.as_object().to_owned(),
+                |v, s, vm| {
+                    v.as_bytes()
+                        .split_str(s)
+                        .map(|s| unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm))
+                        .collect()
+                },
+                |v, s, n, vm| {
+                    v.as_bytes()
+                        .splitn_str(n, s)
+                        .map(|s| unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm))
+                        .collect()
+                },
+                |v, n, vm| {
+                    v.as_bytes().py_split_whitespace(n, |s| {
+                        unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm)
+                    })
+                },
+            ),
+            PyKindStr::Utf8(s) => s.py_split(
+                args,
+                vm,
+                || zelf.as_object().to_owned(),
+                |v, s, vm| v.split(s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
+            ),
+            PyKindStr::Wtf8(w) => w.py_split(
+                args,
+                vm,
+                || zelf.as_object().to_owned(),
+                |v, s, vm| v.split(s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
+                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
+            ),
+        }?;
+        Ok(elements)
+    }
+
+    #[pymethod]
+    fn rsplit(zelf: &Py<Self>, args: SplitArgs, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+        let mut elements = zelf.as_wtf8().py_split(
+            args,
+            vm,
+            || zelf.as_object().to_owned(),
+            |v, s, vm| v.rsplit(s).map(|s| vm.ctx.new_str(s).into()).collect(),
+            |v, s, n, vm| v.rsplitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
+            |v, n, vm| v.py_rsplit_whitespace(n, |s| vm.ctx.new_str(s).into()),
+        )?;
+        // Unlike Python rsplit, Rust rsplitn returns an iterator that
+        // starts from the end of the string.
+        elements.reverse();
+        Ok(elements)
+    }
+
+    #[pymethod]
+    fn strip(&self, chars: OptionalOption<PyStrRef>) -> Self {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s
+                .py_strip(
+                    chars,
+                    |s, chars| {
+                        let s = s
+                            .as_str()
+                            .trim_matches(|c| memchr::memchr(c as _, chars.as_bytes()).is_some());
+                        unsafe { AsciiStr::from_ascii_unchecked(s.as_bytes()) }
+                    },
+                    |s| s.trim(),
+                )
+                .into(),
+            PyKindStr::Utf8(s) => s
+                .py_strip(
+                    chars,
+                    |s, chars| s.trim_matches(|c| chars.contains(c)),
+                    |s| s.trim(),
+                )
+                .into(),
+            PyKindStr::Wtf8(w) => w
+                .py_strip(
+                    chars,
+                    |s, chars| s.trim_matches(|c| chars.code_points().contains(&c)),
+                    |s| s.trim(),
+                )
+                .into(),
+        }
+    }
+
+    #[pymethod]
+    fn lstrip(
+        zelf: PyRef<Self>,
+        chars: OptionalOption<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyRef<Self> {
+        let s = zelf.as_wtf8();
+        let stripped = s.py_strip(
+            chars,
+            |s, chars| s.trim_start_matches(|c| chars.contains_code_point(c)),
+            |s| s.trim_start(),
+        );
+        if s == stripped {
+            zelf
+        } else {
+            vm.ctx.new_str(stripped)
+        }
+    }
+
+    #[pymethod]
+    fn rstrip(
+        zelf: PyRef<Self>,
+        chars: OptionalOption<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyRef<Self> {
+        let s = zelf.as_wtf8();
+        let stripped = s.py_strip(
+            chars,
+            |s, chars| s.trim_end_matches(|c| chars.contains_code_point(c)),
+            |s| s.trim_end(),
+        );
+        if s == stripped {
+            zelf
+        } else {
+            vm.ctx.new_str(stripped)
+        }
+    }
+
+    #[pymethod]
+    fn endswith(&self, options: anystr::StartsEndsWithArgs, vm: &VirtualMachine) -> PyResult<bool> {
+        let (affix, substr) =
+            match options.prepare(self.as_wtf8(), self.len(), |s, r| s.get_chars(r)) {
+                Some(x) => x,
+                None => return Ok(false),
+            };
+        substr.py_starts_ends_with(
+            &affix,
+            "endswith",
+            "str",
+            |s, x: &Py<Self>| s.ends_with(x.as_wtf8()),
+            vm,
+        )
+    }
+
+    #[pymethod]
+    fn startswith(
+        &self,
+        options: anystr::StartsEndsWithArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        let (affix, substr) =
+            match options.prepare(self.as_wtf8(), self.len(), |s, r| s.get_chars(r)) {
+                Some(x) => x,
+                None => return Ok(false),
+            };
+        substr.py_starts_ends_with(
+            &affix,
+            "startswith",
+            "str",
+            |s, x: &Py<Self>| s.starts_with(x.as_wtf8()),
+            vm,
+        )
+    }
+
+    #[pymethod]
+    fn removeprefix(&self, pref: PyStrRef) -> Wtf8Buf {
+        self.as_wtf8()
+            .py_removeprefix(pref.as_wtf8(), pref.byte_len(), |s, p| s.starts_with(p))
+            .to_owned()
+    }
+
+    #[pymethod]
+    fn removesuffix(&self, suffix: PyStrRef) -> Wtf8Buf {
+        self.as_wtf8()
+            .py_removesuffix(suffix.as_wtf8(), suffix.byte_len(), |s, p| s.ends_with(p))
+            .to_owned()
+    }
+
+    #[pymethod]
+    fn isalnum(&self) -> bool {
+        !self.data.is_empty() && self.char_all(char::is_alphanumeric)
+    }
+
+    #[pymethod]
+    fn isnumeric(&self) -> bool {
+        !self.data.is_empty() && self.char_all(char::is_numeric)
+    }
+
+    #[pymethod]
+    fn isdigit(&self) -> bool {
+        // python's isdigit also checks if exponents are digits, these are the unicode codepoints for exponents
+        !self.data.is_empty()
+            && self.char_all(|c| {
+                c.is_ascii_digit()
+                    || matches!(c, '⁰' | '¹' | '²' | '³' | '⁴' | '⁵' | '⁶' | '⁷' | '⁸' | '⁹')
+            })
+    }
+
+    #[pymethod]
+    fn isdecimal(&self) -> bool {
+        !self.data.is_empty()
+            && self.char_all(|c| GeneralCategory::of(c) == GeneralCategory::DecimalNumber)
+    }
+
+    fn __mod__(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        cformat_string(vm, self.as_wtf8(), values)
+    }
+
+    #[pymethod]
+    fn format(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        let format_str =
+            FormatString::from_str(self.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
+        format(&format_str, &args, vm)
+    }
+
+    #[pymethod]
+    fn format_map(&self, mapping: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
+        let format_string =
+            FormatString::from_str(self.as_wtf8()).map_err(|err| err.to_pyexception(vm))?;
+        format_map(&format_string, &mapping, vm)
+    }
+
+    #[pymethod]
+    fn __format__(
+        zelf: PyRef<PyStr>,
+        spec: PyStrRef,
+        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)
+            } else {
+                zelf.as_object().str(vm)
+            };
+        }
+        let zelf = zelf.try_into_utf8(vm)?;
+        let s = FormatSpec::parse(spec)
+            .and_then(|format_spec| {
+                format_spec.format_string(&CharLenStr(zelf.as_str(), zelf.char_len()))
+            })
+            .map_err(|err| err.into_pyexception(vm))?;
+        Ok(vm.ctx.new_str(s))
+    }
+
+    #[pymethod]
+    fn title(&self) -> Wtf8Buf {
+        let mut title = Wtf8Buf::with_capacity(self.data.len());
+        let mut previous_is_cased = false;
+        for c_orig in self.as_wtf8().code_points() {
+            let c = c_orig.to_char_lossy();
+            if c.is_lowercase() {
+                if !previous_is_cased {
+                    title.extend(c.to_titlecase());
+                } else {
+                    title.push_char(c);
+                }
+                previous_is_cased = true;
+            } else if c.is_uppercase() || c.is_titlecase() {
+                if previous_is_cased {
+                    title.extend(c.to_lowercase());
+                } else {
+                    title.push_char(c);
+                }
+                previous_is_cased = true;
+            } else {
+                previous_is_cased = false;
+                title.push(c_orig);
+            }
+        }
+        title
+    }
+
+    #[pymethod]
+    fn swapcase(&self) -> Wtf8Buf {
+        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
+            if c.is_lowercase() {
+                swapped_str.push_char(c.to_ascii_uppercase());
+            } else if c.is_uppercase() {
+                swapped_str.push_char(c.to_ascii_lowercase());
+            } else {
+                swapped_str.push(c_orig);
+            }
+        }
+        swapped_str
+    }
+
+    #[pymethod]
+    fn isalpha(&self) -> bool {
+        !self.data.is_empty() && self.char_all(char::is_alphabetic)
+    }
+
+    #[pymethod]
+    fn replace(&self, args: ReplaceArgs) -> Wtf8Buf {
+        use core::cmp::Ordering;
+
+        let s = self.as_wtf8();
+        let ReplaceArgs { old, new, count } = args;
+
+        match count.cmp(&0) {
+            Ordering::Less => s.replace(old.as_wtf8(), new.as_wtf8()),
+            Ordering::Equal => s.to_owned(),
+            Ordering::Greater => {
+                let s_is_empty = s.is_empty();
+                let old_is_empty = old.is_empty();
+
+                if s_is_empty && !old_is_empty {
+                    s.to_owned()
+                } else if s_is_empty && old_is_empty {
+                    new.as_wtf8().to_owned()
+                } else {
+                    s.replacen(old.as_wtf8(), new.as_wtf8(), count as usize)
+                }
+            }
+        }
+    }
+
+    #[pymethod]
+    fn isprintable(&self) -> bool {
+        self.char_all(|c| c == '\u{0020}' || rustpython_literal::char::is_printable(c))
+    }
+
+    #[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)
+            })
+    }
+
+    // Return true if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.
+    #[pymethod]
+    fn islower(&self) -> bool {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s.py_islower(),
+            PyKindStr::Utf8(s) => s.py_islower(),
+            PyKindStr::Wtf8(w) => w.py_islower(),
+        }
+    }
+
+    // Return true if all cased characters in the string are uppercase and there is at least one cased character, false otherwise.
+    #[pymethod]
+    fn isupper(&self) -> bool {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s.py_isupper(),
+            PyKindStr::Utf8(s) => s.py_isupper(),
+            PyKindStr::Wtf8(w) => w.py_isupper(),
+        }
+    }
+
+    #[pymethod]
+    fn splitlines(&self, args: anystr::SplitLinesArgs, vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        let into_wrapper = |s: &Wtf8| self.new_substr(s.to_owned()).to_pyobject(vm);
+        let mut elements = Vec::new();
+        let mut last_i = 0;
+        let self_str = self.as_wtf8();
+        let mut enumerated = self_str.code_point_indices().peekable();
+        while let Some((i, ch)) = enumerated.next() {
+            let end_len = match ch.to_char_lossy() {
+                '\n' => 1,
+                '\r' => {
+                    let is_rn = enumerated.next_if(|(_, ch)| *ch == '\n').is_some();
+                    if is_rn { 2 } else { 1 }
+                }
+                '\x0b' | '\x0c' | '\x1c' | '\x1d' | '\x1e' | '\u{0085}' | '\u{2028}'
+                | '\u{2029}' => ch.len_wtf8(),
+                _ => continue,
+            };
+            let range = if args.keepends {
+                last_i..i + end_len
+            } else {
+                last_i..i
+            };
+            last_i = i + end_len;
+            elements.push(into_wrapper(&self_str[range]));
+        }
+        if last_i != self_str.len() {
+            elements.push(into_wrapper(&self_str[last_i..]));
+        }
+        elements
+    }
+
+    #[pymethod]
+    fn join(
+        zelf: PyRef<Self>,
+        iterable: ArgIterable<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyStrRef> {
+        let iter = iterable.iter(vm)?;
+        let joined = match iter.exactly_one() {
+            Ok(first) => {
+                let first = first?;
+                if first.as_object().class().is(vm.ctx.types.str_type) {
+                    return Ok(first);
+                } else {
+                    first.as_wtf8().to_owned()
+                }
+            }
+            Err(iter) => zelf.as_wtf8().py_join(iter)?,
+        };
+        Ok(vm.ctx.new_str(joined))
+    }
+
+    // FIXME: two traversals of str is expensive
+    #[inline]
+    fn _to_char_idx(r: &Wtf8, byte_idx: usize) -> usize {
+        r[..byte_idx].code_points().count()
+    }
+
+    #[inline]
+    fn _find<F>(&self, args: FindArgs, find: F) -> Option<usize>
+    where
+        F: Fn(&Wtf8, &Wtf8) -> Option<usize>,
+    {
+        let (sub, range) = args.get_value(self.len());
+        self.as_wtf8().py_find(sub.as_wtf8(), range, find)
+    }
+
+    #[pymethod]
+    fn find(&self, args: FindArgs) -> isize {
+        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.find(s)?)))
+            .map_or(-1, |v| v as isize)
+    }
+
+    #[pymethod]
+    fn rfind(&self, args: FindArgs) -> isize {
+        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.rfind(s)?)))
+            .map_or(-1, |v| v as isize)
+    }
+
+    #[pymethod]
+    fn index(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult<usize> {
+        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.find(s)?)))
+            .ok_or_else(|| vm.new_value_error("substring not found"))
+    }
+
+    #[pymethod]
+    fn rindex(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult<usize> {
+        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.rfind(s)?)))
+            .ok_or_else(|| vm.new_value_error("substring not found"))
+    }
+
+    #[pymethod]
+    fn partition(&self, sep: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        let (front, has_mid, back) = self.as_wtf8().py_partition(
+            sep.as_wtf8(),
+            || self.as_wtf8().splitn(2, sep.as_wtf8()),
+            vm,
+        )?;
+        let partition = (
+            self.new_substr(front),
+            if has_mid {
+                sep
+            } else {
+                vm.ctx.new_str(ascii!(""))
+            },
+            self.new_substr(back),
+        );
+        Ok(partition.to_pyobject(vm))
+    }
+
+    #[pymethod]
+    fn rpartition(&self, sep: PyStrRef, vm: &VirtualMachine) -> PyResult {
+        let (back, has_mid, front) = self.as_wtf8().py_partition(
+            sep.as_wtf8(),
+            || self.as_wtf8().rsplitn(2, sep.as_wtf8()),
+            vm,
+        )?;
+        Ok((
+            self.new_substr(front),
+            if has_mid {
+                sep
+            } else {
+                vm.ctx.empty_str.to_owned()
+            },
+            self.new_substr(back),
+        )
+            .to_pyobject(vm))
+    }
+
+    #[pymethod]
+    fn istitle(&self) -> bool {
+        if self.data.is_empty() {
+            return false;
+        }
+
+        let mut cased = false;
+        let mut previous_is_cased = false;
+        for c in self.as_wtf8().code_points().map(CodePoint::to_char_lossy) {
+            if c.is_uppercase() || c.is_titlecase() {
+                if previous_is_cased {
+                    return false;
+                }
+                previous_is_cased = true;
+                cased = true;
+            } else if c.is_lowercase() {
+                if !previous_is_cased {
+                    return false;
+                }
+                previous_is_cased = true;
+                cased = true;
+            } else {
+                previous_is_cased = false;
+            }
+        }
+        cased
+    }
+
+    #[pymethod]
+    fn count(&self, args: FindArgs) -> usize {
+        let (needle, range) = args.get_value(self.len());
+        self.as_wtf8()
+            .py_count(needle.as_wtf8(), range, |h, n| h.find_iter(n).count())
+    }
+
+    #[pymethod]
+    fn zfill(&self, width: isize) -> Wtf8Buf {
+        unsafe {
+            // SAFETY: this is safe-guaranteed because the original self.as_wtf8() is valid wtf8
+            Wtf8Buf::from_bytes_unchecked(self.as_wtf8().py_zfill(width))
+        }
+    }
+
+    #[inline]
+    fn _pad(
+        &self,
+        width: isize,
+        fillchar: OptionalArg<PyStrRef>,
+        pad: fn(&Wtf8, usize, CodePoint, usize) -> Wtf8Buf,
+        vm: &VirtualMachine,
+    ) -> PyResult<Wtf8Buf> {
+        let fillchar = fillchar.map_or(Ok(' '.into()), |ref s| {
+            s.as_wtf8().code_points().exactly_one().map_err(|_| {
+                vm.new_type_error("The fill character must be exactly one character long")
+            })
+        })?;
+        Ok(if self.len() as isize >= width {
+            self.as_wtf8().to_owned()
+        } else {
+            pad(self.as_wtf8(), width as usize, fillchar, self.len())
+        })
+    }
+
+    #[pymethod]
+    fn center(
+        &self,
+        width: isize,
+        fillchar: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Wtf8Buf> {
+        self._pad(width, fillchar, AnyStr::py_center, vm)
+    }
+
+    #[pymethod]
+    fn ljust(
+        &self,
+        width: isize,
+        fillchar: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Wtf8Buf> {
+        self._pad(width, fillchar, AnyStr::py_ljust, vm)
+    }
+
+    #[pymethod]
+    fn rjust(
+        &self,
+        width: isize,
+        fillchar: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Wtf8Buf> {
+        self._pad(width, fillchar, AnyStr::py_rjust, vm)
+    }
+
+    #[pymethod]
+    fn expandtabs(&self, args: anystr::ExpandTabsArgs, vm: &VirtualMachine) -> PyResult<String> {
+        // TODO: support WTF-8
+        Ok(rustpython_common::str::expandtabs(
+            self.try_as_utf8(vm)?.as_str(),
+            args.tabsize(),
+        ))
+    }
+
+    #[pymethod]
+    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));
+        // a string is not an identifier if it has whitespace or starts with a number
+        is_identifier_start && chars.all(is_xid_continue)
+    }
+
+    // https://docs.python.org/3/library/stdtypes.html#str.translate
+    #[pymethod]
+    fn translate(&self, table: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+        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) {
+                Ok(value) => {
+                    if let Some(text) = value.downcast_ref::<Self>() {
+                        translated.push_str(text.as_str());
+                    } else if let Some(bigint) = value.downcast_ref::<PyInt>() {
+                        let ch = bigint
+                            .as_bigint()
+                            .to_u32()
+                            .and_then(core::char::from_u32)
+                            .ok_or_else(|| {
+                                vm.new_value_error("character mapping must be in range(0x110000)")
+                            })?;
+                        translated.push(ch);
+                    } else if !vm.is_none(&value) {
+                        return Err(
+                            vm.new_type_error("character mapping must return integer, None or str")
+                        );
+                    }
+                }
+                _ => translated.push(c),
+            }
+        }
+        Ok(translated)
+    }
+
+    #[pystaticmethod]
+    fn maketrans(
+        dict_or_str: PyObjectRef,
+        to_str: OptionalArg<PyStrRef>,
+        none_str: OptionalArg<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let new_dict = vm.ctx.new_dict();
+        if let OptionalArg::Present(to_str) = to_str {
+            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()) {
+                            new_dict.set_item(
+                                &*vm.new_pyobj(c1 as u32),
+                                vm.new_pyobj(c2 as 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)?;
+                            }
+                        }
+                        Ok(new_dict.to_pyobject(vm))
+                    } else {
+                        Err(vm.new_value_error(
+                            "the first two maketrans arguments must have equal length",
+                        ))
+                    }
+                }
+                _ => Err(vm.new_type_error(
+                    "first maketrans argument must be a string if there is a second argument",
+                )),
+            }
+        } else {
+            // dict_str must be a dict
+            match dict_or_str.downcast::<PyDict>() {
+                Ok(dict) => {
+                    for (key, val) in dict {
+                        // FIXME: ints are key-compatible
+                        if let Some(num) = key.downcast_ref::<PyInt>() {
+                            new_dict.set_item(
+                                &*num.as_bigint().to_i32().to_pyobject(vm),
+                                val,
+                                vm,
+                            )?;
+                        } else if let Some(string) = key.downcast_ref::<Self>() {
+                            if string.len() == 1 {
+                                let num_value = string.as_str().chars().next().unwrap() as u32;
+                                new_dict.set_item(&*num_value.to_pyobject(vm), val, vm)?;
+                            } else {
+                                return Err(vm.new_value_error(
+                                    "string keys in translate table must be of length 1",
+                                ));
+                            }
+                        } else {
+                            return Err(vm.new_type_error(
+                                "keys in translate table must be strings or integers",
+                            ));
+                        }
+                    }
+                    Ok(new_dict.to_pyobject(vm))
+                }
+                _ => Err(vm.new_value_error(
+                    "if you give only one argument to maketrans it must be a dict",
+                )),
+            }
+        }
+    }
+
+    #[pymethod]
+    fn encode(zelf: PyRef<Self>, args: EncodeArgs, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
+        encode_string(zelf, args.encoding, args.errors, vm)
+    }
+
+    #[pymethod]
+    fn __getnewargs__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
+        (zelf.as_str(),).to_pyobject(vm)
+    }
+
+    #[pymethod]
+    fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        if zelf.class().is(vm.ctx.types.str_type) {
+            // Already exact str, just return a reference
+            Ok(zelf.to_owned())
+        } else {
+            // Subclass, create a new exact str
+            Ok(PyStr::from(zelf.data.clone()).into_ref(&vm.ctx))
+        }
+    }
+}
+
+impl PyRef<PyStr> {
+    pub fn is_empty(&self) -> bool {
+        (**self).is_empty()
+    }
+
+    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);
+    }
+
+    pub fn try_into_utf8(self, vm: &VirtualMachine) -> PyResult<PyRef<PyUtf8Str>> {
+        self.ensure_valid_utf8(vm)?;
+        Ok(unsafe { mem::transmute::<Self, PyRef<PyUtf8Str>>(self) })
+    }
+}
+
+struct CharLenStr<'a>(&'a str, usize);
+impl core::ops::Deref for CharLenStr<'_> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+impl crate::common::format::CharLen for CharLenStr<'_> {
+    fn char_len(&self) -> usize {
+        self.1
+    }
+}
+
+impl Representable for PyStr {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        zelf.repr(vm)
+    }
+}
+
+impl Hashable for PyStr {
+    #[inline]
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        Ok(zelf.hash(vm))
+    }
+}
+
+impl Comparable for PyStr {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        _vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        if let Some(res) = op.identical_optimization(zelf, other) {
+            return Ok(res.into());
+        }
+        let other = class_or_notimplemented!(Self, other);
+        Ok(op.eval_ord(zelf.as_wtf8().cmp(other.as_wtf8())).into())
+    }
+}
+
+impl Iterable for PyStr {
+    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+        Ok(PyStrIterator {
+            internal: PyMutex::new((PositionIterInternal::new(zelf, 0), 0)),
+        }
+        .into_pyobject(vm))
+    }
+}
+
+impl AsMapping for PyStr {
+    fn as_mapping() -> &'static PyMappingMethods {
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            length: atomic_func!(|mapping, _vm| Ok(PyStr::mapping_downcast(mapping).len())),
+            subscript: atomic_func!(
+                |mapping, needle, vm| PyStr::mapping_downcast(mapping)._getitem(needle, vm)
+            ),
+            ..PyMappingMethods::NOT_IMPLEMENTED
+        });
+        &AS_MAPPING
+    }
+}
+
+impl AsNumber for PyStr {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            remainder: Some(|a, b, vm| {
+                if let Some(a) = a.downcast_ref::<PyStr>() {
+                    a.__mod__(b.to_owned(), vm).to_pyresult(vm)
+                } else {
+                    Ok(vm.ctx.not_implemented())
+                }
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl AsSequence for PyStr {
+    fn as_sequence() -> &'static PySequenceMethods {
+        static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            length: atomic_func!(|seq, _vm| Ok(PyStr::sequence_downcast(seq).len())),
+            concat: atomic_func!(|seq, other, vm| {
+                let zelf = PyStr::sequence_downcast(seq);
+                PyStr::__add__(zelf.to_owned(), other.to_owned(), vm)
+            }),
+            repeat: atomic_func!(|seq, n, vm| {
+                let zelf = PyStr::sequence_downcast(seq);
+                PyStr::repeat(zelf.to_owned(), n, vm).map(|x| x.into())
+            }),
+            item: atomic_func!(|seq, i, vm| {
+                let zelf = PyStr::sequence_downcast(seq);
+                zelf.getitem_by_index(vm, i).to_pyresult(vm)
+            }),
+            contains: atomic_func!(
+                |seq, needle, vm| PyStr::sequence_downcast(seq)._contains(needle, vm)
+            ),
+            ..PySequenceMethods::NOT_IMPLEMENTED
+        });
+        &AS_SEQUENCE
+    }
+}
+
+#[derive(FromArgs)]
+struct EncodeArgs {
+    #[pyarg(any, default)]
+    encoding: Option<PyStrRef>,
+    #[pyarg(any, default)]
+    errors: Option<PyStrRef>,
+}
+
+pub(crate) fn encode_string(
+    s: PyStrRef,
+    encoding: Option<PyStrRef>,
+    errors: Option<PyStrRef>,
+    vm: &VirtualMachine,
+) -> PyResult<PyBytesRef> {
+    let encoding = encoding
+        .as_ref()
+        .map_or(crate::codecs::DEFAULT_ENCODING, |s| s.as_str());
+    vm.state.codec_registry.encode_text(s, encoding, errors, vm)
+}
+
+impl PyPayload for PyStr {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.str_type
+    }
+}
+
+impl ToPyObject for String {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for Wtf8Buf {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for char {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for CodePoint {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for &str {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for &String {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self.clone()).into()
+    }
+}
+
+impl ToPyObject for &Wtf8 {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for &Wtf8Buf {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self.clone()).into()
+    }
+}
+
+impl ToPyObject for &AsciiStr {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for AsciiString {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+impl ToPyObject for AsciiChar {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.new_str(self).into()
+    }
+}
+
+type SplitArgs = anystr::SplitArgs<PyStrRef>;
+
+#[derive(FromArgs)]
+pub struct FindArgs {
+    #[pyarg(positional)]
+    sub: PyStrRef,
+    #[pyarg(positional, default)]
+    start: Option<PyIntRef>,
+    #[pyarg(positional, default)]
+    end: Option<PyIntRef>,
+}
+
+impl FindArgs {
+    fn get_value(self, len: usize) -> (PyStrRef, core::ops::Range<usize>) {
+        let range = adjust_indices(self.start, self.end, len);
+        (self.sub, range)
+    }
+}
+
+#[derive(FromArgs)]
+struct ReplaceArgs {
+    #[pyarg(positional)]
+    old: PyStrRef,
+
+    #[pyarg(positional)]
+    new: PyStrRef,
+
+    #[pyarg(any, default = -1)]
+    count: isize,
+}
+
+pub fn init(ctx: &Context) {
+    PyStr::extend_class(ctx, ctx.types.str_type);
+
+    PyStrIterator::extend_class(ctx, ctx.types.str_iterator_type);
+}
+
+impl SliceableSequenceOp for PyStr {
+    type Item = CodePoint;
+    type Sliced = Self;
+
+    fn do_get(&self, index: usize) -> Self::Item {
+        self.data.nth_char(index)
+    }
+
+    fn do_slice(&self, range: Range<usize>) -> Self::Sliced {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s[range].into(),
+            PyKindStr::Utf8(s) => {
+                let char_len = range.len();
+                let out = rustpython_common::str::get_chars(s, range);
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+            PyKindStr::Wtf8(w) => {
+                let char_len = range.len();
+                let out = rustpython_common::str::get_codepoints(w, range);
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+        }
+    }
+
+    fn do_slice_reverse(&self, range: Range<usize>) -> Self::Sliced {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => {
+                let mut out = s[range].to_owned();
+                out.as_mut_slice().reverse();
+                out.into()
+            }
+            PyKindStr::Utf8(s) => {
+                let char_len = range.len();
+                let mut out = String::with_capacity(2 * char_len);
+                out.extend(
+                    s.chars()
+                        .rev()
+                        .skip(self.char_len() - range.end)
+                        .take(range.len()),
+                );
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, range.len()) }
+            }
+            PyKindStr::Wtf8(w) => {
+                let char_len = range.len();
+                let mut out = Wtf8Buf::with_capacity(2 * char_len);
+                out.extend(
+                    w.code_points()
+                        .rev()
+                        .skip(self.char_len() - range.end)
+                        .take(range.len()),
+                );
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+        }
+    }
+
+    fn do_stepped_slice(&self, range: Range<usize>, step: usize) -> Self::Sliced {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s[range]
+                .as_slice()
+                .iter()
+                .copied()
+                .step_by(step)
+                .collect::<AsciiString>()
+                .into(),
+            PyKindStr::Utf8(s) => {
+                let char_len = (range.len() / step) + 1;
+                let mut out = String::with_capacity(2 * char_len);
+                out.extend(s.chars().skip(range.start).take(range.len()).step_by(step));
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+            PyKindStr::Wtf8(w) => {
+                let char_len = (range.len() / step) + 1;
+                let mut out = Wtf8Buf::with_capacity(2 * char_len);
+                out.extend(
+                    w.code_points()
+                        .skip(range.start)
+                        .take(range.len())
+                        .step_by(step),
+                );
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+        }
+    }
+
+    fn do_stepped_slice_reverse(&self, range: Range<usize>, step: usize) -> Self::Sliced {
+        match self.as_str_kind() {
+            PyKindStr::Ascii(s) => s[range]
+                .chars()
+                .rev()
+                .step_by(step)
+                .collect::<AsciiString>()
+                .into(),
+            PyKindStr::Utf8(s) => {
+                let char_len = (range.len() / step) + 1;
+                // not ascii, so the codepoints have to be at least 2 bytes each
+                let mut out = String::with_capacity(2 * char_len);
+                out.extend(
+                    s.chars()
+                        .rev()
+                        .skip(self.char_len() - range.end)
+                        .take(range.len())
+                        .step_by(step),
+                );
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+            PyKindStr::Wtf8(w) => {
+                let char_len = (range.len() / step) + 1;
+                // not ascii, so the codepoints have to be at least 2 bytes each
+                let mut out = Wtf8Buf::with_capacity(2 * char_len);
+                out.extend(
+                    w.code_points()
+                        .rev()
+                        .skip(self.char_len() - range.end)
+                        .take(range.len())
+                        .step_by(step),
+                );
+                // SAFETY: char_len is accurate
+                unsafe { Self::new_with_char_len(out, char_len) }
+            }
+        }
+    }
+
+    fn empty() -> Self::Sliced {
+        Self::default()
+    }
+
+    fn len(&self) -> usize {
+        self.char_len()
+    }
+}
+
+impl AsRef<str> for PyRefExact<PyStr> {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<str> for PyExact<PyStr> {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsRef<Wtf8> for PyRefExact<PyStr> {
+    fn as_ref(&self) -> &Wtf8 {
+        self.as_wtf8()
+    }
+}
+
+impl AsRef<Wtf8> for PyExact<PyStr> {
+    fn as_ref(&self) -> &Wtf8 {
+        self.as_wtf8()
+    }
+}
+
+impl AnyStrWrapper<Wtf8> for PyStrRef {
+    fn as_ref(&self) -> Option<&Wtf8> {
+        Some(self.as_wtf8())
+    }
+
+    fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}
+
+impl AnyStrWrapper<str> for PyStrRef {
+    fn as_ref(&self) -> Option<&str> {
+        self.data.as_str()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}
+
+impl AnyStrWrapper<AsciiStr> for PyStrRef {
+    fn as_ref(&self) -> Option<&AsciiStr> {
+        self.data.as_ascii()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}
+
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct PyUtf8Str(PyStr);
+
+impl fmt::Display for PyUtf8Str {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl MaybeTraverse for PyUtf8Str {
+    fn try_traverse(&self, traverse_fn: &mut TraverseFn<'_>) {
+        self.0.try_traverse(traverse_fn);
+    }
+}
+
+impl PyPayload for PyUtf8Str {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.str_type
+    }
+
+    const PAYLOAD_TYPE_ID: core::any::TypeId = core::any::TypeId::of::<PyStr>();
+
+    fn validate_downcastable_from(obj: &PyObject) -> bool {
+        // SAFETY: we know the object is a PyStr in this context
+        let wtf8 = unsafe { obj.downcast_unchecked_ref::<PyStr>() };
+        wtf8.is_utf8()
+    }
+
+    fn try_downcast_from(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+        let str = obj.try_downcast_ref::<PyStr>(vm)?;
+        str.ensure_valid_utf8(vm)
+    }
+}
+
+impl<'a> From<&'a AsciiStr> for PyUtf8Str {
+    fn from(s: &'a AsciiStr) -> Self {
+        s.to_owned().into()
+    }
+}
+
+impl From<AsciiString> for PyUtf8Str {
+    fn from(s: AsciiString) -> Self {
+        s.into_boxed_ascii_str().into()
+    }
+}
+
+impl From<Box<AsciiStr>> for PyUtf8Str {
+    fn from(s: Box<AsciiStr>) -> Self {
+        let data = StrData::from(s);
+        unsafe { Self::from_str_data_unchecked(data) }
+    }
+}
+
+impl From<AsciiChar> for PyUtf8Str {
+    fn from(ch: AsciiChar) -> Self {
+        AsciiString::from(ch).into()
+    }
+}
+
+impl<'a> From<&'a str> for PyUtf8Str {
+    fn from(s: &'a str) -> Self {
+        s.to_owned().into()
+    }
+}
+
+impl From<String> for PyUtf8Str {
+    fn from(s: String) -> Self {
+        s.into_boxed_str().into()
+    }
+}
+
+impl From<char> for PyUtf8Str {
+    fn from(ch: char) -> Self {
+        let data = StrData::from(ch);
+        unsafe { Self::from_str_data_unchecked(data) }
+    }
+}
+
+impl<'a> From<alloc::borrow::Cow<'a, str>> for PyUtf8Str {
+    fn from(s: alloc::borrow::Cow<'a, str>) -> Self {
+        s.into_owned().into()
+    }
+}
+
+impl From<Box<str>> for PyUtf8Str {
+    #[inline]
+    fn from(value: Box<str>) -> Self {
+        let data = StrData::from(value);
+        unsafe { Self::from_str_data_unchecked(data) }
+    }
+}
+
+impl AsRef<Wtf8> for PyUtf8Str {
+    #[inline]
+    fn as_ref(&self) -> &Wtf8 {
+        self.0.as_wtf8()
+    }
+}
+
+impl AsRef<str> for PyUtf8Str {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
+impl PyUtf8Str {
+    // Create a new `PyUtf8Str` from `StrData` without validation.
+    // This function must be only used in this module to create conversions.
+    // # Safety: must be called with a valid UTF-8 string data.
+    unsafe fn from_str_data_unchecked(data: StrData) -> Self {
+        Self(PyStr::from(data))
+    }
+
+    /// Returns the underlying string slice.
+    pub fn as_str(&self) -> &str {
+        debug_assert!(
+            self.0.is_utf8(),
+            "PyUtf8Str invariant violated: inner string is not valid UTF-8"
+        );
+        // Safety: This is safe because the type invariant guarantees UTF-8 validity.
+        unsafe { self.0.to_str().unwrap_unchecked() }
+    }
+
+    #[inline]
+    pub fn byte_len(&self) -> usize {
+        self.0.byte_len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    #[inline]
+    pub fn char_len(&self) -> usize {
+        self.0.char_len()
+    }
+}
+
+impl Py<PyUtf8Str> {
+    /// Upcast to PyStr.
+    pub fn as_pystr(&self) -> &Py<PyStr> {
+        unsafe {
+            // Safety: PyUtf8Str is a wrapper around PyStr, so this cast is safe.
+            &*(self as *const Self as *const Py<PyStr>)
+        }
+    }
+}
+
+impl PartialEq for PyUtf8Str {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+impl Eq for PyUtf8Str {}
+
+impl AnyStrContainer<str> for String {
+    fn new() -> Self {
+        Self::new()
+    }
+
+    fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity(capacity)
+    }
+
+    fn push_str(&mut self, other: &str) {
+        Self::push_str(self, other)
+    }
+}
+
+impl anystr::AnyChar for char {
+    fn is_lowercase(self) -> bool {
+        self.is_lowercase()
+    }
+
+    fn is_uppercase(self) -> bool {
+        self.is_uppercase()
+    }
+
+    fn bytes_len(self) -> usize {
+        self.len_utf8()
+    }
+}
+
+impl AnyStr for str {
+    type Char = char;
+    type Container = String;
+
+    fn to_container(&self) -> Self::Container {
+        self.to_owned()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        self.as_bytes()
+    }
+
+    fn elements(&self) -> impl Iterator<Item = char> {
+        Self::chars(self)
+    }
+
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
+        &self[range]
+    }
+
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
+        rustpython_common::str::get_chars(self, range)
+    }
+
+    fn is_empty(&self) -> bool {
+        Self::is_empty(self)
+    }
+
+    fn bytes_len(&self) -> usize {
+        Self::len(self)
+    }
+
+    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        // CPython split_whitespace
+        let mut splits = Vec::new();
+        let mut last_offset = 0;
+        let mut count = maxsplit;
+        for (offset, _) in self.match_indices(|c: char| c.is_ascii_whitespace() || c == '\x0b') {
+            if last_offset == offset {
+                last_offset += 1;
+                continue;
+            }
+            if count == 0 {
+                break;
+            }
+            splits.push(convert(&self[last_offset..offset]));
+            last_offset = offset + 1;
+            count -= 1;
+        }
+        if last_offset != self.len() {
+            splits.push(convert(&self[last_offset..]));
+        }
+        splits
+    }
+
+    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        // CPython rsplit_whitespace
+        let mut splits = Vec::new();
+        let mut last_offset = self.len();
+        let mut count = maxsplit;
+        for (offset, _) in self.rmatch_indices(|c: char| c.is_ascii_whitespace() || c == '\x0b') {
+            if last_offset == offset + 1 {
+                last_offset -= 1;
+                continue;
+            }
+            if count == 0 {
+                break;
+            }
+            splits.push(convert(&self[offset + 1..last_offset]));
+            last_offset = offset;
+            count -= 1;
+        }
+        if last_offset != 0 {
+            splits.push(convert(&self[..last_offset]));
+        }
+        splits
+    }
+}
+
+impl AnyStrContainer<Wtf8> for Wtf8Buf {
+    fn new() -> Self {
+        Self::new()
+    }
+
+    fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity(capacity)
+    }
+
+    fn push_str(&mut self, other: &Wtf8) {
+        self.push_wtf8(other)
+    }
+}
+
+impl anystr::AnyChar for CodePoint {
+    fn is_lowercase(self) -> bool {
+        self.is_char_and(char::is_lowercase)
+    }
+    fn is_uppercase(self) -> bool {
+        self.is_char_and(char::is_uppercase)
+    }
+    fn bytes_len(self) -> usize {
+        self.len_wtf8()
+    }
+}
+
+impl AnyStr for Wtf8 {
+    type Char = CodePoint;
+    type Container = Wtf8Buf;
+
+    fn to_container(&self) -> Self::Container {
+        self.to_owned()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        self.as_bytes()
+    }
+
+    fn elements(&self) -> impl Iterator<Item = Self::Char> {
+        self.code_points()
+    }
+
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
+        &self[range]
+    }
+
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
+        rustpython_common::str::get_codepoints(self, range)
+    }
+
+    fn bytes_len(&self) -> usize {
+        self.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
+
+    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        // CPython split_whitespace
+        let mut splits = Vec::new();
+        let mut last_offset = 0;
+        let mut count = maxsplit;
+        for (offset, _) in self
+            .code_point_indices()
+            .filter(|(_, c)| c.is_char_and(|c| c.is_ascii_whitespace() || c == '\x0b'))
+        {
+            if last_offset == offset {
+                last_offset += 1;
+                continue;
+            }
+            if count == 0 {
+                break;
+            }
+            splits.push(convert(&self[last_offset..offset]));
+            last_offset = offset + 1;
+            count -= 1;
+        }
+        if last_offset != self.len() {
+            splits.push(convert(&self[last_offset..]));
+        }
+        splits
+    }
+
+    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        // CPython rsplit_whitespace
+        let mut splits = Vec::new();
+        let mut last_offset = self.len();
+        let mut count = maxsplit;
+        for (offset, _) in self
+            .code_point_indices()
+            .rev()
+            .filter(|(_, c)| c.is_char_and(|c| c.is_ascii_whitespace() || c == '\x0b'))
+        {
+            if last_offset == offset + 1 {
+                last_offset -= 1;
+                continue;
+            }
+            if count == 0 {
+                break;
+            }
+            splits.push(convert(&self[offset + 1..last_offset]));
+            last_offset = offset;
+            count -= 1;
+        }
+        if last_offset != 0 {
+            splits.push(convert(&self[..last_offset]));
+        }
+        splits
+    }
+}
+
+impl AnyStrContainer<AsciiStr> for AsciiString {
+    fn new() -> Self {
+        Self::new()
+    }
+
+    fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity(capacity)
+    }
+
+    fn push_str(&mut self, other: &AsciiStr) {
+        Self::push_str(self, other)
+    }
+}
+
+impl anystr::AnyChar for ascii::AsciiChar {
+    fn is_lowercase(self) -> bool {
+        self.is_lowercase()
+    }
+
+    fn is_uppercase(self) -> bool {
+        self.is_uppercase()
+    }
+
+    fn bytes_len(self) -> usize {
+        1
+    }
+}
+
+const ASCII_WHITESPACES: [u8; 6] = [0x20, 0x09, 0x0a, 0x0c, 0x0d, 0x0b];
+
+impl AnyStr for AsciiStr {
+    type Char = AsciiChar;
+    type Container = AsciiString;
+
+    fn to_container(&self) -> Self::Container {
+        self.to_ascii_string()
+    }
+
+    fn as_bytes(&self) -> &[u8] {
+        self.as_bytes()
+    }
+
+    fn elements(&self) -> impl Iterator<Item = Self::Char> {
+        self.chars()
+    }
+
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
+        &self[range]
+    }
+
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
+        &self[range]
+    }
+
+    fn bytes_len(&self) -> usize {
+        self.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.is_empty()
+    }
+
+    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        let mut splits = Vec::new();
+        let mut count = maxsplit;
+        let mut haystack = self;
+        while let Some(offset) = haystack.as_bytes().find_byteset(ASCII_WHITESPACES) {
+            if offset != 0 {
+                if count == 0 {
+                    break;
+                }
+                splits.push(convert(&haystack[..offset]));
+                count -= 1;
+            }
+            haystack = &haystack[offset + 1..];
+        }
+        if !haystack.is_empty() {
+            splits.push(convert(haystack));
+        }
+        splits
+    }
+
+    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
+    where
+        F: Fn(&Self) -> PyObjectRef,
+    {
+        // CPython rsplit_whitespace
+        let mut splits = Vec::new();
+        let mut count = maxsplit;
+        let mut haystack = self;
+        while let Some(offset) = haystack.as_bytes().rfind_byteset(ASCII_WHITESPACES) {
+            if offset + 1 != haystack.len() {
+                if count == 0 {
+                    break;
+                }
+                splits.push(convert(&haystack[offset + 1..]));
+                count -= 1;
+            }
+            haystack = &haystack[..offset];
+        }
+        if !haystack.is_empty() {
+            splits.push(convert(haystack));
+        }
+        splits
+    }
+}
+
+/// The unique reference of interned PyStr
+/// Always intended to be used as a static reference
+pub type PyStrInterned = PyInterned<PyStr>;
+
+impl PyStrInterned {
+    #[inline]
+    pub fn to_exact(&'static self) -> PyRefExact<PyStr> {
+        unsafe { PyRefExact::new_unchecked(self.to_owned()) }
+    }
+}
+
+impl core::fmt::Display for PyStrInterned {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.data.fmt(f)
+    }
+}
+
+impl AsRef<str> for PyStrInterned {
+    #[inline(always)]
+    fn as_ref(&self) -> &str {
+        self.to_str()
+            .expect("Interned PyStr should always be valid UTF-8")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Interpreter;
+
+    #[test]
+    fn str_title() {
+        let tests = vec![
+            (" Hello ", " hello "),
+            ("Hello ", "hello "),
+            ("Hello ", "Hello "),
+            ("Format This As Title String", "fOrMaT thIs aS titLe String"),
+            ("Format,This-As*Title;String", "fOrMaT,thIs-aS*titLe;String"),
+            ("Getint", "getInt"),
+            // spell-checker:disable-next-line
+            ("Greek Ωppercases ...", "greek ωppercases ..."),
+            // spell-checker:disable-next-line
+            ("Greek ῼitlecases ...", "greek ῳitlecases ..."),
+        ];
+        for (title, input) in tests {
+            assert_eq!(PyStr::from(input).title().as_str(), Ok(title));
+        }
+    }
+
+    #[test]
+    fn str_istitle() {
+        let pos = vec![
+            "A",
+            "A Titlecased Line",
+            "A\nTitlecased Line",
+            "A Titlecased, Line",
+            // spell-checker:disable-next-line
+            "Greek Ωppercases ...",
+            // spell-checker:disable-next-line
+            "Greek ῼitlecases ...",
+        ];
+
+        for s in pos {
+            assert!(PyStr::from(s).istitle());
+        }
+
+        let neg = vec![
+            "",
+            "a",
+            "\n",
+            "Not a capitalized String",
+            "Not\ta Titlecase String",
+            "Not--a Titlecase String",
+            "NOT",
+        ];
+        for s in neg {
+            assert!(!PyStr::from(s).istitle());
+        }
+    }
+
+    #[test]
+    fn str_maketrans_and_translate() {
+        Interpreter::without_stdlib(Default::default()).enter(|vm| {
+            let table = vm.ctx.new_dict();
+            table
+                .set_item("a", vm.ctx.new_str("🎅").into(), vm)
+                .unwrap();
+            table.set_item("b", vm.ctx.none(), vm).unwrap();
+            table
+                .set_item("c", vm.ctx.new_str(ascii!("xda")).into(), vm)
+                .unwrap();
+            let translated =
+                PyStr::maketrans(table.into(), OptionalArg::Missing, OptionalArg::Missing, vm)
+                    .unwrap();
+            let text = PyStr::from("abc");
+            let translated = text.translate(translated, vm).unwrap();
+            assert_eq!(translated, "🎅xda".to_owned());
+            let translated = text.translate(vm.ctx.new_int(3).into(), vm);
+            assert_eq!("TypeError", &*translated.unwrap_err().class().name(),);
+        })
+    }
+}
diff --git a/vm/src/builtins/super.rs b/crates/vm/src/builtins/super.rs
similarity index 87%
rename from vm/src/builtins/super.rs
rename to crates/vm/src/builtins/super.rs
index 2d7e48447f..893509bc6d 100644
--- a/vm/src/builtins/super.rs
+++ b/crates/vm/src/builtins/super.rs
@@ -47,23 +47,21 @@ impl PyPayload for PySuper {
 impl Constructor for PySuper {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let obj = Self {
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self {
             inner: PyRwLock::new(PySuperInner::new(
                 vm.ctx.types.object_type.to_owned(), // is this correct?
                 vm.ctx.none(),
                 vm,
             )?),
-        }
-        .into_ref_with_type(vm, cls)?;
-        Ok(obj.into())
+        })
     }
 }
 
 #[derive(FromArgs)]
 pub struct InitArgs {
     #[pyarg(positional, optional)]
-    py_type: OptionalArg<PyTypeRef>,
+    py_type: OptionalArg<PyObjectRef>,
     #[pyarg(positional, optional)]
     py_obj: OptionalArg<PyObjectRef>,
 }
@@ -77,7 +75,10 @@ impl Initializer for PySuper {
         vm: &VirtualMachine,
     ) -> PyResult<()> {
         // Get the type:
-        let (typ, obj) = if let OptionalArg::Present(ty) = py_type {
+        let (typ, obj) = if let OptionalArg::Present(ty_obj) = py_type {
+            let ty = ty_obj
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("super() argument 1 must be a type"))?;
             (ty, py_obj.unwrap_or_none(vm))
         } else {
             let frame = vm
@@ -104,7 +105,7 @@ impl Initializer for PySuper {
 
             let mut typ = None;
             for (i, var) in frame.code.freevars.iter().enumerate() {
-                if var.as_str() == "__class__" {
+                if var.as_bytes() == b"__class__" {
                     let i = frame.code.cellvars.len() + i;
                     let class = frame.cells_frees[i]
                         .get()
@@ -162,7 +163,7 @@ impl GetAttr for PySuper {
         // We want __class__ to return the class of the super object
         // (i.e. super, or a subclass), not the class of su->obj.
 
-        if name.as_str() == "__class__" {
+        if name.as_bytes() == b"__class__" {
             return skip(zelf, name);
         }
 
@@ -174,7 +175,7 @@ impl GetAttr for PySuper {
                 .skip_while(|cls| !cls.is(&zelf.inner.read().typ))
                 .skip(1) // skip su->type (if any)
                 .collect();
-            for cls in mro.iter() {
+            for cls in &mro {
                 if let Some(descr) = cls.get_direct_attr(name) {
                     return vm
                         .call_get_descriptor_specific(
@@ -239,21 +240,35 @@ impl Representable for PySuper {
 }
 
 fn super_check(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyTypeRef> {
-    if let Ok(cls) = obj.clone().downcast::<PyType>() {
-        if cls.fast_issubclass(&ty) {
-            return Ok(cls);
-        }
-    }
+    let typ = match obj.clone().downcast::<PyType>() {
+        Ok(cls) if cls.fast_issubclass(&ty) => return Ok(cls),
+        Ok(cls) => Some(cls),
+        Err(_) => None,
+    };
+
     if obj.fast_isinstance(&ty) {
         return Ok(obj.class().to_owned());
     }
+
     let class_attr = obj.get_attr("__class__", vm)?;
-    if let Ok(cls) = class_attr.downcast::<PyType>() {
-        if !cls.is(&ty) && cls.fast_issubclass(&ty) {
-            return Ok(cls);
-        }
+    if let Ok(cls) = class_attr.downcast::<PyType>()
+        && !cls.is(&ty)
+        && cls.fast_issubclass(&ty)
+    {
+        return Ok(cls);
     }
-    Err(vm.new_type_error("super(type, obj): obj must be an instance or subtype of type"))
+
+    let (type_or_instance, obj_str) = match typ {
+        Some(t) => ("type", t.name().to_owned()),
+        None => ("instance of", obj.class().name().to_owned()),
+    };
+
+    Err(vm.new_type_error(format!(
+        "super(type, obj): obj ({} {}) is not an instance or subtype of type ({}).",
+        type_or_instance,
+        obj_str,
+        ty.name(),
+    )))
 }
 
 pub fn init(context: &Context) {
diff --git a/crates/vm/src/builtins/template.rs b/crates/vm/src/builtins/template.rs
new file mode 100644
index 0000000000..2433c9082e
--- /dev/null
+++ b/crates/vm/src/builtins/template.rs
@@ -0,0 +1,338 @@
+use super::{PyStr, PyTupleRef, PyType};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    atomic_func,
+    class::PyClassImpl,
+    function::{FuncArgs, PyComparisonValue},
+    protocol::{PyIterReturn, PySequenceMethods},
+    types::{
+        AsSequence, Comparable, Constructor, IterNext, Iterable, PyComparisonOp, Representable,
+        SelfIter,
+    },
+};
+use std::sync::LazyLock;
+
+use super::interpolation::PyInterpolation;
+
+/// Template object for t-strings (PEP 750).
+///
+/// Represents a template string with interpolated expressions.
+#[pyclass(module = "string.templatelib", name = "Template")]
+#[derive(Debug, Clone)]
+pub struct PyTemplate {
+    pub strings: PyTupleRef,
+    pub interpolations: PyTupleRef,
+}
+
+impl PyPayload for PyTemplate {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.template_type
+    }
+}
+
+impl PyTemplate {
+    pub fn new(strings: PyTupleRef, interpolations: PyTupleRef) -> Self {
+        Self {
+            strings,
+            interpolations,
+        }
+    }
+}
+
+impl Constructor for PyTemplate {
+    type Args = FuncArgs;
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        if !args.kwargs.is_empty() {
+            return Err(vm.new_type_error("Template.__new__ only accepts *args arguments"));
+        }
+
+        let mut strings: Vec<PyObjectRef> = Vec::new();
+        let mut interpolations: Vec<PyObjectRef> = Vec::new();
+        let mut last_was_str = false;
+
+        for item in args.args.iter() {
+            if let Ok(s) = item.clone().downcast::<PyStr>() {
+                if last_was_str {
+                    // Concatenate adjacent strings
+                    if let Some(last) = strings.last_mut() {
+                        let last_str = last.downcast_ref::<PyStr>().unwrap();
+                        let concatenated = format!("{}{}", last_str.as_str(), s.as_str());
+                        *last = vm.ctx.new_str(concatenated).into();
+                    }
+                } else {
+                    strings.push(s.into());
+                }
+                last_was_str = true;
+            } else if item.class().is(vm.ctx.types.interpolation_type) {
+                if !last_was_str {
+                    // Add empty string before interpolation
+                    strings.push(vm.ctx.empty_str.to_owned().into());
+                }
+                interpolations.push(item.clone());
+                last_was_str = false;
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "Template.__new__ *args need to be of type 'str' or 'Interpolation', got {}",
+                    item.class().name()
+                )));
+            }
+        }
+
+        if !last_was_str {
+            // Add trailing empty string
+            strings.push(vm.ctx.empty_str.to_owned().into());
+        }
+
+        Ok(PyTemplate {
+            strings: vm.ctx.new_tuple(strings),
+            interpolations: vm.ctx.new_tuple(interpolations),
+        })
+    }
+}
+
+#[pyclass(with(Constructor, Comparable, Iterable, Representable, AsSequence))]
+impl PyTemplate {
+    #[pygetset]
+    fn strings(&self) -> PyTupleRef {
+        self.strings.clone()
+    }
+
+    #[pygetset]
+    fn interpolations(&self) -> PyTupleRef {
+        self.interpolations.clone()
+    }
+
+    #[pygetset]
+    fn values(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let values: Vec<PyObjectRef> = self
+            .interpolations
+            .iter()
+            .map(|interp| {
+                interp
+                    .downcast_ref::<PyInterpolation>()
+                    .map(|i| i.value.clone())
+                    .unwrap_or_else(|| interp.clone())
+            })
+            .collect();
+        vm.ctx.new_tuple(values)
+    }
+
+    fn concat(&self, other: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        let other = other.downcast_ref::<PyTemplate>().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "can only concatenate Template (not '{}') to Template",
+                other.class().name()
+            ))
+        })?;
+
+        // Concatenate the two templates
+        let mut new_strings: Vec<PyObjectRef> = Vec::new();
+        let mut new_interps: Vec<PyObjectRef> = Vec::new();
+
+        // Add all strings from self except the last one
+        let self_strings_len = self.strings.len();
+        for i in 0..self_strings_len.saturating_sub(1) {
+            new_strings.push(self.strings.get(i).unwrap().clone());
+        }
+
+        // Add all interpolations from self
+        for interp in self.interpolations.iter() {
+            new_interps.push(interp.clone());
+        }
+
+        // Concatenate last string of self with first string of other
+        let last_self = self
+            .strings
+            .get(self_strings_len.saturating_sub(1))
+            .and_then(|s| s.downcast_ref::<PyStr>().map(|s| s.as_str().to_owned()))
+            .unwrap_or_default();
+        let first_other = other
+            .strings
+            .first()
+            .and_then(|s| s.downcast_ref::<PyStr>().map(|s| s.as_str().to_owned()))
+            .unwrap_or_default();
+        let concatenated = format!("{}{}", last_self, first_other);
+        new_strings.push(vm.ctx.new_str(concatenated).into());
+
+        // Add remaining strings from other (skip first)
+        for i in 1..other.strings.len() {
+            new_strings.push(other.strings.get(i).unwrap().clone());
+        }
+
+        // Add all interpolations from other
+        for interp in other.interpolations.iter() {
+            new_interps.push(interp.clone());
+        }
+
+        let template = PyTemplate {
+            strings: vm.ctx.new_tuple(new_strings),
+            interpolations: vm.ctx.new_tuple(new_interps),
+        };
+
+        Ok(template.into_ref(&vm.ctx))
+    }
+
+    fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+        self.concat(&other, vm)
+    }
+
+    #[pymethod]
+    fn __reduce__(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        // Import string.templatelib._template_unpickle
+        // We need to import string first, then get templatelib from it,
+        // because import("string.templatelib", 0) with empty from_list returns the top-level module
+        let string_mod = vm.import("string.templatelib", 0)?;
+        let templatelib = string_mod.get_attr("templatelib", vm)?;
+        let unpickle_func = templatelib.get_attr("_template_unpickle", vm)?;
+
+        // Return (func, (strings, interpolations))
+        let args = vm.ctx.new_tuple(vec![
+            self.strings.clone().into(),
+            self.interpolations.clone().into(),
+        ]);
+        Ok(vm.ctx.new_tuple(vec![unpickle_func, args.into()]))
+    }
+}
+
+impl AsSequence for PyTemplate {
+    fn as_sequence() -> &'static PySequenceMethods {
+        static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            concat: atomic_func!(|seq, other, vm| {
+                let zelf = PyTemplate::sequence_downcast(seq);
+                zelf.concat(other, vm).map(|t| t.into())
+            }),
+            ..PySequenceMethods::NOT_IMPLEMENTED
+        });
+        &AS_SEQUENCE
+    }
+}
+
+impl Comparable for PyTemplate {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+
+            let eq = vm.bool_eq(zelf.strings.as_object(), other.strings.as_object())?
+                && vm.bool_eq(
+                    zelf.interpolations.as_object(),
+                    other.interpolations.as_object(),
+                )?;
+
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Iterable for PyTemplate {
+    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+        Ok(PyTemplateIter::new(zelf).into_pyobject(vm))
+    }
+}
+
+impl Representable for PyTemplate {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let mut parts = Vec::new();
+
+        let strings_len = zelf.strings.len();
+        let interps_len = zelf.interpolations.len();
+
+        for i in 0..strings_len.max(interps_len * 2 + 1) {
+            if i % 2 == 0 {
+                // String position
+                let idx = i / 2;
+                if idx < strings_len {
+                    let s = zelf.strings.get(idx).unwrap();
+                    parts.push(s.repr(vm)?.as_str().to_owned());
+                }
+            } else {
+                // Interpolation position
+                let idx = i / 2;
+                if idx < interps_len {
+                    let interp = zelf.interpolations.get(idx).unwrap();
+                    parts.push(interp.repr(vm)?.as_str().to_owned());
+                }
+            }
+        }
+
+        Ok(format!("Template({})", parts.join(", ")))
+    }
+}
+
+/// Iterator for Template objects
+#[pyclass(module = "string.templatelib", name = "TemplateIter")]
+#[derive(Debug)]
+pub struct PyTemplateIter {
+    template: PyRef<PyTemplate>,
+    index: std::sync::atomic::AtomicUsize,
+    from_strings: std::sync::atomic::AtomicBool,
+}
+
+impl PyPayload for PyTemplateIter {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.template_iter_type
+    }
+}
+
+impl PyTemplateIter {
+    fn new(template: PyRef<PyTemplate>) -> Self {
+        Self {
+            template,
+            index: std::sync::atomic::AtomicUsize::new(0),
+            from_strings: std::sync::atomic::AtomicBool::new(true),
+        }
+    }
+}
+
+#[pyclass(with(IterNext, Iterable))]
+impl PyTemplateIter {}
+
+impl SelfIter for PyTemplateIter {}
+
+impl IterNext for PyTemplateIter {
+    fn next(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        use std::sync::atomic::Ordering;
+
+        loop {
+            let from_strings = zelf.from_strings.load(Ordering::SeqCst);
+            let index = zelf.index.load(Ordering::SeqCst);
+
+            if from_strings {
+                if index < zelf.template.strings.len() {
+                    let item = zelf.template.strings.get(index).unwrap();
+                    zelf.from_strings.store(false, Ordering::SeqCst);
+
+                    // Skip empty strings
+                    if let Some(s) = item.downcast_ref::<PyStr>()
+                        && s.as_str().is_empty()
+                    {
+                        continue;
+                    }
+                    return Ok(PyIterReturn::Return(item.clone()));
+                } else {
+                    return Ok(PyIterReturn::StopIteration(None));
+                }
+            } else if index < zelf.template.interpolations.len() {
+                let item = zelf.template.interpolations.get(index).unwrap();
+                zelf.index.fetch_add(1, Ordering::SeqCst);
+                zelf.from_strings.store(true, Ordering::SeqCst);
+                return Ok(PyIterReturn::Return(item.clone()));
+            } else {
+                return Ok(PyIterReturn::StopIteration(None));
+            }
+        }
+    }
+}
+
+pub fn init(context: &Context) {
+    PyTemplate::extend_class(context, context.types.template_type);
+    PyTemplateIter::extend_class(context, context.types.template_iter_type);
+}
diff --git a/crates/vm/src/builtins/traceback.rs b/crates/vm/src/builtins/traceback.rs
new file mode 100644
index 0000000000..675025cd6b
--- /dev/null
+++ b/crates/vm/src/builtins/traceback.rs
@@ -0,0 +1,121 @@
+use super::PyType;
+use crate::{
+    AsObject, Context, Py, PyPayload, PyRef, PyResult, VirtualMachine, class::PyClassImpl,
+    frame::FrameRef, types::Constructor,
+};
+use rustpython_common::lock::PyMutex;
+use rustpython_compiler_core::OneIndexed;
+
+#[pyclass(module = false, name = "traceback", traverse)]
+#[derive(Debug)]
+pub struct PyTraceback {
+    pub next: PyMutex<Option<PyTracebackRef>>,
+    pub frame: FrameRef,
+    #[pytraverse(skip)]
+    pub lasti: u32,
+    #[pytraverse(skip)]
+    pub lineno: OneIndexed,
+}
+
+pub type PyTracebackRef = PyRef<PyTraceback>;
+
+impl PyPayload for PyTraceback {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.traceback_type
+    }
+}
+
+#[pyclass(with(Constructor))]
+impl PyTraceback {
+    pub const fn new(
+        next: Option<PyRef<Self>>,
+        frame: FrameRef,
+        lasti: u32,
+        lineno: OneIndexed,
+    ) -> Self {
+        Self {
+            next: PyMutex::new(next),
+            frame,
+            lasti,
+            lineno,
+        }
+    }
+
+    #[pygetset]
+    fn tb_frame(&self) -> FrameRef {
+        self.frame.clone()
+    }
+
+    #[pygetset]
+    const fn tb_lasti(&self) -> u32 {
+        self.lasti
+    }
+
+    #[pygetset]
+    const fn tb_lineno(&self) -> usize {
+        self.lineno.get()
+    }
+
+    #[pygetset]
+    fn tb_next(&self) -> Option<PyRef<Self>> {
+        self.next.lock().as_ref().cloned()
+    }
+
+    #[pygetset(setter)]
+    fn set_tb_next(
+        zelf: &Py<Self>,
+        value: Option<PyRef<Self>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if let Some(ref new_next) = value {
+            let mut cursor = new_next.clone();
+            loop {
+                if cursor.is(zelf) {
+                    return Err(vm.new_value_error("traceback loop detected".to_owned()));
+                }
+                let next = cursor.next.lock().clone();
+                match next {
+                    Some(n) => cursor = n,
+                    None => break,
+                }
+            }
+        }
+        *zelf.next.lock() = value;
+        Ok(())
+    }
+}
+
+impl Constructor for PyTraceback {
+    type Args = (Option<PyRef<Self>>, FrameRef, u32, usize);
+
+    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()))?;
+        Ok(Self::new(next, frame, lasti, lineno))
+    }
+}
+
+impl PyTracebackRef {
+    pub fn iter(&self) -> impl Iterator<Item = Self> {
+        core::iter::successors(Some(self.clone()), |tb| tb.next.lock().clone())
+    }
+}
+
+pub fn init(context: &Context) {
+    PyTraceback::extend_class(context, context.types.traceback_type);
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for PyTraceback {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::SerializeStruct;
+
+        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.end()
+    }
+}
diff --git a/vm/src/builtins/tuple.rs b/crates/vm/src/builtins/tuple.rs
similarity index 76%
rename from vm/src/builtins/tuple.rs
rename to crates/vm/src/builtins/tuple.rs
index 2ee8497dda..f6eff5b91e 100644
--- a/vm/src/builtins/tuple.rs
+++ b/crates/vm/src/builtins/tuple.rs
@@ -3,33 +3,33 @@ use crate::common::{
     hash::{PyHash, PyUHash},
     lock::PyMutex,
 };
-use crate::object::{Traverse, TraverseFn};
 use crate::{
     AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
     atomic_func,
     class::PyClassImpl,
     convert::{ToPyObject, TransmuteFromObject},
-    function::{ArgSize, OptionalArg, PyArithmeticValue, PyComparisonValue},
+    function::{ArgSize, FuncArgs, OptionalArg, PyArithmeticValue, PyComparisonValue},
     iter::PyExactSizeIterator,
-    protocol::{PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     recursion::ReprGuard,
     sequence::{OptionalRangeArgs, SequenceExt},
     sliceable::{SequenceIndex, SliceableSequenceOp},
     types::{
-        AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
+        PyComparisonOp, Representable, SelfIter,
     },
     utils::collection_repr,
     vm::VirtualMachine,
 };
-use std::{fmt, marker::PhantomData, sync::LazyLock};
+use alloc::fmt;
+use std::sync::LazyLock;
 
 #[pyclass(module = false, name = "tuple", traverse)]
-pub struct PyTuple {
-    elements: Box<[PyObjectRef]>,
+pub struct PyTuple<R = PyObjectRef> {
+    elements: Box<[R]>,
 }
 
-impl fmt::Debug for PyTuple {
+impl<R> fmt::Debug for PyTuple<R> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // TODO: implement more informational, non-recursive Debug formatter
         f.write_str("tuple")
@@ -111,68 +111,103 @@ impl_from_into_pytuple!(A, B, C, D, E, F, G);
 pub type PyTupleRef = PyRef<PyTuple>;
 
 impl Constructor for PyTuple {
-    type Args = OptionalArg<PyObjectRef>;
+    type Args = Vec<PyObjectRef>;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let iterable: OptionalArg<PyObjectRef> = args.bind(vm)?;
+
+        // Optimizations for exact tuple type
+        if cls.is(vm.ctx.types.tuple_type) {
+            // Return exact tuple as-is
+            if let OptionalArg::Present(ref input) = iterable
+                && let Ok(tuple) = input.clone().downcast_exact::<PyTuple>(vm)
+            {
+                return Ok(tuple.into_pyref().into());
+            }
+
+            // Return empty tuple singleton
+            if iterable.is_missing() {
+                return Ok(vm.ctx.empty_tuple.clone().into());
+            }
+        }
 
-    fn py_new(cls: PyTypeRef, iterable: Self::Args, vm: &VirtualMachine) -> PyResult {
         let elements = if let OptionalArg::Present(iterable) = iterable {
-            let iterable = if cls.is(vm.ctx.types.tuple_type) {
-                match iterable.downcast_exact::<Self>(vm) {
-                    Ok(tuple) => return Ok(tuple.into_pyref().into()),
-                    Err(iterable) => iterable,
-                }
-            } else {
-                iterable
-            };
             iterable.try_to_value(vm)?
         } else {
             vec![]
         };
-        // Return empty tuple only for exact tuple types if the iterable is empty.
+
+        // Return empty tuple singleton for exact tuple types (when iterable was empty)
         if elements.is_empty() && cls.is(vm.ctx.types.tuple_type) {
-            Ok(vm.ctx.empty_tuple.clone().into())
-        } else {
-            Self {
-                elements: elements.into_boxed_slice(),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            return Ok(vm.ctx.empty_tuple.clone().into());
         }
+
+        let payload = Self::py_new(&cls, elements, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, elements: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        Ok(Self {
+            elements: elements.into_boxed_slice(),
+        })
     }
 }
 
-impl AsRef<[PyObjectRef]> for PyTuple {
-    fn as_ref(&self) -> &[PyObjectRef] {
-        self.as_slice()
+impl<R> AsRef<[R]> for PyTuple<R> {
+    fn as_ref(&self) -> &[R] {
+        &self.elements
     }
 }
 
-impl std::ops::Deref for PyTuple {
-    type Target = [PyObjectRef];
+impl<R> core::ops::Deref for PyTuple<R> {
+    type Target = [R];
 
-    fn deref(&self) -> &[PyObjectRef] {
-        self.as_slice()
+    fn deref(&self) -> &[R] {
+        &self.elements
     }
 }
 
-impl<'a> std::iter::IntoIterator for &'a PyTuple {
-    type Item = &'a PyObjectRef;
-    type IntoIter = std::slice::Iter<'a, PyObjectRef>;
+impl<'a, R> core::iter::IntoIterator for &'a PyTuple<R> {
+    type Item = &'a R;
+    type IntoIter = core::slice::Iter<'a, R>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 
-impl<'a> std::iter::IntoIterator for &'a Py<PyTuple> {
-    type Item = &'a PyObjectRef;
-    type IntoIter = std::slice::Iter<'a, PyObjectRef>;
+impl<'a, R> core::iter::IntoIterator for &'a Py<PyTuple<R>> {
+    type Item = &'a R;
+    type IntoIter = core::slice::Iter<'a, R>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 
-impl PyTuple {
+impl<R> PyTuple<R> {
+    pub const fn as_slice(&self) -> &[R] {
+        &self.elements
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.elements.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.elements.is_empty()
+    }
+
+    #[inline]
+    pub fn iter(&self) -> core::slice::Iter<'_, R> {
+        self.elements.iter()
+    }
+}
+
+impl PyTuple<PyObjectRef> {
+    // Do not deprecate this. empty_tuple must be checked.
     pub fn new_ref(elements: Vec<PyObjectRef>, ctx: &Context) -> PyRef<Self> {
         if elements.is_empty() {
             ctx.empty_tuple.clone()
@@ -189,10 +224,6 @@ impl PyTuple {
         Self { elements }
     }
 
-    pub const fn as_slice(&self) -> &[PyObjectRef] {
-        &self.elements
-    }
-
     fn repeat(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Ok(if zelf.elements.is_empty() || value == 0 {
             vm.ctx.empty_tuple.clone()
@@ -214,20 +245,24 @@ impl PyTuple {
     }
 }
 
+impl<T> PyTuple<PyRef<T>> {
+    pub fn new_ref_typed(elements: Vec<PyRef<T>>, ctx: &Context) -> PyRef<Self> {
+        // SAFETY: PyRef<T> has the same layout as PyObjectRef
+        unsafe {
+            let elements: Vec<PyObjectRef> =
+                core::mem::transmute::<Vec<PyRef<T>>, Vec<PyObjectRef>>(elements);
+            let tuple = PyTuple::<PyObjectRef>::new_ref(elements, ctx);
+            core::mem::transmute::<PyRef<PyTuple>, PyRef<Self>>(tuple)
+        }
+    }
+}
+
 #[pyclass(
-    flags(BASETYPE),
-    with(
-        AsMapping,
-        AsSequence,
-        Hashable,
-        Comparable,
-        Iterable,
-        Constructor,
-        Representable
-    )
+    itemsize = core::mem::size_of::<crate::PyObjectRef>(),
+    flags(BASETYPE, SEQUENCE, _MATCH_SELF),
+    with(AsMapping, AsNumber, AsSequence, Hashable, Comparable, Iterable, Constructor, Representable)
 )]
 impl PyTuple {
-    #[pymethod]
     fn __add__(
         zelf: PyRef<Self>,
         other: PyObjectRef,
@@ -250,11 +285,6 @@ impl PyTuple {
         PyArithmeticValue::from_option(added.ok())
     }
 
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        !self.elements.is_empty()
-    }
-
     #[pymethod]
     fn count(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
         let mut count: usize = 0;
@@ -267,18 +297,10 @@ impl PyTuple {
     }
 
     #[inline]
-    #[pymethod]
     pub const fn __len__(&self) -> usize {
         self.elements.len()
     }
 
-    #[inline]
-    pub const fn is_empty(&self) -> bool {
-        self.elements.is_empty()
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
     fn __mul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
         Self::repeat(zelf, value.into(), vm)
     }
@@ -293,7 +315,6 @@ impl PyTuple {
         }
     }
 
-    #[pymethod]
     fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
         self._getitem(&needle, vm)
     }
@@ -315,7 +336,7 @@ impl PyTuple {
     }
 
     fn _contains(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        for element in self.elements.iter() {
+        for element in &self.elements {
             if vm.identical_or_equal(element, needle)? {
                 return Ok(true);
             }
@@ -323,7 +344,6 @@ impl PyTuple {
         Ok(false)
     }
 
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         self._contains(&needle, vm)
     }
@@ -392,6 +412,19 @@ impl AsSequence for PyTuple {
     }
 }
 
+impl AsNumber for PyTuple {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyTuple>().unwrap();
+                Ok(!zelf.elements.is_empty())
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
 impl Hashable for PyTuple {
     #[inline]
     fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
@@ -449,6 +482,41 @@ impl Representable for PyTuple {
     }
 }
 
+impl PyRef<PyTuple<PyObjectRef>> {
+    pub fn try_into_typed<T: PyPayload>(
+        self,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<PyTuple<PyRef<T>>>> {
+        // Check that all elements are of the correct type
+        for elem in self.as_slice() {
+            <PyRef<T> as TransmuteFromObject>::check(vm, elem)?;
+        }
+        // SAFETY: We just verified all elements are of type T
+        Ok(unsafe { core::mem::transmute::<Self, PyRef<PyTuple<PyRef<T>>>>(self) })
+    }
+}
+
+impl<T: PyPayload> PyRef<PyTuple<PyRef<T>>> {
+    pub fn into_untyped(self) -> PyRef<PyTuple> {
+        // SAFETY: PyTuple<PyRef<T>> has the same layout as PyTuple
+        unsafe { core::mem::transmute::<Self, PyRef<PyTuple>>(self) }
+    }
+}
+
+impl<T: PyPayload> Py<PyTuple<PyRef<T>>> {
+    pub fn as_untyped(&self) -> &Py<PyTuple> {
+        // SAFETY: PyTuple<PyRef<T>> has the same layout as PyTuple
+        unsafe { core::mem::transmute::<&Self, &Py<PyTuple>>(self) }
+    }
+}
+
+impl<T: PyPayload> From<PyRef<PyTuple<PyRef<T>>>> for PyTupleRef {
+    #[inline]
+    fn from(tup: PyRef<PyTuple<PyRef<T>>>) -> Self {
+        tup.into_untyped()
+    }
+}
+
 #[pyclass(module = false, name = "tuple_iterator", traverse)]
 #[derive(Debug)]
 pub(crate) struct PyTupleIterator {
@@ -461,7 +529,7 @@ impl PyPayload for PyTupleIterator {
     }
 }
 
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
+#[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
 impl PyTupleIterator {
     #[pymethod]
     fn __length_hint__(&self) -> usize {
@@ -482,7 +550,6 @@ impl PyTupleIterator {
             .builtins_iter_reduce(|x| x.clone().into(), vm)
     }
 }
-impl Unconstructible for PyTupleIterator {}
 
 impl SelfIter for PyTupleIterator {}
 impl IterNext for PyTupleIterator {
@@ -500,95 +567,6 @@ pub(crate) fn init(context: &Context) {
     PyTupleIterator::extend_class(context, context.types.tuple_iterator_type);
 }
 
-pub struct PyTupleTyped<T: TransmuteFromObject> {
-    // SAFETY INVARIANT: T must be repr(transparent) over PyObjectRef, and the
-    //                   elements must be logically valid when transmuted to T
-    tuple: PyTupleRef,
-    _marker: PhantomData<Vec<T>>,
-}
-
-unsafe impl<T> Traverse for PyTupleTyped<T>
-where
-    T: TransmuteFromObject + Traverse,
-{
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.tuple.traverse(tracer_fn);
-    }
-}
-
-impl<T: TransmuteFromObject> TryFromObject for PyTupleTyped<T> {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let tuple = PyTupleRef::try_from_object(vm, obj)?;
-        for elem in &*tuple {
-            T::check(vm, elem)?
-        }
-        // SAFETY: the contract of TransmuteFromObject upholds the variant on `tuple`
-        Ok(Self {
-            tuple,
-            _marker: PhantomData,
-        })
-    }
-}
-
-impl<T: TransmuteFromObject> AsRef<[T]> for PyTupleTyped<T> {
-    fn as_ref(&self) -> &[T] {
-        self.as_slice()
-    }
-}
-
-impl<T: TransmuteFromObject> PyTupleTyped<T> {
-    pub fn empty(vm: &VirtualMachine) -> Self {
-        Self {
-            tuple: vm.ctx.empty_tuple.clone(),
-            _marker: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        unsafe { &*(self.tuple.as_slice() as *const [PyObjectRef] as *const [T]) }
-    }
-
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.tuple.len()
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.tuple.is_empty()
-    }
-}
-
-impl<T: TransmuteFromObject> Clone for PyTupleTyped<T> {
-    fn clone(&self) -> Self {
-        Self {
-            tuple: self.tuple.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T: TransmuteFromObject + fmt::Debug> fmt::Debug for PyTupleTyped<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_slice().fmt(f)
-    }
-}
-
-impl<T: TransmuteFromObject> From<PyTupleTyped<T>> for PyTupleRef {
-    #[inline]
-    fn from(tup: PyTupleTyped<T>) -> Self {
-        tup.tuple
-    }
-}
-
-impl<T: TransmuteFromObject> ToPyObject for PyTupleTyped<T> {
-    #[inline]
-    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        self.tuple.into()
-    }
-}
-
 pub(super) fn tuple_hash(elements: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<PyHash> {
     #[cfg(target_pointer_width = "64")]
     const PRIME1: PyUHash = 11400714785074694791;
diff --git a/crates/vm/src/builtins/type.rs b/crates/vm/src/builtins/type.rs
new file mode 100644
index 0000000000..fed9af976f
--- /dev/null
+++ b/crates/vm/src/builtins/type.rs
@@ -0,0 +1,2146 @@
+use super::{
+    PyClassMethod, PyDictRef, PyList, PyStaticMethod, PyStr, PyStrInterned, PyStrRef, PyTupleRef,
+    PyWeak, mappingproxy::PyMappingProxy, object, union_,
+};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+    VirtualMachine,
+    builtins::{
+        PyBaseExceptionRef,
+        descriptor::{
+            MemberGetter, MemberKind, MemberSetter, PyDescriptorOwned, PyMemberDef,
+            PyMemberDescriptor,
+        },
+        function::PyCellRef,
+        tuple::{IntoPyTuple, PyTuple},
+    },
+    class::{PyClassImpl, StaticType},
+    common::{
+        ascii,
+        borrow::BorrowedValue,
+        lock::{PyRwLock, PyRwLockReadGuard},
+    },
+    convert::ToPyResult,
+    function::{FuncArgs, KwArgs, OptionalArg, PyMethodDef, PySetterValue},
+    object::{Traverse, TraverseFn},
+    protocol::{PyIterReturn, PyNumberMethods},
+    types::{
+        AsNumber, Callable, Constructor, GetAttr, Initializer, PyTypeFlags, PyTypeSlots,
+        Representable, SLOT_DEFS, SetAttr, TypeDataRef, TypeDataRefMut, TypeDataSlot,
+    },
+};
+use core::{any::Any, borrow::Borrow, ops::Deref, pin::Pin, ptr::NonNull};
+use indexmap::{IndexMap, map::Entry};
+use itertools::Itertools;
+use num_traits::ToPrimitive;
+use std::collections::HashSet;
+
+#[pyclass(module = false, name = "type", traverse = "manual")]
+pub struct PyType {
+    pub base: Option<PyTypeRef>,
+    pub bases: PyRwLock<Vec<PyTypeRef>>,
+    pub mro: PyRwLock<Vec<PyTypeRef>>,
+    pub subclasses: PyRwLock<Vec<PyRef<PyWeak>>>,
+    pub attributes: PyRwLock<PyAttributes>,
+    pub slots: PyTypeSlots,
+    pub heaptype_ext: Option<Pin<Box<HeapTypeExt>>>,
+}
+
+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.subclasses.traverse(tracer_fn);
+        self.attributes
+            .read_recursive()
+            .iter()
+            .map(|(_, v)| v.traverse(tracer_fn))
+            .count();
+    }
+}
+
+// PyHeapTypeObject in CPython
+pub struct HeapTypeExt {
+    pub name: PyRwLock<PyStrRef>,
+    pub qualname: PyRwLock<PyStrRef>,
+    pub slots: Option<PyRef<PyTuple<PyStrRef>>>,
+    pub type_data: PyRwLock<Option<TypeDataSlot>>,
+}
+
+pub struct PointerSlot<T>(NonNull<T>);
+
+unsafe impl<T> Sync for PointerSlot<T> {}
+unsafe impl<T> Send for PointerSlot<T> {}
+
+impl<T> PointerSlot<T> {
+    pub const unsafe fn borrow_static(&self) -> &'static T {
+        unsafe { self.0.as_ref() }
+    }
+}
+
+impl<T> Clone for PointerSlot<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> Copy for PointerSlot<T> {}
+
+impl<T> From<&'static T> for PointerSlot<T> {
+    fn from(x: &'static T) -> Self {
+        Self(NonNull::from(x))
+    }
+}
+
+impl<T> AsRef<T> for PointerSlot<T> {
+    fn as_ref(&self) -> &T {
+        unsafe { self.0.as_ref() }
+    }
+}
+
+pub type PyTypeRef = PyRef<PyType>;
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        unsafe impl Send for PyType {}
+        unsafe impl Sync for PyType {}
+    }
+}
+
+/// For attributes we do not use a dict, but an IndexMap, which is an Hash Table
+/// that maintains order and is compatible with the standard HashMap  This is probably
+/// faster and only supports strings as keys.
+pub type PyAttributes = IndexMap<&'static PyStrInterned, PyObjectRef, ahash::RandomState>;
+
+unsafe impl Traverse for PyAttributes {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.values().for_each(|v| v.traverse(tracer_fn));
+    }
+}
+
+impl core::fmt::Display for PyType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(&self.name(), f)
+    }
+}
+
+impl core::fmt::Debug for PyType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "[PyType {}]", &self.name())
+    }
+}
+
+impl PyPayload for PyType {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.type_type
+    }
+}
+
+fn downcast_qualname(value: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+    match value.downcast::<PyStr>() {
+        Ok(value) => Ok(value),
+        Err(value) => Err(vm.new_type_error(format!(
+            "can only assign string to __qualname__, not '{}'",
+            value.class().name()
+        ))),
+    }
+}
+
+fn is_subtype_with_mro(a_mro: &[PyTypeRef], a: &Py<PyType>, b: &Py<PyType>) -> bool {
+    if a.is(b) {
+        return true;
+    }
+    for item in a_mro {
+        if item.is(b) {
+            return true;
+        }
+    }
+    false
+}
+
+impl PyType {
+    pub fn new_simple_heap(
+        name: &str,
+        base: &Py<PyType>,
+        ctx: &Context,
+    ) -> Result<PyRef<Self>, String> {
+        Self::new_heap(
+            name,
+            vec![base.to_owned()],
+            Default::default(),
+            Default::default(),
+            Self::static_type().to_owned(),
+            ctx,
+        )
+    }
+    pub fn new_heap(
+        name: &str,
+        bases: Vec<PyRef<Self>>,
+        attrs: PyAttributes,
+        mut slots: PyTypeSlots,
+        metaclass: PyRef<Self>,
+        ctx: &Context,
+    ) -> Result<PyRef<Self>, String> {
+        // TODO: ensure clean slot name
+        // assert_eq!(slots.name.borrow(), "");
+
+        // Set HEAPTYPE flag for heap-allocated types
+        slots.flags |= PyTypeFlags::HEAPTYPE;
+
+        let name = ctx.new_str(name);
+        let heaptype_ext = HeapTypeExt {
+            name: PyRwLock::new(name.clone()),
+            qualname: PyRwLock::new(name),
+            slots: None,
+            type_data: PyRwLock::new(None),
+        };
+        let base = bases[0].clone();
+
+        Self::new_heap_inner(base, bases, attrs, slots, heaptype_ext, metaclass, ctx)
+    }
+
+    /// Equivalent to CPython's PyType_Check macro
+    /// Checks if obj is an instance of type (or its subclass)
+    pub(crate) fn check(obj: &PyObject) -> Option<&Py<Self>> {
+        obj.downcast_ref::<Self>()
+    }
+
+    fn resolve_mro(bases: &[PyRef<Self>]) -> Result<Vec<PyTypeRef>, String> {
+        // Check for duplicates in bases.
+        let mut unique_bases = HashSet::new();
+        for base in bases {
+            if !unique_bases.insert(base.get_id()) {
+                return Err(format!("duplicate base class {}", base.name()));
+            }
+        }
+
+        let mros = bases
+            .iter()
+            .map(|base| base.mro_map_collect(|t| t.to_owned()))
+            .collect();
+        linearise_mro(mros)
+    }
+
+    /// Inherit SEQUENCE and MAPPING flags from base classes
+    /// Check all bases in order and inherit the first SEQUENCE or MAPPING flag found
+    fn inherit_patma_flags(slots: &mut PyTypeSlots, bases: &[PyRef<Self>]) {
+        const COLLECTION_FLAGS: PyTypeFlags = PyTypeFlags::from_bits_truncate(
+            PyTypeFlags::SEQUENCE.bits() | PyTypeFlags::MAPPING.bits(),
+        );
+
+        // If flags are already set, don't override
+        if slots.flags.intersects(COLLECTION_FLAGS) {
+            return;
+        }
+
+        // Check each base in order and inherit the first collection flag found
+        for base in bases {
+            let base_flags = base.slots.flags & COLLECTION_FLAGS;
+            if !base_flags.is_empty() {
+                slots.flags |= base_flags;
+                return;
+            }
+        }
+    }
+
+    /// Check for __abc_tpflags__ and set the appropriate flags
+    /// This checks in attrs and all base classes for __abc_tpflags__
+    fn check_abc_tpflags(
+        slots: &mut PyTypeSlots,
+        attrs: &PyAttributes,
+        bases: &[PyRef<Self>],
+        ctx: &Context,
+    ) {
+        const COLLECTION_FLAGS: PyTypeFlags = PyTypeFlags::from_bits_truncate(
+            PyTypeFlags::SEQUENCE.bits() | PyTypeFlags::MAPPING.bits(),
+        );
+
+        // Don't override if flags are already set
+        if slots.flags.intersects(COLLECTION_FLAGS) {
+            return;
+        }
+
+        // First check in our own attributes
+        let abc_tpflags_name = ctx.intern_str("__abc_tpflags__");
+        if let Some(abc_tpflags_obj) = attrs.get(abc_tpflags_name)
+            && let Some(int_obj) = abc_tpflags_obj.downcast_ref::<crate::builtins::int::PyInt>()
+        {
+            let flags_val = int_obj.as_bigint().to_i64().unwrap_or(0);
+            let abc_flags = PyTypeFlags::from_bits_truncate(flags_val as u64);
+            slots.flags |= abc_flags & COLLECTION_FLAGS;
+            return;
+        }
+
+        // Then check in base classes
+        for base in bases {
+            if let Some(abc_tpflags_obj) = base.find_name_in_mro(abc_tpflags_name)
+                && let Some(int_obj) = abc_tpflags_obj.downcast_ref::<crate::builtins::int::PyInt>()
+            {
+                let flags_val = int_obj.as_bigint().to_i64().unwrap_or(0);
+                let abc_flags = PyTypeFlags::from_bits_truncate(flags_val as u64);
+                slots.flags |= abc_flags & COLLECTION_FLAGS;
+                return;
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn new_heap_inner(
+        base: PyRef<Self>,
+        bases: Vec<PyRef<Self>>,
+        attrs: PyAttributes,
+        mut slots: PyTypeSlots,
+        heaptype_ext: HeapTypeExt,
+        metaclass: PyRef<Self>,
+        ctx: &Context,
+    ) -> Result<PyRef<Self>, String> {
+        let mro = Self::resolve_mro(&bases)?;
+
+        // Inherit HAS_DICT from any base in MRO that has it
+        // (not just the first base, as any base with __dict__ means subclass needs it too)
+        if mro
+            .iter()
+            .any(|b| b.slots.flags.has_feature(PyTypeFlags::HAS_DICT))
+        {
+            slots.flags |= PyTypeFlags::HAS_DICT
+        }
+
+        // Inherit SEQUENCE and MAPPING flags from base classes
+        Self::inherit_patma_flags(&mut slots, &bases);
+
+        // Check for __abc_tpflags__ from ABCMeta (for collections.abc.Sequence, Mapping, etc.)
+        Self::check_abc_tpflags(&mut slots, &attrs, &bases, ctx);
+
+        if slots.basicsize == 0 {
+            slots.basicsize = base.slots.basicsize;
+        }
+
+        Self::inherit_readonly_slots(&mut slots, &base);
+
+        if let Some(qualname) = attrs.get(identifier!(ctx, __qualname__))
+            && !qualname.fast_isinstance(ctx.types.str_type)
+        {
+            return Err(format!(
+                "type __qualname__ must be a str, not {}",
+                qualname.class().name()
+            ));
+        }
+
+        let new_type = PyRef::new_ref(
+            Self {
+                base: Some(base),
+                bases: PyRwLock::new(bases),
+                mro: PyRwLock::new(mro),
+                subclasses: PyRwLock::default(),
+                attributes: PyRwLock::new(attrs),
+                slots,
+                heaptype_ext: Some(Pin::new(Box::new(heaptype_ext))),
+            },
+            metaclass,
+            None,
+        );
+        new_type.mro.write().insert(0, new_type.clone());
+
+        new_type.init_slots(ctx);
+
+        let weakref_type = super::PyWeak::static_type();
+        for base in new_type.bases.read().iter() {
+            base.subclasses.write().push(
+                new_type
+                    .as_object()
+                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
+                    .unwrap(),
+            );
+        }
+
+        Ok(new_type)
+    }
+
+    pub fn new_static(
+        base: PyRef<Self>,
+        attrs: PyAttributes,
+        mut slots: PyTypeSlots,
+        metaclass: PyRef<Self>,
+    ) -> Result<PyRef<Self>, String> {
+        if base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+            slots.flags |= PyTypeFlags::HAS_DICT
+        }
+
+        // Inherit SEQUENCE and MAPPING flags from base class
+        // For static types, we only have a single base
+        Self::inherit_patma_flags(&mut slots, core::slice::from_ref(&base));
+
+        if slots.basicsize == 0 {
+            slots.basicsize = base.slots.basicsize;
+        }
+
+        Self::inherit_readonly_slots(&mut slots, &base);
+
+        let bases = PyRwLock::new(vec![base.clone()]);
+        let mro = base.mro_map_collect(|x| x.to_owned());
+
+        let new_type = PyRef::new_ref(
+            Self {
+                base: Some(base),
+                bases,
+                mro: PyRwLock::new(mro),
+                subclasses: PyRwLock::default(),
+                attributes: PyRwLock::new(attrs),
+                slots,
+                heaptype_ext: None,
+            },
+            metaclass,
+            None,
+        );
+        new_type.mro.write().insert(0, new_type.clone());
+
+        // Note: inherit_slots is called in PyClassImpl::init_class after
+        // slots are fully initialized by make_slots()
+
+        Self::set_new(&new_type.slots, &new_type.base);
+
+        let weakref_type = super::PyWeak::static_type();
+        for base in new_type.bases.read().iter() {
+            base.subclasses.write().push(
+                new_type
+                    .as_object()
+                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
+                    .unwrap(),
+            );
+        }
+
+        Ok(new_type)
+    }
+
+    pub(crate) fn init_slots(&self, ctx: &Context) {
+        // Inherit slots from MRO (mro[0] is self, so skip it)
+        let mro: Vec<_> = self.mro.read()[1..].to_vec();
+        for base in mro.iter() {
+            self.inherit_slots(base);
+        }
+
+        // Wire dunder methods to slots
+        #[allow(clippy::mutable_key_type)]
+        let mut slot_name_set = std::collections::HashSet::new();
+
+        // mro[0] is self, so skip it; self.attributes is checked separately below
+        for cls in self.mro.read()[1..].iter() {
+            for &name in cls.attributes.read().keys() {
+                if name.as_bytes().starts_with(b"__") && name.as_bytes().ends_with(b"__") {
+                    slot_name_set.insert(name);
+                }
+            }
+        }
+        for &name in self.attributes.read().keys() {
+            if name.as_bytes().starts_with(b"__") && name.as_bytes().ends_with(b"__") {
+                slot_name_set.insert(name);
+            }
+        }
+        // Sort for deterministic iteration order (important for slot processing)
+        let mut slot_names: Vec<_> = slot_name_set.into_iter().collect();
+        slot_names.sort_by_key(|name| name.as_str());
+        for attr_name in slot_names {
+            self.update_slot::<true>(attr_name, ctx);
+        }
+
+        Self::set_new(&self.slots, &self.base);
+    }
+
+    fn set_new(slots: &PyTypeSlots, base: &Option<PyTypeRef>) {
+        if slots.flags.contains(PyTypeFlags::DISALLOW_INSTANTIATION) {
+            slots.new.store(None)
+        } else if slots.new.load().is_none() {
+            slots.new.store(
+                base.as_ref()
+                    .map(|base| base.slots.new.load())
+                    .unwrap_or(None),
+            )
+        }
+    }
+
+    /// Inherit readonly slots from base type at creation time.
+    /// These slots are not AtomicCell and must be set before the type is used.
+    fn inherit_readonly_slots(slots: &mut PyTypeSlots, base: &Self) {
+        if slots.as_buffer.is_none() {
+            slots.as_buffer = base.slots.as_buffer;
+        }
+    }
+
+    /// Inherit slots from base type. inherit_slots
+    pub(crate) fn inherit_slots(&self, base: &Self) {
+        // Use SLOT_DEFS to iterate all slots
+        // Note: as_buffer is handled in inherit_readonly_slots (not AtomicCell)
+        for def in SLOT_DEFS {
+            def.accessor.copyslot_if_none(self, base);
+        }
+    }
+
+    // This is used for class initialization where the vm is not yet available.
+    pub fn set_str_attr<V: Into<PyObjectRef>>(
+        &self,
+        attr_name: &str,
+        value: V,
+        ctx: impl AsRef<Context>,
+    ) {
+        let ctx = ctx.as_ref();
+        let attr_name = ctx.intern_str(attr_name);
+        self.set_attr(attr_name, value.into())
+    }
+
+    pub fn set_attr(&self, attr_name: &'static PyStrInterned, value: PyObjectRef) {
+        self.attributes.write().insert(attr_name, value);
+    }
+
+    /// This is the internal get_attr implementation for fast lookup on a class.
+    pub fn get_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
+        flame_guard!(format!("class_get_attr({:?})", attr_name));
+
+        self.get_direct_attr(attr_name)
+            .or_else(|| self.get_super_attr(attr_name))
+    }
+
+    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
+    fn find_name_in_mro(&self, name: &'static PyStrInterned) -> Option<PyObjectRef> {
+        // mro[0] is self, so we just iterate through the entire MRO
+        for cls in self.mro.read().iter() {
+            if let Some(value) = cls.attributes.read().get(name) {
+                return Some(value.clone());
+            }
+        }
+        None
+    }
+
+    /// Equivalent to CPython's _PyType_LookupRef
+    /// Looks 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)
+    }
+
+    pub fn get_super_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
+        self.mro.read()[1..]
+            .iter()
+            .find_map(|class| class.attributes.read().get(attr_name).cloned())
+    }
+
+    // This is the internal has_attr implementation for fast lookup on a class.
+    pub fn has_attr(&self, attr_name: &'static PyStrInterned) -> bool {
+        self.attributes.read().contains_key(attr_name)
+            || self.mro.read()[1..]
+                .iter()
+                .any(|c| c.attributes.read().contains_key(attr_name))
+    }
+
+    pub fn get_attributes(&self) -> PyAttributes {
+        // Gather all members here:
+        let mut attributes = PyAttributes::default();
+
+        // mro[0] is self, so we iterate through the entire MRO in reverse
+        for bc in self.mro.read().iter().map(|cls| -> &Self { cls }).rev() {
+            for (name, value) in bc.attributes.read().iter() {
+                attributes.insert(name.to_owned(), value.clone());
+            }
+        }
+
+        attributes
+    }
+
+    // bound method for every type
+    pub(crate) fn __new__(zelf: PyRef<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let (subtype, args): (PyRef<Self>, FuncArgs) = args.bind(vm)?;
+        if !subtype.fast_issubclass(&zelf) {
+            return Err(vm.new_type_error(format!(
+                "{zelf}.__new__({subtype}): {subtype} is not a subtype of {zelf}",
+                zelf = zelf.name(),
+                subtype = subtype.name(),
+            )));
+        }
+        call_slot_new(zelf, subtype, args, vm)
+    }
+
+    fn name_inner<'a, R: 'a>(
+        &'a self,
+        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)
+        } else {
+            heap_f(self.heaptype_ext.as_ref().unwrap())
+        }
+    }
+
+    pub fn slot_name(&self) -> BorrowedValue<'_, str> {
+        self.name_inner(
+            |name| name.into(),
+            |ext| PyRwLockReadGuard::map(ext.name.read(), |name| 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(),
+        )
+    }
+
+    // Type Data Slot API - CPython's PyObject_GetTypeData equivalent
+
+    /// Initialize type data for this type. Can only be called once.
+    /// Returns an error if the type is not a heap type or if data is already initialized.
+    pub fn init_type_data<T: Any + Send + Sync + 'static>(&self, data: T) -> Result<(), String> {
+        let ext = self
+            .heaptype_ext
+            .as_ref()
+            .ok_or_else(|| "Cannot set type data on non-heap types".to_string())?;
+
+        let mut type_data = ext.type_data.write();
+        if type_data.is_some() {
+            return Err("Type data already initialized".to_string());
+        }
+        *type_data = Some(TypeDataSlot::new(data));
+        Ok(())
+    }
+
+    /// Get a read guard to the type data.
+    /// Returns None if the type is not a heap type, has no data, or the data type doesn't match.
+    pub fn get_type_data<T: Any + 'static>(&self) -> Option<TypeDataRef<'_, T>> {
+        self.heaptype_ext
+            .as_ref()
+            .and_then(|ext| TypeDataRef::try_new(ext.type_data.read()))
+    }
+
+    /// Get a write guard to the type data.
+    /// Returns None if the type is not a heap type, has no data, or the data type doesn't match.
+    pub fn get_type_data_mut<T: Any + 'static>(&self) -> Option<TypeDataRefMut<'_, T>> {
+        self.heaptype_ext
+            .as_ref()
+            .and_then(|ext| TypeDataRefMut::try_new(ext.type_data.write()))
+    }
+
+    /// Check if this type has type data of the given type.
+    pub fn has_type_data<T: Any + 'static>(&self) -> bool {
+        self.heaptype_ext.as_ref().is_some_and(|ext| {
+            ext.type_data
+                .read()
+                .as_ref()
+                .is_some_and(|slot| slot.get::<T>().is_some())
+        })
+    }
+}
+
+impl Py<PyType> {
+    pub(crate) fn is_subtype(&self, other: &Self) -> bool {
+        is_subtype_with_mro(&self.mro.read(), self, other)
+    }
+
+    /// Equivalent to CPython's PyType_CheckExact macro
+    /// Checks if obj is exactly a type (not a subclass)
+    pub fn check_exact<'a>(obj: &'a PyObject, vm: &VirtualMachine) -> Option<&'a Self> {
+        obj.downcast_ref_if_exact::<PyType>(vm)
+    }
+
+    /// Determines if `subclass` is actually a subclass of `cls`, this doesn't call __subclasscheck__,
+    /// so only use this if `cls` is known to have not overridden the base __subclasscheck__ magic
+    /// method.
+    pub fn fast_issubclass(&self, cls: &impl Borrow<PyObject>) -> bool {
+        self.as_object().is(cls.borrow()) || self.mro.read()[1..].iter().any(|c| c.is(cls.borrow()))
+    }
+
+    pub fn mro_map_collect<F, R>(&self, f: F) -> Vec<R>
+    where
+        F: Fn(&Self) -> R,
+    {
+        self.mro.read().iter().map(|x| x.deref()).map(f).collect()
+    }
+
+    pub fn mro_collect(&self) -> Vec<PyRef<PyType>> {
+        self.mro
+            .read()
+            .iter()
+            .map(|x| x.deref())
+            .map(|x| x.to_owned())
+            .collect()
+    }
+
+    pub fn iter_base_chain(&self) -> impl Iterator<Item = &Self> {
+        core::iter::successors(Some(self), |cls| cls.base.as_deref())
+    }
+
+    pub fn extend_methods(&'static self, method_defs: &'static [PyMethodDef], ctx: &Context) {
+        for method_def in method_defs {
+            let method = method_def.to_proper_method(self, ctx);
+            self.set_attr(ctx.intern_str(method_def.name), method);
+        }
+    }
+}
+
+#[pyclass(
+    with(
+        Py,
+        Constructor,
+        Initializer,
+        GetAttr,
+        SetAttr,
+        Callable,
+        AsNumber,
+        Representable
+    ),
+    flags(BASETYPE)
+)]
+impl PyType {
+    #[pygetset]
+    fn __bases__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        vm.ctx.new_tuple(
+            self.bases
+                .read()
+                .iter()
+                .map(|x| x.as_object().to_owned())
+                .collect(),
+        )
+    }
+    #[pygetset(setter, name = "__bases__")]
+    fn set_bases(zelf: &Py<Self>, bases: Vec<PyTypeRef>, vm: &VirtualMachine) -> PyResult<()> {
+        // TODO: Assigning to __bases__ is only used in typing.NamedTupleMeta.__new__
+        // Rather than correctly re-initializing the class, we are skipping a few steps for now
+        if zelf.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            return Err(vm.new_type_error(format!(
+                "cannot set '__bases__' attribute of immutable type '{}'",
+                zelf.name()
+            )));
+        }
+        if bases.is_empty() {
+            return Err(vm.new_type_error(format!(
+                "can only assign non-empty tuple to %s.__bases__, not {}",
+                zelf.name()
+            )));
+        }
+
+        // TODO: check for mro cycles
+
+        // TODO: Remove this class from all subclass lists
+        // for base in self.bases.read().iter() {
+        //     let subclasses = base.subclasses.write();
+        //     // TODO: how to uniquely identify the subclasses to remove?
+        // }
+
+        *zelf.bases.write() = bases;
+        // Recursively update the mros of this class and all subclasses
+        fn update_mro_recursively(cls: &PyType, vm: &VirtualMachine) -> PyResult<()> {
+            let mut mro =
+                PyType::resolve_mro(&cls.bases.read()).map_err(|msg| vm.new_type_error(msg))?;
+            // Preserve self (mro[0]) when updating MRO
+            mro.insert(0, cls.mro.read()[0].to_owned());
+            *cls.mro.write() = mro;
+            for subclass in cls.subclasses.write().iter() {
+                let subclass = subclass.upgrade().unwrap();
+                let subclass: &Py<PyType> = subclass.downcast_ref().unwrap();
+                update_mro_recursively(subclass, vm)?;
+            }
+            Ok(())
+        }
+        update_mro_recursively(zelf, vm)?;
+
+        // TODO: do any old slots need to be cleaned up first?
+        zelf.init_slots(&vm.ctx);
+
+        // Register this type as a subclass of its new bases
+        let weakref_type = super::PyWeak::static_type();
+        for base in zelf.bases.read().iter() {
+            base.subclasses.write().push(
+                zelf.as_object()
+                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
+                    .unwrap(),
+            );
+        }
+
+        Ok(())
+    }
+
+    #[pygetset]
+    fn __base__(&self) -> Option<PyTypeRef> {
+        self.base.clone()
+    }
+
+    #[pygetset]
+    const fn __flags__(&self) -> u64 {
+        self.slots.flags.bits()
+    }
+
+    #[pygetset]
+    fn __basicsize__(&self) -> usize {
+        crate::object::SIZEOF_PYOBJECT_HEAD + self.slots.basicsize
+    }
+
+    #[pygetset]
+    fn __itemsize__(&self) -> usize {
+        self.slots.itemsize
+    }
+
+    #[pygetset]
+    pub fn __name__(&self, vm: &VirtualMachine) -> PyStrRef {
+        self.name_inner(
+            |name| {
+                vm.ctx
+                    .interned_str(name.rsplit_once('.').map_or(name, |(_, name)| name))
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "static type name must be already interned but {} is not",
+                            self.slot_name()
+                        )
+                    })
+                    .to_owned()
+            },
+            |ext| ext.name.read().clone(),
+        )
+    }
+
+    #[pygetset]
+    pub fn __qualname__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        if let Some(ref heap_type) = self.heaptype_ext {
+            heap_type.qualname.read().clone().into()
+        } else {
+            // For static types, return the name
+            vm.ctx.new_str(self.name().deref()).into()
+        }
+    }
+
+    #[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()
+            )));
+        };
+        let value = value.ok_or_else(|| {
+            vm.new_type_error(format!(
+                "cannot delete '__qualname__' attribute of immutable type '{}'",
+                self.name()
+            ))
+        })?;
+
+        let str_value = downcast_qualname(value, vm)?;
+
+        let heap_type = self
+            .heaptype_ext
+            .as_ref()
+            .expect("HEAPTYPE should have heaptype_ext");
+
+        // 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
+        let _old_qualname = {
+            let mut qualname_guard = heap_type.qualname.write();
+            core::mem::replace(&mut *qualname_guard, str_value)
+        };
+        // old_qualname is dropped here, outside the lock scope
+
+        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()
+            )));
+        }
+
+        let __annotations__ = identifier!(vm, __annotations__);
+        let annotations = self.attributes.read().get(__annotations__).cloned();
+
+        let annotations = if let Some(annotations) = annotations {
+            annotations
+        } else {
+            let annotations: PyObjectRef = vm.ctx.new_dict().into();
+            let removed = self
+                .attributes
+                .write()
+                .insert(__annotations__, annotations.clone());
+            debug_assert!(removed.is_none());
+            annotations
+        };
+        Ok(annotations)
+    }
+
+    #[pygetset(setter)]
+    fn set___annotations__(&self, value: Option<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 '{}'",
+                self.name()
+            )));
+        }
+
+        let __annotations__ = identifier!(vm, __annotations__);
+        if let Some(value) = value {
+            self.attributes.write().insert(__annotations__, value);
+        } else {
+            self.attributes
+                .read()
+                .get(__annotations__)
+                .cloned()
+                .ok_or_else(|| {
+                    vm.new_attribute_error(format!(
+                        "'{}' object has no attribute '__annotations__'",
+                        self.name()
+                    ))
+                })?;
+        }
+
+        Ok(())
+    }
+
+    #[pygetset]
+    pub fn __module__(&self, vm: &VirtualMachine) -> PyObjectRef {
+        self.attributes
+            .read()
+            .get(identifier!(vm, __module__))
+            .cloned()
+            // We need to exclude this method from going into recursion:
+            .and_then(|found| {
+                if found.fast_isinstance(vm.ctx.types.getset_type) {
+                    None
+                } else {
+                    Some(found)
+                }
+            })
+            .unwrap_or_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);
+        Ok(())
+    }
+
+    #[pyclassmethod]
+    fn __prepare__(
+        _cls: PyTypeRef,
+        _name: OptionalArg<PyObjectRef>,
+        _bases: OptionalArg<PyObjectRef>,
+        _kwargs: KwArgs,
+        vm: &VirtualMachine,
+    ) -> PyDictRef {
+        vm.ctx.new_dict()
+    }
+
+    #[pymethod]
+    fn __subclasses__(&self) -> PyList {
+        let mut subclasses = self.subclasses.write();
+        subclasses.retain(|x| x.upgrade().is_some());
+        PyList::from(
+            subclasses
+                .iter()
+                .map(|x| x.upgrade().unwrap())
+                .collect::<Vec<_>>(),
+        )
+    }
+
+    pub fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        or_(other, zelf, vm)
+    }
+
+    pub fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        or_(zelf, other, vm)
+    }
+
+    #[pygetset]
+    fn __dict__(zelf: PyRef<Self>) -> PyMappingProxy {
+        PyMappingProxy::from(zelf)
+    }
+
+    #[pygetset(setter)]
+    fn set___dict__(&self, _value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        Err(vm.new_not_implemented_error(
+            "Setting __dict__ attribute on a type isn't yet implemented",
+        ))
+    }
+
+    fn check_set_special_type_attr(
+        &self,
+        name: &PyStrInterned,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+            return Err(vm.new_type_error(format!(
+                "cannot set '{}' attribute of immutable type '{}'",
+                name,
+                self.slot_name()
+            )));
+        }
+        Ok(())
+    }
+
+    #[pygetset(setter)]
+    fn set___name__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        self.check_set_special_type_attr(identifier!(vm, __name__), vm)?;
+        let name = value.downcast::<PyStr>().map_err(|value| {
+            vm.new_type_error(format!(
+                "can only assign string to {}.__name__, not '{}'",
+                self.slot_name(),
+                value.class().slot_name(),
+            ))
+        })?;
+        if name.as_bytes().contains(&0) {
+            return Err(vm.new_value_error("type name must not contain null characters"));
+        }
+        name.ensure_valid_utf8(vm)?;
+
+        // Use std::mem::replace to swap the new value in and get the old value out,
+        // then drop the old value after releasing the lock (similar to CPython's Py_SETREF)
+        let _old_name = {
+            let mut name_guard = self.heaptype_ext.as_ref().unwrap().name.write();
+            core::mem::replace(&mut *name_guard, name)
+        };
+        // old_name is dropped here, outside the lock scope
+
+        Ok(())
+    }
+
+    #[pygetset]
+    fn __text_signature__(&self) -> Option<String> {
+        self.slots
+            .doc
+            .and_then(|doc| get_text_signature_from_internal_doc(&self.name(), doc))
+            .map(|signature| signature.to_string())
+    }
+
+    #[pygetset]
+    fn __type_params__(&self, vm: &VirtualMachine) -> PyTupleRef {
+        let attrs = self.attributes.read();
+        let key = identifier!(vm, __type_params__);
+        if let Some(params) = attrs.get(&key)
+            && let Ok(tuple) = params.clone().downcast::<PyTuple>()
+        {
+            return tuple;
+        }
+        // Return empty tuple if not found or not a tuple
+        vm.ctx.empty_tuple.clone()
+    }
+
+    #[pygetset(setter)]
+    fn set___type_params__(
+        &self,
+        value: PySetterValue<PyTupleRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match value {
+            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());
+            }
+            PySetterValue::Delete => {
+                // For delete, we still need to check if the type is immutable
+                if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
+                    return Err(vm.new_type_error(format!(
+                        "cannot delete '__type_params__' attribute of immutable type '{}'",
+                        self.slot_name()
+                    )));
+                }
+                let mut attrs = self.attributes.write();
+                let key = identifier!(vm, __type_params__);
+                attrs.shift_remove(&key);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Constructor for PyType {
+    type Args = FuncArgs;
+
+    fn slot_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        vm_trace!("type.__new__ {:?}", args);
+
+        let is_type_type = metatype.is(vm.ctx.types.type_type);
+        if is_type_type && args.args.len() == 1 && args.kwargs.is_empty() {
+            return Ok(args.args[0].class().to_owned().into());
+        }
+
+        if args.args.len() != 3 {
+            return Err(vm.new_type_error(if is_type_type {
+                "type() takes 1 or 3 arguments".to_owned()
+            } else {
+                format!(
+                    "type.__new__() takes exactly 3 arguments ({} given)",
+                    args.args.len()
+                )
+            }));
+        }
+
+        let (name, bases, dict, kwargs): (PyStrRef, PyTupleRef, PyDictRef, KwArgs) =
+            args.clone().bind(vm)?;
+
+        if name.as_bytes().contains(&0) {
+            return Err(vm.new_value_error("type name must not contain null characters"));
+        }
+        name.ensure_valid_utf8(vm)?;
+
+        let (metatype, base, bases, base_is_type) = if bases.is_empty() {
+            let base = vm.ctx.types.object_type.to_owned();
+            (metatype, base.clone(), vec![base], false)
+        } else {
+            let bases = bases
+                .iter()
+                .map(|obj| {
+                    obj.clone().downcast::<Self>().or_else(|obj| {
+                        if vm
+                            .get_attribute_opt(obj, identifier!(vm, __mro_entries__))?
+                            .is_some()
+                        {
+                            Err(vm.new_type_error(
+                                "type() doesn't support MRO entry resolution; \
+                                 use types.new_class()",
+                            ))
+                        } else {
+                            Err(vm.new_type_error("bases must be types"))
+                        }
+                    })
+                })
+                .collect::<PyResult<Vec<_>>>()?;
+
+            // Search the bases for the proper metatype to deal with this:
+            let winner = calculate_meta_class(metatype.clone(), &bases, vm)?;
+            let metatype = if !winner.is(&metatype) {
+                if let Some(ref slot_new) = winner.slots.new.load() {
+                    // Pass it to the winner
+                    return slot_new(winner, args, vm);
+                }
+                winner
+            } else {
+                metatype
+            };
+
+            let base = best_base(&bases, vm)?;
+            let base_is_type = base.is(vm.ctx.types.type_type);
+
+            (metatype, base.to_owned(), bases, base_is_type)
+        };
+
+        let qualname = dict
+            .pop_item(identifier!(vm, __qualname__).as_object(), 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()
+            });
+        let mut attributes = dict.to_attributes(vm);
+
+        // Check __doc__ for surrogates - raises UnicodeEncodeError during type creation
+        if let Some(doc) = attributes.get(identifier!(vm, __doc__))
+            && let Some(doc_str) = doc.downcast_ref::<PyStr>()
+        {
+            doc_str.ensure_valid_utf8(vm)?;
+        }
+
+        if let Some(f) = attributes.get_mut(identifier!(vm, __init_subclass__))
+            && f.class().is(vm.ctx.types.function_type)
+        {
+            *f = PyClassMethod::from(f.clone()).into_pyobject(vm);
+        }
+
+        if let Some(f) = attributes.get_mut(identifier!(vm, __class_getitem__))
+            && f.class().is(vm.ctx.types.function_type)
+        {
+            *f = PyClassMethod::from(f.clone()).into_pyobject(vm);
+        }
+
+        if let Some(f) = attributes.get_mut(identifier!(vm, __new__))
+            && f.class().is(vm.ctx.types.function_type)
+        {
+            *f = PyStaticMethod::from(f.clone()).into_pyobject(vm);
+        }
+
+        if let Some(current_frame) = vm.current_frame() {
+            let entry = attributes.entry(identifier!(vm, __module__));
+            if matches!(entry, Entry::Vacant(_)) {
+                let module_name = vm.unwrap_or_none(
+                    current_frame
+                        .globals
+                        .get_item_opt(identifier!(vm, __name__), vm)?,
+                );
+                entry.or_insert(module_name);
+            }
+        }
+
+        if attributes.get(identifier!(vm, __eq__)).is_some()
+            && attributes.get(identifier!(vm, __hash__)).is_none()
+        {
+            // if __eq__ exists but __hash__ doesn't, overwrite it with None so it doesn't inherit the default hash
+            // https://docs.python.org/3/reference/datamodel.html#object.__hash__
+            attributes.insert(identifier!(vm, __hash__), vm.ctx.none.clone().into());
+        }
+
+        let (heaptype_slots, add_dict): (Option<PyRef<PyTuple<PyStrRef>>>, bool) = if let Some(x) =
+            attributes.get(identifier!(vm, __slots__))
+        {
+            // Check if __slots__ is bytes - not allowed
+            if x.class().is(vm.ctx.types.bytes_type) {
+                return Err(
+                    vm.new_type_error("__slots__ items must be strings, not 'bytes'".to_owned())
+                );
+            }
+
+            let slots = if x.class().is(vm.ctx.types.str_type) {
+                let x = unsafe { x.downcast_unchecked_ref::<PyStr>() };
+                PyTuple::new_ref_typed(vec![x.to_owned()], &vm.ctx)
+            } else {
+                let iter = x.get_iter(vm)?;
+                let elements = {
+                    let mut elements = Vec::new();
+                    while let PyIterReturn::Return(element) = iter.next(vm)? {
+                        // Check if any slot item is bytes
+                        if element.class().is(vm.ctx.types.bytes_type) {
+                            return Err(vm.new_type_error(
+                                "__slots__ items must be strings, not 'bytes'".to_owned(),
+                            ));
+                        }
+                        elements.push(element);
+                    }
+                    elements
+                };
+                let tuple = elements.into_pytuple(vm);
+                tuple.try_into_typed(vm)?
+            };
+
+            // Check if base has itemsize > 0 - can't add arbitrary slots to variable-size types
+            // Types like int, bytes, tuple have itemsize > 0 and don't allow custom slots
+            // But types like weakref.ref have itemsize = 0 and DO allow slots
+            let has_custom_slots = slots
+                .iter()
+                .any(|s| s.as_str() != "__dict__" && s.as_str() != "__weakref__");
+            if has_custom_slots && base.slots.itemsize > 0 {
+                return Err(vm.new_type_error(format!(
+                    "nonempty __slots__ not supported for subtype of '{}'",
+                    base.name()
+                )));
+            }
+
+            // Validate slot names and track duplicates
+            let mut seen_dict = false;
+            let mut seen_weakref = false;
+            for slot in slots.iter() {
+                // Use isidentifier for validation (handles Unicode properly)
+                if !slot.isidentifier() {
+                    return Err(vm.new_type_error("__slots__ must be identifiers".to_owned()));
+                }
+
+                let slot_name = slot.as_str();
+
+                // Check for duplicate __dict__
+                if slot_name == "__dict__" {
+                    if seen_dict {
+                        return Err(vm.new_type_error(
+                            "__dict__ slot disallowed: we already got one".to_owned(),
+                        ));
+                    }
+                    seen_dict = true;
+                }
+
+                // Check for duplicate __weakref__
+                if slot_name == "__weakref__" {
+                    if seen_weakref {
+                        return Err(vm.new_type_error(
+                            "__weakref__ slot disallowed: we already got one".to_owned(),
+                        ));
+                    }
+                    seen_weakref = true;
+                }
+
+                // Check if slot name conflicts with class attributes
+                if attributes.contains_key(vm.ctx.intern_str(slot_name)) {
+                    return Err(vm.new_value_error(format!(
+                        "'{}' in __slots__ conflicts with a class variable",
+                        slot_name
+                    )));
+                }
+            }
+
+            // Check if base class already has __dict__ - can't redefine it
+            if seen_dict && base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+                return Err(
+                    vm.new_type_error("__dict__ slot disallowed: we already got one".to_owned())
+                );
+            }
+
+            // Check if base class already has __weakref__ - can't redefine it
+            // A base has weakref support if:
+            // 1. It's a heap type without explicit __slots__ (automatic weakref), OR
+            // 2. It's a heap type with __weakref__ in its __slots__
+            if seen_weakref {
+                let base_has_weakref = if let Some(ref ext) = base.heaptype_ext {
+                    match &ext.slots {
+                        // Heap type without __slots__ - has automatic weakref
+                        None => true,
+                        // Heap type with __slots__ - check if __weakref__ is in slots
+                        Some(base_slots) => base_slots.iter().any(|s| s.as_str() == "__weakref__"),
+                    }
+                } else {
+                    // 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(),
+                    ));
+                }
+            }
+
+            // Check if __dict__ is in slots
+            let dict_name = "__dict__";
+            let has_dict = slots.iter().any(|s| s.as_str() == dict_name);
+
+            // Filter out __dict__ from slots
+            let filtered_slots = if has_dict {
+                let filtered: Vec<PyStrRef> = slots
+                    .iter()
+                    .filter(|s| s.as_str() != dict_name)
+                    .cloned()
+                    .collect();
+                PyTuple::new_ref_typed(filtered, &vm.ctx)
+            } else {
+                slots
+            };
+
+            (Some(filtered_slots), has_dict)
+        } else {
+            (None, false)
+        };
+
+        // FIXME: this is a temporary fix. multi bases with multiple slots will break object
+        let base_member_count = bases
+            .iter()
+            .map(|base| base.slots.member_count)
+            .max()
+            .unwrap();
+        let heaptype_member_count = heaptype_slots.as_ref().map(|x| x.len()).unwrap_or(0);
+        let member_count: usize = base_member_count + heaptype_member_count;
+
+        let mut flags = PyTypeFlags::heap_type_flags();
+
+        // Check if we may add dict
+        // We can only add a dict if the primary base class doesn't already have one
+        // In CPython, this checks tp_dictoffset == 0
+        let may_add_dict = !base.slots.flags.has_feature(PyTypeFlags::HAS_DICT);
+
+        // Add HAS_DICT and MANAGED_DICT if:
+        // 1. __slots__ is not defined AND base doesn't have dict, OR
+        // 2. __dict__ is in __slots__
+        if (heaptype_slots.is_none() && may_add_dict) || add_dict {
+            flags |= PyTypeFlags::HAS_DICT | PyTypeFlags::MANAGED_DICT;
+        }
+
+        let (slots, heaptype_ext) = {
+            let slots = PyTypeSlots {
+                flags,
+                member_count,
+                itemsize: base.slots.itemsize,
+                ..PyTypeSlots::heap_default()
+            };
+            let heaptype_ext = HeapTypeExt {
+                name: PyRwLock::new(name),
+                qualname: PyRwLock::new(qualname),
+                slots: heaptype_slots.clone(),
+                type_data: PyRwLock::new(None),
+            };
+            (slots, heaptype_ext)
+        };
+
+        let typ = Self::new_heap_inner(
+            base,
+            bases,
+            attributes,
+            slots,
+            heaptype_ext,
+            metatype,
+            &vm.ctx,
+        )
+        .map_err(|e| vm.new_type_error(e))?;
+
+        if let Some(ref slots) = heaptype_slots {
+            let mut offset = base_member_count;
+            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_def = PyMemberDef {
+                    name: mangled_name.clone(),
+                    kind: MemberKind::ObjectEx,
+                    getter: MemberGetter::Offset(offset),
+                    setter: MemberSetter::Offset(offset),
+                    doc: None,
+                };
+                let attr_name = vm.ctx.intern_str(mangled_name.as_str());
+                let member_descriptor: PyRef<PyMemberDescriptor> =
+                    vm.ctx.new_pyref(PyMemberDescriptor {
+                        common: PyDescriptorOwned {
+                            typ: typ.clone(),
+                            name: attr_name,
+                            qualname: PyRwLock::new(None),
+                        },
+                        member: member_def,
+                    });
+                // __slots__ attributes always get a member descriptor
+                // (this overrides any inherited attribute from MRO)
+                typ.set_attr(attr_name, member_descriptor.into());
+                offset += 1;
+            }
+        }
+
+        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()));
+        };
+
+        // All *classes* should have a dict. Exceptions are *instances* of
+        // classes that define __slots__ and instances of built-in classes
+        // (with exceptions, e.g function)
+        // Also, type subclasses don't need their own __dict__ descriptor
+        // since they inherit it from type
+
+        // Add __dict__ descriptor after type creation to ensure correct __objclass__
+        // Only add if:
+        // 1. base is not type (type subclasses inherit __dict__ from type)
+        // 2. the class has HAS_DICT flag (i.e., __slots__ was not defined or __dict__ is in __slots__)
+        // 3. no base class in MRO already provides __dict__ descriptor
+        if !base_is_type && typ.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+            let __dict__ = identifier!(vm, __dict__);
+            let has_inherited_dict = typ
+                .mro
+                .read()
+                .iter()
+                .any(|base| base.attributes.read().contains_key(&__dict__));
+            if !typ.attributes.read().contains_key(&__dict__) && !has_inherited_dict {
+                unsafe {
+                    let descriptor =
+                        vm.ctx
+                            .new_getset("__dict__", &typ, subtype_get_dict, subtype_set_dict);
+                    typ.attributes.write().insert(__dict__, 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
+        {
+            let __doc__ = identifier!(vm, __doc__);
+            if !typ.attributes.read().contains_key(&__doc__) {
+                typ.attributes.write().insert(__doc__, vm.ctx.none());
+            }
+        }
+
+        // avoid deadlock
+        let attributes = typ
+            .attributes
+            .read()
+            .iter()
+            .filter_map(|(name, obj)| {
+                vm.get_method(obj.clone(), identifier!(vm, __set_name__))
+                    .map(|res| res.map(|meth| (obj.clone(), name.to_owned(), meth)))
+            })
+            .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 '{}'",
+                    obj.class().name(),
+                    name,
+                    typ.name()
+                ));
+                err.set___cause__(Some(e));
+                err
+            })?;
+        }
+
+        if let Some(init_subclass) = typ.get_super_attr(identifier!(vm, __init_subclass__)) {
+            let init_subclass = vm
+                .call_get_descriptor_specific(&init_subclass, None, Some(typ.clone().into()))
+                .unwrap_or(Ok(init_subclass))?;
+            init_subclass.call(kwargs, vm)?;
+        };
+
+        Ok(typ.into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+const SIGNATURE_END_MARKER: &str = ")\n--\n\n";
+fn get_signature(doc: &str) -> Option<&str> {
+    doc.find(SIGNATURE_END_MARKER).map(|index| &doc[..=index])
+}
+
+fn find_signature<'a>(name: &str, doc: &'a str) -> Option<&'a str> {
+    let name = name.rsplit('.').next().unwrap();
+    let doc = doc.strip_prefix(name)?;
+    doc.starts_with('(').then_some(doc)
+}
+
+pub(crate) fn get_text_signature_from_internal_doc<'a>(
+    name: &str,
+    internal_doc: &'a str,
+) -> Option<&'a str> {
+    find_signature(name, internal_doc).and_then(get_signature)
+}
+
+// _PyType_GetDocFromInternalDoc in CPython
+fn get_doc_from_internal_doc<'a>(name: &str, internal_doc: &'a str) -> &'a str {
+    // Similar to CPython's _PyType_DocWithoutSignature
+    // If the doc starts with the type name and a '(', it's a signature
+    if let Some(doc_without_sig) = find_signature(name, internal_doc) {
+        // Find where the signature ends
+        if let Some(sig_end_pos) = doc_without_sig.find(SIGNATURE_END_MARKER) {
+            let after_sig = &doc_without_sig[sig_end_pos + SIGNATURE_END_MARKER.len()..];
+            // Return the documentation after the signature, or empty string if none
+            return after_sig;
+        }
+    }
+    // If no signature found, return the whole doc
+    internal_doc
+}
+
+impl Initializer for PyType {
+    type Args = FuncArgs;
+
+    // type_init
+    fn slot_init(_zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        // type.__init__() takes 1 or 3 arguments
+        if args.args.len() == 1 && !args.kwargs.is_empty() {
+            return Err(vm.new_type_error("type.__init__() takes no keyword arguments".to_owned()));
+        }
+        if args.args.len() != 1 && args.args.len() != 3 {
+            return Err(vm.new_type_error("type.__init__() takes 1 or 3 arguments".to_owned()));
+        }
+        Ok(())
+    }
+
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        unreachable!("slot_init is defined")
+    }
+}
+
+impl GetAttr for PyType {
+    fn getattro(zelf: &Py<Self>, name_str: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        #[cold]
+        fn attribute_error(
+            zelf: &Py<PyType>,
+            name: &str,
+            vm: &VirtualMachine,
+        ) -> PyBaseExceptionRef {
+            vm.new_attribute_error(format!(
+                "type object '{}' has no attribute '{}'",
+                zelf.slot_name(),
+                name,
+            ))
+        }
+
+        let Some(name) = vm.ctx.interned_str(name_str) else {
+            return Err(attribute_error(zelf, name_str.as_str(), vm));
+        };
+        vm_trace!("type.__getattribute__({:?}, {:?})", zelf, name);
+        let mcl = zelf.class();
+        let mcl_attr = mcl.get_attr(name);
+
+        if let Some(ref attr) = mcl_attr {
+            let attr_class = attr.class();
+            let has_descr_set = attr_class.slots.descr_set.load().is_some();
+            if has_descr_set {
+                let descr_get = attr_class.slots.descr_get.load();
+                if let Some(descr_get) = descr_get {
+                    let mcl = mcl.to_owned().into();
+                    return descr_get(attr.clone(), Some(zelf.to_owned().into()), Some(mcl), vm);
+                }
+            }
+        }
+
+        let zelf_attr = zelf.get_attr(name);
+
+        if let Some(attr) = zelf_attr {
+            let descr_get = attr.class().slots.descr_get.load();
+            if let Some(descr_get) = descr_get {
+                descr_get(attr, None, Some(zelf.to_owned().into()), vm)
+            } else {
+                Ok(attr)
+            }
+        } 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))
+        }
+    }
+}
+
+#[pyclass]
+impl Py<PyType> {
+    #[pygetset]
+    fn __mro__(&self) -> PyTuple {
+        let elements: Vec<PyObjectRef> = self.mro_map_collect(|x| x.as_object().to_owned());
+        PyTuple::new_unchecked(elements.into_boxed_slice())
+    }
+
+    #[pygetset]
+    fn __doc__(&self, vm: &VirtualMachine) -> PyResult {
+        // Similar to CPython's type_get_doc
+        // For non-heap types (static types), check if there's an internal doc
+        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE)
+            && let Some(internal_doc) = self.slots.doc
+        {
+            // Process internal doc, removing signature if present
+            let doc_str = get_doc_from_internal_doc(&self.name(), internal_doc);
+            return Ok(vm.ctx.new_str(doc_str).into());
+        }
+
+        // Check if there's a __doc__ in THIS type's dict only (not MRO)
+        // CPython returns None if __doc__ is not in the type's own dict
+        if let Some(doc_attr) = self.get_direct_attr(vm.ctx.intern_str("__doc__")) {
+            // If it's a descriptor, call its __get__ method
+            let descr_get = doc_attr.class().slots.descr_get.load();
+            if let Some(descr_get) = descr_get {
+                descr_get(doc_attr, None, Some(self.to_owned().into()), vm)
+            } else {
+                Ok(doc_attr)
+            }
+        } else {
+            Ok(vm.ctx.none())
+        }
+    }
+
+    #[pygetset(setter)]
+    fn set___doc__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
+        // Similar to CPython's type_set_doc
+        let value = value.ok_or_else(|| {
+            vm.new_type_error(format!(
+                "cannot delete '__doc__' attribute of type '{}'",
+                self.name()
+            ))
+        })?;
+
+        // Check if we can set this special type attribute
+        self.check_set_special_type_attr(identifier!(vm, __doc__), vm)?;
+
+        // Set the __doc__ in the type's dict
+        self.attributes
+            .write()
+            .insert(identifier!(vm, __doc__), value);
+
+        Ok(())
+    }
+
+    #[pymethod]
+    fn __dir__(&self) -> PyList {
+        let attributes: Vec<PyObjectRef> = self
+            .get_attributes()
+            .into_iter()
+            .map(|(k, _)| k.to_object())
+            .collect();
+        PyList::from(attributes)
+    }
+
+    #[pymethod]
+    fn __instancecheck__(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        // Use real_is_instance to avoid infinite recursion, matching CPython's behavior
+        obj.real_is_instance(self.as_object(), vm)
+    }
+
+    #[pymethod]
+    fn __subclasscheck__(&self, subclass: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        // Use real_is_subclass to avoid going through __subclasscheck__ recursion
+        // This matches CPython's type___subclasscheck___impl which calls _PyObject_RealIsSubclass
+        subclass.real_is_subclass(self.as_object(), vm)
+    }
+
+    #[pyclassmethod]
+    fn __subclasshook__(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.not_implemented()
+    }
+
+    #[pymethod]
+    fn mro(&self) -> Vec<PyObjectRef> {
+        self.mro_map_collect(|cls| cls.to_owned().into())
+    }
+}
+
+impl SetAttr for PyType {
+    fn setattro(
+        zelf: &Py<Self>,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // TODO: pass PyRefExact instead of &str
+        let attr_name = vm.ctx.intern_str(attr_name.as_str());
+        if let Some(attr) = zelf.get_class_attr(attr_name) {
+            let descr_set = attr.class().slots.descr_set.load();
+            if let Some(descriptor) = descr_set {
+                return descriptor(&attr, zelf.to_owned().into(), value, vm);
+            }
+        }
+        let assign = value.is_assign();
+
+        if let PySetterValue::Assign(value) = value {
+            zelf.attributes.write().insert(attr_name, value);
+        } else {
+            let prev_value = zelf.attributes.write().shift_remove(attr_name); // TODO: swap_remove applicable?
+            if prev_value.is_none() {
+                return Err(vm.new_attribute_error(format!(
+                    "type object '{}' has no attribute '{}'",
+                    zelf.name(),
+                    attr_name.as_str(),
+                )));
+            }
+        }
+        if attr_name.as_str().starts_with("__") && attr_name.as_str().ends_with("__") {
+            if assign {
+                zelf.update_slot::<true>(attr_name, &vm.ctx);
+            } else {
+                zelf.update_slot::<false>(attr_name, &vm.ctx);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Callable for PyType {
+    type Args = FuncArgs;
+    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        vm_trace!("type_call: {:?}", zelf);
+
+        if zelf.is(vm.ctx.types.type_type) {
+            let num_args = args.args.len();
+            if num_args == 1 && args.kwargs.is_empty() {
+                return Ok(args.args[0].obj_type());
+            }
+            if num_args != 3 {
+                return Err(vm.new_type_error("type() takes 1 or 3 arguments".to_owned()));
+            }
+        }
+
+        let obj = if let Some(slot_new) = zelf.slots.new.load() {
+            slot_new(zelf.to_owned(), args.clone(), vm)?
+        } else {
+            return Err(vm.new_type_error(format!("cannot create '{}' instances", zelf.slots.name)));
+        };
+
+        if !obj.class().fast_issubclass(zelf) {
+            return Ok(obj);
+        }
+
+        if let Some(init_method) = obj.class().slots.init.load() {
+            init_method(obj.clone(), args, vm)?;
+        }
+        Ok(obj)
+    }
+}
+
+impl AsNumber for PyType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            or: Some(|a, b, vm| or_(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+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 repr = match module {
+            Some(module) if module != "builtins" => {
+                let name = zelf.name();
+                format!(
+                    "<class '{}.{}'>",
+                    module,
+                    zelf.__qualname__(vm)
+                        .downcast_ref::<PyStr>()
+                        .map(|n| n.as_str())
+                        .unwrap_or_else(|| &name)
+                )
+            }
+            _ => format!("<class '{}'>", zelf.slot_name()),
+        };
+        Ok(repr)
+    }
+}
+
+// = get_builtin_base_with_dict
+fn get_builtin_base_with_dict(typ: &Py<PyType>, vm: &VirtualMachine) -> Option<PyTypeRef> {
+    let mut current = Some(typ.to_owned());
+    while let Some(t) = current {
+        // In CPython: type->tp_dictoffset != 0 && !(type->tp_flags & Py_TPFLAGS_HEAPTYPE)
+        // Special case: type itself is a builtin with dict support
+        if t.is(vm.ctx.types.type_type) {
+            return Some(t);
+        }
+        // We check HAS_DICT flag (equivalent to tp_dictoffset != 0) and HEAPTYPE
+        if t.slots.flags.contains(PyTypeFlags::HAS_DICT)
+            && !t.slots.flags.contains(PyTypeFlags::HEAPTYPE)
+        {
+            return Some(t);
+        }
+        current = t.__base__();
+    }
+    None
+}
+
+// = get_dict_descriptor
+fn get_dict_descriptor(base: &Py<PyType>, vm: &VirtualMachine) -> Option<PyObjectRef> {
+    let dict_attr = identifier!(vm, __dict__);
+    // Use _PyType_Lookup (which is lookup_ref in RustPython)
+    base.lookup_ref(dict_attr, vm)
+}
+
+// = raise_dict_descr_error
+fn raise_dict_descriptor_error(obj: &PyObject, vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_type_error(format!(
+        "this __dict__ descriptor does not support '{}' objects",
+        obj.class().name()
+    ))
+}
+
+fn subtype_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let base = get_builtin_base_with_dict(obj.class(), vm);
+
+    if let Some(base_type) = base {
+        if let Some(descr) = get_dict_descriptor(&base_type, vm) {
+            // Call the descriptor's tp_descr_get
+            vm.call_get_descriptor(&descr, obj.clone())
+                .unwrap_or_else(|| Err(raise_dict_descriptor_error(&obj, vm)))
+        } else {
+            Err(raise_dict_descriptor_error(&obj, vm))
+        }
+    } else {
+        // PyObject_GenericGetDict
+        object::object_get_dict(obj, vm).map(Into::into)
+    }
+}
+
+// = subtype_setdict
+fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    let base = get_builtin_base_with_dict(obj.class(), vm);
+
+    if let Some(base_type) = base {
+        if let Some(descr) = get_dict_descriptor(&base_type, vm) {
+            // Call the descriptor's tp_descr_set
+            let descr_set = descr
+                .class()
+                .slots
+                .descr_set
+                .load()
+                .ok_or_else(|| raise_dict_descriptor_error(&obj, vm))?;
+            descr_set(&descr, obj, PySetterValue::Assign(value), vm)
+        } else {
+            Err(raise_dict_descriptor_error(&obj, vm))
+        }
+    } else {
+        // PyObject_GenericSetDict
+        object::object_set_dict(obj, value.try_into_value(vm)?, vm)?;
+        Ok(())
+    }
+}
+
+/*
+ * The magical type type
+ */
+
+pub(crate) fn init(ctx: &Context) {
+    PyType::extend_class(ctx, ctx.types.type_type);
+}
+
+pub(crate) fn call_slot_new(
+    typ: PyTypeRef,
+    subtype: PyTypeRef,
+    args: FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // Check DISALLOW_INSTANTIATION flag on subtype (the type being instantiated)
+    if subtype
+        .slots
+        .flags
+        .has_feature(PyTypeFlags::DISALLOW_INSTANTIATION)
+    {
+        return Err(vm.new_type_error(format!("cannot create '{}' instances", subtype.slot_name())));
+    }
+
+    // "is not safe" check (tp_new_wrapper logic)
+    // Check that the user doesn't do something silly and unsafe like
+    // object.__new__(dict). To do this, we check that the most derived base
+    // that's not a heap type is this type.
+    let mut staticbase = subtype.clone();
+    while staticbase.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
+        if let Some(base) = staticbase.base.as_ref() {
+            staticbase = base.clone();
+        } else {
+            break;
+        }
+    }
+
+    // Check if staticbase's tp_new differs from typ's tp_new
+    let typ_new = typ.slots.new.load();
+    let staticbase_new = staticbase.slots.new.load();
+    if typ_new.map(|f| f as usize) != staticbase_new.map(|f| f as usize) {
+        return Err(vm.new_type_error(format!(
+            "{}.__new__({}) is not safe, use {}.__new__()",
+            typ.slot_name(),
+            subtype.slot_name(),
+            staticbase.slot_name()
+        )));
+    }
+
+    let slot_new = typ
+        .slots
+        .new
+        .load()
+        .expect("Should be able to find a new slot somewhere in the mro");
+    slot_new(subtype, args, vm)
+}
+
+pub(crate) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+    if !union_::is_unionable(zelf.clone(), vm) || !union_::is_unionable(other.clone(), vm) {
+        return vm.ctx.not_implemented();
+    }
+
+    let tuple = PyTuple::new_ref(vec![zelf, other], &vm.ctx);
+    union_::make_union(&tuple, vm)
+}
+
+fn take_next_base(bases: &mut [Vec<PyTypeRef>]) -> Option<PyTypeRef> {
+    for base in bases.iter() {
+        let head = base[0].clone();
+        if !bases.iter().any(|x| x[1..].iter().any(|x| x.is(&head))) {
+            // Remove from other heads.
+            for item in bases.iter_mut() {
+                if item[0].is(&head) {
+                    item.remove(0);
+                }
+            }
+
+            return Some(head);
+        }
+    }
+
+    None
+}
+
+fn linearise_mro(mut bases: Vec<Vec<PyTypeRef>>) -> Result<Vec<PyTypeRef>, String> {
+    vm_trace!("Linearise MRO: {:?}", bases);
+    // Python requires that the class direct bases are kept in the same order.
+    // This is called local precedence ordering.
+    // This means we must verify that for classes A(), B(A) we must reject C(A, B) even though this
+    // algorithm will allow the mro ordering of [C, B, A, object].
+    // To verify this, we make sure non of the direct bases are in the mro of bases after them.
+    for (i, base_mro) in bases.iter().enumerate() {
+        let base = &base_mro[0]; // MROs cannot be empty.
+        for later_mro in &bases[i + 1..] {
+            // 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(),
+                );
+            }
+        }
+    }
+
+    let mut result = vec![];
+    while !bases.is_empty() {
+        let head = take_next_base(&mut bases).ok_or_else(|| {
+            // Take the head class of each class here. Now that we have reached the problematic bases.
+            // Because this failed, we assume the lists cannot be empty.
+            format!(
+                "Cannot create a consistent method resolution order (MRO) for bases {}",
+                bases.iter().map(|x| x.first().unwrap()).format(", ")
+            )
+        })?;
+
+        result.push(head);
+
+        bases.retain(|x| !x.is_empty());
+    }
+    Ok(result)
+}
+
+fn calculate_meta_class(
+    metatype: PyTypeRef,
+    bases: &[PyTypeRef],
+    vm: &VirtualMachine,
+) -> PyResult<PyTypeRef> {
+    // = _PyType_CalculateMetaclass
+    let mut winner = metatype;
+    for base in bases {
+        let base_type = base.class();
+
+        // First try fast_issubclass for PyType instances
+        if winner.fast_issubclass(base_type) {
+            continue;
+        } else if base_type.fast_issubclass(&winner) {
+            winner = base_type.to_owned();
+            continue;
+        }
+
+        // If fast_issubclass didn't work, fall back to general is_subclass
+        // This handles cases where metaclasses are not PyType subclasses
+        let winner_is_subclass = winner.as_object().is_subclass(base_type.as_object(), vm)?;
+        if winner_is_subclass {
+            continue;
+        }
+
+        let base_type_is_subclass = base_type.as_object().is_subclass(winner.as_object(), vm)?;
+        if base_type_is_subclass {
+            winner = base_type.to_owned();
+            continue;
+        }
+
+        return Err(vm.new_type_error(
+            "metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass \
+             of the metaclasses of all its bases",
+        ));
+    }
+    Ok(winner)
+}
+
+/// Returns true if the two types have different instance layouts.
+fn shape_differs(t1: &Py<PyType>, t2: &Py<PyType>) -> bool {
+    t1.__basicsize__() != t2.__basicsize__() || t1.slots.itemsize != t2.slots.itemsize
+}
+
+fn solid_base<'a>(typ: &'a Py<PyType>, vm: &VirtualMachine) -> &'a Py<PyType> {
+    let base = if let Some(base) = &typ.base {
+        solid_base(base, vm)
+    } else {
+        vm.ctx.types.object_type
+    };
+
+    if shape_differs(typ, base) { typ } else { base }
+}
+
+fn best_base<'a>(bases: &'a [PyTypeRef], vm: &VirtualMachine) -> PyResult<&'a Py<PyType>> {
+    let mut base: Option<&Py<PyType>> = None;
+    let mut winner: Option<&Py<PyType>> = None;
+
+    for base_i in bases {
+        // if !base_i.fast_issubclass(vm.ctx.types.type_type) {
+        //     println!("base_i type : {}", base_i.name());
+        //     return Err(vm.new_type_error("best must be types".into()));
+        // }
+
+        if !base_i.slots.flags.has_feature(PyTypeFlags::BASETYPE) {
+            return Err(vm.new_type_error(format!(
+                "type '{}' is not an acceptable base type",
+                base_i.slot_name()
+            )));
+        }
+
+        let candidate = solid_base(base_i, vm);
+        if winner.is_none() {
+            winner = Some(candidate);
+            base = Some(base_i.deref());
+        } else if winner.unwrap().fast_issubclass(candidate) {
+            // Do nothing
+        } else if candidate.fast_issubclass(winner.unwrap()) {
+            winner = Some(candidate);
+            base = Some(base_i.deref());
+        } else {
+            return Err(vm.new_type_error("multiple bases have instance layout conflict"));
+        }
+    }
+
+    debug_assert!(base.is_some());
+    Ok(base.unwrap())
+}
+
+/// Apply Python name mangling for private attributes.
+/// `__x` becomes `_ClassName__x` if inside a class.
+fn mangle_name(class_name: &str, name: &str) -> String {
+    // Only mangle names starting with __ and not ending with __
+    if !name.starts_with("__") || name.ends_with("__") || name.contains('.') {
+        return name.to_string();
+    }
+    // Strip leading underscores from class name
+    let class_name = class_name.trim_start_matches('_');
+    format!("_{}{}", class_name, name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn map_ids(obj: Result<Vec<PyTypeRef>, String>) -> Result<Vec<usize>, String> {
+        Ok(obj?.into_iter().map(|x| x.get_id()).collect())
+    }
+
+    #[test]
+    fn test_linearise() {
+        let context = Context::genesis();
+        let object = context.types.object_type.to_owned();
+        let type_type = context.types.type_type.to_owned();
+
+        let a = PyType::new_heap(
+            "A",
+            vec![object.clone()],
+            PyAttributes::default(),
+            Default::default(),
+            type_type.clone(),
+            context,
+        )
+        .unwrap();
+        let b = PyType::new_heap(
+            "B",
+            vec![object.clone()],
+            PyAttributes::default(),
+            Default::default(),
+            type_type,
+            context,
+        )
+        .unwrap();
+
+        assert_eq!(
+            map_ids(linearise_mro(vec![
+                vec![object.clone()],
+                vec![object.clone()]
+            ])),
+            map_ids(Ok(vec![object.clone()]))
+        );
+        assert_eq!(
+            map_ids(linearise_mro(vec![
+                vec![a.clone(), object.clone()],
+                vec![b.clone(), object.clone()],
+            ])),
+            map_ids(Ok(vec![a, b, object]))
+        );
+    }
+}
diff --git a/crates/vm/src/builtins/union.rs b/crates/vm/src/builtins/union.rs
new file mode 100644
index 0000000000..b5e12dcb3c
--- /dev/null
+++ b/crates/vm/src/builtins/union.rs
@@ -0,0 +1,315 @@
+use super::{genericalias, type_};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    atomic_func,
+    builtins::{PyFrozenSet, PyGenericAlias, PyStr, PyTuple, PyTupleRef, PyType},
+    class::PyClassImpl,
+    common::hash,
+    convert::{ToPyObject, ToPyResult},
+    function::PyComparisonValue,
+    protocol::{PyMappingMethods, PyNumberMethods},
+    stdlib::typing::TypeAliasType,
+    types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable},
+};
+use alloc::fmt;
+use std::sync::LazyLock;
+
+const CLS_ATTRS: &[&str] = &["__module__"];
+
+#[pyclass(module = "types", name = "UnionType", traverse)]
+pub struct PyUnion {
+    args: PyTupleRef,
+    parameters: PyTupleRef,
+}
+
+impl fmt::Debug for PyUnion {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("UnionObject")
+    }
+}
+
+impl PyPayload for PyUnion {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.union_type
+    }
+}
+
+impl PyUnion {
+    pub fn new(args: PyTupleRef, vm: &VirtualMachine) -> Self {
+        let parameters = make_parameters(&args, vm);
+        Self { args, parameters }
+    }
+
+    /// Direct access to args field, matching CPython's _Py_union_args
+    #[inline]
+    pub fn args(&self) -> &Py<PyTuple> {
+        &self.args
+    }
+
+    fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
+        fn repr_item(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
+            if obj.is(vm.ctx.types.none_type) {
+                return Ok("None".to_string());
+            }
+
+            if vm
+                .get_attribute_opt(obj.clone(), identifier!(vm, __origin__))?
+                .is_some()
+                && vm
+                    .get_attribute_opt(obj.clone(), identifier!(vm, __args__))?
+                    .is_some()
+            {
+                return Ok(obj.repr(vm)?.to_string());
+            }
+
+            match (
+                vm.get_attribute_opt(obj.clone(), identifier!(vm, __qualname__))?
+                    .and_then(|o| o.downcast_ref::<PyStr>().map(|n| n.to_string())),
+                vm.get_attribute_opt(obj.clone(), identifier!(vm, __module__))?
+                    .and_then(|o| o.downcast_ref::<PyStr>().map(|m| m.to_string())),
+            ) {
+                (None, _) | (_, None) => Ok(obj.repr(vm)?.to_string()),
+                (Some(qualname), Some(module)) => Ok(if module == "builtins" {
+                    qualname
+                } else {
+                    format!("{module}.{qualname}")
+                }),
+            }
+        }
+
+        Ok(self
+            .args
+            .iter()
+            .map(|o| repr_item(o.clone(), vm))
+            .collect::<PyResult<Vec<_>>>()?
+            .join(" | "))
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE),
+    with(Hashable, Comparable, AsMapping, AsNumber, Representable)
+)]
+impl PyUnion {
+    #[pygetset]
+    fn __parameters__(&self) -> PyObjectRef {
+        self.parameters.clone().into()
+    }
+
+    #[pygetset]
+    fn __args__(&self) -> PyObjectRef {
+        self.args.clone().into()
+    }
+
+    #[pymethod]
+    fn __instancecheck__(
+        zelf: PyRef<Self>,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        if zelf
+            .args
+            .iter()
+            .any(|x| x.class().is(vm.ctx.types.generic_alias_type))
+        {
+            Err(vm.new_type_error("isinstance() argument 2 cannot be a parameterized generic"))
+        } else {
+            obj.is_instance(zelf.__args__().as_object(), vm)
+        }
+    }
+
+    #[pymethod]
+    fn __subclasscheck__(
+        zelf: PyRef<Self>,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        if zelf
+            .args
+            .iter()
+            .any(|x| x.class().is(vm.ctx.types.generic_alias_type))
+        {
+            Err(vm.new_type_error("issubclass() argument 2 cannot be a parameterized generic"))
+        } else {
+            obj.is_subclass(zelf.__args__().as_object(), vm)
+        }
+    }
+
+    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+        type_::or_(zelf, other, vm)
+    }
+
+    #[pyclassmethod]
+    fn __class_getitem__(
+        cls: crate::builtins::PyTypeRef,
+        args: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+}
+
+pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
+    let cls = obj.class();
+    cls.is(vm.ctx.types.none_type)
+        || obj.downcastable::<PyType>()
+        || cls.fast_issubclass(vm.ctx.types.generic_alias_type)
+        || cls.is(vm.ctx.types.union_type)
+        || obj.downcast_ref::<TypeAliasType>().is_some()
+}
+
+fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+    let parameters = genericalias::make_parameters(args, vm);
+    dedup_and_flatten_args(&parameters, vm)
+}
+
+fn flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+    let mut total_args = 0;
+    for arg in args {
+        if let Some(pyref) = arg.downcast_ref::<PyUnion>() {
+            total_args += pyref.args.len();
+        } else {
+            total_args += 1;
+        };
+    }
+
+    let mut flattened_args = Vec::with_capacity(total_args);
+    for arg in args {
+        if let Some(pyref) = arg.downcast_ref::<PyUnion>() {
+            flattened_args.extend(pyref.args.iter().cloned());
+        } else if vm.is_none(arg) {
+            flattened_args.push(vm.ctx.types.none_type.to_owned().into());
+        } else {
+            flattened_args.push(arg.clone());
+        };
+    }
+
+    PyTuple::new_ref(flattened_args, &vm.ctx)
+}
+
+fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+    let args = flatten_args(args, vm);
+
+    let mut new_args: Vec<PyObjectRef> = Vec::with_capacity(args.len());
+    for arg in &*args {
+        if !new_args.iter().any(|param| {
+            param
+                .rich_compare_bool(arg, PyComparisonOp::Eq, vm)
+                .unwrap_or_default()
+        }) {
+            new_args.push(arg.clone());
+        }
+    }
+
+    new_args.shrink_to_fit();
+
+    PyTuple::new_ref(new_args, &vm.ctx)
+}
+
+pub fn make_union(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyObjectRef {
+    let args = dedup_and_flatten_args(args, vm);
+    match args.len() {
+        1 => args[0].to_owned(),
+        _ => PyUnion::new(args, vm).to_pyobject(vm),
+    }
+}
+
+impl PyUnion {
+    fn getitem(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let new_args = genericalias::subs_parameters(
+            zelf.to_owned().into(),
+            zelf.args.clone(),
+            zelf.parameters.clone(),
+            needle,
+            vm,
+        )?;
+        let mut res;
+        if new_args.is_empty() {
+            res = make_union(&new_args, vm);
+        } else {
+            res = new_args[0].to_owned();
+            for arg in new_args.iter().skip(1) {
+                res = vm._or(&res, arg)?;
+            }
+        }
+
+        Ok(res)
+    }
+}
+
+impl AsMapping for PyUnion {
+    fn as_mapping() -> &'static PyMappingMethods {
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            subscript: atomic_func!(|mapping, needle, vm| {
+                let zelf = PyUnion::mapping_downcast(mapping);
+                PyUnion::getitem(zelf.to_owned(), needle.to_owned(), vm)
+            }),
+            ..PyMappingMethods::NOT_IMPLEMENTED
+        });
+        &AS_MAPPING
+    }
+}
+
+impl AsNumber for PyUnion {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            or: Some(|a, b, vm| PyUnion::__or__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl Comparable for PyUnion {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let a = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
+            let b = PyFrozenSet::from_iter(vm, other.args.into_iter().cloned())?;
+            Ok(PyComparisonValue::Implemented(
+                a.into_pyobject(vm).as_object().rich_compare_bool(
+                    b.into_pyobject(vm).as_object(),
+                    PyComparisonOp::Eq,
+                    vm,
+                )?,
+            ))
+        })
+    }
+}
+
+impl Hashable for PyUnion {
+    #[inline]
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
+        let set = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
+        PyFrozenSet::hash(&set.into_ref(&vm.ctx), vm)
+    }
+}
+
+impl GetAttr for PyUnion {
+    fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        for &exc in CLS_ATTRS {
+            if *exc == attr.to_string() {
+                return zelf.as_object().generic_getattr(attr, vm);
+            }
+        }
+        zelf.as_object().get_attr(attr, vm)
+    }
+}
+
+impl Representable for PyUnion {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        zelf.repr(vm)
+    }
+}
+
+pub fn init(context: &Context) {
+    let union_type = &context.types.union_type;
+    PyUnion::extend_class(context, union_type);
+}
diff --git a/vm/src/builtins/weakproxy.rs b/crates/vm/src/builtins/weakproxy.rs
similarity index 86%
rename from vm/src/builtins/weakproxy.rs
rename to crates/vm/src/builtins/weakproxy.rs
index 6f01e5eb22..0f68e9e981 100644
--- a/vm/src/builtins/weakproxy.rs
+++ b/crates/vm/src/builtins/weakproxy.rs
@@ -4,11 +4,11 @@ use crate::{
     class::PyClassImpl,
     common::hash::PyHash,
     function::{OptionalArg, PyComparisonValue, PySetterValue},
-    protocol::{PyIter, PyIterReturn, PyMappingMethods, PySequenceMethods},
+    protocol::{PyIter, PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
     stdlib::builtins::reversed,
     types::{
-        AsMapping, AsSequence, Comparable, Constructor, GetAttr, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SetAttr,
+        AsMapping, AsNumber, AsSequence, Comparable, Constructor, GetAttr, Hashable, IterNext,
+        Iterable, PyComparisonOp, Representable, SetAttr,
     },
 };
 use std::sync::LazyLock;
@@ -38,10 +38,10 @@ impl Constructor for PyWeakProxy {
     type Args = WeakProxyNewArgs;
 
     fn py_new(
-        cls: PyTypeRef,
+        _cls: &Py<PyType>,
         Self::Args { referent, callback }: Self::Args,
         vm: &VirtualMachine,
-    ) -> PyResult {
+    ) -> PyResult<Self> {
         // using an internal subclass as the class prevents us from getting the generic weakref,
         // which would mess up the weakref count
         let weak_cls = WEAK_SUBCLASS.get_or_init(|| {
@@ -53,11 +53,9 @@ impl Constructor for PyWeakProxy {
             )
         });
         // TODO: PyWeakProxy should use the same payload as PyWeak
-        Self {
+        Ok(Self {
             weak: referent.downgrade_with_typ(callback.into_option(), weak_cls.clone(), vm)?,
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
+        })
     }
 }
 
@@ -70,6 +68,7 @@ crate::common::static_cell! {
     SetAttr,
     Constructor,
     Comparable,
+    AsNumber,
     AsSequence,
     AsMapping,
     Representable,
@@ -81,19 +80,14 @@ impl PyWeakProxy {
     }
 
     #[pymethod]
-    fn __str__(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        self.try_upgrade(vm)?.str(vm)
+    fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        zelf.try_upgrade(vm)?.str(vm)
     }
 
     fn len(&self, vm: &VirtualMachine) -> PyResult<usize> {
         self.try_upgrade(vm)?.length(vm)
     }
 
-    #[pymethod]
-    fn __bool__(&self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.try_upgrade(vm)?.is_true(vm)
-    }
-
     #[pymethod]
     fn __bytes__(&self, vm: &VirtualMachine) -> PyResult {
         self.try_upgrade(vm)?.bytes(vm)
@@ -104,9 +98,10 @@ impl PyWeakProxy {
         let obj = self.try_upgrade(vm)?;
         reversed(obj, vm)
     }
-    #[pymethod]
     fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self.try_upgrade(vm)?.to_sequence().contains(&needle, vm)
+        self.try_upgrade(vm)?
+            .sequence_unchecked()
+            .contains(&needle, vm)
     }
 
     fn getitem(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
@@ -171,6 +166,19 @@ impl SetAttr for PyWeakProxy {
     }
 }
 
+impl AsNumber for PyWeakProxy {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: LazyLock<PyNumberMethods> = LazyLock::new(|| PyNumberMethods {
+            boolean: Some(|number, vm| {
+                let zelf = number.obj.downcast_ref::<PyWeakProxy>().unwrap();
+                zelf.try_upgrade(vm)?.is_true(vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        });
+        &AS_NUMBER
+    }
+}
+
 impl Comparable for PyWeakProxy {
     fn cmp(
         zelf: &Py<Self>,
diff --git a/crates/vm/src/builtins/weakref.rs b/crates/vm/src/builtins/weakref.rs
new file mode 100644
index 0000000000..327c0fd148
--- /dev/null
+++ b/crates/vm/src/builtins/weakref.rs
@@ -0,0 +1,145 @@
+use super::{PyGenericAlias, PyType, PyTypeRef};
+use crate::common::{
+    atomic::{Ordering, Radium},
+    hash::{self, PyHash},
+};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    class::PyClassImpl,
+    function::{FuncArgs, OptionalArg},
+    types::{
+        Callable, Comparable, Constructor, Hashable, Initializer, PyComparisonOp, Representable,
+    },
+};
+
+pub use crate::object::PyWeak;
+
+#[derive(FromArgs)]
+pub struct WeakNewArgs {
+    #[pyarg(positional)]
+    referent: PyObjectRef,
+    #[pyarg(positional, optional)]
+    callback: OptionalArg<PyObjectRef>,
+}
+
+impl PyPayload for PyWeak {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.weakref_type
+    }
+}
+
+impl Callable for PyWeak {
+    type Args = ();
+    #[inline]
+    fn call(zelf: &Py<Self>, _: Self::Args, vm: &VirtualMachine) -> PyResult {
+        Ok(vm.unwrap_or_none(zelf.upgrade()))
+    }
+}
+
+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)?;
+        Ok(weak.into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyWeak {
+    type Args = WeakNewArgs;
+
+    // weakref_tp_init: accepts args but does nothing (all init done in slot_new)
+    fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+        Ok(())
+    }
+}
+
+#[pyclass(
+    with(
+        Callable,
+        Hashable,
+        Comparable,
+        Constructor,
+        Initializer,
+        Representable
+    ),
+    flags(BASETYPE)
+)]
+impl PyWeak {
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+}
+
+impl Hashable for PyWeak {
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
+        let hash = match zelf.hash.load(Ordering::Relaxed) {
+            hash::SENTINEL => {
+                let obj = zelf
+                    .upgrade()
+                    .ok_or_else(|| vm.new_type_error("weak object has gone away"))?;
+                let hash = obj.hash(vm)?;
+                match Radium::compare_exchange(
+                    &zelf.hash,
+                    hash::SENTINEL,
+                    hash::fix_sentinel(hash),
+                    Ordering::Relaxed,
+                    Ordering::Relaxed,
+                ) {
+                    Ok(_) => hash,
+                    Err(prev_stored) => prev_stored,
+                }
+            }
+            hash => hash,
+        };
+        Ok(hash)
+    }
+}
+
+impl Comparable for PyWeak {
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<crate::function::PyComparisonValue> {
+        op.eq_only(|| {
+            let other = class_or_notimplemented!(Self, other);
+            let both = zelf.upgrade().and_then(|s| other.upgrade().map(|o| (s, o)));
+            let eq = match both {
+                Some((a, b)) => vm.bool_eq(&a, &b)?,
+                None => zelf.is(other),
+            };
+            Ok(eq.into())
+        })
+    }
+}
+
+impl Representable for PyWeak {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        let id = zelf.get_id();
+        let repr = if let Some(o) = zelf.upgrade() {
+            format!(
+                "<weakref at {:#x}; to '{}' at {:#x}>",
+                id,
+                o.class().name(),
+                o.get_id(),
+            )
+        } else {
+            format!("<weakref at {id:#x}; dead>")
+        };
+        Ok(repr)
+    }
+}
+
+pub fn init(context: &Context) {
+    PyWeak::extend_class(context, context.types.weakref_type);
+}
diff --git a/vm/src/builtins/zip.rs b/crates/vm/src/builtins/zip.rs
similarity index 94%
rename from vm/src/builtins/zip.rs
rename to crates/vm/src/builtins/zip.rs
index 98371d2f6c..ee3ecb57b2 100644
--- a/vm/src/builtins/zip.rs
+++ b/crates/vm/src/builtins/zip.rs
@@ -1,4 +1,4 @@
-use super::{PyType, PyTypeRef};
+use super::PyType;
 use crate::{
     AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::PyTupleRef,
@@ -33,12 +33,14 @@ pub struct PyZipNewArgs {
 impl Constructor for PyZip {
     type Args = (PosArgs<PyIter>, PyZipNewArgs);
 
-    fn py_new(cls: PyTypeRef, (iterators, args): Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn py_new(
+        _cls: &Py<PyType>,
+        (iterators, args): Self::Args,
+        _vm: &VirtualMachine,
+    ) -> PyResult<Self> {
         let iterators = iterators.into_vec();
         let strict = Radium::new(args.strict.unwrap_or(false));
-        Self { iterators, strict }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+        Ok(Self { iterators, strict })
     }
 }
 
diff --git a/vm/src/byte.rs b/crates/vm/src/byte.rs
similarity index 78%
rename from vm/src/byte.rs
rename to crates/vm/src/byte.rs
index db3f93ba32..d9e927cbfa 100644
--- a/vm/src/byte.rs
+++ b/crates/vm/src/byte.rs
@@ -8,10 +8,10 @@ pub fn bytes_from_object(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Vec<u8
         return Ok(elements);
     }
 
-    if !obj.fast_isinstance(vm.ctx.types.str_type) {
-        if let Ok(elements) = vm.map_iterable_object(obj, |x| value_from_object(vm, &x)) {
-            return elements;
-        }
+    if !obj.fast_isinstance(vm.ctx.types.str_type)
+        && let Ok(elements) = vm.map_iterable_object(obj, |x| value_from_object(vm, &x))
+    {
+        return elements;
     }
 
     Err(vm.new_type_error("can assign only bytes, buffers, or iterables of ints in range(0, 256)"))
diff --git a/vm/src/bytes_inner.rs b/crates/vm/src/bytes_inner.rs
similarity index 93%
rename from vm/src/bytes_inner.rs
rename to crates/vm/src/bytes_inner.rs
index db1e843091..bb5db442c3 100644
--- a/vm/src/bytes_inner.rs
+++ b/crates/vm/src/bytes_inner.rs
@@ -1,16 +1,15 @@
 // spell-checker:ignore unchunked
 use crate::{
-    AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
+    AsObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine,
     anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper},
     builtins::{
         PyBaseExceptionRef, PyByteArray, PyBytes, PyBytesRef, PyInt, PyIntRef, PyStr, PyStrRef,
-        PyTypeRef, pystr,
+        pystr,
     },
     byte::bytes_from_object,
     cformat::cformat_bytes,
     common::hash,
     function::{ArgIterable, Either, OptionalArg, OptionalOption, PyComparisonValue},
-    identifier,
     literal::escape::Escape,
     protocol::PyBuffer,
     sequence::{SequenceExt, SequenceMutExt},
@@ -91,43 +90,6 @@ impl ByteInnerNewOptions {
         })
     }
 
-    pub fn get_bytes(self, cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-        let inner = match (&self.source, &self.encoding, &self.errors) {
-            (OptionalArg::Present(obj), OptionalArg::Missing, OptionalArg::Missing) => {
-                let obj = obj.clone();
-                // construct an exact bytes from an exact bytes do not clone
-                let obj = if cls.is(vm.ctx.types.bytes_type) {
-                    match obj.downcast_exact::<PyBytes>(vm) {
-                        Ok(b) => return Ok(b.into_pyref()),
-                        Err(obj) => obj,
-                    }
-                } else {
-                    obj
-                };
-
-                if let Some(bytes_method) = vm.get_method(obj, identifier!(vm, __bytes__)) {
-                    // construct an exact bytes from __bytes__ slot.
-                    // if __bytes__ return a bytes, use the bytes object except we are the subclass of the bytes
-                    let bytes = bytes_method?.call((), vm)?;
-                    let bytes = if cls.is(vm.ctx.types.bytes_type) {
-                        match bytes.downcast::<PyBytes>() {
-                            Ok(b) => return Ok(b),
-                            Err(bytes) => bytes,
-                        }
-                    } else {
-                        bytes
-                    };
-                    Some(PyBytesInner::try_from_borrowed_object(vm, &bytes))
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-        .unwrap_or_else(|| self.get_bytearray_inner(vm))?;
-        PyBytes::from(inner).into_ref_with_type(vm, cls)
-    }
-
     pub fn get_bytearray_inner(self, vm: &VirtualMachine) -> PyResult<PyBytesInner> {
         match (self.source, self.encoding, self.errors) {
             (OptionalArg::Present(obj), OptionalArg::Missing, OptionalArg::Missing) => {
@@ -189,7 +151,7 @@ impl ByteInnerFindOptions {
         self,
         len: usize,
         vm: &VirtualMachine,
-    ) -> PyResult<(Vec<u8>, std::ops::Range<usize>)> {
+    ) -> PyResult<(Vec<u8>, core::ops::Range<usize>)> {
         let sub = match self.sub {
             Either::A(v) => v.elements.to_vec(),
             Either::B(int) => vec![int.as_bigint().byte_or(vm)?],
@@ -459,11 +421,11 @@ impl PyBytesInner {
         bytes_to_hex(self.elements.as_slice(), sep, bytes_per_sep, vm)
     }
 
-    pub fn fromhex(string: &str, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        let mut iter = string.bytes().enumerate();
-        let mut bytes: Vec<u8> = Vec::with_capacity(string.len() / 2);
+    pub fn fromhex(bytes: &[u8], vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        let mut iter = bytes.iter().enumerate();
+        let mut bytes: Vec<u8> = Vec::with_capacity(bytes.len() / 2);
         let i = loop {
-            let (i, b) = match iter.next() {
+            let (i, &b) = match iter.next() {
                 Some(val) => val,
                 None => {
                     return Ok(bytes);
@@ -757,7 +719,7 @@ impl PyBytesInner {
     // len(self)>=1, from="", len(to)>=1, max_count>=1
     fn replace_interleave(&self, to: Self, max_count: Option<usize>) -> Vec<u8> {
         let place_count = self.elements.len() + 1;
-        let count = max_count.map_or(place_count, |v| std::cmp::min(v, place_count)) - 1;
+        let count = max_count.map_or(place_count, |v| core::cmp::min(v, place_count)) - 1;
         let capacity = self.elements.len() + count * to.len();
         let mut result = Vec::with_capacity(capacity);
         let to_slice = to.elements.as_slice();
@@ -990,7 +952,7 @@ where
 fn count_substring(haystack: &[u8], needle: &[u8], max_count: Option<usize>) -> usize {
     let substrings = haystack.find_iter(needle);
     if let Some(max_count) = max_count {
-        std::cmp::min(substrings.take(max_count).count(), max_count)
+        core::cmp::min(substrings.take(max_count).count(), max_count)
     } else {
         substrings.count()
     }
@@ -1063,11 +1025,11 @@ impl AnyStr for [u8] {
         self.iter().copied()
     }
 
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_bytes(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
+    fn get_chars(&self, range: core::ops::Range<usize>) -> &Self {
         &self[range]
     }
 
@@ -1158,7 +1120,7 @@ fn hex_impl(bytes: &[u8], sep: u8, bytes_per_sep: isize) -> String {
     let len = bytes.len();
 
     let buf = if bytes_per_sep < 0 {
-        let bytes_per_sep = std::cmp::min(len, (-bytes_per_sep) as usize);
+        let bytes_per_sep = core::cmp::min(len, (-bytes_per_sep) as usize);
         let chunks = (len - 1) / bytes_per_sep;
         let chunked = chunks * bytes_per_sep;
         let unchunked = len - chunked;
@@ -1177,7 +1139,7 @@ fn hex_impl(bytes: &[u8], sep: u8, bytes_per_sep: isize) -> String {
         hex::encode_to_slice(&bytes[chunked..], &mut buf[j..j + unchunked * 2]).unwrap();
         buf
     } else {
-        let bytes_per_sep = std::cmp::min(len, bytes_per_sep as usize);
+        let bytes_per_sep = core::cmp::min(len, bytes_per_sep as usize);
         let chunks = (len - 1) / bytes_per_sep;
         let chunked = chunks * bytes_per_sep;
         let unchunked = len - chunked;
diff --git a/crates/vm/src/cformat.rs b/crates/vm/src/cformat.rs
new file mode 100644
index 0000000000..939b1c7760
--- /dev/null
+++ b/crates/vm/src/cformat.rs
@@ -0,0 +1,470 @@
+//cspell:ignore bytesobject
+
+//! Implementation of Printf-Style string formatting
+//! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
+
+use crate::common::cformat::*;
+use crate::common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject,
+    VirtualMachine,
+    builtins::{
+        PyBaseExceptionRef, PyByteArray, PyBytes, PyFloat, PyInt, PyStr, try_f64_to_bigint, tuple,
+    },
+    function::ArgIntoFloat,
+    protocol::PyBuffer,
+    stdlib::builtins,
+};
+use itertools::Itertools;
+use num_traits::cast::ToPrimitive;
+
+fn spec_format_bytes(
+    vm: &VirtualMachine,
+    spec: &CFormatSpec,
+    obj: PyObjectRef,
+) -> PyResult<Vec<u8>> {
+    match &spec.format_type {
+        CFormatType::String(conversion) => match conversion {
+            // 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();
+                Ok(b)
+            }
+            CFormatConversion::Str | CFormatConversion::Bytes => {
+                if let Ok(buffer) = PyBuffer::try_from_borrowed_object(vm, &obj) {
+                    Ok(buffer.contiguous_or_collect(|bytes| spec.format_bytes(bytes)))
+                } else {
+                    let bytes = vm
+                        .get_special_method(&obj, identifier!(vm, __bytes__))?
+                        .ok_or_else(|| {
+                            vm.new_type_error(format!(
+                                "%b requires a bytes-like object, or an object that \
+                                    implements __bytes__, not '{}'",
+                                obj.class().name()
+                            ))
+                        })?
+                        .invoke((), vm)?;
+                    let bytes = PyBytes::try_from_borrowed_object(vm, &bytes)?;
+                    Ok(spec.format_bytes(bytes.as_bytes()))
+                }
+            }
+        },
+        CFormatType::Number(number_type) => match number_type {
+            CNumberType::DecimalD | CNumberType::DecimalI | CNumberType::DecimalU => {
+                match_class!(match &obj {
+                    ref i @ PyInt => {
+                        Ok(spec.format_number(i.as_bigint()).into_bytes())
+                    }
+                    ref f @ PyFloat => {
+                        Ok(spec
+                            .format_number(&try_f64_to_bigint(f.to_f64(), vm)?)
+                            .into_bytes())
+                    }
+                    obj => {
+                        if let Some(method) = vm.get_method(obj.clone(), identifier!(vm, __int__)) {
+                            let result = method?.call((), vm)?;
+                            if let Some(i) = result.downcast_ref::<PyInt>() {
+                                return Ok(spec.format_number(i.as_bigint()).into_bytes());
+                            }
+                        }
+                        Err(vm.new_type_error(format!(
+                            "%{} format: a number is required, not {}",
+                            spec.format_type.to_char(),
+                            obj.class().name()
+                        )))
+                    }
+                })
+            }
+            _ => {
+                if let Some(i) = obj.downcast_ref::<PyInt>() {
+                    Ok(spec.format_number(i.as_bigint()).into_bytes())
+                } else {
+                    Err(vm.new_type_error(format!(
+                        "%{} format: an integer is required, not {}",
+                        spec.format_type.to_char(),
+                        obj.class().name()
+                    )))
+                }
+            }
+        },
+        CFormatType::Float(_) => {
+            let class = obj.class().to_owned();
+            let value = ArgIntoFloat::try_from_object(vm, obj).map_err(|e| {
+                if e.fast_isinstance(vm.ctx.exceptions.type_error) {
+                    // formatfloat in bytesobject.c generates its own specific exception
+                    // text in this case, mirror it here.
+                    vm.new_type_error(format!("float argument required, not {}", class.name()))
+                } else {
+                    e
+                }
+            })?;
+            Ok(spec.format_float(value.into()).into_bytes())
+        }
+        CFormatType::Character(CCharacterType::Character) => {
+            if let Some(i) = obj.downcast_ref::<PyInt>() {
+                let ch = i
+                    .try_to_primitive::<u8>(vm)
+                    .map_err(|_| vm.new_overflow_error("%c arg not in range(256)"))?;
+                return Ok(spec.format_char(ch));
+            }
+            if let Some(b) = obj.downcast_ref::<PyBytes>() {
+                if b.len() == 1 {
+                    return Ok(spec.format_char(b.as_bytes()[0]));
+                }
+            } else if let Some(ba) = obj.downcast_ref::<PyByteArray>() {
+                let buf = ba.borrow_buf();
+                if buf.len() == 1 {
+                    return Ok(spec.format_char(buf[0]));
+                }
+            }
+            Err(vm.new_type_error("%c requires an integer in range(256) or a single byte"))
+        }
+    }
+}
+
+fn spec_format_string(
+    vm: &VirtualMachine,
+    spec: &CFormatSpec,
+    obj: PyObjectRef,
+    idx: usize,
+) -> PyResult<Wtf8Buf> {
+    match &spec.format_type {
+        CFormatType::String(conversion) => {
+            let result = match conversion {
+                CFormatConversion::Ascii => builtins::ascii(obj, vm)?.into(),
+                CFormatConversion::Str => obj.str(vm)?.as_wtf8().to_owned(),
+                CFormatConversion::Repr => obj.repr(vm)?.as_wtf8().to_owned(),
+                CFormatConversion::Bytes => {
+                    // idx is the position of the %, we want the position of the b
+                    return Err(vm.new_value_error(format!(
+                        "unsupported format character 'b' (0x62) at index {}",
+                        idx + 1
+                    )));
+                }
+            };
+            Ok(spec.format_string(result))
+        }
+        CFormatType::Number(number_type) => match number_type {
+            CNumberType::DecimalD | CNumberType::DecimalI | CNumberType::DecimalU => {
+                match_class!(match &obj {
+                    ref i @ PyInt => {
+                        Ok(spec.format_number(i.as_bigint()).into())
+                    }
+                    ref f @ PyFloat => {
+                        Ok(spec
+                            .format_number(&try_f64_to_bigint(f.to_f64(), vm)?)
+                            .into())
+                    }
+                    obj => {
+                        if let Some(method) = vm.get_method(obj.clone(), identifier!(vm, __int__)) {
+                            let result = method?.call((), vm)?;
+                            if let Some(i) = result.downcast_ref::<PyInt>() {
+                                return Ok(spec.format_number(i.as_bigint()).into());
+                            }
+                        }
+                        Err(vm.new_type_error(format!(
+                            "%{} format: a number is required, not {}",
+                            spec.format_type.to_char(),
+                            obj.class().name()
+                        )))
+                    }
+                })
+            }
+            _ => {
+                if let Some(i) = obj.downcast_ref::<PyInt>() {
+                    Ok(spec.format_number(i.as_bigint()).into())
+                } else {
+                    Err(vm.new_type_error(format!(
+                        "%{} format: an integer is required, not {}",
+                        spec.format_type.to_char(),
+                        obj.class().name()
+                    )))
+                }
+            }
+        },
+        CFormatType::Float(_) => {
+            let value = ArgIntoFloat::try_from_object(vm, obj)?;
+            Ok(spec.format_float(value.into()).into())
+        }
+        CFormatType::Character(CCharacterType::Character) => {
+            if let Some(i) = obj.downcast_ref::<PyInt>() {
+                let ch = i
+                    .as_bigint()
+                    .to_u32()
+                    .and_then(CodePoint::from_u32)
+                    .ok_or_else(|| vm.new_overflow_error("%c arg not in range(0x110000)"))?;
+                return Ok(spec.format_char(ch));
+            }
+            if let Some(s) = obj.downcast_ref::<PyStr>()
+                && let Ok(ch) = s.as_wtf8().code_points().exactly_one()
+            {
+                return Ok(spec.format_char(ch));
+            }
+            Err(vm.new_type_error("%c requires int or char"))
+        }
+    }
+}
+
+fn try_update_quantity_from_element(
+    vm: &VirtualMachine,
+    element: Option<&PyObject>,
+) -> PyResult<CFormatQuantity> {
+    match element {
+        Some(width_obj) => {
+            if let Some(i) = width_obj.downcast_ref::<PyInt>() {
+                let i = i.try_to_primitive::<i32>(vm)?.unsigned_abs();
+                Ok(CFormatQuantity::Amount(i as usize))
+            } else {
+                Err(vm.new_type_error("* wants int"))
+            }
+        }
+        None => Err(vm.new_type_error("not enough arguments for format string")),
+    }
+}
+
+fn try_conversion_flag_from_tuple(
+    vm: &VirtualMachine,
+    element: Option<&PyObject>,
+) -> PyResult<CConversionFlags> {
+    match element {
+        Some(width_obj) => {
+            if let Some(i) = width_obj.downcast_ref::<PyInt>() {
+                let i = i.try_to_primitive::<i32>(vm)?;
+                let flags = if i < 0 {
+                    CConversionFlags::LEFT_ADJUST
+                } else {
+                    CConversionFlags::from_bits(0).unwrap()
+                };
+                Ok(flags)
+            } else {
+                Err(vm.new_type_error("* wants int"))
+            }
+        }
+        None => Err(vm.new_type_error("not enough arguments for format string")),
+    }
+}
+
+fn try_update_quantity_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
+    vm: &VirtualMachine,
+    elements: &mut I,
+    q: &mut Option<CFormatQuantity>,
+    f: &mut CConversionFlags,
+) -> PyResult<()> {
+    let Some(CFormatQuantity::FromValuesTuple) = q else {
+        return Ok(());
+    };
+    let element = elements.next();
+    f.insert(try_conversion_flag_from_tuple(
+        vm,
+        element.map(|v| v.as_ref()),
+    )?);
+    let quantity = try_update_quantity_from_element(vm, element.map(|v| v.as_ref()))?;
+    *q = Some(quantity);
+    Ok(())
+}
+
+fn try_update_precision_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
+    vm: &VirtualMachine,
+    elements: &mut I,
+    p: &mut Option<CFormatPrecision>,
+) -> PyResult<()> {
+    let Some(CFormatPrecision::Quantity(CFormatQuantity::FromValuesTuple)) = p else {
+        return Ok(());
+    };
+    let quantity = try_update_quantity_from_element(vm, elements.next().map(|v| v.as_ref()))?;
+    *p = Some(CFormatPrecision::Quantity(quantity));
+    Ok(())
+}
+
+fn specifier_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_type_error("format requires a mapping")
+}
+
+pub(crate) fn cformat_bytes(
+    vm: &VirtualMachine,
+    format_string: &[u8],
+    values_obj: PyObjectRef,
+) -> PyResult<Vec<u8>> {
+    let mut format = CFormatBytes::parse_from_bytes(format_string)
+        .map_err(|err| vm.new_value_error(err.to_string()))?;
+    let (num_specifiers, mapping_required) = format
+        .check_specifiers()
+        .ok_or_else(|| specifier_error(vm))?;
+
+    let mut result = vec![];
+
+    let is_mapping = values_obj.class().has_attr(identifier!(vm, __getitem__))
+        && !values_obj.fast_isinstance(vm.ctx.types.tuple_type)
+        && !values_obj.fast_isinstance(vm.ctx.types.bytes_type)
+        && !values_obj.fast_isinstance(vm.ctx.types.bytearray_type);
+
+    if num_specifiers == 0 {
+        // literal only
+        return if is_mapping
+            || values_obj
+                .downcast_ref::<tuple::PyTuple>()
+                .is_some_and(|e| e.is_empty())
+        {
+            for (_, part) in format.iter_mut() {
+                match part {
+                    CFormatPart::Literal(literal) => result.append(literal),
+                    CFormatPart::Spec(_) => unreachable!(),
+                }
+            }
+            Ok(result)
+        } else {
+            Err(vm.new_type_error("not all arguments converted during bytes formatting"))
+        };
+    }
+
+    if mapping_required {
+        // dict
+        return if is_mapping {
+            for (_, part) in format {
+                match part {
+                    CFormatPart::Literal(literal) => result.extend(literal),
+                    CFormatPart::Spec(CFormatSpecKeyed { mapping_key, spec }) => {
+                        let key = mapping_key.unwrap();
+                        let value = values_obj.get_item(&key, vm)?;
+                        let part_result = spec_format_bytes(vm, &spec, value)?;
+                        result.extend(part_result);
+                    }
+                }
+            }
+            Ok(result)
+        } else {
+            Err(vm.new_type_error("format requires a mapping"))
+        };
+    }
+
+    // tuple
+    let values = if let Some(tup) = values_obj.downcast_ref::<tuple::PyTuple>() {
+        tup.as_slice()
+    } else {
+        core::slice::from_ref(&values_obj)
+    };
+    let mut value_iter = values.iter();
+
+    for (_, part) in format {
+        match part {
+            CFormatPart::Literal(literal) => result.extend(literal),
+            CFormatPart::Spec(CFormatSpecKeyed { mut spec, .. }) => {
+                try_update_quantity_from_tuple(
+                    vm,
+                    &mut value_iter,
+                    &mut spec.min_field_width,
+                    &mut spec.flags,
+                )?;
+                try_update_precision_from_tuple(vm, &mut value_iter, &mut spec.precision)?;
+
+                let value = match value_iter.next() {
+                    Some(obj) => Ok(obj.clone()),
+                    None => Err(vm.new_type_error("not enough arguments for format string")),
+                }?;
+                let part_result = spec_format_bytes(vm, &spec, value)?;
+                result.extend(part_result);
+            }
+        }
+    }
+
+    // check that all arguments were converted
+    if value_iter.next().is_some() && !is_mapping {
+        Err(vm.new_type_error("not all arguments converted during bytes formatting"))
+    } else {
+        Ok(result)
+    }
+}
+
+pub(crate) fn cformat_string(
+    vm: &VirtualMachine,
+    format_string: &Wtf8,
+    values_obj: PyObjectRef,
+) -> PyResult<Wtf8Buf> {
+    let format = CFormatWtf8::parse_from_wtf8(format_string)
+        .map_err(|err| vm.new_value_error(err.to_string()))?;
+    let (num_specifiers, mapping_required) = format
+        .check_specifiers()
+        .ok_or_else(|| specifier_error(vm))?;
+
+    let mut result = Wtf8Buf::new();
+
+    let is_mapping = values_obj.class().has_attr(identifier!(vm, __getitem__))
+        && !values_obj.fast_isinstance(vm.ctx.types.tuple_type)
+        && !values_obj.fast_isinstance(vm.ctx.types.str_type);
+
+    if num_specifiers == 0 {
+        // literal only
+        return if is_mapping
+            || values_obj
+                .downcast_ref::<tuple::PyTuple>()
+                .is_some_and(|e| e.is_empty())
+        {
+            for (_, part) in format.iter() {
+                match part {
+                    CFormatPart::Literal(literal) => result.push_wtf8(literal),
+                    CFormatPart::Spec(_) => unreachable!(),
+                }
+            }
+            Ok(result)
+        } else {
+            Err(vm.new_type_error("not all arguments converted during string formatting"))
+        };
+    }
+
+    if mapping_required {
+        // dict
+        return if is_mapping {
+            for (idx, part) in format {
+                match part {
+                    CFormatPart::Literal(literal) => result.push_wtf8(&literal),
+                    CFormatPart::Spec(CFormatSpecKeyed { mapping_key, spec }) => {
+                        let value = values_obj.get_item(&mapping_key.unwrap(), vm)?;
+                        let part_result = spec_format_string(vm, &spec, value, idx)?;
+                        result.push_wtf8(&part_result);
+                    }
+                }
+            }
+            Ok(result)
+        } else {
+            Err(vm.new_type_error("format requires a mapping"))
+        };
+    }
+
+    // tuple
+    let values = if let Some(tup) = values_obj.downcast_ref::<tuple::PyTuple>() {
+        tup.as_slice()
+    } else {
+        core::slice::from_ref(&values_obj)
+    };
+    let mut value_iter = values.iter();
+
+    for (idx, part) in format {
+        match part {
+            CFormatPart::Literal(literal) => result.push_wtf8(&literal),
+            CFormatPart::Spec(CFormatSpecKeyed { mut spec, .. }) => {
+                try_update_quantity_from_tuple(
+                    vm,
+                    &mut value_iter,
+                    &mut spec.min_field_width,
+                    &mut spec.flags,
+                )?;
+                try_update_precision_from_tuple(vm, &mut value_iter, &mut spec.precision)?;
+
+                let value = match value_iter.next() {
+                    Some(obj) => Ok(obj.clone()),
+                    None => Err(vm.new_type_error("not enough arguments for format string")),
+                }?;
+                let part_result = spec_format_string(vm, &spec, value, idx)?;
+                result.push_wtf8(&part_result);
+            }
+        }
+    }
+
+    // check that all arguments were converted
+    if value_iter.next().is_some() && !is_mapping {
+        Err(vm.new_type_error("not all arguments converted during string formatting"))
+    } else {
+        Ok(result)
+    }
+}
diff --git a/crates/vm/src/class.rs b/crates/vm/src/class.rs
new file mode 100644
index 0000000000..4590b62d50
--- /dev/null
+++ b/crates/vm/src/class.rs
@@ -0,0 +1,258 @@
+//! Utilities to define a new Python class
+
+use crate::{
+    PyPayload,
+    builtins::{PyBaseObject, PyType, PyTypeRef, descriptor::PyWrapper},
+    function::PyMethodDef,
+    object::Py,
+    types::{PyTypeFlags, PyTypeSlots, SLOT_DEFS, hash_not_implemented},
+    vm::Context,
+};
+use rustpython_common::static_cell;
+
+/// Add slot wrapper descriptors to a type's dict
+///
+/// Iterates SLOT_DEFS and creates a PyWrapper for each slot that:
+/// 1. Has a function set in the type's slots
+/// 2. Doesn't already have an attribute in the type's dict
+pub fn add_operators(class: &'static Py<PyType>, ctx: &Context) {
+    for def in SLOT_DEFS.iter() {
+        // Skip __new__ - it has special handling
+        if def.name == "__new__" {
+            continue;
+        }
+
+        // Special handling for __hash__ = None
+        if def.name == "__hash__"
+            && class
+                .slots
+                .hash
+                .load()
+                .is_some_and(|h| h as usize == hash_not_implemented as usize)
+        {
+            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
+            continue;
+        }
+
+        // __getattr__ should only have a wrapper if the type explicitly defines it.
+        // Unlike __getattribute__, __getattr__ is not present on object by default.
+        // Both map to TpGetattro, but only __getattribute__ gets a wrapper from the slot.
+        if def.name == "__getattr__" {
+            continue;
+        }
+
+        // Get the slot function wrapped in SlotFunc
+        let Some(slot_func) = def.accessor.get_slot_func_with_op(&class.slots, def.op) else {
+            continue;
+        };
+
+        // Check if attribute already exists in dict
+        let attr_name = ctx.intern_str(def.name);
+        if class.attributes.read().contains_key(attr_name) {
+            continue;
+        }
+
+        // Create and add the wrapper
+        let wrapper = PyWrapper {
+            typ: class,
+            name: attr_name,
+            wrapped: slot_func,
+            doc: Some(def.doc),
+        };
+        class.set_attr(attr_name, wrapper.into_ref(ctx).into());
+    }
+}
+
+pub trait StaticType {
+    // Ideally, saving PyType is better than PyTypeRef
+    fn static_cell() -> &'static static_cell::StaticCell<PyTypeRef>;
+    #[inline]
+    fn static_metaclass() -> &'static Py<PyType> {
+        PyType::static_type()
+    }
+    #[inline]
+    fn static_baseclass() -> &'static Py<PyType> {
+        PyBaseObject::static_type()
+    }
+    #[inline]
+    fn static_type() -> &'static Py<PyType> {
+        #[cold]
+        fn fail() -> ! {
+            panic!(
+                "static type has not been initialized. e.g. the native types defined in different module may be used before importing library."
+            );
+        }
+        Self::static_cell().get().unwrap_or_else(|| fail())
+    }
+    fn init_manually(typ: PyTypeRef) -> &'static Py<PyType> {
+        let cell = Self::static_cell();
+        cell.set(typ)
+            .unwrap_or_else(|_| panic!("double initialization from init_manually"));
+        cell.get().unwrap()
+    }
+    fn init_builtin_type() -> &'static Py<PyType>
+    where
+        Self: PyClassImpl,
+    {
+        let typ = Self::create_static_type();
+        let cell = Self::static_cell();
+        cell.set(typ)
+            .unwrap_or_else(|_| panic!("double initialization of {}", Self::NAME));
+        cell.get().unwrap()
+    }
+    fn create_static_type() -> PyTypeRef
+    where
+        Self: PyClassImpl,
+    {
+        PyType::new_static(
+            Self::static_baseclass().to_owned(),
+            Default::default(),
+            Self::make_slots(),
+            Self::static_metaclass().to_owned(),
+        )
+        .unwrap()
+    }
+}
+
+pub trait PyClassDef {
+    const NAME: &'static str;
+    const MODULE_NAME: Option<&'static str>;
+    const TP_NAME: &'static str;
+    const DOC: Option<&'static str> = None;
+    const BASICSIZE: usize;
+    const ITEMSIZE: usize = 0;
+    const UNHASHABLE: bool = false;
+
+    // due to restriction of rust trait system, object.__base__ is None
+    // but PyBaseObject::Base will be PyBaseObject.
+    type Base: PyClassDef;
+}
+
+pub trait PyClassImpl: PyClassDef {
+    const TP_FLAGS: PyTypeFlags = PyTypeFlags::DEFAULT;
+
+    fn extend_class(ctx: &Context, class: &'static Py<PyType>)
+    where
+        Self: Sized,
+    {
+        #[cfg(debug_assertions)]
+        {
+            assert!(class.slots.flags.is_created_with_flags());
+        }
+
+        let _ = ctx.intern_str(Self::NAME); // intern type name
+
+        if Self::TP_FLAGS.has_feature(PyTypeFlags::HAS_DICT) {
+            let __dict__ = identifier!(ctx, __dict__);
+            class.set_attr(
+                __dict__,
+                ctx.new_static_getset(
+                    "__dict__",
+                    class,
+                    crate::builtins::object::object_get_dict,
+                    crate::builtins::object::object_set_dict,
+                )
+                .into(),
+            );
+        }
+        Self::impl_extend_class(ctx, class);
+        if let Some(doc) = Self::DOC {
+            // Only set __doc__ if it doesn't already exist (e.g., as a member descriptor)
+            // This matches CPython's behavior in type_dict_set_doc
+            let doc_attr_name = identifier!(ctx, __doc__);
+            if class.attributes.read().get(doc_attr_name).is_none() {
+                class.set_attr(doc_attr_name, ctx.new_str(doc).into());
+            }
+        }
+        if let Some(module_name) = Self::MODULE_NAME {
+            class.set_attr(
+                identifier!(ctx, __module__),
+                ctx.new_str(module_name).into(),
+            );
+        }
+
+        // Don't add __new__ attribute if slot_new is inherited from object
+        // (Python doesn't add __new__ to __dict__ for inherited slots)
+        // Exception: object itself should have __new__ in its dict
+        if let Some(slot_new) = class.slots.new.load() {
+            let object_new = ctx.types.object_type.slots.new.load();
+            let is_object_itself = core::ptr::eq(class, ctx.types.object_type);
+            let is_inherited_from_object = !is_object_itself
+                && object_new.is_some_and(|obj_new| slot_new as usize == obj_new as usize);
+
+            if !is_inherited_from_object {
+                let bound_new = Context::genesis().slot_new_wrapper.build_bound_method(
+                    ctx,
+                    class.to_owned().into(),
+                    class,
+                );
+                class.set_attr(identifier!(ctx, __new__), bound_new.into());
+            }
+        }
+
+        // Add slot wrappers using SLOT_DEFS array
+        add_operators(class, ctx);
+
+        // Inherit slots from base types after slots are fully initialized
+        for base in class.bases.read().iter() {
+            class.inherit_slots(base);
+        }
+
+        class.extend_methods(class.slots.methods, ctx);
+    }
+
+    fn make_class(ctx: &Context) -> PyTypeRef
+    where
+        Self: StaticType + Sized,
+    {
+        (*Self::static_cell().get_or_init(|| {
+            let typ = Self::create_static_type();
+            Self::extend_class(ctx, unsafe {
+                // typ will be saved in static_cell
+                let r: &Py<PyType> = &typ;
+                let r: &'static Py<PyType> = core::mem::transmute(r);
+                r
+            });
+            typ
+        }))
+        .to_owned()
+    }
+
+    fn impl_extend_class(ctx: &Context, class: &'static Py<PyType>);
+    const METHOD_DEFS: &'static [PyMethodDef];
+    fn extend_slots(slots: &mut PyTypeSlots);
+
+    fn make_slots() -> PyTypeSlots {
+        let mut slots = PyTypeSlots {
+            flags: Self::TP_FLAGS,
+            name: Self::TP_NAME,
+            basicsize: Self::BASICSIZE,
+            itemsize: Self::ITEMSIZE,
+            doc: Self::DOC,
+            methods: Self::METHOD_DEFS,
+            ..Default::default()
+        };
+
+        if Self::UNHASHABLE {
+            slots.hash.store(Some(hash_not_implemented));
+        }
+
+        Self::extend_slots(&mut slots);
+        slots
+    }
+}
+
+/// Trait for Python subclasses that can provide a reference to their base type.
+///
+/// This trait is automatically implemented by the `#[pyclass]` macro when
+/// `base = SomeType` is specified. It provides safe reference access to the
+/// base type's payload.
+///
+/// For subclasses with `#[repr(transparent)]`
+/// which enables ownership transfer via `into_base()`.
+pub trait PySubclass: crate::PyPayload {
+    type Base: crate::PyPayload;
+
+    /// Returns a reference to the base type's payload.
+    fn as_base(&self) -> &Self::Base;
+}
diff --git a/crates/vm/src/codecs.rs b/crates/vm/src/codecs.rs
new file mode 100644
index 0000000000..3241dee498
--- /dev/null
+++ b/crates/vm/src/codecs.rs
@@ -0,0 +1,1163 @@
+use rustpython_common::{
+    borrow::BorrowedValue,
+    encodings::{
+        CodecContext, DecodeContext, DecodeErrorHandler, EncodeContext, EncodeErrorHandler,
+        EncodeReplace, StrBuffer, StrSize, errors,
+    },
+    str::StrKind,
+    wtf8::{CodePoint, Wtf8, Wtf8Buf},
+};
+
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject,
+    TryFromObject, VirtualMachine,
+    builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef},
+    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 {
+    inner: PyRwLock<RegistryInner>,
+}
+
+struct RegistryInner {
+    search_path: Vec<PyObjectRef>,
+    search_cache: HashMap<String, PyCodec>,
+    errors: HashMap<String, PyObjectRef>,
+}
+
+pub const DEFAULT_ENCODING: &str = "utf-8";
+
+#[derive(Clone)]
+#[repr(transparent)]
+pub struct PyCodec(PyTupleRef);
+impl PyCodec {
+    #[inline]
+    pub fn from_tuple(tuple: PyTupleRef) -> Result<Self, PyTupleRef> {
+        if tuple.len() == 4 {
+            Ok(Self(tuple))
+        } else {
+            Err(tuple)
+        }
+    }
+    #[inline]
+    pub fn into_tuple(self) -> PyTupleRef {
+        self.0
+    }
+    #[inline]
+    pub fn as_tuple(&self) -> &Py<PyTuple> {
+        &self.0
+    }
+
+    #[inline]
+    pub fn get_encode_func(&self) -> &PyObject {
+        &self.0[0]
+    }
+    #[inline]
+    pub fn get_decode_func(&self) -> &PyObject {
+        &self.0[1]
+    }
+
+    pub fn is_text_codec(&self, vm: &VirtualMachine) -> PyResult<bool> {
+        let is_text = vm.get_attribute_opt(self.0.clone().into(), "_is_text_encoding")?;
+        is_text.map_or(Ok(true), |is_text| is_text.try_to_bool(vm))
+    }
+
+    pub fn encode(
+        &self,
+        obj: PyObjectRef,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let args = match errors {
+            Some(errors) => vec![obj, errors.into()],
+            None => vec![obj],
+        };
+        let res = self.get_encode_func().call(args, vm)?;
+        let res = res
+            .downcast::<PyTuple>()
+            .ok()
+            .filter(|tuple| tuple.len() == 2)
+            .ok_or_else(|| vm.new_type_error("encoder must return a tuple (object, integer)"))?;
+        // we don't actually care about the integer
+        Ok(res[0].clone())
+    }
+
+    pub fn decode(
+        &self,
+        obj: PyObjectRef,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let args = match errors {
+            Some(errors) => vec![obj, errors.into()],
+            None => vec![obj],
+        };
+        let res = self.get_decode_func().call(args, vm)?;
+        let res = res
+            .downcast::<PyTuple>()
+            .ok()
+            .filter(|tuple| tuple.len() == 2)
+            .ok_or_else(|| vm.new_type_error("decoder must return a tuple (object,integer)"))?;
+        // we don't actually care about the integer
+        Ok(res[0].clone())
+    }
+
+    pub fn get_incremental_encoder(
+        &self,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let args = match errors {
+            Some(e) => vec![e.into()],
+            None => vec![],
+        };
+        vm.call_method(self.0.as_object(), "incrementalencoder", args)
+    }
+
+    pub fn get_incremental_decoder(
+        &self,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let args = match errors {
+            Some(e) => vec![e.into()],
+            None => vec![],
+        };
+        vm.call_method(self.0.as_object(), "incrementaldecoder", args)
+    }
+}
+
+impl TryFromObject for PyCodec {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        obj.downcast::<PyTuple>()
+            .ok()
+            .and_then(|tuple| Self::from_tuple(tuple).ok())
+            .ok_or_else(|| vm.new_type_error("codec search functions must return 4-tuples"))
+    }
+}
+
+impl ToPyObject for PyCodec {
+    #[inline]
+    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
+        self.0.into()
+    }
+}
+
+impl CodecsRegistry {
+    pub(crate) fn new(ctx: &Context) -> Self {
+        ::rustpython_vm::common::static_cell! {
+            static METHODS: Box<[PyMethodDef]>;
+        }
+
+        let methods = METHODS.get_or_init(|| {
+            crate::define_methods![
+                "strict_errors" => strict_errors as EMPTY,
+                "ignore_errors" => ignore_errors as EMPTY,
+                "replace_errors" => replace_errors as EMPTY,
+                "xmlcharrefreplace_errors" => xmlcharrefreplace_errors as EMPTY,
+                "backslashreplace_errors" => backslashreplace_errors as EMPTY,
+                "namereplace_errors" => namereplace_errors as EMPTY,
+                "surrogatepass_errors" => surrogatepass_errors as EMPTY,
+                "surrogateescape_errors" => surrogateescape_errors as EMPTY
+            ]
+            .into_boxed_slice()
+        });
+
+        let errors = [
+            ("strict", methods[0].build_function(ctx)),
+            ("ignore", methods[1].build_function(ctx)),
+            ("replace", methods[2].build_function(ctx)),
+            ("xmlcharrefreplace", methods[3].build_function(ctx)),
+            ("backslashreplace", methods[4].build_function(ctx)),
+            ("namereplace", methods[5].build_function(ctx)),
+            ("surrogatepass", methods[6].build_function(ctx)),
+            ("surrogateescape", methods[7].build_function(ctx)),
+        ];
+        let errors = errors
+            .into_iter()
+            .map(|(name, f)| (name.to_owned(), f.into()))
+            .collect();
+        let inner = RegistryInner {
+            search_path: Vec::new(),
+            search_cache: HashMap::new(),
+            errors,
+        };
+        Self {
+            inner: PyRwLock::new(inner),
+        }
+    }
+
+    pub fn register(&self, search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if !search_function.is_callable() {
+            return Err(vm.new_type_error("argument must be callable"));
+        }
+        self.inner.write().search_path.push(search_function);
+        Ok(())
+    }
+
+    pub fn unregister(&self, search_function: PyObjectRef) -> PyResult<()> {
+        let mut inner = self.inner.write();
+        // Do nothing if search_path is not created yet or was cleared.
+        if inner.search_path.is_empty() {
+            return Ok(());
+        }
+        for (i, item) in inner.search_path.iter().enumerate() {
+            if item.get_id() == search_function.get_id() {
+                if !inner.search_cache.is_empty() {
+                    inner.search_cache.clear();
+                }
+                inner.search_path.remove(i);
+                return Ok(());
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn register_manual(&self, name: &str, codec: PyCodec) -> PyResult<()> {
+        self.inner
+            .write()
+            .search_cache
+            .insert(name.to_owned(), codec);
+        Ok(())
+    }
+
+    pub fn lookup(&self, encoding: &str, vm: &VirtualMachine) -> PyResult<PyCodec> {
+        let encoding = normalize_encoding_name(encoding);
+        let search_path = {
+            let inner = self.inner.read();
+            if let Some(codec) = inner.search_cache.get(encoding.as_ref()) {
+                // hit cache
+                return Ok(codec.clone());
+            }
+            inner.search_path.clone()
+        };
+        let encoding = PyStr::from(encoding.into_owned()).into_ref(&vm.ctx);
+        for func in search_path {
+            let res = func.call((encoding.clone(),), vm)?;
+            let res: Option<PyCodec> = res.try_into_value(vm)?;
+            if let Some(codec) = res {
+                let mut inner = self.inner.write();
+                // someone might have raced us to this, so use theirs
+                let codec = inner
+                    .search_cache
+                    .entry(encoding.as_str().to_owned())
+                    .or_insert(codec);
+                return Ok(codec.clone());
+            }
+        }
+        Err(vm.new_lookup_error(format!("unknown encoding: {encoding}")))
+    }
+
+    fn _lookup_text_encoding(
+        &self,
+        encoding: &str,
+        generic_func: &str,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyCodec> {
+        let codec = self.lookup(encoding, vm)?;
+        if codec.is_text_codec(vm)? {
+            Ok(codec)
+        } else {
+            Err(vm.new_lookup_error(format!(
+                "'{encoding}' is not a text encoding; use {generic_func} to handle arbitrary codecs"
+            )))
+        }
+    }
+
+    pub fn forget(&self, encoding: &str) -> Option<PyCodec> {
+        let encoding = normalize_encoding_name(encoding);
+        self.inner.write().search_cache.remove(encoding.as_ref())
+    }
+
+    pub fn encode(
+        &self,
+        obj: PyObjectRef,
+        encoding: &str,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let codec = self.lookup(encoding, vm)?;
+        codec.encode(obj, errors, vm)
+    }
+
+    pub fn decode(
+        &self,
+        obj: PyObjectRef,
+        encoding: &str,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let codec = self.lookup(encoding, vm)?;
+        codec.decode(obj, errors, vm)
+    }
+
+    pub fn encode_text(
+        &self,
+        obj: PyStrRef,
+        encoding: &str,
+        errors: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyBytesRef> {
+        let codec = self._lookup_text_encoding(encoding, "codecs.encode()", vm)?;
+        codec
+            .encode(obj.into(), errors, vm)?
+            .downcast()
+            .map_err(|obj| {
+                vm.new_type_error(format!(
+                    "'{}' encoder returned '{}' instead of 'bytes'; use codecs.encode() to \
+                     encode arbitrary types",
+                    encoding,
+                    obj.class().name(),
+                ))
+            })
+    }
+
+    pub fn decode_text(
+        &self,
+        obj: PyObjectRef,
+        encoding: &str,
+        errors: Option<PyStrRef>,
+        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(),
+            ))
+        })
+    }
+
+    pub fn register_error(&self, name: String, handler: PyObjectRef) -> Option<PyObjectRef> {
+        self.inner.write().errors.insert(name, handler)
+    }
+
+    pub fn lookup_error_opt(&self, name: &str) -> Option<PyObjectRef> {
+        self.inner.read().errors.get(name).cloned()
+    }
+
+    pub fn lookup_error(&self, name: &str, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        self.lookup_error_opt(name)
+            .ok_or_else(|| vm.new_lookup_error(format!("unknown error handler name '{name}'")))
+    }
+}
+
+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();
+            }
+        }
+        String::from_utf8(out).unwrap().into()
+    } else {
+        encoding.into()
+    }
+}
+
+#[derive(Eq, PartialEq)]
+enum StandardEncoding {
+    Utf8,
+    Utf16Be,
+    Utf16Le,
+    Utf32Be,
+    Utf32Le,
+}
+
+impl StandardEncoding {
+    #[cfg(target_endian = "little")]
+    const UTF_16_NE: Self = Self::Utf16Le;
+    #[cfg(target_endian = "big")]
+    const UTF_16_NE: Self = Self::Utf16Be;
+
+    #[cfg(target_endian = "little")]
+    const UTF_32_NE: Self = Self::Utf32Le;
+    #[cfg(target_endian = "big")]
+    const UTF_32_NE: Self = Self::Utf32Be;
+
+    fn parse(encoding: &str) -> Option<Self> {
+        if let Some(encoding) = encoding.to_lowercase().strip_prefix("utf") {
+            let encoding = encoding
+                .strip_prefix(|c| ['-', '_'].contains(&c))
+                .unwrap_or(encoding);
+            if encoding == "8" {
+                Some(Self::Utf8)
+            } else if let Some(encoding) = encoding.strip_prefix("16") {
+                if encoding.is_empty() {
+                    return Some(Self::UTF_16_NE);
+                }
+                let encoding = encoding.strip_prefix(['-', '_']).unwrap_or(encoding);
+                match encoding {
+                    "be" => Some(Self::Utf16Be),
+                    "le" => Some(Self::Utf16Le),
+                    _ => None,
+                }
+            } else if let Some(encoding) = encoding.strip_prefix("32") {
+                if encoding.is_empty() {
+                    return Some(Self::UTF_32_NE);
+                }
+                let encoding = encoding.strip_prefix(['-', '_']).unwrap_or(encoding);
+                match encoding {
+                    "be" => Some(Self::Utf32Be),
+                    "le" => Some(Self::Utf32Le),
+                    _ => None,
+                }
+            } else {
+                None
+            }
+        } else if encoding == "CP_UTF8" {
+            Some(Self::Utf8)
+        } else {
+            None
+        }
+    }
+}
+
+struct SurrogatePass;
+
+impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for SurrogatePass {
+    fn handle_encode_error(
+        &self,
+        ctx: &mut PyEncodeContext<'a>,
+        range: Range<StrSize>,
+        reason: Option<&str>,
+    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
+        let standard_encoding = StandardEncoding::parse(ctx.encoding)
+            .ok_or_else(|| ctx.error_encoding(range.clone(), reason))?;
+        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<u8> = Vec::with_capacity(num_chars * 4);
+        for ch in err_str.code_points() {
+            let c = ch.to_u32();
+            let 0xd800..=0xdfff = c else {
+                // Not a surrogate, fail with original exception
+                return Err(ctx.error_encoding(range, reason));
+            };
+            match standard_encoding {
+                StandardEncoding::Utf8 => out.extend(ch.encode_wtf8(&mut [0; 4]).as_bytes()),
+                StandardEncoding::Utf16Le => out.extend((c as u16).to_le_bytes()),
+                StandardEncoding::Utf16Be => out.extend((c as u16).to_be_bytes()),
+                StandardEncoding::Utf32Le => out.extend(c.to_le_bytes()),
+                StandardEncoding::Utf32Be => out.extend(c.to_be_bytes()),
+            }
+        }
+        Ok((EncodeReplace::Bytes(ctx.bytes(out)), range.end))
+    }
+}
+
+impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for SurrogatePass {
+    fn handle_decode_error(
+        &self,
+        ctx: &mut PyDecodeContext<'a>,
+        byte_range: Range<usize>,
+        reason: Option<&str>,
+    ) -> PyResult<(PyStrRef, usize)> {
+        let standard_encoding = StandardEncoding::parse(ctx.encoding)
+            .ok_or_else(|| ctx.error_decoding(byte_range.clone(), reason))?;
+
+        let s = ctx.full_data();
+        debug_assert!(byte_range.start <= 0.max(s.len() - 1));
+        debug_assert!(byte_range.end >= 1.min(s.len()));
+        debug_assert!(byte_range.end <= s.len());
+
+        // Try decoding a single surrogate character. If there are more,
+        // let the codec call us again.
+        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())
+        }
+
+        let c = match standard_encoding {
+            StandardEncoding::Utf8 => {
+                // it's a three-byte code
+                slice::<3>(p)
+                    .filter(|&[a, b, c]| {
+                        (u32::from(a) & 0xf0) == 0xe0
+                            && (u32::from(b) & 0xc0) == 0x80
+                            && (u32::from(c) & 0xc0) == 0x80
+                    })
+                    .map(|[a, b, c]| {
+                        ((u32::from(a) & 0x0f) << 12)
+                            + ((u32::from(b) & 0x3f) << 6)
+                            + (u32::from(c) & 0x3f)
+                    })
+            }
+            StandardEncoding::Utf16Le => slice(p).map(u16::from_le_bytes).map(u32::from),
+            StandardEncoding::Utf16Be => slice(p).map(u16::from_be_bytes).map(u32::from),
+            StandardEncoding::Utf32Le => slice(p).map(u32::from_le_bytes),
+            StandardEncoding::Utf32Be => slice(p).map(u32::from_be_bytes),
+        };
+        let byte_length = match standard_encoding {
+            StandardEncoding::Utf8 => 3,
+            StandardEncoding::Utf16Be | StandardEncoding::Utf16Le => 2,
+            StandardEncoding::Utf32Be | StandardEncoding::Utf32Le => 4,
+        };
+
+        // !Py_UNICODE_IS_SURROGATE
+        let c = c
+            .and_then(CodePoint::from_u32)
+            .filter(|c| matches!(c.to_u32(), 0xd800..=0xdfff))
+            .ok_or_else(|| ctx.error_decoding(byte_range.clone(), reason))?;
+
+        Ok((ctx.string(c.into()), byte_range.start + byte_length))
+    }
+}
+
+pub struct PyEncodeContext<'a> {
+    vm: &'a VirtualMachine,
+    encoding: &'a str,
+    data: &'a Py<PyStr>,
+    pos: StrSize,
+    exception: OnceCell<PyBaseExceptionRef>,
+}
+
+impl<'a> PyEncodeContext<'a> {
+    pub fn new(encoding: &'a str, data: &'a Py<PyStr>, vm: &'a VirtualMachine) -> Self {
+        Self {
+            vm,
+            encoding,
+            data,
+            pos: StrSize::default(),
+            exception: OnceCell::new(),
+        }
+    }
+}
+
+impl CodecContext for PyEncodeContext<'_> {
+    type Error = PyBaseExceptionRef;
+    type StrBuf = PyStrRef;
+    type BytesBuf = PyBytesRef;
+
+    fn string(&self, s: Wtf8Buf) -> Self::StrBuf {
+        self.vm.ctx.new_str(s)
+    }
+
+    fn bytes(&self, b: Vec<u8>) -> Self::BytesBuf {
+        self.vm.ctx.new_bytes(b)
+    }
+}
+impl EncodeContext for PyEncodeContext<'_> {
+    fn full_data(&self) -> &Wtf8 {
+        self.data.as_wtf8()
+    }
+
+    fn data_len(&self) -> StrSize {
+        StrSize {
+            bytes: self.data.byte_len(),
+            chars: self.data.char_len(),
+        }
+    }
+
+    fn remaining_data(&self) -> &Wtf8 {
+        &self.full_data()[self.pos.bytes..]
+    }
+
+    fn position(&self) -> StrSize {
+        self.pos
+    }
+
+    fn restart_from(&mut self, pos: StrSize) -> Result<(), Self::Error> {
+        if pos.chars > self.data.char_len() {
+            return Err(self.vm.new_index_error(format!(
+                "position {} from error handler out of bounds",
+                pos.chars
+            )));
+        }
+        assert!(
+            self.data.as_wtf8().is_code_point_boundary(pos.bytes),
+            "invalid pos {pos:?} for {:?}",
+            self.data.as_wtf8()
+        );
+        self.pos = pos;
+        Ok(())
+    }
+
+    fn error_encoding(&self, range: Range<StrSize>, reason: Option<&str>) -> Self::Error {
+        let vm = self.vm;
+        match self.exception.get() {
+            Some(exc) => {
+                match update_unicode_error_attrs(
+                    exc.as_object(),
+                    range.start.chars,
+                    range.end.chars,
+                    reason,
+                    vm,
+                ) {
+                    Ok(()) => exc.clone(),
+                    Err(e) => e,
+                }
+            }
+            None => self
+                .exception
+                .get_or_init(|| {
+                    let reason = reason.expect(
+                        "should only ever pass reason: None if an exception is already set",
+                    );
+                    vm.new_unicode_encode_error_real(
+                        vm.ctx.new_str(self.encoding),
+                        self.data.to_owned(),
+                        range.start.chars,
+                        range.end.chars,
+                        vm.ctx.new_str(reason),
+                    )
+                })
+                .clone(),
+        }
+    }
+}
+
+pub struct PyDecodeContext<'a> {
+    vm: &'a VirtualMachine,
+    encoding: &'a str,
+    data: PyDecodeData<'a>,
+    orig_bytes: Option<&'a Py<PyBytes>>,
+    pos: usize,
+    exception: OnceCell<PyBaseExceptionRef>,
+}
+enum PyDecodeData<'a> {
+    Original(BorrowedValue<'a, [u8]>),
+    Modified(PyBytesRef),
+}
+impl ops::Deref for PyDecodeData<'_> {
+    type Target = [u8];
+    fn deref(&self) -> &Self::Target {
+        match self {
+            PyDecodeData::Original(data) => data,
+            PyDecodeData::Modified(data) => data,
+        }
+    }
+}
+
+impl<'a> PyDecodeContext<'a> {
+    pub fn new(encoding: &'a str, data: &'a ArgBytesLike, vm: &'a VirtualMachine) -> Self {
+        Self {
+            vm,
+            encoding,
+            data: PyDecodeData::Original(data.borrow_buf()),
+            orig_bytes: data.as_object().downcast_ref(),
+            pos: 0,
+            exception: OnceCell::new(),
+        }
+    }
+}
+
+impl CodecContext for PyDecodeContext<'_> {
+    type Error = PyBaseExceptionRef;
+    type StrBuf = PyStrRef;
+    type BytesBuf = PyBytesRef;
+
+    fn string(&self, s: Wtf8Buf) -> Self::StrBuf {
+        self.vm.ctx.new_str(s)
+    }
+
+    fn bytes(&self, b: Vec<u8>) -> Self::BytesBuf {
+        self.vm.ctx.new_bytes(b)
+    }
+}
+impl DecodeContext for PyDecodeContext<'_> {
+    fn full_data(&self) -> &[u8] {
+        &self.data
+    }
+
+    fn remaining_data(&self) -> &[u8] {
+        &self.data[self.pos..]
+    }
+
+    fn position(&self) -> usize {
+        self.pos
+    }
+
+    fn advance(&mut self, by: usize) {
+        self.pos += by;
+    }
+
+    fn restart_from(&mut self, pos: usize) -> Result<(), Self::Error> {
+        if pos > self.data.len() {
+            return Err(self
+                .vm
+                .new_index_error(format!("position {pos} from error handler out of bounds",)));
+        }
+        self.pos = pos;
+        Ok(())
+    }
+
+    fn error_decoding(&self, byte_range: Range<usize>, reason: Option<&str>) -> Self::Error {
+        let vm = self.vm;
+
+        match self.exception.get() {
+            Some(exc) => {
+                match update_unicode_error_attrs(
+                    exc.as_object(),
+                    byte_range.start,
+                    byte_range.end,
+                    reason,
+                    vm,
+                ) {
+                    Ok(()) => exc.clone(),
+                    Err(e) => e,
+                }
+            }
+            None => self
+                .exception
+                .get_or_init(|| {
+                    let reason = reason.expect(
+                        "should only ever pass reason: None if an exception is already set",
+                    );
+                    let data = if let Some(bytes) = self.orig_bytes {
+                        bytes.to_owned()
+                    } else {
+                        vm.ctx.new_bytes(self.data.to_vec())
+                    };
+                    vm.new_unicode_decode_error_real(
+                        vm.ctx.new_str(self.encoding),
+                        data,
+                        byte_range.start,
+                        byte_range.end,
+                        vm.ctx.new_str(reason),
+                    )
+                })
+                .clone(),
+        }
+    }
+}
+
+#[derive(strum_macros::EnumString)]
+#[strum(serialize_all = "lowercase")]
+enum StandardError {
+    Strict,
+    Ignore,
+    Replace,
+    XmlCharRefReplace,
+    BackslashReplace,
+    SurrogatePass,
+    SurrogateEscape,
+}
+
+impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for StandardError {
+    fn handle_encode_error(
+        &self,
+        ctx: &mut PyEncodeContext<'a>,
+        range: Range<StrSize>,
+        reason: Option<&str>,
+    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
+        use StandardError::*;
+        // use errors::*;
+        match self {
+            Strict => errors::Strict.handle_encode_error(ctx, range, reason),
+            Ignore => errors::Ignore.handle_encode_error(ctx, range, reason),
+            Replace => errors::Replace.handle_encode_error(ctx, range, reason),
+            XmlCharRefReplace => errors::XmlCharRefReplace.handle_encode_error(ctx, range, reason),
+            BackslashReplace => errors::BackslashReplace.handle_encode_error(ctx, range, reason),
+            SurrogatePass => SurrogatePass.handle_encode_error(ctx, range, reason),
+            SurrogateEscape => errors::SurrogateEscape.handle_encode_error(ctx, range, reason),
+        }
+    }
+}
+
+impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for StandardError {
+    fn handle_decode_error(
+        &self,
+        ctx: &mut PyDecodeContext<'a>,
+        byte_range: Range<usize>,
+        reason: Option<&str>,
+    ) -> PyResult<(PyStrRef, usize)> {
+        use StandardError::*;
+        match self {
+            Strict => errors::Strict.handle_decode_error(ctx, byte_range, reason),
+            Ignore => errors::Ignore.handle_decode_error(ctx, byte_range, reason),
+            Replace => errors::Replace.handle_decode_error(ctx, byte_range, reason),
+            XmlCharRefReplace => Err(ctx
+                .vm
+                .new_type_error("don't know how to handle UnicodeDecodeError in error callback")),
+            BackslashReplace => {
+                errors::BackslashReplace.handle_decode_error(ctx, byte_range, reason)
+            }
+            SurrogatePass => self::SurrogatePass.handle_decode_error(ctx, byte_range, reason),
+            SurrogateEscape => errors::SurrogateEscape.handle_decode_error(ctx, byte_range, reason),
+        }
+    }
+}
+
+pub struct ErrorsHandler<'a> {
+    errors: &'a Py<PyStr>,
+    resolved: OnceCell<ResolvedError>,
+}
+enum ResolvedError {
+    Standard(StandardError),
+    Handler(PyObjectRef),
+}
+
+impl<'a> ErrorsHandler<'a> {
+    #[inline]
+    pub fn new(errors: Option<&'a Py<PyStr>>, 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)),
+            },
+        }
+    }
+    #[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)
+            }
+        })
+    }
+}
+impl StrBuffer for PyStrRef {
+    fn is_compatible_with(&self, kind: StrKind) -> bool {
+        self.kind() <= kind
+    }
+}
+impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for ErrorsHandler<'_> {
+    fn handle_encode_error(
+        &self,
+        ctx: &mut PyEncodeContext<'a>,
+        range: Range<StrSize>,
+        reason: Option<&str>,
+    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
+        let vm = ctx.vm;
+        let handler = match self.resolve(vm)? {
+            ResolvedError::Standard(standard) => {
+                return standard.handle_encode_error(ctx, range, reason);
+            }
+            ResolvedError::Handler(handler) => handler,
+        };
+        let encode_exc = ctx.error_encoding(range.clone(), reason);
+        let res = handler.call((encode_exc.clone(),), vm)?;
+        let tuple_err =
+            || vm.new_type_error("encoding error handler must return (str/bytes, int) tuple");
+        let (replace, restart) = match res.downcast_ref::<PyTuple>().map(|tup| tup.as_slice()) {
+            Some([replace, restart]) => (replace.clone(), restart),
+            _ => return Err(tuple_err()),
+        };
+        let replace = match_class!(match replace {
+            s @ PyStr => EncodeReplace::Str(s),
+            b @ PyBytes => EncodeReplace::Bytes(b),
+            _ => return Err(tuple_err()),
+        });
+        let restart = isize::try_from_borrowed_object(vm, restart).map_err(|_| tuple_err())?;
+        let restart = if restart < 0 {
+            // will still be out of bounds if it underflows ¯\_(ツ)_/¯
+            ctx.data.char_len().wrapping_sub(restart.unsigned_abs())
+        } else {
+            restart as usize
+        };
+        let restart = if restart == range.end.chars {
+            range.end
+        } else {
+            StrSize {
+                chars: restart,
+                bytes: ctx
+                    .data
+                    .as_wtf8()
+                    .code_point_indices()
+                    .nth(restart)
+                    .map_or(ctx.data.byte_len(), |(i, _)| i),
+            }
+        };
+        Ok((replace, restart))
+    }
+}
+impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for ErrorsHandler<'_> {
+    fn handle_decode_error(
+        &self,
+        ctx: &mut PyDecodeContext<'a>,
+        byte_range: Range<usize>,
+        reason: Option<&str>,
+    ) -> PyResult<(PyStrRef, usize)> {
+        let vm = ctx.vm;
+        let handler = match self.resolve(vm)? {
+            ResolvedError::Standard(standard) => {
+                return standard.handle_decode_error(ctx, byte_range, reason);
+            }
+            ResolvedError::Handler(handler) => handler,
+        };
+        let decode_exc = ctx.error_decoding(byte_range.clone(), reason);
+        let data_bytes: PyObjectRef = decode_exc.as_object().get_attr("object", vm)?;
+        let res = handler.call((decode_exc.clone(),), vm)?;
+        let new_data = decode_exc.as_object().get_attr("object", vm)?;
+        if !new_data.is(&data_bytes) {
+            let new_data: PyBytesRef = new_data
+                .downcast()
+                .map_err(|_| vm.new_type_error("object attribute must be bytes"))?;
+            ctx.data = PyDecodeData::Modified(new_data);
+        }
+        let data = &*ctx.data;
+        let tuple_err = || vm.new_type_error("decoding error handler must return (str, int) tuple");
+        match res.downcast_ref::<PyTuple>().map(|tup| tup.as_slice()) {
+            Some([replace, restart]) => {
+                let replace = replace
+                    .downcast_ref::<PyStr>()
+                    .ok_or_else(tuple_err)?
+                    .to_owned();
+                let restart =
+                    isize::try_from_borrowed_object(vm, restart).map_err(|_| tuple_err())?;
+                let restart = if restart < 0 {
+                    // will still be out of bounds if it underflows ¯\_(ツ)_/¯
+                    data.len().wrapping_sub(restart.unsigned_abs())
+                } else {
+                    restart as usize
+                };
+                Ok((replace, restart))
+            }
+            _ => Err(tuple_err()),
+        }
+    }
+}
+
+fn call_native_encode_error<E>(
+    handler: E,
+    err: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, usize)>
+where
+    for<'a> E: EncodeErrorHandler<PyEncodeContext<'a>>,
+{
+    // 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 mut ctx = PyEncodeContext {
+        vm,
+        encoding: s_encoding.as_str(),
+        data: &s,
+        pos: StrSize::default(),
+        exception: OnceCell::with_value(err.downcast().unwrap()),
+    };
+    let mut iter = s.as_wtf8().code_point_indices();
+    let start = StrSize {
+        chars: range.start,
+        bytes: iter.nth(range.start).unwrap().0,
+    };
+    let end = StrSize {
+        chars: range.end,
+        bytes: if let Some(n) = range.len().checked_sub(1) {
+            iter.nth(n).map_or(s.byte_len(), |(i, _)| i)
+        } else {
+            start.bytes
+        },
+    };
+    let (replace, restart) = handler.handle_encode_error(&mut ctx, start..end, None)?;
+    let replace = match replace {
+        EncodeReplace::Str(s) => s.into(),
+        EncodeReplace::Bytes(b) => b.into(),
+    };
+    Ok((replace, restart.chars))
+}
+
+fn call_native_decode_error<E>(
+    handler: E,
+    err: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, usize)>
+where
+    for<'a> E: DecodeErrorHandler<PyDecodeContext<'a>>,
+{
+    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 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()),
+    };
+    let (replace, restart) = handler.handle_decode_error(&mut ctx, range, None)?;
+    Ok((replace.into(), restart))
+}
+
+// this is a hack, for now
+fn call_native_translate_error<E>(
+    handler: E,
+    err: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, usize)>
+where
+    for<'a> E: EncodeErrorHandler<PyEncodeContext<'a>>,
+{
+    // let err = err.
+    let range = extract_unicode_error_range(&err, vm)?;
+    let s = PyStrRef::try_from_object(vm, err.get_attr("object", vm)?)?;
+    let mut ctx = PyEncodeContext {
+        vm,
+        encoding: "",
+        data: &s,
+        pos: StrSize::default(),
+        exception: OnceCell::with_value(err.downcast().unwrap()),
+    };
+    let mut iter = s.as_wtf8().code_point_indices();
+    let start = StrSize {
+        chars: range.start,
+        bytes: iter.nth(range.start).unwrap().0,
+    };
+    let end = StrSize {
+        chars: range.end,
+        bytes: if let Some(n) = range.len().checked_sub(1) {
+            iter.nth(n).map_or(s.byte_len(), |(i, _)| i)
+        } else {
+            start.bytes
+        },
+    };
+    let (replace, restart) = handler.handle_encode_error(&mut ctx, start..end, None)?;
+    let replace = match replace {
+        EncodeReplace::Str(s) => s.into(),
+        EncodeReplace::Bytes(b) => b.into(),
+    };
+    Ok((replace, restart.chars))
+}
+
+// TODO: exceptions with custom payloads
+fn extract_unicode_error_range(err: &PyObject, vm: &VirtualMachine) -> PyResult<Range<usize>> {
+    let start = err.get_attr("start", vm)?;
+    let start = start.try_into_value(vm)?;
+    let end = err.get_attr("end", vm)?;
+    let end = end.try_into_value(vm)?;
+    Ok(Range { start, end })
+}
+
+fn update_unicode_error_attrs(
+    err: &PyObject,
+    start: usize,
+    end: usize,
+    reason: Option<&str>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    err.set_attr("start", start.to_pyobject(vm), vm)?;
+    err.set_attr("end", end.to_pyobject(vm), vm)?;
+    if let Some(reason) = reason {
+        err.set_attr("reason", reason.to_pyobject(vm), vm)?;
+    }
+    Ok(())
+}
+
+#[inline]
+fn is_encode_err(err: &PyObject, vm: &VirtualMachine) -> bool {
+    err.fast_isinstance(vm.ctx.exceptions.unicode_encode_error)
+}
+#[inline]
+fn is_decode_err(err: &PyObject, vm: &VirtualMachine) -> bool {
+    err.fast_isinstance(vm.ctx.exceptions.unicode_decode_error)
+}
+#[inline]
+fn is_translate_err(err: &PyObject, vm: &VirtualMachine) -> bool {
+    err.fast_isinstance(vm.ctx.exceptions.unicode_translate_error)
+}
+
+fn bad_err_type(err: PyObjectRef, vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_type_error(format!(
+        "don't know how to handle {} in error callback",
+        err.class().name()
+    ))
+}
+
+fn strict_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let err = err
+        .downcast()
+        .unwrap_or_else(|_| vm.new_type_error("codec must pass exception instance"));
+    Err(err)
+}
+
+fn ignore_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) || is_decode_err(&err, vm) || is_translate_err(&err, vm) {
+        let range = extract_unicode_error_range(&err, vm)?;
+        Ok((vm.ctx.new_str(ascii!("")).into(), range.end))
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn replace_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) {
+        call_native_encode_error(errors::Replace, err, vm)
+    } else if is_decode_err(&err, vm) {
+        call_native_decode_error(errors::Replace, err, vm)
+    } else if is_translate_err(&err, vm) {
+        // char::REPLACEMENT_CHARACTER as a str
+        let replacement_char = "\u{FFFD}";
+        let range = extract_unicode_error_range(&err, vm)?;
+        let replace = replacement_char.repeat(range.end - range.start);
+        Ok((replace.to_pyobject(vm), range.end))
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn xmlcharrefreplace_errors(
+    err: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) {
+        call_native_encode_error(errors::XmlCharRefReplace, err, vm)
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn backslashreplace_errors(
+    err: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, usize)> {
+    if is_decode_err(&err, vm) {
+        call_native_decode_error(errors::BackslashReplace, err, vm)
+    } else if is_encode_err(&err, vm) {
+        call_native_encode_error(errors::BackslashReplace, err, vm)
+    } else if is_translate_err(&err, vm) {
+        call_native_translate_error(errors::BackslashReplace, err, vm)
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn namereplace_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) {
+        call_native_encode_error(errors::NameReplace, err, vm)
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn surrogatepass_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) {
+        call_native_encode_error(SurrogatePass, err, vm)
+    } else if is_decode_err(&err, vm) {
+        call_native_decode_error(SurrogatePass, err, vm)
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
+
+fn surrogateescape_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
+    if is_encode_err(&err, vm) {
+        call_native_encode_error(errors::SurrogateEscape, err, vm)
+    } else if is_decode_err(&err, vm) {
+        call_native_decode_error(errors::SurrogateEscape, err, vm)
+    } else {
+        Err(bad_err_type(err, vm))
+    }
+}
diff --git a/vm/src/compiler.rs b/crates/vm/src/compiler.rs
similarity index 95%
rename from vm/src/compiler.rs
rename to crates/vm/src/compiler.rs
index 84fea452d1..25fa33302a 100644
--- a/vm/src/compiler.rs
+++ b/crates/vm/src/compiler.rs
@@ -1,11 +1,9 @@
 #[cfg(feature = "codegen")]
 pub use rustpython_codegen::CompileOpts;
+
 #[cfg(feature = "compiler")]
 pub use rustpython_compiler::*;
 
-#[cfg(not(feature = "compiler"))]
-pub use rustpython_compiler_source as source;
-
 #[cfg(not(feature = "compiler"))]
 pub use rustpython_compiler_core::Mode;
 
diff --git a/vm/src/convert/into_object.rs b/crates/vm/src/convert/into_object.rs
similarity index 100%
rename from vm/src/convert/into_object.rs
rename to crates/vm/src/convert/into_object.rs
diff --git a/vm/src/convert/mod.rs b/crates/vm/src/convert/mod.rs
similarity index 100%
rename from vm/src/convert/mod.rs
rename to crates/vm/src/convert/mod.rs
diff --git a/vm/src/convert/to_pyobject.rs b/crates/vm/src/convert/to_pyobject.rs
similarity index 100%
rename from vm/src/convert/to_pyobject.rs
rename to crates/vm/src/convert/to_pyobject.rs
diff --git a/vm/src/convert/transmute_from.rs b/crates/vm/src/convert/transmute_from.rs
similarity index 95%
rename from vm/src/convert/transmute_from.rs
rename to crates/vm/src/convert/transmute_from.rs
index 908188f0d1..c1b4b79384 100644
--- a/vm/src/convert/transmute_from.rs
+++ b/crates/vm/src/convert/transmute_from.rs
@@ -17,7 +17,7 @@ unsafe impl<T: PyPayload> TransmuteFromObject for PyRef<T> {
     fn check(vm: &VirtualMachine, obj: &PyObject) -> PyResult<()> {
         let class = T::class(&vm.ctx);
         if obj.fast_isinstance(class) {
-            if obj.payload_is::<T>() {
+            if obj.downcastable::<T>() {
                 Ok(())
             } else {
                 Err(vm.new_downcast_runtime_error(class, obj))
diff --git a/vm/src/convert/try_from.rs b/crates/vm/src/convert/try_from.rs
similarity index 95%
rename from vm/src/convert/try_from.rs
rename to crates/vm/src/convert/try_from.rs
index d2d83b36e7..ceb7d003e9 100644
--- a/vm/src/convert/try_from.rs
+++ b/crates/vm/src/convert/try_from.rs
@@ -79,8 +79,8 @@ where
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
         let class = T::class(&vm.ctx);
         if obj.fast_isinstance(class) {
-            obj.downcast()
-                .map_err(|obj| vm.new_downcast_runtime_error(class, &obj))
+            T::try_downcast_from(&obj, vm)?;
+            Ok(unsafe { obj.downcast_unchecked() })
         } else {
             Err(vm.new_downcast_type_error(class, &obj))
         }
@@ -122,9 +122,9 @@ impl<'a, T: PyPayload> TryFromBorrowedObject<'a> for &'a Py<T> {
     }
 }
 
-impl TryFromObject for std::time::Duration {
+impl TryFromObject for core::time::Duration {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        if let Some(float) = obj.payload::<PyFloat>() {
+        if let Some(float) = obj.downcast_ref::<PyFloat>() {
             let f = float.to_f64();
             if f < 0.0 {
                 return Err(vm.new_value_error("negative duration"));
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
new file mode 100644
index 0000000000..19830496e6
--- /dev/null
+++ b/crates/vm/src/coroutine.rs
@@ -0,0 +1,258 @@
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
+    builtins::{PyBaseExceptionRef, PyStrRef},
+    common::lock::PyMutex,
+    exceptions::types::PyBaseException,
+    frame::{ExecutionResult, FrameRef},
+    function::OptionalArg,
+    protocol::PyIterReturn,
+};
+use crossbeam_utils::atomic::AtomicCell;
+
+impl ExecutionResult {
+    /// Turn an ExecutionResult into a PyResult that would be returned from a generator or coroutine
+    fn into_iter_return(self, vm: &VirtualMachine) -> PyIterReturn {
+        match self {
+            Self::Yield(value) => PyIterReturn::Return(value),
+            Self::Return(value) => {
+                let arg = if vm.is_none(&value) {
+                    None
+                } else {
+                    Some(value)
+                };
+                PyIterReturn::StopIteration(arg)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Coro {
+    frame: FrameRef,
+    pub closed: AtomicCell<bool>, // TODO: https://github.com/RustPython/RustPython/pull/3183#discussion_r720560652
+    running: AtomicCell<bool>,
+    // code
+    // _weakreflist
+    name: PyMutex<PyStrRef>,
+    qualname: PyMutex<PyStrRef>,
+    exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
+}
+
+fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
+    let typ = jen.class();
+    if typ.is(vm.ctx.types.coroutine_type) {
+        "coroutine"
+    } else if typ.is(vm.ctx.types.async_generator) {
+        "async generator"
+    } else {
+        "generator"
+    }
+}
+
+impl Coro {
+    pub fn new(frame: FrameRef, name: PyStrRef, qualname: PyStrRef) -> Self {
+        Self {
+            frame,
+            closed: AtomicCell::new(false),
+            running: AtomicCell::new(false),
+            exception: PyMutex::default(),
+            name: PyMutex::new(name),
+            qualname: PyMutex::new(qualname),
+        }
+    }
+
+    fn maybe_close(&self, res: &PyResult<ExecutionResult>) {
+        match res {
+            Ok(ExecutionResult::Return(_)) | Err(_) => self.closed.store(true),
+            Ok(ExecutionResult::Yield(_)) => {}
+        }
+    }
+
+    fn run_with_context<F>(
+        &self,
+        jen: &PyObject,
+        vm: &VirtualMachine,
+        func: F,
+    ) -> PyResult<ExecutionResult>
+    where
+        F: FnOnce(FrameRef) -> 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;
+
+        // Run the generator frame
+        // with_frame does push_exception(None) which creates a new exception context
+        // The caller's exception remains in the chain via prev, so topmost_exception()
+        // will find it if generator's exception is None
+        let result = vm.with_frame(self.frame.clone(), |f| {
+            // with_frame pushed None, creating: { exc: None, prev: caller's exc_info }
+            // Pop None and push generator's exception instead
+            // This maintains the chain: { exc: gen_exc, prev: caller's exc_info }
+            vm.pop_exception();
+            vm.push_exception(gen_exc);
+            let result = func(f);
+            // Save generator's exception state BEFORE with_frame pops
+            // This is the generator's current exception context
+            *exception_slot.lock() = vm.current_exception();
+            result
+        });
+
+        self.running.store(false);
+        result
+    }
+
+    pub fn send(
+        &self,
+        jen: &PyObject,
+        value: PyObjectRef,
+        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)),
+            Err(e) => {
+                if e.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
+                    let err =
+                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(jen, vm)));
+                    err.set___cause__(Some(e));
+                    Err(err)
+                } else if jen.class().is(vm.ctx.types.async_generator)
+                    && e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
+                {
+                    let err = vm.new_runtime_error("async generator raised StopAsyncIteration");
+                    err.set___cause__(Some(e));
+                    Err(err)
+                } else {
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    pub fn throw(
+        &self,
+        jen: &PyObject,
+        exc_type: PyObjectRef,
+        exc_val: PyObjectRef,
+        exc_tb: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyIterReturn> {
+        if self.closed.load() {
+            return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
+        }
+        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<()> {
+        if self.closed.load() {
+            return Ok(());
+        }
+        // If generator hasn't started (FRAME_CREATED), just mark as closed
+        if self.frame.lasti() == 0 {
+            self.closed.store(true);
+            return Ok(());
+        }
+        let result = self.run_with_context(jen, vm, |f| {
+            f.gen_throw(
+                vm,
+                vm.ctx.exceptions.generator_exit.to_owned().into(),
+                vm.ctx.none(),
+                vm.ctx.none(),
+            )
+        });
+        self.closed.store(true);
+        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(()),
+        }
+    }
+
+    pub fn running(&self) -> bool {
+        self.running.load()
+    }
+
+    pub fn closed(&self) -> bool {
+        self.closed.load()
+    }
+
+    pub fn frame(&self) -> FrameRef {
+        self.frame.clone()
+    }
+
+    pub fn name(&self) -> PyStrRef {
+        self.name.lock().clone()
+    }
+
+    pub fn set_name(&self, name: PyStrRef) {
+        *self.name.lock() = name;
+    }
+
+    pub fn qualname(&self) -> PyStrRef {
+        self.qualname.lock().clone()
+    }
+
+    pub fn set_qualname(&self, qualname: PyStrRef) {
+        *self.qualname.lock() = qualname;
+    }
+
+    pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
+        format!(
+            "<{} object {} at {:#x}>",
+            gen_name(jen, vm),
+            self.name.lock(),
+            id
+        )
+    }
+}
+
+pub fn is_gen_exit(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> bool {
+    exc.fast_isinstance(vm.ctx.exceptions.generator_exit)
+}
+
+/// Emit DeprecationWarning for the deprecated 3-argument throw() signature.
+pub fn warn_deprecated_throw_signature(
+    exc_val: &OptionalArg,
+    exc_tb: &OptionalArg,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    if exc_val.is_present() || exc_tb.is_present() {
+        crate::warn::warn(
+            vm.ctx.new_str(
+                "the (type, val, tb) signature of throw() is deprecated, \
+                 use throw(val) instead",
+            ),
+            Some(vm.ctx.exceptions.deprecation_warning.to_owned()),
+            1,
+            None,
+            vm,
+        )?;
+    }
+    Ok(())
+}
diff --git a/vm/src/dict_inner.rs b/crates/vm/src/dict_inner.rs
similarity index 96%
rename from vm/src/dict_inner.rs
rename to crates/vm/src/dict_inner.rs
index 000a22b6e3..1d9fe8403a 100644
--- a/vm/src/dict_inner.rs
+++ b/crates/vm/src/dict_inner.rs
@@ -16,8 +16,9 @@ use crate::{
     },
     object::{Traverse, TraverseFn},
 };
+use alloc::fmt;
+use core::{mem::size_of, ops::ControlFlow};
 use num_traits::ToPrimitive;
-use std::{fmt, mem::size_of, ops::ControlFlow};
 
 // HashIndex is intended to be same size with hash::PyHash
 // but it doesn't mean the values are compatible with actual PyHash value
@@ -281,7 +282,7 @@ impl<T: Clone> Dict<T> {
                         continue;
                     };
                     if entry.index == index_index {
-                        let removed = std::mem::replace(&mut entry.value, value);
+                        let removed = core::mem::replace(&mut entry.value, value);
                         // defer dec RC
                         break Some(removed);
                     } else {
@@ -357,7 +358,7 @@ impl<T: Clone> Dict<T> {
             inner.used = 0;
             inner.filled = 0;
             // defer dec rc
-            std::mem::take(&mut inner.entries)
+            core::mem::take(&mut inner.entries)
         };
     }
 
@@ -552,6 +553,22 @@ impl<T: Clone> Dict<T> {
             .collect()
     }
 
+    pub fn values(&self) -> Vec<T> {
+        self.read()
+            .entries
+            .iter()
+            .filter_map(|v| v.as_ref().map(|v| v.value.clone()))
+            .collect()
+    }
+
+    pub fn items(&self) -> Vec<(PyObjectRef, T)> {
+        self.read()
+            .entries
+            .iter()
+            .filter_map(|v| v.as_ref().map(|v| (v.key.clone(), v.value.clone())))
+            .collect()
+    }
+
     pub fn try_fold_keys<Acc, Fold>(&self, init: Acc, f: Fold) -> PyResult<Acc>
     where
         Fold: FnMut(Acc, &PyObject) -> PyResult<Acc>,
@@ -633,7 +650,7 @@ impl<T: Clone> Dict<T> {
 
     // returns Err(()) if changed since lookup
     fn pop_inner(&self, lookup: LookupResult) -> PopInnerResult<T> {
-        self.pop_inner_if(lookup, |_| Ok::<_, std::convert::Infallible>(true))
+        self.pop_inner_if(lookup, |_| Ok::<_, core::convert::Infallible>(true))
             .unwrap_or_else(|x| match x {})
     }
 
@@ -777,7 +794,7 @@ impl DictKey for Py<PyStr> {
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
         if self.is(other_key) {
             Ok(true)
-        } else if let Some(pystr) = other_key.payload_if_exact::<PyStr>(vm) {
+        } else if let Some(pystr) = other_key.downcast_ref_if_exact::<PyStr>(vm) {
             Ok(self.as_wtf8() == pystr.as_wtf8())
         } else {
             vm.bool_eq(self.as_object(), other_key)
@@ -875,7 +892,7 @@ impl DictKey for str {
     }
 
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
-        if let Some(pystr) = other_key.payload_if_exact::<PyStr>(vm) {
+        if let Some(pystr) = other_key.downcast_ref_if_exact::<PyStr>(vm) {
             Ok(pystr.as_wtf8() == self)
         } else {
             // Fall back to PyObjectRef implementation.
@@ -936,7 +953,7 @@ impl DictKey for Wtf8 {
     }
 
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
-        if let Some(pystr) = other_key.payload_if_exact::<PyStr>(vm) {
+        if let Some(pystr) = other_key.downcast_ref_if_exact::<PyStr>(vm) {
             Ok(pystr.as_wtf8() == self)
         } else {
             // Fall back to PyObjectRef implementation.
@@ -997,7 +1014,7 @@ impl DictKey for [u8] {
     }
 
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
-        if let Some(pystr) = other_key.payload_if_exact::<PyBytes>(vm) {
+        if let Some(pystr) = other_key.downcast_ref_if_exact::<PyBytes>(vm) {
             Ok(pystr.as_bytes() == self)
         } else {
             // Fall back to PyObjectRef implementation.
@@ -1053,7 +1070,7 @@ impl DictKey for usize {
     }
 
     fn key_eq(&self, vm: &VirtualMachine, other_key: &PyObject) -> PyResult<bool> {
-        if let Some(int) = other_key.payload_if_exact::<PyInt>(vm) {
+        if let Some(int) = other_key.downcast_ref_if_exact::<PyInt>(vm) {
             if let Some(i) = int.as_bigint().to_usize() {
                 Ok(i == *self)
             } else {
diff --git a/vm/src/eval.rs b/crates/vm/src/eval.rs
similarity index 100%
rename from vm/src/eval.rs
rename to crates/vm/src/eval.rs
diff --git a/crates/vm/src/exception_group.rs b/crates/vm/src/exception_group.rs
new file mode 100644
index 0000000000..a55273480f
--- /dev/null
+++ b/crates/vm/src/exception_group.rs
@@ -0,0 +1,477 @@
+//! ExceptionGroup implementation for Python 3.11+
+//!
+//! This module implements BaseExceptionGroup and ExceptionGroup with multiple inheritance support.
+
+use crate::builtins::{PyList, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef};
+use crate::function::{ArgIterable, FuncArgs};
+use crate::types::{PyTypeFlags, PyTypeSlots};
+use crate::{
+    AsObject, Context, Py, PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
+};
+
+use crate::exceptions::types::PyBaseException;
+
+/// Create dynamic ExceptionGroup type with multiple inheritance
+fn create_exception_group(ctx: &Context) -> PyRef<PyType> {
+    let excs = &ctx.exceptions;
+    let exception_group_slots = PyTypeSlots {
+        flags: PyTypeFlags::heap_type_flags() | PyTypeFlags::HAS_DICT,
+        ..Default::default()
+    };
+    PyType::new_heap(
+        "ExceptionGroup",
+        vec![
+            excs.base_exception_group.to_owned(),
+            excs.exception_type.to_owned(),
+        ],
+        Default::default(),
+        exception_group_slots,
+        ctx.types.type_type.to_owned(),
+        ctx,
+    )
+    .expect("Failed to create ExceptionGroup type with multiple inheritance")
+}
+
+pub fn exception_group() -> &'static Py<PyType> {
+    ::rustpython_vm::common::static_cell! {
+        static CELL: ::rustpython_vm::builtins::PyTypeRef;
+    }
+    CELL.get_or_init(|| create_exception_group(Context::genesis()))
+}
+
+pub(super) mod types {
+    use super::*;
+    use crate::PyPayload;
+    use crate::builtins::PyGenericAlias;
+    use crate::types::{Constructor, Initializer};
+
+    #[pyexception(name, base = PyBaseException, ctx = "base_exception_group")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyBaseExceptionGroup(PyBaseException);
+
+    #[pyexception(with(Constructor, Initializer))]
+    impl PyBaseExceptionGroup {
+        #[pyclassmethod]
+        fn __class_getitem__(
+            cls: PyTypeRef,
+            args: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyGenericAlias {
+            PyGenericAlias::from_args(cls, args, vm)
+        }
+
+        #[pymethod]
+        fn derive(
+            zelf: PyRef<PyBaseException>,
+            excs: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let message = zelf.get_arg(0).unwrap_or_else(|| vm.ctx.new_str("").into());
+            vm.invoke_exception(
+                vm.ctx.exceptions.base_exception_group.to_owned(),
+                vec![message, excs],
+            )
+            .map(|e| e.into())
+        }
+
+        #[pymethod]
+        fn subgroup(
+            zelf: PyRef<PyBaseException>,
+            condition: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let matcher = get_condition_matcher(&condition, vm)?;
+
+            // If self matches the condition entirely, return self
+            let zelf_obj: PyObjectRef = zelf.clone().into();
+            if matcher.check(&zelf_obj, vm)? {
+                return Ok(zelf_obj);
+            }
+
+            let exceptions = get_exceptions_tuple(&zelf, vm)?;
+            let mut matching: Vec<PyObjectRef> = Vec::new();
+            let mut modified = false;
+
+            for exc in exceptions {
+                if is_base_exception_group(&exc, vm) {
+                    // Recursive call for nested groups
+                    let subgroup_result = vm.call_method(&exc, "subgroup", (condition.clone(),))?;
+                    if !vm.is_none(&subgroup_result) {
+                        matching.push(subgroup_result.clone());
+                    }
+                    if !subgroup_result.is(&exc) {
+                        modified = true;
+                    }
+                } else if matcher.check(&exc, vm)? {
+                    matching.push(exc);
+                } else {
+                    modified = true;
+                }
+            }
+
+            if !modified {
+                return Ok(zelf.clone().into());
+            }
+
+            if matching.is_empty() {
+                return Ok(vm.ctx.none());
+            }
+
+            // Create new group with matching exceptions and copy metadata
+            derive_and_copy_attributes(&zelf, matching, vm)
+        }
+
+        #[pymethod]
+        fn split(
+            zelf: PyRef<PyBaseException>,
+            condition: PyObjectRef,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyTupleRef> {
+            let matcher = get_condition_matcher(&condition, vm)?;
+
+            // If self matches the condition entirely
+            let zelf_obj: PyObjectRef = zelf.clone().into();
+            if matcher.check(&zelf_obj, vm)? {
+                return Ok(vm.ctx.new_tuple(vec![zelf_obj, vm.ctx.none()]));
+            }
+
+            let exceptions = get_exceptions_tuple(&zelf, vm)?;
+            let mut matching: Vec<PyObjectRef> = Vec::new();
+            let mut rest: Vec<PyObjectRef> = Vec::new();
+
+            for exc in exceptions {
+                if is_base_exception_group(&exc, vm) {
+                    let result = vm.call_method(&exc, "split", (condition.clone(),))?;
+                    let result_tuple: PyTupleRef = result.try_into_value(vm)?;
+                    let match_part = result_tuple
+                        .first()
+                        .cloned()
+                        .unwrap_or_else(|| vm.ctx.none());
+                    let rest_part = result_tuple
+                        .get(1)
+                        .cloned()
+                        .unwrap_or_else(|| vm.ctx.none());
+
+                    if !vm.is_none(&match_part) {
+                        matching.push(match_part);
+                    }
+                    if !vm.is_none(&rest_part) {
+                        rest.push(rest_part);
+                    }
+                } else if matcher.check(&exc, vm)? {
+                    matching.push(exc);
+                } else {
+                    rest.push(exc);
+                }
+            }
+
+            let match_group = if matching.is_empty() {
+                vm.ctx.none()
+            } else {
+                derive_and_copy_attributes(&zelf, matching, vm)?
+            };
+
+            let rest_group = if rest.is_empty() {
+                vm.ctx.none()
+            } else {
+                derive_and_copy_attributes(&zelf, rest, vm)?
+            };
+
+            Ok(vm.ctx.new_tuple(vec![match_group, rest_group]))
+        }
+
+        #[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 num_excs = zelf
+                .get_arg(1)
+                .and_then(|obj| obj.downcast_ref::<PyTuple>().map(|t| t.len()))
+                .unwrap_or(0);
+
+            let suffix = if num_excs == 1 { "" } else { "s" };
+            Ok(vm.ctx.new_str(format!(
+                "{} ({} sub-exception{})",
+                message, num_excs, suffix
+            )))
+        }
+
+        #[pyslot]
+        fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let zelf = zelf
+                .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 iter: ArgIterable<PyObjectRef> =
+                    ArgIterable::try_from_object(vm, exceptions_obj.clone())?;
+                let mut exc_repr_list = Vec::new();
+                for exc in iter.iter(vm)? {
+                    exc_repr_list.push(exc?.repr(vm)?.as_str().to_owned());
+                }
+                format!("[{}]", exc_repr_list.join(", "))
+            } else {
+                "[]".to_owned()
+            };
+
+            Ok(vm
+                .ctx
+                .new_str(format!("{}({}, {})", class_name, message, exceptions_str)))
+        }
+    }
+
+    impl Constructor for PyBaseExceptionGroup {
+        type Args = crate::function::PosArgs;
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let args: Self::Args = args.bind(vm)?;
+            let args = args.into_vec();
+            // Validate exactly 2 positional arguments
+            if args.len() != 2 {
+                return Err(vm.new_type_error(format!(
+                    "BaseExceptionGroup.__new__() takes exactly 2 positional arguments ({} given)",
+                    args.len()
+                )));
+            }
+
+            // Validate message is str
+            let message = args[0].clone();
+            if !message.fast_isinstance(vm.ctx.types.str_type) {
+                return Err(vm.new_type_error(format!(
+                    "argument 1 must be str, not {}",
+                    message.class().name()
+                )));
+            }
+
+            // Validate exceptions is a sequence (not set or None)
+            let exceptions_arg = &args[1];
+
+            // Check for set/frozenset (not a sequence - unordered)
+            if exceptions_arg.fast_isinstance(vm.ctx.types.set_type)
+                || exceptions_arg.fast_isinstance(vm.ctx.types.frozenset_type)
+            {
+                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
+            }
+
+            // Check for None
+            if exceptions_arg.is(&vm.ctx.none) {
+                return Err(vm.new_type_error("second argument (exceptions) must be a sequence"));
+            }
+
+            let exceptions: Vec<PyObjectRef> = exceptions_arg.try_to_value(vm).map_err(|_| {
+                vm.new_type_error("second argument (exceptions) must be a sequence")
+            })?;
+
+            // Validate non-empty
+            if exceptions.is_empty() {
+                return Err(vm.new_value_error(
+                    "second argument (exceptions) must be a non-empty sequence".to_owned(),
+                ));
+            }
+
+            // Validate all items are BaseException instances
+            let mut has_non_exception = false;
+            for (i, exc) in exceptions.iter().enumerate() {
+                if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_type) {
+                    return Err(vm.new_value_error(format!(
+                        "Item {} of second argument (exceptions) is not an exception",
+                        i
+                    )));
+                }
+                // Check if any exception is not an Exception subclass
+                // With dynamic ExceptionGroup (inherits from both BaseExceptionGroup and Exception),
+                // ExceptionGroup instances are automatically instances of Exception
+                if !exc.fast_isinstance(vm.ctx.exceptions.exception_type) {
+                    has_non_exception = true;
+                }
+            }
+
+            // Get the dynamic ExceptionGroup type
+            let exception_group_type = crate::exception_group::exception_group();
+
+            // Determine the actual class to use
+            let actual_cls = if cls.is(exception_group_type) {
+                // ExceptionGroup cannot contain BaseExceptions that are not Exception
+                if has_non_exception {
+                    return Err(
+                        vm.new_type_error("Cannot nest BaseExceptions in an ExceptionGroup")
+                    );
+                }
+                cls
+            } else if cls.is(vm.ctx.exceptions.base_exception_group) {
+                // Auto-convert to ExceptionGroup if all are Exception subclasses
+                if !has_non_exception {
+                    exception_group_type.to_owned()
+                } else {
+                    cls
+                }
+            } else {
+                // User-defined subclass
+                if has_non_exception && cls.fast_issubclass(vm.ctx.exceptions.exception_type) {
+                    return Err(vm.new_type_error(format!(
+                        "Cannot nest BaseExceptions in '{}'",
+                        cls.name()
+                    )));
+                }
+                cls
+            };
+
+            // Create the exception with (message, exceptions_tuple) as args
+            let exceptions_tuple = vm.ctx.new_tuple(exceptions);
+            let init_args = vec![message, exceptions_tuple.into()];
+            PyBaseException::new(init_args, vm)
+                .into_ref_with_type(vm, actual_cls)
+                .map(Into::into)
+        }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
+    }
+
+    impl Initializer for PyBaseExceptionGroup {
+        type Args = FuncArgs;
+
+        fn slot_init(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
+            // No-op: __new__ already set up the correct args (message, exceptions_tuple)
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is overridden")
+        }
+    }
+
+    // Helper functions for ExceptionGroup
+    fn is_base_exception_group(obj: &PyObject, vm: &VirtualMachine) -> bool {
+        obj.fast_isinstance(vm.ctx.exceptions.base_exception_group)
+    }
+
+    fn get_exceptions_tuple(
+        exc: &Py<PyBaseException>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<PyObjectRef>> {
+        let obj = exc
+            .get_arg(1)
+            .ok_or_else(|| vm.new_type_error("exceptions must be a tuple"))?;
+        let tuple = obj
+            .downcast_ref::<PyTuple>()
+            .ok_or_else(|| vm.new_type_error("exceptions must be a tuple"))?;
+        Ok(tuple.to_vec())
+    }
+
+    enum ConditionMatcher {
+        Type(PyTypeRef),
+        Types(Vec<PyTypeRef>),
+        Callable(PyObjectRef),
+    }
+
+    fn get_condition_matcher(
+        condition: &PyObject,
+        vm: &VirtualMachine,
+    ) -> PyResult<ConditionMatcher> {
+        // If it's a type and subclass of BaseException
+        if let Some(typ) = condition.downcast_ref::<PyType>()
+            && typ.fast_issubclass(vm.ctx.exceptions.base_exception_type)
+        {
+            return Ok(ConditionMatcher::Type(typ.to_owned()));
+        }
+
+        // If it's a tuple of types
+        if let Some(tuple) = condition.downcast_ref::<PyTuple>() {
+            let mut types = Vec::new();
+            for item in tuple.iter() {
+                let typ: PyTypeRef = item.clone().try_into_value(vm).map_err(|_| {
+                    vm.new_type_error(
+                        "expected a function, exception type or tuple of exception types",
+                    )
+                })?;
+                if !typ.fast_issubclass(vm.ctx.exceptions.base_exception_type) {
+                    return Err(vm.new_type_error(
+                        "expected a function, exception type or tuple of exception types",
+                    ));
+                }
+                types.push(typ);
+            }
+            if !types.is_empty() {
+                return Ok(ConditionMatcher::Types(types));
+            }
+        }
+
+        // If it's callable (but not a type)
+        if condition.is_callable() && condition.downcast_ref::<PyType>().is_none() {
+            return Ok(ConditionMatcher::Callable(condition.to_owned()));
+        }
+
+        Err(vm.new_type_error("expected a function, exception type or tuple of exception types"))
+    }
+
+    impl ConditionMatcher {
+        fn check(&self, exc: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+            match self {
+                ConditionMatcher::Type(typ) => Ok(exc.fast_isinstance(typ)),
+                ConditionMatcher::Types(types) => Ok(types.iter().any(|t| exc.fast_isinstance(t))),
+                ConditionMatcher::Callable(func) => {
+                    let result = func.call((exc.to_owned(),), vm)?;
+                    result.try_to_bool(vm)
+                }
+            }
+        }
+    }
+
+    fn derive_and_copy_attributes(
+        orig: &Py<PyBaseException>,
+        excs: Vec<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        // Call derive method to create new group
+        let excs_seq = vm.ctx.new_list(excs);
+        let new_group = vm.call_method(orig.as_object(), "derive", (excs_seq,))?;
+
+        // Verify derive returned a BaseExceptionGroup
+        if !is_base_exception_group(&new_group, vm) {
+            return Err(vm.new_type_error("derive must return an instance of BaseExceptionGroup"));
+        }
+
+        // Copy traceback
+        if let Some(tb) = orig.__traceback__() {
+            new_group.set_attr("__traceback__", tb, vm)?;
+        }
+
+        // Copy context
+        if let Some(ctx) = orig.__context__() {
+            new_group.set_attr("__context__", ctx, vm)?;
+        }
+
+        // Copy cause
+        if let Some(cause) = orig.__cause__() {
+            new_group.set_attr("__cause__", cause, vm)?;
+        }
+
+        // Copy notes (if present) - make a copy of the list
+        if let Ok(notes) = orig.as_object().get_attr("__notes__", vm)
+            && let Some(notes_list) = notes.downcast_ref::<PyList>()
+        {
+            let notes_copy = vm.ctx.new_list(notes_list.borrow_vec().to_vec());
+            new_group.set_attr("__notes__", notes_copy, vm)?;
+        }
+
+        Ok(new_group)
+    }
+}
diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
new file mode 100644
index 0000000000..a2b0865582
--- /dev/null
+++ b/crates/vm/src/exceptions.rs
@@ -0,0 +1,2803 @@
+use self::types::{PyBaseException, PyBaseExceptionRef};
+use crate::common::lock::PyRwLock;
+use crate::object::{Traverse, TraverseFn};
+use crate::{
+    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::{
+        PyList, PyNone, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
+        traceback::{PyTraceback, PyTracebackRef},
+    },
+    class::{PyClassImpl, StaticType},
+    convert::{ToPyException, ToPyObject},
+    function::{ArgIterable, FuncArgs, IntoFuncArgs, PySetterValue},
+    py_io::{self, Write},
+    stdlib::sys,
+    suggestion::offer_suggestions,
+    types::{Callable, Constructor, Initializer, Representable},
+};
+use crossbeam_utils::atomic::AtomicCell;
+use itertools::Itertools;
+use std::{
+    collections::HashSet,
+    io::{self, BufRead, BufReader},
+};
+
+pub use super::exception_group::exception_group;
+
+unsafe impl Traverse for PyBaseException {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.traceback.traverse(tracer_fn);
+        self.cause.traverse(tracer_fn);
+        self.context.traverse(tracer_fn);
+        self.args.traverse(tracer_fn);
+    }
+}
+
+impl core::fmt::Debug for PyBaseException {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        // TODO: implement more detailed, non-recursive Debug formatter
+        f.write_str("PyBaseException")
+    }
+}
+
+impl PyPayload for PyBaseException {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.exceptions.base_exception_type
+    }
+}
+
+impl VirtualMachine {
+    // Why `impl VirtualMachine`?
+    // These functions are natively free function in CPython - not methods of PyException
+
+    /// Print exception chain by calling sys.excepthook
+    pub fn print_exception(&self, exc: PyBaseExceptionRef) {
+        let vm = self;
+        let write_fallback = |exc, errstr| {
+            if let Ok(stderr) = sys::get_stderr(vm) {
+                let mut stderr = py_io::PyWriter(stderr, vm);
+                // if this fails stderr might be closed -- ignore it
+                let _ = writeln!(stderr, "{errstr}");
+                let _ = self.write_exception(&mut stderr, exc);
+            } else {
+                eprintln!("{errstr}\nlost sys.stderr");
+                let _ = self.write_exception(&mut py_io::IoWriter(io::stderr()), exc);
+            }
+        };
+        if let Ok(excepthook) = vm.sys_module.get_attr("excepthook", vm) {
+            let (exc_type, exc_val, exc_tb) = vm.split_exception(exc.clone());
+            if let Err(eh_exc) = excepthook.call((exc_type, exc_val, exc_tb), vm) {
+                write_fallback(&eh_exc, "Error in sys.excepthook:");
+                write_fallback(&exc, "Original exception was:");
+            }
+        } else {
+            write_fallback(&exc, "missing sys.excepthook");
+        }
+    }
+
+    pub fn write_exception<W: Write>(
+        &self,
+        output: &mut W,
+        exc: &Py<PyBaseException>,
+    ) -> Result<(), W::Error> {
+        let seen = &mut HashSet::<usize>::new();
+        self.write_exception_recursive(output, exc, seen)
+    }
+
+    fn write_exception_recursive<W: Write>(
+        &self,
+        output: &mut W,
+        exc: &Py<PyBaseException>,
+        seen: &mut HashSet<usize>,
+    ) -> Result<(), W::Error> {
+        // This function should not be called directly,
+        // use `wite_exception` as a public interface.
+        // It is similar to `print_exception_recursive` from `CPython`.
+        seen.insert(exc.get_id());
+
+        #[allow(clippy::manual_map)]
+        if let Some((cause_or_context, msg)) = if let Some(cause) = exc.__cause__() {
+            // This can be a special case: `raise e from e`,
+            // we just ignore it and treat like `raise e` without any extra steps.
+            Some((
+                cause,
+                "\nThe above exception was the direct cause of the following exception:\n",
+            ))
+        } else if let Some(context) = exc.__context__() {
+            // This can be a special case:
+            //   e = ValueError('e')
+            //   e.__context__ = e
+            // In this case, we just ignore
+            // `__context__` part from going into recursion.
+            Some((
+                context,
+                "\nDuring handling of the above exception, another exception occurred:\n",
+            ))
+        } else {
+            None
+        } {
+            if !seen.contains(&cause_or_context.get_id()) {
+                self.write_exception_recursive(output, &cause_or_context, seen)?;
+                writeln!(output, "{msg}")?;
+            } else {
+                seen.insert(cause_or_context.get_id());
+            }
+        }
+
+        self.write_exception_inner(output, exc)
+    }
+
+    /// Print exception with traceback
+    pub fn write_exception_inner<W: Write>(
+        &self,
+        output: &mut W,
+        exc: &Py<PyBaseException>,
+    ) -> Result<(), W::Error> {
+        let vm = self;
+        if let Some(tb) = exc.traceback.read().clone() {
+            writeln!(output, "Traceback (most recent call last):")?;
+            for tb in tb.iter() {
+                write_traceback_entry(output, &tb)?;
+            }
+        }
+
+        let varargs = exc.args();
+        let args_repr = vm.exception_args_as_string(varargs, true);
+
+        let exc_class = exc.class();
+
+        if exc_class.fast_issubclass(vm.ctx.exceptions.syntax_error) {
+            return self.write_syntaxerror(output, exc, exc_class, &args_repr);
+        }
+
+        let exc_name = exc_class.name();
+        match args_repr.len() {
+            0 => write!(output, "{exc_name}"),
+            1 => write!(output, "{}: {}", exc_name, args_repr[0]),
+            _ => write!(
+                output,
+                "{}: ({})",
+                exc_name,
+                args_repr.into_iter().format(", "),
+            ),
+        }?;
+
+        match offer_suggestions(exc, vm) {
+            Some(suggestions) => writeln!(output, ". Did you mean: '{suggestions}'?"),
+            None => writeln!(output),
+        }
+    }
+
+    /// Format and write a SyntaxError
+    /// This logic is derived from TracebackException._format_syntax_error
+    ///
+    /// The logic has support for `end_offset` to highlight a range in the source code,
+    /// but it looks like `end_offset` is not used yet when SyntaxErrors are created.
+    fn write_syntaxerror<W: Write>(
+        &self,
+        output: &mut W,
+        exc: &Py<PyBaseException>,
+        exc_type: &Py<PyType>,
+        args_repr: &[PyRef<PyStr>],
+    ) -> Result<(), W::Error> {
+        let vm = self;
+        debug_assert!(exc_type.fast_issubclass(vm.ctx.exceptions.syntax_error));
+
+        let getattr = |attr: &'static str| exc.as_object().get_attr(attr, vm).ok();
+
+        let maybe_lineno = getattr("lineno").map(|obj| {
+            obj.str(vm)
+                .unwrap_or_else(|_| vm.ctx.new_str("<lineno str() failed>"))
+        });
+        let maybe_filename = getattr("filename").and_then(|obj| obj.str(vm).ok());
+
+        let maybe_text = getattr("text").map(|obj| {
+            obj.str(vm)
+                .unwrap_or_else(|_| vm.ctx.new_str("<text str() failed>"))
+        });
+
+        let mut filename_suffix = String::new();
+
+        if let Some(lineno) = maybe_lineno {
+            let filename = match maybe_filename {
+                Some(filename) => filename,
+                None => vm.ctx.new_str("<string>"),
+            };
+            writeln!(output, r##"  File "{filename}", line {lineno}"##,)?;
+        } else if let Some(filename) = maybe_filename {
+            filename_suffix = format!(" ({filename})");
+        }
+
+        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
+            let spaces = (r_text.len() - l_text.len()) as isize;
+
+            writeln!(output, "    {l_text}")?;
+
+            let maybe_offset: Option<isize> =
+                getattr("offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+
+            if let Some(offset) = maybe_offset {
+                let maybe_end_offset: Option<isize> =
+                    getattr("end_offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+                let maybe_end_lineno: Option<isize> =
+                    getattr("end_lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+                let maybe_lineno_int: Option<isize> =
+                    getattr("lineno").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
+
+                // Only show caret if end_lineno is same as lineno (or not set)
+                let same_line = match (maybe_lineno_int, maybe_end_lineno) {
+                    (Some(lineno), Some(end_lineno)) => lineno == end_lineno,
+                    _ => true,
+                };
+
+                if same_line {
+                    let mut end_offset = match maybe_end_offset {
+                        Some(0) | None => offset,
+                        Some(end_offset) => end_offset,
+                    };
+
+                    if offset == end_offset || end_offset == -1 {
+                        end_offset = offset + 1;
+                    }
+
+                    // Convert 1-based column offset to 0-based index into stripped text
+                    let colno = offset - 1 - spaces;
+                    let end_colno = end_offset - 1 - spaces;
+                    if colno >= 0 {
+                        let caret_space = l_text
+                            .chars()
+                            .take(colno as usize)
+                            .map(|c| if c.is_whitespace() { c } else { ' ' })
+                            .collect::<String>();
+
+                        let mut error_width = end_colno - colno;
+                        if error_width < 1 {
+                            error_width = 1;
+                        }
+
+                        writeln!(
+                            output,
+                            "    {}{}",
+                            caret_space,
+                            "^".repeat(error_width as usize)
+                        )?;
+                    }
+                }
+            }
+        }
+
+        let exc_name = exc_type.name();
+
+        match args_repr.len() {
+            0 => write!(output, "{exc_name}{filename_suffix}"),
+            1 => write!(output, "{}: {}{}", exc_name, args_repr[0], filename_suffix),
+            _ => write!(
+                output,
+                "{}: ({}){}",
+                exc_name,
+                args_repr.iter().format(", "),
+                filename_suffix
+            ),
+        }?;
+
+        match offer_suggestions(exc, vm) {
+            Some(suggestions) => writeln!(output, ". Did you mean: '{suggestions}'?"),
+            None => writeln!(output),
+        }
+    }
+
+    fn exception_args_as_string(&self, varargs: PyTupleRef, str_single: bool) -> Vec<PyStrRef> {
+        let vm = self;
+        match varargs.len() {
+            0 => vec![],
+            1 => {
+                let args0_repr = if str_single {
+                    varargs[0]
+                        .str(vm)
+                        .unwrap_or_else(|_| PyStr::from("<element str() failed>").into_ref(&vm.ctx))
+                } else {
+                    varargs[0].repr(vm).unwrap_or_else(|_| {
+                        PyStr::from("<element repr() failed>").into_ref(&vm.ctx)
+                    })
+                };
+                vec![args0_repr]
+            }
+            _ => varargs
+                .iter()
+                .map(|vararg| {
+                    vararg.repr(vm).unwrap_or_else(|_| {
+                        PyStr::from("<element repr() failed>").into_ref(&vm.ctx)
+                    })
+                })
+                .collect(),
+        }
+    }
+
+    pub fn split_exception(
+        &self,
+        exc: PyBaseExceptionRef,
+    ) -> (PyObjectRef, PyObjectRef, PyObjectRef) {
+        let tb = exc.__traceback__().to_pyobject(self);
+        let class = exc.class().to_owned();
+        (class.into(), exc.into(), tb)
+    }
+
+    /// Similar to PyErr_NormalizeException in CPython
+    pub fn normalize_exception(
+        &self,
+        exc_type: PyObjectRef,
+        exc_val: PyObjectRef,
+        exc_tb: PyObjectRef,
+    ) -> PyResult<PyBaseExceptionRef> {
+        let ctor = ExceptionCtor::try_from_object(self, exc_type)?;
+        let exc = ctor.instantiate_value(exc_val, self)?;
+        if let Some(tb) = Option::<PyTracebackRef>::try_from_object(self, exc_tb)? {
+            exc.set_traceback_typed(Some(tb));
+        }
+        Ok(exc)
+    }
+
+    pub fn invoke_exception(
+        &self,
+        cls: PyTypeRef,
+        args: Vec<PyObjectRef>,
+    ) -> 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)
+    }
+}
+
+fn print_source_line<W: Write>(
+    output: &mut W,
+    filename: &str,
+    lineno: usize,
+) -> Result<(), W::Error> {
+    // TODO: use io.open() method instead, when available, according to https://github.com/python/cpython/blob/main/Python/traceback.c#L393
+    // TODO: support different encodings
+    let file = match std::fs::File::open(filename) {
+        Ok(file) => file,
+        Err(_) => return Ok(()),
+    };
+    let file = BufReader::new(file);
+
+    for (i, line) in file.lines().enumerate() {
+        if i + 1 == lineno {
+            if let Ok(line) = line {
+                // Indented with 4 spaces
+                writeln!(output, "    {}", line.trim_start())?;
+            }
+            return Ok(());
+        }
+    }
+
+    Ok(())
+}
+
+/// Print exception occurrence location from traceback element
+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();
+    writeln!(
+        output,
+        r##"  File "{}", line {}, in {}"##,
+        filename.trim_start_matches(r"\\?\"),
+        tb_entry.lineno,
+        tb_entry.frame.code.obj_name
+    )?;
+    print_source_line(output, filename, tb_entry.lineno.get())?;
+
+    Ok(())
+}
+
+#[derive(Clone)]
+pub enum ExceptionCtor {
+    Class(PyTypeRef),
+    Instance(PyBaseExceptionRef),
+}
+
+impl TryFromObject for ExceptionCtor {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        obj.downcast::<PyType>()
+            .and_then(|cls| {
+                if cls.fast_issubclass(vm.ctx.exceptions.base_exception_type) {
+                    Ok(Self::Class(cls))
+                } else {
+                    Err(cls.into())
+                }
+            })
+            .or_else(|obj| obj.downcast::<PyBaseException>().map(Self::Instance))
+            .map_err(|obj| {
+                vm.new_type_error(format!(
+                    "exceptions must be classes or instances deriving from BaseException, not {}",
+                    obj.class().name()
+                ))
+            })
+    }
+}
+
+impl ExceptionCtor {
+    pub fn instantiate(self, vm: &VirtualMachine) -> PyResult<PyBaseExceptionRef> {
+        match self {
+            Self::Class(cls) => vm.invoke_exception(cls, vec![]),
+            Self::Instance(exc) => Ok(exc),
+        }
+    }
+
+    pub fn instantiate_value(
+        self,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyBaseExceptionRef> {
+        let exc_inst = value.clone().downcast::<PyBaseException>().ok();
+        match (self, exc_inst) {
+            // both are instances; which would we choose?
+            (Self::Instance(_exc_a), Some(_exc_b)) => {
+                Err(vm.new_type_error("instance exception may not have a separate value"))
+            }
+            // if the "type" is an instance and the value isn't, use the "type"
+            (Self::Instance(exc), None) => Ok(exc),
+            // if the value is an instance of the type, use the instance value
+            (Self::Class(cls), Some(exc)) if exc.fast_isinstance(&cls) => Ok(exc),
+            // otherwise; construct an exception of the type using the value as args
+            (Self::Class(cls), _) => {
+                let args = match_class!(match value {
+                    PyNone => vec![],
+                    tup @ PyTuple => tup.to_vec(),
+                    exc @ PyBaseException => exc.args().to_vec(),
+                    obj => vec![obj],
+                });
+                vm.invoke_exception(cls, args)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ExceptionZoo {
+    pub base_exception_type: &'static Py<PyType>,
+    pub base_exception_group: &'static Py<PyType>,
+    pub system_exit: &'static Py<PyType>,
+    pub keyboard_interrupt: &'static Py<PyType>,
+    pub generator_exit: &'static Py<PyType>,
+    pub exception_type: &'static Py<PyType>,
+    pub stop_iteration: &'static Py<PyType>,
+    pub stop_async_iteration: &'static Py<PyType>,
+    pub arithmetic_error: &'static Py<PyType>,
+    pub floating_point_error: &'static Py<PyType>,
+    pub overflow_error: &'static Py<PyType>,
+    pub zero_division_error: &'static Py<PyType>,
+    pub assertion_error: &'static Py<PyType>,
+    pub attribute_error: &'static Py<PyType>,
+    pub buffer_error: &'static Py<PyType>,
+    pub eof_error: &'static Py<PyType>,
+    pub import_error: &'static Py<PyType>,
+    pub module_not_found_error: &'static Py<PyType>,
+    pub lookup_error: &'static Py<PyType>,
+    pub index_error: &'static Py<PyType>,
+    pub key_error: &'static Py<PyType>,
+    pub memory_error: &'static Py<PyType>,
+    pub name_error: &'static Py<PyType>,
+    pub unbound_local_error: &'static Py<PyType>,
+    pub os_error: &'static Py<PyType>,
+    pub blocking_io_error: &'static Py<PyType>,
+    pub child_process_error: &'static Py<PyType>,
+    pub connection_error: &'static Py<PyType>,
+    pub broken_pipe_error: &'static Py<PyType>,
+    pub connection_aborted_error: &'static Py<PyType>,
+    pub connection_refused_error: &'static Py<PyType>,
+    pub connection_reset_error: &'static Py<PyType>,
+    pub file_exists_error: &'static Py<PyType>,
+    pub file_not_found_error: &'static Py<PyType>,
+    pub interrupted_error: &'static Py<PyType>,
+    pub is_a_directory_error: &'static Py<PyType>,
+    pub not_a_directory_error: &'static Py<PyType>,
+    pub permission_error: &'static Py<PyType>,
+    pub process_lookup_error: &'static Py<PyType>,
+    pub timeout_error: &'static Py<PyType>,
+    pub reference_error: &'static Py<PyType>,
+    pub runtime_error: &'static Py<PyType>,
+    pub not_implemented_error: &'static Py<PyType>,
+    pub recursion_error: &'static Py<PyType>,
+    pub python_finalization_error: &'static Py<PyType>,
+    pub syntax_error: &'static Py<PyType>,
+    pub incomplete_input_error: &'static Py<PyType>,
+    pub indentation_error: &'static Py<PyType>,
+    pub tab_error: &'static Py<PyType>,
+    pub system_error: &'static Py<PyType>,
+    pub type_error: &'static Py<PyType>,
+    pub value_error: &'static Py<PyType>,
+    pub unicode_error: &'static Py<PyType>,
+    pub unicode_decode_error: &'static Py<PyType>,
+    pub unicode_encode_error: &'static Py<PyType>,
+    pub unicode_translate_error: &'static Py<PyType>,
+
+    #[cfg(feature = "jit")]
+    pub jit_error: &'static Py<PyType>,
+
+    pub warning: &'static Py<PyType>,
+    pub deprecation_warning: &'static Py<PyType>,
+    pub pending_deprecation_warning: &'static Py<PyType>,
+    pub runtime_warning: &'static Py<PyType>,
+    pub syntax_warning: &'static Py<PyType>,
+    pub user_warning: &'static Py<PyType>,
+    pub future_warning: &'static Py<PyType>,
+    pub import_warning: &'static Py<PyType>,
+    pub unicode_warning: &'static Py<PyType>,
+    pub bytes_warning: &'static Py<PyType>,
+    pub resource_warning: &'static Py<PyType>,
+    pub encoding_warning: &'static Py<PyType>,
+}
+
+macro_rules! extend_exception {
+    (
+        $exc_struct:ident,
+        $ctx:expr,
+        $class:expr
+    ) => {
+        extend_exception!($exc_struct, $ctx, $class, {});
+    };
+    (
+        $exc_struct:ident,
+        $ctx:expr,
+        $class:expr,
+        { $($name:expr => $value:expr),* $(,)* }
+    ) => {
+        $exc_struct::extend_class($ctx, $class);
+        extend_class!($ctx, $class, {
+            $($name => $value,)*
+        });
+    };
+}
+
+impl PyBaseException {
+    pub(crate) fn new(args: Vec<PyObjectRef>, vm: &VirtualMachine) -> Self {
+        Self {
+            traceback: PyRwLock::new(None),
+            cause: PyRwLock::new(None),
+            context: PyRwLock::new(None),
+            suppress_context: AtomicCell::new(false),
+            args: PyRwLock::new(PyTuple::new_ref(args, &vm.ctx)),
+        }
+    }
+
+    pub fn get_arg(&self, idx: usize) -> Option<PyObjectRef> {
+        self.args.read().get(idx).cloned()
+    }
+}
+
+#[pyclass(
+    with(Py, PyRef, Constructor, Initializer, Representable),
+    flags(BASETYPE, HAS_DICT)
+)]
+impl PyBaseException {
+    #[pygetset]
+    pub fn args(&self) -> PyTupleRef {
+        self.args.read().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set_args(&self, args: ArgIterable, vm: &VirtualMachine) -> PyResult<()> {
+        let args = args.iter(vm)?.collect::<PyResult<Vec<_>>>()?;
+        *self.args.write() = PyTuple::new_ref(args, &vm.ctx);
+        Ok(())
+    }
+
+    #[pygetset]
+    pub fn __traceback__(&self) -> Option<PyTracebackRef> {
+        self.traceback.read().clone()
+    }
+
+    #[pygetset(setter)]
+    pub fn set___traceback__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let traceback = if vm.is_none(&value) {
+            None
+        } else {
+            match value.downcast::<PyTraceback>() {
+                Ok(tb) => Some(tb),
+                Err(_) => {
+                    return Err(vm.new_type_error("__traceback__ must be a traceback or None"));
+                }
+            }
+        };
+        self.set_traceback_typed(traceback);
+        Ok(())
+    }
+
+    // Helper method for internal use that doesn't require PyObjectRef
+    pub(crate) fn set_traceback_typed(&self, traceback: Option<PyTracebackRef>) {
+        *self.traceback.write() = traceback;
+    }
+
+    #[pygetset]
+    pub fn __cause__(&self) -> Option<PyRef<Self>> {
+        self.cause.read().clone()
+    }
+
+    #[pygetset(setter)]
+    pub fn set___cause__(&self, cause: Option<PyRef<Self>>) {
+        let mut c = self.cause.write();
+        self.set_suppress_context(true);
+        *c = cause;
+    }
+
+    #[pygetset]
+    pub fn __context__(&self) -> Option<PyRef<Self>> {
+        self.context.read().clone()
+    }
+
+    #[pygetset(setter)]
+    pub fn set___context__(&self, context: Option<PyRef<Self>>) {
+        *self.context.write() = context;
+    }
+
+    #[pygetset]
+    pub(super) fn __suppress_context__(&self) -> bool {
+        self.suppress_context.load()
+    }
+
+    #[pygetset(name = "__suppress_context__", setter)]
+    fn set_suppress_context(&self, suppress_context: bool) {
+        self.suppress_context.store(suppress_context);
+    }
+}
+
+#[pyclass]
+impl Py<PyBaseException> {
+    #[pymethod]
+    pub(super) fn __str__(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let str_args = vm.exception_args_as_string(self.args(), true);
+        Ok(match str_args.into_iter().exactly_one() {
+            Err(i) if i.len() == 0 => vm.ctx.empty_str.to_owned(),
+            Ok(s) => s,
+            Err(i) => PyStr::from(format!("({})", i.format(", "))).into_ref(&vm.ctx),
+        })
+    }
+}
+
+#[pyclass]
+impl PyRef<PyBaseException> {
+    #[pymethod]
+    fn with_traceback(self, tb: Option<PyTracebackRef>) -> PyResult<Self> {
+        *self.traceback.write() = tb;
+        Ok(self)
+    }
+
+    #[pymethod]
+    fn add_note(self, note: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let dict = self
+            .as_object()
+            .dict()
+            .ok_or_else(|| vm.new_attribute_error("Exception object has no __dict__"))?;
+
+        let notes = if let Ok(notes) = dict.get_item("__notes__", vm) {
+            notes
+        } else {
+            let new_notes = vm.ctx.new_list(vec![]);
+            dict.set_item("__notes__", new_notes.clone().into(), vm)?;
+            new_notes.into()
+        };
+
+        let notes = notes
+            .downcast::<PyList>()
+            .map_err(|_| vm.new_type_error("__notes__ must be a list"))?;
+
+        notes.borrow_vec_mut().push(note.into());
+        Ok(())
+    }
+
+    #[pymethod]
+    fn __reduce__(self, vm: &VirtualMachine) -> PyTupleRef {
+        if let Some(dict) = self.as_object().dict().filter(|x| !x.is_empty()) {
+            vm.new_tuple((self.class().to_owned(), self.args(), dict))
+        } else {
+            vm.new_tuple((self.class().to_owned(), self.args()))
+        }
+    }
+
+    #[pymethod]
+    fn __setstate__(self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        if !vm.is_none(&state) {
+            let dict = state
+                .downcast::<crate::builtins::PyDict>()
+                .map_err(|_| vm.new_type_error("state is not a dictionary"))?;
+
+            for (key, value) in &dict {
+                let key_str = key.str(vm)?;
+                if key_str.as_str().starts_with("__") {
+                    continue;
+                }
+                self.as_object().set_attr(&key_str, value.clone(), vm)?;
+            }
+        }
+        Ok(vm.ctx.none())
+    }
+}
+
+impl Constructor for PyBaseException {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        if cls.is(Self::class(&vm.ctx)) && !args.kwargs.is_empty() {
+            return Err(vm.new_type_error("BaseException() takes no keyword arguments"));
+        }
+        Self::new(args.args, vm)
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyBaseException {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        *zelf.args.write() = PyTuple::new_ref(args.args, &vm.ctx);
+        Ok(())
+    }
+}
+
+impl Representable for PyBaseException {
+    #[inline]
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let repr_args = vm.exception_args_as_string(zelf.args(), false);
+        let cls = zelf.class();
+        Ok(format!("{}({})", cls.name(), repr_args.iter().format(", ")))
+    }
+}
+
+impl ExceptionZoo {
+    pub(crate) fn init() -> Self {
+        use self::types::*;
+
+        let base_exception_type = PyBaseException::init_builtin_type();
+
+        // Sorted By Hierarchy then alphabetized.
+        let base_exception_group = PyBaseExceptionGroup::init_builtin_type();
+        let system_exit = PySystemExit::init_builtin_type();
+        let keyboard_interrupt = PyKeyboardInterrupt::init_builtin_type();
+        let generator_exit = PyGeneratorExit::init_builtin_type();
+
+        let exception_type = PyException::init_builtin_type();
+        let stop_iteration = PyStopIteration::init_builtin_type();
+        let stop_async_iteration = PyStopAsyncIteration::init_builtin_type();
+        let arithmetic_error = PyArithmeticError::init_builtin_type();
+        let floating_point_error = PyFloatingPointError::init_builtin_type();
+        let overflow_error = PyOverflowError::init_builtin_type();
+        let zero_division_error = PyZeroDivisionError::init_builtin_type();
+
+        let assertion_error = PyAssertionError::init_builtin_type();
+        let attribute_error = PyAttributeError::init_builtin_type();
+        let buffer_error = PyBufferError::init_builtin_type();
+        let eof_error = PyEOFError::init_builtin_type();
+
+        let import_error = PyImportError::init_builtin_type();
+        let module_not_found_error = PyModuleNotFoundError::init_builtin_type();
+
+        let lookup_error = PyLookupError::init_builtin_type();
+        let index_error = PyIndexError::init_builtin_type();
+        let key_error = PyKeyError::init_builtin_type();
+
+        let memory_error = PyMemoryError::init_builtin_type();
+
+        let name_error = PyNameError::init_builtin_type();
+        let unbound_local_error = PyUnboundLocalError::init_builtin_type();
+
+        // os errors
+        let os_error = PyOSError::init_builtin_type();
+        let blocking_io_error = PyBlockingIOError::init_builtin_type();
+        let child_process_error = PyChildProcessError::init_builtin_type();
+
+        let connection_error = PyConnectionError::init_builtin_type();
+        let broken_pipe_error = PyBrokenPipeError::init_builtin_type();
+        let connection_aborted_error = PyConnectionAbortedError::init_builtin_type();
+        let connection_refused_error = PyConnectionRefusedError::init_builtin_type();
+        let connection_reset_error = PyConnectionResetError::init_builtin_type();
+
+        let file_exists_error = PyFileExistsError::init_builtin_type();
+        let file_not_found_error = PyFileNotFoundError::init_builtin_type();
+        let interrupted_error = PyInterruptedError::init_builtin_type();
+        let is_a_directory_error = PyIsADirectoryError::init_builtin_type();
+        let not_a_directory_error = PyNotADirectoryError::init_builtin_type();
+        let permission_error = PyPermissionError::init_builtin_type();
+        let process_lookup_error = PyProcessLookupError::init_builtin_type();
+        let timeout_error = PyTimeoutError::init_builtin_type();
+
+        let reference_error = PyReferenceError::init_builtin_type();
+
+        let runtime_error = PyRuntimeError::init_builtin_type();
+        let not_implemented_error = PyNotImplementedError::init_builtin_type();
+        let recursion_error = PyRecursionError::init_builtin_type();
+        let python_finalization_error = PyPythonFinalizationError::init_builtin_type();
+
+        let syntax_error = PySyntaxError::init_builtin_type();
+        let incomplete_input_error = PyIncompleteInputError::init_builtin_type();
+        let indentation_error = PyIndentationError::init_builtin_type();
+        let tab_error = PyTabError::init_builtin_type();
+
+        let system_error = PySystemError::init_builtin_type();
+        let type_error = PyTypeError::init_builtin_type();
+        let value_error = PyValueError::init_builtin_type();
+        let unicode_error = PyUnicodeError::init_builtin_type();
+        let unicode_decode_error = PyUnicodeDecodeError::init_builtin_type();
+        let unicode_encode_error = PyUnicodeEncodeError::init_builtin_type();
+        let unicode_translate_error = PyUnicodeTranslateError::init_builtin_type();
+
+        #[cfg(feature = "jit")]
+        let jit_error = PyJitError::init_builtin_type();
+
+        let warning = PyWarning::init_builtin_type();
+        let deprecation_warning = PyDeprecationWarning::init_builtin_type();
+        let pending_deprecation_warning = PyPendingDeprecationWarning::init_builtin_type();
+        let runtime_warning = PyRuntimeWarning::init_builtin_type();
+        let syntax_warning = PySyntaxWarning::init_builtin_type();
+        let user_warning = PyUserWarning::init_builtin_type();
+        let future_warning = PyFutureWarning::init_builtin_type();
+        let import_warning = PyImportWarning::init_builtin_type();
+        let unicode_warning = PyUnicodeWarning::init_builtin_type();
+        let bytes_warning = PyBytesWarning::init_builtin_type();
+        let resource_warning = PyResourceWarning::init_builtin_type();
+        let encoding_warning = PyEncodingWarning::init_builtin_type();
+
+        Self {
+            base_exception_type,
+            base_exception_group,
+            system_exit,
+            keyboard_interrupt,
+            generator_exit,
+            exception_type,
+            stop_iteration,
+            stop_async_iteration,
+            arithmetic_error,
+            floating_point_error,
+            overflow_error,
+            zero_division_error,
+            assertion_error,
+            attribute_error,
+            buffer_error,
+            eof_error,
+            import_error,
+            module_not_found_error,
+            lookup_error,
+            index_error,
+            key_error,
+            memory_error,
+            name_error,
+            unbound_local_error,
+            os_error,
+            blocking_io_error,
+            child_process_error,
+            connection_error,
+            broken_pipe_error,
+            connection_aborted_error,
+            connection_refused_error,
+            connection_reset_error,
+            file_exists_error,
+            file_not_found_error,
+            interrupted_error,
+            is_a_directory_error,
+            not_a_directory_error,
+            permission_error,
+            process_lookup_error,
+            timeout_error,
+            reference_error,
+            runtime_error,
+            not_implemented_error,
+            recursion_error,
+            python_finalization_error,
+            syntax_error,
+            incomplete_input_error,
+            indentation_error,
+            tab_error,
+            system_error,
+            type_error,
+            value_error,
+            unicode_error,
+            unicode_decode_error,
+            unicode_encode_error,
+            unicode_translate_error,
+
+            #[cfg(feature = "jit")]
+            jit_error,
+
+            warning,
+            deprecation_warning,
+            pending_deprecation_warning,
+            runtime_warning,
+            syntax_warning,
+            user_warning,
+            future_warning,
+            import_warning,
+            unicode_warning,
+            bytes_warning,
+            resource_warning,
+            encoding_warning,
+        }
+    }
+
+    // TODO: remove it after fixing `errno` / `winerror` problem
+    #[allow(clippy::redundant_clone)]
+    pub fn extend(ctx: &Context) {
+        use self::types::*;
+
+        let excs = &ctx.exceptions;
+
+        PyBaseException::extend_class(ctx, excs.base_exception_type);
+
+        // Sorted By Hierarchy then alphabetized.
+        extend_exception!(PyBaseExceptionGroup, ctx, excs.base_exception_group, {
+            "message" => ctx.new_readonly_getset("message", excs.base_exception_group, make_arg_getter(0)),
+            "exceptions" => ctx.new_readonly_getset("exceptions", excs.base_exception_group, make_arg_getter(1)),
+        });
+
+        extend_exception!(PySystemExit, ctx, excs.system_exit, {
+            "code" => ctx.new_readonly_getset("code", excs.system_exit, system_exit_code),
+        });
+        extend_exception!(PyKeyboardInterrupt, ctx, excs.keyboard_interrupt);
+        extend_exception!(PyGeneratorExit, ctx, excs.generator_exit);
+
+        extend_exception!(PyException, ctx, excs.exception_type);
+
+        extend_exception!(PyStopIteration, ctx, excs.stop_iteration, {
+            "value" => ctx.none(),
+        });
+        extend_exception!(PyStopAsyncIteration, ctx, excs.stop_async_iteration);
+
+        extend_exception!(PyArithmeticError, ctx, excs.arithmetic_error);
+        extend_exception!(PyFloatingPointError, ctx, excs.floating_point_error);
+        extend_exception!(PyOverflowError, ctx, excs.overflow_error);
+        extend_exception!(PyZeroDivisionError, ctx, excs.zero_division_error);
+
+        extend_exception!(PyAssertionError, ctx, excs.assertion_error);
+        extend_exception!(PyAttributeError, ctx, excs.attribute_error, {
+            "name" => ctx.none(),
+            "obj" => ctx.none(),
+        });
+        extend_exception!(PyBufferError, ctx, excs.buffer_error);
+        extend_exception!(PyEOFError, ctx, excs.eof_error);
+
+        extend_exception!(PyImportError, ctx, excs.import_error, {
+            "msg" => ctx.new_readonly_getset("msg", excs.import_error, make_arg_getter(0)),
+        });
+        extend_exception!(PyModuleNotFoundError, ctx, excs.module_not_found_error);
+
+        extend_exception!(PyLookupError, ctx, excs.lookup_error);
+        extend_exception!(PyIndexError, ctx, excs.index_error);
+
+        extend_exception!(PyKeyError, ctx, excs.key_error);
+
+        extend_exception!(PyMemoryError, ctx, excs.memory_error);
+        extend_exception!(PyNameError, ctx, excs.name_error, {
+            "name" => ctx.none(),
+        });
+        extend_exception!(PyUnboundLocalError, ctx, excs.unbound_local_error);
+
+        // os errors:
+        // PyOSError now uses struct fields with pygetset, no need for dynamic attributes
+        extend_exception!(PyOSError, ctx, excs.os_error);
+
+        extend_exception!(PyBlockingIOError, ctx, excs.blocking_io_error);
+        extend_exception!(PyChildProcessError, ctx, excs.child_process_error);
+
+        extend_exception!(PyConnectionError, ctx, excs.connection_error);
+        extend_exception!(PyBrokenPipeError, ctx, excs.broken_pipe_error);
+        extend_exception!(PyConnectionAbortedError, ctx, excs.connection_aborted_error);
+        extend_exception!(PyConnectionRefusedError, ctx, excs.connection_refused_error);
+        extend_exception!(PyConnectionResetError, ctx, excs.connection_reset_error);
+
+        extend_exception!(PyFileExistsError, ctx, excs.file_exists_error);
+        extend_exception!(PyFileNotFoundError, ctx, excs.file_not_found_error);
+        extend_exception!(PyInterruptedError, ctx, excs.interrupted_error);
+        extend_exception!(PyIsADirectoryError, ctx, excs.is_a_directory_error);
+        extend_exception!(PyNotADirectoryError, ctx, excs.not_a_directory_error);
+        extend_exception!(PyPermissionError, ctx, excs.permission_error);
+        extend_exception!(PyProcessLookupError, ctx, excs.process_lookup_error);
+        extend_exception!(PyTimeoutError, ctx, excs.timeout_error);
+
+        extend_exception!(PyReferenceError, ctx, excs.reference_error);
+        extend_exception!(PyRuntimeError, ctx, excs.runtime_error);
+        extend_exception!(PyNotImplementedError, ctx, excs.not_implemented_error);
+        extend_exception!(PyRecursionError, ctx, excs.recursion_error);
+        extend_exception!(
+            PyPythonFinalizationError,
+            ctx,
+            excs.python_finalization_error
+        );
+
+        extend_exception!(PySyntaxError, ctx, excs.syntax_error, {
+            "msg" => ctx.new_static_getset(
+                "msg",
+                excs.syntax_error,
+                make_arg_getter(0),
+                syntax_error_set_msg,
+            ),
+            // TODO: members
+            "filename" => ctx.none(),
+            "lineno" => ctx.none(),
+            "end_lineno" => ctx.none(),
+            "offset" => ctx.none(),
+            "end_offset" => ctx.none(),
+            "text" => ctx.none(),
+        });
+        extend_exception!(PyIncompleteInputError, ctx, excs.incomplete_input_error);
+        extend_exception!(PyIndentationError, ctx, excs.indentation_error);
+        extend_exception!(PyTabError, ctx, excs.tab_error);
+
+        extend_exception!(PySystemError, ctx, excs.system_error);
+        extend_exception!(PyTypeError, ctx, excs.type_error);
+        extend_exception!(PyValueError, ctx, excs.value_error);
+        extend_exception!(PyUnicodeError, ctx, excs.unicode_error);
+        extend_exception!(PyUnicodeDecodeError, ctx, excs.unicode_decode_error);
+        extend_exception!(PyUnicodeEncodeError, ctx, excs.unicode_encode_error);
+        extend_exception!(PyUnicodeTranslateError, ctx, excs.unicode_translate_error);
+
+        #[cfg(feature = "jit")]
+        extend_exception!(PyJitError, ctx, excs.jit_error);
+
+        extend_exception!(PyWarning, ctx, excs.warning);
+        extend_exception!(PyDeprecationWarning, ctx, excs.deprecation_warning);
+        extend_exception!(
+            PyPendingDeprecationWarning,
+            ctx,
+            excs.pending_deprecation_warning
+        );
+        extend_exception!(PyRuntimeWarning, ctx, excs.runtime_warning);
+        extend_exception!(PySyntaxWarning, ctx, excs.syntax_warning);
+        extend_exception!(PyUserWarning, ctx, excs.user_warning);
+        extend_exception!(PyFutureWarning, ctx, excs.future_warning);
+        extend_exception!(PyImportWarning, ctx, excs.import_warning);
+        extend_exception!(PyUnicodeWarning, ctx, excs.unicode_warning);
+        extend_exception!(PyBytesWarning, ctx, excs.bytes_warning);
+        extend_exception!(PyResourceWarning, ctx, excs.resource_warning);
+        extend_exception!(PyEncodingWarning, ctx, excs.encoding_warning);
+    }
+}
+
+fn make_arg_getter(idx: usize) -> impl Fn(PyBaseExceptionRef) -> Option<PyObjectRef> {
+    move |exc| exc.get_arg(idx)
+}
+
+fn syntax_error_set_msg(
+    exc: PyBaseExceptionRef,
+    value: PySetterValue,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let mut args = exc.args.write();
+    let mut new_args = args.as_slice().to_vec();
+    // Ensure the message slot at index 0 always exists for SyntaxError.args.
+    if new_args.is_empty() {
+        new_args.push(vm.ctx.none());
+    }
+    match value {
+        PySetterValue::Assign(value) => new_args[0] = value,
+        PySetterValue::Delete => new_args[0] = vm.ctx.none(),
+    }
+    *args = PyTuple::new_ref(new_args, &vm.ctx);
+    Ok(())
+}
+
+fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
+    exc.args.read().first().map(|code| {
+        match_class!(match code {
+            ref tup @ PyTuple => match tup.as_slice() {
+                [x] => x.clone(),
+                _ => code.clone(),
+            },
+            other => other.clone(),
+        })
+    })
+}
+
+#[cfg(feature = "serde")]
+pub struct SerializeException<'vm, 's> {
+    vm: &'vm VirtualMachine,
+    exc: &'s Py<PyBaseException>,
+}
+
+#[cfg(feature = "serde")]
+impl<'vm, 's> SerializeException<'vm, 's> {
+    pub fn new(vm: &'vm VirtualMachine, exc: &'s Py<PyBaseException>) -> Self {
+        SerializeException { vm, exc }
+    }
+}
+
+#[cfg(feature = "serde")]
+pub struct SerializeExceptionOwned<'vm> {
+    vm: &'vm VirtualMachine,
+    exc: PyBaseExceptionRef,
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for SerializeExceptionOwned<'_> {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        let Self { vm, exc } = self;
+        SerializeException::new(vm, exc).serialize(s)
+    }
+}
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for SerializeException<'_, '_> {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        use serde::ser::*;
+
+        let mut struc = s.serialize_struct("PyBaseException", 7)?;
+        struc.serialize_field("exc_type", &*self.exc.class().name())?;
+        let tbs = {
+            struct Tracebacks(PyTracebackRef);
+            impl serde::Serialize for Tracebacks {
+                fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+                    let mut s = s.serialize_seq(None)?;
+                    for tb in self.0.iter() {
+                        s.serialize_element(&**tb)?;
+                    }
+                    s.end()
+                }
+            }
+            self.exc.__traceback__().map(Tracebacks)
+        };
+        struc.serialize_field("traceback", &tbs)?;
+        struc.serialize_field(
+            "cause",
+            &self
+                .exc
+                .__cause__()
+                .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }),
+        )?;
+        struc.serialize_field(
+            "context",
+            &self
+                .exc
+                .__context__()
+                .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }),
+        )?;
+        struc.serialize_field("suppress_context", &self.exc.__suppress_context__())?;
+
+        let args = {
+            struct Args<'vm>(&'vm VirtualMachine, PyTupleRef);
+            impl serde::Serialize for Args<'_> {
+                fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+                    s.collect_seq(
+                        self.1
+                            .iter()
+                            .map(|arg| crate::py_serde::PyObjectSerializer::new(self.0, arg)),
+                    )
+                }
+            }
+            Args(self.vm, self.exc.args())
+        };
+        struc.serialize_field("args", &args)?;
+
+        let rendered = {
+            let mut rendered = String::new();
+            self.vm
+                .write_exception(&mut rendered, self.exc)
+                .map_err(S::Error::custom)?;
+            rendered
+        };
+        struc.serialize_field("rendered", &rendered)?;
+
+        struc.end()
+    }
+}
+
+pub fn cstring_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_value_error("embedded null character")
+}
+
+impl ToPyException for alloc::ffi::NulError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        cstring_error(vm)
+    }
+}
+
+#[cfg(windows)]
+impl<C> ToPyException for widestring::error::ContainsNul<C> {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        cstring_error(vm)
+    }
+}
+
+#[cfg(any(unix, windows, target_os = "wasi"))]
+pub(crate) fn errno_to_exc_type(errno: i32, vm: &VirtualMachine) -> Option<&'static Py<PyType>> {
+    use crate::stdlib::errno::errors;
+    let excs = &vm.ctx.exceptions;
+    match errno {
+        #[allow(unreachable_patterns)] // EAGAIN is sometimes the same as EWOULDBLOCK
+        errors::EWOULDBLOCK | errors::EAGAIN => Some(excs.blocking_io_error),
+        errors::EALREADY => Some(excs.blocking_io_error),
+        errors::EINPROGRESS => Some(excs.blocking_io_error),
+        errors::EPIPE => Some(excs.broken_pipe_error),
+        #[cfg(not(target_os = "wasi"))]
+        errors::ESHUTDOWN => Some(excs.broken_pipe_error),
+        errors::ECHILD => Some(excs.child_process_error),
+        errors::ECONNABORTED => Some(excs.connection_aborted_error),
+        errors::ECONNREFUSED => Some(excs.connection_refused_error),
+        errors::ECONNRESET => Some(excs.connection_reset_error),
+        errors::EEXIST => Some(excs.file_exists_error),
+        errors::ENOENT => Some(excs.file_not_found_error),
+        errors::EISDIR => Some(excs.is_a_directory_error),
+        errors::ENOTDIR => Some(excs.not_a_directory_error),
+        errors::EINTR => Some(excs.interrupted_error),
+        errors::EACCES => Some(excs.permission_error),
+        errors::EPERM => Some(excs.permission_error),
+        errors::ESRCH => Some(excs.process_lookup_error),
+        errors::ETIMEDOUT => Some(excs.timeout_error),
+        _ => None,
+    }
+}
+
+#[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
+pub(crate) fn errno_to_exc_type(_errno: i32, _vm: &VirtualMachine) -> Option<&'static Py<PyType>> {
+    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},
+        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 struct OSErrorBuilder {
+        exc_type: PyTypeRef,
+        errno: Option<i32>,
+        strerror: Option<PyObjectRef>,
+        filename: Option<PyObjectRef>,
+        #[cfg(windows)]
+        winerror: Option<PyObjectRef>,
+        filename2: Option<PyObjectRef>,
+    }
+
+    impl OSErrorBuilder {
+        #[must_use]
+        pub fn with_subtype(
+            exc_type: PyTypeRef,
+            errno: Option<i32>,
+            strerror: impl ToPyObject,
+            vm: &VirtualMachine,
+        ) -> Self {
+            let strerror = strerror.to_pyobject(vm);
+            Self {
+                exc_type,
+                errno,
+                strerror: Some(strerror),
+                filename: None,
+                #[cfg(windows)]
+                winerror: None,
+                filename2: None,
+            }
+        }
+        #[must_use]
+        pub fn with_errno(errno: i32, strerror: impl ToPyObject, vm: &VirtualMachine) -> Self {
+            let exc_type = crate::exceptions::errno_to_exc_type(errno, vm)
+                .unwrap_or(vm.ctx.exceptions.os_error)
+                .to_owned();
+            Self::with_subtype(exc_type, Some(errno), strerror, vm)
+        }
+
+        // #[must_use]
+        // pub(crate) fn errno(mut self, errno: i32) -> Self {
+        //     self.errno.replace(errno);
+        //     self
+        // }
+
+        #[must_use]
+        pub(crate) fn filename(mut self, filename: PyObjectRef) -> Self {
+            self.filename.replace(filename);
+            self
+        }
+
+        #[must_use]
+        pub(crate) fn filename2(mut self, filename: PyObjectRef) -> Self {
+            self.filename2.replace(filename);
+            self
+        }
+
+        #[must_use]
+        #[cfg(windows)]
+        pub(crate) fn winerror(mut self, winerror: PyObjectRef) -> Self {
+            self.winerror.replace(winerror);
+            self
+        }
+
+        pub fn build(self, vm: &VirtualMachine) -> PyRef<PyOSError> {
+            let OSErrorBuilder {
+                exc_type,
+                errno,
+                strerror,
+                filename,
+                #[cfg(windows)]
+                winerror,
+                filename2,
+            } = self;
+
+            let args = if let Some(errno) = errno {
+                #[cfg(windows)]
+                let winerror = winerror.to_pyobject(vm);
+                #[cfg(not(windows))]
+                let winerror = vm.ctx.none();
+
+                vec![
+                    errno.to_pyobject(vm),
+                    strerror.to_pyobject(vm),
+                    filename.to_pyobject(vm),
+                    winerror,
+                    filename2.to_pyobject(vm),
+                ]
+            } else {
+                vec![strerror.to_pyobject(vm)]
+            };
+
+            let payload = PyOSError::py_new(&exc_type, args.clone().into(), vm)
+                .expect("new_os_error usage error");
+            let os_error = payload
+                .into_ref_with_type(vm, exc_type)
+                .expect("new_os_error usage error");
+            PyOSError::slot_init(os_error.as_object().to_owned(), args.into(), vm)
+                .expect("new_os_error usage error");
+            os_error
+        }
+    }
+
+    impl crate::convert::IntoPyException for OSErrorBuilder {
+        fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+            self.build(vm).upcast()
+        }
+    }
+
+    // Re-export exception group types from dedicated module
+    pub use crate::exception_group::types::PyBaseExceptionGroup;
+
+    // This module is designed to be used as `use builtins::*;`.
+    // Do not add any pub symbols not included in builtins module.
+    // `PyBaseExceptionRef` is the only exception.
+
+    pub type PyBaseExceptionRef = PyRef<PyBaseException>;
+
+    // Sorted By Hierarchy then alphabetized.
+
+    #[pyclass(module = false, name = "BaseException", traverse = "manual")]
+    pub struct PyBaseException {
+        pub(super) traceback: PyRwLock<Option<PyTracebackRef>>,
+        pub(super) cause: PyRwLock<Option<PyRef<Self>>>,
+        pub(super) context: PyRwLock<Option<PyRef<Self>>>,
+        pub(super) suppress_context: AtomicCell<bool>,
+        pub(super) args: PyRwLock<PyTupleRef>,
+    }
+
+    #[pyexception(name, base = PyBaseException, ctx = "system_exit", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySystemExit(PyBaseException);
+
+    #[pyexception(name, base = PyBaseException, ctx = "generator_exit", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyGeneratorExit(PyBaseException);
+
+    #[pyexception(name, base = PyBaseException, ctx = "keyboard_interrupt", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyKeyboardInterrupt(PyBaseException);
+
+    #[pyexception(name, base = PyBaseException, ctx = "exception_type", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyException(PyBaseException);
+
+    #[pyexception(name, base = PyException, ctx = "stop_iteration")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyStopIteration(PyException);
+
+    #[pyexception(with(Initializer))]
+    impl PyStopIteration {}
+
+    impl Initializer for PyStopIteration {
+        type Args = FuncArgs;
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.set_attr("value", vm.unwrap_or_none(args.args.first().cloned()), vm)?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyException, ctx = "stop_async_iteration", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyStopAsyncIteration(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "arithmetic_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyArithmeticError(PyException);
+
+    #[pyexception(name, base = PyArithmeticError, ctx = "floating_point_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyFloatingPointError(PyArithmeticError);
+    #[pyexception(name, base = PyArithmeticError, ctx = "overflow_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyOverflowError(PyArithmeticError);
+
+    #[pyexception(name, base = PyArithmeticError, ctx = "zero_division_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyZeroDivisionError(PyArithmeticError);
+
+    #[pyexception(name, base = PyException, ctx = "assertion_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyAssertionError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "attribute_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyAttributeError(PyException);
+
+    #[pyexception(with(Initializer))]
+    impl PyAttributeError {}
+
+    impl Initializer for PyAttributeError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.set_attr(
+                "name",
+                vm.unwrap_or_none(args.kwargs.get("name").cloned()),
+                vm,
+            )?;
+            zelf.set_attr(
+                "obj",
+                vm.unwrap_or_none(args.kwargs.get("obj").cloned()),
+                vm,
+            )?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyException, ctx = "buffer_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyBufferError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "eof_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyEOFError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "import_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyImportError(PyException);
+
+    #[pyexception(with(Initializer))]
+    impl PyImportError {
+        #[pymethod]
+        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
+            let obj = exc.as_object().to_owned();
+            let mut result: Vec<PyObjectRef> = vec![
+                obj.class().to_owned().into(),
+                vm.new_tuple((exc.get_arg(0).unwrap(),)).into(),
+            ];
+
+            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
+                result.push(dict.into());
+            }
+
+            result.into_pytuple(vm)
+        }
+    }
+
+    impl Initializer for PyImportError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let mut kwargs = args.kwargs.clone();
+            let name = kwargs.swap_remove("name");
+            let path = kwargs.swap_remove("path");
+
+            // Check for any remaining invalid keyword arguments
+            if let Some(invalid_key) = kwargs.keys().next() {
+                return Err(vm.new_type_error(format!(
+                    "'{invalid_key}' is an invalid keyword argument for ImportError"
+                )));
+            }
+
+            let dict = zelf.dict().unwrap();
+            dict.set_item("name", vm.unwrap_or_none(name), vm)?;
+            dict.set_item("path", vm.unwrap_or_none(path), vm)?;
+            PyBaseException::slot_init(zelf, args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyImportError, ctx = "module_not_found_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyModuleNotFoundError(PyImportError);
+
+    #[pyexception(name, base = PyException, ctx = "lookup_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyLookupError(PyException);
+
+    #[pyexception(name, base = PyLookupError, ctx = "index_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyIndexError(PyLookupError);
+
+    #[pyexception(name, base = PyLookupError, ctx = "key_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyKeyError(PyLookupError);
+
+    #[pyexception]
+    impl PyKeyError {
+        #[pymethod]
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let args = zelf.args();
+            Ok(if args.len() == 1 {
+                vm.exception_args_as_string(args, false)
+                    .into_iter()
+                    .exactly_one()
+                    .unwrap()
+            } else {
+                zelf.__str__(vm)?
+            })
+        }
+    }
+
+    #[pyexception(name, base = PyException, ctx = "memory_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyMemoryError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "name_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyNameError(PyException);
+
+    #[pyexception(name, base = PyNameError, ctx = "unbound_local_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnboundLocalError(PyNameError);
+
+    #[pyexception(name, base = PyException, ctx = "os_error")]
+    #[repr(C)]
+    pub struct PyOSError {
+        base: PyException,
+        errno: PyAtomicRef<Option<PyObject>>,
+        strerror: PyAtomicRef<Option<PyObject>>,
+        filename: PyAtomicRef<Option<PyObject>>,
+        filename2: PyAtomicRef<Option<PyObject>>,
+        #[cfg(windows)]
+        winerror: PyAtomicRef<Option<PyObject>>,
+        // For BlockingIOError: characters written before blocking occurred
+        // -1 means not set (AttributeError when accessed)
+        written: AtomicCell<isize>,
+    }
+
+    impl crate::class::PySubclass for PyOSError {
+        type Base = PyException;
+        fn as_base(&self) -> &Self::Base {
+            &self.base
+        }
+    }
+
+    impl core::fmt::Debug for PyOSError {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            f.debug_struct("PyOSError").finish_non_exhaustive()
+        }
+    }
+
+    unsafe impl Traverse for PyOSError {
+        fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+            self.base.try_traverse(tracer_fn);
+            if let Some(obj) = self.errno.deref() {
+                tracer_fn(obj);
+            }
+            if let Some(obj) = self.strerror.deref() {
+                tracer_fn(obj);
+            }
+            if let Some(obj) = self.filename.deref() {
+                tracer_fn(obj);
+            }
+            if let Some(obj) = self.filename2.deref() {
+                tracer_fn(obj);
+            }
+            #[cfg(windows)]
+            if let Some(obj) = self.winerror.deref() {
+                tracer_fn(obj);
+            }
+        }
+    }
+
+    // OS Errors:
+    impl Constructor for PyOSError {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, args: FuncArgs, vm: &VirtualMachine) -> PyResult<Self> {
+            let len = args.args.len();
+            // CPython only sets errno/strerror when args len is 2-5
+            let (errno, strerror) = if (2..=5).contains(&len) {
+                (Some(args.args[0].clone()), Some(args.args[1].clone()))
+            } else {
+                (None, None)
+            };
+            let filename = if (3..=5).contains(&len) {
+                Some(args.args[2].clone())
+            } else {
+                None
+            };
+            let filename2 = if len == 5 {
+                args.args.get(4).cloned()
+            } else {
+                None
+            };
+            // Truncate args for base exception when 3-5 args
+            let base_args = if (3..=5).contains(&len) {
+                args.args[..2].to_vec()
+            } else {
+                args.args.to_vec()
+            };
+            let base_exception = PyBaseException::new(base_args, vm);
+            Ok(Self {
+                base: PyException(base_exception),
+                errno: errno.into(),
+                strerror: strerror.into(),
+                filename: filename.into(),
+                filename2: filename2.into(),
+                #[cfg(windows)]
+                winerror: None.into(),
+                written: AtomicCell::new(-1),
+            })
+        }
+
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            // We need this method, because of how `CPython` copies `init`
+            // from `BaseException` in `SimpleExtendsException` macro.
+            // See: `BaseException_new`
+            if *cls.name() == *vm.ctx.exceptions.os_error.name() {
+                let args_vec = args.args.to_vec();
+                let len = args_vec.len();
+                if (2..=5).contains(&len) {
+                    let errno = &args_vec[0];
+                    if let Some(error) = errno
+                        .downcast_ref::<PyInt>()
+                        .and_then(|errno| errno.try_to_primitive::<i32>(vm).ok())
+                        .and_then(|errno| super::errno_to_exc_type(errno, vm))
+                        .and_then(|typ| vm.invoke_exception(typ.to_owned(), args_vec).ok())
+                    {
+                        return error.to_pyresult(vm);
+                    }
+                }
+            }
+            let payload = Self::py_new(&cls, args, vm)?;
+            payload.into_ref_with_type(vm, cls).map(Into::into)
+        }
+    }
+
+    impl Initializer for PyOSError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let len = args.args.len();
+            let mut new_args = args;
+
+            // All OSError subclasses use #[repr(transparent)] wrapping PyOSError,
+            // so we can safely access the PyOSError fields through pointer cast
+            // SAFETY: All OSError subclasses (FileNotFoundError, etc.) are
+            // #[repr(transparent)] wrappers around PyOSError with identical memory layout
+            #[allow(deprecated)]
+            let exc: &Py<PyOSError> = zelf.downcast_ref::<PyOSError>().unwrap();
+
+            // Check if this is BlockingIOError - need to handle characters_written
+            let is_blocking_io_error =
+                zelf.class()
+                    .is(vm.ctx.exceptions.blocking_io_error.as_ref());
+
+            // SAFETY: slot_init is called during object initialization,
+            // so fields are None and swap result can be safely ignored
+            let mut set_filename = true;
+            if len <= 5 {
+                // Only set errno/strerror when args len is 2-5
+                if 2 <= len {
+                    let _ = unsafe { exc.errno.swap(Some(new_args.args[0].clone())) };
+                    let _ = unsafe { exc.strerror.swap(Some(new_args.args[1].clone())) };
+                }
+                if 3 <= len {
+                    let third_arg = &new_args.args[2];
+                    // BlockingIOError's 3rd argument can be the number of characters written
+                    if is_blocking_io_error
+                        && !vm.is_none(third_arg)
+                        && crate::protocol::PyNumber::check(third_arg)
+                        && let Ok(written) = third_arg.try_index(vm)
+                        && let Ok(n) = written.try_to_primitive::<isize>(vm)
+                    {
+                        exc.written.store(n);
+                        set_filename = false;
+                        // Clear filename that was set in py_new
+                        let _ = unsafe { exc.filename.swap(None) };
+                    }
+                    if set_filename {
+                        let _ = unsafe { exc.filename.swap(Some(third_arg.clone())) };
+                    }
+                }
+                #[cfg(windows)]
+                if 4 <= len {
+                    let winerror = new_args.args.get(3).cloned();
+                    // Store original winerror
+                    let _ = unsafe { exc.winerror.swap(winerror.clone()) };
+
+                    // Convert winerror to errno and update errno + args[0]
+                    if let Some(errno) = winerror
+                        .as_ref()
+                        .and_then(|w| w.downcast_ref::<crate::builtins::PyInt>())
+                        .and_then(|w| w.try_to_primitive::<i32>(vm).ok())
+                        .map(crate::common::os::winerror_to_errno)
+                    {
+                        let errno_obj = vm.new_pyobj(errno);
+                        let _ = unsafe { exc.errno.swap(Some(errno_obj.clone())) };
+                        new_args.args[0] = errno_obj;
+                    }
+                }
+                if len == 5 {
+                    let _ = unsafe { exc.filename2.swap(new_args.args.get(4).cloned()) };
+                }
+            }
+
+            // args are truncated to 2 for compatibility (only when 2-5 args and filename is not None)
+            // truncation happens inside "if (filename && filename != Py_None)" block
+            let has_filename = exc.filename.to_owned().filter(|f| !vm.is_none(f)).is_some();
+            if (3..=5).contains(&len) && has_filename {
+                new_args.args.truncate(2);
+            }
+            PyBaseException::slot_init(zelf, new_args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(with(Constructor, Initializer))]
+    impl PyOSError {
+        #[pymethod]
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let obj = zelf.as_object();
+
+            // Get OSError fields directly
+            let errno_field = obj.get_attr("errno", vm).ok().filter(|v| !vm.is_none(v));
+            let strerror = obj.get_attr("strerror", vm).ok().filter(|v| !vm.is_none(v));
+            let filename = obj.get_attr("filename", vm).ok().filter(|v| !vm.is_none(v));
+            let filename2 = obj
+                .get_attr("filename2", vm)
+                .ok()
+                .filter(|v| !vm.is_none(v));
+            #[cfg(windows)]
+            let winerror = obj.get_attr("winerror", vm).ok().filter(|v| !vm.is_none(v));
+
+            // Windows: winerror takes priority over errno
+            #[cfg(windows)]
+            if let Some(ref win_err) = winerror {
+                let code = win_err.str(vm)?;
+                if let Some(ref f) = filename {
+                    let msg = strerror
+                        .as_ref()
+                        .map(|s| s.str(vm))
+                        .transpose()?
+                        .map(|s| s.to_string())
+                        .unwrap_or_else(|| "None".to_owned());
+                    if let Some(ref f2) = filename2 {
+                        return Ok(vm.ctx.new_str(format!(
+                            "[WinError {}] {}: {} -> {}",
+                            code,
+                            msg,
+                            f.repr(vm)?,
+                            f2.repr(vm)?
+                        )));
+                    }
+                    return Ok(vm.ctx.new_str(format!(
+                        "[WinError {}] {}: {}",
+                        code,
+                        msg,
+                        f.repr(vm)?
+                    )));
+                }
+                // winerror && strerror (no filename)
+                if let Some(ref s) = strerror {
+                    return Ok(vm
+                        .ctx
+                        .new_str(format!("[WinError {}] {}", code, s.str(vm)?)));
+                }
+            }
+
+            // Non-Windows or fallback: use errno
+            if let Some(ref f) = filename {
+                let errno_str = errno_field
+                    .as_ref()
+                    .map(|e| e.str(vm))
+                    .transpose()?
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| "None".to_owned());
+                let msg = strerror
+                    .as_ref()
+                    .map(|s| s.str(vm))
+                    .transpose()?
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| "None".to_owned());
+                if let Some(ref f2) = filename2 {
+                    return Ok(vm.ctx.new_str(format!(
+                        "[Errno {}] {}: {} -> {}",
+                        errno_str,
+                        msg,
+                        f.repr(vm)?,
+                        f2.repr(vm)?
+                    )));
+                }
+                return Ok(vm.ctx.new_str(format!(
+                    "[Errno {}] {}: {}",
+                    errno_str,
+                    msg,
+                    f.repr(vm)?
+                )));
+            }
+
+            // errno && strerror (no filename)
+            if let (Some(e), Some(s)) = (&errno_field, &strerror) {
+                return Ok(vm
+                    .ctx
+                    .new_str(format!("[Errno {}] {}", e.str(vm)?, s.str(vm)?)));
+            }
+
+            // fallback to BaseException.__str__
+            zelf.__str__(vm)
+        }
+
+        #[pymethod]
+        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
+            let args = exc.args();
+            let obj = exc.as_object().to_owned();
+            let mut result: Vec<PyObjectRef> = vec![obj.class().to_owned().into()];
+
+            if args.len() >= 2 && args.len() <= 5 {
+                // SAFETY: len() == 2 is checked so get_arg 1 or 2 won't panic
+                let errno = exc.get_arg(0).unwrap();
+                let msg = exc.get_arg(1).unwrap();
+
+                if let Ok(filename) = obj.get_attr("filename", vm) {
+                    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)
+                        {
+                            args_reduced.push(filename2);
+                        }
+                        result.push(args_reduced.into_pytuple(vm).into());
+                    } else {
+                        result.push(vm.new_tuple((errno, msg)).into());
+                    }
+                } else {
+                    result.push(vm.new_tuple((errno, msg)).into());
+                }
+            } else {
+                result.push(args.into());
+            }
+
+            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
+                result.push(dict.into());
+            }
+            result.into_pytuple(vm)
+        }
+
+        // Getters and setters for OSError fields
+        #[pygetset]
+        fn errno(&self) -> Option<PyObjectRef> {
+            self.errno.to_owned()
+        }
+
+        #[pygetset(setter)]
+        fn set_errno(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
+            self.errno.swap_to_temporary_refs(value, vm);
+        }
+
+        #[pygetset]
+        fn strerror(&self) -> Option<PyObjectRef> {
+            self.strerror.to_owned()
+        }
+
+        #[pygetset(setter, name = "strerror")]
+        fn set_strerror(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
+            self.strerror.swap_to_temporary_refs(value, vm);
+        }
+
+        #[pygetset]
+        fn filename(&self) -> Option<PyObjectRef> {
+            self.filename.to_owned()
+        }
+
+        #[pygetset(setter)]
+        fn set_filename(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
+            self.filename.swap_to_temporary_refs(value, vm);
+        }
+
+        #[pygetset]
+        fn filename2(&self) -> Option<PyObjectRef> {
+            self.filename2.to_owned()
+        }
+
+        #[pygetset(setter)]
+        fn set_filename2(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
+            self.filename2.swap_to_temporary_refs(value, vm);
+        }
+
+        #[cfg(windows)]
+        #[pygetset]
+        fn winerror(&self) -> Option<PyObjectRef> {
+            self.winerror.to_owned()
+        }
+
+        #[cfg(windows)]
+        #[pygetset(setter)]
+        fn set_winerror(&self, value: Option<PyObjectRef>, vm: &VirtualMachine) {
+            self.winerror.swap_to_temporary_refs(value, vm);
+        }
+
+        #[pygetset]
+        fn characters_written(&self, vm: &VirtualMachine) -> PyResult<isize> {
+            let written = self.written.load();
+            if written == -1 {
+                Err(vm.new_attribute_error("characters_written".to_owned()))
+            } else {
+                Ok(written)
+            }
+        }
+
+        #[pygetset(setter)]
+        fn set_characters_written(
+            &self,
+            value: Option<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            match value {
+                None => {
+                    // Deleting the attribute
+                    if self.written.load() == -1 {
+                        Err(vm.new_attribute_error("characters_written".to_owned()))
+                    } else {
+                        self.written.store(-1);
+                        Ok(())
+                    }
+                }
+                Some(v) => {
+                    let n = v
+                        .try_index(vm)?
+                        .try_to_primitive::<isize>(vm)
+                        .map_err(|_| {
+                            vm.new_value_error(
+                                "cannot convert characters_written value to isize".to_owned(),
+                            )
+                        })?;
+                    self.written.store(n);
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    #[pyexception(name, base = PyOSError, ctx = "blocking_io_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyBlockingIOError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "child_process_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyChildProcessError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "connection_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyConnectionError(PyOSError);
+
+    #[pyexception(name, base = PyConnectionError, ctx = "broken_pipe_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyBrokenPipeError(PyConnectionError);
+
+    #[pyexception(
+        name,
+        base = PyConnectionError,
+        ctx = "connection_aborted_error",
+        impl
+    )]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyConnectionAbortedError(PyConnectionError);
+
+    #[pyexception(
+        name,
+        base = PyConnectionError,
+        ctx = "connection_refused_error",
+        impl
+    )]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyConnectionRefusedError(PyConnectionError);
+
+    #[pyexception(name, base = PyConnectionError, ctx = "connection_reset_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyConnectionResetError(PyConnectionError);
+
+    #[pyexception(name, base = PyOSError, ctx = "file_exists_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyFileExistsError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "file_not_found_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyFileNotFoundError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "interrupted_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyInterruptedError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "is_a_directory_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyIsADirectoryError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "not_a_directory_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyNotADirectoryError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "permission_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyPermissionError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "process_lookup_error", impl)]
+    #[repr(transparent)]
+    #[derive(Debug)]
+    pub struct PyProcessLookupError(PyOSError);
+
+    #[pyexception(name, base = PyOSError, ctx = "timeout_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyTimeoutError(PyOSError);
+
+    #[pyexception(name, base = PyException, ctx = "reference_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyReferenceError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "runtime_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyRuntimeError(PyException);
+
+    #[pyexception(name, base = PyRuntimeError, ctx = "not_implemented_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyNotImplementedError(PyRuntimeError);
+
+    #[pyexception(name, base = PyRuntimeError, ctx = "recursion_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyRecursionError(PyRuntimeError);
+
+    #[pyexception(name, base = PyRuntimeError, ctx = "python_finalization_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyPythonFinalizationError(PyRuntimeError);
+
+    #[pyexception(name, base = PyException, ctx = "syntax_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySyntaxError(PyException);
+
+    #[pyexception(with(Initializer))]
+    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()
+                } else {
+                    filename.rsplit('/').next()
+                };
+                splitted.unwrap_or(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_filename = zelf.as_object().get_attr("filename", vm).ok().map(|obj| {
+                obj.str(vm)
+                    .unwrap_or_else(|_| vm.ctx.new_str("<filename str() failed>"))
+            });
+
+            let msg = match zelf.as_object().get_attr("msg", vm) {
+                Ok(obj) => obj
+                    .str(vm)
+                    .unwrap_or_else(|_| vm.ctx.new_str("<msg str() failed>")),
+                Err(_) => {
+                    // Fallback to the base formatting if the msg attribute was deleted or attribute lookup fails for any reason.
+                    return Py::<PyBaseException>::__str__(zelf, vm);
+                }
+            };
+
+            let msg_with_location_info: String = match (maybe_lineno, maybe_filename) {
+                (Some(lineno), Some(filename)) => {
+                    format!("{} ({}, line {})", msg, basename(filename.as_str()), lineno)
+                }
+                (Some(lineno), None) => {
+                    format!("{msg} (line {lineno})")
+                }
+                (None, Some(filename)) => {
+                    format!("{} ({})", msg, basename(filename.as_str()))
+                }
+                (None, None) => msg.to_string(),
+            };
+
+            Ok(vm.ctx.new_str(msg_with_location_info))
+        }
+    }
+
+    impl Initializer for PySyntaxError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let len = args.args.len();
+            let new_args = args;
+
+            zelf.set_attr("print_file_and_line", vm.ctx.none(), vm)?;
+
+            if len == 2
+                && let Ok(location_tuple) = new_args.args[1]
+                    .clone()
+                    .downcast::<crate::builtins::PyTuple>()
+            {
+                let location_tup_len = location_tuple.len();
+                for (i, &attr) in [
+                    "filename",
+                    "lineno",
+                    "offset",
+                    "text",
+                    "end_lineno",
+                    "end_offset",
+                ]
+                .iter()
+                .enumerate()
+                {
+                    if location_tup_len > i {
+                        zelf.set_attr(attr, location_tuple[i].to_owned(), vm)?;
+                    } else {
+                        break;
+                    }
+                }
+            }
+
+            PyBaseException::slot_init(zelf, new_args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(
+        name = "_IncompleteInputError",
+        base = PySyntaxError,
+        ctx = "incomplete_input_error"
+    )]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyIncompleteInputError(PySyntaxError);
+
+    #[pyexception(with(Initializer))]
+    impl PyIncompleteInputError {}
+
+    impl Initializer for PyIncompleteInputError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.set_attr("name", vm.ctx.new_str("SyntaxError"), vm)?;
+            PySyntaxError::slot_init(zelf, args, vm)
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PySyntaxError, ctx = "indentation_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyIndentationError(PySyntaxError);
+
+    #[pyexception(name, base = PyIndentationError, ctx = "tab_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyTabError(PyIndentationError);
+
+    #[pyexception(name, base = PyException, ctx = "system_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySystemError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "type_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyTypeError(PyException);
+
+    #[pyexception(name, base = PyException, ctx = "value_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyValueError(PyException);
+
+    #[pyexception(name, base = PyValueError, ctx = "unicode_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeError(PyValueError);
+
+    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_decode_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeDecodeError(PyUnicodeError);
+
+    #[pyexception(with(Initializer))]
+    impl PyUnicodeDecodeError {
+        #[pymethod]
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
+            };
+            let object: ArgBytesLike = object.try_into_value(vm)?;
+            let encoding: PyStrRef = zelf
+                .as_object()
+                .get_attr("encoding", vm)?
+                .try_into_value(vm)?;
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(if start < object.len() && end <= object.len() && end == start + 1 {
+                let b = object.borrow_buf()[start];
+                format!(
+                    "'{encoding}' codec can't decode byte {b:#02x} in position {start}: {reason}"
+                )
+            } else {
+                format!(
+                    "'{encoding}' codec can't decode bytes in position {start}-{}: {reason}",
+                    end - 1,
+                )
+            }))
+        }
+    }
+
+    impl Initializer for PyUnicodeDecodeError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, ArgBytesLike, isize, isize, PyStrRef);
+            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
+            zelf.set_attr("encoding", encoding, vm)?;
+            let object_as_bytes = vm.ctx.new_bytes(object.borrow_buf().to_vec());
+            zelf.set_attr("object", object_as_bytes, vm)?;
+            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
+            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
+            zelf.set_attr("reason", reason, vm)?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_encode_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeEncodeError(PyUnicodeError);
+
+    #[pyexception(with(Initializer))]
+    impl PyUnicodeEncodeError {
+        #[pymethod]
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
+            };
+            let object: PyStrRef = object.try_into_value(vm)?;
+            let encoding: PyStrRef = zelf
+                .as_object()
+                .get_attr("encoding", vm)?
+                .try_into_value(vm)?;
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(if start < object.char_len() && end <= object.char_len() && end == start + 1 {
+                let ch = object.as_wtf8().code_points().nth(start).unwrap();
+                format!(
+                    "'{encoding}' codec can't encode character '{}' in position {start}: {reason}",
+                    UnicodeEscapeCodepoint(ch)
+                )
+            } else {
+                format!(
+                    "'{encoding}' codec can't encode characters in position {start}-{}: {reason}",
+                    end - 1,
+                )
+            }))
+        }
+    }
+
+    impl Initializer for PyUnicodeEncodeError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, PyStrRef, isize, isize, PyStrRef);
+            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
+            zelf.set_attr("encoding", encoding, vm)?;
+            zelf.set_attr("object", object, vm)?;
+            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
+            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
+            zelf.set_attr("reason", reason, vm)?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    #[pyexception(name, base = PyUnicodeError, ctx = "unicode_translate_error")]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeTranslateError(PyUnicodeError);
+
+    #[pyexception(with(Initializer))]
+    impl PyUnicodeTranslateError {
+        #[pymethod]
+        fn __str__(zelf: &Py<PyBaseException>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+            let Ok(object) = zelf.as_object().get_attr("object", vm) else {
+                return Ok(vm.ctx.empty_str.to_owned());
+            };
+            let object: PyStrRef = object.try_into_value(vm)?;
+            let start: usize = zelf.as_object().get_attr("start", vm)?.try_into_value(vm)?;
+            let end: usize = zelf.as_object().get_attr("end", vm)?.try_into_value(vm)?;
+            let reason: PyStrRef = zelf
+                .as_object()
+                .get_attr("reason", vm)?
+                .try_into_value(vm)?;
+            Ok(vm.ctx.new_str(
+                if start < object.char_len() && end <= object.char_len() && end == start + 1 {
+                    let ch = object.as_wtf8().code_points().nth(start).unwrap();
+                    format!(
+                        "can't translate character '{}' in position {start}: {reason}",
+                        UnicodeEscapeCodepoint(ch)
+                    )
+                } else {
+                    format!(
+                        "can't translate characters in position {start}-{}: {reason}",
+                        end - 1,
+                    )
+                },
+            ))
+        }
+    }
+
+    impl Initializer for PyUnicodeTranslateError {
+        type Args = FuncArgs;
+
+        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            type Args = (PyStrRef, isize, isize, PyStrRef);
+            let (object, start, end, reason): Args = args.bind(vm)?;
+            zelf.set_attr("object", object, vm)?;
+            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
+            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
+            zelf.set_attr("reason", reason, vm)?;
+            Ok(())
+        }
+
+        fn init(_zelf: PyRef<Self>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_init is defined")
+        }
+    }
+
+    /// JIT error.
+    #[cfg(feature = "jit")]
+    #[pyexception(name, base = PyException, ctx = "jit_error", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyJitError(PyException);
+
+    // Warnings
+    #[pyexception(name, base = PyException, ctx = "warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyWarning(PyException);
+
+    #[pyexception(name, base = PyWarning, ctx = "deprecation_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyDeprecationWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "pending_deprecation_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyPendingDeprecationWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "runtime_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyRuntimeWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "syntax_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PySyntaxWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "user_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUserWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "future_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyFutureWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "import_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyImportWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "unicode_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyUnicodeWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "bytes_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyBytesWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "resource_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyResourceWarning(PyWarning);
+
+    #[pyexception(name, base = PyWarning, ctx = "encoding_warning", impl)]
+    #[derive(Debug)]
+    #[repr(transparent)]
+    pub struct PyEncodingWarning(PyWarning);
+}
+
+/// Check if match_type is valid for except* (must be exception type, not ExceptionGroup).
+fn check_except_star_type_valid(match_type: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    let base_exc: PyObjectRef = vm.ctx.exceptions.base_exception_type.to_owned().into();
+    let base_eg: PyObjectRef = vm.ctx.exceptions.base_exception_group.to_owned().into();
+
+    // Helper to check a single type
+    let check_one = |exc_type: &PyObjectRef| -> PyResult<()> {
+        // Must be a subclass of BaseException
+        if !exc_type.is_subclass(&base_exc, vm)? {
+            return Err(vm.new_type_error(
+                "catching classes that do not inherit from BaseException is not allowed".to_owned(),
+            ));
+        }
+        // Must not be a subclass of BaseExceptionGroup
+        if exc_type.is_subclass(&base_eg, vm)? {
+            return Err(vm.new_type_error(
+                "catching ExceptionGroup with except* is not allowed. Use except instead."
+                    .to_owned(),
+            ));
+        }
+        Ok(())
+    };
+
+    // If it's a tuple, check each element
+    if let Ok(tuple) = match_type.clone().downcast::<PyTuple>() {
+        for item in tuple.iter() {
+            check_one(item)?;
+        }
+    } else {
+        check_one(match_type)?;
+    }
+    Ok(())
+}
+
+/// Match exception against except* handler type.
+/// Returns (rest, match) tuple.
+pub fn exception_group_match(
+    exc_value: &PyObjectRef,
+    match_type: &PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<(PyObjectRef, PyObjectRef)> {
+    // Implements _PyEval_ExceptionGroupMatch
+
+    // If exc_value is None, return (None, None)
+    if vm.is_none(exc_value) {
+        return Ok((vm.ctx.none(), vm.ctx.none()));
+    }
+
+    // Validate match_type and reject ExceptionGroup/BaseExceptionGroup
+    check_except_star_type_valid(match_type, vm)?;
+
+    // Check if exc_value matches match_type
+    if exc_value.is_instance(match_type, vm)? {
+        // Full match of exc itself
+        let is_eg = exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group);
+        let matched = if is_eg {
+            exc_value.clone()
+        } else {
+            // Naked exception - wrap it in ExceptionGroup
+            let excs = vm.ctx.new_tuple(vec![exc_value.clone()]);
+            let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+            let wrapped = eg_type.call((vm.ctx.new_str(""), excs), vm)?;
+            // Copy traceback from original exception
+            if let Ok(exc) = exc_value.clone().downcast::<types::PyBaseException>()
+                && let Some(tb) = exc.__traceback__()
+                && let Ok(wrapped_exc) = wrapped.clone().downcast::<types::PyBaseException>()
+            {
+                let _ = wrapped_exc.set___traceback__(tb.into(), vm);
+            }
+            wrapped
+        };
+        return Ok((vm.ctx.none(), matched));
+    }
+
+    // Check for partial match if it's an exception group
+    if exc_value.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        let pair = vm.call_method(exc_value, "split", (match_type.clone(),))?;
+        if !pair.class().is(vm.ctx.types.tuple_type) {
+            return Err(vm.new_type_error(format!(
+                "{}.split must return a tuple, not {}",
+                exc_value.class().name(),
+                pair.class().name()
+            )));
+        }
+        let pair_tuple: PyTupleRef = pair.try_into_value(vm)?;
+        if pair_tuple.len() < 2 {
+            return Err(vm.new_type_error(format!(
+                "{}.split must return a 2-tuple, got tuple of size {}",
+                exc_value.class().name(),
+                pair_tuple.len()
+            )));
+        }
+        let matched = pair_tuple[0].clone();
+        let rest = pair_tuple[1].clone();
+        return Ok((rest, matched));
+    }
+
+    // No match
+    Ok((exc_value.clone(), vm.ctx.none()))
+}
+
+/// Prepare exception for reraise in except* block.
+/// Implements _PyExc_PrepReraiseStar
+pub fn prep_reraise_star(orig: PyObjectRef, excs: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    use crate::builtins::PyList;
+
+    let excs_list = excs
+        .downcast::<PyList>()
+        .map_err(|_| vm.new_type_error("expected list for prep_reraise_star"))?;
+
+    let excs_vec: Vec<PyObjectRef> = excs_list.borrow_vec().to_vec();
+
+    // If no exceptions to process, return None
+    if excs_vec.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Special case: naked exception (not an ExceptionGroup)
+    // Only one except* clause could have executed, so there's at most one exception to raise
+    if !orig.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        // Find first non-None exception
+        let first = excs_vec.into_iter().find(|e| !vm.is_none(e));
+        return Ok(first.unwrap_or_else(|| vm.ctx.none()));
+    }
+
+    // Split excs into raised (new) and reraised (from original) by comparing metadata
+    let mut raised: Vec<PyObjectRef> = Vec::new();
+    let mut reraised: Vec<PyObjectRef> = Vec::new();
+
+    for exc in excs_vec {
+        if vm.is_none(&exc) {
+            continue;
+        }
+        // Check if this exception came from the original group
+        if is_exception_from_orig(&exc, &orig, vm) {
+            reraised.push(exc);
+        } else {
+            raised.push(exc);
+        }
+    }
+
+    // If no exceptions to reraise, return None
+    if raised.is_empty() && reraised.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Project reraised exceptions onto original structure to preserve nesting
+    let reraised_eg = exception_group_projection(&orig, &reraised, vm)?;
+
+    // If no new raised exceptions, just return the reraised projection
+    if raised.is_empty() {
+        return Ok(reraised_eg);
+    }
+
+    // Combine raised with reraised_eg
+    if !vm.is_none(&reraised_eg) {
+        raised.push(reraised_eg);
+    }
+
+    // If only one exception, return it directly
+    if raised.len() == 1 {
+        return Ok(raised.into_iter().next().unwrap());
+    }
+
+    // Create new ExceptionGroup for multiple exceptions
+    let excs_tuple = vm.ctx.new_tuple(raised);
+    let eg_type: PyObjectRef = crate::exception_group::exception_group().to_owned().into();
+    eg_type.call((vm.ctx.new_str(""), excs_tuple), vm)
+}
+
+/// Check if an exception came from the original group (for reraise detection).
+/// Instead of comparing metadata (which can be modified when caught), we compare
+/// leaf exception object IDs. split() preserves leaf exception identity.
+fn is_exception_from_orig(exc: &PyObjectRef, orig: &PyObjectRef, vm: &VirtualMachine) -> bool {
+    // Collect leaf exception IDs from exc
+    let mut exc_leaf_ids = HashSet::new();
+    collect_exception_group_leaf_ids(exc, &mut exc_leaf_ids, vm);
+
+    if exc_leaf_ids.is_empty() {
+        return false;
+    }
+
+    // Collect leaf exception IDs from orig
+    let mut orig_leaf_ids = HashSet::new();
+    collect_exception_group_leaf_ids(orig, &mut orig_leaf_ids, vm);
+
+    // If ALL of exc's leaves are in orig's leaves, it's a reraise
+    exc_leaf_ids.iter().all(|id| orig_leaf_ids.contains(id))
+}
+
+/// Collect all leaf exception IDs from an exception (group).
+fn collect_exception_group_leaf_ids(
+    exc: &PyObjectRef,
+    leaf_ids: &mut HashSet<usize>,
+    vm: &VirtualMachine,
+) {
+    if vm.is_none(exc) {
+        return;
+    }
+
+    // If not an exception group, it's a leaf - add its ID
+    if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        leaf_ids.insert(exc.get_id());
+        return;
+    }
+
+    // Recurse into exception group's exceptions
+    if let Ok(excs_attr) = exc.get_attr("exceptions", vm)
+        && let Ok(tuple) = excs_attr.downcast::<PyTuple>()
+    {
+        for e in tuple.iter() {
+            collect_exception_group_leaf_ids(e, leaf_ids, vm);
+        }
+    }
+}
+
+/// Project orig onto keep list, preserving nested structure.
+/// Returns an exception group containing only the exceptions from orig
+/// that are also in the keep list.
+fn exception_group_projection(
+    orig: &PyObjectRef,
+    keep: &[PyObjectRef],
+    vm: &VirtualMachine,
+) -> PyResult {
+    if keep.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Collect all leaf IDs from keep list
+    let mut leaf_ids = HashSet::new();
+    for e in keep {
+        collect_exception_group_leaf_ids(e, &mut leaf_ids, vm);
+    }
+
+    // Split orig by matching leaf IDs, preserving structure
+    split_by_leaf_ids(orig, &leaf_ids, vm)
+}
+
+/// Recursively split an exception (group) by leaf IDs.
+/// Returns the projection containing only matching leaves with preserved structure.
+fn split_by_leaf_ids(
+    exc: &PyObjectRef,
+    leaf_ids: &HashSet<usize>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    if vm.is_none(exc) {
+        return Ok(vm.ctx.none());
+    }
+
+    // If not an exception group, check if it's in our set
+    if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_group) {
+        if leaf_ids.contains(&exc.get_id()) {
+            return Ok(exc.clone());
+        }
+        return Ok(vm.ctx.none());
+    }
+
+    // Exception group - recurse and reconstruct
+    let excs_attr = exc.get_attr("exceptions", vm)?;
+    let tuple: PyTupleRef = excs_attr.try_into_value(vm)?;
+
+    let mut matched = Vec::new();
+    for e in tuple.iter() {
+        let m = split_by_leaf_ids(e, leaf_ids, vm)?;
+        if !vm.is_none(&m) {
+            matched.push(m);
+        }
+    }
+
+    if matched.is_empty() {
+        return Ok(vm.ctx.none());
+    }
+
+    // Reconstruct using derive() to preserve the structure (not necessarily the subclass type)
+    let matched_tuple = vm.ctx.new_tuple(matched);
+    vm.call_method(exc, "derive", (matched_tuple,))
+}
diff --git a/crates/vm/src/format.rs b/crates/vm/src/format.rs
new file mode 100644
index 0000000000..04d06e9be0
--- /dev/null
+++ b/crates/vm/src/format.rs
@@ -0,0 +1,177 @@
+use crate::{
+    PyObject, PyResult, VirtualMachine,
+    builtins::PyBaseExceptionRef,
+    convert::{IntoPyException, ToPyException},
+    function::FuncArgs,
+    stdlib::builtins,
+};
+
+use crate::common::format::*;
+use crate::common::wtf8::{Wtf8, Wtf8Buf};
+
+impl IntoPyException for FormatSpecError {
+    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        match self {
+            Self::DecimalDigitsTooMany => {
+                vm.new_value_error("Too many decimal digits in format string")
+            }
+            Self::PrecisionTooBig => vm.new_value_error("Precision too big"),
+            Self::InvalidFormatSpecifier => vm.new_value_error("Invalid format specifier"),
+            Self::UnspecifiedFormat(c1, c2) => {
+                let msg = format!("Cannot specify '{c1}' with '{c2}'.");
+                vm.new_value_error(msg)
+            }
+            Self::ExclusiveFormat(c1, c2) => {
+                let msg = format!("Cannot specify both '{c1}' and '{c2}'.");
+                vm.new_value_error(msg)
+            }
+            Self::UnknownFormatCode(c, s) => {
+                let msg = format!("Unknown format code '{c}' for object of type '{s}'");
+                vm.new_value_error(msg)
+            }
+            Self::PrecisionNotAllowed => {
+                vm.new_value_error("Precision not allowed in integer format specifier")
+            }
+            Self::NotAllowed(s) => {
+                let msg = format!("{s} not allowed with integer format specifier 'c'");
+                vm.new_value_error(msg)
+            }
+            Self::UnableToConvert => vm.new_value_error("Unable to convert int to float"),
+            Self::CodeNotInRange => vm.new_overflow_error("%c arg not in range(0x110000)"),
+            Self::ZeroPadding => {
+                vm.new_value_error("Zero padding is not allowed in complex format specifier")
+            }
+            Self::AlignmentFlag => {
+                vm.new_value_error("'=' alignment flag is not allowed in complex format specifier")
+            }
+            Self::NotImplemented(c, s) => {
+                let msg = format!("Format code '{c}' for object of type '{s}' not implemented yet");
+                vm.new_value_error(msg)
+            }
+        }
+    }
+}
+
+impl ToPyException for FormatParseError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        match self {
+            Self::UnmatchedBracket => vm.new_value_error("expected '}' before end of string"),
+            _ => vm.new_value_error("Unexpected error parsing format string"),
+        }
+    }
+}
+
+fn format_internal(
+    vm: &VirtualMachine,
+    format: &FormatString,
+    field_func: &mut impl FnMut(FieldType) -> PyResult,
+) -> PyResult<Wtf8Buf> {
+    let mut final_string = Wtf8Buf::new();
+    for part in &format.format_parts {
+        let pystr;
+        let result_string: &Wtf8 = match part {
+            FormatPart::Field {
+                field_name,
+                conversion_spec,
+                format_spec,
+            } => {
+                let FieldName { field_type, parts } =
+                    FieldName::parse(field_name).map_err(|e| e.to_pyexception(vm))?;
+
+                let mut argument = field_func(field_type)?;
+
+                for name_part in parts {
+                    match name_part {
+                        FieldNamePart::Attribute(attribute) => {
+                            argument = argument.get_attr(&vm.ctx.new_str(attribute), vm)?;
+                        }
+                        FieldNamePart::Index(index) => {
+                            argument = argument.get_item(&index, vm)?;
+                        }
+                        FieldNamePart::StringIndex(index) => {
+                            argument = argument.get_item(&index, vm)?;
+                        }
+                    }
+                }
+
+                let nested_format =
+                    FormatString::from_str(format_spec).map_err(|e| e.to_pyexception(vm))?;
+                let format_spec = format_internal(vm, &nested_format, field_func)?;
+
+                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::Bytes) => {
+                        vm.call_method(&argument, identifier!(vm, decode).as_str(), ())?
+                    }
+                    None => argument,
+                };
+
+                // FIXME: compiler can intern specs using parser tree. Then this call can be interned_str
+                pystr = vm.format(&argument, vm.ctx.new_str(format_spec))?;
+                pystr.as_wtf8()
+            }
+            FormatPart::Literal(literal) => literal,
+        };
+        final_string.push_wtf8(result_string);
+    }
+    Ok(final_string)
+}
+
+pub(crate) fn format(
+    format: &FormatString,
+    arguments: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult<Wtf8Buf> {
+    let mut auto_argument_index: usize = 0;
+    let mut seen_index = false;
+    format_internal(vm, format, &mut |field_type| match field_type {
+        FieldType::Auto => {
+            if seen_index {
+                return Err(vm.new_value_error(
+                    "cannot switch from manual field specification to automatic field numbering",
+                ));
+            }
+            auto_argument_index += 1;
+            arguments
+                .args
+                .get(auto_argument_index - 1)
+                .cloned()
+                .ok_or_else(|| vm.new_index_error("tuple index out of range"))
+        }
+        FieldType::Index(index) => {
+            if auto_argument_index != 0 {
+                return Err(vm.new_value_error(
+                    "cannot switch from automatic field numbering to manual field specification",
+                ));
+            }
+            seen_index = true;
+            arguments
+                .args
+                .get(index)
+                .cloned()
+                .ok_or_else(|| vm.new_index_error("tuple index out of range"))
+        }
+        FieldType::Keyword(keyword) => keyword
+            .as_str()
+            .ok()
+            .and_then(|keyword| arguments.get_optional_kwarg(keyword))
+            .ok_or_else(|| vm.new_key_error(vm.ctx.new_str(keyword).into())),
+    })
+}
+
+pub(crate) fn format_map(
+    format: &FormatString,
+    dict: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<Wtf8Buf> {
+    format_internal(vm, format, &mut |field_type| match field_type {
+        FieldType::Auto | FieldType::Index(_) => {
+            Err(vm.new_value_error("Format string contains positional fields"))
+        }
+        FieldType::Keyword(keyword) => dict.get_item(&keyword, vm),
+    })
+}
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
new file mode 100644
index 0000000000..3e356466e5
--- /dev/null
+++ b/crates/vm/src/frame.rs
@@ -0,0 +1,2886 @@
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, 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},
+    },
+    bytecode::{self, Instruction},
+    convert::{IntoObject, ToPyResult},
+    coroutine::Coro,
+    exceptions::ExceptionCtor,
+    function::{ArgMapping, Either, FuncArgs},
+    protocol::{PyIter, PyIterReturn},
+    scope::Scope,
+    stdlib::{builtins, typing},
+    types::PyTypeFlags,
+    vm::{Context, PyMethod},
+};
+use alloc::fmt;
+use core::iter::zip;
+#[cfg(feature = "threading")]
+use core::sync::atomic;
+use indexmap::IndexMap;
+use itertools::Itertools;
+
+use rustpython_common::{boxvec::BoxVec, lock::PyMutex, wtf8::Wtf8Buf};
+use rustpython_compiler_core::SourceLocation;
+
+pub type FrameRef = PyRef<Frame>;
+
+/// The reason why we might be unwinding a block.
+/// This could be return of function, exception being
+/// raised, a break or continue being hit, etc..
+#[derive(Clone, Debug)]
+enum UnwindReason {
+    /// We are returning a value from a return statement.
+    Returning { value: PyObjectRef },
+
+    /// We hit an exception, so unwind any try-except and finally blocks. The exception should be
+    /// on top of the vm exception stack.
+    Raising { exception: PyBaseExceptionRef },
+
+    // NoWorries,
+    /// We are unwinding blocks, since we hit break
+    Break { target: bytecode::Label },
+
+    /// We are unwinding blocks since we hit a continue statements.
+    Continue { target: bytecode::Label },
+}
+
+#[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,
+}
+
+#[cfg(feature = "threading")]
+type Lasti = atomic::AtomicU32;
+#[cfg(not(feature = "threading"))]
+type Lasti = core::cell::Cell<u32>;
+
+#[pyclass(module = false, name = "frame")]
+pub struct Frame {
+    pub code: PyRef<PyCode>,
+    pub func_obj: Option<PyObjectRef>,
+
+    pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
+    pub(crate) cells_frees: Box<[PyCellRef]>,
+    pub locals: ArgMapping,
+    pub globals: PyDictRef,
+    pub builtins: PyDictRef,
+
+    // 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,
+    /// tracer function for this frame (usually is None)
+    pub trace: PyMutex<PyObjectRef>,
+    state: PyMutex<FrameState>,
+
+    // member
+    pub trace_lines: PyMutex<bool>,
+    pub temporary_refs: PyMutex<Vec<PyObjectRef>>,
+}
+
+impl PyPayload for Frame {
+    #[inline]
+    fn class(ctx: &Context) -> &'static Py<PyType> {
+        ctx.types.frame_type
+    }
+}
+
+// Running a frame can result in one of the below:
+pub enum ExecutionResult {
+    Return(PyObjectRef),
+    Yield(PyObjectRef),
+}
+
+/// A valid execution result, or an exception
+type FrameResult = PyResult<Option<ExecutionResult>>;
+
+impl Frame {
+    pub(crate) fn new(
+        code: PyRef<PyCode>,
+        scope: Scope,
+        builtins: PyDictRef,
+        closure: &[PyCellRef],
+        func_obj: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> Self {
+        let cells_frees = core::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
+            .take(code.cellvars.len())
+            .chain(closure.iter().cloned())
+            .collect();
+
+        let state = FrameState {
+            stack: BoxVec::new(code.max_stackdepth as usize),
+            #[cfg(feature = "threading")]
+            lasti: 0,
+        };
+
+        Self {
+            fastlocals: PyMutex::new(vec![None; code.varnames.len()].into_boxed_slice()),
+            cells_frees,
+            locals: scope.locals,
+            globals: scope.globals,
+            builtins,
+            code,
+            func_obj,
+            lasti: Lasti::new(0),
+            state: PyMutex::new(state),
+            trace: PyMutex::new(vm.ctx.none()),
+            trace_lines: PyMutex::new(true),
+            temporary_refs: PyMutex::new(vec![]),
+        }
+    }
+
+    pub fn current_location(&self) -> SourceLocation {
+        self.code.locations[self.lasti() as usize - 1].0
+    }
+
+    pub fn lasti(&self) -> u32 {
+        #[cfg(feature = "threading")]
+        {
+            self.lasti.load(atomic::Ordering::Relaxed)
+        }
+        #[cfg(not(feature = "threading"))]
+        {
+            self.lasti.get()
+        }
+    }
+
+    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),
+                }
+            }
+        }
+        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()..])?;
+            }
+        }
+        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)
+    }
+
+    // #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    pub fn run(&self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
+        self.with_exec(|mut exec| exec.run(vm))
+    }
+
+    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)
+        })
+    }
+
+    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))
+    }
+
+    pub fn yield_from_target(&self) -> Option<PyObjectRef> {
+        self.with_exec(|exec| 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")
+    }
+
+    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;
+                }
+            }
+        })
+    }
+}
+
+/// An executing frame; essentially just a struct to combine the immutable data outside the mutex
+/// with the mutable data inside
+struct ExecutingFrame<'a> {
+    code: &'a PyRef<PyCode>,
+    fastlocals: &'a PyMutex<Box<[Option<PyObjectRef>]>>,
+    cells_frees: &'a [PyCellRef],
+    locals: &'a ArgMapping,
+    globals: &'a PyDictRef,
+    builtins: &'a PyDictRef,
+    object: &'a Py<Frame>,
+    lasti: &'a Lasti,
+    state: &'a mut FrameState,
+}
+
+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)
+            .finish()
+    }
+}
+
+impl ExecutingFrame<'_> {
+    #[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);
+        }
+    }
+
+    #[inline(always)]
+    const fn lasti(&self) -> u32 {
+        #[cfg(feature = "threading")]
+        {
+            self.state.lasti
+        }
+        #[cfg(not(feature = "threading"))]
+        {
+            self.lasti.get()
+        }
+    }
+
+    fn run(&mut self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
+        flame_guard!(format!(
+            "Frame::run({obj_name})",
+            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;
+            self.update_lasti(|i| *i += 1);
+            let bytecode::CodeUnit { op, arg } = instructions[idx];
+            let arg = arg_state.extend(arg);
+            let mut do_extend_arg = false;
+            let result = self.execute_instruction(op, arg, &mut do_extend_arg, vm);
+            match result {
+                Ok(None) => {}
+                Ok(Some(value)) => {
+                    break Ok(value);
+                }
+                // Instruction raised an exception
+                Err(exception) => {
+                    #[cold]
+                    fn handle_exception(
+                        frame: &mut ExecutingFrame<'_>,
+                        exception: PyBaseExceptionRef,
+                        idx: usize,
+                        is_reraise: bool,
+                        vm: &VirtualMachine,
+                    ) -> FrameResult {
+                        // 1. Extract traceback from exception's '__traceback__' attr.
+                        // 2. Add new entry with current execution position (filename, lineno, code_object) to traceback.
+                        // 3. First, try to find handler in exception table
+
+                        // RERAISE instructions should not add traceback entries - they're just
+                        // re-raising an already-processed exception
+                        if !is_reraise {
+                            // PyTraceBack_Here always adds a new entry without
+                            // checking for duplicates. Each time an exception passes through
+                            // a frame (e.g., in a loop with repeated raise statements),
+                            // a new traceback entry is added.
+                            let (loc, _end_loc) = frame.code.locations[idx];
+                            let next = exception.__traceback__();
+
+                            let new_traceback = PyTraceback::new(
+                                next,
+                                frame.object.to_owned(),
+                                idx as u32 * 2,
+                                loc.line,
+                            );
+                            vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.line);
+                            exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                        }
+
+                        // Only contextualize exception for new raises, not re-raises
+                        // CPython only calls _PyErr_SetObject (which does chaining) on initial raise
+                        // RERAISE just propagates the exception without modifying __context__
+                        if !is_reraise {
+                            vm.contextualize_exception(&exception);
+                        }
+
+                        // Use exception table for zero-cost exception handling
+                        frame.unwind_blocks(vm, UnwindReason::Raising { exception })
+                    }
+
+                    // 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
+                    let is_reraise = match op {
+                        Instruction::RaiseVarargs { kind } => matches!(
+                            kind.get(arg),
+                            bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
+                        ),
+                        Instruction::Reraise { .. } => true,
+                        _ => false,
+                    };
+
+                    match handle_exception(self, exception, idx, is_reraise, vm) {
+                        Ok(None) => {}
+                        Ok(Some(result)) => break Ok(result),
+                        Err(exception) => {
+                            // Restore lasti from traceback so frame.f_lineno matches tb_lineno
+                            // The traceback was created with the correct lasti when exception
+                            // was first raised, but frame.lasti may have changed during cleanup
+                            if let Some(tb) = exception.__traceback__()
+                                && core::ptr::eq::<Py<Frame>>(&*tb.frame, self.object)
+                            {
+                                // This traceback entry is for this frame - restore its lasti
+                                // tb.lasti is in bytes (idx * 2), convert back to instruction index
+                                self.update_lasti(|i| *i = tb.lasti / 2);
+                            }
+                            break Err(exception);
+                        }
+                    }
+                }
+            }
+            if !do_extend_arg {
+                arg_state.reset()
+            }
+        }
+    }
+
+    fn yield_from_target(&self) -> Option<&PyObject> {
+        // checks gi_frame_state == FRAME_SUSPENDED_YIELD_FROM
+        // which is set when YIELD_VALUE with oparg >= 1 is executed.
+        // In RustPython, we check:
+        // 1. lasti points to RESUME (after YIELD_VALUE)
+        // 2. The previous instruction was YIELD_VALUE with arg >= 1
+        // 3. Stack top is the delegate (receiver)
+        //
+        // First check if stack is empty - if so, we can't be in yield-from
+        if self.state.stack.is_empty() {
+            return None;
+        }
+        let lasti = self.lasti() as usize;
+        if let Some(unit) = self.code.instructions.get(lasti) {
+            match &unit.op {
+                Instruction::Send { .. } => return Some(self.top_value()),
+                Instruction::Resume { .. } => {
+                    // Check if previous instruction was YIELD_VALUE with arg >= 1
+                    // This indicates yield-from/await context
+                    if lasti > 0
+                        && let Some(prev_unit) = self.code.instructions.get(lasti - 1)
+                        && let Instruction::YieldValue { .. } = &prev_unit.op
+                    {
+                        // YIELD_VALUE arg: 0 = direct yield, >= 1 = yield-from/await
+                        // OpArgByte.0 is the raw byte value
+                        if prev_unit.arg.0 >= 1 {
+                            // In yield-from/await context, delegate is on top of stack
+                            return Some(self.top_value());
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        None
+    }
+
+    /// Handle throw() on a generator/coroutine.
+    fn gen_throw(
+        &mut self,
+        vm: &VirtualMachine,
+        exc_type: PyObjectRef,
+        exc_val: PyObjectRef,
+        exc_tb: PyObjectRef,
+    ) -> PyResult<ExecutionResult> {
+        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))
+            } 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| {
+                    // This pushes Py_None to stack and restarts evalloop in exception mode.
+                    // Stack before throw: [receiver] (YIELD_VALUE already popped yielded value)
+                    // After pushing None: [receiver, None]
+                    // Exception handler will push exc: [receiver, None, exc]
+                    // CLEANUP_THROW expects: [sub_iter, last_sent_val, exc]
+                    self.push_value(vm.ctx.none());
+
+                    // Use unwind_blocks to let exception table route to CLEANUP_THROW
+                    match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
+                        Ok(None) => self.run(vm),
+                        Ok(Some(result)) => Ok(result),
+                        Err(exception) => Err(exception),
+                    }
+                });
+            }
+        }
+        // throw_here: no delegate has throw method, or not in yield-from
+        // gen_send_ex pushes Py_None to stack and restarts evalloop in exception mode
+        let exception = vm.normalize_exception(exc_type, exc_val, exc_tb)?;
+
+        // Add traceback entry for the generator frame at the yield site
+        let idx = self.lasti().saturating_sub(1) as usize;
+        if idx < self.code.locations.len() {
+            let (loc, _end_loc) = self.code.locations[idx];
+            let next = exception.__traceback__();
+            let new_traceback =
+                PyTraceback::new(next, self.object.to_owned(), idx as u32 * 2, loc.line);
+            exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+        }
+
+        // when raising an exception, set __context__ to the current exception
+        // This is done in _PyErr_SetObject
+        vm.contextualize_exception(&exception);
+
+        // always pushes Py_None before calling gen_send_ex with exc=1
+        // This is needed for exception handler to have correct stack state
+        self.push_value(vm.ctx.none());
+
+        match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
+            Ok(None) => self.run(vm),
+            Ok(Some(result)) => Ok(result),
+            Err(exception) => Err(exception),
+        }
+    }
+
+    fn unbound_cell_exception(&self, i: usize, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        if let Some(&name) = self.code.cellvars.get(i) {
+            vm.new_exception_msg(
+                vm.ctx.exceptions.unbound_local_error.to_owned(),
+                format!("local variable '{name}' referenced before assignment"),
+            )
+        } 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(),
+            )
+        }
+    }
+
+    /// Execute a single instruction.
+    #[inline(always)]
+    fn execute_instruction(
+        &mut self,
+        instruction: Instruction,
+        arg: bytecode::OpArg,
+        extend_arg: &mut bool,
+        vm: &VirtualMachine,
+    ) -> FrameResult {
+        vm.check_signals()?;
+
+        flame_guard!(format!(
+            "Frame::execute_instruction({})",
+            instruction.display(arg, &self.code.code).to_string()
+        ));
+
+        #[cfg(feature = "vm-tracing-logging")]
+        {
+            trace!("=======");
+            /* TODO:
+            for frame in self.frames.iter() {
+                trace!("  {:?}", frame);
+            }
+            */
+            trace!("  {:#?}", self);
+            trace!(
+                "  Executing op code: {}",
+                instruction.display(arg, &self.code.code)
+            );
+            trace!("=======");
+        }
+
+        #[cold]
+        fn name_error(name: &'static PyStrInterned, vm: &VirtualMachine) -> PyBaseExceptionRef {
+            vm.new_name_error(format!("name '{name}' is not defined"), name.to_owned())
+        }
+
+        match instruction {
+            Instruction::BeforeAsyncWith => {
+                let mgr = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the asynchronous context manager protocol",
+                        mgr.class().name(),
+                    )
+                };
+
+                let aenter_res = vm
+                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
+                let aexit = mgr
+                    .get_attr(identifier!(vm, __aexit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error({
+                            format!("{} (missed __aexit__ method)", error_string())
+                        })
+                    })?;
+                self.push_value(aexit);
+                self.push_value(aenter_res);
+
+                Ok(None)
+            }
+            Instruction::BinaryOp { op } => self.execute_bin_op(vm, op.get(arg)),
+            Instruction::BinarySubscr => {
+                let key = self.pop_value();
+                let container = self.pop_value();
+                let result = container.get_item(key.as_object(), vm)?;
+                self.push_value(result);
+                Ok(None)
+            }
+
+            Instruction::Break { target } => self.unwind_blocks(
+                vm,
+                UnwindReason::Break {
+                    target: target.get(arg),
+                },
+            ),
+            Instruction::BuildListFromTuples { size } => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
+                Ok(None)
+            }
+            Instruction::BuildList { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_list(elements);
+                self.push_value(list_obj.into());
+                Ok(None)
+            }
+            Instruction::BuildMapForCall { size } => {
+                self.execute_build_map_for_call(vm, size.get(arg))
+            }
+            Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
+            Instruction::BuildSetFromTuples { size } => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    // SAFETY: trust compiler
+                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
+                    for item in tup.iter() {
+                        set.add(item.clone(), vm)?;
+                    }
+                }
+                self.push_value(set.into());
+                Ok(None)
+            }
+            Instruction::BuildSet { size } => {
+                let set = PySet::default().into_ref(&vm.ctx);
+                for element in self.pop_multiple(size.get(arg) as usize) {
+                    set.add(element, vm)?;
+                }
+                self.push_value(set.into());
+                Ok(None)
+            }
+            Instruction::BuildSlice { argc } => self.execute_build_slice(vm, argc.get(arg)),
+            /*
+             Instruction::ToBool => {
+                 dbg!("Shouldn't be called outside of match statements for now")
+                 let value = self.pop_value();
+                 // call __bool__
+                 let result = value.try_to_bool(vm)?;
+                 self.push_value(vm.ctx.new_bool(result).into());
+                 Ok(None)
+            }
+            */
+            Instruction::BuildString { size } => {
+                let s: Wtf8Buf = self
+                    .pop_multiple(size.get(arg) as usize)
+                    .map(|pyobj| pyobj.downcast::<PyStr>().unwrap())
+                    .collect();
+                self.push_value(vm.ctx.new_str(s).into());
+                Ok(None)
+            }
+            Instruction::BuildTupleFromIter => {
+                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
+                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
+                    let list_obj = vm.ctx.new_tuple(elements);
+                    self.push_value(list_obj.into());
+                }
+                Ok(None)
+            }
+            Instruction::BuildTupleFromTuples { size } => {
+                // SAFETY: compiler guarantees `size` tuples are on the stack
+                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
+                Ok(None)
+            }
+            Instruction::BuildTuple { size } => {
+                let elements = self.pop_multiple(size.get(arg) as usize).collect();
+                let list_obj = vm.ctx.new_tuple(elements);
+                self.push_value(list_obj.into());
+                Ok(None)
+            }
+            Instruction::BuildTemplate => {
+                // Stack: [strings_tuple, interpolations_tuple] -> [template]
+                let interpolations = self.pop_value();
+                let strings = self.pop_value();
+
+                let strings = strings
+                    .downcast::<PyTuple>()
+                    .map_err(|_| vm.new_type_error("BUILD_TEMPLATE expected tuple for strings"))?;
+                let interpolations = interpolations.downcast::<PyTuple>().map_err(|_| {
+                    vm.new_type_error("BUILD_TEMPLATE expected tuple for interpolations")
+                })?;
+
+                let template = PyTemplate::new(strings, interpolations);
+                self.push_value(template.into_pyobject(vm));
+                Ok(None)
+            }
+            Instruction::BuildInterpolation { oparg } => {
+                // oparg encoding: (conversion << 2) | has_format_spec
+                // Stack: [value, expression_str, (format_spec)?] -> [interpolation]
+                let oparg_val = oparg.get(arg);
+                let has_format_spec = (oparg_val & 1) != 0;
+                let conversion_code = oparg_val >> 2;
+
+                let format_spec = if has_format_spec {
+                    self.pop_value().downcast::<PyStr>().map_err(|_| {
+                        vm.new_type_error("BUILD_INTERPOLATION expected str for format_spec")
+                    })?
+                } else {
+                    vm.ctx.empty_str.to_owned()
+                };
+
+                let expression = self.pop_value().downcast::<PyStr>().map_err(|_| {
+                    vm.new_type_error("BUILD_INTERPOLATION expected str for expression")
+                })?;
+                let value = self.pop_value();
+
+                // conversion: 0=None, 1=Str, 2=Repr, 3=Ascii
+                let conversion: PyObjectRef = match conversion_code {
+                    0 => vm.ctx.none(),
+                    1 => vm.ctx.new_str("s").into(),
+                    2 => vm.ctx.new_str("r").into(),
+                    3 => vm.ctx.new_str("a").into(),
+                    _ => vm.ctx.none(), // should not happen
+                };
+
+                let interpolation =
+                    PyInterpolation::new(value, expression, conversion, format_spec, vm)?;
+                self.push_value(interpolation.into_pyobject(vm));
+                Ok(None)
+            }
+            Instruction::Call { nargs } => {
+                // Stack: [callable, self_or_null, arg1, ..., argN]
+                let args = self.collect_positional_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            Instruction::CallKw { nargs } => {
+                // Stack: [callable, self_or_null, arg1, ..., argN, kwarg_names]
+                let args = self.collect_keyword_args(nargs.get(arg));
+                self.execute_call(args, vm)
+            }
+            Instruction::CallFunctionEx { has_kwargs } => {
+                // Stack: [callable, self_or_null, args_tuple, (kwargs_dict)?]
+                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
+                self.execute_call(args, vm)
+            }
+            Instruction::CallIntrinsic1 { func } => {
+                let value = self.pop_value();
+                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
+                self.push_value(result);
+                Ok(None)
+            }
+            Instruction::CallIntrinsic2 { func } => {
+                let value2 = self.pop_value();
+                let value1 = self.pop_value();
+                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
+                self.push_value(result);
+                Ok(None)
+            }
+            Instruction::CheckEgMatch => {
+                let match_type = self.pop_value();
+                let exc_value = self.pop_value();
+                let (rest, matched) =
+                    crate::exceptions::exception_group_match(&exc_value, &match_type, vm)?;
+                self.push_value(rest);
+                self.push_value(matched);
+                Ok(None)
+            }
+            Instruction::CompareOp { op } => self.execute_compare(vm, op.get(arg)),
+            Instruction::ContainsOp(invert) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+
+                let value = match invert.get(arg) {
+                    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::Continue { target } => self.unwind_blocks(
+                vm,
+                UnwindReason::Continue {
+                    target: target.get(arg),
+                },
+            ),
+
+            Instruction::ConvertValue { oparg: conversion } => {
+                self.convert_value(conversion.get(arg), vm)
+            }
+            Instruction::Copy { 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);
+                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);
+                Ok(None)
+            }
+            Instruction::DeleteFast(idx) => {
+                let mut fastlocals = self.fastlocals.lock();
+                let idx = idx.get(arg) as usize;
+                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]
+                        ),
+                    ));
+                }
+                fastlocals[idx] = None;
+                Ok(None)
+            }
+            Instruction::DeleteGlobal(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                match self.globals.del_item(name, vm) {
+                    Ok(()) => {}
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                        return Err(name_error(name, vm));
+                    }
+                    Err(e) => return Err(e),
+                }
+                Ok(None)
+            }
+            Instruction::DeleteName(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let res = self.locals.mapping().ass_subscript(name, None, vm);
+
+                match res {
+                    Ok(()) => {}
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                        return Err(name_error(name, vm));
+                    }
+                    Err(e) => return Err(e),
+                }
+                Ok(None)
+            }
+            Instruction::DeleteSubscr => self.execute_delete_subscript(vm),
+            Instruction::DictUpdate { index } => {
+                // Stack before: [..., dict, ..., source]  (source at TOS)
+                // Stack after:  [..., dict, ...]  (source consumed)
+                // The dict to update is at position TOS-i (before popping source)
+
+                let idx = index.get(arg);
+
+                // Pop the source from TOS
+                let source = self.pop_value();
+
+                // Get the dict to update (it's now at TOS-(i-1) after popping source)
+                let dict = if idx <= 1 {
+                    // DICT_UPDATE 0 or 1: dict is at TOS (after popping source)
+                    self.top_value()
+                } else {
+                    // DICT_UPDATE n: dict is at TOS-(n-1)
+                    self.nth_value(idx - 1)
+                };
+
+                let dict = dict.downcast_ref::<PyDict>().expect("exact dict expected");
+
+                // For dictionary unpacking {**x}, x must be a mapping
+                // Check if the object has the mapping protocol (keys method)
+                if vm
+                    .get_method(source.clone(), vm.ctx.intern_str("keys"))
+                    .is_none()
+                {
+                    return Err(vm.new_type_error(format!(
+                        "'{}' object is not a mapping",
+                        source.class().name()
+                    )));
+                }
+
+                dict.merge_object(source, vm)?;
+                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
+                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) {
+                    // StopAsyncIteration - normal end of async for loop
+                    vm.set_exception(None);
+                    Ok(None)
+                } else {
+                    // Other exception - re-raise
+                    Err(exc)
+                }
+            }
+            Instruction::ExtendedArg => {
+                *extend_arg = true;
+                Ok(None)
+            }
+            Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
+            Instruction::FormatSimple => {
+                let value = self.pop_value();
+                let formatted = vm.format(&value, vm.ctx.new_str(""))?;
+                self.push_value(formatted.into());
+
+                Ok(None)
+            }
+            Instruction::FormatWithSpec => {
+                let spec = self.pop_value();
+                let value = self.pop_value();
+                let formatted = vm.format(&value, spec.downcast::<PyStr>().unwrap())?;
+                self.push_value(formatted.into());
+
+                Ok(None)
+            }
+            Instruction::GetAIter => {
+                let aiterable = self.pop_value();
+                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
+                self.push_value(aiter);
+                Ok(None)
+            }
+            Instruction::GetANext => {
+                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
+                let orig_stack_len = self.state.stack.len();
+
+                let aiter = self.top_value();
+                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
+                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
+                } else {
+                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
+                        // TODO: __anext__ must be protocol
+                        let msg = format!(
+                            "'async for' requires an iterator with __anext__ method, got {:.100}",
+                            aiter.class().name()
+                        );
+                        return Err(vm.new_type_error(msg));
+                    }
+                    let next_iter =
+                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
+
+                    // _PyCoro_GetAwaitableIter in CPython
+                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
+                        let gen_is_coroutine = |_| {
+                            // TODO: cpython gen_is_coroutine
+                            true
+                        };
+                        if next_iter.class().is(vm.ctx.types.coroutine_type)
+                            || gen_is_coroutine(next_iter)
+                        {
+                            return Ok(next_iter.to_owned());
+                        }
+                        // TODO: error handling
+                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
+                    }
+                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
+                        vm.new_type_error(format!(
+                            "'async for' received an invalid object from __anext__: {:.200}",
+                            next_iter.class().name()
+                        ))
+                    })?
+                };
+                self.push_value(awaitable);
+                #[cfg(debug_assertions)]
+                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
+                Ok(None)
+            }
+            Instruction::GetAwaitable => {
+                use crate::protocol::PyIter;
+
+                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 {
+                    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()
+                        )));
+                    }
+                    result
+                };
+                self.push_value(awaitable);
+                Ok(None)
+            }
+            Instruction::GetIter => {
+                let iterated_obj = self.pop_value();
+                let iter_obj = iterated_obj.get_iter(vm)?;
+                self.push_value(iter_obj.into());
+                Ok(None)
+            }
+            Instruction::GetYieldFromIter => {
+                // GET_YIELD_FROM_ITER: prepare iterator for yield from
+                // If iterable is a coroutine, ensure we're in a coroutine context
+                // If iterable is a generator, use it directly
+                // Otherwise, call iter() on it
+                let iterable = self.pop_value();
+                let iter = if iterable.class().is(vm.ctx.types.coroutine_type) {
+                    // Coroutine requires CO_COROUTINE or CO_ITERABLE_COROUTINE flag
+                    if !self.code.flags.intersects(bytecode::CodeFlags::COROUTINE) {
+                        return Err(vm.new_type_error(
+                            "cannot 'yield from' a coroutine object in a non-coroutine generator"
+                                .to_owned(),
+                        ));
+                    }
+                    iterable
+                } else if iterable.class().is(vm.ctx.types.generator_type) {
+                    // Generator can be used directly
+                    iterable
+                } else {
+                    // Otherwise, get iterator
+                    iterable.get_iter(vm)?.into()
+                };
+                self.push_value(iter);
+                Ok(None)
+            }
+            Instruction::GetLen => {
+                // STACK.append(len(STACK[-1]))
+                let obj = self.top_value();
+                let len = obj.length(vm)?;
+                self.push_value(vm.ctx.new_int(len).into());
+                Ok(None)
+            }
+            Instruction::ImportFrom { idx } => {
+                let obj = self.import_from(vm, idx.get(arg))?;
+                self.push_value(obj);
+                Ok(None)
+            }
+            Instruction::ImportName { idx } => {
+                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
+                Ok(None)
+            }
+            Instruction::IsOp(invert) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+                let res = a.is(&b);
+
+                let value = match invert.get(arg) {
+                    bytecode::Invert::No => res,
+                    bytecode::Invert::Yes => !res,
+                };
+                self.push_value(vm.ctx.new_bool(value).into());
+                Ok(None)
+            }
+            Instruction::JumpIfFalseOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), false)
+            }
+            Instruction::JumpIfNotExcMatch(target) => {
+                let b = self.pop_value();
+                let a = self.pop_value();
+                if let Some(tuple_of_exceptions) = b.downcast_ref::<PyTuple>() {
+                    for exception in tuple_of_exceptions {
+                        if !exception
+                            .is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)?
+                        {
+                            return Err(vm.new_type_error(
+                                "catching classes that do not inherit from BaseException is not allowed",
+                            ));
+                        }
+                    }
+                } else if !b.is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)? {
+                    return Err(vm.new_type_error(
+                        "catching classes that do not inherit from BaseException is not allowed",
+                    ));
+                }
+
+                let value = a.is_instance(&b, vm)?;
+                self.push_value(vm.ctx.new_bool(value).into());
+                self.pop_jump_if(vm, target.get(arg), false)
+            }
+            Instruction::JumpIfTrueOrPop { target } => {
+                self.jump_if_or_pop(vm, target.get(arg), true)
+            }
+            Instruction::JumpForward { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            Instruction::JumpBackward { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            Instruction::JumpBackwardNoInterrupt { target } => {
+                self.jump(target.get(arg));
+                Ok(None)
+            }
+            Instruction::ListAppend { i } => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let list: &Py<PyList> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
+                };
+                list.append(item);
+                Ok(None)
+            }
+            Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
+            Instruction::LoadSuperAttr { arg: idx } => self.load_super_attr(vm, idx.get(arg)),
+            Instruction::LoadBuildClass => {
+                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
+                Ok(None)
+            }
+            Instruction::LoadFromDictOrDeref(i) => {
+                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 value = self.locals.mapping().subscript(name, vm).ok();
+                self.push_value(match value {
+                    Some(v) => v,
+                    None => self.cells_frees[i]
+                        .get()
+                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
+                });
+                Ok(None)
+            }
+            Instruction::LoadClosure(i) => {
+                let value = self.cells_frees[i.get(arg) as usize].clone();
+                self.push_value(value.into());
+                Ok(None)
+            }
+            Instruction::LoadConst { idx } => {
+                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
+                Ok(None)
+            }
+            Instruction::LoadDeref(i) => {
+                let i = i.get(arg) as usize;
+                let x = self.cells_frees[i]
+                    .get()
+                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
+                self.push_value(x);
+                Ok(None)
+            }
+            Instruction::LoadFast(idx) => {
+                #[cold]
+                fn reference_error(
+                    varname: &'static PyStrInterned,
+                    vm: &VirtualMachine,
+                ) -> PyBaseExceptionRef {
+                    vm.new_exception_msg(
+                        vm.ctx.exceptions.unbound_local_error.to_owned(),
+                        format!("local variable '{varname}' referenced before assignment",),
+                    )
+                }
+                let idx = idx.get(arg) as usize;
+                let x = self.fastlocals.lock()[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);
+                Ok(None)
+            }
+            Instruction::LoadGlobal(idx) => {
+                let name = &self.code.names[idx.get(arg) as usize];
+                let x = self.load_global_or_builtin(name, vm)?;
+                self.push_value(x);
+                Ok(None)
+            }
+            Instruction::LoadName(idx) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let result = self.locals.mapping().subscript(name, vm);
+                match result {
+                    Ok(x) => self.push_value(x),
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                        self.push_value(self.load_global_or_builtin(name, vm)?);
+                    }
+                    Err(e) => return Err(e),
+                }
+                Ok(None)
+            }
+            Instruction::MakeFunction => self.execute_make_function(vm),
+            Instruction::MapAdd { i } => {
+                let value = self.pop_value();
+                let key = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let dict: &Py<PyDict> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
+                };
+                dict.set_item(&*key, value, vm)?;
+                Ok(None)
+            }
+            Instruction::MatchClass(nargs) => {
+                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
+                // nargs is the number of positional sub-patterns.
+                let kwd_attrs = self.pop_value();
+                let kwd_attrs = kwd_attrs.downcast_ref::<PyTuple>().unwrap();
+                let cls = self.pop_value();
+                let subject = self.pop_value();
+                let nargs_val = nargs.get(arg) as usize;
+
+                // Check if subject is an instance of cls
+                if subject.is_instance(cls.as_ref(), vm)? {
+                    let mut extracted = vec![];
+
+                    // Get __match_args__ for positional arguments if nargs > 0
+                    if nargs_val > 0 {
+                        // Get __match_args__ from the class
+                        let match_args =
+                            vm.get_attribute_opt(cls.clone(), identifier!(vm, __match_args__))?;
+
+                        if let Some(match_args) = match_args {
+                            // Convert to tuple
+                            let match_args = match match_args.downcast_exact::<PyTuple>(vm) {
+                                Ok(tuple) => tuple,
+                                Err(match_args) => {
+                                    // __match_args__ must be a tuple
+                                    // 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("?"));
+                                    let match_args_type_name = match_args.class().__name__(vm);
+                                    return Err(vm.new_type_error(format!(
+                                        "{}.__match_args__ must be a tuple (got {})",
+                                        type_name, match_args_type_name
+                                    )));
+                                }
+                            };
+
+                            // Check if we have enough match args
+                            if match_args.len() < nargs_val {
+                                return Err(vm.new_type_error(format!(
+                                    "class pattern accepts at most {} positional sub-patterns ({} given)",
+                                    match_args.len(),
+                                    nargs_val
+                                )));
+                            }
+
+                            // Extract positional attributes
+                            for i in 0..nargs_val {
+                                let attr_name = &match_args[i];
+                                let attr_name_str = match attr_name.downcast_ref::<PyStr>() {
+                                    Some(s) => s,
+                                    None => {
+                                        return Err(vm.new_type_error(
+                                            "__match_args__ elements must be strings".to_string(),
+                                        ));
+                                    }
+                                };
+                                match subject.get_attr(attr_name_str, vm) {
+                                    Ok(value) => extracted.push(value),
+                                    Err(e)
+                                        if e.fast_isinstance(vm.ctx.exceptions.attribute_error) =>
+                                    {
+                                        // Missing attribute → non-match
+                                        self.push_value(vm.ctx.none());
+                                        return Ok(None);
+                                    }
+                                    Err(e) => return Err(e),
+                                }
+                            }
+                        } else {
+                            // No __match_args__, check if this is a type with MATCH_SELF behavior
+                            // For built-in types like bool, int, str, list, tuple, dict, etc.
+                            // they match the subject itself as the single positional argument
+                            let is_match_self_type = cls
+                                .downcast::<PyType>()
+                                .is_ok_and(|t| t.slots.flags.contains(PyTypeFlags::_MATCH_SELF));
+
+                            if is_match_self_type {
+                                if nargs_val == 1 {
+                                    // Match the subject itself as the single positional argument
+                                    extracted.push(subject.clone());
+                                } 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(),
+                                    ));
+                                }
+                            } 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(),
+                                    ));
+                                }
+                            }
+                        }
+                    }
+
+                    // Extract keyword attributes
+                    for name in kwd_attrs {
+                        let name_str = name.downcast_ref::<PyStr>().unwrap();
+                        match subject.get_attr(name_str, vm) {
+                            Ok(value) => extracted.push(value),
+                            Err(e) if e.fast_isinstance(vm.ctx.exceptions.attribute_error) => {
+                                self.push_value(vm.ctx.none());
+                                return Ok(None);
+                            }
+                            Err(e) => return Err(e),
+                        }
+                    }
+
+                    self.push_value(vm.ctx.new_tuple(extracted).into());
+                } else {
+                    // Not an instance, push None
+                    self.push_value(vm.ctx.none());
+                }
+                Ok(None)
+            }
+            Instruction::MatchKeys => {
+                // MATCH_KEYS doesn't pop subject and keys, only reads them
+                let keys_tuple = self.top_value(); // stack[-1]
+                let subject = self.nth_value(1); // stack[-2]
+
+                // Check if subject is a mapping and extract values for keys
+                if subject.class().slots.flags.contains(PyTypeFlags::MAPPING) {
+                    let keys = keys_tuple.downcast_ref::<PyTuple>().unwrap();
+                    let mut values = Vec::new();
+                    let mut all_match = true;
+
+                    // We use the two argument form of map.get(key, default) for two reasons:
+                    // - Atomically check for a key and get its value without error handling.
+                    // - Don't cause key creation or resizing in dict subclasses like
+                    //   collections.defaultdict that define __missing__ (or similar).
+                    // See CPython's _PyEval_MatchKeys
+
+                    if let Some(get_method) = vm
+                        .get_method(subject.to_owned(), vm.ctx.intern_str("get"))
+                        .transpose()?
+                    {
+                        let dummy = vm
+                            .ctx
+                            .new_base_object(vm.ctx.types.object_type.to_owned(), None);
+
+                        for key in keys {
+                            // value = map.get(key, dummy)
+                            match get_method.call((key.as_object(), dummy.clone()), vm) {
+                                Ok(value) => {
+                                    // if value == dummy: key not in map!
+                                    if value.is(&dummy) {
+                                        all_match = false;
+                                        break;
+                                    }
+                                    values.push(value);
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    } else {
+                        // Fallback if .get() method is not available (shouldn't happen for mappings)
+                        for key in keys {
+                            match subject.get_item(key.as_object(), vm) {
+                                Ok(value) => values.push(value),
+                                Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
+                                    all_match = false;
+                                    break;
+                                }
+                                Err(e) => return Err(e),
+                            }
+                        }
+                    }
+
+                    if all_match {
+                        // Push values tuple on successful match
+                        self.push_value(vm.ctx.new_tuple(values).into());
+                    } else {
+                        // No match - push None
+                        self.push_value(vm.ctx.none());
+                    }
+                } else {
+                    // Not a mapping - push None
+                    self.push_value(vm.ctx.none());
+                }
+                Ok(None)
+            }
+            Instruction::MatchMapping => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the MAPPING flag
+                let is_mapping = subject.class().slots.flags.contains(PyTypeFlags::MAPPING);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_mapping).into());
+                Ok(None)
+            }
+            Instruction::MatchSequence => {
+                // Pop and push back the subject to keep it on stack
+                let subject = self.pop_value();
+
+                // Check if the type has the SEQUENCE flag
+                let is_sequence = subject.class().slots.flags.contains(PyTypeFlags::SEQUENCE);
+
+                self.push_value(subject);
+                self.push_value(vm.ctx.new_bool(is_sequence).into());
+                Ok(None)
+            }
+            Instruction::Nop => Ok(None),
+            Instruction::PopExcept => {
+                // Pop prev_exc from value stack and restore it
+                let prev_exc = self.pop_value();
+                if vm.is_none(&prev_exc) {
+                    vm.set_exception(None);
+                } else if let Ok(exc) = prev_exc.downcast::<PyBaseException>() {
+                    vm.set_exception(Some(exc));
+                }
+
+                // NOTE: We do NOT clear the traceback of the exception that was just handled.
+                // Python preserves exception tracebacks even after the exception is no longer
+                // the "current exception". This is important for code that catches an exception,
+                // stores it, and later inspects its traceback.
+                // Reference cycles (Exception → Traceback → Frame → locals) are handled by
+                // Python's garbage collector which can detect and break cycles.
+
+                Ok(None)
+            }
+            Instruction::PopJumpIfFalse { target } => self.pop_jump_if(vm, target.get(arg), false),
+            Instruction::PopJumpIfTrue { target } => self.pop_jump_if(vm, target.get(arg), true),
+            Instruction::PopTop => {
+                // Pop value from stack and ignore.
+                self.pop_value();
+                Ok(None)
+            }
+            Instruction::PushNull => {
+                // Push NULL for self_or_null slot in call protocol
+                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()?;
+                // }
+                Ok(None)
+            }
+            Instruction::ReturnConst { idx } => {
+                let value = self.code.constants[idx.get(arg) as usize].clone().into();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            }
+            Instruction::ReturnValue => {
+                let value = self.pop_value();
+                self.unwind_blocks(vm, UnwindReason::Returning { value })
+            }
+            Instruction::SetAdd { i } => {
+                let item = self.pop_value();
+                let obj = self.nth_value(i.get(arg));
+                let set: &Py<PySet> = unsafe {
+                    // SAFETY: trust compiler
+                    obj.downcast_unchecked_ref()
+                };
+                set.add(item, vm)?;
+                Ok(None)
+            }
+            Instruction::SetExcInfo => {
+                // Set the current exception to TOS (for except* handlers)
+                // This updates sys.exc_info() so bare 'raise' will reraise the matched exception
+                let exc = self.top_value();
+                if let Some(exc) = exc.downcast_ref::<PyBaseException>() {
+                    vm.set_exception(Some(exc.to_owned()));
+                }
+                Ok(None)
+            }
+            Instruction::PushExcInfo => {
+                // Stack: [exc] -> [prev_exc, exc]
+                let exc = self.pop_value();
+                let prev_exc = vm
+                    .current_exception()
+                    .map(|e| e.into())
+                    .unwrap_or_else(|| vm.ctx.none());
+
+                // Set exc as the current exception
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>() {
+                    vm.set_exception(Some(exc_ref.to_owned()));
+                }
+
+                self.push_value(prev_exc);
+                self.push_value(exc);
+                Ok(None)
+            }
+            Instruction::CheckExcMatch => {
+                // Stack: [exc, type] -> [exc, bool]
+                let exc_type = self.pop_value();
+                let exc = self.top_value();
+
+                // Validate that exc_type is valid for exception matching
+                let result = exc.is_instance(&exc_type, vm)?;
+                self.push_value(vm.ctx.new_bool(result).into());
+                Ok(None)
+            }
+            Instruction::Reraise { depth } => {
+                // inst(RERAISE, (values[oparg], exc -- values[oparg]))
+                //
+                // Stack layout: [values..., exc] where len(values) == oparg
+                // RERAISE pops exc and oparg additional values from the stack.
+                // values[0] is lasti used to set frame->instr_ptr for traceback.
+                // We skip the lasti update since RustPython's traceback is already correct.
+                let depth_val = depth.get(arg) as usize;
+
+                // Pop exception from TOS
+                let exc = self.pop_value();
+
+                // Pop the depth values (lasti and possibly other items like prev_exc)
+                for _ in 0..depth_val {
+                    self.pop_value();
+                }
+
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>() {
+                    Err(exc_ref.to_owned())
+                } else {
+                    // Fallback: use current exception if TOS is not an exception
+                    let exc = vm
+                        .topmost_exception()
+                        .ok_or_else(|| vm.new_runtime_error("No active exception to re-raise"))?;
+                    Err(exc)
+                }
+            }
+            Instruction::SetFunctionAttribute { attr } => {
+                self.execute_set_function_attribute(vm, attr.get(arg))
+            }
+            Instruction::SetupAnnotations => self.setup_annotations(vm),
+            Instruction::BeforeWith => {
+                // TOS: context_manager
+                // Result: [..., __exit__, __enter__ result]
+                let context_manager = self.pop_value();
+                let error_string = || -> String {
+                    format!(
+                        "'{:.200}' object does not support the context manager protocol",
+                        context_manager.class().name(),
+                    )
+                };
+
+                // Get __exit__ first (before calling __enter__)
+                let exit = context_manager
+                    .get_attr(identifier!(vm, __exit__), vm)
+                    .map_err(|_exc| {
+                        vm.new_type_error(format!("{} (missed __exit__ method)", error_string()))
+                    })?;
+
+                // Get and call __enter__
+                let enter_res = vm
+                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
+                    .ok_or_else(|| vm.new_type_error(error_string()))?
+                    .invoke((), vm)?;
+
+                // Push __exit__ first, then enter result
+                self.push_value(exit);
+                self.push_value(enter_res);
+                Ok(None)
+            }
+            Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
+            Instruction::StoreDeref(i) => {
+                let value = self.pop_value();
+                self.cells_frees[i.get(arg) as usize].set(Some(value));
+                Ok(None)
+            }
+            Instruction::StoreFast(idx) => {
+                let value = self.pop_value();
+                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
+                Ok(None)
+            }
+            Instruction::StoreFastLoadFast {
+                store_idx,
+                load_idx,
+            } => {
+                // Store to one slot and load from another (often the same) - for inlined comprehensions
+                let value = self.pop_value();
+                let mut locals = self.fastlocals.lock();
+                locals[store_idx.get(arg) as usize] = Some(value);
+                let load_value = locals[load_idx.get(arg) as usize]
+                    .clone()
+                    .expect("StoreFastLoadFast: load slot should have value after store");
+                drop(locals);
+                self.push_value(load_value);
+                Ok(None)
+            }
+            Instruction::StoreGlobal(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) => {
+                let name = self.code.names[idx.get(arg) as usize];
+                let value = self.pop_value();
+                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
+                Ok(None)
+            }
+            Instruction::StoreSubscr => self.execute_store_subscript(vm),
+            Instruction::Subscript => self.execute_subscript(vm),
+            Instruction::Swap { index } => {
+                let len = self.state.stack.len();
+                debug_assert!(len > 0, "stack underflow in SWAP");
+                let i = len - 1; // TOS index
+                let index_val = index.get(arg) as usize;
+                // CPython: SWAP(n) swaps TOS with PEEK(n) where PEEK(n) = stack_pointer[-n]
+                // This means swap TOS with the element at index (len - n)
+                debug_assert!(
+                    index_val <= len,
+                    "SWAP index {} exceeds stack size {}",
+                    index_val,
+                    len
+                );
+                let j = len - index_val;
+                self.state.stack.swap(i, j);
+                Ok(None)
+            }
+            Instruction::ToBool => {
+                let obj = self.pop_value();
+                let bool_val = obj.try_to_bool(vm)?;
+                self.push_value(vm.ctx.new_bool(bool_val).into());
+                Ok(None)
+            }
+            Instruction::UnpackEx { 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::WithExceptStart => {
+                // Stack: [..., __exit__, lasti, prev_exc, exc]
+                // Call __exit__(type, value, tb) and push result
+                // __exit__ is at TOS-3 (below lasti, prev_exc, and exc)
+                let exc = vm.current_exception();
+
+                let stack_len = self.state.stack.len();
+                let exit = expect_unchecked(
+                    self.state.stack[stack_len - 4].clone(),
+                    "WithExceptStart: __exit__ is NULL",
+                );
+
+                let args = if let Some(ref exc) = exc {
+                    vm.split_exception(exc.clone())
+                } else {
+                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
+                };
+                let exit_res = exit.call(args, vm)?;
+                // Push result on top of stack
+                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)
+                } else {
+                    value
+                };
+                Ok(Some(ExecutionResult::Yield(value)))
+            }
+            Instruction::Send { target } => {
+                // Stack: (receiver, value) -> (receiver, retval)
+                // On StopIteration: replace value with stop value and jump to target
+                let exit_label = target.get(arg);
+                let val = self.pop_value();
+                let receiver = self.top_value();
+
+                match self._send(receiver, val, vm)? {
+                    PyIterReturn::Return(value) => {
+                        // Value yielded, push it back for YIELD_VALUE
+                        // Stack: (receiver, retval)
+                        self.push_value(value);
+                        Ok(None)
+                    }
+                    PyIterReturn::StopIteration(value) => {
+                        // StopIteration: replace top with stop value, jump to exit
+                        // Stack: (receiver, value) - receiver stays, v replaced
+                        let value = vm.unwrap_or_none(value);
+                        self.push_value(value);
+                        self.jump(exit_label);
+                        Ok(None)
+                    }
+                }
+            }
+            Instruction::EndSend => {
+                // Stack: (receiver, value) -> (value)
+                // Pops receiver, leaves value
+                let value = self.pop_value();
+                self.pop_value(); // discard receiver
+                self.push_value(value);
+                Ok(None)
+            }
+            Instruction::CleanupThrow => {
+                // CLEANUP_THROW: (sub_iter, last_sent_val, exc) -> (None, value) OR re-raise
+                // If StopIteration: pop all 3, extract value, push (None, value)
+                // Otherwise: pop all 3, return Err(exc) for unwind_blocks to handle
+                //
+                // Unlike CPython where exception_unwind pops the triple as part of
+                // stack cleanup to handler depth, RustPython pops here explicitly
+                // and lets unwind_blocks find outer handlers.
+                // Compiler sets handler_depth = base + 2 (before exc is pushed).
+
+                // First peek at exc_value (top of stack) without popping
+                let exc = self.top_value();
+
+                // Check if it's a StopIteration
+                if let Some(exc_ref) = exc.downcast_ref::<PyBaseException>()
+                    && exc_ref.fast_isinstance(vm.ctx.exceptions.stop_iteration)
+                {
+                    // Extract value from StopIteration
+                    let value = exc_ref.get_arg(0).unwrap_or_else(|| vm.ctx.none());
+                    // Now pop all three
+                    self.pop_value(); // exc
+                    self.pop_value(); // last_sent_val
+                    self.pop_value(); // sub_iter
+                    self.push_value(vm.ctx.none());
+                    self.push_value(value);
+                    return Ok(None);
+                }
+
+                // Re-raise other exceptions: pop all three and return Err(exc)
+                let exc = self.pop_value(); // exc
+                self.pop_value(); // last_sent_val
+                self.pop_value(); // sub_iter
+
+                let exc = exc
+                    .downcast::<PyBaseException>()
+                    .map_err(|_| vm.new_type_error("exception expected".to_owned()))?;
+                Err(exc)
+            }
+            Instruction::UnaryInvert => {
+                let a = self.pop_value();
+                let value = vm._invert(&a)?;
+                self.push_value(value);
+                Ok(None)
+            }
+            Instruction::UnaryNegative => {
+                let a = self.pop_value();
+                let value = vm._neg(&a)?;
+                self.push_value(value);
+                Ok(None)
+            }
+            Instruction::UnaryNot => {
+                let obj = self.pop_value();
+                let value = obj.try_to_bool(vm)?;
+                self.push_value(vm.ctx.new_bool(!value).into());
+                Ok(None)
+            }
+            _ => {
+                unreachable!("{instruction:?} instruction should not be executed")
+            }
+        }
+    }
+
+    #[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())
+            })
+    }
+
+    unsafe fn flatten_tuples(&mut self, size: usize) -> Vec<PyObjectRef> {
+        let mut elements = Vec::new();
+        for tup in self.pop_multiple(size) {
+            // SAFETY: caller ensures that the elements are tuples
+            let tup = unsafe { tup.downcast_unchecked::<PyTuple>() };
+            elements.extend(tup.iter().cloned());
+        }
+        elements
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn import(&mut self, vm: &VirtualMachine, module_name: Option<&Py<PyStr>>) -> PyResult<()> {
+        let module_name = module_name.unwrap_or(vm.ctx.empty_str);
+        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);
+        }
+
+        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());
+
+            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()))
+        }
+    }
+
+    #[cfg_attr(feature = "flame-it", flame("Frame"))]
+    fn import_star(&mut self, vm: &VirtualMachine) -> PyResult<()> {
+        let module = self.pop_value();
+
+        // 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)?;
+                }
+            }
+        }
+        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 (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();
+                    }
+
+                    // 2. If push_lasti=true (SETUP_CLEANUP), push lasti before exception
+                    // pushes lasti as PyLong
+                    if entry.push_lasti {
+                        self.push_value(vm.ctx.new_int(offset as i32).into());
+                    }
+
+                    // 3. Push exception onto stack
+                    // always push exception, PUSH_EXC_INFO transforms [exc] -> [prev_exc, exc]
+                    // Note: Do NOT call vm.set_exception here! PUSH_EXC_INFO will do it.
+                    // PUSH_EXC_INFO needs to get prev_exc from vm.current_exception() BEFORE setting the new one.
+                    self.push_value(exception.into());
+
+                    // 4. Jump to handler
+                    self.jump(bytecode::Label(entry.target));
+
+                    Ok(None)
+                } else {
+                    // No handler found, propagate exception
+                    Err(exception)
+                }
+            }
+            UnwindReason::Returning { value } => {
+                // Clear tracebacks of exceptions in fastlocals to break reference cycles.
+                // This is needed because when returning from inside an except block,
+                // the exception cleanup code (e = None; del e) is skipped, leaving the
+                // exception with a traceback that references this frame, which references
+                // the exception in fastlocals, creating a cycle that can't be collected
+                // since RustPython doesn't have a tracing GC.
+                //
+                // We only clear tracebacks of exceptions that:
+                // 1. Are not the return value itself (will be needed by caller)
+                // 2. Are not the current active exception (still being handled)
+                // 3. Have a traceback whose top frame is THIS frame (we created it)
+                let current_exc = vm.current_exception();
+                let fastlocals = self.fastlocals.lock();
+                for obj in fastlocals.iter().flatten() {
+                    // Skip if this object is the return value
+                    if obj.is(&value) {
+                        continue;
+                    }
+                    if let Ok(exc) = obj.clone().downcast::<PyBaseException>() {
+                        // Skip if this is the current active exception
+                        if current_exc.as_ref().is_some_and(|cur| exc.is(cur)) {
+                            continue;
+                        }
+                        // Only clear if traceback's top frame is this frame
+                        if exc
+                            .__traceback__()
+                            .is_some_and(|tb| core::ptr::eq::<Py<Frame>>(&*tb.frame, self.object))
+                        {
+                            exc.set_traceback_typed(None);
+                        }
+                    }
+                }
+                drop(fastlocals);
+                Ok(Some(ExecutionResult::Return(value)))
+            }
+            UnwindReason::Break { target } | UnwindReason::Continue { target } => {
+                // Break/continue: jump to the target label
+                self.jump(target);
+                Ok(None)
+            }
+        }
+    }
+
+    fn execute_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
+        let b_ref = self.pop_value();
+        let a_ref = self.pop_value();
+        let value = a_ref.get_item(&*b_ref, vm)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    fn execute_store_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
+        let idx = self.pop_value();
+        let obj = self.pop_value();
+        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_map_for_call(&mut self, vm: &VirtualMachine, size: u32) -> FrameResult {
+        let size = size as usize;
+        let map_obj = vm.ctx.new_dict();
+        for obj in self.pop_multiple(size) {
+            // Use keys() method for all mapping objects to preserve order
+            Self::iterate_mapping_keys(vm, &obj, "keyword argument", |key| {
+                // Check for keyword argument restrictions
+                if key.downcast_ref::<PyStr>().is_none() {
+                    return Err(vm.new_type_error("keywords must be strings"));
+                }
+                if map_obj.contains_key(&*key, vm) {
+                    let key_repr = &key.repr(vm)?;
+                    let msg = format!(
+                        "got multiple values for keyword argument {}",
+                        key_repr.as_str()
+                    );
+                    return Err(vm.new_type_error(msg));
+                }
+
+                let value = obj.get_item(&*key, vm)?;
+                map_obj.set_item(&*key, value, vm)?;
+                Ok(())
+            })?;
+        }
+
+        self.push_value(map_obj.into());
+        Ok(None)
+    }
+
+    fn execute_build_slice(
+        &mut self,
+        vm: &VirtualMachine,
+        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::<PyStr>().unwrap().as_str().to_owned());
+        FuncArgs::with_kwargs_names(args, kwarg_names)
+    }
+
+    fn collect_ex_args(&mut self, vm: &VirtualMachine, has_kwargs: bool) -> PyResult<FuncArgs> {
+        let kwargs = if has_kwargs {
+            let kw_obj = self.pop_value();
+            let mut kwargs = IndexMap::new();
+
+            // 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
+        } else {
+            IndexMap::new()
+        };
+        // SAFETY: trust compiler
+        let args = unsafe { self.pop_value().downcast_unchecked::<PyTuple>() }
+            .as_slice()
+            .to_vec();
+        Ok(FuncArgs { args, kwargs })
+    }
+
+    /// 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,
+        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)?;
+        }
+        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();
+
+        // If self_or_null is Some (not NULL), prepend it to args
+        let final_args = if let Some(self_val) = self_or_null {
+            // Method call: prepend self to args
+            let mut all_args = vec![self_val];
+            all_args.extend(args.args);
+            FuncArgs {
+                args: all_args,
+                kwargs: args.kwargs,
+            }
+        } else {
+            // 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
+                    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".to_owned())
+                })?
+            }
+            bytecode::RaiseKind::ReraiseFromStack => {
+                // RERAISE: gets exception from stack top
+                // Used in cleanup blocks where exception is on stack after COPY 3
+                let exc = self.pop_value();
+                exc.downcast::<PyBaseException>().map_err(|obj| {
+                    vm.new_type_error(format!(
+                        "exceptions must derive from BaseException, not {}",
+                        obj.class().name()
+                    ))
+                })?
+            }
+        };
+        #[cfg(debug_assertions)]
+        debug!("Exception raised: {exception:?} with cause: {cause:?}");
+        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),
+            // 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)
+            }
+        }
+    }
+
+    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());
+
+        // Lastly the first reversed values:
+        self.state
+            .stack
+            .extend(elements.into_iter().rev().map(Some));
+
+        Ok(None)
+    }
+
+    #[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);
+    }
+
+    #[inline]
+    fn pop_jump_if(
+        &mut self,
+        vm: &VirtualMachine,
+        target: bytecode::Label,
+        flag: bool,
+    ) -> FrameResult {
+        let obj = self.pop_value();
+        let value = obj.try_to_bool(vm)?;
+        if value == flag {
+            self.jump(target);
+        }
+        Ok(None)
+    }
+
+    #[inline]
+    fn jump_if_or_pop(
+        &mut self,
+        vm: &VirtualMachine,
+        target: bytecode::Label,
+        flag: bool,
+    ) -> FrameResult {
+        let obj = self.top_value();
+        let value = obj.to_owned().try_to_bool(vm)?;
+        if value == flag {
+            self.jump(target);
+        } else {
+            self.pop_value();
+        }
+        Ok(None)
+    }
+
+    /// The top of stack contains the iterator, lets push it forward
+    fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
+        let top_of_stack = PyIter::new(self.top_value());
+        let next_obj = top_of_stack.next(vm);
+
+        // Check the next object:
+        match next_obj {
+            Ok(PyIterReturn::Return(value)) => {
+                self.push_value(value);
+                Ok(None)
+            }
+            Ok(PyIterReturn::StopIteration(_)) => {
+                // Pop iterator from stack:
+                self.pop_value();
+
+                // End of for loop
+                self.jump(target);
+                Ok(None)
+            }
+            Err(next_error) => {
+                // Pop iterator from stack:
+                self.pop_value();
+                Err(next_error)
+            }
+        }
+    }
+    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::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
+
+        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::<PyFunction>()
+            .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 {
+            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),
+        }?;
+
+        self.push_value(value);
+        Ok(None)
+    }
+
+    #[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)?
+            }
+        };
+        if !has_annotations {
+            self.locals
+                .as_object()
+                .set_item(__annotations__, vm.ctx.new_dict().into(), vm)?;
+        }
+        Ok(None)
+    }
+
+    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
+            }
+        })?;
+        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()
+            ),
+        };
+        Err(vm.new_value_error(msg))
+    }
+
+    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 => vm.ctx.new_str(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 value = a.rich_compare(b, op.into(), vm)?;
+        self.push_value(value);
+        Ok(None)
+    }
+
+    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();
+
+        if is_method {
+            // Method call: push [method, self_or_null]
+            let method = PyMethod::get(parent.clone(), attr_name, vm)?;
+            match method {
+                PyMethod::Function { target: _, func } => {
+                    self.push_value(func);
+                    self.push_value(parent);
+                }
+                PyMethod::Attribute(val) => {
+                    self.push_value(val);
+                    self.push_null();
+                }
+            }
+        } else {
+            // Regular attribute access
+            let obj = parent.get_attr(attr_name, vm)?;
+            self.push_value(obj);
+        }
+        Ok(None)
+    }
+
+    fn load_super_attr(&mut self, vm: &VirtualMachine, oparg: u32) -> FrameResult {
+        let (name_idx, load_method, has_class) = bytecode::decode_load_super_attr_arg(oparg);
+        let attr_name = self.code.names[name_idx as usize];
+
+        // Stack layout (bottom to top): [super, class, self]
+        // Pop in LIFO order: self, class, super
+        let self_obj = self.pop_value();
+        let class = self.pop_value();
+        let global_super = self.pop_value();
+
+        // Create super object - pass args based on has_class flag
+        // When super is shadowed, has_class=false means call with 0 args
+        let super_obj = if has_class {
+            global_super.call((class.clone(), self_obj.clone()), vm)?
+        } else {
+            global_super.call((), vm)?
+        };
+
+        if load_method {
+            // Method load: push [method, self_or_null]
+            let method = PyMethod::get(super_obj, attr_name, vm)?;
+            match method {
+                PyMethod::Function { target: _, func } => {
+                    self.push_value(func);
+                    self.push_value(self_obj);
+                }
+                PyMethod::Attribute(val) => {
+                    self.push_value(val);
+                    self.push_null();
+                }
+            }
+        } else {
+            // Regular attribute access
+            let obj = super_obj.get_attr(attr_name, vm)?;
+            self.push_value(obj);
+        }
+        Ok(None)
+    }
+
+    fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
+        let attr_name = self.code.names[attr as usize];
+        let parent = self.pop_value();
+        let value = self.pop_value();
+        parent.set_attr(attr_name, value, vm)?;
+        Ok(None)
+    }
+
+    fn delete_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
+        let attr_name = self.code.names[attr as usize];
+        let parent = self.pop_value();
+        parent.del_attr(attr_name, vm)?;
+        Ok(None)
+    }
+
+    // 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) {
+            Ok(()) => {}
+            Err(_e) => self.fatal("tried to push value onto stack but overflowed max_stackdepth"),
+        }
+    }
+
+    #[inline]
+    #[track_caller]
+    fn push_value(&mut self, obj: PyObjectRef) {
+        self.push_value_opt(Some(obj));
+    }
+
+    #[inline]
+    fn push_null(&mut self) {
+        self.push_value_opt(None);
+    }
+
+    /// Pop a value from the stack, returning None if the stack slot is NULL
+    #[inline]
+    fn pop_value_opt(&mut self) -> Option<PyObjectRef> {
+        match self.state.stack.pop() {
+            Some(slot) => slot, // slot is Option<PyObjectRef>
+            None => self.fatal("tried to pop from empty stack"),
+        }
+    }
+
+    #[inline]
+    #[track_caller]
+    fn pop_value(&mut self) -> PyObjectRef {
+        expect_unchecked(
+            self.pop_value_opt(),
+            "pop value but null found. This is a compiler bug.",
+        )
+    }
+
+    fn call_intrinsic_1(
+        &mut self,
+        func: bytecode::IntrinsicFunction1,
+        arg: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match func {
+            bytecode::IntrinsicFunction1::Print => {
+                let displayhook = vm
+                    .sys_module
+                    .get_attr("displayhook", vm)
+                    .map_err(|_| vm.new_runtime_error("lost sys.displayhook"))?;
+                displayhook.call((arg,), vm)
+            }
+            bytecode::IntrinsicFunction1::ImportStar => {
+                // arg is the module object
+                self.push_value(arg); // Push module back on stack for import_star
+                self.import_star(vm)?;
+                Ok(vm.ctx.none())
+            }
+            bytecode::IntrinsicFunction1::UnaryPositive => vm._pos(&arg),
+            bytecode::IntrinsicFunction1::SubscriptGeneric => {
+                // Used for PEP 695: Generic[*type_params]
+                crate::builtins::genericalias::subscript_generic(arg, vm)
+            }
+            bytecode::IntrinsicFunction1::TypeVar => {
+                let type_var: PyObjectRef =
+                    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)
+                    .into_ref(&vm.ctx)
+                    .into();
+                Ok(param_spec)
+            }
+            bytecode::IntrinsicFunction1::TypeVarTuple => {
+                let type_var_tuple: PyObjectRef = typing::TypeVarTuple::new(arg.clone(), vm)
+                    .into_ref(&vm.ctx)
+                    .into();
+                Ok(type_var_tuple)
+            }
+            bytecode::IntrinsicFunction1::TypeAlias => {
+                // TypeAlias receives a tuple of (name, type_params, value)
+                let tuple: PyTupleRef = arg
+                    .downcast()
+                    .map_err(|_| vm.new_type_error("TypeAlias expects a tuple argument"))?;
+
+                if tuple.len() != 3 {
+                    return Err(vm.new_type_error(format!(
+                        "TypeAlias expects exactly 3 arguments, got {}",
+                        tuple.len()
+                    )));
+                }
+
+                let name = tuple.as_slice()[0].clone();
+                let type_params_obj = tuple.as_slice()[1].clone();
+                let value = tuple.as_slice()[2].clone();
+
+                let type_params: PyTupleRef = if vm.is_none(&type_params_obj) {
+                    vm.ctx.empty_tuple.clone()
+                } else {
+                    type_params_obj
+                        .downcast()
+                        .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);
+                Ok(type_alias.into_ref(&vm.ctx).into())
+            }
+            bytecode::IntrinsicFunction1::ListToTuple => {
+                // Convert list to tuple
+                let list = arg
+                    .downcast::<PyList>()
+                    .map_err(|_| vm.new_type_error("LIST_TO_TUPLE expects a list"))?;
+                Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()).into())
+            }
+        }
+    }
+
+    fn call_intrinsic_2(
+        &mut self,
+        func: bytecode::IntrinsicFunction2,
+        arg1: PyObjectRef,
+        arg2: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match func {
+            bytecode::IntrinsicFunction2::SetTypeparamDefault => {
+                crate::stdlib::typing::set_typeparam_default(arg1, arg2, vm)
+            }
+            bytecode::IntrinsicFunction2::SetFunctionTypeParams => {
+                // arg1 is the function, arg2 is the type params tuple
+                // Set __type_params__ attribute on the function
+                arg1.set_attr("__type_params__", arg2, vm)?;
+                Ok(arg1)
+            }
+            bytecode::IntrinsicFunction2::TypeVarWithBound => {
+                let type_var: PyObjectRef =
+                    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)
+                        .into_ref(&vm.ctx)
+                        .into();
+                Ok(type_var)
+            }
+            bytecode::IntrinsicFunction2::PrepReraiseStar => {
+                // arg1 = orig (original exception)
+                // arg2 = excs (list of exceptions raised/reraised in except* blocks)
+                // Returns: exception to reraise, or None if nothing to reraise
+                crate::exceptions::prep_reraise_star(arg1, arg2, vm)
+            }
+        }
+    }
+
+    /// Pop multiple values from the stack. Panics if any slot is NULL.
+    fn pop_multiple(&mut self, count: usize) -> impl ExactSizeIterator<Item = PyObjectRef> + '_ {
+        let stack_len = self.state.stack.len();
+        if count > stack_len {
+            let instr = self.code.instructions.get(self.lasti() as usize);
+            let op_name = instr
+                .map(|i| format!("{:?}", i.op))
+                .unwrap_or_else(|| "None".to_string());
+            panic!(
+                "Stack underflow in pop_multiple: trying to pop {} elements from stack with {} elements. lasti={}, code={}, op={}, source_path={}",
+                count,
+                stack_len,
+                self.lasti(),
+                self.code.obj_name,
+                op_name,
+                self.code.source_path
+            );
+        }
+        self.state.stack.drain(stack_len - count..).map(|obj| {
+            expect_unchecked(obj, "pop_multiple but null found. This is a compiler bug.")
+        })
+    }
+
+    #[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
+    }
+
+    #[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"),
+        }
+    }
+
+    #[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() },
+        }
+    }
+
+    #[cold]
+    #[inline(never)]
+    #[track_caller]
+    fn fatal(&self, msg: &'static str) -> ! {
+        dbg!(self);
+        panic!("{msg}")
+    }
+}
+
+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
+        });
+        // TODO: fix this up
+        let locals = self.locals.clone();
+        write!(
+            f,
+            "Frame Object {{ \n Stack:{}\n Locals:{:?}\n}}",
+            stack_str,
+            locals.into_object()
+        )
+    }
+}
+
+fn is_module_initializing(module: &PyObject, vm: &VirtualMachine) -> bool {
+    let Ok(spec) = module.get_attr(&vm.ctx.new_str("__spec__"), vm) else {
+        return false;
+    };
+    if vm.is_none(&spec) {
+        return false;
+    }
+    let Ok(initializing_attr) = spec.get_attr(&vm.ctx.new_str("_initializing"), vm) else {
+        return false;
+    };
+    initializing_attr.try_to_bool(vm).unwrap_or(false)
+}
+
+fn expect_unchecked(optional: Option<PyObjectRef>, err_msg: &'static str) -> PyObjectRef {
+    if cfg!(debug_assertions) {
+        optional.expect(err_msg)
+    } else {
+        unsafe { optional.unwrap_unchecked() }
+    }
+}
diff --git a/crates/vm/src/function/argument.rs b/crates/vm/src/function/argument.rs
new file mode 100644
index 0000000000..a4877cf404
--- /dev/null
+++ b/crates/vm/src/function/argument.rs
@@ -0,0 +1,595 @@
+use crate::{
+    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::{PyBaseExceptionRef, PyTupleRef, PyTypeRef},
+    convert::ToPyObject,
+    object::{Traverse, TraverseFn},
+};
+use core::ops::RangeInclusive;
+use indexmap::IndexMap;
+use itertools::Itertools;
+
+pub trait IntoFuncArgs: Sized {
+    fn into_args(self, vm: &VirtualMachine) -> FuncArgs;
+    fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
+        let mut args = self.into_args(vm);
+        args.prepend_arg(obj);
+        args
+    }
+}
+
+impl<T> IntoFuncArgs for T
+where
+    T: Into<FuncArgs>,
+{
+    fn into_args(self, _vm: &VirtualMachine) -> FuncArgs {
+        self.into()
+    }
+}
+
+// A tuple of values that each implement `ToPyObject` represents a sequence of
+// arguments that can be bound and passed to a built-in function.
+macro_rules! into_func_args_from_tuple {
+    ($(($n:tt, $T:ident)),*) => {
+        impl<$($T,)*> IntoFuncArgs for ($($T,)*)
+        where
+            $($T: ToPyObject,)*
+        {
+            #[inline]
+            fn into_args(self, vm: &VirtualMachine) -> FuncArgs {
+                let ($($n,)*) = self;
+                PosArgs::new(vec![$($n.to_pyobject(vm),)*]).into()
+            }
+
+            #[inline]
+            fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
+                let ($($n,)*) = self;
+                PosArgs::new(vec![obj, $($n.to_pyobject(vm),)*]).into()
+            }
+        }
+    };
+}
+
+into_func_args_from_tuple!((v1, T1));
+into_func_args_from_tuple!((v1, T1), (v2, T2));
+into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3));
+into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4));
+into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4), (v5, T5));
+into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4), (v5, T5), (v6, T6));
+// We currently allows only 6 unnamed positional arguments.
+// Please use `#[derive(FromArgs)]` and a struct for more complex argument parsing.
+// The number of limitation came from:
+// https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
+
+/// The `FuncArgs` struct is one of the most used structs then creating
+/// a rust function that can be called from python. It holds both positional
+/// arguments, as well as keyword arguments passed to the function.
+#[derive(Debug, Default, Clone, Traverse)]
+pub struct FuncArgs {
+    pub args: Vec<PyObjectRef>,
+    // sorted map, according to https://www.python.org/dev/peps/pep-0468/
+    pub kwargs: IndexMap<String, PyObjectRef>,
+}
+
+unsafe impl Traverse for IndexMap<String, PyObjectRef> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.values().for_each(|v| v.traverse(tracer_fn));
+    }
+}
+
+/// Conversion from vector of python objects to function arguments.
+impl<A> From<A> for FuncArgs
+where
+    A: Into<PosArgs>,
+{
+    fn from(args: A) -> Self {
+        Self {
+            args: args.into().into_vec(),
+            kwargs: IndexMap::new(),
+        }
+    }
+}
+
+impl From<KwArgs> for FuncArgs {
+    fn from(kwargs: KwArgs) -> Self {
+        Self {
+            args: Vec::new(),
+            kwargs: kwargs.0,
+        }
+    }
+}
+
+impl FromArgs for FuncArgs {
+    fn from_args(_vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        Ok(core::mem::take(args))
+    }
+}
+
+impl FuncArgs {
+    pub fn new<A, K>(args: A, kwargs: K) -> Self
+    where
+        A: Into<PosArgs>,
+        K: Into<KwArgs>,
+    {
+        let PosArgs(args) = args.into();
+        let KwArgs(kwargs) = kwargs.into();
+        Self { args, kwargs }
+    }
+
+    pub fn with_kwargs_names<A, KW>(mut args: A, kwarg_names: KW) -> Self
+    where
+        A: ExactSizeIterator<Item = PyObjectRef>,
+        KW: ExactSizeIterator<Item = String>,
+    {
+        // last `kwarg_names.len()` elements of args in order of appearance in the call signature
+        let total_argc = args.len();
+        let kwarg_count = kwarg_names.len();
+        let pos_arg_count = total_argc - kwarg_count;
+
+        let pos_args = args.by_ref().take(pos_arg_count).collect();
+
+        let kwargs = kwarg_names.zip_eq(args).collect::<IndexMap<_, _>>();
+
+        Self {
+            args: pos_args,
+            kwargs,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.args.is_empty() && self.kwargs.is_empty()
+    }
+
+    pub fn prepend_arg(&mut self, item: PyObjectRef) {
+        self.args.reserve_exact(1);
+        self.args.insert(0, item)
+    }
+
+    pub fn shift(&mut self) -> PyObjectRef {
+        self.args.remove(0)
+    }
+
+    pub fn get_kwarg(&self, key: &str, default: PyObjectRef) -> PyObjectRef {
+        self.kwargs
+            .get(key)
+            .cloned()
+            .unwrap_or_else(|| default.clone())
+    }
+
+    pub fn get_optional_kwarg(&self, key: &str) -> Option<PyObjectRef> {
+        self.kwargs.get(key).cloned()
+    }
+
+    pub fn get_optional_kwarg_with_type(
+        &self,
+        key: &str,
+        ty: PyTypeRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        match self.get_optional_kwarg(key) {
+            Some(kwarg) => {
+                if kwarg.fast_isinstance(&ty) {
+                    Ok(Some(kwarg))
+                } else {
+                    let expected_ty_name = &ty.name();
+                    let kwarg_class = kwarg.class();
+                    let actual_ty_name = &kwarg_class.name();
+                    Err(vm.new_type_error(format!(
+                        "argument of type {expected_ty_name} is required for named parameter `{key}` (got: {actual_ty_name})"
+                    )))
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
+    pub fn take_positional(&mut self) -> Option<PyObjectRef> {
+        if self.args.is_empty() {
+            None
+        } else {
+            Some(self.args.remove(0))
+        }
+    }
+
+    pub fn take_positional_keyword(&mut self, name: &str) -> Option<PyObjectRef> {
+        self.take_positional().or_else(|| self.take_keyword(name))
+    }
+
+    pub fn take_keyword(&mut self, name: &str) -> Option<PyObjectRef> {
+        self.kwargs.swap_remove(name)
+    }
+
+    pub fn remaining_keywords(&mut self) -> impl Iterator<Item = (String, PyObjectRef)> + '_ {
+        self.kwargs.drain(..)
+    }
+
+    /// Binds these arguments to their respective values.
+    ///
+    /// If there is an insufficient number of arguments, there are leftover
+    /// arguments after performing the binding, or if an argument is not of
+    /// the expected type, a TypeError is raised.
+    ///
+    /// If the given `FromArgs` includes any conversions, exceptions raised
+    /// during the conversion will halt the binding and return the error.
+    pub fn bind<T: FromArgs>(mut self, vm: &VirtualMachine) -> PyResult<T> {
+        let given_args = self.args.len();
+        let bound = T::from_args(vm, &mut self)
+            .map_err(|e| e.into_exception(T::arity(), given_args, vm))?;
+
+        if !self.args.is_empty() {
+            Err(vm.new_type_error(format!(
+                "expected at most {} arguments, got {}",
+                T::arity().end(),
+                given_args,
+            )))
+        } else if let Some(err) = self.check_kwargs_empty(vm) {
+            Err(err)
+        } else {
+            Ok(bound)
+        }
+    }
+
+    pub fn check_kwargs_empty(&self, vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
+        self.kwargs
+            .keys()
+            .next()
+            .map(|k| vm.new_type_error(format!("Unexpected keyword argument {k}")))
+    }
+}
+
+/// An error encountered while binding arguments to the parameters of a Python
+/// function call.
+pub enum ArgumentError {
+    /// The call provided fewer positional arguments than the function requires.
+    TooFewArgs,
+    /// The call provided more positional arguments than the function accepts.
+    TooManyArgs,
+    /// The function doesn't accept a keyword argument with the given name.
+    InvalidKeywordArgument(String),
+    /// The function require a keyword argument with the given name, but one wasn't provided
+    RequiredKeywordArgument(String),
+    /// An exception was raised while binding arguments to the function
+    /// parameters.
+    Exception(PyBaseExceptionRef),
+}
+
+impl From<PyBaseExceptionRef> for ArgumentError {
+    fn from(ex: PyBaseExceptionRef) -> Self {
+        Self::Exception(ex)
+    }
+}
+
+impl ArgumentError {
+    fn into_exception(
+        self,
+        arity: RangeInclusive<usize>,
+        num_given: usize,
+        vm: &VirtualMachine,
+    ) -> PyBaseExceptionRef {
+        match self {
+            Self::TooFewArgs => vm.new_type_error(format!(
+                "expected at least {} arguments, got {}",
+                arity.start(),
+                num_given
+            )),
+            Self::TooManyArgs => vm.new_type_error(format!(
+                "expected at most {} arguments, got {}",
+                arity.end(),
+                num_given
+            )),
+            Self::InvalidKeywordArgument(name) => {
+                vm.new_type_error(format!("{name} is an invalid keyword argument"))
+            }
+            Self::RequiredKeywordArgument(name) => {
+                vm.new_type_error(format!("Required keyword only argument {name}"))
+            }
+            Self::Exception(ex) => ex,
+        }
+    }
+}
+
+/// Implemented by any type that can be accepted as a parameter to a built-in
+/// function.
+///
+pub trait FromArgs: Sized {
+    /// The range of positional arguments permitted by the function signature.
+    ///
+    /// Returns an empty range if not applicable.
+    fn arity() -> RangeInclusive<usize> {
+        0..=0
+    }
+
+    /// Extracts this item from the next argument(s).
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError>;
+}
+
+pub trait FromArgOptional {
+    type Inner: TryFromObject;
+    fn from_inner(x: Self::Inner) -> Self;
+}
+
+impl<T: TryFromObject> FromArgOptional for OptionalArg<T> {
+    type Inner = T;
+    fn from_inner(x: T) -> Self {
+        Self::Present(x)
+    }
+}
+
+impl<T: TryFromObject> FromArgOptional for T {
+    type Inner = Self;
+    fn from_inner(x: Self) -> Self {
+        x
+    }
+}
+
+/// A map of keyword arguments to their values.
+///
+/// A built-in function with a `KwArgs` parameter is analogous to a Python
+/// function with `**kwargs`. All remaining keyword arguments are extracted
+/// (and hence the function will permit an arbitrary number of them).
+///
+/// `KwArgs` optionally accepts a generic type parameter to allow type checks
+/// or conversions of each argument.
+///
+/// Note:
+///
+/// KwArgs is only for functions that accept arbitrary keyword arguments. For
+/// functions that accept only *specific* named arguments, a rust struct with
+/// an appropriate FromArgs implementation must be created.
+#[derive(Clone)]
+pub struct KwArgs<T = PyObjectRef>(IndexMap<String, T>);
+
+unsafe impl<T> Traverse for KwArgs<T>
+where
+    T: Traverse,
+{
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.0.iter().map(|(_, v)| v.traverse(tracer_fn)).count();
+    }
+}
+
+impl<T> KwArgs<T> {
+    pub const fn new(map: IndexMap<String, T>) -> Self {
+        Self(map)
+    }
+
+    pub fn pop_kwarg(&mut self, name: &str) -> Option<T> {
+        self.0.swap_remove(name)
+    }
+
+    pub fn is_empty(self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl<T> FromIterator<(String, T)> for KwArgs<T> {
+    fn from_iter<I: IntoIterator<Item = (String, T)>>(iter: I) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl<T> Default for KwArgs<T> {
+    fn default() -> Self {
+        Self(IndexMap::new())
+    }
+}
+
+impl<T> FromArgs for KwArgs<T>
+where
+    T: TryFromObject,
+{
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        let mut kwargs = IndexMap::new();
+        for (name, value) in args.remaining_keywords() {
+            kwargs.insert(name, value.try_into_value(vm)?);
+        }
+        Ok(Self(kwargs))
+    }
+}
+
+impl<T> IntoIterator for KwArgs<T> {
+    type Item = (String, T);
+    type IntoIter = indexmap::map::IntoIter<String, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// A list of positional argument values.
+///
+/// A built-in function with a `PosArgs` parameter is analogous to a Python
+/// function with `*args`. All remaining positional arguments are extracted
+/// (and hence the function will permit an arbitrary number of them).
+///
+/// `PosArgs` optionally accepts a generic type parameter to allow type checks
+/// or conversions of each argument.
+#[derive(Clone)]
+pub struct PosArgs<T = PyObjectRef>(Vec<T>);
+
+unsafe impl<T> Traverse for PosArgs<T>
+where
+    T: Traverse,
+{
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.0.traverse(tracer_fn)
+    }
+}
+
+impl<T> PosArgs<T> {
+    pub const fn new(args: Vec<T>) -> Self {
+        Self(args)
+    }
+
+    pub fn into_vec(self) -> Vec<T> {
+        self.0
+    }
+
+    pub fn iter(&self) -> core::slice::Iter<'_, T> {
+        self.0.iter()
+    }
+}
+
+impl<T> From<Vec<T>> for PosArgs<T> {
+    fn from(v: Vec<T>) -> Self {
+        Self(v)
+    }
+}
+
+impl From<()> for PosArgs<PyObjectRef> {
+    fn from(_args: ()) -> Self {
+        Self(Vec::new())
+    }
+}
+
+impl<T> AsRef<[T]> for PosArgs<T> {
+    fn as_ref(&self) -> &[T] {
+        &self.0
+    }
+}
+
+impl<T: PyPayload> PosArgs<PyRef<T>> {
+    pub fn into_tuple(self, vm: &VirtualMachine) -> PyTupleRef {
+        vm.ctx
+            .new_tuple(self.0.into_iter().map(Into::into).collect())
+    }
+}
+
+impl<T> FromArgs for PosArgs<T>
+where
+    T: TryFromObject,
+{
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        let mut varargs = Vec::new();
+        while let Some(value) = args.take_positional() {
+            varargs.push(value.try_into_value(vm)?);
+        }
+        Ok(Self(varargs))
+    }
+}
+
+impl<T> IntoIterator for PosArgs<T> {
+    type Item = T;
+    type IntoIter = alloc::vec::IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl<T> FromArgs for T
+where
+    T: TryFromObject,
+{
+    fn arity() -> RangeInclusive<usize> {
+        1..=1
+    }
+
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        let value = args.take_positional().ok_or(ArgumentError::TooFewArgs)?;
+        Ok(value.try_into_value(vm)?)
+    }
+}
+
+/// An argument that may or may not be provided by the caller.
+///
+/// This style of argument is not possible in pure Python.
+#[derive(Debug, result_like::OptionLike, is_macro::Is)]
+pub enum OptionalArg<T = PyObjectRef> {
+    Present(T),
+    Missing,
+}
+
+unsafe impl<T> Traverse for OptionalArg<T>
+where
+    T: Traverse,
+{
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        match self {
+            Self::Present(o) => o.traverse(tracer_fn),
+            Self::Missing => (),
+        }
+    }
+}
+
+impl OptionalArg<PyObjectRef> {
+    pub fn unwrap_or_none(self, vm: &VirtualMachine) -> PyObjectRef {
+        self.unwrap_or_else(|| vm.ctx.none())
+    }
+}
+
+pub type OptionalOption<T = PyObjectRef> = OptionalArg<Option<T>>;
+
+impl<T> OptionalOption<T> {
+    #[inline]
+    pub fn flatten(self) -> Option<T> {
+        self.into_option().flatten()
+    }
+}
+
+impl<T> FromArgs for OptionalArg<T>
+where
+    T: TryFromObject,
+{
+    fn arity() -> RangeInclusive<usize> {
+        0..=1
+    }
+
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        let r = if let Some(value) = args.take_positional() {
+            Self::Present(value.try_into_value(vm)?)
+        } else {
+            Self::Missing
+        };
+        Ok(r)
+    }
+}
+
+// For functions that accept no arguments. Implemented explicitly instead of via
+// macro below to avoid unused warnings.
+impl FromArgs for () {
+    fn from_args(_vm: &VirtualMachine, _args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        Ok(())
+    }
+}
+
+// A tuple of types that each implement `FromArgs` represents a sequence of
+// arguments that can be bound and passed to a built-in function.
+//
+// Technically, a tuple can contain tuples, which can contain tuples, and so on,
+// so this actually represents a tree of values to be bound from arguments, but
+// in practice this is only used for the top-level parameters.
+macro_rules! tuple_from_py_func_args {
+    ($($T:ident),+) => {
+        impl<$($T),+> FromArgs for ($($T,)+)
+        where
+            $($T: FromArgs),+
+        {
+            fn arity() -> RangeInclusive<usize> {
+                let mut min = 0;
+                let mut max = 0;
+                $(
+                    let (start, end) = $T::arity().into_inner();
+                    min += start;
+                    max += end;
+                )+
+                min..=max
+            }
+
+            fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+                Ok(($($T::from_args(vm, args)?,)+))
+            }
+        }
+    };
+}
+
+// Implement `FromArgs` for up to 7-tuples, allowing built-in functions to bind
+// up to 7 top-level parameters (note that `PosArgs`, `KwArgs`, nested tuples, etc.
+// count as 1, so this should actually be more than enough).
+tuple_from_py_func_args!(A);
+tuple_from_py_func_args!(A, B);
+tuple_from_py_func_args!(A, B, C);
+tuple_from_py_func_args!(A, B, C, D);
+tuple_from_py_func_args!(A, B, C, D, E);
+tuple_from_py_func_args!(A, B, C, D, E, F);
+tuple_from_py_func_args!(A, B, C, D, E, F, G);
+tuple_from_py_func_args!(A, B, C, D, E, F, G, H);
diff --git a/vm/src/function/arithmetic.rs b/crates/vm/src/function/arithmetic.rs
similarity index 100%
rename from vm/src/function/arithmetic.rs
rename to crates/vm/src/function/arithmetic.rs
diff --git a/crates/vm/src/function/buffer.rs b/crates/vm/src/function/buffer.rs
new file mode 100644
index 0000000000..e8f835e1da
--- /dev/null
+++ b/crates/vm/src/function/buffer.rs
@@ -0,0 +1,205 @@
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject,
+    VirtualMachine,
+    builtins::{PyStr, PyStrRef},
+    common::borrow::{BorrowedValue, BorrowedValueMut},
+    protocol::PyBuffer,
+};
+
+// Python/getargs.c
+
+/// any bytes-like object. Like the `y*` format code for `PyArg_Parse` in CPython.
+#[derive(Debug, Traverse)]
+pub struct ArgBytesLike(PyBuffer);
+
+impl PyObject {
+    pub fn try_bytes_like<R>(
+        &self,
+        vm: &VirtualMachine,
+        f: impl FnOnce(&[u8]) -> R,
+    ) -> PyResult<R> {
+        let buffer = PyBuffer::try_from_borrowed_object(vm, self)?;
+        buffer
+            .as_contiguous()
+            .map(|x| f(&x))
+            .ok_or_else(|| vm.new_buffer_error("non-contiguous buffer is not a bytes-like object"))
+    }
+
+    pub fn try_rw_bytes_like<R>(
+        &self,
+        vm: &VirtualMachine,
+        f: impl FnOnce(&mut [u8]) -> R,
+    ) -> PyResult<R> {
+        let buffer = PyBuffer::try_from_borrowed_object(vm, self)?;
+        buffer
+            .as_contiguous_mut()
+            .map(|mut x| f(&mut x))
+            .ok_or_else(|| vm.new_type_error("buffer is not a read-write bytes-like object"))
+    }
+}
+
+impl ArgBytesLike {
+    pub fn borrow_buf(&self) -> BorrowedValue<'_, [u8]> {
+        unsafe { self.0.contiguous_unchecked() }
+    }
+
+    pub fn with_ref<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&[u8]) -> R,
+    {
+        f(&self.borrow_buf())
+    }
+
+    pub const fn len(&self) -> usize {
+        self.0.desc.len
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn as_object(&self) -> &PyObject {
+        &self.0.obj
+    }
+}
+
+impl From<ArgBytesLike> for PyBuffer {
+    fn from(buffer: ArgBytesLike) -> Self {
+        buffer.0
+    }
+}
+
+impl From<ArgBytesLike> for PyObjectRef {
+    fn from(buffer: ArgBytesLike) -> Self {
+        buffer.as_object().to_owned()
+    }
+}
+
+impl<'a> TryFromBorrowedObject<'a> for ArgBytesLike {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+        let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?;
+        if buffer.desc.is_contiguous() {
+            Ok(Self(buffer))
+        } else {
+            Err(vm.new_buffer_error("non-contiguous buffer is not a bytes-like object"))
+        }
+    }
+}
+
+/// A memory buffer, read-write access. Like the `w*` format code for `PyArg_Parse` in CPython.
+#[derive(Debug, Traverse)]
+pub struct ArgMemoryBuffer(PyBuffer);
+
+impl ArgMemoryBuffer {
+    pub fn borrow_buf_mut(&self) -> BorrowedValueMut<'_, [u8]> {
+        unsafe { self.0.contiguous_mut_unchecked() }
+    }
+
+    pub fn with_ref<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&mut [u8]) -> R,
+    {
+        f(&mut self.borrow_buf_mut())
+    }
+
+    pub const fn len(&self) -> usize {
+        self.0.desc.len
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl From<ArgMemoryBuffer> for PyBuffer {
+    fn from(buffer: ArgMemoryBuffer) -> Self {
+        buffer.0
+    }
+}
+
+impl<'a> TryFromBorrowedObject<'a> for ArgMemoryBuffer {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+        let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?;
+        if !buffer.desc.is_contiguous() {
+            Err(vm.new_buffer_error("non-contiguous buffer is not a bytes-like object"))
+        } else if buffer.desc.readonly {
+            Err(vm.new_type_error("buffer is not a read-write bytes-like object"))
+        } else {
+            Ok(Self(buffer))
+        }
+    }
+}
+
+/// A text string or bytes-like object. Like the `s*` format code for `PyArg_Parse` in CPython.
+pub enum ArgStrOrBytesLike {
+    Buf(ArgBytesLike),
+    Str(PyStrRef),
+}
+
+impl ArgStrOrBytesLike {
+    pub fn as_object(&self) -> &PyObject {
+        match self {
+            Self::Buf(b) => b.as_object(),
+            Self::Str(s) => s.as_object(),
+        }
+    }
+}
+
+impl TryFromObject for ArgStrOrBytesLike {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        obj.downcast()
+            .map(Self::Str)
+            .or_else(|obj| ArgBytesLike::try_from_object(vm, obj).map(Self::Buf))
+    }
+}
+
+impl ArgStrOrBytesLike {
+    pub fn borrow_bytes(&self) -> BorrowedValue<'_, [u8]> {
+        match self {
+            Self::Buf(b) => b.borrow_buf(),
+            Self::Str(s) => s.as_bytes().into(),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum ArgAsciiBuffer {
+    String(PyStrRef),
+    Buffer(ArgBytesLike),
+}
+
+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() {
+                    Ok(Self::String(string))
+                } else {
+                    Err(vm.new_value_error("string argument should contain only ASCII characters"))
+                }
+            }
+            Err(obj) => ArgBytesLike::try_from_object(vm, obj).map(ArgAsciiBuffer::Buffer),
+        }
+    }
+}
+
+impl ArgAsciiBuffer {
+    pub fn len(&self) -> usize {
+        match self {
+            Self::String(s) => s.as_str().len(),
+            Self::Buffer(buffer) => buffer.len(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    #[inline]
+    pub fn with_ref<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
+        match self {
+            Self::String(s) => f(s.as_bytes()),
+            Self::Buffer(buffer) => buffer.with_ref(f),
+        }
+    }
+}
diff --git a/vm/src/function/builtin.rs b/crates/vm/src/function/builtin.rs
similarity index 97%
rename from vm/src/function/builtin.rs
rename to crates/vm/src/function/builtin.rs
index 1a91e4344b..444df64a8e 100644
--- a/vm/src/function/builtin.rs
+++ b/crates/vm/src/function/builtin.rs
@@ -3,7 +3,7 @@ use crate::{
     Py, PyPayload, PyRef, PyResult, VirtualMachine, convert::ToPyResult,
     object::PyThreadingConstraint,
 };
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 /// A built-in Python function.
 // PyCFunction in CPython
@@ -54,14 +54,14 @@ const fn zst_ref_out_of_thin_air<T: 'static>(x: T) -> &'static T {
     // if T is zero-sized, there's no issue forgetting it - even if it does have a Drop impl, it
     // would never get called anyway if we consider this semantically a Box::leak(Box::new(x))-type
     // operation. if T isn't zero-sized, we don't have to worry about it because we'll fail to compile.
-    std::mem::forget(x);
+    core::mem::forget(x);
     const {
-        if std::mem::size_of::<T>() != 0 {
+        if core::mem::size_of::<T>() != 0 {
             panic!("can't use a non-zero-sized type here")
         }
         // SAFETY: we just confirmed that T is zero-sized, so we can
         //         pull a value of it out of thin air.
-        unsafe { std::ptr::NonNull::<T>::dangling().as_ref() }
+        unsafe { core::ptr::NonNull::<T>::dangling().as_ref() }
     }
 }
 
@@ -218,7 +218,7 @@ into_py_native_fn_tuple!(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::mem::size_of_val;
+    use core::mem::size_of_val;
 
     #[test]
     fn test_into_native_fn_noalloc() {
diff --git a/vm/src/function/either.rs b/crates/vm/src/function/either.rs
similarity index 98%
rename from vm/src/function/either.rs
rename to crates/vm/src/function/either.rs
index 8700c6150d..9ee7f028bd 100644
--- a/vm/src/function/either.rs
+++ b/crates/vm/src/function/either.rs
@@ -1,7 +1,7 @@
 use crate::{
     AsObject, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, convert::ToPyObject,
 };
-use std::borrow::Borrow;
+use core::borrow::Borrow;
 
 pub enum Either<A, B> {
     A(A),
diff --git a/crates/vm/src/function/fspath.rs b/crates/vm/src/function/fspath.rs
new file mode 100644
index 0000000000..7d3a0dcbbd
--- /dev/null
+++ b/crates/vm/src/function/fspath.rs
@@ -0,0 +1,153 @@
+use crate::{
+    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::{PyBytes, PyBytesRef, PyStrRef},
+    convert::{IntoPyException, ToPyObject},
+    function::PyStr,
+    protocol::PyBuffer,
+};
+use alloc::borrow::Cow;
+use std::{ffi::OsStr, path::PathBuf};
+
+/// Helper to implement os.fspath()
+#[derive(Clone)]
+pub enum FsPath {
+    Str(PyStrRef),
+    Bytes(PyBytesRef),
+}
+
+impl FsPath {
+    pub fn try_from_path_like(
+        obj: PyObjectRef,
+        check_for_nul: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        Self::try_from(
+            obj,
+            check_for_nul,
+            "expected str, bytes or os.PathLike object",
+            vm,
+        )
+    }
+
+    // PyOS_FSPath
+    pub fn try_from(
+        obj: PyObjectRef,
+        check_for_nul: bool,
+        msg: &'static str,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let check_nul = |b: &[u8]| {
+            if !check_for_nul || memchr::memchr(b'\0', b).is_none() {
+                Ok(())
+            } else {
+                Err(crate::exceptions::cstring_error(vm))
+            }
+        };
+        let match1 = |obj: PyObjectRef| {
+            let pathlike = match_class!(match obj {
+                s @ PyStr => {
+                    check_nul(s.as_bytes())?;
+                    Self::Str(s)
+                }
+                b @ PyBytes => {
+                    check_nul(&b)?;
+                    Self::Bytes(b)
+                }
+                obj => return Ok(Err(obj)),
+            });
+            Ok(Ok(pathlike))
+        };
+        let obj = match match1(obj)? {
+            Ok(pathlike) => return Ok(pathlike),
+            Err(obj) => obj,
+        };
+        let not_pathlike_error = || format!("{msg}, not {}", obj.class().name());
+        let method = vm.get_method_or_type_error(
+            obj.clone(),
+            identifier!(vm, __fspath__),
+            not_pathlike_error,
+        )?;
+        // If __fspath__ is explicitly set to None, treat it as if it doesn't have __fspath__
+        if vm.is_none(&method) {
+            return Err(vm.new_type_error(not_pathlike_error()));
+        }
+        let result = method.call((), vm)?;
+        match1(result)?.map_err(|result| {
+            vm.new_type_error(format!(
+                "expected {}.__fspath__() to return str or bytes, not {}",
+                obj.class().name(),
+                result.class().name(),
+            ))
+        })
+    }
+
+    pub fn as_os_str(&self, vm: &VirtualMachine) -> PyResult<Cow<'_, OsStr>> {
+        // TODO: FS encodings
+        match self {
+            Self::Str(s) => vm.fsencode(s),
+            Self::Bytes(b) => Self::bytes_as_os_str(b.as_bytes(), vm).map(Cow::Borrowed),
+        }
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        // TODO: FS encodings
+        match self {
+            Self::Str(s) => s.as_bytes(),
+            Self::Bytes(b) => b.as_bytes(),
+        }
+    }
+
+    pub fn to_string_lossy(&self) -> Cow<'_, str> {
+        match self {
+            Self::Str(s) => s.to_string_lossy(),
+            Self::Bytes(s) => String::from_utf8_lossy(s),
+        }
+    }
+
+    pub fn to_path_buf(&self, vm: &VirtualMachine) -> PyResult<PathBuf> {
+        let path = match self {
+            Self::Str(s) => PathBuf::from(s.as_str()),
+            Self::Bytes(b) => PathBuf::from(Self::bytes_as_os_str(b, vm)?),
+        };
+        Ok(path)
+    }
+
+    pub fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.as_bytes()).map_err(|e| e.into_pyexception(vm))
+    }
+
+    #[cfg(windows)]
+    pub fn to_wide_cstring(&self, vm: &VirtualMachine) -> PyResult<widestring::WideCString> {
+        widestring::WideCString::from_os_str(self.as_os_str(vm)?)
+            .map_err(|err| err.into_pyexception(vm))
+    }
+
+    pub fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> {
+        rustpython_common::os::bytes_as_os_str(b)
+            .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8"))
+    }
+}
+
+impl ToPyObject for FsPath {
+    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
+        match self {
+            Self::Str(s) => s.into(),
+            Self::Bytes(b) => b.into(),
+        }
+    }
+}
+
+impl TryFromObject for FsPath {
+    // PyUnicode_FSDecoder in CPython
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let obj = match obj.try_to_value::<PyBuffer>(vm) {
+            Ok(buffer) => {
+                let mut bytes = vec![];
+                buffer.append_to(&mut bytes);
+                vm.ctx.new_bytes(bytes).into()
+            }
+            Err(_) => obj,
+        };
+        Self::try_from_path_like(obj, true, vm)
+    }
+}
diff --git a/vm/src/function/getset.rs b/crates/vm/src/function/getset.rs
similarity index 100%
rename from vm/src/function/getset.rs
rename to crates/vm/src/function/getset.rs
diff --git a/crates/vm/src/function/method.rs b/crates/vm/src/function/method.rs
new file mode 100644
index 0000000000..6440fd801f
--- /dev/null
+++ b/crates/vm/src/function/method.rs
@@ -0,0 +1,319 @@
+use crate::{
+    Context, Py, PyObjectRef, PyPayload, PyRef, VirtualMachine,
+    builtins::{
+        PyType,
+        builtin_func::{PyNativeFunction, PyNativeMethod},
+        descriptor::PyMethodDescriptor,
+    },
+    function::{IntoPyNativeFn, PyNativeFn},
+};
+
+bitflags::bitflags! {
+    // METH_XXX flags in CPython
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    pub struct PyMethodFlags: u32 {
+        // 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;
+
+        // METH_CLASS and METH_STATIC are a little different; these control
+        // the construction of methods for a class.  These cannot be used for
+        // functions in modules.
+        const CLASS = 0x0010;
+        const STATIC = 0x0020;
+
+        // METH_COEXIST allows a method to be entered even though a slot has
+        // already filled the entry.  When defined, the flag allows a separate
+        // method, "__contains__" for example, to coexist with a defined
+        // slot like sq_contains.
+        // const COEXIST = 0x0040;
+
+        // if not Py_LIMITED_API
+        // const FASTCALL = 0x0080;
+
+        // This bit is preserved for Stackless Python
+        // const STACKLESS = 0x0100;
+
+        // METH_METHOD means the function stores an
+        // additional reference to the class that defines it;
+        // both self and class are passed to it.
+        // It uses PyCMethodObject instead of PyCFunctionObject.
+        // May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC.
+        const METHOD = 0x0200;
+    }
+}
+
+impl PyMethodFlags {
+    // FIXME: macro temp
+    pub const EMPTY: Self = Self::empty();
+}
+
+#[macro_export]
+macro_rules! define_methods {
+    // TODO: more flexible syntax
+    ($($name:literal => $func:ident as $flags:ident),+) => {
+        vec![ $( $crate::function::PyMethodDef {
+            name: $name,
+            func: $crate::function::static_func($func),
+            flags: $crate::function::PyMethodFlags::$flags,
+            doc: None,
+        }),+ ]
+    };
+}
+
+#[derive(Clone)]
+pub struct PyMethodDef {
+    pub name: &'static str, // TODO: interned
+    pub func: &'static dyn PyNativeFn,
+    pub flags: PyMethodFlags,
+    pub doc: Option<&'static str>, // TODO: interned
+}
+
+impl PyMethodDef {
+    #[inline]
+    pub const fn new_const<Kind>(
+        name: &'static str,
+        func: impl IntoPyNativeFn<Kind>,
+        flags: PyMethodFlags,
+        doc: Option<&'static str>,
+    ) -> Self {
+        Self {
+            name,
+            func: super::static_func(func),
+            flags,
+            doc,
+        }
+    }
+
+    #[inline]
+    pub const fn new_raw_const(
+        name: &'static str,
+        func: impl PyNativeFn,
+        flags: PyMethodFlags,
+        doc: Option<&'static str>,
+    ) -> Self {
+        Self {
+            name,
+            func: super::static_raw_func(func),
+            flags,
+            doc,
+        }
+    }
+
+    pub fn to_proper_method(
+        &'static self,
+        class: &'static Py<PyType>,
+        ctx: &Context,
+    ) -> PyObjectRef {
+        if self.flags.contains(PyMethodFlags::METHOD) {
+            self.build_method(ctx, class).into()
+        } else if self.flags.contains(PyMethodFlags::CLASS) {
+            self.build_classmethod(ctx, class).into()
+        } else if self.flags.contains(PyMethodFlags::STATIC) {
+            self.build_staticmethod(ctx, class).into()
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub const fn to_function(&'static self) -> PyNativeFunction {
+        PyNativeFunction {
+            zelf: None,
+            value: self,
+            module: None,
+        }
+    }
+
+    pub fn to_method(
+        &'static self,
+        class: &'static Py<PyType>,
+        ctx: &Context,
+    ) -> PyMethodDescriptor {
+        PyMethodDescriptor::new(self, class, ctx)
+    }
+
+    pub const fn to_bound_method(
+        &'static self,
+        obj: PyObjectRef,
+        class: &'static Py<PyType>,
+    ) -> PyNativeMethod {
+        PyNativeMethod {
+            func: PyNativeFunction {
+                zelf: Some(obj),
+                value: self,
+                module: None,
+            },
+            class,
+        }
+    }
+
+    pub fn build_function(&'static self, ctx: &Context) -> PyRef<PyNativeFunction> {
+        self.to_function().into_ref(ctx)
+    }
+
+    pub fn build_bound_function(
+        &'static self,
+        ctx: &Context,
+        obj: PyObjectRef,
+    ) -> PyRef<PyNativeFunction> {
+        let function = PyNativeFunction {
+            zelf: Some(obj),
+            value: self,
+            module: None,
+        };
+        PyRef::new_ref(
+            function,
+            ctx.types.builtin_function_or_method_type.to_owned(),
+            None,
+        )
+    }
+
+    pub fn build_method(
+        &'static self,
+        ctx: &Context,
+        class: &'static Py<PyType>,
+    ) -> PyRef<PyMethodDescriptor> {
+        debug_assert!(self.flags.contains(PyMethodFlags::METHOD));
+        let method = self.to_method(class, ctx);
+        PyRef::new_ref(method, ctx.types.method_descriptor_type.to_owned(), None)
+    }
+
+    pub fn build_bound_method(
+        &'static self,
+        ctx: &Context,
+        obj: PyObjectRef,
+        class: &'static Py<PyType>,
+    ) -> PyRef<PyNativeMethod> {
+        PyRef::new_ref(
+            self.to_bound_method(obj, class),
+            ctx.types.builtin_method_type.to_owned(),
+            None,
+        )
+    }
+
+    pub fn build_classmethod(
+        &'static self,
+        ctx: &Context,
+        class: &'static Py<PyType>,
+    ) -> PyRef<PyMethodDescriptor> {
+        PyRef::new_ref(
+            self.to_method(class, ctx),
+            ctx.types.method_descriptor_type.to_owned(),
+            None,
+        )
+    }
+
+    pub fn build_staticmethod(
+        &'static self,
+        ctx: &Context,
+        class: &'static Py<PyType>,
+    ) -> PyRef<PyNativeMethod> {
+        debug_assert!(self.flags.contains(PyMethodFlags::STATIC));
+        let func = self.to_function();
+        PyNativeMethod { func, class }.into_ref(ctx)
+    }
+
+    #[doc(hidden)]
+    pub const fn __const_concat_arrays<const SUM_LEN: usize>(
+        method_groups: &[&[Self]],
+    ) -> [Self; SUM_LEN] {
+        const NULL_METHOD: PyMethodDef = PyMethodDef {
+            name: "",
+            func: &|_, _| unreachable!(),
+            flags: PyMethodFlags::empty(),
+            doc: None,
+        };
+        let mut all_methods = [NULL_METHOD; SUM_LEN];
+        let mut all_idx = 0;
+        let mut group_idx = 0;
+        while group_idx < method_groups.len() {
+            let group = method_groups[group_idx];
+            let mut method_idx = 0;
+            while method_idx < group.len() {
+                all_methods[all_idx] = group[method_idx].const_copy();
+                method_idx += 1;
+                all_idx += 1;
+            }
+            group_idx += 1;
+        }
+        all_methods
+    }
+
+    const fn const_copy(&self) -> Self {
+        Self {
+            name: self.name,
+            func: self.func,
+            flags: self.flags,
+            doc: self.doc,
+        }
+    }
+}
+
+impl core::fmt::Debug for PyMethodDef {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyMethodDef")
+            .field("name", &self.name)
+            .field(
+                "func",
+                &(unsafe {
+                    core::mem::transmute::<&dyn PyNativeFn, [usize; 2]>(self.func)[1] as *const u8
+                }),
+            )
+            .field("flags", &self.flags)
+            .field("doc", &self.doc)
+            .finish()
+    }
+}
+
+// This is not a part of CPython API.
+// But useful to support dynamically generated methods
+#[pyclass(name, module = false, ctx = "method_def")]
+#[derive(Debug)]
+pub struct HeapMethodDef {
+    method: PyMethodDef,
+}
+
+impl HeapMethodDef {
+    pub const fn new(method: PyMethodDef) -> Self {
+        Self { method }
+    }
+}
+
+impl Py<HeapMethodDef> {
+    pub(crate) unsafe fn method(&self) -> &'static PyMethodDef {
+        unsafe { &*(&self.method as *const _) }
+    }
+
+    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();
+        PyRef::new_ref(
+            function,
+            vm.ctx.types.builtin_function_or_method_type.to_owned(),
+            Some(dict),
+        )
+    }
+
+    pub fn build_method(
+        &self,
+        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();
+        PyRef::new_ref(
+            function,
+            vm.ctx.types.method_descriptor_type.to_owned(),
+            Some(dict),
+        )
+    }
+}
+
+#[pyclass]
+impl HeapMethodDef {}
diff --git a/vm/src/function/mod.rs b/crates/vm/src/function/mod.rs
similarity index 100%
rename from vm/src/function/mod.rs
rename to crates/vm/src/function/mod.rs
diff --git a/crates/vm/src/function/number.rs b/crates/vm/src/function/number.rs
new file mode 100644
index 0000000000..b53208bcd9
--- /dev/null
+++ b/crates/vm/src/function/number.rs
@@ -0,0 +1,198 @@
+use super::argument::OptionalArg;
+use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, builtins::PyIntRef};
+use core::ops::Deref;
+use malachite_bigint::BigInt;
+use num_complex::Complex64;
+use num_traits::PrimInt;
+
+/// A Python complex-like object.
+///
+/// `ArgIntoComplex` implements `FromArgs` so that a built-in function can accept
+/// any object that can be transformed into a complex.
+///
+/// If the object is not a Python complex object but has a `__complex__()`
+/// method, this method will first be called to convert the object into a float.
+/// If `__complex__()` is not defined then it falls back to `__float__()`. If
+/// `__float__()` is not defined it falls back to `__index__()`.
+#[derive(Debug, PartialEq)]
+#[repr(transparent)]
+pub struct ArgIntoComplex {
+    value: Complex64,
+}
+
+impl ArgIntoComplex {
+    #[inline]
+    pub fn into_complex(self) -> Complex64 {
+        self.value
+    }
+}
+
+impl From<ArgIntoComplex> for Complex64 {
+    fn from(arg: ArgIntoComplex) -> Self {
+        arg.value
+    }
+}
+
+impl TryFromObject for ArgIntoComplex {
+    // Equivalent to PyComplex_AsCComplex
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        // We do not care if it was already a complex.
+        let (value, _) = obj.try_complex(vm)?.ok_or_else(|| {
+            vm.new_type_error(format!("must be real number, not {}", obj.class().name()))
+        })?;
+        Ok(Self { value })
+    }
+}
+
+/// A Python float-like object.
+///
+/// `ArgIntoFloat` implements `FromArgs` so that a built-in function can accept
+/// any object that can be transformed into a float.
+///
+/// If the object is not a Python floating point object but has a `__float__()`
+/// method, this method will first be called to convert the object into a float.
+/// If `__float__()` is not defined then it falls back to `__index__()`.
+#[derive(Debug, PartialEq)]
+#[repr(transparent)]
+pub struct ArgIntoFloat {
+    value: f64,
+}
+
+impl ArgIntoFloat {
+    #[inline]
+    pub fn into_float(self) -> f64 {
+        self.value
+    }
+
+    pub fn vec_into_f64(v: Vec<Self>) -> Vec<f64> {
+        // TODO: Vec::into_raw_parts once stabilized
+        let mut v = core::mem::ManuallyDrop::new(v);
+        let (p, l, c) = (v.as_mut_ptr(), v.len(), v.capacity());
+        // SAFETY: IntoPyFloat is repr(transparent) over f64
+        unsafe { Vec::from_raw_parts(p.cast(), l, c) }
+    }
+}
+
+impl From<ArgIntoFloat> for f64 {
+    fn from(arg: ArgIntoFloat) -> Self {
+        arg.value
+    }
+}
+
+impl TryFromObject for ArgIntoFloat {
+    // Equivalent to PyFloat_AsDouble.
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let value = obj.try_float(vm)?.to_f64();
+        Ok(Self { value })
+    }
+}
+
+/// A Python bool-like object.
+///
+/// `ArgIntoBool` implements `FromArgs` so that a built-in function can accept
+/// any object that can be transformed into a boolean.
+///
+/// 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.
+#[derive(Debug, Default, PartialEq, Eq)]
+pub struct ArgIntoBool {
+    value: bool,
+}
+
+impl ArgIntoBool {
+    pub const TRUE: Self = Self { value: true };
+    pub const FALSE: Self = Self { value: false };
+
+    #[inline]
+    pub fn into_bool(self) -> bool {
+        self.value
+    }
+}
+
+impl From<ArgIntoBool> for bool {
+    fn from(arg: ArgIntoBool) -> Self {
+        arg.value
+    }
+}
+
+impl TryFromObject for ArgIntoBool {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        Ok(Self {
+            value: obj.try_to_bool(vm)?,
+        })
+    }
+}
+
+// Implement ArgIndex to separate between "true" int and int generated by index
+#[derive(Debug, Traverse)]
+#[repr(transparent)]
+pub struct ArgIndex {
+    value: PyIntRef,
+}
+
+impl ArgIndex {
+    #[inline]
+    pub fn into_int_ref(self) -> PyIntRef {
+        self.value
+    }
+}
+
+impl AsRef<PyIntRef> for ArgIndex {
+    fn as_ref(&self) -> &PyIntRef {
+        &self.value
+    }
+}
+
+impl From<ArgIndex> for PyIntRef {
+    fn from(arg: ArgIndex) -> Self {
+        arg.value
+    }
+}
+
+impl TryFromObject for ArgIndex {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        Ok(Self {
+            value: obj.try_index(vm)?,
+        })
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct ArgPrimitiveIndex<T> {
+    pub value: T,
+}
+
+impl<T> OptionalArg<ArgPrimitiveIndex<T>> {
+    pub fn into_primitive(self) -> OptionalArg<T> {
+        self.map(|x| x.value)
+    }
+}
+
+impl<T> Deref for ArgPrimitiveIndex<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.value
+    }
+}
+
+impl<T> TryFromObject for ArgPrimitiveIndex<T>
+where
+    T: PrimInt + for<'a> TryFrom<&'a BigInt>,
+{
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        Ok(Self {
+            value: obj.try_index(vm)?.try_to_primitive(vm)?,
+        })
+    }
+}
+
+pub type ArgSize = ArgPrimitiveIndex<isize>;
+
+impl From<ArgSize> for isize {
+    fn from(arg: ArgSize) -> Self {
+        arg.value
+    }
+}
diff --git a/vm/src/function/protocol.rs b/crates/vm/src/function/protocol.rs
similarity index 77%
rename from vm/src/function/protocol.rs
rename to crates/vm/src/function/protocol.rs
index 3205f75c27..402f6d0365 100644
--- a/vm/src/function/protocol.rs
+++ b/crates/vm/src/function/protocol.rs
@@ -1,14 +1,13 @@
 use super::IntoFuncArgs;
 use crate::{
     AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyDict, PyDictRef, iter::PySequenceIterator},
+    builtins::{PyDictRef, iter::PySequenceIterator},
     convert::ToPyObject,
-    identifier,
     object::{Traverse, TraverseFn},
-    protocol::{PyIter, PyIterIter, PyMapping, PyMappingMethods},
-    types::{AsMapping, GenericMethod},
+    protocol::{PyIter, PyIterIter, PyMapping},
+    types::GenericMethod,
 };
-use std::{borrow::Borrow, marker::PhantomData, ops::Deref};
+use core::{borrow::Borrow, marker::PhantomData};
 
 #[derive(Clone, Traverse)]
 pub struct ArgCallable {
@@ -25,8 +24,8 @@ impl ArgCallable {
     }
 }
 
-impl std::fmt::Debug for ArgCallable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for ArgCallable {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("ArgCallable")
             .field("obj", &self.obj)
             .field("call", &format!("{:08x}", self.call as usize))
@@ -105,14 +104,11 @@ where
     T: TryFromObject,
 {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let iter_fn = {
-            let cls = obj.class();
-            let iter_fn = cls.mro_find_map(|x| x.slots.iter.load());
-            if iter_fn.is_none() && !cls.has_attr(identifier!(vm, __getitem__)) {
-                return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
-            }
-            iter_fn
-        };
+        let cls = obj.class();
+        let iter_fn = cls.slots.iter.load();
+        if iter_fn.is_none() && !cls.has_attr(identifier!(vm, __getitem__)) {
+            return Err(vm.new_type_error(format!("'{}' object is not iterable", cls.name())));
+        }
         Ok(Self {
             iterable: obj,
             iter_fn,
@@ -124,30 +120,27 @@ where
 #[derive(Debug, Clone, Traverse)]
 pub struct ArgMapping {
     obj: PyObjectRef,
-    #[pytraverse(skip)]
-    methods: &'static PyMappingMethods,
 }
 
 impl ArgMapping {
     #[inline]
-    pub const fn with_methods(obj: PyObjectRef, methods: &'static PyMappingMethods) -> Self {
-        Self { obj, methods }
+    pub const fn new(obj: PyObjectRef) -> Self {
+        Self { obj }
     }
 
     #[inline(always)]
     pub fn from_dict_exact(dict: PyDictRef) -> Self {
-        Self {
-            obj: dict.into(),
-            methods: PyDict::as_mapping(),
-        }
+        Self { obj: dict.into() }
+    }
+
+    #[inline(always)]
+    pub fn obj(&self) -> &PyObject {
+        &self.obj
     }
 
     #[inline(always)]
     pub fn mapping(&self) -> PyMapping<'_> {
-        PyMapping {
-            obj: &self.obj,
-            methods: self.methods,
-        }
+        self.obj.mapping_unchecked()
     }
 }
 
@@ -165,14 +158,6 @@ impl AsRef<PyObject> for ArgMapping {
     }
 }
 
-impl Deref for ArgMapping {
-    type Target = PyObject;
-    #[inline(always)]
-    fn deref(&self) -> &PyObject {
-        &self.obj
-    }
-}
-
 impl From<ArgMapping> for PyObjectRef {
     #[inline(always)]
     fn from(value: ArgMapping) -> Self {
@@ -189,9 +174,8 @@ impl ToPyObject for ArgMapping {
 
 impl TryFromObject for ArgMapping {
     fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let mapping = PyMapping::try_protocol(&obj, vm)?;
-        let methods = mapping.methods;
-        Ok(Self { obj, methods })
+        let _mapping = obj.try_mapping(vm)?;
+        Ok(Self { obj })
     }
 }
 
@@ -216,7 +200,7 @@ impl<T> ArgSequence<T> {
     }
 }
 
-impl<T> std::ops::Deref for ArgSequence<T> {
+impl<T> core::ops::Deref for ArgSequence<T> {
     type Target = [T];
     #[inline(always)]
     fn deref(&self) -> &[T] {
@@ -226,14 +210,14 @@ impl<T> std::ops::Deref for ArgSequence<T> {
 
 impl<'a, T> IntoIterator for &'a ArgSequence<T> {
     type Item = &'a T;
-    type IntoIter = std::slice::Iter<'a, T>;
+    type IntoIter = core::slice::Iter<'a, T>;
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 impl<T> IntoIterator for ArgSequence<T> {
     type Item = T;
-    type IntoIter = std::vec::IntoIter<T>;
+    type IntoIter = alloc::vec::IntoIter<T>;
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
     }
diff --git a/crates/vm/src/getpath.rs b/crates/vm/src/getpath.rs
new file mode 100644
index 0000000000..011d533687
--- /dev/null
+++ b/crates/vm/src/getpath.rs
@@ -0,0 +1,392 @@
+//! Path configuration for RustPython (ref: Modules/getpath.py)
+//!
+//! This module implements Python path calculation logic following getpath.py.
+//! It uses landmark-based search to locate prefix, exec_prefix, and stdlib directories.
+//!
+//! The main entry point is `init_path_config()` which computes Paths from Settings.
+
+use crate::vm::{Paths, Settings};
+use std::env;
+use std::path::{Path, PathBuf};
+
+// Platform-specific landmarks (ref: getpath.py PLATFORM CONSTANTS)
+
+#[cfg(not(windows))]
+mod platform {
+    use crate::version;
+
+    pub const BUILDDIR_TXT: &str = "pybuilddir.txt";
+    pub const BUILD_LANDMARK: &str = "Modules/Setup.local";
+    pub const VENV_LANDMARK: &str = "pyvenv.cfg";
+    pub const BUILDSTDLIB_LANDMARK: &str = "Lib/os.py";
+
+    pub fn stdlib_subdir() -> String {
+        format!("lib/python{}.{}", version::MAJOR, version::MINOR)
+    }
+
+    pub fn stdlib_landmarks() -> [String; 2] {
+        let subdir = stdlib_subdir();
+        [format!("{}/os.py", subdir), format!("{}/os.pyc", subdir)]
+    }
+
+    pub fn platstdlib_landmark() -> String {
+        format!(
+            "lib/python{}.{}/lib-dynload",
+            version::MAJOR,
+            version::MINOR
+        )
+    }
+
+    pub fn zip_landmark() -> String {
+        format!("lib/python{}{}.zip", version::MAJOR, version::MINOR)
+    }
+}
+
+#[cfg(windows)]
+mod platform {
+    use crate::version;
+
+    pub const BUILDDIR_TXT: &str = "pybuilddir.txt";
+    pub const BUILD_LANDMARK: &str = "Modules\\Setup.local";
+    pub const VENV_LANDMARK: &str = "pyvenv.cfg";
+    pub const BUILDSTDLIB_LANDMARK: &str = "Lib\\os.py";
+    pub const STDLIB_SUBDIR: &str = "Lib";
+
+    pub fn stdlib_landmarks() -> [String; 2] {
+        ["Lib\\os.py".into(), "Lib\\os.pyc".into()]
+    }
+
+    pub fn platstdlib_landmark() -> String {
+        "DLLs".into()
+    }
+
+    pub fn zip_landmark() -> String {
+        format!("python{}{}.zip", version::MAJOR, version::MINOR)
+    }
+}
+
+// Helper functions (ref: getpath.py HELPER FUNCTIONS)
+
+/// Search upward from a directory for landmark files/directories
+/// Returns the directory where a landmark was found
+fn search_up<P, F>(start: P, landmarks: &[&str], test: F) -> Option<PathBuf>
+where
+    P: AsRef<Path>,
+    F: Fn(&Path) -> bool,
+{
+    let mut current = start.as_ref().to_path_buf();
+    loop {
+        for landmark in landmarks {
+            let path = current.join(landmark);
+            if test(&path) {
+                return Some(current);
+            }
+        }
+        if !current.pop() {
+            return None;
+        }
+    }
+}
+
+/// Search upward for a file landmark
+fn search_up_file<P: AsRef<Path>>(start: P, landmarks: &[&str]) -> Option<PathBuf> {
+    search_up(start, landmarks, |p| p.is_file())
+}
+
+/// Search upward for a directory landmark
+#[cfg(not(windows))]
+fn search_up_dir<P: AsRef<Path>>(start: P, landmarks: &[&str]) -> Option<PathBuf> {
+    search_up(start, landmarks, |p| p.is_dir())
+}
+
+// Path computation functions
+
+/// Compute path configuration from Settings
+///
+/// This function should be called before interpreter initialization.
+/// It returns a Paths struct with all computed path values.
+pub fn init_path_config(settings: &Settings) -> Paths {
+    let mut paths = Paths::default();
+
+    // Step 0: Get executable path
+    let executable = get_executable_path();
+    let real_executable = executable
+        .as_ref()
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default();
+
+    // Step 1: Check for __PYVENV_LAUNCHER__ environment variable
+    // When launched from a venv launcher, __PYVENV_LAUNCHER__ contains the venv's python.exe path
+    // In this case:
+    //   - sys.executable should be the launcher path (where user invoked Python)
+    //   - sys._base_executable should be the real Python executable
+    let exe_dir = if let Ok(launcher) = env::var("__PYVENV_LAUNCHER__") {
+        paths.executable = launcher.clone();
+        paths.base_executable = real_executable;
+        PathBuf::from(&launcher).parent().map(PathBuf::from)
+    } else {
+        paths.executable = real_executable;
+        executable
+            .as_ref()
+            .and_then(|p| p.parent().map(PathBuf::from))
+    };
+
+    // Step 2: Check for venv (pyvenv.cfg) and get 'home'
+    let (venv_prefix, home_dir) = detect_venv(&exe_dir);
+    let search_dir = home_dir.clone().or(exe_dir.clone());
+
+    // Step 3: Check for build directory
+    let build_prefix = detect_build_directory(&search_dir);
+
+    // Step 4: Calculate prefix via landmark search
+    // When in venv, search_dir is home_dir, so this gives us the base Python's prefix
+    let calculated_prefix = calculate_prefix(&search_dir, &build_prefix);
+
+    // Step 5: Set prefix and base_prefix
+    if venv_prefix.is_some() {
+        // In venv: prefix = venv directory, base_prefix = original Python's prefix
+        paths.prefix = venv_prefix
+            .as_ref()
+            .map(|p| p.to_string_lossy().into_owned())
+            .unwrap_or_else(|| calculated_prefix.clone());
+        paths.base_prefix = calculated_prefix;
+    } else {
+        // Not in venv: prefix == base_prefix
+        paths.prefix = calculated_prefix.clone();
+        paths.base_prefix = calculated_prefix;
+    }
+
+    // Step 6: Calculate exec_prefix
+    paths.exec_prefix = if venv_prefix.is_some() {
+        // In venv: exec_prefix = prefix (venv directory)
+        paths.prefix.clone()
+    } else {
+        calculate_exec_prefix(&search_dir, &paths.prefix)
+    };
+    paths.base_exec_prefix = paths.base_prefix.clone();
+
+    // Step 7: Calculate base_executable (if not already set by __PYVENV_LAUNCHER__)
+    if paths.base_executable.is_empty() {
+        paths.base_executable = calculate_base_executable(executable.as_ref(), &home_dir);
+    }
+
+    // Step 8: Build module_search_paths
+    paths.module_search_paths =
+        build_module_search_paths(settings, &paths.prefix, &paths.exec_prefix);
+
+    paths
+}
+
+/// Get default prefix value
+fn default_prefix() -> String {
+    std::option_env!("RUSTPYTHON_PREFIX")
+        .map(String::from)
+        .unwrap_or_else(|| {
+            if cfg!(windows) {
+                "C:".to_owned()
+            } else {
+                "/usr/local".to_owned()
+            }
+        })
+}
+
+/// Detect virtual environment by looking for pyvenv.cfg
+/// Returns (venv_prefix, home_dir from pyvenv.cfg)
+fn detect_venv(exe_dir: &Option<PathBuf>) -> (Option<PathBuf>, Option<PathBuf>) {
+    // Try exe_dir/../pyvenv.cfg first (standard venv layout: venv/bin/python)
+    if let Some(dir) = exe_dir
+        && let Some(venv_dir) = dir.parent()
+    {
+        let cfg = venv_dir.join(platform::VENV_LANDMARK);
+        if cfg.exists()
+            && let Some(home) = parse_pyvenv_home(&cfg)
+        {
+            return (Some(venv_dir.to_path_buf()), Some(PathBuf::from(home)));
+        }
+    }
+
+    // Try exe_dir/pyvenv.cfg (alternative layout)
+    if let Some(dir) = exe_dir {
+        let cfg = dir.join(platform::VENV_LANDMARK);
+        if cfg.exists()
+            && let Some(home) = parse_pyvenv_home(&cfg)
+        {
+            return (Some(dir.clone()), Some(PathBuf::from(home)));
+        }
+    }
+
+    (None, None)
+}
+
+/// Detect if running from a build directory
+fn detect_build_directory(exe_dir: &Option<PathBuf>) -> Option<PathBuf> {
+    let dir = exe_dir.as_ref()?;
+
+    // Check for pybuilddir.txt (indicates build directory)
+    if dir.join(platform::BUILDDIR_TXT).exists() {
+        return Some(dir.clone());
+    }
+
+    // Check for Modules/Setup.local (build landmark)
+    if dir.join(platform::BUILD_LANDMARK).exists() {
+        return Some(dir.clone());
+    }
+
+    // Search up for Lib/os.py (build stdlib landmark)
+    search_up_file(dir, &[platform::BUILDSTDLIB_LANDMARK])
+}
+
+/// Calculate prefix by searching for landmarks
+fn calculate_prefix(exe_dir: &Option<PathBuf>, build_prefix: &Option<PathBuf>) -> String {
+    // 1. If build directory detected, use it
+    if let Some(bp) = build_prefix {
+        return bp.to_string_lossy().into_owned();
+    }
+
+    if let Some(dir) = exe_dir {
+        // 2. Search for ZIP landmark
+        let zip = platform::zip_landmark();
+        if let Some(prefix) = search_up_file(dir, &[&zip]) {
+            return prefix.to_string_lossy().into_owned();
+        }
+
+        // 3. Search for stdlib landmarks (os.py)
+        let landmarks = platform::stdlib_landmarks();
+        let refs: Vec<&str> = landmarks.iter().map(|s| s.as_str()).collect();
+        if let Some(prefix) = search_up_file(dir, &refs) {
+            return prefix.to_string_lossy().into_owned();
+        }
+    }
+
+    // 4. Fallback to default
+    default_prefix()
+}
+
+/// Calculate exec_prefix
+fn calculate_exec_prefix(exe_dir: &Option<PathBuf>, prefix: &str) -> String {
+    #[cfg(windows)]
+    {
+        // Windows: exec_prefix == prefix
+        let _ = exe_dir; // silence unused warning
+        prefix.to_owned()
+    }
+
+    #[cfg(not(windows))]
+    {
+        // POSIX: search for lib-dynload directory
+        if let Some(dir) = exe_dir {
+            let landmark = platform::platstdlib_landmark();
+            if let Some(exec_prefix) = search_up_dir(dir, &[&landmark]) {
+                return exec_prefix.to_string_lossy().into_owned();
+            }
+        }
+        // Fallback: same as prefix
+        prefix.to_owned()
+    }
+}
+
+/// Calculate base_executable
+fn calculate_base_executable(executable: Option<&PathBuf>, home_dir: &Option<PathBuf>) -> String {
+    // If in venv and we have home, construct base_executable from home
+    if let (Some(exe), Some(home)) = (executable, home_dir)
+        && let Some(exe_name) = exe.file_name()
+    {
+        let base = home.join(exe_name);
+        return base.to_string_lossy().into_owned();
+    }
+
+    // Otherwise, base_executable == executable
+    executable
+        .map(|p| p.to_string_lossy().into_owned())
+        .unwrap_or_default()
+}
+
+/// Build the complete module_search_paths (sys.path)
+fn build_module_search_paths(settings: &Settings, prefix: &str, exec_prefix: &str) -> Vec<String> {
+    let mut paths = Vec::new();
+
+    // 1. PYTHONPATH/RUSTPYTHONPATH from settings
+    paths.extend(settings.path_list.iter().cloned());
+
+    // 2. ZIP file path
+    let zip_path = PathBuf::from(prefix).join(platform::zip_landmark());
+    paths.push(zip_path.to_string_lossy().into_owned());
+
+    // 3. stdlib and platstdlib directories
+    #[cfg(not(windows))]
+    {
+        // POSIX: stdlib first, then lib-dynload
+        let stdlib_dir = PathBuf::from(prefix).join(platform::stdlib_subdir());
+        paths.push(stdlib_dir.to_string_lossy().into_owned());
+
+        let platstdlib = PathBuf::from(exec_prefix).join(platform::platstdlib_landmark());
+        paths.push(platstdlib.to_string_lossy().into_owned());
+    }
+
+    #[cfg(windows)]
+    {
+        // Windows: DLLs first, then Lib
+        let platstdlib = PathBuf::from(exec_prefix).join(platform::platstdlib_landmark());
+        paths.push(platstdlib.to_string_lossy().into_owned());
+
+        let stdlib_dir = PathBuf::from(prefix).join(platform::STDLIB_SUBDIR);
+        paths.push(stdlib_dir.to_string_lossy().into_owned());
+    }
+
+    paths
+}
+
+/// Get the current executable path
+fn get_executable_path() -> Option<PathBuf> {
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        let exec_arg = env::args_os().next()?;
+        which::which(exec_arg).ok()
+    }
+    #[cfg(target_arch = "wasm32")]
+    {
+        let exec_arg = env::args().next()?;
+        Some(PathBuf::from(exec_arg))
+    }
+}
+
+/// Parse pyvenv.cfg and extract the 'home' key value
+fn parse_pyvenv_home(pyvenv_cfg: &Path) -> Option<String> {
+    let content = std::fs::read_to_string(pyvenv_cfg).ok()?;
+
+    for line in content.lines() {
+        if let Some((key, value)) = line.split_once('=')
+            && key.trim().to_lowercase() == "home"
+        {
+            return Some(value.trim().to_string());
+        }
+    }
+
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_init_path_config() {
+        let settings = Settings::default();
+        let paths = init_path_config(&settings);
+        // Just verify it doesn't panic and returns valid paths
+        assert!(!paths.prefix.is_empty());
+    }
+
+    #[test]
+    fn test_search_up() {
+        // Test with a path that doesn't have any landmarks
+        let result = search_up_file(std::env::temp_dir(), &["nonexistent_landmark_xyz"]);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_default_prefix() {
+        let prefix = default_prefix();
+        assert!(!prefix.is_empty());
+    }
+}
diff --git a/vm/src/import.rs b/crates/vm/src/import.rs
similarity index 84%
rename from vm/src/import.rs
rename to crates/vm/src/import.rs
index c119405fe1..80ccbe30de 100644
--- a/vm/src/import.rs
+++ b/crates/vm/src/import.rs
@@ -1,13 +1,17 @@
 //! Import mechanics
 
 use crate::{
-    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-    builtins::{PyBaseExceptionRef, PyCode, list, traceback::PyTraceback},
+    AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+    builtins::{PyCode, list, traceback::PyTraceback},
+    exceptions::types::PyBaseException,
     scope::Scope,
-    version::get_git_revision,
-    vm::{VirtualMachine, thread},
+    vm::{VirtualMachine, resolve_frozen_alias, thread},
 };
 
+pub(crate) fn check_pyc_magic_number_bytes(buf: &[u8]) -> bool {
+    buf.starts_with(&crate::version::PYC_MAGIC_NUMBER_BYTES[..2])
+}
+
 pub(crate) fn init_importlib_base(vm: &mut VirtualMachine) -> PyResult<PyObjectRef> {
     flame_guard!("init importlib");
 
@@ -43,16 +47,6 @@ pub(crate) fn init_importlib_package(vm: &VirtualMachine, importlib: PyObjectRef
 
         let install_external = importlib.get_attr("_install_external_importers", vm)?;
         install_external.call((), vm)?;
-        // Set pyc magic number to commit hash. Should be changed when bytecode will be more stable.
-        let importlib_external = vm.import("_frozen_importlib_external", 0)?;
-        let mut magic = get_git_revision().into_bytes();
-        magic.truncate(4);
-        if magic.len() != 4 {
-            // os_random is expensive, but this is only ever called once
-            magic = rustpython_common::rand::os_random::<4>().to_vec();
-        }
-        let magic: PyObjectRef = vm.ctx.new_bytes(magic).into();
-        importlib_external.set_attr("MAGIC_NUMBER", magic, vm)?;
         let zipimport_res = (|| -> PyResult<()> {
             let zipimport = vm.import("zipimport", 0)?;
             let zipimporter = zipimport.get_attr("zipimporter", vm)?;
@@ -79,11 +73,16 @@ pub fn make_frozen(vm: &VirtualMachine, name: &str) -> PyResult<PyRef<PyCode>> {
 }
 
 pub fn import_frozen(vm: &VirtualMachine, module_name: &str) -> PyResult {
-    let frozen = make_frozen(vm, module_name)?;
-    let module = import_code_obj(vm, module_name, frozen, false)?;
+    let frozen = vm.state.frozen.get(module_name).ok_or_else(|| {
+        vm.new_import_error(
+            format!("No such frozen object named {module_name}"),
+            vm.ctx.new_str(module_name),
+        )
+    })?;
+    let module = import_code_obj(vm, module_name, vm.ctx.new_code(frozen.code), false)?;
     debug_assert!(module.get_attr(identifier!(vm, __name__), vm).is_ok());
-    // TODO: give a correct origname here
-    module.set_attr("__origname__", vm.ctx.new_str(module_name.to_owned()), vm)?;
+    let origname = resolve_frozen_alias(module_name);
+    module.set_attr("__origname__", vm.ctx.new_str(origname), vm)?;
     Ok(module)
 }
 
@@ -204,8 +203,8 @@ fn remove_importlib_frames_inner(
 
 // TODO: This function should do nothing on verbose mode.
 // TODO: Fix this function after making PyTraceback.next mutable
-pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &PyBaseExceptionRef) {
-    if vm.state.settings.verbose != 0 {
+pub fn remove_importlib_frames(vm: &VirtualMachine, exc: &Py<PyBaseException>) {
+    if vm.state.config.settings.verbose != 0 {
         return;
     }
 
diff --git a/vm/src/intern.rs b/crates/vm/src/intern.rs
similarity index 89%
rename from vm/src/intern.rs
rename to crates/vm/src/intern.rs
index 8463e3a1c1..a50b8871cb 100644
--- a/vm/src/intern.rs
+++ b/crates/vm/src/intern.rs
@@ -6,10 +6,8 @@ use crate::{
     common::lock::PyRwLock,
     convert::ToPyObject,
 };
-use std::{
-    borrow::{Borrow, ToOwned},
-    ops::Deref,
-};
+use alloc::borrow::ToOwned;
+use core::{borrow::Borrow, ops::Deref};
 
 #[derive(Debug)]
 pub struct StringPool {
@@ -86,8 +84,8 @@ pub struct CachedPyStrRef {
     inner: PyRefExact<PyStr>,
 }
 
-impl std::hash::Hash for CachedPyStrRef {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+impl core::hash::Hash for CachedPyStrRef {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.inner.as_wtf8().hash(state)
     }
 }
@@ -100,7 +98,7 @@ impl PartialEq for CachedPyStrRef {
 
 impl Eq for CachedPyStrRef {}
 
-impl std::borrow::Borrow<Wtf8> for CachedPyStrRef {
+impl core::borrow::Borrow<Wtf8> for CachedPyStrRef {
     #[inline]
     fn borrow(&self) -> &Wtf8 {
         self.as_wtf8()
@@ -119,7 +117,7 @@ impl CachedPyStrRef {
     /// the given cache must be alive while returned reference is alive
     #[inline]
     const unsafe fn as_interned_str(&self) -> &'static PyStrInterned {
-        unsafe { std::mem::transmute_copy(self) }
+        unsafe { core::mem::transmute_copy(self) }
     }
 
     #[inline]
@@ -128,17 +126,14 @@ impl CachedPyStrRef {
     }
 }
 
-pub struct PyInterned<T>
-where
-    T: PyPayload,
-{
+pub struct PyInterned<T> {
     inner: Py<T>,
 }
 
 impl<T: PyPayload> PyInterned<T> {
     #[inline]
     pub fn leak(cache: PyRef<T>) -> &'static Self {
-        unsafe { std::mem::transmute(cache) }
+        unsafe { core::mem::transmute(cache) }
     }
 
     #[inline]
@@ -166,21 +161,21 @@ impl<T: PyPayload> Borrow<PyObject> for PyInterned<T> {
 
 // NOTE: std::hash::Hash of Self and Self::Borrowed *must* be the same
 // This is ok only because PyObject doesn't implement Hash
-impl<T: PyPayload> std::hash::Hash for PyInterned<T> {
+impl<T: PyPayload> core::hash::Hash for PyInterned<T> {
     #[inline(always)]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.get_id().hash(state)
     }
 }
 
-impl<T: PyPayload> AsRef<Py<T>> for PyInterned<T> {
+impl<T> AsRef<Py<T>> for PyInterned<T> {
     #[inline(always)]
     fn as_ref(&self) -> &Py<T> {
         &self.inner
     }
 }
 
-impl<T: PyPayload> Deref for PyInterned<T> {
+impl<T> Deref for PyInterned<T> {
     type Target = Py<T>;
     #[inline(always)]
     fn deref(&self) -> &Self::Target {
@@ -191,15 +186,15 @@ impl<T: PyPayload> Deref for PyInterned<T> {
 impl<T: PyPayload> PartialEq for PyInterned<T> {
     #[inline(always)]
     fn eq(&self, other: &Self) -> bool {
-        std::ptr::eq(self, other)
+        core::ptr::eq(self, other)
     }
 }
 
 impl<T: PyPayload> Eq for PyInterned<T> {}
 
-impl<T: PyPayload + std::fmt::Debug> std::fmt::Debug for PyInterned<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Debug::fmt(&**self, f)?;
+impl<T: core::fmt::Debug + PyPayload> core::fmt::Debug for PyInterned<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(&**self, f)?;
         write!(f, "@{:p}", self.as_ptr())
     }
 }
@@ -311,7 +306,7 @@ impl MaybeInternedString for Py<PyStr> {
     #[inline(always)]
     fn as_interned(&self) -> Option<&'static PyStrInterned> {
         if self.as_object().is_interned() {
-            Some(unsafe { std::mem::transmute::<&Self, &PyInterned<PyStr>>(self) })
+            Some(unsafe { core::mem::transmute::<&Self, &PyInterned<PyStr>>(self) })
         } else {
             None
         }
diff --git a/vm/src/iter.rs b/crates/vm/src/iter.rs
similarity index 100%
rename from vm/src/iter.rs
rename to crates/vm/src/iter.rs
diff --git a/crates/vm/src/lib.rs b/crates/vm/src/lib.rs
new file mode 100644
index 0000000000..3f0eee278a
--- /dev/null
+++ b/crates/vm/src/lib.rs
@@ -0,0 +1,111 @@
+//! This crate contains most of the python logic.
+//!
+//! - Interpreter
+//! - Import mechanics
+//! - Base objects
+//!
+//! Some stdlib modules are implemented here, but most of them are in the `rustpython-stdlib` module. The
+
+// to allow `mod foo {}` in foo.rs; clippy thinks this is a mistake/misunderstanding of
+// how `mod` works, but we want this sometimes for pymodule declarations
+#![allow(clippy::module_inception)]
+// we want to mirror python naming conventions when defining python structs, so that does mean
+// uppercase acronyms, e.g. TextIOWrapper instead of TextIoWrapper
+#![allow(clippy::upper_case_acronyms)]
+#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
+#![doc(html_root_url = "https://docs.rs/rustpython-vm/")]
+
+#[cfg(feature = "flame-it")]
+#[macro_use]
+extern crate flamer;
+
+#[macro_use]
+extern crate bitflags;
+#[macro_use]
+extern crate log;
+// extern crate env_logger;
+extern crate alloc;
+
+#[macro_use]
+extern crate rustpython_derive;
+
+extern crate self as rustpython_vm;
+
+pub use rustpython_derive::*;
+
+//extern crate eval; use eval::eval::*;
+// use py_code_object::{Function, NativeType, PyCodeObject};
+
+// This is above everything else so that the defined macros are available everywhere
+#[macro_use]
+pub(crate) mod macros;
+
+mod anystr;
+pub mod buffer;
+pub mod builtins;
+pub mod byte;
+mod bytes_inner;
+pub mod cformat;
+pub mod class;
+mod codecs;
+pub mod compiler;
+pub mod convert;
+mod coroutine;
+mod dict_inner;
+
+#[cfg(feature = "rustpython-compiler")]
+pub mod eval;
+
+mod exception_group;
+pub mod exceptions;
+pub mod format;
+pub mod frame;
+pub mod function;
+pub mod getpath;
+pub mod import;
+mod intern;
+pub mod iter;
+pub mod object;
+
+#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+pub mod ospath;
+
+pub mod prelude;
+pub mod protocol;
+pub mod py_io;
+
+#[cfg(feature = "serde")]
+pub mod py_serde;
+
+pub mod readline;
+pub mod recursion;
+pub mod scope;
+pub mod sequence;
+pub mod signal;
+pub mod sliceable;
+pub mod stdlib;
+pub mod suggestion;
+pub mod types;
+pub mod utils;
+pub mod version;
+pub mod vm;
+pub mod warn;
+
+#[cfg(windows)]
+pub mod windows;
+
+pub use self::convert::{TryFromBorrowedObject, TryFromObject};
+pub use self::object::{
+    AsObject, Py, PyAtomicRef, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact,
+    PyResult, PyWeakRef,
+};
+pub use self::vm::{Context, Interpreter, Settings, VirtualMachine};
+
+pub use rustpython_common as common;
+pub use rustpython_compiler_core::{bytecode, frozen};
+pub use rustpython_literal as literal;
+
+#[doc(hidden)]
+pub mod __exports {
+    pub use paste;
+}
diff --git a/crates/vm/src/macros.rs b/crates/vm/src/macros.rs
new file mode 100644
index 0000000000..f5c912d89c
--- /dev/null
+++ b/crates/vm/src/macros.rs
@@ -0,0 +1,260 @@
+#[macro_export]
+macro_rules! extend_module {
+    ( $vm:expr, $module:expr, { $($name:expr => $value:expr),* $(,)? }) => {{
+        $(
+            $vm.__module_set_attr($module, $vm.ctx.intern_str($name), $value).unwrap();
+        )*
+    }};
+}
+
+#[macro_export]
+macro_rules! py_class {
+    ( $ctx:expr, $class_name:expr, $class_base:expr, { $($name:tt => $value:expr),* $(,)* }) => {
+        py_class!($ctx, $class_name, $class_base, $crate::types::PyTypeFlags::BASETYPE, { $($name => $value),* })
+    };
+    ( $ctx:expr, $class_name:expr, $class_base:expr, $flags:expr, { $($name:tt => $value:expr),* $(,)* }) => {
+        {
+            #[allow(unused_mut)]
+            let mut slots = $crate::types::PyTypeSlots::heap_default();
+            slots.flags = $flags;
+            $($crate::py_class!(@extract_slots($ctx, &mut slots, $name, $value));)*
+            let py_class = $ctx.new_class(None, $class_name, $class_base, slots);
+            $($crate::py_class!(@extract_attrs($ctx, &py_class, $name, $value));)*
+            py_class
+        }
+    };
+    (@extract_slots($ctx:expr, $slots:expr, (slot $slot_name:ident), $value:expr)) => {
+        $slots.$slot_name.store(Some($value));
+    };
+    (@extract_slots($ctx:expr, $class:expr, $name:expr, $value:expr)) => {};
+    (@extract_attrs($ctx:expr, $slots:expr, (slot $slot_name:ident), $value:expr)) => {};
+    (@extract_attrs($ctx:expr, $class:expr, $name:expr, $value:expr)) => {
+        $class.set_attr($name, $value);
+    };
+}
+
+#[macro_export]
+macro_rules! extend_class {
+    ( $ctx:expr, $class:expr, { $($name:expr => $value:expr),* $(,)* }) => {
+        $(
+            $class.set_attr($ctx.intern_str($name), $value.into());
+        )*
+    };
+}
+
+#[macro_export]
+macro_rules! py_namespace {
+    ( $vm:expr, { $($name:expr => $value:expr),* $(,)* }) => {
+        {
+            let namespace = $crate::object::PyPayload::into_ref($crate::builtins::PyNamespace {}, &$vm.ctx);
+            let obj = $crate::object::AsObject::as_object(&namespace);
+            $(
+                obj.generic_setattr($vm.ctx.intern_str($name), $crate::function::PySetterValue::Assign($value.into()), $vm).unwrap();
+            )*
+            namespace
+        }
+    }
+}
+
+/// Macro to match on the built-in class of a Python object.
+///
+/// Like `match`, `match_class!` must be exhaustive, so a default arm without
+/// casting is required.
+///
+/// # Examples
+///
+/// ```
+/// use malachite_bigint::ToBigInt;
+/// use num_traits::Zero;
+///
+/// use rustpython_vm::match_class;
+/// use rustpython_vm::builtins::{PyFloat, PyInt};
+/// use rustpython_vm::{PyPayload};
+///
+/// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
+/// let obj = PyInt::from(0).into_pyobject(vm);
+/// assert_eq!(
+///     "int",
+///     match_class!(match obj {
+///         PyInt => "int",
+///         PyFloat => "float",
+///         _ => "neither",
+///     })
+/// );
+/// # });
+///
+/// ```
+///
+/// With a binding to the downcasted type:
+///
+/// ```
+/// use malachite_bigint::ToBigInt;
+/// use num_traits::Zero;
+///
+/// use rustpython_vm::match_class;
+/// use rustpython_vm::builtins::{PyFloat, PyInt};
+/// use rustpython_vm::{ PyPayload};
+///
+/// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
+/// let obj = PyInt::from(0).into_pyobject(vm);
+///
+/// let int_value = match_class!(match obj {
+///     i @ PyInt => i.as_bigint().clone(),
+///     f @ PyFloat => f.to_f64().to_bigint().unwrap(),
+///     obj => panic!("non-numeric object {:?}", obj),
+/// });
+///
+/// assert!(int_value.is_zero());
+/// # });
+/// ```
+#[macro_export]
+macro_rules! match_class {
+    // The default arm.
+    (match ($obj:expr) { _ => $default:expr $(,)? }) => {
+        $default
+    };
+
+    // The default arm, binding the original object to the specified identifier.
+    (match ($obj:expr) { $binding:ident => $default:expr $(,)? }) => {{
+        #[allow(clippy::redundant_locals)]
+        let $binding = $obj;
+        $default
+    }};
+    (match ($obj:expr) { ref $binding:ident => $default:expr $(,)? }) => {{
+        #[allow(clippy::redundant_locals)]
+        let $binding = &$obj;
+        $default
+    }};
+
+    // An arm taken when the object is an instance of the specified built-in
+    // class and binding the downcasted object to the specified identifier and
+    // the target expression is a block.
+    (match ($obj:expr) { $binding:ident @ $class:ty => $expr:block $($rest:tt)* }) => {
+        $crate::match_class!(match ($obj) { $binding @ $class => ($expr), $($rest)* })
+    };
+    (match ($obj:expr) { ref $binding:ident @ $class:ty => $expr:block $($rest:tt)* }) => {
+        $crate::match_class!(match ($obj) { ref $binding @ $class => ($expr), $($rest)* })
+    };
+
+    // An arm taken when the object is an instance of the specified built-in
+    // class and binding the downcasted object to the specified identifier.
+    (match ($obj:expr) { $binding:ident @ $class:ty => $expr:expr, $($rest:tt)* }) => {
+        match $obj.downcast::<$class>() {
+            Ok($binding) => $expr,
+            Err(_obj) => $crate::match_class!(match (_obj) { $($rest)* }),
+        }
+    };
+    (match ($obj:expr) { ref $binding:ident @ $class:ty => $expr:expr, $($rest:tt)* }) => {
+        match $obj.downcast_ref::<$class>() {
+            core::option::Option::Some($binding) => $expr,
+            core::option::Option::None => $crate::match_class!(match ($obj) { $($rest)* }),
+        }
+    };
+
+    // An arm taken when the object is an instance of the specified built-in
+    // class and the target expression is a block.
+    (match ($obj:expr) { $class:ty => $expr:block $($rest:tt)* }) => {
+        $crate::match_class!(match ($obj) { $class => ($expr), $($rest)* })
+    };
+
+    // An arm taken when the object is an instance of the specified built-in
+    // class.
+    (match ($obj:expr) { $class:ty => $expr:expr, $($rest:tt)* }) => {
+        if $obj.downcastable::<$class>() {
+            $expr
+        } else {
+            $crate::match_class!(match ($obj) { $($rest)* })
+        }
+    };
+
+    // To allow match expressions without parens around the match target
+    (match $($rest:tt)*) => {
+        $crate::match_class!(@parse_match () ($($rest)*))
+    };
+    (@parse_match ($($target:tt)*) ({ $($inner:tt)* })) => {
+        $crate::match_class!(match ($($target)*) { $($inner)* })
+    };
+    (@parse_match ($($target:tt)*) ($next:tt $($rest:tt)*)) => {
+        $crate::match_class!(@parse_match ($($target)* $next) ($($rest)*))
+    };
+}
+
+#[macro_export]
+macro_rules! identifier(
+    ($as_ctx:expr, $name:ident) => {
+        $as_ctx.as_ref().names.$name
+    };
+);
+
+#[macro_export]
+macro_rules! identifier_utf8(
+    ($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>() }
+    };
+);
+
+/// Super detailed logging. Might soon overflow your log buffers
+/// Default, this logging is discarded, except when a the `vm-tracing-logging`
+/// build feature is enabled.
+macro_rules! vm_trace {
+    ($($arg:tt)+) => {
+        #[cfg(feature = "vm-tracing-logging")]
+        trace!($($arg)+);
+    }
+}
+
+macro_rules! flame_guard {
+    ($name:expr) => {
+        #[cfg(feature = "flame-it")]
+        let _guard = ::flame::start_guard($name);
+    };
+}
+
+#[macro_export]
+macro_rules! class_or_notimplemented {
+    ($t:ty, $obj:expr) => {{
+        let a: &$crate::PyObject = &*$obj;
+        match $crate::PyObject::downcast_ref::<$t>(&a) {
+            Some(pyref) => pyref,
+            None => return Ok($crate::function::PyArithmeticValue::NotImplemented),
+        }
+    }};
+}
+
+#[macro_export]
+macro_rules! named_function {
+    ($ctx:expr, $module:ident, $func:ident) => {{
+        #[allow(unused_variables)] // weird lint, something to do with paste probably
+        let ctx: &$crate::Context = &$ctx;
+        $crate::__exports::paste::expr! {
+            ctx.new_method_def(
+                stringify!($func),
+                [<$module _ $func>],
+                ::rustpython_vm::function::PyMethodFlags::empty(),
+            )
+            .to_function()
+            .with_module(ctx.intern_str(stringify!($module)).into())
+            .into_ref(ctx)
+        }
+    }};
+}
+
+// can't use PyThreadingConstraint for stuff like this since it's not an auto trait, and
+// therefore we can't add it ad-hoc to a trait object
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        macro_rules! py_dyn_fn {
+            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
+                dyn Fn($($arg),*) -> $ret + Send + Sync + 'static
+            };
+        }
+    } else {
+        macro_rules! py_dyn_fn {
+            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
+                dyn Fn($($arg),*) -> $ret + 'static
+            };
+        }
+    }
+}
diff --git a/vm/src/object/core.rs b/crates/vm/src/object/core.rs
similarity index 78%
rename from vm/src/object/core.rs
rename to crates/vm/src/object/core.rs
index bb057f4906..4e51e29646 100644
--- a/vm/src/object/core.rs
+++ b/crates/vm/src/object/core.rs
@@ -13,9 +13,8 @@
 use super::{
     PyAtomicRef,
     ext::{AsObject, PyRefExact, PyResult},
-    payload::PyObjectPayload,
+    payload::PyPayload,
 };
-use crate::object::traverse::{Traverse, TraverseFn};
 use crate::object::traverse_object::PyObjVTable;
 use crate::{
     builtins::{PyDictRef, PyType, PyTypeRef},
@@ -27,12 +26,18 @@ use crate::{
     },
     vm::VirtualMachine,
 };
+use crate::{
+    class::StaticType,
+    object::traverse::{MaybeTraverse, Traverse, TraverseFn},
+};
 use itertools::Itertools;
-use std::{
+
+use alloc::fmt;
+
+use core::{
     any::TypeId,
     borrow::Borrow,
     cell::UnsafeCell,
-    fmt,
     marker::PhantomData,
     mem::ManuallyDrop,
     ops::Deref,
@@ -76,10 +81,10 @@ use std::{
 #[derive(Debug)]
 pub(super) struct Erased;
 
-pub(super) unsafe fn drop_dealloc_obj<T: PyObjectPayload>(x: *mut PyObject) {
+pub(super) unsafe fn drop_dealloc_obj<T: PyPayload>(x: *mut PyObject) {
     drop(unsafe { Box::from_raw(x as *mut PyInner<T>) });
 }
-pub(super) unsafe fn debug_obj<T: PyObjectPayload>(
+pub(super) unsafe fn debug_obj<T: PyPayload + core::fmt::Debug>(
     x: &PyObject,
     f: &mut fmt::Formatter<'_>,
 ) -> fmt::Result {
@@ -88,24 +93,46 @@ pub(super) unsafe fn debug_obj<T: PyObjectPayload>(
 }
 
 /// Call `try_trace` on payload
-pub(super) unsafe fn try_trace_obj<T: PyObjectPayload>(
-    x: &PyObject,
-    tracer_fn: &mut TraverseFn<'_>,
-) {
+pub(super) unsafe fn try_trace_obj<T: PyPayload>(x: &PyObject, tracer_fn: &mut TraverseFn<'_>) {
     let x = unsafe { &*(x as *const PyObject as *const PyInner<T>) };
     let payload = &x.payload;
     payload.try_traverse(tracer_fn)
 }
 
+bitflags::bitflags! {
+    /// GC bits for free-threading support (like ob_gc_bits in Py_GIL_DISABLED)
+    /// These bits are stored in a separate atomic field for lock-free access.
+    /// See Include/internal/pycore_gc.h
+    #[derive(Copy, Clone, Debug, Default)]
+    pub(crate) struct GcBits: u8 {
+        /// Tracked by the GC
+        const TRACKED = 1 << 0;
+        /// tp_finalize was called (prevents __del__ from being called twice)
+        const FINALIZED = 1 << 1;
+        /// Object is unreachable (during GC collection)
+        const UNREACHABLE = 1 << 2;
+        /// Object is frozen (immutable)
+        const FROZEN = 1 << 3;
+        /// Memory the object references is shared between multiple threads
+        /// and needs special handling when freeing due to possible in-flight lock-free reads
+        const SHARED = 1 << 4;
+        /// Memory of the object itself is shared between multiple threads
+        /// Objects with this bit that are GC objects will automatically be delay-freed
+        const SHARED_INLINE = 1 << 5;
+        /// Use deferred reference counting
+        const DEFERRED = 1 << 6;
+    }
+}
+
 /// This is an actual python object. It consists of a `typ` which is the
 /// python class, and carries some rust payload optionally. This rust
 /// payload can be a rust float or rust int in case of float and int objects.
 #[repr(C)]
 pub(super) struct PyInner<T> {
     pub(super) ref_count: RefCount,
-    // TODO: move typeid into vtable once TypeId::of is const
-    pub(super) typeid: TypeId,
     pub(super) vtable: &'static PyObjVTable,
+    /// GC bits for free-threading (like ob_gc_bits)
+    pub(super) gc_bits: PyAtomic<u8>,
 
     pub(super) typ: PyAtomicRef<PyType>, // __class__ member
     pub(super) dict: Option<InstanceDict>,
@@ -114,6 +141,7 @@ pub(super) struct PyInner<T> {
 
     pub(super) payload: T,
 }
+pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = core::mem::size_of::<PyInner<()>>();
 
 impl<T: fmt::Debug> fmt::Debug for PyInner<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -121,7 +149,7 @@ impl<T: fmt::Debug> fmt::Debug for PyInner<T> {
     }
 }
 
-unsafe impl<T: PyObjectPayload> Traverse for Py<T> {
+unsafe impl<T: MaybeTraverse> Traverse for Py<T> {
     /// DO notice that call `trace` on `Py<T>` means apply `tracer_fn` on `Py<T>`'s children,
     /// not like call `trace` on `PyRef<T>` which apply `tracer_fn` on `PyRef<T>` itself
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
@@ -192,12 +220,10 @@ impl WeakRefList {
             }))
         });
         let mut inner = unsafe { inner_ptr.as_ref().lock() };
-        if is_generic {
-            if 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();
-                }
+        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();
             }
         }
         let obj = PyWeak {
@@ -377,7 +403,7 @@ impl PyWeak {
             let node_ptr = unsafe { NonNull::new_unchecked(py_inner as *mut Py<Self>) };
             // the list doesn't have ownership over its PyRef<PyWeak>! we're being dropped
             // right now so that should be obvious!!
-            std::mem::forget(unsafe { guard.list.remove(node_ptr) });
+            core::mem::forget(unsafe { guard.list.remove(node_ptr) });
             guard.ref_count -= 1;
             if Some(node_ptr) == guard.generic_weakref {
                 guard.generic_weakref = None;
@@ -439,22 +465,22 @@ impl InstanceDict {
 
     #[inline]
     pub fn replace(&self, d: PyDictRef) -> PyDictRef {
-        std::mem::replace(&mut self.d.write(), d)
+        core::mem::replace(&mut self.d.write(), d)
     }
 }
 
-impl<T: PyObjectPayload> PyInner<T> {
+impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
     fn new(payload: T, typ: PyTypeRef, dict: Option<PyDictRef>) -> Box<Self> {
         let member_count = typ.slots.member_count;
         Box::new(Self {
             ref_count: RefCount::new(),
-            typeid: TypeId::of::<T>(),
             vtable: PyObjVTable::of::<T>(),
+            gc_bits: Radium::new(0),
             typ: PyAtomicRef::from(typ),
             dict: dict.map(InstanceDict::new),
             weak_list: WeakRefList::new(),
             payload,
-            slots: std::iter::repeat_with(|| PyRwLock::new(None))
+            slots: core::iter::repeat_with(|| PyRwLock::new(None))
                 .take(member_count)
                 .collect_vec()
                 .into_boxed_slice(),
@@ -514,7 +540,7 @@ impl PyObjectRef {
     #[inline(always)]
     pub const fn into_raw(self) -> NonNull<PyObject> {
         let ptr = self.ptr;
-        std::mem::forget(self);
+        core::mem::forget(self);
         ptr
     }
 
@@ -533,23 +559,17 @@ impl PyObjectRef {
     /// If the downcast fails, the original ref is returned in as `Err` so
     /// another downcast can be attempted without unnecessary cloning.
     #[inline(always)]
-    pub fn downcast<T: PyObjectPayload>(self) -> Result<PyRef<T>, Self> {
-        if self.payload_is::<T>() {
+    pub fn downcast<T: PyPayload>(self) -> Result<PyRef<T>, Self> {
+        if self.downcastable::<T>() {
             Ok(unsafe { self.downcast_unchecked() })
         } else {
             Err(self)
         }
     }
 
-    #[inline(always)]
-    pub fn downcast_ref<T: PyObjectPayload>(&self) -> Option<&Py<T>> {
-        if self.payload_is::<T>() {
-            // SAFETY: just checked that the payload is T, and PyRef is repr(transparent) over
-            // PyObjectRef
-            Some(unsafe { &*(self as *const Self as *const PyRef<T>) })
-        } else {
-            None
-        }
+    pub fn try_downcast<T: PyPayload>(self, vm: &VirtualMachine) -> PyResult<PyRef<T>> {
+        T::try_downcast_from(&self, vm)?;
+        Ok(unsafe { self.downcast_unchecked() })
     }
 
     /// Force to downcast this reference to a subclass.
@@ -557,7 +577,7 @@ impl PyObjectRef {
     /// # Safety
     /// T must be the exact payload type
     #[inline(always)]
-    pub unsafe fn downcast_unchecked<T: PyObjectPayload>(self) -> PyRef<T> {
+    pub unsafe fn downcast_unchecked<T>(self) -> PyRef<T> {
         // PyRef::from_obj_unchecked(self)
         // manual impl to avoid assertion
         let obj = ManuallyDrop::new(self);
@@ -566,15 +586,6 @@ impl PyObjectRef {
         }
     }
 
-    /// # Safety
-    /// T must be the exact payload type
-    #[inline(always)]
-    pub unsafe fn downcast_unchecked_ref<T: PyObjectPayload>(&self) -> &Py<T> {
-        debug_assert!(self.payload_is::<T>());
-        // SAFETY: requirements forwarded from caller
-        unsafe { &*(self as *const Self as *const PyRef<T>) }
-    }
-
     // ideally we'd be able to define these in pyobject.rs, but method visibility rules are weird
 
     /// Attempt to downcast this reference to the specific class that is associated `T`.
@@ -582,17 +593,14 @@ impl PyObjectRef {
     /// If the downcast fails, the original ref is returned in as `Err` so
     /// another downcast can be attempted without unnecessary cloning.
     #[inline]
-    pub fn downcast_exact<T: PyObjectPayload + crate::PyPayload>(
-        self,
-        vm: &VirtualMachine,
-    ) -> Result<PyRefExact<T>, Self> {
+    pub fn downcast_exact<T: PyPayload>(self, vm: &VirtualMachine) -> Result<PyRefExact<T>, Self> {
         if self.class().is(T::class(&vm.ctx)) {
             // TODO: is this always true?
             assert!(
-                self.payload_is::<T>(),
+                self.downcastable::<T>(),
                 "obj.__class__ is T::class() but payload is not T"
             );
-            // SAFETY: just asserted that payload_is::<T>()
+            // SAFETY: just asserted that downcastable::<T>()
             Ok(unsafe { PyRefExact::new_unchecked(PyRef::from_obj_unchecked(self)) })
         } else {
             Err(self)
@@ -653,26 +661,31 @@ impl PyObject {
         self.weak_ref_list().map(|wrl| wrl.get_weak_references())
     }
 
+    #[deprecated(note = "use downcastable instead")]
     #[inline(always)]
-    pub fn payload_is<T: PyObjectPayload>(&self) -> bool {
-        self.0.typeid == TypeId::of::<T>()
+    pub fn payload_is<T: PyPayload>(&self) -> bool {
+        self.0.vtable.typeid == T::PAYLOAD_TYPE_ID
     }
 
     /// Force to return payload as T.
     ///
     /// # Safety
     /// The actual payload type must be T.
+    #[deprecated(note = "use downcast_unchecked_ref instead")]
     #[inline(always)]
-    pub const unsafe fn payload_unchecked<T: PyObjectPayload>(&self) -> &T {
+    pub const unsafe fn payload_unchecked<T: PyPayload>(&self) -> &T {
         // we cast to a PyInner<T> first because we don't know T's exact offset because of
         // varying alignment, but once we get a PyInner<T> the compiler can get it for us
         let inner = unsafe { &*(&self.0 as *const PyInner<Erased> as *const PyInner<T>) };
         &inner.payload
     }
 
+    #[deprecated(note = "use downcast_ref instead")]
     #[inline(always)]
-    pub fn payload<T: PyObjectPayload>(&self) -> Option<&T> {
+    pub fn payload<T: PyPayload>(&self) -> Option<&T> {
+        #[allow(deprecated)]
         if self.payload_is::<T>() {
+            #[allow(deprecated)]
             Some(unsafe { self.payload_unchecked() })
         } else {
             None
@@ -688,12 +701,11 @@ impl PyObject {
         self.0.typ.swap_to_temporary_refs(typ, vm);
     }
 
+    #[deprecated(note = "use downcast_ref_if_exact instead")]
     #[inline(always)]
-    pub fn payload_if_exact<T: PyObjectPayload + crate::PyPayload>(
-        &self,
-        vm: &VirtualMachine,
-    ) -> Option<&T> {
+    pub fn payload_if_exact<T: PyPayload>(&self, vm: &VirtualMachine) -> Option<&T> {
         if self.class().is(T::class(&vm.ctx)) {
+            #[allow(deprecated)]
             self.payload()
         } else {
             None
@@ -722,18 +734,41 @@ impl PyObject {
         }
     }
 
+    #[deprecated(note = "use downcast_ref instead")]
     #[inline(always)]
     pub fn payload_if_subclass<T: crate::PyPayload>(&self, vm: &VirtualMachine) -> Option<&T> {
         if self.class().fast_issubclass(T::class(&vm.ctx)) {
+            #[allow(deprecated)]
             self.payload()
         } else {
             None
         }
     }
 
+    #[inline]
+    pub(crate) fn typeid(&self) -> TypeId {
+        self.0.vtable.typeid
+    }
+
+    /// Check if this object can be downcast to T.
     #[inline(always)]
-    pub fn downcast_ref<T: PyObjectPayload>(&self) -> Option<&Py<T>> {
-        if self.payload_is::<T>() {
+    pub fn downcastable<T: PyPayload>(&self) -> bool {
+        T::downcastable_from(self)
+    }
+
+    /// Attempt to downcast this reference to a subclass.
+    pub fn try_downcast_ref<'a, T: PyPayload>(
+        &'a self,
+        vm: &VirtualMachine,
+    ) -> PyResult<&'a Py<T>> {
+        T::try_downcast_from(self, vm)?;
+        Ok(unsafe { self.downcast_unchecked_ref::<T>() })
+    }
+
+    /// Attempt to downcast this reference to a subclass.
+    #[inline(always)]
+    pub fn downcast_ref<T: PyPayload>(&self) -> Option<&Py<T>> {
+        if self.downcastable::<T>() {
             // SAFETY: just checked that the payload is T, and PyRef is repr(transparent) over
             // PyObjectRef
             Some(unsafe { self.downcast_unchecked_ref::<T>() })
@@ -743,10 +778,7 @@ impl PyObject {
     }
 
     #[inline(always)]
-    pub fn downcast_ref_if_exact<T: PyObjectPayload + crate::PyPayload>(
-        &self,
-        vm: &VirtualMachine,
-    ) -> Option<&Py<T>> {
+    pub fn downcast_ref_if_exact<T: PyPayload>(&self, vm: &VirtualMachine) -> Option<&Py<T>> {
         self.class()
             .is(T::class(&vm.ctx))
             .then(|| unsafe { self.downcast_unchecked_ref::<T>() })
@@ -755,8 +787,8 @@ impl PyObject {
     /// # Safety
     /// T must be the exact payload type
     #[inline(always)]
-    pub unsafe fn downcast_unchecked_ref<T: PyObjectPayload>(&self) -> &Py<T> {
-        debug_assert!(self.payload_is::<T>());
+    pub unsafe fn downcast_unchecked_ref<T: PyPayload>(&self) -> &Py<T> {
+        debug_assert!(self.downcastable::<T>());
         // SAFETY: requirements forwarded from caller
         unsafe { &*(self as *const Self as *const Py<T>) }
     }
@@ -776,6 +808,23 @@ impl PyObject {
         self
     }
 
+    /// Check if the object has been finalized (__del__ already called).
+    /// _PyGC_FINALIZED in Py_GIL_DISABLED mode.
+    #[inline]
+    fn gc_finalized(&self) -> bool {
+        use core::sync::atomic::Ordering::Relaxed;
+        GcBits::from_bits_retain(self.0.gc_bits.load(Relaxed)).contains(GcBits::FINALIZED)
+    }
+
+    /// Mark the object as finalized. Should be called before __del__.
+    /// _PyGC_SET_FINALIZED in Py_GIL_DISABLED mode.
+    #[inline]
+    fn set_gc_finalized(&self) {
+        use core::sync::atomic::Ordering::Relaxed;
+        // Atomic RMW to avoid clobbering other concurrent bit updates.
+        self.0.gc_bits.fetch_or(GcBits::FINALIZED.bits(), Relaxed);
+    }
+
     #[inline(always)] // the outer function is never inlined
     fn drop_slow_inner(&self) -> Result<(), ()> {
         // __del__ is mostly not implemented
@@ -805,9 +854,12 @@ impl PyObject {
             }
         }
 
-        // CPython-compatible drop implementation
-        let del = self.class().mro_find_map(|cls| cls.slots.del.load());
-        if let Some(slot_del) = del {
+        // __del__ should only be called once (like _PyGC_FINALIZED check in GIL_DISABLED)
+        let del = self.class().slots.del.load();
+        if let Some(slot_del) = del
+            && !self.gc_finalized()
+        {
+            self.set_gc_finalized();
             call_slot_del(self, slot_del)?;
         }
         if let Some(wrl) = self.weak_ref_list() {
@@ -862,7 +914,7 @@ impl AsRef<PyObject> for PyObjectRef {
     }
 }
 
-impl<'a, T: PyObjectPayload> From<&'a Py<T>> for &'a PyObject {
+impl<'a, T: PyPayload> From<&'a Py<T>> for &'a PyObject {
     #[inline(always)]
     fn from(py_ref: &'a Py<T>) -> Self {
         py_ref.as_object()
@@ -893,9 +945,9 @@ impl fmt::Debug for PyObjectRef {
 }
 
 #[repr(transparent)]
-pub struct Py<T: PyObjectPayload>(PyInner<T>);
+pub struct Py<T>(PyInner<T>);
 
-impl<T: PyObjectPayload> Py<T> {
+impl<T: PyPayload> Py<T> {
     pub fn downgrade(
         &self,
         callback: Option<PyObjectRef>,
@@ -906,9 +958,14 @@ impl<T: PyObjectPayload> Py<T> {
             _marker: PhantomData,
         })
     }
+
+    #[inline]
+    pub fn payload(&self) -> &T {
+        &self.0.payload
+    }
 }
 
-impl<T: PyObjectPayload> ToOwned for Py<T> {
+impl<T> ToOwned for Py<T> {
     type Owned = PyRef<T>;
 
     #[inline(always)]
@@ -920,7 +977,7 @@ impl<T: PyObjectPayload> ToOwned for Py<T> {
     }
 }
 
-impl<T: PyObjectPayload> Deref for Py<T> {
+impl<T> Deref for Py<T> {
     type Target = T;
 
     #[inline(always)]
@@ -929,26 +986,26 @@ impl<T: PyObjectPayload> Deref for Py<T> {
     }
 }
 
-impl<T: PyObjectPayload> Borrow<PyObject> for Py<T> {
+impl<T: PyPayload> Borrow<PyObject> for Py<T> {
     #[inline(always)]
     fn borrow(&self) -> &PyObject {
         unsafe { &*(&self.0 as *const PyInner<T> as *const PyObject) }
     }
 }
 
-impl<T> std::hash::Hash for Py<T>
+impl<T> core::hash::Hash for Py<T>
 where
-    T: std::hash::Hash + PyObjectPayload,
+    T: core::hash::Hash + PyPayload,
 {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.deref().hash(state)
     }
 }
 
 impl<T> PartialEq for Py<T>
 where
-    T: PartialEq + PyObjectPayload,
+    T: PartialEq + PyPayload,
 {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -956,11 +1013,11 @@ where
     }
 }
 
-impl<T> Eq for Py<T> where T: Eq + PyObjectPayload {}
+impl<T> Eq for Py<T> where T: Eq + PyPayload {}
 
 impl<T> AsRef<PyObject> for Py<T>
 where
-    T: PyObjectPayload,
+    T: PyPayload,
 {
     #[inline(always)]
     fn as_ref(&self) -> &PyObject {
@@ -968,7 +1025,7 @@ where
     }
 }
 
-impl<T: PyObjectPayload> fmt::Debug for Py<T> {
+impl<T: PyPayload + core::fmt::Debug> fmt::Debug for Py<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(f)
     }
@@ -984,24 +1041,24 @@ impl<T: PyObjectPayload> fmt::Debug for Py<T> {
 /// situations (such as when implementing in-place methods such as `__iadd__`)
 /// where a reference to the same object must be returned.
 #[repr(transparent)]
-pub struct PyRef<T: PyObjectPayload> {
+pub struct PyRef<T> {
     ptr: NonNull<Py<T>>,
 }
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "threading")] {
-        unsafe impl<T: PyObjectPayload> Send for PyRef<T> {}
-        unsafe impl<T: PyObjectPayload> Sync for PyRef<T> {}
+        unsafe impl<T> Send for PyRef<T> {}
+        unsafe impl<T> Sync for PyRef<T> {}
     }
 }
 
-impl<T: PyObjectPayload> fmt::Debug for PyRef<T> {
+impl<T: fmt::Debug> fmt::Debug for PyRef<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         (**self).fmt(f)
     }
 }
 
-impl<T: PyObjectPayload> Drop for PyRef<T> {
+impl<T> Drop for PyRef<T> {
     #[inline]
     fn drop(&mut self) {
         if self.0.ref_count.dec() {
@@ -1010,31 +1067,51 @@ impl<T: PyObjectPayload> Drop for PyRef<T> {
     }
 }
 
-impl<T: PyObjectPayload> Clone for PyRef<T> {
+impl<T> Clone for PyRef<T> {
     #[inline(always)]
     fn clone(&self) -> Self {
         (**self).to_owned()
     }
 }
 
-impl<T: PyObjectPayload> PyRef<T> {
+impl<T: PyPayload> PyRef<T> {
+    // #[inline(always)]
+    // pub(crate) const fn into_non_null(self) -> NonNull<Py<T>> {
+    //     let ptr = self.ptr;
+    //     std::mem::forget(self);
+    //     ptr
+    // }
+
+    #[inline(always)]
+    pub(crate) const unsafe fn from_non_null(ptr: NonNull<Py<T>>) -> Self {
+        Self { ptr }
+    }
+
+    /// # Safety
+    /// The raw pointer must point to a valid `Py<T>` object
     #[inline(always)]
     pub(crate) const unsafe fn from_raw(raw: *const Py<T>) -> Self {
-        Self {
-            ptr: unsafe { NonNull::new_unchecked(raw as *mut _) },
-        }
+        unsafe { Self::from_non_null(NonNull::new_unchecked(raw as *mut _)) }
     }
 
     /// Safety: payload type of `obj` must be `T`
     #[inline(always)]
     unsafe fn from_obj_unchecked(obj: PyObjectRef) -> Self {
-        debug_assert!(obj.payload_is::<T>());
+        debug_assert!(obj.downcast_ref::<T>().is_some());
         let obj = ManuallyDrop::new(obj);
         Self {
             ptr: obj.ptr.cast(),
         }
     }
 
+    pub const fn leak(pyref: Self) -> &'static Py<T> {
+        let ptr = pyref.ptr;
+        core::mem::forget(pyref);
+        unsafe { ptr.as_ref() }
+    }
+}
+
+impl<T: PyPayload + core::fmt::Debug> PyRef<T> {
     #[inline(always)]
     pub fn new_ref(payload: T, typ: crate::builtins::PyTypeRef, dict: Option<PyDictRef>) -> Self {
         let inner = Box::into_raw(PyInner::new(payload, typ, dict));
@@ -1042,17 +1119,62 @@ impl<T: PyObjectPayload> PyRef<T> {
             ptr: unsafe { NonNull::new_unchecked(inner.cast::<Py<T>>()) },
         }
     }
+}
 
-    pub const fn leak(pyref: Self) -> &'static Py<T> {
-        let ptr = pyref.ptr;
-        std::mem::forget(pyref);
-        unsafe { ptr.as_ref() }
+impl<T: crate::class::PySubclass + core::fmt::Debug> PyRef<T>
+where
+    T::Base: core::fmt::Debug,
+{
+    /// Converts this reference to the base type (ownership transfer).
+    /// # Safety
+    /// T and T::Base must have compatible layouts in size_of::<T::Base>() bytes.
+    #[inline]
+    pub fn into_base(self) -> PyRef<T::Base> {
+        let obj: PyObjectRef = self.into();
+        match obj.downcast() {
+            Ok(base_ref) => base_ref,
+            Err(_) => unsafe { core::hint::unreachable_unchecked() },
+        }
+    }
+    #[inline]
+    pub fn upcast<U: PyPayload + StaticType>(self) -> PyRef<U>
+    where
+        T: StaticType,
+    {
+        debug_assert!(T::static_type().is_subtype(U::static_type()));
+        let obj: PyObjectRef = self.into();
+        match obj.downcast::<U>() {
+            Ok(upcast_ref) => upcast_ref,
+            Err(_) => unsafe { core::hint::unreachable_unchecked() },
+        }
+    }
+}
+
+impl<T: crate::class::PySubclass> Py<T> {
+    /// Converts `&Py<T>` to `&Py<T::Base>`.
+    #[inline]
+    pub fn to_base(&self) -> &Py<T::Base> {
+        debug_assert!(self.as_object().downcast_ref::<T::Base>().is_some());
+        // SAFETY: T is #[repr(transparent)] over T::Base,
+        // so Py<T> and Py<T::Base> have the same layout.
+        unsafe { &*(self as *const Py<T> as *const Py<T::Base>) }
+    }
+
+    /// Converts `&Py<T>` to `&Py<U>` where U is an ancestor type.
+    #[inline]
+    pub fn upcast_ref<U: PyPayload + StaticType>(&self) -> &Py<U>
+    where
+        T: StaticType,
+    {
+        debug_assert!(T::static_type().is_subtype(U::static_type()));
+        // SAFETY: T is a subtype of U, so Py<T> can be viewed as Py<U>.
+        unsafe { &*(self as *const Py<T> as *const Py<U>) }
     }
 }
 
 impl<T> Borrow<PyObject> for PyRef<T>
 where
-    T: PyObjectPayload,
+    T: PyPayload,
 {
     #[inline(always)]
     fn borrow(&self) -> &PyObject {
@@ -1062,7 +1184,7 @@ where
 
 impl<T> AsRef<PyObject> for PyRef<T>
 where
-    T: PyObjectPayload,
+    T: PyPayload,
 {
     #[inline(always)]
     fn as_ref(&self) -> &PyObject {
@@ -1070,10 +1192,7 @@ where
     }
 }
 
-impl<T> From<PyRef<T>> for PyObjectRef
-where
-    T: PyObjectPayload,
-{
+impl<T> From<PyRef<T>> for PyObjectRef {
     #[inline]
     fn from(value: PyRef<T>) -> Self {
         let me = ManuallyDrop::new(value);
@@ -1081,30 +1200,21 @@ where
     }
 }
 
-impl<T> Borrow<Py<T>> for PyRef<T>
-where
-    T: PyObjectPayload,
-{
+impl<T> Borrow<Py<T>> for PyRef<T> {
     #[inline(always)]
     fn borrow(&self) -> &Py<T> {
         self
     }
 }
 
-impl<T> AsRef<Py<T>> for PyRef<T>
-where
-    T: PyObjectPayload,
-{
+impl<T> AsRef<Py<T>> for PyRef<T> {
     #[inline(always)]
     fn as_ref(&self) -> &Py<T> {
         self
     }
 }
 
-impl<T> Deref for PyRef<T>
-where
-    T: PyObjectPayload,
-{
+impl<T> Deref for PyRef<T> {
     type Target = Py<T>;
 
     #[inline(always)]
@@ -1113,19 +1223,19 @@ where
     }
 }
 
-impl<T> std::hash::Hash for PyRef<T>
+impl<T> core::hash::Hash for PyRef<T>
 where
-    T: std::hash::Hash + PyObjectPayload,
+    T: core::hash::Hash + PyPayload,
 {
     #[inline]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
         self.deref().hash(state)
     }
 }
 
 impl<T> PartialEq for PyRef<T>
 where
-    T: PartialEq + PyObjectPayload,
+    T: PartialEq + PyPayload,
 {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
@@ -1133,15 +1243,15 @@ where
     }
 }
 
-impl<T> Eq for PyRef<T> where T: Eq + PyObjectPayload {}
+impl<T> Eq for PyRef<T> where T: Eq + PyPayload {}
 
 #[repr(transparent)]
-pub struct PyWeakRef<T: PyObjectPayload> {
+pub struct PyWeakRef<T: PyPayload> {
     weak: PyRef<PyWeak>,
     _marker: PhantomData<T>,
 }
 
-impl<T: PyObjectPayload> PyWeakRef<T> {
+impl<T: PyPayload> PyWeakRef<T> {
     pub fn upgrade(&self) -> Option<PyRef<T>> {
         self.weak
             .upgrade()
@@ -1167,10 +1277,10 @@ macro_rules! partially_init {
                 $($uninit_field: unreachable!(),)*
             }};
         }
-        let mut m = ::std::mem::MaybeUninit::<$ty>::uninit();
+        let mut m = ::core::mem::MaybeUninit::<$ty>::uninit();
         #[allow(unused_unsafe)]
         unsafe {
-            $(::std::ptr::write(&mut (*m.as_mut_ptr()).$init_field, $init_value);)*
+            $(::core::ptr::write(&mut (*m.as_mut_ptr()).$init_field, $init_value);)*
         }
         m
     }};
@@ -1178,7 +1288,7 @@ macro_rules! partially_init {
 
 pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
     use crate::{builtins::object, class::PyClassImpl};
-    use std::mem::MaybeUninit;
+    use core::mem::MaybeUninit;
 
     // `type` inherits from `object`
     // and both `type` and `object are instances of `type`.
@@ -1211,8 +1321,8 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         let type_type_ptr = Box::into_raw(Box::new(partially_init!(
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
-                typeid: TypeId::of::<PyType>(),
                 vtable: PyObjVTable::of::<PyType>(),
+                gc_bits: Radium::new(0),
                 dict: None,
                 weak_list: WeakRefList::new(),
                 payload: type_payload,
@@ -1223,8 +1333,8 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         let object_type_ptr = Box::into_raw(Box::new(partially_init!(
             PyInner::<PyType> {
                 ref_count: RefCount::new(),
-                typeid: TypeId::of::<PyType>(),
                 vtable: PyObjVTable::of::<PyType>(),
+                gc_bits: Radium::new(0),
                 dict: None,
                 weak_list: WeakRefList::new(),
                 payload: object_payload,
@@ -1245,12 +1355,16 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
             ptr::write(&mut (*type_type_ptr).typ, PyAtomicRef::from(type_type));
 
             let object_type = PyTypeRef::from_raw(object_type_ptr.cast());
+            // object's mro is [object]
+            (*object_type_ptr).payload.mro = PyRwLock::new(vec![object_type.clone()]);
 
-            (*type_type_ptr).payload.mro = PyRwLock::new(vec![object_type.clone()]);
             (*type_type_ptr).payload.bases = PyRwLock::new(vec![object_type.clone()]);
             (*type_type_ptr).payload.base = Some(object_type.clone());
 
             let type_type = PyTypeRef::from_raw(type_type_ptr.cast());
+            // type's mro is [type, object]
+            (*type_type_ptr).payload.mro =
+                PyRwLock::new(vec![type_type.clone(), object_type.clone()]);
 
             (type_type, object_type)
         }
@@ -1266,6 +1380,8 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
         heaptype_ext: None,
     };
     let weakref_type = PyRef::new_ref(weakref_type, type_type.clone(), None);
+    // weakref's mro is [weakref, object]
+    weakref_type.mro.write().insert(0, weakref_type.clone());
 
     object_type.subclasses.write().push(
         type_type
diff --git a/vm/src/object/ext.rs b/crates/vm/src/object/ext.rs
similarity index 88%
rename from vm/src/object/ext.rs
rename to crates/vm/src/object/ext.rs
index 2815d2b20e..c1a5f63f85 100644
--- a/vm/src/object/ext.rs
+++ b/crates/vm/src/object/ext.rs
@@ -1,6 +1,6 @@
 use super::{
     core::{Py, PyObject, PyObjectRef, PyRef},
-    payload::{PyObjectPayload, PyPayload},
+    payload::PyPayload,
 };
 use crate::common::{
     atomic::{Ordering, PyAtomic, Radium},
@@ -12,9 +12,10 @@ use crate::{
     convert::{IntoPyException, ToPyObject, ToPyResult, TryFromObject},
     vm::Context,
 };
-use std::{
+use alloc::fmt;
+
+use core::{
     borrow::Borrow,
-    fmt,
     marker::PhantomData,
     ops::Deref,
     ptr::{NonNull, null_mut},
@@ -41,7 +42,7 @@ pub type PyResult<T = PyObjectRef> = Result<T, PyBaseExceptionRef>; // A valid v
 
 impl<T: fmt::Display> fmt::Display for PyRef<T>
 where
-    T: PyObjectPayload + fmt::Display,
+    T: PyPayload + fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&**self, f)
@@ -50,7 +51,7 @@ where
 
 impl<T: fmt::Display> fmt::Display for Py<T>
 where
-    T: PyObjectPayload + fmt::Display,
+    T: PyPayload + fmt::Display,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&**self, f)
@@ -58,7 +59,7 @@ where
 }
 
 #[repr(transparent)]
-pub struct PyExact<T: PyObjectPayload> {
+pub struct PyExact<T> {
     inner: Py<T>,
 }
 
@@ -80,35 +81,35 @@ impl<T: PyPayload> Deref for PyExact<T> {
     }
 }
 
-impl<T: PyObjectPayload> Borrow<PyObject> for PyExact<T> {
+impl<T: PyPayload> Borrow<PyObject> for PyExact<T> {
     #[inline(always)]
     fn borrow(&self) -> &PyObject {
         self.inner.borrow()
     }
 }
 
-impl<T: PyObjectPayload> AsRef<PyObject> for PyExact<T> {
+impl<T: PyPayload> AsRef<PyObject> for PyExact<T> {
     #[inline(always)]
     fn as_ref(&self) -> &PyObject {
         self.inner.as_ref()
     }
 }
 
-impl<T: PyObjectPayload> Borrow<Py<T>> for PyExact<T> {
+impl<T: PyPayload> Borrow<Py<T>> for PyExact<T> {
     #[inline(always)]
     fn borrow(&self) -> &Py<T> {
         &self.inner
     }
 }
 
-impl<T: PyObjectPayload> AsRef<Py<T>> for PyExact<T> {
+impl<T: PyPayload> AsRef<Py<T>> for PyExact<T> {
     #[inline(always)]
     fn as_ref(&self) -> &Py<T> {
         &self.inner
     }
 }
 
-impl<T: PyPayload> std::borrow::ToOwned for PyExact<T> {
+impl<T: PyPayload> alloc::borrow::ToOwned for PyExact<T> {
     type Owned = PyRefExact<T>;
 
     fn to_owned(&self) -> Self::Owned {
@@ -134,11 +135,11 @@ impl<T: PyPayload> PyRef<T> {
 /// PyRef but guaranteed not to be a subtype instance
 #[derive(Debug)]
 #[repr(transparent)]
-pub struct PyRefExact<T: PyObjectPayload> {
+pub struct PyRefExact<T: PyPayload> {
     inner: PyRef<T>,
 }
 
-impl<T: PyObjectPayload> PyRefExact<T> {
+impl<T: PyPayload> PyRefExact<T> {
     /// # Safety
     /// obj must have exact type for the payload
     pub const unsafe fn new_unchecked(obj: PyRef<T>) -> Self {
@@ -150,7 +151,7 @@ impl<T: PyObjectPayload> PyRefExact<T> {
     }
 }
 
-impl<T: PyObjectPayload> Clone for PyRefExact<T> {
+impl<T: PyPayload> Clone for PyRefExact<T> {
     fn clone(&self) -> Self {
         let inner = self.inner.clone();
         Self { inner }
@@ -191,28 +192,28 @@ impl<T: PyPayload> Deref for PyRefExact<T> {
     }
 }
 
-impl<T: PyObjectPayload> Borrow<PyObject> for PyRefExact<T> {
+impl<T: PyPayload> Borrow<PyObject> for PyRefExact<T> {
     #[inline(always)]
     fn borrow(&self) -> &PyObject {
         self.inner.borrow()
     }
 }
 
-impl<T: PyObjectPayload> AsRef<PyObject> for PyRefExact<T> {
+impl<T: PyPayload> AsRef<PyObject> for PyRefExact<T> {
     #[inline(always)]
     fn as_ref(&self) -> &PyObject {
         self.inner.as_ref()
     }
 }
 
-impl<T: PyObjectPayload> Borrow<Py<T>> for PyRefExact<T> {
+impl<T: PyPayload> Borrow<Py<T>> for PyRefExact<T> {
     #[inline(always)]
     fn borrow(&self) -> &Py<T> {
         self.inner.borrow()
     }
 }
 
-impl<T: PyObjectPayload> AsRef<Py<T>> for PyRefExact<T> {
+impl<T: PyPayload> AsRef<Py<T>> for PyRefExact<T> {
     #[inline(always)]
     fn as_ref(&self) -> &Py<T> {
         self.inner.as_ref()
@@ -245,12 +246,25 @@ pub struct PyAtomicRef<T> {
     _phantom: PhantomData<T>,
 }
 
+impl<T> Drop for PyAtomicRef<T> {
+    fn drop(&mut self) {
+        // SAFETY: We are dropping the atomic reference, so we can safely
+        // release the pointer.
+        unsafe {
+            let ptr = Radium::swap(&self.inner, null_mut(), Ordering::Relaxed);
+            if let Some(ptr) = NonNull::<PyObject>::new(ptr.cast()) {
+                let _: PyObjectRef = PyObjectRef::from_raw(ptr);
+            }
+        }
+    }
+}
+
 cfg_if::cfg_if! {
     if #[cfg(feature = "threading")] {
-        unsafe impl<T: Send + PyObjectPayload> Send for PyAtomicRef<T> {}
-        unsafe impl<T: Sync + PyObjectPayload> Sync for PyAtomicRef<T> {}
-        unsafe impl<T: Send + PyObjectPayload> Send for PyAtomicRef<Option<T>> {}
-        unsafe impl<T: Sync + PyObjectPayload> Sync for PyAtomicRef<Option<T>> {}
+        unsafe impl<T: Send + PyPayload> Send for PyAtomicRef<T> {}
+        unsafe impl<T: Sync + PyPayload> Sync for PyAtomicRef<T> {}
+        unsafe impl<T: Send + PyPayload> Send for PyAtomicRef<Option<T>> {}
+        unsafe impl<T: Sync + PyPayload> Sync for PyAtomicRef<Option<T>> {}
         unsafe impl Send for PyAtomicRef<PyObject> {}
         unsafe impl Sync for PyAtomicRef<PyObject> {}
         unsafe impl Send for PyAtomicRef<Option<PyObject>> {}
@@ -272,7 +286,7 @@ impl<T: fmt::Debug> fmt::Debug for PyAtomicRef<T> {
     }
 }
 
-impl<T: PyObjectPayload> From<PyRef<T>> for PyAtomicRef<T> {
+impl<T: PyPayload> From<PyRef<T>> for PyAtomicRef<T> {
     fn from(pyref: PyRef<T>) -> Self {
         let py = PyRef::leak(pyref);
         Self {
@@ -282,7 +296,7 @@ impl<T: PyObjectPayload> From<PyRef<T>> for PyAtomicRef<T> {
     }
 }
 
-impl<T: PyObjectPayload> Deref for PyAtomicRef<T> {
+impl<T: PyPayload> Deref for PyAtomicRef<T> {
     type Target = Py<T>;
 
     fn deref(&self) -> &Self::Target {
@@ -296,7 +310,7 @@ impl<T: PyObjectPayload> Deref for PyAtomicRef<T> {
     }
 }
 
-impl<T: PyObjectPayload> PyAtomicRef<T> {
+impl<T: PyPayload> PyAtomicRef<T> {
     /// # Safety
     /// The caller is responsible to keep the returned PyRef alive
     /// until no more reference can be used via PyAtomicRef::deref()
@@ -315,7 +329,7 @@ impl<T: PyObjectPayload> PyAtomicRef<T> {
     }
 }
 
-impl<T: PyObjectPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
+impl<T: PyPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
     fn from(opt_ref: Option<PyRef<T>>) -> Self {
         let val = opt_ref
             .map(|x| PyRef::leak(x) as *const Py<T> as *mut _)
@@ -327,7 +341,7 @@ impl<T: PyObjectPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
     }
 }
 
-impl<T: PyObjectPayload> 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() }
     }
@@ -508,25 +522,25 @@ impl PyObject {
 /// `PyObjectRef`, which isn't that cheap as that increments the atomic reference counter.
 // TODO: check if we still need this
 #[allow(dead_code)]
-pub struct PyLease<'a, T: PyObjectPayload> {
+pub struct PyLease<'a, T: PyPayload> {
     inner: PyRwLockReadGuard<'a, PyRef<T>>,
 }
 
-impl<T: PyObjectPayload + PyPayload> PyLease<'_, T> {
+impl<T: PyPayload> PyLease<'_, T> {
     #[inline(always)]
     pub fn into_owned(self) -> PyRef<T> {
         self.inner.clone()
     }
 }
 
-impl<T: PyObjectPayload + PyPayload> Borrow<PyObject> for PyLease<'_, T> {
+impl<T: PyPayload> Borrow<PyObject> for PyLease<'_, T> {
     #[inline(always)]
     fn borrow(&self) -> &PyObject {
         self.inner.as_ref()
     }
 }
 
-impl<T: PyObjectPayload + PyPayload> Deref for PyLease<'_, T> {
+impl<T: PyPayload> Deref for PyLease<'_, T> {
     type Target = PyRef<T>;
     #[inline(always)]
     fn deref(&self) -> &Self::Target {
@@ -543,7 +557,7 @@ where
     }
 }
 
-impl<T: PyObjectPayload> ToPyObject for PyRef<T> {
+impl<T: PyPayload> ToPyObject for PyRef<T> {
     #[inline(always)]
     fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         self.into()
@@ -568,7 +582,7 @@ impl ToPyObject for &PyObject {
 // explicitly implementing `ToPyObject`.
 impl<T> ToPyObject for T
 where
-    T: PyPayload + Sized,
+    T: PyPayload + core::fmt::Debug + Sized,
 {
     #[inline(always)]
     fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
diff --git a/crates/vm/src/object/mod.rs b/crates/vm/src/object/mod.rs
new file mode 100644
index 0000000000..a279201a0b
--- /dev/null
+++ b/crates/vm/src/object/mod.rs
@@ -0,0 +1,11 @@
+mod core;
+mod ext;
+mod payload;
+mod traverse;
+mod traverse_object;
+
+pub use self::core::*;
+pub use self::ext::*;
+pub use self::payload::*;
+pub(crate) use core::SIZEOF_PYOBJECT_HEAD;
+pub use traverse::{MaybeTraverse, Traverse, TraverseFn};
diff --git a/crates/vm/src/object/payload.rs b/crates/vm/src/object/payload.rs
new file mode 100644
index 0000000000..143033ee64
--- /dev/null
+++ b/crates/vm/src/object/payload.rs
@@ -0,0 +1,146 @@
+use crate::object::{MaybeTraverse, Py, PyObjectRef, PyRef, PyResult};
+use crate::{
+    PyObject, PyRefExact,
+    builtins::{PyBaseExceptionRef, PyType, PyTypeRef},
+    types::PyTypeFlags,
+    vm::{Context, VirtualMachine},
+};
+
+cfg_if::cfg_if! {
+    if #[cfg(feature = "threading")] {
+        pub trait PyThreadingConstraint: Send + Sync {}
+        impl<T: Send + Sync> PyThreadingConstraint for T {}
+    } else {
+        pub trait PyThreadingConstraint {}
+        impl<T> PyThreadingConstraint for T {}
+    }
+}
+
+#[cold]
+pub(crate) fn cold_downcast_type_error(
+    vm: &VirtualMachine,
+    class: &Py<PyType>,
+    obj: &PyObject,
+) -> PyBaseExceptionRef {
+    vm.new_downcast_type_error(class, obj)
+}
+
+pub trait PyPayload: MaybeTraverse + PyThreadingConstraint + Sized + 'static {
+    const PAYLOAD_TYPE_ID: core::any::TypeId = core::any::TypeId::of::<Self>();
+
+    /// # Safety: this function should only be called if `payload_type_id` matches the type of `obj`.
+    #[inline]
+    fn downcastable_from(obj: &PyObject) -> bool {
+        obj.typeid() == Self::PAYLOAD_TYPE_ID && Self::validate_downcastable_from(obj)
+    }
+
+    #[inline]
+    fn validate_downcastable_from(_obj: &PyObject) -> bool {
+        true
+    }
+
+    fn try_downcast_from(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+        if Self::downcastable_from(obj) {
+            return Ok(());
+        }
+
+        let class = Self::class(&vm.ctx);
+        Err(cold_downcast_type_error(vm, class, obj))
+    }
+
+    fn class(ctx: &Context) -> &'static Py<PyType>;
+
+    #[inline]
+    fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef
+    where
+        Self: core::fmt::Debug,
+    {
+        self.into_ref(&vm.ctx).into()
+    }
+
+    #[inline]
+    fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>
+    where
+        Self: core::fmt::Debug,
+    {
+        let dict = if cls.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
+            Some(ctx.new_dict())
+        } else {
+            None
+        };
+        PyRef::new_ref(self, cls, dict)
+    }
+
+    #[inline]
+    fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>
+    where
+        Self: core::fmt::Debug,
+    {
+        unsafe {
+            // Self::into_ref() always returns exact typed PyRef
+            PyRefExact::new_unchecked(self.into_ref(ctx))
+        }
+    }
+
+    #[inline]
+    fn into_ref(self, ctx: &Context) -> PyRef<Self>
+    where
+        Self: core::fmt::Debug,
+    {
+        let cls = Self::class(ctx);
+        self._into_ref(cls.to_owned(), ctx)
+    }
+
+    #[inline]
+    fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyTypeRef) -> PyResult<PyRef<Self>>
+    where
+        Self: core::fmt::Debug,
+    {
+        let exact_class = Self::class(&vm.ctx);
+        if cls.fast_issubclass(exact_class) {
+            if exact_class.slots.basicsize != cls.slots.basicsize {
+                #[cold]
+                #[inline(never)]
+                fn _into_ref_size_error(
+                    vm: &VirtualMachine,
+                    cls: &Py<PyType>,
+                    exact_class: &Py<PyType>,
+                ) -> PyBaseExceptionRef {
+                    vm.new_type_error(format!(
+                        "cannot create '{}' instance: size differs from base type '{}'",
+                        cls.name(),
+                        exact_class.name()
+                    ))
+                }
+                return Err(_into_ref_size_error(vm, &cls, exact_class));
+            }
+            Ok(self._into_ref(cls, &vm.ctx))
+        } else {
+            #[cold]
+            #[inline(never)]
+            fn _into_ref_with_type_error(
+                vm: &VirtualMachine,
+                cls: &Py<PyType>,
+                exact_class: &Py<PyType>,
+            ) -> PyBaseExceptionRef {
+                vm.new_type_error(format!(
+                    "'{}' is not a subtype of '{}'",
+                    &cls.name(),
+                    exact_class.name()
+                ))
+            }
+            Err(_into_ref_with_type_error(vm, &cls, exact_class))
+        }
+    }
+}
+
+pub trait PyObjectPayload:
+    PyPayload + core::any::Any + core::fmt::Debug + MaybeTraverse + PyThreadingConstraint + 'static
+{
+}
+
+impl<T: PyPayload + core::fmt::Debug + 'static> PyObjectPayload for T {}
+
+pub trait SlotOffset {
+    fn offset() -> usize;
+}
diff --git a/vm/src/object/traverse.rs b/crates/vm/src/object/traverse.rs
similarity index 99%
rename from vm/src/object/traverse.rs
rename to crates/vm/src/object/traverse.rs
index 31bee8bece..2ce0db41a5 100644
--- a/vm/src/object/traverse.rs
+++ b/crates/vm/src/object/traverse.rs
@@ -1,4 +1,4 @@
-use std::ptr::NonNull;
+use core::ptr::NonNull;
 
 use rustpython_common::lock::{PyMutex, PyRwLock};
 
diff --git a/vm/src/object/traverse_object.rs b/crates/vm/src/object/traverse_object.rs
similarity index 88%
rename from vm/src/object/traverse_object.rs
rename to crates/vm/src/object/traverse_object.rs
index ee32785950..7a66f0b35f 100644
--- a/vm/src/object/traverse_object.rs
+++ b/crates/vm/src/object/traverse_object.rs
@@ -1,15 +1,18 @@
-use std::fmt;
+use alloc::fmt;
+use core::any::TypeId;
 
 use crate::{
     PyObject,
     object::{
-        Erased, InstanceDict, PyInner, PyObjectPayload, debug_obj, drop_dealloc_obj, try_trace_obj,
+        Erased, InstanceDict, MaybeTraverse, PyInner, PyObjectPayload, debug_obj, drop_dealloc_obj,
+        try_trace_obj,
     },
 };
 
 use super::{Traverse, TraverseFn};
 
 pub(in crate::object) struct PyObjVTable {
+    pub(in crate::object) typeid: TypeId,
     pub(in crate::object) drop_dealloc: unsafe fn(*mut PyObject),
     pub(in crate::object) debug: unsafe fn(&PyObject, &mut fmt::Formatter<'_>) -> fmt::Result,
     pub(in crate::object) trace: Option<unsafe fn(&PyObject, &mut TraverseFn<'_>)>,
@@ -18,6 +21,7 @@ pub(in crate::object) struct PyObjVTable {
 impl PyObjVTable {
     pub const fn of<T: PyObjectPayload>() -> &'static Self {
         &Self {
+            typeid: T::PAYLOAD_TYPE_ID,
             drop_dealloc: drop_dealloc_obj::<T>,
             debug: debug_obj::<T>,
             trace: const {
@@ -56,7 +60,7 @@ unsafe impl Traverse for PyInner<Erased> {
     }
 }
 
-unsafe impl<T: PyObjectPayload> Traverse for PyInner<T> {
+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)
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
new file mode 100644
index 0000000000..25fcafb74c
--- /dev/null
+++ b/crates/vm/src/ospath.rs
@@ -0,0 +1,317 @@
+use rustpython_common::crt_fd;
+
+use crate::{
+    PyObjectRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyStr},
+    convert::{IntoPyException, ToPyException, ToPyObject, TryFromObject},
+    function::FsPath,
+};
+use std::path::{Path, PathBuf};
+
+/// path_converter
+#[derive(Clone, Copy, Default)]
+pub struct PathConverter {
+    /// Function name for error messages (e.g., "rename")
+    pub function_name: Option<&'static str>,
+    /// Argument name for error messages (e.g., "src", "dst")
+    pub argument_name: Option<&'static str>,
+    /// If true, embedded null characters are allowed
+    pub non_strict: bool,
+}
+
+impl PathConverter {
+    pub const fn new() -> Self {
+        Self {
+            function_name: None,
+            argument_name: None,
+            non_strict: false,
+        }
+    }
+
+    pub const fn function(mut self, name: &'static str) -> Self {
+        self.function_name = Some(name);
+        self
+    }
+
+    pub const fn argument(mut self, name: &'static str) -> Self {
+        self.argument_name = Some(name);
+        self
+    }
+
+    pub const fn non_strict(mut self) -> Self {
+        self.non_strict = true;
+        self
+    }
+
+    /// Generate error message prefix like "rename: "
+    fn error_prefix(&self) -> String {
+        match self.function_name {
+            Some(func) => format!("{}: ", func),
+            None => String::new(),
+        }
+    }
+
+    /// Get argument name for error messages, defaults to "path"
+    fn arg_name(&self) -> &'static str {
+        self.argument_name.unwrap_or("path")
+    }
+
+    /// Format a type error message
+    fn type_error_msg(&self, type_name: &str, allow_fd: bool) -> String {
+        let expected = if allow_fd {
+            "string, bytes, os.PathLike or integer"
+        } else {
+            "string, bytes or os.PathLike"
+        };
+        format!(
+            "{}{} should be {}, not {}",
+            self.error_prefix(),
+            self.arg_name(),
+            expected,
+            type_name
+        )
+    }
+
+    /// Convert to OsPathOrFd (path or file descriptor)
+    pub(crate) fn try_path_or_fd<'fd>(
+        &self,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<OsPathOrFd<'fd>> {
+        // Handle fd (before __fspath__ check, like CPython)
+        if let Some(int) = obj.try_index_opt(vm) {
+            let fd = int?.try_to_primitive(vm)?;
+            return unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
+                .map(OsPathOrFd::Fd)
+                .map_err(|e| e.into_pyexception(vm));
+        }
+
+        self.try_path_inner(obj, true, vm).map(OsPathOrFd::Path)
+    }
+
+    /// Convert to OsPath only (no fd support)
+    fn try_path_inner(
+        &self,
+        obj: PyObjectRef,
+        allow_fd: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<OsPath> {
+        // Try direct str/bytes match
+        let obj = match self.try_match_str_bytes(obj.clone(), vm)? {
+            Ok(path) => return Ok(path),
+            Err(obj) => obj,
+        };
+
+        // Call __fspath__
+        let type_error_msg = || self.type_error_msg(&obj.class().name(), allow_fd);
+        let method =
+            vm.get_method_or_type_error(obj.clone(), identifier!(vm, __fspath__), type_error_msg)?;
+        if vm.is_none(&method) {
+            return Err(vm.new_type_error(type_error_msg()));
+        }
+        let result = method.call((), vm)?;
+
+        // Match __fspath__ result
+        self.try_match_str_bytes(result.clone(), vm)?.map_err(|_| {
+            vm.new_type_error(format!(
+                "{}expected {}.__fspath__() to return str or bytes, not {}",
+                self.error_prefix(),
+                obj.class().name(),
+                result.class().name(),
+            ))
+        })
+    }
+
+    /// Try to match str or bytes, returns Err(obj) if neither
+    fn try_match_str_bytes(
+        &self,
+        obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Result<OsPath, PyObjectRef>> {
+        let check_nul = |b: &[u8]| {
+            if self.non_strict || memchr::memchr(b'\0', b).is_none() {
+                Ok(())
+            } else {
+                Err(vm.new_value_error(format!(
+                    "{}embedded null character in {}",
+                    self.error_prefix(),
+                    self.arg_name()
+                )))
+            }
+        };
+
+        match_class!(match obj {
+            s @ PyStr => {
+                check_nul(s.as_bytes())?;
+                let path = vm.fsencode(&s)?.into_owned();
+                Ok(Ok(OsPath {
+                    path,
+                    origin: Some(s.into()),
+                }))
+            }
+            b @ PyBytes => {
+                check_nul(&b)?;
+                let path = FsPath::bytes_as_os_str(&b, vm)?.to_owned();
+                Ok(Ok(OsPath {
+                    path,
+                    origin: Some(b.into()),
+                }))
+            }
+            obj => Ok(Err(obj)),
+        })
+    }
+
+    /// Convert to OsPath directly
+    pub fn try_path(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<OsPath> {
+        self.try_path_inner(obj, false, vm)
+    }
+}
+
+/// path_t output - the converted path
+#[derive(Clone)]
+pub struct OsPath {
+    pub path: std::ffi::OsString,
+    /// Original Python object for identity preservation in OSError
+    pub(super) origin: Option<PyObjectRef>,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum OutputMode {
+    String,
+    Bytes,
+}
+
+impl OutputMode {
+    pub(super) fn process_path(self, path: impl Into<PathBuf>, vm: &VirtualMachine) -> PyObjectRef {
+        fn inner(mode: OutputMode, path: PathBuf, vm: &VirtualMachine) -> PyObjectRef {
+            match mode {
+                OutputMode::String => vm.fsdecode(path).into(),
+                OutputMode::Bytes => vm
+                    .ctx
+                    .new_bytes(path.into_os_string().into_encoded_bytes())
+                    .into(),
+            }
+        }
+        inner(self, path.into(), vm)
+    }
+}
+
+impl OsPath {
+    pub fn new_str(path: impl Into<std::ffi::OsString>) -> Self {
+        let path = path.into();
+        Self { path, origin: None }
+    }
+
+    pub(crate) fn from_fspath(fspath: FsPath, vm: &VirtualMachine) -> PyResult<Self> {
+        let path = fspath.as_os_str(vm)?.into_owned();
+        let origin = match fspath {
+            FsPath::Str(s) => s.into(),
+            FsPath::Bytes(b) => b.into(),
+        };
+        Ok(Self {
+            path,
+            origin: Some(origin),
+        })
+    }
+
+    /// Convert an object to OsPath using the os.fspath-style error message.
+    /// This is used by open() which should report "expected str, bytes or os.PathLike object, not"
+    /// instead of "should be string, bytes or os.PathLike, not".
+    pub(crate) fn try_from_fspath(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
+        let fspath = FsPath::try_from_path_like(obj, true, vm)?;
+        Self::from_fspath(fspath, vm)
+    }
+
+    pub fn as_path(&self) -> &Path {
+        Path::new(&self.path)
+    }
+
+    pub fn into_bytes(self) -> Vec<u8> {
+        self.path.into_encoded_bytes()
+    }
+
+    pub fn to_string_lossy(&self) -> alloc::borrow::Cow<'_, str> {
+        self.path.to_string_lossy()
+    }
+
+    pub fn into_cstring(self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.into_bytes()).map_err(|err| err.to_pyexception(vm))
+    }
+
+    #[cfg(windows)]
+    pub fn to_wide_cstring(&self, vm: &VirtualMachine) -> PyResult<widestring::WideCString> {
+        widestring::WideCString::from_os_str(&self.path).map_err(|err| err.to_pyexception(vm))
+    }
+
+    pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {
+        if let Some(ref origin) = self.origin {
+            origin.clone()
+        } else {
+            // Default to string when no origin (e.g., from new_str)
+            OutputMode::String.process_path(self.path.clone(), vm)
+        }
+    }
+
+    /// Get the output mode based on origin type (bytes -> Bytes, otherwise -> String)
+    pub fn mode(&self) -> OutputMode {
+        match &self.origin {
+            Some(obj) if obj.downcast_ref::<PyBytes>().is_some() => OutputMode::Bytes,
+            _ => OutputMode::String,
+        }
+    }
+}
+
+impl AsRef<Path> for OsPath {
+    fn as_ref(&self) -> &Path {
+        self.as_path()
+    }
+}
+
+impl TryFromObject for OsPath {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        PathConverter::new().try_path(obj, vm)
+    }
+}
+
+// path_t with allow_fd in CPython
+#[derive(Clone)]
+pub(crate) enum OsPathOrFd<'fd> {
+    Path(OsPath),
+    Fd(crt_fd::Borrowed<'fd>),
+}
+
+impl TryFromObject for OsPathOrFd<'_> {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        PathConverter::new().try_path_or_fd(obj, vm)
+    }
+}
+
+impl From<OsPath> for OsPathOrFd<'_> {
+    fn from(path: OsPath) -> Self {
+        Self::Path(path)
+    }
+}
+
+impl OsPathOrFd<'_> {
+    pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {
+        match self {
+            Self::Path(path) => path.filename(vm),
+            Self::Fd(fd) => fd.to_pyobject(vm),
+        }
+    }
+}
+
+impl crate::exceptions::OSErrorBuilder {
+    #[must_use]
+    pub(crate) fn with_filename<'a>(
+        error: &std::io::Error,
+        filename: impl Into<OsPathOrFd<'a>>,
+        vm: &VirtualMachine,
+    ) -> crate::builtins::PyBaseExceptionRef {
+        // TODO: return type to PyRef<PyOSError>
+        use crate::exceptions::ToOSErrorBuilder;
+        let builder = error.to_os_error_builder(vm);
+        let builder = builder.filename(filename.into().filename(vm));
+        builder.build(vm).upcast()
+    }
+}
diff --git a/vm/src/prelude.rs b/crates/vm/src/prelude.rs
similarity index 100%
rename from vm/src/prelude.rs
rename to crates/vm/src/prelude.rs
diff --git a/crates/vm/src/protocol/buffer.rs b/crates/vm/src/protocol/buffer.rs
new file mode 100644
index 0000000000..0fe4d15458
--- /dev/null
+++ b/crates/vm/src/protocol/buffer.rs
@@ -0,0 +1,458 @@
+//! Buffer protocol
+//! <https://docs.python.org/3/c-api/buffer.html>
+
+use crate::{
+    Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject, VirtualMachine,
+    common::{
+        borrow::{BorrowedValue, BorrowedValueMut},
+        lock::{MapImmutable, PyMutex, PyMutexGuard},
+    },
+    object::PyObjectPayload,
+    sliceable::SequenceIndexOp,
+};
+use alloc::borrow::Cow;
+use core::{fmt::Debug, ops::Range};
+use itertools::Itertools;
+
+pub struct BufferMethods {
+    pub obj_bytes: fn(&PyBuffer) -> BorrowedValue<'_, [u8]>,
+    pub obj_bytes_mut: fn(&PyBuffer) -> BorrowedValueMut<'_, [u8]>,
+    pub release: fn(&PyBuffer),
+    pub retain: fn(&PyBuffer),
+}
+
+impl Debug for BufferMethods {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("BufferMethods")
+            .field("obj_bytes", &(self.obj_bytes as usize))
+            .field("obj_bytes_mut", &(self.obj_bytes_mut as usize))
+            .field("release", &(self.release as usize))
+            .field("retain", &(self.retain as usize))
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, Traverse)]
+pub struct PyBuffer {
+    pub obj: PyObjectRef,
+    #[pytraverse(skip)]
+    pub desc: BufferDescriptor,
+    #[pytraverse(skip)]
+    methods: &'static BufferMethods,
+}
+
+impl PyBuffer {
+    pub fn new(obj: PyObjectRef, desc: BufferDescriptor, methods: &'static BufferMethods) -> Self {
+        let zelf = Self {
+            obj,
+            desc: desc.validate(),
+            methods,
+        };
+        zelf.retain();
+        zelf
+    }
+
+    pub fn as_contiguous(&self) -> Option<BorrowedValue<'_, [u8]>> {
+        self.desc
+            .is_contiguous()
+            .then(|| unsafe { self.contiguous_unchecked() })
+    }
+
+    pub fn as_contiguous_mut(&self) -> Option<BorrowedValueMut<'_, [u8]>> {
+        (!self.desc.readonly && self.desc.is_contiguous())
+            .then(|| unsafe { self.contiguous_mut_unchecked() })
+    }
+
+    pub fn from_byte_vector(bytes: Vec<u8>, vm: &VirtualMachine) -> Self {
+        let bytes_len = bytes.len();
+        Self::new(
+            PyPayload::into_pyobject(VecBuffer::from(bytes), vm),
+            BufferDescriptor::simple(bytes_len, true),
+            &VEC_BUFFER_METHODS,
+        )
+    }
+
+    /// # Safety
+    /// assume the buffer is contiguous
+    pub unsafe fn contiguous_unchecked(&self) -> BorrowedValue<'_, [u8]> {
+        self.obj_bytes()
+    }
+
+    /// # Safety
+    /// assume the buffer is contiguous and writable
+    pub unsafe fn contiguous_mut_unchecked(&self) -> BorrowedValueMut<'_, [u8]> {
+        self.obj_bytes_mut()
+    }
+
+    pub fn append_to(&self, buf: &mut Vec<u8>) {
+        if let Some(bytes) = self.as_contiguous() {
+            buf.extend_from_slice(&bytes);
+        } else {
+            let bytes = &*self.obj_bytes();
+            self.desc.for_each_segment(true, |range| {
+                buf.extend_from_slice(&bytes[range.start as usize..range.end as usize])
+            });
+        }
+    }
+
+    pub fn contiguous_or_collect<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+        let borrowed;
+        let mut collected;
+        let v = if let Some(bytes) = self.as_contiguous() {
+            borrowed = bytes;
+            &*borrowed
+        } else {
+            collected = vec![];
+            self.append_to(&mut collected);
+            &collected
+        };
+        f(v)
+    }
+
+    pub fn obj_as<T: PyObjectPayload>(&self) -> &Py<T> {
+        unsafe { self.obj.downcast_unchecked_ref() }
+    }
+
+    pub fn obj_bytes(&self) -> BorrowedValue<'_, [u8]> {
+        (self.methods.obj_bytes)(self)
+    }
+
+    pub fn obj_bytes_mut(&self) -> BorrowedValueMut<'_, [u8]> {
+        (self.methods.obj_bytes_mut)(self)
+    }
+
+    pub fn release(&self) {
+        (self.methods.release)(self)
+    }
+
+    pub fn retain(&self) {
+        (self.methods.retain)(self)
+    }
+
+    // drop PyBuffer without calling release
+    // after this function, the owner should use forget()
+    // or wrap PyBuffer in the ManuallyDrop to prevent drop()
+    pub(crate) unsafe fn drop_without_release(&mut self) {
+        // SAFETY: requirements forwarded from caller
+        unsafe {
+            core::ptr::drop_in_place(&mut self.obj);
+            core::ptr::drop_in_place(&mut self.desc);
+        }
+    }
+}
+
+impl<'a> TryFromBorrowedObject<'a> for PyBuffer {
+    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
+        let cls = obj.class();
+        if let Some(f) = cls.slots.as_buffer {
+            return f(obj, vm);
+        }
+        Err(vm.new_type_error(format!(
+            "a bytes-like object is required, not '{}'",
+            cls.name()
+        )))
+    }
+}
+
+impl Drop for PyBuffer {
+    fn drop(&mut self) {
+        self.release();
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BufferDescriptor {
+    /// product(shape) * itemsize
+    /// bytes length, but not the length for obj_bytes() even is contiguous
+    pub len: usize,
+    pub readonly: bool,
+    pub itemsize: usize,
+    pub format: Cow<'static, str>,
+    /// (shape, stride, suboffset) for each dimension
+    pub dim_desc: Vec<(usize, isize, isize)>,
+    // TODO: flags
+}
+
+impl BufferDescriptor {
+    pub fn simple(bytes_len: usize, readonly: bool) -> Self {
+        Self {
+            len: bytes_len,
+            readonly,
+            itemsize: 1,
+            format: Cow::Borrowed("B"),
+            dim_desc: vec![(bytes_len, 1, 0)],
+        }
+    }
+
+    pub fn format(
+        bytes_len: usize,
+        readonly: bool,
+        itemsize: usize,
+        format: Cow<'static, str>,
+    ) -> Self {
+        Self {
+            len: bytes_len,
+            readonly,
+            itemsize,
+            format,
+            dim_desc: vec![(bytes_len / itemsize, itemsize as isize, 0)],
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn validate(self) -> Self {
+        // ndim=0 is valid for scalar types (e.g., ctypes Structure)
+        if self.ndim() == 0 {
+            // Empty structures (len=0) can have itemsize=0
+            if self.len > 0 {
+                assert!(self.itemsize != 0);
+            }
+            assert!(self.itemsize == self.len);
+        } else {
+            let mut shape_product = 1;
+            let has_zero_dim = self.dim_desc.iter().any(|(s, _, _)| *s == 0);
+            for (shape, stride, suboffset) in self.dim_desc.iter().cloned() {
+                shape_product *= shape;
+                assert!(suboffset >= 0);
+                // For empty arrays (any dimension is 0), strides can be 0
+                if !has_zero_dim {
+                    assert!(stride != 0);
+                }
+            }
+            assert!(shape_product * self.itemsize == self.len);
+        }
+        self
+    }
+
+    #[cfg(not(debug_assertions))]
+    pub fn validate(self) -> Self {
+        self
+    }
+
+    pub fn ndim(&self) -> usize {
+        self.dim_desc.len()
+    }
+
+    pub fn is_contiguous(&self) -> bool {
+        if self.len == 0 {
+            return true;
+        }
+        let mut sd = self.itemsize;
+        for (shape, stride, _) in self.dim_desc.iter().cloned().rev() {
+            if shape > 1 && stride != sd as isize {
+                return false;
+            }
+            sd *= shape;
+        }
+        true
+    }
+
+    /// this function do not check the bound
+    /// panic if indices.len() != ndim
+    pub fn fast_position(&self, indices: &[usize]) -> isize {
+        let mut pos = 0;
+        for (i, (_, stride, suboffset)) in indices
+            .iter()
+            .cloned()
+            .zip_eq(self.dim_desc.iter().cloned())
+        {
+            pos += i as isize * stride + suboffset;
+        }
+        pos
+    }
+
+    /// panic if indices.len() != ndim
+    pub fn position(&self, indices: &[isize], vm: &VirtualMachine) -> PyResult<isize> {
+        let mut pos = 0;
+        for (i, (shape, stride, suboffset)) in indices
+            .iter()
+            .cloned()
+            .zip_eq(self.dim_desc.iter().cloned())
+        {
+            let i = i.wrapped_at(shape).ok_or_else(|| {
+                vm.new_index_error(format!("index out of bounds on dimension {i}"))
+            })?;
+            pos += i as isize * stride + suboffset;
+        }
+        Ok(pos)
+    }
+
+    pub fn for_each_segment<F>(&self, try_contiguous: bool, mut f: F)
+    where
+        F: FnMut(Range<isize>),
+    {
+        if self.ndim() == 0 {
+            f(0..self.itemsize as isize);
+            return;
+        }
+        if try_contiguous && self.is_last_dim_contiguous() {
+            self._for_each_segment::<_, true>(0, 0, &mut f);
+        } else {
+            self._for_each_segment::<_, false>(0, 0, &mut f);
+        }
+    }
+
+    fn _for_each_segment<F, const CONTIGUOUS: bool>(&self, mut index: isize, dim: usize, f: &mut F)
+    where
+        F: FnMut(Range<isize>),
+    {
+        let (shape, stride, suboffset) = self.dim_desc[dim];
+        if dim + 1 == self.ndim() {
+            if CONTIGUOUS {
+                f(index..index + (shape * self.itemsize) as isize);
+            } else {
+                for _ in 0..shape {
+                    let pos = index + suboffset;
+                    f(pos..pos + self.itemsize as isize);
+                    index += stride;
+                }
+            }
+            return;
+        }
+        for _ in 0..shape {
+            self._for_each_segment::<F, CONTIGUOUS>(index + suboffset, dim + 1, f);
+            index += stride;
+        }
+    }
+
+    /// zip two BufferDescriptor with the same shape
+    pub fn zip_eq<F>(&self, other: &Self, try_contiguous: bool, mut f: F)
+    where
+        F: FnMut(Range<isize>, Range<isize>) -> bool,
+    {
+        if self.ndim() == 0 {
+            f(0..self.itemsize as isize, 0..other.itemsize as isize);
+            return;
+        }
+        if try_contiguous && self.is_last_dim_contiguous() {
+            self._zip_eq::<_, true>(other, 0, 0, 0, &mut f);
+        } else {
+            self._zip_eq::<_, false>(other, 0, 0, 0, &mut f);
+        }
+    }
+
+    fn _zip_eq<F, const CONTIGUOUS: bool>(
+        &self,
+        other: &Self,
+        mut a_index: isize,
+        mut b_index: isize,
+        dim: usize,
+        f: &mut F,
+    ) where
+        F: FnMut(Range<isize>, Range<isize>) -> bool,
+    {
+        let (shape, a_stride, a_suboffset) = self.dim_desc[dim];
+        let (_b_shape, b_stride, b_suboffset) = other.dim_desc[dim];
+        debug_assert_eq!(shape, _b_shape);
+        if dim + 1 == self.ndim() {
+            if CONTIGUOUS {
+                if f(
+                    a_index..a_index + (shape * self.itemsize) as isize,
+                    b_index..b_index + (shape * other.itemsize) as isize,
+                ) {
+                    return;
+                }
+            } else {
+                for _ in 0..shape {
+                    let a_pos = a_index + a_suboffset;
+                    let b_pos = b_index + b_suboffset;
+                    if f(
+                        a_pos..a_pos + self.itemsize as isize,
+                        b_pos..b_pos + other.itemsize as isize,
+                    ) {
+                        return;
+                    }
+                    a_index += a_stride;
+                    b_index += b_stride;
+                }
+            }
+            return;
+        }
+
+        for _ in 0..shape {
+            self._zip_eq::<F, CONTIGUOUS>(
+                other,
+                a_index + a_suboffset,
+                b_index + b_suboffset,
+                dim + 1,
+                f,
+            );
+            a_index += a_stride;
+            b_index += b_stride;
+        }
+    }
+
+    fn is_last_dim_contiguous(&self) -> bool {
+        let (_, stride, suboffset) = self.dim_desc[self.ndim() - 1];
+        suboffset == 0 && stride == self.itemsize as isize
+    }
+
+    pub fn is_zero_in_shape(&self) -> bool {
+        self.dim_desc.iter().any(|(shape, _, _)| *shape == 0)
+    }
+
+    // TODO: support column-major order
+}
+
+pub trait BufferResizeGuard {
+    type Resizable<'a>: 'a
+    where
+        Self: 'a;
+    fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>>;
+    fn try_resizable(&self, vm: &VirtualMachine) -> PyResult<Self::Resizable<'_>> {
+        self.try_resizable_opt().ok_or_else(|| {
+            vm.new_buffer_error("Existing exports of data: object cannot be re-sized")
+        })
+    }
+}
+
+#[pyclass(module = false, name = "vec_buffer")]
+#[derive(Debug, PyPayload)]
+pub struct VecBuffer {
+    data: PyMutex<Vec<u8>>,
+}
+
+#[pyclass(flags(BASETYPE, DISALLOW_INSTANTIATION))]
+impl VecBuffer {
+    pub fn take(&self) -> Vec<u8> {
+        core::mem::take(&mut self.data.lock())
+    }
+}
+
+impl From<Vec<u8>> for VecBuffer {
+    fn from(data: Vec<u8>) -> Self {
+        Self {
+            data: PyMutex::new(data),
+        }
+    }
+}
+
+impl PyRef<VecBuffer> {
+    pub fn into_pybuffer(self, readonly: bool) -> PyBuffer {
+        let len = self.data.lock().len();
+        PyBuffer::new(
+            self.into(),
+            BufferDescriptor::simple(len, readonly),
+            &VEC_BUFFER_METHODS,
+        )
+    }
+
+    pub fn into_pybuffer_with_descriptor(self, desc: BufferDescriptor) -> PyBuffer {
+        PyBuffer::new(self.into(), desc, &VEC_BUFFER_METHODS)
+    }
+}
+
+static VEC_BUFFER_METHODS: BufferMethods = BufferMethods {
+    obj_bytes: |buffer| {
+        PyMutexGuard::map_immutable(buffer.obj_as::<VecBuffer>().data.lock(), |x| x.as_slice())
+            .into()
+    },
+    obj_bytes_mut: |buffer| {
+        PyMutexGuard::map(buffer.obj_as::<VecBuffer>().data.lock(), |x| {
+            x.as_mut_slice()
+        })
+        .into()
+    },
+    release: |_| {},
+    retain: |_| {},
+};
diff --git a/vm/src/protocol/callable.rs b/crates/vm/src/protocol/callable.rs
similarity index 94%
rename from vm/src/protocol/callable.rs
rename to crates/vm/src/protocol/callable.rs
index 1444b6bf73..fa5e48d58b 100644
--- a/vm/src/protocol/callable.rs
+++ b/crates/vm/src/protocol/callable.rs
@@ -42,7 +42,7 @@ pub struct PyCallable<'a> {
 
 impl<'a> PyCallable<'a> {
     pub fn new(obj: &'a PyObject) -> Option<Self> {
-        let call = obj.class().mro_find_map(|cls| cls.slots.call.load())?;
+        let call = obj.class().slots.call.load()?;
         Some(PyCallable { obj, call })
     }
 
@@ -61,8 +61,8 @@ enum TraceEvent {
     Return,
 }
 
-impl std::fmt::Display for TraceEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Display for TraceEvent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         use TraceEvent::*;
         match self {
             Call => write!(f, "call"),
diff --git a/crates/vm/src/protocol/iter.rs b/crates/vm/src/protocol/iter.rs
new file mode 100644
index 0000000000..aa6ab6769c
--- /dev/null
+++ b/crates/vm/src/protocol/iter.rs
@@ -0,0 +1,291 @@
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
+    builtins::iter::PySequenceIterator,
+    convert::{ToPyObject, ToPyResult},
+    object::{Traverse, TraverseFn},
+};
+use core::borrow::Borrow;
+use core::ops::Deref;
+
+/// Iterator Protocol
+// https://docs.python.org/3/c-api/iter.html
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct PyIter<O = PyObjectRef>(O)
+where
+    O: Borrow<PyObject>;
+
+unsafe impl<O: Borrow<PyObject>> Traverse for PyIter<O> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.0.borrow().traverse(tracer_fn);
+    }
+}
+
+impl PyIter<PyObjectRef> {
+    pub fn check(obj: &PyObject) -> bool {
+        obj.class().slots.iternext.load().is_some()
+    }
+}
+
+impl<O> PyIter<O>
+where
+    O: Borrow<PyObject>,
+{
+    pub const fn new(obj: O) -> Self {
+        Self(obj)
+    }
+    pub fn next(&self, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        let iternext = self
+            .0
+            .borrow()
+            .class()
+            .slots
+            .iternext
+            .load()
+            .ok_or_else(|| {
+                vm.new_type_error(format!(
+                    "'{}' object is not an iterator",
+                    self.0.borrow().class().name()
+                ))
+            })?;
+        iternext(self.0.borrow(), vm)
+    }
+
+    pub fn iter<'a, 'b, U>(
+        &'b self,
+        vm: &'a VirtualMachine,
+    ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
+        let length_hint = vm.length_hint_opt(self.as_ref().to_owned())?;
+        Ok(PyIterIter::new(vm, self.0.borrow(), length_hint))
+    }
+
+    pub fn iter_without_hint<'a, 'b, U>(
+        &'b self,
+        vm: &'a VirtualMachine,
+    ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
+        Ok(PyIterIter::new(vm, self.0.borrow(), None))
+    }
+}
+
+impl PyIter<PyObjectRef> {
+    /// Returns an iterator over this sequence of objects.
+    pub fn into_iter<U>(self, vm: &VirtualMachine) -> PyResult<PyIterIter<'_, U, PyObjectRef>> {
+        let length_hint = vm.length_hint_opt(self.as_object().to_owned())?;
+        Ok(PyIterIter::new(vm, self.0, length_hint))
+    }
+}
+
+impl From<PyIter<Self>> for PyObjectRef {
+    fn from(value: PyIter<Self>) -> Self {
+        value.0
+    }
+}
+
+impl<O> Borrow<PyObject> for PyIter<O>
+where
+    O: Borrow<PyObject>,
+{
+    #[inline(always)]
+    fn borrow(&self) -> &PyObject {
+        self.0.borrow()
+    }
+}
+
+impl<O> AsRef<PyObject> for PyIter<O>
+where
+    O: Borrow<PyObject>,
+{
+    #[inline(always)]
+    fn as_ref(&self) -> &PyObject {
+        self.0.borrow()
+    }
+}
+
+impl<O> Deref for PyIter<O>
+where
+    O: Borrow<PyObject>,
+{
+    type Target = PyObject;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        self.0.borrow()
+    }
+}
+
+impl ToPyObject for PyIter<PyObjectRef> {
+    #[inline(always)]
+    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
+        self.into()
+    }
+}
+
+impl TryFromObject for PyIter<PyObjectRef> {
+    // This helper function is called at multiple places. First, it is called
+    // in the vm when a for loop is entered. Next, it is used when the builtin
+    // function 'iter' is called.
+    fn try_from_object(vm: &VirtualMachine, iter_target: PyObjectRef) -> PyResult<Self> {
+        let get_iter = iter_target.class().slots.iter.load();
+        if let Some(get_iter) = get_iter {
+            let iter = get_iter(iter_target, vm)?;
+            if Self::check(&iter) {
+                Ok(Self(iter))
+            } else {
+                Err(vm.new_type_error(format!(
+                    "iter() returned non-iterator of type '{}'",
+                    iter.class().name()
+                )))
+            }
+        } else if let Ok(seq_iter) = PySequenceIterator::new(iter_target.clone(), vm) {
+            Ok(Self(seq_iter.into_pyobject(vm)))
+        } else {
+            Err(vm.new_type_error(format!(
+                "'{}' object is not iterable",
+                iter_target.class().name()
+            )))
+        }
+    }
+}
+
+#[derive(result_like::ResultLike)]
+pub enum PyIterReturn<T = PyObjectRef> {
+    Return(T),
+    StopIteration(Option<PyObjectRef>),
+}
+
+unsafe impl<T: Traverse> Traverse for PyIterReturn<T> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        match self {
+            Self::Return(r) => r.traverse(tracer_fn),
+            Self::StopIteration(Some(obj)) => obj.traverse(tracer_fn),
+            _ => (),
+        }
+    }
+}
+
+impl PyIterReturn {
+    pub fn from_pyresult(result: PyResult, vm: &VirtualMachine) -> PyResult<Self> {
+        match result {
+            Ok(obj) => Ok(Self::Return(obj)),
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
+                let args = err.get_arg(0);
+                Ok(Self::StopIteration(args))
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub fn from_getitem_result(result: PyResult, vm: &VirtualMachine) -> PyResult<Self> {
+        match result {
+            Ok(obj) => Ok(Self::Return(obj)),
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.index_error) => {
+                Ok(Self::StopIteration(None))
+            }
+            Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
+                let args = err.get_arg(0);
+                Ok(Self::StopIteration(args))
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub fn into_async_pyresult(self, vm: &VirtualMachine) -> PyResult {
+        match self {
+            Self::Return(obj) => Ok(obj),
+            Self::StopIteration(v) => Err({
+                let args = if let Some(v) = v { vec![v] } else { Vec::new() };
+                vm.new_exception(vm.ctx.exceptions.stop_async_iteration.to_owned(), args)
+            }),
+        }
+    }
+}
+
+impl ToPyResult for PyIterReturn {
+    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
+        match self {
+            Self::Return(obj) => Ok(obj),
+            Self::StopIteration(v) => Err(vm.new_stop_iteration(v)),
+        }
+    }
+}
+
+impl ToPyResult for PyResult<PyIterReturn> {
+    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
+        self?.to_pyresult(vm)
+    }
+}
+
+// Typical rust `Iter` object for `PyIter`
+pub struct PyIterIter<'a, T, O = PyObjectRef>
+where
+    O: Borrow<PyObject>,
+{
+    vm: &'a VirtualMachine,
+    obj: O, // creating PyIter<O> is zero-cost
+    length_hint: Option<usize>,
+    _phantom: core::marker::PhantomData<T>,
+}
+
+unsafe impl<T, O> Traverse for PyIterIter<'_, T, O>
+where
+    O: Traverse + Borrow<PyObject>,
+{
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.obj.traverse(tracer_fn)
+    }
+}
+
+impl<'a, T, O> PyIterIter<'a, T, O>
+where
+    O: Borrow<PyObject>,
+{
+    pub const fn new(vm: &'a VirtualMachine, obj: O, length_hint: Option<usize>) -> Self {
+        Self {
+            vm,
+            obj,
+            length_hint,
+            _phantom: core::marker::PhantomData,
+        }
+    }
+}
+
+impl<T, O> Iterator for PyIterIter<'_, T, O>
+where
+    T: TryFromObject,
+    O: Borrow<PyObject>,
+{
+    type Item = PyResult<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let imp = |next: PyResult<PyIterReturn>| -> PyResult<Option<T>> {
+            let Some(obj) = next?.into_result().ok() else {
+                return Ok(None);
+            };
+            Ok(Some(T::try_from_object(self.vm, obj)?))
+        };
+        let next = PyIter::new(self.obj.borrow()).next(self.vm);
+        imp(next).transpose()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.length_hint.unwrap_or(0), self.length_hint)
+    }
+}
+
+/// Macro to handle `PyIterReturn` values in iterator implementations.
+///
+/// Extracts the object from `PyIterReturn::Return(obj)` or performs early return
+/// for `PyIterReturn::StopIteration(v)`. This macro should only be used within
+/// functions that return `PyResult<PyIterReturn>`.
+#[macro_export]
+macro_rules! raise_if_stop {
+    ($input:expr) => {
+        match $input {
+            $crate::protocol::PyIterReturn::Return(obj) => obj,
+            $crate::protocol::PyIterReturn::StopIteration(v) => {
+                return Ok($crate::protocol::PyIterReturn::StopIteration(v))
+            }
+        }
+    };
+}
diff --git a/crates/vm/src/protocol/mapping.rs b/crates/vm/src/protocol/mapping.rs
new file mode 100644
index 0000000000..6c200043e3
--- /dev/null
+++ b/crates/vm/src/protocol/mapping.rs
@@ -0,0 +1,213 @@
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyResult, VirtualMachine,
+    builtins::{
+        PyDict, PyStrInterned,
+        dict::{PyDictItems, PyDictKeys, PyDictValues},
+    },
+    convert::ToPyResult,
+    object::{Traverse, TraverseFn},
+};
+use crossbeam_utils::atomic::AtomicCell;
+
+// Mapping protocol
+// https://docs.python.org/3/c-api/mapping.html
+
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PyMappingSlots {
+    pub length: AtomicCell<Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>>,
+    pub subscript: AtomicCell<Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub ass_subscript: AtomicCell<
+        Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+    >,
+}
+
+impl core::fmt::Debug for PyMappingSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("PyMappingSlots")
+    }
+}
+
+impl PyMappingSlots {
+    pub fn has_subscript(&self) -> bool {
+        self.subscript.load().is_some()
+    }
+
+    /// Copy from static PyMappingMethods
+    pub fn copy_from(&self, methods: &PyMappingMethods) {
+        if let Some(f) = methods.length {
+            self.length.store(Some(f));
+        }
+        if let Some(f) = methods.subscript {
+            self.subscript.store(Some(f));
+        }
+        if let Some(f) = methods.ass_subscript {
+            self.ass_subscript.store(Some(f));
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PyMappingMethods {
+    pub length: Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>,
+    pub subscript: Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub ass_subscript:
+        Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+}
+
+impl core::fmt::Debug for PyMappingMethods {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("PyMappingMethods")
+    }
+}
+
+impl PyMappingMethods {
+    pub const NOT_IMPLEMENTED: Self = Self {
+        length: None,
+        subscript: None,
+        ass_subscript: None,
+    };
+}
+
+impl PyObject {
+    pub fn mapping_unchecked(&self) -> PyMapping<'_> {
+        PyMapping { obj: self }
+    }
+
+    pub fn try_mapping(&self, vm: &VirtualMachine) -> PyResult<PyMapping<'_>> {
+        let mapping = self.mapping_unchecked();
+        if mapping.check() {
+            Ok(mapping)
+        } else {
+            Err(vm.new_type_error(format!("{} is not a mapping object", self.class())))
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct PyMapping<'a> {
+    pub obj: &'a PyObject,
+}
+
+unsafe impl Traverse for PyMapping<'_> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.obj.traverse(tracer_fn)
+    }
+}
+
+impl AsRef<PyObject> for PyMapping<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &PyObject {
+        self.obj
+    }
+}
+
+impl PyMapping<'_> {
+    #[inline]
+    pub fn slots(&self) -> &PyMappingSlots {
+        &self.obj.class().slots.as_mapping
+    }
+
+    #[inline]
+    pub fn check(&self) -> bool {
+        self.slots().has_subscript()
+    }
+
+    pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
+        self.slots().length.load().map(|f| f(self, vm))
+    }
+
+    pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
+        self.length_opt(vm).ok_or_else(|| {
+            vm.new_type_error(format!(
+                "object of type '{}' has no len() or not a mapping",
+                self.obj.class()
+            ))
+        })?
+    }
+
+    pub fn subscript(self, needle: &impl AsObject, vm: &VirtualMachine) -> PyResult {
+        self._subscript(needle.as_object(), vm)
+    }
+
+    pub fn ass_subscript(
+        self,
+        needle: &impl AsObject,
+        value: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        self._ass_subscript(needle.as_object(), value, vm)
+    }
+
+    fn _subscript(self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
+        let f =
+            self.slots().subscript.load().ok_or_else(|| {
+                vm.new_type_error(format!("{} is not a mapping", self.obj.class()))
+            })?;
+        f(self, needle, vm)
+    }
+
+    fn _ass_subscript(
+        self,
+        needle: &PyObject,
+        value: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let f = self.slots().ass_subscript.load().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "'{}' object does not support item assignment",
+                self.obj.class()
+            ))
+        })?;
+        f(self, needle, value, vm)
+    }
+
+    pub fn keys(self, vm: &VirtualMachine) -> PyResult {
+        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
+            PyDictKeys::new(dict.to_owned()).to_pyresult(vm)
+        } else {
+            self.method_output_as_list(identifier!(vm, keys), vm)
+        }
+    }
+
+    pub fn values(self, vm: &VirtualMachine) -> PyResult {
+        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
+            PyDictValues::new(dict.to_owned()).to_pyresult(vm)
+        } else {
+            self.method_output_as_list(identifier!(vm, values), vm)
+        }
+    }
+
+    pub fn items(self, vm: &VirtualMachine) -> PyResult {
+        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
+            PyDictItems::new(dict.to_owned()).to_pyresult(vm)
+        } else {
+            self.method_output_as_list(identifier!(vm, items), vm)
+        }
+    }
+
+    fn method_output_as_list(
+        self,
+        method_name: &'static PyStrInterned,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let meth_output = vm.call_method(self.obj, method_name.as_str(), ())?;
+        if meth_output.is(vm.ctx.types.list_type) {
+            return Ok(meth_output);
+        }
+
+        let iter = meth_output.get_iter(vm).map_err(|_| {
+            vm.new_type_error(format!(
+                "{}.{}() returned a non-iterable (type {})",
+                self.obj.class(),
+                method_name.as_str(),
+                meth_output.class()
+            ))
+        })?;
+
+        // TODO
+        // PySequence::from(&iter).list(vm).map(|x| x.into())
+        vm.ctx.new_list(iter.try_to_value(vm)?).to_pyresult(vm)
+    }
+}
diff --git a/crates/vm/src/protocol/mod.rs b/crates/vm/src/protocol/mod.rs
new file mode 100644
index 0000000000..6eb2909f16
--- /dev/null
+++ b/crates/vm/src/protocol/mod.rs
@@ -0,0 +1,17 @@
+mod buffer;
+mod callable;
+mod iter;
+mod mapping;
+mod number;
+mod object;
+mod sequence;
+
+pub use buffer::{BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, VecBuffer};
+pub use callable::PyCallable;
+pub use iter::{PyIter, PyIterIter, PyIterReturn};
+pub use mapping::{PyMapping, PyMappingMethods, PyMappingSlots};
+pub use number::{
+    PyNumber, PyNumberBinaryFunc, PyNumberBinaryOp, PyNumberMethods, PyNumberSlots,
+    PyNumberTernaryFunc, PyNumberTernaryOp, PyNumberUnaryFunc, handle_bytes_to_int_err,
+};
+pub use sequence::{PySequence, PySequenceMethods, PySequenceSlots};
diff --git a/crates/vm/src/protocol/number.rs b/crates/vm/src/protocol/number.rs
new file mode 100644
index 0000000000..542afce2c6
--- /dev/null
+++ b/crates/vm/src/protocol/number.rs
@@ -0,0 +1,701 @@
+use core::ops::Deref;
+
+use crossbeam_utils::atomic::AtomicCell;
+
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject,
+    VirtualMachine,
+    builtins::{
+        PyBaseExceptionRef, PyByteArray, PyBytes, PyComplex, PyFloat, PyInt, PyIntRef, PyStr, int,
+    },
+    common::int::{BytesToIntError, bytes_to_int},
+    function::ArgBytesLike,
+    object::{Traverse, TraverseFn},
+    stdlib::warnings,
+};
+
+pub type PyNumberUnaryFunc<R = PyObjectRef> = fn(PyNumber<'_>, &VirtualMachine) -> PyResult<R>;
+pub type PyNumberBinaryFunc = fn(&PyObject, &PyObject, &VirtualMachine) -> PyResult;
+pub type PyNumberTernaryFunc = fn(&PyObject, &PyObject, &PyObject, &VirtualMachine) -> PyResult;
+
+impl PyObject {
+    #[inline]
+    pub const fn number(&self) -> PyNumber<'_> {
+        PyNumber { obj: self }
+    }
+
+    pub fn try_index_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
+        if let Some(i) = self.downcast_ref_if_exact::<PyInt>(vm) {
+            Some(Ok(i.to_owned()))
+        } else if let Some(i) = self.downcast_ref::<PyInt>() {
+            Some(Ok(vm.ctx.new_bigint(i.as_bigint())))
+        } else {
+            self.number().index(vm)
+        }
+    }
+
+    #[inline]
+    pub fn try_index(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+        self.try_index_opt(vm).transpose()?.ok_or_else(|| {
+            vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as an integer",
+                self.class()
+            ))
+        })
+    }
+
+    pub fn try_int(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+        fn try_convert(obj: &PyObject, lit: &[u8], vm: &VirtualMachine) -> PyResult<PyIntRef> {
+            let base = 10;
+            let digit_limit = vm.state.int_max_str_digits.load();
+
+            let i = bytes_to_int(lit, base, digit_limit)
+                .map_err(|e| handle_bytes_to_int_err(e, obj, vm))?;
+            Ok(PyInt::from(i).into_ref(&vm.ctx))
+        }
+
+        if let Some(i) = self.downcast_ref_if_exact::<PyInt>(vm) {
+            Ok(i.to_owned())
+        } 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(
+                vm.ctx.exceptions.deprecation_warning,
+                "The delegation of int() to __trunc__ is deprecated.".to_owned(),
+                1,
+                vm,
+            )?;
+            let ret = f.invoke((), vm)?;
+            ret.try_index(vm).map_err(|_| {
+                vm.new_type_error(format!(
+                    "__trunc__ returned non-Integral (type {})",
+                    ret.class()
+                ))
+            })
+        } else if let Some(s) = self.downcast_ref::<PyStr>() {
+            try_convert(self, s.as_wtf8().trim().as_bytes(), vm)
+        } else if let Some(bytes) = self.downcast_ref::<PyBytes>() {
+            try_convert(self, bytes, vm)
+        } else if let Some(bytearray) = self.downcast_ref::<PyByteArray>() {
+            try_convert(self, &bytearray.borrow_buf(), vm)
+        } else if let Ok(buffer) = ArgBytesLike::try_from_borrowed_object(vm, self) {
+            // TODO: replace to PyBuffer
+            try_convert(self, &buffer.borrow_buf(), vm)
+        } else {
+            Err(vm.new_type_error(format!(
+                "int() argument must be a string, a bytes-like object or a real number, not '{}'",
+                self.class()
+            )))
+        }
+    }
+
+    pub fn try_float_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
+        if let Some(float) = self.downcast_ref_if_exact::<PyFloat>(vm) {
+            Some(Ok(float.to_owned()))
+        } else if let Some(f) = self.number().float(vm) {
+            Some(f)
+        } else {
+            self.try_index_opt(vm)
+                .map(|i| Ok(vm.ctx.new_float(int::try_to_float(i?.as_bigint(), vm)?)))
+        }
+    }
+
+    #[inline]
+    pub fn try_float(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyFloat>> {
+        self.try_float_opt(vm).ok_or_else(|| {
+            vm.new_type_error(format!("must be real number, not {}", self.class()))
+        })?
+    }
+}
+
+#[derive(Default)]
+pub struct PyNumberMethods {
+    /* Number implementations must check *both*
+    arguments for proper type and implement the necessary conversions
+    in the slot functions themselves. */
+    pub add: Option<PyNumberBinaryFunc>,
+    pub subtract: Option<PyNumberBinaryFunc>,
+    pub multiply: Option<PyNumberBinaryFunc>,
+    pub remainder: Option<PyNumberBinaryFunc>,
+    pub divmod: Option<PyNumberBinaryFunc>,
+    pub power: Option<PyNumberTernaryFunc>,
+    pub negative: Option<PyNumberUnaryFunc>,
+    pub positive: Option<PyNumberUnaryFunc>,
+    pub absolute: Option<PyNumberUnaryFunc>,
+    pub boolean: Option<PyNumberUnaryFunc<bool>>,
+    pub invert: Option<PyNumberUnaryFunc>,
+    pub lshift: Option<PyNumberBinaryFunc>,
+    pub rshift: Option<PyNumberBinaryFunc>,
+    pub and: Option<PyNumberBinaryFunc>,
+    pub xor: Option<PyNumberBinaryFunc>,
+    pub or: Option<PyNumberBinaryFunc>,
+    pub int: Option<PyNumberUnaryFunc>,
+    pub float: Option<PyNumberUnaryFunc>,
+
+    pub inplace_add: Option<PyNumberBinaryFunc>,
+    pub inplace_subtract: Option<PyNumberBinaryFunc>,
+    pub inplace_multiply: Option<PyNumberBinaryFunc>,
+    pub inplace_remainder: Option<PyNumberBinaryFunc>,
+    pub inplace_power: Option<PyNumberTernaryFunc>,
+    pub inplace_lshift: Option<PyNumberBinaryFunc>,
+    pub inplace_rshift: Option<PyNumberBinaryFunc>,
+    pub inplace_and: Option<PyNumberBinaryFunc>,
+    pub inplace_xor: Option<PyNumberBinaryFunc>,
+    pub inplace_or: Option<PyNumberBinaryFunc>,
+
+    pub floor_divide: Option<PyNumberBinaryFunc>,
+    pub true_divide: Option<PyNumberBinaryFunc>,
+    pub inplace_floor_divide: Option<PyNumberBinaryFunc>,
+    pub inplace_true_divide: Option<PyNumberBinaryFunc>,
+
+    pub index: Option<PyNumberUnaryFunc>,
+
+    pub matrix_multiply: Option<PyNumberBinaryFunc>,
+    pub inplace_matrix_multiply: Option<PyNumberBinaryFunc>,
+}
+
+impl PyNumberMethods {
+    /// this is NOT a global variable
+    pub const NOT_IMPLEMENTED: Self = Self {
+        add: None,
+        subtract: None,
+        multiply: None,
+        remainder: None,
+        divmod: None,
+        power: None,
+        negative: None,
+        positive: None,
+        absolute: None,
+        boolean: None,
+        invert: None,
+        lshift: None,
+        rshift: None,
+        and: None,
+        xor: None,
+        or: None,
+        int: None,
+        float: None,
+        inplace_add: None,
+        inplace_subtract: None,
+        inplace_multiply: None,
+        inplace_remainder: None,
+        inplace_power: None,
+        inplace_lshift: None,
+        inplace_rshift: None,
+        inplace_and: None,
+        inplace_xor: None,
+        inplace_or: None,
+        floor_divide: None,
+        true_divide: None,
+        inplace_floor_divide: None,
+        inplace_true_divide: None,
+        index: None,
+        matrix_multiply: None,
+        inplace_matrix_multiply: None,
+    };
+
+    pub fn not_implemented() -> &'static Self {
+        static GLOBAL_NOT_IMPLEMENTED: PyNumberMethods = PyNumberMethods::NOT_IMPLEMENTED;
+        &GLOBAL_NOT_IMPLEMENTED
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum PyNumberBinaryOp {
+    Add,
+    Subtract,
+    Multiply,
+    Remainder,
+    Divmod,
+    Lshift,
+    Rshift,
+    And,
+    Xor,
+    Or,
+    InplaceAdd,
+    InplaceSubtract,
+    InplaceMultiply,
+    InplaceRemainder,
+    InplaceLshift,
+    InplaceRshift,
+    InplaceAnd,
+    InplaceXor,
+    InplaceOr,
+    FloorDivide,
+    TrueDivide,
+    InplaceFloorDivide,
+    InplaceTrueDivide,
+    MatrixMultiply,
+    InplaceMatrixMultiply,
+}
+
+#[derive(Copy, Clone)]
+pub enum PyNumberTernaryOp {
+    Power,
+    InplacePower,
+}
+
+#[derive(Default)]
+pub struct PyNumberSlots {
+    pub add: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub divmod: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub power: AtomicCell<Option<PyNumberTernaryFunc>>,
+    pub negative: AtomicCell<Option<PyNumberUnaryFunc>>,
+    pub positive: AtomicCell<Option<PyNumberUnaryFunc>>,
+    pub absolute: AtomicCell<Option<PyNumberUnaryFunc>>,
+    pub boolean: AtomicCell<Option<PyNumberUnaryFunc<bool>>>,
+    pub invert: AtomicCell<Option<PyNumberUnaryFunc>>,
+    pub lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub and: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub xor: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub or: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub int: AtomicCell<Option<PyNumberUnaryFunc>>,
+    pub float: AtomicCell<Option<PyNumberUnaryFunc>>,
+
+    // Right variants (internal - not exposed in SlotAccessor)
+    pub right_add: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_divmod: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_power: AtomicCell<Option<PyNumberTernaryFunc>>,
+    pub right_lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_and: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_xor: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_or: AtomicCell<Option<PyNumberBinaryFunc>>,
+
+    pub inplace_add: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_power: AtomicCell<Option<PyNumberTernaryFunc>>,
+    pub inplace_lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_and: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_xor: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_or: AtomicCell<Option<PyNumberBinaryFunc>>,
+
+    pub floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
+
+    pub index: AtomicCell<Option<PyNumberUnaryFunc>>,
+
+    pub matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub right_matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+    pub inplace_matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
+}
+
+impl From<&PyNumberMethods> for PyNumberSlots {
+    fn from(value: &PyNumberMethods) -> Self {
+        // right_* slots use the same function as left ops for native types
+        Self {
+            add: AtomicCell::new(value.add),
+            subtract: AtomicCell::new(value.subtract),
+            multiply: AtomicCell::new(value.multiply),
+            remainder: AtomicCell::new(value.remainder),
+            divmod: AtomicCell::new(value.divmod),
+            power: AtomicCell::new(value.power),
+            negative: AtomicCell::new(value.negative),
+            positive: AtomicCell::new(value.positive),
+            absolute: AtomicCell::new(value.absolute),
+            boolean: AtomicCell::new(value.boolean),
+            invert: AtomicCell::new(value.invert),
+            lshift: AtomicCell::new(value.lshift),
+            rshift: AtomicCell::new(value.rshift),
+            and: AtomicCell::new(value.and),
+            xor: AtomicCell::new(value.xor),
+            or: AtomicCell::new(value.or),
+            int: AtomicCell::new(value.int),
+            float: AtomicCell::new(value.float),
+            right_add: AtomicCell::new(value.add),
+            right_subtract: AtomicCell::new(value.subtract),
+            right_multiply: AtomicCell::new(value.multiply),
+            right_remainder: AtomicCell::new(value.remainder),
+            right_divmod: AtomicCell::new(value.divmod),
+            right_power: AtomicCell::new(value.power),
+            right_lshift: AtomicCell::new(value.lshift),
+            right_rshift: AtomicCell::new(value.rshift),
+            right_and: AtomicCell::new(value.and),
+            right_xor: AtomicCell::new(value.xor),
+            right_or: AtomicCell::new(value.or),
+            inplace_add: AtomicCell::new(value.inplace_add),
+            inplace_subtract: AtomicCell::new(value.inplace_subtract),
+            inplace_multiply: AtomicCell::new(value.inplace_multiply),
+            inplace_remainder: AtomicCell::new(value.inplace_remainder),
+            inplace_power: AtomicCell::new(value.inplace_power),
+            inplace_lshift: AtomicCell::new(value.inplace_lshift),
+            inplace_rshift: AtomicCell::new(value.inplace_rshift),
+            inplace_and: AtomicCell::new(value.inplace_and),
+            inplace_xor: AtomicCell::new(value.inplace_xor),
+            inplace_or: AtomicCell::new(value.inplace_or),
+            floor_divide: AtomicCell::new(value.floor_divide),
+            true_divide: AtomicCell::new(value.true_divide),
+            right_floor_divide: AtomicCell::new(value.floor_divide),
+            right_true_divide: AtomicCell::new(value.true_divide),
+            inplace_floor_divide: AtomicCell::new(value.inplace_floor_divide),
+            inplace_true_divide: AtomicCell::new(value.inplace_true_divide),
+            index: AtomicCell::new(value.index),
+            matrix_multiply: AtomicCell::new(value.matrix_multiply),
+            right_matrix_multiply: AtomicCell::new(value.matrix_multiply),
+            inplace_matrix_multiply: AtomicCell::new(value.inplace_matrix_multiply),
+        }
+    }
+}
+
+impl PyNumberSlots {
+    /// Copy from static PyNumberMethods
+    pub fn copy_from(&self, methods: &PyNumberMethods) {
+        if let Some(f) = methods.add {
+            self.add.store(Some(f));
+            self.right_add.store(Some(f));
+        }
+        if let Some(f) = methods.subtract {
+            self.subtract.store(Some(f));
+            self.right_subtract.store(Some(f));
+        }
+        if let Some(f) = methods.multiply {
+            self.multiply.store(Some(f));
+            self.right_multiply.store(Some(f));
+        }
+        if let Some(f) = methods.remainder {
+            self.remainder.store(Some(f));
+            self.right_remainder.store(Some(f));
+        }
+        if let Some(f) = methods.divmod {
+            self.divmod.store(Some(f));
+            self.right_divmod.store(Some(f));
+        }
+        if let Some(f) = methods.power {
+            self.power.store(Some(f));
+            self.right_power.store(Some(f));
+        }
+        if let Some(f) = methods.negative {
+            self.negative.store(Some(f));
+        }
+        if let Some(f) = methods.positive {
+            self.positive.store(Some(f));
+        }
+        if let Some(f) = methods.absolute {
+            self.absolute.store(Some(f));
+        }
+        if let Some(f) = methods.boolean {
+            self.boolean.store(Some(f));
+        }
+        if let Some(f) = methods.invert {
+            self.invert.store(Some(f));
+        }
+        if let Some(f) = methods.lshift {
+            self.lshift.store(Some(f));
+            self.right_lshift.store(Some(f));
+        }
+        if let Some(f) = methods.rshift {
+            self.rshift.store(Some(f));
+            self.right_rshift.store(Some(f));
+        }
+        if let Some(f) = methods.and {
+            self.and.store(Some(f));
+            self.right_and.store(Some(f));
+        }
+        if let Some(f) = methods.xor {
+            self.xor.store(Some(f));
+            self.right_xor.store(Some(f));
+        }
+        if let Some(f) = methods.or {
+            self.or.store(Some(f));
+            self.right_or.store(Some(f));
+        }
+        if let Some(f) = methods.int {
+            self.int.store(Some(f));
+        }
+        if let Some(f) = methods.float {
+            self.float.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_add {
+            self.inplace_add.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_subtract {
+            self.inplace_subtract.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_multiply {
+            self.inplace_multiply.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_remainder {
+            self.inplace_remainder.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_power {
+            self.inplace_power.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_lshift {
+            self.inplace_lshift.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_rshift {
+            self.inplace_rshift.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_and {
+            self.inplace_and.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_xor {
+            self.inplace_xor.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_or {
+            self.inplace_or.store(Some(f));
+        }
+        if let Some(f) = methods.floor_divide {
+            self.floor_divide.store(Some(f));
+            self.right_floor_divide.store(Some(f));
+        }
+        if let Some(f) = methods.true_divide {
+            self.true_divide.store(Some(f));
+            self.right_true_divide.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_floor_divide {
+            self.inplace_floor_divide.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_true_divide {
+            self.inplace_true_divide.store(Some(f));
+        }
+        if let Some(f) = methods.index {
+            self.index.store(Some(f));
+        }
+        if let Some(f) = methods.matrix_multiply {
+            self.matrix_multiply.store(Some(f));
+            self.right_matrix_multiply.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_matrix_multiply {
+            self.inplace_matrix_multiply.store(Some(f));
+        }
+    }
+
+    pub fn left_binary_op(&self, op_slot: PyNumberBinaryOp) -> Option<PyNumberBinaryFunc> {
+        use PyNumberBinaryOp::*;
+        match op_slot {
+            Add => self.add.load(),
+            Subtract => self.subtract.load(),
+            Multiply => self.multiply.load(),
+            Remainder => self.remainder.load(),
+            Divmod => self.divmod.load(),
+            Lshift => self.lshift.load(),
+            Rshift => self.rshift.load(),
+            And => self.and.load(),
+            Xor => self.xor.load(),
+            Or => self.or.load(),
+            InplaceAdd => self.inplace_add.load(),
+            InplaceSubtract => self.inplace_subtract.load(),
+            InplaceMultiply => self.inplace_multiply.load(),
+            InplaceRemainder => self.inplace_remainder.load(),
+            InplaceLshift => self.inplace_lshift.load(),
+            InplaceRshift => self.inplace_rshift.load(),
+            InplaceAnd => self.inplace_and.load(),
+            InplaceXor => self.inplace_xor.load(),
+            InplaceOr => self.inplace_or.load(),
+            FloorDivide => self.floor_divide.load(),
+            TrueDivide => self.true_divide.load(),
+            InplaceFloorDivide => self.inplace_floor_divide.load(),
+            InplaceTrueDivide => self.inplace_true_divide.load(),
+            MatrixMultiply => self.matrix_multiply.load(),
+            InplaceMatrixMultiply => self.inplace_matrix_multiply.load(),
+        }
+    }
+
+    pub fn right_binary_op(&self, op_slot: PyNumberBinaryOp) -> Option<PyNumberBinaryFunc> {
+        use PyNumberBinaryOp::*;
+        match op_slot {
+            Add => self.right_add.load(),
+            Subtract => self.right_subtract.load(),
+            Multiply => self.right_multiply.load(),
+            Remainder => self.right_remainder.load(),
+            Divmod => self.right_divmod.load(),
+            Lshift => self.right_lshift.load(),
+            Rshift => self.right_rshift.load(),
+            And => self.right_and.load(),
+            Xor => self.right_xor.load(),
+            Or => self.right_or.load(),
+            FloorDivide => self.right_floor_divide.load(),
+            TrueDivide => self.right_true_divide.load(),
+            MatrixMultiply => self.right_matrix_multiply.load(),
+            _ => None,
+        }
+    }
+
+    pub fn left_ternary_op(&self, op_slot: PyNumberTernaryOp) -> Option<PyNumberTernaryFunc> {
+        use PyNumberTernaryOp::*;
+        match op_slot {
+            Power => self.power.load(),
+            InplacePower => self.inplace_power.load(),
+        }
+    }
+
+    pub fn right_ternary_op(&self, op_slot: PyNumberTernaryOp) -> Option<PyNumberTernaryFunc> {
+        use PyNumberTernaryOp::*;
+        match op_slot {
+            Power => self.right_power.load(),
+            _ => None,
+        }
+    }
+}
+#[derive(Copy, Clone)]
+pub struct PyNumber<'a> {
+    pub obj: &'a PyObject,
+}
+
+unsafe impl Traverse for PyNumber<'_> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.obj.traverse(tracer_fn)
+    }
+}
+
+impl Deref for PyNumber<'_> {
+    type Target = PyObject;
+
+    fn deref(&self) -> &Self::Target {
+        self.obj
+    }
+}
+
+impl<'a> PyNumber<'a> {
+    // PyNumber_Check - slots are now inherited
+    pub fn check(obj: &PyObject) -> bool {
+        let methods = &obj.class().slots.as_number;
+        let has_number = methods.int.load().is_some()
+            || methods.index.load().is_some()
+            || methods.float.load().is_some();
+        has_number || obj.downcastable::<PyComplex>()
+    }
+}
+
+impl PyNumber<'_> {
+    // PyIndex_Check
+    pub fn is_index(self) -> bool {
+        self.class().slots.as_number.index.load().is_some()
+    }
+
+    #[inline]
+    pub fn int(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
+        self.class().slots.as_number.int.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyInt>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__int__ returned non-int (type {ret_class}).  \
+                    The ability to return an instance of a strict subclass of int \
+                    is deprecated, and may be removed in a future version of Python."
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__int__ returned non-int(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
+    }
+
+    #[inline]
+    pub fn index(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
+        self.class().slots.as_number.index.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyInt>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__index__ returned non-int (type {ret_class}).  \
+                    The ability to return an instance of a strict subclass of int \
+                    is deprecated, and may be removed in a future version of Python."
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__index__ returned non-int(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
+    }
+
+    #[inline]
+    pub fn float(self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
+        self.class().slots.as_number.float.load().map(|f| {
+            let ret = f(self, vm)?;
+
+            if let Some(ret) = ret.downcast_ref_if_exact::<PyFloat>(vm) {
+                return Ok(ret.to_owned());
+            }
+
+            let ret_class = ret.class().to_owned();
+            if let Some(ret) = ret.downcast_ref::<PyFloat>() {
+                warnings::warn(
+                    vm.ctx.exceptions.deprecation_warning,
+                    format!(
+                        "__float__ returned non-float (type {ret_class}).  \
+                    The ability to return an instance of a strict subclass of float \
+                    is deprecated, and may be removed in a future version of Python."
+                    ),
+                    1,
+                    vm,
+                )?;
+
+                Ok(ret.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "{}.__float__ returned non-float(type {})",
+                    self.class(),
+                    ret_class
+                )))
+            }
+        })
+    }
+}
+
+pub fn handle_bytes_to_int_err(
+    e: BytesToIntError,
+    obj: &PyObject,
+    vm: &VirtualMachine,
+) -> PyBaseExceptionRef {
+    match e {
+        BytesToIntError::InvalidLiteral { base } => vm.new_value_error(format!(
+            "invalid literal for int() with base {base}: {}",
+            match obj.repr(vm) {
+                Ok(v) => v,
+                Err(err) => return err,
+            },
+        )),
+        BytesToIntError::InvalidBase => {
+            vm.new_value_error("int() base must be >= 2 and <= 36, or 0")
+        }
+        BytesToIntError::DigitLimit { got, limit } => vm.new_value_error(format!(
+"Exceeds the limit ({limit} digits) for integer string conversion: value has {got} digits; use sys.set_int_max_str_digits() to increase the limit"
+                )),
+    }
+}
diff --git a/crates/vm/src/protocol/object.rs b/crates/vm/src/protocol/object.rs
new file mode 100644
index 0000000000..ec1a6f5596
--- /dev/null
+++ b/crates/vm/src/protocol/object.rs
@@ -0,0 +1,781 @@
+//! Object Protocol
+//! <https://docs.python.org/3/c-api/object.html>
+
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
+    builtins::{
+        PyBytes, PyDict, PyDictRef, PyGenericAlias, PyInt, PyList, PyStr, PyTuple, PyTupleRef,
+        PyType, PyTypeRef, PyUtf8Str, pystr::AsPyStr,
+    },
+    common::{hash::PyHash, str::to_ascii},
+    convert::{ToPyObject, ToPyResult},
+    dict_inner::DictKey,
+    function::{Either, FuncArgs, PyArithmeticValue, PySetterValue},
+    object::PyPayload,
+    protocol::PyIter,
+    types::{Constructor, PyComparisonOp},
+};
+
+// RustPython doesn't need these items
+// PyObject *Py_NotImplemented
+// Py_RETURN_NOTIMPLEMENTED
+
+impl PyObjectRef {
+    // int PyObject_Print(PyObject *o, FILE *fp, int flags)
+
+    // PyObject *PyObject_GenericGetDict(PyObject *o, void *context)
+    // int PyObject_GenericSetDict(PyObject *o, PyObject *value, void *context)
+
+    #[inline(always)]
+    pub fn rich_compare(self, other: Self, op_id: PyComparisonOp, vm: &VirtualMachine) -> PyResult {
+        self._cmp(&other, op_id, vm).map(|res| res.to_pyobject(vm))
+    }
+
+    pub fn bytes(self, vm: &VirtualMachine) -> PyResult {
+        let bytes_type = vm.ctx.types.bytes_type;
+        match self.downcast_exact::<PyInt>(vm) {
+            Ok(int) => Err(vm.new_downcast_type_error(bytes_type, &int)),
+            Err(obj) => {
+                let args = FuncArgs::from(vec![obj]);
+                <PyBytes as Constructor>::slot_new(bytes_type.to_owned(), args, vm)
+            }
+        }
+    }
+
+    // const hash_not_implemented: fn(&PyObject, &VirtualMachine) ->PyResult<PyHash> = crate::types::Unhashable::slot_hash;
+
+    pub fn is_true(self, vm: &VirtualMachine) -> PyResult<bool> {
+        self.try_to_bool(vm)
+    }
+
+    pub fn not(self, vm: &VirtualMachine) -> PyResult<bool> {
+        self.is_true(vm).map(|x| !x)
+    }
+
+    pub fn length_hint(self, defaultvalue: usize, vm: &VirtualMachine) -> PyResult<usize> {
+        Ok(vm.length_hint_opt(self)?.unwrap_or(defaultvalue))
+    }
+
+    // PyObject *PyObject_Dir(PyObject *o)
+    pub fn dir(self, vm: &VirtualMachine) -> PyResult<PyList> {
+        let attributes = self.class().get_attributes();
+
+        let dict = PyDict::from_attributes(attributes, vm)?.into_ref(&vm.ctx);
+
+        if let Some(object_dict) = self.dict() {
+            vm.call_method(
+                dict.as_object(),
+                identifier!(vm, update).as_str(),
+                (object_dict,),
+            )?;
+        }
+
+        let attributes: Vec<_> = dict.into_iter().map(|(k, _v)| k).collect();
+
+        Ok(PyList::from(attributes))
+    }
+}
+
+impl PyObject {
+    /// Takes an object and returns an iterator for it.
+    /// This is typically a new iterator but if the argument is an iterator, this
+    /// returns itself.
+    pub fn get_iter(&self, vm: &VirtualMachine) -> PyResult<PyIter> {
+        // PyObject_GetIter
+        PyIter::try_from_object(vm, self.to_owned())
+    }
+
+    // PyObject *PyObject_GetAIter(PyObject *o)
+    pub fn get_aiter(&self, vm: &VirtualMachine) -> PyResult {
+        use crate::builtins::PyCoroutine;
+
+        // Check if object has __aiter__ method
+        let aiter_method = self.class().get_attr(identifier!(vm, __aiter__));
+        let Some(_aiter_method) = aiter_method else {
+            return Err(vm.new_type_error(format!(
+                "'{}' object is not an async iterable",
+                self.class().name()
+            )));
+        };
+
+        // Call __aiter__
+        let iterator = vm.call_special_method(self, identifier!(vm, __aiter__), ())?;
+
+        // Check that __aiter__ did not return a coroutine
+        if iterator.downcast_ref::<PyCoroutine>().is_some() {
+            return Err(vm.new_type_error(
+                "'async_iterator' object cannot be interpreted as an async iterable; \
+                perhaps you forgot to call aiter()?",
+            ));
+        }
+
+        // Check that the result is an async iterator (has __anext__)
+        if !iterator.class().has_attr(identifier!(vm, __anext__)) {
+            return Err(vm.new_type_error(format!(
+                "'{}' object is not an async iterator",
+                iterator.class().name()
+            )));
+        }
+
+        Ok(iterator)
+    }
+
+    pub fn has_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult<bool> {
+        self.get_attr(attr_name, vm).map(|o| !vm.is_none(&o))
+    }
+
+    /// Get an attribute by name.
+    /// `attr_name` can be a `&str`, `String`, or `PyStrRef`.
+    pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
+        let attr_name = attr_name.as_pystr(&vm.ctx);
+        self.get_attr_inner(attr_name, vm)
+    }
+
+    // get_attribute should be used for full attribute access (usually from user code).
+    #[cfg_attr(feature = "flame-it", flame("PyObjectRef"))]
+    #[inline]
+    pub(crate) fn get_attr_inner(&self, attr_name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        vm_trace!("object.__getattribute__: {:?} {:?}", self, attr_name);
+        let getattro = self.class().slots.getattro.load().unwrap();
+        getattro(self, attr_name, vm).inspect_err(|exc| {
+            vm.set_attribute_error_context(exc, self.to_owned(), attr_name.to_owned());
+        })
+    }
+
+    pub fn call_set_attr(
+        &self,
+        vm: &VirtualMachine,
+        attr_name: &Py<PyStr>,
+        attr_value: PySetterValue,
+    ) -> PyResult<()> {
+        let setattro = {
+            let cls = self.class();
+            cls.slots.setattro.load().ok_or_else(|| {
+                let has_getattr = cls.slots.getattro.load().is_some();
+                vm.new_type_error(format!(
+                    "'{}' object has {} attributes ({} {})",
+                    cls.name(),
+                    if has_getattr { "only read-only" } else { "no" },
+                    if attr_value.is_assign() {
+                        "assign to"
+                    } else {
+                        "del"
+                    },
+                    attr_name
+                ))
+            })?
+        };
+        setattro(self, attr_name, attr_value, vm)
+    }
+
+    pub fn set_attr<'a>(
+        &self,
+        attr_name: impl AsPyStr<'a>,
+        attr_value: impl Into<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let attr_name = attr_name.as_pystr(&vm.ctx);
+        let attr_value = attr_value.into();
+        self.call_set_attr(vm, attr_name, PySetterValue::Assign(attr_value))
+    }
+
+    // int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
+    #[cfg_attr(feature = "flame-it", flame)]
+    pub fn generic_setattr(
+        &self,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        vm_trace!("object.__setattr__({:?}, {}, {:?})", self, attr_name, value);
+        if let Some(attr) = vm
+            .ctx
+            .interned_str(attr_name)
+            .and_then(|attr_name| self.get_class_attr(attr_name))
+        {
+            let descr_set = attr.class().slots.descr_set.load();
+            if let Some(descriptor) = descr_set {
+                return descriptor(&attr, self.to_owned(), value, vm);
+            }
+        }
+
+        if let Some(dict) = self.dict() {
+            if let PySetterValue::Assign(value) = value {
+                dict.set_item(attr_name, value, vm)?;
+            } else {
+                dict.del_item(attr_name, vm).map_err(|e| {
+                    if e.fast_isinstance(vm.ctx.exceptions.key_error) {
+                        vm.new_no_attribute_error(self.to_owned(), attr_name.to_owned())
+                    } else {
+                        e
+                    }
+                })?;
+            }
+            Ok(())
+        } else {
+            Err(vm.new_no_attribute_error(self.to_owned(), attr_name.to_owned()))
+        }
+    }
+
+    pub fn generic_getattr(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        self.generic_getattr_opt(name, None, vm)?
+            .ok_or_else(|| vm.new_no_attribute_error(self.to_owned(), name.to_owned()))
+    }
+
+    /// CPython _PyObject_GenericGetAttrWithDict
+    pub fn generic_getattr_opt(
+        &self,
+        name_str: &Py<PyStr>,
+        dict: Option<PyDictRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        let name = name_str.as_wtf8();
+        let obj_cls = self.class();
+        let cls_attr_name = vm.ctx.interned_str(name_str);
+        let cls_attr = match cls_attr_name.and_then(|name| obj_cls.get_attr(name)) {
+            Some(descr) => {
+                let descr_cls = descr.class();
+                let descr_get = descr_cls.slots.descr_get.load();
+                if let Some(descr_get) = descr_get
+                    && descr_cls.slots.descr_set.load().is_some()
+                {
+                    let cls = obj_cls.to_owned().into();
+                    return descr_get(descr, Some(self.to_owned()), Some(cls), vm).map(Some);
+                }
+                Some((descr, descr_get))
+            }
+            None => None,
+        };
+
+        let dict = dict.or_else(|| self.dict());
+
+        let attr = if let Some(dict) = dict {
+            dict.get_item_opt(name, vm)?
+        } else {
+            None
+        };
+
+        if let Some(obj_attr) = attr {
+            Ok(Some(obj_attr))
+        } else if let Some((attr, descr_get)) = cls_attr {
+            match descr_get {
+                Some(descr_get) => {
+                    let cls = obj_cls.to_owned().into();
+                    descr_get(attr, Some(self.to_owned()), Some(cls), vm).map(Some)
+                }
+                None => Ok(Some(attr)),
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn del_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult<()> {
+        let attr_name = attr_name.as_pystr(&vm.ctx);
+        self.call_set_attr(vm, attr_name, PySetterValue::Delete)
+    }
+
+    // Perform a comparison, raising TypeError when the requested comparison
+    // operator is not supported.
+    // see: CPython PyObject_RichCompare
+    #[inline] // called by ExecutingFrame::execute_compare with const op
+    fn _cmp(
+        &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 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),
+            };
+            Ok(r)
+        };
+
+        let mut checked_reverse_op = false;
+        let is_strict_subclass = {
+            let self_class = self.class();
+            let other_class = other.class();
+            !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))?;
+            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))?
+        {
+            return Ok(x);
+        }
+        if !checked_reverse_op {
+            let res = vm.with_recursion("in comparison", || call_cmp(other, self, swapped))?;
+            if let PyArithmeticValue::Implemented(x) = res {
+                return Ok(x);
+            }
+        }
+        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())),
+        }
+    }
+    #[inline(always)]
+    pub fn rich_compare_bool(
+        &self,
+        other: &Self,
+        op_id: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        match self._cmp(other, op_id, vm)? {
+            Either::A(obj) => obj.try_to_bool(vm),
+            Either::B(other) => Ok(other),
+        }
+    }
+
+    pub fn repr_utf8(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyUtf8Str>> {
+        self.repr(vm)?.try_into_utf8(vm)
+    }
+
+    pub fn repr(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        vm.with_recursion("while getting the repr of an object", || {
+            self.class().slots.repr.load().map_or_else(
+                || {
+                    Err(vm.new_runtime_error(format!(
+                    "BUG: object of type '{}' has no __repr__ method. This is a bug in RustPython.",
+                    self.class().name()
+                )))
+                },
+                |repr| repr(self, vm),
+            )
+        })
+    }
+
+    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 str_utf8(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyUtf8Str>> {
+        self.str(vm)?.try_into_utf8(vm)
+    }
+    pub fn str(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        let obj = match self.to_owned().downcast_exact::<PyStr>(vm) {
+            Ok(s) => return Ok(s.into_pyref()),
+            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,
+            None => return obj.repr(vm),
+        };
+        let s = str_method.invoke((), vm)?;
+        s.downcast::<PyStr>().map_err(|obj| {
+            vm.new_type_error(format!(
+                "__str__ returned non-string (type {})",
+                obj.class().name()
+            ))
+        })
+    }
+
+    // Equivalent to CPython's check_class. Returns Ok(()) if cls is a valid class,
+    // Err with TypeError if not. Uses abstract_get_bases internally.
+    fn check_class<F>(&self, vm: &VirtualMachine, msg: F) -> PyResult<()>
+    where
+        F: Fn() -> String,
+    {
+        let cls = self;
+        match cls.abstract_get_bases(vm)? {
+            Some(_bases) => Ok(()), // Has __bases__, it's a valid class
+            None => {
+                // No __bases__ or __bases__ is not a tuple
+                Err(vm.new_type_error(msg()))
+            }
+        }
+    }
+
+    /// abstract_get_bases() has logically 4 return states:
+    /// 1. getattr(cls, '__bases__') could raise an AttributeError
+    /// 2. getattr(cls, '__bases__') could raise some other exception
+    /// 3. getattr(cls, '__bases__') could return a tuple
+    /// 4. getattr(cls, '__bases__') could return something other than a tuple
+    ///
+    /// Only state #3 returns Some(tuple). AttributeErrors are masked by returning None.
+    /// If an object other than a tuple comes out of __bases__, then again, None is returned.
+    /// Other exceptions are propagated.
+    fn abstract_get_bases(&self, vm: &VirtualMachine) -> PyResult<Option<PyTupleRef>> {
+        match vm.get_attribute_opt(self.to_owned(), identifier!(vm, __bases__))? {
+            Some(bases) => {
+                // Check if it's a tuple
+                match PyTupleRef::try_from_object(vm, bases) {
+                    Ok(tuple) => Ok(Some(tuple)),
+                    Err(_) => Ok(None), // Not a tuple, return None
+                }
+            }
+            None => Ok(None), // AttributeError was masked
+        }
+    }
+
+    fn abstract_issubclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        // Store the current derived class to check
+        let mut bases: PyTupleRef;
+        let mut derived = self;
+
+        // First loop: handle single inheritance without recursion
+        let bases = loop {
+            if derived.is(cls) {
+                return Ok(true);
+            }
+
+            let Some(derived_bases) = derived.abstract_get_bases(vm)? else {
+                return Ok(false);
+            };
+
+            let n = derived_bases.len();
+            match n {
+                0 => return Ok(false),
+                1 => {
+                    // Avoid recursion in the single inheritance case
+                    // Get the next derived class and continue the loop
+                    bases = derived_bases;
+                    derived = &bases.as_slice()[0];
+                    continue;
+                }
+                _ => {
+                    // Multiple inheritance - handle recursively
+                    break derived_bases;
+                }
+            }
+        };
+
+        let n = bases.len();
+        // At this point we know n >= 2
+        debug_assert!(n >= 2);
+
+        for i in 0..n {
+            let result = vm.with_recursion("in __issubclass__", || {
+                bases.as_slice()[i].abstract_issubclass(cls, vm)
+            })?;
+            if result {
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
+
+    fn recursive_issubclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        // Fast path for both being types (matches CPython's PyType_Check)
+        if let Some(cls) = PyType::check(cls)
+            && let Some(derived) = PyType::check(self)
+        {
+            // PyType_IsSubtype equivalent
+            return Ok(derived.is_subtype(cls));
+        }
+        // Check if derived is a class
+        self.check_class(vm, || {
+            format!("issubclass() arg 1 must be a class, not {}", self.class())
+        })?;
+
+        // Check if cls is a class, tuple, or union (matches CPython's order and message)
+        if !cls.class().is(vm.ctx.types.union_type) {
+            cls.check_class(vm, || {
+                format!(
+                    "issubclass() arg 2 must be a class, a tuple of classes, or a union, not {}",
+                    cls.class()
+                )
+            })?;
+        }
+
+        self.abstract_issubclass(cls, vm)
+    }
+
+    /// Real issubclass check without going through __subclasscheck__
+    /// This is equivalent to CPython's _PyObject_RealIsSubclass which just calls recursive_issubclass
+    pub fn real_is_subclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        self.recursive_issubclass(cls, vm)
+    }
+
+    /// Determines if `self` is a subclass of `cls`, either directly, indirectly or virtually
+    /// via the __subclasscheck__ magic method.
+    /// PyObject_IsSubclass/object_issubclass
+    pub fn is_subclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        let derived = self;
+        // PyType_CheckExact(cls)
+        if cls.class().is(vm.ctx.types.type_type) {
+            if derived.is(cls) {
+                return Ok(true);
+            }
+            return derived.recursive_issubclass(cls, vm);
+        }
+
+        // Check for Union type - CPython handles this before tuple
+        let cls = if cls.class().is(vm.ctx.types.union_type) {
+            // Get the __args__ attribute which contains the union members
+            // Match CPython's _Py_union_args which directly accesses the args field
+            let union = cls
+                .downcast_ref::<crate::builtins::PyUnion>()
+                .expect("union is already checked");
+            union.args().as_object()
+        } else {
+            cls
+        };
+
+        // Check if cls is a tuple
+        if let Some(tuple) = cls.downcast_ref::<PyTuple>() {
+            for item in tuple {
+                if vm.with_recursion("in __subclasscheck__", || derived.is_subclass(item, vm))? {
+                    return Ok(true);
+                }
+            }
+            return Ok(false);
+        }
+
+        // Check for __subclasscheck__ method using lookup_special (matches CPython)
+        if let Some(checker) = cls.lookup_special(identifier!(vm, __subclasscheck__), vm) {
+            let res = vm.with_recursion("in __subclasscheck__", || {
+                checker.call((derived.to_owned(),), vm)
+            })?;
+            return res.try_to_bool(vm);
+        }
+
+        derived.recursive_issubclass(cls, vm)
+    }
+
+    // _PyObject_RealIsInstance
+    pub(crate) fn real_is_instance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        self.object_isinstance(cls, vm)
+    }
+
+    /// Real isinstance check without going through __instancecheck__
+    /// This is equivalent to CPython's _PyObject_RealIsInstance/object_isinstance
+    fn object_isinstance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        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) =
+                    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);
+                }
+            }
+            Ok(retval)
+        } else {
+            // Not a type object, check if it's a valid class
+            cls.check_class(vm, || {
+                format!(
+                    "isinstance() arg 2 must be a type, a tuple of types, or a union, not {}",
+                    cls.class()
+                )
+            })?;
+
+            // Get __class__ attribute and check, only masking AttributeError
+            if let Some(i_cls) =
+                vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class__))?
+            {
+                i_cls.abstract_issubclass(cls, vm)
+            } else {
+                Ok(false)
+            }
+        }
+    }
+
+    /// Determines if `self` is an instance of `cls`, either directly, indirectly or virtually via
+    /// the __instancecheck__ magic method.
+    pub fn is_instance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        self.object_recursive_isinstance(cls, vm)
+    }
+
+    // This is object_recursive_isinstance from CPython's Objects/abstract.c
+    fn object_recursive_isinstance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
+        // PyObject_TypeCheck(inst, (PyTypeObject *)cls)
+        // This is an exact check of the type
+        if self.class().is(cls) {
+            return Ok(true);
+        }
+
+        // PyType_CheckExact(cls) optimization
+        if cls.class().is(vm.ctx.types.type_type) {
+            // When cls is exactly a type (not a subclass), use object_isinstance
+            // to avoid going through __instancecheck__ (matches CPython behavior)
+            return self.object_isinstance(cls, vm);
+        }
+
+        // Check for Union type (e.g., int | str) - CPython checks this before tuple
+        let cls = if cls.class().is(vm.ctx.types.union_type) {
+            // Match CPython's _Py_union_args which directly accesses the args field
+            let union = cls
+                .try_to_ref::<crate::builtins::PyUnion>(vm)
+                .expect("checked by is");
+            union.args().as_object()
+        } else {
+            cls
+        };
+
+        // Check if cls is a tuple
+        if let Some(tuple) = cls.downcast_ref::<PyTuple>() {
+            for item in tuple {
+                if vm.with_recursion("in __instancecheck__", || {
+                    self.object_recursive_isinstance(item, vm)
+                })? {
+                    return Ok(true);
+                }
+            }
+            return Ok(false);
+        }
+
+        // Check for __instancecheck__ method using lookup_special (matches CPython)
+        if let Some(checker) = cls.lookup_special(identifier!(vm, __instancecheck__), vm) {
+            let res = vm.with_recursion("in __instancecheck__", || {
+                checker.call((self.to_owned(),), vm)
+            })?;
+            return res.try_to_bool(vm);
+        }
+
+        // Fall back to object_isinstance (without going through __instancecheck__ again)
+        self.object_isinstance(cls, vm)
+    }
+
+    pub fn hash(&self, vm: &VirtualMachine) -> PyResult<PyHash> {
+        if let Some(hash) = self.class().slots.hash.load() {
+            return hash(self, vm);
+        }
+
+        Err(vm.new_exception_msg(
+            vm.ctx.exceptions.type_error.to_owned(),
+            format!("unhashable type: '{}'", self.class().name()),
+        ))
+    }
+
+    // type protocol
+    // PyObject *PyObject_Type(PyObject *o)
+    pub fn obj_type(&self) -> PyObjectRef {
+        self.class().to_owned().into()
+    }
+
+    // int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)
+    pub fn type_check(&self, typ: &Py<PyType>) -> bool {
+        self.fast_isinstance(typ)
+    }
+
+    pub fn length_opt(&self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
+        self.sequence_unchecked()
+            .length_opt(vm)
+            .or_else(|| self.mapping_unchecked().length_opt(vm))
+    }
+
+    pub fn length(&self, vm: &VirtualMachine) -> PyResult<usize> {
+        self.length_opt(vm).ok_or_else(|| {
+            vm.new_type_error(format!(
+                "object of type '{}' has no len()",
+                self.class().name()
+            ))
+        })?
+    }
+
+    pub fn get_item<K: DictKey + ?Sized>(&self, needle: &K, vm: &VirtualMachine) -> PyResult {
+        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
+            return dict.get_item(needle, vm);
+        }
+
+        let needle = needle.to_pyobject(vm);
+
+        if let Ok(mapping) = self.try_mapping(vm) {
+            mapping.subscript(&needle, vm)
+        } else if let Ok(seq) = self.try_sequence(vm) {
+            let i = needle.key_as_isize(vm)?;
+            seq.get_item(i, vm)
+        } else {
+            if self.class().fast_issubclass(vm.ctx.types.type_type) {
+                if self.is(vm.ctx.types.type_type) {
+                    return PyGenericAlias::from_args(self.class().to_owned(), needle, vm)
+                        .to_pyresult(vm);
+                }
+
+                if let Some(class_getitem) =
+                    vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class_getitem__))?
+                {
+                    return class_getitem.call((needle,), vm);
+                }
+            }
+            Err(vm.new_type_error(format!("'{}' object is not subscriptable", self.class())))
+        }
+    }
+
+    pub fn set_item<K: DictKey + ?Sized>(
+        &self,
+        needle: &K,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
+            return dict.set_item(needle, value, vm);
+        }
+
+        let mapping = self.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
+            let needle = needle.to_pyobject(vm);
+            return f(mapping, &needle, Some(value), vm);
+        }
+
+        let seq = self.sequence_unchecked();
+        if let Some(f) = seq.slots().ass_item.load() {
+            let i = needle.key_as_isize(vm)?;
+            return f(seq, i, Some(value), vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "'{}' does not support item assignment",
+            self.class()
+        )))
+    }
+
+    pub fn del_item<K: DictKey + ?Sized>(&self, needle: &K, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
+            return dict.del_item(needle, vm);
+        }
+
+        let mapping = self.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
+            let needle = needle.to_pyobject(vm);
+            return f(mapping, &needle, None, vm);
+        }
+        let seq = self.sequence_unchecked();
+        if let Some(f) = seq.slots().ass_item.load() {
+            let i = needle.key_as_isize(vm)?;
+            return f(seq, i, None, vm);
+        }
+
+        Err(vm.new_type_error(format!("'{}' does not support item deletion", self.class())))
+    }
+
+    /// Equivalent to CPython's _PyObject_LookupSpecial
+    /// Looks up a special method in the type's MRO without checking instance dict.
+    /// Returns None if not found (masking AttributeError like CPython).
+    pub fn lookup_special(&self, attr: &Py<PyStr>, vm: &VirtualMachine) -> Option<PyObjectRef> {
+        let obj_cls = self.class();
+
+        // Use PyType::lookup_ref (equivalent to CPython's _PyType_LookupRef)
+        let res = obj_cls.lookup_ref(attr, vm)?;
+
+        // If it's a descriptor, call its __get__ method
+        let descr_get = res.class().slots.descr_get.load();
+        if let Some(descr_get) = descr_get {
+            let obj_cls = obj_cls.to_owned().into();
+            // CPython ignores exceptions in _PyObject_LookupSpecial and returns NULL
+            descr_get(res, Some(self.to_owned()), Some(obj_cls), vm).ok()
+        } else {
+            Some(res)
+        }
+    }
+}
diff --git a/crates/vm/src/protocol/sequence.rs b/crates/vm/src/protocol/sequence.rs
new file mode 100644
index 0000000000..cee46a2908
--- /dev/null
+++ b/crates/vm/src/protocol/sequence.rs
@@ -0,0 +1,412 @@
+use crate::{
+    PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+    builtins::{PyList, PyListRef, PySlice, PyTuple, PyTupleRef},
+    convert::ToPyObject,
+    function::PyArithmeticValue,
+    object::{Traverse, TraverseFn},
+    protocol::PyNumberBinaryOp,
+};
+use crossbeam_utils::atomic::AtomicCell;
+use itertools::Itertools;
+
+// Sequence Protocol
+// https://docs.python.org/3/c-api/sequence.html
+
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PySequenceSlots {
+    pub length: AtomicCell<Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>>,
+    pub concat: AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+    pub item: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+    pub ass_item: AtomicCell<
+        Option<fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+    >,
+    pub contains:
+        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>>,
+    pub inplace_concat:
+        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
+    pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
+}
+
+impl core::fmt::Debug for PySequenceSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("PySequenceSlots")
+    }
+}
+
+impl PySequenceSlots {
+    pub fn has_item(&self) -> bool {
+        self.item.load().is_some()
+    }
+
+    /// Copy from static PySequenceMethods
+    pub fn copy_from(&self, methods: &PySequenceMethods) {
+        if let Some(f) = methods.length {
+            self.length.store(Some(f));
+        }
+        if let Some(f) = methods.concat {
+            self.concat.store(Some(f));
+        }
+        if let Some(f) = methods.repeat {
+            self.repeat.store(Some(f));
+        }
+        if let Some(f) = methods.item {
+            self.item.store(Some(f));
+        }
+        if let Some(f) = methods.ass_item {
+            self.ass_item.store(Some(f));
+        }
+        if let Some(f) = methods.contains {
+            self.contains.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_concat {
+            self.inplace_concat.store(Some(f));
+        }
+        if let Some(f) = methods.inplace_repeat {
+            self.inplace_repeat.store(Some(f));
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+#[derive(Default)]
+pub struct PySequenceMethods {
+    pub length: Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>,
+    pub concat: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub repeat: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
+    pub item: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
+    pub ass_item:
+        Option<fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
+    pub contains: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>,
+    pub inplace_concat: Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>,
+    pub inplace_repeat: Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>,
+}
+
+impl core::fmt::Debug for PySequenceMethods {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("PySequenceMethods")
+    }
+}
+
+impl PySequenceMethods {
+    pub const NOT_IMPLEMENTED: Self = Self {
+        length: None,
+        concat: None,
+        repeat: None,
+        item: None,
+        ass_item: None,
+        contains: None,
+        inplace_concat: None,
+        inplace_repeat: None,
+    };
+}
+
+impl PyObject {
+    #[inline]
+    pub fn sequence_unchecked(&self) -> PySequence<'_> {
+        PySequence { obj: self }
+    }
+
+    pub fn try_sequence(&self, vm: &VirtualMachine) -> PyResult<PySequence<'_>> {
+        let seq = self.sequence_unchecked();
+        if seq.check() {
+            Ok(seq)
+        } else {
+            Err(vm.new_type_error(format!("'{}' is not a sequence", self.class())))
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct PySequence<'a> {
+    pub obj: &'a PyObject,
+}
+
+unsafe impl Traverse for PySequence<'_> {
+    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
+        self.obj.traverse(tracer_fn)
+    }
+}
+
+impl PySequence<'_> {
+    #[inline]
+    pub fn slots(&self) -> &PySequenceSlots {
+        &self.obj.class().slots.as_sequence
+    }
+
+    pub fn check(&self) -> bool {
+        self.slots().has_item()
+    }
+
+    pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
+        self.slots().length.load().map(|f| f(self, vm))
+    }
+
+    pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
+        self.length_opt(vm).ok_or_else(|| {
+            vm.new_type_error(format!(
+                "'{}' is not a sequence or has no len()",
+                self.obj.class()
+            ))
+        })?
+    }
+
+    pub fn concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
+        if let Some(f) = self.slots().concat.load() {
+            return f(self, other, vm);
+        }
+
+        // if both arguments appear to be sequences, try fallback to __add__
+        if self.check() && other.sequence_unchecked().check() {
+            let ret = vm.binary_op1(self.obj, other, PyNumberBinaryOp::Add)?;
+            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
+                return Ok(ret);
+            }
+        }
+
+        Err(vm.new_type_error(format!(
+            "'{}' object can't be concatenated",
+            self.obj.class()
+        )))
+    }
+
+    pub fn repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
+        if let Some(f) = self.slots().repeat.load() {
+            return f(self, n, vm);
+        }
+
+        // fallback to __mul__
+        if self.check() {
+            let ret = vm.binary_op1(self.obj, &n.to_pyobject(vm), PyNumberBinaryOp::Multiply)?;
+            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
+                return Ok(ret);
+            }
+        }
+
+        Err(vm.new_type_error(format!("'{}' object can't be repeated", self.obj.class())))
+    }
+
+    pub fn inplace_concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
+        if let Some(f) = self.slots().inplace_concat.load() {
+            return f(self, other, vm);
+        }
+        if let Some(f) = self.slots().concat.load() {
+            return f(self, other, vm);
+        }
+
+        // if both arguments appear to be sequences, try fallback to __iadd__
+        if self.check() && other.sequence_unchecked().check() {
+            let ret = vm._iadd(self.obj, other)?;
+            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
+                return Ok(ret);
+            }
+        }
+
+        Err(vm.new_type_error(format!(
+            "'{}' object can't be concatenated",
+            self.obj.class()
+        )))
+    }
+
+    pub fn inplace_repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
+        if let Some(f) = self.slots().inplace_repeat.load() {
+            return f(self, n, vm);
+        }
+        if let Some(f) = self.slots().repeat.load() {
+            return f(self, n, vm);
+        }
+
+        if self.check() {
+            let ret = vm._imul(self.obj, &n.to_pyobject(vm))?;
+            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
+                return Ok(ret);
+            }
+        }
+
+        Err(vm.new_type_error(format!("'{}' object can't be repeated", self.obj.class())))
+    }
+
+    pub fn get_item(self, i: isize, vm: &VirtualMachine) -> PyResult {
+        if let Some(f) = self.slots().item.load() {
+            return f(self, i, vm);
+        }
+        Err(vm.new_type_error(format!(
+            "'{}' is not a sequence or does not support indexing",
+            self.obj.class()
+        )))
+    }
+
+    fn _ass_item(self, i: isize, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(f) = self.slots().ass_item.load() {
+            return f(self, i, value, vm);
+        }
+        Err(vm.new_type_error(format!(
+            "'{}' is not a sequence or doesn't support item {}",
+            self.obj.class(),
+            if value.is_some() {
+                "assignment"
+            } else {
+                "deletion"
+            }
+        )))
+    }
+
+    pub fn set_item(self, i: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        self._ass_item(i, Some(value), vm)
+    }
+
+    pub fn del_item(self, i: isize, vm: &VirtualMachine) -> PyResult<()> {
+        self._ass_item(i, None, vm)
+    }
+
+    pub fn get_slice(&self, start: isize, stop: isize, vm: &VirtualMachine) -> PyResult {
+        if let Ok(mapping) = self.obj.try_mapping(vm) {
+            let slice = PySlice {
+                start: Some(start.to_pyobject(vm)),
+                stop: stop.to_pyobject(vm),
+                step: None,
+            };
+            mapping.subscript(&slice.into_pyobject(vm), vm)
+        } else {
+            Err(vm.new_type_error(format!("'{}' object is unsliceable", self.obj.class())))
+        }
+    }
+
+    fn _ass_slice(
+        &self,
+        start: isize,
+        stop: isize,
+        value: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let mapping = self.obj.mapping_unchecked();
+        if let Some(f) = mapping.slots().ass_subscript.load() {
+            let slice = PySlice {
+                start: Some(start.to_pyobject(vm)),
+                stop: stop.to_pyobject(vm),
+                step: None,
+            };
+            f(mapping, &slice.into_pyobject(vm), value, vm)
+        } else {
+            Err(vm.new_type_error(format!(
+                "'{}' object doesn't support slice {}",
+                self.obj.class(),
+                if value.is_some() {
+                    "assignment"
+                } else {
+                    "deletion"
+                }
+            )))
+        }
+    }
+
+    pub fn set_slice(
+        &self,
+        start: isize,
+        stop: isize,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        self._ass_slice(start, stop, Some(value), vm)
+    }
+
+    pub fn del_slice(&self, start: isize, stop: isize, vm: &VirtualMachine) -> PyResult<()> {
+        self._ass_slice(start, stop, None, vm)
+    }
+
+    pub fn tuple(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+        if let Some(tuple) = self.obj.downcast_ref_if_exact::<PyTuple>(vm) {
+            Ok(tuple.to_owned())
+        } else if let Some(list) = self.obj.downcast_ref_if_exact::<PyList>(vm) {
+            Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()))
+        } else {
+            let iter = self.obj.to_owned().get_iter(vm)?;
+            let iter = iter.iter(vm)?;
+            Ok(vm.ctx.new_tuple(iter.try_collect()?))
+        }
+    }
+
+    pub fn list(&self, vm: &VirtualMachine) -> PyResult<PyListRef> {
+        let list = vm.ctx.new_list(self.obj.try_to_value(vm)?);
+        Ok(list)
+    }
+
+    pub fn count(&self, target: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+        let mut n = 0;
+
+        let iter = self.obj.to_owned().get_iter(vm)?;
+        let iter = iter.iter::<PyObjectRef>(vm)?;
+
+        for elem in iter {
+            let elem = elem?;
+            if vm.bool_eq(&elem, target)? {
+                if n == isize::MAX as usize {
+                    return Err(vm.new_overflow_error("index exceeds C integer size"));
+                }
+                n += 1;
+            }
+        }
+
+        Ok(n)
+    }
+
+    pub fn index(&self, target: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+        let mut index: isize = -1;
+
+        let iter = self.obj.to_owned().get_iter(vm)?;
+        let iter = iter.iter::<PyObjectRef>(vm)?;
+
+        for elem in iter {
+            if index == isize::MAX {
+                return Err(vm.new_overflow_error("index exceeds C integer size"));
+            }
+            index += 1;
+
+            let elem = elem?;
+            if vm.bool_eq(&elem, target)? {
+                return Ok(index as usize);
+            }
+        }
+
+        Err(vm.new_value_error("sequence.index(x): x not in sequence"))
+    }
+
+    pub fn extract<F, R>(&self, mut f: F, vm: &VirtualMachine) -> PyResult<Vec<R>>
+    where
+        F: FnMut(&PyObject) -> PyResult<R>,
+    {
+        if let Some(tuple) = self.obj.downcast_ref_if_exact::<PyTuple>(vm) {
+            tuple.iter().map(|x| f(x.as_ref())).collect()
+        } else if let Some(list) = self.obj.downcast_ref_if_exact::<PyList>(vm) {
+            list.borrow_vec().iter().map(|x| f(x.as_ref())).collect()
+        } else {
+            let iter = self.obj.to_owned().get_iter(vm)?;
+            let iter = iter.iter::<PyObjectRef>(vm)?;
+            let len = self.length(vm).unwrap_or(0);
+            let mut v = Vec::with_capacity(len);
+            for x in iter {
+                v.push(f(x?.as_ref())?);
+            }
+            v.shrink_to_fit();
+            Ok(v)
+        }
+    }
+
+    pub fn contains(self, target: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        if let Some(f) = self.slots().contains.load() {
+            return f(self, target, vm);
+        }
+
+        let iter = self.obj.to_owned().get_iter(vm)?;
+        let iter = iter.iter::<PyObjectRef>(vm)?;
+
+        for elem in iter {
+            let elem = elem?;
+            if vm.bool_eq(&elem, target)? {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+}
diff --git a/vm/src/py_io.rs b/crates/vm/src/py_io.rs
similarity index 87%
rename from vm/src/py_io.rs
rename to crates/vm/src/py_io.rs
index 6b82bbd478..5649463b30 100644
--- a/vm/src/py_io.rs
+++ b/crates/vm/src/py_io.rs
@@ -3,7 +3,9 @@ use crate::{
     builtins::{PyBaseExceptionRef, PyBytes, PyStr},
     common::ascii,
 };
-use std::{fmt, io, ops};
+use alloc::fmt;
+use core::ops;
+use std::io;
 
 pub trait Write {
     type Error;
@@ -70,11 +72,14 @@ pub fn file_readline(obj: &PyObject, size: Option<usize>, vm: &VirtualMachine) -
     };
     let ret = match_class!(match ret {
         s @ PyStr => {
-            let s_val = s.as_str();
-            if s_val.is_empty() {
+            // Use as_wtf8() to handle strings with surrogates (e.g., surrogateescape)
+            let s_wtf8 = s.as_wtf8();
+            if s_wtf8.is_empty() {
                 return Err(eof_err());
             }
-            if let Some(no_nl) = s_val.strip_suffix('\n') {
+            // '\n' is ASCII, so we can check bytes directly
+            if s_wtf8.as_bytes().last() == Some(&b'\n') {
+                let no_nl = &s_wtf8[..s_wtf8.len() - 1];
                 vm.ctx.new_str(no_nl).into()
             } else {
                 s.into()
diff --git a/vm/src/py_serde.rs b/crates/vm/src/py_serde.rs
similarity index 95%
rename from vm/src/py_serde.rs
rename to crates/vm/src/py_serde.rs
index 6c23f924e1..945068113f 100644
--- a/vm/src/py_serde.rs
+++ b/crates/vm/src/py_serde.rs
@@ -62,7 +62,7 @@ impl serde::Serialize for PyObjectSerializer<'_> {
                 }
                 seq.end()
             };
-        if let Some(s) = self.pyobject.payload::<PyStr>() {
+        if let Some(s) = self.pyobject.downcast_ref::<PyStr>() {
             serializer.serialize_str(s.as_ref())
         } else if self.pyobject.fast_isinstance(self.vm.ctx.types.float_type) {
             serializer.serialize_f64(float::get_value(self.pyobject))
@@ -80,9 +80,9 @@ impl serde::Serialize for PyObjectSerializer<'_> {
             } else {
                 serializer.serialize_i64(v.to_i64().ok_or_else(int_too_large)?)
             }
-        } else if let Some(list) = self.pyobject.payload_if_subclass::<PyList>(self.vm) {
+        } else if let Some(list) = self.pyobject.downcast_ref::<PyList>() {
             serialize_seq_elements(serializer, &list.borrow_vec())
-        } else if let Some(tuple) = self.pyobject.payload_if_subclass::<PyTuple>(self.vm) {
+        } else if let Some(tuple) = self.pyobject.downcast_ref::<PyTuple>() {
             serialize_seq_elements(serializer, tuple)
         } else if self.pyobject.fast_isinstance(self.vm.ctx.types.dict_type) {
             let dict: PyDictRef = self.pyobject.to_owned().downcast().unwrap();
@@ -130,7 +130,7 @@ impl<'de> DeserializeSeed<'de> for PyObjectDeserializer<'de> {
 impl<'de> Visitor<'de> for PyObjectDeserializer<'de> {
     type Value = PyObjectRef;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         formatter.write_str("a type that can deserialize in Python")
     }
 
diff --git a/vm/src/readline.rs b/crates/vm/src/readline.rs
similarity index 76%
rename from vm/src/readline.rs
rename to crates/vm/src/readline.rs
index 8a90a7ae40..d62d520ecb 100644
--- a/vm/src/readline.rs
+++ b/crates/vm/src/readline.rs
@@ -5,7 +5,7 @@
 
 use std::{io, path::Path};
 
-type OtherError = Box<dyn std::error::Error>;
+type OtherError = Box<dyn core::error::Error>;
 type OtherResult<T> = Result<T, OtherError>;
 
 pub enum ReadlineResult {
@@ -13,6 +13,8 @@ pub enum ReadlineResult {
     Eof,
     Interrupt,
     Io(std::io::Error),
+    #[cfg(unix)]
+    OsError(nix::Error),
     Other(OtherError),
 }
 
@@ -74,6 +76,9 @@ mod rustyline_readline {
         repl: rustyline::Editor<H, rustyline::history::DefaultHistory>,
     }
 
+    #[cfg(windows)]
+    const EOF_CHAR: &str = "\u{001A}";
+
     impl<H: Helper> Readline<H> {
         pub fn new(helper: H) -> Self {
             use rustyline::*;
@@ -86,6 +91,16 @@ mod rustyline_readline {
             )
             .expect("failed to initialize line editor");
             repl.set_helper(Some(helper));
+
+            // Bind CTRL + Z to insert EOF character on Windows
+            #[cfg(windows)]
+            {
+                repl.bind_sequence(
+                    KeyEvent::new('z', Modifiers::CTRL),
+                    EventHandler::Simple(Cmd::Insert(1, EOF_CHAR.into())),
+                );
+            }
+
             Self { repl }
         }
 
@@ -95,10 +110,10 @@ mod rustyline_readline {
         }
 
         pub fn save_history(&mut self, path: &Path) -> OtherResult<()> {
-            if !path.exists() {
-                if let Some(parent) = path.parent() {
-                    std::fs::create_dir_all(parent)?;
-                }
+            if !path.exists()
+                && let Some(parent) = path.parent()
+            {
+                std::fs::create_dir_all(parent)?;
             }
             self.repl.save_history(path)?;
             Ok(())
@@ -113,11 +128,25 @@ mod rustyline_readline {
             use rustyline::error::ReadlineError;
             loop {
                 break match self.repl.readline(prompt) {
-                    Ok(line) => ReadlineResult::Line(line),
+                    Ok(line) => {
+                        // Check for CTRL + Z on Windows
+                        #[cfg(windows)]
+                        {
+                            use std::io::IsTerminal;
+
+                            let trimmed = line.trim_end_matches(&['\r', '\n'][..]);
+                            if trimmed == EOF_CHAR && io::stdin().is_terminal() {
+                                return ReadlineResult::Eof;
+                            }
+                        }
+                        ReadlineResult::Line(line)
+                    }
                     Err(ReadlineError::Interrupted) => ReadlineResult::Interrupt,
                     Err(ReadlineError::Eof) => ReadlineResult::Eof,
                     Err(ReadlineError::Io(e)) => ReadlineResult::Io(e),
-                    Err(ReadlineError::WindowResized) => continue,
+                    Err(ReadlineError::Signal(_)) => continue,
+                    #[cfg(unix)]
+                    Err(ReadlineError::Errno(num)) => ReadlineResult::OsError(num),
                     Err(e) => ReadlineResult::Other(e.into()),
                 };
             }
diff --git a/vm/src/recursion.rs b/crates/vm/src/recursion.rs
similarity index 100%
rename from vm/src/recursion.rs
rename to crates/vm/src/recursion.rs
diff --git a/vm/src/scope.rs b/crates/vm/src/scope.rs
similarity index 98%
rename from vm/src/scope.rs
rename to crates/vm/src/scope.rs
index 9311fa5c2d..74392dc9b7 100644
--- a/vm/src/scope.rs
+++ b/crates/vm/src/scope.rs
@@ -1,5 +1,5 @@
 use crate::{VirtualMachine, builtins::PyDictRef, function::ArgMapping};
-use std::fmt;
+use alloc::fmt;
 
 #[derive(Clone)]
 pub struct Scope {
@@ -34,7 +34,7 @@ impl Scope {
         Self::new(locals, globals)
     }
 
-    // pub fn get_locals(&self) -> &PyDictRef {
+    // pub fn get_locals(&self) -> &Py<PyDict> {
     //     match self.locals.first() {
     //         Some(dict) => dict,
     //         None => &self.globals,
diff --git a/crates/vm/src/sequence.rs b/crates/vm/src/sequence.rs
new file mode 100644
index 0000000000..0bc12fd263
--- /dev/null
+++ b/crates/vm/src/sequence.rs
@@ -0,0 +1,165 @@
+use crate::{
+    AsObject, PyObject, PyObjectRef, PyResult,
+    builtins::PyIntRef,
+    function::OptionalArg,
+    sliceable::SequenceIndexOp,
+    types::PyComparisonOp,
+    vm::{MAX_MEMORY_SIZE, VirtualMachine},
+};
+use core::ops::{Deref, Range};
+use optional::Optioned;
+
+pub trait MutObjectSequenceOp {
+    type Inner: ?Sized;
+
+    fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObject>;
+    fn do_lock(&self) -> impl Deref<Target = Self::Inner>;
+
+    fn mut_count(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<usize> {
+        let mut count = 0;
+        self._mut_iter_equal_skeleton::<_, false>(vm, needle, 0..isize::MAX as usize, || {
+            count += 1
+        })?;
+        Ok(count)
+    }
+
+    fn mut_index_range(
+        &self,
+        vm: &VirtualMachine,
+        needle: &PyObject,
+        range: Range<usize>,
+    ) -> PyResult<Optioned<usize>> {
+        self._mut_iter_equal_skeleton::<_, true>(vm, needle, range, || {})
+    }
+
+    fn mut_index(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<Optioned<usize>> {
+        self.mut_index_range(vm, needle, 0..isize::MAX as usize)
+    }
+
+    fn mut_contains(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<bool> {
+        self.mut_index(vm, needle).map(|x| x.is_some())
+    }
+
+    fn _mut_iter_equal_skeleton<F, const SHORT: bool>(
+        &self,
+        vm: &VirtualMachine,
+        needle: &PyObject,
+        range: Range<usize>,
+        mut f: F,
+    ) -> PyResult<Optioned<usize>>
+    where
+        F: FnMut(),
+    {
+        let mut borrower = None;
+        let mut i = range.start;
+
+        let index = loop {
+            if i >= range.end {
+                break Optioned::<usize>::none();
+            }
+            let guard = if let Some(x) = borrower.take() {
+                x
+            } else {
+                self.do_lock()
+            };
+
+            let elem = if let Some(x) = Self::do_get(i, &guard) {
+                x
+            } else {
+                break Optioned::<usize>::none();
+            };
+
+            if elem.is(needle) {
+                f();
+                if SHORT {
+                    break Optioned::<usize>::some(i);
+                }
+                borrower = Some(guard);
+            } else {
+                let elem = elem.to_owned();
+                drop(guard);
+
+                if elem.rich_compare_bool(needle, PyComparisonOp::Eq, vm)? {
+                    f();
+                    if SHORT {
+                        break Optioned::<usize>::some(i);
+                    }
+                }
+            }
+            i += 1;
+        };
+
+        Ok(index)
+    }
+}
+
+pub trait SequenceExt<T: Clone>
+where
+    Self: AsRef<[T]>,
+{
+    fn mul(&self, vm: &VirtualMachine, n: isize) -> PyResult<Vec<T>> {
+        let n = vm.check_repeat_or_overflow_error(self.as_ref().len(), n)?;
+
+        if n > 1 && core::mem::size_of_val(self.as_ref()) >= MAX_MEMORY_SIZE / n {
+            return Err(vm.new_memory_error(""));
+        }
+
+        let mut v = Vec::with_capacity(n * self.as_ref().len());
+        for _ in 0..n {
+            v.extend_from_slice(self.as_ref());
+        }
+        Ok(v)
+    }
+}
+
+impl<T: Clone> SequenceExt<T> for [T] {}
+
+pub trait SequenceMutExt<T: Clone>
+where
+    Self: AsRef<[T]>,
+{
+    fn as_vec_mut(&mut self) -> &mut Vec<T>;
+
+    fn imul(&mut self, vm: &VirtualMachine, n: isize) -> PyResult<()> {
+        let n = vm.check_repeat_or_overflow_error(self.as_ref().len(), n)?;
+        if n == 0 {
+            self.as_vec_mut().clear();
+        } else if n != 1 {
+            let mut sample = self.as_vec_mut().clone();
+            if n != 2 {
+                self.as_vec_mut().reserve(sample.len() * (n - 1));
+                for _ in 0..n - 2 {
+                    self.as_vec_mut().extend_from_slice(&sample);
+                }
+            }
+            self.as_vec_mut().append(&mut sample);
+        }
+        Ok(())
+    }
+}
+
+impl<T: Clone> SequenceMutExt<T> for Vec<T> {
+    fn as_vec_mut(&mut self) -> &mut Self {
+        self
+    }
+}
+
+#[derive(FromArgs)]
+pub struct OptionalRangeArgs {
+    #[pyarg(positional, optional)]
+    start: OptionalArg<PyObjectRef>,
+    #[pyarg(positional, optional)]
+    stop: OptionalArg<PyObjectRef>,
+}
+
+impl OptionalRangeArgs {
+    pub fn saturate(self, len: usize, vm: &VirtualMachine) -> PyResult<(usize, usize)> {
+        let saturate = |obj: PyObjectRef| -> PyResult<_> {
+            obj.try_into_value(vm)
+                .map(|int: PyIntRef| int.as_bigint().saturated_at(len))
+        };
+        let start = self.start.map_or(Ok(0), saturate)?;
+        let stop = self.stop.map_or(Ok(len), saturate)?;
+        Ok((start, stop))
+    }
+}
diff --git a/crates/vm/src/signal.rs b/crates/vm/src/signal.rs
new file mode 100644
index 0000000000..4a1b84a152
--- /dev/null
+++ b/crates/vm/src/signal.rs
@@ -0,0 +1,120 @@
+#![cfg_attr(target_os = "wasi", allow(dead_code))]
+use crate::{PyResult, VirtualMachine};
+use alloc::fmt;
+use core::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc;
+
+pub(crate) const NSIG: usize = 64;
+static ANY_TRIGGERED: AtomicBool = AtomicBool::new(false);
+// hack to get around const array repeat expressions, rust issue #79270
+#[allow(clippy::declare_interior_mutable_const)]
+const ATOMIC_FALSE: AtomicBool = AtomicBool::new(false);
+pub(crate) static TRIGGERS: [AtomicBool; NSIG] = [ATOMIC_FALSE; NSIG];
+
+#[cfg_attr(feature = "flame-it", flame)]
+#[inline(always)]
+pub fn check_signals(vm: &VirtualMachine) -> PyResult<()> {
+    if vm.signal_handlers.is_none() {
+        return Ok(());
+    }
+
+    if !ANY_TRIGGERED.swap(false, Ordering::Acquire) {
+        return Ok(());
+    }
+
+    trigger_signals(vm)
+}
+#[inline(never)]
+#[cold]
+fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
+    // unwrap should never fail since we check above
+    let signal_handlers = vm.signal_handlers.as_ref().unwrap().borrow();
+    for (signum, trigger) in TRIGGERS.iter().enumerate().skip(1) {
+        let triggered = trigger.swap(false, Ordering::Relaxed);
+        if triggered
+            && let Some(handler) = &signal_handlers[signum]
+            && let Some(callable) = handler.to_callable()
+        {
+            callable.invoke((signum, vm.ctx.none()), vm)?;
+        }
+    }
+    if let Some(signal_rx) = &vm.signal_rx {
+        for f in signal_rx.rx.try_iter() {
+            f(vm)?;
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn set_triggered() {
+    ANY_TRIGGERED.store(true, Ordering::Release);
+}
+
+pub fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
+    if (1..NSIG as i32).contains(&signum) {
+        Ok(())
+    } else {
+        Err(vm.new_value_error("signal number out of range"))
+    }
+}
+
+/// Similar to `PyErr_SetInterruptEx` in CPython
+///
+/// Missing signal handler for the given signal number is silently ignored.
+#[allow(dead_code)]
+#[cfg(not(target_arch = "wasm32"))]
+pub fn set_interrupt_ex(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
+    use crate::stdlib::signal::_signal::{SIG_DFL, SIG_IGN, run_signal};
+    assert_in_range(signum, vm)?;
+
+    match signum as usize {
+        SIG_DFL | SIG_IGN => Ok(()),
+        _ => {
+            // interrupt the main thread with given signal number
+            run_signal(signum);
+            Ok(())
+        }
+    }
+}
+
+pub type UserSignal = Box<dyn FnOnce(&VirtualMachine) -> PyResult<()> + Send>;
+
+#[derive(Clone, Debug)]
+pub struct UserSignalSender {
+    tx: mpsc::Sender<UserSignal>,
+}
+
+#[derive(Debug)]
+pub struct UserSignalReceiver {
+    rx: mpsc::Receiver<UserSignal>,
+}
+
+impl UserSignalSender {
+    pub fn send(&self, sig: UserSignal) -> Result<(), UserSignalSendError> {
+        self.tx
+            .send(sig)
+            .map_err(|mpsc::SendError(sig)| UserSignalSendError(sig))?;
+        set_triggered();
+        Ok(())
+    }
+}
+
+pub struct UserSignalSendError(pub UserSignal);
+
+impl fmt::Debug for UserSignalSendError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("UserSignalSendError")
+            .finish_non_exhaustive()
+    }
+}
+
+impl fmt::Display for UserSignalSendError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("sending a signal to a exited vm")
+    }
+}
+
+pub fn user_signal_channel() -> (UserSignalSender, UserSignalReceiver) {
+    let (tx, rx) = mpsc::channel();
+    (UserSignalSender { tx }, UserSignalReceiver { rx })
+}
diff --git a/vm/src/sliceable.rs b/crates/vm/src/sliceable.rs
similarity index 98%
rename from vm/src/sliceable.rs
rename to crates/vm/src/sliceable.rs
index 7d175d033e..e416f5a1b4 100644
--- a/vm/src/sliceable.rs
+++ b/crates/vm/src/sliceable.rs
@@ -3,9 +3,9 @@ use crate::{
     PyObject, PyResult, VirtualMachine,
     builtins::{int::PyInt, slice::PySlice},
 };
+use core::ops::Range;
 use malachite_bigint::BigInt;
 use num_traits::{Signed, ToPrimitive};
-use std::ops::Range;
 
 pub trait SliceableSequenceMutOp
 where
@@ -263,12 +263,12 @@ impl SequenceIndex {
         obj: &PyObject,
         type_name: &str,
     ) -> PyResult<Self> {
-        if let Some(i) = obj.payload::<PyInt>() {
+        if let Some(i) = obj.downcast_ref::<PyInt>() {
             // TODO: number protocol
             i.try_to_primitive(vm)
                 .map_err(|_| vm.new_index_error("cannot fit 'int' into an index-sized integer"))
                 .map(Self::Int)
-        } else if let Some(slice) = obj.payload::<PySlice>() {
+        } else if let Some(slice) = obj.downcast_ref::<PySlice>() {
             slice.to_saturated(vm).map(Self::Slice)
         } else if let Some(i) = obj.try_index_opt(vm) {
             // TODO: __index__ for indices is no more supported?
diff --git a/crates/vm/src/stdlib/ast.rs b/crates/vm/src/stdlib/ast.rs
new file mode 100644
index 0000000000..31aad306f9
--- /dev/null
+++ b/crates/vm/src/stdlib/ast.rs
@@ -0,0 +1,373 @@
+//! `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.
+
+mod pyast;
+
+use crate::builtins::{PyInt, PyStr};
+use crate::stdlib::ast::module::{Mod, ModInteractive};
+use crate::stdlib::ast::node::BoxedSlice;
+use crate::stdlib::ast::python::_ast;
+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 ruff;
+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 {
+        ruff::Mod::Module(m) => Mod::Module(m),
+        ruff::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) => ruff::Mod::Module(m),
+        Mod::Interactive(ModInteractive { range, body }) => ruff::Mod::Module(ruff::ModModule {
+            node_index: Default::default(),
+            range,
+            body,
+        }),
+        Mod::Expression(e) => ruff::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;
+
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _ast::make_module(vm);
+    pyast::extend_module_nodes(vm, &module);
+    module
+}
diff --git a/crates/vm/src/stdlib/ast/argument.rs b/crates/vm/src/stdlib/ast/argument.rs
new file mode 100644
index 0000000000..a13200e650
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/argument.rs
@@ -0,0 +1,166 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+pub(super) struct PositionalArguments {
+    pub range: TextRange,
+    pub args: Box<[ruff::Expr]>,
+}
+
+impl Node for PositionalArguments {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { args, range: _ } = self;
+        BoxedSlice(args).ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let args: BoxedSlice<_> = Node::ast_from_object(vm, source_file, object)?;
+        Ok(Self {
+            args: args.0,
+            range: TextRange::default(), // TODO
+        })
+    }
+}
+
+pub(super) struct KeywordArguments {
+    pub range: TextRange,
+    pub keywords: Box<[ruff::Keyword]>,
+}
+
+impl Node for KeywordArguments {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { keywords, range: _ } = self;
+        // TODO: use range
+        BoxedSlice(keywords).ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let keywords: BoxedSlice<_> = Node::ast_from_object(vm, source_file, object)?;
+        Ok(Self {
+            keywords: keywords.0,
+            range: TextRange::default(), // TODO
+        })
+    }
+}
+
+pub(super) fn merge_function_call_arguments(
+    pos_args: PositionalArguments,
+    key_args: KeywordArguments,
+) -> ruff::Arguments {
+    let range = pos_args.range.cover(key_args.range);
+
+    ruff::Arguments {
+        node_index: Default::default(),
+        range,
+        args: pos_args.args,
+        keywords: key_args.keywords,
+    }
+}
+
+pub(super) fn split_function_call_arguments(
+    args: ruff::Arguments,
+) -> (PositionalArguments, KeywordArguments) {
+    let ruff::Arguments {
+        node_index: _,
+        range: _,
+        args,
+        keywords,
+    } = args;
+
+    let positional_arguments_range = args
+        .iter()
+        .map(|item| item.range())
+        .reduce(|acc, next| acc.cover(next))
+        .unwrap_or_default();
+    // debug_assert!(range.contains_range(positional_arguments_range));
+    let positional_arguments = PositionalArguments {
+        range: positional_arguments_range,
+        args,
+    };
+
+    let keyword_arguments_range = keywords
+        .iter()
+        .map(|item| item.range())
+        .reduce(|acc, next| acc.cover(next))
+        .unwrap_or_default();
+    // debug_assert!(range.contains_range(keyword_arguments_range));
+    let keyword_arguments = KeywordArguments {
+        range: keyword_arguments_range,
+        keywords,
+    };
+
+    (positional_arguments, keyword_arguments)
+}
+
+pub(super) fn split_class_def_args(
+    args: Option<Box<ruff::Arguments>>,
+) -> (Option<PositionalArguments>, Option<KeywordArguments>) {
+    let args = match args {
+        None => return (None, None),
+        Some(args) => *args,
+    };
+    let ruff::Arguments {
+        node_index: _,
+        range: _,
+        args,
+        keywords,
+    } = args;
+
+    let positional_arguments_range = args
+        .iter()
+        .map(|item| item.range())
+        .reduce(|acc, next| acc.cover(next))
+        .unwrap_or_default();
+    // debug_assert!(range.contains_range(positional_arguments_range));
+    let positional_arguments = PositionalArguments {
+        range: positional_arguments_range,
+        args,
+    };
+
+    let keyword_arguments_range = keywords
+        .iter()
+        .map(|item| item.range())
+        .reduce(|acc, next| acc.cover(next))
+        .unwrap_or_default();
+    // debug_assert!(range.contains_range(keyword_arguments_range));
+    let keyword_arguments = KeywordArguments {
+        range: keyword_arguments_range,
+        keywords,
+    };
+
+    (Some(positional_arguments), Some(keyword_arguments))
+}
+
+pub(super) fn merge_class_def_args(
+    positional_arguments: Option<PositionalArguments>,
+    keyword_arguments: Option<KeywordArguments>,
+) -> Option<Box<ruff::Arguments>> {
+    if positional_arguments.is_none() && keyword_arguments.is_none() {
+        return None;
+    }
+
+    let args = if let Some(positional_arguments) = positional_arguments {
+        positional_arguments.args
+    } else {
+        vec![].into_boxed_slice()
+    };
+    let keywords = if let Some(keyword_arguments) = keyword_arguments {
+        keyword_arguments.keywords
+    } else {
+        vec![].into_boxed_slice()
+    };
+
+    Some(Box::new(ruff::Arguments {
+        node_index: Default::default(),
+        range: Default::default(), // TODO
+        args,
+        keywords,
+    }))
+}
diff --git a/crates/vm/src/stdlib/ast/basic.rs b/crates/vm/src/stdlib/ast/basic.rs
new file mode 100644
index 0000000000..d8565029d6
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/basic.rs
@@ -0,0 +1,50 @@
+use super::*;
+use rustpython_codegen::compile::ruff_int_to_bigint;
+use rustpython_compiler_core::SourceFile;
+
+impl Node for ruff::Identifier {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let id = self.as_str();
+        vm.ctx.new_str(id).into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let py_str = PyStrRef::try_from_object(vm, object)?;
+        Ok(Self::new(py_str.as_str(), TextRange::default()))
+    }
+}
+
+impl Node for ruff::Int {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        vm.ctx.new_int(ruff_int_to_bigint(&self).unwrap()).into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        // FIXME: performance
+        let value: PyIntRef = object.try_into_value(vm)?;
+        let value = value.as_bigint().to_string();
+        Ok(value.parse().unwrap())
+    }
+}
+
+impl Node for bool {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        vm.ctx.new_int(self as u8).into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        i32::try_from_object(vm, object).map(|i| i != 0)
+    }
+}
diff --git a/vm/src/stdlib/ast/constant.rs b/crates/vm/src/stdlib/ast/constant.rs
similarity index 79%
rename from vm/src/stdlib/ast/constant.rs
rename to crates/vm/src/stdlib/ast/constant.rs
index 422a352972..83b2a7f701 100644
--- a/vm/src/stdlib/ast/constant.rs
+++ b/crates/vm/src/stdlib/ast/constant.rs
@@ -1,6 +1,7 @@
 use super::*;
 use crate::builtins::{PyComplex, PyFrozenSet, PyTuple};
 use ruff::str_prefix::StringLiteralPrefix;
+use rustpython_compiler_core::SourceFile;
 
 #[derive(Debug)]
 pub(super) struct Constant {
@@ -97,7 +98,7 @@ pub(crate) enum ConstantLiteral {
 
 // constructor
 impl Node for Constant {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self { range, value } = self;
         let node = NodeAst
             .into_ref_with_type(vm, pyast::NodeExprConstant::static_type().to_owned())
@@ -109,50 +110,50 @@ impl Node for Constant {
             } => vm.ctx.new_str("u").into(),
             _ => vm.ctx.none(),
         };
-        let value = value.ast_to_object(vm, source_code);
+        let value = value.ast_to_object(vm, source_file);
         let dict = node.as_object().dict().unwrap();
         dict.set_item("value", value, vm).unwrap();
         dict.set_item("kind", kind, vm).unwrap();
-        node_add_location(&dict, range, vm, source_code);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
         let value_object = get_node_field(vm, &object, "value", "Constant")?;
-        let value = Node::ast_from_object(vm, source_code, value_object)?;
+        let value = Node::ast_from_object(vm, source_file, value_object)?;
 
         Ok(Self {
             value,
             // kind: get_node_field_opt(_vm, &_object, "kind")?
             //     .map(|obj| Node::ast_from_object(_vm, obj))
             //     .transpose()?,
-            range: range_from_object(vm, source_code, object, "Constant")?,
+            range: range_from_object(vm, source_file, object, "Constant")?,
         })
     }
 }
 
 impl Node for ConstantLiteral {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
             Self::None => vm.ctx.none(),
             Self::Bool(value) => vm.ctx.new_bool(value).to_pyobject(vm),
             Self::Str { value, .. } => vm.ctx.new_str(value).to_pyobject(vm),
             Self::Bytes(value) => vm.ctx.new_bytes(value.into()).to_pyobject(vm),
-            Self::Int(value) => value.ast_to_object(vm, source_code),
+            Self::Int(value) => value.ast_to_object(vm, source_file),
             Self::Tuple(value) => {
                 let value = value
                     .into_iter()
-                    .map(|c| c.ast_to_object(vm, source_code))
+                    .map(|c| c.ast_to_object(vm, source_file))
                     .collect();
                 vm.ctx.new_tuple(value).to_pyobject(vm)
             }
             Self::FrozenSet(value) => PyFrozenSet::from_iter(
                 vm,
-                value.into_iter().map(|c| c.ast_to_object(vm, source_code)),
+                value.into_iter().map(|c| c.ast_to_object(vm, source_file)),
             )
             .unwrap()
             .into_pyobject(vm),
@@ -161,13 +162,13 @@ impl Node for ConstantLiteral {
                 .ctx
                 .new_complex(num_complex::Complex::new(real, imag))
                 .into_pyobject(vm),
-            Self::Ellipsis => vm.ctx.ellipsis(),
+            Self::Ellipsis => vm.ctx.ellipsis.clone().into(),
         }
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         value_object: PyObjectRef,
     ) -> PyResult<Self> {
         let cls = value_object.class();
@@ -189,7 +190,7 @@ impl Node for ConstantLiteral {
         } else if cls.is(vm.ctx.types.bytes_type) {
             Self::Bytes(value_object.try_to_value::<Vec<u8>>(vm)?.into())
         } else if cls.is(vm.ctx.types.int_type) {
-            Self::Int(Node::ast_from_object(vm, source_code, value_object)?)
+            Self::Int(Node::ast_from_object(vm, source_file, value_object)?)
         } else if cls.is(vm.ctx.types.tuple_type) {
             let tuple = value_object.downcast::<PyTuple>().map_err(|obj| {
                 vm.new_type_error(format!(
@@ -201,7 +202,7 @@ impl Node for ConstantLiteral {
             let tuple = tuple
                 .into_iter()
                 .cloned()
-                .map(|object| Node::ast_from_object(vm, source_code, object))
+                .map(|object| Node::ast_from_object(vm, source_file, object))
                 .collect::<PyResult<_>>()?;
             Self::Tuple(tuple)
         } else if cls.is(vm.ctx.types.frozenset_type) {
@@ -209,7 +210,7 @@ impl Node for ConstantLiteral {
             let elements = set
                 .elements()
                 .into_iter()
-                .map(|object| Node::ast_from_object(vm, source_code, object))
+                .map(|object| Node::ast_from_object(vm, source_file, object))
                 .collect::<PyResult<_>>()?;
             Self::FrozenSet(elements)
         } else if cls.is(vm.ctx.types.float_type) {
@@ -235,7 +236,7 @@ impl Node for ConstantLiteral {
             Self::Ellipsis
         } else {
             return Err(vm.new_type_error(format!(
-                "invalid type in Constant: {}",
+                "got an invalid type in Constant: {}",
                 value_object.class().name()
             )));
         };
@@ -246,14 +247,21 @@ impl Node for ConstantLiteral {
 fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
     let Constant { value, range } = value;
     match value {
-        ConstantLiteral::None => ruff::Expr::NoneLiteral(ruff::ExprNoneLiteral { range }),
-        ConstantLiteral::Bool(value) => {
-            ruff::Expr::BooleanLiteral(ruff::ExprBooleanLiteral { range, value })
-        }
+        ConstantLiteral::None => ruff::Expr::NoneLiteral(ruff::ExprNoneLiteral {
+            node_index: Default::default(),
+            range,
+        }),
+        ConstantLiteral::Bool(value) => ruff::Expr::BooleanLiteral(ruff::ExprBooleanLiteral {
+            node_index: Default::default(),
+            range,
+            value,
+        }),
         ConstantLiteral::Str { value, prefix } => {
             ruff::Expr::StringLiteral(ruff::ExprStringLiteral {
+                node_index: Default::default(),
                 range,
                 value: ruff::StringLiteralValue::single(ruff::StringLiteral {
+                    node_index: Default::default(),
                     range,
                     value,
                     flags: ruff::StringLiteralFlags::empty().with_prefix(prefix),
@@ -262,8 +270,10 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
         }
         ConstantLiteral::Bytes(value) => {
             ruff::Expr::BytesLiteral(ruff::ExprBytesLiteral {
+                node_index: Default::default(),
                 range,
                 value: ruff::BytesLiteralValue::single(ruff::BytesLiteral {
+                    node_index: Default::default(),
                     range,
                     value,
                     flags: ruff::BytesLiteralFlags::empty(), // TODO
@@ -271,10 +281,12 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
             })
         }
         ConstantLiteral::Int(value) => ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+            node_index: Default::default(),
             range,
             value: ruff::Number::Int(value),
         }),
         ConstantLiteral::Tuple(value) => ruff::Expr::Tuple(ruff::ExprTuple {
+            node_index: Default::default(),
             range,
             elts: value
                 .into_iter()
@@ -290,14 +302,17 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
             parenthesized: true,
         }),
         ConstantLiteral::FrozenSet(value) => ruff::Expr::Call(ruff::ExprCall {
+            node_index: Default::default(),
             range,
             // idk lol
             func: Box::new(ruff::Expr::Name(ruff::ExprName {
+                node_index: Default::default(),
                 range: TextRange::default(),
                 id: ruff::name::Name::new_static("frozenset"),
                 ctx: ruff::ExprContext::Load,
             })),
             arguments: ruff::Arguments {
+                node_index: Default::default(),
                 range,
                 args: value
                     .into_iter()
@@ -312,86 +327,111 @@ fn constant_to_ruff_expr(value: Constant) -> ruff::Expr {
             },
         }),
         ConstantLiteral::Float(value) => ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+            node_index: Default::default(),
             range,
             value: ruff::Number::Float(value),
         }),
         ConstantLiteral::Complex { real, imag } => {
             ruff::Expr::NumberLiteral(ruff::ExprNumberLiteral {
+                node_index: Default::default(),
                 range,
                 value: ruff::Number::Complex { real, imag },
             })
         }
-        ConstantLiteral::Ellipsis => {
-            ruff::Expr::EllipsisLiteral(ruff::ExprEllipsisLiteral { range })
-        }
+        ConstantLiteral::Ellipsis => ruff::Expr::EllipsisLiteral(ruff::ExprEllipsisLiteral {
+            node_index: Default::default(),
+            range,
+        }),
     }
 }
 
 pub(super) fn number_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprNumberLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprNumberLiteral { range, value } = constant;
+    let ruff::ExprNumberLiteral {
+        node_index: _,
+        range,
+        value,
+    } = constant;
     let c = match value {
         ruff::Number::Int(n) => Constant::new_int(n, range),
         ruff::Number::Float(n) => Constant::new_float(n, range),
         ruff::Number::Complex { real, imag } => Constant::new_complex(real, imag, range),
     };
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
 
 pub(super) fn string_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprStringLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprStringLiteral { range, value } = constant;
+    let ruff::ExprStringLiteral {
+        node_index: _,
+        range,
+        value,
+    } = constant;
     let prefix = value
         .iter()
         .next()
         .map_or(StringLiteralPrefix::Empty, |part| part.flags.prefix());
     let c = Constant::new_str(value.to_str(), prefix, range);
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
 
 pub(super) fn bytes_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprBytesLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprBytesLiteral { range, value } = constant;
+    let ruff::ExprBytesLiteral {
+        node_index: _,
+        range,
+        value,
+    } = constant;
     let bytes = value.as_slice().iter().flat_map(|b| b.value.iter());
     let c = Constant::new_bytes(bytes.copied().collect(), range);
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
 
 pub(super) fn boolean_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprBooleanLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprBooleanLiteral { range, value } = constant;
+    let ruff::ExprBooleanLiteral {
+        node_index: _,
+        range,
+        value,
+    } = constant;
     let c = Constant::new_bool(value, range);
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
 
 pub(super) fn none_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprNoneLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprNoneLiteral { range } = constant;
+    let ruff::ExprNoneLiteral {
+        node_index: _,
+        range,
+    } = constant;
     let c = Constant::new_none(range);
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
 
 pub(super) fn ellipsis_literal_to_object(
     vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
+    source_file: &SourceFile,
     constant: ruff::ExprEllipsisLiteral,
 ) -> PyObjectRef {
-    let ruff::ExprEllipsisLiteral { range } = constant;
+    let ruff::ExprEllipsisLiteral {
+        node_index: _,
+        range,
+    } = constant;
     let c = Constant::new_ellipsis(range);
-    c.ast_to_object(vm, source_code)
+    c.ast_to_object(vm, source_file)
 }
diff --git a/crates/vm/src/stdlib/ast/elif_else_clause.rs b/crates/vm/src/stdlib/ast/elif_else_clause.rs
new file mode 100644
index 0000000000..e2a8789dd0
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/elif_else_clause.rs
@@ -0,0 +1,98 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+pub(super) fn ast_to_object(
+    clause: ruff::ElifElseClause,
+    mut rest: alloc::vec::IntoIter<ruff::ElifElseClause>,
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+) -> PyObjectRef {
+    let ruff::ElifElseClause {
+        node_index: _,
+        range,
+        test,
+        body,
+    } = clause;
+    let Some(test) = test else {
+        assert!(rest.len() == 0);
+        return body.ast_to_object(vm, source_file);
+    };
+    let node = NodeAst
+        .into_ref_with_type(vm, pyast::NodeStmtIf::static_type().to_owned())
+        .unwrap();
+    let dict = node.as_object().dict().unwrap();
+
+    dict.set_item("test", test.ast_to_object(vm, source_file), vm)
+        .unwrap();
+    dict.set_item("body", body.ast_to_object(vm, source_file), vm)
+        .unwrap();
+
+    let orelse = if let Some(next) = rest.next() {
+        if next.test.is_some() {
+            vm.ctx
+                .new_list(vec![ast_to_object(next, rest, vm, source_file)])
+                .into()
+        } else {
+            next.body.ast_to_object(vm, source_file)
+        }
+    } else {
+        vm.ctx.new_list(vec![]).into()
+    };
+    dict.set_item("orelse", orelse, vm).unwrap();
+
+    node_add_location(&dict, range, vm, source_file);
+    node.into()
+}
+
+pub(super) fn ast_from_object(
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+    object: PyObjectRef,
+) -> PyResult<ruff::StmtIf> {
+    let test = Node::ast_from_object(vm, source_file, get_node_field(vm, &object, "test", "If")?)?;
+    let body = Node::ast_from_object(vm, source_file, get_node_field(vm, &object, "body", "If")?)?;
+    let orelse: Vec<ruff::Stmt> = Node::ast_from_object(
+        vm,
+        source_file,
+        get_node_field(vm, &object, "orelse", "If")?,
+    )?;
+    let range = range_from_object(vm, source_file, object, "If")?;
+
+    let elif_else_clauses = if let [ruff::Stmt::If(_)] = &*orelse {
+        let Some(ruff::Stmt::If(ruff::StmtIf {
+            node_index: _,
+            range,
+            test,
+            body,
+            mut elif_else_clauses,
+        })) = orelse.into_iter().next()
+        else {
+            unreachable!()
+        };
+        elif_else_clauses.insert(
+            0,
+            ruff::ElifElseClause {
+                node_index: Default::default(),
+                range,
+                test: Some(*test),
+                body,
+            },
+        );
+        elif_else_clauses
+    } else {
+        vec![ruff::ElifElseClause {
+            node_index: Default::default(),
+            range,
+            test: None,
+            body: orelse,
+        }]
+    };
+
+    Ok(ruff::StmtIf {
+        node_index: Default::default(),
+        test,
+        body,
+        elif_else_clauses,
+        range,
+    })
+}
diff --git a/crates/vm/src/stdlib/ast/exception.rs b/crates/vm/src/stdlib/ast/exception.rs
new file mode 100644
index 0000000000..b5b3ca2709
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/exception.rs
@@ -0,0 +1,82 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+// sum
+impl Node for ruff::ExceptHandler {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::ExceptHandler(cons) => cons.ast_to_object(vm, source_file),
+        }
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(
+            if _cls.is(pyast::NodeExceptHandlerExceptHandler::static_type()) {
+                Self::ExceptHandler(ruff::ExceptHandlerExceptHandler::ast_from_object(
+                    _vm,
+                    source_file,
+                    _object,
+                )?)
+            } else {
+                return Err(_vm.new_type_error(format!(
+                    "expected some sort of excepthandler, but got {}",
+                    _object.repr(_vm)?
+                )));
+            },
+        )
+    }
+}
+
+// constructor
+impl Node for ruff::ExceptHandlerExceptHandler {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            type_,
+            name,
+            body,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(
+                _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)
+            .unwrap();
+        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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _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))
+                .transpose()?,
+            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,
+                source_file,
+                get_node_field(_vm, &_object, "body", "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
new file mode 100644
index 0000000000..c63d0e0df6
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/expression.rs
@@ -0,0 +1,1324 @@
+use super::*;
+use crate::stdlib::ast::{
+    argument::{merge_function_call_arguments, split_function_call_arguments},
+    constant::Constant,
+    string::JoinedStr,
+};
+use rustpython_compiler_core::SourceFile;
+
+// sum
+impl Node for ruff::Expr {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::BoolOp(cons) => cons.ast_to_object(vm, source_file),
+            Self::Name(cons) => cons.ast_to_object(vm, source_file),
+            Self::BinOp(cons) => cons.ast_to_object(vm, source_file),
+            Self::UnaryOp(cons) => cons.ast_to_object(vm, source_file),
+            Self::Lambda(cons) => cons.ast_to_object(vm, source_file),
+            Self::If(cons) => cons.ast_to_object(vm, source_file),
+            Self::Dict(cons) => cons.ast_to_object(vm, source_file),
+            Self::Set(cons) => cons.ast_to_object(vm, source_file),
+            Self::ListComp(cons) => cons.ast_to_object(vm, source_file),
+            Self::SetComp(cons) => cons.ast_to_object(vm, source_file),
+            Self::DictComp(cons) => cons.ast_to_object(vm, source_file),
+            Self::Generator(cons) => cons.ast_to_object(vm, source_file),
+            Self::Await(cons) => cons.ast_to_object(vm, source_file),
+            Self::Yield(cons) => cons.ast_to_object(vm, source_file),
+            Self::YieldFrom(cons) => cons.ast_to_object(vm, source_file),
+            Self::Compare(cons) => cons.ast_to_object(vm, source_file),
+            Self::Call(cons) => cons.ast_to_object(vm, source_file),
+            Self::Attribute(cons) => cons.ast_to_object(vm, source_file),
+            Self::Subscript(cons) => cons.ast_to_object(vm, source_file),
+            Self::Starred(cons) => cons.ast_to_object(vm, source_file),
+            Self::List(cons) => cons.ast_to_object(vm, source_file),
+            Self::Tuple(cons) => cons.ast_to_object(vm, source_file),
+            Self::Slice(cons) => cons.ast_to_object(vm, source_file),
+            Self::NumberLiteral(cons) => constant::number_literal_to_object(vm, source_file, cons),
+            Self::StringLiteral(cons) => constant::string_literal_to_object(vm, source_file, cons),
+            Self::FString(cons) => string::fstring_to_object(vm, source_file, cons),
+            Self::TString(cons) => string::tstring_to_object(vm, source_file, cons),
+            Self::BytesLiteral(cons) => constant::bytes_literal_to_object(vm, source_file, cons),
+            Self::BooleanLiteral(cons) => {
+                constant::boolean_literal_to_object(vm, source_file, cons)
+            }
+            Self::NoneLiteral(cons) => constant::none_literal_to_object(vm, source_file, cons),
+            Self::EllipsisLiteral(cons) => {
+                constant::ellipsis_literal_to_object(vm, source_file, cons)
+            }
+            Self::Named(cons) => cons.ast_to_object(vm, source_file),
+            Self::IpyEscapeCommand(_) => {
+                unimplemented!("IPython escape command is not allowed in Python AST")
+            }
+        }
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeExprBoolOp::static_type()) {
+            Self::BoolOp(ruff::ExprBoolOp::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprNamedExpr::static_type()) {
+            Self::Named(ruff::ExprNamed::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprBinOp::static_type()) {
+            Self::BinOp(ruff::ExprBinOp::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprUnaryOp::static_type()) {
+            Self::UnaryOp(ruff::ExprUnaryOp::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprLambda::static_type()) {
+            Self::Lambda(ruff::ExprLambda::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprIfExp::static_type()) {
+            Self::If(ruff::ExprIf::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprDict::static_type()) {
+            Self::Dict(ruff::ExprDict::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprSet::static_type()) {
+            Self::Set(ruff::ExprSet::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprListComp::static_type()) {
+            Self::ListComp(ruff::ExprListComp::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprSetComp::static_type()) {
+            Self::SetComp(ruff::ExprSetComp::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprDictComp::static_type()) {
+            Self::DictComp(ruff::ExprDictComp::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprGeneratorExp::static_type()) {
+            Self::Generator(ruff::ExprGenerator::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprAwait::static_type()) {
+            Self::Await(ruff::ExprAwait::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprYield::static_type()) {
+            Self::Yield(ruff::ExprYield::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprYieldFrom::static_type()) {
+            Self::YieldFrom(ruff::ExprYieldFrom::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprCompare::static_type()) {
+            Self::Compare(ruff::ExprCompare::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprCall::static_type()) {
+            Self::Call(ruff::ExprCall::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprAttribute::static_type()) {
+            Self::Attribute(ruff::ExprAttribute::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprSubscript::static_type()) {
+            Self::Subscript(ruff::ExprSubscript::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeExprStarred::static_type()) {
+            Self::Starred(ruff::ExprStarred::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprName::static_type()) {
+            Self::Name(ruff::ExprName::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprList::static_type()) {
+            Self::List(ruff::ExprList::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprTuple::static_type()) {
+            Self::Tuple(ruff::ExprTuple::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprSlice::static_type()) {
+            Self::Slice(ruff::ExprSlice::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeExprConstant::static_type()) {
+            Constant::ast_from_object(vm, source_file, object)?.into_expr()
+        } else if cls.is(pyast::NodeExprJoinedStr::static_type()) {
+            JoinedStr::ast_from_object(vm, source_file, object)?.into_expr()
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected some sort of expr, but got {}",
+                object.repr(vm)?
+            )));
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprBoolOp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            op,
+            values,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprBoolOp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("op", op.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("values", values.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            op: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "op", "BoolOp")?,
+            )?,
+            values: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "values", "BoolOp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "BoolOp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprNamed {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            target,
+            value,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprNamedExpr::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("target", target.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            target: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "target", "NamedExpr")?,
+            )?,
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "NamedExpr")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "NamedExpr")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprBinOp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            left,
+            op,
+            right,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprBinOp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("left", left.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("op", op.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("right", right.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            left: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "left", "BinOp")?,
+            )?,
+            op: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "op", "BinOp")?,
+            )?,
+            right: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "right", "BinOp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "BinOp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprUnaryOp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            op,
+            operand,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprUnaryOp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("op", op.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("operand", operand.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            op: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "op", "UnaryOp")?,
+            )?,
+            operand: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "operand", "UnaryOp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "UnaryOp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprLambda {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            parameters,
+            body,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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();
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            parameters: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "args", "Lambda")?,
+            )?,
+            body: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "body", "Lambda")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Lambda")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprIf {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            test,
+            body,
+            orelse,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprIfExp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("test", test.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("orelse", orelse.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            test: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "test", "IfExp")?,
+            )?,
+            body: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "body", "IfExp")?,
+            )?,
+            orelse: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "orelse", "IfExp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "IfExp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprDict {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            items,
+            range,
+        } = self;
+        let (keys, values) =
+            items
+                .into_iter()
+                .fold((vec![], vec![]), |(mut keys, mut values), item| {
+                    keys.push(item.key);
+                    values.push(item.value);
+                    (keys, values)
+                });
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprDict::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("keys", keys.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("values", values.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let keys: Vec<Option<ruff::Expr>> = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "keys", "Dict")?,
+        )?;
+        let values: Vec<_> = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "values", "Dict")?,
+        )?;
+        let items = keys
+            .into_iter()
+            .zip(values)
+            .map(|(key, value)| ruff::DictItem { key, value })
+            .collect();
+        Ok(Self {
+            node_index: Default::default(),
+            items,
+            range: range_from_object(vm, source_file, object, "Dict")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprSet {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elts,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprSet::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elts", elts.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elts: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elts", "Set")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Set")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprListComp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elt,
+            generators,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprListComp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elt", elt.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("generators", generators.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elt: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elt", "ListComp")?,
+            )?,
+            generators: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "generators", "ListComp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "ListComp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprSetComp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elt,
+            generators,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprSetComp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elt", elt.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("generators", generators.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elt: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elt", "SetComp")?,
+            )?,
+            generators: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "generators", "SetComp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "SetComp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprDictComp {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            key,
+            value,
+            generators,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprDictComp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("key", key.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("generators", generators.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            key: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "key", "DictComp")?,
+            )?,
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "DictComp")?,
+            )?,
+            generators: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "generators", "DictComp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "DictComp")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprGenerator {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elt,
+            generators,
+            range,
+            parenthesized: _,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprGeneratorExp::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elt", elt.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("generators", generators.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elt: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elt", "GeneratorExp")?,
+            )?,
+            generators: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "generators", "GeneratorExp")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "GeneratorExp")?,
+            // TODO: Is this correct?
+            parenthesized: true,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprAwait {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprAwait::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Await")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Await")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprYield {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprYield::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: get_node_field_opt(vm, &object, "value")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "Yield")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprYieldFrom {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprYieldFrom::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "YieldFrom")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "YieldFrom")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprCompare {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            left,
+            ops,
+            comparators,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprCompare::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("left", left.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ops", BoxedSlice(ops).ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "comparators",
+            BoxedSlice(comparators).ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            left: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "left", "Compare")?,
+            )?,
+            ops: {
+                let ops: BoxedSlice<_> = Node::ast_from_object(
+                    vm,
+                    source_file,
+                    get_node_field(vm, &object, "ops", "Compare")?,
+                )?;
+                ops.0
+            },
+            comparators: {
+                let comparators: BoxedSlice<_> = Node::ast_from_object(
+                    vm,
+                    source_file,
+                    get_node_field(vm, &object, "comparators", "Compare")?,
+                )?;
+                comparators.0
+            },
+            range: range_from_object(vm, source_file, object, "Compare")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprCall {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            func,
+            arguments,
+            range,
+        } = self;
+        let (positional_arguments, keyword_arguments) = split_function_call_arguments(arguments);
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprCall::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("func", func.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "args",
+            positional_arguments.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        dict.set_item(
+            "keywords",
+            keyword_arguments.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            func: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "func", "Call")?,
+            )?,
+            arguments: merge_function_call_arguments(
+                Node::ast_from_object(
+                    vm,
+                    source_file,
+                    get_node_field(vm, &object, "args", "Call")?,
+                )?,
+                Node::ast_from_object(
+                    vm,
+                    source_file,
+                    get_node_field(vm, &object, "keywords", "Call")?,
+                )?,
+            ),
+            range: range_from_object(vm, source_file, object, "Call")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprAttribute {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            attr,
+            ctx,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprAttribute::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("attr", attr.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Attribute")?,
+            )?,
+            attr: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "attr", "Attribute")?,
+            )?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "Attribute")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Attribute")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprSubscript {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            slice,
+            ctx,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprSubscript::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("slice", slice.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Subscript")?,
+            )?,
+            slice: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "slice", "Subscript")?,
+            )?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "Subscript")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Subscript")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprStarred {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            ctx,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprStarred::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Starred")?,
+            )?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "Starred")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Starred")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprName {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            id,
+            ctx,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprName::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("id", id.to_pyobject(vm), vm).unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            id: Node::ast_from_object(vm, source_file, get_node_field(vm, &object, "id", "Name")?)?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "Name")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Name")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprList {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elts,
+            ctx,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprList::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elts", elts.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elts: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elts", "List")?,
+            )?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "List")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "List")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprTuple {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            elts,
+            ctx,
+            range: _range,
+            parenthesized: _,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprTuple::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("elts", elts.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ctx", ctx.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            elts: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "elts", "Tuple")?,
+            )?,
+            ctx: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ctx", "Tuple")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "Tuple")?,
+            parenthesized: true, // TODO: is this correct?
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ExprSlice {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            lower,
+            upper,
+            step,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprSlice::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("lower", lower.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("upper", upper.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("step", step.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            lower: get_node_field_opt(vm, &object, "lower")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            upper: get_node_field_opt(vm, &object, "upper")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            step: get_node_field_opt(vm, &object, "step")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "Slice")?,
+        })
+    }
+}
+
+// sum
+impl Node for ruff::ExprContext {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let node_type = match self {
+            Self::Load => pyast::NodeExprContextLoad::static_type(),
+            Self::Store => pyast::NodeExprContextStore::static_type(),
+            Self::Del => pyast::NodeExprContextDel::static_type(),
+            Self::Invalid => {
+                unimplemented!("Invalid expression context is not allowed in Python AST")
+            }
+        };
+        NodeAst
+            .into_ref_with_type(vm, node_type.to_owned())
+            .unwrap()
+            .into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = object.class();
+        Ok(if _cls.is(pyast::NodeExprContextLoad::static_type()) {
+            Self::Load
+        } else if _cls.is(pyast::NodeExprContextStore::static_type()) {
+            Self::Store
+        } else if _cls.is(pyast::NodeExprContextDel::static_type()) {
+            Self::Del
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected some sort of expr_context, but got {}",
+                object.repr(vm)?
+            )));
+        })
+    }
+}
+
+// product
+impl Node for ruff::Comprehension {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            target,
+            iter,
+            ifs,
+            is_async,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeComprehension::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("target", target.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("iter", iter.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("ifs", ifs.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("is_async", is_async.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            target: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "target", "comprehension")?,
+            )?,
+            iter: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "iter", "comprehension")?,
+            )?,
+            ifs: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "ifs", "comprehension")?,
+            )?,
+            is_async: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "is_async", "comprehension")?,
+            )?,
+            range: Default::default(),
+        })
+    }
+}
diff --git a/crates/vm/src/stdlib/ast/module.rs b/crates/vm/src/stdlib/ast/module.rs
new file mode 100644
index 0000000000..6fae8f10a3
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/module.rs
@@ -0,0 +1,236 @@
+use super::*;
+use crate::stdlib::ast::type_ignore::TypeIgnore;
+use rustpython_compiler_core::SourceFile;
+
+/// Represents the different types of Python module structures.
+///
+/// This enum is used to represent the various possible forms of a Python module
+/// in an Abstract Syntax Tree (AST). It can correspond to:
+///
+/// - `Module`: A standard Python script, containing a sequence of statements
+///   (e.g., assignments, function calls), possibly with type ignores.
+/// - `Interactive`: A representation of code executed in an interactive
+///   Python session (e.g., the REPL or Jupyter notebooks), where statements
+///   are evaluated one at a time.
+/// - `Expression`: A single expression without any surrounding statements.
+///   This is typically used in scenarios like `eval()` or in expression-only
+///   contexts.
+/// - `FunctionType`: A function signature with argument and return type
+///   annotations, representing the type hints of a function (e.g., `def add(x: int, y: int) -> int`).
+pub(super) enum Mod {
+    Module(ruff::ModModule),
+    Interactive(ModInteractive),
+    Expression(ruff::ModExpression),
+    FunctionType(ModFunctionType),
+}
+
+// sum
+impl Node for Mod {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::Module(cons) => cons.ast_to_object(vm, source_file),
+            Self::Interactive(cons) => cons.ast_to_object(vm, source_file),
+            Self::Expression(cons) => cons.ast_to_object(vm, source_file),
+            Self::FunctionType(cons) => cons.ast_to_object(vm, source_file),
+        }
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let cls = object.class();
+        Ok(if cls.is(pyast::NodeModModule::static_type()) {
+            Self::Module(ruff::ModModule::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeModInteractive::static_type()) {
+            Self::Interactive(ModInteractive::ast_from_object(vm, source_file, object)?)
+        } else if cls.is(pyast::NodeModExpression::static_type()) {
+            Self::Expression(ruff::ModExpression::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?)
+        } else if cls.is(pyast::NodeModFunctionType::static_type()) {
+            Self::FunctionType(ModFunctionType::ast_from_object(vm, source_file, object)?)
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected some sort of mod, but got {}",
+                object.repr(vm)?
+            )));
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ModModule {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            body,
+            // type_ignores,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeModModule::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        // TODO: Improve ruff API
+        // ruff ignores type_ignore comments currently.
+        let type_ignores: Vec<TypeIgnore> = vec![];
+        dict.set_item(
+            "type_ignores",
+            type_ignores.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            body: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "body", "Module")?,
+            )?,
+            // type_ignores: Node::ast_from_object(
+            //     _vm,
+            //     get_node_field(_vm, &_object, "type_ignores", "Module")?,
+            // )?,
+            range: Default::default(),
+        })
+    }
+}
+
+pub(super) struct ModInteractive {
+    pub(crate) range: TextRange,
+    pub(crate) body: Vec<ruff::Stmt>,
+}
+
+// constructor
+impl Node for ModInteractive {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { body, range } = self;
+        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.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            body: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "body", "Interactive")?,
+            )?,
+            range: Default::default(),
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::ModExpression {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            body,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeModExpression::static_type().to_owned())
+            .unwrap();
+        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);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            body: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "body", "Expression")?,
+            )?,
+            range: Default::default(),
+        })
+    }
+}
+
+pub(super) struct ModFunctionType {
+    pub(crate) argtypes: Box<[ruff::Expr]>,
+    pub(crate) returns: ruff::Expr,
+    pub(crate) range: TextRange,
+}
+
+// constructor
+impl Node for ModFunctionType {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            argtypes,
+            returns,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeModFunctionType::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item(
+            "argtypes",
+            BoxedSlice(argtypes).ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        dict.set_item("returns", returns.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            argtypes: {
+                let argtypes: BoxedSlice<_> = Node::ast_from_object(
+                    vm,
+                    source_file,
+                    get_node_field(vm, &object, "argtypes", "FunctionType")?,
+                )?;
+                argtypes.0
+            },
+            returns: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "returns", "FunctionType")?,
+            )?,
+            range: Default::default(),
+        })
+    }
+}
diff --git a/crates/vm/src/stdlib/ast/node.rs b/crates/vm/src/stdlib/ast/node.rs
new file mode 100644
index 0000000000..6f74e71511
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/node.rs
@@ -0,0 +1,94 @@
+use crate::{PyObjectRef, PyResult, VirtualMachine};
+use rustpython_compiler_core::SourceFile;
+
+pub(crate) trait Node: Sized {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef;
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self>;
+
+    /// Used in `Option::ast_from_object`; if `true`, that impl will return None.
+    fn is_none(&self) -> bool {
+        false
+    }
+}
+
+impl<T: Node> Node for Vec<T> {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        vm.ctx
+            .new_list(
+                self.into_iter()
+                    .map(|node| node.ast_to_object(vm, source_file))
+                    .collect(),
+            )
+            .into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        vm.extract_elements_with(&object, |obj| Node::ast_from_object(vm, source_file, obj))
+    }
+}
+
+impl<T: Node> Node for Box<T> {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        (*self).ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        T::ast_from_object(vm, source_file, object).map(Self::new)
+    }
+
+    fn is_none(&self) -> bool {
+        (**self).is_none()
+    }
+}
+
+impl<T: Node> Node for Option<T> {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Some(node) => node.ast_to_object(vm, source_file),
+            None => vm.ctx.none(),
+        }
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        if vm.is_none(&object) {
+            Ok(None)
+        } else {
+            let x = T::ast_from_object(vm, source_file, object)?;
+            Ok((!x.is_none()).then_some(x))
+        }
+    }
+}
+
+pub(super) struct BoxedSlice<T>(pub(super) Box<[T]>);
+
+impl<T: Node> Node for BoxedSlice<T> {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        self.0.into_vec().ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self(
+            <Vec<T> as Node>::ast_from_object(vm, source_file, object)?.into_boxed_slice(),
+        ))
+    }
+}
diff --git a/crates/vm/src/stdlib/ast/operator.rs b/crates/vm/src/stdlib/ast/operator.rs
new file mode 100644
index 0000000000..c394152da2
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/operator.rs
@@ -0,0 +1,193 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+// sum
+impl Node for ruff::BoolOp {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let node_type = match self {
+            Self::And => pyast::NodeBoolOpAnd::static_type(),
+            Self::Or => pyast::NodeBoolOpOr::static_type(),
+        };
+        NodeAst
+            .into_ref_with_type(vm, node_type.to_owned())
+            .unwrap()
+            .into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeBoolOpAnd::static_type()) {
+            Self::And
+        } else if _cls.is(pyast::NodeBoolOpOr::static_type()) {
+            Self::Or
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of boolop, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+
+// sum
+impl Node for ruff::Operator {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let node_type = match self {
+            Self::Add => pyast::NodeOperatorAdd::static_type(),
+            Self::Sub => pyast::NodeOperatorSub::static_type(),
+            Self::Mult => pyast::NodeOperatorMult::static_type(),
+            Self::MatMult => pyast::NodeOperatorMatMult::static_type(),
+            Self::Div => pyast::NodeOperatorDiv::static_type(),
+            Self::Mod => pyast::NodeOperatorMod::static_type(),
+            Self::Pow => pyast::NodeOperatorPow::static_type(),
+            Self::LShift => pyast::NodeOperatorLShift::static_type(),
+            Self::RShift => pyast::NodeOperatorRShift::static_type(),
+            Self::BitOr => pyast::NodeOperatorBitOr::static_type(),
+            Self::BitXor => pyast::NodeOperatorBitXor::static_type(),
+            Self::BitAnd => pyast::NodeOperatorBitAnd::static_type(),
+            Self::FloorDiv => pyast::NodeOperatorFloorDiv::static_type(),
+        };
+        NodeAst
+            .into_ref_with_type(vm, node_type.to_owned())
+            .unwrap()
+            .into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeOperatorAdd::static_type()) {
+            Self::Add
+        } else if _cls.is(pyast::NodeOperatorSub::static_type()) {
+            Self::Sub
+        } else if _cls.is(pyast::NodeOperatorMult::static_type()) {
+            Self::Mult
+        } else if _cls.is(pyast::NodeOperatorMatMult::static_type()) {
+            Self::MatMult
+        } else if _cls.is(pyast::NodeOperatorDiv::static_type()) {
+            Self::Div
+        } else if _cls.is(pyast::NodeOperatorMod::static_type()) {
+            Self::Mod
+        } else if _cls.is(pyast::NodeOperatorPow::static_type()) {
+            Self::Pow
+        } else if _cls.is(pyast::NodeOperatorLShift::static_type()) {
+            Self::LShift
+        } else if _cls.is(pyast::NodeOperatorRShift::static_type()) {
+            Self::RShift
+        } else if _cls.is(pyast::NodeOperatorBitOr::static_type()) {
+            Self::BitOr
+        } else if _cls.is(pyast::NodeOperatorBitXor::static_type()) {
+            Self::BitXor
+        } else if _cls.is(pyast::NodeOperatorBitAnd::static_type()) {
+            Self::BitAnd
+        } else if _cls.is(pyast::NodeOperatorFloorDiv::static_type()) {
+            Self::FloorDiv
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of operator, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+
+// sum
+impl Node for ruff::UnaryOp {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let node_type = match self {
+            Self::Invert => pyast::NodeUnaryOpInvert::static_type(),
+            Self::Not => pyast::NodeUnaryOpNot::static_type(),
+            Self::UAdd => pyast::NodeUnaryOpUAdd::static_type(),
+            Self::USub => pyast::NodeUnaryOpUSub::static_type(),
+        };
+        NodeAst
+            .into_ref_with_type(vm, node_type.to_owned())
+            .unwrap()
+            .into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeUnaryOpInvert::static_type()) {
+            Self::Invert
+        } else if _cls.is(pyast::NodeUnaryOpNot::static_type()) {
+            Self::Not
+        } else if _cls.is(pyast::NodeUnaryOpUAdd::static_type()) {
+            Self::UAdd
+        } else if _cls.is(pyast::NodeUnaryOpUSub::static_type()) {
+            Self::USub
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of unaryop, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+
+// sum
+impl Node for ruff::CmpOp {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        let node_type = match self {
+            Self::Eq => pyast::NodeCmpOpEq::static_type(),
+            Self::NotEq => pyast::NodeCmpOpNotEq::static_type(),
+            Self::Lt => pyast::NodeCmpOpLt::static_type(),
+            Self::LtE => pyast::NodeCmpOpLtE::static_type(),
+            Self::Gt => pyast::NodeCmpOpGt::static_type(),
+            Self::GtE => pyast::NodeCmpOpGtE::static_type(),
+            Self::Is => pyast::NodeCmpOpIs::static_type(),
+            Self::IsNot => pyast::NodeCmpOpIsNot::static_type(),
+            Self::In => pyast::NodeCmpOpIn::static_type(),
+            Self::NotIn => pyast::NodeCmpOpNotIn::static_type(),
+        };
+        NodeAst
+            .into_ref_with_type(vm, node_type.to_owned())
+            .unwrap()
+            .into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeCmpOpEq::static_type()) {
+            Self::Eq
+        } else if _cls.is(pyast::NodeCmpOpNotEq::static_type()) {
+            Self::NotEq
+        } else if _cls.is(pyast::NodeCmpOpLt::static_type()) {
+            Self::Lt
+        } else if _cls.is(pyast::NodeCmpOpLtE::static_type()) {
+            Self::LtE
+        } else if _cls.is(pyast::NodeCmpOpGt::static_type()) {
+            Self::Gt
+        } else if _cls.is(pyast::NodeCmpOpGtE::static_type()) {
+            Self::GtE
+        } else if _cls.is(pyast::NodeCmpOpIs::static_type()) {
+            Self::Is
+        } else if _cls.is(pyast::NodeCmpOpIsNot::static_type()) {
+            Self::IsNot
+        } else if _cls.is(pyast::NodeCmpOpIn::static_type()) {
+            Self::In
+        } else if _cls.is(pyast::NodeCmpOpNotIn::static_type()) {
+            Self::NotIn
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of cmpop, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
diff --git a/crates/vm/src/stdlib/ast/other.rs b/crates/vm/src/stdlib/ast/other.rs
new file mode 100644
index 0000000000..ce7d5fe480
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/other.rs
@@ -0,0 +1,151 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+impl Node for ruff::ConversionFlag {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        vm.ctx.new_int(self as u8).into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        // Python's AST uses ASCII codes: 's', 'r', 'a', -1=None
+        // Note: 255 is -1i8 as u8 (ruff's ConversionFlag::None)
+        match i32::try_from_object(vm, object)? {
+            -1 | 255 => Ok(Self::None),
+            x if x == b's' as i32 => Ok(Self::Str),
+            x if x == b'r' as i32 => Ok(Self::Repr),
+            x if x == b'a' as i32 => Ok(Self::Ascii),
+            _ => Err(vm.new_value_error("invalid conversion flag")),
+        }
+    }
+}
+
+// /// This is just a string, not strictly an AST node. But it makes AST conversions easier.
+impl Node for ruff::name::Name {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        vm.ctx.new_str(self.as_str()).to_pyobject(vm)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        match object.downcast::<PyStr>() {
+            Ok(name) => Ok(Self::new(name)),
+            Err(_) => Err(vm.new_value_error("expected str for name")),
+        }
+    }
+}
+
+impl Node for ruff::Decorator {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        ruff::Expr::ast_to_object(self.expression, vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let expression = ruff::Expr::ast_from_object(vm, source_file, object)?;
+        let range = expression.range();
+        Ok(Self {
+            node_index: Default::default(),
+            expression,
+            range,
+        })
+    }
+}
+
+// product
+impl Node for ruff::Alias {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            asname,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeAlias::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("name", name.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("asname", asname.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "name", "alias")?,
+            )?,
+            asname: get_node_field_opt(vm, &object, "asname")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "alias")?,
+        })
+    }
+}
+
+// product
+impl Node for ruff::WithItem {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            context_expr,
+            optional_vars,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeWithItem::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item(
+            "context_expr",
+            context_expr.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        dict.set_item(
+            "optional_vars",
+            optional_vars.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            context_expr: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "context_expr", "withitem")?,
+            )?,
+            optional_vars: get_node_field_opt(vm, &object, "optional_vars")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: Default::default(),
+        })
+    }
+}
diff --git a/vm/src/stdlib/ast/parameter.rs b/crates/vm/src/stdlib/ast/parameter.rs
similarity index 79%
rename from vm/src/stdlib/ast/parameter.rs
rename to crates/vm/src/stdlib/ast/parameter.rs
index b8bbfc9705..44fcbb2b46 100644
--- a/vm/src/stdlib/ast/parameter.rs
+++ b/crates/vm/src/stdlib/ast/parameter.rs
@@ -1,9 +1,11 @@
 use super::*;
+use rustpython_compiler_core::SourceFile;
 
 // product
 impl Node for ruff::Parameters {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
+            node_index: _,
             posonlyargs,
             args,
             vararg,
@@ -20,73 +22,74 @@ impl Node for ruff::Parameters {
         let dict = node.as_object().dict().unwrap();
         dict.set_item(
             "posonlyargs",
-            posonlyargs.ast_to_object(vm, source_code),
+            posonlyargs.ast_to_object(vm, source_file),
             vm,
         )
         .unwrap();
-        dict.set_item("args", args.ast_to_object(vm, source_code), vm)
+        dict.set_item("args", args.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("vararg", vararg.ast_to_object(vm, source_code), vm)
+        dict.set_item("vararg", vararg.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("kwonlyargs", kwonlyargs.ast_to_object(vm, source_code), vm)
+        dict.set_item("kwonlyargs", kwonlyargs.ast_to_object(vm, source_file), vm)
             .unwrap();
         dict.set_item(
             "kw_defaults",
-            kw_defaults.ast_to_object(vm, source_code),
+            kw_defaults.ast_to_object(vm, source_file),
             vm,
         )
         .unwrap();
-        dict.set_item("kwarg", kwarg.ast_to_object(vm, source_code), vm)
+        dict.set_item("kwarg", kwarg.ast_to_object(vm, source_file), vm)
             .unwrap();
-        dict.set_item("defaults", defaults.ast_to_object(vm, source_code), vm)
+        dict.set_item("defaults", defaults.ast_to_object(vm, source_file), vm)
             .unwrap();
-        node_add_location(&dict, range, vm, source_code);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
         let kwonlyargs = Node::ast_from_object(
             vm,
-            source_code,
+            source_file,
             get_node_field(vm, &object, "kwonlyargs", "arguments")?,
         )?;
         let kw_defaults = Node::ast_from_object(
             vm,
-            source_code,
+            source_file,
             get_node_field(vm, &object, "kw_defaults", "arguments")?,
         )?;
         let kwonlyargs = merge_keyword_parameter_defaults(kwonlyargs, kw_defaults);
 
         let posonlyargs = Node::ast_from_object(
             vm,
-            source_code,
+            source_file,
             get_node_field(vm, &object, "posonlyargs", "arguments")?,
         )?;
         let args = Node::ast_from_object(
             vm,
-            source_code,
+            source_file,
             get_node_field(vm, &object, "args", "arguments")?,
         )?;
         let defaults = Node::ast_from_object(
             vm,
-            source_code,
+            source_file,
             get_node_field(vm, &object, "defaults", "arguments")?,
         )?;
         let (posonlyargs, args) = merge_positional_parameter_defaults(posonlyargs, args, defaults);
 
         Ok(Self {
+            node_index: Default::default(),
             posonlyargs,
             args,
             vararg: get_node_field_opt(vm, &object, "vararg")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
             kwonlyargs,
             kwarg: get_node_field_opt(vm, &object, "kwarg")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
                 .transpose()?,
             range: Default::default(),
         })
@@ -99,8 +102,9 @@ impl Node for ruff::Parameters {
 
 // product
 impl Node for ruff::Parameter {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
+            node_index: _,
             name,
             annotation,
             // type_comment,
@@ -114,46 +118,48 @@ impl Node for ruff::Parameter {
             .into_ref_with_type(_vm, pyast::NodeArg::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("arg", name.ast_to_object(_vm, source_code), _vm)
+        dict.set_item("arg", name.ast_to_object(_vm, source_file), _vm)
             .unwrap();
         dict.set_item(
             "annotation",
-            annotation.ast_to_object(_vm, source_code),
+            annotation.ast_to_object(_vm, source_file),
             _vm,
         )
         .unwrap();
         // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
         //     .unwrap();
-        node_add_location(&dict, range, _vm, source_code);
+        node_add_location(&dict, range, _vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
         _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         _object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
+            node_index: Default::default(),
             name: Node::ast_from_object(
                 _vm,
-                source_code,
+                source_file,
                 get_node_field(_vm, &_object, "arg", "arg")?,
             )?,
             annotation: get_node_field_opt(_vm, &_object, "annotation")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
                 .transpose()?,
             // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
             //     .map(|obj| Node::ast_from_object(_vm, obj))
             //     .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "arg")?,
+            range: range_from_object(_vm, source_file, _object, "arg")?,
         })
     }
 }
 
 // product
 impl Node for ruff::Keyword {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self {
+            node_index: _,
             arg,
             value,
             range: _range,
@@ -162,28 +168,29 @@ impl Node for ruff::Keyword {
             .into_ref_with_type(_vm, pyast::NodeKeyword::static_type().to_owned())
             .unwrap();
         let dict = node.as_object().dict().unwrap();
-        dict.set_item("arg", arg.ast_to_object(_vm, source_code), _vm)
+        dict.set_item("arg", arg.ast_to_object(_vm, source_file), _vm)
             .unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
             .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
+        node_add_location(&dict, _range, _vm, source_file);
         node.into()
     }
     fn ast_from_object(
         _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         _object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
+            node_index: Default::default(),
             arg: get_node_field_opt(_vm, &_object, "arg")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
                 .transpose()?,
             value: Node::ast_from_object(
                 _vm,
-                source_code,
+                source_file,
                 get_node_field(_vm, &_object, "value", "keyword")?,
             )?,
-            range: range_from_object(_vm, source_code, _object, "keyword")?,
+            range: range_from_object(_vm, source_file, _object, "keyword")?,
         })
     }
 }
@@ -194,16 +201,16 @@ struct PositionalParameters {
 }
 
 impl Node for PositionalParameters {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        BoxedSlice(self.args).ast_to_object(vm, source_code)
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        BoxedSlice(self.args).ast_to_object(vm, source_file)
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let args: BoxedSlice<_> = Node::ast_from_object(vm, source_code, object)?;
+        let args: BoxedSlice<_> = Node::ast_from_object(vm, source_file, object)?;
         Ok(Self {
             args: args.0,
             _range: TextRange::default(), // TODO
@@ -217,16 +224,16 @@ struct KeywordParameters {
 }
 
 impl Node for KeywordParameters {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        BoxedSlice(self.keywords).ast_to_object(vm, source_code)
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        BoxedSlice(self.keywords).ast_to_object(vm, source_file)
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let keywords: BoxedSlice<_> = Node::ast_from_object(vm, source_code, object)?;
+        let keywords: BoxedSlice<_> = Node::ast_from_object(vm, source_file, object)?;
         Ok(Self {
             keywords: keywords.0,
             _range: TextRange::default(), // TODO
@@ -240,16 +247,16 @@ struct ParameterDefaults {
 }
 
 impl Node for ParameterDefaults {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        BoxedSlice(self.defaults).ast_to_object(vm, source_code)
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        BoxedSlice(self.defaults).ast_to_object(vm, source_file)
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
-        let defaults: BoxedSlice<_> = Node::ast_from_object(vm, source_code, object)?;
+        let defaults: BoxedSlice<_> = Node::ast_from_object(vm, source_file, object)?;
         Ok(Self {
             defaults: defaults.0,
             _range: TextRange::default(), // TODO
@@ -327,6 +334,7 @@ fn merge_positional_parameter_defaults(
 
     let mut posonlyargs: Vec<_> = <Box<[_]> as IntoIterator>::into_iter(posonlyargs)
         .map(|parameter| ruff::ParameterWithDefault {
+            node_index: Default::default(),
             range: Default::default(),
             parameter,
             default: None,
@@ -334,6 +342,7 @@ fn merge_positional_parameter_defaults(
         .collect();
     let mut args: Vec<_> = <Box<[_]> as IntoIterator>::into_iter(args)
         .map(|parameter| ruff::ParameterWithDefault {
+            node_index: Default::default(),
             range: Default::default(),
             parameter,
             default: None,
@@ -394,8 +403,9 @@ fn merge_keyword_parameter_defaults(
     kw_only_args: KeywordParameters,
     defaults: ParameterDefaults,
 ) -> Vec<ruff::ParameterWithDefault> {
-    std::iter::zip(kw_only_args.keywords, defaults.defaults)
+    core::iter::zip(kw_only_args.keywords, defaults.defaults)
         .map(|(parameter, default)| ruff::ParameterWithDefault {
+            node_index: Default::default(),
             parameter,
             default,
             range: Default::default(),
diff --git a/crates/vm/src/stdlib/ast/pattern.rs b/crates/vm/src/stdlib/ast/pattern.rs
new file mode 100644
index 0000000000..d8128cb062
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/pattern.rs
@@ -0,0 +1,578 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+// product
+impl Node for ruff::MatchCase {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            pattern,
+            guard,
+            body,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        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)
+            .unwrap();
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            pattern: Node::ast_from_object(
+                _vm,
+                source_file,
+                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))
+                .transpose()?,
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "match_case")?,
+            )?,
+            range: Default::default(),
+        })
+    }
+}
+
+// sum
+impl Node for ruff::Pattern {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::MatchValue(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchSingleton(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchSequence(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchMapping(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchClass(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchStar(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchAs(cons) => cons.ast_to_object(vm, source_file),
+            Self::MatchOr(cons) => cons.ast_to_object(vm, source_file),
+        }
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodePatternMatchValue::static_type()) {
+            Self::MatchValue(ruff::PatternMatchValue::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchSingleton::static_type()) {
+            Self::MatchSingleton(ruff::PatternMatchSingleton::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchSequence::static_type()) {
+            Self::MatchSequence(ruff::PatternMatchSequence::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchMapping::static_type()) {
+            Self::MatchMapping(ruff::PatternMatchMapping::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchClass::static_type()) {
+            Self::MatchClass(ruff::PatternMatchClass::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchStar::static_type()) {
+            Self::MatchStar(ruff::PatternMatchStar::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchAs::static_type()) {
+            Self::MatchAs(ruff::PatternMatchAs::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodePatternMatchOr::static_type()) {
+            Self::MatchOr(ruff::PatternMatchOr::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of pattern, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+// constructor
+impl Node for ruff::PatternMatchValue {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "value", "MatchValue")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "MatchValue")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchSingleton {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(
+                _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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "value", "MatchSingleton")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "MatchSingleton")?,
+        })
+    }
+}
+
+impl Node for ruff::Singleton {
+    fn ast_to_object(self, vm: &VirtualMachine, _source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            ruff::Singleton::None => vm.ctx.none(),
+            ruff::Singleton::True => vm.ctx.new_bool(true).into(),
+            ruff::Singleton::False => vm.ctx.new_bool(false).into(),
+        }
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        if vm.is_none(&object) {
+            Ok(ruff::Singleton::None)
+        } else if object.is(&vm.ctx.true_value) {
+            Ok(ruff::Singleton::True)
+        } else if object.is(&vm.ctx.false_value) {
+            Ok(ruff::Singleton::False)
+        } else {
+            Err(vm.new_value_error(format!(
+                "Expected None, True, or False, got {:?}",
+                object.class().name()
+            )))
+        }
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchSequence {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            patterns,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(
+                _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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            patterns: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "patterns", "MatchSequence")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "MatchSequence")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchMapping {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            keys,
+            patterns,
+            rest,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            keys: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "keys", "MatchMapping")?,
+            )?,
+            patterns: Node::ast_from_object(
+                _vm,
+                source_file,
+                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))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "MatchMapping")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchClass {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            cls,
+            arguments,
+            range: _range,
+        } = self;
+        let (patterns, kwd_attrs, kwd_patterns) = split_pattern_match_class(arguments);
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodePatternMatchClass::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("cls", cls.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("patterns", patterns.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("kwd_attrs", kwd_attrs.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "kwd_patterns",
+            kwd_patterns.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let patterns = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "patterns", "MatchClass")?,
+        )?;
+        let kwd_attrs = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "kwd_attrs", "MatchClass")?,
+        )?;
+        let kwd_patterns = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "kwd_patterns", "MatchClass")?,
+        )?;
+        let (patterns, keywords) = merge_pattern_match_class(patterns, kwd_attrs, kwd_patterns);
+
+        Ok(Self {
+            node_index: Default::default(),
+            cls: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "cls", "MatchClass")?,
+            )?,
+            range: range_from_object(vm, source_file, object, "MatchClass")?,
+            arguments: ruff::PatternArguments {
+                node_index: Default::default(),
+                range: Default::default(),
+                patterns,
+                keywords,
+            },
+        })
+    }
+}
+
+struct PatternMatchClassPatterns(Vec<ruff::Pattern>);
+
+impl Node for PatternMatchClassPatterns {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        self.0.ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self(Node::ast_from_object(vm, source_file, object)?))
+    }
+}
+
+struct PatternMatchClassKeywordAttributes(Vec<ruff::Identifier>);
+
+impl Node for PatternMatchClassKeywordAttributes {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        self.0.ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self(Node::ast_from_object(vm, source_file, object)?))
+    }
+}
+
+struct PatternMatchClassKeywordPatterns(Vec<ruff::Pattern>);
+
+impl Node for PatternMatchClassKeywordPatterns {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        self.0.ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self(Node::ast_from_object(vm, source_file, object)?))
+    }
+}
+// constructor
+impl Node for ruff::PatternMatchStar {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _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))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "MatchStar")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchAs {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            pattern,
+            name,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            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))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "MatchAs")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::PatternMatchOr {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            patterns,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            patterns: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "patterns", "MatchOr")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "MatchOr")?,
+        })
+    }
+}
+
+fn split_pattern_match_class(
+    arguments: ruff::PatternArguments,
+) -> (
+    PatternMatchClassPatterns,
+    PatternMatchClassKeywordAttributes,
+    PatternMatchClassKeywordPatterns,
+) {
+    let patterns = PatternMatchClassPatterns(arguments.patterns);
+    let kwd_attrs = PatternMatchClassKeywordAttributes(
+        arguments.keywords.iter().map(|k| k.attr.clone()).collect(),
+    );
+    let kwd_patterns = PatternMatchClassKeywordPatterns(
+        arguments.keywords.into_iter().map(|k| k.pattern).collect(),
+    );
+    (patterns, kwd_attrs, kwd_patterns)
+}
+
+/// Merges the pattern match class attributes and patterns, opposite of [`split_pattern_match_class`].
+fn merge_pattern_match_class(
+    patterns: PatternMatchClassPatterns,
+    kwd_attrs: PatternMatchClassKeywordAttributes,
+    kwd_patterns: PatternMatchClassKeywordPatterns,
+) -> (Vec<ruff::Pattern>, Vec<ruff::PatternKeyword>) {
+    let keywords = kwd_attrs
+        .0
+        .into_iter()
+        .zip(kwd_patterns.0)
+        .map(|(attr, pattern)| ruff::PatternKeyword {
+            range: Default::default(),
+            node_index: Default::default(),
+            attr,
+            pattern,
+        })
+        .collect();
+    (patterns.0, keywords)
+}
diff --git a/crates/vm/src/stdlib/ast/pyast.rs b/crates/vm/src/stdlib/ast/pyast.rs
new file mode 100644
index 0000000000..f5e9d9f6d9
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/pyast.rs
@@ -0,0 +1,1007 @@
+#![allow(clippy::all)]
+
+use super::*;
+use crate::common::ascii;
+
+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"],
+);
+
+impl_node!(
+    #[pyclass(module = "_ast", name = "Constant", base = NodeExpr)]
+    pub(crate) struct NodeExprConstant,
+    fields: ["value", "kind"],
+    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
+);
+
+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
new file mode 100644
index 0000000000..35fe561527
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/python.rs
@@ -0,0 +1,99 @@
+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;
+}
diff --git a/crates/vm/src/stdlib/ast/statement.rs b/crates/vm/src/stdlib/ast/statement.rs
new file mode 100644
index 0000000000..f1d36c52e2
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/statement.rs
@@ -0,0 +1,1294 @@
+use super::*;
+use crate::stdlib::ast::argument::{merge_class_def_args, split_class_def_args};
+use rustpython_compiler_core::SourceFile;
+
+// sum
+impl Node for ruff::Stmt {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::FunctionDef(cons) => cons.ast_to_object(vm, source_file),
+            Self::ClassDef(cons) => cons.ast_to_object(vm, source_file),
+            Self::Return(cons) => cons.ast_to_object(vm, source_file),
+            Self::Delete(cons) => cons.ast_to_object(vm, source_file),
+            Self::Assign(cons) => cons.ast_to_object(vm, source_file),
+            Self::TypeAlias(cons) => cons.ast_to_object(vm, source_file),
+            Self::AugAssign(cons) => cons.ast_to_object(vm, source_file),
+            Self::AnnAssign(cons) => cons.ast_to_object(vm, source_file),
+            Self::For(cons) => cons.ast_to_object(vm, source_file),
+            Self::While(cons) => cons.ast_to_object(vm, source_file),
+            Self::If(cons) => cons.ast_to_object(vm, source_file),
+            Self::With(cons) => cons.ast_to_object(vm, source_file),
+            Self::Match(cons) => cons.ast_to_object(vm, source_file),
+            Self::Raise(cons) => cons.ast_to_object(vm, source_file),
+            Self::Try(cons) => cons.ast_to_object(vm, source_file),
+            Self::Assert(cons) => cons.ast_to_object(vm, source_file),
+            Self::Import(cons) => cons.ast_to_object(vm, source_file),
+            Self::ImportFrom(cons) => cons.ast_to_object(vm, source_file),
+            Self::Global(cons) => cons.ast_to_object(vm, source_file),
+            Self::Nonlocal(cons) => cons.ast_to_object(vm, source_file),
+            Self::Expr(cons) => cons.ast_to_object(vm, source_file),
+            Self::Pass(cons) => cons.ast_to_object(vm, source_file),
+            Self::Break(cons) => cons.ast_to_object(vm, source_file),
+            Self::Continue(cons) => cons.ast_to_object(vm, source_file),
+            Self::IpyEscapeCommand(_) => {
+                unimplemented!("IPython escape command is not allowed in Python AST")
+            }
+        }
+    }
+
+    #[allow(clippy::if_same_then_else)]
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeStmtFunctionDef::static_type()) {
+            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type()) {
+            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtClassDef::static_type()) {
+            Self::ClassDef(ruff::StmtClassDef::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtReturn::static_type()) {
+            Self::Return(ruff::StmtReturn::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtDelete::static_type()) {
+            Self::Delete(ruff::StmtDelete::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtAssign::static_type()) {
+            Self::Assign(ruff::StmtAssign::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtTypeAlias::static_type()) {
+            Self::TypeAlias(ruff::StmtTypeAlias::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtAugAssign::static_type()) {
+            Self::AugAssign(ruff::StmtAugAssign::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtAnnAssign::static_type()) {
+            Self::AnnAssign(ruff::StmtAnnAssign::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtFor::static_type()) {
+            Self::For(ruff::StmtFor::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtAsyncFor::static_type()) {
+            Self::For(ruff::StmtFor::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtWhile::static_type()) {
+            Self::While(ruff::StmtWhile::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtIf::static_type()) {
+            Self::If(ruff::StmtIf::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtWith::static_type()) {
+            Self::With(ruff::StmtWith::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtAsyncWith::static_type()) {
+            Self::With(ruff::StmtWith::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtMatch::static_type()) {
+            Self::Match(ruff::StmtMatch::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtRaise::static_type()) {
+            Self::Raise(ruff::StmtRaise::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtTry::static_type()) {
+            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtTryStar::static_type()) {
+            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtAssert::static_type()) {
+            Self::Assert(ruff::StmtAssert::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtImport::static_type()) {
+            Self::Import(ruff::StmtImport::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtImportFrom::static_type()) {
+            Self::ImportFrom(ruff::StmtImportFrom::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtGlobal::static_type()) {
+            Self::Global(ruff::StmtGlobal::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtNonlocal::static_type()) {
+            Self::Nonlocal(ruff::StmtNonlocal::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeStmtExpr::static_type()) {
+            Self::Expr(ruff::StmtExpr::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtPass::static_type()) {
+            Self::Pass(ruff::StmtPass::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtBreak::static_type()) {
+            Self::Break(ruff::StmtBreak::ast_from_object(_vm, source_file, _object)?)
+        } else if _cls.is(pyast::NodeStmtContinue::static_type()) {
+            Self::Continue(ruff::StmtContinue::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of stmt, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtFunctionDef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            parameters,
+            body,
+            decorator_list,
+            returns,
+            // type_comment,
+            type_params,
+            is_async,
+            range: _range,
+        } = self;
+
+        let cls = if !is_async {
+            pyast::NodeStmtFunctionDef::static_type().to_owned()
+        } else {
+            pyast::NodeStmtAsyncFunctionDef::static_type().to_owned()
+        };
+
+        let node = NodeAst.into_ref_with_type(vm, cls).unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("name", vm.ctx.new_str(name.as_str()).to_pyobject(vm), vm)
+            .unwrap();
+        dict.set_item("args", parameters.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("body", body.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "decorator_list",
+            decorator_list.ast_to_object(vm, source_file),
+            vm,
+        )
+        .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();
+        dict.set_item(
+            "type_params",
+            type_params.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, _range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        let is_async = _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type());
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "name", "FunctionDef")?,
+            )?,
+            parameters: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "args", "FunctionDef")?,
+            )?,
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "FunctionDef")?,
+            )?,
+            decorator_list: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "decorator_list", "FunctionDef")?,
+            )?,
+            returns: get_node_field_opt(_vm, &_object, "returns")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            // TODO: Ruff ignores type_comment during parsing
+            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
+            //     .map(|obj| Node::ast_from_object(_vm, obj))
+            //     .transpose()?,
+            type_params: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
+            )?,
+            range: range_from_object(_vm, source_file, _object, "FunctionDef")?,
+            is_async,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtClassDef {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            arguments,
+            body,
+            decorator_list,
+            type_params,
+            range: _range,
+        } = self;
+        let (bases, keywords) = split_class_def_args(arguments);
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtClassDef::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("bases", bases.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("keywords", keywords.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item(
+            "decorator_list",
+            decorator_list.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        dict.set_item(
+            "type_params",
+            type_params.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let bases = Node::ast_from_object(
+            _vm,
+            source_file,
+            get_node_field(_vm, &_object, "bases", "ClassDef")?,
+        )?;
+        let keywords = Node::ast_from_object(
+            _vm,
+            source_file,
+            get_node_field(_vm, &_object, "keywords", "ClassDef")?,
+        )?;
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "name", "ClassDef")?,
+            )?,
+            arguments: merge_class_def_args(bases, keywords),
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "ClassDef")?,
+            )?,
+            decorator_list: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "decorator_list", "ClassDef")?,
+            )?,
+            type_params: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
+            )?,
+            range: range_from_object(_vm, source_file, _object, "ClassDef")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtReturn {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtReturn::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: get_node_field_opt(_vm, &_object, "value")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "Return")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtDelete {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            targets,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtDelete::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("targets", targets.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            targets: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "targets", "Delete")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Delete")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtAssign {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            targets,
+            value,
+            // type_comment,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeStmtAssign::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("targets", targets.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        // TODO
+        dict.set_item("type_comment", vm.ctx.none(), vm).unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            targets: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "targets", "Assign")?,
+            )?,
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Assign")?,
+            )?,
+            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
+            //     .map(|obj| Node::ast_from_object(_vm, obj))
+            //     .transpose()?,
+            range: range_from_object(vm, source_file, object, "Assign")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtTypeAlias {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            type_params,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtTypeAlias::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("name", name.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item(
+            "type_params",
+            type_params.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "name", "TypeAlias")?,
+            )?,
+            type_params: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field_opt(_vm, &_object, "type_params")?.unwrap_or_else(|| _vm.ctx.none()),
+            )?,
+            value: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "value", "TypeAlias")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "TypeAlias")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtAugAssign {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            target,
+            op,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtAugAssign::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("target", target.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("op", op.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            target: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "target", "AugAssign")?,
+            )?,
+            op: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "op", "AugAssign")?,
+            )?,
+            value: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "value", "AugAssign")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "AugAssign")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtAnnAssign {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            target,
+            annotation,
+            value,
+            simple,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtAnnAssign::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("target", target.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item(
+            "annotation",
+            annotation.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("simple", simple.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            target: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "target", "AnnAssign")?,
+            )?,
+            annotation: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "annotation", "AnnAssign")?,
+            )?,
+            value: get_node_field_opt(_vm, &_object, "value")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            simple: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "simple", "AnnAssign")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "AnnAssign")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtFor {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            is_async,
+            target,
+            iter,
+            body,
+            orelse,
+            // type_comment,
+            range: _range,
+        } = self;
+
+        let cls = if !is_async {
+            pyast::NodeStmtFor::static_type().to_owned()
+        } else {
+            pyast::NodeStmtAsyncFor::static_type().to_owned()
+        };
+
+        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("target", target.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("iter", iter.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+            .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();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        debug_assert!(
+            _cls.is(pyast::NodeStmtFor::static_type())
+                || _cls.is(pyast::NodeStmtAsyncFor::static_type())
+        );
+        let is_async = _cls.is(pyast::NodeStmtAsyncFor::static_type());
+        Ok(Self {
+            node_index: Default::default(),
+            target: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "target", "For")?,
+            )?,
+            iter: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "iter", "For")?,
+            )?,
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "For")?,
+            )?,
+            orelse: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "orelse", "For")?,
+            )?,
+            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
+            //     .map(|obj| Node::ast_from_object(_vm, obj))
+            //     .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "For")?,
+            is_async,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtWhile {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            test,
+            body,
+            orelse,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtWhile::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("test", test.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("orelse", orelse.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            test: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "test", "While")?,
+            )?,
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "While")?,
+            )?,
+            orelse: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "orelse", "While")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "While")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtIf {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            test,
+            body,
+            range,
+            elif_else_clauses,
+        } = self;
+        elif_else_clause::ast_to_object(
+            ruff::ElifElseClause {
+                node_index: Default::default(),
+                range,
+                test: Some(*test),
+                body,
+            },
+            elif_else_clauses.into_iter(),
+            _vm,
+            source_file,
+        )
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        elif_else_clause::ast_from_object(vm, source_file, object)
+    }
+}
+// constructor
+impl Node for ruff::StmtWith {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            is_async,
+            items,
+            body,
+            // type_comment,
+            range: _range,
+        } = self;
+
+        let cls = if !is_async {
+            pyast::NodeStmtWith::static_type().to_owned()
+        } else {
+            pyast::NodeStmtAsyncWith::static_type().to_owned()
+        };
+
+        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("items", items.ast_to_object(_vm, source_file), _vm)
+            .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();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        debug_assert!(
+            _cls.is(pyast::NodeStmtWith::static_type())
+                || _cls.is(pyast::NodeStmtAsyncWith::static_type())
+        );
+        let is_async = _cls.is(pyast::NodeStmtAsyncWith::static_type());
+        Ok(Self {
+            node_index: Default::default(),
+            items: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "items", "With")?,
+            )?,
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "With")?,
+            )?,
+            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
+            //     .map(|obj| Node::ast_from_object(_vm, obj))
+            //     .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "With")?,
+            is_async,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtMatch {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            subject,
+            cases,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtMatch::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("subject", subject.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("cases", cases.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            subject: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "subject", "Match")?,
+            )?,
+            cases: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "cases", "Match")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Match")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtRaise {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            exc,
+            cause,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtRaise::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("exc", exc.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("cause", cause.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            exc: get_node_field_opt(_vm, &_object, "exc")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            cause: get_node_field_opt(_vm, &_object, "cause")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "Raise")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtTry {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            body,
+            handlers,
+            orelse,
+            finalbody,
+            range: _range,
+            is_star,
+        } = self;
+
+        // let cls = gen::NodeStmtTry::static_type().to_owned();
+        let cls = if is_star {
+            pyast::NodeStmtTryStar::static_type()
+        } else {
+            pyast::NodeStmtTry::static_type()
+        }
+        .to_owned();
+
+        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("body", body.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("handlers", handlers.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("orelse", orelse.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("finalbody", finalbody.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        let is_star = _cls.is(pyast::NodeStmtTryStar::static_type());
+        let _cls = _object.class();
+        debug_assert!(
+            _cls.is(pyast::NodeStmtTry::static_type())
+                || _cls.is(pyast::NodeStmtTryStar::static_type())
+        );
+
+        Ok(Self {
+            node_index: Default::default(),
+            body: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "body", "Try")?,
+            )?,
+            handlers: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "handlers", "Try")?,
+            )?,
+            orelse: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "orelse", "Try")?,
+            )?,
+            finalbody: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "finalbody", "Try")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Try")?,
+            is_star,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtAssert {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            test,
+            msg,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtAssert::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("test", test.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        dict.set_item("msg", msg.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            test: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "test", "Assert")?,
+            )?,
+            msg: get_node_field_opt(_vm, &_object, "msg")?
+                .map(|obj| Node::ast_from_object(_vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(_vm, source_file, _object, "Assert")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtImport {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            names,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtImport::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("names", names.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            names: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "names", "Import")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Import")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtImportFrom {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            module,
+            names,
+            level,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeStmtImportFrom::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("module", module.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("names", names.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("level", vm.ctx.new_int(level).to_pyobject(vm), vm)
+            .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            module: get_node_field_opt(vm, &_object, "module")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            names: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &_object, "names", "ImportFrom")?,
+            )?,
+            level: get_node_field_opt(vm, &_object, "level")?
+                .map(|obj| -> PyResult<u32> {
+                    let int: PyRef<PyInt> = obj.try_into_value(vm)?;
+                    int.try_to_primitive(vm)
+                })
+                .transpose()?
+                .unwrap_or(0),
+            range: range_from_object(vm, source_file, _object, "ImportFrom")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtGlobal {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            names,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtGlobal::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("names", names.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            names: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "names", "Global")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Global")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtNonlocal {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            names,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtNonlocal::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("names", names.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            names: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "names", "Nonlocal")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Nonlocal")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtExpr {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            value,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtExpr::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            value: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "value", "Expr")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "Expr")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtPass {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .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);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            range: range_from_object(_vm, source_file, _object, "Pass")?,
+        })
+    }
+}
+// constructor
+impl Node for ruff::StmtBreak {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtBreak::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            range: range_from_object(_vm, source_file, _object, "Break")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::StmtContinue {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            range: _range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(_vm, pyast::NodeStmtContinue::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            range: range_from_object(_vm, source_file, _object, "Continue")?,
+        })
+    }
+}
diff --git a/crates/vm/src/stdlib/ast/string.rs b/crates/vm/src/stdlib/ast/string.rs
new file mode 100644
index 0000000000..c68e378bc7
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/string.rs
@@ -0,0 +1,596 @@
+use super::constant::{Constant, ConstantLiteral};
+use super::*;
+
+fn ruff_fstring_element_into_iter(
+    mut fstring_element: ruff::InterpolatedStringElements,
+) -> impl Iterator<Item = ruff::InterpolatedStringElement> {
+    let default =
+        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            node_index: Default::default(),
+            range: Default::default(),
+            value: Default::default(),
+        });
+    fstring_element
+        .iter_mut()
+        .map(move |elem| core::mem::replace(elem, default.clone()))
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
+fn ruff_fstring_element_to_joined_str_part(
+    element: ruff::InterpolatedStringElement,
+) -> JoinedStrPart {
+    match element {
+        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            range,
+            value,
+            node_index: _,
+        }) => JoinedStrPart::Constant(Constant::new_str(
+            value,
+            ruff::str_prefix::StringLiteralPrefix::Empty,
+            range,
+        )),
+        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            range,
+            expression,
+            debug_text: _, // TODO: What is this?
+            conversion,
+            format_spec,
+            node_index: _,
+        }) => JoinedStrPart::FormattedValue(FormattedValue {
+            value: expression,
+            conversion,
+            format_spec: ruff_format_spec_to_joined_str(format_spec),
+            range,
+        }),
+    }
+}
+
+fn ruff_format_spec_to_joined_str(
+    format_spec: Option<Box<ruff::InterpolatedStringFormatSpec>>,
+) -> Option<Box<JoinedStr>> {
+    match format_spec {
+        None => None,
+        Some(format_spec) => {
+            let ruff::InterpolatedStringFormatSpec {
+                range,
+                elements,
+                node_index: _,
+            } = *format_spec;
+            let values: Vec<_> = ruff_fstring_element_into_iter(elements)
+                .map(ruff_fstring_element_to_joined_str_part)
+                .collect();
+            let values = values.into_boxed_slice();
+            Some(Box::new(JoinedStr { range, values }))
+        }
+    }
+}
+
+fn ruff_fstring_element_to_ruff_fstring_part(
+    element: ruff::InterpolatedStringElement,
+) -> ruff::FStringPart {
+    match element {
+        ruff::InterpolatedStringElement::Literal(value) => {
+            let ruff::InterpolatedStringLiteralElement {
+                node_index,
+                range,
+                value,
+            } = value;
+            ruff::FStringPart::Literal(ruff::StringLiteral {
+                node_index,
+                range,
+                value,
+                flags: ruff::StringLiteralFlags::empty(),
+            })
+        }
+        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            range, ..
+        }) => ruff::FStringPart::FString(ruff::FString {
+            node_index: Default::default(),
+            range,
+            elements: vec![element].into(),
+            flags: ruff::FStringFlags::empty(),
+        }),
+    }
+}
+
+fn joined_str_to_ruff_format_spec(
+    joined_str: Option<Box<JoinedStr>>,
+) -> Option<Box<ruff::InterpolatedStringFormatSpec>> {
+    match joined_str {
+        None => None,
+        Some(joined_str) => {
+            let JoinedStr { range, values } = *joined_str;
+            let elements: Vec<_> = Box::into_iter(values)
+                .map(joined_str_part_to_ruff_fstring_element)
+                .collect();
+            let format_spec = ruff::InterpolatedStringFormatSpec {
+                node_index: Default::default(),
+                range,
+                elements: elements.into(),
+            };
+            Some(Box::new(format_spec))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct JoinedStr {
+    pub(super) range: TextRange,
+    pub(super) values: Box<[JoinedStrPart]>,
+}
+
+impl JoinedStr {
+    pub(super) fn into_expr(self) -> ruff::Expr {
+        let Self { range, values } = self;
+        ruff::Expr::FString(ruff::ExprFString {
+            node_index: Default::default(),
+            range: Default::default(),
+            value: match values.len() {
+                // ruff represents an empty fstring like this:
+                0 => ruff::FStringValue::single(ruff::FString {
+                    node_index: Default::default(),
+                    range,
+                    elements: vec![].into(),
+                    flags: ruff::FStringFlags::empty(),
+                }),
+                1 => ruff::FStringValue::single(
+                    Box::<[_]>::into_iter(values)
+                        .map(joined_str_part_to_ruff_fstring_element)
+                        .map(|element| ruff::FString {
+                            node_index: Default::default(),
+                            range,
+                            elements: vec![element].into(),
+                            flags: ruff::FStringFlags::empty(),
+                        })
+                        .next()
+                        .expect("FString has exactly one part"),
+                ),
+                _ => ruff::FStringValue::concatenated(
+                    Box::<[_]>::into_iter(values)
+                        .map(joined_str_part_to_ruff_fstring_element)
+                        .map(ruff_fstring_element_to_ruff_fstring_part)
+                        .collect(),
+                ),
+            },
+        })
+    }
+}
+
+fn joined_str_part_to_ruff_fstring_element(part: JoinedStrPart) -> ruff::InterpolatedStringElement {
+    match part {
+        JoinedStrPart::FormattedValue(value) => {
+            ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+                node_index: Default::default(),
+                range: value.range,
+                expression: value.value.clone(),
+                debug_text: None, // TODO: What is this?
+                conversion: value.conversion,
+                format_spec: joined_str_to_ruff_format_spec(value.format_spec),
+            })
+        }
+        JoinedStrPart::Constant(value) => {
+            ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+                node_index: Default::default(),
+                range: value.range,
+                value: match value.value {
+                    ConstantLiteral::Str { value, .. } => value,
+                    _ => todo!(),
+                },
+            })
+        }
+    }
+}
+
+// constructor
+impl Node for JoinedStr {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { values, range } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprJoinedStr::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item(
+            "values",
+            BoxedSlice(values).ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let values: BoxedSlice<_> = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "values", "JoinedStr")?,
+        )?;
+        Ok(Self {
+            values: values.0,
+            range: range_from_object(vm, source_file, object, "JoinedStr")?,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum JoinedStrPart {
+    FormattedValue(FormattedValue),
+    Constant(Constant),
+}
+
+// constructor
+impl Node for JoinedStrPart {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::FormattedValue(value) => value.ast_to_object(vm, source_file),
+            Self::Constant(value) => value.ast_to_object(vm, source_file),
+        }
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let cls = object.class();
+        if cls.is(pyast::NodeExprFormattedValue::static_type()) {
+            Ok(Self::FormattedValue(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        } else {
+            Ok(Self::Constant(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct FormattedValue {
+    value: Box<ruff::Expr>,
+    conversion: ruff::ConversionFlag,
+    format_spec: Option<Box<JoinedStr>>,
+    range: TextRange,
+}
+
+// constructor
+impl Node for FormattedValue {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            value,
+            conversion,
+            format_spec,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprFormattedValue::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("conversion", conversion.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "format_spec",
+            format_spec.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "FormattedValue")?,
+            )?,
+            conversion: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "conversion", "FormattedValue")?,
+            )?,
+            format_spec: get_node_field_opt(vm, &object, "format_spec")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "FormattedValue")?,
+        })
+    }
+}
+
+pub(super) fn fstring_to_object(
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+    expression: ruff::ExprFString,
+) -> PyObjectRef {
+    let ruff::ExprFString {
+        range,
+        mut value,
+        node_index: _,
+    } = expression;
+    let default_part = ruff::FStringPart::FString(ruff::FString {
+        node_index: Default::default(),
+        range: Default::default(),
+        elements: Default::default(),
+        flags: ruff::FStringFlags::empty(),
+    });
+    let mut values = Vec::new();
+    for i in 0..value.as_slice().len() {
+        let part = core::mem::replace(value.iter_mut().nth(i).unwrap(), default_part.clone());
+        match part {
+            ruff::FStringPart::Literal(ruff::StringLiteral {
+                range,
+                value,
+                flags,
+                node_index: _,
+            }) => {
+                values.push(JoinedStrPart::Constant(Constant::new_str(
+                    value,
+                    flags.prefix(),
+                    range,
+                )));
+            }
+            ruff::FStringPart::FString(ruff::FString {
+                range: _,
+                elements,
+                flags: _,
+                node_index: _,
+            }) => {
+                for element in ruff_fstring_element_into_iter(elements) {
+                    values.push(ruff_fstring_element_to_joined_str_part(element));
+                }
+            }
+        }
+    }
+    let c = JoinedStr {
+        range,
+        values: values.into_boxed_slice(),
+    };
+    c.ast_to_object(vm, source_file)
+}
+
+// ===== TString (Template String) Support =====
+
+fn ruff_tstring_element_to_template_str_part(
+    element: ruff::InterpolatedStringElement,
+    source_file: &SourceFile,
+) -> TemplateStrPart {
+    match element {
+        ruff::InterpolatedStringElement::Literal(ruff::InterpolatedStringLiteralElement {
+            range,
+            value,
+            node_index: _,
+        }) => TemplateStrPart::Constant(Constant::new_str(
+            value,
+            ruff::str_prefix::StringLiteralPrefix::Empty,
+            range,
+        )),
+        ruff::InterpolatedStringElement::Interpolation(ruff::InterpolatedElement {
+            range,
+            expression,
+            debug_text,
+            conversion,
+            format_spec,
+            node_index: _,
+        }) => {
+            // Get the expression source text for the "str" field
+            let expr_str = debug_text
+                .map(|dt| dt.leading.to_string() + &dt.trailing)
+                .unwrap_or_else(|| source_file.slice(expression.range()).to_string());
+            TemplateStrPart::Interpolation(TStringInterpolation {
+                value: expression,
+                str: expr_str,
+                conversion,
+                format_spec: ruff_format_spec_to_template_str(format_spec, source_file),
+                range,
+            })
+        }
+    }
+}
+
+fn ruff_format_spec_to_template_str(
+    format_spec: Option<Box<ruff::InterpolatedStringFormatSpec>>,
+    source_file: &SourceFile,
+) -> Option<Box<TemplateStr>> {
+    match format_spec {
+        None => None,
+        Some(format_spec) => {
+            let ruff::InterpolatedStringFormatSpec {
+                range,
+                elements,
+                node_index: _,
+            } = *format_spec;
+            let values: Vec<_> = ruff_fstring_element_into_iter(elements)
+                .map(|e| ruff_tstring_element_to_template_str_part(e, source_file))
+                .collect();
+            let values = values.into_boxed_slice();
+            Some(Box::new(TemplateStr { range, values }))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct TemplateStr {
+    pub(super) range: TextRange,
+    pub(super) values: Box<[TemplateStrPart]>,
+}
+
+// constructor
+impl Node for TemplateStr {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self { values, range } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprTemplateStr::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item(
+            "values",
+            BoxedSlice(values).ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let values: BoxedSlice<_> = Node::ast_from_object(
+            vm,
+            source_file,
+            get_node_field(vm, &object, "values", "TemplateStr")?,
+        )?;
+        Ok(Self {
+            values: values.0,
+            range: range_from_object(vm, source_file, object, "TemplateStr")?,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum TemplateStrPart {
+    Interpolation(TStringInterpolation),
+    Constant(Constant),
+}
+
+// constructor
+impl Node for TemplateStrPart {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::Interpolation(value) => value.ast_to_object(vm, source_file),
+            Self::Constant(value) => value.ast_to_object(vm, source_file),
+        }
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let cls = object.class();
+        if cls.is(pyast::NodeExprInterpolation::static_type()) {
+            Ok(Self::Interpolation(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        } else {
+            Ok(Self::Constant(Node::ast_from_object(
+                vm,
+                source_file,
+                object,
+            )?))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(super) struct TStringInterpolation {
+    value: Box<ruff::Expr>,
+    str: String,
+    conversion: ruff::ConversionFlag,
+    format_spec: Option<Box<TemplateStr>>,
+    range: TextRange,
+}
+
+// constructor
+impl Node for TStringInterpolation {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            value,
+            str,
+            conversion,
+            format_spec,
+            range,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(vm, pyast::NodeExprInterpolation::static_type().to_owned())
+            .unwrap();
+        let dict = node.as_object().dict().unwrap();
+        dict.set_item("value", value.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item("str", vm.ctx.new_str(str).into(), vm)
+            .unwrap();
+        dict.set_item("conversion", conversion.ast_to_object(vm, source_file), vm)
+            .unwrap();
+        dict.set_item(
+            "format_spec",
+            format_spec.ast_to_object(vm, source_file),
+            vm,
+        )
+        .unwrap();
+        node_add_location(&dict, range, vm, source_file);
+        node.into()
+    }
+    fn ast_from_object(
+        vm: &VirtualMachine,
+        source_file: &SourceFile,
+        object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let str_obj = get_node_field(vm, &object, "str", "Interpolation")?;
+        let str_val: String = str_obj.try_into_value(vm)?;
+        Ok(Self {
+            value: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "value", "Interpolation")?,
+            )?,
+            str: str_val,
+            conversion: Node::ast_from_object(
+                vm,
+                source_file,
+                get_node_field(vm, &object, "conversion", "Interpolation")?,
+            )?,
+            format_spec: get_node_field_opt(vm, &object, "format_spec")?
+                .map(|obj| Node::ast_from_object(vm, source_file, obj))
+                .transpose()?,
+            range: range_from_object(vm, source_file, object, "Interpolation")?,
+        })
+    }
+}
+
+pub(super) fn tstring_to_object(
+    vm: &VirtualMachine,
+    source_file: &SourceFile,
+    expression: ruff::ExprTString,
+) -> PyObjectRef {
+    let ruff::ExprTString {
+        range,
+        mut value,
+        node_index: _,
+    } = expression;
+    let default_tstring = ruff::TString {
+        node_index: Default::default(),
+        range: Default::default(),
+        elements: Default::default(),
+        flags: ruff::TStringFlags::empty(),
+    };
+    let mut values = Vec::new();
+    for i in 0..value.as_slice().len() {
+        let tstring = core::mem::replace(value.iter_mut().nth(i).unwrap(), default_tstring.clone());
+        for element in ruff_fstring_element_into_iter(tstring.elements) {
+            values.push(ruff_tstring_element_to_template_str_part(
+                element,
+                source_file,
+            ));
+        }
+    }
+    let c = TemplateStr {
+        range,
+        values: values.into_boxed_slice(),
+    };
+    c.ast_to_object(vm, source_file)
+}
diff --git a/vm/src/stdlib/ast/type_ignore.rs b/crates/vm/src/stdlib/ast/type_ignore.rs
similarity index 80%
rename from vm/src/stdlib/ast/type_ignore.rs
rename to crates/vm/src/stdlib/ast/type_ignore.rs
index a247302fa6..de929fcf62 100644
--- a/vm/src/stdlib/ast/type_ignore.rs
+++ b/crates/vm/src/stdlib/ast/type_ignore.rs
@@ -1,4 +1,5 @@
 use super::*;
+use rustpython_compiler_core::SourceFile;
 
 pub(super) enum TypeIgnore {
     TypeIgnore(TypeIgnoreTypeIgnore),
@@ -6,21 +7,21 @@ pub(super) enum TypeIgnore {
 
 // sum
 impl Node for TypeIgnore {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         match self {
-            Self::TypeIgnore(cons) => cons.ast_to_object(vm, source_code),
+            Self::TypeIgnore(cons) => cons.ast_to_object(vm, source_file),
         }
     }
     fn ast_from_object(
         _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         _object: PyObjectRef,
     ) -> PyResult<Self> {
         let _cls = _object.class();
         Ok(if _cls.is(pyast::NodeTypeIgnoreTypeIgnore::static_type()) {
             Self::TypeIgnore(TypeIgnoreTypeIgnore::ast_from_object(
                 _vm,
-                source_code,
+                source_file,
                 _object,
             )?)
         } else {
@@ -40,7 +41,7 @@ pub(super) struct TypeIgnoreTypeIgnore {
 
 // constructor
 impl Node for TypeIgnoreTypeIgnore {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
         let Self { lineno, tag, range } = self;
         let node = NodeAst
             .into_ref_with_type(
@@ -51,13 +52,13 @@ impl Node for TypeIgnoreTypeIgnore {
         let dict = node.as_object().dict().unwrap();
         dict.set_item("lineno", lineno.to_pyobject(vm), vm).unwrap();
         dict.set_item("tag", tag.to_pyobject(vm), vm).unwrap();
-        node_add_location(&dict, range, vm, source_code);
+        node_add_location(&dict, range, vm, source_file);
         node.into()
     }
 
     fn ast_from_object(
         vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
+        source_file: &SourceFile,
         object: PyObjectRef,
     ) -> PyResult<Self> {
         Ok(Self {
@@ -67,7 +68,7 @@ impl Node for TypeIgnoreTypeIgnore {
             tag: get_node_field(vm, &object, "tag", "TypeIgnore")?
                 .downcast_exact(vm)
                 .unwrap(),
-            range: range_from_object(vm, source_code, object, "TypeIgnore")?,
+            range: range_from_object(vm, source_file, object, "TypeIgnore")?,
         })
     }
 }
diff --git a/crates/vm/src/stdlib/ast/type_parameters.rs b/crates/vm/src/stdlib/ast/type_parameters.rs
new file mode 100644
index 0000000000..017470f7e6
--- /dev/null
+++ b/crates/vm/src/stdlib/ast/type_parameters.rs
@@ -0,0 +1,215 @@
+use super::*;
+use rustpython_compiler_core::SourceFile;
+
+impl Node for ruff::TypeParams {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        self.type_params.ast_to_object(vm, source_file)
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        _source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let type_params: Vec<ruff::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();
+        Ok(Self {
+            node_index: Default::default(),
+            type_params,
+            range,
+        })
+    }
+
+    fn is_none(&self) -> bool {
+        self.type_params.is_empty()
+    }
+}
+
+// sum
+impl Node for ruff::TypeParam {
+    fn ast_to_object(self, vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        match self {
+            Self::TypeVar(cons) => cons.ast_to_object(vm, source_file),
+            Self::ParamSpec(cons) => cons.ast_to_object(vm, source_file),
+            Self::TypeVarTuple(cons) => cons.ast_to_object(vm, source_file),
+        }
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        let _cls = _object.class();
+        Ok(if _cls.is(pyast::NodeTypeParamTypeVar::static_type()) {
+            Self::TypeVar(ruff::TypeParamTypeVar::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeTypeParamParamSpec::static_type()) {
+            Self::ParamSpec(ruff::TypeParamParamSpec::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else if _cls.is(pyast::NodeTypeParamTypeVarTuple::static_type()) {
+            Self::TypeVarTuple(ruff::TypeParamTypeVarTuple::ast_from_object(
+                _vm,
+                source_file,
+                _object,
+            )?)
+        } else {
+            return Err(_vm.new_type_error(format!(
+                "expected some sort of type_param, but got {}",
+                _object.repr(_vm)?
+            )));
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::TypeParamTypeVar {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            bound,
+            range: _range,
+            default: _,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        dict.set_item("bound", bound.ast_to_object(_vm, source_file), _vm)
+            .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                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))
+                .transpose()?,
+            default: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "default_value", "TypeVar")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "TypeVar")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::TypeParamParamSpec {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            range: _range,
+            default,
+        } = self;
+        let node = NodeAst
+            .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)
+            .unwrap();
+        dict.set_item(
+            "default_value",
+            default.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "name", "ParamSpec")?,
+            )?,
+            default: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "default_value", "ParamSpec")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "ParamSpec")?,
+        })
+    }
+}
+
+// constructor
+impl Node for ruff::TypeParamTypeVarTuple {
+    fn ast_to_object(self, _vm: &VirtualMachine, source_file: &SourceFile) -> PyObjectRef {
+        let Self {
+            node_index: _,
+            name,
+            range: _range,
+            default,
+        } = self;
+        let node = NodeAst
+            .into_ref_with_type(
+                _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)
+            .unwrap();
+        dict.set_item(
+            "default_value",
+            default.ast_to_object(_vm, source_file),
+            _vm,
+        )
+        .unwrap();
+        node_add_location(&dict, _range, _vm, source_file);
+        node.into()
+    }
+
+    fn ast_from_object(
+        _vm: &VirtualMachine,
+        source_file: &SourceFile,
+        _object: PyObjectRef,
+    ) -> PyResult<Self> {
+        Ok(Self {
+            node_index: Default::default(),
+            name: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "name", "TypeVarTuple")?,
+            )?,
+            default: Node::ast_from_object(
+                _vm,
+                source_file,
+                get_node_field(_vm, &_object, "default_value", "TypeVarTuple")?,
+            )?,
+            range: range_from_object(_vm, source_file, _object, "TypeVarTuple")?,
+        })
+    }
+}
diff --git a/vm/src/stdlib/atexit.rs b/crates/vm/src/stdlib/atexit.rs
similarity index 94%
rename from vm/src/stdlib/atexit.rs
rename to crates/vm/src/stdlib/atexit.rs
index b1832b5481..2286c36f1d 100644
--- a/vm/src/stdlib/atexit.rs
+++ b/crates/vm/src/stdlib/atexit.rs
@@ -34,7 +34,7 @@ mod atexit {
 
     #[pyfunction]
     pub fn _run_exitfuncs(vm: &VirtualMachine) {
-        let funcs: Vec<_> = std::mem::take(&mut *vm.state.atexit_funcs.lock());
+        let funcs: Vec<_> = core::mem::take(&mut *vm.state.atexit_funcs.lock());
         for (func, args) in funcs.into_iter().rev() {
             if let Err(e) = func.call(args, vm) {
                 let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);
diff --git a/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
similarity index 87%
rename from vm/src/stdlib/builtins.rs
rename to crates/vm/src/stdlib/builtins.rs
index 52eb698fbb..b4554bc30a 100644
--- a/vm/src/stdlib/builtins.rs
+++ b/crates/vm/src/stdlib/builtins.rs
@@ -7,10 +7,8 @@ pub use builtins::{ascii, print, reversed};
 
 #[pymodule]
 mod builtins {
-    use std::io::IsTerminal;
-
     use crate::{
-        AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+        AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
         builtins::{
             PyByteArray, PyBytes, PyDictRef, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType,
             enumerate::PyReverseSequenceIterator,
@@ -47,7 +45,7 @@ mod builtins {
     #[pyfunction]
     fn all(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if !*item? {
+            if !item?.into_bool() {
                 return Ok(false);
             }
         }
@@ -57,7 +55,7 @@ mod builtins {
     #[pyfunction]
     fn any(iterable: ArgIterable<ArgIntoBool>, vm: &VirtualMachine) -> PyResult<bool> {
         for item in iterable.iter(vm)? {
-            if *item? {
+            if item?.into_bool() {
                 return Ok(true);
             }
         }
@@ -132,7 +130,7 @@ mod builtins {
 
             let optimize: i32 = args.optimize.map_or(Ok(-1), |v| v.try_to_primitive(vm))?;
             let optimize: u8 = if optimize == -1 {
-                vm.state.settings.optimize
+                vm.state.config.settings.optimize
             } else {
                 optimize
                     .try_into()
@@ -177,7 +175,7 @@ mod builtins {
                 let source = source.borrow_bytes();
 
                 // TODO: compiler::compile should probably get bytes
-                let source = std::str::from_utf8(&source)
+                let source = core::str::from_utf8(&source)
                     .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
 
                 let flags = args.flags.map_or(Ok(0), |v| v.try_to_primitive(vm))?;
@@ -261,14 +259,14 @@ mod builtins {
             func_name: &'static str,
         ) -> PyResult<crate::scope::Scope> {
             fn validate_globals_dict(
-                globals: &PyObjectRef,
+                globals: &PyObject,
                 vm: &VirtualMachine,
                 func_name: &'static str,
             ) -> PyResult<()> {
                 if !globals.fast_isinstance(vm.ctx.types.dict_type) {
                     return Err(match func_name {
                         "eval" => {
-                            let is_mapping = crate::protocol::PyMapping::check(globals);
+                            let is_mapping = globals.mapping_unchecked().check();
                             vm.new_type_error(if is_mapping {
                                 "globals must be a real dict; try eval(expr, {}, mapping)"
                                     .to_owned()
@@ -335,7 +333,7 @@ mod builtins {
                     ));
                 }
 
-                let source = std::str::from_utf8(source).map_err(|err| {
+                let source = core::str::from_utf8(source).map_err(|err| {
                     let msg = format!(
                         "(unicode error) 'utf-8' codec can't decode byte 0x{:x?} in position {}: invalid start byte",
                         source[err.valid_up_to()],
@@ -453,6 +451,7 @@ mod builtins {
 
     #[pyfunction]
     fn hex(number: ArgIndex) -> String {
+        let number = number.into_int_ref();
         let n = number.as_bigint();
         format!("{n:#x}")
     }
@@ -464,6 +463,8 @@ mod builtins {
 
     #[pyfunction]
     fn input(prompt: OptionalArg<PyStrRef>, vm: &VirtualMachine) -> PyResult {
+        use std::io::IsTerminal;
+
         let stdin = sys::get_stdin(vm)?;
         let stdout = sys::get_stdout(vm)?;
         let stderr = sys::get_stderr(vm)?;
@@ -476,8 +477,13 @@ mod builtins {
                 .is_ok_and(|fd| fd == expected)
         };
 
-        // everything is normal, we can just rely on rustyline to use stdin/stdout
-        if fd_matches(&stdin, 0) && fd_matches(&stdout, 1) && std::io::stdin().is_terminal() {
+        // Check if we should use rustyline (interactive terminal, not PTY child)
+        let use_rustyline = fd_matches(&stdin, 0)
+            && fd_matches(&stdout, 1)
+            && std::io::stdin().is_terminal()
+            && !is_pty_child();
+
+        if use_rustyline {
             let prompt = prompt.as_ref().map_or("", |s| s.as_str());
             let mut readline = Readline::new(());
             match readline.readline(prompt) {
@@ -489,6 +495,8 @@ mod builtins {
                     Err(vm.new_exception_empty(vm.ctx.exceptions.keyboard_interrupt.to_owned()))
                 }
                 ReadlineResult::Io(e) => Err(vm.new_os_error(e.to_string())),
+                #[cfg(unix)]
+                ReadlineResult::OsError(num) => Err(vm.new_os_error(num.to_string())),
                 ReadlineResult::Other(e) => Err(vm.new_runtime_error(e.to_string())),
             }
         } else {
@@ -500,6 +508,21 @@ mod builtins {
         }
     }
 
+    /// Check if we're running in a PTY child process (e.g., after pty.fork()).
+    /// pty.fork() calls setsid(), making the child a session leader.
+    /// In this case, rustyline may hang because it uses raw mode.
+    #[cfg(unix)]
+    fn is_pty_child() -> bool {
+        use nix::unistd::{getpid, getsid};
+        // If this process is a session leader, we're likely in a PTY child
+        getsid(None) == Ok(getpid())
+    }
+
+    #[cfg(not(unix))]
+    fn is_pty_child() -> bool {
+        false
+    }
+
     #[pyfunction]
     fn isinstance(obj: PyObjectRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
         obj.is_instance(&typ, vm)
@@ -532,6 +555,33 @@ mod builtins {
         iter_target.get_aiter(vm)
     }
 
+    #[pyfunction]
+    fn anext(
+        aiter: PyObjectRef,
+        default_value: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use crate::builtins::asyncgenerator::PyAnextAwaitable;
+
+        // Check if object is an async iterator (has __anext__ method)
+        if !aiter.class().has_attr(identifier!(vm, __anext__)) {
+            return Err(vm.new_type_error(format!(
+                "'{}' object is not an async iterator",
+                aiter.class().name()
+            )));
+        }
+
+        let awaitable = vm.call_method(&aiter, "__anext__", ())?;
+
+        if let OptionalArg::Present(default) = default_value {
+            Ok(PyAnextAwaitable::new(awaitable, default)
+                .into_ref(&vm.ctx)
+                .into())
+        } else {
+            Ok(awaitable)
+        }
+    }
+
     #[pyfunction]
     fn len(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
         obj.length(vm)
@@ -556,7 +606,7 @@ mod builtins {
         }
 
         let candidates = match args.args.len().cmp(&1) {
-            std::cmp::Ordering::Greater => {
+            core::cmp::Ordering::Greater => {
                 if default.is_some() {
                     return Err(vm.new_type_error(format!(
                         "Cannot specify a default for {func_name}() with multiple positional arguments"
@@ -564,8 +614,8 @@ mod builtins {
                 }
                 args.args
             }
-            std::cmp::Ordering::Equal => args.args[0].try_to_value(vm)?,
-            std::cmp::Ordering::Less => {
+            core::cmp::Ordering::Equal => args.args[0].try_to_value(vm)?,
+            core::cmp::Ordering::Less => {
                 // zero arguments means type error:
                 return Err(
                     vm.new_type_error(format!("{func_name} expected at least 1 argument, got 0"))
@@ -638,6 +688,7 @@ mod builtins {
 
     #[pyfunction]
     fn oct(number: ArgIndex, vm: &VirtualMachine) -> PyResult {
+        let number = number.into_int_ref();
         let n = number.as_bigint();
         let s = if n.is_negative() {
             format!("-0o{:o}", n.abs())
@@ -737,7 +788,7 @@ mod builtins {
             .unwrap_or_else(|| PyStr::from("\n").into_ref(&vm.ctx));
         write(end)?;
 
-        if *options.flush {
+        if options.flush.into() {
             vm.call_method(&file, "flush", ())?;
         }
 
@@ -874,13 +925,12 @@ mod builtins {
     #[pyfunction]
     pub fn __build_class__(
         function: PyRef<PyFunction>,
-        qualified_name: PyStrRef,
+        name: PyStrRef,
         bases: PosArgs,
         mut kwargs: KwArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
-        let name = qualified_name.as_str().split('.').next_back().unwrap();
-        let name_obj = vm.ctx.new_str(name);
+        let name_obj: PyObjectRef = name.clone().into();
 
         // Update bases.
         let mut new_bases: Option<Vec<PyObjectRef>> = None;
@@ -924,20 +974,33 @@ mod builtins {
                     .downcast_exact::<PyType>(vm)
                     .map(|m| m.into_pyref())
             })
-            .unwrap_or_else(|| Ok(vm.ctx.types.type_type.to_owned()));
+            .unwrap_or_else(|| {
+                // if there are no bases, use type; else get the type of the first base
+                Ok(if bases.is_empty() {
+                    vm.ctx.types.type_type.to_owned()
+                } else {
+                    bases.first().unwrap().class().to_owned()
+                })
+            });
 
         let (metaclass, meta_name) = match metaclass {
             Ok(mut metaclass) => {
                 for base in bases.iter() {
                     let base_class = base.class();
+                    // if winner is subtype of tmptype, continue (winner is more derived)
+                    if metaclass.fast_issubclass(base_class) {
+                        continue;
+                    }
+                    // if tmptype is subtype of winner, update (tmptype is more derived)
                     if base_class.fast_issubclass(&metaclass) {
-                        metaclass = base.class().to_owned();
-                    } else if !metaclass.fast_issubclass(base_class) {
-                        return Err(vm.new_type_error(
-                            "metaclass conflict: the metaclass of a derived class must be a (non-strict) \
-                            subclass of the metaclasses of all its bases",
-                        ));
+                        metaclass = base_class.to_owned();
+                        continue;
                     }
+                    // Metaclass conflict
+                    return Err(vm.new_type_error(
+                        "metaclass conflict: the metaclass of a derived class must be a (non-strict) \
+                        subclass of the metaclasses of all its bases",
+                    ));
                 }
                 let meta_name = metaclass.slot_name();
                 (metaclass.to_owned().into(), meta_name.to_owned())
@@ -951,8 +1014,7 @@ mod builtins {
         let namespace = vm
             .get_attribute_opt(metaclass.clone(), identifier!(vm, __prepare__))?
             .map_or(Ok(vm.ctx.new_dict().into()), |prepare| {
-                let args =
-                    FuncArgs::new(vec![name_obj.clone().into(), bases.clone()], kwargs.clone());
+                let args = FuncArgs::new(vec![name_obj.clone(), bases.clone()], kwargs.clone());
                 prepare.call(args, vm)
             })?;
 
@@ -969,17 +1031,13 @@ mod builtins {
         if let Ok(type_params) = function
             .as_object()
             .get_attr(identifier!(vm, __type_params__), vm)
+            && let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>()
+            && !type_params_tuple.is_empty()
         {
-            if let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>() {
-                if !type_params_tuple.is_empty() {
-                    // Set .type_params in namespace so the compiler-generated code can use it
-                    namespace.as_object().set_item(
-                        vm.ctx.intern_str(".type_params"),
-                        type_params,
-                        vm,
-                    )?;
-                }
-            }
+            // Set .type_params in namespace so the compiler-generated code can use it
+            namespace
+                .as_object()
+                .set_item(vm.ctx.intern_str(".type_params"), type_params, vm)?;
         }
 
         let classcell = function.invoke_with_locals(().into(), Some(namespace.clone()), vm)?;
@@ -999,33 +1057,36 @@ mod builtins {
             .del_item(vm.ctx.intern_str(".type_params"), vm)
             .ok();
 
-        let args = FuncArgs::new(vec![name_obj.into(), bases, namespace.into()], kwargs);
+        let args = FuncArgs::new(vec![name_obj, bases, namespace.into()], kwargs);
         let class = metaclass.call(args, vm)?;
 
         // For PEP 695 classes, set __type_params__ on the class from the function
         if let Ok(type_params) = function
             .as_object()
             .get_attr(identifier!(vm, __type_params__), vm)
+            && let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>()
+            && !type_params_tuple.is_empty()
         {
-            if let Some(type_params_tuple) = type_params.downcast_ref::<PyTuple>() {
-                if !type_params_tuple.is_empty() {
-                    class.set_attr(identifier!(vm, __type_params__), type_params.clone(), vm)?;
-                    // Also set __parameters__ for compatibility with typing module
-                    class.set_attr(identifier!(vm, __parameters__), type_params, vm)?;
-                }
-            }
+            class.set_attr(identifier!(vm, __type_params__), type_params.clone(), vm)?;
+            // Also set __parameters__ for compatibility with typing module
+            class.set_attr(identifier!(vm, __parameters__), type_params, vm)?;
         }
 
-        if let Some(ref classcell) = classcell {
-            let classcell = classcell.get().ok_or_else(|| {
-                vm.new_type_error(format!(
-                    "__class__ not set defining {meta_name:?} as {class:?}. Was __classcell__ propagated to type.__new__?"
+        // only check cell if cls is a type and cell is a cell object
+        if let Some(ref classcell) = classcell
+            && class.fast_isinstance(vm.ctx.types.type_type)
+        {
+            let cell_value = classcell.get().ok_or_else(|| {
+                vm.new_runtime_error(format!(
+                    "__class__ not set defining {:?} as {:?}. Was __classcell__ propagated to type.__new__?",
+                    name, class
                 ))
             })?;
 
-            if !classcell.is(&class) {
+            if !cell_value.is(&class) {
                 return Err(vm.new_type_error(format!(
-                    "__class__ set to {classcell:?} defining {meta_name:?} as {class:?}"
+                    "__class__ set to {:?} defining {:?} as {:?}",
+                    cell_value, name, class
                 )));
             }
         }
@@ -1041,7 +1102,10 @@ pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
 
     builtins::extend_module(vm, module).unwrap();
 
-    let debug_mode: bool = vm.state.settings.optimize == 0;
+    let debug_mode: bool = vm.state.config.settings.optimize == 0;
+    // Create dynamic ExceptionGroup with multiple inheritance (BaseExceptionGroup + Exception)
+    let exception_group = crate::exception_group::exception_group();
+
     extend_module!(vm, module, {
         "__debug__" => ctx.new_bool(debug_mode),
 
@@ -1082,7 +1146,7 @@ pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
         // Exceptions:
         "BaseException" => ctx.exceptions.base_exception_type.to_owned(),
         "BaseExceptionGroup" => ctx.exceptions.base_exception_group.to_owned(),
-        "ExceptionGroup" => ctx.exceptions.exception_group.to_owned(),
+        "ExceptionGroup" => exception_group.to_owned(),
         "SystemExit" => ctx.exceptions.system_exit.to_owned(),
         "KeyboardInterrupt" => ctx.exceptions.keyboard_interrupt.to_owned(),
         "GeneratorExit" => ctx.exceptions.generator_exit.to_owned(),
@@ -1159,4 +1223,10 @@ pub fn init_module(vm: &VirtualMachine, module: &Py<PyModule>) {
     extend_module!(vm, module, {
         "JitError" => ctx.exceptions.jit_error.to_owned(),
     });
+
+    #[cfg(windows)]
+    extend_module!(vm, module, {
+        // OSError alias for Windows
+        "WindowsError" => ctx.exceptions.os_error.to_owned(),
+    });
 }
diff --git a/crates/vm/src/stdlib/codecs.rs b/crates/vm/src/stdlib/codecs.rs
new file mode 100644
index 0000000000..1661eef175
--- /dev/null
+++ b/crates/vm/src/stdlib/codecs.rs
@@ -0,0 +1,709 @@
+pub(crate) use _codecs::make_module;
+
+#[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/vm/src/stdlib/collections.rs b/crates/vm/src/stdlib/collections.rs
similarity index 94%
rename from vm/src/stdlib/collections.rs
rename to crates/vm/src/stdlib/collections.rs
index 6d1cdf1f02..fd48cea059 100644
--- a/vm/src/stdlib/collections.rs
+++ b/crates/vm/src/stdlib/collections.rs
@@ -7,24 +7,24 @@ mod _collections {
         atomic_func,
         builtins::{
             IterStatus::{Active, Exhausted},
-            PositionIterInternal, PyGenericAlias, PyInt, PyTypeRef,
+            PositionIterInternal, PyGenericAlias, PyInt, PyType, PyTypeRef,
         },
         common::lock::{PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard},
         function::{KwArgs, OptionalArg, PyComparisonValue},
         iter::PyExactSizeIterator,
-        protocol::{PyIterReturn, PySequenceMethods},
+        protocol::{PyIterReturn, PyNumberMethods, PySequenceMethods},
         recursion::ReprGuard,
         sequence::{MutObjectSequenceOp, OptionalRangeArgs},
         sliceable::SequenceIndexOp,
         types::{
-            AsSequence, Comparable, Constructor, DefaultConstructor, Initializer, IterNext,
-            Iterable, PyComparisonOp, Representable, SelfIter,
+            AsNumber, AsSequence, Comparable, Constructor, DefaultConstructor, Initializer,
+            IterNext, Iterable, PyComparisonOp, Representable, SelfIter,
         },
         utils::collection_repr,
     };
+    use alloc::collections::VecDeque;
+    use core::cmp::max;
     use crossbeam_utils::atomic::AtomicCell;
-    use std::cmp::max;
-    use std::collections::VecDeque;
 
     #[pyattr]
     #[pyclass(module = "collections", name = "deque", unhashable = true)]
@@ -60,6 +60,7 @@ mod _collections {
         with(
             Constructor,
             Initializer,
+            AsNumber,
             AsSequence,
             Comparable,
             Iterable,
@@ -157,7 +158,7 @@ mod _collections {
             let mut created = VecDeque::from(elements);
             let mut borrowed = self.borrow_deque_mut();
             created.append(&mut borrowed);
-            std::mem::swap(&mut created, &mut borrowed);
+            core::mem::swap(&mut created, &mut borrowed);
             Ok(())
         }
 
@@ -277,7 +278,6 @@ mod _collections {
             self.maxlen
         }
 
-        #[pymethod]
         fn __getitem__(&self, idx: isize, vm: &VirtualMachine) -> PyResult {
             let deque = self.borrow_deque();
             idx.wrapped_at(deque.len())
@@ -285,7 +285,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __setitem__(&self, idx: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
             let mut deque = self.borrow_deque_mut();
             idx.wrapped_at(deque.len())
@@ -294,7 +293,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __delitem__(&self, idx: isize, vm: &VirtualMachine) -> PyResult<()> {
             let mut deque = self.borrow_deque_mut();
             idx.wrapped_at(deque.len())
@@ -302,7 +300,6 @@ mod _collections {
                 .ok_or_else(|| vm.new_index_error("deque index out of range"))
         }
 
-        #[pymethod]
         fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
             self._contains(&needle, vm)
         }
@@ -331,8 +328,6 @@ mod _collections {
             Ok(deque)
         }
 
-        #[pymethod]
-        #[pymethod(name = "__rmul__")]
         fn __mul__(&self, n: isize, vm: &VirtualMachine) -> PyResult<Self> {
             let deque = self._mul(n, vm)?;
             Ok(Self {
@@ -342,30 +337,18 @@ mod _collections {
             })
         }
 
-        #[pymethod]
         fn __imul__(zelf: PyRef<Self>, n: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
             let mul_deque = zelf._mul(n, vm)?;
             *zelf.borrow_deque_mut() = mul_deque;
             Ok(zelf)
         }
 
-        #[pymethod]
         fn __len__(&self) -> usize {
             self.borrow_deque().len()
         }
 
-        #[pymethod]
-        fn __bool__(&self) -> bool {
-            !self.borrow_deque().is_empty()
-        }
-
-        #[pymethod]
-        fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
-            self.concat(&other, vm)
-        }
-
         fn concat(&self, other: &PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-            if let Some(o) = other.payload_if_subclass::<Self>(vm) {
+            if let Some(o) = other.downcast_ref::<Self>() {
                 let mut deque = self.borrow_deque().clone();
                 let elements = o.borrow_deque().clone();
                 deque.extend(elements);
@@ -389,7 +372,6 @@ mod _collections {
             }
         }
 
-        #[pymethod]
         fn __iadd__(
             zelf: PyRef<Self>,
             other: PyObjectRef,
@@ -422,11 +404,11 @@ mod _collections {
     impl MutObjectSequenceOp for PyDeque {
         type Inner = VecDeque<PyObjectRef>;
 
-        fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObjectRef> {
-            inner.get(index)
+        fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObject> {
+            inner.get(index).map(|r| r.as_ref())
         }
 
-        fn do_lock(&self) -> impl std::ops::Deref<Target = Self::Inner> {
+        fn do_lock(&self) -> impl core::ops::Deref<Target = Self::Inner> {
             self.borrow_deque()
         }
     }
@@ -446,7 +428,7 @@ mod _collections {
             let maxlen = if let Some(obj) = maxlen.into_option() {
                 if !vm.is_none(&obj) {
                     let maxlen: isize = obj
-                        .payload::<PyInt>()
+                        .downcast_ref::<PyInt>()
                         .ok_or_else(|| vm.new_type_error("an integer is required."))?
                         .try_to_primitive(vm)?;
 
@@ -484,7 +466,7 @@ mod _collections {
                     // `maxlen` is better to be defined as UnsafeCell in common practice,
                     // but then more type works without any safety benefits
                     let unsafe_maxlen =
-                        &zelf.maxlen as *const _ as *const std::cell::UnsafeCell<Option<usize>>;
+                        &zelf.maxlen as *const _ as *const core::cell::UnsafeCell<Option<usize>>;
                     *(*unsafe_maxlen).get() = maxlen;
                 }
                 if let Some(elements) = elements {
@@ -496,6 +478,19 @@ mod _collections {
         }
     }
 
+    impl AsNumber for PyDeque {
+        fn as_number() -> &'static PyNumberMethods {
+            static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+                boolean: Some(|number, _vm| {
+                    let zelf = number.obj.downcast_ref::<PyDeque>().unwrap();
+                    Ok(!zelf.borrow_deque().is_empty())
+                }),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
     impl AsSequence for PyDeque {
         fn as_sequence() -> &'static PySequenceMethods {
             static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
@@ -606,16 +601,16 @@ mod _collections {
         type Args = (DequeIterArgs, KwArgs);
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             (DequeIterArgs { deque, index }, _kwargs): Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let iter = Self::new(deque);
             if let OptionalArg::Present(index) = index {
                 let index = max(index, 0) as usize;
                 iter.internal.lock().position = index;
             }
-            iter.into_ref_with_type(vm, cls).map(Into::into)
+            Ok(iter)
         }
     }
 
@@ -678,17 +673,16 @@ mod _collections {
         type Args = (DequeIterArgs, KwArgs);
 
         fn py_new(
-            cls: PyTypeRef,
-
+            _cls: &Py<PyType>,
             (DequeIterArgs { deque, index }, _kwargs): Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let iter = PyDeque::__reversed__(deque)?;
             if let OptionalArg::Present(index) = index {
                 let index = max(index, 0) as usize;
                 iter.internal.lock().position = index;
             }
-            iter.into_ref_with_type(vm, cls).map(Into::into)
+            Ok(iter)
         }
     }
 
diff --git a/crates/vm/src/stdlib/ctypes.rs b/crates/vm/src/stdlib/ctypes.rs
new file mode 100644
index 0000000000..cbe3f5405b
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes.rs
@@ -0,0 +1,1303 @@
+// spell-checker:disable
+
+mod array;
+mod base;
+mod function;
+mod library;
+mod pointer;
+mod simple;
+mod structure;
+mod union;
+
+use crate::{
+    AsObject, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
+    builtins::{PyModule, PyStr, PyType},
+    class::PyClassImpl,
+    types::TypeDataRef,
+};
+use core::ffi::{
+    c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
+    c_ulonglong, c_ushort,
+};
+use core::mem;
+use widestring::WideChar;
+
+pub use array::PyCArray;
+pub use base::{FfiArgValue, PyCData, PyCField, StgInfo, StgInfoFlags};
+pub use pointer::PyCPointer;
+pub use simple::{PyCSimple, PyCSimpleType};
+pub use structure::PyCStructure;
+pub use union::PyCUnion;
+
+/// Extension for PyType to get StgInfo
+/// PyStgInfo_FromType
+impl Py<PyType> {
+    /// Get StgInfo from a ctypes type object
+    ///
+    /// Returns a TypeDataRef to StgInfo if the type has one and is initialized, error otherwise.
+    /// Abstract classes (whose metaclass __init__ was not called) will have uninitialized StgInfo.
+    fn stg_info<'a>(&'a self, vm: &VirtualMachine) -> PyResult<TypeDataRef<'a, StgInfo>> {
+        self.stg_info_opt()
+            .ok_or_else(|| vm.new_type_error("abstract class"))
+    }
+
+    /// Get StgInfo if initialized, None otherwise.
+    fn stg_info_opt(&self) -> Option<TypeDataRef<'_, StgInfo>> {
+        self.get_type_data::<StgInfo>()
+            .filter(|info| info.initialized)
+    }
+
+    /// Get _type_ attribute as String (type code like "i", "d", etc.)
+    fn type_code(&self, vm: &VirtualMachine) -> Option<String> {
+        self.as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t: PyObjectRef| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
+    }
+
+    /// Mark all base classes as finalized
+    fn mark_bases_final(&self) {
+        for base in self.bases.read().iter() {
+            if let Some(mut stg) = base.get_type_data_mut::<StgInfo>() {
+                stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+            } else {
+                let mut stg = StgInfo::default();
+                stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                let _ = base.init_type_data(stg);
+            }
+        }
+    }
+}
+
+impl PyType {
+    /// Check if StgInfo is already initialized - prevent double initialization
+    pub(crate) fn check_not_initialized(&self, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(stg_info) = self.get_type_data::<StgInfo>()
+            && stg_info.initialized
+        {
+            return Err(vm.new_exception_msg(
+                vm.ctx.exceptions.system_error.to_owned(),
+                format!("StgInfo of '{}' is already initialized.", self.name()),
+            ));
+        }
+        Ok(())
+    }
+}
+
+// Dynamic type check helpers for PyCData
+// These check if an object's type's metaclass is a subclass of a specific metaclass
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _ctypes::make_module(vm);
+    let ctx = &vm.ctx;
+    PyCSimpleType::make_class(ctx);
+    array::PyCArrayType::make_class(ctx);
+    pointer::PyCPointerType::make_class(ctx);
+    structure::PyCStructType::make_class(ctx);
+    union::PyCUnionType::make_class(ctx);
+    function::PyCFuncPtrType::make_class(ctx);
+    extend_module!(vm, &module, {
+        "_CData" => PyCData::make_class(ctx),
+        "_SimpleCData" => PyCSimple::make_class(ctx),
+        "Array" => PyCArray::make_class(ctx),
+        "CField" => PyCField::make_class(ctx),
+        "CFuncPtr" => function::PyCFuncPtr::make_class(ctx),
+        "_Pointer" => PyCPointer::make_class(ctx),
+        "_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),
+    });
+    module
+}
+
+/// Size of long double - platform dependent
+/// x86_64 macOS/Linux: 16 bytes (80-bit extended + padding)
+/// ARM64: 16 bytes (128-bit)
+/// Windows: 8 bytes (same as double)
+#[cfg(all(
+    any(target_arch = "x86_64", target_arch = "aarch64"),
+    not(target_os = "windows")
+))]
+const LONG_DOUBLE_SIZE: usize = 16;
+
+#[cfg(target_os = "windows")]
+const LONG_DOUBLE_SIZE: usize = mem::size_of::<c_double>();
+
+#[cfg(not(any(
+    all(
+        any(target_arch = "x86_64", target_arch = "aarch64"),
+        not(target_os = "windows")
+    ),
+    target_os = "windows"
+)))]
+const LONG_DOUBLE_SIZE: usize = mem::size_of::<c_double>();
+
+/// Type information for ctypes simple types
+struct TypeInfo {
+    pub size: usize,
+    pub ffi_type_fn: fn() -> libffi::middle::Type,
+}
+
+/// Get type information (size and ffi_type) for a ctypes type code
+fn type_info(ty: &str) -> Option<TypeInfo> {
+    use libffi::middle::Type;
+    match ty {
+        "c" => Some(TypeInfo {
+            size: mem::size_of::<c_schar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "u" => Some(TypeInfo {
+            size: mem::size_of::<WideChar>(),
+            ffi_type_fn: if mem::size_of::<WideChar>() == 2 {
+                Type::u16
+            } else {
+                Type::u32
+            },
+        }),
+        "b" => Some(TypeInfo {
+            size: mem::size_of::<c_schar>(),
+            ffi_type_fn: Type::i8,
+        }),
+        "B" => Some(TypeInfo {
+            size: mem::size_of::<c_uchar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "h" | "v" => Some(TypeInfo {
+            size: mem::size_of::<c_short>(),
+            ffi_type_fn: Type::i16,
+        }),
+        "H" => Some(TypeInfo {
+            size: mem::size_of::<c_ushort>(),
+            ffi_type_fn: Type::u16,
+        }),
+        "i" => Some(TypeInfo {
+            size: mem::size_of::<c_int>(),
+            ffi_type_fn: Type::i32,
+        }),
+        "I" => Some(TypeInfo {
+            size: mem::size_of::<c_uint>(),
+            ffi_type_fn: Type::u32,
+        }),
+        "l" => Some(TypeInfo {
+            size: mem::size_of::<c_long>(),
+            ffi_type_fn: if mem::size_of::<c_long>() == 8 {
+                Type::i64
+            } else {
+                Type::i32
+            },
+        }),
+        "L" => Some(TypeInfo {
+            size: mem::size_of::<c_ulong>(),
+            ffi_type_fn: if mem::size_of::<c_ulong>() == 8 {
+                Type::u64
+            } else {
+                Type::u32
+            },
+        }),
+        "q" => Some(TypeInfo {
+            size: mem::size_of::<c_longlong>(),
+            ffi_type_fn: Type::i64,
+        }),
+        "Q" => Some(TypeInfo {
+            size: mem::size_of::<c_ulonglong>(),
+            ffi_type_fn: Type::u64,
+        }),
+        "f" => Some(TypeInfo {
+            size: mem::size_of::<c_float>(),
+            ffi_type_fn: Type::f32,
+        }),
+        "d" => Some(TypeInfo {
+            size: mem::size_of::<c_double>(),
+            ffi_type_fn: Type::f64,
+        }),
+        "g" => Some(TypeInfo {
+            // long double - platform dependent size
+            // x86_64 macOS/Linux: 16 bytes (80-bit extended + padding)
+            // ARM64: 16 bytes (128-bit)
+            // Windows: 8 bytes (same as double)
+            // Note: Use f64 as FFI type since Rust doesn't support long double natively
+            size: LONG_DOUBLE_SIZE,
+            ffi_type_fn: Type::f64,
+        }),
+        "?" => Some(TypeInfo {
+            size: mem::size_of::<c_uchar>(),
+            ffi_type_fn: Type::u8,
+        }),
+        "z" | "Z" | "P" | "X" | "O" => Some(TypeInfo {
+            size: mem::size_of::<usize>(),
+            ffi_type_fn: Type::pointer,
+        }),
+        "void" => Some(TypeInfo {
+            size: 0,
+            ffi_type_fn: Type::void,
+        }),
+        _ => None,
+    }
+}
+
+/// Get size for a ctypes type code
+fn get_size(ty: &str) -> usize {
+    type_info(ty).map(|t| t.size).expect("invalid type code")
+}
+
+/// Get alignment for simple type codes from type_info().
+/// For primitive C types (c_int, c_long, etc.), alignment equals size.
+fn get_align(ty: &str) -> usize {
+    get_size(ty)
+}
+
+#[pymodule]
+pub(crate) mod _ctypes {
+    use super::library;
+    use super::{PyCArray, PyCData, PyCPointer, PyCSimple, PyCStructure, PyCUnion};
+    use crate::builtins::{PyType, PyTypeRef};
+    use crate::class::StaticType;
+    use crate::convert::ToPyObject;
+    use crate::function::{Either, OptionalArg};
+    use crate::types::Representable;
+    use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+    use num_traits::ToPrimitive;
+
+    /// CArgObject - returned by byref() and paramfunc
+    /// tagPyCArgObject
+    #[pyclass(name = "CArgObject", module = "_ctypes", no_attr)]
+    #[derive(Debug, PyPayload)]
+    pub struct CArgObject {
+        /// Type tag ('P', 'V', 'i', 'd', etc.)
+        pub tag: u8,
+        /// The actual FFI value (mirrors union value)
+        pub value: super::FfiArgValue,
+        /// Reference to original object (for memory safety)
+        pub obj: PyObjectRef,
+        /// Size for struct/union ('V' tag)
+        #[allow(dead_code)]
+        pub size: usize,
+        /// Offset for byref()
+        pub offset: isize,
+    }
+
+    /// is_literal_char - check if character is printable literal (not \\ or ')
+    fn is_literal_char(c: u8) -> bool {
+        c < 128 && c.is_ascii_graphic() && c != b'\\' && c != b'\''
+    }
+
+    impl Representable for CArgObject {
+        // PyCArg_repr - use tag and value fields directly
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            use super::base::FfiArgValue;
+
+            let tag_char = zelf.tag as char;
+
+            // Format value based on tag
+            match zelf.tag {
+                b'b' | b'h' | b'i' | b'l' | b'q' => {
+                    // Signed integers
+                    let n = match zelf.value {
+                        FfiArgValue::I8(v) => v as i64,
+                        FfiArgValue::I16(v) => v as i64,
+                        FfiArgValue::I32(v) => v as i64,
+                        FfiArgValue::I64(v) => v,
+                        _ => 0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, n))
+                }
+                b'B' | b'H' | b'I' | b'L' | b'Q' => {
+                    // Unsigned integers
+                    let n = match zelf.value {
+                        FfiArgValue::U8(v) => v as u64,
+                        FfiArgValue::U16(v) => v as u64,
+                        FfiArgValue::U32(v) => v as u64,
+                        FfiArgValue::U64(v) => v,
+                        _ => 0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, n))
+                }
+                b'f' => {
+                    let v = match zelf.value {
+                        FfiArgValue::F32(v) => v as f64,
+                        _ => 0.0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, v))
+                }
+                b'd' | b'g' => {
+                    let v = match zelf.value {
+                        FfiArgValue::F64(v) => v,
+                        FfiArgValue::F32(v) => v as f64,
+                        _ => 0.0,
+                    };
+                    Ok(format!("<cparam '{}' ({})>", tag_char, v))
+                }
+                b'c' => {
+                    // c_char - single byte
+                    let byte = match zelf.value {
+                        FfiArgValue::I8(v) => v as u8,
+                        FfiArgValue::U8(v) => v,
+                        _ => 0,
+                    };
+                    if is_literal_char(byte) {
+                        Ok(format!("<cparam '{}' ('{}')>", tag_char, byte as char))
+                    } else {
+                        Ok(format!("<cparam '{}' ('\\x{:02x}')>", tag_char, byte))
+                    }
+                }
+                b'z' | b'Z' | b'P' | b'V' => {
+                    // Pointer types
+                    let ptr = match zelf.value {
+                        FfiArgValue::Pointer(v) => v,
+                        _ => 0,
+                    };
+                    if ptr == 0 {
+                        Ok(format!("<cparam '{}' (nil)>", tag_char))
+                    } else {
+                        Ok(format!("<cparam '{}' ({:#x})>", tag_char, ptr))
+                    }
+                }
+                _ => {
+                    // Default fallback
+                    let addr = zelf.get_id();
+                    if is_literal_char(zelf.tag) {
+                        Ok(format!("<cparam '{}' at {:#x}>", tag_char, addr))
+                    } else {
+                        Ok(format!("<cparam {:#04x} at {:#x}>", zelf.tag, addr))
+                    }
+                }
+            }
+        }
+    }
+
+    #[pyclass(with(Representable))]
+    impl CArgObject {
+        #[pygetset]
+        fn _obj(&self) -> PyObjectRef {
+            self.obj.clone()
+        }
+    }
+
+    #[pyattr(name = "__version__")]
+    const __VERSION__: &str = "1.1.0";
+
+    // TODO: get properly
+    #[pyattr]
+    const RTLD_LOCAL: i32 = 0;
+
+    // TODO: get properly
+    #[pyattr]
+    const RTLD_GLOBAL: i32 = 0;
+
+    #[pyattr]
+    const SIZEOF_TIME_T: usize = core::mem::size_of::<libc::time_t>();
+
+    #[pyattr]
+    const CTYPES_MAX_ARGCOUNT: usize = 1024;
+
+    #[pyattr]
+    const FUNCFLAG_STDCALL: u32 = 0x0;
+    #[pyattr]
+    const FUNCFLAG_CDECL: u32 = 0x1;
+    #[pyattr]
+    const FUNCFLAG_HRESULT: u32 = 0x2;
+    #[pyattr]
+    const FUNCFLAG_PYTHONAPI: u32 = 0x4;
+    #[pyattr]
+    const FUNCFLAG_USE_ERRNO: u32 = 0x8;
+    #[pyattr]
+    const FUNCFLAG_USE_LASTERROR: u32 = 0x10;
+
+    #[pyattr]
+    const TYPEFLAG_ISPOINTER: u32 = 0x100;
+    #[pyattr]
+    const TYPEFLAG_HASPOINTER: u32 = 0x200;
+
+    #[pyattr]
+    const DICTFLAG_FINAL: u32 = 0x1000;
+
+    #[pyattr(name = "ArgumentError", once)]
+    fn argument_error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "_ctypes",
+            "ArgumentError",
+            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
+        )
+    }
+
+    #[cfg(target_os = "windows")]
+    #[pyattr(name = "COMError", once)]
+    fn com_error(vm: &VirtualMachine) -> PyTypeRef {
+        use crate::builtins::type_::PyAttributes;
+        use crate::function::FuncArgs;
+        use crate::types::{PyTypeFlags, PyTypeSlots};
+
+        // Sets hresult, text, details as instance attributes in __init__
+        // This function has InitFunc signature for direct slots.init use
+        fn comerror_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            let (hresult, text, details): (
+                Option<PyObjectRef>,
+                Option<PyObjectRef>,
+                Option<PyObjectRef>,
+            ) = args.bind(vm)?;
+            let hresult = hresult.unwrap_or_else(|| vm.ctx.none());
+            let text = text.unwrap_or_else(|| vm.ctx.none());
+            let details = details.unwrap_or_else(|| vm.ctx.none());
+
+            // Set instance attributes
+            zelf.set_attr("hresult", hresult.clone(), vm)?;
+            zelf.set_attr("text", text.clone(), vm)?;
+            zelf.set_attr("details", details.clone(), vm)?;
+
+            // self.args = args[1:] = (text, details)
+            // via: PyObject_SetAttrString(self, "args", PySequence_GetSlice(args, 1, size))
+            let args_tuple: PyObjectRef = vm.ctx.new_tuple(vec![text, details]).into();
+            zelf.set_attr("args", args_tuple, vm)?;
+
+            Ok(())
+        }
+
+        // Create exception type with IMMUTABLETYPE flag
+        let mut attrs = PyAttributes::default();
+        attrs.insert(
+            vm.ctx.intern_str("__module__"),
+            vm.ctx.new_str("_ctypes").into(),
+        );
+        attrs.insert(
+            vm.ctx.intern_str("__doc__"),
+            vm.ctx
+                .new_str("Raised when a COM method call failed.")
+                .into(),
+        );
+
+        // Create slots with IMMUTABLETYPE flag
+        let slots = PyTypeSlots {
+            name: "COMError",
+            flags: PyTypeFlags::heap_type_flags()
+                | PyTypeFlags::HAS_DICT
+                | PyTypeFlags::IMMUTABLETYPE,
+            ..PyTypeSlots::default()
+        };
+
+        let exc_type = PyType::new_heap(
+            "COMError",
+            vec![vm.ctx.exceptions.exception_type.to_owned()],
+            attrs,
+            slots,
+            vm.ctx.types.type_type.to_owned(),
+            &vm.ctx,
+        )
+        .unwrap();
+
+        // Set our custom init after new_heap, which runs init_slots that would
+        // otherwise overwrite slots.init with init_wrapper (due to __init__ in MRO).
+        exc_type.slots.init.store(Some(comerror_init));
+
+        exc_type
+    }
+
+    /// Get the size of a ctypes type or instance
+    #[pyfunction]
+    pub fn sizeof(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        use super::structure::PyCStructType;
+        use super::union::PyCUnionType;
+
+        // 1. Check if obj is a TYPE object (not instance) - PyStgInfo_FromType
+        if let Some(type_obj) = obj.downcast_ref::<PyType>() {
+            // Type object - return StgInfo.size
+            if let Some(stg_info) = type_obj.stg_info_opt() {
+                return Ok(stg_info.size);
+            }
+            // Fallback for type objects without StgInfo
+            // Array types
+            if type_obj
+                .class()
+                .fast_issubclass(super::array::PyCArrayType::static_type())
+                && let Ok(stg) = type_obj.stg_info(vm)
+            {
+                return Ok(stg.size);
+            }
+            // Structure types
+            if type_obj
+                .class()
+                .fast_issubclass(PyCStructType::static_type())
+            {
+                return super::structure::calculate_struct_size(type_obj, vm);
+            }
+            // Union types
+            if type_obj
+                .class()
+                .fast_issubclass(PyCUnionType::static_type())
+            {
+                return super::union::calculate_union_size(type_obj, vm);
+            }
+            // Simple types
+            if type_obj.fast_issubclass(PyCSimple::static_type()) {
+                if let Ok(type_attr) = type_obj.as_object().get_attr("_type_", vm)
+                    && let Ok(type_str) = type_attr.str(vm)
+                {
+                    return Ok(super::get_size(type_str.as_ref()));
+                }
+                return Ok(core::mem::size_of::<usize>());
+            }
+            // Pointer types
+            if type_obj.fast_issubclass(PyCPointer::static_type()) {
+                return Ok(core::mem::size_of::<usize>());
+            }
+            return Err(vm.new_type_error("this type has no size"));
+        }
+
+        // 2. Instance object - return actual buffer size (b_size)
+        // CDataObject_Check + return obj->b_size
+        if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            return Ok(cdata.size());
+        }
+        if obj.fast_isinstance(PyCPointer::static_type()) {
+            return Ok(core::mem::size_of::<usize>());
+        }
+
+        Err(vm.new_type_error("this type has no size"))
+    }
+
+    #[cfg(windows)]
+    #[pyfunction(name = "LoadLibrary")]
+    fn load_library_windows(
+        name: String,
+        _load_flags: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        // TODO: audit functions first
+        // TODO: load_flags
+        let cache = library::libcache();
+        let mut cache_write = cache.write();
+        let (id, _) = cache_write.get_or_insert_lib(&name, vm).unwrap();
+        Ok(id)
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction(name = "dlopen")]
+    fn load_library_unix(
+        name: Option<crate::function::FsPath>,
+        load_flags: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        // Default mode: RTLD_NOW | RTLD_LOCAL, always force RTLD_NOW
+        let mode = load_flags.unwrap_or(libc::RTLD_NOW | libc::RTLD_LOCAL) | libc::RTLD_NOW;
+
+        match name {
+            Some(name) => {
+                let cache = library::libcache();
+                let mut cache_write = cache.write();
+                let os_str = name.as_os_str(vm)?;
+                let (id, _) = cache_write
+                    .get_or_insert_lib_with_mode(&*os_str, mode, vm)
+                    .map_err(|e| {
+                        let name_str = os_str.to_string_lossy();
+                        vm.new_os_error(format!("{}: {}", name_str, e))
+                    })?;
+                Ok(id)
+            }
+            None => {
+                // dlopen(NULL, mode) to get the current process handle (for pythonapi)
+                let handle = unsafe { libc::dlopen(core::ptr::null(), mode) };
+                if handle.is_null() {
+                    let err = unsafe { libc::dlerror() };
+                    let msg = if err.is_null() {
+                        "dlopen() error".to_string()
+                    } else {
+                        unsafe {
+                            core::ffi::CStr::from_ptr(err)
+                                .to_string_lossy()
+                                .into_owned()
+                        }
+                    };
+                    return Err(vm.new_os_error(msg));
+                }
+                // Add to library cache so symbol lookup works
+                let cache = library::libcache();
+                let mut cache_write = cache.write();
+                let id = cache_write.insert_raw_handle(handle);
+                Ok(id)
+            }
+        }
+    }
+
+    #[pyfunction(name = "FreeLibrary")]
+    fn free_library(handle: usize) -> PyResult<()> {
+        let cache = library::libcache();
+        let mut cache_write = cache.write();
+        cache_write.drop_lib(handle);
+        Ok(())
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn dlclose(handle: usize, _vm: &VirtualMachine) -> PyResult<()> {
+        // Remove from cache, which triggers SharedLibrary drop.
+        // libloading::Library calls dlclose automatically on Drop.
+        let cache = library::libcache();
+        let mut cache_write = cache.write();
+        cache_write.drop_lib(handle);
+        Ok(())
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn dlsym(
+        handle: usize,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        let symbol_name = alloc::ffi::CString::new(name.as_str())
+            .map_err(|_| vm.new_value_error("symbol name contains null byte"))?;
+
+        // Clear previous error
+        unsafe { libc::dlerror() };
+
+        let ptr = unsafe { libc::dlsym(handle as *mut libc::c_void, symbol_name.as_ptr()) };
+
+        // Check for error via dlerror first
+        let err = unsafe { libc::dlerror() };
+        if !err.is_null() {
+            let msg = unsafe {
+                core::ffi::CStr::from_ptr(err)
+                    .to_string_lossy()
+                    .into_owned()
+            };
+            return Err(vm.new_os_error(msg));
+        }
+
+        // Treat NULL symbol address as error
+        // This handles cases like GNU IFUNCs that resolve to NULL
+        if ptr.is_null() {
+            return Err(vm.new_os_error(format!("symbol '{}' not found", name.as_str())));
+        }
+
+        Ok(ptr as usize)
+    }
+
+    #[pyfunction(name = "POINTER")]
+    fn create_pointer_type(cls: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        use crate::builtins::PyStr;
+
+        // Get the _pointer_type_cache
+        let ctypes_module = vm.import("_ctypes", 0)?;
+        let cache = ctypes_module.get_attr("_pointer_type_cache", vm)?;
+
+        // Check if already in cache using __getitem__
+        if let Ok(cached) = vm.call_method(&cache, "__getitem__", (cls.clone(),))
+            && !vm.is_none(&cached)
+        {
+            return Ok(cached);
+        }
+
+        // Get the _Pointer base class
+        let pointer_base = ctypes_module.get_attr("_Pointer", vm)?;
+
+        // Create a new type that inherits from _Pointer
+        let pointer_base_type = pointer_base
+            .clone()
+            .downcast::<crate::builtins::PyType>()
+            .map_err(|_| vm.new_type_error("_Pointer must be a type"))?;
+        let metaclass = pointer_base_type.class().to_owned();
+
+        let bases = vm.ctx.new_tuple(vec![pointer_base]);
+        let dict = vm.ctx.new_dict();
+
+        // PyUnicode_CheckExact(cls) - string creates incomplete pointer type
+        if let Some(s) = cls.downcast_ref::<PyStr>() {
+            // Incomplete pointer type: _type_ not set, cache key is id(result)
+            let name = format!("LP_{}", s.as_str());
+
+            let new_type = metaclass
+                .as_object()
+                .call((vm.ctx.new_str(name), bases, dict), vm)?;
+
+            // Store with id(result) as key for incomplete pointer types
+            let id_key: PyObjectRef = vm.ctx.new_int(new_type.get_id() as i64).into();
+            vm.call_method(&cache, "__setitem__", (id_key, new_type.clone()))?;
+
+            return Ok(new_type);
+        }
+
+        // PyType_Check(cls) - type creates complete pointer type
+        if !cls.class().fast_issubclass(vm.ctx.types.type_type.as_ref()) {
+            return Err(vm.new_type_error("must be a ctypes type"));
+        }
+
+        // Create the name for the pointer type
+        let name = if let Ok(type_obj) = cls.get_attr("__name__", vm) {
+            format!("LP_{}", type_obj.str(vm)?)
+        } else {
+            "LP_unknown".to_string()
+        };
+
+        // Complete pointer type: set _type_ attribute
+        dict.set_item("_type_", cls.clone(), vm)?;
+
+        // Call the metaclass (PyCPointerType) to create the new type
+        let new_type = metaclass
+            .as_object()
+            .call((vm.ctx.new_str(name), bases, dict), vm)?;
+
+        // Store in cache with cls as key
+        vm.call_method(&cache, "__setitem__", (cls, new_type.clone()))?;
+
+        Ok(new_type)
+    }
+
+    #[pyfunction]
+    fn pointer(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Get the type of the object
+        let obj_type = obj.class().to_owned();
+
+        // Create pointer type for this object's type
+        let ptr_type = create_pointer_type(obj_type.into(), vm)?;
+
+        // Create an instance of the pointer type with the object
+        ptr_type.call((obj,), vm)
+    }
+
+    #[pyfunction]
+    fn _pointer_type_cache() -> PyObjectRef {
+        todo!()
+    }
+
+    #[cfg(target_os = "windows")]
+    #[pyfunction(name = "_check_HRESULT")]
+    fn check_hresult(_self: PyObjectRef, hr: i32, _vm: &VirtualMachine) -> PyResult<i32> {
+        // TODO: fixme
+        if hr < 0 {
+            // vm.ctx.new_windows_error(hr)
+            todo!();
+        } else {
+            Ok(hr)
+        }
+    }
+
+    #[pyfunction]
+    fn addressof(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        // All ctypes objects should return cdata buffer pointer
+        if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            Ok(cdata.buffer.read().as_ptr() as usize)
+        } else {
+            Err(vm.new_type_error("expected a ctypes instance"))
+        }
+    }
+
+    #[pyfunction]
+    pub fn byref(obj: PyObjectRef, offset: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult {
+        use super::FfiArgValue;
+
+        // Check if obj is a ctypes instance
+        if !obj.fast_isinstance(PyCData::static_type())
+            && !obj.fast_isinstance(PyCSimple::static_type())
+        {
+            return Err(vm.new_type_error(format!(
+                "byref() argument must be a ctypes instance, not '{}'",
+                obj.class().name()
+            )));
+        }
+
+        let offset_val = offset.unwrap_or(0);
+
+        // Get buffer address: (char *)((CDataObject *)obj)->b_ptr + offset
+        let ptr_val = if let Some(simple) = obj.downcast_ref::<PyCSimple>() {
+            let buffer = simple.0.buffer.read();
+            (buffer.as_ptr() as isize + offset_val) as usize
+        } else if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            let buffer = cdata.buffer.read();
+            (buffer.as_ptr() as isize + offset_val) as usize
+        } else {
+            0
+        };
+
+        // Create CArgObject to hold the reference
+        Ok(CArgObject {
+            tag: b'P',
+            value: FfiArgValue::Pointer(ptr_val),
+            obj,
+            size: 0,
+            offset: offset_val,
+        }
+        .to_pyobject(vm))
+    }
+
+    #[pyfunction]
+    fn alignment(tp: Either<PyTypeRef, PyObjectRef>, vm: &VirtualMachine) -> PyResult<usize> {
+        use crate::builtins::PyType;
+
+        let obj = match &tp {
+            Either::A(t) => t.as_object(),
+            Either::B(o) => o.as_ref(),
+        };
+
+        // 1. Check TypeDataSlot on class (for instances)
+        if let Some(stg_info) = obj.class().stg_info_opt() {
+            return Ok(stg_info.align);
+        }
+
+        // 2. Check TypeDataSlot on type itself (for type objects)
+        if let Some(type_obj) = obj.downcast_ref::<PyType>()
+            && let Some(stg_info) = type_obj.stg_info_opt()
+        {
+            return Ok(stg_info.align);
+        }
+
+        // 3. Fallback for simple types
+        if obj.fast_isinstance(PyCSimple::static_type())
+            && let Ok(stg) = obj.class().stg_info(vm)
+        {
+            return Ok(stg.align);
+        }
+        if obj.fast_isinstance(PyCArray::static_type())
+            && let Ok(stg) = obj.class().stg_info(vm)
+        {
+            return Ok(stg.align);
+        }
+        if obj.fast_isinstance(PyCStructure::static_type()) {
+            // Calculate alignment from _fields_
+            let cls = obj.class();
+            return alignment(Either::A(cls.to_owned()), vm);
+        }
+        if obj.fast_isinstance(PyCPointer::static_type()) {
+            // Pointer alignment is always pointer size
+            return Ok(core::mem::align_of::<usize>());
+        }
+        if obj.fast_isinstance(PyCUnion::static_type()) {
+            // Calculate alignment from _fields_
+            let cls = obj.class();
+            return alignment(Either::A(cls.to_owned()), vm);
+        }
+
+        // Get the type object to check
+        let type_obj: PyObjectRef = match &tp {
+            Either::A(t) => t.clone().into(),
+            Either::B(obj) => obj.class().to_owned().into(),
+        };
+
+        // For type objects, try to get alignment from _type_ attribute
+        if let Ok(type_attr) = type_obj.get_attr("_type_", vm) {
+            // Array/Pointer: _type_ is the element type (a PyType)
+            if let Ok(elem_type) = type_attr.clone().downcast::<crate::builtins::PyType>() {
+                return alignment(Either::A(elem_type), vm);
+            }
+            // Simple type: _type_ is a single character string
+            if let Ok(s) = type_attr.str(vm) {
+                let ty = s.to_string();
+                if ty.len() == 1 && super::simple::SIMPLE_TYPE_CHARS.contains(ty.as_str()) {
+                    return Ok(super::get_align(&ty));
+                }
+            }
+        }
+
+        // Structure/Union: max alignment of fields
+        if let Ok(fields_attr) = type_obj.get_attr("_fields_", vm)
+            && let Ok(fields) = fields_attr.try_to_value::<Vec<PyObjectRef>>(vm)
+        {
+            let mut max_align = 1usize;
+            for field in fields.iter() {
+                if let Some(tuple) = field.downcast_ref::<crate::builtins::PyTuple>()
+                    && let Some(field_type) = tuple.get(1)
+                {
+                    let align =
+                        if let Ok(ft) = field_type.clone().downcast::<crate::builtins::PyType>() {
+                            alignment(Either::A(ft), vm).unwrap_or(1)
+                        } else {
+                            1
+                        };
+                    max_align = max_align.max(align);
+                }
+            }
+            return Ok(max_align);
+        }
+
+        // For instances, delegate to their class
+        if let Either::B(obj) = &tp
+            && !obj.class().is(vm.ctx.types.type_type.as_ref())
+        {
+            return alignment(Either::A(obj.class().to_owned()), vm);
+        }
+
+        // No alignment info found
+        Err(vm.new_type_error("no alignment info"))
+    }
+
+    #[pyfunction]
+    fn resize(obj: PyObjectRef, size: isize, vm: &VirtualMachine) -> PyResult<()> {
+        use alloc::borrow::Cow;
+
+        // 1. Get StgInfo from object's class (validates ctypes instance)
+        let stg_info = obj
+            .class()
+            .stg_info_opt()
+            .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?;
+
+        // 2. Validate size
+        if size < 0 || (size as usize) < stg_info.size {
+            return Err(vm.new_value_error(format!("minimum size is {}", stg_info.size)));
+        }
+
+        // 3. Get PyCData via upcast (works for all ctypes types due to repr(transparent))
+        let cdata = obj
+            .downcast_ref::<PyCData>()
+            .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?;
+
+        // 4. Check if buffer is owned (not borrowed from external memory)
+        {
+            let buffer = cdata.buffer.read();
+            if matches!(&*buffer, Cow::Borrowed(_)) {
+                return Err(vm.new_value_error(
+                    "Memory cannot be resized because this object doesn't own it".to_owned(),
+                ));
+            }
+        }
+
+        // 5. Resize the buffer
+        let new_size = size as usize;
+        let mut buffer = cdata.buffer.write();
+        let old_data = buffer.to_vec();
+        let mut new_data = vec![0u8; new_size];
+        let copy_len = old_data.len().min(new_size);
+        new_data[..copy_len].copy_from_slice(&old_data[..copy_len]);
+        *buffer = Cow::Owned(new_data);
+
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn get_errno() -> i32 {
+        super::function::get_errno_value()
+    }
+
+    #[pyfunction]
+    fn set_errno(value: i32) -> i32 {
+        super::function::set_errno_value(value)
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn get_last_error() -> PyResult<u32> {
+        Ok(super::function::get_last_error_value())
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn set_last_error(value: u32) -> u32 {
+        super::function::set_last_error_value(value)
+    }
+
+    #[pyattr]
+    fn _memmove_addr(_vm: &VirtualMachine) -> usize {
+        let f = libc::memmove;
+        f as usize
+    }
+
+    #[pyattr]
+    fn _memset_addr(_vm: &VirtualMachine) -> usize {
+        let f = libc::memset;
+        f as usize
+    }
+
+    #[pyattr]
+    fn _string_at_addr(_vm: &VirtualMachine) -> usize {
+        super::function::INTERNAL_STRING_AT_ADDR
+    }
+
+    #[pyattr]
+    fn _wstring_at_addr(_vm: &VirtualMachine) -> usize {
+        super::function::INTERNAL_WSTRING_AT_ADDR
+    }
+
+    #[pyattr]
+    fn _cast_addr(_vm: &VirtualMachine) -> usize {
+        super::function::INTERNAL_CAST_ADDR
+    }
+
+    #[pyfunction]
+    fn _cast(
+        obj: PyObjectRef,
+        src: PyObjectRef,
+        ctype: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        super::function::cast_impl(obj, src, ctype, vm)
+    }
+
+    /// Python-level cast function (PYFUNCTYPE wrapper)
+    #[pyfunction]
+    fn cast(obj: PyObjectRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        super::function::cast_impl(obj.clone(), obj, typ, vm)
+    }
+
+    /// Return buffer interface information for a ctypes type or object.
+    /// Returns a tuple (format, ndim, shape) where:
+    /// - format: PEP 3118 format string
+    /// - ndim: number of dimensions
+    /// - shape: tuple of dimension sizes
+    #[pyfunction]
+    fn buffer_info(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Determine if obj is a type or an instance
+        let is_type = obj.class().fast_issubclass(vm.ctx.types.type_type.as_ref());
+        let cls = if is_type {
+            obj.clone()
+        } else {
+            obj.class().to_owned().into()
+        };
+
+        // Get format from type - try _type_ first (for simple types), then _stg_info_format_
+        let format = if let Ok(type_attr) = cls.get_attr("_type_", vm) {
+            type_attr.str(vm)?.to_string()
+        } else if let Ok(format_attr) = cls.get_attr("_stg_info_format_", vm) {
+            format_attr.str(vm)?.to_string()
+        } else {
+            return Err(vm.new_type_error("not a ctypes type or object"));
+        };
+
+        // Non-array types have ndim=0 and empty shape
+        // TODO: Implement ndim/shape for arrays when StgInfo supports it
+        let ndim = 0;
+        let shape: Vec<PyObjectRef> = vec![];
+
+        let shape_tuple = vm.ctx.new_tuple(shape);
+        Ok(vm
+            .ctx
+            .new_tuple(vec![
+                vm.ctx.new_str(format).into(),
+                vm.ctx.new_int(ndim).into(),
+                shape_tuple.into(),
+            ])
+            .into())
+    }
+
+    /// Unpickle a ctypes object.
+    #[pyfunction]
+    fn _unpickle(typ: PyObjectRef, state: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        if !state.class().is(vm.ctx.types.tuple_type.as_ref()) {
+            return Err(vm.new_type_error("state must be a tuple"));
+        }
+        let obj = vm.call_method(&typ, "__new__", (typ.clone(),))?;
+        vm.call_method(&obj, "__setstate__", (state,))?;
+        Ok(obj)
+    }
+
+    /// Call a function at the given address with the given arguments.
+    #[pyfunction]
+    fn call_function(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        call_function_internal(func_addr, args, 0, vm)
+    }
+
+    /// Call a cdecl function at the given address with the given arguments.
+    #[pyfunction]
+    fn call_cdeclfunction(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        call_function_internal(func_addr, args, FUNCFLAG_CDECL, vm)
+    }
+
+    fn call_function_internal(
+        func_addr: usize,
+        args: crate::builtins::PyTupleRef,
+        _flags: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use libffi::middle::{Arg, Cif, CodePtr, Type};
+
+        if func_addr == 0 {
+            return Err(vm.new_value_error("NULL function pointer"));
+        }
+
+        let mut ffi_args: Vec<Arg<'_>> = Vec::with_capacity(args.len());
+        let mut arg_values: Vec<isize> = Vec::with_capacity(args.len());
+        let mut arg_types: Vec<Type> = Vec::with_capacity(args.len());
+
+        for arg in args.iter() {
+            if vm.is_none(arg) {
+                arg_values.push(0);
+                arg_types.push(Type::pointer());
+            } else if let Ok(int_val) = arg.try_int(vm) {
+                let val = int_val.as_bigint().to_i64().unwrap_or(0) as isize;
+                arg_values.push(val);
+                arg_types.push(Type::isize());
+            } else if let Some(bytes) = arg.downcast_ref::<crate::builtins::PyBytes>() {
+                let ptr = bytes.as_bytes().as_ptr() as isize;
+                arg_values.push(ptr);
+                arg_types.push(Type::pointer());
+            } else if let Some(s) = arg.downcast_ref::<crate::builtins::PyStr>() {
+                let ptr = s.as_str().as_ptr() as isize;
+                arg_values.push(ptr);
+                arg_types.push(Type::pointer());
+            } else {
+                return Err(vm.new_type_error(format!(
+                    "Don't know how to convert parameter of type '{}'",
+                    arg.class().name()
+                )));
+            }
+        }
+
+        for val in &arg_values {
+            ffi_args.push(Arg::new(val));
+        }
+
+        let cif = Cif::new(arg_types, Type::c_int());
+        let code_ptr = CodePtr::from_ptr(func_addr as *const _);
+        let result: libc::c_int = unsafe { cif.call(code_ptr, &ffi_args) };
+        Ok(vm.ctx.new_int(result).into())
+    }
+
+    /// Convert a pointer (as integer) to a Python object.
+    #[pyfunction(name = "PyObj_FromPtr")]
+    fn py_obj_from_ptr(ptr: usize, vm: &VirtualMachine) -> PyResult {
+        if ptr == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+        let raw_ptr = ptr as *mut crate::object::PyObject;
+        unsafe {
+            let obj = crate::PyObjectRef::from_raw(core::ptr::NonNull::new_unchecked(raw_ptr));
+            let obj = core::mem::ManuallyDrop::new(obj);
+            Ok((*obj).clone())
+        }
+    }
+
+    #[pyfunction(name = "Py_INCREF")]
+    fn py_incref(obj: PyObjectRef, _vm: &VirtualMachine) -> PyObjectRef {
+        // TODO:
+        obj
+    }
+
+    #[pyfunction(name = "Py_DECREF")]
+    fn py_decref(obj: PyObjectRef, _vm: &VirtualMachine) -> PyObjectRef {
+        // TODO:
+        obj
+    }
+
+    #[cfg(target_os = "macos")]
+    #[pyfunction]
+    fn _dyld_shared_cache_contains_path(
+        path: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        use alloc::ffi::CString;
+
+        let path = match path {
+            Some(p) if !vm.is_none(&p) => p,
+            _ => return Ok(false),
+        };
+
+        let path_str = path.str(vm)?.to_string();
+        let c_path =
+            CString::new(path_str).map_err(|_| vm.new_value_error("path contains null byte"))?;
+
+        unsafe extern "C" {
+            fn _dyld_shared_cache_contains_path(path: *const libc::c_char) -> bool;
+        }
+
+        let result = unsafe { _dyld_shared_cache_contains_path(c_path.as_ptr()) };
+        Ok(result)
+    }
+
+    #[cfg(windows)]
+    #[pyfunction(name = "FormatError")]
+    fn format_error_func(code: OptionalArg<u32>, _vm: &VirtualMachine) -> PyResult<String> {
+        use windows_sys::Win32::Foundation::{GetLastError, LocalFree};
+        use windows_sys::Win32::System::Diagnostics::Debug::{
+            FORMAT_MESSAGE_ALLOCATE_BUFFER, FORMAT_MESSAGE_FROM_SYSTEM,
+            FORMAT_MESSAGE_IGNORE_INSERTS, FormatMessageW,
+        };
+
+        let error_code = code.unwrap_or_else(|| unsafe { GetLastError() });
+
+        let mut buffer: *mut u16 = std::ptr::null_mut();
+        let len = unsafe {
+            FormatMessageW(
+                FORMAT_MESSAGE_ALLOCATE_BUFFER
+                    | FORMAT_MESSAGE_FROM_SYSTEM
+                    | FORMAT_MESSAGE_IGNORE_INSERTS,
+                core::ptr::null(),
+                error_code,
+                0,
+                &mut buffer as *mut *mut u16 as *mut u16,
+                0,
+                core::ptr::null(),
+            )
+        };
+
+        if len == 0 || buffer.is_null() {
+            return Ok("<no description>".to_string());
+        }
+
+        let message = unsafe {
+            let slice = std::slice::from_raw_parts(buffer, len as usize);
+            let msg = String::from_utf16_lossy(slice).trim_end().to_string();
+            LocalFree(buffer as *mut _);
+            msg
+        };
+
+        Ok(message)
+    }
+
+    #[cfg(windows)]
+    #[pyfunction(name = "CopyComPointer")]
+    fn copy_com_pointer(src: PyObjectRef, dst: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
+        use windows_sys::Win32::Foundation::{E_POINTER, S_OK};
+
+        // 1. Extract pointer-to-pointer address from dst (byref() result)
+        let pdst: usize = if let Some(carg) = dst.downcast_ref::<CArgObject>() {
+            // byref() result: object buffer address + offset
+            let base = if let Some(cdata) = carg.obj.downcast_ref::<PyCData>() {
+                cdata.buffer.read().as_ptr() as usize
+            } else {
+                return Ok(E_POINTER);
+            };
+            (base as isize + carg.offset) as usize
+        } else {
+            return Ok(E_POINTER);
+        };
+
+        if pdst == 0 {
+            return Ok(E_POINTER);
+        }
+
+        // 2. Extract COM pointer value from src
+        let src_ptr: usize = if vm.is_none(&src) {
+            0
+        } else if let Some(cdata) = src.downcast_ref::<PyCData>() {
+            // c_void_p etc: read pointer value from buffer
+            let buffer = cdata.buffer.read();
+            if buffer.len() >= std::mem::size_of::<usize>() {
+                usize::from_ne_bytes(
+                    buffer[..std::mem::size_of::<usize>()]
+                        .try_into()
+                        .unwrap_or([0; std::mem::size_of::<usize>()]),
+                )
+            } else {
+                0
+            }
+        } else {
+            return Ok(E_POINTER);
+        };
+
+        // 3. Call IUnknown::AddRef if src is non-NULL
+        if src_ptr != 0 {
+            unsafe {
+                // IUnknown vtable: [QueryInterface, AddRef, Release, ...]
+                let iunknown = src_ptr as *mut *const usize;
+                let vtable = *iunknown;
+                debug_assert!(!vtable.is_null(), "IUnknown vtable is null");
+                let addref_fn: extern "system" fn(*mut std::ffi::c_void) -> u32 =
+                    core::mem::transmute(*vtable.add(1)); // AddRef is index 1
+                addref_fn(src_ptr as *mut std::ffi::c_void);
+            }
+        }
+
+        // 4. Copy pointer: *pdst = src
+        unsafe {
+            *(pdst as *mut usize) = src_ptr;
+        }
+
+        Ok(S_OK)
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/array.rs b/crates/vm/src/stdlib/ctypes/array.rs
new file mode 100644
index 0000000000..eea1fd765d
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/array.rs
@@ -0,0 +1,1361 @@
+use super::StgInfo;
+use super::base::{CDATA_BUFFER_METHODS, PyCData};
+use super::type_info;
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
+    atomic_func,
+    builtins::{
+        PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef, genericalias::PyGenericAlias,
+    },
+    class::StaticType,
+    function::{ArgBytesLike, FuncArgs, PySetterValue},
+    protocol::{BufferDescriptor, PyBuffer, PyMappingMethods, PyNumberMethods, PySequenceMethods},
+    types::{AsBuffer, AsMapping, AsNumber, AsSequence, Constructor, Initializer},
+};
+use alloc::borrow::Cow;
+use num_traits::{Signed, ToPrimitive};
+
+/// Get itemsize from a PEP 3118 format string
+/// Extracts the type code (last char after endianness prefix) and returns its size
+fn get_size_from_format(fmt: &str) -> usize {
+    // Format is like "<f", ">q", etc. - strip endianness prefix and get type code
+    let code = fmt
+        .trim_start_matches(['<', '>', '@', '=', '!', '&'])
+        .chars()
+        .next()
+        .map(|c| c.to_string());
+    code.map(|c| type_info(&c).map(|t| t.size).unwrap_or(1))
+        .unwrap_or(1)
+}
+
+/// Creates array type for (element_type, length)
+/// Uses _array_type_cache to ensure identical calls return the same type object
+pub(super) fn array_type_from_ctype(
+    itemtype: PyObjectRef,
+    length: usize,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // PyCArrayType_from_ctype
+
+    // Get the _array_type_cache from _ctypes module
+    let ctypes_module = vm.import("_ctypes", 0)?;
+    let cache = ctypes_module.get_attr("_array_type_cache", vm)?;
+
+    // Create cache key: (itemtype, length) tuple
+    let length_obj: PyObjectRef = vm.ctx.new_int(length).into();
+    let cache_key = vm.ctx.new_tuple(vec![itemtype.clone(), length_obj]);
+
+    // Check if already in cache
+    if let Ok(cached) = vm.call_method(&cache, "__getitem__", (cache_key.clone(),))
+        && !vm.is_none(&cached)
+    {
+        return Ok(cached);
+    }
+
+    // Cache miss - create new array type
+    let itemtype_ref = itemtype
+        .clone()
+        .downcast::<PyType>()
+        .map_err(|_| vm.new_type_error("Expected a type object"))?;
+
+    let item_stg = itemtype_ref
+        .stg_info_opt()
+        .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+
+    let element_size = item_stg.size;
+    let element_align = item_stg.align;
+    let item_format = item_stg.format.clone();
+    let item_shape = item_stg.shape.clone();
+    let item_flags = item_stg.flags;
+
+    // Check overflow before multiplication
+    let total_size = element_size
+        .checked_mul(length)
+        .ok_or_else(|| vm.new_overflow_error("array too large"))?;
+
+    // format name: "c_int_Array_5"
+    let type_name = format!("{}_Array_{}", itemtype_ref.name(), length);
+
+    // Get item type code before moving itemtype
+    let item_type_code = itemtype_ref
+        .as_object()
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+    let stg_info = StgInfo::new_array(
+        total_size,
+        element_align,
+        length,
+        itemtype_ref.clone(),
+        element_size,
+        item_format.as_deref(),
+        &item_shape,
+        item_flags,
+    );
+
+    let new_type = create_array_type_with_name(stg_info, &type_name, vm)?;
+
+    // Special case for character arrays - add value/raw attributes
+    let new_type_ref: PyTypeRef = new_type
+        .clone()
+        .downcast()
+        .map_err(|_| vm.new_type_error("expected type"))?;
+
+    match item_type_code.as_deref() {
+        Some("c") => add_char_array_getsets(&new_type_ref, vm),
+        Some("u") => add_wchar_array_getsets(&new_type_ref, vm),
+        _ => {}
+    }
+
+    // Store in cache
+    vm.call_method(&cache, "__setitem__", (cache_key, new_type.clone()))?;
+
+    Ok(new_type)
+}
+
+/// create_array_type_with_name - create array type with specified name
+fn create_array_type_with_name(
+    stg_info: StgInfo,
+    type_name: &str,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let metaclass = PyCArrayType::static_type().to_owned();
+    let name = vm.ctx.new_str(type_name);
+    let bases = vm
+        .ctx
+        .new_tuple(vec![PyCArray::static_type().to_owned().into()]);
+    let dict = vm.ctx.new_dict();
+
+    let args = FuncArgs::new(
+        vec![name.into(), bases.into(), dict.into()],
+        crate::function::KwArgs::default(),
+    );
+
+    let new_type = crate::builtins::type_::PyType::slot_new(metaclass, args, vm)?;
+
+    let type_ref: PyTypeRef = new_type
+        .clone()
+        .downcast()
+        .map_err(|_| vm.new_type_error("Failed to create array type"))?;
+
+    // Set class attributes for _type_ and _length_
+    if let Some(element_type) = stg_info.element_type.clone() {
+        new_type.set_attr("_type_", element_type, vm)?;
+    }
+    new_type.set_attr("_length_", vm.ctx.new_int(stg_info.length), vm)?;
+
+    super::base::set_or_init_stginfo(&type_ref, stg_info);
+
+    Ok(new_type)
+}
+
+/// PyCArrayType - metatype for Array types
+#[pyclass(name = "PyCArrayType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCArrayType(PyType);
+
+// PyCArrayType implements Initializer for slots.init (PyCArrayType_init)
+impl Initializer for PyCArrayType {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // zelf is the newly created array type (e.g., T in "class T(Array)")
+        let new_type: &PyType = &zelf.0;
+
+        new_type.check_not_initialized(vm)?;
+
+        // 1. Get _length_ from class dict first
+        let direct_length = new_type
+            .attributes
+            .read()
+            .get(vm.ctx.intern_str("_length_"))
+            .cloned();
+
+        // 2. Get _type_ from class dict first
+        let direct_type = new_type
+            .attributes
+            .read()
+            .get(vm.ctx.intern_str("_type_"))
+            .cloned();
+
+        // 3. Find parent StgInfo from MRO (for inheritance)
+        // Note: PyType.mro does NOT include self, so no skip needed
+        let parent_stg_info = new_type
+            .mro
+            .read()
+            .iter()
+            .find_map(|base| base.stg_info_opt().map(|s| s.clone()));
+
+        // 4. Resolve _length_ (direct or inherited)
+        let length = if let Some(length_attr) = direct_length {
+            // Direct _length_ defined - validate it (PyLong_Check)
+            let length_int = length_attr
+                .downcast_ref::<PyInt>()
+                .ok_or_else(|| vm.new_type_error("The '_length_' attribute must be an integer"))?;
+            let bigint = length_int.as_bigint();
+            // Check sign first - negative values are ValueError
+            if bigint.is_negative() {
+                return Err(vm.new_value_error("The '_length_' attribute must not be negative"));
+            }
+            // Positive values that don't fit in usize are OverflowError
+            bigint
+                .to_usize()
+                .ok_or_else(|| vm.new_overflow_error("The '_length_' attribute is too large"))?
+        } else if let Some(ref parent_info) = parent_stg_info {
+            // Inherit from parent
+            parent_info.length
+        } else {
+            return Err(vm.new_attribute_error("class must define a '_length_' attribute"));
+        };
+
+        // 5. Resolve _type_ and get item_info (direct or inherited)
+        let (element_type, item_size, item_align, item_format, item_shape, item_flags) =
+            if let Some(type_attr) = direct_type {
+                // Direct _type_ defined - validate it (PyStgInfo_FromType)
+                let type_ref = type_attr
+                    .clone()
+                    .downcast::<PyType>()
+                    .map_err(|_| vm.new_type_error("_type_ must be a type"))?;
+                let (size, align, format, shape, flags) = {
+                    let item_info = type_ref
+                        .stg_info_opt()
+                        .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+                    (
+                        item_info.size,
+                        item_info.align,
+                        item_info.format.clone(),
+                        item_info.shape.clone(),
+                        item_info.flags,
+                    )
+                };
+                (type_ref, size, align, format, shape, flags)
+            } else if let Some(ref parent_info) = parent_stg_info {
+                // Inherit from parent
+                let parent_type = parent_info
+                    .element_type
+                    .clone()
+                    .ok_or_else(|| vm.new_type_error("_type_ must have storage info"))?;
+                (
+                    parent_type,
+                    parent_info.element_size,
+                    parent_info.align,
+                    parent_info.format.clone(),
+                    parent_info.shape.clone(),
+                    parent_info.flags,
+                )
+            } else {
+                return Err(vm.new_attribute_error("class must define a '_type_' attribute"));
+            };
+
+        // 6. Check overflow (item_size != 0 && length > MAX / item_size)
+        if item_size != 0 && length > usize::MAX / item_size {
+            return Err(vm.new_overflow_error("array too large"));
+        }
+
+        // 7. Initialize StgInfo (PyStgInfo_Init + field assignment)
+        let stg_info = StgInfo::new_array(
+            item_size * length, // size = item_size * length
+            item_align,         // align = item_info->align
+            length,             // length
+            element_type.clone(),
+            item_size, // element_size
+            item_format.as_deref(),
+            &item_shape,
+            item_flags,
+        );
+
+        // 8. Store StgInfo in type_data
+        super::base::set_or_init_stginfo(new_type, stg_info);
+
+        // 9. Get type code before moving element_type
+        let item_type_code = element_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        // 10. Set class attributes for _type_ and _length_
+        zelf.as_object().set_attr("_type_", element_type, vm)?;
+        zelf.as_object()
+            .set_attr("_length_", vm.ctx.new_int(length), vm)?;
+
+        // 11. Special case for character arrays - add value/raw attributes
+        // if (iteminfo->getfunc == _ctypes_get_fielddesc("c")->getfunc)
+        //              add_getset((PyTypeObject*)self, CharArray_getsets);
+        //          else if (iteminfo->getfunc == _ctypes_get_fielddesc("u")->getfunc)
+        //              add_getset((PyTypeObject*)self, WCharArray_getsets);
+
+        // Get type ref for add_getset
+        let type_ref: PyTypeRef = zelf.as_object().to_owned().downcast().unwrap();
+        match item_type_code.as_deref() {
+            Some("c") => add_char_array_getsets(&type_ref, vm),
+            Some("u") => add_wchar_array_getsets(&type_ref, vm),
+            _ => {}
+        }
+
+        Ok(())
+    }
+}
+
+#[pyclass(flags(IMMUTABLETYPE), with(Initializer, AsNumber))]
+impl PyCArrayType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the array type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Check for CArgObject (PyCArg_CheckExact)
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>() {
+            // Check if the wrapped object is an instance of the requested type
+            if carg.obj.is_instance(cls.as_object(), vm)? {
+                return Ok(value); // Return the CArgObject as-is
+            }
+        }
+
+        // 3. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCArrayType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+}
+
+impl AsNumber for PyCArrayType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            multiply: Some(|a, b, vm| {
+                // a is a type object whose metaclass is PyCArrayType (e.g., Array_5)
+                let n = b
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_isize()
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+
+                if n < 0 {
+                    return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+                }
+
+                // Check for overflow before creating the new array type
+                let zelf_type = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("Expected type"))?;
+
+                if let Some(stg_info) = zelf_type.stg_info_opt() {
+                    let current_size = stg_info.size;
+                    // Check if current_size * n would overflow
+                    if current_size != 0 && (n as usize) > isize::MAX as usize / current_size {
+                        return Err(vm.new_overflow_error("array too large"));
+                    }
+                }
+
+                // Use cached array type creation
+                // The element type of the new array is the current array type itself
+                array_type_from_ctype(a.to_owned(), n as usize, vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+/// PyCArray - Array instance
+/// All array metadata (element_type, length, element_size) is stored in the type's StgInfo
+#[pyclass(
+    name = "Array",
+    base = PyCData,
+    metaclass = "PyCArrayType",
+    module = "_ctypes"
+)]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PyCArray(pub PyCData);
+
+impl PyCArray {
+    /// Get the type code of array element type (e.g., "c" for c_char, "u" for c_wchar)
+    fn get_element_type_code(zelf: &Py<Self>, vm: &VirtualMachine) -> Option<String> {
+        zelf.class()
+            .stg_info_opt()
+            .and_then(|info| info.element_type.clone())?
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()))
+    }
+}
+
+impl Constructor for PyCArray {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Check for abstract class - StgInfo must exist and be initialized
+        // Extract values in a block to drop the borrow before using cls
+        let (length, total_size) = {
+            let stg = cls.stg_info(vm)?;
+            (stg.length, stg.size)
+        };
+
+        // Check for too many initializers
+        if args.args.len() > length {
+            return Err(vm.new_index_error("too many initializers"));
+        }
+
+        // Create array with zero-initialized buffer
+        let buffer = vec![0u8; total_size];
+        let instance = PyCArray(PyCData::from_bytes_with_length(buffer, None, length))
+            .into_ref_with_type(vm, cls)?;
+
+        // Initialize elements using setitem_by_index (Array_init pattern)
+        for (i, value) in args.args.iter().enumerate() {
+            PyCArray::setitem_by_index(&instance, i as isize, value.clone(), vm)?;
+        }
+
+        Ok(instance.into())
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyCArray {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Re-initialize array elements when __init__ is called
+        for (i, value) in args.args.iter().enumerate() {
+            PyCArray::setitem_by_index(&zelf, i as isize, value.clone(), vm)?;
+        }
+        Ok(())
+    }
+}
+
+impl AsSequence for PyCArray {
+    fn as_sequence() -> &'static PySequenceMethods {
+        use std::sync::LazyLock;
+        static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
+            length: atomic_func!(|seq, _vm| {
+                let zelf = PyCArray::sequence_downcast(seq);
+                Ok(zelf.class().stg_info_opt().map_or(0, |i| i.length))
+            }),
+            item: atomic_func!(|seq, i, vm| {
+                let zelf = PyCArray::sequence_downcast(seq);
+                PyCArray::getitem_by_index(zelf, i, vm)
+            }),
+            ass_item: atomic_func!(|seq, i, value, vm| {
+                let zelf = PyCArray::sequence_downcast(seq);
+                match value {
+                    Some(v) => PyCArray::setitem_by_index(zelf, i, v, vm),
+                    None => Err(vm.new_type_error("cannot delete array elements")),
+                }
+            }),
+            ..PySequenceMethods::NOT_IMPLEMENTED
+        });
+        &AS_SEQUENCE
+    }
+}
+
+impl AsMapping for PyCArray {
+    fn as_mapping() -> &'static PyMappingMethods {
+        use std::sync::LazyLock;
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            length: atomic_func!(|mapping, _vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                Ok(zelf.class().stg_info_opt().map_or(0, |i| i.length))
+            }),
+            subscript: atomic_func!(|mapping, needle, vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                PyCArray::__getitem__(zelf, needle.to_owned(), vm)
+            }),
+            ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                let zelf = PyCArray::mapping_downcast(mapping);
+                match value {
+                    Some(value) => PyCArray::__setitem__(zelf, needle.to_owned(), value, vm),
+                    None => PyCArray::__delitem__(zelf, needle.to_owned(), vm),
+                }
+            }),
+        });
+        &AS_MAPPING
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsSequence, AsMapping, AsBuffer)
+)]
+impl PyCArray {
+    #[pyclassmethod]
+    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::from_args(cls, args, vm)
+    }
+
+    fn int_to_bytes(i: &malachite_bigint::BigInt, size: usize) -> Vec<u8> {
+        // Try unsigned first (handles values like 0xFFFFFFFF that overflow signed)
+        // then fall back to signed (handles negative values)
+        match size {
+            1 => {
+                if let Some(v) = i.to_u8() {
+                    vec![v]
+                } else {
+                    vec![i.to_i8().unwrap_or(0) as u8]
+                }
+            }
+            2 => {
+                if let Some(v) = i.to_u16() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i16().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
+            4 => {
+                if let Some(v) = i.to_u32() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i32().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
+            8 => {
+                if let Some(v) = i.to_u64() {
+                    v.to_ne_bytes().to_vec()
+                } else {
+                    i.to_i64().unwrap_or(0).to_ne_bytes().to_vec()
+                }
+            }
+            _ => vec![0u8; size],
+        }
+    }
+
+    fn bytes_to_int(
+        bytes: &[u8],
+        size: usize,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyObjectRef {
+        // Unsigned type codes: B (uchar), H (ushort), I (uint), L (ulong), Q (ulonglong)
+        let is_unsigned = matches!(
+            type_code,
+            Some("B") | Some("H") | Some("I") | Some("L") | Some("Q")
+        );
+
+        match (size, is_unsigned) {
+            (1, false) => vm.ctx.new_int(bytes[0] as i8).into(),
+            (1, true) => vm.ctx.new_int(bytes[0]).into(),
+            (2, false) => {
+                let val = i16::from_ne_bytes([bytes[0], bytes[1]]);
+                vm.ctx.new_int(val).into()
+            }
+            (2, true) => {
+                let val = u16::from_ne_bytes([bytes[0], bytes[1]]);
+                vm.ctx.new_int(val).into()
+            }
+            (4, false) => {
+                let val = i32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
+                vm.ctx.new_int(val).into()
+            }
+            (4, true) => {
+                let val = u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]);
+                vm.ctx.new_int(val).into()
+            }
+            (8, false) => {
+                let val = i64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ]);
+                vm.ctx.new_int(val).into()
+            }
+            (8, true) => {
+                let val = u64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ]);
+                vm.ctx.new_int(val).into()
+            }
+            _ => vm.ctx.new_int(0).into(),
+        }
+    }
+
+    fn getitem_by_index(zelf: &Py<PyCArray>, i: isize, vm: &VirtualMachine) -> PyResult {
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length) as isize;
+        let index = if i < 0 { length + i } else { i };
+        if index < 0 || index >= length {
+            return Err(vm.new_index_error("invalid index"));
+        }
+        let index = index as usize;
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
+        let offset = index * element_size;
+        let type_code = Self::get_element_type_code(zelf, vm);
+
+        // Get target buffer and offset (base's buffer if available, otherwise own)
+        let base_obj = zelf.0.base.read().clone();
+        let (buffer_lock, final_offset) = if let Some(cdata) = base_obj
+            .as_ref()
+            .and_then(|b| b.downcast_ref::<super::PyCData>())
+        {
+            (&cdata.buffer, zelf.0.base_offset.load() + offset)
+        } else {
+            (&zelf.0.buffer, offset)
+        };
+
+        let buffer = buffer_lock.read();
+        Self::read_element_from_buffer(
+            &buffer,
+            final_offset,
+            element_size,
+            type_code.as_deref(),
+            vm,
+        )
+    }
+
+    /// Helper to read an element value from a buffer at given offset
+    fn read_element_from_buffer(
+        buffer: &[u8],
+        offset: usize,
+        element_size: usize,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        match type_code {
+            Some("c") => {
+                // Return single byte as bytes
+                if offset < buffer.len() {
+                    Ok(vm.ctx.new_bytes(vec![buffer[offset]]).into())
+                } else {
+                    Ok(vm.ctx.new_bytes(vec![0]).into())
+                }
+            }
+            Some("u") => {
+                // Return single wchar as str
+                if let Some(code) = wchar_from_bytes(&buffer[offset..]) {
+                    let s = char::from_u32(code)
+                        .map(|c| c.to_string())
+                        .unwrap_or_default();
+                    Ok(vm.ctx.new_str(s).into())
+                } else {
+                    Ok(vm.ctx.new_str("").into())
+                }
+            }
+            Some("z") => {
+                // c_char_p: pointer to bytes - dereference to get string
+                if offset + element_size > buffer.len() {
+                    return Ok(vm.ctx.none());
+                }
+                let ptr_bytes = &buffer[offset..offset + element_size];
+                let ptr_val = usize::from_ne_bytes(
+                    ptr_bytes
+                        .try_into()
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
+                );
+                if ptr_val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                // Read null-terminated string from pointer address
+                unsafe {
+                    let ptr = ptr_val as *const u8;
+                    let mut len = 0;
+                    while *ptr.add(len) != 0 {
+                        len += 1;
+                    }
+                    let bytes = core::slice::from_raw_parts(ptr, len);
+                    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+                }
+            }
+            Some("Z") => {
+                // c_wchar_p: pointer to wchar_t - dereference to get string
+                if offset + element_size > buffer.len() {
+                    return Ok(vm.ctx.none());
+                }
+                let ptr_bytes = &buffer[offset..offset + element_size];
+                let ptr_val = usize::from_ne_bytes(
+                    ptr_bytes
+                        .try_into()
+                        .unwrap_or([0; core::mem::size_of::<usize>()]),
+                );
+                if ptr_val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                // Read null-terminated wide string using WCHAR_SIZE
+                unsafe {
+                    let ptr = ptr_val as *const u8;
+                    let mut chars = Vec::new();
+                    let mut pos = 0usize;
+                    loop {
+                        let code = if WCHAR_SIZE == 2 {
+                            let bytes = core::slice::from_raw_parts(ptr.add(pos), 2);
+                            u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+                        } else {
+                            let bytes = core::slice::from_raw_parts(ptr.add(pos), 4);
+                            u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+                        };
+                        if code == 0 {
+                            break;
+                        }
+                        if let Some(ch) = char::from_u32(code) {
+                            chars.push(ch);
+                        }
+                        pos += WCHAR_SIZE;
+                    }
+                    let s: String = chars.into_iter().collect();
+                    Ok(vm.ctx.new_str(s).into())
+                }
+            }
+            Some("f") => {
+                // c_float
+                if offset + 4 <= buffer.len() {
+                    let bytes: [u8; 4] = buffer[offset..offset + 4].try_into().unwrap();
+                    let val = f32::from_ne_bytes(bytes);
+                    Ok(vm.ctx.new_float(val as f64).into())
+                } else {
+                    Ok(vm.ctx.new_float(0.0).into())
+                }
+            }
+            Some("d") | Some("g") => {
+                // c_double / c_longdouble - read f64 from first 8 bytes
+                if offset + 8 <= buffer.len() {
+                    let bytes: [u8; 8] = buffer[offset..offset + 8].try_into().unwrap();
+                    let val = f64::from_ne_bytes(bytes);
+                    Ok(vm.ctx.new_float(val).into())
+                } else {
+                    Ok(vm.ctx.new_float(0.0).into())
+                }
+            }
+            _ => {
+                if offset + element_size <= buffer.len() {
+                    let bytes = &buffer[offset..offset + element_size];
+                    Ok(Self::bytes_to_int(bytes, element_size, type_code, vm))
+                } else {
+                    Ok(vm.ctx.new_int(0).into())
+                }
+            }
+        }
+    }
+
+    /// Helper to write an element value to a buffer at given offset
+    /// This is extracted to share code between direct write and base-buffer write
+    #[allow(clippy::too_many_arguments)]
+    fn write_element_to_buffer(
+        buffer: &mut [u8],
+        offset: usize,
+        element_size: usize,
+        type_code: Option<&str>,
+        value: &PyObject,
+        zelf: &Py<PyCArray>,
+        index: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        match type_code {
+            Some("c") => {
+                if let Some(b) = value.downcast_ref::<PyBytes>() {
+                    if offset < buffer.len() {
+                        buffer[offset] = b.as_bytes().first().copied().unwrap_or(0);
+                    }
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    if offset < buffer.len() {
+                        buffer[offset] = int_val.as_bigint().to_u8().unwrap_or(0);
+                    }
+                } else {
+                    return Err(vm.new_type_error("an integer or bytes of length 1 is required"));
+                }
+            }
+            Some("u") => {
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let code = s.as_str().chars().next().map(|c| c as u32).unwrap_or(0);
+                    if offset + WCHAR_SIZE <= buffer.len() {
+                        wchar_to_bytes(code, &mut buffer[offset..]);
+                    }
+                } else {
+                    return Err(vm.new_type_error("unicode string expected"));
+                }
+            }
+            Some("z") => {
+                let (ptr_val, converted) = if value.is(&vm.ctx.none) {
+                    (0usize, None)
+                } else if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (c, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    (ptr, Some(c))
+                } else if let Ok(int_val) = value.try_index(vm) {
+                    (int_val.as_bigint().to_usize().unwrap_or(0), None)
+                } else {
+                    return Err(vm.new_type_error(
+                        "bytes or integer address expected instead of {}".to_owned(),
+                    ));
+                };
+                if offset + element_size <= buffer.len() {
+                    buffer[offset..offset + element_size].copy_from_slice(&ptr_val.to_ne_bytes());
+                }
+                if let Some(c) = converted {
+                    return zelf.0.keep_ref(index, c, vm);
+                }
+            }
+            Some("Z") => {
+                let (ptr_val, converted) = if value.is(&vm.ctx.none) {
+                    (0usize, None)
+                } else if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    (ptr, Some(holder))
+                } else if let Ok(int_val) = value.try_index(vm) {
+                    (int_val.as_bigint().to_usize().unwrap_or(0), None)
+                } else {
+                    return Err(vm.new_type_error("unicode string or integer address expected"));
+                };
+                if offset + element_size <= buffer.len() {
+                    buffer[offset..offset + element_size].copy_from_slice(&ptr_val.to_ne_bytes());
+                }
+                if let Some(c) = converted {
+                    return zelf.0.keep_ref(index, c, vm);
+                }
+            }
+            Some("f") => {
+                // c_float: convert int/float to f32 bytes
+                let f32_val = if let Ok(float_val) = value.try_float(vm) {
+                    float_val.to_f64() as f32
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_f64().unwrap_or(0.0) as f32
+                } else {
+                    return Err(vm.new_type_error("a float is required"));
+                };
+                if offset + 4 <= buffer.len() {
+                    buffer[offset..offset + 4].copy_from_slice(&f32_val.to_ne_bytes());
+                }
+            }
+            Some("d") | Some("g") => {
+                // c_double / c_longdouble: convert int/float to f64 bytes
+                let f64_val = if let Ok(float_val) = value.try_float(vm) {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_f64().unwrap_or(0.0)
+                } else {
+                    return Err(vm.new_type_error("a float is required"));
+                };
+                if offset + 8 <= buffer.len() {
+                    buffer[offset..offset + 8].copy_from_slice(&f64_val.to_ne_bytes());
+                }
+                // For "g" type, remaining bytes stay zero
+            }
+            _ => {
+                // Handle ctypes instances (copy their buffer)
+                if let Some(cdata) = value.downcast_ref::<PyCData>() {
+                    let src_buffer = cdata.buffer.read();
+                    let copy_len = src_buffer.len().min(element_size);
+                    if offset + copy_len <= buffer.len() {
+                        buffer[offset..offset + copy_len].copy_from_slice(&src_buffer[..copy_len]);
+                    }
+                // Other types: use int_to_bytes
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    let bytes = Self::int_to_bytes(int_val.as_bigint(), element_size);
+                    if offset + element_size <= buffer.len() {
+                        buffer[offset..offset + element_size].copy_from_slice(&bytes);
+                    }
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "expected {} instance, not {}",
+                        type_code.unwrap_or("value"),
+                        value.class().name()
+                    )));
+                }
+            }
+        }
+
+        // KeepRef
+        if super::base::PyCData::should_keep_ref(value) {
+            let to_keep = super::base::PyCData::get_kept_objects(value, vm);
+            zelf.0.keep_ref(index, to_keep, vm)?;
+        }
+
+        Ok(())
+    }
+
+    fn setitem_by_index(
+        zelf: &Py<PyCArray>,
+        i: isize,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length) as isize;
+        let index = if i < 0 { length + i } else { i };
+        if index < 0 || index >= length {
+            return Err(vm.new_index_error("invalid index"));
+        }
+        let index = index as usize;
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
+        let offset = index * element_size;
+        let type_code = Self::get_element_type_code(zelf, vm);
+
+        // Get target buffer and offset (base's buffer if available, otherwise own)
+        let base_obj = zelf.0.base.read().clone();
+        let (buffer_lock, final_offset) = if let Some(cdata) = base_obj
+            .as_ref()
+            .and_then(|b| b.downcast_ref::<super::PyCData>())
+        {
+            (&cdata.buffer, zelf.0.base_offset.load() + offset)
+        } else {
+            (&zelf.0.buffer, offset)
+        };
+
+        let mut buffer = buffer_lock.write();
+
+        // For shared memory (Cow::Borrowed), we need to write directly to the memory
+        // For owned memory (Cow::Owned), we can write to the owned buffer
+        match &mut *buffer {
+            Cow::Borrowed(slice) => {
+                // SAFETY: For from_buffer, the slice points to writable shared memory.
+                // Python's from_buffer requires writable buffer, so this is safe.
+                let ptr = slice.as_ptr() as *mut u8;
+                let len = slice.len();
+                let owned_slice = unsafe { core::slice::from_raw_parts_mut(ptr, len) };
+                Self::write_element_to_buffer(
+                    owned_slice,
+                    final_offset,
+                    element_size,
+                    type_code.as_deref(),
+                    &value,
+                    zelf,
+                    index,
+                    vm,
+                )
+            }
+            Cow::Owned(vec) => Self::write_element_to_buffer(
+                vec,
+                final_offset,
+                element_size,
+                type_code.as_deref(),
+                &value,
+                zelf,
+                index,
+                vm,
+            ),
+        }
+    }
+
+    // Array_subscript
+    fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            // getitem_by_index handles negative index normalization
+            Self::getitem_by_index(zelf, i, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::getitem_by_slice(zelf, slice, vm)
+        } else {
+            Err(vm.new_type_error("indices must be integers"))
+        }
+    }
+
+    // Array_subscript slice handling
+    fn getitem_by_slice(zelf: &Py<Self>, slice: &PySlice, vm: &VirtualMachine) -> PyResult {
+        use crate::sliceable::SaturatedSliceIter;
+
+        let stg = zelf.class().stg_info_opt();
+        let length = stg.as_ref().map_or(0, |i| i.length);
+
+        // PySlice_Unpack + PySlice_AdjustIndices
+        let sat_slice = slice.to_saturated(vm)?;
+        let (range, step, slice_len) = sat_slice.adjust_indices(length);
+
+        let type_code = Self::get_element_type_code(zelf, vm);
+        let element_size = stg.as_ref().map_or(0, |i| i.element_size);
+        let start = range.start;
+
+        match type_code.as_deref() {
+            // c_char → bytes (item_info->getfunc == "c")
+            Some("c") => {
+                if slice_len == 0 {
+                    return Ok(vm.ctx.new_bytes(vec![]).into());
+                }
+                let buffer = zelf.0.buffer.read();
+                // step == 1 optimization: direct memcpy
+                if step == 1 {
+                    let start_offset = start * element_size;
+                    let end_offset = start_offset + slice_len;
+                    if end_offset <= buffer.len() {
+                        return Ok(vm
+                            .ctx
+                            .new_bytes(buffer[start_offset..end_offset].to_vec())
+                            .into());
+                    }
+                }
+                // Non-contiguous: iterate
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = Vec::with_capacity(slice_len);
+                for idx in iter {
+                    let offset = idx * element_size;
+                    if offset < buffer.len() {
+                        result.push(buffer[offset]);
+                    }
+                }
+                Ok(vm.ctx.new_bytes(result).into())
+            }
+            // c_wchar → str (item_info->getfunc == "u")
+            Some("u") => {
+                if slice_len == 0 {
+                    return Ok(vm.ctx.new_str("").into());
+                }
+                let buffer = zelf.0.buffer.read();
+                // step == 1 optimization: direct conversion
+                if step == 1 {
+                    let start_offset = start * WCHAR_SIZE;
+                    let end_offset = start_offset + slice_len * WCHAR_SIZE;
+                    if end_offset <= buffer.len() {
+                        let wchar_bytes = &buffer[start_offset..end_offset];
+                        let result: String = wchar_bytes
+                            .chunks(WCHAR_SIZE)
+                            .filter_map(|chunk| wchar_from_bytes(chunk).and_then(char::from_u32))
+                            .collect();
+                        return Ok(vm.ctx.new_str(result).into());
+                    }
+                }
+                // Non-contiguous: iterate
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = String::with_capacity(slice_len);
+                for idx in iter {
+                    let offset = idx * WCHAR_SIZE;
+                    if let Some(code_point) = wchar_from_bytes(&buffer[offset..])
+                        && let Some(c) = char::from_u32(code_point)
+                    {
+                        result.push(c);
+                    }
+                }
+                Ok(vm.ctx.new_str(result).into())
+            }
+            // Other types → list (PyList_New + Array_item for each)
+            _ => {
+                let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+                let mut result = Vec::with_capacity(slice_len);
+                for idx in iter {
+                    result.push(Self::getitem_by_index(zelf, idx as isize, vm)?);
+                }
+                Ok(PyList::from(result).into_ref(&vm.ctx).into())
+            }
+        }
+    }
+
+    // Array_ass_subscript
+    fn __setitem__(
+        zelf: &Py<Self>,
+        item: PyObjectRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Array does not support item deletion
+        // (handled implicitly - value is always provided in __setitem__)
+
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            // setitem_by_index handles negative index normalization
+            Self::setitem_by_index(zelf, i, value, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::setitem_by_slice(zelf, slice, value, vm)
+        } else {
+            Err(vm.new_type_error("indices must be integer"))
+        }
+    }
+
+    // Array does not support item deletion
+    fn __delitem__(&self, _item: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        Err(vm.new_type_error("Array does not support item deletion"))
+    }
+
+    // Array_ass_subscript slice handling
+    fn setitem_by_slice(
+        zelf: &Py<Self>,
+        slice: &PySlice,
+        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
+        let sat_slice = slice.to_saturated(vm)?;
+        let (range, step, slice_len) = sat_slice.adjust_indices(length);
+
+        // other_len = PySequence_Length(value);
+        let items: Vec<PyObjectRef> = vm.extract_elements_with(&value, Ok)?;
+        let other_len = items.len();
+
+        if other_len != slice_len {
+            return Err(vm.new_value_error("Can only assign sequence of same size"));
+        }
+
+        // Use SaturatedSliceIter for correct index iteration (handles negative step)
+        let iter = SaturatedSliceIter::from_adjust_indices(range, step, slice_len);
+
+        for (idx, item) in iter.zip(items) {
+            Self::setitem_by_index(zelf, idx as isize, item, vm)?;
+        }
+        Ok(())
+    }
+
+    fn __len__(zelf: &Py<Self>, _vm: &VirtualMachine) -> usize {
+        zelf.class().stg_info_opt().map_or(0, |i| i.length)
+    }
+}
+
+impl AsBuffer for PyCArray {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // Get format and shape from type's StgInfo
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCArray type must have StgInfo");
+        let format = stg_info.format.clone();
+        let shape = stg_info.shape.clone();
+
+        let desc = if let Some(fmt) = format
+            && !shape.is_empty()
+        {
+            // itemsize is the size of the base element type (item_info->size)
+            // For empty arrays, we still need the element size, not 0
+            let total_elements: usize = shape.iter().product();
+            let has_zero_dim = shape.contains(&0);
+            let itemsize = if total_elements > 0 && buffer_len > 0 {
+                buffer_len / total_elements
+            } else {
+                // For empty arrays, get itemsize from format type code
+                get_size_from_format(&fmt)
+            };
+
+            // Build dim_desc from shape (C-contiguous: row-major order)
+            // stride[i] = product(shape[i+1:]) * itemsize
+            // For empty arrays (any dimension is 0), all strides are 0
+            let mut dim_desc = Vec::with_capacity(shape.len());
+            let mut stride = itemsize as isize;
+
+            for &dim_size in shape.iter().rev() {
+                let current_stride = if has_zero_dim { 0 } else { stride };
+                dim_desc.push((dim_size, current_stride, 0));
+                stride *= dim_size as isize;
+            }
+            dim_desc.reverse();
+
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize,
+                format: alloc::borrow::Cow::Owned(fmt),
+                dim_desc,
+            }
+        } else {
+            // Fallback to simple buffer if no format/shape info
+            BufferDescriptor::simple(buffer_len, false)
+        };
+
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
+
+// CharArray and WCharArray getsets - added dynamically via add_getset
+
+// CharArray_get_value
+fn char_array_get_value(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    let len = buffer.iter().position(|&b| b == 0).unwrap_or(buffer.len());
+    Ok(vm.ctx.new_bytes(buffer[..len].to_vec()).into())
+}
+
+// CharArray_set_value
+fn char_array_set_value(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let bytes = value
+        .downcast_ref::<PyBytes>()
+        .ok_or_else(|| vm.new_type_error("bytes expected"))?;
+    let mut buffer = zelf.0.buffer.write();
+    let src = bytes.as_bytes();
+
+    if src.len() > buffer.len() {
+        return Err(vm.new_value_error("byte string too long"));
+    }
+
+    buffer.to_mut()[..src.len()].copy_from_slice(src);
+    if src.len() < buffer.len() {
+        buffer.to_mut()[src.len()] = 0;
+    }
+    Ok(())
+}
+
+// CharArray_get_raw
+fn char_array_get_raw(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    Ok(vm.ctx.new_bytes(buffer.to_vec()).into())
+}
+
+// CharArray_set_raw
+fn char_array_set_raw(
+    obj: PyObjectRef,
+    value: PySetterValue<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let value = value.ok_or_else(|| vm.new_attribute_error("cannot delete attribute"))?;
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let bytes_like = ArgBytesLike::try_from_object(vm, value)?;
+    let mut buffer = zelf.0.buffer.write();
+    let src = bytes_like.borrow_buf();
+    if src.len() > buffer.len() {
+        return Err(vm.new_value_error("byte string too long"));
+    }
+    buffer.to_mut()[..src.len()].copy_from_slice(&src);
+    Ok(())
+}
+
+// WCharArray_get_value
+fn wchar_array_get_value(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let buffer = zelf.0.buffer.read();
+    Ok(vm.ctx.new_str(wstring_from_bytes(&buffer)).into())
+}
+
+// WCharArray_set_value
+fn wchar_array_set_value(
+    obj: PyObjectRef,
+    value: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let zelf = obj.downcast_ref::<PyCArray>().unwrap();
+    let s = value
+        .downcast_ref::<PyStr>()
+        .ok_or_else(|| vm.new_type_error("unicode string expected"))?;
+    let mut buffer = zelf.0.buffer.write();
+    let wchar_count = buffer.len() / WCHAR_SIZE;
+    let char_count = s.as_str().chars().count();
+
+    if char_count > wchar_count {
+        return Err(vm.new_value_error("string too long"));
+    }
+
+    for (i, ch) in s.as_str().chars().enumerate() {
+        let offset = i * WCHAR_SIZE;
+        wchar_to_bytes(ch as u32, &mut buffer.to_mut()[offset..]);
+    }
+
+    let terminator_offset = char_count * WCHAR_SIZE;
+    if terminator_offset + WCHAR_SIZE <= buffer.len() {
+        wchar_to_bytes(0, &mut buffer.to_mut()[terminator_offset..]);
+    }
+    Ok(())
+}
+
+/// add_getset for c_char arrays - adds 'value' and 'raw' attributes
+/// add_getset((PyTypeObject*)self, CharArray_getsets)
+fn add_char_array_getsets(array_type: &Py<PyType>, vm: &VirtualMachine) {
+    // SAFETY: getset is owned by array_type which outlives the getset
+    let value_getset = unsafe {
+        vm.ctx.new_getset(
+            "value",
+            array_type,
+            char_array_get_value,
+            char_array_set_value,
+        )
+    };
+    let raw_getset = unsafe {
+        vm.ctx
+            .new_getset("raw", array_type, char_array_get_raw, char_array_set_raw)
+    };
+
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("value"), value_getset.into());
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("raw"), raw_getset.into());
+}
+
+/// add_getset for c_wchar arrays - adds only 'value' attribute (no 'raw')
+fn add_wchar_array_getsets(array_type: &Py<PyType>, vm: &VirtualMachine) {
+    // SAFETY: getset is owned by array_type which outlives the getset
+    let value_getset = unsafe {
+        vm.ctx.new_getset(
+            "value",
+            array_type,
+            wchar_array_get_value,
+            wchar_array_set_value,
+        )
+    };
+
+    array_type
+        .attributes
+        .write()
+        .insert(vm.ctx.intern_str("value"), value_getset.into());
+}
+
+// wchar_t helpers - Platform-independent wide character handling
+// Windows: sizeof(wchar_t) == 2 (UTF-16)
+// Linux/macOS: sizeof(wchar_t) == 4 (UTF-32)
+
+/// Size of wchar_t on this platform
+pub(super) const WCHAR_SIZE: usize = core::mem::size_of::<libc::wchar_t>();
+
+/// Read a single wchar_t from bytes (platform-endian)
+#[inline]
+pub(super) fn wchar_from_bytes(bytes: &[u8]) -> Option<u32> {
+    if bytes.len() < WCHAR_SIZE {
+        return None;
+    }
+    Some(if WCHAR_SIZE == 2 {
+        u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+    } else {
+        u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+    })
+}
+
+/// Write a single wchar_t to bytes (platform-endian)
+#[inline]
+pub(super) fn wchar_to_bytes(ch: u32, buffer: &mut [u8]) {
+    if WCHAR_SIZE == 2 {
+        if buffer.len() >= 2 {
+            buffer[..2].copy_from_slice(&(ch as u16).to_ne_bytes());
+        }
+    } else if buffer.len() >= 4 {
+        buffer[..4].copy_from_slice(&ch.to_ne_bytes());
+    }
+}
+
+/// Read a null-terminated wchar_t string from bytes, returns String
+fn wstring_from_bytes(buffer: &[u8]) -> String {
+    let mut chars = Vec::new();
+    for chunk in buffer.chunks(WCHAR_SIZE) {
+        if chunk.len() < WCHAR_SIZE {
+            break;
+        }
+        let code = if WCHAR_SIZE == 2 {
+            u16::from_ne_bytes([chunk[0], chunk[1]]) as u32
+        } else {
+            u32::from_ne_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])
+        };
+        if code == 0 {
+            break; // null terminator
+        }
+        if let Some(ch) = char::from_u32(code) {
+            chars.push(ch);
+        }
+    }
+    chars.into_iter().collect()
+}
diff --git a/crates/vm/src/stdlib/ctypes/base.rs b/crates/vm/src/stdlib/ctypes/base.rs
new file mode 100644
index 0000000000..58d9466adb
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/base.rs
@@ -0,0 +1,2360 @@
+use super::array::{WCHAR_SIZE, wchar_from_bytes, wchar_to_bytes};
+use crate::builtins::{PyBytes, PyDict, PyMemoryView, PyStr, PyType, PyTypeRef};
+use crate::class::StaticType;
+use crate::function::{ArgBytesLike, OptionalArg, PySetterValue};
+use crate::protocol::{BufferMethods, PyBuffer};
+use crate::types::{GetDescriptor, Representable};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
+};
+use alloc::borrow::Cow;
+use core::ffi::{
+    c_double, c_float, c_int, c_long, c_longlong, c_short, c_uint, c_ulong, c_ulonglong, c_ushort,
+};
+use core::fmt::Debug;
+use core::mem;
+use crossbeam_utils::atomic::AtomicCell;
+use num_traits::{Signed, ToPrimitive};
+use rustpython_common::lock::PyRwLock;
+use widestring::WideChar;
+
+// StgInfo - Storage information for ctypes types
+// Stored in TypeDataSlot of heap types (PyType::init_type_data/get_type_data)
+
+// Flag constants
+bitflags::bitflags! {
+    #[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct StgInfoFlags: u32 {
+        // Function calling convention flags
+        /// Standard call convention (Windows)
+        const FUNCFLAG_STDCALL = 0x0;
+        /// C calling convention
+        const FUNCFLAG_CDECL = 0x1;
+        /// Function returns HRESULT
+        const FUNCFLAG_HRESULT = 0x2;
+        /// Use Python API calling convention
+        const FUNCFLAG_PYTHONAPI = 0x4;
+        /// Capture errno after call
+        const FUNCFLAG_USE_ERRNO = 0x8;
+        /// Capture last error after call (Windows)
+        const FUNCFLAG_USE_LASTERROR = 0x10;
+
+        // Type flags
+        /// Type is a pointer type
+        const TYPEFLAG_ISPOINTER = 0x100;
+        /// Type contains pointer fields
+        const TYPEFLAG_HASPOINTER = 0x200;
+        /// Type is or contains a union
+        const TYPEFLAG_HASUNION = 0x400;
+        /// Type contains bitfield members
+        const TYPEFLAG_HASBITFIELD = 0x800;
+
+        // Dict flags
+        /// Type is finalized (_fields_ has been set)
+        const DICTFLAG_FINAL = 0x1000;
+    }
+}
+
+/// ParamFunc - determines how a type is passed to foreign functions
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub(super) enum ParamFunc {
+    #[default]
+    None,
+    /// Array types are passed as pointers (tag = 'P')
+    Array,
+    /// Simple types use their specific conversion (tag = type code)
+    Simple,
+    /// Pointer types (tag = 'P')
+    Pointer,
+    /// Structure types (tag = 'V' for value)
+    Structure,
+    /// Union types (tag = 'V' for value)
+    Union,
+}
+
+#[derive(Clone)]
+pub struct StgInfo {
+    pub initialized: bool,
+    pub size: usize,              // number of bytes
+    pub align: usize,             // alignment requirements
+    pub length: usize,            // number of fields (for arrays/structures)
+    pub proto: Option<PyTypeRef>, // Only for Pointer/ArrayObject
+    pub flags: StgInfoFlags,      // type flags (TYPEFLAG_*, DICTFLAG_*)
+
+    // Array-specific fields
+    pub element_type: Option<PyTypeRef>, // _type_ for arrays
+    pub element_size: usize,             // size of each element
+
+    // PEP 3118 buffer protocol fields
+    pub format: Option<String>, // struct format string (e.g., "i", "(5)i")
+    pub shape: Vec<usize>,      // shape for multi-dimensional arrays
+
+    // Function parameter conversion
+    pub(super) paramfunc: ParamFunc, // how to pass to foreign functions
+
+    // Byte order (for _swappedbytes_)
+    pub big_endian: bool, // true if big endian, false if little endian
+
+    // FFI field types for structure/union passing (inherited from base class)
+    pub ffi_field_types: Vec<libffi::middle::Type>,
+}
+
+// StgInfo is stored in type_data which requires Send + Sync.
+// The PyTypeRef in proto/element_type fields is protected by the type system's locking mechanism.
+// ctypes objects are not thread-safe by design; users must synchronize access.
+unsafe impl Send for StgInfo {}
+unsafe impl Sync for StgInfo {}
+
+impl core::fmt::Debug for StgInfo {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("StgInfo")
+            .field("initialized", &self.initialized)
+            .field("size", &self.size)
+            .field("align", &self.align)
+            .field("length", &self.length)
+            .field("proto", &self.proto)
+            .field("flags", &self.flags)
+            .field("element_type", &self.element_type)
+            .field("element_size", &self.element_size)
+            .field("format", &self.format)
+            .field("shape", &self.shape)
+            .field("paramfunc", &self.paramfunc)
+            .field("big_endian", &self.big_endian)
+            .field("ffi_field_types", &self.ffi_field_types.len())
+            .finish()
+    }
+}
+
+impl Default for StgInfo {
+    fn default() -> Self {
+        StgInfo {
+            initialized: false,
+            size: 0,
+            align: 1,
+            length: 0,
+            proto: None,
+            flags: StgInfoFlags::empty(),
+            element_type: None,
+            element_size: 0,
+            format: None,
+            shape: Vec::new(),
+            paramfunc: ParamFunc::None,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
+        }
+    }
+}
+
+impl StgInfo {
+    pub fn new(size: usize, align: usize) -> Self {
+        StgInfo {
+            initialized: true,
+            size,
+            align,
+            length: 0,
+            proto: None,
+            flags: StgInfoFlags::empty(),
+            element_type: None,
+            element_size: 0,
+            format: None,
+            shape: Vec::new(),
+            paramfunc: ParamFunc::None,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
+        }
+    }
+
+    /// Create StgInfo for an array type
+    /// item_format: the innermost element's format string (kept as-is, e.g., "<i")
+    /// item_shape: the element's shape (will be prepended with length)
+    /// item_flags: the element type's flags (for HASPOINTER inheritance)
+    #[allow(clippy::too_many_arguments)]
+    pub fn new_array(
+        size: usize,
+        align: usize,
+        length: usize,
+        element_type: PyTypeRef,
+        element_size: usize,
+        item_format: Option<&str>,
+        item_shape: &[usize],
+        item_flags: StgInfoFlags,
+    ) -> Self {
+        // Format is kept from innermost element (e.g., "<i" for c_int arrays)
+        // The array dimensions go into shape only, not format
+        let format = item_format.map(|f| f.to_owned());
+
+        // Build shape: [length, ...item_shape]
+        let mut shape = vec![length];
+        shape.extend_from_slice(item_shape);
+
+        // Inherit HASPOINTER flag from element type
+        // if (iteminfo->flags & (TYPEFLAG_ISPOINTER | TYPEFLAG_HASPOINTER))
+        //     stginfo->flags |= TYPEFLAG_HASPOINTER;
+        let flags = if item_flags
+            .intersects(StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER)
+        {
+            StgInfoFlags::TYPEFLAG_HASPOINTER
+        } else {
+            StgInfoFlags::empty()
+        };
+
+        StgInfo {
+            initialized: true,
+            size,
+            align,
+            length,
+            proto: None,
+            flags,
+            element_type: Some(element_type),
+            element_size,
+            format,
+            shape,
+            paramfunc: ParamFunc::Array,
+            big_endian: cfg!(target_endian = "big"), // native endian by default
+            ffi_field_types: Vec::new(),
+        }
+    }
+
+    /// Get libffi type for this StgInfo
+    /// Note: For very large types, returns pointer type to avoid overflow
+    pub fn to_ffi_type(&self) -> libffi::middle::Type {
+        // Limit to avoid overflow in libffi (MAX_STRUCT_SIZE is platform-dependent)
+        const MAX_FFI_STRUCT_SIZE: usize = 1024 * 1024; // 1MB limit for safety
+
+        match self.paramfunc {
+            ParamFunc::Structure | ParamFunc::Union => {
+                if !self.ffi_field_types.is_empty() {
+                    libffi::middle::Type::structure(self.ffi_field_types.iter().cloned())
+                } else if self.size <= MAX_FFI_STRUCT_SIZE {
+                    // Small struct without field types: use bytes array
+                    libffi::middle::Type::structure(core::iter::repeat_n(
+                        libffi::middle::Type::u8(),
+                        self.size,
+                    ))
+                } else {
+                    // Large struct: treat as pointer (passed by reference)
+                    libffi::middle::Type::pointer()
+                }
+            }
+            ParamFunc::Array => {
+                if self.size > MAX_FFI_STRUCT_SIZE || self.length > MAX_FFI_STRUCT_SIZE {
+                    // Large array: treat as pointer
+                    libffi::middle::Type::pointer()
+                } else if let Some(ref fmt) = self.format {
+                    let elem_type = Self::format_to_ffi_type(fmt);
+                    libffi::middle::Type::structure(core::iter::repeat_n(elem_type, self.length))
+                } else {
+                    libffi::middle::Type::structure(core::iter::repeat_n(
+                        libffi::middle::Type::u8(),
+                        self.size,
+                    ))
+                }
+            }
+            ParamFunc::Pointer => libffi::middle::Type::pointer(),
+            _ => {
+                // Simple type: derive from format
+                if let Some(ref fmt) = self.format {
+                    Self::format_to_ffi_type(fmt)
+                } else {
+                    libffi::middle::Type::u8()
+                }
+            }
+        }
+    }
+
+    /// Convert format string to libffi type
+    fn format_to_ffi_type(fmt: &str) -> libffi::middle::Type {
+        // Strip endian prefix if present
+        let code = fmt.trim_start_matches(['<', '>', '!', '@', '=']);
+        match code {
+            "b" => libffi::middle::Type::i8(),
+            "B" => libffi::middle::Type::u8(),
+            "h" => libffi::middle::Type::i16(),
+            "H" => libffi::middle::Type::u16(),
+            "i" | "l" => libffi::middle::Type::i32(),
+            "I" | "L" => libffi::middle::Type::u32(),
+            "q" => libffi::middle::Type::i64(),
+            "Q" => libffi::middle::Type::u64(),
+            "f" => libffi::middle::Type::f32(),
+            "d" => libffi::middle::Type::f64(),
+            "P" | "z" | "Z" | "O" => libffi::middle::Type::pointer(),
+            _ => libffi::middle::Type::u8(), // default
+        }
+    }
+
+    /// Check if this type is finalized (cannot set _fields_ again)
+    pub fn is_final(&self) -> bool {
+        self.flags.contains(StgInfoFlags::DICTFLAG_FINAL)
+    }
+
+    /// Get proto type reference (for Pointer/Array types)
+    pub fn proto(&self) -> &Py<PyType> {
+        self.proto.as_deref().expect("type has proto")
+    }
+}
+
+/// Get PEP3118 format string for a field type
+/// Returns the format string considering byte order
+pub(super) fn get_field_format(
+    field_type: &PyObject,
+    big_endian: bool,
+    vm: &VirtualMachine,
+) -> String {
+    let endian_prefix = if big_endian { ">" } else { "<" };
+
+    // 1. Check StgInfo for format
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+        && let Some(fmt) = &stg_info.format
+    {
+        // For structures (T{...}), arrays ((n)...), and pointers (&...), return as-is
+        // These complex types have their own endianness markers inside
+        if fmt.starts_with('T')
+            || fmt.starts_with('(')
+            || fmt.starts_with('&')
+            || fmt.starts_with("X{")
+        {
+            return fmt.clone();
+        }
+
+        // For simple types, replace existing endian prefix with the correct one
+        let base_fmt = fmt.trim_start_matches(['<', '>', '@', '=', '!']);
+        if !base_fmt.is_empty() {
+            return format!("{}{}", endian_prefix, base_fmt);
+        }
+        return fmt.clone();
+    }
+
+    // 2. Try to get _type_ attribute for simple types
+    if let Ok(type_attr) = field_type.get_attr("_type_", vm)
+        && let Some(type_str) = type_attr.downcast_ref::<PyStr>()
+    {
+        let s = type_str.as_str();
+        if !s.is_empty() {
+            return format!("{}{}", endian_prefix, s);
+        }
+        return s.to_string();
+    }
+
+    // Default: single byte
+    "B".to_string()
+}
+
+/// Compute byte order based on swapped flag
+#[inline]
+pub(super) fn is_big_endian(is_swapped: bool) -> bool {
+    if is_swapped {
+        !cfg!(target_endian = "big")
+    } else {
+        cfg!(target_endian = "big")
+    }
+}
+
+/// Shared BufferMethods for all ctypes types (PyCArray, PyCSimple, PyCStructure, PyCUnion)
+/// All these types are #[repr(transparent)] wrappers around PyCData
+pub(super) static CDATA_BUFFER_METHODS: BufferMethods = BufferMethods {
+    obj_bytes: |buffer| {
+        rustpython_common::lock::PyRwLockReadGuard::map(
+            buffer.obj_as::<PyCData>().buffer.read(),
+            |x| &**x,
+        )
+        .into()
+    },
+    obj_bytes_mut: |buffer| {
+        rustpython_common::lock::PyRwLockWriteGuard::map(
+            buffer.obj_as::<PyCData>().buffer.write(),
+            |x| x.to_mut().as_mut_slice(),
+        )
+        .into()
+    },
+    release: |_| {},
+    retain: |_| {},
+};
+
+/// Convert Vec<T> to Vec<u8> by reinterpreting the memory (same allocation).
+fn vec_to_bytes<T>(vec: Vec<T>) -> Vec<u8> {
+    let len = vec.len() * core::mem::size_of::<T>();
+    let cap = vec.capacity() * core::mem::size_of::<T>();
+    let ptr = vec.as_ptr() as *mut u8;
+    core::mem::forget(vec);
+    unsafe { Vec::from_raw_parts(ptr, len, cap) }
+}
+
+/// Ensure PyBytes is null-terminated. Returns (PyBytes to keep, pointer).
+/// If already contains null, returns original. Otherwise creates new with null appended.
+pub(super) fn ensure_z_null_terminated(
+    bytes: &PyBytes,
+    vm: &VirtualMachine,
+) -> (PyObjectRef, usize) {
+    let data = bytes.as_bytes();
+    if data.contains(&0) {
+        // Already has null, use original
+        let original: PyObjectRef = vm.ctx.new_bytes(data.to_vec()).into();
+        (original, data.as_ptr() as usize)
+    } else {
+        // Create new with null appended
+        let mut buffer = data.to_vec();
+        buffer.push(0);
+        let ptr = buffer.as_ptr() as usize;
+        let new_bytes: PyObjectRef = vm.ctx.new_bytes(buffer).into();
+        (new_bytes, ptr)
+    }
+}
+
+/// Convert str to null-terminated wchar_t buffer. Returns (PyBytes holder, pointer).
+pub(super) fn str_to_wchar_bytes(s: &str, vm: &VirtualMachine) -> (PyObjectRef, usize) {
+    let wchars: Vec<libc::wchar_t> = s
+        .chars()
+        .map(|c| c as libc::wchar_t)
+        .chain(core::iter::once(0))
+        .collect();
+    let ptr = wchars.as_ptr() as usize;
+    let bytes = vec_to_bytes(wchars);
+    let holder: PyObjectRef = vm.ctx.new_bytes(bytes).into();
+    (holder, ptr)
+}
+
+/// PyCData - base type for all ctypes data types
+#[pyclass(name = "_CData", module = "_ctypes")]
+#[derive(Debug, PyPayload)]
+pub struct PyCData {
+    /// Memory buffer - Owned (self-owned) or Borrowed (external reference)
+    ///
+    /// SAFETY: Borrowed variant's 'static lifetime is not actually static.
+    /// When created via from_address or from_base_obj, only valid for the lifetime of the source memory.
+    /// Same behavior as CPython's b_ptr (user responsibility, kept alive via b_base).
+    pub buffer: PyRwLock<Cow<'static, [u8]>>,
+    /// pointer to base object or None (b_base)
+    pub base: PyRwLock<Option<PyObjectRef>>,
+    /// byte offset within base's buffer (for field access)
+    pub base_offset: AtomicCell<usize>,
+    /// index into base's b_objects list (b_index)
+    pub index: AtomicCell<usize>,
+    /// dictionary of references we need to keep (b_objects)
+    pub objects: PyRwLock<Option<PyObjectRef>>,
+    /// number of references we need (b_length)
+    pub length: AtomicCell<usize>,
+}
+
+impl PyCData {
+    /// Create from StgInfo (PyCData_MallocBuffer pattern)
+    pub fn from_stg_info(stg_info: &StgInfo) -> Self {
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(vec![0u8; stg_info.size])),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(stg_info.length),
+        }
+    }
+
+    /// Create from existing bytes (copies data)
+    pub fn from_bytes(data: Vec<u8>, objects: Option<PyObjectRef>) -> Self {
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(objects),
+            length: AtomicCell::new(0),
+        }
+    }
+
+    /// Create from bytes with specified length (for arrays)
+    pub fn from_bytes_with_length(
+        data: Vec<u8>,
+        objects: Option<PyObjectRef>,
+        length: usize,
+    ) -> Self {
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(objects),
+            length: AtomicCell::new(length),
+        }
+    }
+
+    /// Create from external memory address
+    ///
+    /// # Safety
+    /// The returned slice's 'static lifetime is a lie.
+    /// Actually only valid for the lifetime of the memory pointed to by ptr.
+    /// PyCData_AtAddress
+    pub unsafe fn at_address(ptr: *const u8, size: usize) -> Self {
+        // = PyCData_AtAddress
+        // SAFETY: Caller must ensure ptr is valid for the lifetime of returned PyCData
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(0),
+        }
+    }
+
+    /// Create from base object with offset and data copy
+    ///
+    /// Similar to from_base_with_offset, but also stores a copy of the data.
+    /// This is used for arrays where we need our own buffer for the buffer protocol,
+    /// but still maintain the base reference for KeepRef and tracking.
+    pub fn from_base_with_data(
+        base_obj: PyObjectRef,
+        offset: usize,
+        idx: usize,
+        length: usize,
+        data: Vec<u8>,
+    ) -> Self {
+        PyCData {
+            buffer: PyRwLock::new(Cow::Owned(data)), // Has its own buffer copy
+            base: PyRwLock::new(Some(base_obj)),     // But still tracks base
+            base_offset: AtomicCell::new(offset),    // And offset for writes
+            index: AtomicCell::new(idx),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(length),
+        }
+    }
+
+    /// Create from base object's buffer
+    ///
+    /// This creates a borrowed view into the base's buffer at the given address.
+    /// The base object is stored in b_base to keep the memory alive.
+    ///
+    /// # Safety
+    /// ptr must point into base_obj's buffer and remain valid as long as base_obj is alive.
+    pub unsafe fn from_base_obj(
+        ptr: *mut u8,
+        size: usize,
+        base_obj: PyObjectRef,
+        idx: usize,
+    ) -> Self {
+        // = PyCData_FromBaseObj
+        // SAFETY: ptr points into base_obj's buffer, kept alive via base reference
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(Some(base_obj)),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(idx),
+            objects: PyRwLock::new(None),
+            length: AtomicCell::new(0),
+        }
+    }
+
+    /// Create from buffer protocol object (for from_buffer method)
+    ///
+    /// Unlike from_bytes, this shares memory with the source buffer.
+    /// The source object is stored in objects dict to keep the buffer alive.
+    /// Python stores with key -1 via KeepRef(result, -1, mv).
+    ///
+    /// # Safety
+    /// ptr must point to valid memory that remains valid as long as source is alive.
+    pub unsafe fn from_buffer_shared(
+        ptr: *const u8,
+        size: usize,
+        length: usize,
+        source: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> Self {
+        // SAFETY: Caller must ensure ptr is valid for the lifetime of source
+        let slice: &'static [u8] = unsafe { core::slice::from_raw_parts(ptr, size) };
+
+        // Python stores the reference in a dict with key "-1" (unique_key pattern)
+        let objects_dict = vm.ctx.new_dict();
+        objects_dict
+            .set_item("-1", source, vm)
+            .expect("Failed to store buffer reference");
+
+        PyCData {
+            buffer: PyRwLock::new(Cow::Borrowed(slice)),
+            base: PyRwLock::new(None),
+            base_offset: AtomicCell::new(0),
+            index: AtomicCell::new(0),
+            objects: PyRwLock::new(Some(objects_dict.into())),
+            length: AtomicCell::new(length),
+        }
+    }
+
+    /// Common implementation for from_buffer class method.
+    /// Validates buffer, creates memoryview, and returns PyCData sharing memory with source.
+    ///
+    /// CDataType_from_buffer_impl
+    pub fn from_buffer_impl(
+        cls: &Py<PyType>,
+        source: PyObjectRef,
+        offset: isize,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let (size, length) = {
+            let stg_info = cls
+                .stg_info_opt()
+                .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+            (stg_info.size, stg_info.length)
+        };
+
+        if offset < 0 {
+            return Err(vm.new_value_error("offset cannot be negative"));
+        }
+        let offset = offset as usize;
+
+        // Get buffer from source (this exports the buffer)
+        let buffer = PyBuffer::try_from_object(vm, source)?;
+
+        // Check if buffer is writable
+        if buffer.desc.readonly {
+            return Err(vm.new_type_error("underlying buffer is not writable"));
+        }
+
+        // Check if buffer is C contiguous
+        if !buffer.desc.is_contiguous() {
+            return Err(vm.new_type_error("underlying buffer is not C contiguous"));
+        }
+
+        // Check if buffer is large enough
+        let buffer_len = buffer.desc.len;
+        if offset + size > buffer_len {
+            return Err(vm.new_value_error(format!(
+                "Buffer size too small ({} instead of at least {} bytes)",
+                buffer_len,
+                offset + size
+            )));
+        }
+
+        // Get buffer pointer - the memory is owned by source
+        let ptr = {
+            let bytes = buffer.obj_bytes();
+            bytes.as_ptr().wrapping_add(offset)
+        };
+
+        // Create memoryview to keep buffer exported (prevents source from being modified)
+        // mv = PyMemoryView_FromObject(obj); KeepRef(result, -1, mv);
+        let memoryview = PyMemoryView::from_buffer(buffer, vm)?;
+        let mv_obj = memoryview.into_pyobject(vm);
+
+        // Create CData that shares memory with the buffer
+        Ok(unsafe { Self::from_buffer_shared(ptr, size, length, mv_obj, vm) })
+    }
+
+    /// Common implementation for from_buffer_copy class method.
+    /// Copies data from buffer and creates new independent instance.
+    ///
+    /// CDataType_from_buffer_copy_impl
+    pub fn from_buffer_copy_impl(
+        cls: &Py<PyType>,
+        source: &[u8],
+        offset: isize,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let (size, length) = {
+            let stg_info = cls
+                .stg_info_opt()
+                .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+            (stg_info.size, stg_info.length)
+        };
+
+        if offset < 0 {
+            return Err(vm.new_value_error("offset cannot be negative"));
+        }
+        let offset = offset as usize;
+
+        // Check if buffer is large enough
+        if offset + size > source.len() {
+            return Err(vm.new_value_error(format!(
+                "Buffer size too small ({} instead of at least {} bytes)",
+                source.len(),
+                offset + size
+            )));
+        }
+
+        // Copy bytes from buffer at offset
+        let data = source[offset..offset + size].to_vec();
+
+        Ok(Self::from_bytes_with_length(data, None, length))
+    }
+
+    #[inline]
+    pub fn size(&self) -> usize {
+        self.buffer.read().len()
+    }
+
+    /// Check if this buffer is borrowed (external memory reference)
+    #[inline]
+    pub fn is_borrowed(&self) -> bool {
+        matches!(&*self.buffer.read(), Cow::Borrowed(_))
+    }
+
+    /// Write bytes at offset - handles both borrowed and owned buffers
+    ///
+    /// For borrowed buffers (from from_address), writes directly to external memory.
+    /// For owned buffers, writes through to_mut() as normal.
+    ///
+    /// # Safety
+    /// For borrowed buffers, caller must ensure the memory is writable.
+    pub fn write_bytes_at_offset(&self, offset: usize, bytes: &[u8]) {
+        let buffer = self.buffer.read();
+        if offset + bytes.len() > buffer.len() {
+            return; // Out of bounds
+        }
+
+        match &*buffer {
+            Cow::Borrowed(slice) => {
+                // For borrowed memory, write directly
+                // SAFETY: We assume the caller knows this memory is writable
+                // (e.g., from from_address pointing to a ctypes buffer)
+                unsafe {
+                    let ptr = slice.as_ptr() as *mut u8;
+                    core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr.add(offset), bytes.len());
+                }
+            }
+            Cow::Owned(_) => {
+                // For owned memory, use to_mut() through write lock
+                drop(buffer);
+                let mut buffer = self.buffer.write();
+                buffer.to_mut()[offset..offset + bytes.len()].copy_from_slice(bytes);
+            }
+        }
+    }
+
+    /// Generate unique key for nested references (unique_key)
+    /// Creates a hierarchical key by walking up the b_base chain.
+    /// Format: "index:parent_index:grandparent_index:..."
+    pub fn unique_key(&self, index: usize) -> String {
+        let mut key = format!("{index:x}");
+        // Walk up the base chain to build hierarchical key
+        if self.base.read().is_some() {
+            let parent_index = self.index.load();
+            key.push_str(&format!(":{parent_index:x}"));
+        }
+        key
+    }
+
+    /// Keep a reference in the objects dictionary (KeepRef)
+    ///
+    /// Stores 'keep' in this object's b_objects dict at key 'index'.
+    /// If keep is None, does nothing (optimization).
+    /// This function stores the value directly - caller should use get_kept_objects()
+    /// first if they want to store the _objects of a CData instead of the object itself.
+    ///
+    /// If this object has a base (is embedded in another structure/union/array),
+    /// the reference is stored in the root object's b_objects with a hierarchical key.
+    pub fn keep_ref(&self, index: usize, keep: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Optimization: no need to store None
+        if vm.is_none(&keep) {
+            return Ok(());
+        }
+
+        // Build hierarchical key
+        let key = self.unique_key(index);
+
+        // If we have a base object, find root and store there
+        if let Some(base_obj) = self.base.read().clone() {
+            // Find root by walking up the base chain
+            let root_obj = Self::find_root_object(&base_obj);
+            Self::store_in_object(&root_obj, &key, keep, vm)?;
+            return Ok(());
+        }
+
+        // No base - store in own objects dict
+        let mut objects = self.objects.write();
+
+        // Initialize b_objects if needed
+        if objects.is_none() {
+            if self.length.load() > 0 {
+                // Need to store multiple references - create a dict
+                *objects = Some(vm.ctx.new_dict().into());
+            } else {
+                // Only one reference needed - store directly
+                *objects = Some(keep);
+                return Ok(());
+            }
+        }
+
+        // If b_objects is not a dict, convert it to a dict first
+        // This preserves the existing reference (e.g., from cast) when adding new references
+        if let Some(obj) = objects.as_ref()
+            && obj.downcast_ref::<PyDict>().is_none()
+        {
+            // Convert existing single reference to a dict
+            let dict = vm.ctx.new_dict();
+            // Store the original object with a special key (id-based)
+            let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+            dict.set_item(&*id_key, obj.clone(), vm)?;
+            *objects = Some(dict.into());
+        }
+
+        // Store in dict with unique key
+        if let Some(dict_obj) = objects.as_ref()
+            && let Some(dict) = dict_obj.downcast_ref::<PyDict>()
+        {
+            let key_obj: PyObjectRef = vm.ctx.new_str(key).into();
+            dict.set_item(&*key_obj, keep, vm)?;
+        }
+
+        Ok(())
+    }
+
+    /// Find the root object (one without a base) by walking up the base chain
+    fn find_root_object(obj: &PyObject) -> PyObjectRef {
+        // Try to get base from different ctypes types
+        let base = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            cdata.base.read().clone()
+        } else {
+            None
+        };
+
+        // Recurse if there's a base, otherwise this is the root
+        if let Some(base_obj) = base {
+            Self::find_root_object(&base_obj)
+        } else {
+            obj.to_owned()
+        }
+    }
+
+    /// Store a value in an object's _objects dict with the given key
+    fn store_in_object(
+        obj: &PyObject,
+        key: &str,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Get the objects dict from the object
+        let objects_lock = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+            &cdata.objects
+        } else {
+            return Ok(()); // Unknown type, skip
+        };
+
+        let mut objects = objects_lock.write();
+
+        // Initialize if needed
+        if objects.is_none() {
+            *objects = Some(vm.ctx.new_dict().into());
+        }
+
+        // If not a dict, convert to dict
+        if let Some(obj) = objects.as_ref()
+            && obj.downcast_ref::<PyDict>().is_none()
+        {
+            let dict = vm.ctx.new_dict();
+            let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+            dict.set_item(&*id_key, obj.clone(), vm)?;
+            *objects = Some(dict.into());
+        }
+
+        // Store in dict
+        if let Some(dict_obj) = objects.as_ref()
+            && let Some(dict) = dict_obj.downcast_ref::<PyDict>()
+        {
+            let key_obj: PyObjectRef = vm.ctx.new_str(key).into();
+            dict.set_item(&*key_obj, value, vm)?;
+        }
+
+        Ok(())
+    }
+
+    /// Get kept objects from a CData instance
+    /// Returns the _objects of the CData, or an empty dict if None.
+    pub fn get_kept_objects(value: &PyObject, vm: &VirtualMachine) -> PyObjectRef {
+        value
+            .downcast_ref::<PyCData>()
+            .and_then(|cdata| cdata.objects.read().clone())
+            .unwrap_or_else(|| vm.ctx.new_dict().into())
+    }
+
+    /// Check if a value should be stored in _objects
+    /// Returns true for ctypes objects and bytes (for c_char_p)
+    pub fn should_keep_ref(value: &PyObject) -> bool {
+        value.downcast_ref::<PyCData>().is_some() || value.downcast_ref::<PyBytes>().is_some()
+    }
+
+    /// PyCData_set
+    /// Sets a field value at the given offset, handling type conversion and KeepRef
+    #[allow(clippy::too_many_arguments)]
+    pub fn set_field(
+        &self,
+        proto: &PyObject,
+        value: PyObjectRef,
+        index: usize,
+        size: usize,
+        offset: usize,
+        needs_swap: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if this is a c_char or c_wchar array field
+        let is_char_array = PyCField::is_char_array(proto, vm);
+        let is_wchar_array = PyCField::is_wchar_array(proto, vm);
+
+        // For c_char arrays with bytes input, copy only up to first null
+        if is_char_array {
+            if let Some(bytes_val) = value.downcast_ref::<PyBytes>() {
+                let src = bytes_val.as_bytes();
+                let to_copy = PyCField::bytes_for_char_array(src);
+                let copy_len = core::cmp::min(to_copy.len(), size);
+                self.write_bytes_at_offset(offset, &to_copy[..copy_len]);
+                self.keep_ref(index, value, vm)?;
+                return Ok(());
+            } else {
+                return Err(vm.new_type_error("bytes expected instead of str instance"));
+            }
+        }
+
+        // For c_wchar arrays with str input, convert to wchar_t
+        if is_wchar_array {
+            if let Some(str_val) = value.downcast_ref::<PyStr>() {
+                // Convert str to wchar_t bytes (platform-dependent size)
+                let mut wchar_bytes = Vec::with_capacity(size);
+                for ch in str_val.as_str().chars().take(size / WCHAR_SIZE) {
+                    let mut bytes = [0u8; 4];
+                    wchar_to_bytes(ch as u32, &mut bytes);
+                    wchar_bytes.extend_from_slice(&bytes[..WCHAR_SIZE]);
+                }
+                // Pad with nulls to fill the array
+                while wchar_bytes.len() < size {
+                    wchar_bytes.push(0);
+                }
+                self.write_bytes_at_offset(offset, &wchar_bytes);
+                self.keep_ref(index, value, vm)?;
+                return Ok(());
+            } else if value.downcast_ref::<PyBytes>().is_some() {
+                return Err(vm.new_type_error("str expected instead of bytes instance"));
+            }
+        }
+
+        // Special handling for Pointer fields with Array values
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && proto_type
+                .class()
+                .fast_issubclass(super::pointer::PyCPointerType::static_type())
+            && let Some(array) = value.downcast_ref::<super::array::PyCArray>()
+        {
+            let buffer_addr = {
+                let array_buffer = array.0.buffer.read();
+                array_buffer.as_ptr() as usize
+            };
+            let addr_bytes = buffer_addr.to_ne_bytes();
+            let len = core::cmp::min(addr_bytes.len(), size);
+            self.write_bytes_at_offset(offset, &addr_bytes[..len]);
+            self.keep_ref(index, value, vm)?;
+            return Ok(());
+        }
+
+        // Get field type code for special handling
+        let field_type_code = proto
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|attr| attr.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        let (mut bytes, converted_value) = if let Some(type_code) = &field_type_code {
+            PyCField::value_to_bytes_for_type(type_code, &value, size, vm)?
+        } else {
+            (PyCField::value_to_bytes(&value, size, vm)?, None)
+        };
+
+        // Swap bytes for opposite endianness
+        if needs_swap {
+            bytes.reverse();
+        }
+
+        self.write_bytes_at_offset(offset, &bytes);
+
+        // KeepRef: for z/Z types use converted value, otherwise use original
+        if let Some(converted) = converted_value {
+            self.keep_ref(index, converted, vm)?;
+        } else if Self::should_keep_ref(&value) {
+            let to_keep = Self::get_kept_objects(&value, vm);
+            self.keep_ref(index, to_keep, vm)?;
+        }
+
+        Ok(())
+    }
+
+    /// PyCData_get
+    /// Gets a field value at the given offset
+    pub fn get_field(
+        &self,
+        proto: &PyObject,
+        index: usize,
+        size: usize,
+        offset: usize,
+        base_obj: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        // Get buffer data at offset
+        let buffer = self.buffer.read();
+        if offset + size > buffer.len() {
+            return Ok(vm.ctx.new_int(0).into());
+        }
+
+        // Check if field type is an array type
+        if let Some(type_ref) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = type_ref.stg_info_opt()
+            && stg.element_type.is_some()
+        {
+            // c_char array → return bytes
+            if PyCField::is_char_array(proto, vm) {
+                let data = &buffer[offset..offset + size];
+                // Find first null terminator (or use full length)
+                let end = data.iter().position(|&b| b == 0).unwrap_or(data.len());
+                return Ok(vm.ctx.new_bytes(data[..end].to_vec()).into());
+            }
+
+            // c_wchar array → return str
+            if PyCField::is_wchar_array(proto, vm) {
+                let data = &buffer[offset..offset + size];
+                // wchar_t → char conversion, skip null
+                let chars: String = data
+                    .chunks(WCHAR_SIZE)
+                    .filter_map(|chunk| {
+                        wchar_from_bytes(chunk)
+                            .filter(|&wchar| wchar != 0)
+                            .and_then(char::from_u32)
+                    })
+                    .collect();
+                return Ok(vm.ctx.new_str(chars).into());
+            }
+
+            // Other array types - create array with a copy of data from the base's buffer
+            // The array also keeps a reference to the base for keeping it alive and for writes
+            let array_data = buffer[offset..offset + size].to_vec();
+            drop(buffer);
+
+            let cdata_obj =
+                Self::from_base_with_data(base_obj, offset, index, stg.length, array_data);
+            let array_type: PyTypeRef = proto
+                .to_owned()
+                .downcast()
+                .map_err(|_| vm.new_type_error("expected array type"))?;
+
+            return super::array::PyCArray(cdata_obj)
+                .into_ref_with_type(vm, array_type)
+                .map(Into::into);
+        }
+
+        let buffer_data = buffer[offset..offset + size].to_vec();
+        drop(buffer);
+
+        // Get proto as type
+        let proto_type: PyTypeRef = proto
+            .to_owned()
+            .downcast()
+            .map_err(|_| vm.new_type_error("field proto is not a type"))?;
+
+        let proto_metaclass = proto_type.class();
+
+        // Simple types: return primitive value
+        if proto_metaclass.fast_issubclass(super::simple::PyCSimpleType::static_type()) {
+            // Check for byte swapping
+            let needs_swap = base_obj
+                .class()
+                .as_object()
+                .get_attr("_swappedbytes_", vm)
+                .is_ok()
+                || proto_type
+                    .as_object()
+                    .get_attr("_swappedbytes_", vm)
+                    .is_ok();
+
+            let data = if needs_swap && size > 1 {
+                let mut swapped = buffer_data.clone();
+                swapped.reverse();
+                swapped
+            } else {
+                buffer_data
+            };
+
+            return bytes_to_pyobject(&proto_type, &data, vm);
+        }
+
+        // Complex types: create ctypes instance via PyCData_FromBaseObj
+        let ptr = self.buffer.read().as_ptr().wrapping_add(offset) as *mut u8;
+        let cdata_obj = unsafe { Self::from_base_obj(ptr, size, base_obj.clone(), index) };
+
+        if proto_metaclass.fast_issubclass(super::structure::PyCStructType::static_type())
+            || proto_metaclass.fast_issubclass(super::union::PyCUnionType::static_type())
+            || proto_metaclass.fast_issubclass(super::pointer::PyCPointerType::static_type())
+        {
+            cdata_obj.into_ref_with_type(vm, proto_type).map(Into::into)
+        } else {
+            // Fallback
+            Ok(vm.ctx.new_int(0).into())
+        }
+    }
+}
+
+#[pyclass(flags(BASETYPE))]
+impl PyCData {
+    #[pygetset]
+    fn _objects(&self) -> Option<PyObjectRef> {
+        self.objects.read().clone()
+    }
+
+    #[pygetset]
+    fn _b_base_(&self) -> Option<PyObjectRef> {
+        self.base.read().clone()
+    }
+
+    #[pygetset]
+    fn _b_needsfree_(&self) -> i32 {
+        // Borrowed (from_address) or has base object → 0 (don't free)
+        // Owned and no base → 1 (need to free)
+        if self.is_borrowed() || self.base.read().is_some() {
+            0
+        } else {
+            1
+        }
+    }
+
+    // CDataType_methods - shared across all ctypes types
+
+    #[pyclassmethod]
+    fn from_buffer(
+        cls: PyTypeRef,
+        source: PyObjectRef,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cdata = Self::from_buffer_impl(&cls, source, offset.unwrap_or(0), vm)?;
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    #[pyclassmethod]
+    fn from_buffer_copy(
+        cls: PyTypeRef,
+        source: ArgBytesLike,
+        offset: OptionalArg<isize>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let cdata =
+            Self::from_buffer_copy_impl(&cls, &source.borrow_buf(), offset.unwrap_or(0), vm)?;
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    #[pyclassmethod]
+    fn from_address(cls: PyTypeRef, address: isize, vm: &VirtualMachine) -> PyResult {
+        let size = {
+            let stg_info = cls.stg_info(vm)?;
+            stg_info.size
+        };
+
+        if size == 0 {
+            return Err(vm.new_type_error("abstract class"));
+        }
+
+        // PyCData_AtAddress
+        let cdata = unsafe { Self::at_address(address as *const u8, size) };
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    #[pyclassmethod]
+    fn in_dll(
+        cls: PyTypeRef,
+        dll: PyObjectRef,
+        name: crate::builtins::PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let size = {
+            let stg_info = cls.stg_info(vm)?;
+            stg_info.size
+        };
+
+        if size == 0 {
+            return Err(vm.new_type_error("abstract class"));
+        }
+
+        // Get the library handle from dll object
+        let handle = if let Ok(int_handle) = dll.try_int(vm) {
+            int_handle
+                .as_bigint()
+                .to_usize()
+                .ok_or_else(|| vm.new_value_error("Invalid library handle"))?
+        } else {
+            dll.get_attr("_handle", vm)?
+                .try_int(vm)?
+                .as_bigint()
+                .to_usize()
+                .ok_or_else(|| vm.new_value_error("Invalid library handle"))?
+        };
+
+        // Look up the library in the cache and use lib.get() for symbol lookup
+        let library_cache = super::library::libcache().read();
+        let library = library_cache
+            .get_lib(handle)
+            .ok_or_else(|| vm.new_value_error("Library not found"))?;
+        let inner_lib = library.lib.lock();
+
+        let symbol_name_with_nul = format!("{}\0", name.as_str());
+        let ptr: *const u8 = if let Some(lib) = &*inner_lib {
+            unsafe {
+                lib.get::<*const u8>(symbol_name_with_nul.as_bytes())
+                    .map(|sym| *sym)
+                    .map_err(|_| {
+                        vm.new_value_error(format!("symbol '{}' not found", name.as_str()))
+                    })?
+            }
+        } else {
+            return Err(vm.new_value_error("Library closed"));
+        };
+
+        // 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())));
+        }
+
+        // PyCData_AtAddress
+        let cdata = unsafe { Self::at_address(ptr, size) };
+        cdata.into_ref_with_type(vm, cls).map(Into::into)
+    }
+}
+
+// PyCField - Field descriptor for Structure/Union types
+
+/// CField descriptor for Structure/Union field access
+#[pyclass(name = "CField", module = "_ctypes")]
+#[derive(Debug, PyPayload)]
+pub struct PyCField {
+    /// Byte offset of the field within the structure/union
+    pub(crate) offset: isize,
+    /// Encoded size: for bitfields (bit_size << 16) | bit_offset, otherwise byte size
+    pub(crate) size: isize,
+    /// Index into PyCData's object array
+    pub(crate) index: usize,
+    /// The ctypes type for this field
+    pub(crate) proto: PyTypeRef,
+    /// Flag indicating if the field is anonymous (MakeAnonFields sets this)
+    pub(crate) anonymous: bool,
+}
+
+#[inline(always)]
+const fn num_bits(size: isize) -> isize {
+    size >> 16
+}
+
+#[inline(always)]
+const fn field_size(size: isize) -> isize {
+    size & 0xFFFF
+}
+
+#[inline(always)]
+const fn is_bitfield(size: isize) -> bool {
+    (size >> 16) != 0
+}
+
+impl PyCField {
+    /// Create a new CField descriptor (non-bitfield)
+    pub fn new(proto: PyTypeRef, offset: isize, size: isize, index: usize) -> Self {
+        Self {
+            offset,
+            size,
+            index,
+            proto,
+            anonymous: false,
+        }
+    }
+
+    /// Create a new CField descriptor for a bitfield
+    #[allow(dead_code)]
+    pub fn new_bitfield(
+        proto: PyTypeRef,
+        offset: isize,
+        bit_size: u16,
+        bit_offset: u16,
+        index: usize,
+    ) -> Self {
+        let encoded_size = ((bit_size as isize) << 16) | (bit_offset as isize);
+        Self {
+            offset,
+            size: encoded_size,
+            index,
+            proto,
+            anonymous: false,
+        }
+    }
+
+    /// Get the actual byte size (for non-bitfields) or bit storage size (for bitfields)
+    pub fn byte_size(&self) -> usize {
+        field_size(self.size) as usize
+    }
+
+    /// Create a new CField from an existing field with adjusted offset and index
+    /// Used by MakeFields to promote anonymous fields
+    pub fn new_from_field(fdescr: &PyCField, index_offset: usize, offset_delta: isize) -> Self {
+        Self {
+            offset: fdescr.offset + offset_delta,
+            size: fdescr.size,
+            index: fdescr.index + index_offset,
+            proto: fdescr.proto.clone(),
+            anonymous: false, // promoted fields are not anonymous themselves
+        }
+    }
+
+    /// Set anonymous flag
+    pub fn set_anonymous(&mut self, anonymous: bool) {
+        self.anonymous = anonymous;
+    }
+}
+
+impl Representable for PyCField {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        // Get type name from proto (which is always PyTypeRef)
+        let tp_name = zelf.proto.name().to_string();
+
+        // Bitfield: <Field type=TYPE, ofs=OFFSET:BIT_OFFSET, bits=NUM_BITS>
+        // Regular:  <Field type=TYPE, ofs=OFFSET, size=SIZE>
+        if is_bitfield(zelf.size) {
+            let bit_offset = field_size(zelf.size);
+            let bits = num_bits(zelf.size);
+            Ok(format!(
+                "<Field type={}, ofs={}:{}, bits={}>",
+                tp_name, zelf.offset, bit_offset, bits
+            ))
+        } else {
+            Ok(format!(
+                "<Field type={}, ofs={}, size={}>",
+                tp_name, zelf.offset, zelf.size
+            ))
+        }
+    }
+}
+
+/// PyCField_get
+impl GetDescriptor for PyCField {
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        _cls: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let zelf = zelf
+            .downcast::<PyCField>()
+            .map_err(|_| vm.new_type_error("expected CField"))?;
+
+        // If obj is None, return the descriptor itself (class attribute access)
+        let obj = match obj {
+            Some(obj) if !vm.is_none(&obj) => obj,
+            _ => return Ok(zelf.into()),
+        };
+
+        let offset = zelf.offset as usize;
+        let size = zelf.byte_size();
+
+        // Get PyCData from obj (works for both Structure and Union)
+        let cdata = PyCField::get_cdata_from_obj(&obj, vm)?;
+
+        // PyCData_get
+        cdata.get_field(
+            zelf.proto.as_object(),
+            zelf.index,
+            size,
+            offset,
+            obj.clone(),
+            vm,
+        )
+    }
+}
+
+impl PyCField {
+    /// Convert a Python value to bytes
+    fn value_to_bytes(value: &PyObject, size: usize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        // 1. Handle bytes objects
+        if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+            let src = bytes.as_bytes();
+            let mut result = vec![0u8; size];
+            let len = core::cmp::min(src.len(), size);
+            result[..len].copy_from_slice(&src[..len]);
+            Ok(result)
+        }
+        // 2. Handle ctypes array instances (copy their buffer)
+        else if let Some(cdata) = value.downcast_ref::<super::PyCData>() {
+            let buffer = cdata.buffer.read();
+            let mut result = vec![0u8; size];
+            let len = core::cmp::min(buffer.len(), size);
+            result[..len].copy_from_slice(&buffer[..len]);
+            Ok(result)
+        }
+        // 4. Handle float values (check before int, since float.try_int would truncate)
+        else if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+            let f = float_val.to_f64();
+            match size {
+                4 => {
+                    let val = f as f32;
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                8 => Ok(f.to_ne_bytes().to_vec()),
+                _ => unreachable!("wrong payload size"),
+            }
+        }
+        // 4. Handle integer values
+        else if let Ok(int_val) = value.try_int(vm) {
+            let i = int_val.as_bigint();
+            match size {
+                1 => {
+                    let val = i.to_i8().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                2 => {
+                    let val = i.to_i16().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                4 => {
+                    let val = i.to_i32().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                8 => {
+                    let val = i.to_i64().unwrap_or(0);
+                    Ok(val.to_ne_bytes().to_vec())
+                }
+                _ => Ok(vec![0u8; size]),
+            }
+        } else {
+            Ok(vec![0u8; size])
+        }
+    }
+
+    /// Convert a Python value to bytes with type-specific handling for pointer types.
+    /// Returns (bytes, optional holder for wchar buffer).
+    fn value_to_bytes_for_type(
+        type_code: &str,
+        value: &PyObject,
+        size: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<(Vec<u8>, Option<PyObjectRef>)> {
+        match type_code {
+            // c_float: always convert to float first (f_set)
+            "f" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                let val = f as f32;
+                Ok((val.to_ne_bytes().to_vec(), None))
+            }
+            // c_double: always convert to float first (d_set)
+            "d" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                Ok((f.to_ne_bytes().to_vec(), None))
+            }
+            // c_longdouble: convert to float (treated as f64 in RustPython)
+            "g" => {
+                let f = if let Some(float_val) = value.downcast_ref::<crate::builtins::PyFloat>() {
+                    float_val.to_f64()
+                } else if let Ok(int_val) = value.try_int(vm) {
+                    int_val.as_bigint().to_i64().unwrap_or(0) as f64
+                } else {
+                    return Err(vm.new_type_error(format!(
+                        "float expected instead of {}",
+                        value.class().name()
+                    )));
+                };
+                Ok((f.to_ne_bytes().to_vec(), None))
+            }
+            "z" => {
+                // c_char_p: store pointer to null-terminated bytes
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (converted, ptr) = ensure_z_null_terminated(bytes, vm);
+                    let mut result = vec![0u8; size];
+                    let addr_bytes = ptr.to_ne_bytes();
+                    let len = core::cmp::min(addr_bytes.len(), size);
+                    result[..len].copy_from_slice(&addr_bytes[..len]);
+                    return Ok((result, Some(converted)));
+                }
+                // Integer address
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = core::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            "Z" => {
+                // c_wchar_p: store pointer to null-terminated wchar_t buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = str_to_wchar_bytes(s.as_str(), vm);
+                    let mut result = vec![0u8; size];
+                    let addr_bytes = ptr.to_ne_bytes();
+                    let len = core::cmp::min(addr_bytes.len(), size);
+                    result[..len].copy_from_slice(&addr_bytes[..len]);
+                    return Ok((result, Some(holder)));
+                }
+                // Integer address
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = core::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            "P" => {
+                // c_void_p: store integer as pointer
+                if let Ok(int_val) = value.try_index(vm) {
+                    let v = int_val.as_bigint().to_usize().unwrap_or(0);
+                    let mut result = vec![0u8; size];
+                    let bytes = v.to_ne_bytes();
+                    let len = core::cmp::min(bytes.len(), size);
+                    result[..len].copy_from_slice(&bytes[..len]);
+                    return Ok((result, None));
+                }
+                // None -> NULL pointer
+                if vm.is_none(value) {
+                    return Ok((vec![0u8; size], None));
+                }
+                Ok((PyCField::value_to_bytes(value, size, vm)?, None))
+            }
+            _ => Ok((PyCField::value_to_bytes(value, size, vm)?, None)),
+        }
+    }
+
+    /// Check if the field type is a c_char array (element type has _type_ == 'c')
+    fn is_char_array(proto: &PyObject, vm: &VirtualMachine) -> bool {
+        // Get element_type from StgInfo (for array types)
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = proto_type.stg_info_opt()
+            && let Some(element_type) = &stg.element_type
+        {
+            // Check if element type has _type_ == "c"
+            if let Ok(type_code) = element_type.as_object().get_attr("_type_", vm)
+                && let Some(s) = type_code.downcast_ref::<PyStr>()
+            {
+                return s.as_str() == "c";
+            }
+        }
+        false
+    }
+
+    /// Check if the field type is a c_wchar array (element type has _type_ == 'u')
+    fn is_wchar_array(proto: &PyObject, vm: &VirtualMachine) -> bool {
+        // Get element_type from StgInfo (for array types)
+        if let Some(proto_type) = proto.downcast_ref::<PyType>()
+            && let Some(stg) = proto_type.stg_info_opt()
+            && let Some(element_type) = &stg.element_type
+        {
+            // Check if element type has _type_ == "u"
+            if let Ok(type_code) = element_type.as_object().get_attr("_type_", vm)
+                && let Some(s) = type_code.downcast_ref::<PyStr>()
+            {
+                return s.as_str() == "u";
+            }
+        }
+        false
+    }
+
+    /// Convert bytes for c_char array assignment (stops at first null terminator)
+    /// Returns (bytes_to_copy, copy_len)
+    fn bytes_for_char_array(src: &[u8]) -> &[u8] {
+        // Find first null terminator and include it
+        if let Some(null_pos) = src.iter().position(|&b| b == 0) {
+            &src[..=null_pos]
+        } else {
+            src
+        }
+    }
+}
+
+#[pyclass(
+    flags(DISALLOW_INSTANTIATION, IMMUTABLETYPE),
+    with(Representable, GetDescriptor)
+)]
+impl PyCField {
+    /// Get PyCData from object (works for both Structure and Union)
+    fn get_cdata_from_obj<'a>(obj: &'a PyObjectRef, vm: &VirtualMachine) -> PyResult<&'a PyCData> {
+        if let Some(s) = obj.downcast_ref::<super::structure::PyCStructure>() {
+            Ok(&s.0)
+        } else if let Some(u) = obj.downcast_ref::<super::union::PyCUnion>() {
+            Ok(&u.0)
+        } else {
+            Err(vm.new_type_error(format!(
+                "descriptor works only on Structure or Union instances, got {}",
+                obj.class().name()
+            )))
+        }
+    }
+
+    /// PyCField_set
+    #[pyslot]
+    fn descr_set(
+        zelf: &PyObject,
+        obj: PyObjectRef,
+        value: PySetterValue<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let zelf = zelf
+            .downcast_ref::<PyCField>()
+            .ok_or_else(|| vm.new_type_error("expected CField"))?;
+
+        let offset = zelf.offset as usize;
+        let size = zelf.byte_size();
+
+        // Get PyCData from obj (works for both Structure and Union)
+        let cdata = Self::get_cdata_from_obj(&obj, vm)?;
+
+        match value {
+            PySetterValue::Assign(value) => {
+                // Check if needs byte swapping
+                let needs_swap = (obj
+                    .class()
+                    .as_object()
+                    .get_attr("_swappedbytes_", vm)
+                    .is_ok()
+                    || zelf
+                        .proto
+                        .as_object()
+                        .get_attr("_swappedbytes_", vm)
+                        .is_ok())
+                    && size > 1;
+
+                // PyCData_set
+                cdata.set_field(
+                    zelf.proto.as_object(),
+                    value,
+                    zelf.index,
+                    size,
+                    offset,
+                    needs_swap,
+                    vm,
+                )
+            }
+            PySetterValue::Delete => Err(vm.new_type_error("cannot delete field")),
+        }
+    }
+
+    #[pygetset]
+    fn offset(&self) -> isize {
+        self.offset
+    }
+
+    #[pygetset]
+    fn size(&self) -> isize {
+        self.size
+    }
+}
+
+// ParamFunc implementations (PyCArgObject creation)
+
+use super::_ctypes::CArgObject;
+
+/// Call the appropriate paramfunc based on StgInfo.paramfunc
+/// info->paramfunc(st, obj)
+pub(super) fn call_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    let cls = obj.class();
+    let stg_info = cls
+        .stg_info_opt()
+        .ok_or_else(|| vm.new_type_error("not a ctypes type"))?;
+
+    match stg_info.paramfunc {
+        ParamFunc::Simple => simple_paramfunc(obj, vm),
+        ParamFunc::Array => array_paramfunc(obj, vm),
+        ParamFunc::Pointer => pointer_paramfunc(obj, vm),
+        ParamFunc::Structure | ParamFunc::Union => struct_union_paramfunc(obj, &stg_info, vm),
+        ParamFunc::None => Err(vm.new_type_error("no paramfunc")),
+    }
+}
+
+/// PyCSimpleType_paramfunc
+fn simple_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::simple::PyCSimple;
+
+    let simple = obj
+        .downcast_ref::<PyCSimple>()
+        .ok_or_else(|| vm.new_type_error("expected simple type"))?;
+
+    // Get type code from _type_ attribute
+    let cls = obj.class().to_owned();
+    let type_code = cls
+        .type_code(vm)
+        .ok_or_else(|| vm.new_type_error("no _type_ attribute"))?;
+    let tag = type_code.as_bytes().first().copied().unwrap_or(b'?');
+
+    // Read value from buffer: memcpy(&parg->value, self->b_ptr, self->b_size)
+    let buffer = simple.0.buffer.read();
+    let ffi_value = buffer_to_ffi_value(&type_code, &buffer);
+
+    Ok(CArgObject {
+        tag,
+        value: ffi_value,
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// PyCArrayType_paramfunc
+fn array_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::array::PyCArray;
+
+    let array = obj
+        .downcast_ref::<PyCArray>()
+        .ok_or_else(|| vm.new_type_error("expected array"))?;
+
+    // p->value.p = (char *)self->b_ptr
+    let buffer = array.0.buffer.read();
+    let ptr_val = buffer.as_ptr() as usize;
+
+    Ok(CArgObject {
+        tag: b'P',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// PyCPointerType_paramfunc
+fn pointer_paramfunc(obj: &PyObject, vm: &VirtualMachine) -> PyResult<CArgObject> {
+    use super::pointer::PyCPointer;
+
+    let ptr = obj
+        .downcast_ref::<PyCPointer>()
+        .ok_or_else(|| vm.new_type_error("expected pointer"))?;
+
+    // parg->value.p = *(void **)self->b_ptr
+    let ptr_val = ptr.get_ptr_value();
+
+    Ok(CArgObject {
+        tag: b'P',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size: 0,
+        offset: 0,
+    })
+}
+
+/// StructUnionType_paramfunc (for both Structure and Union)
+fn struct_union_paramfunc(
+    obj: &PyObject,
+    stg_info: &StgInfo,
+    _vm: &VirtualMachine,
+) -> PyResult<CArgObject> {
+    // Get buffer pointer
+    // For large structs (> sizeof(void*)), we'd need to allocate and copy.
+    // For now, just point to buffer directly and keep obj reference for memory safety.
+    let buffer = if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+        cdata.buffer.read()
+    } else {
+        return Ok(CArgObject {
+            tag: b'V',
+            value: FfiArgValue::Pointer(0),
+            obj: obj.to_owned(),
+            size: stg_info.size,
+            offset: 0,
+        });
+    };
+
+    let ptr_val = buffer.as_ptr() as usize;
+    let size = buffer.len();
+
+    Ok(CArgObject {
+        tag: b'V',
+        value: FfiArgValue::Pointer(ptr_val),
+        obj: obj.to_owned(),
+        size,
+        offset: 0,
+    })
+}
+
+// FfiArgValue - Owned FFI argument value
+
+/// Owned FFI argument value. Keeps the value alive for the duration of the FFI call.
+#[derive(Debug, Clone)]
+pub enum FfiArgValue {
+    U8(u8),
+    I8(i8),
+    U16(u16),
+    I16(i16),
+    U32(u32),
+    I32(i32),
+    U64(u64),
+    I64(i64),
+    F32(f32),
+    F64(f64),
+    Pointer(usize),
+    /// Pointer with owned data. The PyObjectRef keeps the pointed data alive.
+    OwnedPointer(usize, #[allow(dead_code)] PyObjectRef),
+}
+
+impl FfiArgValue {
+    /// Create an Arg reference to this owned value
+    pub fn as_arg(&self) -> libffi::middle::Arg<'_> {
+        match self {
+            FfiArgValue::U8(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I8(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U16(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I16(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::U64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::I64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::F32(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::F64(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::Pointer(v) => libffi::middle::Arg::new(v),
+            FfiArgValue::OwnedPointer(v, _) => libffi::middle::Arg::new(v),
+        }
+    }
+}
+
+/// Convert buffer bytes to FfiArgValue based on type code
+pub(super) fn buffer_to_ffi_value(type_code: &str, buffer: &[u8]) -> FfiArgValue {
+    match type_code {
+        "c" | "b" => {
+            let v = buffer.first().map(|&b| b as i8).unwrap_or(0);
+            FfiArgValue::I8(v)
+        }
+        "B" => {
+            let v = buffer.first().copied().unwrap_or(0);
+            FfiArgValue::U8(v)
+        }
+        "h" => {
+            let v = if buffer.len() >= 2 {
+                i16::from_ne_bytes(buffer[..2].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::I16(v)
+        }
+        "H" => {
+            let v = if buffer.len() >= 2 {
+                u16::from_ne_bytes(buffer[..2].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U16(v)
+        }
+        "i" => {
+            let v = if buffer.len() >= 4 {
+                i32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::I32(v)
+        }
+        "I" => {
+            let v = if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U32(v)
+        }
+        "l" | "q" => {
+            let v = if buffer.len() >= 8 {
+                i64::from_ne_bytes(buffer[..8].try_into().unwrap())
+            } else if buffer.len() >= 4 {
+                i32::from_ne_bytes(buffer[..4].try_into().unwrap()) as i64
+            } else {
+                0
+            };
+            FfiArgValue::I64(v)
+        }
+        "L" | "Q" => {
+            let v = if buffer.len() >= 8 {
+                u64::from_ne_bytes(buffer[..8].try_into().unwrap())
+            } else if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap()) as u64
+            } else {
+                0
+            };
+            FfiArgValue::U64(v)
+        }
+        "f" => {
+            let v = if buffer.len() >= 4 {
+                f32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0.0
+            };
+            FfiArgValue::F32(v)
+        }
+        "d" | "g" => {
+            let v = if buffer.len() >= 8 {
+                f64::from_ne_bytes(buffer[..8].try_into().unwrap())
+            } else {
+                0.0
+            };
+            FfiArgValue::F64(v)
+        }
+        "z" | "Z" | "P" | "O" => FfiArgValue::Pointer(read_ptr_from_buffer(buffer)),
+        "?" => {
+            let v = buffer.first().map(|&b| b != 0).unwrap_or(false);
+            FfiArgValue::U8(if v { 1 } else { 0 })
+        }
+        "u" => {
+            // wchar_t - 4 bytes on most platforms
+            let v = if buffer.len() >= 4 {
+                u32::from_ne_bytes(buffer[..4].try_into().unwrap())
+            } else {
+                0
+            };
+            FfiArgValue::U32(v)
+        }
+        _ => FfiArgValue::Pointer(0),
+    }
+}
+
+/// Convert bytes to appropriate Python object based on ctypes type
+pub(super) fn bytes_to_pyobject(
+    cls: &Py<PyType>,
+    bytes: &[u8],
+    vm: &VirtualMachine,
+) -> PyResult<PyObjectRef> {
+    // Try to get _type_ attribute
+    if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+        && let Ok(s) = type_attr.str(vm)
+    {
+        let ty = s.to_string();
+        return match ty.as_str() {
+            "c" => Ok(vm.ctx.new_bytes(bytes.to_vec()).into()),
+            "b" => {
+                let val = if !bytes.is_empty() { bytes[0] as i8 } else { 0 };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "B" => {
+                let val = if !bytes.is_empty() { bytes[0] } else { 0 };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "h" => {
+                const SIZE: usize = mem::size_of::<c_short>();
+                let val = if bytes.len() >= SIZE {
+                    c_short::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "H" => {
+                const SIZE: usize = mem::size_of::<c_ushort>();
+                let val = if bytes.len() >= SIZE {
+                    c_ushort::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "i" => {
+                const SIZE: usize = mem::size_of::<c_int>();
+                let val = if bytes.len() >= SIZE {
+                    c_int::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "I" => {
+                const SIZE: usize = mem::size_of::<c_uint>();
+                let val = if bytes.len() >= SIZE {
+                    c_uint::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "l" => {
+                const SIZE: usize = mem::size_of::<c_long>();
+                let val = if bytes.len() >= SIZE {
+                    c_long::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "L" => {
+                const SIZE: usize = mem::size_of::<c_ulong>();
+                let val = if bytes.len() >= SIZE {
+                    c_ulong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "q" => {
+                const SIZE: usize = mem::size_of::<c_longlong>();
+                let val = if bytes.len() >= SIZE {
+                    c_longlong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "Q" => {
+                const SIZE: usize = mem::size_of::<c_ulonglong>();
+                let val = if bytes.len() >= SIZE {
+                    c_ulonglong::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "f" => {
+                const SIZE: usize = mem::size_of::<c_float>();
+                let val = if bytes.len() >= SIZE {
+                    c_float::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val as f64).into())
+            }
+            "d" => {
+                const SIZE: usize = mem::size_of::<c_double>();
+                let val = if bytes.len() >= SIZE {
+                    c_double::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val).into())
+            }
+            "g" => {
+                // long double - read as f64 for now since Rust doesn't have native long double
+                // This may lose precision on platforms where long double > 64 bits
+                const SIZE: usize = mem::size_of::<c_double>();
+                let val = if bytes.len() >= SIZE {
+                    c_double::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0.0
+                };
+                Ok(vm.ctx.new_float(val).into())
+            }
+            "?" => {
+                let val = !bytes.is_empty() && bytes[0] != 0;
+                Ok(vm.ctx.new_bool(val).into())
+            }
+            "v" => {
+                // VARIANT_BOOL: non-zero = True, zero = False
+                const SIZE: usize = mem::size_of::<c_short>();
+                let val = if bytes.len() >= SIZE {
+                    c_short::from_ne_bytes(bytes[..SIZE].try_into().expect("size checked"))
+                } else {
+                    0
+                };
+                Ok(vm.ctx.new_bool(val != 0).into())
+            }
+            "z" => {
+                // c_char_p: read NULL-terminated string from pointer
+                let ptr = read_ptr_from_buffer(bytes);
+                if ptr == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                let c_str = unsafe { core::ffi::CStr::from_ptr(ptr as _) };
+                Ok(vm.ctx.new_bytes(c_str.to_bytes().to_vec()).into())
+            }
+            "Z" => {
+                // c_wchar_p: read NULL-terminated wide string from pointer
+                let ptr = read_ptr_from_buffer(bytes);
+                if ptr == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                let len = unsafe { libc::wcslen(ptr as *const libc::wchar_t) };
+                let wchars =
+                    unsafe { core::slice::from_raw_parts(ptr as *const libc::wchar_t, len) };
+                let s: String = wchars
+                    .iter()
+                    .filter_map(|&c| char::from_u32(c as u32))
+                    .collect();
+                Ok(vm.ctx.new_str(s).into())
+            }
+            "P" => {
+                // c_void_p: return pointer value as integer
+                let val = read_ptr_from_buffer(bytes);
+                if val == 0 {
+                    return Ok(vm.ctx.none());
+                }
+                Ok(vm.ctx.new_int(val).into())
+            }
+            "u" => {
+                let val = if bytes.len() >= mem::size_of::<WideChar>() {
+                    let wc = if mem::size_of::<WideChar>() == 2 {
+                        u16::from_ne_bytes([bytes[0], bytes[1]]) as u32
+                    } else {
+                        u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]])
+                    };
+                    char::from_u32(wc).unwrap_or('\0')
+                } else {
+                    '\0'
+                };
+                Ok(vm.ctx.new_str(val).into())
+            }
+            _ => Ok(vm.ctx.none()),
+        };
+    }
+    // Default: return bytes as-is
+    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+}
+
+// Shared functions for Structure and Union types
+
+/// Parse a non-negative integer attribute, returning default if not present
+pub(super) fn get_usize_attr(
+    obj: &PyObject,
+    attr: &str,
+    default: usize,
+    vm: &VirtualMachine,
+) -> PyResult<usize> {
+    let Ok(attr_val) = obj.get_attr(vm.ctx.intern_str(attr), vm) else {
+        return Ok(default);
+    };
+    let n = attr_val
+        .try_int(vm)
+        .map_err(|_| vm.new_value_error(format!("{attr} must be a non-negative integer")))?;
+    let val = n.as_bigint();
+    if val.is_negative() {
+        return Err(vm.new_value_error(format!("{attr} must be a non-negative integer")));
+    }
+    Ok(val.to_usize().unwrap_or(default))
+}
+
+/// Read a pointer value from buffer
+#[inline]
+pub(super) fn read_ptr_from_buffer(buffer: &[u8]) -> usize {
+    const PTR_SIZE: usize = core::mem::size_of::<usize>();
+    if buffer.len() >= PTR_SIZE {
+        usize::from_ne_bytes(buffer[..PTR_SIZE].try_into().unwrap())
+    } else {
+        0
+    }
+}
+
+/// Check if a type is a "simple instance" (direct subclass of a simple type)
+/// Returns TRUE for c_int, c_void_p, etc. (simple types with _type_ attribute)
+/// Returns FALSE for Structure, Array, POINTER(T), etc.
+pub(super) fn is_simple_instance(typ: &Py<PyType>) -> bool {
+    // _ctypes_simple_instance
+    // Check if the type's metaclass is PyCSimpleType
+    let metaclass = typ.class();
+    metaclass.fast_issubclass(super::simple::PyCSimpleType::static_type())
+}
+
+/// Set or initialize StgInfo on a type
+pub(super) fn set_or_init_stginfo(type_ref: &PyType, stg_info: StgInfo) {
+    if type_ref.init_type_data(stg_info.clone()).is_err()
+        && let Some(mut existing) = type_ref.get_type_data_mut::<StgInfo>()
+    {
+        *existing = stg_info;
+    }
+}
+
+/// Check if a field type supports byte order swapping
+pub(super) fn check_other_endian_support(
+    field_type: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let other_endian_attr = if cfg!(target_endian = "little") {
+        "__ctype_be__"
+    } else {
+        "__ctype_le__"
+    };
+
+    if field_type.get_attr(other_endian_attr, vm).is_ok() {
+        return Ok(());
+    }
+
+    // Array type: recursively check element type
+    if let Ok(elem_type) = field_type.get_attr("_type_", vm)
+        && field_type.get_attr("_length_", vm).is_ok()
+    {
+        return check_other_endian_support(&elem_type, vm);
+    }
+
+    // Structure/Union: has StgInfo but no _type_ attribute
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && type_obj.stg_info_opt().is_some()
+        && field_type.get_attr("_type_", vm).is_err()
+    {
+        return Ok(());
+    }
+
+    Err(vm.new_type_error(format!(
+        "This type does not support other endian: {}",
+        field_type.class().name()
+    )))
+}
+
+/// Get the size of a ctypes field type
+pub(super) fn get_field_size(field_type: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+    {
+        return Ok(stg_info.size);
+    }
+
+    if let Some(size) = field_type
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|type_attr| type_attr.str(vm).ok())
+        .and_then(|type_str| {
+            let s = type_str.to_string();
+            (s.len() == 1).then(|| super::get_size(&s))
+        })
+    {
+        return Ok(size);
+    }
+
+    if let Some(s) = field_type
+        .get_attr("size_of_instances", vm)
+        .ok()
+        .and_then(|size_method| size_method.call((), vm).ok())
+        .and_then(|size| size.try_int(vm).ok())
+        .and_then(|n| n.as_bigint().to_usize())
+    {
+        return Ok(s);
+    }
+
+    Ok(core::mem::size_of::<usize>())
+}
+
+/// Get the alignment of a ctypes field type
+pub(super) fn get_field_align(field_type: &PyObject, vm: &VirtualMachine) -> usize {
+    if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+        && let Some(stg_info) = type_obj.stg_info_opt()
+        && stg_info.align > 0
+    {
+        return stg_info.align;
+    }
+
+    if let Some(align) = field_type
+        .get_attr("_type_", vm)
+        .ok()
+        .and_then(|type_attr| type_attr.str(vm).ok())
+        .and_then(|type_str| {
+            let s = type_str.to_string();
+            (s.len() == 1).then(|| super::get_size(&s))
+        })
+    {
+        return align;
+    }
+
+    1
+}
+
+/// Promote fields from anonymous struct/union to parent type
+fn make_fields(
+    cls: &Py<PyType>,
+    descr: &super::PyCField,
+    index: usize,
+    offset: isize,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    use crate::builtins::{PyList, PyTuple};
+    use crate::convert::ToPyObject;
+
+    let fields = descr.proto.as_object().get_attr("_fields_", vm)?;
+    let fieldlist: Vec<PyObjectRef> = if let Some(list) = fields.downcast_ref::<PyList>() {
+        list.borrow_vec().to_vec()
+    } else if let Some(tuple) = fields.downcast_ref::<PyTuple>() {
+        tuple.to_vec()
+    } else {
+        return Err(vm.new_type_error("_fields_ must be a sequence"));
+    };
+
+    for pair in fieldlist.iter() {
+        let field_tuple = pair
+            .downcast_ref::<PyTuple>()
+            .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
+
+        if field_tuple.len() < 2 {
+            continue;
+        }
+
+        let fname = field_tuple
+            .first()
+            .expect("len checked")
+            .downcast_ref::<PyStr>()
+            .ok_or_else(|| vm.new_type_error("field name must be a string"))?;
+
+        let fdescr_obj = descr
+            .proto
+            .as_object()
+            .get_attr(vm.ctx.intern_str(fname.as_str()), vm)?;
+        let fdescr = fdescr_obj
+            .downcast_ref::<super::PyCField>()
+            .ok_or_else(|| vm.new_type_error("unexpected type"))?;
+
+        if fdescr.anonymous {
+            make_fields(
+                cls,
+                fdescr,
+                index + fdescr.index,
+                offset + fdescr.offset,
+                vm,
+            )?;
+            continue;
+        }
+
+        let new_descr = super::PyCField::new_from_field(fdescr, index, offset);
+        cls.set_attr(vm.ctx.intern_str(fname.as_str()), new_descr.to_pyobject(vm));
+    }
+
+    Ok(())
+}
+
+/// Process _anonymous_ attribute for struct/union
+pub(super) fn make_anon_fields(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<()> {
+    use crate::builtins::{PyList, PyTuple};
+    use crate::convert::ToPyObject;
+
+    let anon = match cls.as_object().get_attr("_anonymous_", vm) {
+        Ok(anon) => anon,
+        Err(_) => return Ok(()),
+    };
+
+    let anon_names: Vec<PyObjectRef> = if let Some(list) = anon.downcast_ref::<PyList>() {
+        list.borrow_vec().to_vec()
+    } else if let Some(tuple) = anon.downcast_ref::<PyTuple>() {
+        tuple.to_vec()
+    } else {
+        return Err(vm.new_type_error("_anonymous_ must be a sequence"));
+    };
+
+    for fname_obj in anon_names.iter() {
+        let fname = fname_obj
+            .downcast_ref::<PyStr>()
+            .ok_or_else(|| vm.new_type_error("_anonymous_ items must be strings"))?;
+
+        let descr_obj = cls
+            .as_object()
+            .get_attr(vm.ctx.intern_str(fname.as_str()), vm)?;
+
+        let descr = descr_obj.downcast_ref::<super::PyCField>().ok_or_else(|| {
+            vm.new_attribute_error(format!(
+                "'{}' is specified in _anonymous_ but not in _fields_",
+                fname.as_str()
+            ))
+        })?;
+
+        let mut new_descr = super::PyCField::new_from_field(descr, 0, 0);
+        new_descr.set_anonymous(true);
+        cls.set_attr(vm.ctx.intern_str(fname.as_str()), new_descr.to_pyobject(vm));
+
+        make_fields(cls, descr, descr.index, descr.offset, vm)?;
+    }
+
+    Ok(())
+}
diff --git a/crates/vm/src/stdlib/ctypes/function.rs b/crates/vm/src/stdlib/ctypes/function.rs
new file mode 100644
index 0000000000..295e6fd137
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/function.rs
@@ -0,0 +1,2217 @@
+// spell-checker:disable
+
+use super::{
+    _ctypes::CArgObject,
+    PyCArray, PyCData, PyCPointer, PyCStructure, StgInfo,
+    base::{CDATA_BUFFER_METHODS, FfiArgValue, ParamFunc, StgInfoFlags},
+    simple::PyCSimple,
+    type_info,
+};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyDict, PyNone, PyStr, PyTuple, PyType, PyTypeRef},
+    class::StaticType,
+    function::FuncArgs,
+    protocol::{BufferDescriptor, PyBuffer, PyNumberMethods},
+    types::{AsBuffer, AsNumber, Callable, Constructor, Initializer, Representable},
+    vm::thread::with_current_vm,
+};
+use alloc::borrow::Cow;
+use core::ffi::c_void;
+use core::fmt::Debug;
+use libffi::{
+    low,
+    middle::{Arg, Cif, Closure, CodePtr, Type},
+};
+use libloading::Symbol;
+use num_traits::{Signed, ToPrimitive};
+use rustpython_common::lock::PyRwLock;
+
+// Internal function addresses for special ctypes functions
+pub(super) const INTERNAL_CAST_ADDR: usize = 1;
+pub(super) const INTERNAL_STRING_AT_ADDR: usize = 2;
+pub(super) const INTERNAL_WSTRING_AT_ADDR: usize = 3;
+
+// Thread-local errno storage for ctypes
+std::thread_local! {
+    /// Thread-local storage for ctypes errno
+    /// This is separate from the system errno - ctypes swaps them during FFI calls
+    /// when use_errno=True is specified.
+    static CTYPES_LOCAL_ERRNO: core::cell::Cell<i32> = const { core::cell::Cell::new(0) };
+}
+
+/// Get ctypes thread-local errno value
+pub(super) fn get_errno_value() -> i32 {
+    CTYPES_LOCAL_ERRNO.with(|e| e.get())
+}
+
+/// Set ctypes thread-local errno value, returns old value
+pub(super) fn set_errno_value(value: i32) -> i32 {
+    CTYPES_LOCAL_ERRNO.with(|e| {
+        let old = e.get();
+        e.set(value);
+        old
+    })
+}
+
+/// Save and restore errno around FFI call (called when use_errno=True)
+/// Before: restore thread-local errno to system
+/// After: save system errno to thread-local
+#[cfg(not(windows))]
+fn swap_errno<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Before call: restore thread-local errno to system
+    let saved = CTYPES_LOCAL_ERRNO.with(|e| e.get());
+    errno::set_errno(errno::Errno(saved));
+
+    // Call the function
+    let result = f();
+
+    // After call: save system errno to thread-local
+    let new_error = errno::errno().0;
+    CTYPES_LOCAL_ERRNO.with(|e| e.set(new_error));
+
+    result
+}
+
+#[cfg(windows)]
+std::thread_local! {
+    /// Thread-local storage for ctypes last_error (Windows only)
+    static CTYPES_LOCAL_LAST_ERROR: core::cell::Cell<u32> = const { core::cell::Cell::new(0) };
+}
+
+#[cfg(windows)]
+pub(super) fn get_last_error_value() -> u32 {
+    CTYPES_LOCAL_LAST_ERROR.with(|e| e.get())
+}
+
+#[cfg(windows)]
+pub(super) fn set_last_error_value(value: u32) -> u32 {
+    CTYPES_LOCAL_LAST_ERROR.with(|e| {
+        let old = e.get();
+        e.set(value);
+        old
+    })
+}
+
+/// Save and restore last_error around FFI call (called when use_last_error=True)
+#[cfg(windows)]
+fn save_and_restore_last_error<F, R>(f: F) -> R
+where
+    F: FnOnce() -> R,
+{
+    // Before call: restore thread-local last_error to Windows
+    let saved = CTYPES_LOCAL_LAST_ERROR.with(|e| e.get());
+    unsafe { windows_sys::Win32::Foundation::SetLastError(saved) };
+
+    // Call the function
+    let result = f();
+
+    // After call: save Windows last_error to thread-local
+    let new_error = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+    CTYPES_LOCAL_LAST_ERROR.with(|e| e.set(new_error));
+
+    result
+}
+
+type FP = unsafe extern "C" fn();
+
+/// Get FFI type for a ctypes type code
+fn get_ffi_type(ty: &str) -> Option<libffi::middle::Type> {
+    type_info(ty).map(|t| (t.ffi_type_fn)())
+}
+
+// PyCFuncPtr - Function pointer implementation
+
+/// Get FFI type from CArgObject tag character
+fn ffi_type_from_tag(tag: u8) -> Type {
+    match tag {
+        b'c' | b'b' => Type::i8(),
+        b'B' => Type::u8(),
+        b'h' => Type::i16(),
+        b'H' => Type::u16(),
+        b'i' => Type::i32(),
+        b'I' => Type::u32(),
+        b'l' => {
+            if core::mem::size_of::<libc::c_long>() == 8 {
+                Type::i64()
+            } else {
+                Type::i32()
+            }
+        }
+        b'L' => {
+            if core::mem::size_of::<libc::c_ulong>() == 8 {
+                Type::u64()
+            } else {
+                Type::u32()
+            }
+        }
+        b'q' => Type::i64(),
+        b'Q' => Type::u64(),
+        b'f' => Type::f32(),
+        b'd' | b'g' => Type::f64(),
+        b'?' => Type::u8(),
+        b'u' => {
+            if core::mem::size_of::<super::WideChar>() == 2 {
+                Type::u16()
+            } else {
+                Type::u32()
+            }
+        }
+        _ => Type::pointer(), // 'P', 'V', 'z', 'Z', 'O', etc.
+    }
+}
+
+/// Convert any object to a pointer value for c_void_p arguments
+/// Follows ConvParam logic for pointer types
+fn convert_to_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<FfiArgValue> {
+    // 0. CArgObject (from byref()) -> buffer address + offset
+    if let Some(carg) = value.downcast_ref::<CArgObject>() {
+        // Get buffer address from the underlying object
+        let base_addr = if let Some(cdata) = carg.obj.downcast_ref::<PyCData>() {
+            cdata.buffer.read().as_ptr() as usize
+        } else {
+            return Err(vm.new_type_error(format!(
+                "byref() argument must be a ctypes instance, not '{}'",
+                carg.obj.class().name()
+            )));
+        };
+        let addr = (base_addr as isize + carg.offset) as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 1. None -> NULL
+    if value.is(&vm.ctx.none) {
+        return Ok(FfiArgValue::Pointer(0));
+    }
+
+    // 2. PyCArray -> buffer address (PyCArrayType_paramfunc)
+    if let Some(array) = value.downcast_ref::<PyCArray>() {
+        let addr = array.0.buffer.read().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 3. PyCPointer -> stored pointer value
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>() {
+        return Ok(FfiArgValue::Pointer(ptr.get_ptr_value()));
+    }
+
+    // 4. PyCStructure -> buffer address
+    if let Some(struct_obj) = value.downcast_ref::<PyCStructure>() {
+        let addr = struct_obj.0.buffer.read().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 5. PyCSimple (c_void_p, c_char_p, etc.) -> value from buffer
+    if let Some(simple) = value.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= core::mem::size_of::<usize>() {
+            let addr = super::base::read_ptr_from_buffer(&buffer);
+            return Ok(FfiArgValue::Pointer(addr));
+        }
+    }
+
+    // 6. bytes -> buffer address (PyBytes_AsString)
+    if let Some(bytes) = value.downcast_ref::<crate::builtins::PyBytes>() {
+        let addr = bytes.as_bytes().as_ptr() as usize;
+        return Ok(FfiArgValue::Pointer(addr));
+    }
+
+    // 7. Integer -> direct value (PyLong_AsVoidPtr behavior)
+    if let Ok(int_val) = value.try_int(vm) {
+        let bigint = int_val.as_bigint();
+        // Negative values: use signed conversion (allows -1 as 0xFFFF...)
+        if bigint.is_negative() {
+            if let Some(signed_val) = bigint.to_isize() {
+                return Ok(FfiArgValue::Pointer(signed_val as usize));
+            }
+        } else if let Some(unsigned_val) = bigint.to_usize() {
+            return Ok(FfiArgValue::Pointer(unsigned_val));
+        }
+        // Value out of range - raise OverflowError
+        return Err(vm.new_overflow_error("int too large to convert to pointer".to_string()));
+    }
+
+    // 8. Check _as_parameter_ attribute ( recursive ConvParam)
+    if let Ok(as_param) = value.get_attr("_as_parameter_", vm) {
+        return convert_to_pointer(&as_param, vm);
+    }
+
+    Err(vm.new_type_error(format!(
+        "cannot convert '{}' to c_void_p",
+        value.class().name()
+    )))
+}
+
+/// ConvParam-like conversion for when argtypes is None
+/// Returns an Argument with FFI type, value, and optional keep object
+fn conv_param(value: &PyObject, vm: &VirtualMachine) -> PyResult<Argument> {
+    // 1. CArgObject (from byref() or paramfunc) -> use stored type and value
+    if let Some(carg) = value.downcast_ref::<CArgObject>() {
+        let ffi_type = ffi_type_from_tag(carg.tag);
+        return Ok(Argument {
+            ffi_type,
+            keep: None,
+            value: carg.value.clone(),
+        });
+    }
+
+    // 2. None -> NULL pointer
+    if value.is(&vm.ctx.none) {
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: None,
+            value: FfiArgValue::Pointer(0),
+        });
+    }
+
+    // 3. ctypes objects -> use paramfunc
+    if let Ok(carg) = super::base::call_paramfunc(value, vm) {
+        let ffi_type = ffi_type_from_tag(carg.tag);
+        return Ok(Argument {
+            ffi_type,
+            keep: None,
+            value: carg.value.clone(),
+        });
+    }
+
+    // 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)
+        let wide: Vec<u16> = s
+            .as_str()
+            .encode_utf16()
+            .chain(core::iter::once(0))
+            .collect();
+        let wide_bytes: Vec<u8> = wide.iter().flat_map(|&x| x.to_ne_bytes()).collect();
+        let keep = vm.ctx.new_bytes(wide_bytes);
+        let addr = keep.as_bytes().as_ptr() as usize;
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: Some(keep.into()),
+            value: FfiArgValue::Pointer(addr),
+        });
+    }
+
+    // 9. Python bytes -> null-terminated buffer pointer
+    // Need to ensure null termination like c_char_p
+    if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+        let mut buffer = bytes.as_bytes().to_vec();
+        buffer.push(0); // Add null terminator
+        let keep = vm.ctx.new_bytes(buffer);
+        let addr = keep.as_bytes().as_ptr() as usize;
+        return Ok(Argument {
+            ffi_type: Type::pointer(),
+            keep: Some(keep.into()),
+            value: FfiArgValue::Pointer(addr),
+        });
+    }
+
+    // 10. Python int -> i32 (default integer type)
+    if let Ok(int_val) = value.try_int(vm) {
+        let val = int_val.as_bigint().to_i32().unwrap_or(0);
+        return Ok(Argument {
+            ffi_type: Type::i32(),
+            keep: None,
+            value: FfiArgValue::I32(val),
+        });
+    }
+
+    // 11. Python float -> f64
+    if let Ok(float_val) = value.try_float(vm) {
+        return Ok(Argument {
+            ffi_type: Type::f64(),
+            keep: None,
+            value: FfiArgValue::F64(float_val.to_f64()),
+        });
+    }
+
+    // 12. Check _as_parameter_ attribute
+    if let Ok(as_param) = value.get_attr("_as_parameter_", vm) {
+        return conv_param(&as_param, vm);
+    }
+
+    Err(vm.new_type_error(format!(
+        "Don't know how to convert parameter {}",
+        value.class().name()
+    )))
+}
+
+trait ArgumentType {
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> PyResult<Type>;
+    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<FfiArgValue>;
+}
+
+impl ArgumentType for PyTypeRef {
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> PyResult<Type> {
+        use super::pointer::PyCPointer;
+        use super::structure::PyCStructure;
+
+        // CArgObject (from byref()) should be treated as pointer
+        if self.fast_issubclass(CArgObject::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Pointer types (POINTER(T)) are always pointer FFI type
+        // Check if type is a subclass of _Pointer (PyCPointer)
+        if self.fast_issubclass(PyCPointer::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Structure types are passed as pointers
+        if self.fast_issubclass(PyCStructure::static_type()) {
+            return Ok(Type::pointer());
+        }
+
+        // Use get_attr to traverse MRO (for subclasses like MyInt(c_int))
+        let typ = self
+            .as_object()
+            .get_attr(vm.ctx.intern_str("_type_"), vm)
+            .ok()
+            .ok_or(vm.new_type_error("Unsupported argument type"))?;
+        let typ = typ
+            .downcast_ref::<PyStr>()
+            .ok_or(vm.new_type_error("Unsupported argument type"))?;
+        let typ = typ.to_string();
+        let typ = typ.as_str();
+        get_ffi_type(typ)
+            .ok_or_else(|| vm.new_type_error(format!("Unsupported argument type: {}", typ)))
+    }
+
+    fn convert_object(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<FfiArgValue> {
+        // Call from_param first to convert the value
+        // converter = PyTuple_GET_ITEM(argtypes, i);
+        // v = PyObject_CallOneArg(converter, arg);
+        let from_param = self
+            .as_object()
+            .get_attr(vm.ctx.intern_str("from_param"), vm)?;
+        let converted = from_param.call((value.clone(),), vm)?;
+
+        // Then pass the converted value to ConvParam logic
+        // CArgObject (from from_param) -> use stored value directly
+        if let Some(carg) = converted.downcast_ref::<CArgObject>() {
+            return Ok(carg.value.clone());
+        }
+
+        // None -> NULL pointer
+        if vm.is_none(&converted) {
+            return Ok(FfiArgValue::Pointer(0));
+        }
+
+        // For pointer types (POINTER(T)), we need to pass the pointer VALUE stored in buffer
+        if self.fast_issubclass(PyCPointer::static_type()) {
+            if let Some(pointer) = converted.downcast_ref::<PyCPointer>() {
+                return Ok(FfiArgValue::Pointer(pointer.get_ptr_value()));
+            }
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // For structure types, convert to pointer to structure
+        if self.fast_issubclass(PyCStructure::static_type()) {
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // Get the type code for this argument type
+        let type_code = self
+            .as_object()
+            .get_attr(vm.ctx.intern_str("_type_"), vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        // For pointer types (c_void_p, c_char_p, c_wchar_p), handle as pointer
+        if matches!(type_code.as_deref(), Some("P") | Some("z") | Some("Z")) {
+            return convert_to_pointer(&converted, vm);
+        }
+
+        // PyCSimple (already a ctypes instance from from_param)
+        if let Ok(simple) = converted.clone().downcast::<PyCSimple>() {
+            let typ = ArgumentType::to_ffi_type(self, vm)?;
+            let ffi_value = simple
+                .to_ffi_value(typ, vm)
+                .ok_or(vm.new_type_error("Unsupported argument type"))?;
+            return Ok(ffi_value);
+        }
+
+        Err(vm.new_type_error("Unsupported argument type"))
+    }
+}
+
+trait ReturnType {
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> Option<Type>;
+}
+
+impl ReturnType for PyTypeRef {
+    fn to_ffi_type(&self, vm: &VirtualMachine) -> Option<Type> {
+        // Try to get _type_ attribute first (for ctypes types like c_void_p)
+        if let Ok(type_attr) = self.as_object().get_attr(vm.ctx.intern_str("_type_"), vm)
+            && let Some(s) = type_attr.downcast_ref::<PyStr>()
+            && let Some(ffi_type) = get_ffi_type(s.as_str())
+        {
+            return Some(ffi_type);
+        }
+
+        // Check for Structure/Array types (have StgInfo but no _type_)
+        // _ctypes_get_ffi_type: returns appropriately sized type for struct returns
+        if let Some(stg_info) = self.stg_info_opt() {
+            let size = stg_info.size;
+            // Small structs can be returned in registers
+            // Match can_return_struct_as_int/can_return_struct_as_sint64
+            return Some(if size <= 4 {
+                Type::i32()
+            } else if size <= 8 {
+                Type::i64()
+            } else {
+                // Large structs: use pointer-sized return
+                // (ABI typically returns via hidden pointer parameter)
+                Type::pointer()
+            });
+        }
+
+        // Fallback to class name
+        get_ffi_type(self.name().to_string().as_str())
+    }
+}
+
+impl ReturnType for PyNone {
+    fn to_ffi_type(&self, _vm: &VirtualMachine) -> Option<Type> {
+        get_ffi_type("void")
+    }
+}
+
+// PyCFuncPtrType - Metaclass for function pointer types
+// PyCFuncPtrType_init
+
+#[pyclass(name = "PyCFuncPtrType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCFuncPtrType(PyType);
+
+impl Initializer for PyCFuncPtrType {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        new_type.check_not_initialized(vm)?;
+
+        let ptr_size = core::mem::size_of::<usize>();
+        let mut stg_info = StgInfo::new(ptr_size, ptr_size);
+        stg_info.format = Some("X{}".to_string());
+        stg_info.length = 1;
+        stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+        stg_info.paramfunc = ParamFunc::Pointer; // CFuncPtr is passed as a pointer
+
+        let _ = new_type.init_type_data(stg_info);
+        Ok(())
+    }
+}
+
+#[pyclass(flags(IMMUTABLETYPE), with(Initializer))]
+impl PyCFuncPtrType {}
+
+/// PyCFuncPtr - Function pointer instance
+/// Saved in _base.buffer
+#[pyclass(
+    module = "_ctypes",
+    name = "CFuncPtr",
+    base = PyCData,
+    metaclass = "PyCFuncPtrType"
+)]
+#[repr(C)]
+pub(super) struct PyCFuncPtr {
+    pub _base: PyCData,
+    /// Thunk for callbacks (keeps thunk alive)
+    pub thunk: PyRwLock<Option<PyRef<PyCThunk>>>,
+    /// Original Python callable (for callbacks)
+    pub callable: PyRwLock<Option<PyObjectRef>>,
+    /// Converters cache
+    pub converters: PyRwLock<Option<PyObjectRef>>,
+    /// Instance-level argtypes override
+    pub argtypes: PyRwLock<Option<PyObjectRef>>,
+    /// Instance-level restype override
+    pub restype: PyRwLock<Option<PyObjectRef>>,
+    /// Checker function
+    pub checker: PyRwLock<Option<PyObjectRef>>,
+    /// Error checking function
+    pub errcheck: PyRwLock<Option<PyObjectRef>>,
+    /// COM method vtable index
+    /// When set, the function reads the function pointer from the vtable at call time
+    #[cfg(windows)]
+    pub index: PyRwLock<Option<usize>>,
+    /// COM method IID (interface ID) for error handling
+    #[cfg(windows)]
+    pub iid: PyRwLock<Option<PyObjectRef>>,
+    /// Parameter flags for COM methods (direction: IN=1, OUT=2, IN|OUT=4)
+    /// Each element is (direction, name, default) tuple
+    pub paramflags: PyRwLock<Option<PyObjectRef>>,
+}
+
+impl Debug for PyCFuncPtr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyCFuncPtr")
+            .field("func_ptr", &self.get_func_ptr())
+            .finish()
+    }
+}
+
+/// Extract pointer value from a ctypes argument (c_void_p conversion)
+fn extract_ptr_from_arg(arg: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    // Try to get pointer value from various ctypes types
+    if let Some(ptr) = arg.downcast_ref::<PyCPointer>() {
+        return Ok(ptr.get_ptr_value());
+    }
+    if let Some(simple) = arg.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= core::mem::size_of::<usize>() {
+            return Ok(usize::from_ne_bytes(
+                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
+            ));
+        }
+    }
+    if let Some(cdata) = arg.downcast_ref::<PyCData>() {
+        // For arrays/structures, return address of buffer
+        return Ok(cdata.buffer.read().as_ptr() as usize);
+    }
+    // PyStr: return internal buffer address
+    if let Some(s) = arg.downcast_ref::<PyStr>() {
+        return Ok(s.as_str().as_ptr() as usize);
+    }
+    // PyBytes: return internal buffer address
+    if let Some(bytes) = arg.downcast_ref::<PyBytes>() {
+        return Ok(bytes.as_bytes().as_ptr() as usize);
+    }
+    // Try as integer
+    if let Ok(int_val) = arg.try_int(vm) {
+        return Ok(int_val.as_bigint().to_usize().unwrap_or(0));
+    }
+    Err(vm.new_type_error(format!(
+        "cannot convert '{}' to pointer",
+        arg.class().name()
+    )))
+}
+
+/// string_at implementation - read bytes from memory at ptr
+fn string_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
+    if ptr == 0 {
+        return Err(vm.new_value_error("NULL pointer access"));
+    }
+    let ptr = ptr as *const u8;
+    let len = if size < 0 {
+        // size == -1 means use strlen
+        unsafe { libc::strlen(ptr as _) }
+    } else {
+        // Overflow check for huge size values
+        let size_usize = size as usize;
+        if size_usize > isize::MAX as usize / 2 {
+            return Err(vm.new_overflow_error("string too long"));
+        }
+        size_usize
+    };
+    let bytes = unsafe { core::slice::from_raw_parts(ptr, len) };
+    Ok(vm.ctx.new_bytes(bytes.to_vec()).into())
+}
+
+/// wstring_at implementation - read wide string from memory at ptr
+fn wstring_at_impl(ptr: usize, size: isize, vm: &VirtualMachine) -> PyResult {
+    if ptr == 0 {
+        return Err(vm.new_value_error("NULL pointer access"));
+    }
+    let w_ptr = ptr as *const libc::wchar_t;
+    let len = if size < 0 {
+        unsafe { libc::wcslen(w_ptr) }
+    } else {
+        // Overflow check for huge size values
+        let size_usize = size as usize;
+        if size_usize > isize::MAX as usize / core::mem::size_of::<libc::wchar_t>() {
+            return Err(vm.new_overflow_error("string too long"));
+        }
+        size_usize
+    };
+    let wchars = unsafe { core::slice::from_raw_parts(w_ptr, len) };
+
+    // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
+    // macOS/Linux: wchar_t = i32 (UTF-32) -> convert via char::from_u32
+    #[cfg(windows)]
+    {
+        use rustpython_common::wtf8::Wtf8Buf;
+        let wide: Vec<u16> = wchars.to_vec();
+        let wtf8 = Wtf8Buf::from_wide(&wide);
+        Ok(vm.ctx.new_str(wtf8).into())
+    }
+    #[cfg(not(windows))]
+    {
+        let s: String = wchars
+            .iter()
+            .filter_map(|&c| char::from_u32(c as u32))
+            .collect();
+        Ok(vm.ctx.new_str(s).into())
+    }
+}
+
+// cast_check_pointertype
+fn cast_check_pointertype(ctype: &PyObject, vm: &VirtualMachine) -> bool {
+    use super::pointer::PyCPointerType;
+
+    // PyCPointerTypeObject_Check
+    if ctype.class().fast_issubclass(PyCPointerType::static_type()) {
+        return true;
+    }
+
+    // PyCFuncPtrTypeObject_Check - TODO
+
+    // simple pointer types via StgInfo.proto (c_void_p, c_char_p, etc.)
+    if let Ok(type_attr) = ctype.get_attr("_type_", vm)
+        && let Some(s) = type_attr.downcast_ref::<PyStr>()
+    {
+        let c = s.as_str();
+        if c.len() == 1 && "sPzUZXO".contains(c) {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// cast implementation
+/// _ctypes.c cast()
+pub(super) fn cast_impl(
+    obj: PyObjectRef,
+    src: PyObjectRef,
+    ctype: PyObjectRef,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // 1. cast_check_pointertype
+    if !cast_check_pointertype(&ctype, vm) {
+        return Err(vm.new_type_error(format!(
+            "cast() argument 2 must be a pointer type, not {}",
+            ctype.class().name()
+        )));
+    }
+
+    // 2. Extract pointer value - matches c_void_p_from_param_impl order
+    let ptr_value: usize = if vm.is_none(&obj) {
+        // None → NULL pointer
+        0
+    } else if let Ok(int_val) = obj.try_int(vm) {
+        // int/long → direct pointer value
+        int_val.as_bigint().to_usize().unwrap_or(0)
+    } else if let Some(bytes) = obj.downcast_ref::<PyBytes>() {
+        // bytes → buffer address (c_void_p_from_param: PyBytes_Check)
+        bytes.as_bytes().as_ptr() as usize
+    } else if let Some(s) = obj.downcast_ref::<PyStr>() {
+        // unicode/str → buffer address (c_void_p_from_param: PyUnicode_Check)
+        s.as_str().as_ptr() as usize
+    } else if let Some(ptr) = obj.downcast_ref::<PyCPointer>() {
+        // Pointer instance → contained pointer value
+        ptr.get_ptr_value()
+    } else if let Some(simple) = obj.downcast_ref::<PyCSimple>() {
+        // Simple type (c_void_p, c_char_p, etc.) → value from buffer
+        let buffer = simple.0.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    } else if let Some(cdata) = obj.downcast_ref::<PyCData>() {
+        // Array, Structure, Union → buffer address (b_ptr)
+        cdata.buffer.read().as_ptr() as usize
+    } else {
+        return Err(vm.new_type_error(format!(
+            "cast() argument 1 must be a ctypes instance, not {}",
+            obj.class().name()
+        )));
+    };
+
+    // 3. Create result instance
+    let result = ctype.call((), vm)?;
+
+    // 4. _objects reference tracking
+    // Share _objects dict between source and result, add id(src): src
+    if src.class().fast_issubclass(PyCData::static_type()) {
+        // Get the source's _objects, create dict if needed
+        let shared_objects: PyObjectRef = if let Some(src_cdata) = src.downcast_ref::<PyCData>() {
+            let mut src_objects = src_cdata.objects.write();
+            if src_objects.is_none() {
+                // Create new dict
+                let dict = vm.ctx.new_dict();
+                *src_objects = Some(dict.clone().into());
+                dict.into()
+            } else if let Some(obj) = src_objects.as_ref() {
+                if obj.downcast_ref::<PyDict>().is_none() {
+                    // Convert to dict (keep existing reference)
+                    let dict = vm.ctx.new_dict();
+                    let id_key: PyObjectRef = vm.ctx.new_int(obj.get_id() as i64).into();
+                    let _ = dict.set_item(&*id_key, obj.clone(), vm);
+                    *src_objects = Some(dict.clone().into());
+                    dict.into()
+                } else {
+                    obj.clone()
+                }
+            } else {
+                vm.ctx.new_dict().into()
+            }
+        } else {
+            vm.ctx.new_dict().into()
+        };
+
+        // Add id(src): src to the shared dict
+        if let Some(dict) = shared_objects.downcast_ref::<PyDict>() {
+            let id_key: PyObjectRef = vm.ctx.new_int(src.get_id() as i64).into();
+            let _ = dict.set_item(&*id_key, src.clone(), vm);
+        }
+
+        // Set result's _objects to the shared dict
+        if let Some(result_cdata) = result.downcast_ref::<PyCData>() {
+            *result_cdata.objects.write() = Some(shared_objects);
+        }
+    }
+
+    // 5. Store pointer value
+    if let Some(ptr) = result.downcast_ref::<PyCPointer>() {
+        ptr.set_ptr_value(ptr_value);
+    } else if let Some(cdata) = result.downcast_ref::<PyCData>() {
+        let bytes = ptr_value.to_ne_bytes();
+        let mut buffer = cdata.buffer.write();
+        let buf = buffer.to_mut();
+        if buf.len() >= bytes.len() {
+            buf[..bytes.len()].copy_from_slice(&bytes);
+        }
+    }
+
+    Ok(result)
+}
+
+impl PyCFuncPtr {
+    /// Get function pointer address from buffer
+    fn get_func_ptr(&self) -> usize {
+        let buffer = self._base.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    }
+
+    /// Get CodePtr from buffer for FFI calls
+    fn get_code_ptr(&self) -> Option<CodePtr> {
+        let addr = self.get_func_ptr();
+        if addr != 0 {
+            Some(CodePtr(addr as *mut _))
+        } else {
+            None
+        }
+    }
+
+    /// Create buffer with function pointer address
+    fn make_ptr_buffer(addr: usize) -> Vec<u8> {
+        addr.to_ne_bytes().to_vec()
+    }
+}
+
+impl Constructor for PyCFuncPtr {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Handle different argument forms:
+        // 1. Empty args: create uninitialized (NULL pointer)
+        // 2. One integer argument: function address
+        // 3. Tuple argument: (name, dll) form
+        // 4. Callable: callback creation
+
+        let ptr_size = core::mem::size_of::<usize>();
+
+        if args.args.is_empty() {
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(vec![0u8; ptr_size], None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
+        let first_arg = &args.args[0];
+
+        // Check for COM method form: (index, name, [paramflags], [iid])
+        // First arg is integer (vtable index), second arg is string (method name)
+        if args.args.len() >= 2
+            && first_arg.try_int(vm).is_ok()
+            && args.args[1].downcast_ref::<PyStr>().is_some()
+        {
+            #[cfg(windows)]
+            let index = first_arg.try_int(vm)?.as_bigint().to_usize().unwrap_or(0);
+
+            // args[3] is iid (GUID struct, optional)
+            // Also check if args[2] is a GUID (has Data1 attribute) when args[3] is not present
+            #[cfg(windows)]
+            let iid = args.args.get(3).cloned().or_else(|| {
+                args.args.get(2).and_then(|arg| {
+                    // If it's a GUID struct (has Data1 attribute), use it as IID
+                    if arg.get_attr("Data1", vm).is_ok() {
+                        Some(arg.clone())
+                    } else {
+                        None
+                    }
+                })
+            });
+
+            // args[2] is paramflags (tuple or None)
+            let paramflags = args.args.get(2).filter(|arg| !vm.is_none(arg)).cloned();
+
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(vec![0u8; ptr_size], None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(Some(index)),
+                #[cfg(windows)]
+                iid: PyRwLock::new(iid),
+                paramflags: PyRwLock::new(paramflags),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
+        // Check if first argument is an integer (function address)
+        if let Ok(addr) = first_arg.try_int(vm) {
+            let ptr_val = addr.as_bigint().to_usize().unwrap_or(0);
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
+        // Check if first argument is a tuple (name, dll) form
+        if let Some(tuple) = first_arg.downcast_ref::<PyTuple>() {
+            let name = tuple
+                .first()
+                .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
+                .downcast_ref::<PyStr>()
+                .ok_or(vm.new_type_error("Expected a string"))?
+                .to_string();
+            let dll = tuple
+                .iter()
+                .nth(1)
+                .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
+                .clone();
+
+            // Get library handle and load function
+            let handle = dll.try_int(vm);
+            let handle = match handle {
+                Ok(handle) => handle.as_bigint().clone(),
+                Err(_) => dll
+                    .get_attr("_handle", vm)?
+                    .try_int(vm)?
+                    .as_bigint()
+                    .clone(),
+            };
+            let library_cache = super::library::libcache().read();
+            let library = library_cache
+                .get_lib(
+                    handle
+                        .to_usize()
+                        .ok_or(vm.new_value_error("Invalid handle"))?,
+                )
+                .ok_or_else(|| vm.new_value_error("Library not found"))?;
+            let inner_lib = library.lib.lock();
+
+            let terminated = format!("{}\0", &name);
+            let ptr_val = if let Some(lib) = &*inner_lib {
+                let pointer: Symbol<'_, FP> = unsafe {
+                    lib.get(terminated.as_bytes())
+                        .map_err(|err| err.to_string())
+                        .map_err(|err| vm.new_attribute_error(err))?
+                };
+                let addr = *pointer as usize;
+                // dlsym can return NULL for symbols that resolve to NULL (e.g., GNU IFUNC)
+                // Treat NULL addresses as errors
+                if addr == 0 {
+                    return Err(vm.new_attribute_error(format!("function '{}' not found", name)));
+                }
+                addr
+            } else {
+                0
+            };
+
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(None),
+                callable: PyRwLock::new(None),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(None),
+                restype: PyRwLock::new(None),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
+        // Check if first argument is a Python callable (callback creation)
+        if first_arg.is_callable() {
+            // Get argument types and result type from the class
+            let class_argtypes = cls.get_attr(vm.ctx.intern_str("_argtypes_"));
+            let class_restype = cls.get_attr(vm.ctx.intern_str("_restype_"));
+            let class_flags = cls
+                .get_attr(vm.ctx.intern_str("_flags_"))
+                .and_then(|f| f.try_to_value::<u32>(vm).ok())
+                .unwrap_or(0);
+
+            // Create the thunk (C-callable wrapper for the Python function)
+            let thunk = PyCThunk::new(
+                first_arg.clone(),
+                class_argtypes.clone(),
+                class_restype.clone(),
+                class_flags,
+                vm,
+            )?;
+            let code_ptr = thunk.code_ptr();
+            let ptr_val = code_ptr.0 as usize;
+
+            // Store the thunk as a Python object to keep it alive
+            let thunk_ref: PyRef<PyCThunk> = thunk.into_ref(&vm.ctx);
+
+            return PyCFuncPtr {
+                _base: PyCData::from_bytes(Self::make_ptr_buffer(ptr_val), None),
+                thunk: PyRwLock::new(Some(thunk_ref)),
+                callable: PyRwLock::new(Some(first_arg.clone())),
+                converters: PyRwLock::new(None),
+                argtypes: PyRwLock::new(class_argtypes),
+                restype: PyRwLock::new(class_restype),
+                checker: PyRwLock::new(None),
+                errcheck: PyRwLock::new(None),
+                #[cfg(windows)]
+                index: PyRwLock::new(None),
+                #[cfg(windows)]
+                iid: PyRwLock::new(None),
+                paramflags: PyRwLock::new(None),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into);
+        }
+
+        Err(vm.new_type_error("Expected an integer address or a tuple"))
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+// PyCFuncPtr call helpers (similar to callproc.c flow)
+
+/// Handle internal function addresses (PYFUNCTYPE special cases)
+/// Returns Some(result) if handled, None if should continue with normal call
+fn handle_internal_func(addr: usize, args: &FuncArgs, vm: &VirtualMachine) -> Option<PyResult> {
+    if addr == INTERNAL_CAST_ADDR {
+        let result: PyResult<(PyObjectRef, PyObjectRef, PyObjectRef)> = args.clone().bind(vm);
+        return Some(result.and_then(|(obj, src, ctype)| cast_impl(obj, src, ctype, vm)));
+    }
+
+    if addr == INTERNAL_STRING_AT_ADDR {
+        let result: PyResult<(PyObjectRef, Option<PyObjectRef>)> = args.clone().bind(vm);
+        return Some(result.and_then(|(ptr_arg, size_arg)| {
+            let ptr = extract_ptr_from_arg(&ptr_arg, vm)?;
+            let size = size_arg
+                .and_then(|s| s.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_isize())
+                .unwrap_or(-1);
+            string_at_impl(ptr, size, vm)
+        }));
+    }
+
+    if addr == INTERNAL_WSTRING_AT_ADDR {
+        let result: PyResult<(PyObjectRef, Option<PyObjectRef>)> = args.clone().bind(vm);
+        return Some(result.and_then(|(ptr_arg, size_arg)| {
+            let ptr = extract_ptr_from_arg(&ptr_arg, vm)?;
+            let size = size_arg
+                .and_then(|s| s.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_isize())
+                .unwrap_or(-1);
+            wstring_at_impl(ptr, size, vm)
+        }));
+    }
+
+    None
+}
+
+/// Call information extracted from PyCFuncPtr (argtypes, restype, etc.)
+struct CallInfo {
+    explicit_arg_types: Option<Vec<PyTypeRef>>,
+    restype_obj: Option<PyObjectRef>,
+    restype_is_none: bool,
+    ffi_return_type: Type,
+    is_pointer_return: bool,
+}
+
+/// Extract call information (argtypes, restype) from PyCFuncPtr
+fn extract_call_info(zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> PyResult<CallInfo> {
+    // Get argtypes - first from instance, then from type's _argtypes_
+    let explicit_arg_types: Option<Vec<PyTypeRef>> =
+        if let Some(argtypes_obj) = zelf.argtypes.read().as_ref() {
+            if !vm.is_none(argtypes_obj) {
+                Some(
+                    argtypes_obj
+                        .try_to_value::<Vec<PyObjectRef>>(vm)?
+                        .into_iter()
+                        .filter_map(|obj| obj.downcast::<PyType>().ok())
+                        .collect(),
+                )
+            } else {
+                None // argtypes is None -> use ConvParam
+            }
+        } else if let Some(class_argtypes) = zelf
+            .as_object()
+            .class()
+            .get_attr(vm.ctx.intern_str("_argtypes_"))
+            && !vm.is_none(&class_argtypes)
+        {
+            Some(
+                class_argtypes
+                    .try_to_value::<Vec<PyObjectRef>>(vm)?
+                    .into_iter()
+                    .filter_map(|obj| obj.downcast::<PyType>().ok())
+                    .collect(),
+            )
+        } else {
+            None // No argtypes -> use ConvParam
+        };
+
+    // Get restype - first from instance, then from class's _restype_
+    let restype_obj = zelf.restype.read().clone().or_else(|| {
+        zelf.as_object()
+            .class()
+            .get_attr(vm.ctx.intern_str("_restype_"))
+    });
+
+    // Check if restype is explicitly None (return void)
+    let restype_is_none = restype_obj.as_ref().is_some_and(|t| vm.is_none(t));
+    let ffi_return_type = if restype_is_none {
+        Type::void()
+    } else {
+        restype_obj
+            .as_ref()
+            .and_then(|t| t.clone().downcast::<PyType>().ok())
+            .and_then(|t| ReturnType::to_ffi_type(&t, vm))
+            .unwrap_or_else(Type::i32)
+    };
+
+    // Check if return type is a pointer type via TYPEFLAG_ISPOINTER
+    // This handles c_void_p, c_char_p, c_wchar_p, and POINTER(T) types
+    let is_pointer_return = restype_obj
+        .as_ref()
+        .and_then(|t| t.clone().downcast::<PyType>().ok())
+        .and_then(|t| {
+            t.stg_info_opt()
+                .map(|info| info.flags.contains(StgInfoFlags::TYPEFLAG_ISPOINTER))
+        })
+        .unwrap_or(false);
+
+    Ok(CallInfo {
+        explicit_arg_types,
+        restype_obj,
+        restype_is_none,
+        ffi_return_type,
+        is_pointer_return,
+    })
+}
+
+/// Parsed paramflags: (direction, name, default) tuples
+/// direction: 1=IN, 2=OUT, 4=IN|OUT (or 1|2=3)
+type ParsedParamFlags = Vec<(u32, Option<String>, Option<PyObjectRef>)>;
+
+/// Parse paramflags from PyCFuncPtr
+fn parse_paramflags(
+    zelf: &Py<PyCFuncPtr>,
+    vm: &VirtualMachine,
+) -> PyResult<Option<ParsedParamFlags>> {
+    let Some(pf) = zelf.paramflags.read().as_ref().cloned() else {
+        return Ok(None);
+    };
+
+    let pf_vec = pf.try_to_value::<Vec<PyObjectRef>>(vm)?;
+    let parsed = pf_vec
+        .into_iter()
+        .map(|item| {
+            let Some(tuple) = item.downcast_ref::<PyTuple>() else {
+                // Single value means just the direction
+                let direction = item
+                    .try_int(vm)
+                    .ok()
+                    .and_then(|i| i.as_bigint().to_u32())
+                    .unwrap_or(1);
+                return (direction, None, None);
+            };
+            let direction = tuple
+                .first()
+                .and_then(|d| d.try_int(vm).ok())
+                .and_then(|i| i.as_bigint().to_u32())
+                .unwrap_or(1);
+            let name = tuple
+                .get(1)
+                .and_then(|n| n.downcast_ref::<PyStr>().map(|s| s.to_string()));
+            let default = tuple.get(2).cloned();
+            (direction, name, default)
+        })
+        .collect();
+    Ok(Some(parsed))
+}
+
+/// Resolve COM method pointer from vtable (Windows only)
+/// Returns (Some(CodePtr), true) if this is a COM method call, (None, false) otherwise
+#[cfg(windows)]
+fn resolve_com_method(
+    zelf: &Py<PyCFuncPtr>,
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult<(Option<CodePtr>, bool)> {
+    let com_index = zelf.index.read();
+    let Some(idx) = *com_index else {
+        return Ok((None, false));
+    };
+
+    // First arg must be the COM object pointer
+    if args.args.is_empty() {
+        return Err(
+            vm.new_type_error("COM method requires at least one argument (self)".to_string())
+        );
+    }
+
+    // Extract COM pointer value from first argument
+    let self_arg = &args.args[0];
+    let com_ptr = if let Some(simple) = self_arg.downcast_ref::<PyCSimple>() {
+        let buffer = simple.0.buffer.read();
+        if buffer.len() >= std::mem::size_of::<usize>() {
+            super::base::read_ptr_from_buffer(&buffer)
+        } else {
+            0
+        }
+    } else if let Ok(int_val) = self_arg.try_int(vm) {
+        int_val.as_bigint().to_usize().unwrap_or(0)
+    } else {
+        return Err(
+            vm.new_type_error("COM method first argument must be a COM pointer".to_string())
+        );
+    };
+
+    if com_ptr == 0 {
+        return Err(vm.new_value_error("NULL COM pointer access"));
+    }
+
+    // Read vtable pointer from COM object: vtable = *(void**)com_ptr
+    let vtable_ptr = unsafe { *(com_ptr as *const usize) };
+    if vtable_ptr == 0 {
+        return Err(vm.new_value_error("NULL vtable pointer"));
+    }
+
+    // Read function pointer from vtable: func = vtable[index]
+    let fptr = unsafe {
+        let vtable = vtable_ptr as *const usize;
+        *vtable.add(idx)
+    };
+
+    if fptr == 0 {
+        return Err(vm.new_value_error("NULL function pointer in vtable"));
+    }
+
+    Ok((Some(CodePtr(fptr as *mut _)), true))
+}
+
+/// Single argument for FFI call
+// struct argument
+struct Argument {
+    ffi_type: Type,
+    value: FfiArgValue,
+    #[allow(dead_code)]
+    keep: Option<PyObjectRef>, // Object to keep alive during call
+}
+
+/// Out buffers for paramflags OUT parameters
+type OutBuffers = Vec<(usize, PyObjectRef)>;
+
+/// Get buffer address from a ctypes object
+fn get_buffer_addr(obj: &PyObjectRef) -> Option<usize> {
+    obj.downcast_ref::<PyCSimple>()
+        .map(|s| s.0.buffer.read().as_ptr() as usize)
+        .or_else(|| {
+            obj.downcast_ref::<super::structure::PyCStructure>()
+                .map(|s| s.0.buffer.read().as_ptr() as usize)
+        })
+        .or_else(|| {
+            obj.downcast_ref::<PyCPointer>()
+                .map(|s| s.0.buffer.read().as_ptr() as usize)
+        })
+}
+
+/// Create OUT buffer for a parameter type
+fn create_out_buffer(arg_type: &PyTypeRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    // For POINTER(T) types, create T instance (the pointed-to type)
+    if arg_type.fast_issubclass(PyCPointer::static_type())
+        && let Some(stg_info) = arg_type.stg_info_opt()
+        && let Some(ref proto) = stg_info.proto
+    {
+        return proto.as_object().call((), vm);
+    }
+    // Not a pointer type or no proto, create instance directly
+    arg_type.as_object().call((), vm)
+}
+
+/// Build callargs when no argtypes specified (use ConvParam)
+fn build_callargs_no_argtypes(
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let arguments: Vec<Argument> = args
+        .args
+        .iter()
+        .map(|arg| conv_param(arg, vm))
+        .collect::<PyResult<Vec<_>>>()?;
+    Ok((arguments, Vec::new()))
+}
+
+/// Build callargs for regular function with argtypes (no paramflags)
+fn build_callargs_simple(
+    args: &FuncArgs,
+    arg_types: &[PyTypeRef],
+    vm: &VirtualMachine,
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let arguments: Vec<Argument> = args
+        .args
+        .iter()
+        .enumerate()
+        .map(|(n, arg)| {
+            let arg_type = arg_types
+                .get(n)
+                .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
+            let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+            let value = arg_type.convert_object(arg.clone(), vm)?;
+            Ok(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            })
+        })
+        .collect::<PyResult<Vec<_>>>()?;
+    Ok((arguments, Vec::new()))
+}
+
+/// Build callargs with paramflags (handles IN/OUT parameters)
+fn build_callargs_with_paramflags(
+    args: &FuncArgs,
+    arg_types: &[PyTypeRef],
+    paramflags: &ParsedParamFlags,
+    skip_first_arg: bool, // true for COM methods
+    vm: &VirtualMachine,
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let mut arguments = Vec::new();
+    let mut out_buffers = Vec::new();
+
+    // For COM methods, first arg is self (pointer)
+    let mut caller_arg_idx = if skip_first_arg {
+        if !args.args.is_empty() {
+            let arg = conv_param(&args.args[0], vm)?;
+            arguments.push(arg);
+        }
+        1usize
+    } else {
+        0usize
+    };
+
+    // Process parameters based on paramflags
+    for (param_idx, (direction, _name, default)) in paramflags.iter().enumerate() {
+        let arg_type = arg_types
+            .get(param_idx)
+            .ok_or_else(|| vm.new_type_error("paramflags/argtypes mismatch"))?;
+
+        let is_out = (*direction & 2) != 0; // OUT flag
+        let is_in = (*direction & 1) != 0 || *direction == 0; // IN flag or default
+
+        let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+
+        if is_out && !is_in {
+            // Pure OUT parameter: create buffer, don't consume caller arg
+            let buffer = create_out_buffer(arg_type, vm)?;
+            let addr = get_buffer_addr(&buffer).ok_or_else(|| {
+                vm.new_type_error("Cannot create OUT buffer for this type".to_string())
+            })?;
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value: FfiArgValue::Pointer(addr),
+            });
+            out_buffers.push((param_idx, buffer));
+        } else {
+            // IN or IN|OUT: get from caller args or default
+            let arg = if caller_arg_idx < args.args.len() {
+                caller_arg_idx += 1;
+                args.args[caller_arg_idx - 1].clone()
+            } else if let Some(def) = default {
+                def.clone()
+            } else {
+                return Err(vm.new_type_error(format!("required argument {} missing", param_idx)));
+            };
+
+            if is_out {
+                // IN|OUT: track for return
+                out_buffers.push((param_idx, arg.clone()));
+            }
+            let value = arg_type.convert_object(arg, vm)?;
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            });
+        }
+    }
+
+    Ok((arguments, out_buffers))
+}
+
+/// Build call arguments (main dispatcher)
+fn build_callargs(
+    args: &FuncArgs,
+    call_info: &CallInfo,
+    paramflags: Option<&ParsedParamFlags>,
+    is_com_method: bool,
+    vm: &VirtualMachine,
+) -> PyResult<(Vec<Argument>, OutBuffers)> {
+    let Some(ref arg_types) = call_info.explicit_arg_types else {
+        // No argtypes: use ConvParam
+        return build_callargs_no_argtypes(args, vm);
+    };
+
+    if let Some(pflags) = paramflags {
+        // Has paramflags: handle IN/OUT
+        build_callargs_with_paramflags(args, arg_types, pflags, is_com_method, vm)
+    } else if is_com_method {
+        // COM method without paramflags
+        let mut arguments = Vec::new();
+        if !args.args.is_empty() {
+            arguments.push(conv_param(&args.args[0], vm)?);
+        }
+        for (n, arg) in args.args.iter().skip(1).enumerate() {
+            let arg_type = arg_types
+                .get(n)
+                .ok_or_else(|| vm.new_type_error("argument amount mismatch"))?;
+            let ffi_type = ArgumentType::to_ffi_type(arg_type, vm)?;
+            let value = arg_type.convert_object(arg.clone(), vm)?;
+            arguments.push(Argument {
+                ffi_type,
+                keep: None,
+                value,
+            });
+        }
+        Ok((arguments, Vec::new()))
+    } else {
+        // Regular function
+        build_callargs_simple(args, arg_types, vm)
+    }
+}
+
+/// Raw result from FFI call
+enum RawResult {
+    Void,
+    Pointer(usize),
+    Value(libffi::low::ffi_arg),
+}
+
+/// Execute FFI call
+fn ctypes_callproc(code_ptr: CodePtr, arguments: &[Argument], call_info: &CallInfo) -> RawResult {
+    let ffi_arg_types: Vec<Type> = arguments.iter().map(|a| a.ffi_type.clone()).collect();
+    let cif = Cif::new(ffi_arg_types, call_info.ffi_return_type.clone());
+    let ffi_args: Vec<Arg<'_>> = arguments.iter().map(|a| a.value.as_arg()).collect();
+
+    if call_info.restype_is_none {
+        unsafe { cif.call::<()>(code_ptr, &ffi_args) };
+        RawResult::Void
+    } else if call_info.is_pointer_return {
+        let result = unsafe { cif.call::<usize>(code_ptr, &ffi_args) };
+        RawResult::Pointer(result)
+    } else {
+        let result = unsafe { cif.call::<libffi::low::ffi_arg>(code_ptr, &ffi_args) };
+        RawResult::Value(result)
+    }
+}
+
+/// Check and handle HRESULT errors (Windows)
+#[cfg(windows)]
+fn check_hresult(hresult: i32, zelf: &Py<PyCFuncPtr>, vm: &VirtualMachine) -> PyResult<()> {
+    if hresult >= 0 {
+        return Ok(());
+    }
+
+    if zelf.iid.read().is_some() {
+        // Raise COMError
+        let ctypes_module = vm.import("_ctypes", 0)?;
+        let com_error_type = ctypes_module.get_attr("COMError", vm)?;
+        let com_error_type = com_error_type
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("COMError is not a type"))?;
+        let hresult_obj: PyObjectRef = vm.ctx.new_int(hresult).into();
+        let text: PyObjectRef = vm
+            .ctx
+            .new_str(format!("HRESULT: 0x{:08X}", hresult as u32))
+            .into();
+        let details: PyObjectRef = vm.ctx.none();
+        let exc = vm.invoke_exception(
+            com_error_type.to_owned(),
+            vec![text.clone(), details.clone()],
+        )?;
+        let _ = exc.as_object().set_attr("hresult", hresult_obj, vm);
+        let _ = exc.as_object().set_attr("text", text, vm);
+        let _ = exc.as_object().set_attr("details", details, vm);
+        Err(exc)
+    } else {
+        // Raise OSError
+        let exc = vm.new_os_error(format!("HRESULT: 0x{:08X}", hresult as u32));
+        let _ = exc
+            .as_object()
+            .set_attr("winerror", vm.ctx.new_int(hresult), vm);
+        Err(exc)
+    }
+}
+
+/// Convert raw FFI result to Python object
+// = GetResult
+fn convert_raw_result(
+    raw_result: &mut RawResult,
+    call_info: &CallInfo,
+    vm: &VirtualMachine,
+) -> Option<PyObjectRef> {
+    // Get result as bytes for type conversion
+    let (result_bytes, result_size) = match raw_result {
+        RawResult::Void => return None,
+        RawResult::Pointer(ptr) => {
+            let bytes = ptr.to_ne_bytes();
+            (bytes.to_vec(), core::mem::size_of::<usize>())
+        }
+        RawResult::Value(val) => {
+            let bytes = val.to_ne_bytes();
+            (bytes.to_vec(), core::mem::size_of::<i64>())
+        }
+    };
+
+    // 1. No restype → return as int
+    let restype = match &call_info.restype_obj {
+        None => {
+            // Default: return as int
+            let val = match raw_result {
+                RawResult::Pointer(p) => *p as isize,
+                RawResult::Value(v) => *v as isize,
+                RawResult::Void => return None,
+            };
+            return Some(vm.ctx.new_int(val).into());
+        }
+        Some(r) => r,
+    };
+
+    // 2. restype is None → return None
+    if restype.is(&vm.ctx.none()) {
+        return None;
+    }
+
+    // 3. Get restype as PyType
+    let restype_type = match restype.clone().downcast::<PyType>() {
+        Ok(t) => t,
+        Err(_) => {
+            // Not a type, call it with int result
+            let val = match raw_result {
+                RawResult::Pointer(p) => *p as isize,
+                RawResult::Value(v) => *v as isize,
+                RawResult::Void => return None,
+            };
+            return restype.call((val,), vm).ok();
+        }
+    };
+
+    // 4. Get StgInfo
+    let stg_info = restype_type.stg_info_opt();
+
+    // No StgInfo → call restype with int
+    if stg_info.is_none() {
+        let val = match raw_result {
+            RawResult::Pointer(p) => *p as isize,
+            RawResult::Value(v) => *v as isize,
+            RawResult::Void => return None,
+        };
+        return restype_type.as_object().call((val,), vm).ok();
+    }
+
+    let info = stg_info.unwrap();
+
+    // 5. Simple type with getfunc → use bytes_to_pyobject (info->getfunc)
+    // is_simple_instance returns TRUE for c_int, c_void_p, etc.
+    if super::base::is_simple_instance(&restype_type) {
+        return super::base::bytes_to_pyobject(&restype_type, &result_bytes, vm).ok();
+    }
+
+    // 6. Complex type → create ctypes instance (PyCData_FromBaseObj)
+    // This handles POINTER(T), Structure, Array, etc.
+
+    // Special handling for POINTER(T) types - set pointer value directly
+    if info.flags.contains(StgInfoFlags::TYPEFLAG_ISPOINTER)
+        && info.proto.is_some()
+        && let RawResult::Pointer(ptr) = raw_result
+        && let Ok(instance) = restype_type.as_object().call((), vm)
+    {
+        if let Some(pointer) = instance.downcast_ref::<PyCPointer>() {
+            pointer.set_ptr_value(*ptr);
+        }
+        return Some(instance);
+    }
+
+    // Create instance and copy result data
+    pycdata_from_ffi_result(&restype_type, &result_bytes, result_size, vm).ok()
+}
+
+/// Create a ctypes instance from FFI result (PyCData_FromBaseObj equivalent)
+fn pycdata_from_ffi_result(
+    typ: &PyTypeRef,
+    result_bytes: &[u8],
+    size: usize,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // Create instance
+    let instance = PyType::call(typ, ().into(), vm)?;
+
+    // Copy result data into instance buffer
+    if let Some(cdata) = instance.downcast_ref::<PyCData>() {
+        let mut buffer = cdata.buffer.write();
+        let copy_size = size.min(buffer.len()).min(result_bytes.len());
+        if copy_size > 0 {
+            buffer.to_mut()[..copy_size].copy_from_slice(&result_bytes[..copy_size]);
+        }
+    }
+
+    Ok(instance)
+}
+
+/// Extract values from OUT buffers
+fn extract_out_values(
+    out_buffers: Vec<(usize, PyObjectRef)>,
+    vm: &VirtualMachine,
+) -> Vec<PyObjectRef> {
+    out_buffers
+        .into_iter()
+        .map(|(_, buffer)| buffer.get_attr("value", vm).unwrap_or(buffer))
+        .collect()
+}
+
+/// Build final result (main function)
+fn build_result(
+    mut raw_result: RawResult,
+    call_info: &CallInfo,
+    out_buffers: OutBuffers,
+    zelf: &Py<PyCFuncPtr>,
+    args: &FuncArgs,
+    vm: &VirtualMachine,
+) -> PyResult {
+    // Check HRESULT on Windows
+    #[cfg(windows)]
+    if let RawResult::Value(val) = raw_result {
+        let is_hresult = call_info
+            .restype_obj
+            .as_ref()
+            .and_then(|t| t.clone().downcast::<PyType>().ok())
+            .is_some_and(|t| t.name().to_string() == "HRESULT");
+        if is_hresult {
+            check_hresult(val as i32, zelf, vm)?;
+        }
+    }
+
+    // Convert raw result to Python object
+    let mut result = convert_raw_result(&mut raw_result, call_info, vm);
+
+    // Apply errcheck if set
+    if let Some(errcheck) = zelf.errcheck.read().as_ref() {
+        let args_tuple = PyTuple::new_ref(args.args.clone(), &vm.ctx);
+        let func_obj = zelf.as_object().to_owned();
+        let result_obj = result.clone().unwrap_or_else(|| vm.ctx.none());
+        result = Some(errcheck.call((result_obj, func_obj, args_tuple), vm)?);
+    }
+
+    // Handle OUT parameter return values
+    if out_buffers.is_empty() {
+        return result.map(Ok).unwrap_or_else(|| Ok(vm.ctx.none()));
+    }
+
+    let out_values = extract_out_values(out_buffers, vm);
+    Ok(match <[PyObjectRef; 1]>::try_from(out_values) {
+        Ok([single]) => single,
+        Err(v) => PyTuple::new_ref(v, &vm.ctx).into(),
+    })
+}
+
+impl Callable for PyCFuncPtr {
+    type Args = FuncArgs;
+    fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        // 1. Check for internal PYFUNCTYPE addresses
+        if let Some(result) = handle_internal_func(zelf.get_func_ptr(), &args, vm) {
+            return result;
+        }
+
+        // 2. Resolve function pointer (COM or direct)
+        #[cfg(windows)]
+        let (func_ptr, is_com_method) = resolve_com_method(zelf, &args, vm)?;
+        #[cfg(not(windows))]
+        let (func_ptr, is_com_method) = (None::<CodePtr>, false);
+
+        // 3. Extract call info (argtypes, restype)
+        let call_info = extract_call_info(zelf, vm)?;
+
+        // 4. Parse paramflags
+        let paramflags = parse_paramflags(zelf, vm)?;
+
+        // 5. Build call arguments
+        let (arguments, out_buffers) =
+            build_callargs(&args, &call_info, paramflags.as_ref(), is_com_method, vm)?;
+
+        // 6. Get code pointer
+        let code_ptr = match func_ptr.or_else(|| zelf.get_code_ptr()) {
+            Some(cp) => cp,
+            None => {
+                debug_assert!(false, "NULL function pointer");
+                // In release mode, this will crash
+                CodePtr(core::ptr::null_mut())
+            }
+        };
+
+        // 7. Get flags to check for use_last_error/use_errno
+        let flags = PyCFuncPtr::_flags_(zelf, vm);
+
+        // 8. Call the function (with use_last_error/use_errno handling)
+        #[cfg(not(windows))]
+        let raw_result = {
+            if flags & super::base::StgInfoFlags::FUNCFLAG_USE_ERRNO.bits() != 0 {
+                swap_errno(|| ctypes_callproc(code_ptr, &arguments, &call_info))
+            } else {
+                ctypes_callproc(code_ptr, &arguments, &call_info)
+            }
+        };
+
+        #[cfg(windows)]
+        let raw_result = {
+            if flags & super::base::StgInfoFlags::FUNCFLAG_USE_LASTERROR.bits() != 0 {
+                save_and_restore_last_error(|| ctypes_callproc(code_ptr, &arguments, &call_info))
+            } else {
+                ctypes_callproc(code_ptr, &arguments, &call_info)
+            }
+        };
+
+        // 9. Build result
+        build_result(raw_result, &call_info, out_buffers, zelf, &args, vm)
+    }
+}
+
+// PyCFuncPtr_repr
+impl Representable for PyCFuncPtr {
+    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+        let type_name = zelf.class().name();
+        // Use object id, not function pointer address
+        let addr = zelf.get_id();
+        Ok(format!("<{} object at {:#x}>", type_name, addr))
+    }
+}
+
+// PyCData_NewGetBuffer
+impl AsBuffer for PyCFuncPtr {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        // CFuncPtr types may not have StgInfo if PyCFuncPtrType metaclass is not used
+        // Use default values for function pointers: format="X{}", size=sizeof(pointer)
+        let (format, itemsize) = if let Some(stg_info) = zelf.class().stg_info_opt() {
+            (
+                stg_info
+                    .format
+                    .clone()
+                    .map(Cow::Owned)
+                    .unwrap_or(Cow::Borrowed("X{}")),
+                stg_info.size,
+            )
+        } else {
+            (Cow::Borrowed("X{}"), core::mem::size_of::<usize>())
+        };
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE),
+    with(Callable, Constructor, AsNumber, Representable, AsBuffer)
+)]
+impl PyCFuncPtr {
+    // restype getter/setter
+    #[pygetset]
+    fn restype(&self) -> Option<PyObjectRef> {
+        self.restype.read().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set_restype(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Must be type, callable, or None
+        if vm.is_none(&value) {
+            *self.restype.write() = None;
+        } else if value.downcast_ref::<PyType>().is_some() || value.is_callable() {
+            *self.restype.write() = Some(value);
+        } else {
+            return Err(vm.new_type_error("restype must be a type, a callable, or None"));
+        }
+        Ok(())
+    }
+
+    // argtypes getter/setter
+    #[pygetset]
+    fn argtypes(&self, vm: &VirtualMachine) -> PyObjectRef {
+        self.argtypes
+            .read()
+            .clone()
+            .unwrap_or_else(|| vm.ctx.empty_tuple.clone().into())
+    }
+
+    #[pygetset(name = "argtypes", setter)]
+    fn set_argtypes(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.is_none(&value) {
+            *self.argtypes.write() = None;
+        } else {
+            // Store the argtypes object directly as it is
+            *self.argtypes.write() = Some(value);
+        }
+        Ok(())
+    }
+
+    // errcheck getter/setter
+    #[pygetset]
+    fn errcheck(&self) -> Option<PyObjectRef> {
+        self.errcheck.read().clone()
+    }
+
+    #[pygetset(setter)]
+    fn set_errcheck(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        if vm.is_none(&value) {
+            *self.errcheck.write() = None;
+        } else if value.is_callable() {
+            *self.errcheck.write() = Some(value);
+        } else {
+            return Err(vm.new_type_error("errcheck must be a callable or None"));
+        }
+        Ok(())
+    }
+
+    // _flags_ getter (read-only, from type's class attribute or StgInfo)
+    #[pygetset]
+    fn _flags_(zelf: &Py<Self>, vm: &VirtualMachine) -> u32 {
+        // First try to get _flags_ from type's class attribute (for dynamically created types)
+        // This is how CDLL sets use_errno: class _FuncPtr(_CFuncPtr): _flags_ = flags
+        if let Ok(flags_attr) = zelf.class().as_object().get_attr("_flags_", vm)
+            && let Ok(flags_int) = flags_attr.try_to_value::<u32>(vm)
+        {
+            return flags_int;
+        }
+
+        // Fallback to StgInfo for native types
+        zelf.class()
+            .stg_info_opt()
+            .map(|stg| stg.flags.bits())
+            .unwrap_or(StgInfoFlags::empty().bits())
+    }
+}
+
+impl AsNumber for PyCFuncPtr {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyCFuncPtr>().unwrap();
+                Ok(zelf.get_func_ptr() != 0)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+// CThunkObject - FFI callback (thunk) implementation
+
+/// Userdata passed to the libffi callback.
+struct ThunkUserData {
+    /// The Python callable to invoke
+    callable: PyObjectRef,
+    /// Argument types for conversion
+    arg_types: Vec<PyTypeRef>,
+    /// Result type for conversion (None means void)
+    pub res_type: Option<PyTypeRef>,
+    /// Function flags (FUNCFLAG_USE_ERRNO, etc.)
+    pub flags: u32,
+}
+
+/// Check if ty is a subclass of a simple type (like MyInt(c_int)).
+fn is_simple_subclass(ty: &Py<PyType>, vm: &VirtualMachine) -> bool {
+    let Ok(base) = ty.as_object().get_attr(vm.ctx.intern_str("__base__"), vm) else {
+        return false;
+    };
+    base.get_attr(vm.ctx.intern_str("_type_"), vm).is_ok()
+}
+
+/// Convert a C value to a Python object based on the type code.
+fn ffi_to_python(ty: &Py<PyType>, ptr: *const c_void, vm: &VirtualMachine) -> PyObjectRef {
+    let type_code = ty.type_code(vm);
+    let raw_value: PyObjectRef = unsafe {
+        match type_code.as_deref() {
+            Some("b") => vm.ctx.new_int(*(ptr as *const i8) as i32).into(),
+            Some("B") => vm.ctx.new_int(*(ptr as *const u8) as i32).into(),
+            Some("c") => vm.ctx.new_bytes(vec![*(ptr as *const u8)]).into(),
+            Some("h") => vm.ctx.new_int(*(ptr as *const i16) as i32).into(),
+            Some("H") => vm.ctx.new_int(*(ptr as *const u16) as i32).into(),
+            Some("i") => vm.ctx.new_int(*(ptr as *const i32)).into(),
+            Some("I") => vm.ctx.new_int(*(ptr as *const u32)).into(),
+            Some("l") => vm.ctx.new_int(*(ptr as *const libc::c_long)).into(),
+            Some("L") => vm.ctx.new_int(*(ptr as *const libc::c_ulong)).into(),
+            Some("q") => vm.ctx.new_int(*(ptr as *const libc::c_longlong)).into(),
+            Some("Q") => vm.ctx.new_int(*(ptr as *const libc::c_ulonglong)).into(),
+            Some("f") => vm.ctx.new_float(*(ptr as *const f32) as f64).into(),
+            Some("d") => vm.ctx.new_float(*(ptr as *const f64)).into(),
+            Some("z") => {
+                // c_char_p: C string pointer → Python bytes
+                let cstr_ptr = *(ptr as *const *const libc::c_char);
+                if cstr_ptr.is_null() {
+                    vm.ctx.none()
+                } else {
+                    let cstr = core::ffi::CStr::from_ptr(cstr_ptr);
+                    vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into()
+                }
+            }
+            Some("Z") => {
+                // c_wchar_p: wchar_t* → Python str
+                let wstr_ptr = *(ptr as *const *const libc::wchar_t);
+                if wstr_ptr.is_null() {
+                    vm.ctx.none()
+                } else {
+                    let mut len = 0;
+                    while *wstr_ptr.add(len) != 0 {
+                        len += 1;
+                    }
+                    let slice = core::slice::from_raw_parts(wstr_ptr, len);
+                    // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide
+                    // Unix: wchar_t = i32 (UTF-32) -> convert via char::from_u32
+                    #[cfg(windows)]
+                    {
+                        use rustpython_common::wtf8::Wtf8Buf;
+                        let wide: Vec<u16> = slice.to_vec();
+                        let wtf8 = Wtf8Buf::from_wide(&wide);
+                        vm.ctx.new_str(wtf8).into()
+                    }
+                    #[cfg(not(windows))]
+                    {
+                        let s: String = slice
+                            .iter()
+                            .filter_map(|&c| char::from_u32(c as u32))
+                            .collect();
+                        vm.ctx.new_str(s).into()
+                    }
+                }
+            }
+            Some("P") => vm.ctx.new_int(*(ptr as *const usize)).into(),
+            Some("?") => vm.ctx.new_bool(*(ptr as *const u8) != 0).into(),
+            _ => return vm.ctx.none(),
+        }
+    };
+
+    if !is_simple_subclass(ty, vm) {
+        return raw_value;
+    }
+    ty.as_object()
+        .call((raw_value.clone(),), vm)
+        .unwrap_or(raw_value)
+}
+
+/// Convert a Python object to a C value and store it at the result pointer
+fn python_to_ffi(obj: PyResult, ty: &Py<PyType>, result: *mut c_void, vm: &VirtualMachine) {
+    let Ok(obj) = obj else { return };
+
+    let type_code = ty.type_code(vm);
+    unsafe {
+        match type_code.as_deref() {
+            Some("b") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i8) = i.as_bigint().to_i8().unwrap_or(0);
+                }
+            }
+            Some("B") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
+                }
+            }
+            Some("c") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u8) = i.as_bigint().to_u8().unwrap_or(0);
+                }
+            }
+            Some("h") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i16) = i.as_bigint().to_i16().unwrap_or(0);
+                }
+            }
+            Some("H") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u16) = i.as_bigint().to_u16().unwrap_or(0);
+                }
+            }
+            Some("i") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    let val = i.as_bigint().to_i32().unwrap_or(0);
+                    *(result as *mut libffi::low::ffi_arg) = val as libffi::low::ffi_arg;
+                }
+            }
+            Some("I") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u32) = i.as_bigint().to_u32().unwrap_or(0);
+                }
+            }
+            Some("l") | Some("q") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut i64) = i.as_bigint().to_i64().unwrap_or(0);
+                }
+            }
+            Some("L") | Some("Q") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut u64) = i.as_bigint().to_u64().unwrap_or(0);
+                }
+            }
+            Some("f") => {
+                if let Ok(f) = obj.try_float(vm) {
+                    *(result as *mut f32) = f.to_f64() as f32;
+                }
+            }
+            Some("d") => {
+                if let Ok(f) = obj.try_float(vm) {
+                    *(result as *mut f64) = f.to_f64();
+                }
+            }
+            Some("P") | Some("z") | Some("Z") => {
+                if let Ok(i) = obj.try_int(vm) {
+                    *(result as *mut usize) = i.as_bigint().to_usize().unwrap_or(0);
+                }
+            }
+            Some("?") => {
+                if let Ok(b) = obj.is_true(vm) {
+                    *(result as *mut u8) = u8::from(b);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+/// The callback function that libffi calls when the closure is invoked.
+unsafe extern "C" fn thunk_callback(
+    _cif: &low::ffi_cif,
+    result: &mut c_void,
+    args: *const *const c_void,
+    userdata: &ThunkUserData,
+) {
+    with_current_vm(|vm| {
+        // Swap errno before call if FUNCFLAG_USE_ERRNO is set
+        let use_errno = userdata.flags & StgInfoFlags::FUNCFLAG_USE_ERRNO.bits() != 0;
+        let saved_errno = if use_errno {
+            let current = rustpython_common::os::get_errno();
+            // TODO: swap with ctypes stored errno (thread-local)
+            Some(current)
+        } else {
+            None
+        };
+
+        let py_args: Vec<PyObjectRef> = userdata
+            .arg_types
+            .iter()
+            .enumerate()
+            .map(|(i, ty)| {
+                let arg_ptr = unsafe { *args.add(i) };
+                ffi_to_python(ty, arg_ptr, vm)
+            })
+            .collect();
+
+        let py_result = userdata.callable.call(py_args, vm);
+
+        // Swap errno back after call
+        if use_errno {
+            let _current = rustpython_common::os::get_errno();
+            // TODO: store current errno to ctypes storage
+            if let Some(saved) = saved_errno {
+                rustpython_common::os::set_errno(saved);
+            }
+        }
+
+        // Call unraisable hook if exception occurred
+        if let Err(exc) = &py_result {
+            let repr = userdata
+                .callable
+                .repr(vm)
+                .map(|s| s.to_string())
+                .unwrap_or_else(|_| "<unknown>".to_string());
+            let msg = format!(
+                "Exception ignored on calling ctypes callback function {}",
+                repr
+            );
+            vm.run_unraisable(exc.clone(), Some(msg), vm.ctx.none());
+        }
+
+        if let Some(ref res_type) = userdata.res_type {
+            python_to_ffi(py_result, res_type, result as *mut c_void, vm);
+        }
+    });
+}
+
+/// Holds the closure and userdata together to ensure proper lifetime.
+struct ThunkData {
+    #[allow(dead_code)]
+    closure: Closure<'static>,
+    userdata_ptr: *mut ThunkUserData,
+}
+
+impl Drop for ThunkData {
+    fn drop(&mut self) {
+        unsafe {
+            drop(Box::from_raw(self.userdata_ptr));
+        }
+    }
+}
+
+/// CThunkObject wraps a Python callable to make it callable from C code.
+#[pyclass(name = "CThunkObject", module = "_ctypes")]
+#[derive(PyPayload)]
+pub(super) struct PyCThunk {
+    callable: PyObjectRef,
+    #[allow(dead_code)]
+    thunk_data: PyRwLock<Option<ThunkData>>,
+    code_ptr: CodePtr,
+}
+
+impl Debug for PyCThunk {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyCThunk")
+            .field("callable", &self.callable)
+            .finish()
+    }
+}
+
+impl PyCThunk {
+    pub fn new(
+        callable: PyObjectRef,
+        arg_types: Option<PyObjectRef>,
+        res_type: Option<PyObjectRef>,
+        flags: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<Self> {
+        let arg_type_vec: Vec<PyTypeRef> = match arg_types {
+            Some(args) if !vm.is_none(&args) => args
+                .try_to_value::<Vec<PyObjectRef>>(vm)?
+                .into_iter()
+                .map(|item| {
+                    item.downcast::<PyType>()
+                        .map_err(|_| vm.new_type_error("_argtypes_ must be a sequence of types"))
+                })
+                .collect::<PyResult<Vec<_>>>()?,
+            _ => Vec::new(),
+        };
+
+        let res_type_ref: Option<PyTypeRef> = match res_type {
+            Some(ref rt) if !vm.is_none(rt) => Some(
+                rt.clone()
+                    .downcast::<PyType>()
+                    .map_err(|_| vm.new_type_error("restype must be a ctypes type"))?,
+            ),
+            _ => None,
+        };
+
+        let ffi_arg_types: Vec<Type> = arg_type_vec
+            .iter()
+            .map(|ty| {
+                ty.type_code(vm)
+                    .and_then(|code| get_ffi_type(&code))
+                    .unwrap_or(Type::pointer())
+            })
+            .collect();
+
+        let ffi_res_type = res_type_ref
+            .as_ref()
+            .and_then(|ty| ty.type_code(vm))
+            .and_then(|code| get_ffi_type(&code))
+            .unwrap_or(Type::void());
+
+        let cif = Cif::new(ffi_arg_types, ffi_res_type);
+
+        let userdata = Box::new(ThunkUserData {
+            callable: callable.clone(),
+            arg_types: arg_type_vec,
+            res_type: res_type_ref,
+            flags,
+        });
+        let userdata_ptr = Box::into_raw(userdata);
+        let userdata_ref: &'static ThunkUserData = unsafe { &*userdata_ptr };
+
+        let closure = Closure::new(cif, thunk_callback, userdata_ref);
+        let code_ptr = CodePtr(*closure.code_ptr() as *mut _);
+
+        let thunk_data = ThunkData {
+            closure,
+            userdata_ptr,
+        };
+
+        Ok(Self {
+            callable,
+            thunk_data: PyRwLock::new(Some(thunk_data)),
+            code_ptr,
+        })
+    }
+
+    pub fn code_ptr(&self) -> CodePtr {
+        self.code_ptr
+    }
+}
+
+unsafe impl Send for PyCThunk {}
+unsafe impl Sync for PyCThunk {}
+
+#[pyclass]
+impl PyCThunk {
+    #[pygetset]
+    fn callable(&self) -> PyObjectRef {
+        self.callable.clone()
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/library.rs b/crates/vm/src/stdlib/ctypes/library.rs
new file mode 100644
index 0000000000..35ccb43384
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/library.rs
@@ -0,0 +1,150 @@
+use crate::VirtualMachine;
+use alloc::fmt;
+use libloading::Library;
+use rustpython_common::lock::{PyMutex, PyRwLock};
+use std::collections::HashMap;
+use std::ffi::OsStr;
+
+#[cfg(unix)]
+use libloading::os::unix::Library as UnixLibrary;
+
+pub struct SharedLibrary {
+    pub(crate) lib: PyMutex<Option<Library>>,
+}
+
+impl fmt::Debug for SharedLibrary {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "SharedLibrary")
+    }
+}
+
+impl SharedLibrary {
+    #[cfg(windows)]
+    pub fn new(name: impl AsRef<OsStr>) -> Result<SharedLibrary, libloading::Error> {
+        Ok(SharedLibrary {
+            lib: PyMutex::new(unsafe { Some(Library::new(name.as_ref())?) }),
+        })
+    }
+
+    #[cfg(unix)]
+    pub fn new_with_mode(
+        name: impl AsRef<OsStr>,
+        mode: i32,
+    ) -> Result<SharedLibrary, libloading::Error> {
+        Ok(SharedLibrary {
+            lib: PyMutex::new(Some(unsafe {
+                UnixLibrary::open(Some(name.as_ref()), mode)?.into()
+            })),
+        })
+    }
+
+    /// Create a SharedLibrary from a raw dlopen handle (for pythonapi / dlopen(NULL))
+    #[cfg(unix)]
+    pub fn from_raw_handle(handle: *mut libc::c_void) -> SharedLibrary {
+        SharedLibrary {
+            lib: PyMutex::new(Some(unsafe { UnixLibrary::from_raw(handle).into() })),
+        }
+    }
+
+    /// Get the underlying OS handle (HMODULE on Windows, dlopen handle on Unix)
+    pub fn get_pointer(&self) -> usize {
+        let lib_lock = self.lib.lock();
+        if let Some(l) = &*lib_lock {
+            // libloading::Library internally stores the OS handle directly
+            // On Windows: HMODULE (*mut c_void)
+            // On Unix: *mut c_void from dlopen
+            // We use transmute_copy to read the handle without consuming the Library
+            unsafe { core::mem::transmute_copy::<Library, usize>(l) }
+        } else {
+            0
+        }
+    }
+
+    fn is_closed(&self) -> bool {
+        let lib_lock = self.lib.lock();
+        lib_lock.is_none()
+    }
+}
+
+pub(super) struct ExternalLibs {
+    libraries: HashMap<usize, SharedLibrary>,
+}
+
+impl ExternalLibs {
+    fn new() -> Self {
+        Self {
+            libraries: HashMap::new(),
+        }
+    }
+
+    pub fn get_lib(&self, key: usize) -> Option<&SharedLibrary> {
+        self.libraries.get(&key)
+    }
+
+    #[cfg(windows)]
+    pub fn get_or_insert_lib(
+        &mut self,
+        library_path: impl AsRef<OsStr>,
+        _vm: &VirtualMachine,
+    ) -> Result<(usize, &SharedLibrary), libloading::Error> {
+        let new_lib = SharedLibrary::new(library_path)?;
+        let key = new_lib.get_pointer();
+
+        // Check if library already exists and is not closed
+        let should_use_cached = self.libraries.get(&key).is_some_and(|l| !l.is_closed());
+
+        if should_use_cached {
+            // new_lib will be dropped, calling FreeLibrary (decrements refcount)
+            // But library stays loaded because cached version maintains refcount
+            drop(new_lib);
+            return Ok((key, self.libraries.get(&key).expect("just checked")));
+        }
+
+        self.libraries.insert(key, new_lib);
+        Ok((key, self.libraries.get(&key).expect("just inserted")))
+    }
+
+    #[cfg(unix)]
+    pub fn get_or_insert_lib_with_mode(
+        &mut self,
+        library_path: impl AsRef<OsStr>,
+        mode: i32,
+        _vm: &VirtualMachine,
+    ) -> Result<(usize, &SharedLibrary), libloading::Error> {
+        let new_lib = SharedLibrary::new_with_mode(library_path, mode)?;
+        let key = new_lib.get_pointer();
+
+        // Check if library already exists and is not closed
+        let should_use_cached = self.libraries.get(&key).is_some_and(|l| !l.is_closed());
+
+        if should_use_cached {
+            // new_lib will be dropped, calling dlclose (decrements refcount)
+            // But library stays loaded because cached version maintains refcount
+            drop(new_lib);
+            return Ok((key, self.libraries.get(&key).expect("just checked")));
+        }
+
+        self.libraries.insert(key, new_lib);
+        Ok((key, self.libraries.get(&key).expect("just inserted")))
+    }
+
+    /// Insert a raw dlopen handle into the cache (for pythonapi / dlopen(NULL))
+    #[cfg(unix)]
+    pub fn insert_raw_handle(&mut self, handle: *mut libc::c_void) -> usize {
+        let shared_lib = SharedLibrary::from_raw_handle(handle);
+        let key = handle as usize;
+        self.libraries.insert(key, shared_lib);
+        key
+    }
+
+    pub fn drop_lib(&mut self, key: usize) {
+        self.libraries.remove(&key);
+    }
+}
+
+pub(super) fn libcache() -> &'static PyRwLock<ExternalLibs> {
+    rustpython_common::static_cell! {
+        static LIBCACHE: PyRwLock<ExternalLibs>;
+    }
+    LIBCACHE.get_or_init(|| PyRwLock::new(ExternalLibs::new()))
+}
diff --git a/crates/vm/src/stdlib/ctypes/pointer.rs b/crates/vm/src/stdlib/ctypes/pointer.rs
new file mode 100644
index 0000000000..875d78a001
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/pointer.rs
@@ -0,0 +1,831 @@
+use super::base::CDATA_BUFFER_METHODS;
+use super::{PyCArray, PyCData, PyCSimple, PyCStructure, StgInfo, StgInfoFlags};
+use crate::atomic_func;
+use crate::protocol::{BufferDescriptor, PyBuffer, PyMappingMethods, PyNumberMethods};
+use crate::types::{AsBuffer, AsMapping, AsNumber, Constructor, Initializer};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyBytes, PyInt, PyList, PySlice, PyStr, PyType, PyTypeRef},
+    class::StaticType,
+    function::{FuncArgs, OptionalArg},
+};
+use alloc::borrow::Cow;
+use num_traits::ToPrimitive;
+
+#[pyclass(name = "PyCPointerType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCPointerType(PyType);
+
+impl Initializer for PyCPointerType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        new_type.check_not_initialized(vm)?;
+
+        // Get the _type_ attribute (element type)
+        // PyCPointerType_init gets the element type from _type_ attribute
+        let proto = new_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|obj| obj.downcast::<PyType>().ok());
+
+        // Initialize StgInfo for pointer type
+        let pointer_size = core::mem::size_of::<usize>();
+        let mut stg_info = StgInfo::new(pointer_size, pointer_size);
+        stg_info.proto = proto;
+        stg_info.paramfunc = super::base::ParamFunc::Pointer;
+        stg_info.length = 1;
+        stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+
+        // Set format string: "&<element_format>" or "&(shape)<element_format>" for arrays
+        if let Some(ref proto) = stg_info.proto
+            && let Some(item_info) = proto.stg_info_opt()
+        {
+            let current_format = item_info.format.as_deref().unwrap_or("B");
+            // Include shape for array types in the pointer format
+            let shape_str = if !item_info.shape.is_empty() {
+                let dims: Vec<String> = item_info.shape.iter().map(|d| d.to_string()).collect();
+                format!("({})", dims.join(","))
+            } else {
+                String::new()
+            };
+            stg_info.format = Some(format!("&{}{}", shape_str, current_format));
+        }
+
+        let _ = new_type.init_type_data(stg_info);
+
+        Ok(())
+    }
+}
+
+#[pyclass(flags(IMMUTABLETYPE), with(AsNumber, Initializer))]
+impl PyCPointerType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the pointer type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. None is allowed for pointer types
+        if vm.is_none(&value) {
+            return Ok(value);
+        }
+
+        // 1.5 CArgObject (from byref()) - check if underlying obj is instance of _type_
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>()
+            && let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+            && let Ok(type_ref) = type_attr.downcast::<PyType>()
+            && carg.obj.is_instance(type_ref.as_object(), vm)?
+        {
+            return Ok(value);
+        }
+
+        // 2. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 3. If value is an instance of _type_ (the pointed-to type), wrap with byref
+        if let Ok(type_attr) = cls.as_object().get_attr("_type_", vm)
+            && let Ok(type_ref) = type_attr.downcast::<PyType>()
+            && value.is_instance(type_ref.as_object(), vm)?
+        {
+            // Return byref(value)
+            return super::_ctypes::byref(value, crate::function::OptionalArg::Missing, vm);
+        }
+
+        // 4. Array/Pointer instances with compatible proto
+        // "Array instances are also pointers when the item types are the same."
+        let is_pointer_or_array = value.downcast_ref::<PyCPointer>().is_some()
+            || value.downcast_ref::<super::array::PyCArray>().is_some();
+
+        if is_pointer_or_array {
+            let is_compatible = {
+                if let Some(value_stginfo) = value.class().stg_info_opt()
+                    && let Some(ref value_proto) = value_stginfo.proto
+                    && let Some(cls_stginfo) = cls.stg_info_opt()
+                    && let Some(ref cls_proto) = cls_stginfo.proto
+                {
+                    // Check if value's proto is a subclass of target's proto
+                    value_proto.fast_issubclass(cls_proto)
+                } else {
+                    false
+                }
+            };
+            if is_compatible {
+                return Ok(value);
+            }
+        }
+
+        // 5. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCPointerType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
+    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        use super::array::array_type_from_ctype;
+
+        if n < 0 {
+            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+        }
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
+    }
+
+    // PyCPointerType_set_type: Complete an incomplete pointer type
+    #[pymethod]
+    fn set_type(zelf: PyTypeRef, typ: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        use crate::AsObject;
+
+        // 1. Validate that typ is a type
+        let typ_type = typ
+            .clone()
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("_type_ must be a type"))?;
+
+        // 2. Validate that typ has storage info
+        if typ_type.stg_info_opt().is_none() {
+            return Err(vm.new_type_error("_type_ must have storage info"));
+        }
+
+        // 3. Update StgInfo.proto and format using mutable access
+        if let Some(mut stg_info) = zelf.get_type_data_mut::<StgInfo>() {
+            stg_info.proto = Some(typ_type.clone());
+
+            // Update format string: "&<element_format>" or "&(shape)<element_format>" for arrays
+            let item_info = typ_type.stg_info_opt().expect("proto has StgInfo");
+            let current_format = item_info.format.as_deref().unwrap_or("B");
+            // Include shape for array types in the pointer format
+            let shape_str = if !item_info.shape.is_empty() {
+                let dims: Vec<String> = item_info.shape.iter().map(|d| d.to_string()).collect();
+                format!("({})", dims.join(","))
+            } else {
+                String::new()
+            };
+            stg_info.format = Some(format!("&{}{}", shape_str, current_format));
+        }
+
+        // 4. Set _type_ attribute on the pointer type
+        zelf.as_object().set_attr("_type_", typ_type, vm)?;
+
+        Ok(())
+    }
+}
+
+impl AsNumber for PyCPointerType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            multiply: Some(|a, b, vm| {
+                let cls = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
+                let n = b
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_isize()
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+                PyCPointerType::__mul__(cls.to_owned(), n, vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+/// PyCPointer - Pointer instance
+/// `contents` is a computed property, not a stored field.
+#[pyclass(
+    name = "_Pointer",
+    base = PyCData,
+    metaclass = "PyCPointerType",
+    module = "_ctypes"
+)]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PyCPointer(pub PyCData);
+
+impl Constructor for PyCPointer {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Pointer_new: Check if _type_ is defined
+        let has_type = cls.stg_info_opt().is_some_and(|info| info.proto.is_some());
+        if !has_type {
+            return Err(vm.new_type_error("Cannot create instance: has no _type_"));
+        }
+
+        // Create a new PyCPointer instance with NULL pointer (all zeros)
+        // Initial contents is set via __init__ if provided
+        let cdata = PyCData::from_bytes(vec![0u8; core::mem::size_of::<usize>()], None);
+        // pointer instance has b_length set to 2 (for index 0 and 1)
+        cdata.length.store(2);
+        PyCPointer(cdata)
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyCPointer {
+    type Args = (OptionalArg<PyObjectRef>,);
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        let (value,) = args;
+        if let OptionalArg::Present(val) = value
+            && !vm.is_none(&val)
+        {
+            Self::set_contents(&zelf, val, vm)?;
+        }
+        Ok(())
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsNumber, AsBuffer, AsMapping)
+)]
+impl PyCPointer {
+    /// Get the pointer value stored in buffer as usize
+    pub fn get_ptr_value(&self) -> usize {
+        let buffer = self.0.buffer.read();
+        super::base::read_ptr_from_buffer(&buffer)
+    }
+
+    /// Set the pointer value in buffer
+    pub fn set_ptr_value(&self, value: usize) {
+        let mut buffer = self.0.buffer.write();
+        let bytes = value.to_ne_bytes();
+        if buffer.len() >= bytes.len() {
+            buffer.to_mut()[..bytes.len()].copy_from_slice(&bytes);
+        }
+    }
+
+    /// contents getter - reads address from b_ptr and creates an instance of the pointed-to type
+    #[pygetset]
+    fn contents(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // Pointer_get_contents
+        let ptr_val = zelf.get_ptr_value();
+        if ptr_val == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+
+        // Get element type from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
+
+        // Create instance that references the memory directly
+        // PyCData.into_ref_with_type works for all ctypes (simple, structure, union, array, pointer)
+        let cdata = unsafe { super::base::PyCData::at_address(ptr_val as *const u8, element_size) };
+        cdata
+            .into_ref_with_type(vm, proto_type.to_owned())
+            .map(Into::into)
+    }
+
+    /// contents setter - stores address in b_ptr and keeps reference
+    /// Pointer_set_contents
+    #[pygetset(setter)]
+    fn set_contents(zelf: &Py<Self>, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Get stginfo and proto for type validation
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto = stg_info.proto();
+
+        // Check if value is CData, or isinstance(value, proto)
+        let cdata = if let Some(c) = value.downcast_ref::<PyCData>() {
+            c
+        } else if value.is_instance(proto.as_object(), vm)? {
+            value
+                .downcast_ref::<PyCData>()
+                .ok_or_else(|| vm.new_type_error("expected ctypes instance"))?
+        } else {
+            return Err(vm.new_type_error(format!(
+                "expected {} instead of {}",
+                proto.name(),
+                value.class().name()
+            )));
+        };
+
+        // Set pointer value
+        {
+            let buffer = cdata.buffer.read();
+            let addr = buffer.as_ptr() as usize;
+            drop(buffer);
+            zelf.set_ptr_value(addr);
+        }
+
+        // KeepRef: store the object directly with index 1
+        zelf.0.keep_ref(1, value.clone(), vm)?;
+
+        // KeepRef: store GetKeepedObjects(dst) at index 0
+        if let Some(kept) = cdata.objects.read().clone() {
+            zelf.0.keep_ref(0, kept, vm)?;
+        }
+
+        Ok(())
+    }
+
+    // Pointer_subscript
+    fn __getitem__(zelf: &Py<Self>, item: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // PyIndex_Check
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            // Note: Pointer does NOT adjust negative indices (no length)
+            Self::getitem_by_index(zelf, i, vm)
+        }
+        // PySlice_Check
+        else if let Some(slice) = item.downcast_ref::<PySlice>() {
+            Self::getitem_by_slice(zelf, slice, vm)
+        } else {
+            Err(vm.new_type_error("Pointer indices must be integer"))
+        }
+    }
+
+    // Pointer_item
+    fn getitem_by_index(zelf: &Py<Self>, index: isize, vm: &VirtualMachine) -> PyResult {
+        // if (*(void **)self->b_ptr == NULL) { PyErr_SetString(...); }
+        let ptr_value = zelf.get_ptr_value();
+        if ptr_value == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+
+        // Get element type and size from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
+
+        // offset = index * iteminfo->size
+        let offset = index * element_size as isize;
+        let addr = (ptr_value as isize + offset) as usize;
+
+        // Check if it's a simple type (has _type_ attribute)
+        if let Ok(type_attr) = proto_type.as_object().get_attr("_type_", vm)
+            && let Ok(type_str) = type_attr.str(vm)
+        {
+            let type_code = type_str.to_string();
+            return Self::read_value_at_address(addr, element_size, Some(&type_code), vm);
+        }
+
+        // Complex type: create instance that references the memory directly (not a copy)
+        // This allows p[i].val = x to modify the original memory
+        // PyCData.into_ref_with_type works for all ctypes (array, structure, union, pointer)
+        let cdata = unsafe { super::base::PyCData::at_address(addr as *const u8, element_size) };
+        cdata
+            .into_ref_with_type(vm, proto_type.to_owned())
+            .map(Into::into)
+    }
+
+    // Pointer_subscript slice handling (manual parsing, not PySlice_Unpack)
+    fn getitem_by_slice(zelf: &Py<Self>, slice: &PySlice, vm: &VirtualMachine) -> PyResult {
+        // Since pointers have no length, we have to dissect the slice ourselves
+
+        // step: defaults to 1, step == 0 is error
+        let step: isize = if let Some(ref step_obj) = slice.step
+            && !vm.is_none(step_obj)
+        {
+            let s = step_obj
+                .try_int(vm)?
+                .as_bigint()
+                .to_isize()
+                .ok_or_else(|| vm.new_value_error("slice step too large"))?;
+            if s == 0 {
+                return Err(vm.new_value_error("slice step cannot be zero"));
+            }
+            s
+        } else {
+            1
+        };
+
+        // start: defaults to 0, but required if step < 0
+        let start: isize = if let Some(ref start_obj) = slice.start
+            && !vm.is_none(start_obj)
+        {
+            start_obj
+                .try_int(vm)?
+                .as_bigint()
+                .to_isize()
+                .ok_or_else(|| vm.new_value_error("slice start too large"))?
+        } else {
+            if step < 0 {
+                return Err(vm.new_value_error("slice start is required for step < 0"));
+            }
+            0
+        };
+
+        // stop: ALWAYS required for pointers
+        if vm.is_none(&slice.stop) {
+            return Err(vm.new_value_error("slice stop is required"));
+        }
+        let stop: isize = slice
+            .stop
+            .try_int(vm)?
+            .as_bigint()
+            .to_isize()
+            .ok_or_else(|| vm.new_value_error("slice stop too large"))?;
+
+        // calculate length
+        let len: usize = if (step > 0 && start > stop) || (step < 0 && start < stop) {
+            0
+        } else if step > 0 {
+            ((stop - start - 1) / step + 1) as usize
+        } else {
+            ((stop - start + 1) / step + 1) as usize
+        };
+
+        // Get element info
+        let stg_info = zelf.class().stg_info(vm)?;
+        let element_size = if let Some(ref proto_type) = stg_info.proto {
+            proto_type.stg_info_opt().expect("proto has StgInfo").size
+        } else {
+            core::mem::size_of::<usize>()
+        };
+        let type_code = stg_info
+            .proto
+            .as_ref()
+            .and_then(|p| p.as_object().get_attr("_type_", vm).ok())
+            .and_then(|t| t.str(vm).ok())
+            .map(|s| s.to_string());
+
+        let ptr_value = zelf.get_ptr_value();
+
+        // c_char → bytes
+        if type_code.as_deref() == Some("c") {
+            if len == 0 {
+                return Ok(vm.ctx.new_bytes(vec![]).into());
+            }
+            let mut result = Vec::with_capacity(len);
+            if step == 1 {
+                // Optimized contiguous copy
+                let start_addr = (ptr_value as isize + start * element_size as isize) as *const u8;
+                unsafe {
+                    result.extend_from_slice(core::slice::from_raw_parts(start_addr, len));
+                }
+            } else {
+                let mut cur = start;
+                for _ in 0..len {
+                    let addr = (ptr_value as isize + cur * element_size as isize) as *const u8;
+                    unsafe {
+                        result.push(*addr);
+                    }
+                    cur += step;
+                }
+            }
+            return Ok(vm.ctx.new_bytes(result).into());
+        }
+
+        // c_wchar → str
+        if type_code.as_deref() == Some("u") {
+            if len == 0 {
+                return Ok(vm.ctx.new_str("").into());
+            }
+            let mut result = String::with_capacity(len);
+            let wchar_size = core::mem::size_of::<libc::wchar_t>();
+            let mut cur = start;
+            for _ in 0..len {
+                let addr = (ptr_value as isize + cur * wchar_size as isize) as *const libc::wchar_t;
+                unsafe {
+                    if let Some(c) = char::from_u32(*addr as u32) {
+                        result.push(c);
+                    }
+                }
+                cur += step;
+            }
+            return Ok(vm.ctx.new_str(result).into());
+        }
+
+        // other types → list with Pointer_item for each
+        let mut items = Vec::with_capacity(len);
+        let mut cur = start;
+        for _ in 0..len {
+            items.push(Self::getitem_by_index(zelf, cur, vm)?);
+            cur += step;
+        }
+        Ok(PyList::from(items).into_ref(&vm.ctx).into())
+    }
+
+    // Pointer_ass_item
+    fn __setitem__(
+        zelf: &Py<Self>,
+        item: PyObjectRef,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Pointer does not support item deletion (value always provided)
+        // only integer indices supported for setitem
+        if let Some(i) = item.downcast_ref::<PyInt>() {
+            let i = i.as_bigint().to_isize().ok_or_else(|| {
+                vm.new_index_error("cannot fit index into an index-sized integer")
+            })?;
+            Self::setitem_by_index(zelf, i, value, vm)
+        } else {
+            Err(vm.new_type_error("Pointer indices must be integer"))
+        }
+    }
+
+    fn setitem_by_index(
+        zelf: &Py<Self>,
+        index: isize,
+        value: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let ptr_value = zelf.get_ptr_value();
+        if ptr_value == 0 {
+            return Err(vm.new_value_error("NULL pointer access"));
+        }
+
+        // Get element type, size and type_code from StgInfo.proto
+        let stg_info = zelf.class().stg_info(vm)?;
+        let proto_type = stg_info.proto();
+
+        // Get type code from proto's _type_ attribute
+        let type_code: Option<String> = proto_type
+            .as_object()
+            .get_attr("_type_", vm)
+            .ok()
+            .and_then(|t| t.downcast_ref::<PyStr>().map(|s| s.to_string()));
+
+        let element_size = proto_type
+            .stg_info_opt()
+            .map_or(core::mem::size_of::<usize>(), |info| info.size);
+
+        // Calculate address
+        let offset = index * element_size as isize;
+        let addr = (ptr_value as isize + offset) as usize;
+
+        // Write value at address
+        // Handle Structure/Array types by copying their buffer
+        if let Some(cdata) = value.downcast_ref::<super::PyCData>()
+            && (cdata.fast_isinstance(PyCStructure::static_type())
+                || cdata.fast_isinstance(PyCArray::static_type())
+                || cdata.fast_isinstance(PyCSimple::static_type()))
+        {
+            let src_buffer = cdata.buffer.read();
+            let copy_len = src_buffer.len().min(element_size);
+            unsafe {
+                let dest_ptr = addr as *mut u8;
+                core::ptr::copy_nonoverlapping(src_buffer.as_ptr(), dest_ptr, copy_len);
+            }
+        } else {
+            // Handle z/Z specially to store converted value
+            if type_code.as_deref() == Some("z")
+                && let Some(bytes) = value.downcast_ref::<PyBytes>()
+            {
+                let (converted, ptr_val) = super::base::ensure_z_null_terminated(bytes, vm);
+                unsafe {
+                    *(addr as *mut usize) = ptr_val;
+                }
+                return zelf.0.keep_ref(index as usize, converted, vm);
+            } else if type_code.as_deref() == Some("Z")
+                && let Some(s) = value.downcast_ref::<PyStr>()
+            {
+                let (holder, ptr_val) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                unsafe {
+                    *(addr as *mut usize) = ptr_val;
+                }
+                return zelf.0.keep_ref(index as usize, holder, vm);
+            } else {
+                Self::write_value_at_address(addr, element_size, &value, type_code.as_deref(), vm)?;
+            }
+        }
+
+        // KeepRef: store reference to keep value alive using actual index
+        zelf.0.keep_ref(index as usize, value, vm)
+    }
+
+    /// Read a value from memory address
+    fn read_value_at_address(
+        addr: usize,
+        size: usize,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        unsafe {
+            let ptr = addr as *const u8;
+            match type_code {
+                // Single-byte types don't need read_unaligned
+                Some("c") => Ok(vm.ctx.new_bytes(vec![*ptr]).into()),
+                Some("b") => Ok(vm.ctx.new_int(*ptr as i8 as i32).into()),
+                Some("B") => Ok(vm.ctx.new_int(*ptr as i32).into()),
+                // Multi-byte types need read_unaligned for safety on strict-alignment architectures
+                Some("h") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const i16) as i32)
+                    .into()),
+                Some("H") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const u16) as i32)
+                    .into()),
+                Some("i") | Some("l") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const i32))
+                    .into()),
+                Some("I") | Some("L") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const u32))
+                    .into()),
+                Some("q") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const i64))
+                    .into()),
+                Some("Q") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const u64))
+                    .into()),
+                Some("f") => Ok(vm
+                    .ctx
+                    .new_float(core::ptr::read_unaligned(ptr as *const f32) as f64)
+                    .into()),
+                Some("d") | Some("g") => Ok(vm
+                    .ctx
+                    .new_float(core::ptr::read_unaligned(ptr as *const f64))
+                    .into()),
+                Some("P") | Some("z") | Some("Z") => Ok(vm
+                    .ctx
+                    .new_int(core::ptr::read_unaligned(ptr as *const usize))
+                    .into()),
+                _ => {
+                    // Default: read as bytes
+                    let bytes = core::slice::from_raw_parts(ptr, size).to_vec();
+                    Ok(vm.ctx.new_bytes(bytes).into())
+                }
+            }
+        }
+    }
+
+    /// Write a value to memory address
+    fn write_value_at_address(
+        addr: usize,
+        size: usize,
+        value: &PyObject,
+        type_code: Option<&str>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        unsafe {
+            let ptr = addr as *mut u8;
+
+            // Handle c_char_p (z) and c_wchar_p (Z) - store pointer address
+            // Note: PyBytes/PyStr cases are handled by caller (setitem_by_index)
+            match type_code {
+                Some("z") | Some("Z") => {
+                    let ptr_val = if vm.is_none(value) {
+                        0usize
+                    } else if let Ok(int_val) = value.try_index(vm) {
+                        int_val.as_bigint().to_usize().unwrap_or(0)
+                    } else {
+                        return Err(vm.new_type_error(
+                            "bytes/string or integer address expected".to_owned(),
+                        ));
+                    };
+                    core::ptr::write_unaligned(ptr as *mut usize, ptr_val);
+                    return Ok(());
+                }
+                _ => {}
+            }
+
+            // Try to get value as integer
+            // Use write_unaligned for safety on strict-alignment architectures
+            if let Ok(int_val) = value.try_int(vm) {
+                let i = int_val.as_bigint();
+                match size {
+                    1 => {
+                        *ptr = i.to_u8().expect("int too large");
+                    }
+                    2 => {
+                        core::ptr::write_unaligned(
+                            ptr as *mut i16,
+                            i.to_i16().expect("int too large"),
+                        );
+                    }
+                    4 => {
+                        core::ptr::write_unaligned(
+                            ptr as *mut i32,
+                            i.to_i32().expect("int too large"),
+                        );
+                    }
+                    8 => {
+                        core::ptr::write_unaligned(
+                            ptr as *mut i64,
+                            i.to_i64().expect("int too large"),
+                        );
+                    }
+                    _ => {
+                        let bytes = i.to_signed_bytes_le();
+                        let copy_len = bytes.len().min(size);
+                        core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                    }
+                }
+                return Ok(());
+            }
+
+            // Try to get value as float
+            if let Ok(float_val) = value.try_float(vm) {
+                let f = float_val.to_f64();
+                match size {
+                    4 => {
+                        core::ptr::write_unaligned(ptr as *mut f32, f as f32);
+                    }
+                    8 => {
+                        core::ptr::write_unaligned(ptr as *mut f64, f);
+                    }
+                    _ => {}
+                }
+                return Ok(());
+            }
+
+            // Try bytes
+            if let Ok(bytes) = value.try_bytes_like(vm, |b| b.to_vec()) {
+                let copy_len = bytes.len().min(size);
+                core::ptr::copy_nonoverlapping(bytes.as_ptr(), ptr, copy_len);
+                return Ok(());
+            }
+
+            Err(vm.new_type_error(format!(
+                "cannot convert {} to ctypes data",
+                value.class().name()
+            )))
+        }
+    }
+}
+
+impl AsNumber for PyCPointer {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|number, _vm| {
+                let zelf = number.obj.downcast_ref::<PyCPointer>().unwrap();
+                Ok(zelf.get_ptr_value() != 0)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl AsMapping for PyCPointer {
+    fn as_mapping() -> &'static PyMappingMethods {
+        use std::sync::LazyLock;
+        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
+            subscript: atomic_func!(|mapping, needle, vm| {
+                let zelf = PyCPointer::mapping_downcast(mapping);
+                PyCPointer::__getitem__(zelf, needle.to_owned(), vm)
+            }),
+            ass_subscript: atomic_func!(|mapping, needle, value, vm| {
+                let zelf = PyCPointer::mapping_downcast(mapping);
+                match value {
+                    Some(value) => PyCPointer::__setitem__(zelf, needle.to_owned(), value, vm),
+                    None => Err(vm.new_type_error("Pointer does not support item deletion")),
+                }
+            }),
+            ..PyMappingMethods::NOT_IMPLEMENTED
+        });
+        &AS_MAPPING
+    }
+}
+
+impl AsBuffer for PyCPointer {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCPointer type must have StgInfo");
+        let format = stg_info
+            .format
+            .clone()
+            .map(Cow::Owned)
+            .unwrap_or(Cow::Borrowed("&B"));
+        let itemsize = stg_info.size;
+        // Pointer types are scalars with ndim=0, shape=()
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/simple.rs b/crates/vm/src/stdlib/ctypes/simple.rs
new file mode 100644
index 0000000000..b2ae0f7cc5
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/simple.rs
@@ -0,0 +1,1470 @@
+use super::_ctypes::CArgObject;
+use super::array::{PyCArray, WCHAR_SIZE, wchar_to_bytes};
+use super::base::{
+    CDATA_BUFFER_METHODS, FfiArgValue, PyCData, StgInfo, StgInfoFlags, buffer_to_ffi_value,
+    bytes_to_pyobject,
+};
+use super::function::PyCFuncPtr;
+use super::get_size;
+use super::pointer::PyCPointer;
+use crate::builtins::{PyByteArray, PyBytes, PyInt, PyNone, PyStr, PyType, PyTypeRef};
+use crate::convert::ToPyObject;
+use crate::function::{Either, FuncArgs, OptionalArg};
+use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, Representable};
+use crate::{AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+use alloc::borrow::Cow;
+use core::fmt::Debug;
+use num_traits::ToPrimitive;
+
+/// Valid type codes for ctypes simple types
+// spell-checker: disable-next-line
+pub(super) const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfuzZqQPXOv?g";
+
+/// Convert ctypes type code to PEP 3118 format code.
+/// Some ctypes codes need to be mapped to standard-size codes based on platform.
+/// _ctypes_alloc_format_string_for_type
+fn ctypes_code_to_pep3118(code: char) -> char {
+    match code {
+        // c_int: map based on sizeof(int)
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 2 => 'h',
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 4 => 'i',
+        'i' if core::mem::size_of::<core::ffi::c_int>() == 8 => 'q',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 2 => 'H',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 4 => 'I',
+        'I' if core::mem::size_of::<core::ffi::c_int>() == 8 => 'Q',
+        // c_long: map based on sizeof(long)
+        'l' if core::mem::size_of::<core::ffi::c_long>() == 4 => 'l',
+        'l' if core::mem::size_of::<core::ffi::c_long>() == 8 => 'q',
+        'L' if core::mem::size_of::<core::ffi::c_long>() == 4 => 'L',
+        'L' if core::mem::size_of::<core::ffi::c_long>() == 8 => 'Q',
+        // c_bool: map based on sizeof(bool) - typically 1 byte on all platforms
+        '?' if core::mem::size_of::<bool>() == 1 => '?',
+        '?' if core::mem::size_of::<bool>() == 2 => 'H',
+        '?' if core::mem::size_of::<bool>() == 4 => 'L',
+        '?' if core::mem::size_of::<bool>() == 8 => 'Q',
+        // Default: use the same code
+        _ => code,
+    }
+}
+
+/// _ctypes_alloc_format_string_for_type
+fn alloc_format_string_for_type(code: char, big_endian: bool) -> String {
+    let prefix = if big_endian { ">" } else { "<" };
+    let pep_code = ctypes_code_to_pep3118(code);
+    format!("{}{}", prefix, pep_code)
+}
+
+/// Create a new simple type instance from a class
+fn new_simple_type(
+    cls: Either<&PyObject, &Py<PyType>>,
+    vm: &VirtualMachine,
+) -> PyResult<PyCSimple> {
+    let cls = match cls {
+        Either::A(obj) => obj,
+        Either::B(typ) => typ.as_object(),
+    };
+
+    let _type_ = cls
+        .get_attr("_type_", vm)
+        .map_err(|_| vm.new_attribute_error("class must define a '_type_' attribute"))?;
+
+    if !_type_.is_instance((&vm.ctx.types.str_type).as_ref(), vm)? {
+        return Err(vm.new_type_error("class must define a '_type_' string attribute"));
+    }
+
+    let tp_str = _type_.str(vm)?.to_string();
+
+    if tp_str.len() != 1 {
+        return Err(vm.new_value_error(format!(
+            "class must define a '_type_' attribute which must be a string of length 1, str: {tp_str}"
+        )));
+    }
+
+    if !SIMPLE_TYPE_CHARS.contains(tp_str.as_str()) {
+        return Err(vm.new_attribute_error(format!(
+            "class must define a '_type_' attribute which must be\n a single character string containing one of {SIMPLE_TYPE_CHARS}, currently it is {tp_str}."
+        )));
+    }
+
+    let size = get_size(&tp_str);
+    Ok(PyCSimple(PyCData::from_bytes(vec![0u8; size], None)))
+}
+
+fn set_primitive(_type_: &str, value: &PyObject, vm: &VirtualMachine) -> PyResult {
+    match _type_ {
+        "c" => {
+            // c_set: accepts bytes(len=1), bytearray(len=1), or int(0-255)
+            if value
+                .downcast_ref_if_exact::<PyBytes>(vm)
+                .is_some_and(|v| v.len() == 1)
+                || value
+                    .downcast_ref_if_exact::<PyByteArray>(vm)
+                    .is_some_and(|v| v.borrow_buf().len() == 1)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some_and(|v| {
+                    v.as_bigint()
+                        .to_i64()
+                        .is_some_and(|n| (0..=255).contains(&n))
+                })
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error("one character bytes, bytearray or integer expected"))
+            }
+        }
+        "u" => {
+            if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
+                if b {
+                    Ok(value.to_owned())
+                } else {
+                    Err(vm.new_type_error("one character unicode string expected"))
+                }
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        "b" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
+            // Support __index__ protocol
+            if value.try_index(vm).is_ok() {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "an integer is required (got type {})",
+                    value.class().name()
+                )))
+            }
+        }
+        "f" | "d" | "g" => {
+            // Handle int specially to check overflow
+            if let Some(int_obj) = value.downcast_ref_if_exact::<PyInt>(vm) {
+                // Check if int can fit in f64
+                if let Some(f) = int_obj.as_bigint().to_f64()
+                    && f.is_finite()
+                {
+                    return Ok(value.to_owned());
+                }
+                return Err(vm.new_overflow_error("int too large to convert to float"));
+            }
+            // __float__ protocol
+            if value.try_float(vm).is_ok() {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!("must be real number, not {}", value.class().name())))
+            }
+        }
+        "?" => Ok(PyObjectRef::from(
+            vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
+        )),
+        "v" => {
+            // VARIANT_BOOL: any truthy → True
+            Ok(PyObjectRef::from(
+                vm.ctx.new_bool(value.to_owned().try_to_bool(vm)?),
+            ))
+        }
+        "B" => {
+            // Support __index__ protocol
+            if value.try_index(vm).is_ok() {
+                // Store as-is, conversion to unsigned happens in the getter
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!("int expected instead of {}", value.class().name())))
+            }
+        }
+        "z" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyBytes>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "bytes or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        "Z" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        // O_set: py_object accepts any Python object
+        "O" => Ok(value.to_owned()),
+        // X_set: BSTR - same as Z (c_wchar_p), accepts None, int, or str
+        "X" => {
+            if value.is(&vm.ctx.none)
+                || value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyStr>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error(format!(
+                    "unicode string or integer address expected instead of {} instance",
+                    value.class().name()
+                )))
+            }
+        }
+        _ => {
+            // "P"
+            if value.downcast_ref_if_exact::<PyInt>(vm).is_some()
+                || value.downcast_ref_if_exact::<PyNone>(vm).is_some()
+            {
+                Ok(value.to_owned())
+            } else {
+                Err(vm.new_type_error("cannot be converted to pointer"))
+            }
+        }
+    }
+}
+
+#[pyclass(module = "_ctypes", name = "PyCSimpleType", base = PyType)]
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct PyCSimpleType(PyType);
+
+#[pyclass(flags(BASETYPE), with(AsNumber, Initializer))]
+impl PyCSimpleType {
+    #[allow(clippy::new_ret_no_self)]
+    #[pymethod]
+    fn new(cls: PyTypeRef, _: OptionalArg, vm: &VirtualMachine) -> PyResult {
+        Ok(PyObjectRef::from(
+            new_simple_type(Either::B(&cls), vm)?
+                .into_ref_with_type(vm, cls)?
+                .clone(),
+        ))
+    }
+
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the class (e.g., c_int) that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If the value is already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Get the type code to determine conversion rules
+        let type_code = cls.type_code(vm);
+
+        // 3. Handle None for pointer types (c_char_p, c_wchar_p, c_void_p)
+        if vm.is_none(&value) && matches!(type_code.as_deref(), Some("z") | Some("Z") | Some("P")) {
+            return Ok(value);
+        }
+
+        // Helper to create CArgObject wrapping a simple instance
+        let create_simple_with_value = |type_str: &str, val: &PyObject| -> PyResult {
+            let simple = new_simple_type(Either::B(&cls), vm)?;
+            let buffer_bytes = value_to_bytes_endian(type_str, val, false, vm);
+            *simple.0.buffer.write() = alloc::borrow::Cow::Owned(buffer_bytes.clone());
+            let simple_obj: PyObjectRef = simple.into_ref_with_type(vm, cls.clone())?.into();
+            // from_param returns CArgObject, not the simple type itself
+            let tag = type_str.as_bytes().first().copied().unwrap_or(b'?');
+            let ffi_value = buffer_to_ffi_value(type_str, &buffer_bytes);
+            Ok(CArgObject {
+                tag,
+                value: ffi_value,
+                obj: simple_obj,
+                size: 0,
+                offset: 0,
+            }
+            .to_pyobject(vm))
+        };
+
+        // 4. Try to convert value based on type code
+        match type_code.as_deref() {
+            // Integer types: accept integers
+            Some(tc @ ("b" | "B" | "h" | "H" | "i" | "I" | "l" | "L" | "q" | "Q")) => {
+                if value.try_int(vm).is_ok() {
+                    return create_simple_with_value(tc, &value);
+                }
+            }
+            // Float types: accept numbers
+            Some(tc @ ("f" | "d" | "g")) => {
+                if value.try_float(vm).is_ok() || value.try_int(vm).is_ok() {
+                    return create_simple_with_value(tc, &value);
+                }
+            }
+            // c_char: 1 byte character
+            Some("c") => {
+                if let Some(bytes) = value.downcast_ref::<PyBytes>()
+                    && bytes.len() == 1
+                {
+                    return create_simple_with_value("c", &value);
+                }
+                if let Ok(int_val) = value.try_int(vm)
+                    && int_val.as_bigint().to_u8().is_some()
+                {
+                    return create_simple_with_value("c", &value);
+                }
+                return Err(vm.new_type_error(
+                    "one character bytes, bytearray or integer expected".to_string(),
+                ));
+            }
+            // c_wchar: 1 unicode character
+            Some("u") => {
+                if let Some(s) = value.downcast_ref::<PyStr>()
+                    && s.as_str().chars().count() == 1
+                {
+                    return create_simple_with_value("u", &value);
+                }
+                return Err(vm.new_type_error("one character unicode string expected"));
+            }
+            // c_char_p: bytes pointer
+            Some("z") => {
+                // 1. bytes → create CArgObject with null-terminated buffer
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (holder, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    return Ok(CArgObject {
+                        tag: b'z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 2. Array/Pointer with c_char element type
+                if is_cchar_array_or_pointer(&value, vm) {
+                    return Ok(value);
+                }
+                // 3. CArgObject (byref(c_char(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'c'
+                {
+                    return Ok(value.clone());
+                }
+            }
+            // c_wchar_p: unicode pointer
+            Some("Z") => {
+                // 1. str → create CArgObject with null-terminated wchar buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    return Ok(CArgObject {
+                        tag: b'Z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 2. Array/Pointer with c_wchar element type
+                if is_cwchar_array_or_pointer(&value, vm)? {
+                    return Ok(value);
+                }
+                // 3. CArgObject (byref(c_wchar(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'u'
+                {
+                    return Ok(value.clone());
+                }
+            }
+            // c_void_p: most flexible - accepts int, bytes, str, any array/pointer, funcptr
+            Some("P") => {
+                // 1. int → create c_void_p with that address
+                if value.try_int(vm).is_ok() {
+                    return create_simple_with_value("P", &value);
+                }
+                // 2. bytes → create CArgObject with null-terminated buffer
+                if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                    let (holder, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    return Ok(CArgObject {
+                        tag: b'z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 3. str → create CArgObject with null-terminated wchar buffer
+                if let Some(s) = value.downcast_ref::<PyStr>() {
+                    let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                    return Ok(CArgObject {
+                        tag: b'Z',
+                        value: FfiArgValue::OwnedPointer(ptr, holder),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 4. Any Array or Pointer → accept directly
+                if value.downcast_ref::<PyCArray>().is_some()
+                    || value.downcast_ref::<PyCPointer>().is_some()
+                {
+                    return Ok(value);
+                }
+                // 5. CArgObject with 'P' tag (byref(c_void_p(...)))
+                if let Some(carg) = value.downcast_ref::<CArgObject>()
+                    && carg.tag == b'P'
+                {
+                    return Ok(value.clone());
+                }
+                // 6. PyCFuncPtr → extract function pointer address
+                if let Some(funcptr) = value.downcast_ref::<PyCFuncPtr>() {
+                    let ptr_val = {
+                        let buffer = funcptr._base.buffer.read();
+                        if buffer.len() >= core::mem::size_of::<usize>() {
+                            usize::from_ne_bytes(
+                                buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
+                            )
+                        } else {
+                            0
+                        }
+                    };
+                    return Ok(CArgObject {
+                        tag: b'P',
+                        value: FfiArgValue::Pointer(ptr_val),
+                        obj: value.clone(),
+                        size: 0,
+                        offset: 0,
+                    }
+                    .to_pyobject(vm));
+                }
+                // 7. c_char_p or c_wchar_p instance → extract pointer value
+                if let Some(simple) = value.downcast_ref::<PyCSimple>() {
+                    let value_type_code = value.class().type_code(vm);
+                    if matches!(value_type_code.as_deref(), Some("z") | Some("Z")) {
+                        let ptr_val = {
+                            let buffer = simple.0.buffer.read();
+                            if buffer.len() >= core::mem::size_of::<usize>() {
+                                usize::from_ne_bytes(
+                                    buffer[..core::mem::size_of::<usize>()].try_into().unwrap(),
+                                )
+                            } else {
+                                0
+                            }
+                        };
+                        return Ok(CArgObject {
+                            tag: b'Z',
+                            value: FfiArgValue::Pointer(ptr_val),
+                            obj: value.clone(),
+                            size: 0,
+                            offset: 0,
+                        }
+                        .to_pyobject(vm));
+                    }
+                }
+            }
+            // c_bool
+            Some("?") => {
+                let bool_val = value.is_true(vm)?;
+                let bool_obj: PyObjectRef = vm.ctx.new_bool(bool_val).into();
+                return create_simple_with_value("?", &bool_obj);
+            }
+            _ => {}
+        }
+
+        // 5. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCSimpleType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        // 6. Type-specific error messages
+        match type_code.as_deref() {
+            Some("z") => Err(vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as ctypes.c_char_p",
+                value.class().name()
+            ))),
+            Some("Z") => Err(vm.new_type_error(format!(
+                "'{}' object cannot be interpreted as ctypes.c_wchar_p",
+                value.class().name()
+            ))),
+            _ => Err(vm.new_type_error("wrong type")),
+        }
+    }
+
+    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        PyCSimple::repeat(cls, n, vm)
+    }
+}
+
+impl AsNumber for PyCSimpleType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            multiply: Some(|a, b, vm| {
+                // a is a PyCSimpleType instance (type object like c_char)
+                // b is int (array size)
+                let cls = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
+                let n = b
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_isize()
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+                PyCSimple::repeat(cls.to_owned(), n, vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl Initializer for PyCSimpleType {
+    type Args = FuncArgs;
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // type_init requires exactly 3 positional arguments: name, bases, dict
+        if args.args.len() != 3 {
+            return Err(vm.new_type_error(format!(
+                "type.__init__() takes 3 positional arguments but {} were given",
+                args.args.len()
+            )));
+        }
+
+        // Get the type from the metatype instance
+        let type_ref: PyTypeRef = zelf
+            .as_object()
+            .to_owned()
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        type_ref.check_not_initialized(vm)?;
+
+        // Get _type_ attribute
+        let type_attr = match type_ref.as_object().get_attr("_type_", vm) {
+            Ok(attr) => attr,
+            Err(_) => {
+                return Err(vm.new_attribute_error("class must define a '_type_' attribute"));
+            }
+        };
+
+        // Validate _type_ is a string
+        let type_str = type_attr.str(vm)?.to_string();
+
+        // Validate _type_ is a single character
+        if type_str.len() != 1 {
+            return Err(vm.new_value_error(
+                "class must define a '_type_' attribute which must be a string of length 1"
+                    .to_owned(),
+            ));
+        }
+
+        // Validate _type_ is a valid type character
+        if !SIMPLE_TYPE_CHARS.contains(type_str.as_str()) {
+            return Err(vm.new_attribute_error(format!(
+                "class must define a '_type_' attribute which must be a single character string containing one of '{}', currently it is '{}'.",
+                SIMPLE_TYPE_CHARS, type_str
+            )));
+        }
+
+        // Initialize StgInfo
+        let size = super::get_size(&type_str);
+        let align = super::get_align(&type_str);
+        let mut stg_info = StgInfo::new(size, align);
+
+        // Set format for PEP 3118 buffer protocol
+        stg_info.format = Some(alloc_format_string_for_type(
+            type_str.chars().next().unwrap_or('?'),
+            cfg!(target_endian = "big"),
+        ));
+        stg_info.paramfunc = super::base::ParamFunc::Simple;
+
+        // Set TYPEFLAG_ISPOINTER for pointer types: z (c_char_p), Z (c_wchar_p),
+        // P (c_void_p), s (char array), X (BSTR), O (py_object)
+        if matches!(type_str.as_str(), "z" | "Z" | "P" | "s" | "X" | "O") {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_ISPOINTER;
+        }
+
+        super::base::set_or_init_stginfo(&type_ref, stg_info);
+
+        // Create __ctype_le__ and __ctype_be__ swapped types
+        create_swapped_types(&type_ref, &type_str, vm)?;
+
+        Ok(())
+    }
+}
+
+/// Create __ctype_le__ and __ctype_be__ swapped byte order types
+/// On little-endian systems: __ctype_le__ = self, __ctype_be__ = swapped type
+/// On big-endian systems: __ctype_be__ = self, __ctype_le__ = swapped type
+///
+/// - Single-byte types (c, b, B): __ctype_le__ = __ctype_be__ = self
+/// - Pointer/unsupported types (z, Z, P, u, O): NO __ctype_le__/__ctype_be__ attributes
+/// - Multi-byte numeric types (h, H, i, I, l, L, q, Q, f, d, g, ?): create swapped types
+fn create_swapped_types(
+    type_ref: &Py<PyType>,
+    type_str: &str,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    use crate::builtins::PyDict;
+
+    // Avoid infinite recursion - if __ctype_le__ already exists, skip
+    if type_ref.as_object().get_attr("__ctype_le__", vm).is_ok() {
+        return Ok(());
+    }
+
+    // Types that don't support byte order swapping - no __ctype_le__/__ctype_be__
+    // c_void_p (P), c_char_p (z), c_wchar_p (Z), c_wchar (u), py_object (O)
+    let unsupported_types = ["P", "z", "Z", "u", "O"];
+    if unsupported_types.contains(&type_str) {
+        return Ok(());
+    }
+
+    // Single-byte types - __ctype_le__ = __ctype_be__ = self (no swapping needed)
+    // c_char (c), c_byte (b), c_ubyte (B)
+    let single_byte_types = ["c", "b", "B"];
+    if single_byte_types.contains(&type_str) {
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        return Ok(());
+    }
+
+    // Multi-byte types - create swapped type
+    // Check system byte order at compile time
+    let is_little_endian = cfg!(target_endian = "little");
+
+    // Create dict for the swapped (non-native) type
+    let swapped_dict: crate::PyRef<crate::builtins::PyDict> = PyDict::default().into_ref(&vm.ctx);
+    swapped_dict.set_item("_type_", vm.ctx.new_str(type_str).into(), vm)?;
+
+    // Create the swapped type using the same metaclass
+    let metaclass = type_ref.class();
+    let bases = vm.ctx.new_tuple(vec![type_ref.as_object().to_owned()]);
+
+    // Set placeholder first to prevent recursion
+    type_ref
+        .as_object()
+        .set_attr("__ctype_le__", vm.ctx.none(), vm)?;
+    type_ref
+        .as_object()
+        .set_attr("__ctype_be__", vm.ctx.none(), vm)?;
+
+    // Create only the non-native endian type
+    let suffix = if is_little_endian { "_be" } else { "_le" };
+    let swapped_type = metaclass.as_object().call(
+        (
+            vm.ctx.new_str(format!("{}{}", type_ref.name(), suffix)),
+            bases,
+            swapped_dict.as_object().to_owned(),
+        ),
+        vm,
+    )?;
+
+    // Set _swappedbytes_ on the swapped type to indicate byte swapping is needed
+    swapped_type.set_attr("_swappedbytes_", vm.ctx.none(), vm)?;
+
+    // Update swapped type's StgInfo format to use opposite endian prefix
+    if let Ok(swapped_type_ref) = swapped_type.clone().downcast::<PyType>()
+        && let Some(mut sw_stg) = swapped_type_ref.get_type_data_mut::<StgInfo>()
+    {
+        // Swapped: little-endian system uses big-endian prefix and vice versa
+        sw_stg.format = Some(alloc_format_string_for_type(
+            type_str.chars().next().unwrap_or('?'),
+            is_little_endian,
+        ));
+    }
+
+    // Set attributes based on system byte order
+    // Native endian attribute points to self, non-native points to swapped type
+    if is_little_endian {
+        // Little-endian system: __ctype_le__ = self, __ctype_be__ = swapped
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", swapped_type.clone(), vm)?;
+        swapped_type.set_attr("__ctype_le__", type_ref.as_object().to_owned(), vm)?;
+        swapped_type.set_attr("__ctype_be__", swapped_type.clone(), vm)?;
+    } else {
+        // Big-endian system: __ctype_be__ = self, __ctype_le__ = swapped
+        type_ref
+            .as_object()
+            .set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        type_ref
+            .as_object()
+            .set_attr("__ctype_le__", swapped_type.clone(), vm)?;
+        swapped_type.set_attr("__ctype_be__", type_ref.as_object().to_owned(), vm)?;
+        swapped_type.set_attr("__ctype_le__", swapped_type.clone(), vm)?;
+    }
+
+    Ok(())
+}
+
+#[pyclass(
+    module = "_ctypes",
+    name = "_SimpleCData",
+    base = PyCData,
+    metaclass = "PyCSimpleType"
+)]
+#[repr(transparent)]
+pub struct PyCSimple(pub PyCData);
+
+impl Debug for PyCSimple {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyCSimple")
+            .field("size", &self.0.buffer.read().len())
+            .finish()
+    }
+}
+
+fn value_to_bytes_endian(
+    _type_: &str,
+    value: &PyObject,
+    swapped: bool,
+    vm: &VirtualMachine,
+) -> Vec<u8> {
+    // Helper macro for endian conversion
+    macro_rules! to_bytes {
+        ($val:expr) => {
+            if swapped {
+                // Use opposite endianness
+                #[cfg(target_endian = "little")]
+                {
+                    $val.to_be_bytes().to_vec()
+                }
+                #[cfg(target_endian = "big")]
+                {
+                    $val.to_le_bytes().to_vec()
+                }
+            } else {
+                $val.to_ne_bytes().to_vec()
+            }
+        };
+    }
+
+    match _type_ {
+        "c" => {
+            // c_char - single byte (bytes, bytearray, or int 0-255)
+            if let Some(bytes) = value.downcast_ref::<PyBytes>()
+                && !bytes.is_empty()
+            {
+                return vec![bytes.as_bytes()[0]];
+            }
+            if let Some(bytearray) = value.downcast_ref::<PyByteArray>() {
+                let buf = bytearray.borrow_buf();
+                if !buf.is_empty() {
+                    return vec![buf[0]];
+                }
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_u8()
+            {
+                return vec![v];
+            }
+            vec![0]
+        }
+        "u" => {
+            // c_wchar - platform-dependent size (2 on Windows, 4 on Unix)
+            if let Ok(s) = value.str(vm)
+                && let Some(c) = s.as_str().chars().next()
+            {
+                let mut buffer = vec![0u8; WCHAR_SIZE];
+                wchar_to_bytes(c as u32, &mut buffer);
+                if swapped {
+                    buffer.reverse();
+                }
+                return buffer;
+            }
+            vec![0; WCHAR_SIZE]
+        }
+        "b" => {
+            // c_byte - signed char (1 byte)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i8;
+                return vec![v as u8];
+            }
+            vec![0]
+        }
+        "B" => {
+            // c_ubyte - unsigned char (1 byte)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u8;
+                return vec![v];
+            }
+            vec![0]
+        }
+        "h" => {
+            // c_short (2 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i16;
+                return to_bytes!(v);
+            }
+            vec![0; 2]
+        }
+        "H" => {
+            // c_ushort (2 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u16;
+                return to_bytes!(v);
+            }
+            vec![0; 2]
+        }
+        "i" => {
+            // c_int (4 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i32;
+                return to_bytes!(v);
+            }
+            vec![0; 4]
+        }
+        "I" => {
+            // c_uint (4 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u32;
+                return to_bytes!(v);
+            }
+            vec![0; 4]
+        }
+        "l" => {
+            // c_long (platform dependent)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_long;
+                return to_bytes!(v);
+            }
+            const SIZE: usize = core::mem::size_of::<libc::c_long>();
+            vec![0; SIZE]
+        }
+        "L" => {
+            // c_ulong (platform dependent)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as libc::c_ulong;
+                return to_bytes!(v);
+            }
+            const SIZE: usize = core::mem::size_of::<libc::c_ulong>();
+            vec![0; SIZE]
+        }
+        "q" => {
+            // c_longlong (8 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as i64;
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "Q" => {
+            // c_ulonglong (8 bytes)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val.as_bigint().to_i128().expect("int too large") as u64;
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "f" => {
+            // c_float (4 bytes) - also accepts int
+            if let Ok(float_val) = value.try_float(vm) {
+                return to_bytes!(float_val.to_f64() as f32);
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_f64()
+            {
+                return to_bytes!(v as f32);
+            }
+            vec![0; 4]
+        }
+        "d" => {
+            // c_double (8 bytes) - also accepts int
+            if let Ok(float_val) = value.try_float(vm) {
+                return to_bytes!(float_val.to_f64());
+            }
+            if let Ok(int_val) = value.try_int(vm)
+                && let Some(v) = int_val.as_bigint().to_f64()
+            {
+                return to_bytes!(v);
+            }
+            vec![0; 8]
+        }
+        "g" => {
+            // long double - platform dependent size
+            // Store as f64, zero-pad to platform long double size
+            // Note: This may lose precision on platforms where long double > 64 bits
+            let f64_val = if let Ok(float_val) = value.try_float(vm) {
+                float_val.to_f64()
+            } else if let Ok(int_val) = value.try_int(vm) {
+                int_val.as_bigint().to_f64().unwrap_or(0.0)
+            } else {
+                0.0
+            };
+            let f64_bytes = if swapped {
+                #[cfg(target_endian = "little")]
+                {
+                    f64_val.to_be_bytes().to_vec()
+                }
+                #[cfg(target_endian = "big")]
+                {
+                    f64_val.to_le_bytes().to_vec()
+                }
+            } else {
+                f64_val.to_ne_bytes().to_vec()
+            };
+            // Pad to long double size
+            let long_double_size = super::get_size("g");
+            let mut result = f64_bytes;
+            result.resize(long_double_size, 0);
+            result
+        }
+        "?" => {
+            // c_bool (1 byte)
+            if let Ok(b) = value.to_owned().try_to_bool(vm) {
+                return vec![if b { 1 } else { 0 }];
+            }
+            vec![0]
+        }
+        "v" => {
+            // VARIANT_BOOL: True = 0xFFFF (-1 as i16), False = 0x0000
+            if let Ok(b) = value.to_owned().try_to_bool(vm) {
+                let val: i16 = if b { -1 } else { 0 };
+                return to_bytes!(val);
+            }
+            vec![0; 2]
+        }
+        "P" => {
+            // c_void_p - pointer type (platform pointer size)
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
+                return to_bytes!(v);
+            }
+            vec![0; core::mem::size_of::<usize>()]
+        }
+        "z" => {
+            // c_char_p - pointer to char (stores pointer value from int)
+            // PyBytes case is handled in slot_new/set_value with make_z_buffer()
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
+                return to_bytes!(v);
+            }
+            vec![0; core::mem::size_of::<usize>()]
+        }
+        "Z" => {
+            // c_wchar_p - pointer to wchar_t (stores pointer value from int)
+            // PyStr case is handled in slot_new/set_value with make_wchar_buffer()
+            if let Ok(int_val) = value.try_index(vm) {
+                let v = int_val
+                    .as_bigint()
+                    .to_usize()
+                    .expect("int too large for pointer");
+                return to_bytes!(v);
+            }
+            vec![0; core::mem::size_of::<usize>()]
+        }
+        "O" => {
+            // py_object - store object id as non-zero marker
+            // The actual object is stored in _objects
+            // Use object's id as a non-zero placeholder (indicates non-NULL)
+            let id = value.get_id();
+            to_bytes!(id)
+        }
+        _ => vec![0],
+    }
+}
+
+/// Check if value is a c_char array or pointer(c_char)
+fn is_cchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> bool {
+    // Check Array with c_char element type
+    if let Some(arr) = value.downcast_ref::<PyCArray>()
+        && let Some(info) = arr.class().stg_info_opt()
+        && let Some(ref elem_type) = info.element_type
+        && let Some(elem_code) = elem_type.type_code(vm)
+    {
+        return elem_code == "c";
+    }
+    // Check Pointer to c_char
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>()
+        && let Some(info) = ptr.class().stg_info_opt()
+        && let Some(ref proto) = info.proto
+        && let Some(proto_code) = proto.type_code(vm)
+    {
+        return proto_code == "c";
+    }
+    false
+}
+
+/// Check if value is a c_wchar array or pointer(c_wchar)
+fn is_cwchar_array_or_pointer(value: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+    // Check Array with c_wchar element type
+    if let Some(arr) = value.downcast_ref::<PyCArray>() {
+        let info = arr.class().stg_info(vm)?;
+        let elem_type = info.element_type.as_ref().expect("array has element_type");
+        if let Some(elem_code) = elem_type.type_code(vm) {
+            return Ok(elem_code == "u");
+        }
+    }
+    // Check Pointer to c_wchar
+    if let Some(ptr) = value.downcast_ref::<PyCPointer>() {
+        let info = ptr.class().stg_info(vm)?;
+        if let Some(ref proto) = info.proto
+            && let Some(proto_code) = proto.type_code(vm)
+        {
+            return Ok(proto_code == "u");
+        }
+    }
+    Ok(false)
+}
+
+impl Constructor for PyCSimple {
+    type Args = (OptionalArg,);
+
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let args: Self::Args = args.bind(vm)?;
+        let _type_ = cls
+            .type_code(vm)
+            .ok_or_else(|| vm.new_type_error("abstract class"))?;
+        // Save the initial argument for c_char_p/c_wchar_p _objects
+        let init_arg = args.0.into_option();
+
+        // Handle z/Z types with PyBytes/PyStr separately to avoid memory leak
+        if let Some(ref v) = init_arg {
+            if _type_ == "z" {
+                if let Some(bytes) = v.downcast_ref::<PyBytes>() {
+                    let (converted, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                    let buffer = ptr.to_ne_bytes().to_vec();
+                    let cdata = PyCData::from_bytes(buffer, Some(converted));
+                    return PyCSimple(cdata).into_ref_with_type(vm, cls).map(Into::into);
+                }
+            } else if _type_ == "Z"
+                && let Some(s) = v.downcast_ref::<PyStr>()
+            {
+                let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+                let buffer = ptr.to_ne_bytes().to_vec();
+                let cdata = PyCData::from_bytes(buffer, Some(holder));
+                return PyCSimple(cdata).into_ref_with_type(vm, cls).map(Into::into);
+            }
+        }
+
+        let value = if let Some(ref v) = init_arg {
+            set_primitive(_type_.as_str(), v, vm)?
+        } else {
+            match _type_.as_str() {
+                "c" | "u" => PyObjectRef::from(vm.ctx.new_bytes(vec![0])),
+                "b" | "B" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
+                    PyObjectRef::from(vm.ctx.new_int(0))
+                }
+                "f" | "d" | "g" => PyObjectRef::from(vm.ctx.new_float(0.0)),
+                "?" => PyObjectRef::from(vm.ctx.new_bool(false)),
+                _ => vm.ctx.none(), // "z" | "Z" | "P"
+            }
+        };
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        let buffer = value_to_bytes_endian(&_type_, &value, swapped, vm);
+
+        // For c_char_p (type "z"), c_wchar_p (type "Z"), and py_object (type "O"),
+        // store the initial value in _objects
+        let objects = if (_type_ == "z" || _type_ == "Z" || _type_ == "O") && init_arg.is_some() {
+            init_arg
+        } else {
+            None
+        };
+
+        PyCSimple(PyCData::from_bytes(buffer, objects))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyCSimple {
+    type Args = (OptionalArg,);
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // If an argument is provided, update the value
+        if let Some(value) = args.0.into_option() {
+            PyCSimple::set_value(zelf.into(), value, vm)?;
+        }
+        Ok(())
+    }
+}
+
+// Simple_repr
+impl Representable for PyCSimple {
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+        let cls = zelf.class();
+        let type_name = cls.name();
+
+        // Check if base is _SimpleCData (direct simple type like c_int, c_char)
+        // vs subclass of simple type (like class X(c_int): pass)
+        let bases = cls.bases.read();
+        let is_direct_simple = bases
+            .iter()
+            .any(|base| base.name().to_string() == "_SimpleCData");
+
+        if is_direct_simple {
+            // Direct SimpleCData: "typename(repr(value))"
+            let value = PyCSimple::value(zelf.to_owned().into(), vm)?;
+            let value_repr = value.repr(vm)?.to_string();
+            Ok(format!("{}({})", type_name, value_repr))
+        } else {
+            // Subclass: "<typename object at addr>"
+            let addr = zelf.get_id();
+            Ok(format!("<{} object at {:#x}>", type_name, addr))
+        }
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE),
+    with(Constructor, Initializer, AsBuffer, AsNumber, Representable)
+)]
+impl PyCSimple {
+    #[pygetset]
+    fn _b0_(&self) -> Option<PyObjectRef> {
+        self.0.base.read().clone()
+    }
+
+    #[pygetset]
+    pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let zelf: &Py<Self> = instance
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("cannot get value of instance"))?;
+
+        // Get _type_ from class
+        let cls = zelf.class();
+        let type_attr = cls
+            .as_object()
+            .get_attr("_type_", vm)
+            .map_err(|_| vm.new_type_error("no _type_ attribute"))?;
+        let type_code = type_attr.str(vm)?.to_string();
+
+        // Special handling for c_char_p (z) and c_wchar_p (Z)
+        // z_get, Z_get - dereference pointer to get string
+        if type_code == "z" {
+            // c_char_p: read pointer from buffer, dereference to get bytes string
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Ok(vm.ctx.none());
+            }
+            // Read null-terminated string at the address
+            unsafe {
+                let cstr = core::ffi::CStr::from_ptr(ptr as _);
+                return Ok(vm.ctx.new_bytes(cstr.to_bytes().to_vec()).into());
+            }
+        }
+        if type_code == "Z" {
+            // c_wchar_p: read pointer from buffer, dereference to get wide string
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Ok(vm.ctx.none());
+            }
+            // Read null-terminated wide string at the address
+            // Windows: wchar_t = u16 (UTF-16) -> use Wtf8Buf::from_wide for surrogate pairs
+            // Unix: wchar_t = i32 (UTF-32) -> convert via char::from_u32
+            unsafe {
+                let w_ptr = ptr as *const libc::wchar_t;
+                let len = libc::wcslen(w_ptr);
+                let wchars = core::slice::from_raw_parts(w_ptr, len);
+                #[cfg(windows)]
+                {
+                    use rustpython_common::wtf8::Wtf8Buf;
+                    let wide: Vec<u16> = wchars.to_vec();
+                    let wtf8 = Wtf8Buf::from_wide(&wide);
+                    return Ok(vm.ctx.new_str(wtf8).into());
+                }
+                #[cfg(not(windows))]
+                {
+                    let s: String = wchars
+                        .iter()
+                        .filter_map(|&c| char::from_u32(c as u32))
+                        .collect();
+                    return Ok(vm.ctx.new_str(s).into());
+                }
+            }
+        }
+
+        // O_get: py_object - read PyObject pointer from buffer
+        if type_code == "O" {
+            let buffer = zelf.0.buffer.read();
+            let ptr = super::base::read_ptr_from_buffer(&buffer);
+            if ptr == 0 {
+                return Err(vm.new_value_error("PyObject is NULL"));
+            }
+            // Non-NULL: return stored object from _objects if available
+            if let Some(obj) = zelf.0.objects.read().as_ref() {
+                return Ok(obj.clone());
+            }
+            return Err(vm.new_value_error("PyObject is NULL"));
+        }
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        // Read value from buffer, swap bytes if needed
+        let buffer = zelf.0.buffer.read();
+        let buffer_data: alloc::borrow::Cow<'_, [u8]> = if swapped {
+            // Reverse bytes for swapped endian types
+            let mut swapped_bytes = buffer.to_vec();
+            swapped_bytes.reverse();
+            alloc::borrow::Cow::Owned(swapped_bytes)
+        } else {
+            alloc::borrow::Cow::Borrowed(&*buffer)
+        };
+
+        let cls_ref = cls.to_owned();
+        bytes_to_pyobject(&cls_ref, &buffer_data, vm).or_else(|_| {
+            // Fallback: return bytes as integer based on type
+            match type_code.as_str() {
+                "c" => {
+                    if !buffer.is_empty() {
+                        Ok(vm.ctx.new_bytes(vec![buffer[0]]).into())
+                    } else {
+                        Ok(vm.ctx.new_bytes(vec![0]).into())
+                    }
+                }
+                "?" => {
+                    let val = buffer.first().copied().unwrap_or(0);
+                    Ok(vm.ctx.new_bool(val != 0).into())
+                }
+                _ => Ok(vm.ctx.new_int(0).into()),
+            }
+        })
+    }
+
+    #[pygetset(setter)]
+    fn set_value(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf: PyRef<Self> = instance
+            .clone()
+            .downcast()
+            .map_err(|_| vm.new_type_error("cannot set value of instance"))?;
+
+        // Get _type_ from class
+        let cls = zelf.class();
+        let type_attr = cls
+            .as_object()
+            .get_attr("_type_", vm)
+            .map_err(|_| vm.new_type_error("no _type_ attribute"))?;
+        let type_code = type_attr.str(vm)?.to_string();
+
+        // Handle z/Z types with PyBytes/PyStr separately to avoid memory leak
+        if type_code == "z" {
+            if let Some(bytes) = value.downcast_ref::<PyBytes>() {
+                let (converted, ptr) = super::base::ensure_z_null_terminated(bytes, vm);
+                *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+                *zelf.0.objects.write() = Some(converted);
+                return Ok(());
+            }
+        } else if type_code == "Z"
+            && let Some(s) = value.downcast_ref::<PyStr>()
+        {
+            let (holder, ptr) = super::base::str_to_wchar_bytes(s.as_str(), vm);
+            *zelf.0.buffer.write() = alloc::borrow::Cow::Owned(ptr.to_ne_bytes().to_vec());
+            *zelf.0.objects.write() = Some(holder);
+            return Ok(());
+        }
+
+        let content = set_primitive(&type_code, &value, vm)?;
+
+        // Check if this is a swapped endian type (presence of attribute indicates swapping)
+        let swapped = instance
+            .class()
+            .as_object()
+            .get_attr("_swappedbytes_", vm)
+            .is_ok();
+
+        // Update buffer when value changes
+        let buffer_bytes = value_to_bytes_endian(&type_code, &content, swapped, vm);
+
+        // If the buffer is borrowed (from shared memory), write in-place
+        // Otherwise replace with new owned buffer
+        let mut buffer = zelf.0.buffer.write();
+        match &mut *buffer {
+            Cow::Borrowed(slice) => {
+                // SAFETY: For from_buffer, the slice points to writable shared memory.
+                // Python's from_buffer requires writable buffer, so this is safe.
+                let ptr = slice.as_ptr() as *mut u8;
+                let len = slice.len().min(buffer_bytes.len());
+                unsafe {
+                    core::ptr::copy_nonoverlapping(buffer_bytes.as_ptr(), ptr, len);
+                }
+            }
+            Cow::Owned(vec) => {
+                vec.copy_from_slice(&buffer_bytes);
+            }
+        }
+
+        // For c_char_p (type "z"), c_wchar_p (type "Z"), and py_object (type "O"),
+        // keep the reference in _objects
+        if type_code == "z" || type_code == "Z" || type_code == "O" {
+            *zelf.0.objects.write() = Some(value);
+        }
+        Ok(())
+    }
+
+    #[pyclassmethod]
+    fn repeat(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        use super::array::array_type_from_ctype;
+
+        if n < 0 {
+            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+        }
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
+    }
+
+    /// Simple_from_outparm - convert output parameter back to Python value
+    /// For direct subclasses of _SimpleCData (e.g., c_int), returns the value.
+    /// For subclasses of those (e.g., class MyInt(c_int)), returns self.
+    #[pymethod]
+    fn __ctypes_from_outparam__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        // _ctypes_simple_instance: returns true if NOT a direct subclass of Simple_Type
+        // i.e., c_int (direct) -> false, MyInt(c_int) (subclass) -> true
+        let is_subclass_of_simple = {
+            let cls = zelf.class();
+            let bases = cls.bases.read();
+            // If base is NOT _SimpleCData, then it's a subclass of a subclass
+            !bases
+                .iter()
+                .any(|base| base.name().to_string() == "_SimpleCData")
+        };
+
+        if is_subclass_of_simple {
+            // Subclass of simple type (e.g., MyInt(c_int)): return self
+            Ok(zelf.into())
+        } else {
+            // Direct simple type (e.g., c_int): return value
+            PyCSimple::value(zelf.into(), vm)
+        }
+    }
+}
+
+impl PyCSimple {
+    /// Extract the value from this ctypes object as an owned FfiArgValue.
+    /// The value must be kept alive until after the FFI call completes.
+    pub fn to_ffi_value(
+        &self,
+        ty: libffi::middle::Type,
+        _vm: &VirtualMachine,
+    ) -> Option<FfiArgValue> {
+        let buffer = self.0.buffer.read();
+        let bytes: &[u8] = &buffer;
+
+        if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
+            if !bytes.is_empty() {
+                return Some(FfiArgValue::U8(bytes[0]));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
+            if !bytes.is_empty() {
+                return Some(FfiArgValue::I8(bytes[0] as i8));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
+            if bytes.len() >= 2 {
+                return Some(FfiArgValue::U16(u16::from_ne_bytes([bytes[0], bytes[1]])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
+            if bytes.len() >= 2 {
+                return Some(FfiArgValue::I16(i16::from_ne_bytes([bytes[0], bytes[1]])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::U32(u32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::I32(i32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::U64(u64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::I64(i64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f32().as_raw_ptr()) {
+            if bytes.len() >= 4 {
+                return Some(FfiArgValue::F32(f32::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3],
+                ])));
+            }
+        } else if core::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::f64().as_raw_ptr()) {
+            if bytes.len() >= 8 {
+                return Some(FfiArgValue::F64(f64::from_ne_bytes([
+                    bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
+                ])));
+            }
+        } else if 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
+    }
+}
+
+impl AsBuffer for PyCSimple {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let stg_info = zelf
+            .class()
+            .stg_info_opt()
+            .expect("PyCSimple type must have StgInfo");
+        let format = stg_info
+            .format
+            .clone()
+            .map(Cow::Owned)
+            .unwrap_or(Cow::Borrowed("B"));
+        let itemsize = stg_info.size;
+        // Simple types are scalars with ndim=0, shape=()
+        let desc = BufferDescriptor {
+            len: itemsize,
+            readonly: false,
+            itemsize,
+            format,
+            dim_desc: vec![],
+        };
+        let buf = PyBuffer::new(zelf.to_owned().into(), desc, &CDATA_BUFFER_METHODS);
+        Ok(buf)
+    }
+}
+
+/// Simple_bool: return non-zero if any byte in buffer is non-zero
+impl AsNumber for PyCSimple {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            boolean: Some(|obj, _vm| {
+                let zelf = obj
+                    .downcast_ref::<PyCSimple>()
+                    .expect("PyCSimple::as_number called on non-PyCSimple");
+                let buffer = zelf.0.buffer.read();
+                // Simple_bool: memcmp(self->b_ptr, zeros, self->b_size)
+                // Returns true if any byte is non-zero
+                Ok(buffer.iter().any(|&b| b != 0))
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/structure.rs b/crates/vm/src/stdlib/ctypes/structure.rs
new file mode 100644
index 0000000000..cd36ce8556
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/structure.rs
@@ -0,0 +1,668 @@
+use super::base::{CDATA_BUFFER_METHODS, PyCData, PyCField, StgInfo, StgInfoFlags};
+use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
+use crate::convert::ToPyObject;
+use crate::function::FuncArgs;
+use crate::function::PySetterValue;
+use crate::protocol::{BufferDescriptor, PyBuffer, PyNumberMethods};
+use crate::types::{AsBuffer, AsNumber, Constructor, Initializer, SetAttr};
+use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use alloc::borrow::Cow;
+use core::fmt::Debug;
+use num_traits::ToPrimitive;
+
+/// Calculate Structure type size from _fields_ (sum of field sizes)
+pub(super) fn calculate_struct_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
+        let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+        let mut total_size = 0usize;
+
+        for field in fields.iter() {
+            if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                && let Some(field_type) = tuple.get(1)
+            {
+                total_size += super::_ctypes::sizeof(field_type.clone(), vm)?;
+            }
+        }
+        return Ok(total_size);
+    }
+    Ok(0)
+}
+
+/// PyCStructType - metaclass for Structure
+#[pyclass(name = "PyCStructType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCStructType(PyType);
+
+impl Constructor for PyCStructType {
+    type Args = FuncArgs;
+
+    fn slot_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // 1. Create the new class using PyType::slot_new
+        let new_class = crate::builtins::type_::PyType::slot_new(metatype, args, vm)?;
+
+        // 2. Get the new type
+        let new_type = new_class
+            .clone()
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // 3. Mark base classes as finalized (subclassing finalizes the parent)
+        new_type.mark_bases_final();
+
+        // 4. Initialize StgInfo for the new type (initialized=false, to be set in init)
+        let stg_info = StgInfo::default();
+        let _ = new_type.init_type_data(stg_info);
+
+        // Note: _fields_ processing moved to Initializer::init()
+        Ok(new_class)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyCStructType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef by converting PyRef<Self> -> PyObjectRef -> PyRef<PyType>
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // Backward compatibility: skip initialization for abstract types
+        if new_type
+            .get_direct_attr(vm.ctx.intern_str("_abstract_"))
+            .is_some()
+        {
+            return Ok(());
+        }
+
+        new_type.check_not_initialized(vm)?;
+
+        // Process _fields_ if defined directly on this class (not inherited)
+        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            Self::process_fields(&new_type, fields_attr, vm)?;
+        } else {
+            // No _fields_ defined - try to copy from base class (PyCStgInfo_clone)
+            let (has_base_info, base_clone) = {
+                let bases = new_type.bases.read();
+                if let Some(base) = bases.first() {
+                    (base.stg_info_opt().is_some(), Some(base.clone()))
+                } else {
+                    (false, None)
+                }
+            };
+
+            if has_base_info && let Some(ref base) = base_clone {
+                // Clone base StgInfo (release guard before getting mutable reference)
+                let stg_info_opt = base.stg_info_opt().map(|baseinfo| {
+                    let mut stg_info = baseinfo.clone();
+                    stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL in subclass
+                    stg_info.initialized = true;
+                    stg_info
+                });
+
+                if let Some(stg_info) = stg_info_opt {
+                    // Mark base as FINAL (now guard is released)
+                    if let Some(mut base_stg) = base.get_type_data_mut::<StgInfo>() {
+                        base_stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    }
+
+                    super::base::set_or_init_stginfo(&new_type, stg_info);
+                    return Ok(());
+                }
+            }
+
+            // No base StgInfo - create default
+            let mut stg_info = StgInfo::new(0, 1);
+            stg_info.paramfunc = super::base::ParamFunc::Structure;
+            stg_info.format = Some("B".to_string());
+            super::base::set_or_init_stginfo(&new_type, stg_info);
+        }
+
+        Ok(())
+    }
+}
+
+#[pyclass(flags(BASETYPE), with(AsNumber, Constructor, Initializer, SetAttr))]
+impl PyCStructType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the structure type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCStructType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
+    /// Called when a new Structure subclass is created
+    #[pyclassmethod]
+    fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+        cls.mark_bases_final();
+
+        // Check if _fields_ is defined
+        if let Some(fields_attr) = cls.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            Self::process_fields(&cls, fields_attr, vm)?;
+        }
+        Ok(())
+    }
+
+    /// Process _fields_ and create CField descriptors
+    fn process_fields(
+        cls: &Py<PyType>,
+        fields_attr: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if this is a swapped byte order structure
+        let is_swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        // Try to downcast to list or tuple
+        let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>() {
+            list.borrow_vec().to_vec()
+        } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
+            tuple.to_vec()
+        } else {
+            return Err(vm.new_type_error("_fields_ must be a list or tuple"));
+        };
+
+        let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+        let forced_alignment =
+            super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
+
+        // Determine byte order for format string
+        let big_endian = super::base::is_big_endian(is_swapped);
+
+        // Initialize offset, alignment, type flags, and ffi_field_types from base class
+        let (
+            mut offset,
+            mut max_align,
+            mut has_pointer,
+            mut has_union,
+            mut has_bitfield,
+            mut ffi_field_types,
+        ) = {
+            let bases = cls.bases.read();
+            if let Some(base) = bases.first()
+                && let Some(baseinfo) = base.stg_info_opt()
+            {
+                (
+                    baseinfo.size,
+                    core::cmp::max(baseinfo.align, forced_alignment),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASUNION),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
+                    baseinfo.ffi_field_types.clone(),
+                )
+            } else {
+                (0, forced_alignment, false, false, false, Vec::new())
+            }
+        };
+
+        // Initialize PEP3118 format string
+        let mut format = String::from("T{");
+        let mut last_end = 0usize; // Track end of last field for padding calculation
+
+        for (index, field) in fields.iter().enumerate() {
+            let field_tuple = field
+                .downcast_ref::<PyTuple>()
+                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
+
+            if field_tuple.len() < 2 {
+                return Err(vm.new_type_error(
+                    "_fields_ tuple must have at least 2 elements (name, type)".to_string(),
+                ));
+            }
+
+            let name = field_tuple
+                .first()
+                .expect("len checked")
+                .downcast_ref::<PyStr>()
+                .ok_or_else(|| vm.new_type_error("field name must be a string"))?
+                .to_string();
+
+            let field_type = field_tuple.get(1).expect("len checked").clone();
+
+            // For swapped byte order structures, validate field type supports byte swapping
+            if is_swapped {
+                super::base::check_other_endian_support(&field_type, vm)?;
+            }
+
+            // Get size and alignment of the field type
+            let size = super::base::get_field_size(&field_type, vm)?;
+            let field_align = super::base::get_field_align(&field_type, vm);
+
+            // Calculate effective alignment (PyCField_FromDesc)
+            let effective_align = if pack > 0 {
+                core::cmp::min(pack, field_align)
+            } else {
+                field_align
+            };
+
+            // Apply padding to align offset (cfield.c NO_BITFIELD case)
+            if effective_align > 0 && offset % effective_align != 0 {
+                let delta = effective_align - (offset % effective_align);
+                offset += delta;
+            }
+
+            max_align = max_align.max(effective_align);
+
+            // Propagate type flags from field type (HASPOINTER, HASUNION, HASBITFIELD)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+            {
+                // HASPOINTER: propagate if field is pointer or contains pointer
+                if field_stg.flags.intersects(
+                    StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER,
+                ) {
+                    has_pointer = true;
+                }
+                // HASUNION, HASBITFIELD: propagate directly
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASUNION) {
+                    has_union = true;
+                }
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD) {
+                    has_bitfield = true;
+                }
+                // Collect FFI type for this field
+                ffi_field_types.push(field_stg.to_ffi_type());
+            }
+
+            // Mark field type as finalized (using type as field finalizes it)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>() {
+                if let Some(mut stg_info) = type_obj.get_type_data_mut::<StgInfo>() {
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                } else {
+                    // Create StgInfo with FINAL flag if it doesn't exist
+                    let mut stg_info = StgInfo::new(size, field_align);
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    let _ = type_obj.init_type_data(stg_info);
+                }
+            }
+
+            // Build format string: add padding before field
+            let padding = offset - last_end;
+            if padding > 0 {
+                if padding != 1 {
+                    format.push_str(&padding.to_string());
+                }
+                format.push('x');
+            }
+
+            // Get field format and add to format string
+            let field_format = super::base::get_field_format(&field_type, big_endian, vm);
+
+            // Handle arrays: prepend shape
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+                && !field_stg.shape.is_empty()
+            {
+                let shape_str = field_stg
+                    .shape
+                    .iter()
+                    .map(|d| d.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",");
+                format.push_str(&std::format!("({}){}", shape_str, field_format));
+            } else {
+                format.push_str(&field_format);
+            }
+
+            // Add field name
+            format.push(':');
+            format.push_str(&name);
+            format.push(':');
+
+            // Create CField descriptor with padding-adjusted offset
+            let field_type_ref = field_type
+                .clone()
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("_fields_ type must be a ctypes type"))?;
+            let c_field = PyCField::new(field_type_ref, offset as isize, size as isize, index);
+
+            // Set the CField as a class attribute
+            cls.set_attr(vm.ctx.intern_str(name.clone()), c_field.to_pyobject(vm));
+
+            // Update tracking
+            last_end = offset + size;
+            offset += size;
+        }
+
+        // Calculate total_align = max(max_align, forced_alignment)
+        let total_align = core::cmp::max(max_align, forced_alignment);
+
+        // Calculate aligned_size (PyCStructUnionType_update_stginfo)
+        let aligned_size = if total_align > 0 {
+            offset.div_ceil(total_align) * total_align
+        } else {
+            offset
+        };
+
+        // Complete format string: add final padding and close
+        let final_padding = aligned_size - last_end;
+        if final_padding > 0 {
+            if final_padding != 1 {
+                format.push_str(&final_padding.to_string());
+            }
+            format.push('x');
+        }
+        format.push('}');
+
+        // Store StgInfo with aligned size and total alignment
+        let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.length = fields.len();
+        stg_info.format = Some(format);
+        stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL; // Mark as finalized
+        if has_pointer {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASPOINTER;
+        }
+        if has_union {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASUNION;
+        }
+        if has_bitfield {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASBITFIELD;
+        }
+        stg_info.paramfunc = super::base::ParamFunc::Structure;
+        // Set byte order: swap if _swappedbytes_ is defined
+        stg_info.big_endian = super::base::is_big_endian(is_swapped);
+        // Store FFI field types for structure passing
+        stg_info.ffi_field_types = ffi_field_types;
+        super::base::set_or_init_stginfo(cls, stg_info);
+
+        // Process _anonymous_ fields
+        super::base::make_anon_fields(cls, vm)?;
+
+        Ok(())
+    }
+
+    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
+        use super::array::array_type_from_ctype;
+
+        if n < 0 {
+            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
+        }
+        // Use cached array type creation
+        array_type_from_ctype(cls.into(), n as usize, vm)
+    }
+}
+
+impl AsNumber for PyCStructType {
+    fn as_number() -> &'static PyNumberMethods {
+        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+            multiply: Some(|a, b, vm| {
+                let cls = a
+                    .downcast_ref::<PyType>()
+                    .ok_or_else(|| vm.new_type_error("expected type"))?;
+                let n = b
+                    .try_index(vm)?
+                    .as_bigint()
+                    .to_isize()
+                    .ok_or_else(|| vm.new_overflow_error("array size too large"))?;
+                PyCStructType::__mul__(cls.to_owned(), n, vm)
+            }),
+            ..PyNumberMethods::NOT_IMPLEMENTED
+        };
+        &AS_NUMBER
+    }
+}
+
+impl SetAttr for PyCStructType {
+    fn setattro(
+        zelf: &Py<Self>,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if _fields_ is being set
+        if attr_name.as_str() == "_fields_" {
+            let pytype: &Py<PyType> = zelf.to_base();
+
+            // Check finalization in separate scope to release read lock before process_fields
+            // This prevents deadlock: process_fields needs write lock on the same RwLock
+            let is_final = {
+                let Some(stg_info) = pytype.get_type_data::<StgInfo>() else {
+                    return Err(vm.new_type_error("ctypes state is not initialized"));
+                };
+                stg_info.is_final()
+            }; // Read lock released here
+
+            if is_final {
+                return Err(vm.new_attribute_error("_fields_ is final"));
+            }
+
+            // Process _fields_ and set attribute
+            let PySetterValue::Assign(fields_value) = value else {
+                return Err(vm.new_attribute_error("cannot delete _fields_"));
+            };
+            // Process fields (this will also set DICTFLAG_FINAL)
+            PyCStructType::process_fields(pytype, fields_value.clone(), vm)?;
+            // Set the _fields_ attribute on the type
+            pytype
+                .attributes
+                .write()
+                .insert(vm.ctx.intern_str("_fields_"), fields_value);
+            return Ok(());
+        }
+        // Delegate to PyType's setattro logic for type attributes
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+        let pytype: &Py<PyType> = zelf.to_base();
+
+        // Check for data descriptor first
+        if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
+            let descr_set = attr.class().slots.descr_set.load();
+            if let Some(descriptor) = descr_set {
+                return descriptor(&attr, pytype.to_owned().into(), value, vm);
+            }
+        }
+
+        // Store in type's attributes dict
+        if let PySetterValue::Assign(value) = value {
+            pytype.attributes.write().insert(attr_name_interned, value);
+        } else {
+            let prev = pytype.attributes.write().shift_remove(attr_name_interned);
+            if prev.is_none() {
+                return Err(vm.new_attribute_error(format!(
+                    "type object '{}' has no attribute '{}'",
+                    pytype.name(),
+                    attr_name.as_str(),
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// PyCStructure - base class for Structure instances
+#[pyclass(
+    module = "_ctypes",
+    name = "Structure",
+    base = PyCData,
+    metaclass = "PyCStructType"
+)]
+#[repr(transparent)]
+pub struct PyCStructure(pub PyCData);
+
+impl Debug for PyCStructure {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyCStructure")
+            .field("size", &self.0.size())
+            .finish()
+    }
+}
+
+impl Constructor for PyCStructure {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Check for abstract class and extract values in a block to drop the borrow
+        let (total_size, total_align, length) = {
+            let stg_info = cls.stg_info(vm)?;
+            (stg_info.size, stg_info.align, stg_info.length)
+        };
+
+        // Mark the class as finalized (instance creation finalizes the type)
+        if let Some(mut stg_info_mut) = cls.get_type_data_mut::<StgInfo>() {
+            stg_info_mut.flags |= StgInfoFlags::DICTFLAG_FINAL;
+        }
+
+        // Initialize buffer with zeros using computed size
+        let mut new_stg_info = StgInfo::new(total_size, total_align);
+        new_stg_info.length = length;
+        PyCStructure(PyCData::from_stg_info(&new_stg_info))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl PyCStructure {
+    /// Recursively initialize positional arguments through inheritance chain
+    /// Returns the number of arguments consumed
+    fn init_pos_args(
+        self_obj: &Py<Self>,
+        type_obj: &Py<PyType>,
+        args: &[PyObjectRef],
+        kwargs: &indexmap::IndexMap<String, PyObjectRef>,
+        index: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        let mut current_index = index;
+
+        // 1. First process base class fields recursively
+        let base_clone = {
+            let bases = type_obj.bases.read();
+            if let Some(base) = bases.first()
+                && base.stg_info_opt().is_some()
+            {
+                Some(base.clone())
+            } else {
+                None
+            }
+        };
+
+        if let Some(ref base) = base_clone {
+            current_index = Self::init_pos_args(self_obj, base, args, kwargs, current_index, vm)?;
+        }
+
+        // 2. Process this class's _fields_
+        if let Some(fields_attr) = type_obj.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+
+            for field in fields.iter() {
+                if current_index >= args.len() {
+                    break;
+                }
+                if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                    && let Some(name) = tuple.first()
+                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                {
+                    let field_name = name_str.as_str().to_owned();
+                    // Check for duplicate in kwargs
+                    if kwargs.contains_key(&field_name) {
+                        return Err(vm.new_type_error(format!(
+                            "duplicate values for field {:?}",
+                            field_name
+                        )));
+                    }
+                    self_obj.as_object().set_attr(
+                        vm.ctx.intern_str(field_name),
+                        args[current_index].clone(),
+                        vm,
+                    )?;
+                    current_index += 1;
+                }
+            }
+        }
+
+        Ok(current_index)
+    }
+}
+
+impl Initializer for PyCStructure {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Struct_init: handle positional and keyword arguments
+        let cls = zelf.class().to_owned();
+
+        // 1. Process positional arguments recursively through inheritance chain
+        if !args.args.is_empty() {
+            let consumed =
+                PyCStructure::init_pos_args(&zelf, &cls, &args.args, &args.kwargs, 0, vm)?;
+
+            if consumed < args.args.len() {
+                return Err(vm.new_type_error("too many initializers"));
+            }
+        }
+
+        // 2. Process keyword arguments
+        for (key, value) in args.kwargs.iter() {
+            zelf.as_object()
+                .set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
+        }
+
+        Ok(())
+    }
+}
+
+// Note: GetAttr and SetAttr are not implemented here.
+// Field access is handled by CField descriptors registered on the class.
+
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsBuffer)
+)]
+impl PyCStructure {
+    #[pygetset]
+    fn _b0_(&self) -> Option<PyObjectRef> {
+        self.0.base.read().clone()
+    }
+}
+
+impl AsBuffer for PyCStructure {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // PyCData_NewGetBuffer: use info->format if available, otherwise "B"
+        let format = zelf
+            .class()
+            .stg_info_opt()
+            .and_then(|info| info.format.clone())
+            .unwrap_or_else(|| "B".to_string());
+
+        // Structure: ndim=0, shape=(), itemsize=struct_size
+        let buf = PyBuffer::new(
+            zelf.to_owned().into(),
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize: buffer_len,
+                format: Cow::Owned(format),
+                dim_desc: vec![], // ndim=0 means empty dim_desc
+            },
+            &CDATA_BUFFER_METHODS,
+        );
+        Ok(buf)
+    }
+}
diff --git a/crates/vm/src/stdlib/ctypes/union.rs b/crates/vm/src/stdlib/ctypes/union.rs
new file mode 100644
index 0000000000..aecef18ec7
--- /dev/null
+++ b/crates/vm/src/stdlib/ctypes/union.rs
@@ -0,0 +1,580 @@
+use super::base::{CDATA_BUFFER_METHODS, StgInfoFlags};
+use super::{PyCData, PyCField, StgInfo};
+use crate::builtins::{PyList, PyStr, PyTuple, PyType, PyTypeRef};
+use crate::convert::ToPyObject;
+use crate::function::FuncArgs;
+use crate::function::PySetterValue;
+use crate::protocol::{BufferDescriptor, PyBuffer};
+use crate::types::{AsBuffer, Constructor, Initializer, SetAttr};
+use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
+use alloc::borrow::Cow;
+
+/// Calculate Union type size from _fields_ (max field size)
+pub(super) fn calculate_union_size(cls: &Py<PyType>, vm: &VirtualMachine) -> PyResult<usize> {
+    if let Ok(fields_attr) = cls.as_object().get_attr("_fields_", vm) {
+        let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+        let mut max_size = 0usize;
+
+        for field in fields.iter() {
+            if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                && let Some(field_type) = tuple.get(1)
+            {
+                let field_size = super::_ctypes::sizeof(field_type.clone(), vm)?;
+                max_size = max_size.max(field_size);
+            }
+        }
+        return Ok(max_size);
+    }
+    Ok(0)
+}
+
+/// PyCUnionType - metaclass for Union
+#[pyclass(name = "UnionType", base = PyType, module = "_ctypes")]
+#[derive(Debug)]
+#[repr(transparent)]
+pub(super) struct PyCUnionType(PyType);
+
+impl Constructor for PyCUnionType {
+    type Args = FuncArgs;
+
+    fn slot_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // 1. Create the new class using PyType::slot_new
+        let new_class = crate::builtins::PyType::slot_new(metatype, args, vm)?;
+
+        // 2. Get the new type
+        let new_type = new_class
+            .clone()
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // 3. Mark base classes as finalized (subclassing finalizes the parent)
+        new_type.mark_bases_final();
+
+        // 4. Initialize StgInfo for the new type (initialized=false, to be set in init)
+        let stg_info = StgInfo::default();
+        let _ = new_type.init_type_data(stg_info);
+
+        // Note: _fields_ processing moved to Initializer::init()
+        Ok(new_class)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl Initializer for PyCUnionType {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Get the type as PyTypeRef by converting PyRef<Self> -> PyObjectRef -> PyRef<PyType>
+        let obj: PyObjectRef = zelf.clone().into();
+        let new_type: PyTypeRef = obj
+            .downcast()
+            .map_err(|_| vm.new_type_error("expected type"))?;
+
+        // Check for _abstract_ attribute - skip initialization if present
+        if new_type
+            .get_direct_attr(vm.ctx.intern_str("_abstract_"))
+            .is_some()
+        {
+            return Ok(());
+        }
+
+        new_type.check_not_initialized(vm)?;
+
+        // Process _fields_ if defined directly on this class (not inherited)
+        // Use set_attr to trigger setattro
+        if let Some(fields_attr) = new_type.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            new_type
+                .as_object()
+                .set_attr(vm.ctx.intern_str("_fields_"), fields_attr, vm)?;
+        } else {
+            // No _fields_ defined - try to copy from base class
+            let (has_base_info, base_clone) = {
+                let bases = new_type.bases.read();
+                if let Some(base) = bases.first() {
+                    (base.stg_info_opt().is_some(), Some(base.clone()))
+                } else {
+                    (false, None)
+                }
+            };
+
+            if has_base_info && let Some(ref base) = base_clone {
+                // Clone base StgInfo (release guard before getting mutable reference)
+                let stg_info_opt = base.stg_info_opt().map(|baseinfo| {
+                    let mut stg_info = baseinfo.clone();
+                    stg_info.flags &= !StgInfoFlags::DICTFLAG_FINAL; // Clear FINAL flag in subclass
+                    stg_info.initialized = true;
+                    stg_info
+                });
+
+                if let Some(stg_info) = stg_info_opt {
+                    // Mark base as FINAL (now guard is released)
+                    if let Some(mut base_stg) = base.get_type_data_mut::<StgInfo>() {
+                        base_stg.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    }
+
+                    super::base::set_or_init_stginfo(&new_type, stg_info);
+                    return Ok(());
+                }
+            }
+
+            // No base StgInfo - create default
+            let mut stg_info = StgInfo::new(0, 1);
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASUNION;
+            stg_info.paramfunc = super::base::ParamFunc::Union;
+            // PEP 3118 doesn't support union. Use 'B' for bytes.
+            stg_info.format = Some("B".to_string());
+            super::base::set_or_init_stginfo(&new_type, stg_info);
+        }
+
+        Ok(())
+    }
+}
+
+impl PyCUnionType {
+    /// Process _fields_ and create CField descriptors
+    /// For Union, all fields start at offset 0
+    fn process_fields(
+        cls: &Py<PyType>,
+        fields_attr: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // Check if already finalized
+        {
+            let Some(stg_info) = cls.get_type_data::<StgInfo>() else {
+                return Err(vm.new_type_error("ctypes state is not initialized"));
+            };
+            if stg_info.is_final() {
+                return Err(vm.new_attribute_error("_fields_ is final"));
+            }
+        } // Read lock released here
+
+        // Check if this is a swapped byte order union
+        let is_swapped = cls.as_object().get_attr("_swappedbytes_", vm).is_ok();
+
+        let fields: Vec<PyObjectRef> = if let Some(list) = fields_attr.downcast_ref::<PyList>() {
+            list.borrow_vec().to_vec()
+        } else if let Some(tuple) = fields_attr.downcast_ref::<PyTuple>() {
+            tuple.to_vec()
+        } else {
+            return Err(vm.new_type_error("_fields_ must be a list or tuple"));
+        };
+
+        let pack = super::base::get_usize_attr(cls.as_object(), "_pack_", 0, vm)?;
+        let forced_alignment =
+            super::base::get_usize_attr(cls.as_object(), "_align_", 1, vm)?.max(1);
+
+        // Initialize size, alignment, type flags, and ffi_field_types from base class
+        // Note: Union fields always start at offset 0, but we inherit base size/align
+        let (mut max_size, mut max_align, mut has_pointer, mut has_bitfield, mut ffi_field_types) = {
+            let bases = cls.bases.read();
+            if let Some(base) = bases.first()
+                && let Some(baseinfo) = base.stg_info_opt()
+            {
+                (
+                    baseinfo.size,
+                    core::cmp::max(baseinfo.align, forced_alignment),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASPOINTER),
+                    baseinfo.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD),
+                    baseinfo.ffi_field_types.clone(),
+                )
+            } else {
+                (0, forced_alignment, false, false, Vec::new())
+            }
+        };
+
+        for (index, field) in fields.iter().enumerate() {
+            let field_tuple = field
+                .downcast_ref::<PyTuple>()
+                .ok_or_else(|| vm.new_type_error("_fields_ must contain tuples"))?;
+
+            if field_tuple.len() < 2 {
+                return Err(vm.new_type_error(
+                    "_fields_ tuple must have at least 2 elements (name, type)".to_string(),
+                ));
+            }
+
+            let name = field_tuple
+                .first()
+                .expect("len checked")
+                .downcast_ref::<PyStr>()
+                .ok_or_else(|| vm.new_type_error("field name must be a string"))?
+                .to_string();
+
+            let field_type = field_tuple.get(1).expect("len checked").clone();
+
+            // For swapped byte order unions, validate field type supports byte swapping
+            if is_swapped {
+                super::base::check_other_endian_support(&field_type, vm)?;
+            }
+
+            let size = super::base::get_field_size(&field_type, vm)?;
+            let field_align = super::base::get_field_align(&field_type, vm);
+
+            // Calculate effective alignment
+            let effective_align = if pack > 0 {
+                core::cmp::min(pack, field_align)
+            } else {
+                field_align
+            };
+
+            max_size = max_size.max(size);
+            max_align = max_align.max(effective_align);
+
+            // Propagate type flags from field type (HASPOINTER, HASBITFIELD)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>()
+                && let Some(field_stg) = type_obj.stg_info_opt()
+            {
+                // HASPOINTER: propagate if field is pointer or contains pointer
+                if field_stg.flags.intersects(
+                    StgInfoFlags::TYPEFLAG_ISPOINTER | StgInfoFlags::TYPEFLAG_HASPOINTER,
+                ) {
+                    has_pointer = true;
+                }
+                // HASBITFIELD: propagate directly
+                if field_stg.flags.contains(StgInfoFlags::TYPEFLAG_HASBITFIELD) {
+                    has_bitfield = true;
+                }
+                // Collect FFI type for this field
+                ffi_field_types.push(field_stg.to_ffi_type());
+            }
+
+            // Mark field type as finalized (using type as field finalizes it)
+            if let Some(type_obj) = field_type.downcast_ref::<PyType>() {
+                if let Some(mut stg_info) = type_obj.get_type_data_mut::<StgInfo>() {
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                } else {
+                    // Create StgInfo with FINAL flag if it doesn't exist
+                    let mut stg_info = StgInfo::new(size, field_align);
+                    stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL;
+                    let _ = type_obj.init_type_data(stg_info);
+                }
+            }
+
+            // For Union, all fields start at offset 0
+            let field_type_ref = field_type
+                .clone()
+                .downcast::<PyType>()
+                .map_err(|_| vm.new_type_error("_fields_ type must be a ctypes type"))?;
+            let c_field = PyCField::new(field_type_ref, 0, size as isize, index);
+
+            cls.set_attr(vm.ctx.intern_str(name), c_field.to_pyobject(vm));
+        }
+
+        // Calculate total_align and aligned_size
+        let total_align = core::cmp::max(max_align, forced_alignment);
+        let aligned_size = if total_align > 0 {
+            max_size.div_ceil(total_align) * total_align
+        } else {
+            max_size
+        };
+
+        // Store StgInfo with aligned size
+        let mut stg_info = StgInfo::new(aligned_size, total_align);
+        stg_info.length = fields.len();
+        stg_info.flags |= StgInfoFlags::DICTFLAG_FINAL | StgInfoFlags::TYPEFLAG_HASUNION;
+        // PEP 3118 doesn't support union. Use 'B' for bytes.
+        stg_info.format = Some("B".to_string());
+        if has_pointer {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASPOINTER;
+        }
+        if has_bitfield {
+            stg_info.flags |= StgInfoFlags::TYPEFLAG_HASBITFIELD;
+        }
+        stg_info.paramfunc = super::base::ParamFunc::Union;
+        // Set byte order: swap if _swappedbytes_ is defined
+        stg_info.big_endian = super::base::is_big_endian(is_swapped);
+        // Store FFI field types for union passing
+        stg_info.ffi_field_types = ffi_field_types;
+        super::base::set_or_init_stginfo(cls, stg_info);
+
+        // Process _anonymous_ fields
+        super::base::make_anon_fields(cls, vm)?;
+
+        Ok(())
+    }
+}
+
+#[pyclass(flags(BASETYPE), with(Constructor, Initializer, SetAttr))]
+impl PyCUnionType {
+    #[pymethod]
+    fn from_param(zelf: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // zelf is the union type class that from_param was called on
+        let cls = zelf
+            .downcast::<PyType>()
+            .map_err(|_| vm.new_type_error("from_param: expected a type"))?;
+
+        // 1. If already an instance of the requested type, return it
+        if value.is_instance(cls.as_object(), vm)? {
+            return Ok(value);
+        }
+
+        // 2. Check for CArgObject (PyCArg_CheckExact)
+        if let Some(carg) = value.downcast_ref::<super::_ctypes::CArgObject>() {
+            // Check against proto (for pointer types)
+            if let Some(stg_info) = cls.stg_info_opt()
+                && let Some(ref proto) = stg_info.proto
+                && carg.obj.is_instance(proto.as_object(), vm)?
+            {
+                return Ok(value);
+            }
+            // Fallback: check if the wrapped object is an instance of the requested type
+            if carg.obj.is_instance(cls.as_object(), vm)? {
+                return Ok(value); // Return the CArgObject as-is
+            }
+            // CArgObject but wrong type
+            return Err(vm.new_type_error(format!(
+                "expected {} instance instead of pointer to {}",
+                cls.name(),
+                carg.obj.class().name()
+            )));
+        }
+
+        // 3. Check for _as_parameter_ attribute
+        if let Ok(as_parameter) = value.get_attr("_as_parameter_", vm) {
+            return PyCUnionType::from_param(cls.as_object().to_owned(), as_parameter, vm);
+        }
+
+        Err(vm.new_type_error(format!(
+            "expected {} instance instead of {}",
+            cls.name(),
+            value.class().name()
+        )))
+    }
+
+    /// Called when a new Union subclass is created
+    #[pyclassmethod]
+    fn __init_subclass__(cls: PyTypeRef, vm: &VirtualMachine) -> PyResult<()> {
+        cls.mark_bases_final();
+
+        // Check if _fields_ is defined
+        if let Some(fields_attr) = cls.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            Self::process_fields(&cls, fields_attr, vm)?;
+        }
+        Ok(())
+    }
+}
+
+impl SetAttr for PyCUnionType {
+    fn setattro(
+        zelf: &Py<Self>,
+        attr_name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let pytype: &Py<PyType> = zelf.to_base();
+        let attr_name_interned = vm.ctx.intern_str(attr_name.as_str());
+
+        // 1. First, do PyType's setattro (PyType_Type.tp_setattro first)
+        // Check for data descriptor first
+        if let Some(attr) = pytype.get_class_attr(attr_name_interned) {
+            let descr_set = attr.class().slots.descr_set.load();
+            if let Some(descriptor) = descr_set {
+                descriptor(&attr, pytype.to_owned().into(), value.clone(), vm)?;
+                // After successful setattro, check if _fields_ and call process_fields
+                if attr_name.as_str() == "_fields_"
+                    && let PySetterValue::Assign(fields_value) = value
+                {
+                    PyCUnionType::process_fields(pytype, fields_value, vm)?;
+                }
+                return Ok(());
+            }
+        }
+
+        // Store in type's attributes dict
+        match &value {
+            PySetterValue::Assign(v) => {
+                pytype
+                    .attributes
+                    .write()
+                    .insert(attr_name_interned, v.clone());
+            }
+            PySetterValue::Delete => {
+                let prev = pytype.attributes.write().shift_remove(attr_name_interned);
+                if prev.is_none() {
+                    return Err(vm.new_attribute_error(format!(
+                        "type object '{}' has no attribute '{}'",
+                        pytype.name(),
+                        attr_name.as_str(),
+                    )));
+                }
+            }
+        }
+
+        // 2. If _fields_, call process_fields (which checks FINAL internally)
+        if attr_name.as_str() == "_fields_"
+            && let PySetterValue::Assign(fields_value) = value
+        {
+            PyCUnionType::process_fields(pytype, fields_value, vm)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// PyCUnion - base class for Union
+#[pyclass(module = "_ctypes", name = "Union", base = PyCData, metaclass = "PyCUnionType")]
+#[repr(transparent)]
+pub struct PyCUnion(pub PyCData);
+
+impl core::fmt::Debug for PyCUnion {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PyCUnion")
+            .field("size", &self.0.size())
+            .finish()
+    }
+}
+
+impl Constructor for PyCUnion {
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        // Check for abstract class and extract values in a block to drop the borrow
+        let (total_size, total_align, length) = {
+            let stg_info = cls.stg_info(vm)?;
+            (stg_info.size, stg_info.align, stg_info.length)
+        };
+
+        // Mark the class as finalized (instance creation finalizes the type)
+        if let Some(mut stg_info_mut) = cls.get_type_data_mut::<StgInfo>() {
+            stg_info_mut.flags |= StgInfoFlags::DICTFLAG_FINAL;
+        }
+
+        // Initialize buffer with zeros using computed size
+        let mut new_stg_info = StgInfo::new(total_size, total_align);
+        new_stg_info.length = length;
+        PyCUnion(PyCData::from_stg_info(&new_stg_info))
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+    }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
+}
+
+impl PyCUnion {
+    /// Recursively initialize positional arguments through inheritance chain
+    /// Returns the number of arguments consumed
+    fn init_pos_args(
+        self_obj: &Py<Self>,
+        type_obj: &Py<PyType>,
+        args: &[PyObjectRef],
+        kwargs: &indexmap::IndexMap<String, PyObjectRef>,
+        index: usize,
+        vm: &VirtualMachine,
+    ) -> PyResult<usize> {
+        let mut current_index = index;
+
+        // 1. First process base class fields recursively
+        // Recurse if base has StgInfo
+        let base_clone = {
+            let bases = type_obj.bases.read();
+            if let Some(base) = bases.first() &&
+                // Check if base has StgInfo
+                base.stg_info_opt().is_some()
+            {
+                Some(base.clone())
+            } else {
+                None
+            }
+        };
+
+        if let Some(ref base) = base_clone {
+            current_index = Self::init_pos_args(self_obj, base, args, kwargs, current_index, vm)?;
+        }
+
+        // 2. Process this class's _fields_
+        if let Some(fields_attr) = type_obj.get_direct_attr(vm.ctx.intern_str("_fields_")) {
+            let fields: Vec<PyObjectRef> = fields_attr.try_to_value(vm)?;
+
+            for field in fields.iter() {
+                if current_index >= args.len() {
+                    break;
+                }
+                if let Some(tuple) = field.downcast_ref::<PyTuple>()
+                    && let Some(name) = tuple.first()
+                    && let Some(name_str) = name.downcast_ref::<PyStr>()
+                {
+                    let field_name = name_str.as_str().to_owned();
+                    // Check for duplicate in kwargs
+                    if kwargs.contains_key(&field_name) {
+                        return Err(vm.new_type_error(format!(
+                            "duplicate values for field {:?}",
+                            field_name
+                        )));
+                    }
+                    self_obj.as_object().set_attr(
+                        vm.ctx.intern_str(field_name),
+                        args[current_index].clone(),
+                        vm,
+                    )?;
+                    current_index += 1;
+                }
+            }
+        }
+
+        Ok(current_index)
+    }
+}
+
+impl Initializer for PyCUnion {
+    type Args = FuncArgs;
+
+    fn init(zelf: crate::PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+        // Struct_init: handle positional and keyword arguments
+        let cls = zelf.class().to_owned();
+
+        // 1. Process positional arguments recursively through inheritance chain
+        if !args.args.is_empty() {
+            let consumed = PyCUnion::init_pos_args(&zelf, &cls, &args.args, &args.kwargs, 0, vm)?;
+
+            if consumed < args.args.len() {
+                return Err(vm.new_type_error("too many initializers"));
+            }
+        }
+
+        // 2. Process keyword arguments
+        for (key, value) in args.kwargs.iter() {
+            zelf.as_object()
+                .set_attr(vm.ctx.intern_str(key.as_str()), value.clone(), vm)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[pyclass(
+    flags(BASETYPE, IMMUTABLETYPE),
+    with(Constructor, Initializer, AsBuffer)
+)]
+impl PyCUnion {}
+
+impl AsBuffer for PyCUnion {
+    fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let buffer_len = zelf.0.buffer.read().len();
+
+        // PyCData_NewGetBuffer: use info->format if available, otherwise "B"
+        let format = zelf
+            .class()
+            .stg_info_opt()
+            .and_then(|info| info.format.clone())
+            .unwrap_or_else(|| "B".to_string());
+
+        // Union: ndim=0, shape=(), itemsize=union_size
+        let buf = PyBuffer::new(
+            zelf.to_owned().into(),
+            BufferDescriptor {
+                len: buffer_len,
+                readonly: false,
+                itemsize: buffer_len,
+                format: Cow::Owned(format),
+                dim_desc: vec![], // ndim=0 means empty dim_desc
+            },
+            &CDATA_BUFFER_METHODS,
+        );
+        Ok(buf)
+    }
+}
diff --git a/vm/src/stdlib/errno.rs b/crates/vm/src/stdlib/errno.rs
similarity index 100%
rename from vm/src/stdlib/errno.rs
rename to crates/vm/src/stdlib/errno.rs
diff --git a/vm/src/stdlib/functools.rs b/crates/vm/src/stdlib/functools.rs
similarity index 83%
rename from vm/src/stdlib/functools.rs
rename to crates/vm/src/stdlib/functools.rs
index 21724db892..a59fd48f6b 100644
--- a/vm/src/stdlib/functools.rs
+++ b/crates/vm/src/stdlib/functools.rs
@@ -43,7 +43,7 @@ mod _functools {
     }
 
     #[pyattr]
-    #[pyclass(name = "partial", module = "_functools")]
+    #[pyclass(name = "partial", module = "functools")]
     #[derive(Debug, PyPayload)]
     pub struct PyPartial {
         inner: PyRwLock<PyPartialInner>,
@@ -73,8 +73,8 @@ mod _functools {
             self.inner.read().keywords.clone()
         }
 
-        #[pymethod(name = "__reduce__")]
-        fn reduce(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult {
+        #[pymethod]
+        fn __reduce__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult {
             let inner = zelf.inner.read();
             let partial_type = zelf.class();
 
@@ -204,7 +204,11 @@ mod _functools {
     impl Constructor for PyPartial {
         type Args = FuncArgs;
 
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(
+            _cls: &crate::Py<crate::builtins::PyType>,
+            args: Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let (func, args_slice) = args
                 .args
                 .split_first()
@@ -230,15 +234,13 @@ mod _functools {
                 final_keywords.set_item(vm.ctx.intern_str(key.as_str()), value, vm)?;
             }
 
-            let partial = Self {
+            Ok(Self {
                 inner: PyRwLock::new(PyPartialInner {
                     func: final_func,
                     args: vm.ctx.new_tuple(final_args),
                     keywords: final_keywords,
                 }),
-            };
-
-            partial.into_ref_with_type(vm, cls).map(Into::into)
+            })
         }
     }
 
@@ -246,15 +248,24 @@ mod _functools {
         type Args = FuncArgs;
 
         fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            let inner = zelf.inner.read();
-            let mut combined_args = inner.args.as_slice().to_vec();
+            // Clone and release lock before calling Python code to prevent deadlock
+            let (func, stored_args, keywords) = {
+                let inner = zelf.inner.read();
+                (
+                    inner.func.clone(),
+                    inner.args.clone(),
+                    inner.keywords.clone(),
+                )
+            };
+
+            let mut combined_args = stored_args.as_slice().to_vec();
             combined_args.extend_from_slice(&args.args);
 
             // Merge keywords from self.keywords and args.kwargs
             let mut final_kwargs = IndexMap::new();
 
             // Add keywords from self.keywords
-            for (key, value) in &*inner.keywords {
+            for (key, value) in &*keywords {
                 let key_str = key
                     .downcast::<crate::builtins::PyStr>()
                     .map_err(|_| vm.new_type_error("keywords must be strings"))?;
@@ -266,9 +277,7 @@ mod _functools {
                 final_kwargs.insert(key, value);
             }
 
-            inner
-                .func
-                .call(FuncArgs::new(combined_args, KwArgs::new(final_kwargs)), vm)
+            func.call(FuncArgs::new(combined_args, KwArgs::new(final_kwargs)), vm)
         }
     }
 
@@ -278,15 +287,24 @@ mod _functools {
             // Check for recursive repr
             let obj = zelf.as_object();
             if let Some(_guard) = ReprGuard::enter(vm, obj) {
-                let inner = zelf.inner.read();
-                let func_repr = inner.func.repr(vm)?;
+                // Clone and release lock before calling Python code to prevent deadlock
+                let (func, args, keywords) = {
+                    let inner = zelf.inner.read();
+                    (
+                        inner.func.clone(),
+                        inner.args.clone(),
+                        inner.keywords.clone(),
+                    )
+                };
+
+                let func_repr = func.repr(vm)?;
                 let mut parts = vec![func_repr.as_str().to_owned()];
 
-                for arg in inner.args.as_slice() {
+                for arg in args.as_slice() {
                     parts.push(arg.repr(vm)?.as_str().to_owned());
                 }
 
-                for (key, value) in inner.keywords.clone() {
+                for (key, value) in &*keywords {
                     // For string keys, use them directly without quotes
                     let key_part = if let Ok(s) = key.clone().downcast::<crate::builtins::PyStr>() {
                         s.as_str().to_owned()
@@ -301,28 +319,22 @@ mod _functools {
                     ));
                 }
 
-                let class_name = zelf.class().name();
+                let qualname = zelf.class().__qualname__(vm);
+                let qualname_str = qualname
+                    .downcast::<crate::builtins::PyStr>()
+                    .map(|s| s.as_str().to_owned())
+                    .unwrap_or_else(|_| zelf.class().name().to_owned());
                 let module = zelf.class().__module__(vm);
 
-                let qualified_name = if zelf.class().is(Self::class(&vm.ctx)) {
-                    // For the base partial class, always use functools.partial
-                    "functools.partial".to_owned()
-                } else {
-                    // For subclasses, check if they're defined in __main__ or test modules
-                    match module.downcast::<crate::builtins::PyStr>() {
-                        Ok(module_str) => {
-                            let module_name = module_str.as_str();
-                            match module_name {
-                                "builtins" | "" | "__main__" => class_name.to_owned(),
-                                name if name.starts_with("test.") || name == "test" => {
-                                    // For test modules, just use the class name without module prefix
-                                    class_name.to_owned()
-                                }
-                                _ => format!("{module_name}.{class_name}"),
-                            }
+                let qualified_name = match module.downcast::<crate::builtins::PyStr>() {
+                    Ok(module_str) => {
+                        let module_name = module_str.as_str();
+                        match module_name {
+                            "builtins" | "" => qualname_str,
+                            _ => format!("{module_name}.{qualname_str}"),
                         }
-                        Err(_) => class_name.to_owned(),
                     }
+                    Err(_) => qualname_str,
                 };
 
                 Ok(format!(
diff --git a/vm/src/stdlib/imp.rs b/crates/vm/src/stdlib/imp.rs
similarity index 94%
rename from vm/src/stdlib/imp.rs
rename to crates/vm/src/stdlib/imp.rs
index 596847776f..ad2cede975 100644
--- a/vm/src/stdlib/imp.rs
+++ b/crates/vm/src/stdlib/imp.rs
@@ -2,6 +2,8 @@ use crate::frozen::FrozenModule;
 use crate::{VirtualMachine, builtins::PyBaseExceptionRef};
 pub(crate) use _imp::make_module;
 
+pub use crate::vm::resolve_frozen_alias;
+
 #[cfg(feature = "threading")]
 #[pymodule(sub)]
 mod lock {
@@ -85,15 +87,18 @@ mod _imp {
         PyObjectRef, PyRef, PyResult, VirtualMachine,
         builtins::{PyBytesRef, PyCode, PyMemoryView, PyModule, PyStrRef},
         function::OptionalArg,
-        import,
+        import, version,
     };
 
     #[pyattr]
     fn check_hash_based_pycs(vm: &VirtualMachine) -> PyStrRef {
         vm.ctx
-            .new_str(vm.state.settings.check_hash_pycs_mode.to_string())
+            .new_str(vm.state.config.settings.check_hash_pycs_mode.to_string())
     }
 
+    #[pyattr(name = "pyc_magic_number_token")]
+    use version::PYC_MAGIC_NUMBER_TOKEN;
+
     #[pyfunction]
     const fn extension_suffixes() -> PyResult<Vec<PyObjectRef>> {
         Ok(Vec::new())
@@ -188,7 +193,7 @@ mod _imp {
             Err(e) => return Err(e.to_pyexception(name.as_str(), vm)),
         };
 
-        let origname = name; // FIXME: origname != name
+        let origname = vm.ctx.new_str(super::resolve_frozen_alias(name.as_str()));
         Ok(Some((None, info.package, origname)))
     }
 
diff --git a/vm/src/stdlib/io.rs b/crates/vm/src/stdlib/io.rs
similarity index 78%
rename from vm/src/stdlib/io.rs
rename to crates/vm/src/stdlib/io.rs
index c546a0c46f..9cb0b7d7d2 100644
--- a/vm/src/stdlib/io.rs
+++ b/crates/vm/src/stdlib/io.rs
@@ -9,36 +9,77 @@ cfg_if::cfg_if! {
     }
 }
 
+// EAGAIN constant for BlockingIOError
+cfg_if::cfg_if! {
+    if #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] {
+        const EAGAIN: i32 = libc::EAGAIN;
+    } else {
+        const EAGAIN: i32 = 11; // Standard POSIX value
+    }
+}
+
 use crate::{
     PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
     builtins::{PyBaseExceptionRef, PyModule},
     common::os::ErrorExt,
     convert::{IntoPyException, ToPyException},
+    exceptions::{OSErrorBuilder, ToOSErrorBuilder},
 };
 pub use _io::{OpenArgs, io_open as open};
 
-impl ToPyException for std::io::Error {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+impl ToOSErrorBuilder for std::io::Error {
+    fn to_os_error_builder(&self, vm: &VirtualMachine) -> OSErrorBuilder {
         let errno = self.posix_errno();
-        let msg = self.to_string();
-        #[allow(clippy::let_and_return)]
-        let exc = vm.new_errno_error(errno, msg);
-
         #[cfg(windows)]
-        {
-            use crate::object::AsObject;
-            let winerror = if let Some(winerror) = self.raw_os_error() {
-                vm.new_pyobj(winerror)
+        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 {
-                vm.ctx.none()
-            };
+                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);
 
-            // FIXME: manual setup winerror due to lack of OSError.__init__ support
-            exc.as_object()
-                .set_attr("winerror", vm.new_pyobj(winerror), vm)
-                .unwrap();
+        #[cfg(windows)]
+        if let Some(winerror) = self.raw_os_error() {
+            use crate::convert::ToPyObject;
+            builder = builder.winerror(winerror.to_pyobject(vm));
         }
-        exc
+
+        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)
     }
 }
 
@@ -56,9 +97,7 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
     fileio::extend_module(vm, &module).unwrap();
 
-    let unsupported_operation = _io::UNSUPPORTED_OPERATION
-        .get_or_init(|| _io::make_unsupportedop(ctx))
-        .clone();
+    let unsupported_operation = _io::unsupported_operation().to_owned();
     extend_module!(vm, &module, {
         "UnsupportedOperation" => unsupported_operation,
         "BlockingIOError" => ctx.exceptions.blocking_io_error.to_owned(),
@@ -119,8 +158,8 @@ mod _io {
         AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
         TryFromBorrowedObject, TryFromObject,
         builtins::{
-            PyBaseExceptionRef, PyByteArray, PyBytes, PyBytesRef, PyIntRef, PyMemoryView, PyStr,
-            PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
+            PyBaseExceptionRef, PyBool, PyByteArray, PyBytes, PyBytesRef, PyDict, PyMemoryView,
+            PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef, PyUtf8StrRef,
         },
         class::StaticType,
         common::lock::{
@@ -129,6 +168,7 @@ mod _io {
         },
         common::wtf8::{Wtf8, Wtf8Buf},
         convert::ToPyObject,
+        exceptions::cstring_error,
         function::{
             ArgBytesLike, ArgIterable, ArgMemoryBuffer, ArgSize, Either, FuncArgs, IntoFuncArgs,
             OptionalArg, OptionalOption, PySetterValue,
@@ -139,18 +179,20 @@ mod _io {
         recursion::ReprGuard,
         types::{
             Callable, Constructor, DefaultConstructor, Destructor, Initializer, IterNext, Iterable,
+            Representable,
         },
         vm::VirtualMachine,
     };
+    use alloc::borrow::Cow;
     use bstr::ByteSlice;
-    use crossbeam_utils::atomic::AtomicCell;
-    use malachite_bigint::{BigInt, BigUint};
-    use num_traits::ToPrimitive;
-    use std::{
-        borrow::Cow,
-        io::{self, Cursor, SeekFrom, prelude::*},
+    use core::{
         ops::Range,
+        sync::atomic::{AtomicBool, Ordering},
     };
+    use crossbeam_utils::atomic::AtomicCell;
+    use malachite_bigint::BigInt;
+    use num_traits::ToPrimitive;
+    use std::io::{self, Cursor, SeekFrom, prelude::*};
 
     #[allow(clippy::let_and_return)]
     fn validate_whence(whence: i32) -> bool {
@@ -172,8 +214,38 @@ mod _io {
         }
     }
 
+    /// Check if an error is an OSError with errno == EINTR.
+    /// If so, call check_signals() and return Ok(None) to indicate retry.
+    /// Otherwise, return Ok(Some(val)) for success or Err for other errors.
+    /// This mirrors CPythons _PyIO_trap_eintr() pattern.
+    #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+    fn trap_eintr<T>(result: PyResult<T>, vm: &VirtualMachine) -> PyResult<Option<T>> {
+        match result {
+            Ok(val) => Ok(Some(val)),
+            Err(exc) => {
+                // Check if its an OSError with errno == EINTR
+                if exc.fast_isinstance(vm.ctx.exceptions.os_error)
+                    && let Ok(errno_attr) = exc.as_object().get_attr("errno", vm)
+                    && let Ok(errno_val) = i32::try_from_object(vm, errno_attr)
+                    && errno_val == libc::EINTR
+                {
+                    vm.check_signals()?;
+                    return Ok(None);
+                }
+                Err(exc)
+            }
+        }
+    }
+
+    /// WASM version: no EINTR handling needed
+    #[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
+    fn trap_eintr<T>(result: PyResult<T>, _vm: &VirtualMachine) -> PyResult<Option<T>> {
+        result.map(Some)
+    }
+
     pub fn new_unsupported_operation(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
-        vm.new_exception_msg(UNSUPPORTED_OPERATION.get().unwrap().clone(), msg)
+        vm.new_os_subtype_error(unsupported_operation().to_owned(), None, msg)
+            .upcast()
     }
 
     fn _unsupported<T>(vm: &VirtualMachine, zelf: &PyObject, operation: &str) -> PyResult<T> {
@@ -282,7 +354,7 @@ mod _io {
             // if we don't specify the number of bytes, or it's too big, give the whole rest of the slice
             let n = bytes.map_or_else(
                 || avail_slice.len(),
-                |n| std::cmp::min(n, avail_slice.len()),
+                |n| core::cmp::min(n, avail_slice.len()),
             );
             let b = avail_slice[..n].to_vec();
             self.cursor.set_position((pos + n) as u64);
@@ -394,7 +466,7 @@ mod _io {
 
     #[pyattr]
     #[pyclass(name = "_IOBase")]
-    #[derive(Debug, PyPayload)]
+    #[derive(Debug, Default, PyPayload)]
     pub struct _IOBase;
 
     #[pyclass(with(IterNext, Iterable, Destructor), flags(BASETYPE, HAS_DICT))]
@@ -425,7 +497,7 @@ mod _io {
         }
 
         #[pyattr]
-        fn __closed(ctx: &Context) -> PyIntRef {
+        fn __closed(ctx: &Context) -> PyRef<PyBool> {
             ctx.new_bool(false)
         }
 
@@ -607,8 +679,10 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "_RawIOBase", base = "_IOBase")]
-    pub(super) struct _RawIOBase;
+    #[pyclass(name = "_RawIOBase", base = _IOBase)]
+    #[derive(Debug, Default)]
+    #[repr(transparent)]
+    pub(super) struct _RawIOBase(_IOBase);
 
     #[pyclass(flags(BASETYPE, HAS_DICT))]
     impl _RawIOBase {
@@ -617,17 +691,26 @@ mod _io {
             if let Some(size) = size.to_usize() {
                 // FIXME: unnecessary zero-init
                 let b = PyByteArray::from(vec![0; size]).into_ref(&vm.ctx);
-                let n = <Option<usize>>::try_from_object(
+                let n = <Option<isize>>::try_from_object(
                     vm,
                     vm.call_method(&instance, "readinto", (b.clone(),))?,
                 )?;
-                Ok(n.map(|n| {
-                    let mut bytes = b.borrow_buf_mut();
-                    bytes.truncate(n);
-                    // FIXME: try to use Arc::unwrap on the bytearray to get at the inner buffer
-                    bytes.clone()
+                Ok(match n {
+                    None => vm.ctx.none(),
+                    Some(n) => {
+                        // Validate the return value is within bounds
+                        if n < 0 || (n as usize) > size {
+                            return Err(vm.new_value_error(format!(
+                                "readinto returned {n} outside buffer size {size}"
+                            )));
+                        }
+                        let n = n as usize;
+                        let mut bytes = b.borrow_buf_mut();
+                        bytes.truncate(n);
+                        // FIXME: try to use Arc::unwrap on the bytearray to get at the inner buffer
+                        bytes.clone().to_pyobject(vm)
+                    }
                 })
-                .to_pyobject(vm))
             } else {
                 vm.call_method(&instance, "readall", ())
             }
@@ -638,7 +721,14 @@ mod _io {
             let mut chunks = Vec::new();
             let mut total_len = 0;
             loop {
-                let data = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,))?;
+                // Loop with EINTR handling (PEP 475)
+                let data = loop {
+                    let res = vm.call_method(&instance, "read", (DEFAULT_BUFFER_SIZE,));
+                    match trap_eintr(res, vm)? {
+                        Some(val) => break val,
+                        None => continue,
+                    }
+                };
                 let data = <Option<PyBytesRef>>::try_from_object(vm, data)?;
                 match data {
                     None => {
@@ -665,8 +755,10 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "_BufferedIOBase", base = "_IOBase")]
-    struct _BufferedIOBase;
+    #[pyclass(name = "_BufferedIOBase", base = _IOBase)]
+    #[derive(Debug, Default)]
+    #[repr(transparent)]
+    struct _BufferedIOBase(_IOBase);
 
     #[pyclass(flags(BASETYPE))]
     impl _BufferedIOBase {
@@ -728,9 +820,10 @@ mod _io {
 
     // TextIO Base has no public constructor
     #[pyattr]
-    #[pyclass(name = "_TextIOBase", base = "_IOBase")]
-    #[derive(Debug, PyPayload)]
-    struct _TextIOBase;
+    #[pyclass(name = "_TextIOBase", base = _IOBase)]
+    #[derive(Debug, Default)]
+    #[repr(transparent)]
+    struct _TextIOBase(_IOBase);
 
     #[pyclass(flags(BASETYPE))]
     impl _TextIOBase {
@@ -738,6 +831,11 @@ mod _io {
         fn encoding(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
             vm.ctx.none()
         }
+
+        #[pygetset]
+        fn errors(_zelf: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
+            vm.ctx.none()
+        }
     }
 
     #[derive(FromArgs, Clone)]
@@ -838,18 +936,26 @@ mod _io {
             let rewind = self.raw_offset() + (self.pos - self.write_pos);
             if rewind != 0 {
                 self.raw_seek(-rewind, 1, vm)?;
-                self.raw_pos = -rewind;
+                self.raw_pos -= rewind;
             }
 
             while self.write_pos < self.write_end {
                 let n =
                     self.raw_write(None, self.write_pos as usize..self.write_end as usize, vm)?;
-                let n = n.ok_or_else(|| {
-                    vm.new_exception_msg(
-                        vm.ctx.exceptions.blocking_io_error.to_owned(),
-                        "write could not complete without blocking".to_owned(),
-                    )
-                })?;
+                let n = match n {
+                    Some(n) => n,
+                    None => {
+                        // BlockingIOError(errno, msg, characters_written=0)
+                        return Err(vm.invoke_exception(
+                            vm.ctx.exceptions.blocking_io_error.to_owned(),
+                            vec![
+                                vm.new_pyobj(EAGAIN),
+                                vm.new_pyobj("write could not complete without blocking"),
+                                vm.new_pyobj(0),
+                            ],
+                        )?);
+                    }
+                };
                 self.write_pos += n as Offset;
                 self.raw_pos = self.write_pos;
                 vm.check_signals()?;
@@ -894,7 +1000,10 @@ mod _io {
                     };
                     if offset >= -self.pos && offset <= available {
                         self.pos += offset;
-                        return Ok(current - available + offset);
+                        // GH-95782: character devices may report raw position 0
+                        // even after reading, which would make this negative
+                        let result = current - available + offset;
+                        return Ok(if result < 0 { 0 } else { result });
                     }
                 }
             }
@@ -950,7 +1059,7 @@ mod _io {
                 // TODO: loop if write() raises an interrupt
                 vm.call_method(self.raw.as_ref().unwrap(), "write", (mem_obj,))?
             } else {
-                let v = std::mem::take(&mut self.buffer);
+                let v = core::mem::take(&mut self.buffer);
                 let write_buf = VecBuffer::from(v).into_ref(&vm.ctx);
                 let mem_obj = PyMemoryView::from_buffer_range(
                     write_buf.clone().into_pybuffer(true),
@@ -1006,9 +1115,51 @@ mod _io {
                 }
             }
 
-            // TODO: something something check if error is BlockingIOError?
-            let _ = self.flush(vm);
+            // if BlockingIOError, shift buffer
+            // and try to buffer the new data; otherwise propagate the error
+            match self.flush(vm) {
+                Ok(()) => {}
+                Err(e) if e.fast_isinstance(vm.ctx.exceptions.blocking_io_error) => {
+                    if self.readable() {
+                        self.reset_read();
+                    }
+                    // Shift buffer and adjust positions
+                    let shift = self.write_pos;
+                    if shift > 0 {
+                        self.buffer
+                            .copy_within(shift as usize..self.write_end as usize, 0);
+                        self.write_end -= shift;
+                        self.raw_pos -= shift;
+                        self.pos -= shift;
+                        self.write_pos = 0;
+                    }
+                    let avail = self.buffer.len() - self.write_end as usize;
+                    if buf_len <= avail {
+                        // Everything can be buffered
+                        let buf = obj.borrow_buf();
+                        self.buffer[self.write_end as usize..][..buf_len].copy_from_slice(&buf);
+                        self.write_end += buf_len as Offset;
+                        self.pos += buf_len as Offset;
+                        return Ok(buf_len);
+                    }
+                    // Buffer as much as possible and return BlockingIOError
+                    let buf = obj.borrow_buf();
+                    self.buffer[self.write_end as usize..][..avail].copy_from_slice(&buf[..avail]);
+                    self.write_end += avail as Offset;
+                    self.pos += avail as Offset;
+                    return Err(vm.invoke_exception(
+                        vm.ctx.exceptions.blocking_io_error.to_owned(),
+                        vec![
+                            vm.new_pyobj(EAGAIN),
+                            vm.new_pyobj("write could not complete without blocking"),
+                            vm.new_pyobj(avail),
+                        ],
+                    )?);
+                }
+                Err(e) => return Err(e),
+            }
 
+            // Only reach here if flush succeeded
             let offset = self.raw_offset();
             if offset != 0 {
                 self.raw_seek(-offset, 1, vm)?;
@@ -1041,12 +1192,16 @@ mod _io {
                             let buffer_size = self.buffer.len() as _;
                             self.adjust_position(buffer_size);
                             self.write_end = buffer_size;
-                            // TODO: BlockingIOError(errno, msg, written)
-                            // written += self.buffer.len();
-                            return Err(vm.new_exception_msg(
+                            // BlockingIOError(errno, msg, characters_written)
+                            let chars_written = written + buffer_len;
+                            return Err(vm.invoke_exception(
                                 vm.ctx.exceptions.blocking_io_error.to_owned(),
-                                "write could not complete without blocking".to_owned(),
-                            ));
+                                vec![
+                                    vm.new_pyobj(EAGAIN),
+                                    vm.new_pyobj("write could not complete without blocking"),
+                                    vm.new_pyobj(chars_written),
+                                ],
+                            )?);
                         } else {
                             break;
                         }
@@ -1112,7 +1267,7 @@ mod _io {
                     }
                 };
             }
-            while remaining > 0 {
+            while remaining > 0 && !self.buffer.is_empty() {
                 // MINUS_LAST_BLOCK() in CPython
                 let r = self.buffer.len() * (remaining / self.buffer.len());
                 if r == 0 {
@@ -1175,7 +1330,7 @@ mod _io {
             let res = match v {
                 Either::A(v) => {
                     let v = v.unwrap_or(&mut self.buffer);
-                    let read_buf = VecBuffer::from(std::mem::take(v)).into_ref(&vm.ctx);
+                    let read_buf = VecBuffer::from(core::mem::take(v)).into_ref(&vm.ctx);
                     let mem_obj = PyMemoryView::from_buffer_range(
                         read_buf.clone().into_pybuffer(false),
                         buf_range,
@@ -1183,30 +1338,60 @@ mod _io {
                     )?
                     .into_ref(&vm.ctx);
 
-                    // TODO: loop if readinto() raises an interrupt
-                    let res =
-                        vm.call_method(self.raw.as_ref().unwrap(), "readinto", (mem_obj.clone(),));
+                    // Loop if readinto() raises EINTR (PEP 475)
+                    let res = loop {
+                        let res = vm.call_method(
+                            self.raw.as_ref().unwrap(),
+                            "readinto",
+                            (mem_obj.clone(),),
+                        );
+                        match trap_eintr(res, vm) {
+                            Ok(Some(val)) => break Ok(val),
+                            Ok(None) => continue, // EINTR, retry
+                            Err(e) => break Err(e),
+                        }
+                    };
 
                     mem_obj.release();
+                    // Always restore the buffer, even if an error occurred
                     *v = read_buf.take();
 
                     res?
                 }
                 Either::B(buf) => {
-                    let mem_obj = PyMemoryView::from_buffer_range(buf, buf_range, vm)?;
-                    // TODO: loop if readinto() raises an interrupt
-                    vm.call_method(self.raw.as_ref().unwrap(), "readinto", (mem_obj,))?
+                    let mem_obj =
+                        PyMemoryView::from_buffer_range(buf, buf_range, vm)?.into_ref(&vm.ctx);
+                    // Loop if readinto() raises EINTR (PEP 475)
+                    loop {
+                        let res = vm.call_method(
+                            self.raw.as_ref().unwrap(),
+                            "readinto",
+                            (mem_obj.clone(),),
+                        );
+                        match trap_eintr(res, vm)? {
+                            Some(val) => break val,
+                            None => continue,
+                        }
+                    }
                 }
             };
 
             if vm.is_none(&res) {
                 return Ok(None);
             }
-            let n = isize::try_from_object(vm, res)?;
+            // Try to convert to int; if it fails, treat as -1 and chain the TypeError
+            let (n, type_error) = match isize::try_from_object(vm, res.clone()) {
+                Ok(n) => (n, None),
+                Err(e) => (-1, Some(e)),
+            };
             if n < 0 || n as usize > len {
-                return Err(vm.new_os_error(format!(
+                let os_error = vm.new_os_error(format!(
                     "raw readinto() returned invalid length {n} (should have been between 0 and {len})"
-                )));
+                ));
+                if let Some(cause) = type_error {
+                    os_error.set___cause__(Some(cause));
+                }
+                return Err(os_error);
             }
             if n > 0 && self.abs_pos != -1 {
                 self.abs_pos += n as Offset
@@ -1249,7 +1434,14 @@ mod _io {
 
             let mut read_size = 0;
             loop {
-                let read_data = vm.call_method(self.raw.as_ref().unwrap(), "read", ())?;
+                // Loop with EINTR handling (PEP 475)
+                let read_data = loop {
+                    let res = vm.call_method(self.raw.as_ref().unwrap(), "read", ());
+                    match trap_eintr(res, vm)? {
+                        Some(val) => break val,
+                        None => continue,
+                    }
+                };
                 let read_data = <Option<PyBytesRef>>::try_from_object(vm, read_data)?;
 
                 match read_data {
@@ -1335,7 +1527,7 @@ mod _io {
                 } else if !(readinto1 && written != 0) {
                     let n = self.fill_buffer(vm)?;
                     if let Some(n) = n.filter(|&n| n > 0) {
-                        let n = std::cmp::min(n, remaining);
+                        let n = core::cmp::min(n, remaining);
                         buf.as_contiguous_mut().unwrap()[written..][..n]
                             .copy_from_slice(&self.buffer[self.pos as usize..][..n]);
                         self.pos += n as Offset;
@@ -1410,6 +1602,7 @@ mod _io {
         const SEEKABLE: bool = false;
 
         fn data(&self) -> &PyThreadMutex<BufferedData>;
+        fn closing(&self) -> &AtomicBool;
 
         fn lock(&self, vm: &VirtualMachine) -> PyResult<PyThreadMutexGuard<'_, BufferedData>> {
             self.data()
@@ -1420,17 +1613,16 @@ mod _io {
         #[pyslot]
         fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let zelf: PyRef<Self> = zelf.try_into_value(vm)?;
-            zelf.__init__(args, vm)
-        }
-
-        #[pymethod]
-        fn __init__(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
             let (raw, BufferSize { buffer_size }): (PyObjectRef, _) =
                 args.bind(vm).map_err(|e| {
-                    let msg = format!("{}() {}", Self::CLASS_NAME, *e.__str__(vm));
+                    let str_repr = e
+                        .__str__(vm)
+                        .map(|s| s.as_str().to_owned())
+                        .unwrap_or_else(|_| "<error getting exception str>".to_owned());
+                    let msg = format!("{}() {}", Self::CLASS_NAME, str_repr);
                     vm.new_exception_msg(e.class().to_owned(), msg)
                 })?;
-            self.init(raw, BufferSize { buffer_size }, vm)
+            zelf.init(raw, BufferSize { buffer_size }, vm)
         }
 
         fn init(
@@ -1521,9 +1713,10 @@ mod _io {
             let pos = pos.flatten().to_pyobject(vm);
             let mut data = zelf.lock(vm)?;
             data.check_init(vm)?;
-            if data.writable() {
-                data.flush_rewind(vm)?;
+            if !data.writable() {
+                return Err(new_unsupported_operation(vm, "truncate".to_owned()));
             }
+            data.flush_rewind(vm)?;
             let res = vm.call_method(data.raw.as_ref().unwrap(), "truncate", (pos,))?;
             let _ = data.raw_tell(vm);
             Ok(res)
@@ -1548,19 +1741,25 @@ mod _io {
             Ok(self.lock(vm)?.raw.clone())
         }
 
+        /// Get raw stream without holding the lock (for calling Python code safely)
+        fn get_raw_unlocked(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+            let data = self.lock(vm)?;
+            Ok(data.check_init(vm)?.to_owned())
+        }
+
         #[pygetset]
         fn closed(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("closed", vm)
+            self.get_raw_unlocked(vm)?.get_attr("closed", vm)
         }
 
         #[pygetset]
         fn name(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("name", vm)
+            self.get_raw_unlocked(vm)?.get_attr("name", vm)
         }
 
         #[pygetset]
         fn mode(&self, vm: &VirtualMachine) -> PyResult {
-            self.lock(vm)?.check_init(vm)?.get_attr("mode", vm)
+            self.get_raw_unlocked(vm)?.get_attr("mode", vm)
         }
 
         #[pymethod]
@@ -1574,7 +1773,7 @@ mod _io {
         }
 
         #[pyslot]
-        fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
             let name_repr = repr_file_obj_name(zelf, vm)?;
             let cls = zelf.class();
             let slot_name = cls.slot_name();
@@ -1587,7 +1786,7 @@ mod _io {
         }
 
         #[pymethod]
-        fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
             Self::slot_repr(&zelf, vm)
         }
 
@@ -1604,17 +1803,19 @@ mod _io {
 
         #[pymethod]
         fn close(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-            {
+            // Don't hold the lock while calling Python code to avoid reentrant lock issues
+            let raw = {
                 let data = zelf.lock(vm)?;
                 let raw = data.check_init(vm)?;
                 if file_closed(raw, vm)? {
                     return Ok(vm.ctx.none());
                 }
-            }
+                raw.to_owned()
+            };
+            // Set closing flag so that concurrent write() calls will fail
+            zelf.closing().store(true, Ordering::Release);
             let flush_res = vm.call_method(zelf.as_object(), "flush", ()).map(drop);
-            let data = zelf.lock(vm)?;
-            let raw = data.raw.as_ref().unwrap();
-            let close_res = vm.call_method(raw, "close", ());
+            let close_res = vm.call_method(&raw, "close", ());
             exception_chain(flush_res, close_res)
         }
 
@@ -1628,10 +1829,9 @@ mod _io {
             Self::WRITABLE
         }
 
-        // TODO: this should be the default for an equivalent of _PyObject_GetState
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
     }
 
@@ -1681,9 +1881,13 @@ mod _io {
             }
             let have = data.readahead();
             if have > 0 {
-                let n = std::cmp::min(have as usize, n);
+                let n = core::cmp::min(have as usize, n);
                 return Ok(data.read_fast(n).unwrap());
             }
+            // Flush write buffer before reading
+            if data.writable() {
+                data.flush_rewind(vm)?;
+            }
             let mut v = vec![0; n];
             data.reset_read();
             let r = data
@@ -1709,6 +1913,19 @@ mod _io {
             ensure_unclosed(raw, "readinto of closed file", vm)?;
             data.readinto_generic(buf.into(), true, vm)
         }
+
+        #[pymethod]
+        fn flush(&self, vm: &VirtualMachine) -> PyResult<()> {
+            // For read-only buffers, flush just calls raw.flush()
+            // Don't hold the lock while calling Python code to avoid reentrant lock issues
+            let raw = {
+                let data = self.reader().lock(vm)?;
+                data.check_init(vm)?.to_owned()
+            };
+            ensure_unclosed(&raw, "flush of closed file", vm)?;
+            vm.call_method(&raw, "flush", ())?;
+            Ok(())
+        }
     }
 
     fn exception_chain<T>(e1: PyResult<()>, e2: PyResult<T>) -> PyResult<T> {
@@ -1723,10 +1940,12 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "BufferedReader", base = "_BufferedIOBase")]
-    #[derive(Debug, Default, PyPayload)]
+    #[pyclass(name = "BufferedReader", base = _BufferedIOBase)]
+    #[derive(Debug, Default)]
     struct BufferedReader {
+        _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedReader {
@@ -1737,6 +1956,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedReadable for BufferedReader {
@@ -1748,11 +1971,23 @@ mod _io {
     }
 
     #[pyclass(
-        with(Constructor, BufferedMixin, BufferedReadable),
+        with(Constructor, BufferedMixin, BufferedReadable, Destructor),
         flags(BASETYPE, HAS_DICT)
     )]
     impl BufferedReader {}
 
+    impl Destructor for BufferedReader {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+
     impl DefaultConstructor for BufferedReader {}
 
     #[pyclass]
@@ -1763,6 +1998,27 @@ mod _io {
 
         #[pymethod]
         fn write(&self, obj: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+            // Check if close() is in progress (Issue #31976)
+            // If closing, wait for close() to complete by spinning until raw is closed.
+            // Note: This spin-wait has no timeout because close() is expected to always
+            // complete (flush + fd close).
+            if self.writer().closing().load(Ordering::Acquire) {
+                loop {
+                    let raw = {
+                        let data = self.writer().lock(vm)?;
+                        match &data.raw {
+                            Some(raw) => raw.to_owned(),
+                            None => break, // detached
+                        }
+                    };
+                    if file_closed(&raw, vm)? {
+                        break;
+                    }
+                    // Yield to other threads
+                    std::thread::yield_now();
+                }
+                return Err(vm.new_value_error("write to closed file".to_owned()));
+            }
             let mut data = self.writer().lock(vm)?;
             let raw = data.check_init(vm)?;
             ensure_unclosed(raw, "write to closed file", vm)?;
@@ -1780,10 +2036,12 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "BufferedWriter", base = "_BufferedIOBase")]
-    #[derive(Debug, Default, PyPayload)]
+    #[pyclass(name = "BufferedWriter", base = _BufferedIOBase)]
+    #[derive(Debug, Default)]
     struct BufferedWriter {
+        _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedWriter {
@@ -1794,6 +2052,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedWritable for BufferedWriter {
@@ -1805,18 +2067,32 @@ mod _io {
     }
 
     #[pyclass(
-        with(Constructor, BufferedMixin, BufferedWritable),
+        with(Constructor, BufferedMixin, BufferedWritable, Destructor),
         flags(BASETYPE, HAS_DICT)
     )]
     impl BufferedWriter {}
 
+    impl Destructor for BufferedWriter {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+
     impl DefaultConstructor for BufferedWriter {}
 
     #[pyattr]
-    #[pyclass(name = "BufferedRandom", base = "_BufferedIOBase")]
-    #[derive(Debug, Default, PyPayload)]
+    #[pyclass(name = "BufferedRandom", base = _BufferedIOBase)]
+    #[derive(Debug, Default)]
     struct BufferedRandom {
+        _base: _BufferedIOBase,
         data: PyThreadMutex<BufferedData>,
+        closing: AtomicBool,
     }
 
     impl BufferedMixin for BufferedRandom {
@@ -1828,6 +2104,10 @@ mod _io {
         fn data(&self) -> &PyThreadMutex<BufferedData> {
             &self.data
         }
+
+        fn closing(&self) -> &AtomicBool {
+            &self.closing
+        }
     }
 
     impl BufferedReadable for BufferedRandom {
@@ -1847,17 +2127,36 @@ mod _io {
     }
 
     #[pyclass(
-        with(Constructor, BufferedMixin, BufferedReadable, BufferedWritable),
+        with(
+            Constructor,
+            BufferedMixin,
+            BufferedReadable,
+            BufferedWritable,
+            Destructor
+        ),
         flags(BASETYPE, HAS_DICT)
     )]
     impl BufferedRandom {}
 
+    impl Destructor for BufferedRandom {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+
     impl DefaultConstructor for BufferedRandom {}
 
     #[pyattr]
-    #[pyclass(name = "BufferedRWPair", base = "_BufferedIOBase")]
-    #[derive(Debug, Default, PyPayload)]
+    #[pyclass(name = "BufferedRWPair", base = _BufferedIOBase)]
+    #[derive(Debug, Default)]
     struct BufferedRWPair {
+        _base: _BufferedIOBase,
         read: BufferedReader,
         write: BufferedWriter,
     }
@@ -1895,7 +2194,13 @@ mod _io {
     }
 
     #[pyclass(
-        with(Constructor, Initializer, BufferedReadable, BufferedWritable),
+        with(
+            Constructor,
+            Initializer,
+            BufferedReadable,
+            BufferedWritable,
+            Destructor
+        ),
         flags(BASETYPE, HAS_DICT)
     )]
     impl BufferedRWPair {
@@ -1937,10 +2242,22 @@ mod _io {
         }
     }
 
+    impl Destructor for BufferedRWPair {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+
     #[derive(FromArgs)]
     struct TextIOWrapperArgs {
         #[pyarg(any, default)]
-        encoding: Option<PyStrRef>,
+        encoding: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
         errors: Option<PyStrRef>,
         #[pyarg(any, default)]
@@ -2056,7 +2373,7 @@ mod _io {
         }
     }
 
-    impl std::ops::Add for Utf8size {
+    impl core::ops::Add for Utf8size {
         type Output = Self;
 
         #[inline]
@@ -2066,7 +2383,7 @@ mod _io {
         }
     }
 
-    impl std::ops::AddAssign for Utf8size {
+    impl core::ops::AddAssign for Utf8size {
         #[inline]
         fn add_assign(&mut self, rhs: Self) {
             self.bytes += rhs.bytes;
@@ -2074,7 +2391,7 @@ mod _io {
         }
     }
 
-    impl std::ops::Sub for Utf8size {
+    impl core::ops::Sub for Utf8size {
         type Output = Self;
 
         #[inline]
@@ -2084,7 +2401,7 @@ mod _io {
         }
     }
 
-    impl std::ops::SubAssign for Utf8size {
+    impl core::ops::SubAssign for Utf8size {
         #[inline]
         fn sub_assign(&mut self, rhs: Self) {
             self.bytes -= rhs.bytes;
@@ -2103,7 +2420,7 @@ mod _io {
         buffer: PyObjectRef,
         encoder: Option<(PyObjectRef, Option<EncodeFunc>)>,
         decoder: Option<PyObjectRef>,
-        encoding: PyStrRef,
+        encoding: PyUtf8StrRef,
         errors: PyStrRef,
         newline: Newlines,
         line_buffering: bool,
@@ -2153,7 +2470,7 @@ mod _io {
     impl PendingWrites {
         fn push(&mut self, write: PendingWrite) {
             self.num_bytes += write.as_bytes().len();
-            self.data = match std::mem::take(&mut self.data) {
+            self.data = match core::mem::take(&mut self.data) {
                 PendingWritesData::None => PendingWritesData::One(write),
                 PendingWritesData::One(write1) => PendingWritesData::Many(vec![write1, write]),
                 PendingWritesData::Many(mut v) => {
@@ -2163,13 +2480,13 @@ mod _io {
             }
         }
         fn take(&mut self, vm: &VirtualMachine) -> PyBytesRef {
-            let Self { num_bytes, data } = std::mem::take(self);
+            let Self { num_bytes, data } = core::mem::take(self);
             if let PendingWritesData::One(PendingWrite::Bytes(b)) = data {
                 return b;
             }
             let writes_iter = match data {
                 PendingWritesData::None => itertools::Either::Left(vec![].into_iter()),
-                PendingWritesData::One(write) => itertools::Either::Right(std::iter::once(write)),
+                PendingWritesData::One(write) => itertools::Either::Right(core::iter::once(write)),
                 PendingWritesData::Many(writes) => itertools::Either::Left(writes.into_iter()),
             };
             let mut buf = Vec::with_capacity(num_bytes);
@@ -2191,7 +2508,7 @@ mod _io {
 
     impl TextIOCookie {
         const START_POS_OFF: usize = 0;
-        const DEC_FLAGS_OFF: usize = Self::START_POS_OFF + std::mem::size_of::<Offset>();
+        const DEC_FLAGS_OFF: usize = Self::START_POS_OFF + core::mem::size_of::<Offset>();
         const BYTES_TO_FEED_OFF: usize = Self::DEC_FLAGS_OFF + 4;
         const CHARS_TO_SKIP_OFF: usize = Self::BYTES_TO_FEED_OFF + 4;
         const NEED_EOF_OFF: usize = Self::CHARS_TO_SKIP_OFF + 4;
@@ -2208,7 +2525,7 @@ mod _io {
             macro_rules! get_field {
                 ($t:ty, $off:ident) => {{
                     <$t>::from_ne_bytes(
-                        buf[Self::$off..][..std::mem::size_of::<$t>()]
+                        buf[Self::$off..][..core::mem::size_of::<$t>()]
                             .try_into()
                             .unwrap(),
                     )
@@ -2229,7 +2546,7 @@ mod _io {
             macro_rules! set_field {
                 ($field:expr, $off:ident) => {{
                     let field = $field;
-                    buf[Self::$off..][..std::mem::size_of_val(&field)]
+                    buf[Self::$off..][..core::mem::size_of_val(&field)]
                         .copy_from_slice(&field.to_ne_bytes())
                 }};
             }
@@ -2239,7 +2556,7 @@ mod _io {
             set_field!(self.chars_to_skip, CHARS_TO_SKIP_OFF);
             set_field!(self.need_eof as u8, NEED_EOF_OFF);
             set_field!(self.bytes_to_skip, BYTES_TO_SKIP_OFF);
-            BigUint::from_bytes_le(&buf).into()
+            BigInt::from_signed_bytes_le(&buf)
         }
 
         fn set_decoder_state(&self, decoder: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
@@ -2269,9 +2586,10 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "TextIOWrapper", base = "_TextIOBase")]
-    #[derive(Debug, Default, PyPayload)]
+    #[pyclass(name = "TextIOWrapper", base = _TextIOBase)]
+    #[derive(Debug, Default)]
     struct TextIOWrapper {
+        _base: _TextIOBase,
         data: PyThreadMutex<Option<TextIOData>>,
     }
 
@@ -2289,8 +2607,16 @@ mod _io {
             *data = None;
 
             let encoding = match args.encoding {
-                None if vm.state.settings.utf8_mode > 0 => identifier!(vm, utf_8).to_owned(),
-                Some(enc) if enc.as_wtf8() != "locale" => enc,
+                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)?
@@ -2304,12 +2630,17 @@ mod _io {
                 .errors
                 .unwrap_or_else(|| identifier!(vm, strict).to_owned());
 
+            // Check for embedded null character in errors (use as_wtf8 to handle surrogates)
+            if errors.as_wtf8().as_bytes().contains(&0) {
+                return Err(cstring_error(vm));
+            }
+
             let has_read1 = vm.get_attribute_opt(buffer.clone(), "read1")?.is_some();
             let seekable = vm.call_method(&buffer, "seekable", ())?.try_to_bool(vm)?;
 
             let newline = args.newline.unwrap_or_default();
             let (encoder, decoder) =
-                Self::find_coder(&buffer, encoding.try_to_str(vm)?, &errors, newline, vm)?;
+                Self::find_coder(&buffer, encoding.as_str(), &errors, newline, vm)?;
 
             *data = Some(TextIOData {
                 buffer,
@@ -2370,7 +2701,7 @@ mod _io {
                     codec.get_incremental_encoder(Some(errors.to_owned()), vm)?;
                 let encoding_name = vm.get_attribute_opt(incremental_encoder.clone(), "name")?;
                 let encode_func = encoding_name.and_then(|name| {
-                    let name = name.payload::<PyStr>()?;
+                    let name = name.downcast_ref::<PyStr>()?;
                     match name.as_str() {
                         "utf-8" => Some(textio_encode_utf8 as EncodeFunc),
                         _ => None,
@@ -2400,7 +2731,25 @@ mod _io {
         }
     }
 
-    #[pyclass(with(Constructor, Initializer), flags(BASETYPE))]
+    #[inline]
+    fn flush_inner(textio: &mut TextIOData, vm: &VirtualMachine) -> PyResult {
+        textio.check_closed(vm)?;
+        textio.telling = textio.seekable;
+        textio.write_pending(vm)?;
+        vm.call_method(&textio.buffer, "flush", ())
+    }
+
+    #[pyclass(
+        with(
+            Constructor,
+            Initializer,
+            Destructor,
+            Iterable,
+            IterNext,
+            Representable
+        ),
+        flags(BASETYPE)
+    )]
     impl TextIOWrapper {
         #[pymethod]
         fn reconfigure(&self, args: TextIOWrapperArgs, vm: &VirtualMachine) -> PyResult<()> {
@@ -2409,7 +2758,7 @@ mod _io {
                 if let Some(encoding) = args.encoding {
                     let (encoder, decoder) = Self::find_coder(
                         &data.buffer,
-                        encoding.try_to_str(vm)?,
+                        encoding.as_str(),
                         &data.errors,
                         data.newline,
                         vm,
@@ -2434,6 +2783,22 @@ mod _io {
             Ok(())
         }
 
+        #[pymethod]
+        fn detach(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
+            let mut textio = zelf.lock(vm)?;
+
+            // Fail fast if already detached
+            if vm.is_none(&textio.buffer) {
+                return Err(vm.new_value_error("underlying buffer has been detached"));
+            }
+
+            flush_inner(&mut textio, vm)?;
+
+            let buffer = textio.buffer.clone();
+            textio.buffer = vm.ctx.none();
+            Ok(buffer)
+        }
+
         #[pymethod]
         fn seekable(&self, vm: &VirtualMachine) -> PyResult {
             let textio = self.lock(vm)?;
@@ -2699,7 +3064,7 @@ mod _io {
                     n_decoded += n;
                     cookie.bytes_to_feed += 1;
                     let (dec_buffer, dec_flags) = decoder_getstate()?;
-                    if dec_buffer.is_empty() && n_decoded.chars < num_to_skip.chars {
+                    if dec_buffer.is_empty() && n_decoded.chars <= num_to_skip.chars {
                         cookie.start_pos += cookie.bytes_to_feed as Offset;
                         num_to_skip -= n_decoded;
                         cookie.dec_flags = dec_flags;
@@ -2734,7 +3099,7 @@ mod _io {
         }
 
         #[pygetset]
-        fn encoding(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        fn encoding(&self, vm: &VirtualMachine) -> PyResult<PyUtf8StrRef> {
             Ok(self.lock(vm)?.encoding.clone())
         }
 
@@ -2868,10 +3233,26 @@ mod _io {
         #[pymethod]
         fn flush(&self, vm: &VirtualMachine) -> PyResult {
             let mut textio = self.lock(vm)?;
-            textio.check_closed(vm)?;
-            textio.telling = textio.seekable;
-            textio.write_pending(vm)?;
-            vm.call_method(&textio.buffer, "flush", ())
+            flush_inner(&mut textio, vm)
+        }
+
+        #[pymethod]
+        fn truncate(
+            zelf: PyRef<Self>,
+            pos: OptionalArg<PyObjectRef>,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            // Implementation follows _pyio.py TextIOWrapper.truncate
+            let mut textio = zelf.lock(vm)?;
+            flush_inner(&mut textio, vm)?;
+            let buffer = textio.buffer.clone();
+            drop(textio);
+
+            let pos = match pos.into_option() {
+                Some(p) => p,
+                None => vm.call_method(zelf.as_object(), "tell", ())?,
+            };
+            vm.call_method(&buffer, "truncate", (pos,))
         }
 
         #[pymethod]
@@ -3073,8 +3454,8 @@ mod _io {
         }
 
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
         }
     }
 
@@ -3090,7 +3471,7 @@ mod _io {
                         obj.class().name()
                     ))
                 })?;
-                let flags = flags.payload::<int::PyInt>().ok_or_else(state_err)?;
+                let flags = flags.downcast_ref::<int::PyInt>().ok_or_else(state_err)?;
                 let flags = flags.try_to_primitive(vm)?;
                 Ok((buf, flags))
             }
@@ -3128,7 +3509,7 @@ mod _io {
             } else {
                 size_hint
             };
-            let chunk_size = std::cmp::max(self.chunk_size, size_hint);
+            let chunk_size = core::cmp::max(self.chunk_size, size_hint);
             let input_chunk = vm.call_method(&self.buffer, method, (chunk_size,))?;
 
             let buf = ArgBytesLike::try_from_borrowed_object(vm, &input_chunk).map_err(|_| {
@@ -3210,8 +3591,8 @@ mod _io {
             vm: &VirtualMachine,
         ) -> PyStrRef {
             let empty_str = || vm.ctx.empty_str.to_owned();
-            let chars_pos = std::mem::take(&mut self.decoded_chars_used).bytes;
-            let decoded_chars = match std::mem::take(&mut self.decoded_chars) {
+            let chars_pos = core::mem::take(&mut self.decoded_chars_used).bytes;
+            let decoded_chars = match core::mem::take(&mut self.decoded_chars) {
                 None => return append.unwrap_or_else(empty_str),
                 Some(s) if s.is_empty() => return append.unwrap_or_else(empty_str),
                 Some(s) => s,
@@ -3231,6 +3612,97 @@ mod _io {
         }
     }
 
+    impl Destructor for TextIOWrapper {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
+        }
+    }
+
+    impl Representable for TextIOWrapper {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let type_name = zelf.class().slot_name();
+            let Some(data) = zelf.data.lock() else {
+                // Reentrant call
+                return Ok(format!("<{type_name}>"));
+            };
+            let Some(data) = data.as_ref() else {
+                return Err(vm.new_value_error("I/O operation on uninitialized object".to_owned()));
+            };
+
+            let mut result = format!("<{type_name}");
+
+            // Add name if present
+            if let Ok(Some(name)) = vm.get_attribute_opt(data.buffer.clone(), "name")
+                && let Ok(name_repr) = name.repr(vm)
+            {
+                result.push_str(" name=");
+                result.push_str(name_repr.as_str());
+            }
+
+            // Add mode if present
+            if let Ok(Some(mode)) = vm.get_attribute_opt(data.buffer.clone(), "mode")
+                && let Ok(mode_repr) = mode.repr(vm)
+            {
+                result.push_str(" mode=");
+                result.push_str(mode_repr.as_str());
+            }
+
+            // Add encoding
+            result.push_str(" encoding='");
+            result.push_str(data.encoding.as_str());
+            result.push('\'');
+
+            result.push('>');
+            Ok(result)
+        }
+    }
+
+    impl Iterable for TextIOWrapper {
+        fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            check_closed(&zelf, vm)?;
+            Ok(zelf)
+        }
+
+        fn iter(_zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {
+            unreachable!("slot_iter is implemented")
+        }
+    }
+
+    impl IterNext for TextIOWrapper {
+        fn slot_iternext(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            // Set telling = false during iteration (matches CPython behavior)
+            let textio_ref: PyRef<TextIOWrapper> =
+                zelf.downcast_ref::<TextIOWrapper>().unwrap().to_owned();
+            {
+                let mut textio = textio_ref.lock(vm)?;
+                textio.telling = false;
+            }
+
+            let line = vm.call_method(zelf, "readline", ())?;
+
+            if !line.clone().try_to_bool(vm)? {
+                // Restore telling on StopIteration
+                let mut textio = textio_ref.lock(vm)?;
+                textio.snapshot = None;
+                textio.telling = textio.seekable;
+                Ok(PyIterReturn::StopIteration(None))
+            } else {
+                Ok(PyIterReturn::Return(line))
+            }
+        }
+
+        fn next(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            unreachable!("slot_iternext is implemented")
+        }
+    }
+
     #[pyattr]
     #[pyclass(name)]
     #[derive(Debug, PyPayload, Default)]
@@ -3389,11 +3861,9 @@ mod _io {
                 output.to_mut().insert(0, '\r'.into());
                 self.pendingcr = false;
             }
-            if !final_ {
-                if let Some(s) = output.strip_suffix("\r".as_ref()) {
-                    output = Cow::Owned(s.to_owned());
-                    self.pendingcr = true;
-                }
+            if !final_ && let Some(s) = output.strip_suffix("\r".as_ref()) {
+                output = Cow::Owned(s.to_owned());
+                self.pendingcr = true;
             }
 
             if output.is_empty() {
@@ -3457,9 +3927,10 @@ mod _io {
     }
 
     #[pyattr]
-    #[pyclass(name = "StringIO", base = "_TextIOBase")]
-    #[derive(Debug, PyPayload)]
+    #[pyclass(name = "StringIO", base = _TextIOBase)]
+    #[derive(Debug)]
     struct StringIO {
+        _base: _TextIOBase,
         buffer: PyRwLock<BufferedIO>,
         closed: AtomicCell<bool>,
     }
@@ -3476,24 +3947,31 @@ mod _io {
     }
 
     impl Constructor for StringIO {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
+                _base: Default::default(),
+                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(Vec::new()))),
+                closed: AtomicCell::new(false),
+            })
+        }
+    }
+
+    impl Initializer for StringIO {
         type Args = StringIONewArgs;
 
         #[allow(unused_variables)]
-        fn py_new(
-            cls: PyTypeRef,
+        fn init(
+            zelf: PyRef<Self>,
             Self::Args { object, newline }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
+            _vm: &VirtualMachine,
+        ) -> PyResult<()> {
             let raw_bytes = object
                 .flatten()
                 .map_or_else(Vec::new, |v| v.as_bytes().to_vec());
-
-            Self {
-                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))),
-                closed: AtomicCell::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
+            Ok(())
         }
     }
 
@@ -3507,7 +3985,7 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(Constructor))]
+    #[pyclass(flags(BASETYPE, HAS_DICT), with(Constructor, Initializer))]
     impl StringIO {
         #[pymethod]
         const fn readable(&self) -> bool {
@@ -3594,32 +4072,115 @@ mod _io {
             let pos = pos.try_usize(vm)?;
             Ok(buffer.truncate(pos))
         }
+
+        #[pygetset]
+        const fn line_buffering(&self) -> bool {
+            false
+        }
+
+        #[pymethod]
+        fn __getstate__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            let buffer = zelf.buffer(vm)?;
+            let content = Wtf8Buf::from_bytes(buffer.getvalue())
+                .map_err(|_| vm.new_value_error("Error Retrieving Value"))?;
+            let pos = buffer.tell();
+            drop(buffer);
+
+            // Get __dict__ if it exists and is non-empty
+            let dict_obj: PyObjectRef = match zelf.as_object().dict() {
+                Some(d) if !d.is_empty() => d.into(),
+                _ => vm.ctx.none(),
+            };
+
+            // Return (content, newline, position, dict)
+            // TODO: store actual newline setting when it's implemented
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_str(content).into(),
+                vm.ctx.new_str("\n").into(),
+                vm.ctx.new_int(pos).into(),
+                dict_obj,
+            ]))
+        }
+
+        #[pymethod]
+        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+            // Check closed state first (like CHECK_CLOSED)
+            if zelf.closed.load() {
+                return Err(vm.new_value_error("__setstate__ on closed file"));
+            }
+            if state.len() != 4 {
+                return Err(vm.new_type_error(format!(
+                    "__setstate__ argument should be 4-tuple, got {}",
+                    state.len()
+                )));
+            }
+
+            let content: PyStrRef = state[0].clone().try_into_value(vm)?;
+            // state[1] is newline - TODO: use when newline handling is implemented
+            let pos: u64 = state[2].clone().try_into_value(vm)?;
+            let dict = &state[3];
+
+            // Set content and position
+            let raw_bytes = content.as_bytes().to_vec();
+            let mut buffer = zelf.buffer.write();
+            *buffer = BufferedIO::new(Cursor::new(raw_bytes));
+            buffer
+                .seek(SeekFrom::Start(pos))
+                .map_err(|err| os_err(vm, err))?;
+            drop(buffer);
+
+            // Set __dict__ if provided
+            if !vm.is_none(dict) {
+                let dict_ref: PyRef<PyDict> = dict.clone().try_into_value(vm)?;
+                if let Some(obj_dict) = zelf.as_object().dict() {
+                    obj_dict.clear();
+                    for (key, value) in dict_ref.into_iter() {
+                        obj_dict.set_item(&*key, value, vm)?;
+                    }
+                }
+            }
+
+            Ok(())
+        }
     }
 
     #[pyattr]
-    #[pyclass(name = "BytesIO", base = "_BufferedIOBase")]
-    #[derive(Debug, PyPayload)]
+    #[pyclass(name = "BytesIO", base = _BufferedIOBase)]
+    #[derive(Debug)]
     struct BytesIO {
+        _base: _BufferedIOBase,
         buffer: PyRwLock<BufferedIO>,
         closed: AtomicCell<bool>,
         exports: AtomicCell<usize>,
     }
 
     impl Constructor for BytesIO {
-        type Args = OptionalArg<Option<PyBytesRef>>;
-
-        fn py_new(cls: PyTypeRef, object: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let raw_bytes = object
-                .flatten()
-                .map_or_else(Vec::new, |input| input.as_bytes().to_vec());
+        type Args = FuncArgs;
 
-            Self {
-                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))),
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
+                _base: Default::default(),
+                buffer: PyRwLock::new(BufferedIO::new(Cursor::new(Vec::new()))),
                 closed: AtomicCell::new(false),
                 exports: AtomicCell::new(0),
+            })
+        }
+    }
+
+    impl Initializer for BytesIO {
+        type Args = OptionalArg<Option<ArgBytesLike>>;
+
+        fn init(zelf: PyRef<Self>, object: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
+            if zelf.exports.load() > 0 {
+                return Err(vm.new_buffer_error(
+                    "Existing exports of data: object cannot be re-sized".to_owned(),
+                ));
             }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            let raw_bytes = object
+                .flatten()
+                .map_or_else(Vec::new, |input| input.borrow_buf().to_vec());
+            *zelf.buffer.write() = BufferedIO::new(Cursor::new(raw_bytes));
+            Ok(())
         }
     }
 
@@ -3633,7 +4194,7 @@ mod _io {
         }
     }
 
-    #[pyclass(flags(BASETYPE, HAS_DICT), with(PyRef, Constructor))]
+    #[pyclass(flags(BASETYPE, HAS_DICT), with(PyRef, Constructor, Initializer))]
     impl BytesIO {
         #[pymethod]
         const fn readable(&self) -> bool {
@@ -3729,6 +4290,65 @@ mod _io {
             self.closed.store(true);
             Ok(())
         }
+
+        #[pymethod]
+        fn __getstate__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            let buffer = zelf.buffer(vm)?;
+            let content = buffer.getvalue();
+            let pos = buffer.tell();
+            drop(buffer);
+
+            // Get __dict__ if it exists and is non-empty
+            let dict_obj: PyObjectRef = match zelf.as_object().dict() {
+                Some(d) if !d.is_empty() => d.into(),
+                _ => vm.ctx.none(),
+            };
+
+            // Return (content, position, dict)
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_bytes(content).into(),
+                vm.ctx.new_int(pos).into(),
+                dict_obj,
+            ]))
+        }
+
+        #[pymethod]
+        fn __setstate__(zelf: PyRef<Self>, state: PyTupleRef, vm: &VirtualMachine) -> PyResult<()> {
+            if zelf.closed.load() {
+                return Err(vm.new_value_error("__setstate__ on closed file"));
+            }
+            if state.len() != 3 {
+                return Err(vm.new_type_error(format!(
+                    "__setstate__ argument should be 3-tuple, got {}",
+                    state.len()
+                )));
+            }
+
+            let content: PyBytesRef = state[0].clone().try_into_value(vm)?;
+            let pos: u64 = state[1].clone().try_into_value(vm)?;
+            let dict = &state[2];
+
+            // Check exports and set content (like CHECK_EXPORTS)
+            let mut buffer = zelf.try_resizable(vm)?;
+            *buffer = BufferedIO::new(Cursor::new(content.as_bytes().to_vec()));
+            buffer
+                .seek(SeekFrom::Start(pos))
+                .map_err(|err| os_err(vm, err))?;
+            drop(buffer);
+
+            // Set __dict__ if provided
+            if !vm.is_none(dict) {
+                let dict_ref: PyRef<PyDict> = dict.clone().try_into_value(vm)?;
+                if let Some(obj_dict) = zelf.as_object().dict() {
+                    obj_dict.clear();
+                    for (key, value) in dict_ref.into_iter() {
+                        obj_dict.set_item(&*key, value, vm)?;
+                    }
+                }
+            }
+
+            Ok(())
+        }
     }
 
     #[pyclass]
@@ -3798,7 +4418,7 @@ mod _io {
         plus: bool,
     }
 
-    impl std::str::FromStr for Mode {
+    impl core::str::FromStr for Mode {
         type Err = ParseModeError;
 
         fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -3882,7 +4502,7 @@ mod _io {
     struct IoOpenArgs {
         file: PyObjectRef,
         #[pyarg(any, optional)]
-        mode: OptionalArg<PyStrRef>,
+        mode: OptionalArg<PyUtf8StrRef>,
         #[pyarg(flatten)]
         opts: OpenArgs,
     }
@@ -3908,7 +4528,7 @@ mod _io {
         #[pyarg(any, default = -1)]
         pub buffering: isize,
         #[pyarg(any, default)]
-        pub encoding: Option<PyStrRef>,
+        pub encoding: Option<PyUtf8StrRef>,
         #[pyarg(any, default)]
         pub errors: Option<PyStrRef>,
         #[pyarg(any, default)]
@@ -3962,8 +4582,7 @@ mod _io {
         // check file descriptor validity
         #[cfg(unix)]
         if let Ok(crate::ospath::OsPathOrFd::Fd(fd)) = file.clone().try_into_value(vm) {
-            nix::fcntl::fcntl(fd, nix::fcntl::F_GETFD)
-                .map_err(|_| crate::stdlib::os::errno_err(vm))?;
+            nix::fcntl::fcntl(fd, nix::fcntl::F_GETFD).map_err(|_| vm.new_last_errno_error())?;
         }
 
         // Construct a FileIO (subclass of RawIOBase)
@@ -3994,6 +4613,16 @@ mod _io {
             bool::try_from_object(vm, atty)?
         };
 
+        // Warn if line buffering is requested in binary mode
+        if opts.buffering == 1 && matches!(mode.encode, EncodeMode::Bytes) {
+            crate::stdlib::warnings::warn(
+                vm.ctx.exceptions.runtime_warning,
+                "line buffering (buffering=1) isn't supported in binary mode, the default buffer size will be used".to_owned(),
+                1,
+                vm,
+            )?;
+        }
+
         let line_buffering = opts.buffering == 1 || isatty;
 
         let buffering = if opts.buffering < 0 || opts.buffering == 1 {
@@ -4041,11 +4670,7 @@ mod _io {
         }
     }
 
-    rustpython_common::static_cell! {
-        pub(super) static UNSUPPORTED_OPERATION: PyTypeRef;
-    }
-
-    pub(super) fn make_unsupportedop(ctx: &Context) -> PyTypeRef {
+    fn create_unsupported_operation(ctx: &Context) -> PyTypeRef {
         use crate::types::PyTypeSlots;
         PyType::new_heap(
             "UnsupportedOperation",
@@ -4061,6 +4686,13 @@ mod _io {
         .unwrap()
     }
 
+    pub fn unsupported_operation() -> &'static Py<PyType> {
+        rustpython_common::static_cell! {
+            static CELL: PyTypeRef;
+        }
+        CELL.get_or_init(|| create_unsupported_operation(Context::genesis()))
+    }
+
     #[pyfunction]
     fn text_encoding(
         encoding: PyObjectRef,
@@ -4119,14 +4751,16 @@ mod _io {
 mod fileio {
     use super::{_io::*, Offset};
     use crate::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyStr, PyStrRef},
-        common::crt_fd::Fd,
-        convert::ToPyException,
+        AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+        VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyUtf8Str, PyUtf8StrRef},
+        common::crt_fd,
+        convert::{IntoPyException, ToPyException},
+        exceptions::OSErrorBuilder,
         function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg, OptionalOption},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd},
+        ospath::{OsPath, OsPathOrFd},
         stdlib::os,
-        types::{Constructor, DefaultConstructor, Initializer, Representable},
+        types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
     };
     use crossbeam_utils::atomic::AtomicCell;
     use std::io::{Read, Write};
@@ -4233,13 +4867,15 @@ mod fileio {
     }
 
     #[pyattr]
-    #[pyclass(module = "io", name, base = "_RawIOBase")]
-    #[derive(Debug, PyPayload)]
+    #[pyclass(module = "_io", name, base = _RawIOBase)]
+    #[derive(Debug)]
     pub(super) struct FileIO {
+        _base: _RawIOBase,
         fd: AtomicCell<i32>,
         closefd: AtomicCell<bool>,
         mode: AtomicCell<Mode>,
         seekable: AtomicCell<Option<bool>>,
+        blksize: AtomicCell<i64>,
     }
 
     #[derive(FromArgs)]
@@ -4247,7 +4883,7 @@ mod fileio {
         #[pyarg(positional)]
         name: PyObjectRef,
         #[pyarg(any, default)]
-        mode: Option<PyStrRef>,
+        mode: Option<PyUtf8StrRef>,
         #[pyarg(any, default = true)]
         closefd: bool,
         #[pyarg(any, default)]
@@ -4257,10 +4893,12 @@ mod fileio {
     impl Default for FileIO {
         fn default() -> Self {
             Self {
+                _base: Default::default(),
                 fd: AtomicCell::new(-1),
                 closefd: AtomicCell::new(true),
                 mode: AtomicCell::new(Mode::empty()),
                 seekable: AtomicCell::new(None),
+                blksize: AtomicCell::new(8 * 1024), // DEFAULT_BUFFER_SIZE
             }
         }
     }
@@ -4273,7 +4911,16 @@ mod fileio {
         fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             // TODO: let atomic_flag_works
             let name = args.name;
-            let arg_fd = if let Some(i) = name.payload::<crate::builtins::PyInt>() {
+            // Check if bool is used as file descriptor
+            if name.class().is(vm.ctx.types.bool_type) {
+                crate::stdlib::warnings::warn(
+                    vm.ctx.exceptions.runtime_warning,
+                    "bool is used as a file descriptor".to_owned(),
+                    1,
+                    vm,
+                )?;
+            }
+            let arg_fd = if let Some(i) = name.downcast_ref::<crate::builtins::PyInt>() {
                 let fd = i.try_to_primitive(vm)?;
                 if fd < 0 {
                     return Err(vm.new_value_error("negative file descriptor"));
@@ -4285,7 +4932,7 @@ mod fileio {
 
             let mode_obj = args
                 .mode
-                .unwrap_or_else(|| PyStr::from("rb").into_ref(&vm.ctx));
+                .unwrap_or_else(|| PyUtf8Str::from("rb").into_ref(&vm.ctx));
             let mode_str = mode_obj.as_str();
             let (mode, flags) =
                 compute_mode(mode_str).map_err(|e| vm.new_value_error(e.error_msg(mode_str)))?;
@@ -4293,7 +4940,7 @@ mod fileio {
 
             let (fd, filename) = if let Some(fd) = arg_fd {
                 zelf.closefd.store(args.closefd);
-                (fd, OsPathOrFd::Fd(fd))
+                (fd, None)
             } else {
                 zelf.closefd.store(true);
                 if !args.closefd {
@@ -4309,24 +4956,24 @@ mod fileio {
                     if fd < 0 {
                         return Err(vm.new_value_error(format!("opener returned {fd}")));
                     }
-                    (
-                        fd,
-                        OsPathOrFd::try_from_object(vm, name.clone()).unwrap_or(OsPathOrFd::Fd(fd)),
-                    )
+                    (fd, None)
                 } else {
-                    let path = OsPath::try_from_object(vm, name.clone())?;
+                    let path = OsPath::try_from_fspath(name.clone(), vm)?;
                     #[cfg(any(unix, target_os = "wasi"))]
-                    let fd = Fd::open(&path.clone().into_cstring(vm)?, flags, 0o666);
+                    let fd = crt_fd::open(&path.clone().into_cstring(vm)?, flags, 0o666);
                     #[cfg(windows)]
-                    let fd = Fd::wopen(&path.to_wide_cstring(vm)?, flags, 0o666);
+                    let fd = crt_fd::wopen(&path.to_wide_cstring(vm)?, flags, 0o666);
                     let filename = OsPathOrFd::Path(path);
                     match fd {
-                        Ok(fd) => (fd.0, filename),
-                        Err(e) => return Err(IOErrorBuilder::with_filename(&e, filename, vm)),
+                        Ok(fd) => (fd.into_raw(), Some(filename)),
+                        Err(e) => return Err(OSErrorBuilder::with_filename(&e, filename, vm)),
                     }
                 }
             };
+            let fd_is_own = arg_fd.is_none();
             zelf.fd.store(fd);
+            let fd = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
+            let filename = filename.unwrap_or(OsPathOrFd::Fd(fd));
 
             // TODO: _Py_set_inheritable
 
@@ -4335,7 +4982,7 @@ mod fileio {
             #[cfg(windows)]
             {
                 if let Err(err) = fd_fstat {
-                    return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                    return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                 }
             }
             #[cfg(any(unix, target_os = "wasi"))]
@@ -4343,13 +4990,26 @@ mod fileio {
                 match fd_fstat {
                     Ok(status) => {
                         if (status.st_mode & libc::S_IFMT) == libc::S_IFDIR {
+                            // If fd was passed by user, don't close it on error
+                            if !fd_is_own {
+                                zelf.fd.store(-1);
+                            }
                             let err = std::io::Error::from_raw_os_error(libc::EISDIR);
-                            return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                            return Err(OSErrorBuilder::with_filename(&err, filename, vm));
+                        }
+                        // Store st_blksize for _blksize property
+                        if status.st_blksize > 1 {
+                            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+                            zelf.blksize.store(i64::from(status.st_blksize));
                         }
                     }
                     Err(err) => {
                         if err.raw_os_error() == Some(libc::EBADF) {
-                            return Err(IOErrorBuilder::with_filename(&err, filename, vm));
+                            // If fd was passed by user, don't close it on error
+                            if !fd_is_own {
+                                zelf.fd.store(-1);
+                            }
+                            return Err(OSErrorBuilder::with_filename(&err, filename, vm));
                         }
                     }
                 }
@@ -4357,10 +5017,16 @@ mod fileio {
 
             #[cfg(windows)]
             crate::stdlib::msvcrt::setmode_binary(fd);
-            zelf.as_object().set_attr("name", name, vm)?;
+            if let Err(e) = zelf.as_object().set_attr("name", name, vm) {
+                // If fd was passed by user, don't close it on error
+                if !fd_is_own {
+                    zelf.fd.store(-1);
+                }
+                return Err(e);
+            }
 
             if mode.contains(Mode::APPENDING) {
-                let _ = os::lseek(fd as _, 0, libc::SEEK_END, vm);
+                let _ = os::lseek(fd, 0, libc::SEEK_END, vm);
             }
 
             Ok(())
@@ -4370,24 +5036,25 @@ mod fileio {
     impl Representable for FileIO {
         #[inline]
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let type_name = zelf.class().slot_name();
             let fd = zelf.fd.load();
             if fd < 0 {
-                return Ok("<_io.FileIO [closed]>".to_owned());
+                return Ok(format!("<{type_name} [closed]>"));
             }
             let name_repr = repr_file_obj_name(zelf.as_object(), vm)?;
             let mode = zelf.mode();
             let closefd = if zelf.closefd.load() { "True" } else { "False" };
             let repr = if let Some(name_repr) = name_repr {
-                format!("<_io.FileIO name={name_repr} mode='{mode}' closefd={closefd}>")
+                format!("<{type_name} name={name_repr} mode='{mode}' closefd={closefd}>")
             } else {
-                format!("<_io.FileIO fd={fd} mode='{mode}' closefd={closefd}>")
+                format!("<{type_name} fd={fd} mode='{mode}' closefd={closefd}>")
             };
             Ok(repr)
         }
     }
 
     #[pyclass(
-        with(Constructor, Initializer, Representable),
+        with(Constructor, Initializer, Representable, Destructor),
         flags(BASETYPE, HAS_DICT)
     )]
     impl FileIO {
@@ -4415,6 +5082,11 @@ mod fileio {
             self.closefd.load()
         }
 
+        #[pygetset(name = "_blksize")]
+        fn blksize(&self) -> i64 {
+            self.blksize.load()
+        }
+
         #[pymethod]
         fn fileno(&self, vm: &VirtualMachine) -> PyResult<i32> {
             let fd = self.fd.load();
@@ -4425,18 +5097,25 @@ mod fileio {
             }
         }
 
-        fn get_fd(&self, vm: &VirtualMachine) -> PyResult<Fd> {
-            self.fileno(vm).map(Fd)
+        fn get_fd(&self, vm: &VirtualMachine) -> PyResult<crt_fd::Borrowed<'_>> {
+            self.fileno(vm)
+                .map(|fd| unsafe { crt_fd::Borrowed::borrow_raw(fd) })
         }
 
         #[pymethod]
-        fn readable(&self) -> bool {
-            self.mode.load().contains(Mode::READABLE)
+        fn readable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.mode.load().contains(Mode::READABLE))
         }
 
         #[pymethod]
-        fn writable(&self) -> bool {
-            self.mode.load().contains(Mode::WRITABLE)
+        fn writable(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            if self.fd.load() < 0 {
+                return Err(io_closed_error(vm));
+            }
+            Ok(self.mode.load().contains(Mode::WRITABLE))
         }
 
         #[pygetset]
@@ -4470,7 +5149,7 @@ mod fileio {
             zelf: &Py<Self>,
             read_byte: OptionalSize,
             vm: &VirtualMachine,
-        ) -> PyResult<Vec<u8>> {
+        ) -> PyResult<Option<Vec<u8>>> {
             if !zelf.mode.load().contains(Mode::READABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4480,24 +5159,55 @@ mod fileio {
             let mut handle = zelf.get_fd(vm)?;
             let bytes = if let Some(read_byte) = read_byte.to_usize() {
                 let mut bytes = vec![0; read_byte];
-                let n = handle
-                    .read(&mut bytes)
-                    .map_err(|err| Self::io_error(zelf, err, vm))?;
+                // Loop on EINTR (PEP 475)
+                let n = loop {
+                    match handle.read(&mut bytes) {
+                        Ok(n) => break n,
+                        Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        // 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)),
+                    }
+                };
                 bytes.truncate(n);
                 bytes
             } else {
                 let mut bytes = vec![];
-                handle
-                    .read_to_end(&mut bytes)
-                    .map_err(|err| Self::io_error(zelf, err, vm))?;
+                // Loop on EINTR (PEP 475)
+                loop {
+                    match handle.read_to_end(&mut bytes) {
+                        Ok(_) => break,
+                        Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                            vm.check_signals()?;
+                            continue;
+                        }
+                        // Non-blocking mode: return None if EAGAIN (only if no data read yet)
+                        Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => {
+                            if bytes.is_empty() {
+                                return Ok(None);
+                            }
+                            break;
+                        }
+                        Err(e) => return Err(Self::io_error(zelf, e, vm)),
+                    }
+                }
                 bytes
             };
 
-            Ok(bytes)
+            Ok(Some(bytes))
         }
 
         #[pymethod]
-        fn readinto(zelf: &Py<Self>, obj: ArgMemoryBuffer, vm: &VirtualMachine) -> PyResult<usize> {
+        fn readinto(
+            zelf: &Py<Self>,
+            obj: ArgMemoryBuffer,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<usize>> {
             if !zelf.mode.load().contains(Mode::READABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4509,15 +5219,31 @@ mod fileio {
 
             let mut buf = obj.borrow_buf_mut();
             let mut f = handle.take(buf.len() as _);
-            let ret = f
-                .read(&mut buf)
-                .map_err(|err| Self::io_error(zelf, err, vm))?;
+            // Loop on EINTR (PEP 475)
+            let ret = loop {
+                match f.read(&mut buf) {
+                    Ok(n) => break n,
+                    Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                        vm.check_signals()?;
+                        continue;
+                    }
+                    // Non-blocking mode: return None if EAGAIN
+                    Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => {
+                        return Ok(None);
+                    }
+                    Err(e) => return Err(Self::io_error(zelf, e, vm)),
+                }
+            };
 
-            Ok(ret)
+            Ok(Some(ret))
         }
 
         #[pymethod]
-        fn write(zelf: &Py<Self>, obj: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
+        fn write(
+            zelf: &Py<Self>,
+            obj: ArgBytesLike,
+            vm: &VirtualMachine,
+        ) -> PyResult<Option<usize>> {
             if !zelf.mode.load().contains(Mode::WRITABLE) {
                 return Err(new_unsupported_operation(
                     vm,
@@ -4527,12 +5253,15 @@ mod fileio {
 
             let mut handle = zelf.get_fd(vm)?;
 
-            let len = obj
-                .with_ref(|b| handle.write(b))
-                .map_err(|err| Self::io_error(zelf, err, vm))?;
+            let len = match obj.with_ref(|b| handle.write(b)) {
+                Ok(n) => n,
+                // Non-blocking mode: return None if EAGAIN
+                Err(e) if e.raw_os_error() == Some(libc::EAGAIN) => return Ok(None),
+                Err(e) => return Err(Self::io_error(zelf, e, vm)),
+            };
 
             //return number of bytes written
-            Ok(len)
+            Ok(Some(len))
         }
 
         #[pymethod]
@@ -4544,8 +5273,7 @@ mod fileio {
             }
             let fd = zelf.fd.swap(-1);
             if fd >= 0 {
-                Fd(fd)
-                    .close()
+                crt_fd::close(unsafe { crt_fd::Owned::from_raw(fd) })
                     .map_err(|err| Self::io_error(zelf, err, vm))?;
             }
             res
@@ -4553,7 +5281,7 @@ mod fileio {
 
         #[pymethod]
         fn seekable(&self, vm: &VirtualMachine) -> PyResult<bool> {
-            let fd = self.fileno(vm)?;
+            let fd = self.get_fd(vm)?;
             Ok(self.seekable.load().unwrap_or_else(|| {
                 let seekable = os::lseek(fd, 0, libc::SEEK_CUR, vm).is_ok();
                 self.seekable.store(Some(seekable));
@@ -4569,7 +5297,7 @@ mod fileio {
             vm: &VirtualMachine,
         ) -> PyResult<Offset> {
             let how = how.unwrap_or(0);
-            let fd = self.fileno(vm)?;
+            let fd = self.get_fd(vm)?;
             let offset = get_offset(offset, vm)?;
 
             os::lseek(fd, offset, how, vm)
@@ -4577,18 +5305,18 @@ mod fileio {
 
         #[pymethod]
         fn tell(&self, vm: &VirtualMachine) -> PyResult<Offset> {
-            let fd = self.fileno(vm)?;
+            let fd = self.get_fd(vm)?;
             os::lseek(fd, 0, libc::SEEK_CUR, vm)
         }
 
         #[pymethod]
         fn truncate(&self, len: OptionalOption, vm: &VirtualMachine) -> PyResult<Offset> {
-            let fd = self.fileno(vm)?;
+            let fd = self.get_fd(vm)?;
             let len = match len.flatten() {
                 Some(l) => get_offset(l, vm)?,
                 None => os::lseek(fd, 0, libc::SEEK_CUR, vm)?,
             };
-            os::ftruncate(fd, len, vm)?;
+            os::ftruncate(fd, len).map_err(|e| e.into_pyexception(vm))?;
             Ok(len)
         }
 
@@ -4599,8 +5327,20 @@ mod fileio {
         }
 
         #[pymethod]
-        fn __reduce__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error(format!("cannot pickle '{}' object", zelf.class().name())))
+        fn __getstate__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(format!("cannot pickle '{}' instances", zelf.class().name())))
+        }
+    }
+
+    impl Destructor for FileIO {
+        fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+            let _ = vm.call_method(zelf, "close", ());
+            Ok(())
+        }
+
+        #[cold]
+        fn del(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<()> {
+            unreachable!("slot_del is implemented")
         }
     }
 }
diff --git a/vm/src/stdlib/itertools.rs b/crates/vm/src/stdlib/itertools.rs
similarity index 91%
rename from vm/src/stdlib/itertools.rs
rename to crates/vm/src/stdlib/itertools.rs
index a018fe382d..1eedbde7a2 100644
--- a/vm/src/stdlib/itertools.rs
+++ b/crates/vm/src/stdlib/itertools.rs
@@ -7,7 +7,7 @@ mod decl {
         AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, PyWeakRef, TryFromObject,
         VirtualMachine,
         builtins::{
-            PyGenericAlias, PyInt, PyIntRef, PyList, PyTuple, PyTupleRef, PyTypeRef, int,
+            PyGenericAlias, PyInt, PyIntRef, PyList, PyTuple, PyTupleRef, PyType, PyTypeRef, int,
             tuple::IntoPyTuple,
         },
         common::{
@@ -16,18 +16,26 @@ mod decl {
         },
         convert::ToPyObject,
         function::{ArgCallable, ArgIntoBool, FuncArgs, OptionalArg, OptionalOption, PosArgs},
-        identifier,
         protocol::{PyIter, PyIterReturn, PyNumber},
         raise_if_stop,
-        stdlib::sys,
+        stdlib::{sys, warnings},
         types::{Constructor, IterNext, Iterable, Representable, SelfIter},
     };
     use crossbeam_utils::atomic::AtomicCell;
     use malachite_bigint::BigInt;
     use num_traits::One;
 
+    use alloc::fmt;
     use num_traits::{Signed, ToPrimitive};
-    use std::fmt;
+
+    fn pickle_deprecation(vm: &VirtualMachine) -> PyResult<()> {
+        warnings::warn(
+            vm.ctx.exceptions.deprecation_warning,
+            "Itertool pickle/copy/deepcopy support will be removed in a Python 3.14.".to_owned(),
+            1,
+            vm,
+        )
+    }
 
     #[pyattr]
     #[pyclass(name = "chain")]
@@ -74,6 +82,7 @@ mod decl {
 
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            pickle_deprecation(vm)?;
             let source = zelf.source.read().clone();
             let active = zelf.active.read().clone();
             let cls = zelf.class().to_owned();
@@ -191,20 +200,19 @@ mod decl {
         type Args = CompressNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { data, selectors }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self { data, selectors }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self { data, selectors })
         }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
     impl PyItertoolsCompress {
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyIter, PyIter)) {
+        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyTypeRef, (PyIter, PyIter)) {
+            let _ = pickle_deprecation(vm);
             (
                 zelf.class().to_owned(),
                 (zelf.data.clone(), zelf.selectors.clone()),
@@ -238,10 +246,10 @@ mod decl {
 
     #[derive(FromArgs)]
     struct CountNewArgs {
-        #[pyarg(positional, optional)]
+        #[pyarg(any, optional)]
         start: OptionalArg<PyObjectRef>,
 
-        #[pyarg(positional, optional)]
+        #[pyarg(any, optional)]
         step: OptionalArg<PyObjectRef>,
     }
 
@@ -249,22 +257,20 @@ mod decl {
         type Args = CountNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { start, step }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let start = start.into_option().unwrap_or_else(|| vm.new_pyobj(0));
             let step = step.into_option().unwrap_or_else(|| vm.new_pyobj(1));
             if !PyNumber::check(&start) || !PyNumber::check(&step) {
                 return Err(vm.new_type_error("a number is required"));
             }
 
-            Self {
+            Ok(Self {
                 cur: PyRwLock::new(start),
                 step,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -274,7 +280,8 @@ mod decl {
         // if (lz->cnt == PY_SSIZE_T_MAX)
         //      return Py_BuildValue("0(00)", Py_TYPE(lz), lz->long_cnt, lz->long_step);
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyObjectRef,)) {
+        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyTypeRef, (PyObjectRef,)) {
+            let _ = pickle_deprecation(vm);
             (zelf.class().to_owned(), (zelf.cur.read().clone(),))
         }
     }
@@ -315,14 +322,12 @@ mod decl {
     impl Constructor for PyItertoolsCycle {
         type Args = PyIter;
 
-        fn py_new(cls: PyTypeRef, iter: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self {
+        fn py_new(_cls: &Py<PyType>, iter: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
                 iter,
                 saved: PyRwLock::new(Vec::new()),
                 index: AtomicCell::new(0),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -374,10 +379,10 @@ mod decl {
         type Args = PyRepeatNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { object, times }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let times = match times.into_option() {
                 Some(int) => {
                     let val: isize = int.try_to_primitive(vm)?;
@@ -386,9 +391,7 @@ mod decl {
                 }
                 None => None,
             };
-            Self { object, times }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+            Ok(Self { object, times })
         }
     }
 
@@ -406,6 +409,7 @@ mod decl {
 
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            pickle_deprecation(vm)?;
             let cls = zelf.class().to_owned();
             Ok(match zelf.times {
                 Some(ref times) => vm.new_tuple((cls, (zelf.object.clone(), *times.read()))),
@@ -461,20 +465,22 @@ mod decl {
         type Args = StarmapNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { function, iterable }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self { function, iterable }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self { function, iterable })
         }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
     impl PyItertoolsStarmap {
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyObjectRef, PyIter)) {
+        fn __reduce__(
+            zelf: PyRef<Self>,
+            vm: &VirtualMachine,
+        ) -> (PyTypeRef, (PyObjectRef, PyIter)) {
+            let _ = pickle_deprecation(vm);
             (
                 zelf.class().to_owned(),
                 (zelf.function.clone(), zelf.iterable.clone()),
@@ -519,27 +525,29 @@ mod decl {
         type Args = TakewhileNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args {
                 predicate,
                 iterable,
             }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self {
                 predicate,
                 iterable,
                 stop_flag: AtomicCell::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
     impl PyItertoolsTakewhile {
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
+        fn __reduce__(
+            zelf: PyRef<Self>,
+            vm: &VirtualMachine,
+        ) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
+            let _ = pickle_deprecation(vm);
             (
                 zelf.class().to_owned(),
                 (zelf.predicate.clone(), zelf.iterable.clone()),
@@ -553,7 +561,7 @@ mod decl {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.stop_flag.store(*obj);
+                zelf.stop_flag.store(obj.into_bool());
             }
             Ok(())
         }
@@ -603,27 +611,29 @@ mod decl {
         type Args = DropwhileNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args {
                 predicate,
                 iterable,
             }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self {
                 predicate,
                 iterable,
                 start_flag: AtomicCell::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
     impl PyItertoolsDropwhile {
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
+        fn __reduce__(
+            zelf: PyRef<Self>,
+            vm: &VirtualMachine,
+        ) -> (PyTypeRef, (PyObjectRef, PyIter), u32) {
+            let _ = pickle_deprecation(vm);
             (
                 zelf.class().to_owned(),
                 (zelf.predicate.clone().into(), zelf.iterable.clone()),
@@ -638,7 +648,7 @@ mod decl {
             vm: &VirtualMachine,
         ) -> PyResult<()> {
             if let Ok(obj) = ArgIntoBool::try_from_object(vm, state) {
-                zelf.start_flag.store(*obj);
+                zelf.start_flag.store(obj.into_bool());
             }
             Ok(())
         }
@@ -666,6 +676,7 @@ mod decl {
         }
     }
 
+    #[derive(Default)]
     struct GroupByState {
         current_value: Option<PyObjectRef>,
         current_key: Option<PyObjectRef>,
@@ -722,22 +733,15 @@ mod decl {
         type Args = GroupByArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { iterable, key }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self {
                 iterable,
                 key_func: key.flatten(),
-                state: PyMutex::new(GroupByState {
-                    current_key: None,
-                    current_value: None,
-                    next_group: false,
-                    grouper: None,
-                }),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+                state: PyMutex::new(GroupByState::default()),
+            })
         }
     }
 
@@ -941,6 +945,7 @@ mod decl {
 
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            pickle_deprecation(vm)?;
             let cls = zelf.class().to_owned();
             let itr = zelf.iterable.clone();
             let cur = zelf.cur.take();
@@ -980,10 +985,10 @@ mod decl {
                 zelf.cur.fetch_add(1);
             }
 
-            if let Some(stop) = zelf.stop {
-                if zelf.cur.load() >= stop {
-                    return Ok(PyIterReturn::StopIteration(None));
-                }
+            if let Some(stop) = zelf.stop
+                && zelf.cur.load() >= stop
+            {
+                return Ok(PyIterReturn::StopIteration(None));
             }
 
             let obj = raise_if_stop!(zelf.iterable.next(vm)?);
@@ -1017,26 +1022,28 @@ mod decl {
         type Args = FilterFalseNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args {
                 predicate,
                 iterable,
             }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            Self {
+            _vm: &VirtualMachine,
+        ) -> PyResult<Self> {
+            Ok(Self {
                 predicate,
                 iterable,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
     impl PyItertoolsFilterFalse {
         #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>) -> (PyTypeRef, (PyObjectRef, PyIter)) {
+        fn __reduce__(
+            zelf: PyRef<Self>,
+            vm: &VirtualMachine,
+        ) -> (PyTypeRef, (PyObjectRef, PyIter)) {
+            let _ = pickle_deprecation(vm);
             (
                 zelf.class().to_owned(),
                 (zelf.predicate.clone(), zelf.iterable.clone()),
@@ -1088,15 +1095,13 @@ mod decl {
     impl Constructor for PyItertoolsAccumulate {
         type Args = AccumulateArgs;
 
-        fn py_new(cls: PyTypeRef, args: AccumulateArgs, vm: &VirtualMachine) -> PyResult {
-            Self {
+        fn py_new(_cls: &Py<PyType>, args: AccumulateArgs, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
                 iterable: args.iterable,
                 bin_op: args.func.flatten(),
                 initial: args.initial.flatten(),
                 acc_value: PyRwLock::new(None),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1114,6 +1119,7 @@ mod decl {
 
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
+            let _ = pickle_deprecation(vm);
             let class = zelf.class().to_owned();
             let bin_op = zelf.bin_op.clone();
             let it = zelf.iterable.clone();
@@ -1184,23 +1190,28 @@ mod decl {
     #[derive(Debug)]
     struct PyItertoolsTeeData {
         iterable: PyIter,
-        values: PyRwLock<Vec<PyObjectRef>>,
+        values: PyMutex<Vec<PyObjectRef>>,
     }
 
     impl PyItertoolsTeeData {
         fn new(iterable: PyIter, _vm: &VirtualMachine) -> PyResult<PyRc<Self>> {
             Ok(PyRc::new(Self {
                 iterable,
-                values: PyRwLock::new(vec![]),
+                values: PyMutex::new(vec![]),
             }))
         }
 
         fn get_item(&self, vm: &VirtualMachine, index: usize) -> PyResult<PyIterReturn> {
-            if self.values.read().len() == index {
-                let result = raise_if_stop!(self.iterable.next(vm)?);
-                self.values.write().push(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(self.values.read()[index].clone()))
+
+            Ok(PyIterReturn::Return(values[index].clone()))
         }
     }
 
@@ -1225,11 +1236,8 @@ mod decl {
 
         // TODO: make tee() a function, rename this class to itertools._tee and make
         // teedata a python class
-        fn py_new(
-            _cls: PyTypeRef,
-            Self::Args { iterable, n }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
+        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let TeeNewArgs { iterable, n } = args.bind(vm)?;
             let n = n.unwrap_or(2);
 
             let copyable = if iterable.class().has_attr(identifier!(vm, __copy__)) {
@@ -1245,6 +1253,10 @@ mod decl {
 
             Ok(PyTuple::new_ref(tee_vec, &vm.ctx).into())
         }
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            unimplemented!("use slot_new")
+        }
     }
 
     #[pyclass(with(IterNext, Iterable, Constructor))]
@@ -1298,26 +1310,28 @@ mod decl {
     impl Constructor for PyItertoolsProduct {
         type Args = (PosArgs<PyObjectRef>, ProductArgs);
 
-        fn py_new(cls: PyTypeRef, (iterables, args): Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(
+            _cls: &Py<PyType>,
+            (iterables, args): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let repeat = args.repeat.unwrap_or(1);
             let mut pools = Vec::new();
             for arg in iterables.iter() {
                 pools.push(arg.try_to_value(vm)?);
             }
-            let pools = std::iter::repeat_n(pools, repeat)
+            let pools = core::iter::repeat_n(pools, repeat)
                 .flatten()
                 .collect::<Vec<Vec<PyObjectRef>>>();
 
             let l = pools.len();
 
-            Self {
+            Ok(Self {
                 pools,
                 idxs: PyRwLock::new(vec![0; l]),
                 cur: AtomicCell::new(l.wrapping_sub(1)),
                 stop: AtomicCell::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1373,6 +1387,7 @@ mod decl {
 
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
+            let _ = pickle_deprecation(vm);
             let class = zelf.class().to_owned();
 
             if zelf.stop.load() {
@@ -1380,7 +1395,7 @@ mod decl {
             }
 
             let mut pools: Vec<PyObjectRef> = Vec::new();
-            for element in zelf.pools.iter() {
+            for element in &zelf.pools {
                 pools.push(element.clone().into_pytuple(vm).into());
             }
 
@@ -1452,10 +1467,10 @@ mod decl {
         type Args = CombinationsNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { iterable, r }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let pool: Vec<_> = iterable.try_to_value(vm)?;
 
             let r = r.as_bigint();
@@ -1466,15 +1481,13 @@ mod decl {
 
             let n = pool.len();
 
-            Self {
+            Ok(Self {
                 pool,
                 indices: PyRwLock::new((0..r).collect()),
                 result: PyRwLock::new(None),
                 r: AtomicCell::new(r),
                 exhausted: AtomicCell::new(r > n),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1482,6 +1495,7 @@ mod decl {
     impl PyItertoolsCombinations {
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyTupleRef {
+            let _ = pickle_deprecation(vm);
             let r = zelf.r.load();
 
             let class = zelf.class().to_owned();
@@ -1584,10 +1598,10 @@ mod decl {
         type Args = CombinationsNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { iterable, r }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let pool: Vec<_> = iterable.try_to_value(vm)?;
             let r = r.as_bigint();
             if r.is_negative() {
@@ -1597,14 +1611,12 @@ mod decl {
 
             let n = pool.len();
 
-            Self {
+            Ok(Self {
                 pool,
                 indices: PyRwLock::new(vec![0; r]),
                 r: AtomicCell::new(r),
                 exhausted: AtomicCell::new(n == 0 && r > 0),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1682,10 +1694,10 @@ mod decl {
         type Args = PermutationsNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
+            _cls: &Py<PyType>,
             Self::Args { iterable, r }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let pool: Vec<_> = iterable.try_to_value(vm)?;
 
             let n = pool.len();
@@ -1694,7 +1706,7 @@ mod decl {
             let r = match r.flatten() {
                 Some(r) => {
                     let val = r
-                        .payload::<PyInt>()
+                        .downcast_ref::<PyInt>()
                         .ok_or_else(|| vm.new_type_error("Expected int as r"))?
                         .as_bigint();
 
@@ -1706,16 +1718,14 @@ mod decl {
                 None => n,
             };
 
-            Self {
+            Ok(Self {
                 pool,
                 indices: PyRwLock::new((0..n).collect()),
                 cycles: PyRwLock::new((0..r.min(n)).map(|i| n - i).collect()),
                 result: PyRwLock::new(None),
                 r: AtomicCell::new(r),
                 exhausted: AtomicCell::new(r > n),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1723,6 +1733,7 @@ mod decl {
     impl PyItertoolsPermutations {
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRef<PyTuple> {
+            let _ = pickle_deprecation(vm);
             vm.new_tuple((
                 zelf.class().to_owned(),
                 vm.new_tuple((zelf.pool.clone(), vm.ctx.new_int(zelf.r.load()))),
@@ -1812,15 +1823,17 @@ mod decl {
     impl Constructor for PyItertoolsZipLongest {
         type Args = (PosArgs<PyIter>, ZipLongestArgs);
 
-        fn py_new(cls: PyTypeRef, (iterators, args): Self::Args, vm: &VirtualMachine) -> PyResult {
+        fn py_new(
+            _cls: &Py<PyType>,
+            (iterators, args): Self::Args,
+            vm: &VirtualMachine,
+        ) -> PyResult<Self> {
             let fillvalue = args.fillvalue.unwrap_or_none(vm);
             let iterators = iterators.into_vec();
-            Self {
+            Ok(Self {
                 iterators,
                 fillvalue: PyRwLock::new(fillvalue),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1836,6 +1849,7 @@ mod decl {
     impl PyItertoolsZipLongest {
         #[pymethod]
         fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            pickle_deprecation(vm)?;
             let args: Vec<PyObjectRef> = zelf
                 .iterators
                 .iter()
@@ -1897,13 +1911,11 @@ mod decl {
     impl Constructor for PyItertoolsPairwise {
         type Args = PyIter;
 
-        fn py_new(cls: PyTypeRef, iterator: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self {
+        fn py_new(_cls: &Py<PyType>, iterator: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
                 iterator,
                 old: PyRwLock::new(None),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -1944,6 +1956,7 @@ mod decl {
         exhausted: AtomicCell<bool>,
         iterable: PyIter,
         n: AtomicCell<usize>,
+        strict: AtomicCell<bool>,
     }
 
     #[derive(FromArgs)]
@@ -1952,16 +1965,22 @@ mod decl {
         iterable_ref: PyObjectRef,
         #[pyarg(positional)]
         n: PyIntRef,
+        #[pyarg(named, default = false)]
+        strict: bool,
     }
 
     impl Constructor for PyItertoolsBatched {
         type Args = BatchedNewArgs;
 
         fn py_new(
-            cls: PyTypeRef,
-            Self::Args { iterable_ref, n }: Self::Args,
+            _cls: &Py<PyType>,
+            Self::Args {
+                iterable_ref,
+                n,
+                strict,
+            }: Self::Args,
             vm: &VirtualMachine,
-        ) -> PyResult {
+        ) -> PyResult<Self> {
             let n = n.as_bigint();
             if n.lt(&BigInt::one()) {
                 return Err(vm.new_value_error("n must be at least one"));
@@ -1971,13 +1990,12 @@ mod decl {
                 .ok_or(vm.new_overflow_error("Python int too large to convert to usize"))?;
             let iterable = iterable_ref.get_iter(vm)?;
 
-            Self {
+            Ok(Self {
                 iterable,
                 n: AtomicCell::new(n),
                 exhausted: AtomicCell::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+                strict: AtomicCell::new(strict),
+            })
         }
     }
 
@@ -2004,9 +2022,16 @@ mod decl {
                     }
                 }
             }
-            match result.len() {
+            let res_len = result.len();
+            match res_len {
                 0 => Ok(PyIterReturn::StopIteration(None)),
-                _ => Ok(PyIterReturn::Return(vm.ctx.new_tuple(result).into())),
+                _ => {
+                    if zelf.strict.load() && res_len != n {
+                        Err(vm.new_value_error("batched(): incomplete batch"))
+                    } else {
+                        Ok(PyIterReturn::Return(vm.ctx.new_tuple(result).into()))
+                    }
+                }
             }
         }
     }
diff --git a/crates/vm/src/stdlib/marshal.rs b/crates/vm/src/stdlib/marshal.rs
new file mode 100644
index 0000000000..aced9e4877
--- /dev/null
+++ b/crates/vm/src/stdlib/marshal.rs
@@ -0,0 +1,252 @@
+// spell-checker:ignore pyfrozen pycomplex
+pub(crate) use decl::make_module;
+
+#[pymodule(name = "marshal")]
+mod decl {
+    use crate::builtins::code::{CodeObject, Literal, PyObjBag};
+    use crate::class::StaticType;
+    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;
+
+    #[pyattr(name = "version")]
+    use marshal::FORMAT_VERSION;
+
+    pub struct DumpError;
+
+    impl marshal::Dumpable for PyObjectRef {
+        type Error = DumpError;
+        type Constant = Literal;
+
+        fn with_dump<R>(
+            &self,
+            f: impl FnOnce(marshal::DumpableValue<'_, Self>) -> R,
+        ) -> Result<R, Self::Error> {
+            use marshal::DumpableValue::*;
+            if self.is(PyStopIteration::static_type()) {
+                return Ok(f(StopIter));
+            }
+            let ret = match_class!(match self {
+                PyNone => f(None),
+                PyEllipsis => f(Ellipsis),
+                ref pyint @ PyInt => {
+                    if self.class().is(PyBool::static_type()) {
+                        f(Boolean(!pyint.as_bigint().is_zero()))
+                    } else {
+                        f(Integer(pyint.as_bigint()))
+                    }
+                }
+                ref pyfloat @ PyFloat => {
+                    f(Float(pyfloat.to_f64()))
+                }
+                ref pycomplex @ PyComplex => {
+                    f(Complex(pycomplex.to_complex64()))
+                }
+                ref pystr @ PyStr => {
+                    f(Str(pystr.as_wtf8()))
+                }
+                ref pylist @ PyList => {
+                    f(List(&pylist.borrow_vec()))
+                }
+                ref pyset @ PySet => {
+                    let elements = pyset.elements();
+                    f(Set(&elements))
+                }
+                ref pyfrozen @ PyFrozenSet => {
+                    let elements = pyfrozen.elements();
+                    f(Frozenset(&elements))
+                }
+                ref pytuple @ PyTuple => {
+                    f(Tuple(pytuple.as_slice()))
+                }
+                ref pydict @ PyDict => {
+                    let entries = pydict.into_iter().collect::<Vec<_>>();
+                    f(Dict(&entries))
+                }
+                ref bytes @ PyBytes => {
+                    f(Bytes(bytes.as_bytes()))
+                }
+                ref bytes @ PyByteArray => {
+                    f(Bytes(&bytes.borrow_buf()))
+                }
+                ref co @ PyCode => {
+                    f(Code(co))
+                }
+                _ => return Err(DumpError),
+            });
+            Ok(ret)
+        }
+    }
+
+    #[pyfunction]
+    fn dumps(
+        value: PyObjectRef,
+        _version: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyBytes> {
+        use marshal::Dumpable;
+        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",
+                )
+            })?;
+        Ok(PyBytes::from(buf))
+    }
+
+    #[pyfunction]
+    fn dump(
+        value: PyObjectRef,
+        f: PyObjectRef,
+        version: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let dumped = dumps(value, version, vm)?;
+        vm.call_method(&f, "write", (dumped,))?;
+        Ok(())
+    }
+
+    #[derive(Copy, Clone)]
+    struct PyMarshalBag<'a>(&'a VirtualMachine);
+
+    impl<'a> marshal::MarshalBag for PyMarshalBag<'a> {
+        type Value = PyObjectRef;
+        type ConstantBag = PyObjBag<'a>;
+
+        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 {
+            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()
+        }
+
+        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);
+            for elem in it {
+                set.add(elem, vm).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))
+        }
+
+        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();
+            for (k, v) in it {
+                dict.set_item(&*k, v, vm).unwrap()
+            }
+            Ok(dict.into())
+        }
+
+        fn constant_bag(self) -> Self::ConstantBag {
+            PyObjBag(&self.0.ctx)
+        }
+    }
+
+    #[pyfunction]
+    fn loads(pybuffer: PyBuffer, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        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")
+            }
+            marshal::MarshalError::InvalidUtf8 => {
+                vm.new_value_error("invalid utf8 in marshalled string")
+            }
+            marshal::MarshalError::InvalidLocation => {
+                vm.new_value_error("invalid location in marshalled object")
+            }
+            marshal::MarshalError::BadType => {
+                vm.new_value_error("bad marshal data (unknown type code)")
+            }
+        })
+    }
+
+    #[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)
+    }
+}
diff --git a/crates/vm/src/stdlib/mod.rs b/crates/vm/src/stdlib/mod.rs
new file mode 100644
index 0000000000..e46f333a28
--- /dev/null
+++ b/crates/vm/src/stdlib/mod.rs
@@ -0,0 +1,154 @@
+#[cfg(feature = "ast")]
+pub(crate) mod ast;
+pub mod atexit;
+pub mod builtins;
+mod codecs;
+mod collections;
+pub mod errno;
+mod functools;
+mod imp;
+pub mod io;
+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"))]
+#[macro_use]
+pub mod os;
+#[cfg(windows)]
+pub mod nt;
+#[cfg(unix)]
+pub mod posix;
+#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
+#[cfg(not(any(unix, windows)))]
+#[path = "posix_compat.rs"]
+pub mod posix;
+
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos", target_os = "windows"),
+    not(any(target_env = "musl", target_env = "sgx"))
+))]
+mod ctypes;
+#[cfg(windows)]
+pub(crate) mod msvcrt;
+
+#[cfg(all(
+    unix,
+    not(any(target_os = "ios", target_os = "wasi", target_os = "redox"))
+))]
+mod pwd;
+
+pub(crate) mod signal;
+pub mod sys;
+#[cfg(windows)]
+mod winapi;
+#[cfg(windows)]
+mod winreg;
+
+use crate::{PyRef, VirtualMachine, builtins::PyModule};
+use alloc::borrow::Cow;
+use std::collections::HashMap;
+
+pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyRef<PyModule>)>;
+pub type StdlibMap = HashMap<Cow<'static, str>, StdlibInitFunc, ahash::RandomState>;
+
+pub fn get_module_inits() -> StdlibMap {
+    macro_rules! modules {
+        {
+            $(
+                #[cfg($cfg:meta)]
+                { $( $key:expr => $val:expr),* $(,)? }
+            )*
+        } => {{
+            let modules = [
+                $(
+                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
+                )*
+            ];
+            modules.into_iter().collect()
+        }};
+    }
+    modules! {
+        #[cfg(all())]
+        {
+            "atexit" => atexit::make_module,
+            "_codecs" => codecs::make_module,
+            "_collections" => collections::make_module,
+            "errno" => errno::make_module,
+            "_functools" => functools::make_module,
+            "itertools" => itertools::make_module,
+            "_io" => io::make_module,
+            "marshal" => marshal::make_module,
+            "_operator" => operator::make_module,
+            "_signal" => signal::make_module,
+            "_sre" => sre::make_module,
+            "_stat" => stat::make_module,
+            "_sysconfig" => sysconfig::make_module,
+            "_string" => string::make_module,
+            "time" => time::make_module,
+            "_typing" => typing::make_module,
+            "_weakref" => weakref::make_module,
+            "_imp" => imp::make_module,
+            "_warnings" => warnings::make_module,
+            sys::sysconfigdata_name() => sysconfigdata::make_module,
+        }
+        // parser related modules:
+        #[cfg(feature = "ast")]
+        {
+            "_ast" => ast::make_module,
+        }
+        // compiler related modules:
+        #[cfg(feature = "compiler")]
+        {
+            "_symtable" => symtable::make_module,
+        }
+        #[cfg(any(unix, target_os = "wasi"))]
+        {
+            "posix" => posix::make_module,
+            // "fcntl" => fcntl::make_module,
+        }
+        #[cfg(feature = "threading")]
+        {
+            "_thread" => thread::make_module,
+        }
+        // Unix-only
+        #[cfg(all(
+            unix,
+            not(any(target_os = "ios", target_os = "wasi", target_os = "redox"))
+        ))]
+        {
+            "pwd" => pwd::make_module,
+        }
+        // Windows-only
+        #[cfg(windows)]
+        {
+            "nt" => nt::make_module,
+            "msvcrt" => msvcrt::make_module,
+            "_winapi" => winapi::make_module,
+            "winreg" => winreg::make_module,
+        }
+        #[cfg(all(
+            any(target_os = "linux", target_os = "macos", target_os = "windows"),
+            not(any(target_env = "musl", target_env = "sgx"))
+        ))]
+        {
+            "_ctypes" => ctypes::make_module,
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/msvcrt.rs b/crates/vm/src/stdlib/msvcrt.rs
new file mode 100644
index 0000000000..cf0dac2c9d
--- /dev/null
+++ b/crates/vm/src/stdlib/msvcrt.rs
@@ -0,0 +1,118 @@
+// spell-checker:disable
+
+pub use msvcrt::*;
+
+#[pymodule]
+mod msvcrt {
+    use crate::{
+        PyRef, PyResult, VirtualMachine,
+        builtins::{PyBytes, PyStrRef},
+        common::{crt_fd, suppress_iph},
+        convert::IntoPyException,
+    };
+    use itertools::Itertools;
+    use std::os::windows::io::AsRawHandle;
+    use windows_sys::Win32::System::Diagnostics::Debug;
+
+    #[pyattr]
+    use windows_sys::Win32::System::Diagnostics::Debug::{
+        SEM_FAILCRITICALERRORS, SEM_NOALIGNMENTFAULTEXCEPT, SEM_NOGPFAULTERRORBOX,
+        SEM_NOOPENFILEERRORBOX,
+    };
+
+    pub fn setmode_binary(fd: crt_fd::Borrowed<'_>) {
+        unsafe { suppress_iph!(_setmode(fd, libc::O_BINARY)) };
+    }
+
+    unsafe extern "C" {
+        fn _getch() -> i32;
+        fn _getwch() -> u32;
+        fn _getche() -> i32;
+        fn _getwche() -> u32;
+        fn _putch(c: u32) -> i32;
+        fn _putwch(c: u16) -> u32;
+    }
+
+    #[pyfunction]
+    fn getch() -> Vec<u8> {
+        let c = unsafe { _getch() };
+        vec![c as u8]
+    }
+    #[pyfunction]
+    fn getwch() -> String {
+        let c = unsafe { _getwch() };
+        std::char::from_u32(c).unwrap().to_string()
+    }
+    #[pyfunction]
+    fn getche() -> Vec<u8> {
+        let c = unsafe { _getche() };
+        vec![c as u8]
+    }
+    #[pyfunction]
+    fn getwche() -> String {
+        let c = unsafe { _getwche() };
+        std::char::from_u32(c).unwrap().to_string()
+    }
+    #[pyfunction]
+    fn putch(b: PyRef<PyBytes>, vm: &VirtualMachine) -> PyResult<()> {
+        let &c =
+            b.as_bytes().iter().exactly_one().map_err(|_| {
+                vm.new_type_error("putch() argument must be a byte string of length 1")
+            })?;
+        unsafe { suppress_iph!(_putch(c.into())) };
+        Ok(())
+    }
+    #[pyfunction]
+    fn putwch(s: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let c = s
+            .as_str()
+            .chars()
+            .exactly_one()
+            .map_err(|_| vm.new_type_error("putch() argument must be a string of length 1"))?;
+        unsafe { suppress_iph!(_putwch(c as u16)) };
+        Ok(())
+    }
+
+    unsafe extern "C" {
+        fn _setmode(fd: crt_fd::Borrowed<'_>, flags: i32) -> i32;
+    }
+
+    #[pyfunction]
+    fn setmode(fd: crt_fd::Borrowed<'_>, flags: i32, vm: &VirtualMachine) -> PyResult<i32> {
+        let flags = unsafe { suppress_iph!(_setmode(fd, flags)) };
+        if flags == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(flags)
+        }
+    }
+
+    #[pyfunction]
+    fn open_osfhandle(handle: isize, flags: i32, vm: &VirtualMachine) -> PyResult<i32> {
+        let ret = unsafe { suppress_iph!(libc::open_osfhandle(handle, flags)) };
+        if ret == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(ret)
+        }
+    }
+
+    #[pyfunction]
+    fn get_osfhandle(fd: crt_fd::Borrowed<'_>, vm: &VirtualMachine) -> PyResult<isize> {
+        crt_fd::as_handle(fd)
+            .map(|h| h.as_raw_handle() as _)
+            .map_err(|e| e.into_pyexception(vm))
+    }
+
+    #[allow(non_snake_case)]
+    #[pyfunction]
+    fn GetErrorMode() -> u32 {
+        unsafe { suppress_iph!(Debug::GetErrorMode()) }
+    }
+
+    #[allow(non_snake_case)]
+    #[pyfunction]
+    fn SetErrorMode(mode: Debug::THREAD_ERROR_MODE, _: &VirtualMachine) -> u32 {
+        unsafe { suppress_iph!(Debug::SetErrorMode(mode)) }
+    }
+}
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
new file mode 100644
index 0000000000..a32959808c
--- /dev/null
+++ b/crates/vm/src/stdlib/nt.rs
@@ -0,0 +1,1926 @@
+// spell-checker:disable
+
+use crate::{PyRef, VirtualMachine, builtins::PyModule};
+
+pub use module::raw_set_handle_inheritable;
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = module::make_module(vm);
+    super::os::extend_module(vm, &module);
+    module
+}
+
+#[pymodule(name = "nt", with(super::os::_os))]
+pub(crate) mod module {
+    use crate::{
+        PyResult, TryFromObject, VirtualMachine,
+        builtins::{PyBaseExceptionRef, PyDictRef, PyListRef, PyStrRef, PyTupleRef},
+        common::{crt_fd, suppress_iph, windows::ToWideString},
+        convert::ToPyException,
+        exceptions::OSErrorBuilder,
+        function::{Either, OptionalArg},
+        ospath::{OsPath, OsPathOrFd},
+        stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
+    };
+
+    use libc::intptr_t;
+    use std::os::windows::io::AsRawHandle;
+    use std::{env, fs, io, mem::MaybeUninit, os::windows::ffi::OsStringExt};
+    use windows_sys::Win32::{
+        Foundation::{self, INVALID_HANDLE_VALUE},
+        Storage::FileSystem,
+        System::{Console, Threading},
+    };
+
+    #[pyattr]
+    use libc::{O_BINARY, O_NOINHERIT, O_RANDOM, O_SEQUENTIAL, O_TEMPORARY, O_TEXT};
+
+    // Windows spawn mode constants
+    #[pyattr]
+    const P_WAIT: i32 = 0;
+    #[pyattr]
+    const P_NOWAIT: i32 = 1;
+    #[pyattr]
+    const P_OVERLAY: i32 = 2;
+    #[pyattr]
+    const P_NOWAITO: i32 = 3;
+    #[pyattr]
+    const P_DETACH: i32 = 4;
+
+    // _O_SHORT_LIVED is not in libc, define manually
+    #[pyattr]
+    const O_SHORT_LIVED: i32 = 0x1000;
+
+    // Exit code constant
+    #[pyattr]
+    const EX_OK: i32 = 0;
+
+    // Maximum number of temporary files
+    #[pyattr]
+    const TMP_MAX: i32 = i32::MAX;
+
+    #[pyattr]
+    use windows_sys::Win32::System::LibraryLoader::{
+        LOAD_LIBRARY_SEARCH_APPLICATION_DIR as _LOAD_LIBRARY_SEARCH_APPLICATION_DIR,
+        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS as _LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
+        LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR as _LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR,
+        LOAD_LIBRARY_SEARCH_SYSTEM32 as _LOAD_LIBRARY_SEARCH_SYSTEM32,
+        LOAD_LIBRARY_SEARCH_USER_DIRS as _LOAD_LIBRARY_SEARCH_USER_DIRS,
+    };
+
+    #[pyfunction]
+    pub(super) fn access(path: OsPath, mode: u8, vm: &VirtualMachine) -> PyResult<bool> {
+        let attr = unsafe { FileSystem::GetFileAttributesW(path.to_wide_cstring(vm)?.as_ptr()) };
+        Ok(attr != FileSystem::INVALID_FILE_ATTRIBUTES
+            && (mode & 2 == 0
+                || attr & FileSystem::FILE_ATTRIBUTE_READONLY == 0
+                || attr & FileSystem::FILE_ATTRIBUTE_DIRECTORY != 0))
+    }
+
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    pub(super) fn remove(
+        path: OsPath,
+        dir_fd: DirFd<'static, 0>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        // On Windows, use DeleteFileW directly.
+        // Rust's std::fs::remove_file may have different behavior for read-only files.
+        // See Py_DeleteFileW.
+        use windows_sys::Win32::Storage::FileSystem::{
+            DeleteFileW, FindClose, FindFirstFileW, RemoveDirectoryW, WIN32_FIND_DATAW,
+        };
+        use windows_sys::Win32::System::SystemServices::{
+            IO_REPARSE_TAG_MOUNT_POINT, IO_REPARSE_TAG_SYMLINK,
+        };
+
+        let [] = dir_fd.0;
+        let wide_path = path.to_wide_cstring(vm)?;
+        let attrs = unsafe { FileSystem::GetFileAttributesW(wide_path.as_ptr()) };
+
+        let mut is_directory = false;
+        let mut is_link = false;
+
+        if attrs != FileSystem::INVALID_FILE_ATTRIBUTES {
+            is_directory = (attrs & FileSystem::FILE_ATTRIBUTE_DIRECTORY) != 0;
+
+            // Check if it's a symlink or junction point
+            if is_directory && (attrs & FileSystem::FILE_ATTRIBUTE_REPARSE_POINT) != 0 {
+                let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+                let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
+                if handle != INVALID_HANDLE_VALUE {
+                    is_link = find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK
+                        || find_data.dwReserved0 == IO_REPARSE_TAG_MOUNT_POINT;
+                    unsafe { FindClose(handle) };
+                }
+            }
+        }
+
+        let result = if is_directory && is_link {
+            unsafe { RemoveDirectoryW(wide_path.as_ptr()) }
+        } else {
+            unsafe { DeleteFileW(wide_path.as_ptr()) }
+        };
+
+        if result == 0 {
+            let err = io::Error::last_os_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    pub(super) fn _supports_virtual_terminal() -> PyResult<bool> {
+        // TODO: implement this
+        Ok(true)
+    }
+
+    #[derive(FromArgs)]
+    pub(super) struct SymlinkArgs<'fd> {
+        src: OsPath,
+        dst: OsPath,
+        #[pyarg(flatten)]
+        target_is_directory: TargetIsDirectory,
+        #[pyarg(flatten)]
+        _dir_fd: DirFd<'fd, { _os::SYMLINK_DIR_FD as usize }>,
+    }
+
+    #[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)
+        };
+        res.map_err(|err| err.to_pyexception(vm))
+    }
+
+    #[pyfunction]
+    fn set_inheritable(
+        fd: crt_fd::Borrowed<'_>,
+        inheritable: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let handle = crt_fd::as_handle(fd).map_err(|e| e.to_pyexception(vm))?;
+        set_handle_inheritable(handle.as_raw_handle() as _, inheritable, vm)
+    }
+
+    #[pyattr]
+    fn environ(vm: &VirtualMachine) -> PyDictRef {
+        let environ = vm.ctx.new_dict();
+
+        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.
+            if key.starts_with('=') {
+                continue;
+            }
+            environ.set_item(&key, vm.new_pyobj(value), vm).unwrap();
+        }
+        environ
+    }
+
+    #[derive(FromArgs)]
+    struct ChmodArgs<'a> {
+        #[pyarg(any)]
+        path: OsPathOrFd<'a>,
+        #[pyarg(any)]
+        mode: u32,
+        #[pyarg(flatten)]
+        dir_fd: DirFd<'static, 0>,
+        #[pyarg(named, name = "follow_symlinks", optional)]
+        follow_symlinks: OptionalArg<bool>,
+    }
+
+    const S_IWRITE: u32 = 128;
+
+    fn fchmod_impl(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::Storage::FileSystem::{
+            FILE_BASIC_INFO, FileBasicInfo, GetFileInformationByHandleEx,
+            SetFileInformationByHandle,
+        };
+
+        // Get Windows HANDLE from fd
+        let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
+        let handle = crt_fd::as_handle(borrowed).map_err(|e| e.to_pyexception(vm))?;
+        let hfile = handle.as_raw_handle() as Foundation::HANDLE;
+
+        // Get current file info
+        let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+        let ret = unsafe {
+            GetFileInformationByHandleEx(
+                hfile,
+                FileBasicInfo,
+                &mut info as *mut _ as *mut _,
+                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Modify readonly attribute based on S_IWRITE bit
+        if mode & S_IWRITE != 0 {
+            info.FileAttributes &= !FileSystem::FILE_ATTRIBUTE_READONLY;
+        } else {
+            info.FileAttributes |= FileSystem::FILE_ATTRIBUTE_READONLY;
+        }
+
+        // Set the new attributes
+        let ret = unsafe {
+            SetFileInformationByHandle(
+                hfile,
+                FileBasicInfo,
+                &info as *const _ as *const _,
+                std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn fchmod(fd: i32, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+        fchmod_impl(fd, mode, vm)
+    }
+
+    #[pyfunction]
+    fn chmod(args: ChmodArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
+        let ChmodArgs {
+            path,
+            mode,
+            dir_fd,
+            follow_symlinks,
+        } = args;
+        let [] = dir_fd.0;
+
+        // If path is a file descriptor, use fchmod
+        if let OsPathOrFd::Fd(fd) = path {
+            if follow_symlinks.into_option().is_some() {
+                return Err(vm.new_value_error(
+                    "chmod: follow_symlinks is not supported with fd argument".to_owned(),
+                ));
+            }
+            return fchmod_impl(fd.as_raw(), mode, vm);
+        }
+
+        let OsPathOrFd::Path(path) = path else {
+            unreachable!()
+        };
+
+        // On Windows, os.chmod behavior differs based on whether follow_symlinks is explicitly provided:
+        // - Not provided (default): use SetFileAttributesW on the path directly (doesn't follow symlinks)
+        // - Explicitly True: resolve symlink first, then apply permissions to target
+        // - 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())
+            }
+        };
+
+        // 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))
+    }
+
+    /// Get the real file name (with correct case) without accessing the file.
+    /// Uses FindFirstFileW to get the name as stored on the filesystem.
+    #[pyfunction]
+    fn _findfirstfile(path: OsPath, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        use crate::common::windows::ToWideString;
+        use std::os::windows::ffi::OsStringExt;
+        use windows_sys::Win32::Storage::FileSystem::{
+            FindClose, FindFirstFileW, WIN32_FIND_DATAW,
+        };
+
+        let wide_path = path.as_ref().to_wide_with_nul();
+        let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+
+        let handle = unsafe { FindFirstFileW(wide_path.as_ptr(), &mut find_data) };
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_os_error(format!(
+                "FindFirstFileW failed for path: {}",
+                path.as_ref().display()
+            )));
+        }
+
+        unsafe { FindClose(handle) };
+
+        // Convert the filename from the find data to a Rust string
+        // cFileName is a null-terminated wide string
+        let len = find_data
+            .cFileName
+            .iter()
+            .position(|&c| c == 0)
+            .unwrap_or(find_data.cFileName.len());
+        let filename = std::ffi::OsString::from_wide(&find_data.cFileName[..len]);
+        let filename_str = filename
+            .to_str()
+            .ok_or_else(|| vm.new_unicode_decode_error("filename contains invalid UTF-8"))?;
+
+        Ok(vm.ctx.new_str(filename_str).to_owned())
+    }
+
+    #[derive(FromArgs)]
+    struct PathArg {
+        #[pyarg(any)]
+        path: crate::PyObjectRef,
+    }
+
+    impl PathArg {
+        fn to_path_or_fd(&self, vm: &VirtualMachine) -> Option<OsPathOrFd<'static>> {
+            OsPathOrFd::try_from_object(vm, self.path.clone()).ok()
+        }
+    }
+
+    // File type test constants (PY_IF* constants - internal, not from Windows API)
+    const PY_IFREG: u32 = 1; // Regular file
+    const PY_IFDIR: u32 = 2; // Directory
+    const PY_IFLNK: u32 = 4; // Symlink
+    const PY_IFMNT: u32 = 8; // Mount point (junction)
+
+    /// _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 {
+        use windows_sys::Win32::Storage::FileSystem::{
+            FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_REPARSE_POINT,
+        };
+        use windows_sys::Win32::System::SystemServices::{
+            IO_REPARSE_TAG_MOUNT_POINT, IO_REPARSE_TAG_SYMLINK,
+        };
+
+        match tested_type {
+            PY_IFREG => {
+                // diskDevice && attributes && !(attributes & FILE_ATTRIBUTE_DIRECTORY)
+                disk_device && attributes != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0
+            }
+            PY_IFDIR => (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0,
+            PY_IFLNK => {
+                (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+                    && reparse_tag == IO_REPARSE_TAG_SYMLINK
+            }
+            PY_IFMNT => {
+                (attributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
+                    && reparse_tag == IO_REPARSE_TAG_MOUNT_POINT
+            }
+            _ => false,
+        }
+    }
+
+    /// _testFileTypeByHandle - test file type using an open handle
+    fn _test_file_type_by_handle(
+        handle: windows_sys::Win32::Foundation::HANDLE,
+        tested_type: u32,
+        disk_only: bool,
+    ) -> bool {
+        use windows_sys::Win32::Storage::FileSystem::{
+            FILE_ATTRIBUTE_TAG_INFO, FILE_BASIC_INFO, FILE_TYPE_DISK,
+            FileAttributeTagInfo as FileAttributeTagInfoClass, FileBasicInfo,
+            GetFileInformationByHandleEx, GetFileType,
+        };
+
+        let disk_device = unsafe { GetFileType(handle) } == FILE_TYPE_DISK;
+        if disk_only && !disk_device {
+            return false;
+        }
+
+        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 ret = unsafe {
+                GetFileInformationByHandleEx(
+                    handle,
+                    FileAttributeTagInfoClass,
+                    &mut info as *mut _ as *mut _,
+                    std::mem::size_of::<FILE_ATTRIBUTE_TAG_INFO>() as u32,
+                )
+            };
+            if ret == 0 {
+                return false;
+            }
+            _test_info(
+                info.FileAttributes,
+                info.ReparseTag,
+                disk_device,
+                tested_type,
+            )
+        } else {
+            // For regular files/directories, FileBasicInfo is sufficient
+            let mut info: FILE_BASIC_INFO = unsafe { std::mem::zeroed() };
+            let ret = unsafe {
+                GetFileInformationByHandleEx(
+                    handle,
+                    FileBasicInfo,
+                    &mut info as *mut _ as *mut _,
+                    std::mem::size_of::<FILE_BASIC_INFO>() as u32,
+                )
+            };
+            if ret == 0 {
+                return false;
+            }
+            _test_info(info.FileAttributes, 0, disk_device, tested_type)
+        }
+    }
+
+    /// _testFileTypeByName - test file type by path name
+    fn _test_file_type_by_name(path: &std::path::Path, tested_type: u32) -> bool {
+        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,
+        };
+
+        // 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;
+            }
+            // 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,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                flags,
+                std::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);
+            unsafe { CloseHandle(handle) };
+            return result;
+        }
+
+        let result = _test_file_type_by_handle(handle, tested_type, true);
+        unsafe { CloseHandle(handle) };
+        result
+    }
+
+    /// _testFileExistsByName - test if path exists
+    fn _test_file_exists_by_name(path: &std::path::Path, follow_links: bool) -> bool {
+        use crate::common::windows::ToWideString;
+        use windows_sys::Win32::Foundation::{CloseHandle, GENERIC_READ, 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,
+        };
+
+        // First try standard Rust exists/symlink_metadata (handles \\?\ paths well)
+        if follow_links {
+            if path.exists() {
+                return true;
+            }
+        } 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,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                flags,
+                std::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;
+        }
+
+        false
+    }
+
+    /// _testFileType wrapper - handles both fd and path
+    fn _test_file_type(path_or_fd: &OsPathOrFd<'_>, tested_type: u32) -> bool {
+        match path_or_fd {
+            OsPathOrFd::Fd(fd) => {
+                if let Ok(handle) = crate::common::crt_fd::as_handle(*fd) {
+                    use std::os::windows::io::AsRawHandle;
+                    _test_file_type_by_handle(handle.as_raw_handle() as _, tested_type, true)
+                } else {
+                    false
+                }
+            }
+            OsPathOrFd::Path(path) => _test_file_type_by_name(path.as_ref(), tested_type),
+        }
+    }
+
+    /// _testFileExists wrapper - handles both fd and path
+    fn _test_file_exists(path_or_fd: &OsPathOrFd<'_>, follow_links: bool) -> bool {
+        use windows_sys::Win32::Storage::FileSystem::{FILE_TYPE_UNKNOWN, GetFileType};
+
+        match path_or_fd {
+            OsPathOrFd::Fd(fd) => {
+                if let Ok(handle) = crate::common::crt_fd::as_handle(*fd) {
+                    use std::os::windows::io::AsRawHandle;
+                    let file_type = unsafe { GetFileType(handle.as_raw_handle() as _) };
+                    // GetFileType(hfile) != FILE_TYPE_UNKNOWN || !GetLastError()
+                    if file_type != FILE_TYPE_UNKNOWN {
+                        return true;
+                    }
+                    // Check if GetLastError is 0 (no error means valid handle)
+                    unsafe { windows_sys::Win32::Foundation::GetLastError() == 0 }
+                } else {
+                    false
+                }
+            }
+            OsPathOrFd::Path(path) => _test_file_exists_by_name(path.as_ref(), follow_links),
+        }
+    }
+
+    /// Check if a path is a directory.
+    /// return _testFileType(path, PY_IFDIR)
+    #[pyfunction]
+    fn _path_isdir(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_type(&p, PY_IFDIR))
+    }
+
+    /// Check if a path is a regular file.
+    /// return _testFileType(path, PY_IFREG)
+    #[pyfunction]
+    fn _path_isfile(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_type(&p, PY_IFREG))
+    }
+
+    /// Check if a path is a symbolic link.
+    /// return _testFileType(path, PY_IFLNK)
+    #[pyfunction]
+    fn _path_islink(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_type(&p, PY_IFLNK))
+    }
+
+    /// Check if a path is a junction (mount point).
+    /// return _testFileType(path, PY_IFMNT)
+    #[pyfunction]
+    fn _path_isjunction(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_type(&p, PY_IFMNT))
+    }
+
+    /// Check if a path exists (follows symlinks).
+    /// return _testFileExists(path, TRUE)
+    #[pyfunction]
+    fn _path_exists(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_exists(&p, true))
+    }
+
+    /// Check if a path exists (does not follow symlinks).
+    /// return _testFileExists(path, FALSE)
+    #[pyfunction]
+    fn _path_lexists(args: PathArg, vm: &VirtualMachine) -> bool {
+        args.to_path_or_fd(vm)
+            .is_some_and(|p| _test_file_exists(&p, false))
+    }
+
+    /// Check if a path is on a Windows Dev Drive.
+    #[pyfunction]
+    fn _path_isdevdrive(path: OsPath, vm: &VirtualMachine) -> PyResult<bool> {
+        use windows_sys::Win32::Foundation::CloseHandle;
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_READ_ATTRIBUTES, FILE_SHARE_READ,
+            FILE_SHARE_WRITE, GetDriveTypeW, GetVolumePathNameW, OPEN_EXISTING,
+        };
+        use windows_sys::Win32::System::IO::DeviceIoControl;
+        use windows_sys::Win32::System::Ioctl::FSCTL_QUERY_PERSISTENT_VOLUME_STATE;
+        use windows_sys::Win32::System::WindowsProgramming::DRIVE_FIXED;
+
+        // PERSISTENT_VOLUME_STATE_DEV_VOLUME flag - not yet in windows-sys
+        const PERSISTENT_VOLUME_STATE_DEV_VOLUME: u32 = 0x00002000;
+
+        // FILE_FS_PERSISTENT_VOLUME_INFORMATION structure
+        #[repr(C)]
+        struct FileFsPersistentVolumeInformation {
+            volume_flags: u32,
+            flag_mask: u32,
+            version: u32,
+            reserved: u32,
+        }
+
+        let wide_path = path.to_wide_cstring(vm)?;
+        let mut volume = [0u16; Foundation::MAX_PATH as usize];
+
+        // Get volume path
+        let ret = unsafe {
+            GetVolumePathNameW(wide_path.as_ptr(), volume.as_mut_ptr(), volume.len() as _)
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Check if it's a fixed drive
+        if unsafe { GetDriveTypeW(volume.as_ptr()) } != DRIVE_FIXED {
+            return Ok(false);
+        }
+
+        // Open the volume
+        let handle = unsafe {
+            CreateFileW(
+                volume.as_ptr(),
+                FILE_READ_ATTRIBUTES,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                FILE_FLAG_BACKUP_SEMANTICS,
+                std::ptr::null_mut(),
+            )
+        };
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Query persistent volume state
+        let mut volume_state = FileFsPersistentVolumeInformation {
+            volume_flags: 0,
+            flag_mask: PERSISTENT_VOLUME_STATE_DEV_VOLUME,
+            version: 1,
+            reserved: 0,
+        };
+
+        let ret = unsafe {
+            DeviceIoControl(
+                handle,
+                FSCTL_QUERY_PERSISTENT_VOLUME_STATE,
+                &volume_state as *const _ as *const std::ffi::c_void,
+                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                &mut volume_state as *mut _ as *mut std::ffi::c_void,
+                std::mem::size_of::<FileFsPersistentVolumeInformation>() as u32,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+            )
+        };
+
+        unsafe { CloseHandle(handle) };
+
+        if ret == 0 {
+            let err = io::Error::last_os_error();
+            // ERROR_INVALID_PARAMETER means not supported on this platform
+            if err.raw_os_error() == Some(Foundation::ERROR_INVALID_PARAMETER as i32) {
+                return Ok(false);
+            }
+            return Err(err.to_pyexception(vm));
+        }
+
+        Ok((volume_state.volume_flags & PERSISTENT_VOLUME_STATE_DEV_VOLUME) != 0)
+    }
+
+    // cwait is available on MSVC only
+    #[cfg(target_env = "msvc")]
+    unsafe extern "C" {
+        fn _cwait(termstat: *mut i32, procHandle: intptr_t, action: i32) -> intptr_t;
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn waitpid(pid: intptr_t, opt: i32, vm: &VirtualMachine) -> PyResult<(intptr_t, u64)> {
+        let mut status: i32 = 0;
+        let pid = unsafe { suppress_iph!(_cwait(&mut status, pid, opt)) };
+        if pid == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            // Cast to unsigned to handle large exit codes (like 0xC000013A)
+            // then shift left by 8 to match POSIX waitpid format
+            let ustatus = (status as u32) as u64;
+            Ok((pid, ustatus << 8))
+        }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn wait(vm: &VirtualMachine) -> PyResult<(intptr_t, u64)> {
+        waitpid(-1, 0, vm)
+    }
+
+    #[pyfunction]
+    fn kill(pid: i32, sig: isize, vm: &VirtualMachine) -> PyResult<()> {
+        let sig = sig as u32;
+        let pid = pid as u32;
+
+        if sig == Console::CTRL_C_EVENT || sig == Console::CTRL_BREAK_EVENT {
+            let ret = unsafe { Console::GenerateConsoleCtrlEvent(sig, pid) };
+            let res = if ret == 0 {
+                Err(vm.new_last_os_error())
+            } else {
+                Ok(())
+            };
+            return res;
+        }
+
+        let h = unsafe { Threading::OpenProcess(Threading::PROCESS_ALL_ACCESS, 0, pid) };
+        if h.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        let ret = unsafe { Threading::TerminateProcess(h, sig) };
+        let res = if ret == 0 {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(())
+        };
+        unsafe { Foundation::CloseHandle(h) };
+        res
+    }
+
+    #[pyfunction]
+    fn get_terminal_size(
+        fd: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<_os::TerminalSizeData> {
+        let fd = fd.unwrap_or(1); // default to stdout
+
+        // Use _get_osfhandle for all fds
+        let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
+        let handle = crt_fd::as_handle(borrowed).map_err(|e| e.to_pyexception(vm))?;
+        let h = handle.as_raw_handle() as Foundation::HANDLE;
+
+        let mut csbi = MaybeUninit::uninit();
+        let ret = unsafe { Console::GetConsoleScreenBufferInfo(h, csbi.as_mut_ptr()) };
+        if ret == 0 {
+            // Check if error is due to lack of read access on a console handle
+            // ERROR_ACCESS_DENIED (5) means it's a console but without read permission
+            // In that case, try opening CONOUT$ directly with read access
+            let err = unsafe { Foundation::GetLastError() };
+            if err != Foundation::ERROR_ACCESS_DENIED {
+                return Err(vm.new_last_os_error());
+            }
+            let conout: Vec<u16> = "CONOUT$\0".encode_utf16().collect();
+            let console_handle = unsafe {
+                FileSystem::CreateFileW(
+                    conout.as_ptr(),
+                    Foundation::GENERIC_READ | Foundation::GENERIC_WRITE,
+                    FileSystem::FILE_SHARE_READ | FileSystem::FILE_SHARE_WRITE,
+                    core::ptr::null(),
+                    FileSystem::OPEN_EXISTING,
+                    0,
+                    std::ptr::null_mut(),
+                )
+            };
+            if console_handle == INVALID_HANDLE_VALUE {
+                return Err(vm.new_last_os_error());
+            }
+            let ret =
+                unsafe { Console::GetConsoleScreenBufferInfo(console_handle, csbi.as_mut_ptr()) };
+            unsafe { Foundation::CloseHandle(console_handle) };
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+        }
+        let csbi = unsafe { csbi.assume_init() };
+        let w = csbi.srWindow;
+        let columns = (w.Right - w.Left + 1) as usize;
+        let lines = (w.Bottom - w.Top + 1) as usize;
+        Ok(_os::TerminalSizeData { columns, lines })
+    }
+
+    #[cfg(target_env = "msvc")]
+    unsafe extern "C" {
+        fn _wexecv(cmdname: *const u16, argv: *const *const u16) -> intptr_t;
+        fn _wexecve(
+            cmdname: *const u16,
+            argv: *const *const u16,
+            envp: *const *const u16,
+        ) -> intptr_t;
+        fn _wspawnv(mode: i32, cmdname: *const u16, argv: *const *const u16) -> intptr_t;
+        fn _wspawnve(
+            mode: i32,
+            cmdname: *const u16,
+            argv: *const *const u16,
+            envp: *const *const u16,
+        ) -> intptr_t;
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn spawnv(
+        mode: i32,
+        path: OsPath,
+        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));
+
+        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 first = argv
+            .first()
+            .ok_or_else(|| vm.new_value_error("spawnv() arg 3 must not be empty"))?;
+
+        if first.is_empty() {
+            return Err(vm.new_value_error("spawnv() arg 3 first element cannot be empty"));
+        }
+
+        let argv_spawn: Vec<*const u16> = argv
+            .iter()
+            .map(|v| v.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        let result = unsafe { suppress_iph!(_wspawnv(mode, path.as_ptr(), argv_spawn.as_ptr())) };
+        if result == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(result)
+        }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn spawnve(
+        mode: i32,
+        path: OsPath,
+        argv: Either<PyListRef, PyTupleRef>,
+        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));
+
+        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 first = argv
+            .first()
+            .ok_or_else(|| vm.new_value_error("spawnve() arg 2 cannot be empty"))?;
+
+        if first.is_empty() {
+            return Err(vm.new_value_error("spawnve() arg 2 first element cannot be empty"));
+        }
+
+        let argv_spawn: Vec<*const u16> = argv
+            .iter()
+            .map(|v| v.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        // 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('=')) {
+                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)?);
+        }
+
+        let envp: Vec<*const u16> = env_strings
+            .iter()
+            .map(|s| s.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        let result = unsafe {
+            suppress_iph!(_wspawnve(
+                mode,
+                path.as_ptr(),
+                argv_spawn.as_ptr(),
+                envp.as_ptr()
+            ))
+        };
+        if result == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(result)
+        }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn execv(
+        path: OsPath,
+        argv: Either<PyListRef, PyTupleRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use std::iter::once;
+
+        let make_widestring =
+            |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
+
+        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 first = argv
+            .first()
+            .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty"))?;
+
+        if first.is_empty() {
+            return Err(vm.new_value_error("execv() arg 2 first element cannot be empty"));
+        }
+
+        let argv_execv: Vec<*const u16> = argv
+            .iter()
+            .map(|v| v.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        if (unsafe { suppress_iph!(_wexecv(path.as_ptr(), argv_execv.as_ptr())) } == -1) {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[pyfunction]
+    fn execve(
+        path: OsPath,
+        argv: Either<PyListRef, PyTupleRef>,
+        env: PyDictRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        use std::iter::once;
+
+        let make_widestring =
+            |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
+
+        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 first = argv
+            .first()
+            .ok_or_else(|| vm.new_value_error("execve: argv must not be empty"))?;
+
+        if first.is_empty() {
+            return Err(vm.new_value_error("execve: argv first element cannot be empty"));
+        }
+
+        let argv_execve: Vec<*const u16> = argv
+            .iter()
+            .map(|v| v.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        // 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('=')) {
+                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)?);
+        }
+
+        let envp: Vec<*const u16> = env_strings
+            .iter()
+            .map(|s| s.as_ptr())
+            .chain(once(core::ptr::null()))
+            .collect();
+
+        if (unsafe { suppress_iph!(_wexecve(path.as_ptr(), argv_execve.as_ptr(), envp.as_ptr())) }
+            == -1)
+        {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    #[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))
+    }
+
+    #[pyfunction]
+    fn _getfullpathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
+        let wpath = path.to_wide_cstring(vm)?;
+        let mut buffer = vec![0u16; Foundation::MAX_PATH as usize];
+        let ret = unsafe {
+            FileSystem::GetFullPathNameW(
+                wpath.as_ptr(),
+                buffer.len() as _,
+                buffer.as_mut_ptr(),
+                std::ptr::null_mut(),
+            )
+        };
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        if ret as usize > buffer.len() {
+            buffer.resize(ret as usize, 0);
+            let ret = unsafe {
+                FileSystem::GetFullPathNameW(
+                    wpath.as_ptr(),
+                    buffer.len() as _,
+                    buffer.as_mut_ptr(),
+                    std::ptr::null_mut(),
+                )
+            };
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+        }
+        let buffer = widestring::WideCString::from_vec_truncate(buffer);
+        Ok(path.mode().process_path(buffer.to_os_string(), vm))
+    }
+
+    #[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 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 buffer = widestring::WideCString::from_vec_truncate(buffer);
+        Ok(path.mode().process_path(buffer.to_os_string(), vm))
+    }
+
+    /// Implements _Py_skiproot logic for Windows paths
+    /// Returns (drive_size, root_size) where:
+    /// - drive_size: length of the drive/UNC portion
+    /// - root_size: length of the root separator (0 or 1)
+    fn skiproot(path: &[u16]) -> (usize, usize) {
+        let len = path.len();
+        if len == 0 {
+            return (0, 0);
+        }
+
+        const SEP: u16 = b'\\' as u16;
+        const ALTSEP: u16 = b'/' as u16;
+        const COLON: u16 = b':' as u16;
+
+        let is_sep = |c: u16| c == SEP || c == ALTSEP;
+        let get = |i: usize| path.get(i).copied().unwrap_or(0);
+
+        if is_sep(get(0)) {
+            if is_sep(get(1)) {
+                // UNC or device path: \\server\share or \\?\device
+                // Check for \\?\UNC\server\share
+                let idx = if len >= 8
+                    && get(2) == b'?' as u16
+                    && is_sep(get(3))
+                    && (get(4) == b'U' as u16 || get(4) == b'u' as u16)
+                    && (get(5) == b'N' as u16 || get(5) == b'n' as u16)
+                    && (get(6) == b'C' as u16 || get(6) == b'c' as u16)
+                    && is_sep(get(7))
+                {
+                    8
+                } else {
+                    2
+                };
+
+                // Find the end of server name
+                let mut i = idx;
+                while i < len && !is_sep(get(i)) {
+                    i += 1;
+                }
+
+                if i >= len {
+                    // No share part: \\server
+                    return (i, 0);
+                }
+
+                // Skip separator and find end of share name
+                i += 1;
+                while i < len && !is_sep(get(i)) {
+                    i += 1;
+                }
+
+                // drive = \\server\share, root = \ (if present)
+                if i >= len { (i, 0) } else { (i, 1) }
+            } else {
+                // Relative path with root: \Windows
+                (0, 1)
+            }
+        } else if len >= 2 && get(1) == COLON {
+            // Drive letter path
+            if len >= 3 && is_sep(get(2)) {
+                // Absolute: X:\Windows
+                (2, 1)
+            } else {
+                // Relative with drive: X:Windows
+                (2, 0)
+            }
+        } else {
+            // Relative path: Windows
+            (0, 0)
+        }
+    }
+
+    #[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)?
+        } else {
+            path
+        };
+
+        // Convert to wide string, validating UTF-8 for bytes input
+        let (wide, is_bytes): (Vec<u16>, bool) = if let Some(s) = path.downcast_ref::<PyStr>() {
+            // Use encode_wide which handles WTF-8 (including surrogates)
+            let wide: Vec<u16> = s.as_wtf8().encode_wide().collect();
+            (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| {
+                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()
+                    ),
+                )
+            })?;
+            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()
+            )));
+        };
+
+        // Normalize slashes for parsing
+        let normalized: Vec<u16> = wide
+            .iter()
+            .map(|&c| if c == b'/' as u16 { b'\\' as u16 } else { c })
+            .collect();
+
+        let (drv_size, root_size) = skiproot(&normalized);
+
+        // Return as bytes if input was bytes, preserving the original content
+        if is_bytes {
+            // Convert UTF-16 back to UTF-8 for bytes output
+            let drv = String::from_utf16(&wide[..drv_size])
+                .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
+            let root = String::from_utf16(&wide[drv_size..drv_size + root_size])
+                .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
+            let tail = String::from_utf16(&wide[drv_size + root_size..])
+                .map_err(|e| vm.new_unicode_decode_error(e.to_string()))?;
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_bytes(drv.into_bytes()).into(),
+                vm.ctx.new_bytes(root.into_bytes()).into(),
+                vm.ctx.new_bytes(tail.into_bytes()).into(),
+            ]))
+        } else {
+            // For str output, use WTF-8 to handle surrogates
+            let drv = Wtf8Buf::from_wide(&wide[..drv_size]);
+            let root = Wtf8Buf::from_wide(&wide[drv_size..drv_size + root_size]);
+            let tail = Wtf8Buf::from_wide(&wide[drv_size + root_size..]);
+            Ok(vm.ctx.new_tuple(vec![
+                vm.ctx.new_str(drv).into(),
+                vm.ctx.new_str(root).into(),
+                vm.ctx.new_str(tail).into(),
+            ]))
+        }
+    }
+
+    #[pyfunction]
+    fn _path_splitroot(
+        path: OsPath,
+        _vm: &VirtualMachine,
+    ) -> (
+        rustpython_common::wtf8::Wtf8Buf,
+        rustpython_common::wtf8::Wtf8Buf,
+    ) {
+        use rustpython_common::wtf8::Wtf8Buf;
+
+        let orig: Vec<_> = path.path.to_wide();
+        if orig.is_empty() {
+            return (Wtf8Buf::new(), Wtf8Buf::new());
+        }
+        let backslashed: Vec<_> = orig
+            .iter()
+            .copied()
+            .map(|c| if c == b'/' as u16 { b'\\' as u16 } else { c })
+            .chain(std::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
+            assert!(!end.is_null());
+            let len: usize = unsafe { end.offset_from(backslashed.as_ptr()) }
+                .try_into()
+                .expect("len must be non-negative");
+            assert!(
+                len < backslashed.len(), // backslashed is null-terminated
+                "path: {:?} {} < {}",
+                std::path::PathBuf::from(std::ffi::OsString::from_wide(&backslashed)),
+                len,
+                backslashed.len()
+            );
+            (
+                Wtf8Buf::from_wide(&orig[..len]),
+                Wtf8Buf::from_wide(&orig[len..]),
+            )
+        } else {
+            (Wtf8Buf::new(), Wtf8Buf::from_wide(&orig))
+        }
+    }
+
+    #[pyfunction]
+    fn _getdiskusage(path: OsPath, vm: &VirtualMachine) -> PyResult<(u64, u64)> {
+        use FileSystem::GetDiskFreeSpaceExW;
+
+        let wpath = path.to_wide_cstring(vm)?;
+        let mut _free_to_me: u64 = 0;
+        let mut total: u64 = 0;
+        let mut free: u64 = 0;
+        let ret =
+            unsafe { GetDiskFreeSpaceExW(wpath.as_ptr(), &mut _free_to_me, &mut total, &mut free) };
+        if ret != 0 {
+            return Ok((total, free));
+        }
+        let err = io::Error::last_os_error();
+        if err.raw_os_error() == Some(Foundation::ERROR_DIRECTORY as i32)
+            && let Some(parent) = path.as_ref().parent()
+        {
+            let parent = widestring::WideCString::from_os_str(parent).unwrap();
+
+            let ret = unsafe {
+                GetDiskFreeSpaceExW(parent.as_ptr(), &mut _free_to_me, &mut total, &mut free)
+            };
+
+            return if ret == 0 {
+                Err(err.to_pyexception(vm))
+            } else {
+                Ok((total, free))
+            };
+        }
+        Err(err.to_pyexception(vm))
+    }
+
+    #[pyfunction]
+    fn get_handle_inheritable(handle: intptr_t, vm: &VirtualMachine) -> PyResult<bool> {
+        let mut flags = 0;
+        if unsafe { Foundation::GetHandleInformation(handle as _, &mut flags) } == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(flags & Foundation::HANDLE_FLAG_INHERIT != 0)
+    }
+
+    #[pyfunction]
+    fn get_inheritable(fd: i32, vm: &VirtualMachine) -> PyResult<bool> {
+        let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
+        let handle = crt_fd::as_handle(borrowed).map_err(|e| e.to_pyexception(vm))?;
+        get_handle_inheritable(handle.as_raw_handle() as _, vm)
+    }
+
+    #[pyfunction]
+    fn getlogin(vm: &VirtualMachine) -> PyResult<String> {
+        let mut buffer = [0u16; 257];
+        let mut size = buffer.len() as u32;
+
+        let success = unsafe {
+            windows_sys::Win32::System::WindowsProgramming::GetUserNameW(
+                buffer.as_mut_ptr(),
+                &mut size,
+            )
+        };
+
+        if success != 0 {
+            // Convert the buffer (which is UTF-16) to a Rust String
+            let username = std::ffi::OsString::from_wide(&buffer[..(size - 1) as usize]);
+            Ok(username.to_str().unwrap().to_string())
+        } else {
+            Err(vm.new_os_error(format!("Error code: {success}")))
+        }
+    }
+
+    pub fn raw_set_handle_inheritable(handle: intptr_t, inheritable: bool) -> std::io::Result<()> {
+        let flags = if inheritable {
+            Foundation::HANDLE_FLAG_INHERIT
+        } else {
+            0
+        };
+        let res = unsafe {
+            Foundation::SetHandleInformation(handle as _, Foundation::HANDLE_FLAG_INHERIT, flags)
+        };
+        if res == 0 {
+            Err(std::io::Error::last_os_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    #[pyfunction]
+    fn listdrives(vm: &VirtualMachine) -> PyResult<PyListRef> {
+        use windows_sys::Win32::Foundation::ERROR_MORE_DATA;
+
+        let mut buffer = [0u16; 256];
+        let len =
+            unsafe { FileSystem::GetLogicalDriveStringsW(buffer.len() as _, buffer.as_mut_ptr()) };
+        if len == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        if len as usize >= buffer.len() {
+            return Err(std::io::Error::from_raw_os_error(ERROR_MORE_DATA as _).to_pyexception(vm));
+        }
+        let drives: Vec<_> = buffer[..(len - 1) as usize]
+            .split(|&c| c == 0)
+            .map(|drive| vm.new_pyobj(String::from_utf16_lossy(drive)))
+            .collect();
+        Ok(vm.ctx.new_list(drives))
+    }
+
+    #[pyfunction]
+    fn listvolumes(vm: &VirtualMachine) -> PyResult<PyListRef> {
+        use windows_sys::Win32::Foundation::ERROR_NO_MORE_FILES;
+
+        let mut result = Vec::new();
+        let mut buffer = [0u16; Foundation::MAX_PATH as usize + 1];
+
+        let find = unsafe { FileSystem::FindFirstVolumeW(buffer.as_mut_ptr(), buffer.len() as _) };
+        if find == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+
+        loop {
+            // Find the null terminator
+            let len = buffer.iter().position(|&c| c == 0).unwrap_or(buffer.len());
+            let volume = String::from_utf16_lossy(&buffer[..len]);
+            result.push(vm.new_pyobj(volume));
+
+            let ret = unsafe {
+                FileSystem::FindNextVolumeW(find, buffer.as_mut_ptr(), buffer.len() as _)
+            };
+            if ret == 0 {
+                let err = io::Error::last_os_error();
+                unsafe { FileSystem::FindVolumeClose(find) };
+                if err.raw_os_error() == Some(ERROR_NO_MORE_FILES as i32) {
+                    break;
+                }
+                return Err(err.to_pyexception(vm));
+            }
+        }
+
+        Ok(vm.ctx.new_list(result))
+    }
+
+    #[pyfunction]
+    fn listmounts(volume: OsPath, vm: &VirtualMachine) -> PyResult<PyListRef> {
+        use windows_sys::Win32::Foundation::ERROR_MORE_DATA;
+
+        let wide = volume.to_wide_cstring(vm)?;
+        let mut buflen: u32 = Foundation::MAX_PATH + 1;
+        let mut buffer: Vec<u16> = vec![0; buflen as usize];
+
+        loop {
+            let success = unsafe {
+                FileSystem::GetVolumePathNamesForVolumeNameW(
+                    wide.as_ptr(),
+                    buffer.as_mut_ptr(),
+                    buflen,
+                    &mut buflen,
+                )
+            };
+            if success != 0 {
+                break;
+            }
+            let err = io::Error::last_os_error();
+            if err.raw_os_error() == Some(ERROR_MORE_DATA as i32) {
+                buffer.resize(buflen as usize, 0);
+                continue;
+            }
+            return Err(err.to_pyexception(vm));
+        }
+
+        // Parse null-separated strings
+        let mut result = Vec::new();
+        let mut start = 0;
+        for (i, &c) in buffer.iter().enumerate() {
+            if c == 0 {
+                if i > start {
+                    let mount = String::from_utf16_lossy(&buffer[start..i]);
+                    result.push(vm.new_pyobj(mount));
+                }
+                start = i + 1;
+                if start < buffer.len() && buffer[start] == 0 {
+                    break; // Double null = end
+                }
+            }
+        }
+
+        Ok(vm.ctx.new_list(result))
+    }
+
+    #[pyfunction]
+    fn set_handle_inheritable(
+        handle: intptr_t,
+        inheritable: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        raw_set_handle_inheritable(handle, inheritable).map_err(|e| e.to_pyexception(vm))
+    }
+
+    #[derive(FromArgs)]
+    struct MkdirArgs<'a> {
+        #[pyarg(any)]
+        path: OsPath,
+        #[pyarg(any, default = 0o777)]
+        mode: i32,
+        #[pyarg(flatten)]
+        dir_fd: DirFd<'a, { _os::MKDIR_DIR_FD as usize }>,
+    }
+
+    #[pyfunction]
+    fn mkdir(args: MkdirArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::Foundation::LocalFree;
+        use windows_sys::Win32::Security::Authorization::{
+            ConvertStringSecurityDescriptorToSecurityDescriptorW, SDDL_REVISION_1,
+        };
+        use windows_sys::Win32::Security::SECURITY_ATTRIBUTES;
+
+        let [] = args.dir_fd.0;
+        let wide = args.path.to_wide_cstring(vm)?;
+
+        // 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(),
+                bInheritHandle: 0,
+            };
+            // Set a discretionary ACL (D) that is protected (P) and includes
+            // inheritable (OICI) entries that allow (A) full control (FA) to
+            // SYSTEM (SY), Administrators (BA), and the owner (OW).
+            let sddl: Vec<u16> = "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;FA;;;OW)\0"
+                .encode_utf16()
+                .collect();
+            let convert_result = unsafe {
+                ConvertStringSecurityDescriptorToSecurityDescriptorW(
+                    sddl.as_ptr(),
+                    SDDL_REVISION_1,
+                    &mut sec_attr.lpSecurityDescriptor,
+                    std::ptr::null_mut(),
+                )
+            };
+            if convert_result == 0 {
+                return Err(vm.new_last_os_error());
+            }
+            let res =
+                unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), &sec_attr as *const _ as _) };
+            unsafe { LocalFree(sec_attr.lpSecurityDescriptor) };
+            res
+        } else {
+            unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), std::ptr::null_mut()) }
+        };
+
+        if res == 0 {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(())
+    }
+
+    unsafe extern "C" {
+        fn _umask(mask: i32) -> i32;
+    }
+
+    /// Close fd and convert error to PyException (PEP 446 cleanup)
+    #[cold]
+    fn close_fd_and_raise(fd: i32, err: std::io::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        let _ = unsafe { crt_fd::Owned::from_raw(fd) };
+        err.to_pyexception(vm)
+    }
+
+    #[pyfunction]
+    fn umask(mask: i32, vm: &VirtualMachine) -> PyResult<i32> {
+        let result = unsafe { _umask(mask) };
+        if result < 0 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(result)
+        }
+    }
+
+    #[pyfunction]
+    fn pipe(vm: &VirtualMachine) -> PyResult<(i32, i32)> {
+        use windows_sys::Win32::System::Pipes::CreatePipe;
+
+        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(),
+                0,
+            );
+            if res == 0 {
+                return Err(vm.new_last_os_error());
+            }
+            (read.assume_init(), write.assume_init())
+        };
+
+        // Convert handles to file descriptors
+        // O_NOINHERIT = 0x80 (MSVC CRT)
+        const O_NOINHERIT: i32 = 0x80;
+        let read_fd = unsafe { libc::open_osfhandle(read_handle, O_NOINHERIT) };
+        let write_fd = unsafe { libc::open_osfhandle(write_handle, libc::O_WRONLY | O_NOINHERIT) };
+
+        if read_fd == -1 || write_fd == -1 {
+            unsafe {
+                Foundation::CloseHandle(read_handle as _);
+                Foundation::CloseHandle(write_handle as _);
+            }
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok((read_fd, write_fd))
+    }
+
+    #[pyfunction]
+    fn getppid() -> u32 {
+        use windows_sys::Win32::System::Threading::{GetCurrentProcess, PROCESS_BASIC_INFORMATION};
+
+        type NtQueryInformationProcessFn = unsafe extern "system" fn(
+            process_handle: isize,
+            process_information_class: u32,
+            process_information: *mut std::ffi::c_void,
+            process_information_length: u32,
+            return_length: *mut u32,
+        ) -> i32;
+
+        let ntdll = unsafe {
+            windows_sys::Win32::System::LibraryLoader::GetModuleHandleW(windows_sys::w!(
+                "ntdll.dll"
+            ))
+        };
+        if ntdll.is_null() {
+            return 0;
+        }
+
+        let func = unsafe {
+            windows_sys::Win32::System::LibraryLoader::GetProcAddress(
+                ntdll,
+                c"NtQueryInformationProcess".as_ptr() as *const u8,
+            )
+        };
+        let Some(func) = func else {
+            return 0;
+        };
+        let nt_query: NtQueryInformationProcessFn = unsafe { core::mem::transmute(func) };
+
+        let mut info: PROCESS_BASIC_INFORMATION = unsafe { std::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(),
+            )
+        };
+
+        if status >= 0
+            && info.InheritedFromUniqueProcessId != 0
+            && info.InheritedFromUniqueProcessId < u32::MAX as usize
+        {
+            info.InheritedFromUniqueProcessId as u32
+        } else {
+            0
+        }
+    }
+
+    #[pyfunction]
+    fn dup(fd: i32, vm: &VirtualMachine) -> PyResult<i32> {
+        let fd2 = unsafe { suppress_iph!(libc::dup(fd)) };
+        if fd2 < 0 {
+            return Err(vm.new_last_errno_error());
+        }
+        let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(fd2) };
+        let handle = crt_fd::as_handle(borrowed).map_err(|e| close_fd_and_raise(fd2, e, vm))?;
+        raw_set_handle_inheritable(handle.as_raw_handle() as _, false)
+            .map_err(|e| close_fd_and_raise(fd2, e, vm))?;
+        Ok(fd2)
+    }
+
+    #[derive(FromArgs)]
+    struct Dup2Args {
+        #[pyarg(positional)]
+        fd: i32,
+        #[pyarg(positional)]
+        fd2: i32,
+        #[pyarg(any, default = true)]
+        inheritable: bool,
+    }
+
+    #[pyfunction]
+    fn dup2(args: Dup2Args, vm: &VirtualMachine) -> PyResult<i32> {
+        let result = unsafe { suppress_iph!(libc::dup2(args.fd, args.fd2)) };
+        if result < 0 {
+            return Err(vm.new_last_errno_error());
+        }
+        if !args.inheritable {
+            let borrowed = unsafe { crt_fd::Borrowed::borrow_raw(args.fd2) };
+            let handle =
+                crt_fd::as_handle(borrowed).map_err(|e| close_fd_and_raise(args.fd2, e, vm))?;
+            raw_set_handle_inheritable(handle.as_raw_handle() as _, false)
+                .map_err(|e| close_fd_and_raise(args.fd2, e, vm))?;
+        }
+        Ok(args.fd2)
+    }
+
+    /// Windows-specific readlink that preserves \\?\ prefix for junctions
+    /// returns the substitute name from reparse data which includes the prefix
+    #[pyfunction]
+    fn readlink(path: OsPath, vm: &VirtualMachine) -> PyResult {
+        use crate::common::windows::ToWideString;
+        use windows_sys::Win32::Foundation::CloseHandle;
+        use windows_sys::Win32::Storage::FileSystem::{
+            CreateFileW, FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT,
+            FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
+        };
+        use windows_sys::Win32::System::IO::DeviceIoControl;
+        use windows_sys::Win32::System::Ioctl::FSCTL_GET_REPARSE_POINT;
+
+        let mode = path.mode();
+        let wide_path = path.as_ref().to_wide_with_nul();
+
+        // Open the file/directory with reparse point flag
+        let handle = unsafe {
+            CreateFileW(
+                wide_path.as_ptr(),
+                0, // No access needed, just reading reparse data
+                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                core::ptr::null(),
+                OPEN_EXISTING,
+                FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+                std::ptr::null_mut(),
+            )
+        };
+
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path.clone(),
+                vm,
+            ));
+        }
+
+        // Buffer for reparse data - MAXIMUM_REPARSE_DATA_BUFFER_SIZE is 16384
+        const BUFFER_SIZE: usize = 16384;
+        let mut buffer = vec![0u8; BUFFER_SIZE];
+        let mut bytes_returned: u32 = 0;
+
+        let result = unsafe {
+            DeviceIoControl(
+                handle,
+                FSCTL_GET_REPARSE_POINT,
+                core::ptr::null(),
+                0,
+                buffer.as_mut_ptr() as *mut _,
+                BUFFER_SIZE as u32,
+                &mut bytes_returned,
+                std::ptr::null_mut(),
+            )
+        };
+
+        unsafe { CloseHandle(handle) };
+
+        if result == 0 {
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path.clone(),
+                vm,
+            ));
+        }
+
+        // Parse the reparse data buffer
+        // REPARSE_DATA_BUFFER structure:
+        // DWORD ReparseTag
+        // WORD ReparseDataLength
+        // WORD Reserved
+        // For symlinks/junctions (IO_REPARSE_TAG_SYMLINK/MOUNT_POINT):
+        // WORD SubstituteNameOffset
+        // WORD SubstituteNameLength
+        // WORD PrintNameOffset
+        // WORD PrintNameLength
+        // (For symlinks only: DWORD Flags)
+        // PathBuffer...
+
+        let reparse_tag = u32::from_le_bytes([buffer[0], buffer[1], buffer[2], buffer[3]]);
+
+        // Check if it's a symlink or mount point (junction)
+        use windows_sys::Win32::System::SystemServices::{
+            IO_REPARSE_TAG_MOUNT_POINT, IO_REPARSE_TAG_SYMLINK,
+        };
+
+        let (substitute_offset, substitute_length, path_buffer_start) =
+            if reparse_tag == IO_REPARSE_TAG_SYMLINK {
+                // Symlink has Flags field (4 bytes) before PathBuffer
+                let sub_offset = u16::from_le_bytes([buffer[8], buffer[9]]) as usize;
+                let sub_length = u16::from_le_bytes([buffer[10], buffer[11]]) as usize;
+                // PathBuffer starts at offset 20 (after Flags at offset 16)
+                (sub_offset, sub_length, 20usize)
+            } else if reparse_tag == IO_REPARSE_TAG_MOUNT_POINT {
+                // Mount point (junction) has no Flags field
+                let sub_offset = u16::from_le_bytes([buffer[8], buffer[9]]) as usize;
+                let sub_length = u16::from_le_bytes([buffer[10], buffer[11]]) as usize;
+                // 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));
+            };
+
+        // Extract the substitute name
+        let path_start = path_buffer_start + substitute_offset;
+        let path_end = path_start + substitute_length;
+
+        if path_end > buffer.len() {
+            return Err(vm.new_os_error("Invalid reparse data".to_owned()));
+        }
+
+        // Convert from UTF-16LE
+        let path_slice = &buffer[path_start..path_end];
+        let wide_chars: Vec<u16> = path_slice
+            .chunks_exact(2)
+            .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+            .collect();
+
+        let mut result_path = std::ffi::OsString::from_wide(&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);
+        }
+
+        Ok(mode.process_path(std::path::PathBuf::from(result_path), vm))
+    }
+
+    pub(crate) fn support_funcs() -> Vec<SupportFunc> {
+        Vec::new()
+    }
+}
diff --git a/crates/vm/src/stdlib/operator.rs b/crates/vm/src/stdlib/operator.rs
new file mode 100644
index 0000000000..7877ddb011
--- /dev/null
+++ b/crates/vm/src/stdlib/operator.rs
@@ -0,0 +1,602 @@
+pub(crate) use _operator::make_module;
+
+#[pymodule]
+mod _operator {
+    use crate::{
+        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyInt, PyIntRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
+        common::wtf8::Wtf8,
+        function::{ArgBytesLike, Either, FuncArgs, KwArgs, OptionalArg},
+        protocol::PyIter,
+        recursion::ReprGuard,
+        types::{Callable, Constructor, PyComparisonOp, Representable},
+    };
+    use constant_time_eq::constant_time_eq;
+
+    #[pyfunction]
+    fn lt(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Lt, vm)
+    }
+
+    #[pyfunction]
+    fn le(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Le, vm)
+    }
+
+    #[pyfunction]
+    fn gt(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Gt, vm)
+    }
+
+    #[pyfunction]
+    fn ge(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Ge, vm)
+    }
+
+    #[pyfunction]
+    fn eq(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Eq, vm)
+    }
+
+    #[pyfunction]
+    fn ne(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.rich_compare(b, PyComparisonOp::Ne, vm)
+    }
+
+    #[pyfunction]
+    fn not_(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        a.try_to_bool(vm).map(|r| !r)
+    }
+
+    #[pyfunction]
+    fn truth(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        a.try_to_bool(vm)
+    }
+
+    #[pyfunction]
+    fn is_(a: PyObjectRef, b: PyObjectRef) -> PyResult<bool> {
+        Ok(a.is(&b))
+    }
+
+    #[pyfunction]
+    fn is_not(a: PyObjectRef, b: PyObjectRef) -> PyResult<bool> {
+        Ok(!a.is(&b))
+    }
+
+    #[pyfunction]
+    fn abs(a: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._abs(&a)
+    }
+
+    #[pyfunction]
+    fn add(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._add(&a, &b)
+    }
+
+    #[pyfunction]
+    fn and_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._and(&a, &b)
+    }
+
+    #[pyfunction]
+    fn floordiv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._floordiv(&a, &b)
+    }
+
+    // Note: Keep track of issue17567. Will need changes in order to strictly match behavior of
+    // a.__index__ as raised in the issue. Currently, we accept int subclasses.
+    #[pyfunction]
+    fn index(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIntRef> {
+        a.try_index(vm)
+    }
+
+    #[pyfunction]
+    fn invert(pos: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._invert(&pos)
+    }
+
+    #[pyfunction]
+    fn lshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._lshift(&a, &b)
+    }
+
+    #[pyfunction(name = "mod")]
+    fn mod_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._mod(&a, &b)
+    }
+
+    #[pyfunction]
+    fn mul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._mul(&a, &b)
+    }
+
+    #[pyfunction]
+    fn matmul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._matmul(&a, &b)
+    }
+
+    #[pyfunction]
+    fn neg(pos: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._neg(&pos)
+    }
+
+    #[pyfunction]
+    fn or_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._or(&a, &b)
+    }
+
+    #[pyfunction]
+    fn pos(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._pos(&obj)
+    }
+
+    #[pyfunction]
+    fn pow(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._pow(&a, &b, vm.ctx.none.as_object())
+    }
+
+    #[pyfunction]
+    fn rshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._rshift(&a, &b)
+    }
+
+    #[pyfunction]
+    fn sub(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._sub(&a, &b)
+    }
+
+    #[pyfunction]
+    fn truediv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._truediv(&a, &b)
+    }
+
+    #[pyfunction]
+    fn xor(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._xor(&a, &b)
+    }
+
+    // Sequence based operators
+
+    #[pyfunction]
+    fn concat(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Best attempt at checking that a is sequence-like.
+        if !a.class().has_attr(identifier!(vm, __getitem__))
+            || a.fast_isinstance(vm.ctx.types.dict_type)
+        {
+            return Err(
+                vm.new_type_error(format!("{} object can't be concatenated", a.class().name()))
+            );
+        }
+        vm._add(&a, &b)
+    }
+
+    #[pyfunction]
+    fn contains(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+        vm._contains(&a, &b)
+    }
+
+    #[pyfunction(name = "countOf")]
+    fn count_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        let mut count: usize = 0;
+        for element in a.iter_without_hint::<PyObjectRef>(vm)? {
+            let element = element?;
+            if element.is(&b) || vm.bool_eq(&b, &element)? {
+                count += 1;
+            }
+        }
+        Ok(count)
+    }
+
+    #[pyfunction]
+    fn delitem(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        a.del_item(&*b, vm)
+    }
+
+    #[pyfunction]
+    fn getitem(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        a.get_item(&*b, vm)
+    }
+
+    #[pyfunction(name = "indexOf")]
+    fn index_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
+        for (index, element) in a.iter_without_hint::<PyObjectRef>(vm)?.enumerate() {
+            let element = element?;
+            if element.is(&b) || vm.bool_eq(&b, &element)? {
+                return Ok(index);
+            }
+        }
+        Err(vm.new_value_error("sequence.index(x): x not in sequence"))
+    }
+
+    #[pyfunction]
+    fn setitem(
+        a: PyObjectRef,
+        b: PyObjectRef,
+        c: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        a.set_item(&*b, c, vm)
+    }
+
+    #[pyfunction]
+    fn length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMachine) -> PyResult<usize> {
+        let default: usize = default
+            .map(|v| {
+                if !v.fast_isinstance(vm.ctx.types.int_type) {
+                    return Err(vm.new_type_error(format!(
+                        "'{}' object cannot be interpreted as an integer",
+                        v.class().name()
+                    )));
+                }
+                v.downcast_ref::<PyInt>().unwrap().try_to_primitive(vm)
+            })
+            .unwrap_or(Ok(0))?;
+        obj.length_hint(default, vm)
+    }
+
+    // Inplace Operators
+
+    #[pyfunction]
+    fn iadd(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._iadd(&a, &b)
+    }
+
+    #[pyfunction]
+    fn iand(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._iand(&a, &b)
+    }
+
+    #[pyfunction]
+    fn iconcat(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        // Best attempt at checking that a is sequence-like.
+        if !a.class().has_attr(identifier!(vm, __getitem__))
+            || a.fast_isinstance(vm.ctx.types.dict_type)
+        {
+            return Err(vm.new_type_error(format!(
+                "'{}' object can't be concatenated",
+                a.class().name()
+            )));
+        }
+        vm._iadd(&a, &b)
+    }
+
+    #[pyfunction]
+    fn ifloordiv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._ifloordiv(&a, &b)
+    }
+
+    #[pyfunction]
+    fn ilshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._ilshift(&a, &b)
+    }
+
+    #[pyfunction]
+    fn imod(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._imod(&a, &b)
+    }
+
+    #[pyfunction]
+    fn imul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._imul(&a, &b)
+    }
+
+    #[pyfunction]
+    fn imatmul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._imatmul(&a, &b)
+    }
+
+    #[pyfunction]
+    fn ior(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._ior(&a, &b)
+    }
+
+    #[pyfunction]
+    fn ipow(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._ipow(&a, &b, vm.ctx.none.as_object())
+    }
+
+    #[pyfunction]
+    fn irshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._irshift(&a, &b)
+    }
+
+    #[pyfunction]
+    fn isub(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._isub(&a, &b)
+    }
+
+    #[pyfunction]
+    fn itruediv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._itruediv(&a, &b)
+    }
+
+    #[pyfunction]
+    fn ixor(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        vm._ixor(&a, &b)
+    }
+
+    #[pyfunction]
+    fn _compare_digest(
+        a: Either<PyStrRef, ArgBytesLike>,
+        b: Either<PyStrRef, ArgBytesLike>,
+        vm: &VirtualMachine,
+    ) -> PyResult<bool> {
+        let res = match (a, b) {
+            (Either::A(a), Either::A(b)) => {
+                if !a.isascii() || !b.isascii() {
+                    return Err(vm.new_type_error(
+                        "comparing strings with non-ASCII characters is not supported",
+                    ));
+                }
+                constant_time_eq(a.as_bytes(), b.as_bytes())
+            }
+            (Either::B(a), Either::B(b)) => a.with_ref(|a| b.with_ref(|b| constant_time_eq(a, b))),
+            _ => {
+                return Err(
+                    vm.new_type_error("unsupported operand types(s) or combination of types")
+                );
+            }
+        };
+        Ok(res)
+    }
+
+    /// attrgetter(attr, ...) --> attrgetter object
+    ///
+    /// Return a callable object that fetches the given attribute(s) from its operand.
+    /// After f = attrgetter('name'), the call f(r) returns r.name.
+    /// After g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).
+    /// After h = attrgetter('name.first', 'name.last'), the call h(r) returns
+    /// (r.name.first, r.name.last).
+    #[pyattr]
+    #[pyclass(name = "attrgetter")]
+    #[derive(Debug, PyPayload)]
+    struct PyAttrGetter {
+        attrs: Vec<PyStrRef>,
+    }
+
+    #[pyclass(with(Callable, Constructor, Representable))]
+    impl PyAttrGetter {
+        #[pymethod]
+        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<(PyTypeRef, PyTupleRef)> {
+            let attrs = vm
+                .ctx
+                .new_tuple(zelf.attrs.iter().map(|v| v.clone().into()).collect());
+            Ok((zelf.class().to_owned(), attrs))
+        }
+
+        // Go through dotted parts of string and call getattr on whatever is returned.
+        fn get_single_attr(
+            obj: PyObjectRef,
+            attr: &Py<PyStr>,
+            vm: &VirtualMachine,
+        ) -> PyResult<PyObjectRef> {
+            let attr_str = attr.as_bytes();
+            let parts = attr_str.split(|&b| b == b'.').collect::<Vec<_>>();
+            if parts.len() == 1 {
+                return obj.get_attr(attr, vm);
+            }
+            let mut obj = obj;
+            for part in parts {
+                let part = Wtf8::from_bytes(part).expect("originally valid WTF-8");
+                obj = obj.get_attr(&vm.ctx.new_str(part), vm)?;
+            }
+            Ok(obj)
+        }
+    }
+
+    impl Constructor for PyAttrGetter {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            let n_attr = args.args.len();
+            // Check we get no keyword and at least one positional.
+            if !args.kwargs.is_empty() {
+                return Err(vm.new_type_error("attrgetter() takes no keyword arguments"));
+            }
+            if n_attr == 0 {
+                return Err(vm.new_type_error("attrgetter expected 1 argument, got 0."));
+            }
+            let mut attrs = Vec::with_capacity(n_attr);
+            for o in args.args {
+                if let Ok(r) = o.try_into_value(vm) {
+                    attrs.push(r);
+                } else {
+                    return Err(vm.new_type_error("attribute name must be a string"));
+                }
+            }
+            Ok(Self { attrs })
+        }
+    }
+
+    impl Callable for PyAttrGetter {
+        type Args = PyObjectRef;
+        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
+            // Handle case where we only have one attribute.
+            if zelf.attrs.len() == 1 {
+                return Self::get_single_attr(obj, &zelf.attrs[0], vm);
+            }
+            // Build tuple and call get_single on each element in attrs.
+            let mut results = Vec::with_capacity(zelf.attrs.len());
+            for o in &zelf.attrs {
+                results.push(Self::get_single_attr(obj.clone(), o, vm)?);
+            }
+            Ok(vm.ctx.new_tuple(results).into())
+        }
+    }
+
+    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());
+                for part in &zelf.attrs {
+                    parts.push(part.as_object().repr(vm)?.as_str().to_owned());
+                }
+                parts.join(", ")
+            } else {
+                "...".to_owned()
+            };
+            Ok(format!("operator.attrgetter({fmt})"))
+        }
+    }
+
+    /// itemgetter(item, ...) --> itemgetter object
+    ///
+    /// Return a callable object that fetches the given item(s) from its operand.
+    /// After f = itemgetter(2), the call f(r) returns r[2].
+    /// After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
+    #[pyattr]
+    #[pyclass(name = "itemgetter")]
+    #[derive(Debug, PyPayload)]
+    struct PyItemGetter {
+        items: Vec<PyObjectRef>,
+    }
+
+    #[pyclass(with(Callable, Constructor, Representable))]
+    impl PyItemGetter {
+        #[pymethod]
+        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
+            let items = vm.ctx.new_tuple(zelf.items.to_vec());
+            vm.new_pyobj((zelf.class().to_owned(), items))
+        }
+    }
+    impl Constructor for PyItemGetter {
+        type Args = FuncArgs;
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            // Check we get no keyword and at least one positional.
+            if !args.kwargs.is_empty() {
+                return Err(vm.new_type_error("itemgetter() takes no keyword arguments"));
+            }
+            if args.args.is_empty() {
+                return Err(vm.new_type_error("itemgetter expected 1 argument, got 0."));
+            }
+            Ok(Self { items: args.args })
+        }
+    }
+
+    impl Callable for PyItemGetter {
+        type Args = PyObjectRef;
+        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
+            // Handle case where we only have one attribute.
+            if zelf.items.len() == 1 {
+                return obj.get_item(&*zelf.items[0], vm);
+            }
+            // Build tuple and call get_single on each element in attrs.
+            let mut results = Vec::with_capacity(zelf.items.len());
+            for item in &zelf.items {
+                results.push(obj.get_item(&**item, vm)?);
+            }
+            Ok(vm.ctx.new_tuple(results).into())
+        }
+    }
+
+    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());
+                for item in &zelf.items {
+                    items.push(item.repr(vm)?.as_str().to_owned());
+                }
+                items.join(", ")
+            } else {
+                "...".to_owned()
+            };
+            Ok(format!("operator.itemgetter({fmt})"))
+        }
+    }
+
+    /// methodcaller(name, ...) --> methodcaller object
+    ///
+    /// Return a callable object that calls the given method on its operand.
+    /// After f = methodcaller('name'), the call f(r) returns r.name().
+    /// After g = methodcaller('name', 'date', foo=1), the call g(r) returns
+    /// r.name('date', foo=1).
+    #[pyattr]
+    #[pyclass(name = "methodcaller")]
+    #[derive(Debug, PyPayload)]
+    struct PyMethodCaller {
+        name: PyStrRef,
+        args: FuncArgs,
+    }
+
+    #[pyclass(with(Callable, Constructor, Representable))]
+    impl PyMethodCaller {
+        #[pymethod]
+        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
+            // With no kwargs, return (type(obj), (name, *args)) tuple.
+            if zelf.args.kwargs.is_empty() {
+                let mut py_args = vec![zelf.name.as_object().to_owned()];
+                py_args.append(&mut zelf.args.args.clone());
+                Ok(vm.new_tuple((zelf.class().to_owned(), vm.ctx.new_tuple(py_args))))
+            } else {
+                // If we have kwargs, create a partial function that contains them and pass back that
+                // along with the args.
+                let partial = vm.import("functools", 0)?.get_attr("partial", vm)?;
+                let args = FuncArgs::new(
+                    vec![zelf.class().to_owned().into(), zelf.name.clone().into()],
+                    KwArgs::new(zelf.args.kwargs.clone()),
+                );
+                let callable = partial.call(args, vm)?;
+                Ok(vm.new_tuple((callable, vm.ctx.new_tuple(zelf.args.args.clone()))))
+            }
+        }
+    }
+
+    impl Constructor for PyMethodCaller {
+        type Args = (PyObjectRef, FuncArgs);
+
+        fn py_new(
+            _cls: &Py<PyType>,
+            (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"))
+            }
+        }
+    }
+
+    impl Callable for PyMethodCaller {
+        type Args = PyObjectRef;
+
+        #[inline]
+        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
+            vm.call_method(&obj, zelf.name.as_str(), zelf.args.clone())
+        }
+    }
+
+    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()) {
+                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(", "));
+                }
+                // 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(", "));
+                }
+                fmt.join(", ")
+            } else {
+                "...".to_owned()
+            };
+            Ok(format!("operator.methodcaller({fmt})"))
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
new file mode 100644
index 0000000000..00f2aea1db
--- /dev/null
+++ b/crates/vm/src/stdlib/os.rs
@@ -0,0 +1,1932 @@
+// spell-checker:disable
+
+use crate::{
+    AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
+    builtins::{PyModule, PySet},
+    common::crt_fd,
+    convert::{IntoPyException, ToPyException, ToPyObject},
+    function::{ArgumentError, FromArgs, FuncArgs},
+};
+use std::{fs, io, path::Path};
+
+pub(crate) fn fs_metadata<P: AsRef<Path>>(
+    path: P,
+    follow_symlink: bool,
+) -> io::Result<fs::Metadata> {
+    if follow_symlink {
+        fs::metadata(path.as_ref())
+    } else {
+        fs::symlink_metadata(path.as_ref())
+    }
+}
+
+#[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 {
+    #[pyarg(any, default = false)]
+    pub(crate) target_is_directory: bool,
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(all(any(unix, target_os = "wasi"), not(target_os = "redox")))] {
+        use libc::AT_FDCWD;
+    } else {
+        const AT_FDCWD: i32 = -100;
+    }
+}
+const DEFAULT_DIR_FD: crt_fd::Borrowed<'static> = unsafe { crt_fd::Borrowed::borrow_raw(AT_FDCWD) };
+
+// XXX: AVAILABLE should be a bool, but we can't yet have it as a bool and just cast it to usize
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct DirFd<'fd, const AVAILABLE: usize>(pub(crate) [crt_fd::Borrowed<'fd>; AVAILABLE]);
+
+impl<const AVAILABLE: usize> Default for DirFd<'_, AVAILABLE> {
+    fn default() -> Self {
+        Self([DEFAULT_DIR_FD; AVAILABLE])
+    }
+}
+
+// not used on all platforms
+#[allow(unused)]
+impl<'fd> DirFd<'fd, 1> {
+    #[inline(always)]
+    pub(crate) fn get_opt(self) -> Option<crt_fd::Borrowed<'fd>> {
+        let [fd] = self.0;
+        (fd != DEFAULT_DIR_FD).then_some(fd)
+    }
+
+    #[inline]
+    pub(crate) fn raw_opt(self) -> Option<i32> {
+        self.get_opt().map(|fd| fd.as_raw())
+    }
+
+    #[inline(always)]
+    pub(crate) const fn get(self) -> crt_fd::Borrowed<'fd> {
+        let [fd] = self.0;
+        fd
+    }
+}
+
+impl<const AVAILABLE: usize> FromArgs for DirFd<'_, AVAILABLE> {
+    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
+        let fd = match args.take_keyword("dir_fd") {
+            Some(o) if vm.is_none(&o) => Ok(DEFAULT_DIR_FD),
+            None => Ok(DEFAULT_DIR_FD),
+            Some(o) => {
+                let fd = o.try_index_opt(vm).unwrap_or_else(|| {
+                    Err(vm.new_type_error(format!(
+                        "argument should be integer or None, not {}",
+                        o.class().name()
+                    )))
+                })?;
+                let fd = fd.try_to_primitive(vm)?;
+                unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
+            }
+        };
+        if AVAILABLE == 0 && fd.as_ref().is_ok_and(|&fd| fd != DEFAULT_DIR_FD) {
+            return Err(vm
+                .new_not_implemented_error("dir_fd unavailable on this platform")
+                .into());
+        }
+        let fd = fd.map_err(|e| e.to_pyexception(vm))?;
+        Ok(Self([fd; AVAILABLE]))
+    }
+}
+
+#[derive(FromArgs)]
+pub(super) struct FollowSymlinks(
+    #[pyarg(named, name = "follow_symlinks", default = true)] pub bool,
+);
+
+#[cfg(not(windows))]
+fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> {
+    rustpython_common::os::bytes_as_os_str(b)
+        .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8"))
+}
+
+impl TryFromObject for crt_fd::Owned {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        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))
+    }
+}
+
+impl TryFromObject for crt_fd::Borrowed<'_> {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        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))
+    }
+}
+
+impl ToPyObject for crt_fd::Owned {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        self.into_raw().to_pyobject(vm)
+    }
+}
+
+impl ToPyObject for crt_fd::Borrowed<'_> {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        self.as_raw().to_pyobject(vm)
+    }
+}
+
+#[pymodule(sub)]
+pub(super) mod _os {
+    use super::{DirFd, FollowSymlinks, SupportFunc};
+    #[cfg(windows)]
+    use crate::common::windows::ToWideString;
+    use crate::{
+        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
+        builtins::{
+            PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
+            ToOSErrorBuilder,
+        },
+        common::{
+            crt_fd,
+            fileutils::StatStruct,
+            lock::{OnceCell, PyRwLock},
+            suppress_iph,
+        },
+        convert::{IntoPyException, ToPyObject},
+        exceptions::OSErrorBuilder,
+        function::{ArgBytesLike, FsPath, FuncArgs, OptionalArg},
+        ospath::{OsPath, OsPathOrFd, OutputMode, PathConverter},
+        protocol::PyIterReturn,
+        recursion::ReprGuard,
+        types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter},
+        utils::ToCString,
+        vm::VirtualMachine,
+    };
+    use core::time::Duration;
+    use crossbeam_utils::atomic::AtomicCell;
+    use itertools::Itertools;
+    use std::{env, fs, fs::OpenOptions, io, path::PathBuf, time::SystemTime};
+
+    const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
+    pub(crate) const MKDIR_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
+    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")));
+
+    #[pyattr]
+    use libc::{
+        O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END,
+        SEEK_SET,
+    };
+
+    #[pyattr]
+    pub(crate) const F_OK: u8 = 0;
+    #[pyattr]
+    pub(crate) const R_OK: u8 = 1 << 2;
+    #[pyattr]
+    pub(crate) const W_OK: u8 = 1 << 1;
+    #[pyattr]
+    pub(crate) const X_OK: u8 = 1 << 0;
+
+    // ST_RDONLY and ST_NOSUID flags for statvfs
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    const ST_RDONLY: libc::c_ulong = libc::ST_RDONLY;
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    const ST_NOSUID: libc::c_ulong = libc::ST_NOSUID;
+
+    #[pyfunction]
+    fn close(fileno: crt_fd::Owned) -> io::Result<()> {
+        crt_fd::close(fileno)
+    }
+
+    #[pyfunction]
+    fn closerange(fd_low: i32, fd_high: i32) {
+        for fileno in fd_low..fd_high {
+            if let Ok(fd) = unsafe { crt_fd::Owned::try_from_raw(fileno) } {
+                drop(fd);
+            }
+        }
+    }
+
+    #[cfg(any(unix, windows, target_os = "wasi"))]
+    #[derive(FromArgs)]
+    struct OpenArgs<'fd> {
+        path: OsPath,
+        flags: i32,
+        #[pyarg(any, default)]
+        mode: Option<i32>,
+        #[pyarg(flatten)]
+        dir_fd: DirFd<'fd, { OPEN_DIR_FD as usize }>,
+    }
+
+    #[pyfunction]
+    fn open(args: OpenArgs<'_>, vm: &VirtualMachine) -> PyResult<crt_fd::Owned> {
+        os_open(args.path, args.flags, args.mode, args.dir_fd, vm)
+    }
+
+    #[cfg(any(unix, windows, target_os = "wasi"))]
+    pub(crate) fn os_open(
+        name: OsPath,
+        flags: i32,
+        mode: Option<i32>,
+        dir_fd: DirFd<'_, { OPEN_DIR_FD as usize }>,
+        vm: &VirtualMachine,
+    ) -> PyResult<crt_fd::Owned> {
+        let mode = mode.unwrap_or(0o777);
+        #[cfg(windows)]
+        let fd = {
+            let [] = dir_fd.0;
+            let name = name.to_wide_cstring(vm)?;
+            let flags = flags | libc::O_NOINHERIT;
+            crt_fd::wopen(&name, flags, mode)
+        };
+        #[cfg(not(windows))]
+        let fd = {
+            let name = name.clone().into_cstring(vm)?;
+            #[cfg(not(target_os = "wasi"))]
+            let flags = flags | libc::O_CLOEXEC;
+            #[cfg(not(target_os = "redox"))]
+            if let Some(dir_fd) = dir_fd.get_opt() {
+                crt_fd::openat(dir_fd, &name, flags, mode)
+            } else {
+                crt_fd::open(&name, flags, mode)
+            }
+            #[cfg(target_os = "redox")]
+            {
+                let [] = dir_fd.0;
+                crt_fd::open(&name, flags, mode)
+            }
+        };
+        fd.map_err(|err| OSErrorBuilder::with_filename(&err, name, vm))
+    }
+
+    #[pyfunction]
+    fn fsync(fd: crt_fd::Borrowed<'_>) -> io::Result<()> {
+        crt_fd::fsync(fd)
+    }
+
+    #[pyfunction]
+    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) {
+                Ok(n) => {
+                    buffer.truncate(n);
+                    return Ok(vm.ctx.new_bytes(buffer));
+                }
+                Err(e) if e.raw_os_error() == Some(libc::EINTR) => {
+                    vm.check_signals()?;
+                    continue;
+                }
+                Err(e) => return Err(e.into_pyexception(vm)),
+            }
+        }
+    }
+
+    #[pyfunction]
+    fn write(fd: crt_fd::Borrowed<'_>, data: ArgBytesLike) -> io::Result<usize> {
+        data.with_ref(|b| crt_fd::write(fd, b))
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn mkdir(
+        path: OsPath,
+        mode: OptionalArg<i32>,
+        dir_fd: DirFd<'_, { MKDIR_DIR_FD as usize }>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let mode = mode.unwrap_or(0o777);
+        let c_path = path.clone().into_cstring(vm)?;
+        #[cfg(not(target_os = "redox"))]
+        if let Some(fd) = dir_fd.raw_opt() {
+            let res = unsafe { libc::mkdirat(fd, c_path.as_ptr(), mode as _) };
+            return if res < 0 {
+                let err = crate::common::os::errno_io_error();
+                Err(OSErrorBuilder::with_filename(&err, path, vm))
+            } else {
+                Ok(())
+            };
+        }
+        #[cfg(target_os = "redox")]
+        let [] = dir_fd.0;
+        let res = unsafe { libc::mkdir(c_path.as_ptr(), mode as _) };
+        if res < 0 {
+            let err = crate::common::os::errno_io_error();
+            return Err(OSErrorBuilder::with_filename(&err, path, vm));
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn mkdirs(path: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        fs::create_dir_all(path.as_str()).map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[pyfunction]
+    fn rmdir(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+        let [] = dir_fd.0;
+        fs::remove_dir(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
+    }
+
+    const LISTDIR_FD: bool = cfg!(all(unix, not(target_os = "redox")));
+
+    #[pyfunction]
+    fn listdir(
+        path: OptionalArg<Option<OsPathOrFd<'_>>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<Vec<PyObjectRef>> {
+        let path = path
+            .flatten()
+            .unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));
+        let list = match path {
+            OsPathOrFd::Path(path) => {
+                let dir_iter = match fs::read_dir(&path) {
+                    Ok(iter) => iter,
+                    Err(err) => {
+                        return Err(OSErrorBuilder::with_filename(&err, path, vm));
+                    }
+                };
+                let mode = path.mode();
+                dir_iter
+                    .map(|entry| match entry {
+                        Ok(entry_path) => Ok(mode.process_path(entry_path.file_name(), vm)),
+                        Err(err) => Err(OSErrorBuilder::with_filename(&err, path.clone(), vm)),
+                    })
+                    .collect::<PyResult<_>>()?
+            }
+            OsPathOrFd::Fd(fno) => {
+                #[cfg(not(all(unix, not(target_os = "redox"))))]
+                {
+                    let _ = fno;
+                    return Err(
+                        vm.new_not_implemented_error("can't pass fd to listdir on this platform")
+                    );
+                }
+                #[cfg(all(unix, not(target_os = "redox")))]
+                {
+                    use rustpython_common::os::ffi::OsStrExt;
+                    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),
+                                ),
+                            }
+                        })
+                        .collect::<Result<_, _>>()
+                        .map_err(|e| e.into_pyexception(vm))?
+                }
+            }
+        };
+        Ok(list)
+    }
+
+    #[cfg(not(windows))]
+    fn env_bytes_as_bytes(obj: &crate::function::Either<PyStrRef, PyBytesRef>) -> &[u8] {
+        match obj {
+            crate::function::Either::A(s) => s.as_bytes(),
+            crate::function::Either::B(b) => b.as_bytes(),
+        }
+    }
+
+    #[cfg(windows)]
+    unsafe extern "C" {
+        fn _wputenv(envstring: *const u16) -> libc::c_int;
+    }
+
+    /// Check if wide string length exceeds Windows environment variable limit.
+    #[cfg(windows)]
+    fn check_env_var_len(wide_len: usize, vm: &VirtualMachine) -> PyResult<()> {
+        use crate::common::windows::_MAX_ENV;
+        if wide_len > _MAX_ENV + 1 {
+            return Err(vm.new_value_error(format!(
+                "the environment variable is longer than {_MAX_ENV} characters",
+            )));
+        }
+        Ok(())
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn putenv(key: PyStrRef, value: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let key_str = key.as_str();
+        let value_str = value.as_str();
+        // 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('='))
+            || key_str.contains('\0')
+            || value_str.contains('\0')
+        {
+            return Err(vm.new_value_error("illegal environment variable name"));
+        }
+        let env_str = format!("{}={}", key_str, value_str);
+        let wide = env_str.to_wide_with_nul();
+        check_env_var_len(wide.len(), vm)?;
+
+        // Use _wputenv like CPython (not SetEnvironmentVariableW) to update CRT environ
+        let result = unsafe { suppress_iph!(_wputenv(wide.as_ptr())) };
+        if result != 0 {
+            return Err(vm.new_last_errno_error());
+        }
+        Ok(())
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn putenv(
+        key: crate::function::Either<PyStrRef, PyBytesRef>,
+        value: crate::function::Either<PyStrRef, PyBytesRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let key = env_bytes_as_bytes(&key);
+        let value = env_bytes_as_bytes(&value);
+        if key.contains(&b'\0') || value.contains(&b'\0') {
+            return Err(vm.new_value_error("embedded null byte"));
+        }
+        if key.is_empty() || key.contains(&b'=') {
+            return Err(vm.new_value_error("illegal environment variable name"));
+        }
+        let key = super::bytes_as_os_str(key, vm)?;
+        let value = super::bytes_as_os_str(value, vm)?;
+        // SAFETY: requirements forwarded from the caller
+        unsafe { env::set_var(key, value) };
+        Ok(())
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn unsetenv(key: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
+        let key_str = key.as_str();
+        // 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('='))
+            || key_str.contains('\0')
+        {
+            return Err(vm.new_value_error("illegal environment variable name"));
+        }
+        // "key=" to unset (empty value removes the variable)
+        let env_str = format!("{}=", key_str);
+        let wide = env_str.to_wide_with_nul();
+        check_env_var_len(wide.len(), vm)?;
+
+        // Use _wputenv like CPython (not SetEnvironmentVariableW) to update CRT environ
+        let result = unsafe { suppress_iph!(_wputenv(wide.as_ptr())) };
+        if result != 0 {
+            return Err(vm.new_last_errno_error());
+        }
+        Ok(())
+    }
+
+    #[cfg(not(windows))]
+    #[pyfunction]
+    fn unsetenv(
+        key: crate::function::Either<PyStrRef, PyBytesRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let key = env_bytes_as_bytes(&key);
+        if key.contains(&b'\0') {
+            return Err(vm.new_value_error("embedded null byte"));
+        }
+        if key.is_empty() || key.contains(&b'=') {
+            let x = vm.new_errno_error(
+                22,
+                format!(
+                    "Invalid argument: {}",
+                    core::str::from_utf8(key).unwrap_or("<bytes encoding failure>")
+                ),
+            );
+
+            return Err(x.upcast());
+        }
+        let key = super::bytes_as_os_str(key, vm)?;
+        // SAFETY: requirements forwarded from the caller
+        unsafe { env::remove_var(key) };
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn readlink(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult {
+        let mode = path.mode();
+        let [] = dir_fd.0;
+        let path =
+            fs::read_link(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
+        Ok(mode.process_path(path, vm))
+    }
+
+    #[pyattr]
+    #[pyclass(name)]
+    #[derive(Debug, PyPayload)]
+    struct DirEntry {
+        file_name: std::ffi::OsString,
+        pathval: PathBuf,
+        file_type: io::Result<fs::FileType>,
+        mode: OutputMode,
+        stat: OnceCell<PyObjectRef>,
+        lstat: OnceCell<PyObjectRef>,
+        #[cfg(unix)]
+        ino: AtomicCell<u64>,
+        #[cfg(windows)]
+        ino: AtomicCell<Option<u128>>,
+        #[cfg(not(any(unix, windows)))]
+        ino: AtomicCell<Option<u64>>,
+    }
+
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(Representable))]
+    impl DirEntry {
+        #[pygetset]
+        fn name(&self, vm: &VirtualMachine) -> PyResult {
+            Ok(self.mode.process_path(&self.file_name, vm))
+        }
+
+        #[pygetset]
+        fn path(&self, vm: &VirtualMachine) -> PyResult {
+            Ok(self.mode.process_path(&self.pathval, vm))
+        }
+
+        #[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());
+            }
+            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))
+                    }
+                }
+            }
+        }
+
+        #[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());
+            }
+            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))
+                    }
+                }
+            }
+        }
+
+        #[pymethod]
+        fn is_symlink(&self, vm: &VirtualMachine) -> PyResult<bool> {
+            Ok(self
+                .file_type
+                .as_ref()
+                .map_err(|err| err.into_pyexception(vm))?
+                .is_symlink())
+        }
+
+        #[pymethod]
+        fn stat(
+            &self,
+            dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
+            follow_symlinks: FollowSymlinks,
+            vm: &VirtualMachine,
+        ) -> PyResult {
+            let do_stat = |follow_symlinks| {
+                stat(
+                    OsPath {
+                        path: self.pathval.as_os_str().to_owned(),
+                        origin: None,
+                    }
+                    .into(),
+                    dir_fd,
+                    FollowSymlinks(follow_symlinks),
+                    vm,
+                )
+            };
+            let lstat = || self.lstat.get_or_try_init(|| do_stat(false));
+            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()
+                    }
+                })?
+            } else {
+                lstat()?
+            };
+            Ok(stat.clone())
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn inode(&self, vm: &VirtualMachine) -> PyResult<u128> {
+            match self.ino.load() {
+                Some(ino) => Ok(ino),
+                None => {
+                    let stat = stat_inner(
+                        OsPath::new_str(self.pathval.as_os_str()).into(),
+                        DirFd::default(),
+                        FollowSymlinks(false),
+                    )
+                    .map_err(|e| e.into_pyexception(vm))?
+                    .ok_or_else(|| crate::exceptions::cstring_error(vm))?;
+                    // On Windows, combine st_ino and st_ino_high into 128-bit value
+                    #[cfg(windows)]
+                    let ino: u128 = stat.st_ino as u128 | ((stat.st_ino_high as u128) << 64);
+                    #[cfg(not(windows))]
+                    let ino: u128 = stat.st_ino as u128;
+                    // Err(T) means other thread set `ino` at the mean time which is safe to ignore
+                    let _ = self.ino.compare_exchange(None, Some(ino));
+                    Ok(ino)
+                }
+            }
+        }
+
+        #[cfg(unix)]
+        #[pymethod]
+        fn inode(&self, _vm: &VirtualMachine) -> PyResult<u64> {
+            Ok(self.ino.load())
+        }
+
+        #[cfg(not(any(unix, windows)))]
+        #[pymethod]
+        fn inode(&self, _vm: &VirtualMachine) -> PyResult<Option<u64>> {
+            Ok(self.ino.load())
+        }
+
+        #[cfg(not(windows))]
+        #[pymethod]
+        const fn is_junction(&self, _vm: &VirtualMachine) -> PyResult<bool> {
+            Ok(false)
+        }
+
+        #[cfg(windows)]
+        #[pymethod]
+        fn is_junction(&self, _vm: &VirtualMachine) -> PyResult<bool> {
+            Ok(junction::exists(self.pathval.clone()).unwrap_or(false))
+        }
+
+        #[pymethod]
+        fn __fspath__(&self, vm: &VirtualMachine) -> PyResult {
+            self.path(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 {
+            Err(vm.new_type_error("cannot pickle 'DirEntry' object".to_owned()))
+        }
+    }
+
+    impl Representable for DirEntry {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
+            let name = match zelf.as_object().get_attr("name", vm) {
+                Ok(name) => Some(name),
+                Err(e)
+                    if e.fast_isinstance(vm.ctx.exceptions.attribute_error)
+                        || e.fast_isinstance(vm.ctx.exceptions.value_error) =>
+                {
+                    None
+                }
+                Err(e) => return Err(e),
+            };
+            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))
+                } else {
+                    Err(vm.new_runtime_error(format!(
+                        "reentrant call inside {}.__repr__",
+                        zelf.class()
+                    )))
+                }
+            } else {
+                Ok(format!("<{}>", zelf.class()))
+            }
+        }
+    }
+    #[pyattr]
+    #[pyclass(name = "ScandirIter")]
+    #[derive(Debug, PyPayload)]
+    struct ScandirIterator {
+        entries: PyRwLock<Option<fs::ReadDir>>,
+        mode: OutputMode,
+    }
+
+    #[pyclass(flags(DISALLOW_INSTANTIATION), with(IterNext, Iterable))]
+    impl ScandirIterator {
+        #[pymethod]
+        fn close(&self) {
+            let entryref: &mut Option<fs::ReadDir> = &mut self.entries.write();
+            let _dropped = entryref.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".to_owned()))
+        }
+    }
+    impl SelfIter for ScandirIterator {}
+    impl IterNext for ScandirIterator {
+        fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+            let entryref: &mut Option<fs::ReadDir> = &mut zelf.entries.write();
+
+            match entryref {
+                None => Ok(PyIterReturn::StopIteration(None)),
+                Some(inner) => match inner.next() {
+                    Some(entry) => match entry {
+                        Ok(entry) => {
+                            #[cfg(unix)]
+                            let ino = {
+                                use std::os::unix::fs::DirEntryExt;
+                                entry.ino()
+                            };
+                            // TODO: wasi is nightly
+                            // #[cfg(target_os = "wasi")]
+                            // let ino = {
+                            //     use std::os::wasi::fs::DirEntryExt;
+                            //     entry.ino()
+                            // };
+                            #[cfg(not(unix))]
+                            let ino = None;
+
+                            let pathval = entry.path();
+
+                            // On Windows, pre-cache lstat from directory entry metadata
+                            // This allows stat() to return cached data even if file is removed
+                            #[cfg(windows)]
+                            let lstat = {
+                                let cell = OnceCell::new();
+                                if let Ok(stat_struct) =
+                                    crate::windows::win32_xstat(pathval.as_os_str(), false)
+                                {
+                                    let stat_obj =
+                                        StatResultData::from_stat(&stat_struct, vm).to_pyobject(vm);
+                                    let _ = cell.set(stat_obj);
+                                }
+                                cell
+                            };
+                            #[cfg(not(windows))]
+                            let lstat = OnceCell::new();
+
+                            Ok(PyIterReturn::Return(
+                                DirEntry {
+                                    file_name: entry.file_name(),
+                                    pathval,
+                                    file_type: entry.file_type(),
+                                    mode: zelf.mode,
+                                    lstat,
+                                    stat: OnceCell::new(),
+                                    ino: AtomicCell::new(ino),
+                                }
+                                .into_ref(&vm.ctx)
+                                .into(),
+                            ))
+                        }
+                        Err(err) => Err(err.into_pyexception(vm)),
+                    },
+                    None => {
+                        let _dropped = entryref.take();
+                        Ok(PyIterReturn::StopIteration(None))
+                    }
+                },
+            }
+        }
+    }
+
+    #[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(),
+        }
+        .into_ref(&vm.ctx)
+        .into())
+    }
+
+    #[derive(Debug, FromArgs)]
+    #[pystruct_sequence_data]
+    struct StatResultData {
+        pub st_mode: PyIntRef,
+        pub st_ino: PyIntRef,
+        pub st_dev: PyIntRef,
+        pub st_nlink: PyIntRef,
+        pub st_uid: PyIntRef,
+        pub st_gid: PyIntRef,
+        pub st_size: PyIntRef,
+        // Indices 7-9: integer seconds
+        #[pyarg(positional, default)]
+        #[pystruct_sequence(unnamed)]
+        pub st_atime_int: libc::time_t,
+        #[pyarg(positional, default)]
+        #[pystruct_sequence(unnamed)]
+        pub st_mtime_int: libc::time_t,
+        #[pyarg(positional, default)]
+        #[pystruct_sequence(unnamed)]
+        pub st_ctime_int: libc::time_t,
+        // Float time attributes
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_atime: f64,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_mtime: f64,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_ctime: f64,
+        // Nanosecond attributes
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_atime_ns: i128,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_mtime_ns: i128,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_ctime_ns: i128,
+        // Unix-specific attributes
+        #[cfg(not(windows))]
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_blksize: i64,
+        #[cfg(not(windows))]
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_blocks: i64,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_reparse_tag: u32,
+        #[pyarg(any, default)]
+        #[pystruct_sequence(skip)]
+        pub st_file_attributes: u32,
+    }
+
+    impl StatResultData {
+        fn from_stat(stat: &StatStruct, vm: &VirtualMachine) -> Self {
+            let (atime, mtime, ctime);
+            #[cfg(any(unix, windows))]
+            #[cfg(not(any(target_os = "netbsd", target_os = "wasi")))]
+            {
+                atime = (stat.st_atime, stat.st_atime_nsec);
+                mtime = (stat.st_mtime, stat.st_mtime_nsec);
+                ctime = (stat.st_ctime, stat.st_ctime_nsec);
+            }
+            #[cfg(target_os = "netbsd")]
+            {
+                atime = (stat.st_atime, stat.st_atimensec);
+                mtime = (stat.st_mtime, stat.st_mtimensec);
+                ctime = (stat.st_ctime, stat.st_ctimensec);
+            }
+            #[cfg(target_os = "wasi")]
+            {
+                atime = (stat.st_atim.tv_sec, stat.st_atim.tv_nsec);
+                mtime = (stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec);
+                ctime = (stat.st_ctim.tv_sec, stat.st_ctim.tv_nsec);
+            }
+
+            const NANOS_PER_SEC: u32 = 1_000_000_000;
+            let to_f64 = |(s, ns)| (s as f64) + (ns as f64) / (NANOS_PER_SEC as f64);
+            let to_ns = |(s, ns)| s as i128 * NANOS_PER_SEC as i128 + ns as i128;
+
+            #[cfg(windows)]
+            let st_reparse_tag = stat.st_reparse_tag;
+            #[cfg(not(windows))]
+            let st_reparse_tag = 0;
+
+            #[cfg(windows)]
+            let st_file_attributes = stat.st_file_attributes;
+            #[cfg(not(windows))]
+            let st_file_attributes = 0;
+
+            // On Windows, combine st_ino and st_ino_high into a 128-bit value
+            // like _pystat_l128_from_l64_l64
+            #[cfg(windows)]
+            let st_ino: u128 = stat.st_ino as u128 | ((stat.st_ino_high as u128) << 64);
+            #[cfg(not(windows))]
+            let st_ino = stat.st_ino;
+
+            #[cfg(not(windows))]
+            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            let st_blksize = i64::from(stat.st_blksize);
+            #[cfg(not(windows))]
+            #[allow(clippy::useless_conversion)] // needed for 32-bit platforms
+            let st_blocks = i64::from(stat.st_blocks);
+
+            Self {
+                st_mode: vm.ctx.new_pyref(stat.st_mode),
+                st_ino: vm.ctx.new_pyref(st_ino),
+                st_dev: vm.ctx.new_pyref(stat.st_dev),
+                st_nlink: vm.ctx.new_pyref(stat.st_nlink),
+                st_uid: vm.ctx.new_pyref(stat.st_uid),
+                st_gid: vm.ctx.new_pyref(stat.st_gid),
+                st_size: vm.ctx.new_pyref(stat.st_size),
+                st_atime_int: atime.0,
+                st_mtime_int: mtime.0,
+                st_ctime_int: ctime.0,
+                st_atime: to_f64(atime),
+                st_mtime: to_f64(mtime),
+                st_ctime: to_f64(ctime),
+                st_atime_ns: to_ns(atime),
+                st_mtime_ns: to_ns(mtime),
+                st_ctime_ns: to_ns(ctime),
+                #[cfg(not(windows))]
+                st_blksize,
+                #[cfg(not(windows))]
+                st_blocks,
+                st_reparse_tag,
+                st_file_attributes,
+            }
+        }
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "stat_result", module = "os", data = "StatResultData")]
+    struct PyStatResult;
+
+    #[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;
+                    }
+                }
+            };
+
+            let args: FuncArgs = flatten_args(&args.args).into();
+
+            let stat: StatResultData = args.bind(vm)?;
+            Ok(stat.to_pyobject(vm))
+        }
+    }
+
+    #[cfg(windows)]
+    fn stat_inner(
+        file: OsPathOrFd<'_>,
+        dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
+        follow_symlinks: FollowSymlinks,
+    ) -> io::Result<Option<StatStruct>> {
+        // TODO: replicate CPython's win32_xstat
+        let [] = dir_fd.0;
+        match file {
+            OsPathOrFd::Path(path) => crate::windows::win32_xstat(&path.path, follow_symlinks.0),
+            OsPathOrFd::Fd(fd) => crate::common::fileutils::fstat(fd),
+        }
+        .map(Some)
+    }
+
+    #[cfg(not(windows))]
+    fn stat_inner(
+        file: OsPathOrFd<'_>,
+        dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
+        follow_symlinks: FollowSymlinks,
+    ) -> io::Result<Option<StatStruct>> {
+        let mut stat = core::mem::MaybeUninit::uninit();
+        let ret = match file {
+            OsPathOrFd::Path(path) => {
+                use rustpython_common::os::ffi::OsStrExt;
+                let path = path.as_ref().as_os_str().as_bytes();
+                let path = match alloc::ffi::CString::new(path) {
+                    Ok(x) => x,
+                    Err(_) => return Ok(None),
+                };
+
+                #[cfg(not(target_os = "redox"))]
+                let fstatat_ret = dir_fd.raw_opt().map(|dir_fd| {
+                    let flags = if follow_symlinks.0 {
+                        0
+                    } else {
+                        libc::AT_SYMLINK_NOFOLLOW
+                    };
+                    unsafe { libc::fstatat(dir_fd, path.as_ptr(), stat.as_mut_ptr(), flags) }
+                });
+                #[cfg(target_os = "redox")]
+                let ([], fstatat_ret) = (dir_fd.0, None);
+
+                fstatat_ret.unwrap_or_else(|| {
+                    if follow_symlinks.0 {
+                        unsafe { libc::stat(path.as_ptr(), stat.as_mut_ptr()) }
+                    } else {
+                        unsafe { libc::lstat(path.as_ptr(), stat.as_mut_ptr()) }
+                    }
+                })
+            }
+            OsPathOrFd::Fd(fd) => unsafe { libc::fstat(fd.as_raw(), stat.as_mut_ptr()) },
+        };
+        if ret < 0 {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(Some(unsafe { stat.assume_init() }))
+    }
+
+    #[pyfunction]
+    #[pyfunction(name = "fstat")]
+    fn stat(
+        file: OsPathOrFd<'_>,
+        dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
+        follow_symlinks: FollowSymlinks,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let stat = stat_inner(file.clone(), dir_fd, follow_symlinks)
+            .map_err(|err| OSErrorBuilder::with_filename(&err, file, vm))?
+            .ok_or_else(|| crate::exceptions::cstring_error(vm))?;
+        Ok(StatResultData::from_stat(&stat, vm).to_pyobject(vm))
+    }
+
+    #[pyfunction]
+    fn lstat(
+        file: OsPath,
+        dir_fd: DirFd<'_, { STAT_DIR_FD as usize }>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        stat(file.into(), dir_fd, FollowSymlinks(false), vm)
+    }
+
+    fn curdir_inner(vm: &VirtualMachine) -> PyResult<PathBuf> {
+        env::current_dir().map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[pyfunction]
+    fn getcwd(vm: &VirtualMachine) -> PyResult {
+        Ok(OutputMode::String.process_path(curdir_inner(vm)?, vm))
+    }
+
+    #[pyfunction]
+    fn getcwdb(vm: &VirtualMachine) -> PyResult {
+        Ok(OutputMode::Bytes.process_path(curdir_inner(vm)?, vm))
+    }
+
+    #[pyfunction]
+    fn chdir(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
+        env::set_current_dir(&path.path)
+            .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
+
+        #[cfg(windows)]
+        {
+            // win32_wchdir()
+
+            // On Windows, set the per-drive CWD environment variable (=X:)
+            // This is required for GetFullPathNameW to work correctly with drive-relative paths
+
+            use std::os::windows::ffi::OsStrExt;
+            use windows_sys::Win32::System::Environment::SetEnvironmentVariableW;
+
+            if let Ok(cwd) = env::current_dir() {
+                let cwd_str = cwd.as_os_str();
+                let mut cwd_wide: Vec<u16> = cwd_str.encode_wide().collect();
+
+                // Check for UNC-like paths (\\server\share or //server/share)
+                // wcsncmp(new_path, L"\\\\", 2) == 0 || wcsncmp(new_path, L"//", 2) == 0
+                let is_unc_like_path = cwd_wide.len() >= 2
+                    && ((cwd_wide[0] == b'\\' as u16 && cwd_wide[1] == b'\\' as u16)
+                        || (cwd_wide[0] == b'/' as u16 && cwd_wide[1] == b'/' as u16));
+
+                if !is_unc_like_path {
+                    // Create env var name "=X:" where X is the drive letter
+                    let env_name: [u16; 4] = [b'=' as u16, cwd_wide[0], b':' as u16, 0];
+                    cwd_wide.push(0); // null-terminate the path
+                    unsafe {
+                        SetEnvironmentVariableW(env_name.as_ptr(), cwd_wide.as_ptr());
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn fspath(path: PyObjectRef, vm: &VirtualMachine) -> PyResult<FsPath> {
+        FsPath::try_from_path_like(path, false, vm)
+    }
+
+    #[pyfunction]
+    #[pyfunction(name = "replace")]
+    fn rename(src: PyObjectRef, dst: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        let src = PathConverter::new()
+            .function("rename")
+            .argument("src")
+            .try_path(src, vm)?;
+        let dst = PathConverter::new()
+            .function("rename")
+            .argument("dst")
+            .try_path(dst, vm)?;
+
+        fs::rename(&src.path, &dst.path).map_err(|err| {
+            let builder = err.to_os_error_builder(vm);
+            let builder = builder.filename(src.filename(vm));
+            let builder = builder.filename2(dst.filename(vm));
+            builder.build(vm).upcast()
+        })
+    }
+
+    #[pyfunction]
+    fn getpid(vm: &VirtualMachine) -> PyObjectRef {
+        let pid = if cfg!(target_arch = "wasm32") {
+            // Return an arbitrary value, greater than 1 which is special.
+            // The value 42 is picked from wasi-libc
+            // https://github.com/WebAssembly/wasi-libc/blob/wasi-sdk-21/libc-bottom-half/getpid/getpid.c
+            42
+        } else {
+            std::process::id()
+        };
+        vm.ctx.new_int(pid).into()
+    }
+
+    #[pyfunction]
+    fn cpu_count(vm: &VirtualMachine) -> PyObjectRef {
+        let cpu_count = num_cpus::get();
+        vm.ctx.new_int(cpu_count).into()
+    }
+
+    #[pyfunction]
+    fn _exit(code: i32) {
+        std::process::exit(code)
+    }
+
+    #[pyfunction]
+    fn abort() {
+        unsafe extern "C" {
+            fn abort();
+        }
+        unsafe { abort() }
+    }
+
+    #[pyfunction]
+    fn urandom(size: isize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
+        if size < 0 {
+            return Err(vm.new_value_error("negative argument not allowed"));
+        }
+        let mut buf = vec![0u8; size as usize];
+        getrandom::fill(&mut buf).map_err(|e| io::Error::from(e).into_pyexception(vm))?;
+        Ok(buf)
+    }
+
+    #[pyfunction]
+    pub fn isatty(fd: i32) -> bool {
+        unsafe { suppress_iph!(libc::isatty(fd)) != 0 }
+    }
+
+    #[pyfunction]
+    pub fn lseek(
+        fd: crt_fd::Borrowed<'_>,
+        position: crt_fd::Offset,
+        how: i32,
+        vm: &VirtualMachine,
+    ) -> PyResult<crt_fd::Offset> {
+        #[cfg(not(windows))]
+        let res = unsafe { suppress_iph!(libc::lseek(fd.as_raw(), position, how)) };
+        #[cfg(windows)]
+        let res = unsafe {
+            use std::os::windows::io::AsRawHandle;
+            use windows_sys::Win32::Storage::FileSystem;
+            let handle = crt_fd::as_handle(fd).map_err(|e| e.into_pyexception(vm))?;
+            let mut distance_to_move: [i32; 2] = core::mem::transmute(position);
+            let ret = FileSystem::SetFilePointer(
+                handle.as_raw_handle(),
+                distance_to_move[0],
+                &mut distance_to_move[1],
+                how as _,
+            );
+            if ret == FileSystem::INVALID_SET_FILE_POINTER {
+                -1
+            } else {
+                distance_to_move[0] = ret as _;
+                core::mem::transmute::<[i32; 2], i64>(distance_to_move)
+            }
+        };
+        if res < 0 {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(res)
+        }
+    }
+
+    #[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()
+        })
+    }
+
+    #[cfg(any(unix, windows))]
+    #[pyfunction]
+    fn system(command: PyStrRef, vm: &VirtualMachine) -> PyResult<i32> {
+        let cstr = command.to_cstring(vm)?;
+        let x = unsafe { libc::system(cstr.as_ptr()) };
+        Ok(x)
+    }
+
+    #[derive(FromArgs)]
+    struct UtimeArgs<'fd> {
+        path: OsPath,
+        #[pyarg(any, default)]
+        times: Option<PyTupleRef>,
+        #[pyarg(named, default)]
+        ns: Option<PyTupleRef>,
+        #[pyarg(flatten)]
+        dir_fd: DirFd<'fd, { UTIME_DIR_FD as usize }>,
+        #[pyarg(flatten)]
+        follow_symlinks: FollowSymlinks,
+    }
+
+    #[pyfunction]
+    fn utime(args: UtimeArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
+        let parse_tup = |tup: &Py<PyTuple>| -> Option<(PyObjectRef, PyObjectRef)> {
+            if tup.len() != 2 {
+                None
+            } else {
+                Some((tup[0].clone(), tup[1].clone()))
+            }
+        };
+        let (acc, modif) = match (args.times, args.ns) {
+            (Some(t), None) => {
+                let (a, m) = parse_tup(&t).ok_or_else(|| {
+                    vm.new_type_error("utime: 'times' must be either a tuple of two ints or None")
+                })?;
+                (a.try_into_value(vm)?, m.try_into_value(vm)?)
+            }
+            (None, Some(ns)) => {
+                let (a, m) = parse_tup(&ns)
+                    .ok_or_else(|| vm.new_type_error("utime: 'ns' must be a tuple of two ints"))?;
+                let ns_in_sec: PyObjectRef = vm.ctx.new_int(1_000_000_000).into();
+                let ns_to_dur = |obj: PyObjectRef| {
+                    let divmod = vm._divmod(&obj, &ns_in_sec)?;
+                    let (div, rem) = divmod
+                        .downcast_ref::<PyTuple>()
+                        .and_then(parse_tup)
+                        .ok_or_else(|| {
+                            vm.new_type_error(format!(
+                                "{}.__divmod__() must return a 2-tuple, not {}",
+                                obj.class().name(),
+                                divmod.class().name()
+                            ))
+                        })?;
+                    let secs = div.try_index(vm)?.try_to_primitive(vm)?;
+                    let ns = rem.try_index(vm)?.try_to_primitive(vm)?;
+                    Ok(Duration::new(secs, ns))
+                };
+                // TODO: do validation to make sure this doesn't.. underflow?
+                (ns_to_dur(a)?, ns_to_dur(m)?)
+            }
+            (None, None) => {
+                let now = SystemTime::now();
+                let now = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
+                (now, now)
+            }
+            (Some(_), Some(_)) => {
+                return Err(vm.new_value_error(
+                    "utime: you may specify either 'times' or 'ns' but not both",
+                ));
+            }
+        };
+        utime_impl(args.path, acc, modif, args.dir_fd, args.follow_symlinks, vm)
+    }
+
+    fn utime_impl(
+        path: OsPath,
+        acc: Duration,
+        modif: Duration,
+        dir_fd: DirFd<'_, { UTIME_DIR_FD as usize }>,
+        _follow_symlinks: FollowSymlinks,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        #[cfg(any(target_os = "wasi", unix))]
+        {
+            #[cfg(not(target_os = "redox"))]
+            {
+                let path_for_err = path.clone();
+                let path = path.into_cstring(vm)?;
+
+                let ts = |d: Duration| libc::timespec {
+                    tv_sec: d.as_secs() as _,
+                    tv_nsec: d.subsec_nanos() as _,
+                };
+                let times = [ts(acc), ts(modif)];
+
+                let ret = unsafe {
+                    libc::utimensat(
+                        dir_fd.get().as_raw(),
+                        path.as_ptr(),
+                        times.as_ptr(),
+                        if _follow_symlinks.0 {
+                            0
+                        } else {
+                            libc::AT_SYMLINK_NOFOLLOW
+                        },
+                    )
+                };
+                if ret < 0 {
+                    Err(OSErrorBuilder::with_filename(
+                        &io::Error::last_os_error(),
+                        path_for_err,
+                        vm,
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            #[cfg(target_os = "redox")]
+            {
+                let [] = dir_fd.0;
+
+                let tv = |d: Duration| libc::timeval {
+                    tv_sec: d.as_secs() as _,
+                    tv_usec: d.as_micros() as _,
+                };
+                nix::sys::stat::utimes(path.as_ref(), &tv(acc).into(), &tv(modif).into())
+                    .map_err(|err| err.into_pyexception(vm))
+            }
+        }
+        #[cfg(windows)]
+        {
+            use std::{fs::OpenOptions, os::windows::prelude::*};
+            type DWORD = u32;
+            use windows_sys::Win32::{Foundation::FILETIME, Storage::FileSystem};
+
+            let [] = dir_fd.0;
+
+            if !_follow_symlinks.0 {
+                return Err(vm.new_not_implemented_error(
+                    "utime: follow_symlinks unavailable on this platform",
+                ));
+            }
+
+            let ft = |d: Duration| {
+                let intervals = ((d.as_secs() as i64 + 11644473600) * 10_000_000)
+                    + (d.subsec_nanos() as i64 / 100);
+                FILETIME {
+                    dwLowDateTime: intervals as DWORD,
+                    dwHighDateTime: (intervals >> 32) as DWORD,
+                }
+            };
+
+            let acc = ft(acc);
+            let modif = ft(modif);
+
+            let f = OpenOptions::new()
+                .write(true)
+                .custom_flags(windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS)
+                .open(&path)
+                .map_err(|err| OSErrorBuilder::with_filename(&err, path.clone(), vm))?;
+
+            let ret = unsafe {
+                FileSystem::SetFileTime(f.as_raw_handle() as _, core::ptr::null(), &acc, &modif)
+            };
+
+            if ret == 0 {
+                Err(OSErrorBuilder::with_filename(
+                    &io::Error::last_os_error(),
+                    path,
+                    vm,
+                ))
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
+    #[derive(Debug)]
+    #[pystruct_sequence_data]
+    struct TimesResultData {
+        pub user: f64,
+        pub system: f64,
+        pub children_user: f64,
+        pub children_system: f64,
+        pub elapsed: f64,
+    }
+
+    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
+    #[pyattr]
+    #[pystruct_sequence(name = "times_result", module = "os", data = "TimesResultData")]
+    struct PyTimesResult;
+
+    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
+    #[pyclass(with(PyStructSequence))]
+    impl PyTimesResult {}
+
+    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
+    #[pyfunction]
+    fn times(vm: &VirtualMachine) -> PyResult {
+        #[cfg(windows)]
+        {
+            use std::mem::MaybeUninit;
+            use windows_sys::Win32::{Foundation::FILETIME, System::Threading};
+
+            let mut _create = MaybeUninit::<FILETIME>::uninit();
+            let mut _exit = MaybeUninit::<FILETIME>::uninit();
+            let mut kernel = MaybeUninit::<FILETIME>::uninit();
+            let mut user = MaybeUninit::<FILETIME>::uninit();
+
+            unsafe {
+                let h_proc = Threading::GetCurrentProcess();
+                Threading::GetProcessTimes(
+                    h_proc,
+                    _create.as_mut_ptr(),
+                    _exit.as_mut_ptr(),
+                    kernel.as_mut_ptr(),
+                    user.as_mut_ptr(),
+                );
+            }
+
+            let kernel = unsafe { kernel.assume_init() };
+            let user = unsafe { user.assume_init() };
+
+            let times_result = TimesResultData {
+                user: user.dwHighDateTime as f64 * 429.4967296 + user.dwLowDateTime as f64 * 1e-7,
+                system: kernel.dwHighDateTime as f64 * 429.4967296
+                    + kernel.dwLowDateTime as f64 * 1e-7,
+                children_user: 0.0,
+                children_system: 0.0,
+                elapsed: 0.0,
+            };
+
+            Ok(times_result.to_pyobject(vm))
+        }
+        #[cfg(unix)]
+        {
+            let mut t = libc::tms {
+                tms_utime: 0,
+                tms_stime: 0,
+                tms_cutime: 0,
+                tms_cstime: 0,
+            };
+
+            let tick_for_second = unsafe { libc::sysconf(libc::_SC_CLK_TCK) } as f64;
+            let c = unsafe { libc::times(&mut t as *mut _) };
+
+            // XXX: The signedness of `clock_t` varies from platform to platform.
+            if c == (-1i8) as libc::clock_t {
+                return Err(vm.new_os_error("Fail to get times".to_string()));
+            }
+
+            let times_result = TimesResultData {
+                user: t.tms_utime as f64 / tick_for_second,
+                system: t.tms_stime as f64 / tick_for_second,
+                children_user: t.tms_cutime as f64 / tick_for_second,
+                children_system: t.tms_cstime as f64 / tick_for_second,
+                elapsed: c as f64 / tick_for_second,
+            };
+
+            Ok(times_result.to_pyobject(vm))
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    #[derive(FromArgs)]
+    struct CopyFileRangeArgs<'fd> {
+        #[pyarg(positional)]
+        src: crt_fd::Borrowed<'fd>,
+        #[pyarg(positional)]
+        dst: crt_fd::Borrowed<'fd>,
+        #[pyarg(positional)]
+        count: i64,
+        #[pyarg(any, default)]
+        offset_src: Option<crt_fd::Offset>,
+        #[pyarg(any, default)]
+        offset_dst: Option<crt_fd::Offset>,
+    }
+
+    #[cfg(target_os = "linux")]
+    #[pyfunction]
+    fn copy_file_range(args: CopyFileRangeArgs<'_>, vm: &VirtualMachine) -> PyResult<usize> {
+        #[allow(clippy::unnecessary_option_map_or_else)]
+        let p_offset_src = args.offset_src.as_ref().map_or_else(core::ptr::null, |x| x);
+        #[allow(clippy::unnecessary_option_map_or_else)]
+        let p_offset_dst = args.offset_dst.as_ref().map_or_else(core::ptr::null, |x| x);
+        let count: usize = args
+            .count
+            .try_into()
+            .map_err(|_| vm.new_value_error("count should >= 0"))?;
+
+        // The flags argument is provided to allow
+        // for future extensions and currently must be to 0.
+        let flags = 0u32;
+
+        // Safety: p_offset_src and p_offset_dst is a unique pointer for offset_src and offset_dst respectively,
+        // and will only be freed after this function ends.
+        //
+        // Why not use `libc::copy_file_range`: On `musl-libc`, `libc::copy_file_range` is not provided. Therefore
+        // we use syscalls directly instead.
+        let ret = unsafe {
+            libc::syscall(
+                libc::SYS_copy_file_range,
+                args.src,
+                p_offset_src as *mut i64,
+                args.dst,
+                p_offset_dst as *mut i64,
+                count,
+                flags,
+            )
+        };
+
+        usize::try_from(ret).map_err(|_| vm.new_last_errno_error())
+    }
+
+    #[pyfunction]
+    fn strerror(e: i32) -> String {
+        unsafe { core::ffi::CStr::from_ptr(libc::strerror(e)) }
+            .to_string_lossy()
+            .into_owned()
+    }
+
+    #[pyfunction]
+    pub fn ftruncate(fd: crt_fd::Borrowed<'_>, length: crt_fd::Offset) -> io::Result<()> {
+        crt_fd::ftruncate(fd, length)
+    }
+
+    #[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));
+        }
+
+        #[cold]
+        fn error(
+            vm: &VirtualMachine,
+            error: std::io::Error,
+            path: OsPath,
+        ) -> crate::builtins::PyBaseExceptionRef {
+            OSErrorBuilder::with_filename(&error, path, vm)
+        }
+
+        let path = OsPath::try_from_object(vm, path)?;
+        // TODO: just call libc::truncate() on POSIX
+        let f = match OpenOptions::new().write(true).open(&path) {
+            Ok(f) => f,
+            Err(e) => return Err(error(vm, e, path)),
+        };
+        f.set_len(length as u64).map_err(|e| error(vm, e, path))?;
+        drop(f);
+        Ok(())
+    }
+
+    #[cfg(all(unix, not(any(target_os = "redox", target_os = "android"))))]
+    #[pyfunction]
+    fn getloadavg(vm: &VirtualMachine) -> PyResult<(f64, f64, f64)> {
+        let mut loadavg = [0f64; 3];
+
+        // Safety: loadavg is on stack and only write by `getloadavg` and are freed
+        // after this function ends.
+        unsafe {
+            if libc::getloadavg(&mut loadavg[0] as *mut f64, 3) != 3 {
+                return Err(vm.new_os_error("Load averages are unobtainable".to_string()));
+            }
+        }
+
+        Ok((loadavg[0], loadavg[1], loadavg[2]))
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn waitstatus_to_exitcode(status: i32, vm: &VirtualMachine) -> PyResult<i32> {
+        let status = u32::try_from(status)
+            .map_err(|_| vm.new_value_error(format!("invalid WEXITSTATUS: {status}")))?;
+
+        let status = status as libc::c_int;
+        if libc::WIFEXITED(status) {
+            return Ok(libc::WEXITSTATUS(status));
+        }
+
+        if libc::WIFSIGNALED(status) {
+            return Ok(-libc::WTERMSIG(status));
+        }
+
+        Err(vm.new_value_error(format!("Invalid wait status: {status}")))
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn waitstatus_to_exitcode(status: u64, vm: &VirtualMachine) -> PyResult<u32> {
+        let exitcode = status >> 8;
+        // ExitProcess() accepts an UINT type:
+        // reject exit code which doesn't fit in an UINT
+        u32::try_from(exitcode)
+            .map_err(|_| vm.new_value_error(format!("Invalid exit code: {exitcode}")))
+    }
+
+    #[pyfunction]
+    fn device_encoding(fd: i32, _vm: &VirtualMachine) -> PyResult<Option<String>> {
+        if !isatty(fd) {
+            return Ok(None);
+        }
+
+        cfg_if::cfg_if! {
+            if #[cfg(any(target_os = "android", target_os = "redox"))] {
+                Ok(Some("UTF-8".to_owned()))
+            } else if #[cfg(windows)] {
+                use windows_sys::Win32::System::Console;
+                let cp = match fd {
+                    0 => unsafe { Console::GetConsoleCP() },
+                    1 | 2 => unsafe { Console::GetConsoleOutputCP() },
+                    _ => 0,
+                };
+
+                Ok(Some(format!("cp{cp}")))
+            } else {
+                let encoding = unsafe {
+                    let encoding = libc::nl_langinfo(libc::CODESET);
+                    if encoding.is_null() || encoding.read() == '\0' as libc::c_char {
+                        "UTF-8".to_owned()
+                    } else {
+                        core::ffi::CStr::from_ptr(encoding).to_string_lossy().into_owned()
+                    }
+                };
+
+                Ok(Some(encoding))
+            }
+        }
+    }
+
+    #[pystruct_sequence_data]
+    #[allow(dead_code)]
+    pub(crate) struct TerminalSizeData {
+        pub columns: usize,
+        pub lines: usize,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "terminal_size", module = "os", data = "TerminalSizeData")]
+    pub(crate) struct PyTerminalSize;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyTerminalSize {}
+
+    #[derive(Debug)]
+    #[pystruct_sequence_data]
+    pub(crate) struct UnameResultData {
+        pub sysname: String,
+        pub nodename: String,
+        pub release: String,
+        pub version: String,
+        pub machine: String,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "uname_result", module = "os", data = "UnameResultData")]
+    pub(crate) struct PyUnameResult;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyUnameResult {}
+
+    // statvfs_result: Result from statvfs or fstatvfs.
+    // = statvfs_result_fields
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[derive(Debug)]
+    #[pystruct_sequence_data]
+    pub(crate) struct StatvfsResultData {
+        pub f_bsize: libc::c_ulong,     // filesystem block size
+        pub f_frsize: libc::c_ulong,    // fragment size
+        pub f_blocks: libc::fsblkcnt_t, // size of fs in f_frsize units
+        pub f_bfree: libc::fsblkcnt_t,  // free blocks
+        pub f_bavail: libc::fsblkcnt_t, // free blocks for unprivileged users
+        pub f_files: libc::fsfilcnt_t,  // inodes
+        pub f_ffree: libc::fsfilcnt_t,  // free inodes
+        pub f_favail: libc::fsfilcnt_t, // free inodes for unprivileged users
+        pub f_flag: libc::c_ulong,      // mount flags
+        pub f_namemax: libc::c_ulong,   // maximum filename length
+        #[pystruct_sequence(skip)]
+        pub f_fsid: libc::c_ulong, // filesystem ID (not in tuple but accessible as attribute)
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyattr]
+    #[pystruct_sequence(name = "statvfs_result", module = "os", data = "StatvfsResultData")]
+    pub(crate) struct PyStatvfsResult;
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyclass(with(PyStructSequence))]
+    impl PyStatvfsResult {
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let seq: PyObjectRef = args.bind(vm)?;
+            crate::types::struct_sequence_new(cls, seq, vm)
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    impl StatvfsResultData {
+        fn from_statvfs(st: libc::statvfs) -> Self {
+            // f_fsid is a struct on some platforms (e.g., Linux fsid_t) and a scalar on others.
+            // We extract raw bytes and interpret as a native-endian integer.
+            // Note: The value may differ across architectures due to endianness.
+            let f_fsid = {
+                let ptr = core::ptr::addr_of!(st.f_fsid) as *const u8;
+                let size = core::mem::size_of_val(&st.f_fsid);
+                if size >= 8 {
+                    let bytes = unsafe { core::slice::from_raw_parts(ptr, 8) };
+                    u64::from_ne_bytes([
+                        bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6],
+                        bytes[7],
+                    ]) as libc::c_ulong
+                } else if size >= 4 {
+                    let bytes = unsafe { core::slice::from_raw_parts(ptr, 4) };
+                    u32::from_ne_bytes([bytes[0], bytes[1], bytes[2], bytes[3]]) as libc::c_ulong
+                } else {
+                    0
+                }
+            };
+
+            Self {
+                f_bsize: st.f_bsize,
+                f_frsize: st.f_frsize,
+                f_blocks: st.f_blocks,
+                f_bfree: st.f_bfree,
+                f_bavail: st.f_bavail,
+                f_files: st.f_files,
+                f_ffree: st.f_ffree,
+                f_favail: st.f_favail,
+                f_flag: st.f_flag,
+                f_namemax: st.f_namemax,
+                f_fsid,
+            }
+        }
+    }
+
+    /// Perform a statvfs system call on the given path.
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction]
+    #[pyfunction(name = "fstatvfs")]
+    fn statvfs(path: OsPathOrFd<'_>, vm: &VirtualMachine) -> PyResult {
+        let mut st: libc::statvfs = unsafe { core::mem::zeroed() };
+        let ret = match &path {
+            OsPathOrFd::Path(p) => {
+                let cpath = p.clone().into_cstring(vm)?;
+                unsafe { libc::statvfs(cpath.as_ptr(), &mut st) }
+            }
+            OsPathOrFd::Fd(fd) => unsafe { libc::fstatvfs(fd.as_raw(), &mut st) },
+        };
+        if ret != 0 {
+            return Err(OSErrorBuilder::with_filename(
+                &io::Error::last_os_error(),
+                path,
+                vm,
+            ));
+        }
+        Ok(StatvfsResultData::from_statvfs(st).to_pyobject(vm))
+    }
+
+    pub(super) fn support_funcs() -> Vec<SupportFunc> {
+        let mut supports = super::platform::module::support_funcs();
+        supports.extend(vec![
+            SupportFunc::new("open", Some(false), Some(OPEN_DIR_FD), Some(false)),
+            SupportFunc::new("access", Some(false), Some(false), None),
+            SupportFunc::new("chdir", None, Some(false), Some(false)),
+            // chflags Some, None Some
+            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("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("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)),
+            SupportFunc::new("truncate", Some(true), Some(false), Some(false)),
+            SupportFunc::new("ftruncate", Some(true), Some(false), Some(false)),
+            SupportFunc::new("fsync", Some(true), Some(false), Some(false)),
+            SupportFunc::new(
+                "utime",
+                Some(false),
+                Some(UTIME_DIR_FD),
+                Some(cfg!(all(unix, not(target_os = "redox")))),
+            ),
+        ]);
+        supports
+    }
+}
+pub(crate) use _os::{ftruncate, isatty, lseek};
+
+pub(crate) struct SupportFunc {
+    name: &'static str,
+    // realistically, each of these is just a bool of "is this function in the supports_* set".
+    // However, None marks that the function maybe _should_ support fd/dir_fd/follow_symlinks, but
+    // we haven't implemented it yet.
+    fd: Option<bool>,
+    dir_fd: Option<bool>,
+    follow_symlinks: Option<bool>,
+}
+
+impl SupportFunc {
+    pub(crate) const fn new(
+        name: &'static str,
+        fd: Option<bool>,
+        dir_fd: Option<bool>,
+        follow_symlinks: Option<bool>,
+    ) -> Self {
+        Self {
+            name,
+            fd,
+            dir_fd,
+            follow_symlinks,
+        }
+    }
+}
+
+pub fn extend_module(vm: &VirtualMachine, module: &Py<PyModule>) {
+    let support_funcs = _os::support_funcs();
+    let supports_fd = PySet::default().into_ref(&vm.ctx);
+    let supports_dir_fd = PySet::default().into_ref(&vm.ctx);
+    let supports_follow_symlinks = PySet::default().into_ref(&vm.ctx);
+    for support in support_funcs {
+        let func_obj = module.get_attr(support.name, vm).unwrap();
+        if support.fd.unwrap_or(false) {
+            supports_fd.clone().add(func_obj.clone(), vm).unwrap();
+        }
+        if support.dir_fd.unwrap_or(false) {
+            supports_dir_fd.clone().add(func_obj.clone(), vm).unwrap();
+        }
+        if support.follow_symlinks.unwrap_or(false) {
+            supports_follow_symlinks.clone().add(func_obj, vm).unwrap();
+        }
+    }
+
+    extend_module!(vm, module, {
+        "supports_fd" => supports_fd,
+        "supports_dir_fd" => supports_dir_fd,
+        "supports_follow_symlinks" => supports_follow_symlinks,
+        "error" => vm.ctx.exceptions.os_error.to_owned(),
+    });
+}
+
+#[cfg(not(windows))]
+use super::posix as platform;
+
+#[cfg(windows)]
+use super::nt as platform;
+
+pub(crate) use platform::module::MODULE_NAME;
diff --git a/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
similarity index 80%
rename from vm/src/stdlib/posix.rs
rename to crates/vm/src/stdlib/posix.rs
index 6220a15b8a..7ac5129d80 100644
--- a/vm/src/stdlib/posix.rs
+++ b/crates/vm/src/stdlib/posix.rs
@@ -1,9 +1,9 @@
 // spell-checker:disable
 
 use crate::{PyRef, VirtualMachine, builtins::PyModule};
-use std::os::unix::io::RawFd;
+use std::os::fd::BorrowedFd;
 
-pub fn raw_set_inheritable(fd: RawFd, inheritable: bool) -> nix::Result<()> {
+pub fn set_inheritable(fd: BorrowedFd<'_>, inheritable: bool) -> nix::Result<()> {
     use nix::fcntl;
     let flags = fcntl::FdFlag::from_bits_truncate(fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFD)?);
     let mut new_flags = flags;
@@ -24,146 +24,259 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 pub mod module {
     use crate::{
         AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyInt, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},
+        builtins::{PyDictRef, PyInt, PyListRef, PyStrRef, PyTupleRef, PyType, PyUtf8StrRef},
         convert::{IntoPyException, ToPyObject, TryFromObject},
+        exceptions::OSErrorBuilder,
         function::{Either, KwArgs, OptionalArg},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd},
-        stdlib::os::{
-            _os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, errno_err, fs_metadata,
-        },
+        ospath::{OsPath, OsPathOrFd},
+        stdlib::os::{_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, fs_metadata},
         types::{Constructor, Representable},
         utils::ToCString,
     };
+    use alloc::ffi::CString;
     use bitflags::bitflags;
+    use core::ffi::CStr;
     use nix::{
         fcntl,
         unistd::{self, Gid, Pid, Uid},
     };
     use std::{
-        env,
-        ffi::{CStr, CString},
-        fs, io,
-        os::fd::{AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd},
+        env, fs, io,
+        os::fd::{AsFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd},
     };
     use strum_macros::{EnumIter, EnumString};
 
+    #[cfg(target_os = "freebsd")]
     #[pyattr]
-    use libc::{PRIO_PGRP, PRIO_PROCESS, PRIO_USER};
+    use libc::{MFD_HUGE_MASK, SF_MNOWAIT, SF_NOCACHE, SF_NODISKIO, SF_SYNC};
+
+    #[cfg(target_os = "linux")]
+    #[pyattr]
+    use libc::PIDFD_NONBLOCK;
+
+    #[cfg(target_os = "macos")]
+    #[pyattr]
+    use libc::{
+        COPYFILE_DATA as _COPYFILE_DATA, O_EVTONLY, O_NOFOLLOW_ANY, PRIO_DARWIN_BG,
+        PRIO_DARWIN_NONUI, PRIO_DARWIN_PROCESS, PRIO_DARWIN_THREAD,
+    };
+
+    #[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,
+        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 = "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,
+    };
+
+    #[cfg(any(target_os = "android", target_os = "linux", target_os = "netbsd"))]
+    #[pyattr]
+    use libc::{TFD_CLOEXEC, TFD_NONBLOCK, TFD_TIMER_ABSTIME, TFD_TIMER_CANCEL_ON_SET};
+
+    #[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 = "dragonfly",
+        target_os = "linux",
+        target_os = "netbsd"
+    ))]
+    #[pyattr]
+    use libc::{GRND_NONBLOCK, GRND_RANDOM};
+
+    #[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 = "linux",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
+    #[pyattr]
+    use libc::O_RSYNC;
+
+    #[cfg(any(
+        target_os = "android",
         target_os = "dragonfly",
         target_os = "freebsd",
         target_os = "linux",
         target_os = "macos"
     ))]
     #[pyattr]
-    use libc::{SEEK_DATA, SEEK_HOLE};
+    use libc::{RTLD_NODELETE, SEEK_DATA, SEEK_HOLE};
 
-    #[cfg(not(any(target_os = "redox", target_os = "freebsd")))]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "netbsd"
+    ))]
     #[pyattr]
-    use libc::O_DSYNC;
+    use libc::O_DIRECT;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd"
+    ))]
     #[pyattr]
-    use libc::{O_CLOEXEC, O_NONBLOCK, WNOHANG};
-    #[cfg(target_os = "macos")]
+    use libc::RTLD_NOLOAD;
+
+    #[cfg(any(
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
     #[pyattr]
-    use libc::{O_EVTONLY, O_FSYNC, O_NOFOLLOW_ANY, O_SYMLINK};
-    #[cfg(not(target_os = "redox"))]
+    use libc::O_DSYNC;
+
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
     #[pyattr]
-    use libc::{O_NDELAY, O_NOCTTY};
+    use libc::SCHED_OTHER;
 
+    #[cfg(any(
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "redox"
+    ))]
     #[pyattr]
-    use libc::{RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NOW};
+    use libc::{O_EXLOCK, O_FSYNC, O_SHLOCK};
 
-    #[cfg(target_os = "linux")]
+    #[cfg(any(
+        target_os = "android",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "linux",
+        target_os = "macos",
+        target_os = "netbsd",
+        target_os = "openbsd"
+    ))]
     #[pyattr]
-    use libc::{GRND_NONBLOCK, GRND_RANDOM};
+    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,
+    };
+
+    #[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 = "redox"
+    ))]
+    #[pyattr]
+    use libc::{O_ASYNC, O_NDELAY, O_NOCTTY, WEXITED, WNOWAIT, WSTOPPED};
 
     #[pyattr]
     const EX_OK: i8 = exitcode::OK as i8;
+
     #[pyattr]
     const EX_USAGE: i8 = exitcode::USAGE as i8;
+
     #[pyattr]
     const EX_DATAERR: i8 = exitcode::DATAERR as i8;
+
     #[pyattr]
     const EX_NOINPUT: i8 = exitcode::NOINPUT as i8;
+
     #[pyattr]
     const EX_NOUSER: i8 = exitcode::NOUSER as i8;
+
     #[pyattr]
     const EX_NOHOST: i8 = exitcode::NOHOST as i8;
+
     #[pyattr]
     const EX_UNAVAILABLE: i8 = exitcode::UNAVAILABLE as i8;
+
     #[pyattr]
     const EX_SOFTWARE: i8 = exitcode::SOFTWARE as i8;
+
     #[pyattr]
     const EX_OSERR: i8 = exitcode::OSERR as i8;
+
     #[pyattr]
     const EX_OSFILE: i8 = exitcode::OSFILE as i8;
+
     #[pyattr]
     const EX_CANTCREAT: i8 = exitcode::CANTCREAT as i8;
+
     #[pyattr]
     const EX_IOERR: i8 = exitcode::IOERR as i8;
+
     #[pyattr]
     const EX_TEMPFAIL: i8 = exitcode::TEMPFAIL as i8;
+
     #[pyattr]
     const EX_PROTOCOL: i8 = exitcode::PROTOCOL as i8;
+
     #[pyattr]
     const EX_NOPERM: i8 = exitcode::NOPERM as i8;
-    #[pyattr]
-    const EX_CONFIG: i8 = exitcode::CONFIG as i8;
 
-    #[cfg(any(
-        target_os = "macos",
-        target_os = "linux",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "dragonfly",
-        target_os = "netbsd",
-        target_os = "macos"
-    ))]
-    #[pyattr]
-    const SCHED_RR: i32 = libc::SCHED_RR;
-    #[cfg(any(
-        target_os = "macos",
-        target_os = "linux",
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "dragonfly",
-        target_os = "netbsd",
-        target_os = "macos"
-    ))]
-    #[pyattr]
-    const SCHED_FIFO: i32 = libc::SCHED_FIFO;
-    #[cfg(any(
-        target_os = "macos",
-        target_os = "linux",
-        target_os = "freebsd",
-        target_os = "dragonfly",
-        target_os = "netbsd",
-        target_os = "macos"
-    ))]
-    #[pyattr]
-    const SCHED_OTHER: i32 = libc::SCHED_OTHER;
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    #[pyattr]
-    const SCHED_IDLE: i32 = libc::SCHED_IDLE;
-    #[cfg(any(target_os = "linux", target_os = "android"))]
     #[pyattr]
-    const SCHED_BATCH: i32 = libc::SCHED_BATCH;
+    const EX_CONFIG: i8 = exitcode::CONFIG as i8;
 
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
     #[pyattr]
     const POSIX_SPAWN_OPEN: i32 = PosixSpawnFileActionIdentifier::Open as i32;
+
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
     #[pyattr]
     const POSIX_SPAWN_CLOSE: i32 = PosixSpawnFileActionIdentifier::Close as i32;
+
     #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))]
     #[pyattr]
     const POSIX_SPAWN_DUP2: i32 = PosixSpawnFileActionIdentifier::Dup2 as i32;
 
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    const _COPYFILE_DATA: u32 = 1 << 3;
-
     impl TryFromObject for BorrowedFd<'_> {
         fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
             let fd = i32::try_from_object(vm, obj)?;
@@ -247,9 +360,9 @@ pub mod module {
 
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     fn getgroups_impl() -> nix::Result<Vec<Gid>> {
+        use core::ptr;
         use libc::{c_int, gid_t};
         use nix::errno::Errno;
-        use std::ptr;
         let ret = unsafe { libc::getgroups(0, ptr::null_mut()) };
         let mut groups = Vec::<Gid>::with_capacity(Errno::result(ret)? as usize);
         let ret = unsafe {
@@ -292,16 +405,17 @@ pub mod module {
         )
         })?;
 
-        let metadata = fs::metadata(&path.path);
+        let metadata = match fs::metadata(&path.path) {
+            Ok(m) => m,
+            // If the file doesn't exist, return False for any access check
+            Err(_) => return Ok(false),
+        };
 
         // if it's only checking for F_OK
         if flags == AccessFlags::F_OK {
-            return Ok(metadata.is_ok());
+            return Ok(true); // File exists
         }
 
-        let metadata =
-            metadata.map_err(|err| IOErrorBuilder::with_filename(&err, path.clone(), vm))?;
-
         let user_id = metadata.uid();
         let group_id = metadata.gid();
         let mode = metadata.mode();
@@ -331,47 +445,58 @@ pub mod module {
     }
 
     #[derive(FromArgs)]
-    pub(super) struct SymlinkArgs {
+    pub(super) struct SymlinkArgs<'fd> {
         src: OsPath,
         dst: OsPath,
         #[pyarg(flatten)]
         _target_is_directory: TargetIsDirectory,
         #[pyarg(flatten)]
-        dir_fd: DirFd<{ _os::SYMLINK_DIR_FD as usize }>,
+        dir_fd: DirFd<'fd, { _os::SYMLINK_DIR_FD as usize }>,
     }
 
     #[pyfunction]
-    pub(super) fn symlink(args: SymlinkArgs, vm: &VirtualMachine) -> PyResult<()> {
+    pub(super) fn symlink(args: SymlinkArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
         let src = args.src.into_cstring(vm)?;
         let dst = args.dst.into_cstring(vm)?;
         #[cfg(not(target_os = "redox"))]
         {
-            nix::unistd::symlinkat(&*src, args.dir_fd.get_opt(), &*dst)
+            nix::unistd::symlinkat(&*src, args.dir_fd.get(), &*dst)
                 .map_err(|err| err.into_pyexception(vm))
         }
         #[cfg(target_os = "redox")]
         {
             let [] = args.dir_fd.0;
             let res = unsafe { libc::symlink(src.as_ptr(), dst.as_ptr()) };
-            if res < 0 { Err(errno_err(vm)) } else { Ok(()) }
+            if res < 0 {
+                Err(vm.new_last_errno_error())
+            } else {
+                Ok(())
+            }
         }
     }
 
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+        let [] = dir_fd.0;
+        fs::remove_file(&path).map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))
+    }
+
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
-    fn fchdir(fd: RawFd, vm: &VirtualMachine) -> PyResult<()> {
+    fn fchdir(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<()> {
         nix::unistd::fchdir(fd).map_err(|err| err.into_pyexception(vm))
     }
 
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn chroot(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        use crate::ospath::IOErrorBuilder;
+        use crate::exceptions::OSErrorBuilder;
 
         nix::unistd::chroot(&*path.path).map_err(|err| {
             // Use `From<nix::Error> for io::Error` when it is available
-            let err = io::Error::from_raw_os_error(err as i32);
-            IOErrorBuilder::with_filename(&err, path, vm)
+            let io_err: io::Error = err.into();
+            OSErrorBuilder::with_filename(&io_err, path, vm)
         })
     }
 
@@ -379,10 +504,10 @@ pub mod module {
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn chown(
-        path: OsPathOrFd,
+        path: OsPathOrFd<'_>,
         uid: isize,
         gid: isize,
-        dir_fd: DirFd<1>,
+        dir_fd: DirFd<'_, 1>,
         follow_symlinks: FollowSymlinks,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
@@ -408,17 +533,16 @@ pub mod module {
             nix::fcntl::AtFlags::AT_SYMLINK_NOFOLLOW
         };
 
-        let dir_fd = dir_fd.get_opt();
         match path {
             OsPathOrFd::Path(ref p) => {
-                nix::unistd::fchownat(dir_fd, p.path.as_os_str(), uid, gid, flag)
+                nix::unistd::fchownat(dir_fd.get(), p.path.as_os_str(), uid, gid, flag)
             }
             OsPathOrFd::Fd(fd) => nix::unistd::fchown(fd, uid, gid),
         }
         .map_err(|err| {
             // Use `From<nix::Error> for io::Error` when it is available
             let err = io::Error::from_raw_os_error(err as i32);
-            IOErrorBuilder::with_filename(&err, path, vm)
+            OSErrorBuilder::with_filename(&err, path, vm)
         })
     }
 
@@ -437,9 +561,9 @@ pub mod module {
 
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
-    fn fchown(fd: i32, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {
+    fn fchown(fd: BorrowedFd<'_>, uid: isize, gid: isize, vm: &VirtualMachine) -> PyResult<()> {
         chown(
-            OsPathOrFd::Fd(fd),
+            OsPathOrFd::Fd(fd.into()),
             uid,
             gid,
             DirFd::default(),
@@ -516,7 +640,7 @@ pub mod module {
             if reversed {
                 funcs.reverse();
             }
-            for func in funcs.into_iter() {
+            for func in funcs {
                 if let Err(e) = func.call((), vm) {
                     let exit = e.fast_isinstance(vm.ctx.exceptions.system_exit);
                     vm.run_unraisable(e, Some("Exception ignored in".to_owned()), func);
@@ -537,6 +661,11 @@ pub mod module {
     }
 
     fn py_os_after_fork_child(vm: &VirtualMachine) {
+        // Mark all other threads as done before running Python callbacks
+        // See _PyThread_AfterFork behavior
+        #[cfg(feature = "threading")]
+        crate::stdlib::thread::after_fork_child(vm);
+
         let after_forkers_child: Vec<PyObjectRef> = vm.state.after_forkers_child.lock().clone();
         run_at_forkers(after_forkers_child, false, vm);
     }
@@ -546,8 +675,64 @@ pub mod module {
         run_at_forkers(after_forkers_parent, false, vm);
     }
 
+    /// Warn if forking from a multi-threaded process
+    fn warn_if_multi_threaded(name: &str, vm: &VirtualMachine) {
+        // Only check threading if it was already imported
+        // Avoid vm.import() which can execute arbitrary Python code in the fork path
+        let threading = match vm
+            .sys_module
+            .get_attr("modules", vm)
+            .and_then(|m| m.get_item("threading", vm))
+        {
+            Ok(m) => m,
+            Err(_) => return,
+        };
+        let active = threading.get_attr("_active", vm).ok();
+        let limbo = threading.get_attr("_limbo", vm).ok();
+
+        let count_dict = |obj: Option<crate::PyObjectRef>| -> usize {
+            obj.and_then(|o| o.length_opt(vm))
+                .and_then(|r| r.ok())
+                .unwrap_or(0)
+        };
+
+        let num_threads = count_dict(active) + count_dict(limbo);
+        if num_threads > 1 {
+            // Use Python warnings module to ensure filters are applied correctly
+            let Ok(warnings) = vm.import("warnings", 0) else {
+                return;
+            };
+            let Ok(warn_fn) = warnings.get_attr("warn", vm) else {
+                return;
+            };
+
+            let pid = unsafe { libc::getpid() };
+            let msg = format!(
+                "This process (pid={}) is multi-threaded, use of {}() may lead to deadlocks in the child.",
+                pid, name
+            );
+
+            // Call warnings.warn(message, DeprecationWarning, stacklevel=2)
+            // stacklevel=2 to point to the caller of fork()
+            let args = crate::function::FuncArgs::new(
+                vec![
+                    vm.ctx.new_str(msg).into(),
+                    vm.ctx.exceptions.deprecation_warning.as_object().to_owned(),
+                ],
+                crate::function::KwArgs::new(
+                    [("stacklevel".to_owned(), vm.ctx.new_int(2).into())]
+                        .into_iter()
+                        .collect(),
+                ),
+            );
+            let _ = warn_fn.call(args, vm);
+        }
+    }
+
     #[pyfunction]
     fn fork(vm: &VirtualMachine) -> i32 {
+        warn_if_multi_threaded("fork", vm);
+
         let pid: i32;
         py_os_before_fork(vm);
         unsafe {
@@ -566,7 +751,7 @@ pub mod module {
 
     #[cfg(not(target_os = "redox"))]
     #[derive(FromArgs)]
-    struct MknodArgs {
+    struct MknodArgs<'fd> {
         #[pyarg(any)]
         path: OsPath,
         #[pyarg(any)]
@@ -574,11 +759,11 @@ pub mod module {
         #[pyarg(any)]
         device: libc::dev_t,
         #[pyarg(flatten)]
-        dir_fd: DirFd<{ MKNOD_DIR_FD as usize }>,
+        dir_fd: DirFd<'fd, { MKNOD_DIR_FD as usize }>,
     }
 
     #[cfg(not(target_os = "redox"))]
-    impl MknodArgs {
+    impl MknodArgs<'_> {
         fn _mknod(self, vm: &VirtualMachine) -> PyResult<i32> {
             Ok(unsafe {
                 libc::mknod(
@@ -591,7 +776,7 @@ pub mod module {
 
         #[cfg(not(target_vendor = "apple"))]
         fn mknod(self, vm: &VirtualMachine) -> PyResult<()> {
-            let ret = match self.dir_fd.get_opt() {
+            let ret = match self.dir_fd.raw_opt() {
                 None => self._mknod(vm)?,
                 Some(non_default_fd) => unsafe {
                     libc::mknodat(
@@ -602,20 +787,28 @@ pub mod module {
                     )
                 },
             };
-            if ret != 0 { Err(errno_err(vm)) } else { Ok(()) }
+            if ret != 0 {
+                Err(vm.new_last_errno_error())
+            } else {
+                Ok(())
+            }
         }
 
         #[cfg(target_vendor = "apple")]
         fn mknod(self, vm: &VirtualMachine) -> PyResult<()> {
             let [] = self.dir_fd.0;
             let ret = self._mknod(vm)?;
-            if ret != 0 { Err(errno_err(vm)) } else { Ok(()) }
+            if ret != 0 {
+                Err(vm.new_last_errno_error())
+            } else {
+                Ok(())
+            }
         }
     }
 
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
-    fn mknod(args: MknodArgs, vm: &VirtualMachine) -> PyResult<()> {
+    fn mknod(args: MknodArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
         args.mknod(vm)
     }
 
@@ -626,7 +819,7 @@ pub mod module {
         Errno::clear();
         let res = unsafe { libc::nice(increment) };
         if res == -1 && Errno::last_raw() != 0 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(res)
         }
@@ -637,7 +830,7 @@ pub mod module {
     fn sched_get_priority_max(policy: i32, vm: &VirtualMachine) -> PyResult<i32> {
         let max = unsafe { libc::sched_get_priority_max(policy) };
         if max == -1 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(max)
         }
@@ -648,7 +841,7 @@ pub mod module {
     fn sched_get_priority_min(policy: i32, vm: &VirtualMachine) -> PyResult<i32> {
         let min = unsafe { libc::sched_get_priority_min(policy) };
         if min == -1 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(min)
         }
@@ -709,12 +902,10 @@ pub mod module {
     impl Constructor for SchedParam {
         type Args = SchedParamArg;
 
-        fn py_new(cls: PyTypeRef, arg: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Self {
+        fn py_new(_cls: &Py<PyType>, arg: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self {
                 sched_priority: arg.sched_priority,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
+            })
         }
     }
 
@@ -739,7 +930,7 @@ pub mod module {
     fn sched_getscheduler(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<i32> {
         let policy = unsafe { libc::sched_getscheduler(pid) };
         if policy == -1 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(policy)
         }
@@ -773,7 +964,7 @@ pub mod module {
         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(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(policy)
         }
@@ -787,9 +978,9 @@ pub mod module {
     #[pyfunction]
     fn sched_getparam(pid: libc::pid_t, vm: &VirtualMachine) -> PyResult<SchedParam> {
         let param = unsafe {
-            let mut param = std::mem::MaybeUninit::uninit();
+            let mut param = core::mem::MaybeUninit::uninit();
             if -1 == libc::sched_getparam(pid, param.as_mut_ptr()) {
-                return Err(errno_err(vm));
+                return Err(vm.new_last_errno_error());
             }
             param.assume_init()
         };
@@ -824,14 +1015,14 @@ pub mod module {
         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(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(ret)
         }
     }
 
     #[pyfunction]
-    fn get_inheritable(fd: RawFd, vm: &VirtualMachine) -> PyResult<bool> {
+    fn get_inheritable(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<bool> {
         let flags = fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFD);
         match flags {
             Ok(ret) => Ok((ret & libc::FD_CLOEXEC) == 0),
@@ -840,12 +1031,12 @@ pub mod module {
     }
 
     #[pyfunction]
-    fn set_inheritable(fd: i32, inheritable: bool, vm: &VirtualMachine) -> PyResult<()> {
-        super::raw_set_inheritable(fd, inheritable).map_err(|err| err.into_pyexception(vm))
+    fn set_inheritable(fd: BorrowedFd<'_>, inheritable: bool, vm: &VirtualMachine) -> PyResult<()> {
+        super::set_inheritable(fd, inheritable).map_err(|err| err.into_pyexception(vm))
     }
 
     #[pyfunction]
-    fn get_blocking(fd: RawFd, vm: &VirtualMachine) -> PyResult<bool> {
+    fn get_blocking(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<bool> {
         let flags = fcntl::fcntl(fd, fcntl::FcntlArg::F_GETFL);
         match flags {
             Ok(ret) => Ok((ret & libc::O_NONBLOCK) == 0),
@@ -854,7 +1045,7 @@ pub mod module {
     }
 
     #[pyfunction]
-    fn set_blocking(fd: RawFd, blocking: bool, vm: &VirtualMachine) -> PyResult<()> {
+    fn set_blocking(fd: BorrowedFd<'_>, blocking: bool, vm: &VirtualMachine) -> PyResult<()> {
         let _set_flag = || {
             use nix::fcntl::{FcntlArg, OFlag, fcntl};
 
@@ -873,8 +1064,8 @@ pub mod module {
     fn pipe(vm: &VirtualMachine) -> PyResult<(OwnedFd, OwnedFd)> {
         use nix::unistd::pipe;
         let (rfd, wfd) = pipe().map_err(|err| err.into_pyexception(vm))?;
-        set_inheritable(rfd.as_raw_fd(), false, vm)?;
-        set_inheritable(wfd.as_raw_fd(), false, vm)?;
+        set_inheritable(rfd.as_fd(), false, vm)?;
+        set_inheritable(wfd.as_fd(), false, vm)?;
         Ok((rfd, wfd))
     }
 
@@ -896,7 +1087,7 @@ pub mod module {
 
     fn _chmod(
         path: OsPath,
-        dir_fd: DirFd<0>,
+        dir_fd: DirFd<'_, 0>,
         mode: u32,
         follow_symlinks: FollowSymlinks,
         vm: &VirtualMachine,
@@ -910,11 +1101,11 @@ pub mod module {
             permissions.set_mode(mode);
             fs::set_permissions(&path, permissions)
         };
-        body().map_err(|err| IOErrorBuilder::with_filename(&err, err_path, vm))
+        body().map_err(|err| OSErrorBuilder::with_filename(&err, err_path, vm))
     }
 
     #[cfg(not(target_os = "redox"))]
-    fn _fchmod(fd: RawFd, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+    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(),
@@ -925,8 +1116,8 @@ pub mod module {
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
     fn chmod(
-        path: OsPathOrFd,
-        dir_fd: DirFd<0>,
+        path: OsPathOrFd<'_>,
+        dir_fd: DirFd<'_, 0>,
         mode: u32,
         follow_symlinks: FollowSymlinks,
         vm: &VirtualMachine,
@@ -939,7 +1130,7 @@ pub mod module {
                 }
                 _chmod(path, dir_fd, mode, follow_symlinks, vm)
             }
-            OsPathOrFd::Fd(fd) => _fchmod(fd, mode, vm),
+            OsPathOrFd::Fd(fd) => _fchmod(fd.into(), mode, vm),
         }
     }
 
@@ -957,7 +1148,7 @@ pub mod module {
 
     #[cfg(not(target_os = "redox"))]
     #[pyfunction]
-    fn fchmod(fd: RawFd, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
+    fn fchmod(fd: BorrowedFd<'_>, mode: u32, vm: &VirtualMachine) -> PyResult<()> {
         _fchmod(fd, mode, vm)
     }
 
@@ -972,7 +1163,7 @@ pub mod module {
             Ok(())
         } else {
             let err = std::io::Error::last_os_error();
-            Err(IOErrorBuilder::with_filename(&err, path, vm))
+            Err(OSErrorBuilder::with_filename(&err, path, vm))
         }
     }
 
@@ -1099,12 +1290,13 @@ pub mod module {
         vm.ctx.new_int(euid).into()
     }
 
+    #[cfg(not(any(target_os = "wasi", target_os = "android")))]
     #[pyfunction]
     fn setgid(gid: Gid, vm: &VirtualMachine) -> PyResult<()> {
         unistd::setgid(gid).map_err(|err| err.into_pyexception(vm))
     }
 
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "wasi", target_os = "android", target_os = "redox")))]
     #[pyfunction]
     fn setegid(egid: Gid, vm: &VirtualMachine) -> PyResult<()> {
         unistd::setegid(egid).map_err(|err| err.into_pyexception(vm))
@@ -1116,7 +1308,13 @@ pub mod module {
             .map_err(|err| err.into_pyexception(vm))
     }
 
-    #[cfg(not(target_os = "redox"))]
+    #[pyfunction]
+    fn setpgrp(vm: &VirtualMachine) -> PyResult<()> {
+        // setpgrp() is equivalent to setpgid(0, 0)
+        unistd::setpgid(Pid::from_raw(0), Pid::from_raw(0)).map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
     #[pyfunction]
     fn setsid(vm: &VirtualMachine) -> PyResult<()> {
         unistd::setsid()
@@ -1124,8 +1322,26 @@ pub mod module {
             .map_err(|err| err.into_pyexception(vm))
     }
 
+    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
+    #[pyfunction]
+    fn tcgetpgrp(fd: i32, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
+        use std::os::fd::BorrowedFd;
+        let fd = unsafe { BorrowedFd::borrow_raw(fd) };
+        unistd::tcgetpgrp(fd)
+            .map(|pid| pid.as_raw())
+            .map_err(|err| err.into_pyexception(vm))
+    }
+
+    #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
+    #[pyfunction]
+    fn tcsetpgrp(fd: i32, pgid: libc::pid_t, vm: &VirtualMachine) -> PyResult<()> {
+        use std::os::fd::BorrowedFd;
+        let fd = unsafe { BorrowedFd::borrow_raw(fd) };
+        unistd::tcsetpgrp(fd, Pid::from_raw(pgid)).map_err(|err| err.into_pyexception(vm))
+    }
+
     fn try_from_id(vm: &VirtualMachine, obj: PyObjectRef, typ_name: &str) -> PyResult<u32> {
-        use std::cmp::Ordering;
+        use core::cmp::Ordering;
         let i = obj
             .try_to_ref::<PyInt>(vm)
             .map_err(|_| {
@@ -1162,18 +1378,19 @@ pub mod module {
         }
     }
 
+    #[cfg(not(any(target_os = "wasi", target_os = "android")))]
     #[pyfunction]
     fn setuid(uid: Uid) -> nix::Result<()> {
         unistd::setuid(uid)
     }
 
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "wasi", target_os = "android", target_os = "redox")))]
     #[pyfunction]
     fn seteuid(euid: Uid) -> nix::Result<()> {
         unistd::seteuid(euid)
     }
 
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "wasi", target_os = "android", target_os = "redox")))]
     #[pyfunction]
     fn setreuid(ruid: Uid, euid: Uid) -> nix::Result<()> {
         let ret = unsafe { libc::setreuid(ruid.as_raw(), euid.as_raw()) };
@@ -1197,8 +1414,7 @@ pub mod module {
     fn openpty(vm: &VirtualMachine) -> PyResult<(OwnedFd, OwnedFd)> {
         let r = nix::pty::openpty(None, None).map_err(|err| err.into_pyexception(vm))?;
         for fd in [&r.master, &r.slave] {
-            super::raw_set_inheritable(fd.as_raw_fd(), false)
-                .map_err(|e| e.into_pyexception(vm))?;
+            super::set_inheritable(fd.as_fd(), false).map_err(|e| e.into_pyexception(vm))?;
         }
         Ok((r.master, r.slave))
     }
@@ -1216,9 +1432,9 @@ pub mod module {
     }
 
     #[pyfunction]
-    fn uname(vm: &VirtualMachine) -> PyResult<_os::UnameResult> {
+    fn uname(vm: &VirtualMachine) -> PyResult<_os::UnameResultData> {
         let info = uname::uname().map_err(|err| err.into_pyexception(vm))?;
-        Ok(_os::UnameResult {
+        Ok(_os::UnameResultData {
             sysname: info.sysname,
             nodename: info.nodename,
             release: info.release,
@@ -1271,7 +1487,7 @@ pub mod module {
         unistd::setresgid(rgid, egid, sgid).map_err(|err| err.into_pyexception(vm))
     }
 
-    #[cfg(not(target_os = "redox"))]
+    #[cfg(not(any(target_os = "wasi", target_os = "android", target_os = "redox")))]
     #[pyfunction]
     fn setregid(rgid: Gid, egid: Gid) -> nix::Result<()> {
         let ret = unsafe { libc::setregid(rgid.as_raw(), egid.as_raw()) };
@@ -1360,7 +1576,7 @@ pub mod module {
         #[pyarg(positional)]
         args: crate::function::ArgIterable<OsPath>,
         #[pyarg(positional)]
-        env: crate::function::ArgMapping,
+        env: Option<crate::function::ArgMapping>,
         #[pyarg(named, default)]
         file_actions: Option<crate::function::ArgIterable<PyTupleRef>>,
         #[pyarg(named, default)]
@@ -1397,11 +1613,8 @@ pub mod module {
                 .into_cstring(vm)
                 .map_err(|_| vm.new_value_error("path should not have nul bytes"))?;
 
-            let mut file_actions = unsafe {
-                let mut fa = std::mem::MaybeUninit::uninit();
-                assert!(libc::posix_spawn_file_actions_init(fa.as_mut_ptr()) == 0);
-                fa.assume_init()
-            };
+            let mut file_actions =
+                nix::spawn::PosixSpawnFileActions::init().map_err(|e| e.into_pyexception(vm))?;
             if let Some(it) = self.file_actions {
                 for action in it.iter(vm)? {
                     let action = action?;
@@ -1420,41 +1633,30 @@ pub mod module {
                                     "POSIX_SPAWN_OPEN path should not have nul bytes",
                                 )
                             })?;
-                            unsafe {
-                                libc::posix_spawn_file_actions_addopen(
-                                    &mut file_actions,
-                                    fd,
-                                    path.as_ptr(),
-                                    oflag,
-                                    mode,
-                                )
-                            }
+                            let oflag = nix::fcntl::OFlag::from_bits_retain(oflag);
+                            let mode = nix::sys::stat::Mode::from_bits_retain(mode);
+                            file_actions.add_open(fd, &*path, oflag, mode)
                         }
                         PosixSpawnFileActionIdentifier::Close => {
                             let (fd,) = args.bind(vm)?;
-                            unsafe {
-                                libc::posix_spawn_file_actions_addclose(&mut file_actions, fd)
-                            }
+                            file_actions.add_close(fd)
                         }
                         PosixSpawnFileActionIdentifier::Dup2 => {
                             let (fd, newfd) = args.bind(vm)?;
-                            unsafe {
-                                libc::posix_spawn_file_actions_adddup2(&mut file_actions, fd, newfd)
-                            }
+                            file_actions.add_dup2(fd, newfd)
                         }
                     };
-                    if ret != 0 {
-                        let err = std::io::Error::from_raw_os_error(ret);
-                        return Err(IOErrorBuilder::with_filename(&err, self.path, vm));
+                    if let Err(err) = ret {
+                        let err = err.into();
+                        return Err(OSErrorBuilder::with_filename(&err, self.path, vm));
                     }
                 }
             }
 
-            let mut attrp = unsafe {
-                let mut sa = std::mem::MaybeUninit::uninit();
-                assert!(libc::posix_spawnattr_init(sa.as_mut_ptr()) == 0);
-                sa.assume_init()
-            };
+            let mut attrp =
+                nix::spawn::PosixSpawnAttr::init().map_err(|e| e.into_pyexception(vm))?;
+            let mut flags = nix::spawn::PosixSpawnFlags::empty();
+
             if let Some(sigs) = self.setsigdef {
                 use nix::sys::signal;
                 let mut set = signal::SigSet::empty();
@@ -1465,37 +1667,39 @@ pub mod module {
                     })?;
                     set.add(sig);
                 }
-                assert!(
-                    unsafe { libc::posix_spawnattr_setsigdefault(&mut attrp, set.as_ref()) } == 0
-                );
+                attrp
+                    .set_sigdefault(&set)
+                    .map_err(|e| e.into_pyexception(vm))?;
+                flags.insert(nix::spawn::PosixSpawnFlags::POSIX_SPAWN_SETSIGDEF);
             }
 
-            // Handle new posix_spawn attributes
-            let mut flags = 0i32;
-
             if let Some(pgid) = self.setpgroup {
-                let ret = unsafe { libc::posix_spawnattr_setpgroup(&mut attrp, pgid) };
-                if ret != 0 {
-                    return Err(vm.new_os_error(format!("posix_spawnattr_setpgroup failed: {ret}")));
-                }
-                flags |= libc::POSIX_SPAWN_SETPGROUP;
+                attrp
+                    .set_pgroup(nix::unistd::Pid::from_raw(pgid))
+                    .map_err(|e| e.into_pyexception(vm))?;
+                flags.insert(nix::spawn::PosixSpawnFlags::POSIX_SPAWN_SETPGROUP);
             }
 
             if self.resetids {
-                flags |= libc::POSIX_SPAWN_RESETIDS;
+                flags.insert(nix::spawn::PosixSpawnFlags::POSIX_SPAWN_RESETIDS);
             }
 
             if self.setsid {
                 // Note: POSIX_SPAWN_SETSID may not be available on all platforms
-                #[cfg(target_os = "linux")]
-                {
-                    flags |= 0x0080; // POSIX_SPAWN_SETSID value on Linux
-                }
-                #[cfg(not(target_os = "linux"))]
-                {
-                    return Err(vm.new_not_implemented_error(
-                        "setsid parameter is not supported on this platform",
-                    ));
+                cfg_if::cfg_if! {
+                    if #[cfg(any(
+                        target_os = "linux",
+                        target_os = "haiku",
+                        target_os = "solaris",
+                        target_os = "illumos",
+                        target_os = "hurd",
+                    ))] {
+                        flags.insert(nix::spawn::PosixSpawnFlags::from_bits_retain(libc::POSIX_SPAWN_SETSID));
+                    } else {
+                        return Err(vm.new_not_implemented_error(
+                            "setsid parameter is not supported on this platform",
+                        ));
+                    }
                 }
             }
 
@@ -1509,13 +1713,10 @@ pub mod module {
                     })?;
                     set.add(sig);
                 }
-                let ret = unsafe { libc::posix_spawnattr_setsigmask(&mut attrp, set.as_ref()) };
-                if ret != 0 {
-                    return Err(
-                        vm.new_os_error(format!("posix_spawnattr_setsigmask failed: {ret}"))
-                    );
-                }
-                flags |= libc::POSIX_SPAWN_SETSIGMASK;
+                attrp
+                    .set_sigmask(&set)
+                    .map_err(|e| e.into_pyexception(vm))?;
+                flags.insert(nix::spawn::PosixSpawnFlags::POSIX_SPAWN_SETSIGMASK);
             }
 
             if let Some(_scheduler) = self.scheduler {
@@ -1526,19 +1727,11 @@ pub mod module {
                 );
             }
 
-            if flags != 0 {
-                // Check for potential overflow when casting to c_short
-                if flags > libc::c_short::MAX as i32 {
-                    return Err(vm.new_value_error("Too many flags set for posix_spawn"));
-                }
-                let ret =
-                    unsafe { libc::posix_spawnattr_setflags(&mut attrp, flags as libc::c_short) };
-                if ret != 0 {
-                    return Err(vm.new_os_error(format!("posix_spawnattr_setflags failed: {ret}")));
-                }
+            if !flags.is_empty() {
+                attrp.set_flags(flags).map_err(|e| e.into_pyexception(vm))?;
             }
 
-            let mut args: Vec<CString> = self
+            let args: Vec<CString> = self
                 .args
                 .iter(vm)?
                 .map(|res| {
@@ -1546,47 +1739,30 @@ pub mod module {
                         .map_err(|_| vm.new_value_error("path should not have nul bytes"))
                 })
                 .collect::<Result<_, _>>()?;
-            let argv: Vec<*mut libc::c_char> = args
-                .iter_mut()
-                .map(|s| s.as_ptr() as _)
-                .chain(std::iter::once(std::ptr::null_mut()))
-                .collect();
-            let mut env = envp_from_dict(self.env, vm)?;
-            let envp: Vec<*mut libc::c_char> = env
-                .iter_mut()
-                .map(|s| s.as_ptr() as _)
-                .chain(std::iter::once(std::ptr::null_mut()))
-                .collect();
-
-            let mut pid = 0;
-            let ret = unsafe {
-                if spawnp {
-                    libc::posix_spawnp(
-                        &mut pid,
-                        path.as_ptr(),
-                        &file_actions,
-                        &attrp,
-                        argv.as_ptr(),
-                        envp.as_ptr(),
-                    )
-                } else {
-                    libc::posix_spawn(
-                        &mut pid,
-                        path.as_ptr(),
-                        &file_actions,
-                        &attrp,
-                        argv.as_ptr(),
-                        envp.as_ptr(),
-                    )
-                }
+            let env = if let Some(env_dict) = self.env {
+                envp_from_dict(env_dict, vm)?
+            } else {
+                // env=None means use the current environment
+                use rustpython_common::os::ffi::OsStringExt;
+                env::vars_os()
+                    .map(|(k, v)| {
+                        let mut entry = k.into_vec();
+                        entry.push(b'=');
+                        entry.extend(v.into_vec());
+                        CString::new(entry).map_err(|_| {
+                            vm.new_value_error("environment string contains null byte")
+                        })
+                    })
+                    .collect::<PyResult<Vec<_>>>()?
             };
 
-            if ret == 0 {
-                Ok(pid)
+            let ret = if spawnp {
+                nix::spawn::posix_spawnp(&path, &file_actions, &attrp, &args, &env)
             } else {
-                let err = std::io::Error::from_raw_os_error(ret);
-                Err(IOErrorBuilder::with_filename(&err, self.path, vm))
-            }
+                nix::spawn::posix_spawn(&*path, &file_actions, &attrp, &args, &env)
+            };
+            ret.map(Into::into)
+                .map_err(|err| OSErrorBuilder::with_filename(&err.into(), self.path, vm))
         }
     }
 
@@ -1602,9 +1778,14 @@ pub mod module {
         args.spawn(true, vm)
     }
 
-    #[pyfunction(name = "WIFSIGNALED")]
-    fn wifsignaled(status: i32) -> bool {
-        libc::WIFSIGNALED(status)
+    #[pyfunction(name = "WCOREDUMP")]
+    fn wcoredump(status: i32) -> bool {
+        libc::WCOREDUMP(status)
+    }
+
+    #[pyfunction(name = "WIFCONTINUED")]
+    fn wifcontinued(status: i32) -> bool {
+        libc::WIFCONTINUED(status)
     }
 
     #[pyfunction(name = "WIFSTOPPED")]
@@ -1612,14 +1793,19 @@ pub mod module {
         libc::WIFSTOPPED(status)
     }
 
+    #[pyfunction(name = "WIFSIGNALED")]
+    fn wifsignaled(status: i32) -> bool {
+        libc::WIFSIGNALED(status)
+    }
+
     #[pyfunction(name = "WIFEXITED")]
     fn wifexited(status: i32) -> bool {
         libc::WIFEXITED(status)
     }
 
-    #[pyfunction(name = "WTERMSIG")]
-    fn wtermsig(status: i32) -> i32 {
-        libc::WTERMSIG(status)
+    #[pyfunction(name = "WEXITSTATUS")]
+    fn wexitstatus(status: i32) -> i32 {
+        libc::WEXITSTATUS(status)
     }
 
     #[pyfunction(name = "WSTOPSIG")]
@@ -1627,17 +1813,42 @@ pub mod module {
         libc::WSTOPSIG(status)
     }
 
-    #[pyfunction(name = "WEXITSTATUS")]
-    fn wexitstatus(status: i32) -> i32 {
-        libc::WEXITSTATUS(status)
+    #[pyfunction(name = "WTERMSIG")]
+    fn wtermsig(status: i32) -> i32 {
+        libc::WTERMSIG(status)
+    }
+
+    #[cfg(target_os = "linux")]
+    #[pyfunction]
+    fn pidfd_open(
+        pid: libc::pid_t,
+        flags: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<OwnedFd> {
+        let flags = flags.unwrap_or(0);
+        let fd = unsafe { libc::syscall(libc::SYS_pidfd_open, pid, flags) as libc::c_long };
+        if fd == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            // Safety: syscall returns a new owned file descriptor.
+            Ok(unsafe { OwnedFd::from_raw_fd(fd as libc::c_int) })
+        }
     }
 
     #[pyfunction]
     fn waitpid(pid: libc::pid_t, opt: i32, vm: &VirtualMachine) -> PyResult<(libc::pid_t, i32)> {
         let mut status = 0;
-        let pid = unsafe { libc::waitpid(pid, &mut status, opt) };
-        let pid = nix::Error::result(pid).map_err(|err| err.into_pyexception(vm))?;
-        Ok((pid, status))
+        loop {
+            let res = unsafe { libc::waitpid(pid, &mut status, opt) };
+            if res == -1 {
+                if nix::Error::last_raw() == libc::EINTR {
+                    vm.check_signals()?;
+                    continue;
+                }
+                return Err(nix::Error::last().into_pyexception(vm));
+            }
+            return Ok((res, status));
+        }
     }
 
     #[pyfunction]
@@ -1650,7 +1861,7 @@ pub mod module {
         {
             let ret = unsafe { libc::kill(pid, sig as i32) };
             if ret == -1 {
-                Err(errno_err(vm))
+                Err(vm.new_last_errno_error())
             } else {
                 Ok(())
             }
@@ -1661,7 +1872,7 @@ pub mod module {
     fn get_terminal_size(
         fd: OptionalArg<i32>,
         vm: &VirtualMachine,
-    ) -> PyResult<_os::PyTerminalSize> {
+    ) -> PyResult<_os::TerminalSizeData> {
         let (columns, lines) = {
             nix::ioctl_read_bad!(winsz, libc::TIOCGWINSZ, libc::winsize);
             let mut w = libc::winsize {
@@ -1674,7 +1885,7 @@ pub mod module {
                 .map_err(|err| err.into_pyexception(vm))?;
             (w.ws_col.into(), w.ws_row.into())
         };
-        Ok(_os::PyTerminalSize { columns, lines })
+        Ok(_os::TerminalSizeData { columns, lines })
     }
 
     // from libstd:
@@ -1692,41 +1903,41 @@ pub mod module {
     #[cfg(target_os = "macos")]
     #[pyfunction]
     fn _fcopyfile(in_fd: i32, out_fd: i32, flags: i32, vm: &VirtualMachine) -> PyResult<()> {
-        let ret = unsafe { fcopyfile(in_fd, out_fd, std::ptr::null_mut(), flags as u32) };
-        if ret < 0 { Err(errno_err(vm)) } else { Ok(()) }
+        let ret = unsafe { fcopyfile(in_fd, out_fd, core::ptr::null_mut(), flags as u32) };
+        if ret < 0 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
     }
 
     #[pyfunction]
-    fn dup(fd: i32, vm: &VirtualMachine) -> PyResult<i32> {
+    fn dup(fd: BorrowedFd<'_>, vm: &VirtualMachine) -> PyResult<OwnedFd> {
         let fd = nix::unistd::dup(fd).map_err(|e| e.into_pyexception(vm))?;
-        super::raw_set_inheritable(fd, false)
+        super::set_inheritable(fd.as_fd(), false)
             .map(|()| fd)
-            .map_err(|e| {
-                let _ = nix::unistd::close(fd);
-                e.into_pyexception(vm)
-            })
+            .map_err(|e| e.into_pyexception(vm))
     }
 
     #[derive(FromArgs)]
-    struct Dup2Args {
+    struct Dup2Args<'fd> {
         #[pyarg(positional)]
-        fd: i32,
+        fd: BorrowedFd<'fd>,
         #[pyarg(positional)]
-        fd2: i32,
+        fd2: OwnedFd,
         #[pyarg(any, default = true)]
         inheritable: bool,
     }
 
     #[pyfunction]
-    fn dup2(args: Dup2Args, vm: &VirtualMachine) -> PyResult<i32> {
-        let fd = nix::unistd::dup2(args.fd, args.fd2).map_err(|e| e.into_pyexception(vm))?;
+    fn dup2(args: Dup2Args<'_>, vm: &VirtualMachine) -> PyResult<OwnedFd> {
+        let mut fd2 = core::mem::ManuallyDrop::new(args.fd2);
+        nix::unistd::dup2(args.fd, &mut fd2).map_err(|e| e.into_pyexception(vm))?;
+        let fd2 = core::mem::ManuallyDrop::into_inner(fd2);
         if !args.inheritable {
-            super::raw_set_inheritable(fd, false).map_err(|e| {
-                let _ = nix::unistd::close(fd);
-                e.into_pyexception(vm)
-            })?
+            super::set_inheritable(fd2.as_fd(), false).map_err(|e| e.into_pyexception(vm))?
         }
-        Ok(fd)
+        Ok(fd2)
     }
 
     pub(crate) fn support_funcs() -> Vec<SupportFunc> {
@@ -1754,6 +1965,8 @@ pub mod module {
             SupportFunc::new("umask", Some(false), Some(false), Some(false)),
             SupportFunc::new("execv", None, None, None),
             SupportFunc::new("pathconf", Some(true), None, None),
+            SupportFunc::new("fpathconf", Some(true), None, None),
+            SupportFunc::new("fchdir", Some(true), None, None),
         ]
     }
 
@@ -1819,7 +2032,7 @@ pub mod module {
         Errno::clear();
         let retval = unsafe { libc::getpriority(which, who) };
         if Errno::last_raw() != 0 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(vm.ctx.new_int(retval).into())
         }
@@ -1835,7 +2048,7 @@ pub mod module {
     ) -> PyResult<()> {
         let retval = unsafe { libc::setpriority(which, who, priority) };
         if retval == -1 {
-            Err(errno_err(vm))
+            Err(vm.new_last_errno_error())
         } else {
             Ok(())
         }
@@ -2029,7 +2242,7 @@ pub mod module {
     #[cfg(unix)]
     #[pyfunction]
     fn pathconf(
-        path: OsPathOrFd,
+        path: OsPathOrFd<'_>,
         PathconfName(name): PathconfName,
         vm: &VirtualMachine,
     ) -> PyResult<Option<libc::c_long>> {
@@ -2042,14 +2255,14 @@ pub mod module {
                 let path = path.clone().into_cstring(vm)?;
                 unsafe { libc::pathconf(path.as_ptr(), name) }
             }
-            OsPathOrFd::Fd(fd) => unsafe { libc::fpathconf(*fd, name) },
+            OsPathOrFd::Fd(fd) => unsafe { libc::fpathconf(fd.as_raw(), name) },
         };
 
         if raw == -1 {
             if Errno::last_raw() == 0 {
                 Ok(None)
             } else {
-                Err(IOErrorBuilder::with_filename(
+                Err(OSErrorBuilder::with_filename(
                     &io::Error::from(Errno::last()),
                     path,
                     vm,
@@ -2062,11 +2275,11 @@ pub mod module {
 
     #[pyfunction]
     fn fpathconf(
-        fd: i32,
+        fd: BorrowedFd<'_>,
         name: PathconfName,
         vm: &VirtualMachine,
     ) -> PyResult<Option<libc::c_long>> {
-        pathconf(OsPathOrFd::Fd(fd), name, vm)
+        pathconf(OsPathOrFd::Fd(fd.into()), name, vm)
     }
 
     #[pyattr]
@@ -2242,7 +2455,7 @@ 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 = PyUtf8StrRef::try_from_object(vm, obj)?;
                     s.as_str().parse::<SysconfVar>().or_else(|_| {
                         if s.as_str() == "SC_PAGESIZE" {
                             Ok(SysconfVar::SC_PAGESIZE)
@@ -2258,9 +2471,10 @@ pub mod module {
 
     #[pyfunction]
     fn sysconf(name: SysconfName, vm: &VirtualMachine) -> PyResult<libc::c_long> {
+        crate::common::os::set_errno(0);
         let r = unsafe { libc::sysconf(name.0) };
-        if r == -1 {
-            return Err(errno_err(vm));
+        if r == -1 && crate::common::os::get_errno() != 0 {
+            return Err(vm.new_last_errno_error());
         }
         Ok(r)
     }
@@ -2387,7 +2601,7 @@ pub mod module {
                 flags.unwrap_or(0),
             )
             .try_into()
-            .map_err(|_| errno_err(vm))?;
+            .map_err(|_| vm.new_last_os_error())?;
             buf.set_len(len);
         }
         Ok(buf)
diff --git a/vm/src/stdlib/posix_compat.rs b/crates/vm/src/stdlib/posix_compat.rs
similarity index 77%
rename from vm/src/stdlib/posix_compat.rs
rename to crates/vm/src/stdlib/posix_compat.rs
index da8dddfb1e..0fabd6a1f4 100644
--- a/vm/src/stdlib/posix_compat.rs
+++ b/crates/vm/src/stdlib/posix_compat.rs
@@ -14,29 +14,37 @@ pub(crate) mod module {
     use crate::{
         PyObjectRef, PyResult, VirtualMachine,
         builtins::PyStrRef,
+        convert::IntoPyException,
         ospath::OsPath,
         stdlib::os::{_os, DirFd, SupportFunc, TargetIsDirectory},
     };
-    use std::env;
+    use std::{env, fs};
 
     #[pyfunction]
     pub(super) fn access(_path: PyStrRef, _mode: u8, vm: &VirtualMachine) -> PyResult<bool> {
         os_unimpl("os.access", vm)
     }
 
+    #[pyfunction]
+    #[pyfunction(name = "unlink")]
+    fn remove(path: OsPath, dir_fd: DirFd<'_, 0>, vm: &VirtualMachine) -> PyResult<()> {
+        let [] = dir_fd.0;
+        fs::remove_file(&path).map_err(|err| err.into_pyexception(vm))
+    }
+
     #[derive(FromArgs)]
     #[allow(unused)]
-    pub(super) struct SymlinkArgs {
+    pub(super) struct SymlinkArgs<'a> {
         src: OsPath,
         dst: OsPath,
         #[pyarg(flatten)]
         _target_is_directory: TargetIsDirectory,
         #[pyarg(flatten)]
-        _dir_fd: DirFd<{ _os::SYMLINK_DIR_FD as usize }>,
+        _dir_fd: DirFd<'a, { _os::SYMLINK_DIR_FD as usize }>,
     }
 
     #[pyfunction]
-    pub(super) fn symlink(_args: SymlinkArgs, vm: &VirtualMachine) -> PyResult<()> {
+    pub(super) fn symlink(_args: SymlinkArgs<'_>, vm: &VirtualMachine) -> PyResult<()> {
         os_unimpl("os.symlink", vm)
     }
 
diff --git a/vm/src/stdlib/pwd.rs b/crates/vm/src/stdlib/pwd.rs
similarity index 76%
rename from vm/src/stdlib/pwd.rs
rename to crates/vm/src/stdlib/pwd.rs
index 633a710030..6405ed7be9 100644
--- a/vm/src/stdlib/pwd.rs
+++ b/crates/vm/src/stdlib/pwd.rs
@@ -5,19 +5,19 @@ pub(crate) use pwd::make_module;
 #[pymodule]
 mod pwd {
     use crate::{
-        PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyIntRef, PyStrRef},
-        convert::{IntoPyException, ToPyObject},
+        PyResult, VirtualMachine,
+        builtins::{PyIntRef, PyUtf8StrRef},
+        convert::IntoPyException,
         exceptions,
         types::PyStructSequence,
     };
     use nix::unistd::{self, User};
-    use std::ptr::NonNull;
 
-    #[pyattr]
-    #[pyclass(module = "pwd", name = "struct_passwd")]
-    #[derive(PyStructSequence)]
-    struct Passwd {
+    #[cfg(not(target_os = "android"))]
+    use crate::{PyObjectRef, convert::ToPyObject};
+
+    #[pystruct_sequence_data]
+    struct PasswdData {
         pw_name: String,
         pw_passwd: String,
         pw_uid: u32,
@@ -26,13 +26,18 @@ mod pwd {
         pw_dir: String,
         pw_shell: String,
     }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "struct_passwd", module = "pwd", data = "PasswdData")]
+    struct PyPasswd;
+
     #[pyclass(with(PyStructSequence))]
-    impl Passwd {}
+    impl PyPasswd {}
 
-    impl From<User> for Passwd {
+    impl From<User> for PasswdData {
         fn from(user: User) -> Self {
             // this is just a pain...
-            let cstr_lossy = |s: std::ffi::CString| {
+            let cstr_lossy = |s: alloc::ffi::CString| {
                 s.into_string()
                     .unwrap_or_else(|e| e.into_cstring().to_string_lossy().into_owned())
             };
@@ -41,7 +46,7 @@ mod pwd {
                     .into_string()
                     .unwrap_or_else(|s| s.to_string_lossy().into_owned())
             };
-            Passwd {
+            PasswdData {
                 pw_name: user.name,
                 pw_passwd: cstr_lossy(user.passwd),
                 pw_uid: user.uid.as_raw(),
@@ -54,7 +59,7 @@ mod pwd {
     }
 
     #[pyfunction]
-    fn getpwnam(name: PyStrRef, vm: &VirtualMachine) -> PyResult<Passwd> {
+    fn getpwnam(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<PasswdData> {
         let pw_name = name.as_str();
         if pw_name.contains('\0') {
             return Err(exceptions::cstring_error(vm));
@@ -67,11 +72,11 @@ mod pwd {
                     .into(),
             )
         })?;
-        Ok(Passwd::from(user))
+        Ok(PasswdData::from(user))
     }
 
     #[pyfunction]
-    fn getpwuid(uid: PyIntRef, vm: &VirtualMachine) -> PyResult<Passwd> {
+    fn getpwuid(uid: PyIntRef, vm: &VirtualMachine) -> PyResult<PasswdData> {
         let uid_t = libc::uid_t::try_from(uid.as_bigint())
             .map(unistd::Uid::from_raw)
             .ok();
@@ -87,10 +92,11 @@ mod pwd {
                     .into(),
             )
         })?;
-        Ok(Passwd::from(user))
+        Ok(PasswdData::from(user))
     }
 
     // TODO: maybe merge this functionality into nix?
+    #[cfg(not(target_os = "android"))]
     #[pyfunction]
     fn getpwall(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
         // setpwent, getpwent, etc are not thread safe. Could use fgetpwent_r, but this is easier
@@ -99,9 +105,9 @@ mod pwd {
         let mut list = Vec::new();
 
         unsafe { libc::setpwent() };
-        while let Some(ptr) = NonNull::new(unsafe { libc::getpwent() }) {
+        while let Some(ptr) = core::ptr::NonNull::new(unsafe { libc::getpwent() }) {
             let user = User::from(unsafe { ptr.as_ref() });
-            let passwd = Passwd::from(user).to_pyobject(vm);
+            let passwd = PasswdData::from(user).to_pyobject(vm);
             list.push(passwd);
         }
         unsafe { libc::endpwent() };
diff --git a/crates/vm/src/stdlib/signal.rs b/crates/vm/src/stdlib/signal.rs
new file mode 100644
index 0000000000..b316ea306d
--- /dev/null
+++ b/crates/vm/src/stdlib/signal.rs
@@ -0,0 +1,685 @@
+// spell-checker:disable
+
+use crate::{PyRef, VirtualMachine, builtins::PyModule};
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = _signal::make_module(vm);
+
+    #[cfg(any(unix, windows))]
+    _signal::init_signal_handlers(&module, vm);
+
+    module
+}
+
+#[pymodule]
+pub(crate) mod _signal {
+    #[cfg(any(unix, windows))]
+    use crate::{
+        Py,
+        convert::{IntoPyException, TryFromBorrowedObject},
+    };
+    use crate::{PyObjectRef, PyResult, VirtualMachine, signal};
+    #[cfg(unix)]
+    use crate::{
+        builtins::PyTypeRef,
+        function::{ArgIntoFloat, OptionalArg},
+    };
+    use core::sync::atomic::{self, Ordering};
+
+    #[cfg(any(unix, windows))]
+    use libc::sighandler_t;
+    #[allow(non_camel_case_types)]
+    #[cfg(not(any(unix, windows)))]
+    type sighandler_t = usize;
+
+    cfg_if::cfg_if! {
+        if #[cfg(windows)] {
+            type WakeupFdRaw = libc::SOCKET;
+            struct WakeupFd(WakeupFdRaw);
+            const INVALID_WAKEUP: libc::SOCKET = windows_sys::Win32::Networking::WinSock::INVALID_SOCKET;
+            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);
+
+            impl<'a> TryFromBorrowedObject<'a> for WakeupFd {
+                fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a crate::PyObject) -> PyResult<Self> {
+                    use num_traits::One;
+
+                    let fd: &crate::Py<crate::builtins::PyInt> = obj.try_to_value(vm)?;
+                    match fd.try_to_primitive::<usize>(vm) {
+                        Ok(fd) => Ok(WakeupFd(fd as _)),
+                        Err(e) => if (-fd.as_bigint()).is_one() {
+                            Ok(WakeupFd(INVALID_WAKEUP))
+                        } else {
+                            Err(e)
+                        },
+                    }
+                }
+            }
+        } else {
+            type WakeupFdRaw = i32;
+            type WakeupFd = WakeupFdRaw;
+            const INVALID_WAKEUP: WakeupFd = -1;
+            static WAKEUP: atomic::AtomicI32 = atomic::AtomicI32::new(INVALID_WAKEUP);
+        }
+    }
+
+    #[cfg(unix)]
+    pub use libc::SIG_ERR;
+    #[cfg(unix)]
+    pub use nix::unistd::alarm as sig_alarm;
+
+    #[cfg(unix)]
+    #[pyattr]
+    pub use libc::{SIG_DFL, SIG_IGN};
+
+    // pthread_sigmask 'how' constants
+    #[cfg(unix)]
+    #[pyattr]
+    use libc::{SIG_BLOCK, SIG_SETMASK, SIG_UNBLOCK};
+
+    #[cfg(not(unix))]
+    #[pyattr]
+    pub const SIG_DFL: sighandler_t = 0;
+    #[cfg(not(unix))]
+    #[pyattr]
+    pub const SIG_IGN: sighandler_t = 1;
+    #[cfg(not(unix))]
+    #[allow(dead_code)]
+    pub const SIG_ERR: sighandler_t = -1 as _;
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    unsafe extern "C" {
+        fn siginterrupt(sig: i32, flag: i32) -> i32;
+    }
+
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    mod ffi {
+        unsafe extern "C" {
+            pub fn getitimer(which: libc::c_int, curr_value: *mut libc::itimerval) -> libc::c_int;
+            pub fn setitimer(
+                which: libc::c_int,
+                new_value: *const libc::itimerval,
+                old_value: *mut libc::itimerval,
+            ) -> libc::c_int;
+        }
+    }
+
+    #[pyattr]
+    use crate::signal::NSIG;
+
+    #[cfg(any(unix, windows))]
+    #[pyattr]
+    pub use libc::{SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM};
+
+    #[cfg(unix)]
+    #[pyattr]
+    use libc::{
+        SIGALRM, SIGBUS, SIGCHLD, SIGCONT, SIGHUP, SIGIO, SIGKILL, SIGPIPE, SIGPROF, SIGQUIT,
+        SIGSTOP, SIGSYS, SIGTRAP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGUSR1, SIGUSR2, SIGVTALRM,
+        SIGWINCH, SIGXCPU, SIGXFSZ,
+    };
+
+    #[cfg(unix)]
+    #[cfg(not(any(
+        target_vendor = "apple",
+        target_os = "openbsd",
+        target_os = "freebsd",
+        target_os = "netbsd"
+    )))]
+    #[pyattr]
+    use libc::{SIGPWR, SIGSTKFLT};
+
+    // Interval timer constants
+    #[cfg(all(unix, not(target_os = "android")))]
+    #[pyattr]
+    use libc::{ITIMER_PROF, ITIMER_REAL, ITIMER_VIRTUAL};
+
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_REAL: libc::c_int = 0;
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_VIRTUAL: libc::c_int = 1;
+    #[cfg(target_os = "android")]
+    #[pyattr]
+    const ITIMER_PROF: libc::c_int = 2;
+
+    #[cfg(unix)]
+    #[pyattr(name = "ItimerError", once)]
+    fn itimer_error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.new_exception_type(
+            "signal",
+            "ItimerError",
+            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
+        )
+    }
+
+    #[cfg(any(unix, windows))]
+    pub(super) fn init_signal_handlers(
+        module: &Py<crate::builtins::PyModule>,
+        vm: &VirtualMachine,
+    ) {
+        if vm.state.config.settings.install_signal_handlers {
+            let sig_dfl = vm.new_pyobj(SIG_DFL as u8);
+            let sig_ign = vm.new_pyobj(SIG_IGN as u8);
+
+            for signum in 1..NSIG {
+                let handler = unsafe { libc::signal(signum as i32, SIG_IGN) };
+                if handler != SIG_ERR {
+                    unsafe { libc::signal(signum as i32, handler) };
+                }
+                let py_handler = if handler == SIG_DFL {
+                    Some(sig_dfl.clone())
+                } else if handler == SIG_IGN {
+                    Some(sig_ign.clone())
+                } else {
+                    None
+                };
+                vm.signal_handlers.as_deref().unwrap().borrow_mut()[signum] = py_handler;
+            }
+
+            let int_handler = module
+                .get_attr("default_int_handler", vm)
+                .expect("_signal does not have this attr?");
+            signal(libc::SIGINT, int_handler, vm).expect("Failed to set sigint handler");
+        }
+    }
+
+    #[cfg(not(any(unix, windows)))]
+    #[pyfunction]
+    pub fn signal(
+        _signalnum: i32,
+        _handler: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<PyObjectRef>> {
+        Err(vm.new_not_implemented_error("signal is not implemented on this platform"))
+    }
+
+    #[cfg(any(unix, windows))]
+    #[pyfunction]
+    pub fn signal(
+        signalnum: i32,
+        handler: PyObjectRef,
+        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"))?;
+
+        let sig_handler =
+            match usize::try_from_borrowed_object(vm, &handler).ok() {
+                Some(SIG_DFL) => SIG_DFL,
+                Some(SIG_IGN) => SIG_IGN,
+                None if handler.is_callable() => run_signal as sighandler_t,
+                _ => return Err(vm.new_type_error(
+                    "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object",
+                )),
+            };
+        signal::check_signals(vm)?;
+
+        let old = unsafe { libc::signal(signalnum, sig_handler) };
+        if old == SIG_ERR {
+            return Err(vm.new_os_error("Failed to set signal".to_owned()));
+        }
+        #[cfg(all(unix, not(target_os = "redox")))]
+        unsafe {
+            siginterrupt(signalnum, 1);
+        }
+
+        let old_handler = signal_handlers.borrow_mut()[signalnum as usize].replace(handler);
+        Ok(old_handler)
+    }
+
+    #[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 handler = signal_handlers.borrow()[signalnum as usize]
+            .clone()
+            .unwrap_or_else(|| vm.ctx.none());
+        Ok(handler)
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn alarm(time: u32) -> u32 {
+        let prev_time = if time == 0 {
+            sig_alarm::cancel()
+        } else {
+            sig_alarm::set(time)
+        };
+        prev_time.unwrap_or(0)
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn pause(vm: &VirtualMachine) -> PyResult<()> {
+        unsafe { libc::pause() };
+        signal::check_signals(vm)?;
+        Ok(())
+    }
+
+    #[cfg(unix)]
+    fn timeval_to_double(tv: &libc::timeval) -> f64 {
+        tv.tv_sec as f64 + (tv.tv_usec as f64 / 1_000_000.0)
+    }
+
+    #[cfg(unix)]
+    fn double_to_timeval(val: f64) -> libc::timeval {
+        libc::timeval {
+            tv_sec: val.trunc() as _,
+            tv_usec: ((val.fract()) * 1_000_000.0) as _,
+        }
+    }
+
+    #[cfg(unix)]
+    fn itimerval_to_tuple(it: &libc::itimerval) -> (f64, f64) {
+        (
+            timeval_to_double(&it.it_value),
+            timeval_to_double(&it.it_interval),
+        )
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn setitimer(
+        which: i32,
+        seconds: ArgIntoFloat,
+        interval: OptionalArg<ArgIntoFloat>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(f64, f64)> {
+        let seconds: f64 = seconds.into();
+        let interval: f64 = interval.map(|v| v.into()).unwrap_or(0.0);
+        let new = libc::itimerval {
+            it_value: double_to_timeval(seconds),
+            it_interval: double_to_timeval(interval),
+        };
+        let mut old = core::mem::MaybeUninit::<libc::itimerval>::uninit();
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        let ret = unsafe { ffi::setitimer(which, &new, old.as_mut_ptr()) };
+        #[cfg(not(any(target_os = "linux", target_os = "android")))]
+        let ret = unsafe { libc::setitimer(which, &new, old.as_mut_ptr()) };
+        if ret != 0 {
+            let err = std::io::Error::last_os_error();
+            let itimer_error = itimer_error(vm);
+            return Err(vm.new_exception_msg(itimer_error, err.to_string()));
+        }
+        let old = unsafe { old.assume_init() };
+        Ok(itimerval_to_tuple(&old))
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn getitimer(which: i32, vm: &VirtualMachine) -> PyResult<(f64, f64)> {
+        let mut old = core::mem::MaybeUninit::<libc::itimerval>::uninit();
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        let ret = unsafe { ffi::getitimer(which, old.as_mut_ptr()) };
+        #[cfg(not(any(target_os = "linux", target_os = "android")))]
+        let ret = unsafe { libc::getitimer(which, old.as_mut_ptr()) };
+        if ret != 0 {
+            let err = std::io::Error::last_os_error();
+            let itimer_error = itimer_error(vm);
+            return Err(vm.new_exception_msg(itimer_error, err.to_string()));
+        }
+        let old = unsafe { old.assume_init() };
+        Ok(itimerval_to_tuple(&old))
+    }
+
+    #[pyfunction]
+    fn default_int_handler(
+        _signum: PyObjectRef,
+        _arg: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        Err(vm.new_exception_empty(vm.ctx.exceptions.keyboard_interrupt.to_owned()))
+    }
+
+    #[derive(FromArgs)]
+    struct SetWakeupFdArgs {
+        fd: WakeupFd,
+        #[pyarg(named, default = true)]
+        warn_on_full_buffer: bool,
+    }
+
+    #[pyfunction]
+    fn set_wakeup_fd(args: SetWakeupFdArgs, vm: &VirtualMachine) -> PyResult<i64> {
+        // TODO: implement warn_on_full_buffer
+        let _ = args.warn_on_full_buffer;
+        #[cfg(windows)]
+        let fd = args.fd.0;
+        #[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"));
+        }
+
+        #[cfg(windows)]
+        let is_socket = if fd != INVALID_WAKEUP {
+            use windows_sys::Win32::Networking::WinSock;
+
+            crate::windows::init_winsock();
+            let mut res = 0i32;
+            let mut res_size = std::mem::size_of::<i32>() as i32;
+            let res = unsafe {
+                WinSock::getsockopt(
+                    fd,
+                    WinSock::SOL_SOCKET,
+                    WinSock::SO_ERROR,
+                    &mut res as *mut i32 as *mut _,
+                    &mut res_size,
+                )
+            };
+            // if getsockopt succeeded, fd is for sure a socket
+            let is_socket = res == 0;
+            if !is_socket {
+                let err = std::io::Error::last_os_error();
+                // if getsockopt failed for some other reason, throw
+                if err.raw_os_error() != Some(WinSock::WSAENOTSOCK) {
+                    return Err(err.into_pyexception(vm));
+                }
+                // 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()))?;
+                // Verify the fd is valid by trying to fstat it
+                let borrowed_fd =
+                    unsafe { crate::common::crt_fd::Borrowed::try_borrow_raw(fd_i32) }
+                        .map_err(|e| e.into_pyexception(vm))?;
+                crate::common::fileutils::fstat(borrowed_fd).map_err(|e| e.into_pyexception(vm))?;
+            }
+            is_socket
+        } else {
+            false
+        };
+        #[cfg(unix)]
+        if let Ok(fd) = unsafe { crate::common::crt_fd::Borrowed::try_borrow_raw(fd) } {
+            use nix::fcntl;
+            let oflags = fcntl::fcntl(fd, fcntl::F_GETFL).map_err(|e| e.into_pyexception(vm))?;
+            let nonblock =
+                fcntl::OFlag::from_bits_truncate(oflags).contains(fcntl::OFlag::O_NONBLOCK);
+            if !nonblock {
+                return Err(vm.new_value_error(format!(
+                    "the fd {} must be in non-blocking mode",
+                    fd.as_raw()
+                )));
+            }
+        }
+
+        let old_fd = WAKEUP.swap(fd, Ordering::Relaxed);
+        #[cfg(windows)]
+        WAKEUP_IS_SOCKET.store(is_socket, Ordering::Relaxed);
+
+        #[cfg(windows)]
+        {
+            if old_fd == INVALID_WAKEUP {
+                Ok(-1)
+            } else {
+                Ok(old_fd as i64)
+            }
+        }
+        #[cfg(not(windows))]
+        {
+            Ok(old_fd as i64)
+        }
+    }
+
+    #[cfg(target_os = "linux")]
+    #[pyfunction]
+    fn pidfd_send_signal(
+        pidfd: i32,
+        sig: i32,
+        siginfo: OptionalArg<PyObjectRef>,
+        flags: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        signal::assert_in_range(sig, vm)?;
+        if let OptionalArg::Present(obj) = siginfo
+            && !vm.is_none(&obj)
+        {
+            return Err(vm.new_type_error("siginfo must be None".to_owned()));
+        }
+
+        let flags = flags.unwrap_or(0);
+        let ret = unsafe {
+            libc::syscall(
+                libc::SYS_pidfd_send_signal,
+                pidfd,
+                sig,
+                std::ptr::null::<libc::siginfo_t>(),
+                flags,
+            ) as libc::c_long
+        };
+
+        if ret == -1 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    #[cfg(all(unix, not(target_os = "redox")))]
+    #[pyfunction(name = "siginterrupt")]
+    fn py_siginterrupt(signum: i32, flag: i32, vm: &VirtualMachine) -> PyResult<()> {
+        signal::assert_in_range(signum, vm)?;
+        let res = unsafe { siginterrupt(signum, flag) };
+        if res < 0 {
+            Err(vm.new_last_errno_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// CPython: signal_raise_signal (signalmodule.c)
+    #[cfg(any(unix, windows))]
+    #[pyfunction]
+    fn raise_signal(signalnum: i32, vm: &VirtualMachine) -> PyResult<()> {
+        signal::assert_in_range(signalnum, vm)?;
+
+        // 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)
+            const VALID_SIGNALS: &[i32] = &[
+                libc::SIGINT,
+                libc::SIGILL,
+                libc::SIGFPE,
+                libc::SIGSEGV,
+                libc::SIGTERM,
+                libc::SIGABRT,
+            ];
+            if !VALID_SIGNALS.contains(&signalnum) {
+                return Err(std::io::Error::from_raw_os_error(libc::EINVAL).into_pyexception(vm));
+            }
+        }
+
+        let res = unsafe { libc::raise(signalnum) };
+        if res != 0 {
+            return Err(vm.new_os_error(format!("raise_signal failed for signal {}", signalnum)));
+        }
+
+        // Check if a signal was triggered and handle it
+        signal::check_signals(vm)?;
+
+        Ok(())
+    }
+
+    /// CPython: signal_strsignal (signalmodule.c)
+    #[cfg(unix)]
+    #[pyfunction]
+    fn strsignal(signalnum: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        if signalnum < 1 || signalnum >= signal::NSIG as i32 {
+            return Err(vm.new_value_error(format!("signal number {} out of range", signalnum)));
+        }
+        let s = unsafe { libc::strsignal(signalnum) };
+        if s.is_null() {
+            Ok(None)
+        } else {
+            let cstr = unsafe { core::ffi::CStr::from_ptr(s) };
+            Ok(Some(cstr.to_string_lossy().into_owned()))
+        }
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn strsignal(signalnum: i32, vm: &VirtualMachine) -> PyResult<Option<String>> {
+        if signalnum < 1 || signalnum >= signal::NSIG as i32 {
+            return Err(vm.new_value_error(format!("signal number {} out of range", signalnum)));
+        }
+        // Windows doesn't have strsignal(), provide our own mapping
+        let name = match signalnum {
+            libc::SIGINT => "Interrupt",
+            libc::SIGILL => "Illegal instruction",
+            libc::SIGFPE => "Floating-point exception",
+            libc::SIGSEGV => "Segmentation fault",
+            libc::SIGTERM => "Terminated",
+            libc::SIGABRT => "Aborted",
+            _ => return Ok(None),
+        };
+        Ok(Some(name.to_owned()))
+    }
+
+    /// CPython: signal_valid_signals (signalmodule.c)
+    #[pyfunction]
+    fn valid_signals(vm: &VirtualMachine) -> PyResult {
+        use crate::PyPayload;
+        use crate::builtins::PySet;
+        let set = PySet::default().into_ref(&vm.ctx);
+        #[cfg(unix)]
+        {
+            // Use sigfillset to get all valid signals
+            let mut mask: libc::sigset_t = unsafe { core::mem::zeroed() };
+            // SAFETY: mask is a valid pointer
+            if unsafe { libc::sigfillset(&mut mask) } != 0 {
+                return Err(vm.new_os_error("sigfillset failed".to_owned()));
+            }
+            // Convert the filled mask to a Python set
+            for signum in 1..signal::NSIG {
+                if unsafe { libc::sigismember(&mask, signum as i32) } == 1 {
+                    set.add(vm.ctx.new_int(signum as i32).into(), vm)?;
+                }
+            }
+        }
+        #[cfg(windows)]
+        {
+            // Windows only supports a limited set of signals
+            for &signum in &[
+                libc::SIGINT,
+                libc::SIGILL,
+                libc::SIGFPE,
+                libc::SIGSEGV,
+                libc::SIGTERM,
+                libc::SIGABRT,
+            ] {
+                set.add(vm.ctx.new_int(signum).into(), vm)?;
+            }
+        }
+        #[cfg(not(any(unix, windows)))]
+        {
+            // Empty set for platforms without signal support (e.g., WASM)
+            let _ = &set;
+        }
+        Ok(set.into())
+    }
+
+    #[cfg(unix)]
+    fn sigset_to_pyset(mask: &libc::sigset_t, vm: &VirtualMachine) -> PyResult {
+        use crate::PyPayload;
+        use crate::builtins::PySet;
+        let set = PySet::default().into_ref(&vm.ctx);
+        for signum in 1..signal::NSIG {
+            // SAFETY: mask is a valid sigset_t
+            if unsafe { libc::sigismember(mask, signum as i32) } == 1 {
+                set.add(vm.ctx.new_int(signum as i32).into(), vm)?;
+            }
+        }
+        Ok(set.into())
+    }
+
+    #[cfg(unix)]
+    #[pyfunction]
+    fn pthread_sigmask(
+        how: i32,
+        mask: crate::function::ArgIterable,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use crate::convert::IntoPyException;
+
+        // Initialize sigset
+        let mut sigset: libc::sigset_t = unsafe { core::mem::zeroed() };
+        // SAFETY: sigset is a valid pointer
+        if unsafe { libc::sigemptyset(&mut sigset) } != 0 {
+            return Err(std::io::Error::last_os_error().into_pyexception(vm));
+        }
+
+        // Add signals to the set
+        for sig in mask.iter(vm)? {
+            let sig = sig?;
+            // Convert to i32, handling overflow by returning ValueError
+            let signum: i32 = sig.try_to_value(vm).map_err(|_| {
+                vm.new_value_error(format!(
+                    "signal number out of range [1, {}]",
+                    signal::NSIG - 1
+                ))
+            })?;
+            // Validate signal number is in range [1, NSIG)
+            if signum < 1 || signum >= signal::NSIG as i32 {
+                return Err(vm.new_value_error(format!(
+                    "signal number {} out of range [1, {}]",
+                    signum,
+                    signal::NSIG - 1
+                )));
+            }
+            // SAFETY: sigset is a valid pointer and signum is validated
+            if unsafe { libc::sigaddset(&mut sigset, signum) } != 0 {
+                return Err(std::io::Error::last_os_error().into_pyexception(vm));
+            }
+        }
+
+        // Call pthread_sigmask
+        let mut old_mask: libc::sigset_t = unsafe { core::mem::zeroed() };
+        // SAFETY: all pointers are valid
+        let err = unsafe { libc::pthread_sigmask(how, &sigset, &mut old_mask) };
+        if err != 0 {
+            return Err(std::io::Error::from_raw_os_error(err).into_pyexception(vm));
+        }
+
+        // Check for pending signals
+        signal::check_signals(vm)?;
+
+        // Convert old mask to Python set
+        sigset_to_pyset(&old_mask, vm)
+    }
+
+    #[cfg(any(unix, windows))]
+    pub extern "C" fn run_signal(signum: i32) {
+        signal::TRIGGERS[signum as usize].store(true, Ordering::Relaxed);
+        signal::set_triggered();
+        let wakeup_fd = WAKEUP.load(Ordering::Relaxed);
+        if wakeup_fd != INVALID_WAKEUP {
+            let sigbyte = signum as u8;
+            #[cfg(windows)]
+            if WAKEUP_IS_SOCKET.load(Ordering::Relaxed) {
+                let _res = unsafe {
+                    windows_sys::Win32::Networking::WinSock::send(
+                        wakeup_fd,
+                        &sigbyte as *const u8 as *const _,
+                        1,
+                        0,
+                    )
+                };
+                return;
+            }
+            let _res = unsafe { libc::write(wakeup_fd as _, &sigbyte as *const u8 as *const _, 1) };
+            // TODO: handle _res < 1, support warn_on_full_buffer
+        }
+    }
+}
diff --git a/vm/src/stdlib/sre.rs b/crates/vm/src/stdlib/sre.rs
similarity index 99%
rename from vm/src/stdlib/sre.rs
rename to crates/vm/src/stdlib/sre.rs
index 33fc977f2c..04ff0695b6 100644
--- a/vm/src/stdlib/sre.rs
+++ b/crates/vm/src/stdlib/sre.rs
@@ -99,7 +99,7 @@ mod _sre {
         // re.Scanner has no official API and in CPython's implement
         // isbytes will be hanging (-1)
         // here is just a hack to let re.Scanner works only with str not bytes
-        let isbytes = !vm.is_none(&pattern) && !pattern.payload_is::<PyStr>();
+        let isbytes = !vm.is_none(&pattern) && !pattern.downcastable::<PyStr>();
         let code = code.try_to_value(vm)?;
         Ok(Pattern {
             pattern,
@@ -155,7 +155,7 @@ mod _sre {
 
         for trunk in trunks {
             let index: usize = trunk[0]
-                .payload::<PyInt>()
+                .downcast_ref::<PyInt>()
                 .ok_or_else(|| vm.new_type_error("expected usize"))?
                 .try_to_primitive(vm)?;
             items.push((index, trunk[1].clone()));
@@ -218,7 +218,7 @@ mod _sre {
         where
             F: FnOnce(&Wtf8) -> PyResult<R>,
         {
-            let string = string.payload::<PyStr>().ok_or_else(|| {
+            let string = string.downcast_ref::<PyStr>().ok_or_else(|| {
                 vm.new_type_error(format!("expected string got '{}'", string.class()))
             })?;
             f(string.as_wtf8())
@@ -554,7 +554,6 @@ mod _sre {
         #[inline]
         fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
             let flag_names = [
-                ("re.TEMPLATE", SreFlag::TEMPLATE),
                 ("re.IGNORECASE", SreFlag::IGNORECASE),
                 ("re.LOCALE", SreFlag::LOCALE),
                 ("re.MULTILINE", SreFlag::MULTILINE),
@@ -737,7 +736,6 @@ mod _sre {
             })
         }
 
-        #[pymethod]
         fn __getitem__(
             &self,
             group: PyObjectRef,
diff --git a/crates/vm/src/stdlib/stat.rs b/crates/vm/src/stdlib/stat.rs
new file mode 100644
index 0000000000..90f045fcaf
--- /dev/null
+++ b/crates/vm/src/stdlib/stat.rs
@@ -0,0 +1,528 @@
+use crate::{PyRef, VirtualMachine, builtins::PyModule};
+
+#[pymodule]
+mod stat {
+    // Use libc::mode_t for Mode to match the system's definition
+    #[cfg(unix)]
+    type Mode = libc::mode_t;
+    #[cfg(windows)]
+    type Mode = u16; // Windows does not have mode_t, but stat constants are u16
+    #[cfg(not(any(unix, windows)))]
+    type Mode = u32; // Fallback for unknown targets
+
+    // libc_const macro for conditional compilation
+    macro_rules! libc_const {
+        (#[cfg($cfg:meta)] $name:ident, $fallback:expr) => {{
+            #[cfg($cfg)]
+            {
+                libc::$name
+            }
+            #[cfg(not($cfg))]
+            {
+                $fallback
+            }
+        }};
+    }
+
+    #[pyattr]
+    pub const S_IFDIR: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFDIR,
+        0o040000
+    );
+
+    #[pyattr]
+    pub const S_IFCHR: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFCHR,
+        0o020000
+    );
+
+    #[pyattr]
+    pub const S_IFBLK: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFBLK,
+        0o060000
+    );
+
+    #[pyattr]
+    pub const S_IFREG: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFREG,
+        0o100000
+    );
+
+    #[pyattr]
+    pub const S_IFIFO: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFIFO,
+        0o010000
+    );
+
+    #[pyattr]
+    pub const S_IFLNK: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFLNK,
+        0o120000
+    );
+
+    #[pyattr]
+    pub const S_IFSOCK: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IFSOCK,
+        0o140000
+    );
+
+    #[pyattr]
+    pub const S_IFDOOR: Mode = 0; // TODO: RUSTPYTHON Support Solaris
+
+    #[pyattr]
+    pub const S_IFPORT: Mode = 0; // TODO: RUSTPYTHON Support Solaris
+
+    // TODO: RUSTPYTHON Support BSD
+    // https://man.freebsd.org/cgi/man.cgi?stat(2)
+
+    #[pyattr]
+    pub const S_IFWHT: Mode = if cfg!(target_os = "macos") {
+        0o160000
+    } else {
+        0
+    };
+
+    // Permission bits
+
+    #[pyattr]
+    pub const S_ISUID: Mode = libc_const!(
+        #[cfg(unix)]
+        S_ISUID,
+        0o4000
+    );
+
+    #[pyattr]
+    pub const S_ISGID: Mode = libc_const!(
+        #[cfg(unix)]
+        S_ISGID,
+        0o2000
+    );
+
+    #[pyattr]
+    pub const S_ENFMT: Mode = libc_const!(
+        #[cfg(unix)]
+        S_ISGID,
+        0o2000
+    );
+
+    #[pyattr]
+    pub const S_ISVTX: Mode = libc_const!(
+        #[cfg(unix)]
+        S_ISVTX,
+        0o1000
+    );
+
+    #[pyattr]
+    pub const S_IRWXU: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRWXU,
+        0o0700
+    );
+
+    #[pyattr]
+    pub const S_IRUSR: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRUSR,
+        0o0400
+    );
+
+    #[pyattr]
+    pub const S_IREAD: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRUSR,
+        0o0400
+    );
+
+    #[pyattr]
+    pub const S_IWUSR: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IWUSR,
+        0o0200
+    );
+
+    #[pyattr]
+    pub const S_IXUSR: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IXUSR,
+        0o0100
+    );
+
+    #[pyattr]
+    pub const S_IRWXG: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRWXG,
+        0o0070
+    );
+
+    #[pyattr]
+    pub const S_IRGRP: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRGRP,
+        0o0040
+    );
+
+    #[pyattr]
+    pub const S_IWGRP: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IWGRP,
+        0o0020
+    );
+
+    #[pyattr]
+    pub const S_IXGRP: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IXGRP,
+        0o0010
+    );
+
+    #[pyattr]
+    pub const S_IRWXO: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IRWXO,
+        0o0007
+    );
+
+    #[pyattr]
+    pub const S_IROTH: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IROTH,
+        0o0004
+    );
+
+    #[pyattr]
+    pub const S_IWOTH: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IWOTH,
+        0o0002
+    );
+
+    #[pyattr]
+    pub const S_IXOTH: Mode = libc_const!(
+        #[cfg(unix)]
+        S_IXOTH,
+        0o0001
+    );
+
+    #[pyattr]
+    pub const S_IWRITE: Mode = libc_const!(
+        #[cfg(all(unix, not(target_os = "android"), not(target_os = "redox")))]
+        S_IWRITE,
+        0o0200
+    );
+
+    #[pyattr]
+    pub const S_IEXEC: Mode = libc_const!(
+        #[cfg(all(unix, not(target_os = "android"), not(target_os = "redox")))]
+        S_IEXEC,
+        0o0100
+    );
+
+    // Windows file attributes (if on Windows)
+
+    #[cfg(windows)]
+    #[pyattr]
+    pub use windows_sys::Win32::Storage::FileSystem::{
+        FILE_ATTRIBUTE_ARCHIVE, FILE_ATTRIBUTE_COMPRESSED, FILE_ATTRIBUTE_DEVICE,
+        FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_ENCRYPTED, FILE_ATTRIBUTE_HIDDEN,
+        FILE_ATTRIBUTE_INTEGRITY_STREAM, FILE_ATTRIBUTE_NO_SCRUB_DATA, FILE_ATTRIBUTE_NORMAL,
+        FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, FILE_ATTRIBUTE_OFFLINE, FILE_ATTRIBUTE_READONLY,
+        FILE_ATTRIBUTE_REPARSE_POINT, FILE_ATTRIBUTE_SPARSE_FILE, FILE_ATTRIBUTE_SYSTEM,
+        FILE_ATTRIBUTE_TEMPORARY, FILE_ATTRIBUTE_VIRTUAL,
+    };
+
+    // Windows reparse point tags
+    #[cfg(windows)]
+    #[pyattr]
+    pub const IO_REPARSE_TAG_SYMLINK: u32 = 0xA000000C;
+    #[cfg(windows)]
+    #[pyattr]
+    pub const IO_REPARSE_TAG_MOUNT_POINT: u32 = 0xA0000003;
+    #[cfg(windows)]
+    #[pyattr]
+    pub const IO_REPARSE_TAG_APPEXECLINK: u32 = 0x8000001B;
+
+    // Unix file flags (if on Unix)
+
+    #[pyattr]
+    pub const UF_NODUMP: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_NODUMP,
+        0x00000001
+    );
+
+    #[pyattr]
+    pub const UF_IMMUTABLE: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_IMMUTABLE,
+        0x00000002
+    );
+
+    #[pyattr]
+    pub const UF_APPEND: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_APPEND,
+        0x00000004
+    );
+
+    #[pyattr]
+    pub const UF_OPAQUE: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_OPAQUE,
+        0x00000008
+    );
+
+    #[pyattr]
+    pub const UF_COMPRESSED: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_COMPRESSED,
+        0x00000020
+    );
+
+    #[pyattr]
+    pub const UF_HIDDEN: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        UF_HIDDEN,
+        0x00008000
+    );
+
+    #[pyattr]
+    pub const SF_ARCHIVED: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        SF_ARCHIVED,
+        0x00010000
+    );
+
+    #[pyattr]
+    pub const SF_IMMUTABLE: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        SF_IMMUTABLE,
+        0x00020000
+    );
+
+    #[pyattr]
+    pub const SF_APPEND: u32 = libc_const!(
+        #[cfg(target_os = "macos")]
+        SF_APPEND,
+        0x00040000
+    );
+
+    #[pyattr]
+    pub const SF_SETTABLE: u32 = if cfg!(target_os = "macos") {
+        0x3fff0000
+    } else {
+        0xffff0000
+    };
+
+    #[pyattr]
+    pub const UF_NOUNLINK: u32 = 0x00000010;
+
+    #[pyattr]
+    pub const SF_NOUNLINK: u32 = 0x00100000;
+
+    #[pyattr]
+    pub const SF_SNAPSHOT: u32 = 0x00200000;
+
+    #[pyattr]
+    pub const SF_FIRMLINK: u32 = 0x00800000;
+
+    #[pyattr]
+    pub const SF_DATALESS: u32 = 0x40000000;
+
+    // MacOS specific
+
+    #[cfg(target_os = "macos")]
+    #[pyattr]
+    pub const SF_SUPPORTED: u32 = 0x009f0000;
+
+    #[cfg(target_os = "macos")]
+    #[pyattr]
+    pub const SF_SYNTHETIC: u32 = 0xc0000000;
+
+    // Stat result indices
+
+    #[pyattr]
+    pub const ST_MODE: u32 = 0;
+
+    #[pyattr]
+    pub const ST_INO: u32 = 1;
+
+    #[pyattr]
+    pub const ST_DEV: u32 = 2;
+
+    #[pyattr]
+    pub const ST_NLINK: u32 = 3;
+
+    #[pyattr]
+    pub const ST_UID: u32 = 4;
+
+    #[pyattr]
+    pub const ST_GID: u32 = 5;
+
+    #[pyattr]
+    pub const ST_SIZE: u32 = 6;
+
+    #[pyattr]
+    pub const ST_ATIME: u32 = 7;
+
+    #[pyattr]
+    pub const ST_MTIME: u32 = 8;
+
+    #[pyattr]
+    pub const ST_CTIME: u32 = 9;
+
+    const S_IFMT: Mode = 0o170000;
+
+    const S_IMODE: Mode = 0o7777;
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISDIR(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFDIR
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISCHR(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFCHR
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISREG(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFREG
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISBLK(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFBLK
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISFIFO(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFIFO
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISLNK(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFLNK
+    }
+
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISSOCK(mode: Mode) -> bool {
+        (mode & S_IFMT) == S_IFSOCK
+    }
+
+    // TODO: RUSTPYTHON Support Solaris
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISDOOR(_mode: Mode) -> bool {
+        false
+    }
+
+    // TODO: RUSTPYTHON Support Solaris
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISPORT(_mode: Mode) -> bool {
+        false
+    }
+
+    // TODO: RUSTPYTHON Support BSD
+    #[pyfunction]
+    #[allow(non_snake_case)]
+    const fn S_ISWHT(_mode: Mode) -> bool {
+        false
+    }
+
+    #[pyfunction(name = "S_IMODE")]
+    #[allow(non_snake_case)]
+    const fn S_IMODE_method(mode: Mode) -> Mode {
+        mode & S_IMODE
+    }
+
+    #[pyfunction(name = "S_IFMT")]
+    #[allow(non_snake_case)]
+    const fn S_IFMT_method(mode: Mode) -> Mode {
+        // 0o170000 is from the S_IFMT definition in CPython include/fileutils.h
+        mode & S_IFMT
+    }
+
+    #[pyfunction]
+    const fn filetype(mode: Mode) -> char {
+        if S_ISREG(mode) {
+            '-'
+        } else if S_ISDIR(mode) {
+            'd'
+        } else if S_ISLNK(mode) {
+            'l'
+        } else if S_ISBLK(mode) {
+            'b'
+        } else if S_ISCHR(mode) {
+            'c'
+        } else if S_ISFIFO(mode) {
+            'p'
+        } else if S_ISSOCK(mode) {
+            's'
+        } else if S_ISDOOR(mode) {
+            'D' // TODO: RUSTPYTHON Support Solaris
+        } else if S_ISPORT(mode) {
+            'P' // TODO: RUSTPYTHON Support Solaris
+        } else if S_ISWHT(mode) {
+            'w' // TODO: RUSTPYTHON Support BSD
+        } else {
+            '?' // Unknown file type
+        }
+    }
+
+    // Convert file mode to string representation
+    #[pyfunction]
+    fn filemode(mode: Mode) -> String {
+        let mut result = String::with_capacity(10);
+
+        // File type
+        result.push(filetype(mode));
+
+        // User permissions
+        result.push(if mode & S_IRUSR != 0 { 'r' } else { '-' });
+        result.push(if mode & S_IWUSR != 0 { 'w' } else { '-' });
+        if mode & S_ISUID != 0 {
+            result.push(if mode & S_IXUSR != 0 { 's' } else { 'S' });
+        } else {
+            result.push(if mode & S_IXUSR != 0 { 'x' } else { '-' });
+        }
+
+        // Group permissions
+        result.push(if mode & S_IRGRP != 0 { 'r' } else { '-' });
+        result.push(if mode & S_IWGRP != 0 { 'w' } else { '-' });
+        if mode & S_ISGID != 0 {
+            result.push(if mode & S_IXGRP != 0 { 's' } else { 'S' });
+        } else {
+            result.push(if mode & S_IXGRP != 0 { 'x' } else { '-' });
+        }
+
+        // Other permissions
+        result.push(if mode & S_IROTH != 0 { 'r' } else { '-' });
+        result.push(if mode & S_IWOTH != 0 { 'w' } else { '-' });
+        if mode & S_ISVTX != 0 {
+            result.push(if mode & S_IXOTH != 0 { 't' } else { 'T' });
+        } else {
+            result.push(if mode & S_IXOTH != 0 { 'x' } else { '-' });
+        }
+
+        result
+    }
+}
+
+pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    stat::make_module(vm)
+}
diff --git a/crates/vm/src/stdlib/string.rs b/crates/vm/src/stdlib/string.rs
new file mode 100644
index 0000000000..a9911f3d45
--- /dev/null
+++ b/crates/vm/src/stdlib/string.rs
@@ -0,0 +1,99 @@
+/* String builtin module
+ */
+
+pub(crate) use _string::make_module;
+
+#[pymodule]
+mod _string {
+    use crate::common::ascii;
+    use crate::common::format::{
+        FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate,
+    };
+    use crate::common::wtf8::{CodePoint, Wtf8Buf};
+    use crate::{
+        PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyList, PyStrRef},
+        convert::ToPyException,
+        convert::ToPyObject,
+    };
+    use core::mem;
+
+    fn create_format_part(
+        literal: Wtf8Buf,
+        field_name: Option<Wtf8Buf>,
+        format_spec: Option<Wtf8Buf>,
+        conversion_spec: Option<CodePoint>,
+        vm: &VirtualMachine,
+    ) -> PyObjectRef {
+        let tuple = (
+            literal,
+            field_name,
+            format_spec,
+            conversion_spec.map(|c| c.to_string()),
+        );
+        tuple.to_pyobject(vm)
+    }
+
+    #[pyfunction]
+    fn formatter_parser(text: PyStrRef, vm: &VirtualMachine) -> PyResult<PyList> {
+        let format_string =
+            FormatString::from_str(text.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
+
+        let mut result: Vec<PyObjectRef> = Vec::new();
+        let mut literal = Wtf8Buf::new();
+        for part in format_string.format_parts {
+            match part {
+                FormatPart::Field {
+                    field_name,
+                    conversion_spec,
+                    format_spec,
+                } => {
+                    result.push(create_format_part(
+                        mem::take(&mut literal),
+                        Some(field_name),
+                        Some(format_spec),
+                        conversion_spec,
+                        vm,
+                    ));
+                }
+                FormatPart::Literal(text) => literal.push_wtf8(&text),
+            }
+        }
+        if !literal.is_empty() {
+            result.push(create_format_part(
+                mem::take(&mut literal),
+                None,
+                None,
+                None,
+                vm,
+            ));
+        }
+        Ok(result.into())
+    }
+
+    #[pyfunction]
+    fn formatter_field_name_split(
+        text: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<(PyObjectRef, PyList)> {
+        let field_name = FieldName::parse(text.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
+
+        let first = match field_name.field_type {
+            FieldType::Auto => vm.ctx.new_str(ascii!("")).into(),
+            FieldType::Index(index) => index.to_pyobject(vm),
+            FieldType::Keyword(attribute) => attribute.to_pyobject(vm),
+        };
+
+        let rest = field_name
+            .parts
+            .iter()
+            .map(|p| match p {
+                FieldNamePart::Attribute(attribute) => (true, attribute).to_pyobject(vm),
+                FieldNamePart::StringIndex(index) => (false, index).to_pyobject(vm),
+                FieldNamePart::Index(index) => (false, *index).to_pyobject(vm),
+            })
+            .collect();
+
+        Ok((first, rest))
+    }
+}
diff --git a/crates/vm/src/stdlib/symtable.rs b/crates/vm/src/stdlib/symtable.rs
new file mode 100644
index 0000000000..51c5c8e47e
--- /dev/null
+++ b/crates/vm/src/stdlib/symtable.rs
@@ -0,0 +1,316 @@
+pub(crate) use symtable::make_module;
+
+#[pymodule]
+mod symtable {
+    use crate::{
+        PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyStrRef},
+        compiler,
+    };
+    use alloc::fmt;
+    use rustpython_codegen::symboltable::{
+        CompilerScope, Symbol, SymbolFlags, SymbolScope, SymbolTable,
+    };
+
+    // Consts as defined at
+    // https://github.com/python/cpython/blob/6cb20a219a860eaf687b2d968b41c480c7461909/Include/internal/pycore_symtable.h#L156
+
+    #[pyattr]
+    pub const DEF_GLOBAL: i32 = 1;
+
+    #[pyattr]
+    pub const DEF_LOCAL: i32 = 2;
+
+    #[pyattr]
+    pub const DEF_PARAM: i32 = 2 << 1;
+
+    #[pyattr]
+    pub const DEF_NONLOCAL: i32 = 2 << 2;
+
+    #[pyattr]
+    pub const USE: i32 = 2 << 3;
+
+    #[pyattr]
+    pub const DEF_FREE: i32 = 2 << 4;
+
+    #[pyattr]
+    pub const DEF_FREE_CLASS: i32 = 2 << 5;
+
+    #[pyattr]
+    pub const DEF_IMPORT: i32 = 2 << 6;
+
+    #[pyattr]
+    pub const DEF_ANNOT: i32 = 2 << 7;
+
+    #[pyattr]
+    pub const DEF_COMP_ITER: i32 = 2 << 8;
+
+    #[pyattr]
+    pub const DEF_TYPE_PARAM: i32 = 2 << 9;
+
+    #[pyattr]
+    pub const DEF_COMP_CELL: i32 = 2 << 10;
+
+    #[pyattr]
+    pub const DEF_BOUND: i32 = DEF_LOCAL | DEF_PARAM | DEF_IMPORT;
+
+    #[pyattr]
+    pub const SCOPE_OFFSET: i32 = 12;
+
+    #[pyattr]
+    pub const SCOPE_MASK: i32 = DEF_GLOBAL | DEF_LOCAL | DEF_PARAM | DEF_NONLOCAL;
+
+    #[pyattr]
+    pub const LOCAL: i32 = 1;
+
+    #[pyattr]
+    pub const GLOBAL_EXPLICIT: i32 = 2;
+
+    #[pyattr]
+    pub const GLOBAL_IMPLICIT: i32 = 3;
+
+    #[pyattr]
+    pub const FREE: i32 = 4;
+
+    #[pyattr]
+    pub const CELL: i32 = 5;
+
+    #[pyattr]
+    pub const GENERATOR: i32 = 1;
+
+    #[pyattr]
+    pub const GENERATOR_EXPRESSION: i32 = 2;
+
+    #[pyattr]
+    pub const SCOPE_OFF: i32 = SCOPE_OFFSET;
+
+    #[pyattr]
+    pub const TYPE_FUNCTION: i32 = 0;
+
+    #[pyattr]
+    pub const TYPE_CLASS: i32 = 1;
+
+    #[pyattr]
+    pub const TYPE_MODULE: i32 = 2;
+
+    #[pyattr]
+    pub const TYPE_ANNOTATION: i32 = 3;
+
+    #[pyattr]
+    pub const TYPE_TYPE_VAR_BOUND: i32 = 4;
+
+    #[pyattr]
+    pub const TYPE_TYPE_ALIAS: i32 = 5;
+
+    #[pyattr]
+    pub const TYPE_TYPE_PARAMETERS: i32 = 6;
+
+    #[pyattr]
+    pub const TYPE_TYPE_VARIABLE: i32 = 7;
+
+    #[pyfunction]
+    fn symtable(
+        source: PyStrRef,
+        filename: PyStrRef,
+        mode: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<PySymbolTable>> {
+        let mode = mode
+            .as_str()
+            .parse::<compiler::Mode>()
+            .map_err(|err| vm.new_value_error(err.to_string()))?;
+
+        let symtable = compiler::compile_symtable(source.as_str(), mode, filename.as_str())
+            .map_err(|err| vm.new_syntax_error(&err, Some(source.as_str())))?;
+
+        let py_symbol_table = to_py_symbol_table(symtable);
+        Ok(py_symbol_table.into_ref(&vm.ctx))
+    }
+
+    const fn to_py_symbol_table(symtable: SymbolTable) -> PySymbolTable {
+        PySymbolTable { symtable }
+    }
+
+    #[pyattr]
+    #[pyclass(name = "SymbolTable")]
+    #[derive(PyPayload)]
+    struct PySymbolTable {
+        symtable: SymbolTable,
+    }
+
+    impl fmt::Debug for PySymbolTable {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(f, "SymbolTable()")
+        }
+    }
+
+    #[pyclass]
+    impl PySymbolTable {
+        #[pygetset]
+        fn name(&self) -> String {
+            self.symtable.name.clone()
+        }
+
+        #[pygetset(name = "type")]
+        fn typ(&self) -> i32 {
+            match self.symtable.typ {
+                CompilerScope::Function => TYPE_FUNCTION,
+                CompilerScope::Class => TYPE_CLASS,
+                CompilerScope::Module => TYPE_MODULE,
+                CompilerScope::TypeParams => TYPE_TYPE_PARAMETERS,
+                _ => -1, // TODO: missing types from the C implementation
+            }
+        }
+
+        #[pygetset]
+        const fn lineno(&self) -> u32 {
+            self.symtable.line_number
+        }
+
+        #[pygetset]
+        fn children(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+            let children = self
+                .symtable
+                .sub_tables
+                .iter()
+                .map(|t| to_py_symbol_table(t.clone()).into_pyobject(vm))
+                .collect();
+            Ok(children)
+        }
+
+        #[pygetset]
+        fn id(&self) -> usize {
+            self as *const Self as *const core::ffi::c_void as usize
+        }
+
+        #[pygetset]
+        fn identifiers(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+            let symbols = self
+                .symtable
+                .symbols
+                .keys()
+                .map(|s| vm.ctx.new_str(s.as_str()).into())
+                .collect();
+            Ok(symbols)
+        }
+
+        #[pygetset]
+        fn symbols(&self, vm: &VirtualMachine) -> PyResult<PyDictRef> {
+            let dict = vm.ctx.new_dict();
+            for (name, symbol) in &self.symtable.symbols {
+                dict.set_item(name, vm.new_pyobj(symbol.flags.bits()), vm)
+                    .unwrap();
+            }
+            Ok(dict)
+        }
+
+        #[pygetset]
+        const fn nested(&self) -> bool {
+            self.symtable.is_nested
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(name = "Symbol")]
+    #[derive(PyPayload)]
+    struct PySymbol {
+        symbol: Symbol,
+        namespaces: Vec<SymbolTable>,
+        is_top_scope: bool,
+    }
+
+    impl fmt::Debug for PySymbol {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            write!(f, "Symbol()")
+        }
+    }
+
+    #[pyclass]
+    impl PySymbol {
+        #[pymethod]
+        fn get_name(&self) -> String {
+            self.symbol.name.clone()
+        }
+
+        #[pymethod]
+        const fn is_global(&self) -> bool {
+            self.symbol.is_global() || (self.is_top_scope && self.symbol.is_bound())
+        }
+
+        #[pymethod]
+        const fn is_declared_global(&self) -> bool {
+            matches!(self.symbol.scope, SymbolScope::GlobalExplicit)
+        }
+
+        #[pymethod]
+        const fn is_local(&self) -> bool {
+            self.symbol.is_local() || (self.is_top_scope && self.symbol.is_bound())
+        }
+
+        #[pymethod]
+        const fn is_imported(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::IMPORTED)
+        }
+
+        #[pymethod]
+        const fn is_nested(&self) -> bool {
+            // TODO
+            false
+        }
+
+        #[pymethod]
+        const fn is_nonlocal(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::NONLOCAL)
+        }
+
+        #[pymethod]
+        const fn is_referenced(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::REFERENCED)
+        }
+
+        #[pymethod]
+        const fn is_assigned(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::ASSIGNED)
+        }
+
+        #[pymethod]
+        const fn is_parameter(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::PARAMETER)
+        }
+
+        #[pymethod]
+        const fn is_free(&self) -> bool {
+            matches!(self.symbol.scope, SymbolScope::Free)
+        }
+
+        #[pymethod]
+        const fn is_namespace(&self) -> bool {
+            !self.namespaces.is_empty()
+        }
+
+        #[pymethod]
+        const fn is_annotated(&self) -> bool {
+            self.symbol.flags.contains(SymbolFlags::ANNOTATED)
+        }
+
+        #[pymethod]
+        fn get_namespaces(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
+            let namespaces = self
+                .namespaces
+                .iter()
+                .map(|table| to_py_symbol_table(table.clone()).into_pyobject(vm))
+                .collect();
+            Ok(namespaces)
+        }
+
+        #[pymethod]
+        fn get_namespace(&self, vm: &VirtualMachine) -> PyResult {
+            if self.namespaces.len() != 1 {
+                return Err(vm.new_value_error("namespace is bound to multiple namespaces"));
+            }
+            Ok(to_py_symbol_table(self.namespaces.first().unwrap().clone())
+                .into_ref(&vm.ctx)
+                .into())
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/sys.rs b/crates/vm/src/stdlib/sys.rs
new file mode 100644
index 0000000000..8a65a926cb
--- /dev/null
+++ b/crates/vm/src/stdlib/sys.rs
@@ -0,0 +1,1608 @@
+use crate::{Py, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
+
+pub(crate) use sys::{
+    __module_def, DOC, MAXSIZE, RUST_MULTIARCH, UnraisableHookArgsData, multiarch,
+};
+
+#[pymodule]
+mod sys {
+    use crate::{
+        AsObject, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult,
+        builtins::{
+            PyBaseExceptionRef, PyDictRef, PyFrozenSet, PyNamespace, PyStr, PyStrRef, PyTupleRef,
+            PyTypeRef,
+        },
+        common::{
+            ascii,
+            hash::{PyHash, PyUHash},
+        },
+        convert::ToPyObject,
+        frame::FrameRef,
+        function::{FuncArgs, KwArgs, OptionalArg, PosArgs},
+        stdlib::{builtins, warnings::warn},
+        types::PyStructSequence,
+        version,
+        vm::{Settings, VirtualMachine},
+    };
+    use core::sync::atomic::Ordering;
+    use num_traits::ToPrimitive;
+    use std::{
+        env::{self, VarError},
+        io::Read,
+    };
+
+    #[cfg(windows)]
+    use windows_sys::Win32::{
+        Foundation::MAX_PATH,
+        Storage::FileSystem::{
+            GetFileVersionInfoSizeW, GetFileVersionInfoW, VS_FIXEDFILEINFO, VerQueryValueW,
+        },
+        System::LibraryLoader::{GetModuleFileNameW, GetModuleHandleW},
+    };
+
+    // Rust target triple (e.g., "x86_64-unknown-linux-gnu")
+    pub(crate) const RUST_MULTIARCH: &str = env!("RUSTPYTHON_TARGET_TRIPLE");
+
+    /// Convert Rust target triple to CPython-style multiarch
+    /// e.g., "x86_64-unknown-linux-gnu" -> "x86_64-linux-gnu"
+    pub(crate) fn multiarch() -> String {
+        RUST_MULTIARCH.replace("-unknown", "")
+    }
+
+    #[pyattr(name = "_rustpython_debugbuild")]
+    const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
+
+    #[pyattr(name = "abiflags")]
+    pub(crate) const ABIFLAGS: &str = "t"; // 't' for free-threaded (no GIL)
+    #[pyattr(name = "api_version")]
+    const API_VERSION: u32 = 0x0; // what C api?
+    #[pyattr(name = "copyright")]
+    const COPYRIGHT: &str = "Copyright (c) 2019 RustPython Team";
+    #[pyattr(name = "float_repr_style")]
+    const FLOAT_REPR_STYLE: &str = "short";
+    #[pyattr(name = "_framework")]
+    const FRAMEWORK: &str = "";
+    #[pyattr(name = "hexversion")]
+    const HEXVERSION: usize = version::VERSION_HEX;
+    #[pyattr(name = "maxsize")]
+    pub(crate) const MAXSIZE: isize = isize::MAX;
+    #[pyattr(name = "maxunicode")]
+    const MAXUNICODE: u32 = core::char::MAX as u32;
+    #[pyattr(name = "platform")]
+    pub(crate) const PLATFORM: &str = {
+        cfg_if::cfg_if! {
+            if #[cfg(target_os = "linux")] {
+                "linux"
+            } else if #[cfg(target_os = "android")] {
+                "android"
+            } else if #[cfg(target_os = "macos")] {
+                "darwin"
+            } else if #[cfg(target_os = "ios")] {
+                "ios"
+            } else if #[cfg(windows)] {
+                "win32"
+            } else if #[cfg(target_os = "wasi")] {
+                "wasi"
+            } else {
+                "unknown"
+            }
+        }
+    };
+    #[pyattr(name = "ps1")]
+    const PS1: &str = ">>>>> ";
+    #[pyattr(name = "ps2")]
+    const PS2: &str = "..... ";
+
+    #[cfg(windows)]
+    #[pyattr(name = "_vpath")]
+    const VPATH: Option<&'static str> = None; // TODO: actual VPATH value
+
+    #[cfg(windows)]
+    #[pyattr(name = "dllhandle")]
+    const DLLHANDLE: usize = 0;
+
+    #[pyattr]
+    fn prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.prefix.clone()
+    }
+    #[pyattr]
+    fn base_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_prefix.clone()
+    }
+    #[pyattr]
+    fn exec_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.exec_prefix.clone()
+    }
+    #[pyattr]
+    fn base_exec_prefix(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_exec_prefix.clone()
+    }
+    #[pyattr]
+    fn platlibdir(_vm: &VirtualMachine) -> &'static str {
+        option_env!("RUSTPYTHON_PLATLIBDIR").unwrap_or("lib")
+    }
+
+    // alphabetical order with segments of pyattr and others
+
+    #[pyattr]
+    fn argv(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        vm.state
+            .config
+            .settings
+            .argv
+            .iter()
+            .map(|arg| vm.ctx.new_str(arg.clone()).into())
+            .collect()
+    }
+
+    #[pyattr]
+    fn builtin_module_names(vm: &VirtualMachine) -> PyTupleRef {
+        let mut module_names: Vec<_> = vm.state.module_inits.keys().cloned().collect();
+        module_names.push("sys".into());
+        module_names.push("builtins".into());
+        module_names.sort();
+        vm.ctx.new_tuple(
+            module_names
+                .into_iter()
+                .map(|n| vm.ctx.new_str(n).into())
+                .collect(),
+        )
+    }
+
+    // List from cpython/Python/stdlib_module_names.h
+    const STDLIB_MODULE_NAMES: &[&str] = &[
+        "__future__",
+        "_abc",
+        "_aix_support",
+        "_android_support",
+        "_apple_support",
+        "_ast",
+        "_asyncio",
+        "_bisect",
+        "_blake2",
+        "_bz2",
+        "_codecs",
+        "_codecs_cn",
+        "_codecs_hk",
+        "_codecs_iso2022",
+        "_codecs_jp",
+        "_codecs_kr",
+        "_codecs_tw",
+        "_collections",
+        "_collections_abc",
+        "_colorize",
+        "_compat_pickle",
+        "_compression",
+        "_contextvars",
+        "_csv",
+        "_ctypes",
+        "_curses",
+        "_curses_panel",
+        "_datetime",
+        "_dbm",
+        "_decimal",
+        "_elementtree",
+        "_frozen_importlib",
+        "_frozen_importlib_external",
+        "_functools",
+        "_gdbm",
+        "_hashlib",
+        "_heapq",
+        "_imp",
+        "_interpchannels",
+        "_interpqueues",
+        "_interpreters",
+        "_io",
+        "_ios_support",
+        "_json",
+        "_locale",
+        "_lsprof",
+        "_lzma",
+        "_markupbase",
+        "_md5",
+        "_multibytecodec",
+        "_multiprocessing",
+        "_opcode",
+        "_opcode_metadata",
+        "_operator",
+        "_osx_support",
+        "_overlapped",
+        "_pickle",
+        "_posixshmem",
+        "_posixsubprocess",
+        "_py_abc",
+        "_pydatetime",
+        "_pydecimal",
+        "_pyio",
+        "_pylong",
+        "_pyrepl",
+        "_queue",
+        "_random",
+        "_scproxy",
+        "_sha1",
+        "_sha2",
+        "_sha3",
+        "_signal",
+        "_sitebuiltins",
+        "_socket",
+        "_sqlite3",
+        "_sre",
+        "_ssl",
+        "_stat",
+        "_statistics",
+        "_string",
+        "_strptime",
+        "_struct",
+        "_suggestions",
+        "_symtable",
+        "_sysconfig",
+        "_thread",
+        "_threading_local",
+        "_tkinter",
+        "_tokenize",
+        "_tracemalloc",
+        "_typing",
+        "_uuid",
+        "_warnings",
+        "_weakref",
+        "_weakrefset",
+        "_winapi",
+        "_wmi",
+        "_zoneinfo",
+        "abc",
+        "antigravity",
+        "argparse",
+        "array",
+        "ast",
+        "asyncio",
+        "atexit",
+        "base64",
+        "bdb",
+        "binascii",
+        "bisect",
+        "builtins",
+        "bz2",
+        "cProfile",
+        "calendar",
+        "cmath",
+        "cmd",
+        "code",
+        "codecs",
+        "codeop",
+        "collections",
+        "colorsys",
+        "compileall",
+        "concurrent",
+        "configparser",
+        "contextlib",
+        "contextvars",
+        "copy",
+        "copyreg",
+        "csv",
+        "ctypes",
+        "curses",
+        "dataclasses",
+        "datetime",
+        "dbm",
+        "decimal",
+        "difflib",
+        "dis",
+        "doctest",
+        "email",
+        "encodings",
+        "ensurepip",
+        "enum",
+        "errno",
+        "faulthandler",
+        "fcntl",
+        "filecmp",
+        "fileinput",
+        "fnmatch",
+        "fractions",
+        "ftplib",
+        "functools",
+        "gc",
+        "genericpath",
+        "getopt",
+        "getpass",
+        "gettext",
+        "glob",
+        "graphlib",
+        "grp",
+        "gzip",
+        "hashlib",
+        "heapq",
+        "hmac",
+        "html",
+        "http",
+        "idlelib",
+        "imaplib",
+        "importlib",
+        "inspect",
+        "io",
+        "ipaddress",
+        "itertools",
+        "json",
+        "keyword",
+        "linecache",
+        "locale",
+        "logging",
+        "lzma",
+        "mailbox",
+        "marshal",
+        "math",
+        "mimetypes",
+        "mmap",
+        "modulefinder",
+        "msvcrt",
+        "multiprocessing",
+        "netrc",
+        "nt",
+        "ntpath",
+        "nturl2path",
+        "numbers",
+        "opcode",
+        "operator",
+        "optparse",
+        "os",
+        "pathlib",
+        "pdb",
+        "pickle",
+        "pickletools",
+        "pkgutil",
+        "platform",
+        "plistlib",
+        "poplib",
+        "posix",
+        "posixpath",
+        "pprint",
+        "profile",
+        "pstats",
+        "pty",
+        "pwd",
+        "py_compile",
+        "pyclbr",
+        "pydoc",
+        "pydoc_data",
+        "pyexpat",
+        "queue",
+        "quopri",
+        "random",
+        "re",
+        "readline",
+        "reprlib",
+        "resource",
+        "rlcompleter",
+        "runpy",
+        "sched",
+        "secrets",
+        "select",
+        "selectors",
+        "shelve",
+        "shlex",
+        "shutil",
+        "signal",
+        "site",
+        "smtplib",
+        "socket",
+        "socketserver",
+        "sqlite3",
+        "sre_compile",
+        "sre_constants",
+        "sre_parse",
+        "ssl",
+        "stat",
+        "statistics",
+        "string",
+        "stringprep",
+        "struct",
+        "subprocess",
+        "symtable",
+        "sys",
+        "sysconfig",
+        "syslog",
+        "tabnanny",
+        "tarfile",
+        "tempfile",
+        "termios",
+        "textwrap",
+        "this",
+        "threading",
+        "time",
+        "timeit",
+        "tkinter",
+        "token",
+        "tokenize",
+        "tomllib",
+        "trace",
+        "traceback",
+        "tracemalloc",
+        "tty",
+        "turtle",
+        "turtledemo",
+        "types",
+        "typing",
+        "unicodedata",
+        "unittest",
+        "urllib",
+        "uuid",
+        "venv",
+        "warnings",
+        "wave",
+        "weakref",
+        "webbrowser",
+        "winreg",
+        "winsound",
+        "wsgiref",
+        "xml",
+        "xmlrpc",
+        "zipapp",
+        "zipfile",
+        "zipimport",
+        "zlib",
+        "zoneinfo",
+    ];
+
+    #[pyattr(once)]
+    fn stdlib_module_names(vm: &VirtualMachine) -> PyObjectRef {
+        let names = STDLIB_MODULE_NAMES
+            .iter()
+            .map(|&n| vm.ctx.new_str(n).into());
+        PyFrozenSet::from_iter(vm, names)
+            .expect("Creating stdlib_module_names frozen set must succeed")
+            .to_pyobject(vm)
+    }
+
+    #[pyattr]
+    fn byteorder(vm: &VirtualMachine) -> PyStrRef {
+        // https://doc.rust-lang.org/reference/conditional-compilation.html#target_endian
+        vm.ctx
+            .intern_str(if cfg!(target_endian = "little") {
+                "little"
+            } else if cfg!(target_endian = "big") {
+                "big"
+            } else {
+                "unknown"
+            })
+            .to_owned()
+    }
+
+    #[pyattr]
+    fn _base_executable(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.base_executable.clone()
+    }
+
+    #[pyattr]
+    fn dont_write_bytecode(vm: &VirtualMachine) -> bool {
+        !vm.state.config.settings.write_bytecode
+    }
+
+    #[pyattr]
+    fn executable(vm: &VirtualMachine) -> String {
+        vm.state.config.paths.executable.clone()
+    }
+
+    #[pyattr]
+    fn _git(vm: &VirtualMachine) -> PyTupleRef {
+        vm.new_tuple((
+            ascii!("RustPython"),
+            version::get_git_identifier(),
+            version::get_git_revision(),
+        ))
+    }
+
+    #[pyattr]
+    fn implementation(vm: &VirtualMachine) -> PyRef<PyNamespace> {
+        const NAME: &str = "rustpython";
+
+        let cache_tag = format!("{NAME}-{}{}", version::MAJOR, version::MINOR);
+        let ctx = &vm.ctx;
+        py_namespace!(vm, {
+            "name" => ctx.new_str(NAME),
+            "cache_tag" => ctx.new_str(cache_tag),
+            "_multiarch" => ctx.new_str(multiarch()),
+            "version" => version_info(vm),
+            "hexversion" => ctx.new_int(version::VERSION_HEX),
+        })
+    }
+
+    #[pyattr]
+    const fn meta_path(_vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        Vec::new()
+    }
+
+    #[pyattr]
+    fn orig_argv(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        env::args().map(|arg| vm.ctx.new_str(arg).into()).collect()
+    }
+
+    #[pyattr]
+    fn path(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        vm.state
+            .config
+            .paths
+            .module_search_paths
+            .iter()
+            .map(|path| vm.ctx.new_str(path.clone()).into())
+            .collect()
+    }
+
+    #[pyattr]
+    const fn path_hooks(_vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        Vec::new()
+    }
+
+    #[pyattr]
+    fn path_importer_cache(vm: &VirtualMachine) -> PyDictRef {
+        vm.ctx.new_dict()
+    }
+
+    #[pyattr]
+    fn pycache_prefix(vm: &VirtualMachine) -> PyObjectRef {
+        vm.ctx.none()
+    }
+
+    #[pyattr]
+    fn version(_vm: &VirtualMachine) -> String {
+        version::get_version()
+    }
+
+    #[cfg(windows)]
+    #[pyattr]
+    fn winver(_vm: &VirtualMachine) -> String {
+        // Note: This is Python DLL version in CPython, but we arbitrary fill it for compatibility
+        version::get_winver_number()
+    }
+
+    #[pyattr]
+    fn _xoptions(vm: &VirtualMachine) -> PyDictRef {
+        let ctx = &vm.ctx;
+        let xopts = ctx.new_dict();
+        for (key, value) in &vm.state.config.settings.xoptions {
+            let value = value.as_ref().map_or_else(
+                || ctx.new_bool(true).into(),
+                |s| ctx.new_str(s.clone()).into(),
+            );
+            xopts.set_item(&**key, value, vm).unwrap();
+        }
+        xopts
+    }
+
+    #[pyattr]
+    fn warnoptions(vm: &VirtualMachine) -> Vec<PyObjectRef> {
+        vm.state
+            .config
+            .settings
+            .warnoptions
+            .iter()
+            .map(|s| vm.ctx.new_str(s.clone()).into())
+            .collect()
+    }
+
+    #[cfg(feature = "rustpython-compiler")]
+    #[pyfunction]
+    fn _baserepl(vm: &VirtualMachine) -> PyResult<()> {
+        // read stdin to end
+        let stdin = std::io::stdin();
+        let mut handle = stdin.lock();
+        let mut source = String::new();
+        handle
+            .read_to_string(&mut source)
+            .map_err(|e| vm.new_os_error(format!("Error reading from stdin: {e}")))?;
+        vm.compile(&source, crate::compiler::Mode::Single, "<stdin>".to_owned())
+            .map_err(|e| vm.new_os_error(format!("Error running stdin: {e}")))?;
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn audit(_args: FuncArgs) {
+        // TODO: sys.audit implementation
+    }
+
+    #[pyfunction]
+    const fn _is_gil_enabled() -> bool {
+        false // RustPython has no GIL (like free-threaded Python)
+    }
+
+    #[pyfunction]
+    fn exit(code: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
+        let code = code.unwrap_or_none(vm);
+        Err(vm.new_exception(vm.ctx.exceptions.system_exit.to_owned(), vec![code]))
+    }
+
+    #[pyfunction]
+    fn exception(vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
+        vm.topmost_exception()
+    }
+
+    #[pyfunction(name = "__displayhook__")]
+    #[pyfunction]
+    fn displayhook(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Save non-None values as "_"
+        if vm.is_none(&obj) {
+            return Ok(());
+        }
+        // set to none to avoid recursion while printing
+        vm.builtins.set_attr("_", vm.ctx.none(), vm)?;
+        // TODO: catch encoding errors
+        let repr = obj.repr(vm)?.into();
+        builtins::print(PosArgs::new(vec![repr]), Default::default(), vm)?;
+        vm.builtins.set_attr("_", obj, vm)?;
+        Ok(())
+    }
+
+    #[pyfunction(name = "__excepthook__")]
+    #[pyfunction]
+    fn excepthook(
+        exc_type: PyObjectRef,
+        exc_val: PyObjectRef,
+        exc_tb: PyObjectRef,
+        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),
+            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"
+                );
+                use crate::py_io::Write;
+                write!(&mut crate::py_io::PyWriter(stderr, vm), "{msg}")?;
+                Ok(())
+            }
+        }
+    }
+
+    #[pyfunction(name = "__breakpointhook__")]
+    #[pyfunction]
+    pub fn breakpointhook(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let env_var = std::env::var("PYTHONBREAKPOINT")
+            .and_then(|env_var| {
+                if env_var.is_empty() {
+                    Err(VarError::NotPresent)
+                } else {
+                    Ok(env_var)
+                }
+            })
+            .unwrap_or_else(|_| "pdb.set_trace".to_owned());
+
+        if env_var.eq("0") {
+            return Ok(vm.ctx.none());
+        };
+
+        let print_unimportable_module_warn = || {
+            warn(
+                vm.ctx.exceptions.runtime_warning,
+                format!("Ignoring unimportable $PYTHONBREAKPOINT: \"{env_var}\"",),
+                0,
+                vm,
+            )
+            .unwrap();
+            Ok(vm.ctx.none())
+        };
+
+        let last = match env_var.rsplit_once('.') {
+            Some((_, last)) => last,
+            None if !env_var.is_empty() => env_var.as_str(),
+            _ => return print_unimportable_module_warn(),
+        };
+
+        let (module_path, attr_name) = if last == env_var {
+            ("builtins", env_var.as_str())
+        } else {
+            (&env_var[..(env_var.len() - last.len() - 1)], last)
+        };
+
+        let module = match vm.import(&vm.ctx.new_str(module_path), 0) {
+            Ok(module) => module,
+            Err(_) => {
+                return print_unimportable_module_warn();
+            }
+        };
+
+        match vm.get_attribute_opt(module, &vm.ctx.new_str(attr_name)) {
+            Ok(Some(hook)) => hook.as_ref().call(args, vm),
+            _ => print_unimportable_module_warn(),
+        }
+    }
+
+    #[pyfunction]
+    fn exc_info(vm: &VirtualMachine) -> (PyObjectRef, PyObjectRef, PyObjectRef) {
+        match vm.topmost_exception() {
+            Some(exception) => vm.split_exception(exception),
+            None => (vm.ctx.none(), vm.ctx.none(), vm.ctx.none()),
+        }
+    }
+
+    #[pyattr]
+    fn flags(vm: &VirtualMachine) -> PyTupleRef {
+        PyFlags::from_data(FlagsData::from_settings(&vm.state.config.settings), vm)
+    }
+
+    #[pyattr]
+    fn float_info(vm: &VirtualMachine) -> PyTupleRef {
+        PyFloatInfo::from_data(FloatInfoData::INFO, vm)
+    }
+
+    #[pyfunction]
+    const fn getdefaultencoding() -> &'static str {
+        crate::codecs::DEFAULT_ENCODING
+    }
+
+    #[pyfunction]
+    fn getrefcount(obj: PyObjectRef) -> usize {
+        obj.strong_count()
+    }
+
+    #[pyfunction]
+    fn getrecursionlimit(vm: &VirtualMachine) -> usize {
+        vm.recursion_limit.get()
+    }
+
+    #[derive(FromArgs)]
+    struct GetsizeofArgs {
+        obj: PyObjectRef,
+        #[pyarg(any, optional)]
+        default: Option<PyObjectRef>,
+    }
+
+    #[pyfunction]
+    fn getsizeof(args: GetsizeofArgs, vm: &VirtualMachine) -> PyResult {
+        let sizeof = || -> PyResult<usize> {
+            let res = vm.call_special_method(&args.obj, identifier!(vm, __sizeof__), ())?;
+            let res = res.try_index(vm)?.try_to_primitive::<usize>(vm)?;
+            Ok(res + core::mem::size_of::<PyObject>())
+        };
+        sizeof()
+            .map(|x| vm.ctx.new_int(x).into())
+            .or_else(|err| args.default.ok_or(err))
+    }
+
+    #[pyfunction]
+    fn getfilesystemencoding(vm: &VirtualMachine) -> PyStrRef {
+        vm.fs_encoding().to_owned()
+    }
+
+    #[pyfunction]
+    fn getfilesystemencodeerrors(vm: &VirtualMachine) -> PyStrRef {
+        vm.fs_encode_errors().to_owned()
+    }
+
+    #[pyfunction]
+    fn getprofile(vm: &VirtualMachine) -> PyObjectRef {
+        vm.profile_func.borrow().clone()
+    }
+
+    #[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 {
+            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())
+    }
+
+    #[pyfunction]
+    fn _getframemodulename(depth: OptionalArg<usize>, vm: &VirtualMachine) -> PyResult {
+        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];
+
+        // If the frame has a function object, return its __module__ attribute
+        if let Some(func_obj) = &frame.func_obj {
+            match func_obj.get_attr(identifier!(vm, __module__), vm) {
+                Ok(module) => Ok(module),
+                Err(_) => {
+                    // CPython clears the error and returns None
+                    Ok(vm.ctx.none())
+                }
+            }
+        } else {
+            Ok(vm.ctx.none())
+        }
+    }
+
+    /// Return a dictionary mapping each thread's identifier to the topmost stack frame
+    /// currently active in that thread at the time the function is called.
+    #[cfg(feature = "threading")]
+    #[pyfunction]
+    fn _current_frames(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        use crate::AsObject;
+        use crate::stdlib::thread::get_all_current_frames;
+
+        let frames = get_all_current_frames(vm);
+        let dict = vm.ctx.new_dict();
+
+        for (thread_id, frame) in frames {
+            let key = vm.ctx.new_int(thread_id);
+            dict.set_item(key.as_object(), frame.into(), vm)?;
+        }
+
+        Ok(dict)
+    }
+
+    /// Stub for non-threading builds - returns empty dict
+    #[cfg(not(feature = "threading"))]
+    #[pyfunction]
+    fn _current_frames(vm: &VirtualMachine) -> PyResult<PyDictRef> {
+        Ok(vm.ctx.new_dict())
+    }
+
+    #[pyfunction]
+    fn gettrace(vm: &VirtualMachine) -> PyObjectRef {
+        vm.trace_func.borrow().clone()
+    }
+
+    #[cfg(windows)]
+    fn get_kernel32_version() -> std::io::Result<(u32, u32, u32)> {
+        use crate::common::windows::ToWideString;
+        unsafe {
+            // Create a wide string for "kernel32.dll"
+            let module_name: Vec<u16> = std::ffi::OsStr::new("kernel32.dll").to_wide_with_nul();
+            let h_kernel32 = GetModuleHandleW(module_name.as_ptr());
+            if h_kernel32.is_null() {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // Prepare a buffer for the module file path
+            let mut kernel32_path = [0u16; MAX_PATH as usize];
+            let len = GetModuleFileNameW(
+                h_kernel32,
+                kernel32_path.as_mut_ptr(),
+                kernel32_path.len() as u32,
+            );
+            if len == 0 {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // Get the size of the version information block
+            let ver_block_size =
+                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), std::ptr::null_mut());
+            if ver_block_size == 0 {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // Allocate a buffer to hold the version information
+            let mut ver_block = vec![0u8; ver_block_size as usize];
+            if GetFileVersionInfoW(
+                kernel32_path.as_ptr(),
+                0,
+                ver_block_size,
+                ver_block.as_mut_ptr() as *mut _,
+            ) == 0
+            {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // 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_len: u32 = 0;
+            if VerQueryValueW(
+                ver_block.as_ptr() as *const _,
+                sub_block.as_ptr(),
+                &mut ffi_ptr as *mut *mut VS_FIXEDFILEINFO as *mut *mut _,
+                &mut ffi_len as *mut u32,
+            ) == 0
+                || ffi_ptr.is_null()
+            {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // Extract the version numbers from the VS_FIXEDFILEINFO structure.
+            let ffi = *ffi_ptr;
+            let real_major = (ffi.dwProductVersionMS >> 16) & 0xFFFF;
+            let real_minor = ffi.dwProductVersionMS & 0xFFFF;
+            let real_build = (ffi.dwProductVersionLS >> 16) & 0xFFFF;
+
+            Ok((real_major, real_minor, real_build))
+        }
+    }
+
+    #[cfg(windows)]
+    #[pyfunction]
+    fn getwindowsversion(vm: &VirtualMachine) -> PyResult<crate::builtins::tuple::PyTupleRef> {
+        use std::ffi::OsString;
+        use std::os::windows::ffi::OsStringExt;
+        use windows_sys::Win32::System::SystemInformation::{
+            GetVersionExW, OSVERSIONINFOEXW, OSVERSIONINFOW,
+        };
+
+        let mut version: OSVERSIONINFOEXW = unsafe { std::mem::zeroed() };
+        version.dwOSVersionInfoSize = std::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.
+            // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getversionexw#parameters
+            GetVersionExW(os_vi)
+        };
+
+        if result == 0 {
+            return Err(vm.new_os_error("failed to get windows version".to_owned()));
+        }
+
+        let service_pack = {
+            let (last, _) = version
+                .szCSDVersion
+                .iter()
+                .take_while(|&x| x != &0)
+                .enumerate()
+                .last()
+                .unwrap_or((0, &0));
+            let sp = OsString::from_wide(&version.szCSDVersion[..last]);
+            sp.into_string()
+                .map_err(|_| vm.new_os_error("service pack is not ASCII".to_owned()))?
+        };
+        let real_version = get_kernel32_version().map_err(|e| vm.new_os_error(e.to_string()))?;
+        let winver = WindowsVersionData {
+            major: real_version.0,
+            minor: real_version.1,
+            build: real_version.2,
+            platform: version.dwPlatformId,
+            service_pack,
+            service_pack_major: version.wServicePackMajor,
+            service_pack_minor: version.wServicePackMinor,
+            suite_mask: version.wSuiteMask,
+            product_type: version.wProductType,
+            platform_version: (real_version.0, real_version.1, real_version.2), // TODO Provide accurate version, like CPython impl
+        };
+        Ok(PyWindowsVersion::from_data(winver, vm))
+    }
+
+    fn _unraisablehook(unraisable: UnraisableHookArgsData, vm: &VirtualMachine) -> PyResult<()> {
+        use super::PyStderr;
+
+        let stderr = PyStderr(vm);
+        if !vm.is_none(&unraisable.object) {
+            if !vm.is_none(&unraisable.err_msg) {
+                write!(stderr, "{}: ", unraisable.err_msg.str(vm)?);
+            } else {
+                write!(stderr, "Exception ignored in: ");
+            }
+            // exception in del will be ignored but printed
+            let repr = &unraisable.object.repr(vm);
+            let str = match repr {
+                Ok(v) => v.to_string(),
+                Err(_) => format!(
+                    "<object {} repr() failed>",
+                    unraisable.object.class().name()
+                ),
+            };
+            writeln!(stderr, "{str}");
+        } else if !vm.is_none(&unraisable.err_msg) {
+            writeln!(stderr, "{}:", unraisable.err_msg.str(vm)?);
+        }
+
+        // Print traceback (using actual exc_traceback, not current stack)
+        if !vm.is_none(&unraisable.exc_traceback) {
+            let tb_module = vm.import("traceback", 0)?;
+            let print_tb = tb_module.get_attr("print_tb", vm)?;
+            let stderr_obj = super::get_stderr(vm)?;
+            let kwargs: KwArgs = [("file".to_string(), stderr_obj)].into_iter().collect();
+            let _ = print_tb.call(
+                FuncArgs::new(vec![unraisable.exc_traceback.clone()], kwargs),
+                vm,
+            );
+        }
+
+        // Check exc_type
+        if vm.is_none(unraisable.exc_type.as_object()) {
+            return Ok(());
+        }
+        assert!(
+            unraisable
+                .exc_type
+                .fast_issubclass(vm.ctx.exceptions.base_exception_type)
+        );
+
+        // Print module name (if not builtins or __main__)
+        let module_name = unraisable.exc_type.__module__(vm);
+        if let Ok(module_str) = module_name.downcast::<PyStr>() {
+            let module = module_str.as_str();
+            if module != "builtins" && module != "__main__" {
+                write!(stderr, "{}.", module);
+            }
+        } else {
+            write!(stderr, "<unknown>.");
+        }
+
+        // Print qualname
+        let qualname = unraisable.exc_type.__qualname__(vm);
+        if let Ok(qualname_str) = qualname.downcast::<PyStr>() {
+            write!(stderr, "{}", qualname_str.as_str());
+        } else {
+            write!(stderr, "{}", unraisable.exc_type.name());
+        }
+
+        // Print exception value
+        if !vm.is_none(&unraisable.exc_value) {
+            write!(stderr, ": ");
+            if let Ok(str) = unraisable.exc_value.str(vm) {
+                write!(stderr, "{}", str.to_str().unwrap_or("<str with surrogate>"));
+            } else {
+                write!(stderr, "<exception str() failed>");
+            }
+        }
+        writeln!(stderr);
+
+        // Flush stderr
+        if let Ok(stderr_obj) = super::get_stderr(vm)
+            && let Ok(flush) = stderr_obj.get_attr("flush", vm)
+        {
+            let _ = flush.call((), vm);
+        }
+
+        Ok(())
+    }
+
+    #[pyattr]
+    #[pyfunction(name = "__unraisablehook__")]
+    fn unraisablehook(unraisable: UnraisableHookArgsData, vm: &VirtualMachine) {
+        if let Err(e) = _unraisablehook(unraisable, vm) {
+            let stderr = super::PyStderr(vm);
+            writeln!(
+                stderr,
+                "{}",
+                e.as_object()
+                    .repr(vm)
+                    .unwrap_or_else(|_| vm.ctx.empty_str.to_owned())
+            );
+        }
+    }
+
+    #[pyattr]
+    fn hash_info(vm: &VirtualMachine) -> PyTupleRef {
+        PyHashInfo::from_data(HashInfoData::INFO, vm)
+    }
+
+    #[pyfunction]
+    fn intern(s: PyRefExact<PyStr>, vm: &VirtualMachine) -> PyRef<PyStr> {
+        vm.ctx.intern_str(s).to_owned()
+    }
+
+    #[pyattr]
+    fn int_info(vm: &VirtualMachine) -> PyTupleRef {
+        PyIntInfo::from_data(IntInfoData::INFO, vm)
+    }
+
+    #[pyfunction]
+    fn get_int_max_str_digits(vm: &VirtualMachine) -> usize {
+        vm.state.int_max_str_digits.load()
+    }
+
+    #[pyfunction]
+    fn set_int_max_str_digits(maxdigits: usize, vm: &VirtualMachine) -> PyResult<()> {
+        let threshold = IntInfoData::INFO.str_digits_check_threshold;
+        if maxdigits == 0 || maxdigits >= threshold {
+            vm.state.int_max_str_digits.store(maxdigits);
+            Ok(())
+        } else {
+            let error = format!("maxdigits must be 0 or larger than {threshold:?}");
+            Err(vm.new_value_error(error))
+        }
+    }
+
+    #[pyfunction]
+    fn is_finalizing(vm: &VirtualMachine) -> bool {
+        vm.state.finalizing.load(Ordering::Acquire)
+    }
+
+    #[pyfunction]
+    fn setprofile(profilefunc: PyObjectRef, vm: &VirtualMachine) {
+        vm.profile_func.replace(profilefunc);
+        update_use_tracing(vm);
+    }
+
+    #[pyfunction]
+    fn setrecursionlimit(recursion_limit: i32, vm: &VirtualMachine) -> PyResult<()> {
+        let recursion_limit = recursion_limit
+            .to_usize()
+            .filter(|&u| u >= 1)
+            .ok_or_else(|| {
+                vm.new_value_error("recursion limit must be greater than or equal to one")
+            })?;
+        let recursion_depth = vm.current_recursion_depth();
+
+        if recursion_limit > recursion_depth {
+            vm.recursion_limit.set(recursion_limit);
+            Ok(())
+        } else {
+            Err(vm.new_recursion_error(format!(
+                "cannot set the recursion limit to {recursion_limit} at the recursion depth {recursion_depth}: the limit is too low"
+            )))
+        }
+    }
+
+    #[pyfunction]
+    fn settrace(tracefunc: PyObjectRef, vm: &VirtualMachine) {
+        vm.trace_func.replace(tracefunc);
+        update_use_tracing(vm);
+    }
+
+    #[pyfunction]
+    fn _settraceallthreads(tracefunc: PyObjectRef, vm: &VirtualMachine) {
+        let func = (!vm.is_none(&tracefunc)).then(|| tracefunc.clone());
+        *vm.state.global_trace_func.lock() = func;
+        vm.trace_func.replace(tracefunc);
+        update_use_tracing(vm);
+    }
+
+    #[pyfunction]
+    fn _setprofileallthreads(profilefunc: PyObjectRef, vm: &VirtualMachine) {
+        let func = (!vm.is_none(&profilefunc)).then(|| profilefunc.clone());
+        *vm.state.global_profile_func.lock() = func;
+        vm.profile_func.replace(profilefunc);
+        update_use_tracing(vm);
+    }
+
+    #[cfg(feature = "threading")]
+    #[pyattr]
+    fn thread_info(vm: &VirtualMachine) -> PyTupleRef {
+        PyThreadInfo::from_data(ThreadInfoData::INFO, vm)
+    }
+
+    #[pyattr]
+    fn version_info(vm: &VirtualMachine) -> PyTupleRef {
+        PyVersionInfo::from_data(VersionInfoData::VERSION, vm)
+    }
+
+    fn update_use_tracing(vm: &VirtualMachine) {
+        let trace_is_none = vm.is_none(&vm.trace_func.borrow());
+        let profile_is_none = vm.is_none(&vm.profile_func.borrow());
+        let tracing = !(trace_is_none && profile_is_none);
+        vm.use_tracing.set(tracing);
+    }
+
+    #[pyfunction]
+    fn set_coroutine_origin_tracking_depth(depth: i32, vm: &VirtualMachine) -> PyResult<()> {
+        if depth < 0 {
+            return Err(vm.new_value_error("depth must be >= 0"));
+        }
+        crate::vm::thread::COROUTINE_ORIGIN_TRACKING_DEPTH.set(depth as u32);
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn get_coroutine_origin_tracking_depth() -> i32 {
+        crate::vm::thread::COROUTINE_ORIGIN_TRACKING_DEPTH.get() as i32
+    }
+
+    #[pyfunction]
+    fn getswitchinterval(vm: &VirtualMachine) -> f64 {
+        // Return the stored switch interval
+        vm.state.switch_interval.load()
+    }
+
+    // TODO: vm.state.switch_interval is currently not used anywhere in the VM
+    #[pyfunction]
+    fn setswitchinterval(interval: f64, vm: &VirtualMachine) -> PyResult<()> {
+        // Validate the interval parameter like CPython does
+        if interval <= 0.0 {
+            return Err(vm.new_value_error("switch interval must be strictly positive"));
+        }
+
+        // Store the switch interval value
+        vm.state.switch_interval.store(interval);
+        Ok(())
+    }
+
+    #[derive(FromArgs)]
+    struct SetAsyncgenHooksArgs {
+        #[pyarg(any, optional)]
+        firstiter: OptionalArg<Option<PyObjectRef>>,
+        #[pyarg(any, optional)]
+        finalizer: OptionalArg<Option<PyObjectRef>>,
+    }
+
+    #[pyfunction]
+    fn set_asyncgen_hooks(args: SetAsyncgenHooksArgs, vm: &VirtualMachine) -> PyResult<()> {
+        if let Some(Some(finalizer)) = args.finalizer.as_option()
+            && !finalizer.is_callable()
+        {
+            return Err(vm.new_type_error(format!(
+                "callable finalizer expected, got {:.50}",
+                finalizer.class().name()
+            )));
+        }
+
+        if let Some(Some(firstiter)) = args.firstiter.as_option()
+            && !firstiter.is_callable()
+        {
+            return Err(vm.new_type_error(format!(
+                "callable firstiter expected, got {:.50}",
+                firstiter.class().name()
+            )));
+        }
+
+        if let Some(finalizer) = args.finalizer.into_option() {
+            *vm.async_gen_finalizer.borrow_mut() = finalizer;
+        }
+        if let Some(firstiter) = args.firstiter.into_option() {
+            *vm.async_gen_firstiter.borrow_mut() = firstiter;
+        }
+
+        Ok(())
+    }
+
+    #[pystruct_sequence_data]
+    pub(super) struct AsyncgenHooksData {
+        firstiter: PyObjectRef,
+        finalizer: PyObjectRef,
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "asyncgen_hooks", data = "AsyncgenHooksData")]
+    pub(super) struct PyAsyncgenHooks;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyAsyncgenHooks {}
+
+    #[pyfunction]
+    fn get_asyncgen_hooks(vm: &VirtualMachine) -> AsyncgenHooksData {
+        AsyncgenHooksData {
+            firstiter: vm.async_gen_firstiter.borrow().clone().to_pyobject(vm),
+            finalizer: vm.async_gen_finalizer.borrow().clone().to_pyobject(vm),
+        }
+    }
+
+    /// sys.flags
+    ///
+    /// Flags provided through command line arguments or environment vars.
+    #[derive(Debug)]
+    #[pystruct_sequence_data]
+    pub(super) struct FlagsData {
+        /// -d
+        debug: u8,
+        /// -i
+        inspect: u8,
+        /// -i
+        interactive: u8,
+        /// -O or -OO
+        optimize: u8,
+        /// -B
+        dont_write_bytecode: u8,
+        /// -s
+        no_user_site: u8,
+        /// -S
+        no_site: u8,
+        /// -E
+        ignore_environment: u8,
+        /// -v
+        verbose: u8,
+        /// -b
+        bytes_warning: u64,
+        /// -q
+        quiet: u8,
+        /// -R
+        hash_randomization: u8,
+        /// -I
+        isolated: u8,
+        /// -X dev
+        dev_mode: bool,
+        /// -X utf8
+        utf8_mode: u8,
+        /// -X int_max_str_digits=number
+        int_max_str_digits: i64,
+        /// -P, `PYTHONSAFEPATH`
+        safe_path: bool,
+        /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
+        warn_default_encoding: u8,
+    }
+
+    impl FlagsData {
+        const fn from_settings(settings: &Settings) -> Self {
+            Self {
+                debug: settings.debug,
+                inspect: settings.inspect as u8,
+                interactive: settings.interactive as u8,
+                optimize: settings.optimize,
+                dont_write_bytecode: (!settings.write_bytecode) as u8,
+                no_user_site: (!settings.user_site_directory) as u8,
+                no_site: (!settings.import_site) as u8,
+                ignore_environment: settings.ignore_environment as u8,
+                verbose: settings.verbose,
+                bytes_warning: settings.bytes_warning,
+                quiet: settings.quiet as u8,
+                hash_randomization: settings.hash_seed.is_none() as u8,
+                isolated: settings.isolated as u8,
+                dev_mode: settings.dev_mode,
+                utf8_mode: settings.utf8_mode,
+                int_max_str_digits: settings.int_max_str_digits,
+                safe_path: settings.safe_path,
+                warn_default_encoding: settings.warn_default_encoding as u8,
+            }
+        }
+    }
+
+    #[pystruct_sequence(name = "flags", module = "sys", data = "FlagsData", no_attr)]
+    pub(super) struct PyFlags;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyFlags {
+        #[pyslot]
+        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error("cannot create 'sys.flags' instances"))
+        }
+    }
+
+    #[cfg(feature = "threading")]
+    #[pystruct_sequence_data]
+    pub(super) struct ThreadInfoData {
+        name: Option<&'static str>,
+        lock: Option<&'static str>,
+        version: Option<&'static str>,
+    }
+
+    #[cfg(feature = "threading")]
+    impl ThreadInfoData {
+        const INFO: Self = Self {
+            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"),
+            version: None,
+        };
+    }
+
+    #[cfg(feature = "threading")]
+    #[pystruct_sequence(name = "thread_info", data = "ThreadInfoData", no_attr)]
+    pub(super) struct PyThreadInfo;
+
+    #[cfg(feature = "threading")]
+    #[pyclass(with(PyStructSequence))]
+    impl PyThreadInfo {}
+
+    #[pystruct_sequence_data]
+    pub(super) struct FloatInfoData {
+        max: f64,
+        max_exp: i32,
+        max_10_exp: i32,
+        min: f64,
+        min_exp: i32,
+        min_10_exp: i32,
+        dig: u32,
+        mant_dig: u32,
+        epsilon: f64,
+        radix: u32,
+        rounds: i32,
+    }
+
+    impl FloatInfoData {
+        const INFO: Self = Self {
+            max: f64::MAX,
+            max_exp: f64::MAX_EXP,
+            max_10_exp: f64::MAX_10_EXP,
+            min: f64::MIN_POSITIVE,
+            min_exp: f64::MIN_EXP,
+            min_10_exp: f64::MIN_10_EXP,
+            dig: f64::DIGITS,
+            mant_dig: f64::MANTISSA_DIGITS,
+            epsilon: f64::EPSILON,
+            radix: f64::RADIX,
+            rounds: 1, // FE_TONEAREST
+        };
+    }
+
+    #[pystruct_sequence(name = "float_info", data = "FloatInfoData", no_attr)]
+    pub(super) struct PyFloatInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyFloatInfo {}
+
+    #[pystruct_sequence_data]
+    pub(super) struct HashInfoData {
+        width: usize,
+        modulus: PyUHash,
+        inf: PyHash,
+        nan: PyHash,
+        imag: PyHash,
+        algorithm: &'static str,
+        hash_bits: usize,
+        seed_bits: usize,
+        cutoff: usize,
+    }
+
+    impl HashInfoData {
+        const INFO: Self = {
+            use rustpython_common::hash::*;
+            Self {
+                width: core::mem::size_of::<PyHash>() * 8,
+                modulus: MODULUS,
+                inf: INF,
+                nan: NAN,
+                imag: IMAG,
+                algorithm: ALGO,
+                hash_bits: HASH_BITS,
+                seed_bits: SEED_BITS,
+                cutoff: 0, // no small string optimizations
+            }
+        };
+    }
+
+    #[pystruct_sequence(name = "hash_info", data = "HashInfoData", no_attr)]
+    pub(super) struct PyHashInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyHashInfo {}
+
+    #[pystruct_sequence_data]
+    pub(super) struct IntInfoData {
+        bits_per_digit: usize,
+        sizeof_digit: usize,
+        default_max_str_digits: usize,
+        str_digits_check_threshold: usize,
+    }
+
+    impl IntInfoData {
+        const INFO: Self = Self {
+            bits_per_digit: 30, //?
+            sizeof_digit: core::mem::size_of::<u32>(),
+            default_max_str_digits: 4300,
+            str_digits_check_threshold: 640,
+        };
+    }
+
+    #[pystruct_sequence(name = "int_info", data = "IntInfoData", no_attr)]
+    pub(super) struct PyIntInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyIntInfo {}
+
+    #[derive(Default, Debug)]
+    #[pystruct_sequence_data]
+    pub struct VersionInfoData {
+        major: usize,
+        minor: usize,
+        micro: usize,
+        releaselevel: &'static str,
+        serial: usize,
+    }
+
+    impl VersionInfoData {
+        pub const VERSION: Self = Self {
+            major: version::MAJOR,
+            minor: version::MINOR,
+            micro: version::MICRO,
+            releaselevel: version::RELEASELEVEL,
+            serial: version::SERIAL,
+        };
+    }
+
+    #[pystruct_sequence(name = "version_info", data = "VersionInfoData", no_attr)]
+    pub struct PyVersionInfo;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyVersionInfo {
+        #[pyslot]
+        fn slot_new(
+            _cls: crate::builtins::type_::PyTypeRef,
+            _args: crate::function::FuncArgs,
+            vm: &crate::VirtualMachine,
+        ) -> crate::PyResult {
+            Err(vm.new_type_error("cannot create 'sys.version_info' instances"))
+        }
+    }
+
+    #[cfg(windows)]
+    #[derive(Default, Debug)]
+    #[pystruct_sequence_data]
+    pub(super) struct WindowsVersionData {
+        major: u32,
+        minor: u32,
+        build: u32,
+        platform: u32,
+        service_pack: String,
+        service_pack_major: u16,
+        service_pack_minor: u16,
+        suite_mask: u16,
+        product_type: u8,
+        platform_version: (u32, u32, u32),
+    }
+
+    #[cfg(windows)]
+    #[pystruct_sequence(name = "getwindowsversion", data = "WindowsVersionData", no_attr)]
+    pub(super) struct PyWindowsVersion;
+
+    #[cfg(windows)]
+    #[pyclass(with(PyStructSequence))]
+    impl PyWindowsVersion {}
+
+    #[derive(Debug)]
+    #[pystruct_sequence_data(try_from_object)]
+    pub struct UnraisableHookArgsData {
+        pub exc_type: PyTypeRef,
+        pub exc_value: PyObjectRef,
+        pub exc_traceback: PyObjectRef,
+        pub err_msg: PyObjectRef,
+        pub object: PyObjectRef,
+    }
+
+    #[pystruct_sequence(name = "UnraisableHookArgs", data = "UnraisableHookArgsData", no_attr)]
+    pub struct PyUnraisableHookArgs;
+
+    #[pyclass(with(PyStructSequence))]
+    impl PyUnraisableHookArgs {}
+}
+
+pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins: &Py<PyModule>) {
+    sys::extend_module(vm, module).unwrap();
+
+    let modules = vm.ctx.new_dict();
+    modules
+        .set_item("sys", module.to_owned().into(), vm)
+        .unwrap();
+    modules
+        .set_item("builtins", builtins.to_owned().into(), vm)
+        .unwrap();
+    extend_module!(vm, module, {
+        "__doc__" => sys::DOC.to_owned().to_pyobject(vm),
+        "modules" => modules,
+    });
+}
+
+/// Similar to PySys_WriteStderr in CPython.
+///
+/// # Usage
+///
+/// ```rust,ignore
+/// writeln!(sys::PyStderr(vm), "foo bar baz :)");
+/// ```
+///
+/// Unlike writing to a `std::io::Write` with the `write[ln]!()` macro, there's no error condition here;
+/// this is intended to be a replacement for the `eprint[ln]!()` macro, so `write!()`-ing to PyStderr just
+/// returns `()`.
+pub struct PyStderr<'vm>(pub &'vm VirtualMachine);
+
+impl PyStderr<'_> {
+    pub fn write_fmt(&self, args: core::fmt::Arguments<'_>) {
+        use crate::py_io::Write;
+
+        let vm = self.0;
+        if let Ok(stderr) = get_stderr(vm) {
+            let mut stderr = crate::py_io::PyWriter(stderr, vm);
+            if let Ok(()) = stderr.write_fmt(args) {
+                return;
+            }
+        }
+        eprint!("{args}")
+    }
+}
+
+pub fn get_stdin(vm: &VirtualMachine) -> PyResult {
+    vm.sys_module
+        .get_attr("stdin", vm)
+        .map_err(|_| vm.new_runtime_error("lost sys.stdin"))
+}
+pub fn get_stdout(vm: &VirtualMachine) -> PyResult {
+    vm.sys_module
+        .get_attr("stdout", vm)
+        .map_err(|_| vm.new_runtime_error("lost sys.stdout"))
+}
+pub fn get_stderr(vm: &VirtualMachine) -> PyResult {
+    vm.sys_module
+        .get_attr("stderr", vm)
+        .map_err(|_| vm.new_runtime_error("lost sys.stderr"))
+}
+
+pub(crate) fn sysconfigdata_name() -> String {
+    format!(
+        "_sysconfigdata_{}_{}_{}",
+        sys::ABIFLAGS,
+        sys::PLATFORM,
+        sys::multiarch()
+    )
+}
diff --git a/crates/vm/src/stdlib/sysconfig.rs b/crates/vm/src/stdlib/sysconfig.rs
new file mode 100644
index 0000000000..df5b7100a9
--- /dev/null
+++ b/crates/vm/src/stdlib/sysconfig.rs
@@ -0,0 +1,25 @@
+pub(crate) use sysconfig::make_module;
+
+#[pymodule(name = "_sysconfig")]
+pub(crate) mod sysconfig {
+    use crate::{VirtualMachine, builtins::PyDictRef, convert::ToPyObject};
+
+    #[pyfunction]
+    fn config_vars(vm: &VirtualMachine) -> PyDictRef {
+        let vars = vm.ctx.new_dict();
+
+        // FIXME: This is an entirely wrong implementation of EXT_SUFFIX.
+        // EXT_SUFFIX must be a string starting with "." for pip compatibility
+        // Using ".pyd" causes pip's _generic_abi() to fall back to _cpython_abis()
+        vars.set_item("EXT_SUFFIX", ".pyd".to_pyobject(vm), vm)
+            .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)
+            .unwrap();
+
+        vars
+    }
+}
diff --git a/crates/vm/src/stdlib/sysconfigdata.rs b/crates/vm/src/stdlib/sysconfigdata.rs
new file mode 100644
index 0000000000..99228024d2
--- /dev/null
+++ b/crates/vm/src/stdlib/sysconfigdata.rs
@@ -0,0 +1,47 @@
+// spell-checker: words LDSHARED ARFLAGS CPPFLAGS CCSHARED BASECFLAGS BLDSHARED
+
+pub(crate) use _sysconfigdata::make_module;
+
+#[pymodule]
+pub(crate) mod _sysconfigdata {
+    use crate::stdlib::sys::{RUST_MULTIARCH, multiarch};
+    use crate::{VirtualMachine, builtins::PyDictRef, convert::ToPyObject};
+
+    #[pyattr]
+    fn build_time_vars(vm: &VirtualMachine) -> PyDictRef {
+        let vars = vm.ctx.new_dict();
+        let multiarch = multiarch();
+        macro_rules! sysvars {
+            ($($key:literal => $value:expr),*$(,)?) => {{
+                $(vars.set_item($key, $value.to_pyobject(vm), vm).unwrap();)*
+            }};
+        }
+        sysvars! {
+            // Extension module suffix in CPython-compatible format
+            "EXT_SUFFIX" => format!(".rustpython313-{multiarch}.so"),
+            "MULTIARCH" => multiarch.clone(),
+            "RUST_MULTIARCH" => RUST_MULTIARCH,
+            // enough for tests to stop expecting urandom() to fail after restricting file resources
+            "HAVE_GETRANDOM" => 1,
+            // RustPython has no GIL (like free-threaded Python)
+            "Py_GIL_DISABLED" => 1,
+            // Compiler configuration for native extension builds
+            "CC" => "cc",
+            "CXX" => "c++",
+            "CFLAGS" => "",
+            "CPPFLAGS" => "",
+            "LDFLAGS" => "",
+            "LDSHARED" => "cc -shared",
+            "CCSHARED" => "",
+            "SHLIB_SUFFIX" => ".so",
+            "SO" => ".so",
+            "AR" => "ar",
+            "ARFLAGS" => "rcs",
+            "OPT" => "",
+            "BASECFLAGS" => "",
+            "BLDSHARED" => "cc -shared",
+        }
+        include!(concat!(env!("OUT_DIR"), "/env_vars.rs"));
+        vars
+    }
+}
diff --git a/crates/vm/src/stdlib/thread.rs b/crates/vm/src/stdlib/thread.rs
new file mode 100644
index 0000000000..db588e5eab
--- /dev/null
+++ b/crates/vm/src/stdlib/thread.rs
@@ -0,0 +1,1213 @@
+//! Implementation of the _thread module
+#[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
+pub(crate) use _thread::{
+    CurrentFrameSlot, HandleEntry, RawRMutex, ShutdownEntry, after_fork_child,
+    get_all_current_frames, get_ident, init_main_thread_ident, make_module,
+};
+
+#[pymodule]
+pub(crate) mod _thread {
+    use crate::{
+        AsObject, Py, PyPayload, PyRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyStr, PyStrRef, PyTupleRef, PyType, PyTypeRef},
+        frame::FrameRef,
+        function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
+        types::{Constructor, GetAttr, Representable, SetAttr},
+    };
+    use alloc::fmt;
+    use core::{cell::RefCell, time::Duration};
+    use crossbeam_utils::atomic::AtomicCell;
+    use parking_lot::{
+        RawMutex, RawThreadId,
+        lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
+    };
+    use std::thread;
+
+    // PYTHREAD_NAME: show current thread name
+    pub const PYTHREAD_NAME: Option<&str> = {
+        cfg_if::cfg_if! {
+            if #[cfg(windows)] {
+                Some("nt")
+            } else if #[cfg(unix)] {
+                Some("pthread")
+            } else if #[cfg(any(target_os = "solaris", target_os = "illumos"))] {
+                Some("solaris")
+            } else {
+                None
+            }
+        }
+    };
+
+    // TIMEOUT_MAX_IN_MICROSECONDS is a value in microseconds
+    #[cfg(not(target_os = "windows"))]
+    const TIMEOUT_MAX_IN_MICROSECONDS: i64 = i64::MAX / 1_000;
+
+    #[cfg(target_os = "windows")]
+    const TIMEOUT_MAX_IN_MICROSECONDS: i64 = 0xffffffff * 1_000;
+
+    // this is a value in seconds
+    #[pyattr]
+    const TIMEOUT_MAX: f64 = (TIMEOUT_MAX_IN_MICROSECONDS / 1_000_000) as f64;
+
+    #[pyattr]
+    fn error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.exceptions.runtime_error.to_owned()
+    }
+
+    #[derive(FromArgs)]
+    struct AcquireArgs {
+        #[pyarg(any, default = true)]
+        blocking: bool,
+        #[pyarg(any, default = Either::A(-1.0))]
+        timeout: Either<f64, i64>,
+    }
+
+    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,
+            };
+            match args.blocking {
+                true if timeout == -1.0 => {
+                    mu.lock();
+                    Ok(true)
+                }
+                true if timeout < 0.0 => {
+                    Err(vm.new_value_error("timeout value must be positive".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(),
+                        ));
+                    }
+
+                    Ok(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())),
+                false => Ok(mu.try_lock()),
+            }
+        }};
+    }
+    macro_rules! repr_lock_impl {
+        ($zelf:expr) => {{
+            let status = if $zelf.mu.is_locked() {
+                "locked"
+            } else {
+                "unlocked"
+            };
+            Ok(format!(
+                "<{} {} object at {:#x}>",
+                status,
+                $zelf.class().name(),
+                $zelf.get_id()
+            ))
+        }};
+    }
+
+    #[pyattr(name = "LockType")]
+    #[pyattr(name = "lock")]
+    #[pyclass(module = "_thread", name = "lock")]
+    #[derive(PyPayload)]
+    struct Lock {
+        mu: RawMutex,
+    }
+
+    impl fmt::Debug for Lock {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("Lock")
+        }
+    }
+
+    #[pyclass(with(Constructor, Representable))]
+    impl Lock {
+        #[pymethod]
+        #[pymethod(name = "acquire_lock")]
+        #[pymethod(name = "__enter__")]
+        fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
+            acquire_lock_impl!(&self.mu, args, vm)
+        }
+        #[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"));
+            }
+            unsafe { self.mu.unlock() };
+            Ok(())
+        }
+
+        #[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);
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.release(vm)
+        }
+
+        #[pymethod]
+        fn locked(&self) -> bool {
+            self.mu.is_locked()
+        }
+    }
+
+    impl Constructor for Lock {
+        type Args = ();
+
+        fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+            Ok(Self { mu: RawMutex::INIT })
+        }
+    }
+
+    impl Representable for Lock {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            repr_lock_impl!(zelf)
+        }
+    }
+
+    pub type RawRMutex = RawReentrantMutex<RawMutex, RawThreadId>;
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "RLock")]
+    #[derive(PyPayload)]
+    struct RLock {
+        mu: RawRMutex,
+        count: core::sync::atomic::AtomicUsize,
+    }
+
+    impl fmt::Debug for RLock {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("RLock")
+        }
+    }
+
+    #[pyclass(with(Representable), flags(BASETYPE))]
+    impl RLock {
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Self {
+                mu: RawRMutex::INIT,
+                count: core::sync::atomic::AtomicUsize::new(0),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+        }
+
+        #[pymethod]
+        #[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 {
+                self.count
+                    .fetch_add(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"));
+            }
+            debug_assert!(
+                self.count.load(core::sync::atomic::Ordering::Relaxed) > 0,
+                "RLock count underflow"
+            );
+            self.count
+                .fetch_sub(1, core::sync::atomic::Ordering::Relaxed);
+            unsafe { self.mu.unlock() };
+            Ok(())
+        }
+
+        #[pymethod]
+        fn _at_fork_reinit(&self, _vm: &VirtualMachine) -> PyResult<()> {
+            if self.mu.is_locked() {
+                unsafe {
+                    self.mu.unlock();
+                };
+            }
+            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);
+            }
+
+            Ok(())
+        }
+
+        #[pymethod]
+        fn locked(&self) -> bool {
+            self.mu.is_locked()
+        }
+
+        #[pymethod]
+        fn _is_owned(&self) -> bool {
+            self.mu.is_owned_by_current_thread()
+        }
+
+        #[pymethod]
+        fn _recursion_count(&self) -> usize {
+            if self.mu.is_owned_by_current_thread() {
+                self.count.load(core::sync::atomic::Ordering::Relaxed)
+            } else {
+                0
+            }
+        }
+
+        #[pymethod]
+        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            self.release(vm)
+        }
+    }
+
+    impl Representable for RLock {
+        #[inline]
+        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
+            repr_lock_impl!(zelf)
+        }
+    }
+
+    /// Get thread identity - uses pthread_self() on Unix for fork compatibility
+    #[pyfunction]
+    pub fn get_ident() -> u64 {
+        current_thread_id()
+    }
+
+    /// Set the name of the current thread
+    #[pyfunction]
+    fn set_name(name: PyStrRef) {
+        #[cfg(target_os = "linux")]
+        {
+            use std::ffi::CString;
+            if let Ok(c_name) = CString::new(name.as_str()) {
+                // pthread_setname_np on Linux has a 16-byte limit including null terminator
+                // TODO: Potential UTF-8 boundary issue when truncating thread name on Linux.
+                // https://github.com/RustPython/RustPython/pull/6726/changes#r2689379171
+                let truncated = if c_name.as_bytes().len() > 15 {
+                    CString::new(&c_name.as_bytes()[..15]).unwrap_or(c_name)
+                } else {
+                    c_name
+                };
+                unsafe {
+                    libc::pthread_setname_np(libc::pthread_self(), truncated.as_ptr());
+                }
+            }
+        }
+        #[cfg(target_os = "macos")]
+        {
+            use std::ffi::CString;
+            if let Ok(c_name) = CString::new(name.as_str()) {
+                unsafe {
+                    libc::pthread_setname_np(c_name.as_ptr());
+                }
+            }
+        }
+        #[cfg(windows)]
+        {
+            // Windows doesn't have a simple pthread_setname_np equivalent
+            // SetThreadDescription requires Windows 10+
+            let _ = name;
+        }
+        #[cfg(not(any(target_os = "linux", target_os = "macos", windows)))]
+        {
+            let _ = name;
+        }
+    }
+
+    /// Get OS-level thread ID (pthread_self on Unix)
+    /// This is important for fork compatibility - the ID must remain stable after fork
+    #[cfg(unix)]
+    fn current_thread_id() -> u64 {
+        // pthread_self() like CPython for fork compatibility
+        unsafe { libc::pthread_self() as u64 }
+    }
+
+    #[cfg(not(unix))]
+    fn current_thread_id() -> u64 {
+        thread_to_rust_id(&thread::current())
+    }
+
+    /// Convert Rust thread to ID (used for non-unix platforms)
+    #[cfg(not(unix))]
+    fn thread_to_rust_id(t: &thread::Thread) -> u64 {
+        use core::hash::{Hash, Hasher};
+        struct U64Hash {
+            v: Option<u64>,
+        }
+        impl Hasher for U64Hash {
+            fn write(&mut self, _: &[u8]) {
+                unreachable!()
+            }
+            fn write_u64(&mut self, i: u64) {
+                self.v = Some(i);
+            }
+            fn finish(&self) -> u64 {
+                self.v.expect("should have written a u64")
+            }
+        }
+        let mut h = U64Hash { v: None };
+        t.id().hash(&mut h);
+        h.finish()
+    }
+
+    /// Get thread ID for a given thread handle (used by start_new_thread)
+    fn thread_to_id(handle: &thread::JoinHandle<()>) -> u64 {
+        #[cfg(unix)]
+        {
+            // On Unix, use pthread ID from the handle
+            use std::os::unix::thread::JoinHandleExt;
+            handle.as_pthread_t() as u64
+        }
+        #[cfg(not(unix))]
+        {
+            thread_to_rust_id(handle.thread())
+        }
+    }
+
+    #[pyfunction]
+    const fn allocate_lock() -> Lock {
+        Lock { mu: RawMutex::INIT }
+    }
+
+    #[pyfunction]
+    fn start_new_thread(
+        func: ArgCallable,
+        args: PyTupleRef,
+        kwargs: OptionalArg<PyDictRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<u64> {
+        let args = FuncArgs::new(
+            args.to_vec(),
+            kwargs
+                .map_or_else(Default::default, |k| k.to_attributes(vm))
+                .into_iter()
+                .map(|(k, v)| (k.as_str().to_owned(), v))
+                .collect::<KwArgs>(),
+        );
+        let mut thread_builder = thread::Builder::new();
+        let stacksize = vm.state.stacksize.load();
+        if stacksize != 0 {
+            thread_builder = thread_builder.stack_size(stacksize);
+        }
+        thread_builder
+            .spawn(
+                vm.new_thread()
+                    .make_spawn_func(move |vm| run_thread(func, args, vm)),
+            )
+            .map(|handle| {
+                vm.state.thread_count.fetch_add(1);
+                thread_to_id(&handle)
+            })
+            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))
+    }
+
+    fn run_thread(func: ArgCallable, args: FuncArgs, vm: &VirtualMachine) {
+        match func.invoke(args, vm) {
+            Ok(_obj) => {}
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.system_exit) => {}
+            Err(exc) => {
+                vm.run_unraisable(
+                    exc,
+                    Some("Exception ignored in thread started by".to_owned()),
+                    func.into(),
+                );
+            }
+        }
+        for lock in SENTINELS.take() {
+            if lock.mu.is_locked() {
+                unsafe { lock.mu.unlock() };
+            }
+        }
+        // Clean up thread-local storage while VM context is still active
+        // This ensures __del__ methods are called properly
+        cleanup_thread_local_data();
+        // Clean up frame tracking
+        crate::vm::thread::cleanup_current_thread_frames(vm);
+        vm.state.thread_count.fetch_sub(1);
+    }
+
+    /// Clean up thread-local data for the current thread.
+    /// This triggers __del__ on objects stored in thread-local variables.
+    fn cleanup_thread_local_data() {
+        // Take all guards - this will trigger LocalGuard::drop for each,
+        // which removes the thread's dict from each Local instance
+        LOCAL_GUARDS.with(|guards| {
+            guards.borrow_mut().clear();
+        });
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyfunction]
+    fn interrupt_main(signum: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<()> {
+        crate::signal::set_interrupt_ex(signum.unwrap_or(libc::SIGINT), vm)
+    }
+
+    #[pyfunction]
+    fn exit(vm: &VirtualMachine) -> PyResult {
+        Err(vm.new_exception_empty(vm.ctx.exceptions.system_exit.to_owned()))
+    }
+
+    thread_local!(static SENTINELS: RefCell<Vec<PyRef<Lock>>> = const { RefCell::new(Vec::new()) });
+
+    #[pyfunction]
+    fn _set_sentinel(vm: &VirtualMachine) -> PyRef<Lock> {
+        let lock = Lock { mu: RawMutex::INIT }.into_ref(&vm.ctx);
+        SENTINELS.with_borrow_mut(|sentinels| sentinels.push(lock.clone()));
+        lock
+    }
+
+    #[pyfunction]
+    fn stack_size(size: OptionalArg<usize>, vm: &VirtualMachine) -> usize {
+        let size = size.unwrap_or(0);
+        // TODO: do validation on this to make sure it's not too small
+        vm.state.stacksize.swap(size)
+    }
+
+    #[pyfunction]
+    fn _count(vm: &VirtualMachine) -> usize {
+        vm.state.thread_count.load()
+    }
+
+    #[pyfunction]
+    fn daemon_threads_allowed() -> bool {
+        // RustPython always allows daemon threads
+        true
+    }
+
+    // Registry for non-daemon threads that need to be joined at shutdown
+    pub type ShutdownEntry = (
+        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    );
+
+    #[pyfunction]
+    fn _shutdown(vm: &VirtualMachine) {
+        // Wait for all non-daemon threads to finish
+        let current_ident = get_ident();
+
+        loop {
+            // Find a thread that's not finished and not the current thread
+            let handle_to_join = {
+                let mut handles = vm.state.shutdown_handles.lock();
+                // Clean up finished entries
+                handles.retain(|(inner_weak, _): &ShutdownEntry| {
+                    inner_weak.upgrade().is_some_and(|inner| {
+                        let guard = inner.lock();
+                        guard.state != ThreadHandleState::Done && guard.ident != current_ident
+                    })
+                });
+
+                // Find first unfinished handle
+                handles
+                    .iter()
+                    .find_map(|(inner_weak, done_event_weak): &ShutdownEntry| {
+                        let inner = inner_weak.upgrade()?;
+                        let done_event = done_event_weak.upgrade()?;
+                        let guard = inner.lock();
+                        if guard.state != ThreadHandleState::Done && guard.ident != current_ident {
+                            Some((inner.clone(), done_event.clone()))
+                        } else {
+                            None
+                        }
+                    })
+            };
+
+            match handle_to_join {
+                Some((_, done_event)) => {
+                    // Wait for this thread to finish (infinite timeout)
+                    // Only check done flag to avoid lock ordering issues
+                    // (done_event lock vs inner lock)
+                    let (lock, cvar) = &*done_event;
+                    let mut done = lock.lock();
+                    while !*done {
+                        cvar.wait(&mut done);
+                    }
+                }
+                None => break, // No more threads to wait on
+            }
+        }
+    }
+
+    /// Add a non-daemon thread handle to the shutdown registry
+    fn add_to_shutdown_handles(
+        vm: &VirtualMachine,
+        inner: &std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        done_event: &std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    ) {
+        let mut handles = vm.state.shutdown_handles.lock();
+        handles.push((
+            std::sync::Arc::downgrade(inner),
+            std::sync::Arc::downgrade(done_event),
+        ));
+    }
+
+    #[pyfunction]
+    fn _make_thread_handle(ident: u64, vm: &VirtualMachine) -> PyRef<ThreadHandle> {
+        let handle = ThreadHandle::new(vm);
+        {
+            let mut inner = handle.inner.lock();
+            inner.ident = ident;
+            inner.state = ThreadHandleState::Running;
+        }
+        handle.into_ref(&vm.ctx)
+    }
+
+    #[pyfunction]
+    fn _get_main_thread_ident(vm: &VirtualMachine) -> u64 {
+        vm.state.main_thread_ident.load()
+    }
+
+    #[pyfunction]
+    fn _is_main_interpreter() -> bool {
+        // RustPython only has one interpreter
+        true
+    }
+
+    /// Initialize the main thread ident. Should be called once at interpreter startup.
+    pub fn init_main_thread_ident(vm: &VirtualMachine) {
+        let ident = get_ident();
+        vm.state.main_thread_ident.store(ident);
+    }
+
+    /// ExceptHookArgs - simple class to hold exception hook arguments
+    /// This allows threading.py to import _excepthook and _ExceptHookArgs from _thread
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "_ExceptHookArgs")]
+    #[derive(Debug, PyPayload)]
+    struct ExceptHookArgs {
+        exc_type: crate::PyObjectRef,
+        exc_value: crate::PyObjectRef,
+        exc_traceback: crate::PyObjectRef,
+        thread: crate::PyObjectRef,
+    }
+
+    #[pyclass(with(Constructor))]
+    impl ExceptHookArgs {
+        #[pygetset]
+        fn exc_type(&self) -> crate::PyObjectRef {
+            self.exc_type.clone()
+        }
+
+        #[pygetset]
+        fn exc_value(&self) -> crate::PyObjectRef {
+            self.exc_value.clone()
+        }
+
+        #[pygetset]
+        fn exc_traceback(&self) -> crate::PyObjectRef {
+            self.exc_traceback.clone()
+        }
+
+        #[pygetset]
+        fn thread(&self) -> crate::PyObjectRef {
+            self.thread.clone()
+        }
+    }
+
+    impl Constructor for ExceptHookArgs {
+        // Takes a single iterable argument like namedtuple
+        type Args = (crate::PyObjectRef,);
+
+        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+            // Convert the argument to a list/tuple and extract elements
+            let seq: Vec<crate::PyObjectRef> = args.0.try_to_value(vm)?;
+            if seq.len() != 4 {
+                return Err(vm.new_type_error(format!(
+                    "_ExceptHookArgs expected 4 arguments, got {}",
+                    seq.len()
+                )));
+            }
+            Ok(Self {
+                exc_type: seq[0].clone(),
+                exc_value: seq[1].clone(),
+                exc_traceback: seq[2].clone(),
+                thread: seq[3].clone(),
+            })
+        }
+    }
+
+    /// Handle uncaught exception in Thread.run()
+    #[pyfunction]
+    fn _excepthook(args: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+        // Type check: args must be _ExceptHookArgs
+        let args = args.downcast::<ExceptHookArgs>().map_err(|_| {
+            vm.new_type_error(
+                "_thread._excepthook argument type must be _ExceptHookArgs".to_owned(),
+            )
+        })?;
+
+        let exc_type = args.exc_type.clone();
+        let exc_value = args.exc_value.clone();
+        let exc_traceback = args.exc_traceback.clone();
+        let thread = args.thread.clone();
+
+        // Silently ignore SystemExit (identity check)
+        if exc_type.is(vm.ctx.exceptions.system_exit.as_ref()) {
+            return Ok(());
+        }
+
+        // Get stderr - fall back to thread._stderr if sys.stderr is None
+        let file = match vm.sys_module.get_attr("stderr", vm) {
+            Ok(stderr) if !vm.is_none(&stderr) => stderr,
+            _ => {
+                if vm.is_none(&thread) {
+                    // do nothing if sys.stderr is None and thread is None
+                    return Ok(());
+                }
+                let thread_stderr = thread.get_attr("_stderr", vm)?;
+                if vm.is_none(&thread_stderr) {
+                    // do nothing if sys.stderr is None and sys.stderr was None
+                    // when the thread was created
+                    return Ok(());
+                }
+                thread_stderr
+            }
+        };
+
+        // Print "Exception in thread {thread.name}:"
+        let thread_name = if !vm.is_none(&thread) {
+            thread
+                .get_attr("name", vm)
+                .ok()
+                .and_then(|n| n.str(vm).ok())
+                .map(|s| s.as_str().to_owned())
+        } else {
+            None
+        };
+        let name = thread_name.unwrap_or_else(|| format!("{}", get_ident()));
+
+        let _ = vm.call_method(
+            &file,
+            "write",
+            (format!("Exception in thread {}:\n", name),),
+        );
+
+        // Display the traceback
+        if let Ok(traceback_mod) = vm.import("traceback", 0)
+            && let Ok(print_exc) = traceback_mod.get_attr("print_exception", vm)
+        {
+            use crate::function::KwArgs;
+            let kwargs: KwArgs = vec![("file".to_owned(), file.clone())]
+                .into_iter()
+                .collect();
+            let _ = print_exc.call_with_args(
+                crate::function::FuncArgs::new(vec![exc_type, exc_value, exc_traceback], kwargs),
+                vm,
+            );
+        }
+
+        // Flush file
+        let _ = vm.call_method(&file, "flush", ());
+        Ok(())
+    }
+
+    // Thread-local storage for cleanup guards
+    // When a thread terminates, the guard is dropped, which triggers cleanup
+    thread_local! {
+        static LOCAL_GUARDS: std::cell::RefCell<Vec<LocalGuard>> = const { std::cell::RefCell::new(Vec::new()) };
+    }
+
+    // Guard that removes thread-local data when dropped
+    struct LocalGuard {
+        local: std::sync::Weak<LocalData>,
+        thread_id: std::thread::ThreadId,
+    }
+
+    impl Drop for LocalGuard {
+        fn drop(&mut self) {
+            if let Some(local_data) = self.local.upgrade() {
+                // Remove from map while holding the lock, but drop the value
+                // outside the lock to prevent deadlock if __del__ accesses _local
+                let removed = local_data.data.lock().remove(&self.thread_id);
+                drop(removed);
+            }
+        }
+    }
+
+    // Shared data structure for Local
+    struct LocalData {
+        data: parking_lot::Mutex<std::collections::HashMap<std::thread::ThreadId, PyDictRef>>,
+    }
+
+    impl std::fmt::Debug for LocalData {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("LocalData").finish_non_exhaustive()
+        }
+    }
+
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "_local")]
+    #[derive(Debug, PyPayload)]
+    struct Local {
+        inner: std::sync::Arc<LocalData>,
+    }
+
+    #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))]
+    impl Local {
+        fn l_dict(&self, vm: &VirtualMachine) -> PyDictRef {
+            let thread_id = std::thread::current().id();
+
+            // Fast path: check if dict exists under lock
+            if let Some(dict) = self.inner.data.lock().get(&thread_id).cloned() {
+                return dict;
+            }
+
+            // Slow path: allocate dict outside lock to reduce lock hold time
+            let new_dict = vm.ctx.new_dict();
+
+            // Insert with double-check to handle races
+            let mut data = self.inner.data.lock();
+            use std::collections::hash_map::Entry;
+            let (dict, need_guard) = match data.entry(thread_id) {
+                Entry::Occupied(e) => (e.get().clone(), false),
+                Entry::Vacant(e) => {
+                    e.insert(new_dict.clone());
+                    (new_dict, true)
+                }
+            };
+            drop(data); // Release lock before TLS access
+
+            // Register cleanup guard only if we inserted a new entry
+            if need_guard {
+                let guard = LocalGuard {
+                    local: std::sync::Arc::downgrade(&self.inner),
+                    thread_id,
+                };
+                LOCAL_GUARDS.with(|guards| {
+                    guards.borrow_mut().push(guard);
+                });
+            }
+
+            dict
+        }
+
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            Self {
+                inner: std::sync::Arc::new(LocalData {
+                    data: parking_lot::Mutex::new(std::collections::HashMap::new()),
+                }),
+            }
+            .into_ref_with_type(vm, cls)
+            .map(Into::into)
+        }
+    }
+
+    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__" {
+                Ok(l_dict.into())
+            } else {
+                zelf.as_object()
+                    .generic_getattr_opt(attr, Some(l_dict), vm)?
+                    .ok_or_else(|| {
+                        vm.new_attribute_error(format!(
+                            "{} has no attribute '{}'",
+                            zelf.class().name(),
+                            attr
+                        ))
+                    })
+            }
+        }
+    }
+
+    impl SetAttr for Local {
+        fn setattro(
+            zelf: &Py<Self>,
+            attr: &Py<PyStr>,
+            value: PySetterValue,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            if attr.as_str() == "__dict__" {
+                Err(vm.new_attribute_error(format!(
+                    "{} attribute '__dict__' is read-only",
+                    zelf.class().name()
+                )))
+            } else {
+                let dict = zelf.l_dict(vm);
+                if let PySetterValue::Assign(value) = value {
+                    dict.set_item(attr, value, vm)?;
+                } else {
+                    dict.del_item(attr, vm)?;
+                }
+                Ok(())
+            }
+        }
+    }
+
+    // Registry of all ThreadHandles for fork cleanup
+    // Stores weak references so handles can be garbage collected normally
+    pub type HandleEntry = (
+        std::sync::Weak<parking_lot::Mutex<ThreadHandleInner>>,
+        std::sync::Weak<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    );
+
+    // Re-export type from vm::thread for PyGlobalState
+    pub use crate::vm::thread::CurrentFrameSlot;
+
+    /// Get all threads' current frames. Used by sys._current_frames().
+    pub fn get_all_current_frames(vm: &VirtualMachine) -> Vec<(u64, FrameRef)> {
+        let registry = vm.state.thread_frames.lock();
+        registry
+            .iter()
+            .filter_map(|(id, slot)| slot.lock().clone().map(|f| (*id, f)))
+            .collect()
+    }
+
+    /// Called after fork() in child process to mark all other threads as done.
+    /// This prevents join() from hanging on threads that don't exist in the child.
+    pub fn after_fork_child(vm: &VirtualMachine) {
+        let current_ident = get_ident();
+
+        // Update main thread ident - after fork, the current thread becomes the main thread
+        vm.state.main_thread_ident.store(current_ident);
+
+        // Reinitialize frame slot for current thread
+        crate::vm::thread::reinit_frame_slot_after_fork(vm);
+
+        // Clean up thread handles if we can acquire the lock.
+        // Use try_lock because the mutex might have been held during fork.
+        // If we can't acquire it, just skip - the child process will work
+        // correctly with new handles it creates.
+        if let Some(mut handles) = vm.state.thread_handles.try_lock() {
+            // Clean up dead weak refs and mark non-current threads as done
+            handles.retain(|(inner_weak, done_event_weak): &HandleEntry| {
+                let Some(inner) = inner_weak.upgrade() else {
+                    return false; // Remove dead entries
+                };
+                let Some(done_event) = done_event_weak.upgrade() else {
+                    return false;
+                };
+
+                // Try to lock the inner state - skip if we can't
+                let Some(mut inner_guard) = inner.try_lock() else {
+                    return false;
+                };
+
+                // Skip current thread and not-started threads
+                if inner_guard.ident == current_ident {
+                    return true;
+                }
+                if inner_guard.state == ThreadHandleState::NotStarted {
+                    return true;
+                }
+
+                // Mark as done and notify waiters
+                inner_guard.state = ThreadHandleState::Done;
+                inner_guard.join_handle = None; // Can't join OS thread from child
+                drop(inner_guard);
+
+                // Try to notify waiters - skip if we can't acquire the lock
+                let (lock, cvar) = &*done_event;
+                if let Some(mut done) = lock.try_lock() {
+                    *done = true;
+                    cvar.notify_all();
+                }
+
+                true
+            });
+        }
+    }
+
+    // Thread handle state enum
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub enum ThreadHandleState {
+        NotStarted,
+        Starting,
+        Running,
+        Done,
+    }
+
+    // Internal shared state for thread handle
+    pub struct ThreadHandleInner {
+        pub state: ThreadHandleState,
+        pub ident: u64,
+        pub join_handle: Option<thread::JoinHandle<()>>,
+        pub joining: bool, // True if a thread is currently joining
+        pub joined: bool,  // Track if join has completed
+    }
+
+    impl fmt::Debug for ThreadHandleInner {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("ThreadHandleInner")
+                .field("state", &self.state)
+                .field("ident", &self.ident)
+                .field("join_handle", &self.join_handle.is_some())
+                .field("joining", &self.joining)
+                .field("joined", &self.joined)
+                .finish()
+        }
+    }
+
+    /// _ThreadHandle - handle for joinable threads
+    #[pyattr]
+    #[pyclass(module = "_thread", name = "_ThreadHandle")]
+    #[derive(Debug, PyPayload)]
+    struct ThreadHandle {
+        inner: std::sync::Arc<parking_lot::Mutex<ThreadHandleInner>>,
+        // Event to signal thread completion (for timed join support)
+        done_event: std::sync::Arc<(parking_lot::Mutex<bool>, parking_lot::Condvar)>,
+    }
+
+    #[pyclass]
+    impl ThreadHandle {
+        fn new(vm: &VirtualMachine) -> Self {
+            let inner = std::sync::Arc::new(parking_lot::Mutex::new(ThreadHandleInner {
+                state: ThreadHandleState::NotStarted,
+                ident: 0,
+                join_handle: None,
+                joining: false,
+                joined: false,
+            }));
+            let done_event =
+                std::sync::Arc::new((parking_lot::Mutex::new(false), parking_lot::Condvar::new()));
+
+            // Register in global registry for fork cleanup
+            vm.state.thread_handles.lock().push((
+                std::sync::Arc::downgrade(&inner),
+                std::sync::Arc::downgrade(&done_event),
+            ));
+
+            Self { inner, done_event }
+        }
+
+        #[pygetset]
+        fn ident(&self) -> u64 {
+            self.inner.lock().ident
+        }
+
+        #[pymethod]
+        fn is_done(&self) -> bool {
+            self.inner.lock().state == ThreadHandleState::Done
+        }
+
+        #[pymethod]
+        fn _set_done(&self) {
+            self.inner.lock().state = ThreadHandleState::Done;
+            // Signal waiting threads that this thread is done
+            let (lock, cvar) = &*self.done_event;
+            *lock.lock() = true;
+            cvar.notify_all();
+        }
+
+        #[pymethod]
+        fn join(
+            &self,
+            timeout: OptionalArg<Option<Either<f64, i64>>>,
+            vm: &VirtualMachine,
+        ) -> PyResult<()> {
+            // Convert timeout to Duration (None or negative = infinite wait)
+            let timeout_duration = match timeout.flatten() {
+                Some(Either::A(t)) if t >= 0.0 => Some(Duration::from_secs_f64(t)),
+                Some(Either::B(t)) if t >= 0 => Some(Duration::from_secs(t as u64)),
+                _ => None,
+            };
+
+            // Check for self-join first
+            {
+                let inner = self.inner.lock();
+                let current_ident = get_ident();
+                if inner.ident == current_ident && inner.state == ThreadHandleState::Running {
+                    return Err(vm.new_runtime_error("cannot join current thread".to_owned()));
+                }
+            }
+
+            // Wait for thread completion using Condvar (supports timeout)
+            // Loop to handle spurious wakeups
+            let (lock, cvar) = &*self.done_event;
+            let mut done = lock.lock();
+
+            while !*done {
+                if let Some(timeout) = timeout_duration {
+                    let result = cvar.wait_for(&mut done, timeout);
+                    if result.timed_out() && !*done {
+                        // Timeout occurred and done is still false
+                        return Ok(());
+                    }
+                } else {
+                    // Infinite wait
+                    cvar.wait(&mut done);
+                }
+            }
+            drop(done);
+
+            // Thread is done, now perform cleanup
+            let join_handle = {
+                let mut inner = self.inner.lock();
+
+                // If already joined, return immediately (idempotent)
+                if inner.joined {
+                    return Ok(());
+                }
+
+                // If another thread is already joining, wait for them to finish
+                if inner.joining {
+                    drop(inner);
+                    // Wait on done_event
+                    let (lock, cvar) = &*self.done_event;
+                    let mut done = lock.lock();
+                    while !*done {
+                        cvar.wait(&mut done);
+                    }
+                    return Ok(());
+                }
+
+                // Mark that we're joining
+                inner.joining = true;
+
+                // Take the join handle if available
+                inner.join_handle.take()
+            };
+
+            // Perform the actual join outside the lock
+            if let Some(handle) = join_handle {
+                // Ignore the result - panics in spawned threads are already handled
+                let _ = handle.join();
+            }
+
+            // Mark as joined and clear joining flag
+            {
+                let mut inner = self.inner.lock();
+                inner.joined = true;
+                inner.joining = false;
+            }
+
+            Ok(())
+        }
+
+        #[pyslot]
+        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            ThreadHandle::new(vm)
+                .into_ref_with_type(vm, cls)
+                .map(Into::into)
+        }
+    }
+
+    #[derive(FromArgs)]
+    struct StartJoinableThreadArgs {
+        #[pyarg(positional)]
+        function: ArgCallable,
+        #[pyarg(any, optional)]
+        handle: OptionalArg<PyRef<ThreadHandle>>,
+        #[pyarg(any, default = true)]
+        daemon: bool,
+    }
+
+    #[pyfunction]
+    fn start_joinable_thread(
+        args: StartJoinableThreadArgs,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyRef<ThreadHandle>> {
+        let handle = match args.handle {
+            OptionalArg::Present(h) => h,
+            OptionalArg::Missing => ThreadHandle::new(vm).into_ref(&vm.ctx),
+        };
+
+        // Mark as starting
+        handle.inner.lock().state = ThreadHandleState::Starting;
+
+        // Add non-daemon threads to shutdown registry so _shutdown() will wait for them
+        if !args.daemon {
+            add_to_shutdown_handles(vm, &handle.inner, &handle.done_event);
+        }
+
+        let func = args.function;
+        let handle_clone = handle.clone();
+        let inner_clone = handle.inner.clone();
+        let done_event_clone = handle.done_event.clone();
+
+        let mut thread_builder = thread::Builder::new();
+        let stacksize = vm.state.stacksize.load();
+        if stacksize != 0 {
+            thread_builder = thread_builder.stack_size(stacksize);
+        }
+
+        let join_handle = thread_builder
+            .spawn(vm.new_thread().make_spawn_func(move |vm| {
+                // Set ident and mark as running
+                {
+                    let mut inner = inner_clone.lock();
+                    inner.ident = get_ident();
+                    inner.state = ThreadHandleState::Running;
+                }
+
+                // Ensure cleanup happens even if the function panics
+                let inner_for_cleanup = inner_clone.clone();
+                let done_event_for_cleanup = done_event_clone.clone();
+                let vm_state = vm.state.clone();
+                scopeguard::defer! {
+                    // Mark as done
+                    inner_for_cleanup.lock().state = ThreadHandleState::Done;
+
+                    // Signal waiting threads that this thread is done
+                    {
+                        let (lock, cvar) = &*done_event_for_cleanup;
+                        *lock.lock() = true;
+                        cvar.notify_all();
+                    }
+
+                    // Handle sentinels
+                    for lock in SENTINELS.take() {
+                        if lock.mu.is_locked() {
+                            unsafe { lock.mu.unlock() };
+                        }
+                    }
+
+                    // Clean up thread-local data while VM context is still active
+                    cleanup_thread_local_data();
+
+                    // Clean up frame tracking
+                    crate::vm::thread::cleanup_current_thread_frames(vm);
+
+                    vm_state.thread_count.fetch_sub(1);
+                }
+
+                // Run the function
+                match func.invoke((), vm) {
+                    Ok(_) => {}
+                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.system_exit) => {}
+                    Err(exc) => {
+                        vm.run_unraisable(
+                            exc,
+                            Some("Exception ignored in thread started by".to_owned()),
+                            func.into(),
+                        );
+                    }
+                }
+            }))
+            .map_err(|err| vm.new_runtime_error(format!("can't start new thread: {err}")))?;
+
+        vm.state.thread_count.fetch_add(1);
+
+        // Store the join handle
+        handle.inner.lock().join_handle = Some(join_handle);
+
+        Ok(handle_clone)
+    }
+}
diff --git a/vm/src/stdlib/time.rs b/crates/vm/src/stdlib/time.rs
similarity index 83%
rename from vm/src/stdlib/time.rs
rename to crates/vm/src/stdlib/time.rs
index 0de8648c12..8539e69bac 100644
--- a/vm/src/stdlib/time.rs
+++ b/crates/vm/src/stdlib/time.rs
@@ -21,12 +21,12 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
 unsafe extern "C" {
     #[cfg(not(target_os = "freebsd"))]
     #[link_name = "daylight"]
-    static c_daylight: std::ffi::c_int;
+    static c_daylight: core::ffi::c_int;
     // pub static dstbias: std::ffi::c_int;
     #[link_name = "timezone"]
-    static c_timezone: std::ffi::c_long;
+    static c_timezone: core::ffi::c_long;
     #[link_name = "tzname"]
-    static c_tzname: [*const std::ffi::c_char; 2];
+    static c_tzname: [*const core::ffi::c_char; 2];
     #[link_name = "tzset"]
     fn c_tzset();
 }
@@ -34,19 +34,19 @@ unsafe extern "C" {
 #[pymodule(name = "time", with(platform))]
 mod decl {
     use crate::{
-        AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyStrRef, PyTypeRef},
+        AsObject, PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyStrRef, PyTypeRef, PyUtf8StrRef},
         function::{Either, FuncArgs, OptionalArg},
-        types::PyStructSequence,
+        types::{PyStructSequence, struct_sequence_new},
     };
     use chrono::{
         DateTime, Datelike, TimeZone, Timelike,
         naive::{NaiveDate, NaiveDateTime, NaiveTime},
     };
-    use std::time::Duration;
+    use core::time::Duration;
     #[cfg(target_env = "msvc")]
     #[cfg(not(target_arch = "wasm32"))]
-    use windows::Win32::System::Time;
+    use windows_sys::Win32::System::Time::{GetTimeZoneInformation, TIME_ZONE_INFORMATION};
 
     #[allow(dead_code)]
     pub(super) const SEC_TO_MS: i64 = 1000;
@@ -91,12 +91,11 @@ mod decl {
     #[pyfunction]
     fn sleep(seconds: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
         let dur = seconds.try_into_value::<Duration>(vm).map_err(|e| {
-            if e.class().is(vm.ctx.exceptions.value_error) {
-                if let Some(s) = e.args().first().and_then(|arg| arg.str(vm).ok()) {
-                    if s.as_str() == "negative duration" {
-                        return vm.new_value_error("sleep length must be non-negative");
-                    }
-                }
+            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"
+            {
+                return vm.new_value_error("sleep length must be non-negative");
             }
             e
         })?;
@@ -105,7 +104,7 @@ mod decl {
         {
             // this is basically std::thread::sleep, but that catches interrupts and we don't want to;
             let ts = nix::sys::time::TimeSpec::from(dur);
-            let res = unsafe { libc::nanosleep(ts.as_ref(), std::ptr::null_mut()) };
+            let res = unsafe { libc::nanosleep(ts.as_ref(), core::ptr::null_mut()) };
             let interrupted = res == -1 && nix::Error::last_raw() == libc::EINTR;
 
             if interrupted {
@@ -121,7 +120,6 @@ mod decl {
         Ok(())
     }
 
-    #[cfg(not(target_os = "wasi"))]
     #[pyfunction]
     fn time_ns(vm: &VirtualMachine) -> PyResult<u64> {
         Ok(duration_since_system_now(vm)?.as_nanos() as u64)
@@ -188,10 +186,9 @@ mod decl {
 
     #[cfg(target_env = "msvc")]
     #[cfg(not(target_arch = "wasm32"))]
-    fn get_tz_info() -> Time::TIME_ZONE_INFORMATION {
-        let mut info = Time::TIME_ZONE_INFORMATION::default();
-        let info_ptr = &mut info as *mut Time::TIME_ZONE_INFORMATION;
-        let _ = unsafe { Time::GetTimeZoneInformation(info_ptr) };
+    fn get_tz_info() -> TIME_ZONE_INFORMATION {
+        let mut info: TIME_ZONE_INFORMATION = unsafe { std::mem::zeroed() };
+        unsafe { GetTimeZoneInformation(&mut info) };
         info
     }
 
@@ -203,7 +200,24 @@ mod decl {
     #[cfg(not(target_env = "msvc"))]
     #[cfg(not(target_arch = "wasm32"))]
     #[pyattr]
-    fn timezone(_vm: &VirtualMachine) -> std::ffi::c_long {
+    fn altzone(_vm: &VirtualMachine) -> core::ffi::c_long {
+        // TODO: RUSTPYTHON; Add support for using the C altzone
+        unsafe { super::c_timezone - 3600 }
+    }
+
+    #[cfg(target_env = "msvc")]
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr]
+    fn altzone(_vm: &VirtualMachine) -> i32 {
+        let info = get_tz_info();
+        // https://users.rust-lang.org/t/accessing-tzname-and-similar-constants-in-windows/125771/3
+        (info.Bias + info.StandardBias) * 60 - 3600
+    }
+
+    #[cfg(not(target_env = "msvc"))]
+    #[cfg(not(target_arch = "wasm32"))]
+    #[pyattr]
+    fn timezone(_vm: &VirtualMachine) -> core::ffi::c_long {
         unsafe { super::c_timezone }
     }
 
@@ -220,7 +234,7 @@ mod decl {
     #[cfg(not(target_env = "msvc"))]
     #[cfg(not(target_arch = "wasm32"))]
     #[pyattr]
-    fn daylight(_vm: &VirtualMachine) -> std::ffi::c_int {
+    fn daylight(_vm: &VirtualMachine) -> core::ffi::c_int {
         unsafe { super::c_daylight }
     }
 
@@ -239,8 +253,8 @@ mod decl {
     fn tzname(vm: &VirtualMachine) -> crate::builtins::PyTupleRef {
         use crate::builtins::tuple::IntoPyTuple;
 
-        unsafe fn to_str(s: *const std::ffi::c_char) -> String {
-            unsafe { std::ffi::CStr::from_ptr(s) }
+        unsafe fn to_str(s: *const core::ffi::c_char) -> String {
+            unsafe { core::ffi::CStr::from_ptr(s) }
                 .to_string_lossy()
                 .into_owned()
         }
@@ -282,7 +296,9 @@ mod decl {
         /// 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)?.naive_utc(),
+                Self::Present(secs) => pyobj_to_date_time(secs, vm)?
+                    .with_timezone(&chrono::Local)
+                    .naive_local(),
                 Self::Missing => chrono::offset::Local::now().naive_local(),
             })
         }
@@ -295,7 +311,7 @@ mod decl {
         }
     }
 
-    impl OptionalArg<PyStructTime> {
+    impl OptionalArg<StructTimeData> {
         fn naive_or_local(self, vm: &VirtualMachine) -> PyResult<NaiveDateTime> {
             Ok(match self {
                 Self::Present(t) => t.to_date_time(vm)?,
@@ -306,33 +322,41 @@ mod decl {
 
     /// https://docs.python.org/3/library/time.html?highlight=gmtime#time.gmtime
     #[pyfunction]
-    fn gmtime(secs: OptionalArg<Either<f64, i64>>, vm: &VirtualMachine) -> PyResult<PyStructTime> {
+    fn gmtime(
+        secs: OptionalArg<Either<f64, i64>>,
+        vm: &VirtualMachine,
+    ) -> PyResult<StructTimeData> {
         let instant = secs.naive_or_utc(vm)?;
-        Ok(PyStructTime::new(vm, instant, 0))
+        Ok(StructTimeData::new_utc(vm, instant))
     }
 
     #[pyfunction]
     fn localtime(
         secs: OptionalArg<Either<f64, i64>>,
         vm: &VirtualMachine,
-    ) -> PyResult<PyStructTime> {
+    ) -> PyResult<StructTimeData> {
         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(PyStructTime::new(vm, instant, -1))
+        Ok(StructTimeData::new_local(vm, instant, -1))
     }
 
     #[pyfunction]
-    fn mktime(t: PyStructTime, vm: &VirtualMachine) -> PyResult<f64> {
+    fn mktime(t: StructTimeData, vm: &VirtualMachine) -> PyResult<f64> {
         let datetime = t.to_date_time(vm)?;
-        let seconds_since_epoch = datetime.and_utc().timestamp() as f64;
+        // 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)
     }
 
     const CFMT: &str = "%a %b %e %H:%M:%S %Y";
 
     #[pyfunction]
-    fn asctime(t: OptionalArg<PyStructTime>, vm: &VirtualMachine) -> PyResult {
+    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())
@@ -345,10 +369,22 @@ mod decl {
     }
 
     #[pyfunction]
-    fn strftime(format: PyStrRef, t: OptionalArg<PyStructTime>, vm: &VirtualMachine) -> PyResult {
-        use std::fmt::Write;
+    fn strftime(
+        format: PyUtf8StrRef,
+        t: OptionalArg<StructTimeData>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        use core::fmt::Write;
 
         let instant = t.naive_or_local(vm)?;
+
+        // 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()));
+        }
+
         let mut formatted_time = String::new();
 
         /*
@@ -356,25 +392,22 @@ mod decl {
          * raises an error if unsupported format is supplied.
          * If error happens, we set result as input arg.
          */
-        write!(
-            &mut formatted_time,
-            "{}",
-            instant.format(format.try_to_str(vm)?)
-        )
-        .unwrap_or_else(|_| formatted_time = format.to_string());
+        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())
     }
 
     #[pyfunction]
-    fn strptime(
-        string: PyStrRef,
-        format: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyStructTime> {
-        let format = format.as_ref().map_or("%a %b %H:%M:%S %Y", |s| s.as_str());
-        let instant = NaiveDateTime::parse_from_str(string.as_str(), format)
-            .map_err(|e| vm.new_value_error(format!("Parse error: {e:?}")))?;
-        Ok(PyStructTime::new(vm, instant, -1))
+    fn strptime(string: PyStrRef, format: OptionalArg<PyStrRef>, vm: &VirtualMachine) -> PyResult {
+        // Call _strptime._strptime_time like CPython does
+        let strptime_module = vm.import("_strptime", 0)?;
+        let strptime_func = strptime_module.get_attr("_strptime_time", vm)?;
+
+        // Call with positional arguments
+        match format.into_option() {
+            Some(fmt) => strptime_func.call((string, fmt), vm),
+            None => strptime_func.call((string,), vm),
+        }
     }
 
     #[cfg(not(any(
@@ -425,19 +458,6 @@ mod decl {
         ))
     }
 
-    // same as the get_process_time impl for most unixes
-    #[cfg(all(target_arch = "wasm32", target_os = "wasi"))]
-    pub(super) fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
-        let time: libc::timespec = unsafe {
-            let mut time = std::mem::MaybeUninit::uninit();
-            if libc::clock_gettime(libc::CLOCK_PROCESS_CPUTIME_ID, time.as_mut_ptr()) == -1 {
-                return Err(vm.new_os_error("Failed to get clock time".to_owned()));
-            }
-            time.assume_init()
-        };
-        Ok(Duration::new(time.tv_sec as u64, time.tv_nsec as u32))
-    }
-
     #[cfg(not(any(
         windows,
         target_os = "macos",
@@ -450,7 +470,7 @@ mod decl {
         target_os = "solaris",
         target_os = "openbsd",
         target_os = "redox",
-        all(target_arch = "wasm32", not(target_os = "unknown"))
+        all(target_arch = "wasm32", target_os = "emscripten")
     )))]
     fn get_process_time(vm: &VirtualMachine) -> PyResult<Duration> {
         Err(vm.new_not_implemented_error("process time unsupported in this system"))
@@ -466,40 +486,38 @@ mod decl {
         Ok(get_process_time(vm)?.as_nanos() as u64)
     }
 
-    #[pyattr]
-    #[pyclass(name = "struct_time")]
-    #[derive(PyStructSequence, TryIntoPyStructSequence)]
-    #[allow(dead_code)]
-    struct PyStructTime {
-        tm_year: PyObjectRef,
-        tm_mon: PyObjectRef,
-        tm_mday: PyObjectRef,
-        tm_hour: PyObjectRef,
-        tm_min: PyObjectRef,
-        tm_sec: PyObjectRef,
-        tm_wday: PyObjectRef,
-        tm_yday: PyObjectRef,
-        tm_isdst: PyObjectRef,
-        #[pystruct(skip)]
-        tm_gmtoff: PyObjectRef,
-        #[pystruct(skip)]
-        tm_zone: PyObjectRef,
-    }
-
-    impl std::fmt::Debug for PyStructTime {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    /// Data struct for struct_time
+    #[pystruct_sequence_data(try_from_object)]
+    pub struct StructTimeData {
+        pub tm_year: PyObjectRef,
+        pub tm_mon: PyObjectRef,
+        pub tm_mday: PyObjectRef,
+        pub tm_hour: PyObjectRef,
+        pub tm_min: PyObjectRef,
+        pub tm_sec: PyObjectRef,
+        pub tm_wday: PyObjectRef,
+        pub tm_yday: PyObjectRef,
+        pub tm_isdst: PyObjectRef,
+        #[pystruct_sequence(skip)]
+        pub tm_gmtoff: PyObjectRef,
+        #[pystruct_sequence(skip)]
+        pub tm_zone: PyObjectRef,
+    }
+
+    impl core::fmt::Debug for StructTimeData {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
             write!(f, "struct_time()")
         }
     }
 
-    #[pyclass(with(PyStructSequence))]
-    impl PyStructTime {
-        fn new(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 tz_abbr = local_time.format("%Z").to_string();
-
+    impl StructTimeData {
+        fn new_inner(
+            vm: &VirtualMachine,
+            tm: NaiveDateTime,
+            isdst: i32,
+            gmtoff: i32,
+            zone: &str,
+        ) -> Self {
             Self {
                 tm_year: vm.ctx.new_int(tm.year()).into(),
                 tm_mon: vm.ctx.new_int(tm.month()).into(),
@@ -510,11 +528,25 @@ 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(offset_seconds).into(),
-                tm_zone: vm.ctx.new_str(tz_abbr).into(),
+                tm_gmtoff: vm.ctx.new_int(gmtoff).into(),
+                tm_zone: vm.ctx.new_str(zone).into(),
             }
         }
 
+        /// Create struct_time for UTC (gmtime)
+        fn new_utc(vm: &VirtualMachine, tm: NaiveDateTime) -> Self {
+            Self::new_inner(vm, tm, 0, 0, "UTC")
+        }
+
+        /// Create struct_time for local timezone (localtime)
+        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 tz_abbr = local_time.format("%Z").to_string();
+            Self::new_inner(vm, tm, isdst, offset_seconds, &tz_abbr)
+        }
+
         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");
@@ -532,12 +564,18 @@ mod decl {
             );
             Ok(dt)
         }
+    }
+
+    #[pyattr]
+    #[pystruct_sequence(name = "struct_time", module = "time", data = "StructTimeData")]
+    pub struct PyStructTime;
 
+    #[pyclass(with(PyStructSequence))]
+    impl PyStructTime {
         #[pyslot]
-        fn slot_new(_cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            // cls is ignorable because this is not a basetype
-            let seq = args.bind(vm)?;
-            Ok(vm.new_pyobj(Self::try_from_object(vm, seq)?))
+        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+            let seq: PyObjectRef = args.bind(vm)?;
+            struct_sequence_new(cls, seq, vm)
         }
     }
 
@@ -556,8 +594,8 @@ mod platform {
         builtins::{PyNamespace, PyStrRef},
         convert::IntoPyException,
     };
+    use core::time::Duration;
     use nix::{sys::time::TimeSpec, time::ClockId};
-    use std::time::Duration;
 
     #[cfg(target_os = "solaris")]
     #[pyattr]
@@ -567,6 +605,7 @@ mod platform {
         target_os = "netbsd",
         target_os = "solaris",
         target_os = "openbsd",
+        target_os = "wasi",
     )))]
     #[pyattr]
     use libc::CLOCK_PROCESS_CPUTIME_ID;
@@ -773,7 +812,6 @@ mod platform {
     use crate::{
         PyRef, PyResult, VirtualMachine,
         builtins::{PyNamespace, PyStrRef},
-        stdlib::os::errno_err,
     };
     use std::time::Duration;
     use windows_sys::Win32::{
@@ -785,14 +823,14 @@ mod platform {
 
     fn u64_from_filetime(time: FILETIME) -> u64 {
         let large: [u32; 2] = [time.dwLowDateTime, time.dwHighDateTime];
-        unsafe { std::mem::transmute(large) }
+        unsafe { core::mem::transmute(large) }
     }
 
     fn win_perf_counter_frequency(vm: &VirtualMachine) -> PyResult<i64> {
         let frequency = unsafe {
             let mut freq = std::mem::MaybeUninit::uninit();
             if QueryPerformanceFrequency(freq.as_mut_ptr()) == 0 {
-                return Err(errno_err(vm));
+                return Err(vm.new_last_os_error());
             }
             freq.assume_init()
         };
@@ -840,7 +878,7 @@ mod platform {
                 _is_time_adjustment_disabled.as_mut_ptr(),
             ) == 0
             {
-                return Err(errno_err(vm));
+                return Err(vm.new_last_os_error());
             }
             time_increment.assume_init()
         };
diff --git a/vm/src/stdlib/typevar.rs b/crates/vm/src/stdlib/typevar.rs
similarity index 94%
rename from vm/src/stdlib/typevar.rs
rename to crates/vm/src/stdlib/typevar.rs
index a8962acc90..65249bfd07 100644
--- a/vm/src/stdlib/typevar.rs
+++ b/crates/vm/src/stdlib/typevar.rs
@@ -1,7 +1,7 @@
 // spell-checker:ignore typevarobject funcobj
 use crate::{
-    AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyTupleRef, PyTypeRef, pystr::AsPyStr},
+    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr},
     common::lock::PyMutex,
     function::{FuncArgs, IntoFuncArgs, PyComparisonValue},
     protocol::PyNumberMethods,
@@ -44,7 +44,7 @@ fn caller(vm: &VirtualMachine) -> Option<PyObjectRef> {
 
 /// Set __module__ attribute for an object based on the caller's module.
 /// This follows CPython's behavior for TypeVar and similar objects.
-fn set_module_from_caller(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+fn set_module_from_caller(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
     // Note: CPython gets module from frame->f_funcobj, but RustPython's Frame
     // architecture is different - we use globals['__name__'] instead
     if let Some(module_name) = caller(vm) {
@@ -261,7 +261,15 @@ impl AsNumber for TypeVar {
 impl Constructor for TypeVar {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let typevar = <Self as Constructor>::py_new(&cls, args, vm)?;
+        let obj = typevar.into_ref_with_type(vm, cls)?;
+        let obj_ref: PyObjectRef = obj.into();
+        set_module_from_caller(&obj_ref, vm)?;
+        Ok(obj_ref)
+    }
+
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
         let mut kwargs = args.kwargs;
         // Parse arguments manually
         let (name, constraints) = if args.args.is_empty() {
@@ -353,7 +361,7 @@ impl Constructor for TypeVar {
             (vm.ctx.typing_no_default.clone().into(), vm.ctx.none())
         };
 
-        let typevar = Self {
+        Ok(Self {
             name,
             bound: parking_lot::Mutex::new(bound_obj),
             evaluate_bound,
@@ -364,12 +372,7 @@ impl Constructor for TypeVar {
             covariant,
             contravariant,
             infer_variance,
-        };
-
-        let obj = typevar.into_ref_with_type(vm, cls)?;
-        let obj_ref: PyObjectRef = obj.into();
-        set_module_from_caller(&obj_ref, vm)?;
-        Ok(obj_ref)
+        })
     }
 }
 
@@ -533,7 +536,7 @@ impl AsNumber for ParamSpec {
 impl Constructor for ParamSpec {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
         let mut kwargs = args.kwargs;
         // Parse arguments manually
         let name = if args.args.is_empty() {
@@ -605,6 +608,10 @@ impl Constructor for ParamSpec {
         set_module_from_caller(&obj_ref, vm)?;
         Ok(obj_ref)
     }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
 }
 
 impl Representable for ParamSpec {
@@ -715,7 +722,7 @@ impl Iterable for TypeVarTuple {
 impl Constructor for TypeVarTuple {
     type Args = FuncArgs;
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn slot_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
         let mut kwargs = args.kwargs;
         // Parse arguments manually
         let name = if args.args.is_empty() {
@@ -763,6 +770,10 @@ impl Constructor for TypeVarTuple {
         set_module_from_caller(&obj_ref, vm)?;
         Ok(obj_ref)
     }
+
+    fn py_new(_cls: &Py<PyType>, _args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
+        unimplemented!("use slot_new")
+    }
 }
 
 impl Representable for TypeVarTuple {
@@ -805,10 +816,9 @@ impl ParamSpecArgs {
 impl Constructor for ParamSpecArgs {
     type Args = (PyObjectRef,);
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
         let origin = args.0;
-        let psa = Self { __origin__: origin };
-        psa.into_ref_with_type(vm, cls).map(Into::into)
+        Ok(Self { __origin__: origin })
     }
 }
 
@@ -833,11 +843,12 @@ impl Comparable for ParamSpecArgs {
         fn eq(
             zelf: &crate::Py<ParamSpecArgs>,
             other: PyObjectRef,
-            vm: &VirtualMachine,
+            _vm: &VirtualMachine,
         ) -> PyResult<bool> {
-            // Check if other has __origin__ attribute
-            if let Ok(other_origin) = other.get_attr("__origin__", vm) {
-                return Ok(zelf.__origin__.is(&other_origin));
+            // 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__));
             }
             Ok(false)
         }
@@ -883,10 +894,9 @@ impl ParamSpecKwargs {
 impl Constructor for ParamSpecKwargs {
     type Args = (PyObjectRef,);
 
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
+    fn py_new(_cls: &Py<PyType>, args: Self::Args, _vm: &VirtualMachine) -> PyResult<Self> {
         let origin = args.0;
-        let psa = Self { __origin__: origin };
-        psa.into_ref_with_type(vm, cls).map(Into::into)
+        Ok(Self { __origin__: origin })
     }
 }
 
@@ -911,11 +921,12 @@ impl Comparable for ParamSpecKwargs {
         fn eq(
             zelf: &crate::Py<ParamSpecKwargs>,
             other: PyObjectRef,
-            vm: &VirtualMachine,
+            _vm: &VirtualMachine,
         ) -> PyResult<bool> {
-            // Check if other has __origin__ attribute
-            if let Ok(other_origin) = other.get_attr("__origin__", vm) {
-                return Ok(zelf.__origin__.is(&other_origin));
+            // 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)
         }
@@ -970,6 +981,11 @@ pub struct Generic {}
 
 #[pyclass(flags(BASETYPE))]
 impl Generic {
+    #[pyattr]
+    fn __slots__(ctx: &Context) -> PyTupleRef {
+        ctx.empty_tuple.clone()
+    }
+
     #[pyclassmethod]
     fn __class_getitem__(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
         call_typing_args_kwargs("_generic_class_getitem", cls, args, vm)
@@ -990,15 +1006,15 @@ pub fn set_typeparam_default(
 ) -> PyResult {
     // Inner function to handle common pattern of setting evaluate_default
     fn try_set_default<T>(
-        obj: &PyObjectRef,
-        evaluate_default: &PyObjectRef,
+        obj: &PyObject,
+        evaluate_default: &PyObject,
         get_field: impl FnOnce(&T) -> &PyMutex<PyObjectRef>,
     ) -> bool
     where
         T: PyPayload,
     {
         if let Some(typed_obj) = obj.downcast_ref::<T>() {
-            *get_field(typed_obj).lock() = evaluate_default.clone();
+            *get_field(typed_obj).lock() = evaluate_default.to_owned();
             true
         } else {
             false
diff --git a/crates/vm/src/stdlib/typing.rs b/crates/vm/src/stdlib/typing.rs
new file mode 100644
index 0000000000..f11acce349
--- /dev/null
+++ b/crates/vm/src/stdlib/typing.rs
@@ -0,0 +1,209 @@
+// spell-checker:ignore typevarobject funcobj
+use crate::{Context, PyPayload, PyRef, VirtualMachine, class::PyClassImpl, stdlib::PyModule};
+
+pub use crate::stdlib::typevar::{
+    Generic, ParamSpec, ParamSpecArgs, ParamSpecKwargs, TypeVar, TypeVarTuple,
+    set_typeparam_default,
+};
+pub use decl::*;
+
+/// Initialize typing types (call extend_class)
+pub fn init(ctx: &Context) {
+    NoDefault::extend_class(ctx, ctx.types.typing_no_default_type);
+}
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    let module = decl::make_module(vm);
+    TypeVar::make_class(&vm.ctx);
+    ParamSpec::make_class(&vm.ctx);
+    TypeVarTuple::make_class(&vm.ctx);
+    ParamSpecArgs::make_class(&vm.ctx);
+    ParamSpecKwargs::make_class(&vm.ctx);
+    Generic::make_class(&vm.ctx);
+    extend_module!(vm, &module, {
+        "NoDefault" => vm.ctx.typing_no_default.clone(),
+        "TypeVar" => TypeVar::class(&vm.ctx).to_owned(),
+        "ParamSpec" => ParamSpec::class(&vm.ctx).to_owned(),
+        "TypeVarTuple" => TypeVarTuple::class(&vm.ctx).to_owned(),
+        "ParamSpecArgs" => ParamSpecArgs::class(&vm.ctx).to_owned(),
+        "ParamSpecKwargs" => ParamSpecKwargs::class(&vm.ctx).to_owned(),
+        "Generic" => Generic::class(&vm.ctx).to_owned(),
+    });
+    module
+}
+
+#[pymodule(name = "_typing")]
+pub(crate) mod decl {
+    use crate::{
+        Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
+        builtins::{PyStrRef, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr, type_},
+        convert::ToPyResult,
+        function::{FuncArgs, IntoFuncArgs},
+        protocol::PyNumberMethods,
+        types::{AsNumber, Constructor, Representable},
+    };
+
+    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).to_pyresult(vm)),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
+    // impl AsMapping for Generic {
+    //     fn as_mapping() -> &'static PyMappingMethods {
+    //         static AS_MAPPING: Lazy<PyMappingMethods> = Lazy::new(|| PyMappingMethods {
+    //             subscript: atomic_func!(|mapping, needle, vm| {
+    //                 call_typing_func_object(vm, "_GenericAlias", (mapping.obj, needle))
+    //             }),
+    //             ..PyMappingMethods::NOT_IMPLEMENTED
+    //         });
+    //         &AS_MAPPING
+    //     }
+    // }
+}
diff --git a/vm/src/stdlib/warnings.rs b/crates/vm/src/stdlib/warnings.rs
similarity index 83%
rename from vm/src/stdlib/warnings.rs
rename to crates/vm/src/stdlib/warnings.rs
index a8ffee4579..2d61c3b571 100644
--- a/vm/src/stdlib/warnings.rs
+++ b/crates/vm/src/stdlib/warnings.rs
@@ -9,10 +9,10 @@ pub fn warn(
     vm: &VirtualMachine,
 ) -> PyResult<()> {
     // TODO: use rust warnings module
-    if let Ok(module) = vm.import("warnings", 0) {
-        if let Ok(func) = module.get_attr("warn", vm) {
-            let _ = func.call((message, category.to_owned(), stack_level), vm);
-        }
+    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(())
 }
diff --git a/crates/vm/src/stdlib/weakref.rs b/crates/vm/src/stdlib/weakref.rs
new file mode 100644
index 0000000000..bedfad9abb
--- /dev/null
+++ b/crates/vm/src/stdlib/weakref.rs
@@ -0,0 +1,65 @@
+//! Implementation in line with the python `weakref` module.
+//!
+//! See also:
+//! - [python weakref module](https://docs.python.org/3/library/weakref.html)
+//! - [rust weak struct](https://doc.rust-lang.org/std/rc/struct.Weak.html)
+//!
+pub(crate) use _weakref::make_module;
+
+#[pymodule]
+mod _weakref {
+    use crate::{
+        PyObjectRef, PyResult, VirtualMachine,
+        builtins::{PyDictRef, PyTypeRef, PyWeak},
+    };
+
+    #[pyattr(name = "ref")]
+    fn ref_(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.types.weakref_type.to_owned()
+    }
+    #[pyattr]
+    fn proxy(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.types.weakproxy_type.to_owned()
+    }
+    #[pyattr(name = "ReferenceType")]
+    fn reference_type(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.types.weakref_type.to_owned()
+    }
+    #[pyattr(name = "ProxyType")]
+    fn proxy_type(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.types.weakproxy_type.to_owned()
+    }
+    #[pyattr(name = "CallableProxyType")]
+    fn callable_proxy_type(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.types.weakproxy_type.to_owned()
+    }
+
+    #[pyfunction]
+    fn getweakrefcount(obj: PyObjectRef) -> usize {
+        obj.weak_count().unwrap_or(0)
+    }
+
+    #[pyfunction]
+    fn getweakrefs(obj: PyObjectRef) -> Vec<PyObjectRef> {
+        match obj.get_weak_references() {
+            Some(v) => v.into_iter().map(Into::into).collect(),
+            None => vec![],
+        }
+    }
+
+    #[pyfunction]
+    fn _remove_dead_weakref(
+        dict: PyDictRef,
+        key: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        dict._as_dict_inner()
+            .delete_if(vm, &*key, |wr| {
+                let wr = wr
+                    .downcast_ref::<PyWeak>()
+                    .ok_or_else(|| vm.new_type_error("not a weakref"))?;
+                Ok(wr.is_dead())
+            })
+            .map(drop)
+    }
+}
diff --git a/crates/vm/src/stdlib/winapi.rs b/crates/vm/src/stdlib/winapi.rs
new file mode 100644
index 0000000000..7279f9776e
--- /dev/null
+++ b/crates/vm/src/stdlib/winapi.rs
@@ -0,0 +1,1166 @@
+// spell-checker:disable
+
+#![allow(non_snake_case)]
+pub(crate) use _winapi::make_module;
+
+#[pymodule]
+mod _winapi {
+    use crate::{
+        PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+        builtins::PyStrRef,
+        common::windows::ToWideString,
+        convert::{ToPyException, ToPyResult},
+        function::{ArgMapping, ArgSequence, OptionalArg},
+        windows::{WinHandle, WindowsSysResult},
+    };
+    use std::ptr::{null, null_mut};
+    use windows_sys::Win32::Foundation::{INVALID_HANDLE_VALUE, 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,
+        },
+        Globalization::{
+            LCMAP_FULLWIDTH, LCMAP_HALFWIDTH, LCMAP_HIRAGANA, LCMAP_KATAKANA,
+            LCMAP_LINGUISTIC_CASING, LCMAP_LOWERCASE, LCMAP_SIMPLIFIED_CHINESE, LCMAP_TITLECASE,
+            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, 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,
+                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,
+            },
+            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,
+            },
+        },
+        UI::WindowsAndMessaging::SW_HIDE,
+    };
+
+    #[pyattr]
+    const NULL: isize = 0;
+
+    #[pyfunction]
+    fn CloseHandle(handle: WinHandle) -> WindowsSysResult<i32> {
+        WindowsSysResult(unsafe { windows_sys::Win32::Foundation::CloseHandle(handle.0) })
+    }
+
+    #[pyfunction]
+    fn GetStdHandle(
+        std_handle: windows_sys::Win32::System::Console::STD_HANDLE,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<WinHandle>> {
+        let handle = unsafe { windows_sys::Win32::System::Console::GetStdHandle(std_handle) };
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(if handle.is_null() {
+            // NULL handle - return None
+            None
+        } else {
+            Some(WinHandle(handle))
+        })
+    }
+
+    #[pyfunction]
+    fn CreatePipe(
+        _pipe_attrs: PyObjectRef,
+        size: u32,
+        vm: &VirtualMachine,
+    ) -> 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();
+            WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
+                read.as_mut_ptr(),
+                write.as_mut_ptr(),
+                core::ptr::null(),
+                size,
+            ))
+            .to_pyresult(vm)?;
+            (read.assume_init(), write.assume_init())
+        };
+        Ok((WinHandle(read), WinHandle(write)))
+    }
+
+    #[pyfunction]
+    fn DuplicateHandle(
+        src_process: WinHandle,
+        src: WinHandle,
+        target_process: WinHandle,
+        access: u32,
+        inherit: i32,
+        options: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::Foundation::HANDLE;
+        let target = unsafe {
+            let mut target = std::mem::MaybeUninit::<HANDLE>::uninit();
+            WindowsSysResult(windows_sys::Win32::Foundation::DuplicateHandle(
+                src_process.0,
+                src.0,
+                target_process.0,
+                target.as_mut_ptr(),
+                access,
+                inherit,
+                options.unwrap_or(0),
+            ))
+            .to_pyresult(vm)?;
+            target.assume_init()
+        };
+        Ok(WinHandle(target))
+    }
+
+    #[pyfunction]
+    fn GetACP() -> u32 {
+        unsafe { windows_sys::Win32::Globalization::GetACP() }
+    }
+
+    #[pyfunction]
+    fn GetCurrentProcess() -> WinHandle {
+        WinHandle(unsafe { windows_sys::Win32::System::Threading::GetCurrentProcess() })
+    }
+
+    #[pyfunction]
+    fn GetFileType(
+        h: WinHandle,
+        vm: &VirtualMachine,
+    ) -> PyResult<windows_sys::Win32::Storage::FileSystem::FILE_TYPE> {
+        let file_type = unsafe { windows_sys::Win32::Storage::FileSystem::GetFileType(h.0) };
+        if file_type == 0 && unsafe { windows_sys::Win32::Foundation::GetLastError() } != 0 {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(file_type)
+        }
+    }
+
+    #[pyfunction]
+    fn GetLastError() -> u32 {
+        unsafe { windows_sys::Win32::Foundation::GetLastError() }
+    }
+
+    #[pyfunction]
+    fn GetVersion() -> u32 {
+        unsafe { windows_sys::Win32::System::SystemInformation::GetVersion() }
+    }
+
+    #[derive(FromArgs)]
+    struct CreateProcessArgs {
+        #[pyarg(positional)]
+        name: Option<PyStrRef>,
+        #[pyarg(positional)]
+        command_line: Option<PyStrRef>,
+        #[pyarg(positional)]
+        _proc_attrs: PyObjectRef,
+        #[pyarg(positional)]
+        _thread_attrs: PyObjectRef,
+        #[pyarg(positional)]
+        inherit_handles: i32,
+        #[pyarg(positional)]
+        creation_flags: u32,
+        #[pyarg(positional)]
+        env_mapping: Option<ArgMapping>,
+        #[pyarg(positional)]
+        current_dir: Option<PyStrRef>,
+        #[pyarg(positional)]
+        startup_info: PyObjectRef,
+    }
+
+    #[pyfunction]
+    fn CreateProcess(
+        args: CreateProcessArgs,
+        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 _;
+
+        macro_rules! si_attr {
+            ($attr:ident, $t:ty) => {{
+                si.StartupInfo.$attr = <Option<$t>>::try_from_object(
+                    vm,
+                    args.startup_info.get_attr(stringify!($attr), vm)?,
+                )?
+                .unwrap_or(0) as _
+            }};
+            ($attr:ident) => {{
+                si.StartupInfo.$attr = <Option<_>>::try_from_object(
+                    vm,
+                    args.startup_info.get_attr(stringify!($attr), vm)?,
+                )?
+                .unwrap_or(0)
+            }};
+        }
+        si_attr!(dwFlags);
+        si_attr!(wShowWindow);
+        si_attr!(hStdInput, usize);
+        si_attr!(hStdOutput, usize);
+        si_attr!(hStdError, usize);
+
+        let mut env = args
+            .env_mapping
+            .map(|m| getenvironment(m, vm))
+            .transpose()?;
+        let env = env.as_mut().map_or_else(null_mut, |v| v.as_mut_ptr());
+
+        let mut attrlist =
+            getattributelist(args.startup_info.get_attr("lpAttributeList", vm)?, vm)?;
+        si.lpAttributeList = attrlist
+            .as_mut()
+            .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())
+                .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')
+        {
+            return Err(crate::exceptions::cstring_error(vm));
+        }
+        if let Some(ref cmd) = args.command_line
+            && cmd.as_str().contains('\0')
+        {
+            return Err(crate::exceptions::cstring_error(vm));
+        }
+
+        let app_name = args.name.map(wstr).transpose()?;
+        let app_name = app_name.as_ref().map_or_else(null, |w| w.as_ptr());
+
+        let mut command_line = args.command_line.map(wstr).transpose()?;
+        let command_line = command_line
+            .as_mut()
+            .map_or_else(null_mut, |w| w.as_mut_ptr());
+
+        let mut current_dir = args.current_dir.map(wstr).transpose()?;
+        let current_dir = current_dir
+            .as_mut()
+            .map_or_else(null_mut, |w| w.as_mut_ptr());
+
+        let procinfo = unsafe {
+            let mut procinfo = std::mem::MaybeUninit::uninit();
+            WindowsSysResult(windows_sys::Win32::System::Threading::CreateProcessW(
+                app_name,
+                command_line,
+                core::ptr::null(),
+                core::ptr::null(),
+                args.inherit_handles,
+                args.creation_flags
+                    | windows_sys::Win32::System::Threading::EXTENDED_STARTUPINFO_PRESENT
+                    | windows_sys::Win32::System::Threading::CREATE_UNICODE_ENVIRONMENT,
+                env as _,
+                current_dir,
+                &mut si as *mut _ as *mut _,
+                procinfo.as_mut_ptr(),
+            ))
+            .into_pyresult(vm)?;
+            procinfo.assume_init()
+        };
+
+        Ok((
+            WinHandle(procinfo.hProcess),
+            WinHandle(procinfo.hThread),
+            procinfo.dwProcessId,
+            procinfo.dwThreadId,
+        ))
+    }
+
+    #[pyfunction]
+    fn OpenProcess(
+        desired_access: u32,
+        inherit_handle: bool,
+        process_id: u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        let handle = unsafe {
+            windows_sys::Win32::System::Threading::OpenProcess(
+                desired_access,
+                i32::from(inherit_handle),
+                process_id,
+            )
+        };
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(WinHandle(handle))
+    }
+
+    #[pyfunction]
+    fn ExitProcess(exit_code: u32) {
+        unsafe { windows_sys::Win32::System::Threading::ExitProcess(exit_code) }
+    }
+
+    #[pyfunction]
+    fn NeedCurrentDirectoryForExePath(exe_name: PyStrRef) -> bool {
+        let exe_name = exe_name.as_wtf8().to_wide_with_nul();
+        let return_value = unsafe {
+            windows_sys::Win32::System::Environment::NeedCurrentDirectoryForExePathW(
+                exe_name.as_ptr(),
+            )
+        };
+        return_value != 0
+    }
+
+    #[pyfunction]
+    fn CreateJunction(
+        src_path: PyStrRef,
+        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());
+
+        junction::create(src_path, dest_path).map_err(|e| e.to_pyexception(vm))
+    }
+
+    fn getenvironment(env: ArgMapping, vm: &VirtualMachine) -> PyResult<Vec<u16>> {
+        let keys = env.mapping().keys(vm)?;
+        let values = env.mapping().values(vm)?;
+
+        let keys = ArgSequence::try_from_object(vm, keys)?.into_vec();
+        let values = ArgSequence::try_from_object(vm, values)?.into_vec();
+
+        if keys.len() != values.len() {
+            return Err(vm.new_runtime_error("environment changed size during iteration"));
+        }
+
+        let mut out = widestring::WideString::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 v = PyStrRef::try_from_object(vm, v)?;
+            let v = v.as_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);
+            out.push_str("\0");
+        }
+        out.push_str("\0");
+        Ok(out.into_vec())
+    }
+
+    struct AttrList {
+        handlelist: Option<Vec<usize>>,
+        attrlist: Vec<u8>,
+    }
+    impl Drop for AttrList {
+        fn drop(&mut self) {
+            unsafe {
+                windows_sys::Win32::System::Threading::DeleteProcThreadAttributeList(
+                    self.attrlist.as_mut_ptr() as *mut _,
+                )
+            };
+        }
+    }
+
+    fn getattributelist(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Option<AttrList>> {
+        <Option<ArgMapping>>::try_from_object(vm, obj)?
+            .map(|mapping| {
+                let handlelist = mapping
+                    .as_ref()
+                    .get_item("handle_list", vm)
+                    .ok()
+                    .and_then(|obj| {
+                        <Option<ArgSequence<usize>>>::try_from_object(vm, obj)
+                            .map(|s| match s {
+                                Some(s) if !s.is_empty() => Some(s.into_vec()),
+                                _ => None,
+                            })
+                            .transpose()
+                    })
+                    .transpose()?;
+
+                let attr_count = handlelist.is_some() as u32;
+                let (result, mut size) = unsafe {
+                    let mut size = std::mem::MaybeUninit::uninit();
+                    let result = WindowsSysResult(
+                        windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
+                            std::ptr::null_mut(),
+                            attr_count,
+                            0,
+                            size.as_mut_ptr(),
+                        ),
+                    );
+                    (result, size.assume_init())
+                };
+                if !result.is_err()
+                    || unsafe { windows_sys::Win32::Foundation::GetLastError() }
+                        != windows_sys::Win32::Foundation::ERROR_INSUFFICIENT_BUFFER
+                {
+                    return Err(vm.new_last_os_error());
+                }
+                let mut attrlist = vec![0u8; size];
+                WindowsSysResult(unsafe {
+                    windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
+                        attrlist.as_mut_ptr() as *mut _,
+                        attr_count,
+                        0,
+                        &mut size,
+                    )
+                })
+                .into_pyresult(vm)?;
+                let mut attrs = AttrList {
+                    handlelist,
+                    attrlist,
+                };
+                if let Some(ref mut handlelist) = attrs.handlelist {
+                    WindowsSysResult(unsafe {
+                        windows_sys::Win32::System::Threading::UpdateProcThreadAttribute(
+                            attrs.attrlist.as_mut_ptr() as _,
+                            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(),
+                            core::ptr::null(),
+                        )
+                    })
+                    .into_pyresult(vm)?;
+                }
+                Ok(attrs)
+            })
+            .transpose()
+    }
+
+    #[pyfunction]
+    fn WaitForSingleObject(h: WinHandle, ms: u32, vm: &VirtualMachine) -> PyResult<u32> {
+        let ret = unsafe { windows_sys::Win32::System::Threading::WaitForSingleObject(h.0, ms) };
+        if ret == windows_sys::Win32::Foundation::WAIT_FAILED {
+            Err(vm.new_last_os_error())
+        } else {
+            Ok(ret)
+        }
+    }
+
+    #[pyfunction]
+    fn GetExitCodeProcess(h: WinHandle, vm: &VirtualMachine) -> PyResult<u32> {
+        unsafe {
+            let mut ec = std::mem::MaybeUninit::uninit();
+            WindowsSysResult(windows_sys::Win32::System::Threading::GetExitCodeProcess(
+                h.0,
+                ec.as_mut_ptr(),
+            ))
+            .to_pyresult(vm)?;
+            Ok(ec.assume_init())
+        }
+    }
+
+    #[pyfunction]
+    fn TerminateProcess(h: WinHandle, exit_code: u32) -> WindowsSysResult<i32> {
+        WindowsSysResult(unsafe {
+            windows_sys::Win32::System::Threading::TerminateProcess(h.0, exit_code)
+        })
+    }
+
+    // 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()) };
+        if handle.is_null() {
+            return Err(vm.new_runtime_error("LoadLibrary failed"));
+        }
+        Ok(handle as isize)
+    }
+
+    #[pyfunction]
+    fn GetModuleFileName(handle: isize, vm: &VirtualMachine) -> PyResult<String> {
+        let mut path: Vec<u16> = vec![0; MAX_PATH as usize];
+
+        let length = unsafe {
+            windows_sys::Win32::System::LibraryLoader::GetModuleFileNameW(
+                handle as windows_sys::Win32::Foundation::HMODULE,
+                path.as_mut_ptr(),
+                path.len() as u32,
+            )
+        };
+        if length == 0 {
+            return Err(vm.new_runtime_error("GetModuleFileName failed"));
+        }
+
+        let (path, _) = path.split_at(length as usize);
+        Ok(String::from_utf16(path).unwrap())
+    }
+
+    #[pyfunction]
+    fn OpenMutexW(
+        desired_access: u32,
+        inherit_handle: bool,
+        name: PyStrRef,
+        vm: &VirtualMachine,
+    ) -> PyResult<isize> {
+        let name_wide = name.as_wtf8().to_wide_with_nul();
+        let handle = unsafe {
+            windows_sys::Win32::System::Threading::OpenMutexW(
+                desired_access,
+                i32::from(inherit_handle),
+                name_wide.as_ptr(),
+            )
+        };
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+        Ok(handle as _)
+    }
+
+    #[pyfunction]
+    fn ReleaseMutex(handle: isize) -> WindowsSysResult<i32> {
+        WindowsSysResult(unsafe {
+            windows_sys::Win32::System::Threading::ReleaseMutex(handle as _)
+        })
+    }
+
+    // LOCALE_NAME_INVARIANT is an empty string in Windows API
+    #[pyattr]
+    const LOCALE_NAME_INVARIANT: &str = "";
+
+    /// LCMapStringEx - Map a string to another string using locale-specific rules
+    /// This is used by ntpath.normcase() for proper Windows case conversion
+    #[pyfunction]
+    fn LCMapStringEx(
+        locale: PyStrRef,
+        flags: u32,
+        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,
+        };
+
+        // Reject unsupported flags
+        if flags & (LCMAP_SORTHANDLE | LCMAP_HASH | LCMAP_BYTEREV | LCMAP_SORTKEY) != 0 {
+            return Err(vm.new_value_error("unsupported flags"));
+        }
+
+        // Use ToWideString which properly handles WTF-8 (including surrogates)
+        let locale_wide = locale.as_wtf8().to_wide_with_nul();
+        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()));
+        }
+
+        // First call to get required buffer size
+        let dest_size = unsafe {
+            WinLCMapStringEx(
+                locale_wide.as_ptr(),
+                flags,
+                src_wide.as_ptr(),
+                src_wide.len() as i32,
+                null_mut(),
+                0,
+                null(),
+                null(),
+                0,
+            )
+        };
+
+        if dest_size <= 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Second call to perform the mapping
+        let mut dest = vec![0u16; dest_size as usize];
+        let nmapped = unsafe {
+            WinLCMapStringEx(
+                locale_wide.as_ptr(),
+                flags,
+                src_wide.as_ptr(),
+                src_wide.len() as i32,
+                dest.as_mut_ptr(),
+                dest_size,
+                null(),
+                null(),
+                0,
+            )
+        };
+
+        if nmapped <= 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        dest.truncate(nmapped as usize);
+
+        // Convert UTF-16 back to WTF-8 (handles surrogates properly)
+        let result = Wtf8Buf::from_wide(&dest);
+        Ok(vm.ctx.new_str(result))
+    }
+
+    #[derive(FromArgs)]
+    struct CreateNamedPipeArgs {
+        #[pyarg(positional)]
+        name: PyStrRef,
+        #[pyarg(positional)]
+        open_mode: u32,
+        #[pyarg(positional)]
+        pipe_mode: u32,
+        #[pyarg(positional)]
+        max_instances: u32,
+        #[pyarg(positional)]
+        out_buffer_size: u32,
+        #[pyarg(positional)]
+        in_buffer_size: u32,
+        #[pyarg(positional)]
+        default_timeout: u32,
+        #[pyarg(positional)]
+        _security_attributes: PyObjectRef, // Ignored, can be None
+    }
+
+    /// CreateNamedPipe - Create a named pipe
+    #[pyfunction]
+    fn CreateNamedPipe(args: CreateNamedPipeArgs, vm: &VirtualMachine) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Pipes::CreateNamedPipeW;
+
+        let name_wide = args.name.as_wtf8().to_wide_with_nul();
+
+        let handle = unsafe {
+            CreateNamedPipeW(
+                name_wide.as_ptr(),
+                args.open_mode,
+                args.pipe_mode,
+                args.max_instances,
+                args.out_buffer_size,
+                args.in_buffer_size,
+                args.default_timeout,
+                null(), // security_attributes - NULL for now
+            )
+        };
+
+        if handle == INVALID_HANDLE_VALUE {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(WinHandle(handle))
+    }
+
+    /// Helper for GetShortPathName and GetLongPathName
+    fn get_path_name_impl(
+        path: &PyStrRef,
+        api_fn: unsafe extern "system" fn(*const u16, *mut u16, u32) -> u32,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyStrRef> {
+        use rustpython_common::wtf8::Wtf8Buf;
+
+        let path_wide = path.as_wtf8().to_wide_with_nul();
+
+        // First call to get required buffer size
+        let size = unsafe { api_fn(path_wide.as_ptr(), null_mut(), 0) };
+
+        if size == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Second call to get the actual path
+        let mut buffer: Vec<u16> = vec![0; size as usize];
+        let result =
+            unsafe { api_fn(path_wide.as_ptr(), buffer.as_mut_ptr(), buffer.len() as u32) };
+
+        if result == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        // Truncate to actual length (excluding null terminator)
+        buffer.truncate(result as usize);
+
+        // Convert UTF-16 back to WTF-8 (handles surrogates properly)
+        let result_str = Wtf8Buf::from_wide(&buffer);
+        Ok(vm.ctx.new_str(result_str))
+    }
+
+    /// GetShortPathName - Return the short version of the provided path.
+    #[pyfunction]
+    fn GetShortPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        use windows_sys::Win32::Storage::FileSystem::GetShortPathNameW;
+        get_path_name_impl(&path, GetShortPathNameW, vm)
+    }
+
+    /// GetLongPathName - Return the long version of the provided path.
+    #[pyfunction]
+    fn GetLongPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        use windows_sys::Win32::Storage::FileSystem::GetLongPathNameW;
+        get_path_name_impl(&path, GetLongPathNameW, vm)
+    }
+
+    /// WaitNamedPipe - Wait for an instance of a named pipe to become available.
+    #[pyfunction]
+    fn WaitNamedPipe(name: PyStrRef, timeout: u32, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Pipes::WaitNamedPipeW;
+
+        let name_wide = name.as_wtf8().to_wide_with_nul();
+
+        let success = unsafe { WaitNamedPipeW(name_wide.as_ptr(), timeout) };
+
+        if success == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
+    /// PeekNamedPipe - Peek at data in a named pipe without removing it.
+    #[pyfunction]
+    fn PeekNamedPipe(
+        handle: WinHandle,
+        size: OptionalArg<i32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        use windows_sys::Win32::System::Pipes::PeekNamedPipe as WinPeekNamedPipe;
+
+        let size = size.unwrap_or(0);
+
+        if size < 0 {
+            return Err(vm.new_value_error("negative size".to_string()));
+        }
+
+        let mut navail: u32 = 0;
+        let mut nleft: u32 = 0;
+
+        if size > 0 {
+            let mut buf = vec![0u8; size as usize];
+            let mut nread: u32 = 0;
+
+            let ret = unsafe {
+                WinPeekNamedPipe(
+                    handle.0,
+                    buf.as_mut_ptr() as *mut _,
+                    size as u32,
+                    &mut nread,
+                    &mut navail,
+                    &mut nleft,
+                )
+            };
+
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+
+            buf.truncate(nread as usize);
+            let bytes: PyObjectRef = vm.ctx.new_bytes(buf).into();
+            Ok(vm
+                .ctx
+                .new_tuple(vec![
+                    bytes,
+                    vm.ctx.new_int(navail).into(),
+                    vm.ctx.new_int(nleft).into(),
+                ])
+                .into())
+        } else {
+            let ret = unsafe {
+                WinPeekNamedPipe(handle.0, null_mut(), 0, null_mut(), &mut navail, &mut nleft)
+            };
+
+            if ret == 0 {
+                return Err(vm.new_last_os_error());
+            }
+
+            Ok(vm
+                .ctx
+                .new_tuple(vec![
+                    vm.ctx.new_int(navail).into(),
+                    vm.ctx.new_int(nleft).into(),
+                ])
+                .into())
+        }
+    }
+
+    /// CreateEventW - Create or open a named or unnamed event object.
+    #[pyfunction]
+    fn CreateEventW(
+        security_attributes: isize, // Always NULL (0)
+        manual_reset: bool,
+        initial_state: bool,
+        name: Option<PyStrRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<WinHandle> {
+        use windows_sys::Win32::System::Threading::CreateEventW as WinCreateEventW;
+
+        let _ = security_attributes; // Ignored, always NULL
+
+        let name_wide = name.map(|n| n.as_wtf8().to_wide_with_nul());
+        let name_ptr = name_wide.as_ref().map_or(null(), |n| n.as_ptr());
+
+        let handle = unsafe {
+            WinCreateEventW(
+                null(),
+                i32::from(manual_reset),
+                i32::from(initial_state),
+                name_ptr,
+            )
+        };
+
+        if handle.is_null() {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(WinHandle(handle))
+    }
+
+    /// SetEvent - Set the specified event object to the signaled state.
+    #[pyfunction]
+    fn SetEvent(event: WinHandle, vm: &VirtualMachine) -> PyResult<()> {
+        use windows_sys::Win32::System::Threading::SetEvent as WinSetEvent;
+
+        let ret = unsafe { WinSetEvent(event.0) };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok(())
+    }
+
+    /// WriteFile - Write data to a file or I/O device.
+    #[pyfunction]
+    fn WriteFile(
+        handle: WinHandle,
+        buffer: crate::function::ArgBytesLike,
+        use_overlapped: OptionalArg<bool>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(u32, u32)> {
+        use windows_sys::Win32::Storage::FileSystem::WriteFile as WinWriteFile;
+
+        let use_overlapped = use_overlapped.unwrap_or(false);
+
+        if use_overlapped {
+            return Err(vm.new_not_implemented_error(
+                "overlapped WriteFile is not yet implemented in _winapi".to_string(),
+            ));
+        }
+
+        let buf = buffer.borrow_buf();
+        let len = core::cmp::min(buf.len(), u32::MAX as usize) as u32;
+        let mut written: u32 = 0;
+
+        let ret = unsafe {
+            WinWriteFile(
+                handle.0,
+                buf.as_ptr() as *const _,
+                len,
+                &mut written,
+                null_mut(),
+            )
+        };
+
+        let err = if ret == 0 {
+            unsafe { windows_sys::Win32::Foundation::GetLastError() }
+        } else {
+            0
+        };
+
+        if ret == 0 {
+            return Err(vm.new_last_os_error());
+        }
+
+        Ok((written, err))
+    }
+
+    const MAXIMUM_WAIT_OBJECTS: usize = 64;
+
+    /// BatchedWaitForMultipleObjects - Wait for multiple handles, supporting more than 64.
+    #[pyfunction]
+    fn BatchedWaitForMultipleObjects(
+        handle_seq: PyObjectRef,
+        wait_all: bool,
+        milliseconds: OptionalArg<u32>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyObjectRef> {
+        use std::sync::Arc;
+        use std::sync::atomic::{AtomicU32, Ordering};
+        use windows_sys::Win32::Foundation::{CloseHandle, WAIT_FAILED, WAIT_OBJECT_0};
+        use windows_sys::Win32::System::SystemInformation::GetTickCount64;
+        use windows_sys::Win32::System::Threading::{
+            CreateEventW as WinCreateEventW, CreateThread, GetExitCodeThread,
+            INFINITE as WIN_INFINITE, ResumeThread, SetEvent as WinSetEvent, TerminateThread,
+            WaitForMultipleObjects,
+        };
+
+        let milliseconds = milliseconds.unwrap_or(WIN_INFINITE);
+
+        // Get handles from sequence
+        let seq = ArgSequence::<isize>::try_from_object(vm, handle_seq)?;
+        let handles: Vec<isize> = seq.into_vec();
+        let nhandles = handles.len();
+
+        if nhandles == 0 {
+            return if wait_all {
+                Ok(vm.ctx.none())
+            } else {
+                Ok(vm.ctx.new_list(vec![]).into())
+            };
+        }
+
+        let max_total_objects = (MAXIMUM_WAIT_OBJECTS - 1) * (MAXIMUM_WAIT_OBJECTS - 1);
+        if nhandles > max_total_objects {
+            return Err(vm.new_value_error(format!(
+                "need at most {} handles, got a sequence of length {}",
+                max_total_objects, nhandles
+            )));
+        }
+
+        // Create batches of handles
+        let batch_size = MAXIMUM_WAIT_OBJECTS - 1; // Leave room for cancel_event
+        let mut batches: Vec<Vec<isize>> = Vec::new();
+        let mut i = 0;
+        while i < nhandles {
+            let end = core::cmp::min(i + batch_size, nhandles);
+            batches.push(handles[i..end].to_vec());
+            i = end;
+        }
+
+        if wait_all {
+            // For wait_all, we wait sequentially for each batch
+            let deadline = if milliseconds != WIN_INFINITE {
+                Some(unsafe { GetTickCount64() } + milliseconds as u64)
+            } else {
+                None
+            };
+
+            for batch in &batches {
+                let timeout = if let Some(deadline) = deadline {
+                    let now = unsafe { GetTickCount64() };
+                    if now >= deadline {
+                        return Err(
+                            vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned())
+                        );
+                    }
+                    (deadline - now) as u32
+                } else {
+                    WIN_INFINITE
+                };
+
+                let batch_handles: Vec<_> = batch.iter().map(|&h| h as _).collect();
+                let result = unsafe {
+                    WaitForMultipleObjects(
+                        batch_handles.len() as u32,
+                        batch_handles.as_ptr(),
+                        1, // wait_all = TRUE
+                        timeout,
+                    )
+                };
+
+                if result == WAIT_FAILED {
+                    return Err(vm.new_last_os_error());
+                }
+                if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                    return Err(vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned()));
+                }
+            }
+
+            Ok(vm.ctx.none())
+        } else {
+            // For wait_any, we use threads to wait on each batch in parallel
+            let cancel_event = unsafe { WinCreateEventW(null(), 1, 0, null()) }; // Manual reset, not signaled
+            if cancel_event.is_null() {
+                return Err(vm.new_last_os_error());
+            }
+
+            struct BatchData {
+                handles: Vec<isize>,
+                cancel_event: isize,
+                handle_base: usize,
+                result: AtomicU32,
+                thread: std::cell::UnsafeCell<isize>,
+            }
+
+            unsafe impl Send for BatchData {}
+            unsafe impl Sync for BatchData {}
+
+            let batch_data: Vec<Arc<BatchData>> = batches
+                .iter()
+                .enumerate()
+                .map(|(idx, batch)| {
+                    let base = idx * batch_size;
+                    let mut handles_with_cancel = batch.clone();
+                    handles_with_cancel.push(cancel_event as isize);
+                    Arc::new(BatchData {
+                        handles: handles_with_cancel,
+                        cancel_event: cancel_event as isize,
+                        handle_base: base,
+                        result: AtomicU32::new(WAIT_FAILED),
+                        thread: std::cell::UnsafeCell::new(0),
+                    })
+                })
+                .collect();
+
+            // Thread function
+            extern "system" fn batch_wait_thread(param: *mut std::ffi::c_void) -> u32 {
+                let data = unsafe { &*(param as *const BatchData) };
+                let handles: Vec<_> = data.handles.iter().map(|&h| h as _).collect();
+                let result = unsafe {
+                    WaitForMultipleObjects(
+                        handles.len() as u32,
+                        handles.as_ptr(),
+                        0, // wait_any
+                        WIN_INFINITE,
+                    )
+                };
+                data.result.store(result, Ordering::SeqCst);
+
+                if result == WAIT_FAILED {
+                    let err = unsafe { windows_sys::Win32::Foundation::GetLastError() };
+                    unsafe { WinSetEvent(data.cancel_event as _) };
+                    return err;
+                } else if result >= windows_sys::Win32::Foundation::WAIT_ABANDONED_0
+                    && result
+                        < windows_sys::Win32::Foundation::WAIT_ABANDONED_0
+                            + MAXIMUM_WAIT_OBJECTS as u32
+                {
+                    data.result.store(WAIT_FAILED, Ordering::SeqCst);
+                    unsafe { WinSetEvent(data.cancel_event as _) };
+                    return windows_sys::Win32::Foundation::ERROR_ABANDONED_WAIT_0;
+                }
+                0
+            }
+
+            // Create threads
+            let mut thread_handles: Vec<isize> = Vec::new();
+            for data in &batch_data {
+                let thread = unsafe {
+                    CreateThread(
+                        null(),
+                        1, // Smallest stack
+                        Some(batch_wait_thread),
+                        Arc::as_ptr(data) as *const _ as *mut _,
+                        4, // CREATE_SUSPENDED
+                        null_mut(),
+                    )
+                };
+                if thread.is_null() {
+                    // Cleanup on error
+                    for h in &thread_handles {
+                        unsafe { TerminateThread(*h as _, 0) };
+                        unsafe { CloseHandle(*h as _) };
+                    }
+                    unsafe { CloseHandle(cancel_event) };
+                    return Err(vm.new_last_os_error());
+                }
+                unsafe { *data.thread.get() = thread as isize };
+                thread_handles.push(thread as isize);
+            }
+
+            // Resume all threads
+            for &thread in &thread_handles {
+                unsafe { ResumeThread(thread as _) };
+            }
+
+            // Wait for any thread to complete
+            let thread_handles_raw: Vec<_> = thread_handles.iter().map(|&h| h as _).collect();
+            let result = unsafe {
+                WaitForMultipleObjects(
+                    thread_handles_raw.len() as u32,
+                    thread_handles_raw.as_ptr(),
+                    0, // wait_any
+                    milliseconds,
+                )
+            };
+
+            let err = if result == WAIT_FAILED {
+                Some(unsafe { windows_sys::Win32::Foundation::GetLastError() })
+            } else if result == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                Some(windows_sys::Win32::Foundation::WAIT_TIMEOUT)
+            } else {
+                None
+            };
+
+            // Signal cancel event to stop other threads
+            unsafe { WinSetEvent(cancel_event) };
+
+            // Wait for all threads to finish
+            unsafe {
+                WaitForMultipleObjects(
+                    thread_handles_raw.len() as u32,
+                    thread_handles_raw.as_ptr(),
+                    1, // wait_all
+                    WIN_INFINITE,
+                )
+            };
+
+            // Check for errors from threads
+            let mut thread_err = err;
+            for data in &batch_data {
+                if thread_err.is_none() && data.result.load(Ordering::SeqCst) == WAIT_FAILED {
+                    let mut exit_code: u32 = 0;
+                    let thread = unsafe { *data.thread.get() };
+                    if unsafe { GetExitCodeThread(thread as _, &mut exit_code) } == 0 {
+                        thread_err =
+                            Some(unsafe { windows_sys::Win32::Foundation::GetLastError() });
+                    } else if exit_code != 0 {
+                        thread_err = Some(exit_code);
+                    }
+                }
+                let thread = unsafe { *data.thread.get() };
+                unsafe { CloseHandle(thread as _) };
+            }
+
+            unsafe { CloseHandle(cancel_event) };
+
+            // Return result
+            if let Some(e) = thread_err {
+                if e == windows_sys::Win32::Foundation::WAIT_TIMEOUT {
+                    return Err(vm.new_exception_empty(vm.ctx.exceptions.timeout_error.to_owned()));
+                }
+                return Err(vm.new_os_error(e as i32));
+            }
+
+            // Collect triggered indices
+            let mut triggered_indices: Vec<PyObjectRef> = Vec::new();
+            for data in &batch_data {
+                let result = data.result.load(Ordering::SeqCst);
+                let triggered = result as i32 - WAIT_OBJECT_0 as i32;
+                // Check if it's a valid handle index (not the cancel_event which is last)
+                if triggered >= 0 && (triggered as usize) < data.handles.len() - 1 {
+                    let index = data.handle_base + triggered as usize;
+                    triggered_indices.push(vm.ctx.new_int(index).into());
+                }
+            }
+
+            Ok(vm.ctx.new_list(triggered_indices).into())
+        }
+    }
+}
diff --git a/crates/vm/src/stdlib/winreg.rs b/crates/vm/src/stdlib/winreg.rs
new file mode 100644
index 0000000000..28fa2e9b74
--- /dev/null
+++ b/crates/vm/src/stdlib/winreg.rs
@@ -0,0 +1,1183 @@
+// spell-checker:disable
+#![allow(non_snake_case)]
+
+use crate::{PyRef, VirtualMachine, builtins::PyModule};
+
+pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
+    winreg::make_module(vm)
+}
+
+#[pymodule]
+mod winreg {
+    use crate::builtins::{PyInt, PyStr, PyTuple, PyTypeRef};
+    use crate::common::hash::PyHash;
+    use crate::common::windows::ToWideString;
+    use crate::convert::TryFromObject;
+    use crate::function::FuncArgs;
+    use crate::object::AsObject;
+    use crate::protocol::PyNumberMethods;
+    use crate::types::{AsNumber, Hashable};
+    use crate::{Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine};
+    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;
+
+    /// Atomic HKEY handle type for lock-free thread-safe access
+    type AtomicHKEY = AtomicCell<Registry::HKEY>;
+
+    /// Convert byte slice to UTF-16 slice (zero-copy when aligned)
+    fn bytes_as_wide_slice(bytes: &[u8]) -> &[u16] {
+        // SAFETY: Windows Registry API returns properly aligned UTF-16 data.
+        // align_to handles any edge cases safely by returning empty prefix/suffix
+        // if alignment doesn't match.
+        let (prefix, u16_slice, suffix) = unsafe { bytes.align_to::<u16>() };
+        debug_assert!(
+            prefix.is_empty() && suffix.is_empty(),
+            "Registry data should be u16-aligned"
+        );
+        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)
+    }
+
+    /// Wrapper type for HKEY that can be created from PyHkey or int
+    struct HKEYArg(Registry::HKEY);
+
+    impl TryFromObject for HKEYArg {
+        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+            // Try PyHkey first
+            if let Some(hkey_obj) = obj.downcast_ref::<PyHkey>() {
+                return Ok(HKEYArg(hkey_obj.hkey.load()));
+            }
+            // Then try int
+            let handle = usize::try_from_object(vm, obj)?;
+            Ok(HKEYArg(handle as Registry::HKEY))
+        }
+    }
+
+    // access rights
+    #[pyattr]
+    pub use windows_sys::Win32::System::Registry::{
+        KEY_ALL_ACCESS, KEY_CREATE_LINK, KEY_CREATE_SUB_KEY, KEY_ENUMERATE_SUB_KEYS, KEY_EXECUTE,
+        KEY_NOTIFY, KEY_QUERY_VALUE, KEY_READ, KEY_SET_VALUE, KEY_WOW64_32KEY, KEY_WOW64_64KEY,
+        KEY_WRITE,
+    };
+    // value types
+    #[pyattr]
+    pub use windows_sys::Win32::System::Registry::{
+        REG_BINARY, REG_CREATED_NEW_KEY, REG_DWORD, REG_DWORD_BIG_ENDIAN, REG_DWORD_LITTLE_ENDIAN,
+        REG_EXPAND_SZ, REG_FULL_RESOURCE_DESCRIPTOR, REG_LINK, REG_MULTI_SZ, REG_NONE,
+        REG_NOTIFY_CHANGE_ATTRIBUTES, REG_NOTIFY_CHANGE_LAST_SET, REG_NOTIFY_CHANGE_NAME,
+        REG_NOTIFY_CHANGE_SECURITY, REG_OPENED_EXISTING_KEY, REG_OPTION_BACKUP_RESTORE,
+        REG_OPTION_CREATE_LINK, REG_OPTION_NON_VOLATILE, REG_OPTION_OPEN_LINK, REG_OPTION_RESERVED,
+        REG_OPTION_VOLATILE, REG_QWORD, REG_QWORD_LITTLE_ENDIAN, REG_RESOURCE_LIST,
+        REG_RESOURCE_REQUIREMENTS_LIST, REG_SZ, REG_WHOLE_HIVE_VOLATILE,
+    };
+
+    // Additional constants not in windows-sys
+    #[pyattr]
+    const REG_REFRESH_HIVE: u32 = 0x00000002;
+    #[pyattr]
+    const REG_NO_LAZY_FLUSH: u32 = 0x00000004;
+    // REG_LEGAL_OPTION is a mask of all option flags
+    #[pyattr]
+    const REG_LEGAL_OPTION: u32 = Registry::REG_OPTION_RESERVED
+        | Registry::REG_OPTION_NON_VOLATILE
+        | Registry::REG_OPTION_VOLATILE
+        | Registry::REG_OPTION_CREATE_LINK
+        | Registry::REG_OPTION_BACKUP_RESTORE
+        | Registry::REG_OPTION_OPEN_LINK;
+    // REG_LEGAL_CHANGE_FILTER is a mask of all notify flags
+    #[pyattr]
+    const REG_LEGAL_CHANGE_FILTER: u32 = Registry::REG_NOTIFY_CHANGE_NAME
+        | Registry::REG_NOTIFY_CHANGE_ATTRIBUTES
+        | Registry::REG_NOTIFY_CHANGE_LAST_SET
+        | Registry::REG_NOTIFY_CHANGE_SECURITY;
+
+    // error is an alias for OSError (for backwards compatibility)
+    #[pyattr]
+    fn error(vm: &VirtualMachine) -> PyTypeRef {
+        vm.ctx.exceptions.os_error.to_owned()
+    }
+
+    #[pyattr(once)]
+    fn HKEY_CLASSES_ROOT(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_CLASSES_ROOT).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_CURRENT_USER(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_CURRENT_USER).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_LOCAL_MACHINE(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_LOCAL_MACHINE).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_USERS(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_USERS).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_PERFORMANCE_DATA(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_PERFORMANCE_DATA).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_CURRENT_CONFIG(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_CURRENT_CONFIG).into_ref(&vm.ctx)
+    }
+
+    #[pyattr(once)]
+    fn HKEY_DYN_DATA(vm: &VirtualMachine) -> PyRef<PyHkey> {
+        PyHkey::new(Registry::HKEY_DYN_DATA).into_ref(&vm.ctx)
+    }
+
+    #[pyattr]
+    #[pyclass(name = "HKEYType")]
+    #[derive(Debug, PyPayload)]
+    struct PyHkey {
+        hkey: AtomicHKEY,
+    }
+
+    unsafe impl Send for PyHkey {}
+    unsafe impl Sync for PyHkey {}
+
+    impl PyHkey {
+        fn new(hkey: Registry::HKEY) -> Self {
+            Self {
+                hkey: AtomicHKEY::new(hkey),
+            }
+        }
+
+        fn unary_fail(vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(HKEY_ERR_MSG.to_owned()))
+        }
+
+        fn binary_fail(vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(HKEY_ERR_MSG.to_owned()))
+        }
+
+        fn ternary_fail(vm: &VirtualMachine) -> PyResult {
+            Err(vm.new_type_error(HKEY_ERR_MSG.to_owned()))
+        }
+    }
+
+    #[pyclass(with(AsNumber, Hashable))]
+    impl PyHkey {
+        #[pygetset]
+        fn handle(&self) -> usize {
+            self.hkey.load() as usize
+        }
+
+        #[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());
+            // Already closed - silently succeed
+            if old_hkey.is_null() {
+                return Ok(());
+            }
+            let res = unsafe { Registry::RegCloseKey(old_hkey) };
+            if res == 0 {
+                Ok(())
+            } else {
+                Err(vm.new_os_error(format!("RegCloseKey failed with error code: {res}")))
+            }
+        }
+
+        #[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());
+            Ok(old_hkey as usize)
+        }
+
+        #[pymethod]
+        fn __enter__(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
+            Ok(zelf)
+        }
+
+        #[pymethod]
+        fn __exit__(zelf: PyRef<Self>, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+            zelf.Close(vm)
+        }
+
+        fn __int__(&self) -> usize {
+            self.hkey.load() as usize
+        }
+
+        #[pymethod]
+        fn __str__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+            Ok(vm.ctx.new_str(format!("<PyHkey:{:p}>", zelf.hkey.load())))
+        }
+    }
+
+    impl Drop for PyHkey {
+        fn drop(&mut self) {
+            let hkey = self.hkey.swap(std::ptr::null_mut());
+            if !hkey.is_null() {
+                unsafe { Registry::RegCloseKey(hkey) };
+            }
+        }
+    }
+
+    impl Hashable for PyHkey {
+        // CPython uses PyObject_GenericHash which hashes the object's address
+        fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyHash> {
+            Ok(zelf.get_id() as PyHash)
+        }
+    }
+
+    pub const HKEY_ERR_MSG: &str = "bad operand type";
+
+    impl AsNumber for PyHkey {
+        fn as_number() -> &'static PyNumberMethods {
+            static AS_NUMBER: PyNumberMethods = PyNumberMethods {
+                add: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                subtract: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                multiply: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                remainder: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                divmod: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                power: Some(|_a, _b, _c, vm| PyHkey::ternary_fail(vm)),
+                negative: Some(|_a, vm| PyHkey::unary_fail(vm)),
+                positive: Some(|_a, vm| PyHkey::unary_fail(vm)),
+                absolute: Some(|_a, vm| PyHkey::unary_fail(vm)),
+                boolean: Some(|a, _vm| {
+                    let zelf = a.obj.downcast_ref::<PyHkey>().unwrap();
+                    Ok(!zelf.hkey.load().is_null())
+                }),
+                invert: Some(|_a, vm| PyHkey::unary_fail(vm)),
+                lshift: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                rshift: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                and: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                xor: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                or: Some(|_a, _b, vm| PyHkey::binary_fail(vm)),
+                int: Some(|a, vm| {
+                    if let Some(a) = a.downcast_ref::<PyHkey>() {
+                        Ok(vm.new_pyobj(a.__int__()))
+                    } else {
+                        PyHkey::unary_fail(vm)?;
+                        unreachable!()
+                    }
+                }),
+                float: Some(|_a, vm| PyHkey::unary_fail(vm)),
+                ..PyNumberMethods::NOT_IMPLEMENTED
+            };
+            &AS_NUMBER
+        }
+    }
+
+    #[pyfunction]
+    fn ConnectRegistry(
+        computer_name: Option<String>,
+        key: PyRef<PyHkey>,
+        vm: &VirtualMachine,
+    ) -> PyResult<PyHkey> {
+        if let Some(computer_name) = computer_name {
+            let mut ret_key = std::ptr::null_mut();
+            let wide_computer_name = computer_name.to_wide_with_nul();
+            let res = unsafe {
+                Registry::RegConnectRegistryW(
+                    wide_computer_name.as_ptr(),
+                    key.hkey.load(),
+                    &mut ret_key,
+                )
+            };
+            if res == 0 {
+                Ok(PyHkey::new(ret_key))
+            } else {
+                Err(vm.new_os_error(format!("error code: {res}")))
+            }
+        } else {
+            let mut ret_key = std::ptr::null_mut();
+            let res = unsafe {
+                Registry::RegConnectRegistryW(std::ptr::null_mut(), key.hkey.load(), &mut ret_key)
+            };
+            if res == 0 {
+                Ok(PyHkey::new(ret_key))
+            } else {
+                Err(vm.new_os_error(format!("error code: {res}")))
+            }
+        }
+    }
+
+    #[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 res = unsafe {
+            Registry::RegCreateKeyW(key.hkey.load(), wide_sub_key.as_ptr(), &mut out_key)
+        };
+        if res == 0 {
+            Ok(PyHkey::new(out_key))
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[derive(FromArgs, Debug)]
+    struct CreateKeyExArgs {
+        #[pyarg(any)]
+        key: PyRef<PyHkey>,
+        #[pyarg(any)]
+        sub_key: String,
+        #[pyarg(any, default = 0)]
+        reserved: u32,
+        #[pyarg(any, default = windows_sys::Win32::System::Registry::KEY_WRITE)]
+        access: u32,
+    }
+
+    #[pyfunction]
+    fn CreateKeyEx(args: CreateKeyExArgs, vm: &VirtualMachine) -> PyResult<PyHkey> {
+        let wide_sub_key = args.sub_key.to_wide_with_nul();
+        let mut res: Registry::HKEY = core::ptr::null_mut();
+        let err = unsafe {
+            let key = args.key.hkey.load();
+            Registry::RegCreateKeyExW(
+                key,
+                wide_sub_key.as_ptr(),
+                args.reserved,
+                core::ptr::null(),
+                Registry::REG_OPTION_NON_VOLATILE,
+                args.access,
+                core::ptr::null(),
+                &mut res,
+                std::ptr::null_mut(),
+            )
+        };
+        if err == 0 {
+            Ok(PyHkey {
+                #[allow(clippy::arc_with_non_send_sync)]
+                hkey: AtomicHKEY::new(res),
+            })
+        } else {
+            Err(vm.new_os_error(format!("error code: {err}")))
+        }
+    }
+
+    #[pyfunction]
+    fn CloseKey(hkey: PyRef<PyHkey>, vm: &VirtualMachine) -> PyResult<()> {
+        hkey.Close(vm)
+    }
+
+    #[pyfunction]
+    fn DeleteKey(key: PyRef<PyHkey>, sub_key: String, vm: &VirtualMachine) -> PyResult<()> {
+        let wide_sub_key = sub_key.to_wide_with_nul();
+        let res = unsafe { Registry::RegDeleteKeyW(key.hkey.load(), wide_sub_key.as_ptr()) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn DeleteValue(key: PyRef<PyHkey>, value: Option<String>, vm: &VirtualMachine) -> PyResult<()> {
+        let wide_value = value.map(|v| v.to_wide_with_nul());
+        let value_ptr = wide_value
+            .as_ref()
+            .map_or(core::ptr::null(), |v| v.as_ptr());
+        let res = unsafe { Registry::RegDeleteValueW(key.hkey.load(), value_ptr) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[derive(FromArgs, Debug)]
+    struct DeleteKeyExArgs {
+        #[pyarg(any)]
+        key: PyRef<PyHkey>,
+        #[pyarg(any)]
+        sub_key: String,
+        #[pyarg(any, default = windows_sys::Win32::System::Registry::KEY_WOW64_64KEY)]
+        access: u32,
+        #[pyarg(any, default = 0)]
+        reserved: u32,
+    }
+
+    #[pyfunction]
+    fn DeleteKeyEx(args: DeleteKeyExArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let wide_sub_key = args.sub_key.to_wide_with_nul();
+        let res = unsafe {
+            Registry::RegDeleteKeyExW(
+                args.key.hkey.load(),
+                wide_sub_key.as_ptr(),
+                args.access,
+                args.reserved,
+            )
+        };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn EnumKey(key: PyRef<PyHkey>, index: i32, vm: &VirtualMachine) -> PyResult<String> {
+        // The Windows docs claim that the max key name length is 255
+        // characters, plus a terminating nul character.  However,
+        // empirical testing demonstrates that it is possible to
+        // create a 256 character key that is missing the terminating
+        // nul.  RegEnumKeyEx requires a 257 character buffer to
+        // retrieve such a key name.
+        let mut tmpbuf = [0u16; 257];
+        let mut len = tmpbuf.len() as u32;
+        let res = unsafe {
+            Registry::RegEnumKeyExW(
+                key.hkey.load(),
+                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(),
+            )
+        };
+        if res != 0 {
+            return Err(vm.new_os_error(format!("error code: {res}")));
+        }
+        String::from_utf16(&tmpbuf[..len as usize])
+            .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))
+    }
+
+    #[pyfunction]
+    fn EnumValue(hkey: PyRef<PyHkey>, index: u32, vm: &VirtualMachine) -> PyResult {
+        // Query registry for the required buffer sizes.
+        let mut ret_value_size: u32 = 0;
+        let mut ret_data_size: u32 = 0;
+        let hkey: Registry::HKEY = hkey.hkey.load();
+        let rc = unsafe {
+            Registry::RegQueryInfoKeyW(
+                hkey,
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                &mut ret_value_size as *mut u32,
+                &mut ret_data_size as *mut u32,
+                ptr::null_mut(),
+                ptr::null_mut(),
+            )
+        };
+        if rc != 0 {
+            return Err(vm.new_os_error(format!("RegQueryInfoKeyW failed with error code {rc}")));
+        }
+
+        // Include room for null terminators.
+        ret_value_size += 1;
+        ret_data_size += 1;
+        let mut buf_value_size = ret_value_size;
+        let mut buf_data_size = ret_data_size;
+
+        // Allocate buffers.
+        let mut ret_value_buf: Vec<u16> = vec![0; ret_value_size as usize];
+        let mut ret_data_buf: Vec<u8> = vec![0; ret_data_size as usize];
+
+        // Loop to enumerate the registry value.
+        loop {
+            let mut current_value_size = ret_value_size;
+            let mut current_data_size = ret_data_size;
+            let mut reg_type: u32 = 0;
+            let rc = unsafe {
+                Registry::RegEnumValueW(
+                    hkey,
+                    index,
+                    ret_value_buf.as_mut_ptr(),
+                    &mut current_value_size as *mut u32,
+                    ptr::null_mut(),
+                    &mut reg_type as *mut u32,
+                    ret_data_buf.as_mut_ptr(),
+                    &mut current_data_size as *mut u32,
+                )
+            };
+            if rc == ERROR_MORE_DATA {
+                // Double the buffer sizes.
+                buf_data_size *= 2;
+                buf_value_size *= 2;
+                ret_data_buf.resize(buf_data_size as usize, 0);
+                ret_value_buf.resize(buf_value_size as usize, 0);
+                // Reset sizes for next iteration.
+                ret_value_size = buf_value_size;
+                ret_data_size = buf_data_size;
+                continue;
+            }
+            if rc != 0 {
+                return Err(vm.new_os_error(format!("RegEnumValueW failed with error code {rc}")));
+            }
+
+            // Convert the registry value name from UTF‑16.
+            let name_len = ret_value_buf
+                .iter()
+                .position(|&c| c == 0)
+                .unwrap_or(ret_value_buf.len());
+            let name = String::from_utf16(&ret_value_buf[..name_len])
+                .map_err(|e| vm.new_value_error(format!("UTF16 conversion error: {e}")))?;
+
+            // Slice the data buffer to the actual size returned.
+            let data_slice = &ret_data_buf[..current_data_size as usize];
+            let py_data = reg_to_py(vm, data_slice, reg_type)?;
+
+            // Return tuple (value_name, data, type)
+            return Ok(vm
+                .ctx
+                .new_tuple(vec![
+                    vm.ctx.new_str(name).into(),
+                    py_data,
+                    vm.ctx.new_int(reg_type).into(),
+                ])
+                .into());
+        }
+    }
+
+    #[pyfunction]
+    fn FlushKey(key: PyRef<PyHkey>, vm: &VirtualMachine) -> PyResult<()> {
+        let res = unsafe { Registry::RegFlushKey(key.hkey.load()) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn LoadKey(
+        key: PyRef<PyHkey>,
+        sub_key: String,
+        file_name: String,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let sub_key = sub_key.to_wide_with_nul();
+        let file_name = file_name.to_wide_with_nul();
+        let res =
+            unsafe { Registry::RegLoadKeyW(key.hkey.load(), sub_key.as_ptr(), file_name.as_ptr()) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[derive(Debug, FromArgs)]
+    struct OpenKeyArgs {
+        #[pyarg(any)]
+        key: PyRef<PyHkey>,
+        #[pyarg(any)]
+        sub_key: String,
+        #[pyarg(any, default = 0)]
+        reserved: u32,
+        #[pyarg(any, default = windows_sys::Win32::System::Registry::KEY_READ)]
+        access: u32,
+    }
+
+    #[pyfunction]
+    #[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 err = unsafe {
+            let key = args.key.hkey.load();
+            Registry::RegOpenKeyExW(
+                key,
+                wide_sub_key.as_ptr(),
+                args.reserved,
+                args.access,
+                &mut res,
+            )
+        };
+        if err == 0 {
+            Ok(PyHkey {
+                #[allow(clippy::arc_with_non_send_sync)]
+                hkey: AtomicHKEY::new(res),
+            })
+        } else {
+            Err(os_error_from_windows_code(vm, err as i32, "RegOpenKeyEx"))
+        }
+    }
+
+    #[pyfunction]
+    fn QueryInfoKey(key: HKEYArg, vm: &VirtualMachine) -> PyResult<PyRef<PyTuple>> {
+        let key = key.0;
+        let mut lpcsubkeys: u32 = 0;
+        let mut lpcvalues: u32 = 0;
+        let mut lpftlastwritetime: Foundation::FILETIME = unsafe { std::mem::zeroed() };
+        let err = unsafe {
+            Registry::RegQueryInfoKeyW(
+                key,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                0 as _,
+                &mut lpcsubkeys,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                &mut lpcvalues,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                &mut lpftlastwritetime,
+            )
+        };
+
+        if err != 0 {
+            return Err(vm.new_os_error(format!("error code: {err}")));
+        }
+        let l: u64 = (lpftlastwritetime.dwHighDateTime as u64) << 32
+            | lpftlastwritetime.dwLowDateTime as u64;
+        let tup: Vec<PyObjectRef> = vec![
+            vm.ctx.new_int(lpcsubkeys).into(),
+            vm.ctx.new_int(lpcvalues).into(),
+            vm.ctx.new_int(l).into(),
+        ];
+        Ok(vm.ctx.new_tuple(tup))
+    }
+
+    #[pyfunction]
+    fn QueryValue(key: HKEYArg, sub_key: Option<String>, vm: &VirtualMachine) -> PyResult<String> {
+        let hkey = key.0;
+
+        if hkey == Registry::HKEY_PERFORMANCE_DATA {
+            return Err(os_error_from_windows_code(
+                vm,
+                Foundation::ERROR_INVALID_HANDLE as i32,
+                "RegQueryValue",
+            ));
+        }
+
+        // Open subkey if provided and non-empty
+        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 res = unsafe {
+                    Registry::RegOpenKeyExW(
+                        hkey,
+                        wide_sub_key.as_ptr(),
+                        0,
+                        Registry::KEY_QUERY_VALUE,
+                        &mut out_key,
+                    )
+                };
+                if res != 0 {
+                    return Err(os_error_from_windows_code(vm, res as i32, "RegOpenKeyEx"));
+                }
+                Some(out_key)
+            } else {
+                None
+            }
+        } else {
+            None
+        };
+
+        let target_key = child_key.unwrap_or(hkey);
+        let mut buf_size: u32 = 256;
+        let mut buffer: Vec<u8> = vec![0; buf_size as usize];
+        let mut reg_type: u32 = 0;
+
+        // Loop to handle ERROR_MORE_DATA
+        let result = loop {
+            let mut size = buf_size;
+            let res = unsafe {
+                Registry::RegQueryValueExW(
+                    target_key,
+                    core::ptr::null(), // NULL value name for default value
+                    std::ptr::null_mut(),
+                    &mut reg_type,
+                    buffer.as_mut_ptr(),
+                    &mut size,
+                )
+            };
+            if res == ERROR_MORE_DATA {
+                buf_size *= 2;
+                buffer.resize(buf_size as usize, 0);
+                continue;
+            }
+            if res == Foundation::ERROR_FILE_NOT_FOUND {
+                // Return empty string if there's no default value
+                break Ok(String::new());
+            }
+            if res != 0 {
+                break Err(os_error_from_windows_code(
+                    vm,
+                    res as i32,
+                    "RegQueryValueEx",
+                ));
+            }
+            if reg_type != Registry::REG_SZ {
+                break Err(os_error_from_windows_code(
+                    vm,
+                    Foundation::ERROR_INVALID_DATA as i32,
+                    "RegQueryValue",
+                ));
+            }
+
+            // Convert UTF-16 to String
+            let u16_slice = bytes_as_wide_slice(&buffer[..size as usize]);
+            let len = u16_slice
+                .iter()
+                .position(|&c| c == 0)
+                .unwrap_or(u16_slice.len());
+            break String::from_utf16(&u16_slice[..len])
+                .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")));
+        };
+
+        // Close child key if we opened one
+        if let Some(ck) = child_key {
+            unsafe { Registry::RegCloseKey(ck) };
+        }
+
+        result
+    }
+
+    #[pyfunction]
+    fn QueryValueEx(key: HKEYArg, name: String, vm: &VirtualMachine) -> PyResult<PyRef<PyTuple>> {
+        let hkey = key.0;
+        let wide_name = name.to_wide_with_nul();
+        let mut buf_size: u32 = 0;
+        let res = unsafe {
+            Registry::RegQueryValueExW(
+                hkey,
+                wide_name.as_ptr(),
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                &mut buf_size,
+            )
+        };
+        // Handle ERROR_MORE_DATA by using a default buffer size
+        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",
+            ));
+        }
+
+        let mut ret_buf = vec![0u8; buf_size as usize];
+        let mut typ = 0;
+        let mut ret_size: u32;
+
+        // Loop to handle ERROR_MORE_DATA
+        loop {
+            ret_size = buf_size;
+            let res = unsafe {
+                Registry::RegQueryValueExW(
+                    hkey,
+                    wide_name.as_ptr(),
+                    std::ptr::null_mut(),
+                    &mut typ,
+                    ret_buf.as_mut_ptr(),
+                    &mut ret_size,
+                )
+            };
+
+            if res != ERROR_MORE_DATA {
+                if res != 0 {
+                    return Err(os_error_from_windows_code(
+                        vm,
+                        res as i32,
+                        "RegQueryValueEx",
+                    ));
+                }
+                break;
+            }
+
+            // Double buffer size and retry
+            buf_size *= 2;
+            ret_buf.resize(buf_size as usize, 0);
+        }
+
+        // Only pass the bytes actually returned by the API
+        let obj = reg_to_py(vm, &ret_buf[..ret_size as usize], typ)?;
+        // Return tuple (value, type)
+        Ok(vm.ctx.new_tuple(vec![obj, vm.ctx.new_int(typ).into()]))
+    }
+
+    #[pyfunction]
+    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())
+        };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn SetValue(
+        key: PyRef<PyHkey>,
+        sub_key: String,
+        typ: u32,
+        value: String,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        if typ != Registry::REG_SZ {
+            return Err(vm.new_type_error("type must be winreg.REG_SZ"));
+        }
+
+        let hkey = key.hkey.load();
+        if hkey == Registry::HKEY_PERFORMANCE_DATA {
+            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 res = unsafe {
+                Registry::RegCreateKeyExW(
+                    hkey,
+                    wide_sub_key.as_ptr(),
+                    0,
+                    core::ptr::null(),
+                    0,
+                    Registry::KEY_SET_VALUE,
+                    core::ptr::null(),
+                    &mut out_key,
+                    std::ptr::null_mut(),
+                )
+            };
+            if res != 0 {
+                return Err(os_error_from_windows_code(vm, res as i32, "RegCreateKeyEx"));
+            }
+            Some(out_key)
+        } else {
+            None
+        };
+
+        let target_key = child_key.unwrap_or(hkey);
+        // Convert value to UTF-16 for Wide API
+        let wide_value = value.to_wide_with_nul();
+        let res = unsafe {
+            Registry::RegSetValueExW(
+                target_key,
+                core::ptr::null(), // value name is NULL
+                0,
+                typ,
+                wide_value.as_ptr() as *const u8,
+                (wide_value.len() * 2) as u32, // byte count
+            )
+        };
+
+        // Close child key if we created one
+        if let Some(ck) = child_key {
+            unsafe { Registry::RegCloseKey(ck) };
+        }
+
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(os_error_from_windows_code(vm, res as i32, "RegSetValueEx"))
+        }
+    }
+
+    fn reg_to_py(vm: &VirtualMachine, ret_data: &[u8], typ: u32) -> PyResult {
+        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())
+                }
+            }
+            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())
+                }
+            }
+            REG_SZ | REG_EXPAND_SZ => {
+                let u16_slice = bytes_as_wide_slice(ret_data);
+                // Only use characters up to the first NUL.
+                let len = u16_slice
+                    .iter()
+                    .position(|&c| c == 0)
+                    .unwrap_or(u16_slice.len());
+                let s = String::from_utf16(&u16_slice[..len])
+                    .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))?;
+                Ok(vm.ctx.new_str(s).into())
+            }
+            REG_MULTI_SZ => {
+                if ret_data.is_empty() {
+                    Ok(vm.ctx.new_list(vec![]).into())
+                } else {
+                    let u16_slice = bytes_as_wide_slice(ret_data);
+                    let u16_count = u16_slice.len();
+
+                    // Remove trailing null if present (like countStrings)
+                    let len = if u16_count > 0 && u16_slice[u16_count - 1] == 0 {
+                        u16_count - 1
+                    } else {
+                        u16_count
+                    };
+
+                    let mut strings: Vec<PyObjectRef> = Vec::new();
+                    let mut start = 0;
+                    for i in 0..len {
+                        if u16_slice[i] == 0 {
+                            let s = String::from_utf16(&u16_slice[start..i])
+                                .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))?;
+                            strings.push(vm.ctx.new_str(s).into());
+                            start = i + 1;
+                        }
+                    }
+                    // Handle last string if not null-terminated
+                    if start < len {
+                        let s = String::from_utf16(&u16_slice[start..len])
+                            .map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))?;
+                        strings.push(vm.ctx.new_str(s).into());
+                    }
+                    Ok(vm.ctx.new_list(strings).into())
+                }
+            }
+            // For REG_BINARY and any other unknown types, return a bytes object if data exists.
+            _ => {
+                if ret_data.is_empty() {
+                    Ok(vm.ctx.none())
+                } else {
+                    Ok(vm.ctx.new_bytes(ret_data.to_vec()).into())
+                }
+            }
+        }
+    }
+
+    fn py2reg(value: PyObjectRef, typ: u32, vm: &VirtualMachine) -> PyResult<Option<Vec<u8>>> {
+        match typ {
+            REG_DWORD => {
+                if vm.is_none(&value) {
+                    return Ok(Some(0u32.to_le_bytes().to_vec()));
+                }
+                let val = value
+                    .downcast_ref::<PyInt>()
+                    .ok_or_else(|| vm.new_type_error("value must be an integer".to_string()))?;
+                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()));
+                }
+                let val = bigint
+                    .to_u32()
+                    .ok_or_else(|| vm.new_overflow_error("int too big to convert".to_string()))?;
+                Ok(Some(val.to_le_bytes().to_vec()))
+            }
+            REG_QWORD => {
+                if vm.is_none(&value) {
+                    return Ok(Some(0u64.to_le_bytes().to_vec()));
+                }
+                let val = value
+                    .downcast_ref::<PyInt>()
+                    .ok_or_else(|| vm.new_type_error("value must be an integer".to_string()))?;
+                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()));
+                }
+                let val = bigint
+                    .to_u64()
+                    .ok_or_else(|| vm.new_overflow_error("int too big to convert".to_string()))?;
+                Ok(Some(val.to_le_bytes().to_vec()))
+            }
+            REG_SZ | REG_EXPAND_SZ => {
+                if vm.is_none(&value) {
+                    // Return empty string as UTF-16 null terminator
+                    return Ok(Some(vec![0u8, 0u8]));
+                }
+                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();
+                // Convert Vec<u16> to Vec<u8>
+                let bytes: Vec<u8> = wide.iter().flat_map(|&c| c.to_le_bytes()).collect();
+                Ok(Some(bytes))
+            }
+            REG_MULTI_SZ => {
+                if vm.is_none(&value) {
+                    // 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 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();
+                    bytes.extend(wide.iter().flat_map(|&c| c.to_le_bytes()));
+                }
+                // Add final null terminator (double null at end)
+                bytes.extend([0u8, 0u8]);
+                Ok(Some(bytes))
+            }
+            // REG_BINARY and other types
+            _ => {
+                if vm.is_none(&value) {
+                    return Ok(None);
+                }
+                // Try to get bytes
+                if let Some(bytes) = value.downcast_ref::<crate::builtins::PyBytes>() {
+                    return Ok(Some(bytes.as_bytes().to_vec()));
+                }
+                Err(vm.new_type_error(format!(
+                    "Objects of type '{}' can not be used as binary registry values",
+                    value.class().name()
+                )))
+            }
+        }
+    }
+
+    #[pyfunction]
+    fn SetValueEx(
+        key: PyRef<PyHkey>,
+        value_name: 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),
+        }
+        Ok(())
+    }
+
+    #[pyfunction]
+    fn DisableReflectionKey(key: PyRef<PyHkey>, vm: &VirtualMachine) -> PyResult<()> {
+        let res = unsafe { Registry::RegDisableReflectionKey(key.hkey.load()) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn EnableReflectionKey(key: PyRef<PyHkey>, vm: &VirtualMachine) -> PyResult<()> {
+        let res = unsafe { Registry::RegEnableReflectionKey(key.hkey.load()) };
+        if res == 0 {
+            Ok(())
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn QueryReflectionKey(key: PyRef<PyHkey>, vm: &VirtualMachine) -> PyResult<bool> {
+        let mut result: i32 = 0;
+        let res = unsafe { Registry::RegQueryReflectionKey(key.hkey.load(), &mut result) };
+        if res == 0 {
+            Ok(result != 0)
+        } else {
+            Err(vm.new_os_error(format!("error code: {res}")))
+        }
+    }
+
+    #[pyfunction]
+    fn ExpandEnvironmentStrings(i: String, vm: &VirtualMachine) -> PyResult<String> {
+        let wide_input = i.to_wide_with_nul();
+
+        // First call with size=0 to get required buffer size
+        let required_size = unsafe {
+            windows_sys::Win32::System::Environment::ExpandEnvironmentStringsW(
+                wide_input.as_ptr(),
+                std::ptr::null_mut(),
+                0,
+            )
+        };
+        if required_size == 0 {
+            return Err(vm.new_os_error("ExpandEnvironmentStringsW failed".to_string()));
+        }
+
+        // Allocate buffer with exact size and expand
+        let mut out = vec![0u16; required_size as usize];
+        let r = unsafe {
+            windows_sys::Win32::System::Environment::ExpandEnvironmentStringsW(
+                wide_input.as_ptr(),
+                out.as_mut_ptr(),
+                required_size,
+            )
+        };
+        if r == 0 {
+            return Err(vm.new_os_error("ExpandEnvironmentStringsW failed".to_string()));
+        }
+
+        let len = out.iter().position(|&c| c == 0).unwrap_or(out.len());
+        String::from_utf16(&out[..len]).map_err(|e| vm.new_value_error(format!("UTF16 error: {e}")))
+    }
+}
diff --git a/vm/src/suggestion.rs b/crates/vm/src/suggestion.rs
similarity index 86%
rename from vm/src/suggestion.rs
rename to crates/vm/src/suggestion.rs
index 32d4b623b4..55326d1d3f 100644
--- a/vm/src/suggestion.rs
+++ b/crates/vm/src/suggestion.rs
@@ -2,19 +2,19 @@
 //! This is used during tracebacks.
 
 use crate::{
-    AsObject, Py, PyObjectRef, VirtualMachine,
+    AsObject, Py, PyObject, PyObjectRef, VirtualMachine,
     builtins::{PyStr, PyStrRef},
-    exceptions::types::PyBaseExceptionRef,
+    exceptions::types::PyBaseException,
     sliceable::SliceableSequenceOp,
 };
+use core::iter::ExactSizeIterator;
 use rustpython_common::str::levenshtein::{MOVE_COST, levenshtein_distance};
-use std::iter::ExactSizeIterator;
 
 const MAX_CANDIDATE_ITEMS: usize = 750;
 
 pub fn calculate_suggestions<'a>(
     dir_iter: impl ExactSizeIterator<Item = &'a PyObjectRef>,
-    name: &PyObjectRef,
+    name: &PyObject,
 ) -> Option<PyStrRef> {
     if dir_iter.len() >= MAX_CANDIDATE_ITEMS {
         return None;
@@ -26,7 +26,7 @@ pub fn calculate_suggestions<'a>(
 
     for item in dir_iter {
         let item_name = item.downcast_ref::<PyStr>()?;
-        if name.as_str() == item_name.as_str() {
+        if name.as_bytes() == item_name.as_bytes() {
             continue;
         }
         // No more than 1/3 of the characters should need changed
@@ -35,7 +35,7 @@ pub fn calculate_suggestions<'a>(
             suggestion_distance - 1,
         );
         let current_distance =
-            levenshtein_distance(name.as_str(), item_name.as_str(), max_distance);
+            levenshtein_distance(name.as_bytes(), item_name.as_bytes(), max_distance);
         if current_distance > max_distance {
             continue;
         }
@@ -47,7 +47,7 @@ pub fn calculate_suggestions<'a>(
     suggestion.map(|r| r.to_owned())
 }
 
-pub fn offer_suggestions(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> Option<PyStrRef> {
+pub fn offer_suggestions(exc: &Py<PyBaseException>, vm: &VirtualMachine) -> Option<PyStrRef> {
     if exc.class().is(vm.ctx.exceptions.attribute_error) {
         let name = exc.as_object().get_attr("name", vm).unwrap();
         let obj = exc.as_object().get_attr("obj", vm).unwrap();
diff --git a/crates/vm/src/types/mod.rs b/crates/vm/src/types/mod.rs
new file mode 100644
index 0000000000..b17a737545
--- /dev/null
+++ b/crates/vm/src/types/mod.rs
@@ -0,0 +1,9 @@
+mod slot;
+pub mod slot_defs;
+mod structseq;
+mod zoo;
+
+pub use slot::*;
+pub use slot_defs::{SLOT_DEFS, SlotAccessor, SlotDef};
+pub use structseq::{PyStructSequence, PyStructSequenceData, struct_sequence_new};
+pub(crate) use zoo::TypeZoo;
diff --git a/crates/vm/src/types/slot.rs b/crates/vm/src/types/slot.rs
new file mode 100644
index 0000000000..b637bfc40b
--- /dev/null
+++ b/crates/vm/src/types/slot.rs
@@ -0,0 +1,2070 @@
+use crate::common::lock::{
+    PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyRwLockReadGuard, PyRwLockWriteGuard,
+};
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
+    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef},
+    bytecode::ComparisonOperator,
+    common::hash::{PyHash, fix_sentinel, hash_bigint},
+    convert::ToPyObject,
+    function::{
+        Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
+    },
+    protocol::{
+        PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyMappingSlots, PyNumber,
+        PyNumberMethods, PyNumberSlots, PySequence, PySequenceMethods, PySequenceSlots,
+    },
+    types::slot_defs::{SlotAccessor, find_slot_defs_by_name},
+    vm::Context,
+};
+use core::{any::Any, any::TypeId, borrow::Borrow, cmp::Ordering, ops::Deref};
+use crossbeam_utils::atomic::AtomicCell;
+use num_traits::{Signed, ToPrimitive};
+
+/// Type-erased storage for extension module data attached to heap types.
+pub struct TypeDataSlot {
+    // PyObject_GetTypeData
+    type_id: TypeId,
+    data: Box<dyn Any + Send + Sync>,
+}
+
+impl TypeDataSlot {
+    /// Create a new type data slot with the given data.
+    pub fn new<T: Any + Send + Sync + 'static>(data: T) -> Self {
+        Self {
+            type_id: TypeId::of::<T>(),
+            data: Box::new(data),
+        }
+    }
+
+    /// Get a reference to the data if the type matches.
+    pub fn get<T: Any + 'static>(&self) -> Option<&T> {
+        if self.type_id == TypeId::of::<T>() {
+            self.data.downcast_ref()
+        } else {
+            None
+        }
+    }
+
+    /// Get a mutable reference to the data if the type matches.
+    pub fn get_mut<T: Any + 'static>(&mut self) -> Option<&mut T> {
+        if self.type_id == TypeId::of::<T>() {
+            self.data.downcast_mut()
+        } else {
+            None
+        }
+    }
+}
+
+/// Read guard for type data access, using mapped guard for zero-cost deref.
+pub struct TypeDataRef<'a, T: 'static> {
+    guard: PyMappedRwLockReadGuard<'a, T>,
+}
+
+impl<'a, T: Any + 'static> TypeDataRef<'a, T> {
+    /// Try to create a TypeDataRef from a read guard.
+    /// Returns None if the slot is empty or contains a different type.
+    pub fn try_new(guard: PyRwLockReadGuard<'a, Option<TypeDataSlot>>) -> Option<Self> {
+        PyRwLockReadGuard::try_map(guard, |opt| opt.as_ref().and_then(|slot| slot.get::<T>()))
+            .ok()
+            .map(|guard| Self { guard })
+    }
+}
+
+impl<T: Any + 'static> core::ops::Deref for TypeDataRef<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+/// Write guard for type data access, using mapped guard for zero-cost deref.
+pub struct TypeDataRefMut<'a, T: 'static> {
+    guard: PyMappedRwLockWriteGuard<'a, T>,
+}
+
+impl<'a, T: Any + 'static> TypeDataRefMut<'a, T> {
+    /// Try to create a TypeDataRefMut from a write guard.
+    /// Returns None if the slot is empty or contains a different type.
+    pub fn try_new(guard: PyRwLockWriteGuard<'a, Option<TypeDataSlot>>) -> Option<Self> {
+        PyRwLockWriteGuard::try_map(guard, |opt| {
+            opt.as_mut().and_then(|slot| slot.get_mut::<T>())
+        })
+        .ok()
+        .map(|guard| Self { guard })
+    }
+}
+
+impl<T: Any + 'static> core::ops::Deref for TypeDataRefMut<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+impl<T: Any + 'static> core::ops::DerefMut for TypeDataRefMut<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.guard
+    }
+}
+
+#[macro_export]
+macro_rules! atomic_func {
+    ($x:expr) => {
+        Some($x)
+    };
+}
+
+// The corresponding field in CPython is `tp_` prefixed.
+// e.g. name -> tp_name
+#[derive(Default)]
+#[non_exhaustive]
+pub struct PyTypeSlots {
+    /// # Safety
+    /// For static types, always safe.
+    /// For heap types, `__name__` must alive
+    pub(crate) name: &'static str, // tp_name with <module>.<class> for print, not class name
+
+    pub basicsize: usize,
+    pub itemsize: usize, // tp_itemsize
+
+    // Methods to implement standard operations
+
+    // Method suites for standard classes
+    pub as_number: PyNumberSlots,
+    pub as_sequence: PySequenceSlots,
+    pub as_mapping: PyMappingSlots,
+
+    // More standard operations (here for binary compatibility)
+    pub hash: AtomicCell<Option<HashFunc>>,
+    pub call: AtomicCell<Option<GenericMethod>>,
+    pub str: AtomicCell<Option<StringifyFunc>>,
+    pub repr: AtomicCell<Option<StringifyFunc>>,
+    pub getattro: AtomicCell<Option<GetattroFunc>>,
+    pub setattro: AtomicCell<Option<SetattroFunc>>,
+
+    // Functions to access object as input/output buffer
+    pub as_buffer: Option<AsBufferFunc>,
+
+    // Assigned meaning in release 2.1
+    // rich comparisons
+    pub richcompare: AtomicCell<Option<RichCompareFunc>>,
+
+    // Iterators
+    pub iter: AtomicCell<Option<IterFunc>>,
+    pub iternext: AtomicCell<Option<IterNextFunc>>,
+
+    pub methods: &'static [PyMethodDef],
+
+    // Flags to define presence of optional/expanded features
+    pub flags: PyTypeFlags,
+
+    // tp_doc
+    pub doc: Option<&'static str>,
+
+    // Strong reference on a heap type, borrowed reference on a static type
+    // tp_base
+    // tp_dict
+    pub descr_get: AtomicCell<Option<DescrGetFunc>>,
+    pub descr_set: AtomicCell<Option<DescrSetFunc>>,
+    // tp_dictoffset
+    pub init: AtomicCell<Option<InitFunc>>,
+    // tp_alloc
+    pub new: AtomicCell<Option<NewFunc>>,
+    // tp_free
+    // tp_is_gc
+    // tp_bases
+    // tp_mro
+    // tp_cache
+    // tp_subclasses
+    // tp_weaklist
+    pub del: AtomicCell<Option<DelFunc>>,
+
+    // The count of tp_members.
+    pub member_count: usize,
+}
+
+impl PyTypeSlots {
+    pub fn new(name: &'static str, flags: PyTypeFlags) -> Self {
+        Self {
+            name,
+            flags,
+            ..Default::default()
+        }
+    }
+
+    pub fn heap_default() -> Self {
+        Self {
+            // init: AtomicCell::new(Some(init_wrapper)),
+            ..Default::default()
+        }
+    }
+}
+
+impl core::fmt::Debug for PyTypeSlots {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("PyTypeSlots")
+    }
+}
+
+bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq)]
+    #[non_exhaustive]
+    pub struct PyTypeFlags: u64 {
+        const MANAGED_DICT = 1 << 4;
+        const SEQUENCE = 1 << 5;
+        const MAPPING = 1 << 6;
+        const DISALLOW_INSTANTIATION = 1 << 7;
+        const IMMUTABLETYPE = 1 << 8;
+        const HEAPTYPE = 1 << 9;
+        const BASETYPE = 1 << 10;
+        const METHOD_DESCRIPTOR = 1 << 17;
+        // For built-in types that match the subject itself in pattern matching
+        // (bool, int, float, str, bytes, bytearray, list, tuple, dict, set, frozenset)
+        // This is not a stable API
+        const _MATCH_SELF = 1 << 22;
+        const HAS_DICT = 1 << 40;
+
+        #[cfg(debug_assertions)]
+        const _CREATED_WITH_FLAGS = 1 << 63;
+    }
+}
+
+impl PyTypeFlags {
+    // Default used for both built-in and normal classes: empty, for now.
+    // CPython default: Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | Py_TPFLAGS_HAVE_VERSION_TAG
+    pub const DEFAULT: Self = Self::empty();
+
+    // CPython: See initialization of flags in type_new.
+    /// Used for types created in Python. Subclassable and are a
+    /// heaptype.
+    pub const fn heap_type_flags() -> Self {
+        match Self::from_bits(Self::DEFAULT.bits() | Self::HEAPTYPE.bits() | Self::BASETYPE.bits())
+        {
+            Some(flags) => flags,
+            None => unreachable!(),
+        }
+    }
+
+    pub const fn has_feature(self, flag: Self) -> bool {
+        self.contains(flag)
+    }
+
+    #[cfg(debug_assertions)]
+    pub const fn is_created_with_flags(self) -> bool {
+        self.contains(Self::_CREATED_WITH_FLAGS)
+    }
+}
+
+impl Default for PyTypeFlags {
+    fn default() -> Self {
+        Self::DEFAULT
+    }
+}
+
+pub(crate) type GenericMethod = fn(&PyObject, FuncArgs, &VirtualMachine) -> PyResult;
+pub(crate) type HashFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyHash>;
+// CallFunc = GenericMethod
+pub(crate) type StringifyFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyRef<PyStr>>;
+pub(crate) type GetattroFunc = fn(&PyObject, &Py<PyStr>, &VirtualMachine) -> PyResult;
+pub(crate) type SetattroFunc =
+    fn(&PyObject, &Py<PyStr>, PySetterValue, &VirtualMachine) -> PyResult<()>;
+pub(crate) type AsBufferFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyBuffer>;
+pub(crate) type RichCompareFunc = fn(
+    &PyObject,
+    &PyObject,
+    PyComparisonOp,
+    &VirtualMachine,
+) -> PyResult<Either<PyObjectRef, PyComparisonValue>>;
+pub(crate) type IterFunc = fn(PyObjectRef, &VirtualMachine) -> PyResult;
+pub(crate) type IterNextFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyIterReturn>;
+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 NewFunc = fn(PyTypeRef, FuncArgs, &VirtualMachine) -> PyResult;
+pub(crate) type InitFunc = fn(PyObjectRef, FuncArgs, &VirtualMachine) -> PyResult<()>;
+pub(crate) type DelFunc = fn(&PyObject, &VirtualMachine) -> PyResult<()>;
+
+// Sequence sub-slot function types
+pub(crate) type SeqLenFunc = fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>;
+pub(crate) type SeqConcatFunc = fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult;
+pub(crate) type SeqRepeatFunc = fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult;
+pub(crate) type SeqItemFunc = fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult;
+pub(crate) type SeqAssItemFunc =
+    fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>;
+pub(crate) type SeqContainsFunc = fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>;
+
+// Mapping sub-slot function types
+pub(crate) type MapLenFunc = fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>;
+pub(crate) type MapSubscriptFunc = fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult;
+pub(crate) type MapAssSubscriptFunc =
+    fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>;
+
+// slot_sq_length
+pub(crate) fn len_wrapper(obj: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    let ret = vm.call_special_method(obj, identifier!(vm, __len__), ())?;
+    let len = ret.downcast_ref::<PyInt>().ok_or_else(|| {
+        vm.new_type_error(format!(
+            "'{}' object cannot be interpreted as an integer",
+            ret.class()
+        ))
+    })?;
+    let len = len.as_bigint();
+    if len.is_negative() {
+        return Err(vm.new_value_error("__len__() should return >= 0"));
+    }
+    let len = len
+        .to_isize()
+        .ok_or_else(|| vm.new_overflow_error("cannot fit 'int' into an index-sized integer"))?;
+    Ok(len as usize)
+}
+
+pub(crate) fn contains_wrapper(
+    obj: &PyObject,
+    needle: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    let ret = vm.call_special_method(obj, identifier!(vm, __contains__), (needle,))?;
+    ret.try_to_bool(vm)
+}
+
+macro_rules! number_unary_op_wrapper {
+    ($name:ident) => {
+        |a, vm| vm.call_special_method(a.deref(), identifier!(vm, $name), ())
+    };
+}
+macro_rules! number_binary_op_wrapper {
+    ($name:ident) => {
+        |a, b, vm| vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(),))
+    };
+}
+macro_rules! number_binary_right_op_wrapper {
+    ($name:ident) => {
+        |a, b, vm| vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(),))
+    };
+}
+macro_rules! number_ternary_op_wrapper {
+    ($name:ident) => {
+        |a, b, c, vm: &VirtualMachine| {
+            if vm.is_none(c) {
+                vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(),))
+            } else {
+                vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(), c.to_owned()))
+            }
+        }
+    };
+}
+macro_rules! number_ternary_right_op_wrapper {
+    ($name:ident) => {
+        |a, b, c, vm: &VirtualMachine| {
+            if vm.is_none(c) {
+                vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(),))
+            } else {
+                vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(), c.to_owned()))
+            }
+        }
+    };
+}
+fn getitem_wrapper<K: ToPyObject>(obj: &PyObject, needle: K, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(obj, identifier!(vm, __getitem__), (needle,))
+}
+
+fn setitem_wrapper<K: ToPyObject>(
+    obj: &PyObject,
+    needle: K,
+    value: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    match value {
+        Some(value) => vm.call_special_method(obj, identifier!(vm, __setitem__), (needle, value)),
+        None => vm.call_special_method(obj, identifier!(vm, __delitem__), (needle,)),
+    }
+    .map(drop)
+}
+
+#[inline(never)]
+fn mapping_setitem_wrapper(
+    mapping: PyMapping<'_>,
+    key: &PyObject,
+    value: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    setitem_wrapper(mapping.obj, key, value, vm)
+}
+
+#[inline(never)]
+fn mapping_getitem_wrapper(
+    mapping: PyMapping<'_>,
+    key: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult {
+    getitem_wrapper(mapping.obj, key, vm)
+}
+
+#[inline(never)]
+fn mapping_len_wrapper(mapping: PyMapping<'_>, vm: &VirtualMachine) -> PyResult<usize> {
+    len_wrapper(mapping.obj, vm)
+}
+
+#[inline(never)]
+fn sequence_len_wrapper(seq: PySequence<'_>, vm: &VirtualMachine) -> PyResult<usize> {
+    len_wrapper(seq.obj, vm)
+}
+
+#[inline(never)]
+fn sequence_getitem_wrapper(seq: PySequence<'_>, i: isize, vm: &VirtualMachine) -> PyResult {
+    getitem_wrapper(seq.obj, i, vm)
+}
+
+#[inline(never)]
+fn sequence_setitem_wrapper(
+    seq: PySequence<'_>,
+    i: isize,
+    value: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    setitem_wrapper(seq.obj, i, value, vm)
+}
+
+#[inline(never)]
+fn sequence_contains_wrapper(
+    seq: PySequence<'_>,
+    needle: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<bool> {
+    contains_wrapper(seq.obj, needle, vm)
+}
+
+#[inline(never)]
+fn sequence_repeat_wrapper(seq: PySequence<'_>, n: isize, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(seq.obj, identifier!(vm, __mul__), (n,))
+}
+
+#[inline(never)]
+fn sequence_inplace_repeat_wrapper(seq: PySequence<'_>, n: isize, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(seq.obj, identifier!(vm, __imul__), (n,))
+}
+
+fn repr_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+    let ret = vm.call_special_method(zelf, identifier!(vm, __repr__), ())?;
+    ret.downcast::<PyStr>().map_err(|obj| {
+        vm.new_type_error(format!(
+            "__repr__ returned non-string (type {})",
+            obj.class()
+        ))
+    })
+}
+
+fn str_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+    let ret = vm.call_special_method(zelf, identifier!(vm, __str__), ())?;
+    ret.downcast::<PyStr>().map_err(|obj| {
+        vm.new_type_error(format!(
+            "__str__ returned non-string (type {})",
+            obj.class()
+        ))
+    })
+}
+
+fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
+    let hash_obj = vm.call_special_method(zelf, identifier!(vm, __hash__), ())?;
+    let py_int = hash_obj
+        .downcast_ref::<PyInt>()
+        .ok_or_else(|| vm.new_type_error("__hash__ method should return an integer"))?;
+    let big_int = py_int.as_bigint();
+    let hash = big_int
+        .to_i64()
+        .map(fix_sentinel)
+        .unwrap_or_else(|| hash_bigint(big_int));
+    Ok(hash)
+}
+
+/// Marks a type as unhashable. Similar to PyObject_HashNotImplemented in CPython
+pub fn hash_not_implemented(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
+    Err(vm.new_type_error(format!("unhashable type: {}", zelf.class().name())))
+}
+
+fn call_wrapper(zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(zelf, identifier!(vm, __call__), args)
+}
+
+fn getattro_wrapper(zelf: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+    let __getattribute__ = identifier!(vm, __getattribute__);
+    let __getattr__ = identifier!(vm, __getattr__);
+    match vm.call_special_method(zelf, __getattribute__, (name.to_owned(),)) {
+        Ok(r) => Ok(r),
+        Err(e)
+            if e.fast_isinstance(vm.ctx.exceptions.attribute_error)
+                && zelf.class().has_attr(__getattr__) =>
+        {
+            vm.call_special_method(zelf, __getattr__, (name.to_owned(),))
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn setattro_wrapper(
+    zelf: &PyObject,
+    name: &Py<PyStr>,
+    value: PySetterValue,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    let name = name.to_owned();
+    match value {
+        PySetterValue::Assign(value) => {
+            vm.call_special_method(zelf, identifier!(vm, __setattr__), (name, value))?;
+        }
+        PySetterValue::Delete => {
+            vm.call_special_method(zelf, identifier!(vm, __delattr__), (name,))?;
+        }
+    };
+    Ok(())
+}
+
+pub(crate) fn richcompare_wrapper(
+    zelf: &PyObject,
+    other: &PyObject,
+    op: PyComparisonOp,
+    vm: &VirtualMachine,
+) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
+    vm.call_special_method(zelf, op.method_name(&vm.ctx), (other.to_owned(),))
+        .map(Either::A)
+}
+
+fn iter_wrapper(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    vm.call_special_method(&zelf, identifier!(vm, __iter__), ())
+}
+
+fn bool_wrapper(num: PyNumber<'_>, vm: &VirtualMachine) -> PyResult<bool> {
+    let result = vm.call_special_method(num.obj, identifier!(vm, __bool__), ())?;
+    // __bool__ must return exactly bool, not int subclass
+    if !result.class().is(vm.ctx.types.bool_type) {
+        return Err(vm.new_type_error(format!(
+            "__bool__ should return bool, returned {}",
+            result.class().name()
+        )));
+    }
+    Ok(crate::builtins::bool_::get_value(&result))
+}
+
+// PyObject_SelfIter in CPython
+const fn self_iter(zelf: PyObjectRef, _vm: &VirtualMachine) -> PyResult {
+    Ok(zelf)
+}
+
+fn iternext_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+    PyIterReturn::from_pyresult(
+        vm.call_special_method(zelf, identifier!(vm, __next__), ()),
+        vm,
+    )
+}
+
+fn descr_get_wrapper(
+    zelf: PyObjectRef,
+    obj: Option<PyObjectRef>,
+    cls: Option<PyObjectRef>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    vm.call_special_method(&zelf, identifier!(vm, __get__), (obj, cls))
+}
+
+fn descr_set_wrapper(
+    zelf: &PyObject,
+    obj: PyObjectRef,
+    value: PySetterValue,
+    vm: &VirtualMachine,
+) -> PyResult<()> {
+    match value {
+        PySetterValue::Assign(val) => {
+            vm.call_special_method(zelf, identifier!(vm, __set__), (obj, val))
+        }
+        PySetterValue::Delete => vm.call_special_method(zelf, identifier!(vm, __delete__), (obj,)),
+    }
+    .map(drop)
+}
+
+fn init_wrapper(obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+    let res = vm.call_special_method(&obj, identifier!(vm, __init__), args)?;
+    if !vm.is_none(&res) {
+        return Err(vm.new_type_error(format!(
+            "__init__ should return None, not '{:.200}'",
+            res.class().name()
+        )));
+    }
+    Ok(())
+}
+
+pub(crate) fn new_wrapper(cls: PyTypeRef, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+    let new = cls.get_attr(identifier!(vm, __new__)).unwrap();
+    args.prepend_arg(cls.into());
+    new.call(args, vm)
+}
+
+fn del_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+    vm.call_special_method(zelf, identifier!(vm, __del__), ())?;
+    Ok(())
+}
+
+impl PyType {
+    /// Update slots based on dunder method changes
+    ///
+    /// Iterates SLOT_DEFS to find all slots matching the given name and updates them.
+    /// Also recursively updates subclasses that don't have their own definition.
+    pub(crate) fn update_slot<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
+        debug_assert!(name.as_str().starts_with("__"));
+        debug_assert!(name.as_str().ends_with("__"));
+
+        // Find all slot_defs matching this name and update each
+        // NOTE: Collect into Vec first to avoid issues during iteration
+        let defs: Vec<_> = find_slot_defs_by_name(name.as_str()).collect();
+        for def in defs {
+            self.update_one_slot::<ADD>(&def.accessor, name, ctx);
+        }
+
+        // Recursively update subclasses that don't have their own definition
+        self.update_subclasses::<ADD>(name, ctx);
+    }
+
+    /// Recursively update subclasses' slots
+    /// recurse_down_subclasses
+    fn update_subclasses<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
+        let subclasses = self.subclasses.read();
+        for weak_ref in subclasses.iter() {
+            let Some(subclass) = weak_ref.upgrade() else {
+                continue;
+            };
+            let Some(subclass) = subclass.downcast_ref::<PyType>() else {
+                continue;
+            };
+
+            // Skip if subclass has its own definition for this attribute
+            if subclass.attributes.read().contains_key(name) {
+                continue;
+            }
+
+            // Update subclass's slots
+            for def in find_slot_defs_by_name(name.as_str()) {
+                subclass.update_one_slot::<ADD>(&def.accessor, name, ctx);
+            }
+
+            // Recurse into subclass's subclasses
+            subclass.update_subclasses::<ADD>(name, ctx);
+        }
+    }
+
+    /// Update a single slot
+    fn update_one_slot<const ADD: bool>(
+        &self,
+        accessor: &SlotAccessor,
+        name: &'static PyStrInterned,
+        ctx: &Context,
+    ) {
+        use crate::builtins::descriptor::SlotFunc;
+
+        // Helper macro for main slots
+        macro_rules! update_main_slot {
+            ($slot:ident, $wrapper:expr, $variant:ident) => {{
+                if ADD {
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::$variant(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.$slot.store(Some(func));
+                    } else {
+                        self.slots.$slot.store(Some($wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }};
+        }
+
+        // Helper macro for number/sequence/mapping sub-slots
+        macro_rules! update_sub_slot {
+            ($group:ident, $slot:ident, $wrapper:expr, $variant:ident) => {{
+                if ADD {
+                    // Check if this type defines any method that maps to this slot.
+                    // Some slots like SqAssItem/MpAssSubscript are shared by multiple
+                    // methods (__setitem__ and __delitem__). If any of those methods
+                    // is defined, we must use the wrapper to ensure Python method calls.
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        // Check the current method name
+                        let mut result = guard.contains_key(name);
+                        // For ass_item/ass_subscript slots, also check the paired method
+                        // (__setitem__ and __delitem__ share the same slot)
+                        if !result
+                            && (stringify!($slot) == "ass_item"
+                                || stringify!($slot) == "ass_subscript")
+                        {
+                            let setitem = ctx.intern_str("__setitem__");
+                            let delitem = ctx.intern_str("__delitem__");
+                            result = guard.contains_key(setitem) || guard.contains_key(delitem);
+                        }
+                        result
+                    };
+                    if has_own {
+                        self.slots.$group.$slot.store(Some($wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::$variant(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.$group.$slot.store(Some(func));
+                    } else {
+                        self.slots.$group.$slot.store(Some($wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }};
+        }
+
+        match accessor {
+            // === Main slots ===
+            SlotAccessor::TpRepr => update_main_slot!(repr, repr_wrapper, Repr),
+            SlotAccessor::TpStr => update_main_slot!(str, str_wrapper, Str),
+            SlotAccessor::TpHash => {
+                // Special handling for __hash__ = None
+                if ADD {
+                    let method = self.attributes.read().get(name).cloned().or_else(|| {
+                        self.mro
+                            .read()
+                            .iter()
+                            .find_map(|cls| cls.attributes.read().get(name).cloned())
+                    });
+
+                    if method.as_ref().is_some_and(|m| m.is(&ctx.none)) {
+                        self.slots.hash.store(Some(hash_not_implemented));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::Hash(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.hash.store(Some(func));
+                    } else {
+                        self.slots.hash.store(Some(hash_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::TpCall => update_main_slot!(call, call_wrapper, Call),
+            SlotAccessor::TpIter => update_main_slot!(iter, iter_wrapper, Iter),
+            SlotAccessor::TpIternext => update_main_slot!(iternext, iternext_wrapper, IterNext),
+            SlotAccessor::TpInit => update_main_slot!(init, init_wrapper, Init),
+            SlotAccessor::TpNew => {
+                // __new__ is not wrapped via PyWrapper
+                if ADD {
+                    self.slots.new.store(Some(new_wrapper));
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::TpDel => update_main_slot!(del, del_wrapper, Del),
+            SlotAccessor::TpGetattro => {
+                // __getattribute__ and __getattr__ both map to TpGetattro.
+                // If __getattr__ is defined anywhere in MRO, we must use the wrapper
+                // because the native slot won't call __getattr__.
+                let __getattr__ = identifier!(ctx, __getattr__);
+                let has_getattr = {
+                    let attrs = self.attributes.read();
+                    let in_self = attrs.contains_key(__getattr__);
+                    drop(attrs);
+                    // mro[0] is self, so skip it
+                    in_self
+                        || self
+                            .mro
+                            .read()
+                            .iter()
+                            .skip(1)
+                            .any(|cls| cls.attributes.read().contains_key(__getattr__))
+                };
+
+                if has_getattr {
+                    // Must use wrapper to handle __getattr__
+                    self.slots.getattro.store(Some(getattro_wrapper));
+                } else if ADD {
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::GetAttro(f) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.getattro.store(Some(func));
+                    } else {
+                        self.slots.getattro.store(Some(getattro_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::TpSetattro => {
+                // __setattr__ and __delattr__ share the same slot
+                if ADD {
+                    if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::SetAttro(f) | SlotFunc::DelAttro(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.setattro.store(Some(func));
+                    } else {
+                        self.slots.setattro.store(Some(setattro_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::TpDescrGet => update_main_slot!(descr_get, descr_get_wrapper, DescrGet),
+            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 {
+                        SlotFunc::DescrSet(f) | SlotFunc::DescrDel(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.descr_set.store(Some(func));
+                    } else {
+                        self.slots.descr_set.store(Some(descr_set_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+
+            // === Rich compare (__lt__, __le__, __eq__, __ne__, __gt__, __ge__) ===
+            SlotAccessor::TpRichcompare => {
+                if ADD {
+                    // Check if self or any class in MRO has a Python-defined comparison method
+                    // All comparison ops share the same slot, so if any is overridden anywhere
+                    // in the hierarchy with a Python function, we need to use the wrapper
+                    let cmp_names = [
+                        identifier!(ctx, __eq__),
+                        identifier!(ctx, __ne__),
+                        identifier!(ctx, __lt__),
+                        identifier!(ctx, __le__),
+                        identifier!(ctx, __gt__),
+                        identifier!(ctx, __ge__),
+                    ];
+
+                    let has_python_cmp = {
+                        // Check self first
+                        let attrs = self.attributes.read();
+                        let in_self = cmp_names.iter().any(|n| attrs.contains_key(*n));
+                        drop(attrs);
+
+                        // mro[0] is self, so skip it since we already checked self above
+                        in_self
+                            || self.mro.read()[1..].iter().any(|cls| {
+                                let attrs = cls.attributes.read();
+                                cmp_names.iter().any(|n| {
+                                    if let Some(attr) = attrs.get(*n) {
+                                        // Check if it's a Python function (not wrapper_descriptor)
+                                        !attr.class().is(ctx.types.wrapper_descriptor_type)
+                                    } else {
+                                        false
+                                    }
+                                })
+                            })
+                    };
+
+                    if has_python_cmp {
+                        // Use wrapper to call the Python method
+                        self.slots.richcompare.store(Some(richcompare_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| {
+                        if let SlotFunc::RichCompare(f, _) = sf {
+                            Some(*f)
+                        } else {
+                            None
+                        }
+                    }) {
+                        self.slots.richcompare.store(Some(func));
+                    } else {
+                        self.slots.richcompare.store(Some(richcompare_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+
+            // === Number binary operations ===
+            SlotAccessor::NbAdd => {
+                if name.as_str() == "__radd__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_add,
+                        number_binary_right_op_wrapper!(__radd__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        add,
+                        number_binary_op_wrapper!(__add__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceAdd => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_add,
+                    number_binary_op_wrapper!(__iadd__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbSubtract => {
+                if name.as_str() == "__rsub__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_subtract,
+                        number_binary_right_op_wrapper!(__rsub__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        subtract,
+                        number_binary_op_wrapper!(__sub__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceSubtract => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_subtract,
+                    number_binary_op_wrapper!(__isub__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbMultiply => {
+                if name.as_str() == "__rmul__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_multiply,
+                        number_binary_right_op_wrapper!(__rmul__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        multiply,
+                        number_binary_op_wrapper!(__mul__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceMultiply => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_multiply,
+                    number_binary_op_wrapper!(__imul__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbRemainder => {
+                if name.as_str() == "__rmod__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_remainder,
+                        number_binary_right_op_wrapper!(__rmod__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        remainder,
+                        number_binary_op_wrapper!(__mod__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceRemainder => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_remainder,
+                    number_binary_op_wrapper!(__imod__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbDivmod => {
+                if name.as_str() == "__rdivmod__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_divmod,
+                        number_binary_right_op_wrapper!(__rdivmod__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        divmod,
+                        number_binary_op_wrapper!(__divmod__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbPower => {
+                if name.as_str() == "__rpow__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_power,
+                        number_ternary_right_op_wrapper!(__rpow__),
+                        NumTernary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        power,
+                        number_ternary_op_wrapper!(__pow__),
+                        NumTernary
+                    )
+                }
+            }
+            SlotAccessor::NbInplacePower => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_power,
+                    number_ternary_op_wrapper!(__ipow__),
+                    NumTernary
+                )
+            }
+            SlotAccessor::NbFloorDivide => {
+                if name.as_str() == "__rfloordiv__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_floor_divide,
+                        number_binary_right_op_wrapper!(__rfloordiv__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        floor_divide,
+                        number_binary_op_wrapper!(__floordiv__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceFloorDivide => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_floor_divide,
+                    number_binary_op_wrapper!(__ifloordiv__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbTrueDivide => {
+                if name.as_str() == "__rtruediv__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_true_divide,
+                        number_binary_right_op_wrapper!(__rtruediv__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        true_divide,
+                        number_binary_op_wrapper!(__truediv__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceTrueDivide => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_true_divide,
+                    number_binary_op_wrapper!(__itruediv__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbMatrixMultiply => {
+                if name.as_str() == "__rmatmul__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_matrix_multiply,
+                        number_binary_right_op_wrapper!(__rmatmul__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        matrix_multiply,
+                        number_binary_op_wrapper!(__matmul__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceMatrixMultiply => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_matrix_multiply,
+                    number_binary_op_wrapper!(__imatmul__),
+                    NumBinary
+                )
+            }
+
+            // === Number bitwise operations ===
+            SlotAccessor::NbLshift => {
+                if name.as_str() == "__rlshift__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_lshift,
+                        number_binary_right_op_wrapper!(__rlshift__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        lshift,
+                        number_binary_op_wrapper!(__lshift__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceLshift => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_lshift,
+                    number_binary_op_wrapper!(__ilshift__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbRshift => {
+                if name.as_str() == "__rrshift__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_rshift,
+                        number_binary_right_op_wrapper!(__rrshift__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        rshift,
+                        number_binary_op_wrapper!(__rshift__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceRshift => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_rshift,
+                    number_binary_op_wrapper!(__irshift__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbAnd => {
+                if name.as_str() == "__rand__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_and,
+                        number_binary_right_op_wrapper!(__rand__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        and,
+                        number_binary_op_wrapper!(__and__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceAnd => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_and,
+                    number_binary_op_wrapper!(__iand__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbXor => {
+                if name.as_str() == "__rxor__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_xor,
+                        number_binary_right_op_wrapper!(__rxor__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(
+                        as_number,
+                        xor,
+                        number_binary_op_wrapper!(__xor__),
+                        NumBinary
+                    )
+                }
+            }
+            SlotAccessor::NbInplaceXor => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_xor,
+                    number_binary_op_wrapper!(__ixor__),
+                    NumBinary
+                )
+            }
+            SlotAccessor::NbOr => {
+                if name.as_str() == "__ror__" {
+                    update_sub_slot!(
+                        as_number,
+                        right_or,
+                        number_binary_right_op_wrapper!(__ror__),
+                        NumBinary
+                    )
+                } else {
+                    update_sub_slot!(as_number, or, number_binary_op_wrapper!(__or__), NumBinary)
+                }
+            }
+            SlotAccessor::NbInplaceOr => {
+                update_sub_slot!(
+                    as_number,
+                    inplace_or,
+                    number_binary_op_wrapper!(__ior__),
+                    NumBinary
+                )
+            }
+
+            // === Number unary operations ===
+            SlotAccessor::NbNegative => {
+                update_sub_slot!(
+                    as_number,
+                    negative,
+                    number_unary_op_wrapper!(__neg__),
+                    NumUnary
+                )
+            }
+            SlotAccessor::NbPositive => {
+                update_sub_slot!(
+                    as_number,
+                    positive,
+                    number_unary_op_wrapper!(__pos__),
+                    NumUnary
+                )
+            }
+            SlotAccessor::NbAbsolute => {
+                update_sub_slot!(
+                    as_number,
+                    absolute,
+                    number_unary_op_wrapper!(__abs__),
+                    NumUnary
+                )
+            }
+            SlotAccessor::NbInvert => {
+                update_sub_slot!(
+                    as_number,
+                    invert,
+                    number_unary_op_wrapper!(__invert__),
+                    NumUnary
+                )
+            }
+            SlotAccessor::NbBool => {
+                update_sub_slot!(as_number, boolean, bool_wrapper, NumBoolean)
+            }
+            SlotAccessor::NbInt => {
+                update_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__), NumUnary)
+            }
+            SlotAccessor::NbFloat => {
+                update_sub_slot!(
+                    as_number,
+                    float,
+                    number_unary_op_wrapper!(__float__),
+                    NumUnary
+                )
+            }
+            SlotAccessor::NbIndex => {
+                update_sub_slot!(
+                    as_number,
+                    index,
+                    number_unary_op_wrapper!(__index__),
+                    NumUnary
+                )
+            }
+
+            // === Sequence slots ===
+            SlotAccessor::SqLength => {
+                update_sub_slot!(as_sequence, length, sequence_len_wrapper, SeqLength)
+            }
+            SlotAccessor::SqConcat | SlotAccessor::SqInplaceConcat => {
+                // Sequence concat uses sq_concat slot - no generic wrapper needed
+                // (handled by number protocol fallback)
+                if !ADD {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::SqRepeat => {
+                update_sub_slot!(as_sequence, repeat, sequence_repeat_wrapper, SeqRepeat)
+            }
+            SlotAccessor::SqInplaceRepeat => {
+                update_sub_slot!(
+                    as_sequence,
+                    inplace_repeat,
+                    sequence_inplace_repeat_wrapper,
+                    SeqRepeat
+                )
+            }
+            SlotAccessor::SqItem => {
+                update_sub_slot!(as_sequence, item, sequence_getitem_wrapper, SeqItem)
+            }
+            SlotAccessor::SqAssItem => {
+                // SqAssItem is shared by __setitem__ (SeqSetItem) and __delitem__ (SeqDelItem)
+                if ADD {
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        let setitem = ctx.intern_str("__setitem__");
+                        let delitem = ctx.intern_str("__delitem__");
+                        guard.contains_key(setitem) || guard.contains_key(delitem)
+                    };
+                    if has_own {
+                        self.slots
+                            .as_sequence
+                            .ass_item
+                            .store(Some(sequence_setitem_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::SeqSetItem(f) | SlotFunc::SeqDelItem(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.as_sequence.ass_item.store(Some(func));
+                    } else {
+                        self.slots
+                            .as_sequence
+                            .ass_item
+                            .store(Some(sequence_setitem_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+            SlotAccessor::SqContains => {
+                update_sub_slot!(
+                    as_sequence,
+                    contains,
+                    sequence_contains_wrapper,
+                    SeqContains
+                )
+            }
+
+            // === Mapping slots ===
+            SlotAccessor::MpLength => {
+                update_sub_slot!(as_mapping, length, mapping_len_wrapper, MapLength)
+            }
+            SlotAccessor::MpSubscript => {
+                update_sub_slot!(as_mapping, subscript, mapping_getitem_wrapper, MapSubscript)
+            }
+            SlotAccessor::MpAssSubscript => {
+                // MpAssSubscript is shared by __setitem__ (MapSetSubscript) and __delitem__ (MapDelSubscript)
+                if ADD {
+                    let has_own = {
+                        let guard = self.attributes.read();
+                        let setitem = ctx.intern_str("__setitem__");
+                        let delitem = ctx.intern_str("__delitem__");
+                        guard.contains_key(setitem) || guard.contains_key(delitem)
+                    };
+                    if has_own {
+                        self.slots
+                            .as_mapping
+                            .ass_subscript
+                            .store(Some(mapping_setitem_wrapper));
+                    } else if let Some(func) = self.lookup_slot_in_mro(name, ctx, |sf| match sf {
+                        SlotFunc::MapSetSubscript(f) | SlotFunc::MapDelSubscript(f) => Some(*f),
+                        _ => None,
+                    }) {
+                        self.slots.as_mapping.ass_subscript.store(Some(func));
+                    } else {
+                        self.slots
+                            .as_mapping
+                            .ass_subscript
+                            .store(Some(mapping_setitem_wrapper));
+                    }
+                } else {
+                    accessor.inherit_from_mro(self);
+                }
+            }
+
+            // Reserved slots - no-op
+            _ => {}
+        }
+    }
+
+    /// Look up a method in MRO and extract the slot function if it's a slot wrapper.
+    /// Returns Some(slot_func) if a matching slot wrapper is found, None if a real method
+    /// is found or no method exists.
+    fn lookup_slot_in_mro<T: Copy>(
+        &self,
+        name: &'static PyStrInterned,
+        ctx: &Context,
+        extract: impl Fn(&crate::builtins::descriptor::SlotFunc) -> Option<T>,
+    ) -> Option<T> {
+        use crate::builtins::descriptor::PyWrapper;
+
+        // Helper to check if a class is a subclass of another by checking MRO
+        let is_subclass_of = |subclass_mro: &[PyRef<PyType>], superclass: &Py<PyType>| -> bool {
+            subclass_mro.iter().any(|c| c.is(superclass))
+        };
+
+        // Helper to extract slot from an attribute if it's a wrapper descriptor
+        // and the wrapper's type is compatible with the given class.
+        // bpo-37619: wrapper descriptor from wrong class should not be used directly.
+        let try_extract = |attr: &PyObjectRef, for_class_mro: &[PyRef<PyType>]| -> Option<T> {
+            if attr.class().is(ctx.types.wrapper_descriptor_type) {
+                attr.downcast_ref::<PyWrapper>().and_then(|wrapper| {
+                    // Only extract slot if for_class is a subclass of wrapper.typ
+                    if is_subclass_of(for_class_mro, wrapper.typ) {
+                        extract(&wrapper.wrapped)
+                    } else {
+                        None
+                    }
+                })
+            } else {
+                None
+            }
+        };
+
+        let mro = self.mro.read();
+
+        // Look up in self's dict first
+        if let Some(attr) = self.attributes.read().get(name).cloned() {
+            if let Some(func) = try_extract(&attr, &mro) {
+                return Some(func);
+            }
+            return None;
+        }
+
+        // Look up in MRO (mro[0] is self, so skip it)
+        for (i, cls) in mro[1..].iter().enumerate() {
+            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 None;
+            }
+        }
+        // No method found in MRO
+        None
+    }
+}
+
+/// Trait for types that can be constructed via Python's `__new__` method.
+///
+/// `slot_new` corresponds to the `__new__` type slot.
+///
+/// In most cases, `__new__` simply initializes the payload and assigns a type,
+/// so you only need to override `py_new`. The default `slot_new` implementation
+/// will call `py_new` and then wrap the result with `into_ref_with_type`.
+///
+/// However, if a subtype requires more than just payload initialization
+/// (e.g., returning an existing object for optimization, setting attributes
+/// after creation, or special handling of the class type), you should override
+/// `slot_new` directly instead of `py_new`.
+///
+/// # When to use `py_new` only (most common case):
+/// - Simple payload initialization that just creates `Self`
+/// - The type doesn't need special handling for subtypes
+///
+/// # When to override `slot_new`:
+/// - Returning existing objects (e.g., `PyInt`, `PyStr`, `PyBool` for optimization)
+/// - Setting attributes or dict entries after object creation
+/// - Special class type handling (e.g., `PyType` and its metaclasses)
+/// - Post-creation mutations that require `PyRef`
+#[pyclass]
+pub trait Constructor: PyPayload + core::fmt::Debug {
+    type Args: FromArgs;
+
+    /// The type slot for `__new__`. Override this only when you need special
+    /// behavior beyond simple payload creation.
+    #[inline]
+    #[pyslot]
+    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        let args: Self::Args = args.bind(vm)?;
+        let payload = Self::py_new(&cls, args, vm)?;
+        payload.into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    /// Creates the payload for this type. In most cases, just implement this method
+    /// and let the default `slot_new` handle wrapping with the correct type.
+    fn py_new(cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self>;
+}
+
+pub trait DefaultConstructor: PyPayload + Default + core::fmt::Debug {
+    fn construct_and_init(args: Self::Args, vm: &VirtualMachine) -> PyResult<PyRef<Self>>
+    where
+        Self: Initializer,
+    {
+        let this = Self::default().into_ref(&vm.ctx);
+        Self::init(this.clone(), args, vm)?;
+        Ok(this)
+    }
+}
+
+impl<T> Constructor for T
+where
+    T: DefaultConstructor,
+{
+    type Args = FuncArgs;
+
+    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
+        Self::default().into_ref_with_type(vm, cls).map(Into::into)
+    }
+
+    fn py_new(cls: &Py<PyType>, _args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
+        Err(vm.new_type_error(format!("cannot create {} instances", cls.slot_name())))
+    }
+}
+
+#[pyclass]
+pub trait Initializer: PyPayload {
+    type Args: FromArgs;
+
+    #[inline]
+    #[pyslot]
+    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
+        #[cfg(debug_assertions)]
+        let class_name_for_debug = zelf.class().name().to_string();
+
+        let zelf = match zelf.try_into_value(vm) {
+            Ok(zelf) => zelf,
+            Err(err) => {
+                #[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;
+                        if double_appearance {
+                            panic!(
+                                "This type `{}` doesn't seem to support `init`. Override `slot_init` instead: {}",
+                                class_name_for_debug, msg
+                            );
+                        }
+                    }
+                }
+                return Err(err);
+            }
+        };
+        let args: Self::Args = args.bind(vm)?;
+        Self::init(zelf, args, vm)
+    }
+
+    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()>;
+}
+
+#[pyclass]
+pub trait Destructor: PyPayload {
+    #[inline] // for __del__
+    #[pyslot]
+    fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+        let zelf = zelf
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __del__"))?;
+        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<()>;
+}
+
+#[pyclass]
+pub trait Callable: PyPayload {
+    type Args: FromArgs;
+
+    #[inline]
+    #[pyslot]
+    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()
+            } else {
+                zelf.class().name().to_owned()
+            };
+            vm.new_type_error(format!("unexpected payload for __call__ of {help}"))
+        })?;
+        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;
+}
+
+#[pyclass]
+pub trait GetDescriptor: PyPayload {
+    #[pyslot]
+    fn descr_get(
+        zelf: PyObjectRef,
+        obj: Option<PyObjectRef>,
+        cls: Option<PyObjectRef>,
+        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)
+    }
+
+    #[inline]
+    fn _unwrap<'a>(
+        zelf: &'a PyObject,
+        obj: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult<(&'a Py<Self>, PyObjectRef)> {
+        let zelf = Self::_as_pyref(zelf, vm)?;
+        let obj = vm.unwrap_or_none(obj);
+        Ok((zelf, obj))
+    }
+
+    #[inline]
+    fn _check<'a>(
+        zelf: &'a PyObject,
+        obj: Option<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> Option<(&'a Py<Self>, PyObjectRef)> {
+        // CPython descr_check
+        let obj = obj?;
+        // if (!PyObject_TypeCheck(obj, descr->d_type)) {
+        //     PyErr_Format(PyExc_TypeError,
+        //                  "descriptor '%V' for '%.100s' objects "
+        //                  "doesn't apply to a '%.100s' object",
+        //                  descr_name((PyDescrObject *)descr), "?",
+        //                  descr->d_type->slot_name,
+        //                  obj->ob_type->slot_name);
+        //     *pres = NULL;
+        //     return 1;
+        // } else {
+        Some((Self::_as_pyref(zelf, vm).unwrap(), obj))
+    }
+
+    #[inline]
+    fn _cls_is(cls: &Option<PyObjectRef>, other: &impl Borrow<PyObject>) -> bool {
+        cls.as_ref().is_some_and(|cls| other.borrow().is(cls))
+    }
+}
+
+#[pyclass]
+pub trait Hashable: PyPayload {
+    #[inline]
+    #[pyslot]
+    fn slot_hash(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
+        let zelf = zelf
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __hash__"))?;
+        Self::hash(zelf, vm)
+    }
+
+    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>;
+}
+
+#[pyclass]
+pub trait Representable: PyPayload {
+    #[inline]
+    #[pyslot]
+    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        let zelf = zelf
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __repr__"))?;
+        Self::repr(zelf, vm)
+    }
+
+    #[inline]
+    fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
+        let repr = Self::repr_str(zelf, vm)?;
+        Ok(vm.ctx.new_str(repr))
+    }
+
+    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>;
+}
+
+#[pyclass]
+pub trait Comparable: PyPayload {
+    #[inline]
+    #[pyslot]
+    fn slot_richcompare(
+        zelf: &PyObject,
+        other: &PyObject,
+        op: PyComparisonOp,
+        vm: &VirtualMachine,
+    ) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
+        let zelf = zelf.downcast_ref().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "unexpected payload for {}",
+                op.method_name(&vm.ctx).as_str()
+            ))
+        })?;
+        Self::cmp(zelf, other, op, vm).map(Either::B)
+    }
+
+    fn cmp(
+        zelf: &Py<Self>,
+        other: &PyObject,
+        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)]
+#[repr(transparent)]
+pub struct PyComparisonOp(ComparisonOperator);
+
+impl From<ComparisonOperator> for PyComparisonOp {
+    fn from(op: ComparisonOperator) -> Self {
+        Self(op)
+    }
+}
+
+#[allow(non_upper_case_globals)]
+impl PyComparisonOp {
+    pub const Lt: Self = Self(ComparisonOperator::Less);
+    pub const Gt: Self = Self(ComparisonOperator::Greater);
+    pub const Ne: Self = Self(ComparisonOperator::NotEqual);
+    pub const Eq: Self = Self(ComparisonOperator::Equal);
+    pub const Le: Self = Self(ComparisonOperator::LessOrEqual);
+    pub const Ge: Self = Self(ComparisonOperator::GreaterOrEqual);
+}
+
+impl PyComparisonOp {
+    pub fn eq_only(
+        self,
+        f: impl FnOnce() -> PyResult<PyComparisonValue>,
+    ) -> PyResult<PyComparisonValue> {
+        match self {
+            Self::Eq => f(),
+            Self::Ne => f().map(|x| x.map(|eq| !eq)),
+            _ => Ok(PyComparisonValue::NotImplemented),
+        }
+    }
+
+    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 const fn swapped(self) -> Self {
+        match self {
+            Self::Lt => Self::Gt,
+            Self::Le => Self::Ge,
+            Self::Eq => Self::Eq,
+            Self::Ne => Self::Ne,
+            Self::Ge => Self::Le,
+            Self::Gt => Self::Lt,
+        }
+    }
+
+    pub fn method_name(self, ctx: &Context) -> &'static PyStrInterned {
+        match self {
+            Self::Lt => identifier!(ctx, __lt__),
+            Self::Le => identifier!(ctx, __le__),
+            Self::Eq => identifier!(ctx, __eq__),
+            Self::Ne => identifier!(ctx, __ne__),
+            Self::Ge => identifier!(ctx, __ge__),
+            Self::Gt => identifier!(ctx, __gt__),
+        }
+    }
+
+    pub const fn operator_token(self) -> &'static str {
+        match self {
+            Self::Lt => "<",
+            Self::Le => "<=",
+            Self::Eq => "==",
+            Self::Ne => "!=",
+            Self::Ge => ">=",
+            Self::Gt => ">",
+        }
+    }
+
+    /// Returns an appropriate return value for the comparison when a and b are the same object, if an
+    /// appropriate return value exists.
+    #[inline]
+    pub fn identical_optimization(
+        self,
+        a: &impl Borrow<PyObject>,
+        b: &impl Borrow<PyObject>,
+    ) -> Option<bool> {
+        self.map_eq(|| a.borrow().is(b.borrow()))
+    }
+
+    /// Returns `Some(true)` when self is `Eq` and `f()` returns true. Returns `Some(false)` when self
+    /// is `Ne` and `f()` returns true. Otherwise returns `None`.
+    #[inline]
+    pub fn map_eq(self, f: impl FnOnce() -> bool) -> Option<bool> {
+        let eq = match self {
+            Self::Eq => true,
+            Self::Ne => false,
+            _ => return None,
+        };
+        f().then_some(eq)
+    }
+}
+
+#[pyclass]
+pub trait GetAttr: PyPayload {
+    #[pyslot]
+    fn slot_getattro(obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
+        let zelf = obj
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __getattribute__"))?;
+        Self::getattro(zelf, name, vm)
+    }
+
+    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]
+pub trait SetAttr: PyPayload {
+    #[pyslot]
+    #[inline]
+    fn slot_setattro(
+        obj: &PyObject,
+        name: &Py<PyStr>,
+        value: PySetterValue,
+        vm: &VirtualMachine,
+    ) -> PyResult<()> {
+        let zelf = obj
+            .downcast_ref::<Self>()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __setattr__"))?;
+        Self::setattro(zelf, name, value, vm)
+    }
+
+    fn setattro(
+        zelf: &Py<Self>,
+        name: &Py<PyStr>,
+        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]
+pub trait AsBuffer: PyPayload {
+    // TODO: `flags` parameter
+    #[inline]
+    #[pyslot]
+    fn slot_as_buffer(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyBuffer> {
+        let zelf = zelf
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for as_buffer"))?;
+        Self::as_buffer(zelf, vm)
+    }
+
+    fn as_buffer(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyBuffer>;
+}
+
+#[pyclass]
+pub trait AsMapping: PyPayload {
+    fn as_mapping() -> &'static PyMappingMethods;
+
+    #[inline]
+    fn mapping_downcast(mapping: PyMapping<'_>) -> &Py<Self> {
+        unsafe { mapping.obj.downcast_unchecked_ref() }
+    }
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_mapping.copy_from(Self::as_mapping());
+    }
+}
+
+#[pyclass]
+pub trait AsSequence: PyPayload {
+    fn as_sequence() -> &'static PySequenceMethods;
+
+    #[inline]
+    fn sequence_downcast(seq: PySequence<'_>) -> &Py<Self> {
+        unsafe { seq.obj.downcast_unchecked_ref() }
+    }
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_sequence.copy_from(Self::as_sequence());
+    }
+}
+
+#[pyclass]
+pub trait AsNumber: PyPayload {
+    #[pyslot]
+    fn as_number() -> &'static PyNumberMethods;
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        slots.as_number.copy_from(Self::as_number());
+    }
+
+    fn clone_exact(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
+        // not all AsNumber requires this implementation.
+        unimplemented!()
+    }
+
+    #[inline]
+    fn number_downcast(num: PyNumber<'_>) -> &Py<Self> {
+        unsafe { num.obj.downcast_unchecked_ref() }
+    }
+
+    #[inline]
+    fn number_downcast_exact(num: PyNumber<'_>, vm: &VirtualMachine) -> PyRef<Self> {
+        if let Some(zelf) = num.downcast_ref_if_exact::<Self>(vm) {
+            zelf.to_owned()
+        } else {
+            Self::clone_exact(Self::number_downcast(num), vm)
+        }
+    }
+}
+
+#[pyclass]
+pub trait Iterable: PyPayload {
+    #[pyslot]
+    fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let zelf = zelf
+            .downcast()
+            .map_err(|_| vm.new_type_error("unexpected payload for __iter__"))?;
+        Self::iter(zelf, vm)
+    }
+
+    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult;
+
+    fn extend_slots(_slots: &mut PyTypeSlots) {}
+}
+
+// `Iterator` fits better, but to avoid confusion with rust core::iter::Iterator
+#[pyclass(with(Iterable))]
+pub trait IterNext: PyPayload + Iterable {
+    #[pyslot]
+    fn slot_iternext(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
+        let zelf = zelf
+            .downcast_ref()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __next__"))?;
+        Self::next(zelf, vm)
+    }
+
+    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn>;
+}
+
+pub trait SelfIter: PyPayload {}
+
+impl<T> Iterable for T
+where
+    T: SelfIter,
+{
+    #[cold]
+    fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let repr = zelf.repr(vm)?;
+        unreachable!("slot must be overridden for {}", repr.as_str());
+    }
+
+    #[cold]
+    fn iter(_zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {
+        unreachable!("slot_iter is implemented");
+    }
+
+    fn extend_slots(slots: &mut PyTypeSlots) {
+        let prev = slots.iter.swap(Some(self_iter));
+        debug_assert!(prev.is_some()); // slot_iter would be set
+    }
+}
diff --git a/crates/vm/src/types/slot_defs.rs b/crates/vm/src/types/slot_defs.rs
new file mode 100644
index 0000000000..024776f789
--- /dev/null
+++ b/crates/vm/src/types/slot_defs.rs
@@ -0,0 +1,1497 @@
+//! Slot definitions array
+//!
+//! This module provides a centralized array of all slot definitions,
+
+use super::{PyComparisonOp, PyTypeSlots};
+use crate::builtins::descriptor::SlotFunc;
+
+/// Slot operation type
+///
+/// Used to distinguish between different operations that share the same slot:
+/// - RichCompare: Lt, Le, Eq, Ne, Gt, Ge
+/// - Binary ops: Left (__add__) vs Right (__radd__)
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum SlotOp {
+    // RichCompare operations
+    Lt,
+    Le,
+    Eq,
+    Ne,
+    Gt,
+    Ge,
+    // Binary operation direction
+    Left,
+    Right,
+    // Setter vs Deleter
+    Delete,
+}
+
+impl SlotOp {
+    /// Convert to PyComparisonOp if this is a comparison operation
+    pub fn as_compare_op(&self) -> Option<PyComparisonOp> {
+        match self {
+            Self::Lt => Some(PyComparisonOp::Lt),
+            Self::Le => Some(PyComparisonOp::Le),
+            Self::Eq => Some(PyComparisonOp::Eq),
+            Self::Ne => Some(PyComparisonOp::Ne),
+            Self::Gt => Some(PyComparisonOp::Gt),
+            Self::Ge => Some(PyComparisonOp::Ge),
+            _ => None,
+        }
+    }
+
+    /// Check if this is a right operation (__radd__, __rsub__, etc.)
+    pub fn is_right(&self) -> bool {
+        matches!(self, Self::Right)
+    }
+}
+
+/// Slot definition entry
+#[derive(Clone, Copy)]
+pub struct SlotDef {
+    /// Method name ("__init__", "__add__", etc.)
+    pub name: &'static str,
+
+    /// Slot accessor (which slot field to access)
+    pub accessor: SlotAccessor,
+
+    /// Operation type (for shared slots like RichCompare, binary ops)
+    pub op: Option<SlotOp>,
+
+    /// Documentation string
+    pub doc: &'static str,
+}
+
+/// Slot accessor
+///
+/// Values match CPython's Py_* slot IDs from typeslots.h.
+/// Unused slots are included for value reservation.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[repr(u8)]
+pub enum SlotAccessor {
+    // Buffer protocol (1-2) - Reserved, not used in RustPython
+    BfGetBuffer = 1,
+    BfReleaseBuffer = 2,
+
+    // Mapping protocol (3-5)
+    MpAssSubscript = 3,
+    MpLength = 4,
+    MpSubscript = 5,
+
+    // Number protocol (6-38)
+    NbAbsolute = 6,
+    NbAdd = 7,
+    NbAnd = 8,
+    NbBool = 9,
+    NbDivmod = 10,
+    NbFloat = 11,
+    NbFloorDivide = 12,
+    NbIndex = 13,
+    NbInplaceAdd = 14,
+    NbInplaceAnd = 15,
+    NbInplaceFloorDivide = 16,
+    NbInplaceLshift = 17,
+    NbInplaceMultiply = 18,
+    NbInplaceOr = 19,
+    NbInplacePower = 20,
+    NbInplaceRemainder = 21,
+    NbInplaceRshift = 22,
+    NbInplaceSubtract = 23,
+    NbInplaceTrueDivide = 24,
+    NbInplaceXor = 25,
+    NbInt = 26,
+    NbInvert = 27,
+    NbLshift = 28,
+    NbMultiply = 29,
+    NbNegative = 30,
+    NbOr = 31,
+    NbPositive = 32,
+    NbPower = 33,
+    NbRemainder = 34,
+    NbRshift = 35,
+    NbSubtract = 36,
+    NbTrueDivide = 37,
+    NbXor = 38,
+
+    // Sequence protocol (39-46)
+    SqAssItem = 39,
+    SqConcat = 40,
+    SqContains = 41,
+    SqInplaceConcat = 42,
+    SqInplaceRepeat = 43,
+    SqItem = 44,
+    SqLength = 45,
+    SqRepeat = 46,
+
+    // Type slots (47-74)
+    TpAlloc = 47, // Reserved
+    TpBase = 48,  // Reserved
+    TpBases = 49, // Reserved
+    TpCall = 50,
+    TpClear = 51,   // Reserved
+    TpDealloc = 52, // Reserved
+    TpDel = 53,
+    TpDescrGet = 54,
+    TpDescrSet = 55,
+    TpDoc = 56,     // Reserved
+    TpGetattr = 57, // Reserved (use TpGetattro)
+    TpGetattro = 58,
+    TpHash = 59,
+    TpInit = 60,
+    TpIsGc = 61, // Reserved
+    TpIter = 62,
+    TpIternext = 63,
+    TpMethods = 64, // Reserved
+    TpNew = 65,
+    TpRepr = 66,
+    TpRichcompare = 67,
+    TpSetattr = 68, // Reserved (use TpSetattro)
+    TpSetattro = 69,
+    TpStr = 70,
+    TpTraverse = 71, // Reserved
+    TpMembers = 72,  // Reserved
+    TpGetset = 73,   // Reserved
+    TpFree = 74,     // Reserved
+
+    // Number protocol additions (75-76)
+    NbMatrixMultiply = 75,
+    NbInplaceMatrixMultiply = 76,
+
+    // Async protocol (77-81) - Reserved for future
+    AmAwait = 77,
+    AmAiter = 78,
+    AmAnext = 79,
+    TpFinalize = 80,
+    AmSend = 81,
+}
+
+impl SlotAccessor {
+    /// Check if this accessor is for a reserved/unused slot
+    pub fn is_reserved(&self) -> bool {
+        matches!(
+            self,
+            Self::BfGetBuffer
+                | Self::BfReleaseBuffer
+                | Self::TpAlloc
+                | Self::TpBase
+                | Self::TpBases
+                | Self::TpClear
+                | Self::TpDealloc
+                | Self::TpDoc
+                | Self::TpGetattr
+                | Self::TpIsGc
+                | Self::TpMethods
+                | Self::TpSetattr
+                | Self::TpTraverse
+                | Self::TpMembers
+                | Self::TpGetset
+                | Self::TpFree
+                | Self::TpFinalize
+                | Self::AmAwait
+                | Self::AmAiter
+                | Self::AmAnext
+                | Self::AmSend
+        )
+    }
+
+    /// Check if this is a number binary operation slot
+    pub fn is_number_binary(&self) -> bool {
+        matches!(
+            self,
+            Self::NbAdd
+                | Self::NbSubtract
+                | Self::NbMultiply
+                | Self::NbRemainder
+                | Self::NbDivmod
+                | Self::NbPower
+                | Self::NbLshift
+                | Self::NbRshift
+                | Self::NbAnd
+                | Self::NbXor
+                | Self::NbOr
+                | Self::NbFloorDivide
+                | Self::NbTrueDivide
+                | Self::NbMatrixMultiply
+        )
+    }
+
+    /// Check if this accessor refers to a shared slot
+    ///
+    /// Shared slots are used by multiple dunder methods:
+    /// - TpSetattro: __setattr__ and __delattr__
+    /// - TpRichcompare: __lt__, __le__, __eq__, __ne__, __gt__, __ge__
+    /// - TpDescrSet: __set__ and __delete__
+    /// - SqAssItem/MpAssSubscript: __setitem__ and __delitem__
+    /// - Number binaries: __add__ and __radd__, etc.
+    pub fn is_shared_slot(&self) -> bool {
+        matches!(
+            self,
+            Self::TpSetattro
+                | Self::TpRichcompare
+                | Self::TpDescrSet
+                | Self::SqAssItem
+                | Self::MpAssSubscript
+        ) || self.is_number_binary()
+    }
+
+    /// Get underlying slot field name for debugging
+    pub fn slot_name(&self) -> &'static str {
+        match self {
+            Self::BfGetBuffer => "bf_getbuffer",
+            Self::BfReleaseBuffer => "bf_releasebuffer",
+            Self::MpAssSubscript => "mp_ass_subscript",
+            Self::MpLength => "mp_length",
+            Self::MpSubscript => "mp_subscript",
+            Self::NbAbsolute => "nb_absolute",
+            Self::NbAdd => "nb_add",
+            Self::NbAnd => "nb_and",
+            Self::NbBool => "nb_bool",
+            Self::NbDivmod => "nb_divmod",
+            Self::NbFloat => "nb_float",
+            Self::NbFloorDivide => "nb_floor_divide",
+            Self::NbIndex => "nb_index",
+            Self::NbInplaceAdd => "nb_inplace_add",
+            Self::NbInplaceAnd => "nb_inplace_and",
+            Self::NbInplaceFloorDivide => "nb_inplace_floor_divide",
+            Self::NbInplaceLshift => "nb_inplace_lshift",
+            Self::NbInplaceMultiply => "nb_inplace_multiply",
+            Self::NbInplaceOr => "nb_inplace_or",
+            Self::NbInplacePower => "nb_inplace_power",
+            Self::NbInplaceRemainder => "nb_inplace_remainder",
+            Self::NbInplaceRshift => "nb_inplace_rshift",
+            Self::NbInplaceSubtract => "nb_inplace_subtract",
+            Self::NbInplaceTrueDivide => "nb_inplace_true_divide",
+            Self::NbInplaceXor => "nb_inplace_xor",
+            Self::NbInt => "nb_int",
+            Self::NbInvert => "nb_invert",
+            Self::NbLshift => "nb_lshift",
+            Self::NbMultiply => "nb_multiply",
+            Self::NbNegative => "nb_negative",
+            Self::NbOr => "nb_or",
+            Self::NbPositive => "nb_positive",
+            Self::NbPower => "nb_power",
+            Self::NbRemainder => "nb_remainder",
+            Self::NbRshift => "nb_rshift",
+            Self::NbSubtract => "nb_subtract",
+            Self::NbTrueDivide => "nb_true_divide",
+            Self::NbXor => "nb_xor",
+            Self::SqAssItem => "sq_ass_item",
+            Self::SqConcat => "sq_concat",
+            Self::SqContains => "sq_contains",
+            Self::SqInplaceConcat => "sq_inplace_concat",
+            Self::SqInplaceRepeat => "sq_inplace_repeat",
+            Self::SqItem => "sq_item",
+            Self::SqLength => "sq_length",
+            Self::SqRepeat => "sq_repeat",
+            Self::TpAlloc => "tp_alloc",
+            Self::TpBase => "tp_base",
+            Self::TpBases => "tp_bases",
+            Self::TpCall => "tp_call",
+            Self::TpClear => "tp_clear",
+            Self::TpDealloc => "tp_dealloc",
+            Self::TpDel => "tp_del",
+            Self::TpDescrGet => "tp_descr_get",
+            Self::TpDescrSet => "tp_descr_set",
+            Self::TpDoc => "tp_doc",
+            Self::TpGetattr => "tp_getattr",
+            Self::TpGetattro => "tp_getattro",
+            Self::TpHash => "tp_hash",
+            Self::TpInit => "tp_init",
+            Self::TpIsGc => "tp_is_gc",
+            Self::TpIter => "tp_iter",
+            Self::TpIternext => "tp_iternext",
+            Self::TpMethods => "tp_methods",
+            Self::TpNew => "tp_new",
+            Self::TpRepr => "tp_repr",
+            Self::TpRichcompare => "tp_richcompare",
+            Self::TpSetattr => "tp_setattr",
+            Self::TpSetattro => "tp_setattro",
+            Self::TpStr => "tp_str",
+            Self::TpTraverse => "tp_traverse",
+            Self::TpMembers => "tp_members",
+            Self::TpGetset => "tp_getset",
+            Self::TpFree => "tp_free",
+            Self::NbMatrixMultiply => "nb_matrix_multiply",
+            Self::NbInplaceMatrixMultiply => "nb_inplace_matrix_multiply",
+            Self::AmAwait => "am_await",
+            Self::AmAiter => "am_aiter",
+            Self::AmAnext => "am_anext",
+            Self::TpFinalize => "tp_finalize",
+            Self::AmSend => "am_send",
+        }
+    }
+
+    /// Extract the raw function pointer from a SlotFunc if it matches this accessor's type
+    pub fn extract_from_slot_func(&self, slot_func: &SlotFunc) -> bool {
+        match self {
+            // Type slots
+            Self::TpHash => matches!(slot_func, SlotFunc::Hash(_)),
+            Self::TpRepr => matches!(slot_func, SlotFunc::Repr(_)),
+            Self::TpStr => matches!(slot_func, SlotFunc::Str(_)),
+            Self::TpCall => matches!(slot_func, SlotFunc::Call(_)),
+            Self::TpIter => matches!(slot_func, SlotFunc::Iter(_)),
+            Self::TpIternext => matches!(slot_func, SlotFunc::IterNext(_)),
+            Self::TpInit => matches!(slot_func, SlotFunc::Init(_)),
+            Self::TpDel => matches!(slot_func, SlotFunc::Del(_)),
+            Self::TpGetattro => matches!(slot_func, SlotFunc::GetAttro(_)),
+            Self::TpSetattro => {
+                matches!(slot_func, SlotFunc::SetAttro(_) | SlotFunc::DelAttro(_))
+            }
+            Self::TpDescrGet => matches!(slot_func, SlotFunc::DescrGet(_)),
+            Self::TpDescrSet => {
+                matches!(slot_func, SlotFunc::DescrSet(_) | SlotFunc::DescrDel(_))
+            }
+            Self::TpRichcompare => matches!(slot_func, SlotFunc::RichCompare(_, _)),
+
+            // Number - Power (ternary)
+            Self::NbPower | Self::NbInplacePower => {
+                matches!(slot_func, SlotFunc::NumTernary(_))
+            }
+            // Number - Boolean
+            Self::NbBool => matches!(slot_func, SlotFunc::NumBoolean(_)),
+            // Number - Unary
+            Self::NbNegative
+            | Self::NbPositive
+            | Self::NbAbsolute
+            | Self::NbInvert
+            | Self::NbInt
+            | Self::NbFloat
+            | Self::NbIndex => matches!(slot_func, SlotFunc::NumUnary(_)),
+            // Number - Binary
+            Self::NbAdd
+            | Self::NbSubtract
+            | Self::NbMultiply
+            | Self::NbRemainder
+            | Self::NbDivmod
+            | Self::NbLshift
+            | Self::NbRshift
+            | Self::NbAnd
+            | Self::NbXor
+            | Self::NbOr
+            | Self::NbFloorDivide
+            | Self::NbTrueDivide
+            | Self::NbMatrixMultiply
+            | Self::NbInplaceAdd
+            | Self::NbInplaceSubtract
+            | Self::NbInplaceMultiply
+            | Self::NbInplaceRemainder
+            | Self::NbInplaceLshift
+            | Self::NbInplaceRshift
+            | Self::NbInplaceAnd
+            | Self::NbInplaceXor
+            | Self::NbInplaceOr
+            | Self::NbInplaceFloorDivide
+            | Self::NbInplaceTrueDivide
+            | Self::NbInplaceMatrixMultiply => matches!(slot_func, SlotFunc::NumBinary(_)),
+
+            // Sequence
+            Self::SqLength => matches!(slot_func, SlotFunc::SeqLength(_)),
+            Self::SqConcat | Self::SqInplaceConcat => matches!(slot_func, SlotFunc::SeqConcat(_)),
+            Self::SqRepeat | Self::SqInplaceRepeat => matches!(slot_func, SlotFunc::SeqRepeat(_)),
+            Self::SqItem => matches!(slot_func, SlotFunc::SeqItem(_)),
+            Self::SqAssItem => {
+                matches!(slot_func, SlotFunc::SeqSetItem(_) | SlotFunc::SeqDelItem(_))
+            }
+            Self::SqContains => matches!(slot_func, SlotFunc::SeqContains(_)),
+
+            // Mapping
+            Self::MpLength => matches!(slot_func, SlotFunc::MapLength(_)),
+            Self::MpSubscript => matches!(slot_func, SlotFunc::MapSubscript(_)),
+            Self::MpAssSubscript => {
+                matches!(
+                    slot_func,
+                    SlotFunc::MapSetSubscript(_) | SlotFunc::MapDelSubscript(_)
+                )
+            }
+
+            // New and reserved slots
+            Self::TpNew => false,
+            _ => false, // Reserved slots
+        }
+    }
+
+    /// Inherit slot value from MRO
+    pub fn inherit_from_mro(&self, typ: &crate::builtins::PyType) {
+        // mro[0] is self, so skip it
+        let mro_guard = typ.mro.read();
+        let mro = &mro_guard[1..];
+
+        macro_rules! inherit_main {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.$slot.load());
+                typ.slots.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_number {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.as_number.$slot.load());
+                typ.slots.as_number.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_sequence {
+            ($slot:ident) => {{
+                let inherited = mro
+                    .iter()
+                    .find_map(|cls| cls.slots.as_sequence.$slot.load());
+                typ.slots.as_sequence.$slot.store(inherited);
+            }};
+        }
+
+        macro_rules! inherit_mapping {
+            ($slot:ident) => {{
+                let inherited = mro.iter().find_map(|cls| cls.slots.as_mapping.$slot.load());
+                typ.slots.as_mapping.$slot.store(inherited);
+            }};
+        }
+
+        match self {
+            // Type slots
+            Self::TpHash => inherit_main!(hash),
+            Self::TpRepr => inherit_main!(repr),
+            Self::TpStr => inherit_main!(str),
+            Self::TpCall => inherit_main!(call),
+            Self::TpIter => inherit_main!(iter),
+            Self::TpIternext => inherit_main!(iternext),
+            Self::TpInit => inherit_main!(init),
+            Self::TpNew => inherit_main!(new),
+            Self::TpDel => inherit_main!(del),
+            Self::TpGetattro => inherit_main!(getattro),
+            Self::TpSetattro => inherit_main!(setattro),
+            Self::TpDescrGet => inherit_main!(descr_get),
+            Self::TpDescrSet => inherit_main!(descr_set),
+            Self::TpRichcompare => inherit_main!(richcompare),
+
+            // Number slots
+            Self::NbAdd => inherit_number!(add),
+            Self::NbSubtract => inherit_number!(subtract),
+            Self::NbMultiply => inherit_number!(multiply),
+            Self::NbRemainder => inherit_number!(remainder),
+            Self::NbDivmod => inherit_number!(divmod),
+            Self::NbPower => inherit_number!(power),
+            Self::NbLshift => inherit_number!(lshift),
+            Self::NbRshift => inherit_number!(rshift),
+            Self::NbAnd => inherit_number!(and),
+            Self::NbXor => inherit_number!(xor),
+            Self::NbOr => inherit_number!(or),
+            Self::NbFloorDivide => inherit_number!(floor_divide),
+            Self::NbTrueDivide => inherit_number!(true_divide),
+            Self::NbMatrixMultiply => inherit_number!(matrix_multiply),
+            Self::NbInplaceAdd => inherit_number!(inplace_add),
+            Self::NbInplaceSubtract => inherit_number!(inplace_subtract),
+            Self::NbInplaceMultiply => inherit_number!(inplace_multiply),
+            Self::NbInplaceRemainder => inherit_number!(inplace_remainder),
+            Self::NbInplacePower => inherit_number!(inplace_power),
+            Self::NbInplaceLshift => inherit_number!(inplace_lshift),
+            Self::NbInplaceRshift => inherit_number!(inplace_rshift),
+            Self::NbInplaceAnd => inherit_number!(inplace_and),
+            Self::NbInplaceXor => inherit_number!(inplace_xor),
+            Self::NbInplaceOr => inherit_number!(inplace_or),
+            Self::NbInplaceFloorDivide => inherit_number!(inplace_floor_divide),
+            Self::NbInplaceTrueDivide => inherit_number!(inplace_true_divide),
+            Self::NbInplaceMatrixMultiply => inherit_number!(inplace_matrix_multiply),
+            // Number unary
+            Self::NbNegative => inherit_number!(negative),
+            Self::NbPositive => inherit_number!(positive),
+            Self::NbAbsolute => inherit_number!(absolute),
+            Self::NbInvert => inherit_number!(invert),
+            Self::NbBool => inherit_number!(boolean),
+            Self::NbInt => inherit_number!(int),
+            Self::NbFloat => inherit_number!(float),
+            Self::NbIndex => inherit_number!(index),
+
+            // Sequence slots
+            Self::SqLength => inherit_sequence!(length),
+            Self::SqConcat => inherit_sequence!(concat),
+            Self::SqRepeat => inherit_sequence!(repeat),
+            Self::SqItem => inherit_sequence!(item),
+            Self::SqAssItem => inherit_sequence!(ass_item),
+            Self::SqContains => inherit_sequence!(contains),
+            Self::SqInplaceConcat => inherit_sequence!(inplace_concat),
+            Self::SqInplaceRepeat => inherit_sequence!(inplace_repeat),
+
+            // Mapping slots
+            Self::MpLength => inherit_mapping!(length),
+            Self::MpSubscript => inherit_mapping!(subscript),
+            Self::MpAssSubscript => inherit_mapping!(ass_subscript),
+
+            // Reserved slots - no-op
+            _ => {}
+        }
+    }
+
+    /// Copy slot from base type if self's slot is None
+    pub fn copyslot_if_none(&self, typ: &crate::builtins::PyType, base: &crate::builtins::PyType) {
+        macro_rules! copy_main {
+            ($slot:ident) => {{
+                if typ.slots.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.$slot.load() {
+                        typ.slots.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_number {
+            ($slot:ident) => {{
+                if typ.slots.as_number.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_number.$slot.load() {
+                        typ.slots.as_number.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_sequence {
+            ($slot:ident) => {{
+                if typ.slots.as_sequence.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_sequence.$slot.load() {
+                        typ.slots.as_sequence.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        macro_rules! copy_mapping {
+            ($slot:ident) => {{
+                if typ.slots.as_mapping.$slot.load().is_none() {
+                    if let Some(base_val) = base.slots.as_mapping.$slot.load() {
+                        typ.slots.as_mapping.$slot.store(Some(base_val));
+                    }
+                }
+            }};
+        }
+
+        match self {
+            // Type slots
+            Self::TpHash => copy_main!(hash),
+            Self::TpRepr => copy_main!(repr),
+            Self::TpStr => copy_main!(str),
+            Self::TpCall => copy_main!(call),
+            Self::TpIter => copy_main!(iter),
+            Self::TpIternext => copy_main!(iternext),
+            Self::TpInit => {
+                // SLOTDEFINED check for multiple inheritance support
+                if typ.slots.init.load().is_none()
+                    && let Some(base_val) = base.slots.init.load()
+                {
+                    let slot_defined = base.base.as_ref().is_none_or(|bb| {
+                        bb.slots.init.load().map(|v| v as usize) != Some(base_val as usize)
+                    });
+                    if slot_defined {
+                        typ.slots.init.store(Some(base_val));
+                    }
+                }
+            }
+            Self::TpNew => {} // handled by set_new()
+            Self::TpDel => copy_main!(del),
+            Self::TpGetattro => copy_main!(getattro),
+            Self::TpSetattro => copy_main!(setattro),
+            Self::TpDescrGet => copy_main!(descr_get),
+            Self::TpDescrSet => copy_main!(descr_set),
+            Self::TpRichcompare => copy_main!(richcompare),
+
+            // Number slots
+            Self::NbAdd => copy_number!(add),
+            Self::NbSubtract => copy_number!(subtract),
+            Self::NbMultiply => copy_number!(multiply),
+            Self::NbRemainder => copy_number!(remainder),
+            Self::NbDivmod => copy_number!(divmod),
+            Self::NbPower => copy_number!(power),
+            Self::NbLshift => copy_number!(lshift),
+            Self::NbRshift => copy_number!(rshift),
+            Self::NbAnd => copy_number!(and),
+            Self::NbXor => copy_number!(xor),
+            Self::NbOr => copy_number!(or),
+            Self::NbFloorDivide => copy_number!(floor_divide),
+            Self::NbTrueDivide => copy_number!(true_divide),
+            Self::NbMatrixMultiply => copy_number!(matrix_multiply),
+            Self::NbInplaceAdd => copy_number!(inplace_add),
+            Self::NbInplaceSubtract => copy_number!(inplace_subtract),
+            Self::NbInplaceMultiply => copy_number!(inplace_multiply),
+            Self::NbInplaceRemainder => copy_number!(inplace_remainder),
+            Self::NbInplacePower => copy_number!(inplace_power),
+            Self::NbInplaceLshift => copy_number!(inplace_lshift),
+            Self::NbInplaceRshift => copy_number!(inplace_rshift),
+            Self::NbInplaceAnd => copy_number!(inplace_and),
+            Self::NbInplaceXor => copy_number!(inplace_xor),
+            Self::NbInplaceOr => copy_number!(inplace_or),
+            Self::NbInplaceFloorDivide => copy_number!(inplace_floor_divide),
+            Self::NbInplaceTrueDivide => copy_number!(inplace_true_divide),
+            Self::NbInplaceMatrixMultiply => copy_number!(inplace_matrix_multiply),
+            // Number unary
+            Self::NbNegative => copy_number!(negative),
+            Self::NbPositive => copy_number!(positive),
+            Self::NbAbsolute => copy_number!(absolute),
+            Self::NbInvert => copy_number!(invert),
+            Self::NbBool => copy_number!(boolean),
+            Self::NbInt => copy_number!(int),
+            Self::NbFloat => copy_number!(float),
+            Self::NbIndex => copy_number!(index),
+
+            // Sequence slots
+            Self::SqLength => copy_sequence!(length),
+            Self::SqConcat => copy_sequence!(concat),
+            Self::SqRepeat => copy_sequence!(repeat),
+            Self::SqItem => copy_sequence!(item),
+            Self::SqAssItem => copy_sequence!(ass_item),
+            Self::SqContains => copy_sequence!(contains),
+            Self::SqInplaceConcat => copy_sequence!(inplace_concat),
+            Self::SqInplaceRepeat => copy_sequence!(inplace_repeat),
+
+            // Mapping slots
+            Self::MpLength => copy_mapping!(length),
+            Self::MpSubscript => copy_mapping!(subscript),
+            Self::MpAssSubscript => copy_mapping!(ass_subscript),
+
+            // Reserved slots - no-op
+            _ => {}
+        }
+    }
+
+    /// Get the SlotFunc from type slots for this accessor
+    pub fn get_slot_func(&self, slots: &PyTypeSlots) -> Option<SlotFunc> {
+        match self {
+            // Type slots
+            Self::TpHash => slots.hash.load().map(SlotFunc::Hash),
+            Self::TpRepr => slots.repr.load().map(SlotFunc::Repr),
+            Self::TpStr => slots.str.load().map(SlotFunc::Str),
+            Self::TpCall => slots.call.load().map(SlotFunc::Call),
+            Self::TpIter => slots.iter.load().map(SlotFunc::Iter),
+            Self::TpIternext => slots.iternext.load().map(SlotFunc::IterNext),
+            Self::TpInit => slots.init.load().map(SlotFunc::Init),
+            Self::TpNew => None, // __new__ handled separately
+            Self::TpDel => slots.del.load().map(SlotFunc::Del),
+            Self::TpGetattro => slots.getattro.load().map(SlotFunc::GetAttro),
+            Self::TpSetattro => slots.setattro.load().map(SlotFunc::SetAttro),
+            Self::TpDescrGet => slots.descr_get.load().map(SlotFunc::DescrGet),
+            Self::TpDescrSet => slots.descr_set.load().map(SlotFunc::DescrSet),
+            Self::TpRichcompare => slots
+                .richcompare
+                .load()
+                .map(|f| SlotFunc::RichCompare(f, PyComparisonOp::Eq)),
+
+            // Number binary slots
+            Self::NbAdd => slots.as_number.add.load().map(SlotFunc::NumBinary),
+            Self::NbSubtract => slots.as_number.subtract.load().map(SlotFunc::NumBinary),
+            Self::NbMultiply => slots.as_number.multiply.load().map(SlotFunc::NumBinary),
+            Self::NbRemainder => slots.as_number.remainder.load().map(SlotFunc::NumBinary),
+            Self::NbDivmod => slots.as_number.divmod.load().map(SlotFunc::NumBinary),
+            Self::NbPower => slots.as_number.power.load().map(SlotFunc::NumTernary),
+            Self::NbLshift => slots.as_number.lshift.load().map(SlotFunc::NumBinary),
+            Self::NbRshift => slots.as_number.rshift.load().map(SlotFunc::NumBinary),
+            Self::NbAnd => slots.as_number.and.load().map(SlotFunc::NumBinary),
+            Self::NbXor => slots.as_number.xor.load().map(SlotFunc::NumBinary),
+            Self::NbOr => slots.as_number.or.load().map(SlotFunc::NumBinary),
+            Self::NbFloorDivide => slots.as_number.floor_divide.load().map(SlotFunc::NumBinary),
+            Self::NbTrueDivide => slots.as_number.true_divide.load().map(SlotFunc::NumBinary),
+            Self::NbMatrixMultiply => slots
+                .as_number
+                .matrix_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+
+            // Number inplace slots
+            Self::NbInplaceAdd => slots.as_number.inplace_add.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceSubtract => slots
+                .as_number
+                .inplace_subtract
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceMultiply => slots
+                .as_number
+                .inplace_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceRemainder => slots
+                .as_number
+                .inplace_remainder
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplacePower => slots
+                .as_number
+                .inplace_power
+                .load()
+                .map(SlotFunc::NumTernary),
+            Self::NbInplaceLshift => slots
+                .as_number
+                .inplace_lshift
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceRshift => slots
+                .as_number
+                .inplace_rshift
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceAnd => slots.as_number.inplace_and.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceXor => slots.as_number.inplace_xor.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceOr => slots.as_number.inplace_or.load().map(SlotFunc::NumBinary),
+            Self::NbInplaceFloorDivide => slots
+                .as_number
+                .inplace_floor_divide
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceTrueDivide => slots
+                .as_number
+                .inplace_true_divide
+                .load()
+                .map(SlotFunc::NumBinary),
+            Self::NbInplaceMatrixMultiply => slots
+                .as_number
+                .inplace_matrix_multiply
+                .load()
+                .map(SlotFunc::NumBinary),
+
+            // Number unary slots
+            Self::NbNegative => slots.as_number.negative.load().map(SlotFunc::NumUnary),
+            Self::NbPositive => slots.as_number.positive.load().map(SlotFunc::NumUnary),
+            Self::NbAbsolute => slots.as_number.absolute.load().map(SlotFunc::NumUnary),
+            Self::NbInvert => slots.as_number.invert.load().map(SlotFunc::NumUnary),
+            Self::NbBool => slots.as_number.boolean.load().map(SlotFunc::NumBoolean),
+            Self::NbInt => slots.as_number.int.load().map(SlotFunc::NumUnary),
+            Self::NbFloat => slots.as_number.float.load().map(SlotFunc::NumUnary),
+            Self::NbIndex => slots.as_number.index.load().map(SlotFunc::NumUnary),
+
+            // Sequence slots
+            Self::SqLength => slots.as_sequence.length.load().map(SlotFunc::SeqLength),
+            Self::SqConcat => slots.as_sequence.concat.load().map(SlotFunc::SeqConcat),
+            Self::SqRepeat => slots.as_sequence.repeat.load().map(SlotFunc::SeqRepeat),
+            Self::SqItem => slots.as_sequence.item.load().map(SlotFunc::SeqItem),
+            Self::SqAssItem => slots.as_sequence.ass_item.load().map(SlotFunc::SeqSetItem),
+            Self::SqContains => slots.as_sequence.contains.load().map(SlotFunc::SeqContains),
+            Self::SqInplaceConcat => slots
+                .as_sequence
+                .inplace_concat
+                .load()
+                .map(SlotFunc::SeqConcat),
+            Self::SqInplaceRepeat => slots
+                .as_sequence
+                .inplace_repeat
+                .load()
+                .map(SlotFunc::SeqRepeat),
+
+            // Mapping slots
+            Self::MpLength => slots.as_mapping.length.load().map(SlotFunc::MapLength),
+            Self::MpSubscript => slots
+                .as_mapping
+                .subscript
+                .load()
+                .map(SlotFunc::MapSubscript),
+            Self::MpAssSubscript => slots
+                .as_mapping
+                .ass_subscript
+                .load()
+                .map(SlotFunc::MapSetSubscript),
+
+            // Reserved slots
+            _ => None,
+        }
+    }
+
+    /// Get slot function considering SlotOp for right-hand and delete operations
+    pub fn get_slot_func_with_op(
+        &self,
+        slots: &PyTypeSlots,
+        op: Option<SlotOp>,
+    ) -> Option<SlotFunc> {
+        // For Delete operations, return the delete variant
+        if op == Some(SlotOp::Delete) {
+            match self {
+                Self::TpSetattro => return slots.setattro.load().map(SlotFunc::DelAttro),
+                Self::TpDescrSet => return slots.descr_set.load().map(SlotFunc::DescrDel),
+                Self::SqAssItem => {
+                    return slots.as_sequence.ass_item.load().map(SlotFunc::SeqDelItem);
+                }
+                Self::MpAssSubscript => {
+                    return slots
+                        .as_mapping
+                        .ass_subscript
+                        .load()
+                        .map(SlotFunc::MapDelSubscript);
+                }
+                _ => {}
+            }
+        }
+        // For Right operations on binary number slots, use right_* fields with swapped args
+        if op == Some(SlotOp::Right) {
+            match self {
+                Self::NbAdd => {
+                    return slots
+                        .as_number
+                        .right_add
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbSubtract => {
+                    return slots
+                        .as_number
+                        .right_subtract
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbMultiply => {
+                    return slots
+                        .as_number
+                        .right_multiply
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbRemainder => {
+                    return slots
+                        .as_number
+                        .right_remainder
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbDivmod => {
+                    return slots
+                        .as_number
+                        .right_divmod
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbPower => {
+                    return slots
+                        .as_number
+                        .right_power
+                        .load()
+                        .map(SlotFunc::NumTernaryRight);
+                }
+                Self::NbLshift => {
+                    return slots
+                        .as_number
+                        .right_lshift
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbRshift => {
+                    return slots
+                        .as_number
+                        .right_rshift
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbAnd => {
+                    return slots
+                        .as_number
+                        .right_and
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbXor => {
+                    return slots
+                        .as_number
+                        .right_xor
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbOr => {
+                    return slots
+                        .as_number
+                        .right_or
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbFloorDivide => {
+                    return slots
+                        .as_number
+                        .right_floor_divide
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbTrueDivide => {
+                    return slots
+                        .as_number
+                        .right_true_divide
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                Self::NbMatrixMultiply => {
+                    return slots
+                        .as_number
+                        .right_matrix_multiply
+                        .load()
+                        .map(SlotFunc::NumBinaryRight);
+                }
+                _ => {}
+            }
+        }
+        // For comparison operations, use the appropriate PyComparisonOp
+        if let Self::TpRichcompare = self
+            && let Some(cmp_op) = op.and_then(|o| o.as_compare_op())
+        {
+            return slots
+                .richcompare
+                .load()
+                .map(|f| SlotFunc::RichCompare(f, cmp_op));
+        }
+        // Fall back to existing get_slot_func for left/other operations
+        self.get_slot_func(slots)
+    }
+}
+
+/// Find all slot definitions with a given name
+pub fn find_slot_defs_by_name(name: &str) -> impl Iterator<Item = &'static SlotDef> {
+    SLOT_DEFS.iter().filter(move |def| def.name == name)
+}
+
+/// Total number of slot definitions
+pub const SLOT_DEFS_COUNT: usize = SLOT_DEFS.len();
+
+/// All slot definitions
+pub static SLOT_DEFS: &[SlotDef] = &[
+    // Type slots (tp_*)
+    SlotDef {
+        name: "__init__",
+        accessor: SlotAccessor::TpInit,
+        op: None,
+        doc: "Initialize self. See help(type(self)) for accurate signature.",
+    },
+    SlotDef {
+        name: "__new__",
+        accessor: SlotAccessor::TpNew,
+        op: None,
+        doc: "Create and return a new object. See help(type) for accurate signature.",
+    },
+    SlotDef {
+        name: "__del__",
+        accessor: SlotAccessor::TpDel,
+        op: None,
+        doc: "Called when the instance is about to be destroyed.",
+    },
+    SlotDef {
+        name: "__repr__",
+        accessor: SlotAccessor::TpRepr,
+        op: None,
+        doc: "Return repr(self).",
+    },
+    SlotDef {
+        name: "__str__",
+        accessor: SlotAccessor::TpStr,
+        op: None,
+        doc: "Return str(self).",
+    },
+    SlotDef {
+        name: "__hash__",
+        accessor: SlotAccessor::TpHash,
+        op: None,
+        doc: "Return hash(self).",
+    },
+    SlotDef {
+        name: "__call__",
+        accessor: SlotAccessor::TpCall,
+        op: None,
+        doc: "Call self as a function.",
+    },
+    SlotDef {
+        name: "__iter__",
+        accessor: SlotAccessor::TpIter,
+        op: None,
+        doc: "Implement iter(self).",
+    },
+    SlotDef {
+        name: "__next__",
+        accessor: SlotAccessor::TpIternext,
+        op: None,
+        doc: "Implement next(self).",
+    },
+    // Attribute access
+    SlotDef {
+        name: "__getattribute__",
+        accessor: SlotAccessor::TpGetattro,
+        op: None,
+        doc: "Return getattr(self, name).",
+    },
+    SlotDef {
+        name: "__getattr__",
+        accessor: SlotAccessor::TpGetattro,
+        op: None,
+        doc: "Implement getattr(self, name).",
+    },
+    SlotDef {
+        name: "__setattr__",
+        accessor: SlotAccessor::TpSetattro,
+        op: None,
+        doc: "Implement setattr(self, name, value).",
+    },
+    SlotDef {
+        name: "__delattr__",
+        accessor: SlotAccessor::TpSetattro,
+        op: Some(SlotOp::Delete),
+        doc: "Implement delattr(self, name).",
+    },
+    // Rich comparison - all map to TpRichcompare with different op
+    SlotDef {
+        name: "__eq__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Eq),
+        doc: "Return self==value.",
+    },
+    SlotDef {
+        name: "__ne__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Ne),
+        doc: "Return self!=value.",
+    },
+    SlotDef {
+        name: "__lt__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Lt),
+        doc: "Return self<value.",
+    },
+    SlotDef {
+        name: "__le__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Le),
+        doc: "Return self<=value.",
+    },
+    SlotDef {
+        name: "__gt__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Gt),
+        doc: "Return self>value.",
+    },
+    SlotDef {
+        name: "__ge__",
+        accessor: SlotAccessor::TpRichcompare,
+        op: Some(SlotOp::Ge),
+        doc: "Return self>=value.",
+    },
+    // Descriptor protocol
+    SlotDef {
+        name: "__get__",
+        accessor: SlotAccessor::TpDescrGet,
+        op: None,
+        doc: "Return an attribute of instance, which is of type owner.",
+    },
+    SlotDef {
+        name: "__set__",
+        accessor: SlotAccessor::TpDescrSet,
+        op: None,
+        doc: "Set an attribute of instance to value.",
+    },
+    SlotDef {
+        name: "__delete__",
+        accessor: SlotAccessor::TpDescrSet,
+        op: Some(SlotOp::Delete),
+        doc: "Delete an attribute of instance.",
+    },
+    // Mapping protocol (mp_*) - must come before Sequence protocol
+    // so that mp_subscript wins over sq_item for __getitem__
+    // (see CPython typeobject.c:10995-11006)
+    SlotDef {
+        name: "__len__",
+        accessor: SlotAccessor::MpLength,
+        op: None,
+        doc: "Return len(self).",
+    },
+    SlotDef {
+        name: "__getitem__",
+        accessor: SlotAccessor::MpSubscript,
+        op: None,
+        doc: "Return self[key].",
+    },
+    SlotDef {
+        name: "__setitem__",
+        accessor: SlotAccessor::MpAssSubscript,
+        op: None,
+        doc: "Set self[key] to value.",
+    },
+    SlotDef {
+        name: "__delitem__",
+        accessor: SlotAccessor::MpAssSubscript,
+        op: Some(SlotOp::Delete),
+        doc: "Delete self[key].",
+    },
+    // Sequence protocol (sq_*)
+    SlotDef {
+        name: "__len__",
+        accessor: SlotAccessor::SqLength,
+        op: None,
+        doc: "Return len(self).",
+    },
+    SlotDef {
+        name: "__getitem__",
+        accessor: SlotAccessor::SqItem,
+        op: None,
+        doc: "Return self[key].",
+    },
+    SlotDef {
+        name: "__setitem__",
+        accessor: SlotAccessor::SqAssItem,
+        op: None,
+        doc: "Set self[key] to value.",
+    },
+    SlotDef {
+        name: "__delitem__",
+        accessor: SlotAccessor::SqAssItem,
+        op: Some(SlotOp::Delete),
+        doc: "Delete self[key].",
+    },
+    SlotDef {
+        name: "__contains__",
+        accessor: SlotAccessor::SqContains,
+        op: None,
+        doc: "Return key in self.",
+    },
+    // Number protocol - binary ops with left/right variants
+    SlotDef {
+        name: "__add__",
+        accessor: SlotAccessor::NbAdd,
+        op: Some(SlotOp::Left),
+        doc: "Return self+value.",
+    },
+    SlotDef {
+        name: "__radd__",
+        accessor: SlotAccessor::NbAdd,
+        op: Some(SlotOp::Right),
+        doc: "Return value+self.",
+    },
+    SlotDef {
+        name: "__iadd__",
+        accessor: SlotAccessor::NbInplaceAdd,
+        op: None,
+        doc: "Implement self+=value.",
+    },
+    SlotDef {
+        name: "__sub__",
+        accessor: SlotAccessor::NbSubtract,
+        op: Some(SlotOp::Left),
+        doc: "Return self-value.",
+    },
+    SlotDef {
+        name: "__rsub__",
+        accessor: SlotAccessor::NbSubtract,
+        op: Some(SlotOp::Right),
+        doc: "Return value-self.",
+    },
+    SlotDef {
+        name: "__isub__",
+        accessor: SlotAccessor::NbInplaceSubtract,
+        op: None,
+        doc: "Implement self-=value.",
+    },
+    SlotDef {
+        name: "__mul__",
+        accessor: SlotAccessor::NbMultiply,
+        op: Some(SlotOp::Left),
+        doc: "Return self*value.",
+    },
+    SlotDef {
+        name: "__rmul__",
+        accessor: SlotAccessor::NbMultiply,
+        op: Some(SlotOp::Right),
+        doc: "Return value*self.",
+    },
+    SlotDef {
+        name: "__imul__",
+        accessor: SlotAccessor::NbInplaceMultiply,
+        op: None,
+        doc: "Implement self*=value.",
+    },
+    SlotDef {
+        name: "__mod__",
+        accessor: SlotAccessor::NbRemainder,
+        op: Some(SlotOp::Left),
+        doc: "Return self%value.",
+    },
+    SlotDef {
+        name: "__rmod__",
+        accessor: SlotAccessor::NbRemainder,
+        op: Some(SlotOp::Right),
+        doc: "Return value%self.",
+    },
+    SlotDef {
+        name: "__imod__",
+        accessor: SlotAccessor::NbInplaceRemainder,
+        op: None,
+        doc: "Implement self%=value.",
+    },
+    SlotDef {
+        name: "__divmod__",
+        accessor: SlotAccessor::NbDivmod,
+        op: Some(SlotOp::Left),
+        doc: "Return divmod(self, value).",
+    },
+    SlotDef {
+        name: "__rdivmod__",
+        accessor: SlotAccessor::NbDivmod,
+        op: Some(SlotOp::Right),
+        doc: "Return divmod(value, self).",
+    },
+    SlotDef {
+        name: "__pow__",
+        accessor: SlotAccessor::NbPower,
+        op: Some(SlotOp::Left),
+        doc: "Return pow(self, value, mod).",
+    },
+    SlotDef {
+        name: "__rpow__",
+        accessor: SlotAccessor::NbPower,
+        op: Some(SlotOp::Right),
+        doc: "Return pow(value, self, mod).",
+    },
+    SlotDef {
+        name: "__ipow__",
+        accessor: SlotAccessor::NbInplacePower,
+        op: None,
+        doc: "Implement self**=value.",
+    },
+    SlotDef {
+        name: "__lshift__",
+        accessor: SlotAccessor::NbLshift,
+        op: Some(SlotOp::Left),
+        doc: "Return self<<value.",
+    },
+    SlotDef {
+        name: "__rlshift__",
+        accessor: SlotAccessor::NbLshift,
+        op: Some(SlotOp::Right),
+        doc: "Return value<<self.",
+    },
+    SlotDef {
+        name: "__ilshift__",
+        accessor: SlotAccessor::NbInplaceLshift,
+        op: None,
+        doc: "Implement self<<=value.",
+    },
+    SlotDef {
+        name: "__rshift__",
+        accessor: SlotAccessor::NbRshift,
+        op: Some(SlotOp::Left),
+        doc: "Return self>>value.",
+    },
+    SlotDef {
+        name: "__rrshift__",
+        accessor: SlotAccessor::NbRshift,
+        op: Some(SlotOp::Right),
+        doc: "Return value>>self.",
+    },
+    SlotDef {
+        name: "__irshift__",
+        accessor: SlotAccessor::NbInplaceRshift,
+        op: None,
+        doc: "Implement self>>=value.",
+    },
+    SlotDef {
+        name: "__and__",
+        accessor: SlotAccessor::NbAnd,
+        op: Some(SlotOp::Left),
+        doc: "Return self&value.",
+    },
+    SlotDef {
+        name: "__rand__",
+        accessor: SlotAccessor::NbAnd,
+        op: Some(SlotOp::Right),
+        doc: "Return value&self.",
+    },
+    SlotDef {
+        name: "__iand__",
+        accessor: SlotAccessor::NbInplaceAnd,
+        op: None,
+        doc: "Implement self&=value.",
+    },
+    SlotDef {
+        name: "__xor__",
+        accessor: SlotAccessor::NbXor,
+        op: Some(SlotOp::Left),
+        doc: "Return self^value.",
+    },
+    SlotDef {
+        name: "__rxor__",
+        accessor: SlotAccessor::NbXor,
+        op: Some(SlotOp::Right),
+        doc: "Return value^self.",
+    },
+    SlotDef {
+        name: "__ixor__",
+        accessor: SlotAccessor::NbInplaceXor,
+        op: None,
+        doc: "Implement self^=value.",
+    },
+    SlotDef {
+        name: "__or__",
+        accessor: SlotAccessor::NbOr,
+        op: Some(SlotOp::Left),
+        doc: "Return self|value.",
+    },
+    SlotDef {
+        name: "__ror__",
+        accessor: SlotAccessor::NbOr,
+        op: Some(SlotOp::Right),
+        doc: "Return value|self.",
+    },
+    SlotDef {
+        name: "__ior__",
+        accessor: SlotAccessor::NbInplaceOr,
+        op: None,
+        doc: "Implement self|=value.",
+    },
+    SlotDef {
+        name: "__floordiv__",
+        accessor: SlotAccessor::NbFloorDivide,
+        op: Some(SlotOp::Left),
+        doc: "Return self//value.",
+    },
+    SlotDef {
+        name: "__rfloordiv__",
+        accessor: SlotAccessor::NbFloorDivide,
+        op: Some(SlotOp::Right),
+        doc: "Return value//self.",
+    },
+    SlotDef {
+        name: "__ifloordiv__",
+        accessor: SlotAccessor::NbInplaceFloorDivide,
+        op: None,
+        doc: "Implement self//=value.",
+    },
+    SlotDef {
+        name: "__truediv__",
+        accessor: SlotAccessor::NbTrueDivide,
+        op: Some(SlotOp::Left),
+        doc: "Return self/value.",
+    },
+    SlotDef {
+        name: "__rtruediv__",
+        accessor: SlotAccessor::NbTrueDivide,
+        op: Some(SlotOp::Right),
+        doc: "Return value/self.",
+    },
+    SlotDef {
+        name: "__itruediv__",
+        accessor: SlotAccessor::NbInplaceTrueDivide,
+        op: None,
+        doc: "Implement self/=value.",
+    },
+    SlotDef {
+        name: "__matmul__",
+        accessor: SlotAccessor::NbMatrixMultiply,
+        op: Some(SlotOp::Left),
+        doc: "Return self@value.",
+    },
+    SlotDef {
+        name: "__rmatmul__",
+        accessor: SlotAccessor::NbMatrixMultiply,
+        op: Some(SlotOp::Right),
+        doc: "Return value@self.",
+    },
+    SlotDef {
+        name: "__imatmul__",
+        accessor: SlotAccessor::NbInplaceMatrixMultiply,
+        op: None,
+        doc: "Implement self@=value.",
+    },
+    // Number unary operations
+    SlotDef {
+        name: "__neg__",
+        accessor: SlotAccessor::NbNegative,
+        op: None,
+        doc: "Return -self.",
+    },
+    SlotDef {
+        name: "__pos__",
+        accessor: SlotAccessor::NbPositive,
+        op: None,
+        doc: "Return +self.",
+    },
+    SlotDef {
+        name: "__abs__",
+        accessor: SlotAccessor::NbAbsolute,
+        op: None,
+        doc: "Return abs(self).",
+    },
+    SlotDef {
+        name: "__invert__",
+        accessor: SlotAccessor::NbInvert,
+        op: None,
+        doc: "Return ~self.",
+    },
+    SlotDef {
+        name: "__bool__",
+        accessor: SlotAccessor::NbBool,
+        op: None,
+        doc: "Return self != 0.",
+    },
+    SlotDef {
+        name: "__int__",
+        accessor: SlotAccessor::NbInt,
+        op: None,
+        doc: "Return int(self).",
+    },
+    SlotDef {
+        name: "__float__",
+        accessor: SlotAccessor::NbFloat,
+        op: None,
+        doc: "Return float(self).",
+    },
+    SlotDef {
+        name: "__index__",
+        accessor: SlotAccessor::NbIndex,
+        op: None,
+        doc: "Return self converted to an integer, if self is suitable for use as an index into a list.",
+    },
+    // Sequence inplace operations (also map to number slots for some types)
+    SlotDef {
+        name: "__add__",
+        accessor: SlotAccessor::SqConcat,
+        op: None,
+        doc: "Return self+value.",
+    },
+    SlotDef {
+        name: "__mul__",
+        accessor: SlotAccessor::SqRepeat,
+        op: None,
+        doc: "Return self*value.",
+    },
+    SlotDef {
+        name: "__rmul__",
+        accessor: SlotAccessor::SqRepeat,
+        op: None,
+        doc: "Return value*self.",
+    },
+    SlotDef {
+        name: "__iadd__",
+        accessor: SlotAccessor::SqInplaceConcat,
+        op: None,
+        doc: "Implement self+=value.",
+    },
+    SlotDef {
+        name: "__imul__",
+        accessor: SlotAccessor::SqInplaceRepeat,
+        op: None,
+        doc: "Implement self*=value.",
+    },
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_find_by_name() {
+        // __len__ appears in both sequence and mapping
+        let len_defs: Vec<_> = find_slot_defs_by_name("__len__").collect();
+        assert_eq!(len_defs.len(), 2);
+
+        // __init__ appears once
+        let init_defs: Vec<_> = find_slot_defs_by_name("__init__").collect();
+        assert_eq!(init_defs.len(), 1);
+
+        // __add__ appears in number (left/right) and sequence
+        let add_defs: Vec<_> = find_slot_defs_by_name("__add__").collect();
+        assert_eq!(add_defs.len(), 2); // NbAdd(Left) and SqConcat
+    }
+
+    #[test]
+    fn test_slot_op() {
+        // Test comparison ops
+        assert_eq!(SlotOp::Lt.as_compare_op(), Some(PyComparisonOp::Lt));
+        assert_eq!(SlotOp::Eq.as_compare_op(), Some(PyComparisonOp::Eq));
+        assert_eq!(SlotOp::Left.as_compare_op(), None);
+
+        // Test right check
+        assert!(SlotOp::Right.is_right());
+        assert!(!SlotOp::Left.is_right());
+    }
+}
diff --git a/crates/vm/src/types/structseq.rs b/crates/vm/src/types/structseq.rs
new file mode 100644
index 0000000000..27315749e0
--- /dev/null
+++ b/crates/vm/src/types/structseq.rs
@@ -0,0 +1,391 @@
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, atomic_func,
+    builtins::{PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef},
+    class::{PyClassImpl, StaticType},
+    function::{Either, PyComparisonValue},
+    iter::PyExactSizeIterator,
+    protocol::{PyMappingMethods, PySequenceMethods},
+    sliceable::{SequenceIndex, SliceableSequenceOp},
+    types::PyComparisonOp,
+    vm::Context,
+};
+use std::sync::LazyLock;
+
+/// Create a new struct sequence instance from a sequence.
+///
+/// The class must have `n_sequence_fields` and `n_fields` attributes set
+/// (done automatically by `PyStructSequence::extend_pyclass`).
+pub fn struct_sequence_new(cls: PyTypeRef, seq: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    // = structseq_new
+
+    #[cold]
+    fn length_error(
+        tp_name: &str,
+        min_len: usize,
+        max_len: usize,
+        len: usize,
+        vm: &VirtualMachine,
+    ) -> PyBaseExceptionRef {
+        if min_len == max_len {
+            vm.new_type_error(format!(
+                "{tp_name}() takes a {min_len}-sequence ({len}-sequence given)"
+            ))
+        } else if len < min_len {
+            vm.new_type_error(format!(
+                "{tp_name}() takes an at least {min_len}-sequence ({len}-sequence given)"
+            ))
+        } else {
+            vm.new_type_error(format!(
+                "{tp_name}() takes an at most {max_len}-sequence ({len}-sequence given)"
+            ))
+        }
+    }
+
+    let min_len: usize = cls
+        .get_attr(identifier!(vm.ctx, n_sequence_fields))
+        .ok_or_else(|| vm.new_type_error("missing n_sequence_fields attribute"))?
+        .try_into_value(vm)?;
+    let max_len: usize = cls
+        .get_attr(identifier!(vm.ctx, n_fields))
+        .ok_or_else(|| vm.new_type_error("missing n_fields attribute"))?
+        .try_into_value(vm)?;
+
+    let seq: Vec<PyObjectRef> = seq.try_into_value(vm)?;
+    let len = seq.len();
+
+    if len < min_len || len > max_len {
+        return Err(length_error(&cls.slot_name(), min_len, max_len, len, vm));
+    }
+
+    // Copy items and pad with None
+    let mut items = seq;
+    items.resize_with(max_len, || vm.ctx.none());
+
+    PyTuple::new_unchecked(items.into_boxed_slice())
+        .into_ref_with_type(vm, cls)
+        .map(Into::into)
+}
+
+fn get_visible_len(obj: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
+    obj.class()
+        .get_attr(identifier!(vm.ctx, n_sequence_fields))
+        .ok_or_else(|| vm.new_type_error("missing n_sequence_fields"))?
+        .try_into_value(vm)
+}
+
+/// Sequence methods for struct sequences.
+/// Uses n_sequence_fields to determine visible length.
+static STRUCT_SEQUENCE_AS_SEQUENCE: LazyLock<PySequenceMethods> =
+    LazyLock::new(|| PySequenceMethods {
+        length: atomic_func!(|seq, vm| get_visible_len(seq.obj, vm)),
+        concat: atomic_func!(|seq, other, vm| {
+            // Convert to visible-only tuple, then use regular tuple concat
+            let n_seq = get_visible_len(seq.obj, vm)?;
+            let tuple = seq.obj.downcast_ref::<PyTuple>().unwrap();
+            let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
+            let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
+            // Use tuple's concat implementation
+            visible_tuple
+                .as_object()
+                .sequence_unchecked()
+                .concat(other, vm)
+        }),
+        repeat: atomic_func!(|seq, n, vm| {
+            // Convert to visible-only tuple, then use regular tuple repeat
+            let n_seq = get_visible_len(seq.obj, vm)?;
+            let tuple = seq.obj.downcast_ref::<PyTuple>().unwrap();
+            let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
+            let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
+            // Use tuple's repeat implementation
+            visible_tuple.as_object().sequence_unchecked().repeat(n, vm)
+        }),
+        item: atomic_func!(|seq, i, vm| {
+            let n_seq = get_visible_len(seq.obj, vm)?;
+            let tuple = seq.obj.downcast_ref::<PyTuple>().unwrap();
+            let idx = if i < 0 {
+                let pos_i = n_seq as isize + i;
+                if pos_i < 0 {
+                    return Err(vm.new_index_error("tuple index out of range"));
+                }
+                pos_i as usize
+            } else {
+                i as usize
+            };
+            if idx >= n_seq {
+                return Err(vm.new_index_error("tuple index out of range"));
+            }
+            Ok(tuple[idx].clone())
+        }),
+        contains: atomic_func!(|seq, needle, vm| {
+            let n_seq = get_visible_len(seq.obj, vm)?;
+            let tuple = seq.obj.downcast_ref::<PyTuple>().unwrap();
+            for item in tuple.iter().take(n_seq) {
+                if item.rich_compare_bool(needle, PyComparisonOp::Eq, vm)? {
+                    return Ok(true);
+                }
+            }
+            Ok(false)
+        }),
+        ..PySequenceMethods::NOT_IMPLEMENTED
+    });
+
+/// Mapping methods for struct sequences.
+/// Handles subscript (indexing) with visible length bounds.
+static STRUCT_SEQUENCE_AS_MAPPING: LazyLock<PyMappingMethods> =
+    LazyLock::new(|| PyMappingMethods {
+        length: atomic_func!(|mapping, vm| get_visible_len(mapping.obj, vm)),
+        subscript: atomic_func!(|mapping, needle, vm| {
+            let n_seq = get_visible_len(mapping.obj, vm)?;
+            let tuple = mapping.obj.downcast_ref::<PyTuple>().unwrap();
+            let visible_elements = &tuple.as_slice()[..n_seq];
+
+            match SequenceIndex::try_from_borrowed_object(vm, needle, "tuple")? {
+                SequenceIndex::Int(i) => visible_elements.getitem_by_index(vm, i),
+                SequenceIndex::Slice(slice) => visible_elements
+                    .getitem_by_slice(vm, slice)
+                    .map(|x| vm.ctx.new_tuple(x).into()),
+            }
+        }),
+        ..PyMappingMethods::NOT_IMPLEMENTED
+    });
+
+/// Trait for Data structs that back a PyStructSequence.
+///
+/// This trait is implemented by `#[pystruct_sequence_data]` on the Data struct.
+/// It provides field information, tuple conversion, and element parsing.
+pub trait PyStructSequenceData: Sized {
+    /// Names of required fields (in order). Shown in repr.
+    const REQUIRED_FIELD_NAMES: &'static [&'static str];
+
+    /// Names of optional/skipped fields (in order, after required fields).
+    const OPTIONAL_FIELD_NAMES: &'static [&'static str];
+
+    /// Number of unnamed fields (visible but index-only access).
+    const UNNAMED_FIELDS_LEN: usize = 0;
+
+    /// Convert this Data struct into a PyTuple.
+    fn into_tuple(self, vm: &VirtualMachine) -> PyTuple;
+
+    /// Construct this Data struct from tuple elements.
+    /// Default implementation returns an error.
+    /// Override with `#[pystruct_sequence_data(try_from_object)]` to enable.
+    fn try_from_elements(_elements: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult<Self> {
+        Err(vm.new_type_error("This struct sequence does not support construction from elements"))
+    }
+}
+
+/// Trait for Python struct sequence types.
+///
+/// This trait is implemented by the `#[pystruct_sequence]` macro on the Python type struct.
+/// It connects to the Data struct and provides Python-level functionality.
+#[pyclass]
+pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
+    /// The Data struct that provides field definitions.
+    type Data: PyStructSequenceData;
+
+    /// Convert a Data struct into a PyStructSequence instance.
+    fn from_data(data: Self::Data, vm: &VirtualMachine) -> PyTupleRef {
+        let tuple =
+            <Self::Data as ::rustpython_vm::types::PyStructSequenceData>::into_tuple(data, vm);
+        let typ = Self::static_type();
+        tuple
+            .into_ref_with_type(vm, typ.to_owned())
+            .expect("Every PyStructSequence must be a valid tuple. This is a RustPython bug.")
+    }
+
+    #[pyslot]
+    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let zelf = zelf
+            .downcast_ref::<PyTuple>()
+            .ok_or_else(|| vm.new_type_error("unexpected payload for __repr__"))?;
+
+        let field_names = Self::Data::REQUIRED_FIELD_NAMES;
+        let format_field = |(value, name): (&PyObject, _)| {
+            let s = value.repr(vm)?;
+            Ok(format!("{name}={s}"))
+        };
+        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(", "), "")
+                }
+            } else {
+                (String::new(), "...")
+            };
+        let repr_str = format!("{}({}{})", Self::TP_NAME, body, suffix);
+        Ok(vm.ctx.new_str(repr_str))
+    }
+
+    #[pymethod]
+    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        Self::slot_repr(&zelf, vm)
+    }
+
+    #[pymethod]
+    fn __reduce__(zelf: PyRef<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
+        vm.new_tuple((zelf.class().to_owned(), (vm.ctx.new_tuple(zelf.to_vec()),)))
+    }
+
+    #[pymethod]
+    fn __getitem__(zelf: PyRef<PyTuple>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+        let n_seq = get_visible_len(zelf.as_ref(), vm)?;
+        let visible_elements = &zelf.as_slice()[..n_seq];
+
+        match SequenceIndex::try_from_borrowed_object(vm, &needle, "tuple")? {
+            SequenceIndex::Int(i) => visible_elements.getitem_by_index(vm, i),
+            SequenceIndex::Slice(slice) => visible_elements
+                .getitem_by_slice(vm, slice)
+                .map(|x| vm.ctx.new_tuple(x).into()),
+        }
+    }
+
+    #[extend_class]
+    fn extend_pyclass(ctx: &Context, class: &'static Py<PyType>) {
+        // Getters for named visible fields (indices 0 to REQUIRED_FIELD_NAMES.len() - 1)
+        for (i, &name) in Self::Data::REQUIRED_FIELD_NAMES.iter().enumerate() {
+            // cast i to a u8 so there's less to store in the getter closure.
+            // Hopefully there's not struct sequences with >=256 elements :P
+            let i = i as u8;
+            class.set_attr(
+                ctx.intern_str(name),
+                ctx.new_readonly_getset(name, class, move |zelf: &PyTuple| {
+                    zelf[i as usize].to_owned()
+                })
+                .into(),
+            );
+        }
+
+        // Getters for hidden/skipped fields (indices after visible fields)
+        let visible_count = Self::Data::REQUIRED_FIELD_NAMES.len() + Self::Data::UNNAMED_FIELDS_LEN;
+        for (i, &name) in Self::Data::OPTIONAL_FIELD_NAMES.iter().enumerate() {
+            let idx = (visible_count + i) as u8;
+            class.set_attr(
+                ctx.intern_str(name),
+                ctx.new_readonly_getset(name, class, move |zelf: &PyTuple| {
+                    zelf[idx as usize].to_owned()
+                })
+                .into(),
+            );
+        }
+
+        class.set_attr(
+            identifier!(ctx, __match_args__),
+            ctx.new_tuple(
+                Self::Data::REQUIRED_FIELD_NAMES
+                    .iter()
+                    .map(|&name| ctx.new_str(name).into())
+                    .collect::<Vec<_>>(),
+            )
+            .into(),
+        );
+
+        // special fields:
+        // n_sequence_fields = visible fields (named + unnamed)
+        // n_fields = all fields (visible + hidden/skipped)
+        // n_unnamed_fields
+        let n_unnamed_fields = Self::Data::UNNAMED_FIELDS_LEN;
+        let n_sequence_fields = Self::Data::REQUIRED_FIELD_NAMES.len() + n_unnamed_fields;
+        let n_fields = n_sequence_fields + Self::Data::OPTIONAL_FIELD_NAMES.len();
+        class.set_attr(
+            identifier!(ctx, n_sequence_fields),
+            ctx.new_int(n_sequence_fields).into(),
+        );
+        class.set_attr(identifier!(ctx, n_fields), ctx.new_int(n_fields).into());
+        class.set_attr(
+            identifier!(ctx, n_unnamed_fields),
+            ctx.new_int(n_unnamed_fields).into(),
+        );
+
+        // Override as_sequence and as_mapping slots to use visible length
+        class
+            .slots
+            .as_sequence
+            .copy_from(&STRUCT_SEQUENCE_AS_SEQUENCE);
+        class
+            .slots
+            .as_mapping
+            .copy_from(&STRUCT_SEQUENCE_AS_MAPPING);
+
+        // Override iter slot to return only visible elements
+        class.slots.iter.store(Some(struct_sequence_iter));
+
+        // Override hash slot to hash only visible elements
+        class.slots.hash.store(Some(struct_sequence_hash));
+
+        // Override richcompare slot to compare only visible elements
+        class
+            .slots
+            .richcompare
+            .store(Some(struct_sequence_richcompare));
+    }
+}
+
+/// Iterator function for struct sequences - returns only visible elements
+fn struct_sequence_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
+    let tuple = zelf
+        .downcast_ref::<PyTuple>()
+        .ok_or_else(|| vm.new_type_error("expected tuple"))?;
+    let n_seq = get_visible_len(&zelf, vm)?;
+    let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
+    let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
+    visible_tuple
+        .as_object()
+        .to_owned()
+        .get_iter(vm)
+        .map(Into::into)
+}
+
+/// Hash function for struct sequences - hashes only visible elements
+fn struct_sequence_hash(
+    zelf: &PyObject,
+    vm: &VirtualMachine,
+) -> PyResult<crate::common::hash::PyHash> {
+    let tuple = zelf
+        .downcast_ref::<PyTuple>()
+        .ok_or_else(|| vm.new_type_error("expected tuple"))?;
+    let n_seq = get_visible_len(zelf, vm)?;
+    // Create a visible-only tuple and hash it
+    let visible: Vec<_> = tuple.iter().take(n_seq).cloned().collect();
+    let visible_tuple = PyTuple::new_ref(visible, &vm.ctx);
+    visible_tuple.as_object().hash(vm)
+}
+
+/// Rich comparison for struct sequences - compares only visible elements
+fn struct_sequence_richcompare(
+    zelf: &PyObject,
+    other: &PyObject,
+    op: PyComparisonOp,
+    vm: &VirtualMachine,
+) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
+    let zelf_tuple = zelf
+        .downcast_ref::<PyTuple>()
+        .ok_or_else(|| vm.new_type_error("expected tuple"))?;
+
+    // If other is not a tuple, return NotImplemented
+    let Some(other_tuple) = other.downcast_ref::<PyTuple>() else {
+        return Ok(Either::B(PyComparisonValue::NotImplemented));
+    };
+
+    let zelf_len = get_visible_len(zelf, vm)?;
+    // For other, try to get visible len; if it fails (not a struct sequence), use full length
+    let other_len = get_visible_len(other, vm).unwrap_or(other_tuple.len());
+
+    let zelf_visible = &zelf_tuple.as_slice()[..zelf_len];
+    let other_visible = &other_tuple.as_slice()[..other_len];
+
+    // Use the same comparison logic as regular tuples
+    zelf_visible
+        .iter()
+        .richcompare(other_visible.iter(), op, vm)
+        .map(|v| Either::B(PyComparisonValue::Implemented(v)))
+}
diff --git a/vm/src/types/zoo.rs b/crates/vm/src/types/zoo.rs
similarity index 90%
rename from vm/src/types/zoo.rs
rename to crates/vm/src/types/zoo.rs
index 383732cf69..9fa4e777a1 100644
--- a/vm/src/types/zoo.rs
+++ b/crates/vm/src/types/zoo.rs
@@ -3,9 +3,9 @@ use crate::{
     builtins::{
         asyncgenerator, bool_, builtin_func, bytearray, bytes, classmethod, code, complex,
         coroutine, descriptor, dict, enumerate, filter, float, frame, function, generator,
-        genericalias, getset, int, iter, list, map, mappingproxy, memory, module, namespace,
-        object, property, pystr, range, set, singletons, slice, staticmethod, super_, traceback,
-        tuple,
+        genericalias, getset, int, interpolation, iter, list, map, mappingproxy, memory, module,
+        namespace, object, property, pystr, range, set, singletons, slice, staticmethod, super_,
+        template, traceback, tuple,
         type_::{self, PyType},
         union_, weakproxy, weakref, zip,
     },
@@ -21,6 +21,7 @@ pub struct TypeZoo {
     pub async_generator_asend: &'static Py<PyType>,
     pub async_generator_athrow: &'static Py<PyType>,
     pub async_generator_wrapped_value: &'static Py<PyType>,
+    pub anext_awaitable: &'static Py<PyType>,
     pub bytes_type: &'static Py<PyType>,
     pub bytes_iterator_type: &'static Py<PyType>,
     pub bytearray_type: &'static Py<PyType>,
@@ -92,7 +93,12 @@ pub struct TypeZoo {
     pub not_implemented_type: &'static Py<PyType>,
     pub generic_alias_type: &'static Py<PyType>,
     pub union_type: &'static Py<PyType>,
+    pub interpolation_type: &'static Py<PyType>,
+    pub template_type: &'static Py<PyType>,
+    pub template_iter_type: &'static Py<PyType>,
     pub member_descriptor_type: &'static Py<PyType>,
+    pub wrapper_descriptor_type: &'static Py<PyType>,
+    pub method_wrapper_type: &'static Py<PyType>,
 
     // RustPython-original types
     pub method_def: &'static Py<PyType>,
@@ -139,6 +145,7 @@ impl TypeZoo {
             async_generator_athrow: asyncgenerator::PyAsyncGenAThrow::init_builtin_type(),
             async_generator_wrapped_value:
                 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(),
@@ -184,7 +191,12 @@ impl TypeZoo {
             not_implemented_type: singletons::PyNotImplemented::init_builtin_type(),
             generic_alias_type: genericalias::PyGenericAlias::init_builtin_type(),
             union_type: union_::PyUnion::init_builtin_type(),
+            interpolation_type: interpolation::PyInterpolation::init_builtin_type(),
+            template_type: template::PyTemplate::init_builtin_type(),
+            template_iter_type: template::PyTemplateIter::init_builtin_type(),
             member_descriptor_type: descriptor::PyMemberDescriptor::init_builtin_type(),
+            wrapper_descriptor_type: descriptor::PyWrapper::init_builtin_type(),
+            method_wrapper_type: descriptor::PyMethodWrapper::init_builtin_type(),
 
             method_def: crate::function::HeapMethodDef::init_builtin_type(),
         }
@@ -193,8 +205,10 @@ impl TypeZoo {
     /// Fill attributes of builtin types.
     #[cold]
     pub(crate) fn extend(context: &Context) {
-        type_::init(context);
+        // object must be initialized before type to set object.slots.init,
+        // which type will inherit via inherit_slots()
         object::init(context);
+        type_::init(context);
         list::init(context);
         set::init(context);
         tuple::init(context);
@@ -235,6 +249,9 @@ impl TypeZoo {
         traceback::init(context);
         genericalias::init(context);
         union_::init(context);
+        interpolation::init(context);
+        template::init(context);
         descriptor::init(context);
+        crate::stdlib::typing::init(context);
     }
 }
diff --git a/vm/src/utils.rs b/crates/vm/src/utils.rs
similarity index 82%
rename from vm/src/utils.rs
rename to crates/vm/src/utils.rs
index 78edfb71cc..db232e8194 100644
--- a/vm/src/utils.rs
+++ b/crates/vm/src/utils.rs
@@ -2,7 +2,7 @@ use rustpython_common::wtf8::Wtf8;
 
 use crate::{
     PyObjectRef, PyResult, VirtualMachine,
-    builtins::PyStr,
+    builtins::{PyStr, PyUtf8Str},
     convert::{ToPyException, ToPyObject},
     exceptions::cstring_error,
 };
@@ -14,15 +14,15 @@ pub fn hash_iter<'a, I: IntoIterator<Item = &'a PyObjectRef>>(
     vm.state.hash_secret.hash_iter(iter, |obj| obj.hash(vm))
 }
 
-impl ToPyObject for std::convert::Infallible {
+impl ToPyObject for core::convert::Infallible {
     fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
         match self {}
     }
 }
 
 pub trait ToCString: AsRef<Wtf8> {
-    fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.as_ref().as_bytes()).map_err(|err| err.to_pyexception(vm))
+    fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<alloc::ffi::CString> {
+        alloc::ffi::CString::new(self.as_ref().as_bytes()).map_err(|err| err.to_pyexception(vm))
     }
     fn ensure_no_nul(&self, vm: &VirtualMachine) -> PyResult<()> {
         if self.as_ref().as_bytes().contains(&b'\0') {
@@ -35,6 +35,7 @@ pub trait ToCString: AsRef<Wtf8> {
 
 impl ToCString for &str {}
 impl ToCString for PyStr {}
+impl ToCString for PyUtf8Str {}
 
 pub(crate) fn collection_repr<'a, I>(
     class_name: Option<&str>,
@@ -44,7 +45,7 @@ pub(crate) fn collection_repr<'a, I>(
     vm: &VirtualMachine,
 ) -> PyResult<String>
 where
-    I: std::iter::Iterator<Item = &'a PyObjectRef>,
+    I: core::iter::Iterator<Item = &'a PyObjectRef>,
 {
     let mut repr = String::new();
     if let Some(name) = class_name {
diff --git a/crates/vm/src/version.rs b/crates/vm/src/version.rs
new file mode 100644
index 0000000000..2b5e82a8d7
--- /dev/null
+++ b/crates/vm/src/version.rs
@@ -0,0 +1,140 @@
+//! Several function to retrieve version information.
+
+use chrono::{Local, prelude::DateTime};
+use core::time::Duration;
+use std::time::UNIX_EPOCH;
+
+// = 3.13.0alpha
+pub const MAJOR: usize = 3;
+pub const MINOR: usize = 13;
+pub const MICRO: usize = 0;
+pub const RELEASELEVEL: &str = "alpha";
+pub const RELEASELEVEL_N: usize = 0xA;
+pub const SERIAL: usize = 0;
+
+pub const VERSION_HEX: usize =
+    (MAJOR << 24) | (MINOR << 16) | (MICRO << 8) | (RELEASELEVEL_N << 4) | SERIAL;
+
+pub fn get_version() -> String {
+    // Windows: include MSC v. for compatibility with ctypes.util.find_library
+    // MSC v.1929 = VS 2019, version 14+ makes find_msvcrt() return None
+    #[cfg(windows)]
+    let msc_info = {
+        let arch = if cfg!(target_pointer_width = "64") {
+            "64 bit (AMD64)"
+        } else {
+            "32 bit (Intel)"
+        };
+        // Include both RustPython identifier and MSC v. for compatibility
+        format!(" MSC v.1929 {arch}",)
+    };
+
+    #[cfg(not(windows))]
+    let msc_info = String::new();
+
+    format!(
+        "{:.80} ({:.80}) \n[RustPython {} with {:.80}{}]", // \n is PyPy convention
+        get_version_number(),
+        get_build_info(),
+        env!("CARGO_PKG_VERSION"),
+        COMPILER,
+        msc_info,
+    )
+}
+
+pub fn get_version_number() -> String {
+    format!("{MAJOR}.{MINOR}.{MICRO}{RELEASELEVEL}")
+}
+
+pub fn get_winver_number() -> String {
+    format!("{MAJOR}.{MINOR}")
+}
+
+const COMPILER: &str = env!("RUSTC_VERSION");
+
+pub fn get_build_info() -> String {
+    // See: https://reproducible-builds.org/docs/timestamps/
+    let git_revision = get_git_revision();
+    let separator = if git_revision.is_empty() { "" } else { ":" };
+
+    let git_identifier = get_git_identifier();
+
+    format!(
+        "{id}{sep}{revision}, {date:.20}, {time:.9}",
+        id = if git_identifier.is_empty() {
+            "default".to_owned()
+        } else {
+            git_identifier
+        },
+        sep = separator,
+        revision = git_revision,
+        date = get_git_date(),
+        time = get_git_time(),
+    )
+}
+
+pub fn get_git_revision() -> String {
+    option_env!("RUSTPYTHON_GIT_HASH").unwrap_or("").to_owned()
+}
+
+pub fn get_git_tag() -> String {
+    option_env!("RUSTPYTHON_GIT_TAG").unwrap_or("").to_owned()
+}
+
+pub fn get_git_branch() -> String {
+    option_env!("RUSTPYTHON_GIT_BRANCH")
+        .unwrap_or("")
+        .to_owned()
+}
+
+pub fn get_git_identifier() -> String {
+    let git_tag = get_git_tag();
+    let git_branch = get_git_branch();
+
+    if git_tag.is_empty() || git_tag == "undefined" {
+        git_branch
+    } else {
+        git_tag
+    }
+}
+
+fn get_git_timestamp_datetime() -> DateTime<Local> {
+    let timestamp = option_env!("RUSTPYTHON_GIT_TIMESTAMP")
+        .unwrap_or("")
+        .to_owned();
+    let timestamp = timestamp.parse::<u64>().unwrap_or(0);
+
+    let datetime = UNIX_EPOCH + Duration::from_secs(timestamp);
+
+    datetime.into()
+}
+
+pub fn get_git_date() -> String {
+    let datetime = get_git_timestamp_datetime();
+
+    datetime.format("%b %e %Y").to_string()
+}
+
+pub fn get_git_time() -> String {
+    let datetime = get_git_timestamp_datetime();
+
+    datetime.format("%H:%M:%S").to_string()
+}
+
+pub fn get_git_datetime() -> String {
+    let date = get_git_date();
+    let time = get_git_time();
+
+    format!("{date} {time}")
+}
+
+// Must be aligned to Lib/importlib/_bootstrap_external.py
+pub const PYC_MAGIC_NUMBER: u16 = 2997;
+
+// CPython format: magic_number | ('\r' << 16) | ('\n' << 24)
+// This protects against text-mode file reads
+pub const PYC_MAGIC_NUMBER_TOKEN: u32 =
+    (PYC_MAGIC_NUMBER as u32) | ((b'\r' as u32) << 16) | ((b'\n' as u32) << 24);
+
+/// Magic number as little-endian bytes for .pyc files
+pub const PYC_MAGIC_NUMBER_BYTES: [u8; 4] = PYC_MAGIC_NUMBER_TOKEN.to_le_bytes();
diff --git a/crates/vm/src/vm/compile.rs b/crates/vm/src/vm/compile.rs
new file mode 100644
index 0000000000..97f0f9e97b
--- /dev/null
+++ b/crates/vm/src/vm/compile.rs
@@ -0,0 +1,30 @@
+//! Python code compilation functions.
+//!
+//! For code execution functions, see python_run.rs
+
+use crate::{
+    PyRef, VirtualMachine,
+    builtins::PyCode,
+    compiler::{self, CompileError, CompileOpts},
+};
+
+impl VirtualMachine {
+    pub fn compile(
+        &self,
+        source: &str,
+        mode: compiler::Mode,
+        source_path: String,
+    ) -> Result<PyRef<PyCode>, CompileError> {
+        self.compile_with_opts(source, mode, source_path, self.compile_opts())
+    }
+
+    pub fn compile_with_opts(
+        &self,
+        source: &str,
+        mode: compiler::Mode,
+        source_path: String,
+        opts: CompileOpts,
+    ) -> Result<PyRef<PyCode>, CompileError> {
+        compiler::compile(source, mode, &source_path, opts).map(|code| self.ctx.new_code(code))
+    }
+}
diff --git a/vm/src/vm/context.rs b/crates/vm/src/vm/context.rs
similarity index 87%
rename from vm/src/vm/context.rs
rename to crates/vm/src/vm/context.rs
index d35b5b7f7e..65c742e491 100644
--- a/vm/src/vm/context.rs
+++ b/crates/vm/src/vm/context.rs
@@ -1,9 +1,10 @@
 use crate::{
     PyResult, VirtualMachine,
     builtins::{
-        PyBaseException, PyByteArray, PyBytes, PyComplex, PyDict, PyDictRef, PyEllipsis, PyFloat,
-        PyFrozenSet, PyInt, PyIntRef, PyList, PyListRef, PyNone, PyNotImplemented, PyStr,
-        PyStrInterned, PyTuple, PyTupleRef, PyType, PyTypeRef,
+        PyByteArray, PyBytes, PyComplex, PyDict, PyDictRef, PyEllipsis, PyFloat, PyFrozenSet,
+        PyInt, PyIntRef, PyList, PyListRef, PyNone, PyNotImplemented, PyStr, PyStrInterned,
+        PyTuple, PyTupleRef, PyType, PyTypeRef,
+        bool_::PyBool,
         code::{self, PyCode},
         descriptor::{
             MemberGetter, MemberKind, MemberSetter, MemberSetterFunc, PyDescriptorOwned,
@@ -13,7 +14,7 @@ use crate::{
         object, pystr,
         type_::PyAttributes,
     },
-    class::{PyClassImpl, StaticType},
+    class::StaticType,
     common::rc::PyRc,
     exceptions,
     function::{
@@ -31,8 +32,8 @@ use rustpython_common::lock::PyRwLock;
 
 #[derive(Debug)]
 pub struct Context {
-    pub true_value: PyIntRef,
-    pub false_value: PyIntRef,
+    pub true_value: PyRef<PyBool>,
+    pub false_value: PyRef<PyBool>,
     pub none: PyRef<PyNone>,
     pub empty_tuple: PyTupleRef,
     pub empty_frozenset: PyRef<PyFrozenSet>,
@@ -61,9 +62,9 @@ macro_rules! declare_const_name {
         }
 
         impl ConstName {
-            unsafe fn new(pool: &StringPool, typ: &PyTypeRef) -> Self {
+            unsafe fn new(pool: &StringPool, typ: &Py<PyType>) -> Self {
                 Self {
-                    $($name: unsafe { pool.intern(declare_const_name!(@string $name $($s)?), typ.clone()) },)*
+                    $($name: unsafe { pool.intern(declare_const_name!(@string $name $($s)?), typ.to_owned()) },)*
                 }
             }
         }
@@ -98,12 +99,13 @@ declare_const_name! {
     __build_class__,
     __builtins__,
     __bytes__,
+    __cached__,
     __call__,
     __ceil__,
     __cformat__,
     __class__,
-    __classcell__,
     __class_getitem__,
+    __classcell__,
     __complex__,
     __contains__,
     __copy__,
@@ -133,6 +135,7 @@ declare_const_name! {
     __getformat__,
     __getitem__,
     __getnewargs__,
+    __getnewargs_ex__,
     __getstate__,
     __gt__,
     __hash__,
@@ -234,31 +237,35 @@ declare_const_name! {
     _attributes,
     _fields,
     _showwarnmsg,
+    backslashreplace,
+    close,
+    copy,
     decode,
     encode,
-    keys,
-    items,
-    values,
-    version,
-    update,
-    copy,
     flush,
-    close,
-    WarningMessage,
-    strict,
     ignore,
-    replace,
-    xmlcharrefreplace,
-    backslashreplace,
+    items,
+    keys,
+    modules,
+    n_fields,
+    n_sequence_fields,
+    n_unnamed_fields,
     namereplace,
-    surrogatepass,
+    replace,
+    strict,
     surrogateescape,
+    surrogatepass,
+    update,
     utf_8: "utf-8",
+    values,
+    version,
+    WarningMessage,
+    xmlcharrefreplace,
 }
 
 // Basic objects:
 impl Context {
-    pub const INT_CACHE_POOL_RANGE: std::ops::RangeInclusive<i32> = (-5)..=256;
+    pub const INT_CACHE_POOL_RANGE: core::ops::RangeInclusive<i32> = (-5)..=256;
     const INT_CACHE_POOL_MIN: i32 = *Self::INT_CACHE_POOL_RANGE.start();
 
     pub fn genesis() -> &'static PyRc<Self> {
@@ -274,10 +281,7 @@ impl Context {
         let exceptions = exceptions::ExceptionZoo::init();
 
         #[inline]
-        fn create_object<T: PyObjectPayload + PyPayload>(
-            payload: T,
-            cls: &'static Py<PyType>,
-        ) -> PyRef<T> {
+        fn create_object<T: PyObjectPayload>(payload: T, cls: &'static Py<PyType>) -> PyRef<T> {
             PyRef::new_ref(payload, cls.to_owned(), None)
         }
 
@@ -300,8 +304,8 @@ impl Context {
             })
             .collect();
 
-        let true_value = create_object(PyInt::from(1), types.bool_type);
-        let false_value = create_object(PyInt::from(0), types.bool_type);
+        let true_value = create_object(PyBool(PyInt::from(1)), types.bool_type);
+        let false_value = create_object(PyBool(PyInt::from(0)), types.bool_type);
 
         let empty_tuple = create_object(
             PyTuple::new_unchecked(Vec::new().into_boxed_slice()),
@@ -314,7 +318,7 @@ impl Context {
         );
 
         let string_pool = StringPool::default();
-        let names = unsafe { ConstName::new(&string_pool, &types.str_type.to_owned()) };
+        let names = unsafe { ConstName::new(&string_pool, types.str_type) };
 
         let slot_new_wrapper = PyMethodDef::new_const(
             names.__new__.as_str(),
@@ -363,21 +367,22 @@ impl Context {
         self.none.clone().into()
     }
 
-    #[inline(always)]
-    pub fn ellipsis(&self) -> PyObjectRef {
-        self.ellipsis.clone().into()
-    }
-
     #[inline(always)]
     pub fn not_implemented(&self) -> PyObjectRef {
         self.not_implemented.clone().into()
     }
 
+    #[inline]
+    pub fn empty_tuple_typed<T>(&self) -> &Py<PyTuple<T>> {
+        let py: &Py<PyTuple> = &self.empty_tuple;
+        unsafe { core::mem::transmute(py) }
+    }
+
     // universal pyref constructor
     pub fn new_pyref<T, P>(&self, value: T) -> PyRef<P>
     where
         T: Into<P>,
-        P: PyPayload,
+        P: PyPayload + core::fmt::Debug,
     {
         value.into().into_ref(self)
     }
@@ -386,22 +391,22 @@ impl Context {
 
     #[inline]
     pub fn new_int<T: Into<BigInt> + ToPrimitive>(&self, i: T) -> PyIntRef {
-        if let Some(i) = i.to_i32() {
-            if Self::INT_CACHE_POOL_RANGE.contains(&i) {
-                let inner_idx = (i - Self::INT_CACHE_POOL_MIN) as usize;
-                return self.int_cache_pool[inner_idx].clone();
-            }
+        if let Some(i) = i.to_i32()
+            && Self::INT_CACHE_POOL_RANGE.contains(&i)
+        {
+            let inner_idx = (i - Self::INT_CACHE_POOL_MIN) as usize;
+            return self.int_cache_pool[inner_idx].clone();
         }
         PyInt::from(i).into_ref(self)
     }
 
     #[inline]
     pub fn new_bigint(&self, i: &BigInt) -> PyIntRef {
-        if let Some(i) = i.to_i32() {
-            if Self::INT_CACHE_POOL_RANGE.contains(&i) {
-                let inner_idx = (i - Self::INT_CACHE_POOL_MIN) as usize;
-                return self.int_cache_pool[inner_idx].clone();
-            }
+        if let Some(i) = i.to_i32()
+            && Self::INT_CACHE_POOL_RANGE.contains(&i)
+        {
+            let inner_idx = (i - Self::INT_CACHE_POOL_MIN) as usize;
+            return self.int_cache_pool[inner_idx].clone();
         }
         PyInt::from(i.clone()).into_ref(self)
     }
@@ -443,13 +448,13 @@ impl Context {
     }
 
     #[inline(always)]
-    pub fn new_bool(&self, b: bool) -> PyIntRef {
+    pub fn new_bool(&self, b: bool) -> PyRef<PyBool> {
         let value = if b {
             &self.true_value
         } else {
             &self.false_value
         };
-        value.clone()
+        value.to_owned()
     }
 
     #[inline(always)]
@@ -504,14 +509,17 @@ impl Context {
         attrs.insert(identifier!(self, __module__), self.new_str(module).into());
 
         let interned_name = self.intern_str(name);
+        let slots = PyTypeSlots {
+            name: interned_name.as_str(),
+            basicsize: 0,
+            flags: PyTypeFlags::heap_type_flags() | PyTypeFlags::HAS_DICT,
+            ..PyTypeSlots::default()
+        };
         PyType::new_heap(
             name,
             bases,
             attrs,
-            PyTypeSlots {
-                name: interned_name.as_str(),
-                ..PyBaseException::make_slots()
-            },
+            slots,
             self.types.type_type.to_owned(),
             self,
         )
diff --git a/vm/src/vm/interpreter.rs b/crates/vm/src/vm/interpreter.rs
similarity index 75%
rename from vm/src/vm/interpreter.rs
rename to crates/vm/src/vm/interpreter.rs
index 02c71bf136..6faef040a0 100644
--- a/vm/src/vm/interpreter.rs
+++ b/crates/vm/src/vm/interpreter.rs
@@ -1,6 +1,6 @@
-use super::{Context, VirtualMachine, setting::Settings, thread};
-use crate::{PyResult, stdlib::atexit, vm::PyBaseExceptionRef};
-use std::sync::atomic::Ordering;
+use super::{Context, PyConfig, VirtualMachine, setting::Settings, thread};
+use crate::{PyResult, getpath, stdlib::atexit, vm::PyBaseExceptionRef};
+use core::sync::atomic::Ordering;
 
 /// The general interface for the VM
 ///
@@ -47,10 +47,14 @@ impl Interpreter {
     where
         F: FnOnce(&mut VirtualMachine),
     {
+        // Compute path configuration from settings
+        let paths = getpath::init_path_config(&settings);
+        let config = PyConfig::new(settings, paths);
+
         let ctx = Context::genesis();
         crate::types::TypeZoo::extend(ctx);
         crate::exceptions::ExceptionZoo::extend(ctx);
-        let mut vm = VirtualMachine::new(settings, ctx.clone());
+        let mut vm = VirtualMachine::new(config, ctx.clone());
         init(&mut vm);
         vm.initialize();
         Self { vm }
@@ -96,7 +100,7 @@ impl Interpreter {
     ///
     /// See [`Interpreter::finalize`] for the finalization steps.
     /// See also [`Interpreter::enter`] for pure function call to obtain Python exception.
-    pub fn run<F>(self, f: F) -> u8
+    pub fn run<F>(self, f: F) -> u32
     where
         F: FnOnce(&VirtualMachine) -> PyResult<()>,
     {
@@ -106,14 +110,15 @@ impl Interpreter {
 
     /// Finalize vm and turns an exception to exit code.
     ///
-    /// Finalization steps including 4 steps:
+    /// Finalization steps including 5 steps:
     /// 1. Flush stdout and stderr.
     /// 1. Handle exit exception and turn it to exit code.
+    /// 1. Wait for non-daemon threads (threading._shutdown).
     /// 1. Run atexit exit functions.
     /// 1. Mark vm as finalized.
     ///
     /// Note that calling `finalize` is not necessary by purpose though.
-    pub fn finalize(self, exc: Option<PyBaseExceptionRef>) -> u8 {
+    pub fn finalize(self, exc: Option<PyBaseExceptionRef>) -> u32 {
         self.enter(|vm| {
             vm.flush_std();
 
@@ -124,6 +129,9 @@ impl Interpreter {
                 0
             };
 
+            // Wait for non-daemon threads (wait_for_thread_shutdown)
+            wait_for_thread_shutdown(vm);
+
             atexit::_run_exitfuncs(vm);
 
             vm.state.finalizing.store(true, Ordering::Release);
@@ -135,6 +143,35 @@ impl Interpreter {
     }
 }
 
+/// Wait until threading._shutdown completes, provided
+/// the threading module was imported in the first place.
+/// The shutdown routine will wait until all non-daemon
+/// "threading" threads have completed.
+fn wait_for_thread_shutdown(vm: &VirtualMachine) {
+    // Try to get the threading module if it was already imported
+    // Use sys.modules.get("threading") like PyImport_GetModule
+    let threading = match (|| -> PyResult<_> {
+        let sys_modules = vm.sys_module.get_attr("modules", vm)?;
+        let threading = sys_modules.get_item("threading", vm)?;
+        Ok(threading)
+    })() {
+        Ok(module) => module,
+        Err(_) => {
+            // threading not imported, nothing to do
+            return;
+        }
+    };
+
+    // Call threading._shutdown()
+    if let Err(e) = vm.call_method(&threading, "_shutdown", ()) {
+        vm.run_unraisable(
+            e,
+            Some("Exception ignored on threading shutdown".to_owned()),
+            threading,
+        );
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -161,7 +198,7 @@ mod tests {
             let a = vm.new_pyobj(crate::common::ascii!("Hello "));
             let b = vm.new_pyobj(4_i32);
             let res = vm._mul(&a, &b).unwrap();
-            let value = res.payload::<PyStr>().unwrap();
+            let value = res.downcast_ref::<PyStr>().unwrap();
             assert_eq!(value.as_str(), "Hello Hello Hello Hello ")
         })
     }
diff --git a/crates/vm/src/vm/method.rs b/crates/vm/src/vm/method.rs
new file mode 100644
index 0000000000..b964a974c5
--- /dev/null
+++ b/crates/vm/src/vm/method.rs
@@ -0,0 +1,143 @@
+//! This module will be replaced once #3100 is done
+//! Do not expose this type to outside of this crate
+
+use super::VirtualMachine;
+use crate::{
+    builtins::{PyBaseObject, PyStr, PyStrInterned, descriptor::PyMethodDescriptor},
+    function::{IntoFuncArgs, PyMethodFlags},
+    object::{AsObject, Py, PyObject, PyObjectRef, PyResult},
+    types::PyTypeFlags,
+};
+
+#[derive(Debug)]
+pub enum PyMethod {
+    Function {
+        target: PyObjectRef,
+        func: PyObjectRef,
+    },
+    Attribute(PyObjectRef),
+}
+
+impl PyMethod {
+    pub fn get(obj: PyObjectRef, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult<Self> {
+        let cls = obj.class();
+        let getattro = cls.slots.getattro.load().unwrap();
+        if getattro as usize != PyBaseObject::getattro as usize {
+            return obj.get_attr(name, vm).map(Self::Attribute);
+        }
+
+        // any correct method name is always interned already.
+        let interned_name = vm.ctx.interned_str(name);
+        let mut is_method = false;
+
+        let cls_attr = match interned_name.and_then(|name| cls.get_attr(name)) {
+            Some(descr) => {
+                let descr_cls = descr.class();
+                let descr_get = if descr_cls
+                    .slots
+                    .flags
+                    .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
+                {
+                    // For classmethods, we need descr_get to convert instance to class
+                    if let Some(method_descr) = descr.downcast_ref::<PyMethodDescriptor>()
+                        && method_descr.method.flags.contains(PyMethodFlags::CLASS)
+                    {
+                        descr_cls.slots.descr_get.load()
+                    } else {
+                        is_method = true;
+                        None
+                    }
+                } else {
+                    let descr_get = descr_cls.slots.descr_get.load();
+                    if let Some(descr_get) = descr_get
+                        && descr_cls.slots.descr_set.load().is_some()
+                    {
+                        let cls = cls.to_owned().into();
+                        return descr_get(descr, Some(obj), Some(cls), vm).map(Self::Attribute);
+                    }
+                    descr_get
+                };
+                Some((descr, descr_get))
+            }
+            None => None,
+        };
+
+        if let Some(dict) = obj.dict()
+            && let Some(attr) = dict.get_item_opt(name, vm)?
+        {
+            return Ok(Self::Attribute(attr));
+        }
+
+        if let Some((attr, descr_get)) = cls_attr {
+            match descr_get {
+                None if is_method => Ok(Self::Function {
+                    target: obj,
+                    func: attr,
+                }),
+                Some(descr_get) => {
+                    let cls = cls.to_owned().into();
+                    descr_get(attr, Some(obj), Some(cls), vm).map(Self::Attribute)
+                }
+                None => Ok(Self::Attribute(attr)),
+            }
+        } else if let Some(getter) = cls.get_attr(identifier!(vm, __getattr__)) {
+            getter.call((obj, name.to_owned()), vm).map(Self::Attribute)
+        } else {
+            Err(vm.new_no_attribute_error(obj.clone(), name.to_owned()))
+        }
+    }
+
+    pub(crate) fn get_special<const DIRECT: bool>(
+        obj: &PyObject,
+        name: &'static PyStrInterned,
+        vm: &VirtualMachine,
+    ) -> PyResult<Option<Self>> {
+        let obj_cls = obj.class();
+        let attr = if DIRECT {
+            obj_cls.get_direct_attr(name)
+        } else {
+            obj_cls.get_attr(name)
+        };
+        let func = match attr {
+            Some(f) => f,
+            None => {
+                return Ok(None);
+            }
+        };
+        let meth = if func
+            .class()
+            .slots
+            .flags
+            .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
+        {
+            Self::Function {
+                target: obj.to_owned(),
+                func,
+            }
+        } else {
+            let obj_cls = obj_cls.to_owned().into();
+            let attr = vm
+                .call_get_descriptor_specific(&func, Some(obj.to_owned()), Some(obj_cls))
+                .unwrap_or(Ok(func))?;
+            Self::Attribute(attr)
+        };
+        Ok(Some(meth))
+    }
+
+    pub fn invoke(self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
+        let (func, args) = match self {
+            Self::Function { target, func } => (func, args.into_method_args(target, vm)),
+            Self::Attribute(func) => (func, args.into_args(vm)),
+        };
+        func.call(args, vm)
+    }
+
+    #[allow(dead_code)]
+    pub fn invoke_ref(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
+        let (func, args) = match self {
+            Self::Function { target, func } => (func, args.into_method_args(target.clone(), vm)),
+            Self::Attribute(func) => (func, args.into_args(vm)),
+        };
+        func.call(args, vm)
+    }
+}
diff --git a/crates/vm/src/vm/mod.rs b/crates/vm/src/vm/mod.rs
new file mode 100644
index 0000000000..8233df43a2
--- /dev/null
+++ b/crates/vm/src/vm/mod.rs
@@ -0,0 +1,1287 @@
+//! Implement virtual machine to run instructions.
+//!
+//! See also:
+//!   <https://github.com/ProgVal/pythonvm-rust/blob/master/src/processor/mod.rs>
+
+#[cfg(feature = "rustpython-compiler")]
+mod compile;
+mod context;
+mod interpreter;
+mod method;
+#[cfg(feature = "rustpython-compiler")]
+mod python_run;
+mod setting;
+pub mod thread;
+mod vm_new;
+mod vm_object;
+mod vm_ops;
+
+use crate::{
+    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
+    builtins::{
+        PyBaseExceptionRef, PyDict, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned,
+        PyStrRef, PyTypeRef,
+        code::PyCode,
+        dict::{PyDictItems, PyDictKeys, PyDictValues},
+        pystr::AsPyStr,
+        tuple::PyTuple,
+    },
+    codecs::CodecsRegistry,
+    common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
+    convert::ToPyObject,
+    exceptions::types::PyBaseException,
+    frame::{ExecutionResult, Frame, FrameRef},
+    frozen::FrozenModule,
+    function::{ArgMapping, FuncArgs, PySetterValue},
+    import,
+    protocol::PyIterIter,
+    scope::Scope,
+    signal, stdlib,
+    warn::WarningsState,
+};
+use alloc::borrow::Cow;
+use core::{
+    cell::{Cell, Ref, RefCell},
+    sync::atomic::AtomicBool,
+};
+use crossbeam_utils::atomic::AtomicCell;
+#[cfg(unix)]
+use nix::{
+    sys::signal::{SaFlags, SigAction, SigSet, Signal::SIGINT, kill, sigaction},
+    unistd::getpid,
+};
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::{OsStr, OsString},
+};
+
+pub use context::Context;
+pub use interpreter::Interpreter;
+pub(crate) use method::PyMethod;
+pub use setting::{CheckHashPycsMode, Paths, PyConfig, Settings};
+
+pub const MAX_MEMORY_SIZE: usize = isize::MAX as usize;
+
+// Objects are live when they are on stack, or referenced by a name (for now)
+
+/// Top level container of a python virtual machine. In theory you could
+/// create more instances of this struct and have them operate fully isolated.
+///
+/// To construct this, please refer to the [`Interpreter`]
+pub struct VirtualMachine {
+    pub builtins: PyRef<PyModule>,
+    pub sys_module: PyRef<PyModule>,
+    pub ctx: PyRc<Context>,
+    pub frames: RefCell<Vec<FrameRef>>,
+    pub wasm_id: Option<String>,
+    exceptions: RefCell<ExceptionStack>,
+    pub import_func: 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_rx: Option<signal::UserSignalReceiver>,
+    pub repr_guards: RefCell<HashSet<usize>>,
+    pub state: PyRc<PyGlobalState>,
+    pub initialized: bool,
+    recursion_depth: Cell<usize>,
+    /// Async generator firstiter hook (per-thread, set via sys.set_asyncgen_hooks)
+    pub async_gen_firstiter: RefCell<Option<PyObjectRef>>,
+    /// Async generator finalizer hook (per-thread, set via sys.set_asyncgen_hooks)
+    pub async_gen_finalizer: RefCell<Option<PyObjectRef>>,
+}
+
+#[derive(Debug, Default)]
+struct ExceptionStack {
+    exc: Option<PyBaseExceptionRef>,
+    prev: Option<Box<ExceptionStack>>,
+}
+
+pub struct PyGlobalState {
+    pub config: PyConfig,
+    pub module_inits: stdlib::StdlibMap,
+    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 codec_registry: CodecsRegistry,
+    pub finalizing: AtomicBool,
+    pub warnings: WarningsState,
+    pub override_frozen_modules: AtomicCell<isize>,
+    pub before_forkers: PyMutex<Vec<PyObjectRef>>,
+    pub after_forkers_child: PyMutex<Vec<PyObjectRef>>,
+    pub after_forkers_parent: PyMutex<Vec<PyObjectRef>>,
+    pub int_max_str_digits: AtomicCell<usize>,
+    pub switch_interval: AtomicCell<f64>,
+    /// Global trace function for all threads (set by sys._settraceallthreads)
+    pub global_trace_func: PyMutex<Option<PyObjectRef>>,
+    /// Global profile function for all threads (set by sys._setprofileallthreads)
+    pub global_profile_func: PyMutex<Option<PyObjectRef>>,
+    /// Main thread identifier (pthread_self on Unix)
+    #[cfg(feature = "threading")]
+    pub main_thread_ident: AtomicCell<u64>,
+    /// Registry of all threads' current frames for sys._current_frames()
+    #[cfg(feature = "threading")]
+    pub thread_frames: parking_lot::Mutex<HashMap<u64, stdlib::thread::CurrentFrameSlot>>,
+    /// Registry of all ThreadHandles for fork cleanup
+    #[cfg(feature = "threading")]
+    pub thread_handles: parking_lot::Mutex<Vec<stdlib::thread::HandleEntry>>,
+    /// Registry for non-daemon threads that need to be joined at shutdown
+    #[cfg(feature = "threading")]
+    pub shutdown_handles: parking_lot::Mutex<Vec<stdlib::thread::ShutdownEntry>>,
+}
+
+pub fn process_hash_secret_seed() -> u32 {
+    use std::sync::OnceLock;
+    static SEED: OnceLock<u32> = OnceLock::new();
+    // os_random is expensive, but this is only ever called once
+    *SEED.get_or_init(|| u32::from_ne_bytes(rustpython_common::rand::os_random()))
+}
+
+impl VirtualMachine {
+    /// Create a new `VirtualMachine` structure.
+    fn new(config: PyConfig, ctx: PyRc<Context>) -> Self {
+        flame_guard!("new VirtualMachine");
+
+        // make a new module without access to the vm; doesn't
+        // set __spec__, __loader__, etc. attributes
+        let new_module = |def| {
+            PyRef::new_ref(
+                PyModule::from_def(def),
+                ctx.types.module_type.to_owned(),
+                Some(ctx.new_dict()),
+            )
+        };
+
+        // Hard-core modules:
+        let builtins = new_module(stdlib::builtins::__module_def(&ctx));
+        let sys_module = new_module(stdlib::sys::__module_def(&ctx));
+
+        let import_func = 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 module_inits = stdlib::get_module_inits();
+
+        let seed = match config.settings.hash_seed {
+            Some(seed) => seed,
+            None => process_hash_secret_seed(),
+        };
+        let hash_secret = HashSecret::new(seed);
+
+        let codec_registry = CodecsRegistry::new(&ctx);
+
+        let warnings = WarningsState::init_state(&ctx);
+
+        let int_max_str_digits = AtomicCell::new(match config.settings.int_max_str_digits {
+            -1 => 4300,
+            other => other,
+        } as usize);
+        let mut vm = Self {
+            builtins,
+            sys_module,
+            ctx,
+            frames: RefCell::new(vec![]),
+            wasm_id: None,
+            exceptions: RefCell::default(),
+            import_func,
+            profile_func,
+            trace_func,
+            use_tracing: Cell::new(false),
+            recursion_limit: Cell::new(if cfg!(debug_assertions) { 256 } else { 1000 }),
+            signal_handlers,
+            signal_rx: None,
+            repr_guards: RefCell::default(),
+            state: PyRc::new(PyGlobalState {
+                config,
+                module_inits,
+                frozen: HashMap::default(),
+                stacksize: AtomicCell::new(0),
+                thread_count: AtomicCell::new(0),
+                hash_secret,
+                atexit_funcs: PyMutex::default(),
+                codec_registry,
+                finalizing: AtomicBool::new(false),
+                warnings,
+                override_frozen_modules: AtomicCell::new(0),
+                before_forkers: PyMutex::default(),
+                after_forkers_child: PyMutex::default(),
+                after_forkers_parent: PyMutex::default(),
+                int_max_str_digits,
+                switch_interval: AtomicCell::new(0.005),
+                global_trace_func: PyMutex::default(),
+                global_profile_func: PyMutex::default(),
+                #[cfg(feature = "threading")]
+                main_thread_ident: AtomicCell::new(0),
+                #[cfg(feature = "threading")]
+                thread_frames: parking_lot::Mutex::new(HashMap::new()),
+                #[cfg(feature = "threading")]
+                thread_handles: parking_lot::Mutex::new(Vec::new()),
+                #[cfg(feature = "threading")]
+                shutdown_handles: parking_lot::Mutex::new(Vec::new()),
+            }),
+            initialized: false,
+            recursion_depth: Cell::new(0),
+            async_gen_firstiter: RefCell::new(None),
+            async_gen_finalizer: RefCell::new(None),
+        };
+
+        if vm.state.hash_secret.hash_str("")
+            != vm
+                .ctx
+                .interned_str("")
+                .expect("empty str must be interned")
+                .hash(&vm)
+        {
+            panic!("Interpreters in same process must share the hash seed");
+        }
+
+        let frozen = core_frozen_inits().collect();
+        PyRc::get_mut(&mut vm.state).unwrap().frozen = frozen;
+
+        vm.builtins.init_dict(
+            vm.ctx.intern_str("builtins"),
+            Some(vm.ctx.intern_str(stdlib::builtins::DOC.unwrap()).to_owned()),
+            &vm,
+        );
+        vm.sys_module.init_dict(
+            vm.ctx.intern_str("sys"),
+            Some(vm.ctx.intern_str(stdlib::sys::DOC.unwrap()).to_owned()),
+            &vm,
+        );
+        // let name = vm.sys_module.get_attr("__name__", &vm).unwrap();
+        vm
+    }
+
+    /// set up the encodings search function
+    /// init_importlib must be called before this call
+    #[cfg(feature = "encodings")]
+    fn import_encodings(&mut self) -> PyResult<()> {
+        self.import("encodings", 0).map_err(|import_err| {
+            let rustpythonpath_env = std::env::var("RUSTPYTHONPATH").ok();
+            let pythonpath_env = std::env::var("PYTHONPATH").ok();
+            let env_set = rustpythonpath_env.as_ref().is_some() || pythonpath_env.as_ref().is_some();
+            let path_contains_env = self.state.config.paths.module_search_paths.iter().any(|s| {
+                Some(s.as_str()) == rustpythonpath_env.as_deref() || Some(s.as_str()) == pythonpath_env.as_deref()
+            });
+
+            let guide_message = if cfg!(feature = "freeze-stdlib") {
+                "`rustpython_pylib` maybe not set while using `freeze-stdlib` feature. Try using `rustpython::InterpreterConfig::init_stdlib` or manually call `vm.add_frozen(rustpython_pylib::FROZEN_STDLIB)` in `rustpython_vm::Interpreter::with_init`."
+            } else if !env_set {
+                "Neither RUSTPYTHONPATH nor PYTHONPATH is set. Try setting one of them to the stdlib directory."
+            } else if path_contains_env {
+                "RUSTPYTHONPATH or PYTHONPATH is set, but it doesn't contain the encodings library. If you are customizing the RustPython vm/interpreter, try adding the stdlib directory to the path. If you are developing the RustPython interpreter, it might be a bug during development."
+            } else {
+                "RUSTPYTHONPATH or PYTHONPATH is set, but it wasn't loaded to `PyConfig::paths::module_search_paths`. If you are going to customize the RustPython vm/interpreter, those environment variables are not loaded in the Settings struct by default. Please try creating a customized instance of the Settings struct. If you are developing the RustPython interpreter, it might be a bug during development."
+            };
+
+            let mut msg = format!(
+                "RustPython could not import the encodings module. It usually means something went wrong. Please carefully read the following messages and follow the steps.\n\
+                \n\
+                {guide_message}");
+            if !cfg!(feature = "freeze-stdlib") {
+                msg += "\n\
+                If you don't have access to a consistent external environment (e.g. targeting wasm, embedding \
+                    rustpython in another application), try enabling the `freeze-stdlib` feature.\n\
+                If this is intended and you want to exclude the encodings module from your interpreter, please remove the `encodings` feature from `rustpython-vm` crate.";
+            }
+
+            let err = self.new_runtime_error(msg);
+            err.set___cause__(Some(import_err));
+            err
+        })?;
+        Ok(())
+    }
+
+    fn import_ascii_utf8_encodings(&mut self) -> PyResult<()> {
+        import::import_frozen(self, "codecs")?;
+
+        // Use dotted names when freeze-stdlib is enabled (modules come from Lib/encodings/),
+        // otherwise use underscored names (modules come from core_modules/).
+        let (ascii_module_name, utf8_module_name) = if cfg!(feature = "freeze-stdlib") {
+            ("encodings.ascii", "encodings.utf_8")
+        } else {
+            ("encodings_ascii", "encodings_utf_8")
+        };
+
+        // Register ascii encoding
+        let ascii_module = import::import_frozen(self, ascii_module_name)?;
+        let getregentry = ascii_module.get_attr("getregentry", self)?;
+        let codec_info = getregentry.call((), self)?;
+        self.state
+            .codec_registry
+            .register_manual("ascii", codec_info.try_into_value(self)?)?;
+
+        // Register utf-8 encoding
+        let utf8_module = import::import_frozen(self, utf8_module_name)?;
+        let getregentry = utf8_module.get_attr("getregentry", self)?;
+        let codec_info = getregentry.call((), self)?;
+        self.state
+            .codec_registry
+            .register_manual("utf-8", codec_info.try_into_value(self)?)?;
+        Ok(())
+    }
+
+    fn initialize(&mut self) {
+        flame_guard!("init VirtualMachine");
+
+        if self.initialized {
+            panic!("Double Initialize Error");
+        }
+
+        // Initialize main thread ident before any threading operations
+        #[cfg(feature = "threading")]
+        stdlib::thread::init_main_thread_ident(self);
+
+        stdlib::builtins::init_module(self, &self.builtins);
+        stdlib::sys::init_module(self, &self.sys_module, &self.builtins);
+
+        let mut essential_init = || -> PyResult {
+            import::import_builtin(self, "_typing")?;
+            #[cfg(not(target_arch = "wasm32"))]
+            import::import_builtin(self, "_signal")?;
+            #[cfg(any(feature = "parser", feature = "compiler"))]
+            import::import_builtin(self, "_ast")?;
+            #[cfg(not(feature = "threading"))]
+            import::import_frozen(self, "_thread")?;
+            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| {
+                    let buffered_stdio = self.state.config.settings.buffered_stdio;
+                    let unbuffered = write && !buffered_stdio;
+                    let buf = crate::stdlib::io::open(
+                        self.ctx.new_int(fd).into(),
+                        Some(if write { "wb" } else { "rb" }),
+                        crate::stdlib::io::OpenArgs {
+                            buffering: if unbuffered { 0 } else { -1 },
+                            ..Default::default()
+                        },
+                        self,
+                    )?;
+                    let raw = if unbuffered {
+                        buf.clone()
+                    } else {
+                        buf.get_attr("raw", self)?
+                    };
+                    raw.set_attr("name", self.ctx.new_str(format!("<{name}>")), self)?;
+                    let isatty = self.call_method(&raw, "isatty", ())?.is_true(self)?;
+                    let write_through = !buffered_stdio;
+                    let line_buffering = buffered_stdio && (isatty || fd == 2);
+
+                    let newline = if cfg!(windows) { None } else { Some("\n") };
+                    let encoding = self.state.config.settings.stdio_encoding.as_deref();
+                    // stderr always uses backslashreplace (ignores stdio_errors)
+                    let errors = if fd == 2 {
+                        Some("backslashreplace")
+                    } else {
+                        self.state.config.settings.stdio_errors.as_deref()
+                    };
+
+                    let stdio = self.call_method(
+                        &io,
+                        "TextIOWrapper",
+                        (
+                            buf,
+                            encoding,
+                            errors,
+                            newline,
+                            line_buffering,
+                            write_through,
+                        ),
+                    )?;
+                    let mode = if write { "w" } else { "r" };
+                    stdio.set_attr("mode", self.ctx.new_str(mode), self)?;
+                    Ok(stdio)
+                };
+                #[cfg(not(feature = "stdio"))]
+                let make_stdio =
+                    |_name, _fd, _write| Ok(crate::builtins::PyNone.into_pyobject(self));
+
+                let set_stdio = |name, fd, write| {
+                    let stdio = make_stdio(name, fd, write)?;
+                    let dunder_name = self.ctx.intern_str(format!("__{name}__"));
+                    self.sys_module.set_attr(
+                        dunder_name, // e.g. __stdin__
+                        stdio.clone(),
+                        self,
+                    )?;
+                    self.sys_module.set_attr(name, stdio, self)?;
+                    Ok(())
+                };
+                set_stdio("stdin", 0, false)?;
+                set_stdio("stdout", 1, true)?;
+                set_stdio("stderr", 2, true)?;
+
+                let io_open = io.get_attr("open", self)?;
+                self.builtins.set_attr("open", io_open, self)?;
+            }
+
+            Ok(importlib)
+        };
+
+        let res = essential_init();
+        let importlib = self.expect_pyresult(res, "essential initialization failed");
+
+        if self.state.config.settings.allow_external_library
+            && cfg!(feature = "rustpython-compiler")
+            && let Err(e) = import::init_importlib_package(self, importlib)
+        {
+            eprintln!(
+                "importlib initialization failed. This is critical for many complicated packages."
+            );
+            self.print_exception(e);
+        }
+
+        let _expect_stdlib = cfg!(feature = "freeze-stdlib")
+            || !self.state.config.paths.module_search_paths.is_empty();
+
+        #[cfg(feature = "encodings")]
+        if _expect_stdlib {
+            if let Err(e) = self.import_encodings() {
+                eprintln!(
+                    "encodings initialization failed. Only utf-8 encoding will be supported."
+                );
+                self.print_exception(e);
+            }
+        } else {
+            // Here may not be the best place to give general `path_list` advice,
+            // but bare rustpython_vm::VirtualMachine users skipped proper settings must hit here while properly setup vm never enters here.
+            eprintln!(
+                "feature `encodings` is enabled but `paths.module_search_paths` is empty. \
+                Please add the library path to `settings.path_list`. If you intended to disable the entire standard library (including the `encodings` feature), please also make sure to disable the `encodings` feature.\n\
+                Tip: You may also want to add `\"\"` to `settings.path_list` in order to enable importing from the current working directory."
+            );
+        }
+
+        self.initialized = true;
+    }
+
+    fn state_mut(&mut self) -> &mut PyGlobalState {
+        PyRc::get_mut(&mut self.state)
+            .expect("there should not be multiple threads while a user has a mut ref to a vm")
+    }
+
+    /// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
+    pub fn add_native_module<S>(&mut self, name: S, module: stdlib::StdlibInitFunc)
+    where
+        S: Into<Cow<'static, str>>,
+    {
+        self.state_mut().module_inits.insert(name.into(), module);
+    }
+
+    pub fn add_native_modules<I>(&mut self, iter: I)
+    where
+        I: IntoIterator<Item = (Cow<'static, str>, stdlib::StdlibInitFunc)>,
+    {
+        self.state_mut().module_inits.extend(iter);
+    }
+
+    /// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
+    pub fn add_frozen<I>(&mut self, frozen: I)
+    where
+        I: IntoIterator<Item = (&'static str, FrozenModule)>,
+    {
+        self.state_mut().frozen.extend(frozen);
+    }
+
+    /// Set the custom signal channel for the interpreter
+    pub fn set_user_signal_channel(&mut self, signal_rx: signal::UserSignalReceiver) {
+        self.signal_rx = Some(signal_rx);
+    }
+
+    /// Execute Python bytecode (`.pyc`) from an in-memory buffer.
+    ///
+    /// When the RustPython CLI is available, `.pyc` files are normally executed by
+    /// invoking `rustpython <input>.pyc`. This method provides an alternative for
+    /// environments where the binary is unavailable or file I/O is restricted
+    /// (e.g. WASM).
+    ///
+    /// ## Preparing a `.pyc` file
+    ///
+    /// First, compile a Python source file into bytecode:
+    ///
+    /// ```sh
+    /// # Generate a .pyc file
+    /// $ rustpython -m py_compile <input>.py
+    /// ```
+    ///
+    /// ## Running the bytecode
+    ///
+    /// Load the resulting `.pyc` file into memory and execute it using the VM:
+    ///
+    /// ```no_run
+    /// use rustpython_vm::Interpreter;
+    /// Interpreter::without_stdlib(Default::default()).enter(|vm| {
+    ///     let bytes = std::fs::read("__pycache__/<input>.rustpython-313.pyc").unwrap();
+    ///     let main_scope = vm.new_scope_with_main().unwrap();
+    ///     vm.run_pyc_bytes(&bytes, main_scope);
+    /// });
+    /// ```
+    pub fn run_pyc_bytes(&self, pyc_bytes: &[u8], scope: Scope) -> PyResult<()> {
+        let code = PyCode::from_pyc(pyc_bytes, Some("<pyc_bytes>"), None, None, self)?;
+        self.with_simple_run("<source>", |_module_dict| {
+            self.run_code_obj(code, scope)?;
+            Ok(())
+        })
+    }
+
+    pub fn run_code_obj(&self, code: PyRef<PyCode>, scope: Scope) -> PyResult {
+        use crate::builtins::PyFunction;
+
+        // 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);
+        self.run_frame(frame)
+    }
+
+    #[cold]
+    pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
+        let sys_module = self.import("sys", 0).unwrap();
+        let unraisablehook = sys_module.get_attr("unraisablehook", self).unwrap();
+
+        let exc_type = e.class().to_owned();
+        let exc_traceback = e.__traceback__().to_pyobject(self); // TODO: actual traceback
+        let exc_value = e.into();
+        let args = stdlib::sys::UnraisableHookArgsData {
+            exc_type,
+            exc_value,
+            exc_traceback,
+            err_msg: self.new_pyobj(msg),
+            object,
+        };
+        if let Err(e) = unraisablehook.call((args,), self) {
+            println!("{}", e.as_object().repr(self).unwrap());
+        }
+    }
+
+    #[inline(always)]
+    pub fn run_frame(&self, frame: FrameRef) -> PyResult {
+        match self.with_frame(frame, |f| f.run(self))? {
+            ExecutionResult::Return(value) => Ok(value),
+            _ => panic!("Got unexpected result from function"),
+        }
+    }
+
+    /// Run `run` with main scope.
+    fn with_simple_run(
+        &self,
+        path: &str,
+        run: impl FnOnce(&Py<PyDict>) -> PyResult<()>,
+    ) -> PyResult<()> {
+        let sys_modules = self.sys_module.get_attr(identifier!(self, modules), self)?;
+        let main_module = sys_modules.get_item(identifier!(self, __main__), self)?;
+        let module_dict = main_module.dict().expect("main module must have __dict__");
+
+        // Track whether we set __file__ (for cleanup)
+        let set_file_name = !module_dict.contains_key(identifier!(self, __file__), self);
+        if set_file_name {
+            module_dict.set_item(
+                identifier!(self, __file__),
+                self.ctx.new_str(path).into(),
+                self,
+            )?;
+            module_dict.set_item(identifier!(self, __cached__), self.ctx.none(), self)?;
+        }
+
+        let result = run(&module_dict);
+
+        self.flush_io();
+
+        // Cleanup __file__ and __cached__ after execution
+        if set_file_name {
+            let _ = module_dict.del_item(identifier!(self, __file__), self);
+            let _ = module_dict.del_item(identifier!(self, __cached__), self);
+        }
+
+        result
+    }
+
+    /// flush_io
+    ///
+    /// Flush stdout and stderr. Errors are silently ignored.
+    fn flush_io(&self) {
+        if let Ok(stdout) = self.sys_module.get_attr("stdout", self) {
+            let _ = self.call_method(&stdout, identifier!(self, flush).as_str(), ());
+        }
+        if let Ok(stderr) = self.sys_module.get_attr("stderr", self) {
+            let _ = self.call_method(&stderr, identifier!(self, flush).as_str(), ());
+        }
+    }
+
+    pub fn current_recursion_depth(&self) -> usize {
+        self.recursion_depth.get()
+    }
+
+    /// Used to run the body of a (possibly) recursive function. It will raise a
+    /// RecursionError if recursive functions are nested far too many times,
+    /// preventing a stack overflow.
+    pub fn with_recursion<R, F: FnOnce() -> PyResult<R>>(&self, _where: &str, f: F) -> PyResult<R> {
+        self.check_recursive_call(_where)?;
+        self.recursion_depth.set(self.recursion_depth.get() + 1);
+        let result = f();
+        self.recursion_depth.set(self.recursion_depth.get() - 1);
+        result
+    }
+
+    pub fn with_frame<R, F: FnOnce(FrameRef) -> PyResult<R>>(
+        &self,
+        frame: FrameRef,
+        f: F,
+    ) -> PyResult<R> {
+        self.with_recursion("", || {
+            self.frames.borrow_mut().push(frame.clone());
+            // Update the current frame slot for sys._current_frames()
+            #[cfg(feature = "threading")]
+            crate::vm::thread::update_current_frame(Some(frame.clone()));
+            // Push a new exception context for frame isolation
+            // Each frame starts with no active exception (None)
+            // This prevents exceptions from leaking between function calls
+            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
+        })
+    }
+
+    /// Returns a basic CompileOpts instance with options accurate to the vm. Used
+    /// as the CompileOpts for `vm.compile()`.
+    #[cfg(feature = "rustpython-codegen")]
+    pub fn compile_opts(&self) -> crate::compiler::CompileOpts {
+        crate::compiler::CompileOpts {
+            optimize: self.state.config.settings.optimize,
+            debug_ranges: self.state.config.settings.code_debug_ranges,
+        }
+    }
+
+    // To be called right before raising the recursion depth.
+    fn check_recursive_call(&self, _where: &str) -> PyResult<()> {
+        if self.recursion_depth.get() >= self.recursion_limit.get() {
+            Err(self.new_recursion_error(format!("maximum recursion depth exceeded {_where}")))
+        } else {
+            Ok(())
+        }
+    }
+
+    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_locals(&self) -> PyResult<ArgMapping> {
+        self.current_frame()
+            .expect("called current_locals but no frames on the stack")
+            .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 try_class(&self, module: &'static str, class: &'static str) -> PyResult<PyTypeRef> {
+        let class = self
+            .import(module, 0)?
+            .get_attr(class, self)?
+            .downcast()
+            .expect("not a class");
+        Ok(class)
+    }
+
+    pub fn class(&self, module: &'static str, class: &'static str) -> PyTypeRef {
+        let module = self
+            .import(module, 0)
+            .unwrap_or_else(|_| panic!("unable to import {module}"));
+
+        let class = module
+            .get_attr(class, self)
+            .unwrap_or_else(|_| panic!("module {module:?} has no class {class}"));
+        class.downcast().expect("not a class")
+    }
+
+    /// Call Python __import__ function without from_list.
+    /// Roughly equivalent to `import module_name` or `import top.submodule`.
+    ///
+    /// See also [`VirtualMachine::import_from`] for more advanced import.
+    /// See also [`rustpython_vm::import::import_source`] and other primitive import functions.
+    #[inline]
+    pub fn import<'a>(&self, module_name: impl AsPyStr<'a>, level: usize) -> PyResult {
+        let module_name = module_name.as_pystr(&self.ctx);
+        let from_list = self.ctx.empty_tuple_typed();
+        self.import_inner(module_name, from_list, level)
+    }
+
+    /// Call Python __import__ function caller with from_list.
+    /// Roughly equivalent to `from module_name import item1, item2` or `from top.submodule import item1, item2`
+    #[inline]
+    pub fn import_from<'a>(
+        &self,
+        module_name: impl AsPyStr<'a>,
+        from_list: &Py<PyTuple<PyStrRef>>,
+        level: usize,
+    ) -> PyResult {
+        let module_name = module_name.as_pystr(&self.ctx);
+        self.import_inner(module_name, from_list, level)
+    }
+
+    fn import_inner(
+        &self,
+        module: &Py<PyStr>,
+        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
+        } else {
+            let sys_modules = self.sys_module.get_attr("modules", self)?;
+            sys_modules.get_item(module, self).ok()
+        };
+
+        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))
+            }
+        }
+    }
+
+    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:
+        let cls = value.class();
+        let list_borrow;
+        let slice = if cls.is(self.ctx.types.tuple_type) {
+            value.downcast_ref::<PyTuple>().unwrap().as_slice()
+        } else if cls.is(self.ctx.types.list_type) {
+            list_borrow = value.downcast_ref::<PyList>().unwrap().borrow_vec();
+            &list_borrow
+        } else if cls.is(self.ctx.types.dict_keys_type) {
+            // Atomic snapshot of dict keys - prevents race condition during iteration
+            let keys = value.downcast_ref::<PyDictKeys>().unwrap().dict.keys_vec();
+            return keys.into_iter().map(func).collect();
+        } else if cls.is(self.ctx.types.dict_values_type) {
+            // Atomic snapshot of dict values - prevents race condition during iteration
+            let values = value
+                .downcast_ref::<PyDictValues>()
+                .unwrap()
+                .dict
+                .values_vec();
+            return values.into_iter().map(func).collect();
+        } else if cls.is(self.ctx.types.dict_items_type) {
+            // Atomic snapshot of dict items - prevents race condition during iteration
+            let items = value
+                .downcast_ref::<PyDictItems>()
+                .unwrap()
+                .dict
+                .items_vec();
+            return items
+                .into_iter()
+                .map(|(k, v)| func(self.ctx.new_tuple(vec![k, v]).into()))
+                .collect();
+        } else {
+            return self.map_py_iter(value, func);
+        };
+        slice.iter().map(|obj| func(obj.clone())).collect()
+    }
+
+    pub fn map_iterable_object<F, R>(&self, obj: &PyObject, mut f: F) -> PyResult<PyResult<Vec<R>>>
+    where
+        F: FnMut(PyObjectRef) -> PyResult<R>,
+    {
+        match_class!(match obj {
+            ref l @ PyList => {
+                let mut i: usize = 0;
+                let mut results = Vec::with_capacity(l.borrow_vec().len());
+                loop {
+                    let elem = {
+                        let elements = &*l.borrow_vec();
+                        if i >= elements.len() {
+                            results.shrink_to_fit();
+                            return Ok(Ok(results));
+                        } else {
+                            elements[i].clone()
+                        }
+                        // free the lock
+                    };
+                    match f(elem) {
+                        Ok(result) => results.push(result),
+                        Err(err) => return Ok(Err(err)),
+                    }
+                    i += 1;
+                }
+            }
+            ref t @ PyTuple => Ok(t.iter().cloned().map(f).collect()),
+            // TODO: put internal iterable type
+            obj => {
+                Ok(self.map_py_iter(obj, f))
+            }
+        })
+    }
+
+    fn map_py_iter<F, R>(&self, value: &PyObject, mut f: F) -> PyResult<Vec<R>>
+    where
+        F: FnMut(PyObjectRef) -> PyResult<R>,
+    {
+        let iter = value.to_owned().get_iter(self)?;
+        let cap = match self.length_hint_opt(value.to_owned()) {
+            Err(e) if e.class().is(self.ctx.exceptions.runtime_error) => return Err(e),
+            Ok(Some(value)) => Some(value),
+            // Use a power of 2 as a default capacity.
+            _ => None,
+        };
+        // TODO: fix extend to do this check (?), see test_extend in Lib/test/list_tests.py,
+        // https://github.com/python/cpython/blob/v3.9.0/Objects/listobject.c#L922-L928
+        if let Some(cap) = cap
+            && cap >= isize::MAX as usize
+        {
+            return Ok(Vec::new());
+        }
+
+        let mut results = PyIterIter::new(self, iter.as_ref(), cap)
+            .map(|element| f(element?))
+            .collect::<PyResult<Vec<_>>>()?;
+        results.shrink_to_fit();
+        Ok(results)
+    }
+
+    pub fn get_attribute_opt<'a>(
+        &self,
+        obj: PyObjectRef,
+        attr_name: impl AsPyStr<'a>,
+    ) -> PyResult<Option<PyObjectRef>> {
+        let attr_name = attr_name.as_pystr(&self.ctx);
+        match obj.get_attr_inner(attr_name, self) {
+            Ok(attr) => Ok(Some(attr)),
+            Err(e) if e.fast_isinstance(self.ctx.exceptions.attribute_error) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+
+    pub fn set_attribute_error_context(
+        &self,
+        exc: &Py<PyBaseException>,
+        obj: PyObjectRef,
+        name: PyStrRef,
+    ) {
+        if exc.class().is(self.ctx.exceptions.attribute_error) {
+            let exc = exc.as_object();
+            exc.set_attr("name", name, self).unwrap();
+            exc.set_attr("obj", obj, self).unwrap();
+        }
+    }
+
+    // get_method should be used for internal access to magic methods (by-passing
+    // the full getattribute look-up.
+    pub fn get_method_or_type_error<F>(
+        &self,
+        obj: PyObjectRef,
+        method_name: &'static PyStrInterned,
+        err_msg: F,
+    ) -> PyResult
+    where
+        F: FnOnce() -> String,
+    {
+        let method = obj
+            .class()
+            .get_attr(method_name)
+            .ok_or_else(|| self.new_type_error(err_msg()))?;
+        self.call_if_get_descriptor(&method, obj)
+    }
+
+    // TODO: remove + transfer over to get_special_method
+    pub(crate) fn get_method(
+        &self,
+        obj: PyObjectRef,
+        method_name: &'static PyStrInterned,
+    ) -> Option<PyResult> {
+        let method = obj.get_class_attr(method_name)?;
+        Some(self.call_if_get_descriptor(&method, obj))
+    }
+
+    pub(crate) fn get_str_method(&self, obj: PyObjectRef, method_name: &str) -> Option<PyResult> {
+        let method_name = self.ctx.interned_str(method_name)?;
+        self.get_method(obj, method_name)
+    }
+
+    #[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(not(target_arch = "wasm32"))]
+        {
+            crate::signal::check_signals(self)
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            Ok(())
+        }
+    }
+
+    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
+    }
+
+    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
+    }
+
+    pub(crate) fn current_exception(&self) -> Option<PyBaseExceptionRef> {
+        self.exceptions.borrow().exc.clone()
+    }
+
+    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);
+    }
+
+    pub(crate) fn contextualize_exception(&self, exception: &Py<PyBaseException>) {
+        if let Some(context_exc) = self.topmost_exception()
+            && !context_exc.is(exception)
+        {
+            // Traverse the context chain to find `exception` and break cycles
+            // Uses Floyd's cycle detection: o moves every step, slow_o every other step
+            let mut o = context_exc.clone();
+            let mut slow_o = context_exc.clone();
+            let mut slow_update_toggle = false;
+            while let Some(context) = o.__context__() {
+                if context.is(exception) {
+                    o.set___context__(None);
+                    break;
+                }
+                o = context;
+                if o.is(&slow_o) {
+                    // Pre-existing cycle detected - all exceptions on the path were visited
+                    break;
+                }
+                if slow_update_toggle && let Some(slow_context) = slow_o.__context__() {
+                    slow_o = slow_context;
+                }
+                slow_update_toggle = !slow_update_toggle;
+            }
+            exception.set___context__(Some(context_exc))
+        }
+    }
+
+    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()?;
+        }
+    }
+
+    pub fn handle_exit_exception(&self, exc: PyBaseExceptionRef) -> u32 {
+        if exc.fast_isinstance(self.ctx.exceptions.system_exit) {
+            let args = exc.args();
+            let msg = match args.as_slice() {
+                [] => return 0,
+                [arg] => match_class!(match arg {
+                    ref i @ PyInt => {
+                        use num_traits::cast::ToPrimitive;
+                        // Try u32 first, then i32 (for negative values), else -1 for overflow
+                        let code = i
+                            .as_bigint()
+                            .to_u32()
+                            .or_else(|| i.as_bigint().to_i32().map(|v| v as u32))
+                            .unwrap_or(-1i32 as u32);
+                        return code;
+                    }
+                    arg => {
+                        if self.is_none(arg) {
+                            return 0;
+                        } else {
+                            arg.str(self).ok()
+                        }
+                    }
+                }),
+                _ => args.as_object().repr(self).ok(),
+            };
+            if let Some(msg) = msg {
+                // Write using Python's write() to use stderr's error handler (backslashreplace)
+                if let Ok(stderr) = stdlib::sys::get_stderr(self) {
+                    let _ = self.call_method(&stderr, "write", (msg,));
+                    let _ = self.call_method(&stderr, "write", ("\n",));
+                }
+            }
+            1
+        } else if exc.fast_isinstance(self.ctx.exceptions.keyboard_interrupt) {
+            #[allow(clippy::if_same_then_else)]
+            {
+                self.print_exception(exc);
+                #[cfg(unix)]
+                {
+                    let action = SigAction::new(
+                        nix::sys::signal::SigHandler::SigDfl,
+                        SaFlags::SA_ONSTACK,
+                        SigSet::empty(),
+                    );
+                    let result = unsafe { sigaction(SIGINT, &action) };
+                    if result.is_ok() {
+                        self.flush_std();
+                        kill(getpid(), SIGINT).expect("Expect to be killed.");
+                    }
+
+                    (libc::SIGINT as u32) + 128
+                }
+                #[cfg(windows)]
+                {
+                    // STATUS_CONTROL_C_EXIT - same as CPython
+                    0xC000013A
+                }
+                #[cfg(not(any(unix, windows)))]
+                {
+                    1
+                }
+            }
+        } else {
+            self.print_exception(exc);
+            1
+        }
+    }
+
+    #[doc(hidden)]
+    pub fn __module_set_attr(
+        &self,
+        module: &Py<PyModule>,
+        attr_name: &'static PyStrInterned,
+        attr_value: impl Into<PyObjectRef>,
+    ) -> PyResult<()> {
+        let val = attr_value.into();
+        module
+            .as_object()
+            .generic_setattr(attr_name, PySetterValue::Assign(val), self)
+    }
+
+    pub fn insert_sys_path(&self, obj: PyObjectRef) -> PyResult<()> {
+        let sys_path = self.sys_module.get_attr("path", self).unwrap();
+        self.call_method(&sys_path, "insert", (0, obj))?;
+        Ok(())
+    }
+
+    pub fn run_module(&self, module: &str) -> PyResult<()> {
+        let runpy = self.import("runpy", 0)?;
+        let run_module_as_main = runpy.get_attr("_run_module_as_main", self)?;
+        run_module_as_main.call((module,), self)?;
+        Ok(())
+    }
+
+    pub fn fs_encoding(&self) -> &'static PyStrInterned {
+        identifier!(self, utf_8)
+    }
+
+    pub fn fs_encode_errors(&self) -> &'static PyStrInterned {
+        if cfg!(windows) {
+            identifier!(self, surrogatepass)
+        } else {
+            identifier!(self, surrogateescape)
+        }
+    }
+
+    pub fn fsdecode(&self, s: impl Into<OsString>) -> PyStrRef {
+        match s.into().into_string() {
+            Ok(s) => self.ctx.new_str(s),
+            Err(s) => {
+                let bytes = self.ctx.new_bytes(s.into_encoded_bytes());
+                let errors = self.fs_encode_errors().to_owned();
+                let res = self.state.codec_registry.decode_text(
+                    bytes.into(),
+                    "utf-8",
+                    Some(errors),
+                    self,
+                );
+                self.expect_pyresult(res, "fsdecode should be lossless and never fail")
+            }
+        }
+    }
+
+    pub fn fsencode<'a>(&self, s: &'a Py<PyStr>) -> PyResult<Cow<'a, OsStr>> {
+        if cfg!(windows) || s.is_utf8() {
+            // XXX: this is sketchy on windows; it's not guaranteed that the
+            //      OsStr encoding will always be compatible with WTF-8.
+            let s = unsafe { OsStr::from_encoded_bytes_unchecked(s.as_bytes()) };
+            return Ok(Cow::Borrowed(s));
+        }
+        let errors = self.fs_encode_errors().to_owned();
+        let bytes = self
+            .state
+            .codec_registry
+            .encode_text(s.to_owned(), "utf-8", Some(errors), self)?
+            .to_vec();
+        // XXX: this is sketchy on windows; it's not guaranteed that the
+        //      OsStr encoding will always be compatible with WTF-8.
+        let s = unsafe { OsString::from_encoded_bytes_unchecked(bytes) };
+        Ok(Cow::Owned(s))
+    }
+}
+
+impl AsRef<Context> for VirtualMachine {
+    fn as_ref(&self) -> &Context {
+        &self.ctx
+    }
+}
+
+/// Resolve frozen module alias to its original name.
+/// Returns the original module name if an alias exists, otherwise returns the input name.
+pub fn resolve_frozen_alias(name: &str) -> &str {
+    match name {
+        "_frozen_importlib" => "importlib._bootstrap",
+        "_frozen_importlib_external" => "importlib._bootstrap_external",
+        "encodings_ascii" => "encodings.ascii",
+        "encodings_utf_8" => "encodings.utf_8",
+        _ => name,
+    }
+}
+
+fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
+    let iter = core::iter::empty();
+    macro_rules! ext_modules {
+        ($iter:ident, $($t:tt)*) => {
+            let $iter = $iter.chain(py_freeze!($($t)*));
+        };
+    }
+
+    // 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",
+        crate_name = "rustpython_compiler_core"
+    );
+
+    // core stdlib Python modules that the vm calls into, but are still used in Python
+    // application code, e.g. copyreg
+    // FIXME: Initializing core_modules here results duplicated frozen module generation for core_modules.
+    // We need a way to initialize this modules for both `Interpreter::without_stdlib()` and `InterpreterConfig::new().init_stdlib().interpreter()`
+    // #[cfg(not(feature = "freeze-stdlib"))]
+    ext_modules!(
+        iter,
+        dir = "./Lib/core_modules",
+        crate_name = "rustpython_compiler_core"
+    );
+
+    iter
+}
+
+#[test]
+fn test_nested_frozen() {
+    use rustpython_vm as vm;
+
+    vm::Interpreter::with_init(Default::default(), |vm| {
+        // vm.add_native_modules(rustpython_stdlib::get_module_inits());
+        vm.add_frozen(rustpython_vm::py_freeze!(
+            dir = "../../extra_tests/snippets"
+        ));
+    })
+    .enter(|vm| {
+        let scope = vm.new_scope_with_builtins();
+
+        let source = "from dir_module.dir_module_inner import value2";
+        let code_obj = vm
+            .compile(source, vm::compiler::Mode::Exec, "<embedded>".to_owned())
+            .map_err(|err| vm.new_syntax_error(&err, Some(source)))
+            .unwrap();
+
+        if let Err(e) = vm.run_code_obj(code_obj, scope) {
+            vm.print_exception(e);
+            panic!();
+        }
+    })
+}
+
+#[test]
+fn frozen_origname_matches() {
+    use rustpython_vm as vm;
+
+    vm::Interpreter::with_init(Default::default(), |_vm| {}).enter(|vm| {
+        let check = |name, expected| {
+            let module = import::import_frozen(vm, name).unwrap();
+            let origname: PyStrRef = module
+                .get_attr("__origname__", vm)
+                .unwrap()
+                .try_into_value(vm)
+                .unwrap();
+            assert_eq!(origname.as_str(), expected);
+        };
+
+        check("_frozen_importlib", "importlib._bootstrap");
+        check(
+            "_frozen_importlib_external",
+            "importlib._bootstrap_external",
+        );
+    });
+}
diff --git a/crates/vm/src/vm/python_run.rs b/crates/vm/src/vm/python_run.rs
new file mode 100644
index 0000000000..1c712279f8
--- /dev/null
+++ b/crates/vm/src/vm/python_run.rs
@@ -0,0 +1,151 @@
+//! Python code execution functions.
+
+use crate::{
+    Py, PyResult, VirtualMachine,
+    builtins::{PyCode, PyDict},
+    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.
+    pub fn run_simple_string(&self, source: &str) -> PyResult {
+        let scope = self.new_scope_with_builtins();
+        self.run_string(scope, source, "<string>".to_owned())
+    }
+
+    /// PyRun_String
+    ///
+    /// Execute a string of Python code with explicit scope and source path.
+    pub fn run_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
+        let code_obj = self
+            .compile(source, compiler::Mode::Exec, source_path)
+            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
+        self.run_code_obj(code_obj, scope)
+    }
+
+    #[deprecated(note = "use run_string instead")]
+    pub fn run_code_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
+        self.run_string(scope, source, source_path)
+    }
+
+    // #[deprecated(note = "use rustpython::run_file instead; if this changes causes problems, please report an issue.")]
+    pub fn run_script(&self, scope: Scope, path: &str) -> PyResult<()> {
+        self.run_any_file(scope, path)
+    }
+
+    pub fn run_block_expr(&self, scope: Scope, source: &str) -> PyResult {
+        let code_obj = self
+            .compile(source, compiler::Mode::BlockExpr, "<embedded>".to_owned())
+            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
+        self.run_code_obj(code_obj, scope)
+    }
+}
+
+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(())
+}
+
+/// 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)
+}
+
+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
new file mode 100644
index 0000000000..9be21b4484
--- /dev/null
+++ b/crates/vm/src/vm/setting.rs
@@ -0,0 +1,212 @@
+#[cfg(feature = "flame-it")]
+use std::ffi::OsString;
+
+/// Path configuration computed at runtime (like PyConfig path outputs)
+#[derive(Debug, Clone, Default)]
+pub struct Paths {
+    /// sys.executable
+    pub executable: String,
+    /// sys._base_executable (original interpreter in venv)
+    pub base_executable: String,
+    /// sys.prefix
+    pub prefix: String,
+    /// sys.base_prefix
+    pub base_prefix: String,
+    /// sys.exec_prefix
+    pub exec_prefix: String,
+    /// sys.base_exec_prefix
+    pub base_exec_prefix: String,
+    /// Computed module_search_paths (complete sys.path)
+    pub module_search_paths: Vec<String>,
+}
+
+/// Combined configuration: user settings + computed paths
+/// CPython directly exposes every fields under both of them.
+/// We separate them to maintain better ownership discipline.
+pub struct PyConfig {
+    pub settings: Settings,
+    pub paths: Paths,
+}
+
+impl PyConfig {
+    pub fn new(settings: Settings, paths: Paths) -> Self {
+        Self { settings, paths }
+    }
+}
+
+/// User-configurable settings for the python vm.
+#[non_exhaustive]
+pub struct Settings {
+    /// -I
+    pub isolated: bool,
+
+    // int use_environment
+    /// -Xdev
+    pub dev_mode: bool,
+
+    /// Not set SIGINT handler(i.e. for embedded mode)
+    pub install_signal_handlers: bool,
+
+    /// PYTHONHASHSEED=x
+    /// None means use_hash_seed = 0 in CPython
+    pub hash_seed: Option<u32>,
+
+    /// -X faulthandler, PYTHONFAULTHANDLER
+    pub faulthandler: bool,
+
+    // int tracemalloc;
+    // int perf_profiling;
+    // int import_time;
+    /// -X no_debug_ranges: disable column info in bytecode
+    pub code_debug_ranges: bool,
+    // int show_ref_count;
+    // int dump_refs;
+    // wchar_t *dump_refs_file;
+    // int malloc_stats;
+    // wchar_t *filesystem_encoding;
+    // wchar_t *filesystem_errors;
+    // wchar_t *pycache_prefix;
+    // int parse_argv;
+    // PyWideStringList orig_argv;
+    /// sys.argv
+    pub argv: Vec<String>,
+
+    // spell-checker:ignore Xfoo
+    /// -Xfoo[=bar]
+    pub xoptions: Vec<(String, Option<String>)>,
+
+    // spell-checker:ignore Wfoo
+    /// -Wfoo
+    pub warnoptions: Vec<String>,
+
+    /// -S
+    pub import_site: bool,
+
+    /// -b
+    pub bytes_warning: u64,
+
+    /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
+    pub warn_default_encoding: bool,
+
+    /// -i
+    pub inspect: bool,
+
+    /// -i, with no script
+    pub interactive: bool,
+
+    // int optimization_level;
+    // int parser_debug;
+    /// -B
+    pub write_bytecode: bool,
+
+    /// verbosity level (-v switch)
+    pub verbose: u8,
+
+    /// -q
+    pub quiet: bool,
+
+    /// -s
+    pub user_site_directory: bool,
+
+    // int configure_c_stdio;
+    /// -u, PYTHONUNBUFFERED=x
+    pub buffered_stdio: bool,
+
+    /// PYTHONIOENCODING - stdio encoding
+    pub stdio_encoding: Option<String>,
+    /// PYTHONIOENCODING - stdio error handler
+    pub stdio_errors: Option<String>,
+    pub utf8_mode: u8,
+    /// --check-hash-based-pycs
+    pub check_hash_pycs_mode: CheckHashPycsMode,
+
+    // int use_frozen_modules;
+    /// -P
+    pub safe_path: bool,
+
+    /// -X int_max_str_digits
+    pub int_max_str_digits: i64,
+
+    // /* --- Path configuration inputs ------------ */
+    // int pathconfig_warnings;
+    // wchar_t *program_name;
+    /// Environment PYTHONPATH (and RUSTPYTHONPATH)
+    pub path_list: Vec<String>,
+
+    // wchar_t *home;
+    // wchar_t *platlibdir;
+    /// -d command line switch
+    pub debug: u8,
+
+    /// -O optimization switch counter
+    pub optimize: u8,
+
+    /// -E
+    pub ignore_environment: bool,
+
+    /// false for wasm. Not a command-line option
+    pub allow_external_library: bool,
+
+    #[cfg(feature = "flame-it")]
+    pub profile_output: Option<OsString>,
+    #[cfg(feature = "flame-it")]
+    pub profile_format: Option<String>,
+}
+
+#[derive(Debug, Default, Copy, Clone, strum_macros::Display, strum_macros::EnumString)]
+#[strum(serialize_all = "lowercase")]
+pub enum CheckHashPycsMode {
+    #[default]
+    Default,
+    Always,
+    Never,
+}
+
+impl Settings {
+    pub fn with_path(mut self, path: String) -> Self {
+        self.path_list.push(path);
+        self
+    }
+}
+
+/// Sensible default settings.
+impl Default for Settings {
+    fn default() -> Self {
+        Self {
+            debug: 0,
+            inspect: false,
+            interactive: false,
+            optimize: 0,
+            install_signal_handlers: true,
+            user_site_directory: true,
+            import_site: true,
+            ignore_environment: false,
+            verbose: 0,
+            quiet: false,
+            write_bytecode: true,
+            safe_path: false,
+            bytes_warning: 0,
+            xoptions: vec![],
+            isolated: false,
+            dev_mode: false,
+            warn_default_encoding: false,
+            warnoptions: vec![],
+            path_list: vec![],
+            argv: vec![],
+            hash_seed: None,
+            faulthandler: false,
+            code_debug_ranges: true,
+            buffered_stdio: true,
+            check_hash_pycs_mode: CheckHashPycsMode::Default,
+            allow_external_library: cfg!(feature = "importlib"),
+            stdio_encoding: None,
+            stdio_errors: None,
+            utf8_mode: 1,
+            int_max_str_digits: 4300,
+            #[cfg(feature = "flame-it")]
+            profile_output: None,
+            #[cfg(feature = "flame-it")]
+            profile_format: None,
+        }
+    }
+}
diff --git a/crates/vm/src/vm/thread.rs b/crates/vm/src/vm/thread.rs
new file mode 100644
index 0000000000..7188aa6d27
--- /dev/null
+++ b/crates/vm/src/vm/thread.rs
@@ -0,0 +1,242 @@
+#[cfg(feature = "threading")]
+use crate::frame::FrameRef;
+use crate::{AsObject, PyObject, VirtualMachine};
+use core::{
+    cell::{Cell, RefCell},
+    ptr::NonNull,
+};
+use itertools::Itertools;
+#[cfg(feature = "threading")]
+use std::sync::Arc;
+use std::thread_local;
+
+/// Type for current frame slot - shared between threads for sys._current_frames()
+#[cfg(feature = "threading")]
+pub type CurrentFrameSlot = Arc<parking_lot::Mutex<Option<FrameRef>>>;
+
+thread_local! {
+    pub(super) static VM_STACK: RefCell<Vec<NonNull<VirtualMachine>>> = Vec::with_capacity(1).into();
+
+    pub(crate) static COROUTINE_ORIGIN_TRACKING_DEPTH: Cell<u32> = const { Cell::new(0) };
+
+    /// Current thread's frame slot for sys._current_frames()
+    #[cfg(feature = "threading")]
+    static CURRENT_FRAME_SLOT: RefCell<Option<CurrentFrameSlot>> = const { RefCell::new(None) };
+}
+
+scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);
+
+pub fn with_current_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {
+    if !VM_CURRENT.is_set() {
+        panic!("call with_current_vm() but VM_CURRENT is null");
+    }
+    VM_CURRENT.with(f)
+}
+
+pub fn enter_vm<R>(vm: &VirtualMachine, f: impl FnOnce() -> R) -> R {
+    VM_STACK.with(|vms| {
+        vms.borrow_mut().push(vm.into());
+
+        // Initialize frame slot for this thread if not already done
+        #[cfg(feature = "threading")]
+        init_frame_slot_if_needed(vm);
+
+        scopeguard::defer! { vms.borrow_mut().pop(); }
+        VM_CURRENT.set(vm, f)
+    })
+}
+
+/// Initialize frame slot for current thread if not already initialized.
+/// Called automatically by enter_vm().
+#[cfg(feature = "threading")]
+fn init_frame_slot_if_needed(vm: &VirtualMachine) {
+    CURRENT_FRAME_SLOT.with(|slot| {
+        if slot.borrow().is_none() {
+            let thread_id = crate::stdlib::thread::get_ident();
+            let new_slot = Arc::new(parking_lot::Mutex::new(None));
+            vm.state
+                .thread_frames
+                .lock()
+                .insert(thread_id, new_slot.clone());
+            *slot.borrow_mut() = Some(new_slot);
+        }
+    });
+}
+
+/// Update the current thread's frame. Called when frames are pushed/popped.
+/// This is a hot path - uses only thread-local storage, no locks.
+#[cfg(feature = "threading")]
+pub fn update_current_frame(frame: Option<FrameRef>) {
+    CURRENT_FRAME_SLOT.with(|slot| {
+        if let Some(s) = slot.borrow().as_ref() {
+            *s.lock() = frame;
+        }
+    });
+}
+
+/// Cleanup frame tracking for the current thread. Called at thread exit.
+#[cfg(feature = "threading")]
+pub fn cleanup_current_thread_frames(vm: &VirtualMachine) {
+    let thread_id = crate::stdlib::thread::get_ident();
+    vm.state.thread_frames.lock().remove(&thread_id);
+    CURRENT_FRAME_SLOT.with(|s| {
+        *s.borrow_mut() = None;
+    });
+}
+
+/// Reinitialize frame slot after fork. Called in child process.
+/// Creates a fresh slot and registers it for the current thread.
+#[cfg(feature = "threading")]
+pub fn reinit_frame_slot_after_fork(vm: &VirtualMachine) {
+    let current_ident = crate::stdlib::thread::get_ident();
+    let new_slot = Arc::new(parking_lot::Mutex::new(None));
+
+    // Try to update the global registry. If we can't get the lock
+    // (parent thread might have been holding it during fork), skip.
+    if let Some(mut registry) = vm.state.thread_frames.try_lock() {
+        registry.clear();
+        registry.insert(current_ident, new_slot.clone());
+    }
+
+    // Always update thread-local to point to the new slot
+    CURRENT_FRAME_SLOT.with(|s| {
+        *s.borrow_mut() = Some(new_slot);
+    });
+}
+
+pub fn with_vm<F, R>(obj: &PyObject, f: F) -> Option<R>
+where
+    F: Fn(&VirtualMachine) -> R,
+{
+    let vm_owns_obj = |interp: NonNull<VirtualMachine>| {
+        // SAFETY: all references in VM_STACK should be valid
+        let vm = unsafe { interp.as_ref() };
+        obj.fast_isinstance(vm.ctx.types.object_type)
+    };
+    VM_STACK.with(|vms| {
+        let interp = match vms.borrow().iter().copied().exactly_one() {
+            Ok(x) => {
+                debug_assert!(vm_owns_obj(x));
+                x
+            }
+            Err(mut others) => others.find(|x| vm_owns_obj(*x))?,
+        };
+        // SAFETY: all references in VM_STACK should be valid, and should not be changed or moved
+        // at least until this function returns and the stack unwinds to an enter_vm() call
+        let vm = unsafe { interp.as_ref() };
+        Some(VM_CURRENT.set(vm, || f(vm)))
+    })
+}
+
+#[must_use = "ThreadedVirtualMachine does nothing unless you move it to another thread and call .run()"]
+#[cfg(feature = "threading")]
+pub struct ThreadedVirtualMachine {
+    pub(super) vm: VirtualMachine,
+}
+
+#[cfg(feature = "threading")]
+impl ThreadedVirtualMachine {
+    /// Create a `FnOnce()` that can easily be passed to a function like [`std::thread::Builder::spawn`]
+    ///
+    /// # Note
+    ///
+    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't `join()`
+    /// on the thread this `FnOnce` runs in, there is a possibility that that thread will panic
+    /// as `PyObjectRef`'s `Drop` implementation tries to run the `__del__` destructor of a
+    /// Python object but finds that it's not in the context of any vm.
+    pub fn make_spawn_func<F, R>(self, f: F) -> impl FnOnce() -> R
+    where
+        F: FnOnce(&VirtualMachine) -> R,
+    {
+        move || self.run(f)
+    }
+
+    /// Run a function in this thread context
+    ///
+    /// # Note
+    ///
+    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't return the object
+    /// to the parent thread and then `join()` on the `JoinHandle` (or similar), there is a possibility that
+    /// the current thread will panic as `PyObjectRef`'s `Drop` implementation tries to run the `__del__`
+    /// destructor of a python object but finds that it's not in the context of any vm.
+    pub fn run<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(&VirtualMachine) -> R,
+    {
+        let vm = &self.vm;
+        enter_vm(vm, || f(vm))
+    }
+}
+
+impl VirtualMachine {
+    /// Start a new thread with access to the same interpreter.
+    ///
+    /// # Note
+    ///
+    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't `join()`
+    /// on the thread, there is a possibility that that thread will panic as `PyObjectRef`'s `Drop`
+    /// implementation tries to run the `__del__` destructor of a python object but finds that it's
+    /// not in the context of any vm.
+    #[cfg(feature = "threading")]
+    pub fn start_thread<F, R>(&self, f: F) -> std::thread::JoinHandle<R>
+    where
+        F: FnOnce(&Self) -> R,
+        F: Send + 'static,
+        R: Send + 'static,
+    {
+        let func = self.new_thread().make_spawn_func(f);
+        std::thread::spawn(func)
+    }
+
+    /// Create a new VM thread that can be passed to a function like [`std::thread::spawn`]
+    /// to use the same interpreter on a different thread. Note that if you just want to
+    /// use this with `thread::spawn`, you can use
+    /// [`vm.start_thread()`](`VirtualMachine::start_thread`) as a convenience.
+    ///
+    /// # Usage
+    ///
+    /// ```
+    /// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
+    /// use std::thread::Builder;
+    /// let handle = Builder::new()
+    ///     .name("my thread :)".into())
+    ///     .spawn(vm.new_thread().make_spawn_func(|vm| vm.ctx.none()))
+    ///     .expect("couldn't spawn thread");
+    /// let returned_obj = handle.join().expect("thread panicked");
+    /// assert!(vm.is_none(&returned_obj));
+    /// # })
+    /// ```
+    ///
+    /// Note: this function is safe, but running the returned ThreadedVirtualMachine in the same
+    /// thread context (i.e. with the same thread-local storage) doesn't have any
+    /// specific guaranteed behavior.
+    #[cfg(feature = "threading")]
+    pub fn new_thread(&self) -> ThreadedVirtualMachine {
+        let global_trace = self.state.global_trace_func.lock().clone();
+        let global_profile = self.state.global_profile_func.lock().clone();
+        let use_tracing = global_trace.is_some() || global_profile.is_some();
+
+        let vm = Self {
+            builtins: self.builtins.clone(),
+            sys_module: self.sys_module.clone(),
+            ctx: self.ctx.clone(),
+            frames: RefCell::new(vec![]),
+            wasm_id: self.wasm_id.clone(),
+            exceptions: RefCell::default(),
+            import_func: self.import_func.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_rx: None,
+            repr_guards: RefCell::default(),
+            state: self.state.clone(),
+            initialized: self.initialized,
+            recursion_depth: Cell::new(0),
+            async_gen_firstiter: RefCell::new(None),
+            async_gen_finalizer: RefCell::new(None),
+        };
+        ThreadedVirtualMachine { vm }
+    }
+}
diff --git a/vm/src/vm/vm_new.rs b/crates/vm/src/vm/vm_new.rs
similarity index 83%
rename from vm/src/vm/vm_new.rs
rename to crates/vm/src/vm/vm_new.rs
index 7673620c00..119444be75 100644
--- a/vm/src/vm/vm_new.rs
+++ b/crates/vm/src/vm/vm_new.rs
@@ -1,17 +1,19 @@
 use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyRef,
+    AsObject, Py, PyObject, PyObjectRef, PyRef, PyResult,
     builtins::{
-        PyBaseException, PyBaseExceptionRef, PyBytesRef, PyDictRef, PyModule, PyStrRef, PyType,
-        PyTypeRef,
+        PyBaseException, PyBaseExceptionRef, PyBytesRef, PyDictRef, PyModule, PyOSError, PyStrRef,
+        PyType, PyTypeRef,
         builtin_func::PyNativeFunction,
         descriptor::PyMethodDescriptor,
         tuple::{IntoPyTuple, PyTupleRef},
     },
-    convert::ToPyObject,
+    convert::{ToPyException, ToPyObject},
+    exceptions::OSErrorBuilder,
     function::{IntoPyNativeFn, PyMethodFlags},
     scope::Scope,
     vm::VirtualMachine,
 };
+use rustpython_compiler_core::SourceLocation;
 
 macro_rules! define_exception_fn {
     (
@@ -60,6 +62,23 @@ impl VirtualMachine {
         Scope::with_builtins(None, self.ctx.new_dict(), self)
     }
 
+    pub fn new_scope_with_main(&self) -> PyResult<Scope> {
+        let scope = self.new_scope_with_builtins();
+        let main_module = self.new_module("__main__", scope.globals.clone(), None);
+        main_module
+            .dict()
+            .set_item("__annotations__", self.ctx.new_dict().into(), self)
+            .expect("Failed to initialize __main__.__annotations__");
+
+        self.sys_module.get_attr("modules", self)?.set_item(
+            "__main__",
+            main_module.into(),
+            self,
+        )?;
+
+        Ok(scope)
+    }
+
     pub fn new_function<F, FKind>(&self, name: &'static str, f: F) -> PyRef<PyNativeFunction>
     where
         F: IntoPyNativeFn<FKind>,
@@ -91,18 +110,36 @@ impl VirtualMachine {
     /// [`vm.invoke_exception()`][Self::invoke_exception] or
     /// [`exceptions::ExceptionCtor`][crate::exceptions::ExceptionCtor] instead.
     pub fn new_exception(&self, exc_type: PyTypeRef, args: Vec<PyObjectRef>) -> PyBaseExceptionRef {
-        // TODO: add repr of args into logging?
+        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()
+        );
 
         PyRef::new_ref(
-            // TODO: this constructor might be invalid, because multiple
-            // exception (even builtin ones) are using custom constructors,
-            // see `OSError` as an example:
             PyBaseException::new(args, self),
             exc_type,
             Some(self.ctx.new_dict()),
         )
     }
 
+    pub fn new_os_error(&self, msg: impl ToPyObject) -> PyRef<PyBaseException> {
+        self.new_os_subtype_error(self.ctx.exceptions.os_error.to_owned(), None, msg)
+            .upcast()
+    }
+
+    pub fn new_os_subtype_error(
+        &self,
+        exc_type: PyTypeRef,
+        errno: Option<i32>,
+        msg: impl ToPyObject,
+    ) -> PyRef<PyOSError> {
+        debug_assert_eq!(exc_type.slots.basicsize, core::mem::size_of::<PyOSError>());
+
+        OSErrorBuilder::with_subtype(exc_type, errno, msg, self).build(self)
+    }
+
     /// Instantiate an exception with no arguments.
     /// This function should only be used with builtin exception types; if a user-defined exception
     /// type is passed in, it may not be fully initialized; try using
@@ -201,16 +238,29 @@ impl VirtualMachine {
         ))
     }
 
-    pub fn new_errno_error(&self, errno: i32, msg: impl Into<String>) -> PyBaseExceptionRef {
-        let vm = self;
-        let exc_type =
-            crate::exceptions::errno_to_exc_type(errno, vm).unwrap_or(vm.ctx.exceptions.os_error);
+    /// Create a new OSError from the last OS error.
+    ///
+    /// On windows, windows-sys errors are expected to be handled by this function.
+    /// This is identical to `new_last_errno_error` on non-Windows platforms.
+    pub fn new_last_os_error(&self) -> PyBaseExceptionRef {
+        let err = std::io::Error::last_os_error();
+        err.to_pyexception(self)
+    }
 
-        let errno_obj = vm.new_pyobj(errno);
-        vm.new_exception(
-            exc_type.to_owned(),
-            vec![errno_obj, vm.new_pyobj(msg.into())],
-        )
+    /// Create a new OSError from the last POSIX errno.
+    ///
+    /// On windows, CRT errno are expected to be handled by this function.
+    /// This is identical to `new_last_os_error` on non-Windows platforms.
+    pub fn new_last_errno_error(&self) -> PyBaseExceptionRef {
+        let err = crate::common::os::errno_io_error();
+        err.to_pyexception(self)
+    }
+
+    pub fn new_errno_error(&self, errno: i32, msg: impl ToPyObject) -> PyRef<PyOSError> {
+        let exc_type = crate::exceptions::errno_to_exc_type(errno, self)
+            .unwrap_or(self.ctx.exceptions.os_error);
+
+        self.new_os_subtype_error(exc_type.to_owned(), Some(errno), msg)
     }
 
     pub fn new_unicode_decode_error_real(
@@ -286,8 +336,6 @@ impl VirtualMachine {
         source: Option<&str>,
         allow_incomplete: bool,
     ) -> PyBaseExceptionRef {
-        use crate::source::SourceLocation;
-
         let syntax_error_type = match &error {
             #[cfg(feature = "parser")]
             // FIXME: this condition will cause TabError even when the matching actual error is IndentationError
@@ -322,7 +370,7 @@ impl VirtualMachine {
                 error:
                     ruff_python_parser::ParseErrorType::Lexical(
                         ruff_python_parser::LexicalErrorType::FStringError(
-                            ruff_python_parser::FStringErrorType::UnterminatedTripleQuotedString,
+                            ruff_python_parser::InterpolatedStringErrorType::UnterminatedTripleQuotedString,
                         ),
                     ),
                 ..
@@ -348,10 +396,11 @@ impl VirtualMachine {
                     if let Some(source) = source {
                         let loc = raw_location.start().to_usize();
                         let mut iter = source.chars();
-                        if let Some(quote) = iter.nth(loc) {
-                            if iter.next() == Some(quote) && iter.next() == Some(quote) {
-                                is_incomplete = true;
-                            }
+                        if let Some(quote) = iter.nth(loc)
+                            && iter.next() == Some(quote)
+                            && iter.next() == Some(quote)
+                        {
+                            is_incomplete = true;
                         }
                     }
 
@@ -412,7 +461,7 @@ impl VirtualMachine {
         fn get_statement(source: &str, loc: Option<SourceLocation>) -> Option<String> {
             let line = source
                 .split('\n')
-                .nth(loc?.row.to_zero_indexed())?
+                .nth(loc?.line.to_zero_indexed())?
                 .to_owned();
             Some(line + "\n")
         }
@@ -450,6 +499,20 @@ impl VirtualMachine {
             .set_attr("offset", offset, self)
             .unwrap();
 
+        // Set end_lineno and end_offset if available
+        if let Some((end_lineno, end_offset)) = error.python_end_location() {
+            let end_lineno = self.ctx.new_int(end_lineno);
+            let end_offset = self.ctx.new_int(end_offset);
+            syntax_error
+                .as_object()
+                .set_attr("end_lineno", end_lineno, self)
+                .unwrap();
+            syntax_error
+                .as_object()
+                .set_attr("end_offset", end_offset, self)
+                .unwrap();
+        }
+
         syntax_error
             .as_object()
             .set_attr("text", statement.to_pyobject(self), self)
@@ -509,7 +572,7 @@ impl VirtualMachine {
         #[cfg(debug_assertions)]
         let msg = if class.get_id() == actual_class.get_id() {
             let mut msg = msg;
-            msg += " Did you forget to add `#[pyclass(with(Constructor))]`?";
+            msg += " It might mean this type doesn't support subclassing very well. e.g. Did you forget to add `#[pyclass(with(Constructor))]`?";
             msg
         } else {
             msg
@@ -547,7 +610,6 @@ impl VirtualMachine {
     define_exception_fn!(fn new_eof_error, eof_error, EOFError);
     define_exception_fn!(fn new_attribute_error, attribute_error, AttributeError);
     define_exception_fn!(fn new_type_error, type_error, TypeError);
-    define_exception_fn!(fn new_os_error, os_error, OSError);
     define_exception_fn!(fn new_system_error, system_error, SystemError);
 
     // TODO: remove & replace with new_unicode_decode_error_real
@@ -569,5 +631,6 @@ impl VirtualMachine {
     define_exception_fn!(fn new_zero_division_error, zero_division_error, ZeroDivisionError);
     define_exception_fn!(fn new_overflow_error, overflow_error, OverflowError);
     define_exception_fn!(fn new_runtime_error, runtime_error, RuntimeError);
+    define_exception_fn!(fn new_python_finalization_error, python_finalization_error, PythonFinalizationError);
     define_exception_fn!(fn new_memory_error, memory_error, MemoryError);
 }
diff --git a/vm/src/vm/vm_object.rs b/crates/vm/src/vm/vm_object.rs
similarity index 97%
rename from vm/src/vm/vm_object.rs
rename to crates/vm/src/vm/vm_object.rs
index 69e8bcd8f3..0d5b286148 100644
--- a/vm/src/vm/vm_object.rs
+++ b/crates/vm/src/vm/vm_object.rs
@@ -2,7 +2,6 @@ use super::PyMethod;
 use crate::{
     builtins::{PyBaseExceptionRef, PyList, PyStrInterned, pystr::AsPyStr},
     function::IntoFuncArgs,
-    identifier,
     object::{AsObject, PyObject, PyObjectRef, PyResult},
     stdlib::sys,
     vm::VirtualMachine,
@@ -97,9 +96,7 @@ impl VirtualMachine {
         obj: Option<PyObjectRef>,
         cls: Option<PyObjectRef>,
     ) -> Option<PyResult> {
-        let descr_get = descr
-            .class()
-            .mro_find_map(|cls| cls.slots.descr_get.load())?;
+        let descr_get = descr.class().slots.descr_get.load()?;
         Some(descr_get(descr.to_owned(), obj, cls, self))
     }
 
diff --git a/vm/src/vm/vm_ops.rs b/crates/vm/src/vm/vm_ops.rs
similarity index 88%
rename from vm/src/vm/vm_ops.rs
rename to crates/vm/src/vm/vm_ops.rs
index 00ba2d0f66..1a362d67be 100644
--- a/vm/src/vm/vm_ops.rs
+++ b/crates/vm/src/vm/vm_ops.rs
@@ -1,9 +1,10 @@
 use super::VirtualMachine;
 use crate::stdlib::warnings;
 use crate::{
-    builtins::{PyInt, PyIntRef, PyStr, PyStrRef},
+    PyRef,
+    builtins::{PyInt, PyStr, PyStrRef, PyUtf8Str},
     object::{AsObject, PyObject, PyObjectRef, PyResult},
-    protocol::{PyIterReturn, PyNumberBinaryOp, PyNumberTernaryOp, PySequence},
+    protocol::{PyNumberBinaryOp, PyNumberTernaryOp},
     types::PyComparisonOp,
 };
 use num_traits::ToPrimitive;
@@ -119,7 +120,7 @@ impl VirtualMachine {
             }
         };
         let hint = result
-            .payload_if_subclass::<PyInt>(self)
+            .downcast_ref::<PyInt>()
             .ok_or_else(|| {
                 self.new_type_error(format!(
                     "'{}' object cannot be interpreted as an integer",
@@ -159,6 +160,7 @@ impl VirtualMachine {
         let class_a = a.class();
         let class_b = b.class();
 
+        // Number slots are inherited, direct access is O(1)
         let slot_a = class_a.slots.as_number.left_binary_op(op_slot);
         let mut slot_b = None;
 
@@ -170,14 +172,14 @@ impl VirtualMachine {
         }
 
         if let Some(slot_a) = slot_a {
-            if let Some(slot_bb) = slot_b {
-                if class_b.fast_issubclass(class_a) {
-                    let ret = slot_bb(a, b, self)?;
-                    if !ret.is(&self.ctx.not_implemented) {
-                        return Ok(ret);
-                    }
-                    slot_b = None;
+            if let Some(slot_bb) = slot_b
+                && class_b.fast_issubclass(class_a)
+            {
+                let ret = slot_bb(a, b, self)?;
+                if !ret.is(&self.ctx.not_implemented) {
+                    return Ok(ret);
                 }
+                slot_b = None;
             }
             let ret = slot_a(a, b, self)?;
             if !ret.is(&self.ctx.not_implemented) {
@@ -265,6 +267,7 @@ impl VirtualMachine {
         let class_b = b.class();
         let class_c = c.class();
 
+        // Number slots are inherited, direct access is O(1)
         let slot_a = class_a.slots.as_number.left_ternary_op(op_slot);
         let mut slot_b = None;
 
@@ -276,14 +279,14 @@ impl VirtualMachine {
         }
 
         if let Some(slot_a) = slot_a {
-            if let Some(slot_bb) = slot_b {
-                if class_b.fast_issubclass(class_a) {
-                    let ret = slot_bb(a, b, c, self)?;
-                    if !ret.is(&self.ctx.not_implemented) {
-                        return Ok(ret);
-                    }
-                    slot_b = None;
+            if let Some(slot_bb) = slot_b
+                && class_b.fast_issubclass(class_a)
+            {
+                let ret = slot_bb(a, b, c, self)?;
+                if !ret.is(&self.ctx.not_implemented) {
+                    return Ok(ret);
                 }
+                slot_b = None;
             }
             let ret = slot_a(a, b, c, self)?;
             if !ret.is(&self.ctx.not_implemented) {
@@ -298,14 +301,13 @@ impl VirtualMachine {
             }
         }
 
-        if let Some(slot_c) = class_c.slots.as_number.left_ternary_op(op_slot) {
-            if slot_a.is_some_and(|slot_a| !std::ptr::fn_addr_eq(slot_a, slot_c))
-                && slot_b.is_some_and(|slot_b| !std::ptr::fn_addr_eq(slot_b, slot_c))
-            {
-                let ret = slot_c(a, b, c, self)?;
-                if !ret.is(&self.ctx.not_implemented) {
-                    return Ok(ret);
-                }
+        if let Some(slot_c) = class_c.slots.as_number.left_ternary_op(op_slot)
+            && slot_a.is_some_and(|slot_a| !core::ptr::fn_addr_eq(slot_a, slot_c))
+            && slot_b.is_some_and(|slot_b| !core::ptr::fn_addr_eq(slot_b, slot_c))
+        {
+            let ret = slot_c(a, b, c, self)?;
+            if !ret.is(&self.ctx.not_implemented) {
+                return Ok(ret);
             }
         }
 
@@ -378,8 +380,10 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
-            let result = seq_a.concat(b, self)?;
+        // Check if concat slot is available directly, matching PyNumber_Add behavior
+        let seq = a.sequence_unchecked();
+        if let Some(f) = seq.slots().concat.load() {
+            let result = f(seq, b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
             }
@@ -392,8 +396,11 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
-            let result = seq_a.inplace_concat(b, self)?;
+        // Check inplace_concat or concat slot directly, matching PyNumber_InPlaceAdd behavior
+        let seq = a.sequence_unchecked();
+        let slots = seq.slots();
+        if let Some(f) = slots.inplace_concat.load().or_else(|| slots.concat.load()) {
+            let result = f(seq, b, self)?;
             if !result.is(&self.ctx.not_implemented) {
                 return Ok(result);
             }
@@ -406,14 +413,14 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let n = b
                 .try_index(self)?
                 .as_bigint()
                 .to_isize()
                 .ok_or_else(|| self.new_overflow_error("repeated bytes are too long"))?;
             return seq_a.repeat(n, self);
-        } else if let Ok(seq_b) = PySequence::try_protocol(b, self) {
+        } else if let Ok(seq_b) = b.try_sequence(self) {
             let n = a
                 .try_index(self)?
                 .as_bigint()
@@ -434,14 +441,14 @@ impl VirtualMachine {
         if !result.is(&self.ctx.not_implemented) {
             return Ok(result);
         }
-        if let Ok(seq_a) = PySequence::try_protocol(a, self) {
+        if let Ok(seq_a) = a.try_sequence(self) {
             let n = b
                 .try_index(self)?
                 .as_bigint()
                 .to_isize()
                 .ok_or_else(|| self.new_overflow_error("repeated bytes are too long"))?;
             return seq_a.inplace_repeat(n, self);
-        } else if let Ok(seq_b) = PySequence::try_protocol(b, self) {
+        } else if let Ok(seq_b) = b.try_sequence(self) {
             let n = a
                 .try_index(self)?
                 .as_bigint()
@@ -517,29 +524,12 @@ impl VirtualMachine {
             ))
         })
     }
-
-    // https://docs.python.org/3/reference/expressions.html#membership-test-operations
-    fn _membership_iter_search(
-        &self,
-        haystack: &PyObject,
-        needle: PyObjectRef,
-    ) -> PyResult<PyIntRef> {
-        let iter = haystack.get_iter(self)?;
-        loop {
-            if let PyIterReturn::Return(element) = iter.next(self)? {
-                if self.bool_eq(&element, &needle)? {
-                    return Ok(self.ctx.new_bool(true));
-                } else {
-                    continue;
-                }
-            } else {
-                return Ok(self.ctx.new_bool(false));
-            }
-        }
+    pub fn format_utf8(&self, obj: &PyObject, format_spec: PyStrRef) -> PyResult<PyRef<PyUtf8Str>> {
+        self.format(obj, format_spec)?.try_into_utf8(self)
     }
 
     pub fn _contains(&self, haystack: &PyObject, needle: &PyObject) -> PyResult<bool> {
-        let seq = haystack.to_sequence();
+        let seq = haystack.sequence_unchecked();
         seq.contains(needle, self)
     }
 }
diff --git a/vm/src/warn.rs b/crates/vm/src/warn.rs
similarity index 85%
rename from vm/src/warn.rs
rename to crates/vm/src/warn.rs
index 943fbcee23..b7249da19f 100644
--- a/vm/src/warn.rs
+++ b/crates/vm/src/warn.rs
@@ -1,5 +1,5 @@
 use crate::{
-    AsObject, Context, Py, PyObjectRef, PyResult, VirtualMachine,
+    AsObject, Context, Py, PyObject, PyObjectRef, PyResult, VirtualMachine,
     builtins::{
         PyDictRef, PyListRef, PyStr, PyStrInterned, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
     },
@@ -38,7 +38,7 @@ impl WarningsState {
     }
 }
 
-fn check_matched(obj: &PyObjectRef, arg: &PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
+fn check_matched(obj: &PyObject, arg: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     if obj.class().is(vm.ctx.types.none_type) {
         return Ok(true);
     }
@@ -60,15 +60,22 @@ fn get_warnings_attr(
         && !vm
             .state
             .finalizing
-            .load(std::sync::atomic::Ordering::SeqCst)
+            .load(core::sync::atomic::Ordering::SeqCst)
     {
         match vm.import("warnings", 0) {
             Ok(module) => module,
             Err(_) => return Ok(None),
         }
     } else {
-        // TODO: finalizing support
-        return Ok(None);
+        // Check sys.modules for already-imported warnings module
+        // This is what CPython does with PyImport_GetModule
+        match vm.sys_module.get_attr(identifier!(vm, modules), vm) {
+            Ok(modules) => match modules.get_item(vm.ctx.intern_str("warnings"), vm) {
+                Ok(module) => module,
+                Err(_) => return Ok(None),
+            },
+            Err(_) => return Ok(None),
+        }
     };
     Ok(Some(module.get_attr(attr_name, vm)?))
 }
@@ -122,7 +129,7 @@ fn get_filter(
 
         /* Python code: action, msg, cat, mod, ln = item */
         let action = if let Some(action) = tmp_item.first() {
-            action.str(vm).map(|action| action.into_object())
+            action.str_utf8(vm).map(|action| action.into_object())
         } else {
             Err(vm.new_type_error("action must be a string"))
         };
@@ -201,8 +208,8 @@ fn already_warned(
 fn normalize_module(filename: &Py<PyStr>, vm: &VirtualMachine) -> Option<PyObjectRef> {
     let obj = match filename.char_len() {
         0 => vm.new_pyobj("<unknown>"),
-        len if len >= 3 && filename.as_str().ends_with(".py") => {
-            vm.new_pyobj(&filename.as_str()[..len - 3])
+        len if len >= 3 && filename.as_bytes().ends_with(b".py") => {
+            vm.new_pyobj(&filename.as_wtf8()[..len - 3])
         }
         _ => filename.as_object().to_owned(),
     };
@@ -232,7 +239,7 @@ fn warn_explicit(
     };
 
     // Normalize message.
-    let text = message.as_str();
+    let text = message.as_wtf8();
 
     let category = if let Some(category) = category {
         if !category.fast_issubclass(vm.ctx.exceptions.warning) {
@@ -278,11 +285,11 @@ fn warn_explicit(
         vm,
     )?;
 
-    if action.str(vm)?.as_str().eq("error") {
+    if action.str_utf8(vm)?.as_str().eq("error") {
         return Err(vm.new_type_error(message.to_string()));
     }
 
-    if action.str(vm)?.as_str().eq("ignore") {
+    if action.str_utf8(vm)?.as_str().eq("ignore") {
         return Ok(());
     }
 
@@ -320,9 +327,13 @@ fn call_show_warning(
         return Err(vm.new_type_error("unable to get warnings.WarningMessage"));
     };
 
+    // Create a Warning instance by calling category(message)
+    // This is what warnings module does
+    let warning_instance = category.as_object().call((message,), vm)?;
+
     let msg = warnmsg_cls.call(
         vec![
-            message.into(),
+            warning_instance,
             category.into(),
             filename.into(),
             vm.new_pyobj(lineno),
@@ -345,7 +356,7 @@ fn show_warning(
     vm: &VirtualMachine,
 ) -> PyResult<()> {
     let stderr = crate::stdlib::sys::PyStderr(vm);
-    writeln!(stderr, "{}: {}", category.name(), text.as_str(),);
+    writeln!(stderr, "{}: {}", category.name(), text);
     Ok(())
 }
 
@@ -393,8 +404,20 @@ fn setup_context(
 
     let (globals, filename, lineno) = if let Some(f) = f {
         (f.globals.clone(), f.code.source_path, f.f_lineno())
+    } else if let Some(frame) = vm.current_frame() {
+        // We have a frame but it wasn't found during stack walking
+        (frame.globals.clone(), vm.ctx.intern_str("<sys>"), 1)
     } else {
-        (vm.current_globals().clone(), vm.ctx.intern_str("sys"), 1)
+        // No frames on the stack - use sys.__dict__ (interp->sysdict)
+        let globals = vm
+            .sys_module
+            .as_object()
+            .get_attr(identifier!(vm, __dict__), vm)
+            .and_then(|d| {
+                d.downcast::<crate::builtins::PyDict>()
+                    .map_err(|_| vm.new_type_error("sys.__dict__ is not a dictionary"))
+            })?;
+        (globals, vm.ctx.intern_str("<sys>"), 0)
     };
 
     let registry = if let Ok(registry) = globals.get_item(__warningregistry__, vm) {
diff --git a/crates/vm/src/windows.rs b/crates/vm/src/windows.rs
new file mode 100644
index 0000000000..ff2b612c06
--- /dev/null
+++ b/crates/vm/src/windows.rs
@@ -0,0 +1,541 @@
+use crate::common::fileutils::{
+    StatStruct,
+    windows::{FILE_INFO_BY_NAME_CLASS, get_file_information_by_name},
+};
+use crate::{
+    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    convert::{ToPyObject, ToPyResult},
+};
+use rustpython_common::windows::ToWideString;
+use std::ffi::OsStr;
+use windows_sys::Win32::Foundation::{HANDLE, INVALID_HANDLE_VALUE};
+
+/// Windows HANDLE wrapper for Python interop
+#[derive(Clone, Copy)]
+pub struct WinHandle(pub HANDLE);
+
+pub(crate) trait WindowsSysResultValue {
+    type Ok: ToPyObject;
+    fn is_err(&self) -> bool;
+    fn into_ok(self) -> Self::Ok;
+}
+
+impl WindowsSysResultValue for HANDLE {
+    type Ok = WinHandle;
+    fn is_err(&self) -> bool {
+        *self == INVALID_HANDLE_VALUE
+    }
+    fn into_ok(self) -> Self::Ok {
+        WinHandle(self)
+    }
+}
+
+// BOOL is i32 in windows-sys 0.61+
+impl WindowsSysResultValue for i32 {
+    type Ok = ();
+    fn is_err(&self) -> bool {
+        *self == 0
+    }
+    fn into_ok(self) -> Self::Ok {}
+}
+
+pub(crate) struct WindowsSysResult<T>(pub T);
+
+impl<T: WindowsSysResultValue> WindowsSysResult<T> {
+    pub fn is_err(&self) -> bool {
+        self.0.is_err()
+    }
+    pub fn into_pyresult(self, vm: &VirtualMachine) -> PyResult<T::Ok> {
+        if !self.is_err() {
+            Ok(self.0.into_ok())
+        } else {
+            Err(vm.new_last_os_error())
+        }
+    }
+}
+
+impl<T: WindowsSysResultValue> ToPyResult for WindowsSysResult<T> {
+    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
+        let ok = self.into_pyresult(vm)?;
+        Ok(ok.to_pyobject(vm))
+    }
+}
+
+type HandleInt = usize; // TODO: change to isize when fully ported to windows-rs
+
+impl TryFromObject for WinHandle {
+    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
+        let handle = HandleInt::try_from_object(vm, obj)?;
+        Ok(WinHandle(handle as HANDLE))
+    }
+}
+
+impl ToPyObject for WinHandle {
+    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
+        (self.0 as HandleInt).to_pyobject(vm)
+    }
+}
+
+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 _ = windows_sys::Win32::Networking::WinSock::WSAStartup(0x0101, wsa_data.as_mut_ptr());
+    })
+}
+
+// win32_xstat in cpython
+pub fn win32_xstat(path: &OsStr, traverse: bool) -> std::io::Result<StatStruct> {
+    let mut result = win32_xstat_impl(path, traverse)?;
+    // ctime is only deprecated from 3.12, so we copy birthtime across
+    result.st_ctime = result.st_birthtime;
+    result.st_ctime_nsec = result.st_birthtime_nsec;
+    Ok(result)
+}
+
+fn is_reparse_tag_name_surrogate(tag: u32) -> bool {
+    (tag & 0x20000000) > 0
+}
+
+// Constants
+const IO_REPARSE_TAG_SYMLINK: u32 = 0xA000000C;
+const S_IFMT: u16 = libc::S_IFMT as u16;
+const S_IFDIR: u16 = libc::S_IFDIR as u16;
+const S_IFREG: u16 = libc::S_IFREG as u16;
+const S_IFCHR: u16 = libc::S_IFCHR as u16;
+const S_IFLNK: u16 = crate::common::fileutils::windows::S_IFLNK as u16;
+const S_IFIFO: u16 = crate::common::fileutils::windows::S_IFIFO as u16;
+
+/// FILE_ATTRIBUTE_TAG_INFO structure for GetFileInformationByHandleEx
+#[repr(C)]
+#[derive(Default)]
+struct FileAttributeTagInfo {
+    file_attributes: u32,
+    reparse_tag: u32,
+}
+
+/// Ported from attributes_to_mode (fileutils.c)
+fn attributes_to_mode(attr: u32) -> u16 {
+    use windows_sys::Win32::Storage::FileSystem::{
+        FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_READONLY,
+    };
+    let mut m: u16 = 0;
+    if attr & FILE_ATTRIBUTE_DIRECTORY != 0 {
+        m |= S_IFDIR | 0o111; // IFEXEC for user,group,other
+    } else {
+        m |= S_IFREG;
+    }
+    if attr & FILE_ATTRIBUTE_READONLY != 0 {
+        m |= 0o444;
+    } else {
+        m |= 0o666;
+    }
+    m
+}
+
+/// Ported from _Py_attribute_data_to_stat (fileutils.c)
+/// Converts BY_HANDLE_FILE_INFORMATION to StatStruct
+fn attribute_data_to_stat(
+    info: &windows_sys::Win32::Storage::FileSystem::BY_HANDLE_FILE_INFORMATION,
+    reparse_tag: u32,
+    basic_info: Option<&windows_sys::Win32::Storage::FileSystem::FILE_BASIC_INFO>,
+    id_info: Option<&windows_sys::Win32::Storage::FileSystem::FILE_ID_INFO>,
+) -> StatStruct {
+    use crate::common::fileutils::windows::SECS_BETWEEN_EPOCHS;
+    use windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT;
+
+    let mut st_mode = attributes_to_mode(info.dwFileAttributes);
+    let st_size = ((info.nFileSizeHigh as u64) << 32) | (info.nFileSizeLow as u64);
+    let st_dev = id_info
+        .map(|id| id.VolumeSerialNumber as u32)
+        .unwrap_or(info.dwVolumeSerialNumber);
+    let st_nlink = info.nNumberOfLinks as i32;
+
+    // Convert FILETIME/LARGE_INTEGER to (time_t, nsec)
+    let filetime_to_time = |ft_low: u32, ft_high: u32| -> (libc::time_t, i32) {
+        let ticks = ((ft_high as i64) << 32) | (ft_low as i64);
+        let nsec = ((ticks % 10_000_000) * 100) as i32;
+        let sec = (ticks / 10_000_000 - SECS_BETWEEN_EPOCHS) as libc::time_t;
+        (sec, nsec)
+    };
+
+    let large_integer_to_time = |li: i64| -> (libc::time_t, i32) {
+        let nsec = ((li % 10_000_000) * 100) as i32;
+        let sec = (li / 10_000_000 - SECS_BETWEEN_EPOCHS) as libc::time_t;
+        (sec, nsec)
+    };
+
+    let (st_birthtime, st_birthtime_nsec);
+    let (st_mtime, st_mtime_nsec);
+    let (st_atime, st_atime_nsec);
+
+    if let Some(bi) = basic_info {
+        (st_birthtime, st_birthtime_nsec) = large_integer_to_time(bi.CreationTime);
+        (st_mtime, st_mtime_nsec) = large_integer_to_time(bi.LastWriteTime);
+        (st_atime, st_atime_nsec) = large_integer_to_time(bi.LastAccessTime);
+    } else {
+        (st_birthtime, st_birthtime_nsec) = filetime_to_time(
+            info.ftCreationTime.dwLowDateTime,
+            info.ftCreationTime.dwHighDateTime,
+        );
+        (st_mtime, st_mtime_nsec) = filetime_to_time(
+            info.ftLastWriteTime.dwLowDateTime,
+            info.ftLastWriteTime.dwHighDateTime,
+        );
+        (st_atime, st_atime_nsec) = filetime_to_time(
+            info.ftLastAccessTime.dwLowDateTime,
+            info.ftLastAccessTime.dwHighDateTime,
+        );
+    }
+
+    // Get file ID from id_info or fallback to file index
+    let (st_ino, st_ino_high) = if let Some(id) = id_info {
+        // FILE_ID_INFO.FileId is FILE_ID_128 which is [u8; 16]
+        let bytes = id.FileId.Identifier;
+        let low = u64::from_le_bytes(bytes[0..8].try_into().unwrap());
+        let high = u64::from_le_bytes(bytes[8..16].try_into().unwrap());
+        (low, high)
+    } else {
+        let ino = ((info.nFileIndexHigh as u64) << 32) | (info.nFileIndexLow as u64);
+        (ino, 0u64)
+    };
+
+    // Set symlink mode if applicable
+    if info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT != 0
+        && reparse_tag == IO_REPARSE_TAG_SYMLINK
+    {
+        st_mode = (st_mode & !S_IFMT) | S_IFLNK;
+    }
+
+    StatStruct {
+        st_dev,
+        st_ino,
+        st_ino_high,
+        st_mode,
+        st_nlink,
+        st_uid: 0,
+        st_gid: 0,
+        st_rdev: 0,
+        st_size,
+        st_atime,
+        st_atime_nsec,
+        st_mtime,
+        st_mtime_nsec,
+        st_ctime: 0, // Will be set by caller
+        st_ctime_nsec: 0,
+        st_birthtime,
+        st_birthtime_nsec,
+        st_file_attributes: info.dwFileAttributes,
+        st_reparse_tag: reparse_tag,
+    }
+}
+
+/// Get file info using FindFirstFileW (fallback when CreateFileW fails)
+/// Ported from attributes_from_dir
+fn attributes_from_dir(
+    path: &OsStr,
+) -> std::io::Result<(
+    windows_sys::Win32::Storage::FileSystem::BY_HANDLE_FILE_INFORMATION,
+    u32,
+)> {
+    use windows_sys::Win32::Storage::FileSystem::{
+        BY_HANDLE_FILE_INFORMATION, FILE_ATTRIBUTE_REPARSE_POINT, FindClose, FindFirstFileW,
+        WIN32_FIND_DATAW,
+    };
+
+    let wide: Vec<u16> = path.to_wide_with_nul();
+    let mut find_data: WIN32_FIND_DATAW = unsafe { std::mem::zeroed() };
+
+    let handle = unsafe { FindFirstFileW(wide.as_ptr(), &mut find_data) };
+    if handle == INVALID_HANDLE_VALUE {
+        return Err(std::io::Error::last_os_error());
+    }
+    unsafe { FindClose(handle) };
+
+    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    info.dwFileAttributes = find_data.dwFileAttributes;
+    info.ftCreationTime = find_data.ftCreationTime;
+    info.ftLastAccessTime = find_data.ftLastAccessTime;
+    info.ftLastWriteTime = find_data.ftLastWriteTime;
+    info.nFileSizeHigh = find_data.nFileSizeHigh;
+    info.nFileSizeLow = find_data.nFileSizeLow;
+
+    let reparse_tag = if find_data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+        find_data.dwReserved0
+    } else {
+        0
+    };
+
+    Ok((info, reparse_tag))
+}
+
+/// Ported from win32_xstat_slow_impl
+fn win32_xstat_slow_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatStruct> {
+    use windows_sys::Win32::{
+        Foundation::{
+            CloseHandle, ERROR_ACCESS_DENIED, ERROR_CANT_ACCESS_FILE, ERROR_INVALID_FUNCTION,
+            ERROR_INVALID_PARAMETER, ERROR_NOT_SUPPORTED, ERROR_SHARING_VIOLATION, GENERIC_READ,
+            INVALID_HANDLE_VALUE,
+        },
+        Storage::FileSystem::{
+            BY_HANDLE_FILE_INFORMATION, CreateFileW, FILE_ATTRIBUTE_DIRECTORY,
+            FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_REPARSE_POINT, FILE_BASIC_INFO,
+            FILE_FLAG_BACKUP_SEMANTICS, FILE_FLAG_OPEN_REPARSE_POINT, FILE_ID_INFO,
+            FILE_READ_ATTRIBUTES, FILE_SHARE_READ, FILE_SHARE_WRITE, FILE_TYPE_CHAR,
+            FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_UNKNOWN, FileAttributeTagInfo, FileBasicInfo,
+            FileIdInfo, GetFileAttributesW, GetFileInformationByHandle,
+            GetFileInformationByHandleEx, GetFileType, INVALID_FILE_ATTRIBUTES, OPEN_EXISTING,
+        },
+    };
+
+    let wide: Vec<u16> = path.to_wide_with_nul();
+
+    let access = FILE_READ_ATTRIBUTES;
+    let mut flags = FILE_FLAG_BACKUP_SEMANTICS;
+    if !traverse {
+        flags |= FILE_FLAG_OPEN_REPARSE_POINT;
+    }
+
+    let mut h_file = unsafe {
+        CreateFileW(
+            wide.as_ptr(),
+            access,
+            0,
+            core::ptr::null(),
+            OPEN_EXISTING,
+            flags,
+            std::ptr::null_mut(),
+        )
+    };
+
+    let mut file_info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
+    let mut tag_info = FileAttributeTagInfo::default();
+    let mut is_unhandled_tag = false;
+
+    if h_file == INVALID_HANDLE_VALUE {
+        let error = std::io::Error::last_os_error();
+        let error_code = error.raw_os_error().unwrap_or(0) as u32;
+
+        match error_code {
+            ERROR_ACCESS_DENIED | ERROR_SHARING_VIOLATION => {
+                // Try reading the parent directory using FindFirstFileW
+                let (info, reparse_tag) = attributes_from_dir(path)?;
+                file_info = info;
+                tag_info.reparse_tag = reparse_tag;
+
+                if file_info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT != 0
+                    && (traverse || !is_reparse_tag_name_surrogate(tag_info.reparse_tag))
+                {
+                    return Err(error);
+                }
+                // h_file remains INVALID_HANDLE_VALUE, we'll use file_info from FindFirstFileW
+            }
+            ERROR_INVALID_PARAMETER => {
+                // Retry with GENERIC_READ (needed for \\.\con)
+                h_file = unsafe {
+                    CreateFileW(
+                        wide.as_ptr(),
+                        access | GENERIC_READ,
+                        FILE_SHARE_READ | FILE_SHARE_WRITE,
+                        core::ptr::null(),
+                        OPEN_EXISTING,
+                        flags,
+                        std::ptr::null_mut(),
+                    )
+                };
+                if h_file == INVALID_HANDLE_VALUE {
+                    return Err(error);
+                }
+            }
+            ERROR_CANT_ACCESS_FILE if traverse => {
+                // bpo37834: open unhandled reparse points if traverse fails
+                is_unhandled_tag = true;
+                h_file = unsafe {
+                    CreateFileW(
+                        wide.as_ptr(),
+                        access,
+                        0,
+                        core::ptr::null(),
+                        OPEN_EXISTING,
+                        flags | FILE_FLAG_OPEN_REPARSE_POINT,
+                        std::ptr::null_mut(),
+                    )
+                };
+                if h_file == INVALID_HANDLE_VALUE {
+                    return Err(error);
+                }
+            }
+            _ => return Err(error),
+        }
+    }
+
+    // Scope for handle cleanup
+    let result = (|| -> std::io::Result<StatStruct> {
+        if h_file != INVALID_HANDLE_VALUE {
+            // Handle types other than files on disk
+            let file_type = unsafe { GetFileType(h_file) };
+            if file_type != FILE_TYPE_DISK {
+                if file_type == FILE_TYPE_UNKNOWN {
+                    let err = std::io::Error::last_os_error();
+                    if err.raw_os_error().unwrap_or(0) != 0 {
+                        return Err(err);
+                    }
+                }
+                let file_attributes = unsafe { GetFileAttributesW(wide.as_ptr()) };
+                let mut st_mode: u16 = 0;
+                if file_attributes != INVALID_FILE_ATTRIBUTES
+                    && file_attributes & FILE_ATTRIBUTE_DIRECTORY != 0
+                {
+                    st_mode = S_IFDIR;
+                } else if file_type == FILE_TYPE_CHAR {
+                    st_mode = S_IFCHR;
+                } else if file_type == FILE_TYPE_PIPE {
+                    st_mode = S_IFIFO;
+                }
+                return Ok(StatStruct {
+                    st_mode,
+                    ..Default::default()
+                });
+            }
+
+            // Query the reparse tag
+            if !traverse || is_unhandled_tag {
+                let mut local_tag_info: FileAttributeTagInfo = unsafe { std::mem::zeroed() };
+                let ret = unsafe {
+                    GetFileInformationByHandleEx(
+                        h_file,
+                        FileAttributeTagInfo,
+                        &mut local_tag_info as *mut _ as *mut _,
+                        std::mem::size_of::<FileAttributeTagInfo>() as u32,
+                    )
+                };
+                if ret == 0 {
+                    let err_code =
+                        std::io::Error::last_os_error().raw_os_error().unwrap_or(0) as u32;
+                    match err_code {
+                        ERROR_INVALID_PARAMETER | ERROR_INVALID_FUNCTION | ERROR_NOT_SUPPORTED => {
+                            local_tag_info.file_attributes = FILE_ATTRIBUTE_NORMAL;
+                            local_tag_info.reparse_tag = 0;
+                        }
+                        _ => return Err(std::io::Error::last_os_error()),
+                    }
+                } else if local_tag_info.file_attributes & FILE_ATTRIBUTE_REPARSE_POINT != 0 {
+                    if is_reparse_tag_name_surrogate(local_tag_info.reparse_tag) {
+                        if is_unhandled_tag {
+                            return Err(std::io::Error::from_raw_os_error(
+                                ERROR_CANT_ACCESS_FILE as i32,
+                            ));
+                        }
+                        // This is a symlink, keep the tag info
+                    } else if !is_unhandled_tag {
+                        // Traverse a non-link reparse point
+                        unsafe { CloseHandle(h_file) };
+                        return win32_xstat_slow_impl(path, true);
+                    }
+                }
+                tag_info = local_tag_info;
+            }
+
+            // Get file information
+            let ret = unsafe { GetFileInformationByHandle(h_file, &mut file_info) };
+            if ret == 0 {
+                let err_code = std::io::Error::last_os_error().raw_os_error().unwrap_or(0) as u32;
+                match err_code {
+                    ERROR_INVALID_PARAMETER | ERROR_INVALID_FUNCTION | ERROR_NOT_SUPPORTED => {
+                        // Volumes and physical disks are block devices
+                        return Ok(StatStruct {
+                            st_mode: 0x6000, // S_IFBLK
+                            ..Default::default()
+                        });
+                    }
+                    _ => return Err(std::io::Error::last_os_error()),
+                }
+            }
+
+            // Get FILE_BASIC_INFO
+            let mut basic_info: FILE_BASIC_INFO = unsafe { std::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,
+                )
+            } != 0;
+
+            // Get FILE_ID_INFO (optional)
+            let mut id_info: FILE_ID_INFO = unsafe { std::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,
+                )
+            } != 0;
+
+            let mut result = attribute_data_to_stat(
+                &file_info,
+                tag_info.reparse_tag,
+                if has_basic_info {
+                    Some(&basic_info)
+                } else {
+                    None
+                },
+                if has_id_info { Some(&id_info) } else { None },
+            );
+            result.update_st_mode_from_path(path, file_info.dwFileAttributes);
+            Ok(result)
+        } else {
+            // We got file_info from attributes_from_dir
+            let mut result = attribute_data_to_stat(&file_info, tag_info.reparse_tag, None, None);
+            result.update_st_mode_from_path(path, file_info.dwFileAttributes);
+            Ok(result)
+        }
+    })();
+
+    // Cleanup
+    if h_file != INVALID_HANDLE_VALUE {
+        unsafe { CloseHandle(h_file) };
+    }
+
+    result
+}
+
+fn win32_xstat_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatStruct> {
+    use windows_sys::Win32::{Foundation, Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT};
+
+    let stat_info =
+        get_file_information_by_name(path, FILE_INFO_BY_NAME_CLASS::FileStatBasicByNameInfo);
+    match stat_info {
+        Ok(stat_info) => {
+            if (stat_info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0)
+                || (!traverse && is_reparse_tag_name_surrogate(stat_info.ReparseTag))
+            {
+                let mut result =
+                    crate::common::fileutils::windows::stat_basic_info_to_stat(&stat_info);
+                // If st_ino is 0, fall through to slow path to get proper file ID
+                if result.st_ino != 0 || result.st_ino_high != 0 {
+                    result.update_st_mode_from_path(path, stat_info.FileAttributes);
+                    return Ok(result);
+                }
+            }
+        }
+        Err(e) => {
+            if let Some(errno) = e.raw_os_error()
+                && matches!(
+                    errno as u32,
+                    Foundation::ERROR_FILE_NOT_FOUND
+                        | Foundation::ERROR_PATH_NOT_FOUND
+                        | Foundation::ERROR_NOT_READY
+                        | Foundation::ERROR_BAD_NET_NAME
+                )
+            {
+                return Err(e);
+            }
+        }
+    }
+
+    // Fallback to slow implementation
+    win32_xstat_slow_impl(path, traverse)
+}
diff --git a/crates/wasm/.cargo/config.toml b/crates/wasm/.cargo/config.toml
new file mode 100644
index 0000000000..f4e8c002fc
--- /dev/null
+++ b/crates/wasm/.cargo/config.toml
@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-unknown-unknown"
diff --git a/crates/wasm/Cargo.toml b/crates/wasm/Cargo.toml
new file mode 100644
index 0000000000..a2bb1a9f94
--- /dev/null
+++ b/crates/wasm/Cargo.toml
@@ -0,0 +1,50 @@
+[package]
+name = "rustpython_wasm"
+description = "A Python-3 (CPython >= 3.5.0) Interpreter written in Rust, compiled to WASM"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["freeze-stdlib"]
+freeze-stdlib = ["rustpython-vm/freeze-stdlib", "rustpython-pylib/freeze-stdlib", "rustpython-stdlib"]
+no-start-func = []
+
+[dependencies]
+rustpython-common = { workspace = true }
+rustpython-pylib = { workspace = true, optional = true }
+rustpython-stdlib = { workspace = true, default-features = false, optional = true }
+# 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 }
+
+console_error_panic_hook = "0.1"
+js-sys = "0.3"
+serde-wasm-bindgen = "0.6.5"
+wasm-bindgen-futures = "0.4"
+web-sys = { version = "0.3", features = [
+    "console",
+    "Document",
+    "Element",
+    "Window",
+    "Headers",
+    "Request",
+    "RequestInit",
+    "Response"
+] }
+
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false#["-O1"]
+
+[lints]
+workspace = true
diff --git a/wasm/lib/Lib/_microdistlib.py b/crates/wasm/Lib/_microdistlib.py
similarity index 100%
rename from wasm/lib/Lib/_microdistlib.py
rename to crates/wasm/Lib/_microdistlib.py
diff --git a/wasm/lib/Lib/asyncweb.py b/crates/wasm/Lib/asyncweb.py
similarity index 100%
rename from wasm/lib/Lib/asyncweb.py
rename to crates/wasm/Lib/asyncweb.py
diff --git a/wasm/lib/Lib/browser.py b/crates/wasm/Lib/browser.py
similarity index 100%
rename from wasm/lib/Lib/browser.py
rename to crates/wasm/Lib/browser.py
diff --git a/wasm/lib/Lib/whlimport.py b/crates/wasm/Lib/whlimport.py
similarity index 100%
rename from wasm/lib/Lib/whlimport.py
rename to crates/wasm/Lib/whlimport.py
diff --git a/wasm/lib/README.md b/crates/wasm/README.md
similarity index 100%
rename from wasm/lib/README.md
rename to crates/wasm/README.md
diff --git a/wasm/lib/src/browser_module.rs b/crates/wasm/src/browser_module.rs
similarity index 99%
rename from wasm/lib/src/browser_module.rs
rename to crates/wasm/src/browser_module.rs
index 0b978a4b56..9b6219cab6 100644
--- a/wasm/lib/src/browser_module.rs
+++ b/crates/wasm/src/browser_module.rs
@@ -117,7 +117,8 @@ mod _browser {
 
     #[pyfunction]
     fn request_animation_frame(func: ArgCallable, vm: &VirtualMachine) -> PyResult {
-        use std::{cell::RefCell, rc::Rc};
+        use alloc::rc::Rc;
+        use core::cell::RefCell;
 
         // this basic setup for request_animation_frame taken from:
         // https://rustwasm.github.io/wasm-bindgen/examples/request-animation-frame.html
diff --git a/crates/wasm/src/convert.rs b/crates/wasm/src/convert.rs
new file mode 100644
index 0000000000..f84b0d4623
--- /dev/null
+++ b/crates/wasm/src/convert.rs
@@ -0,0 +1,281 @@
+#![allow(clippy::empty_docs)] // TODO: remove it later. false positive by wasm-bindgen generated code
+
+use crate::js_module;
+use crate::vm_class::{WASMVirtualMachine, stored_vm_from_wasm};
+use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Array};
+use rustpython_vm::{
+    AsObject, Py, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
+    builtins::{PyBaseException, PyBaseExceptionRef},
+    compiler::{CompileError, ParseError, parser::LexicalErrorType, parser::ParseErrorType},
+    exceptions,
+    function::{ArgBytesLike, FuncArgs},
+    py_serde,
+};
+use wasm_bindgen::{JsCast, closure::Closure, prelude::*};
+
+#[wasm_bindgen(inline_js = r"
+export class PyError extends Error {
+    constructor(info) {
+        const msg = info.args[0];
+        if (typeof msg === 'string') super(msg);
+        else super();
+        this.info = info;
+    }
+    get name() { return this.info.exc_type; }
+    get traceback() { return this.info.traceback; }
+    toString() { return this.info.rendered; }
+}
+")]
+extern "C" {
+    pub type PyError;
+    #[wasm_bindgen(constructor)]
+    fn new(info: JsValue) -> PyError;
+}
+
+pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &Py<PyBaseException>) -> JsValue {
+    let js_err = vm.try_class("_js", "JSError").ok();
+    let js_arg = if js_err.is_some_and(|js_err| py_err.fast_isinstance(&js_err)) {
+        py_err.get_arg(0)
+    } else {
+        None
+    };
+    let js_arg = js_arg
+        .as_ref()
+        .and_then(|x| x.downcast_ref::<js_module::PyJsValue>());
+    match js_arg {
+        Some(val) => val.value.clone(),
+        None => {
+            let res =
+                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(),
+            }
+        }
+    }
+}
+
+pub fn js_py_typeerror(vm: &VirtualMachine, js_err: JsValue) -> PyBaseExceptionRef {
+    let msg = js_err.unchecked_into::<js_sys::Error>().to_string();
+    vm.new_type_error(msg)
+}
+
+pub fn js_err_to_py_err(vm: &VirtualMachine, js_err: &JsValue) -> PyBaseExceptionRef {
+    match js_err.dyn_ref::<js_sys::Error>() {
+        Some(err) => {
+            let exc_type = match String::from(err.name()).as_str() {
+                "TypeError" => vm.ctx.exceptions.type_error,
+                "ReferenceError" => vm.ctx.exceptions.name_error,
+                "SyntaxError" => vm.ctx.exceptions.syntax_error,
+                _ => vm.ctx.exceptions.exception_type,
+            }
+            .to_owned();
+            vm.new_exception_msg(exc_type, err.message().into())
+        }
+        None => vm.new_exception_msg(
+            vm.ctx.exceptions.exception_type.to_owned(),
+            format!("{js_err:?}"),
+        ),
+    }
+}
+
+pub fn py_to_js(vm: &VirtualMachine, py_obj: PyObjectRef) -> JsValue {
+    if let Some(ref wasm_id) = vm.wasm_id
+        && py_obj.fast_isinstance(vm.ctx.types.function_type)
+    {
+        let wasm_vm = WASMVirtualMachine {
+            id: wasm_id.clone(),
+        };
+        let weak_py_obj = wasm_vm.push_held_rc(py_obj).unwrap().unwrap();
+
+        let closure = move |args: Option<Box<[JsValue]>>,
+                            kwargs: Option<Object>|
+              -> Result<JsValue, JsValue> {
+            let py_obj = match wasm_vm.assert_valid() {
+                Ok(_) => weak_py_obj
+                    .upgrade()
+                    .expect("weak_py_obj to be valid if VM is valid"),
+                Err(err) => {
+                    return Err(err);
+                }
+            };
+            stored_vm_from_wasm(&wasm_vm).interp.enter(move |vm| {
+                let args = match args {
+                    Some(args) => Vec::from(args)
+                        .into_iter()
+                        .map(|arg| js_to_py(vm, arg))
+                        .collect::<Vec<_>>(),
+                    None => Vec::new(),
+                };
+                let mut py_func_args = FuncArgs::from(args);
+                if let Some(ref kwargs) = kwargs {
+                    for pair in object_entries(kwargs) {
+                        let (key, val) = pair?;
+                        py_func_args
+                            .kwargs
+                            .insert(js_sys::JsString::from(key).into(), js_to_py(vm, val));
+                    }
+                }
+                let result = py_obj.call(py_func_args, vm);
+                pyresult_to_js_result(vm, result)
+            })
+        };
+        let closure = Closure::wrap(Box::new(closure)
+            as Box<
+                dyn FnMut(Option<Box<[JsValue]>>, Option<Object>) -> Result<JsValue, JsValue>,
+            >);
+        let func = closure.as_ref().clone();
+
+        // stores pretty much nothing, it's fine to leak this because if it gets dropped
+        // the error message is worse
+        closure.forget();
+
+        return func;
+    }
+    // the browser module might not be injected
+    if vm.try_class("_js", "Promise").is_ok()
+        && let Some(py_prom) = py_obj.downcast_ref::<js_module::PyPromise>()
+    {
+        return py_prom.as_js(vm).into();
+    }
+
+    if let Ok(bytes) = ArgBytesLike::try_from_borrowed_object(vm, &py_obj) {
+        bytes.with_ref(|bytes| unsafe {
+            // `Uint8Array::view` is an `unsafe fn` because it provides
+            // a direct view into the WASM linear memory; if you were to allocate
+            // something with Rust that view would probably become invalid. It's safe
+            // because we then copy the array using `Uint8Array::slice`.
+            let view = Uint8Array::view(bytes);
+            view.slice(0, bytes.len() as u32).into()
+        })
+    } else {
+        py_serde::serialize(vm, &py_obj, &serde_wasm_bindgen::Serializer::new())
+            .unwrap_or(JsValue::UNDEFINED)
+    }
+}
+
+pub fn object_entries(obj: &Object) -> impl Iterator<Item = Result<(JsValue, JsValue), JsValue>> {
+    Object::entries(obj).values().into_iter().map(|pair| {
+        pair.map(|pair| {
+            let key = Reflect::get(&pair, &"0".into()).unwrap();
+            let val = Reflect::get(&pair, &"1".into()).unwrap();
+            (key, val)
+        })
+    })
+}
+
+pub fn pyresult_to_js_result(vm: &VirtualMachine, result: PyResult) -> Result<JsValue, JsValue> {
+    result
+        .map(|value| py_to_js(vm, value))
+        .map_err(|err| py_err_to_js_err(vm, &err))
+}
+
+pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
+    if js_val.is_object() {
+        if let Some(promise) = js_val.dyn_ref::<Promise>() {
+            // the browser module might not be injected
+            if vm.try_class("browser", "Promise").is_ok() {
+                return js_module::PyPromise::new(promise.clone())
+                    .into_ref(&vm.ctx)
+                    .into();
+            }
+        }
+        if Array::is_array(&js_val) {
+            let js_arr: Array = js_val.into();
+            let elems = js_arr
+                .values()
+                .into_iter()
+                .map(|val| js_to_py(vm, val.expect("Iteration over array failed")))
+                .collect();
+            vm.ctx.new_list(elems).into()
+        } else if ArrayBuffer::is_view(&js_val) || js_val.is_instance_of::<ArrayBuffer>() {
+            // unchecked_ref because if it's not an ArrayBuffer it could either be a TypedArray
+            // or a DataView, but they all have a `buffer` property
+            let u8_array = js_sys::Uint8Array::new(
+                &js_val
+                    .dyn_ref::<ArrayBuffer>()
+                    .cloned()
+                    .unwrap_or_else(|| js_val.unchecked_ref::<Uint8Array>().buffer()),
+            );
+            let mut vec = vec![0; u8_array.length() as usize];
+            u8_array.copy_to(&mut vec);
+            vm.ctx.new_bytes(vec).into()
+        } else {
+            let dict = vm.ctx.new_dict();
+            for pair in object_entries(&Object::from(js_val)) {
+                let (key, val) = pair.expect("iteration over object to not fail");
+                let py_val = js_to_py(vm, val);
+                dict.set_item(
+                    String::from(js_sys::JsString::from(key)).as_str(),
+                    py_val,
+                    vm,
+                )
+                .unwrap();
+            }
+            dict.into()
+        }
+    } else if js_val.is_function() {
+        let func = js_sys::Function::from(js_val);
+        vm.new_function(
+            vm.ctx.intern_str(String::from(func.name())).as_str(),
+            move |args: FuncArgs, vm: &VirtualMachine| -> PyResult {
+                let this = Object::new();
+                for (k, v) in args.kwargs {
+                    Reflect::set(&this, &k.into(), &py_to_js(vm, v))
+                        .expect("property to be settable");
+                }
+                let js_args = args
+                    .args
+                    .into_iter()
+                    .map(|v| py_to_js(vm, v))
+                    .collect::<Array>();
+                func.apply(&this, &js_args)
+                    .map(|val| js_to_py(vm, val))
+                    .map_err(|err| js_err_to_py_err(vm, &err))
+            },
+        )
+        .into()
+    } else if let Some(err) = js_val.dyn_ref::<js_sys::Error>() {
+        js_err_to_py_err(vm, err).into()
+    } else if js_val.is_undefined() {
+        // Because `JSON.stringify(undefined)` returns undefined
+        vm.ctx.none()
+    } else {
+        py_serde::deserialize(vm, serde_wasm_bindgen::Deserializer::from(js_val))
+            .unwrap_or_else(|_| vm.ctx.none())
+    }
+}
+
+pub fn syntax_err(err: CompileError) -> SyntaxError {
+    let js_err = SyntaxError::new(&format!("Error parsing Python code: {err}"));
+    let _ = Reflect::set(
+        &js_err,
+        &"row".into(),
+        &(err.location().unwrap().line.get()).into(),
+    );
+    let _ = Reflect::set(
+        &js_err,
+        &"col".into(),
+        &(err.location().unwrap().character_offset.get()).into(),
+    );
+    // | ParseErrorType::UnrecognizedToken(Token::Dedent, _)
+    let can_continue = matches!(
+        &err,
+        CompileError::Parse(ParseError {
+            error: ParseErrorType::Lexical(LexicalErrorType::Eof)
+                | ParseErrorType::Lexical(LexicalErrorType::IndentationError),
+            ..
+        })
+    );
+    let _ = Reflect::set(&js_err, &"canContinue".into(), &can_continue.into());
+    js_err
+}
+
+pub trait PyResultExt<T> {
+    fn into_js(self, vm: &VirtualMachine) -> Result<T, JsValue>;
+}
+impl<T> PyResultExt<T> for PyResult<T> {
+    fn into_js(self, vm: &VirtualMachine) -> Result<T, JsValue> {
+        self.map_err(|err| py_err_to_js_err(vm, &err))
+    }
+}
diff --git a/wasm/lib/src/js_module.rs b/crates/wasm/src/js_module.rs
similarity index 99%
rename from wasm/lib/src/js_module.rs
rename to crates/wasm/src/js_module.rs
index 1d8ca0961c..11d23bdf6d 100644
--- a/wasm/lib/src/js_module.rs
+++ b/crates/wasm/src/js_module.rs
@@ -8,6 +8,7 @@ mod _js {
         vm_class::{WASMVirtualMachine, stored_vm_from_wasm},
         weak_vm,
     };
+    use core::{cell, fmt, future};
     use js_sys::{Array, Object, Promise, Reflect};
     use rustpython_vm::{
         Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
@@ -17,7 +18,6 @@ mod _js {
         protocol::PyIterReturn,
         types::{IterNext, Representable, SelfIter},
     };
-    use std::{cell, fmt, future};
     use wasm_bindgen::{JsCast, closure::Closure, prelude::*};
     use wasm_bindgen_futures::{JsFuture, future_to_promise};
 
@@ -612,8 +612,7 @@ mod _js {
     fn js_error(vm: &VirtualMachine) -> PyTypeRef {
         let ctx = &vm.ctx;
         let js_error = PyRef::leak(
-            PyType::new_simple_heap("JSError", &vm.ctx.exceptions.exception_type.to_owned(), ctx)
-                .unwrap(),
+            PyType::new_simple_heap("JSError", vm.ctx.exceptions.exception_type, ctx).unwrap(),
         );
         extend_class!(ctx, js_error, {
             "value" => ctx.new_readonly_getset("value", js_error, |exc: PyBaseExceptionRef| exc.get_arg(0)),
diff --git a/crates/wasm/src/lib.rs b/crates/wasm/src/lib.rs
new file mode 100644
index 0000000000..64595fd63a
--- /dev/null
+++ b/crates/wasm/src/lib.rs
@@ -0,0 +1,137 @@
+extern crate alloc;
+
+pub mod browser_module;
+pub mod convert;
+pub mod js_module;
+pub mod vm_class;
+pub mod wasm_builtins;
+
+#[macro_use]
+extern crate rustpython_vm;
+
+use js_sys::{Reflect, WebAssembly::RuntimeError};
+use std::panic;
+pub use vm_class::add_init_func;
+pub(crate) use vm_class::weak_vm;
+use wasm_bindgen::prelude::*;
+
+/// Sets error info on the window object, and prints the backtrace to console
+pub fn panic_hook(info: &panic::PanicHookInfo<'_>) {
+    // If something errors, just ignore it; we don't want to panic in the panic hook
+    let try_set_info = || {
+        let msg = &info.to_string();
+        let window = match web_sys::window() {
+            Some(win) => win,
+            None => return,
+        };
+        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR_MSG".into(), &msg.into());
+        let error = RuntimeError::new(msg);
+        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR".into(), &error);
+        let stack = match Reflect::get(&error, &"stack".into()) {
+            Ok(stack) => stack,
+            Err(_) => return,
+        };
+        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR_STACK".into(), &stack);
+    };
+    try_set_info();
+    console_error_panic_hook::hook(info);
+}
+
+#[doc(hidden)]
+#[cfg(not(feature = "no-start-func"))]
+#[wasm_bindgen(start)]
+pub fn _setup_console_error() {
+    std::panic::set_hook(Box::new(panic_hook));
+}
+
+pub mod eval {
+    use crate::vm_class::VMStore;
+    use js_sys::{Object, Reflect, TypeError};
+    use rustpython_vm::compiler::Mode;
+    use wasm_bindgen::prelude::*;
+
+    const PY_EVAL_VM_ID: &str = "__py_eval_vm";
+
+    fn run_py(source: &str, options: Option<Object>, mode: Mode) -> Result<JsValue, JsValue> {
+        let vm = VMStore::init(PY_EVAL_VM_ID.into(), Some(true));
+        let options = options.unwrap_or_default();
+        let js_vars = {
+            let prop = Reflect::get(&options, &"vars".into())?;
+            if prop.is_undefined() {
+                None
+            } else if prop.is_object() {
+                Some(Object::from(prop))
+            } else {
+                return Err(TypeError::new("vars must be an object").into());
+            }
+        };
+
+        vm.set_stdout(Reflect::get(&options, &"stdout".into())?)?;
+
+        if let Some(js_vars) = js_vars {
+            vm.add_to_scope("js_vars".into(), js_vars.into())?;
+        }
+        vm.run(source, mode, None)
+    }
+
+    /// Evaluate Python code
+    ///
+    /// ```js
+    /// var result = pyEval(code, options?);
+    /// ```
+    ///
+    /// `code`: `string`: The Python code to run in eval mode
+    ///
+    /// `options`:
+    ///
+    /// -   `vars?`: `{ [key: string]: any }`: Variables passed to the VM that can be
+    ///     accessed in Python with the variable `js_vars`. Functions do work, and
+    ///     receive the Python kwargs as the `this` argument.
+    /// -   `stdout?`: `"console" | ((out: string) => void) | null`: A function to replace the
+    ///     native print native print function, and it will be `console.log` when giving
+    ///     `undefined` or "console", and it will be a dumb function when giving null.
+    #[wasm_bindgen(js_name = pyEval)]
+    pub fn eval_py(source: &str, options: Option<Object>) -> Result<JsValue, JsValue> {
+        run_py(source, options, Mode::Eval)
+    }
+
+    /// Evaluate Python code
+    ///
+    /// ```js
+    /// pyExec(code, options?);
+    /// ```
+    ///
+    /// `code`: `string`: The Python code to run in exec mode
+    ///
+    /// `options`: The options are the same as eval mode
+    #[wasm_bindgen(js_name = pyExec)]
+    pub fn exec_py(source: &str, options: Option<Object>) -> Result<(), JsValue> {
+        run_py(source, options, Mode::Exec).map(drop)
+    }
+
+    /// Evaluate Python code
+    ///
+    /// ```js
+    /// var result = pyExecSingle(code, options?);
+    /// ```
+    ///
+    /// `code`: `string`: The Python code to run in exec single mode
+    ///
+    /// `options`: The options are the same as eval mode
+    #[wasm_bindgen(js_name = pyExecSingle)]
+    pub fn exec_single_py(source: &str, options: Option<Object>) -> Result<JsValue, JsValue> {
+        run_py(source, options, Mode::Single)
+    }
+}
+
+/// A module containing all the wasm-bindgen exports that rustpython_wasm has
+/// Re-export as `pub use rustpython_wasm::exports::*;` in the root of your crate if you want your
+/// wasm module to mimic rustpython_wasm's API
+pub mod exports {
+    pub use crate::convert::PyError;
+    pub use crate::eval::{eval_py, exec_py, exec_single_py};
+    pub use crate::vm_class::{VMStore, WASMVirtualMachine};
+}
+
+#[doc(hidden)]
+pub use exports::*;
diff --git a/wasm/lib/src/vm_class.rs b/crates/wasm/src/vm_class.rs
similarity index 87%
rename from wasm/lib/src/vm_class.rs
rename to crates/wasm/src/vm_class.rs
index bbd895c989..0339a47821 100644
--- a/wasm/lib/src/vm_class.rs
+++ b/crates/wasm/src/vm_class.rs
@@ -3,6 +3,8 @@ use crate::{
     convert::{self, PyResultExt},
     js_module, wasm_builtins,
 };
+use alloc::rc::{Rc, Weak};
+use core::cell::RefCell;
 use js_sys::{Object, TypeError};
 use rustpython_vm::{
     Interpreter, PyObjectRef, PyPayload, PyRef, PyResult, Settings, VirtualMachine,
@@ -10,11 +12,7 @@ use rustpython_vm::{
     compiler::Mode,
     scope::Scope,
 };
-use std::{
-    cell::RefCell,
-    collections::HashMap,
-    rc::{Rc, Weak},
-};
+use std::collections::HashMap;
 use wasm_bindgen::prelude::*;
 
 pub(crate) struct StoredVirtualMachine {
@@ -58,8 +56,8 @@ impl StoredVirtualMachine {
                 setup_browser_module(vm);
             }
 
-            VM_INIT_FUNCS.with(|cell| {
-                for f in cell.borrow().iter() {
+            VM_INIT_FUNCS.with_borrow(|funcs| {
+                for f in funcs {
                     f(vm)
                 }
             });
@@ -78,7 +76,7 @@ impl StoredVirtualMachine {
 /// Add a hook to add builtins or frozen modules to the RustPython VirtualMachine while it's
 /// initializing.
 pub fn add_init_func(f: fn(&mut VirtualMachine)) {
-    VM_INIT_FUNCS.with(|cell| cell.borrow_mut().push(f))
+    VM_INIT_FUNCS.with_borrow_mut(|funcs| funcs.push(f))
 }
 
 // It's fine that it's thread local, since WASM doesn't even have threads yet. thread_local!
@@ -97,17 +95,15 @@ pub fn get_vm_id(vm: &VirtualMachine) -> &str {
         .expect("VirtualMachine inside of WASM crate should have wasm_id set")
 }
 pub(crate) fn stored_vm_from_wasm(wasm_vm: &WASMVirtualMachine) -> Rc<StoredVirtualMachine> {
-    STORED_VMS.with(|cell| {
-        cell.borrow()
-            .get(&wasm_vm.id)
+    STORED_VMS.with_borrow(|vms| {
+        vms.get(&wasm_vm.id)
             .expect("VirtualMachine is not valid")
             .clone()
     })
 }
 pub(crate) fn weak_vm(vm: &VirtualMachine) -> Weak<StoredVirtualMachine> {
     let id = get_vm_id(vm);
-    STORED_VMS
-        .with(|cell| Rc::downgrade(cell.borrow().get(id).expect("VirtualMachine is not valid")))
+    STORED_VMS.with_borrow(|vms| Rc::downgrade(vms.get(id).expect("VirtualMachine is not valid")))
 }
 
 #[wasm_bindgen(js_name = vmStore)]
@@ -116,8 +112,7 @@ pub struct VMStore;
 #[wasm_bindgen(js_class = vmStore)]
 impl VMStore {
     pub fn init(id: String, inject_browser_module: Option<bool>) -> WASMVirtualMachine {
-        STORED_VMS.with(|cell| {
-            let mut vms = cell.borrow_mut();
+        STORED_VMS.with_borrow_mut(|vms| {
             if !vms.contains_key(&id) {
                 let stored_vm =
                     StoredVirtualMachine::new(id.clone(), inject_browser_module.unwrap_or(true));
@@ -128,14 +123,7 @@ impl VMStore {
     }
 
     pub(crate) fn _get(id: String) -> Option<WASMVirtualMachine> {
-        STORED_VMS.with(|cell| {
-            let vms = cell.borrow();
-            if vms.contains_key(&id) {
-                Some(WASMVirtualMachine { id })
-            } else {
-                None
-            }
-        })
+        STORED_VMS.with_borrow(|vms| vms.contains_key(&id).then_some(WASMVirtualMachine { id }))
     }
 
     pub fn get(id: String) -> JsValue {
@@ -146,24 +134,19 @@ impl VMStore {
     }
 
     pub fn destroy(id: String) {
-        STORED_VMS.with(|cell| {
-            use std::collections::hash_map::Entry;
-            match cell.borrow_mut().entry(id) {
-                Entry::Occupied(o) => {
-                    let (_k, stored_vm) = o.remove_entry();
-                    // for f in stored_vm.drop_handlers.iter() {
-                    //     f();
-                    // }
-                    // deallocate the VM
-                    drop(stored_vm);
-                }
-                Entry::Vacant(_v) => {}
+        STORED_VMS.with_borrow_mut(|vms| {
+            if let Some(stored_vm) = vms.remove(&id) {
+                // for f in stored_vm.drop_handlers.iter() {
+                //     f();
+                // }
+                // deallocate the VM
+                drop(stored_vm);
             }
         });
     }
 
     pub fn ids() -> Vec<JsValue> {
-        STORED_VMS.with(|cell| cell.borrow().keys().map(|k| k.into()).collect())
+        STORED_VMS.with_borrow(|vms| vms.keys().map(|k| k.into()).collect())
     }
 }
 
@@ -179,10 +162,7 @@ impl WASMVirtualMachine {
     where
         F: FnOnce(&StoredVirtualMachine) -> R,
     {
-        let stored_vm = STORED_VMS.with(|cell| {
-            let mut vms = cell.borrow_mut();
-            vms.get_mut(&self.id).unwrap().clone()
-        });
+        let stored_vm = STORED_VMS.with_borrow_mut(|vms| vms.get_mut(&self.id).unwrap().clone());
         f(&stored_vm)
     }
 
@@ -202,7 +182,7 @@ impl WASMVirtualMachine {
     }
 
     pub fn valid(&self) -> bool {
-        STORED_VMS.with(|cell| cell.borrow().contains_key(&self.id))
+        STORED_VMS.with_borrow(|vms| vms.contains_key(&self.id))
     }
 
     pub(crate) fn push_held_rc(
diff --git a/wasm/lib/src/wasm_builtins.rs b/crates/wasm/src/wasm_builtins.rs
similarity index 100%
rename from wasm/lib/src/wasm_builtins.rs
rename to crates/wasm/src/wasm_builtins.rs
diff --git a/wtf8/Cargo.toml b/crates/wtf8/Cargo.toml
similarity index 100%
rename from wtf8/Cargo.toml
rename to crates/wtf8/Cargo.toml
diff --git a/wtf8/src/core_char.rs b/crates/wtf8/src/core_char.rs
similarity index 100%
rename from wtf8/src/core_char.rs
rename to crates/wtf8/src/core_char.rs
diff --git a/wtf8/src/core_str.rs b/crates/wtf8/src/core_str.rs
similarity index 100%
rename from wtf8/src/core_str.rs
rename to crates/wtf8/src/core_str.rs
diff --git a/wtf8/src/core_str_count.rs b/crates/wtf8/src/core_str_count.rs
similarity index 98%
rename from wtf8/src/core_str_count.rs
rename to crates/wtf8/src/core_str_count.rs
index 9bc2d8d5b8..f02f0a5708 100644
--- a/wtf8/src/core_str_count.rs
+++ b/crates/wtf8/src/core_str_count.rs
@@ -35,7 +35,7 @@ fn do_count_chars(s: &Wtf8) -> usize {
     // Check the properties of `CHUNK_SIZE` and `UNROLL_INNER` that are required
     // for correctness.
     const _: () = assert!(CHUNK_SIZE < 256);
-    const _: () = assert!(CHUNK_SIZE % UNROLL_INNER == 0);
+    const _: () = assert!(CHUNK_SIZE.is_multiple_of(UNROLL_INNER));
 
     // SAFETY: transmuting `[u8]` to `[usize]` is safe except for size
     // differences which are handled by `align_to`.
diff --git a/wtf8/src/lib.rs b/crates/wtf8/src/lib.rs
similarity index 100%
rename from wtf8/src/lib.rs
rename to crates/wtf8/src/lib.rs
diff --git a/crawl_sourcecode.py b/crawl_sourcecode.py
index a96ec283fa..30e01d0445 100644
--- a/crawl_sourcecode.py
+++ b/crawl_sourcecode.py
@@ -9,9 +9,9 @@
 """
 
 import ast
-import sys
-import symtable
 import dis
+import symtable
+import sys
 
 filename = sys.argv[1]
 print("Crawling file:", filename)
diff --git a/derive-impl/Cargo.toml b/derive-impl/Cargo.toml
deleted file mode 100644
index 66ed67cef8..0000000000
--- a/derive-impl/Cargo.toml
+++ /dev/null
@@ -1,26 +0,0 @@
-[package]
-name = "rustpython-derive-impl"
-description = "Rust language extensions and macros specific to rustpython."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[dependencies]
-rustpython-compiler-core = { workspace = true }
-# rustpython-parser-core = { workspace = true }
-rustpython-doc = { workspace = true }
-
-itertools = { workspace = true }
-syn = { workspace = true, features = ["full", "extra-traits"] }
-
-maplit = "1.0.2"
-proc-macro2 = { workspace = true }
-quote = { workspace = true }
-syn-ext = { version = "0.5.0", features = ["full"] }
-textwrap = { version = "0.16.1", default-features = false }
-
-[lints]
-workspace = true
\ No newline at end of file
diff --git a/derive-impl/src/from_args.rs b/derive-impl/src/from_args.rs
deleted file mode 100644
index 8339be5df6..0000000000
--- a/derive-impl/src/from_args.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::{ToTokens, quote};
-use syn::ext::IdentExt;
-use syn::meta::ParseNestedMeta;
-use syn::{Attribute, Data, DeriveInput, Expr, Field, Ident, Result, Token, parse_quote};
-
-/// The kind of the python parameter, this corresponds to the value of Parameter.kind
-/// (https://docs.python.org/3/library/inspect.html#inspect.Parameter.kind)
-enum ParameterKind {
-    PositionalOnly,
-    PositionalOrKeyword,
-    KeywordOnly,
-    Flatten,
-}
-
-impl ParameterKind {
-    fn from_ident(ident: &Ident) -> Option<Self> {
-        match ident.to_string().as_str() {
-            "positional" => Some(Self::PositionalOnly),
-            "any" => Some(Self::PositionalOrKeyword),
-            "named" => Some(Self::KeywordOnly),
-            "flatten" => Some(Self::Flatten),
-            _ => None,
-        }
-    }
-}
-
-struct ArgAttribute {
-    name: Option<String>,
-    kind: ParameterKind,
-    default: Option<DefaultValue>,
-}
-// None == quote!(Default::default())
-type DefaultValue = Option<Expr>;
-
-impl ArgAttribute {
-    fn from_attribute(attr: &Attribute) -> Option<Result<Self>> {
-        if !attr.path().is_ident("pyarg") {
-            return None;
-        }
-        let inner = move || {
-            let mut arg_attr = None;
-            attr.parse_nested_meta(|meta| {
-                let Some(arg_attr) = &mut arg_attr else {
-                    let kind = meta
-                        .path
-                        .get_ident()
-                        .and_then(ParameterKind::from_ident)
-                        .ok_or_else(|| {
-                            meta.error(
-                                "The first argument to #[pyarg()] must be the parameter type, \
-                                 either 'positional', 'any', 'named', or 'flatten'.",
-                            )
-                        })?;
-                    arg_attr = Some(Self {
-                        name: None,
-                        kind,
-                        default: None,
-                    });
-                    return Ok(());
-                };
-                arg_attr.parse_argument(meta)
-            })?;
-            arg_attr
-                .ok_or_else(|| err_span!(attr, "There must be at least one argument to #[pyarg()]"))
-        };
-        Some(inner())
-    }
-
-    fn parse_argument(&mut self, meta: ParseNestedMeta<'_>) -> Result<()> {
-        if let ParameterKind::Flatten = self.kind {
-            return Err(meta.error("can't put additional arguments on a flatten arg"));
-        }
-        if meta.path.is_ident("default") && meta.input.peek(Token![=]) {
-            if matches!(self.default, Some(Some(_))) {
-                return Err(meta.error("Default already set"));
-            }
-            let val = meta.value()?;
-            self.default = Some(Some(val.parse()?))
-        } else if meta.path.is_ident("default") || meta.path.is_ident("optional") {
-            if self.default.is_none() {
-                self.default = Some(None);
-            }
-        } else if meta.path.is_ident("name") {
-            if self.name.is_some() {
-                return Err(meta.error("already have a name"));
-            }
-            let val = meta.value()?.parse::<syn::LitStr>()?;
-            self.name = Some(val.value())
-        } else {
-            return Err(meta.error("Unrecognized pyarg attribute"));
-        }
-
-        Ok(())
-    }
-}
-
-fn generate_field((i, field): (usize, &Field)) -> Result<TokenStream> {
-    let mut pyarg_attrs = field
-        .attrs
-        .iter()
-        .filter_map(ArgAttribute::from_attribute)
-        .collect::<std::result::Result<Vec<_>, _>>()?;
-    let attr = if pyarg_attrs.is_empty() {
-        ArgAttribute {
-            name: None,
-            kind: ParameterKind::PositionalOrKeyword,
-            default: None,
-        }
-    } else if pyarg_attrs.len() == 1 {
-        pyarg_attrs.remove(0)
-    } else {
-        bail_span!(field, "Multiple pyarg attributes on field");
-    };
-
-    let name = field.ident.as_ref();
-    let name_string = name.map(|ident| ident.unraw().to_string());
-    if matches!(&name_string, Some(s) if s.starts_with("_phantom")) {
-        return Ok(quote! {
-            #name: ::std::marker::PhantomData,
-        });
-    }
-    let field_name = match name {
-        Some(id) => id.to_token_stream(),
-        None => syn::Index::from(i).into_token_stream(),
-    };
-    if let ParameterKind::Flatten = attr.kind {
-        return Ok(quote! {
-            #field_name: ::rustpython_vm::function::FromArgs::from_args(vm, args)?,
-        });
-    }
-    let pyname = attr
-        .name
-        .or(name_string)
-        .ok_or_else(|| err_span!(field, "field in tuple struct must have name attribute"))?;
-    let middle = quote! {
-        .map(|x| ::rustpython_vm::convert::TryFromObject::try_from_object(vm, x)).transpose()?
-    };
-    let ending = if let Some(default) = attr.default {
-        let ty = &field.ty;
-        let default = default.unwrap_or_else(|| parse_quote!(::std::default::Default::default()));
-        quote! {
-            .map(<#ty as ::rustpython_vm::function::FromArgOptional>::from_inner)
-            .unwrap_or_else(|| #default)
-        }
-    } else {
-        let err = match attr.kind {
-            ParameterKind::PositionalOnly | ParameterKind::PositionalOrKeyword => quote! {
-                ::rustpython_vm::function::ArgumentError::TooFewArgs
-            },
-            ParameterKind::KeywordOnly => quote! {
-                ::rustpython_vm::function::ArgumentError::RequiredKeywordArgument(#pyname.to_owned())
-            },
-            ParameterKind::Flatten => unreachable!(),
-        };
-        quote! {
-            .ok_or_else(|| #err)?
-        }
-    };
-
-    let file_output = match attr.kind {
-        ParameterKind::PositionalOnly => {
-            quote! {
-                #field_name: args.take_positional()#middle #ending,
-            }
-        }
-        ParameterKind::PositionalOrKeyword => {
-            quote! {
-                #field_name: args.take_positional_keyword(#pyname)#middle #ending,
-            }
-        }
-        ParameterKind::KeywordOnly => {
-            quote! {
-                #field_name: args.take_keyword(#pyname)#middle #ending,
-            }
-        }
-        ParameterKind::Flatten => unreachable!(),
-    };
-    Ok(file_output)
-}
-
-pub fn impl_from_args(input: DeriveInput) -> Result<TokenStream> {
-    let fields = match input.data {
-        Data::Struct(syn::DataStruct { fields, .. }) => fields
-            .iter()
-            .enumerate()
-            .map(generate_field)
-            .collect::<Result<TokenStream>>()?,
-        _ => bail_span!(input, "FromArgs input must be a struct"),
-    };
-
-    let name = input.ident;
-    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-    let output = quote! {
-        impl #impl_generics ::rustpython_vm::function::FromArgs for #name #ty_generics #where_clause {
-            fn from_args(
-                vm: &::rustpython_vm::VirtualMachine,
-                args: &mut ::rustpython_vm::function::FuncArgs
-            ) -> ::std::result::Result<Self, ::rustpython_vm::function::ArgumentError> {
-                Ok(#name { #fields })
-            }
-        }
-    };
-    Ok(output)
-}
diff --git a/derive-impl/src/lib.rs b/derive-impl/src/lib.rs
deleted file mode 100644
index a1f97c96b0..0000000000
--- a/derive-impl/src/lib.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![recursion_limit = "128"]
-#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
-#![doc(html_root_url = "https://docs.rs/rustpython-derive/")]
-
-extern crate proc_macro;
-
-#[macro_use]
-extern crate maplit;
-
-#[macro_use]
-mod error;
-#[macro_use]
-mod util;
-
-mod compile_bytecode;
-mod from_args;
-mod pyclass;
-mod pymodule;
-mod pypayload;
-mod pystructseq;
-mod pytraverse;
-
-use error::Diagnostic;
-use proc_macro2::TokenStream;
-use quote::ToTokens;
-use rustpython_doc as doc;
-use syn::{DeriveInput, Item};
-use syn_ext::types::PunctuatedNestedMeta;
-
-pub use compile_bytecode::Compiler;
-
-fn result_to_tokens(result: Result<TokenStream, impl Into<Diagnostic>>) -> TokenStream {
-    result
-        .map_err(|e| e.into())
-        .unwrap_or_else(ToTokens::into_token_stream)
-}
-
-pub fn derive_from_args(input: DeriveInput) -> TokenStream {
-    result_to_tokens(from_args::impl_from_args(input))
-}
-
-pub fn pyclass(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
-    if matches!(item, syn::Item::Impl(_) | syn::Item::Trait(_)) {
-        result_to_tokens(pyclass::impl_pyclass_impl(attr, item))
-    } else {
-        result_to_tokens(pyclass::impl_pyclass(attr, item))
-    }
-}
-
-pub fn pyexception(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
-    if matches!(item, syn::Item::Impl(_)) {
-        result_to_tokens(pyclass::impl_pyexception_impl(attr, item))
-    } else {
-        result_to_tokens(pyclass::impl_pyexception(attr, item))
-    }
-}
-
-pub fn pymodule(attr: PunctuatedNestedMeta, item: Item) -> TokenStream {
-    result_to_tokens(pymodule::impl_pymodule(attr, item))
-}
-
-pub fn pystruct_sequence(input: DeriveInput) -> TokenStream {
-    result_to_tokens(pystructseq::impl_pystruct_sequence(input))
-}
-
-pub fn pystruct_sequence_try_from_object(input: DeriveInput) -> TokenStream {
-    result_to_tokens(pystructseq::impl_pystruct_sequence_try_from_object(input))
-}
-
-pub fn py_compile(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
-    result_to_tokens(compile_bytecode::impl_py_compile(input, compiler))
-}
-
-pub fn py_freeze(input: TokenStream, compiler: &dyn Compiler) -> TokenStream {
-    result_to_tokens(compile_bytecode::impl_py_freeze(input, compiler))
-}
-
-pub fn pypayload(input: DeriveInput) -> TokenStream {
-    result_to_tokens(pypayload::impl_pypayload(input))
-}
-
-pub fn pytraverse(item: DeriveInput) -> TokenStream {
-    result_to_tokens(pytraverse::impl_pytraverse(item))
-}
diff --git a/derive-impl/src/pyclass.rs b/derive-impl/src/pyclass.rs
deleted file mode 100644
index a17ac01e79..0000000000
--- a/derive-impl/src/pyclass.rs
+++ /dev/null
@@ -1,1678 +0,0 @@
-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,
-};
-use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
-use quote::{ToTokens, quote, quote_spanned};
-use std::collections::{HashMap, HashSet};
-use std::str::FromStr;
-use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
-use syn_ext::ext::*;
-use syn_ext::types::*;
-
-#[derive(Copy, Clone, Debug)]
-enum AttrName {
-    Method,
-    ClassMethod,
-    StaticMethod,
-    GetSet,
-    Slot,
-    Attr,
-    ExtendClass,
-    Member,
-}
-
-impl std::fmt::Display for AttrName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let s = match self {
-            Self::Method => "pymethod",
-            Self::ClassMethod => "pyclassmethod",
-            Self::StaticMethod => "pystaticmethod",
-            Self::GetSet => "pygetset",
-            Self::Slot => "pyslot",
-            Self::Attr => "pyattr",
-            Self::ExtendClass => "extend_class",
-            Self::Member => "pymember",
-        };
-        s.fmt(f)
-    }
-}
-
-impl FromStr for AttrName {
-    type Err = String;
-
-    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
-        Ok(match s {
-            "pymethod" => Self::Method,
-            "pyclassmethod" => Self::ClassMethod,
-            "pystaticmethod" => Self::StaticMethod,
-            "pygetset" => Self::GetSet,
-            "pyslot" => Self::Slot,
-            "pyattr" => Self::Attr,
-            "extend_class" => Self::ExtendClass,
-            "pymember" => Self::Member,
-            s => {
-                return Err(s.to_owned());
-            }
-        })
-    }
-}
-
-#[derive(Default)]
-struct ImplContext {
-    attribute_items: ItemNursery,
-    method_items: MethodNursery,
-    getset_items: GetSetNursery,
-    member_items: MemberNursery,
-    extend_slots_items: ItemNursery,
-    class_extensions: Vec<TokenStream>,
-    errors: Vec<syn::Error>,
-}
-
-fn extract_items_into_context<'a, Item>(
-    context: &mut ImplContext,
-    items: impl Iterator<Item = &'a mut Item>,
-) where
-    Item: ItemLike + ToTokens + GetIdent + syn_ext::ext::ItemAttrExt + 'a,
-{
-    for item in items {
-        let r = item.try_split_attr_mut(|attrs, item| {
-            let (py_items, cfgs) = attrs_to_content_items(attrs, impl_item_new::<Item>)?;
-            for py_item in py_items.iter().rev() {
-                let r = py_item.gen_impl_item(ImplItemArgs::<Item> {
-                    item,
-                    attrs,
-                    context,
-                    cfgs: cfgs.as_slice(),
-                });
-                context.errors.ok_or_push(r);
-            }
-            Ok(())
-        });
-        context.errors.ok_or_push(r);
-    }
-    context.errors.ok_or_push(context.method_items.validate());
-    context.errors.ok_or_push(context.getset_items.validate());
-    context.errors.ok_or_push(context.member_items.validate());
-}
-
-pub(crate) fn impl_pyclass_impl(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
-    let mut context = ImplContext::default();
-    let mut tokens = match item {
-        Item::Impl(mut imp) => {
-            extract_items_into_context(&mut context, imp.items.iter_mut());
-
-            let (impl_ty, payload_guess) = match imp.self_ty.as_ref() {
-                syn::Type::Path(syn::TypePath {
-                    path: syn::Path { segments, .. },
-                    ..
-                }) if segments.len() == 1 => {
-                    let segment = &segments[0];
-                    let payload_ty = if segment.ident == "Py" || segment.ident == "PyRef" {
-                        match &segment.arguments {
-                            syn::PathArguments::AngleBracketed(
-                                syn::AngleBracketedGenericArguments { args, .. },
-                            ) if args.len() == 1 => {
-                                let arg = &args[0];
-                                match arg {
-                                    syn::GenericArgument::Type(syn::Type::Path(
-                                        syn::TypePath {
-                                            path: syn::Path { segments, .. },
-                                            ..
-                                        },
-                                    )) if segments.len() == 1 => segments[0].ident.clone(),
-                                    _ => {
-                                        return Err(syn::Error::new_spanned(
-                                            segment,
-                                            "Py{Ref}<T> is expected but Py{Ref}<?> is found",
-                                        ));
-                                    }
-                                }
-                            }
-                            _ => {
-                                return Err(syn::Error::new_spanned(
-                                    segment,
-                                    "Py{Ref}<T> is expected but Py{Ref}? is found",
-                                ));
-                            }
-                        }
-                    } else {
-                        if !matches!(segment.arguments, syn::PathArguments::None) {
-                            return Err(syn::Error::new_spanned(
-                                segment,
-                                "PyImpl can only be implemented for Py{Ref}<T> or T",
-                            ));
-                        }
-                        segment.ident.clone()
-                    };
-                    (segment.ident.clone(), payload_ty)
-                }
-                _ => {
-                    return Err(syn::Error::new_spanned(
-                        imp.self_ty,
-                        "PyImpl can only be implemented for Py{Ref}<T> or T",
-                    ));
-                }
-            };
-
-            let ExtractedImplAttrs {
-                payload: attr_payload,
-                flags,
-                with_impl,
-                with_method_defs,
-                with_slots,
-            } = extract_impl_attrs(attr, &impl_ty)?;
-            let payload_ty = attr_payload.unwrap_or(payload_guess);
-            let method_def = &context.method_items;
-            let getset_impl = &context.getset_items;
-            let member_impl = &context.member_items;
-            let extend_impl = context.attribute_items.validate()?;
-            let slots_impl = context.extend_slots_items.validate()?;
-            let class_extensions = &context.class_extensions;
-
-            let extra_methods = [
-                parse_quote! {
-                    const __OWN_METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_def;
-                },
-                parse_quote! {
-                    fn __extend_py_class(
-                        ctx: &::rustpython_vm::Context,
-                        class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
-                    ) {
-                        #getset_impl
-                        #member_impl
-                        #extend_impl
-                        #(#class_extensions)*
-                    }
-                },
-                parse_quote! {
-                    fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
-                        #slots_impl
-                    }
-                },
-            ];
-            imp.items.extend(extra_methods);
-            let is_main_impl = impl_ty == payload_ty;
-            if is_main_impl {
-                let method_defs = if with_method_defs.is_empty() {
-                    quote!(#impl_ty::__OWN_METHOD_DEFS)
-                } else {
-                    quote!(
-                        rustpython_vm::function::PyMethodDef::__const_concat_arrays::<
-                            { #impl_ty::__OWN_METHOD_DEFS.len() #(+ #with_method_defs.len())* },
-                        >(&[#impl_ty::__OWN_METHOD_DEFS, #(#with_method_defs,)*])
-                    )
-                };
-                quote! {
-                    #imp
-                    impl ::rustpython_vm::class::PyClassImpl for #payload_ty {
-                        const TP_FLAGS: ::rustpython_vm::types::PyTypeFlags = #flags;
-
-                        fn impl_extend_class(
-                            ctx: &::rustpython_vm::Context,
-                            class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
-                        ) {
-                            #impl_ty::__extend_py_class(ctx, class);
-                            #with_impl
-                        }
-
-                        const METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_defs;
-
-                        fn extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
-                            #impl_ty::__extend_slots(slots);
-                            #with_slots
-                        }
-                    }
-                }
-            } else {
-                imp.into_token_stream()
-            }
-        }
-        Item::Trait(mut trai) => {
-            let mut context = ImplContext::default();
-            let mut has_extend_slots = false;
-            for item in &trai.items {
-                let has = match item {
-                    syn::TraitItem::Fn(item) => item.sig.ident == "extend_slots",
-                    _ => false,
-                };
-                if has {
-                    has_extend_slots = has;
-                    break;
-                }
-            }
-            extract_items_into_context(&mut context, trai.items.iter_mut());
-
-            let ExtractedImplAttrs {
-                with_impl,
-                with_slots,
-                ..
-            } = extract_impl_attrs(attr, &trai.ident)?;
-
-            let method_def = &context.method_items;
-            let getset_impl = &context.getset_items;
-            let member_impl = &context.member_items;
-            let extend_impl = &context.attribute_items.validate()?;
-            let slots_impl = &context.extend_slots_items.validate()?;
-            let class_extensions = &context.class_extensions;
-            let call_extend_slots = if has_extend_slots {
-                quote! {
-                    Self::extend_slots(slots);
-                }
-            } else {
-                quote! {}
-            };
-            let extra_methods = [
-                parse_quote! {
-                    const __OWN_METHOD_DEFS: &'static [::rustpython_vm::function::PyMethodDef] = &#method_def;
-                },
-                parse_quote! {
-                    fn __extend_py_class(
-                        ctx: &::rustpython_vm::Context,
-                        class: &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType>,
-                    ) {
-                        #getset_impl
-                        #member_impl
-                        #extend_impl
-                        #with_impl
-                        #(#class_extensions)*
-                    }
-                },
-                parse_quote! {
-                    fn __extend_slots(slots: &mut ::rustpython_vm::types::PyTypeSlots) {
-                        #with_slots
-                        #slots_impl
-                        #call_extend_slots
-                    }
-                },
-            ];
-            trai.items.extend(extra_methods);
-
-            trai.into_token_stream()
-        }
-        item => item.into_token_stream(),
-    };
-    if let Some(error) = context.errors.into_error() {
-        let error = Diagnostic::from(error);
-        tokens = quote! {
-            #tokens
-            #error
-        }
-    }
-    Ok(tokens)
-}
-
-fn generate_class_def(
-    ident: &Ident,
-    name: &str,
-    module_name: Option<&str>,
-    base: Option<String>,
-    metaclass: Option<String>,
-    unhashable: bool,
-    attrs: &[Attribute],
-) -> Result<TokenStream> {
-    let doc = attrs.doc().or_else(|| {
-        let module_name = module_name.unwrap_or("builtins");
-        crate::doc::Database::shared()
-            .try_module_item(module_name, name)
-            .ok()
-            .flatten()
-            .map(str::to_owned)
-    });
-    let doc = if let Some(doc) = doc {
-        quote!(Some(#doc))
-    } else {
-        quote!(None)
-    };
-    let module_class_name = if let Some(module_name) = module_name {
-        format!("{module_name}.{name}")
-    } else {
-        name.to_owned()
-    };
-    let module_name = match module_name {
-        Some(v) => quote!(Some(#v) ),
-        None => quote!(None),
-    };
-    let unhashable = if unhashable {
-        quote!(true)
-    } else {
-        quote!(false)
-    };
-    let basicsize = quote!(std::mem::size_of::<#ident>());
-    let is_pystruct = attrs.iter().any(|attr| {
-        attr.path().is_ident("derive")
-            && if let Ok(Meta::List(l)) = attr.parse_meta() {
-                l.nested
-                    .into_iter()
-                    .any(|n| n.get_ident().is_some_and(|p| p == "PyStructSequence"))
-            } else {
-                false
-            }
-    });
-    if base.is_some() && is_pystruct {
-        bail_span!(ident, "PyStructSequence cannot have `base` class attr",);
-    }
-    let base_class = if is_pystruct {
-        Some(quote! { rustpython_vm::builtins::PyTuple })
-    } else {
-        base.as_ref().map(|typ| {
-            let typ = Ident::new(typ, ident.span());
-            quote_spanned! { ident.span() => #typ }
-        })
-    }
-    .map(|typ| {
-        quote! {
-            fn static_baseclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
-                use rustpython_vm::class::StaticType;
-                #typ::static_type()
-            }
-        }
-    });
-
-    let meta_class = metaclass.map(|typ| {
-        let typ = Ident::new(&typ, ident.span());
-        quote! {
-            fn static_metaclass() -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
-                use rustpython_vm::class::StaticType;
-                #typ::static_type()
-            }
-        }
-    });
-
-    let base_or_object = if let Some(base) = base {
-        let base = Ident::new(&base, ident.span());
-        quote! { #base }
-    } else {
-        quote! { ::rustpython_vm::builtins::PyBaseObject }
-    };
-
-    let tokens = quote! {
-        impl ::rustpython_vm::class::PyClassDef for #ident {
-            const NAME: &'static str = #name;
-            const MODULE_NAME: Option<&'static str> = #module_name;
-            const TP_NAME: &'static str = #module_class_name;
-            const DOC: Option<&'static str> = #doc;
-            const BASICSIZE: usize = #basicsize;
-            const UNHASHABLE: bool = #unhashable;
-
-            type Base = #base_or_object;
-        }
-
-        impl ::rustpython_vm::class::StaticType for #ident {
-            fn static_cell() -> &'static ::rustpython_vm::common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> {
-                ::rustpython_vm::common::static_cell! {
-                    static CELL: ::rustpython_vm::builtins::PyTypeRef;
-                }
-                &CELL
-            }
-
-            #meta_class
-
-            #base_class
-        }
-    };
-    Ok(tokens)
-}
-
-pub(crate) fn impl_pyclass(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
-    if matches!(item, syn::Item::Use(_)) {
-        return Ok(quote!(#item));
-    }
-    let (ident, attrs) = pyclass_ident_and_attrs(&item)?;
-    let fake_ident = Ident::new("pyclass", item.span());
-    let class_meta = ClassItemMeta::from_nested(ident.clone(), fake_ident, attr.into_iter())?;
-    let class_name = class_meta.class_name()?;
-    let module_name = class_meta.module()?;
-    let base = class_meta.base()?;
-    let metaclass = class_meta.metaclass()?;
-    let unhashable = class_meta.unhashable()?;
-
-    let class_def = generate_class_def(
-        ident,
-        &class_name,
-        module_name.as_deref(),
-        base,
-        metaclass,
-        unhashable,
-        attrs,
-    )?;
-
-    const ALLOWED_TRAVERSE_OPTS: &[&str] = &["manual"];
-    // try to know if it have a `#[pyclass(trace)]` exist on this struct
-    // TODO(discord9): rethink on auto detect `#[Derive(PyTrace)]`
-
-    // 1. no `traverse` at all: generate a dummy try_traverse
-    // 2. `traverse = "manual"`: generate a try_traverse, but not #[derive(Traverse)]
-    // 3. `traverse`: generate a try_traverse, and #[derive(Traverse)]
-    let (maybe_trace_code, derive_trace) = {
-        if class_meta.inner()._has_key("traverse")? {
-            let maybe_trace_code = quote! {
-                impl ::rustpython_vm::object::MaybeTraverse for #ident {
-                    const IS_TRACE: bool = true;
-                    fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
-                        ::rustpython_vm::object::Traverse::traverse(self, tracer_fn);
-                    }
-                }
-            };
-            // if the key `traverse` exist but not as key-value, _optional_str return Err(...)
-            // so we need to check if it is Ok(Some(...))
-            let value = class_meta.inner()._optional_str("traverse");
-            let derive_trace = if let Ok(Some(s)) = value {
-                if !ALLOWED_TRAVERSE_OPTS.contains(&s.as_str()) {
-                    bail_span!(
-                        item,
-                        "traverse attribute only accept {ALLOWED_TRAVERSE_OPTS:?} as value or no value at all",
-                    );
-                }
-                assert_eq!(s, "manual");
-                quote! {}
-            } else {
-                quote! {#[derive(Traverse)]}
-            };
-            (maybe_trace_code, derive_trace)
-        } else {
-            (
-                // a dummy impl, which do nothing
-                // #attrs
-                quote! {
-                    impl ::rustpython_vm::object::MaybeTraverse for #ident {
-                        fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
-                            // do nothing
-                        }
-                    }
-                },
-                quote! {},
-            )
-        }
-    };
-
-    let impl_payload = if let Some(ctx_type_name) = class_meta.ctx_name()? {
-        let ctx_type_ident = Ident::new(&ctx_type_name, ident.span()); // FIXME span
-
-        // We need this to make extend mechanism work:
-        quote! {
-            impl ::rustpython_vm::PyPayload for #ident {
-                fn class(ctx: &::rustpython_vm::vm::Context) -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
-                    ctx.types.#ctx_type_ident
-                }
-            }
-        }
-    } else {
-        quote! {}
-    };
-
-    let empty_impl = if let Some(attrs) = class_meta.impl_attrs()? {
-        let attrs: Meta = parse_quote! (#attrs);
-        quote! {
-            #[pyclass(#attrs)]
-            impl #ident {}
-        }
-    } else {
-        quote! {}
-    };
-
-    let ret = quote! {
-        #derive_trace
-        #item
-        #maybe_trace_code
-        #class_def
-        #impl_payload
-        #empty_impl
-    };
-    Ok(ret)
-}
-
-/// Special macro to create exception types.
-///
-/// Why do we need it and why can't we just use `pyclass` macro instead?
-/// We generate exception types with a `macro_rules`,
-/// similar to how CPython does it.
-/// But, inside `macro_rules` we don't have an opportunity
-/// to add non-literal attributes to `pyclass`.
-/// That's why we have to use this proxy.
-pub(crate) fn impl_pyexception(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
-    let (ident, _attrs) = pyexception_ident_and_attrs(&item)?;
-    let fake_ident = Ident::new("pyclass", item.span());
-    let class_meta = ExceptionItemMeta::from_nested(ident.clone(), fake_ident, attr.into_iter())?;
-    let class_name = class_meta.class_name()?;
-
-    let base_class_name = class_meta.base()?;
-    let impl_payload = if let Some(ctx_type_name) = class_meta.ctx_name()? {
-        let ctx_type_ident = Ident::new(&ctx_type_name, ident.span()); // FIXME span
-
-        // We need this to make extend mechanism work:
-        quote! {
-            impl ::rustpython_vm::PyPayload for #ident {
-                fn class(ctx: &::rustpython_vm::vm::Context) -> &'static ::rustpython_vm::Py<::rustpython_vm::builtins::PyType> {
-                    ctx.exceptions.#ctx_type_ident
-                }
-            }
-        }
-    } else {
-        quote! {}
-    };
-    let impl_pyclass = if class_meta.has_impl()? {
-        quote! {
-            #[pyexception]
-            impl #ident {}
-        }
-    } else {
-        quote! {}
-    };
-
-    let ret = quote! {
-        #[pyclass(module = false, name = #class_name, base = #base_class_name)]
-        #item
-        #impl_payload
-        #impl_pyclass
-    };
-    Ok(ret)
-}
-
-pub(crate) fn impl_pyexception_impl(attr: PunctuatedNestedMeta, item: Item) -> Result<TokenStream> {
-    let Item::Impl(imp) = item else {
-        return Ok(item.into_token_stream());
-    };
-
-    if !attr.is_empty() {
-        return Err(syn::Error::new_spanned(
-            &attr[0],
-            "#[pyexception] impl doesn't allow attrs. Use #[pyclass] instead.",
-        ));
-    }
-
-    let mut has_slot_new = false;
-    let mut has_slot_init = false;
-    let syn::ItemImpl {
-        generics,
-        self_ty,
-        items,
-        ..
-    } = &imp;
-    for item in items {
-        // FIXME: better detection or correct wrapper implementation
-        let Some(ident) = item.get_ident() else {
-            continue;
-        };
-        let item_name = ident.to_string();
-        match item_name.as_str() {
-            "slot_new" => {
-                has_slot_new = true;
-            }
-            "slot_init" => {
-                has_slot_init = true;
-            }
-            _ => continue,
-        }
-    }
-
-    let slot_new = if has_slot_new {
-        quote!()
-    } else {
-        quote! {
-            #[pyslot]
-            pub(crate) fn slot_new(
-                cls: ::rustpython_vm::builtins::PyTypeRef,
-                args: ::rustpython_vm::function::FuncArgs,
-                vm: &::rustpython_vm::VirtualMachine,
-            ) -> ::rustpython_vm::PyResult {
-                <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_new(cls, args, vm)
-            }
-        }
-    };
-
-    // We need this method, because of how `CPython` copies `__init__`
-    // from `BaseException` in `SimpleExtendsException` macro.
-    // See: `(initproc)BaseException_init`
-    // spell-checker:ignore initproc
-    let slot_init = if has_slot_init {
-        quote!()
-    } else {
-        // FIXME: this is a generic logic for types not only for exceptions
-        quote! {
-            #[pyslot]
-            #[pymethod(name="__init__")]
-            pub(crate) fn slot_init(
-                zelf: ::rustpython_vm::PyObjectRef,
-                args: ::rustpython_vm::function::FuncArgs,
-                vm: &::rustpython_vm::VirtualMachine,
-            ) -> ::rustpython_vm::PyResult<()> {
-                <Self as ::rustpython_vm::class::PyClassDef>::Base::slot_init(zelf, args, vm)
-            }
-        }
-    };
-    Ok(quote! {
-        #[pyclass(flags(BASETYPE, HAS_DICT))]
-        impl #generics #self_ty {
-            #(#items)*
-
-            #slot_new
-            #slot_init
-        }
-    })
-}
-
-macro_rules! define_content_item {
-    (
-        $(#[$meta:meta])*
-        $vis:vis struct $name:ident
-    ) => {
-        $(#[$meta])*
-        $vis struct $name {
-            inner: ContentItemInner<AttrName>,
-        }
-
-        impl ContentItem for $name {
-            type AttrName = AttrName;
-
-            fn inner(&self) -> &ContentItemInner<AttrName> {
-                &self.inner
-            }
-        }
-    };
-}
-
-define_content_item!(
-    /// #[pymethod] and #[pyclassmethod]
-    struct MethodItem
-);
-
-define_content_item!(
-    /// #[pygetset]
-    struct GetSetItem
-);
-
-define_content_item!(
-    /// #[pyslot]
-    struct SlotItem
-);
-
-define_content_item!(
-    /// #[pyattr]
-    struct AttributeItem
-);
-
-define_content_item!(
-    /// #[extend_class]
-    struct ExtendClassItem
-);
-
-define_content_item!(
-    /// #[pymember]
-    struct MemberItem
-);
-
-struct ImplItemArgs<'a, Item: ItemLike> {
-    item: &'a Item,
-    attrs: &'a mut Vec<Attribute>,
-    context: &'a mut ImplContext,
-    cfgs: &'a [Attribute],
-}
-
-trait ImplItem<Item>: ContentItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()>;
-}
-
-impl<Item> ImplItem<Item> for MethodItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        let func = args
-            .item
-            .function_or_method()
-            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
-        let ident = &func.sig().ident;
-
-        let item_attr = args.attrs.remove(self.index());
-        let item_meta = MethodItemMeta::from_attr(ident.clone(), &item_attr)?;
-
-        let py_name = item_meta.method_name()?;
-        let raw = item_meta.raw()?;
-        let sig_doc = text_signature(func.sig(), &py_name);
-
-        // Add #[allow(non_snake_case)] for setter methods like set___name__
-        let method_name = ident.to_string();
-        if method_name.starts_with("set_") && method_name.contains("__") {
-            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
-            args.attrs.push(allow_attr);
-        }
-
-        let doc = args.attrs.doc().map(|doc| format_doc(&sig_doc, &doc));
-        args.context.method_items.add_item(MethodNurseryItem {
-            py_name,
-            cfgs: args.cfgs.to_vec(),
-            ident: ident.to_owned(),
-            doc,
-            raw,
-            attr_name: self.inner.attr_name,
-        });
-        Ok(())
-    }
-}
-
-impl<Item> ImplItem<Item> for GetSetItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        let func = args
-            .item
-            .function_or_method()
-            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
-        let ident = &func.sig().ident;
-
-        let item_attr = args.attrs.remove(self.index());
-        let item_meta = GetSetItemMeta::from_attr(ident.clone(), &item_attr)?;
-
-        let (py_name, kind) = item_meta.getset_name()?;
-
-        // Add #[allow(non_snake_case)] for setter methods
-        if matches!(kind, GetSetItemKind::Set) {
-            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
-            args.attrs.push(allow_attr);
-        }
-
-        args.context
-            .getset_items
-            .add_item(py_name, args.cfgs.to_vec(), kind, ident.clone())?;
-        Ok(())
-    }
-}
-
-impl<Item> ImplItem<Item> for SlotItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        let (ident, span) = if let Ok(c) = args.item.constant() {
-            (c.ident(), c.span())
-        } else if let Ok(f) = args.item.function_or_method() {
-            (&f.sig().ident, f.span())
-        } else {
-            return Err(self.new_syn_error(args.item.span(), "can only be on a method"));
-        };
-
-        let item_attr = args.attrs.remove(self.index());
-        let item_meta = SlotItemMeta::from_attr(ident.clone(), &item_attr)?;
-
-        let slot_ident = item_meta.slot_name()?;
-        let slot_ident = Ident::new(&slot_ident.to_string().to_lowercase(), slot_ident.span());
-        let slot_name = slot_ident.to_string();
-        let tokens = {
-            const NON_ATOMIC_SLOTS: &[&str] = &["as_buffer"];
-            const POINTER_SLOTS: &[&str] = &["as_sequence", "as_mapping"];
-            const STATIC_GEN_SLOTS: &[&str] = &["as_number"];
-
-            if NON_ATOMIC_SLOTS.contains(&slot_name.as_str()) {
-                quote_spanned! { span =>
-                    slots.#slot_ident = Some(Self::#ident as _);
-                }
-            } else if POINTER_SLOTS.contains(&slot_name.as_str()) {
-                quote_spanned! { span =>
-                    slots.#slot_ident.store(Some(PointerSlot::from(Self::#ident())));
-                }
-            } else if STATIC_GEN_SLOTS.contains(&slot_name.as_str()) {
-                quote_spanned! { span =>
-                    slots.#slot_ident = Self::#ident().into();
-                }
-            } else {
-                quote_spanned! { span =>
-                    slots.#slot_ident.store(Some(Self::#ident as _));
-                }
-            }
-        };
-
-        let pyname = format!("(slot {slot_name})");
-        args.context.extend_slots_items.add_item(
-            ident.clone(),
-            vec![pyname],
-            args.cfgs.to_vec(),
-            tokens,
-            2,
-        )?;
-
-        Ok(())
-    }
-}
-
-impl<Item> ImplItem<Item> for AttributeItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        let cfgs = args.cfgs.to_vec();
-        let attr = args.attrs.remove(self.index());
-
-        let get_py_name = |attr: &Attribute, ident: &Ident| -> Result<_> {
-            let item_meta = SimpleItemMeta::from_attr(ident.clone(), attr)?;
-            let py_name = item_meta.simple_name()?;
-            Ok(py_name)
-        };
-        let (ident, py_name, tokens) =
-            if args.item.function_or_method().is_ok() || args.item.constant().is_ok() {
-                let ident = args.item.get_ident().unwrap();
-                let py_name = get_py_name(&attr, ident)?;
-
-                let value = if args.item.constant().is_ok() {
-                    // TODO: ctx.new_value
-                    quote_spanned!(ident.span() => ctx.new_int(Self::#ident).into())
-                } else {
-                    quote_spanned!(ident.span() => Self::#ident(ctx))
-                };
-                (
-                    ident,
-                    py_name.clone(),
-                    quote! {
-                        class.set_str_attr(#py_name, #value, ctx);
-                    },
-                )
-            } else {
-                return Err(self.new_syn_error(
-                    args.item.span(),
-                    "can only be on a const or an associated method without argument",
-                ));
-            };
-
-        args.context
-            .attribute_items
-            .add_item(ident.clone(), vec![py_name], cfgs, tokens, 1)?;
-
-        Ok(())
-    }
-}
-
-impl<Item> ImplItem<Item> for ExtendClassItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        args.attrs.remove(self.index());
-
-        let ident = &args
-            .item
-            .function_or_method()
-            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?
-            .sig()
-            .ident;
-
-        args.context.class_extensions.push(quote! {
-            Self::#ident(ctx, class);
-        });
-
-        Ok(())
-    }
-}
-
-impl<Item> ImplItem<Item> for MemberItem
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    fn gen_impl_item(&self, args: ImplItemArgs<'_, Item>) -> Result<()> {
-        let func = args
-            .item
-            .function_or_method()
-            .map_err(|_| self.new_syn_error(args.item.span(), "can only be on a method"))?;
-        let ident = &func.sig().ident;
-
-        let item_attr = args.attrs.remove(self.index());
-        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,
-        };
-
-        // Add #[allow(non_snake_case)] for setter methods
-        if matches!(member_item_kind, MemberItemKind::Set) {
-            let allow_attr: Attribute = parse_quote!(#[allow(non_snake_case)]);
-            args.attrs.push(allow_attr);
-        }
-
-        args.context.member_items.add_item(
-            py_name,
-            member_item_kind,
-            member_kind,
-            ident.clone(),
-        )?;
-        Ok(())
-    }
-}
-
-#[derive(Default)]
-struct MethodNursery {
-    items: Vec<MethodNurseryItem>,
-}
-
-struct MethodNurseryItem {
-    py_name: String,
-    cfgs: Vec<Attribute>,
-    ident: Ident,
-    raw: bool,
-    doc: Option<String>,
-    attr_name: AttrName,
-}
-
-impl MethodNursery {
-    fn add_item(&mut self, item: MethodNurseryItem) {
-        self.items.push(item);
-    }
-
-    fn validate(&mut self) -> Result<()> {
-        let mut name_set = HashSet::new();
-        for item in &self.items {
-            if !name_set.insert((&item.py_name, &item.cfgs)) {
-                bail_span!(item.ident, "duplicate method name `{}`", item.py_name);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl ToTokens for MethodNursery {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let mut inner_tokens = TokenStream::new();
-        for item in &self.items {
-            let py_name = &item.py_name;
-            let ident = &item.ident;
-            let cfgs = &item.cfgs;
-            let doc = if let Some(doc) = item.doc.as_ref() {
-                quote! { Some(#doc) }
-            } else {
-                quote! { None }
-            };
-            let flags = match &item.attr_name {
-                AttrName::Method => {
-                    quote! { rustpython_vm::function::PyMethodFlags::METHOD }
-                }
-                AttrName::ClassMethod => {
-                    quote! { rustpython_vm::function::PyMethodFlags::CLASS }
-                }
-                AttrName::StaticMethod => {
-                    quote! { rustpython_vm::function::PyMethodFlags::STATIC }
-                }
-                _ => unreachable!(),
-            };
-            // TODO: intern
-            // let py_name = if py_name.starts_with("__") && py_name.ends_with("__") {
-            //     let name_ident = Ident::new(&py_name, ident.span());
-            //     quote_spanned! { ident.span() => ctx.names.#name_ident }
-            // } else {
-            //     quote_spanned! { ident.span() => #py_name }
-            // };
-            let method_new = if item.raw {
-                quote!(new_raw_const)
-            } else {
-                quote!(new_const)
-            };
-            inner_tokens.extend(quote! [
-                #(#cfgs)*
-                rustpython_vm::function::PyMethodDef::#method_new(
-                    #py_name,
-                    Self::#ident,
-                    #flags,
-                    #doc,
-                ),
-            ]);
-        }
-        let array: TokenTree = Group::new(Delimiter::Bracket, inner_tokens).into();
-        tokens.extend([array]);
-    }
-}
-
-#[derive(Default)]
-#[allow(clippy::type_complexity)]
-struct GetSetNursery {
-    map: HashMap<(String, Vec<Attribute>), (Option<Ident>, Option<Ident>, Option<Ident>)>,
-    validated: bool,
-}
-
-enum GetSetItemKind {
-    Get,
-    Set,
-    Delete,
-}
-
-impl GetSetNursery {
-    fn add_item(
-        &mut self,
-        name: String,
-        cfgs: Vec<Attribute>,
-        kind: GetSetItemKind,
-        item_ident: Ident,
-    ) -> Result<()> {
-        assert!(!self.validated, "new item is not allowed after validation");
-        if !matches!(kind, GetSetItemKind::Get) && !cfgs.is_empty() {
-            bail_span!(item_ident, "Only the getter can have #[cfg]",);
-        }
-        let entry = self.map.entry((name.clone(), cfgs)).or_default();
-        let func = match kind {
-            GetSetItemKind::Get => &mut entry.0,
-            GetSetItemKind::Set => &mut entry.1,
-            GetSetItemKind::Delete => &mut entry.2,
-        };
-        if func.is_some() {
-            bail_span!(
-                item_ident,
-                "Multiple property accessors with name '{}'",
-                name
-            );
-        }
-        *func = Some(item_ident);
-        Ok(())
-    }
-
-    fn validate(&mut self) -> Result<()> {
-        let mut errors = Vec::new();
-        for ((name, _cfgs), (getter, setter, deleter)) in &self.map {
-            if getter.is_none() {
-                errors.push(err_span!(
-                    setter.as_ref().or(deleter.as_ref()).unwrap(),
-                    "GetSet '{}' is missing a getter",
-                    name
-                ));
-            };
-        }
-        errors.into_result()?;
-        self.validated = true;
-        Ok(())
-    }
-}
-
-impl ToTokens for GetSetNursery {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        assert!(self.validated, "Call `validate()` before token generation");
-        let properties = self
-            .map
-            .iter()
-            .map(|((name, cfgs), (getter, setter, deleter))| {
-                let setter = match setter {
-                    Some(setter) => quote_spanned! { setter.span() => .with_set(Self::#setter)},
-                    None => quote! {},
-                };
-                let deleter = match deleter {
-                    Some(deleter) => {
-                        quote_spanned! { deleter.span() => .with_delete(Self::#deleter)}
-                    }
-                    None => quote! {},
-                };
-                quote_spanned! { getter.span() =>
-                    #( #cfgs )*
-                    class.set_str_attr(
-                        #name,
-                        ::rustpython_vm::PyRef::new_ref(
-                            ::rustpython_vm::builtins::PyGetSet::new(#name.into(), class)
-                                .with_get(Self::#getter)
-                                #setter #deleter,
-                                ctx.types.getset_type.to_owned(), None),
-                        ctx
-                    );
-                }
-            });
-        tokens.extend(properties);
-    }
-}
-
-#[derive(Default)]
-#[allow(clippy::type_complexity)]
-struct MemberNursery {
-    map: HashMap<(String, MemberKind), (Option<Ident>, Option<Ident>)>,
-    validated: bool,
-}
-
-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,
-        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 func = match kind {
-            MemberItemKind::Get => &mut entry.0,
-            MemberItemKind::Set => &mut entry.1,
-        };
-        if func.is_some() {
-            bail_span!(item_ident, "Multiple member accessors with name '{}'", name);
-        }
-        *func = Some(item_ident);
-        Ok(())
-    }
-
-    fn validate(&mut self) -> Result<()> {
-        let mut errors = Vec::new();
-        for ((name, _), (getter, setter)) in &self.map {
-            if getter.is_none() {
-                errors.push(err_span!(
-                    setter.as_ref().unwrap(),
-                    "Member '{}' is missing a getter",
-                    name
-                ));
-            };
-        }
-        errors.into_result()?;
-        self.validated = true;
-        Ok(())
-    }
-}
-
-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,
-                    );
-                }
-            });
-        tokens.extend(properties);
-    }
-}
-
-struct MethodItemMeta(ItemMetaInner);
-
-impl ItemMeta for MethodItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "raw"];
-
-    fn from_inner(inner: ItemMetaInner) -> Self {
-        Self(inner)
-    }
-
-    fn inner(&self) -> &ItemMetaInner {
-        &self.0
-    }
-}
-
-impl MethodItemMeta {
-    fn raw(&self) -> Result<bool> {
-        self.inner()._bool("raw")
-    }
-
-    fn method_name(&self) -> Result<String> {
-        let inner = self.inner();
-        let name = inner._optional_str("name")?;
-        Ok(if let Some(name) = name {
-            name
-        } else {
-            inner.item_name()
-        })
-    }
-}
-
-struct GetSetItemMeta(ItemMetaInner);
-
-impl ItemMeta for GetSetItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["name", "setter", "deleter"];
-
-    fn from_inner(inner: ItemMetaInner) -> Self {
-        Self(inner)
-    }
-
-    fn inner(&self) -> &ItemMetaInner {
-        &self.0
-    }
-}
-
-impl GetSetItemMeta {
-    fn getset_name(&self) -> Result<(String, GetSetItemKind)> {
-        let inner = self.inner();
-        let kind = match (inner._bool("setter")?, inner._bool("deleter")?) {
-            (false, false) => GetSetItemKind::Get,
-            (true, false) => GetSetItemKind::Set,
-            (false, true) => GetSetItemKind::Delete,
-            (true, true) => {
-                bail_span!(
-                    &inner.meta_ident,
-                    "can't have both setter and deleter on a #[{}] fn",
-                    inner.meta_name()
-                )
-            }
-        };
-        let name = inner._optional_str("name")?;
-        let py_name = if let Some(name) = name {
-            name
-        } else {
-            let sig_name = inner.item_name();
-            let extract_prefix_name = |prefix, item_typ| {
-                if let Some(name) = sig_name.strip_prefix(prefix) {
-                    if name.is_empty() {
-                        Err(err_span!(
-                            inner.meta_ident,
-                            r#"A #[{}({typ})] fn with a {prefix}* name must \
-                             have something after "{prefix}""#,
-                            inner.meta_name(),
-                            typ = item_typ,
-                            prefix = prefix
-                        ))
-                    } else {
-                        Ok(name.to_owned())
-                    }
-                } else {
-                    Err(err_span!(
-                        inner.meta_ident,
-                        r#"A #[{}(setter)] fn must either have a `name` \
-                         parameter or a fn name along the lines of "set_*""#,
-                        inner.meta_name()
-                    ))
-                }
-            };
-            match kind {
-                GetSetItemKind::Get => sig_name,
-                GetSetItemKind::Set => extract_prefix_name("set_", "setter")?,
-                GetSetItemKind::Delete => extract_prefix_name("del_", "deleter")?,
-            }
-        };
-        Ok((py_name, kind))
-    }
-}
-
-struct SlotItemMeta(ItemMetaInner);
-
-impl ItemMeta for SlotItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &[]; // not used
-
-    fn from_nested<I>(item_ident: Ident, meta_ident: Ident, mut nested: I) -> Result<Self>
-    where
-        I: std::iter::Iterator<Item = NestedMeta>,
-    {
-        let meta_map = if let Some(nested_meta) = nested.next() {
-            match nested_meta {
-                NestedMeta::Meta(meta) => {
-                    Some([("name".to_owned(), (0, meta))].iter().cloned().collect())
-                }
-                _ => None,
-            }
-        } else {
-            Some(HashMap::default())
-        };
-        let (Some(meta_map), None) = (meta_map, nested.next()) else {
-            bail_span!(
-                meta_ident,
-                "#[pyslot] must be of the form #[pyslot] or #[pyslot(slot_name)]"
-            )
-        };
-        Ok(Self::from_inner(ItemMetaInner {
-            item_ident,
-            meta_ident,
-            meta_map,
-        }))
-    }
-
-    fn from_inner(inner: ItemMetaInner) -> Self {
-        Self(inner)
-    }
-
-    fn inner(&self) -> &ItemMetaInner {
-        &self.0
-    }
-}
-
-impl SlotItemMeta {
-    fn slot_name(&self) -> Result<Ident> {
-        let inner = self.inner();
-        let method_name = if let Some((_, meta)) = inner.meta_map.get("name") {
-            match meta {
-                Meta::Path(path) => path.get_ident().cloned(),
-                _ => None,
-            }
-        } else {
-            let ident_str = self.inner().item_name();
-            let name = if let Some(stripped) = ident_str.strip_prefix("slot_") {
-                proc_macro2::Ident::new(stripped, inner.item_ident.span())
-            } else {
-                inner.item_ident.clone()
-            };
-            Some(name)
-        };
-        let method_name = method_name.ok_or_else(|| {
-            err_span!(
-                inner.meta_ident,
-                "#[pyslot] must be of the form #[pyslot] or #[pyslot(slot_name)]",
-            )
-        })?;
-
-        // Strip double underscores from slot names like __init__ -> init
-        let method_name_str = method_name.to_string();
-        let slot_name = if method_name_str.starts_with("__")
-            && method_name_str.ends_with("__")
-            && method_name_str.len() > 4
-        {
-            &method_name_str[2..method_name_str.len() - 2]
-        } else {
-            &method_name_str
-        };
-
-        Ok(proc_macro2::Ident::new(slot_name, slot_name.span()))
-    }
-}
-
-struct MemberItemMeta(ItemMetaInner);
-
-impl ItemMeta for MemberItemMeta {
-    const ALLOWED_NAMES: &'static [&'static str] = &["type", "setter"];
-
-    fn from_inner(inner: ItemMetaInner) -> Self {
-        Self(inner)
-    }
-
-    fn inner(&self) -> &ItemMetaInner {
-        &self.0
-    }
-}
-
-impl MemberItemMeta {
-    fn member_name(&self) -> Result<(String, MemberItemKind)> {
-        let inner = self.inner();
-        let sig_name = inner.item_name();
-        let extract_prefix_name = |prefix, item_typ| {
-            if let Some(name) = sig_name.strip_prefix(prefix) {
-                if name.is_empty() {
-                    Err(err_span!(
-                        inner.meta_ident,
-                        r#"A #[{}({typ})] fn with a {prefix}* name must \
-                         have something after "{prefix}""#,
-                        inner.meta_name(),
-                        typ = item_typ,
-                        prefix = prefix
-                    ))
-                } else {
-                    Ok(name.to_owned())
-                }
-            } else {
-                Err(err_span!(
-                    inner.meta_ident,
-                    r#"A #[{}(setter)] fn must either have a `name` \
-                     parameter or a fn name along the lines of "set_*""#,
-                    inner.meta_name()
-                ))
-            }
-        };
-        let kind = if inner._bool("setter")? {
-            MemberItemKind::Set
-        } else {
-            MemberItemKind::Get
-        };
-        let name = match kind {
-            MemberItemKind::Get => sig_name,
-            MemberItemKind::Set => extract_prefix_name("set_", "setter")?,
-        };
-        Ok((name, kind))
-    }
-
-    fn member_kind(&self) -> Result<Option<String>> {
-        let inner = self.inner();
-        inner._optional_str("type")
-    }
-}
-
-struct ExtractedImplAttrs {
-    payload: Option<Ident>,
-    flags: TokenStream,
-    with_impl: TokenStream,
-    with_method_defs: Vec<TokenStream>,
-    with_slots: TokenStream,
-}
-
-fn extract_impl_attrs(attr: PunctuatedNestedMeta, item: &Ident) -> Result<ExtractedImplAttrs> {
-    let mut withs = Vec::new();
-    let mut with_method_defs = Vec::new();
-    let mut with_slots = Vec::new();
-    let mut flags = vec![quote! {
-        {
-            #[cfg(not(debug_assertions))] {
-                ::rustpython_vm::types::PyTypeFlags::DEFAULT
-            }
-            #[cfg(debug_assertions)] {
-                ::rustpython_vm::types::PyTypeFlags::DEFAULT
-                    .union(::rustpython_vm::types::PyTypeFlags::_CREATED_WITH_FLAGS)
-            }
-        }
-    }];
-    let mut payload = None;
-
-    let mut has_constructor = false;
-    for attr in attr {
-        match attr {
-            NestedMeta::Meta(Meta::List(MetaList { path, nested, .. })) => {
-                if path.is_ident("with") {
-                    for meta in nested {
-                        let NestedMeta::Meta(Meta::Path(path)) = &meta else {
-                            bail_span!(meta, "#[pyclass(with(...))] arguments must be paths")
-                        };
-                        let (extend_class, method_defs, extend_slots) = if path.is_ident("PyRef")
-                            || path.is_ident("Py")
-                        {
-                            // special handling for PyRef
-                            (
-                                quote!(#path::<Self>::__extend_py_class),
-                                quote!(#path::<Self>::__OWN_METHOD_DEFS),
-                                quote!(#path::<Self>::__extend_slots),
-                            )
-                        } else {
-                            if path.is_ident("DefaultConstructor") {
-                                bail_span!(
-                                    meta,
-                                    "Try `#[pyclass(with(Constructor, ...))]` instead of `#[pyclass(with(DefaultConstructor, ...))]`. DefaultConstructor implicitly implements Constructor."
-                                )
-                            }
-                            if path.is_ident("Constructor") || path.is_ident("Unconstructible") {
-                                has_constructor = true;
-                            }
-                            (
-                                quote!(<Self as #path>::__extend_py_class),
-                                quote!(<Self as #path>::__OWN_METHOD_DEFS),
-                                quote!(<Self as #path>::__extend_slots),
-                            )
-                        };
-                        let item_span = item.span().resolved_at(Span::call_site());
-                        withs.push(quote_spanned! { path.span() =>
-                            #extend_class(ctx, class);
-                        });
-                        with_method_defs.push(method_defs);
-                        with_slots.push(quote_spanned! { item_span =>
-                            #extend_slots(slots);
-                        });
-                    }
-                } else if path.is_ident("flags") {
-                    for meta in nested {
-                        let NestedMeta::Meta(Meta::Path(path)) = meta else {
-                            bail_span!(meta, "#[pyclass(flags(...))] arguments should be ident")
-                        };
-                        let ident = path.get_ident().ok_or_else(|| {
-                            err_span!(path, "#[pyclass(flags(...))] arguments should be ident")
-                        })?;
-                        flags.push(quote_spanned! { ident.span() =>
-                             .union(::rustpython_vm::types::PyTypeFlags::#ident)
-                        });
-                    }
-                    flags.push(quote! {
-                        .union(::rustpython_vm::types::PyTypeFlags::IMMUTABLETYPE)
-                    });
-                } else {
-                    bail_span!(path, "Unknown pyimpl attribute")
-                }
-            }
-            NestedMeta::Meta(Meta::NameValue(syn::MetaNameValue { path, value, .. })) => {
-                if path.is_ident("payload") {
-                    if let syn::Expr::Lit(syn::ExprLit {
-                        lit: syn::Lit::Str(lit),
-                        ..
-                    }) = value
-                    {
-                        payload = Some(Ident::new(&lit.value(), lit.span()));
-                    } else {
-                        bail_span!(value, "payload must be a string literal")
-                    }
-                } else {
-                    bail_span!(path, "Unknown pyimpl attribute")
-                }
-            }
-            attr => bail_span!(attr, "Unknown pyimpl attribute"),
-        }
-    }
-    // TODO: DISALLOW_INSTANTIATION check is required
-    let _ = has_constructor;
-    // if !withs.is_empty() && !has_constructor {
-    //     bail_span!(item, "#[pyclass(with(...))] does not have a Constructor. Either #[pyclass(with(Constructor, ...))] or #[pyclass(with(Unconstructible, ...))] is mandatory. Consider to add `impl DefaultConstructor for T {{}}` or `impl Unconstructible for T {{}}`.")
-    // }
-
-    Ok(ExtractedImplAttrs {
-        payload,
-        flags: quote! {
-            #(#flags)*
-        },
-        with_impl: quote! {
-            #(#withs)*
-        },
-        with_method_defs,
-        with_slots: quote! {
-            #(#with_slots)*
-        },
-    })
-}
-
-fn impl_item_new<Item>(
-    index: usize,
-    attr_name: AttrName,
-) -> Result<Box<dyn ImplItem<Item, AttrName = AttrName>>>
-where
-    Item: ItemLike + ToTokens + GetIdent,
-{
-    use AttrName::*;
-    Ok(match attr_name {
-        attr_name @ Method | attr_name @ ClassMethod | attr_name @ StaticMethod => {
-            Box::new(MethodItem {
-                inner: ContentItemInner { index, attr_name },
-            })
-        }
-        GetSet => Box::new(GetSetItem {
-            inner: ContentItemInner { index, attr_name },
-        }),
-        Slot => Box::new(SlotItem {
-            inner: ContentItemInner { index, attr_name },
-        }),
-        Attr => Box::new(AttributeItem {
-            inner: ContentItemInner { index, attr_name },
-        }),
-        ExtendClass => Box::new(ExtendClassItem {
-            inner: ContentItemInner { index, attr_name },
-        }),
-        Member => Box::new(MemberItem {
-            inner: ContentItemInner { index, attr_name },
-        }),
-    })
-}
-
-fn attrs_to_content_items<F, R>(
-    attrs: &[Attribute],
-    item_new: F,
-) -> Result<(Vec<R>, Vec<Attribute>)>
-where
-    F: Fn(usize, AttrName) -> Result<R>,
-{
-    let mut cfgs: Vec<Attribute> = Vec::new();
-    let mut result = Vec::new();
-
-    let mut iter = attrs.iter().enumerate().peekable();
-    while let Some((_, attr)) = iter.peek() {
-        // take all cfgs but no py items
-        let attr = *attr;
-        let attr_name = if let Some(ident) = attr.get_ident() {
-            ident.to_string()
-        } else {
-            continue;
-        };
-        if attr_name == "cfg" {
-            cfgs.push(attr.clone());
-        } else if ALL_ALLOWED_NAMES.contains(&attr_name.as_str()) {
-            break;
-        }
-        iter.next();
-    }
-
-    for (i, attr) in iter {
-        // take py items but no cfgs
-        let attr_name = if let Some(ident) = attr.get_ident() {
-            ident.to_string()
-        } else {
-            continue;
-        };
-        if attr_name == "cfg" {
-            bail_span!(attr, "#[py*] items must be placed under `cfgs`",);
-        }
-        let attr_name = match AttrName::from_str(attr_name.as_str()) {
-            Ok(name) => name,
-            Err(wrong_name) => {
-                if ALL_ALLOWED_NAMES.contains(&attr_name.as_str()) {
-                    bail_span!(attr, "#[pyclass] doesn't accept #[{}]", wrong_name)
-                } else {
-                    continue;
-                }
-            }
-        };
-
-        result.push(item_new(i, attr_name)?);
-    }
-    Ok((result, cfgs))
-}
-
-#[allow(dead_code)]
-fn parse_vec_ident(
-    attr: &[NestedMeta],
-    item: &Item,
-    index: usize,
-    message: &str,
-) -> Result<String> {
-    Ok(attr
-        .get(index)
-        .ok_or_else(|| err_span!(item, "We require {} argument to be set", message))?
-        .get_ident()
-        .ok_or_else(|| {
-            err_span!(
-                item,
-                "We require {} argument to be ident or string",
-                message
-            )
-        })?
-        .to_string())
-}
diff --git a/derive-impl/src/pystructseq.rs b/derive-impl/src/pystructseq.rs
deleted file mode 100644
index 89dee8da10..0000000000
--- a/derive-impl/src/pystructseq.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{DeriveInput, Ident, Result};
-use syn_ext::ext::{AttributeExt, GetIdent};
-use syn_ext::types::Meta;
-
-// returning a pair of not-skipped and skipped field names
-fn field_names(input: &mut DeriveInput) -> Result<(Vec<Ident>, Vec<Ident>)> {
-    let syn::Data::Struct(struc) = &mut input.data else {
-        bail_span!(
-            input,
-            "#[pystruct_sequence] can only be on a struct declaration"
-        )
-    };
-
-    let syn::Fields::Named(fields) = &mut struc.fields else {
-        bail_span!(
-            input,
-            "#[pystruct_sequence] can only be on a struct with named fields"
-        );
-    };
-
-    let mut not_skipped = Vec::with_capacity(fields.named.len());
-    let mut skipped = Vec::with_capacity(fields.named.len());
-    for field in &mut fields.named {
-        let mut skip = false;
-        // Collect all attributes with pystruct and their indices
-        let mut attrs_to_remove = Vec::new();
-
-        for (i, attr) in field.attrs.iter().enumerate() {
-            if !attr.path().is_ident("pystruct") {
-                continue;
-            }
-
-            let Ok(meta) = attr.parse_meta() else {
-                continue;
-            };
-
-            let Meta::List(l) = meta else {
-                bail_span!(input, "Only #[pystruct(...)] form is allowed");
-            };
-
-            let idents: Vec<_> = l
-                .nested
-                .iter()
-                .filter_map(|n| n.get_ident())
-                .cloned()
-                .collect();
-
-            // Follow #[serde(skip)] convention.
-            // Consider to add skip_serializing and skip_deserializing if required.
-            for ident in idents {
-                match ident.to_string().as_str() {
-                    "skip" => {
-                        skip = true;
-                    }
-                    _ => {
-                        bail_span!(ident, "Unknown item for #[pystruct(...)]")
-                    }
-                }
-            }
-
-            attrs_to_remove.push(i);
-        }
-
-        // Remove attributes in reverse order to maintain valid indices
-        attrs_to_remove.sort_unstable_by(|a, b| b.cmp(a)); // Sort in descending order
-        for index in attrs_to_remove {
-            field.attrs.remove(index);
-        }
-        let ident = field.ident.clone().unwrap();
-        if skip {
-            skipped.push(ident.clone());
-        } else {
-            not_skipped.push(ident.clone());
-        }
-    }
-
-    Ok((not_skipped, skipped))
-}
-
-pub(crate) fn impl_pystruct_sequence(mut input: DeriveInput) -> Result<TokenStream> {
-    let (not_skipped_fields, skipped_fields) = field_names(&mut input)?;
-    let ty = &input.ident;
-    let ret = quote! {
-        impl ::rustpython_vm::types::PyStructSequence for #ty {
-            const REQUIRED_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#not_skipped_fields),)*];
-            const OPTIONAL_FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#skipped_fields),)*];
-            fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::PyTuple {
-                let items = vec![
-                    #(::rustpython_vm::convert::ToPyObject::to_pyobject(
-                        self.#not_skipped_fields,
-                        vm,
-                    ),)*
-                ];
-                ::rustpython_vm::builtins::PyTuple::new_unchecked(items.into_boxed_slice())
-            }
-        }
-        impl ::rustpython_vm::convert::ToPyObject for #ty {
-            fn to_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::PyObjectRef {
-                ::rustpython_vm::types::PyStructSequence::into_struct_sequence(self, vm).into()
-            }
-        }
-    };
-    Ok(ret)
-}
-
-pub(crate) fn impl_pystruct_sequence_try_from_object(
-    mut input: DeriveInput,
-) -> Result<TokenStream> {
-    let (not_skipped_fields, skipped_fields) = field_names(&mut input)?;
-    let ty = &input.ident;
-    let ret = quote! {
-        impl ::rustpython_vm::TryFromObject for #ty {
-            fn try_from_object(vm: &::rustpython_vm::VirtualMachine, seq: ::rustpython_vm::PyObjectRef) -> ::rustpython_vm::PyResult<Self> {
-                let seq = Self::try_elements_from(seq, vm)?;
-                let mut iter = seq.into_iter();
-                Ok(Self {
-                    #(#not_skipped_fields: iter.next().unwrap().clone().try_into_value(vm)?,)*
-                    #(#skipped_fields: match iter.next() {
-                        Some(v) => v.clone().try_into_value(vm)?,
-                        None => vm.ctx.none(),
-                    },)*
-                })
-            }
-        }
-    };
-    Ok(ret)
-}
diff --git a/derive/Cargo.toml b/derive/Cargo.toml
deleted file mode 100644
index 17c0810884..0000000000
--- a/derive/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "rustpython-derive"
-description = "Rust language extensions and macros specific to rustpython."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[lib]
-proc-macro = true
-
-[dependencies]
-rustpython-compiler = { workspace = true }
-rustpython-derive-impl = { workspace = true }
-proc-macro2 = { workspace = true }
-syn = { workspace = true }
-
-[lints]
-workspace = true
\ No newline at end of file
diff --git a/derive/src/lib.rs b/derive/src/lib.rs
deleted file mode 100644
index 3b95c594a1..0000000000
--- a/derive/src/lib.rs
+++ /dev/null
@@ -1,280 +0,0 @@
-#![recursion_limit = "128"]
-#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
-#![doc(html_root_url = "https://docs.rs/rustpython-derive/")]
-
-use proc_macro::TokenStream;
-use rustpython_derive_impl as derive_impl;
-use syn::parse_macro_input;
-use syn::punctuated::Punctuated;
-
-#[proc_macro_derive(FromArgs, attributes(pyarg))]
-pub fn derive_from_args(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input);
-    derive_impl::derive_from_args(input).into()
-}
-
-/// The attribute can be applied either to a struct, trait, or impl.
-/// # Struct
-/// This implements `MaybeTraverse`, `PyClassDef`, and `StaticType` for the struct.
-/// Consider deriving `Traverse` to implement it.
-/// ## Arguments
-/// - `module`: the module which contains the class --  can be omitted if in a `#[pymodule]`.
-/// - `name`: the name of the Python class, by default it is the name of the struct.
-/// - `base`: the base class of the Python class.
-///   This does not cause inheritance of functions or attributes that must be done by a separate trait.
-/// # Impl
-/// This part implements `PyClassImpl` for the struct.
-/// This includes methods, getters/setters, etc.; only annotated methods will be included.
-/// Common functions and abilities like instantiation and `__call__` are often implemented by
-/// traits rather than in the `impl` itself; see `Constructor` and `Callable` respectively for those.
-/// ## Arguments
-/// - `name`: the name of the Python class, when no name is provided the struct name is used.
-/// - `flags`: the flags of the class, see `PyTypeFlags`.
-///     - `BASETYPE`: allows the class to be inheritable.
-///     - `IMMUTABLETYPE`: class attributes are immutable.
-/// - `with`: which trait implementations are to be included in the python class.
-/// ```rust, ignore
-/// #[pyclass(module = "my_module", name = "MyClass", base = "BaseClass")]
-/// struct MyStruct {
-///    x: i32,
-/// }
-///
-/// impl Constructor for MyStruct {
-///     ...
-/// }
-///
-/// #[pyclass(with(Constructor))]
-/// impl MyStruct {
-///    ...
-/// }
-/// ```
-/// ## Inner markers
-/// ### pymethod/pyclassmethod/pystaticmethod
-/// `pymethod` is used to mark a method of the Python class.
-/// `pyclassmethod` is used to mark a class method.
-/// `pystaticmethod` is used to mark a static method.
-/// #### Method signature
-/// The first parameter can be either `&self` or `<var>: PyRef<Self>` for `pymethod`.
-/// The first parameter can be `cls: PyTypeRef` for `pyclassmethod`.
-/// There is no mandatory parameter for `pystaticmethod`.
-/// Both are valid and essentially the same, but the latter can yield more control.
-/// The last parameter can optionally be of the type `&VirtualMachine` to access the VM.
-/// All other values must implement `IntoPyResult`.
-/// Numeric types, `String`, `bool`, and `PyObjectRef` implement this trait,
-/// but so does any object that implements `PyValue`.
-/// Consider using `OptionalArg` for optional arguments.
-/// #### Arguments
-/// - `name`: the name of the method in Python,
-///   by default it is the same as the Rust method, or surrounded by double underscores if magic is present.
-///   This overrides `magic` and the default name and cannot be used with `magic` to prevent ambiguity.
-/// ### pygetset
-/// This is used to mark a getter/setter pair.
-/// #### Arguments
-/// - `setter`: marks the method as a setter, it acts as a getter by default.
-///   Setter method names should be prefixed with `set_`.
-/// - `name`: the name of the attribute in Python, by default it is the same as the Rust method.
-/// - `magic`: marks the method as a magic method: the method name is surrounded with double underscores.
-///   This cannot be used with `name` to prevent ambiguity.
-///
-/// Ensure both the getter and setter are marked with `name` and `magic` in the same manner.
-/// #### Examples
-/// ```rust, ignore
-/// #[pyclass]
-/// impl MyStruct {
-///    #[pygetset]
-///    fn x(&self) -> PyResult<i32> {
-///       Ok(self.x.lock())
-///     }
-///    #[pygetset(setter)]
-///   fn set_x(&mut self, value: i32) -> PyResult<()> {
-///      self.x.set(value);
-///     Ok(())
-///     }
-/// }
-/// ```
-/// ### pyslot
-/// This is used to mark a slot method it should be marked by prefixing the method in rust with `slot_`.
-/// #### Arguments
-/// - name: the name of the slot method.
-/// ### pyattr
-/// ### extend_class
-/// This helps inherit attributes from a parent class.
-/// The method this is applied on should be called `extend_class_with_fields`.
-/// #### Examples
-/// ```rust, ignore
-/// #[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!("body")).into(),
-///             ctx.new_str(ascii!("type_ignores")).into(),
-///         ])
-///         .into(),
-///     );
-///     class.set_attr(identifier!(ctx, _attributes), ctx.new_list(vec![]).into());
-/// }
-/// ```
-/// ### pymember
-/// # Trait
-/// `#[pyclass]` on traits functions a lot like `#[pyclass]` on `impl` blocks.
-/// Note that associated functions that are annotated with `#[pymethod]` or similar **must**
-/// have a body, abstract functions should be wrapped before applying an annotation.
-#[proc_macro_attribute]
-pub fn pyclass(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
-    let item = parse_macro_input!(item);
-    derive_impl::pyclass(attr, item).into()
-}
-
-/// Helper macro to define `Exception` types.
-/// More-or-less is an alias to `pyclass` macro.
-///
-/// This macro serves a goal of generating multiple
-/// `BaseException` / `Exception`
-/// subtypes in a uniform and convenient manner.
-/// It looks like `SimpleExtendsException` in `CPython`.
-/// <https://github.com/python/cpython/blob/main/Objects/exceptions.c>
-#[proc_macro_attribute]
-pub fn pyexception(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let attr = parse_macro_input!(attr with Punctuated::parse_terminated);
-    let item = parse_macro_input!(item);
-    derive_impl::pyexception(attr, item).into()
-}
-
-/// This attribute must be applied to an inline module.
-/// It defines a Python module in the form a `make_module` function in the module;
-/// this has to be used in a `get_module_inits` to properly register the module.
-/// Additionally, this macro defines 'MODULE_NAME' and 'DOC' in the module.
-/// # Arguments
-/// - `name`: the name of the python module,
-///   by default, it is the name of the module, but this can be configured.
-/// ```rust, ignore
-/// // This will create a module named `my_module`
-/// #[pymodule(name = "my_module")]
-/// mod module {
-/// }
-/// ```
-/// - `sub`: declare the module as a submodule of another module.
-/// ```rust, ignore
-/// #[pymodule(sub)]
-/// mod submodule {
-/// }
-///
-/// #[pymodule(with(submodule))]
-/// mod my_module {
-/// }
-/// ```
-/// - `with`: declare the list of submodules that this module contains (see `sub` for example).
-/// ## Inner markers
-/// ### pyattr
-/// `pyattr` is a multipurpose marker that can be used in a pymodule.
-/// The most common use is to mark a function or class as a part of the module.
-/// This can be done by applying it to a function or struct prior to the `#[pyfunction]` or `#[pyclass]` macro.
-/// If applied to a constant, it will be added to the module as an attribute.
-/// If applied to a function not marked with `pyfunction`,
-/// it will also be added to the module as an attribute but the value is the result of the function.
-/// If `#[pyattr(once)]` is used in this case, the function will be called once
-/// and the result will be stored using a `static_cell`.
-/// #### Examples
-/// ```rust, ignore
-/// #[pymodule]
-/// mod my_module {
-///     #[pyattr]
-///     const MY_CONSTANT: i32 = 42;
-///     #[pyattr]
-///    fn another_constant() -> PyResult<i32> {
-///       Ok(42)
-///    }
-///   #[pyattr(once)]
-///   fn once() -> PyResult<i32> {
-///     // This will only be called once and the result will be stored.
-///     Ok(2 ** 24)
-///  }
-///
-///     #[pyattr]
-///     #[pyfunction]
-///     fn my_function(vm: &VirtualMachine) -> PyResult<()> {
-///         ...
-///     }
-/// }
-/// ```
-/// ### pyfunction
-/// This is used to create a python function.
-/// #### Function signature
-/// The last argument can optionally be of the type `&VirtualMachine` to access the VM.
-/// Refer to the `pymethod` documentation (located in the `pyclass` macro documentation)
-/// for more information on what regular argument types are permitted.
-/// #### Arguments
-/// - `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 item = parse_macro_input!(item);
-    derive_impl::pymodule(attr, item).into()
-}
-
-#[proc_macro_derive(PyStructSequence, attributes(pystruct))]
-pub fn pystruct_sequence(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input);
-    derive_impl::pystruct_sequence(input).into()
-}
-
-#[proc_macro_derive(TryIntoPyStructSequence, attributes(pystruct))]
-pub fn pystruct_sequence_try_from_object(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input);
-    derive_impl::pystruct_sequence_try_from_object(input).into()
-}
-
-struct Compiler;
-impl derive_impl::Compiler for Compiler {
-    fn compile(
-        &self,
-        source: &str,
-        mode: rustpython_compiler::Mode,
-        module_name: String,
-    ) -> Result<rustpython_compiler::CodeObject, Box<dyn std::error::Error>> {
-        use rustpython_compiler::{CompileOpts, compile};
-        Ok(compile(source, mode, &module_name, CompileOpts::default())?)
-    }
-}
-
-#[proc_macro]
-pub fn py_compile(input: TokenStream) -> TokenStream {
-    derive_impl::py_compile(input.into(), &Compiler).into()
-}
-
-#[proc_macro]
-pub fn py_freeze(input: TokenStream) -> TokenStream {
-    derive_impl::py_freeze(input.into(), &Compiler).into()
-}
-
-#[proc_macro_derive(PyPayload)]
-pub fn pypayload(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input);
-    derive_impl::pypayload(input).into()
-}
-
-/// use on struct with named fields like `struct A{x:PyRef<B>, y:PyRef<C>}` to impl `Traverse` for datatype.
-///
-/// use `#[pytraverse(skip)]` on fields you wish not to trace
-///
-/// add `trace` attr to `#[pyclass]` to make it impl `MaybeTraverse` that will call `Traverse`'s `traverse` method so make it
-/// traceable(Even from type-erased PyObject)(i.e. write `#[pyclass(trace)]`).
-/// # Example
-/// ```rust, ignore
-/// #[pyclass(module = false, traverse)]
-/// #[derive(Default, Traverse)]
-/// pub struct PyList {
-///     elements: PyRwLock<Vec<PyObjectRef>>,
-///     #[pytraverse(skip)]
-///     len: AtomicCell<usize>,
-/// }
-/// ```
-/// This create both `MaybeTraverse` that call `Traverse`'s `traverse` method and `Traverse` that impl `Traverse`
-/// for `PyList` which call elements' `traverse` method and ignore `len` field.
-#[proc_macro_derive(Traverse, attributes(pytraverse))]
-pub fn pytraverse(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let item = parse_macro_input!(item);
-    derive_impl::pytraverse(item).into()
-}
diff --git a/example_projects/barebone/Cargo.toml b/example_projects/barebone/Cargo.toml
index a993277f31..b69617bdaf 100644
--- a/example_projects/barebone/Cargo.toml
+++ b/example_projects/barebone/Cargo.toml
@@ -4,9 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-rustpython-vm = { path = "../../vm", default-features = false }
+rustpython-vm = { path = "../../crates/vm", default-features = false }
 
 [workspace]
 
 [patch.crates-io]
-radium = { version = "1.1.0", git = "https://github.com/youknowone/ferrilab", branch = "fix-nightly" }
diff --git a/example_projects/frozen_stdlib/Cargo.toml b/example_projects/frozen_stdlib/Cargo.toml
index be1b1eb16c..91bb14a083 100644
--- a/example_projects/frozen_stdlib/Cargo.toml
+++ b/example_projects/frozen_stdlib/Cargo.toml
@@ -5,10 +5,9 @@ edition = "2021"
 
 [dependencies]
 rustpython = { path = "../../", default-features = false, features = ["freeze-stdlib"] }
-rustpython-vm = { path = "../../vm", default-features = false, features = ["freeze-stdlib"] }
-rustpython-pylib = { path = "../../pylib", default-features = false, features = ["freeze-stdlib"] }
+rustpython-vm = { path = "../../crates/vm", default-features = false, features = ["freeze-stdlib"] }
+rustpython-pylib = { path = "../../crates/pylib", default-features = false, features = ["freeze-stdlib"] }
 
 [workspace]
 
 [patch.crates-io]
-radium = { version = "1.1.0", git = "https://github.com/youknowone/ferrilab", branch = "fix-nightly" }
diff --git a/example_projects/wasm32_without_js/.gitignore b/example_projects/wasm32_without_js/.gitignore
new file mode 100644
index 0000000000..50a623b5da
--- /dev/null
+++ b/example_projects/wasm32_without_js/.gitignore
@@ -0,0 +1,2 @@
+*/target/
+*/Cargo.lock
diff --git a/example_projects/wasm32_without_js/README.md b/example_projects/wasm32_without_js/README.md
new file mode 100644
index 0000000000..67fef3fba4
--- /dev/null
+++ b/example_projects/wasm32_without_js/README.md
@@ -0,0 +1,18 @@
+# RustPython wasm32 build without JS
+
+To test, build rustpython to wasm32-unknown-unknown target first.
+
+```shell
+cd rustpython-without-js  # due to `.cargo/config.toml`
+cargo build
+cd ..
+```
+
+Then there will be `rustpython-without-js/target/wasm32-unknown-unknown/debug/rustpython_without_js.wasm` file.
+
+Now we can run the wasm file with wasm runtime:
+
+```shell
+cargo run --release --manifest-path wasm-runtime/Cargo.toml rustpython-without-js/target/wasm32-unknown-unknown/debug/rustpython_without_js.wasm
+```
+
diff --git a/wasm/wasm-unknown-test/.cargo/config.toml b/example_projects/wasm32_without_js/rustpython-without-js/.cargo/config.toml
similarity index 100%
rename from wasm/wasm-unknown-test/.cargo/config.toml
rename to example_projects/wasm32_without_js/rustpython-without-js/.cargo/config.toml
diff --git a/example_projects/wasm32_without_js/rustpython-without-js/Cargo.toml b/example_projects/wasm32_without_js/rustpython-without-js/Cargo.toml
new file mode 100644
index 0000000000..f987fe94a2
--- /dev/null
+++ b/example_projects/wasm32_without_js/rustpython-without-js/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "rustpython-without-js"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+getrandom = "0.3"
+rustpython-vm = { path = "../../../crates/vm", default-features = false, features = ["compiler"] }
+
+[workspace]
+
+[patch.crates-io]
diff --git a/wasm/wasm-unknown-test/README.md b/example_projects/wasm32_without_js/rustpython-without-js/README.md
similarity index 100%
rename from wasm/wasm-unknown-test/README.md
rename to example_projects/wasm32_without_js/rustpython-without-js/README.md
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
new file mode 100644
index 0000000000..0a8695fd7f
--- /dev/null
+++ b/example_projects/wasm32_without_js/rustpython-without-js/src/lib.rs
@@ -0,0 +1,59 @@
+use rustpython_vm::{Interpreter};
+
+unsafe extern "C" {
+    fn kv_get(kp: i32, kl: i32, vp: i32, vl: i32) -> i32;
+
+    /// kp and kl are the key pointer and length in wasm memory, vp and vl are for the value
+    fn kv_put(kp: i32, kl: i32, vp: i32, vl: i32) -> i32;
+
+    fn print(p: i32, l: i32) -> i32;
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> i32 {
+    // let src = unsafe { std::slice::from_raw_parts(s, l) };
+    // let src = std::str::from_utf8(src).unwrap();
+    // TODO: use src
+    let src = "1 + 3";
+
+    // 2. Execute Python code
+    let interpreter = Interpreter::without_stdlib(Default::default());
+    let result = interpreter.enter(|vm| {
+        let scope = vm.new_scope_with_builtins();
+        let res = match vm.run_block_expr(scope, src) {
+            Ok(val) => val,
+            Err(_) => return Err(-1), // Python execution error
+        };
+        let repr_str = match res.repr(vm) {
+            Ok(repr) => repr.as_str().to_string(),
+            Err(_) => return Err(-1), // Failed to get string representation
+        };
+        Ok(repr_str)
+    });
+    let result = match result {
+        Ok(r) => r,
+        Err(code) => return code,
+    };
+
+    let msg = format!("eval result: {result}");
+
+    unsafe {
+        print(
+            msg.as_str().as_ptr() as usize as i32,
+            msg.len() as i32,
+        )
+    };
+
+    0
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "Rust" fn __getrandom_v03_custom(
+    _dest: *mut u8,
+    _len: usize,
+) -> Result<(), getrandom::Error> {
+    // Err(getrandom::Error::UNSUPPORTED)
+
+    // WARNING: This function **MUST** perform proper getrandom
+    Ok(())
+}
diff --git a/example_projects/wasm32_without_js/wasm-runtime/.gitignore b/example_projects/wasm32_without_js/wasm-runtime/.gitignore
new file mode 100644
index 0000000000..2e2101b506
--- /dev/null
+++ b/example_projects/wasm32_without_js/wasm-runtime/.gitignore
@@ -0,0 +1,4 @@
+*.wasm
+target
+Cargo.lock
+!wasm/rustpython.wasm
diff --git a/example_projects/wasm32_without_js/wasm-runtime/Cargo.toml b/example_projects/wasm32_without_js/wasm-runtime/Cargo.toml
new file mode 100644
index 0000000000..a1d0de5171
--- /dev/null
+++ b/example_projects/wasm32_without_js/wasm-runtime/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "wasm-runtime"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+wasmer = "6.1.0"
+
+[workspace]
\ No newline at end of file
diff --git a/example_projects/wasm32_without_js/wasm-runtime/README.md b/example_projects/wasm32_without_js/wasm-runtime/README.md
new file mode 100644
index 0000000000..2fa2f9e119
--- /dev/null
+++ b/example_projects/wasm32_without_js/wasm-runtime/README.md
@@ -0,0 +1,19 @@
+# Simple WASM Runtime
+
+WebAssembly runtime POC with wasmer with HashMap-based KV store.
+First make sure to install wat2wasm and rust.
+
+```bash
+# following command installs rust
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+cargo run --release <wasm binary>
+```
+
+## WASM binary requirements
+
+Entry point is `eval(code_ptr: i32, code_len: i32) -> i32`, following are exported functions, on error return -1:
+
+- `kv_put(key_ptr: i32, key_len: i32, val_ptr: i32, val_len: i32) -> i32`
+- `kv_get(key_ptr: i32, key_len: i32, val_ptr: i32, val_len: i32) -> i32`
+- `print(msg_ptr: i32, msg_len: i32) -> i32`
diff --git a/example_projects/wasm32_without_js/wasm-runtime/src/main.rs b/example_projects/wasm32_without_js/wasm-runtime/src/main.rs
new file mode 100644
index 0000000000..8ca7d581ce
--- /dev/null
+++ b/example_projects/wasm32_without_js/wasm-runtime/src/main.rs
@@ -0,0 +1,133 @@
+use std::collections::HashMap;
+use wasmer::{
+    Function, FunctionEnv, FunctionEnvMut, Instance, Memory, Module, Store, Value, imports,
+};
+
+struct Ctx {
+    kv: HashMap<Vec<u8>, Vec<u8>>,
+    mem: Option<Memory>,
+}
+
+/// kp and kl are the key pointer and length in wasm memory, vp and vl are for the return value
+/// if read value is bigger than vl then it will be truncated to vl, returns read bytes
+fn kv_get(mut ctx: FunctionEnvMut<Ctx>, kp: i32, kl: i32, vp: i32, vl: i32) -> i32 {
+    let (c, s) = ctx.data_and_store_mut();
+    let mut key = vec![0u8; kl as usize];
+    if c.mem
+        .as_ref()
+        .unwrap()
+        .view(&s)
+        .read(kp as u64, &mut key)
+        .is_err()
+    {
+        return -1;
+    }
+    match c.kv.get(&key) {
+        Some(val) => {
+            let len = val.len().min(vl as usize);
+            if c.mem
+                .as_ref()
+                .unwrap()
+                .view(&s)
+                .write(vp as u64, &val[..len])
+                .is_err()
+            {
+                return -1;
+            }
+            len as i32
+        }
+        None => 0,
+    }
+}
+
+/// kp and kl are the key pointer and length in wasm memory, vp and vl are for the value
+fn kv_put(mut ctx: FunctionEnvMut<Ctx>, kp: i32, kl: i32, vp: i32, vl: i32) -> i32 {
+    let (c, s) = ctx.data_and_store_mut();
+    let mut key = vec![0u8; kl as usize];
+    let mut val = vec![0u8; vl as usize];
+    let m = c.mem.as_ref().unwrap().view(&s);
+    if m.read(kp as u64, &mut key).is_err() || m.read(vp as u64, &mut val).is_err() {
+        return -1;
+    }
+    c.kv.insert(key, val);
+    0
+}
+
+// // p and l are the buffer pointer and length in wasm memory.
+// fn get_code(mut ctx:FunctionEnvMut<Ctx>, p: i32, l: i32) -> i32 {
+//     let file_name = std::env::args().nth(2).expect("file_name is not given");
+//     let code : String = std::fs::read_to_string(file_name).expect("file read failed");
+//     if code.len() > l as usize {
+//         eprintln!("code is too long");
+//         return -1;
+//     }
+
+//     let (c, s) = ctx.data_and_store_mut();
+//     let m = c.mem.as_ref().unwrap().view(&s);
+//     if m.write(p as u64, code.as_bytes()).is_err() {
+//         return -2;
+//     }
+
+//     0
+// }
+
+// p and l are the message pointer and length in wasm memory.
+fn print(mut ctx: FunctionEnvMut<Ctx>, p: i32, l: i32) -> i32 {
+    let (c, s) = ctx.data_and_store_mut();
+    let mut msg = vec![0u8; l as usize];
+    let m = c.mem.as_ref().unwrap().view(&s);
+    if m.read(p as u64, &mut msg).is_err() {
+        return -1;
+    }
+    let s = std::str::from_utf8(&msg).expect("print got non-utf8 str");
+    println!("{s}");
+    0
+}
+
+fn main() {
+    let mut store = Store::default();
+    let module = Module::new(
+        &store,
+        &std::fs::read(&std::env::args().nth(1).unwrap()).unwrap(),
+    )
+    .unwrap();
+
+    // Prepare initial KV store with Python code
+    let mut initial_kv = HashMap::new();
+    initial_kv.insert(
+        b"code".to_vec(),
+        b"a=10;b='str';f'{a}{b}'".to_vec(), // Python code to execute
+    );
+
+    let env = FunctionEnv::new(
+        &mut store,
+        Ctx {
+            kv: initial_kv,
+            mem: None,
+        },
+    );
+    let imports = imports! {
+        "env" => {
+            "kv_get" => Function::new_typed_with_env(&mut store, &env, kv_get),
+            "kv_put" => Function::new_typed_with_env(&mut store, &env, kv_put),
+            // "get_code" => Function::new_typed_with_env(&mut store, &env, get_code),
+            "print" => Function::new_typed_with_env(&mut store, &env, print),
+        }
+    };
+    let inst = Instance::new(&mut store, &module, &imports).unwrap();
+    env.as_mut(&mut store).mem = inst.exports.get_memory("memory").ok().cloned();
+    let res = inst
+        .exports
+        .get_function("eval")
+        .unwrap()
+        // TODO: actually pass source code
+        .call(&mut store, &[wasmer::Value::I32(0), wasmer::Value::I32(0)])
+        .unwrap();
+    println!(
+        "Result: {}",
+        match res[0] {
+            Value::I32(v) => v,
+            _ => -1,
+        }
+    );
+}
diff --git a/examples/call_between_rust_and_python.rs b/examples/call_between_rust_and_python.rs
index 80bf65526a..dee1705847 100644
--- a/examples/call_between_rust_and_python.rs
+++ b/examples/call_between_rust_and_python.rs
@@ -89,7 +89,7 @@ python_person.name: {}",
     impl<'a> TryFromBorrowedObject<'a> for PythonPerson {
         fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
             let name = obj.get_attr("name", vm)?.try_into_value::<String>(vm)?;
-            Ok(PythonPerson { name })
+            Ok(Self { name })
         }
     }
 }
diff --git a/examples/dis.rs b/examples/dis.rs
index 504b734ca5..1ca350603f 100644
--- a/examples/dis.rs
+++ b/examples/dis.rs
@@ -9,9 +9,9 @@
 #[macro_use]
 extern crate log;
 
+use core::error::Error;
 use lexopt::ValueExt;
 use rustpython_compiler as compiler;
-use std::error::Error;
 use std::fs;
 use std::path::{Path, PathBuf};
 
@@ -53,7 +53,10 @@ fn main() -> Result<(), lexopt::Error> {
         return Err("expected at least one argument".into());
     }
 
-    let opts = compiler::CompileOpts { optimize };
+    let opts = compiler::CompileOpts {
+        optimize,
+        debug_ranges: true,
+    };
 
     for script in &scripts {
         if script.exists() && script.is_file() {
diff --git a/examples/generator.rs b/examples/generator.rs
index 937687ab8f..27733a1913 100644
--- a/examples/generator.rs
+++ b/examples/generator.rs
@@ -46,5 +46,5 @@ fn main() -> ExitCode {
         vm.add_native_modules(rustpython_stdlib::get_module_inits());
     });
     let result = py_main(&interp);
-    ExitCode::from(interp.run(|_vm| result))
+    vm::common::os::exit_code(interp.run(|_vm| result))
 }
diff --git a/examples/package_embed.rs b/examples/package_embed.rs
index 975e734593..e82e71f5ce 100644
--- a/examples/package_embed.rs
+++ b/examples/package_embed.rs
@@ -26,5 +26,5 @@ fn main() -> ExitCode {
     let result = result.map(|result| {
         println!("name: {result}");
     });
-    ExitCode::from(interp.run(|_vm| result))
+    vm::common::os::exit_code(interp.run(|_vm| result))
 }
diff --git a/extra_tests/custom_text_test_runner.py b/extra_tests/custom_text_test_runner.py
index 4c48e615c3..afec493a66 100644
--- a/extra_tests/custom_text_test_runner.py
+++ b/extra_tests/custom_text_test_runner.py
@@ -25,16 +25,17 @@
 # SOFTWARE.
 
 
-import unittest
-import os, sys, traceback
 import inspect
 import json
-import time
-import re
 import operator
-from unittest.runner import result
-from unittest.runner import registerResult
+import os
+import re
+import sys
+import time
+import traceback
+import unittest
 from functools import reduce
+from unittest.runner import registerResult, result
 
 
 class TablePrinter(object):
@@ -111,7 +112,7 @@ def __call__(self, data_list, totals=None):
 
 def get_function_args(func_ref):
     try:
-        return [p for p in inspect.getargspec(func_ref).args if p != "self"]
+        return [p for p in inspect.getfullargspec(func_ref).args if p != "self"]
     except:
         return None
 
diff --git a/extra_tests/jsontests.py b/extra_tests/jsontests.py
index a54fd4234e..f3213ac09d 100644
--- a/extra_tests/jsontests.py
+++ b/extra_tests/jsontests.py
@@ -1,8 +1,8 @@
-import unittest
-from custom_text_test_runner import CustomTextTestRunner as Runner
-from test.libregrtest.runtest import findtests
 import os
+import unittest
 
+from custom_text_test_runner import CustomTextTestRunner as Runner
+from test.libregrtest.findtests import findtests
 
 testnames = findtests()
 # idk why this fixes the hanging, if it does
diff --git a/extra_tests/snippets/builtin___main__.py b/extra_tests/snippets/builtin___main__.py
new file mode 100644
index 0000000000..97e76ce324
--- /dev/null
+++ b/extra_tests/snippets/builtin___main__.py
@@ -0,0 +1,5 @@
+import sys
+
+main_module = sys.modules["__main__"]
+assert main_module.__file__.endswith("builtin___main__.py")
+assert main_module.__cached__ is None
diff --git a/extra_tests/snippets/builtin_all.py b/extra_tests/snippets/builtin_all.py
index cf0eea3932..ba11ce0de9 100644
--- a/extra_tests/snippets/builtin_all.py
+++ b/extra_tests/snippets/builtin_all.py
@@ -1,5 +1,4 @@
-from testutils import assert_raises
-from testutils import TestFailingBool, TestFailingIter
+from testutils import TestFailingBool, TestFailingIter, assert_raises
 
 assert all([True])
 assert not all([False])
diff --git a/extra_tests/snippets/builtin_any.py b/extra_tests/snippets/builtin_any.py
index 59b4514f85..11b47d1f08 100644
--- a/extra_tests/snippets/builtin_any.py
+++ b/extra_tests/snippets/builtin_any.py
@@ -1,5 +1,4 @@
-from testutils import assert_raises
-from testutils import TestFailingBool, TestFailingIter
+from testutils import TestFailingBool, TestFailingIter, assert_raises
 
 assert any([True])
 assert not any([False])
diff --git a/extra_tests/snippets/builtin_bytearray.py b/extra_tests/snippets/builtin_bytearray.py
index 1a6993e205..0b7e419390 100644
--- a/extra_tests/snippets/builtin_bytearray.py
+++ b/extra_tests/snippets/builtin_bytearray.py
@@ -1,7 +1,8 @@
-from testutils import assert_raises
 import pickle
 import sys
 
+from testutils import assert_raises
+
 # new
 assert bytearray([1, 2, 3])
 assert bytearray((1, 2, 3))
diff --git a/extra_tests/snippets/builtin_bytes.py b/extra_tests/snippets/builtin_bytes.py
index 9347fbc8fa..4cb743baa6 100644
--- a/extra_tests/snippets/builtin_bytes.py
+++ b/extra_tests/snippets/builtin_bytes.py
@@ -1,3 +1,5 @@
+import sys
+
 from testutils import assert_raises, skip_if_unsupported
 
 # new
@@ -611,6 +613,9 @@
 assert b"\xc2\xae\x75\x73\x74".decode() == "®ust"
 assert b"\xe4\xb8\xad\xe6\x96\x87\xe5\xad\x97".decode("utf-8") == "中文字"
 
+# gh-2391
+assert b"-\xff".decode(sys.getfilesystemencoding(), "surrogateescape") == "-\udcff"
+
 # mod
 assert b"rust%bpython%b" % (b" ", b"!") == b"rust python!"
 assert b"x=%i y=%f" % (1, 2.5) == b"x=1 y=2.500000"
diff --git a/extra_tests/snippets/builtin_exceptions.py b/extra_tests/snippets/builtin_exceptions.py
index 82aa54d632..246be3b8fd 100644
--- a/extra_tests/snippets/builtin_exceptions.py
+++ b/extra_tests/snippets/builtin_exceptions.py
@@ -1,6 +1,6 @@
 import builtins
-import platform
 import pickle
+import platform
 import sys
 
 
@@ -85,6 +85,13 @@ def __init__(self, value):
 assert exc.offset is None
 assert exc.text is None
 
+err = SyntaxError("bad bad", ("bad.py", 1, 2, "abcdefg"))
+err.msg = "changed"
+assert err.msg == "changed"
+assert str(err) == "changed (bad.py, line 1)"
+del err.msg
+assert err.msg is None
+
 # Regression to:
 # https://github.com/RustPython/RustPython/issues/2779
 
@@ -359,3 +366,15 @@ class SubError(MyError):
     vars(builtins).values(),
 ):
     assert isinstance(exc.__doc__, str)
+
+
+# except* handling should normalize non-group exceptions
+try:
+    raise ValueError("x")
+except* ValueError as err:
+    assert isinstance(err, ExceptionGroup)
+    assert len(err.exceptions) == 1
+    assert isinstance(err.exceptions[0], ValueError)
+    assert err.exceptions[0].args == ("x",)
+else:
+    assert False, "except* handler did not run"
diff --git a/extra_tests/snippets/builtin_format.py b/extra_tests/snippets/builtin_format.py
index 457adaa136..a5edcc8952 100644
--- a/extra_tests/snippets/builtin_format.py
+++ b/extra_tests/snippets/builtin_format.py
@@ -81,6 +81,9 @@ def test_zero_padding():
 assert f"{123.456:+011,}" == "+00,123.456"
 assert f"{1234:.3g}" == "1.23e+03"
 assert f"{1234567:.6G}" == "1.23457E+06"
+assert f"{1234:10}" == "      1234"
+assert f"{1234:10,}" == "     1,234"
+assert f"{1234:010,}" == "00,001,234"
 assert f"{'🐍':4}" == "🐍   "
 assert_raises(
     ValueError, "{:,o}".format, 1, _msg="ValueError: Cannot specify ',' with 'o'."
@@ -165,6 +168,9 @@ def test_zero_padding():
 assert f"{3.1415:#.2}" == "3.1"
 assert f"{3.1415:#.3}" == "3.14"
 assert f"{3.1415:#.4}" == "3.142"
+assert f"{1234.5:10}" == "    1234.5"
+assert f"{1234.5:10,}" == "   1,234.5"
+assert f"{1234.5:010,}" == "0,001,234.5"
 assert f"{12.34 + 5.6j}" == "(12.34+5.6j)"
 assert f"{12.34 - 5.6j: }" == "( 12.34-5.6j)"
 assert f"{12.34 + 5.6j:20}" == "        (12.34+5.6j)"
@@ -182,6 +188,11 @@ def test_zero_padding():
 assert f"{12345.6 + 7890.1j:,}" == "(12,345.6+7,890.1j)"
 assert f"{12345.6 + 7890.1j:_.3f}" == "12_345.600+7_890.100j"
 assert f"{12345.6 + 7890.1j:>+30,f}" == "  +12,345.600000+7,890.100000j"
+assert f"{123456:,g}" == "123,456"
+assert f"{123456:,G}" == "123,456"
+assert f"{123456:,e}" == "1.234560e+05"
+assert f"{123456:,E}" == "1.234560E+05"
+assert f"{123456:,%}" == "12,345,600.000000%"
 
 # test issue 4558
 x = 123456789012345678901234567890
diff --git a/extra_tests/snippets/builtin_hash.py b/extra_tests/snippets/builtin_hash.py
index 96ccc46ba8..9b2c838879 100644
--- a/extra_tests/snippets/builtin_hash.py
+++ b/extra_tests/snippets/builtin_hash.py
@@ -12,6 +12,14 @@ class A:
 assert type(hash(1.1)) is int
 assert type(hash("")) is int
 
+
+class Evil:
+    def __hash__(self):
+        return 1 << 63
+
+
+assert hash(Evil()) == 4
+
 with assert_raises(TypeError):
     hash({})
 
diff --git a/extra_tests/snippets/builtin_posixshmem.py b/extra_tests/snippets/builtin_posixshmem.py
new file mode 100644
index 0000000000..38ace68d58
--- /dev/null
+++ b/extra_tests/snippets/builtin_posixshmem.py
@@ -0,0 +1,12 @@
+import os
+import sys
+
+if os.name != "posix":
+    sys.exit(0)
+
+import _posixshmem
+
+name = f"/rp_posixshmem_{os.getpid()}"
+fd = _posixshmem.shm_open(name, os.O_CREAT | os.O_EXCL | os.O_RDWR, 0o600)
+os.close(fd)
+_posixshmem.shm_unlink(name)
diff --git a/extra_tests/snippets/builtin_pow.py b/extra_tests/snippets/builtin_pow.py
index c769914231..d38b57c37a 100644
--- a/extra_tests/snippets/builtin_pow.py
+++ b/extra_tests/snippets/builtin_pow.py
@@ -1,4 +1,4 @@
-from testutils import assert_raises, assert_equal
+from testutils import assert_equal, assert_raises
 
 assert pow(3, 2) == 9
 assert pow(5, 3, 100) == 25
diff --git a/extra_tests/snippets/builtin_print.py b/extra_tests/snippets/builtin_print.py
index b9f3b8cc17..2778cff65a 100644
--- a/extra_tests/snippets/builtin_print.py
+++ b/extra_tests/snippets/builtin_print.py
@@ -1,6 +1,7 @@
-from testutils import assert_raises
 import io
 
+from testutils import assert_raises
+
 print(2 + 3)
 
 assert_raises(TypeError, print, "test", end=4, _msg="wrong type passed to end")
diff --git a/extra_tests/snippets/builtin_set.py b/extra_tests/snippets/builtin_set.py
index 1b2f6ff096..950875ea09 100644
--- a/extra_tests/snippets/builtin_set.py
+++ b/extra_tests/snippets/builtin_set.py
@@ -200,6 +200,18 @@ class S(set):
 with assert_raises(TypeError):
     a &= [1, 2, 3]
 
+a = set([1, 2, 3])
+a &= a
+assert a == set([1, 2, 3])
+
+a = set([1, 2, 3])
+a -= a
+assert a == set()
+
+a = set([1, 2, 3])
+a ^= a
+assert a == set()
+
 a = set([1, 2, 3])
 a.difference_update([3, 4, 5])
 assert a == set([1, 2])
diff --git a/extra_tests/snippets/builtin_str.py b/extra_tests/snippets/builtin_str.py
index 1b9a7bde1a..415156184c 100644
--- a/extra_tests/snippets/builtin_str.py
+++ b/extra_tests/snippets/builtin_str.py
@@ -1,4 +1,4 @@
-from testutils import assert_raises, AssertRaises, skip_if_unsupported
+from testutils import AssertRaises, assert_raises, skip_if_unsupported
 
 assert "".__eq__(1) == NotImplemented
 assert "a" == "a"
diff --git a/extra_tests/snippets/builtin_type.py b/extra_tests/snippets/builtin_type.py
index 923028f2cd..8cb0a09a21 100644
--- a/extra_tests/snippets/builtin_type.py
+++ b/extra_tests/snippets/builtin_type.py
@@ -1,6 +1,6 @@
 import types
-from testutils import assert_raises
 
+from testutils import assert_raises
 
 # Spec: https://docs.python.org/2/library/types.html
 print(None)
@@ -72,6 +72,15 @@
 assert object.__qualname__ == "object"
 assert int.__qualname__ == "int"
 
+with assert_raises(TypeError):
+    type.__module__ = "nope"
+
+with assert_raises(TypeError):
+    object.__module__ = "nope"
+
+with assert_raises(TypeError):
+    map.__module__ = "nope"
+
 
 class A(type):
     pass
@@ -111,8 +120,6 @@ class D:
 with assert_raises(TypeError):
     del int.__qualname__
 
-from testutils import assert_raises
-
 import platform
 
 if platform.python_implementation() == "RustPython":
@@ -233,6 +240,56 @@ class C(B, BB):
 assert C.mro() == [C, B, A, BB, AA, object]
 
 
+class TypeA:
+    def __init__(self):
+        self.a = 1
+
+
+class TypeB:
+    __slots__ = "b"
+
+    def __init__(self):
+        self.b = 2
+
+
+obj = TypeA()
+with assert_raises(TypeError) as cm:
+    obj.__class__ = TypeB
+assert "__class__ assignment: 'TypeB' object layout differs from 'TypeA'" in str(
+    cm.exception
+)
+
+
+# Test: same slot count but different slot names should fail
+class SlotX:
+    __slots__ = ("x",)
+
+
+class SlotY:
+    __slots__ = ("y",)
+
+
+slot_obj = SlotX()
+with assert_raises(TypeError) as cm:
+    slot_obj.__class__ = SlotY
+assert "__class__ assignment: 'SlotY' object layout differs from 'SlotX'" in str(
+    cm.exception
+)
+
+
+# Test: same slots should succeed
+class SlotA:
+    __slots__ = ("a",)
+
+
+class SlotA2:
+    __slots__ = ("a",)
+
+
+slot_a = SlotA()
+slot_a.__class__ = SlotA2  # Should work
+
+
 assert type(Exception.args).__name__ == "getset_descriptor"
 assert type(None).__bool__(None) is False
 
@@ -527,6 +584,7 @@ def __new__(cls, *args, **kwargs):
 assert ClassWithNew().__new__.__qualname__ == "ClassWithNew.__new__"
 assert ClassWithNew.__new__.__name__ == "__new__"
 assert ClassWithNew().__new__.__name__ == "__new__"
+assert isinstance(ClassWithNew.__dict__.get("__new__"), staticmethod)
 
 assert ClassWithNew.N.__new__.__qualname__ == "ClassWithNew.N.__new__"
 assert ClassWithNew().N.__new__.__qualname__ == "ClassWithNew.N.__new__"
@@ -536,6 +594,7 @@ def __new__(cls, *args, **kwargs):
 assert ClassWithNew().N().__new__.__qualname__ == "ClassWithNew.N.__new__"
 assert ClassWithNew.N().__new__.__name__ == "__new__"
 assert ClassWithNew().N().__new__.__name__ == "__new__"
+assert isinstance(ClassWithNew.N.__dict__.get("__new__"), staticmethod)
 
 
 # Regression to:
@@ -595,3 +654,36 @@ def my_repr_func():
 
 # https://github.com/RustPython/RustPython/issues/3100
 assert issubclass(types.BuiltinMethodType, types.BuiltinFunctionType)
+
+assert type.__dict__["__dict__"].__objclass__ is type
+assert (
+    type(type(type.__dict__["__dict__"]).__objclass__).__name__ == "member_descriptor"
+)
+
+
+class A(type):
+    pass
+
+
+assert "__dict__" not in A.__dict__
+
+
+# regression tests for: https://github.com/RustPython/RustPython/issues/4505
+
+
+def foo():
+    def inner():
+        pass
+
+
+assert foo.__code__.co_names == ()
+
+stmts = """
+import blah
+
+def foo():
+    pass
+"""
+
+code = compile(stmts, "<test>", "exec")
+assert code.co_names == ("blah", "foo")
diff --git a/extra_tests/snippets/builtins_module.py b/extra_tests/snippets/builtins_module.py
index 6dea94d8d7..bf762425c8 100644
--- a/extra_tests/snippets/builtins_module.py
+++ b/extra_tests/snippets/builtins_module.py
@@ -22,6 +22,17 @@
 exec("", namespace)
 assert namespace["__builtins__"] == __builtins__.__dict__
 
+
+# function.__builtins__ should be a dict, not a module
+# See: https://docs.python.org/3/reference/datamodel.html
+def test_func():
+    pass
+
+
+assert isinstance(test_func.__builtins__, dict), (
+    f"function.__builtins__ should be dict, got {type(test_func.__builtins__)}"
+)
+
 # with assert_raises(NameError):
 #     exec('print(__builtins__)', {'__builtins__': {}})
 
diff --git a/extra_tests/snippets/dir_module/__init__.py b/extra_tests/snippets/dir_module/__init__.py
index 5d9faff33d..7408005f54 100644
--- a/extra_tests/snippets/dir_module/__init__.py
+++ b/extra_tests/snippets/dir_module/__init__.py
@@ -1,2 +1,2 @@
-from .relative import value
 from .dir_module_inner import value2
+from .relative import value
diff --git a/extra_tests/snippets/forbidden_instantiation.py b/extra_tests/snippets/forbidden_instantiation.py
index 904c5c6f08..50b6f58f07 100644
--- a/extra_tests/snippets/forbidden_instantiation.py
+++ b/extra_tests/snippets/forbidden_instantiation.py
@@ -1,18 +1,19 @@
-from typing import Type
 from types import (
-    GeneratorType,
-    CoroutineType,
     AsyncGeneratorType,
     BuiltinFunctionType,
     BuiltinMethodType,
-    WrapperDescriptorType,
-    MethodWrapperType,
-    MethodDescriptorType,
     ClassMethodDescriptorType,
+    CoroutineType,
     FrameType,
+    GeneratorType,
     GetSetDescriptorType,
     MemberDescriptorType,
+    MethodDescriptorType,
+    MethodWrapperType,
+    WrapperDescriptorType,
 )
+from typing import Type
+
 from testutils import assert_raises
 
 
diff --git a/extra_tests/snippets/import.py b/extra_tests/snippets/import.py
index 466e1315ac..435e622418 100644
--- a/extra_tests/snippets/import.py
+++ b/extra_tests/snippets/import.py
@@ -1,9 +1,10 @@
-import import_target, import_target as aliased
-from import_target import func, other_func
-from import_target import func as aliased_func, other_func as aliased_other_func
-from import_star import *
-
 import import_mutual1
+import import_target
+import import_target as aliased
+from import_star import *
+from import_target import func, other_func
+from import_target import func as aliased_func
+from import_target import other_func as aliased_other_func
 
 assert import_target.X == import_target.func()
 assert import_target.X == func()
diff --git a/extra_tests/snippets/protocol_index_bad.py b/extra_tests/snippets/protocol_index_bad.py
index d4ac003c85..51d9042602 100644
--- a/extra_tests/snippets/protocol_index_bad.py
+++ b/extra_tests/snippets/protocol_index_bad.py
@@ -1,9 +1,10 @@
 """Test that indexing ops don't hang when an object with a mutating
 __index__ is used."""
 
-from testutils import assert_raises
 from array import array
 
+from testutils import assert_raises
+
 
 class BadIndex:
     def __index__(self):
diff --git a/extra_tests/snippets/stdlib_array.py b/extra_tests/snippets/stdlib_array.py
index a31b2f8e42..ed2a8f2236 100644
--- a/extra_tests/snippets/stdlib_array.py
+++ b/extra_tests/snippets/stdlib_array.py
@@ -1,7 +1,8 @@
-from testutils import assert_raises
 from array import array
 from pickle import dumps, loads
 
+from testutils import assert_raises
+
 a1 = array("b", [0, 1, 2, 3])
 
 assert a1.tobytes() == b"\x00\x01\x02\x03"
@@ -125,3 +126,20 @@ def test_array_frombytes():
 a = array("B", [0])
 assert a.__contains__(0)
 assert not a.__contains__(1)
+
+
+class _ReenteringWriter:
+    def __init__(self, arr):
+        self.arr = arr
+        self.reentered = False
+
+    def write(self, chunk):
+        if not self.reentered:
+            self.reentered = True
+            self.arr.append(0)
+        return len(chunk)
+
+
+arr = array("b", range(128))
+arr.tofile(_ReenteringWriter(arr))
+assert len(arr) == 129
diff --git a/extra_tests/snippets/stdlib_binascii.py b/extra_tests/snippets/stdlib_binascii.py
index 5dcb5a0322..c4c2121fa4 100644
--- a/extra_tests/snippets/stdlib_binascii.py
+++ b/extra_tests/snippets/stdlib_binascii.py
@@ -1,6 +1,6 @@
 import binascii
-from testutils import assert_raises, assert_equal
 
+from testutils import assert_equal, assert_raises
 
 # hexlify tests
 h = binascii.hexlify
diff --git a/extra_tests/snippets/stdlib_collections.py b/extra_tests/snippets/stdlib_collections.py
index 8fd7cb6a88..8a9bdb4533 100644
--- a/extra_tests/snippets/stdlib_collections.py
+++ b/extra_tests/snippets/stdlib_collections.py
@@ -1,6 +1,5 @@
 from collections import deque
 
-
 d = deque([0, 1, 2])
 
 d.append(1)
diff --git a/extra_tests/snippets/stdlib_collections_deque.py b/extra_tests/snippets/stdlib_collections_deque.py
index 86e566f418..25b2069f6e 100644
--- a/extra_tests/snippets/stdlib_collections_deque.py
+++ b/extra_tests/snippets/stdlib_collections_deque.py
@@ -1,7 +1,8 @@
-from testutils import assert_raises
 from collections import deque
 from typing import Deque
 
+from testutils import assert_raises
+
 
 def test_deque_iterator__new__():
     klass = type(iter(deque()))
diff --git a/extra_tests/snippets/stdlib_csv.py b/extra_tests/snippets/stdlib_csv.py
index f762c58010..eb3461e908 100644
--- a/extra_tests/snippets/stdlib_csv.py
+++ b/extra_tests/snippets/stdlib_csv.py
@@ -1,7 +1,7 @@
-from testutils import assert_raises
-
 import csv
 
+from testutils import assert_raises
+
 for row in csv.reader(["one,two,three"]):
     [one, two, three] = row
     assert one == "one"
diff --git a/extra_tests/snippets/stdlib_ctypes.py b/extra_tests/snippets/stdlib_ctypes.py
index 32ed17d19f..0a5d1387a8 100644
--- a/extra_tests/snippets/stdlib_ctypes.py
+++ b/extra_tests/snippets/stdlib_ctypes.py
@@ -1,14 +1,10 @@
-import os as _os, sys as _sys
+import os as _os
+import sys as _sys
 import types as _types
-
-from _ctypes import RTLD_LOCAL, RTLD_GLOBAL
-from _ctypes import sizeof
-from _ctypes import _SimpleCData, Array
+from _ctypes import RTLD_GLOBAL, RTLD_LOCAL, Array, _SimpleCData, sizeof
 from _ctypes import CFuncPtr as _CFuncPtr
-
 from struct import calcsize as _calcsize
 
-
 assert Array.__class__.__name__ == "PyCArrayType"
 assert Array.__base__.__name__ == "_CData"
 
@@ -24,8 +20,14 @@
 
 from _ctypes import (
     FUNCFLAG_CDECL as _FUNCFLAG_CDECL,
+)
+from _ctypes import (
     FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI,
+)
+from _ctypes import (
     FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO,
+)
+from _ctypes import (
     FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR,
 )
 
@@ -40,7 +42,6 @@ def create_string_buffer(init, size=None):
             size = len(init) + 1
         _sys.audit("ctypes.create_string_buffer", init, size)
         buftype = c_char.__mul__(size)
-        print(type(c_char.__mul__(size)))
         # buftype = c_char * size
         buf = buftype()
         buf.value = init
@@ -211,8 +212,8 @@ class c_bool(_SimpleCData):
 assert abs(f.value - 3.14) < 1e-06
 
 if _os.name == "nt":
-    from _ctypes import LoadLibrary as _dlopen
     from _ctypes import FUNCFLAG_STDCALL as _FUNCFLAG_STDCALL
+    from _ctypes import LoadLibrary as _dlopen
 elif _os.name == "posix":
     from _ctypes import dlopen as _dlopen
 
@@ -334,8 +335,14 @@ def LoadLibrary(self, name):
 test_byte_array = create_string_buffer(b"Hello, World!\n")
 assert test_byte_array._length_ == 15
 
-if _os.name == "posix" or _sys.platform == "darwin":
-    pass
+if _os.name == "posix":
+    if _sys.platform == "darwin":
+        libc = cdll.LoadLibrary("libc.dylib")
+        libc.rand()
+        i = c_int(1)
+        # print("start srand")
+        # print(libc.srand(i))
+        # print(test_byte_array)
 else:
     import os
 
@@ -343,9 +350,9 @@ def LoadLibrary(self, name):
     libc.rand()
     i = c_int(1)
     print("start srand")
-    print(libc.srand(i))
-    print(test_byte_array)
-    print(test_byte_array._type_)
+    # print(libc.srand(i))
+    # print(test_byte_array)
+    # print(test_byte_array._type_)
     # print("start printf")
     # libc.printf(test_byte_array)
 
@@ -390,3 +397,5 @@ def get_win_folder_via_ctypes(csidl_name: str) -> str:
         return buf.value
 
     # print(get_win_folder_via_ctypes("CSIDL_DOWNLOADS"))
+
+print("done")
diff --git a/extra_tests/snippets/stdlib_datetime.py b/extra_tests/snippets/stdlib_datetime.py
index 60e8049401..57ffd3a441 100644
--- a/extra_tests/snippets/stdlib_datetime.py
+++ b/extra_tests/snippets/stdlib_datetime.py
@@ -4,27 +4,20 @@
 """
 
 # import copy
-import sys
-import random
-
-from operator import lt, le, gt, ge, eq, ne, truediv, floordiv, mod
-
 import datetime as datetime_module
-from datetime import MINYEAR, MAXYEAR
-from datetime import timedelta
-from datetime import tzinfo
-from datetime import time
-from datetime import timezone
-from datetime import date, datetime
+import random
+import sys
 import time as _time
+from datetime import MAXYEAR, MINYEAR, date, datetime, time, timedelta, timezone, tzinfo
+from operator import eq, floordiv, ge, gt, le, lt, mod, ne, truediv
 
 from testutils import (
-    assert_raises,
     assert_equal,
-    assert_true,
     assert_false,
-    assert_isinstance,
     assert_in,
+    assert_isinstance,
+    assert_raises,
+    assert_true,
 )
 
 # An arbitrary collection of objects of non-datetime types, for testing
diff --git a/extra_tests/snippets/stdlib_dir_module.py b/extra_tests/snippets/stdlib_dir_module.py
index a8ab233f37..db00055c7c 100644
--- a/extra_tests/snippets/stdlib_dir_module.py
+++ b/extra_tests/snippets/stdlib_dir_module.py
@@ -1,6 +1,5 @@
-from testutils import assert_equal
-
 import dir_module
+from testutils import assert_equal
 
 assert dir_module.value == 5
 assert dir_module.value2 == 7
diff --git a/extra_tests/snippets/stdlib_functools.py b/extra_tests/snippets/stdlib_functools.py
index 3d323bfbad..d3e2495e8a 100644
--- a/extra_tests/snippets/stdlib_functools.py
+++ b/extra_tests/snippets/stdlib_functools.py
@@ -1,4 +1,5 @@
 from functools import reduce
+
 from testutils import assert_raises
 
 
diff --git a/extra_tests/snippets/stdlib_io.py b/extra_tests/snippets/stdlib_io.py
index 011bb051c2..722886d34e 100644
--- a/extra_tests/snippets/stdlib_io.py
+++ b/extra_tests/snippets/stdlib_io.py
@@ -1,5 +1,6 @@
-from io import BufferedReader, FileIO, StringIO, BytesIO
 import os
+from io import BufferedReader, BytesIO, FileIO, StringIO
+
 from testutils import assert_raises
 
 fi = FileIO("README.md")
diff --git a/extra_tests/snippets/stdlib_itertools.py b/extra_tests/snippets/stdlib_itertools.py
index 31d8adbfd1..4d2e9f6e1f 100644
--- a/extra_tests/snippets/stdlib_itertools.py
+++ b/extra_tests/snippets/stdlib_itertools.py
@@ -1,9 +1,8 @@
 import itertools
+import pickle
 
 from testutils import assert_raises
 
-import pickle
-
 # itertools.chain tests
 chain = itertools.chain
 
diff --git a/extra_tests/snippets/stdlib_json.py b/extra_tests/snippets/stdlib_json.py
index ca35c2c2b2..758cd129cd 100644
--- a/extra_tests/snippets/stdlib_json.py
+++ b/extra_tests/snippets/stdlib_json.py
@@ -1,6 +1,7 @@
-from testutils import assert_raises
 import json
-from io import StringIO, BytesIO
+from io import BytesIO, StringIO
+
+from testutils import assert_raises
 
 
 def round_trip_test(obj):
diff --git a/extra_tests/snippets/stdlib_marshal.py b/extra_tests/snippets/stdlib_marshal.py
index c5fb1e533e..db843ff65d 100644
--- a/extra_tests/snippets/stdlib_marshal.py
+++ b/extra_tests/snippets/stdlib_marshal.py
@@ -1,5 +1,5 @@
-import unittest
 import marshal
+import unittest
 
 
 class MarshalTests(unittest.TestCase):
diff --git a/extra_tests/snippets/stdlib_math.py b/extra_tests/snippets/stdlib_math.py
index 090de710ed..a6bb0099c0 100644
--- a/extra_tests/snippets/stdlib_math.py
+++ b/extra_tests/snippets/stdlib_math.py
@@ -1,4 +1,5 @@
 import math
+
 from testutils import assert_raises, skip_if_unsupported
 
 NAN = float("nan")
diff --git a/extra_tests/snippets/stdlib_os.py b/extra_tests/snippets/stdlib_os.py
index f5d26030a4..d00924e10f 100644
--- a/extra_tests/snippets/stdlib_os.py
+++ b/extra_tests/snippets/stdlib_os.py
@@ -1,7 +1,7 @@
 import os
-import time
 import stat
 import sys
+import time
 
 from testutils import assert_raises
 
@@ -518,3 +518,13 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             if option in ["PC_MAX_CANON", "PC_MAX_INPUT", "PC_VDISABLE"]:
                 continue
         assert os.pathconf("/", index) == os.pathconf("/", option)
+
+# os.access - test with empty path and nonexistent files
+assert os.access("", os.F_OK) is False
+assert os.access("", os.R_OK) is False
+assert os.access("", os.W_OK) is False
+assert os.access("", os.X_OK) is False
+assert os.access("nonexistent_file_12345", os.F_OK) is False
+assert os.access("nonexistent_file_12345", os.W_OK) is False
+assert os.access("README.md", os.F_OK) is True
+assert os.access("README.md", os.R_OK) is True
diff --git a/extra_tests/snippets/stdlib_pwd.py b/extra_tests/snippets/stdlib_pwd.py
index 2a44aed32c..c3aeb7c870 100644
--- a/extra_tests/snippets/stdlib_pwd.py
+++ b/extra_tests/snippets/stdlib_pwd.py
@@ -4,9 +4,10 @@
 if sys.platform.startswith("win"):
     exit(0)
 
-from testutils import assert_raises
 import pwd
 
+from testutils import assert_raises
+
 with assert_raises(KeyError):
     fake_name = "fake_user"
     while pwd.getpwnam(fake_name):
diff --git a/extra_tests/snippets/stdlib_select.py b/extra_tests/snippets/stdlib_select.py
index fe246db99b..d27bb82b1c 100644
--- a/extra_tests/snippets/stdlib_select.py
+++ b/extra_tests/snippets/stdlib_select.py
@@ -1,8 +1,8 @@
-from testutils import assert_raises
-
 import select
-import sys
 import socket
+import sys
+
+from testutils import assert_raises
 
 
 class Nope:
diff --git a/extra_tests/snippets/stdlib_signal.py b/extra_tests/snippets/stdlib_signal.py
index 0abfd7cb71..9d0b13bbd6 100644
--- a/extra_tests/snippets/stdlib_signal.py
+++ b/extra_tests/snippets/stdlib_signal.py
@@ -1,6 +1,7 @@
 import signal
-import time
 import sys
+import time
+
 from testutils import assert_raises
 
 assert_raises(TypeError, lambda: signal.signal(signal.SIGINT, 2))
diff --git a/extra_tests/snippets/stdlib_socket.py b/extra_tests/snippets/stdlib_socket.py
index 199ff9fe47..b49fdcf08c 100644
--- a/extra_tests/snippets/stdlib_socket.py
+++ b/extra_tests/snippets/stdlib_socket.py
@@ -1,6 +1,7 @@
 import _socket
-import socket
 import os
+import socket
+
 from testutils import assert_raises
 
 assert _socket.socket == _socket.SocketType
diff --git a/extra_tests/snippets/stdlib_string.py b/extra_tests/snippets/stdlib_string.py
index ae544f3289..02bfc95c2d 100644
--- a/extra_tests/snippets/stdlib_string.py
+++ b/extra_tests/snippets/stdlib_string.py
@@ -1,6 +1,5 @@
 import string
 
-
 assert string.ascii_letters == "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 assert string.ascii_lowercase == "abcdefghijklmnopqrstuvwxyz"
 assert string.ascii_uppercase == "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
diff --git a/extra_tests/snippets/stdlib_struct.py b/extra_tests/snippets/stdlib_struct.py
index 1e08d0a223..3f97f2519c 100644
--- a/extra_tests/snippets/stdlib_struct.py
+++ b/extra_tests/snippets/stdlib_struct.py
@@ -1,6 +1,7 @@
-from testutils import assert_raises
 import struct
 
+from testutils import assert_raises
+
 data = struct.pack("IH", 14, 12)
 assert data == bytes([14, 0, 0, 0, 12, 0])
 
diff --git a/extra_tests/snippets/stdlib_subprocess.py b/extra_tests/snippets/stdlib_subprocess.py
index a2aa026f4c..014011ea14 100644
--- a/extra_tests/snippets/stdlib_subprocess.py
+++ b/extra_tests/snippets/stdlib_subprocess.py
@@ -1,7 +1,7 @@
+import signal
 import subprocess
-import time
 import sys
-import signal
+import time
 
 from testutils import assert_raises
 
diff --git a/extra_tests/snippets/stdlib_sys.py b/extra_tests/snippets/stdlib_sys.py
index a3e9367c52..155fc905a7 100644
--- a/extra_tests/snippets/stdlib_sys.py
+++ b/extra_tests/snippets/stdlib_sys.py
@@ -1,6 +1,6 @@
-import sys
 import os
 import subprocess
+import sys
 
 from testutils import assert_raises
 
diff --git a/extra_tests/snippets/stdlib_types.py b/extra_tests/snippets/stdlib_types.py
index 3a3872d2f4..14028268f0 100644
--- a/extra_tests/snippets/stdlib_types.py
+++ b/extra_tests/snippets/stdlib_types.py
@@ -1,3 +1,5 @@
+import _ast
+import platform
 import types
 
 from testutils import assert_raises
@@ -8,3 +10,31 @@
 assert ns.b == "Rust"
 with assert_raises(AttributeError):
     _ = ns.c
+
+
+def _run_missing_type_params_regression():
+    args = _ast.arguments(
+        posonlyargs=[],
+        args=[],
+        vararg=None,
+        kwonlyargs=[],
+        kw_defaults=[],
+        kwarg=None,
+        defaults=[],
+    )
+    fn = _ast.FunctionDef("f", args, [], [], None, None)
+    fn.lineno = 1
+    fn.col_offset = 0
+    fn.end_lineno = 1
+    fn.end_col_offset = 0
+    mod = _ast.Module([fn], [])
+    mod.lineno = 1
+    mod.col_offset = 0
+    mod.end_lineno = 1
+    mod.end_col_offset = 0
+    compiled = compile(mod, "<stdlib_types_missing_type_params>", "exec")
+    exec(compiled, {})
+
+
+if platform.python_implementation() == "RustPython":
+    _run_missing_type_params_regression()
diff --git a/extra_tests/snippets/stdlib_typing.py b/extra_tests/snippets/stdlib_typing.py
index ddc30b6846..681790abd0 100644
--- a/extra_tests/snippets/stdlib_typing.py
+++ b/extra_tests/snippets/stdlib_typing.py
@@ -8,3 +8,7 @@ def abort_signal_handler(
     fn: Callable[[], Awaitable[T]], on_abort: Callable[[], None] | None = None
 ) -> T:
     pass
+
+
+# Ensure PEP 604 unions work with typing.Callable aliases.
+TracebackFilter = bool | Callable[[int], int]
diff --git a/extra_tests/snippets/stdlib_weakref.py b/extra_tests/snippets/stdlib_weakref.py
index 059ddd0000..17762addca 100644
--- a/extra_tests/snippets/stdlib_weakref.py
+++ b/extra_tests/snippets/stdlib_weakref.py
@@ -1,4 +1,5 @@
-from _weakref import ref, proxy
+from _weakref import proxy, ref
+
 from testutils import assert_raises
 
 
diff --git a/extra_tests/snippets/stdlib_zlib.py b/extra_tests/snippets/stdlib_zlib.py
index 308a8d23bf..ac2b525b0a 100644
--- a/extra_tests/snippets/stdlib_zlib.py
+++ b/extra_tests/snippets/stdlib_zlib.py
@@ -1,4 +1,5 @@
 import zlib
+
 from testutils import assert_raises
 
 # checksum functions
diff --git a/extra_tests/snippets/syntax_annotations.py b/extra_tests/snippets/syntax_annotations.py
new file mode 100644
index 0000000000..0f78bdc2be
--- /dev/null
+++ b/extra_tests/snippets/syntax_annotations.py
@@ -0,0 +1,10 @@
+from typing import get_type_hints
+
+def func(s: str) -> int:
+    return int(s)
+
+hints = get_type_hints(func)
+
+# The order of type hints matters for certain functions
+# e.g. functools.singledispatch
+assert list(hints.items()) == [('s', str), ('return', int)]
diff --git a/extra_tests/snippets/syntax_class.py b/extra_tests/snippets/syntax_class.py
index fb702f3304..4e80e7edf8 100644
--- a/extra_tests/snippets/syntax_class.py
+++ b/extra_tests/snippets/syntax_class.py
@@ -186,7 +186,7 @@ def b():
 class A:
     pass
 
-assert A.__doc__ == None
+assert A.__doc__ is None, A.__doc__
 
 class B:
     "Docstring"
diff --git a/extra_tests/snippets/syntax_fstring.py b/extra_tests/snippets/syntax_fstring.py
index 5d274478f1..ec198a8125 100644
--- a/extra_tests/snippets/syntax_fstring.py
+++ b/extra_tests/snippets/syntax_fstring.py
@@ -54,12 +54,6 @@
 part_spec = ">+#10x"
 assert f"{16:0{part_spec}}{foo}" == '00000+0x10bar'
 
-# TODO: RUSTPYTHON, delete the next block once `test_fstring.py` can successfully parse
-assert f'{10:#{1}0x}' == '       0xa'
-assert f'{10:{"#"}1{0}{"x"}}' == '       0xa'
-assert f'{-10:-{"#"}1{0}x}' == '      -0xa'
-assert f'{-10:{"-"}#{1}0{"x"}}' == '      -0xa'
-
 spec = "bla"
 assert_raises(ValueError, lambda: f"{16:{spec}}")
 
diff --git a/extra_tests/snippets/syntax_match.py b/extra_tests/snippets/syntax_match.py
index 4e6cd0a962..8868cb93c3 100644
--- a/extra_tests/snippets/syntax_match.py
+++ b/extra_tests/snippets/syntax_match.py
@@ -12,11 +12,13 @@
 # Test enum
 from enum import Enum
 
+
 class Color(Enum):
     RED = 1
     GREEN = 2
     BLUE = 3
 
+
 def test_color(color):
     z = -1
     match color:
@@ -28,9 +30,11 @@ def test_color(color):
             z = 3
     assert z == color.value
 
+
 for color in Color:
     test_color(color)
 
+
 # test or
 def test_or(i):
     z = -1
@@ -43,8 +47,105 @@ def test_or(i):
             z = 2
     return z
 
+
 assert test_or(0) == 0
 assert test_or(1) == 0
 assert test_or(2) == 1
 assert test_or(3) == 1
 assert test_or(4) == 2
+
+# test mapping
+data = {"a": 1, "b": 2}
+match data:
+    case {"a": x}:
+        assert x == 1
+    case _:
+        assert False
+
+match data:
+    case {"a": x, "b": y}:
+        assert x == 1, x
+        assert y == 2, y
+    case _:
+        assert False
+
+# test mapping with rest
+match data:
+    case {"a": x, **rest}:
+        assert x == 1
+        assert rest == {"b": 2}
+    case _:
+        assert False
+
+# test empty rest
+data2 = {"a": 1}
+match data2:
+    case {"a": x, **rest}:
+        assert x == 1
+        assert rest == {}
+    case _:
+        assert False
+
+# test rest with multiple keys
+data3 = {"a": 1, "b": 2, "c": 3, "d": 4}
+match data3:
+    case {"a": x, "b": y, **rest}:
+        assert x == 1
+        assert y == 2
+        assert rest == {"c": 3, "d": 4}
+    case _:
+        assert False
+
+match data3:
+    case {"a": x, "b": y, "c": z, **rest}:
+        assert x == 1
+        assert y == 2
+        assert z == 3
+        assert rest == {"d": 4}
+    case _:
+        assert False
+
+# test mapping pattern with wildcard fallback (reproduces wheelinfo.py issue)
+test_dict = {"sha256": "abc123"}
+result = None
+match test_dict:
+    case {"sha256": checksum}:
+        result = checksum
+    case _:
+        result = "no checksum"
+assert result == "abc123"
+
+# test with no match
+test_dict2 = {"md5": "xyz789"}
+match test_dict2:
+    case {"sha256": checksum}:
+        result = checksum
+    case _:
+        result = "no checksum"
+assert result == "no checksum"
+
+
+# test mapping patterns - comprehensive tests
+def test_mapping_comprehensive():
+    # Single key capture
+    data = {"a": 1}
+    match data:
+        case {"a": x}:
+            captured = x
+        case _:
+            captured = None
+    assert captured == 1, f"Expected 1, got {captured}"
+
+    # Multiple keys
+    data = {"a": 1, "b": 2}
+    match data:
+        case {"a": x, "b": y}:
+            cap_x = x
+            cap_y = y
+        case _:
+            cap_x = cap_y = None
+    assert cap_x == 1, f"Expected x=1, got {cap_x}"
+    assert cap_y == 2, f"Expected y=2, got {cap_y}"
+
+
+test_mapping_comprehensive()
diff --git a/extra_tests/test_snippets.py b/extra_tests/test_snippets.py
index 5ff944c772..d58b86f66b 100644
--- a/extra_tests/test_snippets.py
+++ b/extra_tests/test_snippets.py
@@ -2,14 +2,14 @@
 # in the snippets folder.
 
 
-import sys
-import os
-import unittest
+import contextlib
+import enum
 import glob
 import logging
+import os
 import subprocess
-import contextlib
-import enum
+import sys
+import unittest
 from pathlib import Path
 
 
diff --git a/jit/Cargo.toml b/jit/Cargo.toml
deleted file mode 100644
index 5708ae367b..0000000000
--- a/jit/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "rustpython-jit"
-description = "Experimental JIT(just in time) compiler for python code."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-autotests = false
-
-[dependencies]
-rustpython-compiler-core = { workspace = true }
-
-num-traits = { workspace = true }
-thiserror = { workspace = true }
-libffi = { workspace = true }
-
-cranelift = "0.119"
-cranelift-jit = "0.119"
-cranelift-module = "0.119"
-
-[dev-dependencies]
-rustpython-derive = { path = "../derive", version = "0.4.0" }
-
-approx = "0.5.1"
-
-[[test]]
-name = "integration"
-path = "tests/lib.rs"
-
-[lints]
-workspace = true
diff --git a/jit/src/lib.rs b/jit/src/lib.rs
deleted file mode 100644
index 91911fd8d1..0000000000
--- a/jit/src/lib.rs
+++ /dev/null
@@ -1,375 +0,0 @@
-mod instructions;
-
-use cranelift::prelude::*;
-use cranelift_jit::{JITBuilder, JITModule};
-use cranelift_module::{FuncId, Linkage, Module, ModuleError};
-use instructions::FunctionCompiler;
-use rustpython_compiler_core::bytecode;
-use std::{fmt, mem::ManuallyDrop};
-
-#[derive(Debug, thiserror::Error)]
-#[non_exhaustive]
-pub enum JitCompileError {
-    #[error("function can't be jitted")]
-    NotSupported,
-    #[error("bad bytecode")]
-    BadBytecode,
-    #[error("error while compiling to machine code: {0}")]
-    CraneliftError(Box<ModuleError>),
-}
-
-impl From<ModuleError> for JitCompileError {
-    fn from(err: ModuleError) -> Self {
-        Self::CraneliftError(Box::new(err))
-    }
-}
-
-#[derive(Debug, thiserror::Error, Eq, PartialEq)]
-#[non_exhaustive]
-pub enum JitArgumentError {
-    #[error("argument is of wrong type")]
-    ArgumentTypeMismatch,
-    #[error("wrong number of arguments")]
-    WrongNumberOfArguments,
-}
-
-struct Jit {
-    builder_context: FunctionBuilderContext,
-    ctx: codegen::Context,
-    module: JITModule,
-}
-
-impl Jit {
-    fn new() -> Self {
-        let builder = JITBuilder::new(cranelift_module::default_libcall_names())
-            .expect("Failed to build JITBuilder");
-        let module = JITModule::new(builder);
-        Self {
-            builder_context: FunctionBuilderContext::new(),
-            ctx: module.make_context(),
-            module,
-        }
-    }
-
-    fn build_function<C: bytecode::Constant>(
-        &mut self,
-        bytecode: &bytecode::CodeObject<C>,
-        args: &[JitType],
-        ret: Option<JitType>,
-    ) -> Result<(FuncId, JitSig), JitCompileError> {
-        for arg in args {
-            self.ctx
-                .func
-                .signature
-                .params
-                .push(AbiParam::new(arg.to_cranelift()));
-        }
-
-        if ret.is_some() {
-            self.ctx
-                .func
-                .signature
-                .returns
-                .push(AbiParam::new(ret.clone().unwrap().to_cranelift()));
-        }
-
-        let id = self.module.declare_function(
-            &format!("jit_{}", bytecode.obj_name.as_ref()),
-            Linkage::Export,
-            &self.ctx.func.signature,
-        )?;
-
-        let func_ref = self.module.declare_func_in_func(id, &mut self.ctx.func);
-
-        let mut builder = FunctionBuilder::new(&mut self.ctx.func, &mut self.builder_context);
-        let entry_block = builder.create_block();
-        builder.append_block_params_for_function_params(entry_block);
-        builder.switch_to_block(entry_block);
-
-        let sig = {
-            let mut compiler = FunctionCompiler::new(
-                &mut builder,
-                bytecode.varnames.len(),
-                args,
-                ret,
-                entry_block,
-            );
-
-            compiler.compile(func_ref, bytecode)?;
-
-            compiler.sig
-        };
-
-        builder.seal_all_blocks();
-        builder.finalize();
-
-        self.module.define_function(id, &mut self.ctx)?;
-
-        self.module.clear_context(&mut self.ctx);
-
-        Ok((id, sig))
-    }
-}
-
-pub fn compile<C: bytecode::Constant>(
-    bytecode: &bytecode::CodeObject<C>,
-    args: &[JitType],
-    ret: Option<JitType>,
-) -> Result<CompiledCode, JitCompileError> {
-    let mut jit = Jit::new();
-
-    let (id, sig) = jit.build_function(bytecode, args, ret)?;
-
-    jit.module.finalize_definitions()?;
-
-    let code = jit.module.get_finalized_function(id);
-    Ok(CompiledCode {
-        sig,
-        code,
-        module: ManuallyDrop::new(jit.module),
-    })
-}
-
-pub struct CompiledCode {
-    sig: JitSig,
-    code: *const u8,
-    module: ManuallyDrop<JITModule>,
-}
-
-impl CompiledCode {
-    pub fn args_builder(&self) -> ArgsBuilder<'_> {
-        ArgsBuilder::new(self)
-    }
-
-    pub fn invoke(&self, args: &[AbiValue]) -> Result<Option<AbiValue>, JitArgumentError> {
-        if self.sig.args.len() != args.len() {
-            return Err(JitArgumentError::WrongNumberOfArguments);
-        }
-
-        let cif_args = self
-            .sig
-            .args
-            .iter()
-            .zip(args.iter())
-            .map(|(ty, val)| type_check(ty, val).map(|_| val))
-            .map(|v| v.map(AbiValue::to_libffi_arg))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(unsafe { self.invoke_raw(&cif_args) })
-    }
-
-    unsafe fn invoke_raw(&self, cif_args: &[libffi::middle::Arg]) -> Option<AbiValue> {
-        unsafe {
-            let cif = self.sig.to_cif();
-            let value = cif.call::<UnTypedAbiValue>(
-                libffi::middle::CodePtr::from_ptr(self.code as *const _),
-                cif_args,
-            );
-            self.sig.ret.as_ref().map(|ty| value.to_typed(ty))
-        }
-    }
-}
-
-struct JitSig {
-    args: Vec<JitType>,
-    ret: Option<JitType>,
-}
-
-impl JitSig {
-    fn to_cif(&self) -> libffi::middle::Cif {
-        let ret = match self.ret {
-            Some(ref ty) => ty.to_libffi(),
-            None => libffi::middle::Type::void(),
-        };
-        libffi::middle::Cif::new(self.args.iter().map(JitType::to_libffi), ret)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-#[non_exhaustive]
-pub enum JitType {
-    Int,
-    Float,
-    Bool,
-}
-
-impl JitType {
-    fn to_cranelift(&self) -> types::Type {
-        match self {
-            Self::Int => types::I64,
-            Self::Float => types::F64,
-            Self::Bool => types::I8,
-        }
-    }
-
-    fn to_libffi(&self) -> libffi::middle::Type {
-        match self {
-            Self::Int => libffi::middle::Type::i64(),
-            Self::Float => libffi::middle::Type::f64(),
-            Self::Bool => libffi::middle::Type::u8(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-#[non_exhaustive]
-pub enum AbiValue {
-    Float(f64),
-    Int(i64),
-    Bool(bool),
-}
-
-impl AbiValue {
-    fn to_libffi_arg(&self) -> libffi::middle::Arg {
-        match self {
-            AbiValue::Int(i) => libffi::middle::Arg::new(i),
-            AbiValue::Float(f) => libffi::middle::Arg::new(f),
-            AbiValue::Bool(b) => libffi::middle::Arg::new(b),
-        }
-    }
-}
-
-impl From<i64> for AbiValue {
-    fn from(i: i64) -> Self {
-        AbiValue::Int(i)
-    }
-}
-
-impl From<f64> for AbiValue {
-    fn from(f: f64) -> Self {
-        AbiValue::Float(f)
-    }
-}
-
-impl From<bool> for AbiValue {
-    fn from(b: bool) -> Self {
-        AbiValue::Bool(b)
-    }
-}
-
-impl TryFrom<AbiValue> for i64 {
-    type Error = ();
-
-    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
-        match value {
-            AbiValue::Int(i) => Ok(i),
-            _ => Err(()),
-        }
-    }
-}
-
-impl TryFrom<AbiValue> for f64 {
-    type Error = ();
-
-    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
-        match value {
-            AbiValue::Float(f) => Ok(f),
-            _ => Err(()),
-        }
-    }
-}
-
-impl TryFrom<AbiValue> for bool {
-    type Error = ();
-
-    fn try_from(value: AbiValue) -> Result<Self, Self::Error> {
-        match value {
-            AbiValue::Bool(b) => Ok(b),
-            _ => Err(()),
-        }
-    }
-}
-
-fn type_check(ty: &JitType, val: &AbiValue) -> Result<(), JitArgumentError> {
-    match (ty, val) {
-        (JitType::Int, AbiValue::Int(_))
-        | (JitType::Float, AbiValue::Float(_))
-        | (JitType::Bool, AbiValue::Bool(_)) => Ok(()),
-        _ => Err(JitArgumentError::ArgumentTypeMismatch),
-    }
-}
-
-#[derive(Copy, Clone)]
-union UnTypedAbiValue {
-    float: f64,
-    int: i64,
-    boolean: u8,
-    _void: (),
-}
-
-impl UnTypedAbiValue {
-    unsafe fn to_typed(self, ty: &JitType) -> AbiValue {
-        unsafe {
-            match ty {
-                JitType::Int => AbiValue::Int(self.int),
-                JitType::Float => AbiValue::Float(self.float),
-                JitType::Bool => AbiValue::Bool(self.boolean != 0),
-            }
-        }
-    }
-}
-
-// we don't actually ever touch CompiledCode til we drop it, it should be safe.
-// TODO: confirm with wasmtime ppl that it's not unsound?
-unsafe impl Send for CompiledCode {}
-unsafe impl Sync for CompiledCode {}
-
-impl Drop for CompiledCode {
-    fn drop(&mut self) {
-        // SAFETY: The only pointer that this memory will also be dropped now
-        unsafe { ManuallyDrop::take(&mut self.module).free_memory() }
-    }
-}
-
-impl fmt::Debug for CompiledCode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("[compiled code]")
-    }
-}
-
-pub struct ArgsBuilder<'a> {
-    values: Vec<Option<AbiValue>>,
-    code: &'a CompiledCode,
-}
-
-impl<'a> ArgsBuilder<'a> {
-    fn new(code: &'a CompiledCode) -> ArgsBuilder<'a> {
-        ArgsBuilder {
-            values: vec![None; code.sig.args.len()],
-            code,
-        }
-    }
-
-    pub fn set(&mut self, idx: usize, value: AbiValue) -> Result<(), JitArgumentError> {
-        type_check(&self.code.sig.args[idx], &value).map(|_| {
-            self.values[idx] = Some(value);
-        })
-    }
-
-    pub fn is_set(&self, idx: usize) -> bool {
-        self.values[idx].is_some()
-    }
-
-    pub fn into_args(self) -> Option<Args<'a>> {
-        self.values
-            .iter()
-            .map(|v| v.as_ref().map(AbiValue::to_libffi_arg))
-            .collect::<Option<_>>()
-            .map(|cif_args| Args {
-                _values: self.values,
-                cif_args,
-                code: self.code,
-            })
-    }
-}
-
-pub struct Args<'a> {
-    _values: Vec<Option<AbiValue>>,
-    cif_args: Vec<libffi::middle::Arg>,
-    code: &'a CompiledCode,
-}
-
-impl Args<'_> {
-    pub fn invoke(&self) -> Option<AbiValue> {
-        unsafe { self.code.invoke_raw(&self.cif_args) }
-    }
-}
diff --git a/pylib/Lib b/pylib/Lib
deleted file mode 120000
index 47f928ff4d..0000000000
--- a/pylib/Lib
+++ /dev/null
@@ -1 +0,0 @@
-../Lib
\ No newline at end of file
diff --git a/pylib/build.rs b/pylib/build.rs
deleted file mode 100644
index 553b97202a..0000000000
--- a/pylib/build.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-fn main() {
-    process_python_libs("../vm/Lib/python_builtins/*");
-
-    process_python_libs("../vm/Lib/core_modules/*");
-    #[cfg(feature = "freeze-stdlib")]
-    if cfg!(windows) {
-        process_python_libs("../Lib/**/*");
-    } else {
-        process_python_libs("./Lib/**/*");
-    }
-
-    if cfg!(windows) {
-        if let Ok(real_path) = std::fs::read_to_string("Lib") {
-            let canonicalized_path = std::fs::canonicalize(real_path)
-                .expect("failed to resolve RUSTPYTHONPATH during build time");
-            println!(
-                "cargo:rustc-env=win_lib_path={}",
-                canonicalized_path.to_str().unwrap()
-            );
-        }
-    }
-}
-
-// remove *.pyc files and add *.py to watch list
-fn process_python_libs(pattern: &str) {
-    let glob = glob::glob(pattern).unwrap_or_else(|e| panic!("failed to glob {pattern:?}: {e}"));
-    for entry in glob.flatten() {
-        if entry.is_dir() {
-            continue;
-        }
-        let display = entry.display();
-        if display.to_string().ends_with(".pyc") {
-            if std::fs::remove_file(&entry).is_err() {
-                println!("cargo:warning=failed to remove {display}")
-            }
-            continue;
-        }
-        println!("cargo:rerun-if-changed={display}");
-    }
-}
diff --git a/scripts/auto_mark_test.py b/scripts/auto_mark_test.py
new file mode 100644
index 0000000000..7823095416
--- /dev/null
+++ b/scripts/auto_mark_test.py
@@ -0,0 +1,338 @@
+"""
+An automated script to mark failures in python test suite.
+It adds @unittest.expectedFailure to the test functions that are failing in RustPython, but not in CPython.
+As well as marking the test with a TODO comment.
+
+Quick Import (recommended):
+    python ./scripts/fix_test.py --quick-import cpython/Lib/test/test_foo.py
+
+    This will:
+    1. Copy cpython/Lib/test/test_foo.py to Lib/test/test_foo.py (if not exists)
+    2. Run the test with RustPython
+    3. Mark failing tests with @unittest.expectedFailure
+
+Manual workflow:
+1. Copy a specific test from the CPython repository to the RustPython repository.
+2. Remove all unexpected failures from the test and skip the tests that hang.
+3. Build RustPython: cargo build --release
+4. Run from the project root:
+   - For single-file tests: python ./scripts/fix_test.py --path ./Lib/test/test_venv.py
+   - For package tests: python ./scripts/fix_test.py --path ./Lib/test/test_inspect/test_inspect.py
+5. Verify: cargo run --release -- -m test test_venv (should pass with expected failures)
+6. Actually fix the tests marked with # TODO: RUSTPYTHON
+"""
+
+import argparse
+import ast
+import shutil
+import sys
+from pathlib import Path
+
+from lib_updater import (
+    COMMENT,
+    PatchSpec,
+    UtMethod,
+    apply_patches,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Fix test.")
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--path", type=Path, help="Path to test file")
+    group.add_argument(
+        "--quick-import",
+        type=Path,
+        metavar="PATH",
+        help="Import from path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
+    )
+    parser.add_argument("--force", action="store_true", help="Force modification")
+    parser.add_argument(
+        "--platform", action="store_true", help="Platform specific failure"
+    )
+
+    args = parser.parse_args()
+    return args
+
+
+class Test:
+    name: str = ""
+    path: str = ""
+    result: str = ""
+
+    def __str__(self):
+        return f"Test(name={self.name}, path={self.path}, result={self.result})"
+
+
+class TestResult:
+    tests_result: str = ""
+    tests = []
+    unexpected_successes = []  # Tests that passed but were marked as expectedFailure
+    stdout = ""
+
+    def __str__(self):
+        return f"TestResult(tests_result={self.tests_result},tests={len(self.tests)},unexpected_successes={len(self.unexpected_successes)})"
+
+
+def parse_results(result):
+    lines = result.stdout.splitlines()
+    test_results = TestResult()
+    test_results.tests = []
+    test_results.unexpected_successes = []
+    test_results.stdout = result.stdout
+    in_test_results = False
+    for line in lines:
+        if line == "Run tests sequentially":
+            in_test_results = True
+        elif line.startswith("-----------"):
+            in_test_results = False
+        if in_test_results and " ... " in line:
+            line = line.strip()
+            # Skip lines that don't look like test results
+            if line.startswith("tests") or line.startswith("["):
+                continue
+            # Parse: "test_name (path) [subtest] ... RESULT"
+            parts = line.split(" ... ")
+            if len(parts) >= 2:
+                test_info = parts[0]
+                result_str = parts[-1].lower()
+                # Only process FAIL or ERROR
+                if result_str not in ("fail", "error"):
+                    continue
+                # Extract test name (first word)
+                first_space = test_info.find(" ")
+                if first_space > 0:
+                    test = Test()
+                    test.name = test_info[:first_space]
+                    # Extract path from (path)
+                    rest = test_info[first_space:].strip()
+                    if rest.startswith("("):
+                        end_paren = rest.find(")")
+                        if end_paren > 0:
+                            test.path = rest[1:end_paren]
+                            test.result = result_str
+                            test_results.tests.append(test)
+        elif "== Tests result: " in line:
+            res = line.split("== Tests result: ")[1]
+            res = res.split(" ")[0]
+            test_results.tests_result = res
+        # Parse: "UNEXPECTED SUCCESS: test_name (path)"
+        elif line.startswith("UNEXPECTED SUCCESS: "):
+            rest = line[len("UNEXPECTED SUCCESS: ") :]
+            # Format: "test_name (path)"
+            first_space = rest.find(" ")
+            if first_space > 0:
+                test = Test()
+                test.name = rest[:first_space]
+                path_part = rest[first_space:].strip()
+                if path_part.startswith("(") and path_part.endswith(")"):
+                    test.path = path_part[1:-1]
+                    test.result = "unexpected_success"
+                    test_results.unexpected_successes.append(test)
+    return test_results
+
+
+def path_to_test(path) -> list[str]:
+    # path format: test.module_name[.submodule].ClassName.test_method
+    # We need [ClassName, test_method] - always the last 2 elements
+    parts = path.split(".")
+    return parts[-2:]  # Get class name and method name
+
+
+def is_super_call_only(func_node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Check if the method body is just 'return super().method_name()'."""
+    if len(func_node.body) != 1:
+        return False
+    stmt = func_node.body[0]
+    if not isinstance(stmt, ast.Return) or stmt.value is None:
+        return False
+    # Check for super().method_name() pattern
+    call = stmt.value
+    if not isinstance(call, ast.Call):
+        return False
+    if not isinstance(call.func, ast.Attribute):
+        return False
+    super_call = call.func.value
+    if not isinstance(super_call, ast.Call):
+        return False
+    if not isinstance(super_call.func, ast.Name) or super_call.func.id != "super":
+        return False
+    return True
+
+
+def remove_expected_failures(
+    contents: str, tests_to_remove: set[tuple[str, str]]
+) -> str:
+    """Remove @unittest.expectedFailure decorators from tests that now pass."""
+    if not tests_to_remove:
+        return contents
+
+    tree = ast.parse(contents)
+    lines = contents.splitlines()
+    lines_to_remove = set()
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+        class_name = node.name
+        for item in node.body:
+            if not isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            method_name = item.name
+            if (class_name, method_name) not in tests_to_remove:
+                continue
+
+            # Check if we should remove the entire method (super() call only)
+            remove_entire_method = is_super_call_only(item)
+
+            if remove_entire_method:
+                # Remove entire method including decorators and any preceding comment
+                first_line = item.lineno - 1  # 0-indexed, def line
+                if item.decorator_list:
+                    first_line = item.decorator_list[0].lineno - 1
+                # Check for TODO comment before first decorator/def
+                if first_line > 0:
+                    prev_line = lines[first_line - 1].strip()
+                    if prev_line.startswith("#") and COMMENT in prev_line:
+                        first_line -= 1
+                # Remove from first_line to end_lineno (inclusive)
+                for i in range(first_line, item.end_lineno):
+                    lines_to_remove.add(i)
+            else:
+                # Only remove the expectedFailure decorator
+                for dec in item.decorator_list:
+                    dec_line = dec.lineno - 1  # 0-indexed
+                    line_content = lines[dec_line]
+
+                    # Check if it's @unittest.expectedFailure
+                    if "expectedFailure" not in line_content:
+                        continue
+
+                    # Check if TODO: RUSTPYTHON is on the same line or the line before
+                    has_comment_on_line = COMMENT in line_content
+                    has_comment_before = (
+                        dec_line > 0
+                        and lines[dec_line - 1].strip().startswith("#")
+                        and COMMENT in lines[dec_line - 1]
+                    )
+
+                    if has_comment_on_line or has_comment_before:
+                        lines_to_remove.add(dec_line)
+                        if has_comment_before:
+                            lines_to_remove.add(dec_line - 1)
+
+    # Remove lines in reverse order to maintain line numbers
+    for line_idx in sorted(lines_to_remove, reverse=True):
+        del lines[line_idx]
+
+    return "\n".join(lines) + "\n" if lines else ""
+
+
+def build_patches(test_parts_set: set[tuple[str, str]]) -> dict:
+    """Convert failing tests to lib_updater patch format."""
+    patches = {}
+    for class_name, method_name in test_parts_set:
+        if class_name not in patches:
+            patches[class_name] = {}
+        patches[class_name][method_name] = [
+            PatchSpec(UtMethod.ExpectedFailure, None, "")
+        ]
+    return patches
+
+
+def run_test(test_name):
+    print(f"Running test: {test_name}")
+    rustpython_location = "./target/release/rustpython"
+    if sys.platform == "win32":
+        rustpython_location += ".exe"
+
+    import subprocess
+
+    result = subprocess.run(
+        [rustpython_location, "-m", "test", "-v", "-u", "all", "--slowest", test_name],
+        capture_output=True,
+        text=True,
+    )
+    return parse_results(result)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Handle --quick-import: extract Lib/... path and copy if needed
+    if args.quick_import is not None:
+        # Normalize path separators to forward slashes for cross-platform support
+        src_str = str(args.quick_import).replace("\\", "/")
+        lib_marker = "/Lib/"
+
+        if lib_marker not in src_str:
+            print(
+                f"Error: --quick-import path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_import})"
+            )
+            sys.exit(1)
+
+        idx = src_str.index(lib_marker)
+        lib_path = Path(src_str[idx + 1 :])  # Lib/test/foo.py
+        src_path = args.quick_import
+
+        if not src_path.exists():
+            print(f"Error: Source file not found: {src_path}")
+            sys.exit(1)
+
+        if not lib_path.exists():
+            print(f"Copying: {src_path} -> {lib_path}")
+            lib_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(src_path, lib_path)
+        else:
+            print(f"File already exists: {lib_path}")
+
+        args.path = lib_path
+
+    test_path = args.path.resolve()
+    if not test_path.exists():
+        print(f"Error: File not found: {test_path}")
+        sys.exit(1)
+    # Detect package tests (e.g., test_ctypes/test_random_things.py)
+    if test_path.parent.name.startswith("test_"):
+        test_name = f"{test_path.parent.name}.{test_path.stem}"
+    else:
+        test_name = test_path.stem
+    tests = run_test(test_name)
+    f = test_path.read_text(encoding="utf-8")
+
+    # Collect failing tests (with deduplication for subtests)
+    failing_tests = set()  # Track (class_name, method_name) to avoid duplicates
+    for test in tests.tests:
+        if test.result == "fail" or test.result == "error":
+            test_parts = path_to_test(test.path)
+            if len(test_parts) == 2:
+                test_key = tuple(test_parts)
+                if test_key not in failing_tests:
+                    failing_tests.add(test_key)
+                    print(f"Marking as failing: {test_parts[0]}.{test_parts[1]}")
+
+    # Collect unexpected successes (tests that now pass but have expectedFailure)
+    unexpected_successes = set()
+    for test in tests.unexpected_successes:
+        test_parts = path_to_test(test.path)
+        if len(test_parts) == 2:
+            test_key = tuple(test_parts)
+            if test_key not in unexpected_successes:
+                unexpected_successes.add(test_key)
+                print(f"Removing expectedFailure: {test_parts[0]}.{test_parts[1]}")
+
+    # Remove expectedFailure from tests that now pass
+    if unexpected_successes:
+        f = remove_expected_failures(f, unexpected_successes)
+
+    # Apply patches for failing tests
+    if failing_tests:
+        patches = build_patches(failing_tests)
+        f = apply_patches(f, patches)
+
+    # Write changes if any modifications were made
+    if failing_tests or unexpected_successes:
+        test_path.write_text(f, encoding="utf-8")
+
+    print(f"Added expectedFailure to {len(failing_tests)} tests")
+    print(f"Removed expectedFailure from {len(unexpected_successes)} tests")
diff --git a/scripts/fix_test.py b/scripts/fix_test.py
deleted file mode 100644
index a5663e3eee..0000000000
--- a/scripts/fix_test.py
+++ /dev/null
@@ -1,161 +0,0 @@
-"""
-An automated script to mark failures in python test suite.
-It adds @unittest.expectedFailure to the test functions that are failing in RustPython, but not in CPython.
-As well as marking the test with a TODO comment.
-
-How to use:
-1. Copy a specific test from the CPython repository to the RustPython repository.
-2. Remove all unexpected failures from the test and skip the tests that hang
-3. Run python ./scripts/fix_test.py --test test_venv --path ./Lib/test/test_venv.py or equivalent for the test from the project root.
-4. Ensure that there are no unexpected successes in the test.
-5. Actually fix the test.
-"""
-
-import argparse
-import ast
-import itertools
-import platform
-from pathlib import Path
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Fix test.")
-    parser.add_argument("--path", type=Path, help="Path to test file")
-    parser.add_argument("--force", action="store_true", help="Force modification")
-    parser.add_argument(
-        "--platform", action="store_true", help="Platform specific failure"
-    )
-
-    args = parser.parse_args()
-    return args
-
-
-class Test:
-    name: str = ""
-    path: str = ""
-    result: str = ""
-
-    def __str__(self):
-        return f"Test(name={self.name}, path={self.path}, result={self.result})"
-
-
-class TestResult:
-    tests_result: str = ""
-    tests = []
-    stdout = ""
-
-    def __str__(self):
-        return f"TestResult(tests_result={self.tests_result},tests={len(self.tests)})"
-
-
-def parse_results(result):
-    lines = result.stdout.splitlines()
-    test_results = TestResult()
-    test_results.stdout = result.stdout
-    in_test_results = False
-    for line in lines:
-        if line == "Run tests sequentially":
-            in_test_results = True
-        elif line.startswith("-----------"):
-            in_test_results = False
-        if (
-            in_test_results
-            and not line.startswith("tests")
-            and not line.startswith("[")
-        ):
-            line = line.split(" ")
-            if line != [] and len(line) > 3:
-                test = Test()
-                test.name = line[0]
-                test.path = line[1].strip("(").strip(")")
-                test.result = " ".join(line[3:]).lower()
-                test_results.tests.append(test)
-        else:
-            if "== Tests result: " in line:
-                res = line.split("== Tests result: ")[1]
-                res = res.split(" ")[0]
-                test_results.tests_result = res
-    return test_results
-
-
-def path_to_test(path) -> list[str]:
-    return path.split(".")[2:]
-
-
-def modify_test(file: str, test: list[str], for_platform: bool = False) -> str:
-    a = ast.parse(file)
-    lines = file.splitlines()
-    fixture = "@unittest.expectedFailure"
-    for node in ast.walk(a):
-        if isinstance(node, ast.FunctionDef):
-            if node.name == test[-1]:
-                assert not for_platform
-                indent = " " * node.col_offset
-                lines.insert(node.lineno - 1, indent + fixture)
-                lines.insert(node.lineno - 1, indent + "# TODO: RUSTPYTHON")
-                break
-    return "\n".join(lines)
-
-
-def modify_test_v2(file: str, test: list[str], for_platform: bool = False) -> str:
-    a = ast.parse(file)
-    lines = file.splitlines()
-    fixture = "@unittest.expectedFailure"
-    for key, node in ast.iter_fields(a):
-        if key == "body":
-            for i, n in enumerate(node):
-                match n:
-                    case ast.ClassDef():
-                        if len(test) == 2 and test[0] == n.name:
-                            # look through body for function def
-                            for i, fn in enumerate(n.body):
-                                match fn:
-                                    case ast.FunctionDef():
-                                        if fn.name == test[-1]:
-                                            assert not for_platform
-                                            indent = " " * fn.col_offset
-                                            lines.insert(
-                                                fn.lineno - 1, indent + fixture
-                                            )
-                                            lines.insert(
-                                                fn.lineno - 1,
-                                                indent + "# TODO: RUSTPYTHON",
-                                            )
-                                            break
-                    case ast.FunctionDef():
-                        if n.name == test[0] and len(test) == 1:
-                            assert not for_platform
-                            indent = " " * n.col_offset
-                            lines.insert(n.lineno - 1, indent + fixture)
-                            lines.insert(n.lineno - 1, indent + "# TODO: RUSTPYTHON")
-                            break
-                if i > 500:
-                    exit()
-    return "\n".join(lines)
-
-
-def run_test(test_name):
-    print(f"Running test: {test_name}")
-    rustpython_location = "./target/release/rustpython"
-    import subprocess
-
-    result = subprocess.run(
-        [rustpython_location, "-m", "test", "-v", test_name],
-        capture_output=True,
-        text=True,
-    )
-    return parse_results(result)
-
-
-if __name__ == "__main__":
-    args = parse_args()
-    test_name = args.path.stem
-    tests = run_test(test_name)
-    f = open(args.path).read()
-    for test in tests.tests:
-        if test.result == "fail" or test.result == "error":
-            print("Modifying test:", test.name)
-            f = modify_test_v2(f, path_to_test(test.path), args.platform)
-    with open(args.path, "w") as file:
-        # TODO: Find validation method, and make --force override it
-        file.write(f)
diff --git a/scripts/generate_checklist.py b/scripts/generate_checklist.py
index 9a444b16e2..759e4bd2a2 100644
--- a/scripts/generate_checklist.py
+++ b/scripts/generate_checklist.py
@@ -7,8 +7,8 @@
 import dataclasses
 import difflib
 import pathlib
-from typing import Optional
 import warnings
+from typing import Optional
 
 import requests
 from jinja2 import Environment, FileSystemLoader
diff --git a/scripts/generate_opcode_metadata.py b/scripts/generate_opcode_metadata.py
new file mode 100644
index 0000000000..dc913e1a7e
--- /dev/null
+++ b/scripts/generate_opcode_metadata.py
@@ -0,0 +1,81 @@
+"""
+Generate Lib/_opcode_metadata.py for RustPython bytecode.
+
+This file generates opcode metadata that is compatible with CPython 3.13.
+"""
+
+import itertools
+import pathlib
+import re
+import typing
+
+ROOT = pathlib.Path(__file__).parents[1]
+BYTECODE_FILE = (
+    ROOT / "crates" / "compiler-core" / "src" / "bytecode" / "instruction.rs"
+)
+OPCODE_METADATA_FILE = ROOT / "Lib" / "_opcode_metadata.py"
+
+
+class Opcode(typing.NamedTuple):
+    rust_name: str
+    id: int
+
+    @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()
+
+    @classmethod
+    def from_str(cls, body: str):
+        raw_variants = re.split(r"(\d+),", body.strip())
+        raw_variants.remove("")
+        for raw_name, raw_id in itertools.batched(raw_variants, 2):
+            name = re.findall(r"\b[A-Z][A-Za-z]*\d*\b(?=\s*[\({=])", raw_name)[0]
+            yield cls(rust_name=name.strip(), id=int(raw_id))
+
+    def __lt__(self, other: typing.Self) -> bool:
+        return self.id < other.id
+
+
+def extract_enum_body(contents: str, enum_name: str) -> str:
+    res = re.search(f"pub enum {enum_name} " + r"\{(.+?)\n\}", contents, re.DOTALL)
+    if not res:
+        raise ValueError(f"Could not find {enum_name} enum")
+
+    return "\n".join(
+        line.split("//")[0].strip()  # Remove any comment. i.e. "foo // some comment"
+        for line in res.group(1).splitlines()
+        if not line.strip().startswith("//")  # Ignore comment lines
+    )
+
+
+contents = BYTECODE_FILE.read_text()
+enum_body = "\n".join(
+    extract_enum_body(contents, enum_name)
+    for enum_name in ("Instruction", "PseudoInstruction")
+)
+opcodes = list(Opcode.from_str(enum_body))
+
+# Generate the output file
+output = """# This file is generated by scripts/generate_opcode_metadata.py
+# for RustPython bytecode format (CPython 3.13 compatible opcode numbers).
+# Do not edit!
+
+_specializations = {}
+
+_specialized_opmap = {}
+
+opmap = {
+"""
+
+for opcode in sorted(opcodes):
+    output += f"    '{opcode.cpython_name}': {opcode.id},\n"
+
+output += """}
+
+# CPython 3.13 compatible: opcodes < 44 have no argument
+HAVE_ARGUMENT = 44
+MIN_INSTRUMENTED_OPCODE = 236
+"""
+
+OPCODE_METADATA_FILE.write_text(output)
diff --git a/scripts/generate_sre_constants.py b/scripts/generate_sre_constants.py
new file mode 100644
index 0000000000..8e4091d2eb
--- /dev/null
+++ b/scripts/generate_sre_constants.py
@@ -0,0 +1,139 @@
+#! /usr/bin/env python3
+# This script generates crates/sre_engine/src/constants.rs from Lib/re/_constants.py.
+
+SCRIPT_NAME = "scripts/generate_sre_constants.py"
+
+
+def update_file(file, content):
+    try:
+        with open(file, "r") as fobj:
+            if fobj.read() == content:
+                return False
+    except (OSError, ValueError):
+        pass
+    with open(file, "w") as fobj:
+        fobj.write(content)
+    return True
+
+
+sre_constants_header = f"""\
+/*
+ * Secret Labs' Regular Expression Engine
+ *
+ * regular expression matching engine
+ *
+ * Auto-generated by {SCRIPT_NAME} from
+ * Lib/re/_constants.py.
+ *
+ * Copyright (c) 1997-2001 by Secret Labs AB.  All rights reserved.
+ *
+ * See the sre.c file for information on usage and redistribution.
+ */
+
+"""
+
+
+def dump_enum(d, enum_name, derives, strip_prefix=""):
+    """Generate Rust enum definitions from a Python dictionary.
+
+    Args:
+        d (list): The list containing the enum variants.
+        enum_name (str): The name of the enum to generate.
+        derives (str): The derive attributes to include.
+        strip_prefix (str, optional): A prefix to strip from the variant names. Defaults to "".
+
+    Returns:
+        list: A list of strings representing the enum definition.
+    """
+    items = sorted(d)
+    print(f"items is {items}")
+    content = [f"{derives}\n"]
+    content.append("#[repr(u32)]\n")
+    content.append("#[allow(non_camel_case_types, clippy::upper_case_acronyms)]\n")
+    content.append(f"pub enum {enum_name} {{\n")
+    for i, item in enumerate(items):
+        name = str(item).removeprefix(strip_prefix)
+        content.append(f"    {name} = {i},\n")
+    content.append("}\n\n")
+    return content
+
+
+def dump_bitflags(d, prefix, derives, struct_name, int_t):
+    """Generate Rust bitflags definitions from a Python dictionary.
+
+    Args:
+        d (dict): The dictionary containing the bitflag variants.
+        prefix (str): The prefix to strip from the variant names.
+        derives (str): The derive attributes to include.
+        struct_name (str): The name of the struct to generate.
+        int_t (str): The integer type to use for the bitflags.
+
+    Returns:
+        list: A list of strings representing the bitflags definition.
+    """
+    items = [(value, name) for name, value in d.items() if name.startswith(prefix)]
+    content = ["bitflags! {\n"]
+    content.append(f"{derives}\n") if derives else None
+    content.append(f"    pub struct {struct_name}: {int_t} {{\n")
+    for value, name in sorted(items):
+        name = str(name).removeprefix(prefix)
+        content.append(f"        const {name} = {value};\n")
+    content.append("    }\n")
+    content.append("}\n\n")
+    return content
+
+
+def main(
+    infile="Lib/re/_constants.py",
+    outfile_constants="crates/sre_engine/src/constants.rs",
+):
+    ns = {}
+    with open(infile) as fp:
+        code = fp.read()
+    exec(code, ns)
+
+    content = [sre_constants_header]
+    content.append("use bitflags::bitflags;\n\n")
+    content.append(f"pub const SRE_MAGIC: usize = {ns['MAGIC']};\n")
+    content.extend(
+        dump_enum(
+            ns["OPCODES"],
+            "SreOpcode",
+            "#[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]",
+        )
+    )
+    content.extend(
+        dump_enum(
+            ns["ATCODES"],
+            "SreAtCode",
+            "#[derive(num_enum::TryFromPrimitive, Debug, PartialEq, Eq)]",
+            "AT_",
+        )
+    )
+    content.extend(
+        dump_enum(
+            ns["CHCODES"],
+            "SreCatCode",
+            "#[derive(num_enum::TryFromPrimitive, Debug)]",
+            "CATEGORY_",
+        )
+    )
+
+    content.extend(
+        dump_bitflags(
+            ns,
+            "SRE_FLAG_",
+            "#[derive(Debug, PartialEq, Eq, Clone, Copy)]",
+            "SreFlag",
+            "u16",
+        )
+    )
+    content.extend(dump_bitflags(ns, "SRE_INFO_", "", "SreInfo", "u32"))
+
+    update_file(outfile_constants, "".join(content))
+
+
+if __name__ == "__main__":
+    import sys
+
+    main(*sys.argv[1:])
diff --git a/scripts/lib_updater.py b/scripts/lib_updater.py
new file mode 100755
index 0000000000..4e2f7999ec
--- /dev/null
+++ b/scripts/lib_updater.py
@@ -0,0 +1,393 @@
+#!/usr/bin/env python
+__doc__ = """
+This tool helps with updating test files from CPython.
+
+Quick Upgrade
+-------------
+    ./{fname} --quick-upgrade cpython/Lib/test/test_threading.py
+    ./{fname} --quick-upgrade ../somewhere/Lib/threading.py
+
+    Any path containing `/Lib/` will auto-detect the target:
+    -> Extracts patches from Lib/... (auto-detected from path)
+    -> Applies them to the source file
+    -> Writes result to Lib/...
+
+Examples
+--------
+To move the patches found in `Lib/test/foo.py` to `~/cpython/Lib/test/foo.py` then write the contents back to `Lib/test/foo.py`
+
+>>> ./{fname} --from Lib/test/foo.py --to ~/cpython/Lib/test/foo.py -o Lib/test/foo.py
+
+You can run the same command without `-o` to override the `--from` path:
+
+>>> ./{fname} --from Lib/test/foo.py --to ~/cpython/Lib/test/foo.py
+
+To get a baseline of patches, you can alter the patches file with your favorite tool/script/etc and then reapply it with:
+
+>>> ./{fname} --from Lib/test/foo.py --show-patches -o my_patches.json
+
+(By default the output is set to print to stdout).
+
+When you want to apply your own patches:
+
+>>> ./{fname} -p my_patches.json --to Lib/test/foo.py
+""".format(fname=__import__("os").path.basename(__file__))
+
+
+import argparse
+import ast
+import collections
+import enum
+import json
+import pathlib
+import re
+import sys
+import textwrap
+import typing
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Iterator
+
+type Patches = dict[str, dict[str, list["PatchSpec"]]]
+
+DEFAULT_INDENT = " " * 4
+COMMENT = "TODO: RUSTPYTHON"
+UT = "unittest"
+
+
+@enum.unique
+class UtMethod(enum.StrEnum):
+    """
+    UnitTest Method.
+    """
+
+    def _generate_next_value_(name, start, count, last_values) -> str:
+        return name[0].lower() + name[1:]
+
+    def has_args(self) -> bool:
+        return self != self.ExpectedFailure
+
+    def has_cond(self) -> bool:
+        return self.endswith(("If", "Unless"))
+
+    ExpectedFailure = enum.auto()
+    ExpectedFailureIf = enum.auto()
+    ExpectedFailureIfWindows = enum.auto()
+    Skip = enum.auto()
+    SkipIf = enum.auto()
+    SkipUnless = enum.auto()
+
+
+class PatchSpec(typing.NamedTuple):
+    """
+    Attributes
+    ----------
+    ut_method : UtMethod
+        unittest method.
+    cond : str, optional
+        `ut_method` condition. Relevant only for some of `ut_method` types.
+    reason : str, optional
+        Reason for why the test is patched in this way.
+    """
+
+    ut_method: UtMethod
+    cond: str | None = None
+    reason: str = ""
+
+    @property
+    def _reason(self) -> str:
+        return f"{COMMENT}; {self.reason}".strip(" ;")
+
+    @property
+    def _attr_node(self) -> ast.Attribute:
+        return ast.Attribute(value=ast.Name(id=UT), attr=self.ut_method)
+
+    def as_ast_node(self) -> ast.Attribute | ast.Call:
+        if not self.ut_method.has_args():
+            return self._attr_node
+
+        args = []
+        if self.cond:
+            args.append(ast.parse(self.cond).body[0].value)
+        args.append(ast.Constant(value=self._reason))
+
+        return ast.Call(func=self._attr_node, args=args, keywords=[])
+
+    def as_decorator(self) -> str:
+        unparsed = ast.unparse(self.as_ast_node())
+
+        if not self.ut_method.has_args():
+            unparsed = f"{unparsed} # {self._reason}"
+
+        return f"@{unparsed}"
+
+
+class PatchEntry(typing.NamedTuple):
+    """
+    Stores patch metadata.
+
+    Attributes
+    ----------
+    parent_class : str
+        Parent class of test.
+    test_name : str
+        Test name.
+    spec : PatchSpec
+        Patch spec.
+    """
+
+    parent_class: str
+    test_name: str
+    spec: PatchSpec
+
+    @classmethod
+    def iter_patch_entires(
+        cls, tree: ast.Module, lines: list[str]
+    ) -> "Iterator[typing.Self]":
+        for cls_node, fn_node in iter_tests(tree):
+            parent_class = cls_node.name
+            for dec_node in fn_node.decorator_list:
+                if not isinstance(dec_node, (ast.Attribute, ast.Call)):
+                    continue
+
+                attr_node = (
+                    dec_node if isinstance(dec_node, ast.Attribute) else dec_node.func
+                )
+
+                if (
+                    isinstance(attr_node, ast.Name)
+                    or getattr(attr_node.value, "id", None) != UT
+                ):
+                    continue
+
+                cond = None
+                try:
+                    ut_method = UtMethod(attr_node.attr)
+                except ValueError:
+                    continue
+
+                # If our ut_method has args then,
+                # we need to search for a constant that contains our `COMMENT`.
+                # Otherwise we need to search it in the raw source code :/
+                if ut_method.has_args():
+                    reason = next(
+                        (
+                            node.value
+                            for node in ast.walk(dec_node)
+                            if isinstance(node, ast.Constant)
+                            and isinstance(node.value, str)
+                            and COMMENT in node.value
+                        ),
+                        None,
+                    )
+
+                    # If we didn't find a constant containing <COMMENT>,
+                    # then we didn't put this decorator
+                    if not reason:
+                        continue
+
+                    if ut_method.has_cond():
+                        cond = ast.unparse(dec_node.args[0])
+                else:
+                    # Search first on decorator line, then in the line before
+                    for line in lines[dec_node.lineno - 1 : dec_node.lineno - 3 : -1]:
+                        if found := re.search(rf"{COMMENT}.?(.*)", line):
+                            reason = found.group()
+                            break
+                    else:
+                        # Didn't find our `COMMENT` :)
+                        continue
+
+                reason = reason.removeprefix(COMMENT).strip(";:, ")
+                spec = PatchSpec(ut_method, cond, reason)
+                yield cls(parent_class, fn_node.name, spec)
+
+
+def iter_tests(
+    tree: ast.Module,
+) -> "Iterator[tuple[ast.ClassDef, ast.FunctionDef | ast.AsyncFunctionDef]]":
+    for key, nodes in ast.iter_fields(tree):
+        if key != "body":
+            continue
+
+        for cls_node in nodes:
+            if not isinstance(cls_node, ast.ClassDef):
+                continue
+
+            for fn_node in cls_node.body:
+                if not isinstance(fn_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                    continue
+
+                yield (cls_node, fn_node)
+
+
+def iter_patches(contents: str) -> "Iterator[PatchEntry]":
+    lines = contents.splitlines()
+    tree = ast.parse(contents)
+    yield from PatchEntry.iter_patch_entires(tree, lines)
+
+
+def build_patch_dict(it: "Iterator[PatchEntry]") -> Patches:
+    patches = collections.defaultdict(lambda: collections.defaultdict(list))
+    for entry in it:
+        patches[entry.parent_class][entry.test_name].append(entry.spec)
+
+    return {k: dict(v) for k, v in patches.items()}
+
+
+def iter_patch_lines(tree: ast.Module, patches: Patches) -> "Iterator[tuple[int, str]]":
+    cache = {}  # Used in phase 2. Stores the end line location of a class name.
+
+    # Phase 1: Iterate and mark existing tests
+    for cls_node, fn_node in iter_tests(tree):
+        cache[cls_node.name] = cls_node.end_lineno
+        specs = patches.get(cls_node.name, {}).pop(fn_node.name, None)
+        if not specs:
+            continue
+
+        lineno = min(
+            (dec_node.lineno for dec_node in fn_node.decorator_list),
+            default=fn_node.lineno,
+        )
+        indent = " " * fn_node.col_offset
+        patch_lines = "\n".join(spec.as_decorator() for spec in specs)
+        yield (lineno - 1, textwrap.indent(patch_lines, indent))
+
+    # Phase 2: Iterate and mark inhereted tests
+    for cls_name, tests in 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():
+            decorators = "\n".join(spec.as_decorator() for spec in specs)
+            patch_lines = f"""
+{decorators}
+def {test_name}(self):
+{DEFAULT_INDENT}return super().{test_name}()
+""".rstrip()
+            yield (lineno, textwrap.indent(patch_lines, DEFAULT_INDENT))
+
+
+def apply_patches(contents: str, patches: Patches) -> str:
+    tree = ast.parse(contents)
+    lines = contents.splitlines()
+
+    modifications = list(iter_patch_lines(tree, patches))
+    # Going in reverse to not distrupt the line offset
+    for lineno, patch in sorted(modifications, reverse=True):
+        lines.insert(lineno, patch)
+
+    joined = "\n".join(lines)
+    return f"{joined}\n"
+
+
+def write_output(data: str, dest: str) -> None:
+    if dest == "-":
+        print(data, end="")
+        return
+
+    with open(dest, "w") as fd:
+        fd.write(data)
+
+
+def build_argparse() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+
+    patches_group = parser.add_mutually_exclusive_group(required=True)
+    patches_group.add_argument(
+        "--quick-upgrade",
+        help="Quick upgrade: path containing /Lib/ (e.g., cpython/Lib/test/foo.py)",
+        type=pathlib.Path,
+        metavar="PATH",
+    )
+    patches_group.add_argument(
+        "-p",
+        "--patches",
+        help="File path to file containing patches in a JSON format",
+        type=pathlib.Path,
+    )
+    patches_group.add_argument(
+        "--from",
+        help="File to gather patches from",
+        dest="gather_from",
+        type=pathlib.Path,
+    )
+
+    group = parser.add_mutually_exclusive_group(required=False)
+    group.add_argument(
+        "--to",
+        help="File to apply patches to",
+        type=pathlib.Path,
+    )
+    group.add_argument(
+        "--show-patches", action="store_true", help="Show the patches and exit"
+    )
+
+    parser.add_argument(
+        "-o", "--output", default="-", help="Output file. Set to '-' for stdout"
+    )
+
+    return parser
+
+
+if __name__ == "__main__":
+    parser = build_argparse()
+    args = parser.parse_args()
+
+    # Quick upgrade: auto-fill --from, --to, -o from path
+    if args.quick_upgrade is not None:
+        # Normalize path separators to forward slashes for cross-platform support
+        path_str = str(args.quick_upgrade).replace("\\", "/")
+        lib_marker = "/Lib/"
+
+        if lib_marker not in path_str:
+            parser.error(
+                f"--quick-upgrade path must contain '/Lib/' or '\\Lib\\' (got: {args.quick_upgrade})"
+            )
+
+        idx = path_str.index(lib_marker)
+        lib_path = pathlib.Path(path_str[idx + 1 :])
+
+        args.gather_from = lib_path
+        args.to = args.quick_upgrade
+        if args.output == "-":
+            args.output = str(lib_path)
+
+    # Validate required arguments
+    if args.patches is None and args.gather_from is None:
+        parser.error("--from or --patches is required (or use --quick-upgrade)")
+    if args.to is None and not args.show_patches:
+        parser.error("--to or --show-patches is required")
+
+    if args.patches:
+        patches = {
+            cls_name: {
+                test_name: [
+                    PatchSpec(**spec)._replace(ut_method=UtMethod(spec["ut_method"]))
+                    for spec in specs
+                ]
+                for test_name, specs in tests.items()
+            }
+            for cls_name, tests in json.loads(args.patches.read_text()).items()
+        }
+    else:
+        patches = build_patch_dict(iter_patches(args.gather_from.read_text()))
+
+    if args.show_patches:
+        patches = {
+            cls_name: {
+                test_name: [spec._asdict() for spec in specs]
+                for test_name, specs in tests.items()
+            }
+            for cls_name, tests in patches.items()
+        }
+        output = json.dumps(patches, indent=4) + "\n"
+        write_output(output, args.output)
+        sys.exit(0)
+
+    patched = apply_patches(args.to.read_text(), patches)
+    write_output(patched, args.output)
diff --git a/scripts/libc_posix.py b/scripts/libc_posix.py
new file mode 100644
index 0000000000..73f082a065
--- /dev/null
+++ b/scripts/libc_posix.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+import collections
+import re
+import urllib.request
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+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)
+
+
+LIBC_VERSION = "0.2.177"
+
+EXCLUDE = frozenset(
+    {
+        # Defined at `vm/src/stdlib/os.rs`
+        "O_APPEND",
+        "O_CREAT",
+        "O_EXCL",
+        "O_RDONLY",
+        "O_RDWR",
+        "O_TRUNC",
+        "O_WRONLY",
+        "SEEK_CUR",
+        "SEEK_END",
+        "SEEK_SET",
+        # Functions, not consts
+        "WCOREDUMP",
+        "WIFCONTINUED",
+        "WIFSTOPPED",
+        "WIFSIGNALED",
+        "WIFEXITED",
+        "WEXITSTATUS",
+        "WSTOPSIG",
+        "WTERMSIG",
+        # False positive
+        # "EOF",
+    }
+)
+
+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 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 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,
+    )
+    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
+        )
+        if not target_oses:
+            continue
+
+        group_consts[target_oses].add(const)
+    group_consts = {grp: v | EXTRAS.get(grp, set()) for grp, v in group_consts.items()}
+
+    code = "\n\n".join(
+        f"""
+{cfg}
+#[pyattr]
+{use}
+""".strip()
+        for cfg, use in format_groups(group_consts)
+    )
+
+    print(code)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/make_ssl_data_rs.py b/scripts/make_ssl_data_rs.py
new file mode 100755
index 0000000000..a089fe6ee0
--- /dev/null
+++ b/scripts/make_ssl_data_rs.py
@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+
+"""
+Generate Rust SSL error mapping code from OpenSSL sources.
+
+This is based on CPython's Tools/ssl/make_ssl_data.py but generates
+Rust code instead of C headers.
+
+It takes two arguments:
+- the path to the OpenSSL source tree (e.g. git checkout)
+- the path to the Rust file to be generated (e.g. stdlib/src/ssl/ssl_data.rs)
+- error codes are version specific
+"""
+
+import argparse
+import datetime
+import operator
+import os
+import re
+import sys
+
+parser = argparse.ArgumentParser(
+    description="Generate ssl_data.rs from OpenSSL sources"
+)
+parser.add_argument("srcdir", help="OpenSSL source directory")
+parser.add_argument("output", nargs="?", default=None)
+
+
+def _file_search(fname, pat):
+    with open(fname, encoding="utf-8") as f:
+        for line in f:
+            match = pat.search(line)
+            if match is not None:
+                yield match
+
+
+def parse_err_h(args):
+    """Parse err codes, e.g. ERR_LIB_X509: 11"""
+    pat = re.compile(r"#\s*define\W+ERR_LIB_(\w+)\s+(\d+)")
+    lib2errnum = {}
+    for match in _file_search(args.err_h, pat):
+        libname, num = match.groups()
+        lib2errnum[libname] = int(num)
+
+    return lib2errnum
+
+
+def parse_openssl_error_text(args):
+    """Parse error reasons, X509_R_AKID_MISMATCH"""
+    # ignore backslash line continuation for now
+    pat = re.compile(r"^((\w+?)_R_(\w+)):(\d+):")
+    for match in _file_search(args.errtxt, pat):
+        reason, libname, errname, num = match.groups()
+        if "_F_" in reason:
+            # ignore function codes
+            continue
+        num = int(num)
+        yield reason, libname, errname, num
+
+
+def parse_extra_reasons(args):
+    """Parse extra reasons from openssl.ec"""
+    pat = re.compile(r"^R\s+((\w+)_R_(\w+))\s+(\d+)")
+    for match in _file_search(args.errcodes, pat):
+        reason, libname, errname, num = match.groups()
+        num = int(num)
+        yield reason, libname, errname, num
+
+
+def gen_library_codes_rust(args):
+    """Generate Rust phf map for library codes"""
+    yield "// Maps lib_code -> library name"
+    yield '// Example: 20 -> "SSL"'
+    yield "pub static LIBRARY_CODES: phf::Map<u32, &'static str> = phf_map! {"
+
+    # Deduplicate: keep the last one if there are duplicates
+    seen = {}
+    for libname in sorted(args.lib2errnum):
+        lib_num = args.lib2errnum[libname]
+        seen[lib_num] = libname
+
+    for lib_num in sorted(seen.keys()):
+        libname = seen[lib_num]
+        yield f'    {lib_num}u32 => "{libname}",'
+    yield "};"
+    yield ""
+
+
+def gen_error_codes_rust(args):
+    """Generate Rust phf map for error codes"""
+    yield "// Maps encoded (lib, reason) -> error mnemonic"
+    yield '// Example: encode_error_key(20, 134) -> "CERTIFICATE_VERIFY_FAILED"'
+    yield "// Key encoding: (lib << 32) | reason"
+    yield "pub static ERROR_CODES: phf::Map<u64, &'static str> = phf_map! {"
+    for reason, libname, errname, num in args.reasons:
+        if libname not in args.lib2errnum:
+            continue
+        lib_num = args.lib2errnum[libname]
+        # Encode (lib, reason) as single u64
+        key = (lib_num << 32) | num
+        yield f'    {key}u64 => "{errname}",'
+    yield "};"
+    yield ""
+
+
+def main():
+    args = parser.parse_args()
+
+    args.err_h = os.path.join(args.srcdir, "include", "openssl", "err.h")
+    if not os.path.isfile(args.err_h):
+        # Fall back to infile for OpenSSL 3.0.0
+        args.err_h += ".in"
+    args.errcodes = os.path.join(args.srcdir, "crypto", "err", "openssl.ec")
+    args.errtxt = os.path.join(args.srcdir, "crypto", "err", "openssl.txt")
+
+    if not os.path.isfile(args.errtxt):
+        parser.error(f"File {args.errtxt} not found in srcdir\n.")
+
+    # {X509: 11, ...}
+    args.lib2errnum = parse_err_h(args)
+
+    # [('X509_R_AKID_MISMATCH', 'X509', 'AKID_MISMATCH', 110), ...]
+    reasons = []
+    reasons.extend(parse_openssl_error_text(args))
+    reasons.extend(parse_extra_reasons(args))
+    # sort by libname, numeric error code
+    args.reasons = sorted(reasons, key=operator.itemgetter(0, 3))
+
+    lines = [
+        "// File generated by tools/make_ssl_data_rs.py",
+        f"// Generated on {datetime.datetime.now(datetime.timezone.utc).isoformat()}",
+        f"// Source: OpenSSL from {args.srcdir}",
+        "// spell-checker: disable",
+        "",
+        "use phf::phf_map;",
+        "",
+    ]
+    lines.extend(gen_library_codes_rust(args))
+    lines.extend(gen_error_codes_rust(args))
+
+    # Add helper function
+    lines.extend(
+        [
+            "/// Helper function to create encoded key from (lib, reason) pair",
+            "#[inline]",
+            "pub fn encode_error_key(lib: i32, reason: i32) -> u64 {",
+            "    ((lib as u64) << 32) | (reason as u64 & 0xFFFFFFFF)",
+            "}",
+            "",
+        ]
+    )
+
+    if args.output is None:
+        for line in lines:
+            print(line)
+    else:
+        with open(args.output, "w") as output:
+            for line in lines:
+                print(line, file=output)
+
+        print(f"Generated {args.output}")
+        print(f"Found {len(args.lib2errnum)} library codes")
+        print(f"Found {len(args.reasons)} error codes")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/interpreter.rs b/src/interpreter.rs
index b79a1a0ffb..51667e724f 100644
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -26,15 +26,18 @@ pub type InitHook = Box<dyn FnOnce(&mut VirtualMachine)>;
 /// ```
 ///
 /// To add native modules:
-/// ```compile_fail
+/// ```
+/// use rustpython_vm::pymodule;
+///
+/// #[pymodule]
+/// mod your_module {}
+///
 /// let interpreter = rustpython::InterpreterConfig::new()
 ///     .init_stdlib()
-///     .init_hook(Box::new(|vm| {
-///         vm.add_native_module(
-///             "your_module_name".to_owned(),
-///             Box::new(your_module::make_module),
-///         );
-///     }))
+///     .add_native_module(
+///         "your_module_name".to_owned(),
+///         your_module::make_module,
+///     )
 ///     .interpreter();
 /// ```
 #[derive(Default)]
@@ -44,9 +47,12 @@ pub struct InterpreterConfig {
 }
 
 impl InterpreterConfig {
+    /// Creates a new interpreter configuration with default settings.
     pub fn new() -> Self {
         Self::default()
     }
+
+    /// Builds the interpreter with the current configuration.
     pub fn interpreter(self) -> Interpreter {
         let settings = self.settings.unwrap_or_default();
         Interpreter::with_init(settings, |vm| {
@@ -56,14 +62,23 @@ impl InterpreterConfig {
         })
     }
 
+    /// Sets custom settings for the interpreter.
+    ///
+    /// If called multiple times, only the last settings will be used.
     pub fn settings(mut self, settings: Settings) -> Self {
         self.settings = Some(settings);
         self
     }
+
+    /// Adds a custom initialization hook.
+    ///
+    /// Hooks are executed in the order they are added during interpreter creation.
     pub fn init_hook(mut self, hook: InitHook) -> Self {
         self.init_hooks.push(hook);
         self
     }
+
+    /// Adds a native module to the interpreter.
     pub fn add_native_module(
         self,
         name: String,
@@ -73,54 +88,75 @@ impl InterpreterConfig {
             vm.add_native_module(name, Box::new(make_module))
         }))
     }
+
+    /// Initializes the Python standard library.
+    ///
+    /// Requires the `stdlib` feature to be enabled.
     #[cfg(feature = "stdlib")]
     pub fn init_stdlib(self) -> Self {
         self.init_hook(Box::new(init_stdlib))
     }
 }
 
+/// Initializes all standard library modules for the given VM.
 #[cfg(feature = "stdlib")]
 pub fn init_stdlib(vm: &mut VirtualMachine) {
     vm.add_native_modules(rustpython_stdlib::get_module_inits());
 
-    // if we're on freeze-stdlib, the core stdlib modules will be included anyway
     #[cfg(feature = "freeze-stdlib")]
-    {
-        vm.add_frozen(rustpython_pylib::FROZEN_STDLIB);
-
-        // FIXME: Remove this hack once sys._stdlib_dir is properly implemented or _frozen_importlib doesn't depend on it anymore.
-        assert!(vm.sys_module.get_attr("_stdlib_dir", vm).is_err());
-        vm.sys_module
-            .set_attr(
-                "_stdlib_dir",
-                vm.new_pyobj(rustpython_pylib::LIB_PATH.to_owned()),
-                vm,
-            )
-            .unwrap();
-    }
+    setup_frozen_stdlib(vm);
 
     #[cfg(not(feature = "freeze-stdlib"))]
-    {
-        use rustpython_vm::common::rc::PyRc;
-
-        let state = PyRc::get_mut(&mut vm.state).unwrap();
-        let settings = &mut state.settings;
-
-        let path_list = std::mem::take(&mut settings.path_list);
-
-        // BUILDTIME_RUSTPYTHONPATH should be set when distributing
-        if let Some(paths) = option_env!("BUILDTIME_RUSTPYTHONPATH") {
-            settings.path_list.extend(
-                crate::settings::split_paths(paths)
-                    .map(|path| path.into_os_string().into_string().unwrap()),
-            )
-        } else {
-            #[cfg(feature = "rustpython-pylib")]
-            settings
-                .path_list
-                .push(rustpython_pylib::LIB_PATH.to_owned())
-        }
+    setup_dynamic_stdlib(vm);
+}
 
-        settings.path_list.extend(path_list);
+/// Setup frozen standard library (compiled into the binary)
+#[cfg(all(feature = "stdlib", feature = "freeze-stdlib"))]
+fn setup_frozen_stdlib(vm: &mut VirtualMachine) {
+    vm.add_frozen(rustpython_pylib::FROZEN_STDLIB);
+
+    // FIXME: Remove this hack once sys._stdlib_dir is properly implemented
+    // or _frozen_importlib doesn't depend on it anymore.
+    assert!(vm.sys_module.get_attr("_stdlib_dir", vm).is_err());
+    vm.sys_module
+        .set_attr(
+            "_stdlib_dir",
+            vm.new_pyobj(rustpython_pylib::LIB_PATH.to_owned()),
+            vm,
+        )
+        .unwrap();
+}
+
+/// Setup dynamic standard library loading from filesystem
+#[cfg(all(feature = "stdlib", not(feature = "freeze-stdlib")))]
+fn setup_dynamic_stdlib(vm: &mut VirtualMachine) {
+    use rustpython_vm::common::rc::PyRc;
+
+    let state = PyRc::get_mut(&mut vm.state).unwrap();
+    let paths = collect_stdlib_paths();
+
+    // Insert at the beginning so stdlib comes before user paths
+    for path in paths.into_iter().rev() {
+        state.config.paths.module_search_paths.insert(0, path);
+    }
+}
+
+/// Collect standard library paths from build-time configuration
+#[cfg(all(feature = "stdlib", not(feature = "freeze-stdlib")))]
+fn collect_stdlib_paths() -> Vec<String> {
+    // BUILDTIME_RUSTPYTHONPATH should be set when distributing
+    if let Some(paths) = option_env!("BUILDTIME_RUSTPYTHONPATH") {
+        crate::settings::split_paths(paths)
+            .map(|path| path.into_os_string().into_string().unwrap())
+            .collect()
+    } else {
+        #[cfg(feature = "rustpython-pylib")]
+        {
+            vec![rustpython_pylib::LIB_PATH.to_owned()]
+        }
+        #[cfg(not(feature = "rustpython-pylib"))]
+        {
+            vec![]
+        }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 362adfba49..77c9095ad4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -49,7 +49,7 @@ mod interpreter;
 mod settings;
 mod shell;
 
-use rustpython_vm::{PyResult, VirtualMachine, scope::Scope};
+use rustpython_vm::{AsObject, PyObjectRef, PyResult, VirtualMachine, scope::Scope};
 use std::env;
 use std::io::IsTerminal;
 use std::process::ExitCode;
@@ -59,6 +59,14 @@ pub use rustpython_vm as vm;
 pub use settings::{InstallPipMode, RunMode, parse_opts};
 pub use shell::run_shell;
 
+#[cfg(all(
+    feature = "ssl",
+    not(any(feature = "ssl-rustls", feature = "ssl-openssl"))
+))]
+compile_error!(
+    "Feature \"ssl\" is now enabled by either \"ssl-rustls\" or \"ssl-openssl\" to be enabled. Do not manually pass \"ssl\" feature. To enable ssl-openssl, use --no-default-features to disable ssl-rustls"
+);
+
 /// The main cli of the `rustpython` interpreter. This function will return `std::process::ExitCode`
 /// based on the return code of the python code ran through the cli.
 pub fn run(init: impl FnOnce(&mut VirtualMachine) + 'static) -> ExitCode {
@@ -103,22 +111,7 @@ pub fn run(init: impl FnOnce(&mut VirtualMachine) + 'static) -> ExitCode {
     let interp = config.interpreter();
     let exitcode = interp.run(move |vm| run_rustpython(vm, run_mode));
 
-    ExitCode::from(exitcode)
-}
-
-fn setup_main_module(vm: &VirtualMachine) -> PyResult<Scope> {
-    let scope = vm.new_scope_with_builtins();
-    let main_module = vm.new_module("__main__", scope.globals.clone(), None);
-    main_module
-        .dict()
-        .set_item("__annotations__", vm.ctx.new_dict().into(), vm)
-        .expect("Failed to initialize __main__.__annotations__");
-
-    vm.sys_module
-        .get_attr("modules", vm)?
-        .set_item("__main__", main_module.into(), vm)?;
-
-    Ok(scope)
+    rustpython_vm::common::os::exit_code(exitcode)
 }
 
 fn get_pip(scope: Scope, vm: &VirtualMachine) -> PyResult<()> {
@@ -136,12 +129,12 @@ __import__("io").TextIOWrapper(
         .downcast()
         .expect("TextIOWrapper.read() should return str");
     eprintln!("running get-pip.py...");
-    vm.run_code_string(scope, getpip_code.as_str(), "get-pip.py".to_owned())?;
+    vm.run_string(scope, getpip_code.as_str(), "get-pip.py".to_owned())?;
     Ok(())
 }
 
 fn install_pip(installer: InstallPipMode, scope: Scope, vm: &VirtualMachine) -> PyResult<()> {
-    if cfg!(not(feature = "ssl")) {
+    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(),
@@ -154,22 +147,70 @@ fn install_pip(installer: InstallPipMode, scope: Scope, vm: &VirtualMachine) ->
     }
 }
 
+// pymain_run_file_obj in Modules/main.c
+fn run_file(vm: &VirtualMachine, scope: Scope, path: &str) -> PyResult<()> {
+    // Check if path is a package/directory with __main__.py
+    if let Some(_importer) = get_importer(path, vm)? {
+        vm.insert_sys_path(vm.new_pyobj(path))?;
+        let runpy = vm.import("runpy", 0)?;
+        let run_module_as_main = runpy.get_attr("_run_module_as_main", vm)?;
+        run_module_as_main.call((vm::identifier!(vm, __main__).to_owned(), false), vm)?;
+        return Ok(());
+    }
+
+    // Add script directory to sys.path[0]
+    if !vm.state.config.settings.safe_path {
+        let dir = std::path::Path::new(path)
+            .parent()
+            .and_then(|p| p.to_str())
+            .unwrap_or("");
+        vm.insert_sys_path(vm.new_pyobj(dir))?;
+    }
+
+    vm.run_any_file(scope, path)
+}
+
+fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
+    use rustpython_vm::builtins::PyDictRef;
+    use rustpython_vm::convert::TryFromObject;
+
+    let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
+    let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;
+    if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {
+        return Ok(Some(importer));
+    }
+    let path_obj = vm.ctx.new_str(path);
+    let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;
+    let mut importer = None;
+    let path_hooks: Vec<PyObjectRef> = path_hooks.try_into_value(vm)?;
+    for path_hook in path_hooks {
+        match path_hook.call((path_obj.clone(),), vm) {
+            Ok(imp) => {
+                importer = Some(imp);
+                break;
+            }
+            Err(e) if e.fast_isinstance(vm.ctx.exceptions.import_error) => continue,
+            Err(e) => return Err(e),
+        }
+    }
+    Ok(if let Some(imp) = importer {
+        let imp = path_importer_cache.get_or_insert(vm, path_obj.into(), || imp.clone())?;
+        Some(imp)
+    } else {
+        None
+    })
+}
+
+// pymain_run_python
 fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     #[cfg(feature = "flame-it")]
     let main_guard = flame::start_guard("RustPython main");
 
-    let scope = setup_main_module(vm)?;
-
-    if !vm.state.settings.safe_path {
-        // TODO: The prepending path depends on running mode
-        // See https://docs.python.org/3/using/cmdline.html#cmdoption-P
-        vm.run_code_string(
-            vm.new_scope_with_builtins(),
-            "import sys; sys.path.insert(0, '')",
-            "<embedded>".to_owned(),
-        )?;
-    }
+    let scope = vm.new_scope_with_main()?;
 
+    // Import site first, before setting sys.path[0]
+    // This matches CPython's behavior where site.removeduppaths() runs
+    // before sys.path[0] is set, preventing '' from being converted to cwd
     let site_result = vm.import("site", 0);
     if site_result.is_err() {
         warn!(
@@ -178,9 +219,31 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
         );
     }
 
+    // _PyPathConfig_ComputeSysPath0 - set sys.path[0] after site import
+    if !vm.state.config.settings.safe_path {
+        let path0: Option<String> = match &run_mode {
+            RunMode::Command(_) => Some(String::new()),
+            RunMode::Module(_) => env::current_dir()
+                .ok()
+                .and_then(|p| p.to_str().map(|s| s.to_owned())),
+            RunMode::Script(_) | RunMode::InstallPip(_) => None, // handled by run_script
+            RunMode::Repl => Some(String::new()),
+        };
+
+        if let Some(path) = path0 {
+            vm.insert_sys_path(vm.new_pyobj(path))?;
+        }
+    }
+
+    // Enable faulthandler if -X faulthandler, PYTHONFAULTHANDLER or -X dev is set
+    // _PyFaulthandler_Init()
+    if vm.state.config.settings.faulthandler {
+        let _ = vm.run_simple_string("import faulthandler; faulthandler.enable()");
+    }
+
     let is_repl = matches!(run_mode, RunMode::Repl);
-    if !vm.state.settings.quiet
-        && (vm.state.settings.verbose > 0 || (is_repl && std::io::stdin().is_terminal()))
+    if !vm.state.config.settings.quiet
+        && (vm.state.config.settings.verbose > 0 || (is_repl && std::io::stdin().is_terminal()))
     {
         eprintln!(
             "Welcome to the magnificent Rust Python {} interpreter \u{1f631} \u{1f596}",
@@ -198,7 +261,7 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
     let res = match run_mode {
         RunMode::Command(command) => {
             debug!("Running command {command}");
-            vm.run_code_string(scope.clone(), &command, "<stdin>".to_owned())
+            vm.run_string(scope.clone(), &command, "<string>".to_owned())
                 .map(drop)
         }
         RunMode::Module(module) => {
@@ -206,30 +269,32 @@ fn run_rustpython(vm: &VirtualMachine, run_mode: RunMode) -> PyResult<()> {
             vm.run_module(&module)
         }
         RunMode::InstallPip(installer) => install_pip(installer, scope.clone(), vm),
-        RunMode::Script(script) => {
-            debug!("Running script {}", &script);
-            vm.run_script(scope.clone(), &script)
+        RunMode::Script(script_path) => {
+            // pymain_run_file_obj
+            debug!("Running script {}", &script_path);
+            run_file(vm, scope.clone(), &script_path)
         }
         RunMode::Repl => Ok(()),
     };
-    if is_repl || vm.state.settings.inspect {
-        shell::run_shell(vm, scope)?;
+    let result = if is_repl || vm.state.config.settings.inspect {
+        shell::run_shell(vm, scope)
     } else {
-        res?;
-    }
+        res
+    };
 
     #[cfg(feature = "flame-it")]
     {
         main_guard.end();
-        if let Err(e) = write_profile(&vm.state.as_ref().settings) {
+        if let Err(e) = write_profile(&vm.state.as_ref().config.settings) {
             error!("Error writing profile information: {}", e);
         }
     }
-    Ok(())
+
+    result
 }
 
 #[cfg(feature = "flame-it")]
-fn write_profile(settings: &Settings) -> Result<(), Box<dyn std::error::Error>> {
+fn write_profile(settings: &Settings) -> Result<(), Box<dyn core::error::Error>> {
     use std::{fs, io};
 
     enum ProfileFormat {
@@ -287,13 +352,13 @@ mod tests {
     fn test_run_script() {
         interpreter().enter(|vm| {
             vm.unwrap_pyresult((|| {
-                let scope = setup_main_module(vm)?;
+                let scope = vm.new_scope_with_main()?;
                 // test file run
-                vm.run_script(scope, "extra_tests/snippets/dir_main/__main__.py")?;
+                vm.run_any_file(scope, "extra_tests/snippets/dir_main/__main__.py")?;
 
-                let scope = setup_main_module(vm)?;
-                // test module run
-                vm.run_script(scope, "extra_tests/snippets/dir_main")?;
+                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 00ee55bddd..7dd3c1a771 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -26,8 +26,8 @@ impl FromStr for InstallPipMode {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "ensurepip" => Ok(InstallPipMode::Ensurepip),
-            "get-pip" => Ok(InstallPipMode::GetPip),
+            "ensurepip" => Ok(Self::Ensurepip),
+            "get-pip" => Ok(Self::GetPip),
             _ => Err("--install-pip takes ensurepip or get-pip as first argument"),
         }
     }
@@ -267,8 +267,10 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
         };
         match &*name {
             "dev" => settings.dev_mode = true,
+            "faulthandler" => settings.faulthandler = true,
             "warn_default_encoding" => settings.warn_default_encoding = true,
             "no_sig_int" => settings.install_signal_handlers = false,
+            "no_debug_ranges" => settings.code_debug_ranges = false,
             "int_max_str_digits" => {
                 settings.int_max_str_digits = match value.unwrap().parse() {
                     Ok(digits) if digits == 0 || digits >= 640 => digits,
@@ -291,9 +293,31 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
 
     settings.warn_default_encoding =
         settings.warn_default_encoding || env_bool("PYTHONWARNDEFAULTENCODING");
+    settings.faulthandler = settings.faulthandler || env_bool("PYTHONFAULTHANDLER");
+    if env_bool("PYTHONNODEBUGRANGES") {
+        settings.code_debug_ranges = false;
+    }
+
+    // Parse PYTHONIOENCODING=encoding[:errors]
+    if let Some(val) = get_env("PYTHONIOENCODING")
+        && let Some(val_str) = val.to_str()
+        && !val_str.is_empty()
+    {
+        if let Some((enc, err)) = val_str.split_once(':') {
+            if !enc.is_empty() {
+                settings.stdio_encoding = Some(enc.to_owned());
+            }
+            if !err.is_empty() {
+                settings.stdio_errors = Some(err.to_owned());
+            }
+        } else {
+            settings.stdio_encoding = Some(val_str.to_owned());
+        }
+    }
 
     if settings.dev_mode {
-        settings.warnoptions.push("default".to_owned())
+        settings.warnoptions.push("default".to_owned());
+        settings.faulthandler = true;
     }
     if settings.bytes_warning > 0 {
         let warn = if settings.bytes_warning > 1 {
@@ -336,6 +360,7 @@ pub fn parse_opts() -> Result<(Settings, RunMode), lexopt::Error> {
 /// Helper function to retrieve a sequence of paths from an environment variable.
 fn get_paths(env_variable_name: &str) -> impl Iterator<Item = String> + '_ {
     env::var_os(env_variable_name)
+        .filter(|v| !v.is_empty())
         .into_iter()
         .flat_map(move |paths| {
             split_paths(&paths)
diff --git a/src/shell.rs b/src/shell.rs
index 4222f96271..d2e54c490a 100644
--- a/src/shell.rs
+++ b/src/shell.rs
@@ -1,7 +1,7 @@
 mod helper;
 
 use rustpython_compiler::{
-    CompileError, ParseError, parser::FStringErrorType, parser::LexicalErrorType,
+    CompileError, ParseError, parser::InterpolatedStringErrorType, parser::LexicalErrorType,
     parser::ParseErrorType,
 };
 use rustpython_vm::{
@@ -52,7 +52,7 @@ fn shell_exec(
         Err(CompileError::Parse(ParseError {
             error:
                 ParseErrorType::Lexical(LexicalErrorType::FStringError(
-                    FStringErrorType::UnterminatedTripleQuotedString,
+                    InterpolatedStringErrorType::UnterminatedTripleQuotedString,
                 )),
             ..
         })) => ShellExecResult::ContinueLine,
@@ -67,10 +67,11 @@ fn shell_exec(
             {
                 let loc = raw_location.start().to_usize();
                 let mut iter = source.chars();
-                if let Some(quote) = iter.nth(loc) {
-                    if iter.next() == Some(quote) && iter.next() == Some(quote) {
-                        return ShellExecResult::ContinueLine;
-                    }
+                if let Some(quote) = iter.nth(loc)
+                    && iter.next() == Some(quote)
+                    && iter.next() == Some(quote)
+                {
+                    return ShellExecResult::ContinueLine;
                 }
             };
 
@@ -86,11 +87,7 @@ fn shell_exec(
                             continuing_block
                         } // && p.location.is_some()
                         ParseErrorType::OtherError(msg) => {
-                            if msg.starts_with("Expected an indented block") {
-                                continuing_block
-                            } else {
-                                true
-                            }
+                            !msg.starts_with("Expected an indented block")
                         }
                         _ => true, // !matches!(p, ParseErrorType::UnrecognizedToken(Tok::Dedent, _))
                     }
@@ -212,6 +209,13 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> {
             ReadlineResult::Eof => {
                 break;
             }
+            #[cfg(unix)]
+            ReadlineResult::OsError(num) => {
+                let os_error =
+                    vm.new_exception_msg(vm.ctx.exceptions.os_error.to_owned(), format!("{num:?}"));
+                vm.print_exception(os_error);
+                break;
+            }
             ReadlineResult::Other(err) => {
                 eprintln!("Readline error: {err:?}");
                 break;
diff --git a/src/shell/helper.rs b/src/shell/helper.rs
index 0fe2f5ca93..493dc57846 100644
--- a/src/shell/helper.rs
+++ b/src/shell/helper.rs
@@ -54,7 +54,7 @@ fn split_idents_on_dot(line: &str) -> Option<(usize, Vec<String>)> {
 }
 
 impl<'vm> ShellHelper<'vm> {
-    pub fn new(vm: &'vm VirtualMachine, globals: PyDictRef) -> Self {
+    pub const fn new(vm: &'vm VirtualMachine, globals: PyDictRef) -> Self {
         ShellHelper { vm, globals }
     }
 
diff --git a/stdlib/Cargo.toml b/stdlib/Cargo.toml
deleted file mode 100644
index 82c935b2cf..0000000000
--- a/stdlib/Cargo.toml
+++ /dev/null
@@ -1,140 +0,0 @@
-[package]
-name = "rustpython-stdlib"
-description = "RustPython standard libraries in Rust."
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[features]
-default = ["compiler"]
-compiler = ["rustpython-vm/compiler"]
-threading = ["rustpython-common/threading", "rustpython-vm/threading"]
-sqlite = ["dep:libsqlite3-sys"]
-ssl = ["openssl", "openssl-sys", "foreign-types-shared", "openssl-probe"]
-ssl-vendor = ["ssl", "openssl/vendored"]
-tkinter = ["dep:tk-sys", "dep:tcl-sys"]
-
-[dependencies]
-# rustpython crates
-rustpython-derive = { workspace = true }
-rustpython-vm = { workspace = true, default-features = false }
-rustpython-common = { workspace = true }
-
-ahash = { workspace = true }
-ascii = { workspace = true }
-cfg-if = { workspace = true }
-crossbeam-utils = { workspace = true }
-hex = { workspace = true }
-itertools = { workspace = true }
-indexmap = { workspace = true }
-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 }
-
-memchr = { workspace = true }
-base64 = "0.22"
-csv-core = "0.1.11"
-dyn-clone = "1.0.10"
-pymath = { workspace = true }
-xml-rs = "0.8.14"
-
-# random
-rand_core = { workspace = true }
-mt19937 = "3.1"
-
-# Crypto:
-digest = "0.10.3"
-md-5 = "0.10.1"
-sha-1 = "0.10.0"
-sha2 = "0.10.2"
-sha3 = "0.10.1"
-blake2 = "0.10.4"
-
-## 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 }
-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", default-features = false, features = ["zlib-rs"] }
-libz-sys = { package = "libz-rs-sys", version = "0.5" }
-bzip2 = { version = "0.5", features = ["libbz2-rs-sys"] }
-
-# tkinter
-tk-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
-tcl-sys = { git = "https://github.com/arihant2math/tkinter.git", tag = "v0.2.0", optional = true }
-
-# 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.1.2", features = ["v1"] }
-
-# mmap
-[target.'cfg(all(unix, not(target_arch = "wasm32")))'.dependencies]
-memmap2 = "0.5.10"
-page_size = "0.6"
-
-[target.'cfg(all(unix, not(target_os = "redox"), not(target_os = "ios")))'.dependencies]
-termios = "0.3.3"
-
-[target.'cfg(unix)'.dependencies]
-rustix = { workspace = true }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-gethostname = "1.0.0"
-socket2 = { version = "0.5.8", features = ["all"] }
-dns-lookup = "2"
-openssl = { version = "0.10.72", optional = true }
-openssl-sys = { version = "0.9.80", optional = true }
-openssl-probe = { version = "0.1.5", optional = true }
-foreign-types-shared = { version = "0.1.1", optional = true }
-
-[target.'cfg(not(any(target_os = "android", target_arch = "wasm32")))'.dependencies]
-libsqlite3-sys = { version = "0.28", features = ["bundled"], optional = true }
-lzma-sys = "0.1"
-xz2 = "0.1"
-
-[target.'cfg(windows)'.dependencies]
-junction = { workspace = true }
-paste = { workspace = true }
-schannel = { workspace = true }
-widestring = { workspace = true }
-
-[target.'cfg(windows)'.dependencies.windows-sys]
-workspace = true
-features = [
-  "Win32_Networking_WinSock",
-  "Win32_NetworkManagement_IpHelper",
-  "Win32_NetworkManagement_Ndis",
-  "Win32_Security_Cryptography",
-  "Win32_System_Environment",
-  "Win32_System_IO"
-]
-
-[target.'cfg(target_os = "macos")'.dependencies]
-system-configuration = "0.6.1"
-
-[lints]
-workspace = true
diff --git a/stdlib/build.rs b/stdlib/build.rs
deleted file mode 100644
index b7bf630715..0000000000
--- a/stdlib/build.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-// spell-checker:ignore ossl osslconf
-
-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)]
-    let ossl_vers = [
-        (0x1_00_01_00_0, "ossl101"),
-        (0x1_00_02_00_0, "ossl102"),
-        (0x1_01_00_00_0, "ossl110"),
-        (0x1_01_00_07_0, "ossl110g"),
-        (0x1_01_00_08_0, "ossl110h"),
-        (0x1_01_01_00_0, "ossl111"),
-        (0x1_01_01_04_0, "ossl111d"),
-        (0x3_00_00_00_0, "ossl300"),
-        (0x3_01_00_00_0, "ossl310"),
-        (0x3_02_00_00_0, "ossl320"),
-        (0x3_03_00_00_0, "ossl330"),
-    ];
-
-    for (_, cfg) in ossl_vers {
-        println!("cargo::rustc-check-cfg=cfg({cfg})");
-    }
-
-    #[allow(clippy::unusual_byte_groupings)]
-    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
-        let version = u64::from_str_radix(&v, 16).unwrap();
-        for (ver, cfg) in ossl_vers {
-            if version >= ver {
-                println!("cargo:rustc-cfg={cfg}");
-            }
-        }
-    }
-    if let Ok(v) = std::env::var("DEP_OPENSSL_CONF") {
-        for conf in v.split(',') {
-            println!("cargo:rustc-cfg=osslconf=\"{conf}\"");
-        }
-    }
-    // it's possible for openssl-sys to link against the system openssl under certain conditions,
-    // so let the ssl module know to only perform a probe if we're actually vendored
-    if std::env::var("DEP_OPENSSL_VENDORED").is_ok_and(|s| s == "1") {
-        println!("cargo::rustc-cfg=openssl_vendored")
-    }
-}
diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs
deleted file mode 100644
index 05d059e424..0000000000
--- a/stdlib/src/array.rs
+++ /dev/null
@@ -1,1668 +0,0 @@
-// spell-checker:ignore typecode tofile tolist fromfile
-
-use rustpython_vm::{PyRef, VirtualMachine, builtins::PyModule};
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = array::make_module(vm);
-
-    let array = module
-        .get_attr("array", vm)
-        .expect("Expect array has array type.");
-
-    let collections_abc = vm
-        .import("collections.abc", 0)
-        .expect("Expect collections exist.");
-    let abc = collections_abc
-        .get_attr("abc", vm)
-        .expect("Expect collections has abc submodule.");
-    let mutable_sequence = abc
-        .get_attr("MutableSequence", vm)
-        .expect("Expect collections.abc has MutableSequence type.");
-
-    let register = &mutable_sequence
-        .get_attr("register", vm)
-        .expect("Expect collections.abc.MutableSequence has register method.");
-    register
-        .call((array,), vm)
-        .expect("Expect collections.abc.MutableSequence.register(array.array) not fail.");
-
-    module
-}
-
-#[pymodule(name = "array")]
-mod array {
-    use crate::{
-        common::{
-            atomic::{self, AtomicUsize},
-            lock::{
-                PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyMutex, PyRwLock,
-                PyRwLockReadGuard, PyRwLockWriteGuard,
-            },
-            str::wchar_t,
-        },
-        vm::{
-            AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-            atomic_func,
-            builtins::{
-                PositionIterInternal, PyByteArray, PyBytes, PyBytesRef, PyDictRef, PyFloat,
-                PyGenericAlias, PyInt, PyList, PyListRef, PyStr, PyStrRef, PyTupleRef, PyTypeRef,
-            },
-            class_or_notimplemented,
-            convert::{ToPyObject, ToPyResult, TryFromBorrowedObject, TryFromObject},
-            function::{
-                ArgBytesLike, ArgIntoFloat, ArgIterable, KwArgs, OptionalArg, PyComparisonValue,
-            },
-            protocol::{
-                BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, PyIterReturn,
-                PyMappingMethods, PySequenceMethods,
-            },
-            sequence::{OptionalRangeArgs, SequenceExt, SequenceMutExt},
-            sliceable::{
-                SaturatedSlice, SequenceIndex, SequenceIndexOp, SliceableSequenceMutOp,
-                SliceableSequenceOp,
-            },
-            types::{
-                AsBuffer, AsMapping, AsSequence, Comparable, Constructor, IterNext, Iterable,
-                PyComparisonOp, Representable, SelfIter,
-            },
-        },
-    };
-    use itertools::Itertools;
-    use num_traits::ToPrimitive;
-    use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-    use std::{cmp::Ordering, fmt, os::raw};
-
-    macro_rules! def_array_enum {
-        ($(($n:ident, $t:ty, $c:literal, $scode:literal)),*$(,)?) => {
-            #[derive(Debug, Clone)]
-            pub enum ArrayContentType {
-                $($n(Vec<$t>),)*
-            }
-
-            impl ArrayContentType {
-                fn from_char(c: char) -> Result<Self, String> {
-                    match c {
-                        $($c => Ok(ArrayContentType::$n(Vec::new())),)*
-                        _ => Err(
-                            "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)".into()
-                        ),
-                    }
-                }
-
-                const fn typecode(&self) -> char {
-                    match self {
-                        $(ArrayContentType::$n(_) => $c,)*
-                    }
-                }
-
-                const fn typecode_str(&self) -> &'static str {
-                    match self {
-                        $(ArrayContentType::$n(_) => $scode,)*
-                    }
-                }
-
-                const fn itemsize_of_typecode(c: char) -> Option<usize> {
-                    match c {
-                        $($c => Some(std::mem::size_of::<$t>()),)*
-                        _ => None,
-                    }
-                }
-
-                const fn itemsize(&self) -> usize {
-                    match self {
-                        $(ArrayContentType::$n(_) => std::mem::size_of::<$t>(),)*
-                    }
-                }
-
-                fn addr(&self) -> usize {
-                    match self {
-                        $(ArrayContentType::$n(v) => v.as_ptr() as usize,)*
-                    }
-                }
-
-                fn len(&self) -> usize {
-                    match self {
-                        $(ArrayContentType::$n(v) => v.len(),)*
-                    }
-                }
-
-                fn reserve(&mut self, len: usize) {
-                    match self {
-                        $(ArrayContentType::$n(v) => v.reserve(len),)*
-                    }
-                }
-
-                fn push(&mut self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            let val = <$t>::try_into_from_object(vm, obj)?;
-                            v.push(val);
-                        })*
-                    }
-                    Ok(())
-                }
-
-                fn pop(&mut self, i: isize, vm: &VirtualMachine) -> PyResult {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                        let i = v.wrap_index(i).ok_or_else(|| {
-                            vm.new_index_error("pop index out of range".to_owned())
-                        })?;
-                            v.remove(i).to_pyresult(vm)
-                        })*
-                    }
-                }
-
-                fn insert(
-                    &mut self,
-                    i: isize,
-                    obj: PyObjectRef,
-                    vm: &VirtualMachine
-                ) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            let val = <$t>::try_into_from_object(vm, obj)?;
-                            v.insert(i.saturated_at(v.len()), val);
-                        })*
-                    }
-                    Ok(())
-                }
-
-                fn count(&self, obj: PyObjectRef, vm: &VirtualMachine) -> usize {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
-                                v.iter().filter(|&&a| a == val).count()
-                            } else {
-                                0
-                            }
-                        })*
-                    }
-                }
-
-                fn remove(&mut self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()>{
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
-                                if let Some(pos) = v.iter().position(|&a| a == val) {
-                                    v.remove(pos);
-                                    return Ok(());
-                                }
-                            }
-                            Err(vm.new_value_error("array.remove(x): x not in array".to_owned()))
-                        })*
-                    }
-                }
-
-                fn frombytes_move(&mut self, b: Vec<u8>) {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            if v.is_empty() {
-                                // safe because every configuration of bytes for the types we
-                                // support are valid
-                                let b = std::mem::ManuallyDrop::new(b);
-                                let ptr = b.as_ptr() as *mut $t;
-                                let len = b.len() / std::mem::size_of::<$t>();
-                                let capacity = b.capacity() / std::mem::size_of::<$t>();
-                                *v = unsafe { Vec::from_raw_parts(ptr, len, capacity) };
-                            } else {
-                                self.frombytes(&b);
-                            }
-                        })*
-                    }
-                }
-
-                fn frombytes(&mut self, b: &[u8]) {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // safe because every configuration of bytes for the types we
-                            // support are valid
-                            if b.len() > 0 {
-                                let ptr = b.as_ptr() as *const $t;
-                                let ptr_len = b.len() / std::mem::size_of::<$t>();
-                                let slice = unsafe { std::slice::from_raw_parts(ptr, ptr_len) };
-                                v.extend_from_slice(slice);
-                            }
-                        })*
-                    }
-                }
-
-                fn fromlist(&mut self, list: &PyList, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // convert list before modify self
-                            let mut list: Vec<$t> = list
-                                .borrow_vec()
-                                .iter()
-                                .cloned()
-                                .map(|value| <$t>::try_into_from_object(vm, value))
-                                .try_collect()?;
-                            v.append(&mut list);
-                            Ok(())
-                        })*
-                    }
-                }
-
-                fn get_bytes(&self) -> &[u8] {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // safe because we're just reading memory as bytes
-                            let ptr = v.as_ptr() as *const u8;
-                            let ptr_len = v.len() * std::mem::size_of::<$t>();
-                            unsafe { std::slice::from_raw_parts(ptr, ptr_len) }
-                        })*
-                    }
-                }
-
-                fn get_bytes_mut(&mut self) -> &mut [u8] {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // safe because we're just reading memory as bytes
-                            let ptr = v.as_ptr() as *mut u8;
-                            let ptr_len = v.len() * std::mem::size_of::<$t>();
-                            unsafe { std::slice::from_raw_parts_mut(ptr, ptr_len) }
-                        })*
-                    }
-                }
-
-                fn index(
-                    &self,
-                    obj: PyObjectRef,
-                    start: usize,
-                    stop: usize,
-                    vm: &VirtualMachine
-                ) -> PyResult<usize> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            if let Ok(val) = <$t>::try_into_from_object(vm, obj) {
-                                if let Some(pos) = v.iter().take(stop as _).skip(start as _).position(|&elem| elem == val) {
-                                    return Ok(pos + start);
-                                }
-                            }
-                            Err(vm.new_value_error("array.index(x): x not in array".to_owned()))
-                        })*
-                    }
-                }
-
-                fn reverse(&mut self) {
-                    match self {
-                        $(ArrayContentType::$n(v) => v.reverse(),)*
-                    }
-                }
-
-                fn get(
-                    &self,
-                    i: usize,
-                    vm: &VirtualMachine
-                ) -> Option<PyResult> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            v.get(i).map(|x| x.to_pyresult(vm))
-                        })*
-                    }
-                }
-
-                fn getitem_by_index(&self, i: isize, vm: &VirtualMachine) -> PyResult {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            v.getitem_by_index(vm, i).map(|x| x.to_pyresult(vm))?
-                        })*
-                    }
-                }
-
-                fn getitem_by_slice(&self, slice: SaturatedSlice, vm: &VirtualMachine) -> PyResult {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            let r = v.getitem_by_slice(vm, slice)?;
-                            let array = PyArray::from(ArrayContentType::$n(r));
-                            array.to_pyresult(vm)
-                        })*
-                    }
-                }
-
-                fn setitem_by_index(
-                    &mut self,
-                    i: isize,
-                    value: PyObjectRef,
-                    vm: &VirtualMachine
-                ) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            let value = <$t>::try_into_from_object(vm, value)?;
-                            v.setitem_by_index(vm, i, value)
-                        })*
-                    }
-                }
-
-                fn setitem_by_slice(
-                    &mut self,
-                    slice: SaturatedSlice,
-                    items: &ArrayContentType,
-                    vm: &VirtualMachine
-                ) -> PyResult<()> {
-                    match self {
-                        $(Self::$n(elements) => if let ArrayContentType::$n(items) = items {
-                            elements.setitem_by_slice(vm, slice, items)
-                        } else {
-                            Err(vm.new_type_error(
-                                "bad argument type for built-in operation".to_owned()
-                            ))
-                        },)*
-                    }
-                }
-
-                fn setitem_by_slice_no_resize(
-                    &mut self,
-                    slice: SaturatedSlice,
-                    items: &ArrayContentType,
-                    vm: &VirtualMachine
-                ) -> PyResult<()> {
-                    match self {
-                        $(Self::$n(elements) => if let ArrayContentType::$n(items) = items {
-                            elements.setitem_by_slice_no_resize(vm, slice, items)
-                        } else {
-                            Err(vm.new_type_error(
-                                "bad argument type for built-in operation".to_owned()
-                            ))
-                        },)*
-                    }
-                }
-
-                fn delitem_by_index(&mut self, i: isize, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            v.delitem_by_index(vm, i)
-                        })*
-                    }
-                }
-
-                fn delitem_by_slice(&mut self, slice: SaturatedSlice, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            v.delitem_by_slice(vm, slice)
-                        })*
-                    }
-                }
-
-                fn add(&self, other: &ArrayContentType, vm: &VirtualMachine) -> PyResult<Self> {
-                    match self {
-                        $(ArrayContentType::$n(v) => if let ArrayContentType::$n(other) = other {
-                            let elements = v.iter().chain(other.iter()).cloned().collect();
-                            Ok(ArrayContentType::$n(elements))
-                        } else {
-                            Err(vm.new_type_error(
-                                "bad argument type for built-in operation".to_owned()
-                            ))
-                        },)*
-                    }
-                }
-
-                fn iadd(&mut self, other: &ArrayContentType, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => if let ArrayContentType::$n(other) = other {
-                            v.extend(other);
-                            Ok(())
-                        } else {
-                            Err(vm.new_type_error(
-                                "can only extend with array of same kind".to_owned()
-                            ))
-                        },)*
-                    }
-                }
-
-                fn mul(&self, value: isize, vm: &VirtualMachine) -> PyResult<Self> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // MemoryError instead Overflow Error, hard to says it is right
-                            // but it is how cpython doing right now
-                            let elements = v.mul(vm, value).map_err(|_| vm.new_memory_error("".to_owned()))?;
-                            Ok(ArrayContentType::$n(elements))
-                        })*
-                    }
-                }
-
-                fn imul(&mut self, value: isize, vm: &VirtualMachine) -> PyResult<()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            // MemoryError instead Overflow Error, hard to says it is right
-                            // but it is how cpython doing right now
-                            v.imul(vm, value).map_err(|_| vm.new_memory_error("".to_owned()))
-                        })*
-                    }
-                }
-
-                fn byteswap(&mut self) {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            for element in v.iter_mut() {
-                                let x = element.byteswap();
-                                *element = x;
-                            }
-                        })*
-                    }
-                }
-
-                fn repr(&self, class_name: &str, _vm: &VirtualMachine) -> PyResult<String> {
-                    // we don't need ReprGuard here
-                    let s = match self {
-                        $(ArrayContentType::$n(v) => {
-                            if v.is_empty() {
-                                format!("{}('{}')", class_name, $c)
-                            } else {
-                                format!("{}('{}', [{}])", class_name, $c, v.iter().format(", "))
-                            }
-                        })*
-                    };
-                    Ok(s)
-                }
-
-                fn iter<'a, 'vm: 'a>(
-                    &'a self,
-                    vm: &'vm VirtualMachine
-                ) -> impl Iterator<Item = PyResult> + 'a {
-                    (0..self.len()).map(move |i| self.get(i, vm).unwrap())
-                }
-
-                fn cmp(&self, other: &ArrayContentType) -> Result<Option<Ordering>, ()> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            if let ArrayContentType::$n(other) = other {
-                                Ok(PartialOrd::partial_cmp(v, other))
-                            } else {
-                                Err(())
-                            }
-                        })*
-                    }
-                }
-
-                fn get_objects(&self, vm: &VirtualMachine) -> Vec<PyObjectRef> {
-                    match self {
-                        $(ArrayContentType::$n(v) => {
-                            v.iter().map(|&x| x.to_object(vm)).collect()
-                        })*
-                    }
-                }
-            }
-        };
-    }
-
-    def_array_enum!(
-        (SignedByte, i8, 'b', "b"),
-        (UnsignedByte, u8, 'B', "B"),
-        (PyUnicode, WideChar, 'u', "u"),
-        (SignedShort, raw::c_short, 'h', "h"),
-        (UnsignedShort, raw::c_ushort, 'H', "H"),
-        (SignedInt, raw::c_int, 'i', "i"),
-        (UnsignedInt, raw::c_uint, 'I', "I"),
-        (SignedLong, raw::c_long, 'l', "l"),
-        (UnsignedLong, raw::c_ulong, 'L', "L"),
-        (SignedLongLong, raw::c_longlong, 'q', "q"),
-        (UnsignedLongLong, raw::c_ulonglong, 'Q', "Q"),
-        (Float, f32, 'f', "f"),
-        (Double, f64, 'd', "d"),
-    );
-
-    #[derive(Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
-    pub struct WideChar(wchar_t);
-
-    trait ArrayElement: Sized {
-        fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self>;
-        fn byteswap(self) -> Self;
-        fn to_object(self, vm: &VirtualMachine) -> PyObjectRef;
-    }
-
-    macro_rules! impl_int_element {
-        ($($t:ty,)*) => {$(
-            impl ArrayElement for $t {
-                fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-                    obj.try_index(vm)?.try_to_primitive(vm)
-                }
-                fn byteswap(self) -> Self {
-                    <$t>::swap_bytes(self)
-                }
-                fn to_object(self, vm: &VirtualMachine) -> PyObjectRef {
-                    self.to_pyobject(vm)
-                }
-            }
-        )*};
-    }
-
-    macro_rules! impl_float_element {
-        ($(($t:ty, $f_from:path, $f_swap:path, $f_to:path),)*) => {$(
-            impl ArrayElement for $t {
-                fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-                    $f_from(vm, obj)
-                }
-                fn byteswap(self) -> Self {
-                    $f_swap(self)
-                }
-                fn to_object(self, vm: &VirtualMachine) -> PyObjectRef {
-                    $f_to(self).into_pyobject(vm)
-                }
-            }
-        )*};
-    }
-
-    impl_int_element!(i8, u8, i16, u16, i32, u32, i64, u64,);
-    impl_float_element!(
-        (
-            f32,
-            f32_try_into_from_object,
-            f32_swap_bytes,
-            pyfloat_from_f32
-        ),
-        (f64, f64_try_into_from_object, f64_swap_bytes, PyFloat::from),
-    );
-
-    const fn f32_swap_bytes(x: f32) -> f32 {
-        f32::from_bits(x.to_bits().swap_bytes())
-    }
-
-    const fn f64_swap_bytes(x: f64) -> f64 {
-        f64::from_bits(x.to_bits().swap_bytes())
-    }
-
-    fn f32_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f32> {
-        ArgIntoFloat::try_from_object(vm, obj).map(|x| *x as f32)
-    }
-
-    fn f64_try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<f64> {
-        ArgIntoFloat::try_from_object(vm, obj).map(Into::into)
-    }
-
-    fn pyfloat_from_f32(value: f32) -> PyFloat {
-        PyFloat::from(value as f64)
-    }
-
-    impl ArrayElement for WideChar {
-        fn try_into_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            PyStrRef::try_from_object(vm, obj)?
-                .as_str()
-                .chars()
-                .exactly_one()
-                .map(|ch| Self(ch as _))
-                .map_err(|_| vm.new_type_error("array item must be unicode character"))
-        }
-        fn byteswap(self) -> Self {
-            Self(self.0.swap_bytes())
-        }
-        fn to_object(self, _vm: &VirtualMachine) -> PyObjectRef {
-            unreachable!()
-        }
-    }
-
-    fn u32_to_char(ch: u32) -> Result<CodePoint, String> {
-        CodePoint::from_u32(ch)
-            .ok_or_else(|| format!("character U+{ch:4x} is not in range [U+0000; U+10ffff]"))
-    }
-
-    impl TryFrom<WideChar> for CodePoint {
-        type Error = String;
-
-        fn try_from(ch: WideChar) -> Result<Self, Self::Error> {
-            // safe because every configuration of bytes for the types we support are valid
-            u32_to_char(ch.0 as _)
-        }
-    }
-
-    impl ToPyResult for WideChar {
-        fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
-            Ok(CodePoint::try_from(self)
-                .map_err(|e| vm.new_unicode_encode_error(e))?
-                .to_pyobject(vm))
-        }
-    }
-
-    impl fmt::Display for WideChar {
-        fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            unreachable!("`repr(array('u'))` calls `PyStr::repr`")
-        }
-    }
-
-    #[pyattr]
-    #[pyattr(name = "ArrayType")]
-    #[pyclass(name = "array")]
-    #[derive(Debug, PyPayload)]
-    pub struct PyArray {
-        array: PyRwLock<ArrayContentType>,
-        exports: AtomicUsize,
-    }
-
-    pub type PyArrayRef = PyRef<PyArray>;
-
-    impl From<ArrayContentType> for PyArray {
-        fn from(array: ArrayContentType) -> Self {
-            Self {
-                array: PyRwLock::new(array),
-                exports: AtomicUsize::new(0),
-            }
-        }
-    }
-
-    #[derive(FromArgs)]
-    pub struct ArrayNewArgs {
-        #[pyarg(positional)]
-        spec: PyStrRef,
-        #[pyarg(positional, optional)]
-        init: OptionalArg<PyObjectRef>,
-    }
-
-    impl Constructor for PyArray {
-        type Args = (ArrayNewArgs, KwArgs);
-
-        fn py_new(
-            cls: PyTypeRef,
-            (ArrayNewArgs { spec, init }, kwargs): Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            let spec = spec.as_str().chars().exactly_one().map_err(|_| {
-                vm.new_type_error("array() argument 1 must be a unicode character, not str")
-            })?;
-
-            if cls.is(Self::class(&vm.ctx)) && !kwargs.is_empty() {
-                return Err(vm.new_type_error("array.array() takes no keyword arguments"));
-            }
-
-            let mut array =
-                ArrayContentType::from_char(spec).map_err(|err| vm.new_value_error(err))?;
-
-            if let OptionalArg::Present(init) = init {
-                if let Some(init) = init.payload::<Self>() {
-                    match (spec, init.read().typecode()) {
-                        (spec, ch) if spec == ch => array.frombytes(&init.get_bytes()),
-                        (spec, 'u') => {
-                            return Err(vm.new_type_error(format!(
-                            "cannot use a unicode array to initialize an array with typecode '{spec}'"
-                        )))
-                        }
-                        _ => {
-                            for obj in init.read().iter(vm) {
-                                array.push(obj?, vm)?;
-                            }
-                        }
-                    }
-                } else if let Some(wtf8) = init.payload::<PyStr>() {
-                    if spec == 'u' {
-                        let bytes = Self::_unicode_to_wchar_bytes(wtf8.as_wtf8(), array.itemsize());
-                        array.frombytes_move(bytes);
-                    } else {
-                        return Err(vm.new_type_error(format!(
-                            "cannot use a str to initialize an array with typecode '{spec}'"
-                        )));
-                    }
-                } else if init.payload_is::<PyBytes>() || init.payload_is::<PyByteArray>() {
-                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
-                } else if let Ok(iter) = ArgIterable::try_from_object(vm, init.clone()) {
-                    for obj in iter.iter(vm)? {
-                        array.push(obj?, vm)?;
-                    }
-                } else {
-                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
-                }
-            }
-
-            let zelf = Self::from(array).into_ref_with_type(vm, cls)?;
-            Ok(zelf.into())
-        }
-    }
-
-    #[pyclass(
-        flags(BASETYPE),
-        with(
-            Comparable,
-            AsBuffer,
-            AsMapping,
-            AsSequence,
-            Iterable,
-            Constructor,
-            Representable
-        )
-    )]
-    impl PyArray {
-        fn read(&self) -> PyRwLockReadGuard<'_, ArrayContentType> {
-            self.array.read()
-        }
-
-        fn write(&self) -> PyRwLockWriteGuard<'_, ArrayContentType> {
-            self.array.write()
-        }
-
-        #[pygetset]
-        fn typecode(&self, vm: &VirtualMachine) -> PyStrRef {
-            vm.ctx
-                .intern_str(self.read().typecode().to_string())
-                .to_owned()
-        }
-
-        #[pygetset]
-        fn itemsize(&self) -> usize {
-            self.read().itemsize()
-        }
-
-        #[pymethod]
-        fn append(zelf: &Py<Self>, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.try_resizable(vm)?.push(x, vm)
-        }
-
-        #[pymethod]
-        fn buffer_info(&self) -> (usize, usize) {
-            let array = self.read();
-            (array.addr(), array.len())
-        }
-
-        #[pymethod]
-        fn count(&self, x: PyObjectRef, vm: &VirtualMachine) -> usize {
-            self.read().count(x, vm)
-        }
-
-        #[pymethod]
-        fn remove(zelf: &Py<Self>, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.try_resizable(vm)?.remove(x, vm)
-        }
-
-        #[pymethod]
-        fn extend(zelf: &Py<Self>, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let mut w = zelf.try_resizable(vm)?;
-            if zelf.is(&obj) {
-                w.imul(2, vm)
-            } else if let Some(array) = obj.payload::<Self>() {
-                w.iadd(&array.read(), vm)
-            } else {
-                let iter = ArgIterable::try_from_object(vm, obj)?;
-                // zelf.extend_from_iterable(iter, vm)
-                for obj in iter.iter(vm)? {
-                    w.push(obj?, vm)?;
-                }
-                Ok(())
-            }
-        }
-
-        fn _wchar_bytes_to_string(
-            bytes: &[u8],
-            item_size: usize,
-            vm: &VirtualMachine,
-        ) -> PyResult<Wtf8Buf> {
-            if item_size == 2 {
-                // safe because every configuration of bytes for the types we support are valid
-                let utf16 = unsafe {
-                    std::slice::from_raw_parts(
-                        bytes.as_ptr() as *const u16,
-                        bytes.len() / std::mem::size_of::<u16>(),
-                    )
-                };
-                Ok(Wtf8Buf::from_wide(utf16))
-            } else {
-                // safe because every configuration of bytes for the types we support are valid
-                let chars = unsafe {
-                    std::slice::from_raw_parts(
-                        bytes.as_ptr() as *const u32,
-                        bytes.len() / std::mem::size_of::<u32>(),
-                    )
-                };
-                chars
-                    .iter()
-                    .map(|&ch| {
-                        // cpython issue 17223
-                        u32_to_char(ch).map_err(|msg| vm.new_value_error(msg))
-                    })
-                    .try_collect()
-            }
-        }
-
-        fn _unicode_to_wchar_bytes(wtf8: &Wtf8, item_size: usize) -> Vec<u8> {
-            if item_size == 2 {
-                wtf8.encode_wide().flat_map(|ch| ch.to_ne_bytes()).collect()
-            } else {
-                wtf8.code_points()
-                    .flat_map(|ch| ch.to_u32().to_ne_bytes())
-                    .collect()
-            }
-        }
-
-        #[pymethod]
-        fn fromunicode(zelf: &Py<Self>, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let wtf8: &Wtf8 = obj.try_to_value(vm).map_err(|_| {
-                vm.new_type_error(format!(
-                    "fromunicode() argument must be str, not {}",
-                    obj.class().name()
-                ))
-            })?;
-            if zelf.read().typecode() != 'u' {
-                return Err(
-                    vm.new_value_error("fromunicode() may only be called on unicode type arrays")
-                );
-            }
-            let mut w = zelf.try_resizable(vm)?;
-            let bytes = Self::_unicode_to_wchar_bytes(wtf8, w.itemsize());
-            w.frombytes_move(bytes);
-            Ok(())
-        }
-
-        #[pymethod]
-        fn tounicode(&self, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
-            let array = self.array.read();
-            if array.typecode() != 'u' {
-                return Err(
-                    vm.new_value_error("tounicode() may only be called on unicode type arrays")
-                );
-            }
-            let bytes = array.get_bytes();
-            Self::_wchar_bytes_to_string(bytes, self.itemsize(), vm)
-        }
-
-        fn _from_bytes(&self, b: &[u8], itemsize: usize, vm: &VirtualMachine) -> PyResult<()> {
-            if b.len() % itemsize != 0 {
-                return Err(vm.new_value_error("bytes length not a multiple of item size"));
-            }
-            if b.len() / itemsize > 0 {
-                self.try_resizable(vm)?.frombytes(b);
-            }
-            Ok(())
-        }
-
-        #[pymethod]
-        fn frombytes(&self, b: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
-            let b = b.borrow_buf();
-            let itemsize = self.read().itemsize();
-            self._from_bytes(&b, itemsize, vm)
-        }
-
-        #[pymethod]
-        fn fromfile(&self, f: PyObjectRef, n: isize, vm: &VirtualMachine) -> PyResult<()> {
-            let itemsize = self.itemsize();
-            if n < 0 {
-                return Err(vm.new_value_error("negative count"));
-            }
-            let n = vm.check_repeat_or_overflow_error(itemsize, n)?;
-            let n_bytes = n * itemsize;
-
-            let b = vm.call_method(&f, "read", (n_bytes,))?;
-            let b = b
-                .downcast::<PyBytes>()
-                .map_err(|_| vm.new_type_error("read() didn't return bytes"))?;
-
-            let not_enough_bytes = b.len() != n_bytes;
-
-            self._from_bytes(b.as_bytes(), itemsize, vm)?;
-
-            if not_enough_bytes {
-                Err(vm.new_exception_msg(
-                    vm.ctx.exceptions.eof_error.to_owned(),
-                    "read() didn't return enough bytes".to_owned(),
-                ))
-            } else {
-                Ok(())
-            }
-        }
-
-        #[pymethod]
-        fn byteswap(&self) {
-            self.write().byteswap();
-        }
-
-        #[pymethod]
-        fn index(
-            &self,
-            x: PyObjectRef,
-            range: OptionalRangeArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<usize> {
-            let (start, stop) = range.saturate(self.__len__(), vm)?;
-            self.read().index(x, start, stop, vm)
-        }
-
-        #[pymethod]
-        fn insert(zelf: &Py<Self>, i: isize, x: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let mut w = zelf.try_resizable(vm)?;
-            w.insert(i, x, vm)
-        }
-
-        #[pymethod]
-        fn pop(zelf: &Py<Self>, i: OptionalArg<isize>, vm: &VirtualMachine) -> PyResult {
-            let mut w = zelf.try_resizable(vm)?;
-            if w.len() == 0 {
-                Err(vm.new_index_error("pop from empty array"))
-            } else {
-                w.pop(i.unwrap_or(-1), vm)
-            }
-        }
-
-        #[pymethod]
-        pub(crate) fn tobytes(&self) -> Vec<u8> {
-            self.read().get_bytes().to_vec()
-        }
-
-        #[pymethod]
-        fn tofile(&self, f: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            /* Write 64K blocks at a time */
-            /* XXX Make the block size settable */
-            const BLOCKSIZE: usize = 64 * 1024;
-
-            let bytes = self.read();
-            let bytes = bytes.get_bytes();
-
-            for b in bytes.chunks(BLOCKSIZE) {
-                let b = PyBytes::from(b.to_vec()).into_ref(&vm.ctx);
-                vm.call_method(&f, "write", (b,))?;
-            }
-            Ok(())
-        }
-
-        pub(crate) fn get_bytes(&self) -> PyMappedRwLockReadGuard<'_, [u8]> {
-            PyRwLockReadGuard::map(self.read(), |a| a.get_bytes())
-        }
-
-        pub(crate) fn get_bytes_mut(&self) -> PyMappedRwLockWriteGuard<'_, [u8]> {
-            PyRwLockWriteGuard::map(self.write(), |a| a.get_bytes_mut())
-        }
-
-        #[pymethod]
-        fn tolist(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-            let array = self.read();
-            let mut v = Vec::with_capacity(array.len());
-            for obj in array.iter(vm) {
-                v.push(obj?);
-            }
-            Ok(v)
-        }
-
-        #[pymethod]
-        fn fromlist(zelf: &Py<Self>, list: PyListRef, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.try_resizable(vm)?.fromlist(&list, vm)
-        }
-
-        #[pymethod]
-        fn reverse(&self) {
-            self.write().reverse()
-        }
-
-        #[pymethod]
-        fn __copy__(&self) -> Self {
-            self.array.read().clone().into()
-        }
-
-        #[pymethod]
-        fn __deepcopy__(&self, _memo: PyObjectRef) -> Self {
-            self.__copy__()
-        }
-
-        fn getitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
-            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
-                SequenceIndex::Int(i) => self.read().getitem_by_index(i, vm),
-                SequenceIndex::Slice(slice) => self.read().getitem_by_slice(slice, vm),
-            }
-        }
-
-        #[pymethod]
-        fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-            self.getitem_inner(&needle, vm)
-        }
-
-        fn setitem_inner(
-            zelf: &Py<Self>,
-            needle: &PyObject,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
-                SequenceIndex::Int(i) => zelf.write().setitem_by_index(i, value, vm),
-                SequenceIndex::Slice(slice) => {
-                    let cloned;
-                    let guard;
-                    let items = if zelf.is(&value) {
-                        cloned = zelf.read().clone();
-                        &cloned
-                    } else {
-                        match value.payload::<Self>() {
-                            Some(array) => {
-                                guard = array.read();
-                                &*guard
-                            }
-                            None => {
-                                return Err(vm.new_type_error(format!(
-                                    "can only assign array (not \"{}\") to array slice",
-                                    value.class()
-                                )));
-                            }
-                        }
-                    };
-                    if let Ok(mut w) = zelf.try_resizable(vm) {
-                        w.setitem_by_slice(slice, items, vm)
-                    } else {
-                        zelf.write().setitem_by_slice_no_resize(slice, items, vm)
-                    }
-                }
-            }
-        }
-
-        #[pymethod]
-        fn __setitem__(
-            zelf: &Py<Self>,
-            needle: PyObjectRef,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            Self::setitem_inner(zelf, &needle, value, vm)
-        }
-
-        fn delitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-            match SequenceIndex::try_from_borrowed_object(vm, needle, "array")? {
-                SequenceIndex::Int(i) => self.try_resizable(vm)?.delitem_by_index(i, vm),
-                SequenceIndex::Slice(slice) => self.try_resizable(vm)?.delitem_by_slice(slice, vm),
-            }
-        }
-
-        #[pymethod]
-        fn __delitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            self.delitem_inner(&needle, vm)
-        }
-
-        #[pymethod]
-        fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-            if let Some(other) = other.payload::<Self>() {
-                self.read()
-                    .add(&other.read(), vm)
-                    .map(|array| Self::from(array).into_ref(&vm.ctx))
-            } else {
-                Err(vm.new_type_error(format!(
-                    "can only append array (not \"{}\") to array",
-                    other.class().name()
-                )))
-            }
-        }
-
-        #[pymethod]
-        fn __iadd__(
-            zelf: PyRef<Self>,
-            other: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyRef<Self>> {
-            if zelf.is(&other) {
-                zelf.try_resizable(vm)?.imul(2, vm)?;
-            } else if let Some(other) = other.payload::<Self>() {
-                zelf.try_resizable(vm)?.iadd(&other.read(), vm)?;
-            } else {
-                return Err(vm.new_type_error(format!(
-                    "can only extend array with array (not \"{}\")",
-                    other.class().name()
-                )));
-            }
-            Ok(zelf)
-        }
-
-        #[pymethod(name = "__rmul__")]
-        #[pymethod]
-        fn __mul__(&self, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-            self.read()
-                .mul(value, vm)
-                .map(|x| Self::from(x).into_ref(&vm.ctx))
-        }
-
-        #[pymethod]
-        fn __imul__(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-            zelf.try_resizable(vm)?.imul(value, vm)?;
-            Ok(zelf)
-        }
-
-        #[pymethod]
-        pub(crate) fn __len__(&self) -> usize {
-            self.read().len()
-        }
-
-        fn array_eq(&self, other: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-            // we cannot use zelf.is(other) for shortcut because if we contenting a
-            // float value NaN we always return False even they are the same object.
-            if self.__len__() != other.__len__() {
-                return Ok(false);
-            }
-            let array_a = self.read();
-            let array_b = other.read();
-
-            // fast path for same ArrayContentType type
-            if let Ok(ord) = array_a.cmp(&array_b) {
-                return Ok(ord == Some(Ordering::Equal));
-            }
-
-            let iter = Iterator::zip(array_a.iter(vm), array_b.iter(vm));
-
-            for (a, b) in iter {
-                if !vm.bool_eq(&*a?, &*b?)? {
-                    return Ok(false);
-                }
-            }
-            Ok(true)
-        }
-
-        #[pymethod]
-        fn __reduce_ex__(
-            zelf: &Py<Self>,
-            proto: usize,
-            vm: &VirtualMachine,
-        ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
-            if proto < 3 {
-                return Self::__reduce__(zelf, vm);
-            }
-            let array = zelf.read();
-            let cls = zelf.class().to_owned();
-            let typecode = vm.ctx.new_str(array.typecode_str());
-            let bytes = vm.ctx.new_bytes(array.get_bytes().to_vec());
-            let code = MachineFormatCode::from_typecode(array.typecode()).unwrap();
-            let code = PyInt::from(u8::from(code)).into_pyobject(vm);
-            let module = vm.import("array", 0)?;
-            let func = module.get_attr("_array_reconstructor", vm)?;
-            Ok((
-                func,
-                vm.new_tuple((cls, typecode, code, bytes)),
-                zelf.as_object().dict(),
-            ))
-        }
-
-        #[pymethod]
-        fn __reduce__(
-            zelf: &Py<Self>,
-            vm: &VirtualMachine,
-        ) -> PyResult<(PyObjectRef, PyTupleRef, Option<PyDictRef>)> {
-            let array = zelf.read();
-            let cls = zelf.class().to_owned();
-            let typecode = vm.ctx.new_str(array.typecode_str());
-            let values = if array.typecode() == 'u' {
-                let s = Self::_wchar_bytes_to_string(array.get_bytes(), array.itemsize(), vm)?;
-                s.code_points().map(|x| x.to_pyobject(vm)).collect()
-            } else {
-                array.get_objects(vm)
-            };
-            let values = vm.ctx.new_list(values);
-            Ok((
-                cls.into(),
-                vm.new_tuple((typecode, values)),
-                zelf.as_object().dict(),
-            ))
-        }
-
-        #[pymethod]
-        fn __contains__(&self, value: PyObjectRef, vm: &VirtualMachine) -> bool {
-            let array = self.array.read();
-            for element in array
-                .iter(vm)
-                .map(|x| x.expect("Expected to be checked by array.len() and read lock."))
-            {
-                if let Ok(true) =
-                    element.rich_compare_bool(value.as_object(), PyComparisonOp::Eq, vm)
-                {
-                    return true;
-                }
-            }
-
-            false
-        }
-
-        #[pyclassmethod]
-        fn __class_getitem__(
-            cls: PyTypeRef,
-            args: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyGenericAlias {
-            PyGenericAlias::from_args(cls, args, vm)
-        }
-    }
-
-    impl Comparable for PyArray {
-        fn cmp(
-            zelf: &Py<Self>,
-            other: &PyObject,
-            op: PyComparisonOp,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyComparisonValue> {
-            // TODO: deduplicate this logic with sequence::cmp in sequence.rs. Maybe make it generic?
-
-            // we cannot use zelf.is(other) for shortcut because if we contenting a
-            // float value NaN we always return False even they are the same object.
-            let other = class_or_notimplemented!(Self, other);
-
-            if let PyComparisonValue::Implemented(x) =
-                op.eq_only(|| Ok(zelf.array_eq(other, vm)?.into()))?
-            {
-                return Ok(x.into());
-            }
-
-            let array_a = zelf.read();
-            let array_b = other.read();
-
-            let res = match array_a.cmp(&array_b) {
-                // fast path for same ArrayContentType type
-                Ok(partial_ord) => partial_ord.is_some_and(|ord| op.eval_ord(ord)),
-                Err(()) => {
-                    let iter = Iterator::zip(array_a.iter(vm), array_b.iter(vm));
-
-                    for (a, b) in iter {
-                        let ret = match op {
-                            PyComparisonOp::Lt | PyComparisonOp::Le => {
-                                vm.bool_seq_lt(&*a?, &*b?)?
-                            }
-                            PyComparisonOp::Gt | PyComparisonOp::Ge => {
-                                vm.bool_seq_gt(&*a?, &*b?)?
-                            }
-                            _ => unreachable!(),
-                        };
-                        if let Some(v) = ret {
-                            return Ok(PyComparisonValue::Implemented(v));
-                        }
-                    }
-
-                    // fallback:
-                    op.eval_ord(array_a.len().cmp(&array_b.len()))
-                }
-            };
-
-            Ok(res.into())
-        }
-    }
-
-    impl AsBuffer for PyArray {
-        fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-            let array = zelf.read();
-            let buf = PyBuffer::new(
-                zelf.to_owned().into(),
-                BufferDescriptor::format(
-                    array.len() * array.itemsize(),
-                    false,
-                    array.itemsize(),
-                    array.typecode_str().into(),
-                ),
-                &BUFFER_METHODS,
-            );
-            Ok(buf)
-        }
-    }
-
-    impl Representable for PyArray {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let class = zelf.class();
-            let class_name = class.name();
-            if zelf.read().typecode() == 'u' {
-                if zelf.__len__() == 0 {
-                    return Ok(format!("{class_name}('u')"));
-                }
-                let to_unicode = zelf.tounicode(vm)?;
-                let escape = crate::vm::literal::escape::UnicodeEscape::new_repr(&to_unicode);
-                return Ok(format!("{}('u', {})", class_name, escape.str_repr()));
-            }
-            zelf.read().repr(&class_name, vm)
-        }
-    }
-
-    static BUFFER_METHODS: BufferMethods = BufferMethods {
-        obj_bytes: |buffer| buffer.obj_as::<PyArray>().get_bytes().into(),
-        obj_bytes_mut: |buffer| buffer.obj_as::<PyArray>().get_bytes_mut().into(),
-        release: |buffer| {
-            buffer
-                .obj_as::<PyArray>()
-                .exports
-                .fetch_sub(1, atomic::Ordering::Release);
-        },
-        retain: |buffer| {
-            buffer
-                .obj_as::<PyArray>()
-                .exports
-                .fetch_add(1, atomic::Ordering::Release);
-        },
-    };
-
-    impl AsMapping for PyArray {
-        fn as_mapping() -> &'static PyMappingMethods {
-            static AS_MAPPING: PyMappingMethods = PyMappingMethods {
-                length: atomic_func!(|mapping, _vm| Ok(
-                    PyArray::mapping_downcast(mapping).__len__()
-                )),
-                subscript: atomic_func!(|mapping, needle, vm| {
-                    PyArray::mapping_downcast(mapping).getitem_inner(needle, vm)
-                }),
-                ass_subscript: atomic_func!(|mapping, needle, value, vm| {
-                    let zelf = PyArray::mapping_downcast(mapping);
-                    if let Some(value) = value {
-                        PyArray::setitem_inner(zelf, needle, value, vm)
-                    } else {
-                        zelf.delitem_inner(needle, vm)
-                    }
-                }),
-            };
-            &AS_MAPPING
-        }
-    }
-
-    impl AsSequence for PyArray {
-        fn as_sequence() -> &'static PySequenceMethods {
-            static AS_SEQUENCE: PySequenceMethods = PySequenceMethods {
-                length: atomic_func!(|seq, _vm| Ok(PyArray::sequence_downcast(seq).__len__())),
-                concat: atomic_func!(|seq, other, vm| {
-                    let zelf = PyArray::sequence_downcast(seq);
-                    PyArray::__add__(zelf, other.to_owned(), vm).map(|x| x.into())
-                }),
-                repeat: atomic_func!(|seq, n, vm| {
-                    PyArray::sequence_downcast(seq)
-                        .__mul__(n, vm)
-                        .map(|x| x.into())
-                }),
-                item: atomic_func!(|seq, i, vm| {
-                    PyArray::sequence_downcast(seq)
-                        .read()
-                        .getitem_by_index(i, vm)
-                }),
-                ass_item: atomic_func!(|seq, i, value, vm| {
-                    let zelf = PyArray::sequence_downcast(seq);
-                    if let Some(value) = value {
-                        zelf.write().setitem_by_index(i, value, vm)
-                    } else {
-                        zelf.write().delitem_by_index(i, vm)
-                    }
-                }),
-                contains: atomic_func!(|seq, target, vm| {
-                    let zelf = PyArray::sequence_downcast(seq);
-                    Ok(zelf.__contains__(target.to_owned(), vm))
-                }),
-                inplace_concat: atomic_func!(|seq, other, vm| {
-                    let zelf = PyArray::sequence_downcast(seq).to_owned();
-                    PyArray::__iadd__(zelf, other.to_owned(), vm).map(|x| x.into())
-                }),
-                inplace_repeat: atomic_func!(|seq, n, vm| {
-                    let zelf = PyArray::sequence_downcast(seq).to_owned();
-                    PyArray::__imul__(zelf, n, vm).map(|x| x.into())
-                }),
-            };
-            &AS_SEQUENCE
-        }
-    }
-
-    impl Iterable for PyArray {
-        fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-            Ok(PyArrayIter {
-                internal: PyMutex::new(PositionIterInternal::new(zelf, 0)),
-            }
-            .into_pyobject(vm))
-        }
-    }
-
-    impl BufferResizeGuard for PyArray {
-        type Resizable<'a> = PyRwLockWriteGuard<'a, ArrayContentType>;
-
-        fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>> {
-            let w = self.write();
-            (self.exports.load(atomic::Ordering::SeqCst) == 0).then_some(w)
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(name = "arrayiterator", traverse)]
-    #[derive(Debug, PyPayload)]
-    pub struct PyArrayIter {
-        internal: PyMutex<PositionIterInternal<PyArrayRef>>,
-    }
-
-    #[pyclass(with(IterNext, Iterable), flags(HAS_DICT))]
-    impl PyArrayIter {
-        #[pymethod]
-        fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            self.internal
-                .lock()
-                .set_state(state, |obj, pos| pos.min(obj.__len__()), vm)
-        }
-
-        #[pymethod]
-        fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-            self.internal
-                .lock()
-                .builtins_iter_reduce(|x| x.clone().into(), vm)
-        }
-    }
-
-    impl SelfIter for PyArrayIter {}
-    impl IterNext for PyArrayIter {
-        fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-            zelf.internal.lock().next(|array, pos| {
-                Ok(match array.read().get(pos, vm) {
-                    Some(item) => PyIterReturn::Return(item?),
-                    None => PyIterReturn::StopIteration(None),
-                })
-            })
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct ReconstructorArgs {
-        #[pyarg(positional)]
-        arraytype: PyTypeRef,
-        #[pyarg(positional)]
-        typecode: PyStrRef,
-        #[pyarg(positional)]
-        mformat_code: MachineFormatCode,
-        #[pyarg(positional)]
-        items: PyBytesRef,
-    }
-
-    #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-    #[repr(u8)]
-    enum MachineFormatCode {
-        Int8 { signed: bool },                    // 0, 1
-        Int16 { signed: bool, big_endian: bool }, // 2, 3, 4, 5
-        Int32 { signed: bool, big_endian: bool }, // 6, 7, 8, 9
-        Int64 { signed: bool, big_endian: bool }, // 10, 11, 12, 13
-        Ieee754Float { big_endian: bool },        // 14, 15
-        Ieee754Double { big_endian: bool },       // 16, 17
-        Utf16 { big_endian: bool },               // 18, 19
-        Utf32 { big_endian: bool },               // 20, 21
-    }
-
-    impl From<MachineFormatCode> for u8 {
-        fn from(code: MachineFormatCode) -> Self {
-            use MachineFormatCode::*;
-            match code {
-                Int8 { signed } => signed as Self,
-                Int16 { signed, big_endian } => 2 + signed as Self * 2 + big_endian as Self,
-                Int32 { signed, big_endian } => 6 + signed as Self * 2 + big_endian as Self,
-                Int64 { signed, big_endian } => 10 + signed as Self * 2 + big_endian as Self,
-                Ieee754Float { big_endian } => 14 + big_endian as Self,
-                Ieee754Double { big_endian } => 16 + big_endian as Self,
-                Utf16 { big_endian } => 18 + big_endian as Self,
-                Utf32 { big_endian } => 20 + big_endian as Self,
-            }
-        }
-    }
-
-    impl TryFrom<u8> for MachineFormatCode {
-        type Error = u8;
-
-        fn try_from(code: u8) -> Result<Self, Self::Error> {
-            let big_endian = code % 2 != 0;
-            let signed = match code {
-                0 | 1 => code != 0,
-                2..=13 => (code - 2) % 4 >= 2,
-                _ => false,
-            };
-            match code {
-                0..=1 => Ok(Self::Int8 { signed }),
-                2..=5 => Ok(Self::Int16 { signed, big_endian }),
-                6..=9 => Ok(Self::Int32 { signed, big_endian }),
-                10..=13 => Ok(Self::Int64 { signed, big_endian }),
-                14..=15 => Ok(Self::Ieee754Float { big_endian }),
-                16..=17 => Ok(Self::Ieee754Double { big_endian }),
-                18..=19 => Ok(Self::Utf16 { big_endian }),
-                20..=21 => Ok(Self::Utf32 { big_endian }),
-                _ => Err(code),
-            }
-        }
-    }
-
-    impl<'a> TryFromBorrowedObject<'a> for MachineFormatCode {
-        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-            obj.try_to_ref::<PyInt>(vm)
-                .map_err(|_| {
-                    vm.new_type_error(format!(
-                        "an integer is required (got type {})",
-                        obj.class().name()
-                    ))
-                })?
-                .try_to_primitive::<i32>(vm)?
-                .to_u8()
-                .unwrap_or(u8::MAX)
-                .try_into()
-                .map_err(|_| {
-                    vm.new_value_error("third argument must be a valid machine format code.")
-                })
-        }
-    }
-
-    impl MachineFormatCode {
-        fn from_typecode(code: char) -> Option<Self> {
-            use std::mem::size_of;
-            let signed = code.is_ascii_uppercase();
-            let big_endian = cfg!(target_endian = "big");
-            let int_size = match code {
-                'b' | 'B' => return Some(Self::Int8 { signed }),
-                'u' => {
-                    return match size_of::<wchar_t>() {
-                        2 => Some(Self::Utf16 { big_endian }),
-                        4 => Some(Self::Utf32 { big_endian }),
-                        _ => None,
-                    };
-                }
-                'f' => {
-                    // Copied from CPython
-                    const Y: f32 = 16711938.0;
-                    return match &Y.to_ne_bytes() {
-                        b"\x4b\x7f\x01\x02" => Some(Self::Ieee754Float { big_endian: true }),
-                        b"\x02\x01\x7f\x4b" => Some(Self::Ieee754Float { big_endian: false }),
-                        _ => None,
-                    };
-                }
-                'd' => {
-                    // Copied from CPython
-                    const Y: f64 = 9006104071832581.0;
-                    return match &Y.to_ne_bytes() {
-                        b"\x43\x3f\xff\x01\x02\x03\x04\x05" => {
-                            Some(Self::Ieee754Double { big_endian: true })
-                        }
-                        b"\x05\x04\x03\x02\x01\xff\x3f\x43" => {
-                            Some(Self::Ieee754Double { big_endian: false })
-                        }
-                        _ => None,
-                    };
-                }
-                _ => ArrayContentType::itemsize_of_typecode(code)? as u8,
-            };
-            match int_size {
-                2 => Some(Self::Int16 { signed, big_endian }),
-                4 => Some(Self::Int32 { signed, big_endian }),
-                8 => Some(Self::Int64 { signed, big_endian }),
-                _ => None,
-            }
-        }
-        const fn item_size(self) -> usize {
-            match self {
-                Self::Int8 { .. } => 1,
-                Self::Int16 { .. } | Self::Utf16 { .. } => 2,
-                Self::Int32 { .. } | Self::Utf32 { .. } | Self::Ieee754Float { .. } => 4,
-                Self::Int64 { .. } | Self::Ieee754Double { .. } => 8,
-            }
-        }
-    }
-
-    fn check_array_type(typ: PyTypeRef, vm: &VirtualMachine) -> PyResult<PyTypeRef> {
-        if !typ.fast_issubclass(PyArray::class(&vm.ctx)) {
-            return Err(
-                vm.new_type_error(format!("{} is not a subtype of array.array", typ.name()))
-            );
-        }
-        Ok(typ)
-    }
-
-    fn check_type_code(spec: PyStrRef, 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",
-            )
-        })?;
-        ArrayContentType::from_char(spec)
-            .map_err(|_| vm.new_value_error("second argument must be a valid type code"))
-    }
-
-    macro_rules! chunk_to_obj {
-        ($BYTE:ident, $TY:ty, $BIG_ENDIAN:ident) => {{
-            let b = <[u8; ::std::mem::size_of::<$TY>()]>::try_from($BYTE).unwrap();
-            if $BIG_ENDIAN {
-                <$TY>::from_be_bytes(b)
-            } else {
-                <$TY>::from_le_bytes(b)
-            }
-        }};
-        ($VM:ident, $BYTE:ident, $TY:ty, $BIG_ENDIAN:ident) => {
-            chunk_to_obj!($BYTE, $TY, $BIG_ENDIAN).to_pyobject($VM)
-        };
-        ($VM:ident, $BYTE:ident, $SIGNED_TY:ty, $UNSIGNED_TY:ty, $SIGNED:ident, $BIG_ENDIAN:ident) => {{
-            let b = <[u8; ::std::mem::size_of::<$SIGNED_TY>()]>::try_from($BYTE).unwrap();
-            match ($SIGNED, $BIG_ENDIAN) {
-                (false, false) => <$UNSIGNED_TY>::from_le_bytes(b).to_pyobject($VM),
-                (false, true) => <$UNSIGNED_TY>::from_be_bytes(b).to_pyobject($VM),
-                (true, false) => <$SIGNED_TY>::from_le_bytes(b).to_pyobject($VM),
-                (true, true) => <$SIGNED_TY>::from_be_bytes(b).to_pyobject($VM),
-            }
-        }};
-    }
-
-    #[pyfunction]
-    fn _array_reconstructor(args: ReconstructorArgs, vm: &VirtualMachine) -> PyResult<PyArrayRef> {
-        let cls = check_array_type(args.arraytype, vm)?;
-        let mut array = check_type_code(args.typecode, vm)?;
-        let format = args.mformat_code;
-        let bytes = args.items.as_bytes();
-        if bytes.len() % format.item_size() != 0 {
-            return Err(vm.new_value_error("bytes length not a multiple of item size"));
-        }
-        if MachineFormatCode::from_typecode(array.typecode()) == Some(format) {
-            array.frombytes(bytes);
-            return PyArray::from(array).into_ref_with_type(vm, cls);
-        }
-        if !matches!(
-            format,
-            MachineFormatCode::Utf16 { .. } | MachineFormatCode::Utf32 { .. }
-        ) {
-            array.reserve(bytes.len() / format.item_size());
-        }
-        let mut chunks = bytes.chunks(format.item_size());
-        match format {
-            MachineFormatCode::Ieee754Float { big_endian } => {
-                chunks.try_for_each(|b| array.push(chunk_to_obj!(vm, b, f32, big_endian), vm))?
-            }
-            MachineFormatCode::Ieee754Double { big_endian } => {
-                chunks.try_for_each(|b| array.push(chunk_to_obj!(vm, b, f64, big_endian), vm))?
-            }
-            MachineFormatCode::Int8 { signed } => chunks
-                .try_for_each(|b| array.push(chunk_to_obj!(vm, b, i8, u8, signed, false), vm))?,
-            MachineFormatCode::Int16 { signed, big_endian } => chunks.try_for_each(|b| {
-                array.push(chunk_to_obj!(vm, b, i16, u16, signed, big_endian), vm)
-            })?,
-            MachineFormatCode::Int32 { signed, big_endian } => chunks.try_for_each(|b| {
-                array.push(chunk_to_obj!(vm, b, i32, u32, signed, big_endian), vm)
-            })?,
-            MachineFormatCode::Int64 { signed, big_endian } => chunks.try_for_each(|b| {
-                array.push(chunk_to_obj!(vm, b, i64, u64, signed, big_endian), vm)
-            })?,
-            MachineFormatCode::Utf16 { big_endian } => {
-                let utf16: Vec<_> = chunks.map(|b| chunk_to_obj!(b, u16, big_endian)).collect();
-                let s = String::from_utf16(&utf16)
-                    .map_err(|_| vm.new_unicode_encode_error("items cannot decode as utf16"))?;
-                let bytes = PyArray::_unicode_to_wchar_bytes((*s).as_ref(), array.itemsize());
-                array.frombytes_move(bytes);
-            }
-            MachineFormatCode::Utf32 { big_endian } => {
-                let s: Wtf8Buf = chunks
-                    .map(|b| chunk_to_obj!(b, u32, big_endian))
-                    .map(|ch| u32_to_char(ch).map_err(|msg| vm.new_value_error(msg)))
-                    .try_collect()?;
-                let bytes = PyArray::_unicode_to_wchar_bytes(&s, array.itemsize());
-                array.frombytes_move(bytes);
-            }
-        };
-        PyArray::from(array).into_ref_with_type(vm, cls)
-    }
-}
diff --git a/stdlib/src/cmath.rs b/stdlib/src/cmath.rs
deleted file mode 100644
index e5d1d55a57..0000000000
--- a/stdlib/src/cmath.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-// TODO: Keep track of rust-num/num-complex/issues/2. A common trait could help with duplication
-//       that exists between cmath and math.
-pub(crate) use cmath::make_module;
-#[pymodule]
-mod cmath {
-    use crate::vm::{
-        PyResult, VirtualMachine,
-        function::{ArgIntoComplex, ArgIntoFloat, OptionalArg},
-    };
-    use num_complex::Complex64;
-
-    // Constants
-    #[pyattr]
-    use std::f64::consts::{E as e, PI as pi, TAU as tau};
-    #[pyattr(name = "inf")]
-    const INF: f64 = f64::INFINITY;
-    #[pyattr(name = "nan")]
-    const NAN: f64 = f64::NAN;
-    #[pyattr(name = "infj")]
-    const INFJ: Complex64 = Complex64::new(0., f64::INFINITY);
-    #[pyattr(name = "nanj")]
-    const NANJ: Complex64 = Complex64::new(0., f64::NAN);
-
-    #[pyfunction]
-    fn phase(z: ArgIntoComplex) -> f64 {
-        z.arg()
-    }
-
-    #[pyfunction]
-    fn polar(x: ArgIntoComplex) -> (f64, f64) {
-        x.to_polar()
-    }
-
-    #[pyfunction]
-    fn rect(r: ArgIntoFloat, phi: ArgIntoFloat) -> Complex64 {
-        Complex64::from_polar(*r, *phi)
-    }
-
-    #[pyfunction]
-    fn isinf(z: ArgIntoComplex) -> bool {
-        let Complex64 { re, im } = *z;
-        re.is_infinite() || im.is_infinite()
-    }
-
-    #[pyfunction]
-    fn isfinite(z: ArgIntoComplex) -> bool {
-        z.is_finite()
-    }
-
-    #[pyfunction]
-    fn isnan(z: ArgIntoComplex) -> bool {
-        z.is_nan()
-    }
-
-    #[pyfunction]
-    fn exp(z: ArgIntoComplex, vm: &VirtualMachine) -> PyResult<Complex64> {
-        let z = *z;
-        result_or_overflow(z, z.exp(), vm)
-    }
-
-    #[pyfunction]
-    fn sqrt(z: ArgIntoComplex) -> Complex64 {
-        z.sqrt()
-    }
-
-    #[pyfunction]
-    fn sin(z: ArgIntoComplex) -> Complex64 {
-        z.sin()
-    }
-
-    #[pyfunction]
-    fn asin(z: ArgIntoComplex) -> Complex64 {
-        z.asin()
-    }
-
-    #[pyfunction]
-    fn cos(z: ArgIntoComplex) -> Complex64 {
-        z.cos()
-    }
-
-    #[pyfunction]
-    fn acos(z: ArgIntoComplex) -> Complex64 {
-        z.acos()
-    }
-
-    #[pyfunction]
-    fn log(z: ArgIntoComplex, base: OptionalArg<ArgIntoComplex>) -> Complex64 {
-        // TODO: Complex64.log with a negative base yields wrong results.
-        //       Issue is with num_complex::Complex64 implementation of log
-        //       which returns NaN when base is negative.
-        //       log10(z) / log10(base) yields correct results but division
-        //       doesn't handle pos/neg zero nicely. (i.e log(1, 0.5))
-        z.log(
-            base.into_option()
-                .map(|base| base.re)
-                .unwrap_or(std::f64::consts::E),
-        )
-    }
-
-    #[pyfunction]
-    fn log10(z: ArgIntoComplex) -> Complex64 {
-        z.log(10.0)
-    }
-
-    #[pyfunction]
-    fn acosh(z: ArgIntoComplex) -> Complex64 {
-        z.acosh()
-    }
-
-    #[pyfunction]
-    fn atan(z: ArgIntoComplex) -> Complex64 {
-        z.atan()
-    }
-
-    #[pyfunction]
-    fn atanh(z: ArgIntoComplex) -> Complex64 {
-        z.atanh()
-    }
-
-    #[pyfunction]
-    fn tan(z: ArgIntoComplex) -> Complex64 {
-        z.tan()
-    }
-
-    #[pyfunction]
-    fn tanh(z: ArgIntoComplex) -> Complex64 {
-        z.tanh()
-    }
-
-    #[pyfunction]
-    fn sinh(z: ArgIntoComplex) -> Complex64 {
-        z.sinh()
-    }
-
-    #[pyfunction]
-    fn cosh(z: ArgIntoComplex) -> Complex64 {
-        z.cosh()
-    }
-
-    #[pyfunction]
-    fn asinh(z: ArgIntoComplex) -> Complex64 {
-        z.asinh()
-    }
-
-    #[derive(FromArgs)]
-    struct IsCloseArgs {
-        #[pyarg(positional)]
-        a: ArgIntoComplex,
-        #[pyarg(positional)]
-        b: ArgIntoComplex,
-        #[pyarg(named, optional)]
-        rel_tol: OptionalArg<ArgIntoFloat>,
-        #[pyarg(named, optional)]
-        abs_tol: OptionalArg<ArgIntoFloat>,
-    }
-
-    #[pyfunction]
-    fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
-        let a = *args.a;
-        let b = *args.b;
-        let rel_tol = args.rel_tol.map_or(1e-09, Into::into);
-        let abs_tol = args.abs_tol.map_or(0.0, Into::into);
-
-        if rel_tol < 0.0 || abs_tol < 0.0 {
-            return Err(vm.new_value_error("tolerances must be non-negative"));
-        }
-
-        if a == b {
-            /* short circuit exact equality -- needed to catch two infinities of
-            the same sign. And perhaps speeds things up a bit sometimes.
-            */
-            return Ok(true);
-        }
-
-        /* This catches the case of two infinities of opposite sign, or
-        one infinity and one finite number. Two infinities of opposite
-        sign would otherwise have an infinite relative tolerance.
-        Two infinities of the same sign are caught by the equality check
-        above.
-        */
-        if a.is_infinite() || b.is_infinite() {
-            return Ok(false);
-        }
-
-        let diff = c_abs(b - a);
-
-        Ok(diff <= (rel_tol * c_abs(b)) || (diff <= (rel_tol * c_abs(a))) || diff <= abs_tol)
-    }
-
-    #[inline]
-    fn c_abs(Complex64 { re, im }: Complex64) -> f64 {
-        re.hypot(im)
-    }
-
-    #[inline]
-    fn result_or_overflow(
-        value: Complex64,
-        result: Complex64,
-        vm: &VirtualMachine,
-    ) -> PyResult<Complex64> {
-        if !result.is_finite() && value.is_finite() {
-            // CPython doesn't return `inf` when called with finite
-            // values, it raises OverflowError instead.
-            Err(vm.new_overflow_error("math range error"))
-        } else {
-            Ok(result)
-        }
-    }
-}
diff --git a/stdlib/src/dis.rs b/stdlib/src/dis.rs
deleted file mode 100644
index 341137f91f..0000000000
--- a/stdlib/src/dis.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-pub(crate) use decl::make_module;
-
-#[pymodule(name = "dis")]
-mod decl {
-    use crate::vm::{
-        PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyCode, PyDictRef, PyStrRef},
-        bytecode::CodeFlags,
-    };
-
-    #[pyfunction]
-    fn dis(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let co = if let Ok(co) = obj.get_attr("__code__", vm) {
-            // Method or function:
-            PyRef::try_from_object(vm, co)?
-        } else if let Ok(co_str) = PyStrRef::try_from_object(vm, obj.clone()) {
-            #[cfg(not(feature = "compiler"))]
-            {
-                let _ = co_str;
-                return Err(
-                    vm.new_runtime_error("dis.dis() with str argument requires `compiler` feature")
-                );
-            }
-            #[cfg(feature = "compiler")]
-            {
-                vm.compile(
-                    co_str.as_str(),
-                    crate::vm::compiler::Mode::Exec,
-                    "<dis>".to_owned(),
-                )
-                .map_err(|err| vm.new_syntax_error(&err, Some(co_str.as_str())))?
-            }
-        } else {
-            PyRef::try_from_object(vm, obj)?
-        };
-        disassemble(co)
-    }
-
-    #[pyfunction]
-    fn disassemble(co: PyRef<PyCode>) -> PyResult<()> {
-        print!("{}", &co.code);
-        Ok(())
-    }
-
-    #[pyattr(name = "COMPILER_FLAG_NAMES")]
-    fn compiler_flag_names(vm: &VirtualMachine) -> PyDictRef {
-        let dict = vm.ctx.new_dict();
-        for (name, flag) in CodeFlags::NAME_MAPPING {
-            dict.set_item(
-                &*vm.new_pyobj(flag.bits()),
-                vm.ctx.new_str(*name).into(),
-                vm,
-            )
-            .unwrap();
-        }
-        dict
-    }
-}
diff --git a/stdlib/src/faulthandler.rs b/stdlib/src/faulthandler.rs
deleted file mode 100644
index f358129c87..0000000000
--- a/stdlib/src/faulthandler.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-pub(crate) use decl::make_module;
-
-#[pymodule(name = "faulthandler")]
-mod decl {
-    use crate::vm::{VirtualMachine, frame::Frame, function::OptionalArg, stdlib::sys::PyStderr};
-
-    fn dump_frame(frame: &Frame, vm: &VirtualMachine) {
-        let stderr = PyStderr(vm);
-        writeln!(
-            stderr,
-            "  File \"{}\", line {} in {}",
-            frame.code.source_path,
-            frame.current_location().row,
-            frame.code.obj_name
-        )
-    }
-
-    #[pyfunction]
-    fn dump_traceback(
-        _file: OptionalArg<i64>,
-        _all_threads: OptionalArg<bool>,
-        vm: &VirtualMachine,
-    ) {
-        let stderr = PyStderr(vm);
-        writeln!(stderr, "Stack (most recent call first):");
-
-        for frame in vm.frames.borrow().iter() {
-            dump_frame(frame, vm);
-        }
-    }
-
-    #[derive(FromArgs)]
-    #[allow(unused)]
-    struct EnableArgs {
-        #[pyarg(any, default)]
-        file: Option<i64>,
-        #[pyarg(any, default = true)]
-        all_threads: bool,
-    }
-
-    #[pyfunction]
-    const fn enable(_args: EnableArgs) {
-        // TODO
-    }
-
-    #[derive(FromArgs)]
-    #[allow(unused)]
-    struct RegisterArgs {
-        #[pyarg(positional)]
-        signum: i64,
-        #[pyarg(any, default)]
-        file: Option<i64>,
-        #[pyarg(any, default = true)]
-        all_threads: bool,
-        #[pyarg(any, default = false)]
-        chain: bool,
-    }
-
-    #[pyfunction]
-    const fn register(_args: RegisterArgs) {
-        // TODO
-    }
-}
diff --git a/stdlib/src/json.rs b/stdlib/src/json.rs
deleted file mode 100644
index afc9af234b..0000000000
--- a/stdlib/src/json.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-pub(crate) use _json::make_module;
-mod machinery;
-
-#[pymodule]
-mod _json {
-    use super::machinery;
-    use crate::vm::{
-        AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyStrRef, PyType, PyTypeRef},
-        convert::{ToPyObject, ToPyResult},
-        function::{IntoFuncArgs, OptionalArg},
-        protocol::PyIterReturn,
-        types::{Callable, Constructor},
-    };
-    use malachite_bigint::BigInt;
-    use rustpython_common::wtf8::Wtf8Buf;
-    use std::str::FromStr;
-
-    #[pyattr(name = "make_scanner")]
-    #[pyclass(name = "Scanner", traverse)]
-    #[derive(Debug, PyPayload)]
-    struct JsonScanner {
-        #[pytraverse(skip)]
-        strict: bool,
-        object_hook: Option<PyObjectRef>,
-        object_pairs_hook: Option<PyObjectRef>,
-        parse_float: Option<PyObjectRef>,
-        parse_int: Option<PyObjectRef>,
-        parse_constant: PyObjectRef,
-        ctx: PyObjectRef,
-    }
-
-    impl Constructor for JsonScanner {
-        type Args = PyObjectRef;
-
-        fn py_new(cls: PyTypeRef, ctx: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let strict = ctx.get_attr("strict", vm)?.try_to_bool(vm)?;
-            let object_hook = vm.option_if_none(ctx.get_attr("object_hook", vm)?);
-            let object_pairs_hook = vm.option_if_none(ctx.get_attr("object_pairs_hook", vm)?);
-            let parse_float = ctx.get_attr("parse_float", vm)?;
-            let parse_float = if vm.is_none(&parse_float) || parse_float.is(vm.ctx.types.float_type)
-            {
-                None
-            } else {
-                Some(parse_float)
-            };
-            let parse_int = ctx.get_attr("parse_int", vm)?;
-            let parse_int = if vm.is_none(&parse_int) || parse_int.is(vm.ctx.types.int_type) {
-                None
-            } else {
-                Some(parse_int)
-            };
-            let parse_constant = ctx.get_attr("parse_constant", vm)?;
-
-            Self {
-                strict,
-                object_hook,
-                object_pairs_hook,
-                parse_float,
-                parse_int,
-                parse_constant,
-                ctx,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-        }
-    }
-
-    #[pyclass(with(Callable, Constructor))]
-    impl JsonScanner {
-        fn parse(
-            &self,
-            s: &str,
-            pystr: PyStrRef,
-            idx: usize,
-            scan_once: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyIterReturn> {
-            let c = match s.chars().next() {
-                Some(c) => c,
-                None => {
-                    return Ok(PyIterReturn::StopIteration(Some(
-                        vm.ctx.new_int(idx).into(),
-                    )));
-                }
-            };
-            let next_idx = idx + c.len_utf8();
-            match c {
-                '"' => {
-                    return scanstring(pystr, next_idx, OptionalArg::Present(self.strict), vm)
-                        .map(|x| PyIterReturn::Return(x.to_pyobject(vm)));
-                }
-                '{' => {
-                    // TODO: parse the object in rust
-                    let parse_obj = self.ctx.get_attr("parse_object", vm)?;
-                    let result = parse_obj.call(
-                        (
-                            (pystr, next_idx),
-                            self.strict,
-                            scan_once,
-                            self.object_hook.clone(),
-                            self.object_pairs_hook.clone(),
-                        ),
-                        vm,
-                    );
-                    return PyIterReturn::from_pyresult(result, vm);
-                }
-                '[' => {
-                    // TODO: parse the array in rust
-                    let parse_array = self.ctx.get_attr("parse_array", vm)?;
-                    return PyIterReturn::from_pyresult(
-                        parse_array.call(((pystr, next_idx), scan_once), vm),
-                        vm,
-                    );
-                }
-                _ => {}
-            }
-
-            macro_rules! parse_const {
-                ($s:literal, $val:expr) => {
-                    if s.starts_with($s) {
-                        return Ok(PyIterReturn::Return(
-                            vm.new_tuple(($val, idx + $s.len())).into(),
-                        ));
-                    }
-                };
-            }
-
-            parse_const!("null", vm.ctx.none());
-            parse_const!("true", true);
-            parse_const!("false", false);
-
-            if let Some((res, len)) = self.parse_number(s, vm) {
-                return Ok(PyIterReturn::Return(vm.new_tuple((res?, idx + len)).into()));
-            }
-
-            macro_rules! parse_constant {
-                ($s:literal) => {
-                    if s.starts_with($s) {
-                        return Ok(PyIterReturn::Return(
-                            vm.new_tuple((self.parse_constant.call(($s,), vm)?, idx + $s.len()))
-                                .into(),
-                        ));
-                    }
-                };
-            }
-
-            parse_constant!("NaN");
-            parse_constant!("Infinity");
-            parse_constant!("-Infinity");
-
-            Ok(PyIterReturn::StopIteration(Some(
-                vm.ctx.new_int(idx).into(),
-            )))
-        }
-
-        fn parse_number(&self, s: &str, vm: &VirtualMachine) -> Option<(PyResult, usize)> {
-            let mut has_neg = false;
-            let mut has_decimal = false;
-            let mut has_exponent = false;
-            let mut has_e_sign = false;
-            let mut i = 0;
-            for c in s.chars() {
-                match c {
-                    '-' if i == 0 => has_neg = true,
-                    n if n.is_ascii_digit() => {}
-                    '.' if !has_decimal => has_decimal = true,
-                    'e' | 'E' if !has_exponent => has_exponent = true,
-                    '+' | '-' if !has_e_sign => has_e_sign = true,
-                    _ => break,
-                }
-                i += 1;
-            }
-            if i == 0 || (i == 1 && has_neg) {
-                return None;
-            }
-            let buf = &s[..i];
-            let ret = if has_decimal || has_exponent {
-                // float
-                if let Some(ref parse_float) = self.parse_float {
-                    parse_float.call((buf,), vm)
-                } else {
-                    Ok(vm.ctx.new_float(f64::from_str(buf).unwrap()).into())
-                }
-            } else if let Some(ref parse_int) = self.parse_int {
-                parse_int.call((buf,), vm)
-            } else {
-                Ok(vm.new_pyobj(BigInt::from_str(buf).unwrap()))
-            };
-            Some((ret, buf.len()))
-        }
-    }
-
-    impl Callable for JsonScanner {
-        type Args = (PyStrRef, isize);
-        fn call(zelf: &Py<Self>, (pystr, idx): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if idx < 0 {
-                return Err(vm.new_value_error("idx cannot be negative"));
-            }
-            let idx = idx as usize;
-            let mut chars = pystr.as_str().chars();
-            if idx > 0 && chars.nth(idx - 1).is_none() {
-                PyIterReturn::StopIteration(Some(vm.ctx.new_int(idx).into())).to_pyresult(vm)
-            } else {
-                zelf.parse(
-                    chars.as_str(),
-                    pystr.clone(),
-                    idx,
-                    zelf.to_owned().into(),
-                    vm,
-                )
-                .and_then(|x| x.to_pyresult(vm))
-            }
-        }
-    }
-
-    fn encode_string(s: &str, ascii_only: bool) -> String {
-        let mut buf = Vec::<u8>::with_capacity(s.len() + 2);
-        machinery::write_json_string(s, ascii_only, &mut buf)
-            // SAFETY: writing to a vec can't fail
-            .unwrap_or_else(|_| unsafe { std::hint::unreachable_unchecked() });
-        // SAFETY: we only output valid utf8 from write_json_string
-        unsafe { String::from_utf8_unchecked(buf) }
-    }
-
-    #[pyfunction]
-    fn encode_basestring(s: PyStrRef) -> String {
-        encode_string(s.as_str(), false)
-    }
-
-    #[pyfunction]
-    fn encode_basestring_ascii(s: PyStrRef) -> String {
-        encode_string(s.as_str(), true)
-    }
-
-    fn py_decode_error(
-        e: machinery::DecodeError,
-        s: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyBaseExceptionRef {
-        let get_error = || -> PyResult<_> {
-            let cls = vm.try_class("json", "JSONDecodeError")?;
-            let exc = PyType::call(&cls, (e.msg, s, e.pos).into_args(vm), vm)?;
-            exc.try_into_value(vm)
-        };
-        match get_error() {
-            Ok(x) | Err(x) => x,
-        }
-    }
-
-    #[pyfunction]
-    fn scanstring(
-        s: PyStrRef,
-        end: usize,
-        strict: OptionalArg<bool>,
-        vm: &VirtualMachine,
-    ) -> PyResult<(Wtf8Buf, usize)> {
-        machinery::scanstring(s.as_wtf8(), end, strict.unwrap_or(true))
-            .map_err(|e| py_decode_error(e, s, vm))
-    }
-}
diff --git a/stdlib/src/lib.rs b/stdlib/src/lib.rs
deleted file mode 100644
index 20dcb88232..0000000000
--- a/stdlib/src/lib.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-// to allow `mod foo {}` in foo.rs; clippy thinks this is a mistake/misunderstanding of
-// 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;
-
-pub mod array;
-mod binascii;
-mod bisect;
-mod cmath;
-mod contextvars;
-mod csv;
-mod dis;
-mod gc;
-
-mod bz2;
-mod compression; // internal module
-#[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
-mod lzma;
-mod zlib;
-
-mod blake2;
-mod hashlib;
-mod md5;
-mod sha1;
-mod sha256;
-mod sha3;
-mod sha512;
-
-mod json;
-#[cfg(not(any(target_os = "ios", target_os = "android", target_arch = "wasm32")))]
-mod locale;
-mod math;
-#[cfg(unix)]
-mod mmap;
-mod pyexpat;
-mod pystruct;
-mod random;
-mod statistics;
-mod suggestions;
-// TODO: maybe make this an extension module, if we ever get those
-// mod re;
-#[cfg(not(target_arch = "wasm32"))]
-pub mod socket;
-#[cfg(all(unix, not(target_os = "redox")))]
-mod syslog;
-mod unicodedata;
-
-mod faulthandler;
-#[cfg(any(unix, target_os = "wasi"))]
-mod fcntl;
-#[cfg(not(target_arch = "wasm32"))]
-mod multiprocessing;
-#[cfg(unix)]
-mod posixsubprocess;
-// libc is missing constants on redox
-#[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
-mod grp;
-#[cfg(windows)]
-mod overlapped;
-#[cfg(all(unix, not(target_os = "redox")))]
-mod resource;
-#[cfg(target_os = "macos")]
-mod scproxy;
-#[cfg(any(unix, windows, target_os = "wasi"))]
-mod select;
-#[cfg(all(
-    feature = "sqlite",
-    not(any(target_os = "android", target_arch = "wasm32"))
-))]
-mod sqlite;
-#[cfg(all(not(target_arch = "wasm32"), feature = "ssl"))]
-mod ssl;
-#[cfg(all(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",
-)))]
-mod uuid;
-
-#[cfg(feature = "tkinter")]
-mod tkinter;
-
-use rustpython_common as common;
-use rustpython_vm as vm;
-
-use crate::vm::{builtins, stdlib::StdlibInitFunc};
-use std::borrow::Cow;
-
-pub fn get_module_inits() -> impl Iterator<Item = (Cow<'static, str>, StdlibInitFunc)> {
-    macro_rules! modules {
-        {
-            $(
-                #[cfg($cfg:meta)]
-                { $( $key:expr => $val:expr),* $(,)? }
-            )*
-        } => {{
-            [
-                $(
-                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
-                )*
-            ]
-            .into_iter()
-        }};
-    }
-    modules! {
-        #[cfg(all())]
-        {
-            "array" => array::make_module,
-            "binascii" => binascii::make_module,
-            "_bisect" => bisect::make_module,
-            "_bz2" => bz2::make_module,
-            "cmath" => cmath::make_module,
-            "_contextvars" => contextvars::make_module,
-            "_csv" => csv::make_module,
-            "_dis" => dis::make_module,
-            "faulthandler" => faulthandler::make_module,
-            "gc" => gc::make_module,
-            "_hashlib" => hashlib::make_module,
-            "_sha1" => sha1::make_module,
-            "_sha3" => sha3::make_module,
-            "_sha256" => sha256::make_module,
-            "_sha512" => sha512::make_module,
-            "_md5" => md5::make_module,
-            "_blake2" => blake2::make_module,
-            "_json" => json::make_module,
-            "math" => math::make_module,
-            "pyexpat" => pyexpat::make_module,
-            "_random" => random::make_module,
-            "_statistics" => statistics::make_module,
-            "_struct" => pystruct::make_module,
-            "unicodedata" => unicodedata::make_module,
-            "zlib" => zlib::make_module,
-            "_statistics" => statistics::make_module,
-            "_suggestions" => suggestions::make_module,
-            // crate::vm::sysmodule::sysconfigdata_name() => sysconfigdata::make_module,
-        }
-        #[cfg(any(unix, target_os = "wasi"))]
-        {
-            "fcntl" => fcntl::make_module,
-        }
-        #[cfg(any(unix, windows, target_os = "wasi"))]
-        {
-            "select" => select::make_module,
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            "_multiprocessing" => multiprocessing::make_module,
-            "_socket" => socket::make_module,
-        }
-        #[cfg(not(any(target_os = "android", target_arch = "wasm32")))]
-        {
-            "_lzma" => lzma::make_module,
-        }
-        #[cfg(all(feature = "sqlite", not(any(target_os = "android", target_arch = "wasm32"))))]
-        {
-            "_sqlite3" => sqlite::make_module,
-        }
-        #[cfg(feature = "ssl")]
-        {
-            "_ssl" => ssl::make_module,
-        }
-        #[cfg(windows)]
-        {
-            "_overlapped" => overlapped::make_module,
-        }
-        // Unix-only
-        #[cfg(unix)]
-        {
-            "_posixsubprocess" => posixsubprocess::make_module,
-            "mmap" => mmap::make_module,
-        }
-        #[cfg(all(unix, not(target_os = "redox")))]
-        {
-            "syslog" => syslog::make_module,
-            "resource" => resource::make_module,
-        }
-        #[cfg(all(unix, not(any(target_os = "ios", target_os = "redox"))))]
-        {
-            "termios" => termios::make_module,
-        }
-        #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
-        {
-            "grp" => grp::make_module,
-        }
-        #[cfg(target_os = "macos")]
-        {
-            "_scproxy" => scproxy::make_module,
-        }
-        #[cfg(not(any(target_os = "android", target_os = "ios", target_os = "windows", target_arch = "wasm32", target_os = "redox")))]
-        {
-            "_uuid" => uuid::make_module,
-        }
-        #[cfg(not(any(target_os = "ios", target_os = "android", target_arch = "wasm32")))]
-        {
-            "_locale" => locale::make_module,
-        }
-        #[cfg(feature = "tkinter")]
-        {
-            "_tkinter" => tkinter::make_module,
-        }
-    }
-}
diff --git a/stdlib/src/locale.rs b/stdlib/src/locale.rs
deleted file mode 100644
index eadba4519a..0000000000
--- a/stdlib/src/locale.rs
+++ /dev/null
@@ -1,218 +0,0 @@
-// spell-checker:ignore abday abmon yesexpr noexpr CRNCYSTR RADIXCHAR AMPM THOUSEP
-
-pub(crate) use _locale::make_module;
-
-#[cfg(windows)]
-#[repr(C)]
-struct lconv {
-    decimal_point: *mut libc::c_char,
-    thousands_sep: *mut libc::c_char,
-    grouping: *mut libc::c_char,
-    int_curr_symbol: *mut libc::c_char,
-    currency_symbol: *mut libc::c_char,
-    mon_decimal_point: *mut libc::c_char,
-    mon_thousands_sep: *mut libc::c_char,
-    mon_grouping: *mut libc::c_char,
-    positive_sign: *mut libc::c_char,
-    negative_sign: *mut libc::c_char,
-    int_frac_digits: libc::c_char,
-    frac_digits: libc::c_char,
-    p_cs_precedes: libc::c_char,
-    p_sep_by_space: libc::c_char,
-    n_cs_precedes: libc::c_char,
-    n_sep_by_space: libc::c_char,
-    p_sign_posn: libc::c_char,
-    n_sign_posn: libc::c_char,
-    int_p_cs_precedes: libc::c_char,
-    int_n_cs_precedes: libc::c_char,
-    int_p_sep_by_space: libc::c_char,
-    int_n_sep_by_space: libc::c_char,
-    int_p_sign_posn: libc::c_char,
-    int_n_sign_posn: libc::c_char,
-}
-
-#[cfg(windows)]
-unsafe extern "C" {
-    fn localeconv() -> *mut lconv;
-}
-
-#[cfg(unix)]
-use libc::localeconv;
-
-#[pymodule]
-mod _locale {
-    use rustpython_vm::{
-        PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyIntRef, PyListRef, PyStrRef, PyTypeRef},
-        convert::ToPyException,
-        function::OptionalArg,
-    };
-    use std::{
-        ffi::{CStr, CString},
-        ptr,
-    };
-
-    #[cfg(all(
-        unix,
-        not(any(target_os = "ios", target_os = "android", target_os = "redox"))
-    ))]
-    #[pyattr]
-    use libc::{
-        ABDAY_1, ABDAY_2, ABDAY_3, ABDAY_4, ABDAY_5, ABDAY_6, ABDAY_7, ABMON_1, ABMON_2, ABMON_3,
-        ABMON_4, ABMON_5, ABMON_6, ABMON_7, ABMON_8, ABMON_9, ABMON_10, ABMON_11, ABMON_12,
-        ALT_DIGITS, AM_STR, CODESET, CRNCYSTR, D_FMT, D_T_FMT, DAY_1, DAY_2, DAY_3, DAY_4, DAY_5,
-        DAY_6, DAY_7, ERA, ERA_D_FMT, ERA_D_T_FMT, ERA_T_FMT, LC_MESSAGES, MON_1, MON_2, MON_3,
-        MON_4, MON_5, MON_6, MON_7, MON_8, MON_9, MON_10, MON_11, MON_12, NOEXPR, PM_STR,
-        RADIXCHAR, T_FMT, T_FMT_AMPM, THOUSEP, YESEXPR,
-    };
-
-    #[pyattr]
-    use libc::{LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME};
-
-    #[pyattr(name = "CHAR_MAX")]
-    fn char_max(vm: &VirtualMachine) -> PyIntRef {
-        vm.ctx.new_int(libc::c_char::MAX)
-    }
-
-    unsafe fn copy_grouping(group: *const libc::c_char, vm: &VirtualMachine) -> PyListRef {
-        let mut group_vec: Vec<PyObjectRef> = Vec::new();
-        if group.is_null() {
-            return vm.ctx.new_list(group_vec);
-        }
-
-        unsafe {
-            let mut ptr = group;
-            while ![0, libc::c_char::MAX].contains(&*ptr) {
-                let val = vm.ctx.new_int(*ptr);
-                group_vec.push(val.into());
-                ptr = ptr.add(1);
-            }
-        }
-        // https://github.com/python/cpython/blob/677320348728ce058fa3579017e985af74a236d4/Modules/_localemodule.c#L80
-        if !group_vec.is_empty() {
-            group_vec.push(vm.ctx.new_int(0).into());
-        }
-        vm.ctx.new_list(group_vec)
-    }
-
-    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))
-    }
-
-    #[pyattr(name = "Error", once)]
-    fn error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "locale",
-            "Error",
-            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
-        )
-    }
-
-    #[pyfunction]
-    fn strcoll(string1: PyStrRef, string2: PyStrRef, 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 {
-        // https://github.com/python/cpython/blob/eaae563b6878aa050b4ad406b67728b6b066220e/Modules/_localemodule.c#L390-L442
-        let n1 = string.byte_len() + 1;
-        let mut buff = vec![0u8; n1];
-
-        let cstr = CString::new(string.as_str()).map_err(|e| e.to_pyexception(vm))?;
-        let n2 = unsafe { libc::strxfrm(buff.as_mut_ptr() as _, cstr.as_ptr(), n1) };
-        buff = vec![0u8; n2 + 1];
-        unsafe {
-            libc::strxfrm(buff.as_mut_ptr() as _, cstr.as_ptr(), n2 + 1);
-        }
-        Ok(vm.new_pyobj(String::from_utf8(buff).expect("strxfrm returned invalid utf-8 string")))
-    }
-
-    #[pyfunction]
-    fn localeconv(vm: &VirtualMachine) -> PyResult<PyDictRef> {
-        let result = vm.ctx.new_dict();
-
-        unsafe {
-            macro_rules! set_string_field {
-                ($lc:expr, $field:ident) => {{
-                    result.set_item(
-                        stringify!($field),
-                        pystr_from_raw_cstr(vm, (*$lc).$field)?,
-                        vm,
-                    )?
-                }};
-            }
-
-            macro_rules! set_int_field {
-                ($lc:expr, $field:ident) => {{ result.set_item(stringify!($field), vm.new_pyobj((*$lc).$field), vm)? }};
-            }
-
-            macro_rules! set_group_field {
-                ($lc:expr, $field:ident) => {{
-                    result.set_item(
-                        stringify!($field),
-                        copy_grouping((*$lc).$field, vm).into(),
-                        vm,
-                    )?
-                }};
-            }
-
-            let lc = super::localeconv();
-            set_group_field!(lc, mon_grouping);
-            set_group_field!(lc, grouping);
-            set_int_field!(lc, int_frac_digits);
-            set_int_field!(lc, frac_digits);
-            set_int_field!(lc, p_cs_precedes);
-            set_int_field!(lc, p_sep_by_space);
-            set_int_field!(lc, n_cs_precedes);
-            set_int_field!(lc, p_sign_posn);
-            set_int_field!(lc, n_sign_posn);
-            set_string_field!(lc, decimal_point);
-            set_string_field!(lc, thousands_sep);
-            set_string_field!(lc, int_curr_symbol);
-            set_string_field!(lc, currency_symbol);
-            set_string_field!(lc, mon_decimal_point);
-            set_string_field!(lc, mon_thousands_sep);
-            set_int_field!(lc, n_sep_by_space);
-            set_string_field!(lc, positive_sign);
-            set_string_field!(lc, negative_sign);
-        }
-        Ok(result)
-    }
-
-    #[derive(FromArgs)]
-    struct LocaleArgs {
-        #[pyarg(any)]
-        category: i32,
-        #[pyarg(any, optional)]
-        locale: OptionalArg<Option<PyStrRef>>,
-    }
-
-    #[pyfunction]
-    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")));
-        }
-        unsafe {
-            let result = match args.locale.flatten() {
-                None => libc::setlocale(args.category, ptr::null()),
-                Some(locale) => {
-                    let c_locale: CString =
-                        CString::new(locale.as_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")));
-            }
-            pystr_from_raw_cstr(vm, result)
-        }
-    }
-}
diff --git a/stdlib/src/math.rs b/stdlib/src/math.rs
deleted file mode 100644
index 7860a343b4..0000000000
--- a/stdlib/src/math.rs
+++ /dev/null
@@ -1,989 +0,0 @@
-pub(crate) use math::make_module;
-
-use crate::{builtins::PyBaseExceptionRef, vm::VirtualMachine};
-
-#[pymodule]
-mod math {
-    use crate::vm::{
-        PyObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
-        builtins::{PyFloat, PyInt, PyIntRef, PyStrInterned, try_bigint_to_f64, try_f64_to_bigint},
-        function::{ArgIndex, ArgIntoFloat, ArgIterable, Either, OptionalArg, PosArgs},
-        identifier,
-    };
-    use itertools::Itertools;
-    use malachite_bigint::BigInt;
-    use num_traits::{One, Signed, Zero};
-    use rustpython_common::{float_ops, int::true_div};
-    use std::cmp::Ordering;
-
-    // Constants
-    #[pyattr]
-    use std::f64::consts::{E as e, PI as pi, TAU as tau};
-
-    use super::pymath_error_to_exception;
-    #[pyattr(name = "inf")]
-    const INF: f64 = f64::INFINITY;
-    #[pyattr(name = "nan")]
-    const NAN: f64 = f64::NAN;
-
-    // Helper macro:
-    macro_rules! call_math_func {
-        ( $fun:ident, $name:ident, $vm:ident ) => {{
-            let value = *$name;
-            let result = value.$fun();
-            result_or_overflow(value, result, $vm)
-        }};
-    }
-
-    #[inline]
-    fn result_or_overflow(value: f64, result: f64, vm: &VirtualMachine) -> PyResult<f64> {
-        if !result.is_finite() && value.is_finite() {
-            // CPython doesn't return `inf` when called with finite
-            // values, it raises OverflowError instead.
-            Err(vm.new_overflow_error("math range error"))
-        } else {
-            Ok(result)
-        }
-    }
-
-    // Number theory functions:
-    #[pyfunction]
-    fn fabs(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(abs, x, vm)
-    }
-
-    #[pyfunction]
-    fn isfinite(x: ArgIntoFloat) -> bool {
-        x.is_finite()
-    }
-
-    #[pyfunction]
-    fn isinf(x: ArgIntoFloat) -> bool {
-        x.is_infinite()
-    }
-
-    #[pyfunction]
-    fn isnan(x: ArgIntoFloat) -> bool {
-        x.is_nan()
-    }
-
-    #[derive(FromArgs)]
-    struct IsCloseArgs {
-        #[pyarg(positional)]
-        a: ArgIntoFloat,
-        #[pyarg(positional)]
-        b: ArgIntoFloat,
-        #[pyarg(named, optional)]
-        rel_tol: OptionalArg<ArgIntoFloat>,
-        #[pyarg(named, optional)]
-        abs_tol: OptionalArg<ArgIntoFloat>,
-    }
-
-    #[pyfunction]
-    fn isclose(args: IsCloseArgs, vm: &VirtualMachine) -> PyResult<bool> {
-        let a = *args.a;
-        let b = *args.b;
-        let rel_tol = args.rel_tol.map_or(1e-09, |value| value.into());
-        let abs_tol = args.abs_tol.map_or(0.0, |value| value.into());
-
-        if rel_tol < 0.0 || abs_tol < 0.0 {
-            return Err(vm.new_value_error("tolerances must be non-negative"));
-        }
-
-        if a == b {
-            /* short circuit exact equality -- needed to catch two infinities of
-               the same sign. And perhaps speeds things up a bit sometimes.
-            */
-            return Ok(true);
-        }
-
-        /* This catches the case of two infinities of opposite sign, or
-           one infinity and one finite number. Two infinities of opposite
-           sign would otherwise have an infinite relative tolerance.
-           Two infinities of the same sign are caught by the equality check
-           above.
-        */
-
-        if a.is_infinite() || b.is_infinite() {
-            return Ok(false);
-        }
-
-        let diff = (b - a).abs();
-
-        Ok((diff <= (rel_tol * b).abs()) || (diff <= (rel_tol * a).abs()) || (diff <= abs_tol))
-    }
-
-    #[pyfunction]
-    fn copysign(x: ArgIntoFloat, y: ArgIntoFloat) -> f64 {
-        x.copysign(*y)
-    }
-
-    // Power and logarithmic functions:
-    #[pyfunction]
-    fn exp(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp, x, vm)
-    }
-
-    #[pyfunction]
-    fn exp2(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp2, x, vm)
-    }
-
-    #[pyfunction]
-    fn expm1(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(exp_m1, x, vm)
-    }
-
-    #[pyfunction]
-    fn log(x: PyObjectRef, base: OptionalArg<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let base = base.map(|b| *b).unwrap_or(std::f64::consts::E);
-        if base.is_sign_negative() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        log2(x, vm).map(|log_x| log_x / base.log2())
-    }
-
-    #[pyfunction]
-    fn log1p(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        if x.is_nan() || x > -1.0_f64 {
-            Ok(x.ln_1p())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
-    }
-
-    /// Generates the base-2 logarithm of a BigInt `x`
-    fn int_log2(x: &BigInt) -> f64 {
-        // log2(x) = log2(2^n * 2^-n * x) = n + log2(x/2^n)
-        // If we set 2^n to be the greatest power of 2 below x, then x/2^n is in [1, 2), and can
-        // thus be converted into a float.
-        let n = x.bits() as u32 - 1;
-        let frac = true_div(x, &BigInt::from(2).pow(n));
-        f64::from(n) + frac.log2()
-    }
-
-    #[pyfunction]
-    fn log2(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
-        match x.try_float(vm) {
-            Ok(x) => {
-                let x = x.to_f64();
-                if x.is_nan() || x > 0.0_f64 {
-                    Ok(x.log2())
-                } else {
-                    Err(vm.new_value_error("math domain error"))
-                }
-            }
-            Err(float_err) => {
-                if let Ok(x) = x.try_int(vm) {
-                    let x = x.as_bigint();
-                    if x.is_positive() {
-                        Ok(int_log2(x))
-                    } else {
-                        Err(vm.new_value_error("math domain error"))
-                    }
-                } else {
-                    // Return the float error, as it will be more intuitive to users
-                    Err(float_err)
-                }
-            }
-        }
-    }
-
-    #[pyfunction]
-    fn log10(x: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
-        log2(x, vm).map(|log_x| log_x / 10f64.log2())
-    }
-
-    #[pyfunction]
-    fn pow(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
-
-        if x < 0.0 && x.is_finite() && y.fract() != 0.0 && y.is_finite()
-            || x == 0.0 && y < 0.0 && y != f64::NEG_INFINITY
-        {
-            return Err(vm.new_value_error("math domain error"));
-        }
-
-        let value = x.powf(y);
-
-        if x.is_finite() && y.is_finite() && value.is_infinite() {
-            return Err(vm.new_overflow_error("math range error"));
-        }
-
-        Ok(value)
-    }
-
-    #[pyfunction]
-    fn sqrt(value: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let value = *value;
-        if value.is_nan() {
-            return Ok(value);
-        }
-        if value.is_sign_negative() {
-            if value.is_zero() {
-                return Ok(-0.0f64);
-            }
-            return Err(vm.new_value_error("math domain error"));
-        }
-        Ok(value.sqrt())
-    }
-
-    #[pyfunction]
-    fn isqrt(x: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let value = x.as_bigint();
-
-        if value.is_negative() {
-            return Err(vm.new_value_error("isqrt() argument must be nonnegative"));
-        }
-        Ok(value.sqrt())
-    }
-
-    // Trigonometric functions:
-    #[pyfunction]
-    fn acos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
-            Ok(x.acos())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
-    }
-
-    #[pyfunction]
-    fn asin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        if x.is_nan() || (-1.0_f64..=1.0_f64).contains(&x) {
-            Ok(x.asin())
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
-    }
-
-    #[pyfunction]
-    fn atan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(atan, x, vm)
-    }
-
-    #[pyfunction]
-    fn atan2(y: ArgIntoFloat, x: ArgIntoFloat) -> f64 {
-        y.atan2(*x)
-    }
-
-    #[pyfunction]
-    fn cos(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        call_math_func!(cos, x, vm)
-    }
-
-    #[pyfunction]
-    fn hypot(coordinates: PosArgs<ArgIntoFloat>) -> f64 {
-        let mut coordinates = ArgIntoFloat::vec_into_f64(coordinates.into_vec());
-        let mut max = 0.0;
-        let mut has_nan = false;
-        for f in &mut coordinates {
-            *f = f.abs();
-            if f.is_nan() {
-                has_nan = true;
-            } else if *f > max {
-                max = *f
-            }
-        }
-        // inf takes precedence over nan
-        if max.is_infinite() {
-            return max;
-        }
-        if has_nan {
-            return f64::NAN;
-        }
-        coordinates.sort_unstable_by(|x, y| x.total_cmp(y).reverse());
-        vector_norm(&coordinates)
-    }
-
-    /// Implementation of accurate hypotenuse algorithm from Borges 2019.
-    /// See https://arxiv.org/abs/1904.09481.
-    /// This assumes that its arguments are positive finite and have been scaled to avoid overflow
-    /// and underflow.
-    fn accurate_hypot(max: f64, min: f64) -> f64 {
-        if min <= max * (f64::EPSILON / 2.0).sqrt() {
-            return max;
-        }
-        let hypot = max.mul_add(max, min * min).sqrt();
-        let hypot_sq = hypot * hypot;
-        let max_sq = max * max;
-        let correction = (-min).mul_add(min, hypot_sq - max_sq) + hypot.mul_add(hypot, -hypot_sq)
-            - max.mul_add(max, -max_sq);
-        hypot - correction / (2.0 * hypot)
-    }
-
-    /// Calculates the norm of the vector given by `v`.
-    /// `v` is assumed to be a list of non-negative finite floats, sorted in descending order.
-    fn vector_norm(v: &[f64]) -> f64 {
-        // Drop zeros from the vector.
-        let zero_count = v.iter().rev().cloned().take_while(|x| *x == 0.0).count();
-        let v = &v[..v.len() - zero_count];
-        if v.is_empty() {
-            return 0.0;
-        }
-        if v.len() == 1 {
-            return v[0];
-        }
-        // Calculate scaling to avoid overflow / underflow.
-        let max = *v.first().unwrap();
-        let min = *v.last().unwrap();
-        let scale = if max > (f64::MAX / v.len() as f64).sqrt() {
-            max
-        } else if min < f64::MIN_POSITIVE.sqrt() {
-            // ^ This can be an `else if`, because if the max is near f64::MAX and the min is near
-            // f64::MIN_POSITIVE, then the min is relatively unimportant and will be effectively
-            // ignored.
-            min
-        } else {
-            1.0
-        };
-        let mut norm = v
-            .iter()
-            .copied()
-            .map(|x| x / scale)
-            .reduce(accurate_hypot)
-            .unwrap_or_default();
-        if v.len() > 2 {
-            // For larger lists of numbers, we can accumulate a rounding error, so a correction is
-            // needed, similar to that in `accurate_hypot()`.
-            // First, we estimate [sum of squares - norm^2], then we add the first-order
-            // approximation of the square root of that to `norm`.
-            let correction = v
-                .iter()
-                .copied()
-                .map(|x| (x / scale).powi(2))
-                .chain(std::iter::once(-norm * norm))
-                // Pairwise summation of floats gives less rounding error than a naive sum.
-                .tree_reduce(std::ops::Add::add)
-                .expect("expected at least 1 element");
-            norm = norm + correction / (2.0 * norm);
-        }
-        norm * scale
-    }
-
-    #[pyfunction]
-    fn dist(p: Vec<ArgIntoFloat>, q: Vec<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let mut max = 0.0;
-        let mut has_nan = false;
-
-        let p = ArgIntoFloat::vec_into_f64(p);
-        let q = ArgIntoFloat::vec_into_f64(q);
-        let mut diffs = vec![];
-
-        if p.len() != q.len() {
-            return Err(vm.new_value_error("both points must have the same number of dimensions"));
-        }
-
-        for i in 0..p.len() {
-            let px = p[i];
-            let qx = q[i];
-
-            let x = (px - qx).abs();
-            if x.is_nan() {
-                has_nan = true;
-            }
-
-            diffs.push(x);
-            if x > max {
-                max = x;
-            }
-        }
-
-        if max.is_infinite() {
-            return Ok(max);
-        }
-        if has_nan {
-            return Ok(f64::NAN);
-        }
-        diffs.sort_unstable_by(|x, y| x.total_cmp(y).reverse());
-        Ok(vector_norm(&diffs))
-    }
-
-    #[pyfunction]
-    fn sin(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        call_math_func!(sin, x, vm)
-    }
-
-    #[pyfunction]
-    fn tan(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        if x.is_infinite() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        call_math_func!(tan, x, vm)
-    }
-
-    #[pyfunction]
-    fn degrees(x: ArgIntoFloat) -> f64 {
-        *x * (180.0 / std::f64::consts::PI)
-    }
-
-    #[pyfunction]
-    fn radians(x: ArgIntoFloat) -> f64 {
-        *x * (std::f64::consts::PI / 180.0)
-    }
-
-    // Hyperbolic functions:
-
-    #[pyfunction]
-    fn acosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        if x.is_sign_negative() || x.is_zero() {
-            Err(vm.new_value_error("math domain error"))
-        } else {
-            Ok(x.acosh())
-        }
-    }
-
-    #[pyfunction]
-    fn asinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(asinh, x, vm)
-    }
-
-    #[pyfunction]
-    fn atanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        if x >= 1.0_f64 || x <= -1.0_f64 {
-            Err(vm.new_value_error("math domain error"))
-        } else {
-            Ok(x.atanh())
-        }
-    }
-
-    #[pyfunction]
-    fn cosh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(cosh, x, vm)
-    }
-
-    #[pyfunction]
-    fn sinh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(sinh, x, vm)
-    }
-
-    #[pyfunction]
-    fn tanh(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        call_math_func!(tanh, x, vm)
-    }
-
-    // Special functions:
-    #[pyfunction]
-    fn erf(x: ArgIntoFloat) -> f64 {
-        pymath::erf(*x)
-    }
-
-    #[pyfunction]
-    fn erfc(x: ArgIntoFloat) -> f64 {
-        pymath::erfc(*x)
-    }
-
-    #[pyfunction]
-    fn gamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::gamma(*x).map_err(|err| pymath_error_to_exception(err, vm))
-    }
-
-    #[pyfunction]
-    fn lgamma(x: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        pymath::lgamma(*x).map_err(|err| pymath_error_to_exception(err, vm))
-    }
-
-    fn try_magic_method(
-        func_name: &'static PyStrInterned,
-        vm: &VirtualMachine,
-        value: &PyObject,
-    ) -> PyResult {
-        let method = vm.get_method_or_type_error(value.to_owned(), func_name, || {
-            format!(
-                "type '{}' doesn't define '{}' method",
-                value.class().name(),
-                func_name.as_str(),
-            )
-        })?;
-        method.call((), vm)
-    }
-
-    #[pyfunction]
-    fn trunc(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        try_magic_method(identifier!(vm, __trunc__), vm, &x)
-    }
-
-    #[pyfunction]
-    fn ceil(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let result_or_err = try_magic_method(identifier!(vm, __ceil__), vm, &x);
-        if result_or_err.is_err() {
-            if let Some(v) = x.try_float_opt(vm) {
-                let v = try_f64_to_bigint(v?.to_f64().ceil(), vm)?;
-                return Ok(vm.ctx.new_int(v).into());
-            }
-        }
-        result_or_err
-    }
-
-    #[pyfunction]
-    fn floor(x: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let result_or_err = try_magic_method(identifier!(vm, __floor__), vm, &x);
-        if result_or_err.is_err() {
-            if let Some(v) = x.try_float_opt(vm) {
-                let v = try_f64_to_bigint(v?.to_f64().floor(), vm)?;
-                return Ok(vm.ctx.new_int(v).into());
-            }
-        }
-        result_or_err
-    }
-
-    #[pyfunction]
-    fn frexp(x: ArgIntoFloat) -> (f64, i32) {
-        let value = *x;
-        if value.is_finite() {
-            let (m, exp) = float_ops::decompose_float(value);
-            (m * value.signum(), exp)
-        } else {
-            (value, 0)
-        }
-    }
-
-    #[pyfunction]
-    fn ldexp(
-        x: Either<PyRef<PyFloat>, PyIntRef>,
-        i: PyIntRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<f64> {
-        let value = match x {
-            Either::A(f) => f.to_f64(),
-            Either::B(z) => try_bigint_to_f64(z.as_bigint(), vm)?,
-        };
-
-        if value == 0_f64 || !value.is_finite() {
-            // NaNs, zeros and infinities are returned unchanged
-            Ok(value)
-        } else {
-            let result = value * (2_f64).powf(try_bigint_to_f64(i.as_bigint(), vm)?);
-            result_or_overflow(value, result, vm)
-        }
-    }
-
-    fn math_perf_arb_len_int_op<F>(args: PosArgs<ArgIndex>, op: F, default: BigInt) -> BigInt
-    where
-        F: Fn(&BigInt, &PyInt) -> BigInt,
-    {
-        let arg_vec = args.into_vec();
-
-        if arg_vec.is_empty() {
-            return default;
-        } else if arg_vec.len() == 1 {
-            return op(arg_vec[0].as_bigint(), &arg_vec[0]);
-        }
-
-        let mut res = arg_vec[0].as_bigint().clone();
-        for num in &arg_vec[1..] {
-            res = op(&res, num)
-        }
-        res
-    }
-
-    #[pyfunction]
-    fn gcd(args: PosArgs<ArgIndex>) -> BigInt {
-        use num_integer::Integer;
-        math_perf_arb_len_int_op(args, |x, y| x.gcd(y.as_bigint()), BigInt::zero())
-    }
-
-    #[pyfunction]
-    fn lcm(args: PosArgs<ArgIndex>) -> BigInt {
-        use num_integer::Integer;
-        math_perf_arb_len_int_op(args, |x, y| x.lcm(y.as_bigint()), BigInt::one())
-    }
-
-    #[pyfunction]
-    fn cbrt(x: ArgIntoFloat) -> f64 {
-        x.cbrt()
-    }
-
-    #[pyfunction]
-    fn fsum(seq: ArgIterable<ArgIntoFloat>, vm: &VirtualMachine) -> PyResult<f64> {
-        let mut partials = Vec::with_capacity(32);
-        let mut special_sum = 0.0;
-        let mut inf_sum = 0.0;
-
-        for obj in seq.iter(vm)? {
-            let mut x = *obj?;
-
-            let xsave = x;
-            let mut i = 0;
-            // This inner loop applies `hi`/`lo` summation to each
-            // partial so that the list of partial sums remains exact.
-            for j in 0..partials.len() {
-                let mut y: f64 = partials[j];
-                if x.abs() < y.abs() {
-                    std::mem::swap(&mut x, &mut y);
-                }
-                // Rounded `x+y` is stored in `hi` with round-off stored in
-                // `lo`. Together `hi+lo` are exactly equal to `x+y`.
-                let hi = x + y;
-                let lo = y - (hi - x);
-                if lo != 0.0 {
-                    partials[i] = lo;
-                    i += 1;
-                }
-                x = hi;
-            }
-
-            partials.truncate(i);
-            if x != 0.0 {
-                if !x.is_finite() {
-                    // a non-finite x could arise either as
-                    // a result of intermediate overflow, or
-                    // as a result of a nan or inf in the
-                    // summands
-                    if xsave.is_finite() {
-                        return Err(vm.new_overflow_error("intermediate overflow in fsum"));
-                    }
-                    if xsave.is_infinite() {
-                        inf_sum += xsave;
-                    }
-                    special_sum += xsave;
-                    // reset partials
-                    partials.clear();
-                } else {
-                    partials.push(x);
-                }
-            }
-        }
-        if special_sum != 0.0 {
-            return if inf_sum.is_nan() {
-                Err(vm.new_value_error("-inf + inf in fsum"))
-            } else {
-                Ok(special_sum)
-            };
-        }
-
-        let mut n = partials.len();
-        if n > 0 {
-            n -= 1;
-            let mut hi = partials[n];
-
-            let mut lo = 0.0;
-            while n > 0 {
-                let x = hi;
-
-                n -= 1;
-                let y = partials[n];
-
-                hi = x + y;
-                lo = y - (hi - x);
-                if lo != 0.0 {
-                    break;
-                }
-            }
-            if n > 0 && ((lo < 0.0 && partials[n - 1] < 0.0) || (lo > 0.0 && partials[n - 1] > 0.0))
-            {
-                let y = lo + lo;
-                let x = hi + y;
-
-                // Make half-even rounding work across multiple partials.
-                // Needed so that sum([1e-16, 1, 1e16]) will round-up the last
-                // digit to two instead of down to zero (the 1e-16 makes the 1
-                // slightly closer to two).  With a potential 1 ULP rounding
-                // error fixed-up, math.fsum() can guarantee commutativity.
-                if y == x - hi {
-                    hi = x;
-                }
-            }
-
-            Ok(hi)
-        } else {
-            Ok(0.0)
-        }
-    }
-
-    #[pyfunction]
-    fn factorial(x: PyIntRef, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let value = x.as_bigint();
-        let one = BigInt::one();
-        if value.is_negative() {
-            return Err(vm.new_value_error("factorial() not defined for negative values"));
-        } else if *value <= one {
-            return Ok(one);
-        }
-        // start from 2, since we know that value > 1 and 1*2=2
-        let mut current = one + 1;
-        let mut product = BigInt::from(2u8);
-        while current < *value {
-            current += 1;
-            product *= &current;
-        }
-        Ok(product)
-    }
-
-    #[pyfunction]
-    fn perm(
-        n: ArgIndex,
-        k: OptionalArg<Option<ArgIndex>>,
-        vm: &VirtualMachine,
-    ) -> PyResult<BigInt> {
-        let n = n.as_bigint();
-        let k_ref;
-        let v = match k.flatten() {
-            Some(k) => {
-                k_ref = k;
-                k_ref.as_bigint()
-            }
-            None => n,
-        };
-
-        if n.is_negative() || v.is_negative() {
-            return Err(vm.new_value_error("perm() not defined for negative values"));
-        }
-        if v > n {
-            return Ok(BigInt::zero());
-        }
-        let mut result = BigInt::one();
-        let mut current = n.clone();
-        let tmp = n - v;
-        while current > tmp {
-            result *= &current;
-            current -= 1;
-        }
-        Ok(result)
-    }
-
-    #[pyfunction]
-    fn comb(n: ArgIndex, k: ArgIndex, vm: &VirtualMachine) -> PyResult<BigInt> {
-        let mut k = k.as_bigint();
-        let n = n.as_bigint();
-        let one = BigInt::one();
-        let zero = BigInt::zero();
-
-        if n.is_negative() || k.is_negative() {
-            return Err(vm.new_value_error("comb() not defined for negative values"));
-        }
-
-        let temp = n - k;
-        if temp.is_negative() {
-            return Ok(zero);
-        }
-
-        if temp < *k {
-            k = &temp
-        }
-
-        if k.is_zero() {
-            return Ok(one);
-        }
-
-        let mut result = n.clone();
-        let mut factor = n.clone();
-        let mut current = one;
-        while current < *k {
-            factor -= 1;
-            current += 1;
-
-            result *= &factor;
-            result /= &current;
-        }
-
-        Ok(result)
-    }
-
-    #[pyfunction]
-    fn modf(x: ArgIntoFloat) -> (f64, f64) {
-        let x = *x;
-        if !x.is_finite() {
-            if x.is_infinite() {
-                return (0.0_f64.copysign(x), x);
-            } else if x.is_nan() {
-                return (x, x);
-            }
-        }
-
-        (x.fract(), x.trunc())
-    }
-
-    #[derive(FromArgs)]
-    struct NextAfterArgs {
-        #[pyarg(positional)]
-        x: ArgIntoFloat,
-        #[pyarg(positional)]
-        y: ArgIntoFloat,
-        #[pyarg(named, optional)]
-        steps: OptionalArg<ArgIndex>,
-    }
-
-    #[pyfunction]
-    fn nextafter(arg: NextAfterArgs, vm: &VirtualMachine) -> PyResult<f64> {
-        let steps: Option<i64> = arg
-            .steps
-            .map(|v| v.try_to_primitive(vm))
-            .transpose()?
-            .into_option();
-        match steps {
-            Some(steps) => {
-                if steps < 0 {
-                    return Err(vm.new_value_error("steps must be a non-negative integer"));
-                }
-                Ok(float_ops::nextafter_with_steps(
-                    *arg.x,
-                    *arg.y,
-                    steps as u64,
-                ))
-            }
-            None => Ok(float_ops::nextafter(*arg.x, *arg.y)),
-        }
-    }
-
-    #[pyfunction]
-    fn ulp(x: ArgIntoFloat) -> f64 {
-        float_ops::ulp(*x)
-    }
-
-    fn fmod(x: f64, y: f64) -> f64 {
-        if y.is_infinite() && x.is_finite() {
-            return x;
-        }
-
-        x % y
-    }
-
-    #[pyfunction(name = "fmod")]
-    fn py_fmod(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
-
-        let r = fmod(x, y);
-
-        if r.is_nan() && !x.is_nan() && !y.is_nan() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-
-        Ok(r)
-    }
-
-    #[pyfunction]
-    fn remainder(x: ArgIntoFloat, y: ArgIntoFloat, vm: &VirtualMachine) -> PyResult<f64> {
-        let x = *x;
-        let y = *y;
-
-        if x.is_finite() && y.is_finite() {
-            if y == 0.0 {
-                return Err(vm.new_value_error("math domain error"));
-            }
-
-            let abs_x = x.abs();
-            let abs_y = y.abs();
-            let modulus = abs_x % abs_y;
-
-            let c = abs_y - modulus;
-            let r = match modulus.partial_cmp(&c) {
-                Some(Ordering::Less) => modulus,
-                Some(Ordering::Greater) => -c,
-                _ => modulus - 2.0 * fmod(0.5 * (abs_x - modulus), abs_y),
-            };
-
-            return Ok(1.0_f64.copysign(x) * r);
-        }
-        if x.is_infinite() && !y.is_nan() {
-            return Err(vm.new_value_error("math domain error"));
-        }
-        if x.is_nan() || y.is_nan() {
-            return Ok(f64::NAN);
-        }
-        if y.is_infinite() {
-            Ok(x)
-        } else {
-            Err(vm.new_value_error("math domain error"))
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct ProdArgs {
-        #[pyarg(positional)]
-        iterable: ArgIterable<PyObjectRef>,
-        #[pyarg(named, optional)]
-        start: OptionalArg<PyObjectRef>,
-    }
-
-    #[pyfunction]
-    fn prod(args: ProdArgs, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        let iter = args.iterable;
-
-        let mut result = args.start.unwrap_or_else(|| vm.new_pyobj(1));
-
-        // TODO: CPython has optimized implementation for this
-        // refer: https://github.com/python/cpython/blob/main/Modules/mathmodule.c#L3093-L3193
-        for obj in iter.iter(vm)? {
-            let obj = obj?;
-            result = vm._mul(&result, &obj)?;
-        }
-
-        Ok(result)
-    }
-
-    #[pyfunction]
-    fn sumprod(
-        p: ArgIterable<PyObjectRef>,
-        q: ArgIterable<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRef> {
-        let mut p_iter = p.iter(vm)?;
-        let mut q_iter = q.iter(vm)?;
-        // We cannot just create a float because the iterator may contain
-        // anything as long as it supports __add__ and __mul__.
-        let mut result = vm.new_pyobj(0);
-        loop {
-            let m_p = p_iter.next();
-            let m_q = q_iter.next();
-            match (m_p, m_q) {
-                (Some(r_p), Some(r_q)) => {
-                    let p = r_p?;
-                    let q = r_q?;
-                    let tmp = vm._mul(&p, &q)?;
-                    result = vm._add(&result, &tmp)?;
-                }
-                (None, None) => break,
-                _ => {
-                    return Err(vm.new_value_error("Inputs are not the same length"));
-                }
-            }
-        }
-
-        Ok(result)
-    }
-
-    #[pyfunction]
-    fn fma(
-        x: ArgIntoFloat,
-        y: ArgIntoFloat,
-        z: ArgIntoFloat,
-        vm: &VirtualMachine,
-    ) -> PyResult<f64> {
-        let result = (*x).mul_add(*y, *z);
-
-        if result.is_finite() {
-            return Ok(result);
-        }
-
-        if result.is_nan() {
-            if !x.is_nan() && !y.is_nan() && !z.is_nan() {
-                return Err(vm.new_value_error("invalid operation in fma"));
-            }
-        } else if x.is_finite() && y.is_finite() && z.is_finite() {
-            return Err(vm.new_overflow_error("overflow in fma"));
-        }
-
-        Ok(result)
-    }
-}
-
-fn pymath_error_to_exception(err: pymath::Error, vm: &VirtualMachine) -> PyBaseExceptionRef {
-    match err {
-        pymath::Error::EDOM => vm.new_value_error("math domain error"),
-        pymath::Error::ERANGE => vm.new_overflow_error("math range error"),
-    }
-}
diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs
deleted file mode 100644
index ed92b74d2f..0000000000
--- a/stdlib/src/mmap.rs
+++ /dev/null
@@ -1,1090 +0,0 @@
-// spell-checker:disable
-//! mmap module
-pub(crate) use mmap::make_module;
-
-#[pymodule]
-mod mmap {
-    use crate::common::{
-        borrow::{BorrowedValue, BorrowedValueMut},
-        lock::{MapImmutable, PyMutex, PyMutexGuard},
-    };
-    use crate::vm::{
-        AsObject, FromArgs, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
-        TryFromBorrowedObject, VirtualMachine, atomic_func,
-        builtins::{PyBytes, PyBytesRef, PyInt, PyIntRef, PyTypeRef},
-        byte::{bytes_from_object, value_from_object},
-        convert::ToPyException,
-        function::{ArgBytesLike, FuncArgs, OptionalArg},
-        protocol::{
-            BufferDescriptor, BufferMethods, PyBuffer, PyMappingMethods, PySequenceMethods,
-        },
-        sliceable::{SaturatedSlice, SequenceIndex, SequenceIndexOp},
-        types::{AsBuffer, AsMapping, AsSequence, Constructor, Representable},
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use memmap2::{Advice, Mmap, MmapMut, MmapOptions};
-    #[cfg(unix)]
-    use nix::sys::stat::fstat;
-    use nix::unistd;
-    use num_traits::Signed;
-    use std::fs::File;
-    use std::io::{self, Write};
-    use std::ops::{Deref, DerefMut};
-    #[cfg(unix)]
-    use std::os::unix::io::{FromRawFd, RawFd};
-
-    fn advice_try_from_i32(vm: &VirtualMachine, i: i32) -> PyResult<Advice> {
-        Ok(match i {
-            libc::MADV_NORMAL => Advice::Normal,
-            libc::MADV_RANDOM => Advice::Random,
-            libc::MADV_SEQUENTIAL => Advice::Sequential,
-            libc::MADV_WILLNEED => Advice::WillNeed,
-            libc::MADV_DONTNEED => Advice::DontNeed,
-            #[cfg(any(target_os = "linux", target_os = "macos", target_os = "ios"))]
-            libc::MADV_FREE => Advice::Free,
-            #[cfg(target_os = "linux")]
-            libc::MADV_DONTFORK => Advice::DontFork,
-            #[cfg(target_os = "linux")]
-            libc::MADV_DOFORK => Advice::DoFork,
-            #[cfg(target_os = "linux")]
-            libc::MADV_MERGEABLE => Advice::Mergeable,
-            #[cfg(target_os = "linux")]
-            libc::MADV_UNMERGEABLE => Advice::Unmergeable,
-            #[cfg(target_os = "linux")]
-            libc::MADV_HUGEPAGE => Advice::HugePage,
-            #[cfg(target_os = "linux")]
-            libc::MADV_NOHUGEPAGE => Advice::NoHugePage,
-            #[cfg(target_os = "linux")]
-            libc::MADV_REMOVE => Advice::Remove,
-            #[cfg(target_os = "linux")]
-            libc::MADV_DONTDUMP => Advice::DontDump,
-            #[cfg(target_os = "linux")]
-            libc::MADV_DODUMP => Advice::DoDump,
-            #[cfg(target_os = "linux")]
-            libc::MADV_HWPOISON => Advice::HwPoison,
-            _ => return Err(vm.new_value_error("Not a valid Advice value")),
-        })
-    }
-
-    #[repr(C)]
-    #[derive(PartialEq, Eq, Debug)]
-    enum AccessMode {
-        Default = 0,
-        Read = 1,
-        Write = 2,
-        Copy = 3,
-    }
-
-    impl<'a> TryFromBorrowedObject<'a> for AccessMode {
-        fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-            let i = u32::try_from_borrowed_object(vm, obj)?;
-            Ok(match i {
-                0 => Self::Default,
-                1 => Self::Read,
-                2 => Self::Write,
-                3 => Self::Copy,
-                _ => return Err(vm.new_value_error("Not a valid AccessMode value")),
-            })
-        }
-    }
-
-    #[pyattr]
-    use libc::{
-        MADV_DONTNEED, MADV_NORMAL, MADV_RANDOM, MADV_SEQUENTIAL, MADV_WILLNEED, MAP_ANON,
-        MAP_ANONYMOUS, MAP_PRIVATE, MAP_SHARED, PROT_READ, PROT_WRITE,
-    };
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    use libc::{MADV_FREE_REUSABLE, MADV_FREE_REUSE};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "fuchsia",
-        target_os = "freebsd",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use libc::MADV_FREE;
-
-    #[cfg(target_os = "linux")]
-    #[pyattr]
-    use libc::{
-        MADV_DODUMP, MADV_DOFORK, MADV_DONTDUMP, MADV_DONTFORK, MADV_HUGEPAGE, MADV_HWPOISON,
-        MADV_MERGEABLE, MADV_NOHUGEPAGE, MADV_REMOVE, MADV_UNMERGEABLE,
-    };
-
-    #[cfg(any(
-        target_os = "android",
-        all(
-            target_os = "linux",
-            any(
-                target_arch = "aarch64",
-                target_arch = "arm",
-                target_arch = "powerpc",
-                target_arch = "powerpc64",
-                target_arch = "s390x",
-                target_arch = "x86",
-                target_arch = "x86_64",
-                target_arch = "sparc64"
-            )
-        )
-    ))]
-    #[pyattr]
-    use libc::MADV_SOFT_OFFLINE;
-
-    #[cfg(all(target_os = "linux", target_arch = "x86_64", target_env = "gnu"))]
-    #[pyattr]
-    use libc::{MAP_DENYWRITE, MAP_EXECUTABLE, MAP_POPULATE};
-
-    #[pyattr]
-    const ACCESS_DEFAULT: u32 = AccessMode::Default as u32;
-    #[pyattr]
-    const ACCESS_READ: u32 = AccessMode::Read as u32;
-    #[pyattr]
-    const ACCESS_WRITE: u32 = AccessMode::Write as u32;
-    #[pyattr]
-    const ACCESS_COPY: u32 = AccessMode::Copy as u32;
-
-    #[cfg(all(unix, not(target_arch = "wasm32")))]
-    #[pyattr(name = "PAGESIZE", once)]
-    fn page_size(_vm: &VirtualMachine) -> usize {
-        page_size::get()
-    }
-
-    #[cfg(all(unix, not(target_arch = "wasm32")))]
-    #[pyattr(name = "ALLOCATIONGRANULARITY", once)]
-    fn granularity(_vm: &VirtualMachine) -> usize {
-        page_size::get_granularity()
-    }
-
-    #[pyattr(name = "error", once)]
-    fn error_type(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.exceptions.os_error.to_owned()
-    }
-
-    #[derive(Debug)]
-    enum MmapObj {
-        Write(MmapMut),
-        Read(Mmap),
-    }
-
-    #[pyattr]
-    #[pyclass(name = "mmap")]
-    #[derive(Debug, PyPayload)]
-    struct PyMmap {
-        closed: AtomicCell<bool>,
-        mmap: PyMutex<Option<MmapObj>>,
-        fd: RawFd,
-        offset: libc::off_t,
-        size: AtomicCell<usize>,
-        pos: AtomicCell<usize>, // relative to offset
-        exports: AtomicCell<usize>,
-        access: AccessMode,
-    }
-
-    #[derive(FromArgs)]
-    struct MmapNewArgs {
-        #[pyarg(any)]
-        fileno: RawFd,
-        #[pyarg(any)]
-        length: isize,
-        #[pyarg(any, default = MAP_SHARED)]
-        flags: libc::c_int,
-        #[pyarg(any, default = PROT_WRITE|PROT_READ)]
-        prot: libc::c_int,
-        #[pyarg(any, default = AccessMode::Default)]
-        access: AccessMode,
-        #[pyarg(any, default = 0)]
-        offset: libc::off_t,
-    }
-
-    #[derive(FromArgs)]
-    pub struct FlushOptions {
-        #[pyarg(positional, default)]
-        offset: Option<isize>,
-        #[pyarg(positional, default)]
-        size: Option<isize>,
-    }
-
-    impl FlushOptions {
-        fn values(self, len: usize) -> Option<(usize, usize)> {
-            let offset = match self.offset {
-                Some(o) if o < 0 => return None,
-                Some(o) => o as usize,
-                None => 0,
-            };
-
-            let size = match self.size {
-                Some(s) if s < 0 => return None,
-                Some(s) => s as usize,
-                None => len,
-            };
-
-            if len.checked_sub(offset)? < size {
-                return None;
-            }
-
-            Some((offset, size))
-        }
-    }
-
-    #[derive(FromArgs, Clone)]
-    pub struct FindOptions {
-        #[pyarg(positional)]
-        sub: Vec<u8>,
-        #[pyarg(positional, default)]
-        start: Option<isize>,
-        #[pyarg(positional, default)]
-        end: Option<isize>,
-    }
-
-    #[cfg(not(target_os = "redox"))]
-    #[derive(FromArgs)]
-    pub struct AdviseOptions {
-        #[pyarg(positional)]
-        option: libc::c_int,
-        #[pyarg(positional, default)]
-        start: Option<PyIntRef>,
-        #[pyarg(positional, default)]
-        length: Option<PyIntRef>,
-    }
-
-    #[cfg(not(target_os = "redox"))]
-    impl AdviseOptions {
-        fn values(self, len: usize, vm: &VirtualMachine) -> PyResult<(libc::c_int, usize, usize)> {
-            let start = self
-                .start
-                .map(|s| {
-                    s.try_to_primitive::<usize>(vm)
-                        .ok()
-                        .filter(|s| *s < len)
-                        .ok_or_else(|| vm.new_value_error("madvise start out of bounds"))
-                })
-                .transpose()?
-                .unwrap_or(0);
-            let length = self
-                .length
-                .map(|s| {
-                    s.try_to_primitive::<usize>(vm)
-                        .map_err(|_| vm.new_value_error("madvise length invalid"))
-                })
-                .transpose()?
-                .unwrap_or(len);
-
-            if isize::MAX as usize - start < length {
-                return Err(vm.new_overflow_error("madvise length too large"));
-            }
-
-            let length = if start + length > len {
-                len - start
-            } else {
-                length
-            };
-
-            Ok((self.option, start, length))
-        }
-    }
-
-    impl Constructor for PyMmap {
-        type Args = MmapNewArgs;
-
-        // TODO: Windows is not supported right now.
-        #[cfg(unix)]
-        fn py_new(
-            cls: PyTypeRef,
-            MmapNewArgs {
-                fileno: fd,
-                length,
-                flags,
-                prot,
-                access,
-                offset,
-            }: Self::Args,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            let map_size = length;
-            if map_size < 0 {
-                return Err(vm.new_overflow_error("memory mapped length must be positive"));
-            }
-            let mut map_size = map_size as usize;
-
-            if offset < 0 {
-                return Err(vm.new_overflow_error("memory mapped offset must be positive"));
-            }
-
-            if (access != AccessMode::Default)
-                && ((flags != MAP_SHARED) || (prot != (PROT_WRITE | PROT_READ)))
-            {
-                return Err(vm.new_value_error("mmap can't specify both access and flags, prot."));
-            }
-
-            // TODO: memmap2 doesn't support mapping with pro and flags right now
-            let (_flags, _prot, access) = match access {
-                AccessMode::Read => (MAP_SHARED, PROT_READ, access),
-                AccessMode::Write => (MAP_SHARED, PROT_READ | PROT_WRITE, access),
-                AccessMode::Copy => (MAP_PRIVATE, PROT_READ | PROT_WRITE, access),
-                AccessMode::Default => {
-                    let access = if (prot & PROT_READ) != 0 && (prot & PROT_WRITE) != 0 {
-                        access
-                    } else if (prot & PROT_WRITE) != 0 {
-                        AccessMode::Write
-                    } else {
-                        AccessMode::Read
-                    };
-                    (flags, prot, access)
-                }
-            };
-
-            if fd != -1 {
-                let metadata = fstat(fd)
-                    .map_err(|err| io::Error::from_raw_os_error(err as i32).to_pyexception(vm))?;
-                let file_len = metadata.st_size;
-
-                if map_size == 0 {
-                    if file_len == 0 {
-                        return Err(vm.new_value_error("cannot mmap an empty file"));
-                    }
-
-                    if offset > file_len {
-                        return Err(vm.new_value_error("mmap offset is greater than file size"));
-                    }
-
-                    map_size = (file_len - offset)
-                        .try_into()
-                        .map_err(|_| vm.new_value_error("mmap length is too large"))?;
-                } else if offset > file_len || file_len - offset < map_size as libc::off_t {
-                    return Err(vm.new_value_error("mmap length is greater than file size"));
-                }
-            }
-
-            let mut mmap_opt = MmapOptions::new();
-            let mmap_opt = mmap_opt.offset(offset.try_into().unwrap()).len(map_size);
-
-            let (fd, mmap) = || -> std::io::Result<_> {
-                if fd == -1 {
-                    let mmap = MmapObj::Write(mmap_opt.map_anon()?);
-                    Ok((fd, mmap))
-                } else {
-                    let new_fd = unistd::dup(fd)?;
-                    let mmap = match access {
-                        AccessMode::Default | AccessMode::Write => {
-                            MmapObj::Write(unsafe { mmap_opt.map_mut(fd) }?)
-                        }
-                        AccessMode::Read => MmapObj::Read(unsafe { mmap_opt.map(fd) }?),
-                        AccessMode::Copy => MmapObj::Write(unsafe { mmap_opt.map_copy(fd) }?),
-                    };
-                    Ok((new_fd, mmap))
-                }
-            }()
-            .map_err(|e| e.to_pyexception(vm))?;
-
-            let m_obj = Self {
-                closed: AtomicCell::new(false),
-                mmap: PyMutex::new(Some(mmap)),
-                fd,
-                offset,
-                size: AtomicCell::new(map_size),
-                pos: AtomicCell::new(0),
-                exports: AtomicCell::new(0),
-                access,
-            };
-
-            m_obj.into_ref_with_type(vm, cls).map(Into::into)
-        }
-    }
-
-    static BUFFER_METHODS: BufferMethods = BufferMethods {
-        obj_bytes: |buffer| buffer.obj_as::<PyMmap>().as_bytes(),
-        obj_bytes_mut: |buffer| buffer.obj_as::<PyMmap>().as_bytes_mut(),
-        release: |buffer| {
-            buffer.obj_as::<PyMmap>().exports.fetch_sub(1);
-        },
-        retain: |buffer| {
-            buffer.obj_as::<PyMmap>().exports.fetch_add(1);
-        },
-    };
-
-    impl AsBuffer for PyMmap {
-        fn as_buffer(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<PyBuffer> {
-            let buf = PyBuffer::new(
-                zelf.to_owned().into(),
-                BufferDescriptor::simple(zelf.__len__(), true),
-                &BUFFER_METHODS,
-            );
-
-            Ok(buf)
-        }
-    }
-
-    impl AsMapping for PyMmap {
-        fn as_mapping() -> &'static PyMappingMethods {
-            static AS_MAPPING: PyMappingMethods = PyMappingMethods {
-                length: atomic_func!(
-                    |mapping, _vm| Ok(PyMmap::mapping_downcast(mapping).__len__())
-                ),
-                subscript: atomic_func!(|mapping, needle, vm| {
-                    PyMmap::mapping_downcast(mapping).getitem_inner(needle, vm)
-                }),
-                ass_subscript: atomic_func!(|mapping, needle, value, vm| {
-                    let zelf = PyMmap::mapping_downcast(mapping);
-                    if let Some(value) = value {
-                        PyMmap::setitem_inner(zelf, needle, value, vm)
-                    } else {
-                        Err(vm
-                            .new_type_error("mmap object doesn't support item deletion".to_owned()))
-                    }
-                }),
-            };
-            &AS_MAPPING
-        }
-    }
-
-    impl AsSequence for PyMmap {
-        fn as_sequence() -> &'static PySequenceMethods {
-            use std::sync::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| {
-                    let zelf = PyMmap::sequence_downcast(seq);
-                    zelf.getitem_by_index(i, vm)
-                }),
-                ass_item: atomic_func!(|seq, i, value, vm| {
-                    let zelf = PyMmap::sequence_downcast(seq);
-                    if let Some(value) = value {
-                        PyMmap::setitem_by_index(zelf, i, value, vm)
-                    } else {
-                        Err(vm
-                            .new_type_error("mmap object doesn't support item deletion".to_owned()))
-                    }
-                }),
-                ..PySequenceMethods::NOT_IMPLEMENTED
-            });
-            &AS_SEQUENCE
-        }
-    }
-
-    #[pyclass(
-        with(Constructor, AsMapping, AsSequence, AsBuffer, Representable),
-        flags(BASETYPE)
-    )]
-    impl PyMmap {
-        fn as_bytes_mut(&self) -> BorrowedValueMut<'_, [u8]> {
-            PyMutexGuard::map(self.mmap.lock(), |m| {
-                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[..],
-                }
-            })
-            .into()
-        }
-
-        fn as_bytes(&self) -> BorrowedValue<'_, [u8]> {
-            PyMutexGuard::map_immutable(self.mmap.lock(), |m| {
-                match m.as_ref().expect("mmap closed or invalid") {
-                    MmapObj::Read(mmap) => &mmap[..],
-                    MmapObj::Write(mmap) => &mmap[..],
-                }
-            })
-            .into()
-        }
-
-        #[pymethod]
-        fn __len__(&self) -> usize {
-            self.size.load()
-        }
-
-        #[inline]
-        fn pos(&self) -> usize {
-            self.pos.load()
-        }
-
-        #[inline]
-        fn advance_pos(&self, step: usize) {
-            self.pos.store(self.pos() + step);
-        }
-
-        #[inline]
-        fn try_writable<R>(
-            &self,
-            vm: &VirtualMachine,
-            f: impl FnOnce(&mut MmapMut) -> 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"),
-            }
-        }
-
-        fn check_valid(&self, vm: &VirtualMachine) -> PyResult<PyMutexGuard<'_, Option<MmapObj>>> {
-            let m = self.mmap.lock();
-
-            if m.is_none() {
-                return Err(vm.new_value_error("mmap closed or invalid"));
-            }
-
-            Ok(m)
-        }
-
-        /// TODO: impl resize
-        #[allow(dead_code)]
-        fn check_resizeable(&self, vm: &VirtualMachine) -> PyResult<()> {
-            if self.exports.load() > 0 {
-                return Err(vm.new_buffer_error("mmap can't resize with extant buffers exported."));
-            }
-
-            if self.access == AccessMode::Write || self.access == AccessMode::Default {
-                return Ok(());
-            }
-
-            Err(vm.new_type_error("mmap can't resize a readonly or copy-on-write memory map."))
-        }
-
-        #[pygetset]
-        fn closed(&self) -> bool {
-            self.closed.load()
-        }
-
-        #[pymethod]
-        fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
-            if self.closed() {
-                return Ok(());
-            }
-
-            if self.exports.load() > 0 {
-                return Err(vm.new_buffer_error("cannot close exported pointers exist."));
-            }
-
-            let mut mmap = self.mmap.lock();
-            self.closed.store(true);
-            *mmap = None;
-
-            Ok(())
-        }
-
-        fn get_find_range(&self, options: FindOptions) -> (usize, usize) {
-            let size = self.__len__();
-            let start = options
-                .start
-                .map(|start| start.saturated_at(size))
-                .unwrap_or_else(|| self.pos());
-            let end = options
-                .end
-                .map(|end| end.saturated_at(size))
-                .unwrap_or(size);
-            (start, end)
-        }
-
-        #[pymethod]
-        fn find(&self, options: FindOptions, vm: &VirtualMachine) -> PyResult<PyInt> {
-            let (start, end) = self.get_find_range(options.clone());
-
-            let sub = &options.sub;
-
-            if sub.is_empty() {
-                return Ok(PyInt::from(0isize));
-            }
-
-            let mmap = self.check_valid(vm)?;
-            let buf = match mmap.as_ref().unwrap() {
-                MmapObj::Read(mmap) => &mmap[start..end],
-                MmapObj::Write(mmap) => &mmap[start..end],
-            };
-            let pos = buf.windows(sub.len()).position(|window| window == sub);
-
-            Ok(pos.map_or(PyInt::from(-1isize), |i| PyInt::from(start + i)))
-        }
-
-        #[pymethod]
-        fn rfind(&self, options: FindOptions, vm: &VirtualMachine) -> PyResult<PyInt> {
-            let (start, end) = self.get_find_range(options.clone());
-
-            let sub = &options.sub;
-            if sub.is_empty() {
-                return Ok(PyInt::from(0isize));
-            }
-
-            let mmap = self.check_valid(vm)?;
-            let buf = match mmap.as_ref().unwrap() {
-                MmapObj::Read(mmap) => &mmap[start..end],
-                MmapObj::Write(mmap) => &mmap[start..end],
-            };
-            let pos = buf.windows(sub.len()).rposition(|window| window == sub);
-
-            Ok(pos.map_or(PyInt::from(-1isize), |i| PyInt::from(start + i)))
-        }
-
-        #[pymethod]
-        fn flush(&self, options: FlushOptions, vm: &VirtualMachine) -> PyResult<()> {
-            let (offset, size) = options
-                .values(self.__len__())
-                .ok_or_else(|| vm.new_value_error("flush values out of range"))?;
-
-            if self.access == AccessMode::Read || self.access == AccessMode::Copy {
-                return Ok(());
-            }
-
-            match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(_mmap) => {}
-                MmapObj::Write(mmap) => {
-                    mmap.flush_range(offset, size)
-                        .map_err(|e| e.to_pyexception(vm))?;
-                }
-            }
-
-            Ok(())
-        }
-
-        #[cfg(not(target_os = "redox"))]
-        #[allow(unused_assignments)]
-        #[pymethod]
-        fn madvise(&self, options: AdviseOptions, vm: &VirtualMachine) -> PyResult<()> {
-            let (option, _start, _length) = options.values(self.__len__(), vm)?;
-            let advice = advice_try_from_i32(vm, option)?;
-
-            //TODO: memmap2 doesn't support madvise range right now.
-            match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap.advise(advice),
-                MmapObj::Write(mmap) => mmap.advise(advice),
-            }
-            .map_err(|e| e.to_pyexception(vm))?;
-
-            Ok(())
-        }
-
-        #[pymethod(name = "move")]
-        fn move_(
-            &self,
-            dest: PyIntRef,
-            src: PyIntRef,
-            cnt: PyIntRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            fn args(
-                dest: PyIntRef,
-                src: PyIntRef,
-                cnt: PyIntRef,
-                size: usize,
-                vm: &VirtualMachine,
-            ) -> Option<(usize, usize, usize)> {
-                if dest.as_bigint().is_negative()
-                    || src.as_bigint().is_negative()
-                    || cnt.as_bigint().is_negative()
-                {
-                    return None;
-                }
-                let dest = dest.try_to_primitive(vm).ok()?;
-                let src = src.try_to_primitive(vm).ok()?;
-                let cnt = cnt.try_to_primitive(vm).ok()?;
-                if size - dest < cnt || size - src < cnt {
-                    return None;
-                }
-                Some((dest, src, cnt))
-            }
-
-            let size = self.__len__();
-            let (dest, src, cnt) = args(dest, src, cnt, size, vm)
-                .ok_or_else(|| vm.new_value_error("source, destination, or count out of range"))?;
-
-            let dest_end = dest + cnt;
-            let src_end = src + cnt;
-
-            self.try_writable(vm, |mmap| {
-                let src_buf = mmap[src..src_end].to_vec();
-                (&mut mmap[dest..dest_end])
-                    .write(&src_buf)
-                    .map_err(|e| e.to_pyexception(vm))?;
-                Ok(())
-            })?
-        }
-
-        #[pymethod]
-        fn read(&self, n: OptionalArg<PyObjectRef>, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-            let num_bytes = n
-                .map(|obj| {
-                    let class = obj.class().to_owned();
-                    obj.try_into_value::<Option<isize>>(vm).map_err(|_| {
-                        vm.new_type_error(format!(
-                            "read argument must be int or None, not {}",
-                            class.name()
-                        ))
-                    })
-                })
-                .transpose()?
-                .flatten();
-            let mmap = self.check_valid(vm)?;
-            let pos = self.pos();
-            let remaining = self.__len__().saturating_sub(pos);
-            let num_bytes = num_bytes
-                .filter(|&n| n >= 0 && (n as usize) <= remaining)
-                .map(|n| n as usize)
-                .unwrap_or(remaining);
-
-            let end_pos = pos + num_bytes;
-            let bytes = match mmap.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos..end_pos].to_vec(),
-                MmapObj::Write(mmap) => mmap[pos..end_pos].to_vec(),
-            };
-
-            let result = PyBytes::from(bytes).into_ref(&vm.ctx);
-
-            self.advance_pos(num_bytes);
-
-            Ok(result)
-        }
-
-        #[pymethod]
-        fn read_byte(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
-            let pos = self.pos();
-            if pos >= self.__len__() {
-                return Err(vm.new_value_error("read byte out of range"));
-            }
-
-            let b = match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos],
-                MmapObj::Write(mmap) => mmap[pos],
-            };
-
-            self.advance_pos(1);
-
-            Ok(PyInt::from(b).into_ref(&vm.ctx))
-        }
-
-        #[pymethod]
-        fn readline(&self, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-            let pos = self.pos();
-            let mmap = self.check_valid(vm)?;
-
-            let remaining = self.__len__().saturating_sub(pos);
-            if remaining == 0 {
-                return Ok(PyBytes::from(vec![]).into_ref(&vm.ctx));
-            }
-
-            let eof = match mmap.as_ref().unwrap() {
-                MmapObj::Read(mmap) => &mmap[pos..],
-                MmapObj::Write(mmap) => &mmap[pos..],
-            }
-            .iter()
-            .position(|&x| x == b'\n');
-
-            let end_pos = if let Some(i) = eof {
-                pos + i + 1
-            } else {
-                self.__len__()
-            };
-
-            let bytes = match mmap.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[pos..end_pos].to_vec(),
-                MmapObj::Write(mmap) => mmap[pos..end_pos].to_vec(),
-            };
-
-            let result = PyBytes::from(bytes).into_ref(&vm.ctx);
-
-            self.advance_pos(end_pos - pos);
-
-            Ok(result)
-        }
-
-        // TODO: supports resize
-        #[pymethod]
-        fn resize(&self, _newsize: PyIntRef, vm: &VirtualMachine) -> PyResult<()> {
-            self.check_resizeable(vm)?;
-            Err(vm.new_system_error("mmap: resizing not available--no mremap()"))
-        }
-
-        #[pymethod]
-        fn seek(
-            &self,
-            dist: isize,
-            whence: OptionalArg<libc::c_int>,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            let how = whence.unwrap_or(0);
-            let size = self.__len__();
-
-            let new_pos = match how {
-                0 => dist, // relative to start
-                1 => {
-                    // relative to current position
-                    let pos = self.pos();
-                    if (((isize::MAX as usize) - pos) as isize) < dist {
-                        return Err(vm.new_value_error("seek out of range"));
-                    }
-                    pos as isize + dist
-                }
-                2 => {
-                    // relative to end
-                    if (((isize::MAX as usize) - size) as isize) < dist {
-                        return Err(vm.new_value_error("seek out of range"));
-                    }
-                    size as isize + dist
-                }
-                _ => return Err(vm.new_value_error("unknown seek type")),
-            };
-
-            if new_pos < 0 || (new_pos as usize) > size {
-                return Err(vm.new_value_error("seek out of range"));
-            }
-
-            self.pos.store(new_pos as usize);
-
-            Ok(())
-        }
-
-        #[pymethod]
-        fn size(&self, vm: &VirtualMachine) -> std::io::Result<PyIntRef> {
-            let new_fd = unistd::dup(self.fd)?;
-            let file = unsafe { File::from_raw_fd(new_fd) };
-            let file_len = file.metadata()?.len();
-            Ok(PyInt::from(file_len).into_ref(&vm.ctx))
-        }
-
-        #[pymethod]
-        fn tell(&self) -> PyResult<usize> {
-            Ok(self.pos())
-        }
-
-        #[pymethod]
-        fn write(&self, bytes: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyIntRef> {
-            let pos = self.pos();
-            let size = self.__len__();
-
-            let data = bytes.borrow_buf();
-
-            if pos > size || size - pos < data.len() {
-                return Err(vm.new_value_error("data out of range"));
-            }
-
-            let len = self.try_writable(vm, |mmap| {
-                (&mut mmap[pos..(pos + data.len())])
-                    .write(&data)
-                    .map_err(|err| err.to_pyexception(vm))?;
-                Ok(data.len())
-            })??;
-
-            self.advance_pos(len);
-
-            Ok(PyInt::from(len).into_ref(&vm.ctx))
-        }
-
-        #[pymethod]
-        fn write_byte(&self, byte: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let b = value_from_object(vm, &byte)?;
-
-            let pos = self.pos();
-            let size = self.__len__();
-
-            if pos >= size {
-                return Err(vm.new_value_error("write byte out of range"));
-            }
-
-            self.try_writable(vm, |mmap| {
-                mmap[pos] = b;
-            })?;
-
-            self.advance_pos(1);
-
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-            self.getitem_inner(&needle, vm)
-        }
-
-        #[pymethod]
-        fn __setitem__(
-            zelf: &Py<Self>,
-            needle: PyObjectRef,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            Self::setitem_inner(zelf, &needle, value, vm)
-        }
-
-        #[pymethod]
-        fn __enter__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-            let _m = zelf.check_valid(vm)?;
-            Ok(zelf.to_owned())
-        }
-
-        #[pymethod]
-        fn __exit__(zelf: &Py<Self>, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            zelf.close(vm)
-        }
-    }
-
-    impl PyMmap {
-        fn getitem_by_index(&self, i: isize, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-            let i = i
-                .wrapped_at(self.__len__())
-                .ok_or_else(|| vm.new_index_error("mmap index out of range"))?;
-
-            let b = match self.check_valid(vm)?.deref().as_ref().unwrap() {
-                MmapObj::Read(mmap) => mmap[i],
-                MmapObj::Write(mmap) => mmap[i],
-            };
-
-            Ok(PyInt::from(b).into_ref(&vm.ctx).into())
-        }
-
-        fn getitem_by_slice(
-            &self,
-            slice: &SaturatedSlice,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyObjectRef> {
-            let (range, step, slice_len) = slice.adjust_indices(self.__len__());
-
-            let mmap = self.check_valid(vm)?;
-
-            if slice_len == 0 {
-                return Ok(PyBytes::from(vec![]).into_ref(&vm.ctx).into());
-            } else if step == 1 {
-                let bytes = match mmap.deref().as_ref().unwrap() {
-                    MmapObj::Read(mmap) => &mmap[range],
-                    MmapObj::Write(mmap) => &mmap[range],
-                };
-                return Ok(PyBytes::from(bytes.to_vec()).into_ref(&vm.ctx).into());
-            }
-
-            let mut result_buf = Vec::with_capacity(slice_len);
-            if step.is_negative() {
-                for i in range.rev().step_by(step.unsigned_abs()) {
-                    let b = match mmap.deref().as_ref().unwrap() {
-                        MmapObj::Read(mmap) => mmap[i],
-                        MmapObj::Write(mmap) => mmap[i],
-                    };
-                    result_buf.push(b);
-                }
-            } else {
-                for i in range.step_by(step.unsigned_abs()) {
-                    let b = match mmap.deref().as_ref().unwrap() {
-                        MmapObj::Read(mmap) => mmap[i],
-                        MmapObj::Write(mmap) => mmap[i],
-                    };
-                    result_buf.push(b);
-                }
-            }
-            Ok(PyBytes::from(result_buf).into_ref(&vm.ctx).into())
-        }
-
-        fn getitem_inner(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-            match SequenceIndex::try_from_borrowed_object(vm, needle, "mmap")? {
-                SequenceIndex::Int(i) => self.getitem_by_index(i, vm),
-                SequenceIndex::Slice(slice) => self.getitem_by_slice(&slice, vm),
-            }
-        }
-
-        fn setitem_inner(
-            zelf: &Py<Self>,
-            needle: &PyObject,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            match SequenceIndex::try_from_borrowed_object(vm, needle, "mmap")? {
-                SequenceIndex::Int(i) => Self::setitem_by_index(zelf, i, value, vm),
-                SequenceIndex::Slice(slice) => Self::setitem_by_slice(zelf, &slice, value, vm),
-            }
-        }
-
-        fn setitem_by_index(
-            &self,
-            i: isize,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            let i: usize = i
-                .wrapped_at(self.__len__())
-                .ok_or_else(|| vm.new_index_error("mmap index out of range"))?;
-
-            let b = value_from_object(vm, &value)?;
-
-            self.try_writable(vm, |mmap| {
-                mmap[i] = b;
-            })?;
-
-            Ok(())
-        }
-
-        fn setitem_by_slice(
-            &self,
-            slice: &SaturatedSlice,
-            value: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            let (range, step, slice_len) = slice.adjust_indices(self.__len__());
-
-            let bytes = bytes_from_object(vm, &value)?;
-
-            if bytes.len() != slice_len {
-                return Err(vm.new_index_error("mmap slice assignment is wrong size"));
-            }
-
-            if slice_len == 0 {
-                // do nothing
-                Ok(())
-            } else if step == 1 {
-                self.try_writable(vm, |mmap| {
-                    (&mut mmap[range])
-                        .write(&bytes)
-                        .map_err(|err| err.to_pyexception(vm))?;
-                    Ok(())
-                })?
-            } else {
-                let mut bi = 0; // bytes index
-                if step.is_negative() {
-                    for i in range.rev().step_by(step.unsigned_abs()) {
-                        self.try_writable(vm, |mmap| {
-                            mmap[i] = bytes[bi];
-                        })?;
-                        bi += 1;
-                    }
-                } else {
-                    for i in range.step_by(step.unsigned_abs()) {
-                        self.try_writable(vm, |mmap| {
-                            mmap[i] = bytes[bi];
-                        })?;
-                        bi += 1;
-                    }
-                }
-                Ok(())
-            }
-        }
-    }
-
-    impl Representable for PyMmap {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            let mmap = zelf.mmap.lock();
-
-            if mmap.is_none() {
-                return Ok("<mmap.mmap closed=True>".to_owned());
-            }
-
-            let access_str = match zelf.access {
-                AccessMode::Default => "ACCESS_DEFAULT",
-                AccessMode::Read => "ACCESS_READ",
-                AccessMode::Write => "ACCESS_WRITE",
-                AccessMode::Copy => "ACCESS_COPY",
-            };
-
-            let repr = format!(
-                "<mmap.mmap closed=False, access={}, length={}, pos={}, offset={}>",
-                access_str,
-                zelf.__len__(),
-                zelf.pos(),
-                zelf.offset
-            );
-
-            Ok(repr)
-        }
-    }
-}
diff --git a/stdlib/src/multiprocessing.rs b/stdlib/src/multiprocessing.rs
deleted file mode 100644
index 4a98c1afad..0000000000
--- a/stdlib/src/multiprocessing.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-pub(crate) use _multiprocessing::make_module;
-
-#[cfg(windows)]
-#[pymodule]
-mod _multiprocessing {
-    use crate::vm::{PyResult, VirtualMachine, function::ArgBytesLike, stdlib::os};
-    use windows_sys::Win32::Networking::WinSock::{self, SOCKET};
-
-    #[pyfunction]
-    fn closesocket(socket: usize, vm: &VirtualMachine) -> PyResult<()> {
-        let res = unsafe { WinSock::closesocket(socket as SOCKET) };
-        if res == 0 {
-            Err(os::errno_err(vm))
-        } else {
-            Ok(())
-        }
-    }
-
-    #[pyfunction]
-    fn recv(socket: usize, size: usize, vm: &VirtualMachine) -> PyResult<libc::c_int> {
-        let mut buf = vec![0; 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(os::errno_err(vm))
-        } else {
-            Ok(n_read)
-        }
-    }
-
-    #[pyfunction]
-    fn send(socket: usize, buf: ArgBytesLike, vm: &VirtualMachine) -> PyResult<libc::c_int> {
-        let ret = buf.with_ref(|b| unsafe {
-            WinSock::send(socket as SOCKET, b.as_ptr() as *const _, b.len() as i32, 0)
-        });
-        if ret < 0 {
-            Err(os::errno_err(vm))
-        } else {
-            Ok(ret)
-        }
-    }
-}
-
-#[cfg(not(windows))]
-#[pymodule]
-mod _multiprocessing {}
diff --git a/stdlib/src/overlapped.rs b/stdlib/src/overlapped.rs
deleted file mode 100644
index 9d816a03d4..0000000000
--- a/stdlib/src/overlapped.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-// spell-checker:disable
-
-pub(crate) use _overlapped::make_module;
-
-#[allow(non_snake_case)]
-#[pymodule]
-mod _overlapped {
-    // straight-forward port of Modules/overlapped.c
-
-    use crate::vm::{
-        Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyBytesRef, PyTypeRef},
-        common::lock::PyMutex,
-        convert::{ToPyException, ToPyObject},
-        protocol::PyBuffer,
-        stdlib::os::errno_err,
-        types::Constructor,
-    };
-    use windows_sys::Win32::{
-        Foundation::{self, GetLastError, HANDLE},
-        Networking::WinSock::SOCKADDR_IN6,
-        System::IO::OVERLAPPED,
-    };
-
-    #[pyattr]
-    use windows_sys::Win32::{
-        Foundation::{
-            ERROR_IO_PENDING, ERROR_NETNAME_DELETED, ERROR_OPERATION_ABORTED, ERROR_PIPE_BUSY,
-            ERROR_PORT_UNREACHABLE, ERROR_SEM_TIMEOUT,
-        },
-        Networking::WinSock::{
-            SO_UPDATE_ACCEPT_CONTEXT, SO_UPDATE_CONNECT_CONTEXT, TF_REUSE_SOCKET,
-        },
-        System::Threading::INFINITE,
-    };
-
-    #[pyattr]
-    const INVALID_HANDLE_VALUE: isize =
-        unsafe { std::mem::transmute(windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE) };
-
-    #[pyattr]
-    const NULL: isize = 0;
-
-    #[pyattr]
-    #[pyclass(name)]
-    #[derive(PyPayload)]
-    struct Overlapped {
-        inner: PyMutex<OverlappedInner>,
-    }
-
-    struct OverlappedInner {
-        overlapped: OVERLAPPED,
-        handle: HANDLE,
-        error: u32,
-        data: OverlappedData,
-    }
-
-    unsafe impl Sync for OverlappedInner {}
-    unsafe impl Send for OverlappedInner {}
-
-    impl std::fmt::Debug for Overlapped {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            let zelf = self.inner.lock();
-            f.debug_struct("Overlapped")
-                // .field("overlapped", &(self.overlapped as *const _ as usize))
-                .field("handle", &zelf.handle)
-                .field("error", &zelf.error)
-                .field("data", &zelf.data)
-                .finish()
-        }
-    }
-
-    #[allow(dead_code)] // TODO: remove when done
-    #[derive(Debug)]
-    enum OverlappedData {
-        None,
-        NotStarted,
-        Read(PyBytesRef),
-        ReadInto(PyBuffer),
-        Write(PyBuffer),
-        Accept(PyObjectRef),
-        Connect,
-        Disconnect,
-        ConnectNamedPipe,
-        WaitNamedPipeAndConnect,
-        TransmitFile,
-        ReadFrom(OverlappedReadFrom),
-        WriteTo(PyBuffer),
-        ReadFromInto(OverlappedReadFromInto),
-    }
-
-    struct OverlappedReadFrom {
-        // A (buffer, (host, port)) tuple
-        result: PyObjectRef,
-        // The actual read buffer
-        allocated_buffer: PyObjectRef,
-        #[allow(dead_code)]
-        address: SOCKADDR_IN6, // TODO: remove when done
-        address_length: libc::c_int,
-    }
-
-    impl std::fmt::Debug for OverlappedReadFrom {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.debug_struct("OverlappedReadFrom")
-                .field("result", &self.result)
-                .field("allocated_buffer", &self.allocated_buffer)
-                // .field("address", &self.address)
-                .field("address_length", &self.address_length)
-                .finish()
-        }
-    }
-
-    struct OverlappedReadFromInto {
-        // A (number of bytes read, (host, port)) tuple
-        result: PyObjectRef,
-        /* Buffer passed by the user */
-        user_buffer: PyBuffer,
-        #[allow(dead_code)]
-        address: SOCKADDR_IN6, // TODO: remove when done
-        address_length: libc::c_int,
-    }
-
-    impl std::fmt::Debug for OverlappedReadFromInto {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            f.debug_struct("OverlappedReadFromInto")
-                .field("result", &self.result)
-                .field("user_buffer", &self.user_buffer)
-                // .field("address", &self.address)
-                .field("address_length", &self.address_length)
-                .finish()
-        }
-    }
-
-    fn mark_as_completed(ov: &mut OVERLAPPED) {
-        ov.Internal = 0;
-        if !ov.hEvent.is_null() {
-            unsafe { windows_sys::Win32::System::Threading::SetEvent(ov.hEvent) };
-        }
-    }
-
-    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),
-        };
-        // TODO: set errno and winerror
-        vm.new_exception_empty(exc.to_owned())
-    }
-
-    fn HasOverlappedIoCompleted(overlapped: &OVERLAPPED) -> bool {
-        overlapped.Internal != (Foundation::STATUS_PENDING as usize)
-    }
-
-    #[pyclass(with(Constructor))]
-    impl Overlapped {
-        #[pygetset]
-        fn address(&self, _vm: &VirtualMachine) -> usize {
-            let inner = self.inner.lock();
-            &inner.overlapped as *const _ as usize
-        }
-
-        #[pygetset]
-        fn pending(&self, _vm: &VirtualMachine) -> bool {
-            let inner = self.inner.lock();
-            !HasOverlappedIoCompleted(&inner.overlapped)
-                && !matches!(inner.data, OverlappedData::NotStarted)
-        }
-
-        fn WSARecv_inner(
-            inner: &mut OverlappedInner,
-            handle: isize,
-            buf: &[u8],
-            mut flags: u32,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            use windows_sys::Win32::Foundation::{
-                ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_SUCCESS,
-            };
-
-            let wsabuf = windows_sys::Win32::Networking::WinSock::WSABUF {
-                buf: buf.as_ptr() as *mut _,
-                len: buf.len() as _,
-            };
-            let mut n_read: u32 = 0;
-            // TODO: optimization with MaybeUninit
-            let ret = unsafe {
-                windows_sys::Win32::Networking::WinSock::WSARecv(
-                    handle as _,
-                    &wsabuf,
-                    1,
-                    &mut n_read,
-                    &mut flags,
-                    &mut inner.overlapped,
-                    None,
-                )
-            };
-            let err = if ret < 0 {
-                unsafe { windows_sys::Win32::Networking::WinSock::WSAGetLastError() as u32 }
-            } else {
-                Foundation::ERROR_SUCCESS
-            };
-            inner.error = err;
-            match err {
-                ERROR_BROKEN_PIPE => {
-                    mark_as_completed(&mut inner.overlapped);
-                    Err(from_windows_err(err, vm))
-                }
-                ERROR_SUCCESS | ERROR_MORE_DATA | ERROR_IO_PENDING => Ok(vm.ctx.none()),
-                _ => Err(from_windows_err(err, vm)),
-            }
-        }
-
-        #[pymethod]
-        fn WSARecv(
-            zelf: &Py<Self>,
-            handle: isize,
-            size: u32,
-            flags: u32,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            let mut inner = zelf.inner.lock();
-            if !matches!(inner.data, OverlappedData::None) {
-                return Err(vm.new_value_error("operation already attempted"));
-            }
-
-            #[cfg(target_pointer_width = "32")]
-            let size = std::cmp::min(size, std::isize::MAX as _);
-
-            let buf = vec![0u8; std::cmp::max(size, 1) as usize];
-            let buf = vm.ctx.new_bytes(buf);
-            inner.handle = handle as _;
-
-            let r = Self::WSARecv_inner(&mut inner, handle as _, buf.as_bytes(), flags, vm);
-            inner.data = OverlappedData::Read(buf);
-            r
-        }
-
-        #[pymethod]
-        fn cancel(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<()> {
-            let inner = zelf.inner.lock();
-            if matches!(
-                inner.data,
-                OverlappedData::NotStarted | OverlappedData::WaitNamedPipeAndConnect
-            ) {
-                return Ok(());
-            }
-            let ret = if !HasOverlappedIoCompleted(&inner.overlapped) {
-                unsafe {
-                    windows_sys::Win32::System::IO::CancelIoEx(inner.handle, &inner.overlapped)
-                }
-            } else {
-                1
-            };
-            // CancelIoEx returns ERROR_NOT_FOUND if the I/O completed in-between
-            if ret == 0 && unsafe { GetLastError() } != Foundation::ERROR_NOT_FOUND {
-                return Err(errno_err(vm));
-            }
-            Ok(())
-        }
-    }
-
-    impl Constructor for Overlapped {
-        type Args = (isize,);
-
-        fn py_new(cls: PyTypeRef, (mut event,): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if event == INVALID_HANDLE_VALUE {
-                event = unsafe {
-                    windows_sys::Win32::System::Threading::CreateEventA(
-                        std::ptr::null(),
-                        Foundation::TRUE,
-                        Foundation::FALSE,
-                        std::ptr::null(),
-                    ) as isize
-                };
-                if event == NULL {
-                    return Err(errno_err(vm));
-                }
-            }
-
-            let mut overlapped: OVERLAPPED = unsafe { std::mem::zeroed() };
-            if event != NULL {
-                overlapped.hEvent = event as _;
-            }
-            let inner = OverlappedInner {
-                overlapped,
-                handle: NULL as _,
-                error: 0,
-                data: OverlappedData::None,
-            };
-            let overlapped = Overlapped {
-                inner: PyMutex::new(inner),
-            };
-            overlapped.into_ref_with_type(vm, cls).map(Into::into)
-        }
-    }
-
-    unsafe fn u64_to_handle(raw_ptr_value: u64) -> HANDLE {
-        raw_ptr_value as HANDLE
-    }
-
-    #[pyfunction]
-    fn CreateIoCompletionPort(
-        handle: isize,
-        port: isize,
-        key: usize,
-        concurrency: u32,
-        vm: &VirtualMachine,
-    ) -> PyResult<isize> {
-        let r = unsafe {
-            windows_sys::Win32::System::IO::CreateIoCompletionPort(
-                handle as _,
-                port as _,
-                key,
-                concurrency,
-            ) as isize
-        };
-        if r as usize == 0 {
-            return Err(errno_err(vm));
-        }
-        Ok(r)
-    }
-
-    #[pyfunction]
-    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 ret = unsafe {
-            windows_sys::Win32::System::IO::GetQueuedCompletionStatus(
-                port as _,
-                &mut bytes_transferred,
-                &mut completion_key,
-                &mut overlapped,
-                msecs,
-            )
-        };
-        let err = if ret != 0 {
-            Foundation::ERROR_SUCCESS
-        } else {
-            unsafe { Foundation::GetLastError() }
-        };
-        if overlapped.is_null() {
-            if err == Foundation::WAIT_TIMEOUT {
-                return Ok(vm.ctx.none());
-            } else {
-                return Err(errno_err(vm));
-            }
-        }
-
-        let value = vm.ctx.new_tuple(vec![
-            err.to_pyobject(vm),
-            completion_key.to_pyobject(vm),
-            bytes_transferred.to_pyobject(vm),
-            (overlapped as usize).to_pyobject(vm),
-        ]);
-        Ok(value.into())
-    }
-
-    #[pyfunction]
-    fn CreateEvent(
-        event_attributes: PyObjectRef,
-        manual_reset: bool,
-        initial_state: bool,
-        name: Option<String>,
-        vm: &VirtualMachine,
-    ) -> PyResult<isize> {
-        if !vm.is_none(&event_attributes) {
-            return Err(vm.new_value_error("EventAttributes must be None"));
-        }
-
-        let name = match name {
-            Some(name) => {
-                let name = widestring::WideCString::from_str(&name).unwrap();
-                name.as_ptr()
-            }
-            None => std::ptr::null(),
-        };
-        let event = unsafe {
-            windows_sys::Win32::System::Threading::CreateEventW(
-                std::ptr::null(),
-                manual_reset as _,
-                initial_state as _,
-                name,
-            ) as isize
-        };
-        if event == NULL {
-            return Err(errno_err(vm));
-        }
-        Ok(event)
-    }
-
-    #[pyfunction]
-    fn SetEvent(handle: u64, vm: &VirtualMachine) -> PyResult<()> {
-        let ret = unsafe { windows_sys::Win32::System::Threading::SetEvent(u64_to_handle(handle)) };
-        if ret == 0 {
-            return Err(errno_err(vm));
-        }
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn ResetEvent(handle: u64, vm: &VirtualMachine) -> PyResult<()> {
-        let ret =
-            unsafe { windows_sys::Win32::System::Threading::ResetEvent(u64_to_handle(handle)) };
-        if ret == 0 {
-            return Err(errno_err(vm));
-        }
-        Ok(())
-    }
-}
diff --git a/stdlib/src/posixsubprocess.rs b/stdlib/src/posixsubprocess.rs
deleted file mode 100644
index 744024e21f..0000000000
--- a/stdlib/src/posixsubprocess.rs
+++ /dev/null
@@ -1,416 +0,0 @@
-// spell-checker:disable
-
-use crate::vm::{
-    builtins::PyListRef,
-    function::ArgSequence,
-    ospath::OsPath,
-    stdlib::posix,
-    {PyObjectRef, PyResult, TryFromObject, VirtualMachine},
-};
-use itertools::Itertools;
-use nix::{
-    errno::Errno,
-    unistd::{self, Pid},
-};
-use std::{
-    convert::Infallible as Never,
-    ffi::{CStr, CString},
-    io::prelude::*,
-    marker::PhantomData,
-    ops::Deref,
-    os::fd::FromRawFd,
-};
-use std::{fs::File, os::unix::io::AsRawFd};
-use unistd::{Gid, Uid};
-
-pub(crate) use _posixsubprocess::make_module;
-
-#[pymodule]
-mod _posixsubprocess {
-    use rustpython_vm::{AsObject, TryFromBorrowedObject};
-
-    use super::*;
-    use crate::vm::{PyResult, VirtualMachine, convert::IntoPyException};
-
-    #[pyfunction]
-    fn fork_exec(args: ForkExecArgs, vm: &VirtualMachine) -> PyResult<libc::pid_t> {
-        if args.preexec_fn.is_some() {
-            return Err(vm.new_not_implemented_error("preexec_fn not supported yet"));
-        }
-        let extra_groups = args
-            .groups_list
-            .as_ref()
-            .map(|l| Vec::<Gid>::try_from_borrowed_object(vm, l.as_object()))
-            .transpose()?;
-        let argv = CharPtrVec::from_iter(args.args.iter());
-        let envp = args.env_list.as_ref().map(CharPtrVec::from_iter);
-        let procargs = ProcArgs {
-            argv: &argv,
-            envp: envp.as_deref(),
-            extra_groups: extra_groups.as_deref(),
-        };
-        match unsafe { nix::unistd::fork() }.map_err(|err| err.into_pyexception(vm))? {
-            nix::unistd::ForkResult::Child => exec(&args, procargs),
-            nix::unistd::ForkResult::Parent { child } => Ok(child.as_raw()),
-        }
-    }
-}
-
-macro_rules! gen_args {
-    ($($field:ident: $t:ty),*$(,)?) => {
-        #[derive(FromArgs)]
-        struct ForkExecArgs {
-            $(#[pyarg(positional)] $field: $t,)*
-        }
-    };
-}
-
-struct CStrPathLike {
-    s: CString,
-}
-impl TryFromObject for CStrPathLike {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let s = OsPath::try_from_object(vm, obj)?.into_cstring(vm)?;
-        Ok(Self { s })
-    }
-}
-impl AsRef<CStr> for CStrPathLike {
-    fn as_ref(&self) -> &CStr {
-        &self.s
-    }
-}
-
-#[derive(Default)]
-struct CharPtrVec<'a> {
-    vec: Vec<*const libc::c_char>,
-    marker: PhantomData<Vec<&'a CStr>>,
-}
-
-impl<'a, T: AsRef<CStr>> FromIterator<&'a T> for CharPtrVec<'a> {
-    fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Self {
-        let vec = iter
-            .into_iter()
-            .map(|x| x.as_ref().as_ptr())
-            .chain(std::iter::once(std::ptr::null()))
-            .collect();
-        Self {
-            vec,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'a> Deref for CharPtrVec<'a> {
-    type Target = CharPtrSlice<'a>;
-    fn deref(&self) -> &Self::Target {
-        unsafe {
-            &*(self.vec.as_slice() as *const [*const libc::c_char] as *const CharPtrSlice<'a>)
-        }
-    }
-}
-
-#[repr(transparent)]
-struct CharPtrSlice<'a> {
-    marker: PhantomData<[&'a CStr]>,
-    slice: [*const libc::c_char],
-}
-
-impl CharPtrSlice<'_> {
-    const fn as_ptr(&self) -> *const *const libc::c_char {
-        self.slice.as_ptr()
-    }
-}
-
-gen_args! {
-    args: ArgSequence<CStrPathLike> /* list */,
-    exec_list: ArgSequence<CStrPathLike> /* list */,
-    close_fds: bool,
-    fds_to_keep: ArgSequence<i32>,
-    cwd: Option<CStrPathLike>,
-    env_list: Option<ArgSequence<CStrPathLike>>,
-    p2cread: i32,
-    p2cwrite: i32,
-    c2pread: i32,
-    c2pwrite: i32,
-    errread: i32,
-    errwrite: i32,
-    errpipe_read: i32,
-    errpipe_write: i32,
-    restore_signals: bool,
-    call_setsid: bool,
-    pgid_to_set: libc::pid_t,
-    gid: Option<Gid>,
-    groups_list: Option<PyListRef>,
-    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
-struct ProcArgs<'a> {
-    argv: &'a CharPtrSlice<'a>,
-    envp: Option<&'a CharPtrSlice<'a>>,
-    extra_groups: Option<&'a [Gid]>,
-}
-
-fn exec(args: &ForkExecArgs, procargs: ProcArgs<'_>) -> ! {
-    let mut ctx = ExecErrorContext::NoExec;
-    match exec_inner(args, procargs, &mut ctx) {
-        Ok(x) => match x {},
-        Err(e) => {
-            let mut pipe =
-                std::mem::ManuallyDrop::new(unsafe { File::from_raw_fd(args.errpipe_write) });
-            let _ = write!(pipe, "OSError:{}:{}", e as i32, ctx.as_msg());
-            std::process::exit(255)
-        }
-    }
-}
-
-enum ExecErrorContext {
-    NoExec,
-    ChDir,
-    Exec,
-}
-
-impl ExecErrorContext {
-    const fn as_msg(&self) -> &'static str {
-        match self {
-            Self::NoExec => "noexec",
-            Self::ChDir => "noexec:chdir",
-            Self::Exec => "",
-        }
-    }
-}
-
-fn exec_inner(
-    args: &ForkExecArgs,
-    procargs: ProcArgs<'_>,
-    ctx: &mut ExecErrorContext,
-) -> nix::Result<Never> {
-    for &fd in args.fds_to_keep.as_slice() {
-        if fd != args.errpipe_write {
-            posix::raw_set_inheritable(fd, true)?
-        }
-    }
-
-    for &fd in &[args.p2cwrite, args.c2pread, args.errread] {
-        if fd != -1 {
-            unistd::close(fd)?;
-        }
-    }
-    unistd::close(args.errpipe_read)?;
-
-    let c2pwrite = if args.c2pwrite == 0 {
-        let fd = unistd::dup(args.c2pwrite)?;
-        posix::raw_set_inheritable(fd, true)?;
-        fd
-    } else {
-        args.c2pwrite
-    };
-
-    let mut errwrite = args.errwrite;
-    while errwrite == 0 || errwrite == 1 {
-        errwrite = unistd::dup(errwrite)?;
-        posix::raw_set_inheritable(errwrite, true)?;
-    }
-
-    let dup_into_stdio = |fd, io_fd| {
-        if fd == io_fd {
-            posix::raw_set_inheritable(fd, true)
-        } else if fd != -1 {
-            unistd::dup2(fd, io_fd).map(drop)
-        } else {
-            Ok(())
-        }
-    };
-    dup_into_stdio(args.p2cread, 0)?;
-    dup_into_stdio(c2pwrite, 1)?;
-    dup_into_stdio(errwrite, 2)?;
-
-    if let Some(ref cwd) = args.cwd {
-        unistd::chdir(cwd.s.as_c_str()).inspect_err(|_| *ctx = ExecErrorContext::ChDir)?
-    }
-
-    if args.child_umask >= 0 {
-        // TODO: umask(child_umask);
-    }
-
-    if args.restore_signals {
-        // TODO: restore signals SIGPIPE, SIGXFZ, SIGXFSZ to SIG_DFL
-    }
-
-    if args.call_setsid {
-        unistd::setsid()?;
-    }
-
-    if args.pgid_to_set > -1 {
-        unistd::setpgid(Pid::from_raw(0), Pid::from_raw(args.pgid_to_set))?;
-    }
-
-    if let Some(_groups) = procargs.extra_groups {
-        #[cfg(not(any(target_os = "ios", target_os = "macos", target_os = "redox")))]
-        unistd::setgroups(_groups)?;
-    }
-
-    if let Some(gid) = args.gid.filter(|x| x.as_raw() != u32::MAX) {
-        let ret = unsafe { libc::setregid(gid.as_raw(), gid.as_raw()) };
-        nix::Error::result(ret)?;
-    }
-
-    if let Some(uid) = args.uid.filter(|x| x.as_raw() != u32::MAX) {
-        let ret = unsafe { libc::setreuid(uid.as_raw(), uid.as_raw()) };
-        nix::Error::result(ret)?;
-    }
-
-    *ctx = ExecErrorContext::Exec;
-
-    if args.close_fds {
-        close_fds(KeepFds {
-            above: 2,
-            keep: &args.fds_to_keep,
-        });
-    }
-
-    let mut first_err = None;
-    for exec in args.exec_list.as_slice() {
-        // not using nix's versions of these functions because those allocate the char-ptr array,
-        // and we can't allocate
-        if let Some(envp) = procargs.envp {
-            unsafe { libc::execve(exec.s.as_ptr(), procargs.argv.as_ptr(), envp.as_ptr()) };
-        } else {
-            unsafe { libc::execv(exec.s.as_ptr(), procargs.argv.as_ptr()) };
-        }
-        let e = Errno::last();
-        if e != Errno::ENOENT && e != Errno::ENOTDIR && first_err.is_none() {
-            first_err = Some(e)
-        }
-    }
-    Err(first_err.unwrap_or_else(Errno::last))
-}
-
-#[derive(Copy, Clone)]
-struct KeepFds<'a> {
-    above: i32,
-    keep: &'a [i32],
-}
-
-impl KeepFds<'_> {
-    fn should_keep(self, fd: i32) -> bool {
-        fd > self.above && self.keep.binary_search(&fd).is_err()
-    }
-}
-
-fn close_fds(keep: KeepFds<'_>) {
-    #[cfg(not(target_os = "redox"))]
-    if close_dir_fds(keep).is_ok() {
-        return;
-    }
-    #[cfg(target_os = "redox")]
-    if close_filetable_fds(keep).is_ok() {
-        return;
-    }
-    close_fds_brute_force(keep)
-}
-
-#[cfg(not(target_os = "redox"))]
-fn close_dir_fds(keep: KeepFds<'_>) -> nix::Result<()> {
-    use nix::{dir::Dir, fcntl::OFlag};
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-    ))]
-    let fd_dir_name = c"/dev/fd";
-
-    #[cfg(any(target_os = "linux", target_os = "android"))]
-    let fd_dir_name = c"/proc/self/fd";
-
-    let mut dir = Dir::open(
-        fd_dir_name,
-        OFlag::O_RDONLY | OFlag::O_DIRECTORY,
-        nix::sys::stat::Mode::empty(),
-    )?;
-    let dirfd = dir.as_raw_fd();
-    'outer: for e in dir.iter() {
-        let e = e?;
-        let mut parser = IntParser::default();
-        for &c in e.file_name().to_bytes() {
-            if parser.feed(c).is_err() {
-                continue 'outer;
-            }
-        }
-        let fd = parser.num;
-        if fd != dirfd && keep.should_keep(fd) {
-            let _ = unistd::close(fd);
-        }
-    }
-    Ok(())
-}
-
-#[cfg(target_os = "redox")]
-fn close_filetable_fds(keep: KeepFds<'_>) -> nix::Result<()> {
-    use nix::fcntl;
-    use std::os::fd::{FromRawFd, OwnedFd};
-    let fd = fcntl::open(
-        c"/scheme/thisproc/current/filetable",
-        fcntl::OFlag::O_RDONLY,
-        nix::sys::stat::Mode::empty(),
-    )?;
-    let filetable = unsafe { OwnedFd::from_raw_fd(fd) };
-    let read_one = || -> nix::Result<_> {
-        let mut byte = 0;
-        let n = nix::unistd::read(filetable.as_raw_fd(), std::slice::from_mut(&mut byte))?;
-        Ok((n > 0).then_some(byte))
-    };
-    while let Some(c) = read_one()? {
-        let mut parser = IntParser::default();
-        if parser.feed(c).is_err() {
-            continue;
-        }
-        let done = loop {
-            let Some(c) = read_one()? else { break true };
-            if parser.feed(c).is_err() {
-                break false;
-            }
-        };
-
-        let fd = parser.num as i32;
-        if fd != filetable.as_raw_fd() && keep.should_keep(fd) {
-            let _ = unistd::close(fd);
-        }
-        if done {
-            break;
-        }
-    }
-    Ok(())
-}
-
-fn close_fds_brute_force(keep: KeepFds<'_>) {
-    let max_fd = nix::unistd::sysconf(nix::unistd::SysconfVar::OPEN_MAX)
-        .ok()
-        .flatten()
-        .unwrap_or(256) as i32;
-    let fds = itertools::chain![Some(keep.above), keep.keep.iter().copied(), Some(max_fd)];
-    for fd in fds.tuple_windows().flat_map(|(start, end)| start + 1..end) {
-        let _ = unistd::close(fd);
-    }
-}
-
-#[derive(Default)]
-struct IntParser {
-    num: i32,
-}
-
-struct NonDigit;
-impl IntParser {
-    fn feed(&mut self, c: u8) -> Result<(), NonDigit> {
-        let digit = (c as char).to_digit(10).ok_or(NonDigit)?;
-        self.num *= 10;
-        self.num += digit as i32;
-        Ok(())
-    }
-}
diff --git a/stdlib/src/pyexpat.rs b/stdlib/src/pyexpat.rs
deleted file mode 100644
index 033fa76c06..0000000000
--- a/stdlib/src/pyexpat.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-/* Pyexpat builtin module
-*
-*
-*/
-
-use crate::vm::{PyRef, VirtualMachine, builtins::PyModule, extend_module};
-
-pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = _pyexpat::make_module(vm);
-
-    extend_module!(vm, &module, {
-         "errors" => _errors::make_module(vm),
-         "model" => _model::make_module(vm),
-    });
-
-    module
-}
-
-macro_rules! create_property {
-    ($ctx: expr, $attributes: expr, $name: expr, $class: expr, $element: ident) => {
-        let attr = $ctx.new_static_getset(
-            $name,
-            $class,
-            move |this: &PyExpatLikeXmlParser| this.$element.read().clone(),
-            move |this: &PyExpatLikeXmlParser, func: PyObjectRef| *this.$element.write() = func,
-        );
-
-        $attributes.insert($ctx.intern_str($name), attr.into());
-    };
-}
-
-#[pymodule(name = "pyexpat")]
-mod _pyexpat {
-    use crate::vm::{
-        Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyStr, PyStrRef, PyType},
-        function::ArgBytesLike,
-        function::{IntoFuncArgs, OptionalArg},
-    };
-    use rustpython_common::lock::PyRwLock;
-    use std::io::Cursor;
-    use xml::reader::XmlEvent;
-    type MutableObject = PyRwLock<PyObjectRef>;
-
-    #[pyattr]
-    #[pyclass(name = "xmlparser", module = false, traverse)]
-    #[derive(Debug, PyPayload)]
-    pub struct PyExpatLikeXmlParser {
-        start_element: MutableObject,
-        end_element: MutableObject,
-        character_data: MutableObject,
-        entity_decl: MutableObject,
-        buffer_text: MutableObject,
-    }
-    type PyExpatLikeXmlParserRef = PyRef<PyExpatLikeXmlParser>;
-
-    #[inline]
-    fn invoke_handler<T>(vm: &VirtualMachine, handler: &MutableObject, args: T)
-    where
-        T: IntoFuncArgs,
-    {
-        handler.read().call(args, vm).ok();
-    }
-
-    #[pyclass]
-    impl PyExpatLikeXmlParser {
-        fn new(vm: &VirtualMachine) -> PyResult<PyExpatLikeXmlParserRef> {
-            Ok(Self {
-                start_element: MutableObject::new(vm.ctx.none()),
-                end_element: MutableObject::new(vm.ctx.none()),
-                character_data: MutableObject::new(vm.ctx.none()),
-                entity_decl: MutableObject::new(vm.ctx.none()),
-                buffer_text: MutableObject::new(vm.ctx.new_bool(false).into()),
-            }
-            .into_ref(&vm.ctx))
-        }
-
-        #[extend_class]
-        fn extend_class_with_fields(ctx: &Context, class: &'static Py<PyType>) {
-            let mut attributes = class.attributes.write();
-
-            create_property!(ctx, attributes, "StartElementHandler", class, start_element);
-            create_property!(ctx, attributes, "EndElementHandler", class, end_element);
-            create_property!(
-                ctx,
-                attributes,
-                "CharacterDataHandler",
-                class,
-                character_data
-            );
-            create_property!(ctx, attributes, "EntityDeclHandler", class, entity_decl);
-            create_property!(ctx, attributes, "buffer_text", class, buffer_text);
-        }
-
-        fn create_config(&self) -> xml::ParserConfig {
-            xml::ParserConfig::new()
-                .cdata_to_characters(true)
-                .coalesce_characters(false)
-                .whitespace_to_characters(true)
-        }
-
-        fn do_parse<T>(&self, vm: &VirtualMachine, parser: xml::EventReader<T>)
-        where
-            T: std::io::Read,
-        {
-            for e in parser {
-                match e {
-                    Ok(XmlEvent::StartElement {
-                        name, attributes, ..
-                    }) => {
-                        let dict = vm.ctx.new_dict();
-                        for attribute in attributes {
-                            dict.set_item(
-                                attribute.name.local_name.as_str(),
-                                vm.ctx.new_str(attribute.value).into(),
-                                vm,
-                            )
-                            .unwrap();
-                        }
-
-                        let name_str = PyStr::from(name.local_name).into_ref(&vm.ctx);
-                        invoke_handler(vm, &self.start_element, (name_str, dict));
-                    }
-                    Ok(XmlEvent::EndElement { name, .. }) => {
-                        let name_str = PyStr::from(name.local_name).into_ref(&vm.ctx);
-                        invoke_handler(vm, &self.end_element, (name_str,));
-                    }
-                    Ok(XmlEvent::Characters(chars)) => {
-                        let str = PyStr::from(chars).into_ref(&vm.ctx);
-                        invoke_handler(vm, &self.character_data, (str,));
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        #[pymethod(name = "Parse")]
-        fn parse(&self, data: PyStrRef, _isfinal: OptionalArg<bool>, vm: &VirtualMachine) {
-            let reader = Cursor::<Vec<u8>>::new(data.as_bytes().to_vec());
-            let parser = self.create_config().create_reader(reader);
-            self.do_parse(vm, parser);
-        }
-
-        #[pymethod(name = "ParseFile")]
-        fn parse_file(&self, file: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            // todo: read chunks at a time
-            let read_res = vm.call_method(&file, "read", ())?;
-            let bytes_like = ArgBytesLike::try_from_object(vm, read_res)?;
-            let buf = bytes_like.borrow_buf().to_vec();
-            let reader = Cursor::new(buf);
-            let parser = self.create_config().create_reader(reader);
-            self.do_parse(vm, parser);
-
-            // todo: return value
-            Ok(())
-        }
-    }
-
-    #[derive(FromArgs)]
-    #[allow(dead_code)]
-    struct ParserCreateArgs {
-        #[pyarg(any, optional)]
-        encoding: OptionalArg<PyStrRef>,
-        #[pyarg(any, optional)]
-        namespace_separator: OptionalArg<PyStrRef>,
-        #[pyarg(any, optional)]
-        intern: OptionalArg<PyStrRef>,
-    }
-
-    #[pyfunction(name = "ParserCreate")]
-    fn parser_create(
-        _args: ParserCreateArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyExpatLikeXmlParserRef> {
-        PyExpatLikeXmlParser::new(vm)
-    }
-}
-
-#[pymodule(name = "model")]
-mod _model {}
-
-#[pymodule(name = "errors")]
-mod _errors {}
diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs
deleted file mode 100644
index 50ee2b96fc..0000000000
--- a/stdlib/src/socket.rs
+++ /dev/null
@@ -1,2531 +0,0 @@
-// spell-checker:disable
-
-use crate::vm::{PyRef, VirtualMachine, builtins::PyModule};
-#[cfg(feature = "ssl")]
-pub(super) use _socket::{PySocket, SelectKind, sock_select, timeout_error_msg};
-
-pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    #[cfg(windows)]
-    crate::vm::windows::init_winsock();
-    _socket::make_module(vm)
-}
-
-#[pymodule]
-mod _socket {
-    use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};
-    use crate::vm::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyBaseExceptionRef, PyListRef, PyStrRef, PyTupleRef, PyTypeRef},
-        common::os::ErrorExt,
-        convert::{IntoPyException, ToPyObject, TryFromBorrowedObject, TryFromObject},
-        function::{ArgBytesLike, ArgMemoryBuffer, Either, FsPath, OptionalArg, OptionalOption},
-        types::{Constructor, DefaultConstructor, Initializer, Representable},
-        utils::ToCString,
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use num_traits::ToPrimitive;
-    use socket2::Socket;
-    use std::{
-        ffi,
-        io::{self, Read, Write},
-        mem::MaybeUninit,
-        net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs},
-        time::{Duration, Instant},
-    };
-
-    #[cfg(unix)]
-    use libc as c;
-    #[cfg(windows)]
-    mod c {
-        pub use windows_sys::Win32::NetworkManagement::IpHelper::{if_indextoname, if_nametoindex};
-        pub use windows_sys::Win32::Networking::WinSock::{
-            INADDR_ANY, INADDR_BROADCAST, INADDR_LOOPBACK, INADDR_NONE,
-        };
-
-        pub use windows_sys::Win32::Networking::WinSock::{
-            AF_APPLETALK, AF_DECnet, AF_IPX, AF_LINK, AI_ADDRCONFIG, AI_ALL, AI_CANONNAME,
-            AI_NUMERICSERV, AI_V4MAPPED, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_HDRINCL,
-            IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_OPTIONS, IP_RECVDSTADDR,
-            IP_TOS, IP_TTL, IPPORT_RESERVED, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP,
-            IPPROTO_FRAGMENT, IPPROTO_GGP, IPPROTO_HOPOPTS, IPPROTO_ICMP, IPPROTO_ICMPV6,
-            IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IP, IPPROTO_IP as IPPROTO_IPIP, IPPROTO_IPV4,
-            IPPROTO_IPV6, IPPROTO_ND, IPPROTO_NONE, IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW,
-            IPPROTO_ROUTING, IPPROTO_TCP, IPPROTO_UDP, IPV6_CHECKSUM, IPV6_DONTFRAG, IPV6_HOPLIMIT,
-            IPV6_HOPOPTS, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, IPV6_MULTICAST_HOPS,
-            IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP, IPV6_PKTINFO, IPV6_RECVRTHDR, IPV6_RECVTCLASS,
-            IPV6_RTHDR, IPV6_TCLASS, IPV6_UNICAST_HOPS, IPV6_V6ONLY, MSG_BCAST, MSG_CTRUNC,
-            MSG_DONTROUTE, MSG_MCAST, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM,
-            NI_MAXHOST, NI_MAXSERV, NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV,
-            RCVALL_IPLEVEL, RCVALL_OFF, RCVALL_ON, RCVALL_SOCKETLEVELONLY, SD_BOTH as SHUT_RDWR,
-            SD_RECEIVE as SHUT_RD, SD_SEND as SHUT_WR, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH,
-            SIO_RCVALL, SO_BROADCAST, SO_ERROR, SO_LINGER, SO_OOBINLINE, SO_REUSEADDR, SO_TYPE,
-            SO_USELOOPBACK, SOCK_DGRAM, SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_STREAM,
-            SOL_SOCKET, SOMAXCONN, TCP_NODELAY, WSAEBADF, WSAECONNRESET, WSAENOTSOCK,
-            WSAEWOULDBLOCK,
-        };
-        pub use windows_sys::Win32::Networking::WinSock::{
-            SO_REUSEADDR as SO_EXCLUSIVEADDRUSE, getprotobyname, getservbyname, getservbyport,
-            getsockopt, setsockopt,
-        };
-        pub use windows_sys::Win32::Networking::WinSock::{
-            WSA_NOT_ENOUGH_MEMORY as EAI_MEMORY, WSAEAFNOSUPPORT as EAI_FAMILY,
-            WSAEINVAL as EAI_BADFLAGS, WSAESOCKTNOSUPPORT as EAI_SOCKTYPE,
-            WSAHOST_NOT_FOUND as EAI_NODATA, WSAHOST_NOT_FOUND as EAI_NONAME,
-            WSANO_RECOVERY as EAI_FAIL, WSATRY_AGAIN as EAI_AGAIN,
-            WSATYPE_NOT_FOUND as EAI_SERVICE,
-        };
-        pub const IF_NAMESIZE: usize =
-            windows_sys::Win32::NetworkManagement::Ndis::IF_MAX_STRING_SIZE as _;
-        pub const AF_UNSPEC: i32 = windows_sys::Win32::Networking::WinSock::AF_UNSPEC as _;
-        pub const AF_INET: i32 = windows_sys::Win32::Networking::WinSock::AF_INET as _;
-        pub const AF_INET6: i32 = windows_sys::Win32::Networking::WinSock::AF_INET6 as _;
-        pub const AI_PASSIVE: i32 = windows_sys::Win32::Networking::WinSock::AI_PASSIVE as _;
-        pub const AI_NUMERICHOST: i32 =
-            windows_sys::Win32::Networking::WinSock::AI_NUMERICHOST as _;
-    }
-    // constants
-    #[pyattr(name = "has_ipv6")]
-    const HAS_IPV6: bool = true;
-    #[pyattr]
-    // put IPPROTO_MAX later
-    use c::{
-        AF_INET, AF_INET6, AF_UNSPEC, INADDR_ANY, INADDR_LOOPBACK, INADDR_NONE, IPPROTO_ICMP,
-        IPPROTO_ICMPV6, IPPROTO_IP, IPPROTO_IPV6, IPPROTO_TCP, IPPROTO_TCP as SOL_TCP, IPPROTO_UDP,
-        MSG_CTRUNC, MSG_DONTROUTE, MSG_OOB, MSG_PEEK, MSG_TRUNC, MSG_WAITALL, NI_DGRAM, NI_MAXHOST,
-        NI_NAMEREQD, NI_NOFQDN, NI_NUMERICHOST, NI_NUMERICSERV, SHUT_RD, SHUT_RDWR, SHUT_WR,
-        SO_BROADCAST, SO_ERROR, SO_LINGER, SO_OOBINLINE, SO_REUSEADDR, SO_TYPE, SOCK_DGRAM,
-        SOCK_STREAM, SOL_SOCKET, TCP_NODELAY,
-    };
-
-    #[cfg(not(target_os = "redox"))]
-    #[pyattr]
-    use c::{
-        AF_APPLETALK, AF_DECnet, AF_IPX, IPPROTO_AH, IPPROTO_DSTOPTS, IPPROTO_EGP, IPPROTO_ESP,
-        IPPROTO_FRAGMENT, IPPROTO_HOPOPTS, IPPROTO_IDP, IPPROTO_IGMP, IPPROTO_IPIP, IPPROTO_NONE,
-        IPPROTO_PIM, IPPROTO_PUP, IPPROTO_RAW, IPPROTO_ROUTING,
-    };
-
-    #[cfg(unix)]
-    #[pyattr]
-    use c::{AF_UNIX, SO_REUSEPORT};
-
-    #[pyattr]
-    use c::{AI_ADDRCONFIG, AI_NUMERICHOST, AI_NUMERICSERV, AI_PASSIVE};
-
-    #[cfg(not(target_os = "redox"))]
-    #[pyattr]
-    use c::{SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET};
-
-    #[cfg(target_os = "android")]
-    #[pyattr]
-    use c::{SOL_ATALK, SOL_AX25, SOL_IPX, SOL_NETROM, SOL_ROSE};
-
-    #[cfg(target_os = "freebsd")]
-    #[pyattr]
-    use c::SO_SETFIB;
-
-    #[cfg(target_os = "linux")]
-    #[pyattr]
-    use c::{
-        CAN_BCM, CAN_EFF_FLAG, CAN_EFF_MASK, CAN_ERR_FLAG, CAN_ERR_MASK, CAN_ISOTP, CAN_J1939,
-        CAN_RAW, CAN_RAW_ERR_FILTER, CAN_RAW_FD_FRAMES, CAN_RAW_FILTER, CAN_RAW_JOIN_FILTERS,
-        CAN_RAW_LOOPBACK, CAN_RAW_RECV_OWN_MSGS, CAN_RTR_FLAG, CAN_SFF_MASK, IPPROTO_MPTCP,
-        J1939_IDLE_ADDR, J1939_MAX_UNICAST_ADDR, J1939_NLA_BYTES_ACKED, J1939_NLA_PAD,
-        J1939_NO_ADDR, J1939_NO_NAME, J1939_NO_PGN, J1939_PGN_ADDRESS_CLAIMED,
-        J1939_PGN_ADDRESS_COMMANDED, J1939_PGN_MAX, J1939_PGN_PDU1_MAX, J1939_PGN_REQUEST,
-        SCM_J1939_DEST_ADDR, SCM_J1939_DEST_NAME, SCM_J1939_ERRQUEUE, SCM_J1939_PRIO,
-        SO_J1939_ERRQUEUE, SO_J1939_FILTER, SO_J1939_PROMISC, SO_J1939_SEND_PRIO, SOL_CAN_BASE,
-        SOL_CAN_RAW,
-    };
-
-    #[cfg(all(target_os = "linux", target_env = "gnu"))]
-    #[pyattr]
-    use c::SOL_RDS;
-
-    #[cfg(target_os = "netbsd")]
-    #[pyattr]
-    use c::IPPROTO_VRRP;
-
-    #[cfg(target_vendor = "apple")]
-    #[pyattr]
-    use c::{AF_SYSTEM, PF_SYSTEM, SYSPROTO_CONTROL, TCP_KEEPALIVE};
-
-    #[cfg(windows)]
-    #[pyattr]
-    use c::{
-        IPPORT_RESERVED, IPPROTO_IPV4, RCVALL_IPLEVEL, RCVALL_OFF, RCVALL_ON,
-        RCVALL_SOCKETLEVELONLY, SIO_KEEPALIVE_VALS, SIO_LOOPBACK_FAST_PATH, SIO_RCVALL,
-        SO_EXCLUSIVEADDRUSE,
-    };
-
-    #[cfg(not(windows))]
-    #[pyattr]
-    const IPPORT_RESERVED: i32 = 1024;
-
-    #[pyattr]
-    const IPPORT_USERRESERVED: i32 = 5000;
-
-    #[cfg(any(unix, target_os = "android"))]
-    #[pyattr]
-    use c::{
-        EAI_SYSTEM, MSG_EOR, SO_ACCEPTCONN, SO_DEBUG, SO_DONTROUTE, SO_KEEPALIVE, SO_RCVBUF,
-        SO_RCVLOWAT, SO_RCVTIMEO, SO_SNDBUF, SO_SNDLOWAT, SO_SNDTIMEO,
-    };
-
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    #[pyattr]
-    use c::{
-        ALG_OP_DECRYPT, ALG_OP_ENCRYPT, ALG_SET_AEAD_ASSOCLEN, ALG_SET_AEAD_AUTHSIZE, ALG_SET_IV,
-        ALG_SET_KEY, ALG_SET_OP, IP_DEFAULT_MULTICAST_LOOP, IP_RECVOPTS, IP_RETOPTS, IPV6_DSTOPTS,
-        IPV6_NEXTHOP, IPV6_PATHMTU, IPV6_RECVDSTOPTS, IPV6_RECVHOPLIMIT, IPV6_RECVHOPOPTS,
-        IPV6_RECVPATHMTU, IPV6_RTHDRDSTOPTS, NETLINK_CRYPTO, NETLINK_DNRTMSG, NETLINK_FIREWALL,
-        NETLINK_IP6_FW, NETLINK_NFLOG, NETLINK_ROUTE, NETLINK_USERSOCK, NETLINK_XFRM, SO_PASSSEC,
-        SO_PEERSEC, SOL_ALG,
-    };
-
-    #[cfg(any(target_os = "android", target_vendor = "apple"))]
-    #[pyattr]
-    use c::{AI_DEFAULT, AI_MASK, AI_V4MAPPED_CFG};
-
-    #[cfg(any(target_os = "freebsd", target_os = "netbsd"))]
-    #[pyattr]
-    use c::MSG_NOTIFICATION;
-
-    #[cfg(any(target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    use c::TCP_USER_TIMEOUT;
-
-    #[cfg(any(unix, target_os = "android", windows))]
-    #[pyattr]
-    use c::{
-        INADDR_BROADCAST, IP_ADD_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_MULTICAST_IF,
-        IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TTL, IPV6_MULTICAST_HOPS, IPV6_MULTICAST_IF,
-        IPV6_MULTICAST_LOOP, IPV6_UNICAST_HOPS, IPV6_V6ONLY,
-    };
-
-    #[cfg(any(unix, target_os = "android", windows))]
-    #[pyattr]
-    const INADDR_UNSPEC_GROUP: u32 = 0xe0000000;
-
-    #[cfg(any(unix, target_os = "android", windows))]
-    #[pyattr]
-    const INADDR_ALLHOSTS_GROUP: u32 = 0xe0000001;
-
-    #[cfg(any(unix, target_os = "android", windows))]
-    #[pyattr]
-    const INADDR_MAX_LOCAL_GROUP: u32 = 0xe00000ff;
-
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    use c::{
-        AF_ALG, AF_ASH, AF_ATMPVC, AF_ATMSVC, AF_AX25, AF_BRIDGE, AF_CAN, AF_ECONET, AF_IRDA,
-        AF_LLC, AF_NETBEUI, AF_NETLINK, AF_NETROM, AF_PACKET, AF_PPPOX, AF_RDS, AF_SECURITY,
-        AF_TIPC, AF_VSOCK, AF_WANPIPE, AF_X25, IP_TRANSPARENT, MSG_CONFIRM, MSG_ERRQUEUE,
-        MSG_FASTOPEN, MSG_MORE, PF_CAN, PF_PACKET, PF_RDS, SCM_CREDENTIALS, SO_BINDTODEVICE,
-        SO_MARK, SOL_IP, SOL_TIPC, SOL_UDP, TCP_CORK, TCP_DEFER_ACCEPT, TCP_LINGER2, TCP_QUICKACK,
-        TCP_SYNCNT, TCP_WINDOW_CLAMP,
-    };
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const SO_VM_SOCKETS_BUFFER_SIZE: u32 = 0;
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const SO_VM_SOCKETS_BUFFER_MIN_SIZE: u32 = 1;
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const SO_VM_SOCKETS_BUFFER_MAX_SIZE: u32 = 2;
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const VMADDR_CID_ANY: u32 = 0xffffffff; // 0xffffffff
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const VMADDR_PORT_ANY: u32 = 0xffffffff; // 0xffffffff
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const VMADDR_CID_HOST: u32 = 2;
-
-    // gated on presence of AF_VSOCK:
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    #[pyattr]
-    const VM_SOCKETS_INVALID_VERSION: u32 = 0xffffffff; // 0xffffffff
-
-    // TODO: gated on https://github.com/rust-lang/libc/pull/1662
-    // // gated on presence of AF_VSOCK:
-    // #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
-    // #[pyattr(name = "IOCTL_VM_SOCKETS_GET_LOCAL_CID", once)]
-    // fn ioctl_vm_sockets_get_local_cid(_vm: &VirtualMachine) -> i32 {
-    //     c::_IO(7, 0xb9)
-    // }
-
-    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
-    #[pyattr]
-    const SOL_IP: i32 = 0;
-
-    #[cfg(not(any(target_os = "android", target_os = "fuchsia", target_os = "linux")))]
-    #[pyattr]
-    const SOL_UDP: i32 = 17;
-
-    #[cfg(any(target_os = "android", target_os = "linux", windows))]
-    #[pyattr]
-    use c::{IP_OPTIONS, IPV6_HOPOPTS, IPV6_RECVRTHDR, IPV6_RTHDR};
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::{IPPROTO_HELLO, IPPROTO_XTP, LOCAL_PEERCRED, MSG_EOF};
-
-    #[cfg(any(target_os = "netbsd", target_os = "openbsd", windows))]
-    #[pyattr]
-    use c::{MSG_BCAST, MSG_MCAST};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        target_os = "freebsd",
-        target_os = "linux"
-    ))]
-    #[pyattr]
-    use c::{IPPROTO_UDPLITE, TCP_CONGESTION};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        target_os = "freebsd",
-        target_os = "linux"
-    ))]
-    #[pyattr]
-    const UDPLITE_SEND_CSCOV: i32 = 10;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        target_os = "freebsd",
-        target_os = "linux"
-    ))]
-    #[pyattr]
-    const UDPLITE_RECV_CSCOV: i32 = 11;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    use c::AF_KEY;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::SO_DOMAIN;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "fuchsia",
-        all(
-            target_os = "linux",
-            any(
-                target_arch = "aarch64",
-                target_arch = "x86",
-                target_arch = "loongarch64",
-                target_arch = "mips",
-                target_arch = "powerpc",
-                target_arch = "powerpc64",
-                target_arch = "riscv64",
-                target_arch = "s390x",
-                target_arch = "x86_64"
-            )
-        ),
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::SO_PRIORITY;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    use c::IPPROTO_MOBILE;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::SCM_CREDS;
-
-    #[cfg(any(
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::TCP_FASTOPEN;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        all(
-            target_os = "linux",
-            any(
-                target_arch = "aarch64",
-                target_arch = "x86",
-                target_arch = "loongarch64",
-                target_arch = "mips",
-                target_arch = "powerpc",
-                target_arch = "powerpc64",
-                target_arch = "riscv64",
-                target_arch = "s390x",
-                target_arch = "x86_64"
-            )
-        ),
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::SO_PROTOCOL;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "linux",
-        windows
-    ))]
-    #[pyattr]
-    use c::IPV6_DONTFRAG;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::{SO_PASSCRED, SO_PEERCRED};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd"
-    ))]
-    #[pyattr]
-    use c::TCP_INFO;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::IP_RECVTOS;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "netbsd",
-        target_os = "redox",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::NI_MAXSERV;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::{IPPROTO_EON, IPPROTO_IPCOMP};
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::IPPROTO_ND;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "linux",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::{IPV6_CHECKSUM, IPV6_HOPLIMIT};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd"
-    ))]
-    #[pyattr]
-    use c::IPPROTO_SCTP; // also in windows
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::{AI_ALL, AI_V4MAPPED};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::EAI_NODATA;
-
-    #[cfg(any(
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::{
-        AF_LINK, IP_RECVDSTADDR, IPPROTO_GGP, IPV6_JOIN_GROUP, IPV6_LEAVE_GROUP, SO_USELOOPBACK,
-    };
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    use c::{MSG_CMSG_CLOEXEC, MSG_NOSIGNAL};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::TCP_KEEPIDLE;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::{TCP_KEEPCNT, TCP_KEEPINTVL};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_os = "redox"
-    ))]
-    #[pyattr]
-    use c::{SOCK_CLOEXEC, SOCK_NONBLOCK};
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple"
-    ))]
-    #[pyattr]
-    use c::{
-        AF_ROUTE, AF_SNA, EAI_OVERFLOW, IPPROTO_GRE, IPPROTO_RSVP, IPPROTO_TP, IPV6_RECVPKTINFO,
-        MSG_DONTWAIT, SCM_RIGHTS, TCP_MAXSEG,
-    };
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::IPV6_PKTINFO;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::AI_CANONNAME;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    ))]
-    #[pyattr]
-    use c::{
-        EAI_AGAIN, EAI_BADFLAGS, EAI_FAIL, EAI_FAMILY, EAI_MEMORY, EAI_NONAME, EAI_SERVICE,
-        EAI_SOCKTYPE, IP_HDRINCL, IP_TOS, IPV6_RECVTCLASS, IPV6_TCLASS, SOMAXCONN,
-    };
-
-    #[cfg(not(any(
-        target_os = "android",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "netbsd",
-        target_os = "openbsd",
-        target_vendor = "apple",
-        windows
-    )))]
-    #[pyattr]
-    const SOMAXCONN: i32 = 5; // Common value
-
-    // HERE IS WHERE THE BLUETOOTH CONSTANTS START
-    // TODO: there should be a more intelligent way of detecting bluetooth on a platform.
-    //       CPython uses header-detection, but blocks NetBSD and DragonFly BSD
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    use c::AF_BLUETOOTH;
-
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    const BDADDR_ANY: &str = "00:00:00:00:00:00";
-    #[cfg(any(
-        target_os = "android",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "linux",
-        target_os = "openbsd"
-    ))]
-    #[pyattr]
-    const BDADDR_LOCAL: &str = "00:00:00:FF:FF:FF";
-    // HERE IS WHERE THE BLUETOOTH CONSTANTS END
-
-    #[cfg(windows)]
-    #[pyattr]
-    use windows_sys::Win32::Networking::WinSock::{
-        IPPROTO_CBT, IPPROTO_ICLFXBM, IPPROTO_IGP, IPPROTO_L2TP, IPPROTO_PGM, IPPROTO_RDP,
-        IPPROTO_SCTP, IPPROTO_ST,
-    };
-
-    #[pyattr]
-    fn error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.exceptions.os_error.to_owned()
-    }
-
-    #[pyattr]
-    fn timeout(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.exceptions.timeout_error.to_owned()
-    }
-
-    #[pyattr(once)]
-    fn herror(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "socket",
-            "herror",
-            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
-        )
-    }
-    #[pyattr(once)]
-    fn gaierror(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "socket",
-            "gaierror",
-            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
-        )
-    }
-
-    #[pyfunction]
-    const fn htonl(x: u32) -> u32 {
-        u32::to_be(x)
-    }
-
-    #[pyfunction]
-    const fn htons(x: u16) -> u16 {
-        u16::to_be(x)
-    }
-
-    #[pyfunction]
-    const fn ntohl(x: u32) -> u32 {
-        u32::from_be(x)
-    }
-
-    #[pyfunction]
-    const fn ntohs(x: u16) -> u16 {
-        u16::from_be(x)
-    }
-
-    #[cfg(unix)]
-    type RawSocket = std::os::unix::io::RawFd;
-    #[cfg(windows)]
-    type RawSocket = std::os::windows::raw::SOCKET;
-
-    #[cfg(unix)]
-    macro_rules! errcode {
-        ($e:ident) => {
-            c::$e
-        };
-    }
-    #[cfg(windows)]
-    macro_rules! errcode {
-    ($e:ident) => {
-        paste::paste!(c::[<WSA $e>])
-    };
-}
-
-    #[cfg(windows)]
-    use windows_sys::Win32::NetworkManagement::IpHelper;
-
-    fn get_raw_sock(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<RawSocket> {
-        #[cfg(unix)]
-        type CastFrom = libc::c_long;
-        #[cfg(windows)]
-        type CastFrom = libc::c_longlong;
-
-        // should really just be to_index() but test_socket tests the error messages explicitly
-        if obj.fast_isinstance(vm.ctx.types.float_type) {
-            return Err(vm.new_type_error("integer argument expected, got float"));
-        }
-        let int = obj
-            .try_index_opt(vm)
-            .unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?;
-        int.try_to_primitive::<CastFrom>(vm)
-            .map(|sock| sock as RawSocket)
-    }
-
-    #[pyattr(name = "socket")]
-    #[pyattr(name = "SocketType")]
-    #[pyclass(name = "socket")]
-    #[derive(Debug, PyPayload)]
-    pub struct PySocket {
-        kind: AtomicCell<i32>,
-        family: AtomicCell<i32>,
-        proto: AtomicCell<i32>,
-        pub(crate) timeout: AtomicCell<f64>,
-        sock: PyRwLock<Option<Socket>>,
-    }
-
-    const _: () = assert!(std::mem::size_of::<Option<Socket>>() == std::mem::size_of::<Socket>());
-
-    impl Default for PySocket {
-        fn default() -> Self {
-            Self {
-                kind: AtomicCell::default(),
-                family: AtomicCell::default(),
-                proto: AtomicCell::default(),
-                timeout: AtomicCell::new(-1.0),
-                sock: PyRwLock::new(None),
-            }
-        }
-    }
-
-    #[cfg(windows)]
-    const CLOSED_ERR: i32 = c::WSAENOTSOCK;
-    #[cfg(unix)]
-    const CLOSED_ERR: i32 = c::EBADF;
-
-    impl Read for &PySocket {
-        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-            (&mut &*self.sock()?).read(buf)
-        }
-    }
-
-    impl Write for &PySocket {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            (&mut &*self.sock()?).write(buf)
-        }
-
-        fn flush(&mut self) -> std::io::Result<()> {
-            (&mut &*self.sock()?).flush()
-        }
-    }
-
-    impl PySocket {
-        pub fn sock_opt(&self) -> Option<PyMappedRwLockReadGuard<'_, Socket>> {
-            let sock = PyRwLockReadGuard::try_map(self.sock.read(), |sock| sock.as_ref());
-            sock.ok()
-        }
-
-        pub fn sock(&self) -> io::Result<PyMappedRwLockReadGuard<'_, Socket>> {
-            self.sock_opt()
-                .ok_or_else(|| io::Error::from_raw_os_error(CLOSED_ERR))
-        }
-
-        fn init_inner(
-            &self,
-            family: i32,
-            socket_kind: i32,
-            proto: i32,
-            sock: Socket,
-        ) -> io::Result<()> {
-            self.family.store(family);
-            self.kind.store(socket_kind);
-            self.proto.store(proto);
-            let mut s = self.sock.write();
-            let sock = s.insert(sock);
-            let timeout = DEFAULT_TIMEOUT.load();
-            self.timeout.store(timeout);
-            if timeout >= 0.0 {
-                sock.set_nonblocking(true)?;
-            }
-            Ok(())
-        }
-
-        /// returns Err(blocking)
-        pub fn get_timeout(&self) -> Result<Duration, bool> {
-            let timeout = self.timeout.load();
-            if timeout > 0.0 {
-                Ok(Duration::from_secs_f64(timeout))
-            } else {
-                Err(timeout != 0.0)
-            }
-        }
-
-        fn sock_op<F, R>(
-            &self,
-            vm: &VirtualMachine,
-            select: SelectKind,
-            f: F,
-        ) -> Result<R, IoOrPyException>
-        where
-            F: FnMut() -> io::Result<R>,
-        {
-            let timeout = self.get_timeout().ok();
-            self.sock_op_timeout_err(vm, select, timeout, f)
-        }
-
-        fn sock_op_timeout_err<F, R>(
-            &self,
-            vm: &VirtualMachine,
-            select: SelectKind,
-            timeout: Option<Duration>,
-            mut f: F,
-        ) -> Result<R, IoOrPyException>
-        where
-            F: FnMut() -> io::Result<R>,
-        {
-            let deadline = timeout.map(Deadline::new);
-
-            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);
-                    match res {
-                        Ok(true) => return Err(IoOrPyException::Timeout),
-                        Err(e) if e.kind() == io::ErrorKind::Interrupted => {
-                            vm.check_signals()?;
-                            continue;
-                        }
-                        Err(e) => return Err(e.into()),
-                        Ok(false) => {} // no timeout, continue as normal
-                    }
-                }
-
-                let err = loop {
-                    // loop on interrupt
-                    match f() {
-                        Ok(x) => return Ok(x),
-                        Err(e) if e.kind() == io::ErrorKind::Interrupted => vm.check_signals()?,
-                        Err(e) => break e,
-                    }
-                };
-                if timeout.is_some() && err.kind() == io::ErrorKind::WouldBlock {
-                    continue;
-                }
-                return Err(err.into());
-            }
-        }
-
-        fn extract_address(
-            &self,
-            addr: PyObjectRef,
-            caller: &str,
-            vm: &VirtualMachine,
-        ) -> Result<socket2::SockAddr, IoOrPyException> {
-            let family = self.family.load();
-            match family {
-                #[cfg(unix)]
-                c::AF_UNIX => {
-                    use crate::vm::function::ArgStrOrBytesLike;
-                    use std::os::unix::ffi::OsStrExt;
-                    let buf = ArgStrOrBytesLike::try_from_object(vm, addr)?;
-                    let bytes = &*buf.borrow_bytes();
-                    let path = match &buf {
-                        ArgStrOrBytesLike::Buf(_) => ffi::OsStr::from_bytes(bytes).into(),
-                        ArgStrOrBytesLike::Str(s) => vm.fsencode(s)?,
-                    };
-                    socket2::SockAddr::unix(path)
-                        .map_err(|_| vm.new_os_error("AF_UNIX path too long".to_owned()).into())
-                }
-                c::AF_INET => {
-                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
-                        vm.new_type_error(format!(
-                            "{}(): AF_INET address must be tuple, not {}",
-                            caller,
-                            obj.class().name()
-                        ))
-                    })?;
-                    if tuple.len() != 2 {
-                        return Err(vm
-                            .new_type_error("AF_INET address must be a pair (host, post)")
-                            .into());
-                    }
-                    let addr = Address::from_tuple(&tuple, vm)?;
-                    let mut addr4 = get_addr(vm, addr.host, c::AF_INET)?;
-                    match &mut addr4 {
-                        SocketAddr::V4(addr4) => {
-                            addr4.set_port(addr.port);
-                        }
-                        SocketAddr::V6(_) => unreachable!(),
-                    }
-                    Ok(addr4.into())
-                }
-                c::AF_INET6 => {
-                    let tuple: PyTupleRef = addr.downcast().map_err(|obj| {
-                        vm.new_type_error(format!(
-                            "{}(): AF_INET6 address must be tuple, not {}",
-                            caller,
-                            obj.class().name()
-                        ))
-                    })?;
-                    match tuple.len() {
-                        2..=4 => {}
-                        _ => return Err(vm.new_type_error(
-                            "AF_INET6 address must be a tuple (host, port[, flowinfo[, scopeid]])",
-                        ).into()),
-                    }
-                    let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&tuple, vm)?;
-                    let mut addr6 = get_addr(vm, addr.host, c::AF_INET6)?;
-                    match &mut addr6 {
-                        SocketAddr::V6(addr6) => {
-                            addr6.set_port(addr.port);
-                            addr6.set_flowinfo(flowinfo);
-                            addr6.set_scope_id(scopeid);
-                        }
-                        SocketAddr::V4(_) => unreachable!(),
-                    }
-                    Ok(addr6.into())
-                }
-                _ => Err(vm.new_os_error(format!("{caller}(): bad family")).into()),
-            }
-        }
-
-        fn connect_inner(
-            &self,
-            address: PyObjectRef,
-            caller: &str,
-            vm: &VirtualMachine,
-        ) -> Result<(), IoOrPyException> {
-            let sock_addr = self.extract_address(address, caller, vm)?;
-
-            let err = match self.sock()?.connect(&sock_addr) {
-                Ok(()) => return Ok(()),
-                Err(e) => e,
-            };
-
-            let wait_connect = if err.kind() == io::ErrorKind::Interrupted {
-                vm.check_signals()?;
-                self.timeout.load() != 0.0
-            } else {
-                #[cfg(unix)]
-                use c::EINPROGRESS;
-                #[cfg(windows)]
-                use c::WSAEWOULDBLOCK as EINPROGRESS;
-
-                self.timeout.load() > 0.0 && err.raw_os_error() == Some(EINPROGRESS)
-            };
-
-            if wait_connect {
-                // basically, connect() is async, and it registers an "error" on the socket when it's
-                // done connecting. SelectKind::Connect fills the errorfds fd_set, so if we wake up
-                // from poll and the error is EISCONN then we know that the connect is done
-                self.sock_op(vm, SelectKind::Connect, || {
-                    let sock = self.sock()?;
-                    let err = sock.take_error()?;
-                    match err {
-                        Some(e) if e.posix_errno() == libc::EISCONN => Ok(()),
-                        Some(e) => Err(e),
-                        // TODO: is this accurate?
-                        None => Ok(()),
-                    }
-                })
-            } else {
-                Err(err.into())
-            }
-        }
-    }
-
-    impl DefaultConstructor for PySocket {}
-
-    impl Initializer for PySocket {
-        type Args = (
-            OptionalArg<i32>,
-            OptionalArg<i32>,
-            OptionalArg<i32>,
-            OptionalOption<PyObjectRef>,
-        );
-
-        fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
-            Self::_init(zelf, args, vm).map_err(|e| e.into_pyexception(vm))
-        }
-    }
-
-    impl Representable for PySocket {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            Ok(format!(
-                "<socket object, fd={}, family={}, type={}, proto={}>",
-                // cast because INVALID_SOCKET is unsigned, so would show usize::MAX instead of -1
-                zelf.fileno() as i64,
-                zelf.family.load(),
-                zelf.kind.load(),
-                zelf.proto.load(),
-            ))
-        }
-    }
-
-    #[pyclass(with(Constructor, Initializer, Representable), flags(BASETYPE))]
-    impl PySocket {
-        fn _init(
-            zelf: PyRef<Self>,
-            (family, socket_kind, proto, fileno): <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 fileno = fileno
-                .flatten()
-                .map(|obj| get_raw_sock(obj, vm))
-                .transpose()?;
-            let sock;
-            if let Some(fileno) = fileno {
-                sock = sock_from_raw(fileno, vm)?;
-                match sock.local_addr() {
-                    Ok(addr) if family == -1 => family = addr.family() as i32,
-                    Err(e)
-                        if family == -1
-                            || matches!(
-                                e.raw_os_error(),
-                                Some(errcode!(ENOTSOCK)) | Some(errcode!(EBADF))
-                            ) =>
-                    {
-                        std::mem::forget(sock);
-                        return Err(e.into());
-                    }
-                    _ => {}
-                }
-                if socket_kind == -1 {
-                    socket_kind = sock.r#type().map_err(|e| e.into_pyexception(vm))?.into();
-                }
-                cfg_if::cfg_if! {
-                    if #[cfg(any(
-                        target_os = "android",
-                        target_os = "freebsd",
-                        target_os = "fuchsia",
-                        target_os = "linux",
-                    ))] {
-                        if proto == -1 {
-                            proto = sock.protocol()?.map_or(0, Into::into);
-                        }
-                    } else {
-                        proto = 0;
-                    }
-                }
-            } else {
-                if family == -1 {
-                    family = c::AF_INET as _
-                }
-                if socket_kind == -1 {
-                    socket_kind = c::SOCK_STREAM
-                }
-                if proto == -1 {
-                    proto = 0
-                }
-                sock = Socket::new(family.into(), socket_kind.into(), Some(proto.into()))?;
-            };
-            Ok(zelf.init_inner(family, socket_kind, proto, sock)?)
-        }
-
-        #[pymethod]
-        fn connect(
-            &self,
-            address: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> Result<(), IoOrPyException> {
-            self.connect_inner(address, "connect", vm)
-        }
-
-        #[pymethod]
-        fn connect_ex(&self, address: PyObjectRef, vm: &VirtualMachine) -> PyResult<i32> {
-            match self.connect_inner(address, "connect_ex", vm) {
-                Ok(()) => Ok(0),
-                Err(err) => err.errno(),
-            }
-        }
-
-        #[pymethod]
-        fn bind(&self, address: PyObjectRef, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
-            let sock_addr = self.extract_address(address, "bind", vm)?;
-            Ok(self.sock()?.bind(&sock_addr)?)
-        }
-
-        #[pymethod]
-        fn listen(&self, backlog: OptionalArg<i32>) -> io::Result<()> {
-            let backlog = backlog.unwrap_or(128);
-            let backlog = if backlog < 0 { 0 } else { backlog };
-            self.sock()?.listen(backlog)
-        }
-
-        #[pymethod]
-        fn _accept(
-            &self,
-            vm: &VirtualMachine,
-        ) -> Result<(RawSocket, PyObjectRef), IoOrPyException> {
-            let (sock, addr) = self.sock_op(vm, SelectKind::Read, || self.sock()?.accept())?;
-            let fd = into_sock_fileno(sock);
-            Ok((fd, get_addr_tuple(&addr, vm)))
-        }
-
-        #[pymethod]
-        fn recv(
-            &self,
-            bufsize: usize,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<Vec<u8>, IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-            let mut buffer = Vec::with_capacity(bufsize);
-            let sock = self.sock()?;
-            let n = self.sock_op(vm, SelectKind::Read, || {
-                sock.recv_with_flags(buffer.spare_capacity_mut(), flags)
-            })?;
-            unsafe { buffer.set_len(n) };
-            Ok(buffer)
-        }
-
-        #[pymethod]
-        fn recv_into(
-            &self,
-            buf: ArgMemoryBuffer,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<usize, IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-            let sock = self.sock()?;
-            let mut buf = buf.borrow_buf_mut();
-            let buf = &mut *buf;
-            self.sock_op(vm, SelectKind::Read, || {
-                sock.recv_with_flags(unsafe { slice_as_uninit(buf) }, flags)
-            })
-        }
-
-        #[pymethod]
-        fn recvfrom(
-            &self,
-            bufsize: isize,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<(Vec<u8>, PyObjectRef), IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-            let bufsize = bufsize
-                .to_usize()
-                .ok_or_else(|| vm.new_value_error("negative buffersize in recvfrom"))?;
-            let mut buffer = Vec::with_capacity(bufsize);
-            let (n, addr) = self.sock_op(vm, SelectKind::Read, || {
-                self.sock()?
-                    .recv_from_with_flags(buffer.spare_capacity_mut(), flags)
-            })?;
-            unsafe { buffer.set_len(n) };
-            Ok((buffer, get_addr_tuple(&addr, vm)))
-        }
-
-        #[pymethod]
-        fn recvfrom_into(
-            &self,
-            buf: ArgMemoryBuffer,
-            nbytes: OptionalArg<isize>,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<(usize, PyObjectRef), IoOrPyException> {
-            let mut buf = buf.borrow_buf_mut();
-            let buf = &mut *buf;
-            let buf = match nbytes {
-                OptionalArg::Present(i) => {
-                    let i = i.to_usize().ok_or_else(|| {
-                        vm.new_value_error("negative buffersize in recvfrom_into")
-                    })?;
-                    buf.get_mut(..i).ok_or_else(|| {
-                        vm.new_value_error("nbytes is greater than the length of the buffer")
-                    })?
-                }
-                OptionalArg::Missing => buf,
-            };
-            let flags = flags.unwrap_or(0);
-            let sock = self.sock()?;
-            let (n, addr) = self.sock_op(vm, SelectKind::Read, || {
-                sock.recv_from_with_flags(unsafe { slice_as_uninit(buf) }, flags)
-            })?;
-            Ok((n, get_addr_tuple(&addr, vm)))
-        }
-
-        #[pymethod]
-        fn send(
-            &self,
-            bytes: ArgBytesLike,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<usize, IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-            let buf = bytes.borrow_buf();
-            let buf = &*buf;
-            self.sock_op(vm, SelectKind::Write, || {
-                self.sock()?.send_with_flags(buf, flags)
-            })
-        }
-
-        #[pymethod]
-        fn sendall(
-            &self,
-            bytes: ArgBytesLike,
-            flags: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<(), IoOrPyException> {
-            let flags = flags.unwrap_or(0);
-
-            let timeout = self.get_timeout().ok();
-
-            let deadline = timeout.map(Deadline::new);
-
-            let buf = bytes.borrow_buf();
-            let buf = &*buf;
-            let mut buf_offset = 0;
-            // now we have like 3 layers of interrupt loop :)
-            while buf_offset < buf.len() {
-                let interval = deadline.as_ref().map(|d| d.time_until()).transpose()?;
-                self.sock_op_timeout_err(vm, SelectKind::Write, interval, || {
-                    let subbuf = &buf[buf_offset..];
-                    buf_offset += self.sock()?.send_with_flags(subbuf, flags)?;
-                    Ok(())
-                })?;
-                vm.check_signals()?;
-            }
-            Ok(())
-        }
-
-        #[pymethod]
-        fn sendto(
-            &self,
-            bytes: ArgBytesLike,
-            arg2: PyObjectRef,
-            arg3: OptionalArg<PyObjectRef>,
-            vm: &VirtualMachine,
-        ) -> Result<usize, IoOrPyException> {
-            // signature is bytes[, flags], address
-            let (flags, address) = match arg3 {
-                OptionalArg::Present(arg3) => {
-                    // should just be i32::try_from_obj but tests check for error message
-                    let int = arg2
-                        .try_index_opt(vm)
-                        .unwrap_or_else(|| Err(vm.new_type_error("an integer is required")))?;
-                    let flags = int.try_to_primitive::<i32>(vm)?;
-                    (flags, arg3)
-                }
-                OptionalArg::Missing => (0, arg2),
-            };
-            let addr = self.extract_address(address, "sendto", vm)?;
-            let buf = bytes.borrow_buf();
-            let buf = &*buf;
-            self.sock_op(vm, SelectKind::Write, || {
-                self.sock()?.send_to_with_flags(buf, &addr, flags)
-            })
-        }
-
-        #[cfg(all(unix, not(target_os = "redox")))]
-        #[pymethod]
-        fn sendmsg(
-            &self,
-            buffers: Vec<ArgBytesLike>,
-            ancdata: OptionalArg,
-            flags: OptionalArg<i32>,
-            addr: OptionalOption,
-            vm: &VirtualMachine,
-        ) -> PyResult<usize> {
-            let flags = flags.unwrap_or(0);
-            let mut msg = socket2::MsgHdr::new();
-
-            let sockaddr;
-            if let Some(addr) = addr.flatten() {
-                sockaddr = self
-                    .extract_address(addr, "sendmsg", vm)
-                    .map_err(|e| e.into_pyexception(vm))?;
-                msg = msg.with_addr(&sockaddr);
-            }
-
-            let buffers = buffers
-                .iter()
-                .map(|buf| buf.borrow_buf())
-                .collect::<Vec<_>>();
-            let buffers = buffers
-                .iter()
-                .map(|buf| io::IoSlice::new(buf))
-                .collect::<Vec<_>>();
-            msg = msg.with_buffers(&buffers);
-
-            let control_buf;
-            if let OptionalArg::Present(ancdata) = ancdata {
-                let cmsgs = vm.extract_elements_with(
-                    &ancdata,
-                    |obj| -> PyResult<(i32, i32, ArgBytesLike)> {
-                        let seq: Vec<PyObjectRef> = obj.try_into_value(vm)?;
-                        let [lvl, typ, data]: [PyObjectRef; 3] = seq
-                            .try_into()
-                            .map_err(|_| vm.new_type_error("expected a sequence of length 3"))?;
-                        Ok((
-                            lvl.try_into_value(vm)?,
-                            typ.try_into_value(vm)?,
-                            data.try_into_value(vm)?,
-                        ))
-                    },
-                )?;
-                control_buf = Self::pack_cmsgs_to_send(&cmsgs, vm)?;
-                if !control_buf.is_empty() {
-                    msg = msg.with_control(&control_buf);
-                }
-            }
-
-            self.sock_op(vm, SelectKind::Write, || {
-                let sock = self.sock()?;
-                sock.sendmsg(&msg, flags)
-            })
-            .map_err(|e| e.into_pyexception(vm))
-        }
-
-        // based on nix's implementation
-        #[cfg(all(unix, not(target_os = "redox")))]
-        fn pack_cmsgs_to_send(
-            cmsgs: &[(i32, i32, ArgBytesLike)],
-            vm: &VirtualMachine,
-        ) -> PyResult<Vec<u8>> {
-            use std::{mem, ptr};
-
-            if cmsgs.is_empty() {
-                return Ok(vec![]);
-            }
-
-            let capacity = cmsgs
-                .iter()
-                .map(|(_, _, buf)| buf.len())
-                .try_fold(0, |sum, len| {
-                    let space = checked_cmsg_space(len).ok_or_else(|| {
-                        vm.new_os_error("ancillary data item too large".to_owned())
-                    })?;
-                    usize::checked_add(sum, space)
-                        .ok_or_else(|| vm.new_os_error("too much ancillary data".to_owned()))
-                })?;
-
-            let mut cmsg_buffer = vec![0u8; capacity];
-
-            // make a dummy msghdr so we can use the CMSG_* apis
-            let mut mhdr = unsafe { mem::zeroed::<libc::msghdr>() };
-            mhdr.msg_control = cmsg_buffer.as_mut_ptr().cast();
-            mhdr.msg_controllen = capacity as _;
-
-            let mut pmhdr: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(&mhdr) };
-            for (lvl, typ, buf) in cmsgs {
-                if pmhdr.is_null() {
-                    return Err(vm.new_runtime_error(
-                        "unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR",
-                    ));
-                }
-                let data = &*buf.borrow_buf();
-                assert_eq!(data.len(), buf.len());
-                // Safe because we know that pmhdr is valid, and we initialized it with
-                // sufficient space
-                unsafe {
-                    (*pmhdr).cmsg_level = *lvl;
-                    (*pmhdr).cmsg_type = *typ;
-                    (*pmhdr).cmsg_len = data.len() as _;
-                    ptr::copy_nonoverlapping(data.as_ptr(), libc::CMSG_DATA(pmhdr), data.len());
-                }
-
-                // Safe because mhdr is valid
-                pmhdr = unsafe { libc::CMSG_NXTHDR(&mhdr, pmhdr) };
-            }
-
-            Ok(cmsg_buffer)
-        }
-
-        #[pymethod]
-        fn close(&self) -> io::Result<()> {
-            let sock = self.detach();
-            if sock != INVALID_SOCKET {
-                close_inner(sock)?;
-            }
-            Ok(())
-        }
-
-        #[pymethod]
-        #[inline]
-        fn detach(&self) -> RawSocket {
-            let sock = self.sock.write().take();
-            sock.map_or(INVALID_SOCKET, into_sock_fileno)
-        }
-
-        #[pymethod]
-        fn fileno(&self) -> RawSocket {
-            self.sock
-                .read()
-                .as_ref()
-                .map_or(INVALID_SOCKET, sock_fileno)
-        }
-
-        #[pymethod]
-        fn getsockname(&self, vm: &VirtualMachine) -> std::io::Result<PyObjectRef> {
-            let addr = self.sock()?.local_addr()?;
-
-            Ok(get_addr_tuple(&addr, vm))
-        }
-
-        #[pymethod]
-        fn getpeername(&self, vm: &VirtualMachine) -> std::io::Result<PyObjectRef> {
-            let addr = self.sock()?.peer_addr()?;
-
-            Ok(get_addr_tuple(&addr, vm))
-        }
-
-        #[pymethod]
-        fn gettimeout(&self) -> Option<f64> {
-            let timeout = self.timeout.load();
-            if timeout >= 0.0 { Some(timeout) } else { None }
-        }
-
-        #[pymethod]
-        fn setblocking(&self, block: bool) -> io::Result<()> {
-            self.timeout.store(if block { -1.0 } else { 0.0 });
-            self.sock()?.set_nonblocking(!block)
-        }
-
-        #[pymethod]
-        fn getblocking(&self) -> bool {
-            self.timeout.load() != 0.0
-        }
-
-        #[pymethod]
-        fn settimeout(&self, timeout: Option<Duration>) -> io::Result<()> {
-            self.timeout
-                .store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
-            // 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())
-        }
-
-        #[pymethod]
-        fn getsockopt(
-            &self,
-            level: i32,
-            name: i32,
-            buflen: OptionalArg<i32>,
-            vm: &VirtualMachine,
-        ) -> Result<PyObjectRef, IoOrPyException> {
-            let sock = self.sock()?;
-            let fd = sock_fileno(&sock);
-            let buflen = buflen.unwrap_or(0);
-            if buflen == 0 {
-                let mut flag: libc::c_int = 0;
-                let mut flagsize = std::mem::size_of::<libc::c_int>() as _;
-                let ret = unsafe {
-                    c::getsockopt(
-                        fd as _,
-                        level,
-                        name,
-                        &mut flag as *mut libc::c_int as *mut _,
-                        &mut flagsize,
-                    )
-                };
-                if ret < 0 {
-                    return Err(crate::common::os::last_os_error().into());
-                }
-                Ok(vm.ctx.new_int(flag).into())
-            } else {
-                if buflen <= 0 || buflen > 1024 {
-                    return Err(vm
-                        .new_os_error("getsockopt buflen out of range".to_owned())
-                        .into());
-                }
-                let mut buf = vec![0u8; buflen as usize];
-                let mut buflen = buflen as _;
-                let ret = unsafe {
-                    c::getsockopt(
-                        fd as _,
-                        level,
-                        name,
-                        buf.as_mut_ptr() as *mut _,
-                        &mut buflen,
-                    )
-                };
-                if ret < 0 {
-                    return Err(crate::common::os::last_os_error().into());
-                }
-                buf.truncate(buflen as usize);
-                Ok(vm.ctx.new_bytes(buf).into())
-            }
-        }
-
-        #[pymethod]
-        fn setsockopt(
-            &self,
-            level: i32,
-            name: i32,
-            value: Option<Either<ArgBytesLike, i32>>,
-            optlen: OptionalArg<u32>,
-            vm: &VirtualMachine,
-        ) -> Result<(), IoOrPyException> {
-            let sock = self.sock()?;
-            let fd = sock_fileno(&sock);
-            let ret = match (value, optlen) {
-                (Some(Either::A(b)), OptionalArg::Missing) => b.with_ref(|b| unsafe {
-                    c::setsockopt(fd as _, level, name, b.as_ptr() as *const _, b.len() as _)
-                }),
-                (Some(Either::B(ref val)), OptionalArg::Missing) => unsafe {
-                    c::setsockopt(
-                        fd as _,
-                        level,
-                        name,
-                        val as *const i32 as *const _,
-                        std::mem::size_of::<i32>() as _,
-                    )
-                },
-                (None, OptionalArg::Present(optlen)) => unsafe {
-                    c::setsockopt(fd as _, level, name, std::ptr::null(), optlen as _)
-                },
-                _ => {
-                    return Err(vm
-                        .new_type_error("expected the value arg xor the optlen arg")
-                        .into());
-                }
-            };
-            if ret < 0 {
-                Err(crate::common::os::last_os_error().into())
-            } else {
-                Ok(())
-            }
-        }
-
-        #[pymethod]
-        fn shutdown(&self, how: i32, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
-            let how = match how {
-                c::SHUT_RD => Shutdown::Read,
-                c::SHUT_WR => Shutdown::Write,
-                c::SHUT_RDWR => Shutdown::Both,
-                _ => {
-                    return Err(vm
-                        .new_value_error("`how` must be SHUT_RD, SHUT_WR, or SHUT_RDWR")
-                        .into());
-                }
-            };
-            Ok(self.sock()?.shutdown(how)?)
-        }
-
-        #[pygetset(name = "type")]
-        fn kind(&self) -> i32 {
-            self.kind.load()
-        }
-
-        #[pygetset]
-        fn family(&self) -> i32 {
-            self.family.load()
-        }
-
-        #[pygetset]
-        fn proto(&self) -> i32 {
-            self.proto.load()
-        }
-    }
-
-    struct Address {
-        host: PyStrRef,
-        port: u16,
-    }
-
-    impl ToSocketAddrs for Address {
-        type Iter = std::vec::IntoIter<SocketAddr>;
-        fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
-            (self.host.as_str(), self.port).to_socket_addrs()
-        }
-    }
-
-    impl TryFromObject for Address {
-        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            let tuple = PyTupleRef::try_from_object(vm, obj)?;
-            if tuple.len() != 2 {
-                Err(vm.new_type_error("Address tuple should have only 2 values"))
-            } else {
-                Self::from_tuple(&tuple, vm)
-            }
-        }
-    }
-
-    impl Address {
-        fn from_tuple(tuple: &[PyObjectRef], vm: &VirtualMachine) -> PyResult<Self> {
-            let host = PyStrRef::try_from_object(vm, tuple[0].clone())?;
-            let port = i32::try_from_borrowed_object(vm, &tuple[1])?;
-            let port = port
-                .to_u16()
-                .ok_or_else(|| vm.new_overflow_error("port must be 0-65535."))?;
-            Ok(Self { host, port })
-        }
-
-        fn from_tuple_ipv6(
-            tuple: &[PyObjectRef],
-            vm: &VirtualMachine,
-        ) -> PyResult<(Self, u32, u32)> {
-            let addr = Self::from_tuple(tuple, vm)?;
-            let flowinfo = tuple
-                .get(2)
-                .map(|obj| u32::try_from_borrowed_object(vm, obj))
-                .transpose()?
-                .unwrap_or(0);
-            let scopeid = tuple
-                .get(3)
-                .map(|obj| u32::try_from_borrowed_object(vm, obj))
-                .transpose()?
-                .unwrap_or(0);
-            if flowinfo > 0xfffff {
-                return Err(vm.new_overflow_error("flowinfo must be 0-1048575."));
-            }
-            Ok((addr, flowinfo, scopeid))
-        }
-    }
-
-    fn get_ip_addr_tuple(addr: &SocketAddr, vm: &VirtualMachine) -> PyObjectRef {
-        match addr {
-            SocketAddr::V4(addr) => (addr.ip().to_string(), addr.port()).to_pyobject(vm),
-            SocketAddr::V6(addr) => (
-                addr.ip().to_string(),
-                addr.port(),
-                addr.flowinfo(),
-                addr.scope_id(),
-            )
-                .to_pyobject(vm),
-        }
-    }
-
-    fn get_addr_tuple(addr: &socket2::SockAddr, vm: &VirtualMachine) -> PyObjectRef {
-        if let Some(addr) = addr.as_socket() {
-            return get_ip_addr_tuple(&addr, vm);
-        }
-        #[cfg(unix)]
-        if addr.is_unix() {
-            use std::os::unix::ffi::OsStrExt;
-            if let Some(abstractpath) = addr.as_abstract_namespace() {
-                return vm.ctx.new_bytes([b"\0", abstractpath].concat()).into();
-            }
-            // necessary on macos
-            let path = ffi::OsStr::as_bytes(addr.as_pathname().unwrap_or("".as_ref()).as_ref());
-            let nul_pos = memchr::memchr(b'\0', path).unwrap_or(path.len());
-            let path = ffi::OsStr::from_bytes(&path[..nul_pos]);
-            return vm.fsdecode(path).into();
-        }
-        // TODO: support more address families
-        (String::new(), 0).to_pyobject(vm)
-    }
-
-    #[pyfunction]
-    fn gethostname(vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        gethostname::gethostname()
-            .into_string()
-            .map(|hostname| vm.ctx.new_str(hostname))
-            .map_err(|err| vm.new_os_error(err.into_string().unwrap()))
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    #[pyfunction]
-    fn sethostname(hostname: PyStrRef) -> nix::Result<()> {
-        nix::unistd::sethostname(hostname.as_str())
-    }
-
-    #[pyfunction]
-    fn inet_aton(ip_string: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        ip_string
-            .as_str()
-            .parse::<Ipv4Addr>()
-            .map(|ip_addr| Vec::<u8>::from(ip_addr.octets()))
-            .map_err(|_| {
-                vm.new_os_error("illegal IP address string passed to inet_aton".to_owned())
-            })
-    }
-
-    #[pyfunction]
-    fn inet_ntoa(packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let packed_ip = packed_ip.borrow_buf();
-        let packed_ip = <&[u8; 4]>::try_from(&*packed_ip)
-            .map_err(|_| vm.new_os_error("packed IP wrong length for inet_ntoa".to_owned()))?;
-        Ok(vm.ctx.new_str(Ipv4Addr::from(*packed_ip).to_string()))
-    }
-
-    fn cstr_opt_as_ptr(x: &OptionalArg<ffi::CString>) -> *const libc::c_char {
-        x.as_ref().map_or_else(std::ptr::null, |s| s.as_ptr())
-    }
-
-    #[pyfunction]
-    fn getservbyname(
-        servicename: PyStrRef,
-        protocolname: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<u16> {
-        let cstr_name = servicename.to_cstring(vm)?;
-        let cstr_proto = protocolname
-            .as_ref()
-            .map(|s| s.to_cstring(vm))
-            .transpose()?;
-        let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
-        let serv = unsafe { c::getservbyname(cstr_name.as_ptr() as _, cstr_proto as _) };
-        if serv.is_null() {
-            return Err(vm.new_os_error("service/proto not found".to_owned()));
-        }
-        let port = unsafe { (*serv).s_port };
-        Ok(u16::from_be(port as u16))
-    }
-
-    #[pyfunction]
-    fn getservbyport(
-        port: i32,
-        protocolname: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<String> {
-        let port = port
-            .to_u16()
-            .ok_or_else(|| vm.new_overflow_error("getservbyport: port must be 0-65535."))?;
-        let cstr_proto = protocolname
-            .as_ref()
-            .map(|s| s.to_cstring(vm))
-            .transpose()?;
-        let cstr_proto = cstr_opt_as_ptr(&cstr_proto);
-        let serv = unsafe { c::getservbyport(port.to_be() as _, cstr_proto as _) };
-        if serv.is_null() {
-            return Err(vm.new_os_error("port/proto not found".to_owned()));
-        }
-        let s = unsafe { ffi::CStr::from_ptr((*serv).s_name as _) };
-        Ok(s.to_string_lossy().into_owned())
-    }
-
-    unsafe fn slice_as_uninit<T>(v: &mut [T]) -> &mut [MaybeUninit<T>] {
-        unsafe { &mut *(v as *mut [T] as *mut [MaybeUninit<T>]) }
-    }
-
-    enum IoOrPyException {
-        Timeout,
-        Py(PyBaseExceptionRef),
-        Io(io::Error),
-    }
-    impl From<PyBaseExceptionRef> for IoOrPyException {
-        fn from(exc: PyBaseExceptionRef) -> Self {
-            Self::Py(exc)
-        }
-    }
-    impl From<io::Error> for IoOrPyException {
-        fn from(err: io::Error) -> Self {
-            Self::Io(err)
-        }
-    }
-    impl IoOrPyException {
-        fn errno(self) -> PyResult<i32> {
-            match self {
-                Self::Timeout => Ok(errcode!(EWOULDBLOCK)),
-                Self::Io(err) => Ok(err.posix_errno()),
-                Self::Py(exc) => Err(exc),
-            }
-        }
-    }
-    impl IntoPyException for IoOrPyException {
-        #[inline]
-        fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-            match self {
-                Self::Timeout => timeout_error(vm),
-                Self::Py(exc) => exc,
-                Self::Io(err) => err.into_pyexception(vm),
-            }
-        }
-    }
-
-    #[derive(Copy, Clone)]
-    pub(crate) enum SelectKind {
-        Read,
-        Write,
-        Connect,
-    }
-
-    /// returns true if timed out
-    pub(crate) fn sock_select(
-        sock: &Socket,
-        kind: SelectKind,
-        interval: Option<Duration>,
-    ) -> io::Result<bool> {
-        #[cfg(unix)]
-        {
-            use nix::poll::*;
-            use std::os::fd::AsFd;
-            let events = match kind {
-                SelectKind::Read => PollFlags::POLLIN,
-                SelectKind::Write => PollFlags::POLLOUT,
-                SelectKind::Connect => PollFlags::POLLOUT | PollFlags::POLLERR,
-            };
-            let mut pollfd = [PollFd::new(sock.as_fd(), events)];
-            let timeout = match interval {
-                Some(d) => d.try_into().unwrap_or(PollTimeout::MAX),
-                None => PollTimeout::NONE,
-            };
-            let ret = poll(&mut pollfd, timeout)?;
-            Ok(ret == 0)
-        }
-        #[cfg(windows)]
-        {
-            use crate::select;
-
-            let fd = sock_fileno(sock);
-
-            let mut reads = select::FdSet::new();
-            let mut writes = select::FdSet::new();
-            let mut errs = select::FdSet::new();
-
-            let fd = fd as usize;
-            match kind {
-                SelectKind::Read => reads.insert(fd),
-                SelectKind::Write => writes.insert(fd),
-                SelectKind::Connect => {
-                    writes.insert(fd);
-                    errs.insert(fd);
-                }
-            }
-
-            let mut interval = interval.map(|dur| select::timeval {
-                tv_sec: dur.as_secs() as _,
-                tv_usec: dur.subsec_micros() as _,
-            });
-
-            select::select(
-                fd as i32 + 1,
-                &mut reads,
-                &mut writes,
-                &mut errs,
-                interval.as_mut(),
-            )
-            .map(|ret| ret == 0)
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct GAIOptions {
-        #[pyarg(positional)]
-        host: Option<PyStrRef>,
-        #[pyarg(positional)]
-        port: Option<Either<PyStrRef, i32>>,
-
-        #[pyarg(positional, default = c::AF_UNSPEC)]
-        family: i32,
-        #[pyarg(positional, default = 0)]
-        ty: i32,
-        #[pyarg(positional, default = 0)]
-        proto: i32,
-        #[pyarg(positional, default = 0)]
-        flags: i32,
-    }
-
-    #[pyfunction]
-    fn getaddrinfo(
-        opts: GAIOptions,
-        vm: &VirtualMachine,
-    ) -> Result<Vec<PyObjectRef>, IoOrPyException> {
-        let hints = dns_lookup::AddrInfoHints {
-            socktype: opts.ty,
-            protocol: opts.proto,
-            address: opts.family,
-            flags: opts.flags,
-        };
-
-        let host = opts.host.as_ref().map(|s| s.as_str());
-        let port = opts.port.as_ref().map(|p| -> std::borrow::Cow<'_, str> {
-            match p {
-                Either::A(s) => s.as_str().into(),
-                Either::B(i) => i.to_string().into(),
-            }
-        });
-        let port = port.as_ref().map(|p| p.as_ref());
-
-        let addrs = dns_lookup::getaddrinfo(host, port, Some(hints))
-            .map_err(|err| convert_socket_error(vm, err, SocketError::GaiError))?;
-
-        let list = addrs
-            .map(|ai| {
-                ai.map(|ai| {
-                    vm.new_tuple((
-                        ai.address,
-                        ai.socktype,
-                        ai.protocol,
-                        ai.canonname,
-                        get_ip_addr_tuple(&ai.sockaddr, vm),
-                    ))
-                    .into()
-                })
-            })
-            .collect::<io::Result<Vec<_>>>()?;
-        Ok(list)
-    }
-
-    #[pyfunction]
-    fn gethostbyaddr(
-        addr: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
-        let addr = get_addr(vm, addr, c::AF_UNSPEC)?;
-        let (hostname, _) = dns_lookup::getnameinfo(&addr, 0)
-            .map_err(|e| convert_socket_error(vm, e, SocketError::HError))?;
-        Ok((
-            hostname,
-            vm.ctx.new_list(vec![]),
-            vm.ctx
-                .new_list(vec![vm.ctx.new_str(addr.ip().to_string()).into()]),
-        ))
-    }
-
-    #[pyfunction]
-    fn gethostbyname(name: PyStrRef, vm: &VirtualMachine) -> Result<String, IoOrPyException> {
-        let addr = get_addr(vm, name, c::AF_INET)?;
-        match addr {
-            SocketAddr::V4(ip) => Ok(ip.ip().to_string()),
-            _ => unreachable!(),
-        }
-    }
-
-    #[pyfunction]
-    fn gethostbyname_ex(
-        name: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> Result<(String, PyListRef, PyListRef), IoOrPyException> {
-        let addr = get_addr(vm, name, c::AF_INET)?;
-        let (hostname, _) = dns_lookup::getnameinfo(&addr, 0)
-            .map_err(|e| convert_socket_error(vm, e, SocketError::HError))?;
-        Ok((
-            hostname,
-            vm.ctx.new_list(vec![]),
-            vm.ctx
-                .new_list(vec![vm.ctx.new_str(addr.ip().to_string()).into()]),
-        ))
-    }
-
-    #[pyfunction]
-    fn inet_pton(af_inet: i32, ip_string: PyStrRef, 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
-                .as_str()
-                .parse::<Ipv4Addr>()
-                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
-                .octets()
-                .to_vec(),
-            c::AF_INET6 => ip_string
-                .as_str()
-                .parse::<Ipv6Addr>()
-                .map_err(|_| vm.new_os_error(ERROR_MSG.to_owned()))?
-                .octets()
-                .to_vec(),
-            _ => return Err(vm.new_os_error("Address family not supported by protocol".to_owned())),
-        };
-        Ok(ip_addr)
-    }
-
-    #[pyfunction]
-    fn inet_ntop(af_inet: i32, packed_ip: ArgBytesLike, vm: &VirtualMachine) -> PyResult<String> {
-        let packed_ip = packed_ip.borrow_buf();
-        match af_inet {
-            c::AF_INET => {
-                let packed_ip = <&[u8; 4]>::try_from(&*packed_ip).map_err(|_| {
-                    vm.new_value_error("invalid length of packed IP address string")
-                })?;
-                Ok(Ipv4Addr::from(*packed_ip).to_string())
-            }
-            c::AF_INET6 => {
-                let packed_ip = <&[u8; 16]>::try_from(&*packed_ip).map_err(|_| {
-                    vm.new_value_error("invalid length of packed IP address string")
-                })?;
-                Ok(get_ipv6_addr_str(Ipv6Addr::from(*packed_ip)))
-            }
-            _ => Err(vm.new_value_error(format!("unknown address family {af_inet}"))),
-        }
-    }
-
-    #[pyfunction]
-    fn getprotobyname(name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let cstr = name.to_cstring(vm)?;
-        let proto = unsafe { c::getprotobyname(cstr.as_ptr() as _) };
-        if proto.is_null() {
-            return Err(vm.new_os_error("protocol not found".to_owned()));
-        }
-        let num = unsafe { (*proto).p_proto };
-        Ok(vm.ctx.new_int(num).into())
-    }
-
-    #[pyfunction]
-    fn getnameinfo(
-        address: PyTupleRef,
-        flags: i32,
-        vm: &VirtualMachine,
-    ) -> Result<(String, String), IoOrPyException> {
-        match address.len() {
-            2..=4 => {}
-            _ => {
-                return Err(vm.new_type_error("illegal sockaddr argument").into());
-            }
-        }
-        let (addr, flowinfo, scopeid) = Address::from_tuple_ipv6(&address, vm)?;
-        let hints = dns_lookup::AddrInfoHints {
-            address: c::AF_UNSPEC,
-            socktype: c::SOCK_DGRAM,
-            flags: c::AI_NUMERICHOST,
-            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 mut ainfo = res.next().unwrap();
-        if res.next().is_some() {
-            return Err(vm
-                .new_os_error("sockaddr resolved to multiple addresses".to_owned())
-                .into());
-        }
-        match &mut ainfo.sockaddr {
-            SocketAddr::V4(_) => {
-                if address.len() != 2 {
-                    return Err(vm
-                        .new_os_error("IPv4 sockaddr must be 2 tuple".to_owned())
-                        .into());
-                }
-            }
-            SocketAddr::V6(addr) => {
-                addr.set_flowinfo(flowinfo);
-                addr.set_scope_id(scopeid);
-            }
-        }
-        dns_lookup::getnameinfo(&ainfo.sockaddr, flags)
-            .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))
-    }
-
-    #[cfg(unix)]
-    #[pyfunction]
-    fn socketpair(
-        family: OptionalArg<i32>,
-        socket_kind: OptionalArg<i32>,
-        proto: OptionalArg<i32>,
-    ) -> Result<(PySocket, PySocket), IoOrPyException> {
-        let family = family.unwrap_or(libc::AF_UNIX);
-        let socket_kind = socket_kind.unwrap_or(libc::SOCK_STREAM);
-        let proto = proto.unwrap_or(0);
-        let (a, b) = Socket::pair(family.into(), socket_kind.into(), Some(proto.into()))?;
-        let py_a = PySocket::default();
-        py_a.init_inner(family, socket_kind, proto, a)?;
-        let py_b = PySocket::default();
-        py_b.init_inner(family, socket_kind, proto, b)?;
-        Ok((py_a, py_b))
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    type IfIndex = c::c_uint;
-    #[cfg(windows)]
-    type IfIndex = u32; // NET_IFINDEX but windows-sys 0.59 doesn't have it
-
-    #[cfg(not(target_os = "redox"))]
-    #[pyfunction]
-    fn if_nametoindex(name: FsPath, vm: &VirtualMachine) -> PyResult<IfIndex> {
-        let name = name.to_cstring(vm)?;
-
-        let ret = unsafe { c::if_nametoindex(name.as_ptr() as _) };
-        if ret == 0 {
-            Err(vm.new_os_error("no interface with this name".to_owned()))
-        } else {
-            Ok(ret)
-        }
-    }
-
-    #[cfg(not(target_os = "redox"))]
-    #[pyfunction]
-    fn if_indextoname(index: IfIndex, vm: &VirtualMachine) -> PyResult<String> {
-        let mut buf = [0; c::IF_NAMESIZE + 1];
-        let ret = unsafe { c::if_indextoname(index, buf.as_mut_ptr()) };
-        if ret.is_null() {
-            Err(crate::vm::stdlib::os::errno_err(vm))
-        } else {
-            let buf = unsafe { ffi::CStr::from_ptr(buf.as_ptr() as _) };
-            Ok(buf.to_string_lossy().into_owned())
-        }
-    }
-
-    #[cfg(any(
-        windows,
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "fuchsia",
-        target_os = "ios",
-        target_os = "linux",
-        target_os = "macos",
-        target_os = "netbsd",
-        target_os = "openbsd",
-    ))]
-    #[pyfunction]
-    fn if_nameindex(vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        #[cfg(not(windows))]
-        {
-            let list = nix::net::if_::if_nameindex()
-                .map_err(|err| err.into_pyexception(vm))?
-                .to_slice()
-                .iter()
-                .map(|iface| {
-                    let tup: (u32, String) =
-                        (iface.index(), iface.name().to_string_lossy().into_owned());
-                    tup.to_pyobject(vm)
-                })
-                .collect();
-
-            Ok(list)
-        }
-        #[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))?;
-            let list = table.as_slice().iter().map(|entry| {
-                let name =
-                    get_name(&entry.InterfaceLuid).map_err(|err| err.into_pyexception(vm))?;
-                let tup = (entry.InterfaceIndex, name.to_string_lossy());
-                Ok(tup.to_pyobject(vm))
-            });
-            let list = list.collect::<PyResult<_>>()?;
-            return Ok(list);
-
-            fn get_name(luid: &NET_LUID_LH) -> io::Result<widestring::WideCString> {
-                let mut buf = [0; c::IF_NAMESIZE + 1];
-                let ret = unsafe {
-                    IpHelper::ConvertInterfaceLuidToNameW(luid, buf.as_mut_ptr(), buf.len())
-                };
-                if ret == 0 {
-                    Ok(widestring::WideCString::from_ustr_truncate(
-                        widestring::WideStr::from_slice(&buf[..]),
-                    ))
-                } else {
-                    Err(io::Error::from_raw_os_error(ret as i32))
-                }
-            }
-            struct MibTable {
-                ptr: ptr::NonNull<IpHelper::MIB_IF_TABLE2>,
-            }
-            impl MibTable {
-                fn get_raw() -> io::Result<Self> {
-                    let mut ptr = ptr::null_mut();
-                    let ret = unsafe { IpHelper::GetIfTable2Ex(IpHelper::MibIfTableRaw, &mut ptr) };
-                    if ret == 0 {
-                        let ptr = unsafe { ptr::NonNull::new_unchecked(ptr) };
-                        Ok(Self { ptr })
-                    } else {
-                        Err(io::Error::from_raw_os_error(ret as i32))
-                    }
-                }
-            }
-            impl MibTable {
-                fn as_slice(&self) -> &[IpHelper::MIB_IF_ROW2] {
-                    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)
-                    }
-                }
-            }
-            impl Drop for MibTable {
-                fn drop(&mut self) {
-                    unsafe { IpHelper::FreeMibTable(self.ptr.as_ptr() as *mut _) };
-                }
-            }
-        }
-    }
-
-    fn get_addr(
-        vm: &VirtualMachine,
-        pyname: PyStrRef,
-        af: i32,
-    ) -> Result<SocketAddr, IoOrPyException> {
-        let name = pyname.as_str();
-        if name.is_empty() {
-            let hints = dns_lookup::AddrInfoHints {
-                address: af,
-                socktype: c::SOCK_DGRAM,
-                flags: c::AI_PASSIVE,
-                protocol: 0,
-            };
-            let mut res = dns_lookup::getaddrinfo(None, Some("0"), Some(hints))
-                .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?;
-            let ainfo = res.next().unwrap()?;
-            if res.next().is_some() {
-                return Err(vm
-                    .new_os_error("wildcard resolved to multiple address".to_owned())
-                    .into());
-            }
-            return Ok(ainfo.sockaddr);
-        }
-        if name == "255.255.255.255" || name == "<broadcast>" {
-            match af {
-                c::AF_INET | c::AF_UNSPEC => {}
-                _ => {
-                    return Err(vm
-                        .new_os_error("address family mismatched".to_owned())
-                        .into());
-                }
-            }
-            return Ok(SocketAddr::V4(net::SocketAddrV4::new(
-                c::INADDR_BROADCAST.into(),
-                0,
-            )));
-        }
-        if let c::AF_INET | c::AF_UNSPEC = af {
-            if let Ok(addr) = name.parse::<Ipv4Addr>() {
-                return Ok(SocketAddr::V4(net::SocketAddrV4::new(addr, 0)));
-            }
-        }
-        if matches!(af, c::AF_INET | c::AF_UNSPEC) && !name.contains('%') {
-            if let Ok(addr) = name.parse::<Ipv6Addr>() {
-                return Ok(SocketAddr::V6(net::SocketAddrV6::new(addr, 0, 0, 0)));
-            }
-        }
-        let hints = dns_lookup::AddrInfoHints {
-            address: af,
-            ..Default::default()
-        };
-        let name = vm
-            .state
-            .codec_registry
-            .encode_text(pyname, "idna", None, vm)?;
-        let name = std::str::from_utf8(name.as_bytes())
-            .map_err(|_| vm.new_runtime_error("idna output is not utf8"))?;
-        let mut res = dns_lookup::getaddrinfo(Some(name), None, Some(hints))
-            .map_err(|e| convert_socket_error(vm, e, SocketError::GaiError))?;
-        Ok(res.next().unwrap().map(|ainfo| ainfo.sockaddr)?)
-    }
-
-    fn sock_from_raw(fileno: RawSocket, vm: &VirtualMachine) -> PyResult<Socket> {
-        let invalid = {
-            cfg_if::cfg_if! {
-                if #[cfg(windows)] {
-                    fileno == INVALID_SOCKET
-                } else {
-                    fileno < 0
-                }
-            }
-        };
-        if invalid {
-            return Err(vm.new_value_error("negative file descriptor"));
-        }
-        Ok(unsafe { sock_from_raw_unchecked(fileno) })
-    }
-    /// SAFETY: fileno must not be equal to INVALID_SOCKET
-    unsafe fn sock_from_raw_unchecked(fileno: RawSocket) -> Socket {
-        #[cfg(unix)]
-        {
-            use std::os::unix::io::FromRawFd;
-            unsafe { Socket::from_raw_fd(fileno) }
-        }
-        #[cfg(windows)]
-        {
-            use std::os::windows::io::FromRawSocket;
-            unsafe { Socket::from_raw_socket(fileno) }
-        }
-    }
-    pub(super) fn sock_fileno(sock: &Socket) -> RawSocket {
-        #[cfg(unix)]
-        {
-            use std::os::unix::io::AsRawFd;
-            sock.as_raw_fd()
-        }
-        #[cfg(windows)]
-        {
-            use std::os::windows::io::AsRawSocket;
-            sock.as_raw_socket()
-        }
-    }
-    fn into_sock_fileno(sock: Socket) -> RawSocket {
-        #[cfg(unix)]
-        {
-            use std::os::unix::io::IntoRawFd;
-            sock.into_raw_fd()
-        }
-        #[cfg(windows)]
-        {
-            use std::os::windows::io::IntoRawSocket;
-            sock.into_raw_socket()
-        }
-    }
-
-    pub(super) const INVALID_SOCKET: RawSocket = {
-        #[cfg(unix)]
-        {
-            -1
-        }
-        #[cfg(windows)]
-        {
-            windows_sys::Win32::Networking::WinSock::INVALID_SOCKET as RawSocket
-        }
-    };
-
-    fn convert_socket_error(
-        vm: &VirtualMachine,
-        err: dns_lookup::LookupError,
-        err_kind: SocketError,
-    ) -> IoOrPyException {
-        if let dns_lookup::LookupErrorKind::System = err.kind() {
-            return io::Error::from(err).into();
-        }
-        let strerr = {
-            #[cfg(unix)]
-            {
-                let s = match err_kind {
-                    SocketError::GaiError => unsafe {
-                        ffi::CStr::from_ptr(libc::gai_strerror(err.error_num()))
-                    },
-                    SocketError::HError => unsafe {
-                        ffi::CStr::from_ptr(libc::hstrerror(err.error_num()))
-                    },
-                };
-                s.to_str().unwrap()
-            }
-            #[cfg(windows)]
-            {
-                "getaddrinfo failed"
-            }
-        };
-        let exception_cls = match err_kind {
-            SocketError::GaiError => gaierror(vm),
-            SocketError::HError => herror(vm),
-        };
-        vm.new_exception(
-            exception_cls,
-            vec![vm.new_pyobj(err.error_num()), vm.ctx.new_str(strerr).into()],
-        )
-        .into()
-    }
-
-    fn timeout_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
-        timeout_error_msg(vm, "timed out".to_owned())
-    }
-    pub(crate) fn timeout_error_msg(vm: &VirtualMachine, msg: String) -> PyBaseExceptionRef {
-        vm.new_exception_msg(timeout(vm), msg)
-    }
-
-    fn get_ipv6_addr_str(ipv6: Ipv6Addr) -> String {
-        match ipv6.to_ipv4() {
-            // instead of "::0.0.ddd.ddd" it's "::xxxx"
-            Some(v4) if !ipv6.is_unspecified() && matches!(v4.octets(), [0, 0, _, _]) => {
-                format!("::{:x}", u32::from(v4))
-            }
-            _ => ipv6.to_string(),
-        }
-    }
-
-    pub(crate) struct Deadline {
-        deadline: Instant,
-    }
-
-    impl Deadline {
-        fn new(timeout: Duration) -> Self {
-            Self {
-                deadline: Instant::now() + timeout,
-            }
-        }
-        fn time_until(&self) -> Result<Duration, IoOrPyException> {
-            self.deadline
-                .checked_duration_since(Instant::now())
-                // past the deadline already
-                .ok_or(IoOrPyException::Timeout)
-        }
-    }
-
-    static DEFAULT_TIMEOUT: AtomicCell<f64> = AtomicCell::new(-1.0);
-
-    #[pyfunction]
-    fn getdefaulttimeout() -> Option<f64> {
-        let timeout = DEFAULT_TIMEOUT.load();
-        if timeout >= 0.0 { Some(timeout) } else { None }
-    }
-
-    #[pyfunction]
-    fn setdefaulttimeout(timeout: Option<Duration>) {
-        DEFAULT_TIMEOUT.store(timeout.map_or(-1.0, |d| d.as_secs_f64()));
-    }
-
-    #[pyfunction]
-    fn dup(x: PyObjectRef, vm: &VirtualMachine) -> Result<RawSocket, IoOrPyException> {
-        let sock = get_raw_sock(x, vm)?;
-        let sock = std::mem::ManuallyDrop::new(sock_from_raw(sock, vm)?);
-        let newsock = sock.try_clone()?;
-        let fd = into_sock_fileno(newsock);
-        #[cfg(windows)]
-        crate::vm::stdlib::nt::raw_set_handle_inheritable(fd as _, false)?;
-        Ok(fd)
-    }
-
-    #[pyfunction]
-    fn close(x: PyObjectRef, vm: &VirtualMachine) -> Result<(), IoOrPyException> {
-        Ok(close_inner(get_raw_sock(x, vm)?)?)
-    }
-
-    fn close_inner(x: RawSocket) -> io::Result<()> {
-        #[cfg(unix)]
-        use libc::close;
-        #[cfg(windows)]
-        use windows_sys::Win32::Networking::WinSock::closesocket as close;
-        let ret = unsafe { close(x as _) };
-        if ret < 0 {
-            let err = crate::common::os::last_os_error();
-            if err.raw_os_error() != Some(errcode!(ECONNRESET)) {
-                return Err(err);
-            }
-        }
-        Ok(())
-    }
-
-    enum SocketError {
-        HError,
-        GaiError,
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    fn checked_cmsg_len(len: usize) -> Option<usize> {
-        // SAFETY: CMSG_LEN is always safe
-        let cmsg_len = |length| unsafe { libc::CMSG_LEN(length) };
-        if len as u64 > (i32::MAX as u64 - cmsg_len(0) as u64) {
-            return None;
-        }
-        let res = cmsg_len(len as _) as usize;
-        if res > i32::MAX as usize || res < len {
-            return None;
-        }
-        Some(res)
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    fn checked_cmsg_space(len: usize) -> Option<usize> {
-        // SAFETY: CMSG_SPACE is always safe
-        let cmsg_space = |length| unsafe { libc::CMSG_SPACE(length) };
-        if len as u64 > (i32::MAX as u64 - cmsg_space(1) as u64) {
-            return None;
-        }
-        let res = cmsg_space(len as _) as usize;
-        if res > i32::MAX as usize || res < len {
-            return None;
-        }
-        Some(res)
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    #[pyfunction(name = "CMSG_LEN")]
-    fn cmsg_len(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
-        checked_cmsg_len(length)
-            .ok_or_else(|| vm.new_overflow_error("CMSG_LEN() argument out of range"))
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    #[pyfunction(name = "CMSG_SPACE")]
-    fn cmsg_space(length: usize, vm: &VirtualMachine) -> PyResult<usize> {
-        checked_cmsg_space(length)
-            .ok_or_else(|| vm.new_overflow_error("CMSG_SPACE() argument out of range"))
-    }
-}
diff --git a/stdlib/src/ssl.rs b/stdlib/src/ssl.rs
deleted file mode 100644
index 0e9de9c0dc..0000000000
--- a/stdlib/src/ssl.rs
+++ /dev/null
@@ -1,1563 +0,0 @@
-// spell-checker:disable
-
-use crate::vm::{PyRef, VirtualMachine, builtins::PyModule};
-use openssl_probe::ProbeResult;
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    // if openssl is vendored, it doesn't know the locations
-    // of system certificates - cache the probe result now.
-    #[cfg(openssl_vendored)]
-    LazyLock::force(&PROBE);
-    _ssl::make_module(vm)
-}
-
-// define our own copy of ProbeResult so we can handle the vendor case
-// easily, without having to have a bunch of cfgs
-cfg_if::cfg_if! {
-    if #[cfg(openssl_vendored)] {
-        use std::sync::LazyLock;
-        static PROBE: LazyLock<ProbeResult> = LazyLock::new(openssl_probe::probe);
-        fn probe() -> &'static ProbeResult { &PROBE }
-    } else {
-        fn probe() -> &'static ProbeResult {
-            &ProbeResult { cert_file: None, cert_dir: None }
-        }
-    }
-}
-
-#[allow(non_upper_case_globals)]
-#[pymodule(with(ossl101, windows))]
-mod _ssl {
-    use super::{bio, probe};
-    use crate::{
-        common::{
-            ascii,
-            lock::{
-                PyMappedRwLockReadGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard,
-            },
-        },
-        socket::{self, PySocket},
-        vm::{
-            PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-            builtins::{PyBaseExceptionRef, PyStrRef, PyType, PyTypeRef, PyWeak},
-            convert::{ToPyException, ToPyObject},
-            exceptions,
-            function::{
-                ArgBytesLike, ArgCallable, ArgMemoryBuffer, ArgStrOrBytesLike, Either, FsPath,
-                OptionalArg,
-            },
-            types::Constructor,
-            utils::ToCString,
-        },
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use foreign_types_shared::{ForeignType, ForeignTypeRef};
-    use openssl::{
-        asn1::{Asn1Object, Asn1ObjectRef},
-        error::ErrorStack,
-        nid::Nid,
-        ssl::{self, SslContextBuilder, SslOptions, SslVerifyMode},
-        x509::{self, X509, X509Ref},
-    };
-    use openssl_sys as sys;
-    use rustpython_vm::ospath::OsPath;
-    use std::{
-        ffi::CStr,
-        fmt,
-        io::{Read, Write},
-        path::Path,
-        time::Instant,
-    };
-
-    // Constants
-    #[pyattr]
-    use sys::{
-        // TODO: so many more of these
-        SSL_AD_DECODE_ERROR as ALERT_DESCRIPTION_DECODE_ERROR,
-        SSL_AD_ILLEGAL_PARAMETER as ALERT_DESCRIPTION_ILLEGAL_PARAMETER,
-        SSL_AD_UNRECOGNIZED_NAME as ALERT_DESCRIPTION_UNRECOGNIZED_NAME,
-        // SSL_ERROR_INVALID_ERROR_CODE,
-        SSL_ERROR_SSL,
-        // SSL_ERROR_WANT_X509_LOOKUP,
-        SSL_ERROR_SYSCALL,
-        SSL_ERROR_WANT_CONNECT,
-        SSL_ERROR_WANT_READ,
-        SSL_ERROR_WANT_WRITE,
-        // #ifdef SSL_OP_SINGLE_ECDH_USE
-        // SSL_OP_SINGLE_ECDH_USE as OP_SINGLE_ECDH_USE
-        // #endif
-        // X509_V_FLAG_CRL_CHECK as VERIFY_CRL_CHECK_LEAF,
-        // sys::X509_V_FLAG_CRL_CHECK|sys::X509_V_FLAG_CRL_CHECK_ALL as VERIFY_CRL_CHECK_CHAIN
-        // X509_V_FLAG_X509_STRICT as VERIFY_X509_STRICT,
-        SSL_ERROR_ZERO_RETURN,
-        SSL_OP_CIPHER_SERVER_PREFERENCE as OP_CIPHER_SERVER_PREFERENCE,
-        SSL_OP_NO_SSLv2 as OP_NO_SSLv2,
-        SSL_OP_NO_SSLv3 as OP_NO_SSLv3,
-        SSL_OP_NO_TICKET as OP_NO_TICKET,
-        SSL_OP_NO_TLSv1 as OP_NO_TLSv1,
-        SSL_OP_SINGLE_DH_USE as OP_SINGLE_DH_USE,
-    };
-
-    // taken from CPython, should probably be kept up to date with their version if it ever changes
-    #[pyattr]
-    const _DEFAULT_CIPHERS: &str =
-        "DEFAULT:!aNULL:!eNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK";
-    // #[pyattr] PROTOCOL_SSLv2: u32 = SslVersion::Ssl2 as u32;  // unsupported
-    // #[pyattr] PROTOCOL_SSLv3: u32 = SslVersion::Ssl3 as u32;
-    #[pyattr]
-    const PROTOCOL_SSLv23: u32 = SslVersion::Tls as u32;
-    #[pyattr]
-    const PROTOCOL_TLS: u32 = SslVersion::Tls as u32;
-    #[pyattr]
-    const PROTOCOL_TLS_CLIENT: u32 = SslVersion::TlsClient as u32;
-    #[pyattr]
-    const PROTOCOL_TLS_SERVER: u32 = SslVersion::TlsServer as u32;
-    #[pyattr]
-    const PROTOCOL_TLSv1: u32 = SslVersion::Tls1 as u32;
-    #[pyattr]
-    const PROTO_MINIMUM_SUPPORTED: i32 = ProtoVersion::MinSupported as i32;
-    #[pyattr]
-    const PROTO_SSLv3: i32 = ProtoVersion::Ssl3 as i32;
-    #[pyattr]
-    const PROTO_TLSv1: i32 = ProtoVersion::Tls1 as i32;
-    #[pyattr]
-    const PROTO_TLSv1_1: i32 = ProtoVersion::Tls1_1 as i32;
-    #[pyattr]
-    const PROTO_TLSv1_2: i32 = ProtoVersion::Tls1_2 as i32;
-    #[pyattr]
-    const PROTO_TLSv1_3: i32 = ProtoVersion::Tls1_3 as i32;
-    #[pyattr]
-    const PROTO_MAXIMUM_SUPPORTED: i32 = ProtoVersion::MaxSupported as i32;
-    #[pyattr]
-    const OP_ALL: libc::c_ulong = (sys::SSL_OP_ALL & !sys::SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) as _;
-    #[pyattr]
-    const HAS_TLS_UNIQUE: bool = true;
-    #[pyattr]
-    const CERT_NONE: u32 = CertRequirements::None as u32;
-    #[pyattr]
-    const CERT_OPTIONAL: u32 = CertRequirements::Optional as u32;
-    #[pyattr]
-    const CERT_REQUIRED: u32 = CertRequirements::Required as u32;
-    #[pyattr]
-    const VERIFY_DEFAULT: u32 = 0;
-    #[pyattr]
-    const SSL_ERROR_EOF: u32 = 8; // custom for python
-    #[pyattr]
-    const HAS_SNI: bool = true;
-    #[pyattr]
-    const HAS_ECDH: bool = false;
-    #[pyattr]
-    const HAS_NPN: bool = false;
-    #[pyattr]
-    const HAS_ALPN: bool = true;
-    #[pyattr]
-    const HAS_SSLv2: bool = true;
-    #[pyattr]
-    const HAS_SSLv3: bool = true;
-    #[pyattr]
-    const HAS_TLSv1: bool = true;
-    #[pyattr]
-    const HAS_TLSv1_1: bool = true;
-    #[pyattr]
-    const HAS_TLSv1_2: bool = true;
-    #[pyattr]
-    const HAS_TLSv1_3: bool = cfg!(ossl111);
-
-    // the openssl version from the API headers
-
-    #[pyattr(name = "OPENSSL_VERSION")]
-    fn openssl_version(_vm: &VirtualMachine) -> &str {
-        openssl::version::version()
-    }
-    #[pyattr(name = "OPENSSL_VERSION_NUMBER")]
-    fn openssl_version_number(_vm: &VirtualMachine) -> i64 {
-        openssl::version::number()
-    }
-    #[pyattr(name = "OPENSSL_VERSION_INFO")]
-    fn openssl_version_info(_vm: &VirtualMachine) -> OpensslVersionInfo {
-        parse_version_info(openssl::version::number())
-    }
-
-    #[pyattr(name = "_OPENSSL_API_VERSION")]
-    fn _openssl_api_version(_vm: &VirtualMachine) -> OpensslVersionInfo {
-        let openssl_api_version = i64::from_str_radix(env!("OPENSSL_API_VERSION"), 16).unwrap();
-        parse_version_info(openssl_api_version)
-    }
-
-    /// An error occurred in the SSL implementation.
-    #[pyattr(name = "SSLError", once)]
-    fn ssl_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "ssl",
-            "SSLError",
-            Some(vec![vm.ctx.exceptions.os_error.to_owned()]),
-        )
-    }
-
-    /// A certificate could not be verified.
-    #[pyattr(name = "SSLCertVerificationError", once)]
-    fn ssl_cert_verification_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "ssl",
-            "SSLCertVerificationError",
-            Some(vec![
-                ssl_error(vm),
-                vm.ctx.exceptions.value_error.to_owned(),
-            ]),
-        )
-    }
-
-    /// SSL/TLS session closed cleanly.
-    #[pyattr(name = "SSLZeroReturnError", once)]
-    fn ssl_zero_return_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx
-            .new_exception_type("ssl", "SSLZeroReturnError", Some(vec![ssl_error(vm)]))
-    }
-
-    /// Non-blocking SSL socket needs to read more data before the requested operation can be completed.
-    #[pyattr(name = "SSLWantReadError", once)]
-    fn ssl_want_read_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx
-            .new_exception_type("ssl", "SSLWantReadError", Some(vec![ssl_error(vm)]))
-    }
-
-    /// Non-blocking SSL socket needs to write more data before the requested operation can be completed.
-    #[pyattr(name = "SSLWantWriteError", once)]
-    fn ssl_want_write_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx
-            .new_exception_type("ssl", "SSLWantWriteError", Some(vec![ssl_error(vm)]))
-    }
-
-    /// System error when attempting SSL operation.
-    #[pyattr(name = "SSLSyscallError", once)]
-    fn ssl_syscall_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx
-            .new_exception_type("ssl", "SSLSyscallError", Some(vec![ssl_error(vm)]))
-    }
-
-    /// SSL/TLS connection terminated abruptly.
-    #[pyattr(name = "SSLEOFError", once)]
-    fn ssl_eof_error(vm: &VirtualMachine) -> PyTypeRef {
-        PyType::new_simple_heap("ssl.SSLEOFError", &ssl_error(vm), &vm.ctx).unwrap()
-    }
-
-    type OpensslVersionInfo = (u8, u8, u8, u8, u8);
-    const fn parse_version_info(mut n: i64) -> OpensslVersionInfo {
-        let status = (n & 0xF) as u8;
-        n >>= 4;
-        let patch = (n & 0xFF) as u8;
-        n >>= 8;
-        let fix = (n & 0xFF) as u8;
-        n >>= 8;
-        let minor = (n & 0xFF) as u8;
-        n >>= 8;
-        let major = (n & 0xFF) as u8;
-        (major, minor, fix, patch, status)
-    }
-
-    #[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive, PartialEq)]
-    #[repr(i32)]
-    enum SslVersion {
-        Ssl2,
-        Ssl3 = 1,
-        Tls,
-        Tls1,
-        // TODO: Tls1_1, Tls1_2 ?
-        TlsClient = 0x10,
-        TlsServer,
-    }
-
-    #[derive(Copy, Clone, num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]
-    #[repr(i32)]
-    enum ProtoVersion {
-        MinSupported = -2,
-        Ssl3 = sys::SSL3_VERSION,
-        Tls1 = sys::TLS1_VERSION,
-        Tls1_1 = sys::TLS1_1_VERSION,
-        Tls1_2 = sys::TLS1_2_VERSION,
-        #[cfg(ossl111)]
-        Tls1_3 = sys::TLS1_3_VERSION,
-        #[cfg(not(ossl111))]
-        Tls1_3 = 0x304,
-        MaxSupported = -1,
-    }
-
-    #[derive(num_enum::IntoPrimitive, num_enum::TryFromPrimitive)]
-    #[repr(i32)]
-    enum CertRequirements {
-        None,
-        Optional,
-        Required,
-    }
-
-    #[derive(Debug, PartialEq)]
-    enum SslServerOrClient {
-        Client,
-        Server,
-    }
-
-    unsafe fn ptr2obj(ptr: *mut sys::ASN1_OBJECT) -> Option<Asn1Object> {
-        if ptr.is_null() {
-            None
-        } else {
-            Some(unsafe { Asn1Object::from_ptr(ptr) })
-        }
-    }
-
-    fn _txt2obj(s: &CStr, no_name: bool) -> Option<Asn1Object> {
-        unsafe { ptr2obj(sys::OBJ_txt2obj(s.as_ptr(), i32::from(no_name))) }
-    }
-    fn _nid2obj(nid: Nid) -> Option<Asn1Object> {
-        unsafe { ptr2obj(sys::OBJ_nid2obj(nid.as_raw())) }
-    }
-    fn obj2txt(obj: &Asn1ObjectRef, no_name: bool) -> Option<String> {
-        let no_name = i32::from(no_name);
-        let ptr = obj.as_ptr();
-        let b = unsafe {
-            let buflen = sys::OBJ_obj2txt(std::ptr::null_mut(), 0, ptr, no_name);
-            assert!(buflen >= 0);
-            if buflen == 0 {
-                return None;
-            }
-            let buflen = buflen as usize;
-            let mut buf = Vec::<u8>::with_capacity(buflen + 1);
-            let ret = sys::OBJ_obj2txt(
-                buf.as_mut_ptr() as *mut libc::c_char,
-                buf.capacity() as _,
-                ptr,
-                no_name,
-            );
-            assert!(ret >= 0);
-            // SAFETY: OBJ_obj2txt initialized the buffer successfully
-            buf.set_len(buflen);
-            buf
-        };
-        let s = String::from_utf8(b)
-            .unwrap_or_else(|e| String::from_utf8_lossy(e.as_bytes()).into_owned());
-        Some(s)
-    }
-
-    type PyNid = (libc::c_int, String, String, Option<String>);
-    fn obj2py(obj: &Asn1ObjectRef) -> PyNid {
-        let nid = obj.nid();
-        (
-            nid.as_raw(),
-            nid.short_name().unwrap().to_owned(),
-            nid.long_name().unwrap().to_owned(),
-            obj2txt(obj, true),
-        )
-    }
-
-    #[derive(FromArgs)]
-    struct Txt2ObjArgs {
-        txt: PyStrRef,
-        #[pyarg(any, default = false)]
-        name: bool,
-    }
-
-    #[pyfunction]
-    fn txt2obj(args: Txt2ObjArgs, vm: &VirtualMachine) -> PyResult<PyNid> {
-        _txt2obj(&args.txt.to_cstring(vm)?, !args.name)
-            .as_deref()
-            .map(obj2py)
-            .ok_or_else(|| vm.new_value_error(format!("unknown object '{}'", args.txt)))
-    }
-
-    #[pyfunction]
-    fn nid2obj(nid: libc::c_int, vm: &VirtualMachine) -> PyResult<PyNid> {
-        _nid2obj(Nid::from_raw(nid))
-            .as_deref()
-            .map(obj2py)
-            .ok_or_else(|| vm.new_value_error(format!("unknown NID {nid}")))
-    }
-
-    fn get_cert_file_dir() -> (&'static Path, &'static Path) {
-        let probe = probe();
-        // on windows, these should be utf8 strings
-        fn path_from_bytes(c: &CStr) -> &Path {
-            #[cfg(unix)]
-            {
-                use std::os::unix::ffi::OsStrExt;
-                std::ffi::OsStr::from_bytes(c.to_bytes()).as_ref()
-            }
-            #[cfg(windows)]
-            {
-                c.to_str().unwrap().as_ref()
-            }
-        }
-        let cert_file = probe.cert_file.as_deref().unwrap_or_else(|| {
-            path_from_bytes(unsafe { CStr::from_ptr(sys::X509_get_default_cert_file()) })
-        });
-        let cert_dir = probe.cert_dir.as_deref().unwrap_or_else(|| {
-            path_from_bytes(unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir()) })
-        });
-        (cert_file, cert_dir)
-    }
-
-    #[pyfunction]
-    fn get_default_verify_paths(
-        vm: &VirtualMachine,
-    ) -> PyResult<(&'static str, PyObjectRef, &'static str, PyObjectRef)> {
-        let cert_file_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_file_env()) }
-            .to_str()
-            .unwrap();
-        let cert_dir_env = unsafe { CStr::from_ptr(sys::X509_get_default_cert_dir_env()) }
-            .to_str()
-            .unwrap();
-        let (cert_file, cert_dir) = get_cert_file_dir();
-        let cert_file = OsPath::new_str(cert_file).filename(vm);
-        let cert_dir = OsPath::new_str(cert_dir).filename(vm);
-        Ok((cert_file_env, cert_file, cert_dir_env, cert_dir))
-    }
-
-    #[pyfunction(name = "RAND_status")]
-    fn rand_status() -> i32 {
-        unsafe { sys::RAND_status() }
-    }
-
-    #[pyfunction(name = "RAND_add")]
-    fn rand_add(string: ArgStrOrBytesLike, entropy: f64) {
-        let f = |b: &[u8]| {
-            for buf in b.chunks(libc::c_int::MAX as usize) {
-                unsafe { sys::RAND_add(buf.as_ptr() as *const _, buf.len() as _, entropy) }
-            }
-        };
-        f(&string.borrow_bytes())
-    }
-
-    #[pyfunction(name = "RAND_bytes")]
-    fn rand_bytes(n: i32, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        if n < 0 {
-            return Err(vm.new_value_error("num must be positive"));
-        }
-        let mut buf = vec![0; n as usize];
-        openssl::rand::rand_bytes(&mut buf).map_err(|e| convert_openssl_error(vm, e))?;
-        Ok(buf)
-    }
-
-    #[pyfunction(name = "RAND_pseudo_bytes")]
-    fn rand_pseudo_bytes(n: i32, vm: &VirtualMachine) -> PyResult<(Vec<u8>, bool)> {
-        if n < 0 {
-            return Err(vm.new_value_error("num must be positive"));
-        }
-        let mut buf = vec![0; n as usize];
-        let ret = unsafe { sys::RAND_bytes(buf.as_mut_ptr(), n) };
-        match ret {
-            0 | 1 => Ok((buf, ret == 1)),
-            _ => Err(convert_openssl_error(vm, ErrorStack::get())),
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(module = "ssl", name = "_SSLContext")]
-    #[derive(PyPayload)]
-    struct PySslContext {
-        ctx: PyRwLock<SslContextBuilder>,
-        check_hostname: AtomicCell<bool>,
-        protocol: SslVersion,
-        post_handshake_auth: PyMutex<bool>,
-    }
-
-    impl fmt::Debug for PySslContext {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.pad("_SSLContext")
-        }
-    }
-
-    fn builder_as_ctx(x: &SslContextBuilder) -> &ssl::SslContextRef {
-        unsafe { ssl::SslContextRef::from_ptr(x.as_ptr()) }
-    }
-
-    impl Constructor for PySslContext {
-        type Args = i32;
-
-        fn py_new(cls: PyTypeRef, proto_version: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let proto = SslVersion::try_from(proto_version)
-                .map_err(|_| vm.new_value_error("invalid protocol version"))?;
-            let method = match proto {
-                // SslVersion::Ssl3 => unsafe { ssl::SslMethod::from_ptr(sys::SSLv3_method()) },
-                SslVersion::Tls => ssl::SslMethod::tls(),
-                // TODO: Tls1_1, Tls1_2 ?
-                SslVersion::TlsClient => ssl::SslMethod::tls_client(),
-                SslVersion::TlsServer => ssl::SslMethod::tls_server(),
-                _ => return Err(vm.new_value_error("invalid protocol version")),
-            };
-            let mut builder =
-                SslContextBuilder::new(method).map_err(|e| convert_openssl_error(vm, e))?;
-
-            #[cfg(target_os = "android")]
-            android::load_client_ca_list(vm, &mut builder)?;
-
-            let check_hostname = proto == SslVersion::TlsClient;
-            builder.set_verify(if check_hostname {
-                SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
-            } else {
-                SslVerifyMode::NONE
-            });
-
-            let mut options = SslOptions::ALL & !SslOptions::DONT_INSERT_EMPTY_FRAGMENTS;
-            if proto != SslVersion::Ssl2 {
-                options |= SslOptions::NO_SSLV2;
-            }
-            if proto != SslVersion::Ssl3 {
-                options |= SslOptions::NO_SSLV3;
-            }
-            options |= SslOptions::NO_COMPRESSION;
-            options |= SslOptions::CIPHER_SERVER_PREFERENCE;
-            options |= SslOptions::SINGLE_DH_USE;
-            options |= SslOptions::SINGLE_ECDH_USE;
-            builder.set_options(options);
-
-            let mode = ssl::SslMode::ACCEPT_MOVING_WRITE_BUFFER | ssl::SslMode::AUTO_RETRY;
-            builder.set_mode(mode);
-
-            #[cfg(ossl111)]
-            unsafe {
-                sys::SSL_CTX_set_post_handshake_auth(builder.as_ptr(), 0);
-            }
-
-            builder
-                .set_session_id_context(b"Python")
-                .map_err(|e| convert_openssl_error(vm, e))?;
-
-            PySslContext {
-                ctx: PyRwLock::new(builder),
-                check_hostname: AtomicCell::new(check_hostname),
-                protocol: proto,
-                post_handshake_auth: PyMutex::new(false),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-        }
-    }
-
-    #[pyclass(flags(BASETYPE), with(Constructor))]
-    impl PySslContext {
-        fn builder(&self) -> PyRwLockWriteGuard<'_, SslContextBuilder> {
-            self.ctx.write()
-        }
-        fn ctx(&self) -> PyMappedRwLockReadGuard<'_, ssl::SslContextRef> {
-            PyRwLockReadGuard::map(self.ctx.read(), builder_as_ctx)
-        }
-
-        #[pygetset]
-        fn post_handshake_auth(&self) -> bool {
-            *self.post_handshake_auth.lock()
-        }
-        #[pygetset(setter)]
-        fn set_post_handshake_auth(
-            &self,
-            value: Option<PyObjectRef>,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            let value = value.ok_or_else(|| vm.new_attribute_error("cannot delete attribute"))?;
-            *self.post_handshake_auth.lock() = value.is_true(vm)?;
-            Ok(())
-        }
-
-        #[pymethod]
-        fn set_ciphers(&self, cipherlist: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-            let ciphers = cipherlist.as_str();
-            if ciphers.contains('\0') {
-                return Err(exceptions::cstring_error(vm));
-            }
-            self.builder().set_cipher_list(ciphers).map_err(|_| {
-                vm.new_exception_msg(ssl_error(vm), "No cipher can be selected.".to_owned())
-            })
-        }
-
-        #[pygetset]
-        fn options(&self) -> libc::c_ulong {
-            self.ctx.read().options().bits() as _
-        }
-        #[pygetset(setter)]
-        fn set_options(&self, opts: libc::c_ulong) {
-            self.builder()
-                .set_options(SslOptions::from_bits_truncate(opts as _));
-        }
-        #[pygetset]
-        fn protocol(&self) -> i32 {
-            self.protocol as i32
-        }
-        #[pygetset]
-        fn verify_mode(&self) -> i32 {
-            let mode = self.ctx().verify_mode();
-            if mode == SslVerifyMode::NONE {
-                CertRequirements::None.into()
-            } else if mode == SslVerifyMode::PEER {
-                CertRequirements::Optional.into()
-            } else if mode == SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT {
-                CertRequirements::Required.into()
-            } else {
-                unreachable!()
-            }
-        }
-        #[pygetset(setter)]
-        fn set_verify_mode(&self, cert: i32, vm: &VirtualMachine) -> PyResult<()> {
-            let mut ctx = self.builder();
-            let cert_req = CertRequirements::try_from(cert)
-                .map_err(|_| vm.new_value_error("invalid value for verify_mode"))?;
-            let mode = match cert_req {
-                CertRequirements::None if self.check_hostname.load() => {
-                    return Err(vm.new_value_error(
-                        "Cannot set verify_mode to CERT_NONE when check_hostname is enabled.",
-                    ));
-                }
-                CertRequirements::None => SslVerifyMode::NONE,
-                CertRequirements::Optional => SslVerifyMode::PEER,
-                CertRequirements::Required => {
-                    SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT
-                }
-            };
-            ctx.set_verify(mode);
-            Ok(())
-        }
-        #[pygetset]
-        fn check_hostname(&self) -> bool {
-            self.check_hostname.load()
-        }
-        #[pygetset(setter)]
-        fn set_check_hostname(&self, ch: bool) {
-            let mut ctx = self.builder();
-            if ch && builder_as_ctx(&ctx).verify_mode() == SslVerifyMode::NONE {
-                ctx.set_verify(SslVerifyMode::PEER | SslVerifyMode::FAIL_IF_NO_PEER_CERT);
-            }
-            self.check_hostname.store(ch);
-        }
-
-        #[pymethod]
-        fn set_default_verify_paths(&self, vm: &VirtualMachine) -> PyResult<()> {
-            cfg_if::cfg_if! {
-                if #[cfg(openssl_vendored)] {
-                    let (cert_file, cert_dir) = get_cert_file_dir();
-                    self.builder()
-                        .load_verify_locations(Some(cert_file), Some(cert_dir))
-                        .map_err(|e| convert_openssl_error(vm, e))
-                } else {
-                    self.builder()
-                        .set_default_verify_paths()
-                        .map_err(|e| convert_openssl_error(vm, e))
-                }
-            }
-        }
-
-        #[pymethod]
-        fn _set_alpn_protocols(&self, protos: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
-            #[cfg(ossl102)]
-            {
-                let mut ctx = self.builder();
-                let server = protos.with_ref(|pbuf| {
-                    if pbuf.len() > libc::c_uint::MAX as usize {
-                        return Err(vm.new_overflow_error(format!(
-                            "protocols longer than {} bytes",
-                            libc::c_uint::MAX
-                        )));
-                    }
-                    ctx.set_alpn_protos(pbuf)
-                        .map_err(|e| convert_openssl_error(vm, e))?;
-                    Ok(pbuf.to_vec())
-                })?;
-                ctx.set_alpn_select_callback(move |_, client| {
-                    let proto =
-                        ssl::select_next_proto(&server, client).ok_or(ssl::AlpnError::NOACK)?;
-                    let pos = memchr::memmem::find(client, proto)
-                        .expect("selected alpn proto should be present in client protos");
-                    Ok(&client[pos..proto.len()])
-                });
-                Ok(())
-            }
-            #[cfg(not(ossl102))]
-            {
-                Err(vm.new_not_implemented_error(
-                    "The NPN extension requires OpenSSL 1.0.1 or later.",
-                ))
-            }
-        }
-
-        #[pymethod]
-        fn load_verify_locations(
-            &self,
-            args: LoadVerifyLocationsArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            if let (None, None, None) = (&args.cafile, &args.capath, &args.cadata) {
-                return Err(vm.new_type_error("cafile, capath and cadata cannot be all omitted"));
-            }
-            if let Some(cafile) = &args.cafile {
-                cafile.ensure_no_nul(vm)?
-            }
-            if let Some(capath) = &args.capath {
-                capath.ensure_no_nul(vm)?
-            }
-
-            #[cold]
-            fn invalid_cadata(vm: &VirtualMachine) -> PyBaseExceptionRef {
-                vm.new_type_error("cadata should be an ASCII string or a bytes-like object")
-            }
-
-            let mut ctx = self.builder();
-
-            // validate cadata type and load cadata
-            if let Some(cadata) = args.cadata {
-                let certs = match cadata {
-                    Either::A(s) => {
-                        if !s.is_ascii() {
-                            return Err(invalid_cadata(vm));
-                        }
-                        X509::stack_from_pem(s.as_bytes())
-                    }
-                    Either::B(b) => b.with_ref(x509_stack_from_der),
-                };
-                let certs = certs.map_err(|e| convert_openssl_error(vm, e))?;
-                let store = ctx.cert_store_mut();
-                for cert in certs {
-                    store
-                        .add_cert(cert)
-                        .map_err(|e| convert_openssl_error(vm, e))?;
-                }
-            }
-
-            if args.cafile.is_some() || args.capath.is_some() {
-                ctx.load_verify_locations(
-                    args.cafile.as_ref().map(|s| s.as_str().as_ref()),
-                    args.capath.as_ref().map(|s| s.as_str().as_ref()),
-                )
-                .map_err(|e| convert_openssl_error(vm, e))?;
-            }
-
-            Ok(())
-        }
-
-        #[pymethod]
-        fn get_ca_certs(
-            &self,
-            binary_form: OptionalArg<bool>,
-            vm: &VirtualMachine,
-        ) -> PyResult<Vec<PyObjectRef>> {
-            let binary_form = binary_form.unwrap_or(false);
-            let ctx = self.ctx();
-            #[cfg(ossl300)]
-            let certs = ctx.cert_store().all_certificates();
-            #[cfg(not(ossl300))]
-            let certs = ctx.cert_store().objects().iter().filter_map(|x| x.x509());
-            let certs = certs
-                .into_iter()
-                .map(|ref cert| cert_to_py(vm, cert, binary_form))
-                .collect::<Result<Vec<_>, _>>()?;
-            Ok(certs)
-        }
-
-        #[pymethod]
-        fn load_cert_chain(&self, args: LoadCertChainArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let LoadCertChainArgs {
-                certfile,
-                keyfile,
-                password,
-            } = args;
-            // TODO: requires passing a callback to C
-            if password.is_some() {
-                return Err(vm.new_not_implemented_error("password arg not yet supported"));
-            }
-            let mut ctx = self.builder();
-            let key_path = keyfile.map(|path| path.to_path_buf(vm)).transpose()?;
-            let cert_path = certfile.to_path_buf(vm)?;
-            ctx.set_certificate_chain_file(&cert_path)
-                .and_then(|()| {
-                    ctx.set_private_key_file(
-                        key_path.as_ref().unwrap_or(&cert_path),
-                        ssl::SslFiletype::PEM,
-                    )
-                })
-                .and_then(|()| ctx.check_private_key())
-                .map_err(|e| convert_openssl_error(vm, e))
-        }
-
-        #[pymethod]
-        fn _wrap_socket(
-            zelf: PyRef<Self>,
-            args: WrapSocketArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<PySslSocket> {
-            let mut ssl = ssl::Ssl::new(&zelf.ctx()).map_err(|e| convert_openssl_error(vm, e))?;
-
-            let socket_type = if args.server_side {
-                ssl.set_accept_state();
-                SslServerOrClient::Server
-            } else {
-                ssl.set_connect_state();
-                SslServerOrClient::Client
-            };
-
-            if let Some(hostname) = &args.server_hostname {
-                let hostname = hostname.as_str();
-                if hostname.is_empty() || hostname.starts_with('.') {
-                    return Err(vm.new_value_error(
-                        "server_hostname cannot be an empty string or start with a leading dot.",
-                    ));
-                }
-                let ip = hostname.parse::<std::net::IpAddr>();
-                if ip.is_err() {
-                    ssl.set_hostname(hostname)
-                        .map_err(|e| convert_openssl_error(vm, e))?;
-                }
-                if zelf.check_hostname.load() {
-                    if let Ok(ip) = ip {
-                        ssl.param_mut()
-                            .set_ip(ip)
-                            .map_err(|e| convert_openssl_error(vm, e))?;
-                    } else {
-                        ssl.param_mut()
-                            .set_host(hostname)
-                            .map_err(|e| convert_openssl_error(vm, e))?;
-                    }
-                }
-            }
-
-            let stream = ssl::SslStream::new(ssl, SocketStream(args.sock.clone()))
-                .map_err(|e| convert_openssl_error(vm, e))?;
-
-            // TODO: use this
-            let _ = args.session;
-
-            Ok(PySslSocket {
-                ctx: zelf,
-                stream: PyRwLock::new(stream),
-                socket_type,
-                server_hostname: args.server_hostname,
-                owner: PyRwLock::new(args.owner.map(|o| o.downgrade(None, vm)).transpose()?),
-            })
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct WrapSocketArgs {
-        sock: PyRef<PySocket>,
-        server_side: bool,
-        #[pyarg(any, default)]
-        server_hostname: Option<PyStrRef>,
-        #[pyarg(named, default)]
-        owner: Option<PyObjectRef>,
-        #[pyarg(named, default)]
-        session: Option<PyObjectRef>,
-    }
-
-    #[derive(FromArgs)]
-    struct LoadVerifyLocationsArgs {
-        #[pyarg(any, default)]
-        cafile: Option<PyStrRef>,
-        #[pyarg(any, default)]
-        capath: Option<PyStrRef>,
-        #[pyarg(any, default)]
-        cadata: Option<Either<PyStrRef, ArgBytesLike>>,
-    }
-
-    #[derive(FromArgs)]
-    struct LoadCertChainArgs {
-        certfile: FsPath,
-        #[pyarg(any, optional)]
-        keyfile: Option<FsPath>,
-        #[pyarg(any, optional)]
-        password: Option<Either<PyStrRef, ArgCallable>>,
-    }
-
-    // Err is true if the socket is blocking
-    type SocketDeadline = Result<Instant, bool>;
-
-    enum SelectRet {
-        Nonblocking,
-        TimedOut,
-        IsBlocking,
-        Closed,
-        Ok,
-    }
-
-    #[derive(Clone, Copy)]
-    enum SslNeeds {
-        Read,
-        Write,
-    }
-
-    struct SocketStream(PyRef<PySocket>);
-
-    impl SocketStream {
-        fn timeout_deadline(&self) -> SocketDeadline {
-            self.0.get_timeout().map(|d| Instant::now() + d)
-        }
-
-        fn select(&self, needs: SslNeeds, deadline: &SocketDeadline) -> SelectRet {
-            let sock = match self.0.sock_opt() {
-                Some(s) => s,
-                None => return SelectRet::Closed,
-            };
-            let deadline = match &deadline {
-                Ok(deadline) => match deadline.checked_duration_since(Instant::now()) {
-                    Some(deadline) => deadline,
-                    None => return SelectRet::TimedOut,
-                },
-                Err(true) => return SelectRet::IsBlocking,
-                Err(false) => return SelectRet::Nonblocking,
-            };
-            let res = socket::sock_select(
-                &sock,
-                match needs {
-                    SslNeeds::Read => socket::SelectKind::Read,
-                    SslNeeds::Write => socket::SelectKind::Write,
-                },
-                Some(deadline),
-            );
-            match res {
-                Ok(true) => SelectRet::TimedOut,
-                _ => SelectRet::Ok,
-            }
-        }
-
-        fn socket_needs(
-            &self,
-            err: &ssl::Error,
-            deadline: &SocketDeadline,
-        ) -> (Option<SslNeeds>, SelectRet) {
-            let needs = match err.code() {
-                ssl::ErrorCode::WANT_READ => Some(SslNeeds::Read),
-                ssl::ErrorCode::WANT_WRITE => Some(SslNeeds::Write),
-                _ => None,
-            };
-            let state = needs.map_or(SelectRet::Ok, |needs| self.select(needs, deadline));
-            (needs, state)
-        }
-    }
-
-    fn socket_closed_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
-        vm.new_exception_msg(
-            ssl_error(vm),
-            "Underlying socket has been closed.".to_owned(),
-        )
-    }
-
-    #[pyattr]
-    #[pyclass(module = "ssl", name = "_SSLSocket", traverse)]
-    #[derive(PyPayload)]
-    struct PySslSocket {
-        ctx: PyRef<PySslContext>,
-        #[pytraverse(skip)]
-        stream: PyRwLock<ssl::SslStream<SocketStream>>,
-        #[pytraverse(skip)]
-        socket_type: SslServerOrClient,
-        server_hostname: Option<PyStrRef>,
-        owner: PyRwLock<Option<PyRef<PyWeak>>>,
-    }
-
-    impl fmt::Debug for PySslSocket {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.pad("_SSLSocket")
-        }
-    }
-
-    #[pyclass]
-    impl PySslSocket {
-        #[pygetset]
-        fn owner(&self) -> Option<PyObjectRef> {
-            self.owner.read().as_ref().and_then(|weak| weak.upgrade())
-        }
-        #[pygetset(setter)]
-        fn set_owner(&self, owner: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-            let mut lock = self.owner.write();
-            lock.take();
-            *lock = Some(owner.downgrade(None, vm)?);
-            Ok(())
-        }
-        #[pygetset]
-        fn server_side(&self) -> bool {
-            self.socket_type == SslServerOrClient::Server
-        }
-        #[pygetset]
-        fn context(&self) -> PyRef<PySslContext> {
-            self.ctx.clone()
-        }
-        #[pygetset]
-        fn server_hostname(&self) -> Option<PyStrRef> {
-            self.server_hostname.clone()
-        }
-
-        #[pymethod]
-        fn getpeercert(
-            &self,
-            binary: OptionalArg<bool>,
-            vm: &VirtualMachine,
-        ) -> PyResult<Option<PyObjectRef>> {
-            let binary = binary.unwrap_or(false);
-            let stream = self.stream.read();
-            if !stream.ssl().is_init_finished() {
-                return Err(vm.new_value_error("handshake not done yet"));
-            }
-            stream
-                .ssl()
-                .peer_certificate()
-                .map(|cert| cert_to_py(vm, &cert, binary))
-                .transpose()
-        }
-
-        #[pymethod]
-        fn version(&self) -> Option<&'static str> {
-            let v = self.stream.read().ssl().version_str();
-            if v == "unknown" { None } else { Some(v) }
-        }
-
-        #[pymethod]
-        fn cipher(&self) -> Option<CipherTuple> {
-            self.stream
-                .read()
-                .ssl()
-                .current_cipher()
-                .map(cipher_to_tuple)
-        }
-
-        #[cfg(osslconf = "OPENSSL_NO_COMP")]
-        #[pymethod]
-        fn compression(&self) -> Option<&'static str> {
-            None
-        }
-        #[cfg(not(osslconf = "OPENSSL_NO_COMP"))]
-        #[pymethod]
-        fn compression(&self) -> Option<&'static str> {
-            let stream = self.stream.read();
-            let comp_method = unsafe { sys::SSL_get_current_compression(stream.ssl().as_ptr()) };
-            if comp_method.is_null() {
-                return None;
-            }
-            let typ = unsafe { sys::COMP_get_type(comp_method) };
-            let nid = Nid::from_raw(typ);
-            if nid == Nid::UNDEF {
-                return None;
-            }
-            nid.short_name().ok()
-        }
-
-        #[pymethod]
-        fn do_handshake(&self, vm: &VirtualMachine) -> PyResult<()> {
-            let mut stream = self.stream.write();
-            let timeout = stream.get_ref().timeout_deadline();
-            loop {
-                let err = match stream.do_handshake() {
-                    Ok(()) => return Ok(()),
-                    Err(e) => e,
-                };
-                let (needs, state) = stream.get_ref().socket_needs(&err, &timeout);
-                match state {
-                    SelectRet::TimedOut => {
-                        return Err(socket::timeout_error_msg(
-                            vm,
-                            "The handshake operation timed out".to_owned(),
-                        ));
-                    }
-                    SelectRet::Closed => return Err(socket_closed_error(vm)),
-                    SelectRet::Nonblocking => {}
-                    _ => {
-                        if needs.is_some() {
-                            continue;
-                        }
-                    }
-                }
-                return Err(convert_ssl_error(vm, err));
-            }
-        }
-
-        #[pymethod]
-        fn write(&self, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult<usize> {
-            let mut stream = self.stream.write();
-            let data = data.borrow_buf();
-            let data = &*data;
-            let timeout = stream.get_ref().timeout_deadline();
-            let state = stream.get_ref().select(SslNeeds::Write, &timeout);
-            match state {
-                SelectRet::TimedOut => {
-                    return Err(socket::timeout_error_msg(
-                        vm,
-                        "The write operation timed out".to_owned(),
-                    ));
-                }
-                SelectRet::Closed => return Err(socket_closed_error(vm)),
-                _ => {}
-            }
-            loop {
-                let err = match stream.ssl_write(data) {
-                    Ok(len) => return Ok(len),
-                    Err(e) => e,
-                };
-                let (needs, state) = stream.get_ref().socket_needs(&err, &timeout);
-                match state {
-                    SelectRet::TimedOut => {
-                        return Err(socket::timeout_error_msg(
-                            vm,
-                            "The write operation timed out".to_owned(),
-                        ));
-                    }
-                    SelectRet::Closed => return Err(socket_closed_error(vm)),
-                    SelectRet::Nonblocking => {}
-                    _ => {
-                        if needs.is_some() {
-                            continue;
-                        }
-                    }
-                }
-                return Err(convert_ssl_error(vm, err));
-            }
-        }
-
-        #[pymethod]
-        fn read(
-            &self,
-            n: usize,
-            buffer: OptionalArg<ArgMemoryBuffer>,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            let mut stream = self.stream.write();
-            let mut inner_buffer = if let OptionalArg::Present(buffer) = &buffer {
-                Either::A(buffer.borrow_buf_mut())
-            } else {
-                Either::B(vec![0u8; n])
-            };
-            let buf = match &mut inner_buffer {
-                Either::A(b) => &mut **b,
-                Either::B(b) => b.as_mut_slice(),
-            };
-            let buf = match buf.get_mut(..n) {
-                Some(b) => b,
-                None => buf,
-            };
-            let timeout = stream.get_ref().timeout_deadline();
-            let count = loop {
-                let err = match stream.ssl_read(buf) {
-                    Ok(count) => break count,
-                    Err(e) => e,
-                };
-                if err.code() == ssl::ErrorCode::ZERO_RETURN
-                    && stream.get_shutdown() == ssl::ShutdownState::RECEIVED
-                {
-                    break 0;
-                }
-                let (needs, state) = stream.get_ref().socket_needs(&err, &timeout);
-                match state {
-                    SelectRet::TimedOut => {
-                        return Err(socket::timeout_error_msg(
-                            vm,
-                            "The read operation timed out".to_owned(),
-                        ));
-                    }
-                    SelectRet::Nonblocking => {}
-                    _ => {
-                        if needs.is_some() {
-                            continue;
-                        }
-                    }
-                }
-                return Err(convert_ssl_error(vm, err));
-            };
-            let ret = match inner_buffer {
-                Either::A(_buf) => vm.ctx.new_int(count).into(),
-                Either::B(mut buf) => {
-                    buf.truncate(n);
-                    buf.shrink_to_fit();
-                    vm.ctx.new_bytes(buf).into()
-                }
-            };
-            Ok(ret)
-        }
-    }
-
-    #[track_caller]
-    fn convert_openssl_error(vm: &VirtualMachine, err: ErrorStack) -> PyBaseExceptionRef {
-        let cls = ssl_error(vm);
-        match err.errors().last() {
-            Some(e) => {
-                let caller = std::panic::Location::caller();
-                let (file, line) = (caller.file(), caller.line());
-                let file = file
-                    .rsplit_once(&['/', '\\'][..])
-                    .map_or(file, |(_, basename)| basename);
-                // TODO: finish map
-                let default_errstr = e.reason().unwrap_or("unknown error");
-                let errstr = match default_errstr {
-                    "certificate verify failed" => "CERTIFICATE_VERIFY_FAILED",
-                    _ => default_errstr,
-                };
-                let msg = if let Some(lib) = e.library() {
-                    // add `library` attribute
-                    let attr_name = vm.ctx.as_ref().intern_str("library");
-                    cls.set_attr(attr_name, vm.ctx.new_str(lib).into());
-                    format!("[{lib}] {errstr} ({file}:{line})")
-                } else {
-                    format!("{errstr} ({file}:{line})")
-                };
-                // add `reason` attribute
-                let attr_name = vm.ctx.as_ref().intern_str("reason");
-                cls.set_attr(attr_name, vm.ctx.new_str(errstr).into());
-
-                let reason = sys::ERR_GET_REASON(e.code());
-                vm.new_exception(
-                    cls,
-                    vec![vm.ctx.new_int(reason).into(), vm.ctx.new_str(msg).into()],
-                )
-            }
-            None => vm.new_exception_empty(cls),
-        }
-    }
-    #[track_caller]
-    fn convert_ssl_error(
-        vm: &VirtualMachine,
-        e: impl std::borrow::Borrow<ssl::Error>,
-    ) -> PyBaseExceptionRef {
-        let e = e.borrow();
-        let (cls, msg) = match e.code() {
-            ssl::ErrorCode::WANT_READ => (
-                vm.class("_ssl", "SSLWantReadError"),
-                "The operation did not complete (read)",
-            ),
-            ssl::ErrorCode::WANT_WRITE => (
-                vm.class("_ssl", "SSLWantWriteError"),
-                "The operation did not complete (write)",
-            ),
-            ssl::ErrorCode::SYSCALL => match e.io_error() {
-                Some(io_err) => return io_err.to_pyexception(vm),
-                None => (
-                    vm.class("_ssl", "SSLSyscallError"),
-                    "EOF occurred in violation of protocol",
-                ),
-            },
-            ssl::ErrorCode::SSL => match e.ssl_error() {
-                Some(e) => return convert_openssl_error(vm, e.clone()),
-                None => (ssl_error(vm), "A failure in the SSL library occurred"),
-            },
-            _ => (ssl_error(vm), "A failure in the SSL library occurred"),
-        };
-        vm.new_exception_msg(cls, msg.to_owned())
-    }
-
-    // SSL_FILETYPE_ASN1 part of _add_ca_certs in CPython
-    fn x509_stack_from_der(der: &[u8]) -> Result<Vec<X509>, ErrorStack> {
-        unsafe {
-            openssl::init();
-            let bio = bio::MemBioSlice::new(der)?;
-
-            let mut certs = vec![];
-            loop {
-                let cert = sys::d2i_X509_bio(bio.as_ptr(), std::ptr::null_mut());
-                if cert.is_null() {
-                    break;
-                }
-                certs.push(X509::from_ptr(cert));
-            }
-
-            let err = sys::ERR_peek_last_error();
-
-            if certs.is_empty() {
-                // let msg = if filetype == sys::SSL_FILETYPE_PEM {
-                //     "no start line: cadata does not contain a certificate"
-                // } else {
-                //     "not enough data: cadata does not contain a certificate"
-                // };
-                return Err(ErrorStack::get());
-            }
-            if err != 0 {
-                return Err(ErrorStack::get());
-            }
-
-            Ok(certs)
-        }
-    }
-
-    type CipherTuple = (&'static str, &'static str, i32);
-
-    fn cipher_to_tuple(cipher: &ssl::SslCipherRef) -> CipherTuple {
-        (cipher.name(), cipher.version(), cipher.bits().secret)
-    }
-
-    fn cert_to_py(vm: &VirtualMachine, cert: &X509Ref, binary: bool) -> PyResult {
-        let r = if binary {
-            let b = cert.to_der().map_err(|e| convert_openssl_error(vm, e))?;
-            vm.ctx.new_bytes(b).into()
-        } else {
-            let dict = vm.ctx.new_dict();
-
-            let name_to_py = |name: &x509::X509NameRef| -> PyResult {
-                let list = name
-                    .entries()
-                    .map(|entry| {
-                        let txt = obj2txt(entry.object(), false).to_pyobject(vm);
-                        let data = vm.ctx.new_str(entry.data().as_utf8()?.to_owned());
-                        Ok(vm.new_tuple(((txt, data),)).into())
-                    })
-                    .collect::<Result<_, _>>()
-                    .map_err(|e| convert_openssl_error(vm, e))?;
-                Ok(vm.ctx.new_tuple(list).into())
-            };
-
-            dict.set_item("subject", name_to_py(cert.subject_name())?, vm)?;
-            dict.set_item("issuer", name_to_py(cert.issuer_name())?, vm)?;
-            dict.set_item("version", vm.new_pyobj(cert.version()), vm)?;
-
-            let serial_num = cert
-                .serial_number()
-                .to_bn()
-                .and_then(|bn| bn.to_hex_str())
-                .map_err(|e| convert_openssl_error(vm, e))?;
-            dict.set_item(
-                "serialNumber",
-                vm.ctx.new_str(serial_num.to_owned()).into(),
-                vm,
-            )?;
-
-            dict.set_item(
-                "notBefore",
-                vm.ctx.new_str(cert.not_before().to_string()).into(),
-                vm,
-            )?;
-            dict.set_item(
-                "notAfter",
-                vm.ctx.new_str(cert.not_after().to_string()).into(),
-                vm,
-            )?;
-
-            #[allow(clippy::manual_map)]
-            if let Some(names) = cert.subject_alt_names() {
-                let san = names
-                    .iter()
-                    .filter_map(|gen_name| {
-                        if let Some(email) = gen_name.email() {
-                            Some(vm.new_tuple((ascii!("email"), email)).into())
-                        } else if let Some(dnsname) = gen_name.dnsname() {
-                            Some(vm.new_tuple((ascii!("DNS"), dnsname)).into())
-                        } else if let Some(ip) = gen_name.ipaddress() {
-                            Some(
-                                vm.new_tuple((
-                                    ascii!("IP Address"),
-                                    String::from_utf8_lossy(ip).into_owned(),
-                                ))
-                                .into(),
-                            )
-                        } else {
-                            // TODO: convert every type of general name:
-                            // https://github.com/python/cpython/blob/3.6/Modules/_ssl.c#L1092-L1231
-                            None
-                        }
-                    })
-                    .collect();
-                dict.set_item("subjectAltName", vm.ctx.new_tuple(san).into(), vm)?;
-            };
-
-            dict.into()
-        };
-        Ok(r)
-    }
-
-    #[pyfunction]
-    fn _test_decode_cert(path: FsPath, vm: &VirtualMachine) -> PyResult {
-        let path = path.to_path_buf(vm)?;
-        let pem = std::fs::read(path).map_err(|e| e.to_pyexception(vm))?;
-        let x509 = X509::from_pem(&pem).map_err(|e| convert_openssl_error(vm, e))?;
-        cert_to_py(vm, &x509, false)
-    }
-
-    impl Read for SocketStream {
-        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-            let mut socket: &PySocket = &self.0;
-            socket.read(buf)
-        }
-    }
-
-    impl Write for SocketStream {
-        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-            let mut socket: &PySocket = &self.0;
-            socket.write(buf)
-        }
-        fn flush(&mut self) -> std::io::Result<()> {
-            let mut socket: &PySocket = &self.0;
-            socket.flush()
-        }
-    }
-
-    #[cfg(target_os = "android")]
-    mod android {
-        use super::convert_openssl_error;
-        use crate::vm::{VirtualMachine, builtins::PyBaseExceptionRef};
-        use openssl::{
-            ssl::SslContextBuilder,
-            x509::{X509, store::X509StoreBuilder},
-        };
-        use std::{
-            fs::{File, read_dir},
-            io::Read,
-            path::Path,
-        };
-
-        static CERT_DIR: &'static str = "/system/etc/security/cacerts";
-
-        pub(super) fn load_client_ca_list(
-            vm: &VirtualMachine,
-            b: &mut SslContextBuilder,
-        ) -> Result<(), PyBaseExceptionRef> {
-            let root = Path::new(CERT_DIR);
-            if !root.is_dir() {
-                return Err(vm.new_exception_msg(
-                    vm.ctx.exceptions.file_not_found_error.to_owned(),
-                    CERT_DIR.to_string(),
-                ));
-            }
-
-            let mut combined_pem = String::new();
-            let entries = read_dir(root)
-                .map_err(|err| vm.new_os_error(format!("read cert root: {}", err)))?;
-            for entry in entries {
-                let entry =
-                    entry.map_err(|err| vm.new_os_error(format!("iter cert root: {}", err)))?;
-
-                let path = entry.path();
-                if !path.is_file() {
-                    continue;
-                }
-
-                File::open(&path)
-                    .and_then(|mut file| file.read_to_string(&mut combined_pem))
-                    .map_err(|err| {
-                        vm.new_os_error(format!("open cert file {}: {}", path.display(), err))
-                    })?;
-
-                combined_pem.push('\n');
-            }
-
-            let mut store_b =
-                X509StoreBuilder::new().map_err(|err| convert_openssl_error(vm, err))?;
-            let x509_vec = X509::stack_from_pem(combined_pem.as_bytes())
-                .map_err(|err| convert_openssl_error(vm, err))?;
-            for x509 in x509_vec {
-                store_b
-                    .add_cert(x509)
-                    .map_err(|err| convert_openssl_error(vm, err))?;
-            }
-            b.set_cert_store(store_b.build());
-
-            Ok(())
-        }
-    }
-}
-
-#[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)]
-mod ossl101 {
-    #[pyattr]
-    use openssl_sys::{
-        SSL_OP_NO_COMPRESSION as OP_NO_COMPRESSION, SSL_OP_NO_TLSv1_1 as OP_NO_TLSv1_1,
-        SSL_OP_NO_TLSv1_2 as OP_NO_TLSv1_2,
-    };
-}
-
-#[allow(non_upper_case_globals)]
-#[cfg(ossl111)]
-#[pymodule(sub)]
-mod ossl111 {
-    #[pyattr]
-    use openssl_sys::SSL_OP_NO_TLSv1_3 as OP_NO_TLSv1_3;
-}
-
-#[cfg(windows)]
-#[pymodule(sub)]
-mod windows {
-    use crate::{
-        common::ascii,
-        vm::{
-            PyObjectRef, PyPayload, PyResult, VirtualMachine,
-            builtins::{PyFrozenSet, PyStrRef},
-            convert::ToPyException,
-        },
-    };
-
-    #[pyfunction]
-    fn enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        use schannel::{RawPointer, cert_context::ValidUses, cert_store::CertStore};
-        use windows_sys::Win32::Security::Cryptography;
-
-        // TODO: check every store for it, not just 2 of them:
-        // https://github.com/python/cpython/blob/3.8/Modules/_ssl.c#L5603-L5610
-        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())
-            .collect::<Vec<_>>();
-        let certs = stores.iter().flat_map(|s| s.certs()).map(|c| {
-            let cert = vm.ctx.new_bytes(c.to_der().to_owned());
-            let enc_type = unsafe {
-                let ptr = c.as_ptr() as *const Cryptography::CERT_CONTEXT;
-                (*ptr).dwCertEncodingType
-            };
-            let enc_type = match enc_type {
-                Cryptography::X509_ASN_ENCODING => vm.new_pyobj(ascii!("x509_asn")),
-                Cryptography::PKCS_7_ASN_ENCODING => vm.new_pyobj(ascii!("pkcs_7_asn")),
-                other => vm.new_pyobj(other),
-            };
-            let usage: PyObjectRef = match c.valid_uses()? {
-                ValidUses::All => vm.ctx.new_bool(true).into(),
-                ValidUses::Oids(oids) => PyFrozenSet::from_iter(
-                    vm,
-                    oids.into_iter().map(|oid| vm.ctx.new_str(oid).into()),
-                )
-                .unwrap()
-                .into_ref(&vm.ctx)
-                .into(),
-            };
-            Ok(vm.new_tuple((cert, enc_type, usage)).into())
-        });
-        let certs = certs
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e: std::io::Error| e.to_pyexception(vm))?;
-        Ok(certs)
-    }
-}
-
-mod bio {
-    //! based off rust-openssl's private `bio` module
-
-    use libc::c_int;
-    use openssl::error::ErrorStack;
-    use openssl_sys as sys;
-    use std::marker::PhantomData;
-
-    pub struct MemBioSlice<'a>(*mut sys::BIO, PhantomData<&'a [u8]>);
-
-    impl Drop for MemBioSlice<'_> {
-        fn drop(&mut self) {
-            unsafe {
-                sys::BIO_free_all(self.0);
-            }
-        }
-    }
-
-    impl<'a> MemBioSlice<'a> {
-        pub fn new(buf: &'a [u8]) -> Result<MemBioSlice<'a>, ErrorStack> {
-            openssl::init();
-
-            assert!(buf.len() <= c_int::MAX as usize);
-            let bio = unsafe { sys::BIO_new_mem_buf(buf.as_ptr() as *const _, buf.len() as c_int) };
-            if bio.is_null() {
-                return Err(ErrorStack::get());
-            }
-
-            Ok(MemBioSlice(bio, PhantomData))
-        }
-
-        pub fn as_ptr(&self) -> *mut sys::BIO {
-            self.0
-        }
-    }
-}
diff --git a/vm/.gitignore b/vm/.gitignore
deleted file mode 100644
index 4931874f78..0000000000
--- a/vm/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-venv/
-tests/*.bytecode
-Cargo.lock
-python_compiler/target
-target/
diff --git a/vm/Cargo.toml b/vm/Cargo.toml
deleted file mode 100644
index 5a4b0df2a1..0000000000
--- a/vm/Cargo.toml
+++ /dev/null
@@ -1,166 +0,0 @@
-[package]
-name = "rustpython-vm"
-description = "RustPython virtual machine."
-include = ["src/**/*.rs", "Cargo.toml", "build.rs", "Lib/**/*.py"]
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[features]
-default = ["compiler", "wasmbind", "stdio"]
-stdio = []
-importlib = []
-encodings = ["importlib"]
-vm-tracing-logging = []
-flame-it = ["flame", "flamer"]
-freeze-stdlib = ["encodings"]
-jit = ["rustpython-jit"]
-threading = ["rustpython-common/threading"]
-compiler = ["parser", "codegen", "rustpython-compiler"]
-ast = ["ruff_python_ast", "ruff_text_size", "ruff_source_file"]
-codegen = ["rustpython-codegen", "ast"]
-parser = ["ast"]
-serde = ["dep:serde"]
-wasmbind = ["chrono/wasmbind", "getrandom/wasm_js", "wasm-bindgen"]
-
-[dependencies]
-rustpython-compiler = { workspace = true, optional = true }
-rustpython-codegen = { workspace = true, optional = true }
-rustpython-common = { workspace = true }
-rustpython-derive = { workspace = true }
-rustpython-jit = { workspace = true, optional = true }
-
-ruff_python_ast = { workspace = true, optional = true }
-ruff_python_parser = { workspace = true }
-ruff_text_size = { workspace = true, optional = true }
-ruff_source_file = { workspace = true, optional = true }
-# rustpython-ast = { workspace = true, optional = true }
-# rustpython-parser = { workspace = true, optional = true }
-rustpython-compiler-core = { workspace = true }
-rustpython-compiler-source = { workspace = true }
-# rustpython-parser-core = { workspace = true }
-rustpython-literal = { workspace = true }
-rustpython-sre_engine = { workspace = true }
-
-ascii = { workspace = true }
-ahash = { workspace = true }
-bitflags = { workspace = true }
-bstr = { workspace = true }
-cfg-if = { workspace = true }
-crossbeam-utils = { workspace = true }
-chrono = { workspace = true, features = ["wasmbind"] }
-constant_time_eq = { workspace = true }
-flame = { workspace = true, optional = true }
-getrandom = { workspace = true }
-hex = { workspace = true }
-indexmap = { workspace = true }
-itertools = { workspace = true }
-is-macro = { workspace = true }
-libc = { workspace = true }
-log = { workspace = true }
-nix = { workspace = true }
-malachite-bigint = { workspace = true }
-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 }
-serde = { workspace = true, optional = true }
-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"
-flamer = { version = "0.4", optional = true }
-half = "2"
-memoffset = "0.9.1"
-optional = { workspace = true }
-result-like = "0.5.0"
-timsort = "0.1.2"
-
-## 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-ucd-bidi = { workspace = true }
-unic-ucd-category = { workspace = true }
-unic-ucd-ident = { workspace = true }
-
-[target.'cfg(unix)'.dependencies]
-rustix = { workspace = true }
-exitcode = "1.1.2"
-uname = "0.1.1"
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-rustyline = { workspace = true }
-which = "7"
-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]
-libffi = { workspace = true, features = ["system"] }
-libloading = "0.8"
-
-[target.'cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))'.dependencies]
-num_cpus = "1.13.1"
-
-[target.'cfg(windows)'.dependencies]
-junction = { workspace = true }
-schannel = { workspace = true }
-winreg = "0.55"
-
-[target.'cfg(windows)'.dependencies.windows]
-version = "0.52.0"
-features = [
-  "Win32_Foundation",
-  "Win32_System_LibraryLoader",
-  "Win32_System_Threading",
-  "Win32_System_Time",
-  "Win32_UI_Shell",
-]
-
-[target.'cfg(windows)'.dependencies.windows-sys]
-workspace = true
-features = [
-  "Win32_Foundation",
-  "Win32_Globalization",
-  "Win32_Networking_WinSock",
-  "Win32_Security",
-  "Win32_Storage_FileSystem",
-  "Win32_System_Console",
-  "Win32_System_Diagnostics_Debug",
-  "Win32_System_Environment",
-  "Win32_System_Ioctl",
-  "Win32_System_LibraryLoader",
-  "Win32_System_Memory",
-  "Win32_System_Performance",
-  "Win32_System_Pipes",
-  "Win32_System_Registry",
-  "Win32_System_SystemInformation",
-  "Win32_System_SystemServices",
-  "Win32_System_Threading",
-  "Win32_System_WindowsProgramming",
-  "Win32_UI_Shell",
-  "Win32_UI_WindowsAndMessaging",
-]
-
-[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen = { workspace = true, optional = true }
-getrandom = { workspace = true }
-
-[build-dependencies]
-glob = { workspace = true }
-itertools = { workspace = true }
-
-[lints]
-workspace = true
diff --git a/vm/Lib/core_modules/codecs.py b/vm/Lib/core_modules/codecs.py
deleted file mode 120000
index db3231198d..0000000000
--- a/vm/Lib/core_modules/codecs.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/codecs.py
\ No newline at end of file
diff --git a/vm/Lib/core_modules/copyreg.py b/vm/Lib/core_modules/copyreg.py
deleted file mode 120000
index 4ac7f40c43..0000000000
--- a/vm/Lib/core_modules/copyreg.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/copyreg.py
\ No newline at end of file
diff --git a/vm/Lib/core_modules/encodings_utf_8.py b/vm/Lib/core_modules/encodings_utf_8.py
deleted file mode 120000
index a8f3406626..0000000000
--- a/vm/Lib/core_modules/encodings_utf_8.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/encodings/utf_8.py
\ No newline at end of file
diff --git a/vm/Lib/python_builtins/__hello__.py b/vm/Lib/python_builtins/__hello__.py
deleted file mode 120000
index f6cae8932f..0000000000
--- a/vm/Lib/python_builtins/__hello__.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/__hello__.py
\ No newline at end of file
diff --git a/vm/Lib/python_builtins/__phello__ b/vm/Lib/python_builtins/__phello__
deleted file mode 120000
index 113aeb1504..0000000000
--- a/vm/Lib/python_builtins/__phello__
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/__phello__
\ No newline at end of file
diff --git a/vm/Lib/python_builtins/__reducelib.py b/vm/Lib/python_builtins/__reducelib.py
deleted file mode 100644
index 0067cd0a81..0000000000
--- a/vm/Lib/python_builtins/__reducelib.py
+++ /dev/null
@@ -1,86 +0,0 @@
-# Modified from code from the PyPy project:
-# https://bitbucket.org/pypy/pypy/src/default/pypy/objspace/std/objectobject.py
-
-# The MIT License
-
-# Permission is hereby granted, free of charge, to any person
-# obtaining a copy of this software and associated documentation
-# files (the "Software"), to deal in the Software without
-# restriction, including without limitation the rights to use,
-# copy, modify, merge, publish, distribute, sublicense, and/or
-# sell copies of the Software, and to permit persons to whom the
-# Software is furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included
-# in all copies or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-# DEALINGS IN THE SOFTWARE.
-
-import copyreg
-
-
-def _abstract_method_error(typ):
-    methods = ", ".join(sorted(typ.__abstractmethods__))
-    err = "Can't instantiate abstract class %s with abstract methods %s"
-    raise TypeError(err % (typ.__name__, methods))
-
-
-def reduce_2(obj):
-    cls = obj.__class__
-
-    try:
-        getnewargs = obj.__getnewargs__
-    except AttributeError:
-        args = ()
-    else:
-        args = getnewargs()
-        if not isinstance(args, tuple):
-            raise TypeError("__getnewargs__ should return a tuple")
-
-    try:
-        getstate = obj.__getstate__
-    except AttributeError:
-        state = getattr(obj, "__dict__", None)
-        names = slotnames(cls)  # not checking for list
-        if names is not None:
-            slots = {}
-            for name in names:
-                try:
-                    value = getattr(obj, name)
-                except AttributeError:
-                    pass
-                else:
-                    slots[name] = value
-            if slots:
-                state = state, slots
-    else:
-        state = getstate()
-
-    listitems = iter(obj) if isinstance(obj, list) else None
-    dictitems = iter(obj.items()) if isinstance(obj, dict) else None
-
-    newobj = copyreg.__newobj__
-
-    args2 = (cls,) + args
-    return newobj, args2, state, listitems, dictitems
-
-
-def slotnames(cls):
-    if not isinstance(cls, type):
-        return None
-
-    try:
-        return cls.__dict__["__slotnames__"]
-    except KeyError:
-        pass
-
-    slotnames = copyreg._slotnames(cls)
-    if not isinstance(slotnames, list) and slotnames is not None:
-        raise TypeError("copyreg._slotnames didn't return a list or None")
-    return slotnames
diff --git a/vm/Lib/python_builtins/_frozen_importlib.py b/vm/Lib/python_builtins/_frozen_importlib.py
deleted file mode 120000
index d1d4364aba..0000000000
--- a/vm/Lib/python_builtins/_frozen_importlib.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/importlib/_bootstrap.py
\ No newline at end of file
diff --git a/vm/Lib/python_builtins/_frozen_importlib_external.py b/vm/Lib/python_builtins/_frozen_importlib_external.py
deleted file mode 120000
index ba8aff5805..0000000000
--- a/vm/Lib/python_builtins/_frozen_importlib_external.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/importlib/_bootstrap_external.py
\ No newline at end of file
diff --git a/vm/Lib/python_builtins/_py_exceptiongroup.py b/vm/Lib/python_builtins/_py_exceptiongroup.py
deleted file mode 100644
index 91e9354d8a..0000000000
--- a/vm/Lib/python_builtins/_py_exceptiongroup.py
+++ /dev/null
@@ -1,330 +0,0 @@
-# Copied from https://github.com/agronholm/ExceptionGroup/blob/1.2.1/src/exceptiongroup/_exceptions.py
-# License: https://github.com/agronholm/exceptiongroup/blob/1.2.1/LICENSE
-from __future__ import annotations
-
-from collections.abc import Callable, Sequence
-from functools import partial
-from typing import TYPE_CHECKING, Generic, Type, TypeVar, cast, overload
-
-_BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True)
-_BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
-_ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
-_ExceptionT = TypeVar("_ExceptionT", bound=Exception)
-# using typing.Self would require a typing_extensions dependency on py<3.11
-_ExceptionGroupSelf = TypeVar("_ExceptionGroupSelf", bound="ExceptionGroup")
-_BaseExceptionGroupSelf = TypeVar("_BaseExceptionGroupSelf", bound="BaseExceptionGroup")
-
-
-def check_direct_subclass(
-    exc: BaseException, parents: tuple[type[BaseException]]
-) -> bool:
-    from inspect import getmro  # requires rustpython-stdlib
-
-    for cls in getmro(exc.__class__)[:-1]:
-        if cls in parents:
-            return True
-
-    return False
-
-
-def get_condition_filter(
-    condition: type[_BaseExceptionT]
-    | tuple[type[_BaseExceptionT], ...]
-    | Callable[[_BaseExceptionT_co], bool],
-) -> Callable[[_BaseExceptionT_co], bool]:
-    from inspect import isclass  # requires rustpython-stdlib
-
-    if isclass(condition) and issubclass(
-        cast(Type[BaseException], condition), BaseException
-    ):
-        return partial(check_direct_subclass, parents=(condition,))
-    elif isinstance(condition, tuple):
-        if all(isclass(x) and issubclass(x, BaseException) for x in condition):
-            return partial(check_direct_subclass, parents=condition)
-    elif callable(condition):
-        return cast("Callable[[BaseException], bool]", condition)
-
-    raise TypeError("expected a function, exception type or tuple of exception types")
-
-
-def _derive_and_copy_attributes(self, excs):
-    eg = self.derive(excs)
-    eg.__cause__ = self.__cause__
-    eg.__context__ = self.__context__
-    eg.__traceback__ = self.__traceback__
-    if hasattr(self, "__notes__"):
-        # Create a new list so that add_note() only affects one exceptiongroup
-        eg.__notes__ = list(self.__notes__)
-    return eg
-
-
-class BaseExceptionGroup(BaseException, Generic[_BaseExceptionT_co]):
-    """A combination of multiple unrelated exceptions."""
-
-    def __new__(
-        cls: type[_BaseExceptionGroupSelf],
-        __message: str,
-        __exceptions: Sequence[_BaseExceptionT_co],
-    ) -> _BaseExceptionGroupSelf:
-        if not isinstance(__message, str):
-            raise TypeError(f"argument 1 must be str, not {type(__message)}")
-        if not isinstance(__exceptions, Sequence):
-            raise TypeError("second argument (exceptions) must be a sequence")
-        if not __exceptions:
-            raise ValueError(
-                "second argument (exceptions) must be a non-empty sequence"
-            )
-
-        for i, exc in enumerate(__exceptions):
-            if not isinstance(exc, BaseException):
-                raise ValueError(
-                    f"Item {i} of second argument (exceptions) is not an exception"
-                )
-
-        if cls is BaseExceptionGroup:
-            if all(isinstance(exc, Exception) for exc in __exceptions):
-                cls = ExceptionGroup
-
-        if issubclass(cls, Exception):
-            for exc in __exceptions:
-                if not isinstance(exc, Exception):
-                    if cls is ExceptionGroup:
-                        raise TypeError(
-                            "Cannot nest BaseExceptions in an ExceptionGroup"
-                        )
-                    else:
-                        raise TypeError(
-                            f"Cannot nest BaseExceptions in {cls.__name__!r}"
-                        )
-
-        instance = super().__new__(cls, __message, __exceptions)
-        instance._message = __message
-        instance._exceptions = __exceptions
-        return instance
-
-    def add_note(self, note: str) -> None:
-        if not isinstance(note, str):
-            raise TypeError(
-                f"Expected a string, got note={note!r} (type {type(note).__name__})"
-            )
-
-        if not hasattr(self, "__notes__"):
-            self.__notes__: list[str] = []
-
-        self.__notes__.append(note)
-
-    @property
-    def message(self) -> str:
-        return self._message
-
-    @property
-    def exceptions(
-        self,
-    ) -> tuple[_BaseExceptionT_co | BaseExceptionGroup[_BaseExceptionT_co], ...]:
-        return tuple(self._exceptions)
-
-    @overload
-    def subgroup(
-        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
-    ) -> ExceptionGroup[_ExceptionT] | None: ...
-
-    @overload
-    def subgroup(
-        self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
-    ) -> BaseExceptionGroup[_BaseExceptionT] | None: ...
-
-    @overload
-    def subgroup(
-        self,
-        __condition: Callable[[_BaseExceptionT_co | _BaseExceptionGroupSelf], bool],
-    ) -> BaseExceptionGroup[_BaseExceptionT_co] | None: ...
-
-    def subgroup(
-        self,
-        __condition: type[_BaseExceptionT]
-        | tuple[type[_BaseExceptionT], ...]
-        | Callable[[_BaseExceptionT_co | _BaseExceptionGroupSelf], bool],
-    ) -> BaseExceptionGroup[_BaseExceptionT] | None:
-        condition = get_condition_filter(__condition)
-        modified = False
-        if condition(self):
-            return self
-
-        exceptions: list[BaseException] = []
-        for exc in self.exceptions:
-            if isinstance(exc, BaseExceptionGroup):
-                subgroup = exc.subgroup(__condition)
-                if subgroup is not None:
-                    exceptions.append(subgroup)
-
-                if subgroup is not exc:
-                    modified = True
-            elif condition(exc):
-                exceptions.append(exc)
-            else:
-                modified = True
-
-        if not modified:
-            return self
-        elif exceptions:
-            group = _derive_and_copy_attributes(self, exceptions)
-            return group
-        else:
-            return None
-
-    @overload
-    def split(
-        self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
-    ) -> tuple[
-        ExceptionGroup[_ExceptionT] | None,
-        BaseExceptionGroup[_BaseExceptionT_co] | None,
-    ]: ...
-
-    @overload
-    def split(
-        self, __condition: type[_BaseExceptionT] | tuple[type[_BaseExceptionT], ...]
-    ) -> tuple[
-        BaseExceptionGroup[_BaseExceptionT] | None,
-        BaseExceptionGroup[_BaseExceptionT_co] | None,
-    ]: ...
-
-    @overload
-    def split(
-        self,
-        __condition: Callable[[_BaseExceptionT_co | _BaseExceptionGroupSelf], bool],
-    ) -> tuple[
-        BaseExceptionGroup[_BaseExceptionT_co] | None,
-        BaseExceptionGroup[_BaseExceptionT_co] | None,
-    ]: ...
-
-    def split(
-        self,
-        __condition: type[_BaseExceptionT]
-        | tuple[type[_BaseExceptionT], ...]
-        | Callable[[_BaseExceptionT_co], bool],
-    ) -> (
-        tuple[
-            ExceptionGroup[_ExceptionT] | None,
-            BaseExceptionGroup[_BaseExceptionT_co] | None,
-        ]
-        | tuple[
-            BaseExceptionGroup[_BaseExceptionT] | None,
-            BaseExceptionGroup[_BaseExceptionT_co] | None,
-        ]
-        | tuple[
-            BaseExceptionGroup[_BaseExceptionT_co] | None,
-            BaseExceptionGroup[_BaseExceptionT_co] | None,
-        ]
-    ):
-        condition = get_condition_filter(__condition)
-        if condition(self):
-            return self, None
-
-        matching_exceptions: list[BaseException] = []
-        nonmatching_exceptions: list[BaseException] = []
-        for exc in self.exceptions:
-            if isinstance(exc, BaseExceptionGroup):
-                matching, nonmatching = exc.split(condition)
-                if matching is not None:
-                    matching_exceptions.append(matching)
-
-                if nonmatching is not None:
-                    nonmatching_exceptions.append(nonmatching)
-            elif condition(exc):
-                matching_exceptions.append(exc)
-            else:
-                nonmatching_exceptions.append(exc)
-
-        matching_group: _BaseExceptionGroupSelf | None = None
-        if matching_exceptions:
-            matching_group = _derive_and_copy_attributes(self, matching_exceptions)
-
-        nonmatching_group: _BaseExceptionGroupSelf | None = None
-        if nonmatching_exceptions:
-            nonmatching_group = _derive_and_copy_attributes(
-                self, nonmatching_exceptions
-            )
-
-        return matching_group, nonmatching_group
-
-    @overload
-    def derive(self, __excs: Sequence[_ExceptionT]) -> ExceptionGroup[_ExceptionT]: ...
-
-    @overload
-    def derive(
-        self, __excs: Sequence[_BaseExceptionT]
-    ) -> BaseExceptionGroup[_BaseExceptionT]: ...
-
-    def derive(
-        self, __excs: Sequence[_BaseExceptionT]
-    ) -> BaseExceptionGroup[_BaseExceptionT]:
-        return BaseExceptionGroup(self.message, __excs)
-
-    def __str__(self) -> str:
-        suffix = "" if len(self._exceptions) == 1 else "s"
-        return f"{self.message} ({len(self._exceptions)} sub-exception{suffix})"
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.message!r}, {self._exceptions!r})"
-
-
-class ExceptionGroup(BaseExceptionGroup[_ExceptionT_co], Exception):
-    def __new__(
-        cls: type[_ExceptionGroupSelf],
-        __message: str,
-        __exceptions: Sequence[_ExceptionT_co],
-    ) -> _ExceptionGroupSelf:
-        return super().__new__(cls, __message, __exceptions)
-
-    if TYPE_CHECKING:
-
-        @property
-        def exceptions(
-            self,
-        ) -> tuple[_ExceptionT_co | ExceptionGroup[_ExceptionT_co], ...]: ...
-
-        @overload  # type: ignore[override]
-        def subgroup(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
-        ) -> ExceptionGroup[_ExceptionT] | None: ...
-
-        @overload
-        def subgroup(
-            self, __condition: Callable[[_ExceptionT_co | _ExceptionGroupSelf], bool]
-        ) -> ExceptionGroup[_ExceptionT_co] | None: ...
-
-        def subgroup(
-            self,
-            __condition: type[_ExceptionT]
-            | tuple[type[_ExceptionT], ...]
-            | Callable[[_ExceptionT_co], bool],
-        ) -> ExceptionGroup[_ExceptionT] | None:
-            return super().subgroup(__condition)
-
-        @overload
-        def split(
-            self, __condition: type[_ExceptionT] | tuple[type[_ExceptionT], ...]
-        ) -> tuple[
-            ExceptionGroup[_ExceptionT] | None, ExceptionGroup[_ExceptionT_co] | None
-        ]: ...
-
-        @overload
-        def split(
-            self, __condition: Callable[[_ExceptionT_co | _ExceptionGroupSelf], bool]
-        ) -> tuple[
-            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
-        ]: ...
-
-        def split(
-            self: _ExceptionGroupSelf,
-            __condition: type[_ExceptionT]
-            | tuple[type[_ExceptionT], ...]
-            | Callable[[_ExceptionT_co], bool],
-        ) -> tuple[
-            ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None
-        ]:
-            return super().split(__condition)
-        
-
-BaseExceptionGroup.__module__ = 'builtins'
-ExceptionGroup.__module__ = 'builtins'
diff --git a/vm/Lib/python_builtins/_thread.py b/vm/Lib/python_builtins/_thread.py
deleted file mode 120000
index fa4a34c4fb..0000000000
--- a/vm/Lib/python_builtins/_thread.py
+++ /dev/null
@@ -1 +0,0 @@
-../../../Lib/_dummy_thread.py
\ No newline at end of file
diff --git a/vm/build.rs b/vm/build.rs
deleted file mode 100644
index 93d29c3a57..0000000000
--- a/vm/build.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use itertools::Itertools;
-use std::{env, io::prelude::*, path::PathBuf, process::Command};
-
-fn main() {
-    let frozen_libs = if cfg!(feature = "freeze-stdlib") {
-        "Lib/*/*.py"
-    } else {
-        "Lib/python_builtins/*.py"
-    };
-    for entry in glob::glob(frozen_libs).expect("Lib/ exists?").flatten() {
-        let display = entry.display();
-        println!("cargo:rerun-if-changed={display}");
-    }
-    println!("cargo:rerun-if-changed=../Lib/importlib/_bootstrap.py");
-
-    println!("cargo:rustc-env=RUSTPYTHON_GIT_HASH={}", git_hash());
-    println!(
-        "cargo:rustc-env=RUSTPYTHON_GIT_TIMESTAMP={}",
-        git_timestamp()
-    );
-    println!("cargo:rustc-env=RUSTPYTHON_GIT_TAG={}", git_tag());
-    println!("cargo:rustc-env=RUSTPYTHON_GIT_BRANCH={}", git_branch());
-    println!("cargo:rustc-env=RUSTC_VERSION={}", rustc_version());
-
-    println!(
-        "cargo:rustc-env=RUSTPYTHON_TARGET_TRIPLE={}",
-        env::var("TARGET").unwrap()
-    );
-
-    let mut env_path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    env_path.push("env_vars.rs");
-    let mut f = std::fs::File::create(env_path).unwrap();
-    write!(
-        f,
-        "sysvars! {{ {} }}",
-        std::env::vars_os().format_with(", ", |(k, v), f| f(&format_args!("{k:?} => {v:?}")))
-    )
-    .unwrap();
-}
-
-fn git_hash() -> String {
-    git(&["rev-parse", "--short", "HEAD"])
-}
-
-fn git_timestamp() -> String {
-    git(&["log", "-1", "--format=%ct"])
-}
-
-fn git_tag() -> String {
-    git(&["describe", "--all", "--always", "--dirty"])
-}
-
-fn git_branch() -> String {
-    git(&["name-rev", "--name-only", "HEAD"])
-}
-
-fn git(args: &[&str]) -> String {
-    command("git", args)
-}
-
-fn rustc_version() -> String {
-    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
-    command(rustc, &["-V"])
-}
-
-fn command(cmd: impl AsRef<std::ffi::OsStr>, args: &[&str]) -> String {
-    match Command::new(cmd).args(args).output() {
-        Ok(output) => match String::from_utf8(output.stdout) {
-            Ok(s) => s,
-            Err(err) => format!("(output error: {err})"),
-        },
-        Err(err) => format!("(command error: {err})"),
-    }
-}
diff --git a/vm/src/buffer.rs b/vm/src/buffer.rs
deleted file mode 100644
index 13cebfc6a2..0000000000
--- a/vm/src/buffer.rs
+++ /dev/null
@@ -1,650 +0,0 @@
-use crate::{
-    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyBytesRef, PyTuple, PyTupleRef, PyTypeRef},
-    common::{static_cell, str::wchar_t},
-    convert::ToPyObject,
-    function::{ArgBytesLike, ArgIntoBool, ArgIntoFloat},
-};
-use half::f16;
-use itertools::Itertools;
-use malachite_bigint::BigInt;
-use num_traits::{PrimInt, ToPrimitive};
-use std::{fmt, iter::Peekable, mem, os::raw};
-
-type PackFunc = fn(&VirtualMachine, PyObjectRef, &mut [u8]) -> PyResult<()>;
-type UnpackFunc = fn(&VirtualMachine, &[u8]) -> PyObjectRef;
-
-static OVERFLOW_MSG: &str = "total struct size too long"; // not a const to reduce code size
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub(crate) enum Endianness {
-    Native,
-    Little,
-    Big,
-    Host,
-}
-
-impl Endianness {
-    /// Parse endianness
-    /// See also: https://docs.python.org/3/library/struct.html?highlight=struct#byte-order-size-and-alignment
-    fn parse<I>(chars: &mut Peekable<I>) -> Self
-    where
-        I: Sized + Iterator<Item = u8>,
-    {
-        let e = match chars.peek() {
-            Some(b'@') => Self::Native,
-            Some(b'=') => Self::Host,
-            Some(b'<') => Self::Little,
-            Some(b'>') | Some(b'!') => Self::Big,
-            _ => return Self::Native,
-        };
-        chars.next().unwrap();
-        e
-    }
-}
-
-trait ByteOrder {
-    fn convert<I: PrimInt>(i: I) -> I;
-}
-enum BigEndian {}
-impl ByteOrder for BigEndian {
-    fn convert<I: PrimInt>(i: I) -> I {
-        i.to_be()
-    }
-}
-enum LittleEndian {}
-impl ByteOrder for LittleEndian {
-    fn convert<I: PrimInt>(i: I) -> I {
-        i.to_le()
-    }
-}
-
-#[cfg(target_endian = "big")]
-type NativeEndian = BigEndian;
-#[cfg(target_endian = "little")]
-type NativeEndian = LittleEndian;
-
-#[derive(Copy, Clone, num_enum::TryFromPrimitive)]
-#[repr(u8)]
-pub(crate) enum FormatType {
-    Pad = b'x',
-    SByte = b'b',
-    UByte = b'B',
-    Char = b'c',
-    WideChar = b'u',
-    Str = b's',
-    Pascal = b'p',
-    Short = b'h',
-    UShort = b'H',
-    Int = b'i',
-    UInt = b'I',
-    Long = b'l',
-    ULong = b'L',
-    SSizeT = b'n',
-    SizeT = b'N',
-    LongLong = b'q',
-    ULongLong = b'Q',
-    Bool = b'?',
-    Half = b'e',
-    Float = b'f',
-    Double = b'd',
-    VoidP = b'P',
-}
-
-impl fmt::Debug for FormatType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&(*self as u8 as char), f)
-    }
-}
-
-impl FormatType {
-    fn info(self, e: Endianness) -> &'static FormatInfo {
-        use FormatType::*;
-        use mem::{align_of, size_of};
-        macro_rules! native_info {
-            ($t:ty) => {{
-                &FormatInfo {
-                    size: size_of::<$t>(),
-                    align: align_of::<$t>(),
-                    pack: Some(<$t as Packable>::pack::<NativeEndian>),
-                    unpack: Some(<$t as Packable>::unpack::<NativeEndian>),
-                }
-            }};
-        }
-        macro_rules! nonnative_info {
-            ($t:ty, $end:ty) => {{
-                &FormatInfo {
-                    size: size_of::<$t>(),
-                    align: 0,
-                    pack: Some(<$t as Packable>::pack::<$end>),
-                    unpack: Some(<$t as Packable>::unpack::<$end>),
-                }
-            }};
-        }
-        macro_rules! match_nonnative {
-            ($zelf:expr, $end:ty) => {{
-                match $zelf {
-                    Pad | Str | Pascal => &FormatInfo {
-                        size: size_of::<u8>(),
-                        align: 0,
-                        pack: None,
-                        unpack: None,
-                    },
-                    SByte => nonnative_info!(i8, $end),
-                    UByte => nonnative_info!(u8, $end),
-                    Char => &FormatInfo {
-                        size: size_of::<u8>(),
-                        align: 0,
-                        pack: Some(pack_char),
-                        unpack: Some(unpack_char),
-                    },
-                    Short => nonnative_info!(i16, $end),
-                    UShort => nonnative_info!(u16, $end),
-                    Int | Long => nonnative_info!(i32, $end),
-                    UInt | ULong => nonnative_info!(u32, $end),
-                    LongLong => nonnative_info!(i64, $end),
-                    ULongLong => nonnative_info!(u64, $end),
-                    Bool => nonnative_info!(bool, $end),
-                    Half => nonnative_info!(f16, $end),
-                    Float => nonnative_info!(f32, $end),
-                    Double => nonnative_info!(f64, $end),
-                    _ => unreachable!(), // size_t or void*
-                }
-            }};
-        }
-        match e {
-            Endianness::Native => match self {
-                Pad | Str | Pascal => &FormatInfo {
-                    size: size_of::<raw::c_char>(),
-                    align: 0,
-                    pack: None,
-                    unpack: None,
-                },
-                SByte => native_info!(raw::c_schar),
-                UByte => native_info!(raw::c_uchar),
-                Char => &FormatInfo {
-                    size: size_of::<raw::c_char>(),
-                    align: 0,
-                    pack: Some(pack_char),
-                    unpack: Some(unpack_char),
-                },
-                WideChar => native_info!(wchar_t),
-                Short => native_info!(raw::c_short),
-                UShort => native_info!(raw::c_ushort),
-                Int => native_info!(raw::c_int),
-                UInt => native_info!(raw::c_uint),
-                Long => native_info!(raw::c_long),
-                ULong => native_info!(raw::c_ulong),
-                SSizeT => native_info!(isize), // ssize_t == isize
-                SizeT => native_info!(usize),  //  size_t == usize
-                LongLong => native_info!(raw::c_longlong),
-                ULongLong => native_info!(raw::c_ulonglong),
-                Bool => native_info!(bool),
-                Half => native_info!(f16),
-                Float => native_info!(raw::c_float),
-                Double => native_info!(raw::c_double),
-                VoidP => native_info!(*mut raw::c_void),
-            },
-            Endianness::Big => match_nonnative!(self, BigEndian),
-            Endianness::Little => match_nonnative!(self, LittleEndian),
-            Endianness::Host => match_nonnative!(self, NativeEndian),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct FormatCode {
-    pub repeat: usize,
-    pub code: FormatType,
-    pub info: &'static FormatInfo,
-    pub pre_padding: usize,
-}
-
-impl FormatCode {
-    pub const fn arg_count(&self) -> usize {
-        match self.code {
-            FormatType::Pad => 0,
-            FormatType::Str | FormatType::Pascal => 1,
-            _ => self.repeat,
-        }
-    }
-
-    pub fn parse<I>(
-        chars: &mut Peekable<I>,
-        endianness: Endianness,
-    ) -> Result<(Vec<Self>, usize, usize), String>
-    where
-        I: Sized + Iterator<Item = u8>,
-    {
-        let mut offset = 0isize;
-        let mut arg_count = 0usize;
-        let mut codes = vec![];
-        while chars.peek().is_some() {
-            // determine repeat operator:
-            let repeat = match chars.peek() {
-                Some(b'0'..=b'9') => {
-                    let mut repeat = 0isize;
-                    while let Some(b'0'..=b'9') = chars.peek() {
-                        if let Some(c) = chars.next() {
-                            let current_digit = c - b'0';
-                            repeat = repeat
-                                .checked_mul(10)
-                                .and_then(|r| r.checked_add(current_digit as _))
-                                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
-                        }
-                    }
-                    repeat
-                }
-                _ => 1,
-            };
-
-            // determine format char:
-            let c = chars
-                .next()
-                .ok_or_else(|| "repeat count given without format specifier".to_owned())?;
-
-            // Check for embedded null character
-            if c == 0 {
-                return Err("embedded null character".to_owned());
-            }
-
-            let code = FormatType::try_from(c)
-                .ok()
-                .filter(|c| match c {
-                    FormatType::SSizeT | FormatType::SizeT | FormatType::VoidP => {
-                        endianness == Endianness::Native
-                    }
-                    _ => true,
-                })
-                .ok_or_else(|| "bad char in struct format".to_owned())?;
-
-            let info = code.info(endianness);
-
-            let padding = compensate_alignment(offset as usize, info.align)
-                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
-            offset = padding
-                .to_isize()
-                .and_then(|extra| offset.checked_add(extra))
-                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
-
-            let code = Self {
-                repeat: repeat as usize,
-                code,
-                info,
-                pre_padding: padding,
-            };
-            arg_count += code.arg_count();
-            codes.push(code);
-
-            offset = (info.size as isize)
-                .checked_mul(repeat)
-                .and_then(|item_size| offset.checked_add(item_size))
-                .ok_or_else(|| OVERFLOW_MSG.to_owned())?;
-        }
-
-        Ok((codes, offset as usize, arg_count))
-    }
-}
-
-const fn compensate_alignment(offset: usize, align: usize) -> Option<usize> {
-    if align != 0 && offset != 0 {
-        // a % b == a & (b-1) if b is a power of 2
-        (align - 1).checked_sub((offset - 1) & (align - 1))
-    } else {
-        // alignment is already all good
-        Some(0)
-    }
-}
-
-pub(crate) struct FormatInfo {
-    pub size: usize,
-    pub align: usize,
-    pub pack: Option<PackFunc>,
-    pub unpack: Option<UnpackFunc>,
-}
-impl fmt::Debug for FormatInfo {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FormatInfo")
-            .field("size", &self.size)
-            .field("align", &self.align)
-            .finish()
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct FormatSpec {
-    #[allow(dead_code)]
-    pub(crate) endianness: Endianness,
-    pub(crate) codes: Vec<FormatCode>,
-    pub size: usize,
-    pub arg_count: usize,
-}
-
-impl FormatSpec {
-    pub fn parse(fmt: &[u8], vm: &VirtualMachine) -> PyResult<Self> {
-        let mut chars = fmt.iter().copied().peekable();
-
-        // First determine "@", "<", ">","!" or "="
-        let endianness = Endianness::parse(&mut chars);
-
-        // Now, analyze struct string further:
-        let (codes, size, arg_count) =
-            FormatCode::parse(&mut chars, endianness).map_err(|err| new_struct_error(vm, err))?;
-
-        Ok(Self {
-            endianness,
-            codes,
-            size,
-            arg_count,
-        })
-    }
-
-    pub fn pack(&self, args: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        // Create data vector:
-        let mut data = vec![0; self.size];
-
-        self.pack_into(&mut data, args, vm)?;
-
-        Ok(data)
-    }
-
-    pub fn pack_into(
-        &self,
-        mut buffer: &mut [u8],
-        args: Vec<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        if self.arg_count != args.len() {
-            return Err(new_struct_error(
-                vm,
-                format!(
-                    "pack expected {} items for packing (got {})",
-                    self.codes.len(),
-                    args.len()
-                ),
-            ));
-        }
-
-        let mut args = args.into_iter();
-        // Loop over all opcodes:
-        for code in &self.codes {
-            buffer = &mut buffer[code.pre_padding..];
-            debug!("code: {code:?}");
-            match code.code {
-                FormatType::Str => {
-                    let (buf, rest) = buffer.split_at_mut(code.repeat);
-                    pack_string(vm, args.next().unwrap(), buf)?;
-                    buffer = rest;
-                }
-                FormatType::Pascal => {
-                    let (buf, rest) = buffer.split_at_mut(code.repeat);
-                    pack_pascal(vm, args.next().unwrap(), buf)?;
-                    buffer = rest;
-                }
-                FormatType::Pad => {
-                    let (pad_buf, rest) = buffer.split_at_mut(code.repeat);
-                    for el in pad_buf {
-                        *el = 0
-                    }
-                    buffer = rest;
-                }
-                _ => {
-                    let pack = code.info.pack.unwrap();
-                    for arg in args.by_ref().take(code.repeat) {
-                        let (item_buf, rest) = buffer.split_at_mut(code.info.size);
-                        pack(vm, arg, item_buf)?;
-                        buffer = rest;
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    pub fn unpack(&self, mut data: &[u8], vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-        if self.size != data.len() {
-            return Err(new_struct_error(
-                vm,
-                format!("unpack requires a buffer of {} bytes", self.size),
-            ));
-        }
-
-        let mut items = Vec::with_capacity(self.arg_count);
-        for code in &self.codes {
-            data = &data[code.pre_padding..];
-            debug!("unpack code: {code:?}");
-            match code.code {
-                FormatType::Pad => {
-                    data = &data[code.repeat..];
-                }
-                FormatType::Str => {
-                    let (str_data, rest) = data.split_at(code.repeat);
-                    // string is just stored inline
-                    items.push(vm.ctx.new_bytes(str_data.to_vec()).into());
-                    data = rest;
-                }
-                FormatType::Pascal => {
-                    let (str_data, rest) = data.split_at(code.repeat);
-                    items.push(unpack_pascal(vm, str_data));
-                    data = rest;
-                }
-                _ => {
-                    let unpack = code.info.unpack.unwrap();
-                    for _ in 0..code.repeat {
-                        let (item_data, rest) = data.split_at(code.info.size);
-                        items.push(unpack(vm, item_data));
-                        data = rest;
-                    }
-                }
-            };
-        }
-
-        Ok(PyTuple::new_ref(items, &vm.ctx))
-    }
-
-    #[inline]
-    pub const fn size(&self) -> usize {
-        self.size
-    }
-}
-
-trait Packable {
-    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()>;
-    fn unpack<E: ByteOrder>(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef;
-}
-
-trait PackInt: PrimInt {
-    fn pack_int<E: ByteOrder>(self, data: &mut [u8]);
-    fn unpack_int<E: ByteOrder>(data: &[u8]) -> Self;
-}
-
-macro_rules! make_pack_prim_int {
-    ($T:ty) => {
-        impl PackInt for $T {
-            fn pack_int<E: ByteOrder>(self, data: &mut [u8]) {
-                let i = E::convert(self);
-                data.copy_from_slice(&i.to_ne_bytes());
-            }
-            #[inline]
-            fn unpack_int<E: ByteOrder>(data: &[u8]) -> Self {
-                let mut x = [0; std::mem::size_of::<$T>()];
-                x.copy_from_slice(data);
-                E::convert(<$T>::from_ne_bytes(x))
-            }
-        }
-
-        impl Packable for $T {
-            fn pack<E: ByteOrder>(
-                vm: &VirtualMachine,
-                arg: PyObjectRef,
-                data: &mut [u8],
-            ) -> PyResult<()> {
-                let i: $T = get_int_or_index(vm, arg)?;
-                i.pack_int::<E>(data);
-                Ok(())
-            }
-
-            fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
-                let i = <$T>::unpack_int::<E>(rdr);
-                vm.ctx.new_int(i).into()
-            }
-        }
-    };
-}
-
-fn get_int_or_index<T>(vm: &VirtualMachine, arg: PyObjectRef) -> PyResult<T>
-where
-    T: PrimInt + for<'a> TryFrom<&'a BigInt>,
-{
-    let index = arg
-        .try_index_opt(vm)
-        .unwrap_or_else(|| Err(new_struct_error(vm, "required argument is not an integer")))?;
-    index
-        .try_to_primitive(vm)
-        .map_err(|_| new_struct_error(vm, "argument out of range"))
-}
-
-make_pack_prim_int!(i8);
-make_pack_prim_int!(u8);
-make_pack_prim_int!(i16);
-make_pack_prim_int!(u16);
-make_pack_prim_int!(i32);
-make_pack_prim_int!(u32);
-make_pack_prim_int!(i64);
-make_pack_prim_int!(u64);
-make_pack_prim_int!(usize);
-make_pack_prim_int!(isize);
-
-macro_rules! make_pack_float {
-    ($T:ty) => {
-        impl Packable for $T {
-            fn pack<E: ByteOrder>(
-                vm: &VirtualMachine,
-                arg: PyObjectRef,
-                data: &mut [u8],
-            ) -> PyResult<()> {
-                let f = *ArgIntoFloat::try_from_object(vm, arg)? as $T;
-                f.to_bits().pack_int::<E>(data);
-                Ok(())
-            }
-
-            fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
-                let i = PackInt::unpack_int::<E>(rdr);
-                <$T>::from_bits(i).to_pyobject(vm)
-            }
-        }
-    };
-}
-
-make_pack_float!(f32);
-make_pack_float!(f64);
-
-impl Packable for f16 {
-    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        let f_64 = *ArgIntoFloat::try_from_object(vm, arg)?;
-        // "from_f64 should be preferred in any non-`const` context" except it gives the wrong result :/
-        let f_16 = Self::from_f64_const(f_64);
-        if f_16.is_infinite() != f_64.is_infinite() {
-            return Err(vm.new_overflow_error("float too large to pack with e format"));
-        }
-        f_16.to_bits().pack_int::<E>(data);
-        Ok(())
-    }
-
-    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
-        let i = PackInt::unpack_int::<E>(rdr);
-        Self::from_bits(i).to_f64().to_pyobject(vm)
-    }
-}
-
-impl Packable for *mut raw::c_void {
-    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        usize::pack::<E>(vm, arg, data)
-    }
-
-    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
-        usize::unpack::<E>(vm, rdr)
-    }
-}
-
-impl Packable for bool {
-    fn pack<E: ByteOrder>(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-        let v = *ArgIntoBool::try_from_object(vm, arg)? as u8;
-        v.pack_int::<E>(data);
-        Ok(())
-    }
-
-    fn unpack<E: ByteOrder>(vm: &VirtualMachine, rdr: &[u8]) -> PyObjectRef {
-        let i = u8::unpack_int::<E>(rdr);
-        vm.ctx.new_bool(i != 0).into()
-    }
-}
-
-fn pack_char(vm: &VirtualMachine, arg: PyObjectRef, data: &mut [u8]) -> PyResult<()> {
-    let v = PyBytesRef::try_from_object(vm, arg)?;
-    let ch = *v
-        .as_bytes()
-        .iter()
-        .exactly_one()
-        .map_err(|_| new_struct_error(vm, "char format requires a bytes object of length 1"))?;
-    data[0] = ch;
-    Ok(())
-}
-
-fn pack_string(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResult<()> {
-    let b = ArgBytesLike::try_from_object(vm, arg)?;
-    b.with_ref(|data| write_string(buf, data));
-    Ok(())
-}
-
-fn pack_pascal(vm: &VirtualMachine, arg: PyObjectRef, buf: &mut [u8]) -> PyResult<()> {
-    if buf.is_empty() {
-        return Ok(());
-    }
-    let b = ArgBytesLike::try_from_object(vm, arg)?;
-    b.with_ref(|data| {
-        let string_length = std::cmp::min(std::cmp::min(data.len(), 255), buf.len() - 1);
-        buf[0] = string_length as u8;
-        write_string(&mut buf[1..], data);
-    });
-    Ok(())
-}
-
-fn write_string(buf: &mut [u8], data: &[u8]) {
-    let len_from_data = std::cmp::min(data.len(), buf.len());
-    buf[..len_from_data].copy_from_slice(&data[..len_from_data]);
-    for byte in &mut buf[len_from_data..] {
-        *byte = 0
-    }
-}
-
-fn unpack_char(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef {
-    vm.ctx.new_bytes(vec![data[0]]).into()
-}
-
-fn unpack_pascal(vm: &VirtualMachine, data: &[u8]) -> PyObjectRef {
-    let (&len, data) = match data.split_first() {
-        Some(x) => x,
-        None => {
-            // cpython throws an internal SystemError here
-            return vm.ctx.new_bytes(vec![]).into();
-        }
-    };
-    let len = std::cmp::min(len as usize, data.len());
-    vm.ctx.new_bytes(data[..len].to_vec()).into()
-}
-
-// XXX: are those functions expected to be placed here?
-pub fn struct_error_type(vm: &VirtualMachine) -> &'static PyTypeRef {
-    static_cell! {
-        static INSTANCE: PyTypeRef;
-    }
-    INSTANCE.get_or_init(|| vm.ctx.new_exception_type("struct", "error", None))
-}
-
-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
-    vm.new_exception_msg(struct_error_type(vm).clone(), msg.into())
-}
diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs
deleted file mode 100644
index 05e8b51514..0000000000
--- a/vm/src/builtins/asyncgenerator.rs
+++ /dev/null
@@ -1,429 +0,0 @@
-use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
-use crate::{
-    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::PyBaseExceptionRef,
-    class::PyClassImpl,
-    coroutine::Coro,
-    frame::FrameRef,
-    function::OptionalArg,
-    protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
-};
-
-use crossbeam_utils::atomic::AtomicCell;
-
-#[pyclass(name = "async_generator", module = false)]
-#[derive(Debug)]
-pub struct PyAsyncGen {
-    inner: Coro,
-    running_async: AtomicCell<bool>,
-}
-type PyAsyncGenRef = PyRef<PyAsyncGen>;
-
-impl PyPayload for PyAsyncGen {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.async_generator
-    }
-}
-
-#[pyclass(with(PyRef, Unconstructible, Representable))]
-impl PyAsyncGen {
-    pub const fn as_coro(&self) -> &Coro {
-        &self.inner
-    }
-
-    pub fn new(frame: FrameRef, name: PyStrRef) -> Self {
-        Self {
-            inner: Coro::new(frame, name),
-            running_async: AtomicCell::new(false),
-        }
-    }
-
-    #[pygetset]
-    fn __name__(&self) -> PyStrRef {
-        self.inner.name()
-    }
-
-    #[pygetset(setter)]
-    fn set___name__(&self, name: PyStrRef) {
-        self.inner.set_name(name)
-    }
-
-    #[pygetset]
-    fn ag_await(&self, _vm: &VirtualMachine) -> Option<PyObjectRef> {
-        self.inner.frame().yield_from_target()
-    }
-    #[pygetset]
-    fn ag_frame(&self, _vm: &VirtualMachine) -> FrameRef {
-        self.inner.frame()
-    }
-    #[pygetset]
-    fn ag_running(&self, _vm: &VirtualMachine) -> bool {
-        self.inner.running()
-    }
-    #[pygetset]
-    fn ag_code(&self, _vm: &VirtualMachine) -> PyRef<PyCode> {
-        self.inner.frame().code.clone()
-    }
-
-    #[pyclassmethod]
-    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::from_args(cls, args, vm)
-    }
-}
-
-#[pyclass]
-impl PyRef<PyAsyncGen> {
-    #[pymethod]
-    const fn __aiter__(self, _vm: &VirtualMachine) -> Self {
-        self
-    }
-
-    #[pymethod]
-    fn __anext__(self, vm: &VirtualMachine) -> PyAsyncGenASend {
-        Self::asend(self, vm.ctx.none(), vm)
-    }
-
-    #[pymethod]
-    const fn asend(self, value: PyObjectRef, _vm: &VirtualMachine) -> PyAsyncGenASend {
-        PyAsyncGenASend {
-            ag: self,
-            state: AtomicCell::new(AwaitableState::Init),
-            value,
-        }
-    }
-
-    #[pymethod]
-    fn athrow(
-        self,
-        exc_type: PyObjectRef,
-        exc_val: OptionalArg,
-        exc_tb: OptionalArg,
-        vm: &VirtualMachine,
-    ) -> PyAsyncGenAThrow {
-        PyAsyncGenAThrow {
-            ag: self,
-            aclose: false,
-            state: AtomicCell::new(AwaitableState::Init),
-            value: (
-                exc_type,
-                exc_val.unwrap_or_none(vm),
-                exc_tb.unwrap_or_none(vm),
-            ),
-        }
-    }
-
-    #[pymethod]
-    fn aclose(self, vm: &VirtualMachine) -> PyAsyncGenAThrow {
-        PyAsyncGenAThrow {
-            ag: self,
-            aclose: true,
-            state: AtomicCell::new(AwaitableState::Init),
-            value: (
-                vm.ctx.exceptions.generator_exit.to_owned().into(),
-                vm.ctx.none(),
-                vm.ctx.none(),
-            ),
-        }
-    }
-}
-
-impl Representable for PyAsyncGen {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
-    }
-}
-
-impl Unconstructible for PyAsyncGen {}
-
-#[pyclass(module = false, name = "async_generator_wrapped_value")]
-#[derive(Debug)]
-pub(crate) struct PyAsyncGenWrappedValue(pub PyObjectRef);
-impl PyPayload for PyAsyncGenWrappedValue {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.async_generator_wrapped_value
-    }
-}
-
-#[pyclass]
-impl PyAsyncGenWrappedValue {}
-
-impl PyAsyncGenWrappedValue {
-    fn unbox(ag: &PyAsyncGen, val: PyResult<PyIterReturn>, vm: &VirtualMachine) -> PyResult {
-        let (closed, async_done) = match &val {
-            Ok(PyIterReturn::StopIteration(_)) => (true, true),
-            Err(e) if e.fast_isinstance(vm.ctx.exceptions.generator_exit) => (true, true),
-            Err(_) => (false, true),
-            _ => (false, false),
-        };
-        if closed {
-            ag.inner.closed.store(true);
-        }
-        if async_done {
-            ag.running_async.store(false);
-        }
-        let val = val?.into_async_pyresult(vm)?;
-        match_class!(match val {
-            val @ Self => {
-                ag.running_async.store(false);
-                Err(vm.new_stop_iteration(Some(val.0.clone())))
-            }
-            val => Ok(val),
-        })
-    }
-}
-
-#[derive(Debug, Clone, Copy)]
-enum AwaitableState {
-    Init,
-    Iter,
-    Closed,
-}
-
-#[pyclass(module = false, name = "async_generator_asend")]
-#[derive(Debug)]
-pub(crate) struct PyAsyncGenASend {
-    ag: PyAsyncGenRef,
-    state: AtomicCell<AwaitableState>,
-    value: PyObjectRef,
-}
-
-impl PyPayload for PyAsyncGenASend {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.async_generator_asend
-    }
-}
-
-#[pyclass(with(IterNext, Iterable))]
-impl PyAsyncGenASend {
-    #[pymethod(name = "__await__")]
-    const fn r#await(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
-        zelf
-    }
-
-    #[pymethod]
-    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let val = match self.state.load() {
-            AwaitableState::Closed => {
-                return Err(
-                    vm.new_runtime_error("cannot reuse already awaited __anext__()/asend()")
-                );
-            }
-            AwaitableState::Iter => val, // already running, all good
-            AwaitableState::Init => {
-                if self.ag.running_async.load() {
-                    return Err(
-                        vm.new_runtime_error("anext(): asynchronous generator is already running")
-                    );
-                }
-                self.ag.running_async.store(true);
-                self.state.store(AwaitableState::Iter);
-                if vm.is_none(&val) {
-                    self.value.clone()
-                } else {
-                    val
-                }
-            }
-        };
-        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();
-        }
-        res
-    }
-
-    #[pymethod]
-    fn throw(
-        &self,
-        exc_type: PyObjectRef,
-        exc_val: OptionalArg,
-        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()"));
-        }
-
-        let res = self.ag.inner.throw(
-            self.ag.as_object(),
-            exc_type,
-            exc_val.unwrap_or_none(vm),
-            exc_tb.unwrap_or_none(vm),
-            vm,
-        );
-        let res = PyAsyncGenWrappedValue::unbox(&self.ag, res, vm);
-        if res.is_err() {
-            self.close();
-        }
-        res
-    }
-
-    #[pymethod]
-    fn close(&self) {
-        self.state.store(AwaitableState::Closed);
-    }
-}
-
-impl SelfIter for PyAsyncGenASend {}
-impl IterNext for PyAsyncGenASend {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
-    }
-}
-
-#[pyclass(module = false, name = "async_generator_athrow")]
-#[derive(Debug)]
-pub(crate) struct PyAsyncGenAThrow {
-    ag: PyAsyncGenRef,
-    aclose: bool,
-    state: AtomicCell<AwaitableState>,
-    value: (PyObjectRef, PyObjectRef, PyObjectRef),
-}
-
-impl PyPayload for PyAsyncGenAThrow {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.async_generator_athrow
-    }
-}
-
-#[pyclass(with(IterNext, Iterable))]
-impl PyAsyncGenAThrow {
-    #[pymethod(name = "__await__")]
-    const fn r#await(zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
-        zelf
-    }
-
-    #[pymethod]
-    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        match self.state.load() {
-            AwaitableState::Closed => {
-                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));
-                }
-                if !vm.is_none(&val) {
-                    return Err(vm.new_runtime_error(
-                        "can't send non-None value to a just-started async generator",
-                    ));
-                }
-                self.state.store(AwaitableState::Iter);
-                self.ag.running_async.store(true);
-
-                let (ty, val, tb) = self.value.clone();
-                let ret = self.ag.inner.throw(self.ag.as_object(), ty, val, tb, vm);
-                let ret = if self.aclose {
-                    if self.ignored_close(&ret) {
-                        Err(self.yield_close(vm))
-                    } else {
-                        ret.and_then(|o| o.into_async_pyresult(vm))
-                    }
-                } else {
-                    PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
-                };
-                ret.map_err(|e| self.check_error(e, vm))
-            }
-            AwaitableState::Iter => {
-                let ret = self.ag.inner.send(self.ag.as_object(), val, vm);
-                if self.aclose {
-                    match ret {
-                        Ok(PyIterReturn::Return(v)) if v.payload_is::<PyAsyncGenWrappedValue>() => {
-                            Err(self.yield_close(vm))
-                        }
-                        other => other
-                            .and_then(|o| o.into_async_pyresult(vm))
-                            .map_err(|e| self.check_error(e, vm)),
-                    }
-                } else {
-                    PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
-                }
-            }
-        }
-    }
-
-    #[pymethod]
-    fn throw(
-        &self,
-        exc_type: PyObjectRef,
-        exc_val: OptionalArg,
-        exc_tb: OptionalArg,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let ret = self.ag.inner.throw(
-            self.ag.as_object(),
-            exc_type,
-            exc_val.unwrap_or_none(vm),
-            exc_tb.unwrap_or_none(vm),
-            vm,
-        );
-        let res = if self.aclose {
-            if self.ignored_close(&ret) {
-                Err(self.yield_close(vm))
-            } else {
-                ret.and_then(|o| o.into_async_pyresult(vm))
-            }
-        } else {
-            PyAsyncGenWrappedValue::unbox(&self.ag, ret, vm)
-        };
-        res.map_err(|e| self.check_error(e, vm))
-    }
-
-    #[pymethod]
-    fn close(&self) {
-        self.state.store(AwaitableState::Closed);
-    }
-
-    fn ignored_close(&self, res: &PyResult<PyIterReturn>) -> bool {
-        res.as_ref().is_ok_and(|v| match v {
-            PyIterReturn::Return(obj) => obj.payload_is::<PyAsyncGenWrappedValue>(),
-            PyIterReturn::StopIteration(_) => false,
-        })
-    }
-    fn yield_close(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        self.ag.running_async.store(false);
-        self.state.store(AwaitableState::Closed);
-        vm.new_runtime_error("async generator ignored GeneratorExit")
-    }
-    fn check_error(&self, exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        self.ag.running_async.store(false);
-        self.state.store(AwaitableState::Closed);
-        if self.aclose
-            && (exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
-                || exc.fast_isinstance(vm.ctx.exceptions.generator_exit))
-        {
-            vm.new_stop_iteration(None)
-        } else {
-            exc
-        }
-    }
-}
-
-impl SelfIter for PyAsyncGenAThrow {}
-impl IterNext for PyAsyncGenAThrow {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        PyIterReturn::from_pyresult(zelf.send(vm.ctx.none(), vm), vm)
-    }
-}
-
-pub fn init(ctx: &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/vm/src/builtins/bool.rs b/vm/src/builtins/bool.rs
deleted file mode 100644
index c21db81d56..0000000000
--- a/vm/src/builtins/bool.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-use super::{PyInt, PyStrRef, PyType, PyTypeRef};
-use crate::common::format::FormatSpec;
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject,
-    VirtualMachine,
-    class::PyClassImpl,
-    convert::{IntoPyException, ToPyObject, ToPyResult},
-    function::OptionalArg,
-    identifier,
-    protocol::PyNumberMethods,
-    types::{AsNumber, Constructor, Representable},
-};
-use malachite_bigint::Sign;
-use num_traits::Zero;
-use std::fmt::{Debug, Formatter};
-
-impl ToPyObject for bool {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_bool(self).into()
-    }
-}
-
-impl<'a> TryFromBorrowedObject<'a> for bool {
-    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        if obj.fast_isinstance(vm.ctx.types.int_type) {
-            Ok(get_value(obj))
-        } else {
-            Err(vm.new_type_error(format!("Expected type bool, not {}", obj.class().name())))
-        }
-    }
-}
-
-impl PyObjectRef {
-    /// Convert Python bool into Rust bool.
-    pub fn try_to_bool(self, vm: &VirtualMachine) -> PyResult<bool> {
-        if self.is(&vm.ctx.true_value) {
-            return Ok(true);
-        }
-        if self.is(&vm.ctx.false_value) {
-            return Ok(false);
-        }
-        let rs_bool = match vm.get_method(self.clone(), identifier!(vm, __bool__)) {
-            Some(method_or_err) => {
-                // If descriptor returns Error, propagate it further
-                let method = method_or_err?;
-                let bool_obj = method.call((), vm)?;
-                if !bool_obj.fast_isinstance(vm.ctx.types.bool_type) {
-                    return Err(vm.new_type_error(format!(
-                        "__bool__ should return bool, returned type {}",
-                        bool_obj.class().name()
-                    )));
-                }
-
-                get_value(&bool_obj)
-            }
-            None => match vm.get_method(self, identifier!(vm, __len__)) {
-                Some(method_or_err) => {
-                    let method = method_or_err?;
-                    let bool_obj = method.call((), vm)?;
-                    let int_obj = bool_obj.payload::<PyInt>().ok_or_else(|| {
-                        vm.new_type_error(format!(
-                            "'{}' object cannot be interpreted as an integer",
-                            bool_obj.class().name()
-                        ))
-                    })?;
-
-                    let len_val = int_obj.as_bigint();
-                    if len_val.sign() == Sign::Minus {
-                        return Err(vm.new_value_error("__len__() should return >= 0"));
-                    }
-                    !len_val.is_zero()
-                }
-                None => true,
-            },
-        };
-        Ok(rs_bool)
-    }
-}
-
-#[pyclass(name = "bool", module = false, base = "PyInt")]
-pub struct PyBool;
-
-impl PyPayload for PyBool {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.bool_type
-    }
-}
-
-impl Debug for PyBool {
-    fn fmt(&self, _f: &mut Formatter<'_>) -> std::fmt::Result {
-        todo!()
-    }
-}
-
-impl Constructor for PyBool {
-    type Args = OptionalArg<PyObjectRef>;
-
-    fn py_new(zelf: PyTypeRef, x: Self::Args, vm: &VirtualMachine) -> PyResult {
-        if !zelf.fast_isinstance(vm.ctx.types.type_type) {
-            let actual_class = zelf.class();
-            let actual_type = &actual_class.name();
-            return Err(vm.new_type_error(format!(
-                "requires a 'type' object but received a '{actual_type}'"
-            )));
-        }
-        let val = x.map_or(Ok(false), |val| val.try_to_bool(vm))?;
-        Ok(vm.ctx.new_bool(val).into())
-    }
-}
-
-#[pyclass(with(Constructor, AsNumber, Representable))]
-impl PyBool {
-    #[pymethod]
-    fn __format__(obj: PyObjectRef, spec: PyStrRef, 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))
-            .map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
-    fn __or__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        if lhs.fast_isinstance(vm.ctx.types.bool_type)
-            && rhs.fast_isinstance(vm.ctx.types.bool_type)
-        {
-            let lhs = get_value(&lhs);
-            let rhs = get_value(&rhs);
-            (lhs || rhs).to_pyobject(vm)
-        } else if let Some(lhs) = lhs.payload::<PyInt>() {
-            lhs.__or__(rhs, vm).to_pyobject(vm)
-        } else {
-            vm.ctx.not_implemented()
-        }
-    }
-
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
-    fn __and__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        if lhs.fast_isinstance(vm.ctx.types.bool_type)
-            && rhs.fast_isinstance(vm.ctx.types.bool_type)
-        {
-            let lhs = get_value(&lhs);
-            let rhs = get_value(&rhs);
-            (lhs && rhs).to_pyobject(vm)
-        } else if let Some(lhs) = lhs.payload::<PyInt>() {
-            lhs.__and__(rhs, vm).to_pyobject(vm)
-        } else {
-            vm.ctx.not_implemented()
-        }
-    }
-
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
-    fn __xor__(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        if lhs.fast_isinstance(vm.ctx.types.bool_type)
-            && rhs.fast_isinstance(vm.ctx.types.bool_type)
-        {
-            let lhs = get_value(&lhs);
-            let rhs = get_value(&rhs);
-            (lhs ^ rhs).to_pyobject(vm)
-        } else if let Some(lhs) = lhs.payload::<PyInt>() {
-            lhs.__xor__(rhs, vm).to_pyobject(vm)
-        } else {
-            vm.ctx.not_implemented()
-        }
-    }
-}
-
-impl AsNumber for PyBool {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            and: Some(|a, b, vm| PyBool::__and__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
-            xor: Some(|a, b, vm| PyBool::__xor__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
-            or: Some(|a, b, vm| PyBool::__or__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
-            ..PyInt::AS_NUMBER
-        };
-        &AS_NUMBER
-    }
-}
-
-impl Representable for PyBool {
-    #[inline]
-    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let name = if get_value(zelf.as_object()) {
-            vm.ctx.names.True
-        } else {
-            vm.ctx.names.False
-        };
-        Ok(name.to_owned())
-    }
-
-    #[cold]
-    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        unreachable!("use slot_repr instead")
-    }
-}
-
-pub(crate) fn init(context: &Context) {
-    PyBool::extend_class(context, context.types.bool_type);
-}
-
-// pub fn not(vm: &VirtualMachine, obj: &PyObject) -> PyResult<bool> {
-//     if obj.fast_isinstance(vm.ctx.types.bool_type) {
-//         let value = get_value(obj);
-//         Ok(!value)
-//     } else {
-//         Err(vm.new_type_error(format!("Can only invert a bool, on {:?}", obj)))
-//     }
-// }
-
-// Retrieve inner int value:
-pub(crate) fn get_value(obj: &PyObject) -> bool {
-    !obj.payload::<PyInt>().unwrap().as_bigint().is_zero()
-}
diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs
deleted file mode 100644
index 0058dbf555..0000000000
--- a/vm/src/builtins/code.rs
+++ /dev/null
@@ -1,445 +0,0 @@
-/*! Infamous code object. The python class `code`
-
-*/
-
-use super::{PyStrRef, PyTupleRef, PyType, PyTypeRef};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    builtins::PyStrInterned,
-    bytecode::{self, AsBag, BorrowedConstant, CodeFlags, Constant, ConstantBag},
-    class::{PyClassImpl, StaticType},
-    convert::ToPyObject,
-    frozen,
-    function::{FuncArgs, OptionalArg},
-    source::LineNumber,
-    types::Representable,
-};
-use malachite_bigint::BigInt;
-use num_traits::Zero;
-use std::{borrow::Borrow, fmt, ops::Deref};
-
-#[derive(FromArgs)]
-pub struct ReplaceArgs {
-    #[pyarg(named, optional)]
-    co_posonlyargcount: OptionalArg<u32>,
-    #[pyarg(named, optional)]
-    co_argcount: OptionalArg<u32>,
-    #[pyarg(named, optional)]
-    co_kwonlyargcount: OptionalArg<u32>,
-    #[pyarg(named, optional)]
-    co_filename: OptionalArg<PyStrRef>,
-    #[pyarg(named, optional)]
-    co_firstlineno: OptionalArg<u32>,
-    #[pyarg(named, optional)]
-    co_consts: OptionalArg<Vec<PyObjectRef>>,
-    #[pyarg(named, optional)]
-    co_name: OptionalArg<PyStrRef>,
-    #[pyarg(named, optional)]
-    co_names: OptionalArg<Vec<PyObjectRef>>,
-    #[pyarg(named, optional)]
-    co_flags: OptionalArg<u16>,
-    #[pyarg(named, optional)]
-    co_varnames: OptionalArg<Vec<PyObjectRef>>,
-}
-
-#[derive(Clone)]
-#[repr(transparent)]
-pub struct Literal(PyObjectRef);
-
-impl Borrow<PyObject> for Literal {
-    fn borrow(&self) -> &PyObject {
-        &self.0
-    }
-}
-
-impl From<Literal> for PyObjectRef {
-    fn from(obj: Literal) -> Self {
-        obj.0
-    }
-}
-
-fn borrow_obj_constant(obj: &PyObject) -> BorrowedConstant<'_, Literal> {
-    match_class!(match obj {
-        ref i @ super::int::PyInt => {
-            let value = i.as_bigint();
-            if obj.class().is(super::bool_::PyBool::static_type()) {
-                BorrowedConstant::Boolean {
-                    value: !value.is_zero(),
-                }
-            } else {
-                BorrowedConstant::Integer { value }
-            }
-        }
-        ref f @ super::float::PyFloat => BorrowedConstant::Float { value: f.to_f64() },
-        ref c @ super::complex::PyComplex => BorrowedConstant::Complex {
-            value: c.to_complex()
-        },
-        ref s @ super::pystr::PyStr => BorrowedConstant::Str { value: s.as_wtf8() },
-        ref b @ super::bytes::PyBytes => BorrowedConstant::Bytes {
-            value: b.as_bytes()
-        },
-        ref c @ PyCode => {
-            BorrowedConstant::Code { code: &c.code }
-        }
-        ref t @ super::tuple::PyTuple => {
-            let elements = t.as_slice();
-            // SAFETY: Literal is repr(transparent) over PyObjectRef, and a Literal tuple only ever
-            //         has other literals as elements
-            let elements = unsafe { &*(elements as *const [PyObjectRef] as *const [Literal]) };
-            BorrowedConstant::Tuple { elements }
-        }
-        super::singletons::PyNone => BorrowedConstant::None,
-        super::slice::PyEllipsis => BorrowedConstant::Ellipsis,
-        _ => panic!("unexpected payload for constant python value"),
-    })
-}
-
-impl Constant for Literal {
-    type Name = &'static PyStrInterned;
-    fn borrow_constant(&self) -> BorrowedConstant<'_, Self> {
-        borrow_obj_constant(&self.0)
-    }
-}
-
-impl<'a> AsBag for &'a Context {
-    type Bag = PyObjBag<'a>;
-    fn as_bag(self) -> PyObjBag<'a> {
-        PyObjBag(self)
-    }
-}
-impl<'a> AsBag for &'a VirtualMachine {
-    type Bag = PyObjBag<'a>;
-    fn as_bag(self) -> PyObjBag<'a> {
-        PyObjBag(&self.ctx)
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct PyObjBag<'a>(pub &'a Context);
-
-impl ConstantBag for PyObjBag<'_> {
-    type Constant = Literal;
-
-    fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {
-        let ctx = self.0;
-        let obj = match constant {
-            bytecode::BorrowedConstant::Integer { value } => ctx.new_bigint(value).into(),
-            bytecode::BorrowedConstant::Float { value } => ctx.new_float(value).into(),
-            bytecode::BorrowedConstant::Complex { value } => ctx.new_complex(value).into(),
-            bytecode::BorrowedConstant::Str { value } if value.len() <= 20 => {
-                ctx.intern_str(value).to_object()
-            }
-            bytecode::BorrowedConstant::Str { value } => ctx.new_str(value).into(),
-            bytecode::BorrowedConstant::Bytes { value } => ctx.new_bytes(value.to_vec()).into(),
-            bytecode::BorrowedConstant::Boolean { value } => ctx.new_bool(value).into(),
-            bytecode::BorrowedConstant::Code { code } => {
-                ctx.new_code(code.map_clone_bag(self)).into()
-            }
-            bytecode::BorrowedConstant::Tuple { elements } => {
-                let elements = elements
-                    .iter()
-                    .map(|constant| self.make_constant(constant.borrow_constant()).0)
-                    .collect();
-                ctx.new_tuple(elements).into()
-            }
-            bytecode::BorrowedConstant::None => ctx.none(),
-            bytecode::BorrowedConstant::Ellipsis => ctx.ellipsis(),
-        };
-        Literal(obj)
-    }
-
-    fn make_name(&self, name: &str) -> &'static PyStrInterned {
-        self.0.intern_str(name)
-    }
-
-    fn make_int(&self, value: BigInt) -> Self::Constant {
-        Literal(self.0.new_int(value).into())
-    }
-
-    fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {
-        Literal(self.0.new_tuple(elements.map(|lit| lit.0).collect()).into())
-    }
-
-    fn make_code(&self, code: CodeObject) -> Self::Constant {
-        Literal(self.0.new_code(code).into())
-    }
-}
-
-pub type CodeObject = bytecode::CodeObject<Literal>;
-
-pub trait IntoCodeObject {
-    fn into_code_object(self, ctx: &Context) -> CodeObject;
-}
-
-impl IntoCodeObject for CodeObject {
-    fn into_code_object(self, _ctx: &Context) -> CodeObject {
-        self
-    }
-}
-
-impl IntoCodeObject for bytecode::CodeObject {
-    fn into_code_object(self, ctx: &Context) -> CodeObject {
-        self.map_bag(PyObjBag(ctx))
-    }
-}
-
-impl<B: AsRef<[u8]>> IntoCodeObject for frozen::FrozenCodeObject<B> {
-    fn into_code_object(self, ctx: &Context) -> CodeObject {
-        self.decode(ctx)
-    }
-}
-
-#[pyclass(module = false, name = "code")]
-pub struct PyCode {
-    pub code: CodeObject,
-}
-
-impl Deref for PyCode {
-    type Target = CodeObject;
-    fn deref(&self) -> &Self::Target {
-        &self.code
-    }
-}
-
-impl PyCode {
-    pub const fn new(code: CodeObject) -> Self {
-        Self { code }
-    }
-}
-
-impl fmt::Debug for PyCode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "code: {:?}", self.code)
-    }
-}
-
-impl PyPayload for PyCode {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.code_type
-    }
-}
-
-impl Representable for PyCode {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        let code = &zelf.code;
-        Ok(format!(
-            "<code object {} at {:#x} file {:?}, line {}>",
-            code.obj_name,
-            zelf.get_id(),
-            code.source_path.as_str(),
-            code.first_line_number.map_or(-1, |n| n.get() as i32)
-        ))
-    }
-}
-
-#[pyclass(with(Representable))]
-impl PyCode {
-    #[pyslot]
-    fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_type_error("Cannot directly create code object"))
-    }
-
-    #[pygetset]
-    const fn co_posonlyargcount(&self) -> usize {
-        self.code.posonlyarg_count as usize
-    }
-
-    #[pygetset]
-    const fn co_argcount(&self) -> usize {
-        self.code.arg_count as usize
-    }
-
-    #[pygetset]
-    const fn co_stacksize(&self) -> u32 {
-        self.code.max_stackdepth
-    }
-
-    #[pygetset]
-    pub fn co_filename(&self) -> PyStrRef {
-        self.code.source_path.to_owned()
-    }
-
-    #[pygetset]
-    pub fn co_cellvars(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let cellvars = self
-            .code
-            .cellvars
-            .deref()
-            .iter()
-            .map(|name| name.to_pyobject(vm))
-            .collect();
-        vm.ctx.new_tuple(cellvars)
-    }
-
-    #[pygetset]
-    fn co_nlocals(&self) -> usize {
-        self.varnames.len()
-    }
-
-    #[pygetset]
-    fn co_firstlineno(&self) -> u32 {
-        self.code.first_line_number.map_or(0, |n| n.get() as _)
-    }
-
-    #[pygetset]
-    const fn co_kwonlyargcount(&self) -> usize {
-        self.code.kwonlyarg_count as usize
-    }
-
-    #[pygetset]
-    fn co_consts(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let consts = self.code.constants.iter().map(|x| x.0.clone()).collect();
-        vm.ctx.new_tuple(consts)
-    }
-
-    #[pygetset]
-    fn co_name(&self) -> PyStrRef {
-        self.code.obj_name.to_owned()
-    }
-
-    #[pygetset]
-    fn co_names(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let names = self
-            .code
-            .names
-            .deref()
-            .iter()
-            .map(|name| name.to_pyobject(vm))
-            .collect();
-        vm.ctx.new_tuple(names)
-    }
-
-    #[pygetset]
-    const fn co_flags(&self) -> u16 {
-        self.code.flags.bits()
-    }
-
-    #[pygetset]
-    pub fn co_varnames(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let varnames = self.code.varnames.iter().map(|s| s.to_object()).collect();
-        vm.ctx.new_tuple(varnames)
-    }
-
-    #[pygetset]
-    pub fn co_freevars(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let names = self
-            .code
-            .freevars
-            .deref()
-            .iter()
-            .map(|name| name.to_pyobject(vm))
-            .collect();
-        vm.ctx.new_tuple(names)
-    }
-
-    #[pymethod]
-    pub fn replace(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self> {
-        let posonlyarg_count = match args.co_posonlyargcount {
-            OptionalArg::Present(posonlyarg_count) => posonlyarg_count,
-            OptionalArg::Missing => self.code.posonlyarg_count,
-        };
-
-        let arg_count = match args.co_argcount {
-            OptionalArg::Present(arg_count) => arg_count,
-            OptionalArg::Missing => self.code.arg_count,
-        };
-
-        let source_path = match args.co_filename {
-            OptionalArg::Present(source_path) => source_path,
-            OptionalArg::Missing => self.code.source_path.to_owned(),
-        };
-
-        let first_line_number = match args.co_firstlineno {
-            OptionalArg::Present(first_line_number) => LineNumber::new(first_line_number as _),
-            OptionalArg::Missing => self.code.first_line_number,
-        };
-
-        let kwonlyarg_count = match args.co_kwonlyargcount {
-            OptionalArg::Present(kwonlyarg_count) => kwonlyarg_count,
-            OptionalArg::Missing => self.code.kwonlyarg_count,
-        };
-
-        let constants = match args.co_consts {
-            OptionalArg::Present(constants) => constants,
-            OptionalArg::Missing => self.code.constants.iter().map(|x| x.0.clone()).collect(),
-        };
-
-        let obj_name = match args.co_name {
-            OptionalArg::Present(obj_name) => obj_name,
-            OptionalArg::Missing => self.code.obj_name.to_owned(),
-        };
-
-        let names = match args.co_names {
-            OptionalArg::Present(names) => names,
-            OptionalArg::Missing => self
-                .code
-                .names
-                .deref()
-                .iter()
-                .map(|name| name.to_pyobject(vm))
-                .collect(),
-        };
-
-        let flags = match args.co_flags {
-            OptionalArg::Present(flags) => flags,
-            OptionalArg::Missing => self.code.flags.bits(),
-        };
-
-        let varnames = match args.co_varnames {
-            OptionalArg::Present(varnames) => varnames,
-            OptionalArg::Missing => self.code.varnames.iter().map(|s| s.to_object()).collect(),
-        };
-
-        Ok(Self {
-            code: CodeObject {
-                flags: CodeFlags::from_bits_truncate(flags),
-                posonlyarg_count,
-                arg_count,
-                kwonlyarg_count,
-                source_path: source_path.as_object().as_interned_str(vm).unwrap(),
-                first_line_number,
-                obj_name: obj_name.as_object().as_interned_str(vm).unwrap(),
-
-                max_stackdepth: self.code.max_stackdepth,
-                instructions: self.code.instructions.clone(),
-                locations: self.code.locations.clone(),
-                constants: constants.into_iter().map(Literal).collect(),
-                names: names
-                    .into_iter()
-                    .map(|o| o.as_interned_str(vm).unwrap())
-                    .collect(),
-                varnames: varnames
-                    .into_iter()
-                    .map(|o| o.as_interned_str(vm).unwrap())
-                    .collect(),
-                cellvars: self.code.cellvars.clone(),
-                freevars: self.code.freevars.clone(),
-                cell2arg: self.code.cell2arg.clone(),
-            },
-        })
-    }
-}
-
-impl fmt::Display for PyCode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (**self).fmt(f)
-    }
-}
-
-impl ToPyObject for CodeObject {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_code(self).into()
-    }
-}
-
-impl ToPyObject for bytecode::CodeObject {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_code(self).into()
-    }
-}
-
-pub fn init(ctx: &Context) {
-    PyCode::extend_class(ctx, ctx.types.code_type);
-}
diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs
deleted file mode 100644
index 11c7826649..0000000000
--- a/vm/src/builtins/complex.rs
+++ /dev/null
@@ -1,526 +0,0 @@
-use super::{PyStr, PyType, PyTypeRef, float};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::PyStrRef,
-    class::PyClassImpl,
-    common::format::FormatSpec,
-    convert::{IntoPyException, ToPyObject, ToPyResult},
-    function::{
-        OptionalArg, OptionalOption,
-        PyArithmeticValue::{self, *},
-        PyComparisonValue,
-    },
-    identifier,
-    protocol::PyNumberMethods,
-    stdlib::warnings,
-    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
-};
-use num_complex::Complex64;
-use num_traits::Zero;
-use rustpython_common::hash;
-use std::num::Wrapping;
-
-/// Create a complex number from a real part and an optional imaginary part.
-///
-/// This is equivalent to (real + imag*1j) where imag defaults to 0.
-#[pyclass(module = false, name = "complex")]
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct PyComplex {
-    value: Complex64,
-}
-
-impl PyComplex {
-    pub const fn to_complex64(self) -> Complex64 {
-        self.value
-    }
-}
-
-impl PyPayload for PyComplex {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.complex_type
-    }
-}
-
-impl ToPyObject for Complex64 {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        PyComplex::from(self).to_pyobject(vm)
-    }
-}
-
-impl From<Complex64> for PyComplex {
-    fn from(value: Complex64) -> Self {
-        Self { value }
-    }
-}
-
-impl PyObjectRef {
-    /// Tries converting a python object into a complex, returns an option of whether the complex
-    /// and whether the  object was a complex originally or coerced into one
-    pub fn try_complex(&self, vm: &VirtualMachine) -> PyResult<Option<(Complex64, bool)>> {
-        if let Some(complex) = self.payload_if_exact::<PyComplex>(vm) {
-            return Ok(Some((complex.value, true)));
-        }
-        if let Some(method) = vm.get_method(self.clone(), identifier!(vm, __complex__)) {
-            let result = method?.call((), vm)?;
-
-            let ret_class = result.class().to_owned();
-            if let Some(ret) = result.downcast_ref::<PyComplex>() {
-                warnings::warn(
-                    vm.ctx.exceptions.deprecation_warning,
-                    format!(
-                        "__complex__ returned non-complex (type {ret_class}).  \
-                    The ability to return an instance of a strict subclass of complex \
-                    is deprecated, and may be removed in a future version of Python."
-                    ),
-                    1,
-                    vm,
-                )?;
-
-                return Ok(Some((ret.value, true)));
-            } else {
-                return match result.payload::<PyComplex>() {
-                    Some(complex_obj) => Ok(Some((complex_obj.value, true))),
-                    None => Err(vm.new_type_error(format!(
-                        "__complex__ returned non-complex (type '{}')",
-                        result.class().name()
-                    ))),
-                };
-            }
-        }
-        // `complex` does not have a `__complex__` by default, so subclasses might not either,
-        // use the actual stored value in this case
-        if let Some(complex) = self.payload_if_subclass::<PyComplex>(vm) {
-            return Ok(Some((complex.value, true)));
-        }
-        if let Some(float) = self.try_float_opt(vm) {
-            return Ok(Some((Complex64::new(float?.to_f64(), 0.0), false)));
-        }
-        Ok(None)
-    }
-}
-
-pub fn init(context: &Context) {
-    PyComplex::extend_class(context, context.types.complex_type);
-}
-
-fn to_op_complex(value: &PyObject, vm: &VirtualMachine) -> PyResult<Option<Complex64>> {
-    let r = if let Some(complex) = value.payload_if_subclass::<PyComplex>(vm) {
-        Some(complex.value)
-    } else {
-        float::to_op_float(value, vm)?.map(|float| Complex64::new(float, 0.0))
-    };
-    Ok(r)
-}
-
-fn inner_div(v1: Complex64, v2: Complex64, vm: &VirtualMachine) -> PyResult<Complex64> {
-    if v2.is_zero() {
-        return Err(vm.new_zero_division_error("complex division by zero"));
-    }
-
-    Ok(v1.fdiv(v2))
-}
-
-fn inner_pow(v1: Complex64, v2: Complex64, vm: &VirtualMachine) -> PyResult<Complex64> {
-    if v1.is_zero() {
-        return if v2.re < 0.0 || v2.im != 0.0 {
-            let msg = format!("{v1} cannot be raised to a negative or complex power");
-            Err(vm.new_zero_division_error(msg))
-        } else if v2.is_zero() {
-            Ok(Complex64::new(1.0, 0.0))
-        } else {
-            Ok(Complex64::new(0.0, 0.0))
-        };
-    }
-
-    let ans = powc(v1, v2);
-    if ans.is_infinite() && !(v1.is_infinite() || v2.is_infinite()) {
-        Err(vm.new_overflow_error("complex exponentiation overflow"))
-    } else {
-        Ok(ans)
-    }
-}
-
-// num-complex changed their powc() implementation in 0.4.4, making it incompatible
-// with what the regression tests expect. this is that old formula.
-fn powc(a: Complex64, exp: Complex64) -> Complex64 {
-    let (r, theta) = a.to_polar();
-    if r.is_zero() {
-        return Complex64::new(r, r);
-    }
-    Complex64::from_polar(
-        r.powf(exp.re) * (-exp.im * theta).exp(),
-        exp.re * theta + exp.im * r.ln(),
-    )
-}
-
-impl Constructor for PyComplex {
-    type Args = ComplexArgs;
-
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let imag_missing = args.imag.is_missing();
-        let (real, real_was_complex) = match args.real {
-            OptionalArg::Missing => (Complex64::new(0.0, 0.0), false),
-            OptionalArg::Present(val) => {
-                let val = if cls.is(vm.ctx.types.complex_type) && imag_missing {
-                    match val.downcast_exact::<Self>(vm) {
-                        Ok(c) => {
-                            return Ok(c.into_pyref().into());
-                        }
-                        Err(val) => val,
-                    }
-                } else {
-                    val
-                };
-
-                if let Some(c) = val.try_complex(vm)? {
-                    c
-                } else if let Some(s) = val.payload_if_subclass::<PyStr>(vm) {
-                    if args.imag.is_present() {
-                        return Err(vm.new_type_error(
-                            "complex() can't take second arg if first is a string",
-                        ));
-                    }
-                    let (re, im) = s
-                        .to_str()
-                        .and_then(rustpython_literal::complex::parse_str)
-                        .ok_or_else(|| vm.new_value_error("complex() arg is a malformed string"))?;
-                    return Self::from(Complex64 { re, im })
-                        .into_ref_with_type(vm, cls)
-                        .map(Into::into);
-                } else {
-                    return Err(vm.new_type_error(format!(
-                        "complex() first argument must be a string or a number, not '{}'",
-                        val.class().name()
-                    )));
-                }
-            }
-        };
-
-        let (imag, imag_was_complex) = match args.imag {
-            // Copy the imaginary from the real to the real of the imaginary
-            // if an  imaginary argument is not passed in
-            OptionalArg::Missing => (Complex64::new(real.im, 0.0), false),
-            OptionalArg::Present(obj) => {
-                if let Some(c) = obj.try_complex(vm)? {
-                    c
-                } else if obj.class().fast_issubclass(vm.ctx.types.str_type) {
-                    return Err(vm.new_type_error("complex() second arg can't be a string"));
-                } else {
-                    return Err(vm.new_type_error(format!(
-                        "complex() second argument must be a number, not '{}'",
-                        obj.class().name()
-                    )));
-                }
-            }
-        };
-
-        let final_real = if imag_was_complex {
-            real.re - imag.im
-        } else {
-            real.re
-        };
-
-        let final_imag = if real_was_complex && !imag_missing {
-            imag.re + real.im
-        } else {
-            imag.re
-        };
-        let value = Complex64::new(final_real, final_imag);
-        Self::from(value)
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-}
-
-impl PyComplex {
-    pub fn new_ref(value: Complex64, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(Self::from(value), ctx.types.complex_type.to_owned(), None)
-    }
-
-    pub const fn to_complex(&self) -> Complex64 {
-        self.value
-    }
-}
-
-#[pyclass(
-    flags(BASETYPE),
-    with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
-)]
-impl PyComplex {
-    #[pygetset]
-    const fn real(&self) -> f64 {
-        self.value.re
-    }
-
-    #[pygetset]
-    const fn imag(&self) -> f64 {
-        self.value.im
-    }
-
-    #[pymethod]
-    fn __abs__(&self, vm: &VirtualMachine) -> PyResult<f64> {
-        let Complex64 { im, re } = self.value;
-        let is_finite = im.is_finite() && re.is_finite();
-        let abs_result = re.hypot(im);
-        if is_finite && abs_result.is_infinite() {
-            Err(vm.new_overflow_error("absolute value too large"))
-        } else {
-            Ok(abs_result)
-        }
-    }
-
-    #[inline]
-    fn op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>>
-    where
-        F: Fn(Complex64, Complex64) -> PyResult<Complex64>,
-    {
-        to_op_complex(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a + b), vm)
-    }
-
-    #[pymethod]
-    fn __sub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a - b), vm)
-    }
-
-    #[pymethod]
-    fn __rsub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(b - a), vm)
-    }
-
-    #[pymethod]
-    fn conjugate(&self) -> Complex64 {
-        self.value.conj()
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| Ok(a * b), vm)
-    }
-
-    #[pymethod]
-    fn __truediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_div(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_div(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    const fn __pos__(&self) -> Complex64 {
-        self.value
-    }
-
-    #[pymethod]
-    fn __neg__(&self) -> Complex64 {
-        -self.value
-    }
-
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        mod_val: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        if mod_val.flatten().is_some() {
-            Err(vm.new_value_error("complex modulo not allowed"))
-        } else {
-            self.op(other, |a, b| inner_pow(a, b, vm), vm)
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<Complex64>> {
-        self.op(other, |a, b| inner_pow(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !Complex64::is_zero(&self.value)
-    }
-
-    #[pymethod]
-    const fn __getnewargs__(&self) -> (f64, f64) {
-        let Complex64 { re, im } = self.value;
-        (re, im)
-    }
-
-    #[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))
-            .map_err(|err| err.into_pyexception(vm))
-    }
-}
-
-#[pyclass]
-impl PyRef<PyComplex> {
-    #[pymethod]
-    fn __complex__(self, vm: &VirtualMachine) -> Self {
-        if self.is(vm.ctx.types.complex_type) {
-            self
-        } else {
-            PyComplex::from(self.value).into_ref(&vm.ctx)
-        }
-    }
-}
-
-impl Comparable for PyComplex {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        op.eq_only(|| {
-            let result = if let Some(other) = other.payload_if_subclass::<Self>(vm) {
-                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
-                }
-            } else {
-                match float::to_op_float(other, vm) {
-                    Ok(Some(other)) => zelf.value == other.into(),
-                    Err(_) => false,
-                    Ok(None) => return Ok(PyComparisonValue::NotImplemented),
-                }
-            };
-            Ok(PyComparisonValue::Implemented(result))
-        })
-    }
-}
-
-impl Hashable for PyComplex {
-    #[inline]
-    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        let value = zelf.value;
-
-        let re_hash =
-            hash::hash_float(value.re).unwrap_or_else(|| hash::hash_object_id(zelf.get_id()));
-
-        let im_hash =
-            hash::hash_float(value.im).unwrap_or_else(|| hash::hash_object_id(zelf.get_id()));
-
-        let Wrapping(ret) = Wrapping(re_hash) + Wrapping(im_hash) * Wrapping(hash::IMAG);
-        Ok(hash::fix_sentinel(ret))
-    }
-}
-
-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)),
-            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) {
-                    PyComplex::number_op(a, b, inner_pow, vm)
-                } else {
-                    Err(vm.new_value_error(String::from("complex modulo")))
-                }
-            }),
-            negative: Some(|number, vm| {
-                let value = PyComplex::number_downcast(number).value;
-                (-value).to_pyresult(vm)
-            }),
-            positive: Some(|number, vm| {
-                PyComplex::number_downcast_exact(number, vm).to_pyresult(vm)
-            }),
-            absolute: Some(|number, vm| {
-                let value = PyComplex::number_downcast(number).value;
-                value.norm().to_pyresult(vm)
-            }),
-            boolean: Some(|number, _vm| Ok(PyComplex::number_downcast(number).value.is_zero())),
-            true_divide: Some(|a, b, vm| PyComplex::number_op(a, b, inner_div, vm)),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-
-    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
-        vm.ctx.new_complex(zelf.value)
-    }
-}
-
-impl Representable for PyComplex {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        // TODO: when you fix this, move it to rustpython_common::complex::repr and update
-        //       ast/src/unparse.rs + impl Display for Constant in ast/src/constant.rs
-        let Complex64 { re, im } = zelf.value;
-        Ok(rustpython_literal::complex::to_string(re, im))
-    }
-}
-
-impl PyComplex {
-    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: FnOnce(Complex64, Complex64, &VirtualMachine) -> R,
-        R: ToPyResult,
-    {
-        if let (Some(a), Some(b)) = (to_op_complex(a, vm)?, to_op_complex(b, vm)?) {
-            op(a, b, vm).to_pyresult(vm)
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
-    }
-}
-
-#[derive(FromArgs)]
-pub struct ComplexArgs {
-    #[pyarg(any, optional)]
-    real: OptionalArg<PyObjectRef>,
-    #[pyarg(any, optional)]
-    imag: OptionalArg<PyObjectRef>,
-}
diff --git a/vm/src/builtins/coroutine.rs b/vm/src/builtins/coroutine.rs
deleted file mode 100644
index e084bf50ef..0000000000
--- a/vm/src/builtins/coroutine.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-use super::{PyCode, PyGenericAlias, PyStrRef, PyType, PyTypeRef};
-use crate::{
-    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    coroutine::Coro,
-    frame::FrameRef,
-    function::OptionalArg,
-    protocol::PyIterReturn,
-    types::{IterNext, Iterable, Representable, SelfIter, Unconstructible},
-};
-
-#[pyclass(module = false, name = "coroutine")]
-#[derive(Debug)]
-// PyCoro_Type in CPython
-pub struct PyCoroutine {
-    inner: Coro,
-}
-
-impl PyPayload for PyCoroutine {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.coroutine_type
-    }
-}
-
-#[pyclass(with(Py, Unconstructible, IterNext, Representable))]
-impl PyCoroutine {
-    pub const fn as_coro(&self) -> &Coro {
-        &self.inner
-    }
-
-    pub fn new(frame: FrameRef, name: PyStrRef) -> Self {
-        Self {
-            inner: Coro::new(frame, name),
-        }
-    }
-
-    #[pygetset]
-    fn __name__(&self) -> PyStrRef {
-        self.inner.name()
-    }
-
-    #[pygetset(setter)]
-    fn set___name__(&self, name: PyStrRef) {
-        self.inner.set_name(name)
-    }
-
-    #[pymethod(name = "__await__")]
-    const fn r#await(zelf: PyRef<Self>) -> PyCoroutineWrapper {
-        PyCoroutineWrapper { coro: zelf }
-    }
-
-    #[pygetset]
-    fn cr_await(&self, _vm: &VirtualMachine) -> Option<PyObjectRef> {
-        self.inner.frame().yield_from_target()
-    }
-    #[pygetset]
-    fn cr_frame(&self, _vm: &VirtualMachine) -> FrameRef {
-        self.inner.frame()
-    }
-    #[pygetset]
-    fn cr_running(&self, _vm: &VirtualMachine) -> bool {
-        self.inner.running()
-    }
-    #[pygetset]
-    fn cr_code(&self, _vm: &VirtualMachine) -> PyRef<PyCode> {
-        self.inner.frame().code.clone()
-    }
-    // TODO: coroutine origin tracking:
-    // https://docs.python.org/3/library/sys.html#sys.set_coroutine_origin_tracking_depth
-    #[pygetset]
-    const fn cr_origin(&self, _vm: &VirtualMachine) -> Option<(PyStrRef, usize, PyStrRef)> {
-        None
-    }
-
-    #[pyclassmethod]
-    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::from_args(cls, args, vm)
-    }
-}
-
-#[pyclass]
-impl Py<PyCoroutine> {
-    #[pymethod]
-    fn send(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        self.inner.send(self.as_object(), value, vm)
-    }
-
-    #[pymethod]
-    fn throw(
-        &self,
-        exc_type: PyObjectRef,
-        exc_val: OptionalArg,
-        exc_tb: OptionalArg,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyIterReturn> {
-        self.inner.throw(
-            self.as_object(),
-            exc_type,
-            exc_val.unwrap_or_none(vm),
-            exc_tb.unwrap_or_none(vm),
-            vm,
-        )
-    }
-
-    #[pymethod]
-    fn close(&self, vm: &VirtualMachine) -> PyResult<()> {
-        self.inner.close(self.as_object(), vm)
-    }
-}
-
-impl Unconstructible for PyCoroutine {}
-
-impl Representable for PyCoroutine {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        Ok(zelf.inner.repr(zelf.as_object(), zelf.get_id(), vm))
-    }
-}
-
-impl SelfIter for PyCoroutine {}
-impl IterNext for PyCoroutine {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        zelf.send(vm.ctx.none(), vm)
-    }
-}
-
-#[pyclass(module = false, name = "coroutine_wrapper")]
-#[derive(Debug)]
-// PyCoroWrapper_Type in CPython
-pub struct PyCoroutineWrapper {
-    coro: PyRef<PyCoroutine>,
-}
-
-impl PyPayload for PyCoroutineWrapper {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.coroutine_wrapper_type
-    }
-}
-
-#[pyclass(with(IterNext, Iterable))]
-impl PyCoroutineWrapper {
-    #[pymethod]
-    fn send(&self, val: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        self.coro.send(val, vm)
-    }
-
-    #[pymethod]
-    fn throw(
-        &self,
-        exc_type: PyObjectRef,
-        exc_val: OptionalArg,
-        exc_tb: OptionalArg,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyIterReturn> {
-        self.coro.throw(exc_type, exc_val, exc_tb, vm)
-    }
-}
-
-impl SelfIter for PyCoroutineWrapper {}
-impl IterNext for PyCoroutineWrapper {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        Self::send(zelf, vm.ctx.none(), vm)
-    }
-}
-
-pub fn init(ctx: &Context) {
-    PyCoroutine::extend_class(ctx, ctx.types.coroutine_type);
-    PyCoroutineWrapper::extend_class(ctx, ctx.types.coroutine_wrapper_type);
-}
diff --git a/vm/src/builtins/descriptor.rs b/vm/src/builtins/descriptor.rs
deleted file mode 100644
index 2f4d2169bd..0000000000
--- a/vm/src/builtins/descriptor.rs
+++ /dev/null
@@ -1,378 +0,0 @@
-use super::{PyStr, PyStrInterned, PyType};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyTypeRef, builtin_func::PyNativeMethod, type_},
-    class::PyClassImpl,
-    function::{FuncArgs, PyMethodDef, PyMethodFlags, PySetterValue},
-    types::{Callable, GetDescriptor, Representable, Unconstructible},
-};
-use rustpython_common::lock::PyRwLock;
-
-#[derive(Debug)]
-pub struct PyDescriptor {
-    pub typ: &'static Py<PyType>,
-    pub name: &'static PyStrInterned,
-    pub qualname: PyRwLock<Option<String>>,
-}
-
-#[derive(Debug)]
-pub struct PyDescriptorOwned {
-    pub typ: PyRef<PyType>,
-    pub name: &'static PyStrInterned,
-    pub qualname: PyRwLock<Option<String>>,
-}
-
-#[pyclass(name = "method_descriptor", module = false)]
-pub struct PyMethodDescriptor {
-    pub common: PyDescriptor,
-    pub method: &'static PyMethodDef,
-    // vectorcall: vector_call_func,
-    pub objclass: &'static Py<PyType>, // TODO: move to tp_members
-}
-
-impl PyMethodDescriptor {
-    pub fn new(method: &'static PyMethodDef, typ: &'static Py<PyType>, ctx: &Context) -> Self {
-        Self {
-            common: PyDescriptor {
-                typ,
-                name: ctx.intern_str(method.name),
-                qualname: PyRwLock::new(None),
-            },
-            method,
-            objclass: typ,
-        }
-    }
-}
-
-impl PyPayload for PyMethodDescriptor {
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.method_descriptor_type
-    }
-}
-
-impl std::fmt::Debug for PyMethodDescriptor {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "method descriptor for '{}'", self.common.name)
-    }
-}
-
-impl GetDescriptor for PyMethodDescriptor {
-    fn descr_get(
-        zelf: PyObjectRef,
-        obj: Option<PyObjectRef>,
-        cls: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let descr = Self::_as_pyref(&zelf, vm).unwrap();
-        let bound = match obj {
-            Some(obj) => {
-                if descr.method.flags.contains(PyMethodFlags::METHOD) {
-                    if cls.is_some_and(|c| c.fast_isinstance(vm.ctx.types.type_type)) {
-                        obj
-                    } else {
-                        return Err(vm.new_type_error(format!(
-                            "descriptor '{}' needs a type, not '{}', as arg 2",
-                            descr.common.name.as_str(),
-                            obj.class().name()
-                        )));
-                    }
-                } else if descr.method.flags.contains(PyMethodFlags::CLASS) {
-                    obj.class().to_owned().into()
-                } else {
-                    unimplemented!()
-                }
-            }
-            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())
-    }
-}
-
-impl Callable for PyMethodDescriptor {
-    type Args = FuncArgs;
-    #[inline]
-    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        (zelf.method.func)(vm, args)
-    }
-}
-
-impl PyMethodDescriptor {
-    pub fn bind(&self, obj: PyObjectRef, ctx: &Context) -> PyRef<PyNativeMethod> {
-        self.method.build_bound_method(ctx, obj, self.common.typ)
-    }
-}
-
-#[pyclass(
-    with(GetDescriptor, Callable, Unconstructible, Representable),
-    flags(METHOD_DESCRIPTOR)
-)]
-impl PyMethodDescriptor {
-    #[pygetset]
-    const fn __name__(&self) -> &'static PyStrInterned {
-        self.common.name
-    }
-
-    #[pygetset]
-    fn __qualname__(&self) -> String {
-        format!("{}.{}", self.common.typ.name(), &self.common.name)
-    }
-
-    #[pygetset]
-    const fn __doc__(&self) -> Option<&'static str> {
-        self.method.doc
-    }
-
-    #[pygetset]
-    fn __text_signature__(&self) -> Option<String> {
-        self.method.doc.and_then(|doc| {
-            type_::get_text_signature_from_internal_doc(self.method.name, doc)
-                .map(|signature| signature.to_string())
-        })
-    }
-
-    #[pygetset]
-    fn __objclass__(&self) -> PyTypeRef {
-        self.objclass.to_owned()
-    }
-
-    #[pymethod]
-    fn __reduce__(
-        &self,
-        vm: &VirtualMachine,
-    ) -> (Option<PyObjectRef>, (Option<PyObjectRef>, &'static str)) {
-        let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
-        let classname = vm.builtins.get_attr(&self.common.typ.__name__(vm), vm).ok();
-        (builtins_getattr, (classname, self.method.name))
-    }
-}
-
-impl Representable for PyMethodDescriptor {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(format!(
-            "<method '{}' of '{}' objects>",
-            &zelf.method.name,
-            zelf.common.typ.name()
-        ))
-    }
-}
-
-impl Unconstructible for PyMethodDescriptor {}
-
-#[derive(Debug)]
-pub enum MemberKind {
-    Bool = 14,
-    ObjectEx = 16,
-}
-
-pub type MemberSetterFunc = Option<fn(&VirtualMachine, PyObjectRef, PySetterValue) -> PyResult<()>>;
-
-pub enum MemberGetter {
-    Getter(fn(&VirtualMachine, PyObjectRef) -> PyResult),
-    Offset(usize),
-}
-
-pub enum MemberSetter {
-    Setter(MemberSetterFunc),
-    Offset(usize),
-}
-
-pub struct PyMemberDef {
-    pub name: String,
-    pub kind: MemberKind,
-    pub getter: MemberGetter,
-    pub setter: MemberSetter,
-    pub doc: Option<String>,
-}
-
-impl PyMemberDef {
-    fn get(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        match self.getter {
-            MemberGetter::Getter(getter) => (getter)(vm, obj),
-            MemberGetter::Offset(offset) => get_slot_from_object(obj, offset, self, vm),
-        }
-    }
-
-    fn set(
-        &self,
-        obj: PyObjectRef,
-        value: PySetterValue<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        match self.setter {
-            MemberSetter::Setter(setter) => match setter {
-                Some(setter) => (setter)(vm, obj, value),
-                None => Err(vm.new_attribute_error("readonly attribute")),
-            },
-            MemberSetter::Offset(offset) => set_slot_at_object(obj, offset, self, value, vm),
-        }
-    }
-}
-
-impl std::fmt::Debug for PyMemberDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyMemberDef")
-            .field("name", &self.name)
-            .field("kind", &self.kind)
-            .field("doc", &self.doc)
-            .finish()
-    }
-}
-
-// PyMemberDescrObject in CPython
-#[pyclass(name = "member_descriptor", module = false)]
-#[derive(Debug)]
-pub struct PyMemberDescriptor {
-    pub common: PyDescriptorOwned,
-    pub member: PyMemberDef,
-}
-
-impl PyPayload for PyMemberDescriptor {
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.member_descriptor_type
-    }
-}
-
-fn calculate_qualname(descr: &PyDescriptorOwned, vm: &VirtualMachine) -> PyResult<Option<String>> {
-    if let Some(qualname) = vm.get_attribute_opt(descr.typ.clone().into(), "__qualname__")? {
-        let str = qualname.downcast::<PyStr>().map_err(|_| {
-            vm.new_type_error("<descriptor>.__objclass__.__qualname__ is not a unicode object")
-        })?;
-        Ok(Some(format!("{}.{}", str, descr.name)))
-    } else {
-        Ok(None)
-    }
-}
-
-#[pyclass(with(GetDescriptor, Unconstructible, Representable), flags(BASETYPE))]
-impl PyMemberDescriptor {
-    #[pygetset]
-    fn __doc__(&self) -> Option<String> {
-        self.member.doc.to_owned()
-    }
-
-    #[pygetset]
-    fn __qualname__(&self, vm: &VirtualMachine) -> PyResult<Option<String>> {
-        let qualname = self.common.qualname.read();
-        Ok(if qualname.is_none() {
-            drop(qualname);
-            let calculated = calculate_qualname(&self.common, vm)?;
-            calculated.clone_into(&mut self.common.qualname.write());
-            calculated
-        } else {
-            qualname.to_owned()
-        })
-    }
-
-    #[pyslot]
-    fn descr_set(
-        zelf: &PyObject,
-        obj: PyObjectRef,
-        value: PySetterValue<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let zelf = Self::_as_pyref(zelf, vm)?;
-        zelf.member.set(obj, value, vm)
-    }
-}
-
-// PyMember_GetOne
-fn get_slot_from_object(
-    obj: PyObjectRef,
-    offset: usize,
-    member: &PyMemberDef,
-    vm: &VirtualMachine,
-) -> PyResult {
-    let slot = match member.kind {
-        MemberKind::Bool => obj
-            .get_slot(offset)
-            .unwrap_or_else(|| vm.ctx.new_bool(false).into()),
-        MemberKind::ObjectEx => obj.get_slot(offset).ok_or_else(|| {
-            vm.new_no_attribute_error(obj.clone(), vm.ctx.new_str(member.name.clone()))
-        })?,
-    };
-    Ok(slot)
-}
-
-// PyMember_SetOne
-fn set_slot_at_object(
-    obj: PyObjectRef,
-    offset: usize,
-    member: &PyMemberDef,
-    value: PySetterValue,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    match member.kind {
-        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,
-            };
-            obj.set_slot(offset, value);
-        }
-    }
-
-    Ok(())
-}
-
-impl Unconstructible for PyMemberDescriptor {}
-
-impl Representable for PyMemberDescriptor {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(format!(
-            "<member '{}' of '{}' objects>",
-            zelf.common.name,
-            zelf.common.typ.name(),
-        ))
-    }
-}
-
-impl GetDescriptor for PyMemberDescriptor {
-    fn descr_get(
-        zelf: PyObjectRef,
-        obj: 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 {
-                    if let Ok(cls_type) = cls.downcast::<PyType>() {
-                        if let Some(interned) = vm.ctx.interned_str(descr.member.name.as_str()) {
-                            if let Some(attr) = cls_type.attributes.read().get(&interned) {
-                                return Ok(attr.clone());
-                            }
-                        }
-                    }
-                }
-                Ok(zelf)
-            }
-        }
-    }
-}
-
-pub fn init(ctx: &Context) {
-    PyMemberDescriptor::extend_class(ctx, ctx.types.member_descriptor_type);
-    PyMethodDescriptor::extend_class(ctx, ctx.types.method_descriptor_type);
-}
diff --git a/vm/src/builtins/filter.rs b/vm/src/builtins/filter.rs
deleted file mode 100644
index 5dd0162f83..0000000000
--- a/vm/src/builtins/filter.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use super::{PyType, PyTypeRef};
-use crate::{
-    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    protocol::{PyIter, PyIterReturn},
-    types::{Constructor, IterNext, Iterable, SelfIter},
-};
-
-#[pyclass(module = false, name = "filter", traverse)]
-#[derive(Debug)]
-pub struct PyFilter {
-    predicate: PyObjectRef,
-    iterator: PyIter,
-}
-
-impl PyPayload for PyFilter {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.filter_type
-    }
-}
-
-impl Constructor for PyFilter {
-    type Args = (PyObjectRef, PyIter);
-
-    fn py_new(cls: PyTypeRef, (function, iterator): Self::Args, vm: &VirtualMachine) -> PyResult {
-        Self {
-            predicate: function,
-            iterator,
-        }
-        .into_ref_with_type(vm, cls)
-        .map(Into::into)
-    }
-}
-
-#[pyclass(with(IterNext, Iterable, Constructor), flags(BASETYPE))]
-impl PyFilter {
-    #[pymethod]
-    fn __reduce__(&self, vm: &VirtualMachine) -> (PyTypeRef, (PyObjectRef, PyIter)) {
-        (
-            vm.ctx.types.filter_type.to_owned(),
-            (self.predicate.clone(), self.iterator.clone()),
-        )
-    }
-}
-
-impl SelfIter for PyFilter {}
-impl IterNext for PyFilter {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let predicate = &zelf.predicate;
-        loop {
-            let next_obj = match zelf.iterator.next(vm)? {
-                PyIterReturn::Return(obj) => obj,
-                PyIterReturn::StopIteration(v) => return Ok(PyIterReturn::StopIteration(v)),
-            };
-            let predicate_value = if vm.is_none(predicate) {
-                next_obj.clone()
-            } else {
-                // the predicate itself can raise StopIteration which does stop the filter
-                // iteration
-                match PyIterReturn::from_pyresult(predicate.call((next_obj.clone(),), vm), vm)? {
-                    PyIterReturn::Return(obj) => obj,
-                    PyIterReturn::StopIteration(v) => return Ok(PyIterReturn::StopIteration(v)),
-                }
-            };
-            if predicate_value.try_to_bool(vm)? {
-                return Ok(PyIterReturn::Return(next_obj));
-            }
-        }
-    }
-}
-
-pub fn init(context: &Context) {
-    PyFilter::extend_class(context, context.types.filter_type);
-}
diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs
deleted file mode 100644
index 4982615b04..0000000000
--- a/vm/src/builtins/float.rs
+++ /dev/null
@@ -1,642 +0,0 @@
-use super::{
-    PyByteArray, PyBytes, PyInt, PyIntRef, PyStr, PyStrRef, PyType, PyTypeRef, 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},
-    convert::{IntoPyException, ToPyObject, ToPyResult},
-    function::{
-        ArgBytesLike, OptionalArg, OptionalOption,
-        PyArithmeticValue::{self, *},
-        PyComparisonValue,
-    },
-    protocol::PyNumberMethods,
-    types::{AsNumber, Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
-};
-use malachite_bigint::{BigInt, ToBigInt};
-use num_complex::Complex64;
-use num_traits::{Signed, ToPrimitive, Zero};
-use rustpython_common::int::float_to_ratio;
-
-#[pyclass(module = false, name = "float")]
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct PyFloat {
-    value: f64,
-}
-
-impl PyFloat {
-    pub const fn to_f64(&self) -> f64 {
-        self.value
-    }
-}
-
-impl PyPayload for PyFloat {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.float_type
-    }
-}
-
-impl ToPyObject for f64 {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_float(self).into()
-    }
-}
-impl ToPyObject for f32 {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_float(f64::from(self)).into()
-    }
-}
-
-impl From<f64> for PyFloat {
-    fn from(value: f64) -> Self {
-        Self { value }
-    }
-}
-
-pub(crate) fn to_op_float(obj: &PyObject, vm: &VirtualMachine) -> PyResult<Option<f64>> {
-    let v = if let Some(float) = obj.payload_if_subclass::<PyFloat>(vm) {
-        Some(float.value)
-    } else if let Some(int) = obj.payload_if_subclass::<PyInt>(vm) {
-        Some(try_bigint_to_f64(int.as_bigint(), vm)?)
-    } else {
-        None
-    };
-    Ok(v)
-}
-
-macro_rules! impl_try_from_object_float {
-    ($($t:ty),*) => {
-        $(impl TryFromObject for $t {
-            fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-                PyRef::<PyFloat>::try_from_object(vm, obj).map(|f| f.to_f64() as $t)
-            }
-        })*
-    };
-}
-
-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"))
-}
-
-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"))
-}
-
-pub fn try_to_bigint(value: f64, vm: &VirtualMachine) -> PyResult<BigInt> {
-    match value.to_bigint() {
-        Some(int) => Ok(int),
-        None => {
-            if value.is_infinite() {
-                Err(vm
-                    .new_overflow_error("OverflowError: cannot convert float infinity to integer"))
-            } else if value.is_nan() {
-                Err(vm.new_value_error("ValueError: cannot convert float NaN to integer"))
-            } else {
-                // unreachable unless BigInt has a bug
-                unreachable!(
-                    "A finite float value failed to be converted to bigint: {}",
-                    value
-                )
-            }
-        }
-    }
-}
-
-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"))
-}
-
-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()"))
-}
-
-pub fn float_pow(v1: f64, v2: f64, vm: &VirtualMachine) -> PyResult {
-    if v1.is_zero() && v2.is_sign_negative() {
-        let msg = "0.0 cannot be raised to a negative power";
-        Err(vm.new_zero_division_error(msg.to_owned()))
-    } else if v1.is_sign_negative() && (v2.floor() - v2).abs() > f64::EPSILON {
-        let v1 = Complex64::new(v1, 0.);
-        let v2 = Complex64::new(v2, 0.);
-        Ok(v1.powc(v2).to_pyobject(vm))
-    } else {
-        Ok(v1.powf(v2).to_pyobject(vm))
-    }
-}
-
-impl Constructor for PyFloat {
-    type Args = OptionalArg<PyObjectRef>;
-
-    fn py_new(cls: PyTypeRef, arg: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let float_val = match arg {
-            OptionalArg::Missing => 0.0,
-            OptionalArg::Present(val) => {
-                if cls.is(vm.ctx.types.float_type) && val.class().is(vm.ctx.types.float_type) {
-                    return Ok(val);
-                }
-
-                if let Some(f) = val.try_float_opt(vm) {
-                    f?.value
-                } else {
-                    float_from_string(val, vm)?
-                }
-            }
-        };
-        Self::from(float_val)
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-}
-
-fn float_from_string(val: PyObjectRef, vm: &VirtualMachine) -> PyResult<f64> {
-    let (bytearray, buffer, buffer_lock, mapped_string);
-    let b = if let Some(s) = val.payload_if_subclass::<PyStr>(vm) {
-        use crate::common::str::PyKindStr;
-        match s.as_str_kind() {
-            PyKindStr::Ascii(s) => s.trim().as_bytes(),
-            PyKindStr::Utf8(s) => {
-                mapped_string = s
-                    .trim()
-                    .chars()
-                    .map(|c| {
-                        if let Some(n) = rustpython_common::str::char_to_decimal(c) {
-                            char::from_digit(n.into(), 10).unwrap()
-                        } else if c.is_whitespace() {
-                            ' '
-                        } else {
-                            c
-                        }
-                    })
-                    .collect::<String>();
-                mapped_string.as_bytes()
-            }
-            // if there are surrogates, it's not gonna parse anyway,
-            // so we can just choose a known bad value
-            PyKindStr::Wtf8(_) => b"",
-        }
-    } else if let Some(bytes) = val.payload_if_subclass::<PyBytes>(vm) {
-        bytes.as_bytes()
-    } else if let Some(buf) = val.payload_if_subclass::<PyByteArray>(vm) {
-        bytearray = buf.borrow_buf();
-        &*bytearray
-    } else if let Ok(b) = ArgBytesLike::try_from_borrowed_object(vm, &val) {
-        buffer = b;
-        buffer_lock = buffer.borrow_buf();
-        &*buffer_lock
-    } else {
-        return Err(vm.new_type_error(format!(
-            "float() argument must be a string or a number, not '{}'",
-            val.class().name()
-        )));
-    };
-    crate::literal::float::parse_bytes(b).ok_or_else(|| {
-        val.repr(vm)
-            .map(|repr| vm.new_value_error(format!("could not convert string to float: {repr}")))
-            .unwrap_or_else(|e| e)
-    })
-}
-
-#[pyclass(
-    flags(BASETYPE),
-    with(Comparable, Hashable, Constructor, AsNumber, Representable)
-)]
-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))
-            .map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pystaticmethod]
-    fn __getformat__(spec: PyStrRef, 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'")
-            );
-        }
-
-        const BIG_ENDIAN: bool = cfg!(target_endian = "big");
-
-        Ok(if BIG_ENDIAN {
-            "IEEE, big-endian"
-        } else {
-            "IEEE, little-endian"
-        }
-        .to_owned())
-    }
-
-    #[pymethod]
-    const fn __abs__(&self) -> f64 {
-        self.value.abs()
-    }
-
-    #[inline]
-    fn simple_op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>>
-    where
-        F: Fn(f64, f64) -> PyResult<f64>,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[inline]
-    fn complex_op<F>(&self, other: PyObjectRef, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: Fn(f64, f64) -> PyResult,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(vm.ctx.not_implemented()),
-            |other| op(self.value, other),
-        )
-    }
-
-    #[inline]
-    fn tuple_op<F>(
-        &self,
-        other: PyObjectRef,
-        op: F,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>>
-    where
-        F: Fn(f64, f64) -> PyResult<(f64, f64)>,
-    {
-        to_op_float(&other, vm)?.map_or_else(
-            || Ok(NotImplemented),
-            |other| Ok(Implemented(op(self.value, other)?)),
-        )
-    }
-
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a + b), vm)
-    }
-
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        self.value != 0.0
-    }
-
-    #[pymethod]
-    fn __divmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>> {
-        self.tuple_op(other, |a, b| inner_divmod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rdivmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<(f64, f64)>> {
-        self.tuple_op(other, |a, b| inner_divmod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __floordiv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_floordiv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rfloordiv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_floordiv(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_mod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rmod__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_mod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    const fn __pos__(&self) -> f64 {
-        self.value
-    }
-
-    #[pymethod]
-    const fn __neg__(&self) -> f64 {
-        -self.value
-    }
-
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        mod_val: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        if mod_val.flatten().is_some() {
-            Err(vm.new_type_error("floating point pow() does not accept a 3rd argument"))
-        } else {
-            self.complex_op(other, |a, b| float_pow(a, b, vm), vm)
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.complex_op(other, |a, b| float_pow(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __sub__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a - b), vm)
-    }
-
-    #[pymethod]
-    fn __rsub__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(b - a), vm)
-    }
-
-    #[pymethod]
-    fn __truediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_div(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(
-        &self,
-        other: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| inner_div(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyArithmeticValue<f64>> {
-        self.simple_op(other, |a, b| Ok(a * b), vm)
-    }
-
-    #[pymethod]
-    fn __trunc__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
-        try_to_bigint(self.value, vm)
-    }
-
-    #[pymethod]
-    fn __floor__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
-        try_to_bigint(self.value.floor(), vm)
-    }
-
-    #[pymethod]
-    fn __ceil__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
-        try_to_bigint(self.value.ceil(), vm)
-    }
-
-    #[pymethod]
-    fn __round__(&self, ndigits: OptionalOption<PyIntRef>, vm: &VirtualMachine) -> PyResult {
-        let ndigits = ndigits.flatten();
-        let value = if let Some(ndigits) = ndigits {
-            let ndigits = ndigits.as_bigint();
-            let ndigits = match ndigits.to_i32() {
-                Some(n) => n,
-                None if ndigits.is_positive() => i32::MAX,
-                None => i32::MIN,
-            };
-            let float = float_ops::round_float_digits(self.value, ndigits)
-                .ok_or_else(|| vm.new_overflow_error("overflow occurred during round"))?;
-            vm.ctx.new_float(float).into()
-        } else {
-            let fract = self.value.fract();
-            let value = if (fract.abs() - 0.5).abs() < f64::EPSILON {
-                if self.value.trunc() % 2.0 == 0.0 {
-                    self.value - fract
-                } else {
-                    self.value + fract
-                }
-            } else {
-                self.value.round()
-            };
-            let int = try_to_bigint(value, vm)?;
-            vm.ctx.new_int(int).into()
-        };
-        Ok(value)
-    }
-
-    #[pymethod]
-    fn __int__(&self, vm: &VirtualMachine) -> PyResult<BigInt> {
-        self.__trunc__(vm)
-    }
-
-    #[pymethod]
-    const fn __float__(zelf: PyRef<Self>) -> PyRef<Self> {
-        zelf
-    }
-
-    #[pygetset]
-    const fn real(zelf: PyRef<Self>) -> PyRef<Self> {
-        zelf
-    }
-
-    #[pygetset]
-    const fn imag(&self) -> f64 {
-        0.0f64
-    }
-
-    #[pymethod]
-    const fn conjugate(zelf: PyRef<Self>) -> PyRef<Self> {
-        zelf
-    }
-
-    #[pymethod]
-    fn is_integer(&self) -> bool {
-        crate::literal::float::is_integer(self.value)
-    }
-
-    #[pymethod]
-    fn as_integer_ratio(&self, vm: &VirtualMachine) -> PyResult<(PyIntRef, PyIntRef)> {
-        let value = self.value;
-
-        float_to_ratio(value)
-            .map(|(numer, denom)| (vm.ctx.new_bigint(&numer), vm.ctx.new_bigint(&denom)))
-            .ok_or_else(|| {
-                if value.is_infinite() {
-                    vm.new_overflow_error("cannot convert Infinity to integer ratio")
-                } else if value.is_nan() {
-                    vm.new_value_error("cannot convert NaN to integer ratio")
-                } else {
-                    unreachable!("finite float must able to convert to integer ratio")
-                }
-            })
-    }
-
-    #[pyclassmethod]
-    fn fromhex(cls: PyTypeRef, string: PyStrRef, 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)
-    }
-
-    #[pymethod]
-    fn hex(&self) -> String {
-        crate::literal::float::to_hex(self.value)
-    }
-
-    #[pymethod]
-    fn __getnewargs__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        (self.value,).to_pyobject(vm)
-    }
-}
-
-impl Comparable for PyFloat {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        let ret = if let Some(other) = other.payload_if_subclass::<Self>(vm) {
-            zelf.value
-                .partial_cmp(&other.value)
-                .map_or_else(|| op == PyComparisonOp::Ne, |ord| op.eval_ord(ord))
-        } else if let Some(other) = other.payload_if_subclass::<PyInt>(vm) {
-            let a = zelf.to_f64();
-            let b = other.as_bigint();
-            match op {
-                PyComparisonOp::Lt => float_ops::lt_int(a, b),
-                PyComparisonOp::Le => {
-                    if let (Some(a_int), Some(b_float)) = (a.to_bigint(), b.to_f64()) {
-                        a <= b_float && a_int <= *b
-                    } else {
-                        float_ops::lt_int(a, b)
-                    }
-                }
-                PyComparisonOp::Eq => float_ops::eq_int(a, b),
-                PyComparisonOp::Ne => !float_ops::eq_int(a, b),
-                PyComparisonOp::Ge => {
-                    if let (Some(a_int), Some(b_float)) = (a.to_bigint(), b.to_f64()) {
-                        a >= b_float && a_int >= *b
-                    } else {
-                        float_ops::gt_int(a, b)
-                    }
-                }
-                PyComparisonOp::Gt => float_ops::gt_int(a, b),
-            }
-        } else {
-            return Ok(NotImplemented);
-        };
-        Ok(Implemented(ret))
-    }
-}
-
-impl Hashable for PyFloat {
-    #[inline]
-    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        Ok(hash::hash_float(zelf.to_f64()).unwrap_or_else(|| hash::hash_object_id(zelf.get_id())))
-    }
-}
-
-impl AsNumber for PyFloat {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            add: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a + b, vm)),
-            subtract: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a - b, vm)),
-            multiply: Some(|a, b, vm| PyFloat::number_op(a, b, |a, b, _vm| a * b, vm)),
-            remainder: Some(|a, b, vm| PyFloat::number_op(a, b, inner_mod, vm)),
-            divmod: Some(|a, b, vm| PyFloat::number_op(a, b, inner_divmod, vm)),
-            power: Some(|a, b, c, vm| {
-                if vm.is_none(c) {
-                    PyFloat::number_op(a, b, float_pow, vm)
-                } else {
-                    Err(vm.new_type_error(
-                        "pow() 3rd argument not allowed unless all arguments are integers",
-                    ))
-                }
-            }),
-            negative: Some(|num, vm| {
-                let value = PyFloat::number_downcast(num).value;
-                (-value).to_pyresult(vm)
-            }),
-            positive: Some(|num, vm| PyFloat::number_downcast_exact(num, vm).to_pyresult(vm)),
-            absolute: Some(|num, vm| {
-                let value = PyFloat::number_downcast(num).value;
-                value.abs().to_pyresult(vm)
-            }),
-            boolean: Some(|num, _vm| Ok(PyFloat::number_downcast(num).value.is_zero())),
-            int: Some(|num, vm| {
-                let value = PyFloat::number_downcast(num).value;
-                try_to_bigint(value, vm).map(|x| PyInt::from(x).into_pyobject(vm))
-            }),
-            float: Some(|num, vm| Ok(PyFloat::number_downcast_exact(num, vm).into())),
-            floor_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_floordiv, vm)),
-            true_divide: Some(|a, b, vm| PyFloat::number_op(a, b, inner_div, vm)),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-
-    #[inline]
-    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
-        vm.ctx.new_float(zelf.value)
-    }
-}
-
-impl Representable for PyFloat {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(crate::literal::float::to_string(zelf.value))
-    }
-}
-
-impl PyFloat {
-    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: FnOnce(f64, f64, &VirtualMachine) -> R,
-        R: ToPyResult,
-    {
-        if let (Some(a), Some(b)) = (to_op_float(a, vm)?, to_op_float(b, vm)?) {
-            op(a, b, vm).to_pyresult(vm)
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
-    }
-}
-
-// Retrieve inner float value:
-#[cfg(feature = "serde")]
-pub(crate) fn get_value(obj: &PyObject) -> f64 {
-    obj.payload::<PyFloat>().unwrap().value
-}
-
-#[rustfmt::skip] // to avoid line splitting
-pub fn init(context: &Context) {
-    PyFloat::extend_class(context, context.types.float_type);
-}
diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs
deleted file mode 100644
index 65ac3e798d..0000000000
--- a/vm/src/builtins/frame.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-/*! The python `frame` type.
-
-*/
-
-use super::{PyCode, PyDictRef, PyIntRef, PyStrRef};
-use crate::{
-    AsObject, Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    frame::{Frame, FrameRef},
-    function::PySetterValue,
-    types::{Representable, Unconstructible},
-};
-use num_traits::Zero;
-
-pub fn init(context: &Context) {
-    Frame::extend_class(context, context.types.frame_type);
-}
-
-impl Unconstructible for Frame {}
-
-impl Representable for Frame {
-    #[inline]
-    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        const REPR: &str = "<frame object at .. >";
-        Ok(vm.ctx.intern_str(REPR).to_owned())
-    }
-
-    #[cold]
-    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        unreachable!("use repr instead")
-    }
-}
-
-#[pyclass(with(Unconstructible, Py))]
-impl Frame {
-    #[pymethod]
-    const fn clear(&self) {
-        // TODO
-    }
-
-    #[pygetset]
-    fn f_globals(&self) -> PyDictRef {
-        self.globals.clone()
-    }
-
-    #[pygetset]
-    fn f_locals(&self, vm: &VirtualMachine) -> PyResult {
-        self.locals(vm).map(Into::into)
-    }
-
-    #[pygetset]
-    pub fn f_code(&self) -> PyRef<PyCode> {
-        self.code.clone()
-    }
-
-    #[pygetset]
-    fn f_lasti(&self) -> u32 {
-        self.lasti()
-    }
-
-    #[pygetset]
-    pub fn f_lineno(&self) -> usize {
-        self.current_location().row.get()
-    }
-
-    #[pygetset]
-    fn f_trace(&self) -> PyObjectRef {
-        let boxed = self.trace.lock();
-        boxed.clone()
-    }
-
-    #[pygetset(setter)]
-    fn set_f_trace(&self, value: PySetterValue, vm: &VirtualMachine) {
-        let mut storage = self.trace.lock();
-        *storage = value.unwrap_or_none(vm);
-    }
-
-    #[pymember(type = "bool")]
-    fn f_trace_lines(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
-        let zelf: FrameRef = zelf.downcast().unwrap_or_else(|_| unreachable!());
-
-        let boxed = zelf.trace_lines.lock();
-        Ok(vm.ctx.new_bool(*boxed).into())
-    }
-
-    #[pymember(type = "bool", setter)]
-    fn set_f_trace_lines(
-        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_lines = zelf.trace_lines.lock();
-                *trace_lines = !value.as_bigint().is_zero();
-
-                Ok(())
-            }
-            PySetterValue::Delete => Err(vm.new_type_error("can't delete numeric/char attribute")),
-        }
-    }
-}
-
-#[pyclass]
-impl Py<Frame> {
-    #[pygetset]
-    pub fn f_back(&self, vm: &VirtualMachine) -> Option<PyRef<Frame>> {
-        // TODO: actually store f_back inside Frame struct
-
-        // 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
-            .borrow()
-            .iter()
-            .rev()
-            .skip_while(|p| !p.is(self.as_object()))
-            .nth(1)
-            .cloned()
-    }
-}
diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs
deleted file mode 100644
index a29a077e50..0000000000
--- a/vm/src/builtins/function.rs
+++ /dev/null
@@ -1,880 +0,0 @@
-#[cfg(feature = "jit")]
-mod jit;
-
-use super::{
-    PyAsyncGen, PyCode, PyCoroutine, PyDictRef, PyGenerator, PyStr, PyStrRef, PyTupleRef, PyType,
-    PyTypeRef, tuple::PyTupleTyped,
-};
-#[cfg(feature = "jit")]
-use crate::common::lock::OnceCell;
-use crate::common::lock::PyMutex;
-use crate::convert::{ToPyObject, TryFromObject};
-use crate::function::ArgMapping;
-use crate::object::{Traverse, TraverseFn};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    bytecode,
-    class::PyClassImpl,
-    frame::Frame,
-    function::{FuncArgs, OptionalArg, PyComparisonValue, PySetterValue},
-    scope::Scope,
-    types::{
-        Callable, Comparable, Constructor, GetAttr, GetDescriptor, PyComparisonOp, Representable,
-    },
-};
-use itertools::Itertools;
-#[cfg(feature = "jit")]
-use rustpython_jit::CompiledCode;
-
-#[pyclass(module = false, name = "function", traverse = "manual")]
-#[derive(Debug)]
-pub struct PyFunction {
-    code: PyRef<PyCode>,
-    globals: PyDictRef,
-    builtins: PyObjectRef,
-    closure: Option<PyTupleTyped<PyCellRef>>,
-    defaults_and_kwdefaults: PyMutex<(Option<PyTupleRef>, Option<PyDictRef>)>,
-    name: PyMutex<PyStrRef>,
-    qualname: PyMutex<PyStrRef>,
-    type_params: PyMutex<PyTupleRef>,
-    #[cfg(feature = "jit")]
-    jitted_code: OnceCell<CompiledCode>,
-    annotations: PyMutex<PyDictRef>,
-    module: PyMutex<PyObjectRef>,
-    doc: PyMutex<PyObjectRef>,
-}
-
-unsafe impl Traverse for PyFunction {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.globals.traverse(tracer_fn);
-        self.closure.traverse(tracer_fn);
-        self.defaults_and_kwdefaults.traverse(tracer_fn);
-    }
-}
-
-impl PyFunction {
-    #[allow(clippy::too_many_arguments)]
-    #[inline]
-    pub(crate) fn new(
-        code: PyRef<PyCode>,
-        globals: PyDictRef,
-        closure: Option<PyTupleTyped<PyCellRef>>,
-        defaults: Option<PyTupleRef>,
-        kw_only_defaults: Option<PyDictRef>,
-        qualname: PyStrRef,
-        type_params: PyTupleRef,
-        annotations: PyDictRef,
-        doc: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<Self> {
-        let name = PyMutex::new(code.obj_name.to_owned());
-        let module = vm.unwrap_or_none(globals.get_item_opt(identifier!(vm, __name__), vm)?);
-        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()
-            } else {
-                vm.builtins.clone().into()
-            }
-        });
-
-        let func = Self {
-            code,
-            globals,
-            builtins,
-            closure,
-            defaults_and_kwdefaults: PyMutex::new((defaults, kw_only_defaults)),
-            name,
-            qualname: PyMutex::new(qualname),
-            type_params: PyMutex::new(type_params),
-            annotations: PyMutex::new(annotations),
-            module: PyMutex::new(module),
-            doc: PyMutex::new(doc),
-            #[cfg(feature = "jit")]
-            jitted_code: OnceCell::new(),
-        };
-
-        // let name = qualname.as_str().split('.').next_back().unwrap();
-        // func.set_attr(identifier!(vm, __name__), vm.new_pyobj(name), vm)?;
-        // func.set_attr(identifier!(vm, __qualname__), qualname, vm)?;
-        // func.set_attr(identifier!(vm, __doc__), doc, vm)?;
-
-        Ok(func)
-    }
-
-    fn fill_locals_from_args(
-        &self,
-        frame: &Frame,
-        func_args: FuncArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let code = &*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;
-        // let arg_names = self.code.arg_names();
-
-        // This parses the arguments from args and kwargs into
-        // the proper variables keeping into account default values
-        // and star-args and kwargs.
-        // See also: PyEval_EvalCodeWithName in cpython:
-        // https://github.com/python/cpython/blob/main/Python/ceval.c#L3681
-
-        let mut fastlocals = frame.fastlocals.lock();
-
-        let mut args_iter = func_args.args.into_iter();
-
-        // Copy positional arguments into local variables
-        // zip short-circuits if either iterator returns None, which is the behavior we want --
-        // only fill as much as there is to fill with as much as we have
-        for (local, arg) in Iterator::zip(
-            fastlocals.iter_mut().take(n_expected_args),
-            args_iter.by_ref().take(nargs),
-        ) {
-            *local = Some(arg);
-        }
-
-        let mut vararg_offset = total_args;
-        // Pack other positional arguments in to *args:
-        if code.flags.contains(bytecode::CodeFlags::HAS_VARARGS) {
-            let vararg_value = vm.ctx.new_tuple(args_iter.collect());
-            fastlocals[vararg_offset] = Some(vararg_value.into());
-            vararg_offset += 1;
-        } else {
-            // Check the number of positional arguments
-            if nargs > n_expected_args {
-                return Err(vm.new_type_error(format!(
-                    "{}() takes {} positional arguments but {} were given",
-                    self.__qualname__(),
-                    n_expected_args,
-                    nargs
-                )));
-            }
-        }
-
-        // Do we support `**kwargs` ?
-        let kwargs = if code.flags.contains(bytecode::CodeFlags::HAS_VARKEYWORDS) {
-            let d = vm.ctx.new_dict();
-            fastlocals[vararg_offset] = Some(d.clone().into());
-            Some(d)
-        } else {
-            None
-        };
-
-        let arg_pos = |range: std::ops::Range<_>, name: &str| {
-            code.varnames
-                .iter()
-                .enumerate()
-                .skip(range.start)
-                .take(range.end - range.start)
-                .find(|(_, s)| s.as_str() == name)
-                .map(|(p, _)| p)
-        };
-
-        let mut posonly_passed_as_kwarg = Vec::new();
-        // Handle keyword arguments
-        for (name, value) in func_args.kwargs {
-            // Check if we have a parameter with this name:
-            if let Some(pos) = arg_pos(code.posonlyarg_count as usize..total_args, &name) {
-                let slot = &mut fastlocals[pos];
-                if slot.is_some() {
-                    return Err(vm.new_type_error(format!(
-                        "{}() got multiple values for argument '{}'",
-                        self.__qualname__(),
-                        name
-                    )));
-                }
-                *slot = Some(value);
-            } else if let Some(kwargs) = kwargs.as_ref() {
-                kwargs.set_item(&name, value, vm)?;
-            } else if arg_pos(0..code.posonlyarg_count as usize, &name).is_some() {
-                posonly_passed_as_kwarg.push(name);
-            } else {
-                return Err(vm.new_type_error(format!(
-                    "{}() got an unexpected keyword argument '{}'",
-                    self.__qualname__(),
-                    name
-                )));
-            }
-        }
-        if !posonly_passed_as_kwarg.is_empty() {
-            return Err(vm.new_type_error(format!(
-                "{}() got some positional-only arguments passed as keyword arguments: '{}'",
-                self.__qualname__(),
-                posonly_passed_as_kwarg.into_iter().format(", "),
-            )));
-        }
-
-        let mut defaults_and_kwdefaults = None;
-        // can't be a closure cause it returns a reference to a captured variable :/
-        macro_rules! get_defaults {
-            () => {{
-                defaults_and_kwdefaults
-                    .get_or_insert_with(|| self.defaults_and_kwdefaults.lock().clone())
-            }};
-        }
-
-        // Add missing positional arguments, if we have fewer positional arguments than the
-        // function definition calls for
-        if nargs < n_expected_args {
-            let defaults = get_defaults!().0.as_ref().map(|tup| tup.as_slice());
-            let n_defs = defaults.map_or(0, |d| d.len());
-
-            let n_required = code.arg_count as usize - n_defs;
-
-            // Given the number of defaults available, check all the arguments for which we
-            // _don't_ have defaults; if any are missing, raise an exception
-            let mut missing: Vec<_> = (nargs..n_required)
-                .filter_map(|i| {
-                    if fastlocals[i].is_none() {
-                        Some(&code.varnames[i])
-                    } else {
-                        None
-                    }
-                })
-                .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{}: '{}{}{}'",
-                    self.__qualname__(),
-                    missing_args_len,
-                    if missing_args_len == 1 { "" } else { "s" },
-                    missing.iter().join("', '"),
-                    and,
-                    right,
-                )));
-            }
-
-            if let Some(defaults) = defaults {
-                let n = std::cmp::min(nargs, n_expected_args);
-                let i = n.saturating_sub(n_required);
-
-                // We have sufficient defaults, so iterate over the corresponding names and use
-                // the default if we don't already have a value
-                for i in i..defaults.len() {
-                    let slot = &mut fastlocals[n_required + i];
-                    if slot.is_none() {
-                        *slot = Some(defaults[i].clone());
-                    }
-                }
-            }
-        };
-
-        if code.kwonlyarg_count > 0 {
-            // TODO: compile a list of missing arguments
-            // let mut missing = vec![];
-            // Check if kw only arguments are all present:
-            for (slot, kwarg) in fastlocals
-                .iter_mut()
-                .zip(&*code.varnames)
-                .skip(code.arg_count as usize)
-                .take(code.kwonlyarg_count as usize)
-                .filter(|(slot, _)| slot.is_none())
-            {
-                if let Some(defaults) = &get_defaults!().1 {
-                    if let Some(default) = defaults.get_item_opt(&**kwarg, vm)? {
-                        *slot = Some(default);
-                        continue;
-                    }
-                }
-
-                // No default value and not specified.
-                return Err(
-                    vm.new_type_error(format!("Missing required kw only argument: '{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);
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl Py<PyFunction> {
-    pub fn invoke_with_locals(
-        &self,
-        func_args: FuncArgs,
-        locals: Option<ArgMapping>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        #[cfg(feature = "jit")]
-        if let Some(jitted_code) = self.jitted_code.get() {
-            match jit::get_jit_args(self, &func_args, jitted_code, vm) {
-                Ok(args) => {
-                    return Ok(args.invoke().to_pyobject(vm));
-                }
-                Err(err) => info!(
-                    "jit: function `{}` is falling back to being interpreted because of the \
-                    error: {}",
-                    self.code.obj_name, err
-                ),
-            }
-        }
-
-        let code = &self.code;
-
-        let locals = if self.code.flags.contains(bytecode::CodeFlags::NEW_LOCALS) {
-            ArgMapping::from_dict_exact(vm.ctx.new_dict())
-        } else if let Some(locals) = locals {
-            locals
-        } else {
-            ArgMapping::from_dict_exact(self.globals.clone())
-        };
-
-        // Construct frame:
-        let frame = Frame::new(
-            code.clone(),
-            Scope::new(Some(locals), self.globals.clone()),
-            vm.builtins.dict(),
-            self.closure.as_ref().map_or(&[], |c| c.as_slice()),
-            Some(self.to_owned().into()),
-            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::IS_GENERATOR);
-        let is_coro = code.flags.contains(bytecode::CodeFlags::IS_COROUTINE);
-        match (is_gen, is_coro) {
-            (true, false) => Ok(PyGenerator::new(frame, self.__name__()).into_pyobject(vm)),
-            (false, true) => Ok(PyCoroutine::new(frame, self.__name__()).into_pyobject(vm)),
-            (true, true) => Ok(PyAsyncGen::new(frame, self.__name__()).into_pyobject(vm)),
-            (false, false) => vm.run_frame(frame),
-        }
-    }
-
-    #[inline(always)]
-    pub fn invoke(&self, func_args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        self.invoke_with_locals(func_args, None, vm)
-    }
-}
-
-impl PyPayload for PyFunction {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.function_type
-    }
-}
-
-#[pyclass(
-    with(GetDescriptor, Callable, Representable, Constructor),
-    flags(HAS_DICT, METHOD_DESCRIPTOR)
-)]
-impl PyFunction {
-    #[pygetset]
-    fn __code__(&self) -> PyRef<PyCode> {
-        self.code.clone()
-    }
-
-    #[pygetset]
-    fn __defaults__(&self) -> Option<PyTupleRef> {
-        self.defaults_and_kwdefaults.lock().0.clone()
-    }
-    #[pygetset(setter)]
-    fn set___defaults__(&self, defaults: Option<PyTupleRef>) {
-        self.defaults_and_kwdefaults.lock().0 = defaults
-    }
-
-    #[pygetset]
-    fn __kwdefaults__(&self) -> Option<PyDictRef> {
-        self.defaults_and_kwdefaults.lock().1.clone()
-    }
-    #[pygetset(setter)]
-    fn set___kwdefaults__(&self, kwdefaults: Option<PyDictRef>) {
-        self.defaults_and_kwdefaults.lock().1 = kwdefaults
-    }
-
-    // {"__closure__",   T_OBJECT,     OFF(func_closure), READONLY},
-    // {"__doc__",       T_OBJECT,     OFF(func_doc), 0},
-    // {"__globals__",   T_OBJECT,     OFF(func_globals), READONLY},
-    // {"__module__",    T_OBJECT,     OFF(func_module), 0},
-    // {"__builtins__",  T_OBJECT,     OFF(func_builtins), READONLY},
-    #[pymember]
-    fn __globals__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
-        let zelf = Self::_as_pyref(&zelf, vm)?;
-        Ok(zelf.globals.clone().into())
-    }
-
-    #[pymember]
-    fn __closure__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
-        let zelf = Self::_as_pyref(&zelf, vm)?;
-        Ok(vm.unwrap_or_none(zelf.closure.clone().map(|x| x.to_pyobject(vm))))
-    }
-
-    #[pymember]
-    fn __builtins__(vm: &VirtualMachine, zelf: PyObjectRef) -> PyResult {
-        let zelf = Self::_as_pyref(&zelf, vm)?;
-        Ok(zelf.builtins.clone())
-    }
-
-    #[pygetset]
-    fn __name__(&self) -> PyStrRef {
-        self.name.lock().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___name__(&self, name: PyStrRef) {
-        *self.name.lock() = name;
-    }
-
-    #[pymember]
-    fn __doc__(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult {
-        // When accessed from instance, obj is the PyFunction instance
-        if let Ok(func) = obj.downcast::<Self>() {
-            let doc = func.doc.lock();
-            Ok(doc.clone())
-        } else {
-            // When accessed from class, return None as there's no instance
-            Ok(vm.ctx.none())
-        }
-    }
-
-    #[pymember(setter)]
-    fn set___doc__(vm: &VirtualMachine, zelf: PyObjectRef, value: PySetterValue) -> PyResult<()> {
-        let zelf: PyRef<Self> = zelf.downcast().unwrap_or_else(|_| unreachable!());
-        let value = value.unwrap_or_none(vm);
-        *zelf.doc.lock() = value;
-        Ok(())
-    }
-
-    #[pygetset]
-    fn __module__(&self) -> PyObjectRef {
-        self.module.lock().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___module__(&self, module: PySetterValue<PyObjectRef>, vm: &VirtualMachine) {
-        *self.module.lock() = module.unwrap_or_none(vm);
-    }
-
-    #[pygetset]
-    fn __annotations__(&self) -> PyDictRef {
-        self.annotations.lock().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___annotations__(&self, annotations: PyDictRef) {
-        *self.annotations.lock() = annotations
-    }
-
-    #[pygetset]
-    fn __qualname__(&self) -> PyStrRef {
-        self.qualname.lock().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___qualname__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
-        match value {
-            PySetterValue::Assign(value) => {
-                let Ok(qualname) = value.downcast::<PyStr>() else {
-                    return Err(vm.new_type_error("__qualname__ must be set to a string object"));
-                };
-                *self.qualname.lock() = qualname;
-            }
-            PySetterValue::Delete => {
-                return Err(vm.new_type_error("__qualname__ must be set to a string object"));
-            }
-        }
-        Ok(())
-    }
-
-    #[pygetset]
-    fn __type_params__(&self) -> PyTupleRef {
-        self.type_params.lock().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___type_params__(
-        &self,
-        value: PySetterValue<PyTupleRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        match value {
-            PySetterValue::Assign(value) => {
-                *self.type_params.lock() = value;
-            }
-            PySetterValue::Delete => {
-                return Err(vm.new_type_error("__type_params__ must be set to a tuple object"));
-            }
-        }
-        Ok(())
-    }
-
-    #[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)?;
-                rustpython_jit::compile(&zelf.code.code, &arg_types, ret_type)
-                    .map_err(|err| jit::new_jit_error(err.to_string(), vm))
-            })
-            .map(drop)
-    }
-}
-
-impl GetDescriptor for PyFunction {
-    fn descr_get(
-        zelf: PyObjectRef,
-        obj: Option<PyObjectRef>,
-        cls: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let (_zelf, obj) = Self::_unwrap(&zelf, obj, vm)?;
-        let obj = if vm.is_none(&obj) && !Self::_cls_is(&cls, obj.class()) {
-            zelf
-        } else {
-            PyBoundMethod::new(obj, zelf).into_ref(&vm.ctx).into()
-        };
-        Ok(obj)
-    }
-}
-
-impl Callable for PyFunction {
-    type Args = FuncArgs;
-    #[inline]
-    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        zelf.invoke(args, vm)
-    }
-}
-
-impl Representable for PyFunction {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(format!(
-            "<function {} at {:#x}>",
-            zelf.__qualname__(),
-            zelf.get_id()
-        ))
-    }
-}
-
-#[derive(FromArgs)]
-pub struct PyFunctionNewArgs {
-    #[pyarg(positional)]
-    code: PyRef<PyCode>,
-    #[pyarg(positional)]
-    globals: PyDictRef,
-    #[pyarg(any, optional)]
-    name: OptionalArg<PyStrRef>,
-    #[pyarg(any, optional)]
-    defaults: OptionalArg<PyTupleRef>,
-    #[pyarg(any, optional)]
-    closure: OptionalArg<PyTupleRef>,
-    #[pyarg(any, optional)]
-    kwdefaults: OptionalArg<PyDictRef>,
-}
-
-impl Constructor for PyFunction {
-    type Args = PyFunctionNewArgs;
-
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        // Handle closure - must be a tuple of cells
-        let closure = if let Some(closure_tuple) = args.closure.into_option() {
-            // Check that closure length matches code's free variables
-            if closure_tuple.len() != args.code.freevars.len() {
-                return Err(vm.new_value_error(format!(
-                    "{} requires closure of length {}, not {}",
-                    args.code.obj_name,
-                    args.code.freevars.len(),
-                    closure_tuple.len()
-                )));
-            }
-
-            // Validate that all items are cells and create typed tuple
-            let typed_closure =
-                PyTupleTyped::<PyCellRef>::try_from_object(vm, closure_tuple.into())?;
-            Some(typed_closure)
-        } else if !args.code.freevars.is_empty() {
-            return Err(vm.new_type_error("arg 5 (closure) must be tuple"));
-        } else {
-            None
-        };
-
-        // Get function name - use provided name or default to code object name
-        let name = args
-            .name
-            .into_option()
-            .unwrap_or_else(|| PyStr::from(args.code.obj_name.as_str()).into_ref(&vm.ctx));
-
-        // Get qualname - for now just use the name
-        let qualname = name.clone();
-
-        // Create empty type_params and annotations
-        let type_params = vm.ctx.new_tuple(vec![]);
-        let annotations = vm.ctx.new_dict();
-
-        // Get doc from code object - for now just use None
-        let doc = vm.ctx.none();
-
-        let func = Self::new(
-            args.code,
-            args.globals,
-            closure,
-            args.defaults.into_option(),
-            args.kwdefaults.into_option(),
-            qualname,
-            type_params,
-            annotations,
-            doc,
-            vm,
-        )?;
-
-        func.into_ref_with_type(vm, cls).map(Into::into)
-    }
-}
-
-#[pyclass(module = false, name = "method", traverse)]
-#[derive(Debug)]
-pub struct PyBoundMethod {
-    object: PyObjectRef,
-    function: PyObjectRef,
-}
-
-impl Callable for PyBoundMethod {
-    type Args = FuncArgs;
-    #[inline]
-    fn call(zelf: &Py<Self>, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        args.prepend_arg(zelf.object.clone());
-        zelf.function.call(args, vm)
-    }
-}
-
-impl Comparable for PyBoundMethod {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        _vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        op.eq_only(|| {
-            let other = class_or_notimplemented!(Self, other);
-            Ok(PyComparisonValue::Implemented(
-                zelf.function.is(&other.function) && zelf.object.is(&other.object),
-            ))
-        })
-    }
-}
-
-impl GetAttr for PyBoundMethod {
-    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        let class_attr = vm
-            .ctx
-            .interned_str(name)
-            .and_then(|attr_name| zelf.get_class_attr(attr_name));
-        if let Some(obj) = class_attr {
-            return vm.call_if_get_descriptor(&obj, zelf.to_owned().into());
-        }
-        zelf.function.get_attr(name, vm)
-    }
-}
-
-#[derive(FromArgs)]
-pub struct PyBoundMethodNewArgs {
-    #[pyarg(positional)]
-    function: PyObjectRef,
-    #[pyarg(positional)]
-    object: PyObjectRef,
-}
-
-impl Constructor for PyBoundMethod {
-    type Args = PyBoundMethodNewArgs;
-
-    fn py_new(
-        cls: PyTypeRef,
-        Self::Args { function, object }: Self::Args,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        Self::new(object, function)
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-}
-
-impl PyBoundMethod {
-    pub const fn new(object: PyObjectRef, function: PyObjectRef) -> Self {
-        Self { object, function }
-    }
-
-    pub fn new_ref(object: PyObjectRef, function: PyObjectRef, ctx: &Context) -> PyRef<Self> {
-        PyRef::new_ref(
-            Self::new(object, function),
-            ctx.types.bound_method_type.to_owned(),
-            None,
-        )
-    }
-}
-
-#[pyclass(
-    with(Callable, Comparable, GetAttr, Constructor, Representable),
-    flags(IMMUTABLETYPE)
-)]
-impl PyBoundMethod {
-    #[pymethod]
-    fn __reduce__(
-        &self,
-        vm: &VirtualMachine,
-    ) -> (Option<PyObjectRef>, (PyObjectRef, Option<PyObjectRef>)) {
-        let builtins_getattr = vm.builtins.get_attr("getattr", vm).ok();
-        let func_self = self.object.clone();
-        let func_name = self.function.get_attr("__name__", vm).ok();
-        (builtins_getattr, (func_self, func_name))
-    }
-
-    #[pygetset]
-    fn __doc__(&self, vm: &VirtualMachine) -> PyResult {
-        self.function.get_attr("__doc__", vm)
-    }
-
-    #[pygetset]
-    fn __func__(&self) -> PyObjectRef {
-        self.function.clone()
-    }
-
-    #[pygetset(name = "__self__")]
-    fn get_self(&self) -> PyObjectRef {
-        self.object.clone()
-    }
-
-    #[pygetset]
-    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 {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.bound_method_type
-    }
-}
-
-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());
-        Ok(format!(
-            "<bound method {} of {}>",
-            func_name.as_ref().map_or("?", |s| s.as_str()),
-            &zelf.object.repr(vm)?.as_str(),
-        ))
-    }
-}
-
-#[pyclass(module = false, name = "cell", traverse)]
-#[derive(Debug, Default)]
-pub(crate) struct PyCell {
-    contents: PyMutex<Option<PyObjectRef>>,
-}
-pub(crate) type PyCellRef = PyRef<PyCell>;
-
-impl PyPayload for PyCell {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.cell_type
-    }
-}
-
-impl Constructor for PyCell {
-    type Args = OptionalArg;
-
-    fn py_new(cls: PyTypeRef, value: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Self::new(value.into_option())
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-}
-
-#[pyclass(with(Constructor))]
-impl PyCell {
-    pub const fn new(contents: Option<PyObjectRef>) -> Self {
-        Self {
-            contents: PyMutex::new(contents),
-        }
-    }
-
-    pub fn get(&self) -> Option<PyObjectRef> {
-        self.contents.lock().clone()
-    }
-    pub fn set(&self, x: Option<PyObjectRef>) {
-        *self.contents.lock() = x;
-    }
-
-    #[pygetset]
-    fn cell_contents(&self, vm: &VirtualMachine) -> PyResult {
-        self.get()
-            .ok_or_else(|| vm.new_value_error("Cell is empty"))
-    }
-    #[pygetset(setter)]
-    fn set_cell_contents(&self, x: PySetterValue) {
-        match x {
-            PySetterValue::Assign(value) => self.set(Some(value)),
-            PySetterValue::Delete => self.set(None),
-        }
-    }
-}
-
-pub fn init(context: &Context) {
-    PyFunction::extend_class(context, context.types.function_type);
-    PyBoundMethod::extend_class(context, context.types.bound_method_type);
-    PyCell::extend_class(context, context.types.cell_type);
-}
diff --git a/vm/src/builtins/int.rs b/vm/src/builtins/int.rs
deleted file mode 100644
index 8ae8f30881..0000000000
--- a/vm/src/builtins/int.rs
+++ /dev/null
@@ -1,880 +0,0 @@
-use super::{PyByteArray, PyBytes, PyStr, PyType, PyTypeRef, float};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
-    TryFromBorrowedObject, VirtualMachine,
-    builtins::PyStrRef,
-    bytes_inner::PyBytesInner,
-    class::PyClassImpl,
-    common::{
-        format::FormatSpec,
-        hash,
-        int::{bigint_to_finite_float, bytes_to_int, true_div},
-    },
-    convert::{IntoPyException, ToPyObject, ToPyResult},
-    function::{
-        ArgByteOrder, ArgIntoBool, OptionalArg, OptionalOption, PyArithmeticValue,
-        PyComparisonValue,
-    },
-    protocol::PyNumberMethods,
-    types::{AsNumber, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
-};
-use malachite_bigint::{BigInt, Sign};
-use num_integer::Integer;
-use num_traits::{One, Pow, PrimInt, Signed, ToPrimitive, Zero};
-use std::fmt;
-use std::ops::{Neg, Not};
-
-#[pyclass(module = false, name = "int")]
-#[derive(Debug)]
-pub struct PyInt {
-    value: BigInt,
-}
-
-impl fmt::Display for PyInt {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        BigInt::fmt(&self.value, f)
-    }
-}
-
-pub type PyIntRef = PyRef<PyInt>;
-
-impl<T> From<T> for PyInt
-where
-    T: Into<BigInt>,
-{
-    fn from(v: T) -> Self {
-        Self { value: v.into() }
-    }
-}
-
-impl PyPayload for PyInt {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.int_type
-    }
-
-    fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_int(self.value).into()
-    }
-}
-
-macro_rules! impl_into_pyobject_int {
-    ($($t:ty)*) => {$(
-        impl ToPyObject for $t {
-            fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-                vm.ctx.new_int(self).into()
-            }
-        }
-    )*};
-}
-
-impl_into_pyobject_int!(isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 BigInt);
-
-macro_rules! impl_try_from_object_int {
-    ($(($t:ty, $to_prim:ident),)*) => {$(
-        impl<'a> TryFromBorrowedObject<'a> for $t {
-            fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-                obj.try_value_with(|int: &PyInt| {
-                    int.try_to_primitive(vm)
-                }, vm)
-            }
-        }
-    )*};
-}
-
-impl_try_from_object_int!(
-    (isize, to_isize),
-    (i8, to_i8),
-    (i16, to_i16),
-    (i32, to_i32),
-    (i64, to_i64),
-    (i128, to_i128),
-    (usize, to_usize),
-    (u8, to_u8),
-    (u16, to_u16),
-    (u32, to_u32),
-    (u64, to_u64),
-    (u128, to_u128),
-);
-
-fn inner_pow(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
-    if int2.is_negative() {
-        let v1 = try_to_float(int1, vm)?;
-        let v2 = try_to_float(int2, vm)?;
-        float::float_pow(v1, v2, vm)
-    } else {
-        let value = if let Some(v2) = int2.to_u64() {
-            return Ok(vm.ctx.new_int(Pow::pow(int1, v2)).into());
-        } else if int1.is_one() {
-            1
-        } else if int1.is_zero() {
-            0
-        } else if int1 == &BigInt::from(-1) {
-            if int2.is_odd() { -1 } else { 1 }
-        } else {
-            // missing feature: BigInt exp
-            // practically, exp over u64 is not possible to calculate anyway
-            return Ok(vm.ctx.not_implemented());
-        };
-        Ok(vm.ctx.new_int(value).into())
-    }
-}
-
-fn inner_mod(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
-    if int2.is_zero() {
-        Err(vm.new_zero_division_error("integer modulo by zero"))
-    } else {
-        Ok(vm.ctx.new_int(int1.mod_floor(int2)).into())
-    }
-}
-
-fn inner_floordiv(int1: &BigInt, int2: &BigInt, vm: &VirtualMachine) -> PyResult {
-    if int2.is_zero() {
-        Err(vm.new_zero_division_error("integer division by zero"))
-    } else {
-        Ok(vm.ctx.new_int(int1.div_floor(int2)).into())
-    }
-}
-
-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"));
-    }
-    let (div, modulo) = int1.div_mod_floor(int2);
-    Ok(vm.new_tuple((div, modulo)).into())
-}
-
-fn inner_lshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
-    inner_shift(
-        base,
-        bits,
-        |base, bits| base << bits,
-        |bits, vm| {
-            bits.to_usize()
-                .ok_or_else(|| vm.new_overflow_error("the number is too large to convert to int"))
-        },
-        vm,
-    )
-}
-
-fn inner_rshift(base: &BigInt, bits: &BigInt, vm: &VirtualMachine) -> PyResult {
-    inner_shift(
-        base,
-        bits,
-        |base, bits| base >> bits,
-        |bits, _vm| Ok(bits.to_usize().unwrap_or(usize::MAX)),
-        vm,
-    )
-}
-
-fn inner_shift<F, S>(
-    base: &BigInt,
-    bits: &BigInt,
-    shift_op: F,
-    shift_bits: S,
-    vm: &VirtualMachine,
-) -> PyResult
-where
-    F: Fn(&BigInt, usize) -> BigInt,
-    S: Fn(&BigInt, &VirtualMachine) -> PyResult<usize>,
-{
-    if bits.is_negative() {
-        Err(vm.new_value_error("negative shift count"))
-    } else if base.is_zero() {
-        Ok(vm.ctx.new_int(0).into())
-    } else {
-        shift_bits(bits, vm).map(|bits| vm.ctx.new_int(shift_op(base, bits)).into())
-    }
-}
-
-fn inner_truediv(i1: &BigInt, i2: &BigInt, vm: &VirtualMachine) -> PyResult {
-    if i2.is_zero() {
-        return Err(vm.new_zero_division_error("division by zero"));
-    }
-
-    let float = true_div(i1, i2);
-
-    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(),
-        ))
-    } else {
-        Ok(vm.ctx.new_float(float).into())
-    }
-}
-
-impl Constructor for PyInt {
-    type Args = IntOptions;
-
-    fn py_new(cls: PyTypeRef, options: Self::Args, vm: &VirtualMachine) -> PyResult {
-        if cls.is(vm.ctx.types.bool_type) {
-            return Err(vm.new_type_error("int.__new__(bool) is not safe, use bool.__new__()"));
-        }
-
-        let value = if let OptionalArg::Present(val) = options.val_options {
-            if let OptionalArg::Present(base) = options.base {
-                let base = base
-                    .try_index(vm)?
-                    .as_bigint()
-                    .to_u32()
-                    .filter(|&v| v == 0 || (2..=36).contains(&v))
-                    .ok_or_else(|| vm.new_value_error("int() base must be >= 2 and <= 36, or 0"))?;
-                try_int_radix(&val, base, vm)
-            } else {
-                let val = if cls.is(vm.ctx.types.int_type) {
-                    match val.downcast_exact::<Self>(vm) {
-                        Ok(i) => {
-                            return Ok(i.into_pyref().into());
-                        }
-                        Err(val) => val,
-                    }
-                } else {
-                    val
-                };
-
-                val.try_int(vm).map(|x| x.as_bigint().clone())
-            }
-        } else if let OptionalArg::Present(_) = options.base {
-            Err(vm.new_type_error("int() missing string argument"))
-        } else {
-            Ok(Zero::zero())
-        }?;
-
-        Self::with_value(cls, value, vm).to_pyresult(vm)
-    }
-}
-
-impl PyInt {
-    fn with_value<T>(cls: PyTypeRef, value: T, vm: &VirtualMachine) -> PyResult<PyRef<Self>>
-    where
-        T: Into<BigInt> + ToPrimitive,
-    {
-        if cls.is(vm.ctx.types.int_type) {
-            Ok(vm.ctx.new_int(value))
-        } else if cls.is(vm.ctx.types.bool_type) {
-            Ok(vm.ctx.new_bool(!value.into().eq(&BigInt::zero())))
-        } else {
-            Self::from(value).into_ref_with_type(vm, cls)
-        }
-    }
-
-    pub const fn as_bigint(&self) -> &BigInt {
-        &self.value
-    }
-
-    // _PyLong_AsUnsignedLongMask
-    pub fn as_u32_mask(&self) -> u32 {
-        let v = self.as_bigint();
-        v.to_u32()
-            .or_else(|| v.to_i32().map(|i| i as u32))
-            .unwrap_or_else(|| {
-                let mut out = 0u32;
-                for digit in v.iter_u32_digits() {
-                    out = out.wrapping_shl(32) | digit;
-                }
-                match v.sign() {
-                    Sign::Minus => out * -1i32 as u32,
-                    _ => out,
-                }
-            })
-    }
-
-    pub fn try_to_primitive<'a, I>(&'a self, vm: &VirtualMachine) -> PyResult<I>
-    where
-        I: PrimInt + TryFrom<&'a BigInt>,
-    {
-        I::try_from(self.as_bigint()).map_err(|_| {
-            vm.new_overflow_error(format!(
-                "Python int too large to convert to Rust {}",
-                std::any::type_name::<I>()
-            ))
-        })
-    }
-
-    #[inline]
-    fn int_op<F>(&self, other: PyObjectRef, op: F, vm: &VirtualMachine) -> PyArithmeticValue<BigInt>
-    where
-        F: Fn(&BigInt, &BigInt) -> BigInt,
-    {
-        let r = other
-            .payload_if_subclass::<Self>(vm)
-            .map(|other| op(&self.value, &other.value));
-        PyArithmeticValue::from_option(r)
-    }
-
-    #[inline]
-    fn general_op<F>(&self, other: PyObjectRef, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: Fn(&BigInt, &BigInt) -> PyResult,
-    {
-        if let Some(other) = other.payload_if_subclass::<Self>(vm) {
-            op(&self.value, &other.value)
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
-    }
-}
-
-#[pyclass(
-    flags(BASETYPE),
-    with(PyRef, Comparable, Hashable, Constructor, AsNumber, Representable)
-)]
-impl PyInt {
-    #[pymethod(name = "__radd__")]
-    #[pymethod]
-    fn __add__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a + b, vm)
-    }
-
-    #[pymethod]
-    fn __sub__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a - b, vm)
-    }
-
-    #[pymethod]
-    fn __rsub__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| b - a, vm)
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a * b, vm)
-    }
-
-    #[pymethod]
-    fn __truediv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_truediv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rtruediv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_truediv(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __floordiv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_floordiv(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rfloordiv__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_floordiv(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __lshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_lshift(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rlshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_lshift(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_rshift(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rrshift__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_rshift(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__rxor__")]
-    #[pymethod]
-    pub fn __xor__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a ^ b, vm)
-    }
-
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
-    pub fn __or__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a | b, vm)
-    }
-
-    #[pymethod(name = "__rand__")]
-    #[pymethod]
-    pub fn __and__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmeticValue<BigInt> {
-        self.int_op(other, |a, b| a & b, vm)
-    }
-
-    fn modpow(&self, other: PyObjectRef, modulus: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let modulus = match modulus.payload_if_subclass::<Self>(vm) {
-            Some(val) => val.as_bigint(),
-            None => return Ok(vm.ctx.not_implemented()),
-        };
-        if modulus.is_zero() {
-            return Err(vm.new_value_error("pow() 3rd argument cannot be 0"));
-        }
-
-        self.general_op(
-            other,
-            |a, b| {
-                let i = if b.is_negative() {
-                    // modular multiplicative inverse
-                    // based on rust-num/num-integer#10, should hopefully be published soon
-                    fn normalize(a: BigInt, n: &BigInt) -> BigInt {
-                        let a = a % n;
-                        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))
-                        } else {
-                            None
-                        }
-                    }
-                    let a = inverse(a % modulus, modulus).ok_or_else(|| {
-                        vm.new_value_error("base is not invertible for the given modulus")
-                    })?;
-                    let b = -b;
-                    a.modpow(&b, modulus)
-                } else {
-                    a.modpow(b, modulus)
-                };
-                Ok(vm.ctx.new_int(i).into())
-            },
-            vm,
-        )
-    }
-
-    #[pymethod]
-    fn __pow__(
-        &self,
-        other: PyObjectRef,
-        r#mod: OptionalOption<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        match r#mod.flatten() {
-            Some(modulus) => self.modpow(other, modulus, vm),
-            None => self.general_op(other, |a, b| inner_pow(a, b, vm), vm),
-        }
-    }
-
-    #[pymethod]
-    fn __rpow__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_pow(b, a, vm), vm)
-    }
-
-    #[pymethod(name = "__mod__")]
-    fn mod_(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_mod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_mod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __divmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_divmod(a, b, vm), vm)
-    }
-
-    #[pymethod]
-    fn __rdivmod__(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self.general_op(other, |a, b| inner_divmod(b, a, vm), vm)
-    }
-
-    #[pymethod]
-    fn __neg__(&self) -> BigInt {
-        -(&self.value)
-    }
-
-    #[pymethod]
-    fn __abs__(&self) -> BigInt {
-        self.value.abs()
-    }
-
-    #[pymethod]
-    fn __round__(
-        zelf: PyRef<Self>,
-        ndigits: OptionalArg<PyIntRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyRef<Self>> {
-        if let OptionalArg::Present(ndigits) = ndigits {
-            let ndigits = ndigits.as_bigint();
-            // round(12345, -2) == 12300
-            // If precision >= 0, then any integer is already rounded correctly
-            if let Some(ndigits) = ndigits.neg().to_u32() {
-                if ndigits > 0 {
-                    // Work with positive integers and negate at the end if necessary
-                    let sign = if zelf.value.is_negative() {
-                        BigInt::from(-1)
-                    } else {
-                        BigInt::from(1)
-                    };
-                    let value = zelf.value.abs();
-
-                    // Divide and multiply by the power of 10 to get the approximate answer
-                    let pow10 = BigInt::from(10).pow(ndigits);
-                    let quotient = &value / &pow10;
-                    let rounded = &quotient * &pow10;
-
-                    // Malachite division uses floor rounding, Python uses half-even
-                    let remainder = &value - &rounded;
-                    let half_pow10 = &pow10 / BigInt::from(2);
-                    let correction = if remainder > half_pow10
-                        || (remainder == half_pow10 && quotient.is_odd())
-                    {
-                        pow10
-                    } else {
-                        BigInt::from(0)
-                    };
-                    let rounded = (rounded + correction) * sign;
-                    return Ok(vm.ctx.new_int(rounded));
-                }
-            }
-        }
-        Ok(zelf)
-    }
-
-    #[pymethod]
-    fn __pos__(&self) -> BigInt {
-        self.value.clone()
-    }
-
-    #[pymethod]
-    fn __float__(&self, vm: &VirtualMachine) -> PyResult<f64> {
-        try_to_float(&self.value, vm)
-    }
-
-    #[pymethod]
-    fn __trunc__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pymethod]
-    fn __floor__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pymethod]
-    fn __ceil__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pymethod]
-    fn __index__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pymethod]
-    fn __invert__(&self) -> BigInt {
-        !(&self.value)
-    }
-
-    #[pymethod]
-    fn __format__(&self, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-        FormatSpec::parse(spec.as_str())
-            .and_then(|format_spec| format_spec.format_int(&self.value))
-            .map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pymethod]
-    fn __bool__(&self) -> bool {
-        !self.value.is_zero()
-    }
-
-    #[pymethod]
-    fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + (((self.value.bits() + 7) & !7) / 8) as usize
-    }
-
-    #[pymethod]
-    fn as_integer_ratio(&self, vm: &VirtualMachine) -> (PyRef<Self>, i32) {
-        (vm.ctx.new_bigint(&self.value), 1)
-    }
-
-    #[pymethod]
-    fn bit_length(&self) -> u64 {
-        self.value.bits()
-    }
-
-    #[pymethod]
-    fn conjugate(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pyclassmethod]
-    fn from_bytes(
-        cls: PyTypeRef,
-        args: IntFromByteArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyRef<Self>> {
-        let signed = args.signed.map_or(false, Into::into);
-        let value = match (args.byteorder, signed) {
-            (ArgByteOrder::Big, true) => BigInt::from_signed_bytes_be(args.bytes.as_bytes()),
-            (ArgByteOrder::Big, false) => BigInt::from_bytes_be(Sign::Plus, args.bytes.as_bytes()),
-            (ArgByteOrder::Little, true) => BigInt::from_signed_bytes_le(args.bytes.as_bytes()),
-            (ArgByteOrder::Little, false) => {
-                BigInt::from_bytes_le(Sign::Plus, args.bytes.as_bytes())
-            }
-        };
-        Self::with_value(cls, value, vm)
-    }
-
-    #[pymethod]
-    fn to_bytes(&self, args: IntToByteArgs, vm: &VirtualMachine) -> PyResult<PyBytes> {
-        let signed = args.signed.map_or(false, Into::into);
-        let byte_len = args.length;
-
-        let value = self.as_bigint();
-        match value.sign() {
-            Sign::Minus if !signed => {
-                return Err(vm.new_overflow_error("can't convert negative int to unsigned"));
-            }
-            Sign::NoSign => return Ok(vec![0u8; byte_len].into()),
-            _ => {}
-        }
-
-        let mut origin_bytes = match (args.byteorder, signed) {
-            (ArgByteOrder::Big, true) => value.to_signed_bytes_be(),
-            (ArgByteOrder::Big, false) => value.to_bytes_be().1,
-            (ArgByteOrder::Little, true) => value.to_signed_bytes_le(),
-            (ArgByteOrder::Little, false) => value.to_bytes_le().1,
-        };
-
-        let origin_len = origin_bytes.len();
-        if origin_len > byte_len {
-            return Err(vm.new_overflow_error("int too big to convert"));
-        }
-
-        let mut append_bytes = match value.sign() {
-            Sign::Minus => vec![255u8; byte_len - origin_len],
-            _ => vec![0u8; byte_len - origin_len],
-        };
-
-        let bytes = match args.byteorder {
-            ArgByteOrder::Big => {
-                let mut bytes = append_bytes;
-                bytes.append(&mut origin_bytes);
-                bytes
-            }
-            ArgByteOrder::Little => {
-                let mut bytes = origin_bytes;
-                bytes.append(&mut append_bytes);
-                bytes
-            }
-        };
-        Ok(bytes.into())
-    }
-
-    #[pygetset]
-    fn real(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pygetset]
-    const fn imag(&self) -> usize {
-        0
-    }
-
-    #[pygetset]
-    fn numerator(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyRefExact<Self> {
-        zelf.__int__(vm)
-    }
-
-    #[pygetset]
-    const fn denominator(&self) -> usize {
-        1
-    }
-
-    #[pymethod]
-    /// Returns the number of ones 1 an int. When the number is < 0,
-    /// then it returns the number of ones of the absolute value.
-    fn bit_count(&self) -> u32 {
-        self.value.iter_u32_digits().map(|n| n.count_ones()).sum()
-    }
-
-    #[pymethod]
-    fn __getnewargs__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        (self.value.clone(),).to_pyobject(vm)
-    }
-}
-
-#[pyclass]
-impl PyRef<PyInt> {
-    #[pymethod]
-    fn __int__(self, vm: &VirtualMachine) -> PyRefExact<PyInt> {
-        self.into_exact_or(&vm.ctx, |zelf| unsafe {
-            // TODO: this is actually safe. we need better interface
-            PyRefExact::new_unchecked(vm.ctx.new_bigint(&zelf.value))
-        })
-    }
-}
-
-impl Comparable for PyInt {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        let r = other
-            .payload_if_subclass::<Self>(vm)
-            .map(|other| op.eval_ord(zelf.value.cmp(&other.value)));
-        Ok(PyComparisonValue::from_option(r))
-    }
-}
-
-impl Representable for PyInt {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        Ok(zelf.value.to_string())
-    }
-}
-
-impl Hashable for PyInt {
-    #[inline]
-    fn hash(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        Ok(hash::hash_bigint(zelf.as_bigint()))
-    }
-}
-
-impl AsNumber for PyInt {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyInt::AS_NUMBER;
-        &AS_NUMBER
-    }
-
-    #[inline]
-    fn clone_exact(zelf: &Py<Self>, vm: &VirtualMachine) -> PyRef<Self> {
-        vm.ctx.new_bigint(&zelf.value)
-    }
-}
-
-impl PyInt {
-    pub(super) const AS_NUMBER: PyNumberMethods = PyNumberMethods {
-        add: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a + b, vm)),
-        subtract: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a - b, vm)),
-        multiply: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a * b, vm)),
-        remainder: Some(|a, b, vm| Self::number_op(a, b, inner_mod, vm)),
-        divmod: Some(|a, b, vm| Self::number_op(a, b, inner_divmod, vm)),
-        power: Some(|a, b, c, vm| {
-            if let (Some(a), Some(b)) = (
-                a.payload::<Self>(),
-                if b.payload_is::<Self>() {
-                    Some(b)
-                } else {
-                    None
-                },
-            ) {
-                if vm.is_none(c) {
-                    a.general_op(b.to_owned(), |a, b| inner_pow(a, b, vm), vm)
-                } else {
-                    a.modpow(b.to_owned(), c.to_owned(), vm)
-                }
-            } else {
-                Ok(vm.ctx.not_implemented())
-            }
-        }),
-        negative: Some(|num, vm| (&Self::number_downcast(num).value).neg().to_pyresult(vm)),
-        positive: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
-        absolute: Some(|num, vm| Self::number_downcast(num).value.abs().to_pyresult(vm)),
-        boolean: Some(|num, _vm| Ok(Self::number_downcast(num).value.is_zero())),
-        invert: Some(|num, vm| (&Self::number_downcast(num).value).not().to_pyresult(vm)),
-        lshift: Some(|a, b, vm| Self::number_op(a, b, inner_lshift, vm)),
-        rshift: Some(|a, b, vm| Self::number_op(a, b, inner_rshift, vm)),
-        and: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a & b, vm)),
-        xor: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a ^ b, vm)),
-        or: Some(|a, b, vm| Self::number_op(a, b, |a, b, _vm| a | b, vm)),
-        int: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
-        float: Some(|num, vm| {
-            let zelf = Self::number_downcast(num);
-            try_to_float(&zelf.value, vm).map(|x| vm.ctx.new_float(x).into())
-        }),
-        floor_divide: Some(|a, b, vm| Self::number_op(a, b, inner_floordiv, vm)),
-        true_divide: Some(|a, b, vm| Self::number_op(a, b, inner_truediv, vm)),
-        index: Some(|num, vm| Ok(Self::number_downcast_exact(num, vm).into())),
-        ..PyNumberMethods::NOT_IMPLEMENTED
-    };
-
-    fn number_op<F, R>(a: &PyObject, b: &PyObject, op: F, vm: &VirtualMachine) -> PyResult
-    where
-        F: FnOnce(&BigInt, &BigInt, &VirtualMachine) -> R,
-        R: ToPyResult,
-    {
-        if let (Some(a), Some(b)) = (a.payload::<Self>(), b.payload::<Self>()) {
-            op(&a.value, &b.value, vm).to_pyresult(vm)
-        } else {
-            Ok(vm.ctx.not_implemented())
-        }
-    }
-}
-
-#[derive(FromArgs)]
-pub struct IntOptions {
-    #[pyarg(positional, optional)]
-    val_options: OptionalArg<PyObjectRef>,
-    #[pyarg(any, optional)]
-    base: OptionalArg<PyObjectRef>,
-}
-
-#[derive(FromArgs)]
-struct IntFromByteArgs {
-    bytes: PyBytesInner,
-    #[pyarg(any, default = ArgByteOrder::Big)]
-    byteorder: ArgByteOrder,
-    #[pyarg(named, optional)]
-    signed: OptionalArg<ArgIntoBool>,
-}
-
-#[derive(FromArgs)]
-struct IntToByteArgs {
-    #[pyarg(any, default = 1)]
-    length: usize,
-    #[pyarg(any, default = ArgByteOrder::Big)]
-    byteorder: ArgByteOrder,
-    #[pyarg(named, optional)]
-    signed: OptionalArg<ArgIntoBool>,
-}
-
-fn try_int_radix(obj: &PyObject, base: u32, vm: &VirtualMachine) -> PyResult<BigInt> {
-    debug_assert!(base == 0 || (2..=36).contains(&base));
-
-    let opt = match_class!(match obj.to_owned() {
-        string @ PyStr => {
-            let s = string.as_wtf8().trim();
-            bytes_to_int(s.as_bytes(), base)
-        }
-        bytes @ PyBytes => {
-            let bytes = bytes.as_bytes();
-            bytes_to_int(bytes, base)
-        }
-        bytearray @ PyByteArray => {
-            let inner = bytearray.borrow_buf();
-            bytes_to_int(&inner, base)
-        }
-        _ => {
-            return Err(vm.new_type_error("int() can't convert non-string with explicit base"));
-        }
-    });
-    match opt {
-        Some(int) => Ok(int),
-        None => Err(vm.new_value_error(format!(
-            "invalid literal for int() with base {}: {}",
-            base,
-            obj.repr(vm)?,
-        ))),
-    }
-}
-
-// Retrieve inner int value:
-pub(crate) fn get_value(obj: &PyObject) -> &BigInt {
-    &obj.payload::<PyInt>().unwrap().value
-}
-
-pub fn try_to_float(int: &BigInt, vm: &VirtualMachine) -> PyResult<f64> {
-    bigint_to_finite_float(int)
-        .ok_or_else(|| vm.new_overflow_error("int too large to convert to float"))
-}
-
-pub(crate) fn init(context: &Context) {
-    PyInt::extend_class(context, context.types.int_type);
-}
diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs
deleted file mode 100644
index bea427e696..0000000000
--- a/vm/src/builtins/iter.rs
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
- * iterator types
- */
-
-use super::{PyInt, PyTupleRef, PyType};
-use crate::{
-    Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    function::ArgCallable,
-    object::{Traverse, TraverseFn},
-    protocol::{PyIterReturn, PySequence, PySequenceMethods},
-    types::{IterNext, Iterable, SelfIter},
-};
-use rustpython_common::{
-    lock::{PyMutex, PyRwLock, PyRwLockUpgradableReadGuard},
-    static_cell,
-};
-
-/// Marks status of iterator.
-#[derive(Debug, Clone)]
-pub enum IterStatus<T> {
-    /// Iterator hasn't raised StopIteration.
-    Active(T),
-    /// Iterator has raised StopIteration.
-    Exhausted,
-}
-
-unsafe impl<T: Traverse> Traverse for IterStatus<T> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        match self {
-            Self::Active(r) => r.traverse(tracer_fn),
-            Self::Exhausted => (),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct PositionIterInternal<T> {
-    pub status: IterStatus<T>,
-    pub position: usize,
-}
-
-unsafe impl<T: Traverse> Traverse for PositionIterInternal<T> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.status.traverse(tracer_fn)
-    }
-}
-
-impl<T> PositionIterInternal<T> {
-    pub const fn new(obj: T, position: usize) -> Self {
-        Self {
-            status: IterStatus::Active(obj),
-            position,
-        }
-    }
-
-    pub fn set_state<F>(&mut self, state: PyObjectRef, f: F, vm: &VirtualMachine) -> PyResult<()>
-    where
-        F: FnOnce(&T, usize) -> usize,
-    {
-        if let IterStatus::Active(obj) = &self.status {
-            if let Some(i) = state.payload::<PyInt>() {
-                let i = i.try_to_primitive(vm).unwrap_or(0);
-                self.position = f(obj, i);
-                Ok(())
-            } else {
-                Err(vm.new_type_error("an integer is required."))
-            }
-        } else {
-            Ok(())
-        }
-    }
-
-    fn _reduce<F>(&self, func: PyObjectRef, f: F, vm: &VirtualMachine) -> PyTupleRef
-    where
-        F: FnOnce(&T) -> PyObjectRef,
-    {
-        if let IterStatus::Active(obj) = &self.status {
-            vm.new_tuple((func, (f(obj),), self.position))
-        } else {
-            vm.new_tuple((func, (vm.ctx.new_list(Vec::new()),)))
-        }
-    }
-
-    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>,
-        OP: FnOnce(&mut Self),
-    {
-        if let IterStatus::Active(obj) = &self.status {
-            let ret = f(obj, self.position);
-            if let Ok(PyIterReturn::Return(_)) = ret {
-                op(self);
-            } else {
-                self.status = IterStatus::Exhausted;
-            }
-            ret
-        } else {
-            Ok(PyIterReturn::StopIteration(None))
-        }
-    }
-
-    pub fn next<F>(&mut self, f: F) -> PyResult<PyIterReturn>
-    where
-        F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,
-    {
-        self._next(f, |zelf| zelf.position += 1)
-    }
-
-    pub fn rev_next<F>(&mut self, f: F) -> PyResult<PyIterReturn>
-    where
-        F: FnOnce(&T, usize) -> PyResult<PyIterReturn>,
-    {
-        self._next(f, |zelf| {
-            if zelf.position == 0 {
-                zelf.status = IterStatus::Exhausted;
-            } else {
-                zelf.position -= 1;
-            }
-        })
-    }
-
-    pub fn length_hint<F>(&self, f: F) -> usize
-    where
-        F: FnOnce(&T) -> usize,
-    {
-        if let IterStatus::Active(obj) = &self.status {
-            f(obj).saturating_sub(self.position)
-        } else {
-            0
-        }
-    }
-
-    pub fn rev_length_hint<F>(&self, f: F) -> usize
-    where
-        F: FnOnce(&T) -> usize,
-    {
-        if let IterStatus::Active(obj) = &self.status {
-            if self.position <= f(obj) {
-                return self.position + 1;
-            }
-        }
-        0
-    }
-}
-
-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_reversed(vm: &VirtualMachine) -> &PyObject {
-    static_cell! {
-        static INSTANCE: PyObjectRef;
-    }
-    INSTANCE.get_or_init(|| vm.builtins.get_attr("reversed", vm).unwrap())
-}
-
-#[pyclass(module = false, name = "iterator", traverse)]
-#[derive(Debug)]
-pub struct PySequenceIterator {
-    // cached sequence methods
-    #[pytraverse(skip)]
-    seq_methods: &'static PySequenceMethods,
-    internal: PyMutex<PositionIterInternal<PyObjectRef>>,
-}
-
-impl PyPayload for PySequenceIterator {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.iter_type
-    }
-}
-
-#[pyclass(with(IterNext, Iterable))]
-impl PySequenceIterator {
-    pub fn new(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Self> {
-        let seq = PySequence::try_protocol(&obj, vm)?;
-        Ok(Self {
-            seq_methods: seq.methods,
-            internal: PyMutex::new(PositionIterInternal::new(obj, 0)),
-        })
-    }
-
-    #[pymethod]
-    fn __length_hint__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        let internal = self.internal.lock();
-        if let IterStatus::Active(obj) = &internal.status {
-            let seq = PySequence {
-                obj,
-                methods: self.seq_methods,
-            };
-            seq.length(vm)
-                .map(|x| PyInt::from(x).into_pyobject(vm))
-                .unwrap_or_else(|_| vm.ctx.not_implemented())
-        } else {
-            PyInt::from(0).into_pyobject(vm)
-        }
-    }
-
-    #[pymethod]
-    fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal.lock().builtins_iter_reduce(|x| x.clone(), vm)
-    }
-
-    #[pymethod]
-    fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self.internal.lock().set_state(state, |_, pos| pos, vm)
-    }
-}
-
-impl SelfIter for PySequenceIterator {}
-impl IterNext for PySequenceIterator {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        zelf.internal.lock().next(|obj, pos| {
-            let seq = PySequence {
-                obj,
-                methods: zelf.seq_methods,
-            };
-            PyIterReturn::from_getitem_result(seq.get_item(pos as isize, vm), vm)
-        })
-    }
-}
-
-#[pyclass(module = false, name = "callable_iterator", traverse)]
-#[derive(Debug)]
-pub struct PyCallableIterator {
-    sentinel: PyObjectRef,
-    status: PyRwLock<IterStatus<ArgCallable>>,
-}
-
-impl PyPayload for PyCallableIterator {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.callable_iterator
-    }
-}
-
-#[pyclass(with(IterNext, Iterable))]
-impl PyCallableIterator {
-    pub const fn new(callable: ArgCallable, sentinel: PyObjectRef) -> Self {
-        Self {
-            sentinel,
-            status: PyRwLock::new(IterStatus::Active(callable)),
-        }
-    }
-}
-
-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)
-            }
-        } else {
-            PyIterReturn::StopIteration(None)
-        };
-        Ok(next)
-    }
-}
-
-pub fn init(context: &Context) {
-    PySequenceIterator::extend_class(context, context.types.iter_type);
-    PyCallableIterator::extend_class(context, context.types.callable_iterator);
-}
diff --git a/vm/src/builtins/mod.rs b/vm/src/builtins/mod.rs
deleted file mode 100644
index 8540e6887c..0000000000
--- a/vm/src/builtins/mod.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! This package contains the python basic/builtin types
-//! 7 common PyRef type aliases are exposed - [`PyBytesRef`], [`PyDictRef`], [`PyIntRef`], [`PyListRef`], [`PyStrRef`], [`PyTypeRef`], [`PyTupleRef`]
-//! Do not add more PyRef type aliases. They will be rare enough to use directly `PyRef<T>`.
-
-pub(crate) mod asyncgenerator;
-pub use asyncgenerator::PyAsyncGen;
-pub(crate) mod builtin_func;
-pub(crate) mod bytearray;
-pub use bytearray::PyByteArray;
-pub(crate) mod bytes;
-pub use bytes::{PyBytes, PyBytesRef};
-pub(crate) mod classmethod;
-pub use classmethod::PyClassMethod;
-pub(crate) mod code;
-pub use code::PyCode;
-pub(crate) mod complex;
-pub use complex::PyComplex;
-pub(crate) mod coroutine;
-pub use coroutine::PyCoroutine;
-pub(crate) mod dict;
-pub use dict::{PyDict, PyDictRef};
-pub(crate) mod enumerate;
-pub use enumerate::PyEnumerate;
-pub(crate) mod filter;
-pub use filter::PyFilter;
-pub(crate) mod float;
-pub use float::PyFloat;
-pub(crate) mod frame;
-pub(crate) mod function;
-pub use function::{PyBoundMethod, PyFunction};
-pub(crate) mod generator;
-pub use generator::PyGenerator;
-pub(crate) mod genericalias;
-pub use genericalias::PyGenericAlias;
-pub(crate) mod getset;
-pub use getset::PyGetSet;
-pub(crate) mod int;
-pub use int::{PyInt, PyIntRef};
-pub(crate) mod iter;
-pub use iter::*;
-pub(crate) mod list;
-pub use list::{PyList, PyListRef};
-pub(crate) mod map;
-pub use map::PyMap;
-pub(crate) mod mappingproxy;
-pub use mappingproxy::PyMappingProxy;
-pub(crate) mod memory;
-pub use memory::PyMemoryView;
-pub(crate) mod module;
-pub use module::{PyModule, PyModuleDef};
-pub(crate) mod namespace;
-pub use namespace::PyNamespace;
-pub(crate) mod object;
-pub use object::PyBaseObject;
-pub(crate) mod property;
-pub use property::PyProperty;
-#[path = "bool.rs"]
-pub(crate) mod bool_;
-pub use bool_::PyBool;
-#[path = "str.rs"]
-pub(crate) mod pystr;
-pub use pystr::{PyStr, PyStrInterned, PyStrRef};
-#[path = "super.rs"]
-pub(crate) mod super_;
-pub use super_::PySuper;
-#[path = "type.rs"]
-pub(crate) mod type_;
-pub use type_::{PyType, PyTypeRef};
-pub(crate) mod range;
-pub use range::PyRange;
-pub(crate) mod set;
-pub use set::{PyFrozenSet, PySet};
-pub(crate) mod singletons;
-pub use singletons::{PyNone, PyNotImplemented};
-pub(crate) mod slice;
-pub use slice::{PyEllipsis, PySlice};
-pub(crate) mod staticmethod;
-pub use staticmethod::PyStaticMethod;
-pub(crate) mod traceback;
-pub use traceback::PyTraceback;
-pub(crate) mod tuple;
-pub use tuple::{PyTuple, PyTupleRef};
-pub(crate) mod weakproxy;
-pub use weakproxy::PyWeakProxy;
-pub(crate) mod weakref;
-pub use weakref::PyWeak;
-pub(crate) mod zip;
-pub use zip::PyZip;
-#[path = "union.rs"]
-pub(crate) mod union_;
-pub use union_::PyUnion;
-pub(crate) mod descriptor;
-
-pub use float::try_to_bigint as try_f64_to_bigint;
-pub use int::try_to_float as try_bigint_to_f64;
-
-pub use crate::exceptions::types::*;
diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs
deleted file mode 100644
index f8e42b28e0..0000000000
--- a/vm/src/builtins/module.rs
+++ /dev/null
@@ -1,226 +0,0 @@
-use super::{PyDict, PyDictRef, PyStr, PyStrRef, PyType, PyTypeRef};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyStrInterned, pystr::AsPyStr},
-    class::PyClassImpl,
-    convert::ToPyObject,
-    function::{FuncArgs, PyMethodDef},
-    types::{GetAttr, Initializer, Representable},
-};
-
-#[pyclass(module = false, name = "module")]
-#[derive(Debug)]
-pub struct PyModuleDef {
-    // pub index: usize,
-    pub name: &'static PyStrInterned,
-    pub doc: Option<&'static PyStrInterned>,
-    // pub size: isize,
-    pub methods: &'static [PyMethodDef],
-    pub slots: PyModuleSlots,
-    // traverse: traverse_proc
-    // clear: inquiry
-    // free: free_func
-}
-
-pub type ModuleCreate =
-    fn(&VirtualMachine, &PyObject, &'static PyModuleDef) -> PyResult<PyRef<PyModule>>;
-pub type ModuleExec = fn(&VirtualMachine, &Py<PyModule>) -> PyResult<()>;
-
-#[derive(Default)]
-pub struct PyModuleSlots {
-    pub create: Option<ModuleCreate>,
-    pub exec: Option<ModuleExec>,
-}
-
-impl std::fmt::Debug for PyModuleSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyModuleSlots")
-            .field("create", &self.create.is_some())
-            .field("exec", &self.exec.is_some())
-            .finish()
-    }
-}
-
-#[allow(clippy::new_without_default)] // avoid Default implementation
-#[pyclass(module = false, name = "module")]
-#[derive(Debug)]
-pub struct PyModule {
-    // PyObject *md_dict;
-    pub def: Option<&'static PyModuleDef>,
-    // state: Any
-    // weaklist
-    // for logging purposes after md_dict is cleared
-    pub name: Option<&'static PyStrInterned>,
-}
-
-impl PyPayload for PyModule {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.module_type
-    }
-}
-
-#[derive(FromArgs)]
-pub struct ModuleInitArgs {
-    name: PyStrRef,
-    #[pyarg(any, default)]
-    doc: Option<PyStrRef>,
-}
-
-impl PyModule {
-    #[allow(clippy::new_without_default)]
-    pub const fn new() -> Self {
-        Self {
-            def: None,
-            name: None,
-        }
-    }
-
-    pub const fn from_def(def: &'static PyModuleDef) -> Self {
-        Self {
-            def: Some(def),
-            name: Some(def.name),
-        }
-    }
-
-    pub fn __init_dict_from_def(vm: &VirtualMachine, module: &Py<Self>) {
-        let doc = module.def.unwrap().doc.map(|doc| doc.to_owned());
-        module.init_dict(module.name.unwrap(), doc, vm);
-    }
-}
-
-impl Py<PyModule> {
-    pub fn __init_methods(&self, vm: &VirtualMachine) -> PyResult<()> {
-        debug_assert!(self.def.is_some());
-        for method in self.def.unwrap().methods {
-            let func = method
-                .to_function()
-                .with_module(self.name.unwrap())
-                .into_ref(&vm.ctx);
-            vm.__module_set_attr(self, vm.ctx.intern_str(method.name), func)?;
-        }
-        Ok(())
-    }
-
-    fn getattr_inner(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        if let Some(attr) = self.as_object().generic_getattr_opt(name, None, vm)? {
-            return Ok(attr);
-        }
-        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}'")
-        } else {
-            "".to_owned()
-        };
-        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()
-    }
-
-    // TODO: to be replaced by the commented-out dict method above once dictoffset land
-    pub fn dict(&self) -> PyDictRef {
-        self.as_object().dict().unwrap()
-    }
-
-    // TODO: should be on PyModule, not Py<PyModule>
-    pub(crate) fn init_dict(
-        &self,
-        name: &'static PyStrInterned,
-        doc: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) {
-        let dict = self.dict();
-        dict.set_item(identifier!(vm, __name__), name.to_object(), vm)
-            .expect("Failed to set __name__ on module");
-        dict.set_item(identifier!(vm, __doc__), doc.to_pyobject(vm), vm)
-            .expect("Failed to set __doc__ on module");
-        dict.set_item("__package__", vm.ctx.none(), vm)
-            .expect("Failed to set __package__ on module");
-        dict.set_item("__loader__", vm.ctx.none(), vm)
-            .expect("Failed to set __loader__ on module");
-        dict.set_item("__spec__", vm.ctx.none(), vm)
-            .expect("Failed to set __spec__ on module");
-    }
-
-    pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
-        let attr_name = attr_name.as_pystr(&vm.ctx);
-        self.getattr_inner(attr_name, vm)
-    }
-
-    pub fn set_attr<'a>(
-        &self,
-        attr_name: impl AsPyStr<'a>,
-        attr_value: impl Into<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        self.as_object().set_attr(attr_name, attr_value, vm)
-    }
-}
-
-#[pyclass(with(GetAttr, Initializer, Representable), flags(BASETYPE, HAS_DICT))]
-impl PyModule {
-    #[pyslot]
-    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Self::new().into_ref_with_type(vm, cls).map(Into::into)
-    }
-
-    #[pymethod]
-    fn __dir__(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        // First check if __dict__ attribute exists and is actually a dictionary
-        let dict_attr = zelf.as_object().get_attr(identifier!(vm, __dict__), vm)?;
-        let dict = dict_attr
-            .downcast::<PyDict>()
-            .map_err(|_| vm.new_type_error("<module>.__dict__ is not a dictionary"))?;
-        let attrs = dict.into_iter().map(|(k, _v)| k).collect();
-        Ok(attrs)
-    }
-}
-
-impl Initializer for PyModule {
-    type Args = ModuleInitArgs;
-
-    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
-        debug_assert!(
-            zelf.class()
-                .slots
-                .flags
-                .has_feature(crate::types::PyTypeFlags::HAS_DICT)
-        );
-        zelf.init_dict(vm.ctx.intern_str(args.name.as_str()), args.doc, vm);
-        Ok(())
-    }
-}
-
-impl GetAttr for PyModule {
-    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        zelf.getattr_inner(name, vm)
-    }
-}
-
-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)?;
-        let repr = module_repr.call((zelf.to_owned(),), vm)?;
-        repr.downcast()
-            .map_err(|_| vm.new_type_error("_module_repr did not return a string"))
-    }
-
-    #[cold]
-    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        unreachable!("use repr instead")
-    }
-}
-
-pub(crate) fn init(context: &Context) {
-    PyModule::extend_class(context, context.types.module_type);
-}
diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs
deleted file mode 100644
index fc39e2fb08..0000000000
--- a/vm/src/builtins/object.rs
+++ /dev/null
@@ -1,519 +0,0 @@
-use super::{PyDictRef, PyList, PyStr, PyStrRef, PyType, PyTypeRef};
-use crate::common::hash::PyHash;
-use crate::types::PyTypeFlags;
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    convert::ToPyResult,
-    function::{Either, FuncArgs, PyArithmeticValue, PyComparisonValue, PySetterValue},
-    types::{Constructor, PyComparisonOp},
-};
-use itertools::Itertools;
-
-/// object()
-/// --
-///
-/// The base class of the class hierarchy.
-///
-/// When called, it accepts no arguments and returns a new featureless
-/// instance that has no instance attributes and cannot be given any.
-#[pyclass(module = false, name = "object")]
-#[derive(Debug)]
-pub struct PyBaseObject;
-
-impl PyPayload for PyBaseObject {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.object_type
-    }
-}
-
-impl Constructor for PyBaseObject {
-    type Args = FuncArgs;
-
-    fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        // more or less __new__ operator
-        let dict = if cls.is(vm.ctx.types.object_type) {
-            None
-        } else {
-            Some(vm.ctx.new_dict())
-        };
-
-        // Ensure that all abstract methods are implemented before instantiating instance.
-        if let Some(abs_methods) = cls.get_attr(identifier!(vm, __abstractmethods__)) {
-            if 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 unimplemented_abstract_method_count = unimplemented_abstract_method_count?;
-                let name = cls.name().to_string();
-
-                match unimplemented_abstract_method_count {
-                    0 => {}
-                    1 => {
-                        return Err(vm.new_type_error(format!(
-                            "class {name} without an implementation for abstract method '{methods}'"
-                        )));
-                    }
-                    2.. => {
-                        return Err(vm.new_type_error(format!(
-                            "class {name} without an implementation for abstract methods '{methods}'"
-                        )));
-                    }
-                    // TODO: remove `allow` when redox build doesn't complain about it
-                    #[allow(unreachable_patterns)]
-                    _ => unreachable!(),
-                }
-            }
-        }
-
-        Ok(crate::PyRef::new_ref(Self, cls, dict).into())
-    }
-}
-
-// TODO: implement _PyType_GetSlotNames properly
-fn type_slot_names(typ: &Py<PyType>, vm: &VirtualMachine) -> PyResult<Option<super::PyListRef>> {
-    // let attributes = typ.attributes.read();
-    // if let Some(slot_names) = attributes.get(identifier!(vm.ctx, __slotnames__)) {
-    //     return match_class!(match slot_names.clone() {
-    //         l @ super::PyList => Ok(Some(l)),
-    //         _n @ super::PyNone => Ok(None),
-    //         _ => Err(vm.new_type_error(format!(
-    //             "{:.200}.__slotnames__ should be a list or None, not {:.200}",
-    //             typ.name(),
-    //             slot_names.class().name()
-    //         ))),
-    //     });
-    // }
-
-    let copyreg = vm.import("copyreg", 0)?;
-    let copyreg_slotnames = copyreg.get_attr("_slotnames", vm)?;
-    let slot_names = copyreg_slotnames.call((typ.to_owned(),), vm)?;
-    let result = match_class!(match slot_names {
-        l @ super::PyList => Some(l),
-        _n @ super::PyNone => None,
-        _ => return Err(vm.new_type_error("copyreg._slotnames didn't return a list or None")),
-    });
-    Ok(result)
-}
-
-// object_getstate_default in CPython
-fn object_getstate_default(obj: &PyObject, required: bool, vm: &VirtualMachine) -> PyResult {
-    // TODO: itemsize
-    // if required && obj.class().slots.itemsize > 0 {
-    //     return vm.new_type_error(format!(
-    //         "cannot pickle {:.200} objects",
-    //         obj.class().name()
-    //     ));
-    // }
-
-    let state = if obj.dict().is_none_or(|d| d.is_empty()) {
-        vm.ctx.none()
-    } else {
-        // let state = object_get_dict(obj.clone(), obj.ctx()).unwrap();
-        let Some(state) = obj.dict() else {
-            return Ok(vm.ctx.none());
-        };
-        state.into()
-    };
-
-    let slot_names =
-        type_slot_names(obj.class(), vm).map_err(|_| vm.new_type_error("cannot pickle object"))?;
-
-    if required {
-        let mut basicsize = obj.class().slots.basicsize;
-        // if obj.class().slots.dict_offset > 0
-        //     && !obj.class().slots.flags.has_feature(PyTypeFlags::MANAGED_DICT)
-        // {
-        //     basicsize += std::mem::size_of::<PyObjectRef>();
-        // }
-        // if obj.class().slots.weaklist_offset > 0 {
-        //     basicsize += std::mem::size_of::<PyObjectRef>();
-        // }
-        if let Some(ref slot_names) = slot_names {
-            basicsize += std::mem::size_of::<PyObjectRef>() * slot_names.__len__();
-        }
-        if obj.class().slots.basicsize > basicsize {
-            return Err(
-                vm.new_type_error(format!("cannot pickle {:.200} object", obj.class().name()))
-            );
-        }
-    }
-
-    if let Some(slot_names) = slot_names {
-        let slot_names_len = slot_names.__len__();
-        if slot_names_len > 0 {
-            let slots = vm.ctx.new_dict();
-            for i in 0..slot_names_len {
-                let borrowed_names = slot_names.borrow_vec();
-                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();
-            }
-
-            if !slots.is_empty() {
-                return (state, slots).to_pyresult(vm);
-            }
-        }
-    }
-
-    Ok(state)
-}
-
-// object_getstate in CPython
-// fn object_getstate(
-//     obj: &PyObject,
-//     required: bool,
-//     vm: &VirtualMachine,
-// ) -> PyResult {
-//     let getstate = obj.get_attr(identifier!(vm, __getstate__), vm)?;
-//     if vm.is_none(&getstate) {
-//         return Ok(None);
-//     }
-
-//     let getstate = match getstate.downcast_exact::<PyNativeFunction>(vm) {
-//         Ok(getstate)
-//             if getstate
-//                 .get_self()
-//                 .map_or(false, |self_obj| self_obj.is(obj))
-//                 && std::ptr::addr_eq(
-//                     getstate.as_func() as *const _,
-//                     &PyBaseObject::__getstate__ as &dyn crate::function::PyNativeFn as *const _,
-//                 ) =>
-//         {
-//             return object_getstate_default(obj, required, vm);
-//         }
-//         Ok(getstate) => getstate.into_pyref().into(),
-//         Err(getstate) => getstate,
-//     };
-//     getstate.call((), vm)
-// }
-
-#[pyclass(with(Constructor), flags(BASETYPE))]
-impl PyBaseObject {
-    #[pymethod(raw)]
-    fn __getstate__(vm: &VirtualMachine, args: FuncArgs) -> PyResult {
-        let (zelf,): (PyObjectRef,) = args.bind(vm)?;
-        object_getstate_default(&zelf, false, vm)
-    }
-
-    #[pyslot]
-    fn slot_richcompare(
-        zelf: &PyObject,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
-        Self::cmp(zelf, other, op, vm).map(Either::B)
-    }
-
-    #[inline(always)]
-    fn cmp(
-        zelf: &PyObject,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        let res = match op {
-            PyComparisonOp::Eq => {
-                if zelf.is(other) {
-                    PyComparisonValue::Implemented(true)
-                } else {
-                    PyComparisonValue::NotImplemented
-                }
-            }
-            PyComparisonOp::Ne => {
-                let cmp = zelf
-                    .class()
-                    .mro_find_map(|cls| cls.slots.richcompare.load())
-                    .unwrap();
-                let value = match cmp(zelf, other, PyComparisonOp::Eq, vm)? {
-                    Either::A(obj) => PyArithmeticValue::from_object(vm, obj)
-                        .map(|obj| obj.try_to_bool(vm))
-                        .transpose()?,
-                    Either::B(value) => value,
-                };
-                value.map(|v| !v)
-            }
-            _ => PyComparisonValue::NotImplemented,
-        };
-        Ok(res)
-    }
-
-    /// Return self==value.
-    #[pymethod]
-    fn __eq__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Eq, vm)
-    }
-
-    /// Return self!=value.
-    #[pymethod]
-    fn __ne__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Ne, vm)
-    }
-
-    /// Return self<value.
-    #[pymethod]
-    fn __lt__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Lt, vm)
-    }
-
-    /// Return self<=value.
-    #[pymethod]
-    fn __le__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Le, vm)
-    }
-
-    /// Return self>=value.
-    #[pymethod]
-    fn __ge__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Ge, vm)
-    }
-
-    /// Return self>value.
-    #[pymethod]
-    fn __gt__(
-        zelf: PyObjectRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        Self::cmp(&zelf, &value, PyComparisonOp::Gt, vm)
-    }
-
-    /// Implement setattr(self, name, value).
-    #[pymethod]
-    fn __setattr__(
-        obj: PyObjectRef,
-        name: PyStrRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        obj.generic_setattr(&name, PySetterValue::Assign(value), vm)
-    }
-
-    /// Implement delattr(self, name).
-    #[pymethod]
-    fn __delattr__(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        obj.generic_setattr(&name, PySetterValue::Delete, vm)
-    }
-
-    #[pyslot]
-    fn slot_setattro(
-        obj: &PyObject,
-        attr_name: &Py<PyStr>,
-        value: PySetterValue,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        obj.generic_setattr(attr_name, value, vm)
-    }
-
-    /// Return str(self).
-    #[pymethod]
-    fn __str__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        // FIXME: try tp_repr first and fallback to object.__repr__
-        zelf.repr(vm)
-    }
-
-    #[pyslot]
-    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let class = zelf.class();
-        match (
-            class
-                .__qualname__(vm)
-                .downcast_ref::<PyStr>()
-                .map(|n| n.as_str()),
-            class
-                .__module__(vm)
-                .downcast_ref::<PyStr>()
-                .map(|m| m.as_str()),
-        ) {
-            (None, _) => Err(vm.new_type_error("Unknown qualified name")),
-            (Some(qualname), Some(module)) if module != "builtins" => Ok(PyStr::from(format!(
-                "<{}.{} object at {:#x}>",
-                module,
-                qualname,
-                zelf.get_id()
-            ))
-            .into_ref(&vm.ctx)),
-            _ => Ok(PyStr::from(format!(
-                "<{} object at {:#x}>",
-                class.slot_name(),
-                zelf.get_id()
-            ))
-            .into_ref(&vm.ctx)),
-        }
-    }
-
-    /// Return repr(self).
-    #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
-    }
-
-    #[pyclassmethod]
-    fn __subclasshook__(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
-    #[pyclassmethod]
-    fn __init_subclass__(_cls: PyTypeRef) {}
-
-    #[pymethod]
-    pub fn __dir__(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyList> {
-        obj.dir(vm)
-    }
-
-    #[pymethod]
-    fn __format__(
-        obj: PyObjectRef,
-        format_spec: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyStrRef> {
-        if !format_spec.is_empty() {
-            return Err(vm.new_type_error(format!(
-                "unsupported format string passed to {}.__format__",
-                obj.class().name()
-            )));
-        }
-        obj.str(vm)
-    }
-
-    #[pyslot]
-    #[pymethod]
-    fn __init__(_zelf: PyObjectRef, _args: FuncArgs, _vm: &VirtualMachine) -> PyResult<()> {
-        Ok(())
-    }
-
-    #[pygetset(name = "__class__")]
-    fn get_class(obj: PyObjectRef) -> PyTypeRef {
-        obj.class().to_owned()
-    }
-
-    #[pygetset(name = "__class__", setter)]
-    fn set_class(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        match value.downcast::<PyType>() {
-            Ok(cls) => {
-                let both_module = instance.class().fast_issubclass(vm.ctx.types.module_type)
-                    && cls.fast_issubclass(vm.ctx.types.module_type);
-                let both_mutable = !instance
-                    .class()
-                    .slots
-                    .flags
-                    .has_feature(PyTypeFlags::IMMUTABLETYPE)
-                    && !cls.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE);
-                // FIXME(#1979) cls instances might have a payload
-                if both_mutable || both_module {
-                    instance.set_class(cls, vm);
-                    Ok(())
-                } else {
-                    Err(vm.new_type_error(
-                        "__class__ assignment only supported for mutable types or ModuleType subclasses",
-                    ))
-                }
-            }
-            Err(value) => {
-                let value_class = value.class();
-                let type_repr = &value_class.name();
-                Err(vm.new_type_error(format!(
-                    "__class__ must be set to a class, not '{type_repr}' object"
-                )))
-            }
-        }
-    }
-
-    /// Return getattr(self, name).
-    #[pyslot]
-    pub(crate) fn getattro(obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        vm_trace!("object.__getattribute__({:?}, {:?})", obj, name);
-        obj.as_object().generic_getattr(name, vm)
-    }
-
-    #[pymethod]
-    fn __getattribute__(obj: PyObjectRef, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        Self::getattro(&obj, &name, vm)
-    }
-
-    #[pymethod]
-    fn __reduce__(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        common_reduce(obj, 0, vm)
-    }
-
-    #[pymethod]
-    fn __reduce_ex__(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
-        let __reduce__ = identifier!(vm, __reduce__);
-        if let Some(reduce) = vm.get_attribute_opt(obj.clone(), __reduce__)? {
-            let object_reduce = vm.ctx.types.object_type.get_attr(__reduce__).unwrap();
-            let typ_obj: PyObjectRef = obj.class().to_owned().into();
-            let class_reduce = typ_obj.get_attr(__reduce__, vm)?;
-            if !class_reduce.is(&object_reduce) {
-                return reduce.call((), vm);
-            }
-        }
-        common_reduce(obj, proto, vm)
-    }
-
-    #[pyslot]
-    fn slot_hash(zelf: &PyObject, _vm: &VirtualMachine) -> PyResult<PyHash> {
-        Ok(zelf.get_id() as _)
-    }
-
-    /// Return hash(self).
-    #[pymethod]
-    fn __hash__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyHash> {
-        Self::slot_hash(&zelf, vm)
-    }
-
-    #[pymethod]
-    fn __sizeof__(zelf: PyObjectRef) -> usize {
-        zelf.class().slots.basicsize
-    }
-}
-
-pub fn object_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyDictRef> {
-    obj.dict()
-        .ok_or_else(|| vm.new_attribute_error("This object has no __dict__"))
-}
-pub fn object_set_dict(obj: PyObjectRef, dict: PyDictRef, vm: &VirtualMachine) -> PyResult<()> {
-    obj.set_dict(dict)
-        .map_err(|_| vm.new_attribute_error("This object has no __dict__"))
-}
-
-pub fn init(ctx: &Context) {
-    PyBaseObject::extend_class(ctx, ctx.types.object_type);
-}
-
-fn common_reduce(obj: PyObjectRef, proto: usize, vm: &VirtualMachine) -> PyResult {
-    if proto >= 2 {
-        let reducelib = vm.import("__reducelib", 0)?;
-        let reduce_2 = reducelib.get_attr("reduce_2", vm)?;
-        reduce_2.call((obj,), vm)
-    } else {
-        let copyreg = vm.import("copyreg", 0)?;
-        let reduce_ex = copyreg.get_attr("_reduce_ex", vm)?;
-        reduce_ex.call((obj, proto), vm)
-    }
-}
diff --git a/vm/src/builtins/singletons.rs b/vm/src/builtins/singletons.rs
deleted file mode 100644
index 7b674cb35b..0000000000
--- a/vm/src/builtins/singletons.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-use super::{PyStrRef, PyType, PyTypeRef};
-use crate::{
-    Context, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    convert::ToPyObject,
-    protocol::PyNumberMethods,
-    types::{AsNumber, Constructor, Representable},
-};
-
-#[pyclass(module = false, name = "NoneType")]
-#[derive(Debug)]
-pub struct PyNone;
-
-impl PyPayload for PyNone {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.none_type
-    }
-}
-
-// This allows a built-in function to not return a value, mapping to
-// Python's behavior of returning `None` in this situation.
-impl ToPyObject for () {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.none()
-    }
-}
-
-impl<T: ToPyObject> ToPyObject for Option<T> {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        match self {
-            Some(x) => x.to_pyobject(vm),
-            None => vm.ctx.none(),
-        }
-    }
-}
-
-impl Constructor for PyNone {
-    type Args = ();
-
-    fn py_new(_: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Ok(vm.ctx.none.clone().into())
-    }
-}
-
-#[pyclass(with(Constructor, AsNumber, Representable))]
-impl PyNone {
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        false
-    }
-}
-
-impl Representable for PyNone {
-    #[inline]
-    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(vm.ctx.names.None.to_owned())
-    }
-
-    #[cold]
-    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        unreachable!("use repr instead")
-    }
-}
-
-impl AsNumber for PyNone {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            boolean: Some(|_number, _vm| Ok(false)),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-}
-
-#[pyclass(module = false, name = "NotImplementedType")]
-#[derive(Debug)]
-pub struct PyNotImplemented;
-
-impl PyPayload for PyNotImplemented {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.not_implemented_type
-    }
-}
-
-impl Constructor for PyNotImplemented {
-    type Args = ();
-
-    fn py_new(_: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Ok(vm.ctx.not_implemented.clone().into())
-    }
-}
-
-#[pyclass(with(Constructor))]
-impl PyNotImplemented {
-    // TODO: As per https://bugs.python.org/issue35712, using NotImplemented
-    // in boolean contexts will need to raise a DeprecationWarning in 3.9
-    // and, eventually, a TypeError.
-    #[pymethod]
-    const fn __bool__(&self) -> bool {
-        true
-    }
-
-    #[pymethod]
-    fn __reduce__(&self, vm: &VirtualMachine) -> PyStrRef {
-        vm.ctx.names.NotImplemented.to_owned()
-    }
-}
-
-impl Representable for PyNotImplemented {
-    #[inline]
-    fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Ok(vm.ctx.names.NotImplemented.to_owned())
-    }
-
-    #[cold]
-    fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        unreachable!("use repr instead")
-    }
-}
-
-pub fn init(context: &Context) {
-    PyNone::extend_class(context, context.types.none_type);
-    PyNotImplemented::extend_class(context, context.types.not_implemented_type);
-}
diff --git a/vm/src/builtins/str.rs b/vm/src/builtins/str.rs
deleted file mode 100644
index f822a124ed..0000000000
--- a/vm/src/builtins/str.rs
+++ /dev/null
@@ -1,2328 +0,0 @@
-use super::{
-    PositionIterInternal, PyBytesRef, PyDict, PyTupleRef, PyType, PyTypeRef,
-    int::{PyInt, PyIntRef},
-    iter::IterStatus::{self, Exhausted},
-};
-use crate::{
-    AsObject, Context, Py, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
-    TryFromBorrowedObject, VirtualMachine,
-    anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper, adjust_indices},
-    atomic_func,
-    cformat::cformat_string,
-    class::PyClassImpl,
-    common::str::{PyKindStr, StrData, StrKind},
-    convert::{IntoPyException, ToPyException, ToPyObject, ToPyResult},
-    format::{format, format_map},
-    function::{ArgIterable, ArgSize, FuncArgs, OptionalArg, OptionalOption, PyComparisonValue},
-    intern::PyInterned,
-    object::{Traverse, TraverseFn},
-    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
-    sequence::SequenceExt,
-    sliceable::{SequenceIndex, SliceableSequenceOp},
-    types::{
-        AsMapping, AsNumber, AsSequence, Comparable, Constructor, Hashable, IterNext, Iterable,
-        PyComparisonOp, Representable, SelfIter, Unconstructible,
-    },
-};
-use ascii::{AsciiChar, AsciiStr, AsciiString};
-use bstr::ByteSlice;
-use itertools::Itertools;
-use num_traits::ToPrimitive;
-use rustpython_common::{
-    ascii,
-    atomic::{self, PyAtomic, Radium},
-    format::{FormatSpec, FormatString, FromTemplate},
-    hash,
-    lock::PyMutex,
-    str::DeduceStrKind,
-    wtf8::{CodePoint, Wtf8, Wtf8Buf, Wtf8Chunk},
-};
-use std::sync::LazyLock;
-use std::{borrow::Cow, char, fmt, ops::Range};
-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)
-    }
-}
-
-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)?;
-        Ok(pystr.as_str())
-    }
-}
-
-impl<'a> TryFromBorrowedObject<'a> for &'a Wtf8 {
-    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        let pystr: &Py<PyStr> = TryFromBorrowedObject::try_from_borrowed_object(vm, obj)?;
-        Ok(pystr.as_wtf8())
-    }
-}
-
-#[pyclass(module = false, name = "str")]
-pub struct PyStr {
-    data: StrData,
-    hash: PyAtomic<hash::PyHash>,
-}
-
-impl fmt::Debug for PyStr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("PyStr")
-            .field("value", &self.as_wtf8())
-            .field("kind", &self.data.kind())
-            .field("hash", &self.hash)
-            .finish()
-    }
-}
-
-impl AsRef<str> for PyStr {
-    #[track_caller] // <- can remove this once it doesn't panic
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl AsRef<str> for Py<PyStr> {
-    #[track_caller] // <- can remove this once it doesn't panic
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl AsRef<str> for PyStrRef {
-    #[track_caller] // <- can remove this once it doesn't panic
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl AsRef<Wtf8> for PyStr {
-    fn as_ref(&self) -> &Wtf8 {
-        self.as_wtf8()
-    }
-}
-
-impl AsRef<Wtf8> for Py<PyStr> {
-    fn as_ref(&self) -> &Wtf8 {
-        self.as_wtf8()
-    }
-}
-
-impl AsRef<Wtf8> for PyStrRef {
-    fn as_ref(&self) -> &Wtf8 {
-        self.as_wtf8()
-    }
-}
-
-impl<'a> From<&'a AsciiStr> for PyStr {
-    fn from(s: &'a AsciiStr) -> Self {
-        s.to_owned().into()
-    }
-}
-
-impl From<AsciiString> for PyStr {
-    fn from(s: AsciiString) -> Self {
-        s.into_boxed_ascii_str().into()
-    }
-}
-
-impl From<Box<AsciiStr>> for PyStr {
-    fn from(s: Box<AsciiStr>) -> Self {
-        StrData::from(s).into()
-    }
-}
-
-impl From<AsciiChar> for PyStr {
-    fn from(ch: AsciiChar) -> Self {
-        AsciiString::from(ch).into()
-    }
-}
-
-impl<'a> From<&'a str> for PyStr {
-    fn from(s: &'a str) -> Self {
-        s.to_owned().into()
-    }
-}
-
-impl<'a> From<&'a Wtf8> for PyStr {
-    fn from(s: &'a Wtf8) -> Self {
-        s.to_owned().into()
-    }
-}
-
-impl From<String> for PyStr {
-    fn from(s: String) -> Self {
-        s.into_boxed_str().into()
-    }
-}
-
-impl From<Wtf8Buf> for PyStr {
-    fn from(w: Wtf8Buf) -> Self {
-        w.into_box().into()
-    }
-}
-
-impl From<char> for PyStr {
-    fn from(ch: char) -> Self {
-        StrData::from(ch).into()
-    }
-}
-
-impl From<CodePoint> for PyStr {
-    fn from(ch: CodePoint) -> Self {
-        StrData::from(ch).into()
-    }
-}
-
-impl From<StrData> for PyStr {
-    fn from(data: StrData) -> Self {
-        Self {
-            data,
-            hash: Radium::new(hash::SENTINEL),
-        }
-    }
-}
-
-impl<'a> From<std::borrow::Cow<'a, str>> for PyStr {
-    fn from(s: std::borrow::Cow<'a, str>) -> Self {
-        s.into_owned().into()
-    }
-}
-
-impl From<Box<str>> for PyStr {
-    #[inline]
-    fn from(value: Box<str>) -> Self {
-        StrData::from(value).into()
-    }
-}
-
-impl From<Box<Wtf8>> for PyStr {
-    #[inline]
-    fn from(value: Box<Wtf8>) -> Self {
-        StrData::from(value).into()
-    }
-}
-
-impl Default for PyStr {
-    fn default() -> Self {
-        Self {
-            data: StrData::default(),
-            hash: Radium::new(hash::SENTINEL),
-        }
-    }
-}
-
-pub type PyStrRef = PyRef<PyStr>;
-
-impl fmt::Display for PyStr {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_wtf8().fmt(f)
-    }
-}
-
-pub trait AsPyStr<'a>
-where
-    Self: 'a,
-{
-    #[allow(clippy::wrong_self_convention)] // to implement on refs
-    fn as_pystr(self, ctx: &Context) -> &'a Py<PyStr>;
-}
-
-impl<'a> AsPyStr<'a> for &'a Py<PyStr> {
-    #[inline]
-    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
-        self
-    }
-}
-
-impl<'a> AsPyStr<'a> for &'a PyStrRef {
-    #[inline]
-    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
-        self
-    }
-}
-
-impl AsPyStr<'static> for &'static str {
-    #[inline]
-    fn as_pystr(self, ctx: &Context) -> &'static Py<PyStr> {
-        ctx.intern_str(self)
-    }
-}
-
-impl<'a> AsPyStr<'a> for &'a PyStrInterned {
-    #[inline]
-    fn as_pystr(self, _ctx: &Context) -> &'a Py<PyStr> {
-        self
-    }
-}
-
-#[pyclass(module = false, name = "str_iterator", traverse = "manual")]
-#[derive(Debug)]
-pub struct PyStrIterator {
-    internal: PyMutex<(PositionIterInternal<PyStrRef>, usize)>,
-}
-
-unsafe impl Traverse for PyStrIterator {
-    fn traverse(&self, tracer: &mut TraverseFn<'_>) {
-        // No need to worry about deadlock, for inner is a PyStr and can't make ref cycle
-        self.internal.lock().0.traverse(tracer);
-    }
-}
-
-impl PyPayload for PyStrIterator {
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.str_iterator_type
-    }
-}
-
-#[pyclass(with(Unconstructible, IterNext, Iterable))]
-impl PyStrIterator {
-    #[pymethod]
-    fn __length_hint__(&self) -> usize {
-        self.internal.lock().0.length_hint(|obj| obj.char_len())
-    }
-
-    #[pymethod]
-    fn __setstate__(&self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let mut internal = self.internal.lock();
-        internal.1 = usize::MAX;
-        internal
-            .0
-            .set_state(state, |obj, pos| pos.min(obj.char_len()), vm)
-    }
-
-    #[pymethod]
-    fn __reduce__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        self.internal
-            .lock()
-            .0
-            .builtins_iter_reduce(|x| x.clone().into(), vm)
-    }
-}
-
-impl Unconstructible for PyStrIterator {}
-
-impl SelfIter for PyStrIterator {}
-
-impl IterNext for PyStrIterator {
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let mut internal = zelf.internal.lock();
-
-        if let IterStatus::Active(s) = &internal.0.status {
-            let value = s.as_wtf8();
-
-            if internal.1 == usize::MAX {
-                if let Some((offset, ch)) = value.code_point_indices().nth(internal.0.position) {
-                    internal.0.position += 1;
-                    internal.1 = offset + ch.len_wtf8();
-                    return Ok(PyIterReturn::Return(ch.to_pyobject(vm)));
-                }
-            } else if let Some(value) = value.get(internal.1..) {
-                if let Some(ch) = value.code_points().next() {
-                    internal.0.position += 1;
-                    internal.1 += ch.len_wtf8();
-                    return Ok(PyIterReturn::Return(ch.to_pyobject(vm)));
-                }
-            }
-            internal.0.status = Exhausted;
-        }
-        Ok(PyIterReturn::StopIteration(None))
-    }
-}
-
-#[derive(FromArgs)]
-pub struct StrArgs {
-    #[pyarg(any, optional)]
-    object: OptionalArg<PyObjectRef>,
-    #[pyarg(any, optional)]
-    encoding: OptionalArg<PyStrRef>,
-    #[pyarg(any, optional)]
-    errors: OptionalArg<PyStrRef>,
-}
-
-impl Constructor for PyStr {
-    type Args = StrArgs;
-
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let string: PyStrRef = match args.object {
-            OptionalArg::Present(input) => {
-                if let OptionalArg::Present(enc) = args.encoding {
-                    vm.state.codec_registry.decode_text(
-                        input,
-                        enc.as_str(),
-                        args.errors.into_option(),
-                        vm,
-                    )?
-                } else {
-                    input.str(vm)?
-                }
-            }
-            OptionalArg::Missing => {
-                Self::from(String::new()).into_ref_with_type(vm, cls.clone())?
-            }
-        };
-        if string.class().is(&cls) {
-            Ok(string.into())
-        } else {
-            Self::from(string.as_wtf8())
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
-        }
-    }
-}
-
-impl PyStr {
-    /// # Safety: Given `bytes` must be valid data for given `kind`
-    unsafe fn new_str_unchecked(data: Box<Wtf8>, kind: StrKind) -> Self {
-        unsafe { StrData::new_str_unchecked(data, kind) }.into()
-    }
-
-    unsafe fn new_with_char_len<T: DeduceStrKind + Into<Box<Wtf8>>>(s: T, char_len: usize) -> Self {
-        let kind = s.str_kind();
-        unsafe { StrData::new_with_char_len(s.into(), kind, char_len) }.into()
-    }
-
-    /// # Safety
-    /// Given `bytes` must be ascii
-    pub unsafe fn new_ascii_unchecked(bytes: Vec<u8>) -> Self {
-        unsafe { AsciiString::from_ascii_unchecked(bytes) }.into()
-    }
-
-    pub fn new_ref(zelf: impl Into<Self>, ctx: &Context) -> PyRef<Self> {
-        let zelf = zelf.into();
-        PyRef::new_ref(zelf, ctx.types.str_type.to_owned(), None)
-    }
-
-    fn new_substr(&self, s: Wtf8Buf) -> Self {
-        let kind = if self.kind().is_ascii() || s.is_ascii() {
-            StrKind::Ascii
-        } else if self.kind().is_utf8() || s.is_utf8() {
-            StrKind::Utf8
-        } else {
-            StrKind::Wtf8
-        };
-        unsafe {
-            // SAFETY: kind is properly decided for substring
-            Self::new_str_unchecked(s.into(), kind)
-        }
-    }
-
-    #[inline]
-    pub const fn as_wtf8(&self) -> &Wtf8 {
-        self.data.as_wtf8()
-    }
-
-    pub const fn as_bytes(&self) -> &[u8] {
-        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()
-    }
-
-    pub fn try_to_str(&self, vm: &VirtualMachine) -> PyResult<&str> {
-        self.to_str().ok_or_else(|| {
-            let start = self
-                .as_wtf8()
-                .code_points()
-                .position(|c| c.to_char().is_none())
-                .unwrap();
-            vm.new_unicode_encode_error_real(
-                identifier!(vm, utf_8).to_owned(),
-                vm.ctx.new_str(self.data.clone()),
-                start,
-                start + 1,
-                vm.ctx.new_str("surrogates not allowed"),
-            )
-        })
-    }
-
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        self.to_str()
-            .map(Cow::Borrowed)
-            .unwrap_or_else(|| self.as_wtf8().to_string_lossy())
-    }
-
-    pub const fn kind(&self) -> StrKind {
-        self.data.kind()
-    }
-
-    #[inline]
-    pub fn as_str_kind(&self) -> PyKindStr<'_> {
-        self.data.as_str_kind()
-    }
-
-    pub const fn is_utf8(&self) -> bool {
-        self.kind().is_utf8()
-    }
-
-    fn char_all<F>(&self, test: F) -> bool
-    where
-        F: Fn(char) -> bool,
-    {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s.chars().all(|ch| test(ch.into())),
-            PyKindStr::Utf8(s) => s.chars().all(test),
-            PyKindStr::Wtf8(w) => w.code_points().all(|ch| ch.is_char_and(&test)),
-        }
-    }
-
-    fn repeat(zelf: PyRef<Self>, value: isize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        if value == 0 && zelf.class().is(vm.ctx.types.str_type) {
-            // Special case: when some `str` is multiplied by `0`,
-            // returns the empty `str`.
-            return Ok(vm.ctx.empty_str.to_owned());
-        }
-        if (value == 1 || zelf.is_empty()) && zelf.class().is(vm.ctx.types.str_type) {
-            // Special case: when some `str` is multiplied by `1` or is the empty `str`,
-            // nothing really happens, we need to return an object itself
-            // with the same `id()` to be compatible with CPython.
-            // This only works for `str` itself, not its subclasses.
-            return Ok(zelf);
-        }
-        zelf.as_wtf8()
-            .as_bytes()
-            .mul(vm, value)
-            .map(|x| Self::from(unsafe { Wtf8Buf::from_bytes_unchecked(x) }).into_ref(&vm.ctx))
-    }
-}
-
-#[pyclass(
-    flags(BASETYPE),
-    with(
-        PyRef,
-        AsMapping,
-        AsNumber,
-        AsSequence,
-        Representable,
-        Hashable,
-        Comparable,
-        Iterable,
-        Constructor
-    )
-)]
-impl PyStr {
-    #[pymethod]
-    fn __add__(zelf: PyRef<Self>, other: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        if let Some(other) = other.payload::<Self>() {
-            let bytes = zelf.as_wtf8().py_add(other.as_wtf8());
-            Ok(unsafe {
-                // SAFETY: `kind` is safely decided
-                let kind = zelf.kind() | other.kind();
-                Self::new_str_unchecked(bytes.into(), kind)
-            }
-            .to_pyobject(vm))
-        } else if let Some(radd) = vm.get_method(other.clone(), identifier!(vm, __radd__)) {
-            // hack to get around not distinguishing number add from seq concat
-            radd?.call((zelf,), vm)
-        } else {
-            Err(vm.new_type_error(format!(
-                r#"can only concatenate str (not "{}") to str"#,
-                other.class().name()
-            )))
-        }
-    }
-
-    fn _contains(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        if let Some(needle) = needle.payload::<Self>() {
-            Ok(memchr::memmem::find(self.as_bytes(), needle.as_bytes()).is_some())
-        } else {
-            Err(vm.new_type_error(format!(
-                "'in <string>' requires string as left operand, not {}",
-                needle.class().name()
-            )))
-        }
-    }
-
-    #[pymethod]
-    fn __contains__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        self._contains(&needle, vm)
-    }
-
-    fn _getitem(&self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
-        let item = match SequenceIndex::try_from_borrowed_object(vm, needle, "str")? {
-            SequenceIndex::Int(i) => self.getitem_by_index(vm, i)?.to_pyobject(vm),
-            SequenceIndex::Slice(slice) => self.getitem_by_slice(vm, slice)?.to_pyobject(vm),
-        };
-        Ok(item)
-    }
-
-    #[pymethod]
-    fn __getitem__(&self, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self._getitem(&needle, vm)
-    }
-
-    #[inline]
-    pub(crate) fn hash(&self, vm: &VirtualMachine) -> hash::PyHash {
-        match self.hash.load(atomic::Ordering::Relaxed) {
-            hash::SENTINEL => self._compute_hash(vm),
-            hash => hash,
-        }
-    }
-
-    #[cold]
-    fn _compute_hash(&self, vm: &VirtualMachine) -> hash::PyHash {
-        let hash_val = vm.state.hash_secret.hash_bytes(self.as_bytes());
-        debug_assert_ne!(hash_val, hash::SENTINEL);
-        // spell-checker:ignore cmpxchg
-        // like with char_len, we don't need a cmpxchg loop, since it'll always be the same value
-        self.hash.store(hash_val, atomic::Ordering::Relaxed);
-        hash_val
-    }
-
-    #[inline]
-    pub fn byte_len(&self) -> usize {
-        self.data.len()
-    }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    #[pymethod(name = "__len__")]
-    #[inline]
-    pub fn char_len(&self) -> usize {
-        self.data.char_len()
-    }
-
-    #[pymethod(name = "isascii")]
-    #[inline(always)]
-    pub const fn is_ascii(&self) -> bool {
-        matches!(self.kind(), StrKind::Ascii)
-    }
-
-    #[pymethod]
-    fn __sizeof__(&self) -> usize {
-        std::mem::size_of::<Self>() + self.byte_len() * std::mem::size_of::<u8>()
-    }
-
-    #[pymethod(name = "__rmul__")]
-    #[pymethod]
-    fn __mul__(zelf: PyRef<Self>, value: ArgSize, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {
-        Self::repeat(zelf, value.into(), vm)
-    }
-
-    #[inline]
-    pub(crate) fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-        use crate::literal::escape::UnicodeEscape;
-        UnicodeEscape::new_repr(self.as_wtf8())
-            .str_repr()
-            .to_string()
-            .ok_or_else(|| vm.new_overflow_error("string is too long to generate repr"))
-    }
-
-    #[pymethod]
-    fn lower(&self) -> Self {
-        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(),
-        }
-    }
-
-    // casefold is much more aggressive than lower
-    #[pymethod]
-    fn casefold(&self) -> String {
-        caseless::default_case_fold_str(self.as_str())
-    }
-
-    #[pymethod]
-    fn upper(&self) -> Self {
-        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(),
-        }
-    }
-
-    #[pymethod]
-    fn capitalize(&self) -> Wtf8Buf {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => {
-                let mut s = s.to_owned();
-                if let [first, rest @ ..] = s.as_mut_slice() {
-                    first.make_ascii_uppercase();
-                    ascii::AsciiStr::make_ascii_lowercase(rest.into());
-                }
-                s.into()
-            }
-            PyKindStr::Utf8(s) => {
-                let mut chars = s.chars();
-                let mut out = String::with_capacity(s.len());
-                if let Some(c) = chars.next() {
-                    out.extend(c.to_titlecase());
-                    out.push_str(&chars.as_str().to_lowercase());
-                }
-                out.into()
-            }
-            PyKindStr::Wtf8(s) => {
-                let mut out = Wtf8Buf::with_capacity(s.len());
-                let mut chars = s.code_points();
-                if let Some(ch) = chars.next() {
-                    match ch.to_char() {
-                        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
-            }
-        }
-    }
-
-    #[pymethod]
-    fn split(zelf: &Py<Self>, args: SplitArgs, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        let elements = match zelf.as_str_kind() {
-            PyKindStr::Ascii(s) => s.py_split(
-                args,
-                vm,
-                || zelf.as_object().to_owned(),
-                |v, s, vm| {
-                    v.as_bytes()
-                        .split_str(s)
-                        .map(|s| unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm))
-                        .collect()
-                },
-                |v, s, n, vm| {
-                    v.as_bytes()
-                        .splitn_str(n, s)
-                        .map(|s| unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm))
-                        .collect()
-                },
-                |v, n, vm| {
-                    v.as_bytes().py_split_whitespace(n, |s| {
-                        unsafe { AsciiStr::from_ascii_unchecked(s) }.to_pyobject(vm)
-                    })
-                },
-            ),
-            PyKindStr::Utf8(s) => s.py_split(
-                args,
-                vm,
-                || zelf.as_object().to_owned(),
-                |v, s, vm| v.split(s).map(|s| vm.ctx.new_str(s).into()).collect(),
-                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
-                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
-            ),
-            PyKindStr::Wtf8(w) => w.py_split(
-                args,
-                vm,
-                || zelf.as_object().to_owned(),
-                |v, s, vm| v.split(s).map(|s| vm.ctx.new_str(s).into()).collect(),
-                |v, s, n, vm| v.splitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
-                |v, n, vm| v.py_split_whitespace(n, |s| vm.ctx.new_str(s).into()),
-            ),
-        }?;
-        Ok(elements)
-    }
-
-    #[pymethod]
-    fn rsplit(zelf: &Py<Self>, args: SplitArgs, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        let mut elements = zelf.as_wtf8().py_split(
-            args,
-            vm,
-            || zelf.as_object().to_owned(),
-            |v, s, vm| v.rsplit(s).map(|s| vm.ctx.new_str(s).into()).collect(),
-            |v, s, n, vm| v.rsplitn(n, s).map(|s| vm.ctx.new_str(s).into()).collect(),
-            |v, n, vm| v.py_rsplit_whitespace(n, |s| vm.ctx.new_str(s).into()),
-        )?;
-        // Unlike Python rsplit, Rust rsplitn returns an iterator that
-        // starts from the end of the string.
-        elements.reverse();
-        Ok(elements)
-    }
-
-    #[pymethod]
-    fn strip(&self, chars: OptionalOption<PyStrRef>) -> Self {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s
-                .py_strip(
-                    chars,
-                    |s, chars| {
-                        let s = s
-                            .as_str()
-                            .trim_matches(|c| memchr::memchr(c as _, chars.as_bytes()).is_some());
-                        unsafe { AsciiStr::from_ascii_unchecked(s.as_bytes()) }
-                    },
-                    |s| s.trim(),
-                )
-                .into(),
-            PyKindStr::Utf8(s) => s
-                .py_strip(
-                    chars,
-                    |s, chars| s.trim_matches(|c| chars.contains(c)),
-                    |s| s.trim(),
-                )
-                .into(),
-            PyKindStr::Wtf8(w) => w
-                .py_strip(
-                    chars,
-                    |s, chars| s.trim_matches(|c| chars.code_points().contains(&c)),
-                    |s| s.trim(),
-                )
-                .into(),
-        }
-    }
-
-    #[pymethod]
-    fn lstrip(
-        zelf: PyRef<Self>,
-        chars: OptionalOption<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyRef<Self> {
-        let s = zelf.as_wtf8();
-        let stripped = s.py_strip(
-            chars,
-            |s, chars| s.trim_start_matches(|c| chars.contains_code_point(c)),
-            |s| s.trim_start(),
-        );
-        if s == stripped {
-            zelf
-        } else {
-            vm.ctx.new_str(stripped)
-        }
-    }
-
-    #[pymethod]
-    fn rstrip(
-        zelf: PyRef<Self>,
-        chars: OptionalOption<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyRef<Self> {
-        let s = zelf.as_wtf8();
-        let stripped = s.py_strip(
-            chars,
-            |s, chars| s.trim_end_matches(|c| chars.contains_code_point(c)),
-            |s| s.trim_end(),
-        );
-        if s == stripped {
-            zelf
-        } else {
-            vm.ctx.new_str(stripped)
-        }
-    }
-
-    #[pymethod]
-    fn endswith(&self, options: anystr::StartsEndsWithArgs, vm: &VirtualMachine) -> PyResult<bool> {
-        let (affix, substr) =
-            match options.prepare(self.as_wtf8(), self.len(), |s, r| s.get_chars(r)) {
-                Some(x) => x,
-                None => return Ok(false),
-            };
-        substr.py_starts_ends_with(
-            &affix,
-            "endswith",
-            "str",
-            |s, x: &Py<Self>| s.ends_with(x.as_wtf8()),
-            vm,
-        )
-    }
-
-    #[pymethod]
-    fn startswith(
-        &self,
-        options: anystr::StartsEndsWithArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult<bool> {
-        let (affix, substr) =
-            match options.prepare(self.as_wtf8(), self.len(), |s, r| s.get_chars(r)) {
-                Some(x) => x,
-                None => return Ok(false),
-            };
-        substr.py_starts_ends_with(
-            &affix,
-            "startswith",
-            "str",
-            |s, x: &Py<Self>| s.starts_with(x.as_wtf8()),
-            vm,
-        )
-    }
-
-    /// Return a str with the given prefix string removed if present.
-    ///
-    /// If the string starts with the prefix string, return string[len(prefix):]
-    /// Otherwise, return a copy of the original string.
-    #[pymethod]
-    fn removeprefix(&self, pref: PyStrRef) -> Wtf8Buf {
-        self.as_wtf8()
-            .py_removeprefix(pref.as_wtf8(), pref.byte_len(), |s, p| s.starts_with(p))
-            .to_owned()
-    }
-
-    /// Return a str with the given suffix string removed if present.
-    ///
-    /// If the string ends with the suffix string, return string[:len(suffix)]
-    /// Otherwise, return a copy of the original string.
-    #[pymethod]
-    fn removesuffix(&self, suffix: PyStrRef) -> Wtf8Buf {
-        self.as_wtf8()
-            .py_removesuffix(suffix.as_wtf8(), suffix.byte_len(), |s, p| s.ends_with(p))
-            .to_owned()
-    }
-
-    #[pymethod]
-    fn isalnum(&self) -> bool {
-        !self.data.is_empty() && self.char_all(char::is_alphanumeric)
-    }
-
-    #[pymethod]
-    fn isnumeric(&self) -> bool {
-        !self.data.is_empty() && self.char_all(char::is_numeric)
-    }
-
-    #[pymethod]
-    fn isdigit(&self) -> bool {
-        // python's isdigit also checks if exponents are digits, these are the unicode codepoints for exponents
-        !self.data.is_empty()
-            && self.char_all(|c| {
-                c.is_ascii_digit()
-                    || matches!(c, '⁰' | '¹' | '²' | '³' | '⁴' | '⁵' | '⁶' | '⁷' | '⁸' | '⁹')
-            })
-    }
-
-    #[pymethod]
-    fn isdecimal(&self) -> bool {
-        !self.data.is_empty()
-            && self.char_all(|c| GeneralCategory::of(c) == GeneralCategory::DecimalNumber)
-    }
-
-    #[pymethod(name = "__mod__")]
-    fn modulo(&self, values: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
-        cformat_string(vm, self.as_wtf8(), values)
-    }
-
-    #[pymethod]
-    fn __rmod__(&self, _values: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
-    #[pymethod]
-    fn format(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
-        let format_str =
-            FormatString::from_str(self.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
-        format(&format_str, &args, vm)
-    }
-
-    /// S.format_map(mapping) -> str
-    ///
-    /// Return a formatted version of S, using substitutions from mapping.
-    /// The substitutions are identified by braces ('{' and '}').
-    #[pymethod]
-    fn format_map(&self, mapping: PyObjectRef, vm: &VirtualMachine) -> PyResult<Wtf8Buf> {
-        let format_string =
-            FormatString::from_str(self.as_wtf8()).map_err(|err| err.to_pyexception(vm))?;
-        format_map(&format_string, &mapping, vm)
-    }
-
-    #[pymethod(name = "__format__")]
-    fn __format__(zelf: PyRef<Self>, spec: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let spec = spec.as_str();
-        if spec.is_empty() {
-            return if zelf.class().is(vm.ctx.types.str_type) {
-                Ok(zelf)
-            } else {
-                zelf.as_object().str(vm)
-            };
-        }
-
-        let s = FormatSpec::parse(spec)
-            .and_then(|format_spec| {
-                format_spec.format_string(&CharLenStr(zelf.as_str(), zelf.char_len()))
-            })
-            .map_err(|err| err.into_pyexception(vm))?;
-        Ok(vm.ctx.new_str(s))
-    }
-
-    /// Return a titlecased version of the string where words start with an
-    /// uppercase character and the remaining characters are lowercase.
-    #[pymethod]
-    fn title(&self) -> Wtf8Buf {
-        let mut title = Wtf8Buf::with_capacity(self.data.len());
-        let mut previous_is_cased = false;
-        for c_orig in self.as_wtf8().code_points() {
-            let c = c_orig.to_char_lossy();
-            if c.is_lowercase() {
-                if !previous_is_cased {
-                    title.extend(c.to_titlecase());
-                } else {
-                    title.push_char(c);
-                }
-                previous_is_cased = true;
-            } else if c.is_uppercase() || c.is_titlecase() {
-                if previous_is_cased {
-                    title.extend(c.to_lowercase());
-                } else {
-                    title.push_char(c);
-                }
-                previous_is_cased = true;
-            } else {
-                previous_is_cased = false;
-                title.push(c_orig);
-            }
-        }
-        title
-    }
-
-    #[pymethod]
-    fn swapcase(&self) -> Wtf8Buf {
-        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
-            if c.is_lowercase() {
-                swapped_str.push_char(c.to_ascii_uppercase());
-            } else if c.is_uppercase() {
-                swapped_str.push_char(c.to_ascii_lowercase());
-            } else {
-                swapped_str.push(c_orig);
-            }
-        }
-        swapped_str
-    }
-
-    #[pymethod]
-    fn isalpha(&self) -> bool {
-        !self.data.is_empty() && self.char_all(char::is_alphabetic)
-    }
-
-    #[pymethod]
-    fn replace(&self, old: PyStrRef, new: PyStrRef, count: OptionalArg<isize>) -> Wtf8Buf {
-        let s = self.as_wtf8();
-        match count {
-            OptionalArg::Present(max_count) if max_count >= 0 => {
-                if max_count == 0 || (s.is_empty() && !old.is_empty()) {
-                    // nothing to do; return the original bytes
-                    s.to_owned()
-                } else if s.is_empty() && old.is_empty() {
-                    new.as_wtf8().to_owned()
-                } else {
-                    s.replacen(old.as_wtf8(), new.as_wtf8(), max_count as usize)
-                }
-            }
-            _ => s.replace(old.as_wtf8(), new.as_wtf8()),
-        }
-    }
-
-    /// Return true if all characters in the string are printable or the string is empty,
-    /// false otherwise.  Nonprintable characters are those characters defined in the
-    /// Unicode character database as `Other` or `Separator`,
-    /// excepting the ASCII space (0x20) which is considered printable.
-    ///
-    /// All characters except those characters defined in the Unicode character
-    /// database as following categories are considered printable.
-    ///   * Cc (Other, Control)
-    ///   * Cf (Other, Format)
-    ///   * Cs (Other, Surrogate)
-    ///   * Co (Other, Private Use)
-    ///   * Cn (Other, Not Assigned)
-    ///   * Zl Separator, Line ('\u2028', LINE SEPARATOR)
-    ///   * Zp Separator, Paragraph ('\u2029', PARAGRAPH SEPARATOR)
-    ///   * Zs (Separator, Space) other than ASCII space('\x20').
-    #[pymethod]
-    fn isprintable(&self) -> bool {
-        self.char_all(|c| c == '\u{0020}' || rustpython_literal::char::is_printable(c))
-    }
-
-    #[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)
-            })
-    }
-
-    // Return true if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.
-    #[pymethod]
-    fn islower(&self) -> bool {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s.py_islower(),
-            PyKindStr::Utf8(s) => s.py_islower(),
-            PyKindStr::Wtf8(w) => w.py_islower(),
-        }
-    }
-
-    // Return true if all cased characters in the string are uppercase and there is at least one cased character, false otherwise.
-    #[pymethod]
-    fn isupper(&self) -> bool {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s.py_isupper(),
-            PyKindStr::Utf8(s) => s.py_isupper(),
-            PyKindStr::Wtf8(w) => w.py_isupper(),
-        }
-    }
-
-    #[pymethod]
-    fn splitlines(&self, args: anystr::SplitLinesArgs, vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        let into_wrapper = |s: &Wtf8| self.new_substr(s.to_owned()).to_pyobject(vm);
-        let mut elements = Vec::new();
-        let mut last_i = 0;
-        let self_str = self.as_wtf8();
-        let mut enumerated = self_str.code_point_indices().peekable();
-        while let Some((i, ch)) = enumerated.next() {
-            let end_len = match ch.to_char_lossy() {
-                '\n' => 1,
-                '\r' => {
-                    let is_rn = enumerated.next_if(|(_, ch)| *ch == '\n').is_some();
-                    if is_rn { 2 } else { 1 }
-                }
-                '\x0b' | '\x0c' | '\x1c' | '\x1d' | '\x1e' | '\u{0085}' | '\u{2028}'
-                | '\u{2029}' => ch.len_wtf8(),
-                _ => continue,
-            };
-            let range = if args.keepends {
-                last_i..i + end_len
-            } else {
-                last_i..i
-            };
-            last_i = i + end_len;
-            elements.push(into_wrapper(&self_str[range]));
-        }
-        if last_i != self_str.len() {
-            elements.push(into_wrapper(&self_str[last_i..]));
-        }
-        elements
-    }
-
-    #[pymethod]
-    fn join(
-        zelf: PyRef<Self>,
-        iterable: ArgIterable<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyStrRef> {
-        let iter = iterable.iter(vm)?;
-        let joined = match iter.exactly_one() {
-            Ok(first) => {
-                let first = first?;
-                if first.as_object().class().is(vm.ctx.types.str_type) {
-                    return Ok(first);
-                } else {
-                    first.as_wtf8().to_owned()
-                }
-            }
-            Err(iter) => zelf.as_wtf8().py_join(iter)?,
-        };
-        Ok(vm.ctx.new_str(joined))
-    }
-
-    // FIXME: two traversals of str is expensive
-    #[inline]
-    fn _to_char_idx(r: &Wtf8, byte_idx: usize) -> usize {
-        r[..byte_idx].code_points().count()
-    }
-
-    #[inline]
-    fn _find<F>(&self, args: FindArgs, find: F) -> Option<usize>
-    where
-        F: Fn(&Wtf8, &Wtf8) -> Option<usize>,
-    {
-        let (sub, range) = args.get_value(self.len());
-        self.as_wtf8().py_find(sub.as_wtf8(), range, find)
-    }
-
-    #[pymethod]
-    fn find(&self, args: FindArgs) -> isize {
-        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.find(s)?)))
-            .map_or(-1, |v| v as isize)
-    }
-
-    #[pymethod]
-    fn rfind(&self, args: FindArgs) -> isize {
-        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.rfind(s)?)))
-            .map_or(-1, |v| v as isize)
-    }
-
-    #[pymethod]
-    fn index(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult<usize> {
-        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.find(s)?)))
-            .ok_or_else(|| vm.new_value_error("substring not found"))
-    }
-
-    #[pymethod]
-    fn rindex(&self, args: FindArgs, vm: &VirtualMachine) -> PyResult<usize> {
-        self._find(args, |r, s| Some(Self::_to_char_idx(r, r.rfind(s)?)))
-            .ok_or_else(|| vm.new_value_error("substring not found"))
-    }
-
-    #[pymethod]
-    fn partition(&self, sep: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let (front, has_mid, back) = self.as_wtf8().py_partition(
-            sep.as_wtf8(),
-            || self.as_wtf8().splitn(2, sep.as_wtf8()),
-            vm,
-        )?;
-        let partition = (
-            self.new_substr(front),
-            if has_mid {
-                sep
-            } else {
-                vm.ctx.new_str(ascii!(""))
-            },
-            self.new_substr(back),
-        );
-        Ok(partition.to_pyobject(vm))
-    }
-
-    #[pymethod]
-    fn rpartition(&self, sep: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        let (back, has_mid, front) = self.as_wtf8().py_partition(
-            sep.as_wtf8(),
-            || self.as_wtf8().rsplitn(2, sep.as_wtf8()),
-            vm,
-        )?;
-        Ok((
-            self.new_substr(front),
-            if has_mid {
-                sep
-            } else {
-                vm.ctx.empty_str.to_owned()
-            },
-            self.new_substr(back),
-        )
-            .to_pyobject(vm))
-    }
-
-    /// Return `true` if the sequence is ASCII titlecase and the sequence is not
-    /// empty, `false` otherwise.
-    #[pymethod]
-    fn istitle(&self) -> bool {
-        if self.data.is_empty() {
-            return false;
-        }
-
-        let mut cased = false;
-        let mut previous_is_cased = false;
-        for c in self.as_wtf8().code_points().map(CodePoint::to_char_lossy) {
-            if c.is_uppercase() || c.is_titlecase() {
-                if previous_is_cased {
-                    return false;
-                }
-                previous_is_cased = true;
-                cased = true;
-            } else if c.is_lowercase() {
-                if !previous_is_cased {
-                    return false;
-                }
-                previous_is_cased = true;
-                cased = true;
-            } else {
-                previous_is_cased = false;
-            }
-        }
-        cased
-    }
-
-    #[pymethod]
-    fn count(&self, args: FindArgs) -> usize {
-        let (needle, range) = args.get_value(self.len());
-        self.as_wtf8()
-            .py_count(needle.as_wtf8(), range, |h, n| h.find_iter(n).count())
-    }
-
-    #[pymethod]
-    fn zfill(&self, width: isize) -> Wtf8Buf {
-        unsafe {
-            // SAFETY: this is safe-guaranteed because the original self.as_wtf8() is valid wtf8
-            Wtf8Buf::from_bytes_unchecked(self.as_wtf8().py_zfill(width))
-        }
-    }
-
-    #[inline]
-    fn _pad(
-        &self,
-        width: isize,
-        fillchar: OptionalArg<PyStrRef>,
-        pad: fn(&Wtf8, usize, CodePoint, usize) -> Wtf8Buf,
-        vm: &VirtualMachine,
-    ) -> PyResult<Wtf8Buf> {
-        let fillchar = fillchar.map_or(Ok(' '.into()), |ref s| {
-            s.as_wtf8().code_points().exactly_one().map_err(|_| {
-                vm.new_type_error("The fill character must be exactly one character long")
-            })
-        })?;
-        Ok(if self.len() as isize >= width {
-            self.as_wtf8().to_owned()
-        } else {
-            pad(self.as_wtf8(), width as usize, fillchar, self.len())
-        })
-    }
-
-    #[pymethod]
-    fn center(
-        &self,
-        width: isize,
-        fillchar: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Wtf8Buf> {
-        self._pad(width, fillchar, AnyStr::py_center, vm)
-    }
-
-    #[pymethod]
-    fn ljust(
-        &self,
-        width: isize,
-        fillchar: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Wtf8Buf> {
-        self._pad(width, fillchar, AnyStr::py_ljust, vm)
-    }
-
-    #[pymethod]
-    fn rjust(
-        &self,
-        width: isize,
-        fillchar: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Wtf8Buf> {
-        self._pad(width, fillchar, AnyStr::py_rjust, vm)
-    }
-
-    #[pymethod]
-    fn expandtabs(&self, args: anystr::ExpandTabsArgs) -> String {
-        rustpython_common::str::expandtabs(self.as_str(), args.tabsize())
-    }
-
-    #[pymethod]
-    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));
-        // a string is not an identifier if it has whitespace or starts with a number
-        is_identifier_start && chars.all(is_xid_continue)
-    }
-
-    // https://docs.python.org/3/library/stdtypes.html#str.translate
-    #[pymethod]
-    fn translate(&self, table: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
-        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) {
-                Ok(value) => {
-                    if let Some(text) = value.payload::<Self>() {
-                        translated.push_str(text.as_str());
-                    } else if let Some(bigint) = value.payload::<PyInt>() {
-                        let ch = bigint
-                            .as_bigint()
-                            .to_u32()
-                            .and_then(std::char::from_u32)
-                            .ok_or_else(|| {
-                                vm.new_value_error("character mapping must be in range(0x110000)")
-                            })?;
-                        translated.push(ch);
-                    } else if !vm.is_none(&value) {
-                        return Err(
-                            vm.new_type_error("character mapping must return integer, None or str")
-                        );
-                    }
-                }
-                _ => translated.push(c),
-            }
-        }
-        Ok(translated)
-    }
-
-    #[pystaticmethod]
-    fn maketrans(
-        dict_or_str: PyObjectRef,
-        to_str: OptionalArg<PyStrRef>,
-        none_str: OptionalArg<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let new_dict = vm.ctx.new_dict();
-        if let OptionalArg::Present(to_str) = to_str {
-            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()) {
-                            new_dict.set_item(
-                                &*vm.new_pyobj(c1 as u32),
-                                vm.new_pyobj(c2 as 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)?;
-                            }
-                        }
-                        Ok(new_dict.to_pyobject(vm))
-                    } else {
-                        Err(vm.new_value_error(
-                            "the first two maketrans arguments must have equal length",
-                        ))
-                    }
-                }
-                _ => Err(vm.new_type_error(
-                    "first maketrans argument must be a string if there is a second argument",
-                )),
-            }
-        } else {
-            // dict_str must be a dict
-            match dict_or_str.downcast::<PyDict>() {
-                Ok(dict) => {
-                    for (key, val) in dict {
-                        // FIXME: ints are key-compatible
-                        if let Some(num) = key.payload::<PyInt>() {
-                            new_dict.set_item(
-                                &*num.as_bigint().to_i32().to_pyobject(vm),
-                                val,
-                                vm,
-                            )?;
-                        } else if let Some(string) = key.payload::<Self>() {
-                            if string.len() == 1 {
-                                let num_value = string.as_str().chars().next().unwrap() as u32;
-                                new_dict.set_item(&*num_value.to_pyobject(vm), val, vm)?;
-                            } else {
-                                return Err(vm.new_value_error(
-                                    "string keys in translate table must be of length 1",
-                                ));
-                            }
-                        } else {
-                            return Err(vm.new_type_error(
-                                "keys in translate table must be strings or integers",
-                            ));
-                        }
-                    }
-                    Ok(new_dict.to_pyobject(vm))
-                }
-                _ => Err(vm.new_value_error(
-                    "if you give only one argument to maketrans it must be a dict",
-                )),
-            }
-        }
-    }
-
-    #[pymethod]
-    fn encode(zelf: PyRef<Self>, args: EncodeArgs, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-        encode_string(zelf, args.encoding, args.errors, vm)
-    }
-
-    #[pymethod]
-    fn __getnewargs__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
-        (zelf.as_str(),).to_pyobject(vm)
-    }
-}
-
-struct CharLenStr<'a>(&'a str, usize);
-impl std::ops::Deref for CharLenStr<'_> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        self.0
-    }
-}
-impl crate::common::format::CharLen for CharLenStr<'_> {
-    fn char_len(&self) -> usize {
-        self.1
-    }
-}
-
-#[pyclass]
-impl PyRef<PyStr> {
-    #[pymethod]
-    fn __str__(self, vm: &VirtualMachine) -> PyRefExact<PyStr> {
-        self.into_exact_or(&vm.ctx, |zelf| {
-            PyStr::from(zelf.data.clone()).into_exact_ref(&vm.ctx)
-        })
-    }
-}
-
-impl PyStrRef {
-    pub fn is_empty(&self) -> bool {
-        (**self).is_empty()
-    }
-
-    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);
-    }
-}
-
-impl Representable for PyStr {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        zelf.repr(vm)
-    }
-}
-
-impl Hashable for PyStr {
-    #[inline]
-    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        Ok(zelf.hash(vm))
-    }
-}
-
-impl Comparable for PyStr {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        _vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        if let Some(res) = op.identical_optimization(zelf, other) {
-            return Ok(res.into());
-        }
-        let other = class_or_notimplemented!(Self, other);
-        Ok(op.eval_ord(zelf.as_wtf8().cmp(other.as_wtf8())).into())
-    }
-}
-
-impl Iterable for PyStr {
-    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult {
-        Ok(PyStrIterator {
-            internal: PyMutex::new((PositionIterInternal::new(zelf, 0), 0)),
-        }
-        .into_pyobject(vm))
-    }
-}
-
-impl AsMapping for PyStr {
-    fn as_mapping() -> &'static PyMappingMethods {
-        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
-            length: atomic_func!(|mapping, _vm| Ok(PyStr::mapping_downcast(mapping).len())),
-            subscript: atomic_func!(
-                |mapping, needle, vm| PyStr::mapping_downcast(mapping)._getitem(needle, vm)
-            ),
-            ..PyMappingMethods::NOT_IMPLEMENTED
-        });
-        &AS_MAPPING
-    }
-}
-
-impl AsNumber for PyStr {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            remainder: Some(|a, b, vm| {
-                if let Some(a) = a.downcast_ref::<PyStr>() {
-                    a.modulo(b.to_owned(), vm).to_pyresult(vm)
-                } else {
-                    Ok(vm.ctx.not_implemented())
-                }
-            }),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-}
-
-impl AsSequence for PyStr {
-    fn as_sequence() -> &'static PySequenceMethods {
-        static AS_SEQUENCE: LazyLock<PySequenceMethods> = LazyLock::new(|| PySequenceMethods {
-            length: atomic_func!(|seq, _vm| Ok(PyStr::sequence_downcast(seq).len())),
-            concat: atomic_func!(|seq, other, vm| {
-                let zelf = PyStr::sequence_downcast(seq);
-                PyStr::__add__(zelf.to_owned(), other.to_owned(), vm)
-            }),
-            repeat: atomic_func!(|seq, n, vm| {
-                let zelf = PyStr::sequence_downcast(seq);
-                PyStr::repeat(zelf.to_owned(), n, vm).map(|x| x.into())
-            }),
-            item: atomic_func!(|seq, i, vm| {
-                let zelf = PyStr::sequence_downcast(seq);
-                zelf.getitem_by_index(vm, i).to_pyresult(vm)
-            }),
-            contains: atomic_func!(
-                |seq, needle, vm| PyStr::sequence_downcast(seq)._contains(needle, vm)
-            ),
-            ..PySequenceMethods::NOT_IMPLEMENTED
-        });
-        &AS_SEQUENCE
-    }
-}
-
-#[derive(FromArgs)]
-struct EncodeArgs {
-    #[pyarg(any, default)]
-    encoding: Option<PyStrRef>,
-    #[pyarg(any, default)]
-    errors: Option<PyStrRef>,
-}
-
-pub(crate) fn encode_string(
-    s: PyStrRef,
-    encoding: Option<PyStrRef>,
-    errors: Option<PyStrRef>,
-    vm: &VirtualMachine,
-) -> PyResult<PyBytesRef> {
-    let encoding = encoding
-        .as_ref()
-        .map_or(crate::codecs::DEFAULT_ENCODING, |s| s.as_str());
-    vm.state.codec_registry.encode_text(s, encoding, errors, vm)
-}
-
-impl PyPayload for PyStr {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.str_type
-    }
-}
-
-impl ToPyObject for String {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for Wtf8Buf {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for char {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for CodePoint {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for &str {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for &String {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self.clone()).into()
-    }
-}
-
-impl ToPyObject for &Wtf8 {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for &Wtf8Buf {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self.clone()).into()
-    }
-}
-
-impl ToPyObject for &AsciiStr {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for AsciiString {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-impl ToPyObject for AsciiChar {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.new_str(self).into()
-    }
-}
-
-type SplitArgs = anystr::SplitArgs<PyStrRef>;
-
-#[derive(FromArgs)]
-pub struct FindArgs {
-    #[pyarg(positional)]
-    sub: PyStrRef,
-    #[pyarg(positional, default)]
-    start: Option<PyIntRef>,
-    #[pyarg(positional, default)]
-    end: Option<PyIntRef>,
-}
-
-impl FindArgs {
-    fn get_value(self, len: usize) -> (PyStrRef, std::ops::Range<usize>) {
-        let range = adjust_indices(self.start, self.end, len);
-        (self.sub, range)
-    }
-}
-
-pub fn init(ctx: &Context) {
-    PyStr::extend_class(ctx, ctx.types.str_type);
-
-    PyStrIterator::extend_class(ctx, ctx.types.str_iterator_type);
-}
-
-impl SliceableSequenceOp for PyStr {
-    type Item = CodePoint;
-    type Sliced = Self;
-
-    fn do_get(&self, index: usize) -> Self::Item {
-        self.data.nth_char(index)
-    }
-
-    fn do_slice(&self, range: Range<usize>) -> Self::Sliced {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s[range].into(),
-            PyKindStr::Utf8(s) => {
-                let char_len = range.len();
-                let out = rustpython_common::str::get_chars(s, range);
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-            PyKindStr::Wtf8(w) => {
-                let char_len = range.len();
-                let out = rustpython_common::str::get_codepoints(w, range);
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-        }
-    }
-
-    fn do_slice_reverse(&self, range: Range<usize>) -> Self::Sliced {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => {
-                let mut out = s[range].to_owned();
-                out.as_mut_slice().reverse();
-                out.into()
-            }
-            PyKindStr::Utf8(s) => {
-                let char_len = range.len();
-                let mut out = String::with_capacity(2 * char_len);
-                out.extend(
-                    s.chars()
-                        .rev()
-                        .skip(self.char_len() - range.end)
-                        .take(range.len()),
-                );
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, range.len()) }
-            }
-            PyKindStr::Wtf8(w) => {
-                let char_len = range.len();
-                let mut out = Wtf8Buf::with_capacity(2 * char_len);
-                out.extend(
-                    w.code_points()
-                        .rev()
-                        .skip(self.char_len() - range.end)
-                        .take(range.len()),
-                );
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-        }
-    }
-
-    fn do_stepped_slice(&self, range: Range<usize>, step: usize) -> Self::Sliced {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s[range]
-                .as_slice()
-                .iter()
-                .copied()
-                .step_by(step)
-                .collect::<AsciiString>()
-                .into(),
-            PyKindStr::Utf8(s) => {
-                let char_len = (range.len() / step) + 1;
-                let mut out = String::with_capacity(2 * char_len);
-                out.extend(s.chars().skip(range.start).take(range.len()).step_by(step));
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-            PyKindStr::Wtf8(w) => {
-                let char_len = (range.len() / step) + 1;
-                let mut out = Wtf8Buf::with_capacity(2 * char_len);
-                out.extend(
-                    w.code_points()
-                        .skip(range.start)
-                        .take(range.len())
-                        .step_by(step),
-                );
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-        }
-    }
-
-    fn do_stepped_slice_reverse(&self, range: Range<usize>, step: usize) -> Self::Sliced {
-        match self.as_str_kind() {
-            PyKindStr::Ascii(s) => s[range]
-                .chars()
-                .rev()
-                .step_by(step)
-                .collect::<AsciiString>()
-                .into(),
-            PyKindStr::Utf8(s) => {
-                let char_len = (range.len() / step) + 1;
-                // not ascii, so the codepoints have to be at least 2 bytes each
-                let mut out = String::with_capacity(2 * char_len);
-                out.extend(
-                    s.chars()
-                        .rev()
-                        .skip(self.char_len() - range.end)
-                        .take(range.len())
-                        .step_by(step),
-                );
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-            PyKindStr::Wtf8(w) => {
-                let char_len = (range.len() / step) + 1;
-                // not ascii, so the codepoints have to be at least 2 bytes each
-                let mut out = Wtf8Buf::with_capacity(2 * char_len);
-                out.extend(
-                    w.code_points()
-                        .rev()
-                        .skip(self.char_len() - range.end)
-                        .take(range.len())
-                        .step_by(step),
-                );
-                // SAFETY: char_len is accurate
-                unsafe { Self::new_with_char_len(out, char_len) }
-            }
-        }
-    }
-
-    fn empty() -> Self::Sliced {
-        Self::default()
-    }
-
-    fn len(&self) -> usize {
-        self.char_len()
-    }
-}
-
-impl AsRef<str> for PyRefExact<PyStr> {
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl AsRef<str> for PyExact<PyStr> {
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-impl AsRef<Wtf8> for PyRefExact<PyStr> {
-    fn as_ref(&self) -> &Wtf8 {
-        self.as_wtf8()
-    }
-}
-
-impl AsRef<Wtf8> for PyExact<PyStr> {
-    fn as_ref(&self) -> &Wtf8 {
-        self.as_wtf8()
-    }
-}
-
-impl AnyStrWrapper<Wtf8> for PyStrRef {
-    fn as_ref(&self) -> Option<&Wtf8> {
-        Some(self.as_wtf8())
-    }
-
-    fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-}
-
-impl AnyStrWrapper<str> for PyStrRef {
-    fn as_ref(&self) -> Option<&str> {
-        self.data.as_str()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-}
-
-impl AnyStrWrapper<AsciiStr> for PyStrRef {
-    fn as_ref(&self) -> Option<&AsciiStr> {
-        self.data.as_ascii()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-}
-
-impl AnyStrContainer<str> for String {
-    fn new() -> Self {
-        Self::new()
-    }
-
-    fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity(capacity)
-    }
-
-    fn push_str(&mut self, other: &str) {
-        Self::push_str(self, other)
-    }
-}
-
-impl anystr::AnyChar for char {
-    fn is_lowercase(self) -> bool {
-        self.is_lowercase()
-    }
-
-    fn is_uppercase(self) -> bool {
-        self.is_uppercase()
-    }
-
-    fn bytes_len(self) -> usize {
-        self.len_utf8()
-    }
-}
-
-impl AnyStr for str {
-    type Char = char;
-    type Container = String;
-
-    fn to_container(&self) -> Self::Container {
-        self.to_owned()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        self.as_bytes()
-    }
-
-    fn elements(&self) -> impl Iterator<Item = char> {
-        Self::chars(self)
-    }
-
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
-        &self[range]
-    }
-
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
-        rustpython_common::str::get_chars(self, range)
-    }
-
-    fn is_empty(&self) -> bool {
-        Self::is_empty(self)
-    }
-
-    fn bytes_len(&self) -> usize {
-        Self::len(self)
-    }
-
-    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        // CPython split_whitespace
-        let mut splits = Vec::new();
-        let mut last_offset = 0;
-        let mut count = maxsplit;
-        for (offset, _) in self.match_indices(|c: char| c.is_ascii_whitespace() || c == '\x0b') {
-            if last_offset == offset {
-                last_offset += 1;
-                continue;
-            }
-            if count == 0 {
-                break;
-            }
-            splits.push(convert(&self[last_offset..offset]));
-            last_offset = offset + 1;
-            count -= 1;
-        }
-        if last_offset != self.len() {
-            splits.push(convert(&self[last_offset..]));
-        }
-        splits
-    }
-
-    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        // CPython rsplit_whitespace
-        let mut splits = Vec::new();
-        let mut last_offset = self.len();
-        let mut count = maxsplit;
-        for (offset, _) in self.rmatch_indices(|c: char| c.is_ascii_whitespace() || c == '\x0b') {
-            if last_offset == offset + 1 {
-                last_offset -= 1;
-                continue;
-            }
-            if count == 0 {
-                break;
-            }
-            splits.push(convert(&self[offset + 1..last_offset]));
-            last_offset = offset;
-            count -= 1;
-        }
-        if last_offset != 0 {
-            splits.push(convert(&self[..last_offset]));
-        }
-        splits
-    }
-}
-
-impl AnyStrContainer<Wtf8> for Wtf8Buf {
-    fn new() -> Self {
-        Self::new()
-    }
-
-    fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity(capacity)
-    }
-
-    fn push_str(&mut self, other: &Wtf8) {
-        self.push_wtf8(other)
-    }
-}
-
-impl anystr::AnyChar for CodePoint {
-    fn is_lowercase(self) -> bool {
-        self.is_char_and(char::is_lowercase)
-    }
-    fn is_uppercase(self) -> bool {
-        self.is_char_and(char::is_uppercase)
-    }
-    fn bytes_len(self) -> usize {
-        self.len_wtf8()
-    }
-}
-
-impl AnyStr for Wtf8 {
-    type Char = CodePoint;
-    type Container = Wtf8Buf;
-
-    fn to_container(&self) -> Self::Container {
-        self.to_owned()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        self.as_bytes()
-    }
-
-    fn elements(&self) -> impl Iterator<Item = Self::Char> {
-        self.code_points()
-    }
-
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
-        &self[range]
-    }
-
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
-        rustpython_common::str::get_codepoints(self, range)
-    }
-
-    fn bytes_len(&self) -> usize {
-        self.len()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.is_empty()
-    }
-
-    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        // CPython split_whitespace
-        let mut splits = Vec::new();
-        let mut last_offset = 0;
-        let mut count = maxsplit;
-        for (offset, _) in self
-            .code_point_indices()
-            .filter(|(_, c)| c.is_char_and(|c| c.is_ascii_whitespace() || c == '\x0b'))
-        {
-            if last_offset == offset {
-                last_offset += 1;
-                continue;
-            }
-            if count == 0 {
-                break;
-            }
-            splits.push(convert(&self[last_offset..offset]));
-            last_offset = offset + 1;
-            count -= 1;
-        }
-        if last_offset != self.len() {
-            splits.push(convert(&self[last_offset..]));
-        }
-        splits
-    }
-
-    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        // CPython rsplit_whitespace
-        let mut splits = Vec::new();
-        let mut last_offset = self.len();
-        let mut count = maxsplit;
-        for (offset, _) in self
-            .code_point_indices()
-            .rev()
-            .filter(|(_, c)| c.is_char_and(|c| c.is_ascii_whitespace() || c == '\x0b'))
-        {
-            if last_offset == offset + 1 {
-                last_offset -= 1;
-                continue;
-            }
-            if count == 0 {
-                break;
-            }
-            splits.push(convert(&self[offset + 1..last_offset]));
-            last_offset = offset;
-            count -= 1;
-        }
-        if last_offset != 0 {
-            splits.push(convert(&self[..last_offset]));
-        }
-        splits
-    }
-}
-
-impl AnyStrContainer<AsciiStr> for AsciiString {
-    fn new() -> Self {
-        Self::new()
-    }
-
-    fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity(capacity)
-    }
-
-    fn push_str(&mut self, other: &AsciiStr) {
-        Self::push_str(self, other)
-    }
-}
-
-impl anystr::AnyChar for ascii::AsciiChar {
-    fn is_lowercase(self) -> bool {
-        self.is_lowercase()
-    }
-
-    fn is_uppercase(self) -> bool {
-        self.is_uppercase()
-    }
-
-    fn bytes_len(self) -> usize {
-        1
-    }
-}
-
-const ASCII_WHITESPACES: [u8; 6] = [0x20, 0x09, 0x0a, 0x0c, 0x0d, 0x0b];
-
-impl AnyStr for AsciiStr {
-    type Char = AsciiChar;
-    type Container = AsciiString;
-
-    fn to_container(&self) -> Self::Container {
-        self.to_ascii_string()
-    }
-
-    fn as_bytes(&self) -> &[u8] {
-        self.as_bytes()
-    }
-
-    fn elements(&self) -> impl Iterator<Item = Self::Char> {
-        self.chars()
-    }
-
-    fn get_bytes(&self, range: std::ops::Range<usize>) -> &Self {
-        &self[range]
-    }
-
-    fn get_chars(&self, range: std::ops::Range<usize>) -> &Self {
-        &self[range]
-    }
-
-    fn bytes_len(&self) -> usize {
-        self.len()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.is_empty()
-    }
-
-    fn py_split_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        let mut splits = Vec::new();
-        let mut count = maxsplit;
-        let mut haystack = self;
-        while let Some(offset) = haystack.as_bytes().find_byteset(ASCII_WHITESPACES) {
-            if offset != 0 {
-                if count == 0 {
-                    break;
-                }
-                splits.push(convert(&haystack[..offset]));
-                count -= 1;
-            }
-            haystack = &haystack[offset + 1..];
-        }
-        if !haystack.is_empty() {
-            splits.push(convert(haystack));
-        }
-        splits
-    }
-
-    fn py_rsplit_whitespace<F>(&self, maxsplit: isize, convert: F) -> Vec<PyObjectRef>
-    where
-        F: Fn(&Self) -> PyObjectRef,
-    {
-        // CPython rsplit_whitespace
-        let mut splits = Vec::new();
-        let mut count = maxsplit;
-        let mut haystack = self;
-        while let Some(offset) = haystack.as_bytes().rfind_byteset(ASCII_WHITESPACES) {
-            if offset + 1 != haystack.len() {
-                if count == 0 {
-                    break;
-                }
-                splits.push(convert(&haystack[offset + 1..]));
-                count -= 1;
-            }
-            haystack = &haystack[..offset];
-        }
-        if !haystack.is_empty() {
-            splits.push(convert(haystack));
-        }
-        splits
-    }
-}
-
-/// The unique reference of interned PyStr
-/// Always intended to be used as a static reference
-pub type PyStrInterned = PyInterned<PyStr>;
-
-impl PyStrInterned {
-    #[inline]
-    pub fn to_exact(&'static self) -> PyRefExact<PyStr> {
-        unsafe { PyRefExact::new_unchecked(self.to_owned()) }
-    }
-}
-
-impl std::fmt::Display for PyStrInterned {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.data.fmt(f)
-    }
-}
-
-impl AsRef<str> for PyStrInterned {
-    #[inline(always)]
-    fn as_ref(&self) -> &str {
-        self.as_str()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::Interpreter;
-
-    #[test]
-    fn str_title() {
-        let tests = vec![
-            (" Hello ", " hello "),
-            ("Hello ", "hello "),
-            ("Hello ", "Hello "),
-            ("Format This As Title String", "fOrMaT thIs aS titLe String"),
-            ("Format,This-As*Title;String", "fOrMaT,thIs-aS*titLe;String"),
-            ("Getint", "getInt"),
-            // spell-checker:disable-next-line
-            ("Greek Ωppercases ...", "greek ωppercases ..."),
-            // spell-checker:disable-next-line
-            ("Greek ῼitlecases ...", "greek ῳitlecases ..."),
-        ];
-        for (title, input) in tests {
-            assert_eq!(PyStr::from(input).title().as_str(), Ok(title));
-        }
-    }
-
-    #[test]
-    fn str_istitle() {
-        let pos = vec![
-            "A",
-            "A Titlecased Line",
-            "A\nTitlecased Line",
-            "A Titlecased, Line",
-            // spell-checker:disable-next-line
-            "Greek Ωppercases ...",
-            // spell-checker:disable-next-line
-            "Greek ῼitlecases ...",
-        ];
-
-        for s in pos {
-            assert!(PyStr::from(s).istitle());
-        }
-
-        let neg = vec![
-            "",
-            "a",
-            "\n",
-            "Not a capitalized String",
-            "Not\ta Titlecase String",
-            "Not--a Titlecase String",
-            "NOT",
-        ];
-        for s in neg {
-            assert!(!PyStr::from(s).istitle());
-        }
-    }
-
-    #[test]
-    fn str_maketrans_and_translate() {
-        Interpreter::without_stdlib(Default::default()).enter(|vm| {
-            let table = vm.ctx.new_dict();
-            table
-                .set_item("a", vm.ctx.new_str("🎅").into(), vm)
-                .unwrap();
-            table.set_item("b", vm.ctx.none(), vm).unwrap();
-            table
-                .set_item("c", vm.ctx.new_str(ascii!("xda")).into(), vm)
-                .unwrap();
-            let translated =
-                PyStr::maketrans(table.into(), OptionalArg::Missing, OptionalArg::Missing, vm)
-                    .unwrap();
-            let text = PyStr::from("abc");
-            let translated = text.translate(translated, vm).unwrap();
-            assert_eq!(translated, "🎅xda".to_owned());
-            let translated = text.translate(vm.ctx.new_int(3).into(), vm);
-            assert_eq!("TypeError", &*translated.unwrap_err().class().name(),);
-        })
-    }
-}
diff --git a/vm/src/builtins/traceback.rs b/vm/src/builtins/traceback.rs
deleted file mode 100644
index 33063132c6..0000000000
--- a/vm/src/builtins/traceback.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-use rustpython_common::lock::PyMutex;
-
-use super::PyType;
-use crate::{
-    Context, Py, PyPayload, PyRef, class::PyClassImpl, frame::FrameRef, source::LineNumber,
-};
-
-#[pyclass(module = false, name = "traceback", traverse)]
-#[derive(Debug)]
-pub struct PyTraceback {
-    pub next: PyMutex<Option<PyTracebackRef>>,
-    pub frame: FrameRef,
-    #[pytraverse(skip)]
-    pub lasti: u32,
-    #[pytraverse(skip)]
-    pub lineno: LineNumber,
-}
-
-pub type PyTracebackRef = PyRef<PyTraceback>;
-
-impl PyPayload for PyTraceback {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.traceback_type
-    }
-}
-
-#[pyclass]
-impl PyTraceback {
-    pub const fn new(
-        next: Option<PyRef<Self>>,
-        frame: FrameRef,
-        lasti: u32,
-        lineno: LineNumber,
-    ) -> Self {
-        Self {
-            next: PyMutex::new(next),
-            frame,
-            lasti,
-            lineno,
-        }
-    }
-
-    #[pygetset]
-    fn tb_frame(&self) -> FrameRef {
-        self.frame.clone()
-    }
-
-    #[pygetset]
-    const fn tb_lasti(&self) -> u32 {
-        self.lasti
-    }
-
-    #[pygetset]
-    const fn tb_lineno(&self) -> usize {
-        self.lineno.get()
-    }
-
-    #[pygetset]
-    fn tb_next(&self) -> Option<PyRef<Self>> {
-        self.next.lock().as_ref().cloned()
-    }
-
-    #[pygetset(setter)]
-    fn set_tb_next(&self, value: Option<PyRef<Self>>) {
-        *self.next.lock() = value;
-    }
-}
-
-impl PyTracebackRef {
-    pub fn iter(&self) -> impl Iterator<Item = Self> {
-        std::iter::successors(Some(self.clone()), |tb| tb.next.lock().clone())
-    }
-}
-
-pub fn init(context: &Context) {
-    PyTraceback::extend_class(context, context.types.traceback_type);
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for PyTraceback {
-    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::SerializeStruct;
-
-        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.end()
-    }
-}
diff --git a/vm/src/builtins/type.rs b/vm/src/builtins/type.rs
deleted file mode 100644
index 806d32f906..0000000000
--- a/vm/src/builtins/type.rs
+++ /dev/null
@@ -1,1684 +0,0 @@
-use super::{
-    PyClassMethod, PyDictRef, PyList, PyStr, PyStrInterned, PyStrRef, PyTuple, PyTupleRef, PyWeak,
-    mappingproxy::PyMappingProxy, object, union_,
-};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-    VirtualMachine,
-    builtins::{
-        PyBaseExceptionRef,
-        descriptor::{
-            MemberGetter, MemberKind, MemberSetter, PyDescriptorOwned, PyMemberDef,
-            PyMemberDescriptor,
-        },
-        function::PyCellRef,
-        tuple::{IntoPyTuple, PyTupleTyped},
-    },
-    class::{PyClassImpl, StaticType},
-    common::{
-        ascii,
-        borrow::BorrowedValue,
-        lock::{PyRwLock, PyRwLockReadGuard},
-    },
-    convert::ToPyResult,
-    function::{FuncArgs, KwArgs, OptionalArg, PyMethodDef, PySetterValue},
-    identifier,
-    object::{Traverse, TraverseFn},
-    protocol::{PyIterReturn, PyMappingMethods, PyNumberMethods, PySequenceMethods},
-    types::{
-        AsNumber, Callable, Constructor, GetAttr, PyTypeFlags, PyTypeSlots, Representable, SetAttr,
-    },
-};
-use indexmap::{IndexMap, map::Entry};
-use itertools::Itertools;
-use std::{borrow::Borrow, collections::HashSet, ops::Deref, pin::Pin, ptr::NonNull};
-
-#[pyclass(module = false, name = "type", traverse = "manual")]
-pub struct PyType {
-    pub base: Option<PyTypeRef>,
-    pub bases: PyRwLock<Vec<PyTypeRef>>,
-    pub mro: PyRwLock<Vec<PyTypeRef>>,
-    pub subclasses: PyRwLock<Vec<PyRef<PyWeak>>>,
-    pub attributes: PyRwLock<PyAttributes>,
-    pub slots: PyTypeSlots,
-    pub heaptype_ext: Option<Pin<Box<HeapTypeExt>>>,
-}
-
-unsafe impl crate::object::Traverse for PyType {
-    fn traverse(&self, tracer_fn: &mut crate::object::TraverseFn<'_>) {
-        self.base.traverse(tracer_fn);
-        self.bases.traverse(tracer_fn);
-        self.mro.traverse(tracer_fn);
-        self.subclasses.traverse(tracer_fn);
-        self.attributes
-            .read_recursive()
-            .iter()
-            .map(|(_, v)| v.traverse(tracer_fn))
-            .count();
-    }
-}
-
-// PyHeapTypeObject in CPython
-pub struct HeapTypeExt {
-    pub name: PyRwLock<PyStrRef>,
-    pub qualname: PyRwLock<PyStrRef>,
-    pub slots: Option<PyTupleTyped<PyStrRef>>,
-    pub sequence_methods: PySequenceMethods,
-    pub mapping_methods: PyMappingMethods,
-}
-
-pub struct PointerSlot<T>(NonNull<T>);
-
-unsafe impl<T> Sync for PointerSlot<T> {}
-unsafe impl<T> Send for PointerSlot<T> {}
-
-impl<T> PointerSlot<T> {
-    pub const unsafe fn borrow_static(&self) -> &'static T {
-        unsafe { self.0.as_ref() }
-    }
-}
-
-impl<T> Clone for PointerSlot<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> Copy for PointerSlot<T> {}
-
-impl<T> From<&'static T> for PointerSlot<T> {
-    fn from(x: &'static T) -> Self {
-        Self(NonNull::from(x))
-    }
-}
-
-impl<T> AsRef<T> for PointerSlot<T> {
-    fn as_ref(&self) -> &T {
-        unsafe { self.0.as_ref() }
-    }
-}
-
-impl<T> PointerSlot<T> {
-    pub unsafe fn from_heaptype<F>(typ: &PyType, f: F) -> Option<Self>
-    where
-        F: FnOnce(&HeapTypeExt) -> &T,
-    {
-        typ.heaptype_ext
-            .as_ref()
-            .map(|ext| Self(NonNull::from(f(ext))))
-    }
-}
-
-pub type PyTypeRef = PyRef<PyType>;
-
-cfg_if::cfg_if! {
-    if #[cfg(feature = "threading")] {
-        unsafe impl Send for PyType {}
-        unsafe impl Sync for PyType {}
-    }
-}
-
-/// For attributes we do not use a dict, but an IndexMap, which is an Hash Table
-/// that maintains order and is compatible with the standard HashMap  This is probably
-/// faster and only supports strings as keys.
-pub type PyAttributes = IndexMap<&'static PyStrInterned, PyObjectRef, ahash::RandomState>;
-
-unsafe impl Traverse for PyAttributes {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.values().for_each(|v| v.traverse(tracer_fn));
-    }
-}
-
-impl std::fmt::Display for PyType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(&self.name(), f)
-    }
-}
-
-impl std::fmt::Debug for PyType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "[PyType {}]", &self.name())
-    }
-}
-
-impl PyPayload for PyType {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.type_type
-    }
-}
-
-fn downcast_qualname(value: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>> {
-    match value.downcast::<PyStr>() {
-        Ok(value) => Ok(value),
-        Err(value) => Err(vm.new_type_error(format!(
-            "can only assign string to __qualname__, not '{}'",
-            value.class().name()
-        ))),
-    }
-}
-
-fn is_subtype_with_mro(a_mro: &[PyTypeRef], a: &Py<PyType>, b: &Py<PyType>) -> bool {
-    if a.is(b) {
-        return true;
-    }
-    for item in a_mro {
-        if item.is(b) {
-            return true;
-        }
-    }
-    false
-}
-
-impl PyType {
-    pub fn new_simple_heap(
-        name: &str,
-        base: &PyTypeRef,
-        ctx: &Context,
-    ) -> Result<PyRef<Self>, String> {
-        Self::new_heap(
-            name,
-            vec![base.clone()],
-            Default::default(),
-            Default::default(),
-            Self::static_type().to_owned(),
-            ctx,
-        )
-    }
-    pub fn new_heap(
-        name: &str,
-        bases: Vec<PyRef<Self>>,
-        attrs: PyAttributes,
-        slots: PyTypeSlots,
-        metaclass: PyRef<Self>,
-        ctx: &Context,
-    ) -> Result<PyRef<Self>, String> {
-        // TODO: ensure clean slot name
-        // assert_eq!(slots.name.borrow(), "");
-
-        let name = ctx.new_str(name);
-        let heaptype_ext = HeapTypeExt {
-            name: PyRwLock::new(name.clone()),
-            qualname: PyRwLock::new(name),
-            slots: None,
-            sequence_methods: PySequenceMethods::default(),
-            mapping_methods: PyMappingMethods::default(),
-        };
-        let base = bases[0].clone();
-
-        Self::new_heap_inner(base, bases, attrs, slots, heaptype_ext, metaclass, ctx)
-    }
-
-    /// Equivalent to CPython's PyType_Check macro
-    /// Checks if obj is an instance of type (or its subclass)
-    pub(crate) fn check(obj: &PyObject) -> Option<&Py<Self>> {
-        obj.downcast_ref::<Self>()
-    }
-
-    fn resolve_mro(bases: &[PyRef<Self>]) -> Result<Vec<PyTypeRef>, String> {
-        // Check for duplicates in bases.
-        let mut unique_bases = HashSet::new();
-        for base in bases {
-            if !unique_bases.insert(base.get_id()) {
-                return Err(format!("duplicate base class {}", base.name()));
-            }
-        }
-
-        let mros = bases
-            .iter()
-            .map(|base| base.mro_map_collect(|t| t.to_owned()))
-            .collect();
-        linearise_mro(mros)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn new_heap_inner(
-        base: PyRef<Self>,
-        bases: Vec<PyRef<Self>>,
-        attrs: PyAttributes,
-        mut slots: PyTypeSlots,
-        heaptype_ext: HeapTypeExt,
-        metaclass: PyRef<Self>,
-        ctx: &Context,
-    ) -> Result<PyRef<Self>, String> {
-        let mro = Self::resolve_mro(&bases)?;
-
-        if base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
-            slots.flags |= PyTypeFlags::HAS_DICT
-        }
-        if slots.basicsize == 0 {
-            slots.basicsize = base.slots.basicsize;
-        }
-
-        if let Some(qualname) = attrs.get(identifier!(ctx, __qualname__)) {
-            if !qualname.fast_isinstance(ctx.types.str_type) {
-                return Err(format!(
-                    "type __qualname__ must be a str, not {}",
-                    qualname.class().name()
-                ));
-            }
-        }
-
-        let new_type = PyRef::new_ref(
-            Self {
-                base: Some(base),
-                bases: PyRwLock::new(bases),
-                mro: PyRwLock::new(mro),
-                subclasses: PyRwLock::default(),
-                attributes: PyRwLock::new(attrs),
-                slots,
-                heaptype_ext: Some(Pin::new(Box::new(heaptype_ext))),
-            },
-            metaclass,
-            None,
-        );
-
-        new_type.init_slots(ctx);
-
-        let weakref_type = super::PyWeak::static_type();
-        for base in new_type.bases.read().iter() {
-            base.subclasses.write().push(
-                new_type
-                    .as_object()
-                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
-                    .unwrap(),
-            );
-        }
-
-        Ok(new_type)
-    }
-
-    pub fn new_static(
-        base: PyRef<Self>,
-        attrs: PyAttributes,
-        mut slots: PyTypeSlots,
-        metaclass: PyRef<Self>,
-    ) -> Result<PyRef<Self>, String> {
-        if base.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
-            slots.flags |= PyTypeFlags::HAS_DICT
-        }
-        if slots.basicsize == 0 {
-            slots.basicsize = base.slots.basicsize;
-        }
-
-        let bases = PyRwLock::new(vec![base.clone()]);
-        let mro = base.mro_map_collect(|x| x.to_owned());
-
-        let new_type = PyRef::new_ref(
-            Self {
-                base: Some(base),
-                bases,
-                mro: PyRwLock::new(mro),
-                subclasses: PyRwLock::default(),
-                attributes: PyRwLock::new(attrs),
-                slots,
-                heaptype_ext: None,
-            },
-            metaclass,
-            None,
-        );
-
-        let weakref_type = super::PyWeak::static_type();
-        for base in new_type.bases.read().iter() {
-            base.subclasses.write().push(
-                new_type
-                    .as_object()
-                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
-                    .unwrap(),
-            );
-        }
-
-        Ok(new_type)
-    }
-
-    pub(crate) fn init_slots(&self, ctx: &Context) {
-        #[allow(clippy::mutable_key_type)]
-        let mut slot_name_set = std::collections::HashSet::new();
-
-        for cls in self.mro.read().iter() {
-            for &name in cls.attributes.read().keys() {
-                if name == identifier!(ctx, __new__) {
-                    continue;
-                }
-                if name.as_str().starts_with("__") && name.as_str().ends_with("__") {
-                    slot_name_set.insert(name);
-                }
-            }
-        }
-        for &name in self.attributes.read().keys() {
-            if name.as_str().starts_with("__") && name.as_str().ends_with("__") {
-                slot_name_set.insert(name);
-            }
-        }
-        for attr_name in slot_name_set {
-            self.update_slot::<true>(attr_name, ctx);
-        }
-    }
-
-    // This is used for class initialization where the vm is not yet available.
-    pub fn set_str_attr<V: Into<PyObjectRef>>(
-        &self,
-        attr_name: &str,
-        value: V,
-        ctx: impl AsRef<Context>,
-    ) {
-        let ctx = ctx.as_ref();
-        let attr_name = ctx.intern_str(attr_name);
-        self.set_attr(attr_name, value.into())
-    }
-
-    pub fn set_attr(&self, attr_name: &'static PyStrInterned, value: PyObjectRef) {
-        self.attributes.write().insert(attr_name, value);
-    }
-
-    /// This is the internal get_attr implementation for fast lookup on a class.
-    pub fn get_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        flame_guard!(format!("class_get_attr({:?})", attr_name));
-
-        self.get_direct_attr(attr_name)
-            .or_else(|| self.get_super_attr(attr_name))
-    }
-
-    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
-    fn find_name_in_mro(&self, name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        // First check in our own dict
-        if let Some(value) = self.attributes.read().get(name) {
-            return Some(value.clone());
-        }
-
-        // Then check in MRO
-        for base in self.mro.read().iter() {
-            if let Some(value) = base.attributes.read().get(name) {
-                return Some(value.clone());
-            }
-        }
-
-        None
-    }
-
-    /// Equivalent to CPython's _PyType_LookupRef
-    /// Looks 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)
-    }
-
-    pub fn get_super_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
-        self.mro
-            .read()
-            .iter()
-            .find_map(|class| class.attributes.read().get(attr_name).cloned())
-    }
-
-    // This is the internal has_attr implementation for fast lookup on a class.
-    pub fn has_attr(&self, attr_name: &'static PyStrInterned) -> bool {
-        self.attributes.read().contains_key(attr_name)
-            || self
-                .mro
-                .read()
-                .iter()
-                .any(|c| c.attributes.read().contains_key(attr_name))
-    }
-
-    pub fn get_attributes(&self) -> PyAttributes {
-        // Gather all members here:
-        let mut attributes = PyAttributes::default();
-
-        for bc in std::iter::once(self)
-            .chain(self.mro.read().iter().map(|cls| -> &Self { cls }))
-            .rev()
-        {
-            for (name, value) in bc.attributes.read().iter() {
-                attributes.insert(name.to_owned(), value.clone());
-            }
-        }
-
-        attributes
-    }
-
-    // bound method for every type
-    pub(crate) fn __new__(zelf: PyRef<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let (subtype, args): (PyRef<Self>, FuncArgs) = args.bind(vm)?;
-        if !subtype.fast_issubclass(&zelf) {
-            return Err(vm.new_type_error(format!(
-                "{zelf}.__new__({subtype}): {subtype} is not a subtype of {zelf}",
-                zelf = zelf.name(),
-                subtype = subtype.name(),
-            )));
-        }
-        call_slot_new(zelf, subtype, args, vm)
-    }
-
-    fn name_inner<'a, R: 'a>(
-        &'a self,
-        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)
-        } else {
-            heap_f(self.heaptype_ext.as_ref().unwrap())
-        }
-    }
-
-    pub fn slot_name(&self) -> BorrowedValue<'_, str> {
-        self.name_inner(
-            |name| name.into(),
-            |ext| PyRwLockReadGuard::map(ext.name.read(), |name| 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(),
-        )
-    }
-}
-
-impl Py<PyType> {
-    pub(crate) fn is_subtype(&self, other: &Self) -> bool {
-        is_subtype_with_mro(&self.mro.read(), self, other)
-    }
-
-    /// Equivalent to CPython's PyType_CheckExact macro
-    /// Checks if obj is exactly a type (not a subclass)
-    pub fn check_exact<'a>(obj: &'a PyObject, vm: &VirtualMachine) -> Option<&'a Self> {
-        obj.downcast_ref_if_exact::<PyType>(vm)
-    }
-
-    /// Determines if `subclass` is actually a subclass of `cls`, this doesn't call __subclasscheck__,
-    /// so only use this if `cls` is known to have not overridden the base __subclasscheck__ magic
-    /// method.
-    pub fn fast_issubclass(&self, cls: &impl Borrow<PyObject>) -> bool {
-        self.as_object().is(cls.borrow()) || self.mro.read().iter().any(|c| c.is(cls.borrow()))
-    }
-
-    pub fn mro_map_collect<F, R>(&self, f: F) -> Vec<R>
-    where
-        F: Fn(&Self) -> R,
-    {
-        std::iter::once(self)
-            .chain(self.mro.read().iter().map(|x| x.deref()))
-            .map(f)
-            .collect()
-    }
-
-    pub fn mro_collect(&self) -> Vec<PyRef<PyType>> {
-        std::iter::once(self)
-            .chain(self.mro.read().iter().map(|x| x.deref()))
-            .map(|x| x.to_owned())
-            .collect()
-    }
-
-    pub(crate) fn mro_find_map<F, R>(&self, f: F) -> Option<R>
-    where
-        F: Fn(&Self) -> Option<R>,
-    {
-        // the hot path will be primitive types which usually hit the result from itself.
-        // try std::intrinsics::likely once it is stabilized
-        if let Some(r) = f(self) {
-            Some(r)
-        } else {
-            self.mro.read().iter().find_map(|cls| f(cls))
-        }
-    }
-
-    pub fn iter_base_chain(&self) -> impl Iterator<Item = &Self> {
-        std::iter::successors(Some(self), |cls| cls.base.as_deref())
-    }
-
-    pub fn extend_methods(&'static self, method_defs: &'static [PyMethodDef], ctx: &Context) {
-        for method_def in method_defs {
-            let method = method_def.to_proper_method(self, ctx);
-            self.set_attr(ctx.intern_str(method_def.name), method);
-        }
-    }
-}
-
-#[pyclass(
-    with(Py, Constructor, GetAttr, SetAttr, Callable, AsNumber, Representable),
-    flags(BASETYPE)
-)]
-impl PyType {
-    #[pygetset]
-    fn __bases__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        vm.ctx.new_tuple(
-            self.bases
-                .read()
-                .iter()
-                .map(|x| x.as_object().to_owned())
-                .collect(),
-        )
-    }
-    #[pygetset(setter, name = "__bases__")]
-    fn set_bases(zelf: &Py<Self>, bases: Vec<PyTypeRef>, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: Assigning to __bases__ is only used in typing.NamedTupleMeta.__new__
-        // Rather than correctly re-initializing the class, we are skipping a few steps for now
-        if zelf.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
-            return Err(vm.new_type_error(format!(
-                "cannot set '__bases__' attribute of immutable type '{}'",
-                zelf.name()
-            )));
-        }
-        if bases.is_empty() {
-            return Err(vm.new_type_error(format!(
-                "can only assign non-empty tuple to %s.__bases__, not {}",
-                zelf.name()
-            )));
-        }
-
-        // TODO: check for mro cycles
-
-        // TODO: Remove this class from all subclass lists
-        // for base in self.bases.read().iter() {
-        //     let subclasses = base.subclasses.write();
-        //     // TODO: how to uniquely identify the subclasses to remove?
-        // }
-
-        *zelf.bases.write() = bases;
-        // Recursively update the mros of this class and all subclasses
-        fn update_mro_recursively(cls: &PyType, vm: &VirtualMachine) -> PyResult<()> {
-            *cls.mro.write() =
-                PyType::resolve_mro(&cls.bases.read()).map_err(|msg| vm.new_type_error(msg))?;
-            for subclass in cls.subclasses.write().iter() {
-                let subclass = subclass.upgrade().unwrap();
-                let subclass: &PyType = subclass.payload().unwrap();
-                update_mro_recursively(subclass, vm)?;
-            }
-            Ok(())
-        }
-        update_mro_recursively(zelf, vm)?;
-
-        // TODO: do any old slots need to be cleaned up first?
-        zelf.init_slots(&vm.ctx);
-
-        // Register this type as a subclass of its new bases
-        let weakref_type = super::PyWeak::static_type();
-        for base in zelf.bases.read().iter() {
-            base.subclasses.write().push(
-                zelf.as_object()
-                    .downgrade_with_weakref_typ_opt(None, weakref_type.to_owned())
-                    .unwrap(),
-            );
-        }
-
-        Ok(())
-    }
-
-    #[pygetset]
-    fn __base__(&self) -> Option<PyTypeRef> {
-        self.base.clone()
-    }
-
-    #[pygetset]
-    const fn __flags__(&self) -> u64 {
-        self.slots.flags.bits()
-    }
-
-    #[pygetset]
-    const fn __basicsize__(&self) -> usize {
-        self.slots.basicsize
-    }
-
-    #[pygetset]
-    pub fn __name__(&self, vm: &VirtualMachine) -> PyStrRef {
-        self.name_inner(
-            |name| {
-                vm.ctx
-                    .interned_str(name.rsplit_once('.').map_or(name, |(_, name)| name))
-                    .unwrap_or_else(|| {
-                        panic!(
-                            "static type name must be already interned but {} is not",
-                            self.slot_name()
-                        )
-                    })
-                    .to_owned()
-            },
-            |ext| ext.name.read().clone(),
-        )
-    }
-
-    #[pygetset]
-    pub fn __qualname__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        if let Some(ref heap_type) = self.heaptype_ext {
-            heap_type.qualname.read().clone().into()
-        } else {
-            // For static types, return the name
-            vm.ctx.new_str(self.name().deref()).into()
-        }
-    }
-
-    #[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()
-            )));
-        };
-        let value = value.ok_or_else(|| {
-            vm.new_type_error(format!(
-                "cannot delete '__qualname__' attribute of immutable type '{}'",
-                self.name()
-            ))
-        })?;
-
-        let str_value = downcast_qualname(value, vm)?;
-
-        let heap_type = self
-            .heaptype_ext
-            .as_ref()
-            .expect("HEAPTYPE should have heaptype_ext");
-        *heap_type.qualname.write() = str_value;
-        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()
-            )));
-        }
-
-        let __annotations__ = identifier!(vm, __annotations__);
-        let annotations = self.attributes.read().get(__annotations__).cloned();
-
-        let annotations = if let Some(annotations) = annotations {
-            annotations
-        } else {
-            let annotations: PyObjectRef = vm.ctx.new_dict().into();
-            let removed = self
-                .attributes
-                .write()
-                .insert(__annotations__, annotations.clone());
-            debug_assert!(removed.is_none());
-            annotations
-        };
-        Ok(annotations)
-    }
-
-    #[pygetset(setter)]
-    fn set___annotations__(&self, value: Option<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 '{}'",
-                self.name()
-            )));
-        }
-
-        let __annotations__ = identifier!(vm, __annotations__);
-        if let Some(value) = value {
-            self.attributes.write().insert(__annotations__, value);
-        } else {
-            self.attributes
-                .read()
-                .get(__annotations__)
-                .cloned()
-                .ok_or_else(|| {
-                    vm.new_attribute_error(format!(
-                        "'{}' object has no attribute '__annotations__'",
-                        self.name()
-                    ))
-                })?;
-        }
-
-        Ok(())
-    }
-
-    #[pygetset]
-    pub fn __module__(&self, vm: &VirtualMachine) -> PyObjectRef {
-        self.attributes
-            .read()
-            .get(identifier!(vm, __module__))
-            .cloned()
-            // We need to exclude this method from going into recursion:
-            .and_then(|found| {
-                if found.fast_isinstance(vm.ctx.types.getset_type) {
-                    None
-                } else {
-                    Some(found)
-                }
-            })
-            .unwrap_or_else(|| vm.ctx.new_str(ascii!("builtins")).into())
-    }
-
-    #[pygetset(setter)]
-    fn set___module__(&self, value: PyObjectRef, vm: &VirtualMachine) {
-        self.attributes
-            .write()
-            .insert(identifier!(vm, __module__), value);
-    }
-
-    #[pyclassmethod]
-    fn __prepare__(
-        _cls: PyTypeRef,
-        _name: OptionalArg<PyObjectRef>,
-        _bases: OptionalArg<PyObjectRef>,
-        _kwargs: KwArgs,
-        vm: &VirtualMachine,
-    ) -> PyDictRef {
-        vm.ctx.new_dict()
-    }
-
-    #[pymethod]
-    fn __subclasses__(&self) -> PyList {
-        let mut subclasses = self.subclasses.write();
-        subclasses.retain(|x| x.upgrade().is_some());
-        PyList::from(
-            subclasses
-                .iter()
-                .map(|x| x.upgrade().unwrap())
-                .collect::<Vec<_>>(),
-        )
-    }
-
-    #[pymethod]
-    pub fn __ror__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        or_(other, zelf, vm)
-    }
-
-    #[pymethod]
-    pub fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        or_(zelf, other, vm)
-    }
-
-    #[pygetset]
-    fn __dict__(zelf: PyRef<Self>) -> PyMappingProxy {
-        PyMappingProxy::from(zelf)
-    }
-
-    #[pygetset(setter)]
-    fn set___dict__(&self, _value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        Err(vm.new_not_implemented_error(
-            "Setting __dict__ attribute on a type isn't yet implemented",
-        ))
-    }
-
-    fn check_set_special_type_attr(
-        &self,
-        _value: &PyObject,
-        name: &PyStrInterned,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
-            return Err(vm.new_type_error(format!(
-                "cannot set '{}' attribute of immutable type '{}'",
-                name,
-                self.slot_name()
-            )));
-        }
-        Ok(())
-    }
-
-    #[pygetset(setter)]
-    fn set___name__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self.check_set_special_type_attr(&value, identifier!(vm, __name__), vm)?;
-        let name = value.downcast::<PyStr>().map_err(|value| {
-            vm.new_type_error(format!(
-                "can only assign string to {}.__name__, not '{}'",
-                self.slot_name(),
-                value.class().slot_name(),
-            ))
-        })?;
-        if name.as_bytes().contains(&0) {
-            return Err(vm.new_value_error("type name must not contain null characters"));
-        }
-
-        *self.heaptype_ext.as_ref().unwrap().name.write() = name;
-
-        Ok(())
-    }
-
-    #[pygetset]
-    fn __text_signature__(&self) -> Option<String> {
-        self.slots
-            .doc
-            .and_then(|doc| get_text_signature_from_internal_doc(&self.name(), doc))
-            .map(|signature| signature.to_string())
-    }
-
-    #[pygetset]
-    fn __type_params__(&self, vm: &VirtualMachine) -> PyTupleRef {
-        let attrs = self.attributes.read();
-        let key = identifier!(vm, __type_params__);
-        if let Some(params) = attrs.get(&key) {
-            if let Ok(tuple) = params.clone().downcast::<PyTuple>() {
-                return tuple;
-            }
-        }
-        // Return empty tuple if not found or not a tuple
-        vm.ctx.empty_tuple.clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___type_params__(
-        &self,
-        value: PySetterValue<PyTupleRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        match value {
-            PySetterValue::Assign(ref val) => {
-                let key = identifier!(vm, __type_params__);
-                self.check_set_special_type_attr(val.as_ref(), key, vm)?;
-                let mut attrs = self.attributes.write();
-                attrs.insert(key, val.clone().into());
-            }
-            PySetterValue::Delete => {
-                // For delete, we still need to check if the type is immutable
-                if self.slots.flags.has_feature(PyTypeFlags::IMMUTABLETYPE) {
-                    return Err(vm.new_type_error(format!(
-                        "cannot delete '__type_params__' attribute of immutable type '{}'",
-                        self.slot_name()
-                    )));
-                }
-                let mut attrs = self.attributes.write();
-                let key = identifier!(vm, __type_params__);
-                attrs.shift_remove(&key);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Constructor for PyType {
-    type Args = FuncArgs;
-
-    fn py_new(metatype: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        vm_trace!("type.__new__ {:?}", args);
-
-        let is_type_type = metatype.is(vm.ctx.types.type_type);
-        if is_type_type && args.args.len() == 1 && args.kwargs.is_empty() {
-            return Ok(args.args[0].class().to_owned().into());
-        }
-
-        if args.args.len() != 3 {
-            return Err(vm.new_type_error(if is_type_type {
-                "type() takes 1 or 3 arguments".to_owned()
-            } else {
-                format!(
-                    "type.__new__() takes exactly 3 arguments ({} given)",
-                    args.args.len()
-                )
-            }));
-        }
-
-        let (name, bases, dict, kwargs): (PyStrRef, PyTupleRef, PyDictRef, KwArgs) =
-            args.clone().bind(vm)?;
-
-        if name.as_bytes().contains(&0) {
-            return Err(vm.new_value_error("type name must not contain null characters"));
-        }
-
-        let (metatype, base, bases) = if bases.is_empty() {
-            let base = vm.ctx.types.object_type.to_owned();
-            (metatype, base.clone(), vec![base])
-        } else {
-            let bases = bases
-                .iter()
-                .map(|obj| {
-                    obj.clone().downcast::<Self>().or_else(|obj| {
-                        if vm
-                            .get_attribute_opt(obj, identifier!(vm, __mro_entries__))?
-                            .is_some()
-                        {
-                            Err(vm.new_type_error(
-                                "type() doesn't support MRO entry resolution; \
-                                 use types.new_class()",
-                            ))
-                        } else {
-                            Err(vm.new_type_error("bases must be types"))
-                        }
-                    })
-                })
-                .collect::<PyResult<Vec<_>>>()?;
-
-            // Search the bases for the proper metatype to deal with this:
-            let winner = calculate_meta_class(metatype.clone(), &bases, vm)?;
-            let metatype = if !winner.is(&metatype) {
-                if let Some(ref slot_new) = winner.slots.new.load() {
-                    // Pass it to the winner
-                    return slot_new(winner, args, vm);
-                }
-                winner
-            } else {
-                metatype
-            };
-
-            let base = best_base(&bases, vm)?;
-
-            (metatype, base.to_owned(), bases)
-        };
-
-        let qualname = dict
-            .pop_item(identifier!(vm, __qualname__).as_object(), 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()
-            });
-        let mut attributes = dict.to_attributes(vm);
-
-        if let Some(f) = attributes.get_mut(identifier!(vm, __init_subclass__)) {
-            if f.class().is(vm.ctx.types.function_type) {
-                *f = PyClassMethod::from(f.clone()).into_pyobject(vm);
-            }
-        }
-
-        if let Some(f) = attributes.get_mut(identifier!(vm, __class_getitem__)) {
-            if f.class().is(vm.ctx.types.function_type) {
-                *f = PyClassMethod::from(f.clone()).into_pyobject(vm);
-            }
-        }
-
-        if let Some(current_frame) = vm.current_frame() {
-            let entry = attributes.entry(identifier!(vm, __module__));
-            if matches!(entry, Entry::Vacant(_)) {
-                let module_name = vm.unwrap_or_none(
-                    current_frame
-                        .globals
-                        .get_item_opt(identifier!(vm, __name__), vm)?,
-                );
-                entry.or_insert(module_name);
-            }
-        }
-
-        if attributes.get(identifier!(vm, __eq__)).is_some()
-            && attributes.get(identifier!(vm, __hash__)).is_none()
-        {
-            // if __eq__ exists but __hash__ doesn't, overwrite it with None so it doesn't inherit the default hash
-            // https://docs.python.org/3/reference/datamodel.html#object.__hash__
-            attributes.insert(identifier!(vm, __hash__), vm.ctx.none.clone().into());
-        }
-
-        // All *classes* should have a dict. Exceptions are *instances* of
-        // classes that define __slots__ and instances of built-in classes
-        // (with exceptions, e.g function)
-        let __dict__ = identifier!(vm, __dict__);
-        attributes.entry(__dict__).or_insert_with(|| {
-            vm.ctx
-                .new_static_getset(
-                    "__dict__",
-                    vm.ctx.types.type_type,
-                    subtype_get_dict,
-                    subtype_set_dict,
-                )
-                .into()
-        });
-
-        // TODO: Flags is currently initialized with HAS_DICT. Should be
-        // updated when __slots__ are supported (toggling the flag off if
-        // a class has __slots__ defined).
-        let heaptype_slots: Option<PyTupleTyped<PyStrRef>> =
-            if let Some(x) = attributes.get(identifier!(vm, __slots__)) {
-                Some(if x.to_owned().class().is(vm.ctx.types.str_type) {
-                    PyTupleTyped::<PyStrRef>::try_from_object(
-                        vm,
-                        vec![x.to_owned()].into_pytuple(vm).into(),
-                    )?
-                } else {
-                    let iter = x.to_owned().get_iter(vm)?;
-                    let elements = {
-                        let mut elements = Vec::new();
-                        while let PyIterReturn::Return(element) = iter.next(vm)? {
-                            elements.push(element);
-                        }
-                        elements
-                    };
-                    PyTupleTyped::<PyStrRef>::try_from_object(vm, elements.into_pytuple(vm).into())?
-                })
-            } else {
-                None
-            };
-
-        // FIXME: this is a temporary fix. multi bases with multiple slots will break object
-        let base_member_count = bases
-            .iter()
-            .map(|base| base.slots.member_count)
-            .max()
-            .unwrap();
-        let heaptype_member_count = heaptype_slots.as_ref().map(|x| x.len()).unwrap_or(0);
-        let member_count: usize = base_member_count + heaptype_member_count;
-
-        let flags = PyTypeFlags::heap_type_flags() | PyTypeFlags::HAS_DICT;
-        let (slots, heaptype_ext) = {
-            let slots = PyTypeSlots {
-                flags,
-                member_count,
-                ..PyTypeSlots::heap_default()
-            };
-            let heaptype_ext = HeapTypeExt {
-                name: PyRwLock::new(name),
-                qualname: PyRwLock::new(qualname),
-                slots: heaptype_slots.to_owned(),
-                sequence_methods: PySequenceMethods::default(),
-                mapping_methods: PyMappingMethods::default(),
-            };
-            (slots, heaptype_ext)
-        };
-
-        let typ = Self::new_heap_inner(
-            base,
-            bases,
-            attributes,
-            slots,
-            heaptype_ext,
-            metatype,
-            &vm.ctx,
-        )
-        .map_err(|e| vm.new_type_error(e))?;
-
-        if let Some(ref slots) = heaptype_slots {
-            let mut offset = base_member_count;
-            for member in slots.as_slice() {
-                let member_def = PyMemberDef {
-                    name: member.to_string(),
-                    kind: MemberKind::ObjectEx,
-                    getter: MemberGetter::Offset(offset),
-                    setter: MemberSetter::Offset(offset),
-                    doc: None,
-                };
-                let member_descriptor: PyRef<PyMemberDescriptor> =
-                    vm.ctx.new_pyref(PyMemberDescriptor {
-                        common: PyDescriptorOwned {
-                            typ: typ.clone(),
-                            name: vm.ctx.intern_str(member.as_str()),
-                            qualname: PyRwLock::new(None),
-                        },
-                        member: member_def,
-                    });
-
-                let attr_name = vm.ctx.intern_str(member.to_string());
-                if !typ.has_attr(attr_name) {
-                    typ.set_attr(attr_name, member_descriptor.into());
-                }
-
-                offset += 1;
-            }
-        }
-
-        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()));
-        };
-
-        // avoid deadlock
-        let attributes = typ
-            .attributes
-            .read()
-            .iter()
-            .filter_map(|(name, obj)| {
-                vm.get_method(obj.clone(), identifier!(vm, __set_name__))
-                    .map(|res| res.map(|meth| (obj.clone(), name.to_owned(), meth)))
-            })
-            .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 '{}'",
-                    obj.class().name(),
-                    name,
-                    typ.name()
-                ));
-                err.set___cause__(Some(e));
-                err
-            })?;
-        }
-
-        if let Some(init_subclass) = typ.get_super_attr(identifier!(vm, __init_subclass__)) {
-            let init_subclass = vm
-                .call_get_descriptor_specific(&init_subclass, None, Some(typ.clone().into()))
-                .unwrap_or(Ok(init_subclass))?;
-            init_subclass.call(kwargs, vm)?;
-        };
-
-        Ok(typ.into())
-    }
-}
-
-const SIGNATURE_END_MARKER: &str = ")\n--\n\n";
-fn get_signature(doc: &str) -> Option<&str> {
-    doc.find(SIGNATURE_END_MARKER).map(|index| &doc[..=index])
-}
-
-fn find_signature<'a>(name: &str, doc: &'a str) -> Option<&'a str> {
-    let name = name.rsplit('.').next().unwrap();
-    let doc = doc.strip_prefix(name)?;
-    doc.starts_with('(').then_some(doc)
-}
-
-pub(crate) fn get_text_signature_from_internal_doc<'a>(
-    name: &str,
-    internal_doc: &'a str,
-) -> Option<&'a str> {
-    find_signature(name, internal_doc).and_then(get_signature)
-}
-
-// _PyType_GetDocFromInternalDoc in CPython
-fn get_doc_from_internal_doc<'a>(name: &str, internal_doc: &'a str) -> &'a str {
-    // Similar to CPython's _PyType_DocWithoutSignature
-    // If the doc starts with the type name and a '(', it's a signature
-    if let Some(doc_without_sig) = find_signature(name, internal_doc) {
-        // Find where the signature ends
-        if let Some(sig_end_pos) = doc_without_sig.find(SIGNATURE_END_MARKER) {
-            let after_sig = &doc_without_sig[sig_end_pos + SIGNATURE_END_MARKER.len()..];
-            // Return the documentation after the signature, or empty string if none
-            return after_sig;
-        }
-    }
-    // If no signature found, return the whole doc
-    internal_doc
-}
-
-impl GetAttr for PyType {
-    fn getattro(zelf: &Py<Self>, name_str: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        #[cold]
-        fn attribute_error(
-            zelf: &Py<PyType>,
-            name: &str,
-            vm: &VirtualMachine,
-        ) -> PyBaseExceptionRef {
-            vm.new_attribute_error(format!(
-                "type object '{}' has no attribute '{}'",
-                zelf.slot_name(),
-                name,
-            ))
-        }
-
-        let Some(name) = vm.ctx.interned_str(name_str) else {
-            return Err(attribute_error(zelf, name_str.as_str(), vm));
-        };
-        vm_trace!("type.__getattribute__({:?}, {:?})", zelf, name);
-        let mcl = zelf.class();
-        let mcl_attr = mcl.get_attr(name);
-
-        if let Some(ref attr) = mcl_attr {
-            let attr_class = attr.class();
-            let has_descr_set = attr_class
-                .mro_find_map(|cls| cls.slots.descr_set.load())
-                .is_some();
-            if has_descr_set {
-                let descr_get = attr_class.mro_find_map(|cls| cls.slots.descr_get.load());
-                if let Some(descr_get) = descr_get {
-                    let mcl = mcl.to_owned().into();
-                    return descr_get(attr.clone(), Some(zelf.to_owned().into()), Some(mcl), vm);
-                }
-            }
-        }
-
-        let zelf_attr = zelf.get_attr(name);
-
-        if let Some(attr) = zelf_attr {
-            let descr_get = attr.class().mro_find_map(|cls| cls.slots.descr_get.load());
-            if let Some(descr_get) = descr_get {
-                descr_get(attr, None, Some(zelf.to_owned().into()), vm)
-            } else {
-                Ok(attr)
-            }
-        } 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))
-        }
-    }
-}
-
-#[pyclass]
-impl Py<PyType> {
-    #[pygetset(name = "__mro__")]
-    fn get_mro(&self) -> PyTuple {
-        let elements: Vec<PyObjectRef> = self.mro_map_collect(|x| x.as_object().to_owned());
-        PyTuple::new_unchecked(elements.into_boxed_slice())
-    }
-
-    #[pygetset]
-    fn __doc__(&self, vm: &VirtualMachine) -> PyResult {
-        // Similar to CPython's type_get_doc
-        // For non-heap types (static types), check if there's an internal doc
-        if !self.slots.flags.has_feature(PyTypeFlags::HEAPTYPE) {
-            if let Some(internal_doc) = self.slots.doc {
-                // Process internal doc, removing signature if present
-                let doc_str = get_doc_from_internal_doc(&self.name(), internal_doc);
-                return Ok(vm.ctx.new_str(doc_str).into());
-            }
-        }
-
-        // Check if there's a __doc__ in the type's dict
-        if let Some(doc_attr) = self.get_attr(vm.ctx.intern_str("__doc__")) {
-            // If it's a descriptor, call its __get__ method
-            let descr_get = doc_attr
-                .class()
-                .mro_find_map(|cls| cls.slots.descr_get.load());
-            if let Some(descr_get) = descr_get {
-                descr_get(doc_attr, None, Some(self.to_owned().into()), vm)
-            } else {
-                Ok(doc_attr)
-            }
-        } else {
-            Ok(vm.ctx.none())
-        }
-    }
-
-    #[pygetset(setter)]
-    fn set___doc__(&self, value: PySetterValue, vm: &VirtualMachine) -> PyResult<()> {
-        // Similar to CPython's type_set_doc
-        let value = value.ok_or_else(|| {
-            vm.new_type_error(format!(
-                "cannot delete '__doc__' attribute of type '{}'",
-                self.name()
-            ))
-        })?;
-
-        // Check if we can set this special type attribute
-        self.check_set_special_type_attr(&value, identifier!(vm, __doc__), vm)?;
-
-        // Set the __doc__ in the type's dict
-        self.attributes
-            .write()
-            .insert(identifier!(vm, __doc__), value);
-
-        Ok(())
-    }
-
-    #[pymethod]
-    fn __dir__(&self) -> PyList {
-        let attributes: Vec<PyObjectRef> = self
-            .get_attributes()
-            .into_iter()
-            .map(|(k, _)| k.to_object())
-            .collect();
-        PyList::from(attributes)
-    }
-
-    #[pymethod]
-    fn __instancecheck__(&self, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        // Use real_is_instance to avoid infinite recursion, matching CPython's behavior
-        obj.real_is_instance(self.as_object(), vm)
-    }
-
-    #[pymethod]
-    fn __subclasscheck__(&self, subclass: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        // Use real_is_subclass to avoid going through __subclasscheck__ recursion
-        // This matches CPython's type___subclasscheck___impl which calls _PyObject_RealIsSubclass
-        subclass.real_is_subclass(self.as_object(), vm)
-    }
-
-    #[pyclassmethod]
-    fn __subclasshook__(_args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.not_implemented()
-    }
-
-    #[pymethod]
-    fn mro(&self) -> Vec<PyObjectRef> {
-        self.mro_map_collect(|cls| cls.to_owned().into())
-    }
-}
-
-impl SetAttr for PyType {
-    fn setattro(
-        zelf: &Py<Self>,
-        attr_name: &Py<PyStr>,
-        value: PySetterValue,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        // TODO: pass PyRefExact instead of &str
-        let attr_name = vm.ctx.intern_str(attr_name.as_str());
-        if let Some(attr) = zelf.get_class_attr(attr_name) {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
-            if let Some(descriptor) = descr_set {
-                return descriptor(&attr, zelf.to_owned().into(), value, vm);
-            }
-        }
-        let assign = value.is_assign();
-
-        if let PySetterValue::Assign(value) = value {
-            zelf.attributes.write().insert(attr_name, value);
-        } else {
-            let prev_value = zelf.attributes.write().shift_remove(attr_name); // TODO: swap_remove applicable?
-            if prev_value.is_none() {
-                return Err(vm.new_attribute_error(format!(
-                    "type object '{}' has no attribute '{}'",
-                    zelf.name(),
-                    attr_name.as_str(),
-                )));
-            }
-        }
-        if attr_name.as_str().starts_with("__") && attr_name.as_str().ends_with("__") {
-            if assign {
-                zelf.update_slot::<true>(attr_name, &vm.ctx);
-            } else {
-                zelf.update_slot::<false>(attr_name, &vm.ctx);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Callable for PyType {
-    type Args = FuncArgs;
-    fn call(zelf: &Py<Self>, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        vm_trace!("type_call: {:?}", zelf);
-        let obj = call_slot_new(zelf.to_owned(), zelf.to_owned(), args.clone(), vm)?;
-
-        if (zelf.is(vm.ctx.types.type_type) && args.kwargs.is_empty()) || !obj.fast_isinstance(zelf)
-        {
-            return Ok(obj);
-        }
-
-        let init = obj.class().mro_find_map(|cls| cls.slots.init.load());
-        if let Some(init_method) = init {
-            init_method(obj.clone(), args, vm)?;
-        }
-        Ok(obj)
-    }
-}
-
-impl AsNumber for PyType {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            or: Some(|a, b, vm| or_(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-}
-
-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 repr = match module {
-            Some(module) if module != "builtins" => {
-                let name = zelf.name();
-                format!(
-                    "<class '{}.{}'>",
-                    module,
-                    zelf.__qualname__(vm)
-                        .downcast_ref::<PyStr>()
-                        .map(|n| n.as_str())
-                        .unwrap_or_else(|| &name)
-                )
-            }
-            _ => format!("<class '{}'>", zelf.slot_name()),
-        };
-        Ok(repr)
-    }
-}
-
-fn find_base_dict_descr(cls: &Py<PyType>, vm: &VirtualMachine) -> Option<PyObjectRef> {
-    cls.iter_base_chain().skip(1).find_map(|cls| {
-        // TODO: should actually be some translation of:
-        // cls.slot_dictoffset != 0 && !cls.flags.contains(HEAPTYPE)
-        if cls.is(vm.ctx.types.type_type) {
-            cls.get_attr(identifier!(vm, __dict__))
-        } else {
-            None
-        }
-    })
-}
-
-fn subtype_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    // TODO: obj.class().as_pyref() need to be supported
-    let ret = match find_base_dict_descr(obj.class(), vm) {
-        Some(descr) => vm.call_get_descriptor(&descr, obj).unwrap_or_else(|| {
-            Err(vm.new_type_error(format!(
-                "this __dict__ descriptor does not support '{}' objects",
-                descr.class()
-            )))
-        })?,
-        None => object::object_get_dict(obj, vm)?.into(),
-    };
-    Ok(ret)
-}
-
-fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-    let cls = obj.class();
-    match find_base_dict_descr(cls, vm) {
-        Some(descr) => {
-            let descr_set = descr
-                .class()
-                .mro_find_map(|cls| cls.slots.descr_set.load())
-                .ok_or_else(|| {
-                    vm.new_type_error(format!(
-                        "this __dict__ descriptor does not support '{}' objects",
-                        cls.name()
-                    ))
-                })?;
-            descr_set(&descr, obj, PySetterValue::Assign(value), vm)
-        }
-        None => {
-            object::object_set_dict(obj, value.try_into_value(vm)?, vm)?;
-            Ok(())
-        }
-    }
-}
-
-/*
- * The magical type type
- */
-
-pub(crate) fn init(ctx: &Context) {
-    PyType::extend_class(ctx, ctx.types.type_type);
-}
-
-pub(crate) fn call_slot_new(
-    typ: PyTypeRef,
-    subtype: PyTypeRef,
-    args: FuncArgs,
-    vm: &VirtualMachine,
-) -> PyResult {
-    let slot_new = typ
-        .deref()
-        .mro_find_map(|cls| cls.slots.new.load())
-        .expect("Should be able to find a new slot somewhere in the mro");
-    slot_new(subtype, args, vm)
-}
-
-pub(super) fn or_(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-    if !union_::is_unionable(zelf.clone(), vm) || !union_::is_unionable(other.clone(), vm) {
-        return vm.ctx.not_implemented();
-    }
-
-    let tuple = PyTuple::new_ref(vec![zelf, other], &vm.ctx);
-    union_::make_union(&tuple, vm)
-}
-
-fn take_next_base(bases: &mut [Vec<PyTypeRef>]) -> Option<PyTypeRef> {
-    for base in bases.iter() {
-        let head = base[0].clone();
-        if !bases.iter().any(|x| x[1..].iter().any(|x| x.is(&head))) {
-            // Remove from other heads.
-            for item in bases.iter_mut() {
-                if item[0].is(&head) {
-                    item.remove(0);
-                }
-            }
-
-            return Some(head);
-        }
-    }
-
-    None
-}
-
-fn linearise_mro(mut bases: Vec<Vec<PyTypeRef>>) -> Result<Vec<PyTypeRef>, String> {
-    vm_trace!("Linearise MRO: {:?}", bases);
-    // Python requires that the class direct bases are kept in the same order.
-    // This is called local precedence ordering.
-    // This means we must verify that for classes A(), B(A) we must reject C(A, B) even though this
-    // algorithm will allow the mro ordering of [C, B, A, object].
-    // To verify this, we make sure non of the direct bases are in the mro of bases after them.
-    for (i, base_mro) in bases.iter().enumerate() {
-        let base = &base_mro[0]; // MROs cannot be empty.
-        for later_mro in &bases[i + 1..] {
-            // 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(),
-                );
-            }
-        }
-    }
-
-    let mut result = vec![];
-    while !bases.is_empty() {
-        let head = take_next_base(&mut bases).ok_or_else(|| {
-            // Take the head class of each class here. Now that we have reached the problematic bases.
-            // Because this failed, we assume the lists cannot be empty.
-            format!(
-                "Cannot create a consistent method resolution order (MRO) for bases {}",
-                bases.iter().map(|x| x.first().unwrap()).format(", ")
-            )
-        })?;
-
-        result.push(head);
-
-        bases.retain(|x| !x.is_empty());
-    }
-    Ok(result)
-}
-
-fn calculate_meta_class(
-    metatype: PyTypeRef,
-    bases: &[PyTypeRef],
-    vm: &VirtualMachine,
-) -> PyResult<PyTypeRef> {
-    // = _PyType_CalculateMetaclass
-    let mut winner = metatype;
-    for base in bases {
-        let base_type = base.class();
-        if winner.fast_issubclass(base_type) {
-            continue;
-        } else if base_type.fast_issubclass(&winner) {
-            winner = base_type.to_owned();
-            continue;
-        }
-
-        return Err(vm.new_type_error(
-            "metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass \
-             of the metaclasses of all its bases",
-        ));
-    }
-    Ok(winner)
-}
-
-fn solid_base<'a>(typ: &'a Py<PyType>, vm: &VirtualMachine) -> &'a Py<PyType> {
-    let base = if let Some(base) = &typ.base {
-        solid_base(base, vm)
-    } else {
-        vm.ctx.types.object_type
-    };
-
-    // TODO: requires itemsize comparison too
-    if typ.__basicsize__() != base.__basicsize__() {
-        typ
-    } else {
-        base
-    }
-}
-
-fn best_base<'a>(bases: &'a [PyTypeRef], vm: &VirtualMachine) -> PyResult<&'a Py<PyType>> {
-    let mut base: Option<&Py<PyType>> = None;
-    let mut winner: Option<&Py<PyType>> = None;
-
-    for base_i in bases {
-        // if !base_i.fast_issubclass(vm.ctx.types.type_type) {
-        //     println!("base_i type : {}", base_i.name());
-        //     return Err(vm.new_type_error("best must be types".into()));
-        // }
-
-        if !base_i.slots.flags.has_feature(PyTypeFlags::BASETYPE) {
-            return Err(vm.new_type_error(format!(
-                "type '{}' is not an acceptable base type",
-                base_i.slot_name()
-            )));
-        }
-
-        let candidate = solid_base(base_i, vm);
-        if winner.is_none() {
-            winner = Some(candidate);
-            base = Some(base_i.deref());
-        } else if winner.unwrap().fast_issubclass(candidate) {
-            // Do nothing
-        } else if candidate.fast_issubclass(winner.unwrap()) {
-            winner = Some(candidate);
-            base = Some(base_i.deref());
-        } else {
-            return Err(vm.new_type_error("multiple bases have instance layout conflict"));
-        }
-    }
-
-    debug_assert!(base.is_some());
-    Ok(base.unwrap())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn map_ids(obj: Result<Vec<PyTypeRef>, String>) -> Result<Vec<usize>, String> {
-        Ok(obj?.into_iter().map(|x| x.get_id()).collect())
-    }
-
-    #[test]
-    fn test_linearise() {
-        let context = Context::genesis();
-        let object = context.types.object_type.to_owned();
-        let type_type = context.types.type_type.to_owned();
-
-        let a = PyType::new_heap(
-            "A",
-            vec![object.clone()],
-            PyAttributes::default(),
-            Default::default(),
-            type_type.clone(),
-            context,
-        )
-        .unwrap();
-        let b = PyType::new_heap(
-            "B",
-            vec![object.clone()],
-            PyAttributes::default(),
-            Default::default(),
-            type_type,
-            context,
-        )
-        .unwrap();
-
-        assert_eq!(
-            map_ids(linearise_mro(vec![
-                vec![object.clone()],
-                vec![object.clone()]
-            ])),
-            map_ids(Ok(vec![object.clone()]))
-        );
-        assert_eq!(
-            map_ids(linearise_mro(vec![
-                vec![a.clone(), object.clone()],
-                vec![b.clone(), object.clone()],
-            ])),
-            map_ids(Ok(vec![a, b, object]))
-        );
-    }
-}
diff --git a/vm/src/builtins/union.rs b/vm/src/builtins/union.rs
deleted file mode 100644
index c7abd634ef..0000000000
--- a/vm/src/builtins/union.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-use super::{genericalias, type_};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    atomic_func,
-    builtins::{PyFrozenSet, PyGenericAlias, PyStr, PyTuple, PyTupleRef, PyType},
-    class::PyClassImpl,
-    common::hash,
-    convert::{ToPyObject, ToPyResult},
-    function::PyComparisonValue,
-    protocol::{PyMappingMethods, PyNumberMethods},
-    types::{AsMapping, AsNumber, Comparable, GetAttr, Hashable, PyComparisonOp, Representable},
-};
-use std::fmt;
-use std::sync::LazyLock;
-
-const CLS_ATTRS: &[&str] = &["__module__"];
-
-#[pyclass(module = "types", name = "UnionType", traverse)]
-pub struct PyUnion {
-    args: PyTupleRef,
-    parameters: PyTupleRef,
-}
-
-impl fmt::Debug for PyUnion {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("UnionObject")
-    }
-}
-
-impl PyPayload for PyUnion {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.union_type
-    }
-}
-
-impl PyUnion {
-    pub fn new(args: PyTupleRef, vm: &VirtualMachine) -> Self {
-        let parameters = make_parameters(&args, vm);
-        Self { args, parameters }
-    }
-
-    /// Direct access to args field, matching CPython's _Py_union_args
-    #[inline]
-    pub const fn args(&self) -> &PyTupleRef {
-        &self.args
-    }
-
-    fn repr(&self, vm: &VirtualMachine) -> PyResult<String> {
-        fn repr_item(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<String> {
-            if obj.is(vm.ctx.types.none_type) {
-                return Ok("None".to_string());
-            }
-
-            if vm
-                .get_attribute_opt(obj.clone(), identifier!(vm, __origin__))?
-                .is_some()
-                && vm
-                    .get_attribute_opt(obj.clone(), identifier!(vm, __args__))?
-                    .is_some()
-            {
-                return Ok(obj.repr(vm)?.as_str().to_string());
-            }
-
-            match (
-                vm.get_attribute_opt(obj.clone(), identifier!(vm, __qualname__))?
-                    .and_then(|o| o.downcast_ref::<PyStr>().map(|n| n.as_str().to_string())),
-                vm.get_attribute_opt(obj.clone(), identifier!(vm, __module__))?
-                    .and_then(|o| o.downcast_ref::<PyStr>().map(|m| m.as_str().to_string())),
-            ) {
-                (None, _) | (_, None) => Ok(obj.repr(vm)?.as_str().to_string()),
-                (Some(qualname), Some(module)) => Ok(if module == "builtins" {
-                    qualname
-                } else {
-                    format!("{module}.{qualname}")
-                }),
-            }
-        }
-
-        Ok(self
-            .args
-            .iter()
-            .map(|o| repr_item(o.clone(), vm))
-            .collect::<PyResult<Vec<_>>>()?
-            .join(" | "))
-    }
-}
-
-#[pyclass(
-    flags(BASETYPE),
-    with(Hashable, Comparable, AsMapping, AsNumber, Representable)
-)]
-impl PyUnion {
-    #[pygetset]
-    fn __parameters__(&self) -> PyObjectRef {
-        self.parameters.clone().into()
-    }
-
-    #[pygetset]
-    fn __args__(&self) -> PyObjectRef {
-        self.args.clone().into()
-    }
-
-    #[pymethod]
-    fn __instancecheck__(
-        zelf: PyRef<Self>,
-        obj: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<bool> {
-        if zelf
-            .args
-            .iter()
-            .any(|x| x.class().is(vm.ctx.types.generic_alias_type))
-        {
-            Err(vm.new_type_error("isinstance() argument 2 cannot be a parameterized generic"))
-        } else {
-            obj.is_instance(zelf.__args__().as_object(), vm)
-        }
-    }
-
-    #[pymethod]
-    fn __subclasscheck__(
-        zelf: PyRef<Self>,
-        obj: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<bool> {
-        if zelf
-            .args
-            .iter()
-            .any(|x| x.class().is(vm.ctx.types.generic_alias_type))
-        {
-            Err(vm.new_type_error("issubclass() argument 2 cannot be a parameterized generic"))
-        } else {
-            obj.is_subclass(zelf.__args__().as_object(), vm)
-        }
-    }
-
-    #[pymethod(name = "__ror__")]
-    #[pymethod]
-    fn __or__(zelf: PyObjectRef, other: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef {
-        type_::or_(zelf, other, vm)
-    }
-
-    #[pyclassmethod]
-    fn __class_getitem__(
-        cls: crate::builtins::PyTypeRef,
-        args: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyGenericAlias {
-        PyGenericAlias::from_args(cls, args, vm)
-    }
-}
-
-pub fn is_unionable(obj: PyObjectRef, vm: &VirtualMachine) -> bool {
-    obj.class().is(vm.ctx.types.none_type)
-        || obj.payload_if_subclass::<PyType>(vm).is_some()
-        || obj.class().is(vm.ctx.types.generic_alias_type)
-        || obj.class().is(vm.ctx.types.union_type)
-}
-
-fn make_parameters(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
-    let parameters = genericalias::make_parameters(args, vm);
-    dedup_and_flatten_args(&parameters, vm)
-}
-
-fn flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
-    let mut total_args = 0;
-    for arg in args {
-        if let Some(pyref) = arg.downcast_ref::<PyUnion>() {
-            total_args += pyref.args.len();
-        } else {
-            total_args += 1;
-        };
-    }
-
-    let mut flattened_args = Vec::with_capacity(total_args);
-    for arg in args {
-        if let Some(pyref) = arg.downcast_ref::<PyUnion>() {
-            flattened_args.extend(pyref.args.iter().cloned());
-        } else if vm.is_none(arg) {
-            flattened_args.push(vm.ctx.types.none_type.to_owned().into());
-        } else {
-            flattened_args.push(arg.clone());
-        };
-    }
-
-    PyTuple::new_ref(flattened_args, &vm.ctx)
-}
-
-fn dedup_and_flatten_args(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
-    let args = flatten_args(args, vm);
-
-    let mut new_args: Vec<PyObjectRef> = Vec::with_capacity(args.len());
-    for arg in &*args {
-        if !new_args.iter().any(|param| {
-            param
-                .rich_compare_bool(arg, PyComparisonOp::Eq, vm)
-                .expect("types are always comparable")
-        }) {
-            new_args.push(arg.clone());
-        }
-    }
-
-    new_args.shrink_to_fit();
-
-    PyTuple::new_ref(new_args, &vm.ctx)
-}
-
-pub fn make_union(args: &Py<PyTuple>, vm: &VirtualMachine) -> PyObjectRef {
-    let args = dedup_and_flatten_args(args, vm);
-    match args.len() {
-        1 => args[0].to_owned(),
-        _ => PyUnion::new(args, vm).to_pyobject(vm),
-    }
-}
-
-impl PyUnion {
-    fn getitem(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let new_args = genericalias::subs_parameters(
-            zelf.to_owned().into(),
-            zelf.args.clone(),
-            zelf.parameters.clone(),
-            needle,
-            vm,
-        )?;
-        let mut res;
-        if new_args.is_empty() {
-            res = make_union(&new_args, vm);
-        } else {
-            res = new_args[0].to_owned();
-            for arg in new_args.iter().skip(1) {
-                res = vm._or(&res, arg)?;
-            }
-        }
-
-        Ok(res)
-    }
-}
-
-impl AsMapping for PyUnion {
-    fn as_mapping() -> &'static PyMappingMethods {
-        static AS_MAPPING: LazyLock<PyMappingMethods> = LazyLock::new(|| PyMappingMethods {
-            subscript: atomic_func!(|mapping, needle, vm| {
-                let zelf = PyUnion::mapping_downcast(mapping);
-                PyUnion::getitem(zelf.to_owned(), needle.to_owned(), vm)
-            }),
-            ..PyMappingMethods::NOT_IMPLEMENTED
-        });
-        &AS_MAPPING
-    }
-}
-
-impl AsNumber for PyUnion {
-    fn as_number() -> &'static PyNumberMethods {
-        static AS_NUMBER: PyNumberMethods = PyNumberMethods {
-            or: Some(|a, b, vm| PyUnion::__or__(a.to_owned(), b.to_owned(), vm).to_pyresult(vm)),
-            ..PyNumberMethods::NOT_IMPLEMENTED
-        };
-        &AS_NUMBER
-    }
-}
-
-impl Comparable for PyUnion {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyComparisonValue> {
-        op.eq_only(|| {
-            let other = class_or_notimplemented!(Self, other);
-            let a = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
-            let b = PyFrozenSet::from_iter(vm, other.args.into_iter().cloned())?;
-            Ok(PyComparisonValue::Implemented(
-                a.into_pyobject(vm).as_object().rich_compare_bool(
-                    b.into_pyobject(vm).as_object(),
-                    PyComparisonOp::Eq,
-                    vm,
-                )?,
-            ))
-        })
-    }
-}
-
-impl Hashable for PyUnion {
-    #[inline]
-    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<hash::PyHash> {
-        let set = PyFrozenSet::from_iter(vm, zelf.args.into_iter().cloned())?;
-        PyFrozenSet::hash(&set.into_ref(&vm.ctx), vm)
-    }
-}
-
-impl GetAttr for PyUnion {
-    fn getattro(zelf: &Py<Self>, attr: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        for &exc in CLS_ATTRS {
-            if *exc == attr.to_string() {
-                return zelf.as_object().generic_getattr(attr, vm);
-            }
-        }
-        zelf.as_object().get_attr(attr, vm)
-    }
-}
-
-impl Representable for PyUnion {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        zelf.repr(vm)
-    }
-}
-
-pub fn init(context: &Context) {
-    let union_type = &context.types.union_type;
-    PyUnion::extend_class(context, union_type);
-}
diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs
deleted file mode 100644
index 441cac9b3f..0000000000
--- a/vm/src/builtins/weakref.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-use super::{PyGenericAlias, PyType, PyTypeRef};
-use crate::common::{
-    atomic::{Ordering, Radium},
-    hash::{self, PyHash},
-};
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    class::PyClassImpl,
-    function::OptionalArg,
-    types::{Callable, Comparable, Constructor, Hashable, PyComparisonOp, Representable},
-};
-
-pub use crate::object::PyWeak;
-
-#[derive(FromArgs)]
-pub struct WeakNewArgs {
-    #[pyarg(positional)]
-    referent: PyObjectRef,
-    #[pyarg(positional, optional)]
-    callback: OptionalArg<PyObjectRef>,
-}
-
-impl PyPayload for PyWeak {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.weakref_type
-    }
-}
-
-impl Callable for PyWeak {
-    type Args = ();
-    #[inline]
-    fn call(zelf: &Py<Self>, _: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Ok(vm.unwrap_or_none(zelf.upgrade()))
-    }
-}
-
-impl Constructor for PyWeak {
-    type Args = WeakNewArgs;
-
-    fn py_new(
-        cls: PyTypeRef,
-        Self::Args { referent, callback }: Self::Args,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let weak = referent.downgrade_with_typ(callback.into_option(), cls, vm)?;
-        Ok(weak.into())
-    }
-}
-
-#[pyclass(
-    with(Callable, Hashable, Comparable, Constructor, Representable),
-    flags(BASETYPE)
-)]
-impl PyWeak {
-    #[pyclassmethod]
-    fn __class_getitem__(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
-        PyGenericAlias::from_args(cls, args, vm)
-    }
-}
-
-impl Hashable for PyWeak {
-    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash> {
-        let hash = match zelf.hash.load(Ordering::Relaxed) {
-            hash::SENTINEL => {
-                let obj = zelf
-                    .upgrade()
-                    .ok_or_else(|| vm.new_type_error("weak object has gone away"))?;
-                let hash = obj.hash(vm)?;
-                match Radium::compare_exchange(
-                    &zelf.hash,
-                    hash::SENTINEL,
-                    hash::fix_sentinel(hash),
-                    Ordering::Relaxed,
-                    Ordering::Relaxed,
-                ) {
-                    Ok(_) => hash,
-                    Err(prev_stored) => prev_stored,
-                }
-            }
-            hash => hash,
-        };
-        Ok(hash)
-    }
-}
-
-impl Comparable for PyWeak {
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<crate::function::PyComparisonValue> {
-        op.eq_only(|| {
-            let other = class_or_notimplemented!(Self, other);
-            let both = zelf.upgrade().and_then(|s| other.upgrade().map(|o| (s, o)));
-            let eq = match both {
-                Some((a, b)) => vm.bool_eq(&a, &b)?,
-                None => zelf.is(other),
-            };
-            Ok(eq.into())
-        })
-    }
-}
-
-impl Representable for PyWeak {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-        let id = zelf.get_id();
-        let repr = if let Some(o) = zelf.upgrade() {
-            format!(
-                "<weakref at {:#x}; to '{}' at {:#x}>",
-                id,
-                o.class().name(),
-                o.get_id(),
-            )
-        } else {
-            format!("<weakref at {id:#x}; dead>")
-        };
-        Ok(repr)
-    }
-}
-
-pub fn init(context: &Context) {
-    PyWeak::extend_class(context, context.types.weakref_type);
-}
diff --git a/vm/src/cformat.rs b/vm/src/cformat.rs
deleted file mode 100644
index feca96c833..0000000000
--- a/vm/src/cformat.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-//cspell:ignore bytesobject
-
-//! Implementation of Printf-Style string formatting
-//! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
-
-use crate::common::cformat::*;
-use crate::common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-use crate::{
-    AsObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine,
-    builtins::{
-        PyBaseExceptionRef, PyByteArray, PyBytes, PyFloat, PyInt, PyStr, try_f64_to_bigint, tuple,
-    },
-    function::ArgIntoFloat,
-    protocol::PyBuffer,
-    stdlib::builtins,
-};
-use itertools::Itertools;
-use num_traits::cast::ToPrimitive;
-
-fn spec_format_bytes(
-    vm: &VirtualMachine,
-    spec: &CFormatSpec,
-    obj: PyObjectRef,
-) -> PyResult<Vec<u8>> {
-    match &spec.format_type {
-        CFormatType::String(conversion) => match conversion {
-            // 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();
-                Ok(b)
-            }
-            CFormatConversion::Str | CFormatConversion::Bytes => {
-                if let Ok(buffer) = PyBuffer::try_from_borrowed_object(vm, &obj) {
-                    Ok(buffer.contiguous_or_collect(|bytes| spec.format_bytes(bytes)))
-                } else {
-                    let bytes = vm
-                        .get_special_method(&obj, identifier!(vm, __bytes__))?
-                        .ok_or_else(|| {
-                            vm.new_type_error(format!(
-                                "%b requires a bytes-like object, or an object that \
-                                    implements __bytes__, not '{}'",
-                                obj.class().name()
-                            ))
-                        })?
-                        .invoke((), vm)?;
-                    let bytes = PyBytes::try_from_borrowed_object(vm, &bytes)?;
-                    Ok(spec.format_bytes(bytes.as_bytes()))
-                }
-            }
-        },
-        CFormatType::Number(number_type) => match number_type {
-            CNumberType::DecimalD | CNumberType::DecimalI | CNumberType::DecimalU => {
-                match_class!(match &obj {
-                    ref i @ PyInt => {
-                        Ok(spec.format_number(i.as_bigint()).into_bytes())
-                    }
-                    ref f @ PyFloat => {
-                        Ok(spec
-                            .format_number(&try_f64_to_bigint(f.to_f64(), vm)?)
-                            .into_bytes())
-                    }
-                    obj => {
-                        if let Some(method) = vm.get_method(obj.clone(), identifier!(vm, __int__)) {
-                            let result = method?.call((), vm)?;
-                            if let Some(i) = result.payload::<PyInt>() {
-                                return Ok(spec.format_number(i.as_bigint()).into_bytes());
-                            }
-                        }
-                        Err(vm.new_type_error(format!(
-                            "%{} format: a number is required, not {}",
-                            spec.format_type.to_char(),
-                            obj.class().name()
-                        )))
-                    }
-                })
-            }
-            _ => {
-                if let Some(i) = obj.payload::<PyInt>() {
-                    Ok(spec.format_number(i.as_bigint()).into_bytes())
-                } else {
-                    Err(vm.new_type_error(format!(
-                        "%{} format: an integer is required, not {}",
-                        spec.format_type.to_char(),
-                        obj.class().name()
-                    )))
-                }
-            }
-        },
-        CFormatType::Float(_) => {
-            let class = obj.class().to_owned();
-            let value = ArgIntoFloat::try_from_object(vm, obj).map_err(|e| {
-                if e.fast_isinstance(vm.ctx.exceptions.type_error) {
-                    // formatfloat in bytesobject.c generates its own specific exception
-                    // text in this case, mirror it here.
-                    vm.new_type_error(format!("float argument required, not {}", class.name()))
-                } else {
-                    e
-                }
-            })?;
-            Ok(spec.format_float(value.into()).into_bytes())
-        }
-        CFormatType::Character(CCharacterType::Character) => {
-            if let Some(i) = obj.payload::<PyInt>() {
-                let ch = i
-                    .try_to_primitive::<u8>(vm)
-                    .map_err(|_| vm.new_overflow_error("%c arg not in range(256)"))?;
-                return Ok(spec.format_char(ch));
-            }
-            if let Some(b) = obj.payload::<PyBytes>() {
-                if b.len() == 1 {
-                    return Ok(spec.format_char(b.as_bytes()[0]));
-                }
-            } else if let Some(ba) = obj.payload::<PyByteArray>() {
-                let buf = ba.borrow_buf();
-                if buf.len() == 1 {
-                    return Ok(spec.format_char(buf[0]));
-                }
-            }
-            Err(vm.new_type_error("%c requires an integer in range(256) or a single byte"))
-        }
-    }
-}
-
-fn spec_format_string(
-    vm: &VirtualMachine,
-    spec: &CFormatSpec,
-    obj: PyObjectRef,
-    idx: usize,
-) -> PyResult<Wtf8Buf> {
-    match &spec.format_type {
-        CFormatType::String(conversion) => {
-            let result = match conversion {
-                CFormatConversion::Ascii => builtins::ascii(obj, vm)?.into(),
-                CFormatConversion::Str => obj.str(vm)?.as_wtf8().to_owned(),
-                CFormatConversion::Repr => obj.repr(vm)?.as_wtf8().to_owned(),
-                CFormatConversion::Bytes => {
-                    // idx is the position of the %, we want the position of the b
-                    return Err(vm.new_value_error(format!(
-                        "unsupported format character 'b' (0x62) at index {}",
-                        idx + 1
-                    )));
-                }
-            };
-            Ok(spec.format_string(result))
-        }
-        CFormatType::Number(number_type) => match number_type {
-            CNumberType::DecimalD | CNumberType::DecimalI | CNumberType::DecimalU => {
-                match_class!(match &obj {
-                    ref i @ PyInt => {
-                        Ok(spec.format_number(i.as_bigint()).into())
-                    }
-                    ref f @ PyFloat => {
-                        Ok(spec
-                            .format_number(&try_f64_to_bigint(f.to_f64(), vm)?)
-                            .into())
-                    }
-                    obj => {
-                        if let Some(method) = vm.get_method(obj.clone(), identifier!(vm, __int__)) {
-                            let result = method?.call((), vm)?;
-                            if let Some(i) = result.payload::<PyInt>() {
-                                return Ok(spec.format_number(i.as_bigint()).into());
-                            }
-                        }
-                        Err(vm.new_type_error(format!(
-                            "%{} format: a number is required, not {}",
-                            spec.format_type.to_char(),
-                            obj.class().name()
-                        )))
-                    }
-                })
-            }
-            _ => {
-                if let Some(i) = obj.payload::<PyInt>() {
-                    Ok(spec.format_number(i.as_bigint()).into())
-                } else {
-                    Err(vm.new_type_error(format!(
-                        "%{} format: an integer is required, not {}",
-                        spec.format_type.to_char(),
-                        obj.class().name()
-                    )))
-                }
-            }
-        },
-        CFormatType::Float(_) => {
-            let value = ArgIntoFloat::try_from_object(vm, obj)?;
-            Ok(spec.format_float(value.into()).into())
-        }
-        CFormatType::Character(CCharacterType::Character) => {
-            if let Some(i) = obj.payload::<PyInt>() {
-                let ch = i
-                    .as_bigint()
-                    .to_u32()
-                    .and_then(CodePoint::from_u32)
-                    .ok_or_else(|| vm.new_overflow_error("%c arg not in range(0x110000)"))?;
-                return Ok(spec.format_char(ch));
-            }
-            if let Some(s) = obj.payload::<PyStr>() {
-                if let Ok(ch) = s.as_wtf8().code_points().exactly_one() {
-                    return Ok(spec.format_char(ch));
-                }
-            }
-            Err(vm.new_type_error("%c requires int or char"))
-        }
-    }
-}
-
-fn try_update_quantity_from_element(
-    vm: &VirtualMachine,
-    element: Option<&PyObjectRef>,
-) -> PyResult<CFormatQuantity> {
-    match element {
-        Some(width_obj) => {
-            if let Some(i) = width_obj.payload::<PyInt>() {
-                let i = i.try_to_primitive::<i32>(vm)?.unsigned_abs();
-                Ok(CFormatQuantity::Amount(i as usize))
-            } else {
-                Err(vm.new_type_error("* wants int"))
-            }
-        }
-        None => Err(vm.new_type_error("not enough arguments for format string")),
-    }
-}
-
-fn try_conversion_flag_from_tuple(
-    vm: &VirtualMachine,
-    element: Option<&PyObjectRef>,
-) -> PyResult<CConversionFlags> {
-    match element {
-        Some(width_obj) => {
-            if let Some(i) = width_obj.payload::<PyInt>() {
-                let i = i.try_to_primitive::<i32>(vm)?;
-                let flags = if i < 0 {
-                    CConversionFlags::LEFT_ADJUST
-                } else {
-                    CConversionFlags::from_bits(0).unwrap()
-                };
-                Ok(flags)
-            } else {
-                Err(vm.new_type_error("* wants int"))
-            }
-        }
-        None => Err(vm.new_type_error("not enough arguments for format string")),
-    }
-}
-
-fn try_update_quantity_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
-    vm: &VirtualMachine,
-    elements: &mut I,
-    q: &mut Option<CFormatQuantity>,
-    f: &mut CConversionFlags,
-) -> PyResult<()> {
-    let Some(CFormatQuantity::FromValuesTuple) = q else {
-        return Ok(());
-    };
-    let element = elements.next();
-    f.insert(try_conversion_flag_from_tuple(vm, element)?);
-    let quantity = try_update_quantity_from_element(vm, element)?;
-    *q = Some(quantity);
-    Ok(())
-}
-
-fn try_update_precision_from_tuple<'a, I: Iterator<Item = &'a PyObjectRef>>(
-    vm: &VirtualMachine,
-    elements: &mut I,
-    p: &mut Option<CFormatPrecision>,
-) -> PyResult<()> {
-    let Some(CFormatPrecision::Quantity(CFormatQuantity::FromValuesTuple)) = p else {
-        return Ok(());
-    };
-    let quantity = try_update_quantity_from_element(vm, elements.next())?;
-    *p = Some(CFormatPrecision::Quantity(quantity));
-    Ok(())
-}
-
-fn specifier_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
-    vm.new_type_error("format requires a mapping")
-}
-
-pub(crate) fn cformat_bytes(
-    vm: &VirtualMachine,
-    format_string: &[u8],
-    values_obj: PyObjectRef,
-) -> PyResult<Vec<u8>> {
-    let mut format = CFormatBytes::parse_from_bytes(format_string)
-        .map_err(|err| vm.new_value_error(err.to_string()))?;
-    let (num_specifiers, mapping_required) = format
-        .check_specifiers()
-        .ok_or_else(|| specifier_error(vm))?;
-
-    let mut result = vec![];
-
-    let is_mapping = values_obj.class().has_attr(identifier!(vm, __getitem__))
-        && !values_obj.fast_isinstance(vm.ctx.types.tuple_type)
-        && !values_obj.fast_isinstance(vm.ctx.types.bytes_type)
-        && !values_obj.fast_isinstance(vm.ctx.types.bytearray_type);
-
-    if num_specifiers == 0 {
-        // literal only
-        return if is_mapping
-            || values_obj
-                .payload::<tuple::PyTuple>()
-                .is_some_and(|e| e.is_empty())
-        {
-            for (_, part) in format.iter_mut() {
-                match part {
-                    CFormatPart::Literal(literal) => result.append(literal),
-                    CFormatPart::Spec(_) => unreachable!(),
-                }
-            }
-            Ok(result)
-        } else {
-            Err(vm.new_type_error("not all arguments converted during bytes formatting"))
-        };
-    }
-
-    if mapping_required {
-        // dict
-        return if is_mapping {
-            for (_, part) in format {
-                match part {
-                    CFormatPart::Literal(literal) => result.extend(literal),
-                    CFormatPart::Spec(CFormatSpecKeyed { mapping_key, spec }) => {
-                        let key = mapping_key.unwrap();
-                        let value = values_obj.get_item(&key, vm)?;
-                        let part_result = spec_format_bytes(vm, &spec, value)?;
-                        result.extend(part_result);
-                    }
-                }
-            }
-            Ok(result)
-        } else {
-            Err(vm.new_type_error("format requires a mapping"))
-        };
-    }
-
-    // tuple
-    let values = if let Some(tup) = values_obj.payload_if_subclass::<tuple::PyTuple>(vm) {
-        tup.as_slice()
-    } else {
-        std::slice::from_ref(&values_obj)
-    };
-    let mut value_iter = values.iter();
-
-    for (_, part) in format {
-        match part {
-            CFormatPart::Literal(literal) => result.extend(literal),
-            CFormatPart::Spec(CFormatSpecKeyed { mut spec, .. }) => {
-                try_update_quantity_from_tuple(
-                    vm,
-                    &mut value_iter,
-                    &mut spec.min_field_width,
-                    &mut spec.flags,
-                )?;
-                try_update_precision_from_tuple(vm, &mut value_iter, &mut spec.precision)?;
-
-                let value = match value_iter.next() {
-                    Some(obj) => Ok(obj.clone()),
-                    None => Err(vm.new_type_error("not enough arguments for format string")),
-                }?;
-                let part_result = spec_format_bytes(vm, &spec, value)?;
-                result.extend(part_result);
-            }
-        }
-    }
-
-    // check that all arguments were converted
-    if value_iter.next().is_some() && !is_mapping {
-        Err(vm.new_type_error("not all arguments converted during bytes formatting"))
-    } else {
-        Ok(result)
-    }
-}
-
-pub(crate) fn cformat_string(
-    vm: &VirtualMachine,
-    format_string: &Wtf8,
-    values_obj: PyObjectRef,
-) -> PyResult<Wtf8Buf> {
-    let format = CFormatWtf8::parse_from_wtf8(format_string)
-        .map_err(|err| vm.new_value_error(err.to_string()))?;
-    let (num_specifiers, mapping_required) = format
-        .check_specifiers()
-        .ok_or_else(|| specifier_error(vm))?;
-
-    let mut result = Wtf8Buf::new();
-
-    let is_mapping = values_obj.class().has_attr(identifier!(vm, __getitem__))
-        && !values_obj.fast_isinstance(vm.ctx.types.tuple_type)
-        && !values_obj.fast_isinstance(vm.ctx.types.str_type);
-
-    if num_specifiers == 0 {
-        // literal only
-        return if is_mapping
-            || values_obj
-                .payload::<tuple::PyTuple>()
-                .is_some_and(|e| e.is_empty())
-        {
-            for (_, part) in format.iter() {
-                match part {
-                    CFormatPart::Literal(literal) => result.push_wtf8(literal),
-                    CFormatPart::Spec(_) => unreachable!(),
-                }
-            }
-            Ok(result)
-        } else {
-            Err(vm.new_type_error("not all arguments converted during string formatting"))
-        };
-    }
-
-    if mapping_required {
-        // dict
-        return if is_mapping {
-            for (idx, part) in format {
-                match part {
-                    CFormatPart::Literal(literal) => result.push_wtf8(&literal),
-                    CFormatPart::Spec(CFormatSpecKeyed { mapping_key, spec }) => {
-                        let value = values_obj.get_item(&mapping_key.unwrap(), vm)?;
-                        let part_result = spec_format_string(vm, &spec, value, idx)?;
-                        result.push_wtf8(&part_result);
-                    }
-                }
-            }
-            Ok(result)
-        } else {
-            Err(vm.new_type_error("format requires a mapping"))
-        };
-    }
-
-    // tuple
-    let values = if let Some(tup) = values_obj.payload_if_subclass::<tuple::PyTuple>(vm) {
-        tup.as_slice()
-    } else {
-        std::slice::from_ref(&values_obj)
-    };
-    let mut value_iter = values.iter();
-
-    for (idx, part) in format {
-        match part {
-            CFormatPart::Literal(literal) => result.push_wtf8(&literal),
-            CFormatPart::Spec(CFormatSpecKeyed { mut spec, .. }) => {
-                try_update_quantity_from_tuple(
-                    vm,
-                    &mut value_iter,
-                    &mut spec.min_field_width,
-                    &mut spec.flags,
-                )?;
-                try_update_precision_from_tuple(vm, &mut value_iter, &mut spec.precision)?;
-
-                let value = match value_iter.next() {
-                    Some(obj) => Ok(obj.clone()),
-                    None => Err(vm.new_type_error("not enough arguments for format string")),
-                }?;
-                let part_result = spec_format_string(vm, &spec, value, idx)?;
-                result.push_wtf8(&part_result);
-            }
-        }
-    }
-
-    // check that all arguments were converted
-    if value_iter.next().is_some() && !is_mapping {
-        Err(vm.new_type_error("not all arguments converted during string formatting"))
-    } else {
-        Ok(result)
-    }
-}
diff --git a/vm/src/class.rs b/vm/src/class.rs
deleted file mode 100644
index f977f07ca7..0000000000
--- a/vm/src/class.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-//! Utilities to define a new Python class
-
-use crate::{
-    builtins::{PyBaseObject, PyType, PyTypeRef},
-    function::PyMethodDef,
-    identifier,
-    object::Py,
-    types::{PyTypeFlags, PyTypeSlots, hash_not_implemented},
-    vm::Context,
-};
-use rustpython_common::static_cell;
-
-pub trait StaticType {
-    // Ideally, saving PyType is better than PyTypeRef
-    fn static_cell() -> &'static static_cell::StaticCell<PyTypeRef>;
-    #[inline]
-    fn static_metaclass() -> &'static Py<PyType> {
-        PyType::static_type()
-    }
-    #[inline]
-    fn static_baseclass() -> &'static Py<PyType> {
-        PyBaseObject::static_type()
-    }
-    #[inline]
-    fn static_type() -> &'static Py<PyType> {
-        #[cold]
-        fn fail() -> ! {
-            panic!(
-                "static type has not been initialized. e.g. the native types defined in different module may be used before importing library."
-            );
-        }
-        Self::static_cell().get().unwrap_or_else(|| fail())
-    }
-    fn init_manually(typ: PyTypeRef) -> &'static Py<PyType> {
-        let cell = Self::static_cell();
-        cell.set(typ)
-            .unwrap_or_else(|_| panic!("double initialization from init_manually"));
-        cell.get().unwrap()
-    }
-    fn init_builtin_type() -> &'static Py<PyType>
-    where
-        Self: PyClassImpl,
-    {
-        let typ = Self::create_static_type();
-        let cell = Self::static_cell();
-        cell.set(typ)
-            .unwrap_or_else(|_| panic!("double initialization of {}", Self::NAME));
-        cell.get().unwrap()
-    }
-    fn create_static_type() -> PyTypeRef
-    where
-        Self: PyClassImpl,
-    {
-        PyType::new_static(
-            Self::static_baseclass().to_owned(),
-            Default::default(),
-            Self::make_slots(),
-            Self::static_metaclass().to_owned(),
-        )
-        .unwrap()
-    }
-}
-
-pub trait PyClassDef {
-    const NAME: &'static str;
-    const MODULE_NAME: Option<&'static str>;
-    const TP_NAME: &'static str;
-    const DOC: Option<&'static str> = None;
-    const BASICSIZE: usize;
-    const UNHASHABLE: bool = false;
-
-    // due to restriction of rust trait system, object.__base__ is None
-    // but PyBaseObject::Base will be PyBaseObject.
-    type Base: PyClassDef;
-}
-
-pub trait PyClassImpl: PyClassDef {
-    const TP_FLAGS: PyTypeFlags = PyTypeFlags::DEFAULT;
-
-    fn extend_class(ctx: &Context, class: &'static Py<PyType>)
-    where
-        Self: Sized,
-    {
-        #[cfg(debug_assertions)]
-        {
-            assert!(class.slots.flags.is_created_with_flags());
-        }
-
-        let _ = ctx.intern_str(Self::NAME); // intern type name
-
-        if Self::TP_FLAGS.has_feature(PyTypeFlags::HAS_DICT) {
-            let __dict__ = identifier!(ctx, __dict__);
-            class.set_attr(
-                __dict__,
-                ctx.new_static_getset(
-                    "__dict__",
-                    class,
-                    crate::builtins::object::object_get_dict,
-                    crate::builtins::object::object_set_dict,
-                )
-                .into(),
-            );
-        }
-        Self::impl_extend_class(ctx, class);
-        if let Some(doc) = Self::DOC {
-            // Only set __doc__ if it doesn't already exist (e.g., as a member descriptor)
-            // This matches CPython's behavior in type_dict_set_doc
-            let doc_attr_name = identifier!(ctx, __doc__);
-            if class.attributes.read().get(doc_attr_name).is_none() {
-                class.set_attr(doc_attr_name, ctx.new_str(doc).into());
-            }
-        }
-        if let Some(module_name) = Self::MODULE_NAME {
-            class.set_attr(
-                identifier!(ctx, __module__),
-                ctx.new_str(module_name).into(),
-            );
-        }
-
-        if class.slots.new.load().is_some() {
-            let bound_new = Context::genesis().slot_new_wrapper.build_bound_method(
-                ctx,
-                class.to_owned().into(),
-                class,
-            );
-            class.set_attr(identifier!(ctx, __new__), bound_new.into());
-        }
-
-        if class.slots.hash.load().map_or(0, |h| h as usize) == hash_not_implemented as usize {
-            class.set_attr(ctx.names.__hash__, ctx.none.clone().into());
-        }
-
-        class.extend_methods(class.slots.methods, ctx);
-    }
-
-    fn make_class(ctx: &Context) -> PyTypeRef
-    where
-        Self: StaticType + Sized,
-    {
-        (*Self::static_cell().get_or_init(|| {
-            let typ = Self::create_static_type();
-            Self::extend_class(ctx, unsafe {
-                // typ will be saved in static_cell
-                let r: &Py<PyType> = &typ;
-                let r: &'static Py<PyType> = std::mem::transmute(r);
-                r
-            });
-            typ
-        }))
-        .to_owned()
-    }
-
-    fn impl_extend_class(ctx: &Context, class: &'static Py<PyType>);
-    const METHOD_DEFS: &'static [PyMethodDef];
-    fn extend_slots(slots: &mut PyTypeSlots);
-
-    fn make_slots() -> PyTypeSlots {
-        let mut slots = PyTypeSlots {
-            flags: Self::TP_FLAGS,
-            name: Self::TP_NAME,
-            basicsize: Self::BASICSIZE,
-            doc: Self::DOC,
-            methods: Self::METHOD_DEFS,
-            ..Default::default()
-        };
-
-        if Self::UNHASHABLE {
-            slots.hash.store(Some(hash_not_implemented));
-        }
-
-        Self::extend_slots(&mut slots);
-        slots
-    }
-}
diff --git a/vm/src/codecs.rs b/vm/src/codecs.rs
deleted file mode 100644
index b31222cfee..0000000000
--- a/vm/src/codecs.rs
+++ /dev/null
@@ -1,1165 +0,0 @@
-use rustpython_common::{
-    borrow::BorrowedValue,
-    encodings::{
-        CodecContext, DecodeContext, DecodeErrorHandler, EncodeContext, EncodeErrorHandler,
-        EncodeReplace, StrBuffer, StrSize, errors,
-    },
-    str::StrKind,
-    wtf8::{CodePoint, Wtf8, Wtf8Buf},
-};
-
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject,
-    TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef},
-    common::{ascii, lock::PyRwLock},
-    convert::ToPyObject,
-    function::{ArgBytesLike, PyMethodDef},
-};
-use once_cell::unsync::OnceCell;
-use std::{
-    borrow::Cow,
-    collections::HashMap,
-    ops::{self, Range},
-};
-
-pub struct CodecsRegistry {
-    inner: PyRwLock<RegistryInner>,
-}
-
-struct RegistryInner {
-    search_path: Vec<PyObjectRef>,
-    search_cache: HashMap<String, PyCodec>,
-    errors: HashMap<String, PyObjectRef>,
-}
-
-pub const DEFAULT_ENCODING: &str = "utf-8";
-
-#[derive(Clone)]
-#[repr(transparent)]
-pub struct PyCodec(PyTupleRef);
-impl PyCodec {
-    #[inline]
-    pub fn from_tuple(tuple: PyTupleRef) -> Result<Self, PyTupleRef> {
-        if tuple.len() == 4 {
-            Ok(Self(tuple))
-        } else {
-            Err(tuple)
-        }
-    }
-    #[inline]
-    pub fn into_tuple(self) -> PyTupleRef {
-        self.0
-    }
-    #[inline]
-    pub const fn as_tuple(&self) -> &PyTupleRef {
-        &self.0
-    }
-
-    #[inline]
-    pub fn get_encode_func(&self) -> &PyObject {
-        &self.0[0]
-    }
-    #[inline]
-    pub fn get_decode_func(&self) -> &PyObject {
-        &self.0[1]
-    }
-
-    pub fn is_text_codec(&self, vm: &VirtualMachine) -> PyResult<bool> {
-        let is_text = vm.get_attribute_opt(self.0.clone().into(), "_is_text_encoding")?;
-        is_text.map_or(Ok(true), |is_text| is_text.try_to_bool(vm))
-    }
-
-    pub fn encode(
-        &self,
-        obj: PyObjectRef,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let args = match errors {
-            Some(errors) => vec![obj, errors.into()],
-            None => vec![obj],
-        };
-        let res = self.get_encode_func().call(args, vm)?;
-        let res = res
-            .downcast::<PyTuple>()
-            .ok()
-            .filter(|tuple| tuple.len() == 2)
-            .ok_or_else(|| vm.new_type_error("encoder must return a tuple (object, integer)"))?;
-        // we don't actually care about the integer
-        Ok(res[0].clone())
-    }
-
-    pub fn decode(
-        &self,
-        obj: PyObjectRef,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let args = match errors {
-            Some(errors) => vec![obj, errors.into()],
-            None => vec![obj],
-        };
-        let res = self.get_decode_func().call(args, vm)?;
-        let res = res
-            .downcast::<PyTuple>()
-            .ok()
-            .filter(|tuple| tuple.len() == 2)
-            .ok_or_else(|| vm.new_type_error("decoder must return a tuple (object,integer)"))?;
-        // we don't actually care about the integer
-        Ok(res[0].clone())
-    }
-
-    pub fn get_incremental_encoder(
-        &self,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let args = match errors {
-            Some(e) => vec![e.into()],
-            None => vec![],
-        };
-        vm.call_method(self.0.as_object(), "incrementalencoder", args)
-    }
-
-    pub fn get_incremental_decoder(
-        &self,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let args = match errors {
-            Some(e) => vec![e.into()],
-            None => vec![],
-        };
-        vm.call_method(self.0.as_object(), "incrementaldecoder", args)
-    }
-}
-
-impl TryFromObject for PyCodec {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        obj.downcast::<PyTuple>()
-            .ok()
-            .and_then(|tuple| Self::from_tuple(tuple).ok())
-            .ok_or_else(|| vm.new_type_error("codec search functions must return 4-tuples"))
-    }
-}
-
-impl ToPyObject for PyCodec {
-    #[inline]
-    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        self.0.into()
-    }
-}
-
-impl CodecsRegistry {
-    pub(crate) fn new(ctx: &Context) -> Self {
-        ::rustpython_vm::common::static_cell! {
-            static METHODS: Box<[PyMethodDef]>;
-        }
-
-        let methods = METHODS.get_or_init(|| {
-            crate::define_methods![
-                "strict_errors" => strict_errors as EMPTY,
-                "ignore_errors" => ignore_errors as EMPTY,
-                "replace_errors" => replace_errors as EMPTY,
-                "xmlcharrefreplace_errors" => xmlcharrefreplace_errors as EMPTY,
-                "backslashreplace_errors" => backslashreplace_errors as EMPTY,
-                "namereplace_errors" => namereplace_errors as EMPTY,
-                "surrogatepass_errors" => surrogatepass_errors as EMPTY,
-                "surrogateescape_errors" => surrogateescape_errors as EMPTY
-            ]
-            .into_boxed_slice()
-        });
-
-        let errors = [
-            ("strict", methods[0].build_function(ctx)),
-            ("ignore", methods[1].build_function(ctx)),
-            ("replace", methods[2].build_function(ctx)),
-            ("xmlcharrefreplace", methods[3].build_function(ctx)),
-            ("backslashreplace", methods[4].build_function(ctx)),
-            ("namereplace", methods[5].build_function(ctx)),
-            ("surrogatepass", methods[6].build_function(ctx)),
-            ("surrogateescape", methods[7].build_function(ctx)),
-        ];
-        let errors = errors
-            .into_iter()
-            .map(|(name, f)| (name.to_owned(), f.into()))
-            .collect();
-        let inner = RegistryInner {
-            search_path: Vec::new(),
-            search_cache: HashMap::new(),
-            errors,
-        };
-        Self {
-            inner: PyRwLock::new(inner),
-        }
-    }
-
-    pub fn register(&self, search_function: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        if !search_function.is_callable() {
-            return Err(vm.new_type_error("argument must be callable"));
-        }
-        self.inner.write().search_path.push(search_function);
-        Ok(())
-    }
-
-    pub fn unregister(&self, search_function: PyObjectRef) -> PyResult<()> {
-        let mut inner = self.inner.write();
-        // Do nothing if search_path is not created yet or was cleared.
-        if inner.search_path.is_empty() {
-            return Ok(());
-        }
-        for (i, item) in inner.search_path.iter().enumerate() {
-            if item.get_id() == search_function.get_id() {
-                if !inner.search_cache.is_empty() {
-                    inner.search_cache.clear();
-                }
-                inner.search_path.remove(i);
-                return Ok(());
-            }
-        }
-        Ok(())
-    }
-
-    pub(crate) fn register_manual(&self, name: &str, codec: PyCodec) -> PyResult<()> {
-        self.inner
-            .write()
-            .search_cache
-            .insert(name.to_owned(), codec);
-        Ok(())
-    }
-
-    pub fn lookup(&self, encoding: &str, vm: &VirtualMachine) -> PyResult<PyCodec> {
-        let encoding = normalize_encoding_name(encoding);
-        let search_path = {
-            let inner = self.inner.read();
-            if let Some(codec) = inner.search_cache.get(encoding.as_ref()) {
-                // hit cache
-                return Ok(codec.clone());
-            }
-            inner.search_path.clone()
-        };
-        let encoding = PyStr::from(encoding.into_owned()).into_ref(&vm.ctx);
-        for func in search_path {
-            let res = func.call((encoding.clone(),), vm)?;
-            let res: Option<PyCodec> = res.try_into_value(vm)?;
-            if let Some(codec) = res {
-                let mut inner = self.inner.write();
-                // someone might have raced us to this, so use theirs
-                let codec = inner
-                    .search_cache
-                    .entry(encoding.as_str().to_owned())
-                    .or_insert(codec);
-                return Ok(codec.clone());
-            }
-        }
-        Err(vm.new_lookup_error(format!("unknown encoding: {encoding}")))
-    }
-
-    fn _lookup_text_encoding(
-        &self,
-        encoding: &str,
-        generic_func: &str,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyCodec> {
-        let codec = self.lookup(encoding, vm)?;
-        if codec.is_text_codec(vm)? {
-            Ok(codec)
-        } else {
-            Err(vm.new_lookup_error(format!(
-                "'{encoding}' is not a text encoding; use {generic_func} to handle arbitrary codecs"
-            )))
-        }
-    }
-
-    pub fn forget(&self, encoding: &str) -> Option<PyCodec> {
-        let encoding = normalize_encoding_name(encoding);
-        self.inner.write().search_cache.remove(encoding.as_ref())
-    }
-
-    pub fn encode(
-        &self,
-        obj: PyObjectRef,
-        encoding: &str,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let codec = self.lookup(encoding, vm)?;
-        codec.encode(obj, errors, vm)
-    }
-
-    pub fn decode(
-        &self,
-        obj: PyObjectRef,
-        encoding: &str,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let codec = self.lookup(encoding, vm)?;
-        codec.decode(obj, errors, vm)
-    }
-
-    pub fn encode_text(
-        &self,
-        obj: PyStrRef,
-        encoding: &str,
-        errors: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyBytesRef> {
-        let codec = self._lookup_text_encoding(encoding, "codecs.encode()", vm)?;
-        codec
-            .encode(obj.into(), errors, vm)?
-            .downcast()
-            .map_err(|obj| {
-                vm.new_type_error(format!(
-                    "'{}' encoder returned '{}' instead of 'bytes'; use codecs.encode() to \
-                     encode arbitrary types",
-                    encoding,
-                    obj.class().name(),
-                ))
-            })
-    }
-
-    pub fn decode_text(
-        &self,
-        obj: PyObjectRef,
-        encoding: &str,
-        errors: Option<PyStrRef>,
-        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(),
-            ))
-        })
-    }
-
-    pub fn register_error(&self, name: String, handler: PyObjectRef) -> Option<PyObjectRef> {
-        self.inner.write().errors.insert(name, handler)
-    }
-
-    pub fn lookup_error_opt(&self, name: &str) -> Option<PyObjectRef> {
-        self.inner.read().errors.get(name).cloned()
-    }
-
-    pub fn lookup_error(&self, name: &str, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        self.lookup_error_opt(name)
-            .ok_or_else(|| vm.new_lookup_error(format!("unknown error handler name '{name}'")))
-    }
-}
-
-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();
-            }
-        }
-        String::from_utf8(out).unwrap().into()
-    } else {
-        encoding.into()
-    }
-}
-
-#[derive(Eq, PartialEq)]
-enum StandardEncoding {
-    Utf8,
-    Utf16Be,
-    Utf16Le,
-    Utf32Be,
-    Utf32Le,
-}
-
-impl StandardEncoding {
-    #[cfg(target_endian = "little")]
-    const UTF_16_NE: Self = Self::Utf16Le;
-    #[cfg(target_endian = "big")]
-    const UTF_16_NE: Self = Self::Utf16Be;
-
-    #[cfg(target_endian = "little")]
-    const UTF_32_NE: Self = Self::Utf32Le;
-    #[cfg(target_endian = "big")]
-    const UTF_32_NE: Self = Self::Utf32Be;
-
-    fn parse(encoding: &str) -> Option<Self> {
-        if let Some(encoding) = encoding.to_lowercase().strip_prefix("utf") {
-            let encoding = encoding
-                .strip_prefix(|c| ['-', '_'].contains(&c))
-                .unwrap_or(encoding);
-            if encoding == "8" {
-                Some(Self::Utf8)
-            } else if let Some(encoding) = encoding.strip_prefix("16") {
-                if encoding.is_empty() {
-                    return Some(Self::UTF_16_NE);
-                }
-                let encoding = encoding.strip_prefix(['-', '_']).unwrap_or(encoding);
-                match encoding {
-                    "be" => Some(Self::Utf16Be),
-                    "le" => Some(Self::Utf16Le),
-                    _ => None,
-                }
-            } else if let Some(encoding) = encoding.strip_prefix("32") {
-                if encoding.is_empty() {
-                    return Some(Self::UTF_32_NE);
-                }
-                let encoding = encoding.strip_prefix(['-', '_']).unwrap_or(encoding);
-                match encoding {
-                    "be" => Some(Self::Utf32Be),
-                    "le" => Some(Self::Utf32Le),
-                    _ => None,
-                }
-            } else {
-                None
-            }
-        } else if encoding == "CP_UTF8" {
-            Some(Self::Utf8)
-        } else {
-            None
-        }
-    }
-}
-
-struct SurrogatePass;
-
-impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for SurrogatePass {
-    fn handle_encode_error(
-        &self,
-        ctx: &mut PyEncodeContext<'a>,
-        range: Range<StrSize>,
-        reason: Option<&str>,
-    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
-        let standard_encoding = StandardEncoding::parse(ctx.encoding)
-            .ok_or_else(|| ctx.error_encoding(range.clone(), reason))?;
-        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<u8> = Vec::with_capacity(num_chars * 4);
-        for ch in err_str.code_points() {
-            let c = ch.to_u32();
-            let 0xd800..=0xdfff = c else {
-                // Not a surrogate, fail with original exception
-                return Err(ctx.error_encoding(range, reason));
-            };
-            match standard_encoding {
-                StandardEncoding::Utf8 => out.extend(ch.encode_wtf8(&mut [0; 4]).as_bytes()),
-                StandardEncoding::Utf16Le => out.extend((c as u16).to_le_bytes()),
-                StandardEncoding::Utf16Be => out.extend((c as u16).to_be_bytes()),
-                StandardEncoding::Utf32Le => out.extend(c.to_le_bytes()),
-                StandardEncoding::Utf32Be => out.extend(c.to_be_bytes()),
-            }
-        }
-        Ok((EncodeReplace::Bytes(ctx.bytes(out)), range.end))
-    }
-}
-
-impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for SurrogatePass {
-    fn handle_decode_error(
-        &self,
-        ctx: &mut PyDecodeContext<'a>,
-        byte_range: Range<usize>,
-        reason: Option<&str>,
-    ) -> PyResult<(PyStrRef, usize)> {
-        let standard_encoding = StandardEncoding::parse(ctx.encoding)
-            .ok_or_else(|| ctx.error_decoding(byte_range.clone(), reason))?;
-
-        let s = ctx.full_data();
-        debug_assert!(byte_range.start <= 0.max(s.len() - 1));
-        debug_assert!(byte_range.end >= 1.min(s.len()));
-        debug_assert!(byte_range.end <= s.len());
-
-        // Try decoding a single surrogate character. If there are more,
-        // let the codec call us again.
-        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())
-        }
-
-        let c = match standard_encoding {
-            StandardEncoding::Utf8 => {
-                // it's a three-byte code
-                slice::<3>(p)
-                    .filter(|&[a, b, c]| {
-                        (u32::from(a) & 0xf0) == 0xe0
-                            && (u32::from(b) & 0xc0) == 0x80
-                            && (u32::from(c) & 0xc0) == 0x80
-                    })
-                    .map(|[a, b, c]| {
-                        ((u32::from(a) & 0x0f) << 12)
-                            + ((u32::from(b) & 0x3f) << 6)
-                            + (u32::from(c) & 0x3f)
-                    })
-            }
-            StandardEncoding::Utf16Le => slice(p).map(u16::from_le_bytes).map(u32::from),
-            StandardEncoding::Utf16Be => slice(p).map(u16::from_be_bytes).map(u32::from),
-            StandardEncoding::Utf32Le => slice(p).map(u32::from_le_bytes),
-            StandardEncoding::Utf32Be => slice(p).map(u32::from_be_bytes),
-        };
-        let byte_length = match standard_encoding {
-            StandardEncoding::Utf8 => 3,
-            StandardEncoding::Utf16Be | StandardEncoding::Utf16Le => 2,
-            StandardEncoding::Utf32Be | StandardEncoding::Utf32Le => 4,
-        };
-
-        // !Py_UNICODE_IS_SURROGATE
-        let c = c
-            .and_then(CodePoint::from_u32)
-            .filter(|c| matches!(c.to_u32(), 0xd800..=0xdfff))
-            .ok_or_else(|| ctx.error_decoding(byte_range.clone(), reason))?;
-
-        Ok((ctx.string(c.into()), byte_range.start + byte_length))
-    }
-}
-
-pub struct PyEncodeContext<'a> {
-    vm: &'a VirtualMachine,
-    encoding: &'a str,
-    data: &'a Py<PyStr>,
-    pos: StrSize,
-    exception: OnceCell<PyBaseExceptionRef>,
-}
-
-impl<'a> PyEncodeContext<'a> {
-    pub fn new(encoding: &'a str, data: &'a Py<PyStr>, vm: &'a VirtualMachine) -> Self {
-        Self {
-            vm,
-            encoding,
-            data,
-            pos: StrSize::default(),
-            exception: OnceCell::new(),
-        }
-    }
-}
-
-impl CodecContext for PyEncodeContext<'_> {
-    type Error = PyBaseExceptionRef;
-    type StrBuf = PyStrRef;
-    type BytesBuf = PyBytesRef;
-
-    fn string(&self, s: Wtf8Buf) -> Self::StrBuf {
-        self.vm.ctx.new_str(s)
-    }
-
-    fn bytes(&self, b: Vec<u8>) -> Self::BytesBuf {
-        self.vm.ctx.new_bytes(b)
-    }
-}
-impl EncodeContext for PyEncodeContext<'_> {
-    fn full_data(&self) -> &Wtf8 {
-        self.data.as_wtf8()
-    }
-
-    fn data_len(&self) -> StrSize {
-        StrSize {
-            bytes: self.data.byte_len(),
-            chars: self.data.char_len(),
-        }
-    }
-
-    fn remaining_data(&self) -> &Wtf8 {
-        &self.full_data()[self.pos.bytes..]
-    }
-
-    fn position(&self) -> StrSize {
-        self.pos
-    }
-
-    fn restart_from(&mut self, pos: StrSize) -> Result<(), Self::Error> {
-        if pos.chars > self.data.char_len() {
-            return Err(self.vm.new_index_error(format!(
-                "position {} from error handler out of bounds",
-                pos.chars
-            )));
-        }
-        assert!(
-            self.data.as_wtf8().is_code_point_boundary(pos.bytes),
-            "invalid pos {pos:?} for {:?}",
-            self.data.as_wtf8()
-        );
-        self.pos = pos;
-        Ok(())
-    }
-
-    fn error_encoding(&self, range: Range<StrSize>, reason: Option<&str>) -> Self::Error {
-        let vm = self.vm;
-        match self.exception.get() {
-            Some(exc) => {
-                match update_unicode_error_attrs(
-                    exc.as_object(),
-                    range.start.chars,
-                    range.end.chars,
-                    reason,
-                    vm,
-                ) {
-                    Ok(()) => exc.clone(),
-                    Err(e) => e,
-                }
-            }
-            None => self
-                .exception
-                .get_or_init(|| {
-                    let reason = reason.expect(
-                        "should only ever pass reason: None if an exception is already set",
-                    );
-                    vm.new_unicode_encode_error_real(
-                        vm.ctx.new_str(self.encoding),
-                        self.data.to_owned(),
-                        range.start.chars,
-                        range.end.chars,
-                        vm.ctx.new_str(reason),
-                    )
-                })
-                .clone(),
-        }
-    }
-}
-
-pub struct PyDecodeContext<'a> {
-    vm: &'a VirtualMachine,
-    encoding: &'a str,
-    data: PyDecodeData<'a>,
-    orig_bytes: Option<&'a Py<PyBytes>>,
-    pos: usize,
-    exception: OnceCell<PyBaseExceptionRef>,
-}
-enum PyDecodeData<'a> {
-    Original(BorrowedValue<'a, [u8]>),
-    Modified(PyBytesRef),
-}
-impl ops::Deref for PyDecodeData<'_> {
-    type Target = [u8];
-    fn deref(&self) -> &Self::Target {
-        match self {
-            PyDecodeData::Original(data) => data,
-            PyDecodeData::Modified(data) => data,
-        }
-    }
-}
-
-impl<'a> PyDecodeContext<'a> {
-    pub fn new(encoding: &'a str, data: &'a ArgBytesLike, vm: &'a VirtualMachine) -> Self {
-        Self {
-            vm,
-            encoding,
-            data: PyDecodeData::Original(data.borrow_buf()),
-            orig_bytes: data.as_object().downcast_ref(),
-            pos: 0,
-            exception: OnceCell::new(),
-        }
-    }
-}
-
-impl CodecContext for PyDecodeContext<'_> {
-    type Error = PyBaseExceptionRef;
-    type StrBuf = PyStrRef;
-    type BytesBuf = PyBytesRef;
-
-    fn string(&self, s: Wtf8Buf) -> Self::StrBuf {
-        self.vm.ctx.new_str(s)
-    }
-
-    fn bytes(&self, b: Vec<u8>) -> Self::BytesBuf {
-        self.vm.ctx.new_bytes(b)
-    }
-}
-impl DecodeContext for PyDecodeContext<'_> {
-    fn full_data(&self) -> &[u8] {
-        &self.data
-    }
-
-    fn remaining_data(&self) -> &[u8] {
-        &self.data[self.pos..]
-    }
-
-    fn position(&self) -> usize {
-        self.pos
-    }
-
-    fn advance(&mut self, by: usize) {
-        self.pos += by;
-    }
-
-    fn restart_from(&mut self, pos: usize) -> Result<(), Self::Error> {
-        if pos > self.data.len() {
-            return Err(self
-                .vm
-                .new_index_error(format!("position {pos} from error handler out of bounds",)));
-        }
-        self.pos = pos;
-        Ok(())
-    }
-
-    fn error_decoding(&self, byte_range: Range<usize>, reason: Option<&str>) -> Self::Error {
-        let vm = self.vm;
-
-        match self.exception.get() {
-            Some(exc) => {
-                match update_unicode_error_attrs(
-                    exc.as_object(),
-                    byte_range.start,
-                    byte_range.end,
-                    reason,
-                    vm,
-                ) {
-                    Ok(()) => exc.clone(),
-                    Err(e) => e,
-                }
-            }
-            None => self
-                .exception
-                .get_or_init(|| {
-                    let reason = reason.expect(
-                        "should only ever pass reason: None if an exception is already set",
-                    );
-                    let data = if let Some(bytes) = self.orig_bytes {
-                        bytes.to_owned()
-                    } else {
-                        vm.ctx.new_bytes(self.data.to_vec())
-                    };
-                    vm.new_unicode_decode_error_real(
-                        vm.ctx.new_str(self.encoding),
-                        data,
-                        byte_range.start,
-                        byte_range.end,
-                        vm.ctx.new_str(reason),
-                    )
-                })
-                .clone(),
-        }
-    }
-}
-
-#[derive(strum_macros::EnumString)]
-#[strum(serialize_all = "lowercase")]
-enum StandardError {
-    Strict,
-    Ignore,
-    Replace,
-    XmlCharRefReplace,
-    BackslashReplace,
-    SurrogatePass,
-    SurrogateEscape,
-}
-
-impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for StandardError {
-    fn handle_encode_error(
-        &self,
-        ctx: &mut PyEncodeContext<'a>,
-        range: Range<StrSize>,
-        reason: Option<&str>,
-    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
-        use StandardError::*;
-        // use errors::*;
-        match self {
-            Strict => errors::Strict.handle_encode_error(ctx, range, reason),
-            Ignore => errors::Ignore.handle_encode_error(ctx, range, reason),
-            Replace => errors::Replace.handle_encode_error(ctx, range, reason),
-            XmlCharRefReplace => errors::XmlCharRefReplace.handle_encode_error(ctx, range, reason),
-            BackslashReplace => errors::BackslashReplace.handle_encode_error(ctx, range, reason),
-            SurrogatePass => SurrogatePass.handle_encode_error(ctx, range, reason),
-            SurrogateEscape => errors::SurrogateEscape.handle_encode_error(ctx, range, reason),
-        }
-    }
-}
-
-impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for StandardError {
-    fn handle_decode_error(
-        &self,
-        ctx: &mut PyDecodeContext<'a>,
-        byte_range: Range<usize>,
-        reason: Option<&str>,
-    ) -> PyResult<(PyStrRef, usize)> {
-        use StandardError::*;
-        match self {
-            Strict => errors::Strict.handle_decode_error(ctx, byte_range, reason),
-            Ignore => errors::Ignore.handle_decode_error(ctx, byte_range, reason),
-            Replace => errors::Replace.handle_decode_error(ctx, byte_range, reason),
-            XmlCharRefReplace => Err(ctx
-                .vm
-                .new_type_error("don't know how to handle UnicodeDecodeError in error callback")),
-            BackslashReplace => {
-                errors::BackslashReplace.handle_decode_error(ctx, byte_range, reason)
-            }
-            SurrogatePass => self::SurrogatePass.handle_decode_error(ctx, byte_range, reason),
-            SurrogateEscape => errors::SurrogateEscape.handle_decode_error(ctx, byte_range, reason),
-        }
-    }
-}
-
-pub struct ErrorsHandler<'a> {
-    errors: &'a Py<PyStr>,
-    resolved: OnceCell<ResolvedError>,
-}
-enum ResolvedError {
-    Standard(StandardError),
-    Handler(PyObjectRef),
-}
-
-impl<'a> ErrorsHandler<'a> {
-    #[inline]
-    pub fn new(errors: Option<&'a Py<PyStr>>, 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)),
-            },
-        }
-    }
-    #[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)
-            }
-        })
-    }
-}
-impl StrBuffer for PyStrRef {
-    fn is_compatible_with(&self, kind: StrKind) -> bool {
-        self.kind() <= kind
-    }
-}
-impl<'a> EncodeErrorHandler<PyEncodeContext<'a>> for ErrorsHandler<'_> {
-    fn handle_encode_error(
-        &self,
-        ctx: &mut PyEncodeContext<'a>,
-        range: Range<StrSize>,
-        reason: Option<&str>,
-    ) -> PyResult<(EncodeReplace<PyEncodeContext<'a>>, StrSize)> {
-        let vm = ctx.vm;
-        let handler = match self.resolve(vm)? {
-            ResolvedError::Standard(standard) => {
-                return standard.handle_encode_error(ctx, range, reason);
-            }
-            ResolvedError::Handler(handler) => handler,
-        };
-        let encode_exc = ctx.error_encoding(range.clone(), reason);
-        let res = handler.call((encode_exc.clone(),), vm)?;
-        let tuple_err =
-            || vm.new_type_error("encoding error handler must return (str/bytes, int) tuple");
-        let (replace, restart) = match res.payload::<PyTuple>().map(|tup| tup.as_slice()) {
-            Some([replace, restart]) => (replace.clone(), restart),
-            _ => return Err(tuple_err()),
-        };
-        let replace = match_class!(match replace {
-            s @ PyStr => EncodeReplace::Str(s),
-            b @ PyBytes => EncodeReplace::Bytes(b),
-            _ => return Err(tuple_err()),
-        });
-        let restart = isize::try_from_borrowed_object(vm, restart).map_err(|_| tuple_err())?;
-        let restart = if restart < 0 {
-            // will still be out of bounds if it underflows ¯\_(ツ)_/¯
-            ctx.data.char_len().wrapping_sub(restart.unsigned_abs())
-        } else {
-            restart as usize
-        };
-        let restart = if restart == range.end.chars {
-            range.end
-        } else {
-            StrSize {
-                chars: restart,
-                bytes: ctx
-                    .data
-                    .as_wtf8()
-                    .code_point_indices()
-                    .nth(restart)
-                    .map_or(ctx.data.byte_len(), |(i, _)| i),
-            }
-        };
-        Ok((replace, restart))
-    }
-}
-impl<'a> DecodeErrorHandler<PyDecodeContext<'a>> for ErrorsHandler<'_> {
-    fn handle_decode_error(
-        &self,
-        ctx: &mut PyDecodeContext<'a>,
-        byte_range: Range<usize>,
-        reason: Option<&str>,
-    ) -> PyResult<(PyStrRef, usize)> {
-        let vm = ctx.vm;
-        let handler = match self.resolve(vm)? {
-            ResolvedError::Standard(standard) => {
-                return standard.handle_decode_error(ctx, byte_range, reason);
-            }
-            ResolvedError::Handler(handler) => handler,
-        };
-        let decode_exc = ctx.error_decoding(byte_range.clone(), reason);
-        let data_bytes: PyObjectRef = decode_exc.as_object().get_attr("object", vm)?;
-        let res = handler.call((decode_exc.clone(),), vm)?;
-        let new_data = decode_exc.as_object().get_attr("object", vm)?;
-        if !new_data.is(&data_bytes) {
-            let new_data: PyBytesRef = new_data
-                .downcast()
-                .map_err(|_| vm.new_type_error("object attribute must be bytes"))?;
-            ctx.data = PyDecodeData::Modified(new_data);
-        }
-        let data = &*ctx.data;
-        let tuple_err = || vm.new_type_error("decoding error handler must return (str, int) tuple");
-        match res.payload::<PyTuple>().map(|tup| tup.as_slice()) {
-            Some([replace, restart]) => {
-                let replace = replace
-                    .downcast_ref::<PyStr>()
-                    .ok_or_else(tuple_err)?
-                    .to_owned();
-                let restart =
-                    isize::try_from_borrowed_object(vm, restart).map_err(|_| tuple_err())?;
-                let restart = if restart < 0 {
-                    // will still be out of bounds if it underflows ¯\_(ツ)_/¯
-                    data.len().wrapping_sub(restart.unsigned_abs())
-                } else {
-                    restart as usize
-                };
-                Ok((replace, restart))
-            }
-            _ => Err(tuple_err()),
-        }
-    }
-}
-
-fn call_native_encode_error<E>(
-    handler: E,
-    err: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<(PyObjectRef, usize)>
-where
-    for<'a> E: EncodeErrorHandler<PyEncodeContext<'a>>,
-{
-    // 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 mut ctx = PyEncodeContext {
-        vm,
-        encoding: s_encoding.as_str(),
-        data: &s,
-        pos: StrSize::default(),
-        exception: OnceCell::with_value(err.downcast().unwrap()),
-    };
-    let mut iter = s.as_wtf8().code_point_indices();
-    let start = StrSize {
-        chars: range.start,
-        bytes: iter.nth(range.start).unwrap().0,
-    };
-    let end = StrSize {
-        chars: range.end,
-        bytes: if let Some(n) = range.len().checked_sub(1) {
-            iter.nth(n).map_or(s.byte_len(), |(i, _)| i)
-        } else {
-            start.bytes
-        },
-    };
-    let (replace, restart) = handler.handle_encode_error(&mut ctx, start..end, None)?;
-    let replace = match replace {
-        EncodeReplace::Str(s) => s.into(),
-        EncodeReplace::Bytes(b) => b.into(),
-    };
-    Ok((replace, restart.chars))
-}
-
-fn call_native_decode_error<E>(
-    handler: E,
-    err: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<(PyObjectRef, usize)>
-where
-    for<'a> E: DecodeErrorHandler<PyDecodeContext<'a>>,
-{
-    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 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()),
-    };
-    let (replace, restart) = handler.handle_decode_error(&mut ctx, range, None)?;
-    Ok((replace.into(), restart))
-}
-
-// this is a hack, for now
-fn call_native_translate_error<E>(
-    handler: E,
-    err: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<(PyObjectRef, usize)>
-where
-    for<'a> E: EncodeErrorHandler<PyEncodeContext<'a>>,
-{
-    // let err = err.
-    let range = extract_unicode_error_range(&err, vm)?;
-    let s = PyStrRef::try_from_object(vm, err.get_attr("object", vm)?)?;
-    let mut ctx = PyEncodeContext {
-        vm,
-        encoding: "",
-        data: &s,
-        pos: StrSize::default(),
-        exception: OnceCell::with_value(err.downcast().unwrap()),
-    };
-    let mut iter = s.as_wtf8().code_point_indices();
-    let start = StrSize {
-        chars: range.start,
-        bytes: iter.nth(range.start).unwrap().0,
-    };
-    let end = StrSize {
-        chars: range.end,
-        bytes: if let Some(n) = range.len().checked_sub(1) {
-            iter.nth(n).map_or(s.byte_len(), |(i, _)| i)
-        } else {
-            start.bytes
-        },
-    };
-    let (replace, restart) = handler.handle_encode_error(&mut ctx, start..end, None)?;
-    let replace = match replace {
-        EncodeReplace::Str(s) => s.into(),
-        EncodeReplace::Bytes(b) => b.into(),
-    };
-    Ok((replace, restart.chars))
-}
-
-// TODO: exceptions with custom payloads
-fn extract_unicode_error_range(err: &PyObject, vm: &VirtualMachine) -> PyResult<Range<usize>> {
-    let start = err.get_attr("start", vm)?;
-    let start = start.try_into_value(vm)?;
-    let end = err.get_attr("end", vm)?;
-    let end = end.try_into_value(vm)?;
-    Ok(Range { start, end })
-}
-
-fn update_unicode_error_attrs(
-    err: &PyObject,
-    start: usize,
-    end: usize,
-    reason: Option<&str>,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    err.set_attr("start", start.to_pyobject(vm), vm)?;
-    err.set_attr("end", end.to_pyobject(vm), vm)?;
-    if let Some(reason) = reason {
-        err.set_attr("reason", reason.to_pyobject(vm), vm)?;
-    }
-    Ok(())
-}
-
-#[inline]
-fn is_encode_err(err: &PyObject, vm: &VirtualMachine) -> bool {
-    err.fast_isinstance(vm.ctx.exceptions.unicode_encode_error)
-}
-#[inline]
-fn is_decode_err(err: &PyObject, vm: &VirtualMachine) -> bool {
-    err.fast_isinstance(vm.ctx.exceptions.unicode_decode_error)
-}
-#[inline]
-fn is_translate_err(err: &PyObject, vm: &VirtualMachine) -> bool {
-    err.fast_isinstance(vm.ctx.exceptions.unicode_translate_error)
-}
-
-fn bad_err_type(err: PyObjectRef, vm: &VirtualMachine) -> PyBaseExceptionRef {
-    vm.new_type_error(format!(
-        "don't know how to handle {} in error callback",
-        err.class().name()
-    ))
-}
-
-fn strict_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    let err = err
-        .downcast()
-        .unwrap_or_else(|_| vm.new_type_error("codec must pass exception instance"));
-    Err(err)
-}
-
-fn ignore_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) || is_decode_err(&err, vm) || is_translate_err(&err, vm) {
-        let range = extract_unicode_error_range(&err, vm)?;
-        Ok((vm.ctx.new_str(ascii!("")).into(), range.end))
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn replace_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) {
-        call_native_encode_error(errors::Replace, err, vm)
-    } else if is_decode_err(&err, vm) {
-        call_native_decode_error(errors::Replace, err, vm)
-    } else if is_translate_err(&err, vm) {
-        // char::REPLACEMENT_CHARACTER as a str
-        let replacement_char = "\u{FFFD}";
-        let range = extract_unicode_error_range(&err, vm)?;
-        let replace = replacement_char.repeat(range.end - range.start);
-        Ok((replace.to_pyobject(vm), range.end))
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn xmlcharrefreplace_errors(
-    err: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) {
-        call_native_encode_error(errors::XmlCharRefReplace, err, vm)
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn backslashreplace_errors(
-    err: PyObjectRef,
-    vm: &VirtualMachine,
-) -> PyResult<(PyObjectRef, usize)> {
-    if is_decode_err(&err, vm) {
-        call_native_decode_error(errors::BackslashReplace, err, vm)
-    } else if is_encode_err(&err, vm) {
-        call_native_encode_error(errors::BackslashReplace, err, vm)
-    } else if is_translate_err(&err, vm) {
-        call_native_translate_error(errors::BackslashReplace, err, vm)
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn namereplace_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) {
-        call_native_encode_error(errors::NameReplace, err, vm)
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn surrogatepass_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) {
-        call_native_encode_error(SurrogatePass, err, vm)
-    } else if is_decode_err(&err, vm) {
-        call_native_decode_error(SurrogatePass, err, vm)
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
-
-fn surrogateescape_errors(err: PyObjectRef, vm: &VirtualMachine) -> PyResult<(PyObjectRef, usize)> {
-    if is_encode_err(&err, vm) {
-        call_native_encode_error(errors::SurrogateEscape, err, vm)
-    } else if is_decode_err(&err, vm) {
-        call_native_decode_error(errors::SurrogateEscape, err, vm)
-    } else {
-        Err(bad_err_type(err, vm))
-    }
-}
diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs
deleted file mode 100644
index 5e0ca62cae..0000000000
--- a/vm/src/coroutine.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyResult, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyStrRef},
-    common::lock::PyMutex,
-    frame::{ExecutionResult, FrameRef},
-    protocol::PyIterReturn,
-};
-use crossbeam_utils::atomic::AtomicCell;
-
-impl ExecutionResult {
-    /// Turn an ExecutionResult into a PyResult that would be returned from a generator or coroutine
-    fn into_iter_return(self, vm: &VirtualMachine) -> PyIterReturn {
-        match self {
-            Self::Yield(value) => PyIterReturn::Return(value),
-            Self::Return(value) => {
-                let arg = if vm.is_none(&value) {
-                    None
-                } else {
-                    Some(value)
-                };
-                PyIterReturn::StopIteration(arg)
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Coro {
-    frame: FrameRef,
-    pub closed: AtomicCell<bool>, // TODO: https://github.com/RustPython/RustPython/pull/3183#discussion_r720560652
-    running: AtomicCell<bool>,
-    // code
-    // _weakreflist
-    name: PyMutex<PyStrRef>,
-    // qualname
-    exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
-}
-
-fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
-    let typ = jen.class();
-    if typ.is(vm.ctx.types.coroutine_type) {
-        "coroutine"
-    } else if typ.is(vm.ctx.types.async_generator) {
-        "async generator"
-    } else {
-        "generator"
-    }
-}
-
-impl Coro {
-    pub fn new(frame: FrameRef, name: PyStrRef) -> Self {
-        Self {
-            frame,
-            closed: AtomicCell::new(false),
-            running: AtomicCell::new(false),
-            exception: PyMutex::default(),
-            name: PyMutex::new(name),
-        }
-    }
-
-    fn maybe_close(&self, res: &PyResult<ExecutionResult>) {
-        match res {
-            Ok(ExecutionResult::Return(_)) | Err(_) => self.closed.store(true),
-            Ok(ExecutionResult::Yield(_)) => {}
-        }
-    }
-
-    fn run_with_context<F>(
-        &self,
-        jen: &PyObject,
-        vm: &VirtualMachine,
-        func: F,
-    ) -> PyResult<ExecutionResult>
-    where
-        F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
-    {
-        if self.running.compare_exchange(false, true).is_err() {
-            return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
-        }
-
-        vm.push_exception(self.exception.lock().take());
-
-        let result = vm.with_frame(self.frame.clone(), func);
-
-        *self.exception.lock() = vm.pop_exception();
-
-        self.running.store(false);
-        result
-    }
-
-    pub fn send(
-        &self,
-        jen: &PyObject,
-        value: PyObjectRef,
-        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)),
-            Err(e) => {
-                if e.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
-                    let err =
-                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(jen, vm)));
-                    err.set___cause__(Some(e));
-                    Err(err)
-                } else if jen.class().is(vm.ctx.types.async_generator)
-                    && e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
-                {
-                    let err = vm.new_runtime_error("async generator raised StopAsyncIteration");
-                    err.set___cause__(Some(e));
-                    Err(err)
-                } else {
-                    Err(e)
-                }
-            }
-        }
-    }
-
-    pub fn throw(
-        &self,
-        jen: &PyObject,
-        exc_type: PyObjectRef,
-        exc_val: PyObjectRef,
-        exc_tb: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyIterReturn> {
-        if self.closed.load() {
-            return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
-        }
-        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<()> {
-        if self.closed.load() {
-            return Ok(());
-        }
-        let result = self.run_with_context(jen, vm, |f| {
-            f.gen_throw(
-                vm,
-                vm.ctx.exceptions.generator_exit.to_owned().into(),
-                vm.ctx.none(),
-                vm.ctx.none(),
-            )
-        });
-        self.closed.store(true);
-        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(()),
-        }
-    }
-
-    pub fn running(&self) -> bool {
-        self.running.load()
-    }
-
-    pub fn closed(&self) -> bool {
-        self.closed.load()
-    }
-
-    pub fn frame(&self) -> FrameRef {
-        self.frame.clone()
-    }
-
-    pub fn name(&self) -> PyStrRef {
-        self.name.lock().clone()
-    }
-
-    pub fn set_name(&self, name: PyStrRef) {
-        *self.name.lock() = name;
-    }
-
-    pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
-        format!(
-            "<{} object {} at {:#x}>",
-            gen_name(jen, vm),
-            self.name.lock(),
-            id
-        )
-    }
-}
-
-pub fn is_gen_exit(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool {
-    exc.fast_isinstance(vm.ctx.exceptions.generator_exit)
-}
diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs
deleted file mode 100644
index 1e816145dd..0000000000
--- a/vm/src/exceptions.rs
+++ /dev/null
@@ -1,1990 +0,0 @@
-use self::types::{PyBaseException, PyBaseExceptionRef};
-use crate::common::lock::PyRwLock;
-use crate::object::{Traverse, TraverseFn};
-use crate::{
-    AsObject, Context, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{
-        PyNone, PyStr, PyStrRef, PyTuple, PyTupleRef, PyType, PyTypeRef,
-        traceback::{PyTraceback, PyTracebackRef},
-    },
-    class::{PyClassImpl, StaticType},
-    convert::{ToPyException, ToPyObject},
-    function::{ArgIterable, FuncArgs, IntoFuncArgs},
-    py_io::{self, Write},
-    stdlib::sys,
-    suggestion::offer_suggestions,
-    types::{Callable, Constructor, Initializer, Representable},
-};
-use crossbeam_utils::atomic::AtomicCell;
-use itertools::Itertools;
-use std::{
-    collections::HashSet,
-    io::{self, BufRead, BufReader},
-};
-
-unsafe impl Traverse for PyBaseException {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.traceback.traverse(tracer_fn);
-        self.cause.traverse(tracer_fn);
-        self.context.traverse(tracer_fn);
-        self.args.traverse(tracer_fn);
-    }
-}
-
-impl std::fmt::Debug for PyBaseException {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // TODO: implement more detailed, non-recursive Debug formatter
-        f.write_str("PyBaseException")
-    }
-}
-
-impl PyPayload for PyBaseException {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.exceptions.base_exception_type
-    }
-}
-
-impl VirtualMachine {
-    // Why `impl VirtualMachine`?
-    // These functions are natively free function in CPython - not methods of PyException
-
-    /// Print exception chain by calling sys.excepthook
-    pub fn print_exception(&self, exc: PyBaseExceptionRef) {
-        let vm = self;
-        let write_fallback = |exc, errstr| {
-            if let Ok(stderr) = sys::get_stderr(vm) {
-                let mut stderr = py_io::PyWriter(stderr, vm);
-                // if this fails stderr might be closed -- ignore it
-                let _ = writeln!(stderr, "{errstr}");
-                let _ = self.write_exception(&mut stderr, exc);
-            } else {
-                eprintln!("{errstr}\nlost sys.stderr");
-                let _ = self.write_exception(&mut py_io::IoWriter(io::stderr()), exc);
-            }
-        };
-        if let Ok(excepthook) = vm.sys_module.get_attr("excepthook", vm) {
-            let (exc_type, exc_val, exc_tb) = vm.split_exception(exc.clone());
-            if let Err(eh_exc) = excepthook.call((exc_type, exc_val, exc_tb), vm) {
-                write_fallback(&eh_exc, "Error in sys.excepthook:");
-                write_fallback(&exc, "Original exception was:");
-            }
-        } else {
-            write_fallback(&exc, "missing sys.excepthook");
-        }
-    }
-
-    pub fn write_exception<W: Write>(
-        &self,
-        output: &mut W,
-        exc: &PyBaseExceptionRef,
-    ) -> Result<(), W::Error> {
-        let seen = &mut HashSet::<usize>::new();
-        self.write_exception_recursive(output, exc, seen)
-    }
-
-    fn write_exception_recursive<W: Write>(
-        &self,
-        output: &mut W,
-        exc: &PyBaseExceptionRef,
-        seen: &mut HashSet<usize>,
-    ) -> Result<(), W::Error> {
-        // This function should not be called directly,
-        // use `wite_exception` as a public interface.
-        // It is similar to `print_exception_recursive` from `CPython`.
-        seen.insert(exc.get_id());
-
-        #[allow(clippy::manual_map)]
-        if let Some((cause_or_context, msg)) = if let Some(cause) = exc.__cause__() {
-            // This can be a special case: `raise e from e`,
-            // we just ignore it and treat like `raise e` without any extra steps.
-            Some((
-                cause,
-                "\nThe above exception was the direct cause of the following exception:\n",
-            ))
-        } else if let Some(context) = exc.__context__() {
-            // This can be a special case:
-            //   e = ValueError('e')
-            //   e.__context__ = e
-            // In this case, we just ignore
-            // `__context__` part from going into recursion.
-            Some((
-                context,
-                "\nDuring handling of the above exception, another exception occurred:\n",
-            ))
-        } else {
-            None
-        } {
-            if !seen.contains(&cause_or_context.get_id()) {
-                self.write_exception_recursive(output, &cause_or_context, seen)?;
-                writeln!(output, "{msg}")?;
-            } else {
-                seen.insert(cause_or_context.get_id());
-            }
-        }
-
-        self.write_exception_inner(output, exc)
-    }
-
-    /// Print exception with traceback
-    pub fn write_exception_inner<W: Write>(
-        &self,
-        output: &mut W,
-        exc: &PyBaseExceptionRef,
-    ) -> Result<(), W::Error> {
-        let vm = self;
-        if let Some(tb) = exc.traceback.read().clone() {
-            writeln!(output, "Traceback (most recent call last):")?;
-            for tb in tb.iter() {
-                write_traceback_entry(output, &tb)?;
-            }
-        }
-
-        let varargs = exc.args();
-        let args_repr = vm.exception_args_as_string(varargs, true);
-
-        let exc_class = exc.class();
-
-        if exc_class.fast_issubclass(vm.ctx.exceptions.syntax_error) {
-            return self.write_syntaxerror(output, exc, exc_class, &args_repr);
-        }
-
-        let exc_name = exc_class.name();
-        match args_repr.len() {
-            0 => write!(output, "{exc_name}"),
-            1 => write!(output, "{}: {}", exc_name, args_repr[0]),
-            _ => write!(
-                output,
-                "{}: ({})",
-                exc_name,
-                args_repr.into_iter().format(", "),
-            ),
-        }?;
-
-        match offer_suggestions(exc, vm) {
-            Some(suggestions) => writeln!(output, ". Did you mean: '{suggestions}'?"),
-            None => writeln!(output),
-        }
-    }
-
-    /// Format and write a SyntaxError
-    /// This logic is derived from TracebackException._format_syntax_error
-    ///
-    /// The logic has support for `end_offset` to highlight a range in the source code,
-    /// but it looks like `end_offset` is not used yet when SyntaxErrors are created.
-    fn write_syntaxerror<W: Write>(
-        &self,
-        output: &mut W,
-        exc: &PyBaseExceptionRef,
-        exc_type: &Py<PyType>,
-        args_repr: &[PyRef<PyStr>],
-    ) -> Result<(), W::Error> {
-        let vm = self;
-        debug_assert!(exc_type.fast_issubclass(vm.ctx.exceptions.syntax_error));
-
-        let getattr = |attr: &'static str| exc.as_object().get_attr(attr, vm).ok();
-
-        let maybe_lineno = getattr("lineno").map(|obj| {
-            obj.str(vm)
-                .unwrap_or_else(|_| vm.ctx.new_str("<lineno str() failed>"))
-        });
-        let maybe_filename = getattr("filename").and_then(|obj| obj.str(vm).ok());
-
-        let maybe_text = getattr("text").map(|obj| {
-            obj.str(vm)
-                .unwrap_or_else(|_| vm.ctx.new_str("<text str() failed>"))
-        });
-
-        let mut filename_suffix = String::new();
-
-        if let Some(lineno) = maybe_lineno {
-            writeln!(
-                output,
-                r##"  File "{}", line {}"##,
-                maybe_filename
-                    .as_ref()
-                    .map(|s| s.as_str())
-                    .unwrap_or("<string>"),
-                lineno
-            )?;
-        } else if let Some(filename) = maybe_filename {
-            filename_suffix = format!(" ({filename})");
-        }
-
-        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
-            let spaces = (r_text.len() - l_text.len()) as isize;
-
-            writeln!(output, "    {l_text}")?;
-
-            let maybe_offset: Option<isize> =
-                getattr("offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
-
-            if let Some(offset) = maybe_offset {
-                let maybe_end_offset: Option<isize> =
-                    getattr("end_offset").and_then(|obj| obj.try_to_value::<isize>(vm).ok());
-
-                let mut end_offset = match maybe_end_offset {
-                    Some(0) | None => offset,
-                    Some(end_offset) => end_offset,
-                };
-
-                if offset == end_offset || end_offset == -1 {
-                    end_offset = offset + 1;
-                }
-
-                // Convert 1-based column offset to 0-based index into stripped text
-                let colno = offset - 1 - spaces;
-                let end_colno = end_offset - 1 - spaces;
-                if colno >= 0 {
-                    let caret_space = l_text
-                        .chars()
-                        .take(colno as usize)
-                        .map(|c| if c.is_whitespace() { c } else { ' ' })
-                        .collect::<String>();
-
-                    let mut error_width = end_colno - colno;
-                    if error_width < 1 {
-                        error_width = 1;
-                    }
-
-                    writeln!(
-                        output,
-                        "    {}{}",
-                        caret_space,
-                        "^".repeat(error_width as usize)
-                    )?;
-                }
-            }
-        }
-
-        let exc_name = exc_type.name();
-
-        match args_repr.len() {
-            0 => write!(output, "{exc_name}{filename_suffix}"),
-            1 => write!(output, "{}: {}{}", exc_name, args_repr[0], filename_suffix),
-            _ => write!(
-                output,
-                "{}: ({}){}",
-                exc_name,
-                args_repr.iter().format(", "),
-                filename_suffix
-            ),
-        }?;
-
-        match offer_suggestions(exc, vm) {
-            Some(suggestions) => writeln!(output, ". Did you mean: '{suggestions}'?"),
-            None => writeln!(output),
-        }
-    }
-
-    fn exception_args_as_string(&self, varargs: PyTupleRef, str_single: bool) -> Vec<PyStrRef> {
-        let vm = self;
-        match varargs.len() {
-            0 => vec![],
-            1 => {
-                let args0_repr = if str_single {
-                    varargs[0]
-                        .str(vm)
-                        .unwrap_or_else(|_| PyStr::from("<element str() failed>").into_ref(&vm.ctx))
-                } else {
-                    varargs[0].repr(vm).unwrap_or_else(|_| {
-                        PyStr::from("<element repr() failed>").into_ref(&vm.ctx)
-                    })
-                };
-                vec![args0_repr]
-            }
-            _ => varargs
-                .iter()
-                .map(|vararg| {
-                    vararg.repr(vm).unwrap_or_else(|_| {
-                        PyStr::from("<element repr() failed>").into_ref(&vm.ctx)
-                    })
-                })
-                .collect(),
-        }
-    }
-
-    pub fn split_exception(
-        &self,
-        exc: PyBaseExceptionRef,
-    ) -> (PyObjectRef, PyObjectRef, PyObjectRef) {
-        let tb = exc.__traceback__().to_pyobject(self);
-        let class = exc.class().to_owned();
-        (class.into(), exc.into(), tb)
-    }
-
-    /// Similar to PyErr_NormalizeException in CPython
-    pub fn normalize_exception(
-        &self,
-        exc_type: PyObjectRef,
-        exc_val: PyObjectRef,
-        exc_tb: PyObjectRef,
-    ) -> PyResult<PyBaseExceptionRef> {
-        let ctor = ExceptionCtor::try_from_object(self, exc_type)?;
-        let exc = ctor.instantiate_value(exc_val, self)?;
-        if let Some(tb) = Option::<PyTracebackRef>::try_from_object(self, exc_tb)? {
-            exc.set_traceback_typed(Some(tb));
-        }
-        Ok(exc)
-    }
-
-    pub fn invoke_exception(
-        &self,
-        cls: PyTypeRef,
-        args: Vec<PyObjectRef>,
-    ) -> 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)
-    }
-}
-
-fn print_source_line<W: Write>(
-    output: &mut W,
-    filename: &str,
-    lineno: usize,
-) -> Result<(), W::Error> {
-    // TODO: use io.open() method instead, when available, according to https://github.com/python/cpython/blob/main/Python/traceback.c#L393
-    // TODO: support different encodings
-    let file = match std::fs::File::open(filename) {
-        Ok(file) => file,
-        Err(_) => return Ok(()),
-    };
-    let file = BufReader::new(file);
-
-    for (i, line) in file.lines().enumerate() {
-        if i + 1 == lineno {
-            if let Ok(line) = line {
-                // Indented with 4 spaces
-                writeln!(output, "    {}", line.trim_start())?;
-            }
-            return Ok(());
-        }
-    }
-
-    Ok(())
-}
-
-/// Print exception occurrence location from traceback element
-fn write_traceback_entry<W: Write>(
-    output: &mut W,
-    tb_entry: &PyTracebackRef,
-) -> Result<(), W::Error> {
-    let filename = tb_entry.frame.code.source_path.as_str();
-    writeln!(
-        output,
-        r##"  File "{}", line {}, in {}"##,
-        filename.trim_start_matches(r"\\?\"),
-        tb_entry.lineno,
-        tb_entry.frame.code.obj_name
-    )?;
-    print_source_line(output, filename, tb_entry.lineno.get())?;
-
-    Ok(())
-}
-
-#[derive(Clone)]
-pub enum ExceptionCtor {
-    Class(PyTypeRef),
-    Instance(PyBaseExceptionRef),
-}
-
-impl TryFromObject for ExceptionCtor {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        obj.downcast::<PyType>()
-            .and_then(|cls| {
-                if cls.fast_issubclass(vm.ctx.exceptions.base_exception_type) {
-                    Ok(Self::Class(cls))
-                } else {
-                    Err(cls.into())
-                }
-            })
-            .or_else(|obj| obj.downcast::<PyBaseException>().map(Self::Instance))
-            .map_err(|obj| {
-                vm.new_type_error(format!(
-                    "exceptions must be classes or instances deriving from BaseException, not {}",
-                    obj.class().name()
-                ))
-            })
-    }
-}
-
-impl ExceptionCtor {
-    pub fn instantiate(self, vm: &VirtualMachine) -> PyResult<PyBaseExceptionRef> {
-        match self {
-            Self::Class(cls) => vm.invoke_exception(cls, vec![]),
-            Self::Instance(exc) => Ok(exc),
-        }
-    }
-
-    pub fn instantiate_value(
-        self,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyBaseExceptionRef> {
-        let exc_inst = value.clone().downcast::<PyBaseException>().ok();
-        match (self, exc_inst) {
-            // both are instances; which would we choose?
-            (Self::Instance(_exc_a), Some(_exc_b)) => {
-                Err(vm.new_type_error("instance exception may not have a separate value"))
-            }
-            // if the "type" is an instance and the value isn't, use the "type"
-            (Self::Instance(exc), None) => Ok(exc),
-            // if the value is an instance of the type, use the instance value
-            (Self::Class(cls), Some(exc)) if exc.fast_isinstance(&cls) => Ok(exc),
-            // otherwise; construct an exception of the type using the value as args
-            (Self::Class(cls), _) => {
-                let args = match_class!(match value {
-                    PyNone => vec![],
-                    tup @ PyTuple => tup.to_vec(),
-                    exc @ PyBaseException => exc.args().to_vec(),
-                    obj => vec![obj],
-                });
-                vm.invoke_exception(cls, args)
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct ExceptionZoo {
-    pub base_exception_type: &'static Py<PyType>,
-    pub base_exception_group: &'static Py<PyType>,
-    pub exception_group: &'static Py<PyType>,
-    pub system_exit: &'static Py<PyType>,
-    pub keyboard_interrupt: &'static Py<PyType>,
-    pub generator_exit: &'static Py<PyType>,
-    pub exception_type: &'static Py<PyType>,
-    pub stop_iteration: &'static Py<PyType>,
-    pub stop_async_iteration: &'static Py<PyType>,
-    pub arithmetic_error: &'static Py<PyType>,
-    pub floating_point_error: &'static Py<PyType>,
-    pub overflow_error: &'static Py<PyType>,
-    pub zero_division_error: &'static Py<PyType>,
-    pub assertion_error: &'static Py<PyType>,
-    pub attribute_error: &'static Py<PyType>,
-    pub buffer_error: &'static Py<PyType>,
-    pub eof_error: &'static Py<PyType>,
-    pub import_error: &'static Py<PyType>,
-    pub module_not_found_error: &'static Py<PyType>,
-    pub lookup_error: &'static Py<PyType>,
-    pub index_error: &'static Py<PyType>,
-    pub key_error: &'static Py<PyType>,
-    pub memory_error: &'static Py<PyType>,
-    pub name_error: &'static Py<PyType>,
-    pub unbound_local_error: &'static Py<PyType>,
-    pub os_error: &'static Py<PyType>,
-    pub blocking_io_error: &'static Py<PyType>,
-    pub child_process_error: &'static Py<PyType>,
-    pub connection_error: &'static Py<PyType>,
-    pub broken_pipe_error: &'static Py<PyType>,
-    pub connection_aborted_error: &'static Py<PyType>,
-    pub connection_refused_error: &'static Py<PyType>,
-    pub connection_reset_error: &'static Py<PyType>,
-    pub file_exists_error: &'static Py<PyType>,
-    pub file_not_found_error: &'static Py<PyType>,
-    pub interrupted_error: &'static Py<PyType>,
-    pub is_a_directory_error: &'static Py<PyType>,
-    pub not_a_directory_error: &'static Py<PyType>,
-    pub permission_error: &'static Py<PyType>,
-    pub process_lookup_error: &'static Py<PyType>,
-    pub timeout_error: &'static Py<PyType>,
-    pub reference_error: &'static Py<PyType>,
-    pub runtime_error: &'static Py<PyType>,
-    pub not_implemented_error: &'static Py<PyType>,
-    pub recursion_error: &'static Py<PyType>,
-    pub syntax_error: &'static Py<PyType>,
-    pub incomplete_input_error: &'static Py<PyType>,
-    pub indentation_error: &'static Py<PyType>,
-    pub tab_error: &'static Py<PyType>,
-    pub system_error: &'static Py<PyType>,
-    pub type_error: &'static Py<PyType>,
-    pub value_error: &'static Py<PyType>,
-    pub unicode_error: &'static Py<PyType>,
-    pub unicode_decode_error: &'static Py<PyType>,
-    pub unicode_encode_error: &'static Py<PyType>,
-    pub unicode_translate_error: &'static Py<PyType>,
-
-    #[cfg(feature = "jit")]
-    pub jit_error: &'static Py<PyType>,
-
-    pub warning: &'static Py<PyType>,
-    pub deprecation_warning: &'static Py<PyType>,
-    pub pending_deprecation_warning: &'static Py<PyType>,
-    pub runtime_warning: &'static Py<PyType>,
-    pub syntax_warning: &'static Py<PyType>,
-    pub user_warning: &'static Py<PyType>,
-    pub future_warning: &'static Py<PyType>,
-    pub import_warning: &'static Py<PyType>,
-    pub unicode_warning: &'static Py<PyType>,
-    pub bytes_warning: &'static Py<PyType>,
-    pub resource_warning: &'static Py<PyType>,
-    pub encoding_warning: &'static Py<PyType>,
-}
-
-macro_rules! extend_exception {
-    (
-        $exc_struct:ident,
-        $ctx:expr,
-        $class:expr
-    ) => {
-        extend_exception!($exc_struct, $ctx, $class, {});
-    };
-    (
-        $exc_struct:ident,
-        $ctx:expr,
-        $class:expr,
-        { $($name:expr => $value:expr),* $(,)* }
-    ) => {
-        $exc_struct::extend_class($ctx, $class);
-        extend_class!($ctx, $class, {
-            $($name => $value,)*
-        });
-    };
-}
-
-impl PyBaseException {
-    pub(crate) fn new(args: Vec<PyObjectRef>, vm: &VirtualMachine) -> Self {
-        Self {
-            traceback: PyRwLock::new(None),
-            cause: PyRwLock::new(None),
-            context: PyRwLock::new(None),
-            suppress_context: AtomicCell::new(false),
-            args: PyRwLock::new(PyTuple::new_ref(args, &vm.ctx)),
-        }
-    }
-
-    pub fn get_arg(&self, idx: usize) -> Option<PyObjectRef> {
-        self.args.read().get(idx).cloned()
-    }
-}
-
-#[pyclass(
-    with(PyRef, Constructor, Initializer, Representable),
-    flags(BASETYPE, HAS_DICT)
-)]
-impl PyBaseException {
-    #[pygetset]
-    pub fn args(&self) -> PyTupleRef {
-        self.args.read().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set_args(&self, args: ArgIterable, vm: &VirtualMachine) -> PyResult<()> {
-        let args = args.iter(vm)?.collect::<PyResult<Vec<_>>>()?;
-        *self.args.write() = PyTuple::new_ref(args, &vm.ctx);
-        Ok(())
-    }
-
-    #[pygetset]
-    pub fn __traceback__(&self) -> Option<PyTracebackRef> {
-        self.traceback.read().clone()
-    }
-
-    #[pygetset(setter)]
-    pub fn set___traceback__(&self, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let traceback = if vm.is_none(&value) {
-            None
-        } else {
-            match value.downcast::<PyTraceback>() {
-                Ok(tb) => Some(tb),
-                Err(_) => {
-                    return Err(vm.new_type_error("__traceback__ must be a traceback or None"));
-                }
-            }
-        };
-        self.set_traceback_typed(traceback);
-        Ok(())
-    }
-
-    // Helper method for internal use that doesn't require PyObjectRef
-    pub(crate) fn set_traceback_typed(&self, traceback: Option<PyTracebackRef>) {
-        *self.traceback.write() = traceback;
-    }
-
-    #[pygetset]
-    pub fn __cause__(&self) -> Option<PyRef<Self>> {
-        self.cause.read().clone()
-    }
-
-    #[pygetset(setter)]
-    pub fn set___cause__(&self, cause: Option<PyRef<Self>>) {
-        let mut c = self.cause.write();
-        self.set_suppress_context(true);
-        *c = cause;
-    }
-
-    #[pygetset]
-    pub fn __context__(&self) -> Option<PyRef<Self>> {
-        self.context.read().clone()
-    }
-
-    #[pygetset(setter)]
-    pub fn set___context__(&self, context: Option<PyRef<Self>>) {
-        *self.context.write() = context;
-    }
-
-    #[pygetset(name = "__suppress_context__")]
-    pub(super) fn get_suppress_context(&self) -> bool {
-        self.suppress_context.load()
-    }
-
-    #[pygetset(name = "__suppress_context__", setter)]
-    fn set_suppress_context(&self, suppress_context: bool) {
-        self.suppress_context.store(suppress_context);
-    }
-
-    #[pymethod]
-    pub(super) fn __str__(&self, vm: &VirtualMachine) -> PyStrRef {
-        let str_args = vm.exception_args_as_string(self.args(), true);
-        match str_args.into_iter().exactly_one() {
-            Err(i) if i.len() == 0 => vm.ctx.empty_str.to_owned(),
-            Ok(s) => s,
-            Err(i) => PyStr::from(format!("({})", i.format(", "))).into_ref(&vm.ctx),
-        }
-    }
-}
-
-#[pyclass]
-impl PyRef<PyBaseException> {
-    #[pymethod]
-    fn with_traceback(self, tb: Option<PyTracebackRef>) -> PyResult<Self> {
-        *self.traceback.write() = tb;
-        Ok(self)
-    }
-
-    #[pymethod]
-    fn __reduce__(self, vm: &VirtualMachine) -> PyTupleRef {
-        if let Some(dict) = self.as_object().dict().filter(|x| !x.is_empty()) {
-            vm.new_tuple((self.class().to_owned(), self.args(), dict))
-        } else {
-            vm.new_tuple((self.class().to_owned(), self.args()))
-        }
-    }
-
-    #[pymethod]
-    fn __setstate__(self, state: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        if !vm.is_none(&state) {
-            let dict = state
-                .downcast::<crate::builtins::PyDict>()
-                .map_err(|_| vm.new_type_error("state is not a dictionary"))?;
-
-            for (key, value) in &dict {
-                let key_str = key.str(vm)?;
-                if key_str.as_str().starts_with("__") {
-                    continue;
-                }
-                self.as_object().set_attr(&key_str, value.clone(), vm)?;
-            }
-        }
-        Ok(vm.ctx.none())
-    }
-}
-
-impl Constructor for PyBaseException {
-    type Args = FuncArgs;
-
-    fn py_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        if cls.is(Self::class(&vm.ctx)) && !args.kwargs.is_empty() {
-            return Err(vm.new_type_error("BaseException() takes no keyword arguments"));
-        }
-        Self::new(args.args, vm)
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-    }
-}
-
-impl Initializer for PyBaseException {
-    type Args = FuncArgs;
-
-    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
-        *zelf.args.write() = PyTuple::new_ref(args.args, &vm.ctx);
-        Ok(())
-    }
-}
-
-impl Representable for PyBaseException {
-    #[inline]
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-        let repr_args = vm.exception_args_as_string(zelf.args(), false);
-        let cls = zelf.class();
-        Ok(format!("{}({})", cls.name(), repr_args.iter().format(", ")))
-    }
-}
-
-impl ExceptionZoo {
-    pub(crate) fn init() -> Self {
-        use self::types::*;
-
-        let base_exception_type = PyBaseException::init_builtin_type();
-
-        // Sorted By Hierarchy then alphabetized.
-        let base_exception_group = PyBaseExceptionGroup::init_builtin_type();
-        let exception_group = PyExceptionGroup::init_builtin_type();
-        let system_exit = PySystemExit::init_builtin_type();
-        let keyboard_interrupt = PyKeyboardInterrupt::init_builtin_type();
-        let generator_exit = PyGeneratorExit::init_builtin_type();
-
-        let exception_type = PyException::init_builtin_type();
-        let stop_iteration = PyStopIteration::init_builtin_type();
-        let stop_async_iteration = PyStopAsyncIteration::init_builtin_type();
-        let arithmetic_error = PyArithmeticError::init_builtin_type();
-        let floating_point_error = PyFloatingPointError::init_builtin_type();
-        let overflow_error = PyOverflowError::init_builtin_type();
-        let zero_division_error = PyZeroDivisionError::init_builtin_type();
-
-        let assertion_error = PyAssertionError::init_builtin_type();
-        let attribute_error = PyAttributeError::init_builtin_type();
-        let buffer_error = PyBufferError::init_builtin_type();
-        let eof_error = PyEOFError::init_builtin_type();
-
-        let import_error = PyImportError::init_builtin_type();
-        let module_not_found_error = PyModuleNotFoundError::init_builtin_type();
-
-        let lookup_error = PyLookupError::init_builtin_type();
-        let index_error = PyIndexError::init_builtin_type();
-        let key_error = PyKeyError::init_builtin_type();
-
-        let memory_error = PyMemoryError::init_builtin_type();
-
-        let name_error = PyNameError::init_builtin_type();
-        let unbound_local_error = PyUnboundLocalError::init_builtin_type();
-
-        // os errors
-        let os_error = PyOSError::init_builtin_type();
-        let blocking_io_error = PyBlockingIOError::init_builtin_type();
-        let child_process_error = PyChildProcessError::init_builtin_type();
-
-        let connection_error = PyConnectionError::init_builtin_type();
-        let broken_pipe_error = PyBrokenPipeError::init_builtin_type();
-        let connection_aborted_error = PyConnectionAbortedError::init_builtin_type();
-        let connection_refused_error = PyConnectionRefusedError::init_builtin_type();
-        let connection_reset_error = PyConnectionResetError::init_builtin_type();
-
-        let file_exists_error = PyFileExistsError::init_builtin_type();
-        let file_not_found_error = PyFileNotFoundError::init_builtin_type();
-        let interrupted_error = PyInterruptedError::init_builtin_type();
-        let is_a_directory_error = PyIsADirectoryError::init_builtin_type();
-        let not_a_directory_error = PyNotADirectoryError::init_builtin_type();
-        let permission_error = PyPermissionError::init_builtin_type();
-        let process_lookup_error = PyProcessLookupError::init_builtin_type();
-        let timeout_error = PyTimeoutError::init_builtin_type();
-
-        let reference_error = PyReferenceError::init_builtin_type();
-
-        let runtime_error = PyRuntimeError::init_builtin_type();
-        let not_implemented_error = PyNotImplementedError::init_builtin_type();
-        let recursion_error = PyRecursionError::init_builtin_type();
-
-        let syntax_error = PySyntaxError::init_builtin_type();
-        let incomplete_input_error = PyIncompleteInputError::init_builtin_type();
-        let indentation_error = PyIndentationError::init_builtin_type();
-        let tab_error = PyTabError::init_builtin_type();
-
-        let system_error = PySystemError::init_builtin_type();
-        let type_error = PyTypeError::init_builtin_type();
-        let value_error = PyValueError::init_builtin_type();
-        let unicode_error = PyUnicodeError::init_builtin_type();
-        let unicode_decode_error = PyUnicodeDecodeError::init_builtin_type();
-        let unicode_encode_error = PyUnicodeEncodeError::init_builtin_type();
-        let unicode_translate_error = PyUnicodeTranslateError::init_builtin_type();
-
-        #[cfg(feature = "jit")]
-        let jit_error = PyJitError::init_builtin_type();
-
-        let warning = PyWarning::init_builtin_type();
-        let deprecation_warning = PyDeprecationWarning::init_builtin_type();
-        let pending_deprecation_warning = PyPendingDeprecationWarning::init_builtin_type();
-        let runtime_warning = PyRuntimeWarning::init_builtin_type();
-        let syntax_warning = PySyntaxWarning::init_builtin_type();
-        let user_warning = PyUserWarning::init_builtin_type();
-        let future_warning = PyFutureWarning::init_builtin_type();
-        let import_warning = PyImportWarning::init_builtin_type();
-        let unicode_warning = PyUnicodeWarning::init_builtin_type();
-        let bytes_warning = PyBytesWarning::init_builtin_type();
-        let resource_warning = PyResourceWarning::init_builtin_type();
-        let encoding_warning = PyEncodingWarning::init_builtin_type();
-
-        Self {
-            base_exception_type,
-            base_exception_group,
-            exception_group,
-            system_exit,
-            keyboard_interrupt,
-            generator_exit,
-            exception_type,
-            stop_iteration,
-            stop_async_iteration,
-            arithmetic_error,
-            floating_point_error,
-            overflow_error,
-            zero_division_error,
-            assertion_error,
-            attribute_error,
-            buffer_error,
-            eof_error,
-            import_error,
-            module_not_found_error,
-            lookup_error,
-            index_error,
-            key_error,
-            memory_error,
-            name_error,
-            unbound_local_error,
-            os_error,
-            blocking_io_error,
-            child_process_error,
-            connection_error,
-            broken_pipe_error,
-            connection_aborted_error,
-            connection_refused_error,
-            connection_reset_error,
-            file_exists_error,
-            file_not_found_error,
-            interrupted_error,
-            is_a_directory_error,
-            not_a_directory_error,
-            permission_error,
-            process_lookup_error,
-            timeout_error,
-            reference_error,
-            runtime_error,
-            not_implemented_error,
-            recursion_error,
-            syntax_error,
-            incomplete_input_error,
-            indentation_error,
-            tab_error,
-            system_error,
-            type_error,
-            value_error,
-            unicode_error,
-            unicode_decode_error,
-            unicode_encode_error,
-            unicode_translate_error,
-
-            #[cfg(feature = "jit")]
-            jit_error,
-
-            warning,
-            deprecation_warning,
-            pending_deprecation_warning,
-            runtime_warning,
-            syntax_warning,
-            user_warning,
-            future_warning,
-            import_warning,
-            unicode_warning,
-            bytes_warning,
-            resource_warning,
-            encoding_warning,
-        }
-    }
-
-    // TODO: remove it after fixing `errno` / `winerror` problem
-    #[allow(clippy::redundant_clone)]
-    pub fn extend(ctx: &Context) {
-        use self::types::*;
-
-        let excs = &ctx.exceptions;
-
-        PyBaseException::extend_class(ctx, excs.base_exception_type);
-
-        // Sorted By Hierarchy then alphabetized.
-        extend_exception!(PyBaseExceptionGroup, ctx, excs.base_exception_group, {
-            "message" => ctx.new_readonly_getset("message", excs.base_exception_group, make_arg_getter(0)),
-            "exceptions" => ctx.new_readonly_getset("exceptions", excs.base_exception_group, make_arg_getter(1)),
-        });
-        extend_exception!(PyExceptionGroup, ctx, excs.exception_group);
-        extend_exception!(PySystemExit, ctx, excs.system_exit, {
-            "code" => ctx.new_readonly_getset("code", excs.system_exit, system_exit_code),
-        });
-        extend_exception!(PyKeyboardInterrupt, ctx, excs.keyboard_interrupt);
-        extend_exception!(PyGeneratorExit, ctx, excs.generator_exit);
-
-        extend_exception!(PyException, ctx, excs.exception_type);
-
-        extend_exception!(PyStopIteration, ctx, excs.stop_iteration, {
-            "value" => ctx.none(),
-        });
-        extend_exception!(PyStopAsyncIteration, ctx, excs.stop_async_iteration);
-
-        extend_exception!(PyArithmeticError, ctx, excs.arithmetic_error);
-        extend_exception!(PyFloatingPointError, ctx, excs.floating_point_error);
-        extend_exception!(PyOverflowError, ctx, excs.overflow_error);
-        extend_exception!(PyZeroDivisionError, ctx, excs.zero_division_error);
-
-        extend_exception!(PyAssertionError, ctx, excs.assertion_error);
-        extend_exception!(PyAttributeError, ctx, excs.attribute_error, {
-            "name" => ctx.none(),
-            "obj" => ctx.none(),
-        });
-        extend_exception!(PyBufferError, ctx, excs.buffer_error);
-        extend_exception!(PyEOFError, ctx, excs.eof_error);
-
-        extend_exception!(PyImportError, ctx, excs.import_error, {
-            "msg" => ctx.new_readonly_getset("msg", excs.import_error, make_arg_getter(0)),
-            "name" => ctx.none(),
-            "path" => ctx.none(),
-        });
-        extend_exception!(PyModuleNotFoundError, ctx, excs.module_not_found_error);
-
-        extend_exception!(PyLookupError, ctx, excs.lookup_error);
-        extend_exception!(PyIndexError, ctx, excs.index_error);
-
-        extend_exception!(PyKeyError, ctx, excs.key_error);
-
-        extend_exception!(PyMemoryError, ctx, excs.memory_error);
-        extend_exception!(PyNameError, ctx, excs.name_error, {
-            "name" => ctx.none(),
-        });
-        extend_exception!(PyUnboundLocalError, ctx, excs.unbound_local_error);
-
-        // os errors:
-        let errno_getter =
-            ctx.new_readonly_getset("errno", excs.os_error, |exc: PyBaseExceptionRef| {
-                let args = exc.args();
-                args.first()
-                    .filter(|_| args.len() > 1 && args.len() <= 5)
-                    .cloned()
-            });
-        let strerror_getter =
-            ctx.new_readonly_getset("strerror", excs.os_error, |exc: PyBaseExceptionRef| {
-                let args = exc.args();
-                args.get(1)
-                    .filter(|_| args.len() >= 2 && args.len() <= 5)
-                    .cloned()
-            });
-        extend_exception!(PyOSError, ctx, excs.os_error, {
-            // POSIX exception code
-            "errno" => errno_getter.clone(),
-            // exception strerror
-            "strerror" => strerror_getter.clone(),
-            // exception filename
-            "filename" => ctx.none(),
-            // second exception filename
-            "filename2" => ctx.none(),
-        });
-        #[cfg(windows)]
-        excs.os_error.set_str_attr("winerror", ctx.none(), ctx);
-
-        extend_exception!(PyBlockingIOError, ctx, excs.blocking_io_error);
-        extend_exception!(PyChildProcessError, ctx, excs.child_process_error);
-
-        extend_exception!(PyConnectionError, ctx, excs.connection_error);
-        extend_exception!(PyBrokenPipeError, ctx, excs.broken_pipe_error);
-        extend_exception!(PyConnectionAbortedError, ctx, excs.connection_aborted_error);
-        extend_exception!(PyConnectionRefusedError, ctx, excs.connection_refused_error);
-        extend_exception!(PyConnectionResetError, ctx, excs.connection_reset_error);
-
-        extend_exception!(PyFileExistsError, ctx, excs.file_exists_error);
-        extend_exception!(PyFileNotFoundError, ctx, excs.file_not_found_error);
-        extend_exception!(PyInterruptedError, ctx, excs.interrupted_error);
-        extend_exception!(PyIsADirectoryError, ctx, excs.is_a_directory_error);
-        extend_exception!(PyNotADirectoryError, ctx, excs.not_a_directory_error);
-        extend_exception!(PyPermissionError, ctx, excs.permission_error);
-        extend_exception!(PyProcessLookupError, ctx, excs.process_lookup_error);
-        extend_exception!(PyTimeoutError, ctx, excs.timeout_error);
-
-        extend_exception!(PyReferenceError, ctx, excs.reference_error);
-        extend_exception!(PyRuntimeError, ctx, excs.runtime_error);
-        extend_exception!(PyNotImplementedError, ctx, excs.not_implemented_error);
-        extend_exception!(PyRecursionError, ctx, excs.recursion_error);
-
-        extend_exception!(PySyntaxError, ctx, excs.syntax_error, {
-            "msg" => ctx.new_readonly_getset("msg", excs.syntax_error, make_arg_getter(0)),
-            // TODO: members
-            "filename" => ctx.none(),
-            "lineno" => ctx.none(),
-            "end_lineno" => ctx.none(),
-            "offset" => ctx.none(),
-            "end_offset" => ctx.none(),
-            "text" => ctx.none(),
-        });
-        extend_exception!(PyIncompleteInputError, ctx, excs.incomplete_input_error);
-        extend_exception!(PyIndentationError, ctx, excs.indentation_error);
-        extend_exception!(PyTabError, ctx, excs.tab_error);
-
-        extend_exception!(PySystemError, ctx, excs.system_error);
-        extend_exception!(PyTypeError, ctx, excs.type_error);
-        extend_exception!(PyValueError, ctx, excs.value_error);
-        extend_exception!(PyUnicodeError, ctx, excs.unicode_error);
-        extend_exception!(PyUnicodeDecodeError, ctx, excs.unicode_decode_error);
-        extend_exception!(PyUnicodeEncodeError, ctx, excs.unicode_encode_error);
-        extend_exception!(PyUnicodeTranslateError, ctx, excs.unicode_translate_error);
-
-        #[cfg(feature = "jit")]
-        extend_exception!(PyJitError, ctx, excs.jit_error);
-
-        extend_exception!(PyWarning, ctx, excs.warning);
-        extend_exception!(PyDeprecationWarning, ctx, excs.deprecation_warning);
-        extend_exception!(
-            PyPendingDeprecationWarning,
-            ctx,
-            excs.pending_deprecation_warning
-        );
-        extend_exception!(PyRuntimeWarning, ctx, excs.runtime_warning);
-        extend_exception!(PySyntaxWarning, ctx, excs.syntax_warning);
-        extend_exception!(PyUserWarning, ctx, excs.user_warning);
-        extend_exception!(PyFutureWarning, ctx, excs.future_warning);
-        extend_exception!(PyImportWarning, ctx, excs.import_warning);
-        extend_exception!(PyUnicodeWarning, ctx, excs.unicode_warning);
-        extend_exception!(PyBytesWarning, ctx, excs.bytes_warning);
-        extend_exception!(PyResourceWarning, ctx, excs.resource_warning);
-        extend_exception!(PyEncodingWarning, ctx, excs.encoding_warning);
-    }
-}
-
-fn make_arg_getter(idx: usize) -> impl Fn(PyBaseExceptionRef) -> Option<PyObjectRef> {
-    move |exc| exc.get_arg(idx)
-}
-
-fn system_exit_code(exc: PyBaseExceptionRef) -> Option<PyObjectRef> {
-    exc.args.read().first().map(|code| {
-        match_class!(match code {
-            ref tup @ PyTuple => match tup.as_slice() {
-                [x] => x.clone(),
-                _ => code.clone(),
-            },
-            other => other.clone(),
-        })
-    })
-}
-
-#[cfg(feature = "serde")]
-pub struct SerializeException<'vm, 's> {
-    vm: &'vm VirtualMachine,
-    exc: &'s PyBaseExceptionRef,
-}
-
-#[cfg(feature = "serde")]
-impl<'vm, 's> SerializeException<'vm, 's> {
-    pub fn new(vm: &'vm VirtualMachine, exc: &'s PyBaseExceptionRef) -> Self {
-        SerializeException { vm, exc }
-    }
-}
-
-#[cfg(feature = "serde")]
-pub struct SerializeExceptionOwned<'vm> {
-    vm: &'vm VirtualMachine,
-    exc: PyBaseExceptionRef,
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for SerializeExceptionOwned<'_> {
-    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        let Self { vm, exc } = self;
-        SerializeException::new(vm, exc).serialize(s)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl serde::Serialize for SerializeException<'_, '_> {
-    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-        use serde::ser::*;
-
-        let mut struc = s.serialize_struct("PyBaseException", 7)?;
-        struc.serialize_field("exc_type", &*self.exc.class().name())?;
-        let tbs = {
-            struct Tracebacks(PyTracebackRef);
-            impl serde::Serialize for Tracebacks {
-                fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-                    let mut s = s.serialize_seq(None)?;
-                    for tb in self.0.iter() {
-                        s.serialize_element(&**tb)?;
-                    }
-                    s.end()
-                }
-            }
-            self.exc.__traceback__().map(Tracebacks)
-        };
-        struc.serialize_field("traceback", &tbs)?;
-        struc.serialize_field(
-            "cause",
-            &self
-                .exc
-                .__cause__()
-                .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }),
-        )?;
-        struc.serialize_field(
-            "context",
-            &self
-                .exc
-                .__context__()
-                .map(|exc| SerializeExceptionOwned { vm: self.vm, exc }),
-        )?;
-        struc.serialize_field("suppress_context", &self.exc.get_suppress_context())?;
-
-        let args = {
-            struct Args<'vm>(&'vm VirtualMachine, PyTupleRef);
-            impl serde::Serialize for Args<'_> {
-                fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
-                    s.collect_seq(
-                        self.1
-                            .iter()
-                            .map(|arg| crate::py_serde::PyObjectSerializer::new(self.0, arg)),
-                    )
-                }
-            }
-            Args(self.vm, self.exc.args())
-        };
-        struc.serialize_field("args", &args)?;
-
-        let rendered = {
-            let mut rendered = String::new();
-            self.vm
-                .write_exception(&mut rendered, self.exc)
-                .map_err(S::Error::custom)?;
-            rendered
-        };
-        struc.serialize_field("rendered", &rendered)?;
-
-        struc.end()
-    }
-}
-
-pub fn cstring_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
-    vm.new_value_error("embedded null character")
-}
-
-impl ToPyException for std::ffi::NulError {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        cstring_error(vm)
-    }
-}
-
-#[cfg(windows)]
-impl<C> ToPyException for widestring::error::ContainsNul<C> {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        cstring_error(vm)
-    }
-}
-
-#[cfg(any(unix, windows, target_os = "wasi"))]
-pub(crate) fn errno_to_exc_type(errno: i32, vm: &VirtualMachine) -> Option<&'static Py<PyType>> {
-    use crate::stdlib::errno::errors;
-    let excs = &vm.ctx.exceptions;
-    match errno {
-        #[allow(unreachable_patterns)] // EAGAIN is sometimes the same as EWOULDBLOCK
-        errors::EWOULDBLOCK | errors::EAGAIN => Some(excs.blocking_io_error),
-        errors::EALREADY => Some(excs.blocking_io_error),
-        errors::EINPROGRESS => Some(excs.blocking_io_error),
-        errors::EPIPE => Some(excs.broken_pipe_error),
-        #[cfg(not(target_os = "wasi"))]
-        errors::ESHUTDOWN => Some(excs.broken_pipe_error),
-        errors::ECHILD => Some(excs.child_process_error),
-        errors::ECONNABORTED => Some(excs.connection_aborted_error),
-        errors::ECONNREFUSED => Some(excs.connection_refused_error),
-        errors::ECONNRESET => Some(excs.connection_reset_error),
-        errors::EEXIST => Some(excs.file_exists_error),
-        errors::ENOENT => Some(excs.file_not_found_error),
-        errors::EISDIR => Some(excs.is_a_directory_error),
-        errors::ENOTDIR => Some(excs.not_a_directory_error),
-        errors::EINTR => Some(excs.interrupted_error),
-        errors::EACCES => Some(excs.permission_error),
-        errors::EPERM => Some(excs.permission_error),
-        errors::ESRCH => Some(excs.process_lookup_error),
-        errors::ETIMEDOUT => Some(excs.timeout_error),
-        _ => None,
-    }
-}
-
-#[cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
-pub(crate) fn errno_to_exc_type(_errno: i32, _vm: &VirtualMachine) -> Option<&'static Py<PyType>> {
-    None
-}
-
-pub(super) mod types {
-    use crate::common::lock::PyRwLock;
-    #[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
-    use crate::{
-        AsObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
-        builtins::{
-            PyGenericAlias, PyInt, PyStrRef, PyTupleRef, PyTypeRef, traceback::PyTracebackRef,
-            tuple::IntoPyTuple,
-        },
-        convert::ToPyResult,
-        function::{ArgBytesLike, FuncArgs},
-        types::{Constructor, Initializer},
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use itertools::Itertools;
-    use rustpython_common::str::UnicodeEscapeCodepoint;
-
-    // This module is designed to be used as `use builtins::*;`.
-    // Do not add any pub symbols not included in builtins module.
-    // `PyBaseExceptionRef` is the only exception.
-
-    pub type PyBaseExceptionRef = PyRef<PyBaseException>;
-
-    // Sorted By Hierarchy then alphabetized.
-
-    #[pyclass(module = false, name = "BaseException", traverse = "manual")]
-    pub struct PyBaseException {
-        pub(super) traceback: PyRwLock<Option<PyTracebackRef>>,
-        pub(super) cause: PyRwLock<Option<PyRef<Self>>>,
-        pub(super) context: PyRwLock<Option<PyRef<Self>>>,
-        pub(super) suppress_context: AtomicCell<bool>,
-        pub(super) args: PyRwLock<PyTupleRef>,
-    }
-
-    #[pyexception(name, base = "PyBaseException", ctx = "system_exit", impl)]
-    #[derive(Debug)]
-    pub struct PySystemExit {}
-
-    #[pyexception(name, base = "PyBaseException", ctx = "base_exception_group")]
-    #[derive(Debug)]
-    pub struct PyBaseExceptionGroup {}
-
-    #[pyexception]
-    impl PyBaseExceptionGroup {
-        #[pyclassmethod]
-        fn __class_getitem__(
-            cls: PyTypeRef,
-            args: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyGenericAlias {
-            PyGenericAlias::from_args(cls, args, vm)
-        }
-    }
-
-    #[pyexception(name, base = "PyBaseExceptionGroup", ctx = "exception_group", impl)]
-    #[derive(Debug)]
-    pub struct PyExceptionGroup {}
-
-    #[pyexception(name, base = "PyBaseException", ctx = "generator_exit", impl)]
-    #[derive(Debug)]
-    pub struct PyGeneratorExit {}
-
-    #[pyexception(name, base = "PyBaseException", ctx = "keyboard_interrupt", impl)]
-    #[derive(Debug)]
-    pub struct PyKeyboardInterrupt {}
-
-    #[pyexception(name, base = "PyBaseException", ctx = "exception_type", impl)]
-    #[derive(Debug)]
-    pub struct PyException {}
-
-    #[pyexception(name, base = "PyException", ctx = "stop_iteration")]
-    #[derive(Debug)]
-    pub struct PyStopIteration {}
-
-    #[pyexception]
-    impl PyStopIteration {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
-            zelf.set_attr("value", vm.unwrap_or_none(args.args.first().cloned()), vm)?;
-            Ok(())
-        }
-    }
-
-    #[pyexception(name, base = "PyException", ctx = "stop_async_iteration", impl)]
-    #[derive(Debug)]
-    pub struct PyStopAsyncIteration {}
-
-    #[pyexception(name, base = "PyException", ctx = "arithmetic_error", impl)]
-    #[derive(Debug)]
-    pub struct PyArithmeticError {}
-
-    #[pyexception(name, base = "PyArithmeticError", ctx = "floating_point_error", impl)]
-    #[derive(Debug)]
-    pub struct PyFloatingPointError {}
-
-    #[pyexception(name, base = "PyArithmeticError", ctx = "overflow_error", impl)]
-    #[derive(Debug)]
-    pub struct PyOverflowError {}
-
-    #[pyexception(name, base = "PyArithmeticError", ctx = "zero_division_error", impl)]
-    #[derive(Debug)]
-    pub struct PyZeroDivisionError {}
-
-    #[pyexception(name, base = "PyException", ctx = "assertion_error", impl)]
-    #[derive(Debug)]
-    pub struct PyAssertionError {}
-
-    #[pyexception(name, base = "PyException", ctx = "attribute_error")]
-    #[derive(Debug)]
-    pub struct PyAttributeError {}
-
-    #[pyexception]
-    impl PyAttributeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
-            zelf.set_attr(
-                "name",
-                vm.unwrap_or_none(args.kwargs.get("name").cloned()),
-                vm,
-            )?;
-            zelf.set_attr(
-                "obj",
-                vm.unwrap_or_none(args.kwargs.get("obj").cloned()),
-                vm,
-            )?;
-            Ok(())
-        }
-    }
-
-    #[pyexception(name, base = "PyException", ctx = "buffer_error", impl)]
-    #[derive(Debug)]
-    pub struct PyBufferError {}
-
-    #[pyexception(name, base = "PyException", ctx = "eof_error", impl)]
-    #[derive(Debug)]
-    pub struct PyEOFError {}
-
-    #[pyexception(name, base = "PyException", ctx = "import_error")]
-    #[derive(Debug)]
-    pub struct PyImportError {}
-
-    #[pyexception]
-    impl PyImportError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: ::rustpython_vm::function::FuncArgs,
-            vm: &::rustpython_vm::VirtualMachine,
-        ) -> ::rustpython_vm::PyResult<()> {
-            let mut kwargs = args.kwargs.clone();
-            let name = kwargs.swap_remove("name");
-            let path = kwargs.swap_remove("path");
-
-            // Check for any remaining invalid keyword arguments
-            if let Some(invalid_key) = kwargs.keys().next() {
-                return Err(vm.new_type_error(format!(
-                    "'{invalid_key}' is an invalid keyword argument for ImportError"
-                )));
-            }
-
-            zelf.set_attr("name", vm.unwrap_or_none(name), vm)?;
-            zelf.set_attr("path", vm.unwrap_or_none(path), vm)?;
-            PyBaseException::slot_init(zelf, args, vm)
-        }
-        #[pymethod]
-        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
-            let obj = exc.as_object().to_owned();
-            let mut result: Vec<PyObjectRef> = vec![
-                obj.class().to_owned().into(),
-                vm.new_tuple((exc.get_arg(0).unwrap(),)).into(),
-            ];
-
-            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
-                result.push(dict.into());
-            }
-
-            result.into_pytuple(vm)
-        }
-    }
-
-    #[pyexception(name, base = "PyImportError", ctx = "module_not_found_error", impl)]
-    #[derive(Debug)]
-    pub struct PyModuleNotFoundError {}
-
-    #[pyexception(name, base = "PyException", ctx = "lookup_error", impl)]
-    #[derive(Debug)]
-    pub struct PyLookupError {}
-
-    #[pyexception(name, base = "PyLookupError", ctx = "index_error", impl)]
-    #[derive(Debug)]
-    pub struct PyIndexError {}
-
-    #[pyexception(name, base = "PyLookupError", ctx = "key_error")]
-    #[derive(Debug)]
-    pub struct PyKeyError {}
-
-    #[pyexception]
-    impl PyKeyError {
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyStrRef {
-            let args = exc.args();
-            if args.len() == 1 {
-                vm.exception_args_as_string(args, false)
-                    .into_iter()
-                    .exactly_one()
-                    .unwrap()
-            } else {
-                exc.__str__(vm)
-            }
-        }
-    }
-
-    #[pyexception(name, base = "PyException", ctx = "memory_error", impl)]
-    #[derive(Debug)]
-    pub struct PyMemoryError {}
-
-    #[pyexception(name, base = "PyException", ctx = "name_error", impl)]
-    #[derive(Debug)]
-    pub struct PyNameError {}
-
-    #[pyexception(name, base = "PyNameError", ctx = "unbound_local_error", impl)]
-    #[derive(Debug)]
-    pub struct PyUnboundLocalError {}
-
-    #[pyexception(name, base = "PyException", ctx = "os_error")]
-    #[derive(Debug)]
-    pub struct PyOSError {}
-
-    // OS Errors:
-    #[pyexception]
-    impl PyOSError {
-        #[cfg(not(target_arch = "wasm32"))]
-        fn optional_new(args: Vec<PyObjectRef>, vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
-            let len = args.len();
-            if (2..=5).contains(&len) {
-                let errno = &args[0];
-                errno
-                    .payload_if_subclass::<PyInt>(vm)
-                    .and_then(|errno| errno.try_to_primitive::<i32>(vm).ok())
-                    .and_then(|errno| super::errno_to_exc_type(errno, vm))
-                    .and_then(|typ| vm.invoke_exception(typ.to_owned(), args.to_vec()).ok())
-            } else {
-                None
-            }
-        }
-        #[cfg(not(target_arch = "wasm32"))]
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            // We need this method, because of how `CPython` copies `init`
-            // from `BaseException` in `SimpleExtendsException` macro.
-            // See: `BaseException_new`
-            if *cls.name() == *vm.ctx.exceptions.os_error.name() {
-                match Self::optional_new(args.args.to_vec(), vm) {
-                    Some(error) => error.to_pyresult(vm),
-                    None => PyBaseException::slot_new(cls, args, vm),
-                }
-            } else {
-                PyBaseException::slot_new(cls, args, vm)
-            }
-        }
-        #[cfg(target_arch = "wasm32")]
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            PyBaseException::slot_new(cls, args, vm)
-        }
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let len = args.args.len();
-            let mut new_args = args;
-            if (3..=5).contains(&len) {
-                zelf.set_attr("filename", new_args.args[2].clone(), vm)?;
-                #[cfg(windows)]
-                if let Some(winerror) = new_args.args.get(3) {
-                    zelf.set_attr("winerror", winerror.clone(), vm)?;
-                }
-                if let Some(filename2) = new_args.args.get(4) {
-                    zelf.set_attr("filename2", filename2.clone(), vm)?;
-                }
-
-                new_args.args.truncate(2);
-            }
-            PyBaseException::slot_init(zelf, new_args, vm)
-        }
-
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-            let args = exc.args();
-            let obj = exc.as_object().to_owned();
-
-            if args.len() == 2 {
-                // SAFETY: len() == 2 is checked so get_arg 1 or 2 won't panic
-                let errno = exc.get_arg(0).unwrap().str(vm)?;
-                let msg = exc.get_arg(1).unwrap().str(vm)?;
-
-                let s = match obj.get_attr("filename", vm) {
-                    Ok(filename) => match obj.get_attr("filename2", vm) {
-                        Ok(filename2) if !vm.is_none(&filename2) => format!(
-                            "[Errno {}] {}: '{}' -> '{}'",
-                            errno,
-                            msg,
-                            filename.str(vm)?,
-                            filename2.str(vm)?
-                        ),
-                        _ => format!("[Errno {}] {}: '{}'", errno, msg, filename.str(vm)?),
-                    },
-                    Err(_) => {
-                        format!("[Errno {errno}] {msg}")
-                    }
-                };
-                Ok(vm.ctx.new_str(s))
-            } else {
-                Ok(exc.__str__(vm))
-            }
-        }
-
-        #[pymethod]
-        fn __reduce__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyTupleRef {
-            let args = exc.args();
-            let obj = exc.as_object().to_owned();
-            let mut result: Vec<PyObjectRef> = vec![obj.class().to_owned().into()];
-
-            if args.len() >= 2 && args.len() <= 5 {
-                // SAFETY: len() == 2 is checked so get_arg 1 or 2 won't panic
-                let errno = exc.get_arg(0).unwrap();
-                let msg = exc.get_arg(1).unwrap();
-
-                if let Ok(filename) = obj.get_attr("filename", vm) {
-                    if !vm.is_none(&filename) {
-                        let mut args_reduced: Vec<PyObjectRef> = vec![errno, msg, filename];
-
-                        if let Ok(filename2) = obj.get_attr("filename2", vm) {
-                            if !vm.is_none(&filename2) {
-                                args_reduced.push(filename2);
-                            }
-                        }
-                        result.push(args_reduced.into_pytuple(vm).into());
-                    } else {
-                        result.push(vm.new_tuple((errno, msg)).into());
-                    }
-                } else {
-                    result.push(vm.new_tuple((errno, msg)).into());
-                }
-            } else {
-                result.push(args.into());
-            }
-
-            if let Some(dict) = obj.dict().filter(|x| !x.is_empty()) {
-                result.push(dict.into());
-            }
-            result.into_pytuple(vm)
-        }
-    }
-
-    #[pyexception(name, base = "PyOSError", ctx = "blocking_io_error", impl)]
-    #[derive(Debug)]
-    pub struct PyBlockingIOError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "child_process_error", impl)]
-    #[derive(Debug)]
-    pub struct PyChildProcessError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "connection_error", impl)]
-    #[derive(Debug)]
-    pub struct PyConnectionError {}
-
-    #[pyexception(name, base = "PyConnectionError", ctx = "broken_pipe_error", impl)]
-    #[derive(Debug)]
-    pub struct PyBrokenPipeError {}
-
-    #[pyexception(
-        name,
-        base = "PyConnectionError",
-        ctx = "connection_aborted_error",
-        impl
-    )]
-    #[derive(Debug)]
-    pub struct PyConnectionAbortedError {}
-
-    #[pyexception(
-        name,
-        base = "PyConnectionError",
-        ctx = "connection_refused_error",
-        impl
-    )]
-    #[derive(Debug)]
-    pub struct PyConnectionRefusedError {}
-
-    #[pyexception(name, base = "PyConnectionError", ctx = "connection_reset_error", impl)]
-    #[derive(Debug)]
-    pub struct PyConnectionResetError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "file_exists_error", impl)]
-    #[derive(Debug)]
-    pub struct PyFileExistsError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "file_not_found_error", impl)]
-    #[derive(Debug)]
-    pub struct PyFileNotFoundError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "interrupted_error", impl)]
-    #[derive(Debug)]
-    pub struct PyInterruptedError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "is_a_directory_error", impl)]
-    #[derive(Debug)]
-    pub struct PyIsADirectoryError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "not_a_directory_error", impl)]
-    #[derive(Debug)]
-    pub struct PyNotADirectoryError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "permission_error", impl)]
-    #[derive(Debug)]
-    pub struct PyPermissionError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "process_lookup_error", impl)]
-    #[derive(Debug)]
-    pub struct PyProcessLookupError {}
-
-    #[pyexception(name, base = "PyOSError", ctx = "timeout_error", impl)]
-    #[derive(Debug)]
-    pub struct PyTimeoutError {}
-
-    #[pyexception(name, base = "PyException", ctx = "reference_error", impl)]
-    #[derive(Debug)]
-    pub struct PyReferenceError {}
-
-    #[pyexception(name, base = "PyException", ctx = "runtime_error", impl)]
-    #[derive(Debug)]
-    pub struct PyRuntimeError {}
-
-    #[pyexception(name, base = "PyRuntimeError", ctx = "not_implemented_error", impl)]
-    #[derive(Debug)]
-    pub struct PyNotImplementedError {}
-
-    #[pyexception(name, base = "PyRuntimeError", ctx = "recursion_error", impl)]
-    #[derive(Debug)]
-    pub struct PyRecursionError {}
-
-    #[pyexception(name, base = "PyException", ctx = "syntax_error")]
-    #[derive(Debug)]
-    pub struct PySyntaxError {}
-
-    #[pyexception]
-    impl PySyntaxError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let len = args.args.len();
-            let new_args = args;
-
-            zelf.set_attr("print_file_and_line", vm.ctx.none(), vm)?;
-
-            if len == 2 {
-                if let Ok(location_tuple) = new_args.args[1]
-                    .clone()
-                    .downcast::<crate::builtins::PyTuple>()
-                {
-                    let location_tup_len = location_tuple.len();
-                    for (i, &attr) in [
-                        "filename",
-                        "lineno",
-                        "offset",
-                        "text",
-                        "end_lineno",
-                        "end_offset",
-                    ]
-                    .iter()
-                    .enumerate()
-                    {
-                        if location_tup_len > i {
-                            zelf.set_attr(attr, location_tuple[i].to_owned(), vm)?;
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            }
-
-            PyBaseException::slot_init(zelf, new_args, vm)
-        }
-
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyStrRef {
-            fn basename(filename: &str) -> &str {
-                let splitted = if cfg!(windows) {
-                    filename.rsplit(&['/', '\\']).next()
-                } else {
-                    filename.rsplit('/').next()
-                };
-                splitted.unwrap_or(filename)
-            }
-
-            let maybe_lineno = exc.as_object().get_attr("lineno", vm).ok().map(|obj| {
-                obj.str(vm)
-                    .unwrap_or_else(|_| vm.ctx.new_str("<lineno str() failed>"))
-            });
-            let maybe_filename = exc.as_object().get_attr("filename", vm).ok().map(|obj| {
-                obj.str(vm)
-                    .unwrap_or_else(|_| vm.ctx.new_str("<filename str() failed>"))
-            });
-
-            let args = exc.args();
-
-            let msg = if args.len() == 1 {
-                vm.exception_args_as_string(args, false)
-                    .into_iter()
-                    .exactly_one()
-                    .unwrap()
-            } else {
-                return exc.__str__(vm);
-            };
-
-            let msg_with_location_info: String = match (maybe_lineno, maybe_filename) {
-                (Some(lineno), Some(filename)) => {
-                    format!("{} ({}, line {})", msg, basename(filename.as_str()), lineno)
-                }
-                (Some(lineno), None) => {
-                    format!("{msg} (line {lineno})")
-                }
-                (None, Some(filename)) => {
-                    format!("{} ({})", msg, basename(filename.as_str()))
-                }
-                (None, None) => msg.to_string(),
-            };
-
-            vm.ctx.new_str(msg_with_location_info)
-        }
-    }
-
-    #[pyexception(
-        name = "_IncompleteInputError",
-        base = "PySyntaxError",
-        ctx = "incomplete_input_error"
-    )]
-    #[derive(Debug)]
-    pub struct PyIncompleteInputError {}
-
-    #[pyexception]
-    impl PyIncompleteInputError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            _args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            zelf.set_attr("name", vm.ctx.new_str("SyntaxError"), vm)?;
-            Ok(())
-        }
-    }
-
-    #[pyexception(name, base = "PySyntaxError", ctx = "indentation_error", impl)]
-    #[derive(Debug)]
-    pub struct PyIndentationError {}
-
-    #[pyexception(name, base = "PyIndentationError", ctx = "tab_error", impl)]
-    #[derive(Debug)]
-    pub struct PyTabError {}
-
-    #[pyexception(name, base = "PyException", ctx = "system_error", impl)]
-    #[derive(Debug)]
-    pub struct PySystemError {}
-
-    #[pyexception(name, base = "PyException", ctx = "type_error", impl)]
-    #[derive(Debug)]
-    pub struct PyTypeError {}
-
-    #[pyexception(name, base = "PyException", ctx = "value_error", impl)]
-    #[derive(Debug)]
-    pub struct PyValueError {}
-
-    #[pyexception(name, base = "PyValueError", ctx = "unicode_error", impl)]
-    #[derive(Debug)]
-    pub struct PyUnicodeError {}
-
-    #[pyexception(name, base = "PyUnicodeError", ctx = "unicode_decode_error")]
-    #[derive(Debug)]
-    pub struct PyUnicodeDecodeError {}
-
-    #[pyexception]
-    impl PyUnicodeDecodeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, ArgBytesLike, isize, isize, PyStrRef);
-            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
-            zelf.set_attr("encoding", encoding, vm)?;
-            let object_as_bytes = vm.ctx.new_bytes(object.borrow_buf().to_vec());
-            zelf.set_attr("object", object_as_bytes, vm)?;
-            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
-            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
-            zelf.set_attr("reason", reason, vm)?;
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
-            };
-            let object: ArgBytesLike = object.try_into_value(vm)?;
-            let encoding: PyStrRef = exc
-                .as_object()
-                .get_attr("encoding", vm)?
-                .try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.len() && end <= object.len() && end == start + 1 {
-                let b = object.borrow_buf()[start];
-                Ok(format!(
-                    "'{encoding}' codec can't decode byte {b:#02x} in position {start}: {reason}"
-                ))
-            } else {
-                Ok(format!(
-                    "'{encoding}' codec can't decode bytes in position {start}-{}: {reason}",
-                    end - 1,
-                ))
-            }
-        }
-    }
-
-    #[pyexception(name, base = "PyUnicodeError", ctx = "unicode_encode_error")]
-    #[derive(Debug)]
-    pub struct PyUnicodeEncodeError {}
-
-    #[pyexception]
-    impl PyUnicodeEncodeError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, PyStrRef, isize, isize, PyStrRef);
-            let (encoding, object, start, end, reason): Args = args.bind(vm)?;
-            zelf.set_attr("encoding", encoding, vm)?;
-            zelf.set_attr("object", object, vm)?;
-            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
-            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
-            zelf.set_attr("reason", reason, vm)?;
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
-            };
-            let object: PyStrRef = object.try_into_value(vm)?;
-            let encoding: PyStrRef = exc
-                .as_object()
-                .get_attr("encoding", vm)?
-                .try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.char_len() && end <= object.char_len() && end == start + 1 {
-                let ch = object.as_wtf8().code_points().nth(start).unwrap();
-                Ok(format!(
-                    "'{encoding}' codec can't encode character '{}' in position {start}: {reason}",
-                    UnicodeEscapeCodepoint(ch)
-                ))
-            } else {
-                Ok(format!(
-                    "'{encoding}' codec can't encode characters in position {start}-{}: {reason}",
-                    end - 1,
-                ))
-            }
-        }
-    }
-
-    #[pyexception(name, base = "PyUnicodeError", ctx = "unicode_translate_error")]
-    #[derive(Debug)]
-    pub struct PyUnicodeTranslateError {}
-
-    #[pyexception]
-    impl PyUnicodeTranslateError {
-        #[pyslot]
-        #[pymethod(name = "__init__")]
-        pub(crate) fn slot_init(
-            zelf: PyObjectRef,
-            args: FuncArgs,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            type Args = (PyStrRef, isize, isize, PyStrRef);
-            let (object, start, end, reason): Args = args.bind(vm)?;
-            zelf.set_attr("object", object, vm)?;
-            zelf.set_attr("start", vm.ctx.new_int(start), vm)?;
-            zelf.set_attr("end", vm.ctx.new_int(end), vm)?;
-            zelf.set_attr("reason", reason, vm)?;
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __str__(exc: PyBaseExceptionRef, vm: &VirtualMachine) -> PyResult<String> {
-            let Ok(object) = exc.as_object().get_attr("object", vm) else {
-                return Ok("".to_owned());
-            };
-            let object: PyStrRef = object.try_into_value(vm)?;
-            let start: usize = exc.as_object().get_attr("start", vm)?.try_into_value(vm)?;
-            let end: usize = exc.as_object().get_attr("end", vm)?.try_into_value(vm)?;
-            let reason: PyStrRef = exc.as_object().get_attr("reason", vm)?.try_into_value(vm)?;
-            if start < object.char_len() && end <= object.char_len() && end == start + 1 {
-                let ch = object.as_wtf8().code_points().nth(start).unwrap();
-                Ok(format!(
-                    "can't translate character '{}' in position {start}: {reason}",
-                    UnicodeEscapeCodepoint(ch)
-                ))
-            } else {
-                Ok(format!(
-                    "can't translate characters in position {start}-{}: {reason}",
-                    end - 1,
-                ))
-            }
-        }
-    }
-
-    /// JIT error.
-    #[cfg(feature = "jit")]
-    #[pyexception(name, base = "PyException", ctx = "jit_error", impl)]
-    #[derive(Debug)]
-    pub struct PyJitError {}
-
-    // Warnings
-    #[pyexception(name, base = "PyException", ctx = "warning", impl)]
-    #[derive(Debug)]
-    pub struct PyWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "deprecation_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyDeprecationWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "pending_deprecation_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyPendingDeprecationWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "runtime_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyRuntimeWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "syntax_warning", impl)]
-    #[derive(Debug)]
-    pub struct PySyntaxWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "user_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyUserWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "future_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyFutureWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "import_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyImportWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "unicode_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyUnicodeWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "bytes_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyBytesWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "resource_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyResourceWarning {}
-
-    #[pyexception(name, base = "PyWarning", ctx = "encoding_warning", impl)]
-    #[derive(Debug)]
-    pub struct PyEncodingWarning {}
-}
diff --git a/vm/src/format.rs b/vm/src/format.rs
deleted file mode 100644
index f95f161f7a..0000000000
--- a/vm/src/format.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-use crate::{
-    PyObject, PyResult, VirtualMachine,
-    builtins::PyBaseExceptionRef,
-    convert::{IntoPyException, ToPyException},
-    function::FuncArgs,
-    stdlib::builtins,
-};
-
-use crate::common::format::*;
-use crate::common::wtf8::{Wtf8, Wtf8Buf};
-
-impl IntoPyException for FormatSpecError {
-    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        match self {
-            Self::DecimalDigitsTooMany => {
-                vm.new_value_error("Too many decimal digits in format string")
-            }
-            Self::PrecisionTooBig => vm.new_value_error("Precision too big"),
-            Self::InvalidFormatSpecifier => vm.new_value_error("Invalid format specifier"),
-            Self::UnspecifiedFormat(c1, c2) => {
-                let msg = format!("Cannot specify '{c1}' with '{c2}'.");
-                vm.new_value_error(msg)
-            }
-            Self::ExclusiveFormat(c1, c2) => {
-                let msg = format!("Cannot specify both '{c1}' and '{c2}'.");
-                vm.new_value_error(msg)
-            }
-            Self::UnknownFormatCode(c, s) => {
-                let msg = format!("Unknown format code '{c}' for object of type '{s}'");
-                vm.new_value_error(msg)
-            }
-            Self::PrecisionNotAllowed => {
-                vm.new_value_error("Precision not allowed in integer format specifier")
-            }
-            Self::NotAllowed(s) => {
-                let msg = format!("{s} not allowed with integer format specifier 'c'");
-                vm.new_value_error(msg)
-            }
-            Self::UnableToConvert => vm.new_value_error("Unable to convert int to float"),
-            Self::CodeNotInRange => vm.new_overflow_error("%c arg not in range(0x110000)"),
-            Self::ZeroPadding => {
-                vm.new_value_error("Zero padding is not allowed in complex format specifier")
-            }
-            Self::AlignmentFlag => {
-                vm.new_value_error("'=' alignment flag is not allowed in complex format specifier")
-            }
-            Self::NotImplemented(c, s) => {
-                let msg = format!("Format code '{c}' for object of type '{s}' not implemented yet");
-                vm.new_value_error(msg)
-            }
-        }
-    }
-}
-
-impl ToPyException for FormatParseError {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        match self {
-            Self::UnmatchedBracket => vm.new_value_error("expected '}' before end of string"),
-            _ => vm.new_value_error("Unexpected error parsing format string"),
-        }
-    }
-}
-
-fn format_internal(
-    vm: &VirtualMachine,
-    format: &FormatString,
-    field_func: &mut impl FnMut(FieldType) -> PyResult,
-) -> PyResult<Wtf8Buf> {
-    let mut final_string = Wtf8Buf::new();
-    for part in &format.format_parts {
-        let pystr;
-        let result_string: &Wtf8 = match part {
-            FormatPart::Field {
-                field_name,
-                conversion_spec,
-                format_spec,
-            } => {
-                let FieldName { field_type, parts } =
-                    FieldName::parse(field_name).map_err(|e| e.to_pyexception(vm))?;
-
-                let mut argument = field_func(field_type)?;
-
-                for name_part in parts {
-                    match name_part {
-                        FieldNamePart::Attribute(attribute) => {
-                            argument = argument.get_attr(&vm.ctx.new_str(attribute), vm)?;
-                        }
-                        FieldNamePart::Index(index) => {
-                            argument = argument.get_item(&index, vm)?;
-                        }
-                        FieldNamePart::StringIndex(index) => {
-                            argument = argument.get_item(&index, vm)?;
-                        }
-                    }
-                }
-
-                let nested_format =
-                    FormatString::from_str(format_spec).map_err(|e| e.to_pyexception(vm))?;
-                let format_spec = format_internal(vm, &nested_format, field_func)?;
-
-                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::Bytes) => {
-                        vm.call_method(&argument, identifier!(vm, decode).as_str(), ())?
-                    }
-                    None => argument,
-                };
-
-                // FIXME: compiler can intern specs using parser tree. Then this call can be interned_str
-                pystr = vm.format(&argument, vm.ctx.new_str(format_spec))?;
-                pystr.as_ref()
-            }
-            FormatPart::Literal(literal) => literal,
-        };
-        final_string.push_wtf8(result_string);
-    }
-    Ok(final_string)
-}
-
-pub(crate) fn format(
-    format: &FormatString,
-    arguments: &FuncArgs,
-    vm: &VirtualMachine,
-) -> PyResult<Wtf8Buf> {
-    let mut auto_argument_index: usize = 0;
-    let mut seen_index = false;
-    format_internal(vm, format, &mut |field_type| match field_type {
-        FieldType::Auto => {
-            if seen_index {
-                return Err(vm.new_value_error(
-                    "cannot switch from manual field specification to automatic field numbering",
-                ));
-            }
-            auto_argument_index += 1;
-            arguments
-                .args
-                .get(auto_argument_index - 1)
-                .cloned()
-                .ok_or_else(|| vm.new_index_error("tuple index out of range"))
-        }
-        FieldType::Index(index) => {
-            if auto_argument_index != 0 {
-                return Err(vm.new_value_error(
-                    "cannot switch from automatic field numbering to manual field specification",
-                ));
-            }
-            seen_index = true;
-            arguments
-                .args
-                .get(index)
-                .cloned()
-                .ok_or_else(|| vm.new_index_error("tuple index out of range"))
-        }
-        FieldType::Keyword(keyword) => keyword
-            .as_str()
-            .ok()
-            .and_then(|keyword| arguments.get_optional_kwarg(keyword))
-            .ok_or_else(|| vm.new_key_error(vm.ctx.new_str(keyword).into())),
-    })
-}
-
-pub(crate) fn format_map(
-    format: &FormatString,
-    dict: &PyObject,
-    vm: &VirtualMachine,
-) -> PyResult<Wtf8Buf> {
-    format_internal(vm, format, &mut |field_type| match field_type {
-        FieldType::Auto | FieldType::Index(_) => {
-            Err(vm.new_value_error("Format string contains positional fields"))
-        }
-        FieldType::Keyword(keyword) => dict.get_item(&keyword, vm),
-    })
-}
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
deleted file mode 100644
index 3b69de8fd3..0000000000
--- a/vm/src/frame.rs
+++ /dev/null
@@ -1,2350 +0,0 @@
-use crate::common::{boxvec::BoxVec, lock::PyMutex};
-use crate::protocol::PyMapping;
-use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{
-        PyBaseExceptionRef, PyCode, PyCoroutine, PyDict, PyDictRef, PyGenerator, PyList, PySet,
-        PySlice, PyStr, PyStrInterned, PyStrRef, PyTraceback, PyType,
-        asyncgenerator::PyAsyncGenWrappedValue,
-        function::{PyCell, PyCellRef, PyFunction},
-        tuple::{PyTuple, PyTupleRef, PyTupleTyped},
-    },
-    bytecode,
-    convert::{IntoObject, ToPyResult},
-    coroutine::Coro,
-    exceptions::ExceptionCtor,
-    function::{ArgMapping, Either, FuncArgs},
-    protocol::{PyIter, PyIterReturn},
-    scope::Scope,
-    source::SourceLocation,
-    stdlib::{builtins, typing},
-    vm::{Context, PyMethod},
-};
-use indexmap::IndexMap;
-use itertools::Itertools;
-use rustpython_common::wtf8::Wtf8Buf;
-#[cfg(feature = "threading")]
-use std::sync::atomic;
-use std::{fmt, iter::zip};
-
-#[derive(Clone, Debug)]
-struct Block {
-    /// The type of block.
-    typ: BlockType,
-    /// The level of the value stack when the block was entered.
-    level: usize,
-}
-
-#[derive(Clone, Debug)]
-enum BlockType {
-    Loop,
-    TryExcept {
-        handler: bytecode::Label,
-    },
-    Finally {
-        handler: bytecode::Label,
-    },
-
-    /// Active finally sequence
-    FinallyHandler {
-        reason: Option<UnwindReason>,
-        prev_exc: Option<PyBaseExceptionRef>,
-    },
-    ExceptHandler {
-        prev_exc: Option<PyBaseExceptionRef>,
-    },
-}
-
-pub type FrameRef = PyRef<Frame>;
-
-/// The reason why we might be unwinding a block.
-/// This could be return of function, exception being
-/// raised, a break or continue being hit, etc..
-#[derive(Clone, Debug)]
-enum UnwindReason {
-    /// We are returning a value from a return statement.
-    Returning { value: PyObjectRef },
-
-    /// We hit an exception, so unwind any try-except and finally blocks. The exception should be
-    /// on top of the vm exception stack.
-    Raising { exception: PyBaseExceptionRef },
-
-    // NoWorries,
-    /// We are unwinding blocks, since we hit break
-    Break { target: bytecode::Label },
-
-    /// We are unwinding blocks since we hit a continue statements.
-    Continue { target: bytecode::Label },
-}
-
-#[derive(Debug)]
-struct FrameState {
-    // We need 1 stack per frame
-    /// The main data frame of the stack machine
-    stack: BoxVec<PyObjectRef>,
-    /// Block frames, for controlling loops and exceptions
-    blocks: Vec<Block>,
-    /// index of last instruction ran
-    #[cfg(feature = "threading")]
-    lasti: u32,
-}
-
-#[cfg(feature = "threading")]
-type Lasti = atomic::AtomicU32;
-#[cfg(not(feature = "threading"))]
-type Lasti = std::cell::Cell<u32>;
-
-#[pyclass(module = false, name = "frame")]
-pub struct Frame {
-    pub code: PyRef<PyCode>,
-    pub func_obj: Option<PyObjectRef>,
-
-    pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
-    pub(crate) cells_frees: Box<[PyCellRef]>,
-    pub locals: ArgMapping,
-    pub globals: PyDictRef,
-    pub builtins: PyDictRef,
-
-    // 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,
-    /// tracer function for this frame (usually is None)
-    pub trace: PyMutex<PyObjectRef>,
-    state: PyMutex<FrameState>,
-
-    // member
-    pub trace_lines: PyMutex<bool>,
-    pub temporary_refs: PyMutex<Vec<PyObjectRef>>,
-}
-
-impl PyPayload for Frame {
-    #[inline]
-    fn class(ctx: &Context) -> &'static Py<PyType> {
-        ctx.types.frame_type
-    }
-}
-
-// Running a frame can result in one of the below:
-pub enum ExecutionResult {
-    Return(PyObjectRef),
-    Yield(PyObjectRef),
-}
-
-/// A valid execution result, or an exception
-type FrameResult = PyResult<Option<ExecutionResult>>;
-
-impl Frame {
-    pub(crate) fn new(
-        code: PyRef<PyCode>,
-        scope: Scope,
-        builtins: PyDictRef,
-        closure: &[PyCellRef],
-        func_obj: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> Self {
-        let cells_frees = std::iter::repeat_with(|| PyCell::default().into_ref(&vm.ctx))
-            .take(code.cellvars.len())
-            .chain(closure.iter().cloned())
-            .collect();
-
-        let state = FrameState {
-            stack: BoxVec::new(code.max_stackdepth as usize),
-            blocks: Vec::new(),
-            #[cfg(feature = "threading")]
-            lasti: 0,
-        };
-
-        Self {
-            fastlocals: PyMutex::new(vec![None; code.varnames.len()].into_boxed_slice()),
-            cells_frees,
-            locals: scope.locals,
-            globals: scope.globals,
-            builtins,
-            code,
-            func_obj,
-            lasti: Lasti::new(0),
-            state: PyMutex::new(state),
-            trace: PyMutex::new(vm.ctx.none()),
-            trace_lines: PyMutex::new(true),
-            temporary_refs: PyMutex::new(vec![]),
-        }
-    }
-
-    pub fn current_location(&self) -> SourceLocation {
-        self.code.locations[self.lasti() as usize - 1].clone()
-    }
-
-    pub fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.lasti.load(atomic::Ordering::Relaxed)
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
-        }
-    }
-
-    pub fn locals(&self, vm: &VirtualMachine) -> PyResult<ArgMapping> {
-        let locals = &self.locals;
-        let code = &**self.code;
-        let map = &code.varnames;
-        let j = std::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),
-                }
-            }
-        }
-        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::IS_OPTIMIZED) {
-                map_to_dict(&code.freevars, &self.cells_frees[code.cellvars.len()..])?;
-            }
-        }
-        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)
-    }
-
-    // #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    pub fn run(&self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
-        self.with_exec(|mut exec| exec.run(vm))
-    }
-
-    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)
-        })
-    }
-
-    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))
-    }
-
-    pub fn yield_from_target(&self) -> Option<PyObjectRef> {
-        self.with_exec(|exec| 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")
-    }
-
-    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;
-                }
-            }
-        })
-    }
-}
-
-/// An executing frame; essentially just a struct to combine the immutable data outside the mutex
-/// with the mutable data inside
-struct ExecutingFrame<'a> {
-    code: &'a PyRef<PyCode>,
-    fastlocals: &'a PyMutex<Box<[Option<PyObjectRef>]>>,
-    cells_frees: &'a [PyCellRef],
-    locals: &'a ArgMapping,
-    globals: &'a PyDictRef,
-    builtins: &'a PyDictRef,
-    object: &'a Py<Frame>,
-    lasti: &'a Lasti,
-    state: &'a mut FrameState,
-}
-
-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)
-            .finish()
-    }
-}
-
-impl ExecutingFrame<'_> {
-    #[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);
-        }
-    }
-
-    #[inline(always)]
-    fn lasti(&self) -> u32 {
-        #[cfg(feature = "threading")]
-        {
-            self.state.lasti
-        }
-        #[cfg(not(feature = "threading"))]
-        {
-            self.lasti.get()
-        }
-    }
-
-    fn run(&mut self, vm: &VirtualMachine) -> PyResult<ExecutionResult> {
-        flame_guard!(format!(
-            "Frame::run({obj_name})",
-            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;
-            // eprintln!(
-            //     "location: {:?} {}",
-            //     self.code.locations[idx], self.code.source_path
-            // );
-            self.update_lasti(|i| *i += 1);
-            let bytecode::CodeUnit { op, arg } = instructions[idx];
-            let arg = arg_state.extend(arg);
-            let mut do_extend_arg = false;
-            let result = self.execute_instruction(op, arg, &mut do_extend_arg, vm);
-            match result {
-                Ok(None) => {}
-                Ok(Some(value)) => {
-                    break Ok(value);
-                }
-                // Instruction raised an exception
-                Err(exception) => {
-                    #[cold]
-                    fn handle_exception(
-                        frame: &mut ExecutingFrame<'_>,
-                        exception: PyBaseExceptionRef,
-                        idx: usize,
-                        vm: &VirtualMachine,
-                    ) -> FrameResult {
-                        // 1. Extract traceback from exception's '__traceback__' attr.
-                        // 2. Add new entry with current execution position (filename, lineno, code_object) to traceback.
-                        // 3. Unwind block stack till appropriate handler is found.
-
-                        let loc = frame.code.locations[idx].clone();
-                        let next = exception.__traceback__();
-                        let new_traceback =
-                            PyTraceback::new(next, frame.object.to_owned(), frame.lasti(), loc.row);
-                        vm_trace!("Adding to traceback: {:?} {:?}", new_traceback, loc.row);
-                        exception.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
-
-                        vm.contextualize_exception(&exception);
-
-                        frame.unwind_blocks(vm, UnwindReason::Raising { exception })
-                    }
-
-                    match handle_exception(self, exception, idx, vm) {
-                        Ok(None) => {}
-                        Ok(Some(result)) => break Ok(result),
-                        // TODO: append line number to traceback?
-                        // traceback.append();
-                        Err(exception) => break Err(exception),
-                    }
-                }
-            }
-            if !do_extend_arg {
-                arg_state.reset()
-            }
-        }
-    }
-
-    fn yield_from_target(&self) -> Option<&PyObject> {
-        if let Some(bytecode::CodeUnit {
-            op: bytecode::Instruction::YieldFrom,
-            ..
-        }) = self.code.instructions.get(self.lasti() as usize)
-        {
-            Some(self.top_value())
-        } else {
-            None
-        }
-    }
-
-    /// Ok(Err(e)) means that an error occurred while calling throw() and the generator should try
-    /// sending it
-    fn gen_throw(
-        &mut self,
-        vm: &VirtualMachine,
-        exc_type: PyObjectRef,
-        exc_val: PyObjectRef,
-        exc_tb: PyObjectRef,
-    ) -> PyResult<ExecutionResult> {
-        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))
-            } 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), // FIXME:
-                    Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
-                };
-                return ret.map(ExecutionResult::Yield).or_else(|err| {
-                    self.pop_value();
-                    self.update_lasti(|i| *i += 1);
-                    if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
-                        let val = vm.unwrap_or_none(err.get_arg(0));
-                        self.push_value(val);
-                        self.run(vm)
-                    } else {
-                        let (ty, val, tb) = vm.split_exception(err);
-                        self.gen_throw(vm, ty, val, tb)
-                    }
-                });
-            }
-        }
-        let exception = vm.normalize_exception(exc_type, exc_val, exc_tb)?;
-        match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
-            Ok(None) => self.run(vm),
-            Ok(Some(result)) => Ok(result),
-            Err(exception) => Err(exception),
-        }
-    }
-
-    fn unbound_cell_exception(&self, i: usize, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        if let Some(&name) = self.code.cellvars.get(i) {
-            vm.new_exception_msg(
-                vm.ctx.exceptions.unbound_local_error.to_owned(),
-                format!("local variable '{name}' referenced before assignment"),
-            )
-        } 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(),
-            )
-        }
-    }
-
-    /// Execute a single instruction.
-    #[inline(always)]
-    fn execute_instruction(
-        &mut self,
-        instruction: bytecode::Instruction,
-        arg: bytecode::OpArg,
-        extend_arg: &mut bool,
-        vm: &VirtualMachine,
-    ) -> FrameResult {
-        vm.check_signals()?;
-
-        flame_guard!(format!(
-            "Frame::execute_instruction({})",
-            instruction.display(arg, &self.code.code).to_string()
-        ));
-
-        #[cfg(feature = "vm-tracing-logging")]
-        {
-            trace!("=======");
-            /* TODO:
-            for frame in self.frames.iter() {
-                trace!("  {:?}", frame);
-            }
-            */
-            trace!("  {:#?}", self);
-            trace!(
-                "  Executing op code: {}",
-                instruction.display(arg, &self.code.code).to_string()
-            );
-            trace!("=======");
-        }
-
-        #[cold]
-        fn name_error(name: &'static PyStrInterned, vm: &VirtualMachine) -> PyBaseExceptionRef {
-            vm.new_name_error(format!("name '{name}' is not defined"), name.to_owned())
-        }
-
-        match instruction {
-            bytecode::Instruction::Nop => Ok(None),
-            bytecode::Instruction::LoadConst { idx } => {
-                self.push_value(self.code.constants[idx.get(arg) as usize].clone().into());
-                Ok(None)
-            }
-            bytecode::Instruction::ImportName { idx } => {
-                self.import(vm, Some(self.code.names[idx.get(arg) as usize]))?;
-                Ok(None)
-            }
-            bytecode::Instruction::ImportNameless => {
-                self.import(vm, None)?;
-                Ok(None)
-            }
-            bytecode::Instruction::ImportStar => {
-                self.import_star(vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::ImportFrom { idx } => {
-                let obj = self.import_from(vm, idx.get(arg))?;
-                self.push_value(obj);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadFast(idx) => {
-                #[cold]
-                fn reference_error(
-                    varname: &'static PyStrInterned,
-                    vm: &VirtualMachine,
-                ) -> PyBaseExceptionRef {
-                    vm.new_exception_msg(
-                        vm.ctx.exceptions.unbound_local_error.to_owned(),
-                        format!("local variable '{varname}' referenced before assignment",),
-                    )
-                }
-                let idx = idx.get(arg) as usize;
-                let x = self.fastlocals.lock()[idx]
-                    .clone()
-                    .ok_or_else(|| reference_error(self.code.varnames[idx], vm))?;
-                self.push_value(x);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadNameAny(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                let result = self.locals.mapping().subscript(name, vm);
-                match result {
-                    Ok(x) => self.push_value(x),
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                        self.push_value(self.load_global_or_builtin(name, vm)?);
-                    }
-                    Err(e) => return Err(e),
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::LoadGlobal(idx) => {
-                let name = &self.code.names[idx.get(arg) as usize];
-                let x = self.load_global_or_builtin(name, vm)?;
-                self.push_value(x);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadDeref(i) => {
-                let i = i.get(arg) as usize;
-                let x = self.cells_frees[i]
-                    .get()
-                    .ok_or_else(|| self.unbound_cell_exception(i, vm))?;
-                self.push_value(x);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadClassDeref(i) => {
-                let i = i.get(arg) as usize;
-                let name = self.code.freevars[i - self.code.cellvars.len()];
-                let value = self.locals.mapping().subscript(name, vm).ok();
-                self.push_value(match value {
-                    Some(v) => v,
-                    None => self.cells_frees[i]
-                        .get()
-                        .ok_or_else(|| self.unbound_cell_exception(i, vm))?,
-                });
-                Ok(None)
-            }
-            bytecode::Instruction::StoreFast(idx) => {
-                let value = self.pop_value();
-                self.fastlocals.lock()[idx.get(arg) as usize] = Some(value);
-                Ok(None)
-            }
-            bytecode::Instruction::StoreLocal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                let value = self.pop_value();
-                self.locals.mapping().ass_subscript(name, Some(value), vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::StoreGlobal(idx) => {
-                let value = self.pop_value();
-                self.globals
-                    .set_item(self.code.names[idx.get(arg) as usize], value, vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::StoreDeref(i) => {
-                let value = self.pop_value();
-                self.cells_frees[i.get(arg) as usize].set(Some(value));
-                Ok(None)
-            }
-            bytecode::Instruction::DeleteFast(idx) => {
-                let mut fastlocals = self.fastlocals.lock();
-                let idx = idx.get(arg) as usize;
-                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]
-                        ),
-                    ));
-                }
-                fastlocals[idx] = None;
-                Ok(None)
-            }
-            bytecode::Instruction::DeleteLocal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                let res = self.locals.mapping().ass_subscript(name, None, vm);
-
-                match res {
-                    Ok(()) => {}
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                        return Err(name_error(name, vm));
-                    }
-                    Err(e) => return Err(e),
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::DeleteGlobal(idx) => {
-                let name = self.code.names[idx.get(arg) as usize];
-                match self.globals.del_item(name, vm) {
-                    Ok(()) => {}
-                    Err(e) if e.fast_isinstance(vm.ctx.exceptions.key_error) => {
-                        return Err(name_error(name, vm));
-                    }
-                    Err(e) => return Err(e),
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::DeleteDeref(i) => {
-                self.cells_frees[i.get(arg) as usize].set(None);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadClosure(i) => {
-                let value = self.cells_frees[i.get(arg) as usize].clone();
-                self.push_value(value.into());
-                Ok(None)
-            }
-            bytecode::Instruction::Subscript => self.execute_subscript(vm),
-            bytecode::Instruction::StoreSubscript => self.execute_store_subscript(vm),
-            bytecode::Instruction::DeleteSubscript => self.execute_delete_subscript(vm),
-            bytecode::Instruction::CopyItem { index } => {
-                let value = self
-                    .state
-                    .stack
-                    .len()
-                    .checked_sub(index.get(arg) as usize)
-                    .map(|i| &self.state.stack[i])
-                    .unwrap();
-                self.push_value(value.clone());
-                Ok(None)
-            }
-            bytecode::Instruction::Pop => {
-                // Pop value from stack and ignore.
-                self.pop_value();
-                Ok(None)
-            }
-            bytecode::Instruction::Swap { index } => {
-                let len = self.state.stack.len();
-                let i = len - 1;
-                let j = len - 1 - index.get(arg) as usize;
-                self.state.stack.swap(i, j);
-                Ok(None)
-            }
-            // bytecode::Instruction::ToBool => {
-            //     dbg!("Shouldn't be called outside of match statements for now")
-            //     let value = self.pop_value();
-            //     // call __bool__
-            //     let result = value.try_to_bool(vm)?;
-            //     self.push_value(vm.ctx.new_bool(result).into());
-            //     Ok(None)
-            // }
-            bytecode::Instruction::Duplicate => {
-                // Duplicate top of stack
-                let value = self.top_value();
-                self.push_value(value.to_owned());
-                Ok(None)
-            }
-            bytecode::Instruction::Duplicate2 => {
-                // Duplicate top 2 of stack
-                let len = self.state.stack.len();
-                self.push_value(self.state.stack[len - 2].clone());
-                self.push_value(self.state.stack[len - 1].clone());
-                Ok(None)
-            }
-            // splitting the instructions like this offloads the cost of "dynamic" dispatch (on the
-            // amount to rotate) to the opcode dispatcher, and generates optimized code for the
-            // concrete cases we actually have
-            bytecode::Instruction::Rotate2 => self.execute_rotate(2),
-            bytecode::Instruction::Rotate3 => self.execute_rotate(3),
-            bytecode::Instruction::BuildString { size } => {
-                let s = self
-                    .pop_multiple(size.get(arg) as usize)
-                    .as_slice()
-                    .iter()
-                    .map(|pyobj| pyobj.payload::<PyStr>().unwrap())
-                    .collect::<Wtf8Buf>();
-                let str_obj = vm.ctx.new_str(s);
-                self.push_value(str_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildList { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildListFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_list(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSet { size } => {
-                let set = PySet::new_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    set.add(element, vm)?;
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSetFromTuples { size } => {
-                let set = PySet::new_ref(&vm.ctx);
-                for element in self.pop_multiple(size.get(arg) as usize) {
-                    // SAFETY: trust compiler
-                    let tup = unsafe { element.downcast_unchecked::<PyTuple>() };
-                    for item in tup.iter() {
-                        set.add(item.clone(), vm)?;
-                    }
-                }
-                self.push_value(set.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTuple { size } => {
-                let elements = self.pop_multiple(size.get(arg) as usize).collect();
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromTuples { size } => {
-                // SAFETY: compiler guarantees `size` tuples are on the stack
-                let elements = unsafe { self.flatten_tuples(size.get(arg) as usize) };
-                let list_obj = vm.ctx.new_tuple(elements);
-                self.push_value(list_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::BuildTupleFromIter => {
-                if !self.top_value().class().is(vm.ctx.types.tuple_type) {
-                    let elements: Vec<_> = self.pop_value().try_to_value(vm)?;
-                    let list_obj = vm.ctx.new_tuple(elements);
-                    self.push_value(list_obj.into());
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::BuildMap { size } => self.execute_build_map(vm, size.get(arg)),
-            bytecode::Instruction::BuildMapForCall { size } => {
-                self.execute_build_map_for_call(vm, size.get(arg))
-            }
-            bytecode::Instruction::DictUpdate => {
-                let other = self.pop_value();
-                let dict = self
-                    .top_value()
-                    .downcast_ref::<PyDict>()
-                    .expect("exact dict expected");
-
-                // For dictionary unpacking {**x}, x must be a mapping
-                // Check if the object has the mapping protocol (keys method)
-                if vm
-                    .get_method(other.clone(), vm.ctx.intern_str("keys"))
-                    .is_none()
-                {
-                    return Err(vm.new_type_error(format!(
-                        "'{}' object is not a mapping",
-                        other.class().name()
-                    )));
-                }
-
-                dict.merge_object(other, vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::BuildSlice { step } => {
-                self.execute_build_slice(vm, step.get(arg))
-            }
-            bytecode::Instruction::ListAppend { i } => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let list: &Py<PyList> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                list.append(item);
-                Ok(None)
-            }
-            bytecode::Instruction::SetAdd { i } => {
-                let item = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let set: &Py<PySet> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                set.add(item, vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::MapAdd { i } => {
-                let value = self.pop_value();
-                let key = self.pop_value();
-                let obj = self.nth_value(i.get(arg));
-                let dict: &Py<PyDict> = unsafe {
-                    // SAFETY: trust compiler
-                    obj.downcast_unchecked_ref()
-                };
-                dict.set_item(&*key, value, vm)?;
-                Ok(None)
-            }
-            bytecode::Instruction::BinaryOperation { op } => self.execute_bin_op(vm, op.get(arg)),
-            bytecode::Instruction::BinaryOperationInplace { op } => {
-                self.execute_bin_op_inplace(vm, op.get(arg))
-            }
-            bytecode::Instruction::BinarySubscript => {
-                let key = self.pop_value();
-                let container = self.pop_value();
-                self.state
-                    .stack
-                    .push(container.get_item(key.as_object(), vm)?);
-                Ok(None)
-            }
-            bytecode::Instruction::LoadAttr { idx } => self.load_attr(vm, idx.get(arg)),
-            bytecode::Instruction::StoreAttr { idx } => self.store_attr(vm, idx.get(arg)),
-            bytecode::Instruction::DeleteAttr { idx } => self.delete_attr(vm, idx.get(arg)),
-            bytecode::Instruction::UnaryOperation { op } => self.execute_unary_op(vm, op.get(arg)),
-            bytecode::Instruction::TestOperation { op } => self.execute_test(vm, op.get(arg)),
-            bytecode::Instruction::CompareOperation { op } => self.execute_compare(vm, op.get(arg)),
-            bytecode::Instruction::ReturnValue => {
-                let value = self.pop_value();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
-            }
-            bytecode::Instruction::ReturnConst { idx } => {
-                let value = self.code.constants[idx.get(arg) as usize].clone().into();
-                self.unwind_blocks(vm, UnwindReason::Returning { value })
-            }
-            bytecode::Instruction::YieldValue => {
-                let value = self.pop_value();
-                let value = if self.code.flags.contains(bytecode::CodeFlags::IS_COROUTINE) {
-                    PyAsyncGenWrappedValue(value).into_pyobject(vm)
-                } else {
-                    value
-                };
-                Ok(Some(ExecutionResult::Yield(value)))
-            }
-            bytecode::Instruction::YieldFrom => self.execute_yield_from(vm),
-            bytecode::Instruction::SetupAnnotation => self.setup_annotations(vm),
-            bytecode::Instruction::SetupLoop => {
-                self.push_block(BlockType::Loop);
-                Ok(None)
-            }
-            bytecode::Instruction::SetupExcept { handler } => {
-                self.push_block(BlockType::TryExcept {
-                    handler: handler.get(arg),
-                });
-                Ok(None)
-            }
-            bytecode::Instruction::SetupFinally { handler } => {
-                self.push_block(BlockType::Finally {
-                    handler: handler.get(arg),
-                });
-                Ok(None)
-            }
-            bytecode::Instruction::EnterFinally => {
-                self.push_block(BlockType::FinallyHandler {
-                    reason: None,
-                    prev_exc: vm.current_exception(),
-                });
-                Ok(None)
-            }
-            bytecode::Instruction::EndFinally => {
-                // Pop the finally handler from the stack, and recall
-                // what was the reason we were in this finally clause.
-                let block = self.pop_block();
-
-                if let BlockType::FinallyHandler { reason, prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    if let Some(reason) = reason {
-                        self.unwind_blocks(vm, reason)
-                    } else {
-                        Ok(None)
-                    }
-                } else {
-                    self.fatal(
-                        "Block type must be finally handler when reaching EndFinally instruction!",
-                    );
-                }
-            }
-            bytecode::Instruction::SetupWith { end } => {
-                let context_manager = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the context manager protocol",
-                        context_manager.class().name(),
-                    )
-                };
-                let enter_res = vm
-                    .get_special_method(&context_manager, identifier!(vm, __enter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-
-                let exit = context_manager
-                    .get_attr(identifier!(vm, __exit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __exit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(exit);
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
-                Ok(None)
-            }
-            bytecode::Instruction::BeforeAsyncWith => {
-                let mgr = self.pop_value();
-                let error_string = || -> String {
-                    format!(
-                        "'{:.200}' object does not support the asynchronous context manager protocol",
-                        mgr.class().name(),
-                    )
-                };
-
-                let aenter_res = vm
-                    .get_special_method(&mgr, identifier!(vm, __aenter__))?
-                    .ok_or_else(|| vm.new_type_error(error_string()))?
-                    .invoke((), vm)?;
-                let aexit = mgr
-                    .get_attr(identifier!(vm, __aexit__), vm)
-                    .map_err(|_exc| {
-                        vm.new_type_error({
-                            format!("{} (missed __aexit__ method)", error_string())
-                        })
-                    })?;
-                self.push_value(aexit);
-                self.push_value(aenter_res);
-
-                Ok(None)
-            }
-            bytecode::Instruction::SetupAsyncWith { end } => {
-                let enter_res = self.pop_value();
-                self.push_block(BlockType::Finally {
-                    handler: end.get(arg),
-                });
-                self.push_value(enter_res);
-                Ok(None)
-            }
-            bytecode::Instruction::WithCleanupStart => {
-                let block = self.current_block().unwrap();
-                let reason = match block.typ {
-                    BlockType::FinallyHandler { reason, .. } => reason,
-                    _ => self.fatal("WithCleanupStart expects a FinallyHandler block on stack"),
-                };
-                let exc = match reason {
-                    Some(UnwindReason::Raising { exception }) => Some(exception),
-                    _ => None,
-                };
-
-                let exit = self.top_value();
-
-                let args = if let Some(exc) = exc {
-                    vm.split_exception(exc)
-                } else {
-                    (vm.ctx.none(), vm.ctx.none(), vm.ctx.none())
-                };
-                let exit_res = exit.call(args, vm)?;
-                self.replace_top(exit_res);
-
-                Ok(None)
-            }
-            bytecode::Instruction::WithCleanupFinish => {
-                let block = self.pop_block();
-                let (reason, prev_exc) = match block.typ {
-                    BlockType::FinallyHandler { reason, prev_exc } => (reason, prev_exc),
-                    _ => self.fatal("WithCleanupFinish expects a FinallyHandler block on stack"),
-                };
-
-                vm.set_exception(prev_exc);
-
-                let suppress_exception = self.pop_value().try_to_bool(vm)?;
-
-                if suppress_exception {
-                    Ok(None)
-                } else if let Some(reason) = reason {
-                    self.unwind_blocks(vm, reason)
-                } else {
-                    Ok(None)
-                }
-            }
-            bytecode::Instruction::PopBlock => {
-                self.pop_block();
-                Ok(None)
-            }
-            bytecode::Instruction::GetIter => {
-                let iterated_obj = self.pop_value();
-                let iter_obj = iterated_obj.get_iter(vm)?;
-                self.push_value(iter_obj.into());
-                Ok(None)
-            }
-            bytecode::Instruction::GetLen => {
-                // STACK.append(len(STACK[-1]))
-                let obj = self.top_value();
-                let len = obj.length(vm)?;
-                self.push_value(vm.ctx.new_int(len).into());
-                Ok(None)
-            }
-            bytecode::Instruction::CallIntrinsic1 { func } => {
-                let value = self.pop_value();
-                let result = self.call_intrinsic_1(func.get(arg), value, vm)?;
-                self.push_value(result);
-                Ok(None)
-            }
-            bytecode::Instruction::CallIntrinsic2 { func } => {
-                let value2 = self.pop_value();
-                let value1 = self.pop_value();
-                let result = self.call_intrinsic_2(func.get(arg), value1, value2, vm)?;
-                self.push_value(result);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAwaitable => {
-                let awaited_obj = self.pop_value();
-                let awaitable = if awaited_obj.payload_is::<PyCoroutine>() {
-                    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(),
-                            )
-                        },
-                    )?;
-                    await_method.call((), vm)?
-                };
-                self.push_value(awaitable);
-                Ok(None)
-            }
-            bytecode::Instruction::GetAIter => {
-                let aiterable = self.pop_value();
-                let aiter = vm.call_special_method(&aiterable, identifier!(vm, __aiter__), ())?;
-                self.push_value(aiter);
-                Ok(None)
-            }
-            bytecode::Instruction::GetANext => {
-                #[cfg(debug_assertions)] // remove when GetANext is fully implemented
-                let orig_stack_len = self.state.stack.len();
-
-                let aiter = self.top_value();
-                let awaitable = if aiter.class().is(vm.ctx.types.async_generator) {
-                    vm.call_special_method(aiter, identifier!(vm, __anext__), ())?
-                } else {
-                    if !aiter.has_attr("__anext__", vm).unwrap_or(false) {
-                        // TODO: __anext__ must be protocol
-                        let msg = format!(
-                            "'async for' requires an iterator with __anext__ method, got {:.100}",
-                            aiter.class().name()
-                        );
-                        return Err(vm.new_type_error(msg));
-                    }
-                    let next_iter =
-                        vm.call_special_method(aiter, identifier!(vm, __anext__), ())?;
-
-                    // _PyCoro_GetAwaitableIter in CPython
-                    fn get_awaitable_iter(next_iter: &PyObject, vm: &VirtualMachine) -> PyResult {
-                        let gen_is_coroutine = |_| {
-                            // TODO: cpython gen_is_coroutine
-                            true
-                        };
-                        if next_iter.class().is(vm.ctx.types.coroutine_type)
-                            || gen_is_coroutine(next_iter)
-                        {
-                            return Ok(next_iter.to_owned());
-                        }
-                        // TODO: error handling
-                        vm.call_special_method(next_iter, identifier!(vm, __await__), ())
-                    }
-                    get_awaitable_iter(&next_iter, vm).map_err(|_| {
-                        vm.new_type_error(format!(
-                            "'async for' received an invalid object from __anext__: {:.200}",
-                            next_iter.class().name()
-                        ))
-                    })?
-                };
-                self.push_value(awaitable);
-                #[cfg(debug_assertions)]
-                debug_assert_eq!(orig_stack_len + 1, self.state.stack.len());
-                Ok(None)
-            }
-            bytecode::Instruction::EndAsyncFor => {
-                let exc = self.pop_value();
-                let except_block = self.pop_block(); // pushed by TryExcept unwind
-                debug_assert_eq!(except_block.level, self.state.stack.len());
-                let _async_iterator = self.pop_value(); // __anext__ provider in the loop
-                if exc.fast_isinstance(vm.ctx.exceptions.stop_async_iteration) {
-                    vm.take_exception().expect("Should have exception in stack");
-                    Ok(None)
-                } else {
-                    Err(exc.downcast().unwrap())
-                }
-            }
-            bytecode::Instruction::ForIter { target } => self.execute_for_iter(vm, target.get(arg)),
-            bytecode::Instruction::MakeFunction(flags) => {
-                self.execute_make_function(vm, flags.get(arg))
-            }
-            bytecode::Instruction::CallFunctionPositional { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionKeyword { nargs } => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::CallFunctionEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_call(args, vm)
-            }
-            bytecode::Instruction::LoadMethod { idx } => {
-                let obj = self.pop_value();
-                let method_name = self.code.names[idx.get(arg) as usize];
-                let method = PyMethod::get(obj, method_name, vm)?;
-                let (target, is_method, func) = match method {
-                    PyMethod::Function { target, func } => (target, true, func),
-                    PyMethod::Attribute(val) => (vm.ctx.none(), false, val),
-                };
-                // TODO: figure out a better way to communicate PyMethod::Attribute - CPython uses
-                // target==NULL, maybe we could use a sentinel value or something?
-                self.push_value(target);
-                self.push_value(vm.ctx.new_bool(is_method).into());
-                self.push_value(func);
-                Ok(None)
-            }
-            bytecode::Instruction::CallMethodPositional { nargs } => {
-                let args = self.collect_positional_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodKeyword { nargs } => {
-                let args = self.collect_keyword_args(nargs.get(arg));
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::CallMethodEx { has_kwargs } => {
-                let args = self.collect_ex_args(vm, has_kwargs.get(arg))?;
-                self.execute_method_call(args, vm)
-            }
-            bytecode::Instruction::Jump { target } => {
-                self.jump(target.get(arg));
-                Ok(None)
-            }
-            bytecode::Instruction::JumpIfTrue { target } => self.jump_if(vm, target.get(arg), true),
-            bytecode::Instruction::JumpIfFalse { target } => {
-                self.jump_if(vm, target.get(arg), false)
-            }
-            bytecode::Instruction::JumpIfTrueOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), true)
-            }
-            bytecode::Instruction::JumpIfFalseOrPop { target } => {
-                self.jump_if_or_pop(vm, target.get(arg), false)
-            }
-
-            bytecode::Instruction::Raise { kind } => self.execute_raise(vm, kind.get(arg)),
-
-            bytecode::Instruction::Break { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Break {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::Continue { target } => self.unwind_blocks(
-                vm,
-                UnwindReason::Continue {
-                    target: target.get(arg),
-                },
-            ),
-            bytecode::Instruction::PrintExpr => self.print_expr(vm),
-            bytecode::Instruction::LoadBuildClass => {
-                self.push_value(vm.builtins.get_attr(identifier!(vm, __build_class__), vm)?);
-                Ok(None)
-            }
-            bytecode::Instruction::UnpackSequence { size } => {
-                self.unpack_sequence(size.get(arg), vm)
-            }
-            bytecode::Instruction::UnpackEx { args } => {
-                let args = args.get(arg);
-                self.execute_unpack_ex(vm, args.before, args.after)
-            }
-            bytecode::Instruction::FormatValue { conversion } => {
-                self.format_value(conversion.get(arg), vm)
-            }
-            bytecode::Instruction::PopException => {
-                let block = self.pop_block();
-                if let BlockType::ExceptHandler { prev_exc } = block.typ {
-                    vm.set_exception(prev_exc);
-                    Ok(None)
-                } else {
-                    self.fatal("block type must be ExceptHandler here.")
-                }
-            }
-            bytecode::Instruction::Reverse { amount } => {
-                let stack_len = self.state.stack.len();
-                self.state.stack[stack_len - amount.get(arg) as usize..stack_len].reverse();
-                Ok(None)
-            }
-            bytecode::Instruction::ExtendedArg => {
-                *extend_arg = true;
-                Ok(None)
-            }
-            bytecode::Instruction::TypeVar => {
-                let type_name = self.pop_value();
-                let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, type_name.clone(), vm.ctx.none(), vm.ctx.none())
-                        .into_ref(&vm.ctx)
-                        .into();
-                self.push_value(type_var);
-                Ok(None)
-            }
-            bytecode::Instruction::TypeVarWithBound => {
-                let type_name = self.pop_value();
-                let bound = self.pop_value();
-                let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, type_name.clone(), bound, vm.ctx.none())
-                        .into_ref(&vm.ctx)
-                        .into();
-                self.push_value(type_var);
-                Ok(None)
-            }
-            bytecode::Instruction::TypeVarWithConstraint => {
-                let type_name = self.pop_value();
-                let constraint = self.pop_value();
-                let type_var: PyObjectRef =
-                    typing::TypeVar::new(vm, type_name.clone(), vm.ctx.none(), constraint)
-                        .into_ref(&vm.ctx)
-                        .into();
-                self.push_value(type_var);
-                Ok(None)
-            }
-            bytecode::Instruction::TypeAlias => {
-                let name = self.pop_value();
-                let type_params_obj = self.pop_value();
-
-                // CPython allows None or tuple for type_params
-                let type_params: PyTupleRef = if vm.is_none(&type_params_obj) {
-                    // If None, use empty tuple (matching CPython's behavior)
-                    vm.ctx.empty_tuple.clone()
-                } else {
-                    type_params_obj
-                        .downcast()
-                        .map_err(|_| vm.new_type_error("Type params must be a tuple."))?
-                };
-
-                let value = self.pop_value();
-                let type_alias = typing::TypeAliasType::new(name, type_params, value);
-                self.push_value(type_alias.into_ref(&vm.ctx).into());
-                Ok(None)
-            }
-            bytecode::Instruction::ParamSpec => {
-                let param_spec_name = self.pop_value();
-                let param_spec: PyObjectRef = typing::ParamSpec::new(param_spec_name.clone(), vm)
-                    .into_ref(&vm.ctx)
-                    .into();
-                self.push_value(param_spec);
-                Ok(None)
-            }
-            bytecode::Instruction::TypeVarTuple => {
-                let type_var_tuple_name = self.pop_value();
-                let type_var_tuple: PyObjectRef =
-                    typing::TypeVarTuple::new(type_var_tuple_name.clone(), vm)
-                        .into_ref(&vm.ctx)
-                        .into();
-                self.push_value(type_var_tuple);
-                Ok(None)
-            }
-            bytecode::Instruction::MatchMapping => {
-                // Pop the subject from stack
-                let subject = self.pop_value();
-
-                // Decide if it's a mapping, push True/False or handle error
-                let is_mapping = PyMapping::check(&subject);
-                self.push_value(vm.ctx.new_bool(is_mapping).into());
-                Ok(None)
-            }
-            bytecode::Instruction::MatchSequence => {
-                // Pop the subject from stack
-                let subject = self.pop_value();
-
-                // Decide if it's a sequence (but not a mapping)
-                let is_sequence = subject.to_sequence().check();
-                self.push_value(vm.ctx.new_bool(is_sequence).into());
-                Ok(None)
-            }
-            bytecode::Instruction::MatchKeys => {
-                // Typically we pop a sequence of keys first
-                let _keys = self.pop_value();
-                let subject = self.pop_value();
-
-                // Check if subject is a dict (or mapping) and all keys match
-                if let Ok(_dict) = subject.downcast::<PyDict>() {
-                    // Example: gather the values corresponding to keys
-                    // If keys match, push the matched values & success
-                    self.push_value(vm.ctx.new_bool(true).into());
-                } else {
-                    // Push a placeholder to indicate no match
-                    self.push_value(vm.ctx.new_bool(false).into());
-                }
-                Ok(None)
-            }
-            bytecode::Instruction::MatchClass(_arg) => {
-                // STACK[-1] is a tuple of keyword attribute names, STACK[-2] is the class being matched against, and STACK[-3] is the match subject.
-                // count is the number of positional sub-patterns.
-                // Pop STACK[-1], STACK[-2], and STACK[-3].
-                let names = self.pop_value();
-                let names = names.downcast_ref::<PyTuple>().unwrap();
-                let cls = self.pop_value();
-                let subject = self.pop_value();
-                // If STACK[-3] is an instance of STACK[-2] and has the positional and keyword attributes required by count and STACK[-1],
-                // push a tuple of extracted attributes.
-                if subject.is_instance(cls.as_ref(), vm)? {
-                    let mut extracted = vec![];
-                    for name in names.iter() {
-                        let name_str = name.downcast_ref::<PyStr>().unwrap();
-                        let value = subject.get_attr(name_str, vm)?;
-                        extracted.push(value);
-                    }
-                    self.push_value(vm.ctx.new_tuple(extracted).into());
-                } else {
-                    // Otherwise, push None.
-                    self.push_value(vm.ctx.none());
-                }
-                Ok(None)
-            }
-        }
-    }
-
-    #[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())
-            })
-    }
-
-    unsafe fn flatten_tuples(&mut self, size: usize) -> Vec<PyObjectRef> {
-        let mut elements = Vec::new();
-        for tup in self.pop_multiple(size) {
-            // SAFETY: caller ensures that the elements are tuples
-            let tup = unsafe { tup.downcast_unchecked::<PyTuple>() };
-            elements.extend(tup.iter().cloned());
-        }
-        elements
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn import(&mut self, vm: &VirtualMachine, module_name: Option<&Py<PyStr>>) -> PyResult<()> {
-        let module_name = module_name.unwrap_or(vm.ctx.empty_str);
-        let from_list = <Option<PyTupleTyped<PyStrRef>>>::try_from_object(vm, self.pop_value())?
-            .unwrap_or_else(|| PyTupleTyped::empty(vm));
-        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];
-        let err = || vm.new_import_error(format!("cannot import name '{name}'"), name.to_owned());
-        // 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 mod_name = module
-            .get_attr(identifier!(vm, __name__), vm)
-            .map_err(|_| err())?;
-        let mod_name = mod_name.downcast::<PyStr>().map_err(|_| err())?;
-        let full_mod_name = format!("{mod_name}.{name}");
-        let sys_modules = vm.sys_module.get_attr("modules", vm).map_err(|_| err())?;
-        sys_modules.get_item(&full_mod_name, vm).map_err(|_| err())
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn import_star(&mut self, vm: &VirtualMachine) -> PyResult<()> {
-        let module = self.pop_value();
-
-        // 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)?;
-                }
-            }
-        }
-        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 {
-        // First unwind all existing blocks on the block stack:
-        while let Some(block) = self.current_block() {
-            // eprintln!("unwinding block: {:.60?} {:.60?}", block.typ, reason);
-            match block.typ {
-                BlockType::Loop => match reason {
-                    UnwindReason::Break { target } => {
-                        self.pop_block();
-                        self.jump(target);
-                        return Ok(None);
-                    }
-                    UnwindReason::Continue { target } => {
-                        self.jump(target);
-                        return Ok(None);
-                    }
-                    _ => {
-                        self.pop_block();
-                    }
-                },
-                BlockType::Finally { handler } => {
-                    self.pop_block();
-                    let prev_exc = vm.current_exception();
-                    if let UnwindReason::Raising { exception } = &reason {
-                        vm.set_exception(Some(exception.clone()));
-                    }
-                    self.push_block(BlockType::FinallyHandler {
-                        reason: Some(reason),
-                        prev_exc,
-                    });
-                    self.jump(handler);
-                    return Ok(None);
-                }
-                BlockType::TryExcept { handler } => {
-                    self.pop_block();
-                    if let UnwindReason::Raising { exception } = reason {
-                        self.push_block(BlockType::ExceptHandler {
-                            prev_exc: vm.current_exception(),
-                        });
-                        vm.contextualize_exception(&exception);
-                        vm.set_exception(Some(exception.clone()));
-                        self.push_value(exception.into());
-                        self.jump(handler);
-                        return Ok(None);
-                    }
-                }
-                BlockType::FinallyHandler { prev_exc, .. }
-                | BlockType::ExceptHandler { prev_exc } => {
-                    self.pop_block();
-                    vm.set_exception(prev_exc);
-                }
-            }
-        }
-
-        // We do not have any more blocks to unwind. Inspect the reason we are here:
-        match reason {
-            UnwindReason::Raising { exception } => Err(exception),
-            UnwindReason::Returning { value } => Ok(Some(ExecutionResult::Return(value))),
-            UnwindReason::Break { .. } | UnwindReason::Continue { .. } => {
-                self.fatal("break or continue must occur within a loop block.")
-            } // UnwindReason::NoWorries => Ok(None),
-        }
-    }
-
-    #[inline(always)]
-    fn execute_rotate(&mut self, amount: usize) -> FrameResult {
-        let i = self.state.stack.len() - amount;
-        self.state.stack[i..].rotate_right(1);
-        Ok(None)
-    }
-
-    fn execute_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let b_ref = self.pop_value();
-        let a_ref = self.pop_value();
-        let value = a_ref.get_item(&*b_ref, vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
-    fn execute_store_subscript(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let idx = self.pop_value();
-        let obj = self.pop_value();
-        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_map_for_call(&mut self, vm: &VirtualMachine, size: u32) -> FrameResult {
-        let size = size as usize;
-        let map_obj = vm.ctx.new_dict();
-        for obj in self.pop_multiple(size) {
-            // Use keys() method for all mapping objects to preserve order
-            Self::iterate_mapping_keys(vm, &obj, "keyword argument", |key| {
-                // Check for keyword argument restrictions
-                if key.downcast_ref::<PyStr>().is_none() {
-                    return Err(vm.new_type_error("keywords must be strings"));
-                }
-                if map_obj.contains_key(&*key, vm) {
-                    let key_repr = &key.repr(vm)?;
-                    let msg = format!(
-                        "got multiple values for keyword argument {}",
-                        key_repr.as_str()
-                    );
-                    return Err(vm.new_type_error(msg));
-                }
-
-                let value = obj.get_item(&*key, vm)?;
-                map_obj.set_item(&*key, value, vm)?;
-                Ok(())
-            })?;
-        }
-
-        self.push_value(map_obj.into());
-        Ok(None)
-    }
-
-    fn execute_build_slice(&mut self, vm: &VirtualMachine, step: bool) -> FrameResult {
-        let step = if step { Some(self.pop_value()) } else { None };
-        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.payload::<PyStr>().unwrap().as_str().to_owned());
-        FuncArgs::with_kwargs_names(args, kwarg_names)
-    }
-
-    fn collect_ex_args(&mut self, vm: &VirtualMachine, has_kwargs: bool) -> PyResult<FuncArgs> {
-        let kwargs = if has_kwargs {
-            let kw_obj = self.pop_value();
-            let mut kwargs = IndexMap::new();
-
-            // Use keys() method for all mapping objects to preserve order
-            Self::iterate_mapping_keys(vm, &kw_obj, "argument after **", |key| {
-                let key_str = key
-                    .payload_if_subclass::<PyStr>(vm)
-                    .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()
-        };
-        // SAFETY: trust compiler
-        let args = unsafe { self.pop_value().downcast_unchecked::<PyTuple>() }
-            .as_slice()
-            .to_vec();
-        Ok(FuncArgs { args, kwargs })
-    }
-
-    /// 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: &PyObjectRef,
-        error_prefix: &str,
-        mut key_handler: F,
-    ) -> PyResult<()>
-    where
-        F: FnMut(PyObjectRef) -> PyResult<()>,
-    {
-        let Some(keys_method) = vm.get_method(mapping.clone(), vm.ctx.intern_str("keys")) else {
-            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)?;
-        }
-        Ok(())
-    }
-
-    #[inline]
-    fn execute_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
-        let func_ref = self.pop_value();
-        let value = func_ref.call(args, vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
-    #[inline]
-    fn execute_method_call(&mut self, args: FuncArgs, vm: &VirtualMachine) -> FrameResult {
-        let func = self.pop_value();
-        let is_method = self.pop_value().is(&vm.ctx.true_value);
-        let target = self.pop_value();
-
-        // TODO: It was PyMethod before #4873. Check if it's correct.
-        let func = if is_method {
-            if let Some(descr_get) = func.class().mro_find_map(|cls| cls.slots.descr_get.load()) {
-                let cls = target.class().to_owned().into();
-                descr_get(func, Some(target), Some(cls), vm)?
-            } else {
-                func
-            }
-        } else {
-            drop(target); // should be None
-            func
-        };
-        let value = func.call(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
-                    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
-            bytecode::RaiseKind::Raise | bytecode::RaiseKind::Reraise => None,
-        };
-        let exception = match kind {
-            bytecode::RaiseKind::RaiseCause | bytecode::RaiseKind::Raise => {
-                ExceptionCtor::try_from_object(vm, self.pop_value())?.instantiate(vm)?
-            }
-            bytecode::RaiseKind::Reraise => vm
-                .topmost_exception()
-                .ok_or_else(|| vm.new_runtime_error("No active exception to reraise"))?,
-        };
-        #[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),
-            // 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)
-            }
-        }
-    }
-
-    fn execute_yield_from(&mut self, vm: &VirtualMachine) -> FrameResult {
-        // Value send into iterator:
-        let val = self.pop_value();
-        let coro = self.top_value();
-        let result = self._send(coro, val, vm)?;
-
-        // PyIterReturn returned from e.g. gen.__next__() or gen.send()
-        match result {
-            PyIterReturn::Return(value) => {
-                // Set back program counter:
-                self.update_lasti(|i| *i -= 1);
-                Ok(Some(ExecutionResult::Yield(value)))
-            }
-            PyIterReturn::StopIteration(value) => {
-                let value = vm.unwrap_or_none(value);
-                self.replace_top(value);
-                Ok(None)
-            }
-        }
-    }
-
-    fn execute_unpack_ex(&mut self, vm: &VirtualMachine, before: u8, after: u8) -> FrameResult {
-        let (before, after) = (before as usize, after as usize);
-        let value = self.pop_value();
-        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());
-
-        let middle_elements = elements.drain(before..).collect();
-        let t = vm.ctx.new_list(middle_elements);
-        self.push_value(t.into());
-
-        // Lastly the first reversed values:
-        self.state.stack.extend(elements.into_iter().rev());
-
-        Ok(None)
-    }
-
-    #[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);
-    }
-
-    #[inline]
-    fn jump_if(&mut self, vm: &VirtualMachine, target: bytecode::Label, flag: bool) -> FrameResult {
-        let obj = self.pop_value();
-        let value = obj.try_to_bool(vm)?;
-        if value == flag {
-            self.jump(target);
-        }
-        Ok(None)
-    }
-
-    #[inline]
-    fn jump_if_or_pop(
-        &mut self,
-        vm: &VirtualMachine,
-        target: bytecode::Label,
-        flag: bool,
-    ) -> FrameResult {
-        let obj = self.top_value();
-        let value = obj.to_owned().try_to_bool(vm)?;
-        if value == flag {
-            self.jump(target);
-        } else {
-            self.pop_value();
-        }
-        Ok(None)
-    }
-
-    /// The top of stack contains the iterator, lets push it forward
-    fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult {
-        let top_of_stack = PyIter::new(self.top_value());
-        let next_obj = top_of_stack.next(vm);
-
-        // Check the next object:
-        match next_obj {
-            Ok(PyIterReturn::Return(value)) => {
-                self.push_value(value);
-                Ok(None)
-            }
-            Ok(PyIterReturn::StopIteration(_)) => {
-                // Pop iterator from stack:
-                self.pop_value();
-
-                // End of for loop
-                self.jump(target);
-                Ok(None)
-            }
-            Err(next_error) => {
-                // Pop iterator from stack:
-                self.pop_value();
-                Err(next_error)
-            }
-        }
-    }
-    fn execute_make_function(
-        &mut self,
-        vm: &VirtualMachine,
-        flags: bytecode::MakeFunctionFlags,
-    ) -> FrameResult {
-        let qualified_name = self
-            .pop_value()
-            .downcast::<PyStr>()
-            .expect("qualified name to be a string");
-        let code_obj: PyRef<PyCode> = self
-            .pop_value()
-            .downcast()
-            .expect("Second to top value on the stack must be a code object");
-
-        let closure = if flags.contains(bytecode::MakeFunctionFlags::CLOSURE) {
-            Some(PyTupleTyped::try_from_object(vm, self.pop_value()).unwrap())
-        } else {
-            None
-        };
-
-        let annotations = if flags.contains(bytecode::MakeFunctionFlags::ANNOTATIONS) {
-            self.pop_value()
-        } else {
-            vm.ctx.new_dict().into()
-        };
-
-        let type_params: PyTupleRef = if flags.contains(bytecode::MakeFunctionFlags::TYPE_PARAMS) {
-            self.pop_value()
-                .downcast()
-                .map_err(|_| vm.new_type_error("Type params must be a tuple."))?
-        } else {
-            vm.ctx.empty_tuple.clone()
-        };
-
-        let kw_only_defaults = if flags.contains(bytecode::MakeFunctionFlags::KW_ONLY_DEFAULTS) {
-            Some(
-                self.pop_value()
-                    .downcast::<PyDict>()
-                    .expect("Stack value for keyword only defaults expected to be a dict"),
-            )
-        } else {
-            None
-        };
-
-        let defaults = if flags.contains(bytecode::MakeFunctionFlags::DEFAULTS) {
-            Some(
-                self.pop_value()
-                    .downcast::<PyTuple>()
-                    .expect("Stack value for defaults expected to be a tuple"),
-            )
-        } else {
-            None
-        };
-
-        // pop argc arguments
-        // argument: name, args, globals
-        // let scope = self.scope.clone();
-        let func_obj = PyFunction::new(
-            code_obj,
-            self.globals.clone(),
-            closure,
-            defaults,
-            kw_only_defaults,
-            qualified_name.clone(),
-            type_params,
-            annotations.downcast().unwrap(),
-            vm.ctx.none(),
-            vm,
-        )?
-        .into_pyobject(vm);
-
-        self.push_value(func_obj);
-        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 {
-            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::Divide => vm._truediv(a_ref, b_ref),
-            bytecode::BinaryOperator::FloorDivide => vm._floordiv(a_ref, b_ref),
-            bytecode::BinaryOperator::Modulo => 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),
-        }?;
-
-        self.push_value(value);
-        Ok(None)
-    }
-    fn execute_bin_op_inplace(
-        &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._isub(a_ref, b_ref),
-            bytecode::BinaryOperator::Add => vm._iadd(a_ref, b_ref),
-            bytecode::BinaryOperator::Multiply => vm._imul(a_ref, b_ref),
-            bytecode::BinaryOperator::MatrixMultiply => vm._imatmul(a_ref, b_ref),
-            bytecode::BinaryOperator::Power => vm._ipow(a_ref, b_ref, vm.ctx.none.as_object()),
-            bytecode::BinaryOperator::Divide => vm._itruediv(a_ref, b_ref),
-            bytecode::BinaryOperator::FloorDivide => vm._ifloordiv(a_ref, b_ref),
-            bytecode::BinaryOperator::Modulo => vm._imod(a_ref, b_ref),
-            bytecode::BinaryOperator::Lshift => vm._ilshift(a_ref, b_ref),
-            bytecode::BinaryOperator::Rshift => vm._irshift(a_ref, b_ref),
-            bytecode::BinaryOperator::Xor => vm._ixor(a_ref, b_ref),
-            bytecode::BinaryOperator::Or => vm._ior(a_ref, b_ref),
-            bytecode::BinaryOperator::And => vm._iand(a_ref, b_ref),
-        }?;
-
-        self.push_value(value);
-        Ok(None)
-    }
-
-    #[cfg_attr(feature = "flame-it", flame("Frame"))]
-    fn execute_unary_op(
-        &mut self,
-        vm: &VirtualMachine,
-        op: bytecode::UnaryOperator,
-    ) -> FrameResult {
-        let a = self.pop_value();
-        let value = match op {
-            bytecode::UnaryOperator::Minus => vm._neg(&a)?,
-            bytecode::UnaryOperator::Plus => vm._pos(&a)?,
-            bytecode::UnaryOperator::Invert => vm._invert(&a)?,
-            bytecode::UnaryOperator::Not => {
-                let value = a.try_to_bool(vm)?;
-                vm.ctx.new_bool(!value).into()
-            }
-        };
-        self.push_value(value);
-        Ok(None)
-    }
-
-    #[cold]
-    fn setup_annotations(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let __annotations__ = identifier!(vm, __annotations__);
-        // 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)?
-            }
-        };
-        if !has_annotations {
-            self.locals
-                .as_object()
-                .set_item(__annotations__, vm.ctx.new_dict().into(), vm)?;
-        }
-        Ok(None)
-    }
-
-    fn print_expr(&mut self, vm: &VirtualMachine) -> FrameResult {
-        let expr = self.pop_value();
-
-        let displayhook = vm
-            .sys_module
-            .get_attr("displayhook", vm)
-            .map_err(|_| vm.new_runtime_error("lost sys.displayhook"))?;
-        displayhook.call((expr,), vm)?;
-
-        Ok(None)
-    }
-
-    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
-            }
-        })?;
-        let msg = match elements.len().cmp(&(size as usize)) {
-            std::cmp::Ordering::Equal => {
-                self.state.stack.extend(elements.into_iter().rev());
-                return Ok(None);
-            }
-            std::cmp::Ordering::Greater => {
-                format!("too many values to unpack (expected {size})")
-            }
-            std::cmp::Ordering::Less => format!(
-                "not enough values to unpack (expected {}, got {})",
-                size,
-                elements.len()
-            ),
-        };
-        Err(vm.new_value_error(msg))
-    }
-
-    fn format_value(
-        &mut self,
-        conversion: bytecode::ConversionFlag,
-        vm: &VirtualMachine,
-    ) -> FrameResult {
-        use bytecode::ConversionFlag;
-        let value = self.pop_value();
-        let value = match conversion {
-            ConversionFlag::Str => value.str(vm)?.into(),
-            ConversionFlag::Repr => value.repr(vm)?.into(),
-            ConversionFlag::Ascii => vm.ctx.new_str(builtins::ascii(value, vm)?).into(),
-            ConversionFlag::None => value,
-        };
-
-        let spec = self.pop_value();
-        let formatted = vm.format(&value, spec.downcast::<PyStr>().unwrap())?;
-        self.push_value(formatted.into());
-        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_test(&mut self, vm: &VirtualMachine, op: bytecode::TestOperator) -> FrameResult {
-        let b = self.pop_value();
-        let a = self.pop_value();
-        let value = match op {
-            bytecode::TestOperator::Is => a.is(&b),
-            bytecode::TestOperator::IsNot => !a.is(&b),
-            bytecode::TestOperator::In => self._in(vm, &a, &b)?,
-            bytecode::TestOperator::NotIn => self._not_in(vm, &a, &b)?,
-            bytecode::TestOperator::ExceptionMatch => {
-                if let Some(tuple_of_exceptions) = b.downcast_ref::<PyTuple>() {
-                    for exception in tuple_of_exceptions.iter() {
-                        if !exception
-                            .is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)?
-                        {
-                            return Err(vm.new_type_error(
-                                "catching classes that do not inherit from BaseException is not allowed",
-                            ));
-                        }
-                    }
-                } else if !b.is_subclass(vm.ctx.exceptions.base_exception_type.into(), vm)? {
-                    return Err(vm.new_type_error(
-                        "catching classes that do not inherit from BaseException is not allowed",
-                    ));
-                }
-
-                a.is_instance(&b, vm)?
-            }
-        };
-
-        self.push_value(vm.ctx.new_bool(value).into());
-        Ok(None)
-    }
-
-    #[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 value = a.rich_compare(b, op.into(), vm)?;
-        self.push_value(value);
-        Ok(None)
-    }
-
-    fn load_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize];
-        let parent = self.pop_value();
-        let obj = parent.get_attr(attr_name, vm)?;
-        self.push_value(obj);
-        Ok(None)
-    }
-
-    fn store_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize];
-        let parent = self.pop_value();
-        let value = self.pop_value();
-        parent.set_attr(attr_name, value, vm)?;
-        Ok(None)
-    }
-
-    fn delete_attr(&mut self, vm: &VirtualMachine, attr: bytecode::NameIdx) -> FrameResult {
-        let attr_name = self.code.names[attr as usize];
-        let parent = self.pop_value();
-        parent.del_attr(attr_name, vm)?;
-        Ok(None)
-    }
-
-    fn push_block(&mut self, typ: BlockType) {
-        // eprintln!("block pushed: {:.60?} {}", typ, self.state.stack.len());
-        self.state.blocks.push(Block {
-            typ,
-            level: self.state.stack.len(),
-        });
-    }
-
-    #[track_caller]
-    fn pop_block(&mut self) -> Block {
-        let block = self.state.blocks.pop().expect("No more blocks to pop!");
-        // eprintln!(
-        //     "block popped: {:.60?}  {} -> {} ",
-        //     block.typ,
-        //     self.state.stack.len(),
-        //     block.level
-        // );
-        #[cfg(debug_assertions)]
-        if self.state.stack.len() < block.level {
-            dbg!(&self);
-            panic!(
-                "stack size reversion: current size({}) < truncates target({}).",
-                self.state.stack.len(),
-                block.level
-            );
-        }
-        self.state.stack.truncate(block.level);
-        block
-    }
-
-    #[inline]
-    fn current_block(&self) -> Option<Block> {
-        self.state.blocks.last().cloned()
-    }
-
-    #[inline]
-    #[track_caller] // not a real track_caller but push_value is not very useful
-    fn push_value(&mut self, obj: PyObjectRef) {
-        // eprintln!(
-        //     "push_value {} / len: {} +1",
-        //     obj.class().name(),
-        //     self.state.stack.len()
-        // );
-        match self.state.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 pop_value is not very useful
-    fn pop_value(&mut self) -> PyObjectRef {
-        match self.state.stack.pop() {
-            Some(x) => {
-                // eprintln!(
-                //     "pop_value {} / len: {}",
-                //     x.class().name(),
-                //     self.state.stack.len()
-                // );
-                x
-            }
-            None => self.fatal("tried to pop value but there was nothing on the stack"),
-        }
-    }
-
-    fn call_intrinsic_1(
-        &mut self,
-        func: bytecode::IntrinsicFunction1,
-        arg: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        match func {
-            bytecode::IntrinsicFunction1::SubscriptGeneric => {
-                // Used for PEP 695: Generic[*type_params]
-                crate::builtins::genericalias::subscript_generic(arg, vm)
-            }
-        }
-    }
-
-    fn call_intrinsic_2(
-        &mut self,
-        func: bytecode::IntrinsicFunction2,
-        arg1: PyObjectRef,
-        arg2: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        match func {
-            bytecode::IntrinsicFunction2::SetTypeparamDefault => {
-                crate::stdlib::typing::set_typeparam_default(arg1, arg2, vm)
-            }
-        }
-    }
-
-    fn pop_multiple(&mut self, count: usize) -> crate::common::boxvec::Drain<'_, PyObjectRef> {
-        let stack_len = self.state.stack.len();
-        self.state.stack.drain(stack_len - count..)
-    }
-
-    #[inline]
-    fn replace_top(&mut self, mut top: PyObjectRef) -> PyObjectRef {
-        let last = self.state.stack.last_mut().unwrap();
-        std::mem::swap(&mut top, last);
-        top
-    }
-
-    #[inline]
-    #[track_caller] // not a real track_caller but top_value is not very useful
-    fn top_value(&self) -> &PyObject {
-        match &*self.state.stack {
-            [.., last] => last,
-            [] => 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;
-        &stack[stack.len() - depth as usize - 1]
-    }
-
-    #[cold]
-    #[inline(never)]
-    #[track_caller]
-    fn fatal(&self, msg: &'static str) -> ! {
-        dbg!(self);
-        panic!("{msg}")
-    }
-}
-
-impl fmt::Debug for Frame {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = self.state.lock();
-        let stack_str = state.stack.iter().fold(String::new(), |mut s, elem| {
-            if elem.payload_is::<Self>() {
-                s.push_str("\n  > {frame}");
-            } else {
-                std::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
-            }
-            s
-        });
-        let block_str = state.blocks.iter().fold(String::new(), |mut s, elem| {
-            std::fmt::write(&mut s, format_args!("\n  > {elem:?}")).unwrap();
-            s
-        });
-        // TODO: fix this up
-        let locals = self.locals.clone();
-        write!(
-            f,
-            "Frame Object {{ \n Stack:{}\n Blocks:{}\n Locals:{:?}\n}}",
-            stack_str,
-            block_str,
-            locals.into_object()
-        )
-    }
-}
diff --git a/vm/src/function/argument.rs b/vm/src/function/argument.rs
deleted file mode 100644
index aef5061ff2..0000000000
--- a/vm/src/function/argument.rs
+++ /dev/null
@@ -1,591 +0,0 @@
-use crate::{
-    AsObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyTupleRef, PyTypeRef},
-    convert::ToPyObject,
-    object::{Traverse, TraverseFn},
-};
-use indexmap::IndexMap;
-use itertools::Itertools;
-use std::ops::RangeInclusive;
-
-pub trait IntoFuncArgs: Sized {
-    fn into_args(self, vm: &VirtualMachine) -> FuncArgs;
-    fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
-        let mut args = self.into_args(vm);
-        args.prepend_arg(obj);
-        args
-    }
-}
-
-impl<T> IntoFuncArgs for T
-where
-    T: Into<FuncArgs>,
-{
-    fn into_args(self, _vm: &VirtualMachine) -> FuncArgs {
-        self.into()
-    }
-}
-
-// A tuple of values that each implement `ToPyObject` represents a sequence of
-// arguments that can be bound and passed to a built-in function.
-macro_rules! into_func_args_from_tuple {
-    ($(($n:tt, $T:ident)),*) => {
-        impl<$($T,)*> IntoFuncArgs for ($($T,)*)
-        where
-            $($T: ToPyObject,)*
-        {
-            #[inline]
-            fn into_args(self, vm: &VirtualMachine) -> FuncArgs {
-                let ($($n,)*) = self;
-                PosArgs::new(vec![$($n.to_pyobject(vm),)*]).into()
-            }
-
-            #[inline]
-            fn into_method_args(self, obj: PyObjectRef, vm: &VirtualMachine) -> FuncArgs {
-                let ($($n,)*) = self;
-                PosArgs::new(vec![obj, $($n.to_pyobject(vm),)*]).into()
-            }
-        }
-    };
-}
-
-into_func_args_from_tuple!((v1, T1));
-into_func_args_from_tuple!((v1, T1), (v2, T2));
-into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3));
-into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4));
-into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4), (v5, T5));
-into_func_args_from_tuple!((v1, T1), (v2, T2), (v3, T3), (v4, T4), (v5, T5), (v6, T6));
-
-/// The `FuncArgs` struct is one of the most used structs then creating
-/// a rust function that can be called from python. It holds both positional
-/// arguments, as well as keyword arguments passed to the function.
-#[derive(Debug, Default, Clone, Traverse)]
-pub struct FuncArgs {
-    pub args: Vec<PyObjectRef>,
-    // sorted map, according to https://www.python.org/dev/peps/pep-0468/
-    pub kwargs: IndexMap<String, PyObjectRef>,
-}
-
-unsafe impl Traverse for IndexMap<String, PyObjectRef> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.values().for_each(|v| v.traverse(tracer_fn));
-    }
-}
-
-/// Conversion from vector of python objects to function arguments.
-impl<A> From<A> for FuncArgs
-where
-    A: Into<PosArgs>,
-{
-    fn from(args: A) -> Self {
-        Self {
-            args: args.into().into_vec(),
-            kwargs: IndexMap::new(),
-        }
-    }
-}
-
-impl From<KwArgs> for FuncArgs {
-    fn from(kwargs: KwArgs) -> Self {
-        Self {
-            args: Vec::new(),
-            kwargs: kwargs.0,
-        }
-    }
-}
-
-impl FromArgs for FuncArgs {
-    fn from_args(_vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        Ok(std::mem::take(args))
-    }
-}
-
-impl FuncArgs {
-    pub fn new<A, K>(args: A, kwargs: K) -> Self
-    where
-        A: Into<PosArgs>,
-        K: Into<KwArgs>,
-    {
-        let PosArgs(args) = args.into();
-        let KwArgs(kwargs) = kwargs.into();
-        Self { args, kwargs }
-    }
-
-    pub fn with_kwargs_names<A, KW>(mut args: A, kwarg_names: KW) -> Self
-    where
-        A: ExactSizeIterator<Item = PyObjectRef>,
-        KW: ExactSizeIterator<Item = String>,
-    {
-        // last `kwarg_names.len()` elements of args in order of appearance in the call signature
-        let total_argc = args.len();
-        let kwarg_count = kwarg_names.len();
-        let pos_arg_count = total_argc - kwarg_count;
-
-        let pos_args = args.by_ref().take(pos_arg_count).collect();
-
-        let kwargs = kwarg_names.zip_eq(args).collect::<IndexMap<_, _>>();
-
-        Self {
-            args: pos_args,
-            kwargs,
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.args.is_empty() && self.kwargs.is_empty()
-    }
-
-    pub fn prepend_arg(&mut self, item: PyObjectRef) {
-        self.args.reserve_exact(1);
-        self.args.insert(0, item)
-    }
-
-    pub fn shift(&mut self) -> PyObjectRef {
-        self.args.remove(0)
-    }
-
-    pub fn get_kwarg(&self, key: &str, default: PyObjectRef) -> PyObjectRef {
-        self.kwargs
-            .get(key)
-            .cloned()
-            .unwrap_or_else(|| default.clone())
-    }
-
-    pub fn get_optional_kwarg(&self, key: &str) -> Option<PyObjectRef> {
-        self.kwargs.get(key).cloned()
-    }
-
-    pub fn get_optional_kwarg_with_type(
-        &self,
-        key: &str,
-        ty: PyTypeRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>> {
-        match self.get_optional_kwarg(key) {
-            Some(kwarg) => {
-                if kwarg.fast_isinstance(&ty) {
-                    Ok(Some(kwarg))
-                } else {
-                    let expected_ty_name = &ty.name();
-                    let kwarg_class = kwarg.class();
-                    let actual_ty_name = &kwarg_class.name();
-                    Err(vm.new_type_error(format!(
-                        "argument of type {expected_ty_name} is required for named parameter `{key}` (got: {actual_ty_name})"
-                    )))
-                }
-            }
-            None => Ok(None),
-        }
-    }
-
-    pub fn take_positional(&mut self) -> Option<PyObjectRef> {
-        if self.args.is_empty() {
-            None
-        } else {
-            Some(self.args.remove(0))
-        }
-    }
-
-    pub fn take_positional_keyword(&mut self, name: &str) -> Option<PyObjectRef> {
-        self.take_positional().or_else(|| self.take_keyword(name))
-    }
-
-    pub fn take_keyword(&mut self, name: &str) -> Option<PyObjectRef> {
-        self.kwargs.swap_remove(name)
-    }
-
-    pub fn remaining_keywords(&mut self) -> impl Iterator<Item = (String, PyObjectRef)> + '_ {
-        self.kwargs.drain(..)
-    }
-
-    /// Binds these arguments to their respective values.
-    ///
-    /// If there is an insufficient number of arguments, there are leftover
-    /// arguments after performing the binding, or if an argument is not of
-    /// the expected type, a TypeError is raised.
-    ///
-    /// If the given `FromArgs` includes any conversions, exceptions raised
-    /// during the conversion will halt the binding and return the error.
-    pub fn bind<T: FromArgs>(mut self, vm: &VirtualMachine) -> PyResult<T> {
-        let given_args = self.args.len();
-        let bound = T::from_args(vm, &mut self)
-            .map_err(|e| e.into_exception(T::arity(), given_args, vm))?;
-
-        if !self.args.is_empty() {
-            Err(vm.new_type_error(format!(
-                "Expected at most {} arguments ({} given)",
-                T::arity().end(),
-                given_args,
-            )))
-        } else if let Some(err) = self.check_kwargs_empty(vm) {
-            Err(err)
-        } else {
-            Ok(bound)
-        }
-    }
-
-    pub fn check_kwargs_empty(&self, vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
-        self.kwargs
-            .keys()
-            .next()
-            .map(|k| vm.new_type_error(format!("Unexpected keyword argument {k}")))
-    }
-}
-
-/// An error encountered while binding arguments to the parameters of a Python
-/// function call.
-pub enum ArgumentError {
-    /// The call provided fewer positional arguments than the function requires.
-    TooFewArgs,
-    /// The call provided more positional arguments than the function accepts.
-    TooManyArgs,
-    /// The function doesn't accept a keyword argument with the given name.
-    InvalidKeywordArgument(String),
-    /// The function require a keyword argument with the given name, but one wasn't provided
-    RequiredKeywordArgument(String),
-    /// An exception was raised while binding arguments to the function
-    /// parameters.
-    Exception(PyBaseExceptionRef),
-}
-
-impl From<PyBaseExceptionRef> for ArgumentError {
-    fn from(ex: PyBaseExceptionRef) -> Self {
-        Self::Exception(ex)
-    }
-}
-
-impl ArgumentError {
-    fn into_exception(
-        self,
-        arity: RangeInclusive<usize>,
-        num_given: usize,
-        vm: &VirtualMachine,
-    ) -> PyBaseExceptionRef {
-        match self {
-            Self::TooFewArgs => vm.new_type_error(format!(
-                "Expected at least {} arguments ({} given)",
-                arity.start(),
-                num_given
-            )),
-            Self::TooManyArgs => vm.new_type_error(format!(
-                "Expected at most {} arguments ({} given)",
-                arity.end(),
-                num_given
-            )),
-            Self::InvalidKeywordArgument(name) => {
-                vm.new_type_error(format!("{name} is an invalid keyword argument"))
-            }
-            Self::RequiredKeywordArgument(name) => {
-                vm.new_type_error(format!("Required keyword only argument {name}"))
-            }
-            Self::Exception(ex) => ex,
-        }
-    }
-}
-
-/// Implemented by any type that can be accepted as a parameter to a built-in
-/// function.
-///
-pub trait FromArgs: Sized {
-    /// The range of positional arguments permitted by the function signature.
-    ///
-    /// Returns an empty range if not applicable.
-    fn arity() -> RangeInclusive<usize> {
-        0..=0
-    }
-
-    /// Extracts this item from the next argument(s).
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError>;
-}
-
-pub trait FromArgOptional {
-    type Inner: TryFromObject;
-    fn from_inner(x: Self::Inner) -> Self;
-}
-
-impl<T: TryFromObject> FromArgOptional for OptionalArg<T> {
-    type Inner = T;
-    fn from_inner(x: T) -> Self {
-        Self::Present(x)
-    }
-}
-
-impl<T: TryFromObject> FromArgOptional for T {
-    type Inner = Self;
-    fn from_inner(x: Self) -> Self {
-        x
-    }
-}
-
-/// A map of keyword arguments to their values.
-///
-/// A built-in function with a `KwArgs` parameter is analogous to a Python
-/// function with `**kwargs`. All remaining keyword arguments are extracted
-/// (and hence the function will permit an arbitrary number of them).
-///
-/// `KwArgs` optionally accepts a generic type parameter to allow type checks
-/// or conversions of each argument.
-///
-/// Note:
-///
-/// KwArgs is only for functions that accept arbitrary keyword arguments. For
-/// functions that accept only *specific* named arguments, a rust struct with
-/// an appropriate FromArgs implementation must be created.
-#[derive(Clone)]
-pub struct KwArgs<T = PyObjectRef>(IndexMap<String, T>);
-
-unsafe impl<T> Traverse for KwArgs<T>
-where
-    T: Traverse,
-{
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.0.iter().map(|(_, v)| v.traverse(tracer_fn)).count();
-    }
-}
-
-impl<T> KwArgs<T> {
-    pub const fn new(map: IndexMap<String, T>) -> Self {
-        Self(map)
-    }
-
-    pub fn pop_kwarg(&mut self, name: &str) -> Option<T> {
-        self.0.swap_remove(name)
-    }
-
-    pub fn is_empty(self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl<T> FromIterator<(String, T)> for KwArgs<T> {
-    fn from_iter<I: IntoIterator<Item = (String, T)>>(iter: I) -> Self {
-        Self(iter.into_iter().collect())
-    }
-}
-
-impl<T> Default for KwArgs<T> {
-    fn default() -> Self {
-        Self(IndexMap::new())
-    }
-}
-
-impl<T> FromArgs for KwArgs<T>
-where
-    T: TryFromObject,
-{
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        let mut kwargs = IndexMap::new();
-        for (name, value) in args.remaining_keywords() {
-            kwargs.insert(name, value.try_into_value(vm)?);
-        }
-        Ok(Self(kwargs))
-    }
-}
-
-impl<T> IntoIterator for KwArgs<T> {
-    type Item = (String, T);
-    type IntoIter = indexmap::map::IntoIter<String, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-/// A list of positional argument values.
-///
-/// A built-in function with a `PosArgs` parameter is analogous to a Python
-/// function with `*args`. All remaining positional arguments are extracted
-/// (and hence the function will permit an arbitrary number of them).
-///
-/// `PosArgs` optionally accepts a generic type parameter to allow type checks
-/// or conversions of each argument.
-#[derive(Clone)]
-pub struct PosArgs<T = PyObjectRef>(Vec<T>);
-
-unsafe impl<T> Traverse for PosArgs<T>
-where
-    T: Traverse,
-{
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.0.traverse(tracer_fn)
-    }
-}
-
-impl<T> PosArgs<T> {
-    pub const fn new(args: Vec<T>) -> Self {
-        Self(args)
-    }
-
-    pub fn into_vec(self) -> Vec<T> {
-        self.0
-    }
-
-    pub fn iter(&self) -> std::slice::Iter<'_, T> {
-        self.0.iter()
-    }
-}
-
-impl<T> From<Vec<T>> for PosArgs<T> {
-    fn from(v: Vec<T>) -> Self {
-        Self(v)
-    }
-}
-
-impl From<()> for PosArgs<PyObjectRef> {
-    fn from(_args: ()) -> Self {
-        Self(Vec::new())
-    }
-}
-
-impl<T> AsRef<[T]> for PosArgs<T> {
-    fn as_ref(&self) -> &[T] {
-        &self.0
-    }
-}
-
-impl<T: PyPayload> PosArgs<PyRef<T>> {
-    pub fn into_tuple(self, vm: &VirtualMachine) -> PyTupleRef {
-        vm.ctx
-            .new_tuple(self.0.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<T> FromArgs for PosArgs<T>
-where
-    T: TryFromObject,
-{
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        let mut varargs = Vec::new();
-        while let Some(value) = args.take_positional() {
-            varargs.push(value.try_into_value(vm)?);
-        }
-        Ok(Self(varargs))
-    }
-}
-
-impl<T> IntoIterator for PosArgs<T> {
-    type Item = T;
-    type IntoIter = std::vec::IntoIter<T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-impl<T> FromArgs for T
-where
-    T: TryFromObject,
-{
-    fn arity() -> RangeInclusive<usize> {
-        1..=1
-    }
-
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        let value = args.take_positional().ok_or(ArgumentError::TooFewArgs)?;
-        Ok(value.try_into_value(vm)?)
-    }
-}
-
-/// An argument that may or may not be provided by the caller.
-///
-/// This style of argument is not possible in pure Python.
-#[derive(Debug, result_like::OptionLike, is_macro::Is)]
-pub enum OptionalArg<T = PyObjectRef> {
-    Present(T),
-    Missing,
-}
-
-unsafe impl<T> Traverse for OptionalArg<T>
-where
-    T: Traverse,
-{
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        match self {
-            Self::Present(o) => o.traverse(tracer_fn),
-            Self::Missing => (),
-        }
-    }
-}
-
-impl OptionalArg<PyObjectRef> {
-    pub fn unwrap_or_none(self, vm: &VirtualMachine) -> PyObjectRef {
-        self.unwrap_or_else(|| vm.ctx.none())
-    }
-}
-
-pub type OptionalOption<T = PyObjectRef> = OptionalArg<Option<T>>;
-
-impl<T> OptionalOption<T> {
-    #[inline]
-    pub fn flatten(self) -> Option<T> {
-        self.into_option().flatten()
-    }
-}
-
-impl<T> FromArgs for OptionalArg<T>
-where
-    T: TryFromObject,
-{
-    fn arity() -> RangeInclusive<usize> {
-        0..=1
-    }
-
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        let r = if let Some(value) = args.take_positional() {
-            Self::Present(value.try_into_value(vm)?)
-        } else {
-            Self::Missing
-        };
-        Ok(r)
-    }
-}
-
-// For functions that accept no arguments. Implemented explicitly instead of via
-// macro below to avoid unused warnings.
-impl FromArgs for () {
-    fn from_args(_vm: &VirtualMachine, _args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        Ok(())
-    }
-}
-
-// A tuple of types that each implement `FromArgs` represents a sequence of
-// arguments that can be bound and passed to a built-in function.
-//
-// Technically, a tuple can contain tuples, which can contain tuples, and so on,
-// so this actually represents a tree of values to be bound from arguments, but
-// in practice this is only used for the top-level parameters.
-macro_rules! tuple_from_py_func_args {
-    ($($T:ident),+) => {
-        impl<$($T),+> FromArgs for ($($T,)+)
-        where
-            $($T: FromArgs),+
-        {
-            fn arity() -> RangeInclusive<usize> {
-                let mut min = 0;
-                let mut max = 0;
-                $(
-                    let (start, end) = $T::arity().into_inner();
-                    min += start;
-                    max += end;
-                )+
-                min..=max
-            }
-
-            fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-                Ok(($($T::from_args(vm, args)?,)+))
-            }
-        }
-    };
-}
-
-// Implement `FromArgs` for up to 7-tuples, allowing built-in functions to bind
-// up to 7 top-level parameters (note that `PosArgs`, `KwArgs`, nested tuples, etc.
-// count as 1, so this should actually be more than enough).
-tuple_from_py_func_args!(A);
-tuple_from_py_func_args!(A, B);
-tuple_from_py_func_args!(A, B, C);
-tuple_from_py_func_args!(A, B, C, D);
-tuple_from_py_func_args!(A, B, C, D, E);
-tuple_from_py_func_args!(A, B, C, D, E, F);
-tuple_from_py_func_args!(A, B, C, D, E, F, G);
-tuple_from_py_func_args!(A, B, C, D, E, F, G, H);
diff --git a/vm/src/function/buffer.rs b/vm/src/function/buffer.rs
deleted file mode 100644
index 8a2a471ac9..0000000000
--- a/vm/src/function/buffer.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject,
-    VirtualMachine,
-    builtins::{PyStr, PyStrRef},
-    common::borrow::{BorrowedValue, BorrowedValueMut},
-    protocol::PyBuffer,
-};
-
-// Python/getargs.c
-
-/// any bytes-like object. Like the `y*` format code for `PyArg_Parse` in CPython.
-#[derive(Debug, Traverse)]
-pub struct ArgBytesLike(PyBuffer);
-
-impl PyObject {
-    pub fn try_bytes_like<R>(
-        &self,
-        vm: &VirtualMachine,
-        f: impl FnOnce(&[u8]) -> R,
-    ) -> PyResult<R> {
-        let buffer = PyBuffer::try_from_borrowed_object(vm, self)?;
-        buffer
-            .as_contiguous()
-            .map(|x| f(&x))
-            .ok_or_else(|| vm.new_type_error("non-contiguous buffer is not a bytes-like object"))
-    }
-
-    pub fn try_rw_bytes_like<R>(
-        &self,
-        vm: &VirtualMachine,
-        f: impl FnOnce(&mut [u8]) -> R,
-    ) -> PyResult<R> {
-        let buffer = PyBuffer::try_from_borrowed_object(vm, self)?;
-        buffer
-            .as_contiguous_mut()
-            .map(|mut x| f(&mut x))
-            .ok_or_else(|| vm.new_type_error("buffer is not a read-write bytes-like object"))
-    }
-}
-
-impl ArgBytesLike {
-    pub fn borrow_buf(&self) -> BorrowedValue<'_, [u8]> {
-        unsafe { self.0.contiguous_unchecked() }
-    }
-
-    pub fn with_ref<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&[u8]) -> R,
-    {
-        f(&self.borrow_buf())
-    }
-
-    pub const fn len(&self) -> usize {
-        self.0.desc.len
-    }
-
-    pub const fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn as_object(&self) -> &PyObject {
-        &self.0.obj
-    }
-}
-
-impl From<ArgBytesLike> for PyBuffer {
-    fn from(buffer: ArgBytesLike) -> Self {
-        buffer.0
-    }
-}
-
-impl From<ArgBytesLike> for PyObjectRef {
-    fn from(buffer: ArgBytesLike) -> Self {
-        buffer.as_object().to_owned()
-    }
-}
-
-impl<'a> TryFromBorrowedObject<'a> for ArgBytesLike {
-    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?;
-        if buffer.desc.is_contiguous() {
-            Ok(Self(buffer))
-        } else {
-            Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object"))
-        }
-    }
-}
-
-/// A memory buffer, read-write access. Like the `w*` format code for `PyArg_Parse` in CPython.
-#[derive(Debug, Traverse)]
-pub struct ArgMemoryBuffer(PyBuffer);
-
-impl ArgMemoryBuffer {
-    pub fn borrow_buf_mut(&self) -> BorrowedValueMut<'_, [u8]> {
-        unsafe { self.0.contiguous_mut_unchecked() }
-    }
-
-    pub fn with_ref<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&mut [u8]) -> R,
-    {
-        f(&mut self.borrow_buf_mut())
-    }
-
-    pub const fn len(&self) -> usize {
-        self.0.desc.len
-    }
-
-    pub const fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-impl From<ArgMemoryBuffer> for PyBuffer {
-    fn from(buffer: ArgMemoryBuffer) -> Self {
-        buffer.0
-    }
-}
-
-impl<'a> TryFromBorrowedObject<'a> for ArgMemoryBuffer {
-    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        let buffer = PyBuffer::try_from_borrowed_object(vm, obj)?;
-        if !buffer.desc.is_contiguous() {
-            Err(vm.new_type_error("non-contiguous buffer is not a bytes-like object"))
-        } else if buffer.desc.readonly {
-            Err(vm.new_type_error("buffer is not a read-write bytes-like object"))
-        } else {
-            Ok(Self(buffer))
-        }
-    }
-}
-
-/// A text string or bytes-like object. Like the `s*` format code for `PyArg_Parse` in CPython.
-pub enum ArgStrOrBytesLike {
-    Buf(ArgBytesLike),
-    Str(PyStrRef),
-}
-
-impl ArgStrOrBytesLike {
-    pub fn as_object(&self) -> &PyObject {
-        match self {
-            Self::Buf(b) => b.as_object(),
-            Self::Str(s) => s.as_object(),
-        }
-    }
-}
-
-impl TryFromObject for ArgStrOrBytesLike {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        obj.downcast()
-            .map(Self::Str)
-            .or_else(|obj| ArgBytesLike::try_from_object(vm, obj).map(Self::Buf))
-    }
-}
-
-impl ArgStrOrBytesLike {
-    pub fn borrow_bytes(&self) -> BorrowedValue<'_, [u8]> {
-        match self {
-            Self::Buf(b) => b.borrow_buf(),
-            Self::Str(s) => s.as_bytes().into(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub enum ArgAsciiBuffer {
-    String(PyStrRef),
-    Buffer(ArgBytesLike),
-}
-
-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() {
-                    Ok(Self::String(string))
-                } else {
-                    Err(vm.new_value_error("string argument should contain only ASCII characters"))
-                }
-            }
-            Err(obj) => ArgBytesLike::try_from_object(vm, obj).map(ArgAsciiBuffer::Buffer),
-        }
-    }
-}
-
-impl ArgAsciiBuffer {
-    pub fn len(&self) -> usize {
-        match self {
-            Self::String(s) => s.as_str().len(),
-            Self::Buffer(buffer) => buffer.len(),
-        }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    #[inline]
-    pub fn with_ref<R>(&self, f: impl FnOnce(&[u8]) -> R) -> R {
-        match self {
-            Self::String(s) => f(s.as_bytes()),
-            Self::Buffer(buffer) => buffer.with_ref(f),
-        }
-    }
-}
diff --git a/vm/src/function/fspath.rs b/vm/src/function/fspath.rs
deleted file mode 100644
index 5e0108986d..0000000000
--- a/vm/src/function/fspath.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use crate::{
-    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBytes, PyBytesRef, PyStrRef},
-    convert::{IntoPyException, ToPyObject},
-    function::PyStr,
-    protocol::PyBuffer,
-};
-use std::{borrow::Cow, ffi::OsStr, path::PathBuf};
-
-#[derive(Clone)]
-pub enum FsPath {
-    Str(PyStrRef),
-    Bytes(PyBytesRef),
-}
-
-impl FsPath {
-    // PyOS_FSPath in CPython
-    pub fn try_from(obj: PyObjectRef, check_for_nul: bool, vm: &VirtualMachine) -> PyResult<Self> {
-        let check_nul = |b: &[u8]| {
-            if !check_for_nul || memchr::memchr(b'\0', b).is_none() {
-                Ok(())
-            } else {
-                Err(crate::exceptions::cstring_error(vm))
-            }
-        };
-        let match1 = |obj: PyObjectRef| {
-            let pathlike = match_class!(match obj {
-                s @ PyStr => {
-                    check_nul(s.as_bytes())?;
-                    Self::Str(s)
-                }
-                b @ PyBytes => {
-                    check_nul(&b)?;
-                    Self::Bytes(b)
-                }
-                obj => return Ok(Err(obj)),
-            });
-            Ok(Ok(pathlike))
-        };
-        let obj = match match1(obj)? {
-            Ok(pathlike) => return Ok(pathlike),
-            Err(obj) => obj,
-        };
-        let method =
-            vm.get_method_or_type_error(obj.clone(), identifier!(vm, __fspath__), || {
-                format!(
-                    "should be string, bytes, os.PathLike or integer, not {}",
-                    obj.class().name()
-                )
-            })?;
-        let result = method.call((), vm)?;
-        match1(result)?.map_err(|result| {
-            vm.new_type_error(format!(
-                "expected {}.__fspath__() to return str or bytes, not {}",
-                obj.class().name(),
-                result.class().name(),
-            ))
-        })
-    }
-
-    pub fn as_os_str(&self, vm: &VirtualMachine) -> PyResult<Cow<'_, OsStr>> {
-        // TODO: FS encodings
-        match self {
-            Self::Str(s) => vm.fsencode(s),
-            Self::Bytes(b) => Self::bytes_as_os_str(b.as_bytes(), vm).map(Cow::Borrowed),
-        }
-    }
-
-    pub fn as_bytes(&self) -> &[u8] {
-        // TODO: FS encodings
-        match self {
-            Self::Str(s) => s.as_bytes(),
-            Self::Bytes(b) => b.as_bytes(),
-        }
-    }
-
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        match self {
-            Self::Str(s) => s.to_string_lossy(),
-            Self::Bytes(s) => String::from_utf8_lossy(s),
-        }
-    }
-
-    pub fn to_path_buf(&self, vm: &VirtualMachine) -> PyResult<PathBuf> {
-        let path = match self {
-            Self::Str(s) => PathBuf::from(s.as_str()),
-            Self::Bytes(b) => PathBuf::from(Self::bytes_as_os_str(b, vm)?),
-        };
-        Ok(path)
-    }
-
-    pub fn to_cstring(&self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.as_bytes()).map_err(|e| e.into_pyexception(vm))
-    }
-
-    #[cfg(windows)]
-    pub fn to_wide_cstring(&self, vm: &VirtualMachine) -> PyResult<widestring::WideCString> {
-        widestring::WideCString::from_os_str(self.as_os_str(vm)?)
-            .map_err(|err| err.into_pyexception(vm))
-    }
-
-    pub fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> {
-        rustpython_common::os::bytes_as_os_str(b)
-            .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8"))
-    }
-}
-
-impl ToPyObject for FsPath {
-    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        match self {
-            Self::Str(s) => s.into(),
-            Self::Bytes(b) => b.into(),
-        }
-    }
-}
-
-impl TryFromObject for FsPath {
-    // PyUnicode_FSDecoder in CPython
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let obj = match obj.try_to_value::<PyBuffer>(vm) {
-            Ok(buffer) => {
-                let mut bytes = vec![];
-                buffer.append_to(&mut bytes);
-                vm.ctx.new_bytes(bytes).into()
-            }
-            Err(_) => obj,
-        };
-        Self::try_from(obj, true, vm)
-    }
-}
diff --git a/vm/src/function/method.rs b/vm/src/function/method.rs
deleted file mode 100644
index 5e109176c5..0000000000
--- a/vm/src/function/method.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-use crate::{
-    Context, Py, PyObjectRef, PyPayload, PyRef, VirtualMachine,
-    builtins::{
-        PyType,
-        builtin_func::{PyNativeFunction, PyNativeMethod},
-        descriptor::PyMethodDescriptor,
-    },
-    function::{IntoPyNativeFn, PyNativeFn},
-};
-
-bitflags::bitflags! {
-    // METH_XXX flags in CPython
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct PyMethodFlags: u32 {
-        // 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;
-
-        // METH_CLASS and METH_STATIC are a little different; these control
-        // the construction of methods for a class.  These cannot be used for
-        // functions in modules.
-        const CLASS = 0x0010;
-        const STATIC = 0x0020;
-
-        // METH_COEXIST allows a method to be entered even though a slot has
-        // already filled the entry.  When defined, the flag allows a separate
-        // method, "__contains__" for example, to coexist with a defined
-        // slot like sq_contains.
-        // const COEXIST = 0x0040;
-
-        // if not Py_LIMITED_API
-        // const FASTCALL = 0x0080;
-
-        // This bit is preserved for Stackless Python
-        // const STACKLESS = 0x0100;
-
-        // METH_METHOD means the function stores an
-        // additional reference to the class that defines it;
-        // both self and class are passed to it.
-        // It uses PyCMethodObject instead of PyCFunctionObject.
-        // May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC.
-        const METHOD = 0x0200;
-    }
-}
-
-impl PyMethodFlags {
-    // FIXME: macro temp
-    pub const EMPTY: Self = Self::empty();
-}
-
-#[macro_export]
-macro_rules! define_methods {
-    // TODO: more flexible syntax
-    ($($name:literal => $func:ident as $flags:ident),+) => {
-        vec![ $( $crate::function::PyMethodDef {
-            name: $name,
-            func: $crate::function::static_func($func),
-            flags: $crate::function::PyMethodFlags::$flags,
-            doc: None,
-        }),+ ]
-    };
-}
-
-#[derive(Clone)]
-pub struct PyMethodDef {
-    pub name: &'static str, // TODO: interned
-    pub func: &'static dyn PyNativeFn,
-    pub flags: PyMethodFlags,
-    pub doc: Option<&'static str>, // TODO: interned
-}
-
-impl PyMethodDef {
-    #[inline]
-    pub const fn new_const<Kind>(
-        name: &'static str,
-        func: impl IntoPyNativeFn<Kind>,
-        flags: PyMethodFlags,
-        doc: Option<&'static str>,
-    ) -> Self {
-        Self {
-            name,
-            func: super::static_func(func),
-            flags,
-            doc,
-        }
-    }
-
-    #[inline]
-    pub const fn new_raw_const(
-        name: &'static str,
-        func: impl PyNativeFn,
-        flags: PyMethodFlags,
-        doc: Option<&'static str>,
-    ) -> Self {
-        Self {
-            name,
-            func: super::static_raw_func(func),
-            flags,
-            doc,
-        }
-    }
-
-    pub fn to_proper_method(
-        &'static self,
-        class: &'static Py<PyType>,
-        ctx: &Context,
-    ) -> PyObjectRef {
-        if self.flags.contains(PyMethodFlags::METHOD) {
-            self.build_method(ctx, class).into()
-        } else if self.flags.contains(PyMethodFlags::CLASS) {
-            self.build_classmethod(ctx, class).into()
-        } else if self.flags.contains(PyMethodFlags::STATIC) {
-            self.build_staticmethod(ctx, class).into()
-        } else {
-            unreachable!()
-        }
-    }
-
-    pub const fn to_function(&'static self) -> PyNativeFunction {
-        PyNativeFunction {
-            zelf: None,
-            value: self,
-            module: None,
-        }
-    }
-
-    pub fn to_method(
-        &'static self,
-        class: &'static Py<PyType>,
-        ctx: &Context,
-    ) -> PyMethodDescriptor {
-        PyMethodDescriptor::new(self, class, ctx)
-    }
-
-    pub const fn to_bound_method(
-        &'static self,
-        obj: PyObjectRef,
-        class: &'static Py<PyType>,
-    ) -> PyNativeMethod {
-        PyNativeMethod {
-            func: PyNativeFunction {
-                zelf: Some(obj),
-                value: self,
-                module: None,
-            },
-            class,
-        }
-    }
-
-    pub fn build_function(&'static self, ctx: &Context) -> PyRef<PyNativeFunction> {
-        self.to_function().into_ref(ctx)
-    }
-
-    pub fn build_bound_function(
-        &'static self,
-        ctx: &Context,
-        obj: PyObjectRef,
-    ) -> PyRef<PyNativeFunction> {
-        let function = PyNativeFunction {
-            zelf: Some(obj),
-            value: self,
-            module: None,
-        };
-        PyRef::new_ref(
-            function,
-            ctx.types.builtin_function_or_method_type.to_owned(),
-            None,
-        )
-    }
-
-    pub fn build_method(
-        &'static self,
-        ctx: &Context,
-        class: &'static Py<PyType>,
-    ) -> PyRef<PyMethodDescriptor> {
-        debug_assert!(self.flags.contains(PyMethodFlags::METHOD));
-        let method = self.to_method(class, ctx);
-        PyRef::new_ref(method, ctx.types.method_descriptor_type.to_owned(), None)
-    }
-
-    pub fn build_bound_method(
-        &'static self,
-        ctx: &Context,
-        obj: PyObjectRef,
-        class: &'static Py<PyType>,
-    ) -> PyRef<PyNativeMethod> {
-        PyRef::new_ref(
-            self.to_bound_method(obj, class),
-            ctx.types.builtin_method_type.to_owned(),
-            None,
-        )
-    }
-
-    pub fn build_classmethod(
-        &'static self,
-        ctx: &Context,
-        class: &'static Py<PyType>,
-    ) -> PyRef<PyMethodDescriptor> {
-        PyRef::new_ref(
-            self.to_method(class, ctx),
-            ctx.types.method_descriptor_type.to_owned(),
-            None,
-        )
-    }
-
-    pub fn build_staticmethod(
-        &'static self,
-        ctx: &Context,
-        class: &'static Py<PyType>,
-    ) -> PyRef<PyNativeMethod> {
-        debug_assert!(self.flags.contains(PyMethodFlags::STATIC));
-        let func = self.to_function();
-        PyNativeMethod { func, class }.into_ref(ctx)
-    }
-
-    #[doc(hidden)]
-    pub const fn __const_concat_arrays<const SUM_LEN: usize>(
-        method_groups: &[&[Self]],
-    ) -> [Self; SUM_LEN] {
-        const NULL_METHOD: PyMethodDef = PyMethodDef {
-            name: "",
-            func: &|_, _| unreachable!(),
-            flags: PyMethodFlags::empty(),
-            doc: None,
-        };
-        let mut all_methods = [NULL_METHOD; SUM_LEN];
-        let mut all_idx = 0;
-        let mut group_idx = 0;
-        while group_idx < method_groups.len() {
-            let group = method_groups[group_idx];
-            let mut method_idx = 0;
-            while method_idx < group.len() {
-                all_methods[all_idx] = group[method_idx].const_copy();
-                method_idx += 1;
-                all_idx += 1;
-            }
-            group_idx += 1;
-        }
-        all_methods
-    }
-
-    const fn const_copy(&self) -> Self {
-        Self {
-            name: self.name,
-            func: self.func,
-            flags: self.flags,
-            doc: self.doc,
-        }
-    }
-}
-
-impl std::fmt::Debug for PyMethodDef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyMethodDef")
-            .field("name", &self.name)
-            .field(
-                "func",
-                &(unsafe {
-                    std::mem::transmute::<&dyn PyNativeFn, [usize; 2]>(self.func)[1] as *const u8
-                }),
-            )
-            .field("flags", &self.flags)
-            .field("doc", &self.doc)
-            .finish()
-    }
-}
-
-// This is not a part of CPython API.
-// But useful to support dynamically generated methods
-#[pyclass(name, module = false, ctx = "method_def")]
-#[derive(Debug)]
-pub struct HeapMethodDef {
-    method: PyMethodDef,
-}
-
-impl HeapMethodDef {
-    pub const fn new(method: PyMethodDef) -> Self {
-        Self { method }
-    }
-}
-
-impl Py<HeapMethodDef> {
-    pub(crate) unsafe fn method(&self) -> &'static PyMethodDef {
-        unsafe { &*(&self.method as *const _) }
-    }
-
-    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();
-        PyRef::new_ref(
-            function,
-            vm.ctx.types.builtin_function_or_method_type.to_owned(),
-            Some(dict),
-        )
-    }
-
-    pub fn build_method(
-        &self,
-        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();
-        PyRef::new_ref(
-            function,
-            vm.ctx.types.method_descriptor_type.to_owned(),
-            Some(dict),
-        )
-    }
-}
-
-#[pyclass]
-impl HeapMethodDef {}
diff --git a/vm/src/function/number.rs b/vm/src/function/number.rs
deleted file mode 100644
index 7bb37b8f54..0000000000
--- a/vm/src/function/number.rs
+++ /dev/null
@@ -1,198 +0,0 @@
-use super::argument::OptionalArg;
-use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, builtins::PyIntRef};
-use malachite_bigint::BigInt;
-use num_complex::Complex64;
-use num_traits::PrimInt;
-use std::ops::Deref;
-
-/// A Python complex-like object.
-///
-/// `ArgIntoComplex` implements `FromArgs` so that a built-in function can accept
-/// any object that can be transformed into a complex.
-///
-/// If the object is not a Python complex object but has a `__complex__()`
-/// method, this method will first be called to convert the object into a float.
-/// If `__complex__()` is not defined then it falls back to `__float__()`. If
-/// `__float__()` is not defined it falls back to `__index__()`.
-#[derive(Debug, PartialEq)]
-#[repr(transparent)]
-pub struct ArgIntoComplex {
-    value: Complex64,
-}
-
-impl From<ArgIntoComplex> for Complex64 {
-    fn from(arg: ArgIntoComplex) -> Self {
-        arg.value
-    }
-}
-
-impl Deref for ArgIntoComplex {
-    type Target = Complex64;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl TryFromObject for ArgIntoComplex {
-    // Equivalent to PyComplex_AsCComplex
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        // We do not care if it was already a complex.
-        let (value, _) = obj.try_complex(vm)?.ok_or_else(|| {
-            vm.new_type_error(format!("must be real number, not {}", obj.class().name()))
-        })?;
-        Ok(Self { value })
-    }
-}
-
-/// A Python float-like object.
-///
-/// `ArgIntoFloat` implements `FromArgs` so that a built-in function can accept
-/// any object that can be transformed into a float.
-///
-/// If the object is not a Python floating point object but has a `__float__()`
-/// method, this method will first be called to convert the object into a float.
-/// If `__float__()` is not defined then it falls back to `__index__()`.
-#[derive(Debug, PartialEq)]
-#[repr(transparent)]
-pub struct ArgIntoFloat {
-    value: f64,
-}
-
-impl ArgIntoFloat {
-    pub fn vec_into_f64(v: Vec<Self>) -> Vec<f64> {
-        // TODO: Vec::into_raw_parts once stabilized
-        let mut v = std::mem::ManuallyDrop::new(v);
-        let (p, l, c) = (v.as_mut_ptr(), v.len(), v.capacity());
-        // SAFETY: IntoPyFloat is repr(transparent) over f64
-        unsafe { Vec::from_raw_parts(p.cast(), l, c) }
-    }
-}
-
-impl From<ArgIntoFloat> for f64 {
-    fn from(arg: ArgIntoFloat) -> Self {
-        arg.value
-    }
-}
-
-impl Deref for ArgIntoFloat {
-    type Target = f64;
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl TryFromObject for ArgIntoFloat {
-    // Equivalent to PyFloat_AsDouble.
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let value = obj.try_float(vm)?.to_f64();
-        Ok(Self { value })
-    }
-}
-
-/// A Python bool-like object.
-///
-/// `ArgIntoBool` implements `FromArgs` so that a built-in function can accept
-/// any object that can be transformed into a boolean.
-///
-/// 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.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ArgIntoBool {
-    value: bool,
-}
-
-impl ArgIntoBool {
-    pub const TRUE: Self = Self { value: true };
-    pub const FALSE: Self = Self { value: false };
-}
-
-impl From<ArgIntoBool> for bool {
-    fn from(arg: ArgIntoBool) -> Self {
-        arg.value
-    }
-}
-
-impl Deref for ArgIntoBool {
-    type Target = bool;
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl TryFromObject for ArgIntoBool {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        Ok(Self {
-            value: obj.try_to_bool(vm)?,
-        })
-    }
-}
-
-// Implement ArgIndex to separate between "true" int and int generated by index
-#[derive(Debug, Traverse)]
-#[repr(transparent)]
-pub struct ArgIndex {
-    value: PyIntRef,
-}
-
-impl From<ArgIndex> for PyIntRef {
-    fn from(arg: ArgIndex) -> Self {
-        arg.value
-    }
-}
-
-impl Deref for ArgIndex {
-    type Target = PyIntRef;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl TryFromObject for ArgIndex {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        Ok(Self {
-            value: obj.try_index(vm)?,
-        })
-    }
-}
-
-#[derive(Debug, Copy, Clone)]
-#[repr(transparent)]
-pub struct ArgPrimitiveIndex<T> {
-    pub value: T,
-}
-
-impl<T> OptionalArg<ArgPrimitiveIndex<T>> {
-    pub fn into_primitive(self) -> OptionalArg<T> {
-        self.map(|x| x.value)
-    }
-}
-
-impl<T> Deref for ArgPrimitiveIndex<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-impl<T> TryFromObject for ArgPrimitiveIndex<T>
-where
-    T: PrimInt + for<'a> TryFrom<&'a BigInt>,
-{
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        Ok(Self {
-            value: obj.try_index(vm)?.try_to_primitive(vm)?,
-        })
-    }
-}
-
-pub type ArgSize = ArgPrimitiveIndex<isize>;
-
-impl From<ArgSize> for isize {
-    fn from(arg: ArgSize) -> Self {
-        arg.value
-    }
-}
diff --git a/vm/src/lib.rs b/vm/src/lib.rs
deleted file mode 100644
index e854518dc2..0000000000
--- a/vm/src/lib.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-//! This crate contains most of the python logic.
-//!
-//! - Interpreter
-//! - Import mechanics
-//! - Base objects
-//!
-//! Some stdlib modules are implemented here, but most of them are in the `rustpython-stdlib` module. The
-
-// to allow `mod foo {}` in foo.rs; clippy thinks this is a mistake/misunderstanding of
-// how `mod` works, but we want this sometimes for pymodule declarations
-#![allow(clippy::module_inception)]
-// we want to mirror python naming conventions when defining python structs, so that does mean
-// uppercase acronyms, e.g. TextIOWrapper instead of TextIoWrapper
-#![allow(clippy::upper_case_acronyms)]
-#![doc(html_logo_url = "https://raw.githubusercontent.com/RustPython/RustPython/main/logo.png")]
-#![doc(html_root_url = "https://docs.rs/rustpython-vm/")]
-
-#[cfg(feature = "flame-it")]
-#[macro_use]
-extern crate flamer;
-
-#[macro_use]
-extern crate bitflags;
-#[macro_use]
-extern crate log;
-// extern crate env_logger;
-
-#[macro_use]
-extern crate rustpython_derive;
-
-extern crate self as rustpython_vm;
-
-pub use rustpython_derive::*;
-
-//extern crate eval; use eval::eval::*;
-// use py_code_object::{Function, NativeType, PyCodeObject};
-
-// This is above everything else so that the defined macros are available everywhere
-#[macro_use]
-pub(crate) mod macros;
-
-mod anystr;
-pub mod buffer;
-pub mod builtins;
-pub mod byte;
-mod bytes_inner;
-pub mod cformat;
-pub mod class;
-mod codecs;
-pub mod compiler;
-pub mod convert;
-mod coroutine;
-mod dict_inner;
-#[cfg(feature = "rustpython-compiler")]
-pub mod eval;
-pub mod exceptions;
-pub mod format;
-pub mod frame;
-pub mod function;
-pub mod import;
-mod intern;
-pub mod iter;
-pub mod object;
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-pub mod ospath;
-pub mod prelude;
-pub mod protocol;
-pub mod py_io;
-#[cfg(feature = "serde")]
-pub mod py_serde;
-pub mod readline;
-pub mod recursion;
-pub mod scope;
-pub mod sequence;
-pub mod signal;
-pub mod sliceable;
-pub mod stdlib;
-pub mod suggestion;
-pub mod types;
-pub mod utils;
-pub mod version;
-pub mod vm;
-pub mod warn;
-#[cfg(windows)]
-pub mod windows;
-
-pub use self::compiler::source;
-pub use self::convert::{TryFromBorrowedObject, TryFromObject};
-pub use self::object::{
-    AsObject, Py, PyAtomicRef, PyExact, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact,
-    PyResult, PyWeakRef,
-};
-pub use self::vm::{Context, Interpreter, Settings, VirtualMachine};
-
-pub use rustpython_common as common;
-pub use rustpython_compiler_core::{bytecode, frozen};
-pub use rustpython_literal as literal;
-
-#[doc(hidden)]
-pub mod __exports {
-    pub use paste;
-}
diff --git a/vm/src/macros.rs b/vm/src/macros.rs
deleted file mode 100644
index 4554a65c26..0000000000
--- a/vm/src/macros.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-#[macro_export]
-macro_rules! extend_module {
-    ( $vm:expr, $module:expr, { $($name:expr => $value:expr),* $(,)? }) => {{
-        $(
-            $vm.__module_set_attr($module, $vm.ctx.intern_str($name), $value).unwrap();
-        )*
-    }};
-}
-
-#[macro_export]
-macro_rules! py_class {
-    ( $ctx:expr, $class_name:expr, $class_base:expr, { $($name:tt => $value:expr),* $(,)* }) => {
-        py_class!($ctx, $class_name, $class_base, $crate::types::PyTypeFlags::BASETYPE, { $($name => $value),* })
-    };
-    ( $ctx:expr, $class_name:expr, $class_base:expr, $flags:expr, { $($name:tt => $value:expr),* $(,)* }) => {
-        {
-            #[allow(unused_mut)]
-            let mut slots = $crate::types::PyTypeSlots::heap_default();
-            slots.flags = $flags;
-            $($crate::py_class!(@extract_slots($ctx, &mut slots, $name, $value));)*
-            let py_class = $ctx.new_class(None, $class_name, $class_base, slots);
-            $($crate::py_class!(@extract_attrs($ctx, &py_class, $name, $value));)*
-            py_class
-        }
-    };
-    (@extract_slots($ctx:expr, $slots:expr, (slot $slot_name:ident), $value:expr)) => {
-        $slots.$slot_name.store(Some($value));
-    };
-    (@extract_slots($ctx:expr, $class:expr, $name:expr, $value:expr)) => {};
-    (@extract_attrs($ctx:expr, $slots:expr, (slot $slot_name:ident), $value:expr)) => {};
-    (@extract_attrs($ctx:expr, $class:expr, $name:expr, $value:expr)) => {
-        $class.set_attr($name, $value);
-    };
-}
-
-#[macro_export]
-macro_rules! extend_class {
-    ( $ctx:expr, $class:expr, { $($name:expr => $value:expr),* $(,)* }) => {
-        $(
-            $class.set_attr($ctx.intern_str($name), $value.into());
-        )*
-    };
-}
-
-#[macro_export]
-macro_rules! py_namespace {
-    ( $vm:expr, { $($name:expr => $value:expr),* $(,)* }) => {
-        {
-            let namespace = $crate::builtins::PyNamespace::new_ref(&$vm.ctx);
-            let obj = $crate::object::AsObject::as_object(&namespace);
-            $(
-                obj.generic_setattr($vm.ctx.intern_str($name), $crate::function::PySetterValue::Assign($value.into()), $vm).unwrap();
-            )*
-            namespace
-        }
-    }
-}
-
-/// Macro to match on the built-in class of a Python object.
-///
-/// Like `match`, `match_class!` must be exhaustive, so a default arm without
-/// casting is required.
-///
-/// # Examples
-///
-/// ```
-/// use malachite_bigint::ToBigInt;
-/// use num_traits::Zero;
-///
-/// use rustpython_vm::match_class;
-/// use rustpython_vm::builtins::{PyFloat, PyInt};
-/// use rustpython_vm::{PyPayload};
-///
-/// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
-/// let obj = PyInt::from(0).into_pyobject(vm);
-/// assert_eq!(
-///     "int",
-///     match_class!(match obj {
-///         PyInt => "int",
-///         PyFloat => "float",
-///         _ => "neither",
-///     })
-/// );
-/// # });
-///
-/// ```
-///
-/// With a binding to the downcasted type:
-///
-/// ```
-/// use malachite_bigint::ToBigInt;
-/// use num_traits::Zero;
-///
-/// use rustpython_vm::match_class;
-/// use rustpython_vm::builtins::{PyFloat, PyInt};
-/// use rustpython_vm::{ PyPayload};
-///
-/// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
-/// let obj = PyInt::from(0).into_pyobject(vm);
-///
-/// let int_value = match_class!(match obj {
-///     i @ PyInt => i.as_bigint().clone(),
-///     f @ PyFloat => f.to_f64().to_bigint().unwrap(),
-///     obj => panic!("non-numeric object {:?}", obj),
-/// });
-///
-/// assert!(int_value.is_zero());
-/// # });
-/// ```
-#[macro_export]
-macro_rules! match_class {
-    // The default arm.
-    (match ($obj:expr) { _ => $default:expr $(,)? }) => {
-        $default
-    };
-
-    // The default arm, binding the original object to the specified identifier.
-    (match ($obj:expr) { $binding:ident => $default:expr $(,)? }) => {{
-        #[allow(clippy::redundant_locals)]
-        let $binding = $obj;
-        $default
-    }};
-    (match ($obj:expr) { ref $binding:ident => $default:expr $(,)? }) => {{
-        #[allow(clippy::redundant_locals)]
-        let $binding = &$obj;
-        $default
-    }};
-
-    // An arm taken when the object is an instance of the specified built-in
-    // class and binding the downcasted object to the specified identifier and
-    // the target expression is a block.
-    (match ($obj:expr) { $binding:ident @ $class:ty => $expr:block $($rest:tt)* }) => {
-        $crate::match_class!(match ($obj) { $binding @ $class => ($expr), $($rest)* })
-    };
-    (match ($obj:expr) { ref $binding:ident @ $class:ty => $expr:block $($rest:tt)* }) => {
-        $crate::match_class!(match ($obj) { ref $binding @ $class => ($expr), $($rest)* })
-    };
-
-    // An arm taken when the object is an instance of the specified built-in
-    // class and binding the downcasted object to the specified identifier.
-    (match ($obj:expr) { $binding:ident @ $class:ty => $expr:expr, $($rest:tt)* }) => {
-        match $obj.downcast::<$class>() {
-            Ok($binding) => $expr,
-            Err(_obj) => $crate::match_class!(match (_obj) { $($rest)* }),
-        }
-    };
-    (match ($obj:expr) { ref $binding:ident @ $class:ty => $expr:expr, $($rest:tt)* }) => {
-        match $obj.payload::<$class>() {
-            ::std::option::Option::Some($binding) => $expr,
-            ::std::option::Option::None => $crate::match_class!(match ($obj) { $($rest)* }),
-        }
-    };
-
-    // An arm taken when the object is an instance of the specified built-in
-    // class and the target expression is a block.
-    (match ($obj:expr) { $class:ty => $expr:block $($rest:tt)* }) => {
-        $crate::match_class!(match ($obj) { $class => ($expr), $($rest)* })
-    };
-
-    // An arm taken when the object is an instance of the specified built-in
-    // class.
-    (match ($obj:expr) { $class:ty => $expr:expr, $($rest:tt)* }) => {
-        if $obj.payload_is::<$class>() {
-            $expr
-        } else {
-            $crate::match_class!(match ($obj) { $($rest)* })
-        }
-    };
-
-    // To allow match expressions without parens around the match target
-    (match $($rest:tt)*) => {
-        $crate::match_class!(@parse_match () ($($rest)*))
-    };
-    (@parse_match ($($target:tt)*) ({ $($inner:tt)* })) => {
-        $crate::match_class!(match ($($target)*) { $($inner)* })
-    };
-    (@parse_match ($($target:tt)*) ($next:tt $($rest:tt)*)) => {
-        $crate::match_class!(@parse_match ($($target)* $next) ($($rest)*))
-    };
-}
-
-#[macro_export]
-macro_rules! identifier(
-    ($as_ctx:expr, $name:ident) => {
-        $as_ctx.as_ref().names.$name
-    };
-);
-
-/// Super detailed logging. Might soon overflow your log buffers
-/// Default, this logging is discarded, except when a the `vm-tracing-logging`
-/// build feature is enabled.
-macro_rules! vm_trace {
-    ($($arg:tt)+) => {
-        #[cfg(feature = "vm-tracing-logging")]
-        trace!($($arg)+);
-    }
-}
-
-macro_rules! flame_guard {
-    ($name:expr) => {
-        #[cfg(feature = "flame-it")]
-        let _guard = ::flame::start_guard($name);
-    };
-}
-
-#[macro_export]
-macro_rules! class_or_notimplemented {
-    ($t:ty, $obj:expr) => {{
-        let a: &$crate::PyObject = &*$obj;
-        match $crate::PyObject::downcast_ref::<$t>(&a) {
-            Some(pyref) => pyref,
-            None => return Ok($crate::function::PyArithmeticValue::NotImplemented),
-        }
-    }};
-}
-
-#[macro_export]
-macro_rules! named_function {
-    ($ctx:expr, $module:ident, $func:ident) => {{
-        #[allow(unused_variables)] // weird lint, something to do with paste probably
-        let ctx: &$crate::Context = &$ctx;
-        $crate::__exports::paste::expr! {
-            ctx.new_method_def(
-                stringify!($func),
-                [<$module _ $func>],
-                ::rustpython_vm::function::PyMethodFlags::empty(),
-            )
-            .to_function()
-            .with_module(ctx.intern_str(stringify!($module)).into())
-            .into_ref(ctx)
-        }
-    }};
-}
-
-// can't use PyThreadingConstraint for stuff like this since it's not an auto trait, and
-// therefore we can't add it ad-hoc to a trait object
-cfg_if::cfg_if! {
-    if #[cfg(feature = "threading")] {
-        macro_rules! py_dyn_fn {
-            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
-                dyn Fn($($arg),*) -> $ret + Send + Sync + 'static
-            };
-        }
-    } else {
-        macro_rules! py_dyn_fn {
-            (dyn Fn($($arg:ty),*$(,)*) -> $ret:ty) => {
-                dyn Fn($($arg),*) -> $ret + 'static
-            };
-        }
-    }
-}
diff --git a/vm/src/object/mod.rs b/vm/src/object/mod.rs
deleted file mode 100644
index 034523afe5..0000000000
--- a/vm/src/object/mod.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-mod core;
-mod ext;
-mod payload;
-mod traverse;
-mod traverse_object;
-
-pub use self::core::*;
-pub use self::ext::*;
-pub use self::payload::*;
-pub use traverse::{MaybeTraverse, Traverse, TraverseFn};
diff --git a/vm/src/object/payload.rs b/vm/src/object/payload.rs
deleted file mode 100644
index 6413d6ae06..0000000000
--- a/vm/src/object/payload.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-use crate::object::{MaybeTraverse, Py, PyObjectRef, PyRef, PyResult};
-use crate::{
-    PyRefExact,
-    builtins::{PyBaseExceptionRef, PyType, PyTypeRef},
-    types::PyTypeFlags,
-    vm::{Context, VirtualMachine},
-};
-
-cfg_if::cfg_if! {
-    if #[cfg(feature = "threading")] {
-        pub trait PyThreadingConstraint: Send + Sync {}
-        impl<T: Send + Sync> PyThreadingConstraint for T {}
-    } else {
-        pub trait PyThreadingConstraint {}
-        impl<T> PyThreadingConstraint for T {}
-    }
-}
-
-pub trait PyPayload:
-    std::fmt::Debug + MaybeTraverse + PyThreadingConstraint + Sized + 'static
-{
-    fn class(ctx: &Context) -> &'static Py<PyType>;
-
-    #[inline]
-    fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        self.into_ref(&vm.ctx).into()
-    }
-
-    #[inline]
-    fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self> {
-        let dict = if cls.slots.flags.has_feature(PyTypeFlags::HAS_DICT) {
-            Some(ctx.new_dict())
-        } else {
-            None
-        };
-        PyRef::new_ref(self, cls, dict)
-    }
-
-    #[inline]
-    fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self> {
-        unsafe {
-            // Self::into_ref() always returns exact typed PyRef
-            PyRefExact::new_unchecked(self.into_ref(ctx))
-        }
-    }
-
-    #[inline]
-    fn into_ref(self, ctx: &Context) -> PyRef<Self> {
-        let cls = Self::class(ctx);
-        self._into_ref(cls.to_owned(), ctx)
-    }
-
-    #[inline]
-    fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyTypeRef) -> PyResult<PyRef<Self>> {
-        let exact_class = Self::class(&vm.ctx);
-        if cls.fast_issubclass(exact_class) {
-            Ok(self._into_ref(cls, &vm.ctx))
-        } else {
-            #[cold]
-            #[inline(never)]
-            fn _into_ref_with_type_error(
-                vm: &VirtualMachine,
-                cls: &PyTypeRef,
-                exact_class: &Py<PyType>,
-            ) -> PyBaseExceptionRef {
-                vm.new_type_error(format!(
-                    "'{}' is not a subtype of '{}'",
-                    &cls.name(),
-                    exact_class.name()
-                ))
-            }
-            Err(_into_ref_with_type_error(vm, &cls, exact_class))
-        }
-    }
-}
-
-pub trait PyObjectPayload:
-    std::any::Any + std::fmt::Debug + MaybeTraverse + PyThreadingConstraint + 'static
-{
-}
-
-impl<T: PyPayload + 'static> PyObjectPayload for T {}
-
-pub trait SlotOffset {
-    fn offset() -> usize;
-}
diff --git a/vm/src/ospath.rs b/vm/src/ospath.rs
deleted file mode 100644
index dde1f47af0..0000000000
--- a/vm/src/ospath.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-use crate::{
-    PyObjectRef, PyResult, VirtualMachine,
-    builtins::PyBaseExceptionRef,
-    convert::{ToPyException, TryFromObject},
-    function::FsPath,
-    object::AsObject,
-};
-use std::path::{Path, PathBuf};
-
-// path_ without allow_fd in CPython
-#[derive(Clone)]
-pub struct OsPath {
-    pub path: std::ffi::OsString,
-    pub(super) mode: OutputMode,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub(super) enum OutputMode {
-    String,
-    Bytes,
-}
-
-impl OutputMode {
-    pub(super) fn process_path(self, path: impl Into<PathBuf>, vm: &VirtualMachine) -> PyObjectRef {
-        fn inner(mode: OutputMode, path: PathBuf, vm: &VirtualMachine) -> PyObjectRef {
-            match mode {
-                OutputMode::String => vm.fsdecode(path).into(),
-                OutputMode::Bytes => vm
-                    .ctx
-                    .new_bytes(path.into_os_string().into_encoded_bytes())
-                    .into(),
-            }
-        }
-        inner(self, path.into(), vm)
-    }
-}
-
-impl OsPath {
-    pub fn new_str(path: impl Into<std::ffi::OsString>) -> Self {
-        let path = path.into();
-        Self {
-            path,
-            mode: OutputMode::String,
-        }
-    }
-
-    pub(crate) fn from_fspath(fspath: FsPath, vm: &VirtualMachine) -> PyResult<Self> {
-        let path = fspath.as_os_str(vm)?.into_owned();
-        let mode = match fspath {
-            FsPath::Str(_) => OutputMode::String,
-            FsPath::Bytes(_) => OutputMode::Bytes,
-        };
-        Ok(Self { path, mode })
-    }
-
-    pub fn as_path(&self) -> &Path {
-        Path::new(&self.path)
-    }
-
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.path.into_encoded_bytes()
-    }
-
-    pub fn to_string_lossy(&self) -> std::borrow::Cow<'_, str> {
-        self.path.to_string_lossy()
-    }
-
-    pub fn into_cstring(self, vm: &VirtualMachine) -> PyResult<std::ffi::CString> {
-        std::ffi::CString::new(self.into_bytes()).map_err(|err| err.to_pyexception(vm))
-    }
-
-    #[cfg(windows)]
-    pub fn to_wide_cstring(&self, vm: &VirtualMachine) -> PyResult<widestring::WideCString> {
-        widestring::WideCString::from_os_str(&self.path).map_err(|err| err.to_pyexception(vm))
-    }
-
-    pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {
-        self.mode.process_path(self.path.clone(), vm)
-    }
-}
-
-impl AsRef<Path> for OsPath {
-    fn as_ref(&self) -> &Path {
-        self.as_path()
-    }
-}
-
-impl TryFromObject for OsPath {
-    // TODO: path_converter with allow_fd=0 in CPython
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let fspath = FsPath::try_from(obj, true, vm)?;
-        Self::from_fspath(fspath, vm)
-    }
-}
-
-// path_t with allow_fd in CPython
-#[derive(Clone)]
-pub(crate) enum OsPathOrFd {
-    Path(OsPath),
-    Fd(i32),
-}
-
-impl TryFromObject for OsPathOrFd {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let r = match obj.try_index_opt(vm) {
-            Some(int) => Self::Fd(int?.try_to_primitive(vm)?),
-            None => Self::Path(obj.try_into_value(vm)?),
-        };
-        Ok(r)
-    }
-}
-
-impl From<OsPath> for OsPathOrFd {
-    fn from(path: OsPath) -> Self {
-        Self::Path(path)
-    }
-}
-
-impl OsPathOrFd {
-    pub fn filename(&self, vm: &VirtualMachine) -> PyObjectRef {
-        match self {
-            Self::Path(path) => path.filename(vm),
-            Self::Fd(fd) => vm.ctx.new_int(*fd).into(),
-        }
-    }
-}
-
-// TODO: preserve the input `PyObjectRef` of filename and filename2 (Failing check `self.assertIs(err.filename, name, str(func)`)
-pub struct IOErrorBuilder<'a> {
-    error: &'a std::io::Error,
-    filename: Option<OsPathOrFd>,
-    filename2: Option<OsPathOrFd>,
-}
-
-impl<'a> IOErrorBuilder<'a> {
-    pub const fn new(error: &'a std::io::Error) -> Self {
-        Self {
-            error,
-            filename: None,
-            filename2: None,
-        }
-    }
-
-    pub(crate) fn filename(mut self, filename: impl Into<OsPathOrFd>) -> Self {
-        let filename = filename.into();
-        self.filename.replace(filename);
-        self
-    }
-
-    pub(crate) fn filename2(mut self, filename: impl Into<OsPathOrFd>) -> Self {
-        let filename = filename.into();
-        self.filename2.replace(filename);
-        self
-    }
-
-    pub(crate) fn with_filename(
-        error: &'a std::io::Error,
-        filename: impl Into<OsPathOrFd>,
-        vm: &VirtualMachine,
-    ) -> PyBaseExceptionRef {
-        let zelf = Self {
-            error,
-            filename: Some(filename.into()),
-            filename2: None,
-        };
-        zelf.to_pyexception(vm)
-    }
-}
-
-impl ToPyException for IOErrorBuilder<'_> {
-    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        let exc = self.error.to_pyexception(vm);
-
-        if let Some(filename) = &self.filename {
-            exc.as_object()
-                .set_attr("filename", filename.filename(vm), vm)
-                .unwrap();
-        }
-        if let Some(filename2) = &self.filename2 {
-            exc.as_object()
-                .set_attr("filename2", filename2.filename(vm), vm)
-                .unwrap();
-        }
-        exc
-    }
-}
diff --git a/vm/src/protocol/buffer.rs b/vm/src/protocol/buffer.rs
deleted file mode 100644
index 1b1a4a14df..0000000000
--- a/vm/src/protocol/buffer.rs
+++ /dev/null
@@ -1,450 +0,0 @@
-//! Buffer protocol
-//! <https://docs.python.org/3/c-api/buffer.html>
-
-use crate::{
-    Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject, VirtualMachine,
-    common::{
-        borrow::{BorrowedValue, BorrowedValueMut},
-        lock::{MapImmutable, PyMutex, PyMutexGuard},
-    },
-    object::PyObjectPayload,
-    sliceable::SequenceIndexOp,
-    types::Unconstructible,
-};
-use itertools::Itertools;
-use std::{borrow::Cow, fmt::Debug, ops::Range};
-
-pub struct BufferMethods {
-    pub obj_bytes: fn(&PyBuffer) -> BorrowedValue<'_, [u8]>,
-    pub obj_bytes_mut: fn(&PyBuffer) -> BorrowedValueMut<'_, [u8]>,
-    pub release: fn(&PyBuffer),
-    pub retain: fn(&PyBuffer),
-}
-
-impl Debug for BufferMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("BufferMethods")
-            .field("obj_bytes", &(self.obj_bytes as usize))
-            .field("obj_bytes_mut", &(self.obj_bytes_mut as usize))
-            .field("release", &(self.release as usize))
-            .field("retain", &(self.retain as usize))
-            .finish()
-    }
-}
-
-#[derive(Debug, Clone, Traverse)]
-pub struct PyBuffer {
-    pub obj: PyObjectRef,
-    #[pytraverse(skip)]
-    pub desc: BufferDescriptor,
-    #[pytraverse(skip)]
-    methods: &'static BufferMethods,
-}
-
-impl PyBuffer {
-    pub fn new(obj: PyObjectRef, desc: BufferDescriptor, methods: &'static BufferMethods) -> Self {
-        let zelf = Self {
-            obj,
-            desc: desc.validate(),
-            methods,
-        };
-        zelf.retain();
-        zelf
-    }
-
-    pub fn as_contiguous(&self) -> Option<BorrowedValue<'_, [u8]>> {
-        self.desc
-            .is_contiguous()
-            .then(|| unsafe { self.contiguous_unchecked() })
-    }
-
-    pub fn as_contiguous_mut(&self) -> Option<BorrowedValueMut<'_, [u8]>> {
-        (!self.desc.readonly && self.desc.is_contiguous())
-            .then(|| unsafe { self.contiguous_mut_unchecked() })
-    }
-
-    pub fn from_byte_vector(bytes: Vec<u8>, vm: &VirtualMachine) -> Self {
-        let bytes_len = bytes.len();
-        Self::new(
-            PyPayload::into_pyobject(VecBuffer::from(bytes), vm),
-            BufferDescriptor::simple(bytes_len, true),
-            &VEC_BUFFER_METHODS,
-        )
-    }
-
-    /// # Safety
-    /// assume the buffer is contiguous
-    pub unsafe fn contiguous_unchecked(&self) -> BorrowedValue<'_, [u8]> {
-        self.obj_bytes()
-    }
-
-    /// # Safety
-    /// assume the buffer is contiguous and writable
-    pub unsafe fn contiguous_mut_unchecked(&self) -> BorrowedValueMut<'_, [u8]> {
-        self.obj_bytes_mut()
-    }
-
-    pub fn append_to(&self, buf: &mut Vec<u8>) {
-        if let Some(bytes) = self.as_contiguous() {
-            buf.extend_from_slice(&bytes);
-        } else {
-            let bytes = &*self.obj_bytes();
-            self.desc.for_each_segment(true, |range| {
-                buf.extend_from_slice(&bytes[range.start as usize..range.end as usize])
-            });
-        }
-    }
-
-    pub fn contiguous_or_collect<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
-        let borrowed;
-        let mut collected;
-        let v = if let Some(bytes) = self.as_contiguous() {
-            borrowed = bytes;
-            &*borrowed
-        } else {
-            collected = vec![];
-            self.append_to(&mut collected);
-            &collected
-        };
-        f(v)
-    }
-
-    pub fn obj_as<T: PyObjectPayload>(&self) -> &Py<T> {
-        unsafe { self.obj.downcast_unchecked_ref() }
-    }
-
-    pub fn obj_bytes(&self) -> BorrowedValue<'_, [u8]> {
-        (self.methods.obj_bytes)(self)
-    }
-
-    pub fn obj_bytes_mut(&self) -> BorrowedValueMut<'_, [u8]> {
-        (self.methods.obj_bytes_mut)(self)
-    }
-
-    pub fn release(&self) {
-        (self.methods.release)(self)
-    }
-
-    pub fn retain(&self) {
-        (self.methods.retain)(self)
-    }
-
-    // drop PyBuffer without calling release
-    // after this function, the owner should use forget()
-    // or wrap PyBuffer in the ManuallyDrop to prevent drop()
-    pub(crate) unsafe fn drop_without_release(&mut self) {
-        // SAFETY: requirements forwarded from caller
-        unsafe {
-            std::ptr::drop_in_place(&mut self.obj);
-            std::ptr::drop_in_place(&mut self.desc);
-        }
-    }
-}
-
-impl<'a> TryFromBorrowedObject<'a> for PyBuffer {
-    fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a PyObject) -> PyResult<Self> {
-        let cls = obj.class();
-        let as_buffer = cls.mro_find_map(|cls| cls.slots.as_buffer);
-        if let Some(f) = as_buffer {
-            return f(obj, vm);
-        }
-        Err(vm.new_type_error(format!(
-            "a bytes-like object is required, not '{}'",
-            cls.name()
-        )))
-    }
-}
-
-impl Drop for PyBuffer {
-    fn drop(&mut self) {
-        self.release();
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct BufferDescriptor {
-    /// product(shape) * itemsize
-    /// bytes length, but not the length for obj_bytes() even is contiguous
-    pub len: usize,
-    pub readonly: bool,
-    pub itemsize: usize,
-    pub format: Cow<'static, str>,
-    /// (shape, stride, suboffset) for each dimension
-    pub dim_desc: Vec<(usize, isize, isize)>,
-    // TODO: flags
-}
-
-impl BufferDescriptor {
-    pub fn simple(bytes_len: usize, readonly: bool) -> Self {
-        Self {
-            len: bytes_len,
-            readonly,
-            itemsize: 1,
-            format: Cow::Borrowed("B"),
-            dim_desc: vec![(bytes_len, 1, 0)],
-        }
-    }
-
-    pub fn format(
-        bytes_len: usize,
-        readonly: bool,
-        itemsize: usize,
-        format: Cow<'static, str>,
-    ) -> Self {
-        Self {
-            len: bytes_len,
-            readonly,
-            itemsize,
-            format,
-            dim_desc: vec![(bytes_len / itemsize, itemsize as isize, 0)],
-        }
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn validate(self) -> Self {
-        assert!(self.itemsize != 0);
-        assert!(self.ndim() != 0);
-        let mut shape_product = 1;
-        for (shape, stride, suboffset) in self.dim_desc.iter().cloned() {
-            shape_product *= shape;
-            assert!(suboffset >= 0);
-            assert!(stride != 0);
-        }
-        assert!(shape_product * self.itemsize == self.len);
-        self
-    }
-
-    #[cfg(not(debug_assertions))]
-    pub fn validate(self) -> Self {
-        self
-    }
-
-    pub fn ndim(&self) -> usize {
-        self.dim_desc.len()
-    }
-
-    pub fn is_contiguous(&self) -> bool {
-        if self.len == 0 {
-            return true;
-        }
-        let mut sd = self.itemsize;
-        for (shape, stride, _) in self.dim_desc.iter().cloned().rev() {
-            if shape > 1 && stride != sd as isize {
-                return false;
-            }
-            sd *= shape;
-        }
-        true
-    }
-
-    /// this function do not check the bound
-    /// panic if indices.len() != ndim
-    pub fn fast_position(&self, indices: &[usize]) -> isize {
-        let mut pos = 0;
-        for (i, (_, stride, suboffset)) in indices
-            .iter()
-            .cloned()
-            .zip_eq(self.dim_desc.iter().cloned())
-        {
-            pos += i as isize * stride + suboffset;
-        }
-        pos
-    }
-
-    /// panic if indices.len() != ndim
-    pub fn position(&self, indices: &[isize], vm: &VirtualMachine) -> PyResult<isize> {
-        let mut pos = 0;
-        for (i, (shape, stride, suboffset)) in indices
-            .iter()
-            .cloned()
-            .zip_eq(self.dim_desc.iter().cloned())
-        {
-            let i = i.wrapped_at(shape).ok_or_else(|| {
-                vm.new_index_error(format!("index out of bounds on dimension {i}"))
-            })?;
-            pos += i as isize * stride + suboffset;
-        }
-        Ok(pos)
-    }
-
-    pub fn for_each_segment<F>(&self, try_contiguous: bool, mut f: F)
-    where
-        F: FnMut(Range<isize>),
-    {
-        if self.ndim() == 0 {
-            f(0..self.itemsize as isize);
-            return;
-        }
-        if try_contiguous && self.is_last_dim_contiguous() {
-            self._for_each_segment::<_, true>(0, 0, &mut f);
-        } else {
-            self._for_each_segment::<_, false>(0, 0, &mut f);
-        }
-    }
-
-    fn _for_each_segment<F, const CONTIGUOUS: bool>(&self, mut index: isize, dim: usize, f: &mut F)
-    where
-        F: FnMut(Range<isize>),
-    {
-        let (shape, stride, suboffset) = self.dim_desc[dim];
-        if dim + 1 == self.ndim() {
-            if CONTIGUOUS {
-                f(index..index + (shape * self.itemsize) as isize);
-            } else {
-                for _ in 0..shape {
-                    let pos = index + suboffset;
-                    f(pos..pos + self.itemsize as isize);
-                    index += stride;
-                }
-            }
-            return;
-        }
-        for _ in 0..shape {
-            self._for_each_segment::<F, CONTIGUOUS>(index + suboffset, dim + 1, f);
-            index += stride;
-        }
-    }
-
-    /// zip two BufferDescriptor with the same shape
-    pub fn zip_eq<F>(&self, other: &Self, try_contiguous: bool, mut f: F)
-    where
-        F: FnMut(Range<isize>, Range<isize>) -> bool,
-    {
-        if self.ndim() == 0 {
-            f(0..self.itemsize as isize, 0..other.itemsize as isize);
-            return;
-        }
-        if try_contiguous && self.is_last_dim_contiguous() {
-            self._zip_eq::<_, true>(other, 0, 0, 0, &mut f);
-        } else {
-            self._zip_eq::<_, false>(other, 0, 0, 0, &mut f);
-        }
-    }
-
-    fn _zip_eq<F, const CONTIGUOUS: bool>(
-        &self,
-        other: &Self,
-        mut a_index: isize,
-        mut b_index: isize,
-        dim: usize,
-        f: &mut F,
-    ) where
-        F: FnMut(Range<isize>, Range<isize>) -> bool,
-    {
-        let (shape, a_stride, a_suboffset) = self.dim_desc[dim];
-        let (_b_shape, b_stride, b_suboffset) = other.dim_desc[dim];
-        debug_assert_eq!(shape, _b_shape);
-        if dim + 1 == self.ndim() {
-            if CONTIGUOUS {
-                if f(
-                    a_index..a_index + (shape * self.itemsize) as isize,
-                    b_index..b_index + (shape * other.itemsize) as isize,
-                ) {
-                    return;
-                }
-            } else {
-                for _ in 0..shape {
-                    let a_pos = a_index + a_suboffset;
-                    let b_pos = b_index + b_suboffset;
-                    if f(
-                        a_pos..a_pos + self.itemsize as isize,
-                        b_pos..b_pos + other.itemsize as isize,
-                    ) {
-                        return;
-                    }
-                    a_index += a_stride;
-                    b_index += b_stride;
-                }
-            }
-            return;
-        }
-
-        for _ in 0..shape {
-            self._zip_eq::<F, CONTIGUOUS>(
-                other,
-                a_index + a_suboffset,
-                b_index + b_suboffset,
-                dim + 1,
-                f,
-            );
-            a_index += a_stride;
-            b_index += b_stride;
-        }
-    }
-
-    fn is_last_dim_contiguous(&self) -> bool {
-        let (_, stride, suboffset) = self.dim_desc[self.ndim() - 1];
-        suboffset == 0 && stride == self.itemsize as isize
-    }
-
-    pub fn is_zero_in_shape(&self) -> bool {
-        self.dim_desc.iter().any(|(shape, _, _)| *shape == 0)
-    }
-
-    // TODO: support column-major order
-}
-
-pub trait BufferResizeGuard {
-    type Resizable<'a>: 'a
-    where
-        Self: 'a;
-    fn try_resizable_opt(&self) -> Option<Self::Resizable<'_>>;
-    fn try_resizable(&self, vm: &VirtualMachine) -> PyResult<Self::Resizable<'_>> {
-        self.try_resizable_opt().ok_or_else(|| {
-            vm.new_buffer_error("Existing exports of data: object cannot be re-sized")
-        })
-    }
-}
-
-#[pyclass(module = false, name = "vec_buffer")]
-#[derive(Debug, PyPayload)]
-pub struct VecBuffer {
-    data: PyMutex<Vec<u8>>,
-}
-
-#[pyclass(flags(BASETYPE), with(Unconstructible))]
-impl VecBuffer {
-    pub fn take(&self) -> Vec<u8> {
-        std::mem::take(&mut self.data.lock())
-    }
-}
-
-impl From<Vec<u8>> for VecBuffer {
-    fn from(data: Vec<u8>) -> Self {
-        Self {
-            data: PyMutex::new(data),
-        }
-    }
-}
-
-impl Unconstructible for VecBuffer {}
-
-impl PyRef<VecBuffer> {
-    pub fn into_pybuffer(self, readonly: bool) -> PyBuffer {
-        let len = self.data.lock().len();
-        PyBuffer::new(
-            self.into(),
-            BufferDescriptor::simple(len, readonly),
-            &VEC_BUFFER_METHODS,
-        )
-    }
-
-    pub fn into_pybuffer_with_descriptor(self, desc: BufferDescriptor) -> PyBuffer {
-        PyBuffer::new(self.into(), desc, &VEC_BUFFER_METHODS)
-    }
-}
-
-static VEC_BUFFER_METHODS: BufferMethods = BufferMethods {
-    obj_bytes: |buffer| {
-        PyMutexGuard::map_immutable(buffer.obj_as::<VecBuffer>().data.lock(), |x| x.as_slice())
-            .into()
-    },
-    obj_bytes_mut: |buffer| {
-        PyMutexGuard::map(buffer.obj_as::<VecBuffer>().data.lock(), |x| {
-            x.as_mut_slice()
-        })
-        .into()
-    },
-    release: |_| {},
-    retain: |_| {},
-};
diff --git a/vm/src/protocol/iter.rs b/vm/src/protocol/iter.rs
deleted file mode 100644
index 18f2b5243e..0000000000
--- a/vm/src/protocol/iter.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyPayload, PyResult, TryFromObject, VirtualMachine,
-    builtins::iter::PySequenceIterator,
-    convert::{ToPyObject, ToPyResult},
-    object::{Traverse, TraverseFn},
-};
-use std::borrow::Borrow;
-use std::ops::Deref;
-
-/// Iterator Protocol
-// https://docs.python.org/3/c-api/iter.html
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-pub struct PyIter<O = PyObjectRef>(O)
-where
-    O: Borrow<PyObject>;
-
-unsafe impl<O: Borrow<PyObject>> Traverse for PyIter<O> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.0.borrow().traverse(tracer_fn);
-    }
-}
-
-impl PyIter<PyObjectRef> {
-    pub fn check(obj: &PyObject) -> bool {
-        obj.class()
-            .mro_find_map(|x| x.slots.iternext.load())
-            .is_some()
-    }
-}
-
-impl<O> PyIter<O>
-where
-    O: Borrow<PyObject>,
-{
-    pub const fn new(obj: O) -> Self {
-        Self(obj)
-    }
-    pub fn next(&self, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let iternext = {
-            self.0
-                .borrow()
-                .class()
-                .mro_find_map(|x| x.slots.iternext.load())
-                .ok_or_else(|| {
-                    vm.new_type_error(format!(
-                        "'{}' object is not an iterator",
-                        self.0.borrow().class().name()
-                    ))
-                })?
-        };
-        iternext(self.0.borrow(), vm)
-    }
-
-    pub fn iter<'a, 'b, U>(
-        &'b self,
-        vm: &'a VirtualMachine,
-    ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
-        let length_hint = vm.length_hint_opt(self.as_ref().to_owned())?;
-        Ok(PyIterIter::new(vm, self.0.borrow(), length_hint))
-    }
-
-    pub fn iter_without_hint<'a, 'b, U>(
-        &'b self,
-        vm: &'a VirtualMachine,
-    ) -> PyResult<PyIterIter<'a, U, &'b PyObject>> {
-        Ok(PyIterIter::new(vm, self.0.borrow(), None))
-    }
-}
-
-impl PyIter<PyObjectRef> {
-    /// Returns an iterator over this sequence of objects.
-    pub fn into_iter<U>(self, vm: &VirtualMachine) -> PyResult<PyIterIter<'_, U, PyObjectRef>> {
-        let length_hint = vm.length_hint_opt(self.as_object().to_owned())?;
-        Ok(PyIterIter::new(vm, self.0, length_hint))
-    }
-}
-
-impl From<PyIter<Self>> for PyObjectRef {
-    fn from(value: PyIter<Self>) -> Self {
-        value.0
-    }
-}
-
-impl<O> Borrow<PyObject> for PyIter<O>
-where
-    O: Borrow<PyObject>,
-{
-    #[inline(always)]
-    fn borrow(&self) -> &PyObject {
-        self.0.borrow()
-    }
-}
-
-impl<O> AsRef<PyObject> for PyIter<O>
-where
-    O: Borrow<PyObject>,
-{
-    #[inline(always)]
-    fn as_ref(&self) -> &PyObject {
-        self.0.borrow()
-    }
-}
-
-impl<O> Deref for PyIter<O>
-where
-    O: Borrow<PyObject>,
-{
-    type Target = PyObject;
-
-    #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        self.0.borrow()
-    }
-}
-
-impl ToPyObject for PyIter<PyObjectRef> {
-    #[inline(always)]
-    fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
-        self.into()
-    }
-}
-
-impl TryFromObject for PyIter<PyObjectRef> {
-    // This helper function is called at multiple places. First, it is called
-    // in the vm when a for loop is entered. Next, it is used when the builtin
-    // function 'iter' is called.
-    fn try_from_object(vm: &VirtualMachine, iter_target: PyObjectRef) -> PyResult<Self> {
-        let get_iter = {
-            let cls = iter_target.class();
-            cls.mro_find_map(|x| x.slots.iter.load())
-        };
-        if let Some(get_iter) = get_iter {
-            let iter = get_iter(iter_target, vm)?;
-            if Self::check(&iter) {
-                Ok(Self(iter))
-            } else {
-                Err(vm.new_type_error(format!(
-                    "iter() returned non-iterator of type '{}'",
-                    iter.class().name()
-                )))
-            }
-        } else if let Ok(seq_iter) = PySequenceIterator::new(iter_target.clone(), vm) {
-            Ok(Self(seq_iter.into_pyobject(vm)))
-        } else {
-            Err(vm.new_type_error(format!(
-                "'{}' object is not iterable",
-                iter_target.class().name()
-            )))
-        }
-    }
-}
-
-#[derive(result_like::ResultLike)]
-pub enum PyIterReturn<T = PyObjectRef> {
-    Return(T),
-    StopIteration(Option<PyObjectRef>),
-}
-
-unsafe impl<T: Traverse> Traverse for PyIterReturn<T> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        match self {
-            Self::Return(r) => r.traverse(tracer_fn),
-            Self::StopIteration(Some(obj)) => obj.traverse(tracer_fn),
-            _ => (),
-        }
-    }
-}
-
-impl PyIterReturn {
-    pub fn from_pyresult(result: PyResult, vm: &VirtualMachine) -> PyResult<Self> {
-        match result {
-            Ok(obj) => Ok(Self::Return(obj)),
-            Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
-                let args = err.get_arg(0);
-                Ok(Self::StopIteration(args))
-            }
-            Err(err) => Err(err),
-        }
-    }
-
-    pub fn from_getitem_result(result: PyResult, vm: &VirtualMachine) -> PyResult<Self> {
-        match result {
-            Ok(obj) => Ok(Self::Return(obj)),
-            Err(err) if err.fast_isinstance(vm.ctx.exceptions.index_error) => {
-                Ok(Self::StopIteration(None))
-            }
-            Err(err) if err.fast_isinstance(vm.ctx.exceptions.stop_iteration) => {
-                let args = err.get_arg(0);
-                Ok(Self::StopIteration(args))
-            }
-            Err(err) => Err(err),
-        }
-    }
-
-    pub fn into_async_pyresult(self, vm: &VirtualMachine) -> PyResult {
-        match self {
-            Self::Return(obj) => Ok(obj),
-            Self::StopIteration(v) => Err({
-                let args = if let Some(v) = v { vec![v] } else { Vec::new() };
-                vm.new_exception(vm.ctx.exceptions.stop_async_iteration.to_owned(), args)
-            }),
-        }
-    }
-}
-
-impl ToPyResult for PyIterReturn {
-    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
-        match self {
-            Self::Return(obj) => Ok(obj),
-            Self::StopIteration(v) => Err(vm.new_stop_iteration(v)),
-        }
-    }
-}
-
-impl ToPyResult for PyResult<PyIterReturn> {
-    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
-        self?.to_pyresult(vm)
-    }
-}
-
-// Typical rust `Iter` object for `PyIter`
-pub struct PyIterIter<'a, T, O = PyObjectRef>
-where
-    O: Borrow<PyObject>,
-{
-    vm: &'a VirtualMachine,
-    obj: O, // creating PyIter<O> is zero-cost
-    length_hint: Option<usize>,
-    _phantom: std::marker::PhantomData<T>,
-}
-
-unsafe impl<T, O> Traverse for PyIterIter<'_, T, O>
-where
-    O: Traverse + Borrow<PyObject>,
-{
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.obj.traverse(tracer_fn)
-    }
-}
-
-impl<'a, T, O> PyIterIter<'a, T, O>
-where
-    O: Borrow<PyObject>,
-{
-    pub const fn new(vm: &'a VirtualMachine, obj: O, length_hint: Option<usize>) -> Self {
-        Self {
-            vm,
-            obj,
-            length_hint,
-            _phantom: std::marker::PhantomData,
-        }
-    }
-}
-
-impl<T, O> Iterator for PyIterIter<'_, T, O>
-where
-    T: TryFromObject,
-    O: Borrow<PyObject>,
-{
-    type Item = PyResult<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let imp = |next: PyResult<PyIterReturn>| -> PyResult<Option<T>> {
-            let Some(obj) = next?.into_result().ok() else {
-                return Ok(None);
-            };
-            Ok(Some(T::try_from_object(self.vm, obj)?))
-        };
-        let next = PyIter::new(self.obj.borrow()).next(self.vm);
-        imp(next).transpose()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.length_hint.unwrap_or(0), self.length_hint)
-    }
-}
-
-/// Macro to handle `PyIterReturn` values in iterator implementations.
-///
-/// Extracts the object from `PyIterReturn::Return(obj)` or performs early return
-/// for `PyIterReturn::StopIteration(v)`. This macro should only be used within
-/// functions that return `PyResult<PyIterReturn>`.
-#[macro_export]
-macro_rules! raise_if_stop {
-    ($input:expr) => {
-        match $input {
-            $crate::protocol::PyIterReturn::Return(obj) => obj,
-            $crate::protocol::PyIterReturn::StopIteration(v) => {
-                return Ok($crate::protocol::PyIterReturn::StopIteration(v))
-            }
-        }
-    };
-}
diff --git a/vm/src/protocol/mapping.rs b/vm/src/protocol/mapping.rs
deleted file mode 100644
index f5da3f7de6..0000000000
--- a/vm/src/protocol/mapping.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyResult, VirtualMachine,
-    builtins::{
-        PyDict, PyStrInterned,
-        dict::{PyDictItems, PyDictKeys, PyDictValues},
-        type_::PointerSlot,
-    },
-    convert::ToPyResult,
-    object::{Traverse, TraverseFn},
-};
-use crossbeam_utils::atomic::AtomicCell;
-
-// Mapping protocol
-// https://docs.python.org/3/c-api/mapping.html
-
-impl PyObject {
-    pub fn to_mapping(&self) -> PyMapping<'_> {
-        PyMapping::from(self)
-    }
-}
-
-#[allow(clippy::type_complexity)]
-#[derive(Default)]
-pub struct PyMappingMethods {
-    pub length: AtomicCell<Option<fn(PyMapping<'_>, &VirtualMachine) -> PyResult<usize>>>,
-    pub subscript: AtomicCell<Option<fn(PyMapping<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub ass_subscript: AtomicCell<
-        Option<fn(PyMapping<'_>, &PyObject, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
-    >,
-}
-
-impl std::fmt::Debug for PyMappingMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "mapping methods")
-    }
-}
-
-impl PyMappingMethods {
-    fn check(&self) -> bool {
-        self.subscript.load().is_some()
-    }
-
-    #[allow(clippy::declare_interior_mutable_const)]
-    pub const NOT_IMPLEMENTED: Self = Self {
-        length: AtomicCell::new(None),
-        subscript: AtomicCell::new(None),
-        ass_subscript: AtomicCell::new(None),
-    };
-}
-
-impl<'a> From<&'a PyObject> for PyMapping<'a> {
-    fn from(obj: &'a PyObject) -> Self {
-        static GLOBAL_NOT_IMPLEMENTED: PyMappingMethods = PyMappingMethods::NOT_IMPLEMENTED;
-        let methods = Self::find_methods(obj)
-            .map_or(&GLOBAL_NOT_IMPLEMENTED, |x| unsafe { x.borrow_static() });
-        Self { obj, methods }
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct PyMapping<'a> {
-    pub obj: &'a PyObject,
-    pub methods: &'static PyMappingMethods,
-}
-
-unsafe impl Traverse for PyMapping<'_> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.obj.traverse(tracer_fn)
-    }
-}
-
-impl AsRef<PyObject> for PyMapping<'_> {
-    #[inline(always)]
-    fn as_ref(&self) -> &PyObject {
-        self.obj
-    }
-}
-
-impl<'a> PyMapping<'a> {
-    pub fn try_protocol(obj: &'a PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-        if let Some(methods) = Self::find_methods(obj) {
-            if methods.as_ref().check() {
-                return Ok(Self {
-                    obj,
-                    methods: unsafe { methods.borrow_static() },
-                });
-            }
-        }
-
-        Err(vm.new_type_error(format!("{} is not a mapping object", obj.class())))
-    }
-}
-
-impl PyMapping<'_> {
-    // PyMapping::Check
-    #[inline]
-    pub fn check(obj: &PyObject) -> bool {
-        Self::find_methods(obj).is_some_and(|x| x.as_ref().check())
-    }
-
-    pub fn find_methods(obj: &PyObject) -> Option<PointerSlot<PyMappingMethods>> {
-        obj.class().mro_find_map(|cls| cls.slots.as_mapping.load())
-    }
-
-    pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.methods.length.load().map(|f| f(self, vm))
-    }
-
-    pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
-        self.length_opt(vm).ok_or_else(|| {
-            vm.new_type_error(format!(
-                "object of type '{}' has no len() or not a mapping",
-                self.obj.class()
-            ))
-        })?
-    }
-
-    pub fn subscript(self, needle: &impl AsObject, vm: &VirtualMachine) -> PyResult {
-        self._subscript(needle.as_object(), vm)
-    }
-
-    pub fn ass_subscript(
-        self,
-        needle: &impl AsObject,
-        value: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        self._ass_subscript(needle.as_object(), value, vm)
-    }
-
-    fn _subscript(self, needle: &PyObject, vm: &VirtualMachine) -> PyResult {
-        let f =
-            self.methods.subscript.load().ok_or_else(|| {
-                vm.new_type_error(format!("{} is not a mapping", self.obj.class()))
-            })?;
-        f(self, needle, vm)
-    }
-
-    fn _ass_subscript(
-        self,
-        needle: &PyObject,
-        value: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let f = self.methods.ass_subscript.load().ok_or_else(|| {
-            vm.new_type_error(format!(
-                "'{}' object does not support item assignment",
-                self.obj.class()
-            ))
-        })?;
-        f(self, needle, value, vm)
-    }
-
-    pub fn keys(self, vm: &VirtualMachine) -> PyResult {
-        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
-            PyDictKeys::new(dict.to_owned()).to_pyresult(vm)
-        } else {
-            self.method_output_as_list(identifier!(vm, keys), vm)
-        }
-    }
-
-    pub fn values(self, vm: &VirtualMachine) -> PyResult {
-        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
-            PyDictValues::new(dict.to_owned()).to_pyresult(vm)
-        } else {
-            self.method_output_as_list(identifier!(vm, values), vm)
-        }
-    }
-
-    pub fn items(self, vm: &VirtualMachine) -> PyResult {
-        if let Some(dict) = self.obj.downcast_ref_if_exact::<PyDict>(vm) {
-            PyDictItems::new(dict.to_owned()).to_pyresult(vm)
-        } else {
-            self.method_output_as_list(identifier!(vm, items), vm)
-        }
-    }
-
-    fn method_output_as_list(
-        self,
-        method_name: &'static PyStrInterned,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let meth_output = vm.call_method(self.obj, method_name.as_str(), ())?;
-        if meth_output.is(vm.ctx.types.list_type) {
-            return Ok(meth_output);
-        }
-
-        let iter = meth_output.get_iter(vm).map_err(|_| {
-            vm.new_type_error(format!(
-                "{}.{}() returned a non-iterable (type {})",
-                self.obj.class(),
-                method_name.as_str(),
-                meth_output.class()
-            ))
-        })?;
-
-        // TODO
-        // PySequence::from(&iter).list(vm).map(|x| x.into())
-        vm.ctx.new_list(iter.try_to_value(vm)?).to_pyresult(vm)
-    }
-}
diff --git a/vm/src/protocol/mod.rs b/vm/src/protocol/mod.rs
deleted file mode 100644
index 989cca73d8..0000000000
--- a/vm/src/protocol/mod.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-mod buffer;
-mod callable;
-mod iter;
-mod mapping;
-mod number;
-mod object;
-mod sequence;
-
-pub use buffer::{BufferDescriptor, BufferMethods, BufferResizeGuard, PyBuffer, VecBuffer};
-pub use callable::PyCallable;
-pub use iter::{PyIter, PyIterIter, PyIterReturn};
-pub use mapping::{PyMapping, PyMappingMethods};
-pub use number::{
-    PyNumber, PyNumberBinaryFunc, PyNumberBinaryOp, PyNumberMethods, PyNumberSlots,
-    PyNumberTernaryOp, PyNumberUnaryFunc,
-};
-pub use sequence::{PySequence, PySequenceMethods};
diff --git a/vm/src/protocol/number.rs b/vm/src/protocol/number.rs
deleted file mode 100644
index ec5f6d9795..0000000000
--- a/vm/src/protocol/number.rs
+++ /dev/null
@@ -1,561 +0,0 @@
-use std::ops::Deref;
-
-use crossbeam_utils::atomic::AtomicCell;
-
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, TryFromBorrowedObject,
-    VirtualMachine,
-    builtins::{PyByteArray, PyBytes, PyComplex, PyFloat, PyInt, PyIntRef, PyStr, int},
-    common::int::bytes_to_int,
-    function::ArgBytesLike,
-    object::{Traverse, TraverseFn},
-    stdlib::warnings,
-};
-
-pub type PyNumberUnaryFunc<R = PyObjectRef> = fn(PyNumber<'_>, &VirtualMachine) -> PyResult<R>;
-pub type PyNumberBinaryFunc = fn(&PyObject, &PyObject, &VirtualMachine) -> PyResult;
-pub type PyNumberTernaryFunc = fn(&PyObject, &PyObject, &PyObject, &VirtualMachine) -> PyResult;
-
-impl PyObject {
-    #[inline]
-    pub const fn to_number(&self) -> PyNumber<'_> {
-        PyNumber(self)
-    }
-
-    pub fn try_index_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        if let Some(i) = self.downcast_ref_if_exact::<PyInt>(vm) {
-            Some(Ok(i.to_owned()))
-        } else if let Some(i) = self.payload::<PyInt>() {
-            Some(Ok(vm.ctx.new_bigint(i.as_bigint())))
-        } else {
-            self.to_number().index(vm)
-        }
-    }
-
-    #[inline]
-    pub fn try_index(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
-        self.try_index_opt(vm).transpose()?.ok_or_else(|| {
-            vm.new_type_error(format!(
-                "'{}' object cannot be interpreted as an integer",
-                self.class()
-            ))
-        })
-    }
-
-    pub fn try_int(&self, vm: &VirtualMachine) -> PyResult<PyIntRef> {
-        fn try_convert(obj: &PyObject, lit: &[u8], vm: &VirtualMachine) -> PyResult<PyIntRef> {
-            let base = 10;
-            let i = bytes_to_int(lit, base).ok_or_else(|| {
-                let repr = match obj.repr(vm) {
-                    Ok(repr) => repr,
-                    Err(err) => return err,
-                };
-                vm.new_value_error(format!(
-                    "invalid literal for int() with base {base}: {repr}",
-                ))
-            })?;
-            Ok(PyInt::from(i).into_ref(&vm.ctx))
-        }
-
-        if let Some(i) = self.downcast_ref_if_exact::<PyInt>(vm) {
-            Ok(i.to_owned())
-        } else if let Some(i) = self.to_number().int(vm).or_else(|| self.try_index_opt(vm)) {
-            i
-        } else if let Ok(Some(f)) = vm.get_special_method(self, identifier!(vm, __trunc__)) {
-            warnings::warn(
-                vm.ctx.exceptions.deprecation_warning,
-                "The delegation of int() to __trunc__ is deprecated.".to_owned(),
-                1,
-                vm,
-            )?;
-            let ret = f.invoke((), vm)?;
-            ret.try_index(vm).map_err(|_| {
-                vm.new_type_error(format!(
-                    "__trunc__ returned non-Integral (type {})",
-                    ret.class()
-                ))
-            })
-        } else if let Some(s) = self.payload::<PyStr>() {
-            try_convert(self, s.as_wtf8().trim().as_bytes(), vm)
-        } else if let Some(bytes) = self.payload::<PyBytes>() {
-            try_convert(self, bytes, vm)
-        } else if let Some(bytearray) = self.payload::<PyByteArray>() {
-            try_convert(self, &bytearray.borrow_buf(), vm)
-        } else if let Ok(buffer) = ArgBytesLike::try_from_borrowed_object(vm, self) {
-            // TODO: replace to PyBuffer
-            try_convert(self, &buffer.borrow_buf(), vm)
-        } else {
-            Err(vm.new_type_error(format!(
-                "int() argument must be a string, a bytes-like object or a real number, not '{}'",
-                self.class()
-            )))
-        }
-    }
-
-    pub fn try_float_opt(&self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
-        if let Some(float) = self.downcast_ref_if_exact::<PyFloat>(vm) {
-            Some(Ok(float.to_owned()))
-        } else if let Some(f) = self.to_number().float(vm) {
-            Some(f)
-        } else {
-            self.try_index_opt(vm)
-                .map(|i| Ok(vm.ctx.new_float(int::try_to_float(i?.as_bigint(), vm)?)))
-        }
-    }
-
-    #[inline]
-    pub fn try_float(&self, vm: &VirtualMachine) -> PyResult<PyRef<PyFloat>> {
-        self.try_float_opt(vm).ok_or_else(|| {
-            vm.new_type_error(format!("must be real number, not {}", self.class()))
-        })?
-    }
-}
-
-#[derive(Default)]
-pub struct PyNumberMethods {
-    /* Number implementations must check *both*
-    arguments for proper type and implement the necessary conversions
-    in the slot functions themselves. */
-    pub add: Option<PyNumberBinaryFunc>,
-    pub subtract: Option<PyNumberBinaryFunc>,
-    pub multiply: Option<PyNumberBinaryFunc>,
-    pub remainder: Option<PyNumberBinaryFunc>,
-    pub divmod: Option<PyNumberBinaryFunc>,
-    pub power: Option<PyNumberTernaryFunc>,
-    pub negative: Option<PyNumberUnaryFunc>,
-    pub positive: Option<PyNumberUnaryFunc>,
-    pub absolute: Option<PyNumberUnaryFunc>,
-    pub boolean: Option<PyNumberUnaryFunc<bool>>,
-    pub invert: Option<PyNumberUnaryFunc>,
-    pub lshift: Option<PyNumberBinaryFunc>,
-    pub rshift: Option<PyNumberBinaryFunc>,
-    pub and: Option<PyNumberBinaryFunc>,
-    pub xor: Option<PyNumberBinaryFunc>,
-    pub or: Option<PyNumberBinaryFunc>,
-    pub int: Option<PyNumberUnaryFunc>,
-    pub float: Option<PyNumberUnaryFunc>,
-
-    pub inplace_add: Option<PyNumberBinaryFunc>,
-    pub inplace_subtract: Option<PyNumberBinaryFunc>,
-    pub inplace_multiply: Option<PyNumberBinaryFunc>,
-    pub inplace_remainder: Option<PyNumberBinaryFunc>,
-    pub inplace_power: Option<PyNumberTernaryFunc>,
-    pub inplace_lshift: Option<PyNumberBinaryFunc>,
-    pub inplace_rshift: Option<PyNumberBinaryFunc>,
-    pub inplace_and: Option<PyNumberBinaryFunc>,
-    pub inplace_xor: Option<PyNumberBinaryFunc>,
-    pub inplace_or: Option<PyNumberBinaryFunc>,
-
-    pub floor_divide: Option<PyNumberBinaryFunc>,
-    pub true_divide: Option<PyNumberBinaryFunc>,
-    pub inplace_floor_divide: Option<PyNumberBinaryFunc>,
-    pub inplace_true_divide: Option<PyNumberBinaryFunc>,
-
-    pub index: Option<PyNumberUnaryFunc>,
-
-    pub matrix_multiply: Option<PyNumberBinaryFunc>,
-    pub inplace_matrix_multiply: Option<PyNumberBinaryFunc>,
-}
-
-impl PyNumberMethods {
-    /// this is NOT a global variable
-    pub const NOT_IMPLEMENTED: Self = Self {
-        add: None,
-        subtract: None,
-        multiply: None,
-        remainder: None,
-        divmod: None,
-        power: None,
-        negative: None,
-        positive: None,
-        absolute: None,
-        boolean: None,
-        invert: None,
-        lshift: None,
-        rshift: None,
-        and: None,
-        xor: None,
-        or: None,
-        int: None,
-        float: None,
-        inplace_add: None,
-        inplace_subtract: None,
-        inplace_multiply: None,
-        inplace_remainder: None,
-        inplace_power: None,
-        inplace_lshift: None,
-        inplace_rshift: None,
-        inplace_and: None,
-        inplace_xor: None,
-        inplace_or: None,
-        floor_divide: None,
-        true_divide: None,
-        inplace_floor_divide: None,
-        inplace_true_divide: None,
-        index: None,
-        matrix_multiply: None,
-        inplace_matrix_multiply: None,
-    };
-
-    pub fn not_implemented() -> &'static Self {
-        static GLOBAL_NOT_IMPLEMENTED: PyNumberMethods = PyNumberMethods::NOT_IMPLEMENTED;
-        &GLOBAL_NOT_IMPLEMENTED
-    }
-}
-
-#[derive(Copy, Clone)]
-pub enum PyNumberBinaryOp {
-    Add,
-    Subtract,
-    Multiply,
-    Remainder,
-    Divmod,
-    Lshift,
-    Rshift,
-    And,
-    Xor,
-    Or,
-    InplaceAdd,
-    InplaceSubtract,
-    InplaceMultiply,
-    InplaceRemainder,
-    InplaceLshift,
-    InplaceRshift,
-    InplaceAnd,
-    InplaceXor,
-    InplaceOr,
-    FloorDivide,
-    TrueDivide,
-    InplaceFloorDivide,
-    InplaceTrueDivide,
-    MatrixMultiply,
-    InplaceMatrixMultiply,
-}
-
-#[derive(Copy, Clone)]
-pub enum PyNumberTernaryOp {
-    Power,
-    InplacePower,
-}
-
-#[derive(Default)]
-pub struct PyNumberSlots {
-    pub add: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub divmod: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub power: AtomicCell<Option<PyNumberTernaryFunc>>,
-    pub negative: AtomicCell<Option<PyNumberUnaryFunc>>,
-    pub positive: AtomicCell<Option<PyNumberUnaryFunc>>,
-    pub absolute: AtomicCell<Option<PyNumberUnaryFunc>>,
-    pub boolean: AtomicCell<Option<PyNumberUnaryFunc<bool>>>,
-    pub invert: AtomicCell<Option<PyNumberUnaryFunc>>,
-    pub lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub and: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub xor: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub or: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub int: AtomicCell<Option<PyNumberUnaryFunc>>,
-    pub float: AtomicCell<Option<PyNumberUnaryFunc>>,
-
-    pub right_add: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_divmod: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_power: AtomicCell<Option<PyNumberTernaryFunc>>,
-    pub right_lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_and: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_xor: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_or: AtomicCell<Option<PyNumberBinaryFunc>>,
-
-    pub inplace_add: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_subtract: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_remainder: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_power: AtomicCell<Option<PyNumberTernaryFunc>>,
-    pub inplace_lshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_rshift: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_and: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_xor: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_or: AtomicCell<Option<PyNumberBinaryFunc>>,
-
-    pub floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_floor_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_true_divide: AtomicCell<Option<PyNumberBinaryFunc>>,
-
-    pub index: AtomicCell<Option<PyNumberUnaryFunc>>,
-
-    pub matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub right_matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-    pub inplace_matrix_multiply: AtomicCell<Option<PyNumberBinaryFunc>>,
-}
-
-impl From<&PyNumberMethods> for PyNumberSlots {
-    fn from(value: &PyNumberMethods) -> Self {
-        // right_* functions will use the same left function as PyNumberMethods
-        // allows both f(self, other) and f(other, self)
-        Self {
-            add: AtomicCell::new(value.add),
-            subtract: AtomicCell::new(value.subtract),
-            multiply: AtomicCell::new(value.multiply),
-            remainder: AtomicCell::new(value.remainder),
-            divmod: AtomicCell::new(value.divmod),
-            power: AtomicCell::new(value.power),
-            negative: AtomicCell::new(value.negative),
-            positive: AtomicCell::new(value.positive),
-            absolute: AtomicCell::new(value.absolute),
-            boolean: AtomicCell::new(value.boolean),
-            invert: AtomicCell::new(value.invert),
-            lshift: AtomicCell::new(value.lshift),
-            rshift: AtomicCell::new(value.rshift),
-            and: AtomicCell::new(value.and),
-            xor: AtomicCell::new(value.xor),
-            or: AtomicCell::new(value.or),
-            int: AtomicCell::new(value.int),
-            float: AtomicCell::new(value.float),
-            right_add: AtomicCell::new(value.add),
-            right_subtract: AtomicCell::new(value.subtract),
-            right_multiply: AtomicCell::new(value.multiply),
-            right_remainder: AtomicCell::new(value.remainder),
-            right_divmod: AtomicCell::new(value.divmod),
-            right_power: AtomicCell::new(value.power),
-            right_lshift: AtomicCell::new(value.lshift),
-            right_rshift: AtomicCell::new(value.rshift),
-            right_and: AtomicCell::new(value.and),
-            right_xor: AtomicCell::new(value.xor),
-            right_or: AtomicCell::new(value.or),
-            inplace_add: AtomicCell::new(value.inplace_add),
-            inplace_subtract: AtomicCell::new(value.inplace_subtract),
-            inplace_multiply: AtomicCell::new(value.inplace_multiply),
-            inplace_remainder: AtomicCell::new(value.inplace_remainder),
-            inplace_power: AtomicCell::new(value.inplace_power),
-            inplace_lshift: AtomicCell::new(value.inplace_lshift),
-            inplace_rshift: AtomicCell::new(value.inplace_rshift),
-            inplace_and: AtomicCell::new(value.inplace_and),
-            inplace_xor: AtomicCell::new(value.inplace_xor),
-            inplace_or: AtomicCell::new(value.inplace_or),
-            floor_divide: AtomicCell::new(value.floor_divide),
-            true_divide: AtomicCell::new(value.true_divide),
-            right_floor_divide: AtomicCell::new(value.floor_divide),
-            right_true_divide: AtomicCell::new(value.true_divide),
-            inplace_floor_divide: AtomicCell::new(value.inplace_floor_divide),
-            inplace_true_divide: AtomicCell::new(value.inplace_true_divide),
-            index: AtomicCell::new(value.index),
-            matrix_multiply: AtomicCell::new(value.matrix_multiply),
-            right_matrix_multiply: AtomicCell::new(value.matrix_multiply),
-            inplace_matrix_multiply: AtomicCell::new(value.inplace_matrix_multiply),
-        }
-    }
-}
-
-impl PyNumberSlots {
-    pub fn left_binary_op(&self, op_slot: PyNumberBinaryOp) -> Option<PyNumberBinaryFunc> {
-        use PyNumberBinaryOp::*;
-        match op_slot {
-            Add => self.add.load(),
-            Subtract => self.subtract.load(),
-            Multiply => self.multiply.load(),
-            Remainder => self.remainder.load(),
-            Divmod => self.divmod.load(),
-            Lshift => self.lshift.load(),
-            Rshift => self.rshift.load(),
-            And => self.and.load(),
-            Xor => self.xor.load(),
-            Or => self.or.load(),
-            InplaceAdd => self.inplace_add.load(),
-            InplaceSubtract => self.inplace_subtract.load(),
-            InplaceMultiply => self.inplace_multiply.load(),
-            InplaceRemainder => self.inplace_remainder.load(),
-            InplaceLshift => self.inplace_lshift.load(),
-            InplaceRshift => self.inplace_rshift.load(),
-            InplaceAnd => self.inplace_and.load(),
-            InplaceXor => self.inplace_xor.load(),
-            InplaceOr => self.inplace_or.load(),
-            FloorDivide => self.floor_divide.load(),
-            TrueDivide => self.true_divide.load(),
-            InplaceFloorDivide => self.inplace_floor_divide.load(),
-            InplaceTrueDivide => self.inplace_true_divide.load(),
-            MatrixMultiply => self.matrix_multiply.load(),
-            InplaceMatrixMultiply => self.inplace_matrix_multiply.load(),
-        }
-    }
-
-    pub fn right_binary_op(&self, op_slot: PyNumberBinaryOp) -> Option<PyNumberBinaryFunc> {
-        use PyNumberBinaryOp::*;
-        match op_slot {
-            Add => self.right_add.load(),
-            Subtract => self.right_subtract.load(),
-            Multiply => self.right_multiply.load(),
-            Remainder => self.right_remainder.load(),
-            Divmod => self.right_divmod.load(),
-            Lshift => self.right_lshift.load(),
-            Rshift => self.right_rshift.load(),
-            And => self.right_and.load(),
-            Xor => self.right_xor.load(),
-            Or => self.right_or.load(),
-            FloorDivide => self.right_floor_divide.load(),
-            TrueDivide => self.right_true_divide.load(),
-            MatrixMultiply => self.right_matrix_multiply.load(),
-            _ => None,
-        }
-    }
-
-    pub fn left_ternary_op(&self, op_slot: PyNumberTernaryOp) -> Option<PyNumberTernaryFunc> {
-        use PyNumberTernaryOp::*;
-        match op_slot {
-            Power => self.power.load(),
-            InplacePower => self.inplace_power.load(),
-        }
-    }
-
-    pub fn right_ternary_op(&self, op_slot: PyNumberTernaryOp) -> Option<PyNumberTernaryFunc> {
-        use PyNumberTernaryOp::*;
-        match op_slot {
-            Power => self.right_power.load(),
-            _ => None,
-        }
-    }
-}
-#[derive(Copy, Clone)]
-pub struct PyNumber<'a>(&'a PyObject);
-
-unsafe impl Traverse for PyNumber<'_> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.0.traverse(tracer_fn)
-    }
-}
-
-impl Deref for PyNumber<'_> {
-    type Target = PyObject;
-
-    fn deref(&self) -> &Self::Target {
-        self.0
-    }
-}
-
-impl<'a> PyNumber<'a> {
-    pub(crate) const fn obj(self) -> &'a PyObject {
-        self.0
-    }
-
-    // PyNumber_Check
-    pub fn check(obj: &PyObject) -> bool {
-        let methods = &obj.class().slots.as_number;
-        methods.int.load().is_some()
-            || methods.index.load().is_some()
-            || methods.float.load().is_some()
-            || obj.payload_is::<PyComplex>()
-    }
-}
-
-impl PyNumber<'_> {
-    // PyIndex_Check
-    pub fn is_index(self) -> bool {
-        self.class().slots.as_number.index.load().is_some()
-    }
-
-    #[inline]
-    pub fn int(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class().slots.as_number.int.load().map(|f| {
-            let ret = f(self, vm)?;
-
-            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
-                return Ok(ret.to_owned());
-            }
-
-            let ret_class = ret.class().to_owned();
-            if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                warnings::warn(
-                    vm.ctx.exceptions.deprecation_warning,
-                    format!(
-                        "__int__ returned non-int (type {ret_class}).  \
-                    The ability to return an instance of a strict subclass of int \
-                    is deprecated, and may be removed in a future version of Python."
-                    ),
-                    1,
-                    vm,
-                )?;
-
-                Ok(ret.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "{}.__int__ returned non-int(type {})",
-                    self.class(),
-                    ret_class
-                )))
-            }
-        })
-    }
-
-    #[inline]
-    pub fn index(self, vm: &VirtualMachine) -> Option<PyResult<PyIntRef>> {
-        self.class().slots.as_number.index.load().map(|f| {
-            let ret = f(self, vm)?;
-
-            if let Some(ret) = ret.downcast_ref_if_exact::<PyInt>(vm) {
-                return Ok(ret.to_owned());
-            }
-
-            let ret_class = ret.class().to_owned();
-            if let Some(ret) = ret.downcast_ref::<PyInt>() {
-                warnings::warn(
-                    vm.ctx.exceptions.deprecation_warning,
-                    format!(
-                        "__index__ returned non-int (type {ret_class}).  \
-                    The ability to return an instance of a strict subclass of int \
-                    is deprecated, and may be removed in a future version of Python."
-                    ),
-                    1,
-                    vm,
-                )?;
-
-                Ok(ret.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "{}.__index__ returned non-int(type {})",
-                    self.class(),
-                    ret_class
-                )))
-            }
-        })
-    }
-
-    #[inline]
-    pub fn float(self, vm: &VirtualMachine) -> Option<PyResult<PyRef<PyFloat>>> {
-        self.class().slots.as_number.float.load().map(|f| {
-            let ret = f(self, vm)?;
-
-            if let Some(ret) = ret.downcast_ref_if_exact::<PyFloat>(vm) {
-                return Ok(ret.to_owned());
-            }
-
-            let ret_class = ret.class().to_owned();
-            if let Some(ret) = ret.downcast_ref::<PyFloat>() {
-                warnings::warn(
-                    vm.ctx.exceptions.deprecation_warning,
-                    format!(
-                        "__float__ returned non-float (type {ret_class}).  \
-                    The ability to return an instance of a strict subclass of float \
-                    is deprecated, and may be removed in a future version of Python."
-                    ),
-                    1,
-                    vm,
-                )?;
-
-                Ok(ret.to_owned())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "{}.__float__ returned non-float(type {})",
-                    self.class(),
-                    ret_class
-                )))
-            }
-        })
-    }
-}
diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs
deleted file mode 100644
index 498db0b26e..0000000000
--- a/vm/src/protocol/object.rs
+++ /dev/null
@@ -1,776 +0,0 @@
-//! Object Protocol
-//! <https://docs.python.org/3/c-api/object.html>
-
-use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{
-        PyAsyncGen, PyBytes, PyDict, PyDictRef, PyGenericAlias, PyInt, PyList, PyStr, PyStrRef,
-        PyTuple, PyTupleRef, PyType, PyTypeRef, pystr::AsPyStr,
-    },
-    bytes_inner::ByteInnerNewOptions,
-    common::{hash::PyHash, str::to_ascii},
-    convert::{ToPyObject, ToPyResult},
-    dict_inner::DictKey,
-    function::{Either, OptionalArg, PyArithmeticValue, PySetterValue},
-    object::PyPayload,
-    protocol::{PyIter, PyMapping, PySequence},
-    types::{Constructor, PyComparisonOp},
-};
-
-// RustPython doesn't need these items
-// PyObject *Py_NotImplemented
-// Py_RETURN_NOTIMPLEMENTED
-
-impl PyObjectRef {
-    // int PyObject_Print(PyObject *o, FILE *fp, int flags)
-
-    // PyObject *PyObject_GenericGetDict(PyObject *o, void *context)
-    // int PyObject_GenericSetDict(PyObject *o, PyObject *value, void *context)
-
-    #[inline(always)]
-    pub fn rich_compare(self, other: Self, op_id: PyComparisonOp, vm: &VirtualMachine) -> PyResult {
-        self._cmp(&other, op_id, vm).map(|res| res.to_pyobject(vm))
-    }
-
-    pub fn bytes(self, vm: &VirtualMachine) -> PyResult {
-        let bytes_type = vm.ctx.types.bytes_type;
-        match self.downcast_exact::<PyInt>(vm) {
-            Ok(int) => Err(vm.new_downcast_type_error(bytes_type, &int)),
-            Err(obj) => PyBytes::py_new(
-                bytes_type.to_owned(),
-                ByteInnerNewOptions {
-                    source: OptionalArg::Present(obj),
-                    encoding: OptionalArg::Missing,
-                    errors: OptionalArg::Missing,
-                },
-                vm,
-            ),
-        }
-    }
-
-    // const hash_not_implemented: fn(&PyObject, &VirtualMachine) ->PyResult<PyHash> = crate::types::Unhashable::slot_hash;
-
-    pub fn is_true(self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.try_to_bool(vm)
-    }
-
-    pub fn not(self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.is_true(vm).map(|x| !x)
-    }
-
-    pub fn length_hint(self, defaultvalue: usize, vm: &VirtualMachine) -> PyResult<usize> {
-        Ok(vm.length_hint_opt(self)?.unwrap_or(defaultvalue))
-    }
-
-    // PyObject *PyObject_Dir(PyObject *o)
-    pub fn dir(self, vm: &VirtualMachine) -> PyResult<PyList> {
-        let attributes = self.class().get_attributes();
-
-        let dict = PyDict::from_attributes(attributes, vm)?.into_ref(&vm.ctx);
-
-        if let Some(object_dict) = self.dict() {
-            vm.call_method(
-                dict.as_object(),
-                identifier!(vm, update).as_str(),
-                (object_dict,),
-            )?;
-        }
-
-        let attributes: Vec<_> = dict.into_iter().map(|(k, _v)| k).collect();
-
-        Ok(PyList::from(attributes))
-    }
-}
-
-impl PyObject {
-    /// Takes an object and returns an iterator for it.
-    /// This is typically a new iterator but if the argument is an iterator, this
-    /// returns itself.
-    pub fn get_iter(&self, vm: &VirtualMachine) -> PyResult<PyIter> {
-        // PyObject_GetIter
-        PyIter::try_from_object(vm, self.to_owned())
-    }
-
-    // PyObject *PyObject_GetAIter(PyObject *o)
-    pub fn get_aiter(&self, vm: &VirtualMachine) -> PyResult {
-        if self.payload_is::<PyAsyncGen>() {
-            vm.call_special_method(self, identifier!(vm, __aiter__), ())
-        } else {
-            Err(vm.new_type_error("wrong argument type"))
-        }
-    }
-
-    pub fn has_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult<bool> {
-        self.get_attr(attr_name, vm).map(|o| !vm.is_none(&o))
-    }
-
-    /// Get an attribute by name.
-    /// `attr_name` can be a `&str`, `String`, or `PyStrRef`.
-    pub fn get_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult {
-        let attr_name = attr_name.as_pystr(&vm.ctx);
-        self.get_attr_inner(attr_name, vm)
-    }
-
-    // get_attribute should be used for full attribute access (usually from user code).
-    #[cfg_attr(feature = "flame-it", flame("PyObjectRef"))]
-    #[inline]
-    pub(crate) fn get_attr_inner(&self, attr_name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        vm_trace!("object.__getattribute__: {:?} {:?}", self, attr_name);
-        let getattro = self
-            .class()
-            .mro_find_map(|cls| cls.slots.getattro.load())
-            .unwrap();
-        getattro(self, attr_name, vm).inspect_err(|exc| {
-            vm.set_attribute_error_context(exc, self.to_owned(), attr_name.to_owned());
-        })
-    }
-
-    pub fn call_set_attr(
-        &self,
-        vm: &VirtualMachine,
-        attr_name: &Py<PyStr>,
-        attr_value: PySetterValue,
-    ) -> PyResult<()> {
-        let setattro = {
-            let cls = self.class();
-            cls.mro_find_map(|cls| cls.slots.setattro.load())
-                .ok_or_else(|| {
-                    let has_getattr = cls.mro_find_map(|cls| cls.slots.getattro.load()).is_some();
-                    vm.new_type_error(format!(
-                        "'{}' object has {} attributes ({} {})",
-                        cls.name(),
-                        if has_getattr { "only read-only" } else { "no" },
-                        if attr_value.is_assign() {
-                            "assign to"
-                        } else {
-                            "del"
-                        },
-                        attr_name
-                    ))
-                })?
-        };
-        setattro(self, attr_name, attr_value, vm)
-    }
-
-    pub fn set_attr<'a>(
-        &self,
-        attr_name: impl AsPyStr<'a>,
-        attr_value: impl Into<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let attr_name = attr_name.as_pystr(&vm.ctx);
-        let attr_value = attr_value.into();
-        self.call_set_attr(vm, attr_name, PySetterValue::Assign(attr_value))
-    }
-
-    // int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
-    #[cfg_attr(feature = "flame-it", flame)]
-    pub fn generic_setattr(
-        &self,
-        attr_name: &Py<PyStr>,
-        value: PySetterValue,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        vm_trace!("object.__setattr__({:?}, {}, {:?})", self, attr_name, value);
-        if let Some(attr) = vm
-            .ctx
-            .interned_str(attr_name)
-            .and_then(|attr_name| self.get_class_attr(attr_name))
-        {
-            let descr_set = attr.class().mro_find_map(|cls| cls.slots.descr_set.load());
-            if let Some(descriptor) = descr_set {
-                return descriptor(&attr, self.to_owned(), value, vm);
-            }
-        }
-
-        if let Some(dict) = self.dict() {
-            if let PySetterValue::Assign(value) = value {
-                dict.set_item(attr_name, value, vm)?;
-            } else {
-                dict.del_item(attr_name, vm).map_err(|e| {
-                    if e.fast_isinstance(vm.ctx.exceptions.key_error) {
-                        vm.new_no_attribute_error(self.to_owned(), attr_name.to_owned())
-                    } else {
-                        e
-                    }
-                })?;
-            }
-            Ok(())
-        } else {
-            Err(vm.new_no_attribute_error(self.to_owned(), attr_name.to_owned()))
-        }
-    }
-
-    pub fn generic_getattr(&self, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        self.generic_getattr_opt(name, None, vm)?
-            .ok_or_else(|| vm.new_no_attribute_error(self.to_owned(), name.to_owned()))
-    }
-
-    /// CPython _PyObject_GenericGetAttrWithDict
-    pub fn generic_getattr_opt(
-        &self,
-        name_str: &Py<PyStr>,
-        dict: Option<PyDictRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>> {
-        let name = name_str.as_wtf8();
-        let obj_cls = self.class();
-        let cls_attr_name = vm.ctx.interned_str(name_str);
-        let cls_attr = match cls_attr_name.and_then(|name| obj_cls.get_attr(name)) {
-            Some(descr) => {
-                let descr_cls = descr.class();
-                let descr_get = descr_cls.mro_find_map(|cls| cls.slots.descr_get.load());
-                if let Some(descr_get) = descr_get {
-                    if descr_cls
-                        .mro_find_map(|cls| cls.slots.descr_set.load())
-                        .is_some()
-                    {
-                        let cls = obj_cls.to_owned().into();
-                        return descr_get(descr, Some(self.to_owned()), Some(cls), vm).map(Some);
-                    }
-                }
-                Some((descr, descr_get))
-            }
-            None => None,
-        };
-
-        let dict = dict.or_else(|| self.dict());
-
-        let attr = if let Some(dict) = dict {
-            dict.get_item_opt(name, vm)?
-        } else {
-            None
-        };
-
-        if let Some(obj_attr) = attr {
-            Ok(Some(obj_attr))
-        } else if let Some((attr, descr_get)) = cls_attr {
-            match descr_get {
-                Some(descr_get) => {
-                    let cls = obj_cls.to_owned().into();
-                    descr_get(attr, Some(self.to_owned()), Some(cls), vm).map(Some)
-                }
-                None => Ok(Some(attr)),
-            }
-        } else {
-            Ok(None)
-        }
-    }
-
-    pub fn del_attr<'a>(&self, attr_name: impl AsPyStr<'a>, vm: &VirtualMachine) -> PyResult<()> {
-        let attr_name = attr_name.as_pystr(&vm.ctx);
-        self.call_set_attr(vm, attr_name, PySetterValue::Delete)
-    }
-
-    // Perform a comparison, raising TypeError when the requested comparison
-    // operator is not supported.
-    // see: CPython PyObject_RichCompare
-    #[inline] // called by ExecutingFrame::execute_compare with const op
-    fn _cmp(
-        &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()
-                .mro_find_map(|cls| cls.slots.richcompare.load())
-                .unwrap();
-            let r = match cmp(obj, other, op, vm)? {
-                Either::A(obj) => PyArithmeticValue::from_object(vm, obj).map(Either::A),
-                Either::B(arithmetic) => arithmetic.map(Either::B),
-            };
-            Ok(r)
-        };
-
-        let mut checked_reverse_op = false;
-        let is_strict_subclass = {
-            let self_class = self.class();
-            let other_class = other.class();
-            !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))?;
-            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))?
-        {
-            return Ok(x);
-        }
-        if !checked_reverse_op {
-            let res = vm.with_recursion("in comparison", || call_cmp(other, self, swapped))?;
-            if let PyArithmeticValue::Implemented(x) = res {
-                return Ok(x);
-            }
-        }
-        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())),
-        }
-    }
-    #[inline(always)]
-    pub fn rich_compare_bool(
-        &self,
-        other: &Self,
-        op_id: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<bool> {
-        match self._cmp(other, op_id, vm)? {
-            Either::A(obj) => obj.try_to_bool(vm),
-            Either::B(other) => Ok(other),
-        }
-    }
-
-    pub fn repr(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        vm.with_recursion("while getting the repr of an object", || {
-            // TODO: RustPython does not implement type slots inheritance yet
-            self.class()
-                .mro_find_map(|cls| cls.slots.repr.load())
-                .map_or_else(
-                    || {
-                        Err(vm.new_runtime_error(format!(
-                    "BUG: object of type '{}' has no __repr__ method. This is a bug in RustPython.",
-                    self.class().name()
-                )))
-                    },
-                    |repr| repr(self, vm),
-                )
-        })
-    }
-
-    pub fn ascii(&self, vm: &VirtualMachine) -> PyResult<ascii::AsciiString> {
-        let repr = self.repr(vm)?;
-        let ascii = to_ascii(repr.as_str());
-        Ok(ascii)
-    }
-
-    // Container of the virtual machine state:
-    pub fn str(&self, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let obj = match self.to_owned().downcast_exact::<PyStr>(vm) {
-            Ok(s) => return Ok(s.into_pyref()),
-            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,
-            None => return obj.repr(vm),
-        };
-        let s = str_method.invoke((), vm)?;
-        s.downcast::<PyStr>().map_err(|obj| {
-            vm.new_type_error(format!(
-                "__str__ returned non-string (type {})",
-                obj.class().name()
-            ))
-        })
-    }
-
-    // Equivalent to CPython's check_class. Returns Ok(()) if cls is a valid class,
-    // Err with TypeError if not. Uses abstract_get_bases internally.
-    fn check_class<F>(&self, vm: &VirtualMachine, msg: F) -> PyResult<()>
-    where
-        F: Fn() -> String,
-    {
-        let cls = self;
-        match cls.abstract_get_bases(vm)? {
-            Some(_bases) => Ok(()), // Has __bases__, it's a valid class
-            None => {
-                // No __bases__ or __bases__ is not a tuple
-                Err(vm.new_type_error(msg()))
-            }
-        }
-    }
-
-    /// abstract_get_bases() has logically 4 return states:
-    /// 1. getattr(cls, '__bases__') could raise an AttributeError
-    /// 2. getattr(cls, '__bases__') could raise some other exception
-    /// 3. getattr(cls, '__bases__') could return a tuple
-    /// 4. getattr(cls, '__bases__') could return something other than a tuple
-    ///
-    /// Only state #3 returns Some(tuple). AttributeErrors are masked by returning None.
-    /// If an object other than a tuple comes out of __bases__, then again, None is returned.
-    /// Other exceptions are propagated.
-    fn abstract_get_bases(&self, vm: &VirtualMachine) -> PyResult<Option<PyTupleRef>> {
-        match vm.get_attribute_opt(self.to_owned(), identifier!(vm, __bases__))? {
-            Some(bases) => {
-                // Check if it's a tuple
-                match PyTupleRef::try_from_object(vm, bases) {
-                    Ok(tuple) => Ok(Some(tuple)),
-                    Err(_) => Ok(None), // Not a tuple, return None
-                }
-            }
-            None => Ok(None), // AttributeError was masked
-        }
-    }
-
-    fn abstract_issubclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        // Store the current derived class to check
-        let mut bases: PyTupleRef;
-        let mut derived = self;
-
-        // First loop: handle single inheritance without recursion
-        let bases = loop {
-            if derived.is(cls) {
-                return Ok(true);
-            }
-
-            let Some(derived_bases) = derived.abstract_get_bases(vm)? else {
-                return Ok(false);
-            };
-
-            let n = derived_bases.len();
-            match n {
-                0 => return Ok(false),
-                1 => {
-                    // Avoid recursion in the single inheritance case
-                    // Get the next derived class and continue the loop
-                    bases = derived_bases;
-                    derived = &bases.as_slice()[0];
-                    continue;
-                }
-                _ => {
-                    // Multiple inheritance - handle recursively
-                    break derived_bases;
-                }
-            }
-        };
-
-        let n = bases.len();
-        // At this point we know n >= 2
-        debug_assert!(n >= 2);
-
-        for i in 0..n {
-            let result = vm.with_recursion("in __issubclass__", || {
-                bases.as_slice()[i].abstract_issubclass(cls, vm)
-            })?;
-            if result {
-                return Ok(true);
-            }
-        }
-
-        Ok(false)
-    }
-
-    fn recursive_issubclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        // Fast path for both being types (matches CPython's PyType_Check)
-        if let Some(cls) = PyType::check(cls)
-            && let Some(derived) = PyType::check(self)
-        {
-            // PyType_IsSubtype equivalent
-            return Ok(derived.is_subtype(cls));
-        }
-        // Check if derived is a class
-        self.check_class(vm, || {
-            format!("issubclass() arg 1 must be a class, not {}", self.class())
-        })?;
-
-        // Check if cls is a class, tuple, or union (matches CPython's order and message)
-        if !cls.class().is(vm.ctx.types.union_type) {
-            cls.check_class(vm, || {
-                format!(
-                    "issubclass() arg 2 must be a class, a tuple of classes, or a union, not {}",
-                    cls.class()
-                )
-            })?;
-        }
-
-        self.abstract_issubclass(cls, vm)
-    }
-
-    /// Real issubclass check without going through __subclasscheck__
-    /// This is equivalent to CPython's _PyObject_RealIsSubclass which just calls recursive_issubclass
-    pub fn real_is_subclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.recursive_issubclass(cls, vm)
-    }
-
-    /// Determines if `self` is a subclass of `cls`, either directly, indirectly or virtually
-    /// via the __subclasscheck__ magic method.
-    /// PyObject_IsSubclass/object_issubclass
-    pub fn is_subclass(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        let derived = self;
-        // PyType_CheckExact(cls)
-        if cls.class().is(vm.ctx.types.type_type) {
-            if derived.is(cls) {
-                return Ok(true);
-            }
-            return derived.recursive_issubclass(cls, vm);
-        }
-
-        // Check for Union type - CPython handles this before tuple
-        let cls = if cls.class().is(vm.ctx.types.union_type) {
-            // Get the __args__ attribute which contains the union members
-            // Match CPython's _Py_union_args which directly accesses the args field
-            let union = cls
-                .downcast_ref::<crate::builtins::PyUnion>()
-                .expect("union is already checked");
-            union.args().as_object()
-        } else {
-            cls
-        };
-
-        // Check if cls is a tuple
-        if let Some(tuple) = cls.downcast_ref::<PyTuple>() {
-            for item in tuple {
-                if vm.with_recursion("in __subclasscheck__", || derived.is_subclass(item, vm))? {
-                    return Ok(true);
-                }
-            }
-            return Ok(false);
-        }
-
-        // Check for __subclasscheck__ method using lookup_special (matches CPython)
-        if let Some(checker) = cls.lookup_special(identifier!(vm, __subclasscheck__), vm) {
-            let res = vm.with_recursion("in __subclasscheck__", || {
-                checker.call((derived.to_owned(),), vm)
-            })?;
-            return res.try_to_bool(vm);
-        }
-
-        derived.recursive_issubclass(cls, vm)
-    }
-
-    // _PyObject_RealIsInstance
-    pub(crate) fn real_is_instance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.object_isinstance(cls, vm)
-    }
-
-    /// Real isinstance check without going through __instancecheck__
-    /// This is equivalent to CPython's _PyObject_RealIsInstance/object_isinstance
-    fn object_isinstance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        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) =
-                    vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class__))?
-                {
-                    if let Ok(i_cls_type) = PyTypeRef::try_from_object(vm, i_cls) {
-                        if !i_cls_type.is(self.class()) {
-                            retval = i_cls_type.is_subtype(cls);
-                        }
-                    }
-                }
-            }
-            Ok(retval)
-        } else {
-            // Not a type object, check if it's a valid class
-            cls.check_class(vm, || {
-                format!(
-                    "isinstance() arg 2 must be a type, a tuple of types, or a union, not {}",
-                    cls.class()
-                )
-            })?;
-
-            // Get __class__ attribute and check, only masking AttributeError
-            if let Some(i_cls) =
-                vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class__))?
-            {
-                i_cls.abstract_issubclass(cls, vm)
-            } else {
-                Ok(false)
-            }
-        }
-    }
-
-    /// Determines if `self` is an instance of `cls`, either directly, indirectly or virtually via
-    /// the __instancecheck__ magic method.
-    pub fn is_instance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        self.object_recursive_isinstance(cls, vm)
-    }
-
-    // This is object_recursive_isinstance from CPython's Objects/abstract.c
-    fn object_recursive_isinstance(&self, cls: &Self, vm: &VirtualMachine) -> PyResult<bool> {
-        // PyObject_TypeCheck(inst, (PyTypeObject *)cls)
-        // This is an exact check of the type
-        if self.class().is(cls) {
-            return Ok(true);
-        }
-
-        // PyType_CheckExact(cls) optimization
-        if cls.class().is(vm.ctx.types.type_type) {
-            // When cls is exactly a type (not a subclass), use object_isinstance
-            // to avoid going through __instancecheck__ (matches CPython behavior)
-            return self.object_isinstance(cls, vm);
-        }
-
-        // Check for Union type (e.g., int | str) - CPython checks this before tuple
-        let cls = if cls.class().is(vm.ctx.types.union_type) {
-            // Match CPython's _Py_union_args which directly accesses the args field
-            let union = cls
-                .try_to_ref::<crate::builtins::PyUnion>(vm)
-                .expect("checked by is");
-            union.args().as_object()
-        } else {
-            cls
-        };
-
-        // Check if cls is a tuple
-        if let Some(tuple) = cls.downcast_ref::<PyTuple>() {
-            for item in tuple {
-                if vm.with_recursion("in __instancecheck__", || {
-                    self.object_recursive_isinstance(item, vm)
-                })? {
-                    return Ok(true);
-                }
-            }
-            return Ok(false);
-        }
-
-        // Check for __instancecheck__ method using lookup_special (matches CPython)
-        if let Some(checker) = cls.lookup_special(identifier!(vm, __instancecheck__), vm) {
-            let res = vm.with_recursion("in __instancecheck__", || {
-                checker.call((self.to_owned(),), vm)
-            })?;
-            return res.try_to_bool(vm);
-        }
-
-        // Fall back to object_isinstance (without going through __instancecheck__ again)
-        self.object_isinstance(cls, vm)
-    }
-
-    pub fn hash(&self, vm: &VirtualMachine) -> PyResult<PyHash> {
-        let hash = self.get_class_attr(identifier!(vm, __hash__)).unwrap();
-        if vm.is_none(&hash) {
-            return Err(vm.new_exception_msg(
-                vm.ctx.exceptions.type_error.to_owned(),
-                format!("unhashable type: '{}'", self.class().name()),
-            ));
-        }
-
-        let hash = self
-            .class()
-            .mro_find_map(|cls| cls.slots.hash.load())
-            .unwrap();
-
-        hash(self, vm)
-    }
-
-    // type protocol
-    // PyObject *PyObject_Type(PyObject *o)
-    pub fn obj_type(&self) -> PyObjectRef {
-        self.class().to_owned().into()
-    }
-
-    // int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)
-    pub fn type_check(&self, typ: &Py<PyType>) -> bool {
-        self.fast_isinstance(typ)
-    }
-
-    pub fn length_opt(&self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.to_sequence()
-            .length_opt(vm)
-            .or_else(|| self.to_mapping().length_opt(vm))
-    }
-
-    pub fn length(&self, vm: &VirtualMachine) -> PyResult<usize> {
-        self.length_opt(vm).ok_or_else(|| {
-            vm.new_type_error(format!(
-                "object of type '{}' has no len()",
-                self.class().name()
-            ))
-        })?
-    }
-
-    pub fn get_item<K: DictKey + ?Sized>(&self, needle: &K, vm: &VirtualMachine) -> PyResult {
-        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
-            return dict.get_item(needle, vm);
-        }
-
-        let needle = needle.to_pyobject(vm);
-
-        if let Ok(mapping) = PyMapping::try_protocol(self, vm) {
-            mapping.subscript(&needle, vm)
-        } else if let Ok(seq) = PySequence::try_protocol(self, vm) {
-            let i = needle.key_as_isize(vm)?;
-            seq.get_item(i, vm)
-        } else {
-            if self.class().fast_issubclass(vm.ctx.types.type_type) {
-                if self.is(vm.ctx.types.type_type) {
-                    return PyGenericAlias::from_args(self.class().to_owned(), needle, vm)
-                        .to_pyresult(vm);
-                }
-
-                if let Some(class_getitem) =
-                    vm.get_attribute_opt(self.to_owned(), identifier!(vm, __class_getitem__))?
-                {
-                    return class_getitem.call((needle,), vm);
-                }
-            }
-            Err(vm.new_type_error(format!("'{}' object is not subscriptable", self.class())))
-        }
-    }
-
-    pub fn set_item<K: DictKey + ?Sized>(
-        &self,
-        needle: &K,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
-            return dict.set_item(needle, value, vm);
-        }
-
-        let mapping = self.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
-            let needle = needle.to_pyobject(vm);
-            return f(mapping, &needle, Some(value), vm);
-        }
-
-        let seq = self.to_sequence();
-        if let Some(f) = seq.methods.ass_item.load() {
-            let i = needle.key_as_isize(vm)?;
-            return f(seq, i, Some(value), vm);
-        }
-
-        Err(vm.new_type_error(format!(
-            "'{}' does not support item assignment",
-            self.class()
-        )))
-    }
-
-    pub fn del_item<K: DictKey + ?Sized>(&self, needle: &K, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(dict) = self.downcast_ref_if_exact::<PyDict>(vm) {
-            return dict.del_item(needle, vm);
-        }
-
-        let mapping = self.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
-            let needle = needle.to_pyobject(vm);
-            return f(mapping, &needle, None, vm);
-        }
-        let seq = self.to_sequence();
-        if let Some(f) = seq.methods.ass_item.load() {
-            let i = needle.key_as_isize(vm)?;
-            return f(seq, i, None, vm);
-        }
-
-        Err(vm.new_type_error(format!("'{}' does not support item deletion", self.class())))
-    }
-
-    /// Equivalent to CPython's _PyObject_LookupSpecial
-    /// Looks up a special method in the type's MRO without checking instance dict.
-    /// Returns None if not found (masking AttributeError like CPython).
-    pub fn lookup_special(&self, attr: &Py<PyStr>, vm: &VirtualMachine) -> Option<PyObjectRef> {
-        let obj_cls = self.class();
-
-        // Use PyType::lookup_ref (equivalent to CPython's _PyType_LookupRef)
-        let res = obj_cls.lookup_ref(attr, vm)?;
-
-        // If it's a descriptor, call its __get__ method
-        let descr_get = res.class().mro_find_map(|cls| cls.slots.descr_get.load());
-        if let Some(descr_get) = descr_get {
-            let obj_cls = obj_cls.to_owned().into();
-            // CPython ignores exceptions in _PyObject_LookupSpecial and returns NULL
-            descr_get(res, Some(self.to_owned()), Some(obj_cls), vm).ok()
-        } else {
-            Some(res)
-        }
-    }
-}
diff --git a/vm/src/protocol/sequence.rs b/vm/src/protocol/sequence.rs
deleted file mode 100644
index 6d9eb56151..0000000000
--- a/vm/src/protocol/sequence.rs
+++ /dev/null
@@ -1,373 +0,0 @@
-use crate::{
-    PyObject, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-    builtins::{PyList, PyListRef, PySlice, PyTuple, PyTupleRef, type_::PointerSlot},
-    convert::ToPyObject,
-    function::PyArithmeticValue,
-    object::{Traverse, TraverseFn},
-    protocol::{PyMapping, PyNumberBinaryOp},
-};
-use crossbeam_utils::atomic::AtomicCell;
-use itertools::Itertools;
-use std::fmt::Debug;
-
-// Sequence Protocol
-// https://docs.python.org/3/c-api/sequence.html
-
-impl PyObject {
-    #[inline]
-    pub fn to_sequence(&self) -> PySequence<'_> {
-        static GLOBAL_NOT_IMPLEMENTED: PySequenceMethods = PySequenceMethods::NOT_IMPLEMENTED;
-        PySequence {
-            obj: self,
-            methods: PySequence::find_methods(self)
-                .map_or(&GLOBAL_NOT_IMPLEMENTED, |x| unsafe { x.borrow_static() }),
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-#[derive(Default)]
-pub struct PySequenceMethods {
-    pub length: AtomicCell<Option<fn(PySequence<'_>, &VirtualMachine) -> PyResult<usize>>>,
-    pub concat: AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
-    pub item: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
-    pub ass_item: AtomicCell<
-        Option<fn(PySequence<'_>, isize, Option<PyObjectRef>, &VirtualMachine) -> PyResult<()>>,
-    >,
-    pub contains:
-        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult<bool>>>,
-    pub inplace_concat:
-        AtomicCell<Option<fn(PySequence<'_>, &PyObject, &VirtualMachine) -> PyResult>>,
-    pub inplace_repeat: AtomicCell<Option<fn(PySequence<'_>, isize, &VirtualMachine) -> PyResult>>,
-}
-
-impl Debug for PySequenceMethods {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Sequence Methods")
-    }
-}
-
-impl PySequenceMethods {
-    #[allow(clippy::declare_interior_mutable_const)]
-    pub const NOT_IMPLEMENTED: Self = Self {
-        length: AtomicCell::new(None),
-        concat: AtomicCell::new(None),
-        repeat: AtomicCell::new(None),
-        item: AtomicCell::new(None),
-        ass_item: AtomicCell::new(None),
-        contains: AtomicCell::new(None),
-        inplace_concat: AtomicCell::new(None),
-        inplace_repeat: AtomicCell::new(None),
-    };
-}
-
-#[derive(Copy, Clone)]
-pub struct PySequence<'a> {
-    pub obj: &'a PyObject,
-    pub methods: &'static PySequenceMethods,
-}
-
-unsafe impl Traverse for PySequence<'_> {
-    fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
-        self.obj.traverse(tracer_fn)
-    }
-}
-
-impl<'a> PySequence<'a> {
-    #[inline]
-    pub const fn with_methods(obj: &'a PyObject, methods: &'static PySequenceMethods) -> Self {
-        Self { obj, methods }
-    }
-
-    pub fn try_protocol(obj: &'a PyObject, vm: &VirtualMachine) -> PyResult<Self> {
-        let seq = obj.to_sequence();
-        if seq.check() {
-            Ok(seq)
-        } else {
-            Err(vm.new_type_error(format!("'{}' is not a sequence", obj.class())))
-        }
-    }
-}
-
-impl PySequence<'_> {
-    pub fn check(&self) -> bool {
-        self.methods.item.load().is_some()
-    }
-
-    pub fn find_methods(obj: &PyObject) -> Option<PointerSlot<PySequenceMethods>> {
-        let cls = obj.class();
-        cls.mro_find_map(|x| x.slots.as_sequence.load())
-    }
-
-    pub fn length_opt(self, vm: &VirtualMachine) -> Option<PyResult<usize>> {
-        self.methods.length.load().map(|f| f(self, vm))
-    }
-
-    pub fn length(self, vm: &VirtualMachine) -> PyResult<usize> {
-        self.length_opt(vm).ok_or_else(|| {
-            vm.new_type_error(format!(
-                "'{}' is not a sequence or has no len()",
-                self.obj.class()
-            ))
-        })?
-    }
-
-    pub fn concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.concat.load() {
-            return f(self, other, vm);
-        }
-
-        // if both arguments appear to be sequences, try fallback to __add__
-        if self.check() && other.to_sequence().check() {
-            let ret = vm.binary_op1(self.obj, other, PyNumberBinaryOp::Add)?;
-            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
-                return Ok(ret);
-            }
-        }
-
-        Err(vm.new_type_error(format!(
-            "'{}' object can't be concatenated",
-            self.obj.class()
-        )))
-    }
-
-    pub fn repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.repeat.load() {
-            return f(self, n, vm);
-        }
-
-        // fallback to __mul__
-        if self.check() {
-            let ret = vm.binary_op1(self.obj, &n.to_pyobject(vm), PyNumberBinaryOp::Multiply)?;
-            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
-                return Ok(ret);
-            }
-        }
-
-        Err(vm.new_type_error(format!("'{}' object can't be repeated", self.obj.class())))
-    }
-
-    pub fn inplace_concat(self, other: &PyObject, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.inplace_concat.load() {
-            return f(self, other, vm);
-        }
-        if let Some(f) = self.methods.concat.load() {
-            return f(self, other, vm);
-        }
-
-        // if both arguments appear to be sequences, try fallback to __iadd__
-        if self.check() && other.to_sequence().check() {
-            let ret = vm._iadd(self.obj, other)?;
-            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
-                return Ok(ret);
-            }
-        }
-
-        Err(vm.new_type_error(format!(
-            "'{}' object can't be concatenated",
-            self.obj.class()
-        )))
-    }
-
-    pub fn inplace_repeat(self, n: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.inplace_repeat.load() {
-            return f(self, n, vm);
-        }
-        if let Some(f) = self.methods.repeat.load() {
-            return f(self, n, vm);
-        }
-
-        if self.check() {
-            let ret = vm._imul(self.obj, &n.to_pyobject(vm))?;
-            if let PyArithmeticValue::Implemented(ret) = PyArithmeticValue::from_object(vm, ret) {
-                return Ok(ret);
-            }
-        }
-
-        Err(vm.new_type_error(format!("'{}' object can't be repeated", self.obj.class())))
-    }
-
-    pub fn get_item(self, i: isize, vm: &VirtualMachine) -> PyResult {
-        if let Some(f) = self.methods.item.load() {
-            return f(self, i, vm);
-        }
-        Err(vm.new_type_error(format!(
-            "'{}' is not a sequence or does not support indexing",
-            self.obj.class()
-        )))
-    }
-
-    fn _ass_item(self, i: isize, value: Option<PyObjectRef>, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(f) = self.methods.ass_item.load() {
-            return f(self, i, value, vm);
-        }
-        Err(vm.new_type_error(format!(
-            "'{}' is not a sequence or doesn't support item {}",
-            self.obj.class(),
-            if value.is_some() {
-                "assignment"
-            } else {
-                "deletion"
-            }
-        )))
-    }
-
-    pub fn set_item(self, i: isize, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        self._ass_item(i, Some(value), vm)
-    }
-
-    pub fn del_item(self, i: isize, vm: &VirtualMachine) -> PyResult<()> {
-        self._ass_item(i, None, vm)
-    }
-
-    pub fn get_slice(&self, start: isize, stop: isize, vm: &VirtualMachine) -> PyResult {
-        if let Ok(mapping) = PyMapping::try_protocol(self.obj, vm) {
-            let slice = PySlice {
-                start: Some(start.to_pyobject(vm)),
-                stop: stop.to_pyobject(vm),
-                step: None,
-            };
-            mapping.subscript(&slice.into_pyobject(vm), vm)
-        } else {
-            Err(vm.new_type_error(format!("'{}' object is unsliceable", self.obj.class())))
-        }
-    }
-
-    fn _ass_slice(
-        &self,
-        start: isize,
-        stop: isize,
-        value: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let mapping = self.obj.to_mapping();
-        if let Some(f) = mapping.methods.ass_subscript.load() {
-            let slice = PySlice {
-                start: Some(start.to_pyobject(vm)),
-                stop: stop.to_pyobject(vm),
-                step: None,
-            };
-            f(mapping, &slice.into_pyobject(vm), value, vm)
-        } else {
-            Err(vm.new_type_error(format!(
-                "'{}' object doesn't support slice {}",
-                self.obj.class(),
-                if value.is_some() {
-                    "assignment"
-                } else {
-                    "deletion"
-                }
-            )))
-        }
-    }
-
-    pub fn set_slice(
-        &self,
-        start: isize,
-        stop: isize,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        self._ass_slice(start, stop, Some(value), vm)
-    }
-
-    pub fn del_slice(&self, start: isize, stop: isize, vm: &VirtualMachine) -> PyResult<()> {
-        self._ass_slice(start, stop, None, vm)
-    }
-
-    pub fn tuple(&self, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-        if let Some(tuple) = self.obj.downcast_ref_if_exact::<PyTuple>(vm) {
-            Ok(tuple.to_owned())
-        } else if let Some(list) = self.obj.downcast_ref_if_exact::<PyList>(vm) {
-            Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()))
-        } else {
-            let iter = self.obj.to_owned().get_iter(vm)?;
-            let iter = iter.iter(vm)?;
-            Ok(vm.ctx.new_tuple(iter.try_collect()?))
-        }
-    }
-
-    pub fn list(&self, vm: &VirtualMachine) -> PyResult<PyListRef> {
-        let list = vm.ctx.new_list(self.obj.try_to_value(vm)?);
-        Ok(list)
-    }
-
-    pub fn count(&self, target: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
-        let mut n = 0;
-
-        let iter = self.obj.to_owned().get_iter(vm)?;
-        let iter = iter.iter::<PyObjectRef>(vm)?;
-
-        for elem in iter {
-            let elem = elem?;
-            if vm.bool_eq(&elem, target)? {
-                if n == isize::MAX as usize {
-                    return Err(vm.new_overflow_error("index exceeds C integer size"));
-                }
-                n += 1;
-            }
-        }
-
-        Ok(n)
-    }
-
-    pub fn index(&self, target: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
-        let mut index: isize = -1;
-
-        let iter = self.obj.to_owned().get_iter(vm)?;
-        let iter = iter.iter::<PyObjectRef>(vm)?;
-
-        for elem in iter {
-            if index == isize::MAX {
-                return Err(vm.new_overflow_error("index exceeds C integer size"));
-            }
-            index += 1;
-
-            let elem = elem?;
-            if vm.bool_eq(&elem, target)? {
-                return Ok(index as usize);
-            }
-        }
-
-        Err(vm.new_value_error("sequence.index(x): x not in sequence"))
-    }
-
-    pub fn extract<F, R>(&self, mut f: F, vm: &VirtualMachine) -> PyResult<Vec<R>>
-    where
-        F: FnMut(&PyObject) -> PyResult<R>,
-    {
-        if let Some(tuple) = self.obj.payload_if_exact::<PyTuple>(vm) {
-            tuple.iter().map(|x| f(x.as_ref())).collect()
-        } else if let Some(list) = self.obj.payload_if_exact::<PyList>(vm) {
-            list.borrow_vec().iter().map(|x| f(x.as_ref())).collect()
-        } else {
-            let iter = self.obj.to_owned().get_iter(vm)?;
-            let iter = iter.iter::<PyObjectRef>(vm)?;
-            let len = self.length(vm).unwrap_or(0);
-            let mut v = Vec::with_capacity(len);
-            for x in iter {
-                v.push(f(x?.as_ref())?);
-            }
-            v.shrink_to_fit();
-            Ok(v)
-        }
-    }
-
-    pub fn contains(self, target: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        if let Some(f) = self.methods.contains.load() {
-            return f(self, target, vm);
-        }
-
-        let iter = self.obj.to_owned().get_iter(vm)?;
-        let iter = iter.iter::<PyObjectRef>(vm)?;
-
-        for elem in iter {
-            let elem = elem?;
-            if vm.bool_eq(&elem, target)? {
-                return Ok(true);
-            }
-        }
-        Ok(false)
-    }
-}
diff --git a/vm/src/sequence.rs b/vm/src/sequence.rs
deleted file mode 100644
index e75c0a6da5..0000000000
--- a/vm/src/sequence.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use crate::{
-    AsObject, PyObject, PyObjectRef, PyResult,
-    builtins::PyIntRef,
-    function::OptionalArg,
-    sliceable::SequenceIndexOp,
-    types::PyComparisonOp,
-    vm::{MAX_MEMORY_SIZE, VirtualMachine},
-};
-use optional::Optioned;
-use std::ops::{Deref, Range};
-
-pub trait MutObjectSequenceOp {
-    type Inner: ?Sized;
-
-    fn do_get(index: usize, inner: &Self::Inner) -> Option<&PyObjectRef>;
-    fn do_lock(&self) -> impl Deref<Target = Self::Inner>;
-
-    fn mut_count(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<usize> {
-        let mut count = 0;
-        self._mut_iter_equal_skeleton::<_, false>(vm, needle, 0..isize::MAX as usize, || {
-            count += 1
-        })?;
-        Ok(count)
-    }
-
-    fn mut_index_range(
-        &self,
-        vm: &VirtualMachine,
-        needle: &PyObject,
-        range: Range<usize>,
-    ) -> PyResult<Optioned<usize>> {
-        self._mut_iter_equal_skeleton::<_, true>(vm, needle, range, || {})
-    }
-
-    fn mut_index(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<Optioned<usize>> {
-        self.mut_index_range(vm, needle, 0..isize::MAX as usize)
-    }
-
-    fn mut_contains(&self, vm: &VirtualMachine, needle: &PyObject) -> PyResult<bool> {
-        self.mut_index(vm, needle).map(|x| x.is_some())
-    }
-
-    fn _mut_iter_equal_skeleton<F, const SHORT: bool>(
-        &self,
-        vm: &VirtualMachine,
-        needle: &PyObject,
-        range: Range<usize>,
-        mut f: F,
-    ) -> PyResult<Optioned<usize>>
-    where
-        F: FnMut(),
-    {
-        let mut borrower = None;
-        let mut i = range.start;
-
-        let index = loop {
-            if i >= range.end {
-                break Optioned::<usize>::none();
-            }
-            let guard = if let Some(x) = borrower.take() {
-                x
-            } else {
-                self.do_lock()
-            };
-
-            let elem = if let Some(x) = Self::do_get(i, &guard) {
-                x
-            } else {
-                break Optioned::<usize>::none();
-            };
-
-            if elem.is(needle) {
-                f();
-                if SHORT {
-                    break Optioned::<usize>::some(i);
-                }
-                borrower = Some(guard);
-            } else {
-                let elem = elem.clone();
-                drop(guard);
-
-                if elem.rich_compare_bool(needle, PyComparisonOp::Eq, vm)? {
-                    f();
-                    if SHORT {
-                        break Optioned::<usize>::some(i);
-                    }
-                }
-            }
-            i += 1;
-        };
-
-        Ok(index)
-    }
-}
-
-pub trait SequenceExt<T: Clone>
-where
-    Self: AsRef<[T]>,
-{
-    fn mul(&self, vm: &VirtualMachine, n: isize) -> PyResult<Vec<T>> {
-        let n = vm.check_repeat_or_overflow_error(self.as_ref().len(), n)?;
-
-        if n > 1 && std::mem::size_of_val(self.as_ref()) >= MAX_MEMORY_SIZE / n {
-            return Err(vm.new_memory_error(""));
-        }
-
-        let mut v = Vec::with_capacity(n * self.as_ref().len());
-        for _ in 0..n {
-            v.extend_from_slice(self.as_ref());
-        }
-        Ok(v)
-    }
-}
-
-impl<T: Clone> SequenceExt<T> for [T] {}
-
-pub trait SequenceMutExt<T: Clone>
-where
-    Self: AsRef<[T]>,
-{
-    fn as_vec_mut(&mut self) -> &mut Vec<T>;
-
-    fn imul(&mut self, vm: &VirtualMachine, n: isize) -> PyResult<()> {
-        let n = vm.check_repeat_or_overflow_error(self.as_ref().len(), n)?;
-        if n == 0 {
-            self.as_vec_mut().clear();
-        } else if n != 1 {
-            let mut sample = self.as_vec_mut().clone();
-            if n != 2 {
-                self.as_vec_mut().reserve(sample.len() * (n - 1));
-                for _ in 0..n - 2 {
-                    self.as_vec_mut().extend_from_slice(&sample);
-                }
-            }
-            self.as_vec_mut().append(&mut sample);
-        }
-        Ok(())
-    }
-}
-
-impl<T: Clone> SequenceMutExt<T> for Vec<T> {
-    fn as_vec_mut(&mut self) -> &mut Self {
-        self
-    }
-}
-
-#[derive(FromArgs)]
-pub struct OptionalRangeArgs {
-    #[pyarg(positional, optional)]
-    start: OptionalArg<PyObjectRef>,
-    #[pyarg(positional, optional)]
-    stop: OptionalArg<PyObjectRef>,
-}
-
-impl OptionalRangeArgs {
-    pub fn saturate(self, len: usize, vm: &VirtualMachine) -> PyResult<(usize, usize)> {
-        let saturate = |obj: PyObjectRef| -> PyResult<_> {
-            obj.try_into_value(vm)
-                .map(|int: PyIntRef| int.as_bigint().saturated_at(len))
-        };
-        let start = self.start.map_or(Ok(0), saturate)?;
-        let stop = self.stop.map_or(Ok(len), saturate)?;
-        Ok((start, stop))
-    }
-}
diff --git a/vm/src/signal.rs b/vm/src/signal.rs
deleted file mode 100644
index 4157a2c67e..0000000000
--- a/vm/src/signal.rs
+++ /dev/null
@@ -1,125 +0,0 @@
-#![cfg_attr(target_os = "wasi", allow(dead_code))]
-use crate::{PyResult, VirtualMachine};
-use std::{
-    fmt,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc,
-    },
-};
-
-pub(crate) const NSIG: usize = 64;
-static ANY_TRIGGERED: AtomicBool = AtomicBool::new(false);
-// hack to get around const array repeat expressions, rust issue #79270
-#[allow(clippy::declare_interior_mutable_const)]
-const ATOMIC_FALSE: AtomicBool = AtomicBool::new(false);
-pub(crate) static TRIGGERS: [AtomicBool; NSIG] = [ATOMIC_FALSE; NSIG];
-
-#[cfg_attr(feature = "flame-it", flame)]
-#[inline(always)]
-pub fn check_signals(vm: &VirtualMachine) -> PyResult<()> {
-    if vm.signal_handlers.is_none() {
-        return Ok(());
-    }
-
-    if !ANY_TRIGGERED.swap(false, Ordering::Acquire) {
-        return Ok(());
-    }
-
-    trigger_signals(vm)
-}
-#[inline(never)]
-#[cold]
-fn trigger_signals(vm: &VirtualMachine) -> PyResult<()> {
-    // unwrap should never fail since we check above
-    let signal_handlers = vm.signal_handlers.as_ref().unwrap().borrow();
-    for (signum, trigger) in TRIGGERS.iter().enumerate().skip(1) {
-        let triggered = trigger.swap(false, Ordering::Relaxed);
-        if triggered {
-            if let Some(handler) = &signal_handlers[signum] {
-                if let Some(callable) = handler.to_callable() {
-                    callable.invoke((signum, vm.ctx.none()), vm)?;
-                }
-            }
-        }
-    }
-    if let Some(signal_rx) = &vm.signal_rx {
-        for f in signal_rx.rx.try_iter() {
-            f(vm)?;
-        }
-    }
-    Ok(())
-}
-
-pub(crate) fn set_triggered() {
-    ANY_TRIGGERED.store(true, Ordering::Release);
-}
-
-pub fn assert_in_range(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
-    if (1..NSIG as i32).contains(&signum) {
-        Ok(())
-    } else {
-        Err(vm.new_value_error("signal number out of range"))
-    }
-}
-
-/// Similar to `PyErr_SetInterruptEx` in CPython
-///
-/// Missing signal handler for the given signal number is silently ignored.
-#[allow(dead_code)]
-#[cfg(not(target_arch = "wasm32"))]
-pub fn set_interrupt_ex(signum: i32, vm: &VirtualMachine) -> PyResult<()> {
-    use crate::stdlib::signal::_signal::{SIG_DFL, SIG_IGN, run_signal};
-    assert_in_range(signum, vm)?;
-
-    match signum as usize {
-        SIG_DFL | SIG_IGN => Ok(()),
-        _ => {
-            // interrupt the main thread with given signal number
-            run_signal(signum);
-            Ok(())
-        }
-    }
-}
-
-pub type UserSignal = Box<dyn FnOnce(&VirtualMachine) -> PyResult<()> + Send>;
-
-#[derive(Clone, Debug)]
-pub struct UserSignalSender {
-    tx: mpsc::Sender<UserSignal>,
-}
-
-#[derive(Debug)]
-pub struct UserSignalReceiver {
-    rx: mpsc::Receiver<UserSignal>,
-}
-
-impl UserSignalSender {
-    pub fn send(&self, sig: UserSignal) -> Result<(), UserSignalSendError> {
-        self.tx
-            .send(sig)
-            .map_err(|mpsc::SendError(sig)| UserSignalSendError(sig))?;
-        set_triggered();
-        Ok(())
-    }
-}
-
-pub struct UserSignalSendError(pub UserSignal);
-
-impl fmt::Debug for UserSignalSendError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("UserSignalSendError")
-            .finish_non_exhaustive()
-    }
-}
-
-impl fmt::Display for UserSignalSendError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("sending a signal to a exited vm")
-    }
-}
-
-pub fn user_signal_channel() -> (UserSignalSender, UserSignalReceiver) {
-    let (tx, rx) = mpsc::channel();
-    (UserSignalSender { tx }, UserSignalReceiver { rx })
-}
diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs
deleted file mode 100644
index f6679f1897..0000000000
--- a/vm/src/stdlib/ast.rs
+++ /dev/null
@@ -1,337 +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.
-
-mod pyast;
-
-use crate::builtins::{PyInt, PyStr};
-use crate::stdlib::ast::module::{Mod, ModInteractive};
-use crate::stdlib::ast::node::BoxedSlice;
-use crate::stdlib::ast::python::_ast;
-use crate::{
-    AsObject, Context, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyRefExact, PyResult,
-    TryFromObject, VirtualMachine,
-    builtins::PyIntRef,
-    builtins::{PyDict, PyModule, PyStrRef, PyType},
-    class::{PyClassImpl, StaticType},
-    compiler::core::bytecode::OpArgType,
-    compiler::{CompileError, ParseError},
-    convert::ToPyObject,
-    source::SourceCode,
-    source::SourceLocation,
-};
-use node::Node;
-use ruff_python_ast as ruff;
-use ruff_source_file::OneIndexed;
-use ruff_text_size::{Ranged, TextRange, TextSize};
-use rustpython_compiler_source::SourceCodeOwned;
-
-#[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 {
-            row: self.row.get_one_indexed(),
-            column: 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_code: &SourceCodeOwned,
-    text_range: TextRange,
-) -> PySourceRange {
-    let index = &source_code.index;
-    let source = &source_code.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 range_from_object(
-    vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
-    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)?;
-    let end_row = get_int_field(vm, &object, "end_lineno", name)?;
-    let end_column = get_int_field(vm, &object, "end_col_offset", name)?;
-
-    let location = PySourceRange {
-        start: PySourceLocation {
-            row: Row(OneIndexed::new(start_row.try_to_primitive(vm)?).unwrap()),
-            column: Column(TextSize::new(start_column.try_to_primitive(vm)?)),
-        },
-        end: PySourceLocation {
-            row: Row(OneIndexed::new(end_row.try_to_primitive(vm)?).unwrap()),
-            column: Column(TextSize::new(end_column.try_to_primitive(vm)?)),
-        },
-    };
-
-    Ok(source_range_to_text_range(source_code, location))
-}
-
-fn source_range_to_text_range(source_code: &SourceCodeOwned, location: PySourceRange) -> TextRange {
-    let source = &source_code.text;
-    let index = &source_code.index;
-
-    if source.is_empty() {
-        return TextRange::new(TextSize::new(0), TextSize::new(0));
-    }
-
-    let start = index.offset(
-        location.start.row.get_one_indexed(),
-        location.start.column.get_one_indexed(),
-        source,
-    );
-    let end = index.offset(
-        location.end.row.get_one_indexed(),
-        location.end.column.get_one_indexed(),
-        source,
-    );
-
-    TextRange::new(start, end)
-}
-
-fn node_add_location(
-    dict: &Py<PyDict>,
-    range: TextRange,
-    vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
-) {
-    let range = text_range_to_source_range(source_code, 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_code = SourceCodeOwned::new("".to_owned(), source.to_owned());
-    let top = parser::parse(source, mode.into())
-        .map_err(|parse_error| ParseError {
-            error: parse_error.error,
-            raw_location: parse_error.location,
-            location: text_range_to_source_range(&source_code, parse_error.location)
-                .start
-                .to_source_location(),
-            source_path: "<unknown>".to_string(),
-        })?
-        .into_syntax();
-    let top = match top {
-        ruff::Mod::Module(m) => Mod::Module(m),
-        ruff::Mod::Expression(e) => Mod::Expression(e),
-    };
-    Ok(top.ast_to_object(vm, &source_code))
-}
-
-#[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_code = SourceCodeOwned::new(filename.to_owned(), "".to_owned());
-    let ast: Mod = Node::ast_from_object(vm, &source_code, object)?;
-    let ast = match ast {
-        Mod::Module(m) => ruff::Mod::Module(m),
-        Mod::Interactive(ModInteractive { range, body }) => {
-            ruff::Mod::Module(ruff::ModModule { range, body })
-        }
-        Mod::Expression(e) => ruff::Mod::Expression(e),
-        Mod::FunctionType(_) => todo!(),
-    };
-    // TODO: create a textual representation of the ast
-    let text = "";
-    let source_code = SourceCode::new(filename, text);
-    let code = codegen::compile::compile_top(ast, source_code, 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;
-
-// __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
-    | 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;
-
-pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = _ast::make_module(vm);
-    pyast::extend_module_nodes(vm, &module);
-    module
-}
diff --git a/vm/src/stdlib/ast/argument.rs b/vm/src/stdlib/ast/argument.rs
deleted file mode 100644
index dae2345f0a..0000000000
--- a/vm/src/stdlib/ast/argument.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use super::*;
-
-pub(super) struct PositionalArguments {
-    pub range: TextRange,
-    pub args: Box<[ruff::Expr]>,
-}
-
-impl Node for PositionalArguments {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { args, range: _ } = self;
-        BoxedSlice(args).ast_to_object(vm, source_code)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let args: BoxedSlice<_> = Node::ast_from_object(vm, source_code, object)?;
-        Ok(Self {
-            args: args.0,
-            range: TextRange::default(), // TODO
-        })
-    }
-}
-
-pub(super) struct KeywordArguments {
-    pub range: TextRange,
-    pub keywords: Box<[ruff::Keyword]>,
-}
-
-impl Node for KeywordArguments {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { keywords, range: _ } = self;
-        // TODO: use range
-        BoxedSlice(keywords).ast_to_object(vm, source_code)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let keywords: BoxedSlice<_> = Node::ast_from_object(vm, source_code, object)?;
-        Ok(Self {
-            keywords: keywords.0,
-            range: TextRange::default(), // TODO
-        })
-    }
-}
-
-pub(super) fn merge_function_call_arguments(
-    pos_args: PositionalArguments,
-    key_args: KeywordArguments,
-) -> ruff::Arguments {
-    let range = pos_args.range.cover(key_args.range);
-
-    ruff::Arguments {
-        range,
-        args: pos_args.args,
-        keywords: key_args.keywords,
-    }
-}
-
-pub(super) fn split_function_call_arguments(
-    args: ruff::Arguments,
-) -> (PositionalArguments, KeywordArguments) {
-    let ruff::Arguments {
-        range: _,
-        args,
-        keywords,
-    } = args;
-
-    let positional_arguments_range = args
-        .iter()
-        .map(|item| item.range())
-        .reduce(|acc, next| acc.cover(next))
-        .unwrap_or_default();
-    // debug_assert!(range.contains_range(positional_arguments_range));
-    let positional_arguments = PositionalArguments {
-        range: positional_arguments_range,
-        args,
-    };
-
-    let keyword_arguments_range = keywords
-        .iter()
-        .map(|item| item.range())
-        .reduce(|acc, next| acc.cover(next))
-        .unwrap_or_default();
-    // debug_assert!(range.contains_range(keyword_arguments_range));
-    let keyword_arguments = KeywordArguments {
-        range: keyword_arguments_range,
-        keywords,
-    };
-
-    (positional_arguments, keyword_arguments)
-}
-
-pub(super) fn split_class_def_args(
-    args: Option<Box<ruff::Arguments>>,
-) -> (Option<PositionalArguments>, Option<KeywordArguments>) {
-    let args = match args {
-        None => return (None, None),
-        Some(args) => *args,
-    };
-    let ruff::Arguments {
-        range: _,
-        args,
-        keywords,
-    } = args;
-
-    let positional_arguments_range = args
-        .iter()
-        .map(|item| item.range())
-        .reduce(|acc, next| acc.cover(next))
-        .unwrap_or_default();
-    // debug_assert!(range.contains_range(positional_arguments_range));
-    let positional_arguments = PositionalArguments {
-        range: positional_arguments_range,
-        args,
-    };
-
-    let keyword_arguments_range = keywords
-        .iter()
-        .map(|item| item.range())
-        .reduce(|acc, next| acc.cover(next))
-        .unwrap_or_default();
-    // debug_assert!(range.contains_range(keyword_arguments_range));
-    let keyword_arguments = KeywordArguments {
-        range: keyword_arguments_range,
-        keywords,
-    };
-
-    (Some(positional_arguments), Some(keyword_arguments))
-}
-
-pub(super) fn merge_class_def_args(
-    positional_arguments: Option<PositionalArguments>,
-    keyword_arguments: Option<KeywordArguments>,
-) -> Option<Box<ruff::Arguments>> {
-    if positional_arguments.is_none() && keyword_arguments.is_none() {
-        return None;
-    }
-
-    let args = if let Some(positional_arguments) = positional_arguments {
-        positional_arguments.args
-    } else {
-        vec![].into_boxed_slice()
-    };
-    let keywords = if let Some(keyword_arguments) = keyword_arguments {
-        keyword_arguments.keywords
-    } else {
-        vec![].into_boxed_slice()
-    };
-
-    Some(Box::new(ruff::Arguments {
-        range: Default::default(), // TODO
-        args,
-        keywords,
-    }))
-}
diff --git a/vm/src/stdlib/ast/basic.rs b/vm/src/stdlib/ast/basic.rs
deleted file mode 100644
index c6ad8fa228..0000000000
--- a/vm/src/stdlib/ast/basic.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use rustpython_codegen::compile::ruff_int_to_bigint;
-
-use super::*;
-
-impl Node for ruff::Identifier {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let id = self.as_str();
-        vm.ctx.new_str(id).into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let py_str = PyStrRef::try_from_object(vm, object)?;
-        Ok(Self::new(py_str.as_str(), TextRange::default()))
-    }
-}
-
-impl Node for ruff::Int {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        vm.ctx.new_int(ruff_int_to_bigint(&self).unwrap()).into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        // FIXME: performance
-        let value: PyIntRef = object.try_into_value(vm)?;
-        let value = value.as_bigint().to_string();
-        Ok(value.parse().unwrap())
-    }
-}
-
-impl Node for bool {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        vm.ctx.new_int(self as u8).into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        i32::try_from_object(vm, object).map(|i| i != 0)
-    }
-}
diff --git a/vm/src/stdlib/ast/elif_else_clause.rs b/vm/src/stdlib/ast/elif_else_clause.rs
deleted file mode 100644
index 13f6865eaf..0000000000
--- a/vm/src/stdlib/ast/elif_else_clause.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use super::*;
-
-pub(super) fn ast_to_object(
-    clause: ruff::ElifElseClause,
-    mut rest: std::vec::IntoIter<ruff::ElifElseClause>,
-    vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
-) -> PyObjectRef {
-    let ruff::ElifElseClause { range, test, body } = clause;
-    let Some(test) = test else {
-        assert!(rest.len() == 0);
-        return body.ast_to_object(vm, source_code);
-    };
-    let node = NodeAst
-        .into_ref_with_type(vm, pyast::NodeStmtIf::static_type().to_owned())
-        .unwrap();
-    let dict = node.as_object().dict().unwrap();
-
-    dict.set_item("test", test.ast_to_object(vm, source_code), vm)
-        .unwrap();
-    dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-        .unwrap();
-
-    let orelse = if let Some(next) = rest.next() {
-        if next.test.is_some() {
-            vm.ctx
-                .new_list(vec![ast_to_object(next, rest, vm, source_code)])
-                .into()
-        } else {
-            next.body.ast_to_object(vm, source_code)
-        }
-    } else {
-        vm.ctx.new_list(vec![]).into()
-    };
-    dict.set_item("orelse", orelse, vm).unwrap();
-
-    node_add_location(&dict, range, vm, source_code);
-    node.into()
-}
-
-pub(super) fn ast_from_object(
-    vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
-    object: PyObjectRef,
-) -> PyResult<ruff::StmtIf> {
-    let test = Node::ast_from_object(vm, source_code, get_node_field(vm, &object, "test", "If")?)?;
-    let body = Node::ast_from_object(vm, source_code, get_node_field(vm, &object, "body", "If")?)?;
-    let orelse: Vec<ruff::Stmt> = Node::ast_from_object(
-        vm,
-        source_code,
-        get_node_field(vm, &object, "orelse", "If")?,
-    )?;
-    let range = range_from_object(vm, source_code, object, "If")?;
-
-    let elif_else_clauses = if let [ruff::Stmt::If(_)] = &*orelse {
-        let Some(ruff::Stmt::If(ruff::StmtIf {
-            range,
-            test,
-            body,
-            mut elif_else_clauses,
-        })) = orelse.into_iter().next()
-        else {
-            unreachable!()
-        };
-        elif_else_clauses.insert(
-            0,
-            ruff::ElifElseClause {
-                range,
-                test: Some(*test),
-                body,
-            },
-        );
-        elif_else_clauses
-    } else {
-        vec![ruff::ElifElseClause {
-            range,
-            test: None,
-            body: orelse,
-        }]
-    };
-
-    Ok(ruff::StmtIf {
-        test,
-        body,
-        elif_else_clauses,
-        range,
-    })
-}
diff --git a/vm/src/stdlib/ast/exception.rs b/vm/src/stdlib/ast/exception.rs
deleted file mode 100644
index b8bf034a7b..0000000000
--- a/vm/src/stdlib/ast/exception.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use super::*;
-
-// sum
-impl Node for ruff::ExceptHandler {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::ExceptHandler(cons) => cons.ast_to_object(vm, source_code),
-        }
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(
-            if _cls.is(pyast::NodeExceptHandlerExceptHandler::static_type()) {
-                Self::ExceptHandler(ruff::ExceptHandlerExceptHandler::ast_from_object(
-                    _vm,
-                    source_code,
-                    _object,
-                )?)
-            } else {
-                return Err(_vm.new_type_error(format!(
-                    "expected some sort of excepthandler, but got {}",
-                    _object.repr(_vm)?
-                )));
-            },
-        )
-    }
-}
-// constructor
-impl Node for ruff::ExceptHandlerExceptHandler {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            type_,
-            name,
-            body,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(
-                _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_code), _vm)
-            .unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            type_: get_node_field_opt(_vm, &_object, "type")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "ExceptHandler")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "ExceptHandler")?,
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/expression.rs b/vm/src/stdlib/ast/expression.rs
deleted file mode 100644
index 8999c2c92c..0000000000
--- a/vm/src/stdlib/ast/expression.rs
+++ /dev/null
@@ -1,1235 +0,0 @@
-use super::*;
-use crate::stdlib::ast::argument::{merge_function_call_arguments, split_function_call_arguments};
-use crate::stdlib::ast::constant::Constant;
-use crate::stdlib::ast::string::JoinedStr;
-
-// sum
-impl Node for ruff::Expr {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::BoolOp(cons) => cons.ast_to_object(vm, source_code),
-            Self::Name(cons) => cons.ast_to_object(vm, source_code),
-            Self::BinOp(cons) => cons.ast_to_object(vm, source_code),
-            Self::UnaryOp(cons) => cons.ast_to_object(vm, source_code),
-            Self::Lambda(cons) => cons.ast_to_object(vm, source_code),
-            Self::If(cons) => cons.ast_to_object(vm, source_code),
-            Self::Dict(cons) => cons.ast_to_object(vm, source_code),
-            Self::Set(cons) => cons.ast_to_object(vm, source_code),
-            Self::ListComp(cons) => cons.ast_to_object(vm, source_code),
-            Self::SetComp(cons) => cons.ast_to_object(vm, source_code),
-            Self::DictComp(cons) => cons.ast_to_object(vm, source_code),
-            Self::Generator(cons) => cons.ast_to_object(vm, source_code),
-            Self::Await(cons) => cons.ast_to_object(vm, source_code),
-            Self::Yield(cons) => cons.ast_to_object(vm, source_code),
-            Self::YieldFrom(cons) => cons.ast_to_object(vm, source_code),
-            Self::Compare(cons) => cons.ast_to_object(vm, source_code),
-            Self::Call(cons) => cons.ast_to_object(vm, source_code),
-            Self::Attribute(cons) => cons.ast_to_object(vm, source_code),
-            Self::Subscript(cons) => cons.ast_to_object(vm, source_code),
-            Self::Starred(cons) => cons.ast_to_object(vm, source_code),
-            Self::List(cons) => cons.ast_to_object(vm, source_code),
-            Self::Tuple(cons) => cons.ast_to_object(vm, source_code),
-            Self::Slice(cons) => cons.ast_to_object(vm, source_code),
-            Self::NumberLiteral(cons) => constant::number_literal_to_object(vm, source_code, cons),
-            Self::StringLiteral(cons) => constant::string_literal_to_object(vm, source_code, cons),
-            Self::FString(cons) => string::fstring_to_object(vm, source_code, cons),
-            Self::BytesLiteral(cons) => constant::bytes_literal_to_object(vm, source_code, cons),
-            Self::BooleanLiteral(cons) => {
-                constant::boolean_literal_to_object(vm, source_code, cons)
-            }
-            Self::NoneLiteral(cons) => constant::none_literal_to_object(vm, source_code, cons),
-            Self::EllipsisLiteral(cons) => {
-                constant::ellipsis_literal_to_object(vm, source_code, cons)
-            }
-            Self::Named(cons) => cons.ast_to_object(vm, source_code),
-            Self::IpyEscapeCommand(_) => {
-                unimplemented!("IPython escape command is not allowed in Python AST")
-            }
-        }
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let cls = object.class();
-        Ok(if cls.is(pyast::NodeExprBoolOp::static_type()) {
-            Self::BoolOp(ruff::ExprBoolOp::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprNamedExpr::static_type()) {
-            Self::Named(ruff::ExprNamed::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprBinOp::static_type()) {
-            Self::BinOp(ruff::ExprBinOp::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprUnaryOp::static_type()) {
-            Self::UnaryOp(ruff::ExprUnaryOp::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprLambda::static_type()) {
-            Self::Lambda(ruff::ExprLambda::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprIfExp::static_type()) {
-            Self::If(ruff::ExprIf::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprDict::static_type()) {
-            Self::Dict(ruff::ExprDict::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprSet::static_type()) {
-            Self::Set(ruff::ExprSet::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprListComp::static_type()) {
-            Self::ListComp(ruff::ExprListComp::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprSetComp::static_type()) {
-            Self::SetComp(ruff::ExprSetComp::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprDictComp::static_type()) {
-            Self::DictComp(ruff::ExprDictComp::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprGeneratorExp::static_type()) {
-            Self::Generator(ruff::ExprGenerator::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprAwait::static_type()) {
-            Self::Await(ruff::ExprAwait::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprYield::static_type()) {
-            Self::Yield(ruff::ExprYield::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprYieldFrom::static_type()) {
-            Self::YieldFrom(ruff::ExprYieldFrom::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprCompare::static_type()) {
-            Self::Compare(ruff::ExprCompare::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprCall::static_type()) {
-            Self::Call(ruff::ExprCall::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprAttribute::static_type()) {
-            Self::Attribute(ruff::ExprAttribute::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprSubscript::static_type()) {
-            Self::Subscript(ruff::ExprSubscript::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeExprStarred::static_type()) {
-            Self::Starred(ruff::ExprStarred::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprName::static_type()) {
-            Self::Name(ruff::ExprName::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprList::static_type()) {
-            Self::List(ruff::ExprList::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprTuple::static_type()) {
-            Self::Tuple(ruff::ExprTuple::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprSlice::static_type()) {
-            Self::Slice(ruff::ExprSlice::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeExprConstant::static_type()) {
-            Constant::ast_from_object(vm, source_code, object)?.into_expr()
-        } else if cls.is(pyast::NodeExprJoinedStr::static_type()) {
-            JoinedStr::ast_from_object(vm, source_code, object)?.into_expr()
-        } else {
-            return Err(vm.new_type_error(format!(
-                "expected some sort of expr, but got {}",
-                object.repr(vm)?
-            )));
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprBoolOp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { op, values, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprBoolOp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("op", op.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("values", values.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            op: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "op", "BoolOp")?,
-            )?,
-            values: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "values", "BoolOp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "BoolOp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprNamed {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            target,
-            value,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprNamedExpr::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("target", target.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            target: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "target", "NamedExpr")?,
-            )?,
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "NamedExpr")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "NamedExpr")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprBinOp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            left,
-            op,
-            right,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprBinOp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("left", left.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("op", op.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("right", right.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            left: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "left", "BinOp")?,
-            )?,
-            op: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "op", "BinOp")?,
-            )?,
-            right: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "right", "BinOp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "BinOp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprUnaryOp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { op, operand, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprUnaryOp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("op", op.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("operand", operand.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            op: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "op", "UnaryOp")?,
-            )?,
-            operand: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "operand", "UnaryOp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "UnaryOp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprLambda {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            parameters,
-            body,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            parameters: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "args", "Lambda")?,
-            )?,
-            body: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "body", "Lambda")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Lambda")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprIf {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            test,
-            body,
-            orelse,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprIfExp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("test", test.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("orelse", orelse.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            test: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "test", "IfExp")?,
-            )?,
-            body: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "body", "IfExp")?,
-            )?,
-            orelse: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "orelse", "IfExp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "IfExp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprDict {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { items, range } = self;
-        let (keys, values) =
-            items
-                .into_iter()
-                .fold((vec![], vec![]), |(mut keys, mut values), item| {
-                    keys.push(item.key);
-                    values.push(item.value);
-                    (keys, values)
-                });
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprDict::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("keys", keys.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("values", values.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let keys: Vec<Option<ruff::Expr>> = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "keys", "Dict")?,
-        )?;
-        let values: Vec<_> = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "values", "Dict")?,
-        )?;
-        let items = keys
-            .into_iter()
-            .zip(values)
-            .map(|(key, value)| ruff::DictItem { key, value })
-            .collect();
-        Ok(Self {
-            items,
-            range: range_from_object(vm, source_code, object, "Dict")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprSet {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { elts, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprSet::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elts", elts.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elts: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elts", "Set")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Set")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprListComp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            elt,
-            generators,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprListComp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elt", elt.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("generators", generators.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elt: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elt", "ListComp")?,
-            )?,
-            generators: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "generators", "ListComp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "ListComp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprSetComp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            elt,
-            generators,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprSetComp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elt", elt.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("generators", generators.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elt: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elt", "SetComp")?,
-            )?,
-            generators: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "generators", "SetComp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "SetComp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprDictComp {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            key,
-            value,
-            generators,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprDictComp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("key", key.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("generators", generators.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            key: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "key", "DictComp")?,
-            )?,
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "DictComp")?,
-            )?,
-            generators: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "generators", "DictComp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "DictComp")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprGenerator {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            elt,
-            generators,
-            range,
-            parenthesized: _,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprGeneratorExp::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elt", elt.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("generators", generators.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elt: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elt", "GeneratorExp")?,
-            )?,
-            generators: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "generators", "GeneratorExp")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "GeneratorExp")?,
-            // TODO: Is this correct?
-            parenthesized: true,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprAwait {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { value, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprAwait::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "Await")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Await")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprYield {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { value, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprYield::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: get_node_field_opt(vm, &object, "value")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(vm, source_code, object, "Yield")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprYieldFrom {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { value, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprYieldFrom::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "YieldFrom")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "YieldFrom")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprCompare {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            left,
-            ops,
-            comparators,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprCompare::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("left", left.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ops", BoxedSlice(ops).ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item(
-            "comparators",
-            BoxedSlice(comparators).ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            left: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "left", "Compare")?,
-            )?,
-            ops: {
-                let ops: BoxedSlice<_> = Node::ast_from_object(
-                    vm,
-                    source_code,
-                    get_node_field(vm, &object, "ops", "Compare")?,
-                )?;
-                ops.0
-            },
-            comparators: {
-                let comparators: BoxedSlice<_> = Node::ast_from_object(
-                    vm,
-                    source_code,
-                    get_node_field(vm, &object, "comparators", "Compare")?,
-                )?;
-                comparators.0
-            },
-            range: range_from_object(vm, source_code, object, "Compare")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprCall {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            func,
-            arguments,
-            range,
-        } = self;
-        let (positional_arguments, keyword_arguments) = split_function_call_arguments(arguments);
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprCall::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("func", func.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item(
-            "args",
-            positional_arguments.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        dict.set_item(
-            "keywords",
-            keyword_arguments.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            func: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "func", "Call")?,
-            )?,
-            arguments: merge_function_call_arguments(
-                Node::ast_from_object(
-                    vm,
-                    source_code,
-                    get_node_field(vm, &object, "args", "Call")?,
-                )?,
-                Node::ast_from_object(
-                    vm,
-                    source_code,
-                    get_node_field(vm, &object, "keywords", "Call")?,
-                )?,
-            ),
-            range: range_from_object(vm, source_code, object, "Call")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprAttribute {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            attr,
-            ctx,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprAttribute::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("attr", attr.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "Attribute")?,
-            )?,
-            attr: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "attr", "Attribute")?,
-            )?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "Attribute")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Attribute")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprSubscript {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            slice,
-            ctx,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprSubscript::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("slice", slice.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "Subscript")?,
-            )?,
-            slice: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "slice", "Subscript")?,
-            )?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "Subscript")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Subscript")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprStarred {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { value, ctx, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprStarred::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "Starred")?,
-            )?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "Starred")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Starred")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprName {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { id, ctx, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprName::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("id", id.to_pyobject(vm), vm).unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            id: Node::ast_from_object(vm, source_code, get_node_field(vm, &object, "id", "Name")?)?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "Name")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Name")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprList {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { elts, ctx, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprList::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elts", elts.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elts: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elts", "List")?,
-            )?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "List")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "List")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprTuple {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            elts,
-            ctx,
-            range: _range,
-            parenthesized: _,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprTuple::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("elts", elts.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ctx", ctx.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            elts: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "elts", "Tuple")?,
-            )?,
-            ctx: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ctx", "Tuple")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "Tuple")?,
-            parenthesized: true, // TODO: is this correct?
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ExprSlice {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            lower,
-            upper,
-            step,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprSlice::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("lower", lower.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("upper", upper.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("step", step.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            lower: get_node_field_opt(vm, &object, "lower")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            upper: get_node_field_opt(vm, &object, "upper")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            step: get_node_field_opt(vm, &object, "step")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(vm, source_code, object, "Slice")?,
-        })
-    }
-}
-
-// sum
-impl Node for ruff::ExprContext {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let node_type = match self {
-            Self::Load => pyast::NodeExprContextLoad::static_type(),
-            Self::Store => pyast::NodeExprContextStore::static_type(),
-            Self::Del => pyast::NodeExprContextDel::static_type(),
-            Self::Invalid => {
-                unimplemented!("Invalid expression context is not allowed in Python AST")
-            }
-        };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = object.class();
-        Ok(if _cls.is(pyast::NodeExprContextLoad::static_type()) {
-            Self::Load
-        } else if _cls.is(pyast::NodeExprContextStore::static_type()) {
-            Self::Store
-        } else if _cls.is(pyast::NodeExprContextDel::static_type()) {
-            Self::Del
-        } else {
-            return Err(vm.new_type_error(format!(
-                "expected some sort of expr_context, but got {}",
-                object.repr(vm)?
-            )));
-        })
-    }
-}
-
-// product
-impl Node for ruff::Comprehension {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            target,
-            iter,
-            ifs,
-            is_async,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeComprehension::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("target", target.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("iter", iter.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("ifs", ifs.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("is_async", is_async.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            target: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "target", "comprehension")?,
-            )?,
-            iter: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "iter", "comprehension")?,
-            )?,
-            ifs: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "ifs", "comprehension")?,
-            )?,
-            is_async: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "is_async", "comprehension")?,
-            )?,
-            range: Default::default(),
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/module.rs b/vm/src/stdlib/ast/module.rs
deleted file mode 100644
index 409d836808..0000000000
--- a/vm/src/stdlib/ast/module.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use super::*;
-use crate::stdlib::ast::type_ignore::TypeIgnore;
-
-/// Represents the different types of Python module structures.
-///
-/// This enum is used to represent the various possible forms of a Python module
-/// in an Abstract Syntax Tree (AST). It can correspond to:
-///
-/// - `Module`: A standard Python script, containing a sequence of statements
-///   (e.g., assignments, function calls), possibly with type ignores.
-/// - `Interactive`: A representation of code executed in an interactive
-///   Python session (e.g., the REPL or Jupyter notebooks), where statements
-///   are evaluated one at a time.
-/// - `Expression`: A single expression without any surrounding statements.
-///   This is typically used in scenarios like `eval()` or in expression-only
-///   contexts.
-/// - `FunctionType`: A function signature with argument and return type
-///   annotations, representing the type hints of a function (e.g., `def add(x: int, y: int) -> int`).
-pub(super) enum Mod {
-    Module(ruff::ModModule),
-    Interactive(ModInteractive),
-    Expression(ruff::ModExpression),
-    FunctionType(ModFunctionType),
-}
-
-// sum
-impl Node for Mod {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::Module(cons) => cons.ast_to_object(vm, source_code),
-            Self::Interactive(cons) => cons.ast_to_object(vm, source_code),
-            Self::Expression(cons) => cons.ast_to_object(vm, source_code),
-            Self::FunctionType(cons) => cons.ast_to_object(vm, source_code),
-        }
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let cls = object.class();
-        Ok(if cls.is(pyast::NodeModModule::static_type()) {
-            Self::Module(ruff::ModModule::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeModInteractive::static_type()) {
-            Self::Interactive(ModInteractive::ast_from_object(vm, source_code, object)?)
-        } else if cls.is(pyast::NodeModExpression::static_type()) {
-            Self::Expression(ruff::ModExpression::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?)
-        } else if cls.is(pyast::NodeModFunctionType::static_type()) {
-            Self::FunctionType(ModFunctionType::ast_from_object(vm, source_code, object)?)
-        } else {
-            return Err(vm.new_type_error(format!(
-                "expected some sort of mod, but got {}",
-                object.repr(vm)?
-            )));
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ModModule {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            body,
-            // type_ignores,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeModModule::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        // TODO: Improve ruff API
-        // ruff ignores type_ignore comments currently.
-        let type_ignores: Vec<TypeIgnore> = vec![];
-        dict.set_item(
-            "type_ignores",
-            type_ignores.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            body: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "body", "Module")?,
-            )?,
-            // type_ignores: Node::ast_from_object(
-            //     _vm,
-            //     get_node_field(_vm, &_object, "type_ignores", "Module")?,
-            // )?,
-            range: Default::default(),
-        })
-    }
-}
-
-pub(super) struct ModInteractive {
-    pub(crate) range: TextRange,
-    pub(crate) body: Vec<ruff::Stmt>,
-}
-
-// constructor
-impl Node for ModInteractive {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { body, range } = self;
-        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.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            body: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "body", "Interactive")?,
-            )?,
-            range: Default::default(),
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::ModExpression {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { body, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeModExpression::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            body: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "body", "Expression")?,
-            )?,
-            range: Default::default(),
-        })
-    }
-}
-
-pub(super) struct ModFunctionType {
-    pub(crate) argtypes: Box<[ruff::Expr]>,
-    pub(crate) returns: ruff::Expr,
-    pub(crate) range: TextRange,
-}
-
-// constructor
-impl Node for ModFunctionType {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            argtypes,
-            returns,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeModFunctionType::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item(
-            "argtypes",
-            BoxedSlice(argtypes).ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        dict.set_item("returns", returns.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            argtypes: {
-                let argtypes: BoxedSlice<_> = Node::ast_from_object(
-                    vm,
-                    source_code,
-                    get_node_field(vm, &object, "argtypes", "FunctionType")?,
-                )?;
-                argtypes.0
-            },
-            returns: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "returns", "FunctionType")?,
-            )?,
-            range: Default::default(),
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/node.rs b/vm/src/stdlib/ast/node.rs
deleted file mode 100644
index bf56f6683d..0000000000
--- a/vm/src/stdlib/ast/node.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-use crate::{PyObjectRef, PyResult, VirtualMachine};
-use rustpython_compiler_source::SourceCodeOwned;
-
-pub(crate) trait Node: Sized {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef;
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self>;
-
-    /// Used in `Option::ast_from_object`; if `true`, that impl will return None.
-    fn is_none(&self) -> bool {
-        false
-    }
-}
-
-impl<T: Node> Node for Vec<T> {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        vm.ctx
-            .new_list(
-                self.into_iter()
-                    .map(|node| node.ast_to_object(vm, source_code))
-                    .collect(),
-            )
-            .into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        vm.extract_elements_with(&object, |obj| Node::ast_from_object(vm, source_code, obj))
-    }
-}
-
-impl<T: Node> Node for Box<T> {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        (*self).ast_to_object(vm, source_code)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        T::ast_from_object(vm, source_code, object).map(Self::new)
-    }
-
-    fn is_none(&self) -> bool {
-        (**self).is_none()
-    }
-}
-
-impl<T: Node> Node for Option<T> {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Some(node) => node.ast_to_object(vm, source_code),
-            None => vm.ctx.none(),
-        }
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        if vm.is_none(&object) {
-            Ok(None)
-        } else {
-            let x = T::ast_from_object(vm, source_code, object)?;
-            Ok((!x.is_none()).then_some(x))
-        }
-    }
-}
-
-pub(super) struct BoxedSlice<T>(pub(super) Box<[T]>);
-
-impl<T: Node> Node for BoxedSlice<T> {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        self.0.into_vec().ast_to_object(vm, source_code)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self(
-            <Vec<T> as Node>::ast_from_object(vm, source_code, object)?.into_boxed_slice(),
-        ))
-    }
-}
diff --git a/vm/src/stdlib/ast/operator.rs b/vm/src/stdlib/ast/operator.rs
deleted file mode 100644
index fbb2af68c5..0000000000
--- a/vm/src/stdlib/ast/operator.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use super::*;
-
-// sum
-impl Node for ruff::BoolOp {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let node_type = match self {
-            Self::And => pyast::NodeBoolOpAnd::static_type(),
-            Self::Or => pyast::NodeBoolOpOr::static_type(),
-        };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeBoolOpAnd::static_type()) {
-            Self::And
-        } else if _cls.is(pyast::NodeBoolOpOr::static_type()) {
-            Self::Or
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of boolop, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-
-// sum
-impl Node for ruff::Operator {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let node_type = match self {
-            Self::Add => pyast::NodeOperatorAdd::static_type(),
-            Self::Sub => pyast::NodeOperatorSub::static_type(),
-            Self::Mult => pyast::NodeOperatorMult::static_type(),
-            Self::MatMult => pyast::NodeOperatorMatMult::static_type(),
-            Self::Div => pyast::NodeOperatorDiv::static_type(),
-            Self::Mod => pyast::NodeOperatorMod::static_type(),
-            Self::Pow => pyast::NodeOperatorPow::static_type(),
-            Self::LShift => pyast::NodeOperatorLShift::static_type(),
-            Self::RShift => pyast::NodeOperatorRShift::static_type(),
-            Self::BitOr => pyast::NodeOperatorBitOr::static_type(),
-            Self::BitXor => pyast::NodeOperatorBitXor::static_type(),
-            Self::BitAnd => pyast::NodeOperatorBitAnd::static_type(),
-            Self::FloorDiv => pyast::NodeOperatorFloorDiv::static_type(),
-        };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeOperatorAdd::static_type()) {
-            Self::Add
-        } else if _cls.is(pyast::NodeOperatorSub::static_type()) {
-            Self::Sub
-        } else if _cls.is(pyast::NodeOperatorMult::static_type()) {
-            Self::Mult
-        } else if _cls.is(pyast::NodeOperatorMatMult::static_type()) {
-            Self::MatMult
-        } else if _cls.is(pyast::NodeOperatorDiv::static_type()) {
-            Self::Div
-        } else if _cls.is(pyast::NodeOperatorMod::static_type()) {
-            Self::Mod
-        } else if _cls.is(pyast::NodeOperatorPow::static_type()) {
-            Self::Pow
-        } else if _cls.is(pyast::NodeOperatorLShift::static_type()) {
-            Self::LShift
-        } else if _cls.is(pyast::NodeOperatorRShift::static_type()) {
-            Self::RShift
-        } else if _cls.is(pyast::NodeOperatorBitOr::static_type()) {
-            Self::BitOr
-        } else if _cls.is(pyast::NodeOperatorBitXor::static_type()) {
-            Self::BitXor
-        } else if _cls.is(pyast::NodeOperatorBitAnd::static_type()) {
-            Self::BitAnd
-        } else if _cls.is(pyast::NodeOperatorFloorDiv::static_type()) {
-            Self::FloorDiv
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of operator, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-
-// sum
-impl Node for ruff::UnaryOp {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let node_type = match self {
-            Self::Invert => pyast::NodeUnaryOpInvert::static_type(),
-            Self::Not => pyast::NodeUnaryOpNot::static_type(),
-            Self::UAdd => pyast::NodeUnaryOpUAdd::static_type(),
-            Self::USub => pyast::NodeUnaryOpUSub::static_type(),
-        };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeUnaryOpInvert::static_type()) {
-            Self::Invert
-        } else if _cls.is(pyast::NodeUnaryOpNot::static_type()) {
-            Self::Not
-        } else if _cls.is(pyast::NodeUnaryOpUAdd::static_type()) {
-            Self::UAdd
-        } else if _cls.is(pyast::NodeUnaryOpUSub::static_type()) {
-            Self::USub
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of unaryop, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-
-// sum
-impl Node for ruff::CmpOp {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        let node_type = match self {
-            Self::Eq => pyast::NodeCmpOpEq::static_type(),
-            Self::NotEq => pyast::NodeCmpOpNotEq::static_type(),
-            Self::Lt => pyast::NodeCmpOpLt::static_type(),
-            Self::LtE => pyast::NodeCmpOpLtE::static_type(),
-            Self::Gt => pyast::NodeCmpOpGt::static_type(),
-            Self::GtE => pyast::NodeCmpOpGtE::static_type(),
-            Self::Is => pyast::NodeCmpOpIs::static_type(),
-            Self::IsNot => pyast::NodeCmpOpIsNot::static_type(),
-            Self::In => pyast::NodeCmpOpIn::static_type(),
-            Self::NotIn => pyast::NodeCmpOpNotIn::static_type(),
-        };
-        NodeAst
-            .into_ref_with_type(vm, node_type.to_owned())
-            .unwrap()
-            .into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeCmpOpEq::static_type()) {
-            Self::Eq
-        } else if _cls.is(pyast::NodeCmpOpNotEq::static_type()) {
-            Self::NotEq
-        } else if _cls.is(pyast::NodeCmpOpLt::static_type()) {
-            Self::Lt
-        } else if _cls.is(pyast::NodeCmpOpLtE::static_type()) {
-            Self::LtE
-        } else if _cls.is(pyast::NodeCmpOpGt::static_type()) {
-            Self::Gt
-        } else if _cls.is(pyast::NodeCmpOpGtE::static_type()) {
-            Self::GtE
-        } else if _cls.is(pyast::NodeCmpOpIs::static_type()) {
-            Self::Is
-        } else if _cls.is(pyast::NodeCmpOpIsNot::static_type()) {
-            Self::IsNot
-        } else if _cls.is(pyast::NodeCmpOpIn::static_type()) {
-            Self::In
-        } else if _cls.is(pyast::NodeCmpOpNotIn::static_type()) {
-            Self::NotIn
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of cmpop, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/other.rs b/vm/src/stdlib/ast/other.rs
deleted file mode 100644
index 9003584896..0000000000
--- a/vm/src/stdlib/ast/other.rs
+++ /dev/null
@@ -1,145 +0,0 @@
-use super::*;
-use num_traits::ToPrimitive;
-use rustpython_compiler_core::bytecode;
-
-impl Node for ruff::ConversionFlag {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        vm.ctx.new_int(self as u8).into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        i32::try_from_object(vm, object)?
-            .to_u32()
-            .and_then(bytecode::ConversionFlag::from_op_arg)
-            .map(|flag| match flag {
-                bytecode::ConversionFlag::None => Self::None,
-                bytecode::ConversionFlag::Str => Self::Str,
-                bytecode::ConversionFlag::Ascii => Self::Ascii,
-                bytecode::ConversionFlag::Repr => Self::Repr,
-            })
-            .ok_or_else(|| vm.new_value_error("invalid conversion flag"))
-    }
-}
-
-// /// This is just a string, not strictly an AST node. But it makes AST conversions easier.
-impl Node for ruff::name::Name {
-    fn ast_to_object(self, vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        vm.ctx.new_str(self.as_str()).to_pyobject(vm)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        match object.downcast::<PyStr>() {
-            Ok(name) => Ok(Self::new(name)),
-            Err(_) => Err(vm.new_value_error("expected str for name")),
-        }
-    }
-}
-
-impl Node for ruff::Decorator {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        ruff::Expr::ast_to_object(self.expression, vm, source_code)
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let expression = ruff::Expr::ast_from_object(vm, source_code, object)?;
-        let range = expression.range();
-        Ok(Self { expression, range })
-    }
-}
-
-// product
-impl Node for ruff::Alias {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            asname,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeAlias::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("asname", asname.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "name", "alias")?,
-            )?,
-            asname: get_node_field_opt(vm, &object, "asname")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(vm, source_code, object, "alias")?,
-        })
-    }
-}
-
-// product
-impl Node for ruff::WithItem {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            context_expr,
-            optional_vars,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeWithItem::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item(
-            "context_expr",
-            context_expr.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        dict.set_item(
-            "optional_vars",
-            optional_vars.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            context_expr: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "context_expr", "withitem")?,
-            )?,
-            optional_vars: get_node_field_opt(vm, &object, "optional_vars")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            range: Default::default(),
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/pattern.rs b/vm/src/stdlib/ast/pattern.rs
deleted file mode 100644
index 7057309989..0000000000
--- a/vm/src/stdlib/ast/pattern.rs
+++ /dev/null
@@ -1,531 +0,0 @@
-use super::*;
-
-// product
-impl Node for ruff::MatchCase {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            pattern,
-            guard,
-            body,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        dict.set_item("guard", guard.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            pattern: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "pattern", "match_case")?,
-            )?,
-            guard: get_node_field_opt(_vm, &_object, "guard")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "match_case")?,
-            )?,
-            range: Default::default(),
-        })
-    }
-}
-
-// sum
-impl Node for ruff::Pattern {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::MatchValue(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchSingleton(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchSequence(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchMapping(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchClass(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchStar(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchAs(cons) => cons.ast_to_object(vm, source_code),
-            Self::MatchOr(cons) => cons.ast_to_object(vm, source_code),
-        }
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodePatternMatchValue::static_type()) {
-            Self::MatchValue(ruff::PatternMatchValue::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchSingleton::static_type()) {
-            Self::MatchSingleton(ruff::PatternMatchSingleton::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchSequence::static_type()) {
-            Self::MatchSequence(ruff::PatternMatchSequence::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchMapping::static_type()) {
-            Self::MatchMapping(ruff::PatternMatchMapping::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchClass::static_type()) {
-            Self::MatchClass(ruff::PatternMatchClass::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchStar::static_type()) {
-            Self::MatchStar(ruff::PatternMatchStar::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchAs::static_type()) {
-            Self::MatchAs(ruff::PatternMatchAs::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodePatternMatchOr::static_type()) {
-            Self::MatchOr(ruff::PatternMatchOr::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of pattern, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-// constructor
-impl Node for ruff::PatternMatchValue {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "value", "MatchValue")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "MatchValue")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchSingleton {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(
-                _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_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "value", "MatchSingleton")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "MatchSingleton")?,
-        })
-    }
-}
-
-impl Node for ruff::Singleton {
-    fn ast_to_object(self, _vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        todo!()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        todo!()
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchSequence {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(
-                _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_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            patterns: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "patterns", "MatchSequence")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "MatchSequence")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchMapping {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            keys,
-            patterns,
-            rest,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        dict.set_item("patterns", patterns.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("rest", rest.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            keys: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "keys", "MatchMapping")?,
-            )?,
-            patterns: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "patterns", "MatchMapping")?,
-            )?,
-            rest: get_node_field_opt(_vm, &_object, "rest")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "MatchMapping")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchClass {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            cls,
-            arguments,
-            range: _range,
-        } = self;
-        let (patterns, kwd_attrs, kwd_patterns) = split_pattern_match_class(arguments);
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodePatternMatchClass::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("cls", cls.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("patterns", patterns.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("kwd_attrs", kwd_attrs.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item(
-            "kwd_patterns",
-            kwd_patterns.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let patterns = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "patterns", "MatchClass")?,
-        )?;
-        let kwd_attrs = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "kwd_attrs", "MatchClass")?,
-        )?;
-        let kwd_patterns = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "kwd_patterns", "MatchClass")?,
-        )?;
-        let (patterns, keywords) = merge_pattern_match_class(patterns, kwd_attrs, kwd_patterns);
-
-        Ok(Self {
-            cls: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "cls", "MatchClass")?,
-            )?,
-            range: range_from_object(vm, source_code, object, "MatchClass")?,
-            arguments: ruff::PatternArguments {
-                range: Default::default(),
-                patterns,
-                keywords,
-            },
-        })
-    }
-}
-
-struct PatternMatchClassPatterns {
-    pub _range: TextRange, // TODO: Use this
-}
-
-impl Node for PatternMatchClassPatterns {
-    fn ast_to_object(self, _vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        todo!()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        todo!()
-    }
-}
-
-struct PatternMatchClassKeywordAttributes {
-    pub _range: TextRange, // TODO: Use this
-}
-
-impl Node for PatternMatchClassKeywordAttributes {
-    fn ast_to_object(self, _vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        todo!()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        todo!()
-    }
-}
-
-struct PatternMatchClassKeywordPatterns {
-    pub _range: TextRange, // TODO: Use this
-}
-
-impl Node for PatternMatchClassKeywordPatterns {
-    fn ast_to_object(self, _vm: &VirtualMachine, _source_code: &SourceCodeOwned) -> PyObjectRef {
-        todo!()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        todo!()
-    }
-}
-// constructor
-impl Node for ruff::PatternMatchStar {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "MatchStar")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchAs {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            pattern,
-            name,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            pattern: get_node_field_opt(_vm, &_object, "pattern")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            name: get_node_field_opt(_vm, &_object, "name")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "MatchAs")?,
-        })
-    }
-}
-
-// constructor
-impl Node for ruff::PatternMatchOr {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            patterns,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            patterns: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "patterns", "MatchOr")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "MatchOr")?,
-        })
-    }
-}
-
-fn split_pattern_match_class(
-    _arguments: ruff::PatternArguments,
-) -> (
-    PatternMatchClassPatterns,
-    PatternMatchClassKeywordAttributes,
-    PatternMatchClassKeywordPatterns,
-) {
-    todo!()
-}
-
-/// Merges the pattern match class attributes and patterns, opposite of [`split_pattern_match_class`].
-fn merge_pattern_match_class(
-    _patterns: PatternMatchClassPatterns,
-    _kwd_attrs: PatternMatchClassKeywordAttributes,
-    _kwd_patterns: PatternMatchClassKeywordPatterns,
-) -> (Vec<ruff::Pattern>, Vec<ruff::PatternKeyword>) {
-    todo!()
-}
diff --git a/vm/src/stdlib/ast/pyast.rs b/vm/src/stdlib/ast/pyast.rs
deleted file mode 100644
index 8aae6c72e0..0000000000
--- a/vm/src/stdlib/ast/pyast.rs
+++ /dev/null
@@ -1,979 +0,0 @@
-#![allow(clippy::all)]
-
-use super::*;
-use crate::common::ascii;
-
-macro_rules! impl_node {
-    (
-        $(#[$meta:meta])*
-        $vis:vis struct $name:ident,
-        fields: [$($field:expr),* $(,)?],
-        attributes: [$($attr:expr),* $(,)?] $(,)?
-    ) => {
-        $(#[$meta])*
-        $vis struct $name;
-
-        #[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
-    (
-        $(#[$meta:meta])*
-        $vis:vis struct $name:ident,
-        fields: [$($field:expr),* $(,)?] $(,)?
-    ) => {
-        impl_node!(
-            $(#[$meta])*
-            $vis struct $name,
-            fields: [$($field),*],
-            attributes: [],
-        );
-    };
-    // Without fields
-    (
-        $(#[$meta:meta])*
-        $vis:vis struct $name:ident,
-        attributes: [$($attr:expr),* $(,)?] $(,)?
-    ) => {
-        impl_node!(
-            $(#[$meta])*
-            $vis struct $name,
-            fields: [],
-            attributes: [$($attr),*],
-        );
-    };
-    // Without fields and attributes
-    (
-        $(#[$meta:meta])*
-        $vis:vis struct $name:ident $(,)?
-    ) => {
-        impl_node!(
-            $(#[$meta])*
-            $vis struct $name,
-            fields: [],
-            attributes: [],
-        );
-    };
-}
-
-#[pyclass(module = "_ast", name = "mod", base = "NodeAst")]
-pub(crate) struct NodeMod;
-
-#[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")]
-pub(crate) struct NodeStmt;
-
-#[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")]
-pub(crate) struct NodeExpr;
-
-#[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 = "Constant", base = "NodeExpr")]
-    pub(crate) struct NodeExprConstant,
-    fields: ["value", "kind"],
-    attributes: ["lineno", "col_offset", "end_lineno", "end_col_offset"],
-);
-
-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")]
-pub(crate) struct NodeExprContext;
-
-#[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")]
-pub(crate) struct NodeBoolOp;
-
-#[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")]
-pub(crate) struct NodeOperator;
-
-#[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")]
-pub(crate) struct NodeUnaryOp;
-
-#[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")]
-pub(crate) struct NodeCmpOp;
-
-#[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")]
-pub(crate) struct NodeExceptHandler;
-
-#[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")]
-pub(crate) struct NodePattern;
-
-#[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")]
-pub(crate) struct NodeTypeIgnore;
-
-#[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")]
-pub(crate) struct NodeTypeParam;
-
-#[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),
-        "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/vm/src/stdlib/ast/python.rs b/vm/src/stdlib/ast/python.rs
deleted file mode 100644
index 0ce2843a4d..0000000000
--- a/vm/src/stdlib/ast/python.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use super::PY_COMPILE_FLAG_AST_ONLY;
-
-#[pymodule]
-pub(crate) mod _ast {
-    use crate::{
-        AsObject, Context, PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyStrRef, PyTupleRef},
-        function::FuncArgs,
-    };
-    #[pyattr]
-    #[pyclass(module = "_ast", name = "AST")]
-    #[derive(Debug, PyPayload)]
-    pub(crate) struct NodeAst;
-
-    #[pyclass(flags(BASETYPE, HAS_DICT))]
-    impl NodeAst {
-        #[pyslot]
-        #[pymethod]
-        fn __init__(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            let fields = zelf.get_attr("_fields", vm)?;
-            let fields: Vec<PyStrRef> = fields.try_to_value(vm)?;
-            let n_args = args.args.len();
-            if n_args > fields.len() {
-                return Err(vm.new_type_error(format!(
-                    "{} constructor takes at most {} positional argument{}",
-                    zelf.class().name(),
-                    fields.len(),
-                    if fields.len() == 1 { "" } else { "s" },
-                )));
-            }
-            for (name, arg) in fields.iter().zip(args.args) {
-                zelf.set_attr(name, arg, vm)?;
-            }
-            for (key, value) in args.kwargs {
-                if let Some(pos) = fields.iter().position(|f| f.as_str() == key) {
-                    if pos < n_args {
-                        return Err(vm.new_type_error(format!(
-                            "{} got multiple values for argument '{}'",
-                            zelf.class().name(),
-                            key
-                        )));
-                    }
-                }
-                zelf.set_attr(vm.ctx.intern_str(key), value, vm)?;
-            }
-            Ok(())
-        }
-
-        #[pyattr(name = "_fields")]
-        fn fields(ctx: &Context) -> PyTupleRef {
-            ctx.empty_tuple.clone()
-        }
-    }
-
-    #[pyattr(name = "PyCF_ONLY_AST")]
-    use super::PY_COMPILE_FLAG_AST_ONLY;
-}
diff --git a/vm/src/stdlib/ast/statement.rs b/vm/src/stdlib/ast/statement.rs
deleted file mode 100644
index 3636c4ab6d..0000000000
--- a/vm/src/stdlib/ast/statement.rs
+++ /dev/null
@@ -1,1222 +0,0 @@
-use super::*;
-use crate::stdlib::ast::argument::{merge_class_def_args, split_class_def_args};
-// sum
-impl Node for ruff::Stmt {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::FunctionDef(cons) => cons.ast_to_object(vm, source_code),
-            Self::ClassDef(cons) => cons.ast_to_object(vm, source_code),
-            Self::Return(cons) => cons.ast_to_object(vm, source_code),
-            Self::Delete(cons) => cons.ast_to_object(vm, source_code),
-            Self::Assign(cons) => cons.ast_to_object(vm, source_code),
-            Self::TypeAlias(cons) => cons.ast_to_object(vm, source_code),
-            Self::AugAssign(cons) => cons.ast_to_object(vm, source_code),
-            Self::AnnAssign(cons) => cons.ast_to_object(vm, source_code),
-            Self::For(cons) => cons.ast_to_object(vm, source_code),
-            Self::While(cons) => cons.ast_to_object(vm, source_code),
-            Self::If(cons) => cons.ast_to_object(vm, source_code),
-            Self::With(cons) => cons.ast_to_object(vm, source_code),
-            Self::Match(cons) => cons.ast_to_object(vm, source_code),
-            Self::Raise(cons) => cons.ast_to_object(vm, source_code),
-            Self::Try(cons) => cons.ast_to_object(vm, source_code),
-            Self::Assert(cons) => cons.ast_to_object(vm, source_code),
-            Self::Import(cons) => cons.ast_to_object(vm, source_code),
-            Self::ImportFrom(cons) => cons.ast_to_object(vm, source_code),
-            Self::Global(cons) => cons.ast_to_object(vm, source_code),
-            Self::Nonlocal(cons) => cons.ast_to_object(vm, source_code),
-            Self::Expr(cons) => cons.ast_to_object(vm, source_code),
-            Self::Pass(cons) => cons.ast_to_object(vm, source_code),
-            Self::Break(cons) => cons.ast_to_object(vm, source_code),
-            Self::Continue(cons) => cons.ast_to_object(vm, source_code),
-            Self::IpyEscapeCommand(_) => {
-                unimplemented!("IPython escape command is not allowed in Python AST")
-            }
-        }
-    }
-
-    #[allow(clippy::if_same_then_else)]
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeStmtFunctionDef::static_type()) {
-            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type()) {
-            Self::FunctionDef(ruff::StmtFunctionDef::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtClassDef::static_type()) {
-            Self::ClassDef(ruff::StmtClassDef::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtReturn::static_type()) {
-            Self::Return(ruff::StmtReturn::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtDelete::static_type()) {
-            Self::Delete(ruff::StmtDelete::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtAssign::static_type()) {
-            Self::Assign(ruff::StmtAssign::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtTypeAlias::static_type()) {
-            Self::TypeAlias(ruff::StmtTypeAlias::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtAugAssign::static_type()) {
-            Self::AugAssign(ruff::StmtAugAssign::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtAnnAssign::static_type()) {
-            Self::AnnAssign(ruff::StmtAnnAssign::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtFor::static_type()) {
-            Self::For(ruff::StmtFor::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtAsyncFor::static_type()) {
-            Self::For(ruff::StmtFor::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtWhile::static_type()) {
-            Self::While(ruff::StmtWhile::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtIf::static_type()) {
-            Self::If(ruff::StmtIf::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtWith::static_type()) {
-            Self::With(ruff::StmtWith::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtAsyncWith::static_type()) {
-            Self::With(ruff::StmtWith::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtMatch::static_type()) {
-            Self::Match(ruff::StmtMatch::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtRaise::static_type()) {
-            Self::Raise(ruff::StmtRaise::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtTry::static_type()) {
-            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtTryStar::static_type()) {
-            Self::Try(ruff::StmtTry::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtAssert::static_type()) {
-            Self::Assert(ruff::StmtAssert::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtImport::static_type()) {
-            Self::Import(ruff::StmtImport::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtImportFrom::static_type()) {
-            Self::ImportFrom(ruff::StmtImportFrom::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtGlobal::static_type()) {
-            Self::Global(ruff::StmtGlobal::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtNonlocal::static_type()) {
-            Self::Nonlocal(ruff::StmtNonlocal::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeStmtExpr::static_type()) {
-            Self::Expr(ruff::StmtExpr::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtPass::static_type()) {
-            Self::Pass(ruff::StmtPass::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtBreak::static_type()) {
-            Self::Break(ruff::StmtBreak::ast_from_object(_vm, source_code, _object)?)
-        } else if _cls.is(pyast::NodeStmtContinue::static_type()) {
-            Self::Continue(ruff::StmtContinue::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of stmt, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtFunctionDef {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            parameters,
-            body,
-            decorator_list,
-            returns,
-            // type_comment,
-            type_params,
-            is_async,
-            range: _range,
-        } = self;
-
-        let cls = if !is_async {
-            pyast::NodeStmtFunctionDef::static_type().to_owned()
-        } else {
-            pyast::NodeStmtAsyncFunctionDef::static_type().to_owned()
-        };
-
-        let node = NodeAst.into_ref_with_type(vm, cls).unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", vm.ctx.new_str(name.as_str()).to_pyobject(vm), vm)
-            .unwrap();
-        dict.set_item("args", parameters.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item(
-            "decorator_list",
-            decorator_list.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        dict.set_item("returns", returns.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        // TODO: Ruff ignores type_comment during parsing
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
-        dict.set_item(
-            "type_params",
-            type_params.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        let is_async = _cls.is(pyast::NodeStmtAsyncFunctionDef::static_type());
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "FunctionDef")?,
-            )?,
-            parameters: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "args", "FunctionDef")?,
-            )?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "FunctionDef")?,
-            )?,
-            decorator_list: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "decorator_list", "FunctionDef")?,
-            )?,
-            returns: get_node_field_opt(_vm, &_object, "returns")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            // TODO: Ruff ignores type_comment during parsing
-            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
-            //     .map(|obj| Node::ast_from_object(_vm, obj))
-            //     .transpose()?,
-            type_params: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "type_params", "FunctionDef")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "FunctionDef")?,
-            is_async,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtClassDef {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            arguments,
-            body,
-            decorator_list,
-            type_params,
-            range: _range,
-        } = self;
-        let (bases, keywords) = split_class_def_args(arguments);
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtClassDef::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("bases", bases.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("keywords", keywords.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item(
-            "decorator_list",
-            decorator_list.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        dict.set_item(
-            "type_params",
-            type_params.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let bases = Node::ast_from_object(
-            _vm,
-            source_code,
-            get_node_field(_vm, &_object, "bases", "ClassDef")?,
-        )?;
-        let keywords = Node::ast_from_object(
-            _vm,
-            source_code,
-            get_node_field(_vm, &_object, "keywords", "ClassDef")?,
-        )?;
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "ClassDef")?,
-            )?,
-            arguments: merge_class_def_args(bases, keywords),
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "ClassDef")?,
-            )?,
-            decorator_list: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "decorator_list", "ClassDef")?,
-            )?,
-            type_params: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "type_params", "ClassDef")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "ClassDef")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtReturn {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtReturn::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: get_node_field_opt(_vm, &_object, "value")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "Return")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtDelete {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            targets,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtDelete::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("targets", targets.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            targets: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "targets", "Delete")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Delete")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtAssign {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            targets,
-            value,
-            // type_comment,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeStmtAssign::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("targets", targets.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        // TODO
-        dict.set_item("type_comment", vm.ctx.none(), vm).unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            targets: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "targets", "Assign")?,
-            )?,
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "Assign")?,
-            )?,
-            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
-            //     .map(|obj| Node::ast_from_object(_vm, obj))
-            //     .transpose()?,
-            range: range_from_object(vm, source_code, object, "Assign")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtTypeAlias {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            type_params,
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtTypeAlias::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("name", name.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item(
-            "type_params",
-            type_params.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "TypeAlias")?,
-            )?,
-            type_params: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "type_params", "TypeAlias")?,
-            )?,
-            value: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "value", "TypeAlias")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "TypeAlias")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtAugAssign {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            target,
-            op,
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtAugAssign::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("target", target.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("op", op.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            target: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "target", "AugAssign")?,
-            )?,
-            op: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "op", "AugAssign")?,
-            )?,
-            value: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "value", "AugAssign")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "AugAssign")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtAnnAssign {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            target,
-            annotation,
-            value,
-            simple,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtAnnAssign::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("target", target.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item(
-            "annotation",
-            annotation.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("simple", simple.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            target: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "target", "AnnAssign")?,
-            )?,
-            annotation: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "annotation", "AnnAssign")?,
-            )?,
-            value: get_node_field_opt(_vm, &_object, "value")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            simple: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "simple", "AnnAssign")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "AnnAssign")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtFor {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            is_async,
-            target,
-            iter,
-            body,
-            orelse,
-            // type_comment,
-            range: _range,
-        } = self;
-
-        let cls = if !is_async {
-            pyast::NodeStmtFor::static_type().to_owned()
-        } else {
-            pyast::NodeStmtAsyncFor::static_type().to_owned()
-        };
-
-        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("target", target.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("iter", iter.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("orelse", orelse.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        debug_assert!(
-            _cls.is(pyast::NodeStmtFor::static_type())
-                || _cls.is(pyast::NodeStmtAsyncFor::static_type())
-        );
-        let is_async = _cls.is(pyast::NodeStmtAsyncFor::static_type());
-        Ok(Self {
-            target: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "target", "For")?,
-            )?,
-            iter: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "iter", "For")?,
-            )?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "For")?,
-            )?,
-            orelse: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "orelse", "For")?,
-            )?,
-            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
-            //     .map(|obj| Node::ast_from_object(_vm, obj))
-            //     .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "For")?,
-            is_async,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtWhile {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            test,
-            body,
-            orelse,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtWhile::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("test", test.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("orelse", orelse.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            test: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "test", "While")?,
-            )?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "While")?,
-            )?,
-            orelse: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "orelse", "While")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "While")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtIf {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            test,
-            body,
-            range,
-            elif_else_clauses,
-        } = self;
-        elif_else_clause::ast_to_object(
-            ruff::ElifElseClause {
-                range,
-                test: Some(*test),
-                body,
-            },
-            elif_else_clauses.into_iter(),
-            _vm,
-            source_code,
-        )
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        elif_else_clause::ast_from_object(vm, source_code, object)
-    }
-}
-// constructor
-impl Node for ruff::StmtWith {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            is_async,
-            items,
-            body,
-            // type_comment,
-            range: _range,
-        } = self;
-
-        let cls = if !is_async {
-            pyast::NodeStmtWith::static_type().to_owned()
-        } else {
-            pyast::NodeStmtAsyncWith::static_type().to_owned()
-        };
-
-        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("items", items.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        // dict.set_item("type_comment", type_comment.ast_to_object(_vm), _vm)
-        //     .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        debug_assert!(
-            _cls.is(pyast::NodeStmtWith::static_type())
-                || _cls.is(pyast::NodeStmtAsyncWith::static_type())
-        );
-        let is_async = _cls.is(pyast::NodeStmtAsyncWith::static_type());
-        Ok(Self {
-            items: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "items", "With")?,
-            )?,
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "With")?,
-            )?,
-            // type_comment: get_node_field_opt(_vm, &_object, "type_comment")?
-            //     .map(|obj| Node::ast_from_object(_vm, obj))
-            //     .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "With")?,
-            is_async,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtMatch {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            subject,
-            cases,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtMatch::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("subject", subject.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("cases", cases.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            subject: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "subject", "Match")?,
-            )?,
-            cases: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "cases", "Match")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Match")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtRaise {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            exc,
-            cause,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtRaise::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("exc", exc.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("cause", cause.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            exc: get_node_field_opt(_vm, &_object, "exc")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            cause: get_node_field_opt(_vm, &_object, "cause")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "Raise")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtTry {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            body,
-            handlers,
-            orelse,
-            finalbody,
-            range: _range,
-            is_star,
-        } = self;
-
-        // let cls = gen::NodeStmtTry::static_type().to_owned();
-        let cls = if is_star {
-            pyast::NodeStmtTryStar::static_type()
-        } else {
-            pyast::NodeStmtTry::static_type()
-        }
-        .to_owned();
-
-        let node = NodeAst.into_ref_with_type(_vm, cls).unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("body", body.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("handlers", handlers.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("orelse", orelse.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("finalbody", finalbody.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        let is_star = _cls.is(pyast::NodeStmtTryStar::static_type());
-        let _cls = _object.class();
-        debug_assert!(
-            _cls.is(pyast::NodeStmtTry::static_type())
-                || _cls.is(pyast::NodeStmtTryStar::static_type())
-        );
-
-        Ok(Self {
-            body: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "body", "Try")?,
-            )?,
-            handlers: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "handlers", "Try")?,
-            )?,
-            orelse: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "orelse", "Try")?,
-            )?,
-            finalbody: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "finalbody", "Try")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Try")?,
-            is_star,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtAssert {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            test,
-            msg,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtAssert::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("test", test.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        dict.set_item("msg", msg.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            test: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "test", "Assert")?,
-            )?,
-            msg: get_node_field_opt(_vm, &_object, "msg")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(_vm, source_code, _object, "Assert")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtImport {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtImport::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("names", names.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            names: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "names", "Import")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Import")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtImportFrom {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            module,
-            names,
-            level,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeStmtImportFrom::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("module", module.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("names", names.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("level", vm.ctx.new_int(level).to_pyobject(vm), vm)
-            .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            module: get_node_field_opt(vm, &_object, "module")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            names: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &_object, "names", "ImportFrom")?,
-            )?,
-            level: get_node_field(vm, &_object, "level", "ImportFrom")?
-                .downcast_exact::<PyInt>(vm)
-                .unwrap()
-                .try_to_primitive::<u32>(vm)?,
-            range: range_from_object(vm, source_code, _object, "ImportFrom")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtGlobal {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtGlobal::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("names", names.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            names: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "names", "Global")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Global")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtNonlocal {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            names,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtNonlocal::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("names", names.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            names: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "names", "Nonlocal")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Nonlocal")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtExpr {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            range: _range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtExpr::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "value", "Expr")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "Expr")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtPass {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { range: _range } = self;
-        let node = NodeAst
-            .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_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            range: range_from_object(_vm, source_code, _object, "Pass")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtBreak {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { range: _range } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtBreak::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            range: range_from_object(_vm, source_code, _object, "Break")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::StmtContinue {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { range: _range } = self;
-        let node = NodeAst
-            .into_ref_with_type(_vm, pyast::NodeStmtContinue::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            range: range_from_object(_vm, source_code, _object, "Continue")?,
-        })
-    }
-}
diff --git a/vm/src/stdlib/ast/string.rs b/vm/src/stdlib/ast/string.rs
deleted file mode 100644
index 7b1e71a533..0000000000
--- a/vm/src/stdlib/ast/string.rs
+++ /dev/null
@@ -1,354 +0,0 @@
-use super::constant::{Constant, ConstantLiteral};
-use super::*;
-
-fn ruff_fstring_value_into_iter(
-    mut fstring_value: ruff::FStringValue,
-) -> impl Iterator<Item = ruff::FStringPart> + 'static {
-    let default = ruff::FStringPart::FString(ruff::FString {
-        range: Default::default(),
-        elements: Default::default(),
-        flags: ruff::FStringFlags::empty(),
-    });
-    (0..fstring_value.as_slice().len()).map(move |i| {
-        let fstring_value = &mut fstring_value;
-        let tmp = fstring_value.into_iter().nth(i).unwrap();
-        std::mem::replace(tmp, default.clone())
-    })
-}
-
-fn ruff_fstring_element_into_iter(
-    mut fstring_element: ruff::FStringElements,
-) -> impl Iterator<Item = ruff::FStringElement> + 'static {
-    let default = ruff::FStringElement::Literal(ruff::FStringLiteralElement {
-        range: Default::default(),
-        value: Default::default(),
-    });
-    (0..fstring_element.into_iter().len()).map(move |i| {
-        let fstring_element = &mut fstring_element;
-        let tmp = fstring_element.into_iter().nth(i).unwrap();
-        std::mem::replace(tmp, default.clone())
-    })
-}
-
-fn fstring_part_to_joined_str_part(fstring_part: ruff::FStringPart) -> Vec<JoinedStrPart> {
-    match fstring_part {
-        ruff::FStringPart::Literal(ruff::StringLiteral {
-            range,
-            value,
-            flags,
-        }) => {
-            vec![JoinedStrPart::Constant(Constant::new_str(
-                value,
-                flags.prefix(),
-                range,
-            ))]
-        }
-        ruff::FStringPart::FString(ruff::FString {
-            range: _,
-            elements,
-            flags: _, // TODO
-        }) => ruff_fstring_element_into_iter(elements)
-            .map(ruff_fstring_element_to_joined_str_part)
-            .collect(),
-    }
-}
-
-fn ruff_fstring_element_to_joined_str_part(element: ruff::FStringElement) -> JoinedStrPart {
-    match element {
-        ruff::FStringElement::Literal(ruff::FStringLiteralElement { range, value }) => {
-            JoinedStrPart::Constant(Constant::new_str(
-                value,
-                ruff::str_prefix::StringLiteralPrefix::Empty,
-                range,
-            ))
-        }
-        ruff::FStringElement::Expression(ruff::FStringExpressionElement {
-            range,
-            expression,
-            debug_text: _, // TODO: What is this?
-            conversion,
-            format_spec,
-        }) => JoinedStrPart::FormattedValue(FormattedValue {
-            value: expression,
-            conversion,
-            format_spec: ruff_format_spec_to_joined_str(format_spec),
-            range,
-        }),
-    }
-}
-
-fn ruff_format_spec_to_joined_str(
-    format_spec: Option<Box<ruff::FStringFormatSpec>>,
-) -> Option<Box<JoinedStr>> {
-    match format_spec {
-        None => None,
-        Some(format_spec) => {
-            let ruff::FStringFormatSpec { range, elements } = *format_spec;
-            let values: Vec<_> = ruff_fstring_element_into_iter(elements)
-                .map(ruff_fstring_element_to_joined_str_part)
-                .collect();
-            let values = values.into_boxed_slice();
-            Some(Box::new(JoinedStr { range, values }))
-        }
-    }
-}
-
-fn ruff_fstring_element_to_ruff_fstring_part(element: ruff::FStringElement) -> ruff::FStringPart {
-    match element {
-        ruff::FStringElement::Literal(value) => {
-            let ruff::FStringLiteralElement { range, value } = value;
-            ruff::FStringPart::Literal(ruff::StringLiteral {
-                range,
-                value,
-                flags: ruff::StringLiteralFlags::empty(),
-            })
-        }
-        ruff::FStringElement::Expression(value) => {
-            let ruff::FStringExpressionElement {
-                range,
-                expression,
-                debug_text,
-                conversion,
-                format_spec,
-            } = value;
-            ruff::FStringPart::FString(ruff::FString {
-                range,
-                elements: vec![ruff::FStringElement::Expression(
-                    ruff::FStringExpressionElement {
-                        range,
-                        expression,
-                        debug_text,
-                        conversion,
-                        format_spec,
-                    },
-                )]
-                .into(),
-                flags: ruff::FStringFlags::empty(),
-            })
-        }
-    }
-}
-
-fn joined_str_to_ruff_format_spec(
-    joined_str: Option<Box<JoinedStr>>,
-) -> Option<Box<ruff::FStringFormatSpec>> {
-    match joined_str {
-        None => None,
-        Some(joined_str) => {
-            let JoinedStr { range, values } = *joined_str;
-            let elements: Vec<_> = Box::into_iter(values)
-                .map(joined_str_part_to_ruff_fstring_element)
-                .collect();
-            let format_spec = ruff::FStringFormatSpec {
-                range,
-                elements: elements.into(),
-            };
-            Some(Box::new(format_spec))
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(super) struct JoinedStr {
-    pub(super) range: TextRange,
-    pub(super) values: Box<[JoinedStrPart]>,
-}
-
-impl JoinedStr {
-    pub(super) fn into_expr(self) -> ruff::Expr {
-        let Self { range, values } = self;
-        ruff::Expr::FString(ruff::ExprFString {
-            range: Default::default(),
-            value: match values.len() {
-                // ruff represents an empty fstring like this:
-                0 => ruff::FStringValue::single(ruff::FString {
-                    range,
-                    elements: vec![].into(),
-                    flags: ruff::FStringFlags::empty(),
-                }),
-                1 => ruff::FStringValue::single(
-                    Box::<[_]>::into_iter(values)
-                        .map(joined_str_part_to_ruff_fstring_element)
-                        .map(|element| ruff::FString {
-                            range,
-                            elements: vec![element].into(),
-                            flags: ruff::FStringFlags::empty(),
-                        })
-                        .next()
-                        .expect("FString has exactly one part"),
-                ),
-                _ => ruff::FStringValue::concatenated(
-                    Box::<[_]>::into_iter(values)
-                        .map(joined_str_part_to_ruff_fstring_element)
-                        .map(ruff_fstring_element_to_ruff_fstring_part)
-                        .collect(),
-                ),
-            },
-        })
-    }
-}
-
-fn joined_str_part_to_ruff_fstring_element(part: JoinedStrPart) -> ruff::FStringElement {
-    match part {
-        JoinedStrPart::FormattedValue(value) => {
-            ruff::FStringElement::Expression(ruff::FStringExpressionElement {
-                range: value.range,
-                expression: value.value.clone(),
-                debug_text: None, // TODO: What is this?
-                conversion: value.conversion,
-                format_spec: joined_str_to_ruff_format_spec(value.format_spec),
-            })
-        }
-        JoinedStrPart::Constant(value) => {
-            ruff::FStringElement::Literal(ruff::FStringLiteralElement {
-                range: value.range,
-                value: match value.value {
-                    ConstantLiteral::Str { value, .. } => value,
-                    _ => todo!(),
-                },
-            })
-        }
-    }
-}
-
-// constructor
-impl Node for JoinedStr {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self { values, range } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprJoinedStr::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item(
-            "values",
-            BoxedSlice(values).ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let values: BoxedSlice<_> = Node::ast_from_object(
-            vm,
-            source_code,
-            get_node_field(vm, &object, "values", "JoinedStr")?,
-        )?;
-        Ok(Self {
-            values: values.0,
-            range: range_from_object(vm, source_code, object, "JoinedStr")?,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub(super) enum JoinedStrPart {
-    FormattedValue(FormattedValue),
-    Constant(Constant),
-}
-
-// constructor
-impl Node for JoinedStrPart {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::FormattedValue(value) => value.ast_to_object(vm, source_code),
-            Self::Constant(value) => value.ast_to_object(vm, source_code),
-        }
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let cls = object.class();
-        if cls.is(pyast::NodeExprFormattedValue::static_type()) {
-            Ok(Self::FormattedValue(Node::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?))
-        } else {
-            Ok(Self::Constant(Node::ast_from_object(
-                vm,
-                source_code,
-                object,
-            )?))
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(super) struct FormattedValue {
-    value: Box<ruff::Expr>,
-    conversion: ruff::ConversionFlag,
-    format_spec: Option<Box<JoinedStr>>,
-    range: TextRange,
-}
-
-// constructor
-impl Node for FormattedValue {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            value,
-            conversion,
-            format_spec,
-            range,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(vm, pyast::NodeExprFormattedValue::static_type().to_owned())
-            .unwrap();
-        let dict = node.as_object().dict().unwrap();
-        dict.set_item("value", value.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item("conversion", conversion.ast_to_object(vm, source_code), vm)
-            .unwrap();
-        dict.set_item(
-            "format_spec",
-            format_spec.ast_to_object(vm, source_code),
-            vm,
-        )
-        .unwrap();
-        node_add_location(&dict, range, vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            value: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "value", "FormattedValue")?,
-            )?,
-            conversion: Node::ast_from_object(
-                vm,
-                source_code,
-                get_node_field(vm, &object, "conversion", "FormattedValue")?,
-            )?,
-            format_spec: get_node_field_opt(vm, &object, "format_spec")?
-                .map(|obj| Node::ast_from_object(vm, source_code, obj))
-                .transpose()?,
-            range: range_from_object(vm, source_code, object, "FormattedValue")?,
-        })
-    }
-}
-
-pub(super) fn fstring_to_object(
-    vm: &VirtualMachine,
-    source_code: &SourceCodeOwned,
-    expression: ruff::ExprFString,
-) -> PyObjectRef {
-    let ruff::ExprFString { range, value } = expression;
-    let values: Vec<_> = ruff_fstring_value_into_iter(value)
-        .flat_map(fstring_part_to_joined_str_part)
-        .collect();
-    let values = values.into_boxed_slice();
-    let c = JoinedStr { range, values };
-    c.ast_to_object(vm, source_code)
-}
diff --git a/vm/src/stdlib/ast/type_parameters.rs b/vm/src/stdlib/ast/type_parameters.rs
deleted file mode 100644
index 1856f2c5b8..0000000000
--- a/vm/src/stdlib/ast/type_parameters.rs
+++ /dev/null
@@ -1,197 +0,0 @@
-use super::*;
-
-impl Node for ruff::TypeParams {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        self.type_params.ast_to_object(vm, source_code)
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        _source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let type_params: Vec<ruff::TypeParam> = Node::ast_from_object(_vm, _source_code, _object)?;
-        let range = Option::zip(type_params.first(), type_params.last())
-            .map(|(first, last)| first.range().cover(last.range()))
-            .unwrap_or_default();
-        Ok(Self { type_params, range })
-    }
-
-    fn is_none(&self) -> bool {
-        self.type_params.is_empty()
-    }
-}
-// sum
-impl Node for ruff::TypeParam {
-    fn ast_to_object(self, vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        match self {
-            Self::TypeVar(cons) => cons.ast_to_object(vm, source_code),
-            Self::ParamSpec(cons) => cons.ast_to_object(vm, source_code),
-            Self::TypeVarTuple(cons) => cons.ast_to_object(vm, source_code),
-        }
-    }
-
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        let _cls = _object.class();
-        Ok(if _cls.is(pyast::NodeTypeParamTypeVar::static_type()) {
-            Self::TypeVar(ruff::TypeParamTypeVar::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeTypeParamParamSpec::static_type()) {
-            Self::ParamSpec(ruff::TypeParamParamSpec::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else if _cls.is(pyast::NodeTypeParamTypeVarTuple::static_type()) {
-            Self::TypeVarTuple(ruff::TypeParamTypeVarTuple::ast_from_object(
-                _vm,
-                source_code,
-                _object,
-            )?)
-        } else {
-            return Err(_vm.new_type_error(format!(
-                "expected some sort of type_param, but got {}",
-                _object.repr(_vm)?
-            )));
-        })
-    }
-}
-// constructor
-impl Node for ruff::TypeParamTypeVar {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            bound,
-            range: _range,
-            default: _,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        dict.set_item("bound", bound.ast_to_object(_vm, source_code), _vm)
-            .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "TypeVar")?,
-            )?,
-            bound: get_node_field_opt(_vm, &_object, "bound")?
-                .map(|obj| Node::ast_from_object(_vm, source_code, obj))
-                .transpose()?,
-            default: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "default_value", "TypeVar")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "TypeVar")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::TypeParamParamSpec {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            range: _range,
-            default,
-        } = self;
-        let node = NodeAst
-            .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_code), _vm)
-            .unwrap();
-        dict.set_item(
-            "default_value",
-            default.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "ParamSpec")?,
-            )?,
-            default: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "default_value", "ParamSpec")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "ParamSpec")?,
-        })
-    }
-}
-// constructor
-impl Node for ruff::TypeParamTypeVarTuple {
-    fn ast_to_object(self, _vm: &VirtualMachine, source_code: &SourceCodeOwned) -> PyObjectRef {
-        let Self {
-            name,
-            range: _range,
-            default,
-        } = self;
-        let node = NodeAst
-            .into_ref_with_type(
-                _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_code), _vm)
-            .unwrap();
-        dict.set_item(
-            "default_value",
-            default.ast_to_object(_vm, source_code),
-            _vm,
-        )
-        .unwrap();
-        node_add_location(&dict, _range, _vm, source_code);
-        node.into()
-    }
-    fn ast_from_object(
-        _vm: &VirtualMachine,
-        source_code: &SourceCodeOwned,
-        _object: PyObjectRef,
-    ) -> PyResult<Self> {
-        Ok(Self {
-            name: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "name", "TypeVarTuple")?,
-            )?,
-            default: Node::ast_from_object(
-                _vm,
-                source_code,
-                get_node_field(_vm, &_object, "default_value", "TypeVarTuple")?,
-            )?,
-            range: range_from_object(_vm, source_code, _object, "TypeVarTuple")?,
-        })
-    }
-}
diff --git a/vm/src/stdlib/codecs.rs b/vm/src/stdlib/codecs.rs
deleted file mode 100644
index c0a091bcf8..0000000000
--- a/vm/src/stdlib/codecs.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-pub(crate) use _codecs::make_module;
-
-#[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,
-        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: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        vm.state
-            .codec_registry
-            .lookup(encoding.try_to_str(vm)?, 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) {
-        vm.state
-            .codec_registry
-            .register_error(name.as_str().to_owned(), handler);
-    }
-
-    #[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.is_ascii() {
-            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.is_ascii() {
-            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)
-        }};
-    }
-
-    #[pyfunction]
-    fn mbcs_encode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(mbcs_encode, args, vm)
-    }
-    #[pyfunction]
-    fn mbcs_decode(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        delegate_pycodecs!(mbcs_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/vm/src/stdlib/ctypes.rs b/vm/src/stdlib/ctypes.rs
deleted file mode 100644
index 8ea4dd165e..0000000000
--- a/vm/src/stdlib/ctypes.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-// spell-checker:disable
-
-pub(crate) mod array;
-pub(crate) mod base;
-pub(crate) mod function;
-pub(crate) mod library;
-pub(crate) mod pointer;
-pub(crate) mod structure;
-pub(crate) mod union;
-
-use crate::builtins::PyModule;
-use crate::class::PyClassImpl;
-use crate::stdlib::ctypes::base::{PyCData, PyCSimple, PyCSimpleType};
-use crate::{Py, PyRef, VirtualMachine};
-
-pub fn extend_module_nodes(vm: &VirtualMachine, module: &Py<PyModule>) {
-    let ctx = &vm.ctx;
-    PyCSimpleType::make_class(ctx);
-    array::PyCArrayType::make_class(ctx);
-    extend_module!(vm, module, {
-        "_CData" => PyCData::make_class(ctx),
-        "_SimpleCData" => PyCSimple::make_class(ctx),
-        "Array" => array::PyCArray::make_class(ctx),
-        "CFuncPtr" => function::PyCFuncPtr::make_class(ctx),
-        "_Pointer" => pointer::PyCPointer::make_class(ctx),
-        "_pointer_type_cache" => ctx.new_dict(),
-        "Structure" => structure::PyCStructure::make_class(ctx),
-        "Union" => union::PyCUnion::make_class(ctx),
-    })
-}
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = _ctypes::make_module(vm);
-    extend_module_nodes(vm, &module);
-    module
-}
-
-#[pymodule]
-pub(crate) mod _ctypes {
-    use super::base::PyCSimple;
-    use crate::builtins::PyTypeRef;
-    use crate::class::StaticType;
-    use crate::function::{Either, FuncArgs, OptionalArg};
-    use crate::stdlib::ctypes::library;
-    use crate::{AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine};
-    use crossbeam_utils::atomic::AtomicCell;
-    use std::ffi::{
-        c_double, c_float, c_int, c_long, c_longlong, c_schar, c_short, c_uchar, c_uint, c_ulong,
-        c_ulonglong,
-    };
-    use std::mem;
-    use widestring::WideChar;
-
-    #[pyattr(name = "__version__")]
-    const __VERSION__: &str = "1.1.0";
-
-    // TODO: get properly
-    #[pyattr(name = "RTLD_LOCAL")]
-    const RTLD_LOCAL: i32 = 0;
-
-    // TODO: get properly
-    #[pyattr(name = "RTLD_GLOBAL")]
-    const RTLD_GLOBAL: i32 = 0;
-
-    #[cfg(target_os = "windows")]
-    #[pyattr(name = "SIZEOF_TIME_T")]
-    pub const SIZEOF_TIME_T: usize = 8;
-    #[cfg(not(target_os = "windows"))]
-    #[pyattr(name = "SIZEOF_TIME_T")]
-    pub const SIZEOF_TIME_T: usize = 4;
-
-    #[pyattr(name = "CTYPES_MAX_ARGCOUNT")]
-    pub const CTYPES_MAX_ARGCOUNT: usize = 1024;
-
-    #[pyattr]
-    pub const FUNCFLAG_STDCALL: u32 = 0x0;
-    #[pyattr]
-    pub const FUNCFLAG_CDECL: u32 = 0x1;
-    #[pyattr]
-    pub const FUNCFLAG_HRESULT: u32 = 0x2;
-    #[pyattr]
-    pub const FUNCFLAG_PYTHONAPI: u32 = 0x4;
-    #[pyattr]
-    pub const FUNCFLAG_USE_ERRNO: u32 = 0x8;
-    #[pyattr]
-    pub const FUNCFLAG_USE_LASTERROR: u32 = 0x10;
-
-    #[pyattr]
-    pub const TYPEFLAG_ISPOINTER: u32 = 0x100;
-    #[pyattr]
-    pub const TYPEFLAG_HASPOINTER: u32 = 0x200;
-
-    #[pyattr]
-    pub const DICTFLAG_FINAL: u32 = 0x1000;
-
-    #[pyattr(name = "ArgumentError", once)]
-    fn argument_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "_ctypes",
-            "ArgumentError",
-            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
-        )
-    }
-
-    #[pyattr(name = "FormatError", once)]
-    fn format_error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.new_exception_type(
-            "_ctypes",
-            "FormatError",
-            Some(vec![vm.ctx.exceptions.exception_type.to_owned()]),
-        )
-    }
-
-    pub fn get_size(ty: &str) -> usize {
-        match ty {
-            "u" => mem::size_of::<WideChar>(),
-            "c" | "b" => mem::size_of::<c_schar>(),
-            "h" => mem::size_of::<c_short>(),
-            "H" => mem::size_of::<c_short>(),
-            "i" => mem::size_of::<c_int>(),
-            "I" => mem::size_of::<c_uint>(),
-            "l" => mem::size_of::<c_long>(),
-            "q" => mem::size_of::<c_longlong>(),
-            "L" => mem::size_of::<c_ulong>(),
-            "Q" => mem::size_of::<c_ulonglong>(),
-            "f" => mem::size_of::<c_float>(),
-            "d" | "g" => mem::size_of::<c_double>(),
-            "?" | "B" => mem::size_of::<c_uchar>(),
-            "P" | "z" | "Z" => mem::size_of::<usize>(),
-            "O" => mem::size_of::<PyObjectRef>(),
-            _ => unreachable!(),
-        }
-    }
-
-    const SIMPLE_TYPE_CHARS: &str = "cbBhHiIlLdfguzZPqQ?O";
-
-    pub fn new_simple_type(
-        cls: Either<&PyObjectRef, &PyTypeRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyCSimple> {
-        let cls = match cls {
-            Either::A(obj) => obj,
-            Either::B(typ) => typ.as_object(),
-        };
-
-        if let Ok(_type_) = cls.get_attr("_type_", vm) {
-            if _type_.is_instance((&vm.ctx.types.str_type).as_ref(), vm)? {
-                let tp_str = _type_.str(vm)?.to_string();
-
-                if tp_str.len() != 1 {
-                    Err(vm.new_value_error(
-                        format!("class must define a '_type_' attribute which must be a string of length 1, str: {tp_str}"),
-                    ))
-                } else if !SIMPLE_TYPE_CHARS.contains(tp_str.as_str()) {
-                    Err(vm.new_attribute_error(format!("class must define a '_type_' attribute which must be\n a single character string containing one of {SIMPLE_TYPE_CHARS}, currently it is {tp_str}.")))
-                } else {
-                    Ok(PyCSimple {
-                        _type_: tp_str,
-                        value: AtomicCell::new(vm.ctx.none()),
-                    })
-                }
-            } else {
-                Err(vm.new_type_error("class must define a '_type_' string attribute"))
-            }
-        } else {
-            Err(vm.new_attribute_error("class must define a '_type_' attribute"))
-        }
-    }
-
-    #[pyfunction(name = "sizeof")]
-    pub fn size_of(tp: Either<PyTypeRef, PyObjectRef>, vm: &VirtualMachine) -> PyResult<usize> {
-        match tp {
-            Either::A(type_) if type_.fast_issubclass(PyCSimple::static_type()) => {
-                let zelf = new_simple_type(Either::B(&type_), vm)?;
-                Ok(get_size(zelf._type_.as_str()))
-            }
-            Either::B(obj) if obj.has_attr("size_of_instances", vm)? => {
-                let size_of_method = obj.get_attr("size_of_instances", vm)?;
-                let size_of_return = size_of_method.call(vec![], vm)?;
-                Ok(usize::try_from_object(vm, size_of_return)?)
-            }
-            _ => Err(vm.new_type_error("this type has no size")),
-        }
-    }
-
-    #[pyfunction(name = "LoadLibrary")]
-    fn load_library_windows(
-        name: String,
-        _load_flags: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<usize> {
-        // TODO: audit functions first
-        // TODO: load_flags
-        let cache = library::libcache();
-        let mut cache_write = cache.write();
-        let (id, _) = cache_write.get_or_insert_lib(&name, vm).unwrap();
-        Ok(id)
-    }
-
-    #[pyfunction(name = "dlopen")]
-    fn load_library_unix(
-        name: String,
-        _load_flags: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<usize> {
-        // TODO: audit functions first
-        // TODO: load_flags
-        let cache = library::libcache();
-        let mut cache_write = cache.write();
-        let (id, _) = cache_write.get_or_insert_lib(&name, vm).unwrap();
-        Ok(id)
-    }
-
-    #[pyfunction(name = "FreeLibrary")]
-    fn free_library(handle: usize) -> PyResult<()> {
-        let cache = library::libcache();
-        let mut cache_write = cache.write();
-        cache_write.drop_lib(handle);
-        Ok(())
-    }
-
-    #[pyfunction(name = "POINTER")]
-    pub fn pointer(_cls: PyTypeRef) {}
-
-    #[pyfunction(name = "pointer")]
-    pub fn pointer_fn(_inst: PyObjectRef) {}
-
-    #[pyfunction]
-    fn _pointer_type_cache() -> PyObjectRef {
-        todo!()
-    }
-
-    #[cfg(target_os = "windows")]
-    #[pyfunction(name = "_check_HRESULT")]
-    pub fn check_hresult(_self: PyObjectRef, hr: i32, _vm: &VirtualMachine) -> PyResult<i32> {
-        // TODO: fixme
-        if hr < 0 {
-            // vm.ctx.new_windows_error(hr)
-            todo!();
-        } else {
-            Ok(hr)
-        }
-    }
-
-    #[pyfunction]
-    fn addressof(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        if obj.is_instance(PyCSimple::static_type().as_ref(), vm)? {
-            let simple = obj.downcast_ref::<PyCSimple>().unwrap();
-            Ok(simple.value.as_ptr() as usize)
-        } else {
-            Err(vm.new_type_error("expected a ctypes instance"))
-        }
-    }
-
-    #[pyfunction]
-    fn byref(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: RUSTPYTHON
-        Err(vm.new_value_error("not implemented"))
-    }
-
-    #[pyfunction]
-    fn alignment(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: RUSTPYTHON
-        Err(vm.new_value_error("not implemented"))
-    }
-
-    #[pyfunction]
-    fn resize(_args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        // TODO: RUSTPYTHON
-        Err(vm.new_value_error("not implemented"))
-    }
-
-    #[pyfunction]
-    fn get_errno() -> i32 {
-        errno::errno().0
-    }
-
-    #[pyfunction]
-    fn set_errno(value: i32) {
-        errno::set_errno(errno::Errno(value));
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn get_last_error() -> PyResult<u32> {
-        Ok(unsafe { windows_sys::Win32::Foundation::GetLastError() })
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn set_last_error(value: u32) -> PyResult<()> {
-        unsafe { windows_sys::Win32::Foundation::SetLastError(value) };
-        Ok(())
-    }
-
-    #[pyattr]
-    fn _memmove_addr(_vm: &VirtualMachine) -> usize {
-        let f = libc::memmove;
-        f as usize
-    }
-
-    #[pyattr]
-    fn _memset_addr(_vm: &VirtualMachine) -> usize {
-        let f = libc::memset;
-        f as usize
-    }
-
-    #[pyattr]
-    fn _string_at_addr(_vm: &VirtualMachine) -> usize {
-        let f = libc::strnlen;
-        f as usize
-    }
-
-    #[pyattr]
-    fn _cast_addr(_vm: &VirtualMachine) -> usize {
-        // TODO: RUSTPYTHON
-        0
-    }
-}
diff --git a/vm/src/stdlib/ctypes/array.rs b/vm/src/stdlib/ctypes/array.rs
deleted file mode 100644
index 0880c6b63b..0000000000
--- a/vm/src/stdlib/ctypes/array.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-use crate::builtins::PyBytes;
-use crate::types::Callable;
-use crate::{Py, PyObjectRef, PyPayload};
-use crate::{
-    PyResult, VirtualMachine,
-    builtins::{PyType, PyTypeRef},
-    types::Constructor,
-};
-use crossbeam_utils::atomic::AtomicCell;
-use rustpython_common::lock::PyRwLock;
-use rustpython_vm::stdlib::ctypes::base::PyCData;
-
-#[pyclass(name = "PyCArrayType", base = "PyType", module = "_ctypes")]
-#[derive(PyPayload)]
-pub struct PyCArrayType {
-    pub(super) inner: PyCArray,
-}
-
-impl std::fmt::Debug for PyCArrayType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCArrayType")
-            .field("inner", &self.inner)
-            .finish()
-    }
-}
-
-impl Callable for PyCArrayType {
-    type Args = ();
-    fn call(zelf: &Py<Self>, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Ok(PyCArray {
-            typ: PyRwLock::new(zelf.inner.typ.read().clone()),
-            length: AtomicCell::new(zelf.inner.length.load()),
-            value: PyRwLock::new(zelf.inner.value.read().clone()),
-        }
-        .into_pyobject(vm))
-    }
-}
-
-impl Constructor for PyCArrayType {
-    type Args = PyObjectRef;
-
-    fn py_new(_cls: PyTypeRef, _args: Self::Args, _vm: &VirtualMachine) -> PyResult {
-        unreachable!()
-    }
-}
-
-#[pyclass(flags(IMMUTABLETYPE), with(Callable, Constructor))]
-impl PyCArrayType {}
-
-#[pyclass(
-    name = "Array",
-    base = "PyCData",
-    metaclass = "PyCArrayType",
-    module = "_ctypes"
-)]
-#[derive(PyPayload)]
-pub struct PyCArray {
-    pub(super) typ: PyRwLock<PyTypeRef>,
-    pub(super) length: AtomicCell<usize>,
-    pub(super) value: PyRwLock<PyObjectRef>,
-}
-
-impl std::fmt::Debug for PyCArray {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCArray")
-            .field("typ", &self.typ)
-            .field("length", &self.length)
-            .finish()
-    }
-}
-
-impl Constructor for PyCArray {
-    type Args = (PyTypeRef, usize);
-
-    fn py_new(_cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Ok(Self {
-            typ: PyRwLock::new(args.0),
-            length: AtomicCell::new(args.1),
-            value: PyRwLock::new(vm.ctx.none()),
-        }
-        .into_pyobject(vm))
-    }
-}
-
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE), with(Constructor))]
-impl PyCArray {
-    #[pygetset(name = "_type_")]
-    fn typ(&self) -> PyTypeRef {
-        self.typ.read().clone()
-    }
-
-    #[pygetset(name = "_length_")]
-    fn length(&self) -> usize {
-        self.length.load()
-    }
-
-    #[pygetset]
-    fn value(&self) -> PyObjectRef {
-        self.value.read().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set_value(&self, value: PyObjectRef) {
-        *self.value.write() = value;
-    }
-}
-
-impl PyCArray {
-    pub fn to_arg(&self, _vm: &VirtualMachine) -> PyResult<libffi::middle::Arg> {
-        let value = self.value.read();
-        let py_bytes = value.payload::<PyBytes>().unwrap();
-        let bytes = py_bytes.as_ref().to_vec();
-        Ok(libffi::middle::Arg::new(&bytes))
-    }
-}
diff --git a/vm/src/stdlib/ctypes/base.rs b/vm/src/stdlib/ctypes/base.rs
deleted file mode 100644
index 2fcac469b9..0000000000
--- a/vm/src/stdlib/ctypes/base.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-use super::array::{PyCArray, PyCArrayType};
-use crate::builtins::PyType;
-use crate::builtins::{PyBytes, PyFloat, PyInt, PyNone, PyStr, PyTypeRef};
-use crate::convert::ToPyObject;
-use crate::function::{Either, OptionalArg};
-use crate::stdlib::ctypes::_ctypes::new_simple_type;
-use crate::types::Constructor;
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine};
-use crossbeam_utils::atomic::AtomicCell;
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
-use std::fmt::Debug;
-
-pub fn ffi_type_from_str(_type_: &str) -> Option<libffi::middle::Type> {
-    match _type_ {
-        "c" => Some(libffi::middle::Type::u8()),
-        "u" => Some(libffi::middle::Type::u32()),
-        "b" => Some(libffi::middle::Type::i8()),
-        "B" => Some(libffi::middle::Type::u8()),
-        "h" => Some(libffi::middle::Type::i16()),
-        "H" => Some(libffi::middle::Type::u16()),
-        "i" => Some(libffi::middle::Type::i32()),
-        "I" => Some(libffi::middle::Type::u32()),
-        "l" => Some(libffi::middle::Type::i32()),
-        "L" => Some(libffi::middle::Type::u32()),
-        "q" => Some(libffi::middle::Type::i64()),
-        "Q" => Some(libffi::middle::Type::u64()),
-        "f" => Some(libffi::middle::Type::f32()),
-        "d" => Some(libffi::middle::Type::f64()),
-        "g" => Some(libffi::middle::Type::f64()),
-        "?" => Some(libffi::middle::Type::u8()),
-        "z" => Some(libffi::middle::Type::u64()),
-        "Z" => Some(libffi::middle::Type::u64()),
-        "P" => Some(libffi::middle::Type::u64()),
-        _ => None,
-    }
-}
-
-#[allow(dead_code)]
-fn set_primitive(_type_: &str, value: &PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    match _type_ {
-        "c" => {
-            if value
-                .clone()
-                .downcast_exact::<PyBytes>(vm)
-                .is_ok_and(|v| v.len() == 1)
-                || value
-                    .clone()
-                    .downcast_exact::<PyBytes>(vm)
-                    .is_ok_and(|v| v.len() == 1)
-                || value
-                    .clone()
-                    .downcast_exact::<PyInt>(vm)
-                    .map_or(Ok(false), |v| {
-                        let n = v.as_bigint().to_i64();
-                        if let Some(n) = n {
-                            Ok((0..=255).contains(&n))
-                        } else {
-                            Ok(false)
-                        }
-                    })?
-            {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error("one character bytes, bytearray or integer expected"))
-            }
-        }
-        "u" => {
-            if let Ok(b) = value.str(vm).map(|v| v.to_string().chars().count() == 1) {
-                if b {
-                    Ok(value.clone())
-                } else {
-                    Err(vm.new_type_error("one character unicode string expected"))
-                }
-            } else {
-                Err(vm.new_type_error(format!(
-                    "unicode string expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
-        }
-        "b" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok() {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "an integer is required (got type {})",
-                    value.class().name()
-                )))
-            }
-        }
-        "f" | "d" | "g" => {
-            if value.clone().downcast_exact::<PyFloat>(vm).is_ok() {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error(format!("must be real number, not {}", value.class().name())))
-            }
-        }
-        "?" => Ok(PyObjectRef::from(
-            vm.ctx.new_bool(value.clone().try_to_bool(vm)?),
-        )),
-        "B" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok() {
-                Ok(vm.new_pyobj(u8::try_from_object(vm, value.clone())?))
-            } else {
-                Err(vm.new_type_error(format!("int expected instead of {}", value.class().name())))
-            }
-        }
-        "z" => {
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok()
-                || value.clone().downcast_exact::<PyBytes>(vm).is_ok()
-            {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "bytes or integer address expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
-        }
-        "Z" => {
-            if value.clone().downcast_exact::<PyStr>(vm).is_ok() {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error(format!(
-                    "unicode string or integer address expected instead of {} instance",
-                    value.class().name()
-                )))
-            }
-        }
-        _ => {
-            // "P"
-            if value.clone().downcast_exact::<PyInt>(vm).is_ok()
-                || value.clone().downcast_exact::<PyNone>(vm).is_ok()
-            {
-                Ok(value.clone())
-            } else {
-                Err(vm.new_type_error("cannot be converted to pointer"))
-            }
-        }
-    }
-}
-
-pub struct RawBuffer {
-    #[allow(dead_code)]
-    pub inner: Box<[u8]>,
-    #[allow(dead_code)]
-    pub size: usize,
-}
-
-#[pyclass(name = "_CData", module = "_ctypes")]
-pub struct PyCData {
-    _objects: AtomicCell<Vec<PyObjectRef>>,
-    _buffer: PyRwLock<RawBuffer>,
-}
-
-#[pyclass]
-impl PyCData {}
-
-#[pyclass(module = "_ctypes", name = "PyCSimpleType", base = "PyType")]
-pub struct PyCSimpleType {}
-
-#[pyclass(flags(BASETYPE))]
-impl PyCSimpleType {
-    #[allow(clippy::new_ret_no_self)]
-    #[pymethod]
-    fn new(cls: PyTypeRef, _: OptionalArg, vm: &VirtualMachine) -> PyResult {
-        Ok(PyObjectRef::from(
-            new_simple_type(Either::B(&cls), vm)?
-                .into_ref_with_type(vm, cls)?
-                .clone(),
-        ))
-    }
-}
-
-#[pyclass(
-    module = "_ctypes",
-    name = "_SimpleCData",
-    base = "PyCData",
-    metaclass = "PyCSimpleType"
-)]
-#[derive(PyPayload)]
-pub struct PyCSimple {
-    pub _type_: String,
-    pub value: AtomicCell<PyObjectRef>,
-}
-
-impl Debug for PyCSimple {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCSimple")
-            .field("_type_", &self._type_)
-            .finish()
-    }
-}
-
-impl Constructor for PyCSimple {
-    type Args = (OptionalArg,);
-
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let attributes = cls.get_attributes();
-        let _type_ = attributes
-            .iter()
-            .find(|(k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
-            .unwrap()
-            .1
-            .str(vm)?
-            .to_string();
-        let value = if let Some(ref v) = args.0.into_option() {
-            set_primitive(_type_.as_str(), v, vm)?
-        } else {
-            match _type_.as_str() {
-                "c" | "u" => PyObjectRef::from(vm.ctx.new_bytes(vec![0])),
-                "b" | "B" | "h" | "H" | "i" | "I" | "l" | "q" | "L" | "Q" => {
-                    PyObjectRef::from(vm.ctx.new_int(0))
-                }
-                "f" | "d" | "g" => PyObjectRef::from(vm.ctx.new_float(0.0)),
-                "?" => PyObjectRef::from(vm.ctx.new_bool(false)),
-                _ => vm.ctx.none(), // "z" | "Z" | "P"
-            }
-        };
-        Ok(PyCSimple {
-            _type_,
-            value: AtomicCell::new(value),
-        }
-        .to_pyobject(vm))
-    }
-}
-
-#[pyclass(flags(BASETYPE), with(Constructor))]
-impl PyCSimple {
-    #[pygetset(name = "value")]
-    pub fn value(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        let zelf: &Py<Self> = instance
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("cannot get value of instance"))?;
-        Ok(unsafe { (*zelf.value.as_ptr()).clone() })
-    }
-
-    #[pygetset(name = "value", setter)]
-    fn set_value(instance: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let zelf: PyRef<Self> = instance
-            .downcast()
-            .map_err(|_| vm.new_type_error("cannot set value of instance"))?;
-        let content = set_primitive(zelf._type_.as_str(), &value, vm)?;
-        zelf.value.store(content);
-        Ok(())
-    }
-
-    #[pyclassmethod]
-    fn repeat(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        if n < 0 {
-            return Err(vm.new_value_error(format!("Array length must be >= 0, not {n}")));
-        }
-        Ok(PyCArrayType {
-            inner: PyCArray {
-                typ: PyRwLock::new(cls),
-                length: AtomicCell::new(n as usize),
-                value: PyRwLock::new(vm.ctx.none()),
-            },
-        }
-        .to_pyobject(vm))
-    }
-
-    #[pyclassmethod]
-    fn __mul__(cls: PyTypeRef, n: isize, vm: &VirtualMachine) -> PyResult {
-        PyCSimple::repeat(cls, n, vm)
-    }
-}
-
-impl PyCSimple {
-    pub fn to_arg(
-        &self,
-        ty: libffi::middle::Type,
-        vm: &VirtualMachine,
-    ) -> Option<libffi::middle::Arg> {
-        let value = unsafe { (*self.value.as_ptr()).clone() };
-        if let Ok(i) = value.try_int(vm) {
-            let i = i.as_bigint();
-            if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u8().as_raw_ptr()) {
-                return i.to_u8().map(|r: u8| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i8().as_raw_ptr()) {
-                return i.to_i8().map(|r: i8| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u16().as_raw_ptr()) {
-                return i.to_u16().map(|r: u16| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i16().as_raw_ptr()) {
-                return i.to_i16().map(|r: i16| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u32().as_raw_ptr()) {
-                return i.to_u32().map(|r: u32| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i32().as_raw_ptr()) {
-                return i.to_i32().map(|r: i32| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::u64().as_raw_ptr()) {
-                return i.to_u64().map(|r: u64| libffi::middle::Arg::new(&r));
-            } else if std::ptr::eq(ty.as_raw_ptr(), libffi::middle::Type::i64().as_raw_ptr()) {
-                return i.to_i64().map(|r: i64| libffi::middle::Arg::new(&r));
-            } else {
-                return None;
-            }
-        }
-        if let Ok(_f) = value.try_float(vm) {
-            todo!();
-        }
-        if let Ok(_b) = value.try_to_bool(vm) {
-            todo!();
-        }
-        None
-    }
-}
diff --git a/vm/src/stdlib/ctypes/function.rs b/vm/src/stdlib/ctypes/function.rs
deleted file mode 100644
index 4ecff564b8..0000000000
--- a/vm/src/stdlib/ctypes/function.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// spell-checker:disable
-
-use crate::builtins::{PyStr, PyTupleRef, PyTypeRef};
-use crate::convert::ToPyObject;
-use crate::function::FuncArgs;
-use crate::stdlib::ctypes::PyCData;
-use crate::stdlib::ctypes::array::PyCArray;
-use crate::stdlib::ctypes::base::{PyCSimple, ffi_type_from_str};
-use crate::types::{Callable, Constructor};
-use crate::{Py, PyObjectRef, PyResult, VirtualMachine};
-use crossbeam_utils::atomic::AtomicCell;
-use libffi::middle::{Arg, Cif, CodePtr, Type};
-use libloading::Symbol;
-use num_traits::ToPrimitive;
-use rustpython_common::lock::PyRwLock;
-use std::ffi::CString;
-use std::fmt::Debug;
-
-// https://github.com/python/cpython/blob/4f8bb3947cfbc20f970ff9d9531e1132a9e95396/Modules/_ctypes/callproc.c#L15
-
-#[derive(Debug)]
-pub struct Function {
-    args: Vec<Type>,
-    // TODO: no protection from use-after-free
-    pointer: CodePtr,
-    cif: Cif,
-}
-
-unsafe impl Send for Function {}
-unsafe impl Sync for Function {}
-
-type FP = unsafe extern "C" fn();
-
-impl Function {
-    pub unsafe fn load(
-        library: &libloading::Library,
-        function: &str,
-        args: &[PyObjectRef],
-        ret_type: &Option<PyTypeRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<Self> {
-        // map each arg to a PyCSimple
-        let args = args
-            .iter()
-            .map(|arg| {
-                if let Some(arg) = arg.payload_if_subclass::<PyCSimple>(vm) {
-                    let converted = ffi_type_from_str(&arg._type_);
-                    return match converted {
-                        Some(t) => Ok(t),
-                        None => Err(vm.new_type_error("Invalid type")), // TODO: add type name
-                    };
-                }
-                if let Some(arg) = arg.payload_if_subclass::<PyCArray>(vm) {
-                    let t = arg.typ.read();
-                    let ty_attributes = t.attributes.read();
-                    let ty_pystr = ty_attributes
-                        .get(vm.ctx.intern_str("_type_"))
-                        .ok_or_else(|| vm.new_type_error("Expected a ctypes simple type"))?;
-                    let ty_str = ty_pystr
-                        .downcast_ref::<PyStr>()
-                        .ok_or_else(|| vm.new_type_error("Expected a ctypes simple type"))?
-                        .to_string();
-                    let converted = ffi_type_from_str(&ty_str);
-                    match converted {
-                        Some(_t) => {
-                            // TODO: Use
-                            Ok(Type::void())
-                        }
-                        None => Err(vm.new_type_error("Invalid type")), // TODO: add type name
-                    }
-                } else {
-                    Err(vm.new_type_error("Expected a ctypes simple type"))
-                }
-            })
-            .collect::<PyResult<Vec<Type>>>()?;
-        let c_function_name = CString::new(function)
-            .map_err(|_| vm.new_value_error("Function name contains null bytes"))?;
-        let pointer: Symbol<'_, FP> = unsafe {
-            library
-                .get(c_function_name.as_bytes())
-                .map_err(|err| err.to_string())
-                .map_err(|err| vm.new_attribute_error(err))?
-        };
-        let code_ptr = CodePtr(*pointer as *mut _);
-        let return_type = match ret_type {
-            // TODO: Fix this
-            Some(_t) => {
-                return Err(vm.new_not_implemented_error("Return type not implemented"));
-            }
-            None => Type::c_int(),
-        };
-        let cif = Cif::new(args.clone(), return_type);
-        Ok(Function {
-            args,
-            cif,
-            pointer: code_ptr,
-        })
-    }
-
-    pub unsafe fn call(
-        &self,
-        args: Vec<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyObjectRef> {
-        let args = args
-            .into_iter()
-            .enumerate()
-            .map(|(count, arg)| {
-                // none type check
-                if let Some(d) = arg.payload_if_subclass::<PyCSimple>(vm) {
-                    return Ok(d.to_arg(self.args[count].clone(), vm).unwrap());
-                }
-                if let Some(d) = arg.payload_if_subclass::<PyCArray>(vm) {
-                    return Ok(d.to_arg(vm).unwrap());
-                }
-                Err(vm.new_type_error("Expected a ctypes simple type"))
-            })
-            .collect::<PyResult<Vec<Arg>>>()?;
-        // TODO: FIX return
-        let result: i32 = unsafe { self.cif.call(self.pointer, &args) };
-        Ok(vm.ctx.new_int(result).into())
-    }
-}
-
-#[pyclass(module = "_ctypes", name = "CFuncPtr", base = "PyCData")]
-#[derive(PyPayload)]
-pub struct PyCFuncPtr {
-    pub name: PyRwLock<String>,
-    pub _flags_: AtomicCell<u32>,
-    // FIXME(arihant2math): This shouldn't be an option, setting the default as the none type should work
-    //  This is a workaround for now and I'll fix it later
-    pub _restype_: PyRwLock<Option<PyTypeRef>>,
-    pub handler: PyObjectRef,
-}
-
-impl Debug for PyCFuncPtr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PyCFuncPtr")
-            .field("name", &self.name)
-            .finish()
-    }
-}
-
-impl Constructor for PyCFuncPtr {
-    type Args = (PyTupleRef, FuncArgs);
-
-    fn py_new(_cls: PyTypeRef, (tuple, _args): Self::Args, vm: &VirtualMachine) -> PyResult {
-        let name = tuple
-            .first()
-            .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
-            .downcast_ref::<PyStr>()
-            .ok_or(vm.new_type_error("Expected a string"))?
-            .to_string();
-        let handler = tuple
-            .into_iter()
-            .nth(1)
-            .ok_or(vm.new_type_error("Expected a tuple with at least 2 elements"))?
-            .clone();
-        Ok(Self {
-            _flags_: AtomicCell::new(0),
-            name: PyRwLock::new(name),
-            _restype_: PyRwLock::new(None),
-            handler,
-        }
-        .to_pyobject(vm))
-    }
-}
-
-impl Callable for PyCFuncPtr {
-    type Args = FuncArgs;
-    fn call(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        unsafe {
-            let handle = zelf.handler.get_attr("_handle", vm)?;
-            let handle = handle.try_int(vm)?.as_bigint().clone();
-            let library_cache = crate::stdlib::ctypes::library::libcache().read();
-            let library = library_cache
-                .get_lib(
-                    handle
-                        .to_usize()
-                        .ok_or(vm.new_value_error("Invalid handle"))?,
-                )
-                .ok_or_else(|| vm.new_value_error("Library not found"))?;
-            let inner_lib = library.lib.lock();
-            let name = zelf.name.read();
-            let res_type = zelf._restype_.read();
-            let func = Function::load(
-                inner_lib
-                    .as_ref()
-                    .ok_or_else(|| vm.new_value_error("Library not found"))?,
-                &name,
-                &args.args,
-                &res_type,
-                vm,
-            )?;
-            func.call(args.args, vm)
-        }
-    }
-}
-
-#[pyclass(flags(BASETYPE), with(Callable, Constructor))]
-impl PyCFuncPtr {
-    #[pygetset]
-    fn __name__(&self) -> String {
-        self.name.read().clone()
-    }
-
-    #[pygetset(setter)]
-    fn set___name__(&self, name: String) {
-        *self.name.write() = name;
-    }
-
-    #[pygetset(name = "_restype_")]
-    fn restype(&self) -> Option<PyTypeRef> {
-        self._restype_.read().as_ref().cloned()
-    }
-
-    #[pygetset(name = "_restype_", setter)]
-    fn set_restype(&self, restype: PyTypeRef) {
-        *self._restype_.write() = Some(restype);
-    }
-}
diff --git a/vm/src/stdlib/ctypes/library.rs b/vm/src/stdlib/ctypes/library.rs
deleted file mode 100644
index e918470b6c..0000000000
--- a/vm/src/stdlib/ctypes/library.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-use crate::VirtualMachine;
-use libloading::Library;
-use rustpython_common::lock::{PyMutex, PyRwLock};
-use std::collections::HashMap;
-use std::ffi::c_void;
-use std::fmt;
-use std::ptr::null;
-
-pub struct SharedLibrary {
-    pub(crate) lib: PyMutex<Option<Library>>,
-}
-
-impl fmt::Debug for SharedLibrary {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "SharedLibrary")
-    }
-}
-
-impl SharedLibrary {
-    pub fn new(name: &str) -> Result<SharedLibrary, libloading::Error> {
-        Ok(SharedLibrary {
-            lib: PyMutex::new(unsafe { Some(Library::new(name)?) }),
-        })
-    }
-
-    pub fn get_pointer(&self) -> usize {
-        let lib_lock = self.lib.lock();
-        if let Some(l) = &*lib_lock {
-            l as *const Library as usize
-        } else {
-            null::<c_void>() as usize
-        }
-    }
-
-    pub fn is_closed(&self) -> bool {
-        let lib_lock = self.lib.lock();
-        lib_lock.is_none()
-    }
-
-    pub fn close(&self) {
-        *self.lib.lock() = None;
-    }
-}
-
-impl Drop for SharedLibrary {
-    fn drop(&mut self) {
-        self.close();
-    }
-}
-
-pub struct ExternalLibs {
-    libraries: HashMap<usize, SharedLibrary>,
-}
-
-impl ExternalLibs {
-    pub fn new() -> Self {
-        Self {
-            libraries: HashMap::new(),
-        }
-    }
-
-    #[allow(dead_code)]
-    pub fn get_lib(&self, key: usize) -> Option<&SharedLibrary> {
-        self.libraries.get(&key)
-    }
-
-    pub fn get_or_insert_lib(
-        &mut self,
-        library_path: &str,
-        _vm: &VirtualMachine,
-    ) -> Result<(usize, &SharedLibrary), libloading::Error> {
-        let new_lib = SharedLibrary::new(library_path)?;
-        let key = new_lib.get_pointer();
-
-        match self.libraries.get(&key) {
-            Some(l) => {
-                if l.is_closed() {
-                    self.libraries.insert(key, new_lib);
-                }
-            }
-            _ => {
-                self.libraries.insert(key, new_lib);
-            }
-        };
-
-        Ok((key, self.libraries.get(&key).unwrap()))
-    }
-
-    pub fn drop_lib(&mut self, key: usize) {
-        self.libraries.remove(&key);
-    }
-}
-
-rustpython_common::static_cell! {
-    static LIBCACHE: PyRwLock<ExternalLibs>;
-}
-
-pub fn libcache() -> &'static PyRwLock<ExternalLibs> {
-    LIBCACHE.get_or_init(|| PyRwLock::new(ExternalLibs::new()))
-}
diff --git a/vm/src/stdlib/ctypes/pointer.rs b/vm/src/stdlib/ctypes/pointer.rs
deleted file mode 100644
index d1360f9862..0000000000
--- a/vm/src/stdlib/ctypes/pointer.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[pyclass(name = "Pointer", module = "_ctypes")]
-pub struct PyCPointer {}
-
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE))]
-impl PyCPointer {}
diff --git a/vm/src/stdlib/ctypes/structure.rs b/vm/src/stdlib/ctypes/structure.rs
deleted file mode 100644
index d675c3263d..0000000000
--- a/vm/src/stdlib/ctypes/structure.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use super::base::PyCData;
-use crate::builtins::{PyList, PyStr, PyTuple, PyTypeRef};
-use crate::function::FuncArgs;
-use crate::types::GetAttr;
-use crate::{AsObject, Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-use rustpython_common::lock::PyRwLock;
-use rustpython_vm::types::Constructor;
-use std::collections::HashMap;
-use std::fmt::Debug;
-
-#[pyclass(module = "_ctypes", name = "Structure", base = "PyCData")]
-#[derive(PyPayload, Debug)]
-pub struct PyCStructure {
-    #[allow(dead_code)]
-    field_data: PyRwLock<HashMap<String, PyObjectRef>>,
-    data: PyRwLock<HashMap<String, PyObjectRef>>,
-}
-
-impl Constructor for PyCStructure {
-    type Args = FuncArgs;
-
-    fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        let fields_attr = cls
-            .get_class_attr(vm.ctx.interned_str("_fields_").unwrap())
-            .ok_or_else(|| vm.new_attribute_error("Structure must have a _fields_ attribute"))?;
-        // downcast into list
-        let fields = fields_attr
-            .downcast_ref::<PyList>()
-            .ok_or_else(|| vm.new_type_error("Structure _fields_ attribute must be a list"))?;
-        let fields = fields.borrow_vec();
-        let mut field_data = HashMap::new();
-        for field in fields.iter() {
-            let field = field
-                .downcast_ref::<PyTuple>()
-                .ok_or_else(|| vm.new_type_error("Field must be a tuple"))?;
-            let name = field
-                .first()
-                .unwrap()
-                .downcast_ref::<PyStr>()
-                .ok_or_else(|| vm.new_type_error("Field name must be a string"))?;
-            let typ = field.get(1).unwrap().clone();
-            field_data.insert(name.as_str().to_string(), typ);
-        }
-        todo!("Implement PyCStructure::py_new")
-    }
-}
-
-impl GetAttr for PyCStructure {
-    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        let name = name.to_string();
-        let data = zelf.data.read();
-        match data.get(&name) {
-            Some(value) => Ok(value.clone()),
-            None => Err(vm.new_attribute_error(format!("No attribute named {name}"))),
-        }
-    }
-}
-
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE))]
-impl PyCStructure {}
diff --git a/vm/src/stdlib/ctypes/union.rs b/vm/src/stdlib/ctypes/union.rs
deleted file mode 100644
index 2d76dbc9ca..0000000000
--- a/vm/src/stdlib/ctypes/union.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use super::base::PyCData;
-
-// TODO: metaclass = "UnionType"
-#[pyclass(module = "_ctypes", name = "Union", base = "PyCData")]
-pub struct PyCUnion {}
-
-#[pyclass(flags(BASETYPE, IMMUTABLETYPE))]
-impl PyCUnion {}
diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs
deleted file mode 100644
index 4498b0eebf..0000000000
--- a/vm/src/stdlib/marshal.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-// spell-checker:ignore pyfrozen pycomplex
-pub(crate) use decl::make_module;
-
-#[pymodule(name = "marshal")]
-mod decl {
-    use crate::builtins::code::{CodeObject, Literal, PyObjBag};
-    use crate::class::StaticType;
-    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,
-        protocol::PyBuffer,
-    };
-    use malachite_bigint::BigInt;
-    use num_complex::Complex64;
-    use num_traits::Zero;
-    use rustpython_compiler_core::marshal;
-
-    #[pyattr(name = "version")]
-    use marshal::FORMAT_VERSION;
-
-    pub struct DumpError;
-
-    impl marshal::Dumpable for PyObjectRef {
-        type Error = DumpError;
-        type Constant = Literal;
-
-        fn with_dump<R>(
-            &self,
-            f: impl FnOnce(marshal::DumpableValue<'_, Self>) -> R,
-        ) -> Result<R, Self::Error> {
-            use marshal::DumpableValue::*;
-            if self.is(PyStopIteration::static_type()) {
-                return Ok(f(StopIter));
-            }
-            let ret = match_class!(match self {
-                PyNone => f(None),
-                PyEllipsis => f(Ellipsis),
-                ref pyint @ PyInt => {
-                    if self.class().is(PyBool::static_type()) {
-                        f(Boolean(!pyint.as_bigint().is_zero()))
-                    } else {
-                        f(Integer(pyint.as_bigint()))
-                    }
-                }
-                ref pyfloat @ PyFloat => {
-                    f(Float(pyfloat.to_f64()))
-                }
-                ref pycomplex @ PyComplex => {
-                    f(Complex(pycomplex.to_complex64()))
-                }
-                ref pystr @ PyStr => {
-                    f(Str(pystr.as_wtf8()))
-                }
-                ref pylist @ PyList => {
-                    f(List(&pylist.borrow_vec()))
-                }
-                ref pyset @ PySet => {
-                    let elements = pyset.elements();
-                    f(Set(&elements))
-                }
-                ref pyfrozen @ PyFrozenSet => {
-                    let elements = pyfrozen.elements();
-                    f(Frozenset(&elements))
-                }
-                ref pytuple @ PyTuple => {
-                    f(Tuple(pytuple.as_slice()))
-                }
-                ref pydict @ PyDict => {
-                    let entries = pydict.into_iter().collect::<Vec<_>>();
-                    f(Dict(&entries))
-                }
-                ref bytes @ PyBytes => {
-                    f(Bytes(bytes.as_bytes()))
-                }
-                ref bytes @ PyByteArray => {
-                    f(Bytes(&bytes.borrow_buf()))
-                }
-                ref co @ PyCode => {
-                    f(Code(co))
-                }
-                _ => return Err(DumpError),
-            });
-            Ok(ret)
-        }
-    }
-
-    #[pyfunction]
-    fn dumps(
-        value: PyObjectRef,
-        _version: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyBytes> {
-        use marshal::Dumpable;
-        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",
-                )
-            })?;
-        Ok(PyBytes::from(buf))
-    }
-
-    #[pyfunction]
-    fn dump(
-        value: PyObjectRef,
-        f: PyObjectRef,
-        version: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let dumped = dumps(value, version, vm)?;
-        vm.call_method(&f, "write", (dumped,))?;
-        Ok(())
-    }
-
-    #[derive(Copy, Clone)]
-    struct PyMarshalBag<'a>(&'a VirtualMachine);
-
-    impl<'a> marshal::MarshalBag for PyMarshalBag<'a> {
-        type Value = PyObjectRef;
-        type ConstantBag = PyObjBag<'a>;
-
-        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()
-        }
-
-        fn make_float(&self, value: f64) -> Self::Value {
-            self.0.ctx.new_float(value).into()
-        }
-
-        fn make_complex(&self, value: 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()
-        }
-
-        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::new_ref(&vm.ctx);
-            for elem in it {
-                set.add(elem, vm).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))
-        }
-
-        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();
-            for (k, v) in it {
-                dict.set_item(&*k, v, vm).unwrap()
-            }
-            Ok(dict.into())
-        }
-
-        fn constant_bag(self) -> Self::ConstantBag {
-            PyObjBag(&self.0.ctx)
-        }
-    }
-
-    #[pyfunction]
-    fn loads(pybuffer: PyBuffer, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
-        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")
-            }
-            marshal::MarshalError::InvalidUtf8 => {
-                vm.new_value_error("invalid utf8 in marshalled string")
-            }
-            marshal::MarshalError::InvalidLocation => {
-                vm.new_value_error("invalid location in marshalled object")
-            }
-            marshal::MarshalError::BadType => {
-                vm.new_value_error("bad marshal data (unknown type code)")
-            }
-        })
-    }
-
-    #[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)
-    }
-}
diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs
deleted file mode 100644
index c2f17fd00b..0000000000
--- a/vm/src/stdlib/mod.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-#[cfg(feature = "ast")]
-pub(crate) mod ast;
-pub mod atexit;
-pub mod builtins;
-mod codecs;
-mod collections;
-pub mod errno;
-mod functools;
-mod imp;
-pub mod io;
-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 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"))]
-#[macro_use]
-pub mod os;
-#[cfg(windows)]
-pub mod nt;
-#[cfg(unix)]
-pub mod posix;
-#[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
-#[cfg(not(any(unix, windows)))]
-#[path = "posix_compat.rs"]
-pub mod posix;
-
-#[cfg(all(
-    any(target_os = "linux", target_os = "macos", target_os = "windows"),
-    not(any(target_env = "musl", target_env = "sgx"))
-))]
-mod ctypes;
-#[cfg(windows)]
-pub(crate) mod msvcrt;
-#[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
-mod pwd;
-pub(crate) mod signal;
-pub mod sys;
-#[cfg(windows)]
-mod winapi;
-#[cfg(windows)]
-mod winreg;
-
-use crate::{PyRef, VirtualMachine, builtins::PyModule};
-use std::{borrow::Cow, collections::HashMap};
-
-pub type StdlibInitFunc = Box<py_dyn_fn!(dyn Fn(&VirtualMachine) -> PyRef<PyModule>)>;
-pub type StdlibMap = HashMap<Cow<'static, str>, StdlibInitFunc, ahash::RandomState>;
-
-pub fn get_module_inits() -> StdlibMap {
-    macro_rules! modules {
-        {
-            $(
-                #[cfg($cfg:meta)]
-                { $( $key:expr => $val:expr),* $(,)? }
-            )*
-        } => {{
-            let modules = [
-                $(
-                    $(#[cfg($cfg)] (Cow::<'static, str>::from($key), Box::new($val) as StdlibInitFunc),)*
-                )*
-            ];
-            modules.into_iter().collect()
-        }};
-    }
-    modules! {
-        #[cfg(all())]
-        {
-            "atexit" => atexit::make_module,
-            "_codecs" => codecs::make_module,
-            "_collections" => collections::make_module,
-            "errno" => errno::make_module,
-            "_functools" => functools::make_module,
-            "itertools" => itertools::make_module,
-            "_io" => io::make_module,
-            "marshal" => marshal::make_module,
-            "_operator" => operator::make_module,
-            "_signal" => signal::make_module,
-            "_sre" => sre::make_module,
-            "_stat" => stat::make_module,
-            "_string" => string::make_module,
-            "time" => time::make_module,
-            "_typing" => typing::make_module,
-            "_weakref" => weakref::make_module,
-            "_imp" => imp::make_module,
-            "_warnings" => warnings::make_module,
-            sys::sysconfigdata_name() => sysconfigdata::make_module,
-        }
-        // parser related modules:
-        #[cfg(feature = "ast")]
-        {
-            "_ast" => ast::make_module,
-        }
-        // compiler related modules:
-        #[cfg(feature = "compiler")]
-        {
-            "symtable" => symtable::make_module,
-        }
-        #[cfg(any(unix, target_os = "wasi"))]
-        {
-            "posix" => posix::make_module,
-            // "fcntl" => fcntl::make_module,
-        }
-        #[cfg(feature = "threading")]
-        {
-            "_thread" => thread::make_module,
-        }
-        // Unix-only
-        #[cfg(all(unix, not(any(target_os = "android", target_os = "redox"))))]
-        {
-            "pwd" => pwd::make_module,
-        }
-        // Windows-only
-        #[cfg(windows)]
-        {
-            "nt" => nt::make_module,
-            "msvcrt" => msvcrt::make_module,
-            "_winapi" => winapi::make_module,
-            "winreg" => winreg::make_module,
-        }
-        #[cfg(all(
-            any(target_os = "linux", target_os = "macos", target_os = "windows"),
-            not(any(target_env = "musl", target_env = "sgx"))
-        ))]
-        {
-            "_ctypes" => ctypes::make_module,
-        }
-    }
-}
diff --git a/vm/src/stdlib/msvcrt.rs b/vm/src/stdlib/msvcrt.rs
deleted file mode 100644
index 393ddd80fd..0000000000
--- a/vm/src/stdlib/msvcrt.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-// spell-checker:disable
-
-pub use msvcrt::*;
-
-#[pymodule]
-mod msvcrt {
-    use crate::{
-        PyRef, PyResult, VirtualMachine,
-        builtins::{PyBytes, PyStrRef},
-        common::suppress_iph,
-        stdlib::os::errno_err,
-    };
-    use itertools::Itertools;
-    use windows_sys::Win32::{
-        Foundation::{HANDLE, INVALID_HANDLE_VALUE},
-        System::Diagnostics::Debug,
-    };
-
-    #[pyattr]
-    use windows_sys::Win32::System::Diagnostics::Debug::{
-        SEM_FAILCRITICALERRORS, SEM_NOALIGNMENTFAULTEXCEPT, SEM_NOGPFAULTERRORBOX,
-        SEM_NOOPENFILEERRORBOX,
-    };
-
-    pub fn setmode_binary(fd: i32) {
-        unsafe { suppress_iph!(_setmode(fd, libc::O_BINARY)) };
-    }
-
-    unsafe extern "C" {
-        fn _getch() -> i32;
-        fn _getwch() -> u32;
-        fn _getche() -> i32;
-        fn _getwche() -> u32;
-        fn _putch(c: u32) -> i32;
-        fn _putwch(c: u16) -> u32;
-    }
-
-    #[pyfunction]
-    fn getch() -> Vec<u8> {
-        let c = unsafe { _getch() };
-        vec![c as u8]
-    }
-    #[pyfunction]
-    fn getwch() -> String {
-        let c = unsafe { _getwch() };
-        std::char::from_u32(c).unwrap().to_string()
-    }
-    #[pyfunction]
-    fn getche() -> Vec<u8> {
-        let c = unsafe { _getche() };
-        vec![c as u8]
-    }
-    #[pyfunction]
-    fn getwche() -> String {
-        let c = unsafe { _getwche() };
-        std::char::from_u32(c).unwrap().to_string()
-    }
-    #[pyfunction]
-    fn putch(b: PyRef<PyBytes>, vm: &VirtualMachine) -> PyResult<()> {
-        let &c =
-            b.as_bytes().iter().exactly_one().map_err(|_| {
-                vm.new_type_error("putch() argument must be a byte string of length 1")
-            })?;
-        unsafe { suppress_iph!(_putch(c.into())) };
-        Ok(())
-    }
-    #[pyfunction]
-    fn putwch(s: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        let c = s
-            .as_str()
-            .chars()
-            .exactly_one()
-            .map_err(|_| vm.new_type_error("putch() argument must be a string of length 1"))?;
-        unsafe { suppress_iph!(_putwch(c as u16)) };
-        Ok(())
-    }
-
-    unsafe extern "C" {
-        fn _setmode(fd: i32, flags: i32) -> i32;
-    }
-
-    #[pyfunction]
-    fn setmode(fd: i32, flags: i32, vm: &VirtualMachine) -> PyResult<i32> {
-        let flags = unsafe { suppress_iph!(_setmode(fd, flags)) };
-        if flags == -1 {
-            Err(errno_err(vm))
-        } else {
-            Ok(flags)
-        }
-    }
-
-    unsafe extern "C" {
-        fn _open_osfhandle(osfhandle: isize, flags: i32) -> i32;
-        fn _get_osfhandle(fd: i32) -> libc::intptr_t;
-    }
-
-    #[pyfunction]
-    fn open_osfhandle(handle: isize, flags: i32, vm: &VirtualMachine) -> PyResult<i32> {
-        let ret = unsafe { suppress_iph!(_open_osfhandle(handle, flags)) };
-        if ret == -1 {
-            Err(errno_err(vm))
-        } else {
-            Ok(ret)
-        }
-    }
-
-    #[pyfunction]
-    fn get_osfhandle(fd: i32, vm: &VirtualMachine) -> PyResult<isize> {
-        let ret = unsafe { suppress_iph!(_get_osfhandle(fd)) };
-        if ret as HANDLE == INVALID_HANDLE_VALUE {
-            Err(errno_err(vm))
-        } else {
-            Ok(ret)
-        }
-    }
-
-    #[allow(non_snake_case)]
-    #[pyfunction]
-    fn SetErrorMode(mode: Debug::THREAD_ERROR_MODE, _: &VirtualMachine) -> u32 {
-        unsafe { suppress_iph!(Debug::SetErrorMode(mode)) }
-    }
-}
diff --git a/vm/src/stdlib/nt.rs b/vm/src/stdlib/nt.rs
deleted file mode 100644
index b180744fe0..0000000000
--- a/vm/src/stdlib/nt.rs
+++ /dev/null
@@ -1,476 +0,0 @@
-// spell-checker:disable
-
-use crate::{PyRef, VirtualMachine, builtins::PyModule};
-
-pub use module::raw_set_handle_inheritable;
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = module::make_module(vm);
-    super::os::extend_module(vm, &module);
-    module
-}
-
-#[pymodule(name = "nt", with(super::os::_os))]
-pub(crate) mod module {
-    use crate::{
-        PyResult, TryFromObject, VirtualMachine,
-        builtins::{PyDictRef, PyListRef, PyStrRef, PyTupleRef},
-        common::{crt_fd::Fd, os::last_os_error, suppress_iph},
-        convert::ToPyException,
-        function::{Either, OptionalArg},
-        ospath::OsPath,
-        stdlib::os::{_os, DirFd, FollowSymlinks, SupportFunc, TargetIsDirectory, errno_err},
-    };
-    use libc::intptr_t;
-    use std::{
-        env, fs, io,
-        mem::MaybeUninit,
-        os::windows::ffi::{OsStrExt, OsStringExt},
-    };
-    use windows_sys::Win32::{
-        Foundation::{self, INVALID_HANDLE_VALUE},
-        Storage::FileSystem,
-        System::{Console, Threading},
-    };
-
-    #[pyattr]
-    use libc::{O_BINARY, O_TEMPORARY};
-
-    #[pyattr]
-    use windows_sys::Win32::System::LibraryLoader::{
-        LOAD_LIBRARY_SEARCH_APPLICATION_DIR as _LOAD_LIBRARY_SEARCH_APPLICATION_DIR,
-        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS as _LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
-        LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR as _LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR,
-        LOAD_LIBRARY_SEARCH_SYSTEM32 as _LOAD_LIBRARY_SEARCH_SYSTEM32,
-        LOAD_LIBRARY_SEARCH_USER_DIRS as _LOAD_LIBRARY_SEARCH_USER_DIRS,
-    };
-
-    #[pyfunction]
-    pub(super) fn access(path: OsPath, mode: u8, vm: &VirtualMachine) -> PyResult<bool> {
-        let attr = unsafe { FileSystem::GetFileAttributesW(path.to_wide_cstring(vm)?.as_ptr()) };
-        Ok(attr != FileSystem::INVALID_FILE_ATTRIBUTES
-            && (mode & 2 == 0
-                || attr & FileSystem::FILE_ATTRIBUTE_READONLY == 0
-                || attr & FileSystem::FILE_ATTRIBUTE_DIRECTORY != 0))
-    }
-
-    #[pyfunction]
-    pub(super) fn _supports_virtual_terminal() -> PyResult<bool> {
-        // TODO: implement this
-        Ok(true)
-    }
-
-    #[derive(FromArgs)]
-    pub(super) struct SymlinkArgs {
-        src: OsPath,
-        dst: OsPath,
-        #[pyarg(flatten)]
-        target_is_directory: TargetIsDirectory,
-        #[pyarg(flatten)]
-        _dir_fd: DirFd<{ _os::SYMLINK_DIR_FD as usize }>,
-    }
-
-    #[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)
-        };
-        res.map_err(|err| err.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn set_inheritable(fd: i32, inheritable: bool, vm: &VirtualMachine) -> PyResult<()> {
-        let handle = Fd(fd).to_raw_handle().map_err(|e| e.to_pyexception(vm))?;
-        set_handle_inheritable(handle as _, inheritable, vm)
-    }
-
-    #[pyattr]
-    fn environ(vm: &VirtualMachine) -> PyDictRef {
-        let environ = vm.ctx.new_dict();
-
-        for (key, value) in env::vars() {
-            environ.set_item(&key, vm.new_pyobj(value), vm).unwrap();
-        }
-        environ
-    }
-
-    #[pyfunction]
-    fn chmod(
-        path: OsPath,
-        dir_fd: DirFd<0>,
-        mode: u32,
-        follow_symlinks: FollowSymlinks,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        const S_IWRITE: u32 = 128;
-        let [] = dir_fd.0;
-        let metadata = if follow_symlinks.0 {
-            fs::metadata(&path)
-        } else {
-            fs::symlink_metadata(&path)
-        };
-        let meta = metadata.map_err(|err| err.to_pyexception(vm))?;
-        let mut permissions = meta.permissions();
-        permissions.set_readonly(mode & S_IWRITE == 0);
-        fs::set_permissions(&path, permissions).map_err(|err| err.to_pyexception(vm))
-    }
-
-    // cwait is available on MSVC only (according to CPython)
-    #[cfg(target_env = "msvc")]
-    unsafe extern "C" {
-        fn _cwait(termstat: *mut i32, procHandle: intptr_t, action: i32) -> intptr_t;
-    }
-
-    #[cfg(target_env = "msvc")]
-    #[pyfunction]
-    fn waitpid(pid: intptr_t, opt: i32, vm: &VirtualMachine) -> PyResult<(intptr_t, i32)> {
-        let mut status = 0;
-        let pid = unsafe { suppress_iph!(_cwait(&mut status, pid, opt)) };
-        if pid == -1 {
-            Err(errno_err(vm))
-        } else {
-            Ok((pid, status << 8))
-        }
-    }
-
-    #[cfg(target_env = "msvc")]
-    #[pyfunction]
-    fn wait(vm: &VirtualMachine) -> PyResult<(intptr_t, i32)> {
-        waitpid(-1, 0, vm)
-    }
-
-    #[pyfunction]
-    fn kill(pid: i32, sig: isize, vm: &VirtualMachine) -> PyResult<()> {
-        let sig = sig as u32;
-        let pid = pid as u32;
-
-        if sig == Console::CTRL_C_EVENT || sig == Console::CTRL_BREAK_EVENT {
-            let ret = unsafe { Console::GenerateConsoleCtrlEvent(sig, pid) };
-            let res = if ret == 0 { Err(errno_err(vm)) } else { Ok(()) };
-            return res;
-        }
-
-        let h = unsafe { Threading::OpenProcess(Threading::PROCESS_ALL_ACCESS, 0, pid) };
-        if h.is_null() {
-            return Err(errno_err(vm));
-        }
-        let ret = unsafe { Threading::TerminateProcess(h, sig) };
-        let res = if ret == 0 { Err(errno_err(vm)) } else { Ok(()) };
-        unsafe { Foundation::CloseHandle(h) };
-        res
-    }
-
-    #[pyfunction]
-    fn get_terminal_size(
-        fd: OptionalArg<i32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<_os::PyTerminalSize> {
-        let (columns, lines) = {
-            let stdhandle = match fd {
-                OptionalArg::Present(0) => Console::STD_INPUT_HANDLE,
-                OptionalArg::Present(1) | OptionalArg::Missing => Console::STD_OUTPUT_HANDLE,
-                OptionalArg::Present(2) => Console::STD_ERROR_HANDLE,
-                _ => return Err(vm.new_value_error("bad file descriptor")),
-            };
-            let h = unsafe { Console::GetStdHandle(stdhandle) };
-            if h.is_null() {
-                return Err(vm.new_os_error("handle cannot be retrieved".to_owned()));
-            }
-            if h == INVALID_HANDLE_VALUE {
-                return Err(errno_err(vm));
-            }
-            let mut csbi = MaybeUninit::uninit();
-            let ret = unsafe { Console::GetConsoleScreenBufferInfo(h, csbi.as_mut_ptr()) };
-            let csbi = unsafe { csbi.assume_init() };
-            if ret == 0 {
-                return Err(errno_err(vm));
-            }
-            let w = csbi.srWindow;
-            (
-                (w.Right - w.Left + 1) as usize,
-                (w.Bottom - w.Top + 1) as usize,
-            )
-        };
-        Ok(_os::PyTerminalSize { columns, lines })
-    }
-
-    #[cfg(target_env = "msvc")]
-    unsafe extern "C" {
-        fn _wexecv(cmdname: *const u16, argv: *const *const u16) -> intptr_t;
-    }
-
-    #[cfg(target_env = "msvc")]
-    #[pyfunction]
-    fn execv(
-        path: PyStrRef,
-        argv: Either<PyListRef, PyTupleRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        use std::iter::once;
-
-        let make_widestring =
-            |s: &str| widestring::WideCString::from_os_str(s).map_err(|err| err.to_pyexception(vm));
-
-        let path = make_widestring(path.as_str())?;
-
-        let argv = vm.extract_elements_with(argv.as_ref(), |obj| {
-            let arg = PyStrRef::try_from_object(vm, obj)?;
-            make_widestring(arg.as_str())
-        })?;
-
-        let first = argv
-            .first()
-            .ok_or_else(|| vm.new_value_error("execv() arg 2 must not be empty"))?;
-
-        if first.is_empty() {
-            return Err(vm.new_value_error("execv() arg 2 first element cannot be empty"));
-        }
-
-        let argv_execv: Vec<*const u16> = argv
-            .iter()
-            .map(|v| v.as_ptr())
-            .chain(once(std::ptr::null()))
-            .collect();
-
-        if (unsafe { suppress_iph!(_wexecv(path.as_ptr(), argv_execv.as_ptr())) } == -1) {
-            Err(errno_err(vm))
-        } else {
-            Ok(())
-        }
-    }
-
-    #[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))
-    }
-
-    #[pyfunction]
-    fn _getfullpathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
-        let wpath = path.to_wide_cstring(vm)?;
-        let mut buffer = vec![0u16; Foundation::MAX_PATH as usize];
-        let ret = unsafe {
-            FileSystem::GetFullPathNameW(
-                wpath.as_ptr(),
-                buffer.len() as _,
-                buffer.as_mut_ptr(),
-                std::ptr::null_mut(),
-            )
-        };
-        if ret == 0 {
-            return Err(errno_err(vm));
-        }
-        if ret as usize > buffer.len() {
-            buffer.resize(ret as usize, 0);
-            let ret = unsafe {
-                FileSystem::GetFullPathNameW(
-                    wpath.as_ptr(),
-                    buffer.len() as _,
-                    buffer.as_mut_ptr(),
-                    std::ptr::null_mut(),
-                )
-            };
-            if ret == 0 {
-                return Err(errno_err(vm));
-            }
-        }
-        let buffer = widestring::WideCString::from_vec_truncate(buffer);
-        Ok(path.mode.process_path(buffer.to_os_string(), vm))
-    }
-
-    #[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 mut buffer = vec![0u16; buflen];
-        let ret = unsafe {
-            FileSystem::GetVolumePathNameW(wide.as_ptr(), buffer.as_mut_ptr(), buflen as _)
-        };
-        if ret == 0 {
-            return Err(errno_err(vm));
-        }
-        let buffer = widestring::WideCString::from_vec_truncate(buffer);
-        Ok(path.mode.process_path(buffer.to_os_string(), vm))
-    }
-
-    #[pyfunction]
-    fn _path_splitroot(path: OsPath, vm: &VirtualMachine) -> PyResult<(String, String)> {
-        let orig: Vec<_> = path.path.encode_wide().collect();
-        if orig.is_empty() {
-            return Ok(("".to_owned(), "".to_owned()));
-        }
-        let backslashed: Vec<_> = orig
-            .iter()
-            .copied()
-            .map(|c| if c == b'/' as u16 { b'\\' as u16 } else { c })
-            .chain(std::iter::once(0)) // null-terminated
-            .collect();
-
-        fn from_utf16(wstr: &[u16], vm: &VirtualMachine) -> PyResult<String> {
-            String::from_utf16(wstr).map_err(|e| vm.new_unicode_decode_error(e.to_string()))
-        }
-
-        let wbuf = windows::core::PCWSTR::from_raw(backslashed.as_ptr());
-        let (root, path) = match unsafe { windows::Win32::UI::Shell::PathCchSkipRoot(wbuf) } {
-            Ok(end) => {
-                assert!(!end.is_null());
-                let len: usize = unsafe { end.as_ptr().offset_from(wbuf.as_ptr()) }
-                    .try_into()
-                    .expect("len must be non-negative");
-                assert!(
-                    len < backslashed.len(), // backslashed is null-terminated
-                    "path: {:?} {} < {}",
-                    std::path::PathBuf::from(std::ffi::OsString::from_wide(&backslashed)),
-                    len,
-                    backslashed.len()
-                );
-                (from_utf16(&orig[..len], vm)?, from_utf16(&orig[len..], vm)?)
-            }
-            Err(_) => ("".to_owned(), from_utf16(&orig, vm)?),
-        };
-        Ok((root, path))
-    }
-
-    #[pyfunction]
-    fn _getdiskusage(path: OsPath, vm: &VirtualMachine) -> PyResult<(u64, u64)> {
-        use FileSystem::GetDiskFreeSpaceExW;
-
-        let wpath = path.to_wide_cstring(vm)?;
-        let mut _free_to_me: u64 = 0;
-        let mut total: u64 = 0;
-        let mut free: u64 = 0;
-        let ret =
-            unsafe { GetDiskFreeSpaceExW(wpath.as_ptr(), &mut _free_to_me, &mut total, &mut free) };
-        if ret != 0 {
-            return Ok((total, free));
-        }
-        let err = io::Error::last_os_error();
-        if err.raw_os_error() == Some(Foundation::ERROR_DIRECTORY as i32) {
-            if let Some(parent) = path.as_ref().parent() {
-                let parent = widestring::WideCString::from_os_str(parent).unwrap();
-
-                let ret = unsafe {
-                    GetDiskFreeSpaceExW(parent.as_ptr(), &mut _free_to_me, &mut total, &mut free)
-                };
-
-                return if ret == 0 {
-                    Err(errno_err(vm))
-                } else {
-                    Ok((total, free))
-                };
-            }
-        }
-        Err(err.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn get_handle_inheritable(handle: intptr_t, vm: &VirtualMachine) -> PyResult<bool> {
-        let mut flags = 0;
-        if unsafe { Foundation::GetHandleInformation(handle as _, &mut flags) } == 0 {
-            Err(errno_err(vm))
-        } else {
-            Ok(flags & Foundation::HANDLE_FLAG_INHERIT != 0)
-        }
-    }
-
-    #[pyfunction]
-    fn getlogin(vm: &VirtualMachine) -> PyResult<String> {
-        let mut buffer = [0u16; 257];
-        let mut size = buffer.len() as u32;
-
-        let success = unsafe {
-            windows_sys::Win32::System::WindowsProgramming::GetUserNameW(
-                buffer.as_mut_ptr(),
-                &mut size,
-            )
-        };
-
-        if success != 0 {
-            // Convert the buffer (which is UTF-16) to a Rust String
-            let username = std::ffi::OsString::from_wide(&buffer[..(size - 1) as usize]);
-            Ok(username.to_str().unwrap().to_string())
-        } else {
-            Err(vm.new_os_error(format!("Error code: {success}")))
-        }
-    }
-
-    pub fn raw_set_handle_inheritable(handle: intptr_t, inheritable: bool) -> std::io::Result<()> {
-        let flags = if inheritable {
-            Foundation::HANDLE_FLAG_INHERIT
-        } else {
-            0
-        };
-        let res = unsafe {
-            Foundation::SetHandleInformation(handle as _, Foundation::HANDLE_FLAG_INHERIT, flags)
-        };
-        if res == 0 {
-            Err(last_os_error())
-        } else {
-            Ok(())
-        }
-    }
-
-    #[pyfunction]
-    fn listdrives(vm: &VirtualMachine) -> PyResult<PyListRef> {
-        use windows_sys::Win32::Foundation::ERROR_MORE_DATA;
-
-        let mut buffer = [0u16; 256];
-        let len =
-            unsafe { FileSystem::GetLogicalDriveStringsW(buffer.len() as _, buffer.as_mut_ptr()) };
-        if len == 0 {
-            return Err(errno_err(vm));
-        }
-        if len as usize >= buffer.len() {
-            return Err(std::io::Error::from_raw_os_error(ERROR_MORE_DATA as _).to_pyexception(vm));
-        }
-        let drives: Vec<_> = buffer[..(len - 1) as usize]
-            .split(|&c| c == 0)
-            .map(|drive| vm.new_pyobj(String::from_utf16_lossy(drive)))
-            .collect();
-        Ok(vm.ctx.new_list(drives))
-    }
-
-    #[pyfunction]
-    fn set_handle_inheritable(
-        handle: intptr_t,
-        inheritable: bool,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        raw_set_handle_inheritable(handle, inheritable).map_err(|e| e.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn mkdir(
-        path: OsPath,
-        mode: OptionalArg<i32>,
-        dir_fd: DirFd<{ _os::MKDIR_DIR_FD as usize }>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let mode = mode.unwrap_or(0o777);
-        let [] = dir_fd.0;
-        let _ = mode;
-        let wide = path.to_wide_cstring(vm)?;
-        let res = unsafe { FileSystem::CreateDirectoryW(wide.as_ptr(), std::ptr::null_mut()) };
-        if res == 0 {
-            return Err(errno_err(vm));
-        }
-        Ok(())
-    }
-
-    pub(crate) fn support_funcs() -> Vec<SupportFunc> {
-        Vec::new()
-    }
-}
diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs
deleted file mode 100644
index c33b9a47b0..0000000000
--- a/vm/src/stdlib/operator.rs
+++ /dev/null
@@ -1,601 +0,0 @@
-pub(crate) use _operator::make_module;
-
-#[pymodule]
-mod _operator {
-    use crate::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyInt, PyIntRef, PyStr, PyStrRef, PyTupleRef, PyTypeRef},
-        function::Either,
-        function::{ArgBytesLike, FuncArgs, KwArgs, OptionalArg},
-        identifier,
-        protocol::PyIter,
-        recursion::ReprGuard,
-        types::{Callable, Constructor, PyComparisonOp, Representable},
-    };
-    use constant_time_eq::constant_time_eq;
-
-    #[pyfunction]
-    fn lt(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Lt, vm)
-    }
-
-    #[pyfunction]
-    fn le(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Le, vm)
-    }
-
-    #[pyfunction]
-    fn gt(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Gt, vm)
-    }
-
-    #[pyfunction]
-    fn ge(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Ge, vm)
-    }
-
-    #[pyfunction]
-    fn eq(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Eq, vm)
-    }
-
-    #[pyfunction]
-    fn ne(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.rich_compare(b, PyComparisonOp::Ne, vm)
-    }
-
-    #[pyfunction]
-    fn not_(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        a.try_to_bool(vm).map(|r| !r)
-    }
-
-    #[pyfunction]
-    fn truth(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        a.try_to_bool(vm)
-    }
-
-    #[pyfunction]
-    fn is_(a: PyObjectRef, b: PyObjectRef) -> PyResult<bool> {
-        Ok(a.is(&b))
-    }
-
-    #[pyfunction]
-    fn is_not(a: PyObjectRef, b: PyObjectRef) -> PyResult<bool> {
-        Ok(!a.is(&b))
-    }
-
-    #[pyfunction]
-    fn abs(a: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._abs(&a)
-    }
-
-    #[pyfunction]
-    fn add(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._add(&a, &b)
-    }
-
-    #[pyfunction]
-    fn and_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._and(&a, &b)
-    }
-
-    #[pyfunction]
-    fn floordiv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._floordiv(&a, &b)
-    }
-
-    // Note: Keep track of issue17567. Will need changes in order to strictly match behavior of
-    // a.__index__ as raised in the issue. Currently, we accept int subclasses.
-    #[pyfunction]
-    fn index(a: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyIntRef> {
-        a.try_index(vm)
-    }
-
-    #[pyfunction]
-    fn invert(pos: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._invert(&pos)
-    }
-
-    #[pyfunction]
-    fn lshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._lshift(&a, &b)
-    }
-
-    #[pyfunction(name = "mod")]
-    fn mod_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._mod(&a, &b)
-    }
-
-    #[pyfunction]
-    fn mul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._mul(&a, &b)
-    }
-
-    #[pyfunction]
-    fn matmul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._matmul(&a, &b)
-    }
-
-    #[pyfunction]
-    fn neg(pos: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._neg(&pos)
-    }
-
-    #[pyfunction]
-    fn or_(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._or(&a, &b)
-    }
-
-    #[pyfunction]
-    fn pos(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._pos(&obj)
-    }
-
-    #[pyfunction]
-    fn pow(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._pow(&a, &b, vm.ctx.none.as_object())
-    }
-
-    #[pyfunction]
-    fn rshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._rshift(&a, &b)
-    }
-
-    #[pyfunction]
-    fn sub(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._sub(&a, &b)
-    }
-
-    #[pyfunction]
-    fn truediv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._truediv(&a, &b)
-    }
-
-    #[pyfunction]
-    fn xor(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._xor(&a, &b)
-    }
-
-    // Sequence based operators
-
-    #[pyfunction]
-    fn concat(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        // Best attempt at checking that a is sequence-like.
-        if !a.class().has_attr(identifier!(vm, __getitem__))
-            || a.fast_isinstance(vm.ctx.types.dict_type)
-        {
-            return Err(
-                vm.new_type_error(format!("{} object can't be concatenated", a.class().name()))
-            );
-        }
-        vm._add(&a, &b)
-    }
-
-    #[pyfunction]
-    fn contains(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<bool> {
-        vm._contains(&a, &b)
-    }
-
-    #[pyfunction(name = "countOf")]
-    fn count_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        let mut count: usize = 0;
-        for element in a.iter_without_hint::<PyObjectRef>(vm)? {
-            let element = element?;
-            if element.is(&b) || vm.bool_eq(&b, &element)? {
-                count += 1;
-            }
-        }
-        Ok(count)
-    }
-
-    #[pyfunction]
-    fn delitem(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        a.del_item(&*b, vm)
-    }
-
-    #[pyfunction]
-    fn getitem(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        a.get_item(&*b, vm)
-    }
-
-    #[pyfunction(name = "indexOf")]
-    fn index_of(a: PyIter, b: PyObjectRef, vm: &VirtualMachine) -> PyResult<usize> {
-        for (index, element) in a.iter_without_hint::<PyObjectRef>(vm)?.enumerate() {
-            let element = element?;
-            if element.is(&b) || vm.bool_eq(&b, &element)? {
-                return Ok(index);
-            }
-        }
-        Err(vm.new_value_error("sequence.index(x): x not in sequence"))
-    }
-
-    #[pyfunction]
-    fn setitem(
-        a: PyObjectRef,
-        b: PyObjectRef,
-        c: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        a.set_item(&*b, c, vm)
-    }
-
-    #[pyfunction]
-    fn length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMachine) -> PyResult<usize> {
-        let default: usize = default
-            .map(|v| {
-                if !v.fast_isinstance(vm.ctx.types.int_type) {
-                    return Err(vm.new_type_error(format!(
-                        "'{}' type cannot be interpreted as an integer",
-                        v.class().name()
-                    )));
-                }
-                v.payload::<PyInt>().unwrap().try_to_primitive(vm)
-            })
-            .unwrap_or(Ok(0))?;
-        obj.length_hint(default, vm)
-    }
-
-    // Inplace Operators
-
-    #[pyfunction]
-    fn iadd(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._iadd(&a, &b)
-    }
-
-    #[pyfunction]
-    fn iand(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._iand(&a, &b)
-    }
-
-    #[pyfunction]
-    fn iconcat(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        // Best attempt at checking that a is sequence-like.
-        if !a.class().has_attr(identifier!(vm, __getitem__))
-            || a.fast_isinstance(vm.ctx.types.dict_type)
-        {
-            return Err(
-                vm.new_type_error(format!("{} object can't be concatenated", a.class().name()))
-            );
-        }
-        vm._iadd(&a, &b)
-    }
-
-    #[pyfunction]
-    fn ifloordiv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._ifloordiv(&a, &b)
-    }
-
-    #[pyfunction]
-    fn ilshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._ilshift(&a, &b)
-    }
-
-    #[pyfunction]
-    fn imod(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._imod(&a, &b)
-    }
-
-    #[pyfunction]
-    fn imul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._imul(&a, &b)
-    }
-
-    #[pyfunction]
-    fn imatmul(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._imatmul(&a, &b)
-    }
-
-    #[pyfunction]
-    fn ior(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._ior(&a, &b)
-    }
-
-    #[pyfunction]
-    fn ipow(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._ipow(&a, &b, vm.ctx.none.as_object())
-    }
-
-    #[pyfunction]
-    fn irshift(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._irshift(&a, &b)
-    }
-
-    #[pyfunction]
-    fn isub(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._isub(&a, &b)
-    }
-
-    #[pyfunction]
-    fn itruediv(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._itruediv(&a, &b)
-    }
-
-    #[pyfunction]
-    fn ixor(a: PyObjectRef, b: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        vm._ixor(&a, &b)
-    }
-
-    #[pyfunction]
-    fn _compare_digest(
-        a: Either<PyStrRef, ArgBytesLike>,
-        b: Either<PyStrRef, ArgBytesLike>,
-        vm: &VirtualMachine,
-    ) -> PyResult<bool> {
-        let res = match (a, b) {
-            (Either::A(a), Either::A(b)) => {
-                if !a.as_str().is_ascii() || !b.as_str().is_ascii() {
-                    return Err(vm.new_type_error(
-                        "comparing strings with non-ASCII characters is not supported",
-                    ));
-                }
-                constant_time_eq(a.as_bytes(), b.as_bytes())
-            }
-            (Either::B(a), Either::B(b)) => a.with_ref(|a| b.with_ref(|b| constant_time_eq(a, b))),
-            _ => {
-                return Err(
-                    vm.new_type_error("unsupported operand types(s) or combination of types")
-                );
-            }
-        };
-        Ok(res)
-    }
-
-    /// attrgetter(attr, ...) --> attrgetter object
-    ///
-    /// Return a callable object that fetches the given attribute(s) from its operand.
-    /// After f = attrgetter('name'), the call f(r) returns r.name.
-    /// After g = attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).
-    /// After h = attrgetter('name.first', 'name.last'), the call h(r) returns
-    /// (r.name.first, r.name.last).
-    #[pyattr]
-    #[pyclass(name = "attrgetter")]
-    #[derive(Debug, PyPayload)]
-    struct PyAttrGetter {
-        attrs: Vec<PyStrRef>,
-    }
-
-    #[pyclass(with(Callable, Constructor, Representable))]
-    impl PyAttrGetter {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<(PyTypeRef, PyTupleRef)> {
-            let attrs = vm
-                .ctx
-                .new_tuple(zelf.attrs.iter().map(|v| v.clone().into()).collect());
-            Ok((zelf.class().to_owned(), attrs))
-        }
-
-        // Go through dotted parts of string and call getattr on whatever is returned.
-        fn get_single_attr(
-            obj: PyObjectRef,
-            attr: &Py<PyStr>,
-            vm: &VirtualMachine,
-        ) -> PyResult<PyObjectRef> {
-            let attr_str = attr.as_str();
-            let parts = attr_str.split('.').collect::<Vec<_>>();
-            if parts.len() == 1 {
-                return obj.get_attr(attr, vm);
-            }
-            let mut obj = obj;
-            for part in parts {
-                obj = obj.get_attr(&vm.ctx.new_str(part), vm)?;
-            }
-            Ok(obj)
-        }
-    }
-
-    impl Constructor for PyAttrGetter {
-        type Args = FuncArgs;
-
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            let n_attr = args.args.len();
-            // Check we get no keyword and at least one positional.
-            if !args.kwargs.is_empty() {
-                return Err(vm.new_type_error("attrgetter() takes no keyword arguments"));
-            }
-            if n_attr == 0 {
-                return Err(vm.new_type_error("attrgetter expected 1 argument, got 0."));
-            }
-            let mut attrs = Vec::with_capacity(n_attr);
-            for o in args.args {
-                if let Ok(r) = o.try_into_value(vm) {
-                    attrs.push(r);
-                } else {
-                    return Err(vm.new_type_error("attribute name must be a string"));
-                }
-            }
-            Self { attrs }.into_ref_with_type(vm, cls).map(Into::into)
-        }
-    }
-
-    impl Callable for PyAttrGetter {
-        type Args = PyObjectRef;
-        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
-            // Handle case where we only have one attribute.
-            if zelf.attrs.len() == 1 {
-                return Self::get_single_attr(obj, &zelf.attrs[0], vm);
-            }
-            // Build tuple and call get_single on each element in attrs.
-            let mut results = Vec::with_capacity(zelf.attrs.len());
-            for o in &zelf.attrs {
-                results.push(Self::get_single_attr(obj.clone(), o, vm)?);
-            }
-            Ok(vm.ctx.new_tuple(results).into())
-        }
-    }
-
-    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());
-                for part in &zelf.attrs {
-                    parts.push(part.as_object().repr(vm)?.as_str().to_owned());
-                }
-                parts.join(", ")
-            } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.attrgetter({fmt})"))
-        }
-    }
-
-    /// itemgetter(item, ...) --> itemgetter object
-    ///
-    /// Return a callable object that fetches the given item(s) from its operand.
-    /// After f = itemgetter(2), the call f(r) returns r[2].
-    /// After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
-    #[pyattr]
-    #[pyclass(name = "itemgetter")]
-    #[derive(Debug, PyPayload)]
-    struct PyItemGetter {
-        items: Vec<PyObjectRef>,
-    }
-
-    #[pyclass(with(Callable, Constructor, Representable))]
-    impl PyItemGetter {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyObjectRef {
-            let items = vm.ctx.new_tuple(zelf.items.to_vec());
-            vm.new_pyobj((zelf.class().to_owned(), items))
-        }
-    }
-    impl Constructor for PyItemGetter {
-        type Args = FuncArgs;
-
-        fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            // Check we get no keyword and at least one positional.
-            if !args.kwargs.is_empty() {
-                return Err(vm.new_type_error("itemgetter() takes no keyword arguments"));
-            }
-            if args.args.is_empty() {
-                return Err(vm.new_type_error("itemgetter expected 1 argument, got 0."));
-            }
-            Self { items: args.args }
-                .into_ref_with_type(vm, cls)
-                .map(Into::into)
-        }
-    }
-
-    impl Callable for PyItemGetter {
-        type Args = PyObjectRef;
-        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
-            // Handle case where we only have one attribute.
-            if zelf.items.len() == 1 {
-                return obj.get_item(&*zelf.items[0], vm);
-            }
-            // Build tuple and call get_single on each element in attrs.
-            let mut results = Vec::with_capacity(zelf.items.len());
-            for item in &zelf.items {
-                results.push(obj.get_item(&**item, vm)?);
-            }
-            Ok(vm.ctx.new_tuple(results).into())
-        }
-    }
-
-    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());
-                for item in &zelf.items {
-                    items.push(item.repr(vm)?.as_str().to_owned());
-                }
-                items.join(", ")
-            } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.itemgetter({fmt})"))
-        }
-    }
-
-    /// methodcaller(name, ...) --> methodcaller object
-    ///
-    /// Return a callable object that calls the given method on its operand.
-    /// After f = methodcaller('name'), the call f(r) returns r.name().
-    /// After g = methodcaller('name', 'date', foo=1), the call g(r) returns
-    /// r.name('date', foo=1).
-    #[pyattr]
-    #[pyclass(name = "methodcaller")]
-    #[derive(Debug, PyPayload)]
-    struct PyMethodCaller {
-        name: PyStrRef,
-        args: FuncArgs,
-    }
-
-    #[pyclass(with(Callable, Constructor, Representable))]
-    impl PyMethodCaller {
-        #[pymethod]
-        fn __reduce__(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult<PyTupleRef> {
-            // With no kwargs, return (type(obj), (name, *args)) tuple.
-            if zelf.args.kwargs.is_empty() {
-                let mut py_args = vec![zelf.name.as_object().to_owned()];
-                py_args.append(&mut zelf.args.args.clone());
-                Ok(vm.new_tuple((zelf.class().to_owned(), vm.ctx.new_tuple(py_args))))
-            } else {
-                // If we have kwargs, create a partial function that contains them and pass back that
-                // along with the args.
-                let partial = vm.import("functools", 0)?.get_attr("partial", vm)?;
-                let args = FuncArgs::new(
-                    vec![zelf.class().to_owned().into(), zelf.name.clone().into()],
-                    KwArgs::new(zelf.args.kwargs.clone()),
-                );
-                let callable = partial.call(args, vm)?;
-                Ok(vm.new_tuple((callable, vm.ctx.new_tuple(zelf.args.args.clone()))))
-            }
-        }
-    }
-
-    impl Constructor for PyMethodCaller {
-        type Args = (PyObjectRef, FuncArgs);
-
-        fn py_new(cls: PyTypeRef, (name, args): Self::Args, vm: &VirtualMachine) -> PyResult {
-            if let Ok(name) = name.try_into_value(vm) {
-                Self { name, args }
-                    .into_ref_with_type(vm, cls)
-                    .map(Into::into)
-            } else {
-                Err(vm.new_type_error("method name must be a string"))
-            }
-        }
-    }
-
-    impl Callable for PyMethodCaller {
-        type Args = PyObjectRef;
-
-        #[inline]
-        fn call(zelf: &Py<Self>, obj: Self::Args, vm: &VirtualMachine) -> PyResult {
-            vm.call_method(&obj, zelf.name.as_str(), zelf.args.clone())
-        }
-    }
-
-    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()) {
-                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(", "));
-                }
-                // 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(", "));
-                }
-                fmt.join(", ")
-            } else {
-                "...".to_owned()
-            };
-            Ok(format!("operator.methodcaller({fmt})"))
-        }
-    }
-}
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
deleted file mode 100644
index 19f5e44b34..0000000000
--- a/vm/src/stdlib/os.rs
+++ /dev/null
@@ -1,1545 +0,0 @@
-// spell-checker:disable
-
-use crate::{
-    AsObject, Py, PyPayload, PyResult, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyModule, PySet},
-    common::crt_fd::Fd,
-    convert::ToPyException,
-    function::{ArgumentError, FromArgs, FuncArgs},
-};
-use std::{ffi, fs, io, path::Path};
-
-pub(crate) fn fs_metadata<P: AsRef<Path>>(
-    path: P,
-    follow_symlink: bool,
-) -> io::Result<fs::Metadata> {
-    if follow_symlink {
-        fs::metadata(path.as_ref())
-    } else {
-        fs::symlink_metadata(path.as_ref())
-    }
-}
-
-#[cfg(unix)]
-impl crate::convert::IntoPyException for nix::Error {
-    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        io::Error::from(self).into_pyexception(vm)
-    }
-}
-
-#[cfg(unix)]
-impl crate::convert::IntoPyException for rustix::io::Errno {
-    fn into_pyexception(self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        io::Error::from(self).into_pyexception(vm)
-    }
-}
-
-/// Convert the error stored in the `errno` variable into an Exception
-#[inline]
-pub fn errno_err(vm: &VirtualMachine) -> PyBaseExceptionRef {
-    crate::common::os::last_os_error().to_pyexception(vm)
-}
-
-#[allow(dead_code)]
-#[derive(FromArgs, Default)]
-pub struct TargetIsDirectory {
-    #[pyarg(any, default = false)]
-    pub(crate) target_is_directory: bool,
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(all(any(unix, target_os = "wasi"), not(target_os = "redox")))] {
-        use libc::AT_FDCWD;
-    } else {
-        const AT_FDCWD: i32 = -100;
-    }
-}
-const DEFAULT_DIR_FD: Fd = Fd(AT_FDCWD);
-
-// XXX: AVAILABLE should be a bool, but we can't yet have it as a bool and just cast it to usize
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct DirFd<const AVAILABLE: usize>(pub(crate) [Fd; AVAILABLE]);
-
-impl<const AVAILABLE: usize> Default for DirFd<AVAILABLE> {
-    fn default() -> Self {
-        Self([DEFAULT_DIR_FD; AVAILABLE])
-    }
-}
-
-// not used on all platforms
-#[allow(unused)]
-impl DirFd<1> {
-    #[inline(always)]
-    pub(crate) fn fd_opt(&self) -> Option<Fd> {
-        self.get_opt().map(Fd)
-    }
-
-    #[inline]
-    pub(crate) fn get_opt(&self) -> Option<i32> {
-        let fd = self.fd();
-        if fd == DEFAULT_DIR_FD {
-            None
-        } else {
-            Some(fd.0)
-        }
-    }
-
-    #[inline(always)]
-    pub(crate) const fn fd(&self) -> Fd {
-        self.0[0]
-    }
-}
-
-impl<const AVAILABLE: usize> FromArgs for DirFd<AVAILABLE> {
-    fn from_args(vm: &VirtualMachine, args: &mut FuncArgs) -> Result<Self, ArgumentError> {
-        let fd = match args.take_keyword("dir_fd") {
-            Some(o) if vm.is_none(&o) => DEFAULT_DIR_FD,
-            None => DEFAULT_DIR_FD,
-            Some(o) => {
-                let fd = o.try_index_opt(vm).unwrap_or_else(|| {
-                    Err(vm.new_type_error(format!(
-                        "argument should be integer or None, not {}",
-                        o.class().name()
-                    )))
-                })?;
-                let fd = fd.try_to_primitive(vm)?;
-                Fd(fd)
-            }
-        };
-        if AVAILABLE == 0 && fd != DEFAULT_DIR_FD {
-            return Err(vm
-                .new_not_implemented_error("dir_fd unavailable on this platform")
-                .into());
-        }
-        Ok(Self([fd; AVAILABLE]))
-    }
-}
-
-#[derive(FromArgs)]
-pub(super) struct FollowSymlinks(
-    #[pyarg(named, name = "follow_symlinks", default = true)] pub bool,
-);
-
-fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a ffi::OsStr> {
-    rustpython_common::os::bytes_as_os_str(b)
-        .map_err(|_| vm.new_unicode_decode_error("can't decode path for utf-8"))
-}
-
-#[pymodule(sub)]
-pub(super) mod _os {
-    use super::{DirFd, FollowSymlinks, SupportFunc, errno_err};
-    use crate::{
-        AsObject, Py, PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject,
-        builtins::{
-            PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
-        },
-        common::{
-            crt_fd::{Fd, Offset},
-            fileutils::StatStruct,
-            lock::{OnceCell, PyRwLock},
-            suppress_iph,
-        },
-        convert::{IntoPyException, ToPyObject},
-        function::{ArgBytesLike, Either, FsPath, FuncArgs, OptionalArg},
-        ospath::{IOErrorBuilder, OsPath, OsPathOrFd, OutputMode},
-        protocol::PyIterReturn,
-        recursion::ReprGuard,
-        types::{IterNext, Iterable, PyStructSequence, Representable, SelfIter},
-        utils::ToCString,
-        vm::VirtualMachine,
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use itertools::Itertools;
-    use std::{
-        env, ffi, fs,
-        fs::OpenOptions,
-        io::{self, Read, Write},
-        path::PathBuf,
-        time::{Duration, SystemTime},
-    };
-
-    const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
-    pub(crate) const MKDIR_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
-    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")));
-
-    #[pyattr]
-    use libc::{
-        O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_TRUNC, O_WRONLY, SEEK_CUR, SEEK_END,
-        SEEK_SET,
-    };
-
-    #[pyattr]
-    pub(crate) const F_OK: u8 = 0;
-    #[pyattr]
-    pub(crate) const R_OK: u8 = 1 << 2;
-    #[pyattr]
-    pub(crate) const W_OK: u8 = 1 << 1;
-    #[pyattr]
-    pub(crate) const X_OK: u8 = 1 << 0;
-
-    #[pyfunction]
-    fn close(fileno: i32, vm: &VirtualMachine) -> PyResult<()> {
-        Fd(fileno).close().map_err(|e| e.into_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn closerange(fd_low: i32, fd_high: i32) {
-        for fileno in fd_low..fd_high {
-            let _ = Fd(fileno).close();
-        }
-    }
-
-    #[cfg(any(unix, windows, target_os = "wasi"))]
-    #[derive(FromArgs)]
-    struct OpenArgs {
-        path: OsPath,
-        flags: i32,
-        #[pyarg(any, default)]
-        mode: Option<i32>,
-        #[pyarg(flatten)]
-        dir_fd: DirFd<{ OPEN_DIR_FD as usize }>,
-    }
-
-    #[pyfunction]
-    fn open(args: OpenArgs, vm: &VirtualMachine) -> PyResult<i32> {
-        os_open(args.path, args.flags, args.mode, args.dir_fd, vm)
-    }
-
-    #[cfg(any(unix, windows, target_os = "wasi"))]
-    pub(crate) fn os_open(
-        name: OsPath,
-        flags: i32,
-        mode: Option<i32>,
-        dir_fd: DirFd<{ OPEN_DIR_FD as usize }>,
-        vm: &VirtualMachine,
-    ) -> PyResult<i32> {
-        let mode = mode.unwrap_or(0o777);
-        #[cfg(windows)]
-        let fd = {
-            let [] = dir_fd.0;
-            let name = name.to_wide_cstring(vm)?;
-            let flags = flags | libc::O_NOINHERIT;
-            Fd::wopen(&name, flags, mode)
-        };
-        #[cfg(not(windows))]
-        let fd = {
-            let name = name.clone().into_cstring(vm)?;
-            #[cfg(not(target_os = "wasi"))]
-            let flags = flags | libc::O_CLOEXEC;
-            #[cfg(not(target_os = "redox"))]
-            if let Some(dir_fd) = dir_fd.fd_opt() {
-                dir_fd.openat(&name, flags, mode)
-            } else {
-                Fd::open(&name, flags, mode)
-            }
-            #[cfg(target_os = "redox")]
-            {
-                let [] = dir_fd.0;
-                Fd::open(&name, flags, mode)
-            }
-        };
-        fd.map(|fd| fd.0)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, name, vm))
-    }
-
-    #[pyfunction]
-    fn fsync(fd: i32, vm: &VirtualMachine) -> PyResult<()> {
-        Fd(fd).fsync().map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn read(fd: i32, n: usize, vm: &VirtualMachine) -> PyResult<PyBytesRef> {
-        let mut buffer = vec![0u8; n];
-        let mut file = Fd(fd);
-        let n = file
-            .read(&mut buffer)
-            .map_err(|err| err.into_pyexception(vm))?;
-        buffer.truncate(n);
-
-        Ok(vm.ctx.new_bytes(buffer))
-    }
-
-    #[pyfunction]
-    fn write(fd: i32, data: ArgBytesLike, vm: &VirtualMachine) -> PyResult {
-        let mut file = Fd(fd);
-        let written = data
-            .with_ref(|b| file.write(b))
-            .map_err(|err| err.into_pyexception(vm))?;
-
-        Ok(vm.ctx.new_int(written).into())
-    }
-
-    #[pyfunction]
-    #[pyfunction(name = "unlink")]
-    fn remove(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult<()> {
-        let [] = dir_fd.0;
-        let is_junction = cfg!(windows)
-            && fs::metadata(&path).is_ok_and(|meta| meta.file_type().is_dir())
-            && fs::symlink_metadata(&path).is_ok_and(|meta| meta.file_type().is_symlink());
-        let res = if is_junction {
-            fs::remove_dir(&path)
-        } else {
-            fs::remove_file(&path)
-        };
-        res.map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
-    }
-
-    #[cfg(not(windows))]
-    #[pyfunction]
-    fn mkdir(
-        path: OsPath,
-        mode: OptionalArg<i32>,
-        dir_fd: DirFd<{ MKDIR_DIR_FD as usize }>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let mode = mode.unwrap_or(0o777);
-        let path = path.into_cstring(vm)?;
-        #[cfg(not(target_os = "redox"))]
-        if let Some(fd) = dir_fd.get_opt() {
-            let res = unsafe { libc::mkdirat(fd, path.as_ptr(), mode as _) };
-            let res = if res < 0 { Err(errno_err(vm)) } else { Ok(()) };
-            return res;
-        }
-        #[cfg(target_os = "redox")]
-        let [] = dir_fd.0;
-        let res = unsafe { libc::mkdir(path.as_ptr(), mode as _) };
-        if res < 0 { Err(errno_err(vm)) } else { Ok(()) }
-    }
-
-    #[pyfunction]
-    fn mkdirs(path: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        fs::create_dir_all(path.as_str()).map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn rmdir(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult<()> {
-        let [] = dir_fd.0;
-        fs::remove_dir(&path).map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
-    }
-
-    const LISTDIR_FD: bool = cfg!(all(unix, not(target_os = "redox")));
-
-    #[pyfunction]
-    fn listdir(path: OptionalArg<OsPathOrFd>, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        let path = path.unwrap_or_else(|| OsPathOrFd::Path(OsPath::new_str(".")));
-        let list = match path {
-            OsPathOrFd::Path(path) => {
-                let dir_iter = match fs::read_dir(&path) {
-                    Ok(iter) => iter,
-                    Err(err) => {
-                        return Err(IOErrorBuilder::with_filename(&err, path, vm));
-                    }
-                };
-                dir_iter
-                    .map(|entry| match entry {
-                        Ok(entry_path) => Ok(path.mode.process_path(entry_path.file_name(), vm)),
-                        Err(err) => Err(IOErrorBuilder::with_filename(&err, path.clone(), vm)),
-                    })
-                    .collect::<PyResult<_>>()?
-            }
-            OsPathOrFd::Fd(fno) => {
-                #[cfg(not(all(unix, not(target_os = "redox"))))]
-                {
-                    let _ = fno;
-                    return Err(
-                        vm.new_not_implemented_error("can't pass fd to listdir on this platform")
-                    );
-                }
-                #[cfg(all(unix, not(target_os = "redox")))]
-                {
-                    use rustpython_common::os::ffi::OsStrExt;
-                    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(ffi::OsStr::from_bytes(fname), vm),
-                                ),
-                            }
-                        })
-                        .collect::<Result<_, _>>()
-                        .map_err(|e| e.into_pyexception(vm))?
-                }
-            }
-        };
-        Ok(list)
-    }
-
-    fn env_bytes_as_bytes(obj: &Either<PyStrRef, PyBytesRef>) -> &[u8] {
-        match obj {
-            Either::A(s) => s.as_bytes(),
-            Either::B(b) => b.as_bytes(),
-        }
-    }
-
-    #[pyfunction]
-    fn putenv(
-        key: Either<PyStrRef, PyBytesRef>,
-        value: Either<PyStrRef, PyBytesRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let key = env_bytes_as_bytes(&key);
-        let value = env_bytes_as_bytes(&value);
-        if key.contains(&b'\0') || value.contains(&b'\0') {
-            return Err(vm.new_value_error("embedded null byte"));
-        }
-        if key.is_empty() || key.contains(&b'=') {
-            return Err(vm.new_value_error("illegal environment variable name"));
-        }
-        let key = super::bytes_as_os_str(key, vm)?;
-        let value = super::bytes_as_os_str(value, vm)?;
-        // SAFETY: requirements forwarded from the caller
-        unsafe { env::set_var(key, value) };
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn unsetenv(key: Either<PyStrRef, PyBytesRef>, vm: &VirtualMachine) -> PyResult<()> {
-        let key = env_bytes_as_bytes(&key);
-        if key.contains(&b'\0') {
-            return Err(vm.new_value_error("embedded null byte"));
-        }
-        if key.is_empty() || key.contains(&b'=') {
-            return Err(vm.new_errno_error(
-                22,
-                format!(
-                    "Invalid argument: {}",
-                    std::str::from_utf8(key).unwrap_or("<bytes encoding failure>")
-                ),
-            ));
-        }
-        let key = super::bytes_as_os_str(key, vm)?;
-        // SAFETY: requirements forwarded from the caller
-        unsafe { env::remove_var(key) };
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn readlink(path: OsPath, dir_fd: DirFd<0>, vm: &VirtualMachine) -> PyResult {
-        let mode = path.mode;
-        let [] = dir_fd.0;
-        let path =
-            fs::read_link(&path).map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))?;
-        Ok(mode.process_path(path, vm))
-    }
-
-    #[pyattr]
-    #[pyclass(name)]
-    #[derive(Debug, PyPayload)]
-    struct DirEntry {
-        file_name: std::ffi::OsString,
-        pathval: PathBuf,
-        file_type: io::Result<fs::FileType>,
-        mode: OutputMode,
-        stat: OnceCell<PyObjectRef>,
-        lstat: OnceCell<PyObjectRef>,
-        #[cfg(unix)]
-        ino: AtomicCell<u64>,
-        #[cfg(not(unix))]
-        ino: AtomicCell<Option<u64>>,
-    }
-
-    #[pyclass(with(Representable))]
-    impl DirEntry {
-        #[pygetset]
-        fn name(&self, vm: &VirtualMachine) -> PyResult {
-            Ok(self.mode.process_path(&self.file_name, vm))
-        }
-
-        #[pygetset]
-        fn path(&self, vm: &VirtualMachine) -> PyResult {
-            Ok(self.mode.process_path(&self.pathval, vm))
-        }
-
-        fn perform_on_metadata(
-            &self,
-            follow_symlinks: FollowSymlinks,
-            action: fn(fs::Metadata) -> bool,
-            vm: &VirtualMachine,
-        ) -> PyResult<bool> {
-            match super::fs_metadata(&self.pathval, follow_symlinks.0) {
-                Ok(meta) => Ok(action(meta)),
-                Err(e) => {
-                    // FileNotFoundError is caught and not raised
-                    if e.kind() == io::ErrorKind::NotFound {
-                        Ok(false)
-                    } else {
-                        Err(e.into_pyexception(vm))
-                    }
-                }
-            }
-        }
-
-        #[pymethod]
-        fn is_dir(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
-            self.perform_on_metadata(
-                follow_symlinks,
-                |meta: fs::Metadata| -> bool { meta.is_dir() },
-                vm,
-            )
-        }
-
-        #[pymethod]
-        fn is_file(&self, follow_symlinks: FollowSymlinks, vm: &VirtualMachine) -> PyResult<bool> {
-            self.perform_on_metadata(
-                follow_symlinks,
-                |meta: fs::Metadata| -> bool { meta.is_file() },
-                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())
-        }
-
-        #[pymethod]
-        fn stat(
-            &self,
-            dir_fd: DirFd<{ STAT_DIR_FD as usize }>,
-            follow_symlinks: FollowSymlinks,
-            vm: &VirtualMachine,
-        ) -> PyResult {
-            let do_stat = |follow_symlinks| {
-                stat(
-                    OsPath {
-                        path: self.pathval.as_os_str().to_owned(),
-                        mode: OutputMode::String,
-                    }
-                    .into(),
-                    dir_fd,
-                    FollowSymlinks(follow_symlinks),
-                    vm,
-                )
-            };
-            let lstat = || self.lstat.get_or_try_init(|| do_stat(false));
-            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()
-                    }
-                })?
-            } else {
-                lstat()?
-            };
-            Ok(stat.clone())
-        }
-
-        #[cfg(not(unix))]
-        #[pymethod]
-        fn inode(&self, vm: &VirtualMachine) -> PyResult<u64> {
-            match self.ino.load() {
-                Some(ino) => Ok(ino),
-                None => {
-                    let stat = stat_inner(
-                        OsPath {
-                            path: self.pathval.as_os_str().to_owned(),
-                            mode: OutputMode::String,
-                        }
-                        .into(),
-                        DirFd::default(),
-                        FollowSymlinks(false),
-                    )
-                    .map_err(|e| e.into_pyexception(vm))?
-                    .ok_or_else(|| crate::exceptions::cstring_error(vm))?;
-                    // Err(T) means other thread set `ino` at the mean time which is safe to ignore
-                    let _ = self.ino.compare_exchange(None, Some(stat.st_ino));
-                    Ok(stat.st_ino)
-                }
-            }
-        }
-
-        #[cfg(unix)]
-        #[pymethod]
-        fn inode(&self, _vm: &VirtualMachine) -> PyResult<u64> {
-            Ok(self.ino.load())
-        }
-
-        #[cfg(not(windows))]
-        #[pymethod]
-        const fn is_junction(&self, _vm: &VirtualMachine) -> PyResult<bool> {
-            Ok(false)
-        }
-
-        #[cfg(windows)]
-        #[pymethod]
-        fn is_junction(&self, _vm: &VirtualMachine) -> PyResult<bool> {
-            Ok(junction::exists(self.pathval.clone()).unwrap_or(false))
-        }
-
-        #[pymethod]
-        fn __fspath__(&self, vm: &VirtualMachine) -> PyResult {
-            self.path(vm)
-        }
-
-        #[pyclassmethod]
-        fn __class_getitem__(
-            cls: PyTypeRef,
-            args: PyObjectRef,
-            vm: &VirtualMachine,
-        ) -> PyGenericAlias {
-            PyGenericAlias::from_args(cls, args, vm)
-        }
-    }
-
-    impl Representable for DirEntry {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String> {
-            let name = match zelf.as_object().get_attr("name", vm) {
-                Ok(name) => Some(name),
-                Err(e)
-                    if e.fast_isinstance(vm.ctx.exceptions.attribute_error)
-                        || e.fast_isinstance(vm.ctx.exceptions.value_error) =>
-                {
-                    None
-                }
-                Err(e) => return Err(e),
-            };
-            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))
-                } else {
-                    Err(vm.new_runtime_error(format!(
-                        "reentrant call inside {}.__repr__",
-                        zelf.class()
-                    )))
-                }
-            } else {
-                Ok(format!("<{}>", zelf.class()))
-            }
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(name = "ScandirIter")]
-    #[derive(Debug, PyPayload)]
-    struct ScandirIterator {
-        entries: PyRwLock<Option<fs::ReadDir>>,
-        mode: OutputMode,
-    }
-
-    #[pyclass(with(IterNext, Iterable))]
-    impl ScandirIterator {
-        #[pymethod]
-        fn close(&self) {
-            let entryref: &mut Option<fs::ReadDir> = &mut self.entries.write();
-            let _dropped = entryref.take();
-        }
-
-        #[pymethod]
-        const fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
-            zelf
-        }
-
-        #[pymethod]
-        fn __exit__(zelf: PyRef<Self>, _args: FuncArgs) {
-            zelf.close()
-        }
-    }
-    impl SelfIter for ScandirIterator {}
-    impl IterNext for ScandirIterator {
-        fn next(zelf: &crate::Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-            let entryref: &mut Option<fs::ReadDir> = &mut zelf.entries.write();
-
-            match entryref {
-                None => Ok(PyIterReturn::StopIteration(None)),
-                Some(inner) => match inner.next() {
-                    Some(entry) => match entry {
-                        Ok(entry) => {
-                            #[cfg(unix)]
-                            let ino = {
-                                use std::os::unix::fs::DirEntryExt;
-                                entry.ino()
-                            };
-                            #[cfg(not(unix))]
-                            let ino = None;
-
-                            Ok(PyIterReturn::Return(
-                                DirEntry {
-                                    file_name: entry.file_name(),
-                                    pathval: entry.path(),
-                                    file_type: entry.file_type(),
-                                    mode: zelf.mode,
-                                    lstat: OnceCell::new(),
-                                    stat: OnceCell::new(),
-                                    ino: AtomicCell::new(ino),
-                                }
-                                .into_ref(&vm.ctx)
-                                .into(),
-                            ))
-                        }
-                        Err(err) => Err(err.into_pyexception(vm)),
-                    },
-                    None => {
-                        let _dropped = entryref.take();
-                        Ok(PyIterReturn::StopIteration(None))
-                    }
-                },
-            }
-        }
-    }
-
-    #[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| IOErrorBuilder::with_filename(&err, path.clone(), vm))?;
-        Ok(ScandirIterator {
-            entries: PyRwLock::new(Some(entries)),
-            mode: path.mode,
-        }
-        .into_ref(&vm.ctx)
-        .into())
-    }
-
-    #[pyattr]
-    #[pyclass(module = "os", name = "stat_result")]
-    #[derive(Debug, PyStructSequence, FromArgs)]
-    struct StatResult {
-        pub st_mode: PyIntRef,
-        pub st_ino: PyIntRef,
-        pub st_dev: PyIntRef,
-        pub st_nlink: PyIntRef,
-        pub st_uid: PyIntRef,
-        pub st_gid: PyIntRef,
-        pub st_size: PyIntRef,
-        // TODO: unnamed structsequence fields
-        #[pyarg(positional, default)]
-        pub __st_atime_int: libc::time_t,
-        #[pyarg(positional, default)]
-        pub __st_mtime_int: libc::time_t,
-        #[pyarg(positional, default)]
-        pub __st_ctime_int: libc::time_t,
-        #[pyarg(any, default)]
-        pub st_atime: f64,
-        #[pyarg(any, default)]
-        pub st_mtime: f64,
-        #[pyarg(any, default)]
-        pub st_ctime: f64,
-        #[pyarg(any, default)]
-        pub st_atime_ns: i128,
-        #[pyarg(any, default)]
-        pub st_mtime_ns: i128,
-        #[pyarg(any, default)]
-        pub st_ctime_ns: i128,
-        #[pyarg(any, default)]
-        pub st_reparse_tag: u32,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl StatResult {
-        fn from_stat(stat: &StatStruct, vm: &VirtualMachine) -> Self {
-            let (atime, mtime, ctime);
-            #[cfg(any(unix, windows))]
-            #[cfg(not(target_os = "netbsd"))]
-            {
-                atime = (stat.st_atime, stat.st_atime_nsec);
-                mtime = (stat.st_mtime, stat.st_mtime_nsec);
-                ctime = (stat.st_ctime, stat.st_ctime_nsec);
-            }
-            #[cfg(target_os = "netbsd")]
-            {
-                atime = (stat.st_atime, stat.st_atimensec);
-                mtime = (stat.st_mtime, stat.st_mtimensec);
-                ctime = (stat.st_ctime, stat.st_ctimensec);
-            }
-            #[cfg(target_os = "wasi")]
-            {
-                atime = (stat.st_atim.tv_sec, stat.st_atim.tv_nsec);
-                mtime = (stat.st_mtim.tv_sec, stat.st_mtim.tv_nsec);
-                ctime = (stat.st_ctim.tv_sec, stat.st_ctim.tv_nsec);
-            }
-
-            const NANOS_PER_SEC: u32 = 1_000_000_000;
-            let to_f64 = |(s, ns)| (s as f64) + (ns as f64) / (NANOS_PER_SEC as f64);
-            let to_ns = |(s, ns)| s as i128 * NANOS_PER_SEC as i128 + ns as i128;
-
-            #[cfg(windows)]
-            let st_reparse_tag = stat.st_reparse_tag;
-            #[cfg(not(windows))]
-            let st_reparse_tag = 0;
-
-            Self {
-                st_mode: vm.ctx.new_pyref(stat.st_mode),
-                st_ino: vm.ctx.new_pyref(stat.st_ino),
-                st_dev: vm.ctx.new_pyref(stat.st_dev),
-                st_nlink: vm.ctx.new_pyref(stat.st_nlink),
-                st_uid: vm.ctx.new_pyref(stat.st_uid),
-                st_gid: vm.ctx.new_pyref(stat.st_gid),
-                st_size: vm.ctx.new_pyref(stat.st_size),
-                __st_atime_int: atime.0,
-                __st_mtime_int: mtime.0,
-                __st_ctime_int: ctime.0,
-                st_atime: to_f64(atime),
-                st_mtime: to_f64(mtime),
-                st_ctime: to_f64(ctime),
-                st_atime_ns: to_ns(atime),
-                st_mtime_ns: to_ns(mtime),
-                st_ctime_ns: to_ns(ctime),
-                st_reparse_tag,
-            }
-        }
-
-        #[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.payload::<PyTuple>() {
-                            Some(t) => {
-                                vec_args = Vec::from(t.as_slice());
-                            }
-                            None => {
-                                return vec_args;
-                            }
-                        }
-                    } else {
-                        return vec_args;
-                    }
-                }
-            };
-
-            let args: FuncArgs = flatten_args(&args.args).into();
-
-            let stat: Self = args.bind(vm)?;
-            Ok(stat.to_pyobject(vm))
-        }
-    }
-
-    #[cfg(windows)]
-    fn stat_inner(
-        file: OsPathOrFd,
-        dir_fd: DirFd<{ STAT_DIR_FD as usize }>,
-        follow_symlinks: FollowSymlinks,
-    ) -> io::Result<Option<StatStruct>> {
-        // TODO: replicate CPython's win32_xstat
-        let [] = dir_fd.0;
-        match file {
-            OsPathOrFd::Path(path) => crate::windows::win32_xstat(&path.path, follow_symlinks.0),
-            OsPathOrFd::Fd(fd) => crate::common::fileutils::fstat(fd),
-        }
-        .map(Some)
-    }
-
-    #[cfg(not(windows))]
-    fn stat_inner(
-        file: OsPathOrFd,
-        dir_fd: DirFd<{ STAT_DIR_FD as usize }>,
-        follow_symlinks: FollowSymlinks,
-    ) -> io::Result<Option<StatStruct>> {
-        let mut stat = std::mem::MaybeUninit::uninit();
-        let ret = match file {
-            OsPathOrFd::Path(path) => {
-                use rustpython_common::os::ffi::OsStrExt;
-                let path = path.as_ref().as_os_str().as_bytes();
-                let path = match ffi::CString::new(path) {
-                    Ok(x) => x,
-                    Err(_) => return Ok(None),
-                };
-
-                #[cfg(not(target_os = "redox"))]
-                let fstatat_ret = dir_fd.get_opt().map(|dir_fd| {
-                    let flags = if follow_symlinks.0 {
-                        0
-                    } else {
-                        libc::AT_SYMLINK_NOFOLLOW
-                    };
-                    unsafe { libc::fstatat(dir_fd, path.as_ptr(), stat.as_mut_ptr(), flags) }
-                });
-                #[cfg(target_os = "redox")]
-                let ([], fstatat_ret) = (dir_fd.0, None);
-
-                fstatat_ret.unwrap_or_else(|| {
-                    if follow_symlinks.0 {
-                        unsafe { libc::stat(path.as_ptr(), stat.as_mut_ptr()) }
-                    } else {
-                        unsafe { libc::lstat(path.as_ptr(), stat.as_mut_ptr()) }
-                    }
-                })
-            }
-            OsPathOrFd::Fd(fd) => unsafe { libc::fstat(fd, stat.as_mut_ptr()) },
-        };
-        if ret < 0 {
-            return Err(io::Error::last_os_error());
-        }
-        Ok(Some(unsafe { stat.assume_init() }))
-    }
-
-    #[pyfunction]
-    #[pyfunction(name = "fstat")]
-    fn stat(
-        file: OsPathOrFd,
-        dir_fd: DirFd<{ STAT_DIR_FD as usize }>,
-        follow_symlinks: FollowSymlinks,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        let stat = stat_inner(file.clone(), dir_fd, follow_symlinks)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, file, vm))?
-            .ok_or_else(|| crate::exceptions::cstring_error(vm))?;
-        Ok(StatResult::from_stat(&stat, vm).to_pyobject(vm))
-    }
-
-    #[pyfunction]
-    fn lstat(
-        file: OsPathOrFd,
-        dir_fd: DirFd<{ STAT_DIR_FD as usize }>,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        stat(file, dir_fd, FollowSymlinks(false), vm)
-    }
-
-    fn curdir_inner(vm: &VirtualMachine) -> PyResult<PathBuf> {
-        env::current_dir().map_err(|err| err.into_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn getcwd(vm: &VirtualMachine) -> PyResult {
-        Ok(OutputMode::String.process_path(curdir_inner(vm)?, vm))
-    }
-
-    #[pyfunction]
-    fn getcwdb(vm: &VirtualMachine) -> PyResult {
-        Ok(OutputMode::Bytes.process_path(curdir_inner(vm)?, vm))
-    }
-
-    #[pyfunction]
-    fn chdir(path: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        env::set_current_dir(&path.path)
-            .map_err(|err| IOErrorBuilder::with_filename(&err, path, vm))
-    }
-
-    #[pyfunction]
-    fn fspath(path: PyObjectRef, vm: &VirtualMachine) -> PyResult<FsPath> {
-        FsPath::try_from(path, false, vm)
-    }
-
-    #[pyfunction]
-    #[pyfunction(name = "replace")]
-    fn rename(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        fs::rename(&src.path, &dst.path).map_err(|err| {
-            IOErrorBuilder::new(&err)
-                .filename(src)
-                .filename2(dst)
-                .into_pyexception(vm)
-        })
-    }
-
-    #[pyfunction]
-    fn getpid(vm: &VirtualMachine) -> PyObjectRef {
-        let pid = if cfg!(target_arch = "wasm32") {
-            // Return an arbitrary value, greater than 1 which is special.
-            // The value 42 is picked from wasi-libc
-            // https://github.com/WebAssembly/wasi-libc/blob/wasi-sdk-21/libc-bottom-half/getpid/getpid.c
-            42
-        } else {
-            std::process::id()
-        };
-        vm.ctx.new_int(pid).into()
-    }
-
-    #[pyfunction]
-    fn cpu_count(vm: &VirtualMachine) -> PyObjectRef {
-        let cpu_count = num_cpus::get();
-        vm.ctx.new_int(cpu_count).into()
-    }
-
-    #[pyfunction]
-    fn _exit(code: i32) {
-        std::process::exit(code)
-    }
-
-    #[pyfunction]
-    fn abort() {
-        unsafe extern "C" {
-            fn abort();
-        }
-        unsafe { abort() }
-    }
-
-    #[pyfunction]
-    fn urandom(size: isize, vm: &VirtualMachine) -> PyResult<Vec<u8>> {
-        if size < 0 {
-            return Err(vm.new_value_error("negative argument not allowed"));
-        }
-        let mut buf = vec![0u8; size as usize];
-        getrandom::fill(&mut buf).map_err(|e| io::Error::from(e).into_pyexception(vm))?;
-        Ok(buf)
-    }
-
-    #[pyfunction]
-    pub fn isatty(fd: i32) -> bool {
-        unsafe { suppress_iph!(libc::isatty(fd)) != 0 }
-    }
-
-    #[pyfunction]
-    pub fn lseek(fd: i32, position: Offset, how: i32, vm: &VirtualMachine) -> PyResult<Offset> {
-        #[cfg(not(windows))]
-        let res = unsafe { suppress_iph!(libc::lseek(fd, position, how)) };
-        #[cfg(windows)]
-        let res = unsafe {
-            use windows_sys::Win32::Storage::FileSystem;
-            let handle = Fd(fd).to_raw_handle().map_err(|e| e.into_pyexception(vm))?;
-            let mut distance_to_move: [i32; 2] = std::mem::transmute(position);
-            let ret = FileSystem::SetFilePointer(
-                handle as _,
-                distance_to_move[0],
-                &mut distance_to_move[1],
-                how as _,
-            );
-            if ret == FileSystem::INVALID_SET_FILE_POINTER {
-                -1
-            } else {
-                distance_to_move[0] = ret as _;
-                std::mem::transmute::<[i32; 2], i64>(distance_to_move)
-            }
-        };
-        if res < 0 { Err(errno_err(vm)) } else { Ok(res) }
-    }
-
-    #[pyfunction]
-    fn link(src: OsPath, dst: OsPath, vm: &VirtualMachine) -> PyResult<()> {
-        fs::hard_link(&src.path, &dst.path).map_err(|err| {
-            IOErrorBuilder::new(&err)
-                .filename(src)
-                .filename2(dst)
-                .into_pyexception(vm)
-        })
-    }
-
-    #[cfg(any(unix, windows))]
-    #[pyfunction]
-    fn system(command: PyStrRef, vm: &VirtualMachine) -> PyResult<i32> {
-        let cstr = command.to_cstring(vm)?;
-        let x = unsafe { libc::system(cstr.as_ptr()) };
-        Ok(x)
-    }
-
-    #[derive(FromArgs)]
-    struct UtimeArgs {
-        path: OsPath,
-        #[pyarg(any, default)]
-        times: Option<PyTupleRef>,
-        #[pyarg(named, default)]
-        ns: Option<PyTupleRef>,
-        #[pyarg(flatten)]
-        dir_fd: DirFd<{ UTIME_DIR_FD as usize }>,
-        #[pyarg(flatten)]
-        follow_symlinks: FollowSymlinks,
-    }
-
-    #[pyfunction]
-    fn utime(args: UtimeArgs, vm: &VirtualMachine) -> PyResult<()> {
-        let parse_tup = |tup: &PyTuple| -> Option<(PyObjectRef, PyObjectRef)> {
-            if tup.len() != 2 {
-                None
-            } else {
-                Some((tup[0].clone(), tup[1].clone()))
-            }
-        };
-        let (acc, modif) = match (args.times, args.ns) {
-            (Some(t), None) => {
-                let (a, m) = parse_tup(&t).ok_or_else(|| {
-                    vm.new_type_error("utime: 'times' must be either a tuple of two ints or None")
-                })?;
-                (a.try_into_value(vm)?, m.try_into_value(vm)?)
-            }
-            (None, Some(ns)) => {
-                let (a, m) = parse_tup(&ns)
-                    .ok_or_else(|| vm.new_type_error("utime: 'ns' must be a tuple of two ints"))?;
-                let ns_in_sec: PyObjectRef = vm.ctx.new_int(1_000_000_000).into();
-                let ns_to_dur = |obj: PyObjectRef| {
-                    let divmod = vm._divmod(&obj, &ns_in_sec)?;
-                    let (div, rem) =
-                        divmod
-                            .payload::<PyTuple>()
-                            .and_then(parse_tup)
-                            .ok_or_else(|| {
-                                vm.new_type_error(format!(
-                                    "{}.__divmod__() must return a 2-tuple, not {}",
-                                    obj.class().name(),
-                                    divmod.class().name()
-                                ))
-                            })?;
-                    let secs = div.try_index(vm)?.try_to_primitive(vm)?;
-                    let ns = rem.try_index(vm)?.try_to_primitive(vm)?;
-                    Ok(Duration::new(secs, ns))
-                };
-                // TODO: do validation to make sure this doesn't.. underflow?
-                (ns_to_dur(a)?, ns_to_dur(m)?)
-            }
-            (None, None) => {
-                let now = SystemTime::now();
-                let now = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
-                (now, now)
-            }
-            (Some(_), Some(_)) => {
-                return Err(vm.new_value_error(
-                    "utime: you may specify either 'times' or 'ns' but not both",
-                ));
-            }
-        };
-        utime_impl(args.path, acc, modif, args.dir_fd, args.follow_symlinks, vm)
-    }
-
-    fn utime_impl(
-        path: OsPath,
-        acc: Duration,
-        modif: Duration,
-        dir_fd: DirFd<{ UTIME_DIR_FD as usize }>,
-        _follow_symlinks: FollowSymlinks,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        #[cfg(any(target_os = "wasi", unix))]
-        {
-            #[cfg(not(target_os = "redox"))]
-            {
-                let path = path.into_cstring(vm)?;
-
-                let ts = |d: Duration| libc::timespec {
-                    tv_sec: d.as_secs() as _,
-                    tv_nsec: d.subsec_nanos() as _,
-                };
-                let times = [ts(acc), ts(modif)];
-
-                let ret = unsafe {
-                    libc::utimensat(
-                        dir_fd.fd().0,
-                        path.as_ptr(),
-                        times.as_ptr(),
-                        if _follow_symlinks.0 {
-                            0
-                        } else {
-                            libc::AT_SYMLINK_NOFOLLOW
-                        },
-                    )
-                };
-                if ret < 0 { Err(errno_err(vm)) } else { Ok(()) }
-            }
-            #[cfg(target_os = "redox")]
-            {
-                let [] = dir_fd.0;
-
-                let tv = |d: Duration| libc::timeval {
-                    tv_sec: d.as_secs() as _,
-                    tv_usec: d.as_micros() as _,
-                };
-                nix::sys::stat::utimes(path.as_ref(), &tv(acc).into(), &tv(modif).into())
-                    .map_err(|err| err.into_pyexception(vm))
-            }
-        }
-        #[cfg(windows)]
-        {
-            use std::{fs::OpenOptions, os::windows::prelude::*};
-            type DWORD = u32;
-            use windows_sys::Win32::{Foundation::FILETIME, Storage::FileSystem};
-
-            let [] = dir_fd.0;
-
-            let ft = |d: Duration| {
-                let intervals =
-                    ((d.as_secs() as i64 + 11644473600) * 10_000_000) + (d.as_nanos() as i64 / 100);
-                FILETIME {
-                    dwLowDateTime: intervals as DWORD,
-                    dwHighDateTime: (intervals >> 32) as DWORD,
-                }
-            };
-
-            let acc = ft(acc);
-            let modif = ft(modif);
-
-            let f = OpenOptions::new()
-                .write(true)
-                .custom_flags(windows_sys::Win32::Storage::FileSystem::FILE_FLAG_BACKUP_SEMANTICS)
-                .open(path)
-                .map_err(|err| err.into_pyexception(vm))?;
-
-            let ret = unsafe {
-                FileSystem::SetFileTime(f.as_raw_handle() as _, std::ptr::null(), &acc, &modif)
-            };
-
-            if ret == 0 {
-                Err(io::Error::last_os_error().into_pyexception(vm))
-            } else {
-                Ok(())
-            }
-        }
-    }
-
-    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
-    #[pyattr]
-    #[pyclass(module = "os", name = "times_result")]
-    #[derive(Debug, PyStructSequence)]
-    struct TimesResult {
-        pub user: f64,
-        pub system: f64,
-        pub children_user: f64,
-        pub children_system: f64,
-        pub elapsed: f64,
-    }
-
-    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
-    #[pyclass(with(PyStructSequence))]
-    impl TimesResult {}
-
-    #[cfg(all(any(unix, windows), not(target_os = "redox")))]
-    #[pyfunction]
-    fn times(vm: &VirtualMachine) -> PyResult {
-        #[cfg(windows)]
-        {
-            use std::mem::MaybeUninit;
-            use windows_sys::Win32::{Foundation::FILETIME, System::Threading};
-
-            let mut _create = MaybeUninit::<FILETIME>::uninit();
-            let mut _exit = MaybeUninit::<FILETIME>::uninit();
-            let mut kernel = MaybeUninit::<FILETIME>::uninit();
-            let mut user = MaybeUninit::<FILETIME>::uninit();
-
-            unsafe {
-                let h_proc = Threading::GetCurrentProcess();
-                Threading::GetProcessTimes(
-                    h_proc,
-                    _create.as_mut_ptr(),
-                    _exit.as_mut_ptr(),
-                    kernel.as_mut_ptr(),
-                    user.as_mut_ptr(),
-                );
-            }
-
-            let kernel = unsafe { kernel.assume_init() };
-            let user = unsafe { user.assume_init() };
-
-            let times_result = TimesResult {
-                user: user.dwHighDateTime as f64 * 429.4967296 + user.dwLowDateTime as f64 * 1e-7,
-                system: kernel.dwHighDateTime as f64 * 429.4967296
-                    + kernel.dwLowDateTime as f64 * 1e-7,
-                children_user: 0.0,
-                children_system: 0.0,
-                elapsed: 0.0,
-            };
-
-            Ok(times_result.to_pyobject(vm))
-        }
-        #[cfg(unix)]
-        {
-            let mut t = libc::tms {
-                tms_utime: 0,
-                tms_stime: 0,
-                tms_cutime: 0,
-                tms_cstime: 0,
-            };
-
-            let tick_for_second = unsafe { libc::sysconf(libc::_SC_CLK_TCK) } as f64;
-            let c = unsafe { libc::times(&mut t as *mut _) };
-
-            // XXX: The signedness of `clock_t` varies from platform to platform.
-            if c == (-1i8) as libc::clock_t {
-                return Err(vm.new_os_error("Fail to get times".to_string()));
-            }
-
-            let times_result = TimesResult {
-                user: t.tms_utime as f64 / tick_for_second,
-                system: t.tms_stime as f64 / tick_for_second,
-                children_user: t.tms_cutime as f64 / tick_for_second,
-                children_system: t.tms_cstime as f64 / tick_for_second,
-                elapsed: c as f64 / tick_for_second,
-            };
-
-            Ok(times_result.to_pyobject(vm))
-        }
-    }
-
-    #[cfg(target_os = "linux")]
-    #[derive(FromArgs)]
-    struct CopyFileRangeArgs {
-        #[pyarg(positional)]
-        src: i32,
-        #[pyarg(positional)]
-        dst: i32,
-        #[pyarg(positional)]
-        count: i64,
-        #[pyarg(any, default)]
-        offset_src: Option<Offset>,
-        #[pyarg(any, default)]
-        offset_dst: Option<Offset>,
-    }
-
-    #[cfg(target_os = "linux")]
-    #[pyfunction]
-    fn copy_file_range(args: CopyFileRangeArgs, vm: &VirtualMachine) -> PyResult<usize> {
-        let p_offset_src = args.offset_src.as_ref().map_or_else(std::ptr::null, |x| x);
-        let p_offset_dst = args.offset_dst.as_ref().map_or_else(std::ptr::null, |x| x);
-        let count: usize = args
-            .count
-            .try_into()
-            .map_err(|_| vm.new_value_error("count should >= 0"))?;
-
-        // The flags argument is provided to allow
-        // for future extensions and currently must be to 0.
-        let flags = 0u32;
-
-        // Safety: p_offset_src and p_offset_dst is a unique pointer for offset_src and offset_dst respectively,
-        // and will only be freed after this function ends.
-        //
-        // Why not use `libc::copy_file_range`: On `musl-libc`, `libc::copy_file_range` is not provided. Therefore
-        // we use syscalls directly instead.
-        let ret = unsafe {
-            libc::syscall(
-                libc::SYS_copy_file_range,
-                args.src,
-                p_offset_src as *mut i64,
-                args.dst,
-                p_offset_dst as *mut i64,
-                count,
-                flags,
-            )
-        };
-
-        usize::try_from(ret).map_err(|_| errno_err(vm))
-    }
-
-    #[pyfunction]
-    fn strerror(e: i32) -> String {
-        unsafe { ffi::CStr::from_ptr(libc::strerror(e)) }
-            .to_string_lossy()
-            .into_owned()
-    }
-
-    #[pyfunction]
-    pub fn ftruncate(fd: i32, length: Offset, vm: &VirtualMachine) -> PyResult<()> {
-        Fd(fd).ftruncate(length).map_err(|e| e.into_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn truncate(path: PyObjectRef, length: Offset, vm: &VirtualMachine) -> PyResult<()> {
-        if let Ok(fd) = path.try_to_value(vm) {
-            return ftruncate(fd, length, vm);
-        }
-
-        #[cold]
-        fn error(
-            vm: &VirtualMachine,
-            error: std::io::Error,
-            path: OsPath,
-        ) -> crate::builtins::PyBaseExceptionRef {
-            IOErrorBuilder::with_filename(&error, path, vm)
-        }
-
-        let path = OsPath::try_from_object(vm, path)?;
-        // TODO: just call libc::truncate() on POSIX
-        let f = match OpenOptions::new().write(true).open(&path) {
-            Ok(f) => f,
-            Err(e) => return Err(error(vm, e, path)),
-        };
-        f.set_len(length as u64).map_err(|e| error(vm, e, path))?;
-        drop(f);
-        Ok(())
-    }
-
-    #[cfg(all(unix, not(any(target_os = "redox", target_os = "android"))))]
-    #[pyfunction]
-    fn getloadavg(vm: &VirtualMachine) -> PyResult<(f64, f64, f64)> {
-        let mut loadavg = [0f64; 3];
-
-        // Safety: loadavg is on stack and only write by `getloadavg` and are freed
-        // after this function ends.
-        unsafe {
-            if libc::getloadavg(&mut loadavg[0] as *mut f64, 3) != 3 {
-                return Err(vm.new_os_error("Load averages are unobtainable".to_string()));
-            }
-        }
-
-        Ok((loadavg[0], loadavg[1], loadavg[2]))
-    }
-
-    #[cfg(any(unix, windows))]
-    #[pyfunction]
-    fn waitstatus_to_exitcode(status: i32, vm: &VirtualMachine) -> PyResult<i32> {
-        let status = u32::try_from(status)
-            .map_err(|_| vm.new_value_error(format!("invalid WEXITSTATUS: {status}")))?;
-
-        cfg_if::cfg_if! {
-            if #[cfg(not(windows))] {
-                let status = status as libc::c_int;
-                if libc::WIFEXITED(status) {
-                    return Ok(libc::WEXITSTATUS(status));
-                }
-
-                if libc::WIFSIGNALED(status) {
-                    return Ok(-libc::WTERMSIG(status));
-                }
-
-                Err(vm.new_value_error(format!("Invalid wait status: {status}")))
-            } else {
-                i32::try_from(status.rotate_right(8))
-                    .map_err(|_| vm.new_value_error(format!("invalid wait status: {status}")))
-            }
-        }
-    }
-
-    #[pyfunction]
-    fn device_encoding(fd: i32, _vm: &VirtualMachine) -> PyResult<Option<String>> {
-        if !isatty(fd) {
-            return Ok(None);
-        }
-
-        cfg_if::cfg_if! {
-            if #[cfg(any(target_os = "android", target_os = "redox"))] {
-                Ok(Some("UTF-8".to_owned()))
-            } else if #[cfg(windows)] {
-                use windows_sys::Win32::System::Console;
-                let cp = match fd {
-                    0 => unsafe { Console::GetConsoleCP() },
-                    1 | 2 => unsafe { Console::GetConsoleOutputCP() },
-                    _ => 0,
-                };
-
-                Ok(Some(format!("cp{cp}")))
-            } else {
-                let encoding = unsafe {
-                    let encoding = libc::nl_langinfo(libc::CODESET);
-                    if encoding.is_null() || encoding.read() == '\0' as libc::c_char {
-                        "UTF-8".to_owned()
-                    } else {
-                        ffi::CStr::from_ptr(encoding).to_string_lossy().into_owned()
-                    }
-                };
-
-                Ok(Some(encoding))
-            }
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(module = "os", name = "terminal_size")]
-    #[derive(PyStructSequence)]
-    #[allow(dead_code)]
-    pub(crate) struct PyTerminalSize {
-        pub columns: usize,
-        pub lines: usize,
-    }
-    #[pyclass(with(PyStructSequence))]
-    impl PyTerminalSize {}
-
-    #[pyattr]
-    #[pyclass(module = "os", name = "uname_result")]
-    #[derive(Debug, PyStructSequence)]
-    pub(crate) struct UnameResult {
-        pub sysname: String,
-        pub nodename: String,
-        pub release: String,
-        pub version: String,
-        pub machine: String,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl UnameResult {}
-
-    pub(super) fn support_funcs() -> Vec<SupportFunc> {
-        let mut supports = super::platform::module::support_funcs();
-        supports.extend(vec![
-            SupportFunc::new("open", Some(false), Some(OPEN_DIR_FD), Some(false)),
-            SupportFunc::new("access", Some(false), Some(false), None),
-            SupportFunc::new("chdir", None, Some(false), Some(false)),
-            // chflags Some, None Some
-            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("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("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)),
-            SupportFunc::new("truncate", Some(true), Some(false), Some(false)),
-            SupportFunc::new(
-                "utime",
-                Some(false),
-                Some(UTIME_DIR_FD),
-                Some(cfg!(all(unix, not(target_os = "redox")))),
-            ),
-        ]);
-        supports
-    }
-}
-pub(crate) use _os::{ftruncate, isatty, lseek};
-
-pub(crate) struct SupportFunc {
-    name: &'static str,
-    // realistically, each of these is just a bool of "is this function in the supports_* set".
-    // However, None marks that the function maybe _should_ support fd/dir_fd/follow_symlinks, but
-    // we haven't implemented it yet.
-    fd: Option<bool>,
-    dir_fd: Option<bool>,
-    follow_symlinks: Option<bool>,
-}
-
-impl SupportFunc {
-    pub(crate) const fn new(
-        name: &'static str,
-        fd: Option<bool>,
-        dir_fd: Option<bool>,
-        follow_symlinks: Option<bool>,
-    ) -> Self {
-        Self {
-            name,
-            fd,
-            dir_fd,
-            follow_symlinks,
-        }
-    }
-}
-
-pub fn extend_module(vm: &VirtualMachine, module: &Py<PyModule>) {
-    let support_funcs = _os::support_funcs();
-    let supports_fd = PySet::default().into_ref(&vm.ctx);
-    let supports_dir_fd = PySet::default().into_ref(&vm.ctx);
-    let supports_follow_symlinks = PySet::default().into_ref(&vm.ctx);
-    for support in support_funcs {
-        let func_obj = module.get_attr(support.name, vm).unwrap();
-        if support.fd.unwrap_or(false) {
-            supports_fd.clone().add(func_obj.clone(), vm).unwrap();
-        }
-        if support.dir_fd.unwrap_or(false) {
-            supports_dir_fd.clone().add(func_obj.clone(), vm).unwrap();
-        }
-        if support.follow_symlinks.unwrap_or(false) {
-            supports_follow_symlinks.clone().add(func_obj, vm).unwrap();
-        }
-    }
-
-    extend_module!(vm, module, {
-        "supports_fd" => supports_fd,
-        "supports_dir_fd" => supports_dir_fd,
-        "supports_follow_symlinks" => supports_follow_symlinks,
-        "error" => vm.ctx.exceptions.os_error.to_owned(),
-    });
-}
-
-#[cfg(not(windows))]
-use super::posix as platform;
-
-#[cfg(windows)]
-use super::nt as platform;
-
-pub(crate) use platform::module::MODULE_NAME;
diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs
deleted file mode 100644
index ff59208ade..0000000000
--- a/vm/src/stdlib/signal.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-// spell-checker:disable
-
-use crate::{PyRef, VirtualMachine, builtins::PyModule};
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = _signal::make_module(vm);
-
-    #[cfg(any(unix, windows))]
-    _signal::init_signal_handlers(&module, vm);
-
-    module
-}
-
-#[pymodule]
-pub(crate) mod _signal {
-    #[cfg(any(unix, windows))]
-    use crate::{
-        Py,
-        convert::{IntoPyException, TryFromBorrowedObject},
-    };
-    use crate::{PyObjectRef, PyResult, VirtualMachine, signal};
-    use std::sync::atomic::{self, Ordering};
-
-    #[cfg(any(unix, windows))]
-    use libc::sighandler_t;
-    #[allow(non_camel_case_types)]
-    #[cfg(not(any(unix, windows)))]
-    type sighandler_t = usize;
-
-    cfg_if::cfg_if! {
-        if #[cfg(windows)] {
-            type WakeupFdRaw = libc::SOCKET;
-            struct WakeupFd(WakeupFdRaw);
-            const INVALID_WAKEUP: libc::SOCKET = windows_sys::Win32::Networking::WinSock::INVALID_SOCKET;
-            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);
-
-            impl<'a> TryFromBorrowedObject<'a> for WakeupFd {
-                fn try_from_borrowed_object(vm: &VirtualMachine, obj: &'a crate::PyObject) -> PyResult<Self> {
-                    use num_traits::One;
-
-                    let fd: &crate::Py<crate::builtins::PyInt> = obj.try_to_value(vm)?;
-                    match fd.try_to_primitive::<usize>(vm) {
-                        Ok(fd) => Ok(WakeupFd(fd as _)),
-                        Err(e) => if (-fd.as_bigint()).is_one() {
-                            Ok(WakeupFd(INVALID_WAKEUP))
-                        } else {
-                            Err(e)
-                        },
-                    }
-                }
-            }
-        } else {
-            type WakeupFdRaw = i32;
-            type WakeupFd = WakeupFdRaw;
-            const INVALID_WAKEUP: WakeupFd = -1;
-            static WAKEUP: atomic::AtomicI32 = atomic::AtomicI32::new(INVALID_WAKEUP);
-        }
-    }
-
-    #[cfg(unix)]
-    pub use libc::SIG_ERR;
-    #[cfg(unix)]
-    pub use nix::unistd::alarm as sig_alarm;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub use libc::{SIG_DFL, SIG_IGN};
-
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const SIG_DFL: sighandler_t = 0;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const SIG_IGN: sighandler_t = 1;
-    #[cfg(not(unix))]
-    #[allow(dead_code)]
-    pub const SIG_ERR: sighandler_t = -1 as _;
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    unsafe extern "C" {
-        fn siginterrupt(sig: i32, flag: i32) -> i32;
-    }
-
-    #[pyattr]
-    use crate::signal::NSIG;
-
-    #[cfg(any(unix, windows))]
-    #[pyattr]
-    pub use libc::{SIGABRT, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM};
-
-    #[cfg(unix)]
-    #[pyattr]
-    use libc::{
-        SIGALRM, SIGBUS, SIGCHLD, SIGCONT, SIGHUP, SIGIO, SIGKILL, SIGPIPE, SIGPROF, SIGQUIT,
-        SIGSTOP, SIGSYS, SIGTRAP, SIGTSTP, SIGTTIN, SIGTTOU, SIGURG, SIGUSR1, SIGUSR2, SIGVTALRM,
-        SIGWINCH, SIGXCPU, SIGXFSZ,
-    };
-
-    #[cfg(unix)]
-    #[cfg(not(any(
-        target_vendor = "apple",
-        target_os = "openbsd",
-        target_os = "freebsd",
-        target_os = "netbsd"
-    )))]
-    #[pyattr]
-    use libc::{SIGPWR, SIGSTKFLT};
-
-    #[cfg(any(unix, windows))]
-    pub(super) fn init_signal_handlers(
-        module: &Py<crate::builtins::PyModule>,
-        vm: &VirtualMachine,
-    ) {
-        if vm.state.settings.install_signal_handlers {
-            let sig_dfl = vm.new_pyobj(SIG_DFL as u8);
-            let sig_ign = vm.new_pyobj(SIG_IGN as u8);
-
-            for signum in 1..NSIG {
-                let handler = unsafe { libc::signal(signum as i32, SIG_IGN) };
-                if handler != SIG_ERR {
-                    unsafe { libc::signal(signum as i32, handler) };
-                }
-                let py_handler = if handler == SIG_DFL {
-                    Some(sig_dfl.clone())
-                } else if handler == SIG_IGN {
-                    Some(sig_ign.clone())
-                } else {
-                    None
-                };
-                vm.signal_handlers.as_deref().unwrap().borrow_mut()[signum] = py_handler;
-            }
-
-            let int_handler = module
-                .get_attr("default_int_handler", vm)
-                .expect("_signal does not have this attr?");
-            signal(libc::SIGINT, int_handler, vm).expect("Failed to set sigint handler");
-        }
-    }
-
-    #[cfg(not(any(unix, windows)))]
-    #[pyfunction]
-    pub fn signal(
-        _signalnum: i32,
-        _handler: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<PyObjectRef>> {
-        Err(vm.new_not_implemented_error("signal is not implemented on this platform"))
-    }
-
-    #[cfg(any(unix, windows))]
-    #[pyfunction]
-    pub fn signal(
-        signalnum: i32,
-        handler: PyObjectRef,
-        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"))?;
-
-        let sig_handler =
-            match usize::try_from_borrowed_object(vm, &handler).ok() {
-                Some(SIG_DFL) => SIG_DFL,
-                Some(SIG_IGN) => SIG_IGN,
-                None if handler.is_callable() => run_signal as sighandler_t,
-                _ => return Err(vm.new_type_error(
-                    "signal handler must be signal.SIG_IGN, signal.SIG_DFL, or a callable object",
-                )),
-            };
-        signal::check_signals(vm)?;
-
-        let old = unsafe { libc::signal(signalnum, sig_handler) };
-        if old == SIG_ERR {
-            return Err(vm.new_os_error("Failed to set signal".to_owned()));
-        }
-        #[cfg(all(unix, not(target_os = "redox")))]
-        unsafe {
-            siginterrupt(signalnum, 1);
-        }
-
-        let old_handler = signal_handlers.borrow_mut()[signalnum as usize].replace(handler);
-        Ok(old_handler)
-    }
-
-    #[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 handler = signal_handlers.borrow()[signalnum as usize]
-            .clone()
-            .unwrap_or_else(|| vm.ctx.none());
-        Ok(handler)
-    }
-
-    #[cfg(unix)]
-    #[pyfunction]
-    fn alarm(time: u32) -> u32 {
-        let prev_time = if time == 0 {
-            sig_alarm::cancel()
-        } else {
-            sig_alarm::set(time)
-        };
-        prev_time.unwrap_or(0)
-    }
-
-    #[pyfunction]
-    fn default_int_handler(
-        _signum: PyObjectRef,
-        _arg: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult {
-        Err(vm.new_exception_empty(vm.ctx.exceptions.keyboard_interrupt.to_owned()))
-    }
-
-    #[derive(FromArgs)]
-    struct SetWakeupFdArgs {
-        fd: WakeupFd,
-        #[pyarg(named, default = true)]
-        warn_on_full_buffer: bool,
-    }
-
-    #[pyfunction]
-    fn set_wakeup_fd(args: SetWakeupFdArgs, vm: &VirtualMachine) -> PyResult<WakeupFdRaw> {
-        // TODO: implement warn_on_full_buffer
-        let _ = args.warn_on_full_buffer;
-        #[cfg(windows)]
-        let fd = args.fd.0;
-        #[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"));
-        }
-
-        #[cfg(windows)]
-        let is_socket = if fd != INVALID_WAKEUP {
-            use windows_sys::Win32::Networking::WinSock;
-
-            crate::windows::init_winsock();
-            let mut res = 0i32;
-            let mut res_size = std::mem::size_of::<i32>() as i32;
-            let res = unsafe {
-                WinSock::getsockopt(
-                    fd,
-                    WinSock::SOL_SOCKET,
-                    WinSock::SO_ERROR,
-                    &mut res as *mut i32 as *mut _,
-                    &mut res_size,
-                )
-            };
-            // if getsockopt succeeded, fd is for sure a socket
-            let is_socket = res == 0;
-            if !is_socket {
-                let err = std::io::Error::last_os_error();
-                // if getsockopt failed for some other reason, throw
-                if err.raw_os_error() != Some(WinSock::WSAENOTSOCK) {
-                    return Err(err.into_pyexception(vm));
-                }
-            }
-            is_socket
-        } else {
-            false
-        };
-        #[cfg(unix)]
-        if fd != INVALID_WAKEUP {
-            use nix::fcntl;
-            let oflags = fcntl::fcntl(fd, fcntl::F_GETFL).map_err(|e| e.into_pyexception(vm))?;
-            let nonblock =
-                fcntl::OFlag::from_bits_truncate(oflags).contains(fcntl::OFlag::O_NONBLOCK);
-            if !nonblock {
-                return Err(vm.new_value_error(format!("the fd {fd} must be in non-blocking mode")));
-            }
-        }
-
-        let old_fd = WAKEUP.swap(fd, Ordering::Relaxed);
-        #[cfg(windows)]
-        WAKEUP_IS_SOCKET.store(is_socket, Ordering::Relaxed);
-
-        Ok(old_fd)
-    }
-
-    #[cfg(all(unix, not(target_os = "redox")))]
-    #[pyfunction(name = "siginterrupt")]
-    fn py_siginterrupt(signum: i32, flag: i32, vm: &VirtualMachine) -> PyResult<()> {
-        signal::assert_in_range(signum, vm)?;
-        let res = unsafe { siginterrupt(signum, flag) };
-        if res < 0 {
-            Err(crate::stdlib::os::errno_err(vm))
-        } else {
-            Ok(())
-        }
-    }
-
-    #[cfg(any(unix, windows))]
-    pub extern "C" fn run_signal(signum: i32) {
-        signal::TRIGGERS[signum as usize].store(true, Ordering::Relaxed);
-        signal::set_triggered();
-        let wakeup_fd = WAKEUP.load(Ordering::Relaxed);
-        if wakeup_fd != INVALID_WAKEUP {
-            let sigbyte = signum as u8;
-            #[cfg(windows)]
-            if WAKEUP_IS_SOCKET.load(Ordering::Relaxed) {
-                let _res = unsafe {
-                    windows_sys::Win32::Networking::WinSock::send(
-                        wakeup_fd,
-                        &sigbyte as *const u8 as *const _,
-                        1,
-                        0,
-                    )
-                };
-                return;
-            }
-            let _res = unsafe { libc::write(wakeup_fd as _, &sigbyte as *const u8 as *const _, 1) };
-            // TODO: handle _res < 1, support warn_on_full_buffer
-        }
-    }
-}
diff --git a/vm/src/stdlib/stat.rs b/vm/src/stdlib/stat.rs
deleted file mode 100644
index fdb88b37f0..0000000000
--- a/vm/src/stdlib/stat.rs
+++ /dev/null
@@ -1,571 +0,0 @@
-use crate::{PyRef, VirtualMachine, builtins::PyModule};
-
-#[pymodule]
-mod stat {
-    #[cfg(unix)]
-    use libc;
-
-    // Use libc::mode_t for Mode to match the system's definition
-    #[cfg(unix)]
-    type Mode = libc::mode_t;
-    #[cfg(windows)]
-    type Mode = u16; // Windows does not have mode_t, but stat constants are u16
-    #[cfg(not(any(unix, windows)))]
-    type Mode = u32; // Fallback for unknown targets
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFDIR: Mode = libc::S_IFDIR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFDIR: Mode = 0o040000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFCHR: Mode = libc::S_IFCHR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFCHR: Mode = 0o020000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFBLK: Mode = libc::S_IFBLK;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFBLK: Mode = 0o060000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFREG: Mode = libc::S_IFREG;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFREG: Mode = 0o100000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFIFO: Mode = libc::S_IFIFO;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFIFO: Mode = 0o010000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFLNK: Mode = libc::S_IFLNK;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFLNK: Mode = 0o120000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IFSOCK: Mode = libc::S_IFSOCK;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IFSOCK: Mode = 0o140000;
-
-    // TODO: RUSTPYTHON Support Solaris
-    #[pyattr]
-    pub const S_IFDOOR: Mode = 0;
-
-    // TODO: RUSTPYTHON Support Solaris
-    #[pyattr]
-    pub const S_IFPORT: Mode = 0;
-
-    // TODO: RUSTPYTHON Support BSD
-    // https://man.freebsd.org/cgi/man.cgi?stat(2)
-    #[pyattr]
-    pub const S_IFWHT: Mode = 0;
-
-    // Permission bits
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_ISUID: Mode = libc::S_ISUID;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_ISUID: Mode = 0o4000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_ISGID: Mode = libc::S_ISGID;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_ISGID: Mode = 0o2000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_ENFMT: Mode = libc::S_ISGID;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_ENFMT: Mode = 0o2000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_ISVTX: Mode = libc::S_ISVTX;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_ISVTX: Mode = 0o1000;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IRWXU: Mode = libc::S_IRWXU;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IRWXU: Mode = 0o0700;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IRUSR: Mode = libc::S_IRUSR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IRUSR: Mode = 0o0400;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IREAD: Mode = libc::S_IRUSR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IREAD: Mode = 0o0400;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IWUSR: Mode = libc::S_IWUSR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IWUSR: Mode = 0o0200;
-
-    #[cfg(all(unix, not(target_os = "android"), not(target_os = "redox")))]
-    #[pyattr]
-    pub const S_IWRITE: Mode = libc::S_IWRITE;
-    #[cfg(any(not(unix), target_os = "android", target_os = "redox"))]
-    #[pyattr]
-    pub const S_IWRITE: Mode = 0o0200;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IXUSR: Mode = libc::S_IXUSR;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IXUSR: Mode = 0o0100;
-
-    #[cfg(all(unix, not(target_os = "android"), not(target_os = "redox")))]
-    #[pyattr]
-    pub const S_IEXEC: Mode = libc::S_IEXEC;
-    #[cfg(any(not(unix), target_os = "android", target_os = "redox"))]
-    #[pyattr]
-    pub const S_IEXEC: Mode = 0o0100;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IRWXG: Mode = libc::S_IRWXG;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IRWXG: Mode = 0o0070;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IRGRP: Mode = libc::S_IRGRP;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IRGRP: Mode = 0o0040;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IWGRP: Mode = libc::S_IWGRP;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IWGRP: Mode = 0o0020;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IXGRP: Mode = libc::S_IXGRP;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IXGRP: Mode = 0o0010;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IRWXO: Mode = libc::S_IRWXO;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IRWXO: Mode = 0o0007;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IROTH: Mode = libc::S_IROTH;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IROTH: Mode = 0o0004;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IWOTH: Mode = libc::S_IWOTH;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IWOTH: Mode = 0o0002;
-
-    #[cfg(unix)]
-    #[pyattr]
-    pub const S_IXOTH: Mode = libc::S_IXOTH;
-    #[cfg(not(unix))]
-    #[pyattr]
-    pub const S_IXOTH: Mode = 0o0001;
-
-    // Stat result indices
-    #[pyattr]
-    pub const ST_MODE: u32 = 0;
-
-    #[pyattr]
-    pub const ST_INO: u32 = 1;
-
-    #[pyattr]
-    pub const ST_DEV: u32 = 2;
-
-    #[pyattr]
-    pub const ST_NLINK: u32 = 3;
-
-    #[pyattr]
-    pub const ST_UID: u32 = 4;
-
-    #[pyattr]
-    pub const ST_GID: u32 = 5;
-
-    #[pyattr]
-    pub const ST_SIZE: u32 = 6;
-
-    #[pyattr]
-    pub const ST_ATIME: u32 = 7;
-
-    #[pyattr]
-    pub const ST_MTIME: u32 = 8;
-
-    #[pyattr]
-    pub const ST_CTIME: u32 = 9;
-
-    const S_IFMT: Mode = 0o170000;
-
-    const S_IMODE: Mode = 0o7777;
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISDIR(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFDIR
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISCHR(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFCHR
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISREG(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFREG
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISBLK(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFBLK
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISFIFO(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFIFO
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISLNK(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFLNK
-    }
-
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISSOCK(mode: Mode) -> bool {
-        (mode & S_IFMT) == S_IFSOCK
-    }
-
-    // TODO: RUSTPYTHON Support Solaris
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISDOOR(_mode: Mode) -> bool {
-        false
-    }
-
-    // TODO: RUSTPYTHON Support Solaris
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISPORT(_mode: Mode) -> bool {
-        false
-    }
-
-    // TODO: RUSTPYTHON Support BSD
-    #[pyfunction]
-    #[allow(non_snake_case)]
-    const fn S_ISWHT(_mode: Mode) -> bool {
-        false
-    }
-
-    #[pyfunction(name = "S_IMODE")]
-    #[allow(non_snake_case)]
-    const fn S_IMODE_method(mode: Mode) -> Mode {
-        mode & S_IMODE
-    }
-
-    #[pyfunction(name = "S_IFMT")]
-    #[allow(non_snake_case)]
-    const fn S_IFMT_method(mode: Mode) -> Mode {
-        // 0o170000 is from the S_IFMT definition in CPython include/fileutils.h
-        mode & S_IFMT
-    }
-
-    #[pyfunction]
-    const fn filetype(mode: Mode) -> char {
-        if S_ISREG(mode) {
-            '-'
-        } else if S_ISDIR(mode) {
-            'd'
-        } else if S_ISLNK(mode) {
-            'l'
-        } else if S_ISBLK(mode) {
-            'b'
-        } else if S_ISCHR(mode) {
-            'c'
-        } else if S_ISFIFO(mode) {
-            'p'
-        } else if S_ISSOCK(mode) {
-            's'
-        } else if S_ISDOOR(mode) {
-            'D' // TODO: RUSTPYTHON Support Solaris
-        } else if S_ISPORT(mode) {
-            'P' // TODO: RUSTPYTHON Support Solaris
-        } else if S_ISWHT(mode) {
-            'w' // TODO: RUSTPYTHON Support BSD
-        } else {
-            '?' // Unknown file type
-        }
-    }
-
-    // Convert file mode to string representation
-    #[pyfunction]
-    fn filemode(mode: Mode) -> String {
-        let mut result = String::with_capacity(10);
-
-        // File type
-        result.push(filetype(mode));
-
-        // User permissions
-        result.push(if mode & S_IRUSR != 0 { 'r' } else { '-' });
-        result.push(if mode & S_IWUSR != 0 { 'w' } else { '-' });
-        if mode & S_ISUID != 0 {
-            result.push(if mode & S_IXUSR != 0 { 's' } else { 'S' });
-        } else {
-            result.push(if mode & S_IXUSR != 0 { 'x' } else { '-' });
-        }
-
-        // Group permissions
-        result.push(if mode & S_IRGRP != 0 { 'r' } else { '-' });
-        result.push(if mode & S_IWGRP != 0 { 'w' } else { '-' });
-        if mode & S_ISGID != 0 {
-            result.push(if mode & S_IXGRP != 0 { 's' } else { 'S' });
-        } else {
-            result.push(if mode & S_IXGRP != 0 { 'x' } else { '-' });
-        }
-
-        // Other permissions
-        result.push(if mode & S_IROTH != 0 { 'r' } else { '-' });
-        result.push(if mode & S_IWOTH != 0 { 'w' } else { '-' });
-        if mode & S_ISVTX != 0 {
-            result.push(if mode & S_IXOTH != 0 { 't' } else { 'T' });
-        } else {
-            result.push(if mode & S_IXOTH != 0 { 'x' } else { '-' });
-        }
-
-        result
-    }
-
-    // Windows file attributes (if on Windows)
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_ARCHIVE: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_ARCHIVE;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_COMPRESSED: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_COMPRESSED;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_DEVICE: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_DEVICE;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_DIRECTORY: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_DIRECTORY;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_ENCRYPTED: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_ENCRYPTED;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_HIDDEN: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_HIDDEN;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_INTEGRITY_STREAM: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_INTEGRITY_STREAM;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_NORMAL: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_NORMAL;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_NO_SCRUB_DATA: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_NO_SCRUB_DATA;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_OFFLINE: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_OFFLINE;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_READONLY: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_READONLY;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_REPARSE_POINT: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_SPARSE_FILE: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_SPARSE_FILE;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_SYSTEM: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_SYSTEM;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_TEMPORARY: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_TEMPORARY;
-
-    #[cfg(windows)]
-    #[pyattr]
-    pub const FILE_ATTRIBUTE_VIRTUAL: u32 =
-        windows_sys::Win32::Storage::FileSystem::FILE_ATTRIBUTE_VIRTUAL;
-
-    // Unix file flags (if on Unix)
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_NODUMP: u32 = libc::UF_NODUMP;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_NODUMP: u32 = 0x00000001;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_IMMUTABLE: u32 = libc::UF_IMMUTABLE;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_IMMUTABLE: u32 = 0x00000002;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_APPEND: u32 = libc::UF_APPEND;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_APPEND: u32 = 0x00000004;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_OPAQUE: u32 = libc::UF_OPAQUE;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_OPAQUE: u32 = 0x00000008;
-
-    #[pyattr]
-    pub const UF_NOUNLINK: u32 = 0x00000010;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_COMPRESSED: u32 = libc::UF_COMPRESSED;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_COMPRESSED: u32 = 0x00000020;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const UF_HIDDEN: u32 = libc::UF_HIDDEN;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const UF_HIDDEN: u32 = 0x00008000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_ARCHIVED: u32 = libc::SF_ARCHIVED;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const SF_ARCHIVED: u32 = 0x00010000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_IMMUTABLE: u32 = libc::SF_IMMUTABLE;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const SF_IMMUTABLE: u32 = 0x00020000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_APPEND: u32 = libc::SF_APPEND;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const SF_APPEND: u32 = 0x00040000;
-
-    #[pyattr]
-    pub const SF_NOUNLINK: u32 = 0x00100000;
-
-    #[pyattr]
-    pub const SF_SNAPSHOT: u32 = 0x00200000;
-
-    #[pyattr]
-    pub const SF_FIRMLINK: u32 = 0x00800000;
-
-    #[pyattr]
-    pub const SF_DATALESS: u32 = 0x40000000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_SUPPORTED: u32 = 0x009f0000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_SETTABLE: u32 = 0x3fff0000;
-    #[cfg(not(target_os = "macos"))]
-    #[pyattr]
-    pub const SF_SETTABLE: u32 = 0xffff0000;
-
-    #[cfg(target_os = "macos")]
-    #[pyattr]
-    pub const SF_SYNTHETIC: u32 = 0xc0000000;
-}
-
-pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    stat::make_module(vm)
-}
diff --git a/vm/src/stdlib/string.rs b/vm/src/stdlib/string.rs
deleted file mode 100644
index 576cae6277..0000000000
--- a/vm/src/stdlib/string.rs
+++ /dev/null
@@ -1,99 +0,0 @@
-/* String builtin module
- */
-
-pub(crate) use _string::make_module;
-
-#[pymodule]
-mod _string {
-    use crate::common::ascii;
-    use crate::common::format::{
-        FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate,
-    };
-    use crate::common::wtf8::{CodePoint, Wtf8Buf};
-    use crate::{
-        PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyList, PyStrRef},
-        convert::ToPyException,
-        convert::ToPyObject,
-    };
-    use std::mem;
-
-    fn create_format_part(
-        literal: Wtf8Buf,
-        field_name: Option<Wtf8Buf>,
-        format_spec: Option<Wtf8Buf>,
-        conversion_spec: Option<CodePoint>,
-        vm: &VirtualMachine,
-    ) -> PyObjectRef {
-        let tuple = (
-            literal,
-            field_name,
-            format_spec,
-            conversion_spec.map(|c| c.to_string()),
-        );
-        tuple.to_pyobject(vm)
-    }
-
-    #[pyfunction]
-    fn formatter_parser(text: PyStrRef, vm: &VirtualMachine) -> PyResult<PyList> {
-        let format_string =
-            FormatString::from_str(text.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
-
-        let mut result: Vec<PyObjectRef> = Vec::new();
-        let mut literal = Wtf8Buf::new();
-        for part in format_string.format_parts {
-            match part {
-                FormatPart::Field {
-                    field_name,
-                    conversion_spec,
-                    format_spec,
-                } => {
-                    result.push(create_format_part(
-                        mem::take(&mut literal),
-                        Some(field_name),
-                        Some(format_spec),
-                        conversion_spec,
-                        vm,
-                    ));
-                }
-                FormatPart::Literal(text) => literal.push_wtf8(&text),
-            }
-        }
-        if !literal.is_empty() {
-            result.push(create_format_part(
-                mem::take(&mut literal),
-                None,
-                None,
-                None,
-                vm,
-            ));
-        }
-        Ok(result.into())
-    }
-
-    #[pyfunction]
-    fn formatter_field_name_split(
-        text: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<(PyObjectRef, PyList)> {
-        let field_name = FieldName::parse(text.as_wtf8()).map_err(|e| e.to_pyexception(vm))?;
-
-        let first = match field_name.field_type {
-            FieldType::Auto => vm.ctx.new_str(ascii!("")).into(),
-            FieldType::Index(index) => index.to_pyobject(vm),
-            FieldType::Keyword(attribute) => attribute.to_pyobject(vm),
-        };
-
-        let rest = field_name
-            .parts
-            .iter()
-            .map(|p| match p {
-                FieldNamePart::Attribute(attribute) => (true, attribute).to_pyobject(vm),
-                FieldNamePart::StringIndex(index) => (false, index).to_pyobject(vm),
-                FieldNamePart::Index(index) => (false, *index).to_pyobject(vm),
-            })
-            .collect();
-
-        Ok((first, rest))
-    }
-}
diff --git a/vm/src/stdlib/symtable.rs b/vm/src/stdlib/symtable.rs
deleted file mode 100644
index 9178006b36..0000000000
--- a/vm/src/stdlib/symtable.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-pub(crate) use symtable::make_module;
-
-#[pymodule]
-mod symtable {
-    use crate::{
-        PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine, builtins::PyStrRef, compiler,
-    };
-    use rustpython_codegen::symboltable::{
-        Symbol, SymbolFlags, SymbolScope, SymbolTable, SymbolTableType,
-    };
-    use std::fmt;
-
-    #[pyfunction]
-    fn symtable(
-        source: PyStrRef,
-        filename: PyStrRef,
-        mode: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<PyRef<PySymbolTable>> {
-        let mode = mode
-            .as_str()
-            .parse::<compiler::Mode>()
-            .map_err(|err| vm.new_value_error(err.to_string()))?;
-
-        let symtable = compiler::compile_symtable(source.as_str(), mode, filename.as_str())
-            .map_err(|err| vm.new_syntax_error(&err, Some(source.as_str())))?;
-
-        let py_symbol_table = to_py_symbol_table(symtable);
-        Ok(py_symbol_table.into_ref(&vm.ctx))
-    }
-
-    const fn to_py_symbol_table(symtable: SymbolTable) -> PySymbolTable {
-        PySymbolTable { symtable }
-    }
-
-    #[pyattr]
-    #[pyclass(name = "SymbolTable")]
-    #[derive(PyPayload)]
-    struct PySymbolTable {
-        symtable: SymbolTable,
-    }
-
-    impl fmt::Debug for PySymbolTable {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            write!(f, "SymbolTable()")
-        }
-    }
-
-    #[pyclass]
-    impl PySymbolTable {
-        #[pymethod]
-        fn get_name(&self) -> String {
-            self.symtable.name.clone()
-        }
-
-        #[pymethod]
-        fn get_type(&self) -> String {
-            self.symtable.typ.to_string()
-        }
-
-        #[pymethod]
-        const fn get_lineno(&self) -> u32 {
-            self.symtable.line_number
-        }
-
-        #[pymethod]
-        const fn is_nested(&self) -> bool {
-            self.symtable.is_nested
-        }
-
-        #[pymethod]
-        fn is_optimized(&self) -> bool {
-            self.symtable.typ == SymbolTableType::Function
-        }
-
-        #[pymethod]
-        fn lookup(&self, name: PyStrRef, vm: &VirtualMachine) -> PyResult<PyRef<PySymbol>> {
-            let name = name.as_str();
-            if let Some(symbol) = self.symtable.symbols.get(name) {
-                Ok(PySymbol {
-                    symbol: symbol.clone(),
-                    namespaces: self
-                        .symtable
-                        .sub_tables
-                        .iter()
-                        .filter(|table| table.name == name)
-                        .cloned()
-                        .collect(),
-                    is_top_scope: self.symtable.name == "top",
-                }
-                .into_ref(&vm.ctx))
-            } else {
-                Err(vm.new_key_error(vm.ctx.new_str(format!("lookup {name} failed")).into()))
-            }
-        }
-
-        #[pymethod]
-        fn get_identifiers(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-            let symbols = self
-                .symtable
-                .symbols
-                .keys()
-                .map(|s| vm.ctx.new_str(s.as_str()).into())
-                .collect();
-            Ok(symbols)
-        }
-
-        #[pymethod]
-        fn get_symbols(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-            let symbols = self
-                .symtable
-                .symbols
-                .values()
-                .map(|s| {
-                    (PySymbol {
-                        symbol: s.clone(),
-                        namespaces: self
-                            .symtable
-                            .sub_tables
-                            .iter()
-                            .filter(|&table| table.name == s.name)
-                            .cloned()
-                            .collect(),
-                        is_top_scope: self.symtable.name == "top",
-                    })
-                    .into_ref(&vm.ctx)
-                    .into()
-                })
-                .collect();
-            Ok(symbols)
-        }
-
-        #[pymethod]
-        const fn has_children(&self) -> bool {
-            !self.symtable.sub_tables.is_empty()
-        }
-
-        #[pymethod]
-        fn get_children(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-            let children = self
-                .symtable
-                .sub_tables
-                .iter()
-                .map(|t| to_py_symbol_table(t.clone()).into_pyobject(vm))
-                .collect();
-            Ok(children)
-        }
-    }
-
-    #[pyattr]
-    #[pyclass(name = "Symbol")]
-    #[derive(PyPayload)]
-    struct PySymbol {
-        symbol: Symbol,
-        namespaces: Vec<SymbolTable>,
-        is_top_scope: bool,
-    }
-
-    impl fmt::Debug for PySymbol {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            write!(f, "Symbol()")
-        }
-    }
-
-    #[pyclass]
-    impl PySymbol {
-        #[pymethod]
-        fn get_name(&self) -> String {
-            self.symbol.name.clone()
-        }
-
-        #[pymethod]
-        const fn is_global(&self) -> bool {
-            self.symbol.is_global() || (self.is_top_scope && self.symbol.is_bound())
-        }
-
-        #[pymethod]
-        const fn is_declared_global(&self) -> bool {
-            matches!(self.symbol.scope, SymbolScope::GlobalExplicit)
-        }
-
-        #[pymethod]
-        const fn is_local(&self) -> bool {
-            self.symbol.is_local() || (self.is_top_scope && self.symbol.is_bound())
-        }
-
-        #[pymethod]
-        const fn is_imported(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::IMPORTED)
-        }
-
-        #[pymethod]
-        const fn is_nested(&self) -> bool {
-            // TODO
-            false
-        }
-
-        #[pymethod]
-        const fn is_nonlocal(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::NONLOCAL)
-        }
-
-        #[pymethod]
-        const fn is_referenced(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::REFERENCED)
-        }
-
-        #[pymethod]
-        const fn is_assigned(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::ASSIGNED)
-        }
-
-        #[pymethod]
-        const fn is_parameter(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::PARAMETER)
-        }
-
-        #[pymethod]
-        const fn is_free(&self) -> bool {
-            matches!(self.symbol.scope, SymbolScope::Free)
-        }
-
-        #[pymethod]
-        const fn is_namespace(&self) -> bool {
-            !self.namespaces.is_empty()
-        }
-
-        #[pymethod]
-        const fn is_annotated(&self) -> bool {
-            self.symbol.flags.contains(SymbolFlags::ANNOTATED)
-        }
-
-        #[pymethod]
-        fn get_namespaces(&self, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-            let namespaces = self
-                .namespaces
-                .iter()
-                .map(|table| to_py_symbol_table(table.clone()).into_pyobject(vm))
-                .collect();
-            Ok(namespaces)
-        }
-
-        #[pymethod]
-        fn get_namespace(&self, vm: &VirtualMachine) -> PyResult {
-            if self.namespaces.len() != 1 {
-                return Err(vm.new_value_error("namespace is bound to multiple namespaces"));
-            }
-            Ok(to_py_symbol_table(self.namespaces.first().unwrap().clone())
-                .into_ref(&vm.ctx)
-                .into())
-        }
-    }
-}
diff --git a/vm/src/stdlib/sys.rs b/vm/src/stdlib/sys.rs
deleted file mode 100644
index 4a4d60ef2a..0000000000
--- a/vm/src/stdlib/sys.rs
+++ /dev/null
@@ -1,1234 +0,0 @@
-use crate::{Py, PyResult, VirtualMachine, builtins::PyModule, convert::ToPyObject};
-
-pub(crate) use sys::{__module_def, DOC, MAXSIZE, MULTIARCH, UnraisableHookArgs};
-
-#[pymodule]
-mod sys {
-    use crate::{
-        AsObject, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult,
-        builtins::{
-            PyBaseExceptionRef, PyDictRef, PyNamespace, PyStr, PyStrRef, PyTupleRef, PyTypeRef,
-        },
-        common::{
-            ascii,
-            hash::{PyHash, PyUHash},
-        },
-        convert::ToPyObject,
-        frame::FrameRef,
-        function::{FuncArgs, OptionalArg, PosArgs},
-        stdlib::{builtins, warnings::warn},
-        types::PyStructSequence,
-        version,
-        vm::{Settings, VirtualMachine},
-    };
-    use num_traits::ToPrimitive;
-    #[cfg(windows)]
-    use std::os::windows::ffi::OsStrExt;
-    use std::{
-        env::{self, VarError},
-        io::Read,
-        path,
-        sync::atomic::Ordering,
-    };
-
-    #[cfg(windows)]
-    use windows_sys::Win32::{
-        Foundation::MAX_PATH,
-        Storage::FileSystem::{
-            GetFileVersionInfoSizeW, GetFileVersionInfoW, VS_FIXEDFILEINFO, VerQueryValueW,
-        },
-        System::LibraryLoader::{GetModuleFileNameW, GetModuleHandleW},
-    };
-
-    // not the same as CPython (e.g. rust's x86_x64-unknown-linux-gnu is just x86_64-linux-gnu)
-    // but hopefully that's just an implementation detail? TODO: copy CPython's multiarch exactly,
-    // https://github.com/python/cpython/blob/3.8/configure.ac#L725
-    pub(crate) const MULTIARCH: &str = env!("RUSTPYTHON_TARGET_TRIPLE");
-
-    #[pyattr(name = "_rustpython_debugbuild")]
-    const RUSTPYTHON_DEBUGBUILD: bool = cfg!(debug_assertions);
-
-    #[pyattr(name = "abiflags")]
-    pub(crate) const ABIFLAGS: &str = "";
-    #[pyattr(name = "api_version")]
-    const API_VERSION: u32 = 0x0; // what C api?
-    #[pyattr(name = "copyright")]
-    const COPYRIGHT: &str = "Copyright (c) 2019 RustPython Team";
-    #[pyattr(name = "float_repr_style")]
-    const FLOAT_REPR_STYLE: &str = "short";
-    #[pyattr(name = "_framework")]
-    const FRAMEWORK: &str = "";
-    #[pyattr(name = "hexversion")]
-    const HEXVERSION: usize = version::VERSION_HEX;
-    #[pyattr(name = "maxsize")]
-    pub(crate) const MAXSIZE: isize = isize::MAX;
-    #[pyattr(name = "maxunicode")]
-    const MAXUNICODE: u32 = std::char::MAX as u32;
-    #[pyattr(name = "platform")]
-    pub(crate) const PLATFORM: &str = {
-        cfg_if::cfg_if! {
-            if #[cfg(target_os = "linux")] {
-                "linux"
-            } else if #[cfg(target_os = "android")] {
-                "android"
-            } else if #[cfg(target_os = "macos")] {
-                "darwin"
-            } else if #[cfg(target_os = "ios")] {
-                "ios"
-            } else if #[cfg(windows)] {
-                "win32"
-            } else if #[cfg(target_os = "wasi")] {
-                "wasi"
-            } else {
-                "unknown"
-            }
-        }
-    };
-    #[pyattr(name = "ps1")]
-    const PS1: &str = ">>>>> ";
-    #[pyattr(name = "ps2")]
-    const PS2: &str = "..... ";
-
-    #[cfg(windows)]
-    #[pyattr(name = "_vpath")]
-    const VPATH: Option<&'static str> = None; // TODO: actual VPATH value
-
-    #[cfg(windows)]
-    #[pyattr(name = "dllhandle")]
-    const DLLHANDLE: usize = 0;
-
-    #[pyattr]
-    const fn default_prefix(_vm: &VirtualMachine) -> &'static str {
-        // TODO: the windows one doesn't really make sense
-        if cfg!(windows) { "C:" } else { "/usr/local" }
-    }
-    #[pyattr]
-    fn prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_PREFIX").unwrap_or_else(|| default_prefix(vm))
-    }
-    #[pyattr]
-    fn base_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| prefix(vm))
-    }
-    #[pyattr]
-    fn exec_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| prefix(vm))
-    }
-    #[pyattr]
-    fn base_exec_prefix(vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_BASEPREFIX").unwrap_or_else(|| exec_prefix(vm))
-    }
-    #[pyattr]
-    fn platlibdir(_vm: &VirtualMachine) -> &'static str {
-        option_env!("RUSTPYTHON_PLATLIBDIR").unwrap_or("lib")
-    }
-
-    // alphabetical order with segments of pyattr and others
-
-    #[pyattr]
-    fn argv(vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        vm.state
-            .settings
-            .argv
-            .iter()
-            .map(|arg| vm.ctx.new_str(arg.clone()).into())
-            .collect()
-    }
-
-    #[pyattr]
-    fn builtin_module_names(vm: &VirtualMachine) -> PyTupleRef {
-        let mut module_names: Vec<_> = vm.state.module_inits.keys().cloned().collect();
-        module_names.push("sys".into());
-        module_names.push("builtins".into());
-        module_names.sort();
-        vm.ctx.new_tuple(
-            module_names
-                .into_iter()
-                .map(|n| vm.ctx.new_str(n).into())
-                .collect(),
-        )
-    }
-
-    #[pyattr]
-    fn byteorder(vm: &VirtualMachine) -> PyStrRef {
-        // https://doc.rust-lang.org/reference/conditional-compilation.html#target_endian
-        vm.ctx
-            .intern_str(if cfg!(target_endian = "little") {
-                "little"
-            } else if cfg!(target_endian = "big") {
-                "big"
-            } else {
-                "unknown"
-            })
-            .to_owned()
-    }
-
-    #[pyattr]
-    fn _base_executable(vm: &VirtualMachine) -> PyObjectRef {
-        let ctx = &vm.ctx;
-        if let Ok(var) = env::var("__PYVENV_LAUNCHER__") {
-            ctx.new_str(var).into()
-        } else {
-            executable(vm)
-        }
-    }
-
-    #[pyattr]
-    fn dont_write_bytecode(vm: &VirtualMachine) -> bool {
-        !vm.state.settings.write_bytecode
-    }
-
-    #[pyattr]
-    fn executable(vm: &VirtualMachine) -> PyObjectRef {
-        let ctx = &vm.ctx;
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            if let Some(exec_path) = env::args_os().next() {
-                if let Ok(path) = which::which(exec_path) {
-                    return ctx
-                        .new_str(
-                            path.into_os_string()
-                                .into_string()
-                                .unwrap_or_else(|p| p.to_string_lossy().into_owned()),
-                        )
-                        .into();
-                }
-            }
-        }
-        if let Some(exec_path) = env::args().next() {
-            let path = path::Path::new(&exec_path);
-            if !path.exists() {
-                return ctx.new_str(ascii!("")).into();
-            }
-            if path.is_absolute() {
-                return ctx.new_str(exec_path).into();
-            }
-            if let Ok(dir) = env::current_dir() {
-                if let Ok(dir) = dir.into_os_string().into_string() {
-                    return ctx
-                        .new_str(format!(
-                            "{}/{}",
-                            dir,
-                            exec_path.strip_prefix("./").unwrap_or(&exec_path)
-                        ))
-                        .into();
-                }
-            }
-        }
-        ctx.none()
-    }
-
-    #[pyattr]
-    fn _git(vm: &VirtualMachine) -> PyTupleRef {
-        vm.new_tuple((
-            ascii!("RustPython"),
-            version::get_git_identifier(),
-            version::get_git_revision(),
-        ))
-    }
-
-    #[pyattr]
-    fn implementation(vm: &VirtualMachine) -> PyRef<PyNamespace> {
-        // TODO: Add crate version to this namespace
-        let ctx = &vm.ctx;
-        py_namespace!(vm, {
-            "name" => ctx.new_str(ascii!("rustpython")),
-            "cache_tag" => ctx.new_str(ascii!("rustpython-01")),
-            "_multiarch" => ctx.new_str(MULTIARCH.to_owned()),
-            "version" => version_info(vm),
-            "hexversion" => ctx.new_int(version::VERSION_HEX),
-        })
-    }
-
-    #[pyattr]
-    const fn meta_path(_vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        Vec::new()
-    }
-
-    #[pyattr]
-    fn orig_argv(vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        env::args().map(|arg| vm.ctx.new_str(arg).into()).collect()
-    }
-
-    #[pyattr]
-    fn path(vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        vm.state
-            .settings
-            .path_list
-            .iter()
-            .map(|path| vm.ctx.new_str(path.clone()).into())
-            .collect()
-    }
-
-    #[pyattr]
-    const fn path_hooks(_vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        Vec::new()
-    }
-
-    #[pyattr]
-    fn path_importer_cache(vm: &VirtualMachine) -> PyDictRef {
-        vm.ctx.new_dict()
-    }
-
-    #[pyattr]
-    fn pycache_prefix(vm: &VirtualMachine) -> PyObjectRef {
-        vm.ctx.none()
-    }
-
-    #[pyattr]
-    fn version(_vm: &VirtualMachine) -> String {
-        version::get_version()
-    }
-
-    #[cfg(windows)]
-    #[pyattr]
-    fn winver(_vm: &VirtualMachine) -> String {
-        // Note: This is Python DLL version in CPython, but we arbitrary fill it for compatibility
-        version::get_winver_number()
-    }
-
-    #[pyattr]
-    fn _xoptions(vm: &VirtualMachine) -> PyDictRef {
-        let ctx = &vm.ctx;
-        let xopts = ctx.new_dict();
-        for (key, value) in &vm.state.settings.xoptions {
-            let value = value.as_ref().map_or_else(
-                || ctx.new_bool(true).into(),
-                |s| ctx.new_str(s.clone()).into(),
-            );
-            xopts.set_item(&**key, value, vm).unwrap();
-        }
-        xopts
-    }
-
-    #[pyattr]
-    fn warnoptions(vm: &VirtualMachine) -> Vec<PyObjectRef> {
-        vm.state
-            .settings
-            .warnoptions
-            .iter()
-            .map(|s| vm.ctx.new_str(s.clone()).into())
-            .collect()
-    }
-
-    #[cfg(feature = "rustpython-compiler")]
-    #[pyfunction]
-    fn _baserepl(vm: &VirtualMachine) -> PyResult<()> {
-        // read stdin to end
-        let stdin = std::io::stdin();
-        let mut handle = stdin.lock();
-        let mut source = String::new();
-        handle
-            .read_to_string(&mut source)
-            .map_err(|e| vm.new_os_error(format!("Error reading from stdin: {e}")))?;
-        vm.compile(&source, crate::compiler::Mode::Single, "<stdin>".to_owned())
-            .map_err(|e| vm.new_os_error(format!("Error running stdin: {e}")))?;
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn audit(_args: FuncArgs) {
-        // TODO: sys.audit implementation
-    }
-
-    #[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]))
-    }
-
-    #[pyfunction]
-    fn exception(vm: &VirtualMachine) -> Option<PyBaseExceptionRef> {
-        vm.topmost_exception()
-    }
-
-    #[pyfunction(name = "__displayhook__")]
-    #[pyfunction]
-    fn displayhook(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        // Save non-None values as "_"
-        if vm.is_none(&obj) {
-            return Ok(());
-        }
-        // set to none to avoid recursion while printing
-        vm.builtins.set_attr("_", vm.ctx.none(), vm)?;
-        // TODO: catch encoding errors
-        let repr = obj.repr(vm)?.into();
-        builtins::print(PosArgs::new(vec![repr]), Default::default(), vm)?;
-        vm.builtins.set_attr("_", obj, vm)?;
-        Ok(())
-    }
-
-    #[pyfunction(name = "__excepthook__")]
-    #[pyfunction]
-    fn excepthook(
-        exc_type: PyObjectRef,
-        exc_val: PyObjectRef,
-        exc_tb: PyObjectRef,
-        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),
-            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"
-                );
-                use crate::py_io::Write;
-                write!(&mut crate::py_io::PyWriter(stderr, vm), "{msg}")?;
-                Ok(())
-            }
-        }
-    }
-
-    #[pyfunction(name = "__breakpointhook__")]
-    #[pyfunction]
-    pub fn breakpointhook(args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let env_var = std::env::var("PYTHONBREAKPOINT")
-            .and_then(|env_var| {
-                if env_var.is_empty() {
-                    Err(VarError::NotPresent)
-                } else {
-                    Ok(env_var)
-                }
-            })
-            .unwrap_or_else(|_| "pdb.set_trace".to_owned());
-
-        if env_var.eq("0") {
-            return Ok(vm.ctx.none());
-        };
-
-        let print_unimportable_module_warn = || {
-            warn(
-                vm.ctx.exceptions.runtime_warning,
-                format!("Ignoring unimportable $PYTHONBREAKPOINT: \"{env_var}\"",),
-                0,
-                vm,
-            )
-            .unwrap();
-            Ok(vm.ctx.none())
-        };
-
-        let last = match env_var.rsplit_once('.') {
-            Some((_, last)) => last,
-            None if !env_var.is_empty() => env_var.as_str(),
-            _ => return print_unimportable_module_warn(),
-        };
-
-        let (module_path, attr_name) = if last == env_var {
-            ("builtins", env_var.as_str())
-        } else {
-            (&env_var[..(env_var.len() - last.len() - 1)], last)
-        };
-
-        let module = match vm.import(&vm.ctx.new_str(module_path), 0) {
-            Ok(module) => module,
-            Err(_) => {
-                return print_unimportable_module_warn();
-            }
-        };
-
-        match vm.get_attribute_opt(module, &vm.ctx.new_str(attr_name)) {
-            Ok(Some(hook)) => hook.as_ref().call(args, vm),
-            _ => print_unimportable_module_warn(),
-        }
-    }
-
-    #[pyfunction]
-    fn exc_info(vm: &VirtualMachine) -> (PyObjectRef, PyObjectRef, PyObjectRef) {
-        match vm.topmost_exception() {
-            Some(exception) => vm.split_exception(exception),
-            None => (vm.ctx.none(), vm.ctx.none(), vm.ctx.none()),
-        }
-    }
-
-    #[pyattr]
-    fn flags(vm: &VirtualMachine) -> PyTupleRef {
-        Flags::from_settings(&vm.state.settings).into_struct_sequence(vm)
-    }
-
-    #[pyattr]
-    fn float_info(vm: &VirtualMachine) -> PyTupleRef {
-        PyFloatInfo::INFO.into_struct_sequence(vm)
-    }
-
-    #[pyfunction]
-    const fn getdefaultencoding() -> &'static str {
-        crate::codecs::DEFAULT_ENCODING
-    }
-
-    #[pyfunction]
-    fn getrefcount(obj: PyObjectRef) -> usize {
-        obj.strong_count()
-    }
-
-    #[pyfunction]
-    fn getrecursionlimit(vm: &VirtualMachine) -> usize {
-        vm.recursion_limit.get()
-    }
-
-    #[derive(FromArgs)]
-    struct GetsizeofArgs {
-        obj: PyObjectRef,
-        #[pyarg(any, optional)]
-        default: Option<PyObjectRef>,
-    }
-
-    #[pyfunction]
-    fn getsizeof(args: GetsizeofArgs, vm: &VirtualMachine) -> PyResult {
-        let sizeof = || -> PyResult<usize> {
-            let res = vm.call_special_method(&args.obj, identifier!(vm, __sizeof__), ())?;
-            let res = res.try_index(vm)?.try_to_primitive::<usize>(vm)?;
-            Ok(res + std::mem::size_of::<PyObject>())
-        };
-        sizeof()
-            .map(|x| vm.ctx.new_int(x).into())
-            .or_else(|err| args.default.ok_or(err))
-    }
-
-    #[pyfunction]
-    fn getfilesystemencoding(vm: &VirtualMachine) -> PyStrRef {
-        vm.fs_encoding().to_owned()
-    }
-
-    #[pyfunction]
-    fn getfilesystemencodeerrors(vm: &VirtualMachine) -> PyStrRef {
-        vm.fs_encode_errors().to_owned()
-    }
-
-    #[pyfunction]
-    fn getprofile(vm: &VirtualMachine) -> PyObjectRef {
-        vm.profile_func.borrow().clone()
-    }
-
-    #[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 {
-            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())
-    }
-
-    #[pyfunction]
-    fn _getframemodulename(depth: OptionalArg<usize>, vm: &VirtualMachine) -> PyResult {
-        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];
-
-        // If the frame has a function object, return its __module__ attribute
-        if let Some(func_obj) = &frame.func_obj {
-            match func_obj.get_attr(identifier!(vm, __module__), vm) {
-                Ok(module) => Ok(module),
-                Err(_) => {
-                    // CPython clears the error and returns None
-                    Ok(vm.ctx.none())
-                }
-            }
-        } else {
-            Ok(vm.ctx.none())
-        }
-    }
-
-    #[pyfunction]
-    fn gettrace(vm: &VirtualMachine) -> PyObjectRef {
-        vm.trace_func.borrow().clone()
-    }
-
-    #[cfg(windows)]
-    fn get_kernel32_version() -> std::io::Result<(u32, u32, u32)> {
-        unsafe {
-            // Create a wide string for "kernel32.dll"
-            let module_name: Vec<u16> = std::ffi::OsStr::new("kernel32.dll")
-                .encode_wide()
-                .chain(Some(0))
-                .collect();
-            let h_kernel32 = GetModuleHandleW(module_name.as_ptr());
-            if h_kernel32.is_null() {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // Prepare a buffer for the module file path
-            let mut kernel32_path = [0u16; MAX_PATH as usize];
-            let len = GetModuleFileNameW(
-                h_kernel32,
-                kernel32_path.as_mut_ptr(),
-                kernel32_path.len() as u32,
-            );
-            if len == 0 {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // Get the size of the version information block
-            let ver_block_size =
-                GetFileVersionInfoSizeW(kernel32_path.as_ptr(), std::ptr::null_mut());
-            if ver_block_size == 0 {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // Allocate a buffer to hold the version information
-            let mut ver_block = vec![0u8; ver_block_size as usize];
-            if GetFileVersionInfoW(
-                kernel32_path.as_ptr(),
-                0,
-                ver_block_size,
-                ver_block.as_mut_ptr() as *mut _,
-            ) == 0
-            {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // Prepare an empty sub-block string (L"") as required by VerQueryValueW
-            let sub_block: Vec<u16> = std::ffi::OsStr::new("")
-                .encode_wide()
-                .chain(Some(0))
-                .collect();
-
-            let mut ffi_ptr: *mut VS_FIXEDFILEINFO = std::ptr::null_mut();
-            let mut ffi_len: u32 = 0;
-            if VerQueryValueW(
-                ver_block.as_ptr() as *const _,
-                sub_block.as_ptr(),
-                &mut ffi_ptr as *mut *mut VS_FIXEDFILEINFO as *mut *mut _,
-                &mut ffi_len as *mut u32,
-            ) == 0
-                || ffi_ptr.is_null()
-            {
-                return Err(std::io::Error::last_os_error());
-            }
-
-            // Extract the version numbers from the VS_FIXEDFILEINFO structure.
-            let ffi = *ffi_ptr;
-            let real_major = (ffi.dwProductVersionMS >> 16) & 0xFFFF;
-            let real_minor = ffi.dwProductVersionMS & 0xFFFF;
-            let real_build = (ffi.dwProductVersionLS >> 16) & 0xFFFF;
-
-            Ok((real_major, real_minor, real_build))
-        }
-    }
-
-    #[cfg(windows)]
-    #[pyfunction]
-    fn getwindowsversion(vm: &VirtualMachine) -> PyResult<crate::builtins::tuple::PyTupleRef> {
-        use std::ffi::OsString;
-        use std::os::windows::ffi::OsStringExt;
-        use windows_sys::Win32::System::SystemInformation::{
-            GetVersionExW, OSVERSIONINFOEXW, OSVERSIONINFOW,
-        };
-
-        let mut version: OSVERSIONINFOEXW = unsafe { std::mem::zeroed() };
-        version.dwOSVersionInfoSize = std::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.
-            // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getversionexw#parameters
-            GetVersionExW(os_vi)
-        };
-
-        if result == 0 {
-            return Err(vm.new_os_error("failed to get windows version".to_owned()));
-        }
-
-        let service_pack = {
-            let (last, _) = version
-                .szCSDVersion
-                .iter()
-                .take_while(|&x| x != &0)
-                .enumerate()
-                .last()
-                .unwrap_or((0, &0));
-            let sp = OsString::from_wide(&version.szCSDVersion[..last]);
-            sp.into_string()
-                .map_err(|_| vm.new_os_error("service pack is not ASCII".to_owned()))?
-        };
-        let real_version = get_kernel32_version().map_err(|e| vm.new_os_error(e.to_string()))?;
-        Ok(WindowsVersion {
-            major: real_version.0,
-            minor: real_version.1,
-            build: real_version.2,
-            platform: version.dwPlatformId,
-            service_pack,
-            service_pack_major: version.wServicePackMajor,
-            service_pack_minor: version.wServicePackMinor,
-            suite_mask: version.wSuiteMask,
-            product_type: version.wProductType,
-            platform_version: (real_version.0, real_version.1, real_version.2), // TODO Provide accurate version, like CPython impl
-        }
-        .into_struct_sequence(vm))
-    }
-
-    fn _unraisablehook(unraisable: UnraisableHookArgs, vm: &VirtualMachine) -> PyResult<()> {
-        use super::PyStderr;
-
-        let stderr = PyStderr(vm);
-        if !vm.is_none(&unraisable.object) {
-            if !vm.is_none(&unraisable.err_msg) {
-                write!(stderr, "{}: ", unraisable.err_msg.str(vm)?);
-            } else {
-                write!(stderr, "Exception ignored in: ");
-            }
-            // exception in del will be ignored but printed
-            let repr = &unraisable.object.repr(vm);
-            let str = match repr {
-                Ok(v) => v.to_string(),
-                Err(_) => format!(
-                    "<object {} repr() failed>",
-                    unraisable.object.class().name()
-                ),
-            };
-            writeln!(stderr, "{str}");
-        } else if !vm.is_none(&unraisable.err_msg) {
-            writeln!(stderr, "{}:", unraisable.err_msg.str(vm)?);
-        }
-
-        // TODO: print received unraisable.exc_traceback
-        let tb_module = vm.import("traceback", 0)?;
-        let print_stack = tb_module.get_attr("print_stack", vm)?;
-        print_stack.call((), vm)?;
-
-        if vm.is_none(unraisable.exc_type.as_object()) {
-            // TODO: early return, but with what error?
-        }
-        assert!(
-            unraisable
-                .exc_type
-                .fast_issubclass(vm.ctx.exceptions.base_exception_type)
-        );
-
-        // TODO: print module name and qualname
-
-        if !vm.is_none(&unraisable.exc_value) {
-            write!(stderr, "{}: ", unraisable.exc_type);
-            if let Ok(str) = unraisable.exc_value.str(vm) {
-                write!(stderr, "{}", str.as_str());
-            } else {
-                write!(stderr, "<exception str() failed>");
-            }
-        }
-        writeln!(stderr);
-        // TODO: call file.flush()
-
-        Ok(())
-    }
-
-    #[pyattr]
-    #[pyfunction(name = "__unraisablehook__")]
-    fn unraisablehook(unraisable: UnraisableHookArgs, vm: &VirtualMachine) {
-        if let Err(e) = _unraisablehook(unraisable, vm) {
-            let stderr = super::PyStderr(vm);
-            writeln!(
-                stderr,
-                "{}",
-                e.as_object()
-                    .repr(vm)
-                    .unwrap_or_else(|_| vm.ctx.empty_str.to_owned())
-                    .as_str()
-            );
-        }
-    }
-
-    #[pyattr]
-    fn hash_info(vm: &VirtualMachine) -> PyTupleRef {
-        PyHashInfo::INFO.into_struct_sequence(vm)
-    }
-
-    #[pyfunction]
-    fn intern(s: PyRefExact<PyStr>, vm: &VirtualMachine) -> PyRef<PyStr> {
-        vm.ctx.intern_str(s).to_owned()
-    }
-
-    #[pyattr]
-    fn int_info(vm: &VirtualMachine) -> PyTupleRef {
-        PyIntInfo::INFO.into_struct_sequence(vm)
-    }
-
-    #[pyfunction]
-    fn get_int_max_str_digits(vm: &VirtualMachine) -> usize {
-        vm.state.int_max_str_digits.load()
-    }
-
-    #[pyfunction]
-    fn set_int_max_str_digits(maxdigits: usize, vm: &VirtualMachine) -> PyResult<()> {
-        let threshold = PyIntInfo::INFO.str_digits_check_threshold;
-        if maxdigits == 0 || maxdigits >= threshold {
-            vm.state.int_max_str_digits.store(maxdigits);
-            Ok(())
-        } else {
-            let error = format!("maxdigits must be 0 or larger than {threshold:?}");
-            Err(vm.new_value_error(error))
-        }
-    }
-
-    #[pyfunction]
-    fn is_finalizing(vm: &VirtualMachine) -> bool {
-        vm.state.finalizing.load(Ordering::Acquire)
-    }
-
-    #[pyfunction]
-    fn setprofile(profilefunc: PyObjectRef, vm: &VirtualMachine) {
-        vm.profile_func.replace(profilefunc);
-        update_use_tracing(vm);
-    }
-
-    #[pyfunction]
-    fn setrecursionlimit(recursion_limit: i32, vm: &VirtualMachine) -> PyResult<()> {
-        let recursion_limit = recursion_limit
-            .to_usize()
-            .filter(|&u| u >= 1)
-            .ok_or_else(|| {
-                vm.new_value_error("recursion limit must be greater than or equal to one")
-            })?;
-        let recursion_depth = vm.current_recursion_depth();
-
-        if recursion_limit > recursion_depth {
-            vm.recursion_limit.set(recursion_limit);
-            Ok(())
-        } else {
-            Err(vm.new_recursion_error(format!(
-                "cannot set the recursion limit to {recursion_limit} at the recursion depth {recursion_depth}: the limit is too low"
-            )))
-        }
-    }
-
-    #[pyfunction]
-    fn settrace(tracefunc: PyObjectRef, vm: &VirtualMachine) {
-        vm.trace_func.replace(tracefunc);
-        update_use_tracing(vm);
-    }
-
-    #[cfg(feature = "threading")]
-    #[pyattr]
-    fn thread_info(vm: &VirtualMachine) -> PyTupleRef {
-        PyThreadInfo::INFO.into_struct_sequence(vm)
-    }
-
-    #[pyattr]
-    fn version_info(vm: &VirtualMachine) -> PyTupleRef {
-        VersionInfo::VERSION.into_struct_sequence(vm)
-    }
-
-    fn update_use_tracing(vm: &VirtualMachine) {
-        let trace_is_none = vm.is_none(&vm.trace_func.borrow());
-        let profile_is_none = vm.is_none(&vm.profile_func.borrow());
-        let tracing = !(trace_is_none && profile_is_none);
-        vm.use_tracing.set(tracing);
-    }
-
-    #[pyfunction]
-    fn set_coroutine_origin_tracking_depth(depth: i32, vm: &VirtualMachine) -> PyResult<()> {
-        if depth < 0 {
-            return Err(vm.new_value_error("depth must be >= 0"));
-        }
-        crate::vm::thread::COROUTINE_ORIGIN_TRACKING_DEPTH.with(|cell| cell.set(depth as _));
-        Ok(())
-    }
-
-    #[pyfunction]
-    fn get_coroutine_origin_tracking_depth() -> i32 {
-        crate::vm::thread::COROUTINE_ORIGIN_TRACKING_DEPTH.with(|cell| cell.get()) as _
-    }
-
-    #[pyfunction]
-    fn getswitchinterval(vm: &VirtualMachine) -> f64 {
-        // Return the stored switch interval
-        vm.state.switch_interval.load()
-    }
-
-    // TODO: vm.state.switch_interval is currently not used anywhere in the VM
-    #[pyfunction]
-    fn setswitchinterval(interval: f64, vm: &VirtualMachine) -> PyResult<()> {
-        // Validate the interval parameter like CPython does
-        if interval <= 0.0 {
-            return Err(vm.new_value_error("switch interval must be strictly positive"));
-        }
-
-        // Store the switch interval value
-        vm.state.switch_interval.store(interval);
-        Ok(())
-    }
-
-    #[derive(FromArgs)]
-    struct SetAsyncgenHooksArgs {
-        #[pyarg(any, optional)]
-        firstiter: OptionalArg<Option<PyObjectRef>>,
-        #[pyarg(any, optional)]
-        finalizer: OptionalArg<Option<PyObjectRef>>,
-    }
-
-    #[pyfunction]
-    fn set_asyncgen_hooks(args: SetAsyncgenHooksArgs, vm: &VirtualMachine) -> PyResult<()> {
-        if let Some(Some(finalizer)) = args.finalizer.as_option() {
-            if !finalizer.is_callable() {
-                return Err(vm.new_type_error(format!(
-                    "callable finalizer expected, got {:.50}",
-                    finalizer.class().name()
-                )));
-            }
-        }
-
-        if let Some(Some(firstiter)) = args.firstiter.as_option() {
-            if !firstiter.is_callable() {
-                return Err(vm.new_type_error(format!(
-                    "callable firstiter expected, got {:.50}",
-                    firstiter.class().name()
-                )));
-            }
-        }
-
-        if let Some(finalizer) = args.finalizer.into_option() {
-            crate::vm::thread::ASYNC_GEN_FINALIZER.with(|cell| {
-                cell.replace(finalizer);
-            });
-        }
-        if let Some(firstiter) = args.firstiter.into_option() {
-            crate::vm::thread::ASYNC_GEN_FIRSTITER.with(|cell| {
-                cell.replace(firstiter);
-            });
-        }
-
-        Ok(())
-    }
-
-    #[pyclass(no_attr, name = "asyncgen_hooks")]
-    #[derive(PyStructSequence)]
-    pub(super) struct PyAsyncgenHooks {
-        firstiter: PyObjectRef,
-        finalizer: PyObjectRef,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl PyAsyncgenHooks {}
-
-    #[pyfunction]
-    fn get_asyncgen_hooks(vm: &VirtualMachine) -> PyAsyncgenHooks {
-        PyAsyncgenHooks {
-            firstiter: crate::vm::thread::ASYNC_GEN_FIRSTITER
-                .with(|cell| cell.borrow().clone().to_pyobject(vm)),
-            finalizer: crate::vm::thread::ASYNC_GEN_FINALIZER
-                .with(|cell| cell.borrow().clone().to_pyobject(vm)),
-        }
-    }
-
-    /// sys.flags
-    ///
-    /// Flags provided through command line arguments or environment vars.
-    #[pyclass(no_attr, name = "flags", module = "sys")]
-    #[derive(Debug, PyStructSequence)]
-    pub(super) struct Flags {
-        /// -d
-        debug: u8,
-        /// -i
-        inspect: u8,
-        /// -i
-        interactive: u8,
-        /// -O or -OO
-        optimize: u8,
-        /// -B
-        dont_write_bytecode: u8,
-        /// -s
-        no_user_site: u8,
-        /// -S
-        no_site: u8,
-        /// -E
-        ignore_environment: u8,
-        /// -v
-        verbose: u8,
-        /// -b
-        bytes_warning: u64,
-        /// -q
-        quiet: u8,
-        /// -R
-        hash_randomization: u8,
-        /// -I
-        isolated: u8,
-        /// -X dev
-        dev_mode: bool,
-        /// -X utf8
-        utf8_mode: u8,
-        /// -X int_max_str_digits=number
-        int_max_str_digits: i64,
-        /// -P, `PYTHONSAFEPATH`
-        safe_path: bool,
-        /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
-        warn_default_encoding: u8,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl Flags {
-        const fn from_settings(settings: &Settings) -> Self {
-            Self {
-                debug: settings.debug,
-                inspect: settings.inspect as u8,
-                interactive: settings.interactive as u8,
-                optimize: settings.optimize,
-                dont_write_bytecode: (!settings.write_bytecode) as u8,
-                no_user_site: (!settings.user_site_directory) as u8,
-                no_site: (!settings.import_site) as u8,
-                ignore_environment: settings.ignore_environment as u8,
-                verbose: settings.verbose,
-                bytes_warning: settings.bytes_warning,
-                quiet: settings.quiet as u8,
-                hash_randomization: settings.hash_seed.is_none() as u8,
-                isolated: settings.isolated as u8,
-                dev_mode: settings.dev_mode,
-                utf8_mode: settings.utf8_mode,
-                int_max_str_digits: settings.int_max_str_digits,
-                safe_path: settings.safe_path,
-                warn_default_encoding: settings.warn_default_encoding as u8,
-            }
-        }
-
-        #[pyslot]
-        fn slot_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error("cannot create 'sys.flags' instances"))
-        }
-    }
-
-    #[cfg(feature = "threading")]
-    #[pyclass(no_attr, name = "thread_info")]
-    #[derive(PyStructSequence)]
-    pub(super) struct PyThreadInfo {
-        name: Option<&'static str>,
-        lock: Option<&'static str>,
-        version: Option<&'static str>,
-    }
-
-    #[cfg(feature = "threading")]
-    #[pyclass(with(PyStructSequence))]
-    impl PyThreadInfo {
-        const INFO: Self = Self {
-            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"),
-            version: None,
-        };
-    }
-
-    #[pyclass(no_attr, name = "float_info")]
-    #[derive(PyStructSequence)]
-    pub(super) struct PyFloatInfo {
-        max: f64,
-        max_exp: i32,
-        max_10_exp: i32,
-        min: f64,
-        min_exp: i32,
-        min_10_exp: i32,
-        dig: u32,
-        mant_dig: u32,
-        epsilon: f64,
-        radix: u32,
-        rounds: i32,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl PyFloatInfo {
-        const INFO: Self = Self {
-            max: f64::MAX,
-            max_exp: f64::MAX_EXP,
-            max_10_exp: f64::MAX_10_EXP,
-            min: f64::MIN_POSITIVE,
-            min_exp: f64::MIN_EXP,
-            min_10_exp: f64::MIN_10_EXP,
-            dig: f64::DIGITS,
-            mant_dig: f64::MANTISSA_DIGITS,
-            epsilon: f64::EPSILON,
-            radix: f64::RADIX,
-            rounds: 1, // FE_TONEAREST
-        };
-    }
-
-    #[pyclass(no_attr, name = "hash_info")]
-    #[derive(PyStructSequence)]
-    pub(super) struct PyHashInfo {
-        width: usize,
-        modulus: PyUHash,
-        inf: PyHash,
-        nan: PyHash,
-        imag: PyHash,
-        algorithm: &'static str,
-        hash_bits: usize,
-        seed_bits: usize,
-        cutoff: usize,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl PyHashInfo {
-        const INFO: Self = {
-            use rustpython_common::hash::*;
-            Self {
-                width: std::mem::size_of::<PyHash>() * 8,
-                modulus: MODULUS,
-                inf: INF,
-                nan: NAN,
-                imag: IMAG,
-                algorithm: ALGO,
-                hash_bits: HASH_BITS,
-                seed_bits: SEED_BITS,
-                cutoff: 0, // no small string optimizations
-            }
-        };
-    }
-
-    #[pyclass(no_attr, name = "int_info")]
-    #[derive(PyStructSequence)]
-    pub(super) struct PyIntInfo {
-        bits_per_digit: usize,
-        sizeof_digit: usize,
-        default_max_str_digits: usize,
-        str_digits_check_threshold: usize,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl PyIntInfo {
-        const INFO: Self = Self {
-            bits_per_digit: 30, //?
-            sizeof_digit: std::mem::size_of::<u32>(),
-            default_max_str_digits: 4300,
-            str_digits_check_threshold: 640,
-        };
-    }
-
-    #[pyclass(no_attr, name = "version_info")]
-    #[derive(Default, Debug, PyStructSequence)]
-    pub struct VersionInfo {
-        major: usize,
-        minor: usize,
-        micro: usize,
-        releaselevel: &'static str,
-        serial: usize,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl VersionInfo {
-        pub const VERSION: Self = Self {
-            major: version::MAJOR,
-            minor: version::MINOR,
-            micro: version::MICRO,
-            releaselevel: version::RELEASELEVEL,
-            serial: version::SERIAL,
-        };
-        #[pyslot]
-        fn slot_new(
-            _cls: crate::builtins::type_::PyTypeRef,
-            _args: crate::function::FuncArgs,
-            vm: &crate::VirtualMachine,
-        ) -> crate::PyResult {
-            Err(vm.new_type_error("cannot create 'sys.version_info' instances"))
-        }
-    }
-
-    #[cfg(windows)]
-    #[pyclass(no_attr, name = "getwindowsversion")]
-    #[derive(Default, Debug, PyStructSequence)]
-    pub(super) struct WindowsVersion {
-        major: u32,
-        minor: u32,
-        build: u32,
-        platform: u32,
-        service_pack: String,
-        service_pack_major: u16,
-        service_pack_minor: u16,
-        suite_mask: u16,
-        product_type: u8,
-        platform_version: (u32, u32, u32),
-    }
-
-    #[cfg(windows)]
-    #[pyclass(with(PyStructSequence))]
-    impl WindowsVersion {}
-
-    #[pyclass(no_attr, name = "UnraisableHookArgs")]
-    #[derive(Debug, PyStructSequence, TryIntoPyStructSequence)]
-    pub struct UnraisableHookArgs {
-        pub exc_type: PyTypeRef,
-        pub exc_value: PyObjectRef,
-        pub exc_traceback: PyObjectRef,
-        pub err_msg: PyObjectRef,
-        pub object: PyObjectRef,
-    }
-
-    #[pyclass(with(PyStructSequence))]
-    impl UnraisableHookArgs {}
-}
-
-pub(crate) fn init_module(vm: &VirtualMachine, module: &Py<PyModule>, builtins: &Py<PyModule>) {
-    sys::extend_module(vm, module).unwrap();
-
-    let modules = vm.ctx.new_dict();
-    modules
-        .set_item("sys", module.to_owned().into(), vm)
-        .unwrap();
-    modules
-        .set_item("builtins", builtins.to_owned().into(), vm)
-        .unwrap();
-    extend_module!(vm, module, {
-        "__doc__" => sys::DOC.to_owned().to_pyobject(vm),
-        "modules" => modules,
-    });
-}
-
-/// Similar to PySys_WriteStderr in CPython.
-///
-/// # Usage
-///
-/// ```rust,ignore
-/// writeln!(sys::PyStderr(vm), "foo bar baz :)");
-/// ```
-///
-/// Unlike writing to a `std::io::Write` with the `write[ln]!()` macro, there's no error condition here;
-/// this is intended to be a replacement for the `eprint[ln]!()` macro, so `write!()`-ing to PyStderr just
-/// returns `()`.
-pub struct PyStderr<'vm>(pub &'vm VirtualMachine);
-
-impl PyStderr<'_> {
-    pub fn write_fmt(&self, args: std::fmt::Arguments<'_>) {
-        use crate::py_io::Write;
-
-        let vm = self.0;
-        if let Ok(stderr) = get_stderr(vm) {
-            let mut stderr = crate::py_io::PyWriter(stderr, vm);
-            if let Ok(()) = stderr.write_fmt(args) {
-                return;
-            }
-        }
-        eprint!("{args}")
-    }
-}
-
-pub fn get_stdin(vm: &VirtualMachine) -> PyResult {
-    vm.sys_module
-        .get_attr("stdin", vm)
-        .map_err(|_| vm.new_runtime_error("lost sys.stdin"))
-}
-pub fn get_stdout(vm: &VirtualMachine) -> PyResult {
-    vm.sys_module
-        .get_attr("stdout", vm)
-        .map_err(|_| vm.new_runtime_error("lost sys.stdout"))
-}
-pub fn get_stderr(vm: &VirtualMachine) -> PyResult {
-    vm.sys_module
-        .get_attr("stderr", vm)
-        .map_err(|_| vm.new_runtime_error("lost sys.stderr"))
-}
-
-pub(crate) fn sysconfigdata_name() -> String {
-    format!(
-        "_sysconfigdata_{}_{}_{}",
-        sys::ABIFLAGS,
-        sys::PLATFORM,
-        sys::MULTIARCH
-    )
-}
diff --git a/vm/src/stdlib/sysconfigdata.rs b/vm/src/stdlib/sysconfigdata.rs
deleted file mode 100644
index 90e46b83b9..0000000000
--- a/vm/src/stdlib/sysconfigdata.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-pub(crate) use _sysconfigdata::make_module;
-
-#[pymodule]
-pub(crate) mod _sysconfigdata {
-    use crate::{VirtualMachine, builtins::PyDictRef, convert::ToPyObject, stdlib::sys::MULTIARCH};
-
-    #[pyattr]
-    fn build_time_vars(vm: &VirtualMachine) -> PyDictRef {
-        let vars = vm.ctx.new_dict();
-        macro_rules! sysvars {
-            ($($key:literal => $value:expr),*$(,)?) => {{
-                $(vars.set_item($key, $value.to_pyobject(vm), vm).unwrap();)*
-            }};
-        }
-        sysvars! {
-            // fake shared module extension
-            "EXT_SUFFIX" => format!(".rustpython-{MULTIARCH}"),
-            "MULTIARCH" => MULTIARCH,
-            // enough for tests to stop expecting urandom() to fail after restricting file resources
-            "HAVE_GETRANDOM" => 1,
-        }
-        include!(concat!(env!("OUT_DIR"), "/env_vars.rs"));
-        vars
-    }
-}
diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs
deleted file mode 100644
index 6b751f3074..0000000000
--- a/vm/src/stdlib/thread.rs
+++ /dev/null
@@ -1,446 +0,0 @@
-//! Implementation of the _thread module
-#[cfg_attr(target_arch = "wasm32", allow(unused_imports))]
-pub(crate) use _thread::{RawRMutex, make_module};
-
-#[pymodule]
-pub(crate) mod _thread {
-    use crate::{
-        AsObject, Py, PyPayload, PyRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyStr, PyTupleRef, PyTypeRef},
-        convert::ToPyException,
-        function::{ArgCallable, Either, FuncArgs, KwArgs, OptionalArg, PySetterValue},
-        types::{Constructor, GetAttr, Representable, SetAttr},
-    };
-    use crossbeam_utils::atomic::AtomicCell;
-    use parking_lot::{
-        RawMutex, RawThreadId,
-        lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex},
-    };
-    use std::{cell::RefCell, fmt, thread, time::Duration};
-    use thread_local::ThreadLocal;
-
-    // PYTHREAD_NAME: show current thread name
-    pub const PYTHREAD_NAME: Option<&str> = {
-        cfg_if::cfg_if! {
-            if #[cfg(windows)] {
-                Some("nt")
-            } else if #[cfg(unix)] {
-                Some("pthread")
-            } else if #[cfg(any(target_os = "solaris", target_os = "illumos"))] {
-                Some("solaris")
-            } else {
-                None
-            }
-        }
-    };
-
-    // TIMEOUT_MAX_IN_MICROSECONDS is a value in microseconds
-    #[cfg(not(target_os = "windows"))]
-    const TIMEOUT_MAX_IN_MICROSECONDS: i64 = i64::MAX / 1_000;
-
-    #[cfg(target_os = "windows")]
-    const TIMEOUT_MAX_IN_MICROSECONDS: i64 = 0xffffffff * 1_000;
-
-    // this is a value in seconds
-    #[pyattr]
-    const TIMEOUT_MAX: f64 = (TIMEOUT_MAX_IN_MICROSECONDS / 1_000_000) as f64;
-
-    #[pyattr]
-    fn error(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.exceptions.runtime_error.to_owned()
-    }
-
-    #[derive(FromArgs)]
-    struct AcquireArgs {
-        #[pyarg(any, default = true)]
-        blocking: bool,
-        #[pyarg(any, default = Either::A(-1.0))]
-        timeout: Either<f64, i64>,
-    }
-
-    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,
-            };
-            match args.blocking {
-                true if timeout == -1.0 => {
-                    mu.lock();
-                    Ok(true)
-                }
-                true if timeout < 0.0 => {
-                    Err(vm.new_value_error("timeout value must be positive".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(),
-                        ));
-                    }
-
-                    Ok(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())),
-                false => Ok(mu.try_lock()),
-            }
-        }};
-    }
-    macro_rules! repr_lock_impl {
-        ($zelf:expr) => {{
-            let status = if $zelf.mu.is_locked() {
-                "locked"
-            } else {
-                "unlocked"
-            };
-            Ok(format!(
-                "<{} {} object at {:#x}>",
-                status,
-                $zelf.class().name(),
-                $zelf.get_id()
-            ))
-        }};
-    }
-
-    #[pyattr(name = "LockType")]
-    #[pyclass(module = "thread", name = "lock")]
-    #[derive(PyPayload)]
-    struct Lock {
-        mu: RawMutex,
-    }
-
-    impl fmt::Debug for Lock {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.pad("Lock")
-        }
-    }
-
-    #[pyclass(with(Constructor, Representable))]
-    impl Lock {
-        #[pymethod]
-        #[pymethod(name = "acquire_lock")]
-        #[pymethod(name = "__enter__")]
-        fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
-            acquire_lock_impl!(&self.mu, args, vm)
-        }
-        #[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"));
-            }
-            unsafe { self.mu.unlock() };
-            Ok(())
-        }
-
-        #[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> = std::mem::transmute(&self.mu);
-                old_mutex.swap(new_mut);
-            }
-
-            Ok(())
-        }
-
-        #[pymethod]
-        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            self.release(vm)
-        }
-
-        #[pymethod]
-        fn locked(&self) -> bool {
-            self.mu.is_locked()
-        }
-    }
-
-    impl Constructor for Lock {
-        type Args = FuncArgs;
-        fn py_new(_cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            Err(vm.new_type_error("cannot create '_thread.lock' instances"))
-        }
-    }
-
-    impl Representable for Lock {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            repr_lock_impl!(zelf)
-        }
-    }
-
-    pub type RawRMutex = RawReentrantMutex<RawMutex, RawThreadId>;
-    #[pyattr]
-    #[pyclass(module = "thread", name = "RLock")]
-    #[derive(PyPayload)]
-    struct RLock {
-        mu: RawRMutex,
-    }
-
-    impl fmt::Debug for RLock {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.pad("RLock")
-        }
-    }
-
-    #[pyclass(with(Representable))]
-    impl RLock {
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            Self {
-                mu: RawRMutex::INIT,
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-        }
-
-        #[pymethod]
-        #[pymethod(name = "acquire_lock")]
-        #[pymethod(name = "__enter__")]
-        fn acquire(&self, args: AcquireArgs, vm: &VirtualMachine) -> PyResult<bool> {
-            acquire_lock_impl!(&self.mu, args, vm)
-        }
-        #[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"));
-            }
-            unsafe { self.mu.unlock() };
-            Ok(())
-        }
-
-        #[pymethod]
-        fn _at_fork_reinit(&self, _vm: &VirtualMachine) -> PyResult<()> {
-            if self.mu.is_locked() {
-                unsafe {
-                    self.mu.unlock();
-                };
-            }
-            let new_mut = RawRMutex::INIT;
-
-            let old_mutex: AtomicCell<&RawRMutex> = AtomicCell::new(&self.mu);
-            old_mutex.swap(&new_mut);
-
-            Ok(())
-        }
-
-        #[pymethod]
-        fn _is_owned(&self) -> bool {
-            self.mu.is_owned_by_current_thread()
-        }
-
-        #[pymethod]
-        fn __exit__(&self, _args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-            self.release(vm)
-        }
-    }
-
-    impl Representable for RLock {
-        #[inline]
-        fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {
-            repr_lock_impl!(zelf)
-        }
-    }
-
-    #[pyfunction]
-    fn get_ident() -> u64 {
-        thread_to_id(&thread::current())
-    }
-
-    fn thread_to_id(t: &thread::Thread) -> u64 {
-        use std::hash::{Hash, Hasher};
-        struct U64Hash {
-            v: Option<u64>,
-        }
-        impl Hasher for U64Hash {
-            fn write(&mut self, _: &[u8]) {
-                unreachable!()
-            }
-            fn write_u64(&mut self, i: u64) {
-                self.v = Some(i);
-            }
-            fn finish(&self) -> u64 {
-                self.v.expect("should have written a u64")
-            }
-        }
-        // TODO: use id.as_u64() once it's stable, until then, ThreadId is just a wrapper
-        // around NonZeroU64, so this should work (?)
-        let mut h = U64Hash { v: None };
-        t.id().hash(&mut h);
-        h.finish()
-    }
-
-    #[pyfunction]
-    fn allocate_lock() -> Lock {
-        Lock { mu: RawMutex::INIT }
-    }
-
-    #[pyfunction]
-    fn start_new_thread(
-        func: ArgCallable,
-        args: PyTupleRef,
-        kwargs: OptionalArg<PyDictRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<u64> {
-        let args = FuncArgs::new(
-            args.to_vec(),
-            kwargs
-                .map_or_else(Default::default, |k| k.to_attributes(vm))
-                .into_iter()
-                .map(|(k, v)| (k.as_str().to_owned(), v))
-                .collect::<KwArgs>(),
-        );
-        let mut thread_builder = thread::Builder::new();
-        let stacksize = vm.state.stacksize.load();
-        if stacksize != 0 {
-            thread_builder = thread_builder.stack_size(stacksize);
-        }
-        thread_builder
-            .spawn(
-                vm.new_thread()
-                    .make_spawn_func(move |vm| run_thread(func, args, vm)),
-            )
-            .map(|handle| {
-                vm.state.thread_count.fetch_add(1);
-                thread_to_id(handle.thread())
-            })
-            .map_err(|err| err.to_pyexception(vm))
-    }
-
-    fn run_thread(func: ArgCallable, args: FuncArgs, vm: &VirtualMachine) {
-        match func.invoke(args, vm) {
-            Ok(_obj) => {}
-            Err(e) if e.fast_isinstance(vm.ctx.exceptions.system_exit) => {}
-            Err(exc) => {
-                vm.run_unraisable(
-                    exc,
-                    Some("Exception ignored in thread started by".to_owned()),
-                    func.into(),
-                );
-            }
-        }
-        SENTINELS.with(|sentinels| {
-            for lock in sentinels.replace(Default::default()) {
-                if lock.mu.is_locked() {
-                    unsafe { lock.mu.unlock() };
-                }
-            }
-        });
-        vm.state.thread_count.fetch_sub(1);
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[pyfunction]
-    fn interrupt_main(signum: OptionalArg<i32>, vm: &VirtualMachine) -> PyResult<()> {
-        crate::signal::set_interrupt_ex(signum.unwrap_or(libc::SIGINT), vm)
-    }
-
-    #[pyfunction]
-    fn exit(vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_exception_empty(vm.ctx.exceptions.system_exit.to_owned()))
-    }
-
-    thread_local! {
-        static SENTINELS: RefCell<Vec<PyRef<Lock>>> = const { RefCell::new(Vec::new()) };
-    }
-
-    #[pyfunction]
-    fn _set_sentinel(vm: &VirtualMachine) -> PyRef<Lock> {
-        let lock = Lock { mu: RawMutex::INIT }.into_ref(&vm.ctx);
-        SENTINELS.with(|sentinels| sentinels.borrow_mut().push(lock.clone()));
-        lock
-    }
-
-    #[pyfunction]
-    fn stack_size(size: OptionalArg<usize>, vm: &VirtualMachine) -> usize {
-        let size = size.unwrap_or(0);
-        // TODO: do validation on this to make sure it's not too small
-        vm.state.stacksize.swap(size)
-    }
-
-    #[pyfunction]
-    fn _count(vm: &VirtualMachine) -> usize {
-        vm.state.thread_count.load()
-    }
-
-    #[pyattr]
-    #[pyclass(module = "thread", name = "_local")]
-    #[derive(Debug, PyPayload)]
-    struct Local {
-        data: ThreadLocal<PyDictRef>,
-    }
-
-    #[pyclass(with(GetAttr, SetAttr), flags(BASETYPE))]
-    impl Local {
-        fn l_dict(&self, vm: &VirtualMachine) -> PyDictRef {
-            self.data.get_or(|| vm.ctx.new_dict()).clone()
-        }
-
-        #[pyslot]
-        fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-            Self {
-                data: ThreadLocal::new(),
-            }
-            .into_ref_with_type(vm, cls)
-            .map(Into::into)
-        }
-    }
-
-    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__" {
-                Ok(l_dict.into())
-            } else {
-                zelf.as_object()
-                    .generic_getattr_opt(attr, Some(l_dict), vm)?
-                    .ok_or_else(|| {
-                        vm.new_attribute_error(format!(
-                            "{} has no attribute '{}'",
-                            zelf.class().name(),
-                            attr
-                        ))
-                    })
-            }
-        }
-    }
-
-    impl SetAttr for Local {
-        fn setattro(
-            zelf: &Py<Self>,
-            attr: &Py<PyStr>,
-            value: PySetterValue,
-            vm: &VirtualMachine,
-        ) -> PyResult<()> {
-            if attr.as_str() == "__dict__" {
-                Err(vm.new_attribute_error(format!(
-                    "{} attribute '__dict__' is read-only",
-                    zelf.class().name()
-                )))
-            } else {
-                let dict = zelf.l_dict(vm);
-                if let PySetterValue::Assign(value) = value {
-                    dict.set_item(attr, value, vm)?;
-                } else {
-                    dict.del_item(attr, vm)?;
-                }
-                Ok(())
-            }
-        }
-    }
-}
diff --git a/vm/src/stdlib/typing.rs b/vm/src/stdlib/typing.rs
deleted file mode 100644
index 331206b214..0000000000
--- a/vm/src/stdlib/typing.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-// spell-checker:ignore typevarobject funcobj
-use crate::{PyPayload, PyRef, VirtualMachine, class::PyClassImpl, stdlib::PyModule};
-
-pub use crate::stdlib::typevar::{
-    Generic, ParamSpec, ParamSpecArgs, ParamSpecKwargs, TypeVar, TypeVarTuple,
-    set_typeparam_default,
-};
-pub use decl::*;
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = decl::make_module(vm);
-    TypeVar::make_class(&vm.ctx);
-    ParamSpec::make_class(&vm.ctx);
-    TypeVarTuple::make_class(&vm.ctx);
-    ParamSpecArgs::make_class(&vm.ctx);
-    ParamSpecKwargs::make_class(&vm.ctx);
-    Generic::make_class(&vm.ctx);
-    extend_module!(vm, &module, {
-        "NoDefault" => vm.ctx.typing_no_default.clone(),
-        "TypeVar" => TypeVar::class(&vm.ctx).to_owned(),
-        "ParamSpec" => ParamSpec::class(&vm.ctx).to_owned(),
-        "TypeVarTuple" => TypeVarTuple::class(&vm.ctx).to_owned(),
-        "ParamSpecArgs" => ParamSpecArgs::class(&vm.ctx).to_owned(),
-        "ParamSpecKwargs" => ParamSpecKwargs::class(&vm.ctx).to_owned(),
-        "Generic" => Generic::class(&vm.ctx).to_owned(),
-    });
-    module
-}
-
-#[pymodule(name = "_typing")]
-pub(crate) mod decl {
-    use crate::{
-        PyObjectRef, PyPayload, PyResult, VirtualMachine,
-        builtins::{PyTupleRef, PyTypeRef, pystr::AsPyStr},
-        function::{FuncArgs, IntoFuncArgs},
-        types::{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 = FuncArgs;
-
-        fn py_new(_cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult {
-            if !args.args.is_empty() || !args.kwargs.is_empty() {
-                return Err(vm.new_type_error("NoDefaultType takes no arguments"));
-            }
-
-            // Return singleton instance from context
-            Ok(vm.ctx.typing_no_default.clone().into())
-        }
-    }
-
-    impl Representable for NoDefault {
-        #[inline(always)]
-        fn repr_str(_zelf: &crate::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: PyObjectRef, // TODO PyStrRef?
-        type_params: PyTupleRef,
-        value: PyObjectRef,
-        // compute_value: PyObjectRef,
-        // module: PyObjectRef,
-    }
-    #[pyclass(flags(BASETYPE))]
-    impl TypeAliasType {
-        pub const fn new(name: PyObjectRef, type_params: PyTupleRef, value: PyObjectRef) -> Self {
-            Self {
-                name,
-                type_params,
-                value,
-            }
-        }
-    }
-
-    // impl AsMapping for Generic {
-    //     fn as_mapping() -> &'static PyMappingMethods {
-    //         static AS_MAPPING: Lazy<PyMappingMethods> = Lazy::new(|| PyMappingMethods {
-    //             subscript: atomic_func!(|mapping, needle, vm| {
-    //                 call_typing_func_object(vm, "_GenericAlias", (mapping.obj, needle))
-    //             }),
-    //             ..PyMappingMethods::NOT_IMPLEMENTED
-    //         });
-    //         &AS_MAPPING
-    //     }
-    // }
-}
diff --git a/vm/src/stdlib/weakref.rs b/vm/src/stdlib/weakref.rs
deleted file mode 100644
index bfec54e9c6..0000000000
--- a/vm/src/stdlib/weakref.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-//! Implementation in line with the python `weakref` module.
-//!
-//! See also:
-//! - [python weakref module](https://docs.python.org/3/library/weakref.html)
-//! - [rust weak struct](https://doc.rust-lang.org/std/rc/struct.Weak.html)
-//!
-pub(crate) use _weakref::make_module;
-
-#[pymodule]
-mod _weakref {
-    use crate::{
-        PyObjectRef, PyResult, VirtualMachine,
-        builtins::{PyDictRef, PyTypeRef, PyWeak},
-    };
-
-    #[pyattr(name = "ref")]
-    fn ref_(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.types.weakref_type.to_owned()
-    }
-    #[pyattr]
-    fn proxy(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.types.weakproxy_type.to_owned()
-    }
-    #[pyattr(name = "ReferenceType")]
-    fn reference_type(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.types.weakref_type.to_owned()
-    }
-    #[pyattr(name = "ProxyType")]
-    fn proxy_type(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.types.weakproxy_type.to_owned()
-    }
-    #[pyattr(name = "CallableProxyType")]
-    fn callable_proxy_type(vm: &VirtualMachine) -> PyTypeRef {
-        vm.ctx.types.weakproxy_type.to_owned()
-    }
-
-    #[pyfunction]
-    fn getweakrefcount(obj: PyObjectRef) -> usize {
-        obj.weak_count().unwrap_or(0)
-    }
-
-    #[pyfunction]
-    fn getweakrefs(obj: PyObjectRef) -> Vec<PyObjectRef> {
-        match obj.get_weak_references() {
-            Some(v) => v.into_iter().map(Into::into).collect(),
-            None => vec![],
-        }
-    }
-
-    #[pyfunction]
-    fn _remove_dead_weakref(
-        dict: PyDictRef,
-        key: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        dict._as_dict_inner()
-            .delete_if(vm, &*key, |wr| {
-                let wr = wr
-                    .payload::<PyWeak>()
-                    .ok_or_else(|| vm.new_type_error("not a weakref"))?;
-                Ok(wr.is_dead())
-            })
-            .map(drop)
-    }
-}
diff --git a/vm/src/stdlib/winapi.rs b/vm/src/stdlib/winapi.rs
deleted file mode 100644
index 10a14acbc9..0000000000
--- a/vm/src/stdlib/winapi.rs
+++ /dev/null
@@ -1,516 +0,0 @@
-// spell-checker:disable
-
-#![allow(non_snake_case)]
-pub(crate) use _winapi::make_module;
-
-#[pymodule]
-mod _winapi {
-    use crate::{
-        PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-        builtins::PyStrRef,
-        common::windows::ToWideString,
-        convert::{ToPyException, ToPyResult},
-        function::{ArgMapping, ArgSequence, OptionalArg},
-        stdlib::os::errno_err,
-        windows::WindowsSysResult,
-    };
-    use std::ptr::{null, null_mut};
-    use windows::{
-        Win32::Foundation::{HANDLE, HINSTANCE, MAX_PATH},
-        core::PCWSTR,
-    };
-    use windows_sys::Win32::Foundation::{BOOL, HANDLE as RAW_HANDLE};
-
-    #[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,
-        },
-        Globalization::{
-            LCMAP_FULLWIDTH, LCMAP_HALFWIDTH, LCMAP_HIRAGANA, LCMAP_KATAKANA,
-            LCMAP_LINGUISTIC_CASING, LCMAP_LOWERCASE, LCMAP_SIMPLIFIED_CHINESE, LCMAP_TITLECASE,
-            LCMAP_TRADITIONAL_CHINESE, LCMAP_UPPERCASE,
-        },
-        Storage::FileSystem::{
-            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,
-                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,
-            },
-            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_USESHOWWINDOW, STARTF_USESTDHANDLES,
-            },
-            WindowsProgramming::{
-                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,
-            },
-        },
-        UI::WindowsAndMessaging::SW_HIDE,
-    };
-
-    #[pyattr]
-    const NULL: isize = 0;
-
-    #[pyfunction]
-    fn CloseHandle(handle: HANDLE) -> WindowsSysResult<BOOL> {
-        WindowsSysResult(unsafe { windows_sys::Win32::Foundation::CloseHandle(handle.0 as _) })
-    }
-
-    #[pyfunction]
-    fn GetStdHandle(
-        std_handle: windows_sys::Win32::System::Console::STD_HANDLE,
-    ) -> WindowsSysResult<RAW_HANDLE> {
-        WindowsSysResult(unsafe { windows_sys::Win32::System::Console::GetStdHandle(std_handle) })
-    }
-
-    #[pyfunction]
-    fn CreatePipe(
-        _pipe_attrs: PyObjectRef,
-        size: u32,
-        vm: &VirtualMachine,
-    ) -> PyResult<(HANDLE, HANDLE)> {
-        let (read, write) = unsafe {
-            let mut read = std::mem::MaybeUninit::<isize>::uninit();
-            let mut write = std::mem::MaybeUninit::<isize>::uninit();
-            WindowsSysResult(windows_sys::Win32::System::Pipes::CreatePipe(
-                read.as_mut_ptr() as _,
-                write.as_mut_ptr() as _,
-                std::ptr::null(),
-                size,
-            ))
-            .to_pyresult(vm)?;
-            (read.assume_init(), write.assume_init())
-        };
-        Ok((HANDLE(read), HANDLE(write)))
-    }
-
-    #[pyfunction]
-    fn DuplicateHandle(
-        (src_process, src): (HANDLE, HANDLE),
-        target_process: HANDLE,
-        access: u32,
-        inherit: BOOL,
-        options: OptionalArg<u32>,
-        vm: &VirtualMachine,
-    ) -> PyResult<HANDLE> {
-        let target = unsafe {
-            let mut target = std::mem::MaybeUninit::<isize>::uninit();
-            WindowsSysResult(windows_sys::Win32::Foundation::DuplicateHandle(
-                src_process.0 as _,
-                src.0 as _,
-                target_process.0 as _,
-                target.as_mut_ptr() as _,
-                access,
-                inherit,
-                options.unwrap_or(0),
-            ))
-            .to_pyresult(vm)?;
-            target.assume_init()
-        };
-        Ok(HANDLE(target))
-    }
-
-    #[pyfunction]
-    fn GetACP() -> u32 {
-        unsafe { windows_sys::Win32::Globalization::GetACP() }
-    }
-
-    #[pyfunction]
-    fn GetCurrentProcess() -> HANDLE {
-        unsafe { windows::Win32::System::Threading::GetCurrentProcess() }
-    }
-
-    #[pyfunction]
-    fn GetFileType(
-        h: HANDLE,
-        vm: &VirtualMachine,
-    ) -> PyResult<windows_sys::Win32::Storage::FileSystem::FILE_TYPE> {
-        let file_type = unsafe { windows_sys::Win32::Storage::FileSystem::GetFileType(h.0 as _) };
-        if file_type == 0 && unsafe { windows_sys::Win32::Foundation::GetLastError() } != 0 {
-            Err(errno_err(vm))
-        } else {
-            Ok(file_type)
-        }
-    }
-
-    #[pyfunction]
-    fn GetLastError() -> u32 {
-        unsafe { windows_sys::Win32::Foundation::GetLastError() }
-    }
-
-    #[pyfunction]
-    fn GetVersion() -> u32 {
-        unsafe { windows_sys::Win32::System::SystemInformation::GetVersion() }
-    }
-
-    #[derive(FromArgs)]
-    struct CreateProcessArgs {
-        #[pyarg(positional)]
-        name: Option<PyStrRef>,
-        #[pyarg(positional)]
-        command_line: Option<PyStrRef>,
-        #[pyarg(positional)]
-        _proc_attrs: PyObjectRef,
-        #[pyarg(positional)]
-        _thread_attrs: PyObjectRef,
-        #[pyarg(positional)]
-        inherit_handles: i32,
-        #[pyarg(positional)]
-        creation_flags: u32,
-        #[pyarg(positional)]
-        env_mapping: Option<ArgMapping>,
-        #[pyarg(positional)]
-        current_dir: Option<PyStrRef>,
-        #[pyarg(positional)]
-        startup_info: PyObjectRef,
-    }
-
-    #[pyfunction]
-    fn CreateProcess(
-        args: CreateProcessArgs,
-        vm: &VirtualMachine,
-    ) -> PyResult<(HANDLE, HANDLE, 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 _;
-
-        macro_rules! si_attr {
-            ($attr:ident, $t:ty) => {{
-                si.StartupInfo.$attr = <Option<$t>>::try_from_object(
-                    vm,
-                    args.startup_info.get_attr(stringify!($attr), vm)?,
-                )?
-                .unwrap_or(0) as _
-            }};
-            ($attr:ident) => {{
-                si.StartupInfo.$attr = <Option<_>>::try_from_object(
-                    vm,
-                    args.startup_info.get_attr(stringify!($attr), vm)?,
-                )?
-                .unwrap_or(0)
-            }};
-        }
-        si_attr!(dwFlags);
-        si_attr!(wShowWindow);
-        si_attr!(hStdInput, usize);
-        si_attr!(hStdOutput, usize);
-        si_attr!(hStdError, usize);
-
-        let mut env = args
-            .env_mapping
-            .map(|m| getenvironment(m, vm))
-            .transpose()?;
-        let env = env.as_mut().map_or_else(null_mut, |v| v.as_mut_ptr());
-
-        let mut attrlist =
-            getattributelist(args.startup_info.get_attr("lpAttributeList", vm)?, vm)?;
-        si.lpAttributeList = attrlist
-            .as_mut()
-            .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())
-                .map_err(|err| err.to_pyexception(vm))?;
-            Ok(ws.into_vec_with_nul())
-        };
-
-        let app_name = args.name.map(wstr).transpose()?;
-        let app_name = app_name.as_ref().map_or_else(null, |w| w.as_ptr());
-
-        let mut command_line = args.command_line.map(wstr).transpose()?;
-        let command_line = command_line
-            .as_mut()
-            .map_or_else(null_mut, |w| w.as_mut_ptr());
-
-        let mut current_dir = args.current_dir.map(wstr).transpose()?;
-        let current_dir = current_dir
-            .as_mut()
-            .map_or_else(null_mut, |w| w.as_mut_ptr());
-
-        let procinfo = unsafe {
-            let mut procinfo = std::mem::MaybeUninit::uninit();
-            WindowsSysResult(windows_sys::Win32::System::Threading::CreateProcessW(
-                app_name,
-                command_line,
-                std::ptr::null(),
-                std::ptr::null(),
-                args.inherit_handles,
-                args.creation_flags
-                    | windows_sys::Win32::System::Threading::EXTENDED_STARTUPINFO_PRESENT
-                    | windows_sys::Win32::System::Threading::CREATE_UNICODE_ENVIRONMENT,
-                env as _,
-                current_dir,
-                &mut si as *mut _ as *mut _,
-                procinfo.as_mut_ptr(),
-            ))
-            .into_pyresult(vm)?;
-            procinfo.assume_init()
-        };
-
-        Ok((
-            HANDLE(procinfo.hProcess as _),
-            HANDLE(procinfo.hThread as _),
-            procinfo.dwProcessId,
-            procinfo.dwThreadId,
-        ))
-    }
-
-    #[pyfunction]
-    fn OpenProcess(desired_access: u32, inherit_handle: bool, process_id: u32) -> isize {
-        unsafe {
-            windows_sys::Win32::System::Threading::OpenProcess(
-                desired_access,
-                BOOL::from(inherit_handle),
-                process_id,
-            ) as _
-        }
-    }
-
-    #[pyfunction]
-    fn NeedCurrentDirectoryForExePath(exe_name: PyStrRef) -> bool {
-        let exe_name = exe_name.as_str().to_wide_with_nul();
-        let return_value = unsafe {
-            windows_sys::Win32::System::Environment::NeedCurrentDirectoryForExePathW(
-                exe_name.as_ptr(),
-            )
-        };
-        return_value != 0
-    }
-
-    #[pyfunction]
-    fn CreateJunction(
-        src_path: PyStrRef,
-        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());
-
-        junction::create(dest_path, src_path).map_err(|e| e.to_pyexception(vm))
-    }
-
-    fn getenvironment(env: ArgMapping, vm: &VirtualMachine) -> PyResult<Vec<u16>> {
-        let keys = env.mapping().keys(vm)?;
-        let values = env.mapping().values(vm)?;
-
-        let keys = ArgSequence::try_from_object(vm, keys)?.into_vec();
-        let values = ArgSequence::try_from_object(vm, values)?.into_vec();
-
-        if keys.len() != values.len() {
-            return Err(vm.new_runtime_error("environment changed size during iteration"));
-        }
-
-        let mut out = widestring::WideString::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 v = PyStrRef::try_from_object(vm, v)?;
-            let v = v.as_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);
-            out.push_str("\0");
-        }
-        out.push_str("\0");
-        Ok(out.into_vec())
-    }
-
-    struct AttrList {
-        handlelist: Option<Vec<usize>>,
-        attrlist: Vec<u8>,
-    }
-    impl Drop for AttrList {
-        fn drop(&mut self) {
-            unsafe {
-                windows_sys::Win32::System::Threading::DeleteProcThreadAttributeList(
-                    self.attrlist.as_mut_ptr() as *mut _,
-                )
-            };
-        }
-    }
-
-    fn getattributelist(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Option<AttrList>> {
-        <Option<ArgMapping>>::try_from_object(vm, obj)?
-            .map(|mapping| {
-                let handlelist = mapping
-                    .as_ref()
-                    .get_item("handle_list", vm)
-                    .ok()
-                    .and_then(|obj| {
-                        <Option<ArgSequence<usize>>>::try_from_object(vm, obj)
-                            .map(|s| match s {
-                                Some(s) if !s.is_empty() => Some(s.into_vec()),
-                                _ => None,
-                            })
-                            .transpose()
-                    })
-                    .transpose()?;
-
-                let attr_count = handlelist.is_some() as u32;
-                let (result, mut size) = unsafe {
-                    let mut size = std::mem::MaybeUninit::uninit();
-                    let result = WindowsSysResult(
-                        windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
-                            std::ptr::null_mut(),
-                            attr_count,
-                            0,
-                            size.as_mut_ptr(),
-                        ),
-                    );
-                    (result, size.assume_init())
-                };
-                if !result.is_err()
-                    || unsafe { windows_sys::Win32::Foundation::GetLastError() }
-                        != windows_sys::Win32::Foundation::ERROR_INSUFFICIENT_BUFFER
-                {
-                    return Err(errno_err(vm));
-                }
-                let mut attrlist = vec![0u8; size];
-                WindowsSysResult(unsafe {
-                    windows_sys::Win32::System::Threading::InitializeProcThreadAttributeList(
-                        attrlist.as_mut_ptr() as *mut _,
-                        attr_count,
-                        0,
-                        &mut size,
-                    )
-                })
-                .into_pyresult(vm)?;
-                let mut attrs = AttrList {
-                    handlelist,
-                    attrlist,
-                };
-                if let Some(ref mut handlelist) = attrs.handlelist {
-                    WindowsSysResult(unsafe {
-                        windows_sys::Win32::System::Threading::UpdateProcThreadAttribute(
-                            attrs.attrlist.as_mut_ptr() as _,
-                            0,
-                            (2 & 0xffff) | 0x20000, // PROC_THREAD_ATTRIBUTE_HANDLE_LIST
-                            handlelist.as_mut_ptr() as _,
-                            (handlelist.len() * std::mem::size_of::<HANDLE>()) as _,
-                            std::ptr::null_mut(),
-                            std::ptr::null(),
-                        )
-                    })
-                    .into_pyresult(vm)?;
-                }
-                Ok(attrs)
-            })
-            .transpose()
-    }
-
-    #[pyfunction]
-    fn WaitForSingleObject(h: HANDLE, ms: u32, vm: &VirtualMachine) -> PyResult<u32> {
-        let ret =
-            unsafe { windows_sys::Win32::System::Threading::WaitForSingleObject(h.0 as _, ms) };
-        if ret == windows_sys::Win32::Foundation::WAIT_FAILED {
-            Err(errno_err(vm))
-        } else {
-            Ok(ret)
-        }
-    }
-
-    #[pyfunction]
-    fn GetExitCodeProcess(h: HANDLE, vm: &VirtualMachine) -> PyResult<u32> {
-        unsafe {
-            let mut ec = std::mem::MaybeUninit::uninit();
-            WindowsSysResult(windows_sys::Win32::System::Threading::GetExitCodeProcess(
-                h.0 as _,
-                ec.as_mut_ptr(),
-            ))
-            .to_pyresult(vm)?;
-            Ok(ec.assume_init())
-        }
-    }
-
-    #[pyfunction]
-    fn TerminateProcess(h: HANDLE, exit_code: u32) -> WindowsSysResult<BOOL> {
-        WindowsSysResult(unsafe {
-            windows_sys::Win32::System::Threading::TerminateProcess(h.0 as _, exit_code)
-        })
-    }
-
-    // TODO: ctypes.LibraryLoader.LoadLibrary
-    #[allow(dead_code)]
-    fn LoadLibrary(path: PyStrRef, vm: &VirtualMachine) -> PyResult<isize> {
-        let path = path.as_str().to_wide_with_nul();
-        let handle = unsafe {
-            windows::Win32::System::LibraryLoader::LoadLibraryW(PCWSTR::from_raw(path.as_ptr()))
-                .unwrap()
-        };
-        if handle.is_invalid() {
-            return Err(vm.new_runtime_error("LoadLibrary failed"));
-        }
-        Ok(handle.0)
-    }
-
-    #[pyfunction]
-    fn GetModuleFileName(handle: isize, vm: &VirtualMachine) -> PyResult<String> {
-        let mut path: Vec<u16> = vec![0; MAX_PATH as usize];
-        let handle = HINSTANCE(handle);
-
-        let length =
-            unsafe { windows::Win32::System::LibraryLoader::GetModuleFileNameW(handle, &mut path) };
-        if length == 0 {
-            return Err(vm.new_runtime_error("GetModuleFileName failed"));
-        }
-
-        let (path, _) = path.split_at(length as usize);
-        Ok(String::from_utf16(path).unwrap())
-    }
-
-    #[pyfunction]
-    fn OpenMutexW(desired_access: u32, inherit_handle: bool, name: u16) -> PyResult<isize> {
-        let handle = unsafe {
-            windows_sys::Win32::System::Threading::OpenMutexW(
-                desired_access,
-                BOOL::from(inherit_handle),
-                windows_sys::core::PCWSTR::from(name as _),
-            )
-        };
-        // if handle.is_invalid() {
-        //     return Err(errno_err(vm));
-        // }
-        Ok(handle as _)
-    }
-
-    #[pyfunction]
-    fn ReleaseMutex(handle: isize) -> WindowsSysResult<BOOL> {
-        WindowsSysResult(unsafe {
-            windows_sys::Win32::System::Threading::ReleaseMutex(handle as _)
-        })
-    }
-}
diff --git a/vm/src/stdlib/winreg.rs b/vm/src/stdlib/winreg.rs
deleted file mode 100644
index d64a05ea40..0000000000
--- a/vm/src/stdlib/winreg.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-// spell-checker:disable
-#![allow(non_snake_case)]
-
-use crate::{PyRef, VirtualMachine, builtins::PyModule};
-
-pub(crate) fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
-    let module = winreg::make_module(vm);
-
-    macro_rules! add_constants {
-        ($($name:ident),*$(,)?) => {
-            extend_module!(vm, &module, {
-                $((stringify!($name)) => vm.new_pyobj(::winreg::enums::$name as usize)),*
-            })
-        };
-    }
-
-    add_constants!(
-        HKEY_CLASSES_ROOT,
-        HKEY_CURRENT_USER,
-        HKEY_LOCAL_MACHINE,
-        HKEY_USERS,
-        HKEY_PERFORMANCE_DATA,
-        HKEY_CURRENT_CONFIG,
-        HKEY_DYN_DATA,
-    );
-    module
-}
-
-#[pymodule]
-mod winreg {
-    use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
-    use crate::{
-        PyObjectRef, PyPayload, PyRef, PyResult, TryFromObject, VirtualMachine, builtins::PyStrRef,
-        convert::ToPyException,
-    };
-    use ::winreg::{RegKey, RegValue, enums::RegType};
-    use std::mem::ManuallyDrop;
-    use std::{ffi::OsStr, io};
-    use windows_sys::Win32::Foundation;
-
-    // access rights
-    #[pyattr]
-    pub use windows_sys::Win32::System::Registry::{
-        KEY_ALL_ACCESS, KEY_CREATE_LINK, KEY_CREATE_SUB_KEY, KEY_ENUMERATE_SUB_KEYS, KEY_EXECUTE,
-        KEY_NOTIFY, KEY_QUERY_VALUE, KEY_READ, KEY_SET_VALUE, KEY_WOW64_32KEY, KEY_WOW64_64KEY,
-        KEY_WRITE,
-    };
-    // value types
-    #[pyattr]
-    pub use windows_sys::Win32::System::Registry::{
-        REG_BINARY, REG_CREATED_NEW_KEY, REG_DWORD, REG_DWORD_BIG_ENDIAN, REG_DWORD_LITTLE_ENDIAN,
-        REG_EXPAND_SZ, REG_FULL_RESOURCE_DESCRIPTOR, REG_LINK, REG_MULTI_SZ, REG_NONE,
-        REG_NOTIFY_CHANGE_ATTRIBUTES, REG_NOTIFY_CHANGE_LAST_SET, REG_NOTIFY_CHANGE_NAME,
-        REG_NOTIFY_CHANGE_SECURITY, REG_OPENED_EXISTING_KEY, REG_OPTION_BACKUP_RESTORE,
-        REG_OPTION_CREATE_LINK, REG_OPTION_NON_VOLATILE, REG_OPTION_OPEN_LINK, REG_OPTION_RESERVED,
-        REG_OPTION_VOLATILE, REG_QWORD, REG_QWORD_LITTLE_ENDIAN, REG_RESOURCE_LIST,
-        REG_RESOURCE_REQUIREMENTS_LIST, REG_SZ, REG_WHOLE_HIVE_VOLATILE,
-    };
-
-    #[pyattr]
-    #[pyclass(module = "winreg", name = "HKEYType")]
-    #[derive(Debug, PyPayload)]
-    struct PyHkey {
-        key: PyRwLock<RegKey>,
-    }
-    type PyHkeyRef = PyRef<PyHkey>;
-
-    // TODO: fix this
-    unsafe impl Sync for PyHkey {}
-
-    impl PyHkey {
-        fn new(key: RegKey) -> Self {
-            Self {
-                key: PyRwLock::new(key),
-            }
-        }
-
-        fn key(&self) -> PyRwLockReadGuard<'_, RegKey> {
-            self.key.read()
-        }
-
-        fn key_mut(&self) -> PyRwLockWriteGuard<'_, RegKey> {
-            self.key.write()
-        }
-    }
-
-    #[pyclass]
-    impl PyHkey {
-        #[pymethod]
-        fn Close(&self) {
-            let null_key = RegKey::predef(0 as ::winreg::HKEY);
-            let key = std::mem::replace(&mut *self.key_mut(), null_key);
-            drop(key);
-        }
-        #[pymethod]
-        fn Detach(&self) -> usize {
-            let null_key = RegKey::predef(0 as ::winreg::HKEY);
-            let key = std::mem::replace(&mut *self.key_mut(), null_key);
-            let handle = key.raw_handle();
-            std::mem::forget(key);
-            handle as usize
-        }
-
-        #[pymethod]
-        fn __bool__(&self) -> bool {
-            !self.key().raw_handle().is_null()
-        }
-        #[pymethod]
-        fn __enter__(zelf: PyRef<Self>) -> PyRef<Self> {
-            zelf
-        }
-        #[pymethod]
-        fn __exit__(&self, _cls: PyObjectRef, _exc: PyObjectRef, _tb: PyObjectRef) {
-            self.Close();
-        }
-    }
-
-    enum Hkey {
-        PyHkey(PyHkeyRef),
-        Constant(::winreg::HKEY),
-    }
-    impl TryFromObject for Hkey {
-        fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-            obj.downcast().map(Self::PyHkey).or_else(|o| {
-                usize::try_from_object(vm, o).map(|i| Self::Constant(i as ::winreg::HKEY))
-            })
-        }
-    }
-    impl Hkey {
-        fn with_key<R>(&self, f: impl FnOnce(&RegKey) -> R) -> R {
-            match self {
-                Self::PyHkey(py) => f(&py.key()),
-                Self::Constant(hkey) => {
-                    let k = ManuallyDrop::new(RegKey::predef(*hkey));
-                    f(&k)
-                }
-            }
-        }
-        fn into_key(self) -> RegKey {
-            let k = match self {
-                Self::PyHkey(py) => py.key().raw_handle(),
-                Self::Constant(k) => k,
-            };
-            RegKey::predef(k)
-        }
-    }
-
-    #[derive(FromArgs)]
-    struct OpenKeyArgs {
-        key: Hkey,
-        sub_key: Option<PyStrRef>,
-        #[pyarg(any, default = 0)]
-        reserved: i32,
-        #[pyarg(any, default = ::winreg::enums::KEY_READ)]
-        access: u32,
-    }
-
-    #[pyfunction(name = "OpenKeyEx")]
-    #[pyfunction]
-    fn OpenKey(args: OpenKeyArgs, vm: &VirtualMachine) -> PyResult<PyHkey> {
-        let OpenKeyArgs {
-            key,
-            sub_key,
-            reserved,
-            access,
-        } = args;
-
-        if reserved != 0 {
-            // RegKey::open_subkey* doesn't have a reserved param, so this'll do
-            return Err(vm.new_value_error("reserved param must be 0"));
-        }
-
-        let sub_key = sub_key.as_ref().map_or("", |s| s.as_str());
-        let key = key
-            .with_key(|k| k.open_subkey_with_flags(sub_key, access))
-            .map_err(|e| e.to_pyexception(vm))?;
-
-        Ok(PyHkey::new(key))
-    }
-
-    #[pyfunction]
-    fn QueryValue(key: Hkey, subkey: Option<PyStrRef>, vm: &VirtualMachine) -> PyResult<String> {
-        let subkey = subkey.as_ref().map_or("", |s| s.as_str());
-        key.with_key(|k| k.get_value(subkey))
-            .map_err(|e| e.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn QueryValueEx(
-        key: Hkey,
-        subkey: Option<PyStrRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<(PyObjectRef, usize)> {
-        let subkey = subkey.as_ref().map_or("", |s| s.as_str());
-        let regval = key
-            .with_key(|k| k.get_raw_value(subkey))
-            .map_err(|e| e.to_pyexception(vm))?;
-        #[allow(clippy::redundant_clone)]
-        let ty = regval.vtype.clone() as usize;
-        Ok((reg_to_py(regval, vm)?, ty))
-    }
-
-    #[pyfunction]
-    fn EnumKey(key: Hkey, index: u32, vm: &VirtualMachine) -> PyResult<String> {
-        key.with_key(|k| k.enum_keys().nth(index as usize))
-            .unwrap_or_else(|| {
-                Err(io::Error::from_raw_os_error(
-                    Foundation::ERROR_NO_MORE_ITEMS as i32,
-                ))
-            })
-            .map_err(|e| e.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn EnumValue(
-        key: Hkey,
-        index: u32,
-        vm: &VirtualMachine,
-    ) -> PyResult<(String, PyObjectRef, usize)> {
-        let (name, value) = key
-            .with_key(|k| k.enum_values().nth(index as usize))
-            .unwrap_or_else(|| {
-                Err(io::Error::from_raw_os_error(
-                    Foundation::ERROR_NO_MORE_ITEMS as i32,
-                ))
-            })
-            .map_err(|e| e.to_pyexception(vm))?;
-        #[allow(clippy::redundant_clone)]
-        let ty = value.vtype.clone() as usize;
-        Ok((name, reg_to_py(value, vm)?, ty))
-    }
-
-    #[pyfunction]
-    fn CloseKey(key: Hkey) {
-        match key {
-            Hkey::PyHkey(py) => py.Close(),
-            Hkey::Constant(hkey) => drop(RegKey::predef(hkey)),
-        }
-    }
-
-    #[pyfunction]
-    fn CreateKey(key: Hkey, subkey: Option<PyStrRef>, vm: &VirtualMachine) -> PyResult<PyHkey> {
-        let k = match subkey {
-            Some(subkey) => {
-                let (k, _disp) = key
-                    .with_key(|k| k.create_subkey(subkey.as_str()))
-                    .map_err(|e| e.to_pyexception(vm))?;
-                k
-            }
-            None => key.into_key(),
-        };
-        Ok(PyHkey::new(k))
-    }
-
-    #[pyfunction]
-    fn SetValue(
-        key: Hkey,
-        subkey: Option<PyStrRef>,
-        typ: u32,
-        value: PyStrRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        if typ != REG_SZ {
-            return Err(vm.new_type_error("type must be winreg.REG_SZ"));
-        }
-        let subkey = subkey.as_ref().map_or("", |s| s.as_str());
-        key.with_key(|k| k.set_value(subkey, &OsStr::new(value.as_str())))
-            .map_err(|e| e.to_pyexception(vm))
-    }
-
-    #[pyfunction]
-    fn DeleteKey(key: Hkey, subkey: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        key.with_key(|k| k.delete_subkey(subkey.as_str()))
-            .map_err(|e| e.to_pyexception(vm))
-    }
-
-    fn reg_to_py(value: RegValue, vm: &VirtualMachine) -> PyResult {
-        macro_rules! bytes_to_int {
-            ($int:ident, $f:ident, $name:ident) => {{
-                let i = if value.bytes.is_empty() {
-                    Ok(0 as $int)
-                } else {
-                    (&*value.bytes).try_into().map($int::$f).map_err(|_| {
-                        vm.new_value_error(format!("{} value is wrong length", stringify!(name)))
-                    })
-                };
-                i.map(|i| vm.ctx.new_int(i).into())
-            }};
-        }
-        let bytes_to_wide = |b| {
-            if <[u8]>::len(b) % 2 == 0 {
-                let (pref, wide, suf) = unsafe { <[u8]>::align_to::<u16>(b) };
-                assert!(pref.is_empty() && suf.is_empty(), "wide slice is unaligned");
-                Some(wide)
-            } else {
-                None
-            }
-        };
-        match value.vtype {
-            RegType::REG_DWORD => bytes_to_int!(u32, from_ne_bytes, REG_DWORD),
-            RegType::REG_DWORD_BIG_ENDIAN => {
-                bytes_to_int!(u32, from_be_bytes, REG_DWORD_BIG_ENDIAN)
-            }
-            RegType::REG_QWORD => bytes_to_int!(u64, from_ne_bytes, REG_DWORD),
-            // RegType::REG_QWORD_BIG_ENDIAN => bytes_to_int!(u64, from_be_bytes, REG_DWORD_BIG_ENDIAN),
-            RegType::REG_SZ | RegType::REG_EXPAND_SZ => {
-                let wide_slice = bytes_to_wide(&value.bytes).ok_or_else(|| {
-                    vm.new_value_error("REG_SZ string doesn't have an even byte length")
-                })?;
-                let nul_pos = wide_slice
-                    .iter()
-                    .position(|w| *w == 0)
-                    .unwrap_or(wide_slice.len());
-                let s = String::from_utf16_lossy(&wide_slice[..nul_pos]);
-                Ok(vm.ctx.new_str(s).into())
-            }
-            RegType::REG_MULTI_SZ => {
-                if value.bytes.is_empty() {
-                    return Ok(vm.ctx.new_list(vec![]).into());
-                }
-                let wide_slice = bytes_to_wide(&value.bytes).ok_or_else(|| {
-                    vm.new_value_error("REG_MULTI_SZ string doesn't have an even byte length")
-                })?;
-                let wide_slice = if let Some((0, rest)) = wide_slice.split_last() {
-                    rest
-                } else {
-                    wide_slice
-                };
-                let strings = wide_slice
-                    .split(|c| *c == 0)
-                    .map(|s| vm.new_pyobj(String::from_utf16_lossy(s)))
-                    .collect();
-                Ok(vm.ctx.new_list(strings).into())
-            }
-            _ => {
-                if value.bytes.is_empty() {
-                    Ok(vm.ctx.none())
-                } else {
-                    Ok(vm.ctx.new_bytes(value.bytes).into())
-                }
-            }
-        }
-    }
-}
diff --git a/vm/src/types/mod.rs b/vm/src/types/mod.rs
deleted file mode 100644
index 56d925bfaf..0000000000
--- a/vm/src/types/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-mod slot;
-mod structseq;
-mod zoo;
-
-pub use slot::*;
-pub use structseq::PyStructSequence;
-pub(crate) use zoo::TypeZoo;
diff --git a/vm/src/types/slot.rs b/vm/src/types/slot.rs
deleted file mode 100644
index 704ec3edf0..0000000000
--- a/vm/src/types/slot.rs
+++ /dev/null
@@ -1,1365 +0,0 @@
-use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyInt, PyStr, PyStrInterned, PyStrRef, PyType, PyTypeRef, type_::PointerSlot},
-    bytecode::ComparisonOperator,
-    common::hash::PyHash,
-    convert::{ToPyObject, ToPyResult},
-    function::{
-        Either, FromArgs, FuncArgs, OptionalArg, PyComparisonValue, PyMethodDef, PySetterValue,
-    },
-    identifier,
-    protocol::{
-        PyBuffer, PyIterReturn, PyMapping, PyMappingMethods, PyNumber, PyNumberMethods,
-        PyNumberSlots, PySequence, PySequenceMethods,
-    },
-    vm::Context,
-};
-use crossbeam_utils::atomic::AtomicCell;
-use malachite_bigint::BigInt;
-use num_traits::{Signed, ToPrimitive};
-use std::{borrow::Borrow, cmp::Ordering, ops::Deref};
-
-#[macro_export]
-macro_rules! atomic_func {
-    ($x:expr) => {
-        crossbeam_utils::atomic::AtomicCell::new(Some($x))
-    };
-}
-
-// The corresponding field in CPython is `tp_` prefixed.
-// e.g. name -> tp_name
-#[derive(Default)]
-#[non_exhaustive]
-pub struct PyTypeSlots {
-    /// # Safety
-    /// For static types, always safe.
-    /// For heap types, `__name__` must alive
-    pub(crate) name: &'static str, // tp_name with <module>.<class> for print, not class name
-
-    pub basicsize: usize,
-    // tp_itemsize
-
-    // Methods to implement standard operations
-
-    // Method suites for standard classes
-    pub as_number: PyNumberSlots,
-    pub as_sequence: AtomicCell<Option<PointerSlot<PySequenceMethods>>>,
-    pub as_mapping: AtomicCell<Option<PointerSlot<PyMappingMethods>>>,
-
-    // More standard operations (here for binary compatibility)
-    pub hash: AtomicCell<Option<HashFunc>>,
-    pub call: AtomicCell<Option<GenericMethod>>,
-    // tp_str
-    pub repr: AtomicCell<Option<StringifyFunc>>,
-    pub getattro: AtomicCell<Option<GetattroFunc>>,
-    pub setattro: AtomicCell<Option<SetattroFunc>>,
-
-    // Functions to access object as input/output buffer
-    pub as_buffer: Option<AsBufferFunc>,
-
-    // Assigned meaning in release 2.1
-    // rich comparisons
-    pub richcompare: AtomicCell<Option<RichCompareFunc>>,
-
-    // Iterators
-    pub iter: AtomicCell<Option<IterFunc>>,
-    pub iternext: AtomicCell<Option<IterNextFunc>>,
-
-    pub methods: &'static [PyMethodDef],
-
-    // Flags to define presence of optional/expanded features
-    pub flags: PyTypeFlags,
-
-    // tp_doc
-    pub doc: Option<&'static str>,
-
-    // Strong reference on a heap type, borrowed reference on a static type
-    // tp_base
-    // tp_dict
-    pub descr_get: AtomicCell<Option<DescrGetFunc>>,
-    pub descr_set: AtomicCell<Option<DescrSetFunc>>,
-    // tp_dictoffset
-    pub init: AtomicCell<Option<InitFunc>>,
-    // tp_alloc
-    pub new: AtomicCell<Option<NewFunc>>,
-    // tp_free
-    // tp_is_gc
-    // tp_bases
-    // tp_mro
-    // tp_cache
-    // tp_subclasses
-    // tp_weaklist
-    pub del: AtomicCell<Option<DelFunc>>,
-
-    // The count of tp_members.
-    pub member_count: usize,
-}
-
-impl PyTypeSlots {
-    pub fn new(name: &'static str, flags: PyTypeFlags) -> Self {
-        Self {
-            name,
-            flags,
-            ..Default::default()
-        }
-    }
-
-    pub fn heap_default() -> Self {
-        Self {
-            // init: AtomicCell::new(Some(init_wrapper)),
-            ..Default::default()
-        }
-    }
-}
-
-impl std::fmt::Debug for PyTypeSlots {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("PyTypeSlots")
-    }
-}
-
-bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    #[non_exhaustive]
-    pub struct PyTypeFlags: u64 {
-        const IMMUTABLETYPE = 1 << 8;
-        const HEAPTYPE = 1 << 9;
-        const BASETYPE = 1 << 10;
-        const METHOD_DESCRIPTOR = 1 << 17;
-        const HAS_DICT = 1 << 40;
-
-        #[cfg(debug_assertions)]
-        const _CREATED_WITH_FLAGS = 1 << 63;
-    }
-}
-
-impl PyTypeFlags {
-    // Default used for both built-in and normal classes: empty, for now.
-    // CPython default: Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | Py_TPFLAGS_HAVE_VERSION_TAG
-    pub const DEFAULT: Self = Self::empty();
-
-    // CPython: See initialization of flags in type_new.
-    /// Used for types created in Python. Subclassable and are a
-    /// heaptype.
-    pub const fn heap_type_flags() -> Self {
-        match Self::from_bits(Self::DEFAULT.bits() | Self::HEAPTYPE.bits() | Self::BASETYPE.bits())
-        {
-            Some(flags) => flags,
-            None => unreachable!(),
-        }
-    }
-
-    pub const fn has_feature(self, flag: Self) -> bool {
-        self.contains(flag)
-    }
-
-    #[cfg(debug_assertions)]
-    pub const fn is_created_with_flags(self) -> bool {
-        self.contains(Self::_CREATED_WITH_FLAGS)
-    }
-}
-
-impl Default for PyTypeFlags {
-    fn default() -> Self {
-        Self::DEFAULT
-    }
-}
-
-pub(crate) type GenericMethod = fn(&PyObject, FuncArgs, &VirtualMachine) -> PyResult;
-pub(crate) type HashFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyHash>;
-// CallFunc = GenericMethod
-pub(crate) type StringifyFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyStrRef>;
-pub(crate) type GetattroFunc = fn(&PyObject, &Py<PyStr>, &VirtualMachine) -> PyResult;
-pub(crate) type SetattroFunc =
-    fn(&PyObject, &Py<PyStr>, PySetterValue, &VirtualMachine) -> PyResult<()>;
-pub(crate) type AsBufferFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyBuffer>;
-pub(crate) type RichCompareFunc = fn(
-    &PyObject,
-    &PyObject,
-    PyComparisonOp,
-    &VirtualMachine,
-) -> PyResult<Either<PyObjectRef, PyComparisonValue>>;
-pub(crate) type IterFunc = fn(PyObjectRef, &VirtualMachine) -> PyResult;
-pub(crate) type IterNextFunc = fn(&PyObject, &VirtualMachine) -> PyResult<PyIterReturn>;
-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 NewFunc = fn(PyTypeRef, FuncArgs, &VirtualMachine) -> PyResult;
-pub(crate) type InitFunc = fn(PyObjectRef, FuncArgs, &VirtualMachine) -> PyResult<()>;
-pub(crate) type DelFunc = fn(&PyObject, &VirtualMachine) -> PyResult<()>;
-
-// slot_sq_length
-pub(crate) fn len_wrapper(obj: &PyObject, vm: &VirtualMachine) -> PyResult<usize> {
-    let ret = vm.call_special_method(obj, identifier!(vm, __len__), ())?;
-    let len = ret.payload::<PyInt>().ok_or_else(|| {
-        vm.new_type_error(format!(
-            "'{}' object cannot be interpreted as an integer",
-            ret.class()
-        ))
-    })?;
-    let len = len.as_bigint();
-    if len.is_negative() {
-        return Err(vm.new_value_error("__len__() should return >= 0"));
-    }
-    let len = len
-        .to_isize()
-        .ok_or_else(|| vm.new_overflow_error("cannot fit 'int' into an index-sized integer"))?;
-    Ok(len as usize)
-}
-
-pub(crate) fn contains_wrapper(
-    obj: &PyObject,
-    needle: &PyObject,
-    vm: &VirtualMachine,
-) -> PyResult<bool> {
-    let ret = vm.call_special_method(obj, identifier!(vm, __contains__), (needle,))?;
-    ret.try_to_bool(vm)
-}
-
-macro_rules! number_unary_op_wrapper {
-    ($name:ident) => {
-        |a, vm| vm.call_special_method(a.deref(), identifier!(vm, $name), ())
-    };
-}
-macro_rules! number_binary_op_wrapper {
-    ($name:ident) => {
-        |a, b, vm| vm.call_special_method(a, identifier!(vm, $name), (b.to_owned(),))
-    };
-}
-macro_rules! number_binary_right_op_wrapper {
-    ($name:ident) => {
-        |a, b, vm| vm.call_special_method(b, identifier!(vm, $name), (a.to_owned(),))
-    };
-}
-fn getitem_wrapper<K: ToPyObject>(obj: &PyObject, needle: K, vm: &VirtualMachine) -> PyResult {
-    vm.call_special_method(obj, identifier!(vm, __getitem__), (needle,))
-}
-
-fn setitem_wrapper<K: ToPyObject>(
-    obj: &PyObject,
-    needle: K,
-    value: Option<PyObjectRef>,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    match value {
-        Some(value) => vm.call_special_method(obj, identifier!(vm, __setitem__), (needle, value)),
-        None => vm.call_special_method(obj, identifier!(vm, __delitem__), (needle,)),
-    }
-    .map(drop)
-}
-
-fn repr_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-    let ret = vm.call_special_method(zelf, identifier!(vm, __repr__), ())?;
-    ret.downcast::<PyStr>().map_err(|obj| {
-        vm.new_type_error(format!(
-            "__repr__ returned non-string (type {})",
-            obj.class()
-        ))
-    })
-}
-
-fn hash_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
-    let hash_obj = vm.call_special_method(zelf, identifier!(vm, __hash__), ())?;
-    let py_int = hash_obj
-        .payload_if_subclass::<PyInt>(vm)
-        .ok_or_else(|| vm.new_type_error("__hash__ method should return an integer"))?;
-    let big_int = py_int.as_bigint();
-    let hash: PyHash = big_int
-        .to_i64()
-        .unwrap_or_else(|| (big_int % BigInt::from(u64::MAX)).to_i64().unwrap());
-    Ok(hash)
-}
-
-/// Marks a type as unhashable. Similar to PyObject_HashNotImplemented in CPython
-pub fn hash_not_implemented(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
-    Err(vm.new_type_error(format!("unhashable type: {}", zelf.class().name())))
-}
-
-fn call_wrapper(zelf: &PyObject, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-    vm.call_special_method(zelf, identifier!(vm, __call__), args)
-}
-
-fn getattro_wrapper(zelf: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-    let __getattribute__ = identifier!(vm, __getattribute__);
-    let __getattr__ = identifier!(vm, __getattr__);
-    match vm.call_special_method(zelf, __getattribute__, (name.to_owned(),)) {
-        Ok(r) => Ok(r),
-        Err(_) if zelf.class().has_attr(__getattr__) => {
-            vm.call_special_method(zelf, __getattr__, (name.to_owned(),))
-        }
-        Err(e) => Err(e),
-    }
-}
-
-fn setattro_wrapper(
-    zelf: &PyObject,
-    name: &Py<PyStr>,
-    value: PySetterValue,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    let name = name.to_owned();
-    match value {
-        PySetterValue::Assign(value) => {
-            vm.call_special_method(zelf, identifier!(vm, __setattr__), (name, value))?;
-        }
-        PySetterValue::Delete => {
-            vm.call_special_method(zelf, identifier!(vm, __delattr__), (name,))?;
-        }
-    };
-    Ok(())
-}
-
-pub(crate) fn richcompare_wrapper(
-    zelf: &PyObject,
-    other: &PyObject,
-    op: PyComparisonOp,
-    vm: &VirtualMachine,
-) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
-    vm.call_special_method(zelf, op.method_name(&vm.ctx), (other.to_owned(),))
-        .map(Either::A)
-}
-
-fn iter_wrapper(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-    vm.call_special_method(&zelf, identifier!(vm, __iter__), ())
-}
-
-// PyObject_SelfIter in CPython
-const fn self_iter(zelf: PyObjectRef, _vm: &VirtualMachine) -> PyResult {
-    Ok(zelf)
-}
-
-fn iternext_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-    PyIterReturn::from_pyresult(
-        vm.call_special_method(zelf, identifier!(vm, __next__), ()),
-        vm,
-    )
-}
-
-fn descr_get_wrapper(
-    zelf: PyObjectRef,
-    obj: Option<PyObjectRef>,
-    cls: Option<PyObjectRef>,
-    vm: &VirtualMachine,
-) -> PyResult {
-    vm.call_special_method(&zelf, identifier!(vm, __get__), (obj, cls))
-}
-
-fn descr_set_wrapper(
-    zelf: &PyObject,
-    obj: PyObjectRef,
-    value: PySetterValue,
-    vm: &VirtualMachine,
-) -> PyResult<()> {
-    match value {
-        PySetterValue::Assign(val) => {
-            vm.call_special_method(zelf, identifier!(vm, __set__), (obj, val))
-        }
-        PySetterValue::Delete => vm.call_special_method(zelf, identifier!(vm, __delete__), (obj,)),
-    }
-    .map(drop)
-}
-
-fn init_wrapper(obj: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-    let res = vm.call_special_method(&obj, identifier!(vm, __init__), args)?;
-    if !vm.is_none(&res) {
-        return Err(vm.new_type_error("__init__ must return None"));
-    }
-    Ok(())
-}
-
-pub(crate) fn new_wrapper(cls: PyTypeRef, mut args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-    let new = cls.get_attr(identifier!(vm, __new__)).unwrap();
-    args.prepend_arg(cls.into());
-    new.call(args, vm)
-}
-
-fn del_wrapper(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-    vm.call_special_method(zelf, identifier!(vm, __del__), ())?;
-    Ok(())
-}
-
-impl PyType {
-    pub(crate) fn update_slot<const ADD: bool>(&self, name: &'static PyStrInterned, ctx: &Context) {
-        debug_assert!(name.as_str().starts_with("__"));
-        debug_assert!(name.as_str().ends_with("__"));
-
-        macro_rules! toggle_slot {
-            ($name:ident, $func:expr) => {{
-                self.slots.$name.store(if ADD { Some($func) } else { None });
-            }};
-        }
-
-        macro_rules! toggle_sub_slot {
-            ($group:ident, $name:ident, $func:expr) => {
-                self.slots
-                    .$group
-                    .$name
-                    .store(if ADD { Some($func) } else { None });
-            };
-        }
-
-        macro_rules! update_slot {
-            ($name:ident, $func:expr) => {{
-                self.slots.$name.store(Some($func));
-            }};
-        }
-
-        macro_rules! update_pointer_slot {
-            ($name:ident, $pointed:ident) => {{
-                self.slots
-                    .$name
-                    .store(unsafe { PointerSlot::from_heaptype(self, |ext| &ext.$pointed) });
-            }};
-        }
-
-        macro_rules! toggle_ext_func {
-            ($n1:ident, $n2:ident, $func:expr) => {{
-                self.heaptype_ext.as_ref().unwrap().$n1.$n2.store(if ADD {
-                    Some($func)
-                } else {
-                    None
-                });
-            }};
-        }
-
-        match name {
-            _ if name == identifier!(ctx, __len__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, length, |seq, vm| len_wrapper(seq.obj, vm));
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, length, |mapping, vm| len_wrapper(
-                    mapping.obj,
-                    vm
-                ));
-                update_pointer_slot!(as_mapping, mapping_methods);
-            }
-            _ if name == identifier!(ctx, __getitem__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, item, |seq, i, vm| getitem_wrapper(
-                    seq.obj, i, vm
-                ));
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, subscript, |mapping, key, vm| {
-                    getitem_wrapper(mapping.obj, key, vm)
-                });
-                update_pointer_slot!(as_mapping, mapping_methods);
-            }
-            _ if name == identifier!(ctx, __setitem__) || name == identifier!(ctx, __delitem__) => {
-                // update_slot!(as_mapping, slot_as_mapping);
-                toggle_ext_func!(sequence_methods, ass_item, |seq, i, value, vm| {
-                    setitem_wrapper(seq.obj, i, value, vm)
-                });
-                update_pointer_slot!(as_sequence, sequence_methods);
-                toggle_ext_func!(mapping_methods, ass_subscript, |mapping, key, value, vm| {
-                    setitem_wrapper(mapping.obj, key, value, vm)
-                });
-                update_pointer_slot!(as_mapping, mapping_methods);
-            }
-            _ if name == identifier!(ctx, __contains__) => {
-                toggle_ext_func!(sequence_methods, contains, |seq, needle, vm| {
-                    contains_wrapper(seq.obj, needle, vm)
-                });
-                update_pointer_slot!(as_sequence, sequence_methods);
-            }
-            _ if name == identifier!(ctx, __repr__) => {
-                update_slot!(repr, repr_wrapper);
-            }
-            _ if name == identifier!(ctx, __hash__) => {
-                let is_unhashable = self
-                    .attributes
-                    .read()
-                    .get(identifier!(ctx, __hash__))
-                    .is_some_and(|a| a.is(&ctx.none));
-                let wrapper = if is_unhashable {
-                    hash_not_implemented
-                } else {
-                    hash_wrapper
-                };
-                toggle_slot!(hash, wrapper);
-            }
-            _ if name == identifier!(ctx, __call__) => {
-                toggle_slot!(call, call_wrapper);
-            }
-            _ if name == identifier!(ctx, __getattr__)
-                || name == identifier!(ctx, __getattribute__) =>
-            {
-                update_slot!(getattro, getattro_wrapper);
-            }
-            _ if name == identifier!(ctx, __setattr__) || name == identifier!(ctx, __delattr__) => {
-                update_slot!(setattro, setattro_wrapper);
-            }
-            _ if name == identifier!(ctx, __eq__)
-                || name == identifier!(ctx, __ne__)
-                || name == identifier!(ctx, __le__)
-                || name == identifier!(ctx, __lt__)
-                || name == identifier!(ctx, __ge__)
-                || name == identifier!(ctx, __gt__) =>
-            {
-                update_slot!(richcompare, richcompare_wrapper);
-            }
-            _ if name == identifier!(ctx, __iter__) => {
-                toggle_slot!(iter, iter_wrapper);
-            }
-            _ if name == identifier!(ctx, __next__) => {
-                toggle_slot!(iternext, iternext_wrapper);
-            }
-            _ if name == identifier!(ctx, __get__) => {
-                toggle_slot!(descr_get, descr_get_wrapper);
-            }
-            _ if name == identifier!(ctx, __set__) || name == identifier!(ctx, __delete__) => {
-                update_slot!(descr_set, descr_set_wrapper);
-            }
-            _ if name == identifier!(ctx, __init__) => {
-                toggle_slot!(init, init_wrapper);
-            }
-            _ if name == identifier!(ctx, __new__) => {
-                toggle_slot!(new, new_wrapper);
-            }
-            _ if name == identifier!(ctx, __del__) => {
-                toggle_slot!(del, del_wrapper);
-            }
-            _ if name == identifier!(ctx, __int__) => {
-                toggle_sub_slot!(as_number, int, number_unary_op_wrapper!(__int__));
-            }
-            _ if name == identifier!(ctx, __index__) => {
-                toggle_sub_slot!(as_number, index, number_unary_op_wrapper!(__index__));
-            }
-            _ if name == identifier!(ctx, __float__) => {
-                toggle_sub_slot!(as_number, float, number_unary_op_wrapper!(__float__));
-            }
-            _ if name == identifier!(ctx, __add__) => {
-                toggle_sub_slot!(as_number, add, number_binary_op_wrapper!(__add__));
-            }
-            _ if name == identifier!(ctx, __radd__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_add,
-                    number_binary_right_op_wrapper!(__radd__)
-                );
-            }
-            _ if name == identifier!(ctx, __iadd__) => {
-                toggle_sub_slot!(as_number, inplace_add, number_binary_op_wrapper!(__iadd__));
-            }
-            _ if name == identifier!(ctx, __sub__) => {
-                toggle_sub_slot!(as_number, subtract, number_binary_op_wrapper!(__sub__));
-            }
-            _ if name == identifier!(ctx, __rsub__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_subtract,
-                    number_binary_right_op_wrapper!(__rsub__)
-                );
-            }
-            _ if name == identifier!(ctx, __isub__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_subtract,
-                    number_binary_op_wrapper!(__isub__)
-                );
-            }
-            _ if name == identifier!(ctx, __mul__) => {
-                toggle_sub_slot!(as_number, multiply, number_binary_op_wrapper!(__mul__));
-            }
-            _ if name == identifier!(ctx, __rmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_multiply,
-                    number_binary_right_op_wrapper!(__rmul__)
-                );
-            }
-            _ if name == identifier!(ctx, __imul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_multiply,
-                    number_binary_op_wrapper!(__imul__)
-                );
-            }
-            _ if name == identifier!(ctx, __mod__) => {
-                toggle_sub_slot!(as_number, remainder, number_binary_op_wrapper!(__mod__));
-            }
-            _ if name == identifier!(ctx, __rmod__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_remainder,
-                    number_binary_right_op_wrapper!(__rmod__)
-                );
-            }
-            _ if name == identifier!(ctx, __imod__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_remainder,
-                    number_binary_op_wrapper!(__imod__)
-                );
-            }
-            _ if name == identifier!(ctx, __divmod__) => {
-                toggle_sub_slot!(as_number, divmod, number_binary_op_wrapper!(__divmod__));
-            }
-            _ if name == identifier!(ctx, __rdivmod__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_divmod,
-                    number_binary_right_op_wrapper!(__rdivmod__)
-                );
-            }
-            _ if name == identifier!(ctx, __pow__) => {
-                toggle_sub_slot!(as_number, power, |a, b, c, vm| {
-                    let args = if vm.is_none(c) {
-                        vec![b.to_owned()]
-                    } else {
-                        vec![b.to_owned(), c.to_owned()]
-                    };
-                    vm.call_special_method(a, identifier!(vm, __pow__), args)
-                });
-            }
-            _ if name == identifier!(ctx, __rpow__) => {
-                toggle_sub_slot!(as_number, right_power, |a, b, c, vm| {
-                    let args = if vm.is_none(c) {
-                        vec![a.to_owned()]
-                    } else {
-                        vec![a.to_owned(), c.to_owned()]
-                    };
-                    vm.call_special_method(b, identifier!(vm, __rpow__), args)
-                });
-            }
-            _ if name == identifier!(ctx, __ipow__) => {
-                toggle_sub_slot!(as_number, inplace_power, |a, b, _, vm| {
-                    vm.call_special_method(a, identifier!(vm, __ipow__), (b.to_owned(),))
-                });
-            }
-            _ if name == identifier!(ctx, __lshift__) => {
-                toggle_sub_slot!(as_number, lshift, number_binary_op_wrapper!(__lshift__));
-            }
-            _ if name == identifier!(ctx, __rlshift__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_lshift,
-                    number_binary_right_op_wrapper!(__rlshift__)
-                );
-            }
-            _ if name == identifier!(ctx, __ilshift__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_lshift,
-                    number_binary_op_wrapper!(__ilshift__)
-                );
-            }
-            _ if name == identifier!(ctx, __rshift__) => {
-                toggle_sub_slot!(as_number, rshift, number_binary_op_wrapper!(__rshift__));
-            }
-            _ if name == identifier!(ctx, __rrshift__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_rshift,
-                    number_binary_right_op_wrapper!(__rrshift__)
-                );
-            }
-            _ if name == identifier!(ctx, __irshift__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_rshift,
-                    number_binary_op_wrapper!(__irshift__)
-                );
-            }
-            _ if name == identifier!(ctx, __and__) => {
-                toggle_sub_slot!(as_number, and, number_binary_op_wrapper!(__and__));
-            }
-            _ if name == identifier!(ctx, __rand__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_and,
-                    number_binary_right_op_wrapper!(__rand__)
-                );
-            }
-            _ if name == identifier!(ctx, __iand__) => {
-                toggle_sub_slot!(as_number, inplace_and, number_binary_op_wrapper!(__iand__));
-            }
-            _ if name == identifier!(ctx, __xor__) => {
-                toggle_sub_slot!(as_number, xor, number_binary_op_wrapper!(__xor__));
-            }
-            _ if name == identifier!(ctx, __rxor__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_xor,
-                    number_binary_right_op_wrapper!(__rxor__)
-                );
-            }
-            _ if name == identifier!(ctx, __ixor__) => {
-                toggle_sub_slot!(as_number, inplace_xor, number_binary_op_wrapper!(__ixor__));
-            }
-            _ if name == identifier!(ctx, __or__) => {
-                toggle_sub_slot!(as_number, or, number_binary_op_wrapper!(__or__));
-            }
-            _ if name == identifier!(ctx, __ror__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_or,
-                    number_binary_right_op_wrapper!(__ror__)
-                );
-            }
-            _ if name == identifier!(ctx, __ior__) => {
-                toggle_sub_slot!(as_number, inplace_or, number_binary_op_wrapper!(__ior__));
-            }
-            _ if name == identifier!(ctx, __floordiv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    floor_divide,
-                    number_binary_op_wrapper!(__floordiv__)
-                );
-            }
-            _ if name == identifier!(ctx, __rfloordiv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_floor_divide,
-                    number_binary_right_op_wrapper!(__rfloordiv__)
-                );
-            }
-            _ if name == identifier!(ctx, __ifloordiv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_floor_divide,
-                    number_binary_op_wrapper!(__ifloordiv__)
-                );
-            }
-            _ if name == identifier!(ctx, __truediv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    true_divide,
-                    number_binary_op_wrapper!(__truediv__)
-                );
-            }
-            _ if name == identifier!(ctx, __rtruediv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_true_divide,
-                    number_binary_right_op_wrapper!(__rtruediv__)
-                );
-            }
-            _ if name == identifier!(ctx, __itruediv__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_true_divide,
-                    number_binary_op_wrapper!(__itruediv__)
-                );
-            }
-            _ if name == identifier!(ctx, __matmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    matrix_multiply,
-                    number_binary_op_wrapper!(__matmul__)
-                );
-            }
-            _ if name == identifier!(ctx, __rmatmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    right_matrix_multiply,
-                    number_binary_right_op_wrapper!(__rmatmul__)
-                );
-            }
-            _ if name == identifier!(ctx, __imatmul__) => {
-                toggle_sub_slot!(
-                    as_number,
-                    inplace_matrix_multiply,
-                    number_binary_op_wrapper!(__imatmul__)
-                );
-            }
-            _ => {}
-        }
-    }
-}
-
-#[pyclass]
-pub trait Constructor: PyPayload {
-    type Args: FromArgs;
-
-    #[inline]
-    #[pyslot]
-    fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        let args: Self::Args = args.bind(vm)?;
-        Self::py_new(cls, args, vm)
-    }
-
-    fn py_new(cls: PyTypeRef, args: Self::Args, vm: &VirtualMachine) -> PyResult;
-}
-
-pub trait DefaultConstructor: PyPayload + Default {
-    fn construct_and_init(args: Self::Args, vm: &VirtualMachine) -> PyResult<PyRef<Self>>
-    where
-        Self: Initializer,
-    {
-        let this = Self::default().into_ref(&vm.ctx);
-        Self::init(this.clone(), args, vm)?;
-        Ok(this)
-    }
-}
-
-/// For types that cannot be instantiated through Python code.
-#[pyclass]
-pub trait Unconstructible: PyPayload {
-    #[pyslot]
-    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_type_error(format!("cannot create {} instances", cls.slot_name())))
-    }
-}
-
-impl<T> Constructor for T
-where
-    T: DefaultConstructor,
-{
-    type Args = FuncArgs;
-
-    fn slot_new(cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult {
-        Self::default().into_ref_with_type(vm, cls).map(Into::into)
-    }
-
-    fn py_new(cls: PyTypeRef, _args: Self::Args, vm: &VirtualMachine) -> PyResult {
-        Err(vm.new_type_error(format!("cannot create {} instances", cls.slot_name())))
-    }
-}
-
-#[pyclass]
-pub trait Initializer: PyPayload {
-    type Args: FromArgs;
-
-    #[pyslot]
-    #[inline]
-    fn slot_init(zelf: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        let zelf = zelf.try_into_value(vm)?;
-        let args: Self::Args = args.bind(vm)?;
-        Self::init(zelf, args, vm)
-    }
-
-    #[pymethod]
-    #[inline]
-    fn __init__(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
-        Self::init(zelf, args, vm)
-    }
-
-    fn init(zelf: PyRef<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()>;
-}
-
-#[pyclass]
-pub trait Destructor: PyPayload {
-    #[inline] // for __del__
-    #[pyslot]
-    fn slot_del(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
-        let zelf = zelf
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __del__"))?;
-        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<()>;
-}
-
-#[pyclass]
-pub trait Callable: PyPayload {
-    type Args: FromArgs;
-
-    #[inline]
-    #[pyslot]
-    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()
-            } else {
-                zelf.class().name().to_owned()
-            };
-            vm.new_type_error(format!("unexpected payload for __call__ of {help}"))
-        })?;
-        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;
-}
-
-#[pyclass]
-pub trait GetDescriptor: PyPayload {
-    #[pyslot]
-    fn descr_get(
-        zelf: PyObjectRef,
-        obj: Option<PyObjectRef>,
-        cls: Option<PyObjectRef>,
-        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)
-    }
-
-    #[inline]
-    fn _unwrap<'a>(
-        zelf: &'a PyObject,
-        obj: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> PyResult<(&'a Py<Self>, PyObjectRef)> {
-        let zelf = Self::_as_pyref(zelf, vm)?;
-        let obj = vm.unwrap_or_none(obj);
-        Ok((zelf, obj))
-    }
-
-    #[inline]
-    fn _check<'a>(
-        zelf: &'a PyObject,
-        obj: Option<PyObjectRef>,
-        vm: &VirtualMachine,
-    ) -> Option<(&'a Py<Self>, PyObjectRef)> {
-        // CPython descr_check
-        let obj = obj?;
-        // if (!PyObject_TypeCheck(obj, descr->d_type)) {
-        //     PyErr_Format(PyExc_TypeError,
-        //                  "descriptor '%V' for '%.100s' objects "
-        //                  "doesn't apply to a '%.100s' object",
-        //                  descr_name((PyDescrObject *)descr), "?",
-        //                  descr->d_type->slot_name,
-        //                  obj->ob_type->slot_name);
-        //     *pres = NULL;
-        //     return 1;
-        // } else {
-        Some((Self::_as_pyref(zelf, vm).unwrap(), obj))
-    }
-
-    #[inline]
-    fn _cls_is(cls: &Option<PyObjectRef>, other: &impl Borrow<PyObject>) -> bool {
-        cls.as_ref().is_some_and(|cls| other.borrow().is(cls))
-    }
-}
-
-#[pyclass]
-pub trait Hashable: PyPayload {
-    #[inline]
-    #[pyslot]
-    fn slot_hash(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash> {
-        let zelf = zelf
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __hash__"))?;
-        Self::hash(zelf, vm)
-    }
-
-    #[inline]
-    #[pymethod]
-    fn __hash__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyHash> {
-        Self::slot_hash(&zelf, vm)
-    }
-
-    fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>;
-}
-
-#[pyclass]
-pub trait Representable: PyPayload {
-    #[inline]
-    #[pyslot]
-    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let zelf = zelf
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __repr__"))?;
-        Self::repr(zelf, vm)
-    }
-
-    #[inline]
-    #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
-    }
-
-    #[inline]
-    fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let repr = Self::repr_str(zelf, vm)?;
-        Ok(vm.ctx.new_str(repr))
-    }
-
-    fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>;
-}
-
-#[pyclass]
-pub trait Comparable: PyPayload {
-    #[inline]
-    #[pyslot]
-    fn slot_richcompare(
-        zelf: &PyObject,
-        other: &PyObject,
-        op: PyComparisonOp,
-        vm: &VirtualMachine,
-    ) -> PyResult<Either<PyObjectRef, PyComparisonValue>> {
-        let zelf = zelf.downcast_ref().ok_or_else(|| {
-            vm.new_type_error(format!(
-                "unexpected payload for {}",
-                op.method_name(&vm.ctx).as_str()
-            ))
-        })?;
-        Self::cmp(zelf, other, op, vm).map(Either::B)
-    }
-
-    fn cmp(
-        zelf: &Py<Self>,
-        other: &PyObject,
-        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)]
-#[repr(transparent)]
-pub struct PyComparisonOp(ComparisonOperator);
-
-impl From<ComparisonOperator> for PyComparisonOp {
-    fn from(op: ComparisonOperator) -> Self {
-        Self(op)
-    }
-}
-
-#[allow(non_upper_case_globals)]
-impl PyComparisonOp {
-    pub const Lt: Self = Self(ComparisonOperator::Less);
-    pub const Gt: Self = Self(ComparisonOperator::Greater);
-    pub const Ne: Self = Self(ComparisonOperator::NotEqual);
-    pub const Eq: Self = Self(ComparisonOperator::Equal);
-    pub const Le: Self = Self(ComparisonOperator::LessOrEqual);
-    pub const Ge: Self = Self(ComparisonOperator::GreaterOrEqual);
-}
-
-impl PyComparisonOp {
-    pub fn eq_only(
-        self,
-        f: impl FnOnce() -> PyResult<PyComparisonValue>,
-    ) -> PyResult<PyComparisonValue> {
-        match self {
-            Self::Eq => f(),
-            Self::Ne => f().map(|x| x.map(|eq| !eq)),
-            _ => Ok(PyComparisonValue::NotImplemented),
-        }
-    }
-
-    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 const fn swapped(self) -> Self {
-        match self {
-            Self::Lt => Self::Gt,
-            Self::Le => Self::Ge,
-            Self::Eq => Self::Eq,
-            Self::Ne => Self::Ne,
-            Self::Ge => Self::Le,
-            Self::Gt => Self::Lt,
-        }
-    }
-
-    pub fn method_name(self, ctx: &Context) -> &'static PyStrInterned {
-        match self {
-            Self::Lt => identifier!(ctx, __lt__),
-            Self::Le => identifier!(ctx, __le__),
-            Self::Eq => identifier!(ctx, __eq__),
-            Self::Ne => identifier!(ctx, __ne__),
-            Self::Ge => identifier!(ctx, __ge__),
-            Self::Gt => identifier!(ctx, __gt__),
-        }
-    }
-
-    pub const fn operator_token(self) -> &'static str {
-        match self {
-            Self::Lt => "<",
-            Self::Le => "<=",
-            Self::Eq => "==",
-            Self::Ne => "!=",
-            Self::Ge => ">=",
-            Self::Gt => ">",
-        }
-    }
-
-    /// Returns an appropriate return value for the comparison when a and b are the same object, if an
-    /// appropriate return value exists.
-    #[inline]
-    pub fn identical_optimization(
-        self,
-        a: &impl Borrow<PyObject>,
-        b: &impl Borrow<PyObject>,
-    ) -> Option<bool> {
-        self.map_eq(|| a.borrow().is(b.borrow()))
-    }
-
-    /// Returns `Some(true)` when self is `Eq` and `f()` returns true. Returns `Some(false)` when self
-    /// is `Ne` and `f()` returns true. Otherwise returns `None`.
-    #[inline]
-    pub fn map_eq(self, f: impl FnOnce() -> bool) -> Option<bool> {
-        let eq = match self {
-            Self::Eq => true,
-            Self::Ne => false,
-            _ => return None,
-        };
-        f().then_some(eq)
-    }
-}
-
-#[pyclass]
-pub trait GetAttr: PyPayload {
-    #[pyslot]
-    fn slot_getattro(obj: &PyObject, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult {
-        let zelf = obj
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __getattribute__"))?;
-        Self::getattro(zelf, name, vm)
-    }
-
-    fn getattro(zelf: &Py<Self>, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult;
-
-    #[inline]
-    #[pymethod]
-    fn __getattribute__(zelf: PyRef<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult {
-        Self::getattro(&zelf, &name, vm)
-    }
-}
-
-#[pyclass]
-pub trait SetAttr: PyPayload {
-    #[pyslot]
-    #[inline]
-    fn slot_setattro(
-        obj: &PyObject,
-        name: &Py<PyStr>,
-        value: PySetterValue,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        let zelf = obj
-            .downcast_ref::<Self>()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __setattr__"))?;
-        Self::setattro(zelf, name, value, vm)
-    }
-
-    fn setattro(
-        zelf: &Py<Self>,
-        name: &Py<PyStr>,
-        value: PySetterValue,
-        vm: &VirtualMachine,
-    ) -> PyResult<()>;
-
-    #[inline]
-    #[pymethod]
-    fn __setattr__(
-        zelf: PyRef<Self>,
-        name: PyStrRef,
-        value: PyObjectRef,
-        vm: &VirtualMachine,
-    ) -> PyResult<()> {
-        Self::setattro(&zelf, &name, PySetterValue::Assign(value), vm)
-    }
-
-    #[inline]
-    #[pymethod]
-    fn __delattr__(zelf: PyRef<Self>, name: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
-        Self::setattro(&zelf, &name, PySetterValue::Delete, vm)
-    }
-}
-
-#[pyclass]
-pub trait AsBuffer: PyPayload {
-    // TODO: `flags` parameter
-    #[inline]
-    #[pyslot]
-    fn slot_as_buffer(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyBuffer> {
-        let zelf = zelf
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for as_buffer"))?;
-        Self::as_buffer(zelf, vm)
-    }
-
-    fn as_buffer(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyBuffer>;
-}
-
-#[pyclass]
-pub trait AsMapping: PyPayload {
-    #[pyslot]
-    fn as_mapping() -> &'static PyMappingMethods;
-
-    #[inline]
-    fn mapping_downcast(mapping: PyMapping<'_>) -> &Py<Self> {
-        unsafe { mapping.obj.downcast_unchecked_ref() }
-    }
-}
-
-#[pyclass]
-pub trait AsSequence: PyPayload {
-    #[pyslot]
-    fn as_sequence() -> &'static PySequenceMethods;
-
-    #[inline]
-    fn sequence_downcast(seq: PySequence<'_>) -> &Py<Self> {
-        unsafe { seq.obj.downcast_unchecked_ref() }
-    }
-}
-
-#[pyclass]
-pub trait AsNumber: PyPayload {
-    #[pyslot]
-    fn as_number() -> &'static PyNumberMethods;
-
-    fn clone_exact(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyRef<Self> {
-        // not all AsNumber requires this implementation.
-        unimplemented!()
-    }
-
-    #[inline]
-    fn number_downcast(num: PyNumber<'_>) -> &Py<Self> {
-        unsafe { num.obj().downcast_unchecked_ref() }
-    }
-
-    #[inline]
-    fn number_downcast_exact(num: PyNumber<'_>, vm: &VirtualMachine) -> PyRef<Self> {
-        if let Some(zelf) = num.downcast_ref_if_exact::<Self>(vm) {
-            zelf.to_owned()
-        } else {
-            Self::clone_exact(Self::number_downcast(num), vm)
-        }
-    }
-}
-
-#[pyclass]
-pub trait Iterable: PyPayload {
-    #[pyslot]
-    fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let zelf = zelf
-            .downcast()
-            .map_err(|_| vm.new_type_error("unexpected payload for __iter__"))?;
-        Self::iter(zelf, vm)
-    }
-
-    #[pymethod]
-    fn __iter__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        Self::slot_iter(zelf, vm)
-    }
-
-    fn iter(zelf: PyRef<Self>, vm: &VirtualMachine) -> PyResult;
-
-    fn extend_slots(_slots: &mut PyTypeSlots) {}
-}
-
-// `Iterator` fits better, but to avoid confusion with rust std::iter::Iterator
-#[pyclass(with(Iterable))]
-pub trait IterNext: PyPayload + Iterable {
-    #[pyslot]
-    fn slot_iternext(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyIterReturn> {
-        let zelf = zelf
-            .downcast_ref()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __next__"))?;
-        Self::next(zelf, vm)
-    }
-
-    fn next(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyIterReturn>;
-
-    #[inline]
-    #[pymethod]
-    fn __next__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        Self::slot_iternext(&zelf, vm).to_pyresult(vm)
-    }
-}
-
-pub trait SelfIter: PyPayload {}
-
-impl<T> Iterable for T
-where
-    T: SelfIter,
-{
-    #[cold]
-    fn slot_iter(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        let repr = zelf.repr(vm)?;
-        unreachable!("slot must be overridden for {}", repr.as_str());
-    }
-
-    fn __iter__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        self_iter(zelf, vm)
-    }
-
-    #[cold]
-    fn iter(_zelf: PyRef<Self>, _vm: &VirtualMachine) -> PyResult {
-        unreachable!("slot_iter is implemented");
-    }
-
-    fn extend_slots(slots: &mut PyTypeSlots) {
-        let prev = slots.iter.swap(Some(self_iter));
-        debug_assert!(prev.is_some()); // slot_iter would be set
-    }
-}
diff --git a/vm/src/types/structseq.rs b/vm/src/types/structseq.rs
deleted file mode 100644
index 318280f862..0000000000
--- a/vm/src/types/structseq.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyStrRef, PyTuple, PyTupleRef, PyType},
-    class::{PyClassImpl, StaticType},
-    vm::Context,
-};
-
-#[pyclass]
-pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static {
-    const REQUIRED_FIELD_NAMES: &'static [&'static str];
-    const OPTIONAL_FIELD_NAMES: &'static [&'static str];
-
-    fn into_tuple(self, vm: &VirtualMachine) -> PyTuple;
-
-    fn into_struct_sequence(self, vm: &VirtualMachine) -> PyTupleRef {
-        self.into_tuple(vm)
-            .into_ref_with_type(vm, Self::static_type().to_owned())
-            .unwrap()
-    }
-
-    fn try_elements_from(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<Vec<PyObjectRef>> {
-        #[cold]
-        fn sequence_length_error(
-            name: &str,
-            len: usize,
-            vm: &VirtualMachine,
-        ) -> PyBaseExceptionRef {
-            vm.new_type_error(format!("{name} takes a sequence of length {len}"))
-        }
-
-        let typ = Self::static_type();
-        // if !obj.fast_isinstance(typ) {
-        //     return Err(vm.new_type_error(format!(
-        //         "{} is not a subclass of {}",
-        //         obj.class().name(),
-        //         typ.name(),
-        //     )));
-        // }
-        let seq: Vec<PyObjectRef> = obj.try_into_value(vm)?;
-        if seq.len() < Self::REQUIRED_FIELD_NAMES.len() {
-            return Err(sequence_length_error(
-                &typ.name(),
-                Self::REQUIRED_FIELD_NAMES.len(),
-                vm,
-            ));
-        }
-        Ok(seq)
-    }
-
-    #[pyslot]
-    fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        let zelf = zelf
-            .downcast_ref::<PyTuple>()
-            .ok_or_else(|| vm.new_type_error("unexpected payload for __repr__"))?;
-
-        let format_field = |(value, name): (&PyObjectRef, _)| {
-            let s = value.repr(vm)?;
-            Ok(format!("{name}={s}"))
-        };
-        let (body, suffix) =
-            if let Some(_guard) = rustpython_vm::recursion::ReprGuard::enter(vm, zelf.as_ref()) {
-                if Self::REQUIRED_FIELD_NAMES.len() == 1 {
-                    let value = zelf.first().unwrap();
-                    let formatted = format_field((value, Self::REQUIRED_FIELD_NAMES[0]))?;
-                    (formatted, ",")
-                } else {
-                    let fields: PyResult<Vec<_>> = zelf
-                        .iter()
-                        .zip(Self::REQUIRED_FIELD_NAMES.iter().copied())
-                        .map(format_field)
-                        .collect();
-                    (fields?.join(", "), "")
-                }
-            } else {
-                (String::new(), "...")
-            };
-        let repr_str = format!("{}({}{})", Self::TP_NAME, body, suffix);
-        Ok(vm.ctx.new_str(repr_str))
-    }
-
-    #[pymethod]
-    fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
-        Self::slot_repr(&zelf, vm)
-    }
-
-    #[pymethod]
-    fn __reduce__(zelf: PyRef<PyTuple>, vm: &VirtualMachine) -> PyTupleRef {
-        vm.new_tuple((zelf.class().to_owned(), (vm.ctx.new_tuple(zelf.to_vec()),)))
-    }
-
-    #[extend_class]
-    fn extend_pyclass(ctx: &Context, class: &'static Py<PyType>) {
-        for (i, &name) in Self::REQUIRED_FIELD_NAMES.iter().enumerate() {
-            // cast i to a u8 so there's less to store in the getter closure.
-            // Hopefully there's not struct sequences with >=256 elements :P
-            let i = i as u8;
-            class.set_attr(
-                ctx.intern_str(name),
-                ctx.new_readonly_getset(name, class, move |zelf: &PyTuple| {
-                    zelf[i as usize].to_owned()
-                })
-                .into(),
-            );
-        }
-
-        class.set_attr(
-            identifier!(ctx, __match_args__),
-            ctx.new_tuple(
-                Self::REQUIRED_FIELD_NAMES
-                    .iter()
-                    .map(|&name| ctx.new_str(name).into())
-                    .collect::<Vec<_>>(),
-            )
-            .into(),
-        );
-    }
-}
diff --git a/vm/src/version.rs b/vm/src/version.rs
deleted file mode 100644
index 9d472e8be0..0000000000
--- a/vm/src/version.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-//! Several function to retrieve version information.
-
-use chrono::{Local, prelude::DateTime};
-use std::time::{Duration, UNIX_EPOCH};
-
-// = 3.13.0alpha
-pub const MAJOR: usize = 3;
-pub const MINOR: usize = 13;
-pub const MICRO: usize = 0;
-pub const RELEASELEVEL: &str = "alpha";
-pub const RELEASELEVEL_N: usize = 0xA;
-pub const SERIAL: usize = 0;
-
-pub const VERSION_HEX: usize =
-    (MAJOR << 24) | (MINOR << 16) | (MICRO << 8) | (RELEASELEVEL_N << 4) | SERIAL;
-
-pub fn get_version() -> String {
-    format!(
-        "{:.80} ({:.80}) \n[RustPython {} with {:.80}]", // \n is PyPy convention
-        get_version_number(),
-        get_build_info(),
-        env!("CARGO_PKG_VERSION"),
-        COMPILER,
-    )
-}
-
-pub fn get_version_number() -> String {
-    format!("{MAJOR}.{MINOR}.{MICRO}{RELEASELEVEL}")
-}
-
-pub fn get_winver_number() -> String {
-    format!("{MAJOR}.{MINOR}")
-}
-
-const COMPILER: &str = env!("RUSTC_VERSION");
-
-pub fn get_build_info() -> String {
-    // See: https://reproducible-builds.org/docs/timestamps/
-    let git_revision = get_git_revision();
-    let separator = if git_revision.is_empty() { "" } else { ":" };
-
-    let git_identifier = get_git_identifier();
-
-    format!(
-        "{id}{sep}{revision}, {date:.20}, {time:.9}",
-        id = if git_identifier.is_empty() {
-            "default".to_owned()
-        } else {
-            git_identifier
-        },
-        sep = separator,
-        revision = git_revision,
-        date = get_git_date(),
-        time = get_git_time(),
-    )
-}
-
-pub fn get_git_revision() -> String {
-    option_env!("RUSTPYTHON_GIT_HASH").unwrap_or("").to_owned()
-}
-
-pub fn get_git_tag() -> String {
-    option_env!("RUSTPYTHON_GIT_TAG").unwrap_or("").to_owned()
-}
-
-pub fn get_git_branch() -> String {
-    option_env!("RUSTPYTHON_GIT_BRANCH")
-        .unwrap_or("")
-        .to_owned()
-}
-
-pub fn get_git_identifier() -> String {
-    let git_tag = get_git_tag();
-    let git_branch = get_git_branch();
-
-    if git_tag.is_empty() || git_tag == "undefined" {
-        git_branch
-    } else {
-        git_tag
-    }
-}
-
-fn get_git_timestamp_datetime() -> DateTime<Local> {
-    let timestamp = option_env!("RUSTPYTHON_GIT_TIMESTAMP")
-        .unwrap_or("")
-        .to_owned();
-    let timestamp = timestamp.parse::<u64>().unwrap_or(0);
-
-    let datetime = UNIX_EPOCH + Duration::from_secs(timestamp);
-
-    datetime.into()
-}
-
-pub fn get_git_date() -> String {
-    let datetime = get_git_timestamp_datetime();
-
-    datetime.format("%b %e %Y").to_string()
-}
-
-pub fn get_git_time() -> String {
-    let datetime = get_git_timestamp_datetime();
-
-    datetime.format("%H:%M:%S").to_string()
-}
-
-pub fn get_git_datetime() -> String {
-    let date = get_git_date();
-    let time = get_git_time();
-
-    format!("{date} {time}")
-}
diff --git a/vm/src/vm/compile.rs b/vm/src/vm/compile.rs
deleted file mode 100644
index ee813bf7b4..0000000000
--- a/vm/src/vm/compile.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-use crate::{
-    AsObject, PyObjectRef, PyRef, PyResult, VirtualMachine,
-    builtins::{PyCode, PyDictRef},
-    compiler::{self, CompileError, CompileOpts},
-    convert::TryFromObject,
-    scope::Scope,
-};
-
-impl VirtualMachine {
-    pub fn compile(
-        &self,
-        source: &str,
-        mode: compiler::Mode,
-        source_path: String,
-    ) -> Result<PyRef<PyCode>, CompileError> {
-        self.compile_with_opts(source, mode, source_path, self.compile_opts())
-    }
-
-    pub fn compile_with_opts(
-        &self,
-        source: &str,
-        mode: compiler::Mode,
-        source_path: String,
-        opts: CompileOpts,
-    ) -> Result<PyRef<PyCode>, CompileError> {
-        compiler::compile(source, mode, &source_path, opts).map(|code| self.ctx.new_code(code))
-    }
-
-    pub fn run_script(&self, scope: Scope, path: &str) -> PyResult<()> {
-        if get_importer(path, self)?.is_some() {
-            self.insert_sys_path(self.new_pyobj(path))?;
-            let runpy = self.import("runpy", 0)?;
-            let run_module_as_main = runpy.get_attr("_run_module_as_main", self)?;
-            run_module_as_main.call((identifier!(self, __main__).to_owned(), false), self)?;
-            return Ok(());
-        }
-
-        if !self.state.settings.safe_path {
-            let dir = std::path::Path::new(path)
-                .parent()
-                .unwrap()
-                .to_str()
-                .unwrap();
-            self.insert_sys_path(self.new_pyobj(dir))?;
-        }
-
-        match std::fs::read_to_string(path) {
-            Ok(source) => {
-                self.run_code_string(scope, &source, path.to_owned())?;
-            }
-            Err(err) => {
-                error!("Failed reading file '{path}': {err}");
-                // TODO: Need to change to ExitCode or Termination
-                std::process::exit(1);
-            }
-        }
-        Ok(())
-    }
-
-    pub fn run_code_string(&self, scope: Scope, source: &str, source_path: String) -> PyResult {
-        let code_obj = self
-            .compile(source, compiler::Mode::Exec, source_path.clone())
-            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
-        // trace!("Code object: {:?}", code_obj.borrow());
-        scope.globals.set_item(
-            identifier!(self, __file__),
-            self.new_pyobj(source_path),
-            self,
-        )?;
-        self.run_code_obj(code_obj, scope)
-    }
-
-    pub fn run_block_expr(&self, scope: Scope, source: &str) -> PyResult {
-        let code_obj = self
-            .compile(source, compiler::Mode::BlockExpr, "<embedded>".to_owned())
-            .map_err(|err| self.new_syntax_error(&err, Some(source)))?;
-        // trace!("Code object: {:?}", code_obj.borrow());
-        self.run_code_obj(code_obj, scope)
-    }
-}
-
-fn get_importer(path: &str, vm: &VirtualMachine) -> PyResult<Option<PyObjectRef>> {
-    let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;
-    let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;
-    if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {
-        return Ok(Some(importer));
-    }
-    let path = vm.ctx.new_str(path);
-    let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;
-    let mut importer = None;
-    let path_hooks: Vec<PyObjectRef> = path_hooks.try_into_value(vm)?;
-    for path_hook in path_hooks {
-        match path_hook.call((path.clone(),), vm) {
-            Ok(imp) => {
-                importer = Some(imp);
-                break;
-            }
-            Err(e) if e.fast_isinstance(vm.ctx.exceptions.import_error) => continue,
-            Err(e) => return Err(e),
-        }
-    }
-    Ok(if let Some(imp) = importer {
-        let imp = path_importer_cache.get_or_insert(vm, path.into(), || imp.clone())?;
-        Some(imp)
-    } else {
-        None
-    })
-}
diff --git a/vm/src/vm/method.rs b/vm/src/vm/method.rs
deleted file mode 100644
index e10eb2db83..0000000000
--- a/vm/src/vm/method.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-//! This module will be replaced once #3100 is done
-//! Do not expose this type to outside of this crate
-
-use super::VirtualMachine;
-use crate::{
-    builtins::{PyBaseObject, PyStr, PyStrInterned},
-    function::IntoFuncArgs,
-    object::{AsObject, Py, PyObject, PyObjectRef, PyResult},
-    types::PyTypeFlags,
-};
-
-#[derive(Debug)]
-pub enum PyMethod {
-    Function {
-        target: PyObjectRef,
-        func: PyObjectRef,
-    },
-    Attribute(PyObjectRef),
-}
-
-impl PyMethod {
-    pub fn get(obj: PyObjectRef, name: &Py<PyStr>, vm: &VirtualMachine) -> PyResult<Self> {
-        let cls = obj.class();
-        let getattro = cls.mro_find_map(|cls| cls.slots.getattro.load()).unwrap();
-        if getattro as usize != PyBaseObject::getattro as usize {
-            return obj.get_attr(name, vm).map(Self::Attribute);
-        }
-
-        // any correct method name is always interned already.
-        let interned_name = vm.ctx.interned_str(name);
-        let mut is_method = false;
-
-        let cls_attr = match interned_name.and_then(|name| cls.get_attr(name)) {
-            Some(descr) => {
-                let descr_cls = descr.class();
-                let descr_get = if descr_cls
-                    .slots
-                    .flags
-                    .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
-                {
-                    is_method = true;
-                    None
-                } else {
-                    let descr_get = descr_cls.mro_find_map(|cls| cls.slots.descr_get.load());
-                    if let Some(descr_get) = descr_get {
-                        if descr_cls
-                            .mro_find_map(|cls| cls.slots.descr_set.load())
-                            .is_some()
-                        {
-                            let cls = cls.to_owned().into();
-                            return descr_get(descr, Some(obj), Some(cls), vm).map(Self::Attribute);
-                        }
-                    }
-                    descr_get
-                };
-                Some((descr, descr_get))
-            }
-            None => None,
-        };
-
-        if let Some(dict) = obj.dict() {
-            if let Some(attr) = dict.get_item_opt(name, vm)? {
-                return Ok(Self::Attribute(attr));
-            }
-        }
-
-        if let Some((attr, descr_get)) = cls_attr {
-            match descr_get {
-                None if is_method => Ok(Self::Function {
-                    target: obj,
-                    func: attr,
-                }),
-                Some(descr_get) => {
-                    let cls = cls.to_owned().into();
-                    descr_get(attr, Some(obj), Some(cls), vm).map(Self::Attribute)
-                }
-                None => Ok(Self::Attribute(attr)),
-            }
-        } else if let Some(getter) = cls.get_attr(identifier!(vm, __getattr__)) {
-            getter.call((obj, name.to_owned()), vm).map(Self::Attribute)
-        } else {
-            Err(vm.new_no_attribute_error(obj.clone(), name.to_owned()))
-        }
-    }
-
-    pub(crate) fn get_special<const DIRECT: bool>(
-        obj: &PyObject,
-        name: &'static PyStrInterned,
-        vm: &VirtualMachine,
-    ) -> PyResult<Option<Self>> {
-        let obj_cls = obj.class();
-        let attr = if DIRECT {
-            obj_cls.get_direct_attr(name)
-        } else {
-            obj_cls.get_attr(name)
-        };
-        let func = match attr {
-            Some(f) => f,
-            None => {
-                return Ok(None);
-            }
-        };
-        let meth = if func
-            .class()
-            .slots
-            .flags
-            .has_feature(PyTypeFlags::METHOD_DESCRIPTOR)
-        {
-            Self::Function {
-                target: obj.to_owned(),
-                func,
-            }
-        } else {
-            let obj_cls = obj_cls.to_owned().into();
-            let attr = vm
-                .call_get_descriptor_specific(&func, Some(obj.to_owned()), Some(obj_cls))
-                .unwrap_or(Ok(func))?;
-            Self::Attribute(attr)
-        };
-        Ok(Some(meth))
-    }
-
-    pub fn invoke(self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
-        let (func, args) = match self {
-            Self::Function { target, func } => (func, args.into_method_args(target, vm)),
-            Self::Attribute(func) => (func, args.into_args(vm)),
-        };
-        func.call(args, vm)
-    }
-
-    #[allow(dead_code)]
-    pub fn invoke_ref(&self, args: impl IntoFuncArgs, vm: &VirtualMachine) -> PyResult {
-        let (func, args) = match self {
-            Self::Function { target, func } => (func, args.into_method_args(target.clone(), vm)),
-            Self::Attribute(func) => (func, args.into_args(vm)),
-        };
-        func.call(args, vm)
-    }
-}
diff --git a/vm/src/vm/mod.rs b/vm/src/vm/mod.rs
deleted file mode 100644
index 4a319c9635..0000000000
--- a/vm/src/vm/mod.rs
+++ /dev/null
@@ -1,1070 +0,0 @@
-//! Implement virtual machine to run instructions.
-//!
-//! See also:
-//!   <https://github.com/ProgVal/pythonvm-rust/blob/master/src/processor/mod.rs>
-
-#[cfg(feature = "rustpython-compiler")]
-mod compile;
-mod context;
-mod interpreter;
-mod method;
-mod setting;
-pub mod thread;
-mod vm_new;
-mod vm_object;
-mod vm_ops;
-
-#[cfg(not(feature = "stdio"))]
-use crate::builtins::PyNone;
-use crate::{
-    AsObject, Py, PyObject, PyObjectRef, PyPayload, PyRef, PyResult,
-    builtins::{
-        PyBaseExceptionRef, PyDictRef, PyInt, PyList, PyModule, PyStr, PyStrInterned, PyStrRef,
-        PyTypeRef,
-        code::PyCode,
-        pystr::AsPyStr,
-        tuple::{PyTuple, PyTupleTyped},
-    },
-    codecs::CodecsRegistry,
-    common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
-    convert::ToPyObject,
-    frame::{ExecutionResult, Frame, FrameRef},
-    frozen::FrozenModule,
-    function::{ArgMapping, FuncArgs, PySetterValue},
-    import,
-    protocol::PyIterIter,
-    scope::Scope,
-    signal, stdlib,
-    warn::WarningsState,
-};
-use crossbeam_utils::atomic::AtomicCell;
-#[cfg(unix)]
-use nix::{
-    sys::signal::{SaFlags, SigAction, SigSet, Signal::SIGINT, kill, sigaction},
-    unistd::getpid,
-};
-use std::{
-    borrow::Cow,
-    cell::{Cell, Ref, RefCell},
-    collections::{HashMap, HashSet},
-    ffi::{OsStr, OsString},
-    sync::atomic::AtomicBool,
-};
-
-pub use context::Context;
-pub use interpreter::Interpreter;
-pub(crate) use method::PyMethod;
-pub use setting::{CheckHashPycsMode, Settings};
-
-pub const MAX_MEMORY_SIZE: usize = isize::MAX as usize;
-
-// Objects are live when they are on stack, or referenced by a name (for now)
-
-/// Top level container of a python virtual machine. In theory you could
-/// create more instances of this struct and have them operate fully isolated.
-///
-/// To construct this, please refer to the [`Interpreter`]
-pub struct VirtualMachine {
-    pub builtins: PyRef<PyModule>,
-    pub sys_module: PyRef<PyModule>,
-    pub ctx: PyRc<Context>,
-    pub frames: RefCell<Vec<FrameRef>>,
-    pub wasm_id: Option<String>,
-    exceptions: RefCell<ExceptionStack>,
-    pub import_func: 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_rx: Option<signal::UserSignalReceiver>,
-    pub repr_guards: RefCell<HashSet<usize>>,
-    pub state: PyRc<PyGlobalState>,
-    pub initialized: bool,
-    recursion_depth: Cell<usize>,
-}
-
-#[derive(Debug, Default)]
-struct ExceptionStack {
-    exc: Option<PyBaseExceptionRef>,
-    prev: Option<Box<ExceptionStack>>,
-}
-
-pub struct PyGlobalState {
-    pub settings: Settings,
-    pub module_inits: stdlib::StdlibMap,
-    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 codec_registry: CodecsRegistry,
-    pub finalizing: AtomicBool,
-    pub warnings: WarningsState,
-    pub override_frozen_modules: AtomicCell<isize>,
-    pub before_forkers: PyMutex<Vec<PyObjectRef>>,
-    pub after_forkers_child: PyMutex<Vec<PyObjectRef>>,
-    pub after_forkers_parent: PyMutex<Vec<PyObjectRef>>,
-    pub int_max_str_digits: AtomicCell<usize>,
-    pub switch_interval: AtomicCell<f64>,
-}
-
-pub fn process_hash_secret_seed() -> u32 {
-    use std::sync::OnceLock;
-    static SEED: OnceLock<u32> = OnceLock::new();
-    // os_random is expensive, but this is only ever called once
-    *SEED.get_or_init(|| u32::from_ne_bytes(rustpython_common::rand::os_random()))
-}
-
-impl VirtualMachine {
-    /// Create a new `VirtualMachine` structure.
-    fn new(settings: Settings, ctx: PyRc<Context>) -> Self {
-        flame_guard!("new VirtualMachine");
-
-        // make a new module without access to the vm; doesn't
-        // set __spec__, __loader__, etc. attributes
-        let new_module = |def| {
-            PyRef::new_ref(
-                PyModule::from_def(def),
-                ctx.types.module_type.to_owned(),
-                Some(ctx.new_dict()),
-            )
-        };
-
-        // Hard-core modules:
-        let builtins = new_module(stdlib::builtins::__module_def(&ctx));
-        let sys_module = new_module(stdlib::sys::__module_def(&ctx));
-
-        let import_func = 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 module_inits = stdlib::get_module_inits();
-
-        let seed = match settings.hash_seed {
-            Some(seed) => seed,
-            None => process_hash_secret_seed(),
-        };
-        let hash_secret = HashSecret::new(seed);
-
-        let codec_registry = CodecsRegistry::new(&ctx);
-
-        let warnings = WarningsState::init_state(&ctx);
-
-        let int_max_str_digits = AtomicCell::new(match settings.int_max_str_digits {
-            -1 => 4300,
-            other => other,
-        } as usize);
-        let mut vm = Self {
-            builtins,
-            sys_module,
-            ctx,
-            frames: RefCell::new(vec![]),
-            wasm_id: None,
-            exceptions: RefCell::default(),
-            import_func,
-            profile_func,
-            trace_func,
-            use_tracing: Cell::new(false),
-            recursion_limit: Cell::new(if cfg!(debug_assertions) { 256 } else { 1000 }),
-            signal_handlers,
-            signal_rx: None,
-            repr_guards: RefCell::default(),
-            state: PyRc::new(PyGlobalState {
-                settings,
-                module_inits,
-                frozen: HashMap::default(),
-                stacksize: AtomicCell::new(0),
-                thread_count: AtomicCell::new(0),
-                hash_secret,
-                atexit_funcs: PyMutex::default(),
-                codec_registry,
-                finalizing: AtomicBool::new(false),
-                warnings,
-                override_frozen_modules: AtomicCell::new(0),
-                before_forkers: PyMutex::default(),
-                after_forkers_child: PyMutex::default(),
-                after_forkers_parent: PyMutex::default(),
-                int_max_str_digits,
-                switch_interval: AtomicCell::new(0.005),
-            }),
-            initialized: false,
-            recursion_depth: Cell::new(0),
-        };
-
-        if vm.state.hash_secret.hash_str("")
-            != vm
-                .ctx
-                .interned_str("")
-                .expect("empty str must be interned")
-                .hash(&vm)
-        {
-            panic!("Interpreters in same process must share the hash seed");
-        }
-
-        let frozen = core_frozen_inits().collect();
-        PyRc::get_mut(&mut vm.state).unwrap().frozen = frozen;
-
-        vm.builtins.init_dict(
-            vm.ctx.intern_str("builtins"),
-            Some(vm.ctx.intern_str(stdlib::builtins::DOC.unwrap()).to_owned()),
-            &vm,
-        );
-        vm.sys_module.init_dict(
-            vm.ctx.intern_str("sys"),
-            Some(vm.ctx.intern_str(stdlib::sys::DOC.unwrap()).to_owned()),
-            &vm,
-        );
-        // let name = vm.sys_module.get_attr("__name__", &vm).unwrap();
-        vm
-    }
-
-    /// set up the encodings search function
-    /// init_importlib must be called before this call
-    #[cfg(feature = "encodings")]
-    fn import_encodings(&mut self) -> PyResult<()> {
-        self.import("encodings", 0).map_err(|import_err| {
-            let rustpythonpath_env = std::env::var("RUSTPYTHONPATH").ok();
-            let pythonpath_env = std::env::var("PYTHONPATH").ok();
-            let env_set = rustpythonpath_env.as_ref().is_some() || pythonpath_env.as_ref().is_some();
-            let path_contains_env = self.state.settings.path_list.iter().any(|s| {
-                Some(s.as_str()) == rustpythonpath_env.as_deref() || Some(s.as_str()) == pythonpath_env.as_deref()
-            });
-
-            let guide_message = if cfg!(feature = "freeze-stdlib") {
-                "`rustpython_pylib` maybe not set while using `freeze-stdlib` feature. Try using `rustpython::InterpreterConfig::init_stdlib` or manually call `vm.add_frozen(rustpython_pylib::FROZEN_STDLIB)` in `rustpython_vm::Interpreter::with_init`."
-            } else if !env_set {
-                "Neither RUSTPYTHONPATH nor PYTHONPATH is set. Try setting one of them to the stdlib directory."
-            } else if path_contains_env {
-                "RUSTPYTHONPATH or PYTHONPATH is set, but it doesn't contain the encodings library. If you are customizing the RustPython vm/interpreter, try adding the stdlib directory to the path. If you are developing the RustPython interpreter, it might be a bug during development."
-            } else {
-                "RUSTPYTHONPATH or PYTHONPATH is set, but it wasn't loaded to `Settings::path_list`. If you are going to customize the RustPython vm/interpreter, those environment variables are not loaded in the Settings struct by default. Please try creating a customized instance of the Settings struct. If you are developing the RustPython interpreter, it might be a bug during development."
-            };
-
-            let mut msg = format!(
-                "RustPython could not import the encodings module. It usually means something went wrong. Please carefully read the following messages and follow the steps.\n\
-                \n\
-                {guide_message}");
-            if !cfg!(feature = "freeze-stdlib") {
-                msg += "\n\
-                If you don't have access to a consistent external environment (e.g. targeting wasm, embedding \
-                    rustpython in another application), try enabling the `freeze-stdlib` feature.\n\
-                If this is intended and you want to exclude the encodings module from your interpreter, please remove the `encodings` feature from `rustpython-vm` crate.";
-            }
-
-            let err = self.new_runtime_error(msg);
-            err.set___cause__(Some(import_err));
-            err
-        })?;
-        Ok(())
-    }
-
-    fn import_utf8_encodings(&mut self) -> PyResult<()> {
-        import::import_frozen(self, "codecs")?;
-        // FIXME: See corresponding part of `core_frozen_inits`
-        // let encoding_module_name = if cfg!(feature = "freeze-stdlib") {
-        //     "encodings.utf_8"
-        // } else {
-        //     "encodings_utf_8"
-        // };
-        let encoding_module_name = "encodings_utf_8";
-        let encoding_module = import::import_frozen(self, encoding_module_name)?;
-        let getregentry = encoding_module.get_attr("getregentry", self)?;
-        let codec_info = getregentry.call((), self)?;
-        self.state
-            .codec_registry
-            .register_manual("utf-8", codec_info.try_into_value(self)?)?;
-        Ok(())
-    }
-
-    fn initialize(&mut self) {
-        flame_guard!("init VirtualMachine");
-
-        if self.initialized {
-            panic!("Double Initialize Error");
-        }
-
-        stdlib::builtins::init_module(self, &self.builtins);
-        stdlib::sys::init_module(self, &self.sys_module, &self.builtins);
-
-        let mut essential_init = || -> PyResult {
-            import::import_builtin(self, "_typing")?;
-            #[cfg(not(target_arch = "wasm32"))]
-            import::import_builtin(self, "_signal")?;
-            #[cfg(any(feature = "parser", feature = "compiler"))]
-            import::import_builtin(self, "_ast")?;
-            #[cfg(not(feature = "threading"))]
-            import::import_frozen(self, "_thread")?;
-            let importlib = import::init_importlib_base(self)?;
-            self.import_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| {
-                    let buffered_stdio = self.state.settings.buffered_stdio;
-                    let unbuffered = write && !buffered_stdio;
-                    let buf = crate::stdlib::io::open(
-                        self.ctx.new_int(fd).into(),
-                        Some(if write { "wb" } else { "rb" }),
-                        crate::stdlib::io::OpenArgs {
-                            buffering: if unbuffered { 0 } else { -1 },
-                            ..Default::default()
-                        },
-                        self,
-                    )?;
-                    let raw = if unbuffered {
-                        buf.clone()
-                    } else {
-                        buf.get_attr("raw", self)?
-                    };
-                    raw.set_attr("name", self.ctx.new_str(format!("<{name}>")), self)?;
-                    let isatty = self.call_method(&raw, "isatty", ())?.is_true(self)?;
-                    let write_through = !buffered_stdio;
-                    let line_buffering = buffered_stdio && (isatty || fd == 2);
-
-                    let newline = if cfg!(windows) { None } else { Some("\n") };
-
-                    let stdio = self.call_method(
-                        &io,
-                        "TextIOWrapper",
-                        (buf, (), (), newline, line_buffering, write_through),
-                    )?;
-                    let mode = if write { "w" } else { "r" };
-                    stdio.set_attr("mode", self.ctx.new_str(mode), self)?;
-                    Ok(stdio)
-                };
-                #[cfg(not(feature = "stdio"))]
-                let make_stdio = |_name, _fd, _write| Ok(PyNone.into_pyobject(self));
-
-                let set_stdio = |name, fd, write| {
-                    let stdio = make_stdio(name, fd, write)?;
-                    let dunder_name = self.ctx.intern_str(format!("__{name}__"));
-                    self.sys_module.set_attr(
-                        dunder_name, // e.g. __stdin__
-                        stdio.clone(),
-                        self,
-                    )?;
-                    self.sys_module.set_attr(name, stdio, self)?;
-                    Ok(())
-                };
-                set_stdio("stdin", 0, false)?;
-                set_stdio("stdout", 1, true)?;
-                set_stdio("stderr", 2, true)?;
-
-                let io_open = io.get_attr("open", self)?;
-                self.builtins.set_attr("open", io_open, self)?;
-            }
-
-            Ok(importlib)
-        };
-
-        let res = essential_init();
-        let importlib = self.expect_pyresult(res, "essential initialization failed");
-
-        if self.state.settings.allow_external_library && cfg!(feature = "rustpython-compiler") {
-            if let Err(e) = import::init_importlib_package(self, importlib) {
-                eprintln!(
-                    "importlib initialization failed. This is critical for many complicated packages."
-                );
-                self.print_exception(e);
-            }
-        }
-
-        let expect_stdlib =
-            cfg!(feature = "freeze-stdlib") || !self.state.settings.path_list.is_empty();
-
-        #[cfg(feature = "encodings")]
-        if expect_stdlib {
-            if let Err(e) = self.import_encodings() {
-                eprintln!(
-                    "encodings initialization failed. Only utf-8 encoding will be supported."
-                );
-                self.print_exception(e);
-            }
-        } else {
-            // Here may not be the best place to give general `path_list` advice,
-            // but bare rustpython_vm::VirtualMachine users skipped proper settings must hit here while properly setup vm never enters here.
-            eprintln!(
-                "feature `encodings` is enabled but `settings.path_list` is empty. \
-                Please add the library path to `settings.path_list`. If you intended to disable the entire standard library (including the `encodings` feature), please also make sure to disable the `encodings` feature.\n\
-                Tip: You may also want to add `\"\"` to `settings.path_list` in order to enable importing from the current working directory."
-            );
-        }
-
-        if expect_stdlib {
-            // enable python-implemented ExceptionGroup when stdlib exists
-            let py_core_init = || -> PyResult<()> {
-                let exception_group = import::import_frozen(self, "_py_exceptiongroup")?;
-                let base_exception_group = exception_group.get_attr("BaseExceptionGroup", self)?;
-                self.builtins
-                    .set_attr("BaseExceptionGroup", base_exception_group, self)?;
-                let exception_group = exception_group.get_attr("ExceptionGroup", self)?;
-                self.builtins
-                    .set_attr("ExceptionGroup", exception_group, self)?;
-                Ok(())
-            };
-            self.expect_pyresult(py_core_init(), "exceptiongroup initialization failed");
-        }
-
-        self.initialized = true;
-    }
-
-    fn state_mut(&mut self) -> &mut PyGlobalState {
-        PyRc::get_mut(&mut self.state)
-            .expect("there should not be multiple threads while a user has a mut ref to a vm")
-    }
-
-    /// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
-    pub fn add_native_module<S>(&mut self, name: S, module: stdlib::StdlibInitFunc)
-    where
-        S: Into<Cow<'static, str>>,
-    {
-        self.state_mut().module_inits.insert(name.into(), module);
-    }
-
-    pub fn add_native_modules<I>(&mut self, iter: I)
-    where
-        I: IntoIterator<Item = (Cow<'static, str>, stdlib::StdlibInitFunc)>,
-    {
-        self.state_mut().module_inits.extend(iter);
-    }
-
-    /// Can only be used in the initialization closure passed to [`Interpreter::with_init`]
-    pub fn add_frozen<I>(&mut self, frozen: I)
-    where
-        I: IntoIterator<Item = (&'static str, FrozenModule)>,
-    {
-        self.state_mut().frozen.extend(frozen);
-    }
-
-    /// Set the custom signal channel for the interpreter
-    pub fn set_user_signal_channel(&mut self, signal_rx: signal::UserSignalReceiver) {
-        self.signal_rx = Some(signal_rx);
-    }
-
-    pub fn run_code_obj(&self, code: PyRef<PyCode>, scope: Scope) -> PyResult {
-        use crate::builtins::PyFunction;
-
-        // Create a function object for module code, similar to CPython's PyEval_EvalCode
-        let qualname = self.ctx.new_str(code.obj_name.as_str());
-        let func = PyFunction::new(
-            code.clone(),
-            scope.globals.clone(),
-            None, // closure
-            None, // defaults
-            None, // kwdefaults
-            qualname,
-            self.ctx.new_tuple(vec![]), // type_params
-            self.ctx.new_dict(),        // annotations
-            self.ctx.none(),            // doc
-            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);
-        self.run_frame(frame)
-    }
-
-    #[cold]
-    pub fn run_unraisable(&self, e: PyBaseExceptionRef, msg: Option<String>, object: PyObjectRef) {
-        let sys_module = self.import("sys", 0).unwrap();
-        let unraisablehook = sys_module.get_attr("unraisablehook", self).unwrap();
-
-        let exc_type = e.class().to_owned();
-        let exc_traceback = e.__traceback__().to_pyobject(self); // TODO: actual traceback
-        let exc_value = e.into();
-        let args = stdlib::sys::UnraisableHookArgs {
-            exc_type,
-            exc_value,
-            exc_traceback,
-            err_msg: self.new_pyobj(msg),
-            object,
-        };
-        if let Err(e) = unraisablehook.call((args,), self) {
-            println!("{}", e.as_object().repr(self).unwrap().as_str());
-        }
-    }
-
-    #[inline(always)]
-    pub fn run_frame(&self, frame: FrameRef) -> PyResult {
-        match self.with_frame(frame, |f| f.run(self))? {
-            ExecutionResult::Return(value) => Ok(value),
-            _ => panic!("Got unexpected result from function"),
-        }
-    }
-
-    pub fn current_recursion_depth(&self) -> usize {
-        self.recursion_depth.get()
-    }
-
-    /// Used to run the body of a (possibly) recursive function. It will raise a
-    /// RecursionError if recursive functions are nested far too many times,
-    /// preventing a stack overflow.
-    pub fn with_recursion<R, F: FnOnce() -> PyResult<R>>(&self, _where: &str, f: F) -> PyResult<R> {
-        self.check_recursive_call(_where)?;
-        self.recursion_depth.set(self.recursion_depth.get() + 1);
-        let result = f();
-        self.recursion_depth.set(self.recursion_depth.get() - 1);
-        result
-    }
-
-    pub fn with_frame<R, F: FnOnce(FrameRef) -> PyResult<R>>(
-        &self,
-        frame: FrameRef,
-        f: F,
-    ) -> PyResult<R> {
-        self.with_recursion("", || {
-            self.frames.borrow_mut().push(frame.clone());
-            let result = f(frame);
-            // defer dec frame
-            let _popped = self.frames.borrow_mut().pop();
-            result
-        })
-    }
-
-    /// Returns a basic CompileOpts instance with options accurate to the vm. Used
-    /// as the CompileOpts for `vm.compile()`.
-    #[cfg(feature = "rustpython-codegen")]
-    pub fn compile_opts(&self) -> crate::compiler::CompileOpts {
-        crate::compiler::CompileOpts {
-            optimize: self.state.settings.optimize,
-        }
-    }
-
-    // To be called right before raising the recursion depth.
-    fn check_recursive_call(&self, _where: &str) -> PyResult<()> {
-        if self.recursion_depth.get() >= self.recursion_limit.get() {
-            Err(self.new_recursion_error(format!("maximum recursion depth exceeded {_where}")))
-        } else {
-            Ok(())
-        }
-    }
-
-    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_locals(&self) -> PyResult<ArgMapping> {
-        self.current_frame()
-            .expect("called current_locals but no frames on the stack")
-            .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 try_class(&self, module: &'static str, class: &'static str) -> PyResult<PyTypeRef> {
-        let class = self
-            .import(module, 0)?
-            .get_attr(class, self)?
-            .downcast()
-            .expect("not a class");
-        Ok(class)
-    }
-
-    pub fn class(&self, module: &'static str, class: &'static str) -> PyTypeRef {
-        let module = self
-            .import(module, 0)
-            .unwrap_or_else(|_| panic!("unable to import {module}"));
-
-        let class = module
-            .get_attr(class, self)
-            .unwrap_or_else(|_| panic!("module {module:?} has no class {class}"));
-        class.downcast().expect("not a class")
-    }
-
-    /// Call Python __import__ function without from_list.
-    /// Roughly equivalent to `import module_name` or `import top.submodule`.
-    ///
-    /// See also [`VirtualMachine::import_from`] for more advanced import.
-    /// See also [`rustpython_vm::import::import_source`] and other primitive import functions.
-    #[inline]
-    pub fn import<'a>(&self, module_name: impl AsPyStr<'a>, level: usize) -> PyResult {
-        let module_name = module_name.as_pystr(&self.ctx);
-        let from_list = PyTupleTyped::empty(self);
-        self.import_inner(module_name, from_list, level)
-    }
-
-    /// Call Python __import__ function caller with from_list.
-    /// Roughly equivalent to `from module_name import item1, item2` or `from top.submodule import item1, item2`
-    #[inline]
-    pub fn import_from<'a>(
-        &self,
-        module_name: impl AsPyStr<'a>,
-        from_list: PyTupleTyped<PyStrRef>,
-        level: usize,
-    ) -> PyResult {
-        let module_name = module_name.as_pystr(&self.ctx);
-        self.import_inner(module_name, from_list, level)
-    }
-
-    fn import_inner(
-        &self,
-        module: &Py<PyStr>,
-        from_list: PyTupleTyped<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
-        } else {
-            let sys_modules = self.sys_module.get_attr("modules", self)?;
-            sys_modules.get_item(module, self).ok()
-        };
-
-        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 = from_list.to_pyobject(self);
-                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:
-        let cls = value.class();
-        let list_borrow;
-        let slice = if cls.is(self.ctx.types.tuple_type) {
-            value.payload::<PyTuple>().unwrap().as_slice()
-        } else if cls.is(self.ctx.types.list_type) {
-            list_borrow = value.payload::<PyList>().unwrap().borrow_vec();
-            &list_borrow
-        } else {
-            return self.map_py_iter(value, func);
-        };
-        slice.iter().map(|obj| func(obj.clone())).collect()
-    }
-
-    pub fn map_iterable_object<F, R>(&self, obj: &PyObject, mut f: F) -> PyResult<PyResult<Vec<R>>>
-    where
-        F: FnMut(PyObjectRef) -> PyResult<R>,
-    {
-        match_class!(match obj {
-            ref l @ PyList => {
-                let mut i: usize = 0;
-                let mut results = Vec::with_capacity(l.borrow_vec().len());
-                loop {
-                    let elem = {
-                        let elements = &*l.borrow_vec();
-                        if i >= elements.len() {
-                            results.shrink_to_fit();
-                            return Ok(Ok(results));
-                        } else {
-                            elements[i].clone()
-                        }
-                        // free the lock
-                    };
-                    match f(elem) {
-                        Ok(result) => results.push(result),
-                        Err(err) => return Ok(Err(err)),
-                    }
-                    i += 1;
-                }
-            }
-            ref t @ PyTuple => Ok(t.iter().cloned().map(f).collect()),
-            // TODO: put internal iterable type
-            obj => {
-                Ok(self.map_py_iter(obj, f))
-            }
-        })
-    }
-
-    fn map_py_iter<F, R>(&self, value: &PyObject, mut f: F) -> PyResult<Vec<R>>
-    where
-        F: FnMut(PyObjectRef) -> PyResult<R>,
-    {
-        let iter = value.to_owned().get_iter(self)?;
-        let cap = match self.length_hint_opt(value.to_owned()) {
-            Err(e) if e.class().is(self.ctx.exceptions.runtime_error) => return Err(e),
-            Ok(Some(value)) => Some(value),
-            // Use a power of 2 as a default capacity.
-            _ => None,
-        };
-        // TODO: fix extend to do this check (?), see test_extend in Lib/test/list_tests.py,
-        // https://github.com/python/cpython/blob/v3.9.0/Objects/listobject.c#L922-L928
-        if let Some(cap) = cap {
-            if cap >= isize::MAX as usize {
-                return Ok(Vec::new());
-            }
-        }
-
-        let mut results = PyIterIter::new(self, iter.as_ref(), cap)
-            .map(|element| f(element?))
-            .collect::<PyResult<Vec<_>>>()?;
-        results.shrink_to_fit();
-        Ok(results)
-    }
-
-    pub fn get_attribute_opt<'a>(
-        &self,
-        obj: PyObjectRef,
-        attr_name: impl AsPyStr<'a>,
-    ) -> PyResult<Option<PyObjectRef>> {
-        let attr_name = attr_name.as_pystr(&self.ctx);
-        match obj.get_attr_inner(attr_name, self) {
-            Ok(attr) => Ok(Some(attr)),
-            Err(e) if e.fast_isinstance(self.ctx.exceptions.attribute_error) => Ok(None),
-            Err(e) => Err(e),
-        }
-    }
-
-    pub fn set_attribute_error_context(
-        &self,
-        exc: &PyBaseExceptionRef,
-        obj: PyObjectRef,
-        name: PyStrRef,
-    ) {
-        if exc.class().is(self.ctx.exceptions.attribute_error) {
-            let exc = exc.as_object();
-            exc.set_attr("name", name, self).unwrap();
-            exc.set_attr("obj", obj, self).unwrap();
-        }
-    }
-
-    // get_method should be used for internal access to magic methods (by-passing
-    // the full getattribute look-up.
-    pub fn get_method_or_type_error<F>(
-        &self,
-        obj: PyObjectRef,
-        method_name: &'static PyStrInterned,
-        err_msg: F,
-    ) -> PyResult
-    where
-        F: FnOnce() -> String,
-    {
-        let method = obj
-            .class()
-            .get_attr(method_name)
-            .ok_or_else(|| self.new_type_error(err_msg()))?;
-        self.call_if_get_descriptor(&method, obj)
-    }
-
-    // TODO: remove + transfer over to get_special_method
-    pub(crate) fn get_method(
-        &self,
-        obj: PyObjectRef,
-        method_name: &'static PyStrInterned,
-    ) -> Option<PyResult> {
-        let method = obj.get_class_attr(method_name)?;
-        Some(self.call_if_get_descriptor(&method, obj))
-    }
-
-    pub(crate) fn get_str_method(&self, obj: PyObjectRef, method_name: &str) -> Option<PyResult> {
-        let method_name = self.ctx.interned_str(method_name)?;
-        self.get_method(obj, method_name)
-    }
-
-    #[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(not(target_arch = "wasm32"))]
-        {
-            crate::signal::check_signals(self)
-        }
-        #[cfg(target_arch = "wasm32")]
-        {
-            Ok(())
-        }
-    }
-
-    pub(crate) fn push_exception(&self, exc: Option<PyBaseExceptionRef>) {
-        let mut excs = self.exceptions.borrow_mut();
-        let prev = std::mem::take(&mut *excs);
-        excs.prev = Some(Box::new(prev));
-        excs.exc = exc
-    }
-
-    pub(crate) fn pop_exception(&self) -> Option<PyBaseExceptionRef> {
-        let mut excs = self.exceptions.borrow_mut();
-        let cur = std::mem::take(&mut *excs);
-        *excs = *cur.prev.expect("pop_exception() without nested exc stack");
-        cur.exc
-    }
-
-    pub(crate) fn take_exception(&self) -> Option<PyBaseExceptionRef> {
-        self.exceptions.borrow_mut().exc.take()
-    }
-
-    pub(crate) fn current_exception(&self) -> Option<PyBaseExceptionRef> {
-        self.exceptions.borrow().exc.clone()
-    }
-
-    pub(crate) fn set_exception(&self, exc: Option<PyBaseExceptionRef>) {
-        // don't be holding the RefCell guard while __del__ is called
-        let prev = std::mem::replace(&mut self.exceptions.borrow_mut().exc, exc);
-        drop(prev);
-    }
-
-    pub(crate) fn contextualize_exception(&self, exception: &PyBaseExceptionRef) {
-        if let Some(context_exc) = self.topmost_exception() {
-            if !context_exc.is(exception) {
-                let mut o = context_exc.clone();
-                while let Some(context) = o.__context__() {
-                    if context.is(exception) {
-                        o.set___context__(None);
-                        break;
-                    }
-                    o = context;
-                }
-                exception.set___context__(Some(context_exc))
-            }
-        }
-    }
-
-    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()?;
-        }
-    }
-
-    pub fn handle_exit_exception(&self, exc: PyBaseExceptionRef) -> u8 {
-        if exc.fast_isinstance(self.ctx.exceptions.system_exit) {
-            let args = exc.args();
-            let msg = match args.as_slice() {
-                [] => return 0,
-                [arg] => match_class!(match arg {
-                    ref i @ PyInt => {
-                        use num_traits::cast::ToPrimitive;
-                        return i.as_bigint().to_u8().unwrap_or(0);
-                    }
-                    arg => {
-                        if self.is_none(arg) {
-                            return 0;
-                        } else {
-                            arg.str(self).ok()
-                        }
-                    }
-                }),
-                _ => args.as_object().repr(self).ok(),
-            };
-            if let Some(msg) = msg {
-                let stderr = stdlib::sys::PyStderr(self);
-                writeln!(stderr, "{msg}");
-            }
-            1
-        } else if exc.fast_isinstance(self.ctx.exceptions.keyboard_interrupt) {
-            #[allow(clippy::if_same_then_else)]
-            {
-                self.print_exception(exc);
-                #[cfg(unix)]
-                {
-                    let action = SigAction::new(
-                        nix::sys::signal::SigHandler::SigDfl,
-                        SaFlags::SA_ONSTACK,
-                        SigSet::empty(),
-                    );
-                    let result = unsafe { sigaction(SIGINT, &action) };
-                    if result.is_ok() {
-                        self.flush_std();
-                        kill(getpid(), SIGINT).expect("Expect to be killed.");
-                    }
-
-                    (libc::SIGINT as u8) + 128u8
-                }
-                #[cfg(not(unix))]
-                {
-                    1
-                }
-            }
-        } else {
-            self.print_exception(exc);
-            1
-        }
-    }
-
-    #[doc(hidden)]
-    pub fn __module_set_attr(
-        &self,
-        module: &Py<PyModule>,
-        attr_name: &'static PyStrInterned,
-        attr_value: impl Into<PyObjectRef>,
-    ) -> PyResult<()> {
-        let val = attr_value.into();
-        module
-            .as_object()
-            .generic_setattr(attr_name, PySetterValue::Assign(val), self)
-    }
-
-    pub fn insert_sys_path(&self, obj: PyObjectRef) -> PyResult<()> {
-        let sys_path = self.sys_module.get_attr("path", self).unwrap();
-        self.call_method(&sys_path, "insert", (0, obj))?;
-        Ok(())
-    }
-
-    pub fn run_module(&self, module: &str) -> PyResult<()> {
-        let runpy = self.import("runpy", 0)?;
-        let run_module_as_main = runpy.get_attr("_run_module_as_main", self)?;
-        run_module_as_main.call((module,), self)?;
-        Ok(())
-    }
-
-    pub fn fs_encoding(&self) -> &'static PyStrInterned {
-        identifier!(self, utf_8)
-    }
-
-    pub fn fs_encode_errors(&self) -> &'static PyStrInterned {
-        if cfg!(windows) {
-            identifier!(self, surrogatepass)
-        } else {
-            identifier!(self, surrogateescape)
-        }
-    }
-
-    pub fn fsdecode(&self, s: impl Into<OsString>) -> PyStrRef {
-        match s.into().into_string() {
-            Ok(s) => self.ctx.new_str(s),
-            Err(s) => {
-                let bytes = self.ctx.new_bytes(s.into_encoded_bytes());
-                let errors = self.fs_encode_errors().to_owned();
-                let res = self.state.codec_registry.decode_text(
-                    bytes.into(),
-                    "utf-8",
-                    Some(errors),
-                    self,
-                );
-                self.expect_pyresult(res, "fsdecode should be lossless and never fail")
-            }
-        }
-    }
-
-    pub fn fsencode<'a>(&self, s: &'a Py<PyStr>) -> PyResult<Cow<'a, OsStr>> {
-        if cfg!(windows) || s.is_utf8() {
-            // XXX: this is sketchy on windows; it's not guaranteed that the
-            //      OsStr encoding will always be compatible with WTF-8.
-            let s = unsafe { OsStr::from_encoded_bytes_unchecked(s.as_bytes()) };
-            return Ok(Cow::Borrowed(s));
-        }
-        let errors = self.fs_encode_errors().to_owned();
-        let bytes = self
-            .state
-            .codec_registry
-            .encode_text(s.to_owned(), "utf-8", Some(errors), self)?
-            .to_vec();
-        // XXX: this is sketchy on windows; it's not guaranteed that the
-        //      OsStr encoding will always be compatible with WTF-8.
-        let s = unsafe { OsString::from_encoded_bytes_unchecked(bytes) };
-        Ok(Cow::Owned(s))
-    }
-}
-
-impl AsRef<Context> for VirtualMachine {
-    fn as_ref(&self) -> &Context {
-        &self.ctx
-    }
-}
-
-fn core_frozen_inits() -> impl Iterator<Item = (&'static str, FrozenModule)> {
-    let iter = std::iter::empty();
-    macro_rules! ext_modules {
-        ($iter:ident, $($t:tt)*) => {
-            let $iter = $iter.chain(py_freeze!($($t)*));
-        };
-    }
-
-    // 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",
-        crate_name = "rustpython_compiler_core"
-    );
-
-    // core stdlib Python modules that the vm calls into, but are still used in Python
-    // application code, e.g. copyreg
-    // FIXME: Initializing core_modules here results duplicated frozen module generation for core_modules.
-    // We need a way to initialize this modules for both `Interpreter::without_stdlib()` and `InterpreterConfig::new().init_stdlib().interpreter()`
-    // #[cfg(not(feature = "freeze-stdlib"))]
-    ext_modules!(
-        iter,
-        dir = "./Lib/core_modules",
-        crate_name = "rustpython_compiler_core"
-    );
-
-    iter
-}
-
-#[test]
-fn test_nested_frozen() {
-    use rustpython_vm as vm;
-
-    vm::Interpreter::with_init(Default::default(), |vm| {
-        // vm.add_native_modules(rustpython_stdlib::get_module_inits());
-        vm.add_frozen(rustpython_vm::py_freeze!(dir = "../extra_tests/snippets"));
-    })
-    .enter(|vm| {
-        let scope = vm.new_scope_with_builtins();
-
-        let source = "from dir_module.dir_module_inner import value2";
-        let code_obj = vm
-            .compile(source, vm::compiler::Mode::Exec, "<embedded>".to_owned())
-            .map_err(|err| vm.new_syntax_error(&err, Some(source)))
-            .unwrap();
-
-        if let Err(e) = vm.run_code_obj(code_obj, scope) {
-            vm.print_exception(e);
-            panic!();
-        }
-    })
-}
diff --git a/vm/src/vm/setting.rs b/vm/src/vm/setting.rs
deleted file mode 100644
index caf8c9139d..0000000000
--- a/vm/src/vm/setting.rs
+++ /dev/null
@@ -1,171 +0,0 @@
-#[cfg(feature = "flame-it")]
-use std::ffi::OsString;
-
-/// Struct containing all kind of settings for the python vm.
-/// Mostly `PyConfig` in CPython.
-#[non_exhaustive]
-pub struct Settings {
-    /// -I
-    pub isolated: bool,
-
-    // int use_environment
-    /// -Xdev
-    pub dev_mode: bool,
-
-    /// Not set SIGINT handler(i.e. for embedded mode)
-    pub install_signal_handlers: bool,
-
-    /// PYTHONHASHSEED=x
-    /// None means use_hash_seed = 0 in CPython
-    pub hash_seed: Option<u32>,
-
-    // int faulthandler;
-    // int tracemalloc;
-    // int perf_profiling;
-    // int import_time;
-    // int code_debug_ranges;
-    // int show_ref_count;
-    // int dump_refs;
-    // wchar_t *dump_refs_file;
-    // int malloc_stats;
-    // wchar_t *filesystem_encoding;
-    // wchar_t *filesystem_errors;
-    // wchar_t *pycache_prefix;
-    // int parse_argv;
-    // PyWideStringList orig_argv;
-    /// sys.argv
-    pub argv: Vec<String>,
-
-    // spell-checker:ignore Xfoo
-    /// -Xfoo[=bar]
-    pub xoptions: Vec<(String, Option<String>)>,
-
-    // spell-checker:ignore Wfoo
-    /// -Wfoo
-    pub warnoptions: Vec<String>,
-
-    /// -S
-    pub import_site: bool,
-
-    /// -b
-    pub bytes_warning: u64,
-
-    /// -X warn_default_encoding, PYTHONWARNDEFAULTENCODING
-    pub warn_default_encoding: bool,
-
-    /// -i
-    pub inspect: bool,
-
-    /// -i, with no script
-    pub interactive: bool,
-
-    // int optimization_level;
-    // int parser_debug;
-    /// -B
-    pub write_bytecode: bool,
-
-    /// verbosity level (-v switch)
-    pub verbose: u8,
-
-    /// -q
-    pub quiet: bool,
-
-    /// -s
-    pub user_site_directory: bool,
-
-    // int configure_c_stdio;
-    /// -u, PYTHONUNBUFFERED=x
-    pub buffered_stdio: bool,
-
-    // wchar_t *stdio_encoding;
-    pub utf8_mode: u8,
-    // wchar_t *stdio_errors;
-    /// --check-hash-based-pycs
-    pub check_hash_pycs_mode: CheckHashPycsMode,
-
-    // int use_frozen_modules;
-    /// -P
-    pub safe_path: bool,
-
-    /// -X int_max_str_digits
-    pub int_max_str_digits: i64,
-
-    // /* --- Path configuration inputs ------------ */
-    // int pathconfig_warnings;
-    // wchar_t *program_name;
-    /// Environment PYTHONPATH (and RUSTPYTHONPATH)
-    pub path_list: Vec<String>,
-
-    // wchar_t *home;
-    // wchar_t *platlibdir;
-    /// -d command line switch
-    pub debug: u8,
-
-    /// -O optimization switch counter
-    pub optimize: u8,
-
-    /// -E
-    pub ignore_environment: bool,
-
-    /// false for wasm. Not a command-line option
-    pub allow_external_library: bool,
-
-    #[cfg(feature = "flame-it")]
-    pub profile_output: Option<OsString>,
-    #[cfg(feature = "flame-it")]
-    pub profile_format: Option<String>,
-}
-
-#[derive(Debug, Default, Copy, Clone, strum_macros::Display, strum_macros::EnumString)]
-#[strum(serialize_all = "lowercase")]
-pub enum CheckHashPycsMode {
-    #[default]
-    Default,
-    Always,
-    Never,
-}
-
-impl Settings {
-    pub fn with_path(mut self, path: String) -> Self {
-        self.path_list.push(path);
-        self
-    }
-}
-
-/// Sensible default settings.
-impl Default for Settings {
-    fn default() -> Self {
-        Self {
-            debug: 0,
-            inspect: false,
-            interactive: false,
-            optimize: 0,
-            install_signal_handlers: true,
-            user_site_directory: true,
-            import_site: true,
-            ignore_environment: false,
-            verbose: 0,
-            quiet: false,
-            write_bytecode: true,
-            safe_path: false,
-            bytes_warning: 0,
-            xoptions: vec![],
-            isolated: false,
-            dev_mode: false,
-            warn_default_encoding: false,
-            warnoptions: vec![],
-            path_list: vec![],
-            argv: vec![],
-            hash_seed: None,
-            buffered_stdio: true,
-            check_hash_pycs_mode: CheckHashPycsMode::Default,
-            allow_external_library: cfg!(feature = "importlib"),
-            utf8_mode: 1,
-            int_max_str_digits: 4300,
-            #[cfg(feature = "flame-it")]
-            profile_output: None,
-            #[cfg(feature = "flame-it")]
-            profile_format: None,
-        }
-    }
-}
diff --git a/vm/src/vm/thread.rs b/vm/src/vm/thread.rs
deleted file mode 100644
index a5a0a7b63b..0000000000
--- a/vm/src/vm/thread.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use crate::{AsObject, PyObject, PyObjectRef, VirtualMachine};
-use itertools::Itertools;
-use std::{
-    cell::{Cell, RefCell},
-    ptr::NonNull,
-    thread_local,
-};
-
-thread_local! {
-    pub(super) static VM_STACK: RefCell<Vec<NonNull<VirtualMachine>>> = Vec::with_capacity(1).into();
-    static VM_CURRENT: RefCell<*const VirtualMachine> = std::ptr::null::<VirtualMachine>().into();
-
-    pub(crate) static COROUTINE_ORIGIN_TRACKING_DEPTH: Cell<u32> = const { Cell::new(0) };
-    pub(crate) static ASYNC_GEN_FINALIZER: RefCell<Option<PyObjectRef>> = const { RefCell::new(None) };
-    pub(crate) static ASYNC_GEN_FIRSTITER: RefCell<Option<PyObjectRef>> = const { RefCell::new(None) };
-}
-
-pub fn with_current_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {
-    VM_CURRENT.with(|x| unsafe {
-        f(x.clone()
-            .into_inner()
-            .as_ref()
-            .expect("call with_current_vm() but VM_CURRENT is null"))
-    })
-}
-
-pub fn enter_vm<R>(vm: &VirtualMachine, f: impl FnOnce() -> R) -> R {
-    VM_STACK.with(|vms| {
-        vms.borrow_mut().push(vm.into());
-        let prev = VM_CURRENT.with(|current| current.replace(vm));
-        let ret = std::panic::catch_unwind(std::panic::AssertUnwindSafe(f));
-        vms.borrow_mut().pop();
-        VM_CURRENT.with(|current| current.replace(prev));
-        ret.unwrap_or_else(|e| std::panic::resume_unwind(e))
-    })
-}
-
-pub fn with_vm<F, R>(obj: &PyObject, f: F) -> Option<R>
-where
-    F: Fn(&VirtualMachine) -> R,
-{
-    let vm_owns_obj = |interp: NonNull<VirtualMachine>| {
-        // SAFETY: all references in VM_STACK should be valid
-        let vm = unsafe { interp.as_ref() };
-        obj.fast_isinstance(vm.ctx.types.object_type)
-    };
-    VM_STACK.with(|vms| {
-        let interp = match vms.borrow().iter().copied().exactly_one() {
-            Ok(x) => {
-                debug_assert!(vm_owns_obj(x));
-                x
-            }
-            Err(mut others) => others.find(|x| vm_owns_obj(*x))?,
-        };
-        // SAFETY: all references in VM_STACK should be valid, and should not be changed or moved
-        // at least until this function returns and the stack unwinds to an enter_vm() call
-        let vm = unsafe { interp.as_ref() };
-        let prev = VM_CURRENT.with(|current| current.replace(vm));
-        let ret = f(vm);
-        VM_CURRENT.with(|current| current.replace(prev));
-        Some(ret)
-    })
-}
-
-#[must_use = "ThreadedVirtualMachine does nothing unless you move it to another thread and call .run()"]
-#[cfg(feature = "threading")]
-pub struct ThreadedVirtualMachine {
-    pub(super) vm: VirtualMachine,
-}
-
-#[cfg(feature = "threading")]
-impl ThreadedVirtualMachine {
-    /// Create a `FnOnce()` that can easily be passed to a function like [`std::thread::Builder::spawn`]
-    ///
-    /// # Note
-    ///
-    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't `join()`
-    /// on the thread this `FnOnce` runs in, there is a possibility that that thread will panic
-    /// as `PyObjectRef`'s `Drop` implementation tries to run the `__del__` destructor of a
-    /// Python object but finds that it's not in the context of any vm.
-    pub fn make_spawn_func<F, R>(self, f: F) -> impl FnOnce() -> R
-    where
-        F: FnOnce(&VirtualMachine) -> R,
-    {
-        move || self.run(f)
-    }
-
-    /// Run a function in this thread context
-    ///
-    /// # Note
-    ///
-    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't return the object
-    /// to the parent thread and then `join()` on the `JoinHandle` (or similar), there is a possibility that
-    /// the current thread will panic as `PyObjectRef`'s `Drop` implementation tries to run the `__del__`
-    /// destructor of a python object but finds that it's not in the context of any vm.
-    pub fn run<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&VirtualMachine) -> R,
-    {
-        let vm = &self.vm;
-        enter_vm(vm, || f(vm))
-    }
-}
-
-impl VirtualMachine {
-    /// Start a new thread with access to the same interpreter.
-    ///
-    /// # Note
-    ///
-    /// If you return a `PyObjectRef` (or a type that contains one) from `F`, and don't `join()`
-    /// on the thread, there is a possibility that that thread will panic as `PyObjectRef`'s `Drop`
-    /// implementation tries to run the `__del__` destructor of a python object but finds that it's
-    /// not in the context of any vm.
-    #[cfg(feature = "threading")]
-    pub fn start_thread<F, R>(&self, f: F) -> std::thread::JoinHandle<R>
-    where
-        F: FnOnce(&Self) -> R,
-        F: Send + 'static,
-        R: Send + 'static,
-    {
-        let func = self.new_thread().make_spawn_func(f);
-        std::thread::spawn(func)
-    }
-
-    /// Create a new VM thread that can be passed to a function like [`std::thread::spawn`]
-    /// to use the same interpreter on a different thread. Note that if you just want to
-    /// use this with `thread::spawn`, you can use
-    /// [`vm.start_thread()`](`VirtualMachine::start_thread`) as a convenience.
-    ///
-    /// # Usage
-    ///
-    /// ```
-    /// # rustpython_vm::Interpreter::without_stdlib(Default::default()).enter(|vm| {
-    /// use std::thread::Builder;
-    /// let handle = Builder::new()
-    ///     .name("my thread :)".into())
-    ///     .spawn(vm.new_thread().make_spawn_func(|vm| vm.ctx.none()))
-    ///     .expect("couldn't spawn thread");
-    /// let returned_obj = handle.join().expect("thread panicked");
-    /// assert!(vm.is_none(&returned_obj));
-    /// # })
-    /// ```
-    ///
-    /// Note: this function is safe, but running the returned ThreadedVirtualMachine in the same
-    /// thread context (i.e. with the same thread-local storage) doesn't have any
-    /// specific guaranteed behavior.
-    #[cfg(feature = "threading")]
-    pub fn new_thread(&self) -> ThreadedVirtualMachine {
-        let vm = Self {
-            builtins: self.builtins.clone(),
-            sys_module: self.sys_module.clone(),
-            ctx: self.ctx.clone(),
-            frames: RefCell::new(vec![]),
-            wasm_id: self.wasm_id.clone(),
-            exceptions: RefCell::default(),
-            import_func: self.import_func.clone(),
-            profile_func: RefCell::new(self.ctx.none()),
-            trace_func: RefCell::new(self.ctx.none()),
-            use_tracing: Cell::new(false),
-            recursion_limit: self.recursion_limit.clone(),
-            signal_handlers: None,
-            signal_rx: None,
-            repr_guards: RefCell::default(),
-            state: self.state.clone(),
-            initialized: self.initialized,
-            recursion_depth: Cell::new(0),
-        };
-        ThreadedVirtualMachine { vm }
-    }
-}
diff --git a/vm/src/windows.rs b/vm/src/windows.rs
deleted file mode 100644
index a14216768e..0000000000
--- a/vm/src/windows.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-use crate::common::fileutils::{
-    StatStruct,
-    windows::{FILE_INFO_BY_NAME_CLASS, get_file_information_by_name},
-};
-use crate::{
-    PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    convert::{ToPyObject, ToPyResult},
-    stdlib::os::errno_err,
-};
-use std::{ffi::OsStr, time::SystemTime};
-use windows::Win32::Foundation::HANDLE;
-use windows_sys::Win32::Foundation::{BOOL, HANDLE as RAW_HANDLE, INVALID_HANDLE_VALUE};
-
-pub(crate) trait WindowsSysResultValue {
-    type Ok: ToPyObject;
-    fn is_err(&self) -> bool;
-    fn into_ok(self) -> Self::Ok;
-}
-
-impl WindowsSysResultValue for RAW_HANDLE {
-    type Ok = HANDLE;
-    fn is_err(&self) -> bool {
-        *self == INVALID_HANDLE_VALUE
-    }
-    fn into_ok(self) -> Self::Ok {
-        HANDLE(self as _)
-    }
-}
-
-impl WindowsSysResultValue for BOOL {
-    type Ok = ();
-    fn is_err(&self) -> bool {
-        *self == 0
-    }
-    fn into_ok(self) -> Self::Ok {}
-}
-
-pub(crate) struct WindowsSysResult<T>(pub T);
-
-impl<T: WindowsSysResultValue> WindowsSysResult<T> {
-    pub fn is_err(&self) -> bool {
-        self.0.is_err()
-    }
-    pub fn into_pyresult(self, vm: &VirtualMachine) -> PyResult<T::Ok> {
-        if self.is_err() {
-            Err(errno_err(vm))
-        } else {
-            Ok(self.0.into_ok())
-        }
-    }
-}
-
-impl<T: WindowsSysResultValue> ToPyResult for WindowsSysResult<T> {
-    fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
-        let ok = self.into_pyresult(vm)?;
-        Ok(ok.to_pyobject(vm))
-    }
-}
-
-type HandleInt = usize; // TODO: change to isize when fully ported to windows-rs
-
-impl TryFromObject for HANDLE {
-    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
-        let handle = HandleInt::try_from_object(vm, obj)?;
-        Ok(HANDLE(handle as isize))
-    }
-}
-
-impl ToPyObject for HANDLE {
-    fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
-        (self.0 as HandleInt).to_pyobject(vm)
-    }
-}
-
-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 _ = windows_sys::Win32::Networking::WinSock::WSAStartup(0x0101, wsa_data.as_mut_ptr());
-    })
-}
-
-// win32_xstat in cpython
-pub fn win32_xstat(path: &OsStr, traverse: bool) -> std::io::Result<StatStruct> {
-    let mut result = win32_xstat_impl(path, traverse)?;
-    // ctime is only deprecated from 3.12, so we copy birthtime across
-    result.st_ctime = result.st_birthtime;
-    result.st_ctime_nsec = result.st_birthtime_nsec;
-    Ok(result)
-}
-
-fn is_reparse_tag_name_surrogate(tag: u32) -> bool {
-    (tag & 0x20000000) > 0
-}
-
-fn win32_xstat_impl(path: &OsStr, traverse: bool) -> std::io::Result<StatStruct> {
-    use windows_sys::Win32::{Foundation, Storage::FileSystem::FILE_ATTRIBUTE_REPARSE_POINT};
-
-    let stat_info =
-        get_file_information_by_name(path, FILE_INFO_BY_NAME_CLASS::FileStatBasicByNameInfo);
-    match stat_info {
-        Ok(stat_info) => {
-            if (stat_info.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT == 0)
-                || (!traverse && is_reparse_tag_name_surrogate(stat_info.ReparseTag))
-            {
-                let mut result =
-                    crate::common::fileutils::windows::stat_basic_info_to_stat(&stat_info);
-                result.update_st_mode_from_path(path, stat_info.FileAttributes);
-                return Ok(result);
-            }
-        }
-        Err(e) => {
-            if let Some(errno) = e.raw_os_error() {
-                if matches!(
-                    errno as u32,
-                    Foundation::ERROR_FILE_NOT_FOUND
-                        | Foundation::ERROR_PATH_NOT_FOUND
-                        | Foundation::ERROR_NOT_READY
-                        | Foundation::ERROR_BAD_NET_NAME
-                ) {
-                    return Err(e);
-                }
-            }
-        }
-    }
-
-    // TODO: check if win32_xstat_slow_impl(&path, result, traverse) is required
-    meta_to_stat(
-        &crate::stdlib::os::fs_metadata(path, traverse)?,
-        file_id(path)?,
-    )
-}
-
-// Ported from zed: https://github.com/zed-industries/zed/blob/v0.131.6/crates/fs/src/fs.rs#L1532-L1562
-// can we get file id not open the file twice?
-// https://github.com/rust-lang/rust/issues/63010
-fn file_id(path: &OsStr) -> std::io::Result<u64> {
-    use std::os::windows::{fs::OpenOptionsExt, io::AsRawHandle};
-    use windows_sys::Win32::{
-        Foundation::HANDLE,
-        Storage::FileSystem::{
-            BY_HANDLE_FILE_INFORMATION, FILE_FLAG_BACKUP_SEMANTICS, GetFileInformationByHandle,
-        },
-    };
-
-    let file = std::fs::OpenOptions::new()
-        .read(true)
-        .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)
-        .open(path)?;
-
-    let mut info: BY_HANDLE_FILE_INFORMATION = unsafe { std::mem::zeroed() };
-    // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfileinformationbyhandle
-    // This function supports Windows XP+
-    let ret = unsafe { GetFileInformationByHandle(file.as_raw_handle() as HANDLE, &mut info) };
-    if ret == 0 {
-        return Err(std::io::Error::last_os_error());
-    };
-
-    Ok(((info.nFileIndexHigh as u64) << 32) | (info.nFileIndexLow as u64))
-}
-
-fn meta_to_stat(meta: &std::fs::Metadata, file_id: u64) -> std::io::Result<StatStruct> {
-    let st_mode = {
-        // Based on CPython fileutils.c' attributes_to_mode
-        let mut m = 0;
-        if meta.is_dir() {
-            m |= libc::S_IFDIR | 0o111; /* IFEXEC for user,group,other */
-        } else {
-            m |= libc::S_IFREG;
-        }
-        if meta.is_symlink() {
-            m |= 0o100000;
-        }
-        if meta.permissions().readonly() {
-            m |= 0o444;
-        } else {
-            m |= 0o666;
-        }
-        m as _
-    };
-    let (atime, mtime, ctime) = (meta.accessed()?, meta.modified()?, meta.created()?);
-    let sec = |systime: SystemTime| match systime.duration_since(SystemTime::UNIX_EPOCH) {
-        Ok(d) => d.as_secs() as libc::time_t,
-        Err(e) => -(e.duration().as_secs() as libc::time_t),
-    };
-    let nsec = |systime: SystemTime| match systime.duration_since(SystemTime::UNIX_EPOCH) {
-        Ok(d) => d.subsec_nanos() as i32,
-        Err(e) => -(e.duration().subsec_nanos() as i32),
-    };
-    Ok(StatStruct {
-        st_dev: 0,
-        st_ino: file_id,
-        st_mode,
-        st_nlink: 0,
-        st_uid: 0,
-        st_gid: 0,
-        st_size: meta.len(),
-        st_atime: sec(atime),
-        st_mtime: sec(mtime),
-        st_birthtime: sec(ctime),
-        st_atime_nsec: nsec(atime),
-        st_mtime_nsec: nsec(mtime),
-        st_birthtime_nsec: nsec(ctime),
-        ..Default::default()
-    })
-}
diff --git a/vm/sre_engine/.vscode/launch.json b/vm/sre_engine/.vscode/launch.json
deleted file mode 100644
index 5ebfe34f05..0000000000
--- a/vm/sre_engine/.vscode/launch.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "lldb",
-            "request": "launch",
-            "name": "Debug Unit Test",
-            "cargo": {
-                "args": [
-                    "test",
-                    "--no-run"
-                ],
-                "filter": {
-                    "kind": "test"
-                }
-            },
-            "args": [],
-            "cwd": "${workspaceFolder}"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/vm/sre_engine/src/string.rs b/vm/sre_engine/src/string.rs
deleted file mode 100644
index 9ca97069f8..0000000000
--- a/vm/sre_engine/src/string.rs
+++ /dev/null
@@ -1,466 +0,0 @@
-use rustpython_wtf8::Wtf8;
-
-#[derive(Debug, Clone, Copy)]
-pub struct StringCursor {
-    pub(crate) ptr: *const u8,
-    pub position: usize,
-}
-
-impl Default for StringCursor {
-    fn default() -> Self {
-        Self {
-            ptr: std::ptr::null(),
-            position: 0,
-        }
-    }
-}
-
-pub trait StrDrive: Copy {
-    fn count(&self) -> usize;
-    fn create_cursor(&self, n: usize) -> StringCursor;
-    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize);
-    fn advance(cursor: &mut StringCursor) -> u32;
-    fn peek(cursor: &StringCursor) -> u32;
-    fn skip(cursor: &mut StringCursor, n: usize);
-    fn back_advance(cursor: &mut StringCursor) -> u32;
-    fn back_peek(cursor: &StringCursor) -> u32;
-    fn back_skip(cursor: &mut StringCursor, n: usize);
-}
-
-impl StrDrive for &[u8] {
-    #[inline]
-    fn count(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn create_cursor(&self, n: usize) -> StringCursor {
-        StringCursor {
-            ptr: self[n..].as_ptr(),
-            position: n,
-        }
-    }
-
-    #[inline]
-    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
-        cursor.position = n;
-        cursor.ptr = self[n..].as_ptr();
-    }
-
-    #[inline]
-    fn advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position += 1;
-        unsafe { cursor.ptr = cursor.ptr.add(1) };
-        unsafe { *cursor.ptr as u32 }
-    }
-
-    #[inline]
-    fn peek(cursor: &StringCursor) -> u32 {
-        unsafe { *cursor.ptr as u32 }
-    }
-
-    #[inline]
-    fn skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position += n;
-        unsafe { cursor.ptr = cursor.ptr.add(n) };
-    }
-
-    #[inline]
-    fn back_advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position -= 1;
-        unsafe { cursor.ptr = cursor.ptr.sub(1) };
-        unsafe { *cursor.ptr as u32 }
-    }
-
-    #[inline]
-    fn back_peek(cursor: &StringCursor) -> u32 {
-        unsafe { *cursor.ptr.offset(-1) as u32 }
-    }
-
-    #[inline]
-    fn back_skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position -= n;
-        unsafe { cursor.ptr = cursor.ptr.sub(n) };
-    }
-}
-
-impl StrDrive for &str {
-    #[inline]
-    fn count(&self) -> usize {
-        self.chars().count()
-    }
-
-    #[inline]
-    fn create_cursor(&self, n: usize) -> StringCursor {
-        let mut cursor = StringCursor {
-            ptr: self.as_ptr(),
-            position: 0,
-        };
-        Self::skip(&mut cursor, n);
-        cursor
-    }
-
-    #[inline]
-    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
-        if cursor.ptr.is_null() || cursor.position > n {
-            *cursor = Self::create_cursor(self, n);
-        } else if cursor.position < n {
-            Self::skip(cursor, n - cursor.position);
-        }
-    }
-
-    #[inline]
-    fn advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position += 1;
-        unsafe { next_code_point(&mut cursor.ptr) }
-    }
-
-    #[inline]
-    fn peek(cursor: &StringCursor) -> u32 {
-        let mut ptr = cursor.ptr;
-        unsafe { next_code_point(&mut ptr) }
-    }
-
-    #[inline]
-    fn skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position += n;
-        for _ in 0..n {
-            unsafe { next_code_point(&mut cursor.ptr) };
-        }
-    }
-
-    #[inline]
-    fn back_advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position -= 1;
-        unsafe { next_code_point_reverse(&mut cursor.ptr) }
-    }
-
-    #[inline]
-    fn back_peek(cursor: &StringCursor) -> u32 {
-        let mut ptr = cursor.ptr;
-        unsafe { next_code_point_reverse(&mut ptr) }
-    }
-
-    #[inline]
-    fn back_skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position -= n;
-        for _ in 0..n {
-            unsafe { next_code_point_reverse(&mut cursor.ptr) };
-        }
-    }
-}
-
-impl StrDrive for &Wtf8 {
-    #[inline]
-    fn count(&self) -> usize {
-        self.code_points().count()
-    }
-
-    #[inline]
-    fn create_cursor(&self, n: usize) -> StringCursor {
-        let mut cursor = StringCursor {
-            ptr: self.as_bytes().as_ptr(),
-            position: 0,
-        };
-        Self::skip(&mut cursor, n);
-        cursor
-    }
-
-    #[inline]
-    fn adjust_cursor(&self, cursor: &mut StringCursor, n: usize) {
-        if cursor.ptr.is_null() || cursor.position > n {
-            *cursor = Self::create_cursor(self, n);
-        } else if cursor.position < n {
-            Self::skip(cursor, n - cursor.position);
-        }
-    }
-
-    #[inline]
-    fn advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position += 1;
-        unsafe { next_code_point(&mut cursor.ptr) }
-    }
-
-    #[inline]
-    fn peek(cursor: &StringCursor) -> u32 {
-        let mut ptr = cursor.ptr;
-        unsafe { next_code_point(&mut ptr) }
-    }
-
-    #[inline]
-    fn skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position += n;
-        for _ in 0..n {
-            unsafe { next_code_point(&mut cursor.ptr) };
-        }
-    }
-
-    #[inline]
-    fn back_advance(cursor: &mut StringCursor) -> u32 {
-        cursor.position -= 1;
-        unsafe { next_code_point_reverse(&mut cursor.ptr) }
-    }
-
-    #[inline]
-    fn back_peek(cursor: &StringCursor) -> u32 {
-        let mut ptr = cursor.ptr;
-        unsafe { next_code_point_reverse(&mut ptr) }
-    }
-
-    #[inline]
-    fn back_skip(cursor: &mut StringCursor, n: usize) {
-        cursor.position -= n;
-        for _ in 0..n {
-            unsafe { next_code_point_reverse(&mut cursor.ptr) };
-        }
-    }
-}
-
-/// Reads the next code point out of a byte iterator (assuming a
-/// UTF-8-like encoding).
-///
-/// # Safety
-///
-/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
-#[inline]
-unsafe fn next_code_point(ptr: &mut *const u8) -> u32 {
-    // Decode UTF-8
-    let x = unsafe { **ptr };
-    *ptr = unsafe { ptr.offset(1) };
-
-    if x < 128 {
-        return x as u32;
-    }
-
-    // Multibyte case follows
-    // Decode from a byte combination out of: [[[x y] z] w]
-    // NOTE: Performance is sensitive to the exact formulation here
-    let init = utf8_first_byte(x, 2);
-    // SAFETY: `bytes` produces an UTF-8-like string,
-    // so the iterator must produce a value here.
-    let y = unsafe { **ptr };
-    *ptr = unsafe { ptr.offset(1) };
-    let mut ch = utf8_acc_cont_byte(init, y);
-    if x >= 0xE0 {
-        // [[x y z] w] case
-        // 5th bit in 0xE0 .. 0xEF is always clear, so `init` is still valid
-        // SAFETY: `bytes` produces an UTF-8-like string,
-        // so the iterator must produce a value here.
-        let z = unsafe { **ptr };
-        *ptr = unsafe { ptr.offset(1) };
-        let y_z = utf8_acc_cont_byte((y & CONT_MASK) as u32, z);
-        ch = (init << 12) | y_z;
-        if x >= 0xF0 {
-            // [x y z w] case
-            // use only the lower 3 bits of `init`
-            // SAFETY: `bytes` produces an UTF-8-like string,
-            // so the iterator must produce a value here.
-            let w = unsafe { **ptr };
-            *ptr = unsafe { ptr.offset(1) };
-            ch = ((init & 7) << 18) | utf8_acc_cont_byte(y_z, w);
-        }
-    }
-
-    ch
-}
-
-/// Reads the last code point out of a byte iterator (assuming a
-/// UTF-8-like encoding).
-///
-/// # Safety
-///
-/// `bytes` must produce a valid UTF-8-like (UTF-8 or WTF-8) string
-#[inline]
-unsafe fn next_code_point_reverse(ptr: &mut *const u8) -> u32 {
-    // Decode UTF-8
-    *ptr = unsafe { ptr.offset(-1) };
-    let w = match unsafe { **ptr } {
-        next_byte if next_byte < 128 => return next_byte as u32,
-        back_byte => back_byte,
-    };
-
-    // Multibyte case follows
-    // Decode from a byte combination out of: [x [y [z w]]]
-    let mut ch;
-    // SAFETY: `bytes` produces an UTF-8-like string,
-    // so the iterator must produce a value here.
-    *ptr = unsafe { ptr.offset(-1) };
-    let z = unsafe { **ptr };
-    ch = utf8_first_byte(z, 2);
-    if utf8_is_cont_byte(z) {
-        // SAFETY: `bytes` produces an UTF-8-like string,
-        // so the iterator must produce a value here.
-        *ptr = unsafe { ptr.offset(-1) };
-        let y = unsafe { **ptr };
-        ch = utf8_first_byte(y, 3);
-        if utf8_is_cont_byte(y) {
-            // SAFETY: `bytes` produces an UTF-8-like string,
-            // so the iterator must produce a value here.
-            *ptr = unsafe { ptr.offset(-1) };
-            let x = unsafe { **ptr };
-            ch = utf8_first_byte(x, 4);
-            ch = utf8_acc_cont_byte(ch, y);
-        }
-        ch = utf8_acc_cont_byte(ch, z);
-    }
-    ch = utf8_acc_cont_byte(ch, w);
-
-    ch
-}
-
-/// Returns the initial codepoint accumulator for the first byte.
-/// The first byte is special, only want bottom 5 bits for width 2, 4 bits
-/// for width 3, and 3 bits for width 4.
-#[inline]
-const fn utf8_first_byte(byte: u8, width: u32) -> u32 {
-    (byte & (0x7F >> width)) as u32
-}
-
-/// Returns the value of `ch` updated with continuation byte `byte`.
-#[inline]
-const fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 {
-    (ch << 6) | (byte & CONT_MASK) as u32
-}
-
-/// Checks whether the byte is a UTF-8 continuation byte (i.e., starts with the
-/// bits `10`).
-#[inline]
-const fn utf8_is_cont_byte(byte: u8) -> bool {
-    (byte as i8) < -64
-}
-
-/// Mask of the value bits of a continuation byte.
-const CONT_MASK: u8 = 0b0011_1111;
-
-const fn is_py_ascii_whitespace(b: u8) -> bool {
-    matches!(b, b'\t' | b'\n' | b'\x0C' | b'\r' | b' ' | b'\x0B')
-}
-
-#[inline]
-pub(crate) fn is_word(ch: u32) -> bool {
-    ch == '_' as u32
-        || u8::try_from(ch)
-            .map(|x| x.is_ascii_alphanumeric())
-            .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_space(ch: u32) -> bool {
-    u8::try_from(ch)
-        .map(is_py_ascii_whitespace)
-        .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_digit(ch: u32) -> bool {
-    u8::try_from(ch)
-        .map(|x| x.is_ascii_digit())
-        .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_loc_alnum(ch: u32) -> bool {
-    // FIXME: Ignore the locales
-    u8::try_from(ch)
-        .map(|x| x.is_ascii_alphanumeric())
-        .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_loc_word(ch: u32) -> bool {
-    ch == '_' as u32 || is_loc_alnum(ch)
-}
-#[inline]
-pub(crate) fn is_linebreak(ch: u32) -> bool {
-    ch == '\n' as u32
-}
-#[inline]
-pub fn lower_ascii(ch: u32) -> u32 {
-    u8::try_from(ch)
-        .map(|x| x.to_ascii_lowercase() as u32)
-        .unwrap_or(ch)
-}
-#[inline]
-pub(crate) fn lower_locate(ch: u32) -> u32 {
-    // FIXME: Ignore the locales
-    lower_ascii(ch)
-}
-#[inline]
-pub(crate) fn upper_locate(ch: u32) -> u32 {
-    // FIXME: Ignore the locales
-    u8::try_from(ch)
-        .map(|x| x.to_ascii_uppercase() as u32)
-        .unwrap_or(ch)
-}
-#[inline]
-pub(crate) fn is_uni_digit(ch: u32) -> bool {
-    // TODO: check with cpython
-    char::try_from(ch)
-        .map(|x| x.is_ascii_digit())
-        .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_uni_space(ch: u32) -> bool {
-    // TODO: check with cpython
-    is_space(ch)
-        || matches!(
-            ch,
-            0x0009
-                | 0x000A
-                | 0x000B
-                | 0x000C
-                | 0x000D
-                | 0x001C
-                | 0x001D
-                | 0x001E
-                | 0x001F
-                | 0x0020
-                | 0x0085
-                | 0x00A0
-                | 0x1680
-                | 0x2000
-                | 0x2001
-                | 0x2002
-                | 0x2003
-                | 0x2004
-                | 0x2005
-                | 0x2006
-                | 0x2007
-                | 0x2008
-                | 0x2009
-                | 0x200A
-                | 0x2028
-                | 0x2029
-                | 0x202F
-                | 0x205F
-                | 0x3000
-        )
-}
-#[inline]
-pub(crate) fn is_uni_linebreak(ch: u32) -> bool {
-    matches!(
-        ch,
-        0x000A | 0x000B | 0x000C | 0x000D | 0x001C | 0x001D | 0x001E | 0x0085 | 0x2028 | 0x2029
-    )
-}
-#[inline]
-pub(crate) fn is_uni_alnum(ch: u32) -> bool {
-    // TODO: check with cpython
-    char::try_from(ch)
-        .map(|x| x.is_alphanumeric())
-        .unwrap_or(false)
-}
-#[inline]
-pub(crate) fn is_uni_word(ch: u32) -> bool {
-    ch == '_' as u32 || is_uni_alnum(ch)
-}
-#[inline]
-pub fn lower_unicode(ch: u32) -> u32 {
-    // TODO: check with cpython
-    char::try_from(ch)
-        .map(|x| x.to_lowercase().next().unwrap() as u32)
-        .unwrap_or(ch)
-}
-#[inline]
-pub fn upper_unicode(ch: u32) -> u32 {
-    // TODO: check with cpython
-    char::try_from(ch)
-        .map(|x| x.to_uppercase().next().unwrap() as u32)
-        .unwrap_or(ch)
-}
diff --git a/wasm/demo/package-lock.json b/wasm/demo/package-lock.json
index ce1a1219c0..eb6957b3c5 100644
--- a/wasm/demo/package-lock.json
+++ b/wasm/demo/package-lock.json
@@ -21,7 +21,7 @@
                 "css-loader": "^7.1.2",
                 "html-webpack-plugin": "^5.6.3",
                 "mini-css-extract-plugin": "^2.9.2",
-                "serve": "^14.2.4",
+                "serve": "^14.2.5",
                 "webpack": "^5.97.1",
                 "webpack-cli": "^6.0.1",
                 "webpack-dev-server": "^5.2.1"
@@ -775,7 +775,8 @@
             "version": "5.5.0",
             "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-5.5.0.tgz",
             "integrity": "sha512-hqJHYaQb5OptNunnyAnkHyM8aCjZ1MEIDTQu1iIbbTD/xops91NB5yq1ZK/dC2JDbVWtF23zUtl9JE2NqwT87A==",
-            "license": "MIT"
+            "license": "MIT",
+            "peer": true
         },
         "node_modules/@xtuc/ieee754": {
             "version": "1.2.0",
@@ -831,6 +832,7 @@
             "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "fast-deep-equal": "^3.1.3",
                 "fast-uri": "^3.0.1",
@@ -1149,6 +1151,7 @@
                 }
             ],
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "caniuse-lite": "^1.0.30001688",
                 "electron-to-chromium": "^1.5.73",
@@ -1542,24 +1545,65 @@
             }
         },
         "node_modules/compression": {
-            "version": "1.7.4",
-            "resolved": "https://registry.npmjs.org/compression/-/compression-1.7.4.tgz",
-            "integrity": "sha512-jaSIDzP9pZVS4ZfQ+TzvtiWhdpFhE2RDHz8QJkpX9SIpLq88VueF5jJw6t+6CUQcAoA6t+x89MLrWAqpfDE8iQ==",
+            "version": "1.8.1",
+            "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz",
+            "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
-                "accepts": "~1.3.5",
-                "bytes": "3.0.0",
-                "compressible": "~2.0.16",
+                "bytes": "3.1.2",
+                "compressible": "~2.0.18",
                 "debug": "2.6.9",
-                "on-headers": "~1.0.2",
-                "safe-buffer": "5.1.2",
+                "negotiator": "~0.6.4",
+                "on-headers": "~1.1.0",
+                "safe-buffer": "5.2.1",
                 "vary": "~1.1.2"
             },
             "engines": {
                 "node": ">= 0.8.0"
             }
         },
+        "node_modules/compression/node_modules/bytes": {
+            "version": "3.1.2",
+            "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+            "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.8"
+            }
+        },
+        "node_modules/compression/node_modules/negotiator": {
+            "version": "0.6.4",
+            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz",
+            "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
+            "dev": true,
+            "license": "MIT",
+            "engines": {
+                "node": ">= 0.6"
+            }
+        },
+        "node_modules/compression/node_modules/safe-buffer": {
+            "version": "5.2.1",
+            "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+            "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+            "dev": true,
+            "funding": [
+                {
+                    "type": "github",
+                    "url": "https://github.com/sponsors/feross"
+                },
+                {
+                    "type": "patreon",
+                    "url": "https://www.patreon.com/feross"
+                },
+                {
+                    "type": "consulting",
+                    "url": "https://feross.org/support"
+                }
+            ],
+            "license": "MIT"
+        },
         "node_modules/concat-map": {
             "version": "0.0.1",
             "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
@@ -2161,40 +2205,40 @@
             }
         },
         "node_modules/express": {
-            "version": "4.21.2",
-            "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
-            "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+            "version": "4.22.1",
+            "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
+            "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
                 "accepts": "~1.3.8",
                 "array-flatten": "1.1.1",
-                "body-parser": "1.20.3",
-                "content-disposition": "0.5.4",
+                "body-parser": "~1.20.3",
+                "content-disposition": "~0.5.4",
                 "content-type": "~1.0.4",
-                "cookie": "0.7.1",
-                "cookie-signature": "1.0.6",
+                "cookie": "~0.7.1",
+                "cookie-signature": "~1.0.6",
                 "debug": "2.6.9",
                 "depd": "2.0.0",
                 "encodeurl": "~2.0.0",
                 "escape-html": "~1.0.3",
                 "etag": "~1.8.1",
-                "finalhandler": "1.3.1",
-                "fresh": "0.5.2",
-                "http-errors": "2.0.0",
+                "finalhandler": "~1.3.1",
+                "fresh": "~0.5.2",
+                "http-errors": "~2.0.0",
                 "merge-descriptors": "1.0.3",
                 "methods": "~1.1.2",
-                "on-finished": "2.4.1",
+                "on-finished": "~2.4.1",
                 "parseurl": "~1.3.3",
-                "path-to-regexp": "0.1.12",
+                "path-to-regexp": "~0.1.12",
                 "proxy-addr": "~2.0.7",
-                "qs": "6.13.0",
+                "qs": "~6.14.0",
                 "range-parser": "~1.2.1",
                 "safe-buffer": "5.2.1",
-                "send": "0.19.0",
-                "serve-static": "1.16.2",
+                "send": "~0.19.0",
+                "serve-static": "~1.16.2",
                 "setprototypeof": "1.2.0",
-                "statuses": "2.0.1",
+                "statuses": "~2.0.1",
                 "type-is": "~1.6.18",
                 "utils-merge": "1.0.1",
                 "vary": "~1.1.2"
@@ -2227,6 +2271,22 @@
             "dev": true,
             "license": "MIT"
         },
+        "node_modules/express/node_modules/qs": {
+            "version": "6.14.1",
+            "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz",
+            "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==",
+            "dev": true,
+            "license": "BSD-3-Clause",
+            "dependencies": {
+                "side-channel": "^1.1.0"
+            },
+            "engines": {
+                "node": ">=0.6"
+            },
+            "funding": {
+                "url": "https://github.com/sponsors/ljharb"
+            }
+        },
         "node_modules/express/node_modules/range-parser": {
             "version": "1.2.1",
             "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
@@ -3454,9 +3514,9 @@
             }
         },
         "node_modules/node-forge": {
-            "version": "1.3.1",
-            "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz",
-            "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==",
+            "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==",
             "dev": true,
             "license": "(BSD-3-Clause OR GPL-2.0)",
             "engines": {
@@ -3540,9 +3600,9 @@
             }
         },
         "node_modules/on-headers": {
-            "version": "1.0.2",
-            "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz",
-            "integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==",
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz",
+            "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==",
             "dev": true,
             "license": "MIT",
             "engines": {
@@ -3783,6 +3843,7 @@
                 }
             ],
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "nanoid": "^3.3.8",
                 "picocolors": "^1.1.1",
@@ -4310,9 +4371,9 @@
             }
         },
         "node_modules/serve": {
-            "version": "14.2.4",
-            "resolved": "https://registry.npmjs.org/serve/-/serve-14.2.4.tgz",
-            "integrity": "sha512-qy1S34PJ/fcY8gjVGszDB3EXiPSk5FKhUa7tQe0UPRddxRidc2V6cNHPNewbE1D7MAkgLuWEt3Vw56vYy73tzQ==",
+            "version": "14.2.5",
+            "resolved": "https://registry.npmjs.org/serve/-/serve-14.2.5.tgz",
+            "integrity": "sha512-Qn/qMkzCcMFVPb60E/hQy+iRLpiU8PamOfOSYoAHmmF+fFFmpPpqa6Oci2iWYpTdOUM3VF+TINud7CfbQnsZbA==",
             "dev": true,
             "license": "MIT",
             "dependencies": {
@@ -4323,7 +4384,7 @@
                 "chalk": "5.0.1",
                 "chalk-template": "0.4.0",
                 "clipboardy": "3.0.0",
-                "compression": "1.7.4",
+                "compression": "1.8.1",
                 "is-port-reachable": "4.0.0",
                 "serve-handler": "6.1.6",
                 "update-check": "1.5.4"
@@ -5041,7 +5102,8 @@
             "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
             "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
             "dev": true,
-            "license": "0BSD"
+            "license": "0BSD",
+            "peer": true
         },
         "node_modules/type-fest": {
             "version": "2.19.0",
@@ -5225,6 +5287,7 @@
             "integrity": "sha512-UFynvx+gM44Gv9qFgj0acCQK2VE1CtdfwFdimkapco3hlPCJ/zeq73n2yVKimVbtm+TnApIugGhLJnkU6gjYXA==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@types/eslint-scope": "^3.7.7",
                 "@types/estree": "^1.0.6",
@@ -5272,6 +5335,7 @@
             "integrity": "sha512-MfwFQ6SfwinsUVi0rNJm7rHZ31GyTcpVE5pgVA3hwFRb7COD4TzjUUwhGWKfO50+xdc2MQPuEBBJoqIMGt3JDw==",
             "dev": true,
             "license": "MIT",
+            "peer": true,
             "dependencies": {
                 "@discoveryjs/json-ext": "^0.6.1",
                 "@webpack-cli/configtest": "^3.0.1",
diff --git a/wasm/demo/package.json b/wasm/demo/package.json
index 22c82e1557..2c08e5c416 100644
--- a/wasm/demo/package.json
+++ b/wasm/demo/package.json
@@ -16,7 +16,7 @@
         "css-loader": "^7.1.2",
         "html-webpack-plugin": "^5.6.3",
         "mini-css-extract-plugin": "^2.9.2",
-        "serve": "^14.2.4",
+        "serve": "^14.2.5",
         "webpack": "^5.97.1",
         "webpack-cli": "^6.0.1",
         "webpack-dev-server": "^5.2.1"
diff --git a/wasm/demo/snippets/asyncbrowser.py b/wasm/demo/snippets/asyncbrowser.py
index d3a9dca85f..979c1d389d 100644
--- a/wasm/demo/snippets/asyncbrowser.py
+++ b/wasm/demo/snippets/asyncbrowser.py
@@ -1,5 +1,5 @@
-import browser
 import asyncweb
+import browser
 
 
 async def main(delay):
diff --git a/wasm/demo/snippets/import_pypi.py b/wasm/demo/snippets/import_pypi.py
index e3325d56f4..547fe2365e 100644
--- a/wasm/demo/snippets/import_pypi.py
+++ b/wasm/demo/snippets/import_pypi.py
@@ -2,7 +2,6 @@
 # available as os.path as well as a few other utilities, but will raise an
 # OSError for anything that actually requires an OS
 import _dummy_os
-
 import asyncweb
 import whlimport
 
@@ -13,8 +12,8 @@
 async def main():
     await whlimport.load_package("pygments")
     import pygments
-    import pygments.lexers
     import pygments.formatters.html
+    import pygments.lexers
 
     lexer = pygments.lexers.get_lexer_by_name("python")
     fmter = pygments.formatters.html.HtmlFormatter(noclasses=True, style="default")
diff --git a/wasm/demo/webpack.config.js b/wasm/demo/webpack.config.js
index 75fb6786e6..6c798d2ca4 100644
--- a/wasm/demo/webpack.config.js
+++ b/wasm/demo/webpack.config.js
@@ -18,7 +18,7 @@ module.exports = (env = {}) => {
             alias: {
                 rustpython: path.resolve(
                     __dirname,
-                    env.rustpythonPkg || '../lib/pkg',
+                    env.rustpythonPkg || '../../crates/wasm/pkg',
                 ),
             },
         },
@@ -65,7 +65,7 @@ module.exports = (env = {}) => {
     if (!env.noWasmPack) {
         config.plugins.push(
             new WasmPackPlugin({
-                crateDirectory: path.join(__dirname, '../lib'),
+                crateDirectory: path.join(__dirname, '../../crates/wasm'),
             }),
         );
     }
diff --git a/wasm/example/src/main.py b/wasm/example/src/main.py
index b5a1bda7c0..855b1e2ce4 100644
--- a/wasm/example/src/main.py
+++ b/wasm/example/src/main.py
@@ -1,4 +1,4 @@
-from browser import fetch, alert
+from browser import alert, fetch
 
 
 def fetch_handler(repos):
diff --git a/wasm/lib/.cargo/config.toml b/wasm/lib/.cargo/config.toml
deleted file mode 100644
index ce1e7c694a..0000000000
--- a/wasm/lib/.cargo/config.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-[build]
-target = "wasm32-unknown-unknown"
-
-[target.wasm32-unknown-unknown]
-rustflags = ["--cfg=getrandom_backend=\"wasm_js\""]
diff --git a/wasm/lib/Cargo.toml b/wasm/lib/Cargo.toml
deleted file mode 100644
index 768a1e671f..0000000000
--- a/wasm/lib/Cargo.toml
+++ /dev/null
@@ -1,50 +0,0 @@
-[package]
-name = "rustpython_wasm"
-description = "A Python-3 (CPython >= 3.5.0) Interpreter written in Rust, compiled to WASM"
-version.workspace = true
-authors.workspace = true
-edition.workspace = true
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[features]
-default = ["freeze-stdlib"]
-freeze-stdlib = ["rustpython-vm/freeze-stdlib", "rustpython-pylib/freeze-stdlib", "rustpython-stdlib"]
-no-start-func = []
-
-[dependencies]
-rustpython-common = { workspace = true }
-rustpython-pylib = { workspace = true, optional = true }
-rustpython-stdlib = { workspace = true, default-features = false, optional = true }
-# 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 }
-
-console_error_panic_hook = "0.1"
-js-sys = "0.3"
-serde-wasm-bindgen = "0.3.1"
-wasm-bindgen-futures = "0.4"
-web-sys = { version = "0.3", features = [
-    "console",
-    "Document",
-    "Element",
-    "Window",
-    "Headers",
-    "Request",
-    "RequestInit",
-    "Response"
-] }
-
-[package.metadata.wasm-pack.profile.release]
-wasm-opt = false#["-O1"]
-
-[lints]
-workspace = true
diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs
deleted file mode 100644
index 9d83f70ceb..0000000000
--- a/wasm/lib/src/convert.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-#![allow(clippy::empty_docs)] // TODO: remove it later. false positive by wasm-bindgen generated code
-
-use crate::js_module;
-use crate::vm_class::{WASMVirtualMachine, stored_vm_from_wasm};
-use js_sys::{Array, ArrayBuffer, Object, Promise, Reflect, SyntaxError, Uint8Array};
-use rustpython_vm::{
-    AsObject, PyObjectRef, PyPayload, PyResult, TryFromBorrowedObject, VirtualMachine,
-    builtins::PyBaseExceptionRef,
-    compiler::{CompileError, ParseError, parser::LexicalErrorType, parser::ParseErrorType},
-    exceptions,
-    function::{ArgBytesLike, FuncArgs},
-    py_serde,
-};
-use wasm_bindgen::{JsCast, closure::Closure, prelude::*};
-
-#[wasm_bindgen(inline_js = r"
-export class PyError extends Error {
-    constructor(info) {
-        const msg = info.args[0];
-        if (typeof msg === 'string') super(msg);
-        else super();
-        this.info = info;
-    }
-    get name() { return this.info.exc_type; }
-    get traceback() { return this.info.traceback; }
-    toString() { return this.info.rendered; }
-}
-")]
-extern "C" {
-    pub type PyError;
-    #[wasm_bindgen(constructor)]
-    fn new(info: JsValue) -> PyError;
-}
-
-pub fn py_err_to_js_err(vm: &VirtualMachine, py_err: &PyBaseExceptionRef) -> JsValue {
-    let js_err = vm.try_class("_js", "JSError").ok();
-    let js_arg = if js_err.is_some_and(|js_err| py_err.fast_isinstance(&js_err)) {
-        py_err.get_arg(0)
-    } else {
-        None
-    };
-    let js_arg = js_arg
-        .as_ref()
-        .and_then(|x| x.payload::<js_module::PyJsValue>());
-    match js_arg {
-        Some(val) => val.value.clone(),
-        None => {
-            let res =
-                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(),
-            }
-        }
-    }
-}
-
-pub fn js_py_typeerror(vm: &VirtualMachine, js_err: JsValue) -> PyBaseExceptionRef {
-    let msg = js_err.unchecked_into::<js_sys::Error>().to_string();
-    vm.new_type_error(msg)
-}
-
-pub fn js_err_to_py_err(vm: &VirtualMachine, js_err: &JsValue) -> PyBaseExceptionRef {
-    match js_err.dyn_ref::<js_sys::Error>() {
-        Some(err) => {
-            let exc_type = match String::from(err.name()).as_str() {
-                "TypeError" => vm.ctx.exceptions.type_error,
-                "ReferenceError" => vm.ctx.exceptions.name_error,
-                "SyntaxError" => vm.ctx.exceptions.syntax_error,
-                _ => vm.ctx.exceptions.exception_type,
-            }
-            .to_owned();
-            vm.new_exception_msg(exc_type, err.message().into())
-        }
-        None => vm.new_exception_msg(
-            vm.ctx.exceptions.exception_type.to_owned(),
-            format!("{js_err:?}"),
-        ),
-    }
-}
-
-pub fn py_to_js(vm: &VirtualMachine, py_obj: PyObjectRef) -> JsValue {
-    if let Some(ref wasm_id) = vm.wasm_id {
-        if py_obj.fast_isinstance(vm.ctx.types.function_type) {
-            let wasm_vm = WASMVirtualMachine {
-                id: wasm_id.clone(),
-            };
-            let weak_py_obj = wasm_vm.push_held_rc(py_obj).unwrap().unwrap();
-
-            let closure = move |args: Option<Box<[JsValue]>>,
-                                kwargs: Option<Object>|
-                  -> Result<JsValue, JsValue> {
-                let py_obj = match wasm_vm.assert_valid() {
-                    Ok(_) => weak_py_obj
-                        .upgrade()
-                        .expect("weak_py_obj to be valid if VM is valid"),
-                    Err(err) => {
-                        return Err(err);
-                    }
-                };
-                stored_vm_from_wasm(&wasm_vm).interp.enter(move |vm| {
-                    let args = match args {
-                        Some(args) => Vec::from(args)
-                            .into_iter()
-                            .map(|arg| js_to_py(vm, arg))
-                            .collect::<Vec<_>>(),
-                        None => Vec::new(),
-                    };
-                    let mut py_func_args = FuncArgs::from(args);
-                    if let Some(ref kwargs) = kwargs {
-                        for pair in object_entries(kwargs) {
-                            let (key, val) = pair?;
-                            py_func_args
-                                .kwargs
-                                .insert(js_sys::JsString::from(key).into(), js_to_py(vm, val));
-                        }
-                    }
-                    let result = py_obj.call(py_func_args, vm);
-                    pyresult_to_js_result(vm, result)
-                })
-            };
-            let closure = Closure::wrap(Box::new(closure)
-                as Box<
-                    dyn FnMut(Option<Box<[JsValue]>>, Option<Object>) -> Result<JsValue, JsValue>,
-                >);
-            let func = closure.as_ref().clone();
-
-            // stores pretty much nothing, it's fine to leak this because if it gets dropped
-            // the error message is worse
-            closure.forget();
-
-            return func;
-        }
-    }
-    // the browser module might not be injected
-    if vm.try_class("_js", "Promise").is_ok() {
-        if let Some(py_prom) = py_obj.payload::<js_module::PyPromise>() {
-            return py_prom.as_js(vm).into();
-        }
-    }
-
-    if let Ok(bytes) = ArgBytesLike::try_from_borrowed_object(vm, &py_obj) {
-        bytes.with_ref(|bytes| unsafe {
-            // `Uint8Array::view` is an `unsafe fn` because it provides
-            // a direct view into the WASM linear memory; if you were to allocate
-            // something with Rust that view would probably become invalid. It's safe
-            // because we then copy the array using `Uint8Array::slice`.
-            let view = Uint8Array::view(bytes);
-            view.slice(0, bytes.len() as u32).into()
-        })
-    } else {
-        py_serde::serialize(vm, &py_obj, &serde_wasm_bindgen::Serializer::new())
-            .unwrap_or(JsValue::UNDEFINED)
-    }
-}
-
-pub fn object_entries(obj: &Object) -> impl Iterator<Item = Result<(JsValue, JsValue), JsValue>> {
-    Object::entries(obj).values().into_iter().map(|pair| {
-        pair.map(|pair| {
-            let key = Reflect::get(&pair, &"0".into()).unwrap();
-            let val = Reflect::get(&pair, &"1".into()).unwrap();
-            (key, val)
-        })
-    })
-}
-
-pub fn pyresult_to_js_result(vm: &VirtualMachine, result: PyResult) -> Result<JsValue, JsValue> {
-    result
-        .map(|value| py_to_js(vm, value))
-        .map_err(|err| py_err_to_js_err(vm, &err))
-}
-
-pub fn js_to_py(vm: &VirtualMachine, js_val: JsValue) -> PyObjectRef {
-    if js_val.is_object() {
-        if let Some(promise) = js_val.dyn_ref::<Promise>() {
-            // the browser module might not be injected
-            if vm.try_class("browser", "Promise").is_ok() {
-                return js_module::PyPromise::new(promise.clone())
-                    .into_ref(&vm.ctx)
-                    .into();
-            }
-        }
-        if Array::is_array(&js_val) {
-            let js_arr: Array = js_val.into();
-            let elems = js_arr
-                .values()
-                .into_iter()
-                .map(|val| js_to_py(vm, val.expect("Iteration over array failed")))
-                .collect();
-            vm.ctx.new_list(elems).into()
-        } else if ArrayBuffer::is_view(&js_val) || js_val.is_instance_of::<ArrayBuffer>() {
-            // unchecked_ref because if it's not an ArrayBuffer it could either be a TypedArray
-            // or a DataView, but they all have a `buffer` property
-            let u8_array = js_sys::Uint8Array::new(
-                &js_val
-                    .dyn_ref::<ArrayBuffer>()
-                    .cloned()
-                    .unwrap_or_else(|| js_val.unchecked_ref::<Uint8Array>().buffer()),
-            );
-            let mut vec = vec![0; u8_array.length() as usize];
-            u8_array.copy_to(&mut vec);
-            vm.ctx.new_bytes(vec).into()
-        } else {
-            let dict = vm.ctx.new_dict();
-            for pair in object_entries(&Object::from(js_val)) {
-                let (key, val) = pair.expect("iteration over object to not fail");
-                let py_val = js_to_py(vm, val);
-                dict.set_item(
-                    String::from(js_sys::JsString::from(key)).as_str(),
-                    py_val,
-                    vm,
-                )
-                .unwrap();
-            }
-            dict.into()
-        }
-    } else if js_val.is_function() {
-        let func = js_sys::Function::from(js_val);
-        vm.new_function(
-            vm.ctx.intern_str(String::from(func.name())).as_str(),
-            move |args: FuncArgs, vm: &VirtualMachine| -> PyResult {
-                let this = Object::new();
-                for (k, v) in args.kwargs {
-                    Reflect::set(&this, &k.into(), &py_to_js(vm, v))
-                        .expect("property to be settable");
-                }
-                let js_args = args
-                    .args
-                    .into_iter()
-                    .map(|v| py_to_js(vm, v))
-                    .collect::<Array>();
-                func.apply(&this, &js_args)
-                    .map(|val| js_to_py(vm, val))
-                    .map_err(|err| js_err_to_py_err(vm, &err))
-            },
-        )
-        .into()
-    } else if let Some(err) = js_val.dyn_ref::<js_sys::Error>() {
-        js_err_to_py_err(vm, err).into()
-    } else if js_val.is_undefined() {
-        // Because `JSON.stringify(undefined)` returns undefined
-        vm.ctx.none()
-    } else {
-        py_serde::deserialize(vm, serde_wasm_bindgen::Deserializer::from(js_val))
-            .unwrap_or_else(|_| vm.ctx.none())
-    }
-}
-
-pub fn syntax_err(err: CompileError) -> SyntaxError {
-    let js_err = SyntaxError::new(&format!("Error parsing Python code: {err}"));
-    let _ = Reflect::set(
-        &js_err,
-        &"row".into(),
-        &(err.location().unwrap().row.get()).into(),
-    );
-    let _ = Reflect::set(
-        &js_err,
-        &"col".into(),
-        &(err.location().unwrap().column.get()).into(),
-    );
-    // | ParseErrorType::UnrecognizedToken(Token::Dedent, _)
-    let can_continue = matches!(
-        &err,
-        CompileError::Parse(ParseError {
-            error: ParseErrorType::Lexical(LexicalErrorType::Eof)
-                | ParseErrorType::Lexical(LexicalErrorType::IndentationError),
-            ..
-        })
-    );
-    let _ = Reflect::set(&js_err, &"canContinue".into(), &can_continue.into());
-    js_err
-}
-
-pub trait PyResultExt<T> {
-    fn into_js(self, vm: &VirtualMachine) -> Result<T, JsValue>;
-}
-impl<T> PyResultExt<T> for PyResult<T> {
-    fn into_js(self, vm: &VirtualMachine) -> Result<T, JsValue> {
-        self.map_err(|err| py_err_to_js_err(vm, &err))
-    }
-}
diff --git a/wasm/lib/src/lib.rs b/wasm/lib/src/lib.rs
deleted file mode 100644
index 8d1d19ddae..0000000000
--- a/wasm/lib/src/lib.rs
+++ /dev/null
@@ -1,135 +0,0 @@
-pub mod browser_module;
-pub mod convert;
-pub mod js_module;
-pub mod vm_class;
-pub mod wasm_builtins;
-
-#[macro_use]
-extern crate rustpython_vm;
-
-use js_sys::{Reflect, WebAssembly::RuntimeError};
-use std::panic;
-pub use vm_class::add_init_func;
-pub(crate) use vm_class::weak_vm;
-use wasm_bindgen::prelude::*;
-
-/// Sets error info on the window object, and prints the backtrace to console
-pub fn panic_hook(info: &panic::PanicHookInfo<'_>) {
-    // If something errors, just ignore it; we don't want to panic in the panic hook
-    let try_set_info = || {
-        let msg = &info.to_string();
-        let window = match web_sys::window() {
-            Some(win) => win,
-            None => return,
-        };
-        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR_MSG".into(), &msg.into());
-        let error = RuntimeError::new(msg);
-        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR".into(), &error);
-        let stack = match Reflect::get(&error, &"stack".into()) {
-            Ok(stack) => stack,
-            Err(_) => return,
-        };
-        let _ = Reflect::set(&window, &"__RUSTPYTHON_ERROR_STACK".into(), &stack);
-    };
-    try_set_info();
-    console_error_panic_hook::hook(info);
-}
-
-#[doc(hidden)]
-#[cfg(not(feature = "no-start-func"))]
-#[wasm_bindgen(start)]
-pub fn _setup_console_error() {
-    std::panic::set_hook(Box::new(panic_hook));
-}
-
-pub mod eval {
-    use crate::vm_class::VMStore;
-    use js_sys::{Object, Reflect, TypeError};
-    use rustpython_vm::compiler::Mode;
-    use wasm_bindgen::prelude::*;
-
-    const PY_EVAL_VM_ID: &str = "__py_eval_vm";
-
-    fn run_py(source: &str, options: Option<Object>, mode: Mode) -> Result<JsValue, JsValue> {
-        let vm = VMStore::init(PY_EVAL_VM_ID.into(), Some(true));
-        let options = options.unwrap_or_default();
-        let js_vars = {
-            let prop = Reflect::get(&options, &"vars".into())?;
-            if prop.is_undefined() {
-                None
-            } else if prop.is_object() {
-                Some(Object::from(prop))
-            } else {
-                return Err(TypeError::new("vars must be an object").into());
-            }
-        };
-
-        vm.set_stdout(Reflect::get(&options, &"stdout".into())?)?;
-
-        if let Some(js_vars) = js_vars {
-            vm.add_to_scope("js_vars".into(), js_vars.into())?;
-        }
-        vm.run(source, mode, None)
-    }
-
-    /// Evaluate Python code
-    ///
-    /// ```js
-    /// var result = pyEval(code, options?);
-    /// ```
-    ///
-    /// `code`: `string`: The Python code to run in eval mode
-    ///
-    /// `options`:
-    ///
-    /// -   `vars?`: `{ [key: string]: any }`: Variables passed to the VM that can be
-    ///     accessed in Python with the variable `js_vars`. Functions do work, and
-    ///     receive the Python kwargs as the `this` argument.
-    /// -   `stdout?`: `"console" | ((out: string) => void) | null`: A function to replace the
-    ///     native print native print function, and it will be `console.log` when giving
-    ///     `undefined` or "console", and it will be a dumb function when giving null.
-    #[wasm_bindgen(js_name = pyEval)]
-    pub fn eval_py(source: &str, options: Option<Object>) -> Result<JsValue, JsValue> {
-        run_py(source, options, Mode::Eval)
-    }
-
-    /// Evaluate Python code
-    ///
-    /// ```js
-    /// pyExec(code, options?);
-    /// ```
-    ///
-    /// `code`: `string`: The Python code to run in exec mode
-    ///
-    /// `options`: The options are the same as eval mode
-    #[wasm_bindgen(js_name = pyExec)]
-    pub fn exec_py(source: &str, options: Option<Object>) -> Result<(), JsValue> {
-        run_py(source, options, Mode::Exec).map(drop)
-    }
-
-    /// Evaluate Python code
-    ///
-    /// ```js
-    /// var result = pyExecSingle(code, options?);
-    /// ```
-    ///
-    /// `code`: `string`: The Python code to run in exec single mode
-    ///
-    /// `options`: The options are the same as eval mode
-    #[wasm_bindgen(js_name = pyExecSingle)]
-    pub fn exec_single_py(source: &str, options: Option<Object>) -> Result<JsValue, JsValue> {
-        run_py(source, options, Mode::Single)
-    }
-}
-
-/// A module containing all the wasm-bindgen exports that rustpython_wasm has
-/// Re-export as `pub use rustpython_wasm::exports::*;` in the root of your crate if you want your
-/// wasm module to mimic rustpython_wasm's API
-pub mod exports {
-    pub use crate::convert::PyError;
-    pub use crate::eval::{eval_py, exec_py, exec_single_py};
-    pub use crate::vm_class::{VMStore, WASMVirtualMachine};
-}
-
-#[doc(hidden)]
-pub use exports::*;
diff --git a/wasm/notebook/webpack.config.js b/wasm/notebook/webpack.config.js
index ca19f3384a..a3e3f8ef71 100644
--- a/wasm/notebook/webpack.config.js
+++ b/wasm/notebook/webpack.config.js
@@ -18,7 +18,7 @@ module.exports = (env = {}) => {
             alias: {
                 rustpython: path.resolve(
                     __dirname,
-                    env.rustpythonPkg || '../lib/pkg',
+                    env.rustpythonPkg || '../../crates/wasm/pkg',
                 ),
             },
         },
diff --git a/wasm/tests/conftest.py b/wasm/tests/conftest.py
index 84a2530575..c7555c9958 100644
--- a/wasm/tests/conftest.py
+++ b/wasm/tests/conftest.py
@@ -1,10 +1,11 @@
-import subprocess
+import atexit
 import os
-import time
 import socket
-import atexit
-import pytest
+import subprocess
 import sys
+import time
+
+import pytest
 
 PORT = 8080
 
@@ -41,7 +42,7 @@ def pytest_sessionfinish(session):
 
 
 # From https://gist.github.com/butla/2d9a4c0f35ea47b7452156c96a4e7b12
-def wait_for_port(port, host="0.0.0.0", timeout=5.0):
+def wait_for_port(port, host="localhost", timeout=5.0):
     """Wait until a port starts accepting TCP connections.
     Args:
         port (int): Port number.
@@ -65,11 +66,11 @@ def wait_for_port(port, host="0.0.0.0", timeout=5.0):
 
 
 from selenium import webdriver
-from selenium.webdriver.firefox.options import Options
+from selenium.common.exceptions import JavascriptException
 from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.firefox.options import Options
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.common.exceptions import JavascriptException
+from selenium.webdriver.support.ui import WebDriverWait
 
 
 class Driver(webdriver.Firefox):
@@ -94,7 +95,7 @@ def wdriver(request):
     options.add_argument("-headless")
     driver = Driver(options=options)
     try:
-        driver.get(f"http://0.0.0.0:{PORT}")
+        driver.get(f"http://localhost:{PORT}")
         WebDriverWait(driver, 5).until(
             EC.presence_of_element_located((By.ID, "rp_loaded"))
         )
diff --git a/wasm/tests/requirements.txt b/wasm/tests/requirements.txt
index 52dc203912..a474c5f74b 100644
--- a/wasm/tests/requirements.txt
+++ b/wasm/tests/requirements.txt
@@ -1,3 +1,3 @@
 pytest
-selenium
+selenium==4.36.0
 certifi
diff --git a/wasm/wasm-unknown-test/Cargo.toml b/wasm/wasm-unknown-test/Cargo.toml
deleted file mode 100644
index 5945f69006..0000000000
--- a/wasm/wasm-unknown-test/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "wasm-unknown-test"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-getrandom = "0.3"
-rustpython-vm = { path = "../../vm", default-features = false, features = ["compiler"] }
-
-[workspace]
-
-[patch.crates-io]
-radium = { version = "1.1.0", git = "https://github.com/youknowone/ferrilab", branch = "fix-nightly" }
diff --git a/wasm/wasm-unknown-test/src/lib.rs b/wasm/wasm-unknown-test/src/lib.rs
deleted file mode 100644
index a3beead890..0000000000
--- a/wasm/wasm-unknown-test/src/lib.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use rustpython_vm::{Interpreter, eval};
-
-pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> u32 {
-    let src = std::slice::from_raw_parts(s, l);
-    let src = std::str::from_utf8(src).unwrap();
-    Interpreter::without_stdlib(Default::default()).enter(|vm| {
-        let res = eval::eval(vm, src, vm.new_scope_with_builtins(), "<string>").unwrap();
-        res.try_into_value(vm).unwrap()
-    })
-}
-
-#[unsafe(no_mangle)]
-unsafe extern "Rust" fn __getrandom_v03_custom(
-    _dest: *mut u8,
-    _len: usize,
-) -> Result<(), getrandom::Error> {
-    Err(getrandom::Error::UNSUPPORTED)
-}
diff --git a/whats_left.py b/whats_left.py
index c79bfb146a..c5b0be6ead 100755
--- a/whats_left.py
+++ b/whats_left.py
@@ -17,15 +17,14 @@
 # We then run this second generated script with RustPython.
 
 import argparse
-import re
+import inspect
+import json
 import os
+import platform
 import re
+import subprocess
 import sys
-import json
 import warnings
-import inspect
-import subprocess
-import platform
 from pydoc import ModuleScanner
 
 if not sys.flags.isolated:
@@ -327,13 +326,13 @@ def gen_modules():
 def compare():
     import inspect
     import io
+    import json
     import os
+    import platform
     import re
     import sys
     import warnings
     from contextlib import redirect_stdout
-    import json
-    import platform
 
     def method_incompatibility_reason(typ, method_name, real_method_value):
         has_method = hasattr(typ, method_name)
@@ -362,7 +361,9 @@ def method_incompatibility_reason(typ, method_name, real_method_value):
 
     if platform.python_implementation() == "CPython":
         if not_implementeds:
-            sys.exit("ERROR: CPython should have all the methods")
+            sys.exit(
+                f"ERROR: CPython should have all the methods but missing: {not_implementeds}"
+            )
 
     mod_names = [
         name.decode()
@@ -456,6 +457,7 @@ def remove_one_indent(s):
 )
 # The last line should be json output, the rest of the lines can contain noise
 # because importing certain modules can print stuff to stdout/stderr
+print(result.stderr, file=sys.stderr)
 result = json.loads(result.stdout.splitlines()[-1])
 
 if args.json: